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