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