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