SAFE public projects git trees. - safe/jmp/linux-2.6/blob - drivers/pci/hotplug/cpci_hotplug_core.c

   1 /*
   2  * CompactPCI Hot Plug Driver
   3  *
   4  * Copyright (C) 2002,2005 SOMA Networks, Inc.
   5  * Copyright (C) 2001 Greg Kroah-Hartman (greg@kroah.com)
   6  * Copyright (C) 2001 IBM Corp.
   7  *
   8  * All rights reserved.
   9  *
  10  * This program is free software; you can redistribute it and/or modify
  11  * it under the terms of the GNU General Public License as published by
  12  * the Free Software Foundation; either version 2 of the License, or (at
  13  * your option) any later version.
  14  *
  15  * This program is distributed in the hope that it will be useful, but
  16  * WITHOUT ANY WARRANTY; without even the implied warranty of
  17  * MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE, GOOD TITLE or
  18  * NON INFRINGEMENT.  See the GNU General Public License for more
  19  * details.
  20  *
  21  * You should have received a copy of the GNU General Public License
  22  * along with this program; if not, write to the Free Software
  23  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  24  *
  25  * Send feedback to <scottm@somanetworks.com>
  26  */
  27
  28 #include <linux/module.h>
  29 #include <linux/kernel.h>
  30 #include <linux/slab.h>
  31 #include <linux/pci.h>
  32 #include <linux/pci_hotplug.h>
  33 #include <linux/init.h>
  34 #include <linux/interrupt.h>
  35 #include <linux/smp_lock.h>
  36 #include <asm/atomic.h>
  37 #include <linux/delay.h>
  38 #include <linux/kthread.h>
  39 #include "cpci_hotplug.h"
  40
  41 #define DRIVER_AUTHOR   "Scott Murray <scottm@somanetworks.com>"
  42 #define DRIVER_DESC     "CompactPCI Hot Plug Core"
  43
  44 #define MY_NAME "cpci_hotplug"
  45
  46 #define dbg(format, arg...)                                     \
  47         do {                                                    \
  48                 if (cpci_debug)                                 \
  49                         printk (KERN_DEBUG "%s: " format "\n",  \
  50                                 MY_NAME , ## arg);              \
  51         } while (0)
  52 #define err(format, arg...) printk(KERN_ERR "%s: " format "\n", MY_NAME , ## arg)
  53 #define info(format, arg...) printk(KERN_INFO "%s: " format "\n", MY_NAME , ## arg)
  54 #define warn(format, arg...) printk(KERN_WARNING "%s: " format "\n", MY_NAME , ## arg)
  55
  56 /* local variables */
  57 static DECLARE_RWSEM(list_rwsem);
  58 static LIST_HEAD(slot_list);
  59 static int slots;
  60 static atomic_t extracting;
  61 int cpci_debug;
  62 static struct cpci_hp_controller *controller;
  63 static struct task_struct *cpci_thread;
  64 static int thread_finished;
  65
  66 static int enable_slot(struct hotplug_slot *slot);
  67 static int disable_slot(struct hotplug_slot *slot);
  68 static int set_attention_status(struct hotplug_slot *slot, u8 value);
  69 static int get_power_status(struct hotplug_slot *slot, u8 * value);
  70 static int get_attention_status(struct hotplug_slot *slot, u8 * value);
  71 static int get_adapter_status(struct hotplug_slot *slot, u8 * value);
  72 static int get_latch_status(struct hotplug_slot *slot, u8 * value);
  73
  74 static struct hotplug_slot_ops cpci_hotplug_slot_ops = {
  75         .owner = THIS_MODULE,
  76         .enable_slot = enable_slot,
  77         .disable_slot = disable_slot,
  78         .set_attention_status = set_attention_status,
  79         .get_power_status = get_power_status,
  80         .get_attention_status = get_attention_status,
  81         .get_adapter_status = get_adapter_status,
  82         .get_latch_status = get_latch_status,
  83 };
  84
  85 static int
  86 update_latch_status(struct hotplug_slot *hotplug_slot, u8 value)
  87 {
  88         struct hotplug_slot_info info;
  89
  90         memcpy(&info, hotplug_slot->info, sizeof(struct hotplug_slot_info));
  91         info.latch_status = value;
  92         return pci_hp_change_slot_info(hotplug_slot, &info);
  93 }
  94
  95 static int
  96 update_adapter_status(struct hotplug_slot *hotplug_slot, u8 value)
  97 {
  98         struct hotplug_slot_info info;
  99
 100         memcpy(&info, hotplug_slot->info, sizeof(struct hotplug_slot_info));
 101         info.adapter_status = value;
 102         return pci_hp_change_slot_info(hotplug_slot, &info);
 103 }
 104
 105 static int
 106 enable_slot(struct hotplug_slot *hotplug_slot)
 107 {
 108         struct slot *slot = hotplug_slot->private;
 109         int retval = 0;
 110
 111         dbg("%s - physical_slot = %s", __func__, hotplug_slot->name);
 112
 113         if (controller->ops->set_power)
 114                 retval = controller->ops->set_power(slot, 1);
 115         return retval;
 116 }
 117
 118 static int
 119 disable_slot(struct hotplug_slot *hotplug_slot)
 120 {
 121         struct slot *slot = hotplug_slot->private;
 122         int retval = 0;
 123
 124         dbg("%s - physical_slot = %s", __func__, hotplug_slot->name);
 125
 126         down_write(&list_rwsem);
 127
 128         /* Unconfigure device */
 129         dbg("%s - unconfiguring slot %s",
 130             __func__, slot->hotplug_slot->name);
 131         if ((retval = cpci_unconfigure_slot(slot))) {
 132                 err("%s - could not unconfigure slot %s",
 133                     __func__, slot->hotplug_slot->name);
 134                 goto disable_error;
 135         }
 136         dbg("%s - finished unconfiguring slot %s",
 137             __func__, slot->hotplug_slot->name);
 138
 139         /* Clear EXT (by setting it) */
 140         if (cpci_clear_ext(slot)) {
 141                 err("%s - could not clear EXT for slot %s",
 142                     __func__, slot->hotplug_slot->name);
 143                 retval = -ENODEV;
 144                 goto disable_error;
 145         }
 146         cpci_led_on(slot);
 147
 148         if (controller->ops->set_power)
 149                 if ((retval = controller->ops->set_power(slot, 0)))
 150                         goto disable_error;
 151
 152         if (update_adapter_status(slot->hotplug_slot, 0))
 153                 warn("failure to update adapter file");
 154
 155         if (slot->extracting) {
 156                 slot->extracting = 0;
 157                 atomic_dec(&extracting);
 158         }
 159 disable_error:
 160         up_write(&list_rwsem);
 161         return retval;
 162 }
 163
 164 static u8
 165 cpci_get_power_status(struct slot *slot)
 166 {
 167         u8 power = 1;
 168
 169         if (controller->ops->get_power)
 170                 power = controller->ops->get_power(slot);
 171         return power;
 172 }
 173
 174 static int
 175 get_power_status(struct hotplug_slot *hotplug_slot, u8 * value)
 176 {
 177         struct slot *slot = hotplug_slot->private;
 178
 179         *value = cpci_get_power_status(slot);
 180         return 0;
 181 }
 182
 183 static int
 184 get_attention_status(struct hotplug_slot *hotplug_slot, u8 * value)
 185 {
 186         struct slot *slot = hotplug_slot->private;
 187
 188         *value = cpci_get_attention_status(slot);
 189         return 0;
 190 }
 191
 192 static int
 193 set_attention_status(struct hotplug_slot *hotplug_slot, u8 status)
 194 {
 195         return cpci_set_attention_status(hotplug_slot->private, status);
 196 }
 197
 198 static int
 199 get_adapter_status(struct hotplug_slot *hotplug_slot, u8 * value)
 200 {
 201         *value = hotplug_slot->info->adapter_status;
 202         return 0;
 203 }
 204
 205 static int
 206 get_latch_status(struct hotplug_slot *hotplug_slot, u8 * value)
 207 {
 208         *value = hotplug_slot->info->latch_status;
 209         return 0;
 210 }
 211
 212 static void release_slot(struct hotplug_slot *hotplug_slot)
 213 {
 214         struct slot *slot = hotplug_slot->private;
 215
 216         kfree(slot->hotplug_slot->info);
 217         kfree(slot->hotplug_slot->name);
 218         kfree(slot->hotplug_slot);
 219         if (slot->dev)
 220                 pci_dev_put(slot->dev);
 221         kfree(slot);
 222 }
 223
 224 #define SLOT_NAME_SIZE  6
 225 static void
 226 make_slot_name(struct slot *slot)
 227 {
 228         snprintf(slot->hotplug_slot->name,
 229                  SLOT_NAME_SIZE, "%02x:%02x", slot->bus->number, slot->number);
 230 }
 231
 232 int
 233 cpci_hp_register_bus(struct pci_bus *bus, u8 first, u8 last)
 234 {
 235         struct slot *slot;
 236         struct hotplug_slot *hotplug_slot;
 237         struct hotplug_slot_info *info;
 238         char *name;
 239         int status = -ENOMEM;
 240         int i;
 241
 242         if (!(controller && bus))
 243                 return -ENODEV;
 244
 245         /*
 246          * Create a structure for each slot, and register that slot
 247          * with the pci_hotplug subsystem.
 248          */
 249         for (i = first; i <= last; ++i) {
 250                 slot = kzalloc(sizeof (struct slot), GFP_KERNEL);
 251                 if (!slot)
 252                         goto error;
 253
 254                 hotplug_slot =
 255                         kzalloc(sizeof (struct hotplug_slot), GFP_KERNEL);
 256                 if (!hotplug_slot)
 257                         goto error_slot;
 258                 slot->hotplug_slot = hotplug_slot;
 259
 260                 info = kzalloc(sizeof (struct hotplug_slot_info), GFP_KERNEL);
 261                 if (!info)
 262                         goto error_hpslot;
 263                 hotplug_slot->info = info;
 264
 265                 name = kmalloc(SLOT_NAME_SIZE, GFP_KERNEL);
 266                 if (!name)
 267                         goto error_info;
 268                 hotplug_slot->name = name;
 269
 270                 slot->bus = bus;
 271                 slot->number = i;
 272                 slot->devfn = PCI_DEVFN(i, 0);
 273
 274                 hotplug_slot->private = slot;
 275                 hotplug_slot->release = &release_slot;
 276                 make_slot_name(slot);
 277                 hotplug_slot->ops = &cpci_hotplug_slot_ops;
 278
 279                 /*
 280                  * Initialize the slot info structure with some known
 281                  * good values.
 282                  */
 283                 dbg("initializing slot %s", slot->hotplug_slot->name);
 284                 info->power_status = cpci_get_power_status(slot);
 285                 info->attention_status = cpci_get_attention_status(slot);
 286
 287                 dbg("registering slot %s", slot->hotplug_slot->name);
 288                 status = pci_hp_register(slot->hotplug_slot, bus, i,
 289                                          slot->hotplug_slot->name);
 290                 if (status) {
 291                         err("pci_hp_register failed with error %d", status);
 292                         goto error_name;
 293                 }
 294
 295                 /* Add slot to our internal list */
 296                 down_write(&list_rwsem);
 297                 list_add(&slot->slot_list, &slot_list);
 298                 slots++;
 299                 up_write(&list_rwsem);
 300         }
 301         return 0;
 302 error_name:
 303         kfree(name);
 304 error_info:
 305         kfree(info);
 306 error_hpslot:
 307         kfree(hotplug_slot);
 308 error_slot:
 309         kfree(slot);
 310 error:
 311         return status;
 312 }
 313
 314 int
 315 cpci_hp_unregister_bus(struct pci_bus *bus)
 316 {
 317         struct slot *slot;
 318         struct slot *tmp;
 319         int status = 0;
 320
 321         down_write(&list_rwsem);
 322         if (!slots) {
 323                 up_write(&list_rwsem);
 324                 return -1;
 325         }
 326         list_for_each_entry_safe(slot, tmp, &slot_list, slot_list) {
 327                 if (slot->bus == bus) {
 328                         list_del(&slot->slot_list);
 329                         slots--;
 330
 331                         dbg("deregistering slot %s", slot->hotplug_slot->name);
 332                         status = pci_hp_deregister(slot->hotplug_slot);
 333                         if (status) {
 334                                 err("pci_hp_deregister failed with error %d",
 335                                     status);
 336                                 break;
 337                         }
 338                 }
 339         }
 340         up_write(&list_rwsem);
 341         return status;
 342 }
 343
 344 /* This is the interrupt mode interrupt handler */
 345 static irqreturn_t
 346 cpci_hp_intr(int irq, void *data)
 347 {
 348         dbg("entered cpci_hp_intr");
 349
 350         /* Check to see if it was our interrupt */
 351         if ((controller->irq_flags & IRQF_SHARED) &&
 352             !controller->ops->check_irq(controller->dev_id)) {
 353                 dbg("exited cpci_hp_intr, not our interrupt");
 354                 return IRQ_NONE;
 355         }
 356
 357         /* Disable ENUM interrupt */
 358         controller->ops->disable_irq();
 359
 360         /* Trigger processing by the event thread */
 361         wake_up_process(cpci_thread);
 362         return IRQ_HANDLED;
 363 }
 364
 365 /*
 366  * According to PICMG 2.1 R2.0, section 6.3.2, upon
 367  * initialization, the system driver shall clear the
 368  * INS bits of the cold-inserted devices.
 369  */
 370 static int
 371 init_slots(int clear_ins)
 372 {
 373         struct slot *slot;
 374         struct pci_dev* dev;
 375
 376         dbg("%s - enter", __func__);
 377         down_read(&list_rwsem);
 378         if (!slots) {
 379                 up_read(&list_rwsem);
 380                 return -1;
 381         }
 382         list_for_each_entry(slot, &slot_list, slot_list) {
 383                 dbg("%s - looking at slot %s",
 384                     __func__, slot->hotplug_slot->name);
 385                 if (clear_ins && cpci_check_and_clear_ins(slot))
 386                         dbg("%s - cleared INS for slot %s",
 387                             __func__, slot->hotplug_slot->name);
 388                 dev = pci_get_slot(slot->bus, PCI_DEVFN(slot->number, 0));
 389                 if (dev) {
 390                         if (update_adapter_status(slot->hotplug_slot, 1))
 391                                 warn("failure to update adapter file");
 392                         if (update_latch_status(slot->hotplug_slot, 1))
 393                                 warn("failure to update latch file");
 394                         slot->dev = dev;
 395                 }
 396         }
 397         up_read(&list_rwsem);
 398         dbg("%s - exit", __func__);
 399         return 0;
 400 }
 401
 402 static int
 403 check_slots(void)
 404 {
 405         struct slot *slot;
 406         int extracted;
 407         int inserted;
 408         u16 hs_csr;
 409
 410         down_read(&list_rwsem);
 411         if (!slots) {
 412                 up_read(&list_rwsem);
 413                 err("no slots registered, shutting down");
 414                 return -1;
 415         }
 416         extracted = inserted = 0;
 417         list_for_each_entry(slot, &slot_list, slot_list) {
 418                 dbg("%s - looking at slot %s",
 419                     __func__, slot->hotplug_slot->name);
 420                 if (cpci_check_and_clear_ins(slot)) {
 421                         /*
 422                          * Some broken hardware (e.g. PLX 9054AB) asserts
 423                          * ENUM# twice...
 424                          */
 425                         if (slot->dev) {
 426                                 warn("slot %s already inserted",
 427                                      slot->hotplug_slot->name);
 428                                 inserted++;
 429                                 continue;
 430                         }
 431
 432                         /* Process insertion */
 433                         dbg("%s - slot %s inserted",
 434                             __func__, slot->hotplug_slot->name);
 435
 436                         /* GSM, debug */
 437                         hs_csr = cpci_get_hs_csr(slot);
 438                         dbg("%s - slot %s HS_CSR (1) = %04x",
 439                             __func__, slot->hotplug_slot->name, hs_csr);
 440
 441                         /* Configure device */
 442                         dbg("%s - configuring slot %s",
 443                             __func__, slot->hotplug_slot->name);
 444                         if (cpci_configure_slot(slot)) {
 445                                 err("%s - could not configure slot %s",
 446                                     __func__, slot->hotplug_slot->name);
 447                                 continue;
 448                         }
 449                         dbg("%s - finished configuring slot %s",
 450                             __func__, slot->hotplug_slot->name);
 451
 452                         /* GSM, debug */
 453                         hs_csr = cpci_get_hs_csr(slot);
 454                         dbg("%s - slot %s HS_CSR (2) = %04x",
 455                             __func__, slot->hotplug_slot->name, hs_csr);
 456
 457                         if (update_latch_status(slot->hotplug_slot, 1))
 458                                 warn("failure to update latch file");
 459
 460                         if (update_adapter_status(slot->hotplug_slot, 1))
 461                                 warn("failure to update adapter file");
 462
 463                         cpci_led_off(slot);
 464
 465                         /* GSM, debug */
 466                         hs_csr = cpci_get_hs_csr(slot);
 467                         dbg("%s - slot %s HS_CSR (3) = %04x",
 468                             __func__, slot->hotplug_slot->name, hs_csr);
 469
 470                         inserted++;
 471                 } else if (cpci_check_ext(slot)) {
 472                         /* Process extraction request */
 473                         dbg("%s - slot %s extracted",
 474                             __func__, slot->hotplug_slot->name);
 475
 476                         /* GSM, debug */
 477                         hs_csr = cpci_get_hs_csr(slot);
 478                         dbg("%s - slot %s HS_CSR = %04x",
 479                             __func__, slot->hotplug_slot->name, hs_csr);
 480
 481                         if (!slot->extracting) {
 482                                 if (update_latch_status(slot->hotplug_slot, 0)) {
 483                                         warn("failure to update latch file");
 484                                 }
 485                                 slot->extracting = 1;
 486                                 atomic_inc(&extracting);
 487                         }
 488                         extracted++;
 489                 } else if (slot->extracting) {
 490                         hs_csr = cpci_get_hs_csr(slot);
 491                         if (hs_csr == 0xffff) {
 492                                 /*
 493                                  * Hmmm, we're likely hosed at this point, should we
 494                                  * bother trying to tell the driver or not?
 495                                  */
 496                                 err("card in slot %s was improperly removed",
 497                                     slot->hotplug_slot->name);
 498                                 if (update_adapter_status(slot->hotplug_slot, 0))
 499                                         warn("failure to update adapter file");
 500                                 slot->extracting = 0;
 501                                 atomic_dec(&extracting);
 502                         }
 503                 }
 504         }
 505         up_read(&list_rwsem);
 506         dbg("inserted=%d, extracted=%d, extracting=%d",
 507             inserted, extracted, atomic_read(&extracting));
 508         if (inserted || extracted)
 509                 return extracted;
 510         else if (!atomic_read(&extracting)) {
 511                 err("cannot find ENUM# source, shutting down");
 512                 return -1;
 513         }
 514         return 0;
 515 }
 516
 517 /* This is the interrupt mode worker thread body */
 518 static int
 519 event_thread(void *data)
 520 {
 521         int rc;
 522
 523         dbg("%s - event thread started", __func__);
 524         while (1) {
 525                 dbg("event thread sleeping");
 526                 set_current_state(TASK_INTERRUPTIBLE);
 527                 schedule();
 528                 if (kthread_should_stop())
 529                         break;
 530                 do {
 531                         rc = check_slots();
 532                         if (rc > 0) {
 533                                 /* Give userspace a chance to handle extraction */
 534                                 msleep(500);
 535                         } else if (rc < 0) {
 536                                 dbg("%s - error checking slots", __func__);
 537                                 thread_finished = 1;
 538                                 goto out;
 539                         }
 540                 } while (atomic_read(&extracting) && !kthread_should_stop());
 541                 if (kthread_should_stop())
 542                         break;
 543
 544                 /* Re-enable ENUM# interrupt */
 545                 dbg("%s - re-enabling irq", __func__);
 546                 controller->ops->enable_irq();
 547         }
 548  out:
 549         return 0;
 550 }
 551
 552 /* This is the polling mode worker thread body */
 553 static int
 554 poll_thread(void *data)
 555 {
 556         int rc;
 557
 558         while (1) {
 559                 if (kthread_should_stop() || signal_pending(current))
 560                         break;
 561                 if (controller->ops->query_enum()) {
 562                         do {
 563                                 rc = check_slots();
 564                                 if (rc > 0) {
 565                                         /* Give userspace a chance to handle extraction */
 566                                         msleep(500);
 567                                 } else if (rc < 0) {
 568                                         dbg("%s - error checking slots", __func__);
 569                                         thread_finished = 1;
 570                                         goto out;
 571                                 }
 572                         } while (atomic_read(&extracting) && !kthread_should_stop());
 573                 }
 574                 msleep(100);
 575         }
 576  out:
 577         return 0;
 578 }
 579
 580 static int
 581 cpci_start_thread(void)
 582 {
 583         if (controller->irq)
 584                 cpci_thread = kthread_run(event_thread, NULL, "cpci_hp_eventd");
 585         else
 586                 cpci_thread = kthread_run(poll_thread, NULL, "cpci_hp_polld");
 587         if (IS_ERR(cpci_thread)) {
 588                 err("Can't start up our thread");
 589                 return PTR_ERR(cpci_thread);
 590         }
 591         thread_finished = 0;
 592         return 0;
 593 }
 594
 595 static void
 596 cpci_stop_thread(void)
 597 {
 598         kthread_stop(cpci_thread);
 599         thread_finished = 1;
 600 }
 601
 602 int
 603 cpci_hp_register_controller(struct cpci_hp_controller *new_controller)
 604 {
 605         int status = 0;
 606
 607         if (controller)
 608                 return -1;
 609         if (!(new_controller && new_controller->ops))
 610                 return -EINVAL;
 611         if (new_controller->irq) {
 612                 if (!(new_controller->ops->enable_irq &&
 613                      new_controller->ops->disable_irq))
 614                         status = -EINVAL;
 615                 if (request_irq(new_controller->irq,
 616                                cpci_hp_intr,
 617                                new_controller->irq_flags,
 618                                MY_NAME,
 619                                new_controller->dev_id)) {
 620                         err("Can't get irq %d for the hotplug cPCI controller",
 621                             new_controller->irq);
 622                         status = -ENODEV;
 623                 }
 624                 dbg("%s - acquired controller irq %d",
 625                     __func__, new_controller->irq);
 626         }
 627         if (!status)
 628                 controller = new_controller;
 629         return status;
 630 }
 631
 632 static void
 633 cleanup_slots(void)
 634 {
 635         struct slot *slot;
 636         struct slot *tmp;
 637
 638         /*
 639          * Unregister all of our slots with the pci_hotplug subsystem,
 640          * and free up all memory that we had allocated.
 641          */
 642         down_write(&list_rwsem);
 643         if (!slots)
 644                 goto cleanup_null;
 645         list_for_each_entry_safe(slot, tmp, &slot_list, slot_list) {
 646                 list_del(&slot->slot_list);
 647                 pci_hp_deregister(slot->hotplug_slot);
 648         }
 649 cleanup_null:
 650         up_write(&list_rwsem);
 651         return;
 652 }
 653
 654 int
 655 cpci_hp_unregister_controller(struct cpci_hp_controller *old_controller)
 656 {
 657         int status = 0;
 658
 659         if (controller) {
 660                 if (!thread_finished)
 661                         cpci_stop_thread();
 662                 if (controller->irq)
 663                         free_irq(controller->irq, controller->dev_id);
 664                 controller = NULL;
 665                 cleanup_slots();
 666         } else
 667                 status = -ENODEV;
 668         return status;
 669 }
 670
 671 int
 672 cpci_hp_start(void)
 673 {
 674         static int first = 1;
 675         int status;
 676
 677         dbg("%s - enter", __func__);
 678         if (!controller)
 679                 return -ENODEV;
 680
 681         down_read(&list_rwsem);
 682         if (list_empty(&slot_list)) {
 683                 up_read(&list_rwsem);
 684                 return -ENODEV;
 685         }
 686         up_read(&list_rwsem);
 687
 688         status = init_slots(first);
 689         if (first)
 690                 first = 0;
 691         if (status)
 692                 return status;
 693
 694         status = cpci_start_thread();
 695         if (status)
 696                 return status;
 697         dbg("%s - thread started", __func__);
 698
 699         if (controller->irq) {
 700                 /* Start enum interrupt processing */
 701                 dbg("%s - enabling irq", __func__);
 702                 controller->ops->enable_irq();
 703         }
 704         dbg("%s - exit", __func__);
 705         return 0;
 706 }
 707
 708 int
 709 cpci_hp_stop(void)
 710 {
 711         if (!controller)
 712                 return -ENODEV;
 713         if (controller->irq) {
 714                 /* Stop enum interrupt processing */
 715                 dbg("%s - disabling irq", __func__);
 716                 controller->ops->disable_irq();
 717         }
 718         cpci_stop_thread();
 719         return 0;
 720 }
 721
 722 int __init
 723 cpci_hotplug_init(int debug)
 724 {
 725         cpci_debug = debug;
 726         return 0;
 727 }
 728
 729 void __exit
 730 cpci_hotplug_exit(void)
 731 {
 732         /*
 733          * Clean everything up.
 734          */
 735         cpci_hp_stop();
 736         cpci_hp_unregister_controller(controller);
 737 }
 738
 739 EXPORT_SYMBOL_GPL(cpci_hp_register_controller);
 740 EXPORT_SYMBOL_GPL(cpci_hp_unregister_controller);
 741 EXPORT_SYMBOL_GPL(cpci_hp_register_bus);
 742 EXPORT_SYMBOL_GPL(cpci_hp_unregister_bus);
 743 EXPORT_SYMBOL_GPL(cpci_hp_start);
 744 EXPORT_SYMBOL_GPL(cpci_hp_stop);