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