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 "
799 res_cur
= bus_cur
->firstIO
;
803 res_cur
= bus_cur
->firstMem
;
807 res_cur
= bus_cur
->firstPFMem
;
811 err ("unknown type for resource to remove\n");
817 if ((res_cur
->start
== res
->start
) && (res_cur
->end
== res
->end
))
821 res_cur
= res_cur
->next
;
823 res_cur
= res_cur
->nextRange
;
827 if (res
->type
== PFMEM
) {
829 * case where pfmem might be in the PFMemFromMem list
830 * so will also need to remove the corresponding mem
833 res_cur
= bus_cur
->firstPFMemFromMem
;
837 if ((res_cur
->start
== res
->start
) && (res_cur
->end
== res
->end
)) {
838 mem_cur
= bus_cur
->firstMem
;
840 if ((mem_cur
->start
== res_cur
->start
)
841 && (mem_cur
->end
== res_cur
->end
))
844 mem_cur
= mem_cur
->next
;
846 mem_cur
= mem_cur
->nextRange
;
849 err ("cannot find corresponding mem node for pfmem...\n");
853 ibmphp_remove_resource (mem_cur
);
855 bus_cur
->firstPFMemFromMem
= res_cur
->next
;
857 res_prev
->next
= res_cur
->next
;
863 res_cur
= res_cur
->next
;
865 res_cur
= res_cur
->nextRange
;
868 err ("cannot find pfmem to delete...\n");
872 err ("the %s resource is not in the list to be deleted...\n", type
);
877 /* first device to be deleted */
881 bus_cur
->firstIO
= res_cur
->next
;
884 bus_cur
->firstMem
= res_cur
->next
;
887 bus_cur
->firstPFMem
= res_cur
->next
;
890 } else if (res_cur
->nextRange
) {
893 bus_cur
->firstIO
= res_cur
->nextRange
;
896 bus_cur
->firstMem
= res_cur
->nextRange
;
899 bus_cur
->firstPFMem
= res_cur
->nextRange
;
905 bus_cur
->firstIO
= NULL
;
908 bus_cur
->firstMem
= NULL
;
911 bus_cur
->firstPFMem
= NULL
;
919 if (res_prev
->rangeno
== res_cur
->rangeno
)
920 res_prev
->next
= res_cur
->next
;
922 res_prev
->nextRange
= res_cur
->next
;
923 } else if (res_cur
->nextRange
) {
924 res_prev
->next
= NULL
;
925 res_prev
->nextRange
= res_cur
->nextRange
;
927 res_prev
->next
= NULL
;
928 res_prev
->nextRange
= NULL
;
937 static struct range_node
* find_range (struct bus_node
*bus_cur
, struct resource_node
* res
)
939 struct range_node
* range
= NULL
;
943 range
= bus_cur
->rangeIO
;
946 range
= bus_cur
->rangeMem
;
949 range
= bus_cur
->rangePFMem
;
952 err ("cannot read resource type in find_range\n");
956 if (res
->rangeno
== range
->rangeno
)
963 /*****************************************************************************
964 * This routine will check to make sure the io/mem/pfmem->len that the device asked for
965 * can fit w/i our list of available IO/MEM/PFMEM resources. If cannot, returns -EINVAL,
966 * otherwise, returns 0
969 * Output: the correct start and end address are inputted into the resource node,
971 *****************************************************************************/
972 int ibmphp_check_resource (struct resource_node
*res
, u8 bridge
)
974 struct bus_node
*bus_cur
;
975 struct range_node
*range
= NULL
;
976 struct resource_node
*res_prev
;
977 struct resource_node
*res_cur
= NULL
;
978 u32 len_cur
= 0, start_cur
= 0, len_tmp
= 0;
980 u32 tmp_start
; /* this is to make sure start address is divisible by the length needed */
988 /* The rules for bridges are different, 4K divisible for IO, 1M for (pf)mem*/
990 tmp_divide
= IOBRIDGE
;
992 tmp_divide
= MEMBRIDGE
;
994 tmp_divide
= res
->len
;
996 bus_cur
= find_bus_wprev (res
->busno
, NULL
, 0);
999 /* didn't find a bus, something's wrong!!! */
1000 debug ("no bus in the system, either pci_dev's wrong or allocation failed\n");
1004 debug ("%s - enter\n", __func__
);
1005 debug ("bus_cur->busno is %d\n", bus_cur
->busno
);
1007 /* This is a quick fix to not mess up with the code very much. i.e.,
1008 * 2000-2fff, len = 1000, but when we compare, we need it to be fff */
1011 switch (res
->type
) {
1013 res_cur
= bus_cur
->firstIO
;
1014 noranges
= bus_cur
->noIORanges
;
1017 res_cur
= bus_cur
->firstMem
;
1018 noranges
= bus_cur
->noMemRanges
;
1021 res_cur
= bus_cur
->firstPFMem
;
1022 noranges
= bus_cur
->noPFMemRanges
;
1025 err ("wrong type of resource to check\n");
1031 range
= find_range (bus_cur
, res_cur
);
1032 debug ("%s - rangeno = %d\n", __func__
, res_cur
->rangeno
);
1035 err ("no range for the device exists... bailing out...\n");
1039 /* found our range */
1041 /* first time in the loop */
1042 if ((res_cur
->start
!= range
->start
) && ((len_tmp
= res_cur
->start
- 1 - range
->start
) >= res
->len
)) {
1043 debug ("len_tmp = %x\n", len_tmp
);
1045 if ((len_tmp
< len_cur
) || (len_cur
== 0)) {
1047 if ((range
->start
% tmp_divide
) == 0) {
1048 /* just perfect, starting address is divisible by length */
1051 start_cur
= range
->start
;
1053 /* Needs adjusting */
1054 tmp_start
= range
->start
;
1057 while ((len_tmp
= res_cur
->start
- 1 - tmp_start
) >= res
->len
) {
1058 if ((tmp_start
% tmp_divide
) == 0) {
1061 start_cur
= tmp_start
;
1064 tmp_start
+= tmp_divide
- tmp_start
% tmp_divide
;
1065 if (tmp_start
>= res_cur
->start
- 1)
1070 if (flag
&& len_cur
== res
->len
) {
1071 debug ("but we are not here, right?\n");
1072 res
->start
= start_cur
;
1073 res
->len
+= 1; /* To restore the balance */
1074 res
->end
= res
->start
+ res
->len
- 1;
1080 if (!res_cur
->next
) {
1081 /* last device on the range */
1082 if ((range
->end
!= res_cur
->end
) && ((len_tmp
= range
->end
- (res_cur
->end
+ 1)) >= res
->len
)) {
1083 debug ("len_tmp = %x\n", len_tmp
);
1084 if ((len_tmp
< len_cur
) || (len_cur
== 0)) {
1086 if (((res_cur
->end
+ 1) % tmp_divide
) == 0) {
1087 /* just perfect, starting address is divisible by length */
1090 start_cur
= res_cur
->end
+ 1;
1092 /* Needs adjusting */
1093 tmp_start
= res_cur
->end
+ 1;
1096 while ((len_tmp
= range
->end
- tmp_start
) >= res
->len
) {
1097 if ((tmp_start
% tmp_divide
) == 0) {
1100 start_cur
= tmp_start
;
1103 tmp_start
+= tmp_divide
- tmp_start
% tmp_divide
;
1104 if (tmp_start
>= range
->end
)
1108 if (flag
&& len_cur
== res
->len
) {
1109 res
->start
= start_cur
;
1110 res
->len
+= 1; /* To restore the balance */
1111 res
->end
= res
->start
+ res
->len
- 1;
1119 if (res_prev
->rangeno
!= res_cur
->rangeno
) {
1120 /* 1st device on this range */
1121 if ((res_cur
->start
!= range
->start
) &&
1122 ((len_tmp
= res_cur
->start
- 1 - range
->start
) >= res
->len
)) {
1123 if ((len_tmp
< len_cur
) || (len_cur
== 0)) {
1124 if ((range
->start
% tmp_divide
) == 0) {
1125 /* just perfect, starting address is divisible by length */
1128 start_cur
= range
->start
;
1130 /* Needs adjusting */
1131 tmp_start
= range
->start
;
1134 while ((len_tmp
= res_cur
->start
- 1 - tmp_start
) >= res
->len
) {
1135 if ((tmp_start
% tmp_divide
) == 0) {
1138 start_cur
= tmp_start
;
1141 tmp_start
+= tmp_divide
- tmp_start
% tmp_divide
;
1142 if (tmp_start
>= res_cur
->start
- 1)
1147 if (flag
&& len_cur
== res
->len
) {
1148 res
->start
= start_cur
;
1149 res
->len
+= 1; /* To restore the balance */
1150 res
->end
= res
->start
+ res
->len
- 1;
1156 /* in the same range */
1157 if ((len_tmp
= res_cur
->start
- 1 - res_prev
->end
- 1) >= res
->len
) {
1158 if ((len_tmp
< len_cur
) || (len_cur
== 0)) {
1159 if (((res_prev
->end
+ 1) % tmp_divide
) == 0) {
1160 /* just perfect, starting address's divisible by length */
1163 start_cur
= res_prev
->end
+ 1;
1165 /* Needs adjusting */
1166 tmp_start
= res_prev
->end
+ 1;
1169 while ((len_tmp
= res_cur
->start
- 1 - tmp_start
) >= res
->len
) {
1170 if ((tmp_start
% tmp_divide
) == 0) {
1173 start_cur
= tmp_start
;
1176 tmp_start
+= tmp_divide
- tmp_start
% tmp_divide
;
1177 if (tmp_start
>= res_cur
->start
- 1)
1182 if (flag
&& len_cur
== res
->len
) {
1183 res
->start
= start_cur
;
1184 res
->len
+= 1; /* To restore the balance */
1185 res
->end
= res
->start
+ res
->len
- 1;
1192 /* end if (res_prev) */
1195 res_cur
= res_cur
->next
;
1197 res_cur
= res_cur
->nextRange
;
1198 } /* end of while */
1202 /* 1st device ever */
1203 /* need to find appropriate range */
1204 switch (res
->type
) {
1206 range
= bus_cur
->rangeIO
;
1209 range
= bus_cur
->rangeMem
;
1212 range
= bus_cur
->rangePFMem
;
1216 if ((len_tmp
= range
->end
- range
->start
) >= res
->len
) {
1217 if ((len_tmp
< len_cur
) || (len_cur
== 0)) {
1218 if ((range
->start
% tmp_divide
) == 0) {
1219 /* just perfect, starting address's divisible by length */
1222 start_cur
= range
->start
;
1224 /* Needs adjusting */
1225 tmp_start
= range
->start
;
1228 while ((len_tmp
= range
->end
- tmp_start
) >= res
->len
) {
1229 if ((tmp_start
% tmp_divide
) == 0) {
1232 start_cur
= tmp_start
;
1235 tmp_start
+= tmp_divide
- tmp_start
% tmp_divide
;
1236 if (tmp_start
>= range
->end
)
1241 if (flag
&& len_cur
== res
->len
) {
1242 res
->start
= start_cur
;
1243 res
->len
+= 1; /* To restore the balance */
1244 res
->end
= res
->start
+ res
->len
- 1;
1249 range
= range
->next
;
1250 } /* end of while */
1252 if ((!range
) && (len_cur
== 0)) {
1253 /* have gone through the list of devices and ranges and haven't found n.e.thing */
1254 err ("no appropriate range.. bailing out...\n");
1256 } else if (len_cur
) {
1257 res
->start
= start_cur
;
1258 res
->len
+= 1; /* To restore the balance */
1259 res
->end
= res
->start
+ res
->len
- 1;
1265 debug ("prev->rangeno = %d, noranges = %d\n", res_prev
->rangeno
, noranges
);
1266 if (res_prev
->rangeno
< noranges
) {
1267 /* if there're more ranges out there to check */
1268 switch (res
->type
) {
1270 range
= bus_cur
->rangeIO
;
1273 range
= bus_cur
->rangeMem
;
1276 range
= bus_cur
->rangePFMem
;
1280 if ((len_tmp
= range
->end
- range
->start
) >= res
->len
) {
1281 if ((len_tmp
< len_cur
) || (len_cur
== 0)) {
1282 if ((range
->start
% tmp_divide
) == 0) {
1283 /* just perfect, starting address's divisible by length */
1286 start_cur
= range
->start
;
1288 /* Needs adjusting */
1289 tmp_start
= range
->start
;
1292 while ((len_tmp
= range
->end
- tmp_start
) >= res
->len
) {
1293 if ((tmp_start
% tmp_divide
) == 0) {
1296 start_cur
= tmp_start
;
1299 tmp_start
+= tmp_divide
- tmp_start
% tmp_divide
;
1300 if (tmp_start
>= range
->end
)
1305 if (flag
&& len_cur
== res
->len
) {
1306 res
->start
= start_cur
;
1307 res
->len
+= 1; /* To restore the balance */
1308 res
->end
= res
->start
+ res
->len
- 1;
1313 range
= range
->next
;
1314 } /* end of while */
1316 if ((!range
) && (len_cur
== 0)) {
1317 /* have gone through the list of devices and ranges and haven't found n.e.thing */
1318 err ("no appropriate range.. bailing out...\n");
1320 } else if (len_cur
) {
1321 res
->start
= start_cur
;
1322 res
->len
+= 1; /* To restore the balance */
1323 res
->end
= res
->start
+ res
->len
- 1;
1327 /* no more ranges to check on */
1329 res
->start
= start_cur
;
1330 res
->len
+= 1; /* To restore the balance */
1331 res
->end
= res
->start
+ res
->len
- 1;
1334 /* have gone through the list of devices and haven't found n.e.thing */
1335 err ("no appropriate range.. bailing out...\n");
1339 } /* end if(!res_cur) */
1343 /********************************************************************************
1344 * This routine is called from remove_card if the card contained PPB.
1345 * It will remove all the resources on the bus as well as the bus itself
1347 * Output: 0, -ENODEV
1348 ********************************************************************************/
1349 int ibmphp_remove_bus (struct bus_node
*bus
, u8 parent_busno
)
1351 struct resource_node
*res_cur
;
1352 struct resource_node
*res_tmp
;
1353 struct bus_node
*prev_bus
;
1356 prev_bus
= find_bus_wprev (parent_busno
, NULL
, 0);
1359 debug ("something terribly wrong. Cannot find parent bus to the one to remove\n");
1363 debug ("In ibmphp_remove_bus... prev_bus->busno is %x\n", prev_bus
->busno
);
1365 rc
= remove_ranges (bus
, prev_bus
);
1370 res_cur
= bus
->firstIO
;
1374 res_cur
= res_cur
->next
;
1376 res_cur
= res_cur
->nextRange
;
1380 bus
->firstIO
= NULL
;
1382 if (bus
->firstMem
) {
1383 res_cur
= bus
->firstMem
;
1387 res_cur
= res_cur
->next
;
1389 res_cur
= res_cur
->nextRange
;
1393 bus
->firstMem
= NULL
;
1395 if (bus
->firstPFMem
) {
1396 res_cur
= bus
->firstPFMem
;
1400 res_cur
= res_cur
->next
;
1402 res_cur
= res_cur
->nextRange
;
1406 bus
->firstPFMem
= NULL
;
1409 if (bus
->firstPFMemFromMem
) {
1410 res_cur
= bus
->firstPFMemFromMem
;
1413 res_cur
= res_cur
->next
;
1418 bus
->firstPFMemFromMem
= NULL
;
1421 list_del (&bus
->bus_list
);
1426 /******************************************************************************
1427 * This routine deletes the ranges from a given bus, and the entries from the
1428 * parent's bus in the resources
1429 * Input: current bus, previous bus
1430 * Output: 0, -EINVAL
1431 ******************************************************************************/
1432 static int remove_ranges (struct bus_node
*bus_cur
, struct bus_node
*bus_prev
)
1434 struct range_node
*range_cur
;
1435 struct range_node
*range_tmp
;
1437 struct resource_node
*res
= NULL
;
1439 if (bus_cur
->noIORanges
) {
1440 range_cur
= bus_cur
->rangeIO
;
1441 for (i
= 0; i
< bus_cur
->noIORanges
; i
++) {
1442 if (ibmphp_find_resource (bus_prev
, range_cur
->start
, &res
, IO
) < 0)
1444 ibmphp_remove_resource (res
);
1446 range_tmp
= range_cur
;
1447 range_cur
= range_cur
->next
;
1451 bus_cur
->rangeIO
= NULL
;
1453 if (bus_cur
->noMemRanges
) {
1454 range_cur
= bus_cur
->rangeMem
;
1455 for (i
= 0; i
< bus_cur
->noMemRanges
; i
++) {
1456 if (ibmphp_find_resource (bus_prev
, range_cur
->start
, &res
, MEM
) < 0)
1459 ibmphp_remove_resource (res
);
1460 range_tmp
= range_cur
;
1461 range_cur
= range_cur
->next
;
1465 bus_cur
->rangeMem
= NULL
;
1467 if (bus_cur
->noPFMemRanges
) {
1468 range_cur
= bus_cur
->rangePFMem
;
1469 for (i
= 0; i
< bus_cur
->noPFMemRanges
; i
++) {
1470 if (ibmphp_find_resource (bus_prev
, range_cur
->start
, &res
, PFMEM
) < 0)
1473 ibmphp_remove_resource (res
);
1474 range_tmp
= range_cur
;
1475 range_cur
= range_cur
->next
;
1479 bus_cur
->rangePFMem
= NULL
;
1485 * find the resource node in the bus
1486 * Input: Resource needed, start address of the resource, type of resource
1488 int ibmphp_find_resource (struct bus_node
*bus
, u32 start_address
, struct resource_node
**res
, int flag
)
1490 struct resource_node
*res_cur
= NULL
;
1494 err ("The bus passed in NULL to find resource\n");
1500 res_cur
= bus
->firstIO
;
1504 res_cur
= bus
->firstMem
;
1508 res_cur
= bus
->firstPFMem
;
1512 err ("wrong type of flag\n");
1517 if (res_cur
->start
== start_address
) {
1522 res_cur
= res_cur
->next
;
1524 res_cur
= res_cur
->nextRange
;
1528 if (flag
== PFMEM
) {
1529 res_cur
= bus
->firstPFMemFromMem
;
1531 if (res_cur
->start
== start_address
) {
1535 res_cur
= res_cur
->next
;
1538 debug ("SOS...cannot find %s resource in the bus.\n", type
);
1542 debug ("SOS... cannot find %s resource in the bus.\n", type
);
1548 debug ("*res->start = %x\n", (*res
)->start
);
1553 /***********************************************************************
1554 * This routine will free the resource structures used by the
1555 * system. It is called from cleanup routine for the module
1558 ***********************************************************************/
1559 void ibmphp_free_resources (void)
1561 struct bus_node
*bus_cur
= NULL
;
1562 struct bus_node
*bus_tmp
;
1563 struct range_node
*range_cur
;
1564 struct range_node
*range_tmp
;
1565 struct resource_node
*res_cur
;
1566 struct resource_node
*res_tmp
;
1567 struct list_head
*tmp
;
1568 struct list_head
*next
;
1572 list_for_each_safe (tmp
, next
, &gbuses
) {
1573 bus_cur
= list_entry (tmp
, struct bus_node
, bus_list
);
1574 if (bus_cur
->noIORanges
) {
1575 range_cur
= bus_cur
->rangeIO
;
1576 for (i
= 0; i
< bus_cur
->noIORanges
; i
++) {
1579 range_tmp
= range_cur
;
1580 range_cur
= range_cur
->next
;
1585 if (bus_cur
->noMemRanges
) {
1586 range_cur
= bus_cur
->rangeMem
;
1587 for (i
= 0; i
< bus_cur
->noMemRanges
; i
++) {
1590 range_tmp
= range_cur
;
1591 range_cur
= range_cur
->next
;
1596 if (bus_cur
->noPFMemRanges
) {
1597 range_cur
= bus_cur
->rangePFMem
;
1598 for (i
= 0; i
< bus_cur
->noPFMemRanges
; i
++) {
1601 range_tmp
= range_cur
;
1602 range_cur
= range_cur
->next
;
1608 if (bus_cur
->firstIO
) {
1609 res_cur
= bus_cur
->firstIO
;
1613 res_cur
= res_cur
->next
;
1615 res_cur
= res_cur
->nextRange
;
1619 bus_cur
->firstIO
= NULL
;
1621 if (bus_cur
->firstMem
) {
1622 res_cur
= bus_cur
->firstMem
;
1626 res_cur
= res_cur
->next
;
1628 res_cur
= res_cur
->nextRange
;
1632 bus_cur
->firstMem
= NULL
;
1634 if (bus_cur
->firstPFMem
) {
1635 res_cur
= bus_cur
->firstPFMem
;
1639 res_cur
= res_cur
->next
;
1641 res_cur
= res_cur
->nextRange
;
1645 bus_cur
->firstPFMem
= NULL
;
1648 if (bus_cur
->firstPFMemFromMem
) {
1649 res_cur
= bus_cur
->firstPFMemFromMem
;
1652 res_cur
= res_cur
->next
;
1657 bus_cur
->firstPFMemFromMem
= NULL
;
1661 list_del (&bus_cur
->bus_list
);
1667 /*********************************************************************************
1668 * This function will go over the PFmem resources to check if the EBDA allocated
1669 * pfmem out of memory buckets of the bus. If so, it will change the range numbers
1670 * and a flag to indicate that this resource is out of memory. It will also move the
1671 * Pfmem out of the pfmem resource list to the PFMemFromMem list, and will create
1673 * This routine is called right after initialization
1674 *******************************************************************************/
1675 static int __init
once_over (void)
1677 struct resource_node
*pfmem_cur
;
1678 struct resource_node
*pfmem_prev
;
1679 struct resource_node
*mem
;
1680 struct bus_node
*bus_cur
;
1681 struct list_head
*tmp
;
1683 list_for_each (tmp
, &gbuses
) {
1684 bus_cur
= list_entry (tmp
, struct bus_node
, bus_list
);
1685 if ((!bus_cur
->rangePFMem
) && (bus_cur
->firstPFMem
)) {
1686 for (pfmem_cur
= bus_cur
->firstPFMem
, pfmem_prev
= NULL
; pfmem_cur
; pfmem_prev
= pfmem_cur
, pfmem_cur
= pfmem_cur
->next
) {
1687 pfmem_cur
->fromMem
= 1;
1689 pfmem_prev
->next
= pfmem_cur
->next
;
1691 bus_cur
->firstPFMem
= pfmem_cur
->next
;
1693 if (!bus_cur
->firstPFMemFromMem
)
1694 pfmem_cur
->next
= NULL
;
1696 /* we don't need to sort PFMemFromMem since we're using mem node for
1697 all the real work anyways, so just insert at the beginning of the
1700 pfmem_cur
->next
= bus_cur
->firstPFMemFromMem
;
1702 bus_cur
->firstPFMemFromMem
= pfmem_cur
;
1704 mem
= kzalloc(sizeof(struct resource_node
), GFP_KERNEL
);
1706 err ("out of system memory\n");
1710 mem
->busno
= pfmem_cur
->busno
;
1711 mem
->devfunc
= pfmem_cur
->devfunc
;
1712 mem
->start
= pfmem_cur
->start
;
1713 mem
->end
= pfmem_cur
->end
;
1714 mem
->len
= pfmem_cur
->len
;
1715 if (ibmphp_add_resource (mem
) < 0)
1716 err ("Trouble...trouble... EBDA allocated pfmem from mem, but system doesn't display it has this space... unless not PCI device...\n");
1717 pfmem_cur
->rangeno
= mem
->rangeno
;
1718 } /* end for pfmem */
1720 } /* end list_for_each bus */
1724 int ibmphp_add_pfmem_from_mem (struct resource_node
*pfmem
)
1726 struct bus_node
*bus_cur
= find_bus_wprev (pfmem
->busno
, NULL
, 0);
1729 err ("cannot find bus of pfmem to add...\n");
1733 if (bus_cur
->firstPFMemFromMem
)
1734 pfmem
->next
= bus_cur
->firstPFMemFromMem
;
1738 bus_cur
->firstPFMemFromMem
= pfmem
;
1743 /* This routine just goes through the buses to see if the bus already exists.
1744 * It is called from ibmphp_find_sec_number, to find out a secondary bus number for
1746 * Parameters: bus_number
1747 * Returns: Bus pointer or NULL
1749 struct bus_node
*ibmphp_find_res_bus (u8 bus_number
)
1751 return find_bus_wprev (bus_number
, NULL
, 0);
1754 static struct bus_node
*find_bus_wprev (u8 bus_number
, struct bus_node
**prev
, u8 flag
)
1756 struct bus_node
*bus_cur
;
1757 struct list_head
*tmp
;
1758 struct list_head
*tmp_prev
;
1760 list_for_each (tmp
, &gbuses
) {
1761 tmp_prev
= tmp
->prev
;
1762 bus_cur
= list_entry (tmp
, struct bus_node
, bus_list
);
1764 *prev
= list_entry (tmp_prev
, struct bus_node
, bus_list
);
1765 if (bus_cur
->busno
== bus_number
)
1772 void ibmphp_print_test (void)
1775 struct bus_node
*bus_cur
= NULL
;
1776 struct range_node
*range
;
1777 struct resource_node
*res
;
1778 struct list_head
*tmp
;
1780 debug_pci ("*****************START**********************\n");
1782 if ((!list_empty(&gbuses
)) && flags
) {
1783 err ("The GBUSES is not NULL?!?!?!?!?\n");
1787 list_for_each (tmp
, &gbuses
) {
1788 bus_cur
= list_entry (tmp
, struct bus_node
, bus_list
);
1789 debug_pci ("This is bus # %d. There are\n", bus_cur
->busno
);
1790 debug_pci ("IORanges = %d\t", bus_cur
->noIORanges
);
1791 debug_pci ("MemRanges = %d\t", bus_cur
->noMemRanges
);
1792 debug_pci ("PFMemRanges = %d\n", bus_cur
->noPFMemRanges
);
1793 debug_pci ("The IO Ranges are as follows:\n");
1794 if (bus_cur
->rangeIO
) {
1795 range
= bus_cur
->rangeIO
;
1796 for (i
= 0; i
< bus_cur
->noIORanges
; i
++) {
1797 debug_pci ("rangeno is %d\n", range
->rangeno
);
1798 debug_pci ("[%x - %x]\n", range
->start
, range
->end
);
1799 range
= range
->next
;
1803 debug_pci ("The Mem Ranges are as follows:\n");
1804 if (bus_cur
->rangeMem
) {
1805 range
= bus_cur
->rangeMem
;
1806 for (i
= 0; i
< bus_cur
->noMemRanges
; i
++) {
1807 debug_pci ("rangeno is %d\n", range
->rangeno
);
1808 debug_pci ("[%x - %x]\n", range
->start
, range
->end
);
1809 range
= range
->next
;
1813 debug_pci ("The PFMem Ranges are as follows:\n");
1815 if (bus_cur
->rangePFMem
) {
1816 range
= bus_cur
->rangePFMem
;
1817 for (i
= 0; i
< bus_cur
->noPFMemRanges
; i
++) {
1818 debug_pci ("rangeno is %d\n", range
->rangeno
);
1819 debug_pci ("[%x - %x]\n", range
->start
, range
->end
);
1820 range
= range
->next
;
1824 debug_pci ("The resources on this bus are as follows\n");
1826 debug_pci ("IO...\n");
1827 if (bus_cur
->firstIO
) {
1828 res
= bus_cur
->firstIO
;
1830 debug_pci ("The range # is %d\n", res
->rangeno
);
1831 debug_pci ("The bus, devfnc is %d, %x\n", res
->busno
, res
->devfunc
);
1832 debug_pci ("[%x - %x], len=%x\n", res
->start
, res
->end
, res
->len
);
1835 else if (res
->nextRange
)
1836 res
= res
->nextRange
;
1841 debug_pci ("Mem...\n");
1842 if (bus_cur
->firstMem
) {
1843 res
= bus_cur
->firstMem
;
1845 debug_pci ("The range # is %d\n", res
->rangeno
);
1846 debug_pci ("The bus, devfnc is %d, %x\n", res
->busno
, res
->devfunc
);
1847 debug_pci ("[%x - %x], len=%x\n", res
->start
, res
->end
, res
->len
);
1850 else if (res
->nextRange
)
1851 res
= res
->nextRange
;
1856 debug_pci ("PFMem...\n");
1857 if (bus_cur
->firstPFMem
) {
1858 res
= bus_cur
->firstPFMem
;
1860 debug_pci ("The range # is %d\n", res
->rangeno
);
1861 debug_pci ("The bus, devfnc is %d, %x\n", res
->busno
, res
->devfunc
);
1862 debug_pci ("[%x - %x], len=%x\n", res
->start
, res
->end
, res
->len
);
1865 else if (res
->nextRange
)
1866 res
= res
->nextRange
;
1872 debug_pci ("PFMemFromMem...\n");
1873 if (bus_cur
->firstPFMemFromMem
) {
1874 res
= bus_cur
->firstPFMemFromMem
;
1876 debug_pci ("The range # is %d\n", res
->rangeno
);
1877 debug_pci ("The bus, devfnc is %d, %x\n", res
->busno
, res
->devfunc
);
1878 debug_pci ("[%x - %x], len=%x\n", res
->start
, res
->end
, res
->len
);
1883 debug_pci ("***********************END***********************\n");
1886 static int range_exists_already (struct range_node
* range
, struct bus_node
* bus_cur
, u8 type
)
1888 struct range_node
* range_cur
= NULL
;
1891 range_cur
= bus_cur
->rangeIO
;
1894 range_cur
= bus_cur
->rangeMem
;
1897 range_cur
= bus_cur
->rangePFMem
;
1900 err ("wrong type passed to find out if range already exists\n");
1905 if ((range_cur
->start
== range
->start
) && (range_cur
->end
== range
->end
))
1907 range_cur
= range_cur
->next
;
1913 /* This routine will read the windows for any PPB we have and update the
1914 * range info for the secondary bus, and will also input this info into
1915 * primary bus, since BIOS doesn't. This is for PPB that are in the system
1916 * on bootup. For bridged cards that were added during previous load of the
1917 * driver, only the ranges and the bus structure are added, the devices are
1919 * Input: primary busno
1921 * Note: this function doesn't take into account IO restrictions etc,
1922 * so will only work for bridges with no video/ISA devices behind them It
1923 * also will not work for onboard PPBs that can have more than 1 *bus
1924 * behind them All these are TO DO.
1925 * Also need to add more error checkings... (from fnc returns etc)
1927 static int __init
update_bridge_ranges (struct bus_node
**bus
)
1929 u8 sec_busno
, device
, function
, hdr_type
, start_io_address
, end_io_address
;
1930 u16 vendor_id
, upper_io_start
, upper_io_end
, start_mem_address
, end_mem_address
;
1931 u32 start_address
, end_address
, upper_start
, upper_end
;
1932 struct bus_node
*bus_sec
;
1933 struct bus_node
*bus_cur
;
1934 struct resource_node
*io
;
1935 struct resource_node
*mem
;
1936 struct resource_node
*pfmem
;
1937 struct range_node
*range
;
1943 ibmphp_pci_bus
->number
= bus_cur
->busno
;
1945 debug ("inside %s\n", __func__
);
1946 debug ("bus_cur->busno = %x\n", bus_cur
->busno
);
1948 for (device
= 0; device
< 32; device
++) {
1949 for (function
= 0x00; function
< 0x08; function
++) {
1950 devfn
= PCI_DEVFN(device
, function
);
1951 pci_bus_read_config_word (ibmphp_pci_bus
, devfn
, PCI_VENDOR_ID
, &vendor_id
);
1953 if (vendor_id
!= PCI_VENDOR_ID_NOTVALID
) {
1954 /* found correct device!!! */
1955 pci_bus_read_config_byte (ibmphp_pci_bus
, devfn
, PCI_HEADER_TYPE
, &hdr_type
);
1958 case PCI_HEADER_TYPE_NORMAL
:
1961 case PCI_HEADER_TYPE_MULTIDEVICE
:
1963 case PCI_HEADER_TYPE_BRIDGE
:
1965 case PCI_HEADER_TYPE_MULTIBRIDGE
:
1966 /* We assume here that only 1 bus behind the bridge
1967 TO DO: add functionality for several:
1969 while (temp < subordinate) {
1974 pci_bus_read_config_byte (ibmphp_pci_bus
, devfn
, PCI_SECONDARY_BUS
, &sec_busno
);
1975 bus_sec
= find_bus_wprev (sec_busno
, NULL
, 0);
1976 /* this bus structure doesn't exist yet, PPB was configured during previous loading of ibmphp */
1978 bus_sec
= alloc_error_bus (NULL
, sec_busno
, 1);
1979 /* the rest will be populated during NVRAM call */
1982 pci_bus_read_config_byte (ibmphp_pci_bus
, devfn
, PCI_IO_BASE
, &start_io_address
);
1983 pci_bus_read_config_byte (ibmphp_pci_bus
, devfn
, PCI_IO_LIMIT
, &end_io_address
);
1984 pci_bus_read_config_word (ibmphp_pci_bus
, devfn
, PCI_IO_BASE_UPPER16
, &upper_io_start
);
1985 pci_bus_read_config_word (ibmphp_pci_bus
, devfn
, PCI_IO_LIMIT_UPPER16
, &upper_io_end
);
1986 start_address
= (start_io_address
& PCI_IO_RANGE_MASK
) << 8;
1987 start_address
|= (upper_io_start
<< 16);
1988 end_address
= (end_io_address
& PCI_IO_RANGE_MASK
) << 8;
1989 end_address
|= (upper_io_end
<< 16);
1991 if ((start_address
) && (start_address
<= end_address
)) {
1992 range
= kzalloc(sizeof(struct range_node
), GFP_KERNEL
);
1994 err ("out of system memory\n");
1997 range
->start
= start_address
;
1998 range
->end
= end_address
+ 0xfff;
2000 if (bus_sec
->noIORanges
> 0) {
2001 if (!range_exists_already (range
, bus_sec
, IO
)) {
2002 add_bus_range (IO
, range
, bus_sec
);
2003 ++bus_sec
->noIORanges
;
2009 /* 1st IO Range on the bus */
2011 bus_sec
->rangeIO
= range
;
2012 ++bus_sec
->noIORanges
;
2014 fix_resources (bus_sec
);
2016 if (ibmphp_find_resource (bus_cur
, start_address
, &io
, IO
)) {
2017 io
= kzalloc(sizeof(struct resource_node
), GFP_KERNEL
);
2020 err ("out of system memory\n");
2024 io
->busno
= bus_cur
->busno
;
2025 io
->devfunc
= ((device
<< 3) | (function
& 0x7));
2026 io
->start
= start_address
;
2027 io
->end
= end_address
+ 0xfff;
2028 io
->len
= io
->end
- io
->start
+ 1;
2029 ibmphp_add_resource (io
);
2033 pci_bus_read_config_word (ibmphp_pci_bus
, devfn
, PCI_MEMORY_BASE
, &start_mem_address
);
2034 pci_bus_read_config_word (ibmphp_pci_bus
, devfn
, PCI_MEMORY_LIMIT
, &end_mem_address
);
2036 start_address
= 0x00000000 | (start_mem_address
& PCI_MEMORY_RANGE_MASK
) << 16;
2037 end_address
= 0x00000000 | (end_mem_address
& PCI_MEMORY_RANGE_MASK
) << 16;
2039 if ((start_address
) && (start_address
<= end_address
)) {
2041 range
= kzalloc(sizeof(struct range_node
), GFP_KERNEL
);
2043 err ("out of system memory\n");
2046 range
->start
= start_address
;
2047 range
->end
= end_address
+ 0xfffff;
2049 if (bus_sec
->noMemRanges
> 0) {
2050 if (!range_exists_already (range
, bus_sec
, MEM
)) {
2051 add_bus_range (MEM
, range
, bus_sec
);
2052 ++bus_sec
->noMemRanges
;
2058 /* 1st Mem Range on the bus */
2060 bus_sec
->rangeMem
= range
;
2061 ++bus_sec
->noMemRanges
;
2064 fix_resources (bus_sec
);
2066 if (ibmphp_find_resource (bus_cur
, start_address
, &mem
, MEM
)) {
2067 mem
= kzalloc(sizeof(struct resource_node
), GFP_KERNEL
);
2070 err ("out of system memory\n");
2074 mem
->busno
= bus_cur
->busno
;
2075 mem
->devfunc
= ((device
<< 3) | (function
& 0x7));
2076 mem
->start
= start_address
;
2077 mem
->end
= end_address
+ 0xfffff;
2078 mem
->len
= mem
->end
- mem
->start
+ 1;
2079 ibmphp_add_resource (mem
);
2082 pci_bus_read_config_word (ibmphp_pci_bus
, devfn
, PCI_PREF_MEMORY_BASE
, &start_mem_address
);
2083 pci_bus_read_config_word (ibmphp_pci_bus
, devfn
, PCI_PREF_MEMORY_LIMIT
, &end_mem_address
);
2084 pci_bus_read_config_dword (ibmphp_pci_bus
, devfn
, PCI_PREF_BASE_UPPER32
, &upper_start
);
2085 pci_bus_read_config_dword (ibmphp_pci_bus
, devfn
, PCI_PREF_LIMIT_UPPER32
, &upper_end
);
2086 start_address
= 0x00000000 | (start_mem_address
& PCI_MEMORY_RANGE_MASK
) << 16;
2087 end_address
= 0x00000000 | (end_mem_address
& PCI_MEMORY_RANGE_MASK
) << 16;
2088 #if BITS_PER_LONG == 64
2089 start_address
|= ((long) upper_start
) << 32;
2090 end_address
|= ((long) upper_end
) << 32;
2093 if ((start_address
) && (start_address
<= end_address
)) {
2095 range
= kzalloc(sizeof(struct range_node
), GFP_KERNEL
);
2097 err ("out of system memory\n");
2100 range
->start
= start_address
;
2101 range
->end
= end_address
+ 0xfffff;
2103 if (bus_sec
->noPFMemRanges
> 0) {
2104 if (!range_exists_already (range
, bus_sec
, PFMEM
)) {
2105 add_bus_range (PFMEM
, range
, bus_sec
);
2106 ++bus_sec
->noPFMemRanges
;
2112 /* 1st PFMem Range on the bus */
2114 bus_sec
->rangePFMem
= range
;
2115 ++bus_sec
->noPFMemRanges
;
2118 fix_resources (bus_sec
);
2119 if (ibmphp_find_resource (bus_cur
, start_address
, &pfmem
, PFMEM
)) {
2120 pfmem
= kzalloc(sizeof(struct resource_node
), GFP_KERNEL
);
2123 err ("out of system memory\n");
2126 pfmem
->type
= PFMEM
;
2127 pfmem
->busno
= bus_cur
->busno
;
2128 pfmem
->devfunc
= ((device
<< 3) | (function
& 0x7));
2129 pfmem
->start
= start_address
;
2130 pfmem
->end
= end_address
+ 0xfffff;
2131 pfmem
->len
= pfmem
->end
- pfmem
->start
+ 1;
2134 ibmphp_add_resource (pfmem
);
2138 } /* end of switch */
2139 } /* end if vendor */
2140 } /* end for function */
2141 } /* end for device */