3 * Purpose: PCI Express Port Bus Driver
5 * Copyright (C) 2004 Intel
6 * Copyright (C) Tom Long Nguyen (tom.l.nguyen@intel.com)
9 #include <linux/module.h>
10 #include <linux/pci.h>
11 #include <linux/kernel.h>
12 #include <linux/errno.h>
14 #include <linux/init.h>
15 #include <linux/slab.h>
16 #include <linux/pcieport_if.h>
17 #include <linux/aer.h>
20 #include "aer/aerdrv.h"
25 #define DRIVER_VERSION "v1.0"
26 #define DRIVER_AUTHOR "tom.l.nguyen@intel.com"
27 #define DRIVER_DESC "PCIE Port Bus Driver"
28 MODULE_AUTHOR(DRIVER_AUTHOR
);
29 MODULE_DESCRIPTION(DRIVER_DESC
);
30 MODULE_LICENSE("GPL");
33 static const char device_name
[] = "pcieport-driver";
35 static int pcie_portdrv_save_config(struct pci_dev
*dev
)
37 return pci_save_state(dev
);
41 static int pcie_portdrv_restore_config(struct pci_dev
*dev
)
45 pci_restore_state(dev
);
46 retval
= pci_enable_device(dev
);
53 static int pcie_portdrv_suspend(struct pci_dev
*dev
, pm_message_t state
)
55 int ret
= pcie_port_device_suspend(dev
, state
);
58 ret
= pcie_portdrv_save_config(dev
);
62 static int pcie_portdrv_resume(struct pci_dev
*dev
)
64 pcie_portdrv_restore_config(dev
);
65 return pcie_port_device_resume(dev
);
68 #define pcie_portdrv_suspend NULL
69 #define pcie_portdrv_resume NULL
73 * pcie_portdrv_probe - Probe PCI-Express port devices
74 * @dev: PCI-Express port device being probed
76 * If detected invokes the pcie_port_device_register() method for
80 static int __devinit
pcie_portdrv_probe (struct pci_dev
*dev
,
81 const struct pci_device_id
*id
)
85 status
= pcie_port_device_probe(dev
);
89 if (pci_enable_device(dev
) < 0)
95 "%s->Dev[%04x:%04x] has invalid IRQ. Check vendor BIOS\n",
96 __FUNCTION__
, dev
->device
, dev
->vendor
);
98 if (pcie_port_device_register(dev
)) {
99 pci_disable_device(dev
);
103 pcie_portdrv_save_config(dev
);
105 pci_enable_pcie_error_reporting(dev
);
110 static void pcie_portdrv_remove (struct pci_dev
*dev
)
112 pcie_port_device_remove(dev
);
113 kfree(pci_get_drvdata(dev
));
116 static int error_detected_iter(struct device
*device
, void *data
)
118 struct pcie_device
*pcie_device
;
119 struct pcie_port_service_driver
*driver
;
120 struct aer_broadcast_data
*result_data
;
121 pci_ers_result_t status
;
123 result_data
= (struct aer_broadcast_data
*) data
;
125 if (device
->bus
== &pcie_port_bus_type
&& device
->driver
) {
126 driver
= to_service_driver(device
->driver
);
128 !driver
->err_handler
||
129 !driver
->err_handler
->error_detected
)
132 pcie_device
= to_pcie_device(device
);
134 /* Forward error detected message to service drivers */
135 status
= driver
->err_handler
->error_detected(
138 result_data
->result
=
139 merge_result(result_data
->result
, status
);
145 static pci_ers_result_t
pcie_portdrv_error_detected(struct pci_dev
*dev
,
146 enum pci_channel_state error
)
148 struct aer_broadcast_data result_data
=
149 {error
, PCI_ERS_RESULT_CAN_RECOVER
};
151 device_for_each_child(&dev
->dev
, &result_data
, error_detected_iter
);
153 return result_data
.result
;
156 static int mmio_enabled_iter(struct device
*device
, void *data
)
158 struct pcie_device
*pcie_device
;
159 struct pcie_port_service_driver
*driver
;
160 pci_ers_result_t status
, *result
;
162 result
= (pci_ers_result_t
*) data
;
164 if (device
->bus
== &pcie_port_bus_type
&& device
->driver
) {
165 driver
= to_service_driver(device
->driver
);
167 driver
->err_handler
&&
168 driver
->err_handler
->mmio_enabled
) {
169 pcie_device
= to_pcie_device(device
);
171 /* Forward error message to service drivers */
172 status
= driver
->err_handler
->mmio_enabled(
174 *result
= merge_result(*result
, status
);
181 static pci_ers_result_t
pcie_portdrv_mmio_enabled(struct pci_dev
*dev
)
183 pci_ers_result_t status
= PCI_ERS_RESULT_RECOVERED
;
185 device_for_each_child(&dev
->dev
, &status
, mmio_enabled_iter
);
189 static int slot_reset_iter(struct device
*device
, void *data
)
191 struct pcie_device
*pcie_device
;
192 struct pcie_port_service_driver
*driver
;
193 pci_ers_result_t status
, *result
;
195 result
= (pci_ers_result_t
*) data
;
197 if (device
->bus
== &pcie_port_bus_type
&& device
->driver
) {
198 driver
= to_service_driver(device
->driver
);
200 driver
->err_handler
&&
201 driver
->err_handler
->slot_reset
) {
202 pcie_device
= to_pcie_device(device
);
204 /* Forward error message to service drivers */
205 status
= driver
->err_handler
->slot_reset(
207 *result
= merge_result(*result
, status
);
214 static pci_ers_result_t
pcie_portdrv_slot_reset(struct pci_dev
*dev
)
216 pci_ers_result_t status
;
218 /* If fatal, restore cfg space for possible link reset at upstream */
219 if (dev
->error_state
== pci_channel_io_frozen
) {
220 pcie_portdrv_restore_config(dev
);
221 pci_enable_pcie_error_reporting(dev
);
224 device_for_each_child(&dev
->dev
, &status
, slot_reset_iter
);
229 static int resume_iter(struct device
*device
, void *data
)
231 struct pcie_device
*pcie_device
;
232 struct pcie_port_service_driver
*driver
;
234 if (device
->bus
== &pcie_port_bus_type
&& device
->driver
) {
235 driver
= to_service_driver(device
->driver
);
237 driver
->err_handler
&&
238 driver
->err_handler
->resume
) {
239 pcie_device
= to_pcie_device(device
);
241 /* Forward error message to service drivers */
242 driver
->err_handler
->resume(pcie_device
->port
);
249 static void pcie_portdrv_err_resume(struct pci_dev
*dev
)
251 device_for_each_child(&dev
->dev
, NULL
, resume_iter
);
255 * LINUX Device Driver Model
257 static const struct pci_device_id port_pci_ids
[] = { {
258 /* handle any PCI-Express port */
259 PCI_DEVICE_CLASS(((PCI_CLASS_BRIDGE_PCI
<< 8) | 0x00), ~0),
260 }, { /* end: all zeroes */ }
262 MODULE_DEVICE_TABLE(pci
, port_pci_ids
);
264 static struct pci_error_handlers pcie_portdrv_err_handler
= {
265 .error_detected
= pcie_portdrv_error_detected
,
266 .mmio_enabled
= pcie_portdrv_mmio_enabled
,
267 .slot_reset
= pcie_portdrv_slot_reset
,
268 .resume
= pcie_portdrv_err_resume
,
271 static struct pci_driver pcie_portdrv
= {
272 .name
= (char *)device_name
,
273 .id_table
= &port_pci_ids
[0],
275 .probe
= pcie_portdrv_probe
,
276 .remove
= pcie_portdrv_remove
,
278 .suspend
= pcie_portdrv_suspend
,
279 .resume
= pcie_portdrv_resume
,
281 .err_handler
= &pcie_portdrv_err_handler
,
284 static int __init
pcie_portdrv_init(void)
288 retval
= pcie_port_bus_register();
290 printk(KERN_WARNING
"PCIE: bus_register error: %d\n", retval
);
293 retval
= pci_register_driver(&pcie_portdrv
);
295 pcie_port_bus_unregister();
300 static void __exit
pcie_portdrv_exit(void)
302 pci_unregister_driver(&pcie_portdrv
);
303 pcie_port_bus_unregister();
306 module_init(pcie_portdrv_init
);
307 module_exit(pcie_portdrv_exit
);