git.oblomov.eu Git - linux-2.6/blob - drivers/pci/hotplug/ibmphp_core.c

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