?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
spi-topcliff-pch: add recovery processing in case wait-event timeout
[zen-stable.git] / drivers / pci / hotplug / ibmphp_res.c
blobe2dc289f767ccfb4ac3096f6148bc1db3ee61d8f
1 /*
2 * IBM Hot Plug Controller Driver
3 *
4 * Written By: Irene Zubarev, IBM Corporation
5 *
6 * Copyright (C) 2001 Greg Kroah-Hartman (greg@kroah.com)
7 * Copyright (C) 2001,2002 IBM Corp.
8 *
9 * All rights reserved.
10 *
11 * This program is free software; you can redistribute it and/or modify
12 * it under the terms of the GNU General Public License as published by
13 * the Free Software Foundation; either version 2 of the License, or (at
14 * your option) any later version.
15 *
16 * This program is distributed in the hope that it will be useful, but
17 * WITHOUT ANY WARRANTY; without even the implied warranty of
18 * MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE, GOOD TITLE or
19 * NON INFRINGEMENT. See the GNU General Public License for more
20 * details.
21 *
22 * You should have received a copy of the GNU General Public License
23 * along with this program; if not, write to the Free Software
24 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
25 *
26 * Send feedback to <gregkh@us.ibm.com>
27 *
28 */
29
30 #include <linux/module.h>
31 #include <linux/slab.h>
32 #include <linux/pci.h>
33 #include <linux/list.h>
34 #include <linux/init.h>
35 #include "ibmphp.h"
36
37 static int flags = 0; /* for testing */
38
39 static void update_resources (struct bus_node *bus_cur, int type, int rangeno);
40 static int once_over (void);
41 static int remove_ranges (struct bus_node *, struct bus_node *);
42 static int update_bridge_ranges (struct bus_node **);
43 static int add_bus_range (int type, struct range_node *, struct bus_node *);
44 static void fix_resources (struct bus_node *);
45 static struct bus_node *find_bus_wprev (u8, struct bus_node **, u8);
46
47 static LIST_HEAD(gbuses);
48
49 static struct bus_node * __init alloc_error_bus (struct ebda_pci_rsrc * curr, u8 busno, int flag)
50 {
51 struct bus_node * newbus;
52
53 if (!(curr) && !(flag)) {
54 err ("NULL pointer passed\n");
55 return NULL;
56 }
57
58 newbus = kzalloc(sizeof(struct bus_node), GFP_KERNEL);
59 if (!newbus) {
60 err ("out of system memory\n");
61 return NULL;
62 }
63
64 if (flag)
65 newbus->busno = busno;
66 else
67 newbus->busno = curr->bus_num;
68 list_add_tail (&newbus->bus_list, &gbuses);
69 return newbus;
70 }
71
72 static struct resource_node * __init alloc_resources (struct ebda_pci_rsrc * curr)
73 {
74 struct resource_node *rs;
75
76 if (!curr) {
77 err ("NULL passed to allocate\n");
78 return NULL;
79 }
80
81 rs = kzalloc(sizeof(struct resource_node), GFP_KERNEL);
82 if (!rs) {
83 err ("out of system memory\n");
84 return NULL;
85 }
86 rs->busno = curr->bus_num;
87 rs->devfunc = curr->dev_fun;
88 rs->start = curr->start_addr;
89 rs->end = curr->end_addr;
90 rs->len = curr->end_addr - curr->start_addr + 1;
91 return rs;
92 }
93
94 static int __init alloc_bus_range (struct bus_node **new_bus, struct range_node **new_range, struct ebda_pci_rsrc *curr, int flag, u8 first_bus)
95 {
96 struct bus_node * newbus;
97 struct range_node *newrange;
98 u8 num_ranges = 0;
99
100 if (first_bus) {
101 newbus = kzalloc(sizeof(struct bus_node), GFP_KERNEL);
102 if (!newbus) {
103 err ("out of system memory.\n");
104 return -ENOMEM;
105 }
106 newbus->busno = curr->bus_num;
107 } else {
108 newbus = *new_bus;
109 switch (flag) {
110 case MEM:
111 num_ranges = newbus->noMemRanges;
112 break;
113 case PFMEM:
114 num_ranges = newbus->noPFMemRanges;
115 break;
116 case IO:
117 num_ranges = newbus->noIORanges;
118 break;
119 }
120 }
121
122 newrange = kzalloc(sizeof(struct range_node), GFP_KERNEL);
123 if (!newrange) {
124 if (first_bus)
125 kfree (newbus);
126 err ("out of system memory\n");
127 return -ENOMEM;
128 }
129 newrange->start = curr->start_addr;
130 newrange->end = curr->end_addr;
131
132 if (first_bus || (!num_ranges))
133 newrange->rangeno = 1;
134 else {
135 /* need to insert our range */
136 add_bus_range (flag, newrange, newbus);
137 debug ("%d resource Primary Bus inserted on bus %x [%x - %x]\n", flag, newbus->busno, newrange->start, newrange->end);
138 }
139
140 switch (flag) {
141 case MEM:
142 newbus->rangeMem = newrange;
143 if (first_bus)
144 newbus->noMemRanges = 1;
145 else {
146 debug ("First Memory Primary on bus %x, [%x - %x]\n", newbus->busno, newrange->start, newrange->end);
147 ++newbus->noMemRanges;
148 fix_resources (newbus);
149 }
150 break;
151 case IO:
152 newbus->rangeIO = newrange;
153 if (first_bus)
154 newbus->noIORanges = 1;
155 else {
156 debug ("First IO Primary on bus %x, [%x - %x]\n", newbus->busno, newrange->start, newrange->end);
157 ++newbus->noIORanges;
158 fix_resources (newbus);
159 }
160 break;
161 case PFMEM:
162 newbus->rangePFMem = newrange;
163 if (first_bus)
164 newbus->noPFMemRanges = 1;
165 else {
166 debug ("1st PFMemory Primary on Bus %x [%x - %x]\n", newbus->busno, newrange->start, newrange->end);
167 ++newbus->noPFMemRanges;
168 fix_resources (newbus);
169 }
170
171 break;
172 }
173
174 *new_bus = newbus;
175 *new_range = newrange;
176 return 0;
177 }
178
179
180 /* Notes:
181 * 1. The ranges are ordered. The buses are not ordered. (First come)
182 *
183 * 2. If cannot allocate out of PFMem range, allocate from Mem ranges. PFmemFromMem
184 * are not sorted. (no need since use mem node). To not change the entire code, we
185 * also add mem node whenever this case happens so as not to change
186 * ibmphp_check_mem_resource etc (and since it really is taking Mem resource)
187 */
188
189 /*****************************************************************************
190 * This is the Resource Management initialization function. It will go through
191 * the Resource list taken from EBDA and fill in this module's data structures
192 *
193 * THIS IS NOT TAKING INTO CONSIDERATION IO RESTRICTIONS OF PRIMARY BUSES,
194 * SINCE WE'RE GOING TO ASSUME FOR NOW WE DON'T HAVE THOSE ON OUR BUSES FOR NOW
195 *
196 * Input: ptr to the head of the resource list from EBDA
197 * Output: 0, -1 or error codes
198 ***************************************************************************/
199 int __init ibmphp_rsrc_init (void)
200 {
201 struct ebda_pci_rsrc *curr;
202 struct range_node *newrange = NULL;
203 struct bus_node *newbus = NULL;
204 struct bus_node *bus_cur;
205 struct bus_node *bus_prev;
206 struct list_head *tmp;
207 struct resource_node *new_io = NULL;
208 struct resource_node *new_mem = NULL;
209 struct resource_node *new_pfmem = NULL;
210 int rc;
211 struct list_head *tmp_ebda;
212
213 list_for_each (tmp_ebda, &ibmphp_ebda_pci_rsrc_head) {
214 curr = list_entry (tmp_ebda, struct ebda_pci_rsrc, ebda_pci_rsrc_list);
215 if (!(curr->rsrc_type & PCIDEVMASK)) {
216 /* EBDA still lists non PCI devices, so ignore... */
217 debug ("this is not a PCI DEVICE in rsrc_init, please take care\n");
218 // continue;
219 }
220
221 /* this is a primary bus resource */
222 if (curr->rsrc_type & PRIMARYBUSMASK) {
223 /* memory */
224 if ((curr->rsrc_type & RESTYPE) == MMASK) {
225 /* no bus structure exists in place yet */
226 if (list_empty (&gbuses)) {
227 if ((rc = alloc_bus_range (&newbus, &newrange, curr, MEM, 1)))
228 return rc;
229 list_add_tail (&newbus->bus_list, &gbuses);
230 debug ("gbuses = NULL, Memory Primary Bus %x [%x - %x]\n", newbus->busno, newrange->start, newrange->end);
231 } else {
232 bus_cur = find_bus_wprev (curr->bus_num, &bus_prev, 1);
233 /* found our bus */
234 if (bus_cur) {
235 rc = alloc_bus_range (&bus_cur, &newrange, curr, MEM, 0);
236 if (rc)
237 return rc;
238 } else {
239 /* went through all the buses and didn't find ours, need to create a new bus node */
240 if ((rc = alloc_bus_range (&newbus, &newrange, curr, MEM, 1)))
241 return rc;
242
243 list_add_tail (&newbus->bus_list, &gbuses);
244 debug ("New Bus, Memory Primary Bus %x [%x - %x]\n", newbus->busno, newrange->start, newrange->end);
245 }
246 }
247 } else if ((curr->rsrc_type & RESTYPE) == PFMASK) {
248 /* prefetchable memory */
249 if (list_empty (&gbuses)) {
250 /* no bus structure exists in place yet */
251 if ((rc = alloc_bus_range (&newbus, &newrange, curr, PFMEM, 1)))
252 return rc;
253 list_add_tail (&newbus->bus_list, &gbuses);
254 debug ("gbuses = NULL, PFMemory Primary Bus %x [%x - %x]\n", newbus->busno, newrange->start, newrange->end);
255 } else {
256 bus_cur = find_bus_wprev (curr->bus_num, &bus_prev, 1);
257 if (bus_cur) {
258 /* found our bus */
259 rc = alloc_bus_range (&bus_cur, &newrange, curr, PFMEM, 0);
260 if (rc)
261 return rc;
262 } else {
263 /* went through all the buses and didn't find ours, need to create a new bus node */
264 if ((rc = alloc_bus_range (&newbus, &newrange, curr, PFMEM, 1)))
265 return rc;
266 list_add_tail (&newbus->bus_list, &gbuses);
267 debug ("1st Bus, PFMemory Primary Bus %x [%x - %x]\n", newbus->busno, newrange->start, newrange->end);
268 }
269 }
270 } else if ((curr->rsrc_type & RESTYPE) == IOMASK) {
271 /* IO */
272 if (list_empty (&gbuses)) {
273 /* no bus structure exists in place yet */
274 if ((rc = alloc_bus_range (&newbus, &newrange, curr, IO, 1)))
275 return rc;
276 list_add_tail (&newbus->bus_list, &gbuses);
277 debug ("gbuses = NULL, IO Primary Bus %x [%x - %x]\n", newbus->busno, newrange->start, newrange->end);
278 } else {
279 bus_cur = find_bus_wprev (curr->bus_num, &bus_prev, 1);
280 if (bus_cur) {
281 rc = alloc_bus_range (&bus_cur, &newrange, curr, IO, 0);
282 if (rc)
283 return rc;
284 } else {
285 /* went through all the buses and didn't find ours, need to create a new bus node */
286 if ((rc = alloc_bus_range (&newbus, &newrange, curr, IO, 1)))
287 return rc;
288 list_add_tail (&newbus->bus_list, &gbuses);
289 debug ("1st Bus, IO Primary Bus %x [%x - %x]\n", newbus->busno, newrange->start, newrange->end);
290 }
291 }
292
293 } else {
294 ; /* type is reserved WHAT TO DO IN THIS CASE???
295 NOTHING TO DO??? */
296 }
297 } else {
298 /* regular pci device resource */
299 if ((curr->rsrc_type & RESTYPE) == MMASK) {
300 /* Memory resource */
301 new_mem = alloc_resources (curr);
302 if (!new_mem)
303 return -ENOMEM;
304 new_mem->type = MEM;
305 /*
306 * if it didn't find the bus, means PCI dev
307 * came b4 the Primary Bus info, so need to
308 * create a bus rangeno becomes a problem...
309 * assign a -1 and then update once the range
310 * actually appears...
311 */
312 if (ibmphp_add_resource (new_mem) < 0) {
313 newbus = alloc_error_bus (curr, 0, 0);
314 if (!newbus)
315 return -ENOMEM;
316 newbus->firstMem = new_mem;
317 ++newbus->needMemUpdate;
318 new_mem->rangeno = -1;
319 }
320 debug ("Memory resource for device %x, bus %x, [%x - %x]\n", new_mem->devfunc, new_mem->busno, new_mem->start, new_mem->end);
321
322 } else if ((curr->rsrc_type & RESTYPE) == PFMASK) {
323 /* PFMemory resource */
324 new_pfmem = alloc_resources (curr);
325 if (!new_pfmem)
326 return -ENOMEM;
327 new_pfmem->type = PFMEM;
328 new_pfmem->fromMem = 0;
329 if (ibmphp_add_resource (new_pfmem) < 0) {
330 newbus = alloc_error_bus (curr, 0, 0);
331 if (!newbus)
332 return -ENOMEM;
333 newbus->firstPFMem = new_pfmem;
334 ++newbus->needPFMemUpdate;
335 new_pfmem->rangeno = -1;
336 }
337
338 debug ("PFMemory resource for device %x, bus %x, [%x - %x]\n", new_pfmem->devfunc, new_pfmem->busno, new_pfmem->start, new_pfmem->end);
339 } else if ((curr->rsrc_type & RESTYPE) == IOMASK) {
340 /* IO resource */
341 new_io = alloc_resources (curr);
342 if (!new_io)
343 return -ENOMEM;
344 new_io->type = IO;
345
346 /*
347 * if it didn't find the bus, means PCI dev
348 * came b4 the Primary Bus info, so need to
349 * create a bus rangeno becomes a problem...
350 * Can assign a -1 and then update once the
351 * range actually appears...
352 */
353 if (ibmphp_add_resource (new_io) < 0) {
354 newbus = alloc_error_bus (curr, 0, 0);
355 if (!newbus)
356 return -ENOMEM;
357 newbus->firstIO = new_io;
358 ++newbus->needIOUpdate;
359 new_io->rangeno = -1;
360 }
361 debug ("IO resource for device %x, bus %x, [%x - %x]\n", new_io->devfunc, new_io->busno, new_io->start, new_io->end);
362 }
363 }
364 }
365
366 list_for_each (tmp, &gbuses) {
367 bus_cur = list_entry (tmp, struct bus_node, bus_list);
368 /* This is to get info about PPB resources, since EBDA doesn't put this info into the primary bus info */
369 rc = update_bridge_ranges (&bus_cur);
370 if (rc)
371 return rc;
372 }
373 rc = once_over (); /* This is to align ranges (so no -1) */
374 if (rc)
375 return rc;
376 return 0;
377 }
378
379 /********************************************************************************
380 * This function adds a range into a sorted list of ranges per bus for a particular
381 * range type, it then calls another routine to update the range numbers on the
382 * pci devices' resources for the appropriate resource
383 *
384 * Input: type of the resource, range to add, current bus
385 * Output: 0 or -1, bus and range ptrs
386 ********************************************************************************/
387 static int add_bus_range (int type, struct range_node *range, struct bus_node *bus_cur)
388 {
389 struct range_node *range_cur = NULL;
390 struct range_node *range_prev;
391 int count = 0, i_init;
392 int noRanges = 0;
393
394 switch (type) {
395 case MEM:
396 range_cur = bus_cur->rangeMem;
397 noRanges = bus_cur->noMemRanges;
398 break;
399 case PFMEM:
400 range_cur = bus_cur->rangePFMem;
401 noRanges = bus_cur->noPFMemRanges;
402 break;
403 case IO:
404 range_cur = bus_cur->rangeIO;
405 noRanges = bus_cur->noIORanges;
406 break;
407 }
408
409 range_prev = NULL;
410 while (range_cur) {
411 if (range->start < range_cur->start)
412 break;
413 range_prev = range_cur;
414 range_cur = range_cur->next;
415 count = count + 1;
416 }
417 if (!count) {
418 /* our range will go at the beginning of the list */
419 switch (type) {
420 case MEM:
421 bus_cur->rangeMem = range;
422 break;
423 case PFMEM:
424 bus_cur->rangePFMem = range;
425 break;
426 case IO:
427 bus_cur->rangeIO = range;
428 break;
429 }
430 range->next = range_cur;
431 range->rangeno = 1;
432 i_init = 0;
433 } else if (!range_cur) {
434 /* our range will go at the end of the list */
435 range->next = NULL;
436 range_prev->next = range;
437 range->rangeno = range_prev->rangeno + 1;
438 return 0;
439 } else {
440 /* the range is in the middle */
441 range_prev->next = range;
442 range->next = range_cur;
443 range->rangeno = range_cur->rangeno;
444 i_init = range_prev->rangeno;
445 }
446
447 for (count = i_init; count < noRanges; ++count) {
448 ++range_cur->rangeno;
449 range_cur = range_cur->next;
450 }
451
452 update_resources (bus_cur, type, i_init + 1);
453 return 0;
454 }
455
456 /*******************************************************************************
457 * This routine goes through the list of resources of type 'type' and updates
458 * the range numbers that they correspond to. It was called from add_bus_range fnc
459 *
460 * Input: bus, type of the resource, the rangeno starting from which to update
461 ******************************************************************************/
462 static void update_resources (struct bus_node *bus_cur, int type, int rangeno)
463 {
464 struct resource_node *res = NULL;
465 u8 eol = 0; /* end of list indicator */
466
467 switch (type) {
468 case MEM:
469 if (bus_cur->firstMem)
470 res = bus_cur->firstMem;
471 break;
472 case PFMEM:
473 if (bus_cur->firstPFMem)
474 res = bus_cur->firstPFMem;
475 break;
476 case IO:
477 if (bus_cur->firstIO)
478 res = bus_cur->firstIO;
479 break;
480 }
481
482 if (res) {
483 while (res) {
484 if (res->rangeno == rangeno)
485 break;
486 if (res->next)
487 res = res->next;
488 else if (res->nextRange)
489 res = res->nextRange;
490 else {
491 eol = 1;
492 break;
493 }
494 }
495
496 if (!eol) {
497 /* found the range */
498 while (res) {
499 ++res->rangeno;
500 res = res->next;
501 }
502 }
503 }
504 }
505
506 static void fix_me (struct resource_node *res, struct bus_node *bus_cur, struct range_node *range)
507 {
508 char * str = "";
509 switch (res->type) {
510 case IO:
511 str = "io";
512 break;
513 case MEM:
514 str = "mem";
515 break;
516 case PFMEM:
517 str = "pfmem";
518 break;
519 }
520
521 while (res) {
522 if (res->rangeno == -1) {
523 while (range) {
524 if ((res->start >= range->start) && (res->end <= range->end)) {
525 res->rangeno = range->rangeno;
526 debug ("%s->rangeno in fix_resources is %d\n", str, res->rangeno);
527 switch (res->type) {
528 case IO:
529 --bus_cur->needIOUpdate;
530 break;
531 case MEM:
532 --bus_cur->needMemUpdate;
533 break;
534 case PFMEM:
535 --bus_cur->needPFMemUpdate;
536 break;
537 }
538 break;
539 }
540 range = range->next;
541 }
542 }
543 if (res->next)
544 res = res->next;
545 else
546 res = res->nextRange;
547 }
548
549 }
550
551 /*****************************************************************************
552 * This routine reassigns the range numbers to the resources that had a -1
553 * This case can happen only if upon initialization, resources taken by pci dev
554 * appear in EBDA before the resources allocated for that bus, since we don't
555 * know the range, we assign -1, and this routine is called after a new range
556 * is assigned to see the resources with unknown range belong to the added range
557 *
558 * Input: current bus
559 * Output: none, list of resources for that bus are fixed if can be
560 *******************************************************************************/
561 static void fix_resources (struct bus_node *bus_cur)
562 {
563 struct range_node *range;
564 struct resource_node *res;
565
566 debug ("%s - bus_cur->busno = %d\n", __func__, bus_cur->busno);
567
568 if (bus_cur->needIOUpdate) {
569 res = bus_cur->firstIO;
570 range = bus_cur->rangeIO;
571 fix_me (res, bus_cur, range);
572 }
573 if (bus_cur->needMemUpdate) {
574 res = bus_cur->firstMem;
575 range = bus_cur->rangeMem;
576 fix_me (res, bus_cur, range);
577 }
578 if (bus_cur->needPFMemUpdate) {
579 res = bus_cur->firstPFMem;
580 range = bus_cur->rangePFMem;
581 fix_me (res, bus_cur, range);
582 }
583 }
584
585 /*******************************************************************************
586 * This routine adds a resource to the list of resources to the appropriate bus
587 * based on their resource type and sorted by their starting addresses. It assigns
588 * the ptrs to next and nextRange if needed.
589 *
590 * Input: resource ptr
591 * Output: ptrs assigned (to the node)
592 * 0 or -1
593 *******************************************************************************/
594 int ibmphp_add_resource (struct resource_node *res)
595 {
596 struct resource_node *res_cur;
597 struct resource_node *res_prev;
598 struct bus_node *bus_cur;
599 struct range_node *range_cur = NULL;
600 struct resource_node *res_start = NULL;
601
602 debug ("%s - enter\n", __func__);
603
604 if (!res) {
605 err ("NULL passed to add\n");
606 return -ENODEV;
607 }
608
609 bus_cur = find_bus_wprev (res->busno, NULL, 0);
610
611 if (!bus_cur) {
612 /* didn't find a bus, smth's wrong!!! */
613 debug ("no bus in the system, either pci_dev's wrong or allocation failed\n");
614 return -ENODEV;
615 }
616
617 /* Normal case */
618 switch (res->type) {
619 case IO:
620 range_cur = bus_cur->rangeIO;
621 res_start = bus_cur->firstIO;
622 break;
623 case MEM:
624 range_cur = bus_cur->rangeMem;
625 res_start = bus_cur->firstMem;
626 break;
627 case PFMEM:
628 range_cur = bus_cur->rangePFMem;
629 res_start = bus_cur->firstPFMem;
630 break;
631 default:
632 err ("cannot read the type of the resource to add... problem\n");
633 return -EINVAL;
634 }
635 while (range_cur) {
636 if ((res->start >= range_cur->start) && (res->end <= range_cur->end)) {
637 res->rangeno = range_cur->rangeno;
638 break;
639 }
640 range_cur = range_cur->next;
641 }
642
643 /* !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
644 * this is again the case of rangeno = -1
645 * !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
646 */
647
648 if (!range_cur) {
649 switch (res->type) {
650 case IO:
651 ++bus_cur->needIOUpdate;
652 break;
653 case MEM:
654 ++bus_cur->needMemUpdate;
655 break;
656 case PFMEM:
657 ++bus_cur->needPFMemUpdate;
658 break;
659 }
660 res->rangeno = -1;
661 }
662
663 debug ("The range is %d\n", res->rangeno);
664 if (!res_start) {
665 /* no first{IO,Mem,Pfmem} on the bus, 1st IO/Mem/Pfmem resource ever */
666 switch (res->type) {
667 case IO:
668 bus_cur->firstIO = res;
669 break;
670 case MEM:
671 bus_cur->firstMem = res;
672 break;
673 case PFMEM:
674 bus_cur->firstPFMem = res;
675 break;
676 }
677 res->next = NULL;
678 res->nextRange = NULL;
679 } else {
680 res_cur = res_start;
681 res_prev = NULL;
682
683 debug ("res_cur->rangeno is %d\n", res_cur->rangeno);
684
685 while (res_cur) {
686 if (res_cur->rangeno >= res->rangeno)
687 break;
688 res_prev = res_cur;
689 if (res_cur->next)
690 res_cur = res_cur->next;
691 else
692 res_cur = res_cur->nextRange;
693 }
694
695 if (!res_cur) {
696 /* at the end of the resource list */
697 debug ("i should be here, [%x - %x]\n", res->start, res->end);
698 res_prev->nextRange = res;
699 res->next = NULL;
700 res->nextRange = NULL;
701 } else if (res_cur->rangeno == res->rangeno) {
702 /* in the same range */
703 while (res_cur) {
704 if (res->start < res_cur->start)
705 break;
706 res_prev = res_cur;
707 res_cur = res_cur->next;
708 }
709 if (!res_cur) {
710 /* the last resource in this range */
711 res_prev->next = res;
712 res->next = NULL;
713 res->nextRange = res_prev->nextRange;
714 res_prev->nextRange = NULL;
715 } else if (res->start < res_cur->start) {
716 /* at the beginning or middle of the range */
717 if (!res_prev) {
718 switch (res->type) {
719 case IO:
720 bus_cur->firstIO = res;
721 break;
722 case MEM:
723 bus_cur->firstMem = res;
724 break;
725 case PFMEM:
726 bus_cur->firstPFMem = res;
727 break;
728 }
729 } else if (res_prev->rangeno == res_cur->rangeno)
730 res_prev->next = res;
731 else
732 res_prev->nextRange = res;
733
734 res->next = res_cur;
735 res->nextRange = NULL;
736 }
737 } else {
738 /* this is the case where it is 1st occurrence of the range */
739 if (!res_prev) {
740 /* at the beginning of the resource list */
741 res->next = NULL;
742 switch (res->type) {
743 case IO:
744 res->nextRange = bus_cur->firstIO;
745 bus_cur->firstIO = res;
746 break;
747 case MEM:
748 res->nextRange = bus_cur->firstMem;
749 bus_cur->firstMem = res;
750 break;
751 case PFMEM:
752 res->nextRange = bus_cur->firstPFMem;
753 bus_cur->firstPFMem = res;
754 break;
755 }
756 } else if (res_cur->rangeno > res->rangeno) {
757 /* in the middle of the resource list */
758 res_prev->nextRange = res;
759 res->next = NULL;
760 res->nextRange = res_cur;
761 }
762 }
763 }
764
765 debug ("%s - exit\n", __func__);
766 return 0;
767 }
768
769 /****************************************************************************
770 * This routine will remove the resource from the list of resources
771 *
772 * Input: io, mem, and/or pfmem resource to be deleted
773 * Ouput: modified resource list
774 * 0 or error code
775 ****************************************************************************/
776 int ibmphp_remove_resource (struct resource_node *res)
777 {
778 struct bus_node *bus_cur;
779 struct resource_node *res_cur = NULL;
780 struct resource_node *res_prev;
781 struct resource_node *mem_cur;
782 char * type = "";
783
784 if (!res) {
785 err ("resource to remove is NULL\n");
786 return -ENODEV;
787 }
788
789 bus_cur = find_bus_wprev (res->busno, NULL, 0);
790
791 if (!bus_cur) {
792 err ("cannot find corresponding bus of the io resource to remove "
793 "bailing out...\n");
794 return -ENODEV;
795 }
796
797 switch (res->type) {
798 case IO:
799 res_cur = bus_cur->firstIO;
800 type = "io";
801 break;
802 case MEM:
803 res_cur = bus_cur->firstMem;
804 type = "mem";
805 break;
806 case PFMEM:
807 res_cur = bus_cur->firstPFMem;
808 type = "pfmem";
809 break;
810 default:
811 err ("unknown type for resource to remove\n");
812 return -EINVAL;
813 }
814 res_prev = NULL;
815
816 while (res_cur) {
817 if ((res_cur->start == res->start) && (res_cur->end == res->end))
818 break;
819 res_prev = res_cur;
820 if (res_cur->next)
821 res_cur = res_cur->next;
822 else
823 res_cur = res_cur->nextRange;
824 }
825
826 if (!res_cur) {
827 if (res->type == PFMEM) {
828 /*
829 * case where pfmem might be in the PFMemFromMem list
830 * so will also need to remove the corresponding mem
831 * entry
832 */
833 res_cur = bus_cur->firstPFMemFromMem;
834 res_prev = NULL;
835
836 while (res_cur) {
837 if ((res_cur->start == res->start) && (res_cur->end == res->end)) {
838 mem_cur = bus_cur->firstMem;
839 while (mem_cur) {
840 if ((mem_cur->start == res_cur->start)
841 && (mem_cur->end == res_cur->end))
842 break;
843 if (mem_cur->next)
844 mem_cur = mem_cur->next;
845 else
846 mem_cur = mem_cur->nextRange;
847 }
848 if (!mem_cur) {
849 err ("cannot find corresponding mem node for pfmem...\n");
850 return -EINVAL;
851 }
852
853 ibmphp_remove_resource (mem_cur);
854 if (!res_prev)
855 bus_cur->firstPFMemFromMem = res_cur->next;
856 else
857 res_prev->next = res_cur->next;
858 kfree (res_cur);
859 return 0;
860 }
861 res_prev = res_cur;
862 if (res_cur->next)
863 res_cur = res_cur->next;
864 else
865 res_cur = res_cur->nextRange;
866 }
867 if (!res_cur) {
868 err ("cannot find pfmem to delete...\n");
869 return -EINVAL;
870 }
871 } else {
872 err ("the %s resource is not in the list to be deleted...\n", type);
873 return -EINVAL;
874 }
875 }
876 if (!res_prev) {
877 /* first device to be deleted */
878 if (res_cur->next) {
879 switch (res->type) {
880 case IO:
881 bus_cur->firstIO = res_cur->next;
882 break;
883 case MEM:
884 bus_cur->firstMem = res_cur->next;
885 break;
886 case PFMEM:
887 bus_cur->firstPFMem = res_cur->next;
888 break;
889 }
890 } else if (res_cur->nextRange) {
891 switch (res->type) {
892 case IO:
893 bus_cur->firstIO = res_cur->nextRange;
894 break;
895 case MEM:
896 bus_cur->firstMem = res_cur->nextRange;
897 break;
898 case PFMEM:
899 bus_cur->firstPFMem = res_cur->nextRange;
900 break;
901 }
902 } else {
903 switch (res->type) {
904 case IO:
905 bus_cur->firstIO = NULL;
906 break;
907 case MEM:
908 bus_cur->firstMem = NULL;
909 break;
910 case PFMEM:
911 bus_cur->firstPFMem = NULL;
912 break;
913 }
914 }
915 kfree (res_cur);
916 return 0;
917 } else {
918 if (res_cur->next) {
919 if (res_prev->rangeno == res_cur->rangeno)
920 res_prev->next = res_cur->next;
921 else
922 res_prev->nextRange = res_cur->next;
923 } else if (res_cur->nextRange) {
924 res_prev->next = NULL;
925 res_prev->nextRange = res_cur->nextRange;
926 } else {
927 res_prev->next = NULL;
928 res_prev->nextRange = NULL;
929 }
930 kfree (res_cur);
931 return 0;
932 }
933
934 return 0;
935 }
936
937 static struct range_node * find_range (struct bus_node *bus_cur, struct resource_node * res)
938 {
939 struct range_node * range = NULL;
940
941 switch (res->type) {
942 case IO:
943 range = bus_cur->rangeIO;
944 break;
945 case MEM:
946 range = bus_cur->rangeMem;
947 break;
948 case PFMEM:
949 range = bus_cur->rangePFMem;
950 break;
951 default:
952 err ("cannot read resource type in find_range\n");
953 }
954
955 while (range) {
956 if (res->rangeno == range->rangeno)
957 break;
958 range = range->next;
959 }
960 return range;
961 }
962
963 /*****************************************************************************
964 * This routine will check to make sure the io/mem/pfmem->len that the device asked for
965 * can fit w/i our list of available IO/MEM/PFMEM resources. If cannot, returns -EINVAL,
966 * otherwise, returns 0
967 *
968 * Input: resource
969 * Ouput: the correct start and end address are inputted into the resource node,
970 * 0 or -EINVAL
971 *****************************************************************************/
972 int ibmphp_check_resource (struct resource_node *res, u8 bridge)
973 {
974 struct bus_node *bus_cur;
975 struct range_node *range = NULL;
976 struct resource_node *res_prev;
977 struct resource_node *res_cur = NULL;
978 u32 len_cur = 0, start_cur = 0, len_tmp = 0;
979 int noranges = 0;
980 u32 tmp_start; /* this is to make sure start address is divisible by the length needed */
981 u32 tmp_divide;
982 u8 flag = 0;
983
984 if (!res)
985 return -EINVAL;
986
987 if (bridge) {
988 /* The rules for bridges are different, 4K divisible for IO, 1M for (pf)mem*/
989 if (res->type == IO)
990 tmp_divide = IOBRIDGE;
991 else
992 tmp_divide = MEMBRIDGE;
993 } else
994 tmp_divide = res->len;
995
996 bus_cur = find_bus_wprev (res->busno, NULL, 0);
997
998 if (!bus_cur) {
999 /* didn't find a bus, smth's wrong!!! */
1000 debug ("no bus in the system, either pci_dev's wrong or allocation failed\n");
1001 return -EINVAL;
1002 }
1003
1004 debug ("%s - enter\n", __func__);
1005 debug ("bus_cur->busno is %d\n", bus_cur->busno);
1006
1007 /* This is a quick fix to not mess up with the code very much. i.e.,
1008 * 2000-2fff, len = 1000, but when we compare, we need it to be fff */
1009 res->len -= 1;
1010
1011 switch (res->type) {
1012 case IO:
1013 res_cur = bus_cur->firstIO;
1014 noranges = bus_cur->noIORanges;
1015 break;
1016 case MEM:
1017 res_cur = bus_cur->firstMem;
1018 noranges = bus_cur->noMemRanges;
1019 break;
1020 case PFMEM:
1021 res_cur = bus_cur->firstPFMem;
1022 noranges = bus_cur->noPFMemRanges;
1023 break;
1024 default:
1025 err ("wrong type of resource to check\n");
1026 return -EINVAL;
1027 }
1028 res_prev = NULL;
1029
1030 while (res_cur) {
1031 range = find_range (bus_cur, res_cur);
1032 debug ("%s - rangeno = %d\n", __func__, res_cur->rangeno);
1033
1034 if (!range) {
1035 err ("no range for the device exists... bailing out...\n");
1036 return -EINVAL;
1037 }
1038
1039 /* found our range */
1040 if (!res_prev) {
1041 /* first time in the loop */
1042 if ((res_cur->start != range->start) && ((len_tmp = res_cur->start - 1 - range->start) >= res->len)) {
1043 debug ("len_tmp = %x\n", len_tmp);
1044
1045 if ((len_tmp < len_cur) || (len_cur == 0)) {
1046
1047 if ((range->start % tmp_divide) == 0) {
1048 /* just perfect, starting address is divisible by length */
1049 flag = 1;
1050 len_cur = len_tmp;
1051 start_cur = range->start;
1052 } else {
1053 /* Needs adjusting */
1054 tmp_start = range->start;
1055 flag = 0;
1056
1057 while ((len_tmp = res_cur->start - 1 - tmp_start) >= res->len) {
1058 if ((tmp_start % tmp_divide) == 0) {
1059 flag = 1;
1060 len_cur = len_tmp;
1061 start_cur = tmp_start;
1062 break;
1063 }
1064 tmp_start += tmp_divide - tmp_start % tmp_divide;
1065 if (tmp_start >= res_cur->start - 1)
1066 break;
1067 }
1068 }
1069
1070 if (flag && len_cur == res->len) {
1071 debug ("but we are not here, right?\n");
1072 res->start = start_cur;
1073 res->len += 1; /* To restore the balance */
1074 res->end = res->start + res->len - 1;
1075 return 0;
1076 }
1077 }
1078 }
1079 }
1080 if (!res_cur->next) {
1081 /* last device on the range */
1082 if ((range->end != res_cur->end) && ((len_tmp = range->end - (res_cur->end + 1)) >= res->len)) {
1083 debug ("len_tmp = %x\n", len_tmp);
1084 if ((len_tmp < len_cur) || (len_cur == 0)) {
1085
1086 if (((res_cur->end + 1) % tmp_divide) == 0) {
1087 /* just perfect, starting address is divisible by length */
1088 flag = 1;
1089 len_cur = len_tmp;
1090 start_cur = res_cur->end + 1;
1091 } else {
1092 /* Needs adjusting */
1093 tmp_start = res_cur->end + 1;
1094 flag = 0;
1095
1096 while ((len_tmp = range->end - tmp_start) >= res->len) {
1097 if ((tmp_start % tmp_divide) == 0) {
1098 flag = 1;
1099 len_cur = len_tmp;
1100 start_cur = tmp_start;
1101 break;
1102 }
1103 tmp_start += tmp_divide - tmp_start % tmp_divide;
1104 if (tmp_start >= range->end)
1105 break;
1106 }
1107 }
1108 if (flag && len_cur == res->len) {
1109 res->start = start_cur;
1110 res->len += 1; /* To restore the balance */
1111 res->end = res->start + res->len - 1;
1112 return 0;
1113 }
1114 }
1115 }
1116 }
1117
1118 if (res_prev) {
1119 if (res_prev->rangeno != res_cur->rangeno) {
1120 /* 1st device on this range */
1121 if ((res_cur->start != range->start) &&
1122 ((len_tmp = res_cur->start - 1 - range->start) >= res->len)) {
1123 if ((len_tmp < len_cur) || (len_cur == 0)) {
1124 if ((range->start % tmp_divide) == 0) {
1125 /* just perfect, starting address is divisible by length */
1126 flag = 1;
1127 len_cur = len_tmp;
1128 start_cur = range->start;
1129 } else {
1130 /* Needs adjusting */
1131 tmp_start = range->start;
1132 flag = 0;
1133
1134 while ((len_tmp = res_cur->start - 1 - tmp_start) >= res->len) {
1135 if ((tmp_start % tmp_divide) == 0) {
1136 flag = 1;
1137 len_cur = len_tmp;
1138 start_cur = tmp_start;
1139 break;
1140 }
1141 tmp_start += tmp_divide - tmp_start % tmp_divide;
1142 if (tmp_start >= res_cur->start - 1)
1143 break;
1144 }
1145 }
1146
1147 if (flag && len_cur == res->len) {
1148 res->start = start_cur;
1149 res->len += 1; /* To restore the balance */
1150 res->end = res->start + res->len - 1;
1151 return 0;
1152 }
1153 }
1154 }
1155 } else {
1156 /* in the same range */
1157 if ((len_tmp = res_cur->start - 1 - res_prev->end - 1) >= res->len) {
1158 if ((len_tmp < len_cur) || (len_cur == 0)) {
1159 if (((res_prev->end + 1) % tmp_divide) == 0) {
1160 /* just perfect, starting address's divisible by length */
1161 flag = 1;
1162 len_cur = len_tmp;
1163 start_cur = res_prev->end + 1;
1164 } else {
1165 /* Needs adjusting */
1166 tmp_start = res_prev->end + 1;
1167 flag = 0;
1168
1169 while ((len_tmp = res_cur->start - 1 - tmp_start) >= res->len) {
1170 if ((tmp_start % tmp_divide) == 0) {
1171 flag = 1;
1172 len_cur = len_tmp;
1173 start_cur = tmp_start;
1174 break;
1175 }
1176 tmp_start += tmp_divide - tmp_start % tmp_divide;
1177 if (tmp_start >= res_cur->start - 1)
1178 break;
1179 }
1180 }
1181
1182 if (flag && len_cur == res->len) {
1183 res->start = start_cur;
1184 res->len += 1; /* To restore the balance */
1185 res->end = res->start + res->len - 1;
1186 return 0;
1187 }
1188 }
1189 }
1190 }
1191 }
1192 /* end if (res_prev) */
1193 res_prev = res_cur;
1194 if (res_cur->next)
1195 res_cur = res_cur->next;
1196 else
1197 res_cur = res_cur->nextRange;
1198 } /* end of while */
1199
1200
1201 if (!res_prev) {
1202 /* 1st device ever */
1203 /* need to find appropriate range */
1204 switch (res->type) {
1205 case IO:
1206 range = bus_cur->rangeIO;
1207 break;
1208 case MEM:
1209 range = bus_cur->rangeMem;
1210 break;
1211 case PFMEM:
1212 range = bus_cur->rangePFMem;
1213 break;
1214 }
1215 while (range) {
1216 if ((len_tmp = range->end - range->start) >= res->len) {
1217 if ((len_tmp < len_cur) || (len_cur == 0)) {
1218 if ((range->start % tmp_divide) == 0) {
1219 /* just perfect, starting address's divisible by length */
1220 flag = 1;
1221 len_cur = len_tmp;
1222 start_cur = range->start;
1223 } else {
1224 /* Needs adjusting */
1225 tmp_start = range->start;
1226 flag = 0;
1227
1228 while ((len_tmp = range->end - tmp_start) >= res->len) {
1229 if ((tmp_start % tmp_divide) == 0) {
1230 flag = 1;
1231 len_cur = len_tmp;
1232 start_cur = tmp_start;
1233 break;
1234 }
1235 tmp_start += tmp_divide - tmp_start % tmp_divide;
1236 if (tmp_start >= range->end)
1237 break;
1238 }
1239 }
1240
1241 if (flag && len_cur == res->len) {
1242 res->start = start_cur;
1243 res->len += 1; /* To restore the balance */
1244 res->end = res->start + res->len - 1;
1245 return 0;
1246 }
1247 }
1248 }
1249 range = range->next;
1250 } /* end of while */
1251
1252 if ((!range) && (len_cur == 0)) {
1253 /* have gone through the list of devices and ranges and haven't found n.e.thing */
1254 err ("no appropriate range.. bailing out...\n");
1255 return -EINVAL;
1256 } else if (len_cur) {
1257 res->start = start_cur;
1258 res->len += 1; /* To restore the balance */
1259 res->end = res->start + res->len - 1;
1260 return 0;
1261 }
1262 }
1263
1264 if (!res_cur) {
1265 debug ("prev->rangeno = %d, noranges = %d\n", res_prev->rangeno, noranges);
1266 if (res_prev->rangeno < noranges) {
1267 /* if there're more ranges out there to check */
1268 switch (res->type) {
1269 case IO:
1270 range = bus_cur->rangeIO;
1271 break;
1272 case MEM:
1273 range = bus_cur->rangeMem;
1274 break;
1275 case PFMEM:
1276 range = bus_cur->rangePFMem;
1277 break;
1278 }
1279 while (range) {
1280 if ((len_tmp = range->end - range->start) >= res->len) {
1281 if ((len_tmp < len_cur) || (len_cur == 0)) {
1282 if ((range->start % tmp_divide) == 0) {
1283 /* just perfect, starting address's divisible by length */
1284 flag = 1;
1285 len_cur = len_tmp;
1286 start_cur = range->start;
1287 } else {
1288 /* Needs adjusting */
1289 tmp_start = range->start;
1290 flag = 0;
1291
1292 while ((len_tmp = range->end - tmp_start) >= res->len) {
1293 if ((tmp_start % tmp_divide) == 0) {
1294 flag = 1;
1295 len_cur = len_tmp;
1296 start_cur = tmp_start;
1297 break;
1298 }
1299 tmp_start += tmp_divide - tmp_start % tmp_divide;
1300 if (tmp_start >= range->end)
1301 break;
1302 }
1303 }
1304
1305 if (flag && len_cur == res->len) {
1306 res->start = start_cur;
1307 res->len += 1; /* To restore the balance */
1308 res->end = res->start + res->len - 1;
1309 return 0;
1310 }
1311 }
1312 }
1313 range = range->next;
1314 } /* end of while */
1315
1316 if ((!range) && (len_cur == 0)) {
1317 /* have gone through the list of devices and ranges and haven't found n.e.thing */
1318 err ("no appropriate range.. bailing out...\n");
1319 return -EINVAL;
1320 } else if (len_cur) {
1321 res->start = start_cur;
1322 res->len += 1; /* To restore the balance */
1323 res->end = res->start + res->len - 1;
1324 return 0;
1325 }
1326 } else {
1327 /* no more ranges to check on */
1328 if (len_cur) {
1329 res->start = start_cur;
1330 res->len += 1; /* To restore the balance */
1331 res->end = res->start + res->len - 1;
1332 return 0;
1333 } else {
1334 /* have gone through the list of devices and haven't found n.e.thing */
1335 err ("no appropriate range.. bailing out...\n");
1336 return -EINVAL;
1337 }
1338 }
1339 } /* end if(!res_cur) */
1340 return -EINVAL;
1341 }
1342
1343 /********************************************************************************
1344 * This routine is called from remove_card if the card contained PPB.
1345 * It will remove all the resources on the bus as well as the bus itself
1346 * Input: Bus
1347 * Ouput: 0, -ENODEV
1348 ********************************************************************************/
1349 int ibmphp_remove_bus (struct bus_node *bus, u8 parent_busno)
1350 {
1351 struct resource_node *res_cur;
1352 struct resource_node *res_tmp;
1353 struct bus_node *prev_bus;
1354 int rc;
1355
1356 prev_bus = find_bus_wprev (parent_busno, NULL, 0);
1357
1358 if (!prev_bus) {
1359 debug ("something terribly wrong. Cannot find parent bus to the one to remove\n");
1360 return -ENODEV;
1361 }
1362
1363 debug ("In ibmphp_remove_bus... prev_bus->busno is %x\n", prev_bus->busno);
1364
1365 rc = remove_ranges (bus, prev_bus);
1366 if (rc)
1367 return rc;
1368
1369 if (bus->firstIO) {
1370 res_cur = bus->firstIO;
1371 while (res_cur) {
1372 res_tmp = res_cur;
1373 if (res_cur->next)
1374 res_cur = res_cur->next;
1375 else
1376 res_cur = res_cur->nextRange;
1377 kfree (res_tmp);
1378 res_tmp = NULL;
1379 }
1380 bus->firstIO = NULL;
1381 }
1382 if (bus->firstMem) {
1383 res_cur = bus->firstMem;
1384 while (res_cur) {
1385 res_tmp = res_cur;
1386 if (res_cur->next)
1387 res_cur = res_cur->next;
1388 else
1389 res_cur = res_cur->nextRange;
1390 kfree (res_tmp);
1391 res_tmp = NULL;
1392 }
1393 bus->firstMem = NULL;
1394 }
1395 if (bus->firstPFMem) {
1396 res_cur = bus->firstPFMem;
1397 while (res_cur) {
1398 res_tmp = res_cur;
1399 if (res_cur->next)
1400 res_cur = res_cur->next;
1401 else
1402 res_cur = res_cur->nextRange;
1403 kfree (res_tmp);
1404 res_tmp = NULL;
1405 }
1406 bus->firstPFMem = NULL;
1407 }
1408
1409 if (bus->firstPFMemFromMem) {
1410 res_cur = bus->firstPFMemFromMem;
1411 while (res_cur) {
1412 res_tmp = res_cur;
1413 res_cur = res_cur->next;
1414
1415 kfree (res_tmp);
1416 res_tmp = NULL;
1417 }
1418 bus->firstPFMemFromMem = NULL;
1419 }
1420
1421 list_del (&bus->bus_list);
1422 kfree (bus);
1423 return 0;
1424 }
1425
1426 /******************************************************************************
1427 * This routine deletes the ranges from a given bus, and the entries from the
1428 * parent's bus in the resources
1429 * Input: current bus, previous bus
1430 * Output: 0, -EINVAL
1431 ******************************************************************************/
1432 static int remove_ranges (struct bus_node *bus_cur, struct bus_node *bus_prev)
1433 {
1434 struct range_node *range_cur;
1435 struct range_node *range_tmp;
1436 int i;
1437 struct resource_node *res = NULL;
1438
1439 if (bus_cur->noIORanges) {
1440 range_cur = bus_cur->rangeIO;
1441 for (i = 0; i < bus_cur->noIORanges; i++) {
1442 if (ibmphp_find_resource (bus_prev, range_cur->start, &res, IO) < 0)
1443 return -EINVAL;
1444 ibmphp_remove_resource (res);
1445
1446 range_tmp = range_cur;
1447 range_cur = range_cur->next;
1448 kfree (range_tmp);
1449 range_tmp = NULL;
1450 }
1451 bus_cur->rangeIO = NULL;
1452 }
1453 if (bus_cur->noMemRanges) {
1454 range_cur = bus_cur->rangeMem;
1455 for (i = 0; i < bus_cur->noMemRanges; i++) {
1456 if (ibmphp_find_resource (bus_prev, range_cur->start, &res, MEM) < 0)
1457 return -EINVAL;
1458
1459 ibmphp_remove_resource (res);
1460 range_tmp = range_cur;
1461 range_cur = range_cur->next;
1462 kfree (range_tmp);
1463 range_tmp = NULL;
1464 }
1465 bus_cur->rangeMem = NULL;
1466 }
1467 if (bus_cur->noPFMemRanges) {
1468 range_cur = bus_cur->rangePFMem;
1469 for (i = 0; i < bus_cur->noPFMemRanges; i++) {
1470 if (ibmphp_find_resource (bus_prev, range_cur->start, &res, PFMEM) < 0)
1471 return -EINVAL;
1472
1473 ibmphp_remove_resource (res);
1474 range_tmp = range_cur;
1475 range_cur = range_cur->next;
1476 kfree (range_tmp);
1477 range_tmp = NULL;
1478 }
1479 bus_cur->rangePFMem = NULL;
1480 }
1481 return 0;
1482 }
1483
1484 /*
1485 * find the resource node in the bus
1486 * Input: Resource needed, start address of the resource, type of resource
1487 */
1488 int ibmphp_find_resource (struct bus_node *bus, u32 start_address, struct resource_node **res, int flag)
1489 {
1490 struct resource_node *res_cur = NULL;
1491 char * type = "";
1492
1493 if (!bus) {
1494 err ("The bus passed in NULL to find resource\n");
1495 return -ENODEV;
1496 }
1497
1498 switch (flag) {
1499 case IO:
1500 res_cur = bus->firstIO;
1501 type = "io";
1502 break;
1503 case MEM:
1504 res_cur = bus->firstMem;
1505 type = "mem";
1506 break;
1507 case PFMEM:
1508 res_cur = bus->firstPFMem;
1509 type = "pfmem";
1510 break;
1511 default:
1512 err ("wrong type of flag\n");
1513 return -EINVAL;
1514 }
1515
1516 while (res_cur) {
1517 if (res_cur->start == start_address) {
1518 *res = res_cur;
1519 break;
1520 }
1521 if (res_cur->next)
1522 res_cur = res_cur->next;
1523 else
1524 res_cur = res_cur->nextRange;
1525 }
1526
1527 if (!res_cur) {
1528 if (flag == PFMEM) {
1529 res_cur = bus->firstPFMemFromMem;
1530 while (res_cur) {
1531 if (res_cur->start == start_address) {
1532 *res = res_cur;
1533 break;
1534 }
1535 res_cur = res_cur->next;
1536 }
1537 if (!res_cur) {
1538 debug ("SOS...cannot find %s resource in the bus.\n", type);
1539 return -EINVAL;
1540 }
1541 } else {
1542 debug ("SOS... cannot find %s resource in the bus.\n", type);
1543 return -EINVAL;
1544 }
1545 }
1546
1547 if (*res)
1548 debug ("*res->start = %x\n", (*res)->start);
1549
1550 return 0;
1551 }
1552
1553 /***********************************************************************
1554 * This routine will free the resource structures used by the
1555 * system. It is called from cleanup routine for the module
1556 * Parameters: none
1557 * Returns: none
1558 ***********************************************************************/
1559 void ibmphp_free_resources (void)
1560 {
1561 struct bus_node *bus_cur = NULL;
1562 struct bus_node *bus_tmp;
1563 struct range_node *range_cur;
1564 struct range_node *range_tmp;
1565 struct resource_node *res_cur;
1566 struct resource_node *res_tmp;
1567 struct list_head *tmp;
1568 struct list_head *next;
1569 int i = 0;
1570 flags = 1;
1571
1572 list_for_each_safe (tmp, next, &gbuses) {
1573 bus_cur = list_entry (tmp, struct bus_node, bus_list);
1574 if (bus_cur->noIORanges) {
1575 range_cur = bus_cur->rangeIO;
1576 for (i = 0; i < bus_cur->noIORanges; i++) {
1577 if (!range_cur)
1578 break;
1579 range_tmp = range_cur;
1580 range_cur = range_cur->next;
1581 kfree (range_tmp);
1582 range_tmp = NULL;
1583 }
1584 }
1585 if (bus_cur->noMemRanges) {
1586 range_cur = bus_cur->rangeMem;
1587 for (i = 0; i < bus_cur->noMemRanges; i++) {
1588 if (!range_cur)
1589 break;
1590 range_tmp = range_cur;
1591 range_cur = range_cur->next;
1592 kfree (range_tmp);
1593 range_tmp = NULL;
1594 }
1595 }
1596 if (bus_cur->noPFMemRanges) {
1597 range_cur = bus_cur->rangePFMem;
1598 for (i = 0; i < bus_cur->noPFMemRanges; i++) {
1599 if (!range_cur)
1600 break;
1601 range_tmp = range_cur;
1602 range_cur = range_cur->next;
1603 kfree (range_tmp);
1604 range_tmp = NULL;
1605 }
1606 }
1607
1608 if (bus_cur->firstIO) {
1609 res_cur = bus_cur->firstIO;
1610 while (res_cur) {
1611 res_tmp = res_cur;
1612 if (res_cur->next)
1613 res_cur = res_cur->next;
1614 else
1615 res_cur = res_cur->nextRange;
1616 kfree (res_tmp);
1617 res_tmp = NULL;
1618 }
1619 bus_cur->firstIO = NULL;
1620 }
1621 if (bus_cur->firstMem) {
1622 res_cur = bus_cur->firstMem;
1623 while (res_cur) {
1624 res_tmp = res_cur;
1625 if (res_cur->next)
1626 res_cur = res_cur->next;
1627 else
1628 res_cur = res_cur->nextRange;
1629 kfree (res_tmp);
1630 res_tmp = NULL;
1631 }
1632 bus_cur->firstMem = NULL;
1633 }
1634 if (bus_cur->firstPFMem) {
1635 res_cur = bus_cur->firstPFMem;
1636 while (res_cur) {
1637 res_tmp = res_cur;
1638 if (res_cur->next)
1639 res_cur = res_cur->next;
1640 else
1641 res_cur = res_cur->nextRange;
1642 kfree (res_tmp);
1643 res_tmp = NULL;
1644 }
1645 bus_cur->firstPFMem = NULL;
1646 }
1647
1648 if (bus_cur->firstPFMemFromMem) {
1649 res_cur = bus_cur->firstPFMemFromMem;
1650 while (res_cur) {
1651 res_tmp = res_cur;
1652 res_cur = res_cur->next;
1653
1654 kfree (res_tmp);
1655 res_tmp = NULL;
1656 }
1657 bus_cur->firstPFMemFromMem = NULL;
1658 }
1659
1660 bus_tmp = bus_cur;
1661 list_del (&bus_cur->bus_list);
1662 kfree (bus_tmp);
1663 bus_tmp = NULL;
1664 }
1665 }
1666
1667 /*********************************************************************************
1668 * This function will go over the PFmem resources to check if the EBDA allocated
1669 * pfmem out of memory buckets of the bus. If so, it will change the range numbers
1670 * and a flag to indicate that this resource is out of memory. It will also move the
1671 * Pfmem out of the pfmem resource list to the PFMemFromMem list, and will create
1672 * a new Mem node
1673 * This routine is called right after initialization
1674 *******************************************************************************/
1675 static int __init once_over (void)
1676 {
1677 struct resource_node *pfmem_cur;
1678 struct resource_node *pfmem_prev;
1679 struct resource_node *mem;
1680 struct bus_node *bus_cur;
1681 struct list_head *tmp;
1682
1683 list_for_each (tmp, &gbuses) {
1684 bus_cur = list_entry (tmp, struct bus_node, bus_list);
1685 if ((!bus_cur->rangePFMem) && (bus_cur->firstPFMem)) {
1686 for (pfmem_cur = bus_cur->firstPFMem, pfmem_prev = NULL; pfmem_cur; pfmem_prev = pfmem_cur, pfmem_cur = pfmem_cur->next) {
1687 pfmem_cur->fromMem = 1;
1688 if (pfmem_prev)
1689 pfmem_prev->next = pfmem_cur->next;
1690 else
1691 bus_cur->firstPFMem = pfmem_cur->next;
1692
1693 if (!bus_cur->firstPFMemFromMem)
1694 pfmem_cur->next = NULL;
1695 else
1696 /* we don't need to sort PFMemFromMem since we're using mem node for
1697 all the real work anyways, so just insert at the beginning of the
1698 list
1699 */
1700 pfmem_cur->next = bus_cur->firstPFMemFromMem;
1701
1702 bus_cur->firstPFMemFromMem = pfmem_cur;
1703
1704 mem = kzalloc(sizeof(struct resource_node), GFP_KERNEL);
1705 if (!mem) {
1706 err ("out of system memory\n");
1707 return -ENOMEM;
1708 }
1709 mem->type = MEM;
1710 mem->busno = pfmem_cur->busno;
1711 mem->devfunc = pfmem_cur->devfunc;
1712 mem->start = pfmem_cur->start;
1713 mem->end = pfmem_cur->end;
1714 mem->len = pfmem_cur->len;
1715 if (ibmphp_add_resource (mem) < 0)
1716 err ("Trouble...trouble... EBDA allocated pfmem from mem, but system doesn't display it has this space... unless not PCI device...\n");
1717 pfmem_cur->rangeno = mem->rangeno;
1718 } /* end for pfmem */
1719 } /* end if */
1720 } /* end list_for_each bus */
1721 return 0;
1722 }
1723
1724 int ibmphp_add_pfmem_from_mem (struct resource_node *pfmem)
1725 {
1726 struct bus_node *bus_cur = find_bus_wprev (pfmem->busno, NULL, 0);
1727
1728 if (!bus_cur) {
1729 err ("cannot find bus of pfmem to add...\n");
1730 return -ENODEV;
1731 }
1732
1733 if (bus_cur->firstPFMemFromMem)
1734 pfmem->next = bus_cur->firstPFMemFromMem;
1735 else
1736 pfmem->next = NULL;
1737
1738 bus_cur->firstPFMemFromMem = pfmem;
1739
1740 return 0;
1741 }
1742
1743 /* This routine just goes through the buses to see if the bus already exists.
1744 * It is called from ibmphp_find_sec_number, to find out a secondary bus number for
1745 * bridged cards
1746 * Parameters: bus_number
1747 * Returns: Bus pointer or NULL
1748 */
1749 struct bus_node *ibmphp_find_res_bus (u8 bus_number)
1750 {
1751 return find_bus_wprev (bus_number, NULL, 0);
1752 }
1753
1754 static struct bus_node *find_bus_wprev (u8 bus_number, struct bus_node **prev, u8 flag)
1755 {
1756 struct bus_node *bus_cur;
1757 struct list_head *tmp;
1758 struct list_head *tmp_prev;
1759
1760 list_for_each (tmp, &gbuses) {
1761 tmp_prev = tmp->prev;
1762 bus_cur = list_entry (tmp, struct bus_node, bus_list);
1763 if (flag)
1764 *prev = list_entry (tmp_prev, struct bus_node, bus_list);
1765 if (bus_cur->busno == bus_number)
1766 return bus_cur;
1767 }
1768
1769 return NULL;
1770 }
1771
1772 void ibmphp_print_test (void)
1773 {
1774 int i = 0;
1775 struct bus_node *bus_cur = NULL;
1776 struct range_node *range;
1777 struct resource_node *res;
1778 struct list_head *tmp;
1779
1780 debug_pci ("*****************START**********************\n");
1781
1782 if ((!list_empty(&gbuses)) && flags) {
1783 err ("The GBUSES is not NULL?!?!?!?!?\n");
1784 return;
1785 }
1786
1787 list_for_each (tmp, &gbuses) {
1788 bus_cur = list_entry (tmp, struct bus_node, bus_list);
1789 debug_pci ("This is bus # %d. There are\n", bus_cur->busno);
1790 debug_pci ("IORanges = %d\t", bus_cur->noIORanges);
1791 debug_pci ("MemRanges = %d\t", bus_cur->noMemRanges);
1792 debug_pci ("PFMemRanges = %d\n", bus_cur->noPFMemRanges);
1793 debug_pci ("The IO Ranges are as follows:\n");
1794 if (bus_cur->rangeIO) {
1795 range = bus_cur->rangeIO;
1796 for (i = 0; i < bus_cur->noIORanges; i++) {
1797 debug_pci ("rangeno is %d\n", range->rangeno);
1798 debug_pci ("[%x - %x]\n", range->start, range->end);
1799 range = range->next;
1800 }
1801 }
1802
1803 debug_pci ("The Mem Ranges are as follows:\n");
1804 if (bus_cur->rangeMem) {
1805 range = bus_cur->rangeMem;
1806 for (i = 0; i < bus_cur->noMemRanges; i++) {
1807 debug_pci ("rangeno is %d\n", range->rangeno);
1808 debug_pci ("[%x - %x]\n", range->start, range->end);
1809 range = range->next;
1810 }
1811 }
1812
1813 debug_pci ("The PFMem Ranges are as follows:\n");
1814
1815 if (bus_cur->rangePFMem) {
1816 range = bus_cur->rangePFMem;
1817 for (i = 0; i < bus_cur->noPFMemRanges; i++) {
1818 debug_pci ("rangeno is %d\n", range->rangeno);
1819 debug_pci ("[%x - %x]\n", range->start, range->end);
1820 range = range->next;
1821 }
1822 }
1823
1824 debug_pci ("The resources on this bus are as follows\n");
1825
1826 debug_pci ("IO...\n");
1827 if (bus_cur->firstIO) {
1828 res = bus_cur->firstIO;
1829 while (res) {
1830 debug_pci ("The range # is %d\n", res->rangeno);
1831 debug_pci ("The bus, devfnc is %d, %x\n", res->busno, res->devfunc);
1832 debug_pci ("[%x - %x], len=%x\n", res->start, res->end, res->len);
1833 if (res->next)
1834 res = res->next;
1835 else if (res->nextRange)
1836 res = res->nextRange;
1837 else
1838 break;
1839 }
1840 }
1841 debug_pci ("Mem...\n");
1842 if (bus_cur->firstMem) {
1843 res = bus_cur->firstMem;
1844 while (res) {
1845 debug_pci ("The range # is %d\n", res->rangeno);
1846 debug_pci ("The bus, devfnc is %d, %x\n", res->busno, res->devfunc);
1847 debug_pci ("[%x - %x], len=%x\n", res->start, res->end, res->len);
1848 if (res->next)
1849 res = res->next;
1850 else if (res->nextRange)
1851 res = res->nextRange;
1852 else
1853 break;
1854 }
1855 }
1856 debug_pci ("PFMem...\n");
1857 if (bus_cur->firstPFMem) {
1858 res = bus_cur->firstPFMem;
1859 while (res) {
1860 debug_pci ("The range # is %d\n", res->rangeno);
1861 debug_pci ("The bus, devfnc is %d, %x\n", res->busno, res->devfunc);
1862 debug_pci ("[%x - %x], len=%x\n", res->start, res->end, res->len);
1863 if (res->next)
1864 res = res->next;
1865 else if (res->nextRange)
1866 res = res->nextRange;
1867 else
1868 break;
1869 }
1870 }
1871
1872 debug_pci ("PFMemFromMem...\n");
1873 if (bus_cur->firstPFMemFromMem) {
1874 res = bus_cur->firstPFMemFromMem;
1875 while (res) {
1876 debug_pci ("The range # is %d\n", res->rangeno);
1877 debug_pci ("The bus, devfnc is %d, %x\n", res->busno, res->devfunc);
1878 debug_pci ("[%x - %x], len=%x\n", res->start, res->end, res->len);
1879 res = res->next;
1880 }
1881 }
1882 }
1883 debug_pci ("***********************END***********************\n");
1884 }
1885
1886 static int range_exists_already (struct range_node * range, struct bus_node * bus_cur, u8 type)
1887 {
1888 struct range_node * range_cur = NULL;
1889 switch (type) {
1890 case IO:
1891 range_cur = bus_cur->rangeIO;
1892 break;
1893 case MEM:
1894 range_cur = bus_cur->rangeMem;
1895 break;
1896 case PFMEM:
1897 range_cur = bus_cur->rangePFMem;
1898 break;
1899 default:
1900 err ("wrong type passed to find out if range already exists\n");
1901 return -ENODEV;
1902 }
1903
1904 while (range_cur) {
1905 if ((range_cur->start == range->start) && (range_cur->end == range->end))
1906 return 1;
1907 range_cur = range_cur->next;
1908 }
1909
1910 return 0;
1911 }
1912
1913 /* This routine will read the windows for any PPB we have and update the
1914 * range info for the secondary bus, and will also input this info into
1915 * primary bus, since BIOS doesn't. This is for PPB that are in the system
1916 * on bootup. For bridged cards that were added during previous load of the
1917 * driver, only the ranges and the bus structure are added, the devices are
1918 * added from NVRAM
1919 * Input: primary busno
1920 * Returns: none
1921 * Note: this function doesn't take into account IO restrictions etc,
1922 * so will only work for bridges with no video/ISA devices behind them It
1923 * also will not work for onboard PPB's that can have more than 1 *bus
1924 * behind them All these are TO DO.
1925 * Also need to add more error checkings... (from fnc returns etc)
1926 */
1927 static int __init update_bridge_ranges (struct bus_node **bus)
1928 {
1929 u8 sec_busno, device, function, hdr_type, start_io_address, end_io_address;
1930 u16 vendor_id, upper_io_start, upper_io_end, start_mem_address, end_mem_address;
1931 u32 start_address, end_address, upper_start, upper_end;
1932 struct bus_node *bus_sec;
1933 struct bus_node *bus_cur;
1934 struct resource_node *io;
1935 struct resource_node *mem;
1936 struct resource_node *pfmem;
1937 struct range_node *range;
1938 unsigned int devfn;
1939
1940 bus_cur = *bus;
1941 if (!bus_cur)
1942 return -ENODEV;
1943 ibmphp_pci_bus->number = bus_cur->busno;
1944
1945 debug ("inside %s\n", __func__);
1946 debug ("bus_cur->busno = %x\n", bus_cur->busno);
1947
1948 for (device = 0; device < 32; device++) {
1949 for (function = 0x00; function < 0x08; function++) {
1950 devfn = PCI_DEVFN(device, function);
1951 pci_bus_read_config_word (ibmphp_pci_bus, devfn, PCI_VENDOR_ID, &vendor_id);
1952
1953 if (vendor_id != PCI_VENDOR_ID_NOTVALID) {
1954 /* found correct device!!! */
1955 pci_bus_read_config_byte (ibmphp_pci_bus, devfn, PCI_HEADER_TYPE, &hdr_type);
1956
1957 switch (hdr_type) {
1958 case PCI_HEADER_TYPE_NORMAL:
1959 function = 0x8;
1960 break;
1961 case PCI_HEADER_TYPE_MULTIDEVICE:
1962 break;
1963 case PCI_HEADER_TYPE_BRIDGE:
1964 function = 0x8;
1965 case PCI_HEADER_TYPE_MULTIBRIDGE:
1966 /* We assume here that only 1 bus behind the bridge
1967 TO DO: add functionality for several:
1968 temp = secondary;
1969 while (temp < subordinate) {
1970 ...
1971 temp++;
1972 }
1973 */
1974 pci_bus_read_config_byte (ibmphp_pci_bus, devfn, PCI_SECONDARY_BUS, &sec_busno);
1975 bus_sec = find_bus_wprev (sec_busno, NULL, 0);
1976 /* this bus structure doesn't exist yet, PPB was configured during previous loading of ibmphp */
1977 if (!bus_sec) {
1978 bus_sec = alloc_error_bus (NULL, sec_busno, 1);
1979 /* the rest will be populated during NVRAM call */
1980 return 0;
1981 }
1982 pci_bus_read_config_byte (ibmphp_pci_bus, devfn, PCI_IO_BASE, &start_io_address);
1983 pci_bus_read_config_byte (ibmphp_pci_bus, devfn, PCI_IO_LIMIT, &end_io_address);
1984 pci_bus_read_config_word (ibmphp_pci_bus, devfn, PCI_IO_BASE_UPPER16, &upper_io_start);
1985 pci_bus_read_config_word (ibmphp_pci_bus, devfn, PCI_IO_LIMIT_UPPER16, &upper_io_end);
1986 start_address = (start_io_address & PCI_IO_RANGE_MASK) << 8;
1987 start_address |= (upper_io_start << 16);
1988 end_address = (end_io_address & PCI_IO_RANGE_MASK) << 8;
1989 end_address |= (upper_io_end << 16);
1990
1991 if ((start_address) && (start_address <= end_address)) {
1992 range = kzalloc(sizeof(struct range_node), GFP_KERNEL);
1993 if (!range) {
1994 err ("out of system memory\n");
1995 return -ENOMEM;
1996 }
1997 range->start = start_address;
1998 range->end = end_address + 0xfff;
1999
2000 if (bus_sec->noIORanges > 0) {
2001 if (!range_exists_already (range, bus_sec, IO)) {
2002 add_bus_range (IO, range, bus_sec);
2003 ++bus_sec->noIORanges;
2004 } else {
2005 kfree (range);
2006 range = NULL;
2007 }
2008 } else {
2009 /* 1st IO Range on the bus */
2010 range->rangeno = 1;
2011 bus_sec->rangeIO = range;
2012 ++bus_sec->noIORanges;
2013 }
2014 fix_resources (bus_sec);
2015
2016 if (ibmphp_find_resource (bus_cur, start_address, &io, IO)) {
2017 io = kzalloc(sizeof(struct resource_node), GFP_KERNEL);
2018 if (!io) {
2019 kfree (range);
2020 err ("out of system memory\n");
2021 return -ENOMEM;
2022 }
2023 io->type = IO;
2024 io->busno = bus_cur->busno;
2025 io->devfunc = ((device << 3) | (function & 0x7));
2026 io->start = start_address;
2027 io->end = end_address + 0xfff;
2028 io->len = io->end - io->start + 1;
2029 ibmphp_add_resource (io);
2030 }
2031 }
2032
2033 pci_bus_read_config_word (ibmphp_pci_bus, devfn, PCI_MEMORY_BASE, &start_mem_address);
2034 pci_bus_read_config_word (ibmphp_pci_bus, devfn, PCI_MEMORY_LIMIT, &end_mem_address);
2035
2036 start_address = 0x00000000 | (start_mem_address & PCI_MEMORY_RANGE_MASK) << 16;
2037 end_address = 0x00000000 | (end_mem_address & PCI_MEMORY_RANGE_MASK) << 16;
2038
2039 if ((start_address) && (start_address <= end_address)) {
2040
2041 range = kzalloc(sizeof(struct range_node), GFP_KERNEL);
2042 if (!range) {
2043 err ("out of system memory\n");
2044 return -ENOMEM;
2045 }
2046 range->start = start_address;
2047 range->end = end_address + 0xfffff;
2048
2049 if (bus_sec->noMemRanges > 0) {
2050 if (!range_exists_already (range, bus_sec, MEM)) {
2051 add_bus_range (MEM, range, bus_sec);
2052 ++bus_sec->noMemRanges;
2053 } else {
2054 kfree (range);
2055 range = NULL;
2056 }
2057 } else {
2058 /* 1st Mem Range on the bus */
2059 range->rangeno = 1;
2060 bus_sec->rangeMem = range;
2061 ++bus_sec->noMemRanges;
2062 }
2063
2064 fix_resources (bus_sec);
2065
2066 if (ibmphp_find_resource (bus_cur, start_address, &mem, MEM)) {
2067 mem = kzalloc(sizeof(struct resource_node), GFP_KERNEL);
2068 if (!mem) {
2069 kfree (range);
2070 err ("out of system memory\n");
2071 return -ENOMEM;
2072 }
2073 mem->type = MEM;
2074 mem->busno = bus_cur->busno;
2075 mem->devfunc = ((device << 3) | (function & 0x7));
2076 mem->start = start_address;
2077 mem->end = end_address + 0xfffff;
2078 mem->len = mem->end - mem->start + 1;
2079 ibmphp_add_resource (mem);
2080 }
2081 }
2082 pci_bus_read_config_word (ibmphp_pci_bus, devfn, PCI_PREF_MEMORY_BASE, &start_mem_address);
2083 pci_bus_read_config_word (ibmphp_pci_bus, devfn, PCI_PREF_MEMORY_LIMIT, &end_mem_address);
2084 pci_bus_read_config_dword (ibmphp_pci_bus, devfn, PCI_PREF_BASE_UPPER32, &upper_start);
2085 pci_bus_read_config_dword (ibmphp_pci_bus, devfn, PCI_PREF_LIMIT_UPPER32, &upper_end);
2086 start_address = 0x00000000 | (start_mem_address & PCI_MEMORY_RANGE_MASK) << 16;
2087 end_address = 0x00000000 | (end_mem_address & PCI_MEMORY_RANGE_MASK) << 16;
2088 #if BITS_PER_LONG == 64
2089 start_address |= ((long) upper_start) << 32;
2090 end_address |= ((long) upper_end) << 32;
2091 #endif
2092
2093 if ((start_address) && (start_address <= end_address)) {
2094
2095 range = kzalloc(sizeof(struct range_node), GFP_KERNEL);
2096 if (!range) {
2097 err ("out of system memory\n");
2098 return -ENOMEM;
2099 }
2100 range->start = start_address;
2101 range->end = end_address + 0xfffff;
2102
2103 if (bus_sec->noPFMemRanges > 0) {
2104 if (!range_exists_already (range, bus_sec, PFMEM)) {
2105 add_bus_range (PFMEM, range, bus_sec);
2106 ++bus_sec->noPFMemRanges;
2107 } else {
2108 kfree (range);
2109 range = NULL;
2110 }
2111 } else {
2112 /* 1st PFMem Range on the bus */
2113 range->rangeno = 1;
2114 bus_sec->rangePFMem = range;
2115 ++bus_sec->noPFMemRanges;
2116 }
2117
2118 fix_resources (bus_sec);
2119 if (ibmphp_find_resource (bus_cur, start_address, &pfmem, PFMEM)) {
2120 pfmem = kzalloc(sizeof(struct resource_node), GFP_KERNEL);
2121 if (!pfmem) {
2122 kfree (range);
2123 err ("out of system memory\n");
2124 return -ENOMEM;
2125 }
2126 pfmem->type = PFMEM;
2127 pfmem->busno = bus_cur->busno;
2128 pfmem->devfunc = ((device << 3) | (function & 0x7));
2129 pfmem->start = start_address;
2130 pfmem->end = end_address + 0xfffff;
2131 pfmem->len = pfmem->end - pfmem->start + 1;
2132 pfmem->fromMem = 0;
2133
2134 ibmphp_add_resource (pfmem);
2135 }
2136 }
2137 break;
2138 } /* end of switch */
2139 } /* end if vendor */
2140 } /* end for function */
2141 } /* end for device */
2142
2143 bus = &bus_cur;
2144 return 0;
2145 }