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>
18 #include <linux/pci-aspm.h>
21 #include "aer/aerdrv.h"
26 #define DRIVER_VERSION "v1.0"
27 #define DRIVER_AUTHOR "tom.l.nguyen@intel.com"
28 #define DRIVER_DESC "PCIe Port Bus Driver"
29 MODULE_AUTHOR(DRIVER_AUTHOR
);
30 MODULE_DESCRIPTION(DRIVER_DESC
);
31 MODULE_LICENSE("GPL");
33 /* If this switch is set, PCIe port native services should not be enabled. */
34 bool pcie_ports_disabled
;
37 * If this switch is set, ACPI _OSC will be used to determine whether or not to
38 * enable PCIe port native services.
40 bool pcie_ports_auto
= true;
42 static int __init
pcie_port_setup(char *str
)
44 if (!strncmp(str
, "compat", 6)) {
45 pcie_ports_disabled
= true;
46 } else if (!strncmp(str
, "native", 6)) {
47 pcie_ports_disabled
= false;
48 pcie_ports_auto
= false;
49 } else if (!strncmp(str
, "auto", 4)) {
50 pcie_ports_disabled
= false;
51 pcie_ports_auto
= true;
56 __setup("pcie_ports=", pcie_port_setup
);
60 static int pcie_portdrv_restore_config(struct pci_dev
*dev
)
64 retval
= pci_enable_device(dev
);
72 static const struct dev_pm_ops pcie_portdrv_pm_ops
= {
73 .suspend
= pcie_port_device_suspend
,
74 .resume
= pcie_port_device_resume
,
75 .freeze
= pcie_port_device_suspend
,
76 .thaw
= pcie_port_device_resume
,
77 .poweroff
= pcie_port_device_suspend
,
78 .restore
= pcie_port_device_resume
,
81 #define PCIE_PORTDRV_PM_OPS (&pcie_portdrv_pm_ops)
85 #define PCIE_PORTDRV_PM_OPS NULL
89 * pcie_portdrv_probe - Probe PCI-Express port devices
90 * @dev: PCI-Express port device being probed
92 * If detected invokes the pcie_port_device_register() method for
96 static int __devinit
pcie_portdrv_probe(struct pci_dev
*dev
,
97 const struct pci_device_id
*id
)
101 if (!pci_is_pcie(dev
) ||
102 ((dev
->pcie_type
!= PCI_EXP_TYPE_ROOT_PORT
) &&
103 (dev
->pcie_type
!= PCI_EXP_TYPE_UPSTREAM
) &&
104 (dev
->pcie_type
!= PCI_EXP_TYPE_DOWNSTREAM
)))
107 if (!dev
->irq
&& dev
->pin
) {
108 dev_warn(&dev
->dev
, "device [%04x:%04x] has invalid IRQ; "
109 "check vendor BIOS\n", dev
->vendor
, dev
->device
);
111 status
= pcie_port_device_register(dev
);
120 static void pcie_portdrv_remove(struct pci_dev
*dev
)
122 pcie_port_device_remove(dev
);
123 pci_disable_device(dev
);
126 static int error_detected_iter(struct device
*device
, void *data
)
128 struct pcie_device
*pcie_device
;
129 struct pcie_port_service_driver
*driver
;
130 struct aer_broadcast_data
*result_data
;
131 pci_ers_result_t status
;
133 result_data
= (struct aer_broadcast_data
*) data
;
135 if (device
->bus
== &pcie_port_bus_type
&& device
->driver
) {
136 driver
= to_service_driver(device
->driver
);
138 !driver
->err_handler
||
139 !driver
->err_handler
->error_detected
)
142 pcie_device
= to_pcie_device(device
);
144 /* Forward error detected message to service drivers */
145 status
= driver
->err_handler
->error_detected(
148 result_data
->result
=
149 merge_result(result_data
->result
, status
);
155 static pci_ers_result_t
pcie_portdrv_error_detected(struct pci_dev
*dev
,
156 enum pci_channel_state error
)
158 struct aer_broadcast_data data
= {error
, PCI_ERS_RESULT_CAN_RECOVER
};
162 ret
= device_for_each_child(&dev
->dev
, &data
, error_detected_iter
);
167 static int mmio_enabled_iter(struct device
*device
, void *data
)
169 struct pcie_device
*pcie_device
;
170 struct pcie_port_service_driver
*driver
;
171 pci_ers_result_t status
, *result
;
173 result
= (pci_ers_result_t
*) data
;
175 if (device
->bus
== &pcie_port_bus_type
&& device
->driver
) {
176 driver
= to_service_driver(device
->driver
);
178 driver
->err_handler
&&
179 driver
->err_handler
->mmio_enabled
) {
180 pcie_device
= to_pcie_device(device
);
182 /* Forward error message to service drivers */
183 status
= driver
->err_handler
->mmio_enabled(
185 *result
= merge_result(*result
, status
);
192 static pci_ers_result_t
pcie_portdrv_mmio_enabled(struct pci_dev
*dev
)
194 pci_ers_result_t status
= PCI_ERS_RESULT_RECOVERED
;
197 /* get true return value from &status */
198 retval
= device_for_each_child(&dev
->dev
, &status
, mmio_enabled_iter
);
202 static int slot_reset_iter(struct device
*device
, void *data
)
204 struct pcie_device
*pcie_device
;
205 struct pcie_port_service_driver
*driver
;
206 pci_ers_result_t status
, *result
;
208 result
= (pci_ers_result_t
*) data
;
210 if (device
->bus
== &pcie_port_bus_type
&& device
->driver
) {
211 driver
= to_service_driver(device
->driver
);
213 driver
->err_handler
&&
214 driver
->err_handler
->slot_reset
) {
215 pcie_device
= to_pcie_device(device
);
217 /* Forward error message to service drivers */
218 status
= driver
->err_handler
->slot_reset(
220 *result
= merge_result(*result
, status
);
227 static pci_ers_result_t
pcie_portdrv_slot_reset(struct pci_dev
*dev
)
229 pci_ers_result_t status
= PCI_ERS_RESULT_RECOVERED
;
232 /* If fatal, restore cfg space for possible link reset at upstream */
233 if (dev
->error_state
== pci_channel_io_frozen
) {
234 dev
->state_saved
= true;
235 pci_restore_state(dev
);
236 pcie_portdrv_restore_config(dev
);
237 pci_enable_pcie_error_reporting(dev
);
240 /* get true return value from &status */
241 retval
= device_for_each_child(&dev
->dev
, &status
, slot_reset_iter
);
246 static int resume_iter(struct device
*device
, void *data
)
248 struct pcie_device
*pcie_device
;
249 struct pcie_port_service_driver
*driver
;
251 if (device
->bus
== &pcie_port_bus_type
&& device
->driver
) {
252 driver
= to_service_driver(device
->driver
);
254 driver
->err_handler
&&
255 driver
->err_handler
->resume
) {
256 pcie_device
= to_pcie_device(device
);
258 /* Forward error message to service drivers */
259 driver
->err_handler
->resume(pcie_device
->port
);
266 static void pcie_portdrv_err_resume(struct pci_dev
*dev
)
269 /* nothing to do with error value, if it ever happens */
270 retval
= device_for_each_child(&dev
->dev
, NULL
, resume_iter
);
274 * LINUX Device Driver Model
276 static const struct pci_device_id port_pci_ids
[] = { {
277 /* handle any PCI-Express port */
278 PCI_DEVICE_CLASS(((PCI_CLASS_BRIDGE_PCI
<< 8) | 0x00), ~0),
279 }, { /* end: all zeroes */ }
281 MODULE_DEVICE_TABLE(pci
, port_pci_ids
);
283 static struct pci_error_handlers pcie_portdrv_err_handler
= {
284 .error_detected
= pcie_portdrv_error_detected
,
285 .mmio_enabled
= pcie_portdrv_mmio_enabled
,
286 .slot_reset
= pcie_portdrv_slot_reset
,
287 .resume
= pcie_portdrv_err_resume
,
290 static struct pci_driver pcie_portdriver
= {
292 .id_table
= &port_pci_ids
[0],
294 .probe
= pcie_portdrv_probe
,
295 .remove
= pcie_portdrv_remove
,
297 .err_handler
= &pcie_portdrv_err_handler
,
299 .driver
.pm
= PCIE_PORTDRV_PM_OPS
,
302 static int __init
dmi_pcie_pme_disable_msi(const struct dmi_system_id
*d
)
304 pr_notice("%s detected: will not use MSI for PCIe PME signaling\n",
306 pcie_pme_disable_msi();
310 static struct dmi_system_id __initdata pcie_portdrv_dmi_table
[] = {
312 * Boxes that should not use MSI for PCIe PME signaling.
315 .callback
= dmi_pcie_pme_disable_msi
,
316 .ident
= "MSI Wind U-100",
318 DMI_MATCH(DMI_SYS_VENDOR
,
319 "MICRO-STAR INTERNATIONAL CO., LTD"),
320 DMI_MATCH(DMI_PRODUCT_NAME
, "U-100"),
326 static int __init
pcie_portdrv_init(void)
330 if (pcie_ports_disabled
) {
335 dmi_check_system(pcie_portdrv_dmi_table
);
337 retval
= pcie_port_bus_register();
339 printk(KERN_WARNING
"PCIE: bus_register error: %d\n", retval
);
342 retval
= pci_register_driver(&pcie_portdriver
);
344 pcie_port_bus_unregister();
349 module_init(pcie_portdrv_init
);