git.oblomov.eu Git - 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", __FUNCTION__, 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", __FUNCTION__, hotplug_slot->name);
 125
 126         down_write(&list_rwsem);
 127
 128         /* Unconfigure device */
 129         dbg("%s - unconfiguring slot %s",
 130             __FUNCTION__, slot->hotplug_slot->name);
 131         if ((retval = cpci_unconfigure_slot(slot))) {
 132                 err("%s - could not unconfigure slot %s",
 133                     __FUNCTION__, slot->hotplug_slot->name);
 134                 goto disable_error;
 135         }
 136         dbg("%s - finished unconfiguring slot %s",
 137             __FUNCTION__, 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                     __FUNCTION__, 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);
 289                 if (status) {
 290                         err("pci_hp_register failed with error %d", status);
 291                         goto error_name;
 292                 }
 293
 294                 /* Add slot to our internal list */
 295                 down_write(&list_rwsem);
 296                 list_add(&slot->slot_list, &slot_list);
 297                 slots++;
 298                 up_write(&list_rwsem);
 299         }
 300         return 0;
 301 error_name:
 302         kfree(name);
 303 error_info:
 304         kfree(info);
 305 error_hpslot:
 306         kfree(hotplug_slot);
 307 error_slot:
 308         kfree(slot);
 309 error:
 310         return status;
 311 }
 312
 313 int
 314 cpci_hp_unregister_bus(struct pci_bus *bus)
 315 {
 316         struct slot *slot;
 317         struct slot *tmp;
 318         int status = 0;
 319
 320         down_write(&list_rwsem);
 321         if (!slots) {
 322                 up_write(&list_rwsem);
 323                 return -1;
 324         }
 325         list_for_each_entry_safe(slot, tmp, &slot_list, slot_list) {
 326                 if (slot->bus == bus) {
 327                         list_del(&slot->slot_list);
 328                         slots--;
 329
 330                         dbg("deregistering slot %s", slot->hotplug_slot->name);
 331                         status = pci_hp_deregister(slot->hotplug_slot);
 332                         if (status) {
 333                                 err("pci_hp_deregister failed with error %d",
 334                                     status);
 335                                 break;
 336                         }
 337                 }
 338         }
 339         up_write(&list_rwsem);
 340         return status;
 341 }
 342
 343 /* This is the interrupt mode interrupt handler */
 344 static irqreturn_t
 345 cpci_hp_intr(int irq, void *data)
 346 {
 347         dbg("entered cpci_hp_intr");
 348
 349         /* Check to see if it was our interrupt */
 350         if ((controller->irq_flags & IRQF_SHARED) &&
 351             !controller->ops->check_irq(controller->dev_id)) {
 352                 dbg("exited cpci_hp_intr, not our interrupt");
 353                 return IRQ_NONE;
 354         }
 355
 356         /* Disable ENUM interrupt */
 357         controller->ops->disable_irq();
 358
 359         /* Trigger processing by the event thread */
 360         wake_up_process(cpci_thread);
 361         return IRQ_HANDLED;
 362 }
 363
 364 /*
 365  * According to PICMG 2.1 R2.0, section 6.3.2, upon
 366  * initialization, the system driver shall clear the
 367  * INS bits of the cold-inserted devices.
 368  */
 369 static int
 370 init_slots(int clear_ins)
 371 {
 372         struct slot *slot;
 373         struct pci_dev* dev;
 374
 375         dbg("%s - enter", __FUNCTION__);
 376         down_read(&list_rwsem);
 377         if (!slots) {
 378                 up_read(&list_rwsem);
 379                 return -1;
 380         }
 381         list_for_each_entry(slot, &slot_list, slot_list) {
 382                 dbg("%s - looking at slot %s",
 383                     __FUNCTION__, slot->hotplug_slot->name);
 384                 if (clear_ins && cpci_check_and_clear_ins(slot))
 385                         dbg("%s - cleared INS for slot %s",
 386                             __FUNCTION__, slot->hotplug_slot->name);
 387                 dev = pci_get_slot(slot->bus, PCI_DEVFN(slot->number, 0));
 388                 if (dev) {
 389                         if (update_adapter_status(slot->hotplug_slot, 1))
 390                                 warn("failure to update adapter file");
 391                         if (update_latch_status(slot->hotplug_slot, 1))
 392                                 warn("failure to update latch file");
 393                         slot->dev = dev;
 394                 }
 395         }
 396         up_read(&list_rwsem);
 397         dbg("%s - exit", __FUNCTION__);
 398         return 0;
 399 }
 400
 401 static int
 402 check_slots(void)
 403 {
 404         struct slot *slot;
 405         int extracted;
 406         int inserted;
 407         u16 hs_csr;
 408
 409         down_read(&list_rwsem);
 410         if (!slots) {
 411                 up_read(&list_rwsem);
 412                 err("no slots registered, shutting down");
 413                 return -1;
 414         }
 415         extracted = inserted = 0;
 416         list_for_each_entry(slot, &slot_list, slot_list) {
 417                 dbg("%s - looking at slot %s",
 418                     __FUNCTION__, slot->hotplug_slot->name);
 419                 if (cpci_check_and_clear_ins(slot)) {
 420                         /*
 421                          * Some broken hardware (e.g. PLX 9054AB) asserts
 422                          * ENUM# twice...
 423                          */
 424                         if (slot->dev) {
 425                                 warn("slot %s already inserted",
 426                                      slot->hotplug_slot->name);
 427                                 inserted++;
 428                                 continue;
 429                         }
 430
 431                         /* Process insertion */
 432                         dbg("%s - slot %s inserted",
 433                             __FUNCTION__, slot->hotplug_slot->name);
 434
 435                         /* GSM, debug */
 436                         hs_csr = cpci_get_hs_csr(slot);
 437                         dbg("%s - slot %s HS_CSR (1) = %04x",
 438                             __FUNCTION__, slot->hotplug_slot->name, hs_csr);
 439
 440                         /* Configure device */
 441                         dbg("%s - configuring slot %s",
 442                             __FUNCTION__, slot->hotplug_slot->name);
 443                         if (cpci_configure_slot(slot)) {
 444                                 err("%s - could not configure slot %s",
 445                                     __FUNCTION__, slot->hotplug_slot->name);
 446                                 continue;
 447                         }
 448                         dbg("%s - finished configuring slot %s",
 449                             __FUNCTION__, slot->hotplug_slot->name);
 450
 451                         /* GSM, debug */
 452                         hs_csr = cpci_get_hs_csr(slot);
 453                         dbg("%s - slot %s HS_CSR (2) = %04x",
 454                             __FUNCTION__, slot->hotplug_slot->name, hs_csr);
 455
 456                         if (update_latch_status(slot->hotplug_slot, 1))
 457                                 warn("failure to update latch file");
 458
 459                         if (update_adapter_status(slot->hotplug_slot, 1))
 460                                 warn("failure to update adapter file");
 461
 462                         cpci_led_off(slot);
 463
 464                         /* GSM, debug */
 465                         hs_csr = cpci_get_hs_csr(slot);
 466                         dbg("%s - slot %s HS_CSR (3) = %04x",
 467                             __FUNCTION__, slot->hotplug_slot->name, hs_csr);
 468
 469                         inserted++;
 470                 } else if (cpci_check_ext(slot)) {
 471                         /* Process extraction request */
 472                         dbg("%s - slot %s extracted",
 473                             __FUNCTION__, slot->hotplug_slot->name);
 474
 475                         /* GSM, debug */
 476                         hs_csr = cpci_get_hs_csr(slot);
 477                         dbg("%s - slot %s HS_CSR = %04x",
 478                             __FUNCTION__, slot->hotplug_slot->name, hs_csr);
 479
 480                         if (!slot->extracting) {
 481                                 if (update_latch_status(slot->hotplug_slot, 0)) {
 482                                         warn("failure to update latch file");
 483                                 }
 484                                 slot->extracting = 1;
 485                                 atomic_inc(&extracting);
 486                         }
 487                         extracted++;
 488                 } else if (slot->extracting) {
 489                         hs_csr = cpci_get_hs_csr(slot);
 490                         if (hs_csr == 0xffff) {
 491                                 /*
 492                                  * Hmmm, we're likely hosed at this point, should we
 493                                  * bother trying to tell the driver or not?
 494                                  */
 495                                 err("card in slot %s was improperly removed",
 496                                     slot->hotplug_slot->name);
 497                                 if (update_adapter_status(slot->hotplug_slot, 0))
 498                                         warn("failure to update adapter file");
 499                                 slot->extracting = 0;
 500                                 atomic_dec(&extracting);
 501                         }
 502                 }
 503         }
 504         up_read(&list_rwsem);
 505         dbg("inserted=%d, extracted=%d, extracting=%d",
 506             inserted, extracted, atomic_read(&extracting));
 507         if (inserted || extracted)
 508                 return extracted;
 509         else if (!atomic_read(&extracting)) {
 510                 err("cannot find ENUM# source, shutting down");
 511                 return -1;
 512         }
 513         return 0;
 514 }
 515
 516 /* This is the interrupt mode worker thread body */
 517 static int
 518 event_thread(void *data)
 519 {
 520         int rc;
 521
 522         dbg("%s - event thread started", __FUNCTION__);
 523         while (1) {
 524                 dbg("event thread sleeping");
 525                 set_current_state(TASK_INTERRUPTIBLE);
 526                 schedule();
 527                 if (kthread_should_stop())
 528                         break;
 529                 do {
 530                         rc = check_slots();
 531                         if (rc > 0) {
 532                                 /* Give userspace a chance to handle extraction */
 533                                 msleep(500);
 534                         } else if (rc < 0) {
 535                                 dbg("%s - error checking slots", __FUNCTION__);
 536                                 thread_finished = 1;
 537                                 goto out;
 538                         }
 539                 } while (atomic_read(&extracting) && !kthread_should_stop());
 540                 if (kthread_should_stop())
 541                         break;
 542
 543                 /* Re-enable ENUM# interrupt */
 544                 dbg("%s - re-enabling irq", __FUNCTION__);
 545                 controller->ops->enable_irq();
 546         }
 547  out:
 548         return 0;
 549 }
 550
 551 /* This is the polling mode worker thread body */
 552 static int
 553 poll_thread(void *data)
 554 {
 555         int rc;
 556
 557         while (1) {
 558                 if (kthread_should_stop() || signal_pending(current))
 559                         break;
 560                 if (controller->ops->query_enum()) {
 561                         do {
 562                                 rc = check_slots();
 563                                 if (rc > 0) {
 564                                         /* Give userspace a chance to handle extraction */
 565                                         msleep(500);
 566                                 } else if (rc < 0) {
 567                                         dbg("%s - error checking slots", __FUNCTION__);
 568                                         thread_finished = 1;
 569                                         goto out;
 570                                 }
 571                         } while (atomic_read(&extracting) && !kthread_should_stop());
 572                 }
 573                 msleep(100);
 574         }
 575  out:
 576         return 0;
 577 }
 578
 579 static int
 580 cpci_start_thread(void)
 581 {
 582         if (controller->irq)
 583                 cpci_thread = kthread_run(event_thread, NULL, "cpci_hp_eventd");
 584         else
 585                 cpci_thread = kthread_run(poll_thread, NULL, "cpci_hp_polld");
 586         if (IS_ERR(cpci_thread)) {
 587                 err("Can't start up our thread");
 588                 return PTR_ERR(cpci_thread);
 589         }
 590         thread_finished = 0;
 591         return 0;
 592 }
 593
 594 static void
 595 cpci_stop_thread(void)
 596 {
 597         kthread_stop(cpci_thread);
 598         thread_finished = 1;
 599 }
 600
 601 int
 602 cpci_hp_register_controller(struct cpci_hp_controller *new_controller)
 603 {
 604         int status = 0;
 605
 606         if (controller)
 607                 return -1;
 608         if (!(new_controller && new_controller->ops))
 609                 return -EINVAL;
 610         if (new_controller->irq) {
 611                 if (!(new_controller->ops->enable_irq &&
 612                      new_controller->ops->disable_irq))
 613                         status = -EINVAL;
 614                 if (request_irq(new_controller->irq,
 615                                cpci_hp_intr,
 616                                new_controller->irq_flags,
 617                                MY_NAME,
 618                                new_controller->dev_id)) {
 619                         err("Can't get irq %d for the hotplug cPCI controller",
 620                             new_controller->irq);
 621                         status = -ENODEV;
 622                 }
 623                 dbg("%s - acquired controller irq %d",
 624                     __FUNCTION__, new_controller->irq);
 625         }
 626         if (!status)
 627                 controller = new_controller;
 628         return status;
 629 }
 630
 631 static void
 632 cleanup_slots(void)
 633 {
 634         struct slot *slot;
 635         struct slot *tmp;
 636
 637         /*
 638          * Unregister all of our slots with the pci_hotplug subsystem,
 639          * and free up all memory that we had allocated.
 640          */
 641         down_write(&list_rwsem);
 642         if (!slots)
 643                 goto cleanup_null;
 644         list_for_each_entry_safe(slot, tmp, &slot_list, slot_list) {
 645                 list_del(&slot->slot_list);
 646                 pci_hp_deregister(slot->hotplug_slot);
 647         }
 648 cleanup_null:
 649         up_write(&list_rwsem);
 650         return;
 651 }
 652
 653 int
 654 cpci_hp_unregister_controller(struct cpci_hp_controller *old_controller)
 655 {
 656         int status = 0;
 657
 658         if (controller) {
 659                 if (!thread_finished)
 660                         cpci_stop_thread();
 661                 if (controller->irq)
 662                         free_irq(controller->irq, controller->dev_id);
 663                 controller = NULL;
 664                 cleanup_slots();
 665         } else
 666                 status = -ENODEV;
 667         return status;
 668 }
 669
 670 int
 671 cpci_hp_start(void)
 672 {
 673         static int first = 1;
 674         int status;
 675
 676         dbg("%s - enter", __FUNCTION__);
 677         if (!controller)
 678                 return -ENODEV;
 679
 680         down_read(&list_rwsem);
 681         if (list_empty(&slot_list)) {
 682                 up_read(&list_rwsem);
 683                 return -ENODEV;
 684         }
 685         up_read(&list_rwsem);
 686
 687         status = init_slots(first);
 688         if (first)
 689                 first = 0;
 690         if (status)
 691                 return status;
 692
 693         status = cpci_start_thread();
 694         if (status)
 695                 return status;
 696         dbg("%s - thread started", __FUNCTION__);
 697
 698         if (controller->irq) {
 699                 /* Start enum interrupt processing */
 700                 dbg("%s - enabling irq", __FUNCTION__);
 701                 controller->ops->enable_irq();
 702         }
 703         dbg("%s - exit", __FUNCTION__);
 704         return 0;
 705 }
 706
 707 int
 708 cpci_hp_stop(void)
 709 {
 710         if (!controller)
 711                 return -ENODEV;
 712         if (controller->irq) {
 713                 /* Stop enum interrupt processing */
 714                 dbg("%s - disabling irq", __FUNCTION__);
 715                 controller->ops->disable_irq();
 716         }
 717         cpci_stop_thread();
 718         return 0;
 719 }
 720
 721 int __init
 722 cpci_hotplug_init(int debug)
 723 {
 724         cpci_debug = debug;
 725         return 0;
 726 }
 727
 728 void __exit
 729 cpci_hotplug_exit(void)
 730 {
 731         /*
 732          * Clean everything up.
 733          */
 734         cpci_hp_stop();
 735         cpci_hp_unregister_controller(controller);
 736 }
 737
 738 EXPORT_SYMBOL_GPL(cpci_hp_register_controller);
 739 EXPORT_SYMBOL_GPL(cpci_hp_unregister_controller);
 740 EXPORT_SYMBOL_GPL(cpci_hp_register_bus);
 741 EXPORT_SYMBOL_GPL(cpci_hp_unregister_bus);
 742 EXPORT_SYMBOL_GPL(cpci_hp_start);
 743 EXPORT_SYMBOL_GPL(cpci_hp_stop);