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