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 int 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 hotplug_slot *hotplug_slot, enum pci_bus_speed *value) 399 { 400 int rc = -ENODEV; 401 struct slot *pslot; 402 u8 mode = 0; 403 404 debug("%s - Entry hotplug_slot[%p] pvalue[%p]\n", __func__, 405 hotplug_slot, value); 406 407 ibmphp_lock_operations(); 408 409 if (hotplug_slot) { 410 pslot = hotplug_slot->private; 411 if (pslot) { 412 rc = 0; 413 mode = pslot->supported_bus_mode; 414 *value = pslot->supported_speed; 415 switch (*value) { 416 case BUS_SPEED_33: 417 break; 418 case BUS_SPEED_66: 419 if (mode == BUS_MODE_PCIX) 420 *value += 0x01; 421 break; 422 case BUS_SPEED_100: 423 case BUS_SPEED_133: 424 *value = pslot->supported_speed + 0x01; 425 break; 426 default: 427 /* Note (will need to change): there would be soon 256, 512 also */ 428 rc = -ENODEV; 429 } 430 } 431 } 432 433 ibmphp_unlock_operations(); 434 debug("%s - Exit rc[%d] value[%x]\n", __func__, rc, *value); 435 return rc; 436 } 437 438 static int get_cur_bus_speed(struct hotplug_slot *hotplug_slot, enum pci_bus_speed *value) 439 { 440 int rc = -ENODEV; 441 struct slot *pslot; 442 u8 mode = 0; 443 444 debug("%s - Entry hotplug_slot[%p] pvalue[%p]\n", __func__, 445 hotplug_slot, value); 446 447 ibmphp_lock_operations(); 448 449 if (hotplug_slot) { 450 pslot = hotplug_slot->private; 451 if (pslot) { 452 rc = get_cur_bus_info(&pslot); 453 if (!rc) { 454 mode = pslot->bus_on->current_bus_mode; 455 *value = pslot->bus_on->current_speed; 456 switch (*value) { 457 case BUS_SPEED_33: 458 break; 459 case BUS_SPEED_66: 460 if (mode == BUS_MODE_PCIX) 461 *value += 0x01; 462 else if (mode == BUS_MODE_PCI) 463 ; 464 else 465 *value = PCI_SPEED_UNKNOWN; 466 break; 467 case BUS_SPEED_100: 468 case BUS_SPEED_133: 469 *value += 0x01; 470 break; 471 default: 472 /* Note of change: there would also be 256, 512 soon */ 473 rc = -ENODEV; 474 } 475 } 476 } 477 } 478 479 ibmphp_unlock_operations(); 480 debug("%s - Exit rc[%d] value[%x]\n", __func__, rc, *value); 481 return rc; 482 } 483 484 /* 485 static int get_max_adapter_speed_1(struct hotplug_slot *hotplug_slot, u8 * value, u8 flag) 486 { 487 int rc = -ENODEV; 488 struct slot *pslot; 489 struct slot myslot; 490 491 debug("get_max_adapter_speed_1 - Entry hotplug_slot[%lx] pvalue[%lx]\n", 492 (ulong)hotplug_slot, (ulong) value); 493 494 if (flag) 495 ibmphp_lock_operations(); 496 497 if (hotplug_slot && value) { 498 pslot = hotplug_slot->private; 499 if (pslot) { 500 memcpy(&myslot, pslot, sizeof(struct slot)); 501 rc = ibmphp_hpc_readslot(pslot, READ_SLOTSTATUS, 502 &(myslot.status)); 503 504 if (!(SLOT_LATCH (myslot.status)) && 505 (SLOT_PRESENT (myslot.status))) { 506 rc = ibmphp_hpc_readslot(pslot, 507 READ_EXTSLOTSTATUS, 508 &(myslot.ext_status)); 509 if (!rc) 510 *value = SLOT_SPEED(myslot.ext_status); 511 } else 512 *value = MAX_ADAPTER_NONE; 513 } 514 } 515 516 if (flag) 517 ibmphp_unlock_operations(); 518 519 debug("get_max_adapter_speed_1 - Exit rc[%d] value[%x]\n", rc, *value); 520 return rc; 521 } 522 523 static int get_bus_name(struct hotplug_slot *hotplug_slot, char * value) 524 { 525 int rc = -ENODEV; 526 struct slot *pslot = NULL; 527 528 debug("get_bus_name - Entry hotplug_slot[%lx]\n", (ulong)hotplug_slot); 529 530 ibmphp_lock_operations(); 531 532 if (hotplug_slot) { 533 pslot = hotplug_slot->private; 534 if (pslot) { 535 rc = 0; 536 snprintf(value, 100, "Bus %x", pslot->bus); 537 } 538 } else 539 rc = -ENODEV; 540 541 ibmphp_unlock_operations(); 542 debug("get_bus_name - Exit rc[%d] value[%x]\n", rc, *value); 543 return rc; 544 } 545 */ 546 547 /**************************************************************************** 548 * This routine will initialize the ops data structure used in the validate 549 * function. It will also power off empty slots that are powered on since BIOS 550 * leaves those on, albeit disconnected 551 ****************************************************************************/ 552 static int __init init_ops(void) 553 { 554 struct slot *slot_cur; 555 struct list_head *tmp; 556 int retval; 557 int rc; 558 559 list_for_each(tmp, &ibmphp_slot_head) { 560 slot_cur = list_entry(tmp, struct slot, ibm_slot_list); 561 562 if (!slot_cur) 563 return -ENODEV; 564 565 debug("BEFORE GETTING SLOT STATUS, slot # %x\n", 566 slot_cur->number); 567 if (slot_cur->ctrl->revision == 0xFF) 568 if (get_ctrl_revision(slot_cur, 569 &slot_cur->ctrl->revision)) 570 return -1; 571 572 if (slot_cur->bus_on->current_speed == 0xFF) 573 if (get_cur_bus_info(&slot_cur)) 574 return -1; 575 576 if (slot_cur->ctrl->options == 0xFF) 577 if (get_hpc_options(slot_cur, &slot_cur->ctrl->options)) 578 return -1; 579 580 retval = slot_update(&slot_cur); 581 if (retval) 582 return retval; 583 584 debug("status = %x\n", slot_cur->status); 585 debug("ext_status = %x\n", slot_cur->ext_status); 586 debug("SLOT_POWER = %x\n", SLOT_POWER(slot_cur->status)); 587 debug("SLOT_PRESENT = %x\n", SLOT_PRESENT(slot_cur->status)); 588 debug("SLOT_LATCH = %x\n", SLOT_LATCH(slot_cur->status)); 589 590 if ((SLOT_PWRGD(slot_cur->status)) && 591 !(SLOT_PRESENT(slot_cur->status)) && 592 !(SLOT_LATCH(slot_cur->status))) { 593 debug("BEFORE POWER OFF COMMAND\n"); 594 rc = power_off(slot_cur); 595 if (rc) 596 return rc; 597 598 /* retval = slot_update(&slot_cur); 599 * if (retval) 600 * return retval; 601 * ibmphp_update_slot_info(slot_cur); 602 */ 603 } 604 } 605 init_flag = 0; 606 return 0; 607 } 608 609 /* This operation will check whether the slot is within the bounds and 610 * the operation is valid to perform on that slot 611 * Parameters: slot, operation 612 * Returns: 0 or error codes 613 */ 614 static int validate(struct slot *slot_cur, int opn) 615 { 616 int number; 617 int retval; 618 619 if (!slot_cur) 620 return -ENODEV; 621 number = slot_cur->number; 622 if ((number > max_slots) || (number < 0)) 623 return -EBADSLT; 624 debug("slot_number in validate is %d\n", slot_cur->number); 625 626 retval = slot_update(&slot_cur); 627 if (retval) 628 return retval; 629 630 switch (opn) { 631 case ENABLE: 632 if (!(SLOT_PWRGD(slot_cur->status)) && 633 (SLOT_PRESENT(slot_cur->status)) && 634 !(SLOT_LATCH(slot_cur->status))) 635 return 0; 636 break; 637 case DISABLE: 638 if ((SLOT_PWRGD(slot_cur->status)) && 639 (SLOT_PRESENT(slot_cur->status)) && 640 !(SLOT_LATCH(slot_cur->status))) 641 return 0; 642 break; 643 default: 644 break; 645 } 646 err("validate failed....\n"); 647 return -EINVAL; 648 } 649 650 /**************************************************************************** 651 * This routine is for updating the data structures in the hotplug core 652 * Parameters: struct slot 653 * Returns: 0 or error 654 ****************************************************************************/ 655 int ibmphp_update_slot_info(struct slot *slot_cur) 656 { 657 struct hotplug_slot_info *info; 658 int rc; 659 u8 bus_speed; 660 u8 mode; 661 662 info = kmalloc(sizeof(struct hotplug_slot_info), GFP_KERNEL); 663 if (!info) { 664 err("out of system memory\n"); 665 return -ENOMEM; 666 } 667 668 info->power_status = SLOT_PWRGD(slot_cur->status); 669 info->attention_status = SLOT_ATTN(slot_cur->status, 670 slot_cur->ext_status); 671 info->latch_status = SLOT_LATCH(slot_cur->status); 672 if (!SLOT_PRESENT(slot_cur->status)) { 673 info->adapter_status = 0; 674 /* info->max_adapter_speed_status = MAX_ADAPTER_NONE; */ 675 } else { 676 info->adapter_status = 1; 677 /* get_max_adapter_speed_1(slot_cur->hotplug_slot, 678 &info->max_adapter_speed_status, 0); */ 679 } 680 681 bus_speed = slot_cur->bus_on->current_speed; 682 mode = slot_cur->bus_on->current_bus_mode; 683 684 switch (bus_speed) { 685 case BUS_SPEED_33: 686 break; 687 case BUS_SPEED_66: 688 if (mode == BUS_MODE_PCIX) 689 bus_speed += 0x01; 690 else if (mode == BUS_MODE_PCI) 691 ; 692 else 693 bus_speed = PCI_SPEED_UNKNOWN; 694 break; 695 case BUS_SPEED_100: 696 case BUS_SPEED_133: 697 bus_speed += 0x01; 698 break; 699 default: 700 bus_speed = PCI_SPEED_UNKNOWN; 701 } 702 703 info->cur_bus_speed = bus_speed; 704 info->max_bus_speed = slot_cur->hotplug_slot->info->max_bus_speed; 705 // To do: bus_names 706 707 rc = pci_hp_change_slot_info(slot_cur->hotplug_slot, info); 708 kfree(info); 709 return rc; 710 } 711 712 713 /****************************************************************************** 714 * This function will return the pci_func, given bus and devfunc, or NULL. It 715 * is called from visit routines 716 ******************************************************************************/ 717 718 static struct pci_func *ibm_slot_find(u8 busno, u8 device, u8 function) 719 { 720 struct pci_func *func_cur; 721 struct slot *slot_cur; 722 struct list_head * tmp; 723 list_for_each(tmp, &ibmphp_slot_head) { 724 slot_cur = list_entry(tmp, struct slot, ibm_slot_list); 725 if (slot_cur->func) { 726 func_cur = slot_cur->func; 727 while (func_cur) { 728 if ((func_cur->busno == busno) && 729 (func_cur->device == device) && 730 (func_cur->function == function)) 731 return func_cur; 732 func_cur = func_cur->next; 733 } 734 } 735 } 736 return NULL; 737 } 738 739 /************************************************************* 740 * This routine frees up memory used by struct slot, including 741 * the pointers to pci_func, bus, hotplug_slot, controller, 742 * and deregistering from the hotplug core 743 *************************************************************/ 744 static void free_slots(void) 745 { 746 struct slot *slot_cur; 747 struct list_head * tmp; 748 struct list_head * next; 749 750 debug("%s -- enter\n", __func__); 751 752 list_for_each_safe(tmp, next, &ibmphp_slot_head) { 753 slot_cur = list_entry(tmp, struct slot, ibm_slot_list); 754 pci_hp_deregister(slot_cur->hotplug_slot); 755 } 756 debug("%s -- exit\n", __func__); 757 } 758 759 static void ibm_unconfigure_device(struct pci_func *func) 760 { 761 struct pci_dev *temp; 762 u8 j; 763 764 debug("inside %s\n", __func__); 765 debug("func->device = %x, func->function = %x\n", 766 func->device, func->function); 767 debug("func->device << 3 | 0x0 = %x\n", func->device << 3 | 0x0); 768 769 for (j = 0; j < 0x08; j++) { 770 temp = pci_get_bus_and_slot(func->busno, (func->device << 3) | j); 771 if (temp) { 772 pci_remove_bus_device(temp); 773 pci_dev_put(temp); 774 } 775 } 776 pci_dev_put(func->dev); 777 } 778 779 /* 780 * The following function is to fix kernel bug regarding 781 * getting bus entries, here we manually add those primary 782 * bus entries to kernel bus structure whenever apply 783 */ 784 static u8 bus_structure_fixup(u8 busno) 785 { 786 struct pci_bus *bus; 787 struct pci_dev *dev; 788 u16 l; 789 790 if (pci_find_bus(0, busno) || !(ibmphp_find_same_bus_num(busno))) 791 return 1; 792 793 bus = kmalloc(sizeof(*bus), GFP_KERNEL); 794 if (!bus) { 795 err("%s - out of memory\n", __func__); 796 return 1; 797 } 798 dev = kmalloc(sizeof(*dev), GFP_KERNEL); 799 if (!dev) { 800 kfree(bus); 801 err("%s - out of memory\n", __func__); 802 return 1; 803 } 804 805 bus->number = busno; 806 bus->ops = ibmphp_pci_bus->ops; 807 dev->bus = bus; 808 for (dev->devfn = 0; dev->devfn < 256; dev->devfn += 8) { 809 if (!pci_read_config_word(dev, PCI_VENDOR_ID, &l) && 810 (l != 0x0000) && (l != 0xffff)) { 811 debug("%s - Inside bus_struture_fixup()\n", 812 __func__); 813 pci_scan_bus(busno, ibmphp_pci_bus->ops, NULL); 814 break; 815 } 816 } 817 818 kfree(dev); 819 kfree(bus); 820 821 return 0; 822 } 823 824 static int ibm_configure_device(struct pci_func *func) 825 { 826 unsigned char bus; 827 struct pci_bus *child; 828 int num; 829 int flag = 0; /* this is to make sure we don't double scan the bus, 830 for bridged devices primarily */ 831 832 if (!(bus_structure_fixup(func->busno))) 833 flag = 1; 834 if (func->dev == NULL) 835 func->dev = pci_get_bus_and_slot(func->busno, 836 PCI_DEVFN(func->device, func->function)); 837 838 if (func->dev == NULL) { 839 struct pci_bus *bus = pci_find_bus(0, func->busno); 840 if (!bus) 841 return 0; 842 843 num = pci_scan_slot(bus, 844 PCI_DEVFN(func->device, func->function)); 845 if (num) 846 pci_bus_add_devices(bus); 847 848 func->dev = pci_get_bus_and_slot(func->busno, 849 PCI_DEVFN(func->device, func->function)); 850 if (func->dev == NULL) { 851 err("ERROR... : pci_dev still NULL\n"); 852 return 0; 853 } 854 } 855 if (!(flag) && (func->dev->hdr_type == PCI_HEADER_TYPE_BRIDGE)) { 856 pci_read_config_byte(func->dev, PCI_SECONDARY_BUS, &bus); 857 child = pci_add_new_bus(func->dev->bus, func->dev, bus); 858 pci_do_scan_bus(child); 859 } 860 861 return 0; 862 } 863 864 /******************************************************* 865 * Returns whether the bus is empty or not 866 *******************************************************/ 867 static int is_bus_empty(struct slot * slot_cur) 868 { 869 int rc; 870 struct slot * tmp_slot; 871 u8 i = slot_cur->bus_on->slot_min; 872 873 while (i <= slot_cur->bus_on->slot_max) { 874 if (i == slot_cur->number) { 875 i++; 876 continue; 877 } 878 tmp_slot = ibmphp_get_slot_from_physical_num(i); 879 if (!tmp_slot) 880 return 0; 881 rc = slot_update(&tmp_slot); 882 if (rc) 883 return 0; 884 if (SLOT_PRESENT(tmp_slot->status) && 885 SLOT_PWRGD(tmp_slot->status)) 886 return 0; 887 i++; 888 } 889 return 1; 890 } 891 892 /*********************************************************** 893 * If the HPC permits and the bus currently empty, tries to set the 894 * bus speed and mode at the maximum card and bus capability 895 * Parameters: slot 896 * Returns: bus is set (0) or error code 897 ***********************************************************/ 898 static int set_bus(struct slot * slot_cur) 899 { 900 int rc; 901 u8 speed; 902 u8 cmd = 0x0; 903 int retval; 904 static struct pci_device_id ciobx[] = { 905 { PCI_DEVICE(PCI_VENDOR_ID_SERVERWORKS, 0x0101) }, 906 { }, 907 }; 908 909 debug("%s - entry slot # %d\n", __func__, slot_cur->number); 910 if (SET_BUS_STATUS(slot_cur->ctrl) && is_bus_empty(slot_cur)) { 911 rc = slot_update(&slot_cur); 912 if (rc) 913 return rc; 914 speed = SLOT_SPEED(slot_cur->ext_status); 915 debug("ext_status = %x, speed = %x\n", slot_cur->ext_status, speed); 916 switch (speed) { 917 case HPC_SLOT_SPEED_33: 918 cmd = HPC_BUS_33CONVMODE; 919 break; 920 case HPC_SLOT_SPEED_66: 921 if (SLOT_PCIX(slot_cur->ext_status)) { 922 if ((slot_cur->supported_speed >= BUS_SPEED_66) && 923 (slot_cur->supported_bus_mode == BUS_MODE_PCIX)) 924 cmd = HPC_BUS_66PCIXMODE; 925 else if (!SLOT_BUS_MODE(slot_cur->ext_status)) 926 /* if max slot/bus capability is 66 pci 927 and there's no bus mode mismatch, then 928 the adapter supports 66 pci */ 929 cmd = HPC_BUS_66CONVMODE; 930 else 931 cmd = HPC_BUS_33CONVMODE; 932 } else { 933 if (slot_cur->supported_speed >= BUS_SPEED_66) 934 cmd = HPC_BUS_66CONVMODE; 935 else 936 cmd = HPC_BUS_33CONVMODE; 937 } 938 break; 939 case HPC_SLOT_SPEED_133: 940 switch (slot_cur->supported_speed) { 941 case BUS_SPEED_33: 942 cmd = HPC_BUS_33CONVMODE; 943 break; 944 case BUS_SPEED_66: 945 if (slot_cur->supported_bus_mode == BUS_MODE_PCIX) 946 cmd = HPC_BUS_66PCIXMODE; 947 else 948 cmd = HPC_BUS_66CONVMODE; 949 break; 950 case BUS_SPEED_100: 951 cmd = HPC_BUS_100PCIXMODE; 952 break; 953 case BUS_SPEED_133: 954 /* This is to take care of the bug in CIOBX chip */ 955 if (pci_dev_present(ciobx)) 956 ibmphp_hpc_writeslot(slot_cur, 957 HPC_BUS_100PCIXMODE); 958 cmd = HPC_BUS_133PCIXMODE; 959 break; 960 default: 961 err("Wrong bus speed\n"); 962 return -ENODEV; 963 } 964 break; 965 default: 966 err("wrong slot speed\n"); 967 return -ENODEV; 968 } 969 debug("setting bus speed for slot %d, cmd %x\n", 970 slot_cur->number, cmd); 971 retval = ibmphp_hpc_writeslot(slot_cur, cmd); 972 if (retval) { 973 err("setting bus speed failed\n"); 974 return retval; 975 } 976 if (CTLR_RESULT(slot_cur->ctrl->status)) { 977 err("command not completed successfully in set_bus\n"); 978 return -EIO; 979 } 980 } 981 /* This is for x440, once Brandon fixes the firmware, 982 will not need this delay */ 983 msleep(1000); 984 debug("%s -Exit\n", __func__); 985 return 0; 986 } 987 988 /* This routine checks the bus limitations that the slot is on from the BIOS. 989 * This is used in deciding whether or not to power up the slot. 990 * (electrical/spec limitations. For example, >1 133 MHz or >2 66 PCI cards on 991 * same bus) 992 * Parameters: slot 993 * Returns: 0 = no limitations, -EINVAL = exceeded limitations on the bus 994 */ 995 static int check_limitations(struct slot *slot_cur) 996 { 997 u8 i; 998 struct slot * tmp_slot; 999 u8 count = 0; 1000 u8 limitation = 0; 1001 1002 for (i = slot_cur->bus_on->slot_min; i <= slot_cur->bus_on->slot_max; i++) { 1003 tmp_slot = ibmphp_get_slot_from_physical_num(i); 1004 if (!tmp_slot) 1005 return -ENODEV; 1006 if ((SLOT_PWRGD(tmp_slot->status)) && 1007 !(SLOT_CONNECT(tmp_slot->status))) 1008 count++; 1009 } 1010 get_cur_bus_info(&slot_cur); 1011 switch (slot_cur->bus_on->current_speed) { 1012 case BUS_SPEED_33: 1013 limitation = slot_cur->bus_on->slots_at_33_conv; 1014 break; 1015 case BUS_SPEED_66: 1016 if (slot_cur->bus_on->current_bus_mode == BUS_MODE_PCIX) 1017 limitation = slot_cur->bus_on->slots_at_66_pcix; 1018 else 1019 limitation = slot_cur->bus_on->slots_at_66_conv; 1020 break; 1021 case BUS_SPEED_100: 1022 limitation = slot_cur->bus_on->slots_at_100_pcix; 1023 break; 1024 case BUS_SPEED_133: 1025 limitation = slot_cur->bus_on->slots_at_133_pcix; 1026 break; 1027 } 1028 1029 if ((count + 1) > limitation) 1030 return -EINVAL; 1031 return 0; 1032 } 1033 1034 static inline void print_card_capability(struct slot *slot_cur) 1035 { 1036 info("capability of the card is "); 1037 if ((slot_cur->ext_status & CARD_INFO) == PCIX133) 1038 info(" 133 MHz PCI-X\n"); 1039 else if ((slot_cur->ext_status & CARD_INFO) == PCIX66) 1040 info(" 66 MHz PCI-X\n"); 1041 else if ((slot_cur->ext_status & CARD_INFO) == PCI66) 1042 info(" 66 MHz PCI\n"); 1043 else 1044 info(" 33 MHz PCI\n"); 1045 1046 } 1047 1048 /* This routine will power on the slot, configure the device(s) and find the 1049 * drivers for them. 1050 * Parameters: hotplug_slot 1051 * Returns: 0 or failure codes 1052 */ 1053 static int enable_slot(struct hotplug_slot *hs) 1054 { 1055 int rc, i, rcpr; 1056 struct slot *slot_cur; 1057 u8 function; 1058 struct pci_func *tmp_func; 1059 1060 ibmphp_lock_operations(); 1061 1062 debug("ENABLING SLOT........\n"); 1063 slot_cur = hs->private; 1064 1065 if ((rc = validate(slot_cur, ENABLE))) { 1066 err("validate function failed\n"); 1067 goto error_nopower; 1068 } 1069 1070 attn_LED_blink(slot_cur); 1071 1072 rc = set_bus(slot_cur); 1073 if (rc) { 1074 err("was not able to set the bus\n"); 1075 goto error_nopower; 1076 } 1077 1078 /*-----------------debugging------------------------------*/ 1079 get_cur_bus_info(&slot_cur); 1080 debug("the current bus speed right after set_bus = %x\n", 1081 slot_cur->bus_on->current_speed); 1082 /*----------------------------------------------------------*/ 1083 1084 rc = check_limitations(slot_cur); 1085 if (rc) { 1086 err("Adding this card exceeds the limitations of this bus.\n"); 1087 err("(i.e., >1 133MHz cards running on same bus, or " 1088 ">2 66 PCI cards running on same bus.\n"); 1089 err("Try hot-adding into another bus\n"); 1090 rc = -EINVAL; 1091 goto error_nopower; 1092 } 1093 1094 rc = power_on(slot_cur); 1095 1096 if (rc) { 1097 err("something wrong when powering up... please see below for details\n"); 1098 /* need to turn off before on, otherwise, blinking overwrites */ 1099 attn_off(slot_cur); 1100 attn_on(slot_cur); 1101 if (slot_update(&slot_cur)) { 1102 attn_off(slot_cur); 1103 attn_on(slot_cur); 1104 rc = -ENODEV; 1105 goto exit; 1106 } 1107 /* Check to see the error of why it failed */ 1108 if ((SLOT_POWER(slot_cur->status)) && 1109 !(SLOT_PWRGD(slot_cur->status))) 1110 err("power fault occurred trying to power up\n"); 1111 else if (SLOT_BUS_SPEED(slot_cur->status)) { 1112 err("bus speed mismatch occurred. please check " 1113 "current bus speed and card capability\n"); 1114 print_card_capability(slot_cur); 1115 } else if (SLOT_BUS_MODE(slot_cur->ext_status)) { 1116 err("bus mode mismatch occurred. please check " 1117 "current bus mode and card capability\n"); 1118 print_card_capability(slot_cur); 1119 } 1120 ibmphp_update_slot_info(slot_cur); 1121 goto exit; 1122 } 1123 debug("after power_on\n"); 1124 /*-----------------------debugging---------------------------*/ 1125 get_cur_bus_info(&slot_cur); 1126 debug("the current bus speed right after power_on = %x\n", 1127 slot_cur->bus_on->current_speed); 1128 /*----------------------------------------------------------*/ 1129 1130 rc = slot_update(&slot_cur); 1131 if (rc) 1132 goto error_power; 1133 1134 rc = -EINVAL; 1135 if (SLOT_POWER(slot_cur->status) && !(SLOT_PWRGD(slot_cur->status))) { 1136 err("power fault occurred trying to power up...\n"); 1137 goto error_power; 1138 } 1139 if (SLOT_POWER(slot_cur->status) && (SLOT_BUS_SPEED(slot_cur->status))) { 1140 err("bus speed mismatch occurred. please check current bus " 1141 "speed and card capability\n"); 1142 print_card_capability(slot_cur); 1143 goto error_power; 1144 } 1145 /* Don't think this case will happen after above checks... 1146 * but just in case, for paranoia sake */ 1147 if (!(SLOT_POWER(slot_cur->status))) { 1148 err("power on failed...\n"); 1149 goto error_power; 1150 } 1151 1152 slot_cur->func = kzalloc(sizeof(struct pci_func), GFP_KERNEL); 1153 if (!slot_cur->func) { 1154 /* We cannot do update_slot_info here, since no memory for 1155 * kmalloc n.e.ways, and update_slot_info allocates some */ 1156 err("out of system memory\n"); 1157 rc = -ENOMEM; 1158 goto error_power; 1159 } 1160 slot_cur->func->busno = slot_cur->bus; 1161 slot_cur->func->device = slot_cur->device; 1162 for (i = 0; i < 4; i++) 1163 slot_cur->func->irq[i] = slot_cur->irq[i]; 1164 1165 debug("b4 configure_card, slot_cur->bus = %x, slot_cur->device = %x\n", 1166 slot_cur->bus, slot_cur->device); 1167 1168 if (ibmphp_configure_card(slot_cur->func, slot_cur->number)) { 1169 err("configure_card was unsuccessful...\n"); 1170 /* true because don't need to actually deallocate resources, 1171 * just remove references */ 1172 ibmphp_unconfigure_card(&slot_cur, 1); 1173 debug("after unconfigure_card\n"); 1174 slot_cur->func = NULL; 1175 rc = -ENOMEM; 1176 goto error_power; 1177 } 1178 1179 function = 0x00; 1180 do { 1181 tmp_func = ibm_slot_find(slot_cur->bus, slot_cur->func->device, 1182 function++); 1183 if (tmp_func && !(tmp_func->dev)) 1184 ibm_configure_device(tmp_func); 1185 } while (tmp_func); 1186 1187 attn_off(slot_cur); 1188 if (slot_update(&slot_cur)) { 1189 rc = -EFAULT; 1190 goto exit; 1191 } 1192 ibmphp_print_test(); 1193 rc = ibmphp_update_slot_info(slot_cur); 1194 exit: 1195 ibmphp_unlock_operations(); 1196 return rc; 1197 1198 error_nopower: 1199 attn_off(slot_cur); /* need to turn off if was blinking b4 */ 1200 attn_on(slot_cur); 1201 error_cont: 1202 rcpr = slot_update(&slot_cur); 1203 if (rcpr) { 1204 rc = rcpr; 1205 goto exit; 1206 } 1207 ibmphp_update_slot_info(slot_cur); 1208 goto exit; 1209 1210 error_power: 1211 attn_off(slot_cur); /* need to turn off if was blinking b4 */ 1212 attn_on(slot_cur); 1213 rcpr = power_off(slot_cur); 1214 if (rcpr) { 1215 rc = rcpr; 1216 goto exit; 1217 } 1218 goto error_cont; 1219 } 1220 1221 /************************************************************** 1222 * HOT REMOVING ADAPTER CARD * 1223 * INPUT: POINTER TO THE HOTPLUG SLOT STRUCTURE * 1224 * OUTPUT: SUCCESS 0 ; FAILURE: UNCONFIGURE , VALIDATE * 1225 DISABLE POWER , * 1226 **************************************************************/ 1227 static int ibmphp_disable_slot(struct hotplug_slot *hotplug_slot) 1228 { 1229 struct slot *slot = hotplug_slot->private; 1230 int rc; 1231 1232 ibmphp_lock_operations(); 1233 rc = ibmphp_do_disable_slot(slot); 1234 ibmphp_unlock_operations(); 1235 return rc; 1236 } 1237 1238 int ibmphp_do_disable_slot(struct slot *slot_cur) 1239 { 1240 int rc; 1241 u8 flag; 1242 1243 debug("DISABLING SLOT...\n"); 1244 1245 if ((slot_cur == NULL) || (slot_cur->ctrl == NULL)) { 1246 return -ENODEV; 1247 } 1248 1249 flag = slot_cur->flag; 1250 slot_cur->flag = 1; 1251 1252 if (flag == 1) { 1253 rc = validate(slot_cur, DISABLE); 1254 /* checking if powered off already & valid slot # */ 1255 if (rc) 1256 goto error; 1257 } 1258 attn_LED_blink(slot_cur); 1259 1260 if (slot_cur->func == NULL) { 1261 /* We need this for fncs's that were there on bootup */ 1262 slot_cur->func = kzalloc(sizeof(struct pci_func), GFP_KERNEL); 1263 if (!slot_cur->func) { 1264 err("out of system memory\n"); 1265 rc = -ENOMEM; 1266 goto error; 1267 } 1268 slot_cur->func->busno = slot_cur->bus; 1269 slot_cur->func->device = slot_cur->device; 1270 } 1271 1272 ibm_unconfigure_device(slot_cur->func); 1273 1274 /* If we got here from latch suddenly opening on operating card or 1275 a power fault, there's no power to the card, so cannot 1276 read from it to determine what resources it occupied. This operation 1277 is forbidden anyhow. The best we can do is remove it from kernel 1278 lists at least */ 1279 1280 if (!flag) { 1281 attn_off(slot_cur); 1282 return 0; 1283 } 1284 1285 rc = ibmphp_unconfigure_card(&slot_cur, 0); 1286 slot_cur->func = NULL; 1287 debug("in disable_slot. after unconfigure_card\n"); 1288 if (rc) { 1289 err("could not unconfigure card.\n"); 1290 goto error; 1291 } 1292 1293 rc = ibmphp_hpc_writeslot(slot_cur, HPC_SLOT_OFF); 1294 if (rc) 1295 goto error; 1296 1297 attn_off(slot_cur); 1298 rc = slot_update(&slot_cur); 1299 if (rc) 1300 goto exit; 1301 1302 rc = ibmphp_update_slot_info(slot_cur); 1303 ibmphp_print_test(); 1304 exit: 1305 return rc; 1306 1307 error: 1308 /* Need to turn off if was blinking b4 */ 1309 attn_off(slot_cur); 1310 attn_on(slot_cur); 1311 if (slot_update(&slot_cur)) { 1312 rc = -EFAULT; 1313 goto exit; 1314 } 1315 if (flag) 1316 ibmphp_update_slot_info(slot_cur); 1317 goto exit; 1318 } 1319 1320 struct hotplug_slot_ops ibmphp_hotplug_slot_ops = { 1321 .owner = THIS_MODULE, 1322 .set_attention_status = set_attention_status, 1323 .enable_slot = enable_slot, 1324 .disable_slot = ibmphp_disable_slot, 1325 .hardware_test = NULL, 1326 .get_power_status = get_power_status, 1327 .get_attention_status = get_attention_status, 1328 .get_latch_status = get_latch_status, 1329 .get_adapter_status = get_adapter_present, 1330 .get_max_bus_speed = get_max_bus_speed, 1331 .get_cur_bus_speed = get_cur_bus_speed, 1332 /* .get_max_adapter_speed = get_max_adapter_speed, 1333 .get_bus_name_status = get_bus_name, 1334 */ 1335 }; 1336 1337 static void ibmphp_unload(void) 1338 { 1339 free_slots(); 1340 debug("after slots\n"); 1341 ibmphp_free_resources(); 1342 debug("after resources\n"); 1343 ibmphp_free_bus_info_queue(); 1344 debug("after bus info\n"); 1345 ibmphp_free_ebda_hpc_queue(); 1346 debug("after ebda hpc\n"); 1347 ibmphp_free_ebda_pci_rsrc_queue(); 1348 debug("after ebda pci rsrc\n"); 1349 kfree(ibmphp_pci_bus); 1350 } 1351 1352 static int __init ibmphp_init(void) 1353 { 1354 struct pci_bus *bus; 1355 int i = 0; 1356 int rc = 0; 1357 1358 init_flag = 1; 1359 1360 info(DRIVER_DESC " version: " DRIVER_VERSION "\n"); 1361 1362 ibmphp_pci_bus = kmalloc(sizeof(*ibmphp_pci_bus), GFP_KERNEL); 1363 if (!ibmphp_pci_bus) { 1364 err("out of memory\n"); 1365 rc = -ENOMEM; 1366 goto exit; 1367 } 1368 1369 bus = pci_find_bus(0, 0); 1370 if (!bus) { 1371 err("Can't find the root pci bus, can not continue\n"); 1372 rc = -ENODEV; 1373 goto error; 1374 } 1375 memcpy(ibmphp_pci_bus, bus, sizeof(*ibmphp_pci_bus)); 1376 1377 ibmphp_debug = debug; 1378 1379 ibmphp_hpc_initvars(); 1380 1381 for (i = 0; i < 16; i++) 1382 irqs[i] = 0; 1383 1384 if ((rc = ibmphp_access_ebda())) 1385 goto error; 1386 debug("after ibmphp_access_ebda()\n"); 1387 1388 if ((rc = ibmphp_rsrc_init())) 1389 goto error; 1390 debug("AFTER Resource & EBDA INITIALIZATIONS\n"); 1391 1392 max_slots = get_max_slots(); 1393 1394 if ((rc = ibmphp_register_pci())) 1395 goto error; 1396 1397 if (init_ops()) { 1398 rc = -ENODEV; 1399 goto error; 1400 } 1401 1402 ibmphp_print_test(); 1403 if ((rc = ibmphp_hpc_start_poll_thread())) { 1404 goto error; 1405 } 1406 1407 exit: 1408 return rc; 1409 1410 error: 1411 ibmphp_unload(); 1412 goto exit; 1413 } 1414 1415 static void __exit ibmphp_exit(void) 1416 { 1417 ibmphp_hpc_stop_poll_thread(); 1418 debug("after polling\n"); 1419 ibmphp_unload(); 1420 debug("done\n"); 1421 } 1422 1423 module_init(ibmphp_init); 1424