1 /* 2 * Standard Hot Plug Controller Driver 3 * 4 * Copyright (C) 1995,2001 Compaq Computer Corporation 5 * Copyright (C) 2001 Greg Kroah-Hartman (greg@kroah.com) 6 * Copyright (C) 2001 IBM Corp. 7 * Copyright (C) 2003-2004 Intel Corporation 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 <greg@kroah.com>, <dely.l.sy@intel.com> 27 * 28 */ 29 30 #include <linux/config.h> 31 #include <linux/module.h> 32 #include <linux/kernel.h> 33 #include <linux/types.h> 34 #include <linux/slab.h> 35 #include <linux/workqueue.h> 36 #include <linux/interrupt.h> 37 #include <linux/delay.h> 38 #include <linux/wait.h> 39 #include <linux/smp_lock.h> 40 #include <linux/pci.h> 41 #include "shpchp.h" 42 #include "shpchprm.h" 43 44 static u32 configure_new_device(struct controller *ctrl, struct pci_func *func, 45 u8 behind_bridge, struct resource_lists *resources, u8 bridge_bus, u8 bridge_dev); 46 static int configure_new_function( struct controller *ctrl, struct pci_func *func, 47 u8 behind_bridge, struct resource_lists *resources, u8 bridge_bus, u8 bridge_dev); 48 static void interrupt_event_handler(struct controller *ctrl); 49 50 static struct semaphore event_semaphore; /* mutex for process loop (up if something to process) */ 51 static struct semaphore event_exit; /* guard ensure thread has exited before calling it quits */ 52 static int event_finished; 53 static unsigned long pushbutton_pending; /* = 0 */ 54 55 u8 shpchp_disk_irq; 56 u8 shpchp_nic_irq; 57 58 u8 shpchp_handle_attention_button(u8 hp_slot, void *inst_id) 59 { 60 struct controller *ctrl = (struct controller *) inst_id; 61 struct slot *p_slot; 62 u8 rc = 0; 63 u8 getstatus; 64 struct pci_func *func; 65 struct event_info *taskInfo; 66 67 /* Attention Button Change */ 68 dbg("shpchp: Attention button interrupt received.\n"); 69 70 func = shpchp_slot_find(ctrl->slot_bus, (hp_slot + ctrl->slot_device_offset), 0); 71 72 /* This is the structure that tells the worker thread what to do */ 73 taskInfo = &(ctrl->event_queue[ctrl->next_event]); 74 p_slot = shpchp_find_slot(ctrl, hp_slot + ctrl->slot_device_offset); 75 76 p_slot->hpc_ops->get_adapter_status(p_slot, &(func->presence_save)); 77 p_slot->hpc_ops->get_latch_status(p_slot, &getstatus); 78 79 ctrl->next_event = (ctrl->next_event + 1) % 10; 80 taskInfo->hp_slot = hp_slot; 81 82 rc++; 83 84 /* 85 * Button pressed - See if need to TAKE ACTION!!! 86 */ 87 info("Button pressed on Slot(%d)\n", ctrl->first_slot + hp_slot); 88 taskInfo->event_type = INT_BUTTON_PRESS; 89 90 if ((p_slot->state == BLINKINGON_STATE) 91 || (p_slot->state == BLINKINGOFF_STATE)) { 92 /* Cancel if we are still blinking; this means that we press the 93 * attention again before the 5 sec. limit expires to cancel hot-add 94 * or hot-remove 95 */ 96 taskInfo->event_type = INT_BUTTON_CANCEL; 97 info("Button cancel on Slot(%d)\n", ctrl->first_slot + hp_slot); 98 } else if ((p_slot->state == POWERON_STATE) 99 || (p_slot->state == POWEROFF_STATE)) { 100 /* Ignore if the slot is on power-on or power-off state; this 101 * means that the previous attention button action to hot-add or 102 * hot-remove is undergoing 103 */ 104 taskInfo->event_type = INT_BUTTON_IGNORE; 105 info("Button ignore on Slot(%d)\n", ctrl->first_slot + hp_slot); 106 } 107 108 if (rc) 109 up(&event_semaphore); /* signal event thread that new event is posted */ 110 111 return 0; 112 113 } 114 115 u8 shpchp_handle_switch_change(u8 hp_slot, void *inst_id) 116 { 117 struct controller *ctrl = (struct controller *) inst_id; 118 struct slot *p_slot; 119 u8 rc = 0; 120 u8 getstatus; 121 struct pci_func *func; 122 struct event_info *taskInfo; 123 124 /* Switch Change */ 125 dbg("shpchp: Switch interrupt received.\n"); 126 127 func = shpchp_slot_find(ctrl->slot_bus, (hp_slot + ctrl->slot_device_offset), 0); 128 129 /* This is the structure that tells the worker thread 130 * what to do 131 */ 132 taskInfo = &(ctrl->event_queue[ctrl->next_event]); 133 ctrl->next_event = (ctrl->next_event + 1) % 10; 134 taskInfo->hp_slot = hp_slot; 135 136 rc++; 137 p_slot = shpchp_find_slot(ctrl, hp_slot + ctrl->slot_device_offset); 138 p_slot->hpc_ops->get_adapter_status(p_slot, &(func->presence_save)); 139 p_slot->hpc_ops->get_latch_status(p_slot, &getstatus); 140 dbg("%s: Card present %x Power status %x\n", __FUNCTION__, 141 func->presence_save, func->pwr_save); 142 143 if (getstatus) { 144 /* 145 * Switch opened 146 */ 147 info("Latch open on Slot(%d)\n", ctrl->first_slot + hp_slot); 148 func->switch_save = 0; 149 taskInfo->event_type = INT_SWITCH_OPEN; 150 if (func->pwr_save && func->presence_save) { 151 taskInfo->event_type = INT_POWER_FAULT; 152 err("Surprise Removal of card\n"); 153 } 154 } else { 155 /* 156 * Switch closed 157 */ 158 info("Latch close on Slot(%d)\n", ctrl->first_slot + hp_slot); 159 func->switch_save = 0x10; 160 taskInfo->event_type = INT_SWITCH_CLOSE; 161 } 162 163 if (rc) 164 up(&event_semaphore); /* signal event thread that new event is posted */ 165 166 return rc; 167 } 168 169 u8 shpchp_handle_presence_change(u8 hp_slot, void *inst_id) 170 { 171 struct controller *ctrl = (struct controller *) inst_id; 172 struct slot *p_slot; 173 u8 rc = 0; 174 /*u8 temp_byte;*/ 175 struct pci_func *func; 176 struct event_info *taskInfo; 177 178 /* Presence Change */ 179 dbg("shpchp: Presence/Notify input change.\n"); 180 181 func = shpchp_slot_find(ctrl->slot_bus, (hp_slot + ctrl->slot_device_offset), 0); 182 183 /* This is the structure that tells the worker thread 184 * what to do 185 */ 186 taskInfo = &(ctrl->event_queue[ctrl->next_event]); 187 ctrl->next_event = (ctrl->next_event + 1) % 10; 188 taskInfo->hp_slot = hp_slot; 189 190 rc++; 191 p_slot = shpchp_find_slot(ctrl, hp_slot + ctrl->slot_device_offset); 192 193 /* 194 * Save the presence state 195 */ 196 p_slot->hpc_ops->get_adapter_status(p_slot, &(func->presence_save)); 197 if (func->presence_save) { 198 /* 199 * Card Present 200 */ 201 info("Card present on Slot(%d)\n", ctrl->first_slot + hp_slot); 202 taskInfo->event_type = INT_PRESENCE_ON; 203 } else { 204 /* 205 * Not Present 206 */ 207 info("Card not present on Slot(%d)\n", ctrl->first_slot + hp_slot); 208 taskInfo->event_type = INT_PRESENCE_OFF; 209 } 210 211 if (rc) 212 up(&event_semaphore); /* signal event thread that new event is posted */ 213 214 return rc; 215 } 216 217 u8 shpchp_handle_power_fault(u8 hp_slot, void *inst_id) 218 { 219 struct controller *ctrl = (struct controller *) inst_id; 220 struct slot *p_slot; 221 u8 rc = 0; 222 struct pci_func *func; 223 struct event_info *taskInfo; 224 225 /* Power fault */ 226 dbg("shpchp: Power fault interrupt received.\n"); 227 228 func = shpchp_slot_find(ctrl->slot_bus, (hp_slot + ctrl->slot_device_offset), 0); 229 230 /* This is the structure that tells the worker thread 231 * what to do 232 */ 233 taskInfo = &(ctrl->event_queue[ctrl->next_event]); 234 ctrl->next_event = (ctrl->next_event + 1) % 10; 235 taskInfo->hp_slot = hp_slot; 236 237 rc++; 238 p_slot = shpchp_find_slot(ctrl, hp_slot + ctrl->slot_device_offset); 239 240 if ( !(p_slot->hpc_ops->query_power_fault(p_slot))) { 241 /* 242 * Power fault Cleared 243 */ 244 info("Power fault cleared on Slot(%d)\n", ctrl->first_slot + hp_slot); 245 func->status = 0x00; 246 taskInfo->event_type = INT_POWER_FAULT_CLEAR; 247 } else { 248 /* 249 * Power fault 250 */ 251 info("Power fault on Slot(%d)\n", ctrl->first_slot + hp_slot); 252 taskInfo->event_type = INT_POWER_FAULT; 253 /* set power fault status for this board */ 254 func->status = 0xFF; 255 info("power fault bit %x set\n", hp_slot); 256 } 257 if (rc) 258 up(&event_semaphore); /* signal event thread that new event is posted */ 259 260 return rc; 261 } 262 263 264 /* 265 * sort_by_size 266 * 267 * Sorts nodes on the list by their length. 268 * Smallest first. 269 * 270 */ 271 static int sort_by_size(struct pci_resource **head) 272 { 273 struct pci_resource *current_res; 274 struct pci_resource *next_res; 275 int out_of_order = 1; 276 277 if (!(*head)) 278 return(1); 279 280 if (!((*head)->next)) 281 return(0); 282 283 while (out_of_order) { 284 out_of_order = 0; 285 286 /* Special case for swapping list head */ 287 if (((*head)->next) && 288 ((*head)->length > (*head)->next->length)) { 289 out_of_order++; 290 current_res = *head; 291 *head = (*head)->next; 292 current_res->next = (*head)->next; 293 (*head)->next = current_res; 294 } 295 296 current_res = *head; 297 298 while (current_res->next && current_res->next->next) { 299 if (current_res->next->length > current_res->next->next->length) { 300 out_of_order++; 301 next_res = current_res->next; 302 current_res->next = current_res->next->next; 303 current_res = current_res->next; 304 next_res->next = current_res->next; 305 current_res->next = next_res; 306 } else 307 current_res = current_res->next; 308 } 309 } /* End of out_of_order loop */ 310 311 return(0); 312 } 313 314 315 /* 316 * sort_by_max_size 317 * 318 * Sorts nodes on the list by their length. 319 * Largest first. 320 * 321 */ 322 static int sort_by_max_size(struct pci_resource **head) 323 { 324 struct pci_resource *current_res; 325 struct pci_resource *next_res; 326 int out_of_order = 1; 327 328 if (!(*head)) 329 return(1); 330 331 if (!((*head)->next)) 332 return(0); 333 334 while (out_of_order) { 335 out_of_order = 0; 336 337 /* Special case for swapping list head */ 338 if (((*head)->next) && 339 ((*head)->length < (*head)->next->length)) { 340 out_of_order++; 341 current_res = *head; 342 *head = (*head)->next; 343 current_res->next = (*head)->next; 344 (*head)->next = current_res; 345 } 346 347 current_res = *head; 348 349 while (current_res->next && current_res->next->next) { 350 if (current_res->next->length < current_res->next->next->length) { 351 out_of_order++; 352 next_res = current_res->next; 353 current_res->next = current_res->next->next; 354 current_res = current_res->next; 355 next_res->next = current_res->next; 356 current_res->next = next_res; 357 } else 358 current_res = current_res->next; 359 } 360 } /* End of out_of_order loop */ 361 362 return(0); 363 } 364 365 366 /* 367 * do_pre_bridge_resource_split 368 * 369 * Returns zero or one node of resources that aren't in use 370 * 371 */ 372 static struct pci_resource *do_pre_bridge_resource_split (struct pci_resource **head, struct pci_resource **orig_head, u32 alignment) 373 { 374 struct pci_resource *prevnode = NULL; 375 struct pci_resource *node; 376 struct pci_resource *split_node; 377 u32 rc; 378 u32 temp_dword; 379 dbg("do_pre_bridge_resource_split\n"); 380 381 if (!(*head) || !(*orig_head)) 382 return(NULL); 383 384 rc = shpchp_resource_sort_and_combine(head); 385 386 if (rc) 387 return(NULL); 388 389 if ((*head)->base != (*orig_head)->base) 390 return(NULL); 391 392 if ((*head)->length == (*orig_head)->length) 393 return(NULL); 394 395 396 /* If we got here, there the bridge requires some of the resource, but 397 * we may be able to split some off of the front 398 */ 399 node = *head; 400 401 if (node->length & (alignment -1)) { 402 /* This one isn't an aligned length, so we'll make a new entry 403 * and split it up. 404 */ 405 split_node = kmalloc(sizeof(*split_node), GFP_KERNEL); 406 407 if (!split_node) 408 return(NULL); 409 410 temp_dword = (node->length | (alignment-1)) + 1 - alignment; 411 412 split_node->base = node->base; 413 split_node->length = temp_dword; 414 415 node->length -= temp_dword; 416 node->base += split_node->length; 417 418 /* Put it in the list */ 419 *head = split_node; 420 split_node->next = node; 421 } 422 423 if (node->length < alignment) { 424 return(NULL); 425 } 426 427 /* Now unlink it */ 428 if (*head == node) { 429 *head = node->next; 430 node->next = NULL; 431 } else { 432 prevnode = *head; 433 while (prevnode->next != node) 434 prevnode = prevnode->next; 435 436 prevnode->next = node->next; 437 node->next = NULL; 438 } 439 440 return(node); 441 } 442 443 444 /* 445 * do_bridge_resource_split 446 * 447 * Returns zero or one node of resources that aren't in use 448 * 449 */ 450 static struct pci_resource *do_bridge_resource_split (struct pci_resource **head, u32 alignment) 451 { 452 struct pci_resource *prevnode = NULL; 453 struct pci_resource *node; 454 u32 rc; 455 u32 temp_dword; 456 457 if (!(*head)) 458 return(NULL); 459 460 rc = shpchp_resource_sort_and_combine(head); 461 462 if (rc) 463 return(NULL); 464 465 node = *head; 466 467 while (node->next) { 468 prevnode = node; 469 node = node->next; 470 kfree(prevnode); 471 } 472 473 if (node->length < alignment) { 474 kfree(node); 475 return(NULL); 476 } 477 478 if (node->base & (alignment - 1)) { 479 /* Short circuit if adjusted size is too small */ 480 temp_dword = (node->base | (alignment-1)) + 1; 481 if ((node->length - (temp_dword - node->base)) < alignment) { 482 kfree(node); 483 return(NULL); 484 } 485 486 node->length -= (temp_dword - node->base); 487 node->base = temp_dword; 488 } 489 490 if (node->length & (alignment - 1)) { 491 /* There's stuff in use after this node */ 492 kfree(node); 493 return(NULL); 494 } 495 496 return(node); 497 } 498 499 500 /* 501 * get_io_resource 502 * 503 * this function sorts the resource list by size and then 504 * returns the first node of "size" length that is not in the 505 * ISA aliasing window. If it finds a node larger than "size" 506 * it will split it up. 507 * 508 * size must be a power of two. 509 */ 510 static struct pci_resource *get_io_resource (struct pci_resource **head, u32 size) 511 { 512 struct pci_resource *prevnode; 513 struct pci_resource *node; 514 struct pci_resource *split_node = NULL; 515 u32 temp_dword; 516 517 if (!(*head)) 518 return(NULL); 519 520 if ( shpchp_resource_sort_and_combine(head) ) 521 return(NULL); 522 523 if ( sort_by_size(head) ) 524 return(NULL); 525 526 for (node = *head; node; node = node->next) { 527 if (node->length < size) 528 continue; 529 530 if (node->base & (size - 1)) { 531 /* This one isn't base aligned properly 532 so we'll make a new entry and split it up */ 533 temp_dword = (node->base | (size-1)) + 1; 534 535 /*/ Short circuit if adjusted size is too small */ 536 if ((node->length - (temp_dword - node->base)) < size) 537 continue; 538 539 split_node = kmalloc(sizeof(*split_node), GFP_KERNEL); 540 541 if (!split_node) 542 return(NULL); 543 544 split_node->base = node->base; 545 split_node->length = temp_dword - node->base; 546 node->base = temp_dword; 547 node->length -= split_node->length; 548 549 /* Put it in the list */ 550 split_node->next = node->next; 551 node->next = split_node; 552 } /* End of non-aligned base */ 553 554 /* Don't need to check if too small since we already did */ 555 if (node->length > size) { 556 /* This one is longer than we need 557 so we'll make a new entry and split it up */ 558 split_node = kmalloc(sizeof(*split_node), GFP_KERNEL); 559 560 if (!split_node) 561 return(NULL); 562 563 split_node->base = node->base + size; 564 split_node->length = node->length - size; 565 node->length = size; 566 567 /* Put it in the list */ 568 split_node->next = node->next; 569 node->next = split_node; 570 } /* End of too big on top end */ 571 572 /* For IO make sure it's not in the ISA aliasing space */ 573 if (node->base & 0x300L) 574 continue; 575 576 /* If we got here, then it is the right size 577 Now take it out of the list */ 578 if (*head == node) { 579 *head = node->next; 580 } else { 581 prevnode = *head; 582 while (prevnode->next != node) 583 prevnode = prevnode->next; 584 585 prevnode->next = node->next; 586 } 587 node->next = NULL; 588 /* Stop looping */ 589 break; 590 } 591 592 return(node); 593 } 594 595 596 /* 597 * get_max_resource 598 * 599 * Gets the largest node that is at least "size" big from the 600 * list pointed to by head. It aligns the node on top and bottom 601 * to "size" alignment before returning it. 602 * J.I. modified to put max size limits of; 64M->32M->16M->8M->4M->1M 603 * This is needed to avoid allocating entire ACPI _CRS res to one child bridge/slot. 604 */ 605 static struct pci_resource *get_max_resource (struct pci_resource **head, u32 size) 606 { 607 struct pci_resource *max; 608 struct pci_resource *temp; 609 struct pci_resource *split_node; 610 u32 temp_dword; 611 u32 max_size[] = { 0x4000000, 0x2000000, 0x1000000, 0x0800000, 0x0400000, 0x0200000, 0x0100000, 0x00 }; 612 int i; 613 614 if (!(*head)) 615 return(NULL); 616 617 if (shpchp_resource_sort_and_combine(head)) 618 return(NULL); 619 620 if (sort_by_max_size(head)) 621 return(NULL); 622 623 for (max = *head;max; max = max->next) { 624 625 /* If not big enough we could probably just bail, 626 instead we'll continue to the next. */ 627 if (max->length < size) 628 continue; 629 630 if (max->base & (size - 1)) { 631 /* This one isn't base aligned properly 632 so we'll make a new entry and split it up */ 633 temp_dword = (max->base | (size-1)) + 1; 634 635 /* Short circuit if adjusted size is too small */ 636 if ((max->length - (temp_dword - max->base)) < size) 637 continue; 638 639 split_node = kmalloc(sizeof(*split_node), GFP_KERNEL); 640 641 if (!split_node) 642 return(NULL); 643 644 split_node->base = max->base; 645 split_node->length = temp_dword - max->base; 646 max->base = temp_dword; 647 max->length -= split_node->length; 648 649 /* Put it next in the list */ 650 split_node->next = max->next; 651 max->next = split_node; 652 } 653 654 if ((max->base + max->length) & (size - 1)) { 655 /* This one isn't end aligned properly at the top 656 so we'll make a new entry and split it up */ 657 split_node = kmalloc(sizeof(*split_node), GFP_KERNEL); 658 659 if (!split_node) 660 return(NULL); 661 temp_dword = ((max->base + max->length) & ~(size - 1)); 662 split_node->base = temp_dword; 663 split_node->length = max->length + max->base 664 - split_node->base; 665 max->length -= split_node->length; 666 667 /* Put it in the list */ 668 split_node->next = max->next; 669 max->next = split_node; 670 } 671 672 /* Make sure it didn't shrink too much when we aligned it */ 673 if (max->length < size) 674 continue; 675 676 for ( i = 0; max_size[i] > size; i++) { 677 if (max->length > max_size[i]) { 678 split_node = kmalloc(sizeof(*split_node), 679 GFP_KERNEL); 680 if (!split_node) 681 break; /* return (NULL); */ 682 split_node->base = max->base + max_size[i]; 683 split_node->length = max->length - max_size[i]; 684 max->length = max_size[i]; 685 /* Put it next in the list */ 686 split_node->next = max->next; 687 max->next = split_node; 688 break; 689 } 690 } 691 692 /* Now take it out of the list */ 693 temp = (struct pci_resource*) *head; 694 if (temp == max) { 695 *head = max->next; 696 } else { 697 while (temp && temp->next != max) { 698 temp = temp->next; 699 } 700 701 temp->next = max->next; 702 } 703 704 max->next = NULL; 705 return(max); 706 } 707 708 /* If we get here, we couldn't find one */ 709 return(NULL); 710 } 711 712 713 /* 714 * get_resource 715 * 716 * this function sorts the resource list by size and then 717 * returns the first node of "size" length. If it finds a node 718 * larger than "size" it will split it up. 719 * 720 * size must be a power of two. 721 */ 722 static struct pci_resource *get_resource (struct pci_resource **head, u32 size) 723 { 724 struct pci_resource *prevnode; 725 struct pci_resource *node; 726 struct pci_resource *split_node; 727 u32 temp_dword; 728 729 if (!(*head)) 730 return(NULL); 731 732 if ( shpchp_resource_sort_and_combine(head) ) 733 return(NULL); 734 735 if ( sort_by_size(head) ) 736 return(NULL); 737 738 for (node = *head; node; node = node->next) { 739 dbg("%s: req_size =0x%x node=%p, base=0x%x, length=0x%x\n", 740 __FUNCTION__, size, node, node->base, node->length); 741 if (node->length < size) 742 continue; 743 744 if (node->base & (size - 1)) { 745 dbg("%s: not aligned\n", __FUNCTION__); 746 /* this one isn't base aligned properly 747 so we'll make a new entry and split it up */ 748 temp_dword = (node->base | (size-1)) + 1; 749 750 /* Short circuit if adjusted size is too small */ 751 if ((node->length - (temp_dword - node->base)) < size) 752 continue; 753 754 split_node = kmalloc(sizeof(*split_node), GFP_KERNEL); 755 756 if (!split_node) 757 return(NULL); 758 759 split_node->base = node->base; 760 split_node->length = temp_dword - node->base; 761 node->base = temp_dword; 762 node->length -= split_node->length; 763 764 /* Put it in the list */ 765 split_node->next = node->next; 766 node->next = split_node; 767 } /* End of non-aligned base */ 768 769 /* Don't need to check if too small since we already did */ 770 if (node->length > size) { 771 dbg("%s: too big\n", __FUNCTION__); 772 /* this one is longer than we need 773 so we'll make a new entry and split it up */ 774 split_node = kmalloc(sizeof(*split_node), GFP_KERNEL); 775 776 if (!split_node) 777 return(NULL); 778 779 split_node->base = node->base + size; 780 split_node->length = node->length - size; 781 node->length = size; 782 783 /* Put it in the list */ 784 split_node->next = node->next; 785 node->next = split_node; 786 } /* End of too big on top end */ 787 788 dbg("%s: got one!!!\n", __FUNCTION__); 789 /* If we got here, then it is the right size 790 Now take it out of the list */ 791 if (*head == node) { 792 *head = node->next; 793 } else { 794 prevnode = *head; 795 while (prevnode->next != node) 796 prevnode = prevnode->next; 797 798 prevnode->next = node->next; 799 } 800 node->next = NULL; 801 /* Stop looping */ 802 break; 803 } 804 return(node); 805 } 806 807 808 /* 809 * shpchp_resource_sort_and_combine 810 * 811 * Sorts all of the nodes in the list in ascending order by 812 * their base addresses. Also does garbage collection by 813 * combining adjacent nodes. 814 * 815 * returns 0 if success 816 */ 817 int shpchp_resource_sort_and_combine(struct pci_resource **head) 818 { 819 struct pci_resource *node1; 820 struct pci_resource *node2; 821 int out_of_order = 1; 822 823 dbg("%s: head = %p, *head = %p\n", __FUNCTION__, head, *head); 824 825 if (!(*head)) 826 return(1); 827 828 dbg("*head->next = %p\n",(*head)->next); 829 830 if (!(*head)->next) 831 return(0); /* only one item on the list, already sorted! */ 832 833 dbg("*head->base = 0x%x\n",(*head)->base); 834 dbg("*head->next->base = 0x%x\n",(*head)->next->base); 835 while (out_of_order) { 836 out_of_order = 0; 837 838 /* Special case for swapping list head */ 839 if (((*head)->next) && 840 ((*head)->base > (*head)->next->base)) { 841 node1 = *head; 842 (*head) = (*head)->next; 843 node1->next = (*head)->next; 844 (*head)->next = node1; 845 out_of_order++; 846 } 847 848 node1 = (*head); 849 850 while (node1->next && node1->next->next) { 851 if (node1->next->base > node1->next->next->base) { 852 out_of_order++; 853 node2 = node1->next; 854 node1->next = node1->next->next; 855 node1 = node1->next; 856 node2->next = node1->next; 857 node1->next = node2; 858 } else 859 node1 = node1->next; 860 } 861 } /* End of out_of_order loop */ 862 863 node1 = *head; 864 865 while (node1 && node1->next) { 866 if ((node1->base + node1->length) == node1->next->base) { 867 /* Combine */ 868 dbg("8..\n"); 869 node1->length += node1->next->length; 870 node2 = node1->next; 871 node1->next = node1->next->next; 872 kfree(node2); 873 } else 874 node1 = node1->next; 875 } 876 877 return(0); 878 } 879 880 881 /** 882 * shpchp_slot_create - Creates a node and adds it to the proper bus. 883 * @busnumber - bus where new node is to be located 884 * 885 * Returns pointer to the new node or NULL if unsuccessful 886 */ 887 struct pci_func *shpchp_slot_create(u8 busnumber) 888 { 889 struct pci_func *new_slot; 890 struct pci_func *next; 891 892 new_slot = kmalloc(sizeof(*new_slot), GFP_KERNEL); 893 894 if (new_slot == NULL) { 895 return(new_slot); 896 } 897 898 memset(new_slot, 0, sizeof(struct pci_func)); 899 900 new_slot->next = NULL; 901 new_slot->configured = 1; 902 903 if (shpchp_slot_list[busnumber] == NULL) { 904 shpchp_slot_list[busnumber] = new_slot; 905 } else { 906 next = shpchp_slot_list[busnumber]; 907 while (next->next != NULL) 908 next = next->next; 909 next->next = new_slot; 910 } 911 return(new_slot); 912 } 913 914 915 /* 916 * slot_remove - Removes a node from the linked list of slots. 917 * @old_slot: slot to remove 918 * 919 * Returns 0 if successful, !0 otherwise. 920 */ 921 static int slot_remove(struct pci_func * old_slot) 922 { 923 struct pci_func *next; 924 925 if (old_slot == NULL) 926 return(1); 927 928 next = shpchp_slot_list[old_slot->bus]; 929 930 if (next == NULL) { 931 return(1); 932 } 933 934 if (next == old_slot) { 935 shpchp_slot_list[old_slot->bus] = old_slot->next; 936 shpchp_destroy_board_resources(old_slot); 937 kfree(old_slot); 938 return(0); 939 } 940 941 while ((next->next != old_slot) && (next->next != NULL)) { 942 next = next->next; 943 } 944 945 if (next->next == old_slot) { 946 next->next = old_slot->next; 947 shpchp_destroy_board_resources(old_slot); 948 kfree(old_slot); 949 return(0); 950 } else 951 return(2); 952 } 953 954 955 /** 956 * bridge_slot_remove - Removes a node from the linked list of slots. 957 * @bridge: bridge to remove 958 * 959 * Returns 0 if successful, !0 otherwise. 960 */ 961 static int bridge_slot_remove(struct pci_func *bridge) 962 { 963 u8 subordinateBus, secondaryBus; 964 u8 tempBus; 965 struct pci_func *next; 966 967 if (bridge == NULL) 968 return(1); 969 970 secondaryBus = (bridge->config_space[0x06] >> 8) & 0xFF; 971 subordinateBus = (bridge->config_space[0x06] >> 16) & 0xFF; 972 973 for (tempBus = secondaryBus; tempBus <= subordinateBus; tempBus++) { 974 next = shpchp_slot_list[tempBus]; 975 976 while (!slot_remove(next)) { 977 next = shpchp_slot_list[tempBus]; 978 } 979 } 980 981 next = shpchp_slot_list[bridge->bus]; 982 983 if (next == NULL) { 984 return(1); 985 } 986 987 if (next == bridge) { 988 shpchp_slot_list[bridge->bus] = bridge->next; 989 kfree(bridge); 990 return(0); 991 } 992 993 while ((next->next != bridge) && (next->next != NULL)) { 994 next = next->next; 995 } 996 997 if (next->next == bridge) { 998 next->next = bridge->next; 999 kfree(bridge); 1000 return(0); 1001 } else 1002 return(2); 1003 } 1004 1005 1006 /** 1007 * shpchp_slot_find - Looks for a node by bus, and device, multiple functions accessed 1008 * @bus: bus to find 1009 * @device: device to find 1010 * @index: is 0 for first function found, 1 for the second... 1011 * 1012 * Returns pointer to the node if successful, %NULL otherwise. 1013 */ 1014 struct pci_func *shpchp_slot_find(u8 bus, u8 device, u8 index) 1015 { 1016 int found = -1; 1017 struct pci_func *func; 1018 1019 func = shpchp_slot_list[bus]; 1020 1021 if ((func == NULL) || ((func->device == device) && (index == 0))) 1022 return(func); 1023 1024 if (func->device == device) 1025 found++; 1026 1027 while (func->next != NULL) { 1028 func = func->next; 1029 1030 if (func->device == device) 1031 found++; 1032 1033 if (found == index) 1034 return(func); 1035 } 1036 1037 return(NULL); 1038 } 1039 1040 static int is_bridge(struct pci_func * func) 1041 { 1042 /* Check the header type */ 1043 if (((func->config_space[0x03] >> 16) & 0xFF) == 0x01) 1044 return 1; 1045 else 1046 return 0; 1047 } 1048 1049 1050 /* The following routines constitute the bulk of the 1051 hotplug controller logic 1052 */ 1053 static u32 change_bus_speed(struct controller *ctrl, struct slot *p_slot, enum pci_bus_speed speed) 1054 { 1055 u32 rc = 0; 1056 1057 dbg("%s: change to speed %d\n", __FUNCTION__, speed); 1058 down(&ctrl->crit_sect); 1059 if ((rc = p_slot->hpc_ops->set_bus_speed_mode(p_slot, speed))) { 1060 err("%s: Issue of set bus speed mode command failed\n", __FUNCTION__); 1061 up(&ctrl->crit_sect); 1062 return WRONG_BUS_FREQUENCY; 1063 } 1064 wait_for_ctrl_irq (ctrl); 1065 1066 if ((rc = p_slot->hpc_ops->check_cmd_status(ctrl))) { 1067 err("%s: Can't set bus speed/mode in the case of adapter & bus mismatch\n", 1068 __FUNCTION__); 1069 err("%s: Error code (%d)\n", __FUNCTION__, rc); 1070 up(&ctrl->crit_sect); 1071 return WRONG_BUS_FREQUENCY; 1072 } 1073 up(&ctrl->crit_sect); 1074 return rc; 1075 } 1076 1077 static u32 fix_bus_speed(struct controller *ctrl, struct slot *pslot, u8 flag, 1078 enum pci_bus_speed asp, enum pci_bus_speed bsp, enum pci_bus_speed msp) 1079 { 1080 u32 rc = 0; 1081 1082 if (flag != 0) { /* Other slots on the same bus are occupied */ 1083 if ( asp < bsp ) { 1084 err("%s: speed of bus %x and adapter %x mismatch\n", __FUNCTION__, bsp, asp); 1085 return WRONG_BUS_FREQUENCY; 1086 } 1087 } else { 1088 /* Other slots on the same bus are empty */ 1089 if (msp == bsp) { 1090 /* if adapter_speed >= bus_speed, do nothing */ 1091 if (asp < bsp) { 1092 /* 1093 * Try to lower bus speed to accommodate the adapter if other slots 1094 * on the same controller are empty 1095 */ 1096 if ((rc = change_bus_speed(ctrl, pslot, asp))) 1097 return rc; 1098 } 1099 } else { 1100 if (asp < msp) { 1101 if ((rc = change_bus_speed(ctrl, pslot, asp))) 1102 return rc; 1103 } else { 1104 if ((rc = change_bus_speed(ctrl, pslot, msp))) 1105 return rc; 1106 } 1107 } 1108 } 1109 return rc; 1110 } 1111 1112 /** 1113 * board_added - Called after a board has been added to the system. 1114 * 1115 * Turns power on for the board 1116 * Configures board 1117 * 1118 */ 1119 static u32 board_added(struct pci_func * func, struct controller * ctrl) 1120 { 1121 u8 hp_slot; 1122 u8 slots_not_empty = 0; 1123 int index; 1124 u32 temp_register = 0xFFFFFFFF; 1125 u32 retval, rc = 0; 1126 struct pci_func *new_func = NULL; 1127 struct slot *p_slot; 1128 struct resource_lists res_lists; 1129 enum pci_bus_speed adapter_speed, bus_speed, max_bus_speed; 1130 u8 pi, mode; 1131 1132 p_slot = shpchp_find_slot(ctrl, func->device); 1133 hp_slot = func->device - ctrl->slot_device_offset; 1134 1135 dbg("%s: func->device, slot_offset, hp_slot = %d, %d ,%d\n", __FUNCTION__, func->device, ctrl->slot_device_offset, hp_slot); 1136 1137 /* Wait for exclusive access to hardware */ 1138 down(&ctrl->crit_sect); 1139 1140 /* Power on slot without connecting to bus */ 1141 rc = p_slot->hpc_ops->power_on_slot(p_slot); 1142 if (rc) { 1143 err("%s: Failed to power on slot\n", __FUNCTION__); 1144 /* Done with exclusive hardware access */ 1145 up(&ctrl->crit_sect); 1146 return -1; 1147 } 1148 1149 /* Wait for the command to complete */ 1150 wait_for_ctrl_irq (ctrl); 1151 1152 rc = p_slot->hpc_ops->check_cmd_status(ctrl); 1153 if (rc) { 1154 err("%s: Failed to power on slot, error code(%d)\n", __FUNCTION__, rc); 1155 /* Done with exclusive hardware access */ 1156 up(&ctrl->crit_sect); 1157 return -1; 1158 } 1159 1160 1161 if ((ctrl->pci_dev->vendor == 0x8086) && (ctrl->pci_dev->device == 0x0332)) { 1162 if (slots_not_empty) 1163 return WRONG_BUS_FREQUENCY; 1164 1165 if ((rc = p_slot->hpc_ops->set_bus_speed_mode(p_slot, PCI_SPEED_33MHz))) { 1166 err("%s: Issue of set bus speed mode command failed\n", __FUNCTION__); 1167 up(&ctrl->crit_sect); 1168 return WRONG_BUS_FREQUENCY; 1169 } 1170 wait_for_ctrl_irq (ctrl); 1171 1172 if ((rc = p_slot->hpc_ops->check_cmd_status(ctrl))) { 1173 err("%s: Can't set bus speed/mode in the case of adapter & bus mismatch\n", 1174 __FUNCTION__); 1175 err("%s: Error code (%d)\n", __FUNCTION__, rc); 1176 up(&ctrl->crit_sect); 1177 return WRONG_BUS_FREQUENCY; 1178 } 1179 /* turn on board, blink green LED, turn off Amber LED */ 1180 if ((rc = p_slot->hpc_ops->slot_enable(p_slot))) { 1181 err("%s: Issue of Slot Enable command failed\n", __FUNCTION__); 1182 up(&ctrl->crit_sect); 1183 return rc; 1184 } 1185 wait_for_ctrl_irq (ctrl); 1186 1187 if ((rc = p_slot->hpc_ops->check_cmd_status(ctrl))) { 1188 err("%s: Failed to enable slot, error code(%d)\n", __FUNCTION__, rc); 1189 up(&ctrl->crit_sect); 1190 return rc; 1191 } 1192 } 1193 1194 rc = p_slot->hpc_ops->get_adapter_speed(p_slot, &adapter_speed); 1195 /* 0 = PCI 33Mhz, 1 = PCI 66 Mhz, 2 = PCI-X 66 PA, 4 = PCI-X 66 ECC, */ 1196 /* 5 = PCI-X 133 PA, 7 = PCI-X 133 ECC, 0xa = PCI-X 133 Mhz 266, */ 1197 /* 0xd = PCI-X 133 Mhz 533 */ 1198 /* This encoding is different from the one used in cur_bus_speed & */ 1199 /* max_bus_speed */ 1200 1201 if (rc || adapter_speed == PCI_SPEED_UNKNOWN) { 1202 err("%s: Can't get adapter speed or bus mode mismatch\n", __FUNCTION__); 1203 /* Done with exclusive hardware access */ 1204 up(&ctrl->crit_sect); 1205 return WRONG_BUS_FREQUENCY; 1206 } 1207 1208 rc = p_slot->hpc_ops->get_cur_bus_speed(p_slot, &bus_speed); 1209 if (rc || bus_speed == PCI_SPEED_UNKNOWN) { 1210 err("%s: Can't get bus operation speed\n", __FUNCTION__); 1211 /* Done with exclusive hardware access */ 1212 up(&ctrl->crit_sect); 1213 return WRONG_BUS_FREQUENCY; 1214 } 1215 1216 rc = p_slot->hpc_ops->get_max_bus_speed(p_slot, &max_bus_speed); 1217 if (rc || max_bus_speed == PCI_SPEED_UNKNOWN) { 1218 err("%s: Can't get max bus operation speed\n", __FUNCTION__); 1219 max_bus_speed = bus_speed; 1220 } 1221 1222 /* Done with exclusive hardware access */ 1223 up(&ctrl->crit_sect); 1224 1225 if ((rc = p_slot->hpc_ops->get_prog_int(p_slot, &pi))) { 1226 err("%s: Can't get controller programming interface, set it to 1\n", __FUNCTION__); 1227 pi = 1; 1228 } 1229 1230 /* Check if there are other slots or devices on the same bus */ 1231 if (!list_empty(&ctrl->pci_dev->subordinate->devices)) 1232 slots_not_empty = 1; 1233 1234 dbg("%s: slots_not_empty %d, pi %d\n", __FUNCTION__, 1235 slots_not_empty, pi); 1236 dbg("adapter_speed %d, bus_speed %d, max_bus_speed %d\n", 1237 adapter_speed, bus_speed, max_bus_speed); 1238 1239 if (pi == 2) { 1240 dbg("%s: In PI = %d\n", __FUNCTION__, pi); 1241 if ((rc = p_slot->hpc_ops->get_mode1_ECC_cap(p_slot, &mode))) { 1242 err("%s: Can't get Mode1_ECC, set mode to 0\n", __FUNCTION__); 1243 mode = 0; 1244 } 1245 1246 switch (adapter_speed) { 1247 case PCI_SPEED_133MHz_PCIX_533: 1248 case PCI_SPEED_133MHz_PCIX_266: 1249 if ((bus_speed != adapter_speed) && 1250 ((rc = fix_bus_speed(ctrl, p_slot, slots_not_empty, adapter_speed, bus_speed, max_bus_speed)))) 1251 return rc; 1252 break; 1253 case PCI_SPEED_133MHz_PCIX_ECC: 1254 case PCI_SPEED_133MHz_PCIX: 1255 if (mode) { /* Bus - Mode 1 ECC */ 1256 if ((bus_speed != 0x7) && 1257 ((rc = fix_bus_speed(ctrl, p_slot, slots_not_empty, adapter_speed, bus_speed, max_bus_speed)))) 1258 return rc; 1259 } else { 1260 if ((bus_speed != 0x4) && 1261 ((rc = fix_bus_speed(ctrl, p_slot, slots_not_empty, adapter_speed, bus_speed, max_bus_speed)))) 1262 return rc; 1263 } 1264 break; 1265 case PCI_SPEED_66MHz_PCIX_ECC: 1266 case PCI_SPEED_66MHz_PCIX: 1267 if (mode) { /* Bus - Mode 1 ECC */ 1268 if ((bus_speed != 0x5) && 1269 ((rc = fix_bus_speed(ctrl, p_slot, slots_not_empty, adapter_speed, bus_speed, max_bus_speed)))) 1270 return rc; 1271 } else { 1272 if ((bus_speed != 0x2) && 1273 ((rc = fix_bus_speed(ctrl, p_slot, slots_not_empty, adapter_speed, bus_speed, max_bus_speed)))) 1274 return rc; 1275 } 1276 break; 1277 case PCI_SPEED_66MHz: 1278 if ((bus_speed != 0x1) && 1279 ((rc = fix_bus_speed(ctrl, p_slot, slots_not_empty, adapter_speed, bus_speed, max_bus_speed)))) 1280 return rc; 1281 break; 1282 case PCI_SPEED_33MHz: 1283 if (bus_speed > 0x0) { 1284 if (slots_not_empty == 0) { 1285 if ((rc = change_bus_speed(ctrl, p_slot, adapter_speed))) 1286 return rc; 1287 } else { 1288 err("%s: speed of bus %x and adapter %x mismatch\n", __FUNCTION__, bus_speed, adapter_speed); 1289 return WRONG_BUS_FREQUENCY; 1290 } 1291 } 1292 break; 1293 default: 1294 err("%s: speed of bus %x and adapter %x mismatch\n", __FUNCTION__, bus_speed, adapter_speed); 1295 return WRONG_BUS_FREQUENCY; 1296 } 1297 } else { 1298 /* If adpater_speed == bus_speed, nothing to do here */ 1299 dbg("%s: In PI = %d\n", __FUNCTION__, pi); 1300 if ((adapter_speed != bus_speed) && 1301 ((rc = fix_bus_speed(ctrl, p_slot, slots_not_empty, adapter_speed, bus_speed, max_bus_speed)))) 1302 return rc; 1303 } 1304 1305 down(&ctrl->crit_sect); 1306 /* turn on board, blink green LED, turn off Amber LED */ 1307 if ((rc = p_slot->hpc_ops->slot_enable(p_slot))) { 1308 err("%s: Issue of Slot Enable command failed\n", __FUNCTION__); 1309 up(&ctrl->crit_sect); 1310 return rc; 1311 } 1312 wait_for_ctrl_irq (ctrl); 1313 1314 if ((rc = p_slot->hpc_ops->check_cmd_status(ctrl))) { 1315 err("%s: Failed to enable slot, error code(%d)\n", __FUNCTION__, rc); 1316 up(&ctrl->crit_sect); 1317 return rc; 1318 } 1319 1320 up(&ctrl->crit_sect); 1321 1322 /* Wait for ~1 second */ 1323 dbg("%s: before long_delay\n", __FUNCTION__); 1324 wait_for_ctrl_irq (ctrl); 1325 dbg("%s: after long_delay\n", __FUNCTION__); 1326 1327 dbg("%s: func status = %x\n", __FUNCTION__, func->status); 1328 /* Check for a power fault */ 1329 if (func->status == 0xFF) { 1330 /* power fault occurred, but it was benign */ 1331 temp_register = 0xFFFFFFFF; 1332 dbg("%s: temp register set to %x by power fault\n", __FUNCTION__, temp_register); 1333 rc = POWER_FAILURE; 1334 func->status = 0; 1335 } else { 1336 /* Get vendor/device ID u32 */ 1337 rc = pci_bus_read_config_dword (ctrl->pci_dev->subordinate, PCI_DEVFN(func->device, func->function), 1338 PCI_VENDOR_ID, &temp_register); 1339 dbg("%s: pci_bus_read_config_dword returns %d\n", __FUNCTION__, rc); 1340 dbg("%s: temp_register is %x\n", __FUNCTION__, temp_register); 1341 1342 if (rc != 0) { 1343 /* Something's wrong here */ 1344 temp_register = 0xFFFFFFFF; 1345 dbg("%s: temp register set to %x by error\n", __FUNCTION__, temp_register); 1346 } 1347 /* Preset return code. It will be changed later if things go okay. */ 1348 rc = NO_ADAPTER_PRESENT; 1349 } 1350 1351 /* All F's is an empty slot or an invalid board */ 1352 if (temp_register != 0xFFFFFFFF) { /* Check for a board in the slot */ 1353 res_lists.io_head = ctrl->io_head; 1354 res_lists.mem_head = ctrl->mem_head; 1355 res_lists.p_mem_head = ctrl->p_mem_head; 1356 res_lists.bus_head = ctrl->bus_head; 1357 res_lists.irqs = NULL; 1358 1359 rc = configure_new_device(ctrl, func, 0, &res_lists, 0, 0); 1360 dbg("%s: back from configure_new_device\n", __FUNCTION__); 1361 1362 ctrl->io_head = res_lists.io_head; 1363 ctrl->mem_head = res_lists.mem_head; 1364 ctrl->p_mem_head = res_lists.p_mem_head; 1365 ctrl->bus_head = res_lists.bus_head; 1366 1367 shpchp_resource_sort_and_combine(&(ctrl->mem_head)); 1368 shpchp_resource_sort_and_combine(&(ctrl->p_mem_head)); 1369 shpchp_resource_sort_and_combine(&(ctrl->io_head)); 1370 shpchp_resource_sort_and_combine(&(ctrl->bus_head)); 1371 1372 if (rc) { 1373 /* Wait for exclusive access to hardware */ 1374 down(&ctrl->crit_sect); 1375 1376 /* turn off slot, turn on Amber LED, turn off Green LED */ 1377 retval = p_slot->hpc_ops->slot_disable(p_slot); 1378 if (retval) { 1379 err("%s: Issue of Slot Enable command failed\n", __FUNCTION__); 1380 /* Done with exclusive hardware access */ 1381 up(&ctrl->crit_sect); 1382 return retval; 1383 } 1384 /* Wait for the command to complete */ 1385 wait_for_ctrl_irq (ctrl); 1386 1387 retval = p_slot->hpc_ops->check_cmd_status(ctrl); 1388 if (retval) { 1389 err("%s: Failed to disable slot, error code(%d)\n", __FUNCTION__, retval); 1390 /* Done with exclusive hardware access */ 1391 up(&ctrl->crit_sect); 1392 return retval; 1393 } 1394 1395 /* Done with exclusive hardware access */ 1396 up(&ctrl->crit_sect); 1397 1398 return(rc); 1399 } 1400 shpchp_save_slot_config(ctrl, func); 1401 1402 func->status = 0; 1403 func->switch_save = 0x10; 1404 func->is_a_board = 0x01; 1405 func->pwr_save = 1; 1406 1407 /* Next, we will instantiate the linux pci_dev structures 1408 * (with appropriate driver notification, if already present) 1409 */ 1410 index = 0; 1411 do { 1412 new_func = shpchp_slot_find(ctrl->slot_bus, func->device, index++); 1413 if (new_func && !new_func->pci_dev) { 1414 dbg("%s:call pci_hp_configure_dev\n", __FUNCTION__); 1415 shpchp_configure_device(ctrl, new_func); 1416 } 1417 } while (new_func); 1418 1419 /* Wait for exclusive access to hardware */ 1420 down(&ctrl->crit_sect); 1421 1422 p_slot->hpc_ops->green_led_on(p_slot); 1423 1424 /* Wait for the command to complete */ 1425 wait_for_ctrl_irq (ctrl); 1426 1427 1428 /* Done with exclusive hardware access */ 1429 up(&ctrl->crit_sect); 1430 1431 } else { 1432 /* Wait for exclusive access to hardware */ 1433 down(&ctrl->crit_sect); 1434 1435 /* turn off slot, turn on Amber LED, turn off Green LED */ 1436 rc = p_slot->hpc_ops->slot_disable(p_slot); 1437 if (rc) { 1438 err("%s: Issue of Slot Disable command failed\n", __FUNCTION__); 1439 /* Done with exclusive hardware access */ 1440 up(&ctrl->crit_sect); 1441 return rc; 1442 } 1443 /* Wait for the command to complete */ 1444 wait_for_ctrl_irq (ctrl); 1445 1446 rc = p_slot->hpc_ops->check_cmd_status(ctrl); 1447 if (rc) { 1448 err("%s: Failed to disable slot, error code(%d)\n", __FUNCTION__, rc); 1449 /* Done with exclusive hardware access */ 1450 up(&ctrl->crit_sect); 1451 return rc; 1452 } 1453 1454 /* Done with exclusive hardware access */ 1455 up(&ctrl->crit_sect); 1456 1457 return(rc); 1458 } 1459 return 0; 1460 } 1461 1462 1463 /** 1464 * remove_board - Turns off slot and LED's 1465 * 1466 */ 1467 static u32 remove_board(struct pci_func *func, struct controller *ctrl) 1468 { 1469 int index; 1470 u8 skip = 0; 1471 u8 device; 1472 u8 hp_slot; 1473 u32 rc; 1474 struct resource_lists res_lists; 1475 struct pci_func *temp_func; 1476 struct slot *p_slot; 1477 1478 if (func == NULL) 1479 return(1); 1480 1481 if (shpchp_unconfigure_device(func)) 1482 return(1); 1483 1484 device = func->device; 1485 1486 hp_slot = func->device - ctrl->slot_device_offset; 1487 p_slot = shpchp_find_slot(ctrl, hp_slot + ctrl->slot_device_offset); 1488 1489 dbg("In %s, hp_slot = %d\n", __FUNCTION__, hp_slot); 1490 1491 if ((ctrl->add_support) && 1492 !(func->bus_head || func->mem_head || func->p_mem_head || func->io_head)) { 1493 /* Here we check to see if we've saved any of the board's 1494 * resources already. If so, we'll skip the attempt to 1495 * determine what's being used. 1496 */ 1497 index = 0; 1498 1499 temp_func = func; 1500 1501 while ((temp_func = shpchp_slot_find(temp_func->bus, temp_func->device, index++))) { 1502 if (temp_func->bus_head || temp_func->mem_head 1503 || temp_func->p_mem_head || temp_func->io_head) { 1504 skip = 1; 1505 break; 1506 } 1507 } 1508 1509 if (!skip) 1510 rc = shpchp_save_used_resources(ctrl, func, DISABLE_CARD); 1511 } 1512 /* Change status to shutdown */ 1513 if (func->is_a_board) 1514 func->status = 0x01; 1515 func->configured = 0; 1516 1517 /* Wait for exclusive access to hardware */ 1518 down(&ctrl->crit_sect); 1519 1520 /* turn off slot, turn on Amber LED, turn off Green LED */ 1521 rc = p_slot->hpc_ops->slot_disable(p_slot); 1522 if (rc) { 1523 err("%s: Issue of Slot Disable command failed\n", __FUNCTION__); 1524 /* Done with exclusive hardware access */ 1525 up(&ctrl->crit_sect); 1526 return rc; 1527 } 1528 /* Wait for the command to complete */ 1529 wait_for_ctrl_irq (ctrl); 1530 1531 rc = p_slot->hpc_ops->check_cmd_status(ctrl); 1532 if (rc) { 1533 err("%s: Failed to disable slot, error code(%d)\n", __FUNCTION__, rc); 1534 /* Done with exclusive hardware access */ 1535 up(&ctrl->crit_sect); 1536 return rc; 1537 } 1538 1539 rc = p_slot->hpc_ops->set_attention_status(p_slot, 0); 1540 if (rc) { 1541 err("%s: Issue of Set Attention command failed\n", __FUNCTION__); 1542 /* Done with exclusive hardware access */ 1543 up(&ctrl->crit_sect); 1544 return rc; 1545 } 1546 /* Wait for the command to complete */ 1547 wait_for_ctrl_irq (ctrl); 1548 1549 /* Done with exclusive hardware access */ 1550 up(&ctrl->crit_sect); 1551 1552 if (ctrl->add_support) { 1553 while (func) { 1554 res_lists.io_head = ctrl->io_head; 1555 res_lists.mem_head = ctrl->mem_head; 1556 res_lists.p_mem_head = ctrl->p_mem_head; 1557 res_lists.bus_head = ctrl->bus_head; 1558 1559 dbg("Returning resources to ctlr lists for (B/D/F) = (%#x/%#x/%#x)\n", func->bus, 1560 func->device, func->function); 1561 1562 shpchp_return_board_resources(func, &res_lists); 1563 1564 ctrl->io_head = res_lists.io_head; 1565 ctrl->mem_head = res_lists.mem_head; 1566 ctrl->p_mem_head = res_lists.p_mem_head; 1567 ctrl->bus_head = res_lists.bus_head; 1568 1569 shpchp_resource_sort_and_combine(&(ctrl->mem_head)); 1570 shpchp_resource_sort_and_combine(&(ctrl->p_mem_head)); 1571 shpchp_resource_sort_and_combine(&(ctrl->io_head)); 1572 shpchp_resource_sort_and_combine(&(ctrl->bus_head)); 1573 1574 if (is_bridge(func)) { 1575 dbg("PCI Bridge Hot-Remove s:b:d:f(%02x:%02x:%02x:%02x)\n", ctrl->seg, func->bus, 1576 func->device, func->function); 1577 bridge_slot_remove(func); 1578 } else 1579 dbg("PCI Function Hot-Remove s:b:d:f(%02x:%02x:%02x:%02x)\n", ctrl->seg, func->bus, 1580 func->device, func->function); 1581 slot_remove(func); 1582 1583 func = shpchp_slot_find(ctrl->slot_bus, device, 0); 1584 } 1585 1586 /* Setup slot structure with entry for empty slot */ 1587 func = shpchp_slot_create(ctrl->slot_bus); 1588 1589 if (func == NULL) { 1590 return(1); 1591 } 1592 1593 func->bus = ctrl->slot_bus; 1594 func->device = device; 1595 func->function = 0; 1596 func->configured = 0; 1597 func->switch_save = 0x10; 1598 func->pwr_save = 0; 1599 func->is_a_board = 0; 1600 } 1601 1602 return 0; 1603 } 1604 1605 1606 static void pushbutton_helper_thread (unsigned long data) 1607 { 1608 pushbutton_pending = data; 1609 1610 up(&event_semaphore); 1611 } 1612 1613 1614 /** 1615 * shpchp_pushbutton_thread 1616 * 1617 * Scheduled procedure to handle blocking stuff for the pushbuttons 1618 * Handles all pending events and exits. 1619 * 1620 */ 1621 static void shpchp_pushbutton_thread (unsigned long slot) 1622 { 1623 struct slot *p_slot = (struct slot *) slot; 1624 u8 getstatus; 1625 1626 pushbutton_pending = 0; 1627 1628 if (!p_slot) { 1629 dbg("%s: Error! slot NULL\n", __FUNCTION__); 1630 return; 1631 } 1632 1633 p_slot->hpc_ops->get_power_status(p_slot, &getstatus); 1634 if (getstatus) { 1635 p_slot->state = POWEROFF_STATE; 1636 dbg("In power_down_board, b:d(%x:%x)\n", p_slot->bus, p_slot->device); 1637 1638 shpchp_disable_slot(p_slot); 1639 p_slot->state = STATIC_STATE; 1640 } else { 1641 p_slot->state = POWERON_STATE; 1642 dbg("In add_board, b:d(%x:%x)\n", p_slot->bus, p_slot->device); 1643 1644 if (shpchp_enable_slot(p_slot)) { 1645 /* Wait for exclusive access to hardware */ 1646 down(&p_slot->ctrl->crit_sect); 1647 1648 p_slot->hpc_ops->green_led_off(p_slot); 1649 1650 /* Wait for the command to complete */ 1651 wait_for_ctrl_irq (p_slot->ctrl); 1652 1653 /* Done with exclusive hardware access */ 1654 up(&p_slot->ctrl->crit_sect); 1655 } 1656 p_slot->state = STATIC_STATE; 1657 } 1658 1659 return; 1660 } 1661 1662 1663 /* this is the main worker thread */ 1664 static int event_thread(void* data) 1665 { 1666 struct controller *ctrl; 1667 lock_kernel(); 1668 daemonize("shpchpd_event"); 1669 unlock_kernel(); 1670 1671 while (1) { 1672 dbg("!!!!event_thread sleeping\n"); 1673 down_interruptible (&event_semaphore); 1674 dbg("event_thread woken finished = %d\n", event_finished); 1675 if (event_finished || signal_pending(current)) 1676 break; 1677 /* Do stuff here */ 1678 if (pushbutton_pending) 1679 shpchp_pushbutton_thread(pushbutton_pending); 1680 else 1681 for (ctrl = shpchp_ctrl_list; ctrl; ctrl=ctrl->next) 1682 interrupt_event_handler(ctrl); 1683 } 1684 dbg("event_thread signals exit\n"); 1685 up(&event_exit); 1686 return 0; 1687 } 1688 1689 int shpchp_event_start_thread (void) 1690 { 1691 int pid; 1692 1693 /* initialize our semaphores */ 1694 init_MUTEX_LOCKED(&event_exit); 1695 event_finished=0; 1696 1697 init_MUTEX_LOCKED(&event_semaphore); 1698 pid = kernel_thread(event_thread, NULL, 0); 1699 1700 if (pid < 0) { 1701 err ("Can't start up our event thread\n"); 1702 return -1; 1703 } 1704 dbg("Our event thread pid = %d\n", pid); 1705 return 0; 1706 } 1707 1708 1709 void shpchp_event_stop_thread (void) 1710 { 1711 event_finished = 1; 1712 dbg("event_thread finish command given\n"); 1713 up(&event_semaphore); 1714 dbg("wait for event_thread to exit\n"); 1715 down(&event_exit); 1716 } 1717 1718 1719 static int update_slot_info (struct slot *slot) 1720 { 1721 struct hotplug_slot_info *info; 1722 int result; 1723 1724 info = kmalloc(sizeof(*info), GFP_KERNEL); 1725 if (!info) 1726 return -ENOMEM; 1727 1728 slot->hpc_ops->get_power_status(slot, &(info->power_status)); 1729 slot->hpc_ops->get_attention_status(slot, &(info->attention_status)); 1730 slot->hpc_ops->get_latch_status(slot, &(info->latch_status)); 1731 slot->hpc_ops->get_adapter_status(slot, &(info->adapter_status)); 1732 1733 result = pci_hp_change_slot_info(slot->hotplug_slot, info); 1734 kfree (info); 1735 return result; 1736 } 1737 1738 static void interrupt_event_handler(struct controller *ctrl) 1739 { 1740 int loop = 0; 1741 int change = 1; 1742 struct pci_func *func; 1743 u8 hp_slot; 1744 u8 getstatus; 1745 struct slot *p_slot; 1746 1747 dbg("%s:\n", __FUNCTION__); 1748 while (change) { 1749 change = 0; 1750 1751 for (loop = 0; loop < 10; loop++) { 1752 if (ctrl->event_queue[loop].event_type != 0) { 1753 dbg("%s:loop %x event_type %x\n", __FUNCTION__, loop, 1754 ctrl->event_queue[loop].event_type); 1755 hp_slot = ctrl->event_queue[loop].hp_slot; 1756 1757 func = shpchp_slot_find(ctrl->slot_bus, (hp_slot + ctrl->slot_device_offset), 0); 1758 1759 p_slot = shpchp_find_slot(ctrl, hp_slot + ctrl->slot_device_offset); 1760 1761 dbg("%s: hp_slot %d, func %p, p_slot %p\n", __FUNCTION__, hp_slot, func, p_slot); 1762 1763 if (ctrl->event_queue[loop].event_type == INT_BUTTON_CANCEL) { 1764 dbg("%s: button cancel\n", __FUNCTION__); 1765 del_timer(&p_slot->task_event); 1766 1767 switch (p_slot->state) { 1768 case BLINKINGOFF_STATE: 1769 /* Wait for exclusive access to hardware */ 1770 down(&ctrl->crit_sect); 1771 1772 p_slot->hpc_ops->green_led_on(p_slot); 1773 /* Wait for the command to complete */ 1774 wait_for_ctrl_irq (ctrl); 1775 1776 p_slot->hpc_ops->set_attention_status(p_slot, 0); 1777 1778 /* Wait for the command to complete */ 1779 wait_for_ctrl_irq (ctrl); 1780 1781 /* Done with exclusive hardware access */ 1782 up(&ctrl->crit_sect); 1783 break; 1784 case BLINKINGON_STATE: 1785 /* Wait for exclusive access to hardware */ 1786 down(&ctrl->crit_sect); 1787 1788 p_slot->hpc_ops->green_led_off(p_slot); 1789 /* Wait for the command to complete */ 1790 wait_for_ctrl_irq (ctrl); 1791 1792 p_slot->hpc_ops->set_attention_status(p_slot, 0); 1793 /* Wait for the command to complete */ 1794 wait_for_ctrl_irq (ctrl); 1795 1796 /* Done with exclusive hardware access */ 1797 up(&ctrl->crit_sect); 1798 1799 break; 1800 default: 1801 warn("Not a valid state\n"); 1802 return; 1803 } 1804 info(msg_button_cancel, p_slot->number); 1805 p_slot->state = STATIC_STATE; 1806 } else if (ctrl->event_queue[loop].event_type == INT_BUTTON_PRESS) { 1807 /* Button Pressed (No action on 1st press...) */ 1808 dbg("%s: Button pressed\n", __FUNCTION__); 1809 1810 p_slot->hpc_ops->get_power_status(p_slot, &getstatus); 1811 if (getstatus) { 1812 /* slot is on */ 1813 dbg("%s: slot is on\n", __FUNCTION__); 1814 p_slot->state = BLINKINGOFF_STATE; 1815 info(msg_button_off, p_slot->number); 1816 } else { 1817 /* slot is off */ 1818 dbg("%s: slot is off\n", __FUNCTION__); 1819 p_slot->state = BLINKINGON_STATE; 1820 info(msg_button_on, p_slot->number); 1821 } 1822 1823 /* Wait for exclusive access to hardware */ 1824 down(&ctrl->crit_sect); 1825 1826 /* blink green LED and turn off amber */ 1827 p_slot->hpc_ops->green_led_blink(p_slot); 1828 /* Wait for the command to complete */ 1829 wait_for_ctrl_irq (ctrl); 1830 1831 p_slot->hpc_ops->set_attention_status(p_slot, 0); 1832 1833 /* Wait for the command to complete */ 1834 wait_for_ctrl_irq (ctrl); 1835 1836 /* Done with exclusive hardware access */ 1837 up(&ctrl->crit_sect); 1838 1839 init_timer(&p_slot->task_event); 1840 p_slot->task_event.expires = jiffies + 5 * HZ; /* 5 second delay */ 1841 p_slot->task_event.function = (void (*)(unsigned long)) pushbutton_helper_thread; 1842 p_slot->task_event.data = (unsigned long) p_slot; 1843 1844 dbg("%s: add_timer p_slot = %p\n", __FUNCTION__,(void *) p_slot); 1845 add_timer(&p_slot->task_event); 1846 } else if (ctrl->event_queue[loop].event_type == INT_POWER_FAULT) { 1847 /***********POWER FAULT********************/ 1848 dbg("%s: power fault\n", __FUNCTION__); 1849 /* Wait for exclusive access to hardware */ 1850 down(&ctrl->crit_sect); 1851 1852 p_slot->hpc_ops->set_attention_status(p_slot, 1); 1853 /* Wait for the command to complete */ 1854 wait_for_ctrl_irq (ctrl); 1855 1856 p_slot->hpc_ops->green_led_off(p_slot); 1857 /* Wait for the command to complete */ 1858 wait_for_ctrl_irq (ctrl); 1859 1860 /* Done with exclusive hardware access */ 1861 up(&ctrl->crit_sect); 1862 } else { 1863 /* refresh notification */ 1864 if (p_slot) 1865 update_slot_info(p_slot); 1866 } 1867 1868 ctrl->event_queue[loop].event_type = 0; 1869 1870 change = 1; 1871 } 1872 } /* End of FOR loop */ 1873 } 1874 1875 return; 1876 } 1877 1878 1879 int shpchp_enable_slot (struct slot *p_slot) 1880 { 1881 u8 getstatus = 0; 1882 int rc; 1883 struct pci_func *func; 1884 1885 func = shpchp_slot_find(p_slot->bus, p_slot->device, 0); 1886 if (!func) { 1887 dbg("%s: Error! slot NULL\n", __FUNCTION__); 1888 return 1; 1889 } 1890 1891 /* Check to see if (latch closed, card present, power off) */ 1892 down(&p_slot->ctrl->crit_sect); 1893 rc = p_slot->hpc_ops->get_adapter_status(p_slot, &getstatus); 1894 if (rc || !getstatus) { 1895 info("%s: no adapter on slot(%x)\n", __FUNCTION__, p_slot->number); 1896 up(&p_slot->ctrl->crit_sect); 1897 return 1; 1898 } 1899 rc = p_slot->hpc_ops->get_latch_status(p_slot, &getstatus); 1900 if (rc || getstatus) { 1901 info("%s: latch open on slot(%x)\n", __FUNCTION__, p_slot->number); 1902 up(&p_slot->ctrl->crit_sect); 1903 return 1; 1904 } 1905 rc = p_slot->hpc_ops->get_power_status(p_slot, &getstatus); 1906 if (rc || getstatus) { 1907 info("%s: already enabled on slot(%x)\n", __FUNCTION__, p_slot->number); 1908 up(&p_slot->ctrl->crit_sect); 1909 return 1; 1910 } 1911 up(&p_slot->ctrl->crit_sect); 1912 1913 slot_remove(func); 1914 1915 func = shpchp_slot_create(p_slot->bus); 1916 if (func == NULL) 1917 return 1; 1918 1919 func->bus = p_slot->bus; 1920 func->device = p_slot->device; 1921 func->function = 0; 1922 func->configured = 0; 1923 func->is_a_board = 1; 1924 1925 /* We have to save the presence info for these slots */ 1926 p_slot->hpc_ops->get_adapter_status(p_slot, &(func->presence_save)); 1927 p_slot->hpc_ops->get_power_status(p_slot, &(func->pwr_save)); 1928 dbg("%s: func->pwr_save %x\n", __FUNCTION__, func->pwr_save); 1929 p_slot->hpc_ops->get_latch_status(p_slot, &getstatus); 1930 func->switch_save = !getstatus? 0x10:0; 1931 1932 rc = board_added(func, p_slot->ctrl); 1933 if (rc) { 1934 if (is_bridge(func)) 1935 bridge_slot_remove(func); 1936 else 1937 slot_remove(func); 1938 1939 /* Setup slot structure with entry for empty slot */ 1940 func = shpchp_slot_create(p_slot->bus); 1941 if (func == NULL) 1942 return (1); /* Out of memory */ 1943 1944 func->bus = p_slot->bus; 1945 func->device = p_slot->device; 1946 func->function = 0; 1947 func->configured = 0; 1948 func->is_a_board = 1; 1949 1950 /* We have to save the presence info for these slots */ 1951 p_slot->hpc_ops->get_adapter_status(p_slot, &(func->presence_save)); 1952 p_slot->hpc_ops->get_latch_status(p_slot, &getstatus); 1953 func->switch_save = !getstatus? 0x10:0; 1954 } 1955 1956 if (p_slot) 1957 update_slot_info(p_slot); 1958 1959 return rc; 1960 } 1961 1962 1963 int shpchp_disable_slot (struct slot *p_slot) 1964 { 1965 u8 class_code, header_type, BCR; 1966 u8 index = 0; 1967 u8 getstatus = 0; 1968 u32 rc = 0; 1969 int ret = 0; 1970 unsigned int devfn; 1971 struct pci_bus *pci_bus; 1972 struct pci_func *func; 1973 1974 if (!p_slot->ctrl) 1975 return 1; 1976 1977 pci_bus = p_slot->ctrl->pci_dev->subordinate; 1978 1979 /* Check to see if (latch closed, card present, power on) */ 1980 down(&p_slot->ctrl->crit_sect); 1981 1982 ret = p_slot->hpc_ops->get_adapter_status(p_slot, &getstatus); 1983 if (ret || !getstatus) { 1984 info("%s: no adapter on slot(%x)\n", __FUNCTION__, p_slot->number); 1985 up(&p_slot->ctrl->crit_sect); 1986 return 1; 1987 } 1988 ret = p_slot->hpc_ops->get_latch_status(p_slot, &getstatus); 1989 if (ret || getstatus) { 1990 info("%s: latch open on slot(%x)\n", __FUNCTION__, p_slot->number); 1991 up(&p_slot->ctrl->crit_sect); 1992 return 1; 1993 } 1994 ret = p_slot->hpc_ops->get_power_status(p_slot, &getstatus); 1995 if (ret || !getstatus) { 1996 info("%s: already disabled slot(%x)\n", __FUNCTION__, p_slot->number); 1997 up(&p_slot->ctrl->crit_sect); 1998 return 1; 1999 } 2000 up(&p_slot->ctrl->crit_sect); 2001 2002 func = shpchp_slot_find(p_slot->bus, p_slot->device, index++); 2003 2004 /* Make sure there are no video controllers here 2005 * for all func of p_slot 2006 */ 2007 while (func && !rc) { 2008 pci_bus->number = func->bus; 2009 devfn = PCI_DEVFN(func->device, func->function); 2010 2011 /* Check the Class Code */ 2012 rc = pci_bus_read_config_byte (pci_bus, devfn, 0x0B, &class_code); 2013 if (rc) 2014 return rc; 2015 2016 if (class_code == PCI_BASE_CLASS_DISPLAY) { 2017 /* Display/Video adapter (not supported) */ 2018 rc = REMOVE_NOT_SUPPORTED; 2019 } else { 2020 /* See if it's a bridge */ 2021 rc = pci_bus_read_config_byte (pci_bus, devfn, PCI_HEADER_TYPE, &header_type); 2022 if (rc) 2023 return rc; 2024 2025 /* If it's a bridge, check the VGA Enable bit */ 2026 if ((header_type & 0x7F) == PCI_HEADER_TYPE_BRIDGE) { 2027 rc = pci_bus_read_config_byte (pci_bus, devfn, PCI_BRIDGE_CONTROL, &BCR); 2028 if (rc) 2029 return rc; 2030 2031 /* If the VGA Enable bit is set, remove isn't supported */ 2032 if (BCR & PCI_BRIDGE_CTL_VGA) { 2033 rc = REMOVE_NOT_SUPPORTED; 2034 } 2035 } 2036 } 2037 2038 func = shpchp_slot_find(p_slot->bus, p_slot->device, index++); 2039 } 2040 2041 func = shpchp_slot_find(p_slot->bus, p_slot->device, 0); 2042 if ((func != NULL) && !rc) { 2043 rc = remove_board(func, p_slot->ctrl); 2044 } else if (!rc) 2045 rc = 1; 2046 2047 if (p_slot) 2048 update_slot_info(p_slot); 2049 2050 return(rc); 2051 } 2052 2053 2054 /** 2055 * configure_new_device - Configures the PCI header information of one board. 2056 * 2057 * @ctrl: pointer to controller structure 2058 * @func: pointer to function structure 2059 * @behind_bridge: 1 if this is a recursive call, 0 if not 2060 * @resources: pointer to set of resource lists 2061 * 2062 * Returns 0 if success 2063 * 2064 */ 2065 static u32 configure_new_device (struct controller * ctrl, struct pci_func * func, 2066 u8 behind_bridge, struct resource_lists * resources, u8 bridge_bus, u8 bridge_dev) 2067 { 2068 u8 temp_byte, function, max_functions, stop_it; 2069 int rc; 2070 u32 ID; 2071 struct pci_func *new_slot; 2072 struct pci_bus lpci_bus, *pci_bus; 2073 int index; 2074 2075 new_slot = func; 2076 2077 dbg("%s\n", __FUNCTION__); 2078 memcpy(&lpci_bus, ctrl->pci_dev->subordinate, sizeof(lpci_bus)); 2079 pci_bus = &lpci_bus; 2080 pci_bus->number = func->bus; 2081 2082 /* Check for Multi-function device */ 2083 rc = pci_bus_read_config_byte(pci_bus, PCI_DEVFN(func->device, func->function), 0x0E, &temp_byte); 2084 if (rc) { 2085 dbg("%s: rc = %d\n", __FUNCTION__, rc); 2086 return rc; 2087 } 2088 2089 if (temp_byte & 0x80) /* Multi-function device */ 2090 max_functions = 8; 2091 else 2092 max_functions = 1; 2093 2094 function = 0; 2095 2096 do { 2097 rc = configure_new_function(ctrl, new_slot, behind_bridge, resources, bridge_bus, bridge_dev); 2098 2099 if (rc) { 2100 dbg("configure_new_function failed %d\n",rc); 2101 index = 0; 2102 2103 while (new_slot) { 2104 new_slot = shpchp_slot_find(new_slot->bus, new_slot->device, index++); 2105 2106 if (new_slot) 2107 shpchp_return_board_resources(new_slot, resources); 2108 } 2109 2110 return(rc); 2111 } 2112 2113 function++; 2114 2115 stop_it = 0; 2116 2117 /* The following loop skips to the next present function 2118 * and creates a board structure 2119 */ 2120 2121 while ((function < max_functions) && (!stop_it)) { 2122 pci_bus_read_config_dword(pci_bus, PCI_DEVFN(func->device, function), 0x00, &ID); 2123 2124 if (ID == 0xFFFFFFFF) { /* There's nothing there. */ 2125 function++; 2126 } else { /* There's something there */ 2127 /* Setup slot structure. */ 2128 new_slot = shpchp_slot_create(func->bus); 2129 2130 if (new_slot == NULL) { 2131 /* Out of memory */ 2132 return(1); 2133 } 2134 2135 new_slot->bus = func->bus; 2136 new_slot->device = func->device; 2137 new_slot->function = function; 2138 new_slot->is_a_board = 1; 2139 new_slot->status = 0; 2140 2141 stop_it++; 2142 } 2143 } 2144 2145 } while (function < max_functions); 2146 dbg("returning from configure_new_device\n"); 2147 2148 return 0; 2149 } 2150 2151 2152 /* 2153 * Configuration logic that involves the hotplug data structures and 2154 * their bookkeeping 2155 */ 2156 2157 2158 /** 2159 * configure_new_function - Configures the PCI header information of one device 2160 * 2161 * @ctrl: pointer to controller structure 2162 * @func: pointer to function structure 2163 * @behind_bridge: 1 if this is a recursive call, 0 if not 2164 * @resources: pointer to set of resource lists 2165 * 2166 * Calls itself recursively for bridged devices. 2167 * Returns 0 if success 2168 * 2169 */ 2170 static int configure_new_function (struct controller * ctrl, struct pci_func * func, 2171 u8 behind_bridge, struct resource_lists *resources, u8 bridge_bus, u8 bridge_dev) 2172 { 2173 int cloop; 2174 u8 temp_byte; 2175 u8 device; 2176 u8 class_code; 2177 u16 temp_word; 2178 u32 rc; 2179 u32 temp_register; 2180 u32 base; 2181 u32 ID; 2182 unsigned int devfn; 2183 struct pci_resource *mem_node; 2184 struct pci_resource *p_mem_node; 2185 struct pci_resource *io_node; 2186 struct pci_resource *bus_node; 2187 struct pci_resource *hold_mem_node; 2188 struct pci_resource *hold_p_mem_node; 2189 struct pci_resource *hold_IO_node; 2190 struct pci_resource *hold_bus_node; 2191 struct irq_mapping irqs; 2192 struct pci_func *new_slot; 2193 struct pci_bus lpci_bus, *pci_bus; 2194 struct resource_lists temp_resources; 2195 #if defined(CONFIG_X86_64) 2196 u8 IRQ=0; 2197 #endif 2198 2199 memcpy(&lpci_bus, ctrl->pci_dev->subordinate, sizeof(lpci_bus)); 2200 pci_bus = &lpci_bus; 2201 pci_bus->number = func->bus; 2202 devfn = PCI_DEVFN(func->device, func->function); 2203 2204 /* Check for Bridge */ 2205 rc = pci_bus_read_config_byte (pci_bus, devfn, PCI_HEADER_TYPE, &temp_byte); 2206 if (rc) 2207 return rc; 2208 2209 if ((temp_byte & 0x7F) == PCI_HEADER_TYPE_BRIDGE) { /* PCI-PCI Bridge */ 2210 /* set Primary bus */ 2211 dbg("set Primary bus = 0x%x\n", func->bus); 2212 rc = pci_bus_write_config_byte(pci_bus, devfn, PCI_PRIMARY_BUS, func->bus); 2213 if (rc) 2214 return rc; 2215 2216 /* find range of busses to use */ 2217 bus_node = get_max_resource(&resources->bus_head, 1L); 2218 2219 /* If we don't have any busses to allocate, we can't continue */ 2220 if (!bus_node) { 2221 err("Got NO bus resource to use\n"); 2222 return -ENOMEM; 2223 } 2224 dbg("Got ranges of buses to use: base:len=0x%x:%x\n", bus_node->base, bus_node->length); 2225 2226 /* set Secondary bus */ 2227 temp_byte = (u8)bus_node->base; 2228 dbg("set Secondary bus = 0x%x\n", temp_byte); 2229 rc = pci_bus_write_config_byte(pci_bus, devfn, PCI_SECONDARY_BUS, temp_byte); 2230 if (rc) 2231 return rc; 2232 2233 /* set subordinate bus */ 2234 temp_byte = (u8)(bus_node->base + bus_node->length - 1); 2235 dbg("set subordinate bus = 0x%x\n", temp_byte); 2236 rc = pci_bus_write_config_byte (pci_bus, devfn, PCI_SUBORDINATE_BUS, temp_byte); 2237 if (rc) 2238 return rc; 2239 2240 /* Set HP parameters (Cache Line Size, Latency Timer) */ 2241 rc = shpchprm_set_hpp(ctrl, func, PCI_HEADER_TYPE_BRIDGE); 2242 if (rc) 2243 return rc; 2244 2245 /* Setup the IO, memory, and prefetchable windows */ 2246 2247 io_node = get_max_resource(&(resources->io_head), 0x1000L); 2248 if (io_node) { 2249 dbg("io_node(base, len, next) (%x, %x, %p)\n", io_node->base, io_node->length, io_node->next); 2250 } 2251 2252 mem_node = get_max_resource(&(resources->mem_head), 0x100000L); 2253 if (mem_node) { 2254 dbg("mem_node(base, len, next) (%x, %x, %p)\n", mem_node->base, mem_node->length, mem_node->next); 2255 } 2256 2257 if (resources->p_mem_head) 2258 p_mem_node = get_max_resource(&(resources->p_mem_head), 0x100000L); 2259 else { 2260 /* 2261 * In some platform implementation, MEM and PMEM are not 2262 * distinguished, and hence ACPI _CRS has only MEM entries 2263 * for both MEM and PMEM. 2264 */ 2265 dbg("using MEM for PMEM\n"); 2266 p_mem_node = get_max_resource(&(resources->mem_head), 0x100000L); 2267 } 2268 if (p_mem_node) { 2269 dbg("p_mem_node(base, len, next) (%x, %x, %p)\n", p_mem_node->base, p_mem_node->length, p_mem_node->next); 2270 } 2271 2272 /* set up the IRQ info */ 2273 if (!resources->irqs) { 2274 irqs.barber_pole = 0; 2275 irqs.interrupt[0] = 0; 2276 irqs.interrupt[1] = 0; 2277 irqs.interrupt[2] = 0; 2278 irqs.interrupt[3] = 0; 2279 irqs.valid_INT = 0; 2280 } else { 2281 irqs.barber_pole = resources->irqs->barber_pole; 2282 irqs.interrupt[0] = resources->irqs->interrupt[0]; 2283 irqs.interrupt[1] = resources->irqs->interrupt[1]; 2284 irqs.interrupt[2] = resources->irqs->interrupt[2]; 2285 irqs.interrupt[3] = resources->irqs->interrupt[3]; 2286 irqs.valid_INT = resources->irqs->valid_INT; 2287 } 2288 2289 /* set up resource lists that are now aligned on top and bottom 2290 * for anything behind the bridge. 2291 */ 2292 temp_resources.bus_head = bus_node; 2293 temp_resources.io_head = io_node; 2294 temp_resources.mem_head = mem_node; 2295 temp_resources.p_mem_head = p_mem_node; 2296 temp_resources.irqs = &irqs; 2297 2298 /* Make copies of the nodes we are going to pass down so that 2299 * if there is a problem,we can just use these to free resources 2300 */ 2301 hold_bus_node = kmalloc(sizeof(*hold_bus_node), GFP_KERNEL); 2302 hold_IO_node = kmalloc(sizeof(*hold_IO_node), GFP_KERNEL); 2303 hold_mem_node = kmalloc(sizeof(*hold_mem_node), GFP_KERNEL); 2304 hold_p_mem_node = kmalloc(sizeof(*hold_p_mem_node), GFP_KERNEL); 2305 2306 if (!hold_bus_node || !hold_IO_node || !hold_mem_node || !hold_p_mem_node) { 2307 kfree(hold_bus_node); 2308 kfree(hold_IO_node); 2309 kfree(hold_mem_node); 2310 kfree(hold_p_mem_node); 2311 2312 return 1; 2313 } 2314 2315 memcpy(hold_bus_node, bus_node, sizeof(struct pci_resource)); 2316 2317 bus_node->base += 1; 2318 bus_node->length -= 1; 2319 bus_node->next = NULL; 2320 2321 /* If we have IO resources copy them and fill in the bridge's 2322 * IO range registers 2323 */ 2324 if (io_node) { 2325 memcpy(hold_IO_node, io_node, sizeof(struct pci_resource)); 2326 io_node->next = NULL; 2327 2328 /* set IO base and Limit registers */ 2329 RES_CHECK(io_node->base, 8); 2330 temp_byte = (u8)(io_node->base >> 8); 2331 rc = pci_bus_write_config_byte(pci_bus, devfn, PCI_IO_BASE, temp_byte); 2332 2333 RES_CHECK(io_node->base + io_node->length - 1, 8); 2334 temp_byte = (u8)((io_node->base + io_node->length - 1) >> 8); 2335 rc = pci_bus_write_config_byte(pci_bus, devfn, PCI_IO_LIMIT, temp_byte); 2336 } else { 2337 kfree(hold_IO_node); 2338 hold_IO_node = NULL; 2339 } 2340 2341 /* If we have memory resources copy them and fill in the bridge's 2342 * memory range registers. Otherwise, fill in the range 2343 * registers with values that disable them. 2344 */ 2345 if (mem_node) { 2346 memcpy(hold_mem_node, mem_node, sizeof(struct pci_resource)); 2347 mem_node->next = NULL; 2348 2349 /* set Mem base and Limit registers */ 2350 RES_CHECK(mem_node->base, 16); 2351 temp_word = (u32)(mem_node->base >> 16); 2352 rc = pci_bus_write_config_word(pci_bus, devfn, PCI_MEMORY_BASE, temp_word); 2353 2354 RES_CHECK(mem_node->base + mem_node->length - 1, 16); 2355 temp_word = (u32)((mem_node->base + mem_node->length - 1) >> 16); 2356 rc = pci_bus_write_config_word(pci_bus, devfn, PCI_MEMORY_LIMIT, temp_word); 2357 } else { 2358 temp_word = 0xFFFF; 2359 rc = pci_bus_write_config_word(pci_bus, devfn, PCI_MEMORY_BASE, temp_word); 2360 2361 temp_word = 0x0000; 2362 rc = pci_bus_write_config_word(pci_bus, devfn, PCI_MEMORY_LIMIT, temp_word); 2363 2364 kfree(hold_mem_node); 2365 hold_mem_node = NULL; 2366 } 2367 2368 /* If we have prefetchable memory resources copy them and 2369 * fill in the bridge's memory range registers. Otherwise, 2370 * fill in the range registers with values that disable them. 2371 */ 2372 if (p_mem_node) { 2373 memcpy(hold_p_mem_node, p_mem_node, sizeof(struct pci_resource)); 2374 p_mem_node->next = NULL; 2375 2376 /* set Pre Mem base and Limit registers */ 2377 RES_CHECK(p_mem_node->base, 16); 2378 temp_word = (u32)(p_mem_node->base >> 16); 2379 rc = pci_bus_write_config_word(pci_bus, devfn, PCI_PREF_MEMORY_BASE, temp_word); 2380 2381 RES_CHECK(p_mem_node->base + p_mem_node->length - 1, 16); 2382 temp_word = (u32)((p_mem_node->base + p_mem_node->length - 1) >> 16); 2383 rc = pci_bus_write_config_word(pci_bus, devfn, PCI_PREF_MEMORY_LIMIT, temp_word); 2384 } else { 2385 temp_word = 0xFFFF; 2386 rc = pci_bus_write_config_word(pci_bus, devfn, PCI_PREF_MEMORY_BASE, temp_word); 2387 2388 temp_word = 0x0000; 2389 rc = pci_bus_write_config_word(pci_bus, devfn, PCI_PREF_MEMORY_LIMIT, temp_word); 2390 2391 kfree(hold_p_mem_node); 2392 hold_p_mem_node = NULL; 2393 } 2394 2395 /* Adjust this to compensate for extra adjustment in first loop */ 2396 irqs.barber_pole--; 2397 2398 rc = 0; 2399 2400 /* Here we actually find the devices and configure them */ 2401 for (device = 0; (device <= 0x1F) && !rc; device++) { 2402 irqs.barber_pole = (irqs.barber_pole + 1) & 0x03; 2403 2404 ID = 0xFFFFFFFF; 2405 pci_bus->number = hold_bus_node->base; 2406 pci_bus_read_config_dword(pci_bus, PCI_DEVFN(device, 0), 2407 PCI_VENDOR_ID, &ID); 2408 pci_bus->number = func->bus; 2409 2410 if (ID != 0xFFFFFFFF) { /* device Present */ 2411 /* Setup slot structure. */ 2412 new_slot = shpchp_slot_create(hold_bus_node->base); 2413 2414 if (new_slot == NULL) { 2415 /* Out of memory */ 2416 rc = -ENOMEM; 2417 continue; 2418 } 2419 2420 new_slot->bus = hold_bus_node->base; 2421 new_slot->device = device; 2422 new_slot->function = 0; 2423 new_slot->is_a_board = 1; 2424 new_slot->status = 0; 2425 2426 rc = configure_new_device(ctrl, new_slot, 1, &temp_resources, func->bus, func->device); 2427 dbg("configure_new_device rc=0x%x\n",rc); 2428 } /* End of IF (device in slot?) */ 2429 } /* End of FOR loop */ 2430 2431 if (rc) { 2432 shpchp_destroy_resource_list(&temp_resources); 2433 2434 return_resource(&(resources->bus_head), hold_bus_node); 2435 return_resource(&(resources->io_head), hold_IO_node); 2436 return_resource(&(resources->mem_head), hold_mem_node); 2437 return_resource(&(resources->p_mem_head), hold_p_mem_node); 2438 return(rc); 2439 } 2440 2441 /* save the interrupt routing information */ 2442 if (resources->irqs) { 2443 resources->irqs->interrupt[0] = irqs.interrupt[0]; 2444 resources->irqs->interrupt[1] = irqs.interrupt[1]; 2445 resources->irqs->interrupt[2] = irqs.interrupt[2]; 2446 resources->irqs->interrupt[3] = irqs.interrupt[3]; 2447 resources->irqs->valid_INT = irqs.valid_INT; 2448 } else if (!behind_bridge) { 2449 /* We need to hook up the interrupts here */ 2450 for (cloop = 0; cloop < 4; cloop++) { 2451 if (irqs.valid_INT & (0x01 << cloop)) { 2452 rc = shpchp_set_irq(func->bus, func->device, 2453 0x0A + cloop, irqs.interrupt[cloop]); 2454 if (rc) { 2455 shpchp_destroy_resource_list (&temp_resources); 2456 return_resource(&(resources->bus_head), hold_bus_node); 2457 return_resource(&(resources->io_head), hold_IO_node); 2458 return_resource(&(resources->mem_head), hold_mem_node); 2459 return_resource(&(resources->p_mem_head), hold_p_mem_node); 2460 return rc; 2461 } 2462 } 2463 } /* end of for loop */ 2464 } 2465 2466 /* Return unused bus resources 2467 * First use the temporary node to store information for the board 2468 */ 2469 if (hold_bus_node && bus_node && temp_resources.bus_head) { 2470 hold_bus_node->length = bus_node->base - hold_bus_node->base; 2471 2472 hold_bus_node->next = func->bus_head; 2473 func->bus_head = hold_bus_node; 2474 2475 temp_byte = (u8)(temp_resources.bus_head->base - 1); 2476 2477 /* set subordinate bus */ 2478 dbg("re-set subordinate bus = 0x%x\n", temp_byte); 2479 rc = pci_bus_write_config_byte (pci_bus, devfn, PCI_SUBORDINATE_BUS, temp_byte); 2480 2481 if (temp_resources.bus_head->length == 0) { 2482 kfree(temp_resources.bus_head); 2483 temp_resources.bus_head = NULL; 2484 } else { 2485 dbg("return bus res of b:d(0x%x:%x) base:len(0x%x:%x)\n", 2486 func->bus, func->device, temp_resources.bus_head->base, temp_resources.bus_head->length); 2487 return_resource(&(resources->bus_head), temp_resources.bus_head); 2488 } 2489 } 2490 2491 /* If we have IO space available and there is some left, 2492 * return the unused portion 2493 */ 2494 if (hold_IO_node && temp_resources.io_head) { 2495 io_node = do_pre_bridge_resource_split(&(temp_resources.io_head), 2496 &hold_IO_node, 0x1000); 2497 2498 /* Check if we were able to split something off */ 2499 if (io_node) { 2500 hold_IO_node->base = io_node->base + io_node->length; 2501 2502 RES_CHECK(hold_IO_node->base, 8); 2503 temp_byte = (u8)((hold_IO_node->base) >> 8); 2504 rc = pci_bus_write_config_byte (pci_bus, devfn, PCI_IO_BASE, temp_byte); 2505 2506 return_resource(&(resources->io_head), io_node); 2507 } 2508 2509 io_node = do_bridge_resource_split(&(temp_resources.io_head), 0x1000); 2510 2511 /* Check if we were able to split something off */ 2512 if (io_node) { 2513 /* First use the temporary node to store information for the board */ 2514 hold_IO_node->length = io_node->base - hold_IO_node->base; 2515 2516 /* If we used any, add it to the board's list */ 2517 if (hold_IO_node->length) { 2518 hold_IO_node->next = func->io_head; 2519 func->io_head = hold_IO_node; 2520 2521 RES_CHECK(io_node->base - 1, 8); 2522 temp_byte = (u8)((io_node->base - 1) >> 8); 2523 rc = pci_bus_write_config_byte (pci_bus, devfn, PCI_IO_LIMIT, temp_byte); 2524 2525 return_resource(&(resources->io_head), io_node); 2526 } else { 2527 /* it doesn't need any IO */ 2528 temp_byte = 0x00; 2529 rc = pci_bus_write_config_byte(pci_bus, devfn, PCI_IO_LIMIT, temp_byte); 2530 2531 return_resource(&(resources->io_head), io_node); 2532 kfree(hold_IO_node); 2533 } 2534 } else { 2535 /* it used most of the range */ 2536 hold_IO_node->next = func->io_head; 2537 func->io_head = hold_IO_node; 2538 } 2539 } else if (hold_IO_node) { 2540 /* it used the whole range */ 2541 hold_IO_node->next = func->io_head; 2542 func->io_head = hold_IO_node; 2543 } 2544 2545 /* If we have memory space available and there is some left, 2546 * return the unused portion 2547 */ 2548 if (hold_mem_node && temp_resources.mem_head) { 2549 mem_node = do_pre_bridge_resource_split(&(temp_resources.mem_head), &hold_mem_node, 0x100000L); 2550 2551 /* Check if we were able to split something off */ 2552 if (mem_node) { 2553 hold_mem_node->base = mem_node->base + mem_node->length; 2554 2555 RES_CHECK(hold_mem_node->base, 16); 2556 temp_word = (u32)((hold_mem_node->base) >> 16); 2557 rc = pci_bus_write_config_word (pci_bus, devfn, PCI_MEMORY_BASE, temp_word); 2558 2559 return_resource(&(resources->mem_head), mem_node); 2560 } 2561 2562 mem_node = do_bridge_resource_split(&(temp_resources.mem_head), 0x100000L); 2563 2564 /* Check if we were able to split something off */ 2565 if (mem_node) { 2566 /* First use the temporary node to store information for the board */ 2567 hold_mem_node->length = mem_node->base - hold_mem_node->base; 2568 2569 if (hold_mem_node->length) { 2570 hold_mem_node->next = func->mem_head; 2571 func->mem_head = hold_mem_node; 2572 2573 /* configure end address */ 2574 RES_CHECK(mem_node->base - 1, 16); 2575 temp_word = (u32)((mem_node->base - 1) >> 16); 2576 rc = pci_bus_write_config_word (pci_bus, devfn, PCI_MEMORY_LIMIT, temp_word); 2577 2578 /* Return unused resources to the pool */ 2579 return_resource(&(resources->mem_head), mem_node); 2580 } else { 2581 /* it doesn't need any Mem */ 2582 temp_word = 0x0000; 2583 rc = pci_bus_write_config_word (pci_bus, devfn, PCI_MEMORY_LIMIT, temp_word); 2584 2585 return_resource(&(resources->mem_head), mem_node); 2586 kfree(hold_mem_node); 2587 } 2588 } else { 2589 /* it used most of the range */ 2590 hold_mem_node->next = func->mem_head; 2591 func->mem_head = hold_mem_node; 2592 } 2593 } else if (hold_mem_node) { 2594 /* it used the whole range */ 2595 hold_mem_node->next = func->mem_head; 2596 func->mem_head = hold_mem_node; 2597 } 2598 2599 /* If we have prefetchable memory space available and there is some 2600 * left at the end, return the unused portion 2601 */ 2602 if (hold_p_mem_node && temp_resources.p_mem_head) { 2603 p_mem_node = do_pre_bridge_resource_split(&(temp_resources.p_mem_head), 2604 &hold_p_mem_node, 0x100000L); 2605 2606 /* Check if we were able to split something off */ 2607 if (p_mem_node) { 2608 hold_p_mem_node->base = p_mem_node->base + p_mem_node->length; 2609 2610 RES_CHECK(hold_p_mem_node->base, 16); 2611 temp_word = (u32)((hold_p_mem_node->base) >> 16); 2612 rc = pci_bus_write_config_word (pci_bus, devfn, PCI_PREF_MEMORY_BASE, temp_word); 2613 2614 return_resource(&(resources->p_mem_head), p_mem_node); 2615 } 2616 2617 p_mem_node = do_bridge_resource_split(&(temp_resources.p_mem_head), 0x100000L); 2618 2619 /* Check if we were able to split something off */ 2620 if (p_mem_node) { 2621 /* First use the temporary node to store information for the board */ 2622 hold_p_mem_node->length = p_mem_node->base - hold_p_mem_node->base; 2623 2624 /* If we used any, add it to the board's list */ 2625 if (hold_p_mem_node->length) { 2626 hold_p_mem_node->next = func->p_mem_head; 2627 func->p_mem_head = hold_p_mem_node; 2628 2629 RES_CHECK(p_mem_node->base - 1, 16); 2630 temp_word = (u32)((p_mem_node->base - 1) >> 16); 2631 rc = pci_bus_write_config_word (pci_bus, devfn, PCI_PREF_MEMORY_LIMIT, temp_word); 2632 2633 return_resource(&(resources->p_mem_head), p_mem_node); 2634 } else { 2635 /* it doesn't need any PMem */ 2636 temp_word = 0x0000; 2637 rc = pci_bus_write_config_word (pci_bus, devfn, PCI_PREF_MEMORY_LIMIT, temp_word); 2638 2639 return_resource(&(resources->p_mem_head), p_mem_node); 2640 kfree(hold_p_mem_node); 2641 } 2642 } else { 2643 /* it used the most of the range */ 2644 hold_p_mem_node->next = func->p_mem_head; 2645 func->p_mem_head = hold_p_mem_node; 2646 } 2647 } else if (hold_p_mem_node) { 2648 /* it used the whole range */ 2649 hold_p_mem_node->next = func->p_mem_head; 2650 func->p_mem_head = hold_p_mem_node; 2651 } 2652 2653 /* We should be configuring an IRQ and the bridge's base address 2654 * registers if it needs them. Although we have never seen such 2655 * a device 2656 */ 2657 2658 shpchprm_enable_card(ctrl, func, PCI_HEADER_TYPE_BRIDGE); 2659 2660 dbg("PCI Bridge Hot-Added s:b:d:f(%02x:%02x:%02x:%02x)\n", ctrl->seg, func->bus, func->device, func->function); 2661 } else if ((temp_byte & 0x7F) == PCI_HEADER_TYPE_NORMAL) { 2662 /* Standard device */ 2663 u64 base64; 2664 rc = pci_bus_read_config_byte (pci_bus, devfn, 0x0B, &class_code); 2665 2666 if (class_code == PCI_BASE_CLASS_DISPLAY) 2667 return (DEVICE_TYPE_NOT_SUPPORTED); 2668 2669 /* Figure out IO and memory needs */ 2670 for (cloop = PCI_BASE_ADDRESS_0; cloop <= PCI_BASE_ADDRESS_5; cloop += 4) { 2671 temp_register = 0xFFFFFFFF; 2672 2673 rc = pci_bus_write_config_dword (pci_bus, devfn, cloop, temp_register); 2674 rc = pci_bus_read_config_dword(pci_bus, devfn, cloop, &temp_register); 2675 dbg("Bar[%x]=0x%x on bus:dev:func(0x%x:%x:%x)\n", cloop, temp_register, func->bus, func->device, 2676 func->function); 2677 2678 if (!temp_register) 2679 continue; 2680 2681 base64 = 0L; 2682 if (temp_register & PCI_BASE_ADDRESS_SPACE_IO) { 2683 /* Map IO */ 2684 2685 /* set base = amount of IO space */ 2686 base = temp_register & 0xFFFFFFFC; 2687 base = ~base + 1; 2688 2689 dbg("NEED IO length(0x%x)\n", base); 2690 io_node = get_io_resource(&(resources->io_head),(ulong)base); 2691 2692 /* allocate the resource to the board */ 2693 if (io_node) { 2694 dbg("Got IO base=0x%x(length=0x%x)\n", io_node->base, io_node->length); 2695 base = (u32)io_node->base; 2696 io_node->next = func->io_head; 2697 func->io_head = io_node; 2698 } else { 2699 err("Got NO IO resource(length=0x%x)\n", base); 2700 return -ENOMEM; 2701 } 2702 } else { /* map MEM */ 2703 int prefetchable = 1; 2704 struct pci_resource **res_node = &func->p_mem_head; 2705 char *res_type_str = "PMEM"; 2706 u32 temp_register2; 2707 2708 if (!(temp_register & PCI_BASE_ADDRESS_MEM_PREFETCH)) { 2709 prefetchable = 0; 2710 res_node = &func->mem_head; 2711 res_type_str++; 2712 } 2713 2714 base = temp_register & 0xFFFFFFF0; 2715 base = ~base + 1; 2716 2717 switch (temp_register & PCI_BASE_ADDRESS_MEM_TYPE_MASK) { 2718 case PCI_BASE_ADDRESS_MEM_TYPE_32: 2719 dbg("NEED 32 %s bar=0x%x(length=0x%x)\n", res_type_str, temp_register, base); 2720 2721 if (prefetchable && resources->p_mem_head) 2722 mem_node=get_resource(&(resources->p_mem_head), (ulong)base); 2723 else { 2724 if (prefetchable) 2725 dbg("using MEM for PMEM\n"); 2726 mem_node=get_resource(&(resources->mem_head), (ulong)base); 2727 } 2728 2729 /* allocate the resource to the board */ 2730 if (mem_node) { 2731 base = (u32)mem_node->base; 2732 mem_node->next = *res_node; 2733 *res_node = mem_node; 2734 dbg("Got 32 %s base=0x%x(length=0x%x)\n", res_type_str, mem_node->base, 2735 mem_node->length); 2736 } else { 2737 err("Got NO 32 %s resource(length=0x%x)\n", res_type_str, base); 2738 return -ENOMEM; 2739 } 2740 break; 2741 case PCI_BASE_ADDRESS_MEM_TYPE_64: 2742 rc = pci_bus_read_config_dword(pci_bus, devfn, cloop+4, &temp_register2); 2743 dbg("NEED 64 %s bar=0x%x:%x(length=0x%x)\n", res_type_str, temp_register2, 2744 temp_register, base); 2745 2746 if (prefetchable && resources->p_mem_head) 2747 mem_node = get_resource(&(resources->p_mem_head), (ulong)base); 2748 else { 2749 if (prefetchable) 2750 dbg("using MEM for PMEM\n"); 2751 mem_node = get_resource(&(resources->mem_head), (ulong)base); 2752 } 2753 2754 /* allocate the resource to the board */ 2755 if (mem_node) { 2756 base64 = mem_node->base; 2757 mem_node->next = *res_node; 2758 *res_node = mem_node; 2759 dbg("Got 64 %s base=0x%x:%x(length=%x)\n", res_type_str, (u32)(base64 >> 32), 2760 (u32)base64, mem_node->length); 2761 } else { 2762 err("Got NO 64 %s resource(length=0x%x)\n", res_type_str, base); 2763 return -ENOMEM; 2764 } 2765 break; 2766 default: 2767 dbg("reserved BAR type=0x%x\n", temp_register); 2768 break; 2769 } 2770 2771 } 2772 2773 if (base64) { 2774 rc = pci_bus_write_config_dword(pci_bus, devfn, cloop, (u32)base64); 2775 cloop += 4; 2776 base64 >>= 32; 2777 2778 if (base64) { 2779 dbg("%s: high dword of base64(0x%x) set to 0\n", __FUNCTION__, (u32)base64); 2780 base64 = 0x0L; 2781 } 2782 2783 rc = pci_bus_write_config_dword(pci_bus, devfn, cloop, (u32)base64); 2784 } else { 2785 rc = pci_bus_write_config_dword(pci_bus, devfn, cloop, base); 2786 } 2787 } /* End of base register loop */ 2788 2789 #if defined(CONFIG_X86_64) 2790 /* Figure out which interrupt pin this function uses */ 2791 rc = pci_bus_read_config_byte (pci_bus, devfn, PCI_INTERRUPT_PIN, &temp_byte); 2792 2793 /* If this function needs an interrupt and we are behind a bridge 2794 and the pin is tied to something that's alread mapped, 2795 set this one the same 2796 */ 2797 if (temp_byte && resources->irqs && 2798 (resources->irqs->valid_INT & 2799 (0x01 << ((temp_byte + resources->irqs->barber_pole - 1) & 0x03)))) { 2800 /* We have to share with something already set up */ 2801 IRQ = resources->irqs->interrupt[(temp_byte + resources->irqs->barber_pole - 1) & 0x03]; 2802 } else { 2803 /* Program IRQ based on card type */ 2804 rc = pci_bus_read_config_byte (pci_bus, devfn, 0x0B, &class_code); 2805 2806 if (class_code == PCI_BASE_CLASS_STORAGE) { 2807 IRQ = shpchp_disk_irq; 2808 } else { 2809 IRQ = shpchp_nic_irq; 2810 } 2811 } 2812 2813 /* IRQ Line */ 2814 rc = pci_bus_write_config_byte (pci_bus, devfn, PCI_INTERRUPT_LINE, IRQ); 2815 2816 if (!behind_bridge) { 2817 rc = shpchp_set_irq(func->bus, func->device, temp_byte + 0x09, IRQ); 2818 if (rc) 2819 return(1); 2820 } else { 2821 /* TBD - this code may also belong in the other clause of this If statement */ 2822 resources->irqs->interrupt[(temp_byte + resources->irqs->barber_pole - 1) & 0x03] = IRQ; 2823 resources->irqs->valid_INT |= 0x01 << (temp_byte + resources->irqs->barber_pole - 1) & 0x03; 2824 } 2825 #endif 2826 /* Disable ROM base Address */ 2827 temp_word = 0x00L; 2828 rc = pci_bus_write_config_word (pci_bus, devfn, PCI_ROM_ADDRESS, temp_word); 2829 2830 /* Set HP parameters (Cache Line Size, Latency Timer) */ 2831 rc = shpchprm_set_hpp(ctrl, func, PCI_HEADER_TYPE_NORMAL); 2832 if (rc) 2833 return rc; 2834 2835 shpchprm_enable_card(ctrl, func, PCI_HEADER_TYPE_NORMAL); 2836 2837 dbg("PCI function Hot-Added s:b:d:f(%02x:%02x:%02x:%02x)\n", ctrl->seg, func->bus, func->device, func->function); 2838 } /* End of Not-A-Bridge else */ 2839 else { 2840 /* It's some strange type of PCI adapter (Cardbus?) */ 2841 return(DEVICE_TYPE_NOT_SUPPORTED); 2842 } 2843 2844 func->configured = 1; 2845 2846 return 0; 2847 } 2848 2849