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
  23static int configure_device(struct pci_func *);
  24static int configure_bridge(struct pci_func **, u8);
  25static struct res_needed *scan_behind_bridge(struct pci_func *, u8);
  26static int add_new_bus(struct bus_node *, struct resource_node *, struct resource_node *, struct resource_node *, u8);
  27static 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 */
  36static 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 */
  67int 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
 308error:
 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 */
 329static 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 ******************************************************************************/
 543static 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
1017error:
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 *****************************************************************************/
1046static 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 & PCI_HEADER_TYPE_MASK) == 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 */
1182static 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
1298report_search_failure:
1299	err("cannot find corresponding IO resource to remove\n");
1300	return -EIO;
1301}
1302
1303static 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
1415static 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 */
1531int 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 */
1603static 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 */
1661static 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}