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