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/pcieport_if.h>
16 #include <linux/aer.h>
17 #include <linux/dmi.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");
32 /* If this switch is set, PCIe port native services should not be enabled. */
33 bool pcie_ports_disabled
;
35 static int __init
pcie_port_setup(char *str
)
37 if (!strncmp(str
, "compat", 6))
38 pcie_ports_disabled
= true;
42 __setup("pcie_ports=", pcie_port_setup
);
46 static int pcie_portdrv_restore_config(struct pci_dev
*dev
)
50 retval
= pci_enable_device(dev
);
58 static const struct dev_pm_ops pcie_portdrv_pm_ops
= {
59 .suspend
= pcie_port_device_suspend
,
60 .resume
= pcie_port_device_resume
,
61 .freeze
= pcie_port_device_suspend
,
62 .thaw
= pcie_port_device_resume
,
63 .poweroff
= pcie_port_device_suspend
,
64 .restore
= pcie_port_device_resume
,
67 #define PCIE_PORTDRV_PM_OPS (&pcie_portdrv_pm_ops)
71 #define PCIE_PORTDRV_PM_OPS NULL
75 * pcie_portdrv_probe - Probe PCI-Express port devices
76 * @dev: PCI-Express port device being probed
78 * If detected invokes the pcie_port_device_register() method for
82 static int __devinit
pcie_portdrv_probe(struct pci_dev
*dev
,
83 const struct pci_device_id
*id
)
87 if (!pci_is_pcie(dev
) ||
88 ((dev
->pcie_type
!= PCI_EXP_TYPE_ROOT_PORT
) &&
89 (dev
->pcie_type
!= PCI_EXP_TYPE_UPSTREAM
) &&
90 (dev
->pcie_type
!= PCI_EXP_TYPE_DOWNSTREAM
)))
93 if (!dev
->irq
&& dev
->pin
) {
94 dev_warn(&dev
->dev
, "device [%04x:%04x] has invalid IRQ; "
95 "check vendor BIOS\n", dev
->vendor
, dev
->device
);
97 status
= pcie_port_device_register(dev
);
106 static void pcie_portdrv_remove(struct pci_dev
*dev
)
108 pcie_port_device_remove(dev
);
109 pci_disable_device(dev
);
112 static int error_detected_iter(struct device
*device
, void *data
)
114 struct pcie_device
*pcie_device
;
115 struct pcie_port_service_driver
*driver
;
116 struct aer_broadcast_data
*result_data
;
117 pci_ers_result_t status
;
119 result_data
= (struct aer_broadcast_data
*) data
;
121 if (device
->bus
== &pcie_port_bus_type
&& device
->driver
) {
122 driver
= to_service_driver(device
->driver
);
124 !driver
->err_handler
||
125 !driver
->err_handler
->error_detected
)
128 pcie_device
= to_pcie_device(device
);
130 /* Forward error detected message to service drivers */
131 status
= driver
->err_handler
->error_detected(
134 result_data
->result
=
135 merge_result(result_data
->result
, status
);
141 static pci_ers_result_t
pcie_portdrv_error_detected(struct pci_dev
*dev
,
142 enum pci_channel_state error
)
144 struct aer_broadcast_data data
= {error
, PCI_ERS_RESULT_CAN_RECOVER
};
148 ret
= device_for_each_child(&dev
->dev
, &data
, error_detected_iter
);
153 static int mmio_enabled_iter(struct device
*device
, void *data
)
155 struct pcie_device
*pcie_device
;
156 struct pcie_port_service_driver
*driver
;
157 pci_ers_result_t status
, *result
;
159 result
= (pci_ers_result_t
*) data
;
161 if (device
->bus
== &pcie_port_bus_type
&& device
->driver
) {
162 driver
= to_service_driver(device
->driver
);
164 driver
->err_handler
&&
165 driver
->err_handler
->mmio_enabled
) {
166 pcie_device
= to_pcie_device(device
);
168 /* Forward error message to service drivers */
169 status
= driver
->err_handler
->mmio_enabled(
171 *result
= merge_result(*result
, status
);
178 static pci_ers_result_t
pcie_portdrv_mmio_enabled(struct pci_dev
*dev
)
180 pci_ers_result_t status
= PCI_ERS_RESULT_RECOVERED
;
183 /* get true return value from &status */
184 retval
= device_for_each_child(&dev
->dev
, &status
, mmio_enabled_iter
);
188 static int slot_reset_iter(struct device
*device
, void *data
)
190 struct pcie_device
*pcie_device
;
191 struct pcie_port_service_driver
*driver
;
192 pci_ers_result_t status
, *result
;
194 result
= (pci_ers_result_t
*) data
;
196 if (device
->bus
== &pcie_port_bus_type
&& device
->driver
) {
197 driver
= to_service_driver(device
->driver
);
199 driver
->err_handler
&&
200 driver
->err_handler
->slot_reset
) {
201 pcie_device
= to_pcie_device(device
);
203 /* Forward error message to service drivers */
204 status
= driver
->err_handler
->slot_reset(
206 *result
= merge_result(*result
, status
);
213 static pci_ers_result_t
pcie_portdrv_slot_reset(struct pci_dev
*dev
)
215 pci_ers_result_t status
= PCI_ERS_RESULT_RECOVERED
;
218 /* If fatal, restore cfg space for possible link reset at upstream */
219 if (dev
->error_state
== pci_channel_io_frozen
) {
220 dev
->state_saved
= true;
221 pci_restore_state(dev
);
222 pcie_portdrv_restore_config(dev
);
223 pci_enable_pcie_error_reporting(dev
);
226 /* get true return value from &status */
227 retval
= device_for_each_child(&dev
->dev
, &status
, slot_reset_iter
);
232 static int resume_iter(struct device
*device
, void *data
)
234 struct pcie_device
*pcie_device
;
235 struct pcie_port_service_driver
*driver
;
237 if (device
->bus
== &pcie_port_bus_type
&& device
->driver
) {
238 driver
= to_service_driver(device
->driver
);
240 driver
->err_handler
&&
241 driver
->err_handler
->resume
) {
242 pcie_device
= to_pcie_device(device
);
244 /* Forward error message to service drivers */
245 driver
->err_handler
->resume(pcie_device
->port
);
252 static void pcie_portdrv_err_resume(struct pci_dev
*dev
)
255 /* nothing to do with error value, if it ever happens */
256 retval
= device_for_each_child(&dev
->dev
, NULL
, resume_iter
);
260 * LINUX Device Driver Model
262 static const struct pci_device_id port_pci_ids
[] = { {
263 /* handle any PCI-Express port */
264 PCI_DEVICE_CLASS(((PCI_CLASS_BRIDGE_PCI
<< 8) | 0x00), ~0),
265 }, { /* end: all zeroes */ }
267 MODULE_DEVICE_TABLE(pci
, port_pci_ids
);
269 static struct pci_error_handlers pcie_portdrv_err_handler
= {
270 .error_detected
= pcie_portdrv_error_detected
,
271 .mmio_enabled
= pcie_portdrv_mmio_enabled
,
272 .slot_reset
= pcie_portdrv_slot_reset
,
273 .resume
= pcie_portdrv_err_resume
,
276 static struct pci_driver pcie_portdriver
= {
278 .id_table
= &port_pci_ids
[0],
280 .probe
= pcie_portdrv_probe
,
281 .remove
= pcie_portdrv_remove
,
283 .err_handler
= &pcie_portdrv_err_handler
,
285 .driver
.pm
= PCIE_PORTDRV_PM_OPS
,
288 static int __init
dmi_pcie_pme_disable_msi(const struct dmi_system_id
*d
)
290 pr_notice("%s detected: will not use MSI for PCIe PME signaling\n",
292 pcie_pme_disable_msi();
296 static struct dmi_system_id __initdata pcie_portdrv_dmi_table
[] = {
298 * Boxes that should not use MSI for PCIe PME signaling.
301 .callback
= dmi_pcie_pme_disable_msi
,
302 .ident
= "MSI Wind U-100",
304 DMI_MATCH(DMI_SYS_VENDOR
,
305 "MICRO-STAR INTERNATIONAL CO., LTD"),
306 DMI_MATCH(DMI_PRODUCT_NAME
, "U-100"),
312 static int __init
pcie_portdrv_init(void)
316 if (pcie_ports_disabled
)
319 dmi_check_system(pcie_portdrv_dmi_table
);
321 retval
= pcie_port_bus_register();
323 printk(KERN_WARNING
"PCIE: bus_register error: %d\n", retval
);
326 retval
= pci_register_driver(&pcie_portdriver
);
328 pcie_port_bus_unregister();
333 static void __exit
pcie_portdrv_exit(void)
335 pci_unregister_driver(&pcie_portdriver
);
336 pcie_port_bus_unregister();
339 module_init(pcie_portdrv_init
);
340 module_exit(pcie_portdrv_exit
);