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