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