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->funcion = %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. " 141 "Please choose another device.\n", 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 if ((rc = configure_device (cur_func)) < 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.\n", 151 cur_func->device, cur_func->busno); 152 cleanup_count = 6; 153 goto error; 154 } 155 cur_func->next = NULL; 156 function = 0x8; 157 break; 158 case PCI_HEADER_TYPE_MULTIDEVICE: 159 assign_alt_irq (cur_func, class_code); 160 if ((rc = configure_device (cur_func)) < 0) { 161 /* We need to do this in case some other BARs were properly inserted */ 162 err ("was not able to configure devfunc %x on bus %x...bailing out\n", 163 cur_func->device, cur_func->busno); 164 cleanup_count = 6; 165 goto error; 166 } 167 newfunc = kzalloc(sizeof(*newfunc), GFP_KERNEL); 168 if (!newfunc) { 169 err ("out of system memory\n"); 170 return -ENOMEM; 171 } 172 newfunc->busno = cur_func->busno; 173 newfunc->device = device; 174 cur_func->next = newfunc; 175 cur_func = newfunc; 176 for (j = 0; j < 4; j++) 177 newfunc->irq[j] = cur_func->irq[j]; 178 break; 179 case PCI_HEADER_TYPE_MULTIBRIDGE: 180 class >>= 8; 181 if (class != PCI_CLASS_BRIDGE_PCI) { 182 err ("This %x is not PCI-to-PCI bridge, and as is not supported for hot-plugging. " 183 "Please insert another card.\n", cur_func->device); 184 return -ENODEV; 185 } 186 assign_alt_irq (cur_func, class_code); 187 rc = configure_bridge (&cur_func, slotno); 188 if (rc == -ENODEV) { 189 err ("You chose to insert Single Bridge, or nested bridges, this is not supported...\n"); 190 err ("Bus %x, devfunc %x\n", cur_func->busno, cur_func->device); 191 return rc; 192 } 193 if (rc) { 194 /* We need to do this in case some other BARs were properly inserted */ 195 err ("was not able to hot-add PPB properly.\n"); 196 func->bus = 1; /* To indicate to the unconfigure function that this is a PPB */ 197 cleanup_count = 2; 198 goto error; 199 } 200 201 pci_bus_read_config_byte (ibmphp_pci_bus, devfn, PCI_SECONDARY_BUS, &sec_number); 202 flag = 0; 203 for (i = 0; i < 32; i++) { 204 if (func->devices[i]) { 205 newfunc = kzalloc(sizeof(*newfunc), GFP_KERNEL); 206 if (!newfunc) { 207 err ("out of system memory\n"); 208 return -ENOMEM; 209 } 210 newfunc->busno = sec_number; 211 newfunc->device = (u8) i; 212 for (j = 0; j < 4; j++) 213 newfunc->irq[j] = cur_func->irq[j]; 214 215 if (flag) { 216 for (prev_func = cur_func; prev_func->next; prev_func = prev_func->next) ; 217 prev_func->next = newfunc; 218 } else 219 cur_func->next = newfunc; 220 221 rc = ibmphp_configure_card (newfunc, slotno); 222 /* This could only happen if kmalloc failed */ 223 if (rc) { 224 /* We need to do this in case bridge itself got configured properly, but devices behind it failed */ 225 func->bus = 1; /* To indicate to the unconfigure function that this is a PPB */ 226 cleanup_count = 2; 227 goto error; 228 } 229 flag = 1; 230 } 231 } 232 233 newfunc = kzalloc(sizeof(*newfunc), GFP_KERNEL); 234 if (!newfunc) { 235 err ("out of system memory\n"); 236 return -ENOMEM; 237 } 238 newfunc->busno = cur_func->busno; 239 newfunc->device = device; 240 for (j = 0; j < 4; j++) 241 newfunc->irq[j] = cur_func->irq[j]; 242 for (prev_func = cur_func; prev_func->next; prev_func = prev_func->next) ; 243 prev_func->next = newfunc; 244 cur_func = newfunc; 245 break; 246 case PCI_HEADER_TYPE_BRIDGE: 247 class >>= 8; 248 debug ("class now is %x\n", class); 249 if (class != PCI_CLASS_BRIDGE_PCI) { 250 err ("This %x is not PCI-to-PCI bridge, and as is not supported for hot-plugging. " 251 "Please insert another card.\n", cur_func->device); 252 return -ENODEV; 253 } 254 255 assign_alt_irq (cur_func, class_code); 256 257 debug ("cur_func->busno b4 configure_bridge is %x\n", cur_func->busno); 258 rc = configure_bridge (&cur_func, slotno); 259 if (rc == -ENODEV) { 260 err ("You chose to insert Single Bridge, or nested bridges, this is not supported...\n"); 261 err ("Bus %x, devfunc %x\n", cur_func->busno, cur_func->device); 262 return rc; 263 } 264 if (rc) { 265 /* We need to do this in case some other BARs were properly inserted */ 266 func->bus = 1; /* To indicate to the unconfigure function that this is a PPB */ 267 err ("was not able to hot-add PPB properly.\n"); 268 cleanup_count = 2; 269 goto error; 270 } 271 debug ("cur_func->busno = %x, device = %x, function = %x\n", 272 cur_func->busno, device, function); 273 pci_bus_read_config_byte (ibmphp_pci_bus, devfn, PCI_SECONDARY_BUS, &sec_number); 274 debug ("after configuring bridge..., sec_number = %x\n", sec_number); 275 flag = 0; 276 for (i = 0; i < 32; i++) { 277 if (func->devices[i]) { 278 debug ("inside for loop, device is %x\n", i); 279 newfunc = kzalloc(sizeof(*newfunc), GFP_KERNEL); 280 if (!newfunc) { 281 err (" out of system memory\n"); 282 return -ENOMEM; 283 } 284 newfunc->busno = sec_number; 285 newfunc->device = (u8) i; 286 for (j = 0; j < 4; j++) 287 newfunc->irq[j] = cur_func->irq[j]; 288 289 if (flag) { 290 for (prev_func = cur_func; prev_func->next; prev_func = prev_func->next) ; 291 prev_func->next = newfunc; 292 } else 293 cur_func->next = newfunc; 294 295 rc = ibmphp_configure_card (newfunc, slotno); 296 297 /* Again, this case should not happen... For complete paranoia, will need to call remove_bus */ 298 if (rc) { 299 /* We need to do this in case some other BARs were properly inserted */ 300 func->bus = 1; /* To indicate to the unconfigure function that this is a PPB */ 301 cleanup_count = 2; 302 goto error; 303 } 304 flag = 1; 305 } 306 } 307 308 function = 0x8; 309 break; 310 default: 311 err ("MAJOR PROBLEM!!!!, header type not supported? %x\n", hdr_type); 312 return -ENXIO; 313 break; 314 } /* end of switch */ 315 } /* end of valid device */ 316 } /* end of for */ 317 318 if (!valid_device) { 319 err ("Cannot find any valid devices on the card. Or unable to read from card.\n"); 320 return -ENODEV; 321 } 322 323 return 0; 324 325error: 326 for (i = 0; i < cleanup_count; i++) { 327 if (cur_func->io[i]) { 328 ibmphp_remove_resource (cur_func->io[i]); 329 cur_func->io[i] = NULL; 330 } else if (cur_func->pfmem[i]) { 331 ibmphp_remove_resource (cur_func->pfmem[i]); 332 cur_func->pfmem[i] = NULL; 333 } else if (cur_func->mem[i]) { 334 ibmphp_remove_resource (cur_func->mem[i]); 335 cur_func->mem[i] = NULL; 336 } 337 } 338 return rc; 339} 340 341/* 342 * This function configures the pci BARs of a single device. 343 * Input: pointer to the pci_func 344 * Output: configured PCI, 0, or error 345 */ 346static int configure_device (struct pci_func *func) 347{ 348 u32 bar[6]; 349 u32 address[] = { 350 PCI_BASE_ADDRESS_0, 351 PCI_BASE_ADDRESS_1, 352 PCI_BASE_ADDRESS_2, 353 PCI_BASE_ADDRESS_3, 354 PCI_BASE_ADDRESS_4, 355 PCI_BASE_ADDRESS_5, 356 0 357 }; 358 u8 irq; 359 int count; 360 int len[6]; 361 struct resource_node *io[6]; 362 struct resource_node *mem[6]; 363 struct resource_node *mem_tmp; 364 struct resource_node *pfmem[6]; 365 unsigned int devfn; 366 367 debug ("%s - inside\n", __func__); 368 369 devfn = PCI_DEVFN(func->device, func->function); 370 ibmphp_pci_bus->number = func->busno; 371 372 for (count = 0; address[count]; count++) { /* for 6 BARs */ 373 374 /* not sure if i need this. per scott, said maybe need smth like this 375 if devices don't adhere 100% to the spec, so don't want to write 376 to the reserved bits 377 378 pcibios_read_config_byte(cur_func->busno, cur_func->device, 379 PCI_BASE_ADDRESS_0 + 4 * count, &tmp); 380 if (tmp & 0x01) // IO 381 pcibios_write_config_dword(cur_func->busno, cur_func->device, 382 PCI_BASE_ADDRESS_0 + 4 * count, 0xFFFFFFFD); 383 else // Memory 384 pcibios_write_config_dword(cur_func->busno, cur_func->device, 385 PCI_BASE_ADDRESS_0 + 4 * count, 0xFFFFFFFF); 386 */ 387 pci_bus_write_config_dword (ibmphp_pci_bus, devfn, address[count], 0xFFFFFFFF); 388 pci_bus_read_config_dword (ibmphp_pci_bus, devfn, address[count], &bar[count]); 389 390 if (!bar[count]) /* This BAR is not implemented */ 391 continue; 392 393 debug ("Device %x BAR %d wants %x\n", func->device, count, bar[count]); 394 395 if (bar[count] & PCI_BASE_ADDRESS_SPACE_IO) { 396 /* This is IO */ 397 debug ("inside IO SPACE\n"); 398 399 len[count] = bar[count] & 0xFFFFFFFC; 400 len[count] = ~len[count] + 1; 401 402 debug ("len[count] in IO %x, count %d\n", len[count], count); 403 404 io[count] = kzalloc(sizeof(struct resource_node), GFP_KERNEL); 405 406 if (!io[count]) { 407 err ("out of system memory\n"); 408 return -ENOMEM; 409 } 410 io[count]->type = IO; 411 io[count]->busno = func->busno; 412 io[count]->devfunc = PCI_DEVFN(func->device, func->function); 413 io[count]->len = len[count]; 414 if (ibmphp_check_resource(io[count], 0) == 0) { 415 ibmphp_add_resource (io[count]); 416 func->io[count] = io[count]; 417 } else { 418 err ("cannot allocate requested io for bus %x device %x function %x len %x\n", 419 func->busno, func->device, func->function, len[count]); 420 kfree (io[count]); 421 return -EIO; 422 } 423 pci_bus_write_config_dword (ibmphp_pci_bus, devfn, address[count], func->io[count]->start); 424 425 /* _______________This is for debugging purposes only_____________________ */ 426 debug ("b4 writing, the IO address is %x\n", func->io[count]->start); 427 pci_bus_read_config_dword (ibmphp_pci_bus, devfn, address[count], &bar[count]); 428 debug ("after writing.... the start address is %x\n", bar[count]); 429 /* _________________________________________________________________________*/ 430 431 } else { 432 /* This is Memory */ 433 if (bar[count] & PCI_BASE_ADDRESS_MEM_PREFETCH) { 434 /* pfmem */ 435 debug ("PFMEM SPACE\n"); 436 437 len[count] = bar[count] & 0xFFFFFFF0; 438 len[count] = ~len[count] + 1; 439 440 debug ("len[count] in PFMEM %x, count %d\n", len[count], count); 441 442 pfmem[count] = kzalloc(sizeof(struct resource_node), GFP_KERNEL); 443 if (!pfmem[count]) { 444 err ("out of system memory\n"); 445 return -ENOMEM; 446 } 447 pfmem[count]->type = PFMEM; 448 pfmem[count]->busno = func->busno; 449 pfmem[count]->devfunc = PCI_DEVFN(func->device, 450 func->function); 451 pfmem[count]->len = len[count]; 452 pfmem[count]->fromMem = 0; 453 if (ibmphp_check_resource (pfmem[count], 0) == 0) { 454 ibmphp_add_resource (pfmem[count]); 455 func->pfmem[count] = pfmem[count]; 456 } else { 457 mem_tmp = kzalloc(sizeof(*mem_tmp), GFP_KERNEL); 458 if (!mem_tmp) { 459 err ("out of system memory\n"); 460 kfree (pfmem[count]); 461 return -ENOMEM; 462 } 463 mem_tmp->type = MEM; 464 mem_tmp->busno = pfmem[count]->busno; 465 mem_tmp->devfunc = pfmem[count]->devfunc; 466 mem_tmp->len = pfmem[count]->len; 467 debug ("there's no pfmem... going into mem.\n"); 468 if (ibmphp_check_resource (mem_tmp, 0) == 0) { 469 ibmphp_add_resource (mem_tmp); 470 pfmem[count]->fromMem = 1; 471 pfmem[count]->rangeno = mem_tmp->rangeno; 472 pfmem[count]->start = mem_tmp->start; 473 pfmem[count]->end = mem_tmp->end; 474 ibmphp_add_pfmem_from_mem (pfmem[count]); 475 func->pfmem[count] = pfmem[count]; 476 } else { 477 err ("cannot allocate requested pfmem for bus %x, device %x, len %x\n", 478 func->busno, func->device, len[count]); 479 kfree (mem_tmp); 480 kfree (pfmem[count]); 481 return -EIO; 482 } 483 } 484 485 pci_bus_write_config_dword (ibmphp_pci_bus, devfn, address[count], func->pfmem[count]->start); 486 487 /*_______________This is for debugging purposes only______________________________*/ 488 debug ("b4 writing, start address is %x\n", func->pfmem[count]->start); 489 pci_bus_read_config_dword (ibmphp_pci_bus, devfn, address[count], &bar[count]); 490 debug ("after writing, start address is %x\n", bar[count]); 491 /*_________________________________________________________________________________*/ 492 493 if (bar[count] & PCI_BASE_ADDRESS_MEM_TYPE_64) { /* takes up another dword */ 494 debug ("inside the mem 64 case, count %d\n", count); 495 count += 1; 496 /* on the 2nd dword, write all 0s, since we can't handle them n.e.ways */ 497 pci_bus_write_config_dword (ibmphp_pci_bus, devfn, address[count], 0x00000000); 498 } 499 } else { 500 /* regular memory */ 501 debug ("REGULAR MEM SPACE\n"); 502 503 len[count] = bar[count] & 0xFFFFFFF0; 504 len[count] = ~len[count] + 1; 505 506 debug ("len[count] in Mem %x, count %d\n", len[count], count); 507 508 mem[count] = kzalloc(sizeof(struct resource_node), GFP_KERNEL); 509 if (!mem[count]) { 510 err ("out of system memory\n"); 511 return -ENOMEM; 512 } 513 mem[count]->type = MEM; 514 mem[count]->busno = func->busno; 515 mem[count]->devfunc = PCI_DEVFN(func->device, 516 func->function); 517 mem[count]->len = len[count]; 518 if (ibmphp_check_resource (mem[count], 0) == 0) { 519 ibmphp_add_resource (mem[count]); 520 func->mem[count] = mem[count]; 521 } else { 522 err ("cannot allocate requested mem for bus %x, device %x, len %x\n", 523 func->busno, func->device, len[count]); 524 kfree (mem[count]); 525 return -EIO; 526 } 527 pci_bus_write_config_dword (ibmphp_pci_bus, devfn, address[count], func->mem[count]->start); 528 /* _______________________This is for debugging purposes only _______________________*/ 529 debug ("b4 writing, start address is %x\n", func->mem[count]->start); 530 pci_bus_read_config_dword (ibmphp_pci_bus, devfn, address[count], &bar[count]); 531 debug ("after writing, the address is %x\n", bar[count]); 532 /* __________________________________________________________________________________*/ 533 534 if (bar[count] & PCI_BASE_ADDRESS_MEM_TYPE_64) { 535 /* takes up another dword */ 536 debug ("inside mem 64 case, reg. mem, count %d\n", count); 537 count += 1; 538 /* on the 2nd dword, write all 0s, since we can't handle them n.e.ways */ 539 pci_bus_write_config_dword (ibmphp_pci_bus, devfn, address[count], 0x00000000); 540 } 541 } 542 } /* end of mem */ 543 } /* end of for */ 544 545 func->bus = 0; /* To indicate that this is not a PPB */ 546 pci_bus_read_config_byte (ibmphp_pci_bus, devfn, PCI_INTERRUPT_PIN, &irq); 547 if ((irq > 0x00) && (irq < 0x05)) 548 pci_bus_write_config_byte (ibmphp_pci_bus, devfn, PCI_INTERRUPT_LINE, func->irq[irq - 1]); 549 550 pci_bus_write_config_byte (ibmphp_pci_bus, devfn, PCI_CACHE_LINE_SIZE, CACHE); 551 pci_bus_write_config_byte (ibmphp_pci_bus, devfn, PCI_LATENCY_TIMER, LATENCY); 552 553 pci_bus_write_config_dword (ibmphp_pci_bus, devfn, PCI_ROM_ADDRESS, 0x00L); 554 pci_bus_write_config_word (ibmphp_pci_bus, devfn, PCI_COMMAND, DEVICEENABLE); 555 556 return 0; 557} 558 559/****************************************************************************** 560 * This routine configures a PCI-2-PCI bridge and the functions behind it 561 * Parameters: pci_func 562 * Returns: 563 ******************************************************************************/ 564static int configure_bridge (struct pci_func **func_passed, u8 slotno) 565{ 566 int count; 567 int i; 568 int rc; 569 u8 sec_number; 570 u8 io_base; 571 u16 pfmem_base; 572 u32 bar[2]; 573 u32 len[2]; 574 u8 flag_io = 0; 575 u8 flag_mem = 0; 576 u8 flag_pfmem = 0; 577 u8 need_io_upper = 0; 578 u8 need_pfmem_upper = 0; 579 struct res_needed *amount_needed = NULL; 580 struct resource_node *io = NULL; 581 struct resource_node *bus_io[2] = {NULL, NULL}; 582 struct resource_node *mem = NULL; 583 struct resource_node *bus_mem[2] = {NULL, NULL}; 584 struct resource_node *mem_tmp = NULL; 585 struct resource_node *pfmem = NULL; 586 struct resource_node *bus_pfmem[2] = {NULL, NULL}; 587 struct bus_node *bus; 588 u32 address[] = { 589 PCI_BASE_ADDRESS_0, 590 PCI_BASE_ADDRESS_1, 591 0 592 }; 593 struct pci_func *func = *func_passed; 594 unsigned int devfn; 595 u8 irq; 596 int retval; 597 598 debug ("%s - enter\n", __func__); 599 600 devfn = PCI_DEVFN(func->function, func->device); 601 ibmphp_pci_bus->number = func->busno; 602 603 /* Configuring necessary info for the bridge so that we could see the devices 604 * behind it 605 */ 606 607 pci_bus_write_config_byte (ibmphp_pci_bus, devfn, PCI_PRIMARY_BUS, func->busno); 608 609 /* _____________________For debugging purposes only __________________________ 610 pci_bus_config_byte (ibmphp_pci_bus, devfn, PCI_PRIMARY_BUS, &pri_number); 611 debug ("primary # written into the bridge is %x\n", pri_number); 612 ___________________________________________________________________________*/ 613 614 /* in EBDA, only get allocated 1 additional bus # per slot */ 615 sec_number = find_sec_number (func->busno, slotno); 616 if (sec_number == 0xff) { 617 err ("cannot allocate secondary bus number for the bridged device\n"); 618 return -EINVAL; 619 } 620 621 debug ("after find_sec_number, the number we got is %x\n", sec_number); 622 debug ("AFTER FIND_SEC_NUMBER, func->busno IS %x\n", func->busno); 623 624 pci_bus_write_config_byte (ibmphp_pci_bus, devfn, PCI_SECONDARY_BUS, sec_number); 625 626 /* __________________For debugging purposes only __________________________________ 627 pci_bus_read_config_byte (ibmphp_pci_bus, devfn, PCI_SECONDARY_BUS, &sec_number); 628 debug ("sec_number after write/read is %x\n", sec_number); 629 ________________________________________________________________________________*/ 630 631 pci_bus_write_config_byte (ibmphp_pci_bus, devfn, PCI_SUBORDINATE_BUS, sec_number); 632 633 /* __________________For debugging purposes only ____________________________________ 634 pci_bus_read_config_byte (ibmphp_pci_bus, devfn, PCI_SUBORDINATE_BUS, &sec_number); 635 debug ("subordinate number after write/read is %x\n", sec_number); 636 __________________________________________________________________________________*/ 637 638 pci_bus_write_config_byte (ibmphp_pci_bus, devfn, PCI_CACHE_LINE_SIZE, CACHE); 639 pci_bus_write_config_byte (ibmphp_pci_bus, devfn, PCI_LATENCY_TIMER, LATENCY); 640 pci_bus_write_config_byte (ibmphp_pci_bus, devfn, PCI_SEC_LATENCY_TIMER, LATENCY); 641 642 debug ("func->busno is %x\n", func->busno); 643 debug ("sec_number after writing is %x\n", sec_number); 644 645 646 /* !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! 647 !!!!!!!!!!!!!!!NEED TO ADD!!! FAST BACK-TO-BACK ENABLE!!!!!!!!!!!!!!!!!!!! 648 !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!*/ 649 650 651 /* First we need to allocate mem/io for the bridge itself in case it needs it */ 652 for (count = 0; address[count]; count++) { /* for 2 BARs */ 653 pci_bus_write_config_dword (ibmphp_pci_bus, devfn, address[count], 0xFFFFFFFF); 654 pci_bus_read_config_dword (ibmphp_pci_bus, devfn, address[count], &bar[count]); 655 656 if (!bar[count]) { 657 /* This BAR is not implemented */ 658 debug ("so we come here then, eh?, count = %d\n", count); 659 continue; 660 } 661 // tmp_bar = bar[count]; 662 663 debug ("Bar %d wants %x\n", count, bar[count]); 664 665 if (bar[count] & PCI_BASE_ADDRESS_SPACE_IO) { 666 /* This is IO */ 667 len[count] = bar[count] & 0xFFFFFFFC; 668 len[count] = ~len[count] + 1; 669 670 debug ("len[count] in IO = %x\n", len[count]); 671 672 bus_io[count] = kzalloc(sizeof(struct resource_node), GFP_KERNEL); 673 674 if (!bus_io[count]) { 675 err ("out of system memory\n"); 676 retval = -ENOMEM; 677 goto error; 678 } 679 bus_io[count]->type = IO; 680 bus_io[count]->busno = func->busno; 681 bus_io[count]->devfunc = PCI_DEVFN(func->device, 682 func->function); 683 bus_io[count]->len = len[count]; 684 if (ibmphp_check_resource (bus_io[count], 0) == 0) { 685 ibmphp_add_resource (bus_io[count]); 686 func->io[count] = bus_io[count]; 687 } else { 688 err ("cannot allocate requested io for bus %x, device %x, len %x\n", 689 func->busno, func->device, len[count]); 690 kfree (bus_io[count]); 691 return -EIO; 692 } 693 694 pci_bus_write_config_dword (ibmphp_pci_bus, devfn, address[count], func->io[count]->start); 695 696 } else { 697 /* This is Memory */ 698 if (bar[count] & PCI_BASE_ADDRESS_MEM_PREFETCH) { 699 /* pfmem */ 700 len[count] = bar[count] & 0xFFFFFFF0; 701 len[count] = ~len[count] + 1; 702 703 debug ("len[count] in PFMEM = %x\n", len[count]); 704 705 bus_pfmem[count] = kzalloc(sizeof(struct resource_node), GFP_KERNEL); 706 if (!bus_pfmem[count]) { 707 err ("out of system memory\n"); 708 retval = -ENOMEM; 709 goto error; 710 } 711 bus_pfmem[count]->type = PFMEM; 712 bus_pfmem[count]->busno = func->busno; 713 bus_pfmem[count]->devfunc = PCI_DEVFN(func->device, 714 func->function); 715 bus_pfmem[count]->len = len[count]; 716 bus_pfmem[count]->fromMem = 0; 717 if (ibmphp_check_resource (bus_pfmem[count], 0) == 0) { 718 ibmphp_add_resource (bus_pfmem[count]); 719 func->pfmem[count] = bus_pfmem[count]; 720 } else { 721 mem_tmp = kzalloc(sizeof(*mem_tmp), GFP_KERNEL); 722 if (!mem_tmp) { 723 err ("out of system memory\n"); 724 retval = -ENOMEM; 725 goto error; 726 } 727 mem_tmp->type = MEM; 728 mem_tmp->busno = bus_pfmem[count]->busno; 729 mem_tmp->devfunc = bus_pfmem[count]->devfunc; 730 mem_tmp->len = bus_pfmem[count]->len; 731 if (ibmphp_check_resource (mem_tmp, 0) == 0) { 732 ibmphp_add_resource (mem_tmp); 733 bus_pfmem[count]->fromMem = 1; 734 bus_pfmem[count]->rangeno = mem_tmp->rangeno; 735 ibmphp_add_pfmem_from_mem (bus_pfmem[count]); 736 func->pfmem[count] = bus_pfmem[count]; 737 } else { 738 err ("cannot allocate requested pfmem for bus %x, device %x, len %x\n", 739 func->busno, func->device, len[count]); 740 kfree (mem_tmp); 741 kfree (bus_pfmem[count]); 742 return -EIO; 743 } 744 } 745 746 pci_bus_write_config_dword (ibmphp_pci_bus, devfn, address[count], func->pfmem[count]->start); 747 748 if (bar[count] & PCI_BASE_ADDRESS_MEM_TYPE_64) { 749 /* takes up another dword */ 750 count += 1; 751 /* on the 2nd dword, write all 0s, since we can't handle them n.e.ways */ 752 pci_bus_write_config_dword (ibmphp_pci_bus, devfn, address[count], 0x00000000); 753 754 } 755 } else { 756 /* regular memory */ 757 len[count] = bar[count] & 0xFFFFFFF0; 758 len[count] = ~len[count] + 1; 759 760 debug ("len[count] in Memory is %x\n", len[count]); 761 762 bus_mem[count] = kzalloc(sizeof(struct resource_node), GFP_KERNEL); 763 if (!bus_mem[count]) { 764 err ("out of system memory\n"); 765 retval = -ENOMEM; 766 goto error; 767 } 768 bus_mem[count]->type = MEM; 769 bus_mem[count]->busno = func->busno; 770 bus_mem[count]->devfunc = PCI_DEVFN(func->device, 771 func->function); 772 bus_mem[count]->len = len[count]; 773 if (ibmphp_check_resource (bus_mem[count], 0) == 0) { 774 ibmphp_add_resource (bus_mem[count]); 775 func->mem[count] = bus_mem[count]; 776 } else { 777 err ("cannot allocate requested mem for bus %x, device %x, len %x\n", 778 func->busno, func->device, len[count]); 779 kfree (bus_mem[count]); 780 return -EIO; 781 } 782 783 pci_bus_write_config_dword (ibmphp_pci_bus, devfn, address[count], func->mem[count]->start); 784 785 if (bar[count] & PCI_BASE_ADDRESS_MEM_TYPE_64) { 786 /* takes up another dword */ 787 count += 1; 788 /* on the 2nd dword, write all 0s, since we can't handle them n.e.ways */ 789 pci_bus_write_config_dword (ibmphp_pci_bus, devfn, address[count], 0x00000000); 790 791 } 792 } 793 } /* end of mem */ 794 } /* end of for */ 795 796 /* Now need to see how much space the devices behind the bridge needed */ 797 amount_needed = scan_behind_bridge (func, sec_number); 798 if (amount_needed == NULL) 799 return -ENOMEM; 800 801 ibmphp_pci_bus->number = func->busno; 802 debug ("after coming back from scan_behind_bridge\n"); 803 debug ("amount_needed->not_correct = %x\n", amount_needed->not_correct); 804 debug ("amount_needed->io = %x\n", amount_needed->io); 805 debug ("amount_needed->mem = %x\n", amount_needed->mem); 806 debug ("amount_needed->pfmem = %x\n", amount_needed->pfmem); 807 808 if (amount_needed->not_correct) { 809 debug ("amount_needed is not correct\n"); 810 for (count = 0; address[count]; count++) { 811 /* for 2 BARs */ 812 if (bus_io[count]) { 813 ibmphp_remove_resource (bus_io[count]); 814 func->io[count] = NULL; 815 } else if (bus_pfmem[count]) { 816 ibmphp_remove_resource (bus_pfmem[count]); 817 func->pfmem[count] = NULL; 818 } else if (bus_mem[count]) { 819 ibmphp_remove_resource (bus_mem[count]); 820 func->mem[count] = NULL; 821 } 822 } 823 kfree (amount_needed); 824 return -ENODEV; 825 } 826 827 if (!amount_needed->io) { 828 debug ("it doesn't want IO?\n"); 829 flag_io = 1; 830 } else { 831 debug ("it wants %x IO behind the bridge\n", amount_needed->io); 832 io = kzalloc(sizeof(*io), GFP_KERNEL); 833 834 if (!io) { 835 err ("out of system memory\n"); 836 retval = -ENOMEM; 837 goto error; 838 } 839 io->type = IO; 840 io->busno = func->busno; 841 io->devfunc = PCI_DEVFN(func->device, func->function); 842 io->len = amount_needed->io; 843 if (ibmphp_check_resource (io, 1) == 0) { 844 debug ("were we able to add io\n"); 845 ibmphp_add_resource (io); 846 flag_io = 1; 847 } 848 } 849 850 if (!amount_needed->mem) { 851 debug ("it doesn't want n.e.memory?\n"); 852 flag_mem = 1; 853 } else { 854 debug ("it wants %x memory behind the bridge\n", amount_needed->mem); 855 mem = kzalloc(sizeof(*mem), GFP_KERNEL); 856 if (!mem) { 857 err ("out of system memory\n"); 858 retval = -ENOMEM; 859 goto error; 860 } 861 mem->type = MEM; 862 mem->busno = func->busno; 863 mem->devfunc = PCI_DEVFN(func->device, func->function); 864 mem->len = amount_needed->mem; 865 if (ibmphp_check_resource (mem, 1) == 0) { 866 ibmphp_add_resource (mem); 867 flag_mem = 1; 868 debug ("were we able to add mem\n"); 869 } 870 } 871 872 if (!amount_needed->pfmem) { 873 debug ("it doesn't want n.e.pfmem mem?\n"); 874 flag_pfmem = 1; 875 } else { 876 debug ("it wants %x pfmemory behind the bridge\n", amount_needed->pfmem); 877 pfmem = kzalloc(sizeof(*pfmem), GFP_KERNEL); 878 if (!pfmem) { 879 err ("out of system memory\n"); 880 retval = -ENOMEM; 881 goto error; 882 } 883 pfmem->type = PFMEM; 884 pfmem->busno = func->busno; 885 pfmem->devfunc = PCI_DEVFN(func->device, func->function); 886 pfmem->len = amount_needed->pfmem; 887 pfmem->fromMem = 0; 888 if (ibmphp_check_resource (pfmem, 1) == 0) { 889 ibmphp_add_resource (pfmem); 890 flag_pfmem = 1; 891 } else { 892 mem_tmp = kzalloc(sizeof(*mem_tmp), GFP_KERNEL); 893 if (!mem_tmp) { 894 err ("out of system memory\n"); 895 retval = -ENOMEM; 896 goto error; 897 } 898 mem_tmp->type = MEM; 899 mem_tmp->busno = pfmem->busno; 900 mem_tmp->devfunc = pfmem->devfunc; 901 mem_tmp->len = pfmem->len; 902 if (ibmphp_check_resource (mem_tmp, 1) == 0) { 903 ibmphp_add_resource (mem_tmp); 904 pfmem->fromMem = 1; 905 pfmem->rangeno = mem_tmp->rangeno; 906 ibmphp_add_pfmem_from_mem (pfmem); 907 flag_pfmem = 1; 908 } 909 } 910 } 911 912 debug ("b4 if (flag_io && flag_mem && flag_pfmem)\n"); 913 debug ("flag_io = %x, flag_mem = %x, flag_pfmem = %x\n", flag_io, flag_mem, flag_pfmem); 914 915 if (flag_io && flag_mem && flag_pfmem) { 916 /* If on bootup, there was a bridged card in this slot, 917 * then card was removed and ibmphp got unloaded and loaded 918 * back again, there's no way for us to remove the bus 919 * struct, so no need to kmalloc, can use existing node 920 */ 921 bus = ibmphp_find_res_bus (sec_number); 922 if (!bus) { 923 bus = kzalloc(sizeof(*bus), GFP_KERNEL); 924 if (!bus) { 925 err ("out of system memory\n"); 926 retval = -ENOMEM; 927 goto error; 928 } 929 bus->busno = sec_number; 930 debug ("b4 adding new bus\n"); 931 rc = add_new_bus (bus, io, mem, pfmem, func->busno); 932 } else if (!(bus->rangeIO) && !(bus->rangeMem) && !(bus->rangePFMem)) 933 rc = add_new_bus (bus, io, mem, pfmem, 0xFF); 934 else { 935 err ("expected bus structure not empty?\n"); 936 retval = -EIO; 937 goto error; 938 } 939 if (rc) { 940 if (rc == -ENOMEM) { 941 ibmphp_remove_bus (bus, func->busno); 942 kfree (amount_needed); 943 return rc; 944 } 945 retval = rc; 946 goto error; 947 } 948 pci_bus_read_config_byte (ibmphp_pci_bus, devfn, PCI_IO_BASE, &io_base); 949 pci_bus_read_config_word (ibmphp_pci_bus, devfn, PCI_PREF_MEMORY_BASE, &pfmem_base); 950 951 if ((io_base & PCI_IO_RANGE_TYPE_MASK) == PCI_IO_RANGE_TYPE_32) { 952 debug ("io 32\n"); 953 need_io_upper = 1; 954 } 955 if ((pfmem_base & PCI_PREF_RANGE_TYPE_MASK) == PCI_PREF_RANGE_TYPE_64) { 956 debug ("pfmem 64\n"); 957 need_pfmem_upper = 1; 958 } 959 960 if (bus->noIORanges) { 961 pci_bus_write_config_byte (ibmphp_pci_bus, devfn, PCI_IO_BASE, 0x00 | bus->rangeIO->start >> 8); 962 pci_bus_write_config_byte (ibmphp_pci_bus, devfn, PCI_IO_LIMIT, 0x00 | bus->rangeIO->end >> 8); 963 964 /* _______________This is for debugging purposes only ____________________ 965 pci_bus_read_config_byte (ibmphp_pci_bus, devfn, PCI_IO_BASE, &temp); 966 debug ("io_base = %x\n", (temp & PCI_IO_RANGE_TYPE_MASK) << 8); 967 pci_bus_read_config_byte (ibmphp_pci_bus, devfn, PCI_IO_LIMIT, &temp); 968 debug ("io_limit = %x\n", (temp & PCI_IO_RANGE_TYPE_MASK) << 8); 969 ________________________________________________________________________*/ 970 971 if (need_io_upper) { /* since can't support n.e.ways */ 972 pci_bus_write_config_word (ibmphp_pci_bus, devfn, PCI_IO_BASE_UPPER16, 0x0000); 973 pci_bus_write_config_word (ibmphp_pci_bus, devfn, PCI_IO_LIMIT_UPPER16, 0x0000); 974 } 975 } else { 976 pci_bus_write_config_byte (ibmphp_pci_bus, devfn, PCI_IO_BASE, 0x00); 977 pci_bus_write_config_byte (ibmphp_pci_bus, devfn, PCI_IO_LIMIT, 0x00); 978 } 979 980 if (bus->noMemRanges) { 981 pci_bus_write_config_word (ibmphp_pci_bus, devfn, PCI_MEMORY_BASE, 0x0000 | bus->rangeMem->start >> 16); 982 pci_bus_write_config_word (ibmphp_pci_bus, devfn, PCI_MEMORY_LIMIT, 0x0000 | bus->rangeMem->end >> 16); 983 984 /* ____________________This is for debugging purposes only ________________________ 985 pci_bus_read_config_word (ibmphp_pci_bus, devfn, PCI_MEMORY_BASE, &temp); 986 debug ("mem_base = %x\n", (temp & PCI_MEMORY_RANGE_TYPE_MASK) << 16); 987 pci_bus_read_config_word (ibmphp_pci_bus, devfn, PCI_MEMORY_LIMIT, &temp); 988 debug ("mem_limit = %x\n", (temp & PCI_MEMORY_RANGE_TYPE_MASK) << 16); 989 __________________________________________________________________________________*/ 990 991 } else { 992 pci_bus_write_config_word (ibmphp_pci_bus, devfn, PCI_MEMORY_BASE, 0xffff); 993 pci_bus_write_config_word (ibmphp_pci_bus, devfn, PCI_MEMORY_LIMIT, 0x0000); 994 } 995 if (bus->noPFMemRanges) { 996 pci_bus_write_config_word (ibmphp_pci_bus, devfn, PCI_PREF_MEMORY_BASE, 0x0000 | bus->rangePFMem->start >> 16); 997 pci_bus_write_config_word (ibmphp_pci_bus, devfn, PCI_PREF_MEMORY_LIMIT, 0x0000 | bus->rangePFMem->end >> 16); 998 999 /* __________________________This is for debugging purposes only _______________________ 1000 pci_bus_read_config_word (ibmphp_pci_bus, devfn, PCI_PREF_MEMORY_BASE, &temp); 1001 debug ("pfmem_base = %x", (temp & PCI_MEMORY_RANGE_TYPE_MASK) << 16); 1002 pci_bus_read_config_word (ibmphp_pci_bus, devfn, PCI_PREF_MEMORY_LIMIT, &temp); 1003 debug ("pfmem_limit = %x\n", (temp & PCI_MEMORY_RANGE_TYPE_MASK) << 16); 1004 ______________________________________________________________________________________*/ 1005 1006 if (need_pfmem_upper) { /* since can't support n.e.ways */ 1007 pci_bus_write_config_dword (ibmphp_pci_bus, devfn, PCI_PREF_BASE_UPPER32, 0x00000000); 1008 pci_bus_write_config_dword (ibmphp_pci_bus, devfn, PCI_PREF_LIMIT_UPPER32, 0x00000000); 1009 } 1010 } else { 1011 pci_bus_write_config_word (ibmphp_pci_bus, devfn, PCI_PREF_MEMORY_BASE, 0xffff); 1012 pci_bus_write_config_word (ibmphp_pci_bus, devfn, PCI_PREF_MEMORY_LIMIT, 0x0000); 1013 } 1014 1015 debug ("b4 writing control information\n"); 1016 1017 pci_bus_read_config_byte (ibmphp_pci_bus, devfn, PCI_INTERRUPT_PIN, &irq); 1018 if ((irq > 0x00) && (irq < 0x05)) 1019 pci_bus_write_config_byte (ibmphp_pci_bus, devfn, PCI_INTERRUPT_LINE, func->irq[irq - 1]); 1020 /* 1021 pci_bus_write_config_byte (ibmphp_pci_bus, devfn, PCI_BRIDGE_CONTROL, ctrl); 1022 pci_bus_write_config_byte (ibmphp_pci_bus, devfn, PCI_BRIDGE_CONTROL, PCI_BRIDGE_CTL_PARITY); 1023 pci_bus_write_config_byte (ibmphp_pci_bus, devfn, PCI_BRIDGE_CONTROL, PCI_BRIDGE_CTL_SERR); 1024 */ 1025 1026 pci_bus_write_config_word (ibmphp_pci_bus, devfn, PCI_COMMAND, DEVICEENABLE); 1027 pci_bus_write_config_word (ibmphp_pci_bus, devfn, PCI_BRIDGE_CONTROL, 0x07); 1028 for (i = 0; i < 32; i++) { 1029 if (amount_needed->devices[i]) { 1030 debug ("device where devices[i] is 1 = %x\n", i); 1031 func->devices[i] = 1; 1032 } 1033 } 1034 func->bus = 1; /* For unconfiguring, to indicate it's PPB */ 1035 func_passed = &func; 1036 debug ("func->busno b4 returning is %x\n", func->busno); 1037 debug ("func->busno b4 returning in the other structure is %x\n", (*func_passed)->busno); 1038 kfree (amount_needed); 1039 return 0; 1040 } else { 1041 err ("Configuring bridge was unsuccessful...\n"); 1042 mem_tmp = NULL; 1043 retval = -EIO; 1044 goto error; 1045 } 1046 1047error: 1048 kfree(amount_needed); 1049 if (pfmem) 1050 ibmphp_remove_resource (pfmem); 1051 if (io) 1052 ibmphp_remove_resource (io); 1053 if (mem) 1054 ibmphp_remove_resource (mem); 1055 for (i = 0; i < 2; i++) { /* for 2 BARs */ 1056 if (bus_io[i]) { 1057 ibmphp_remove_resource (bus_io[i]); 1058 func->io[i] = NULL; 1059 } else if (bus_pfmem[i]) { 1060 ibmphp_remove_resource (bus_pfmem[i]); 1061 func->pfmem[i] = NULL; 1062 } else if (bus_mem[i]) { 1063 ibmphp_remove_resource (bus_mem[i]); 1064 func->mem[i] = NULL; 1065 } 1066 } 1067 return retval; 1068} 1069 1070/***************************************************************************** 1071 * This function adds up the amount of resources needed behind the PPB bridge 1072 * and passes it to the configure_bridge function 1073 * Input: bridge function 1074 * Ouput: amount of resources needed 1075 *****************************************************************************/ 1076static struct res_needed *scan_behind_bridge (struct pci_func * func, u8 busno) 1077{ 1078 int count, len[6]; 1079 u16 vendor_id; 1080 u8 hdr_type; 1081 u8 device, function; 1082 unsigned int devfn; 1083 int howmany = 0; /*this is to see if there are any devices behind the bridge */ 1084 1085 u32 bar[6], class; 1086 u32 address[] = { 1087 PCI_BASE_ADDRESS_0, 1088 PCI_BASE_ADDRESS_1, 1089 PCI_BASE_ADDRESS_2, 1090 PCI_BASE_ADDRESS_3, 1091 PCI_BASE_ADDRESS_4, 1092 PCI_BASE_ADDRESS_5, 1093 0 1094 }; 1095 struct res_needed *amount; 1096 1097 amount = kzalloc(sizeof(*amount), GFP_KERNEL); 1098 if (amount == NULL) 1099 return NULL; 1100 1101 ibmphp_pci_bus->number = busno; 1102 1103 debug ("the bus_no behind the bridge is %x\n", busno); 1104 debug ("scanning devices behind the bridge...\n"); 1105 for (device = 0; device < 32; device++) { 1106 amount->devices[device] = 0; 1107 for (function = 0; function < 8; function++) { 1108 devfn = PCI_DEVFN(device, function); 1109 1110 pci_bus_read_config_word (ibmphp_pci_bus, devfn, PCI_VENDOR_ID, &vendor_id); 1111 1112 if (vendor_id != PCI_VENDOR_ID_NOTVALID) { 1113 /* found correct device!!! */ 1114 howmany++; 1115 1116 pci_bus_read_config_byte (ibmphp_pci_bus, devfn, PCI_HEADER_TYPE, &hdr_type); 1117 pci_bus_read_config_dword (ibmphp_pci_bus, devfn, PCI_CLASS_REVISION, &class); 1118 1119 debug ("hdr_type behind the bridge is %x\n", hdr_type); 1120 if (hdr_type & PCI_HEADER_TYPE_BRIDGE) { 1121 err ("embedded bridges not supported for hot-plugging.\n"); 1122 amount->not_correct = 1; 1123 return amount; 1124 } 1125 1126 class >>= 8; /* to take revision out, class = class.subclass.prog i/f */ 1127 if (class == PCI_CLASS_NOT_DEFINED_VGA) { 1128 err ("The device %x is VGA compatible and as is not supported for hot plugging. " 1129 "Please choose another device.\n", device); 1130 amount->not_correct = 1; 1131 return amount; 1132 } else if (class == PCI_CLASS_DISPLAY_VGA) { 1133 err ("The device %x is not supported for hot plugging. " 1134 "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. " 1487 "Please choose another device.\n", device, function); 1488 return -ENODEV; 1489 } else if (class == PCI_CLASS_DISPLAY_VGA) { 1490 err ("The device %x function %x is not supported for hot removing. " 1491 "Please choose another device.\n", device, function); 1492 return -ENODEV; 1493 } 1494 1495 switch (hdr_type) { 1496 case PCI_HEADER_TYPE_NORMAL: 1497 rc = unconfigure_boot_device (busno, device, function); 1498 if (rc) { 1499 err ("was not able to unconfigure device %x func %x on bus %x. bailing out...\n", 1500 device, function, busno); 1501 return rc; 1502 } 1503 function = 0x8; 1504 break; 1505 case PCI_HEADER_TYPE_MULTIDEVICE: 1506 rc = unconfigure_boot_device (busno, device, function); 1507 if (rc) { 1508 err ("was not able to unconfigure device %x func %x on bus %x. bailing out...\n", 1509 device, function, busno); 1510 return rc; 1511 } 1512 break; 1513 case PCI_HEADER_TYPE_BRIDGE: 1514 class >>= 8; 1515 if (class != PCI_CLASS_BRIDGE_PCI) { 1516 err ("This device %x function %x is not PCI-to-PCI bridge, " 1517 "and is not supported for hot-removing. " 1518 "Please try another card.\n", device, function); 1519 return -ENODEV; 1520 } 1521 rc = unconfigure_boot_bridge (busno, device, function); 1522 if (rc != 0) { 1523 err ("was not able to hot-remove PPB properly.\n"); 1524 return rc; 1525 } 1526 1527 function = 0x8; 1528 break; 1529 case PCI_HEADER_TYPE_MULTIBRIDGE: 1530 class >>= 8; 1531 if (class != PCI_CLASS_BRIDGE_PCI) { 1532 err ("This device %x function %x is not PCI-to-PCI bridge, " 1533 "and is not supported for hot-removing. " 1534 "Please try another card.\n", device, function); 1535 return -ENODEV; 1536 } 1537 rc = unconfigure_boot_bridge (busno, device, function); 1538 if (rc != 0) { 1539 err ("was not able to hot-remove PPB properly.\n"); 1540 return rc; 1541 } 1542 break; 1543 default: 1544 err ("MAJOR PROBLEM!!!! Cannot read device's header\n"); 1545 return -1; 1546 break; 1547 } /* end of switch */ 1548 } /* end of valid device */ 1549 } /* end of for */ 1550 1551 if (!valid_device) { 1552 err ("Could not find device to unconfigure. Or could not read the card.\n"); 1553 return -1; 1554 } 1555 return 0; 1556} 1557 1558/* 1559 * free the resources of the card (multi, single, or bridged) 1560 * Parameters: slot, flag to say if this is for removing entire module or just 1561 * unconfiguring the device 1562 * TO DO: will probably need to add some code in case there was some resource, 1563 * to remove it... this is from when we have errors in the configure_card... 1564 * !!!!!!!!!!!!!!!!!!!!!!!!!FOR BUSES!!!!!!!!!!!! 1565 * Returns: 0, -1, -ENODEV 1566 */ 1567int ibmphp_unconfigure_card (struct slot **slot_cur, int the_end) 1568{ 1569 int i; 1570 int count; 1571 int rc; 1572 struct slot *sl = *slot_cur; 1573 struct pci_func *cur_func = NULL; 1574 struct pci_func *temp_func; 1575 1576 debug ("%s - enter\n", __func__); 1577 1578 if (!the_end) { 1579 /* Need to unconfigure the card */ 1580 rc = unconfigure_boot_card (sl); 1581 if ((rc == -ENODEV) || (rc == -EIO) || (rc == -EINVAL)) { 1582 /* In all other cases, will still need to get rid of func structure if it exists */ 1583 return rc; 1584 } 1585 } 1586 1587 if (sl->func) { 1588 cur_func = sl->func; 1589 while (cur_func) { 1590 /* TO DO: WILL MOST LIKELY NEED TO GET RID OF THE BUS STRUCTURE FROM RESOURCES AS WELL */ 1591 if (cur_func->bus) { 1592 /* in other words, it's a PPB */ 1593 count = 2; 1594 } else { 1595 count = 6; 1596 } 1597 1598 for (i = 0; i < count; i++) { 1599 if (cur_func->io[i]) { 1600 debug ("io[%d] exists\n", i); 1601 if (the_end > 0) 1602 ibmphp_remove_resource (cur_func->io[i]); 1603 cur_func->io[i] = NULL; 1604 } 1605 if (cur_func->mem[i]) { 1606 debug ("mem[%d] exists\n", i); 1607 if (the_end > 0) 1608 ibmphp_remove_resource (cur_func->mem[i]); 1609 cur_func->mem[i] = NULL; 1610 } 1611 if (cur_func->pfmem[i]) { 1612 debug ("pfmem[%d] exists\n", i); 1613 if (the_end > 0) 1614 ibmphp_remove_resource (cur_func->pfmem[i]); 1615 cur_func->pfmem[i] = NULL; 1616 } 1617 } 1618 1619 temp_func = cur_func->next; 1620 kfree (cur_func); 1621 cur_func = temp_func; 1622 } 1623 } 1624 1625 sl->func = NULL; 1626 *slot_cur = sl; 1627 debug ("%s - exit\n", __func__); 1628 return 0; 1629} 1630 1631/* 1632 * add a new bus resulting from hot-plugging a PPB bridge with devices 1633 * 1634 * Input: bus and the amount of resources needed (we know we can assign those, 1635 * since they've been checked already 1636 * Output: bus added to the correct spot 1637 * 0, -1, error 1638 */ 1639static int add_new_bus (struct bus_node *bus, struct resource_node *io, struct resource_node *mem, struct resource_node *pfmem, u8 parent_busno) 1640{ 1641 struct range_node *io_range = NULL; 1642 struct range_node *mem_range = NULL; 1643 struct range_node *pfmem_range = NULL; 1644 struct bus_node *cur_bus = NULL; 1645 1646 /* Trying to find the parent bus number */ 1647 if (parent_busno != 0xFF) { 1648 cur_bus = ibmphp_find_res_bus (parent_busno); 1649 if (!cur_bus) { 1650 err ("strange, cannot find bus which is supposed to be at the system... something is terribly wrong...\n"); 1651 return -ENODEV; 1652 } 1653 1654 list_add (&bus->bus_list, &cur_bus->bus_list); 1655 } 1656 if (io) { 1657 io_range = kzalloc(sizeof(*io_range), GFP_KERNEL); 1658 if (!io_range) { 1659 err ("out of system memory\n"); 1660 return -ENOMEM; 1661 } 1662 io_range->start = io->start; 1663 io_range->end = io->end; 1664 io_range->rangeno = 1; 1665 bus->noIORanges = 1; 1666 bus->rangeIO = io_range; 1667 } 1668 if (mem) { 1669 mem_range = kzalloc(sizeof(*mem_range), GFP_KERNEL); 1670 if (!mem_range) { 1671 err ("out of system memory\n"); 1672 return -ENOMEM; 1673 } 1674 mem_range->start = mem->start; 1675 mem_range->end = mem->end; 1676 mem_range->rangeno = 1; 1677 bus->noMemRanges = 1; 1678 bus->rangeMem = mem_range; 1679 } 1680 if (pfmem) { 1681 pfmem_range = kzalloc(sizeof(*pfmem_range), GFP_KERNEL); 1682 if (!pfmem_range) { 1683 err ("out of system memory\n"); 1684 return -ENOMEM; 1685 } 1686 pfmem_range->start = pfmem->start; 1687 pfmem_range->end = pfmem->end; 1688 pfmem_range->rangeno = 1; 1689 bus->noPFMemRanges = 1; 1690 bus->rangePFMem = pfmem_range; 1691 } 1692 return 0; 1693} 1694 1695/* 1696 * find the 1st available bus number for PPB to set as its secondary bus 1697 * Parameters: bus_number of the primary bus 1698 * Returns: bus_number of the secondary bus or 0xff in case of failure 1699 */ 1700static u8 find_sec_number (u8 primary_busno, u8 slotno) 1701{ 1702 int min, max; 1703 u8 busno; 1704 struct bus_info *bus; 1705 struct bus_node *bus_cur; 1706 1707 bus = ibmphp_find_same_bus_num (primary_busno); 1708 if (!bus) { 1709 err ("cannot get slot range of the bus from the BIOS\n"); 1710 return 0xff; 1711 } 1712 max = bus->slot_max; 1713 min = bus->slot_min; 1714 if ((slotno > max) || (slotno < min)) { 1715 err ("got the wrong range\n"); 1716 return 0xff; 1717 } 1718 busno = (u8) (slotno - (u8) min); 1719 busno += primary_busno + 0x01; 1720 bus_cur = ibmphp_find_res_bus (busno); 1721 /* either there is no such bus number, or there are no ranges, which 1722 * can only happen if we removed the bridged device in previous load 1723 * of the driver, and now only have the skeleton bus struct 1724 */ 1725 if ((!bus_cur) || (!(bus_cur->rangeIO) && !(bus_cur->rangeMem) && !(bus_cur->rangePFMem))) 1726 return busno; 1727 return 0xff; 1728} 1729 1730