?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Merge branch 'r6040-next'
[linux/fpc-iii.git] / drivers / pci / hotplug / ibmphp_res.c
blobaee6e41001e1950a5dcfdfb12d4357570b10ecea
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 resource_node *new_io = NULL;
207 struct resource_node *new_mem = NULL;
208 struct resource_node *new_pfmem = NULL;
209 int rc;
210
211 list_for_each_entry(curr, &ibmphp_ebda_pci_rsrc_head,
212 ebda_pci_rsrc_list) {
213 if (!(curr->rsrc_type & PCIDEVMASK)) {
214 /* EBDA still lists non PCI devices, so ignore... */
215 debug("this is not a PCI DEVICE in rsrc_init, please take care\n");
216 // continue;
217 }
218
219 /* this is a primary bus resource */
220 if (curr->rsrc_type & PRIMARYBUSMASK) {
221 /* memory */
222 if ((curr->rsrc_type & RESTYPE) == MMASK) {
223 /* no bus structure exists in place yet */
224 if (list_empty(&gbuses)) {
225 rc = alloc_bus_range(&newbus, &newrange, curr, MEM, 1);
226 if (rc)
227 return rc;
228 list_add_tail(&newbus->bus_list, &gbuses);
229 debug("gbuses = NULL, Memory Primary Bus %x [%x - %x]\n", newbus->busno, newrange->start, newrange->end);
230 } else {
231 bus_cur = find_bus_wprev(curr->bus_num, &bus_prev, 1);
232 /* found our bus */
233 if (bus_cur) {
234 rc = alloc_bus_range(&bus_cur, &newrange, curr, MEM, 0);
235 if (rc)
236 return rc;
237 } else {
238 /* went through all the buses and didn't find ours, need to create a new bus node */
239 rc = alloc_bus_range(&newbus, &newrange, curr, MEM, 1);
240 if (rc)
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 rc = alloc_bus_range(&newbus, &newrange, curr, PFMEM, 1);
252 if (rc)
253 return rc;
254 list_add_tail(&newbus->bus_list, &gbuses);
255 debug("gbuses = NULL, PFMemory Primary Bus %x [%x - %x]\n", newbus->busno, newrange->start, newrange->end);
256 } else {
257 bus_cur = find_bus_wprev(curr->bus_num, &bus_prev, 1);
258 if (bus_cur) {
259 /* found our bus */
260 rc = alloc_bus_range(&bus_cur, &newrange, curr, PFMEM, 0);
261 if (rc)
262 return rc;
263 } else {
264 /* went through all the buses and didn't find ours, need to create a new bus node */
265 rc = alloc_bus_range(&newbus, &newrange, curr, PFMEM, 1);
266 if (rc)
267 return rc;
268 list_add_tail(&newbus->bus_list, &gbuses);
269 debug("1st Bus, PFMemory Primary Bus %x [%x - %x]\n", newbus->busno, newrange->start, newrange->end);
270 }
271 }
272 } else if ((curr->rsrc_type & RESTYPE) == IOMASK) {
273 /* IO */
274 if (list_empty(&gbuses)) {
275 /* no bus structure exists in place yet */
276 rc = alloc_bus_range(&newbus, &newrange, curr, IO, 1);
277 if (rc)
278 return rc;
279 list_add_tail(&newbus->bus_list, &gbuses);
280 debug("gbuses = NULL, IO Primary Bus %x [%x - %x]\n", newbus->busno, newrange->start, newrange->end);
281 } else {
282 bus_cur = find_bus_wprev(curr->bus_num, &bus_prev, 1);
283 if (bus_cur) {
284 rc = alloc_bus_range(&bus_cur, &newrange, curr, IO, 0);
285 if (rc)
286 return rc;
287 } else {
288 /* went through all the buses and didn't find ours, need to create a new bus node */
289 rc = alloc_bus_range(&newbus, &newrange, curr, IO, 1);
290 if (rc)
291 return rc;
292 list_add_tail(&newbus->bus_list, &gbuses);
293 debug("1st Bus, IO Primary Bus %x [%x - %x]\n", newbus->busno, newrange->start, newrange->end);
294 }
295 }
296
297 } else {
298 ; /* type is reserved WHAT TO DO IN THIS CASE???
299 NOTHING TO DO??? */
300 }
301 } else {
302 /* regular pci device resource */
303 if ((curr->rsrc_type & RESTYPE) == MMASK) {
304 /* Memory resource */
305 new_mem = alloc_resources(curr);
306 if (!new_mem)
307 return -ENOMEM;
308 new_mem->type = MEM;
309 /*
310 * if it didn't find the bus, means PCI dev
311 * came b4 the Primary Bus info, so need to
312 * create a bus rangeno becomes a problem...
313 * assign a -1 and then update once the range
314 * actually appears...
315 */
316 if (ibmphp_add_resource(new_mem) < 0) {
317 newbus = alloc_error_bus(curr, 0, 0);
318 if (!newbus)
319 return -ENOMEM;
320 newbus->firstMem = new_mem;
321 ++newbus->needMemUpdate;
322 new_mem->rangeno = -1;
323 }
324 debug("Memory resource for device %x, bus %x, [%x - %x]\n", new_mem->devfunc, new_mem->busno, new_mem->start, new_mem->end);
325
326 } else if ((curr->rsrc_type & RESTYPE) == PFMASK) {
327 /* PFMemory resource */
328 new_pfmem = alloc_resources(curr);
329 if (!new_pfmem)
330 return -ENOMEM;
331 new_pfmem->type = PFMEM;
332 new_pfmem->fromMem = 0;
333 if (ibmphp_add_resource(new_pfmem) < 0) {
334 newbus = alloc_error_bus(curr, 0, 0);
335 if (!newbus)
336 return -ENOMEM;
337 newbus->firstPFMem = new_pfmem;
338 ++newbus->needPFMemUpdate;
339 new_pfmem->rangeno = -1;
340 }
341
342 debug("PFMemory resource for device %x, bus %x, [%x - %x]\n", new_pfmem->devfunc, new_pfmem->busno, new_pfmem->start, new_pfmem->end);
343 } else if ((curr->rsrc_type & RESTYPE) == IOMASK) {
344 /* IO resource */
345 new_io = alloc_resources(curr);
346 if (!new_io)
347 return -ENOMEM;
348 new_io->type = IO;
349
350 /*
351 * if it didn't find the bus, means PCI dev
352 * came b4 the Primary Bus info, so need to
353 * create a bus rangeno becomes a problem...
354 * Can assign a -1 and then update once the
355 * range actually appears...
356 */
357 if (ibmphp_add_resource(new_io) < 0) {
358 newbus = alloc_error_bus(curr, 0, 0);
359 if (!newbus)
360 return -ENOMEM;
361 newbus->firstIO = new_io;
362 ++newbus->needIOUpdate;
363 new_io->rangeno = -1;
364 }
365 debug("IO resource for device %x, bus %x, [%x - %x]\n", new_io->devfunc, new_io->busno, new_io->start, new_io->end);
366 }
367 }
368 }
369
370 list_for_each_entry(bus_cur, &gbuses, bus_list) {
371 /* This is to get info about PPB resources, since EBDA doesn't put this info into the primary bus info */
372 rc = update_bridge_ranges(&bus_cur);
373 if (rc)
374 return rc;
375 }
376 return once_over(); /* This is to align ranges (so no -1) */
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, something'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 * Output: 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 bailing out...\n");
793 return -ENODEV;
794 }
795
796 switch (res->type) {
797 case IO:
798 res_cur = bus_cur->firstIO;
799 type = "io";
800 break;
801 case MEM:
802 res_cur = bus_cur->firstMem;
803 type = "mem";
804 break;
805 case PFMEM:
806 res_cur = bus_cur->firstPFMem;
807 type = "pfmem";
808 break;
809 default:
810 err("unknown type for resource to remove\n");
811 return -EINVAL;
812 }
813 res_prev = NULL;
814
815 while (res_cur) {
816 if ((res_cur->start == res->start) && (res_cur->end == res->end))
817 break;
818 res_prev = res_cur;
819 if (res_cur->next)
820 res_cur = res_cur->next;
821 else
822 res_cur = res_cur->nextRange;
823 }
824
825 if (!res_cur) {
826 if (res->type == PFMEM) {
827 /*
828 * case where pfmem might be in the PFMemFromMem list
829 * so will also need to remove the corresponding mem
830 * entry
831 */
832 res_cur = bus_cur->firstPFMemFromMem;
833 res_prev = NULL;
834
835 while (res_cur) {
836 if ((res_cur->start == res->start) && (res_cur->end == res->end)) {
837 mem_cur = bus_cur->firstMem;
838 while (mem_cur) {
839 if ((mem_cur->start == res_cur->start)
840 && (mem_cur->end == res_cur->end))
841 break;
842 if (mem_cur->next)
843 mem_cur = mem_cur->next;
844 else
845 mem_cur = mem_cur->nextRange;
846 }
847 if (!mem_cur) {
848 err("cannot find corresponding mem node for pfmem...\n");
849 return -EINVAL;
850 }
851
852 ibmphp_remove_resource(mem_cur);
853 if (!res_prev)
854 bus_cur->firstPFMemFromMem = res_cur->next;
855 else
856 res_prev->next = res_cur->next;
857 kfree(res_cur);
858 return 0;
859 }
860 res_prev = res_cur;
861 if (res_cur->next)
862 res_cur = res_cur->next;
863 else
864 res_cur = res_cur->nextRange;
865 }
866 if (!res_cur) {
867 err("cannot find pfmem to delete...\n");
868 return -EINVAL;
869 }
870 } else {
871 err("the %s resource is not in the list to be deleted...\n", type);
872 return -EINVAL;
873 }
874 }
875 if (!res_prev) {
876 /* first device to be deleted */
877 if (res_cur->next) {
878 switch (res->type) {
879 case IO:
880 bus_cur->firstIO = res_cur->next;
881 break;
882 case MEM:
883 bus_cur->firstMem = res_cur->next;
884 break;
885 case PFMEM:
886 bus_cur->firstPFMem = res_cur->next;
887 break;
888 }
889 } else if (res_cur->nextRange) {
890 switch (res->type) {
891 case IO:
892 bus_cur->firstIO = res_cur->nextRange;
893 break;
894 case MEM:
895 bus_cur->firstMem = res_cur->nextRange;
896 break;
897 case PFMEM:
898 bus_cur->firstPFMem = res_cur->nextRange;
899 break;
900 }
901 } else {
902 switch (res->type) {
903 case IO:
904 bus_cur->firstIO = NULL;
905 break;
906 case MEM:
907 bus_cur->firstMem = NULL;
908 break;
909 case PFMEM:
910 bus_cur->firstPFMem = NULL;
911 break;
912 }
913 }
914 kfree(res_cur);
915 return 0;
916 } else {
917 if (res_cur->next) {
918 if (res_prev->rangeno == res_cur->rangeno)
919 res_prev->next = res_cur->next;
920 else
921 res_prev->nextRange = res_cur->next;
922 } else if (res_cur->nextRange) {
923 res_prev->next = NULL;
924 res_prev->nextRange = res_cur->nextRange;
925 } else {
926 res_prev->next = NULL;
927 res_prev->nextRange = NULL;
928 }
929 kfree(res_cur);
930 return 0;
931 }
932
933 return 0;
934 }
935
936 static struct range_node *find_range(struct bus_node *bus_cur, struct resource_node *res)
937 {
938 struct range_node *range = NULL;
939
940 switch (res->type) {
941 case IO:
942 range = bus_cur->rangeIO;
943 break;
944 case MEM:
945 range = bus_cur->rangeMem;
946 break;
947 case PFMEM:
948 range = bus_cur->rangePFMem;
949 break;
950 default:
951 err("cannot read resource type in find_range\n");
952 }
953
954 while (range) {
955 if (res->rangeno == range->rangeno)
956 break;
957 range = range->next;
958 }
959 return range;
960 }
961
962 /*****************************************************************************
963 * This routine will check to make sure the io/mem/pfmem->len that the device asked for
964 * can fit w/i our list of available IO/MEM/PFMEM resources. If cannot, returns -EINVAL,
965 * otherwise, returns 0
966 *
967 * Input: resource
968 * Output: the correct start and end address are inputted into the resource node,
969 * 0 or -EINVAL
970 *****************************************************************************/
971 int ibmphp_check_resource(struct resource_node *res, u8 bridge)
972 {
973 struct bus_node *bus_cur;
974 struct range_node *range = NULL;
975 struct resource_node *res_prev;
976 struct resource_node *res_cur = NULL;
977 u32 len_cur = 0, start_cur = 0, len_tmp = 0;
978 int noranges = 0;
979 u32 tmp_start; /* this is to make sure start address is divisible by the length needed */
980 u32 tmp_divide;
981 u8 flag = 0;
982
983 if (!res)
984 return -EINVAL;
985
986 if (bridge) {
987 /* The rules for bridges are different, 4K divisible for IO, 1M for (pf)mem*/
988 if (res->type == IO)
989 tmp_divide = IOBRIDGE;
990 else
991 tmp_divide = MEMBRIDGE;
992 } else
993 tmp_divide = res->len;
994
995 bus_cur = find_bus_wprev(res->busno, NULL, 0);
996
997 if (!bus_cur) {
998 /* didn't find a bus, something's wrong!!! */
999 debug("no bus in the system, either pci_dev's wrong or allocation failed\n");
1000 return -EINVAL;
1001 }
1002
1003 debug("%s - enter\n", __func__);
1004 debug("bus_cur->busno is %d\n", bus_cur->busno);
1005
1006 /* This is a quick fix to not mess up with the code very much. i.e.,
1007 * 2000-2fff, len = 1000, but when we compare, we need it to be fff */
1008 res->len -= 1;
1009
1010 switch (res->type) {
1011 case IO:
1012 res_cur = bus_cur->firstIO;
1013 noranges = bus_cur->noIORanges;
1014 break;
1015 case MEM:
1016 res_cur = bus_cur->firstMem;
1017 noranges = bus_cur->noMemRanges;
1018 break;
1019 case PFMEM:
1020 res_cur = bus_cur->firstPFMem;
1021 noranges = bus_cur->noPFMemRanges;
1022 break;
1023 default:
1024 err("wrong type of resource to check\n");
1025 return -EINVAL;
1026 }
1027 res_prev = NULL;
1028
1029 while (res_cur) {
1030 range = find_range(bus_cur, res_cur);
1031 debug("%s - rangeno = %d\n", __func__, res_cur->rangeno);
1032
1033 if (!range) {
1034 err("no range for the device exists... bailing out...\n");
1035 return -EINVAL;
1036 }
1037
1038 /* found our range */
1039 if (!res_prev) {
1040 /* first time in the loop */
1041 len_tmp = res_cur->start - 1 - range->start;
1042
1043 if ((res_cur->start != range->start) && (len_tmp >= res->len)) {
1044 debug("len_tmp = %x\n", len_tmp);
1045
1046 if ((len_tmp < len_cur) || (len_cur == 0)) {
1047
1048 if ((range->start % tmp_divide) == 0) {
1049 /* just perfect, starting address is divisible by length */
1050 flag = 1;
1051 len_cur = len_tmp;
1052 start_cur = range->start;
1053 } else {
1054 /* Needs adjusting */
1055 tmp_start = range->start;
1056 flag = 0;
1057
1058 while ((len_tmp = res_cur->start - 1 - tmp_start) >= res->len) {
1059 if ((tmp_start % tmp_divide) == 0) {
1060 flag = 1;
1061 len_cur = len_tmp;
1062 start_cur = tmp_start;
1063 break;
1064 }
1065 tmp_start += tmp_divide - tmp_start % tmp_divide;
1066 if (tmp_start >= res_cur->start - 1)
1067 break;
1068 }
1069 }
1070
1071 if (flag && len_cur == res->len) {
1072 debug("but we are not here, right?\n");
1073 res->start = start_cur;
1074 res->len += 1; /* To restore the balance */
1075 res->end = res->start + res->len - 1;
1076 return 0;
1077 }
1078 }
1079 }
1080 }
1081 if (!res_cur->next) {
1082 /* last device on the range */
1083 len_tmp = range->end - (res_cur->end + 1);
1084
1085 if ((range->end != res_cur->end) && (len_tmp >= res->len)) {
1086 debug("len_tmp = %x\n", len_tmp);
1087 if ((len_tmp < len_cur) || (len_cur == 0)) {
1088
1089 if (((res_cur->end + 1) % tmp_divide) == 0) {
1090 /* just perfect, starting address is divisible by length */
1091 flag = 1;
1092 len_cur = len_tmp;
1093 start_cur = res_cur->end + 1;
1094 } else {
1095 /* Needs adjusting */
1096 tmp_start = res_cur->end + 1;
1097 flag = 0;
1098
1099 while ((len_tmp = range->end - tmp_start) >= res->len) {
1100 if ((tmp_start % tmp_divide) == 0) {
1101 flag = 1;
1102 len_cur = len_tmp;
1103 start_cur = tmp_start;
1104 break;
1105 }
1106 tmp_start += tmp_divide - tmp_start % tmp_divide;
1107 if (tmp_start >= range->end)
1108 break;
1109 }
1110 }
1111 if (flag && len_cur == res->len) {
1112 res->start = start_cur;
1113 res->len += 1; /* To restore the balance */
1114 res->end = res->start + res->len - 1;
1115 return 0;
1116 }
1117 }
1118 }
1119 }
1120
1121 if (res_prev) {
1122 if (res_prev->rangeno != res_cur->rangeno) {
1123 /* 1st device on this range */
1124 len_tmp = res_cur->start - 1 - range->start;
1125
1126 if ((res_cur->start != range->start) && (len_tmp >= res->len)) {
1127 if ((len_tmp < len_cur) || (len_cur == 0)) {
1128 if ((range->start % tmp_divide) == 0) {
1129 /* just perfect, starting address is divisible by length */
1130 flag = 1;
1131 len_cur = len_tmp;
1132 start_cur = range->start;
1133 } else {
1134 /* Needs adjusting */
1135 tmp_start = range->start;
1136 flag = 0;
1137
1138 while ((len_tmp = res_cur->start - 1 - tmp_start) >= res->len) {
1139 if ((tmp_start % tmp_divide) == 0) {
1140 flag = 1;
1141 len_cur = len_tmp;
1142 start_cur = tmp_start;
1143 break;
1144 }
1145 tmp_start += tmp_divide - tmp_start % tmp_divide;
1146 if (tmp_start >= res_cur->start - 1)
1147 break;
1148 }
1149 }
1150
1151 if (flag && len_cur == res->len) {
1152 res->start = start_cur;
1153 res->len += 1; /* To restore the balance */
1154 res->end = res->start + res->len - 1;
1155 return 0;
1156 }
1157 }
1158 }
1159 } else {
1160 /* in the same range */
1161 len_tmp = res_cur->start - 1 - res_prev->end - 1;
1162
1163 if (len_tmp >= res->len) {
1164 if ((len_tmp < len_cur) || (len_cur == 0)) {
1165 if (((res_prev->end + 1) % tmp_divide) == 0) {
1166 /* just perfect, starting address's divisible by length */
1167 flag = 1;
1168 len_cur = len_tmp;
1169 start_cur = res_prev->end + 1;
1170 } else {
1171 /* Needs adjusting */
1172 tmp_start = res_prev->end + 1;
1173 flag = 0;
1174
1175 while ((len_tmp = res_cur->start - 1 - tmp_start) >= res->len) {
1176 if ((tmp_start % tmp_divide) == 0) {
1177 flag = 1;
1178 len_cur = len_tmp;
1179 start_cur = tmp_start;
1180 break;
1181 }
1182 tmp_start += tmp_divide - tmp_start % tmp_divide;
1183 if (tmp_start >= res_cur->start - 1)
1184 break;
1185 }
1186 }
1187
1188 if (flag && len_cur == res->len) {
1189 res->start = start_cur;
1190 res->len += 1; /* To restore the balance */
1191 res->end = res->start + res->len - 1;
1192 return 0;
1193 }
1194 }
1195 }
1196 }
1197 }
1198 /* end if (res_prev) */
1199 res_prev = res_cur;
1200 if (res_cur->next)
1201 res_cur = res_cur->next;
1202 else
1203 res_cur = res_cur->nextRange;
1204 } /* end of while */
1205
1206
1207 if (!res_prev) {
1208 /* 1st device ever */
1209 /* need to find appropriate range */
1210 switch (res->type) {
1211 case IO:
1212 range = bus_cur->rangeIO;
1213 break;
1214 case MEM:
1215 range = bus_cur->rangeMem;
1216 break;
1217 case PFMEM:
1218 range = bus_cur->rangePFMem;
1219 break;
1220 }
1221 while (range) {
1222 len_tmp = range->end - range->start;
1223
1224 if (len_tmp >= res->len) {
1225 if ((len_tmp < len_cur) || (len_cur == 0)) {
1226 if ((range->start % tmp_divide) == 0) {
1227 /* just perfect, starting address's divisible by length */
1228 flag = 1;
1229 len_cur = len_tmp;
1230 start_cur = range->start;
1231 } else {
1232 /* Needs adjusting */
1233 tmp_start = range->start;
1234 flag = 0;
1235
1236 while ((len_tmp = range->end - tmp_start) >= res->len) {
1237 if ((tmp_start % tmp_divide) == 0) {
1238 flag = 1;
1239 len_cur = len_tmp;
1240 start_cur = tmp_start;
1241 break;
1242 }
1243 tmp_start += tmp_divide - tmp_start % tmp_divide;
1244 if (tmp_start >= range->end)
1245 break;
1246 }
1247 }
1248
1249 if (flag && len_cur == res->len) {
1250 res->start = start_cur;
1251 res->len += 1; /* To restore the balance */
1252 res->end = res->start + res->len - 1;
1253 return 0;
1254 }
1255 }
1256 }
1257 range = range->next;
1258 } /* end of while */
1259
1260 if ((!range) && (len_cur == 0)) {
1261 /* have gone through the list of devices and ranges and haven't found n.e.thing */
1262 err("no appropriate range.. bailing out...\n");
1263 return -EINVAL;
1264 } else if (len_cur) {
1265 res->start = start_cur;
1266 res->len += 1; /* To restore the balance */
1267 res->end = res->start + res->len - 1;
1268 return 0;
1269 }
1270 }
1271
1272 if (!res_cur) {
1273 debug("prev->rangeno = %d, noranges = %d\n", res_prev->rangeno, noranges);
1274 if (res_prev->rangeno < noranges) {
1275 /* if there're more ranges out there to check */
1276 switch (res->type) {
1277 case IO:
1278 range = bus_cur->rangeIO;
1279 break;
1280 case MEM:
1281 range = bus_cur->rangeMem;
1282 break;
1283 case PFMEM:
1284 range = bus_cur->rangePFMem;
1285 break;
1286 }
1287 while (range) {
1288 len_tmp = range->end - range->start;
1289
1290 if (len_tmp >= res->len) {
1291 if ((len_tmp < len_cur) || (len_cur == 0)) {
1292 if ((range->start % tmp_divide) == 0) {
1293 /* just perfect, starting address's divisible by length */
1294 flag = 1;
1295 len_cur = len_tmp;
1296 start_cur = range->start;
1297 } else {
1298 /* Needs adjusting */
1299 tmp_start = range->start;
1300 flag = 0;
1301
1302 while ((len_tmp = range->end - tmp_start) >= res->len) {
1303 if ((tmp_start % tmp_divide) == 0) {
1304 flag = 1;
1305 len_cur = len_tmp;
1306 start_cur = tmp_start;
1307 break;
1308 }
1309 tmp_start += tmp_divide - tmp_start % tmp_divide;
1310 if (tmp_start >= range->end)
1311 break;
1312 }
1313 }
1314
1315 if (flag && len_cur == res->len) {
1316 res->start = start_cur;
1317 res->len += 1; /* To restore the balance */
1318 res->end = res->start + res->len - 1;
1319 return 0;
1320 }
1321 }
1322 }
1323 range = range->next;
1324 } /* end of while */
1325
1326 if ((!range) && (len_cur == 0)) {
1327 /* have gone through the list of devices and ranges and haven't found n.e.thing */
1328 err("no appropriate range.. bailing out...\n");
1329 return -EINVAL;
1330 } else if (len_cur) {
1331 res->start = start_cur;
1332 res->len += 1; /* To restore the balance */
1333 res->end = res->start + res->len - 1;
1334 return 0;
1335 }
1336 } else {
1337 /* no more ranges to check on */
1338 if (len_cur) {
1339 res->start = start_cur;
1340 res->len += 1; /* To restore the balance */
1341 res->end = res->start + res->len - 1;
1342 return 0;
1343 } else {
1344 /* have gone through the list of devices and haven't found n.e.thing */
1345 err("no appropriate range.. bailing out...\n");
1346 return -EINVAL;
1347 }
1348 }
1349 } /* end if (!res_cur) */
1350 return -EINVAL;
1351 }
1352
1353 /********************************************************************************
1354 * This routine is called from remove_card if the card contained PPB.
1355 * It will remove all the resources on the bus as well as the bus itself
1356 * Input: Bus
1357 * Output: 0, -ENODEV
1358 ********************************************************************************/
1359 int ibmphp_remove_bus(struct bus_node *bus, u8 parent_busno)
1360 {
1361 struct resource_node *res_cur;
1362 struct resource_node *res_tmp;
1363 struct bus_node *prev_bus;
1364 int rc;
1365
1366 prev_bus = find_bus_wprev(parent_busno, NULL, 0);
1367
1368 if (!prev_bus) {
1369 debug("something terribly wrong. Cannot find parent bus to the one to remove\n");
1370 return -ENODEV;
1371 }
1372
1373 debug("In ibmphp_remove_bus... prev_bus->busno is %x\n", prev_bus->busno);
1374
1375 rc = remove_ranges(bus, prev_bus);
1376 if (rc)
1377 return rc;
1378
1379 if (bus->firstIO) {
1380 res_cur = bus->firstIO;
1381 while (res_cur) {
1382 res_tmp = res_cur;
1383 if (res_cur->next)
1384 res_cur = res_cur->next;
1385 else
1386 res_cur = res_cur->nextRange;
1387 kfree(res_tmp);
1388 res_tmp = NULL;
1389 }
1390 bus->firstIO = NULL;
1391 }
1392 if (bus->firstMem) {
1393 res_cur = bus->firstMem;
1394 while (res_cur) {
1395 res_tmp = res_cur;
1396 if (res_cur->next)
1397 res_cur = res_cur->next;
1398 else
1399 res_cur = res_cur->nextRange;
1400 kfree(res_tmp);
1401 res_tmp = NULL;
1402 }
1403 bus->firstMem = NULL;
1404 }
1405 if (bus->firstPFMem) {
1406 res_cur = bus->firstPFMem;
1407 while (res_cur) {
1408 res_tmp = res_cur;
1409 if (res_cur->next)
1410 res_cur = res_cur->next;
1411 else
1412 res_cur = res_cur->nextRange;
1413 kfree(res_tmp);
1414 res_tmp = NULL;
1415 }
1416 bus->firstPFMem = NULL;
1417 }
1418
1419 if (bus->firstPFMemFromMem) {
1420 res_cur = bus->firstPFMemFromMem;
1421 while (res_cur) {
1422 res_tmp = res_cur;
1423 res_cur = res_cur->next;
1424
1425 kfree(res_tmp);
1426 res_tmp = NULL;
1427 }
1428 bus->firstPFMemFromMem = NULL;
1429 }
1430
1431 list_del(&bus->bus_list);
1432 kfree(bus);
1433 return 0;
1434 }
1435
1436 /******************************************************************************
1437 * This routine deletes the ranges from a given bus, and the entries from the
1438 * parent's bus in the resources
1439 * Input: current bus, previous bus
1440 * Output: 0, -EINVAL
1441 ******************************************************************************/
1442 static int remove_ranges(struct bus_node *bus_cur, struct bus_node *bus_prev)
1443 {
1444 struct range_node *range_cur;
1445 struct range_node *range_tmp;
1446 int i;
1447 struct resource_node *res = NULL;
1448
1449 if (bus_cur->noIORanges) {
1450 range_cur = bus_cur->rangeIO;
1451 for (i = 0; i < bus_cur->noIORanges; i++) {
1452 if (ibmphp_find_resource(bus_prev, range_cur->start, &res, IO) < 0)
1453 return -EINVAL;
1454 ibmphp_remove_resource(res);
1455
1456 range_tmp = range_cur;
1457 range_cur = range_cur->next;
1458 kfree(range_tmp);
1459 range_tmp = NULL;
1460 }
1461 bus_cur->rangeIO = NULL;
1462 }
1463 if (bus_cur->noMemRanges) {
1464 range_cur = bus_cur->rangeMem;
1465 for (i = 0; i < bus_cur->noMemRanges; i++) {
1466 if (ibmphp_find_resource(bus_prev, range_cur->start, &res, MEM) < 0)
1467 return -EINVAL;
1468
1469 ibmphp_remove_resource(res);
1470 range_tmp = range_cur;
1471 range_cur = range_cur->next;
1472 kfree(range_tmp);
1473 range_tmp = NULL;
1474 }
1475 bus_cur->rangeMem = NULL;
1476 }
1477 if (bus_cur->noPFMemRanges) {
1478 range_cur = bus_cur->rangePFMem;
1479 for (i = 0; i < bus_cur->noPFMemRanges; i++) {
1480 if (ibmphp_find_resource(bus_prev, range_cur->start, &res, PFMEM) < 0)
1481 return -EINVAL;
1482
1483 ibmphp_remove_resource(res);
1484 range_tmp = range_cur;
1485 range_cur = range_cur->next;
1486 kfree(range_tmp);
1487 range_tmp = NULL;
1488 }
1489 bus_cur->rangePFMem = NULL;
1490 }
1491 return 0;
1492 }
1493
1494 /*
1495 * find the resource node in the bus
1496 * Input: Resource needed, start address of the resource, type of resource
1497 */
1498 int ibmphp_find_resource(struct bus_node *bus, u32 start_address, struct resource_node **res, int flag)
1499 {
1500 struct resource_node *res_cur = NULL;
1501 char *type = "";
1502
1503 if (!bus) {
1504 err("The bus passed in NULL to find resource\n");
1505 return -ENODEV;
1506 }
1507
1508 switch (flag) {
1509 case IO:
1510 res_cur = bus->firstIO;
1511 type = "io";
1512 break;
1513 case MEM:
1514 res_cur = bus->firstMem;
1515 type = "mem";
1516 break;
1517 case PFMEM:
1518 res_cur = bus->firstPFMem;
1519 type = "pfmem";
1520 break;
1521 default:
1522 err("wrong type of flag\n");
1523 return -EINVAL;
1524 }
1525
1526 while (res_cur) {
1527 if (res_cur->start == start_address) {
1528 *res = res_cur;
1529 break;
1530 }
1531 if (res_cur->next)
1532 res_cur = res_cur->next;
1533 else
1534 res_cur = res_cur->nextRange;
1535 }
1536
1537 if (!res_cur) {
1538 if (flag == PFMEM) {
1539 res_cur = bus->firstPFMemFromMem;
1540 while (res_cur) {
1541 if (res_cur->start == start_address) {
1542 *res = res_cur;
1543 break;
1544 }
1545 res_cur = res_cur->next;
1546 }
1547 if (!res_cur) {
1548 debug("SOS...cannot find %s resource in the bus.\n", type);
1549 return -EINVAL;
1550 }
1551 } else {
1552 debug("SOS... cannot find %s resource in the bus.\n", type);
1553 return -EINVAL;
1554 }
1555 }
1556
1557 if (*res)
1558 debug("*res->start = %x\n", (*res)->start);
1559
1560 return 0;
1561 }
1562
1563 /***********************************************************************
1564 * This routine will free the resource structures used by the
1565 * system. It is called from cleanup routine for the module
1566 * Parameters: none
1567 * Returns: none
1568 ***********************************************************************/
1569 void ibmphp_free_resources(void)
1570 {
1571 struct bus_node *bus_cur = NULL, *next;
1572 struct bus_node *bus_tmp;
1573 struct range_node *range_cur;
1574 struct range_node *range_tmp;
1575 struct resource_node *res_cur;
1576 struct resource_node *res_tmp;
1577 int i = 0;
1578 flags = 1;
1579
1580 list_for_each_entry_safe(bus_cur, next, &gbuses, bus_list) {
1581 if (bus_cur->noIORanges) {
1582 range_cur = bus_cur->rangeIO;
1583 for (i = 0; i < bus_cur->noIORanges; i++) {
1584 if (!range_cur)
1585 break;
1586 range_tmp = range_cur;
1587 range_cur = range_cur->next;
1588 kfree(range_tmp);
1589 range_tmp = NULL;
1590 }
1591 }
1592 if (bus_cur->noMemRanges) {
1593 range_cur = bus_cur->rangeMem;
1594 for (i = 0; i < bus_cur->noMemRanges; i++) {
1595 if (!range_cur)
1596 break;
1597 range_tmp = range_cur;
1598 range_cur = range_cur->next;
1599 kfree(range_tmp);
1600 range_tmp = NULL;
1601 }
1602 }
1603 if (bus_cur->noPFMemRanges) {
1604 range_cur = bus_cur->rangePFMem;
1605 for (i = 0; i < bus_cur->noPFMemRanges; i++) {
1606 if (!range_cur)
1607 break;
1608 range_tmp = range_cur;
1609 range_cur = range_cur->next;
1610 kfree(range_tmp);
1611 range_tmp = NULL;
1612 }
1613 }
1614
1615 if (bus_cur->firstIO) {
1616 res_cur = bus_cur->firstIO;
1617 while (res_cur) {
1618 res_tmp = res_cur;
1619 if (res_cur->next)
1620 res_cur = res_cur->next;
1621 else
1622 res_cur = res_cur->nextRange;
1623 kfree(res_tmp);
1624 res_tmp = NULL;
1625 }
1626 bus_cur->firstIO = NULL;
1627 }
1628 if (bus_cur->firstMem) {
1629 res_cur = bus_cur->firstMem;
1630 while (res_cur) {
1631 res_tmp = res_cur;
1632 if (res_cur->next)
1633 res_cur = res_cur->next;
1634 else
1635 res_cur = res_cur->nextRange;
1636 kfree(res_tmp);
1637 res_tmp = NULL;
1638 }
1639 bus_cur->firstMem = NULL;
1640 }
1641 if (bus_cur->firstPFMem) {
1642 res_cur = bus_cur->firstPFMem;
1643 while (res_cur) {
1644 res_tmp = res_cur;
1645 if (res_cur->next)
1646 res_cur = res_cur->next;
1647 else
1648 res_cur = res_cur->nextRange;
1649 kfree(res_tmp);
1650 res_tmp = NULL;
1651 }
1652 bus_cur->firstPFMem = NULL;
1653 }
1654
1655 if (bus_cur->firstPFMemFromMem) {
1656 res_cur = bus_cur->firstPFMemFromMem;
1657 while (res_cur) {
1658 res_tmp = res_cur;
1659 res_cur = res_cur->next;
1660
1661 kfree(res_tmp);
1662 res_tmp = NULL;
1663 }
1664 bus_cur->firstPFMemFromMem = NULL;
1665 }
1666
1667 bus_tmp = bus_cur;
1668 list_del(&bus_cur->bus_list);
1669 kfree(bus_tmp);
1670 bus_tmp = NULL;
1671 }
1672 }
1673
1674 /*********************************************************************************
1675 * This function will go over the PFmem resources to check if the EBDA allocated
1676 * pfmem out of memory buckets of the bus. If so, it will change the range numbers
1677 * and a flag to indicate that this resource is out of memory. It will also move the
1678 * Pfmem out of the pfmem resource list to the PFMemFromMem list, and will create
1679 * a new Mem node
1680 * This routine is called right after initialization
1681 *******************************************************************************/
1682 static int __init once_over(void)
1683 {
1684 struct resource_node *pfmem_cur;
1685 struct resource_node *pfmem_prev;
1686 struct resource_node *mem;
1687 struct bus_node *bus_cur;
1688
1689 list_for_each_entry(bus_cur, &gbuses, bus_list) {
1690 if ((!bus_cur->rangePFMem) && (bus_cur->firstPFMem)) {
1691 for (pfmem_cur = bus_cur->firstPFMem, pfmem_prev = NULL; pfmem_cur; pfmem_prev = pfmem_cur, pfmem_cur = pfmem_cur->next) {
1692 pfmem_cur->fromMem = 1;
1693 if (pfmem_prev)
1694 pfmem_prev->next = pfmem_cur->next;
1695 else
1696 bus_cur->firstPFMem = pfmem_cur->next;
1697
1698 if (!bus_cur->firstPFMemFromMem)
1699 pfmem_cur->next = NULL;
1700 else
1701 /* we don't need to sort PFMemFromMem since we're using mem node for
1702 all the real work anyways, so just insert at the beginning of the
1703 list
1704 */
1705 pfmem_cur->next = bus_cur->firstPFMemFromMem;
1706
1707 bus_cur->firstPFMemFromMem = pfmem_cur;
1708
1709 mem = kzalloc(sizeof(struct resource_node), GFP_KERNEL);
1710 if (!mem) {
1711 err("out of system memory\n");
1712 return -ENOMEM;
1713 }
1714 mem->type = MEM;
1715 mem->busno = pfmem_cur->busno;
1716 mem->devfunc = pfmem_cur->devfunc;
1717 mem->start = pfmem_cur->start;
1718 mem->end = pfmem_cur->end;
1719 mem->len = pfmem_cur->len;
1720 if (ibmphp_add_resource(mem) < 0)
1721 err("Trouble...trouble... EBDA allocated pfmem from mem, but system doesn't display it has this space... unless not PCI device...\n");
1722 pfmem_cur->rangeno = mem->rangeno;
1723 } /* end for pfmem */
1724 } /* end if */
1725 } /* end list_for_each bus */
1726 return 0;
1727 }
1728
1729 int ibmphp_add_pfmem_from_mem(struct resource_node *pfmem)
1730 {
1731 struct bus_node *bus_cur = find_bus_wprev(pfmem->busno, NULL, 0);
1732
1733 if (!bus_cur) {
1734 err("cannot find bus of pfmem to add...\n");
1735 return -ENODEV;
1736 }
1737
1738 if (bus_cur->firstPFMemFromMem)
1739 pfmem->next = bus_cur->firstPFMemFromMem;
1740 else
1741 pfmem->next = NULL;
1742
1743 bus_cur->firstPFMemFromMem = pfmem;
1744
1745 return 0;
1746 }
1747
1748 /* This routine just goes through the buses to see if the bus already exists.
1749 * It is called from ibmphp_find_sec_number, to find out a secondary bus number for
1750 * bridged cards
1751 * Parameters: bus_number
1752 * Returns: Bus pointer or NULL
1753 */
1754 struct bus_node *ibmphp_find_res_bus(u8 bus_number)
1755 {
1756 return find_bus_wprev(bus_number, NULL, 0);
1757 }
1758
1759 static struct bus_node *find_bus_wprev(u8 bus_number, struct bus_node **prev, u8 flag)
1760 {
1761 struct bus_node *bus_cur;
1762
1763 list_for_each_entry(bus_cur, &gbuses, bus_list) {
1764 if (flag)
1765 *prev = list_prev_entry(bus_cur, bus_list);
1766 if (bus_cur->busno == bus_number)
1767 return bus_cur;
1768 }
1769
1770 return NULL;
1771 }
1772
1773 void ibmphp_print_test(void)
1774 {
1775 int i = 0;
1776 struct bus_node *bus_cur = NULL;
1777 struct range_node *range;
1778 struct resource_node *res;
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_entry(bus_cur, &gbuses, bus_list) {
1788 debug_pci ("This is bus # %d. There are\n", bus_cur->busno);
1789 debug_pci ("IORanges = %d\t", bus_cur->noIORanges);
1790 debug_pci ("MemRanges = %d\t", bus_cur->noMemRanges);
1791 debug_pci ("PFMemRanges = %d\n", bus_cur->noPFMemRanges);
1792 debug_pci ("The IO Ranges are as follows:\n");
1793 if (bus_cur->rangeIO) {
1794 range = bus_cur->rangeIO;
1795 for (i = 0; i < bus_cur->noIORanges; i++) {
1796 debug_pci("rangeno is %d\n", range->rangeno);
1797 debug_pci("[%x - %x]\n", range->start, range->end);
1798 range = range->next;
1799 }
1800 }
1801
1802 debug_pci("The Mem Ranges are as follows:\n");
1803 if (bus_cur->rangeMem) {
1804 range = bus_cur->rangeMem;
1805 for (i = 0; i < bus_cur->noMemRanges; i++) {
1806 debug_pci("rangeno is %d\n", range->rangeno);
1807 debug_pci("[%x - %x]\n", range->start, range->end);
1808 range = range->next;
1809 }
1810 }
1811
1812 debug_pci("The PFMem Ranges are as follows:\n");
1813
1814 if (bus_cur->rangePFMem) {
1815 range = bus_cur->rangePFMem;
1816 for (i = 0; i < bus_cur->noPFMemRanges; i++) {
1817 debug_pci("rangeno is %d\n", range->rangeno);
1818 debug_pci("[%x - %x]\n", range->start, range->end);
1819 range = range->next;
1820 }
1821 }
1822
1823 debug_pci("The resources on this bus are as follows\n");
1824
1825 debug_pci("IO...\n");
1826 if (bus_cur->firstIO) {
1827 res = bus_cur->firstIO;
1828 while (res) {
1829 debug_pci("The range # is %d\n", res->rangeno);
1830 debug_pci("The bus, devfnc is %d, %x\n", res->busno, res->devfunc);
1831 debug_pci("[%x - %x], len=%x\n", res->start, res->end, res->len);
1832 if (res->next)
1833 res = res->next;
1834 else if (res->nextRange)
1835 res = res->nextRange;
1836 else
1837 break;
1838 }
1839 }
1840 debug_pci("Mem...\n");
1841 if (bus_cur->firstMem) {
1842 res = bus_cur->firstMem;
1843 while (res) {
1844 debug_pci("The range # is %d\n", res->rangeno);
1845 debug_pci("The bus, devfnc is %d, %x\n", res->busno, res->devfunc);
1846 debug_pci("[%x - %x], len=%x\n", res->start, res->end, res->len);
1847 if (res->next)
1848 res = res->next;
1849 else if (res->nextRange)
1850 res = res->nextRange;
1851 else
1852 break;
1853 }
1854 }
1855 debug_pci("PFMem...\n");
1856 if (bus_cur->firstPFMem) {
1857 res = bus_cur->firstPFMem;
1858 while (res) {
1859 debug_pci("The range # is %d\n", res->rangeno);
1860 debug_pci("The bus, devfnc is %d, %x\n", res->busno, res->devfunc);
1861 debug_pci("[%x - %x], len=%x\n", res->start, res->end, res->len);
1862 if (res->next)
1863 res = res->next;
1864 else if (res->nextRange)
1865 res = res->nextRange;
1866 else
1867 break;
1868 }
1869 }
1870
1871 debug_pci("PFMemFromMem...\n");
1872 if (bus_cur->firstPFMemFromMem) {
1873 res = bus_cur->firstPFMemFromMem;
1874 while (res) {
1875 debug_pci("The range # is %d\n", res->rangeno);
1876 debug_pci("The bus, devfnc is %d, %x\n", res->busno, res->devfunc);
1877 debug_pci("[%x - %x], len=%x\n", res->start, res->end, res->len);
1878 res = res->next;
1879 }
1880 }
1881 }
1882 debug_pci("***********************END***********************\n");
1883 }
1884
1885 static int range_exists_already(struct range_node *range, struct bus_node *bus_cur, u8 type)
1886 {
1887 struct range_node *range_cur = NULL;
1888 switch (type) {
1889 case IO:
1890 range_cur = bus_cur->rangeIO;
1891 break;
1892 case MEM:
1893 range_cur = bus_cur->rangeMem;
1894 break;
1895 case PFMEM:
1896 range_cur = bus_cur->rangePFMem;
1897 break;
1898 default:
1899 err("wrong type passed to find out if range already exists\n");
1900 return -ENODEV;
1901 }
1902
1903 while (range_cur) {
1904 if ((range_cur->start == range->start) && (range_cur->end == range->end))
1905 return 1;
1906 range_cur = range_cur->next;
1907 }
1908
1909 return 0;
1910 }
1911
1912 /* This routine will read the windows for any PPB we have and update the
1913 * range info for the secondary bus, and will also input this info into
1914 * primary bus, since BIOS doesn't. This is for PPB that are in the system
1915 * on bootup. For bridged cards that were added during previous load of the
1916 * driver, only the ranges and the bus structure are added, the devices are
1917 * added from NVRAM
1918 * Input: primary busno
1919 * Returns: none
1920 * Note: this function doesn't take into account IO restrictions etc,
1921 * so will only work for bridges with no video/ISA devices behind them It
1922 * also will not work for onboard PPBs that can have more than 1 *bus
1923 * behind them All these are TO DO.
1924 * Also need to add more error checkings... (from fnc returns etc)
1925 */
1926 static int __init update_bridge_ranges(struct bus_node **bus)
1927 {
1928 u8 sec_busno, device, function, hdr_type, start_io_address, end_io_address;
1929 u16 vendor_id, upper_io_start, upper_io_end, start_mem_address, end_mem_address;
1930 u32 start_address, end_address, upper_start, upper_end;
1931 struct bus_node *bus_sec;
1932 struct bus_node *bus_cur;
1933 struct resource_node *io;
1934 struct resource_node *mem;
1935 struct resource_node *pfmem;
1936 struct range_node *range;
1937 unsigned int devfn;
1938
1939 bus_cur = *bus;
1940 if (!bus_cur)
1941 return -ENODEV;
1942 ibmphp_pci_bus->number = bus_cur->busno;
1943
1944 debug("inside %s\n", __func__);
1945 debug("bus_cur->busno = %x\n", bus_cur->busno);
1946
1947 for (device = 0; device < 32; device++) {
1948 for (function = 0x00; function < 0x08; function++) {
1949 devfn = PCI_DEVFN(device, function);
1950 pci_bus_read_config_word(ibmphp_pci_bus, devfn, PCI_VENDOR_ID, &vendor_id);
1951
1952 if (vendor_id != PCI_VENDOR_ID_NOTVALID) {
1953 /* found correct device!!! */
1954 pci_bus_read_config_byte(ibmphp_pci_bus, devfn, PCI_HEADER_TYPE, &hdr_type);
1955
1956 switch (hdr_type) {
1957 case PCI_HEADER_TYPE_NORMAL:
1958 function = 0x8;
1959 break;
1960 case PCI_HEADER_TYPE_MULTIDEVICE:
1961 break;
1962 case PCI_HEADER_TYPE_BRIDGE:
1963 function = 0x8;
1964 case PCI_HEADER_TYPE_MULTIBRIDGE:
1965 /* We assume here that only 1 bus behind the bridge
1966 TO DO: add functionality for several:
1967 temp = secondary;
1968 while (temp < subordinate) {
1969 ...
1970 temp++;
1971 }
1972 */
1973 pci_bus_read_config_byte(ibmphp_pci_bus, devfn, PCI_SECONDARY_BUS, &sec_busno);
1974 bus_sec = find_bus_wprev(sec_busno, NULL, 0);
1975 /* this bus structure doesn't exist yet, PPB was configured during previous loading of ibmphp */
1976 if (!bus_sec) {
1977 bus_sec = alloc_error_bus(NULL, sec_busno, 1);
1978 /* the rest will be populated during NVRAM call */
1979 return 0;
1980 }
1981 pci_bus_read_config_byte(ibmphp_pci_bus, devfn, PCI_IO_BASE, &start_io_address);
1982 pci_bus_read_config_byte(ibmphp_pci_bus, devfn, PCI_IO_LIMIT, &end_io_address);
1983 pci_bus_read_config_word(ibmphp_pci_bus, devfn, PCI_IO_BASE_UPPER16, &upper_io_start);
1984 pci_bus_read_config_word(ibmphp_pci_bus, devfn, PCI_IO_LIMIT_UPPER16, &upper_io_end);
1985 start_address = (start_io_address & PCI_IO_RANGE_MASK) << 8;
1986 start_address |= (upper_io_start << 16);
1987 end_address = (end_io_address & PCI_IO_RANGE_MASK) << 8;
1988 end_address |= (upper_io_end << 16);
1989
1990 if ((start_address) && (start_address <= end_address)) {
1991 range = kzalloc(sizeof(struct range_node), GFP_KERNEL);
1992 if (!range) {
1993 err("out of system memory\n");
1994 return -ENOMEM;
1995 }
1996 range->start = start_address;
1997 range->end = end_address + 0xfff;
1998
1999 if (bus_sec->noIORanges > 0) {
2000 if (!range_exists_already(range, bus_sec, IO)) {
2001 add_bus_range(IO, range, bus_sec);
2002 ++bus_sec->noIORanges;
2003 } else {
2004 kfree(range);
2005 range = NULL;
2006 }
2007 } else {
2008 /* 1st IO Range on the bus */
2009 range->rangeno = 1;
2010 bus_sec->rangeIO = range;
2011 ++bus_sec->noIORanges;
2012 }
2013 fix_resources(bus_sec);
2014
2015 if (ibmphp_find_resource(bus_cur, start_address, &io, IO)) {
2016 io = kzalloc(sizeof(struct resource_node), GFP_KERNEL);
2017 if (!io) {
2018 kfree(range);
2019 err("out of system memory\n");
2020 return -ENOMEM;
2021 }
2022 io->type = IO;
2023 io->busno = bus_cur->busno;
2024 io->devfunc = ((device << 3) | (function & 0x7));
2025 io->start = start_address;
2026 io->end = end_address + 0xfff;
2027 io->len = io->end - io->start + 1;
2028 ibmphp_add_resource(io);
2029 }
2030 }
2031
2032 pci_bus_read_config_word(ibmphp_pci_bus, devfn, PCI_MEMORY_BASE, &start_mem_address);
2033 pci_bus_read_config_word(ibmphp_pci_bus, devfn, PCI_MEMORY_LIMIT, &end_mem_address);
2034
2035 start_address = 0x00000000 | (start_mem_address & PCI_MEMORY_RANGE_MASK) << 16;
2036 end_address = 0x00000000 | (end_mem_address & PCI_MEMORY_RANGE_MASK) << 16;
2037
2038 if ((start_address) && (start_address <= end_address)) {
2039
2040 range = kzalloc(sizeof(struct range_node), GFP_KERNEL);
2041 if (!range) {
2042 err("out of system memory\n");
2043 return -ENOMEM;
2044 }
2045 range->start = start_address;
2046 range->end = end_address + 0xfffff;
2047
2048 if (bus_sec->noMemRanges > 0) {
2049 if (!range_exists_already(range, bus_sec, MEM)) {
2050 add_bus_range(MEM, range, bus_sec);
2051 ++bus_sec->noMemRanges;
2052 } else {
2053 kfree(range);
2054 range = NULL;
2055 }
2056 } else {
2057 /* 1st Mem Range on the bus */
2058 range->rangeno = 1;
2059 bus_sec->rangeMem = range;
2060 ++bus_sec->noMemRanges;
2061 }
2062
2063 fix_resources(bus_sec);
2064
2065 if (ibmphp_find_resource(bus_cur, start_address, &mem, MEM)) {
2066 mem = kzalloc(sizeof(struct resource_node), GFP_KERNEL);
2067 if (!mem) {
2068 kfree(range);
2069 err("out of system memory\n");
2070 return -ENOMEM;
2071 }
2072 mem->type = MEM;
2073 mem->busno = bus_cur->busno;
2074 mem->devfunc = ((device << 3) | (function & 0x7));
2075 mem->start = start_address;
2076 mem->end = end_address + 0xfffff;
2077 mem->len = mem->end - mem->start + 1;
2078 ibmphp_add_resource(mem);
2079 }
2080 }
2081 pci_bus_read_config_word(ibmphp_pci_bus, devfn, PCI_PREF_MEMORY_BASE, &start_mem_address);
2082 pci_bus_read_config_word(ibmphp_pci_bus, devfn, PCI_PREF_MEMORY_LIMIT, &end_mem_address);
2083 pci_bus_read_config_dword(ibmphp_pci_bus, devfn, PCI_PREF_BASE_UPPER32, &upper_start);
2084 pci_bus_read_config_dword(ibmphp_pci_bus, devfn, PCI_PREF_LIMIT_UPPER32, &upper_end);
2085 start_address = 0x00000000 | (start_mem_address & PCI_MEMORY_RANGE_MASK) << 16;
2086 end_address = 0x00000000 | (end_mem_address & PCI_MEMORY_RANGE_MASK) << 16;
2087 #if BITS_PER_LONG == 64
2088 start_address |= ((long) upper_start) << 32;
2089 end_address |= ((long) upper_end) << 32;
2090 #endif
2091
2092 if ((start_address) && (start_address <= end_address)) {
2093
2094 range = kzalloc(sizeof(struct range_node), GFP_KERNEL);
2095 if (!range) {
2096 err("out of system memory\n");
2097 return -ENOMEM;
2098 }
2099 range->start = start_address;
2100 range->end = end_address + 0xfffff;
2101
2102 if (bus_sec->noPFMemRanges > 0) {
2103 if (!range_exists_already(range, bus_sec, PFMEM)) {
2104 add_bus_range(PFMEM, range, bus_sec);
2105 ++bus_sec->noPFMemRanges;
2106 } else {
2107 kfree(range);
2108 range = NULL;
2109 }
2110 } else {
2111 /* 1st PFMem Range on the bus */
2112 range->rangeno = 1;
2113 bus_sec->rangePFMem = range;
2114 ++bus_sec->noPFMemRanges;
2115 }
2116
2117 fix_resources(bus_sec);
2118 if (ibmphp_find_resource(bus_cur, start_address, &pfmem, PFMEM)) {
2119 pfmem = kzalloc(sizeof(struct resource_node), GFP_KERNEL);
2120 if (!pfmem) {
2121 kfree(range);
2122 err("out of system memory\n");
2123 return -ENOMEM;
2124 }
2125 pfmem->type = PFMEM;
2126 pfmem->busno = bus_cur->busno;
2127 pfmem->devfunc = ((device << 3) | (function & 0x7));
2128 pfmem->start = start_address;
2129 pfmem->end = end_address + 0xfffff;
2130 pfmem->len = pfmem->end - pfmem->start + 1;
2131 pfmem->fromMem = 0;
2132
2133 ibmphp_add_resource(pfmem);
2134 }
2135 }
2136 break;
2137 } /* end of switch */
2138 } /* end if vendor */
2139 } /* end for function */
2140 } /* end for device */
2141
2142 bus = &bus_cur;
2143 return 0;
2144 }
Linux with added FPC-III support