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