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