Automatic merge of /spare/repo/netdev-2.6 branch starfire
[pandora-kernel.git] / 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/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         return retval;
117 }
118
119 static int
120 disable_slot(struct hotplug_slot *hotplug_slot)
121 {
122         struct slot *slot = hotplug_slot->private;
123         int retval = 0;
124
125         dbg("%s - physical_slot = %s", __FUNCTION__, hotplug_slot->name);
126
127         down_write(&list_rwsem);
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                 goto disable_error;
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                 goto disable_error;
146         }
147         cpci_led_on(slot);
148
149         if (controller->ops->set_power)
150                 if ((retval = controller->ops->set_power(slot, 0)))
151                         goto disable_error;
152
153         if (update_adapter_status(slot->hotplug_slot, 0))
154                 warn("failure to update adapter file");
155
156         if (slot->extracting) {
157                 slot->extracting = 0;
158                 atomic_dec(&extracting);
159         }
160 disable_error:
161         up_write(&list_rwsem);
162         return retval;
163 }
164
165 static u8
166 cpci_get_power_status(struct slot *slot)
167 {
168         u8 power = 1;
169
170         if (controller->ops->get_power)
171                 power = controller->ops->get_power(slot);
172         return power;
173 }
174
175 static int
176 get_power_status(struct hotplug_slot *hotplug_slot, u8 * value)
177 {
178         struct slot *slot = hotplug_slot->private;
179
180         *value = cpci_get_power_status(slot);
181         return 0;
182 }
183
184 static int
185 get_attention_status(struct hotplug_slot *hotplug_slot, u8 * value)
186 {
187         struct slot *slot = hotplug_slot->private;
188
189         *value = cpci_get_attention_status(slot);
190         return 0;
191 }
192
193 static int
194 set_attention_status(struct hotplug_slot *hotplug_slot, u8 status)
195 {
196         return cpci_set_attention_status(hotplug_slot->private, status);
197 }
198
199 static int
200 get_adapter_status(struct hotplug_slot *hotplug_slot, u8 * value)
201 {
202         *value = hotplug_slot->info->adapter_status;
203         return 0;
204 }
205
206 static int
207 get_latch_status(struct hotplug_slot *hotplug_slot, u8 * value)
208 {
209         *value = hotplug_slot->info->latch_status;
210         return 0;
211 }
212
213 static void release_slot(struct hotplug_slot *hotplug_slot)
214 {
215         struct slot *slot = hotplug_slot->private;
216
217         kfree(slot->hotplug_slot->info);
218         kfree(slot->hotplug_slot->name);
219         kfree(slot->hotplug_slot);
220         kfree(slot);
221 }
222
223 #define SLOT_NAME_SIZE  6
224 static void
225 make_slot_name(struct slot *slot)
226 {
227         snprintf(slot->hotplug_slot->name,
228                  SLOT_NAME_SIZE, "%02x:%02x", slot->bus->number, slot->number);
229 }
230
231 int
232 cpci_hp_register_bus(struct pci_bus *bus, u8 first, u8 last)
233 {
234         struct slot *slot;
235         struct hotplug_slot *hotplug_slot;
236         struct hotplug_slot_info *info;
237         char *name;
238         int status = -ENOMEM;
239         int i;
240
241         if (!(controller && bus))
242                 return -ENODEV;
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 slot *tmp;
320         int status = 0;
321
322         down_write(&list_rwsem);
323         if (!slots) {
324                 up_write(&list_rwsem);
325                 return -1;
326         }
327         list_for_each_entry_safe(slot, tmp, &slot_list, slot_list) {
328                 if (slot->bus == bus) {
329                         list_del(&slot->slot_list);
330                         slots--;
331
332                         dbg("deregistering slot %s", slot->hotplug_slot->name);
333                         status = pci_hp_deregister(slot->hotplug_slot);
334                         if (status) {
335                                 err("pci_hp_deregister failed with error %d",
336                                     status);
337                                 break;
338                         }
339                 }
340         }
341         up_write(&list_rwsem);
342         return status;
343 }
344
345 /* This is the interrupt mode interrupt handler */
346 static irqreturn_t
347 cpci_hp_intr(int irq, void *data, struct pt_regs *regs)
348 {
349         dbg("entered cpci_hp_intr");
350
351         /* Check to see if it was our interrupt */
352         if ((controller->irq_flags & SA_SHIRQ) &&
353             !controller->ops->check_irq(controller->dev_id)) {
354                 dbg("exited cpci_hp_intr, not our interrupt");
355                 return IRQ_NONE;
356         }
357
358         /* Disable ENUM interrupt */
359         controller->ops->disable_irq();
360
361         /* Trigger processing by the event thread */
362         dbg("Signal event_semaphore");
363         up(&event_semaphore);
364         dbg("exited cpci_hp_intr");
365         return IRQ_HANDLED;
366 }
367
368 /*
369  * According to PICMG 2.1 R2.0, section 6.3.2, upon
370  * initialization, the system driver shall clear the
371  * INS bits of the cold-inserted devices.
372  */
373 static int
374 init_slots(int clear_ins)
375 {
376         struct slot *slot;
377         struct pci_dev* dev;
378
379         dbg("%s - enter", __FUNCTION__);
380         down_read(&list_rwsem);
381         if (!slots) {
382                 up_read(&list_rwsem);
383                 return -1;
384         }
385         list_for_each_entry(slot, &slot_list, slot_list) {
386                 dbg("%s - looking at slot %s",
387                     __FUNCTION__, slot->hotplug_slot->name);
388                 if (clear_ins && cpci_check_and_clear_ins(slot))
389                         dbg("%s - cleared INS for slot %s",
390                             __FUNCTION__, slot->hotplug_slot->name);
391                 dev = pci_get_slot(slot->bus, PCI_DEVFN(slot->number, 0));
392                 if (dev) {
393                         if (update_adapter_status(slot->hotplug_slot, 1))
394                                 warn("failure to update adapter file");
395                         if (update_latch_status(slot->hotplug_slot, 1))
396                                 warn("failure to update latch file");
397                         slot->dev = dev;
398                 }
399         }
400         up_read(&list_rwsem);
401         dbg("%s - exit", __FUNCTION__);
402         return 0;
403 }
404
405 static int
406 check_slots(void)
407 {
408         struct slot *slot;
409         int extracted;
410         int inserted;
411         u16 hs_csr;
412
413         down_read(&list_rwsem);
414         if (!slots) {
415                 up_read(&list_rwsem);
416                 err("no slots registered, shutting down");
417                 return -1;
418         }
419         extracted = inserted = 0;
420         list_for_each_entry(slot, &slot_list, slot_list) {
421                 dbg("%s - looking at slot %s",
422                     __FUNCTION__, slot->hotplug_slot->name);
423                 if (cpci_check_and_clear_ins(slot)) {
424                         /*
425                          * Some broken hardware (e.g. PLX 9054AB) asserts
426                          * ENUM# twice...
427                          */
428                         if (slot->dev) {
429                                 warn("slot %s already inserted",
430                                      slot->hotplug_slot->name);
431                                 inserted++;
432                                 continue;
433                         }
434
435                         /* Process insertion */
436                         dbg("%s - slot %s inserted",
437                             __FUNCTION__, slot->hotplug_slot->name);
438
439                         /* GSM, debug */
440                         hs_csr = cpci_get_hs_csr(slot);
441                         dbg("%s - slot %s HS_CSR (1) = %04x",
442                             __FUNCTION__, slot->hotplug_slot->name, hs_csr);
443
444                         /* Configure device */
445                         dbg("%s - configuring slot %s",
446                             __FUNCTION__, slot->hotplug_slot->name);
447                         if (cpci_configure_slot(slot)) {
448                                 err("%s - could not configure slot %s",
449                                     __FUNCTION__, slot->hotplug_slot->name);
450                                 continue;
451                         }
452                         dbg("%s - finished configuring slot %s",
453                             __FUNCTION__, slot->hotplug_slot->name);
454
455                         /* GSM, debug */
456                         hs_csr = cpci_get_hs_csr(slot);
457                         dbg("%s - slot %s HS_CSR (2) = %04x",
458                             __FUNCTION__, slot->hotplug_slot->name, hs_csr);
459
460                         if (update_latch_status(slot->hotplug_slot, 1))
461                                 warn("failure to update latch file");
462
463                         if (update_adapter_status(slot->hotplug_slot, 1))
464                                 warn("failure to update adapter file");
465
466                         cpci_led_off(slot);
467
468                         /* GSM, debug */
469                         hs_csr = cpci_get_hs_csr(slot);
470                         dbg("%s - slot %s HS_CSR (3) = %04x",
471                             __FUNCTION__, slot->hotplug_slot->name, hs_csr);
472
473                         inserted++;
474                 } else if (cpci_check_ext(slot)) {
475                         /* Process extraction request */
476                         dbg("%s - slot %s extracted",
477                             __FUNCTION__, slot->hotplug_slot->name);
478
479                         /* GSM, debug */
480                         hs_csr = cpci_get_hs_csr(slot);
481                         dbg("%s - slot %s HS_CSR = %04x",
482                             __FUNCTION__, slot->hotplug_slot->name, hs_csr);
483
484                         if (!slot->extracting) {
485                                 if (update_latch_status(slot->hotplug_slot, 0)) {
486                                         warn("failure to update latch file");
487                                 }
488                                 slot->extracting = 1;
489                                 atomic_inc(&extracting);
490                         }
491                         extracted++;
492                 } else if (slot->extracting) {
493                         hs_csr = cpci_get_hs_csr(slot);
494                         if (hs_csr == 0xffff) {
495                                 /*
496                                  * Hmmm, we're likely hosed at this point, should we
497                                  * bother trying to tell the driver or not?
498                                  */
499                                 err("card in slot %s was improperly removed",
500                                     slot->hotplug_slot->name);
501                                 if (update_adapter_status(slot->hotplug_slot, 0))
502                                         warn("failure to update adapter file");
503                                 slot->extracting = 0;
504                                 atomic_dec(&extracting);
505                         }
506                 }
507         }
508         up_read(&list_rwsem);
509         dbg("inserted=%d, extracted=%d, extracting=%d",
510             inserted, extracted, atomic_read(&extracting));
511         if (inserted || extracted)
512                 return extracted;
513         else if (!atomic_read(&extracting)) {
514                 err("cannot find ENUM# source, shutting down");
515                 return -1;
516         }
517         return 0;
518 }
519
520 /* This is the interrupt mode worker thread body */
521 static int
522 event_thread(void *data)
523 {
524         int rc;
525
526         lock_kernel();
527         daemonize("cpci_hp_eventd");
528         unlock_kernel();
529
530         dbg("%s - event thread started", __FUNCTION__);
531         while (1) {
532                 dbg("event thread sleeping");
533                 down_interruptible(&event_semaphore);
534                 dbg("event thread woken, thread_finished = %d",
535                     thread_finished);
536                 if (thread_finished || signal_pending(current))
537                         break;
538                 do {
539                         rc = check_slots();
540                         if (rc > 0) {
541                                 /* Give userspace a chance to handle extraction */
542                                 msleep(500);
543                         } else if (rc < 0) {
544                                 dbg("%s - error checking slots", __FUNCTION__);
545                                 thread_finished = 1;
546                                 break;
547                         }
548                 } while (atomic_read(&extracting) && !thread_finished);
549                 if (thread_finished)
550                         break;
551
552                 /* Re-enable ENUM# interrupt */
553                 dbg("%s - re-enabling irq", __FUNCTION__);
554                 controller->ops->enable_irq();
555         }
556         dbg("%s - event thread signals exit", __FUNCTION__);
557         up(&thread_exit);
558         return 0;
559 }
560
561 /* This is the polling mode worker thread body */
562 static int
563 poll_thread(void *data)
564 {
565         int rc;
566
567         lock_kernel();
568         daemonize("cpci_hp_polld");
569         unlock_kernel();
570
571         while (1) {
572                 if (thread_finished || signal_pending(current))
573                         break;
574                 if (controller->ops->query_enum()) {
575                         do {
576                                 rc = check_slots();
577                                 if (rc > 0) {
578                                         /* Give userspace a chance to handle extraction */
579                                         msleep(500);
580                                 } else if (rc < 0) {
581                                         dbg("%s - error checking slots", __FUNCTION__);
582                                         thread_finished = 1;
583                                         break;
584                                 }
585                         } while (atomic_read(&extracting) && !thread_finished);
586                 }
587                 msleep(100);
588         }
589         dbg("poll thread signals exit");
590         up(&thread_exit);
591         return 0;
592 }
593
594 static int
595 cpci_start_thread(void)
596 {
597         int pid;
598
599         /* initialize our semaphores */
600         init_MUTEX_LOCKED(&event_semaphore);
601         init_MUTEX_LOCKED(&thread_exit);
602         thread_finished = 0;
603
604         if (controller->irq)
605                 pid = kernel_thread(event_thread, NULL, 0);
606         else
607                 pid = kernel_thread(poll_thread, NULL, 0);
608         if (pid < 0) {
609                 err("Can't start up our thread");
610                 return -1;
611         }
612         dbg("Our thread pid = %d", pid);
613         return 0;
614 }
615
616 static void
617 cpci_stop_thread(void)
618 {
619         thread_finished = 1;
620         dbg("thread finish command given");
621         if (controller->irq)
622                 up(&event_semaphore);
623         dbg("wait for thread to exit");
624         down(&thread_exit);
625 }
626
627 int
628 cpci_hp_register_controller(struct cpci_hp_controller *new_controller)
629 {
630         int status = 0;
631
632         if (controller)
633                 return -1;
634         if (!(new_controller && new_controller->ops))
635                 return -EINVAL;
636         if (new_controller->irq) {
637                 if (!(new_controller->ops->enable_irq &&
638                      new_controller->ops->disable_irq))
639                         status = -EINVAL;
640                 if (request_irq(new_controller->irq,
641                                cpci_hp_intr,
642                                new_controller->irq_flags,
643                                MY_NAME,
644                                new_controller->dev_id)) {
645                         err("Can't get irq %d for the hotplug cPCI controller",
646                             new_controller->irq);
647                         status = -ENODEV;
648                 }
649                 dbg("%s - acquired controller irq %d",
650                     __FUNCTION__, new_controller->irq);
651         }
652         if (!status)
653                 controller = new_controller;
654         return status;
655 }
656
657 static void
658 cleanup_slots(void)
659 {
660         struct slot *slot;
661         struct slot *tmp;
662
663         /*
664          * Unregister all of our slots with the pci_hotplug subsystem,
665          * and free up all memory that we had allocated.
666          */
667         down_write(&list_rwsem);
668         if (!slots)
669                 goto cleanup_null;
670         list_for_each_entry_safe(slot, tmp, &slot_list, slot_list) {
671                 list_del(&slot->slot_list);
672                 pci_hp_deregister(slot->hotplug_slot);
673         }
674 cleanup_null:
675         up_write(&list_rwsem);
676         return;
677 }
678
679 int
680 cpci_hp_unregister_controller(struct cpci_hp_controller *old_controller)
681 {
682         int status = 0;
683
684         if (controller) {
685                 if (!thread_finished)
686                         cpci_stop_thread();
687                 if (controller->irq)
688                         free_irq(controller->irq, controller->dev_id);
689                 controller = NULL;
690                 cleanup_slots();
691         } else
692                 status = -ENODEV;
693         return status;
694 }
695
696 int
697 cpci_hp_start(void)
698 {
699         static int first = 1;
700         int status;
701
702         dbg("%s - enter", __FUNCTION__);
703         if (!controller)
704                 return -ENODEV;
705
706         down_read(&list_rwsem);
707         if (list_empty(&slot_list)) {
708                 up_read(&list_rwsem);
709                 return -ENODEV;
710         }
711         up_read(&list_rwsem);
712
713         status = init_slots(first);
714         if (first)
715                 first = 0;
716         if (status)
717                 return status;
718
719         status = cpci_start_thread();
720         if (status)
721                 return status;
722         dbg("%s - thread started", __FUNCTION__);
723
724         if (controller->irq) {
725                 /* Start enum interrupt processing */
726                 dbg("%s - enabling irq", __FUNCTION__);
727                 controller->ops->enable_irq();
728         }
729         dbg("%s - exit", __FUNCTION__);
730         return 0;
731 }
732
733 int
734 cpci_hp_stop(void)
735 {
736         if (!controller)
737                 return -ENODEV;
738         if (controller->irq) {
739                 /* Stop enum interrupt processing */
740                 dbg("%s - disabling irq", __FUNCTION__);
741                 controller->ops->disable_irq();
742         }
743         cpci_stop_thread();
744         return 0;
745 }
746
747 int __init
748 cpci_hotplug_init(int debug)
749 {
750         cpci_debug = debug;
751         return 0;
752 }
753
754 void __exit
755 cpci_hotplug_exit(void)
756 {
757         /*
758          * Clean everything up.
759          */
760         cpci_hp_stop();
761         cpci_hp_unregister_controller(controller);
762 }
763
764 EXPORT_SYMBOL_GPL(cpci_hp_register_controller);
765 EXPORT_SYMBOL_GPL(cpci_hp_unregister_controller);
766 EXPORT_SYMBOL_GPL(cpci_hp_register_bus);
767 EXPORT_SYMBOL_GPL(cpci_hp_unregister_bus);
768 EXPORT_SYMBOL_GPL(cpci_hp_start);
769 EXPORT_SYMBOL_GPL(cpci_hp_stop);