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