2 * IBM Hot Plug Controller Driver
4 * Written By: Irene Zubarev, IBM Corporation
6 * Copyright (C) 2001 Greg Kroah-Hartman (greg@kroah.com)
7 * Copyright (C) 2001,2002 IBM Corp.
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.
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
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.
26 * Send feedback to <gregkh@us.ibm.com>
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>
37 static int flags
= 0; /* for testing */
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
);
47 static LIST_HEAD(gbuses
);
49 static struct bus_node
* __init
alloc_error_bus (struct ebda_pci_rsrc
*curr
, u8 busno
, int flag
)
51 struct bus_node
*newbus
;
53 if (!(curr
) && !(flag
)) {
54 err ("NULL pointer passed\n");
58 newbus
= kzalloc(sizeof(struct bus_node
), GFP_KERNEL
);
60 err ("out of system memory\n");
65 newbus
->busno
= busno
;
67 newbus
->busno
= curr
->bus_num
;
68 list_add_tail (&newbus
->bus_list
, &gbuses
);
72 static struct resource_node
* __init
alloc_resources (struct ebda_pci_rsrc
*curr
)
74 struct resource_node
*rs
;
77 err ("NULL passed to allocate\n");
81 rs
= kzalloc(sizeof(struct resource_node
), GFP_KERNEL
);
83 err ("out of system memory\n");
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;
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
)
96 struct bus_node
*newbus
;
97 struct range_node
*newrange
;
101 newbus
= kzalloc(sizeof(struct bus_node
), GFP_KERNEL
);
103 err ("out of system memory.\n");
106 newbus
->busno
= curr
->bus_num
;
111 num_ranges
= newbus
->noMemRanges
;
114 num_ranges
= newbus
->noPFMemRanges
;
117 num_ranges
= newbus
->noIORanges
;
122 newrange
= kzalloc(sizeof(struct range_node
), GFP_KERNEL
);
126 err ("out of system memory\n");
129 newrange
->start
= curr
->start_addr
;
130 newrange
->end
= curr
->end_addr
;
132 if (first_bus
|| (!num_ranges
))
133 newrange
->rangeno
= 1;
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
);
142 newbus
->rangeMem
= newrange
;
144 newbus
->noMemRanges
= 1;
146 debug ("First Memory Primary on bus %x, [%x - %x]\n", newbus
->busno
, newrange
->start
, newrange
->end
);
147 ++newbus
->noMemRanges
;
148 fix_resources (newbus
);
152 newbus
->rangeIO
= newrange
;
154 newbus
->noIORanges
= 1;
156 debug ("First IO Primary on bus %x, [%x - %x]\n", newbus
->busno
, newrange
->start
, newrange
->end
);
157 ++newbus
->noIORanges
;
158 fix_resources (newbus
);
162 newbus
->rangePFMem
= newrange
;
164 newbus
->noPFMemRanges
= 1;
166 debug ("1st PFMemory Primary on Bus %x [%x - %x]\n", newbus
->busno
, newrange
->start
, newrange
->end
);
167 ++newbus
->noPFMemRanges
;
168 fix_resources (newbus
);
175 *new_range
= newrange
;
181 * 1. The ranges are ordered. The buses are not ordered. (First come)
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)
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
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
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)
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
;
211 struct list_head
*tmp_ebda
;
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");
221 /* this is a primary bus resource */
222 if (curr
->rsrc_type
& PRIMARYBUSMASK
) {
224 if ((curr
->rsrc_type
& RESTYPE
) == MMASK
) {
225 /* no bus structure exists in place yet */
226 if (list_empty (&gbuses
)) {
227 if ((rc
= alloc_bus_range (&newbus
, &newrange
, curr
, MEM
, 1)))
229 list_add_tail (&newbus
->bus_list
, &gbuses
);
230 debug ("gbuses = NULL, Memory Primary Bus %x [%x - %x]\n", newbus
->busno
, newrange
->start
, newrange
->end
);
232 bus_cur
= find_bus_wprev (curr
->bus_num
, &bus_prev
, 1);
235 rc
= alloc_bus_range (&bus_cur
, &newrange
, curr
, MEM
, 0);
239 /* went through all the buses and didn't find ours, need to create a new bus node */
240 if ((rc
= alloc_bus_range (&newbus
, &newrange
, curr
, MEM
, 1)))
243 list_add_tail (&newbus
->bus_list
, &gbuses
);
244 debug ("New Bus, Memory Primary Bus %x [%x - %x]\n", newbus
->busno
, newrange
->start
, newrange
->end
);
247 } else if ((curr
->rsrc_type
& RESTYPE
) == PFMASK
) {
248 /* prefetchable memory */
249 if (list_empty (&gbuses
)) {
250 /* no bus structure exists in place yet */
251 if ((rc
= alloc_bus_range (&newbus
, &newrange
, curr
, PFMEM
, 1)))
253 list_add_tail (&newbus
->bus_list
, &gbuses
);
254 debug ("gbuses = NULL, PFMemory Primary Bus %x [%x - %x]\n", newbus
->busno
, newrange
->start
, newrange
->end
);
256 bus_cur
= find_bus_wprev (curr
->bus_num
, &bus_prev
, 1);
259 rc
= alloc_bus_range (&bus_cur
, &newrange
, curr
, PFMEM
, 0);
263 /* went through all the buses and didn't find ours, need to create a new bus node */
264 if ((rc
= alloc_bus_range (&newbus
, &newrange
, curr
, PFMEM
, 1)))
266 list_add_tail (&newbus
->bus_list
, &gbuses
);
267 debug ("1st Bus, PFMemory Primary Bus %x [%x - %x]\n", newbus
->busno
, newrange
->start
, newrange
->end
);
270 } else if ((curr
->rsrc_type
& RESTYPE
) == IOMASK
) {
272 if (list_empty (&gbuses
)) {
273 /* no bus structure exists in place yet */
274 if ((rc
= alloc_bus_range (&newbus
, &newrange
, curr
, IO
, 1)))
276 list_add_tail (&newbus
->bus_list
, &gbuses
);
277 debug ("gbuses = NULL, IO Primary Bus %x [%x - %x]\n", newbus
->busno
, newrange
->start
, newrange
->end
);
279 bus_cur
= find_bus_wprev (curr
->bus_num
, &bus_prev
, 1);
281 rc
= alloc_bus_range (&bus_cur
, &newrange
, curr
, IO
, 0);
285 /* went through all the buses and didn't find ours, need to create a new bus node */
286 if ((rc
= alloc_bus_range (&newbus
, &newrange
, curr
, IO
, 1)))
288 list_add_tail (&newbus
->bus_list
, &gbuses
);
289 debug ("1st Bus, IO Primary Bus %x [%x - %x]\n", newbus
->busno
, newrange
->start
, newrange
->end
);
294 ; /* type is reserved WHAT TO DO IN THIS CASE???
298 /* regular pci device resource */
299 if ((curr
->rsrc_type
& RESTYPE
) == MMASK
) {
300 /* Memory resource */
301 new_mem
= alloc_resources (curr
);
306 * if it didn't find the bus, means PCI dev
307 * came b4 the Primary Bus info, so need to
308 * create a bus rangeno becomes a problem...
309 * assign a -1 and then update once the range
310 * actually appears...
312 if (ibmphp_add_resource (new_mem
) < 0) {
313 newbus
= alloc_error_bus (curr
, 0, 0);
316 newbus
->firstMem
= new_mem
;
317 ++newbus
->needMemUpdate
;
318 new_mem
->rangeno
= -1;
320 debug ("Memory resource for device %x, bus %x, [%x - %x]\n", new_mem
->devfunc
, new_mem
->busno
, new_mem
->start
, new_mem
->end
);
322 } else if ((curr
->rsrc_type
& RESTYPE
) == PFMASK
) {
323 /* PFMemory resource */
324 new_pfmem
= alloc_resources (curr
);
327 new_pfmem
->type
= PFMEM
;
328 new_pfmem
->fromMem
= 0;
329 if (ibmphp_add_resource (new_pfmem
) < 0) {
330 newbus
= alloc_error_bus (curr
, 0, 0);
333 newbus
->firstPFMem
= new_pfmem
;
334 ++newbus
->needPFMemUpdate
;
335 new_pfmem
->rangeno
= -1;
338 debug ("PFMemory resource for device %x, bus %x, [%x - %x]\n", new_pfmem
->devfunc
, new_pfmem
->busno
, new_pfmem
->start
, new_pfmem
->end
);
339 } else if ((curr
->rsrc_type
& RESTYPE
) == IOMASK
) {
341 new_io
= alloc_resources (curr
);
347 * if it didn't find the bus, means PCI dev
348 * came b4 the Primary Bus info, so need to
349 * create a bus rangeno becomes a problem...
350 * Can assign a -1 and then update once the
351 * range actually appears...
353 if (ibmphp_add_resource (new_io
) < 0) {
354 newbus
= alloc_error_bus (curr
, 0, 0);
357 newbus
->firstIO
= new_io
;
358 ++newbus
->needIOUpdate
;
359 new_io
->rangeno
= -1;
361 debug ("IO resource for device %x, bus %x, [%x - %x]\n", new_io
->devfunc
, new_io
->busno
, new_io
->start
, new_io
->end
);
366 list_for_each (tmp
, &gbuses
) {
367 bus_cur
= list_entry (tmp
, struct bus_node
, bus_list
);
368 /* This is to get info about PPB resources, since EBDA doesn't put this info into the primary bus info */
369 rc
= update_bridge_ranges (&bus_cur
);
373 rc
= once_over (); /* This is to align ranges (so no -1) */
379 /********************************************************************************
380 * This function adds a range into a sorted list of ranges per bus for a particular
381 * range type, it then calls another routine to update the range numbers on the
382 * pci devices' resources for the appropriate resource
384 * Input: type of the resource, range to add, current bus
385 * Output: 0 or -1, bus and range ptrs
386 ********************************************************************************/
387 static int add_bus_range (int type
, struct range_node
*range
, struct bus_node
*bus_cur
)
389 struct range_node
*range_cur
= NULL
;
390 struct range_node
*range_prev
;
391 int count
= 0, i_init
;
396 range_cur
= bus_cur
->rangeMem
;
397 noRanges
= bus_cur
->noMemRanges
;
400 range_cur
= bus_cur
->rangePFMem
;
401 noRanges
= bus_cur
->noPFMemRanges
;
404 range_cur
= bus_cur
->rangeIO
;
405 noRanges
= bus_cur
->noIORanges
;
411 if (range
->start
< range_cur
->start
)
413 range_prev
= range_cur
;
414 range_cur
= range_cur
->next
;
418 /* our range will go at the beginning of the list */
421 bus_cur
->rangeMem
= range
;
424 bus_cur
->rangePFMem
= range
;
427 bus_cur
->rangeIO
= range
;
430 range
->next
= range_cur
;
433 } else if (!range_cur
) {
434 /* our range will go at the end of the list */
436 range_prev
->next
= range
;
437 range
->rangeno
= range_prev
->rangeno
+ 1;
440 /* the range is in the middle */
441 range_prev
->next
= range
;
442 range
->next
= range_cur
;
443 range
->rangeno
= range_cur
->rangeno
;
444 i_init
= range_prev
->rangeno
;
447 for (count
= i_init
; count
< noRanges
; ++count
) {
448 ++range_cur
->rangeno
;
449 range_cur
= range_cur
->next
;
452 update_resources (bus_cur
, type
, i_init
+ 1);
456 /*******************************************************************************
457 * This routine goes through the list of resources of type 'type' and updates
458 * the range numbers that they correspond to. It was called from add_bus_range fnc
460 * Input: bus, type of the resource, the rangeno starting from which to update
461 ******************************************************************************/
462 static void update_resources (struct bus_node
*bus_cur
, int type
, int rangeno
)
464 struct resource_node
*res
= NULL
;
465 u8 eol
= 0; /* end of list indicator */
469 if (bus_cur
->firstMem
)
470 res
= bus_cur
->firstMem
;
473 if (bus_cur
->firstPFMem
)
474 res
= bus_cur
->firstPFMem
;
477 if (bus_cur
->firstIO
)
478 res
= bus_cur
->firstIO
;
484 if (res
->rangeno
== rangeno
)
488 else if (res
->nextRange
)
489 res
= res
->nextRange
;
497 /* found the range */
506 static void fix_me (struct resource_node
*res
, struct bus_node
*bus_cur
, struct range_node
*range
)
522 if (res
->rangeno
== -1) {
524 if ((res
->start
>= range
->start
) && (res
->end
<= range
->end
)) {
525 res
->rangeno
= range
->rangeno
;
526 debug ("%s->rangeno in fix_resources is %d\n", str
, res
->rangeno
);
529 --bus_cur
->needIOUpdate
;
532 --bus_cur
->needMemUpdate
;
535 --bus_cur
->needPFMemUpdate
;
546 res
= res
->nextRange
;
551 /*****************************************************************************
552 * This routine reassigns the range numbers to the resources that had a -1
553 * This case can happen only if upon initialization, resources taken by pci dev
554 * appear in EBDA before the resources allocated for that bus, since we don't
555 * know the range, we assign -1, and this routine is called after a new range
556 * is assigned to see the resources with unknown range belong to the added range
559 * Output: none, list of resources for that bus are fixed if can be
560 *******************************************************************************/
561 static void fix_resources (struct bus_node
*bus_cur
)
563 struct range_node
*range
;
564 struct resource_node
*res
;
566 debug ("%s - bus_cur->busno = %d\n", __func__
, bus_cur
->busno
);
568 if (bus_cur
->needIOUpdate
) {
569 res
= bus_cur
->firstIO
;
570 range
= bus_cur
->rangeIO
;
571 fix_me (res
, bus_cur
, range
);
573 if (bus_cur
->needMemUpdate
) {
574 res
= bus_cur
->firstMem
;
575 range
= bus_cur
->rangeMem
;
576 fix_me (res
, bus_cur
, range
);
578 if (bus_cur
->needPFMemUpdate
) {
579 res
= bus_cur
->firstPFMem
;
580 range
= bus_cur
->rangePFMem
;
581 fix_me (res
, bus_cur
, range
);
585 /*******************************************************************************
586 * This routine adds a resource to the list of resources to the appropriate bus
587 * based on their resource type and sorted by their starting addresses. It assigns
588 * the ptrs to next and nextRange if needed.
590 * Input: resource ptr
591 * Output: ptrs assigned (to the node)
593 *******************************************************************************/
594 int ibmphp_add_resource (struct resource_node
*res
)
596 struct resource_node
*res_cur
;
597 struct resource_node
*res_prev
;
598 struct bus_node
*bus_cur
;
599 struct range_node
*range_cur
= NULL
;
600 struct resource_node
*res_start
= NULL
;
602 debug ("%s - enter\n", __func__
);
605 err ("NULL passed to add\n");
609 bus_cur
= find_bus_wprev (res
->busno
, NULL
, 0);
612 /* didn't find a bus, something's wrong!!! */
613 debug ("no bus in the system, either pci_dev's wrong or allocation failed\n");
620 range_cur
= bus_cur
->rangeIO
;
621 res_start
= bus_cur
->firstIO
;
624 range_cur
= bus_cur
->rangeMem
;
625 res_start
= bus_cur
->firstMem
;
628 range_cur
= bus_cur
->rangePFMem
;
629 res_start
= bus_cur
->firstPFMem
;
632 err ("cannot read the type of the resource to add... problem\n");
636 if ((res
->start
>= range_cur
->start
) && (res
->end
<= range_cur
->end
)) {
637 res
->rangeno
= range_cur
->rangeno
;
640 range_cur
= range_cur
->next
;
643 /* !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
644 * this is again the case of rangeno = -1
645 * !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
651 ++bus_cur
->needIOUpdate
;
654 ++bus_cur
->needMemUpdate
;
657 ++bus_cur
->needPFMemUpdate
;
663 debug ("The range is %d\n", res
->rangeno
);
665 /* no first{IO,Mem,Pfmem} on the bus, 1st IO/Mem/Pfmem resource ever */
668 bus_cur
->firstIO
= res
;
671 bus_cur
->firstMem
= res
;
674 bus_cur
->firstPFMem
= res
;
678 res
->nextRange
= NULL
;
683 debug ("res_cur->rangeno is %d\n", res_cur
->rangeno
);
686 if (res_cur
->rangeno
>= res
->rangeno
)
690 res_cur
= res_cur
->next
;
692 res_cur
= res_cur
->nextRange
;
696 /* at the end of the resource list */
697 debug ("i should be here, [%x - %x]\n", res
->start
, res
->end
);
698 res_prev
->nextRange
= res
;
700 res
->nextRange
= NULL
;
701 } else if (res_cur
->rangeno
== res
->rangeno
) {
702 /* in the same range */
704 if (res
->start
< res_cur
->start
)
707 res_cur
= res_cur
->next
;
710 /* the last resource in this range */
711 res_prev
->next
= res
;
713 res
->nextRange
= res_prev
->nextRange
;
714 res_prev
->nextRange
= NULL
;
715 } else if (res
->start
< res_cur
->start
) {
716 /* at the beginning or middle of the range */
720 bus_cur
->firstIO
= res
;
723 bus_cur
->firstMem
= res
;
726 bus_cur
->firstPFMem
= res
;
729 } else if (res_prev
->rangeno
== res_cur
->rangeno
)
730 res_prev
->next
= res
;
732 res_prev
->nextRange
= res
;
735 res
->nextRange
= NULL
;
738 /* this is the case where it is 1st occurrence of the range */
740 /* at the beginning of the resource list */
744 res
->nextRange
= bus_cur
->firstIO
;
745 bus_cur
->firstIO
= res
;
748 res
->nextRange
= bus_cur
->firstMem
;
749 bus_cur
->firstMem
= res
;
752 res
->nextRange
= bus_cur
->firstPFMem
;
753 bus_cur
->firstPFMem
= res
;
756 } else if (res_cur
->rangeno
> res
->rangeno
) {
757 /* in the middle of the resource list */
758 res_prev
->nextRange
= res
;
760 res
->nextRange
= res_cur
;
765 debug ("%s - exit\n", __func__
);
769 /****************************************************************************
770 * This routine will remove the resource from the list of resources
772 * Input: io, mem, and/or pfmem resource to be deleted
773 * Output: modified resource list
775 ****************************************************************************/
776 int ibmphp_remove_resource (struct resource_node
*res
)
778 struct bus_node
*bus_cur
;
779 struct resource_node
*res_cur
= NULL
;
780 struct resource_node
*res_prev
;
781 struct resource_node
*mem_cur
;
785 err ("resource to remove is NULL\n");
789 bus_cur
= find_bus_wprev (res
->busno
, NULL
, 0);
792 err ("cannot find corresponding bus of the io resource to remove bailing out...\n");
798 res_cur
= bus_cur
->firstIO
;
802 res_cur
= bus_cur
->firstMem
;
806 res_cur
= bus_cur
->firstPFMem
;
810 err ("unknown type for resource to remove\n");
816 if ((res_cur
->start
== res
->start
) && (res_cur
->end
== res
->end
))
820 res_cur
= res_cur
->next
;
822 res_cur
= res_cur
->nextRange
;
826 if (res
->type
== PFMEM
) {
828 * case where pfmem might be in the PFMemFromMem list
829 * so will also need to remove the corresponding mem
832 res_cur
= bus_cur
->firstPFMemFromMem
;
836 if ((res_cur
->start
== res
->start
) && (res_cur
->end
== res
->end
)) {
837 mem_cur
= bus_cur
->firstMem
;
839 if ((mem_cur
->start
== res_cur
->start
)
840 && (mem_cur
->end
== res_cur
->end
))
843 mem_cur
= mem_cur
->next
;
845 mem_cur
= mem_cur
->nextRange
;
848 err ("cannot find corresponding mem node for pfmem...\n");
852 ibmphp_remove_resource (mem_cur
);
854 bus_cur
->firstPFMemFromMem
= res_cur
->next
;
856 res_prev
->next
= res_cur
->next
;
862 res_cur
= res_cur
->next
;
864 res_cur
= res_cur
->nextRange
;
867 err ("cannot find pfmem to delete...\n");
871 err ("the %s resource is not in the list to be deleted...\n", type
);
876 /* first device to be deleted */
880 bus_cur
->firstIO
= res_cur
->next
;
883 bus_cur
->firstMem
= res_cur
->next
;
886 bus_cur
->firstPFMem
= res_cur
->next
;
889 } else if (res_cur
->nextRange
) {
892 bus_cur
->firstIO
= res_cur
->nextRange
;
895 bus_cur
->firstMem
= res_cur
->nextRange
;
898 bus_cur
->firstPFMem
= res_cur
->nextRange
;
904 bus_cur
->firstIO
= NULL
;
907 bus_cur
->firstMem
= NULL
;
910 bus_cur
->firstPFMem
= NULL
;
918 if (res_prev
->rangeno
== res_cur
->rangeno
)
919 res_prev
->next
= res_cur
->next
;
921 res_prev
->nextRange
= res_cur
->next
;
922 } else if (res_cur
->nextRange
) {
923 res_prev
->next
= NULL
;
924 res_prev
->nextRange
= res_cur
->nextRange
;
926 res_prev
->next
= NULL
;
927 res_prev
->nextRange
= NULL
;
936 static struct range_node
*find_range (struct bus_node
*bus_cur
, struct resource_node
*res
)
938 struct range_node
*range
= NULL
;
942 range
= bus_cur
->rangeIO
;
945 range
= bus_cur
->rangeMem
;
948 range
= bus_cur
->rangePFMem
;
951 err ("cannot read resource type in find_range\n");
955 if (res
->rangeno
== range
->rangeno
)
962 /*****************************************************************************
963 * This routine will check to make sure the io/mem/pfmem->len that the device asked for
964 * can fit w/i our list of available IO/MEM/PFMEM resources. If cannot, returns -EINVAL,
965 * otherwise, returns 0
968 * Output: the correct start and end address are inputted into the resource node,
970 *****************************************************************************/
971 int ibmphp_check_resource (struct resource_node
*res
, u8 bridge
)
973 struct bus_node
*bus_cur
;
974 struct range_node
*range
= NULL
;
975 struct resource_node
*res_prev
;
976 struct resource_node
*res_cur
= NULL
;
977 u32 len_cur
= 0, start_cur
= 0, len_tmp
= 0;
979 u32 tmp_start
; /* this is to make sure start address is divisible by the length needed */
987 /* The rules for bridges are different, 4K divisible for IO, 1M for (pf)mem*/
989 tmp_divide
= IOBRIDGE
;
991 tmp_divide
= MEMBRIDGE
;
993 tmp_divide
= res
->len
;
995 bus_cur
= find_bus_wprev (res
->busno
, NULL
, 0);
998 /* didn't find a bus, something's wrong!!! */
999 debug ("no bus in the system, either pci_dev's wrong or allocation failed\n");
1003 debug ("%s - enter\n", __func__
);
1004 debug ("bus_cur->busno is %d\n", bus_cur
->busno
);
1006 /* This is a quick fix to not mess up with the code very much. i.e.,
1007 * 2000-2fff, len = 1000, but when we compare, we need it to be fff */
1010 switch (res
->type
) {
1012 res_cur
= bus_cur
->firstIO
;
1013 noranges
= bus_cur
->noIORanges
;
1016 res_cur
= bus_cur
->firstMem
;
1017 noranges
= bus_cur
->noMemRanges
;
1020 res_cur
= bus_cur
->firstPFMem
;
1021 noranges
= bus_cur
->noPFMemRanges
;
1024 err ("wrong type of resource to check\n");
1030 range
= find_range (bus_cur
, res_cur
);
1031 debug ("%s - rangeno = %d\n", __func__
, res_cur
->rangeno
);
1034 err ("no range for the device exists... bailing out...\n");
1038 /* found our range */
1040 /* first time in the loop */
1041 if ((res_cur
->start
!= range
->start
) && ((len_tmp
= res_cur
->start
- 1 - range
->start
) >= res
->len
)) {
1042 debug ("len_tmp = %x\n", len_tmp
);
1044 if ((len_tmp
< len_cur
) || (len_cur
== 0)) {
1046 if ((range
->start
% tmp_divide
) == 0) {
1047 /* just perfect, starting address is divisible by length */
1050 start_cur
= range
->start
;
1052 /* Needs adjusting */
1053 tmp_start
= range
->start
;
1056 while ((len_tmp
= res_cur
->start
- 1 - tmp_start
) >= res
->len
) {
1057 if ((tmp_start
% tmp_divide
) == 0) {
1060 start_cur
= tmp_start
;
1063 tmp_start
+= tmp_divide
- tmp_start
% tmp_divide
;
1064 if (tmp_start
>= res_cur
->start
- 1)
1069 if (flag
&& len_cur
== res
->len
) {
1070 debug ("but we are not here, right?\n");
1071 res
->start
= start_cur
;
1072 res
->len
+= 1; /* To restore the balance */
1073 res
->end
= res
->start
+ res
->len
- 1;
1079 if (!res_cur
->next
) {
1080 /* last device on the range */
1081 if ((range
->end
!= res_cur
->end
) && ((len_tmp
= range
->end
- (res_cur
->end
+ 1)) >= res
->len
)) {
1082 debug ("len_tmp = %x\n", len_tmp
);
1083 if ((len_tmp
< len_cur
) || (len_cur
== 0)) {
1085 if (((res_cur
->end
+ 1) % tmp_divide
) == 0) {
1086 /* just perfect, starting address is divisible by length */
1089 start_cur
= res_cur
->end
+ 1;
1091 /* Needs adjusting */
1092 tmp_start
= res_cur
->end
+ 1;
1095 while ((len_tmp
= range
->end
- tmp_start
) >= res
->len
) {
1096 if ((tmp_start
% tmp_divide
) == 0) {
1099 start_cur
= tmp_start
;
1102 tmp_start
+= tmp_divide
- tmp_start
% tmp_divide
;
1103 if (tmp_start
>= range
->end
)
1107 if (flag
&& len_cur
== res
->len
) {
1108 res
->start
= start_cur
;
1109 res
->len
+= 1; /* To restore the balance */
1110 res
->end
= res
->start
+ res
->len
- 1;
1118 if (res_prev
->rangeno
!= res_cur
->rangeno
) {
1119 /* 1st device on this range */
1120 if ((res_cur
->start
!= range
->start
) &&
1121 ((len_tmp
= res_cur
->start
- 1 - range
->start
) >= res
->len
)) {
1122 if ((len_tmp
< len_cur
) || (len_cur
== 0)) {
1123 if ((range
->start
% tmp_divide
) == 0) {
1124 /* just perfect, starting address is divisible by length */
1127 start_cur
= range
->start
;
1129 /* Needs adjusting */
1130 tmp_start
= range
->start
;
1133 while ((len_tmp
= res_cur
->start
- 1 - tmp_start
) >= res
->len
) {
1134 if ((tmp_start
% tmp_divide
) == 0) {
1137 start_cur
= tmp_start
;
1140 tmp_start
+= tmp_divide
- tmp_start
% tmp_divide
;
1141 if (tmp_start
>= res_cur
->start
- 1)
1146 if (flag
&& len_cur
== res
->len
) {
1147 res
->start
= start_cur
;
1148 res
->len
+= 1; /* To restore the balance */
1149 res
->end
= res
->start
+ res
->len
- 1;
1155 /* in the same range */
1156 if ((len_tmp
= res_cur
->start
- 1 - res_prev
->end
- 1) >= res
->len
) {
1157 if ((len_tmp
< len_cur
) || (len_cur
== 0)) {
1158 if (((res_prev
->end
+ 1) % tmp_divide
) == 0) {
1159 /* just perfect, starting address's divisible by length */
1162 start_cur
= res_prev
->end
+ 1;
1164 /* Needs adjusting */
1165 tmp_start
= res_prev
->end
+ 1;
1168 while ((len_tmp
= res_cur
->start
- 1 - tmp_start
) >= res
->len
) {
1169 if ((tmp_start
% tmp_divide
) == 0) {
1172 start_cur
= tmp_start
;
1175 tmp_start
+= tmp_divide
- tmp_start
% tmp_divide
;
1176 if (tmp_start
>= res_cur
->start
- 1)
1181 if (flag
&& len_cur
== res
->len
) {
1182 res
->start
= start_cur
;
1183 res
->len
+= 1; /* To restore the balance */
1184 res
->end
= res
->start
+ res
->len
- 1;
1191 /* end if (res_prev) */
1194 res_cur
= res_cur
->next
;
1196 res_cur
= res_cur
->nextRange
;
1197 } /* end of while */
1201 /* 1st device ever */
1202 /* need to find appropriate range */
1203 switch (res
->type
) {
1205 range
= bus_cur
->rangeIO
;
1208 range
= bus_cur
->rangeMem
;
1211 range
= bus_cur
->rangePFMem
;
1215 if ((len_tmp
= range
->end
- range
->start
) >= res
->len
) {
1216 if ((len_tmp
< len_cur
) || (len_cur
== 0)) {
1217 if ((range
->start
% tmp_divide
) == 0) {
1218 /* just perfect, starting address's divisible by length */
1221 start_cur
= range
->start
;
1223 /* Needs adjusting */
1224 tmp_start
= range
->start
;
1227 while ((len_tmp
= range
->end
- tmp_start
) >= res
->len
) {
1228 if ((tmp_start
% tmp_divide
) == 0) {
1231 start_cur
= tmp_start
;
1234 tmp_start
+= tmp_divide
- tmp_start
% tmp_divide
;
1235 if (tmp_start
>= range
->end
)
1240 if (flag
&& len_cur
== res
->len
) {
1241 res
->start
= start_cur
;
1242 res
->len
+= 1; /* To restore the balance */
1243 res
->end
= res
->start
+ res
->len
- 1;
1248 range
= range
->next
;
1249 } /* end of while */
1251 if ((!range
) && (len_cur
== 0)) {
1252 /* have gone through the list of devices and ranges and haven't found n.e.thing */
1253 err ("no appropriate range.. bailing out...\n");
1255 } else if (len_cur
) {
1256 res
->start
= start_cur
;
1257 res
->len
+= 1; /* To restore the balance */
1258 res
->end
= res
->start
+ res
->len
- 1;
1264 debug ("prev->rangeno = %d, noranges = %d\n", res_prev
->rangeno
, noranges
);
1265 if (res_prev
->rangeno
< noranges
) {
1266 /* if there're more ranges out there to check */
1267 switch (res
->type
) {
1269 range
= bus_cur
->rangeIO
;
1272 range
= bus_cur
->rangeMem
;
1275 range
= bus_cur
->rangePFMem
;
1279 if ((len_tmp
= range
->end
- range
->start
) >= res
->len
) {
1280 if ((len_tmp
< len_cur
) || (len_cur
== 0)) {
1281 if ((range
->start
% tmp_divide
) == 0) {
1282 /* just perfect, starting address's divisible by length */
1285 start_cur
= range
->start
;
1287 /* Needs adjusting */
1288 tmp_start
= range
->start
;
1291 while ((len_tmp
= range
->end
- tmp_start
) >= res
->len
) {
1292 if ((tmp_start
% tmp_divide
) == 0) {
1295 start_cur
= tmp_start
;
1298 tmp_start
+= tmp_divide
- tmp_start
% tmp_divide
;
1299 if (tmp_start
>= range
->end
)
1304 if (flag
&& len_cur
== res
->len
) {
1305 res
->start
= start_cur
;
1306 res
->len
+= 1; /* To restore the balance */
1307 res
->end
= res
->start
+ res
->len
- 1;
1312 range
= range
->next
;
1313 } /* end of while */
1315 if ((!range
) && (len_cur
== 0)) {
1316 /* have gone through the list of devices and ranges and haven't found n.e.thing */
1317 err ("no appropriate range.. bailing out...\n");
1319 } else if (len_cur
) {
1320 res
->start
= start_cur
;
1321 res
->len
+= 1; /* To restore the balance */
1322 res
->end
= res
->start
+ res
->len
- 1;
1326 /* no more ranges to check on */
1328 res
->start
= start_cur
;
1329 res
->len
+= 1; /* To restore the balance */
1330 res
->end
= res
->start
+ res
->len
- 1;
1333 /* have gone through the list of devices and haven't found n.e.thing */
1334 err ("no appropriate range.. bailing out...\n");
1338 } /* end if(!res_cur) */
1342 /********************************************************************************
1343 * This routine is called from remove_card if the card contained PPB.
1344 * It will remove all the resources on the bus as well as the bus itself
1346 * Output: 0, -ENODEV
1347 ********************************************************************************/
1348 int ibmphp_remove_bus (struct bus_node
*bus
, u8 parent_busno
)
1350 struct resource_node
*res_cur
;
1351 struct resource_node
*res_tmp
;
1352 struct bus_node
*prev_bus
;
1355 prev_bus
= find_bus_wprev (parent_busno
, NULL
, 0);
1358 debug ("something terribly wrong. Cannot find parent bus to the one to remove\n");
1362 debug ("In ibmphp_remove_bus... prev_bus->busno is %x\n", prev_bus
->busno
);
1364 rc
= remove_ranges (bus
, prev_bus
);
1369 res_cur
= bus
->firstIO
;
1373 res_cur
= res_cur
->next
;
1375 res_cur
= res_cur
->nextRange
;
1379 bus
->firstIO
= NULL
;
1381 if (bus
->firstMem
) {
1382 res_cur
= bus
->firstMem
;
1386 res_cur
= res_cur
->next
;
1388 res_cur
= res_cur
->nextRange
;
1392 bus
->firstMem
= NULL
;
1394 if (bus
->firstPFMem
) {
1395 res_cur
= bus
->firstPFMem
;
1399 res_cur
= res_cur
->next
;
1401 res_cur
= res_cur
->nextRange
;
1405 bus
->firstPFMem
= NULL
;
1408 if (bus
->firstPFMemFromMem
) {
1409 res_cur
= bus
->firstPFMemFromMem
;
1412 res_cur
= res_cur
->next
;
1417 bus
->firstPFMemFromMem
= NULL
;
1420 list_del (&bus
->bus_list
);
1425 /******************************************************************************
1426 * This routine deletes the ranges from a given bus, and the entries from the
1427 * parent's bus in the resources
1428 * Input: current bus, previous bus
1429 * Output: 0, -EINVAL
1430 ******************************************************************************/
1431 static int remove_ranges (struct bus_node
*bus_cur
, struct bus_node
*bus_prev
)
1433 struct range_node
*range_cur
;
1434 struct range_node
*range_tmp
;
1436 struct resource_node
*res
= NULL
;
1438 if (bus_cur
->noIORanges
) {
1439 range_cur
= bus_cur
->rangeIO
;
1440 for (i
= 0; i
< bus_cur
->noIORanges
; i
++) {
1441 if (ibmphp_find_resource (bus_prev
, range_cur
->start
, &res
, IO
) < 0)
1443 ibmphp_remove_resource (res
);
1445 range_tmp
= range_cur
;
1446 range_cur
= range_cur
->next
;
1450 bus_cur
->rangeIO
= NULL
;
1452 if (bus_cur
->noMemRanges
) {
1453 range_cur
= bus_cur
->rangeMem
;
1454 for (i
= 0; i
< bus_cur
->noMemRanges
; i
++) {
1455 if (ibmphp_find_resource (bus_prev
, range_cur
->start
, &res
, MEM
) < 0)
1458 ibmphp_remove_resource (res
);
1459 range_tmp
= range_cur
;
1460 range_cur
= range_cur
->next
;
1464 bus_cur
->rangeMem
= NULL
;
1466 if (bus_cur
->noPFMemRanges
) {
1467 range_cur
= bus_cur
->rangePFMem
;
1468 for (i
= 0; i
< bus_cur
->noPFMemRanges
; i
++) {
1469 if (ibmphp_find_resource (bus_prev
, range_cur
->start
, &res
, PFMEM
) < 0)
1472 ibmphp_remove_resource (res
);
1473 range_tmp
= range_cur
;
1474 range_cur
= range_cur
->next
;
1478 bus_cur
->rangePFMem
= NULL
;
1484 * find the resource node in the bus
1485 * Input: Resource needed, start address of the resource, type of resource
1487 int ibmphp_find_resource (struct bus_node
*bus
, u32 start_address
, struct resource_node
**res
, int flag
)
1489 struct resource_node
*res_cur
= NULL
;
1493 err ("The bus passed in NULL to find resource\n");
1499 res_cur
= bus
->firstIO
;
1503 res_cur
= bus
->firstMem
;
1507 res_cur
= bus
->firstPFMem
;
1511 err ("wrong type of flag\n");
1516 if (res_cur
->start
== start_address
) {
1521 res_cur
= res_cur
->next
;
1523 res_cur
= res_cur
->nextRange
;
1527 if (flag
== PFMEM
) {
1528 res_cur
= bus
->firstPFMemFromMem
;
1530 if (res_cur
->start
== start_address
) {
1534 res_cur
= res_cur
->next
;
1537 debug ("SOS...cannot find %s resource in the bus.\n", type
);
1541 debug ("SOS... cannot find %s resource in the bus.\n", type
);
1547 debug ("*res->start = %x\n", (*res
)->start
);
1552 /***********************************************************************
1553 * This routine will free the resource structures used by the
1554 * system. It is called from cleanup routine for the module
1557 ***********************************************************************/
1558 void ibmphp_free_resources (void)
1560 struct bus_node
*bus_cur
= NULL
;
1561 struct bus_node
*bus_tmp
;
1562 struct range_node
*range_cur
;
1563 struct range_node
*range_tmp
;
1564 struct resource_node
*res_cur
;
1565 struct resource_node
*res_tmp
;
1566 struct list_head
*tmp
;
1567 struct list_head
*next
;
1571 list_for_each_safe (tmp
, next
, &gbuses
) {
1572 bus_cur
= list_entry (tmp
, struct bus_node
, bus_list
);
1573 if (bus_cur
->noIORanges
) {
1574 range_cur
= bus_cur
->rangeIO
;
1575 for (i
= 0; i
< bus_cur
->noIORanges
; i
++) {
1578 range_tmp
= range_cur
;
1579 range_cur
= range_cur
->next
;
1584 if (bus_cur
->noMemRanges
) {
1585 range_cur
= bus_cur
->rangeMem
;
1586 for (i
= 0; i
< bus_cur
->noMemRanges
; i
++) {
1589 range_tmp
= range_cur
;
1590 range_cur
= range_cur
->next
;
1595 if (bus_cur
->noPFMemRanges
) {
1596 range_cur
= bus_cur
->rangePFMem
;
1597 for (i
= 0; i
< bus_cur
->noPFMemRanges
; i
++) {
1600 range_tmp
= range_cur
;
1601 range_cur
= range_cur
->next
;
1607 if (bus_cur
->firstIO
) {
1608 res_cur
= bus_cur
->firstIO
;
1612 res_cur
= res_cur
->next
;
1614 res_cur
= res_cur
->nextRange
;
1618 bus_cur
->firstIO
= NULL
;
1620 if (bus_cur
->firstMem
) {
1621 res_cur
= bus_cur
->firstMem
;
1625 res_cur
= res_cur
->next
;
1627 res_cur
= res_cur
->nextRange
;
1631 bus_cur
->firstMem
= NULL
;
1633 if (bus_cur
->firstPFMem
) {
1634 res_cur
= bus_cur
->firstPFMem
;
1638 res_cur
= res_cur
->next
;
1640 res_cur
= res_cur
->nextRange
;
1644 bus_cur
->firstPFMem
= NULL
;
1647 if (bus_cur
->firstPFMemFromMem
) {
1648 res_cur
= bus_cur
->firstPFMemFromMem
;
1651 res_cur
= res_cur
->next
;
1656 bus_cur
->firstPFMemFromMem
= NULL
;
1660 list_del (&bus_cur
->bus_list
);
1666 /*********************************************************************************
1667 * This function will go over the PFmem resources to check if the EBDA allocated
1668 * pfmem out of memory buckets of the bus. If so, it will change the range numbers
1669 * and a flag to indicate that this resource is out of memory. It will also move the
1670 * Pfmem out of the pfmem resource list to the PFMemFromMem list, and will create
1672 * This routine is called right after initialization
1673 *******************************************************************************/
1674 static int __init
once_over (void)
1676 struct resource_node
*pfmem_cur
;
1677 struct resource_node
*pfmem_prev
;
1678 struct resource_node
*mem
;
1679 struct bus_node
*bus_cur
;
1680 struct list_head
*tmp
;
1682 list_for_each (tmp
, &gbuses
) {
1683 bus_cur
= list_entry (tmp
, struct bus_node
, bus_list
);
1684 if ((!bus_cur
->rangePFMem
) && (bus_cur
->firstPFMem
)) {
1685 for (pfmem_cur
= bus_cur
->firstPFMem
, pfmem_prev
= NULL
; pfmem_cur
; pfmem_prev
= pfmem_cur
, pfmem_cur
= pfmem_cur
->next
) {
1686 pfmem_cur
->fromMem
= 1;
1688 pfmem_prev
->next
= pfmem_cur
->next
;
1690 bus_cur
->firstPFMem
= pfmem_cur
->next
;
1692 if (!bus_cur
->firstPFMemFromMem
)
1693 pfmem_cur
->next
= NULL
;
1695 /* we don't need to sort PFMemFromMem since we're using mem node for
1696 all the real work anyways, so just insert at the beginning of the
1699 pfmem_cur
->next
= bus_cur
->firstPFMemFromMem
;
1701 bus_cur
->firstPFMemFromMem
= pfmem_cur
;
1703 mem
= kzalloc(sizeof(struct resource_node
), GFP_KERNEL
);
1705 err ("out of system memory\n");
1709 mem
->busno
= pfmem_cur
->busno
;
1710 mem
->devfunc
= pfmem_cur
->devfunc
;
1711 mem
->start
= pfmem_cur
->start
;
1712 mem
->end
= pfmem_cur
->end
;
1713 mem
->len
= pfmem_cur
->len
;
1714 if (ibmphp_add_resource (mem
) < 0)
1715 err ("Trouble...trouble... EBDA allocated pfmem from mem, but system doesn't display it has this space... unless not PCI device...\n");
1716 pfmem_cur
->rangeno
= mem
->rangeno
;
1717 } /* end for pfmem */
1719 } /* end list_for_each bus */
1723 int ibmphp_add_pfmem_from_mem (struct resource_node
*pfmem
)
1725 struct bus_node
*bus_cur
= find_bus_wprev (pfmem
->busno
, NULL
, 0);
1728 err ("cannot find bus of pfmem to add...\n");
1732 if (bus_cur
->firstPFMemFromMem
)
1733 pfmem
->next
= bus_cur
->firstPFMemFromMem
;
1737 bus_cur
->firstPFMemFromMem
= pfmem
;
1742 /* This routine just goes through the buses to see if the bus already exists.
1743 * It is called from ibmphp_find_sec_number, to find out a secondary bus number for
1745 * Parameters: bus_number
1746 * Returns: Bus pointer or NULL
1748 struct bus_node
*ibmphp_find_res_bus (u8 bus_number
)
1750 return find_bus_wprev (bus_number
, NULL
, 0);
1753 static struct bus_node
*find_bus_wprev (u8 bus_number
, struct bus_node
**prev
, u8 flag
)
1755 struct bus_node
*bus_cur
;
1756 struct list_head
*tmp
;
1757 struct list_head
*tmp_prev
;
1759 list_for_each (tmp
, &gbuses
) {
1760 tmp_prev
= tmp
->prev
;
1761 bus_cur
= list_entry (tmp
, struct bus_node
, bus_list
);
1763 *prev
= list_entry (tmp_prev
, struct bus_node
, bus_list
);
1764 if (bus_cur
->busno
== bus_number
)
1771 void ibmphp_print_test (void)
1774 struct bus_node
*bus_cur
= NULL
;
1775 struct range_node
*range
;
1776 struct resource_node
*res
;
1777 struct list_head
*tmp
;
1779 debug_pci ("*****************START**********************\n");
1781 if ((!list_empty(&gbuses
)) && flags
) {
1782 err ("The GBUSES is not NULL?!?!?!?!?\n");
1786 list_for_each (tmp
, &gbuses
) {
1787 bus_cur
= list_entry (tmp
, struct bus_node
, bus_list
);
1788 debug_pci ("This is bus # %d. There are\n", bus_cur
->busno
);
1789 debug_pci ("IORanges = %d\t", bus_cur
->noIORanges
);
1790 debug_pci ("MemRanges = %d\t", bus_cur
->noMemRanges
);
1791 debug_pci ("PFMemRanges = %d\n", bus_cur
->noPFMemRanges
);
1792 debug_pci ("The IO Ranges are as follows:\n");
1793 if (bus_cur
->rangeIO
) {
1794 range
= bus_cur
->rangeIO
;
1795 for (i
= 0; i
< bus_cur
->noIORanges
; i
++) {
1796 debug_pci ("rangeno is %d\n", range
->rangeno
);
1797 debug_pci ("[%x - %x]\n", range
->start
, range
->end
);
1798 range
= range
->next
;
1802 debug_pci ("The Mem Ranges are as follows:\n");
1803 if (bus_cur
->rangeMem
) {
1804 range
= bus_cur
->rangeMem
;
1805 for (i
= 0; i
< bus_cur
->noMemRanges
; i
++) {
1806 debug_pci ("rangeno is %d\n", range
->rangeno
);
1807 debug_pci ("[%x - %x]\n", range
->start
, range
->end
);
1808 range
= range
->next
;
1812 debug_pci ("The PFMem Ranges are as follows:\n");
1814 if (bus_cur
->rangePFMem
) {
1815 range
= bus_cur
->rangePFMem
;
1816 for (i
= 0; i
< bus_cur
->noPFMemRanges
; i
++) {
1817 debug_pci ("rangeno is %d\n", range
->rangeno
);
1818 debug_pci ("[%x - %x]\n", range
->start
, range
->end
);
1819 range
= range
->next
;
1823 debug_pci ("The resources on this bus are as follows\n");
1825 debug_pci ("IO...\n");
1826 if (bus_cur
->firstIO
) {
1827 res
= bus_cur
->firstIO
;
1829 debug_pci ("The range # is %d\n", res
->rangeno
);
1830 debug_pci ("The bus, devfnc is %d, %x\n", res
->busno
, res
->devfunc
);
1831 debug_pci ("[%x - %x], len=%x\n", res
->start
, res
->end
, res
->len
);
1834 else if (res
->nextRange
)
1835 res
= res
->nextRange
;
1840 debug_pci ("Mem...\n");
1841 if (bus_cur
->firstMem
) {
1842 res
= bus_cur
->firstMem
;
1844 debug_pci ("The range # is %d\n", res
->rangeno
);
1845 debug_pci ("The bus, devfnc is %d, %x\n", res
->busno
, res
->devfunc
);
1846 debug_pci ("[%x - %x], len=%x\n", res
->start
, res
->end
, res
->len
);
1849 else if (res
->nextRange
)
1850 res
= res
->nextRange
;
1855 debug_pci ("PFMem...\n");
1856 if (bus_cur
->firstPFMem
) {
1857 res
= bus_cur
->firstPFMem
;
1859 debug_pci ("The range # is %d\n", res
->rangeno
);
1860 debug_pci ("The bus, devfnc is %d, %x\n", res
->busno
, res
->devfunc
);
1861 debug_pci ("[%x - %x], len=%x\n", res
->start
, res
->end
, res
->len
);
1864 else if (res
->nextRange
)
1865 res
= res
->nextRange
;
1871 debug_pci ("PFMemFromMem...\n");
1872 if (bus_cur
->firstPFMemFromMem
) {
1873 res
= bus_cur
->firstPFMemFromMem
;
1875 debug_pci ("The range # is %d\n", res
->rangeno
);
1876 debug_pci ("The bus, devfnc is %d, %x\n", res
->busno
, res
->devfunc
);
1877 debug_pci ("[%x - %x], len=%x\n", res
->start
, res
->end
, res
->len
);
1882 debug_pci ("***********************END***********************\n");
1885 static int range_exists_already (struct range_node
* range
, struct bus_node
* bus_cur
, u8 type
)
1887 struct range_node
* range_cur
= NULL
;
1890 range_cur
= bus_cur
->rangeIO
;
1893 range_cur
= bus_cur
->rangeMem
;
1896 range_cur
= bus_cur
->rangePFMem
;
1899 err ("wrong type passed to find out if range already exists\n");
1904 if ((range_cur
->start
== range
->start
) && (range_cur
->end
== range
->end
))
1906 range_cur
= range_cur
->next
;
1912 /* This routine will read the windows for any PPB we have and update the
1913 * range info for the secondary bus, and will also input this info into
1914 * primary bus, since BIOS doesn't. This is for PPB that are in the system
1915 * on bootup. For bridged cards that were added during previous load of the
1916 * driver, only the ranges and the bus structure are added, the devices are
1918 * Input: primary busno
1920 * Note: this function doesn't take into account IO restrictions etc,
1921 * so will only work for bridges with no video/ISA devices behind them It
1922 * also will not work for onboard PPBs that can have more than 1 *bus
1923 * behind them All these are TO DO.
1924 * Also need to add more error checkings... (from fnc returns etc)
1926 static int __init
update_bridge_ranges (struct bus_node
**bus
)
1928 u8 sec_busno
, device
, function
, hdr_type
, start_io_address
, end_io_address
;
1929 u16 vendor_id
, upper_io_start
, upper_io_end
, start_mem_address
, end_mem_address
;
1930 u32 start_address
, end_address
, upper_start
, upper_end
;
1931 struct bus_node
*bus_sec
;
1932 struct bus_node
*bus_cur
;
1933 struct resource_node
*io
;
1934 struct resource_node
*mem
;
1935 struct resource_node
*pfmem
;
1936 struct range_node
*range
;
1942 ibmphp_pci_bus
->number
= bus_cur
->busno
;
1944 debug ("inside %s\n", __func__
);
1945 debug ("bus_cur->busno = %x\n", bus_cur
->busno
);
1947 for (device
= 0; device
< 32; device
++) {
1948 for (function
= 0x00; function
< 0x08; function
++) {
1949 devfn
= PCI_DEVFN(device
, function
);
1950 pci_bus_read_config_word (ibmphp_pci_bus
, devfn
, PCI_VENDOR_ID
, &vendor_id
);
1952 if (vendor_id
!= PCI_VENDOR_ID_NOTVALID
) {
1953 /* found correct device!!! */
1954 pci_bus_read_config_byte (ibmphp_pci_bus
, devfn
, PCI_HEADER_TYPE
, &hdr_type
);
1957 case PCI_HEADER_TYPE_NORMAL
:
1960 case PCI_HEADER_TYPE_MULTIDEVICE
:
1962 case PCI_HEADER_TYPE_BRIDGE
:
1964 case PCI_HEADER_TYPE_MULTIBRIDGE
:
1965 /* We assume here that only 1 bus behind the bridge
1966 TO DO: add functionality for several:
1968 while (temp < subordinate) {
1973 pci_bus_read_config_byte (ibmphp_pci_bus
, devfn
, PCI_SECONDARY_BUS
, &sec_busno
);
1974 bus_sec
= find_bus_wprev (sec_busno
, NULL
, 0);
1975 /* this bus structure doesn't exist yet, PPB was configured during previous loading of ibmphp */
1977 bus_sec
= alloc_error_bus (NULL
, sec_busno
, 1);
1978 /* the rest will be populated during NVRAM call */
1981 pci_bus_read_config_byte (ibmphp_pci_bus
, devfn
, PCI_IO_BASE
, &start_io_address
);
1982 pci_bus_read_config_byte (ibmphp_pci_bus
, devfn
, PCI_IO_LIMIT
, &end_io_address
);
1983 pci_bus_read_config_word (ibmphp_pci_bus
, devfn
, PCI_IO_BASE_UPPER16
, &upper_io_start
);
1984 pci_bus_read_config_word (ibmphp_pci_bus
, devfn
, PCI_IO_LIMIT_UPPER16
, &upper_io_end
);
1985 start_address
= (start_io_address
& PCI_IO_RANGE_MASK
) << 8;
1986 start_address
|= (upper_io_start
<< 16);
1987 end_address
= (end_io_address
& PCI_IO_RANGE_MASK
) << 8;
1988 end_address
|= (upper_io_end
<< 16);
1990 if ((start_address
) && (start_address
<= end_address
)) {
1991 range
= kzalloc(sizeof(struct range_node
), GFP_KERNEL
);
1993 err ("out of system memory\n");
1996 range
->start
= start_address
;
1997 range
->end
= end_address
+ 0xfff;
1999 if (bus_sec
->noIORanges
> 0) {
2000 if (!range_exists_already (range
, bus_sec
, IO
)) {
2001 add_bus_range (IO
, range
, bus_sec
);
2002 ++bus_sec
->noIORanges
;
2008 /* 1st IO Range on the bus */
2010 bus_sec
->rangeIO
= range
;
2011 ++bus_sec
->noIORanges
;
2013 fix_resources (bus_sec
);
2015 if (ibmphp_find_resource (bus_cur
, start_address
, &io
, IO
)) {
2016 io
= kzalloc(sizeof(struct resource_node
), GFP_KERNEL
);
2019 err ("out of system memory\n");
2023 io
->busno
= bus_cur
->busno
;
2024 io
->devfunc
= ((device
<< 3) | (function
& 0x7));
2025 io
->start
= start_address
;
2026 io
->end
= end_address
+ 0xfff;
2027 io
->len
= io
->end
- io
->start
+ 1;
2028 ibmphp_add_resource (io
);
2032 pci_bus_read_config_word (ibmphp_pci_bus
, devfn
, PCI_MEMORY_BASE
, &start_mem_address
);
2033 pci_bus_read_config_word (ibmphp_pci_bus
, devfn
, PCI_MEMORY_LIMIT
, &end_mem_address
);
2035 start_address
= 0x00000000 | (start_mem_address
& PCI_MEMORY_RANGE_MASK
) << 16;
2036 end_address
= 0x00000000 | (end_mem_address
& PCI_MEMORY_RANGE_MASK
) << 16;
2038 if ((start_address
) && (start_address
<= end_address
)) {
2040 range
= kzalloc(sizeof(struct range_node
), GFP_KERNEL
);
2042 err ("out of system memory\n");
2045 range
->start
= start_address
;
2046 range
->end
= end_address
+ 0xfffff;
2048 if (bus_sec
->noMemRanges
> 0) {
2049 if (!range_exists_already (range
, bus_sec
, MEM
)) {
2050 add_bus_range (MEM
, range
, bus_sec
);
2051 ++bus_sec
->noMemRanges
;
2057 /* 1st Mem Range on the bus */
2059 bus_sec
->rangeMem
= range
;
2060 ++bus_sec
->noMemRanges
;
2063 fix_resources (bus_sec
);
2065 if (ibmphp_find_resource (bus_cur
, start_address
, &mem
, MEM
)) {
2066 mem
= kzalloc(sizeof(struct resource_node
), GFP_KERNEL
);
2069 err ("out of system memory\n");
2073 mem
->busno
= bus_cur
->busno
;
2074 mem
->devfunc
= ((device
<< 3) | (function
& 0x7));
2075 mem
->start
= start_address
;
2076 mem
->end
= end_address
+ 0xfffff;
2077 mem
->len
= mem
->end
- mem
->start
+ 1;
2078 ibmphp_add_resource (mem
);
2081 pci_bus_read_config_word (ibmphp_pci_bus
, devfn
, PCI_PREF_MEMORY_BASE
, &start_mem_address
);
2082 pci_bus_read_config_word (ibmphp_pci_bus
, devfn
, PCI_PREF_MEMORY_LIMIT
, &end_mem_address
);
2083 pci_bus_read_config_dword (ibmphp_pci_bus
, devfn
, PCI_PREF_BASE_UPPER32
, &upper_start
);
2084 pci_bus_read_config_dword (ibmphp_pci_bus
, devfn
, PCI_PREF_LIMIT_UPPER32
, &upper_end
);
2085 start_address
= 0x00000000 | (start_mem_address
& PCI_MEMORY_RANGE_MASK
) << 16;
2086 end_address
= 0x00000000 | (end_mem_address
& PCI_MEMORY_RANGE_MASK
) << 16;
2087 #if BITS_PER_LONG == 64
2088 start_address
|= ((long) upper_start
) << 32;
2089 end_address
|= ((long) upper_end
) << 32;
2092 if ((start_address
) && (start_address
<= end_address
)) {
2094 range
= kzalloc(sizeof(struct range_node
), GFP_KERNEL
);
2096 err ("out of system memory\n");
2099 range
->start
= start_address
;
2100 range
->end
= end_address
+ 0xfffff;
2102 if (bus_sec
->noPFMemRanges
> 0) {
2103 if (!range_exists_already (range
, bus_sec
, PFMEM
)) {
2104 add_bus_range (PFMEM
, range
, bus_sec
);
2105 ++bus_sec
->noPFMemRanges
;
2111 /* 1st PFMem Range on the bus */
2113 bus_sec
->rangePFMem
= range
;
2114 ++bus_sec
->noPFMemRanges
;
2117 fix_resources (bus_sec
);
2118 if (ibmphp_find_resource (bus_cur
, start_address
, &pfmem
, PFMEM
)) {
2119 pfmem
= kzalloc(sizeof(struct resource_node
), GFP_KERNEL
);
2122 err ("out of system memory\n");
2125 pfmem
->type
= PFMEM
;
2126 pfmem
->busno
= bus_cur
->busno
;
2127 pfmem
->devfunc
= ((device
<< 3) | (function
& 0x7));
2128 pfmem
->start
= start_address
;
2129 pfmem
->end
= end_address
+ 0xfffff;
2130 pfmem
->len
= pfmem
->end
- pfmem
->start
+ 1;
2133 ibmphp_add_resource (pfmem
);
2137 } /* end of switch */
2138 } /* end if vendor */
2139 } /* end for function */
2140 } /* end for device */