2 * PCI Express Hot Plug Controller Driver
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
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.
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
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.
26 * Send feedback to <greg@kroah.com>, <kristen.c.accardi@intel.com>
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>
42 #include <linux/interrupt.h>
44 /* Global variables */
48 struct controller *pciehp_ctrl_list;
49 struct pci_func *pciehp_slot_list[256];
51 #define DRIVER_VERSION "0.4"
52 #define DRIVER_AUTHOR "Dan Zink <dan.zink@compaq.com>, Greg Kroah-Hartman <greg@kroah.com>, Dely Sy <dely.l.sy@intel.com>"
53 #define DRIVER_DESC "PCI Express Hot Plug Controller Driver"
55 MODULE_AUTHOR(DRIVER_AUTHOR);
56 MODULE_DESCRIPTION(DRIVER_DESC);
57 MODULE_LICENSE("GPL");
59 module_param(pciehp_debug, bool, 0644);
60 module_param(pciehp_poll_mode, bool, 0644);
61 module_param(pciehp_poll_time, int, 0644);
62 MODULE_PARM_DESC(pciehp_debug, "Debugging mode enabled or not");
63 MODULE_PARM_DESC(pciehp_poll_mode, "Using polling mechanism for hot-plug events or not");
64 MODULE_PARM_DESC(pciehp_poll_time, "Polling mechanism frequency, in seconds");
66 #define PCIE_MODULE_NAME "pciehp"
68 static int pcie_start_thread (void);
69 static int set_attention_status (struct hotplug_slot *slot, u8 value);
70 static int enable_slot (struct hotplug_slot *slot);
71 static int disable_slot (struct hotplug_slot *slot);
72 static int get_power_status (struct hotplug_slot *slot, u8 *value);
73 static int get_attention_status (struct hotplug_slot *slot, u8 *value);
74 static int get_latch_status (struct hotplug_slot *slot, u8 *value);
75 static int get_adapter_status (struct hotplug_slot *slot, u8 *value);
76 static int get_max_bus_speed (struct hotplug_slot *slot, enum pci_bus_speed *value);
77 static int get_cur_bus_speed (struct hotplug_slot *slot, enum pci_bus_speed *value);
79 static struct hotplug_slot_ops pciehp_hotplug_slot_ops = {
81 .set_attention_status = set_attention_status,
82 .enable_slot = enable_slot,
83 .disable_slot = disable_slot,
84 .get_power_status = get_power_status,
85 .get_attention_status = get_attention_status,
86 .get_latch_status = get_latch_status,
87 .get_adapter_status = get_adapter_status,
88 .get_max_bus_speed = get_max_bus_speed,
89 .get_cur_bus_speed = get_cur_bus_speed,
93 * release_slot - free up the memory used by a slot
94 * @hotplug_slot: slot to free
96 static void release_slot(struct hotplug_slot *hotplug_slot)
98 struct slot *slot = hotplug_slot->private;
100 dbg("%s - physical_slot = %s\n", __FUNCTION__, hotplug_slot->name);
102 kfree(slot->hotplug_slot->info);
103 kfree(slot->hotplug_slot->name);
104 kfree(slot->hotplug_slot);
108 static int init_slots(struct controller *ctrl)
110 struct slot *new_slot;
114 int result = -ENOMEM;
116 dbg("%s\n",__FUNCTION__);
118 number_of_slots = ctrl->num_slots;
119 slot_device = ctrl->slot_device_offset;
120 slot_number = ctrl->first_slot;
122 while (number_of_slots) {
123 new_slot = kmalloc(sizeof(*new_slot), GFP_KERNEL);
127 memset(new_slot, 0, sizeof(struct slot));
128 new_slot->hotplug_slot =
129 kmalloc(sizeof(*(new_slot->hotplug_slot)),
131 if (!new_slot->hotplug_slot)
133 memset(new_slot->hotplug_slot, 0, sizeof(struct hotplug_slot));
135 new_slot->hotplug_slot->info =
136 kmalloc(sizeof(*(new_slot->hotplug_slot->info)),
138 if (!new_slot->hotplug_slot->info)
140 memset(new_slot->hotplug_slot->info, 0,
141 sizeof(struct hotplug_slot_info));
142 new_slot->hotplug_slot->name = kmalloc(SLOT_NAME_SIZE,
144 if (!new_slot->hotplug_slot->name)
147 new_slot->ctrl = ctrl;
148 new_slot->bus = ctrl->slot_bus;
149 new_slot->device = slot_device;
150 new_slot->hpc_ops = ctrl->hpc_ops;
152 new_slot->number = ctrl->first_slot;
153 new_slot->hp_slot = slot_device - ctrl->slot_device_offset;
155 /* register this slot with the hotplug pci core */
156 new_slot->hotplug_slot->private = new_slot;
157 new_slot->hotplug_slot->release = &release_slot;
158 make_slot_name(new_slot->hotplug_slot->name, SLOT_NAME_SIZE, new_slot);
159 new_slot->hotplug_slot->ops = &pciehp_hotplug_slot_ops;
161 new_slot->hpc_ops->get_power_status(new_slot, &(new_slot->hotplug_slot->info->power_status));
162 new_slot->hpc_ops->get_attention_status(new_slot, &(new_slot->hotplug_slot->info->attention_status));
163 new_slot->hpc_ops->get_latch_status(new_slot, &(new_slot->hotplug_slot->info->latch_status));
164 new_slot->hpc_ops->get_adapter_status(new_slot, &(new_slot->hotplug_slot->info->adapter_status));
166 dbg("Registering bus=%x dev=%x hp_slot=%x sun=%x slot_device_offset=%x\n",
167 new_slot->bus, new_slot->device, new_slot->hp_slot, new_slot->number, ctrl->slot_device_offset);
168 result = pci_hp_register (new_slot->hotplug_slot);
170 err ("pci_hp_register failed with error %d\n", result);
174 new_slot->next = ctrl->slot;
175 ctrl->slot = new_slot;
179 slot_number += ctrl->slot_num_inc;
185 kfree(new_slot->hotplug_slot->name);
187 kfree(new_slot->hotplug_slot->info);
189 kfree(new_slot->hotplug_slot);
197 static int cleanup_slots (struct controller * ctrl)
199 struct slot *old_slot, *next_slot;
201 old_slot = ctrl->slot;
205 next_slot = old_slot->next;
206 pci_hp_deregister (old_slot->hotplug_slot);
207 old_slot = next_slot;
214 static int get_ctlr_slot_config(struct controller *ctrl)
216 int num_ctlr_slots; /* Not needed; PCI Express has 1 slot per port*/
217 int first_device_num; /* Not needed */
218 int physical_slot_num;
222 rc = pcie_get_ctlr_slot_config(ctrl, &num_ctlr_slots, &first_device_num, &physical_slot_num, &ctrlcap);
224 err("%s: get_ctlr_slot_config fail for b:d (%x:%x)\n", __FUNCTION__, ctrl->bus, ctrl->device);
228 ctrl->num_slots = num_ctlr_slots; /* PCI Express has 1 slot per port */
229 ctrl->slot_device_offset = first_device_num;
230 ctrl->first_slot = physical_slot_num;
231 ctrl->ctrlcap = ctrlcap;
233 dbg("%s: bus(0x%x) num_slot(0x%x) 1st_dev(0x%x) psn(0x%x) ctrlcap(%x) for b:d (%x:%x)\n",
234 __FUNCTION__, ctrl->slot_bus, num_ctlr_slots, first_device_num, physical_slot_num, ctrlcap,
235 ctrl->bus, ctrl->device);
242 * set_attention_status - Turns the Amber LED for a slot on, off or blink
244 static int set_attention_status(struct hotplug_slot *hotplug_slot, u8 status)
246 struct slot *slot = hotplug_slot->private;
248 dbg("%s - physical_slot = %s\n", __FUNCTION__, hotplug_slot->name);
250 hotplug_slot->info->attention_status = status;
252 if (ATTN_LED(slot->ctrl->ctrlcap))
253 slot->hpc_ops->set_attention_status(slot, status);
259 static int enable_slot(struct hotplug_slot *hotplug_slot)
261 struct slot *slot = hotplug_slot->private;
263 dbg("%s - physical_slot = %s\n", __FUNCTION__, hotplug_slot->name);
265 return pciehp_enable_slot(slot);
269 static int disable_slot(struct hotplug_slot *hotplug_slot)
271 struct slot *slot = hotplug_slot->private;
273 dbg("%s - physical_slot = %s\n", __FUNCTION__, hotplug_slot->name);
275 return pciehp_disable_slot(slot);
278 static int get_power_status(struct hotplug_slot *hotplug_slot, u8 *value)
280 struct slot *slot = hotplug_slot->private;
283 dbg("%s - physical_slot = %s\n", __FUNCTION__, hotplug_slot->name);
285 retval = slot->hpc_ops->get_power_status(slot, value);
287 *value = hotplug_slot->info->power_status;
292 static int get_attention_status(struct hotplug_slot *hotplug_slot, u8 *value)
294 struct slot *slot = hotplug_slot->private;
297 dbg("%s - physical_slot = %s\n", __FUNCTION__, hotplug_slot->name);
299 retval = slot->hpc_ops->get_attention_status(slot, value);
301 *value = hotplug_slot->info->attention_status;
306 static int get_latch_status(struct hotplug_slot *hotplug_slot, u8 *value)
308 struct slot *slot = hotplug_slot->private;
311 dbg("%s - physical_slot = %s\n", __FUNCTION__, hotplug_slot->name);
313 retval = slot->hpc_ops->get_latch_status(slot, value);
315 *value = hotplug_slot->info->latch_status;
320 static int get_adapter_status(struct hotplug_slot *hotplug_slot, u8 *value)
322 struct slot *slot = hotplug_slot->private;
325 dbg("%s - physical_slot = %s\n", __FUNCTION__, hotplug_slot->name);
327 retval = slot->hpc_ops->get_adapter_status(slot, value);
329 *value = hotplug_slot->info->adapter_status;
334 static int get_max_bus_speed(struct hotplug_slot *hotplug_slot, enum pci_bus_speed *value)
336 struct slot *slot = hotplug_slot->private;
339 dbg("%s - physical_slot = %s\n", __FUNCTION__, hotplug_slot->name);
341 retval = slot->hpc_ops->get_max_bus_speed(slot, value);
343 *value = PCI_SPEED_UNKNOWN;
348 static int get_cur_bus_speed(struct hotplug_slot *hotplug_slot, enum pci_bus_speed *value)
350 struct slot *slot = hotplug_slot->private;
353 dbg("%s - physical_slot = %s\n", __FUNCTION__, hotplug_slot->name);
355 retval = slot->hpc_ops->get_cur_bus_speed(slot, value);
357 *value = PCI_SPEED_UNKNOWN;
362 static int pciehp_probe(struct pcie_device *dev, const struct pcie_port_service_id *id)
365 struct controller *ctrl;
367 int first_device_num = 0 ; /* first PCI device number supported by this PCIE */
368 int num_ctlr_slots; /* number of slots supported by this HPC */
370 struct pci_dev *pdev;
372 dbg("%s: Called by hp_drv\n", __FUNCTION__);
373 ctrl = kmalloc(sizeof(*ctrl), GFP_KERNEL);
375 err("%s : out of memory\n", __FUNCTION__);
378 memset(ctrl, 0, sizeof(struct controller));
380 dbg("%s: DRV_thread pid = %d\n", __FUNCTION__, current->pid);
383 ctrl->pci_dev = pdev;
385 rc = pcie_init(ctrl, dev,
386 (php_intr_callback_t) pciehp_handle_attention_button,
387 (php_intr_callback_t) pciehp_handle_switch_change,
388 (php_intr_callback_t) pciehp_handle_presence_change,
389 (php_intr_callback_t) pciehp_handle_power_fault);
391 dbg("%s: controller initialization failed\n", PCIE_MODULE_NAME);
392 goto err_out_free_ctrl;
395 pci_set_drvdata(pdev, ctrl);
397 ctrl->pci_bus = kmalloc(sizeof(*ctrl->pci_bus), GFP_KERNEL);
398 if (!ctrl->pci_bus) {
399 err("%s: out of memory\n", __FUNCTION__);
401 goto err_out_unmap_mmio_region;
403 dbg("%s: ctrl->pci_bus %p\n", __FUNCTION__, ctrl->pci_bus);
404 memcpy (ctrl->pci_bus, pdev->bus, sizeof (*ctrl->pci_bus));
405 ctrl->bus = pdev->bus->number; /* ctrl bus */
406 ctrl->slot_bus = pdev->subordinate->number; /* bus controlled by this HPC */
408 ctrl->device = PCI_SLOT(pdev->devfn);
409 ctrl->function = PCI_FUNC(pdev->devfn);
410 dbg("%s: ctrl bus=0x%x, device=%x, function=%x, irq=%x\n", __FUNCTION__,
411 ctrl->bus, ctrl->device, ctrl->function, pdev->irq);
414 * Save configuration headers for this and subordinate PCI buses
417 rc = get_ctlr_slot_config(ctrl);
419 err(msg_initialization_err, rc);
420 goto err_out_free_ctrl_bus;
422 first_device_num = ctrl->slot_device_offset;
423 num_ctlr_slots = ctrl->num_slots;
425 /* Store PCI Config Space for all devices on this bus */
426 dbg("%s: Before calling pciehp_save_config, ctrl->bus %x,ctrl->slot_bus %x\n",
427 __FUNCTION__,ctrl->bus, ctrl->slot_bus);
428 rc = pciehp_save_config(ctrl, ctrl->slot_bus, num_ctlr_slots, first_device_num);
430 err("%s: unable to save PCI configuration data, error %d\n", __FUNCTION__, rc);
431 goto err_out_free_ctrl_bus;
434 ctrl->add_support = 1;
436 /* Setup the slot information structures */
437 rc = init_slots(ctrl);
439 err(msg_initialization_err, 6);
440 goto err_out_free_ctrl_slot;
443 t_slot = pciehp_find_slot(ctrl, first_device_num);
444 dbg("%s: t_slot %p\n", __FUNCTION__, t_slot);
446 /* Finish setting up the hot plug ctrl device */
447 ctrl->next_event = 0;
449 if (!pciehp_ctrl_list) {
450 pciehp_ctrl_list = ctrl;
453 ctrl->next = pciehp_ctrl_list;
454 pciehp_ctrl_list = ctrl;
457 /* Wait for exclusive access to hardware */
458 down(&ctrl->crit_sect);
460 t_slot->hpc_ops->get_adapter_status(t_slot, &value); /* Check if slot is occupied */
461 dbg("%s: adpater value %x\n", __FUNCTION__, value);
463 if ((POWER_CTRL(ctrl->ctrlcap)) && !value) {
464 rc = t_slot->hpc_ops->power_off_slot(t_slot); /* Power off slot if not occupied*/
466 /* Done with exclusive hardware access */
467 up(&ctrl->crit_sect);
468 goto err_out_free_ctrl_slot;
470 /* Wait for the command to complete */
471 wait_for_ctrl_irq (ctrl);
474 /* Done with exclusive hardware access */
475 up(&ctrl->crit_sect);
479 err_out_free_ctrl_slot:
481 err_out_free_ctrl_bus:
482 kfree(ctrl->pci_bus);
483 err_out_unmap_mmio_region:
484 ctrl->hpc_ops->release_ctlr(ctrl);
492 static int pcie_start_thread(void)
497 dbg("Initialize + Start the notification/polling mechanism \n");
499 retval = pciehp_event_start_thread();
501 dbg("pciehp_event_start_thread() failed\n");
505 dbg("Initialize slot lists\n");
506 /* One slot list for each bus in the system */
507 for (loop = 0; loop < 256; loop++) {
508 pciehp_slot_list[loop] = NULL;
514 static void __exit unload_pciehpd(void)
516 struct pci_func *next;
517 struct pci_func *TempSlot;
519 struct controller *ctrl;
520 struct controller *tctrl;
522 ctrl = pciehp_ctrl_list;
527 kfree (ctrl->pci_bus);
529 ctrl->hpc_ops->release_ctlr(ctrl);
537 for (loop = 0; loop < 256; loop++) {
538 next = pciehp_slot_list[loop];
539 while (next != NULL) {
546 /* Stop the notification mechanism */
547 pciehp_event_stop_thread();
551 int hpdriver_context = 0;
553 static void pciehp_remove (struct pcie_device *device)
555 printk("%s ENTRY\n", __FUNCTION__);
556 printk("%s -> Call free_irq for irq = %d\n",
557 __FUNCTION__, device->irq);
558 free_irq(device->irq, &hpdriver_context);
562 static int pciehp_suspend (struct pcie_device *dev, pm_message_t state)
564 printk("%s ENTRY\n", __FUNCTION__);
568 static int pciehp_resume (struct pcie_device *dev)
570 printk("%s ENTRY\n", __FUNCTION__);
575 static struct pcie_port_service_id port_pci_ids[] = { {
576 .vendor = PCI_ANY_ID,
577 .device = PCI_ANY_ID,
578 .port_type = PCIE_ANY_PORT,
579 .service_type = PCIE_PORT_SERVICE_HP,
581 }, { /* end: all zeroes */ }
583 static const char device_name[] = "hpdriver";
585 static struct pcie_port_service_driver hpdriver_portdrv = {
586 .name = (char *)device_name,
587 .id_table = &port_pci_ids[0],
589 .probe = pciehp_probe,
590 .remove = pciehp_remove,
593 .suspend = pciehp_suspend,
594 .resume = pciehp_resume,
598 static int __init pcied_init(void)
602 #ifdef CONFIG_HOTPLUG_PCI_PCIE_POLL_EVENT_MODE
603 pciehp_poll_mode = 1;
606 retval = pcie_start_thread();
610 retval = pcie_port_service_register(&hpdriver_portdrv);
611 dbg("pcie_port_service_register = %d\n", retval);
612 info(DRIVER_DESC " version: " DRIVER_VERSION "\n");
614 dbg("%s: Failure to register service\n", __FUNCTION__);
618 pciehp_event_stop_thread();
624 static void __exit pcied_cleanup(void)
626 dbg("unload_pciehpd()\n");
629 dbg("pcie_port_service_unregister\n");
630 pcie_port_service_unregister(&hpdriver_portdrv);
632 info(DRIVER_DESC " version: " DRIVER_VERSION " unloaded\n");
635 module_init(pcied_init);
636 module_exit(pcied_cleanup);