xref: /openbmc/linux/drivers/pci/hotplug/ibmphp_pci.c (revision 5810ab21)
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 "ibmphp.h"
21 
22 
23 static int configure_device(struct pci_func *);
24 static int configure_bridge(struct pci_func **, u8);
25 static struct res_needed *scan_behind_bridge(struct pci_func *, u8);
26 static int add_new_bus(struct bus_node *, struct resource_node *, struct resource_node *, struct resource_node *, u8);
27 static u8 find_sec_number(u8 primary_busno, u8 slotno);
28 
29 /*
30  * NOTE..... If BIOS doesn't provide default routing, we assign:
31  * 9 for SCSI, 10 for LAN adapters, and 11 for everything else.
32  * If adapter is bridged, then we assign 11 to it and devices behind it.
33  * We also assign the same irq numbers for multi function devices.
34  * These are PIC mode, so shouldn't matter n.e.ways (hopefully)
35  */
assign_alt_irq(struct pci_func * cur_func,u8 class_code)36 static void assign_alt_irq(struct pci_func *cur_func, u8 class_code)
37 {
38 	int j;
39 	for (j = 0; j < 4; j++) {
40 		if (cur_func->irq[j] == 0xff) {
41 			switch (class_code) {
42 				case PCI_BASE_CLASS_STORAGE:
43 					cur_func->irq[j] = SCSI_IRQ;
44 					break;
45 				case PCI_BASE_CLASS_NETWORK:
46 					cur_func->irq[j] = LAN_IRQ;
47 					break;
48 				default:
49 					cur_func->irq[j] = OTHER_IRQ;
50 					break;
51 			}
52 		}
53 	}
54 }
55 
56 /*
57  * Configures the device to be added (will allocate needed resources if it
58  * can), the device can be a bridge or a regular pci device, can also be
59  * multi-functional
60  *
61  * Input: function to be added
62  *
63  * TO DO:  The error case with Multifunction device or multi function bridge,
64  * if there is an error, will need to go through all previous functions and
65  * unconfigure....or can add some code into unconfigure_card....
66  */
ibmphp_configure_card(struct pci_func * func,u8 slotno)67 int ibmphp_configure_card(struct pci_func *func, u8 slotno)
68 {
69 	u16 vendor_id;
70 	u32 class;
71 	u8 class_code;
72 	u8 hdr_type, device, sec_number;
73 	u8 function;
74 	struct pci_func *newfunc;	/* for multi devices */
75 	struct pci_func *cur_func, *prev_func;
76 	int rc, i, j;
77 	int cleanup_count;
78 	u8 flag;
79 	u8 valid_device = 0x00; /* to see if we are able to read from card any device info at all */
80 
81 	debug("inside configure_card, func->busno = %x\n", func->busno);
82 
83 	device = func->device;
84 	cur_func = func;
85 
86 	/* We only get bus and device from IRQ routing table.  So at this point,
87 	 * func->busno is correct, and func->device contains only device (at the 5
88 	 * highest bits)
89 	 */
90 
91 	/* For every function on the card */
92 	for (function = 0x00; function < 0x08; function++) {
93 		unsigned int devfn = PCI_DEVFN(device, function);
94 		ibmphp_pci_bus->number = cur_func->busno;
95 
96 		cur_func->function = function;
97 
98 		debug("inside the loop, cur_func->busno = %x, cur_func->device = %x, cur_func->function = %x\n",
99 			cur_func->busno, cur_func->device, cur_func->function);
100 
101 		pci_bus_read_config_word(ibmphp_pci_bus, devfn, PCI_VENDOR_ID, &vendor_id);
102 
103 		debug("vendor_id is %x\n", vendor_id);
104 		if (vendor_id != PCI_VENDOR_ID_NOTVALID) {
105 			/* found correct device!!! */
106 			debug("found valid device, vendor_id = %x\n", vendor_id);
107 
108 			++valid_device;
109 
110 			/* header: x x x x x x x x
111 			 *         | |___________|=> 1=PPB bridge, 0=normal device, 2=CardBus Bridge
112 			 *         |_=> 0 = single function device, 1 = multi-function device
113 			 */
114 
115 			pci_bus_read_config_byte(ibmphp_pci_bus, devfn, PCI_HEADER_TYPE, &hdr_type);
116 			pci_bus_read_config_dword(ibmphp_pci_bus, devfn, PCI_CLASS_REVISION, &class);
117 
118 			class_code = class >> 24;
119 			debug("hrd_type = %x, class = %x, class_code %x\n", hdr_type, class, class_code);
120 			class >>= 8;	/* to take revision out, class = class.subclass.prog i/f */
121 			if (class == PCI_CLASS_NOT_DEFINED_VGA) {
122 				err("The device %x is VGA compatible and as is not supported for hot plugging. "
123 				     "Please choose another device.\n", cur_func->device);
124 				return -ENODEV;
125 			} else if (class == PCI_CLASS_DISPLAY_VGA) {
126 				err("The device %x is not supported for hot plugging. Please choose another device.\n",
127 				     cur_func->device);
128 				return -ENODEV;
129 			}
130 			switch (hdr_type) {
131 				case PCI_HEADER_TYPE_NORMAL:
132 					debug("single device case.... vendor id = %x, hdr_type = %x, class = %x\n", vendor_id, hdr_type, class);
133 					assign_alt_irq(cur_func, class_code);
134 					rc = configure_device(cur_func);
135 					if (rc < 0) {
136 						/* We need to do this in case some other BARs were properly inserted */
137 						err("was not able to configure devfunc %x on bus %x.\n",
138 						     cur_func->device, cur_func->busno);
139 						cleanup_count = 6;
140 						goto error;
141 					}
142 					cur_func->next = NULL;
143 					function = 0x8;
144 					break;
145 				case PCI_HEADER_TYPE_MULTIDEVICE:
146 					assign_alt_irq(cur_func, class_code);
147 					rc = configure_device(cur_func);
148 					if (rc < 0) {
149 						/* We need to do this in case some other BARs were properly inserted */
150 						err("was not able to configure devfunc %x on bus %x...bailing out\n",
151 						     cur_func->device, cur_func->busno);
152 						cleanup_count = 6;
153 						goto error;
154 					}
155 					newfunc = kzalloc(sizeof(*newfunc), GFP_KERNEL);
156 					if (!newfunc)
157 						return -ENOMEM;
158 
159 					newfunc->busno = cur_func->busno;
160 					newfunc->device = device;
161 					cur_func->next = newfunc;
162 					cur_func = newfunc;
163 					for (j = 0; j < 4; j++)
164 						newfunc->irq[j] = cur_func->irq[j];
165 					break;
166 				case PCI_HEADER_TYPE_MULTIBRIDGE:
167 					class >>= 8;
168 					if (class != PCI_CLASS_BRIDGE_PCI) {
169 						err("This %x is not PCI-to-PCI bridge, and as is not supported for hot-plugging.  Please insert another card.\n",
170 						     cur_func->device);
171 						return -ENODEV;
172 					}
173 					assign_alt_irq(cur_func, class_code);
174 					rc = configure_bridge(&cur_func, slotno);
175 					if (rc == -ENODEV) {
176 						err("You chose to insert Single Bridge, or nested bridges, this is not supported...\n");
177 						err("Bus %x, devfunc %x\n", cur_func->busno, cur_func->device);
178 						return rc;
179 					}
180 					if (rc) {
181 						/* We need to do this in case some other BARs were properly inserted */
182 						err("was not able to hot-add PPB properly.\n");
183 						func->bus = 1; /* To indicate to the unconfigure function that this is a PPB */
184 						cleanup_count = 2;
185 						goto error;
186 					}
187 
188 					pci_bus_read_config_byte(ibmphp_pci_bus, devfn, PCI_SECONDARY_BUS, &sec_number);
189 					flag = 0;
190 					for (i = 0; i < 32; i++) {
191 						if (func->devices[i]) {
192 							newfunc = kzalloc(sizeof(*newfunc), GFP_KERNEL);
193 							if (!newfunc)
194 								return -ENOMEM;
195 
196 							newfunc->busno = sec_number;
197 							newfunc->device = (u8) i;
198 							for (j = 0; j < 4; j++)
199 								newfunc->irq[j] = cur_func->irq[j];
200 
201 							if (flag) {
202 								for (prev_func = cur_func; prev_func->next; prev_func = prev_func->next) ;
203 								prev_func->next = newfunc;
204 							} else
205 								cur_func->next = newfunc;
206 
207 							rc = ibmphp_configure_card(newfunc, slotno);
208 							/* This could only happen if kmalloc failed */
209 							if (rc) {
210 								/* We need to do this in case bridge itself got configured properly, but devices behind it failed */
211 								func->bus = 1; /* To indicate to the unconfigure function that this is a PPB */
212 								cleanup_count = 2;
213 								goto error;
214 							}
215 							flag = 1;
216 						}
217 					}
218 
219 					newfunc = kzalloc(sizeof(*newfunc), GFP_KERNEL);
220 					if (!newfunc)
221 						return -ENOMEM;
222 
223 					newfunc->busno = cur_func->busno;
224 					newfunc->device = device;
225 					for (j = 0; j < 4; j++)
226 						newfunc->irq[j] = cur_func->irq[j];
227 					for (prev_func = cur_func; prev_func->next; prev_func = prev_func->next);
228 					prev_func->next = newfunc;
229 					cur_func = newfunc;
230 					break;
231 				case PCI_HEADER_TYPE_BRIDGE:
232 					class >>= 8;
233 					debug("class now is %x\n", class);
234 					if (class != PCI_CLASS_BRIDGE_PCI) {
235 						err("This %x is not PCI-to-PCI bridge, and as is not supported for hot-plugging.  Please insert another card.\n",
236 						     cur_func->device);
237 						return -ENODEV;
238 					}
239 
240 					assign_alt_irq(cur_func, class_code);
241 
242 					debug("cur_func->busno b4 configure_bridge is %x\n", cur_func->busno);
243 					rc = configure_bridge(&cur_func, slotno);
244 					if (rc == -ENODEV) {
245 						err("You chose to insert Single Bridge, or nested bridges, this is not supported...\n");
246 						err("Bus %x, devfunc %x\n", cur_func->busno, cur_func->device);
247 						return rc;
248 					}
249 					if (rc) {
250 						/* We need to do this in case some other BARs were properly inserted */
251 						func->bus = 1; /* To indicate to the unconfigure function that this is a PPB */
252 						err("was not able to hot-add PPB properly.\n");
253 						cleanup_count = 2;
254 						goto error;
255 					}
256 					debug("cur_func->busno = %x, device = %x, function = %x\n",
257 						cur_func->busno, device, function);
258 					pci_bus_read_config_byte(ibmphp_pci_bus, devfn, PCI_SECONDARY_BUS, &sec_number);
259 					debug("after configuring bridge..., sec_number = %x\n", sec_number);
260 					flag = 0;
261 					for (i = 0; i < 32; i++) {
262 						if (func->devices[i]) {
263 							debug("inside for loop, device is %x\n", i);
264 							newfunc = kzalloc(sizeof(*newfunc), GFP_KERNEL);
265 							if (!newfunc)
266 								return -ENOMEM;
267 
268 							newfunc->busno = sec_number;
269 							newfunc->device = (u8) i;
270 							for (j = 0; j < 4; j++)
271 								newfunc->irq[j] = cur_func->irq[j];
272 
273 							if (flag) {
274 								for (prev_func = cur_func; prev_func->next; prev_func = prev_func->next);
275 								prev_func->next = newfunc;
276 							} else
277 								cur_func->next = newfunc;
278 
279 							rc = ibmphp_configure_card(newfunc, slotno);
280 
281 							/* Again, this case should not happen... For complete paranoia, will need to call remove_bus */
282 							if (rc) {
283 								/* We need to do this in case some other BARs were properly inserted */
284 								func->bus = 1; /* To indicate to the unconfigure function that this is a PPB */
285 								cleanup_count = 2;
286 								goto error;
287 							}
288 							flag = 1;
289 						}
290 					}
291 
292 					function = 0x8;
293 					break;
294 				default:
295 					err("MAJOR PROBLEM!!!!, header type not supported? %x\n", hdr_type);
296 					return -ENXIO;
297 			}	/* end of switch */
298 		}	/* end of valid device */
299 	}	/* end of for */
300 
301 	if (!valid_device) {
302 		err("Cannot find any valid devices on the card.  Or unable to read from card.\n");
303 		return -ENODEV;
304 	}
305 
306 	return 0;
307 
308 error:
309 	for (i = 0; i < cleanup_count; i++) {
310 		if (cur_func->io[i]) {
311 			ibmphp_remove_resource(cur_func->io[i]);
312 			cur_func->io[i] = NULL;
313 		} else if (cur_func->pfmem[i]) {
314 			ibmphp_remove_resource(cur_func->pfmem[i]);
315 			cur_func->pfmem[i] = NULL;
316 		} else if (cur_func->mem[i]) {
317 			ibmphp_remove_resource(cur_func->mem[i]);
318 			cur_func->mem[i] = NULL;
319 		}
320 	}
321 	return rc;
322 }
323 
324 /*
325  * This function configures the pci BARs of a single device.
326  * Input: pointer to the pci_func
327  * Output: configured PCI, 0, or error
328  */
configure_device(struct pci_func * func)329 static int configure_device(struct pci_func *func)
330 {
331 	u32 bar[6];
332 	static const u32 address[] = {
333 		PCI_BASE_ADDRESS_0,
334 		PCI_BASE_ADDRESS_1,
335 		PCI_BASE_ADDRESS_2,
336 		PCI_BASE_ADDRESS_3,
337 		PCI_BASE_ADDRESS_4,
338 		PCI_BASE_ADDRESS_5,
339 		0
340 	};
341 	u8 irq;
342 	int count;
343 	int len[6];
344 	struct resource_node *io[6];
345 	struct resource_node *mem[6];
346 	struct resource_node *mem_tmp;
347 	struct resource_node *pfmem[6];
348 	unsigned int devfn;
349 
350 	debug("%s - inside\n", __func__);
351 
352 	devfn = PCI_DEVFN(func->device, func->function);
353 	ibmphp_pci_bus->number = func->busno;
354 
355 	for (count = 0; address[count]; count++) {	/* for 6 BARs */
356 
357 		/* not sure if i need this.  per scott, said maybe need * something like this
358 		   if devices don't adhere 100% to the spec, so don't want to write
359 		   to the reserved bits
360 
361 		pcibios_read_config_byte(cur_func->busno, cur_func->device,
362 		PCI_BASE_ADDRESS_0 + 4 * count, &tmp);
363 		if (tmp & 0x01) // IO
364 			pcibios_write_config_dword(cur_func->busno, cur_func->device,
365 			PCI_BASE_ADDRESS_0 + 4 * count, 0xFFFFFFFD);
366 		else  // Memory
367 			pcibios_write_config_dword(cur_func->busno, cur_func->device,
368 			PCI_BASE_ADDRESS_0 + 4 * count, 0xFFFFFFFF);
369 		 */
370 		pci_bus_write_config_dword(ibmphp_pci_bus, devfn, address[count], 0xFFFFFFFF);
371 		pci_bus_read_config_dword(ibmphp_pci_bus, devfn, address[count], &bar[count]);
372 
373 		if (!bar[count])	/* This BAR is not implemented */
374 			continue;
375 
376 		debug("Device %x BAR %d wants %x\n", func->device, count, bar[count]);
377 
378 		if (bar[count] & PCI_BASE_ADDRESS_SPACE_IO) {
379 			/* This is IO */
380 			debug("inside IO SPACE\n");
381 
382 			len[count] = bar[count] & 0xFFFFFFFC;
383 			len[count] = ~len[count] + 1;
384 
385 			debug("len[count] in IO %x, count %d\n", len[count], count);
386 
387 			io[count] = kzalloc(sizeof(struct resource_node), GFP_KERNEL);
388 
389 			if (!io[count])
390 				return -ENOMEM;
391 
392 			io[count]->type = IO;
393 			io[count]->busno = func->busno;
394 			io[count]->devfunc = PCI_DEVFN(func->device, func->function);
395 			io[count]->len = len[count];
396 			if (ibmphp_check_resource(io[count], 0) == 0) {
397 				ibmphp_add_resource(io[count]);
398 				func->io[count] = io[count];
399 			} else {
400 				err("cannot allocate requested io for bus %x device %x function %x len %x\n",
401 				     func->busno, func->device, func->function, len[count]);
402 				kfree(io[count]);
403 				return -EIO;
404 			}
405 			pci_bus_write_config_dword(ibmphp_pci_bus, devfn, address[count], func->io[count]->start);
406 
407 			/* _______________This is for debugging purposes only_____________________ */
408 			debug("b4 writing, the IO address is %x\n", func->io[count]->start);
409 			pci_bus_read_config_dword(ibmphp_pci_bus, devfn, address[count], &bar[count]);
410 			debug("after writing.... the start address is %x\n", bar[count]);
411 			/* _________________________________________________________________________*/
412 
413 		} else {
414 			/* This is Memory */
415 			if (bar[count] & PCI_BASE_ADDRESS_MEM_PREFETCH) {
416 				/* pfmem */
417 				debug("PFMEM SPACE\n");
418 
419 				len[count] = bar[count] & 0xFFFFFFF0;
420 				len[count] = ~len[count] + 1;
421 
422 				debug("len[count] in PFMEM %x, count %d\n", len[count], count);
423 
424 				pfmem[count] = kzalloc(sizeof(struct resource_node), GFP_KERNEL);
425 				if (!pfmem[count])
426 					return -ENOMEM;
427 
428 				pfmem[count]->type = PFMEM;
429 				pfmem[count]->busno = func->busno;
430 				pfmem[count]->devfunc = PCI_DEVFN(func->device,
431 							func->function);
432 				pfmem[count]->len = len[count];
433 				pfmem[count]->fromMem = 0;
434 				if (ibmphp_check_resource(pfmem[count], 0) == 0) {
435 					ibmphp_add_resource(pfmem[count]);
436 					func->pfmem[count] = pfmem[count];
437 				} else {
438 					mem_tmp = kzalloc(sizeof(*mem_tmp), GFP_KERNEL);
439 					if (!mem_tmp) {
440 						kfree(pfmem[count]);
441 						return -ENOMEM;
442 					}
443 					mem_tmp->type = MEM;
444 					mem_tmp->busno = pfmem[count]->busno;
445 					mem_tmp->devfunc = pfmem[count]->devfunc;
446 					mem_tmp->len = pfmem[count]->len;
447 					debug("there's no pfmem... going into mem.\n");
448 					if (ibmphp_check_resource(mem_tmp, 0) == 0) {
449 						ibmphp_add_resource(mem_tmp);
450 						pfmem[count]->fromMem = 1;
451 						pfmem[count]->rangeno = mem_tmp->rangeno;
452 						pfmem[count]->start = mem_tmp->start;
453 						pfmem[count]->end = mem_tmp->end;
454 						ibmphp_add_pfmem_from_mem(pfmem[count]);
455 						func->pfmem[count] = pfmem[count];
456 					} else {
457 						err("cannot allocate requested pfmem for bus %x, device %x, len %x\n",
458 						     func->busno, func->device, len[count]);
459 						kfree(mem_tmp);
460 						kfree(pfmem[count]);
461 						return -EIO;
462 					}
463 				}
464 
465 				pci_bus_write_config_dword(ibmphp_pci_bus, devfn, address[count], func->pfmem[count]->start);
466 
467 				/*_______________This is for debugging purposes only______________________________*/
468 				debug("b4 writing, start address is %x\n", func->pfmem[count]->start);
469 				pci_bus_read_config_dword(ibmphp_pci_bus, devfn, address[count], &bar[count]);
470 				debug("after writing, start address is %x\n", bar[count]);
471 				/*_________________________________________________________________________________*/
472 
473 				if (bar[count] & PCI_BASE_ADDRESS_MEM_TYPE_64) {	/* takes up another dword */
474 					debug("inside the mem 64 case, count %d\n", count);
475 					count += 1;
476 					/* on the 2nd dword, write all 0s, since we can't handle them n.e.ways */
477 					pci_bus_write_config_dword(ibmphp_pci_bus, devfn, address[count], 0x00000000);
478 				}
479 			} else {
480 				/* regular memory */
481 				debug("REGULAR MEM SPACE\n");
482 
483 				len[count] = bar[count] & 0xFFFFFFF0;
484 				len[count] = ~len[count] + 1;
485 
486 				debug("len[count] in Mem %x, count %d\n", len[count], count);
487 
488 				mem[count] = kzalloc(sizeof(struct resource_node), GFP_KERNEL);
489 				if (!mem[count])
490 					return -ENOMEM;
491 
492 				mem[count]->type = MEM;
493 				mem[count]->busno = func->busno;
494 				mem[count]->devfunc = PCI_DEVFN(func->device,
495 							func->function);
496 				mem[count]->len = len[count];
497 				if (ibmphp_check_resource(mem[count], 0) == 0) {
498 					ibmphp_add_resource(mem[count]);
499 					func->mem[count] = mem[count];
500 				} else {
501 					err("cannot allocate requested mem for bus %x, device %x, len %x\n",
502 					     func->busno, func->device, len[count]);
503 					kfree(mem[count]);
504 					return -EIO;
505 				}
506 				pci_bus_write_config_dword(ibmphp_pci_bus, devfn, address[count], func->mem[count]->start);
507 				/* _______________________This is for debugging purposes only _______________________*/
508 				debug("b4 writing, start address is %x\n", func->mem[count]->start);
509 				pci_bus_read_config_dword(ibmphp_pci_bus, devfn, address[count], &bar[count]);
510 				debug("after writing, the address is %x\n", bar[count]);
511 				/* __________________________________________________________________________________*/
512 
513 				if (bar[count] & PCI_BASE_ADDRESS_MEM_TYPE_64) {
514 					/* takes up another dword */
515 					debug("inside mem 64 case, reg. mem, count %d\n", count);
516 					count += 1;
517 					/* on the 2nd dword, write all 0s, since we can't handle them n.e.ways */
518 					pci_bus_write_config_dword(ibmphp_pci_bus, devfn, address[count], 0x00000000);
519 				}
520 			}
521 		}		/* end of mem */
522 	}			/* end of for */
523 
524 	func->bus = 0;		/* To indicate that this is not a PPB */
525 	pci_bus_read_config_byte(ibmphp_pci_bus, devfn, PCI_INTERRUPT_PIN, &irq);
526 	if ((irq > 0x00) && (irq < 0x05))
527 		pci_bus_write_config_byte(ibmphp_pci_bus, devfn, PCI_INTERRUPT_LINE, func->irq[irq - 1]);
528 
529 	pci_bus_write_config_byte(ibmphp_pci_bus, devfn, PCI_CACHE_LINE_SIZE, CACHE);
530 	pci_bus_write_config_byte(ibmphp_pci_bus, devfn, PCI_LATENCY_TIMER, LATENCY);
531 
532 	pci_bus_write_config_dword(ibmphp_pci_bus, devfn, PCI_ROM_ADDRESS, 0x00L);
533 	pci_bus_write_config_word(ibmphp_pci_bus, devfn, PCI_COMMAND, DEVICEENABLE);
534 
535 	return 0;
536 }
537 
538 /******************************************************************************
539  * This routine configures a PCI-2-PCI bridge and the functions behind it
540  * Parameters: pci_func
541  * Returns:
542  ******************************************************************************/
configure_bridge(struct pci_func ** func_passed,u8 slotno)543 static int configure_bridge(struct pci_func **func_passed, u8 slotno)
544 {
545 	int count;
546 	int i;
547 	int rc;
548 	u8 sec_number;
549 	u8 io_base;
550 	u16 pfmem_base;
551 	u32 bar[2];
552 	u32 len[2];
553 	u8 flag_io = 0;
554 	u8 flag_mem = 0;
555 	u8 flag_pfmem = 0;
556 	u8 need_io_upper = 0;
557 	u8 need_pfmem_upper = 0;
558 	struct res_needed *amount_needed = NULL;
559 	struct resource_node *io = NULL;
560 	struct resource_node *bus_io[2] = {NULL, NULL};
561 	struct resource_node *mem = NULL;
562 	struct resource_node *bus_mem[2] = {NULL, NULL};
563 	struct resource_node *mem_tmp = NULL;
564 	struct resource_node *pfmem = NULL;
565 	struct resource_node *bus_pfmem[2] = {NULL, NULL};
566 	struct bus_node *bus;
567 	static const u32 address[] = {
568 		PCI_BASE_ADDRESS_0,
569 		PCI_BASE_ADDRESS_1,
570 		0
571 	};
572 	struct pci_func *func = *func_passed;
573 	unsigned int devfn;
574 	u8 irq;
575 	int retval;
576 
577 	debug("%s - enter\n", __func__);
578 
579 	devfn = PCI_DEVFN(func->function, func->device);
580 	ibmphp_pci_bus->number = func->busno;
581 
582 	/* Configuring necessary info for the bridge so that we could see the devices
583 	 * behind it
584 	 */
585 
586 	pci_bus_write_config_byte(ibmphp_pci_bus, devfn, PCI_PRIMARY_BUS, func->busno);
587 
588 	/* _____________________For debugging purposes only __________________________
589 	pci_bus_config_byte(ibmphp_pci_bus, devfn, PCI_PRIMARY_BUS, &pri_number);
590 	debug("primary # written into the bridge is %x\n", pri_number);
591 	 ___________________________________________________________________________*/
592 
593 	/* in EBDA, only get allocated 1 additional bus # per slot */
594 	sec_number = find_sec_number(func->busno, slotno);
595 	if (sec_number == 0xff) {
596 		err("cannot allocate secondary bus number for the bridged device\n");
597 		return -EINVAL;
598 	}
599 
600 	debug("after find_sec_number, the number we got is %x\n", sec_number);
601 	debug("AFTER FIND_SEC_NUMBER, func->busno IS %x\n", func->busno);
602 
603 	pci_bus_write_config_byte(ibmphp_pci_bus, devfn, PCI_SECONDARY_BUS, sec_number);
604 
605 	/* __________________For debugging purposes only __________________________________
606 	pci_bus_read_config_byte(ibmphp_pci_bus, devfn, PCI_SECONDARY_BUS, &sec_number);
607 	debug("sec_number after write/read is %x\n", sec_number);
608 	 ________________________________________________________________________________*/
609 
610 	pci_bus_write_config_byte(ibmphp_pci_bus, devfn, PCI_SUBORDINATE_BUS, sec_number);
611 
612 	/* __________________For debugging purposes only ____________________________________
613 	pci_bus_read_config_byte(ibmphp_pci_bus, devfn, PCI_SUBORDINATE_BUS, &sec_number);
614 	debug("subordinate number after write/read is %x\n", sec_number);
615 	 __________________________________________________________________________________*/
616 
617 	pci_bus_write_config_byte(ibmphp_pci_bus, devfn, PCI_CACHE_LINE_SIZE, CACHE);
618 	pci_bus_write_config_byte(ibmphp_pci_bus, devfn, PCI_LATENCY_TIMER, LATENCY);
619 	pci_bus_write_config_byte(ibmphp_pci_bus, devfn, PCI_SEC_LATENCY_TIMER, LATENCY);
620 
621 	debug("func->busno is %x\n", func->busno);
622 	debug("sec_number after writing is %x\n", sec_number);
623 
624 
625 	/* !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
626 	   !!!!!!!!!!!!!!!NEED TO ADD!!!  FAST BACK-TO-BACK ENABLE!!!!!!!!!!!!!!!!!!!!
627 	   !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!*/
628 
629 
630 	/* First we need to allocate mem/io for the bridge itself in case it needs it */
631 	for (count = 0; address[count]; count++) {	/* for 2 BARs */
632 		pci_bus_write_config_dword(ibmphp_pci_bus, devfn, address[count], 0xFFFFFFFF);
633 		pci_bus_read_config_dword(ibmphp_pci_bus, devfn, address[count], &bar[count]);
634 
635 		if (!bar[count]) {
636 			/* This BAR is not implemented */
637 			debug("so we come here then, eh?, count = %d\n", count);
638 			continue;
639 		}
640 		//  tmp_bar = bar[count];
641 
642 		debug("Bar %d wants %x\n", count, bar[count]);
643 
644 		if (bar[count] & PCI_BASE_ADDRESS_SPACE_IO) {
645 			/* This is IO */
646 			len[count] = bar[count] & 0xFFFFFFFC;
647 			len[count] = ~len[count] + 1;
648 
649 			debug("len[count] in IO = %x\n", len[count]);
650 
651 			bus_io[count] = kzalloc(sizeof(struct resource_node), GFP_KERNEL);
652 
653 			if (!bus_io[count]) {
654 				retval = -ENOMEM;
655 				goto error;
656 			}
657 			bus_io[count]->type = IO;
658 			bus_io[count]->busno = func->busno;
659 			bus_io[count]->devfunc = PCI_DEVFN(func->device,
660 							func->function);
661 			bus_io[count]->len = len[count];
662 			if (ibmphp_check_resource(bus_io[count], 0) == 0) {
663 				ibmphp_add_resource(bus_io[count]);
664 				func->io[count] = bus_io[count];
665 			} else {
666 				err("cannot allocate requested io for bus %x, device %x, len %x\n",
667 				     func->busno, func->device, len[count]);
668 				kfree(bus_io[count]);
669 				return -EIO;
670 			}
671 
672 			pci_bus_write_config_dword(ibmphp_pci_bus, devfn, address[count], func->io[count]->start);
673 
674 		} else {
675 			/* This is Memory */
676 			if (bar[count] & PCI_BASE_ADDRESS_MEM_PREFETCH) {
677 				/* pfmem */
678 				len[count] = bar[count] & 0xFFFFFFF0;
679 				len[count] = ~len[count] + 1;
680 
681 				debug("len[count] in PFMEM = %x\n", len[count]);
682 
683 				bus_pfmem[count] = kzalloc(sizeof(struct resource_node), GFP_KERNEL);
684 				if (!bus_pfmem[count]) {
685 					retval = -ENOMEM;
686 					goto error;
687 				}
688 				bus_pfmem[count]->type = PFMEM;
689 				bus_pfmem[count]->busno = func->busno;
690 				bus_pfmem[count]->devfunc = PCI_DEVFN(func->device,
691 							func->function);
692 				bus_pfmem[count]->len = len[count];
693 				bus_pfmem[count]->fromMem = 0;
694 				if (ibmphp_check_resource(bus_pfmem[count], 0) == 0) {
695 					ibmphp_add_resource(bus_pfmem[count]);
696 					func->pfmem[count] = bus_pfmem[count];
697 				} else {
698 					mem_tmp = kzalloc(sizeof(*mem_tmp), GFP_KERNEL);
699 					if (!mem_tmp) {
700 						retval = -ENOMEM;
701 						goto error;
702 					}
703 					mem_tmp->type = MEM;
704 					mem_tmp->busno = bus_pfmem[count]->busno;
705 					mem_tmp->devfunc = bus_pfmem[count]->devfunc;
706 					mem_tmp->len = bus_pfmem[count]->len;
707 					if (ibmphp_check_resource(mem_tmp, 0) == 0) {
708 						ibmphp_add_resource(mem_tmp);
709 						bus_pfmem[count]->fromMem = 1;
710 						bus_pfmem[count]->rangeno = mem_tmp->rangeno;
711 						ibmphp_add_pfmem_from_mem(bus_pfmem[count]);
712 						func->pfmem[count] = bus_pfmem[count];
713 					} else {
714 						err("cannot allocate requested pfmem for bus %x, device %x, len %x\n",
715 						     func->busno, func->device, len[count]);
716 						kfree(mem_tmp);
717 						kfree(bus_pfmem[count]);
718 						return -EIO;
719 					}
720 				}
721 
722 				pci_bus_write_config_dword(ibmphp_pci_bus, devfn, address[count], func->pfmem[count]->start);
723 
724 				if (bar[count] & PCI_BASE_ADDRESS_MEM_TYPE_64) {
725 					/* takes up another dword */
726 					count += 1;
727 					/* on the 2nd dword, write all 0s, since we can't handle them n.e.ways */
728 					pci_bus_write_config_dword(ibmphp_pci_bus, devfn, address[count], 0x00000000);
729 
730 				}
731 			} else {
732 				/* regular memory */
733 				len[count] = bar[count] & 0xFFFFFFF0;
734 				len[count] = ~len[count] + 1;
735 
736 				debug("len[count] in Memory is %x\n", len[count]);
737 
738 				bus_mem[count] = kzalloc(sizeof(struct resource_node), GFP_KERNEL);
739 				if (!bus_mem[count]) {
740 					retval = -ENOMEM;
741 					goto error;
742 				}
743 				bus_mem[count]->type = MEM;
744 				bus_mem[count]->busno = func->busno;
745 				bus_mem[count]->devfunc = PCI_DEVFN(func->device,
746 							func->function);
747 				bus_mem[count]->len = len[count];
748 				if (ibmphp_check_resource(bus_mem[count], 0) == 0) {
749 					ibmphp_add_resource(bus_mem[count]);
750 					func->mem[count] = bus_mem[count];
751 				} else {
752 					err("cannot allocate requested mem for bus %x, device %x, len %x\n",
753 					     func->busno, func->device, len[count]);
754 					kfree(bus_mem[count]);
755 					return -EIO;
756 				}
757 
758 				pci_bus_write_config_dword(ibmphp_pci_bus, devfn, address[count], func->mem[count]->start);
759 
760 				if (bar[count] & PCI_BASE_ADDRESS_MEM_TYPE_64) {
761 					/* takes up another dword */
762 					count += 1;
763 					/* on the 2nd dword, write all 0s, since we can't handle them n.e.ways */
764 					pci_bus_write_config_dword(ibmphp_pci_bus, devfn, address[count], 0x00000000);
765 
766 				}
767 			}
768 		}		/* end of mem */
769 	}			/* end of for  */
770 
771 	/* Now need to see how much space the devices behind the bridge needed */
772 	amount_needed = scan_behind_bridge(func, sec_number);
773 	if (amount_needed == NULL)
774 		return -ENOMEM;
775 
776 	ibmphp_pci_bus->number = func->busno;
777 	debug("after coming back from scan_behind_bridge\n");
778 	debug("amount_needed->not_correct = %x\n", amount_needed->not_correct);
779 	debug("amount_needed->io = %x\n", amount_needed->io);
780 	debug("amount_needed->mem = %x\n", amount_needed->mem);
781 	debug("amount_needed->pfmem =  %x\n", amount_needed->pfmem);
782 
783 	if (amount_needed->not_correct) {
784 		debug("amount_needed is not correct\n");
785 		for (count = 0; address[count]; count++) {
786 			/* for 2 BARs */
787 			if (bus_io[count]) {
788 				ibmphp_remove_resource(bus_io[count]);
789 				func->io[count] = NULL;
790 			} else if (bus_pfmem[count]) {
791 				ibmphp_remove_resource(bus_pfmem[count]);
792 				func->pfmem[count] = NULL;
793 			} else if (bus_mem[count]) {
794 				ibmphp_remove_resource(bus_mem[count]);
795 				func->mem[count] = NULL;
796 			}
797 		}
798 		kfree(amount_needed);
799 		return -ENODEV;
800 	}
801 
802 	if (!amount_needed->io) {
803 		debug("it doesn't want IO?\n");
804 		flag_io = 1;
805 	} else {
806 		debug("it wants %x IO behind the bridge\n", amount_needed->io);
807 		io = kzalloc(sizeof(*io), GFP_KERNEL);
808 
809 		if (!io) {
810 			retval = -ENOMEM;
811 			goto error;
812 		}
813 		io->type = IO;
814 		io->busno = func->busno;
815 		io->devfunc = PCI_DEVFN(func->device, func->function);
816 		io->len = amount_needed->io;
817 		if (ibmphp_check_resource(io, 1) == 0) {
818 			debug("were we able to add io\n");
819 			ibmphp_add_resource(io);
820 			flag_io = 1;
821 		}
822 	}
823 
824 	if (!amount_needed->mem) {
825 		debug("it doesn't want n.e.memory?\n");
826 		flag_mem = 1;
827 	} else {
828 		debug("it wants %x memory behind the bridge\n", amount_needed->mem);
829 		mem = kzalloc(sizeof(*mem), GFP_KERNEL);
830 		if (!mem) {
831 			retval = -ENOMEM;
832 			goto error;
833 		}
834 		mem->type = MEM;
835 		mem->busno = func->busno;
836 		mem->devfunc = PCI_DEVFN(func->device, func->function);
837 		mem->len = amount_needed->mem;
838 		if (ibmphp_check_resource(mem, 1) == 0) {
839 			ibmphp_add_resource(mem);
840 			flag_mem = 1;
841 			debug("were we able to add mem\n");
842 		}
843 	}
844 
845 	if (!amount_needed->pfmem) {
846 		debug("it doesn't want n.e.pfmem mem?\n");
847 		flag_pfmem = 1;
848 	} else {
849 		debug("it wants %x pfmemory behind the bridge\n", amount_needed->pfmem);
850 		pfmem = kzalloc(sizeof(*pfmem), GFP_KERNEL);
851 		if (!pfmem) {
852 			retval = -ENOMEM;
853 			goto error;
854 		}
855 		pfmem->type = PFMEM;
856 		pfmem->busno = func->busno;
857 		pfmem->devfunc = PCI_DEVFN(func->device, func->function);
858 		pfmem->len = amount_needed->pfmem;
859 		pfmem->fromMem = 0;
860 		if (ibmphp_check_resource(pfmem, 1) == 0) {
861 			ibmphp_add_resource(pfmem);
862 			flag_pfmem = 1;
863 		} else {
864 			mem_tmp = kzalloc(sizeof(*mem_tmp), GFP_KERNEL);
865 			if (!mem_tmp) {
866 				retval = -ENOMEM;
867 				goto error;
868 			}
869 			mem_tmp->type = MEM;
870 			mem_tmp->busno = pfmem->busno;
871 			mem_tmp->devfunc = pfmem->devfunc;
872 			mem_tmp->len = pfmem->len;
873 			if (ibmphp_check_resource(mem_tmp, 1) == 0) {
874 				ibmphp_add_resource(mem_tmp);
875 				pfmem->fromMem = 1;
876 				pfmem->rangeno = mem_tmp->rangeno;
877 				ibmphp_add_pfmem_from_mem(pfmem);
878 				flag_pfmem = 1;
879 			}
880 		}
881 	}
882 
883 	debug("b4 if (flag_io && flag_mem && flag_pfmem)\n");
884 	debug("flag_io = %x, flag_mem = %x, flag_pfmem = %x\n", flag_io, flag_mem, flag_pfmem);
885 
886 	if (flag_io && flag_mem && flag_pfmem) {
887 		/* If on bootup, there was a bridged card in this slot,
888 		 * then card was removed and ibmphp got unloaded and loaded
889 		 * back again, there's no way for us to remove the bus
890 		 * struct, so no need to kmalloc, can use existing node
891 		 */
892 		bus = ibmphp_find_res_bus(sec_number);
893 		if (!bus) {
894 			bus = kzalloc(sizeof(*bus), GFP_KERNEL);
895 			if (!bus) {
896 				retval = -ENOMEM;
897 				goto error;
898 			}
899 			bus->busno = sec_number;
900 			debug("b4 adding new bus\n");
901 			rc = add_new_bus(bus, io, mem, pfmem, func->busno);
902 		} else if (!(bus->rangeIO) && !(bus->rangeMem) && !(bus->rangePFMem))
903 			rc = add_new_bus(bus, io, mem, pfmem, 0xFF);
904 		else {
905 			err("expected bus structure not empty?\n");
906 			retval = -EIO;
907 			goto error;
908 		}
909 		if (rc) {
910 			if (rc == -ENOMEM) {
911 				ibmphp_remove_bus(bus, func->busno);
912 				kfree(amount_needed);
913 				return rc;
914 			}
915 			retval = rc;
916 			goto error;
917 		}
918 		pci_bus_read_config_byte(ibmphp_pci_bus, devfn, PCI_IO_BASE, &io_base);
919 		pci_bus_read_config_word(ibmphp_pci_bus, devfn, PCI_PREF_MEMORY_BASE, &pfmem_base);
920 
921 		if ((io_base & PCI_IO_RANGE_TYPE_MASK) == PCI_IO_RANGE_TYPE_32) {
922 			debug("io 32\n");
923 			need_io_upper = 1;
924 		}
925 		if ((pfmem_base & PCI_PREF_RANGE_TYPE_MASK) == PCI_PREF_RANGE_TYPE_64) {
926 			debug("pfmem 64\n");
927 			need_pfmem_upper = 1;
928 		}
929 
930 		if (bus->noIORanges) {
931 			pci_bus_write_config_byte(ibmphp_pci_bus, devfn, PCI_IO_BASE, 0x00 | bus->rangeIO->start >> 8);
932 			pci_bus_write_config_byte(ibmphp_pci_bus, devfn, PCI_IO_LIMIT, 0x00 | bus->rangeIO->end >> 8);
933 
934 			/* _______________This is for debugging purposes only ____________________
935 			pci_bus_read_config_byte(ibmphp_pci_bus, devfn, PCI_IO_BASE, &temp);
936 			debug("io_base = %x\n", (temp & PCI_IO_RANGE_TYPE_MASK) << 8);
937 			pci_bus_read_config_byte(ibmphp_pci_bus, devfn, PCI_IO_LIMIT, &temp);
938 			debug("io_limit = %x\n", (temp & PCI_IO_RANGE_TYPE_MASK) << 8);
939 			 ________________________________________________________________________*/
940 
941 			if (need_io_upper) {	/* since can't support n.e.ways */
942 				pci_bus_write_config_word(ibmphp_pci_bus, devfn, PCI_IO_BASE_UPPER16, 0x0000);
943 				pci_bus_write_config_word(ibmphp_pci_bus, devfn, PCI_IO_LIMIT_UPPER16, 0x0000);
944 			}
945 		} else {
946 			pci_bus_write_config_byte(ibmphp_pci_bus, devfn, PCI_IO_BASE, 0x00);
947 			pci_bus_write_config_byte(ibmphp_pci_bus, devfn, PCI_IO_LIMIT, 0x00);
948 		}
949 
950 		if (bus->noMemRanges) {
951 			pci_bus_write_config_word(ibmphp_pci_bus, devfn, PCI_MEMORY_BASE, 0x0000 | bus->rangeMem->start >> 16);
952 			pci_bus_write_config_word(ibmphp_pci_bus, devfn, PCI_MEMORY_LIMIT, 0x0000 | bus->rangeMem->end >> 16);
953 
954 			/* ____________________This is for debugging purposes only ________________________
955 			pci_bus_read_config_word(ibmphp_pci_bus, devfn, PCI_MEMORY_BASE, &temp);
956 			debug("mem_base = %x\n", (temp & PCI_MEMORY_RANGE_TYPE_MASK) << 16);
957 			pci_bus_read_config_word(ibmphp_pci_bus, devfn, PCI_MEMORY_LIMIT, &temp);
958 			debug("mem_limit = %x\n", (temp & PCI_MEMORY_RANGE_TYPE_MASK) << 16);
959 			 __________________________________________________________________________________*/
960 
961 		} else {
962 			pci_bus_write_config_word(ibmphp_pci_bus, devfn, PCI_MEMORY_BASE, 0xffff);
963 			pci_bus_write_config_word(ibmphp_pci_bus, devfn, PCI_MEMORY_LIMIT, 0x0000);
964 		}
965 		if (bus->noPFMemRanges) {
966 			pci_bus_write_config_word(ibmphp_pci_bus, devfn, PCI_PREF_MEMORY_BASE, 0x0000 | bus->rangePFMem->start >> 16);
967 			pci_bus_write_config_word(ibmphp_pci_bus, devfn, PCI_PREF_MEMORY_LIMIT, 0x0000 | bus->rangePFMem->end >> 16);
968 
969 			/* __________________________This is for debugging purposes only _______________________
970 			pci_bus_read_config_word(ibmphp_pci_bus, devfn, PCI_PREF_MEMORY_BASE, &temp);
971 			debug("pfmem_base = %x", (temp & PCI_MEMORY_RANGE_TYPE_MASK) << 16);
972 			pci_bus_read_config_word(ibmphp_pci_bus, devfn, PCI_PREF_MEMORY_LIMIT, &temp);
973 			debug("pfmem_limit = %x\n", (temp & PCI_MEMORY_RANGE_TYPE_MASK) << 16);
974 			 ______________________________________________________________________________________*/
975 
976 			if (need_pfmem_upper) {	/* since can't support n.e.ways */
977 				pci_bus_write_config_dword(ibmphp_pci_bus, devfn, PCI_PREF_BASE_UPPER32, 0x00000000);
978 				pci_bus_write_config_dword(ibmphp_pci_bus, devfn, PCI_PREF_LIMIT_UPPER32, 0x00000000);
979 			}
980 		} else {
981 			pci_bus_write_config_word(ibmphp_pci_bus, devfn, PCI_PREF_MEMORY_BASE, 0xffff);
982 			pci_bus_write_config_word(ibmphp_pci_bus, devfn, PCI_PREF_MEMORY_LIMIT, 0x0000);
983 		}
984 
985 		debug("b4 writing control information\n");
986 
987 		pci_bus_read_config_byte(ibmphp_pci_bus, devfn, PCI_INTERRUPT_PIN, &irq);
988 		if ((irq > 0x00) && (irq < 0x05))
989 			pci_bus_write_config_byte(ibmphp_pci_bus, devfn, PCI_INTERRUPT_LINE, func->irq[irq - 1]);
990 		/*
991 		pci_bus_write_config_byte(ibmphp_pci_bus, devfn, PCI_BRIDGE_CONTROL, ctrl);
992 		pci_bus_write_config_byte(ibmphp_pci_bus, devfn, PCI_BRIDGE_CONTROL, PCI_BRIDGE_CTL_PARITY);
993 		pci_bus_write_config_byte(ibmphp_pci_bus, devfn, PCI_BRIDGE_CONTROL, PCI_BRIDGE_CTL_SERR);
994 		 */
995 
996 		pci_bus_write_config_word(ibmphp_pci_bus, devfn, PCI_COMMAND, DEVICEENABLE);
997 		pci_bus_write_config_word(ibmphp_pci_bus, devfn, PCI_BRIDGE_CONTROL, 0x07);
998 		for (i = 0; i < 32; i++) {
999 			if (amount_needed->devices[i]) {
1000 				debug("device where devices[i] is 1 = %x\n", i);
1001 				func->devices[i] = 1;
1002 			}
1003 		}
1004 		func->bus = 1;	/* For unconfiguring, to indicate it's PPB */
1005 		func_passed = &func;
1006 		debug("func->busno b4 returning is %x\n", func->busno);
1007 		debug("func->busno b4 returning in the other structure is %x\n", (*func_passed)->busno);
1008 		kfree(amount_needed);
1009 		return 0;
1010 	} else {
1011 		err("Configuring bridge was unsuccessful...\n");
1012 		mem_tmp = NULL;
1013 		retval = -EIO;
1014 		goto error;
1015 	}
1016 
1017 error:
1018 	kfree(amount_needed);
1019 	if (pfmem)
1020 		ibmphp_remove_resource(pfmem);
1021 	if (io)
1022 		ibmphp_remove_resource(io);
1023 	if (mem)
1024 		ibmphp_remove_resource(mem);
1025 	for (i = 0; i < 2; i++) {	/* for 2 BARs */
1026 		if (bus_io[i]) {
1027 			ibmphp_remove_resource(bus_io[i]);
1028 			func->io[i] = NULL;
1029 		} else if (bus_pfmem[i]) {
1030 			ibmphp_remove_resource(bus_pfmem[i]);
1031 			func->pfmem[i] = NULL;
1032 		} else if (bus_mem[i]) {
1033 			ibmphp_remove_resource(bus_mem[i]);
1034 			func->mem[i] = NULL;
1035 		}
1036 	}
1037 	return retval;
1038 }
1039 
1040 /*****************************************************************************
1041  * This function adds up the amount of resources needed behind the PPB bridge
1042  * and passes it to the configure_bridge function
1043  * Input: bridge function
1044  * Output: amount of resources needed
1045  *****************************************************************************/
scan_behind_bridge(struct pci_func * func,u8 busno)1046 static struct res_needed *scan_behind_bridge(struct pci_func *func, u8 busno)
1047 {
1048 	int count, len[6];
1049 	u16 vendor_id;
1050 	u8 hdr_type;
1051 	u8 device, function;
1052 	unsigned int devfn;
1053 	int howmany = 0;	/*this is to see if there are any devices behind the bridge */
1054 
1055 	u32 bar[6], class;
1056 	static const u32 address[] = {
1057 		PCI_BASE_ADDRESS_0,
1058 		PCI_BASE_ADDRESS_1,
1059 		PCI_BASE_ADDRESS_2,
1060 		PCI_BASE_ADDRESS_3,
1061 		PCI_BASE_ADDRESS_4,
1062 		PCI_BASE_ADDRESS_5,
1063 		0
1064 	};
1065 	struct res_needed *amount;
1066 
1067 	amount = kzalloc(sizeof(*amount), GFP_KERNEL);
1068 	if (amount == NULL)
1069 		return NULL;
1070 
1071 	ibmphp_pci_bus->number = busno;
1072 
1073 	debug("the bus_no behind the bridge is %x\n", busno);
1074 	debug("scanning devices behind the bridge...\n");
1075 	for (device = 0; device < 32; device++) {
1076 		amount->devices[device] = 0;
1077 		for (function = 0; function < 8; function++) {
1078 			devfn = PCI_DEVFN(device, function);
1079 
1080 			pci_bus_read_config_word(ibmphp_pci_bus, devfn, PCI_VENDOR_ID, &vendor_id);
1081 
1082 			if (vendor_id != PCI_VENDOR_ID_NOTVALID) {
1083 				/* found correct device!!! */
1084 				howmany++;
1085 
1086 				pci_bus_read_config_byte(ibmphp_pci_bus, devfn, PCI_HEADER_TYPE, &hdr_type);
1087 				pci_bus_read_config_dword(ibmphp_pci_bus, devfn, PCI_CLASS_REVISION, &class);
1088 
1089 				debug("hdr_type behind the bridge is %x\n", hdr_type);
1090 				if ((hdr_type & 0x7f) == PCI_HEADER_TYPE_BRIDGE) {
1091 					err("embedded bridges not supported for hot-plugging.\n");
1092 					amount->not_correct = 1;
1093 					return amount;
1094 				}
1095 
1096 				class >>= 8;	/* to take revision out, class = class.subclass.prog i/f */
1097 				if (class == PCI_CLASS_NOT_DEFINED_VGA) {
1098 					err("The device %x is VGA compatible and as is not supported for hot plugging.  Please choose another device.\n", device);
1099 					amount->not_correct = 1;
1100 					return amount;
1101 				} else if (class == PCI_CLASS_DISPLAY_VGA) {
1102 					err("The device %x is not supported for hot plugging.  Please choose another device.\n", device);
1103 					amount->not_correct = 1;
1104 					return amount;
1105 				}
1106 
1107 				amount->devices[device] = 1;
1108 
1109 				for (count = 0; address[count]; count++) {
1110 					/* for 6 BARs */
1111 					/*
1112 					pci_bus_read_config_byte(ibmphp_pci_bus, devfn, address[count], &tmp);
1113 					if (tmp & 0x01) // IO
1114 						pci_bus_write_config_dword(ibmphp_pci_bus, devfn, address[count], 0xFFFFFFFD);
1115 					else // MEMORY
1116 						pci_bus_write_config_dword(ibmphp_pci_bus, devfn, address[count], 0xFFFFFFFF);
1117 					*/
1118 					pci_bus_write_config_dword(ibmphp_pci_bus, devfn, address[count], 0xFFFFFFFF);
1119 					pci_bus_read_config_dword(ibmphp_pci_bus, devfn, address[count], &bar[count]);
1120 
1121 					debug("what is bar[count]? %x, count = %d\n", bar[count], count);
1122 
1123 					if (!bar[count])	/* This BAR is not implemented */
1124 						continue;
1125 
1126 					//tmp_bar = bar[count];
1127 
1128 					debug("count %d device %x function %x wants %x resources\n", count, device, function, bar[count]);
1129 
1130 					if (bar[count] & PCI_BASE_ADDRESS_SPACE_IO) {
1131 						/* This is IO */
1132 						len[count] = bar[count] & 0xFFFFFFFC;
1133 						len[count] = ~len[count] + 1;
1134 						amount->io += len[count];
1135 					} else {
1136 						/* This is Memory */
1137 						if (bar[count] & PCI_BASE_ADDRESS_MEM_PREFETCH) {
1138 							/* pfmem */
1139 							len[count] = bar[count] & 0xFFFFFFF0;
1140 							len[count] = ~len[count] + 1;
1141 							amount->pfmem += len[count];
1142 							if (bar[count] & PCI_BASE_ADDRESS_MEM_TYPE_64)
1143 								/* takes up another dword */
1144 								count += 1;
1145 
1146 						} else {
1147 							/* regular memory */
1148 							len[count] = bar[count] & 0xFFFFFFF0;
1149 							len[count] = ~len[count] + 1;
1150 							amount->mem += len[count];
1151 							if (bar[count] & PCI_BASE_ADDRESS_MEM_TYPE_64) {
1152 								/* takes up another dword */
1153 								count += 1;
1154 							}
1155 						}
1156 					}
1157 				}	/* end for */
1158 			}	/* end if (valid) */
1159 		}	/* end for */
1160 	}	/* end for */
1161 
1162 	if (!howmany)
1163 		amount->not_correct = 1;
1164 	else
1165 		amount->not_correct = 0;
1166 	if ((amount->io) && (amount->io < IOBRIDGE))
1167 		amount->io = IOBRIDGE;
1168 	if ((amount->mem) && (amount->mem < MEMBRIDGE))
1169 		amount->mem = MEMBRIDGE;
1170 	if ((amount->pfmem) && (amount->pfmem < MEMBRIDGE))
1171 		amount->pfmem = MEMBRIDGE;
1172 	return amount;
1173 }
1174 
1175 /* The following 3 unconfigure_boot_ routines deal with the case when we had the card
1176  * upon bootup in the system, since we don't allocate func to such case, we need to read
1177  * the start addresses from pci config space and then find the corresponding entries in
1178  * our resource lists.  The functions return either 0, -ENODEV, or -1 (general failure)
1179  * Change: we also call these functions even if we configured the card ourselves (i.e., not
1180  * the bootup case), since it should work same way
1181  */
unconfigure_boot_device(u8 busno,u8 device,u8 function)1182 static int unconfigure_boot_device(u8 busno, u8 device, u8 function)
1183 {
1184 	u32 start_address;
1185 	static const u32 address[] = {
1186 		PCI_BASE_ADDRESS_0,
1187 		PCI_BASE_ADDRESS_1,
1188 		PCI_BASE_ADDRESS_2,
1189 		PCI_BASE_ADDRESS_3,
1190 		PCI_BASE_ADDRESS_4,
1191 		PCI_BASE_ADDRESS_5,
1192 		0
1193 	};
1194 	int count;
1195 	struct resource_node *io;
1196 	struct resource_node *mem;
1197 	struct resource_node *pfmem;
1198 	struct bus_node *bus;
1199 	u32 end_address;
1200 	u32 temp_end;
1201 	u32 size;
1202 	u32 tmp_address;
1203 	unsigned int devfn;
1204 
1205 	debug("%s - enter\n", __func__);
1206 
1207 	bus = ibmphp_find_res_bus(busno);
1208 	if (!bus) {
1209 		debug("cannot find corresponding bus.\n");
1210 		return -EINVAL;
1211 	}
1212 
1213 	devfn = PCI_DEVFN(device, function);
1214 	ibmphp_pci_bus->number = busno;
1215 	for (count = 0; address[count]; count++) {	/* for 6 BARs */
1216 		pci_bus_read_config_dword(ibmphp_pci_bus, devfn, address[count], &start_address);
1217 
1218 		/* We can do this here, b/c by that time the device driver of the card has been stopped */
1219 
1220 		pci_bus_write_config_dword(ibmphp_pci_bus, devfn, address[count], 0xFFFFFFFF);
1221 		pci_bus_read_config_dword(ibmphp_pci_bus, devfn, address[count], &size);
1222 		pci_bus_write_config_dword(ibmphp_pci_bus, devfn, address[count], start_address);
1223 
1224 		debug("start_address is %x\n", start_address);
1225 		debug("busno, device, function %x %x %x\n", busno, device, function);
1226 		if (!size) {
1227 			/* This BAR is not implemented */
1228 			debug("is this bar no implemented?, count = %d\n", count);
1229 			continue;
1230 		}
1231 		tmp_address = start_address;
1232 		if (start_address & PCI_BASE_ADDRESS_SPACE_IO) {
1233 			/* This is IO */
1234 			start_address &= PCI_BASE_ADDRESS_IO_MASK;
1235 			size = size & 0xFFFFFFFC;
1236 			size = ~size + 1;
1237 			end_address = start_address + size - 1;
1238 			if (ibmphp_find_resource(bus, start_address, &io, IO))
1239 				goto report_search_failure;
1240 
1241 			debug("io->start = %x\n", io->start);
1242 			temp_end = io->end;
1243 			start_address = io->end + 1;
1244 			ibmphp_remove_resource(io);
1245 			/* This is needed b/c of the old I/O restrictions in the BIOS */
1246 			while (temp_end < end_address) {
1247 				if (ibmphp_find_resource(bus, start_address,
1248 							 &io, IO))
1249 					goto report_search_failure;
1250 
1251 				debug("io->start = %x\n", io->start);
1252 				temp_end = io->end;
1253 				start_address = io->end + 1;
1254 				ibmphp_remove_resource(io);
1255 			}
1256 
1257 			/* ????????? DO WE NEED TO WRITE ANYTHING INTO THE PCI CONFIG SPACE BACK ?????????? */
1258 		} else {
1259 			/* This is Memory */
1260 			if (start_address & PCI_BASE_ADDRESS_MEM_PREFETCH) {
1261 				/* pfmem */
1262 				debug("start address of pfmem is %x\n", start_address);
1263 				start_address &= PCI_BASE_ADDRESS_MEM_MASK;
1264 
1265 				if (ibmphp_find_resource(bus, start_address, &pfmem, PFMEM) < 0) {
1266 					err("cannot find corresponding PFMEM resource to remove\n");
1267 					return -EIO;
1268 				}
1269 				if (pfmem) {
1270 					debug("pfmem->start = %x\n", pfmem->start);
1271 
1272 					ibmphp_remove_resource(pfmem);
1273 				}
1274 			} else {
1275 				/* regular memory */
1276 				debug("start address of mem is %x\n", start_address);
1277 				start_address &= PCI_BASE_ADDRESS_MEM_MASK;
1278 
1279 				if (ibmphp_find_resource(bus, start_address, &mem, MEM) < 0) {
1280 					err("cannot find corresponding MEM resource to remove\n");
1281 					return -EIO;
1282 				}
1283 				if (mem) {
1284 					debug("mem->start = %x\n", mem->start);
1285 
1286 					ibmphp_remove_resource(mem);
1287 				}
1288 			}
1289 			if (tmp_address & PCI_BASE_ADDRESS_MEM_TYPE_64) {
1290 				/* takes up another dword */
1291 				count += 1;
1292 			}
1293 		}	/* end of mem */
1294 	}	/* end of for */
1295 
1296 	return 0;
1297 
1298 report_search_failure:
1299 	err("cannot find corresponding IO resource to remove\n");
1300 	return -EIO;
1301 }
1302 
unconfigure_boot_bridge(u8 busno,u8 device,u8 function)1303 static int unconfigure_boot_bridge(u8 busno, u8 device, u8 function)
1304 {
1305 	int count;
1306 	int bus_no, pri_no, sub_no, sec_no = 0;
1307 	u32 start_address, tmp_address;
1308 	u8 sec_number, sub_number, pri_number;
1309 	struct resource_node *io = NULL;
1310 	struct resource_node *mem = NULL;
1311 	struct resource_node *pfmem = NULL;
1312 	struct bus_node *bus;
1313 	static const u32 address[] = {
1314 		PCI_BASE_ADDRESS_0,
1315 		PCI_BASE_ADDRESS_1,
1316 		0
1317 	};
1318 	unsigned int devfn;
1319 
1320 	devfn = PCI_DEVFN(device, function);
1321 	ibmphp_pci_bus->number = busno;
1322 	bus_no = (int) busno;
1323 	debug("busno is %x\n", busno);
1324 	pci_bus_read_config_byte(ibmphp_pci_bus, devfn, PCI_PRIMARY_BUS, &pri_number);
1325 	debug("%s - busno = %x, primary_number = %x\n", __func__, busno, pri_number);
1326 
1327 	pci_bus_read_config_byte(ibmphp_pci_bus, devfn, PCI_SECONDARY_BUS, &sec_number);
1328 	debug("sec_number is %x\n", sec_number);
1329 	sec_no = (int) sec_number;
1330 	pri_no = (int) pri_number;
1331 	if (pri_no != bus_no) {
1332 		err("primary numbers in our structures and pci config space don't match.\n");
1333 		return -EINVAL;
1334 	}
1335 
1336 	pci_bus_read_config_byte(ibmphp_pci_bus, devfn, PCI_SUBORDINATE_BUS, &sub_number);
1337 	sub_no = (int) sub_number;
1338 	debug("sub_no is %d, sec_no is %d\n", sub_no, sec_no);
1339 	if (sec_no != sub_number) {
1340 		err("there're more buses behind this bridge.  Hot removal is not supported.  Please choose another card\n");
1341 		return -ENODEV;
1342 	}
1343 
1344 	bus = ibmphp_find_res_bus(sec_number);
1345 	if (!bus) {
1346 		err("cannot find Bus structure for the bridged device\n");
1347 		return -EINVAL;
1348 	}
1349 	debug("bus->busno is %x\n", bus->busno);
1350 	debug("sec_number is %x\n", sec_number);
1351 
1352 	ibmphp_remove_bus(bus, busno);
1353 
1354 	for (count = 0; address[count]; count++) {
1355 		/* for 2 BARs */
1356 		pci_bus_read_config_dword(ibmphp_pci_bus, devfn, address[count], &start_address);
1357 
1358 		if (!start_address) {
1359 			/* This BAR is not implemented */
1360 			continue;
1361 		}
1362 
1363 		tmp_address = start_address;
1364 
1365 		if (start_address & PCI_BASE_ADDRESS_SPACE_IO) {
1366 			/* This is IO */
1367 			start_address &= PCI_BASE_ADDRESS_IO_MASK;
1368 			if (ibmphp_find_resource(bus, start_address, &io, IO) < 0) {
1369 				err("cannot find corresponding IO resource to remove\n");
1370 				return -EIO;
1371 			}
1372 			if (io)
1373 				debug("io->start = %x\n", io->start);
1374 
1375 			ibmphp_remove_resource(io);
1376 
1377 			/* ????????? DO WE NEED TO WRITE ANYTHING INTO THE PCI CONFIG SPACE BACK ?????????? */
1378 		} else {
1379 			/* This is Memory */
1380 			if (start_address & PCI_BASE_ADDRESS_MEM_PREFETCH) {
1381 				/* pfmem */
1382 				start_address &= PCI_BASE_ADDRESS_MEM_MASK;
1383 				if (ibmphp_find_resource(bus, start_address, &pfmem, PFMEM) < 0) {
1384 					err("cannot find corresponding PFMEM resource to remove\n");
1385 					return -EINVAL;
1386 				}
1387 				if (pfmem) {
1388 					debug("pfmem->start = %x\n", pfmem->start);
1389 
1390 					ibmphp_remove_resource(pfmem);
1391 				}
1392 			} else {
1393 				/* regular memory */
1394 				start_address &= PCI_BASE_ADDRESS_MEM_MASK;
1395 				if (ibmphp_find_resource(bus, start_address, &mem, MEM) < 0) {
1396 					err("cannot find corresponding MEM resource to remove\n");
1397 					return -EINVAL;
1398 				}
1399 				if (mem) {
1400 					debug("mem->start = %x\n", mem->start);
1401 
1402 					ibmphp_remove_resource(mem);
1403 				}
1404 			}
1405 			if (tmp_address & PCI_BASE_ADDRESS_MEM_TYPE_64) {
1406 				/* takes up another dword */
1407 				count += 1;
1408 			}
1409 		}	/* end of mem */
1410 	}	/* end of for */
1411 	debug("%s - exiting, returning success\n", __func__);
1412 	return 0;
1413 }
1414 
unconfigure_boot_card(struct slot * slot_cur)1415 static int unconfigure_boot_card(struct slot *slot_cur)
1416 {
1417 	u16 vendor_id;
1418 	u32 class;
1419 	u8 hdr_type;
1420 	u8 device;
1421 	u8 busno;
1422 	u8 function;
1423 	int rc;
1424 	unsigned int devfn;
1425 	u8 valid_device = 0x00; /* To see if we are ever able to find valid device and read it */
1426 
1427 	debug("%s - enter\n", __func__);
1428 
1429 	device = slot_cur->device;
1430 	busno = slot_cur->bus;
1431 
1432 	debug("b4 for loop, device is %x\n", device);
1433 	/* For every function on the card */
1434 	for (function = 0x0; function < 0x08; function++) {
1435 		devfn = PCI_DEVFN(device, function);
1436 		ibmphp_pci_bus->number = busno;
1437 
1438 		pci_bus_read_config_word(ibmphp_pci_bus, devfn, PCI_VENDOR_ID, &vendor_id);
1439 
1440 		if (vendor_id != PCI_VENDOR_ID_NOTVALID) {
1441 			/* found correct device!!! */
1442 			++valid_device;
1443 
1444 			debug("%s - found correct device\n", __func__);
1445 
1446 			/* header: x x x x x x x x
1447 			 *         | |___________|=> 1=PPB bridge, 0=normal device, 2=CardBus Bridge
1448 			 *         |_=> 0 = single function device, 1 = multi-function device
1449 			 */
1450 
1451 			pci_bus_read_config_byte(ibmphp_pci_bus, devfn, PCI_HEADER_TYPE, &hdr_type);
1452 			pci_bus_read_config_dword(ibmphp_pci_bus, devfn, PCI_CLASS_REVISION, &class);
1453 
1454 			debug("hdr_type %x, class %x\n", hdr_type, class);
1455 			class >>= 8;	/* to take revision out, class = class.subclass.prog i/f */
1456 			if (class == PCI_CLASS_NOT_DEFINED_VGA) {
1457 				err("The device %x function %x is VGA compatible and is not supported for hot removing.  Please choose another device.\n", device, function);
1458 				return -ENODEV;
1459 			} else if (class == PCI_CLASS_DISPLAY_VGA) {
1460 				err("The device %x function %x is not supported for hot removing.  Please choose another device.\n", device, function);
1461 				return -ENODEV;
1462 			}
1463 
1464 			switch (hdr_type) {
1465 				case PCI_HEADER_TYPE_NORMAL:
1466 					rc = unconfigure_boot_device(busno, device, function);
1467 					if (rc) {
1468 						err("was not able to unconfigure device %x func %x on bus %x. bailing out...\n",
1469 						     device, function, busno);
1470 						return rc;
1471 					}
1472 					function = 0x8;
1473 					break;
1474 				case PCI_HEADER_TYPE_MULTIDEVICE:
1475 					rc = unconfigure_boot_device(busno, device, function);
1476 					if (rc) {
1477 						err("was not able to unconfigure device %x func %x on bus %x. bailing out...\n",
1478 						     device, function, busno);
1479 						return rc;
1480 					}
1481 					break;
1482 				case PCI_HEADER_TYPE_BRIDGE:
1483 					class >>= 8;
1484 					if (class != PCI_CLASS_BRIDGE_PCI) {
1485 						err("This device %x function %x is not PCI-to-PCI bridge, and is not supported for hot-removing.  Please try another card.\n", device, function);
1486 						return -ENODEV;
1487 					}
1488 					rc = unconfigure_boot_bridge(busno, device, function);
1489 					if (rc != 0) {
1490 						err("was not able to hot-remove PPB properly.\n");
1491 						return rc;
1492 					}
1493 
1494 					function = 0x8;
1495 					break;
1496 				case PCI_HEADER_TYPE_MULTIBRIDGE:
1497 					class >>= 8;
1498 					if (class != PCI_CLASS_BRIDGE_PCI) {
1499 						err("This device %x function %x is not PCI-to-PCI bridge,  and is not supported for hot-removing.  Please try another card.\n", device, function);
1500 						return -ENODEV;
1501 					}
1502 					rc = unconfigure_boot_bridge(busno, device, function);
1503 					if (rc != 0) {
1504 						err("was not able to hot-remove PPB properly.\n");
1505 						return rc;
1506 					}
1507 					break;
1508 				default:
1509 					err("MAJOR PROBLEM!!!! Cannot read device's header\n");
1510 					return -1;
1511 			}	/* end of switch */
1512 		}	/* end of valid device */
1513 	}	/* end of for */
1514 
1515 	if (!valid_device) {
1516 		err("Could not find device to unconfigure.  Or could not read the card.\n");
1517 		return -1;
1518 	}
1519 	return 0;
1520 }
1521 
1522 /*
1523  * free the resources of the card (multi, single, or bridged)
1524  * Parameters: slot, flag to say if this is for removing entire module or just
1525  * unconfiguring the device
1526  * TO DO:  will probably need to add some code in case there was some resource,
1527  * to remove it... this is from when we have errors in the configure_card...
1528  *			!!!!!!!!!!!!!!!!!!!!!!!!!FOR BUSES!!!!!!!!!!!!
1529  * Returns: 0, -1, -ENODEV
1530  */
ibmphp_unconfigure_card(struct slot ** slot_cur,int the_end)1531 int ibmphp_unconfigure_card(struct slot **slot_cur, int the_end)
1532 {
1533 	int i;
1534 	int count;
1535 	int rc;
1536 	struct slot *sl = *slot_cur;
1537 	struct pci_func *cur_func = NULL;
1538 	struct pci_func *temp_func;
1539 
1540 	debug("%s - enter\n", __func__);
1541 
1542 	if (!the_end) {
1543 		/* Need to unconfigure the card */
1544 		rc = unconfigure_boot_card(sl);
1545 		if ((rc == -ENODEV) || (rc == -EIO) || (rc == -EINVAL)) {
1546 			/* In all other cases, will still need to get rid of func structure if it exists */
1547 			return rc;
1548 		}
1549 	}
1550 
1551 	if (sl->func) {
1552 		cur_func = sl->func;
1553 		while (cur_func) {
1554 			/* TO DO: WILL MOST LIKELY NEED TO GET RID OF THE BUS STRUCTURE FROM RESOURCES AS WELL */
1555 			if (cur_func->bus) {
1556 				/* in other words, it's a PPB */
1557 				count = 2;
1558 			} else {
1559 				count = 6;
1560 			}
1561 
1562 			for (i = 0; i < count; i++) {
1563 				if (cur_func->io[i]) {
1564 					debug("io[%d] exists\n", i);
1565 					if (the_end > 0)
1566 						ibmphp_remove_resource(cur_func->io[i]);
1567 					cur_func->io[i] = NULL;
1568 				}
1569 				if (cur_func->mem[i]) {
1570 					debug("mem[%d] exists\n", i);
1571 					if (the_end > 0)
1572 						ibmphp_remove_resource(cur_func->mem[i]);
1573 					cur_func->mem[i] = NULL;
1574 				}
1575 				if (cur_func->pfmem[i]) {
1576 					debug("pfmem[%d] exists\n", i);
1577 					if (the_end > 0)
1578 						ibmphp_remove_resource(cur_func->pfmem[i]);
1579 					cur_func->pfmem[i] = NULL;
1580 				}
1581 			}
1582 
1583 			temp_func = cur_func->next;
1584 			kfree(cur_func);
1585 			cur_func = temp_func;
1586 		}
1587 	}
1588 
1589 	sl->func = NULL;
1590 	*slot_cur = sl;
1591 	debug("%s - exit\n", __func__);
1592 	return 0;
1593 }
1594 
1595 /*
1596  * add a new bus resulting from hot-plugging a PPB bridge with devices
1597  *
1598  * Input: bus and the amount of resources needed (we know we can assign those,
1599  *        since they've been checked already
1600  * Output: bus added to the correct spot
1601  *         0, -1, error
1602  */
add_new_bus(struct bus_node * bus,struct resource_node * io,struct resource_node * mem,struct resource_node * pfmem,u8 parent_busno)1603 static int add_new_bus(struct bus_node *bus, struct resource_node *io, struct resource_node *mem, struct resource_node *pfmem, u8 parent_busno)
1604 {
1605 	struct range_node *io_range = NULL;
1606 	struct range_node *mem_range = NULL;
1607 	struct range_node *pfmem_range = NULL;
1608 	struct bus_node *cur_bus = NULL;
1609 
1610 	/* Trying to find the parent bus number */
1611 	if (parent_busno != 0xFF) {
1612 		cur_bus	= ibmphp_find_res_bus(parent_busno);
1613 		if (!cur_bus) {
1614 			err("strange, cannot find bus which is supposed to be at the system... something is terribly wrong...\n");
1615 			return -ENODEV;
1616 		}
1617 
1618 		list_add(&bus->bus_list, &cur_bus->bus_list);
1619 	}
1620 	if (io) {
1621 		io_range = kzalloc(sizeof(*io_range), GFP_KERNEL);
1622 		if (!io_range)
1623 			return -ENOMEM;
1624 
1625 		io_range->start = io->start;
1626 		io_range->end = io->end;
1627 		io_range->rangeno = 1;
1628 		bus->noIORanges = 1;
1629 		bus->rangeIO = io_range;
1630 	}
1631 	if (mem) {
1632 		mem_range = kzalloc(sizeof(*mem_range), GFP_KERNEL);
1633 		if (!mem_range)
1634 			return -ENOMEM;
1635 
1636 		mem_range->start = mem->start;
1637 		mem_range->end = mem->end;
1638 		mem_range->rangeno = 1;
1639 		bus->noMemRanges = 1;
1640 		bus->rangeMem = mem_range;
1641 	}
1642 	if (pfmem) {
1643 		pfmem_range = kzalloc(sizeof(*pfmem_range), GFP_KERNEL);
1644 		if (!pfmem_range)
1645 			return -ENOMEM;
1646 
1647 		pfmem_range->start = pfmem->start;
1648 		pfmem_range->end = pfmem->end;
1649 		pfmem_range->rangeno = 1;
1650 		bus->noPFMemRanges = 1;
1651 		bus->rangePFMem = pfmem_range;
1652 	}
1653 	return 0;
1654 }
1655 
1656 /*
1657  * find the 1st available bus number for PPB to set as its secondary bus
1658  * Parameters: bus_number of the primary bus
1659  * Returns: bus_number of the secondary bus or 0xff in case of failure
1660  */
find_sec_number(u8 primary_busno,u8 slotno)1661 static u8 find_sec_number(u8 primary_busno, u8 slotno)
1662 {
1663 	int min, max;
1664 	u8 busno;
1665 	struct bus_info *bus;
1666 	struct bus_node *bus_cur;
1667 
1668 	bus = ibmphp_find_same_bus_num(primary_busno);
1669 	if (!bus) {
1670 		err("cannot get slot range of the bus from the BIOS\n");
1671 		return 0xff;
1672 	}
1673 	max = bus->slot_max;
1674 	min = bus->slot_min;
1675 	if ((slotno > max) || (slotno < min)) {
1676 		err("got the wrong range\n");
1677 		return 0xff;
1678 	}
1679 	busno = (u8) (slotno - (u8) min);
1680 	busno += primary_busno + 0x01;
1681 	bus_cur = ibmphp_find_res_bus(busno);
1682 	/* either there is no such bus number, or there are no ranges, which
1683 	 * can only happen if we removed the bridged device in previous load
1684 	 * of the driver, and now only have the skeleton bus struct
1685 	 */
1686 	if ((!bus_cur) || (!(bus_cur->rangeIO) && !(bus_cur->rangeMem) && !(bus_cur->rangePFMem)))
1687 		return busno;
1688 	return 0xff;
1689 }
1690