]> nv-tegra.nvidia Code Review - linux-3.10.git/blob - drivers/pci/hotplug/pciehp_core.c
[PATCH] fix u32 vs. pm_message_t in PCI, PCIE
[linux-3.10.git] / drivers / pci / hotplug / pciehp_core.c
1 /*
2  * PCI Express Hot Plug Controller Driver
3  *
4  * Copyright (C) 1995,2001 Compaq Computer Corporation
5  * Copyright (C) 2001 Greg Kroah-Hartman (greg@kroah.com)
6  * Copyright (C) 2001 IBM Corp.
7  * Copyright (C) 2003-2004 Intel Corporation
8  *
9  * All rights reserved.
10  *
11  * This program is free software; you can redistribute it and/or modify
12  * it under the terms of the GNU General Public License as published by
13  * the Free Software Foundation; either version 2 of the License, or (at
14  * your option) any later version.
15  *
16  * This program is distributed in the hope that it will be useful, but
17  * WITHOUT ANY WARRANTY; without even the implied warranty of
18  * MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE, GOOD TITLE or
19  * NON INFRINGEMENT.  See the GNU General Public License for more
20  * details.
21  *
22  * You should have received a copy of the GNU General Public License
23  * along with this program; if not, write to the Free Software
24  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
25  *
26  * Send feedback to <greg@kroah.com>, <dely.l.sy@intel.com>
27  *
28  */
29
30 #include <linux/config.h>
31 #include <linux/module.h>
32 #include <linux/moduleparam.h>
33 #include <linux/kernel.h>
34 #include <linux/types.h>
35 #include <linux/proc_fs.h>
36 #include <linux/slab.h>
37 #include <linux/workqueue.h>
38 #include <linux/pci.h>
39 #include <linux/init.h>
40 #include <asm/uaccess.h>
41 #include "pciehp.h"
42 #include "pciehprm.h"
43 #include <linux/interrupt.h>
44
45 /* Global variables */
46 int pciehp_debug;
47 int pciehp_poll_mode;
48 int pciehp_poll_time;
49 struct controller *pciehp_ctrl_list;
50 struct pci_func *pciehp_slot_list[256];
51
52 #define DRIVER_VERSION  "0.4"
53 #define DRIVER_AUTHOR   "Dan Zink <dan.zink@compaq.com>, Greg Kroah-Hartman <greg@kroah.com>, Dely Sy <dely.l.sy@intel.com>"
54 #define DRIVER_DESC     "PCI Express Hot Plug Controller Driver"
55
56 MODULE_AUTHOR(DRIVER_AUTHOR);
57 MODULE_DESCRIPTION(DRIVER_DESC);
58 MODULE_LICENSE("GPL");
59
60 module_param(pciehp_debug, bool, 0644);
61 module_param(pciehp_poll_mode, bool, 0644);
62 module_param(pciehp_poll_time, int, 0644);
63 MODULE_PARM_DESC(pciehp_debug, "Debugging mode enabled or not");
64 MODULE_PARM_DESC(pciehp_poll_mode, "Using polling mechanism for hot-plug events or not");
65 MODULE_PARM_DESC(pciehp_poll_time, "Polling mechanism frequency, in seconds");
66
67 #define PCIE_MODULE_NAME "pciehp"
68
69 static int pcie_start_thread (void);
70 static int set_attention_status (struct hotplug_slot *slot, u8 value);
71 static int enable_slot          (struct hotplug_slot *slot);
72 static int disable_slot         (struct hotplug_slot *slot);
73 static int get_power_status     (struct hotplug_slot *slot, u8 *value);
74 static int get_attention_status (struct hotplug_slot *slot, u8 *value);
75 static int get_latch_status     (struct hotplug_slot *slot, u8 *value);
76 static int get_adapter_status   (struct hotplug_slot *slot, u8 *value);
77 static int get_max_bus_speed    (struct hotplug_slot *slot, enum pci_bus_speed *value);
78 static int get_cur_bus_speed    (struct hotplug_slot *slot, enum pci_bus_speed *value);
79
80 static struct hotplug_slot_ops pciehp_hotplug_slot_ops = {
81         .owner =                THIS_MODULE,
82         .set_attention_status = set_attention_status,
83         .enable_slot =          enable_slot,
84         .disable_slot =         disable_slot,
85         .get_power_status =     get_power_status,
86         .get_attention_status = get_attention_status,
87         .get_latch_status =     get_latch_status,
88         .get_adapter_status =   get_adapter_status,
89         .get_max_bus_speed =    get_max_bus_speed,
90         .get_cur_bus_speed =    get_cur_bus_speed,
91 };
92
93 static int init_slots(struct controller *ctrl)
94 {
95         struct slot *new_slot;
96         u8 number_of_slots;
97         u8 slot_device;
98         u32 slot_number;
99         int result = -ENOMEM;
100
101         dbg("%s\n",__FUNCTION__);
102
103         number_of_slots = ctrl->num_slots;
104         slot_device = ctrl->slot_device_offset;
105         slot_number = ctrl->first_slot;
106
107         while (number_of_slots) {
108                 new_slot = kmalloc(sizeof(*new_slot), GFP_KERNEL);
109                 if (!new_slot)
110                         goto error;
111
112                 memset(new_slot, 0, sizeof(struct slot));
113                 new_slot->hotplug_slot =
114                                 kmalloc(sizeof(*(new_slot->hotplug_slot)),
115                                                 GFP_KERNEL);
116                 if (!new_slot->hotplug_slot)
117                         goto error_slot;
118                 memset(new_slot->hotplug_slot, 0, sizeof(struct hotplug_slot));
119
120                 new_slot->hotplug_slot->info =
121                         kmalloc(sizeof(*(new_slot->hotplug_slot->info)),
122                                                 GFP_KERNEL);
123                 if (!new_slot->hotplug_slot->info)
124                         goto error_hpslot;
125                 memset(new_slot->hotplug_slot->info, 0,
126                                         sizeof(struct hotplug_slot_info));
127                 new_slot->hotplug_slot->name = kmalloc(SLOT_NAME_SIZE,
128                                                 GFP_KERNEL);
129                 if (!new_slot->hotplug_slot->name)
130                         goto error_info;
131
132                 new_slot->ctrl = ctrl;
133                 new_slot->bus = ctrl->slot_bus;
134                 new_slot->device = slot_device;
135                 new_slot->hpc_ops = ctrl->hpc_ops;
136
137                 new_slot->number = ctrl->first_slot;
138                 new_slot->hp_slot = slot_device - ctrl->slot_device_offset;
139
140                 /* register this slot with the hotplug pci core */
141                 new_slot->hotplug_slot->private = new_slot;
142                 make_slot_name (new_slot->hotplug_slot->name, SLOT_NAME_SIZE, new_slot);
143                 new_slot->hotplug_slot->ops = &pciehp_hotplug_slot_ops;
144
145                 new_slot->hpc_ops->get_power_status(new_slot, &(new_slot->hotplug_slot->info->power_status));
146                 new_slot->hpc_ops->get_attention_status(new_slot, &(new_slot->hotplug_slot->info->attention_status));
147                 new_slot->hpc_ops->get_latch_status(new_slot, &(new_slot->hotplug_slot->info->latch_status));
148                 new_slot->hpc_ops->get_adapter_status(new_slot, &(new_slot->hotplug_slot->info->adapter_status));
149
150                 dbg("Registering bus=%x dev=%x hp_slot=%x sun=%x slot_device_offset=%x\n", 
151                         new_slot->bus, new_slot->device, new_slot->hp_slot, new_slot->number, ctrl->slot_device_offset);
152                 result = pci_hp_register (new_slot->hotplug_slot);
153                 if (result) {
154                         err ("pci_hp_register failed with error %d\n", result);
155                         goto error_name;
156                 }
157
158                 new_slot->next = ctrl->slot;
159                 ctrl->slot = new_slot;
160
161                 number_of_slots--;
162                 slot_device++;
163                 slot_number += ctrl->slot_num_inc;
164         }
165
166         return 0;
167
168 error_name:
169         kfree(new_slot->hotplug_slot->name);
170 error_info:
171         kfree(new_slot->hotplug_slot->info);
172 error_hpslot:
173         kfree(new_slot->hotplug_slot);
174 error_slot:
175         kfree(new_slot);
176 error:
177         return result;
178 }
179
180
181 static int cleanup_slots (struct controller * ctrl)
182 {
183         struct slot *old_slot, *next_slot;
184
185         old_slot = ctrl->slot;
186         ctrl->slot = NULL;
187
188         while (old_slot) {
189                 next_slot = old_slot->next;
190                 pci_hp_deregister (old_slot->hotplug_slot);
191                 kfree(old_slot->hotplug_slot->info);
192                 kfree(old_slot->hotplug_slot->name);
193                 kfree(old_slot->hotplug_slot);
194                 kfree(old_slot);
195                 old_slot = next_slot;
196         }
197
198
199         return(0);
200 }
201
202 static int get_ctlr_slot_config(struct controller *ctrl)
203 {
204         int num_ctlr_slots;             /* Not needed; PCI Express has 1 slot per port*/
205         int first_device_num;           /* Not needed */
206         int physical_slot_num;
207         u8 ctrlcap;                     
208         int rc;
209
210         rc = pcie_get_ctlr_slot_config(ctrl, &num_ctlr_slots, &first_device_num, &physical_slot_num, &ctrlcap);
211         if (rc) {
212                 err("%s: get_ctlr_slot_config fail for b:d (%x:%x)\n", __FUNCTION__, ctrl->bus, ctrl->device);
213                 return (-1);
214         }
215
216         ctrl->num_slots = num_ctlr_slots;       /* PCI Express has 1 slot per port */
217         ctrl->slot_device_offset = first_device_num;
218         ctrl->first_slot = physical_slot_num;
219         ctrl->ctrlcap = ctrlcap;        
220
221         dbg("%s: bus(0x%x) num_slot(0x%x) 1st_dev(0x%x) psn(0x%x) ctrlcap(%x) for b:d (%x:%x)\n",
222                 __FUNCTION__, ctrl->slot_bus, num_ctlr_slots, first_device_num, physical_slot_num, ctrlcap, 
223                 ctrl->bus, ctrl->device);
224
225         return (0);
226 }
227
228
229 /*
230  * set_attention_status - Turns the Amber LED for a slot on, off or blink
231  */
232 static int set_attention_status(struct hotplug_slot *hotplug_slot, u8 status)
233 {
234         struct slot *slot = hotplug_slot->private;
235
236         dbg("%s - physical_slot = %s\n", __FUNCTION__, hotplug_slot->name);
237
238         hotplug_slot->info->attention_status = status;
239         
240         if (ATTN_LED(slot->ctrl->ctrlcap)) 
241                 slot->hpc_ops->set_attention_status(slot, status);
242
243         return 0;
244 }
245
246
247 static int enable_slot(struct hotplug_slot *hotplug_slot)
248 {
249         struct slot *slot = hotplug_slot->private;
250
251         dbg("%s - physical_slot = %s\n", __FUNCTION__, hotplug_slot->name);
252
253         return pciehp_enable_slot(slot);
254 }
255
256
257 static int disable_slot(struct hotplug_slot *hotplug_slot)
258 {
259         struct slot *slot = hotplug_slot->private;
260
261         dbg("%s - physical_slot = %s\n", __FUNCTION__, hotplug_slot->name);
262
263         return pciehp_disable_slot(slot);
264 }
265
266 static int get_power_status(struct hotplug_slot *hotplug_slot, u8 *value)
267 {
268         struct slot *slot = hotplug_slot->private;
269         int retval;
270
271         dbg("%s - physical_slot = %s\n", __FUNCTION__, hotplug_slot->name);
272
273         retval = slot->hpc_ops->get_power_status(slot, value);
274         if (retval < 0)
275                 *value = hotplug_slot->info->power_status;
276
277         return 0;
278 }
279
280 static int get_attention_status(struct hotplug_slot *hotplug_slot, u8 *value)
281 {
282         struct slot *slot = hotplug_slot->private;
283         int retval;
284
285         dbg("%s - physical_slot = %s\n", __FUNCTION__, hotplug_slot->name);
286
287         retval = slot->hpc_ops->get_attention_status(slot, value);
288         if (retval < 0)
289                 *value = hotplug_slot->info->attention_status;
290
291         return 0;
292 }
293
294 static int get_latch_status(struct hotplug_slot *hotplug_slot, u8 *value)
295 {
296         struct slot *slot = hotplug_slot->private;
297         int retval;
298
299         dbg("%s - physical_slot = %s\n", __FUNCTION__, hotplug_slot->name);
300
301         retval = slot->hpc_ops->get_latch_status(slot, value);
302         if (retval < 0)
303                 *value = hotplug_slot->info->latch_status;
304
305         return 0;
306 }
307
308 static int get_adapter_status(struct hotplug_slot *hotplug_slot, u8 *value)
309 {
310         struct slot *slot = hotplug_slot->private;
311         int retval;
312
313         dbg("%s - physical_slot = %s\n", __FUNCTION__, hotplug_slot->name);
314
315         retval = slot->hpc_ops->get_adapter_status(slot, value);
316         if (retval < 0)
317                 *value = hotplug_slot->info->adapter_status;
318
319         return 0;
320 }
321
322 static int get_max_bus_speed(struct hotplug_slot *hotplug_slot, enum pci_bus_speed *value)
323 {
324         struct slot *slot = hotplug_slot->private;
325         int retval;
326
327         dbg("%s - physical_slot = %s\n", __FUNCTION__, hotplug_slot->name);
328         
329         retval = slot->hpc_ops->get_max_bus_speed(slot, value);
330         if (retval < 0)
331                 *value = PCI_SPEED_UNKNOWN;
332
333         return 0;
334 }
335
336 static int get_cur_bus_speed(struct hotplug_slot *hotplug_slot, enum pci_bus_speed *value)
337 {
338         struct slot *slot = hotplug_slot->private;
339         int retval;
340
341         dbg("%s - physical_slot = %s\n", __FUNCTION__, hotplug_slot->name);
342         
343         retval = slot->hpc_ops->get_cur_bus_speed(slot, value);
344         if (retval < 0)
345                 *value = PCI_SPEED_UNKNOWN;
346
347         return 0;
348 }
349
350 static int pciehp_probe(struct pcie_device *dev, const struct pcie_port_service_id *id)
351 {
352         int rc;
353         struct controller *ctrl;
354         struct slot *t_slot;
355         int first_device_num = 0 ;      /* first PCI device number supported by this PCIE */  
356         int num_ctlr_slots;             /* number of slots supported by this HPC */
357         u8 value;
358         struct pci_dev *pdev;
359         
360         dbg("%s: Called by hp_drv\n", __FUNCTION__);
361         ctrl = kmalloc(sizeof(*ctrl), GFP_KERNEL);
362         if (!ctrl) {
363                 err("%s : out of memory\n", __FUNCTION__);
364                 goto err_out_none;
365         }
366         memset(ctrl, 0, sizeof(struct controller));
367
368         dbg("%s: DRV_thread pid = %d\n", __FUNCTION__, current->pid);
369         
370         pdev = dev->port;
371
372         rc = pcie_init(ctrl, dev,
373                 (php_intr_callback_t) pciehp_handle_attention_button,
374                 (php_intr_callback_t) pciehp_handle_switch_change,
375                 (php_intr_callback_t) pciehp_handle_presence_change,
376                 (php_intr_callback_t) pciehp_handle_power_fault);
377         if (rc) {
378                 dbg("%s: controller initialization failed\n", PCIE_MODULE_NAME);
379                 goto err_out_free_ctrl;
380         }
381
382         ctrl->pci_dev = pdev;
383
384         pci_set_drvdata(pdev, ctrl);
385
386         ctrl->pci_bus = kmalloc(sizeof(*ctrl->pci_bus), GFP_KERNEL);
387         if (!ctrl->pci_bus) {
388                 err("%s: out of memory\n", __FUNCTION__);
389                 rc = -ENOMEM;
390                 goto err_out_unmap_mmio_region;
391         }
392         dbg("%s: ctrl->pci_bus %p\n", __FUNCTION__, ctrl->pci_bus);
393         memcpy (ctrl->pci_bus, pdev->bus, sizeof (*ctrl->pci_bus));
394         ctrl->bus = pdev->bus->number;  /* ctrl bus */
395         ctrl->slot_bus = pdev->subordinate->number;  /* bus controlled by this HPC */
396
397         ctrl->device = PCI_SLOT(pdev->devfn);
398         ctrl->function = PCI_FUNC(pdev->devfn);
399         dbg("%s: ctrl bus=0x%x, device=%x, function=%x, irq=%x\n", __FUNCTION__,
400                 ctrl->bus, ctrl->device, ctrl->function, pdev->irq);
401
402         /*
403          *      Save configuration headers for this and subordinate PCI buses
404          */
405
406         rc = get_ctlr_slot_config(ctrl);
407         if (rc) {
408                 err(msg_initialization_err, rc);
409                 goto err_out_free_ctrl_bus;
410         }
411         first_device_num = ctrl->slot_device_offset;
412         num_ctlr_slots = ctrl->num_slots; 
413
414         /* Store PCI Config Space for all devices on this bus */
415         dbg("%s: Before calling pciehp_save_config, ctrl->bus %x,ctrl->slot_bus %x\n", 
416                 __FUNCTION__,ctrl->bus, ctrl->slot_bus);
417         rc = pciehp_save_config(ctrl, ctrl->slot_bus, num_ctlr_slots, first_device_num);
418         if (rc) {
419                 err("%s: unable to save PCI configuration data, error %d\n", __FUNCTION__, rc);
420                 goto err_out_free_ctrl_bus;
421         }
422
423         /* Get IO, memory, and IRQ resources for new devices */
424         rc = pciehprm_find_available_resources(ctrl);
425         ctrl->add_support = !rc;
426         
427         if (rc) {
428                 dbg("pciehprm_find_available_resources = %#x\n", rc);
429                 err("unable to locate PCI configuration resources for hot plug add.\n");
430                 goto err_out_free_ctrl_bus;
431         }
432
433         /* Setup the slot information structures */
434         rc = init_slots(ctrl);
435         if (rc) {
436                 err(msg_initialization_err, 6);
437                 goto err_out_free_ctrl_slot;
438         }
439
440         t_slot = pciehp_find_slot(ctrl, first_device_num);
441         dbg("%s: t_slot %p\n", __FUNCTION__, t_slot);
442
443         /*      Finish setting up the hot plug ctrl device */
444         ctrl->next_event = 0;
445
446         if (!pciehp_ctrl_list) {
447                 pciehp_ctrl_list = ctrl;
448                 ctrl->next = NULL;
449         } else {
450                 ctrl->next = pciehp_ctrl_list;
451                 pciehp_ctrl_list = ctrl;
452         }
453
454         /* Wait for exclusive access to hardware */
455         down(&ctrl->crit_sect);
456
457         t_slot->hpc_ops->get_adapter_status(t_slot, &value); /* Check if slot is occupied */
458         dbg("%s: adpater value %x\n", __FUNCTION__, value);
459         
460         if ((POWER_CTRL(ctrl->ctrlcap)) && !value) {
461                 rc = t_slot->hpc_ops->power_off_slot(t_slot); /* Power off slot if not occupied*/
462                 if (rc) {
463                         /* Done with exclusive hardware access */
464                         up(&ctrl->crit_sect);
465                         goto err_out_free_ctrl_slot;
466                 } else
467                         /* Wait for the command to complete */
468                         wait_for_ctrl_irq (ctrl);
469         }
470
471         /* Done with exclusive hardware access */
472         up(&ctrl->crit_sect);
473
474         return 0;
475
476 err_out_free_ctrl_slot:
477         cleanup_slots(ctrl);
478 err_out_free_ctrl_bus:
479         kfree(ctrl->pci_bus);
480 err_out_unmap_mmio_region:
481         ctrl->hpc_ops->release_ctlr(ctrl);
482 err_out_free_ctrl:
483         kfree(ctrl);
484 err_out_none:
485         return -ENODEV;
486 }
487
488
489 static int pcie_start_thread(void)
490 {
491         int loop;
492         int retval = 0;
493         
494         dbg("Initialize + Start the notification/polling mechanism \n");
495
496         retval = pciehp_event_start_thread();
497         if (retval) {
498                 dbg("pciehp_event_start_thread() failed\n");
499                 return retval;
500         }
501
502         dbg("Initialize slot lists\n");
503         /* One slot list for each bus in the system */
504         for (loop = 0; loop < 256; loop++) {
505                 pciehp_slot_list[loop] = NULL;
506         }
507
508         return retval;
509 }
510
511 static inline void __exit
512 free_pciehp_res(struct pci_resource *res)
513 {
514         struct pci_resource *tres;
515
516         while (res) {
517                 tres = res;
518                 res = res->next;
519                 kfree(tres);
520         }
521 }
522
523 static void __exit unload_pciehpd(void)
524 {
525         struct pci_func *next;
526         struct pci_func *TempSlot;
527         int loop;
528         struct controller *ctrl;
529         struct controller *tctrl;
530
531         ctrl = pciehp_ctrl_list;
532
533         while (ctrl) {
534                 cleanup_slots(ctrl);
535
536                 free_pciehp_res(ctrl->io_head);
537                 free_pciehp_res(ctrl->mem_head);
538                 free_pciehp_res(ctrl->p_mem_head);
539                 free_pciehp_res(ctrl->bus_head);
540
541                 kfree (ctrl->pci_bus);
542
543                 ctrl->hpc_ops->release_ctlr(ctrl);
544
545                 tctrl = ctrl;
546                 ctrl = ctrl->next;
547
548                 kfree(tctrl);
549         }
550
551         for (loop = 0; loop < 256; loop++) {
552                 next = pciehp_slot_list[loop];
553                 while (next != NULL) {
554                         free_pciehp_res(next->io_head);
555                         free_pciehp_res(next->mem_head);
556                         free_pciehp_res(next->p_mem_head);
557                         free_pciehp_res(next->bus_head);
558
559                         TempSlot = next;
560                         next = next->next;
561                         kfree(TempSlot);
562                 }
563         }
564
565         /* Stop the notification mechanism */
566         pciehp_event_stop_thread();
567
568 }
569
570 int hpdriver_context = 0;
571
572 static void pciehp_remove (struct pcie_device *device)
573 {
574         printk("%s ENTRY\n", __FUNCTION__);     
575         printk("%s -> Call free_irq for irq = %d\n",  
576                 __FUNCTION__, device->irq);
577         free_irq(device->irq, &hpdriver_context);
578 }
579
580 #ifdef CONFIG_PM
581 static int pciehp_suspend (struct pcie_device *dev, pm_message_t state)
582 {
583         printk("%s ENTRY\n", __FUNCTION__);     
584         return 0;
585 }
586
587 static int pciehp_resume (struct pcie_device *dev)
588 {
589         printk("%s ENTRY\n", __FUNCTION__);     
590         return 0;
591 }
592 #endif
593
594 static struct pcie_port_service_id port_pci_ids[] = { { 
595         .vendor = PCI_ANY_ID, 
596         .device = PCI_ANY_ID,
597         .port_type = PCIE_RC_PORT, 
598         .service_type = PCIE_PORT_SERVICE_HP,
599         .driver_data =  0, 
600         }, { /* end: all zeroes */ }
601 };
602 static const char device_name[] = "hpdriver";
603
604 static struct pcie_port_service_driver hpdriver_portdrv = {
605         .name           = (char *)device_name,
606         .id_table       = &port_pci_ids[0],
607
608         .probe          = pciehp_probe,
609         .remove         = pciehp_remove,
610
611 #ifdef  CONFIG_PM
612         .suspend        = pciehp_suspend,
613         .resume         = pciehp_resume,
614 #endif  /* PM */
615 };
616
617 static int __init pcied_init(void)
618 {
619         int retval = 0;
620
621 #ifdef CONFIG_HOTPLUG_PCI_PCIE_POLL_EVENT_MODE
622         pciehp_poll_mode = 1;
623 #endif
624
625         retval = pcie_start_thread();
626         if (retval)
627                 goto error_hpc_init;
628
629         retval = pciehprm_init(PCI);
630         if (!retval) {
631                 retval = pcie_port_service_register(&hpdriver_portdrv);
632                 dbg("pcie_port_service_register = %d\n", retval);
633                 info(DRIVER_DESC " version: " DRIVER_VERSION "\n");
634                 if (retval)
635                    dbg("%s: Failure to register service\n", __FUNCTION__);
636         }
637
638 error_hpc_init:
639         if (retval) {
640                 pciehprm_cleanup();
641                 pciehp_event_stop_thread();
642         } else
643                 pciehprm_print_pirt();
644
645         return retval;
646 }
647
648 static void __exit pcied_cleanup(void)
649 {
650         dbg("unload_pciehpd()\n");
651         unload_pciehpd();
652
653         pciehprm_cleanup();
654
655         dbg("pcie_port_service_unregister\n");
656         pcie_port_service_unregister(&hpdriver_portdrv);
657
658         info(DRIVER_DESC " version: " DRIVER_VERSION " unloaded\n");
659 }
660
661 module_init(pcied_init);
662 module_exit(pcied_cleanup);