drivers/pci/hotplug/cpci_hotplug_core.c

   1 /*
   2  * CompactPCI Hot Plug Driver
   3  *
   4  * Copyright (C) 2002 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/config.h>
  29 #include <linux/module.h>
  30 #include <linux/kernel.h>
  31 #include <linux/slab.h>
  32 #include <linux/pci.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 "pci_hotplug.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 semaphore event_semaphore;        /* mutex for process loop (up if something to process) */
  64 static struct semaphore thread_exit;            /* guard ensure thread has exited before calling it quits */
  65 static int thread_finished = 1;
  66
  67 static int enable_slot(struct hotplug_slot *slot);
  68 static int disable_slot(struct hotplug_slot *slot);
  69 static int set_attention_status(struct hotplug_slot *slot, u8 value);
  70 static int get_power_status(struct hotplug_slot *slot, u8 * value);
  71 static int get_attention_status(struct hotplug_slot *slot, u8 * value);
  72 static int get_adapter_status(struct hotplug_slot *slot, u8 * value);
  73 static int get_latch_status(struct hotplug_slot *slot, u8 * value);
  74
  75 static struct hotplug_slot_ops cpci_hotplug_slot_ops = {
  76         .owner = THIS_MODULE,
  77         .enable_slot = enable_slot,
  78         .disable_slot = disable_slot,
  79         .set_attention_status = set_attention_status,
  80         .get_power_status = get_power_status,
  81         .get_attention_status = get_attention_status,
  82         .get_adapter_status = get_adapter_status,
  83         .get_latch_status = get_latch_status,
  84 };
  85
  86 static int
  87 update_latch_status(struct hotplug_slot *hotplug_slot, u8 value)
  88 {
  89         struct hotplug_slot_info info;
  90
  91         memcpy(&info, hotplug_slot->info, sizeof(struct hotplug_slot_info));
  92         info.latch_status = value;
  93         return pci_hp_change_slot_info(hotplug_slot, &info);
  94 }
  95
  96 static int
  97 update_adapter_status(struct hotplug_slot *hotplug_slot, u8 value)
  98 {
  99         struct hotplug_slot_info info;
 100
 101         memcpy(&info, hotplug_slot->info, sizeof(struct hotplug_slot_info));
 102         info.adapter_status = value;
 103         return pci_hp_change_slot_info(hotplug_slot, &info);
 104 }
 105
 106 static int
 107 enable_slot(struct hotplug_slot *hotplug_slot)
 108 {
 109         struct slot *slot = hotplug_slot->private;
 110         int retval = 0;
 111
 112         dbg("%s - physical_slot = %s", __FUNCTION__, hotplug_slot->name);
 113
 114         if(controller->ops->set_power) {
 115                 retval = controller->ops->set_power(slot, 1);
 116         }
 117
 118         return retval;
 119 }
 120
 121 static int
 122 disable_slot(struct hotplug_slot *hotplug_slot)
 123 {
 124         struct slot *slot = hotplug_slot->private;
 125         int retval = 0;
 126
 127         dbg("%s - physical_slot = %s", __FUNCTION__, hotplug_slot->name);
 128
 129         /* Unconfigure device */
 130         dbg("%s - unconfiguring slot %s",
 131             __FUNCTION__, slot->hotplug_slot->name);
 132         if((retval = cpci_unconfigure_slot(slot))) {
 133                 err("%s - could not unconfigure slot %s",
 134                     __FUNCTION__, slot->hotplug_slot->name);
 135                 return retval;
 136         }
 137         dbg("%s - finished unconfiguring slot %s",
 138             __FUNCTION__, slot->hotplug_slot->name);
 139
 140         /* Clear EXT (by setting it) */
 141         if(cpci_clear_ext(slot)) {
 142                 err("%s - could not clear EXT for slot %s",
 143                     __FUNCTION__, slot->hotplug_slot->name);
 144                 retval = -ENODEV;
 145         }
 146         cpci_led_on(slot);
 147
 148         if(controller->ops->set_power) {
 149                 retval = controller->ops->set_power(slot, 0);
 150         }
 151
 152         if(update_adapter_status(slot->hotplug_slot, 0)) {
 153                 warn("failure to update adapter file");
 154         }
 155
 156         if(slot->extracting) {
 157                 slot->extracting = 0;
 158                 atomic_dec(&extracting);
 159         }
 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         }
 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         kfree(slot);
 220 }
 221
 222 #define SLOT_NAME_SIZE  6
 223 static void
 224 make_slot_name(struct slot *slot)
 225 {
 226         snprintf(slot->hotplug_slot->name,
 227                  SLOT_NAME_SIZE, "%02x:%02x", slot->bus->number, slot->number);
 228 }
 229
 230 int
 231 cpci_hp_register_bus(struct pci_bus *bus, u8 first, u8 last)
 232 {
 233         struct slot *slot;
 234         struct hotplug_slot *hotplug_slot;
 235         struct hotplug_slot_info *info;
 236         char *name;
 237         int status = -ENOMEM;
 238         int i;
 239
 240         if(!(controller && bus)) {
 241                 return -ENODEV;
 242         }
 243
 244         /*
 245          * Create a structure for each slot, and register that slot
 246          * with the pci_hotplug subsystem.
 247          */
 248         for (i = first; i <= last; ++i) {
 249                 slot = kmalloc(sizeof (struct slot), GFP_KERNEL);
 250                 if (!slot)
 251                         goto error;
 252                 memset(slot, 0, sizeof (struct slot));
 253
 254                 hotplug_slot =
 255                     kmalloc(sizeof (struct hotplug_slot), GFP_KERNEL);
 256                 if (!hotplug_slot)
 257                         goto error_slot;
 258                 memset(hotplug_slot, 0, sizeof (struct hotplug_slot));
 259                 slot->hotplug_slot = hotplug_slot;
 260
 261                 info = kmalloc(sizeof (struct hotplug_slot_info), GFP_KERNEL);
 262                 if (!info)
 263                         goto error_hpslot;
 264                 memset(info, 0, sizeof (struct hotplug_slot_info));
 265                 hotplug_slot->info = info;
 266
 267                 name = kmalloc(SLOT_NAME_SIZE, GFP_KERNEL);
 268                 if (!name)
 269                         goto error_info;
 270                 hotplug_slot->name = name;
 271
 272                 slot->bus = bus;
 273                 slot->number = i;
 274                 slot->devfn = PCI_DEVFN(i, 0);
 275
 276                 hotplug_slot->private = slot;
 277                 hotplug_slot->release = &release_slot;
 278                 make_slot_name(slot);
 279                 hotplug_slot->ops = &cpci_hotplug_slot_ops;
 280
 281                 /*
 282                  * Initialize the slot info structure with some known
 283                  * good values.
 284                  */
 285                 dbg("initializing slot %s", slot->hotplug_slot->name);
 286                 info->power_status = cpci_get_power_status(slot);
 287                 info->attention_status = cpci_get_attention_status(slot);
 288
 289                 dbg("registering slot %s", slot->hotplug_slot->name);
 290                 status = pci_hp_register(slot->hotplug_slot);
 291                 if (status) {
 292                         err("pci_hp_register failed with error %d", status);
 293                         goto error_name;
 294                 }
 295
 296                 /* Add slot to our internal list */
 297                 down_write(&list_rwsem);
 298                 list_add(&slot->slot_list, &slot_list);
 299                 slots++;
 300                 up_write(&list_rwsem);
 301         }
 302         return 0;
 303 error_name:
 304         kfree(name);
 305 error_info:
 306         kfree(info);
 307 error_hpslot:
 308         kfree(hotplug_slot);
 309 error_slot:
 310         kfree(slot);
 311 error:
 312         return status;
 313 }
 314
 315 int
 316 cpci_hp_unregister_bus(struct pci_bus *bus)
 317 {
 318         struct slot *slot;
 319         struct list_head *tmp;
 320         struct list_head *next;
 321         int status;
 322
 323         down_write(&list_rwsem);
 324         if(!slots) {
 325                 up_write(&list_rwsem);
 326                 return -1;
 327         }
 328         list_for_each_safe(tmp, next, &slot_list) {
 329                 slot = list_entry(tmp, struct slot, slot_list);
 330                 if(slot->bus == bus) {
 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                                 return status;
 337                         }
 338
 339                         list_del(&slot->slot_list);
 340                         slots--;
 341                 }
 342         }
 343         up_write(&list_rwsem);
 344         return 0;
 345 }
 346
 347 /* This is the interrupt mode interrupt handler */
 348 static irqreturn_t
 349 cpci_hp_intr(int irq, void *data, struct pt_regs *regs)
 350 {
 351         dbg("entered cpci_hp_intr");
 352
 353         /* Check to see if it was our interrupt */
 354         if((controller->irq_flags & SA_SHIRQ) &&
 355             !controller->ops->check_irq(controller->dev_id)) {
 356                 dbg("exited cpci_hp_intr, not our interrupt");
 357                 return IRQ_NONE;
 358         }
 359
 360         /* Disable ENUM interrupt */
 361         controller->ops->disable_irq();
 362
 363         /* Trigger processing by the event thread */
 364         dbg("Signal event_semaphore");
 365         up(&event_semaphore);
 366         dbg("exited cpci_hp_intr");
 367         return IRQ_HANDLED;
 368 }
 369
 370 /*
 371  * According to PICMG 2.1 R2.0, section 6.3.2, upon
 372  * initialization, the system driver shall clear the
 373  * INS bits of the cold-inserted devices.
 374  */
 375 static int
 376 init_slots(void)
 377 {
 378         struct slot *slot;
 379         struct list_head *tmp;
 380         struct pci_dev* dev;
 381
 382         dbg("%s - enter", __FUNCTION__);
 383         down_read(&list_rwsem);
 384         if(!slots) {
 385                 up_read(&list_rwsem);
 386                 return -1;
 387         }
 388         list_for_each(tmp, &slot_list) {
 389                 slot = list_entry(tmp, struct slot, slot_list);
 390                 dbg("%s - looking at slot %s",
 391                     __FUNCTION__, slot->hotplug_slot->name);
 392                 if(cpci_check_and_clear_ins(slot)) {
 393                         dbg("%s - cleared INS for slot %s",
 394                             __FUNCTION__, slot->hotplug_slot->name);
 395                         dev = pci_find_slot(slot->bus->number, PCI_DEVFN(slot->number, 0));
 396                         if(dev) {
 397                                 if(update_adapter_status(slot->hotplug_slot, 1)) {
 398                                         warn("failure to update adapter file");
 399                                 }
 400                                 if(update_latch_status(slot->hotplug_slot, 1)) {
 401                                         warn("failure to update latch file");
 402                                 }
 403                                 slot->dev = dev;
 404                         } else {
 405                                 err("%s - no driver attached to device in slot %s",
 406                                     __FUNCTION__, slot->hotplug_slot->name);
 407                         }
 408                 }
 409         }
 410         up_read(&list_rwsem);
 411         dbg("%s - exit", __FUNCTION__);
 412         return 0;
 413 }
 414
 415 static int
 416 check_slots(void)
 417 {
 418         struct slot *slot;
 419         struct list_head *tmp;
 420         int extracted;
 421         int inserted;
 422         u16 hs_csr;
 423
 424         down_read(&list_rwsem);
 425         if(!slots) {
 426                 up_read(&list_rwsem);
 427                 err("no slots registered, shutting down");
 428                 return -1;
 429         }
 430         extracted = inserted = 0;
 431         list_for_each(tmp, &slot_list) {
 432                 slot = list_entry(tmp, struct slot, slot_list);
 433                 dbg("%s - looking at slot %s",
 434                     __FUNCTION__, slot->hotplug_slot->name);
 435                 if(cpci_check_and_clear_ins(slot)) {
 436                         /* Some broken hardware (e.g. PLX 9054AB) asserts ENUM# twice... */
 437                         if(slot->dev) {
 438                                 warn("slot %s already inserted", slot->hotplug_slot->name);
 439                                 inserted++;
 440                                 continue;
 441                         }
 442
 443                         /* Process insertion */
 444                         dbg("%s - slot %s inserted",
 445                             __FUNCTION__, slot->hotplug_slot->name);
 446
 447                         /* GSM, debug */
 448                         hs_csr = cpci_get_hs_csr(slot);
 449                         dbg("%s - slot %s HS_CSR (1) = %04x",
 450                             __FUNCTION__, slot->hotplug_slot->name, hs_csr);
 451
 452                         /* Configure device */
 453                         dbg("%s - configuring slot %s",
 454                             __FUNCTION__, slot->hotplug_slot->name);
 455                         if(cpci_configure_slot(slot)) {
 456                                 err("%s - could not configure slot %s",
 457                                     __FUNCTION__, slot->hotplug_slot->name);
 458                                 continue;
 459                         }
 460                         dbg("%s - finished configuring slot %s",
 461                             __FUNCTION__, slot->hotplug_slot->name);
 462
 463                         /* GSM, debug */
 464                         hs_csr = cpci_get_hs_csr(slot);
 465                         dbg("%s - slot %s HS_CSR (2) = %04x",
 466                             __FUNCTION__, slot->hotplug_slot->name, hs_csr);
 467
 468                         if(update_latch_status(slot->hotplug_slot, 1)) {
 469                                 warn("failure to update latch file");
 470                         }
 471
 472                         if(update_adapter_status(slot->hotplug_slot, 1)) {
 473                                 warn("failure to update adapter file");
 474                         }
 475
 476                         cpci_led_off(slot);
 477
 478                         /* GSM, debug */
 479                         hs_csr = cpci_get_hs_csr(slot);
 480                         dbg("%s - slot %s HS_CSR (3) = %04x",
 481                             __FUNCTION__, slot->hotplug_slot->name, hs_csr);
 482
 483                         inserted++;
 484                 } else if(cpci_check_ext(slot)) {
 485                         /* Process extraction request */
 486                         dbg("%s - slot %s extracted",
 487                             __FUNCTION__, slot->hotplug_slot->name);
 488
 489                         /* GSM, debug */
 490                         hs_csr = cpci_get_hs_csr(slot);
 491                         dbg("%s - slot %s HS_CSR = %04x",
 492                             __FUNCTION__, slot->hotplug_slot->name, hs_csr);
 493
 494                         if(!slot->extracting) {
 495                                 if(update_latch_status(slot->hotplug_slot, 0)) {
 496                                         warn("failure to update latch file");
 497
 498                                 }
 499                                 atomic_inc(&extracting);
 500                                 slot->extracting = 1;
 501                         }
 502                         extracted++;
 503                 } else if(slot->extracting) {
 504                         hs_csr = cpci_get_hs_csr(slot);
 505                         if(hs_csr == 0xffff) {
 506                                 /*
 507                                  * Hmmm, we're likely hosed at this point, should we
 508                                  * bother trying to tell the driver or not?
 509                                  */
 510                                 err("card in slot %s was improperly removed",
 511                                     slot->hotplug_slot->name);
 512                                 if(update_adapter_status(slot->hotplug_slot, 0)) {
 513                                         warn("failure to update adapter file");
 514                                 }
 515                                 slot->extracting = 0;
 516                                 atomic_dec(&extracting);
 517                         }
 518                 }
 519         }
 520         up_read(&list_rwsem);
 521         dbg("inserted=%d, extracted=%d, extracting=%d",
 522             inserted, extracted, atomic_read(&extracting));
 523         if(inserted || extracted) {
 524                 return extracted;
 525         }
 526         else if(!atomic_read(&extracting)) {
 527                 err("cannot find ENUM# source, shutting down");
 528                 return -1;
 529         }
 530         return 0;
 531 }
 532
 533 /* This is the interrupt mode worker thread body */
 534 static int
 535 event_thread(void *data)
 536 {
 537         int rc;
 538
 539         lock_kernel();
 540         daemonize("cpci_hp_eventd");
 541         unlock_kernel();
 542
 543         dbg("%s - event thread started", __FUNCTION__);
 544         while(1) {
 545                 dbg("event thread sleeping");
 546                 down_interruptible(&event_semaphore);
 547                 dbg("event thread woken, thread_finished = %d",
 548                     thread_finished);
 549                 if(thread_finished || signal_pending(current))
 550                         break;
 551                 do {
 552                         rc = check_slots();
 553                         if (rc > 0) {
 554                                 /* Give userspace a chance to handle extraction */
 555                                 msleep(500);
 556                         } else if (rc < 0) {
 557                                 dbg("%s - error checking slots", __FUNCTION__);
 558                                 thread_finished = 1;
 559                                 break;
 560                         }
 561                 } while(atomic_read(&extracting) != 0);
 562
 563                 /* Re-enable ENUM# interrupt */
 564                 dbg("%s - re-enabling irq", __FUNCTION__);
 565                 controller->ops->enable_irq();
 566         }
 567         dbg("%s - event thread signals exit", __FUNCTION__);
 568         up(&thread_exit);
 569         return 0;
 570 }
 571
 572 /* This is the polling mode worker thread body */
 573 static int
 574 poll_thread(void *data)
 575 {
 576         int rc;
 577
 578         lock_kernel();
 579         daemonize("cpci_hp_polld");
 580         unlock_kernel();
 581
 582         while(1) {
 583                 if(thread_finished || signal_pending(current))
 584                         break;
 585                 if(controller->ops->query_enum()) {
 586                         do {
 587                                 rc = check_slots();
 588                                 if(rc > 0) {
 589                                         /* Give userspace a chance to handle extraction */
 590                                         msleep(500);
 591                                 } else if(rc < 0) {
 592                                         dbg("%s - error checking slots", __FUNCTION__);
 593                                         thread_finished = 1;
 594                                         break;
 595                                 }
 596                         } while(atomic_read(&extracting) != 0);
 597                 }
 598                 msleep(100);
 599         }
 600         dbg("poll thread signals exit");
 601         up(&thread_exit);
 602         return 0;
 603 }
 604
 605 static int
 606 cpci_start_thread(void)
 607 {
 608         int pid;
 609
 610         /* initialize our semaphores */
 611         init_MUTEX_LOCKED(&event_semaphore);
 612         init_MUTEX_LOCKED(&thread_exit);
 613         thread_finished = 0;
 614
 615         if(controller->irq) {
 616                 pid = kernel_thread(event_thread, NULL, 0);
 617         } else {
 618                 pid = kernel_thread(poll_thread, NULL, 0);
 619         }
 620         if(pid < 0) {
 621                 err("Can't start up our thread");
 622                 return -1;
 623         }
 624         dbg("Our thread pid = %d", pid);
 625         return 0;
 626 }
 627
 628 static void
 629 cpci_stop_thread(void)
 630 {
 631         thread_finished = 1;
 632         dbg("thread finish command given");
 633         if(controller->irq) {
 634                 up(&event_semaphore);
 635         }
 636         dbg("wait for thread to exit");
 637         down(&thread_exit);
 638 }
 639
 640 int
 641 cpci_hp_register_controller(struct cpci_hp_controller *new_controller)
 642 {
 643         int status = 0;
 644
 645         if(!controller) {
 646                 controller = new_controller;
 647                 if(controller->irq) {
 648                         if(request_irq(controller->irq,
 649                                         cpci_hp_intr,
 650                                         controller->irq_flags,
 651                                         MY_NAME, controller->dev_id)) {
 652                                 err("Can't get irq %d for the hotplug cPCI controller", controller->irq);
 653                                 status = -ENODEV;
 654                         }
 655                         dbg("%s - acquired controller irq %d", __FUNCTION__,
 656                             controller->irq);
 657                 }
 658         } else {
 659                 err("cPCI hotplug controller already registered");
 660                 status = -1;
 661         }
 662         return status;
 663 }
 664
 665 int
 666 cpci_hp_unregister_controller(struct cpci_hp_controller *old_controller)
 667 {
 668         int status = 0;
 669
 670         if(controller) {
 671                 if(atomic_read(&extracting) != 0) {
 672                         return -EBUSY;
 673                 }
 674                 if(!thread_finished) {
 675                         cpci_stop_thread();
 676                 }
 677                 if(controller->irq) {
 678                         free_irq(controller->irq, controller->dev_id);
 679                 }
 680                 controller = NULL;
 681         } else {
 682                 status = -ENODEV;
 683         }
 684         return status;
 685 }
 686
 687 int
 688 cpci_hp_start(void)
 689 {
 690         static int first = 1;
 691         int status;
 692
 693         dbg("%s - enter", __FUNCTION__);
 694         if(!controller) {
 695                 return -ENODEV;
 696         }
 697
 698         down_read(&list_rwsem);
 699         if(list_empty(&slot_list)) {
 700                 up_read(&list_rwsem);
 701                 return -ENODEV;
 702         }
 703         up_read(&list_rwsem);
 704
 705         if(first) {
 706                 status = init_slots();
 707                 if(status) {
 708                         return status;
 709                 }
 710                 first = 0;
 711         }
 712
 713         status = cpci_start_thread();
 714         if(status) {
 715                 return status;
 716         }
 717         dbg("%s - thread started", __FUNCTION__);
 718
 719         if(controller->irq) {
 720                 /* Start enum interrupt processing */
 721                 dbg("%s - enabling irq", __FUNCTION__);
 722                 controller->ops->enable_irq();
 723         }
 724         dbg("%s - exit", __FUNCTION__);
 725         return 0;
 726 }
 727
 728 int
 729 cpci_hp_stop(void)
 730 {
 731         if(!controller) {
 732                 return -ENODEV;
 733         }
 734         if(atomic_read(&extracting) != 0) {
 735                 return -EBUSY;
 736         }
 737         if(controller->irq) {
 738                 /* Stop enum interrupt processing */
 739                 dbg("%s - disabling irq", __FUNCTION__);
 740                 controller->ops->disable_irq();
 741         }
 742         cpci_stop_thread();
 743         return 0;
 744 }
 745
 746 static void __exit
 747 cleanup_slots(void)
 748 {
 749         struct list_head *tmp;
 750         struct slot *slot;
 751
 752         /*
 753          * Unregister all of our slots with the pci_hotplug subsystem,
 754          * and free up all memory that we had allocated.
 755          */
 756         down_write(&list_rwsem);
 757         if(!slots) {
 758                 goto null_cleanup;
 759         }
 760         list_for_each(tmp, &slot_list) {
 761                 slot = list_entry(tmp, struct slot, slot_list);
 762                 list_del(&slot->slot_list);
 763                 pci_hp_deregister(slot->hotplug_slot);
 764                 kfree(slot->hotplug_slot->info);
 765                 kfree(slot->hotplug_slot->name);
 766                 kfree(slot->hotplug_slot);
 767                 kfree(slot);
 768         }
 769       null_cleanup:
 770         up_write(&list_rwsem);
 771         return;
 772 }
 773
 774 int __init
 775 cpci_hotplug_init(int debug)
 776 {
 777         cpci_debug = debug;
 778         return 0;
 779 }
 780
 781 void __exit
 782 cpci_hotplug_exit(void)
 783 {
 784         /*
 785          * Clean everything up.
 786          */
 787         cleanup_slots();
 788 }
 789
 790 EXPORT_SYMBOL_GPL(cpci_hp_register_controller);
 791 EXPORT_SYMBOL_GPL(cpci_hp_unregister_controller);
 792 EXPORT_SYMBOL_GPL(cpci_hp_register_bus);
 793 EXPORT_SYMBOL_GPL(cpci_hp_unregister_bus);
 794 EXPORT_SYMBOL_GPL(cpci_hp_start);
 795 EXPORT_SYMBOL_GPL(cpci_hp_stop);