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