drivers/pci/hotplug/ibmphp_core.c

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