Greg Kroah-Hartman | b244131 | 2017-11-01 15:07:57 +0100 | [diff] [blame] | 1 | // SPDX-License-Identifier: GPL-2.0 |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 2 | /* |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 3 | * Purpose: PCI Express Port Bus Driver |
Paul Gortmaker | a7dadf45 | 2016-08-22 17:59:44 -0400 | [diff] [blame] | 4 | * Author: Tom Nguyen <tom.l.nguyen@intel.com> |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 5 | * |
| 6 | * Copyright (C) 2004 Intel |
| 7 | * Copyright (C) Tom Long Nguyen (tom.l.nguyen@intel.com) |
| 8 | */ |
| 9 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 10 | #include <linux/pci.h> |
| 11 | #include <linux/kernel.h> |
| 12 | #include <linux/errno.h> |
| 13 | #include <linux/pm.h> |
Zheng Yan | 71a83bd | 2012-06-23 10:23:49 +0800 | [diff] [blame] | 14 | #include <linux/pm_runtime.h> |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 15 | #include <linux/init.h> |
Zhang, Yanmin | 4bf3392 | 2006-07-31 15:26:16 +0800 | [diff] [blame] | 16 | #include <linux/aer.h> |
Rafael J. Wysocki | c39fae1 | 2010-02-17 23:40:07 +0100 | [diff] [blame] | 17 | #include <linux/dmi.h> |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 18 | |
Lukas Wunner | c6a6330 | 2016-10-28 10:52:06 +0200 | [diff] [blame] | 19 | #include "../pci.h" |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 20 | #include "portdrv.h" |
| 21 | |
Rafael J. Wysocki | 79dd918 | 2010-08-21 01:51:44 +0200 | [diff] [blame] | 22 | /* If this switch is set, PCIe port native services should not be enabled. */ |
| 23 | bool pcie_ports_disabled; |
| 24 | |
Rafael J. Wysocki | 28eb5f2 | 2010-08-21 22:02:38 +0200 | [diff] [blame] | 25 | /* |
Bjorn Helgaas | d850882 | 2018-03-09 11:21:30 -0600 | [diff] [blame] | 26 | * If the user specified "pcie_ports=native", use the PCIe services regardless |
| 27 | * of whether the platform has given us permission. On ACPI systems, this |
| 28 | * means we ignore _OSC. |
Rafael J. Wysocki | 28eb5f2 | 2010-08-21 22:02:38 +0200 | [diff] [blame] | 29 | */ |
Bjorn Helgaas | d850882 | 2018-03-09 11:21:30 -0600 | [diff] [blame] | 30 | bool pcie_ports_native; |
Rafael J. Wysocki | 28eb5f2 | 2010-08-21 22:02:38 +0200 | [diff] [blame] | 31 | |
Olof Johansson | 35a0b23 | 2019-10-23 12:22:05 -0700 | [diff] [blame] | 32 | /* |
| 33 | * If the user specified "pcie_ports=dpc-native", use the Linux DPC PCIe |
| 34 | * service even if the platform hasn't given us permission. |
| 35 | */ |
| 36 | bool pcie_ports_dpc_native; |
| 37 | |
Rafael J. Wysocki | 79dd918 | 2010-08-21 01:51:44 +0200 | [diff] [blame] | 38 | static int __init pcie_port_setup(char *str) |
| 39 | { |
Bjorn Helgaas | d850882 | 2018-03-09 11:21:30 -0600 | [diff] [blame] | 40 | if (!strncmp(str, "compat", 6)) |
Rafael J. Wysocki | 79dd918 | 2010-08-21 01:51:44 +0200 | [diff] [blame] | 41 | pcie_ports_disabled = true; |
Bjorn Helgaas | d850882 | 2018-03-09 11:21:30 -0600 | [diff] [blame] | 42 | else if (!strncmp(str, "native", 6)) |
| 43 | pcie_ports_native = true; |
Olof Johansson | 35a0b23 | 2019-10-23 12:22:05 -0700 | [diff] [blame] | 44 | else if (!strncmp(str, "dpc-native", 10)) |
| 45 | pcie_ports_dpc_native = true; |
Rafael J. Wysocki | 79dd918 | 2010-08-21 01:51:44 +0200 | [diff] [blame] | 46 | |
| 47 | return 1; |
| 48 | } |
| 49 | __setup("pcie_ports=", pcie_port_setup); |
| 50 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 51 | /* global data */ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 52 | |
Zhang, Yanmin | 0bed208 | 2006-09-28 14:35:59 +0800 | [diff] [blame] | 53 | #ifdef CONFIG_PM |
Mika Westerberg | 006d44e | 2016-06-02 11:17:15 +0300 | [diff] [blame] | 54 | static int pcie_port_runtime_suspend(struct device *dev) |
| 55 | { |
Mika Westerberg | 94c7993 | 2018-09-27 16:41:48 -0500 | [diff] [blame] | 56 | if (!to_pci_dev(dev)->bridge_d3) |
| 57 | return -EBUSY; |
Mika Westerberg | 006d44e | 2016-06-02 11:17:15 +0300 | [diff] [blame] | 58 | |
Mika Westerberg | 94c7993 | 2018-09-27 16:41:48 -0500 | [diff] [blame] | 59 | return pcie_port_device_runtime_suspend(dev); |
Mika Westerberg | 006d44e | 2016-06-02 11:17:15 +0300 | [diff] [blame] | 60 | } |
| 61 | |
| 62 | static int pcie_port_runtime_idle(struct device *dev) |
| 63 | { |
| 64 | /* |
| 65 | * Assume the PCI core has set bridge_d3 whenever it thinks the port |
| 66 | * should be good to go to D3. Everything else, including moving |
| 67 | * the port to D3, is handled by the PCI core. |
| 68 | */ |
| 69 | return to_pci_dev(dev)->bridge_d3 ? 0 : -EBUSY; |
| 70 | } |
| 71 | |
Alexey Dobriyan | 4714521 | 2009-12-14 18:00:08 -0800 | [diff] [blame] | 72 | static const struct dev_pm_ops pcie_portdrv_pm_ops = { |
Rafael J. Wysocki | 3a3c244 | 2009-02-15 22:32:48 +0100 | [diff] [blame] | 73 | .suspend = pcie_port_device_suspend, |
Lukas Wunner | 7903782 | 2018-07-19 17:27:53 -0500 | [diff] [blame] | 74 | .resume_noirq = pcie_port_device_resume_noirq, |
Rafael J. Wysocki | 3a3c244 | 2009-02-15 22:32:48 +0100 | [diff] [blame] | 75 | .resume = pcie_port_device_resume, |
| 76 | .freeze = pcie_port_device_suspend, |
| 77 | .thaw = pcie_port_device_resume, |
| 78 | .poweroff = pcie_port_device_suspend, |
Lukas Wunner | 7903782 | 2018-07-19 17:27:53 -0500 | [diff] [blame] | 79 | .restore_noirq = pcie_port_device_resume_noirq, |
Rafael J. Wysocki | 3a3c244 | 2009-02-15 22:32:48 +0100 | [diff] [blame] | 80 | .restore = pcie_port_device_resume, |
Mika Westerberg | 006d44e | 2016-06-02 11:17:15 +0300 | [diff] [blame] | 81 | .runtime_suspend = pcie_port_runtime_suspend, |
Mika Westerberg | 94c7993 | 2018-09-27 16:41:48 -0500 | [diff] [blame] | 82 | .runtime_resume = pcie_port_device_runtime_resume, |
Mika Westerberg | 006d44e | 2016-06-02 11:17:15 +0300 | [diff] [blame] | 83 | .runtime_idle = pcie_port_runtime_idle, |
Rafael J. Wysocki | 3a3c244 | 2009-02-15 22:32:48 +0100 | [diff] [blame] | 84 | }; |
Rafael J. Wysocki | a79d682 | 2008-12-27 16:28:58 +0100 | [diff] [blame] | 85 | |
Rafael J. Wysocki | 3a3c244 | 2009-02-15 22:32:48 +0100 | [diff] [blame] | 86 | #define PCIE_PORTDRV_PM_OPS (&pcie_portdrv_pm_ops) |
Rafael J. Wysocki | a79d682 | 2008-12-27 16:28:58 +0100 | [diff] [blame] | 87 | |
Rafael J. Wysocki | 3a3c244 | 2009-02-15 22:32:48 +0100 | [diff] [blame] | 88 | #else /* !PM */ |
| 89 | |
| 90 | #define PCIE_PORTDRV_PM_OPS NULL |
| 91 | #endif /* !PM */ |
Zhang, Yanmin | 4bf3392 | 2006-07-31 15:26:16 +0800 | [diff] [blame] | 92 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 93 | /* |
| 94 | * pcie_portdrv_probe - Probe PCI-Express port devices |
| 95 | * @dev: PCI-Express port device being probed |
| 96 | * |
Hidetoshi Seto | 40da418 | 2009-12-15 11:38:04 +0900 | [diff] [blame] | 97 | * If detected invokes the pcie_port_device_register() method for |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 98 | * this port device. |
| 99 | * |
| 100 | */ |
Bill Pemberton | 15856ad | 2012-11-21 15:35:00 -0500 | [diff] [blame] | 101 | static int pcie_portdrv_probe(struct pci_dev *dev, |
Kenji Kaneshige | 898294c | 2009-11-25 21:00:53 +0900 | [diff] [blame] | 102 | const struct pci_device_id *id) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 103 | { |
Kenji Kaneshige | 898294c | 2009-11-25 21:00:53 +0900 | [diff] [blame] | 104 | int status; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 105 | |
Kenji Kaneshige | 898294c | 2009-11-25 21:00:53 +0900 | [diff] [blame] | 106 | if (!pci_is_pcie(dev) || |
Yijing Wang | 62f87c0 | 2012-07-24 17:20:03 +0800 | [diff] [blame] | 107 | ((pci_pcie_type(dev) != PCI_EXP_TYPE_ROOT_PORT) && |
| 108 | (pci_pcie_type(dev) != PCI_EXP_TYPE_UPSTREAM) && |
| 109 | (pci_pcie_type(dev) != PCI_EXP_TYPE_DOWNSTREAM))) |
Kenji Kaneshige | 898294c | 2009-11-25 21:00:53 +0900 | [diff] [blame] | 110 | return -ENODEV; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 111 | |
Rafael J. Wysocki | f118c0c | 2009-01-13 14:42:01 +0100 | [diff] [blame] | 112 | status = pcie_port_device_register(dev); |
| 113 | if (status) |
| 114 | return status; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 115 | |
Rafael J. Wysocki | 87d2e2e | 2009-01-13 14:43:07 +0100 | [diff] [blame] | 116 | pci_save_state(dev); |
Mika Westerberg | 006d44e | 2016-06-02 11:17:15 +0300 | [diff] [blame] | 117 | |
Rafael J. Wysocki | e075155 | 2020-04-18 18:53:01 +0200 | [diff] [blame] | 118 | dev_pm_set_driver_flags(&dev->dev, DPM_FLAG_NO_DIRECT_COMPLETE | |
Mika Westerberg | 52be946 | 2018-09-27 16:41:47 -0500 | [diff] [blame] | 119 | DPM_FLAG_SMART_SUSPEND); |
Rafael J. Wysocki | 877b3729c | 2018-01-03 01:38:27 +0100 | [diff] [blame] | 120 | |
Lukas Wunner | 97a90ae | 2016-10-28 10:52:06 +0200 | [diff] [blame] | 121 | if (pci_bridge_d3_possible(dev)) { |
Mika Westerberg | 006d44e | 2016-06-02 11:17:15 +0300 | [diff] [blame] | 122 | /* |
| 123 | * Keep the port resumed 100ms to make sure things like |
| 124 | * config space accesses from userspace (lspci) will not |
| 125 | * cause the port to repeatedly suspend and resume. |
| 126 | */ |
| 127 | pm_runtime_set_autosuspend_delay(&dev->dev, 100); |
| 128 | pm_runtime_use_autosuspend(&dev->dev); |
| 129 | pm_runtime_mark_last_busy(&dev->dev); |
| 130 | pm_runtime_put_autosuspend(&dev->dev); |
| 131 | pm_runtime_allow(&dev->dev); |
| 132 | } |
| 133 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 134 | return 0; |
| 135 | } |
| 136 | |
Hidetoshi Seto | 40da418 | 2009-12-15 11:38:04 +0900 | [diff] [blame] | 137 | static void pcie_portdrv_remove(struct pci_dev *dev) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 138 | { |
Lukas Wunner | 97a90ae | 2016-10-28 10:52:06 +0200 | [diff] [blame] | 139 | if (pci_bridge_d3_possible(dev)) { |
Mika Westerberg | 006d44e | 2016-06-02 11:17:15 +0300 | [diff] [blame] | 140 | pm_runtime_forbid(&dev->dev); |
| 141 | pm_runtime_get_noresume(&dev->dev); |
| 142 | pm_runtime_dont_use_autosuspend(&dev->dev); |
| 143 | } |
| 144 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 145 | pcie_port_device_remove(dev); |
| 146 | } |
| 147 | |
Zhang, Yanmin | 4bf3392 | 2006-07-31 15:26:16 +0800 | [diff] [blame] | 148 | static pci_ers_result_t pcie_portdrv_error_detected(struct pci_dev *dev, |
Luc Van Oostenryck | 16d79cd | 2020-07-02 18:26:49 +0200 | [diff] [blame] | 149 | pci_channel_state_t error) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 150 | { |
Christoph Hellwig | c5dc3c6 | 2017-06-19 20:04:58 +0200 | [diff] [blame] | 151 | /* Root Port has no impact. Always recovers. */ |
| 152 | return PCI_ERS_RESULT_CAN_RECOVER; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 153 | } |
Zhang, Yanmin | 4bf3392 | 2006-07-31 15:26:16 +0800 | [diff] [blame] | 154 | |
Keith Busch | 874b325 | 2018-09-20 10:27:07 -0600 | [diff] [blame] | 155 | static pci_ers_result_t pcie_portdrv_slot_reset(struct pci_dev *dev) |
| 156 | { |
| 157 | pci_restore_state(dev); |
| 158 | pci_save_state(dev); |
| 159 | return PCI_ERS_RESULT_RECOVERED; |
| 160 | } |
| 161 | |
Zhang, Yanmin | 4bf3392 | 2006-07-31 15:26:16 +0800 | [diff] [blame] | 162 | static pci_ers_result_t pcie_portdrv_mmio_enabled(struct pci_dev *dev) |
| 163 | { |
Christoph Hellwig | c5dc3c6 | 2017-06-19 20:04:58 +0200 | [diff] [blame] | 164 | return PCI_ERS_RESULT_RECOVERED; |
Zhang, Yanmin | 4bf3392 | 2006-07-31 15:26:16 +0800 | [diff] [blame] | 165 | } |
| 166 | |
Zhang, Yanmin | 4bf3392 | 2006-07-31 15:26:16 +0800 | [diff] [blame] | 167 | static int resume_iter(struct device *device, void *data) |
| 168 | { |
| 169 | struct pcie_device *pcie_device; |
| 170 | struct pcie_port_service_driver *driver; |
| 171 | |
| 172 | if (device->bus == &pcie_port_bus_type && device->driver) { |
| 173 | driver = to_service_driver(device->driver); |
Christoph Hellwig | c5dc3c6 | 2017-06-19 20:04:58 +0200 | [diff] [blame] | 174 | if (driver && driver->error_resume) { |
Zhang, Yanmin | 4bf3392 | 2006-07-31 15:26:16 +0800 | [diff] [blame] | 175 | pcie_device = to_pcie_device(device); |
| 176 | |
| 177 | /* Forward error message to service drivers */ |
Christoph Hellwig | c5dc3c6 | 2017-06-19 20:04:58 +0200 | [diff] [blame] | 178 | driver->error_resume(pcie_device->port); |
Zhang, Yanmin | 4bf3392 | 2006-07-31 15:26:16 +0800 | [diff] [blame] | 179 | } |
| 180 | } |
| 181 | |
| 182 | return 0; |
| 183 | } |
| 184 | |
| 185 | static void pcie_portdrv_err_resume(struct pci_dev *dev) |
| 186 | { |
Bjorn Helgaas | b638d7e | 2013-04-12 11:18:01 -0600 | [diff] [blame] | 187 | device_for_each_child(&dev->dev, NULL, resume_iter); |
Zhang, Yanmin | 4bf3392 | 2006-07-31 15:26:16 +0800 | [diff] [blame] | 188 | } |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 189 | |
| 190 | /* |
| 191 | * LINUX Device Driver Model |
| 192 | */ |
Bjorn Helgaas | c89f7f9 | 2019-02-15 13:49:18 -0600 | [diff] [blame] | 193 | static const struct pci_device_id port_pci_ids[] = { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 194 | /* handle any PCI-Express port */ |
Bjorn Helgaas | c89f7f9 | 2019-02-15 13:49:18 -0600 | [diff] [blame] | 195 | { PCI_DEVICE_CLASS(((PCI_CLASS_BRIDGE_PCI << 8) | 0x00), ~0) }, |
Honghui Zhang | f0cfece | 2019-02-14 13:21:17 +0800 | [diff] [blame] | 196 | /* subtractive decode PCI-to-PCI bridge, class type is 060401h */ |
| 197 | { PCI_DEVICE_CLASS(((PCI_CLASS_BRIDGE_PCI << 8) | 0x01), ~0) }, |
Bjorn Helgaas | c89f7f9 | 2019-02-15 13:49:18 -0600 | [diff] [blame] | 198 | { }, |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 199 | }; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 200 | |
Stephen Hemminger | 4945302 | 2012-09-07 09:33:14 -0700 | [diff] [blame] | 201 | static const struct pci_error_handlers pcie_portdrv_err_handler = { |
| 202 | .error_detected = pcie_portdrv_error_detected, |
Keith Busch | 874b325 | 2018-09-20 10:27:07 -0600 | [diff] [blame] | 203 | .slot_reset = pcie_portdrv_slot_reset, |
Stephen Hemminger | 4945302 | 2012-09-07 09:33:14 -0700 | [diff] [blame] | 204 | .mmio_enabled = pcie_portdrv_mmio_enabled, |
Stephen Hemminger | 4945302 | 2012-09-07 09:33:14 -0700 | [diff] [blame] | 205 | .resume = pcie_portdrv_err_resume, |
Zhang, Yanmin | 4bf3392 | 2006-07-31 15:26:16 +0800 | [diff] [blame] | 206 | }; |
| 207 | |
Sam Ravnborg | 3603a6a | 2007-02-27 10:19:17 +0100 | [diff] [blame] | 208 | static struct pci_driver pcie_portdriver = { |
Bjorn Helgaas | e3fb20f | 2009-10-05 16:47:34 -0600 | [diff] [blame] | 209 | .name = "pcieport", |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 210 | .id_table = &port_pci_ids[0], |
| 211 | |
| 212 | .probe = pcie_portdrv_probe, |
| 213 | .remove = pcie_portdrv_remove, |
Sinan Kaya | cc27b73 | 2017-10-25 15:01:02 -0400 | [diff] [blame] | 214 | .shutdown = pcie_portdrv_remove, |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 215 | |
Bjorn Helgaas | f762598 | 2013-11-14 11:28:18 -0700 | [diff] [blame] | 216 | .err_handler = &pcie_portdrv_err_handler, |
Rafael J. Wysocki | 3a3c244 | 2009-02-15 22:32:48 +0100 | [diff] [blame] | 217 | |
Bjorn Helgaas | f762598 | 2013-11-14 11:28:18 -0700 | [diff] [blame] | 218 | .driver.pm = PCIE_PORTDRV_PM_OPS, |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 219 | }; |
| 220 | |
Rafael J. Wysocki | c39fae1 | 2010-02-17 23:40:07 +0100 | [diff] [blame] | 221 | static int __init dmi_pcie_pme_disable_msi(const struct dmi_system_id *d) |
| 222 | { |
| 223 | pr_notice("%s detected: will not use MSI for PCIe PME signaling\n", |
Ryan Desfosses | 227f064 | 2014-04-18 20:13:50 -0400 | [diff] [blame] | 224 | d->ident); |
Rafael J. Wysocki | c39fae1 | 2010-02-17 23:40:07 +0100 | [diff] [blame] | 225 | pcie_pme_disable_msi(); |
| 226 | return 0; |
| 227 | } |
| 228 | |
Christoph Hellwig | 6faadbb | 2017-09-14 11:59:30 +0200 | [diff] [blame] | 229 | static const struct dmi_system_id pcie_portdrv_dmi_table[] __initconst = { |
Rafael J. Wysocki | c39fae1 | 2010-02-17 23:40:07 +0100 | [diff] [blame] | 230 | /* |
| 231 | * Boxes that should not use MSI for PCIe PME signaling. |
| 232 | */ |
| 233 | { |
| 234 | .callback = dmi_pcie_pme_disable_msi, |
| 235 | .ident = "MSI Wind U-100", |
| 236 | .matches = { |
| 237 | DMI_MATCH(DMI_SYS_VENDOR, |
Bjorn Helgaas | f762598 | 2013-11-14 11:28:18 -0700 | [diff] [blame] | 238 | "MICRO-STAR INTERNATIONAL CO., LTD"), |
Rafael J. Wysocki | c39fae1 | 2010-02-17 23:40:07 +0100 | [diff] [blame] | 239 | DMI_MATCH(DMI_PRODUCT_NAME, "U-100"), |
| 240 | }, |
| 241 | }, |
| 242 | {} |
| 243 | }; |
| 244 | |
Keith Busch | c29de84 | 2018-09-20 10:27:06 -0600 | [diff] [blame] | 245 | static void __init pcie_init_services(void) |
| 246 | { |
| 247 | pcie_aer_init(); |
| 248 | pcie_pme_init(); |
| 249 | pcie_dpc_init(); |
| 250 | pcie_hp_init(); |
Alexandru Gagniuc | e8303bb | 2019-02-27 14:58:17 -0600 | [diff] [blame] | 251 | pcie_bandwidth_notification_init(); |
Keith Busch | c29de84 | 2018-09-20 10:27:06 -0600 | [diff] [blame] | 252 | } |
| 253 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 254 | static int __init pcie_portdrv_init(void) |
| 255 | { |
Rafael J. Wysocki | fe31e69 | 2010-12-19 15:57:16 +0100 | [diff] [blame] | 256 | if (pcie_ports_disabled) |
Bjorn Helgaas | 79a0111 | 2018-03-09 11:06:56 -0600 | [diff] [blame] | 257 | return -EACCES; |
Rafael J. Wysocki | 79dd918 | 2010-08-21 01:51:44 +0200 | [diff] [blame] | 258 | |
Keith Busch | c29de84 | 2018-09-20 10:27:06 -0600 | [diff] [blame] | 259 | pcie_init_services(); |
Rafael J. Wysocki | c39fae1 | 2010-02-17 23:40:07 +0100 | [diff] [blame] | 260 | dmi_check_system(pcie_portdrv_dmi_table); |
| 261 | |
Bjorn Helgaas | c6c889d | 2018-03-09 11:06:56 -0600 | [diff] [blame] | 262 | return pci_register_driver(&pcie_portdriver); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 263 | } |
Paul Gortmaker | a7dadf45 | 2016-08-22 17:59:44 -0400 | [diff] [blame] | 264 | device_initcall(pcie_portdrv_init); |