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 "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 semaphore event_semaphore;        /* mutex for process loop (up if something to process) */
  63 static struct semaphore thread_exit;            /* guard ensure thread has exited before calling it quits */
  64 static int thread_finished = 1;
  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         dbg("Signal event_semaphore");
 361         up(&event_semaphore);
 362         dbg("exited cpci_hp_intr");
 363         return IRQ_HANDLED;
 364 }
 365
 366 /*
 367  * According to PICMG 2.1 R2.0, section 6.3.2, upon
 368  * initialization, the system driver shall clear the
 369  * INS bits of the cold-inserted devices.
 370  */
 371 static int
 372 init_slots(int clear_ins)
 373 {
 374         struct slot *slot;
 375         struct pci_dev* dev;
 376
 377         dbg("%s - enter", __FUNCTION__);
 378         down_read(&list_rwsem);
 379         if (!slots) {
 380                 up_read(&list_rwsem);
 381                 return -1;
 382         }
 383         list_for_each_entry(slot, &slot_list, slot_list) {
 384                 dbg("%s - looking at slot %s",
 385                     __FUNCTION__, slot->hotplug_slot->name);
 386                 if (clear_ins && cpci_check_and_clear_ins(slot))
 387                         dbg("%s - cleared INS for slot %s",
 388                             __FUNCTION__, slot->hotplug_slot->name);
 389                 dev = pci_get_slot(slot->bus, PCI_DEVFN(slot->number, 0));
 390                 if (dev) {
 391                         if (update_adapter_status(slot->hotplug_slot, 1))
 392                                 warn("failure to update adapter file");
 393                         if (update_latch_status(slot->hotplug_slot, 1))
 394                                 warn("failure to update latch file");
 395                         slot->dev = dev;
 396                 }
 397         }
 398         up_read(&list_rwsem);
 399         dbg("%s - exit", __FUNCTION__);
 400         return 0;
 401 }
 402
 403 static int
 404 check_slots(void)
 405 {
 406         struct slot *slot;
 407         int extracted;
 408         int inserted;
 409         u16 hs_csr;
 410
 411         down_read(&list_rwsem);
 412         if (!slots) {
 413                 up_read(&list_rwsem);
 414                 err("no slots registered, shutting down");
 415                 return -1;
 416         }
 417         extracted = inserted = 0;
 418         list_for_each_entry(slot, &slot_list, slot_list) {
 419                 dbg("%s - looking at slot %s",
 420                     __FUNCTION__, slot->hotplug_slot->name);
 421                 if (cpci_check_and_clear_ins(slot)) {
 422                         /*
 423                          * Some broken hardware (e.g. PLX 9054AB) asserts
 424                          * ENUM# twice...
 425                          */
 426                         if (slot->dev) {
 427                                 warn("slot %s already inserted",
 428                                      slot->hotplug_slot->name);
 429                                 inserted++;
 430                                 continue;
 431                         }
 432
 433                         /* Process insertion */
 434                         dbg("%s - slot %s inserted",
 435                             __FUNCTION__, slot->hotplug_slot->name);
 436
 437                         /* GSM, debug */
 438                         hs_csr = cpci_get_hs_csr(slot);
 439                         dbg("%s - slot %s HS_CSR (1) = %04x",
 440                             __FUNCTION__, slot->hotplug_slot->name, hs_csr);
 441
 442                         /* Configure device */
 443                         dbg("%s - configuring slot %s",
 444                             __FUNCTION__, slot->hotplug_slot->name);
 445                         if (cpci_configure_slot(slot)) {
 446                                 err("%s - could not configure slot %s",
 447                                     __FUNCTION__, slot->hotplug_slot->name);
 448                                 continue;
 449                         }
 450                         dbg("%s - finished configuring slot %s",
 451                             __FUNCTION__, slot->hotplug_slot->name);
 452
 453                         /* GSM, debug */
 454                         hs_csr = cpci_get_hs_csr(slot);
 455                         dbg("%s - slot %s HS_CSR (2) = %04x",
 456                             __FUNCTION__, slot->hotplug_slot->name, hs_csr);
 457
 458                         if (update_latch_status(slot->hotplug_slot, 1))
 459                                 warn("failure to update latch file");
 460
 461                         if (update_adapter_status(slot->hotplug_slot, 1))
 462                                 warn("failure to update adapter file");
 463
 464                         cpci_led_off(slot);
 465
 466                         /* GSM, debug */
 467                         hs_csr = cpci_get_hs_csr(slot);
 468                         dbg("%s - slot %s HS_CSR (3) = %04x",
 469                             __FUNCTION__, slot->hotplug_slot->name, hs_csr);
 470
 471                         inserted++;
 472                 } else if (cpci_check_ext(slot)) {
 473                         /* Process extraction request */
 474                         dbg("%s - slot %s extracted",
 475                             __FUNCTION__, slot->hotplug_slot->name);
 476
 477                         /* GSM, debug */
 478                         hs_csr = cpci_get_hs_csr(slot);
 479                         dbg("%s - slot %s HS_CSR = %04x",
 480                             __FUNCTION__, slot->hotplug_slot->name, hs_csr);
 481
 482                         if (!slot->extracting) {
 483                                 if (update_latch_status(slot->hotplug_slot, 0)) {
 484                                         warn("failure to update latch file");
 485                                 }
 486                                 slot->extracting = 1;
 487                                 atomic_inc(&extracting);
 488                         }
 489                         extracted++;
 490                 } else if (slot->extracting) {
 491                         hs_csr = cpci_get_hs_csr(slot);
 492                         if (hs_csr == 0xffff) {
 493                                 /*
 494                                  * Hmmm, we're likely hosed at this point, should we
 495                                  * bother trying to tell the driver or not?
 496                                  */
 497                                 err("card in slot %s was improperly removed",
 498                                     slot->hotplug_slot->name);
 499                                 if (update_adapter_status(slot->hotplug_slot, 0))
 500                                         warn("failure to update adapter file");
 501                                 slot->extracting = 0;
 502                                 atomic_dec(&extracting);
 503                         }
 504                 }
 505         }
 506         up_read(&list_rwsem);
 507         dbg("inserted=%d, extracted=%d, extracting=%d",
 508             inserted, extracted, atomic_read(&extracting));
 509         if (inserted || extracted)
 510                 return extracted;
 511         else if (!atomic_read(&extracting)) {
 512                 err("cannot find ENUM# source, shutting down");
 513                 return -1;
 514         }
 515         return 0;
 516 }
 517
 518 /* This is the interrupt mode worker thread body */
 519 static int
 520 event_thread(void *data)
 521 {
 522         int rc;
 523
 524         lock_kernel();
 525         daemonize("cpci_hp_eventd");
 526         unlock_kernel();
 527
 528         dbg("%s - event thread started", __FUNCTION__);
 529         while (1) {
 530                 dbg("event thread sleeping");
 531                 down_interruptible(&event_semaphore);
 532                 dbg("event thread woken, thread_finished = %d",
 533                     thread_finished);
 534                 if (thread_finished || signal_pending(current))
 535                         break;
 536                 do {
 537                         rc = check_slots();
 538                         if (rc > 0) {
 539                                 /* Give userspace a chance to handle extraction */
 540                                 msleep(500);
 541                         } else if (rc < 0) {
 542                                 dbg("%s - error checking slots", __FUNCTION__);
 543                                 thread_finished = 1;
 544                                 break;
 545                         }
 546                 } while (atomic_read(&extracting) && !thread_finished);
 547                 if (thread_finished)
 548                         break;
 549
 550                 /* Re-enable ENUM# interrupt */
 551                 dbg("%s - re-enabling irq", __FUNCTION__);
 552                 controller->ops->enable_irq();
 553         }
 554         dbg("%s - event thread signals exit", __FUNCTION__);
 555         up(&thread_exit);
 556         return 0;
 557 }
 558
 559 /* This is the polling mode worker thread body */
 560 static int
 561 poll_thread(void *data)
 562 {
 563         int rc;
 564
 565         lock_kernel();
 566         daemonize("cpci_hp_polld");
 567         unlock_kernel();
 568
 569         while (1) {
 570                 if (thread_finished || signal_pending(current))
 571                         break;
 572                 if (controller->ops->query_enum()) {
 573                         do {
 574                                 rc = check_slots();
 575                                 if (rc > 0) {
 576                                         /* Give userspace a chance to handle extraction */
 577                                         msleep(500);
 578                                 } else if (rc < 0) {
 579                                         dbg("%s - error checking slots", __FUNCTION__);
 580                                         thread_finished = 1;
 581                                         break;
 582                                 }
 583                         } while (atomic_read(&extracting) && !thread_finished);
 584                 }
 585                 msleep(100);
 586         }
 587         dbg("poll thread signals exit");
 588         up(&thread_exit);
 589         return 0;
 590 }
 591
 592 static int
 593 cpci_start_thread(void)
 594 {
 595         int pid;
 596
 597         /* initialize our semaphores */
 598         init_MUTEX_LOCKED(&event_semaphore);
 599         init_MUTEX_LOCKED(&thread_exit);
 600         thread_finished = 0;
 601
 602         if (controller->irq)
 603                 pid = kernel_thread(event_thread, NULL, 0);
 604         else
 605                 pid = kernel_thread(poll_thread, NULL, 0);
 606         if (pid < 0) {
 607                 err("Can't start up our thread");
 608                 return -1;
 609         }
 610         dbg("Our thread pid = %d", pid);
 611         return 0;
 612 }
 613
 614 static void
 615 cpci_stop_thread(void)
 616 {
 617         thread_finished = 1;
 618         dbg("thread finish command given");
 619         if (controller->irq)
 620                 up(&event_semaphore);
 621         dbg("wait for thread to exit");
 622         down(&thread_exit);
 623 }
 624
 625 int
 626 cpci_hp_register_controller(struct cpci_hp_controller *new_controller)
 627 {
 628         int status = 0;
 629
 630         if (controller)
 631                 return -1;
 632         if (!(new_controller && new_controller->ops))
 633                 return -EINVAL;
 634         if (new_controller->irq) {
 635                 if (!(new_controller->ops->enable_irq &&
 636                      new_controller->ops->disable_irq))
 637                         status = -EINVAL;
 638                 if (request_irq(new_controller->irq,
 639                                cpci_hp_intr,
 640                                new_controller->irq_flags,
 641                                MY_NAME,
 642                                new_controller->dev_id)) {
 643                         err("Can't get irq %d for the hotplug cPCI controller",
 644                             new_controller->irq);
 645                         status = -ENODEV;
 646                 }
 647                 dbg("%s - acquired controller irq %d",
 648                     __FUNCTION__, new_controller->irq);
 649         }
 650         if (!status)
 651                 controller = new_controller;
 652         return status;
 653 }
 654
 655 static void
 656 cleanup_slots(void)
 657 {
 658         struct slot *slot;
 659         struct slot *tmp;
 660
 661         /*
 662          * Unregister all of our slots with the pci_hotplug subsystem,
 663          * and free up all memory that we had allocated.
 664          */
 665         down_write(&list_rwsem);
 666         if (!slots)
 667                 goto cleanup_null;
 668         list_for_each_entry_safe(slot, tmp, &slot_list, slot_list) {
 669                 list_del(&slot->slot_list);
 670                 pci_hp_deregister(slot->hotplug_slot);
 671         }
 672 cleanup_null:
 673         up_write(&list_rwsem);
 674         return;
 675 }
 676
 677 int
 678 cpci_hp_unregister_controller(struct cpci_hp_controller *old_controller)
 679 {
 680         int status = 0;
 681
 682         if (controller) {
 683                 if (!thread_finished)
 684                         cpci_stop_thread();
 685                 if (controller->irq)
 686                         free_irq(controller->irq, controller->dev_id);
 687                 controller = NULL;
 688                 cleanup_slots();
 689         } else
 690                 status = -ENODEV;
 691         return status;
 692 }
 693
 694 int
 695 cpci_hp_start(void)
 696 {
 697         static int first = 1;
 698         int status;
 699
 700         dbg("%s - enter", __FUNCTION__);
 701         if (!controller)
 702                 return -ENODEV;
 703
 704         down_read(&list_rwsem);
 705         if (list_empty(&slot_list)) {
 706                 up_read(&list_rwsem);
 707                 return -ENODEV;
 708         }
 709         up_read(&list_rwsem);
 710
 711         status = init_slots(first);
 712         if (first)
 713                 first = 0;
 714         if (status)
 715                 return status;
 716
 717         status = cpci_start_thread();
 718         if (status)
 719                 return status;
 720         dbg("%s - thread started", __FUNCTION__);
 721
 722         if (controller->irq) {
 723                 /* Start enum interrupt processing */
 724                 dbg("%s - enabling irq", __FUNCTION__);
 725                 controller->ops->enable_irq();
 726         }
 727         dbg("%s - exit", __FUNCTION__);
 728         return 0;
 729 }
 730
 731 int
 732 cpci_hp_stop(void)
 733 {
 734         if (!controller)
 735                 return -ENODEV;
 736         if (controller->irq) {
 737                 /* Stop enum interrupt processing */
 738                 dbg("%s - disabling irq", __FUNCTION__);
 739                 controller->ops->disable_irq();
 740         }
 741         cpci_stop_thread();
 742         return 0;
 743 }
 744
 745 int __init
 746 cpci_hotplug_init(int debug)
 747 {
 748         cpci_debug = debug;
 749         return 0;
 750 }
 751
 752 void __exit
 753 cpci_hotplug_exit(void)
 754 {
 755         /*
 756          * Clean everything up.
 757          */
 758         cpci_hp_stop();
 759         cpci_hp_unregister_controller(controller);
 760 }
 761
 762 EXPORT_SYMBOL_GPL(cpci_hp_register_controller);
 763 EXPORT_SYMBOL_GPL(cpci_hp_unregister_controller);
 764 EXPORT_SYMBOL_GPL(cpci_hp_register_bus);
 765 EXPORT_SYMBOL_GPL(cpci_hp_unregister_bus);
 766 EXPORT_SYMBOL_GPL(cpci_hp_start);
 767 EXPORT_SYMBOL_GPL(cpci_hp_stop);