5d9d5305ebeffe41f23356f3edd194e5682a4b60
[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 static int pcie_portdrv_restore_config(struct pci_dev *dev)
53 {
54         int retval;
55
56         retval = pci_enable_device(dev);
57         if (retval)
58                 return retval;
59         pci_set_master(dev);
60         return 0;
61 }
62
63 #ifdef CONFIG_PM
64 static int pcie_port_runtime_suspend(struct device *dev)
65 {
66         return to_pci_dev(dev)->bridge_d3 ? 0 : -EBUSY;
67 }
68
69 static int pcie_port_runtime_resume(struct device *dev)
70 {
71         return 0;
72 }
73
74 static int pcie_port_runtime_idle(struct device *dev)
75 {
76         /*
77          * Assume the PCI core has set bridge_d3 whenever it thinks the port
78          * should be good to go to D3.  Everything else, including moving
79          * the port to D3, is handled by the PCI core.
80          */
81         return to_pci_dev(dev)->bridge_d3 ? 0 : -EBUSY;
82 }
83
84 static const struct dev_pm_ops pcie_portdrv_pm_ops = {
85         .suspend        = pcie_port_device_suspend,
86         .resume         = pcie_port_device_resume,
87         .freeze         = pcie_port_device_suspend,
88         .thaw           = pcie_port_device_resume,
89         .poweroff       = pcie_port_device_suspend,
90         .restore        = pcie_port_device_resume,
91         .runtime_suspend = pcie_port_runtime_suspend,
92         .runtime_resume = pcie_port_runtime_resume,
93         .runtime_idle   = pcie_port_runtime_idle,
94 };
95
96 #define PCIE_PORTDRV_PM_OPS     (&pcie_portdrv_pm_ops)
97
98 #else /* !PM */
99
100 #define PCIE_PORTDRV_PM_OPS     NULL
101 #endif /* !PM */
102
103 /*
104  * pcie_portdrv_probe - Probe PCI-Express port devices
105  * @dev: PCI-Express port device being probed
106  *
107  * If detected invokes the pcie_port_device_register() method for
108  * this port device.
109  *
110  */
111 static int pcie_portdrv_probe(struct pci_dev *dev,
112                                         const struct pci_device_id *id)
113 {
114         int status;
115
116         if (!pci_is_pcie(dev) ||
117             ((pci_pcie_type(dev) != PCI_EXP_TYPE_ROOT_PORT) &&
118              (pci_pcie_type(dev) != PCI_EXP_TYPE_UPSTREAM) &&
119              (pci_pcie_type(dev) != PCI_EXP_TYPE_DOWNSTREAM)))
120                 return -ENODEV;
121
122         status = pcie_port_device_register(dev);
123         if (status)
124                 return status;
125
126         pci_save_state(dev);
127
128         dev_pm_set_driver_flags(&dev->dev, DPM_FLAG_SMART_SUSPEND |
129                                            DPM_FLAG_LEAVE_SUSPENDED);
130
131         if (pci_bridge_d3_possible(dev)) {
132                 /*
133                  * Keep the port resumed 100ms to make sure things like
134                  * config space accesses from userspace (lspci) will not
135                  * cause the port to repeatedly suspend and resume.
136                  */
137                 pm_runtime_set_autosuspend_delay(&dev->dev, 100);
138                 pm_runtime_use_autosuspend(&dev->dev);
139                 pm_runtime_mark_last_busy(&dev->dev);
140                 pm_runtime_put_autosuspend(&dev->dev);
141                 pm_runtime_allow(&dev->dev);
142         }
143
144         return 0;
145 }
146
147 static void pcie_portdrv_remove(struct pci_dev *dev)
148 {
149         if (pci_bridge_d3_possible(dev)) {
150                 pm_runtime_forbid(&dev->dev);
151                 pm_runtime_get_noresume(&dev->dev);
152                 pm_runtime_dont_use_autosuspend(&dev->dev);
153         }
154
155         pcie_port_device_remove(dev);
156 }
157
158 static pci_ers_result_t pcie_portdrv_error_detected(struct pci_dev *dev,
159                                         enum pci_channel_state error)
160 {
161         /* Root Port has no impact. Always recovers. */
162         return PCI_ERS_RESULT_CAN_RECOVER;
163 }
164
165 static pci_ers_result_t pcie_portdrv_mmio_enabled(struct pci_dev *dev)
166 {
167         return PCI_ERS_RESULT_RECOVERED;
168 }
169
170 static pci_ers_result_t pcie_portdrv_slot_reset(struct pci_dev *dev)
171 {
172         /* If fatal, restore cfg space for possible link reset at upstream */
173         if (dev->error_state == pci_channel_io_frozen) {
174                 dev->state_saved = true;
175                 pci_restore_state(dev);
176                 pcie_portdrv_restore_config(dev);
177                 pci_enable_pcie_error_reporting(dev);
178         }
179
180         return PCI_ERS_RESULT_RECOVERED;
181 }
182
183 static int resume_iter(struct device *device, void *data)
184 {
185         struct pcie_device *pcie_device;
186         struct pcie_port_service_driver *driver;
187
188         if (device->bus == &pcie_port_bus_type && device->driver) {
189                 driver = to_service_driver(device->driver);
190                 if (driver && driver->error_resume) {
191                         pcie_device = to_pcie_device(device);
192
193                         /* Forward error message to service drivers */
194                         driver->error_resume(pcie_device->port);
195                 }
196         }
197
198         return 0;
199 }
200
201 static void pcie_portdrv_err_resume(struct pci_dev *dev)
202 {
203         device_for_each_child(&dev->dev, NULL, resume_iter);
204 }
205
206 /*
207  * LINUX Device Driver Model
208  */
209 static const struct pci_device_id port_pci_ids[] = { {
210         /* handle any PCI-Express port */
211         PCI_DEVICE_CLASS(((PCI_CLASS_BRIDGE_PCI << 8) | 0x00), ~0),
212         }, { /* end: all zeroes */ }
213 };
214
215 static const struct pci_error_handlers pcie_portdrv_err_handler = {
216         .error_detected = pcie_portdrv_error_detected,
217         .mmio_enabled = pcie_portdrv_mmio_enabled,
218         .slot_reset = pcie_portdrv_slot_reset,
219         .resume = pcie_portdrv_err_resume,
220 };
221
222 static struct pci_driver pcie_portdriver = {
223         .name           = "pcieport",
224         .id_table       = &port_pci_ids[0],
225
226         .probe          = pcie_portdrv_probe,
227         .remove         = pcie_portdrv_remove,
228         .shutdown       = pcie_portdrv_remove,
229
230         .err_handler    = &pcie_portdrv_err_handler,
231
232         .driver.pm      = PCIE_PORTDRV_PM_OPS,
233 };
234
235 static int __init dmi_pcie_pme_disable_msi(const struct dmi_system_id *d)
236 {
237         pr_notice("%s detected: will not use MSI for PCIe PME signaling\n",
238                   d->ident);
239         pcie_pme_disable_msi();
240         return 0;
241 }
242
243 static const struct dmi_system_id pcie_portdrv_dmi_table[] __initconst = {
244         /*
245          * Boxes that should not use MSI for PCIe PME signaling.
246          */
247         {
248          .callback = dmi_pcie_pme_disable_msi,
249          .ident = "MSI Wind U-100",
250          .matches = {
251                      DMI_MATCH(DMI_SYS_VENDOR,
252                                 "MICRO-STAR INTERNATIONAL CO., LTD"),
253                      DMI_MATCH(DMI_PRODUCT_NAME, "U-100"),
254                      },
255          },
256          {}
257 };
258
259 static int __init pcie_portdrv_init(void)
260 {
261         int retval;
262
263         if (pcie_ports_disabled)
264                 return -EACCES;
265
266         dmi_check_system(pcie_portdrv_dmi_table);
267
268         retval = pcie_port_bus_register();
269         if (retval) {
270                 printk(KERN_WARNING "PCIE: bus_register error: %d\n", retval);
271                 goto out;
272         }
273         retval = pci_register_driver(&pcie_portdriver);
274         if (retval)
275                 pcie_port_bus_unregister();
276  out:
277         return retval;
278 }
279 device_initcall(pcie_portdrv_init);