blob: 70d7ad8c6d17d95ba07ae6cbc7458b3b3efacac0 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
2 * File: portdrv_pci.c
3 * Purpose: PCI Express Port Bus Driver
4 *
5 * Copyright (C) 2004 Intel
6 * Copyright (C) Tom Long Nguyen (tom.l.nguyen@intel.com)
7 */
8
9#include <linux/module.h>
10#include <linux/pci.h>
11#include <linux/kernel.h>
12#include <linux/errno.h>
13#include <linux/pm.h>
Zheng Yan71a83bd2012-06-23 10:23:49 +080014#include <linux/pm_runtime.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070015#include <linux/init.h>
16#include <linux/pcieport_if.h>
Zhang, Yanmin4bf33922006-07-31 15:26:16 +080017#include <linux/aer.h>
Rafael J. Wysockic39fae12010-02-17 23:40:07 +010018#include <linux/dmi.h>
Rafael J. Wysocki28eb5f22010-08-21 22:02:38 +020019#include <linux/pci-aspm.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070020
21#include "portdrv.h"
Zhang, Yanmin4bf33922006-07-31 15:26:16 +080022#include "aer/aerdrv.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070023
24/*
25 * Version Information
26 */
27#define DRIVER_VERSION "v1.0"
28#define DRIVER_AUTHOR "tom.l.nguyen@intel.com"
Stefan Assmann7e8af372009-12-03 18:00:10 +010029#define DRIVER_DESC "PCIe Port Bus Driver"
Linus Torvalds1da177e2005-04-16 15:20:36 -070030MODULE_AUTHOR(DRIVER_AUTHOR);
31MODULE_DESCRIPTION(DRIVER_DESC);
32MODULE_LICENSE("GPL");
33
Rafael J. Wysocki79dd9182010-08-21 01:51:44 +020034/* If this switch is set, PCIe port native services should not be enabled. */
35bool pcie_ports_disabled;
36
Rafael J. Wysocki28eb5f22010-08-21 22:02:38 +020037/*
38 * If this switch is set, ACPI _OSC will be used to determine whether or not to
39 * enable PCIe port native services.
40 */
41bool pcie_ports_auto = true;
42
Rafael J. Wysocki79dd9182010-08-21 01:51:44 +020043static int __init pcie_port_setup(char *str)
44{
Rafael J. Wysocki28eb5f22010-08-21 22:02:38 +020045 if (!strncmp(str, "compat", 6)) {
Rafael J. Wysocki79dd9182010-08-21 01:51:44 +020046 pcie_ports_disabled = true;
Rafael J. Wysocki28eb5f22010-08-21 22:02:38 +020047 } else if (!strncmp(str, "native", 6)) {
48 pcie_ports_disabled = false;
49 pcie_ports_auto = false;
50 } else if (!strncmp(str, "auto", 4)) {
51 pcie_ports_disabled = false;
52 pcie_ports_auto = true;
53 }
Rafael J. Wysocki79dd9182010-08-21 01:51:44 +020054
55 return 1;
56}
57__setup("pcie_ports=", pcie_port_setup);
58
Linus Torvalds1da177e2005-04-16 15:20:36 -070059/* global data */
Linus Torvalds1da177e2005-04-16 15:20:36 -070060
Rafael J. Wysockife31e692010-12-19 15:57:16 +010061/**
62 * pcie_clear_root_pme_status - Clear root port PME interrupt status.
63 * @dev: PCIe root port or event collector.
64 */
65void pcie_clear_root_pme_status(struct pci_dev *dev)
66{
Jiang Liu2dcfaf82012-07-24 17:20:08 +080067 pcie_capability_set_dword(dev, PCI_EXP_RTSTA, PCI_EXP_RTSTA_PME);
Rafael J. Wysockife31e692010-12-19 15:57:16 +010068}
69
Zhang, Yanmin4bf33922006-07-31 15:26:16 +080070static int pcie_portdrv_restore_config(struct pci_dev *dev)
71{
72 int retval;
73
Zhang, Yanmin4bf33922006-07-31 15:26:16 +080074 retval = pci_enable_device(dev);
75 if (retval)
76 return retval;
77 pci_set_master(dev);
78 return 0;
79}
80
Zhang, Yanmin0bed2082006-09-28 14:35:59 +080081#ifdef CONFIG_PM
Rafael J. Wysockife31e692010-12-19 15:57:16 +010082static int pcie_port_resume_noirq(struct device *dev)
83{
84 struct pci_dev *pdev = to_pci_dev(dev);
85
86 /*
87 * Some BIOSes forget to clear Root PME Status bits after system wakeup
88 * which breaks ACPI-based runtime wakeup on PCI Express, so clear those
89 * bits now just in case (shouldn't hurt).
90 */
Yijing Wang62f87c02012-07-24 17:20:03 +080091 if (pci_pcie_type(pdev) == PCI_EXP_TYPE_ROOT_PORT)
Rafael J. Wysockife31e692010-12-19 15:57:16 +010092 pcie_clear_root_pme_status(pdev);
93 return 0;
94}
95
Mika Westerberg006d44e2016-06-02 11:17:15 +030096static int pcie_port_runtime_suspend(struct device *dev)
97{
98 return to_pci_dev(dev)->bridge_d3 ? 0 : -EBUSY;
99}
100
101static int pcie_port_runtime_resume(struct device *dev)
102{
103 return 0;
104}
105
106static int pcie_port_runtime_idle(struct device *dev)
107{
108 /*
109 * Assume the PCI core has set bridge_d3 whenever it thinks the port
110 * should be good to go to D3. Everything else, including moving
111 * the port to D3, is handled by the PCI core.
112 */
113 return to_pci_dev(dev)->bridge_d3 ? 0 : -EBUSY;
114}
115
Alexey Dobriyan47145212009-12-14 18:00:08 -0800116static const struct dev_pm_ops pcie_portdrv_pm_ops = {
Rafael J. Wysocki3a3c2442009-02-15 22:32:48 +0100117 .suspend = pcie_port_device_suspend,
118 .resume = pcie_port_device_resume,
119 .freeze = pcie_port_device_suspend,
120 .thaw = pcie_port_device_resume,
121 .poweroff = pcie_port_device_suspend,
122 .restore = pcie_port_device_resume,
Rafael J. Wysockife31e692010-12-19 15:57:16 +0100123 .resume_noirq = pcie_port_resume_noirq,
Mika Westerberg006d44e2016-06-02 11:17:15 +0300124 .runtime_suspend = pcie_port_runtime_suspend,
125 .runtime_resume = pcie_port_runtime_resume,
126 .runtime_idle = pcie_port_runtime_idle,
Rafael J. Wysocki3a3c2442009-02-15 22:32:48 +0100127};
Rafael J. Wysockia79d6822008-12-27 16:28:58 +0100128
Rafael J. Wysocki3a3c2442009-02-15 22:32:48 +0100129#define PCIE_PORTDRV_PM_OPS (&pcie_portdrv_pm_ops)
Rafael J. Wysockia79d6822008-12-27 16:28:58 +0100130
Rafael J. Wysocki3a3c2442009-02-15 22:32:48 +0100131#else /* !PM */
132
133#define PCIE_PORTDRV_PM_OPS NULL
134#endif /* !PM */
Zhang, Yanmin4bf33922006-07-31 15:26:16 +0800135
Linus Torvalds1da177e2005-04-16 15:20:36 -0700136/*
137 * pcie_portdrv_probe - Probe PCI-Express port devices
138 * @dev: PCI-Express port device being probed
139 *
Hidetoshi Seto40da4182009-12-15 11:38:04 +0900140 * If detected invokes the pcie_port_device_register() method for
Linus Torvalds1da177e2005-04-16 15:20:36 -0700141 * this port device.
142 *
143 */
Bill Pemberton15856ad2012-11-21 15:35:00 -0500144static int pcie_portdrv_probe(struct pci_dev *dev,
Kenji Kaneshige898294c2009-11-25 21:00:53 +0900145 const struct pci_device_id *id)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700146{
Kenji Kaneshige898294c2009-11-25 21:00:53 +0900147 int status;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700148
Kenji Kaneshige898294c2009-11-25 21:00:53 +0900149 if (!pci_is_pcie(dev) ||
Yijing Wang62f87c02012-07-24 17:20:03 +0800150 ((pci_pcie_type(dev) != PCI_EXP_TYPE_ROOT_PORT) &&
151 (pci_pcie_type(dev) != PCI_EXP_TYPE_UPSTREAM) &&
152 (pci_pcie_type(dev) != PCI_EXP_TYPE_DOWNSTREAM)))
Kenji Kaneshige898294c2009-11-25 21:00:53 +0900153 return -ENODEV;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700154
Rafael J. Wysockif118c0c2009-01-13 14:42:01 +0100155 status = pcie_port_device_register(dev);
156 if (status)
157 return status;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700158
Rafael J. Wysocki87d2e2e2009-01-13 14:43:07 +0100159 pci_save_state(dev);
Mika Westerberg006d44e2016-06-02 11:17:15 +0300160
161 /*
162 * Prevent runtime PM if the port is advertising support for PCIe
163 * hotplug. Otherwise the BIOS hotplug SMI code might not be able
164 * to enumerate devices behind this port properly (the port is
165 * powered down preventing all config space accesses to the
166 * subordinate devices). We can't be sure for native PCIe hotplug
167 * either so prevent that as well.
168 */
169 if (!dev->is_hotplug_bridge) {
170 /*
171 * Keep the port resumed 100ms to make sure things like
172 * config space accesses from userspace (lspci) will not
173 * cause the port to repeatedly suspend and resume.
174 */
175 pm_runtime_set_autosuspend_delay(&dev->dev, 100);
176 pm_runtime_use_autosuspend(&dev->dev);
177 pm_runtime_mark_last_busy(&dev->dev);
178 pm_runtime_put_autosuspend(&dev->dev);
179 pm_runtime_allow(&dev->dev);
180 }
181
Linus Torvalds1da177e2005-04-16 15:20:36 -0700182 return 0;
183}
184
Hidetoshi Seto40da4182009-12-15 11:38:04 +0900185static void pcie_portdrv_remove(struct pci_dev *dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700186{
Mika Westerberg006d44e2016-06-02 11:17:15 +0300187 if (!dev->is_hotplug_bridge) {
188 pm_runtime_forbid(&dev->dev);
189 pm_runtime_get_noresume(&dev->dev);
190 pm_runtime_dont_use_autosuspend(&dev->dev);
191 }
192
Linus Torvalds1da177e2005-04-16 15:20:36 -0700193 pcie_port_device_remove(dev);
194}
195
Zhang, Yanmin4bf33922006-07-31 15:26:16 +0800196static int error_detected_iter(struct device *device, void *data)
Henrik Kretzschmar60854832006-07-06 18:05:51 +0400197{
Zhang, Yanmin4bf33922006-07-31 15:26:16 +0800198 struct pcie_device *pcie_device;
199 struct pcie_port_service_driver *driver;
200 struct aer_broadcast_data *result_data;
201 pci_ers_result_t status;
Henrik Kretzschmar60854832006-07-06 18:05:51 +0400202
Zhang, Yanmin4bf33922006-07-31 15:26:16 +0800203 result_data = (struct aer_broadcast_data *) data;
Henrik Kretzschmar60854832006-07-06 18:05:51 +0400204
Zhang, Yanmin4bf33922006-07-31 15:26:16 +0800205 if (device->bus == &pcie_port_bus_type && device->driver) {
206 driver = to_service_driver(device->driver);
207 if (!driver ||
208 !driver->err_handler ||
209 !driver->err_handler->error_detected)
210 return 0;
211
212 pcie_device = to_pcie_device(device);
213
214 /* Forward error detected message to service drivers */
215 status = driver->err_handler->error_detected(
216 pcie_device->port,
217 result_data->state);
218 result_data->result =
219 merge_result(result_data->result, status);
220 }
221
Henrik Kretzschmar60854832006-07-06 18:05:51 +0400222 return 0;
223}
224
Zhang, Yanmin4bf33922006-07-31 15:26:16 +0800225static pci_ers_result_t pcie_portdrv_error_detected(struct pci_dev *dev,
226 enum pci_channel_state error)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700227{
Hidetoshi Seto40da4182009-12-15 11:38:04 +0900228 struct aer_broadcast_data data = {error, PCI_ERS_RESULT_CAN_RECOVER};
long5823d102005-06-22 09:09:54 -0700229
Bjorn Helgaasb638d7e2013-04-12 11:18:01 -0600230 /* get true return value from &data */
231 device_for_each_child(&dev->dev, &data, error_detected_iter);
Hidetoshi Seto40da4182009-12-15 11:38:04 +0900232 return data.result;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700233}
234
Zhang, Yanmin4bf33922006-07-31 15:26:16 +0800235static int mmio_enabled_iter(struct device *device, void *data)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700236{
Zhang, Yanmin4bf33922006-07-31 15:26:16 +0800237 struct pcie_device *pcie_device;
238 struct pcie_port_service_driver *driver;
239 pci_ers_result_t status, *result;
240
241 result = (pci_ers_result_t *) data;
242
243 if (device->bus == &pcie_port_bus_type && device->driver) {
244 driver = to_service_driver(device->driver);
245 if (driver &&
246 driver->err_handler &&
247 driver->err_handler->mmio_enabled) {
248 pcie_device = to_pcie_device(device);
249
250 /* Forward error message to service drivers */
251 status = driver->err_handler->mmio_enabled(
252 pcie_device->port);
253 *result = merge_result(*result, status);
254 }
255 }
256
257 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700258}
Zhang, Yanmin4bf33922006-07-31 15:26:16 +0800259
260static pci_ers_result_t pcie_portdrv_mmio_enabled(struct pci_dev *dev)
261{
262 pci_ers_result_t status = PCI_ERS_RESULT_RECOVERED;
263
Greg Kroah-Hartmanb19441a2006-08-28 11:43:25 -0700264 /* get true return value from &status */
Bjorn Helgaasb638d7e2013-04-12 11:18:01 -0600265 device_for_each_child(&dev->dev, &status, mmio_enabled_iter);
Zhang, Yanmin4bf33922006-07-31 15:26:16 +0800266 return status;
267}
268
269static int slot_reset_iter(struct device *device, void *data)
270{
271 struct pcie_device *pcie_device;
272 struct pcie_port_service_driver *driver;
273 pci_ers_result_t status, *result;
274
275 result = (pci_ers_result_t *) data;
276
277 if (device->bus == &pcie_port_bus_type && device->driver) {
278 driver = to_service_driver(device->driver);
279 if (driver &&
280 driver->err_handler &&
281 driver->err_handler->slot_reset) {
282 pcie_device = to_pcie_device(device);
283
284 /* Forward error message to service drivers */
285 status = driver->err_handler->slot_reset(
286 pcie_device->port);
287 *result = merge_result(*result, status);
288 }
289 }
290
291 return 0;
292}
293
294static pci_ers_result_t pcie_portdrv_slot_reset(struct pci_dev *dev)
295{
Zhang, Yanmin029091d2009-04-30 14:48:29 +0800296 pci_ers_result_t status = PCI_ERS_RESULT_RECOVERED;
Zhang, Yanmin4bf33922006-07-31 15:26:16 +0800297
298 /* If fatal, restore cfg space for possible link reset at upstream */
299 if (dev->error_state == pci_channel_io_frozen) {
Rafael J. Wysockie9d82882009-09-14 22:25:11 +0200300 dev->state_saved = true;
Rafael J. Wysockia79d6822008-12-27 16:28:58 +0100301 pci_restore_state(dev);
Zhang, Yanmin4bf33922006-07-31 15:26:16 +0800302 pcie_portdrv_restore_config(dev);
303 pci_enable_pcie_error_reporting(dev);
304 }
305
Greg Kroah-Hartmanb19441a2006-08-28 11:43:25 -0700306 /* get true return value from &status */
Bjorn Helgaasb638d7e2013-04-12 11:18:01 -0600307 device_for_each_child(&dev->dev, &status, slot_reset_iter);
Zhang, Yanmin4bf33922006-07-31 15:26:16 +0800308 return status;
309}
310
311static int resume_iter(struct device *device, void *data)
312{
313 struct pcie_device *pcie_device;
314 struct pcie_port_service_driver *driver;
315
316 if (device->bus == &pcie_port_bus_type && device->driver) {
317 driver = to_service_driver(device->driver);
318 if (driver &&
319 driver->err_handler &&
320 driver->err_handler->resume) {
321 pcie_device = to_pcie_device(device);
322
323 /* Forward error message to service drivers */
324 driver->err_handler->resume(pcie_device->port);
325 }
326 }
327
328 return 0;
329}
330
331static void pcie_portdrv_err_resume(struct pci_dev *dev)
332{
Bjorn Helgaasb638d7e2013-04-12 11:18:01 -0600333 device_for_each_child(&dev->dev, NULL, resume_iter);
Zhang, Yanmin4bf33922006-07-31 15:26:16 +0800334}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700335
336/*
337 * LINUX Device Driver Model
338 */
339static const struct pci_device_id port_pci_ids[] = { {
340 /* handle any PCI-Express port */
341 PCI_DEVICE_CLASS(((PCI_CLASS_BRIDGE_PCI << 8) | 0x00), ~0),
342 }, { /* end: all zeroes */ }
343};
344MODULE_DEVICE_TABLE(pci, port_pci_ids);
345
Stephen Hemminger49453022012-09-07 09:33:14 -0700346static const struct pci_error_handlers pcie_portdrv_err_handler = {
347 .error_detected = pcie_portdrv_error_detected,
348 .mmio_enabled = pcie_portdrv_mmio_enabled,
349 .slot_reset = pcie_portdrv_slot_reset,
350 .resume = pcie_portdrv_err_resume,
Zhang, Yanmin4bf33922006-07-31 15:26:16 +0800351};
352
Sam Ravnborg3603a6a2007-02-27 10:19:17 +0100353static struct pci_driver pcie_portdriver = {
Bjorn Helgaase3fb20f2009-10-05 16:47:34 -0600354 .name = "pcieport",
Linus Torvalds1da177e2005-04-16 15:20:36 -0700355 .id_table = &port_pci_ids[0],
356
357 .probe = pcie_portdrv_probe,
358 .remove = pcie_portdrv_remove,
359
Bjorn Helgaasf7625982013-11-14 11:28:18 -0700360 .err_handler = &pcie_portdrv_err_handler,
Rafael J. Wysocki3a3c2442009-02-15 22:32:48 +0100361
Bjorn Helgaasf7625982013-11-14 11:28:18 -0700362 .driver.pm = PCIE_PORTDRV_PM_OPS,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700363};
364
Rafael J. Wysockic39fae12010-02-17 23:40:07 +0100365static int __init dmi_pcie_pme_disable_msi(const struct dmi_system_id *d)
366{
367 pr_notice("%s detected: will not use MSI for PCIe PME signaling\n",
Ryan Desfosses227f0642014-04-18 20:13:50 -0400368 d->ident);
Rafael J. Wysockic39fae12010-02-17 23:40:07 +0100369 pcie_pme_disable_msi();
370 return 0;
371}
372
373static struct dmi_system_id __initdata pcie_portdrv_dmi_table[] = {
374 /*
375 * Boxes that should not use MSI for PCIe PME signaling.
376 */
377 {
378 .callback = dmi_pcie_pme_disable_msi,
379 .ident = "MSI Wind U-100",
380 .matches = {
381 DMI_MATCH(DMI_SYS_VENDOR,
Bjorn Helgaasf7625982013-11-14 11:28:18 -0700382 "MICRO-STAR INTERNATIONAL CO., LTD"),
Rafael J. Wysockic39fae12010-02-17 23:40:07 +0100383 DMI_MATCH(DMI_PRODUCT_NAME, "U-100"),
384 },
385 },
386 {}
387};
388
Linus Torvalds1da177e2005-04-16 15:20:36 -0700389static int __init pcie_portdrv_init(void)
390{
Randy Dunlap20d51662006-07-08 22:58:25 -0700391 int retval;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700392
Rafael J. Wysockife31e692010-12-19 15:57:16 +0100393 if (pcie_ports_disabled)
394 return pci_register_driver(&pcie_portdriver);
Rafael J. Wysocki79dd9182010-08-21 01:51:44 +0200395
Rafael J. Wysockic39fae12010-02-17 23:40:07 +0100396 dmi_check_system(pcie_portdrv_dmi_table);
397
Randy Dunlap20d51662006-07-08 22:58:25 -0700398 retval = pcie_port_bus_register();
399 if (retval) {
400 printk(KERN_WARNING "PCIE: bus_register error: %d\n", retval);
401 goto out;
402 }
Sam Ravnborg3603a6a2007-02-27 10:19:17 +0100403 retval = pci_register_driver(&pcie_portdriver);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700404 if (retval)
405 pcie_port_bus_unregister();
Randy Dunlap20d51662006-07-08 22:58:25 -0700406 out:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700407 return retval;
408}
409
Linus Torvalds1da177e2005-04-16 15:20:36 -0700410module_init(pcie_portdrv_init);