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_param(debug, bool, S_IRUGO | S_IWUSR);
  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         msleep(3000);   /* 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         int retval;
 842         static struct pci_device_id ciobx[] = {
 843                 { PCI_DEVICE(PCI_VENDOR_ID_SERVERWORKS, 0x0101) },
 844                 { },
 845         };
 846
 847         debug ("%s - entry slot # %d\n", __FUNCTION__, slot_cur->number);
 848         if (SET_BUS_STATUS (slot_cur->ctrl) && is_bus_empty (slot_cur)) {
 849                 rc = slot_update (&slot_cur);
 850                 if (rc)
 851                         return rc;
 852                 speed = SLOT_SPEED (slot_cur->ext_status);
 853                 debug ("ext_status = %x, speed = %x\n", slot_cur->ext_status, speed);
 854                 switch (speed) {
 855                 case HPC_SLOT_SPEED_33:
 856                         cmd = HPC_BUS_33CONVMODE;
 857                         break;
 858                 case HPC_SLOT_SPEED_66:
 859                         if (SLOT_PCIX (slot_cur->ext_status)) {
 860                                 if ((slot_cur->supported_speed >= BUS_SPEED_66) && (slot_cur->supported_bus_mode == BUS_MODE_PCIX))
 861                                         cmd = HPC_BUS_66PCIXMODE;
 862                                 else if (!SLOT_BUS_MODE (slot_cur->ext_status))
 863                                         /* if max slot/bus capability is 66 pci
 864                                         and there's no bus mode mismatch, then
 865                                         the adapter supports 66 pci */
 866                                         cmd = HPC_BUS_66CONVMODE;
 867                                 else
 868                                         cmd = HPC_BUS_33CONVMODE;
 869                         } else {
 870                                 if (slot_cur->supported_speed >= BUS_SPEED_66)
 871                                         cmd = HPC_BUS_66CONVMODE;
 872                                 else
 873                                         cmd = HPC_BUS_33CONVMODE;
 874                         }
 875                         break;
 876                 case HPC_SLOT_SPEED_133:
 877                         switch (slot_cur->supported_speed) {
 878                         case BUS_SPEED_33:
 879                                 cmd = HPC_BUS_33CONVMODE;
 880                                 break;
 881                         case BUS_SPEED_66:
 882                                 if (slot_cur->supported_bus_mode == BUS_MODE_PCIX)
 883                                         cmd = HPC_BUS_66PCIXMODE;
 884                                 else
 885                                         cmd = HPC_BUS_66CONVMODE;
 886                                 break;
 887                         case BUS_SPEED_100:
 888                                 cmd = HPC_BUS_100PCIXMODE;
 889                                 break;
 890                         case BUS_SPEED_133:
 891                                 /* This is to take care of the bug in CIOBX chip */
 892                                 if (pci_dev_present(ciobx))
 893                                         ibmphp_hpc_writeslot (slot_cur, HPC_BUS_100PCIXMODE);
 894                                 cmd = HPC_BUS_133PCIXMODE;
 895                                 break;
 896                         default:
 897                                 err ("Wrong bus speed\n");
 898                                 return -ENODEV;
 899                         }
 900                         break;
 901                 default:
 902                         err ("wrong slot speed\n");
 903                         return -ENODEV;
 904                 }
 905                 debug ("setting bus speed for slot %d, cmd %x\n", slot_cur->number, cmd);
 906                 retval = ibmphp_hpc_writeslot (slot_cur, cmd);
 907                 if (retval) {
 908                         err ("setting bus speed failed\n");
 909                         return retval;
 910                 }
 911                 if (CTLR_RESULT (slot_cur->ctrl->status)) {
 912                         err ("command not completed successfully in set_bus\n");
 913                         return -EIO;
 914                 }
 915         }
 916         /* This is for x440, once Brandon fixes the firmware,
 917         will not need this delay */
 918         msleep(1000);
 919         debug ("%s -Exit\n", __FUNCTION__);
 920         return 0;
 921 }
 922
 923 /* This routine checks the bus limitations that the slot is on from the BIOS.
 924  * This is used in deciding whether or not to power up the slot.
 925  * (electrical/spec limitations. For example, >1 133 MHz or >2 66 PCI cards on
 926  * same bus)
 927  * Parameters: slot
 928  * Returns: 0 = no limitations, -EINVAL = exceeded limitations on the bus
 929  */
 930 static int check_limitations (struct slot *slot_cur)
 931 {
 932         u8 i;
 933         struct slot * tmp_slot;
 934         u8 count = 0;
 935         u8 limitation = 0;
 936
 937         for (i = slot_cur->bus_on->slot_min; i <= slot_cur->bus_on->slot_max; i++) {
 938                 tmp_slot = ibmphp_get_slot_from_physical_num (i);
 939                 if (!tmp_slot)
 940                         return -ENODEV;
 941                 if ((SLOT_PWRGD (tmp_slot->status)) && !(SLOT_CONNECT (tmp_slot->status)))
 942                         count++;
 943         }
 944         get_cur_bus_info (&slot_cur);
 945         switch (slot_cur->bus_on->current_speed) {
 946         case BUS_SPEED_33:
 947                 limitation = slot_cur->bus_on->slots_at_33_conv;
 948                 break;
 949         case BUS_SPEED_66:
 950                 if (slot_cur->bus_on->current_bus_mode == BUS_MODE_PCIX)
 951                         limitation = slot_cur->bus_on->slots_at_66_pcix;
 952                 else
 953                         limitation = slot_cur->bus_on->slots_at_66_conv;
 954                 break;
 955         case BUS_SPEED_100:
 956                 limitation = slot_cur->bus_on->slots_at_100_pcix;
 957                 break;
 958         case BUS_SPEED_133:
 959                 limitation = slot_cur->bus_on->slots_at_133_pcix;
 960                 break;
 961         }
 962
 963         if ((count + 1) > limitation)
 964                 return -EINVAL;
 965         return 0;
 966 }
 967
 968 static inline void print_card_capability (struct slot *slot_cur)
 969 {
 970         info ("capability of the card is ");
 971         if ((slot_cur->ext_status & CARD_INFO) == PCIX133)
 972                 info ("   133 MHz PCI-X\n");
 973         else if ((slot_cur->ext_status & CARD_INFO) == PCIX66)
 974                 info ("    66 MHz PCI-X\n");
 975         else if ((slot_cur->ext_status & CARD_INFO) == PCI66)
 976                 info ("    66 MHz PCI\n");
 977         else
 978                 info ("    33 MHz PCI\n");
 979
 980 }
 981
 982 /* This routine will power on the slot, configure the device(s) and find the
 983  * drivers for them.
 984  * Parameters: hotplug_slot
 985  * Returns: 0 or failure codes
 986  */
 987 static int enable_slot (struct hotplug_slot *hs)
 988 {
 989         int rc, i, rcpr;
 990         struct slot *slot_cur;
 991         u8 function;
 992         struct pci_func *tmp_func;
 993
 994         ibmphp_lock_operations ();
 995
 996         debug ("ENABLING SLOT........\n");
 997         slot_cur = (struct slot *) hs->private;
 998
 999         if ((rc = validate (slot_cur, ENABLE))) {
1000                 err ("validate function failed\n");
1001                 goto error_nopower;
1002         }
1003
1004         attn_LED_blink (slot_cur);
1005
1006         rc = set_bus (slot_cur);
1007         if (rc) {
1008                 err ("was not able to set the bus\n");
1009                 goto error_nopower;
1010         }
1011
1012         /*-----------------debugging------------------------------*/
1013         get_cur_bus_info (&slot_cur);
1014         debug ("the current bus speed right after set_bus = %x\n", slot_cur->bus_on->current_speed);
1015         /*----------------------------------------------------------*/
1016
1017         rc = check_limitations (slot_cur);
1018         if (rc) {
1019                 err ("Adding this card exceeds the limitations of this bus.\n");
1020                 err ("(i.e., >1 133MHz cards running on same bus, or "
1021                      ">2 66 PCI cards running on same bus\n.");
1022                 err ("Try hot-adding into another bus\n");
1023                 rc = -EINVAL;
1024                 goto error_nopower;
1025         }
1026
1027         rc = power_on (slot_cur);
1028
1029         if (rc) {
1030                 err ("something wrong when powering up... please see below for details\n");
1031                 /* need to turn off before on, otherwise, blinking overwrites */
1032                 attn_off(slot_cur);
1033                 attn_on (slot_cur);
1034                 if (slot_update (&slot_cur)) {
1035                         attn_off (slot_cur);
1036                         attn_on (slot_cur);
1037                         rc = -ENODEV;
1038                         goto exit;
1039                 }
1040                 /* Check to see the error of why it failed */
1041                 if ((SLOT_POWER (slot_cur->status)) && !(SLOT_PWRGD (slot_cur->status)))
1042                         err ("power fault occurred trying to power up\n");
1043                 else if (SLOT_BUS_SPEED (slot_cur->status)) {
1044                         err ("bus speed mismatch occurred.  please check current bus speed and card capability\n");
1045                         print_card_capability (slot_cur);
1046                 } else if (SLOT_BUS_MODE (slot_cur->ext_status)) {
1047                         err ("bus mode mismatch occurred.  please check current bus mode and card capability\n");
1048                         print_card_capability (slot_cur);
1049                 }
1050                 ibmphp_update_slot_info (slot_cur);
1051                 goto exit;
1052         }
1053         debug ("after power_on\n");
1054         /*-----------------------debugging---------------------------*/
1055         get_cur_bus_info (&slot_cur);
1056         debug ("the current bus speed right after power_on = %x\n", slot_cur->bus_on->current_speed);
1057         /*----------------------------------------------------------*/
1058
1059         rc = slot_update (&slot_cur);
1060         if (rc)
1061                 goto error_power;
1062
1063         rc = -EINVAL;
1064         if (SLOT_POWER (slot_cur->status) && !(SLOT_PWRGD (slot_cur->status))) {
1065                 err ("power fault occurred trying to power up...\n");
1066                 goto error_power;
1067         }
1068         if (SLOT_POWER (slot_cur->status) && (SLOT_BUS_SPEED (slot_cur->status))) {
1069                 err ("bus speed mismatch occurred.  please check current bus speed and card capability\n");
1070                 print_card_capability (slot_cur);
1071                 goto error_power;
1072         }
1073         /* Don't think this case will happen after above checks... but just in case, for paranoia sake */
1074         if (!(SLOT_POWER (slot_cur->status))) {
1075                 err ("power on failed...\n");
1076                 goto error_power;
1077         }
1078
1079         slot_cur->func = (struct pci_func *) kmalloc (sizeof (struct pci_func), GFP_KERNEL);
1080         if (!slot_cur->func) {
1081                 /* We cannot do update_slot_info here, since no memory for
1082                  * kmalloc n.e.ways, and update_slot_info allocates some */
1083                 err ("out of system memory\n");
1084                 rc = -ENOMEM;
1085                 goto error_power;
1086         }
1087         memset (slot_cur->func, 0, sizeof (struct pci_func));
1088         slot_cur->func->busno = slot_cur->bus;
1089         slot_cur->func->device = slot_cur->device;
1090         for (i = 0; i < 4; i++)
1091                 slot_cur->func->irq[i] = slot_cur->irq[i];
1092
1093         debug ("b4 configure_card, slot_cur->bus = %x, slot_cur->device = %x\n", slot_cur->bus, slot_cur->device);
1094
1095         if (ibmphp_configure_card (slot_cur->func, slot_cur->number)) {
1096                 err ("configure_card was unsuccessful...\n");
1097                 ibmphp_unconfigure_card (&slot_cur, 1); /* true because don't need to actually deallocate resources, just remove references */
1098                 debug ("after unconfigure_card\n");
1099                 slot_cur->func = NULL;
1100                 rc = -ENOMEM;
1101                 goto error_power;
1102         }
1103
1104         function = 0x00;
1105         do {
1106                 tmp_func = ibm_slot_find (slot_cur->bus, slot_cur->func->device, function++);
1107                 if (tmp_func && !(tmp_func->dev))
1108                         ibm_configure_device (tmp_func);
1109         } while (tmp_func);
1110
1111         attn_off (slot_cur);
1112         if (slot_update (&slot_cur)) {
1113                 rc = -EFAULT;
1114                 goto exit;
1115         }
1116         ibmphp_print_test ();
1117         rc = ibmphp_update_slot_info (slot_cur);
1118 exit:
1119         ibmphp_unlock_operations();
1120         return rc;
1121
1122 error_nopower:
1123         attn_off (slot_cur);    /* need to turn off if was blinking b4 */
1124         attn_on (slot_cur);
1125 error_cont:
1126         rcpr = slot_update (&slot_cur);
1127         if (rcpr) {
1128                 rc = rcpr;
1129                 goto exit;
1130         }
1131         ibmphp_update_slot_info (slot_cur);
1132         goto exit;
1133
1134 error_power:
1135         attn_off (slot_cur);    /* need to turn off if was blinking b4 */
1136         attn_on (slot_cur);
1137         rcpr = power_off (slot_cur);
1138         if (rcpr) {
1139                 rc = rcpr;
1140                 goto exit;
1141         }
1142         goto error_cont;
1143 }
1144
1145 /**************************************************************
1146 * HOT REMOVING ADAPTER CARD                                   *
1147 * INPUT: POINTER TO THE HOTPLUG SLOT STRUCTURE                *
1148 * OUTPUT: SUCCESS 0 ; FAILURE: UNCONFIGURE , VALIDATE         *
1149           DISABLE POWER ,                                    *
1150 **************************************************************/
1151 static int ibmphp_disable_slot (struct hotplug_slot *hotplug_slot)
1152 {
1153         struct slot *slot = hotplug_slot->private;
1154         int rc;
1155
1156         ibmphp_lock_operations();
1157         rc = ibmphp_do_disable_slot(slot);
1158         ibmphp_unlock_operations();
1159         return rc;
1160 }
1161
1162 int ibmphp_do_disable_slot (struct slot *slot_cur)
1163 {
1164         int rc;
1165         u8 flag;
1166
1167         debug ("DISABLING SLOT...\n");
1168
1169         if ((slot_cur == NULL) || (slot_cur->ctrl == NULL)) {
1170                 return -ENODEV;
1171         }
1172
1173         flag = slot_cur->flag;
1174         slot_cur->flag = TRUE;
1175
1176         if (flag == TRUE) {
1177                 rc = validate (slot_cur, DISABLE);      /* checking if powered off already & valid slot # */
1178                 if (rc)
1179                         goto error;
1180         }
1181         attn_LED_blink (slot_cur);
1182
1183         if (slot_cur->func == NULL) {
1184                 /* We need this for fncs's that were there on bootup */
1185                 slot_cur->func = (struct pci_func *) kmalloc (sizeof (struct pci_func), GFP_KERNEL);
1186                 if (!slot_cur->func) {
1187                         err ("out of system memory\n");
1188                         rc = -ENOMEM;
1189                         goto error;
1190                 }
1191                 memset (slot_cur->func, 0, sizeof (struct pci_func));
1192                 slot_cur->func->busno = slot_cur->bus;
1193                 slot_cur->func->device = slot_cur->device;
1194         }
1195
1196         ibm_unconfigure_device(slot_cur->func);
1197
1198         /* If we got here from latch suddenly opening on operating card or
1199         a power fault, there's no power to the card, so cannot
1200         read from it to determine what resources it occupied.  This operation
1201         is forbidden anyhow.  The best we can do is remove it from kernel
1202         lists at least */
1203
1204         if (!flag) {
1205                 attn_off (slot_cur);
1206                 return 0;
1207         }
1208
1209         rc = ibmphp_unconfigure_card (&slot_cur, 0);
1210         slot_cur->func = NULL;
1211         debug ("in disable_slot. after unconfigure_card\n");
1212         if (rc) {
1213                 err ("could not unconfigure card.\n");
1214                 goto error;
1215         }
1216
1217         rc = ibmphp_hpc_writeslot (slot_cur, HPC_SLOT_OFF);
1218         if (rc)
1219                 goto error;
1220
1221         attn_off (slot_cur);
1222         rc = slot_update (&slot_cur);
1223         if (rc)
1224                 goto exit;
1225
1226         rc = ibmphp_update_slot_info (slot_cur);
1227         ibmphp_print_test ();
1228 exit:
1229         return rc;
1230
1231 error:
1232         /*  Need to turn off if was blinking b4 */
1233         attn_off (slot_cur);
1234         attn_on (slot_cur);
1235         if (slot_update (&slot_cur)) {
1236                 rc = -EFAULT;
1237                 goto exit;
1238         }
1239         if (flag)
1240                 ibmphp_update_slot_info (slot_cur);
1241         goto exit;
1242 }
1243
1244 struct hotplug_slot_ops ibmphp_hotplug_slot_ops = {
1245         .owner =                        THIS_MODULE,
1246         .set_attention_status =         set_attention_status,
1247         .enable_slot =                  enable_slot,
1248         .disable_slot =                 ibmphp_disable_slot,
1249         .hardware_test =                NULL,
1250         .get_power_status =             get_power_status,
1251         .get_attention_status =         get_attention_status,
1252         .get_latch_status =             get_latch_status,
1253         .get_adapter_status =           get_adapter_present,
1254         .get_max_bus_speed =            get_max_bus_speed,
1255         .get_cur_bus_speed =            get_cur_bus_speed,
1256 /*      .get_max_adapter_speed =        get_max_adapter_speed,
1257         .get_bus_name_status =          get_bus_name,
1258 */
1259 };
1260
1261 static void ibmphp_unload (void)
1262 {
1263         free_slots ();
1264         debug ("after slots\n");
1265         ibmphp_free_resources ();
1266         debug ("after resources\n");
1267         ibmphp_free_bus_info_queue ();
1268         debug ("after bus info\n");
1269         ibmphp_free_ebda_hpc_queue ();
1270         debug ("after ebda hpc\n");
1271         ibmphp_free_ebda_pci_rsrc_queue ();
1272         debug ("after ebda pci rsrc\n");
1273         kfree (ibmphp_pci_bus);
1274 }
1275
1276 static int __init ibmphp_init (void)
1277 {
1278         struct pci_bus *bus;
1279         int i = 0;
1280         int rc = 0;
1281
1282         init_flag = 1;
1283
1284         info (DRIVER_DESC " version: " DRIVER_VERSION "\n");
1285
1286         ibmphp_pci_bus = kmalloc (sizeof (*ibmphp_pci_bus), GFP_KERNEL);
1287         if (!ibmphp_pci_bus) {
1288                 err ("out of memory\n");
1289                 rc = -ENOMEM;
1290                 goto exit;
1291         }
1292
1293         bus = pci_find_bus(0, 0);
1294         if (!bus) {
1295                 err ("Can't find the root pci bus, can not continue\n");
1296                 rc = -ENODEV;
1297                 goto error;
1298         }
1299         memcpy (ibmphp_pci_bus, bus, sizeof (*ibmphp_pci_bus));
1300
1301         ibmphp_debug = debug;
1302
1303         ibmphp_hpc_initvars ();
1304
1305         for (i = 0; i < 16; i++)
1306                 irqs[i] = 0;
1307
1308         if ((rc = ibmphp_access_ebda ()))
1309                 goto error;
1310         debug ("after ibmphp_access_ebda ()\n");
1311
1312         if ((rc = ibmphp_rsrc_init ()))
1313                 goto error;
1314         debug ("AFTER Resource & EBDA INITIALIZATIONS\n");
1315
1316         max_slots = get_max_slots ();
1317
1318         if ((rc = ibmphp_register_pci ()))
1319                 goto error;
1320
1321         if (init_ops ()) {
1322                 rc = -ENODEV;
1323                 goto error;
1324         }
1325
1326         ibmphp_print_test ();
1327         if ((rc = ibmphp_hpc_start_poll_thread ())) {
1328                 goto error;
1329         }
1330
1331         /* lock ourselves into memory with a module
1332          * count of -1 so that no one can unload us. */
1333         module_put(THIS_MODULE);
1334
1335 exit:
1336         return rc;
1337
1338 error:
1339         ibmphp_unload ();
1340         goto exit;
1341 }
1342
1343 static void __exit ibmphp_exit (void)
1344 {
1345         ibmphp_hpc_stop_poll_thread ();
1346         debug ("after polling\n");
1347         ibmphp_unload ();
1348         debug ("done\n");
1349 }
1350
1351 module_init (ibmphp_init);
1352 module_exit (ibmphp_exit);