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 IRQ's 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->exlusive_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 fncs's 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 /* If we got here from latch suddenly opening on operating card or 1227 a power fault, there's no power to the card, so cannot 1228 read from it to determine what resources it occupied. This operation 1229 is forbidden anyhow. The best we can do is remove it from kernel 1230 lists at least */ 1231 1232 if (!flag) { 1233 attn_off(slot_cur); 1234 return 0; 1235 } 1236 1237 rc = ibmphp_unconfigure_card(&slot_cur, 0); 1238 slot_cur->func = NULL; 1239 debug("in disable_slot. after unconfigure_card\n"); 1240 if (rc) { 1241 err("could not unconfigure card.\n"); 1242 goto error; 1243 } 1244 1245 rc = ibmphp_hpc_writeslot(slot_cur, HPC_SLOT_OFF); 1246 if (rc) 1247 goto error; 1248 1249 attn_off(slot_cur); 1250 rc = slot_update(&slot_cur); 1251 if (rc) 1252 goto exit; 1253 1254 rc = ibmphp_update_slot_info(slot_cur); 1255 ibmphp_print_test(); 1256 exit: 1257 return rc; 1258 1259 error: 1260 /* Need to turn off if was blinking b4 */ 1261 attn_off(slot_cur); 1262 attn_on(slot_cur); 1263 if (slot_update(&slot_cur)) { 1264 rc = -EFAULT; 1265 goto exit; 1266 } 1267 if (flag) 1268 ibmphp_update_slot_info(slot_cur); 1269 goto exit; 1270 } 1271 1272 struct hotplug_slot_ops ibmphp_hotplug_slot_ops = { 1273 .set_attention_status = set_attention_status, 1274 .enable_slot = enable_slot, 1275 .disable_slot = ibmphp_disable_slot, 1276 .hardware_test = NULL, 1277 .get_power_status = get_power_status, 1278 .get_attention_status = get_attention_status, 1279 .get_latch_status = get_latch_status, 1280 .get_adapter_status = get_adapter_present, 1281 /* .get_max_adapter_speed = get_max_adapter_speed, 1282 .get_bus_name_status = get_bus_name, 1283 */ 1284 }; 1285 1286 static void ibmphp_unload(void) 1287 { 1288 free_slots(); 1289 debug("after slots\n"); 1290 ibmphp_free_resources(); 1291 debug("after resources\n"); 1292 ibmphp_free_bus_info_queue(); 1293 debug("after bus info\n"); 1294 ibmphp_free_ebda_hpc_queue(); 1295 debug("after ebda hpc\n"); 1296 ibmphp_free_ebda_pci_rsrc_queue(); 1297 debug("after ebda pci rsrc\n"); 1298 kfree(ibmphp_pci_bus); 1299 } 1300 1301 static int __init ibmphp_init(void) 1302 { 1303 struct pci_bus *bus; 1304 int i = 0; 1305 int rc = 0; 1306 1307 init_flag = 1; 1308 1309 info(DRIVER_DESC " version: " DRIVER_VERSION "\n"); 1310 1311 ibmphp_pci_bus = kmalloc(sizeof(*ibmphp_pci_bus), GFP_KERNEL); 1312 if (!ibmphp_pci_bus) { 1313 err("out of memory\n"); 1314 rc = -ENOMEM; 1315 goto exit; 1316 } 1317 1318 bus = pci_find_bus(0, 0); 1319 if (!bus) { 1320 err("Can't find the root pci bus, can not continue\n"); 1321 rc = -ENODEV; 1322 goto error; 1323 } 1324 memcpy(ibmphp_pci_bus, bus, sizeof(*ibmphp_pci_bus)); 1325 1326 ibmphp_debug = debug; 1327 1328 ibmphp_hpc_initvars(); 1329 1330 for (i = 0; i < 16; i++) 1331 irqs[i] = 0; 1332 1333 if ((rc = ibmphp_access_ebda())) 1334 goto error; 1335 debug("after ibmphp_access_ebda()\n"); 1336 1337 if ((rc = ibmphp_rsrc_init())) 1338 goto error; 1339 debug("AFTER Resource & EBDA INITIALIZATIONS\n"); 1340 1341 max_slots = get_max_slots(); 1342 1343 if ((rc = ibmphp_register_pci())) 1344 goto error; 1345 1346 if (init_ops()) { 1347 rc = -ENODEV; 1348 goto error; 1349 } 1350 1351 ibmphp_print_test(); 1352 if ((rc = ibmphp_hpc_start_poll_thread())) { 1353 goto error; 1354 } 1355 1356 exit: 1357 return rc; 1358 1359 error: 1360 ibmphp_unload(); 1361 goto exit; 1362 } 1363 1364 static void __exit ibmphp_exit(void) 1365 { 1366 ibmphp_hpc_stop_poll_thread(); 1367 debug("after polling\n"); 1368 ibmphp_unload(); 1369 debug("done\n"); 1370 } 1371 1372 module_init(ibmphp_init); 1373 module_exit(ibmphp_exit); 1374