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