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