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);