1 /* 2 * IBM Hot Plug Controller Driver 3 * 4 * Written By: Chuck Cole, Jyoti Shah, Tong Yu, Irene Zubarev, IBM Corporation 5 * 6 * Copyright (C) 2001,2003 Greg Kroah-Hartman (greg@kroah.com) 7 * Copyright (C) 2001-2003 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/init.h> 31 #include <linux/module.h> 32 #include <linux/slab.h> 33 #include <linux/pci.h> 34 #include <linux/interrupt.h> 35 #include <linux/delay.h> 36 #include <linux/wait.h> 37 #include "../pci.h" 38 #include <asm/pci_x86.h> /* for struct irq_routing_table */ 39 #include "ibmphp.h" 40 41 #define attn_on(sl) ibmphp_hpc_writeslot (sl, HPC_SLOT_ATTNON) 42 #define attn_off(sl) ibmphp_hpc_writeslot (sl, HPC_SLOT_ATTNOFF) 43 #define attn_LED_blink(sl) ibmphp_hpc_writeslot (sl, HPC_SLOT_BLINKLED) 44 #define get_ctrl_revision(sl, rev) ibmphp_hpc_readslot (sl, READ_REVLEVEL, rev) 45 #define get_hpc_options(sl, opt) ibmphp_hpc_readslot (sl, READ_HPCOPTIONS, opt) 46 47 #define DRIVER_VERSION "0.6" 48 #define DRIVER_DESC "IBM Hot Plug PCI Controller Driver" 49 50 int ibmphp_debug; 51 52 static bool debug; 53 module_param(debug, bool, S_IRUGO | S_IWUSR); 54 MODULE_PARM_DESC (debug, "Debugging mode enabled or not"); 55 MODULE_LICENSE ("GPL"); 56 MODULE_DESCRIPTION (DRIVER_DESC); 57 58 struct pci_bus *ibmphp_pci_bus; 59 static int max_slots; 60 61 static int irqs[16]; /* PIC mode IRQs we're using so far (in case MPS 62 * tables don't provide default info for empty slots */ 63 64 static int init_flag; 65 66 /* 67 static int get_max_adapter_speed_1 (struct hotplug_slot *, u8 *, u8); 68 69 static inline int get_max_adapter_speed (struct hotplug_slot *hs, u8 *value) 70 { 71 return get_max_adapter_speed_1 (hs, value, 1); 72 } 73 */ 74 static inline int get_cur_bus_info(struct slot **sl) 75 { 76 int rc = 1; 77 struct slot * slot_cur = *sl; 78 79 debug("options = %x\n", slot_cur->ctrl->options); 80 debug("revision = %x\n", slot_cur->ctrl->revision); 81 82 if (READ_BUS_STATUS(slot_cur->ctrl)) 83 rc = ibmphp_hpc_readslot(slot_cur, READ_BUSSTATUS, NULL); 84 85 if (rc) 86 return rc; 87 88 slot_cur->bus_on->current_speed = CURRENT_BUS_SPEED(slot_cur->busstatus); 89 if (READ_BUS_MODE(slot_cur->ctrl)) 90 slot_cur->bus_on->current_bus_mode = 91 CURRENT_BUS_MODE(slot_cur->busstatus); 92 else 93 slot_cur->bus_on->current_bus_mode = 0xFF; 94 95 debug("busstatus = %x, bus_speed = %x, bus_mode = %x\n", 96 slot_cur->busstatus, 97 slot_cur->bus_on->current_speed, 98 slot_cur->bus_on->current_bus_mode); 99 100 *sl = slot_cur; 101 return 0; 102 } 103 104 static inline int slot_update(struct slot **sl) 105 { 106 int rc; 107 rc = ibmphp_hpc_readslot(*sl, READ_ALLSTAT, NULL); 108 if (rc) 109 return rc; 110 if (!init_flag) 111 rc = get_cur_bus_info(sl); 112 return rc; 113 } 114 115 static int __init get_max_slots (void) 116 { 117 struct slot * slot_cur; 118 struct list_head * tmp; 119 u8 slot_count = 0; 120 121 list_for_each(tmp, &ibmphp_slot_head) { 122 slot_cur = list_entry(tmp, struct slot, ibm_slot_list); 123 /* sometimes the hot-pluggable slots start with 4 (not always from 1) */ 124 slot_count = max(slot_count, slot_cur->number); 125 } 126 return slot_count; 127 } 128 129 /* This routine will put the correct slot->device information per slot. It's 130 * called from initialization of the slot structures. It will also assign 131 * interrupt numbers per each slot. 132 * Parameters: struct slot 133 * Returns 0 or errors 134 */ 135 int ibmphp_init_devno(struct slot **cur_slot) 136 { 137 struct irq_routing_table *rtable; 138 int len; 139 int loop; 140 int i; 141 142 rtable = pcibios_get_irq_routing_table(); 143 if (!rtable) { 144 err("no BIOS routing table...\n"); 145 return -ENOMEM; 146 } 147 148 len = (rtable->size - sizeof(struct irq_routing_table)) / 149 sizeof(struct irq_info); 150 151 if (!len) { 152 kfree(rtable); 153 return -1; 154 } 155 for (loop = 0; loop < len; loop++) { 156 if ((*cur_slot)->number == rtable->slots[loop].slot && 157 (*cur_slot)->bus == rtable->slots[loop].bus) { 158 struct io_apic_irq_attr irq_attr; 159 160 (*cur_slot)->device = PCI_SLOT(rtable->slots[loop].devfn); 161 for (i = 0; i < 4; i++) 162 (*cur_slot)->irq[i] = IO_APIC_get_PCI_irq_vector((int) (*cur_slot)->bus, 163 (int) (*cur_slot)->device, i, 164 &irq_attr); 165 166 debug("(*cur_slot)->irq[0] = %x\n", 167 (*cur_slot)->irq[0]); 168 debug("(*cur_slot)->irq[1] = %x\n", 169 (*cur_slot)->irq[1]); 170 debug("(*cur_slot)->irq[2] = %x\n", 171 (*cur_slot)->irq[2]); 172 debug("(*cur_slot)->irq[3] = %x\n", 173 (*cur_slot)->irq[3]); 174 175 debug("rtable->exclusive_irqs = %x\n", 176 rtable->exclusive_irqs); 177 debug("rtable->slots[loop].irq[0].bitmap = %x\n", 178 rtable->slots[loop].irq[0].bitmap); 179 debug("rtable->slots[loop].irq[1].bitmap = %x\n", 180 rtable->slots[loop].irq[1].bitmap); 181 debug("rtable->slots[loop].irq[2].bitmap = %x\n", 182 rtable->slots[loop].irq[2].bitmap); 183 debug("rtable->slots[loop].irq[3].bitmap = %x\n", 184 rtable->slots[loop].irq[3].bitmap); 185 186 debug("rtable->slots[loop].irq[0].link = %x\n", 187 rtable->slots[loop].irq[0].link); 188 debug("rtable->slots[loop].irq[1].link = %x\n", 189 rtable->slots[loop].irq[1].link); 190 debug("rtable->slots[loop].irq[2].link = %x\n", 191 rtable->slots[loop].irq[2].link); 192 debug("rtable->slots[loop].irq[3].link = %x\n", 193 rtable->slots[loop].irq[3].link); 194 debug("end of init_devno\n"); 195 kfree(rtable); 196 return 0; 197 } 198 } 199 200 kfree(rtable); 201 return -1; 202 } 203 204 static inline int power_on(struct slot *slot_cur) 205 { 206 u8 cmd = HPC_SLOT_ON; 207 int retval; 208 209 retval = ibmphp_hpc_writeslot(slot_cur, cmd); 210 if (retval) { 211 err("power on failed\n"); 212 return retval; 213 } 214 if (CTLR_RESULT(slot_cur->ctrl->status)) { 215 err("command not completed successfully in power_on\n"); 216 return -EIO; 217 } 218 msleep(3000); /* For ServeRAID cards, and some 66 PCI */ 219 return 0; 220 } 221 222 static inline int power_off(struct slot *slot_cur) 223 { 224 u8 cmd = HPC_SLOT_OFF; 225 int retval; 226 227 retval = ibmphp_hpc_writeslot(slot_cur, cmd); 228 if (retval) { 229 err("power off failed\n"); 230 return retval; 231 } 232 if (CTLR_RESULT(slot_cur->ctrl->status)) { 233 err("command not completed successfully in power_off\n"); 234 retval = -EIO; 235 } 236 return retval; 237 } 238 239 static int set_attention_status(struct hotplug_slot *hotplug_slot, u8 value) 240 { 241 int rc = 0; 242 struct slot *pslot; 243 u8 cmd = 0x00; /* avoid compiler warning */ 244 245 debug("set_attention_status - Entry hotplug_slot[%lx] value[%x]\n", 246 (ulong) hotplug_slot, value); 247 ibmphp_lock_operations(); 248 249 250 if (hotplug_slot) { 251 switch (value) { 252 case HPC_SLOT_ATTN_OFF: 253 cmd = HPC_SLOT_ATTNOFF; 254 break; 255 case HPC_SLOT_ATTN_ON: 256 cmd = HPC_SLOT_ATTNON; 257 break; 258 case HPC_SLOT_ATTN_BLINK: 259 cmd = HPC_SLOT_BLINKLED; 260 break; 261 default: 262 rc = -ENODEV; 263 err("set_attention_status - Error : invalid input [%x]\n", 264 value); 265 break; 266 } 267 if (rc == 0) { 268 pslot = hotplug_slot->private; 269 if (pslot) 270 rc = ibmphp_hpc_writeslot(pslot, cmd); 271 else 272 rc = -ENODEV; 273 } 274 } else 275 rc = -ENODEV; 276 277 ibmphp_unlock_operations(); 278 279 debug("set_attention_status - Exit rc[%d]\n", rc); 280 return rc; 281 } 282 283 static int get_attention_status(struct hotplug_slot *hotplug_slot, u8 * value) 284 { 285 int rc = -ENODEV; 286 struct slot *pslot; 287 struct slot myslot; 288 289 debug("get_attention_status - Entry hotplug_slot[%lx] pvalue[%lx]\n", 290 (ulong) hotplug_slot, (ulong) value); 291 292 ibmphp_lock_operations(); 293 if (hotplug_slot) { 294 pslot = hotplug_slot->private; 295 if (pslot) { 296 memcpy(&myslot, pslot, sizeof(struct slot)); 297 rc = ibmphp_hpc_readslot(pslot, READ_SLOTSTATUS, 298 &(myslot.status)); 299 if (!rc) 300 rc = ibmphp_hpc_readslot(pslot, 301 READ_EXTSLOTSTATUS, 302 &(myslot.ext_status)); 303 if (!rc) 304 *value = SLOT_ATTN(myslot.status, 305 myslot.ext_status); 306 } 307 } 308 309 ibmphp_unlock_operations(); 310 debug("get_attention_status - Exit rc[%d] value[%x]\n", rc, *value); 311 return rc; 312 } 313 314 static int get_latch_status(struct hotplug_slot *hotplug_slot, u8 * value) 315 { 316 int rc = -ENODEV; 317 struct slot *pslot; 318 struct slot myslot; 319 320 debug("get_latch_status - Entry hotplug_slot[%lx] pvalue[%lx]\n", 321 (ulong) hotplug_slot, (ulong) value); 322 ibmphp_lock_operations(); 323 if (hotplug_slot) { 324 pslot = hotplug_slot->private; 325 if (pslot) { 326 memcpy(&myslot, pslot, sizeof(struct slot)); 327 rc = ibmphp_hpc_readslot(pslot, READ_SLOTSTATUS, 328 &(myslot.status)); 329 if (!rc) 330 *value = SLOT_LATCH(myslot.status); 331 } 332 } 333 334 ibmphp_unlock_operations(); 335 debug("get_latch_status - Exit rc[%d] rc[%x] value[%x]\n", 336 rc, rc, *value); 337 return rc; 338 } 339 340 341 static int get_power_status(struct hotplug_slot *hotplug_slot, u8 * value) 342 { 343 int rc = -ENODEV; 344 struct slot *pslot; 345 struct slot myslot; 346 347 debug("get_power_status - Entry hotplug_slot[%lx] pvalue[%lx]\n", 348 (ulong) hotplug_slot, (ulong) value); 349 ibmphp_lock_operations(); 350 if (hotplug_slot) { 351 pslot = hotplug_slot->private; 352 if (pslot) { 353 memcpy(&myslot, pslot, sizeof(struct slot)); 354 rc = ibmphp_hpc_readslot(pslot, READ_SLOTSTATUS, 355 &(myslot.status)); 356 if (!rc) 357 *value = SLOT_PWRGD(myslot.status); 358 } 359 } 360 361 ibmphp_unlock_operations(); 362 debug("get_power_status - Exit rc[%d] rc[%x] value[%x]\n", 363 rc, rc, *value); 364 return rc; 365 } 366 367 static int get_adapter_present(struct hotplug_slot *hotplug_slot, u8 * value) 368 { 369 int rc = -ENODEV; 370 struct slot *pslot; 371 u8 present; 372 struct slot myslot; 373 374 debug("get_adapter_status - Entry hotplug_slot[%lx] pvalue[%lx]\n", 375 (ulong) hotplug_slot, (ulong) value); 376 ibmphp_lock_operations(); 377 if (hotplug_slot) { 378 pslot = hotplug_slot->private; 379 if (pslot) { 380 memcpy(&myslot, pslot, sizeof(struct slot)); 381 rc = ibmphp_hpc_readslot(pslot, READ_SLOTSTATUS, 382 &(myslot.status)); 383 if (!rc) { 384 present = SLOT_PRESENT(myslot.status); 385 if (present == HPC_SLOT_EMPTY) 386 *value = 0; 387 else 388 *value = 1; 389 } 390 } 391 } 392 393 ibmphp_unlock_operations(); 394 debug("get_adapter_present - Exit rc[%d] value[%x]\n", rc, *value); 395 return rc; 396 } 397 398 static int get_max_bus_speed(struct slot *slot) 399 { 400 int rc; 401 u8 mode = 0; 402 enum pci_bus_speed speed; 403 struct pci_bus *bus = slot->hotplug_slot->pci_slot->bus; 404 405 debug("%s - Entry slot[%p]\n", __func__, slot); 406 407 ibmphp_lock_operations(); 408 mode = slot->supported_bus_mode; 409 speed = slot->supported_speed; 410 ibmphp_unlock_operations(); 411 412 switch (speed) { 413 case BUS_SPEED_33: 414 break; 415 case BUS_SPEED_66: 416 if (mode == BUS_MODE_PCIX) 417 speed += 0x01; 418 break; 419 case BUS_SPEED_100: 420 case BUS_SPEED_133: 421 speed += 0x01; 422 break; 423 default: 424 /* Note (will need to change): there would be soon 256, 512 also */ 425 rc = -ENODEV; 426 } 427 428 if (!rc) 429 bus->max_bus_speed = speed; 430 431 debug("%s - Exit rc[%d] speed[%x]\n", __func__, rc, speed); 432 return rc; 433 } 434 435 /* 436 static int get_max_adapter_speed_1(struct hotplug_slot *hotplug_slot, u8 * value, u8 flag) 437 { 438 int rc = -ENODEV; 439 struct slot *pslot; 440 struct slot myslot; 441 442 debug("get_max_adapter_speed_1 - Entry hotplug_slot[%lx] pvalue[%lx]\n", 443 (ulong)hotplug_slot, (ulong) value); 444 445 if (flag) 446 ibmphp_lock_operations(); 447 448 if (hotplug_slot && value) { 449 pslot = hotplug_slot->private; 450 if (pslot) { 451 memcpy(&myslot, pslot, sizeof(struct slot)); 452 rc = ibmphp_hpc_readslot(pslot, READ_SLOTSTATUS, 453 &(myslot.status)); 454 455 if (!(SLOT_LATCH (myslot.status)) && 456 (SLOT_PRESENT (myslot.status))) { 457 rc = ibmphp_hpc_readslot(pslot, 458 READ_EXTSLOTSTATUS, 459 &(myslot.ext_status)); 460 if (!rc) 461 *value = SLOT_SPEED(myslot.ext_status); 462 } else 463 *value = MAX_ADAPTER_NONE; 464 } 465 } 466 467 if (flag) 468 ibmphp_unlock_operations(); 469 470 debug("get_max_adapter_speed_1 - Exit rc[%d] value[%x]\n", rc, *value); 471 return rc; 472 } 473 474 static int get_bus_name(struct hotplug_slot *hotplug_slot, char * value) 475 { 476 int rc = -ENODEV; 477 struct slot *pslot = NULL; 478 479 debug("get_bus_name - Entry hotplug_slot[%lx]\n", (ulong)hotplug_slot); 480 481 ibmphp_lock_operations(); 482 483 if (hotplug_slot) { 484 pslot = hotplug_slot->private; 485 if (pslot) { 486 rc = 0; 487 snprintf(value, 100, "Bus %x", pslot->bus); 488 } 489 } else 490 rc = -ENODEV; 491 492 ibmphp_unlock_operations(); 493 debug("get_bus_name - Exit rc[%d] value[%x]\n", rc, *value); 494 return rc; 495 } 496 */ 497 498 /**************************************************************************** 499 * This routine will initialize the ops data structure used in the validate 500 * function. It will also power off empty slots that are powered on since BIOS 501 * leaves those on, albeit disconnected 502 ****************************************************************************/ 503 static int __init init_ops(void) 504 { 505 struct slot *slot_cur; 506 struct list_head *tmp; 507 int retval; 508 int rc; 509 510 list_for_each(tmp, &ibmphp_slot_head) { 511 slot_cur = list_entry(tmp, struct slot, ibm_slot_list); 512 513 if (!slot_cur) 514 return -ENODEV; 515 516 debug("BEFORE GETTING SLOT STATUS, slot # %x\n", 517 slot_cur->number); 518 if (slot_cur->ctrl->revision == 0xFF) 519 if (get_ctrl_revision(slot_cur, 520 &slot_cur->ctrl->revision)) 521 return -1; 522 523 if (slot_cur->bus_on->current_speed == 0xFF) 524 if (get_cur_bus_info(&slot_cur)) 525 return -1; 526 get_max_bus_speed(slot_cur); 527 528 if (slot_cur->ctrl->options == 0xFF) 529 if (get_hpc_options(slot_cur, &slot_cur->ctrl->options)) 530 return -1; 531 532 retval = slot_update(&slot_cur); 533 if (retval) 534 return retval; 535 536 debug("status = %x\n", slot_cur->status); 537 debug("ext_status = %x\n", slot_cur->ext_status); 538 debug("SLOT_POWER = %x\n", SLOT_POWER(slot_cur->status)); 539 debug("SLOT_PRESENT = %x\n", SLOT_PRESENT(slot_cur->status)); 540 debug("SLOT_LATCH = %x\n", SLOT_LATCH(slot_cur->status)); 541 542 if ((SLOT_PWRGD(slot_cur->status)) && 543 !(SLOT_PRESENT(slot_cur->status)) && 544 !(SLOT_LATCH(slot_cur->status))) { 545 debug("BEFORE POWER OFF COMMAND\n"); 546 rc = power_off(slot_cur); 547 if (rc) 548 return rc; 549 550 /* retval = slot_update(&slot_cur); 551 * if (retval) 552 * return retval; 553 * ibmphp_update_slot_info(slot_cur); 554 */ 555 } 556 } 557 init_flag = 0; 558 return 0; 559 } 560 561 /* This operation will check whether the slot is within the bounds and 562 * the operation is valid to perform on that slot 563 * Parameters: slot, operation 564 * Returns: 0 or error codes 565 */ 566 static int validate(struct slot *slot_cur, int opn) 567 { 568 int number; 569 int retval; 570 571 if (!slot_cur) 572 return -ENODEV; 573 number = slot_cur->number; 574 if ((number > max_slots) || (number < 0)) 575 return -EBADSLT; 576 debug("slot_number in validate is %d\n", slot_cur->number); 577 578 retval = slot_update(&slot_cur); 579 if (retval) 580 return retval; 581 582 switch (opn) { 583 case ENABLE: 584 if (!(SLOT_PWRGD(slot_cur->status)) && 585 (SLOT_PRESENT(slot_cur->status)) && 586 !(SLOT_LATCH(slot_cur->status))) 587 return 0; 588 break; 589 case DISABLE: 590 if ((SLOT_PWRGD(slot_cur->status)) && 591 (SLOT_PRESENT(slot_cur->status)) && 592 !(SLOT_LATCH(slot_cur->status))) 593 return 0; 594 break; 595 default: 596 break; 597 } 598 err("validate failed....\n"); 599 return -EINVAL; 600 } 601 602 /**************************************************************************** 603 * This routine is for updating the data structures in the hotplug core 604 * Parameters: struct slot 605 * Returns: 0 or error 606 ****************************************************************************/ 607 int ibmphp_update_slot_info(struct slot *slot_cur) 608 { 609 struct hotplug_slot_info *info; 610 struct pci_bus *bus = slot_cur->hotplug_slot->pci_slot->bus; 611 int rc; 612 u8 bus_speed; 613 u8 mode; 614 615 info = kmalloc(sizeof(struct hotplug_slot_info), GFP_KERNEL); 616 if (!info) { 617 err("out of system memory\n"); 618 return -ENOMEM; 619 } 620 621 info->power_status = SLOT_PWRGD(slot_cur->status); 622 info->attention_status = SLOT_ATTN(slot_cur->status, 623 slot_cur->ext_status); 624 info->latch_status = SLOT_LATCH(slot_cur->status); 625 if (!SLOT_PRESENT(slot_cur->status)) { 626 info->adapter_status = 0; 627 /* info->max_adapter_speed_status = MAX_ADAPTER_NONE; */ 628 } else { 629 info->adapter_status = 1; 630 /* get_max_adapter_speed_1(slot_cur->hotplug_slot, 631 &info->max_adapter_speed_status, 0); */ 632 } 633 634 bus_speed = slot_cur->bus_on->current_speed; 635 mode = slot_cur->bus_on->current_bus_mode; 636 637 switch (bus_speed) { 638 case BUS_SPEED_33: 639 break; 640 case BUS_SPEED_66: 641 if (mode == BUS_MODE_PCIX) 642 bus_speed += 0x01; 643 else if (mode == BUS_MODE_PCI) 644 ; 645 else 646 bus_speed = PCI_SPEED_UNKNOWN; 647 break; 648 case BUS_SPEED_100: 649 case BUS_SPEED_133: 650 bus_speed += 0x01; 651 break; 652 default: 653 bus_speed = PCI_SPEED_UNKNOWN; 654 } 655 656 bus->cur_bus_speed = bus_speed; 657 // To do: bus_names 658 659 rc = pci_hp_change_slot_info(slot_cur->hotplug_slot, info); 660 kfree(info); 661 return rc; 662 } 663 664 665 /****************************************************************************** 666 * This function will return the pci_func, given bus and devfunc, or NULL. It 667 * is called from visit routines 668 ******************************************************************************/ 669 670 static struct pci_func *ibm_slot_find(u8 busno, u8 device, u8 function) 671 { 672 struct pci_func *func_cur; 673 struct slot *slot_cur; 674 struct list_head * tmp; 675 list_for_each(tmp, &ibmphp_slot_head) { 676 slot_cur = list_entry(tmp, struct slot, ibm_slot_list); 677 if (slot_cur->func) { 678 func_cur = slot_cur->func; 679 while (func_cur) { 680 if ((func_cur->busno == busno) && 681 (func_cur->device == device) && 682 (func_cur->function == function)) 683 return func_cur; 684 func_cur = func_cur->next; 685 } 686 } 687 } 688 return NULL; 689 } 690 691 /************************************************************* 692 * This routine frees up memory used by struct slot, including 693 * the pointers to pci_func, bus, hotplug_slot, controller, 694 * and deregistering from the hotplug core 695 *************************************************************/ 696 static void free_slots(void) 697 { 698 struct slot *slot_cur; 699 struct list_head * tmp; 700 struct list_head * next; 701 702 debug("%s -- enter\n", __func__); 703 704 list_for_each_safe(tmp, next, &ibmphp_slot_head) { 705 slot_cur = list_entry(tmp, struct slot, ibm_slot_list); 706 pci_hp_deregister(slot_cur->hotplug_slot); 707 } 708 debug("%s -- exit\n", __func__); 709 } 710 711 static void ibm_unconfigure_device(struct pci_func *func) 712 { 713 struct pci_dev *temp; 714 u8 j; 715 716 debug("inside %s\n", __func__); 717 debug("func->device = %x, func->function = %x\n", 718 func->device, func->function); 719 debug("func->device << 3 | 0x0 = %x\n", func->device << 3 | 0x0); 720 721 for (j = 0; j < 0x08; j++) { 722 temp = pci_get_bus_and_slot(func->busno, (func->device << 3) | j); 723 if (temp) { 724 pci_stop_and_remove_bus_device(temp); 725 pci_dev_put(temp); 726 } 727 } 728 pci_dev_put(func->dev); 729 } 730 731 /* 732 * The following function is to fix kernel bug regarding 733 * getting bus entries, here we manually add those primary 734 * bus entries to kernel bus structure whenever apply 735 */ 736 static u8 bus_structure_fixup(u8 busno) 737 { 738 struct pci_bus *bus; 739 struct pci_dev *dev; 740 u16 l; 741 742 if (pci_find_bus(0, busno) || !(ibmphp_find_same_bus_num(busno))) 743 return 1; 744 745 bus = kmalloc(sizeof(*bus), GFP_KERNEL); 746 if (!bus) { 747 err("%s - out of memory\n", __func__); 748 return 1; 749 } 750 dev = kmalloc(sizeof(*dev), GFP_KERNEL); 751 if (!dev) { 752 kfree(bus); 753 err("%s - out of memory\n", __func__); 754 return 1; 755 } 756 757 bus->number = busno; 758 bus->ops = ibmphp_pci_bus->ops; 759 dev->bus = bus; 760 for (dev->devfn = 0; dev->devfn < 256; dev->devfn += 8) { 761 if (!pci_read_config_word(dev, PCI_VENDOR_ID, &l) && 762 (l != 0x0000) && (l != 0xffff)) { 763 debug("%s - Inside bus_structure_fixup()\n", 764 __func__); 765 pci_scan_bus(busno, ibmphp_pci_bus->ops, NULL); 766 break; 767 } 768 } 769 770 kfree(dev); 771 kfree(bus); 772 773 return 0; 774 } 775 776 static int ibm_configure_device(struct pci_func *func) 777 { 778 struct pci_bus *child; 779 int num; 780 int flag = 0; /* this is to make sure we don't double scan the bus, 781 for bridged devices primarily */ 782 783 if (!(bus_structure_fixup(func->busno))) 784 flag = 1; 785 if (func->dev == NULL) 786 func->dev = pci_get_bus_and_slot(func->busno, 787 PCI_DEVFN(func->device, func->function)); 788 789 if (func->dev == NULL) { 790 struct pci_bus *bus = pci_find_bus(0, func->busno); 791 if (!bus) 792 return 0; 793 794 num = pci_scan_slot(bus, 795 PCI_DEVFN(func->device, func->function)); 796 if (num) 797 pci_bus_add_devices(bus); 798 799 func->dev = pci_get_bus_and_slot(func->busno, 800 PCI_DEVFN(func->device, func->function)); 801 if (func->dev == NULL) { 802 err("ERROR... : pci_dev still NULL\n"); 803 return 0; 804 } 805 } 806 if (!(flag) && (func->dev->hdr_type == PCI_HEADER_TYPE_BRIDGE)) { 807 pci_hp_add_bridge(func->dev); 808 child = func->dev->subordinate; 809 if (child) 810 pci_bus_add_devices(child); 811 } 812 813 return 0; 814 } 815 816 /******************************************************* 817 * Returns whether the bus is empty or not 818 *******************************************************/ 819 static int is_bus_empty(struct slot * slot_cur) 820 { 821 int rc; 822 struct slot * tmp_slot; 823 u8 i = slot_cur->bus_on->slot_min; 824 825 while (i <= slot_cur->bus_on->slot_max) { 826 if (i == slot_cur->number) { 827 i++; 828 continue; 829 } 830 tmp_slot = ibmphp_get_slot_from_physical_num(i); 831 if (!tmp_slot) 832 return 0; 833 rc = slot_update(&tmp_slot); 834 if (rc) 835 return 0; 836 if (SLOT_PRESENT(tmp_slot->status) && 837 SLOT_PWRGD(tmp_slot->status)) 838 return 0; 839 i++; 840 } 841 return 1; 842 } 843 844 /*********************************************************** 845 * If the HPC permits and the bus currently empty, tries to set the 846 * bus speed and mode at the maximum card and bus capability 847 * Parameters: slot 848 * Returns: bus is set (0) or error code 849 ***********************************************************/ 850 static int set_bus(struct slot * slot_cur) 851 { 852 int rc; 853 u8 speed; 854 u8 cmd = 0x0; 855 int retval; 856 static struct pci_device_id ciobx[] = { 857 { PCI_DEVICE(PCI_VENDOR_ID_SERVERWORKS, 0x0101) }, 858 { }, 859 }; 860 861 debug("%s - entry slot # %d\n", __func__, slot_cur->number); 862 if (SET_BUS_STATUS(slot_cur->ctrl) && is_bus_empty(slot_cur)) { 863 rc = slot_update(&slot_cur); 864 if (rc) 865 return rc; 866 speed = SLOT_SPEED(slot_cur->ext_status); 867 debug("ext_status = %x, speed = %x\n", slot_cur->ext_status, speed); 868 switch (speed) { 869 case HPC_SLOT_SPEED_33: 870 cmd = HPC_BUS_33CONVMODE; 871 break; 872 case HPC_SLOT_SPEED_66: 873 if (SLOT_PCIX(slot_cur->ext_status)) { 874 if ((slot_cur->supported_speed >= BUS_SPEED_66) && 875 (slot_cur->supported_bus_mode == BUS_MODE_PCIX)) 876 cmd = HPC_BUS_66PCIXMODE; 877 else if (!SLOT_BUS_MODE(slot_cur->ext_status)) 878 /* if max slot/bus capability is 66 pci 879 and there's no bus mode mismatch, then 880 the adapter supports 66 pci */ 881 cmd = HPC_BUS_66CONVMODE; 882 else 883 cmd = HPC_BUS_33CONVMODE; 884 } else { 885 if (slot_cur->supported_speed >= BUS_SPEED_66) 886 cmd = HPC_BUS_66CONVMODE; 887 else 888 cmd = HPC_BUS_33CONVMODE; 889 } 890 break; 891 case HPC_SLOT_SPEED_133: 892 switch (slot_cur->supported_speed) { 893 case BUS_SPEED_33: 894 cmd = HPC_BUS_33CONVMODE; 895 break; 896 case BUS_SPEED_66: 897 if (slot_cur->supported_bus_mode == BUS_MODE_PCIX) 898 cmd = HPC_BUS_66PCIXMODE; 899 else 900 cmd = HPC_BUS_66CONVMODE; 901 break; 902 case BUS_SPEED_100: 903 cmd = HPC_BUS_100PCIXMODE; 904 break; 905 case BUS_SPEED_133: 906 /* This is to take care of the bug in CIOBX chip */ 907 if (pci_dev_present(ciobx)) 908 ibmphp_hpc_writeslot(slot_cur, 909 HPC_BUS_100PCIXMODE); 910 cmd = HPC_BUS_133PCIXMODE; 911 break; 912 default: 913 err("Wrong bus speed\n"); 914 return -ENODEV; 915 } 916 break; 917 default: 918 err("wrong slot speed\n"); 919 return -ENODEV; 920 } 921 debug("setting bus speed for slot %d, cmd %x\n", 922 slot_cur->number, cmd); 923 retval = ibmphp_hpc_writeslot(slot_cur, cmd); 924 if (retval) { 925 err("setting bus speed failed\n"); 926 return retval; 927 } 928 if (CTLR_RESULT(slot_cur->ctrl->status)) { 929 err("command not completed successfully in set_bus\n"); 930 return -EIO; 931 } 932 } 933 /* This is for x440, once Brandon fixes the firmware, 934 will not need this delay */ 935 msleep(1000); 936 debug("%s -Exit\n", __func__); 937 return 0; 938 } 939 940 /* This routine checks the bus limitations that the slot is on from the BIOS. 941 * This is used in deciding whether or not to power up the slot. 942 * (electrical/spec limitations. For example, >1 133 MHz or >2 66 PCI cards on 943 * same bus) 944 * Parameters: slot 945 * Returns: 0 = no limitations, -EINVAL = exceeded limitations on the bus 946 */ 947 static int check_limitations(struct slot *slot_cur) 948 { 949 u8 i; 950 struct slot * tmp_slot; 951 u8 count = 0; 952 u8 limitation = 0; 953 954 for (i = slot_cur->bus_on->slot_min; i <= slot_cur->bus_on->slot_max; i++) { 955 tmp_slot = ibmphp_get_slot_from_physical_num(i); 956 if (!tmp_slot) 957 return -ENODEV; 958 if ((SLOT_PWRGD(tmp_slot->status)) && 959 !(SLOT_CONNECT(tmp_slot->status))) 960 count++; 961 } 962 get_cur_bus_info(&slot_cur); 963 switch (slot_cur->bus_on->current_speed) { 964 case BUS_SPEED_33: 965 limitation = slot_cur->bus_on->slots_at_33_conv; 966 break; 967 case BUS_SPEED_66: 968 if (slot_cur->bus_on->current_bus_mode == BUS_MODE_PCIX) 969 limitation = slot_cur->bus_on->slots_at_66_pcix; 970 else 971 limitation = slot_cur->bus_on->slots_at_66_conv; 972 break; 973 case BUS_SPEED_100: 974 limitation = slot_cur->bus_on->slots_at_100_pcix; 975 break; 976 case BUS_SPEED_133: 977 limitation = slot_cur->bus_on->slots_at_133_pcix; 978 break; 979 } 980 981 if ((count + 1) > limitation) 982 return -EINVAL; 983 return 0; 984 } 985 986 static inline void print_card_capability(struct slot *slot_cur) 987 { 988 info("capability of the card is "); 989 if ((slot_cur->ext_status & CARD_INFO) == PCIX133) 990 info(" 133 MHz PCI-X\n"); 991 else if ((slot_cur->ext_status & CARD_INFO) == PCIX66) 992 info(" 66 MHz PCI-X\n"); 993 else if ((slot_cur->ext_status & CARD_INFO) == PCI66) 994 info(" 66 MHz PCI\n"); 995 else 996 info(" 33 MHz PCI\n"); 997 998 } 999 1000 /* This routine will power on the slot, configure the device(s) and find the 1001 * drivers for them. 1002 * Parameters: hotplug_slot 1003 * Returns: 0 or failure codes 1004 */ 1005 static int enable_slot(struct hotplug_slot *hs) 1006 { 1007 int rc, i, rcpr; 1008 struct slot *slot_cur; 1009 u8 function; 1010 struct pci_func *tmp_func; 1011 1012 ibmphp_lock_operations(); 1013 1014 debug("ENABLING SLOT........\n"); 1015 slot_cur = hs->private; 1016 1017 if ((rc = validate(slot_cur, ENABLE))) { 1018 err("validate function failed\n"); 1019 goto error_nopower; 1020 } 1021 1022 attn_LED_blink(slot_cur); 1023 1024 rc = set_bus(slot_cur); 1025 if (rc) { 1026 err("was not able to set the bus\n"); 1027 goto error_nopower; 1028 } 1029 1030 /*-----------------debugging------------------------------*/ 1031 get_cur_bus_info(&slot_cur); 1032 debug("the current bus speed right after set_bus = %x\n", 1033 slot_cur->bus_on->current_speed); 1034 /*----------------------------------------------------------*/ 1035 1036 rc = check_limitations(slot_cur); 1037 if (rc) { 1038 err("Adding this card exceeds the limitations of this bus.\n"); 1039 err("(i.e., >1 133MHz cards running on same bus, or " 1040 ">2 66 PCI cards running on same bus.\n"); 1041 err("Try hot-adding into another bus\n"); 1042 rc = -EINVAL; 1043 goto error_nopower; 1044 } 1045 1046 rc = power_on(slot_cur); 1047 1048 if (rc) { 1049 err("something wrong when powering up... please see below for details\n"); 1050 /* need to turn off before on, otherwise, blinking overwrites */ 1051 attn_off(slot_cur); 1052 attn_on(slot_cur); 1053 if (slot_update(&slot_cur)) { 1054 attn_off(slot_cur); 1055 attn_on(slot_cur); 1056 rc = -ENODEV; 1057 goto exit; 1058 } 1059 /* Check to see the error of why it failed */ 1060 if ((SLOT_POWER(slot_cur->status)) && 1061 !(SLOT_PWRGD(slot_cur->status))) 1062 err("power fault occurred trying to power up\n"); 1063 else if (SLOT_BUS_SPEED(slot_cur->status)) { 1064 err("bus speed mismatch occurred. please check " 1065 "current bus speed and card capability\n"); 1066 print_card_capability(slot_cur); 1067 } else if (SLOT_BUS_MODE(slot_cur->ext_status)) { 1068 err("bus mode mismatch occurred. please check " 1069 "current bus mode and card capability\n"); 1070 print_card_capability(slot_cur); 1071 } 1072 ibmphp_update_slot_info(slot_cur); 1073 goto exit; 1074 } 1075 debug("after power_on\n"); 1076 /*-----------------------debugging---------------------------*/ 1077 get_cur_bus_info(&slot_cur); 1078 debug("the current bus speed right after power_on = %x\n", 1079 slot_cur->bus_on->current_speed); 1080 /*----------------------------------------------------------*/ 1081 1082 rc = slot_update(&slot_cur); 1083 if (rc) 1084 goto error_power; 1085 1086 rc = -EINVAL; 1087 if (SLOT_POWER(slot_cur->status) && !(SLOT_PWRGD(slot_cur->status))) { 1088 err("power fault occurred trying to power up...\n"); 1089 goto error_power; 1090 } 1091 if (SLOT_POWER(slot_cur->status) && (SLOT_BUS_SPEED(slot_cur->status))) { 1092 err("bus speed mismatch occurred. please check current bus " 1093 "speed and card capability\n"); 1094 print_card_capability(slot_cur); 1095 goto error_power; 1096 } 1097 /* Don't think this case will happen after above checks... 1098 * but just in case, for paranoia sake */ 1099 if (!(SLOT_POWER(slot_cur->status))) { 1100 err("power on failed...\n"); 1101 goto error_power; 1102 } 1103 1104 slot_cur->func = kzalloc(sizeof(struct pci_func), GFP_KERNEL); 1105 if (!slot_cur->func) { 1106 /* We cannot do update_slot_info here, since no memory for 1107 * kmalloc n.e.ways, and update_slot_info allocates some */ 1108 err("out of system memory\n"); 1109 rc = -ENOMEM; 1110 goto error_power; 1111 } 1112 slot_cur->func->busno = slot_cur->bus; 1113 slot_cur->func->device = slot_cur->device; 1114 for (i = 0; i < 4; i++) 1115 slot_cur->func->irq[i] = slot_cur->irq[i]; 1116 1117 debug("b4 configure_card, slot_cur->bus = %x, slot_cur->device = %x\n", 1118 slot_cur->bus, slot_cur->device); 1119 1120 if (ibmphp_configure_card(slot_cur->func, slot_cur->number)) { 1121 err("configure_card was unsuccessful...\n"); 1122 /* true because don't need to actually deallocate resources, 1123 * just remove references */ 1124 ibmphp_unconfigure_card(&slot_cur, 1); 1125 debug("after unconfigure_card\n"); 1126 slot_cur->func = NULL; 1127 rc = -ENOMEM; 1128 goto error_power; 1129 } 1130 1131 function = 0x00; 1132 do { 1133 tmp_func = ibm_slot_find(slot_cur->bus, slot_cur->func->device, 1134 function++); 1135 if (tmp_func && !(tmp_func->dev)) 1136 ibm_configure_device(tmp_func); 1137 } while (tmp_func); 1138 1139 attn_off(slot_cur); 1140 if (slot_update(&slot_cur)) { 1141 rc = -EFAULT; 1142 goto exit; 1143 } 1144 ibmphp_print_test(); 1145 rc = ibmphp_update_slot_info(slot_cur); 1146 exit: 1147 ibmphp_unlock_operations(); 1148 return rc; 1149 1150 error_nopower: 1151 attn_off(slot_cur); /* need to turn off if was blinking b4 */ 1152 attn_on(slot_cur); 1153 error_cont: 1154 rcpr = slot_update(&slot_cur); 1155 if (rcpr) { 1156 rc = rcpr; 1157 goto exit; 1158 } 1159 ibmphp_update_slot_info(slot_cur); 1160 goto exit; 1161 1162 error_power: 1163 attn_off(slot_cur); /* need to turn off if was blinking b4 */ 1164 attn_on(slot_cur); 1165 rcpr = power_off(slot_cur); 1166 if (rcpr) { 1167 rc = rcpr; 1168 goto exit; 1169 } 1170 goto error_cont; 1171 } 1172 1173 /************************************************************** 1174 * HOT REMOVING ADAPTER CARD * 1175 * INPUT: POINTER TO THE HOTPLUG SLOT STRUCTURE * 1176 * OUTPUT: SUCCESS 0 ; FAILURE: UNCONFIGURE , VALIDATE * 1177 DISABLE POWER , * 1178 **************************************************************/ 1179 static int ibmphp_disable_slot(struct hotplug_slot *hotplug_slot) 1180 { 1181 struct slot *slot = hotplug_slot->private; 1182 int rc; 1183 1184 ibmphp_lock_operations(); 1185 rc = ibmphp_do_disable_slot(slot); 1186 ibmphp_unlock_operations(); 1187 return rc; 1188 } 1189 1190 int ibmphp_do_disable_slot(struct slot *slot_cur) 1191 { 1192 int rc; 1193 u8 flag; 1194 1195 debug("DISABLING SLOT...\n"); 1196 1197 if ((slot_cur == NULL) || (slot_cur->ctrl == NULL)) { 1198 return -ENODEV; 1199 } 1200 1201 flag = slot_cur->flag; 1202 slot_cur->flag = 1; 1203 1204 if (flag == 1) { 1205 rc = validate(slot_cur, DISABLE); 1206 /* checking if powered off already & valid slot # */ 1207 if (rc) 1208 goto error; 1209 } 1210 attn_LED_blink(slot_cur); 1211 1212 if (slot_cur->func == NULL) { 1213 /* We need this for functions that were there on bootup */ 1214 slot_cur->func = kzalloc(sizeof(struct pci_func), GFP_KERNEL); 1215 if (!slot_cur->func) { 1216 err("out of system memory\n"); 1217 rc = -ENOMEM; 1218 goto error; 1219 } 1220 slot_cur->func->busno = slot_cur->bus; 1221 slot_cur->func->device = slot_cur->device; 1222 } 1223 1224 ibm_unconfigure_device(slot_cur->func); 1225 1226 /* 1227 * If we got here from latch suddenly opening on operating card or 1228 * a power fault, there's no power to the card, so cannot 1229 * read from it to determine what resources it occupied. This operation 1230 * is forbidden anyhow. The best we can do is remove it from kernel 1231 * lists at least */ 1232 1233 if (!flag) { 1234 attn_off(slot_cur); 1235 return 0; 1236 } 1237 1238 rc = ibmphp_unconfigure_card(&slot_cur, 0); 1239 slot_cur->func = NULL; 1240 debug("in disable_slot. after unconfigure_card\n"); 1241 if (rc) { 1242 err("could not unconfigure card.\n"); 1243 goto error; 1244 } 1245 1246 rc = ibmphp_hpc_writeslot(slot_cur, HPC_SLOT_OFF); 1247 if (rc) 1248 goto error; 1249 1250 attn_off(slot_cur); 1251 rc = slot_update(&slot_cur); 1252 if (rc) 1253 goto exit; 1254 1255 rc = ibmphp_update_slot_info(slot_cur); 1256 ibmphp_print_test(); 1257 exit: 1258 return rc; 1259 1260 error: 1261 /* Need to turn off if was blinking b4 */ 1262 attn_off(slot_cur); 1263 attn_on(slot_cur); 1264 if (slot_update(&slot_cur)) { 1265 rc = -EFAULT; 1266 goto exit; 1267 } 1268 if (flag) 1269 ibmphp_update_slot_info(slot_cur); 1270 goto exit; 1271 } 1272 1273 struct hotplug_slot_ops ibmphp_hotplug_slot_ops = { 1274 .set_attention_status = set_attention_status, 1275 .enable_slot = enable_slot, 1276 .disable_slot = ibmphp_disable_slot, 1277 .hardware_test = NULL, 1278 .get_power_status = get_power_status, 1279 .get_attention_status = get_attention_status, 1280 .get_latch_status = get_latch_status, 1281 .get_adapter_status = get_adapter_present, 1282 /* .get_max_adapter_speed = get_max_adapter_speed, 1283 .get_bus_name_status = get_bus_name, 1284 */ 1285 }; 1286 1287 static void ibmphp_unload(void) 1288 { 1289 free_slots(); 1290 debug("after slots\n"); 1291 ibmphp_free_resources(); 1292 debug("after resources\n"); 1293 ibmphp_free_bus_info_queue(); 1294 debug("after bus info\n"); 1295 ibmphp_free_ebda_hpc_queue(); 1296 debug("after ebda hpc\n"); 1297 ibmphp_free_ebda_pci_rsrc_queue(); 1298 debug("after ebda pci rsrc\n"); 1299 kfree(ibmphp_pci_bus); 1300 } 1301 1302 static int __init ibmphp_init(void) 1303 { 1304 struct pci_bus *bus; 1305 int i = 0; 1306 int rc = 0; 1307 1308 init_flag = 1; 1309 1310 info(DRIVER_DESC " version: " DRIVER_VERSION "\n"); 1311 1312 ibmphp_pci_bus = kmalloc(sizeof(*ibmphp_pci_bus), GFP_KERNEL); 1313 if (!ibmphp_pci_bus) { 1314 err("out of memory\n"); 1315 rc = -ENOMEM; 1316 goto exit; 1317 } 1318 1319 bus = pci_find_bus(0, 0); 1320 if (!bus) { 1321 err("Can't find the root pci bus, can not continue\n"); 1322 rc = -ENODEV; 1323 goto error; 1324 } 1325 memcpy(ibmphp_pci_bus, bus, sizeof(*ibmphp_pci_bus)); 1326 1327 ibmphp_debug = debug; 1328 1329 ibmphp_hpc_initvars(); 1330 1331 for (i = 0; i < 16; i++) 1332 irqs[i] = 0; 1333 1334 if ((rc = ibmphp_access_ebda())) 1335 goto error; 1336 debug("after ibmphp_access_ebda()\n"); 1337 1338 if ((rc = ibmphp_rsrc_init())) 1339 goto error; 1340 debug("AFTER Resource & EBDA INITIALIZATIONS\n"); 1341 1342 max_slots = get_max_slots(); 1343 1344 if ((rc = ibmphp_register_pci())) 1345 goto error; 1346 1347 if (init_ops()) { 1348 rc = -ENODEV; 1349 goto error; 1350 } 1351 1352 ibmphp_print_test(); 1353 if ((rc = ibmphp_hpc_start_poll_thread())) { 1354 goto error; 1355 } 1356 1357 exit: 1358 return rc; 1359 1360 error: 1361 ibmphp_unload(); 1362 goto exit; 1363 } 1364 1365 static void __exit ibmphp_exit(void) 1366 { 1367 ibmphp_hpc_stop_poll_thread(); 1368 debug("after polling\n"); 1369 ibmphp_unload(); 1370 debug("done\n"); 1371 } 1372 1373 module_init(ibmphp_init); 1374 module_exit(ibmphp_exit); 1375