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