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