977bd3cca2e526e5b936ec8f188d15fdb91f61cd
[muen/linux.git] / drivers / pci / pcie / portdrv_pci.c
1 // SPDX-License-Identifier: GPL-2.0
2 /*
3  * File:        portdrv_pci.c
4  * Purpose:     PCI Express Port Bus Driver
5  * Author:      Tom Nguyen <tom.l.nguyen@intel.com>
6  * Version:     v1.0
7  *
8  * Copyright (C) 2004 Intel
9  * Copyright (C) Tom Long Nguyen (tom.l.nguyen@intel.com)
10  */
11
12 #include <linux/pci.h>
13 #include <linux/kernel.h>
14 #include <linux/errno.h>
15 #include <linux/pm.h>
16 #include <linux/pm_runtime.h>
17 #include <linux/init.h>
18 #include <linux/aer.h>
19 #include <linux/dmi.h>
20 #include <linux/pci-aspm.h>
21
22 #include "../pci.h"
23 #include "portdrv.h"
24
25 /* If this switch is set, PCIe port native services should not be enabled. */
26 bool pcie_ports_disabled;
27
28 /*
29  * If this switch is set, ACPI _OSC will be used to determine whether or not to
30  * enable PCIe port native services.
31  */
32 bool pcie_ports_auto = true;
33
34 static int __init pcie_port_setup(char *str)
35 {
36         if (!strncmp(str, "compat", 6)) {
37                 pcie_ports_disabled = true;
38         } else if (!strncmp(str, "native", 6)) {
39                 pcie_ports_disabled = false;
40                 pcie_ports_auto = false;
41         } else if (!strncmp(str, "auto", 4)) {
42                 pcie_ports_disabled = false;
43                 pcie_ports_auto = true;
44         }
45
46         return 1;
47 }
48 __setup("pcie_ports=", pcie_port_setup);
49
50 /* global data */
51
52 /**
53  * pcie_clear_root_pme_status - Clear root port PME interrupt status.
54  * @dev: PCIe root port or event collector.
55  */
56 void pcie_clear_root_pme_status(struct pci_dev *dev)
57 {
58         pcie_capability_set_dword(dev, PCI_EXP_RTSTA, PCI_EXP_RTSTA_PME);
59 }
60
61 static int pcie_portdrv_restore_config(struct pci_dev *dev)
62 {
63         int retval;
64
65         retval = pci_enable_device(dev);
66         if (retval)
67                 return retval;
68         pci_set_master(dev);
69         return 0;
70 }
71
72 #ifdef CONFIG_PM
73 static int pcie_port_resume_noirq(struct device *dev)
74 {
75         struct pci_dev *pdev = to_pci_dev(dev);
76
77         /*
78          * Some BIOSes forget to clear Root PME Status bits after system wakeup
79          * which breaks ACPI-based runtime wakeup on PCI Express, so clear those
80          * bits now just in case (shouldn't hurt).
81          */
82         if (pci_pcie_type(pdev) == PCI_EXP_TYPE_ROOT_PORT)
83                 pcie_clear_root_pme_status(pdev);
84         return 0;
85 }
86
87 static int pcie_port_runtime_suspend(struct device *dev)
88 {
89         return to_pci_dev(dev)->bridge_d3 ? 0 : -EBUSY;
90 }
91
92 static int pcie_port_runtime_resume(struct device *dev)
93 {
94         return 0;
95 }
96
97 static int pcie_port_runtime_idle(struct device *dev)
98 {
99         /*
100          * Assume the PCI core has set bridge_d3 whenever it thinks the port
101          * should be good to go to D3.  Everything else, including moving
102          * the port to D3, is handled by the PCI core.
103          */
104         return to_pci_dev(dev)->bridge_d3 ? 0 : -EBUSY;
105 }
106
107 static const struct dev_pm_ops pcie_portdrv_pm_ops = {
108         .suspend        = pcie_port_device_suspend,
109         .resume         = pcie_port_device_resume,
110         .freeze         = pcie_port_device_suspend,
111         .thaw           = pcie_port_device_resume,
112         .poweroff       = pcie_port_device_suspend,
113         .restore        = pcie_port_device_resume,
114         .resume_noirq   = pcie_port_resume_noirq,
115         .runtime_suspend = pcie_port_runtime_suspend,
116         .runtime_resume = pcie_port_runtime_resume,
117         .runtime_idle   = pcie_port_runtime_idle,
118 };
119
120 #define PCIE_PORTDRV_PM_OPS     (&pcie_portdrv_pm_ops)
121
122 #else /* !PM */
123
124 #define PCIE_PORTDRV_PM_OPS     NULL
125 #endif /* !PM */
126
127 /*
128  * pcie_portdrv_probe - Probe PCI-Express port devices
129  * @dev: PCI-Express port device being probed
130  *
131  * If detected invokes the pcie_port_device_register() method for
132  * this port device.
133  *
134  */
135 static int pcie_portdrv_probe(struct pci_dev *dev,
136                                         const struct pci_device_id *id)
137 {
138         int status;
139
140         if (!pci_is_pcie(dev) ||
141             ((pci_pcie_type(dev) != PCI_EXP_TYPE_ROOT_PORT) &&
142              (pci_pcie_type(dev) != PCI_EXP_TYPE_UPSTREAM) &&
143              (pci_pcie_type(dev) != PCI_EXP_TYPE_DOWNSTREAM)))
144                 return -ENODEV;
145
146         status = pcie_port_device_register(dev);
147         if (status)
148                 return status;
149
150         pci_save_state(dev);
151
152         dev_pm_set_driver_flags(&dev->dev, DPM_FLAG_SMART_SUSPEND |
153                                            DPM_FLAG_LEAVE_SUSPENDED);
154
155         if (pci_bridge_d3_possible(dev)) {
156                 /*
157                  * Keep the port resumed 100ms to make sure things like
158                  * config space accesses from userspace (lspci) will not
159                  * cause the port to repeatedly suspend and resume.
160                  */
161                 pm_runtime_set_autosuspend_delay(&dev->dev, 100);
162                 pm_runtime_use_autosuspend(&dev->dev);
163                 pm_runtime_mark_last_busy(&dev->dev);
164                 pm_runtime_put_autosuspend(&dev->dev);
165                 pm_runtime_allow(&dev->dev);
166         }
167
168         return 0;
169 }
170
171 static void pcie_portdrv_remove(struct pci_dev *dev)
172 {
173         if (pci_bridge_d3_possible(dev)) {
174                 pm_runtime_forbid(&dev->dev);
175                 pm_runtime_get_noresume(&dev->dev);
176                 pm_runtime_dont_use_autosuspend(&dev->dev);
177         }
178
179         pcie_port_device_remove(dev);
180 }
181
182 static pci_ers_result_t pcie_portdrv_error_detected(struct pci_dev *dev,
183                                         enum pci_channel_state error)
184 {
185         /* Root Port has no impact. Always recovers. */
186         return PCI_ERS_RESULT_CAN_RECOVER;
187 }
188
189 static pci_ers_result_t pcie_portdrv_mmio_enabled(struct pci_dev *dev)
190 {
191         return PCI_ERS_RESULT_RECOVERED;
192 }
193
194 static pci_ers_result_t pcie_portdrv_slot_reset(struct pci_dev *dev)
195 {
196         /* If fatal, restore cfg space for possible link reset at upstream */
197         if (dev->error_state == pci_channel_io_frozen) {
198                 dev->state_saved = true;
199                 pci_restore_state(dev);
200                 pcie_portdrv_restore_config(dev);
201                 pci_enable_pcie_error_reporting(dev);
202         }
203
204         return PCI_ERS_RESULT_RECOVERED;
205 }
206
207 static int resume_iter(struct device *device, void *data)
208 {
209         struct pcie_device *pcie_device;
210         struct pcie_port_service_driver *driver;
211
212         if (device->bus == &pcie_port_bus_type && device->driver) {
213                 driver = to_service_driver(device->driver);
214                 if (driver && driver->error_resume) {
215                         pcie_device = to_pcie_device(device);
216
217                         /* Forward error message to service drivers */
218                         driver->error_resume(pcie_device->port);
219                 }
220         }
221
222         return 0;
223 }
224
225 static void pcie_portdrv_err_resume(struct pci_dev *dev)
226 {
227         device_for_each_child(&dev->dev, NULL, resume_iter);
228 }
229
230 /*
231  * LINUX Device Driver Model
232  */
233 static const struct pci_device_id port_pci_ids[] = { {
234         /* handle any PCI-Express port */
235         PCI_DEVICE_CLASS(((PCI_CLASS_BRIDGE_PCI << 8) | 0x00), ~0),
236         }, { /* end: all zeroes */ }
237 };
238
239 static const struct pci_error_handlers pcie_portdrv_err_handler = {
240         .error_detected = pcie_portdrv_error_detected,
241         .mmio_enabled = pcie_portdrv_mmio_enabled,
242         .slot_reset = pcie_portdrv_slot_reset,
243         .resume = pcie_portdrv_err_resume,
244 };
245
246 static struct pci_driver pcie_portdriver = {
247         .name           = "pcieport",
248         .id_table       = &port_pci_ids[0],
249
250         .probe          = pcie_portdrv_probe,
251         .remove         = pcie_portdrv_remove,
252         .shutdown       = pcie_portdrv_remove,
253
254         .err_handler    = &pcie_portdrv_err_handler,
255
256         .driver.pm      = PCIE_PORTDRV_PM_OPS,
257 };
258
259 static int __init dmi_pcie_pme_disable_msi(const struct dmi_system_id *d)
260 {
261         pr_notice("%s detected: will not use MSI for PCIe PME signaling\n",
262                   d->ident);
263         pcie_pme_disable_msi();
264         return 0;
265 }
266
267 static const struct dmi_system_id pcie_portdrv_dmi_table[] __initconst = {
268         /*
269          * Boxes that should not use MSI for PCIe PME signaling.
270          */
271         {
272          .callback = dmi_pcie_pme_disable_msi,
273          .ident = "MSI Wind U-100",
274          .matches = {
275                      DMI_MATCH(DMI_SYS_VENDOR,
276                                 "MICRO-STAR INTERNATIONAL CO., LTD"),
277                      DMI_MATCH(DMI_PRODUCT_NAME, "U-100"),
278                      },
279          },
280          {}
281 };
282
283 static int __init pcie_portdrv_init(void)
284 {
285         int retval;
286
287         if (pcie_ports_disabled)
288                 return pci_register_driver(&pcie_portdriver);
289
290         dmi_check_system(pcie_portdrv_dmi_table);
291
292         retval = pcie_port_bus_register();
293         if (retval) {
294                 printk(KERN_WARNING "PCIE: bus_register error: %d\n", retval);
295                 goto out;
296         }
297         retval = pci_register_driver(&pcie_portdriver);
298         if (retval)
299                 pcie_port_bus_unregister();
300  out:
301         return retval;
302 }
303 device_initcall(pcie_portdrv_init);