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