PCI/PM: Clear PCIe PME Status bit for Root Complex Event Collectors
[muen/linux.git] / drivers / pci / pcie / portdrv_core.c
1 // SPDX-License-Identifier: GPL-2.0
2 /*
3  * File:        portdrv_core.c
4  * Purpose:     PCI Express Port Bus Driver's Core Functions
5  *
6  * Copyright (C) 2004 Intel
7  * Copyright (C) Tom Long Nguyen (tom.l.nguyen@intel.com)
8  */
9
10 #include <linux/module.h>
11 #include <linux/pci.h>
12 #include <linux/kernel.h>
13 #include <linux/errno.h>
14 #include <linux/pm.h>
15 #include <linux/pm_runtime.h>
16 #include <linux/string.h>
17 #include <linux/slab.h>
18 #include <linux/aer.h>
19
20 #include "../pci.h"
21 #include "portdrv.h"
22
23 bool pciehp_msi_disabled;
24
25 static int __init pciehp_setup(char *str)
26 {
27         if (!strncmp(str, "nomsi", 5))
28                 pciehp_msi_disabled = true;
29
30         return 1;
31 }
32 __setup("pcie_hp=", pciehp_setup);
33
34 /**
35  * release_pcie_device - free PCI Express port service device structure
36  * @dev: Port service device to release
37  *
38  * Invoked automatically when device is being removed in response to
39  * device_unregister(dev).  Release all resources being claimed.
40  */
41 static void release_pcie_device(struct device *dev)
42 {
43         kfree(to_pcie_device(dev));
44 }
45
46 /*
47  * Fill in *pme, *aer, *dpc with the relevant Interrupt Message Numbers if
48  * services are enabled in "mask".  Return the number of MSI/MSI-X vectors
49  * required to accommodate the largest Message Number.
50  */
51 static int pcie_message_numbers(struct pci_dev *dev, int mask,
52                                 u32 *pme, u32 *aer, u32 *dpc)
53 {
54         u32 nvec = 0, pos, reg32;
55         u16 reg16;
56
57         /*
58          * The Interrupt Message Number indicates which vector is used, i.e.,
59          * the MSI-X table entry or the MSI offset between the base Message
60          * Data and the generated interrupt message.  See PCIe r3.1, sec
61          * 7.8.2, 7.10.10, 7.31.2.
62          */
63
64         if (mask & (PCIE_PORT_SERVICE_PME | PCIE_PORT_SERVICE_HP)) {
65                 pcie_capability_read_word(dev, PCI_EXP_FLAGS, &reg16);
66                 *pme = (reg16 & PCI_EXP_FLAGS_IRQ) >> 9;
67                 nvec = *pme + 1;
68         }
69
70         if (mask & PCIE_PORT_SERVICE_AER) {
71                 pos = pci_find_ext_capability(dev, PCI_EXT_CAP_ID_ERR);
72                 if (pos) {
73                         pci_read_config_dword(dev, pos + PCI_ERR_ROOT_STATUS,
74                                               &reg32);
75                         *aer = (reg32 & PCI_ERR_ROOT_AER_IRQ) >> 27;
76                         nvec = max(nvec, *aer + 1);
77                 }
78         }
79
80         if (mask & PCIE_PORT_SERVICE_DPC) {
81                 pos = pci_find_ext_capability(dev, PCI_EXT_CAP_ID_DPC);
82                 if (pos) {
83                         pci_read_config_word(dev, pos + PCI_EXP_DPC_CAP,
84                                              &reg16);
85                         *dpc = reg16 & PCI_EXP_DPC_IRQ;
86                         nvec = max(nvec, *dpc + 1);
87                 }
88         }
89
90         return nvec;
91 }
92
93 /**
94  * pcie_port_enable_irq_vec - try to set up MSI-X or MSI as interrupt mode
95  * for given port
96  * @dev: PCI Express port to handle
97  * @irqs: Array of interrupt vectors to populate
98  * @mask: Bitmask of port capabilities returned by get_port_device_capability()
99  *
100  * Return value: 0 on success, error code on failure
101  */
102 static int pcie_port_enable_irq_vec(struct pci_dev *dev, int *irqs, int mask)
103 {
104         int nr_entries, nvec;
105         u32 pme = 0, aer = 0, dpc = 0;
106
107         /* Allocate the maximum possible number of MSI/MSI-X vectors */
108         nr_entries = pci_alloc_irq_vectors(dev, 1, PCIE_PORT_MAX_MSI_ENTRIES,
109                         PCI_IRQ_MSIX | PCI_IRQ_MSI);
110         if (nr_entries < 0)
111                 return nr_entries;
112
113         /* See how many and which Interrupt Message Numbers we actually use */
114         nvec = pcie_message_numbers(dev, mask, &pme, &aer, &dpc);
115         if (nvec > nr_entries) {
116                 pci_free_irq_vectors(dev);
117                 return -EIO;
118         }
119
120         /*
121          * If we allocated more than we need, free them and reallocate fewer.
122          *
123          * Reallocating may change the specific vectors we get, so
124          * pci_irq_vector() must be done *after* the reallocation.
125          *
126          * If we're using MSI, hardware is *allowed* to change the Interrupt
127          * Message Numbers when we free and reallocate the vectors, but we
128          * assume it won't because we allocate enough vectors for the
129          * biggest Message Number we found.
130          */
131         if (nvec != nr_entries) {
132                 pci_free_irq_vectors(dev);
133
134                 nr_entries = pci_alloc_irq_vectors(dev, nvec, nvec,
135                                 PCI_IRQ_MSIX | PCI_IRQ_MSI);
136                 if (nr_entries < 0)
137                         return nr_entries;
138         }
139
140         /* PME and hotplug share an MSI/MSI-X vector */
141         if (mask & (PCIE_PORT_SERVICE_PME | PCIE_PORT_SERVICE_HP)) {
142                 irqs[PCIE_PORT_SERVICE_PME_SHIFT] = pci_irq_vector(dev, pme);
143                 irqs[PCIE_PORT_SERVICE_HP_SHIFT] = pci_irq_vector(dev, pme);
144         }
145
146         if (mask & PCIE_PORT_SERVICE_AER)
147                 irqs[PCIE_PORT_SERVICE_AER_SHIFT] = pci_irq_vector(dev, aer);
148
149         if (mask & PCIE_PORT_SERVICE_DPC)
150                 irqs[PCIE_PORT_SERVICE_DPC_SHIFT] = pci_irq_vector(dev, dpc);
151
152         return 0;
153 }
154
155 /**
156  * pcie_init_service_irqs - initialize irqs for PCI Express port services
157  * @dev: PCI Express port to handle
158  * @irqs: Array of irqs to populate
159  * @mask: Bitmask of port capabilities returned by get_port_device_capability()
160  *
161  * Return value: Interrupt mode associated with the port
162  */
163 static int pcie_init_service_irqs(struct pci_dev *dev, int *irqs, int mask)
164 {
165         int ret, i;
166
167         for (i = 0; i < PCIE_PORT_DEVICE_MAXSERVICES; i++)
168                 irqs[i] = -1;
169
170         /*
171          * If we support PME or hotplug, but we can't use MSI/MSI-X for
172          * them, we have to fall back to INTx or other interrupts, e.g., a
173          * system shared interrupt.
174          */
175         if ((mask & PCIE_PORT_SERVICE_PME) && pcie_pme_no_msi())
176                 goto legacy_irq;
177
178         if ((mask & PCIE_PORT_SERVICE_HP) && pciehp_no_msi())
179                 goto legacy_irq;
180
181         /* Try to use MSI-X or MSI if supported */
182         if (pcie_port_enable_irq_vec(dev, irqs, mask) == 0)
183                 return 0;
184
185 legacy_irq:
186         /* fall back to legacy IRQ */
187         ret = pci_alloc_irq_vectors(dev, 1, 1, PCI_IRQ_LEGACY);
188         if (ret < 0)
189                 return -ENODEV;
190
191         for (i = 0; i < PCIE_PORT_DEVICE_MAXSERVICES; i++) {
192                 if (i != PCIE_PORT_SERVICE_VC_SHIFT)
193                         irqs[i] = pci_irq_vector(dev, 0);
194         }
195
196         return 0;
197 }
198
199 /**
200  * get_port_device_capability - discover capabilities of a PCI Express port
201  * @dev: PCI Express port to examine
202  *
203  * The capabilities are read from the port's PCI Express configuration registers
204  * as described in PCI Express Base Specification 1.0a sections 7.8.2, 7.8.9 and
205  * 7.9 - 7.11.
206  *
207  * Return value: Bitmask of discovered port capabilities
208  */
209 static int get_port_device_capability(struct pci_dev *dev)
210 {
211         int services = 0;
212         int cap_mask = 0;
213
214         if (pcie_ports_disabled)
215                 return 0;
216
217         cap_mask = PCIE_PORT_SERVICE_PME | PCIE_PORT_SERVICE_HP
218                         | PCIE_PORT_SERVICE_VC;
219         if (pci_aer_available())
220                 cap_mask |= PCIE_PORT_SERVICE_AER | PCIE_PORT_SERVICE_DPC;
221
222         if (pcie_ports_auto)
223                 pcie_port_platform_notify(dev, &cap_mask);
224
225         /* Hot-Plug Capable */
226         if ((cap_mask & PCIE_PORT_SERVICE_HP) && dev->is_hotplug_bridge) {
227                 services |= PCIE_PORT_SERVICE_HP;
228                 /*
229                  * Disable hot-plug interrupts in case they have been enabled
230                  * by the BIOS and the hot-plug service driver is not loaded.
231                  */
232                 pcie_capability_clear_word(dev, PCI_EXP_SLTCTL,
233                           PCI_EXP_SLTCTL_CCIE | PCI_EXP_SLTCTL_HPIE);
234         }
235         /* AER capable */
236         if ((cap_mask & PCIE_PORT_SERVICE_AER)
237             && pci_find_ext_capability(dev, PCI_EXT_CAP_ID_ERR)) {
238                 services |= PCIE_PORT_SERVICE_AER;
239                 /*
240                  * Disable AER on this port in case it's been enabled by the
241                  * BIOS (the AER service driver will enable it when necessary).
242                  */
243                 pci_disable_pcie_error_reporting(dev);
244         }
245         /* VC support */
246         if (pci_find_ext_capability(dev, PCI_EXT_CAP_ID_VC))
247                 services |= PCIE_PORT_SERVICE_VC;
248         /* Root ports are capable of generating PME too */
249         if ((cap_mask & PCIE_PORT_SERVICE_PME)
250             && pci_pcie_type(dev) == PCI_EXP_TYPE_ROOT_PORT) {
251                 services |= PCIE_PORT_SERVICE_PME;
252                 /*
253                  * Disable PME interrupt on this port in case it's been enabled
254                  * by the BIOS (the PME service driver will enable it when
255                  * necessary).
256                  */
257                 pcie_pme_interrupt_enable(dev, false);
258         }
259         if (pci_find_ext_capability(dev, PCI_EXT_CAP_ID_DPC))
260                 services |= PCIE_PORT_SERVICE_DPC;
261
262         return services;
263 }
264
265 /**
266  * pcie_device_init - allocate and initialize PCI Express port service device
267  * @pdev: PCI Express port to associate the service device with
268  * @service: Type of service to associate with the service device
269  * @irq: Interrupt vector to associate with the service device
270  */
271 static int pcie_device_init(struct pci_dev *pdev, int service, int irq)
272 {
273         int retval;
274         struct pcie_device *pcie;
275         struct device *device;
276
277         pcie = kzalloc(sizeof(*pcie), GFP_KERNEL);
278         if (!pcie)
279                 return -ENOMEM;
280         pcie->port = pdev;
281         pcie->irq = irq;
282         pcie->service = service;
283
284         /* Initialize generic device interface */
285         device = &pcie->device;
286         device->bus = &pcie_port_bus_type;
287         device->release = release_pcie_device;  /* callback to free pcie dev */
288         dev_set_name(device, "%s:pcie%03x",
289                      pci_name(pdev),
290                      get_descriptor_id(pci_pcie_type(pdev), service));
291         device->parent = &pdev->dev;
292         device_enable_async_suspend(device);
293
294         retval = device_register(device);
295         if (retval) {
296                 put_device(device);
297                 return retval;
298         }
299
300         pm_runtime_no_callbacks(device);
301
302         return 0;
303 }
304
305 /**
306  * pcie_port_device_register - register PCI Express port
307  * @dev: PCI Express port to register
308  *
309  * Allocate the port extension structure and register services associated with
310  * the port.
311  */
312 int pcie_port_device_register(struct pci_dev *dev)
313 {
314         int status, capabilities, i, nr_service;
315         int irqs[PCIE_PORT_DEVICE_MAXSERVICES];
316
317         /* Enable PCI Express port device */
318         status = pci_enable_device(dev);
319         if (status)
320                 return status;
321
322         /* Get and check PCI Express port services */
323         capabilities = get_port_device_capability(dev);
324         if (!capabilities)
325                 return 0;
326
327         pci_set_master(dev);
328         /*
329          * Initialize service irqs. Don't use service devices that
330          * require interrupts if there is no way to generate them.
331          * However, some drivers may have a polling mode (e.g. pciehp_poll_mode)
332          * that can be used in the absence of irqs.  Allow them to determine
333          * if that is to be used.
334          */
335         status = pcie_init_service_irqs(dev, irqs, capabilities);
336         if (status) {
337                 capabilities &= PCIE_PORT_SERVICE_VC | PCIE_PORT_SERVICE_HP;
338                 if (!capabilities)
339                         goto error_disable;
340         }
341
342         /* Allocate child services if any */
343         status = -ENODEV;
344         nr_service = 0;
345         for (i = 0; i < PCIE_PORT_DEVICE_MAXSERVICES; i++) {
346                 int service = 1 << i;
347                 if (!(capabilities & service))
348                         continue;
349                 if (!pcie_device_init(dev, service, irqs[i]))
350                         nr_service++;
351         }
352         if (!nr_service)
353                 goto error_cleanup_irqs;
354
355         return 0;
356
357 error_cleanup_irqs:
358         pci_free_irq_vectors(dev);
359 error_disable:
360         pci_disable_device(dev);
361         return status;
362 }
363
364 #ifdef CONFIG_PM
365 static int suspend_iter(struct device *dev, void *data)
366 {
367         struct pcie_port_service_driver *service_driver;
368
369         if ((dev->bus == &pcie_port_bus_type) && dev->driver) {
370                 service_driver = to_service_driver(dev->driver);
371                 if (service_driver->suspend)
372                         service_driver->suspend(to_pcie_device(dev));
373         }
374         return 0;
375 }
376
377 /**
378  * pcie_port_device_suspend - suspend port services associated with a PCIe port
379  * @dev: PCI Express port to handle
380  */
381 int pcie_port_device_suspend(struct device *dev)
382 {
383         return device_for_each_child(dev, NULL, suspend_iter);
384 }
385
386 static int resume_iter(struct device *dev, void *data)
387 {
388         struct pcie_port_service_driver *service_driver;
389
390         if ((dev->bus == &pcie_port_bus_type) &&
391             (dev->driver)) {
392                 service_driver = to_service_driver(dev->driver);
393                 if (service_driver->resume)
394                         service_driver->resume(to_pcie_device(dev));
395         }
396         return 0;
397 }
398
399 /**
400  * pcie_port_device_resume - resume port services associated with a PCIe port
401  * @dev: PCI Express port to handle
402  */
403 int pcie_port_device_resume(struct device *dev)
404 {
405         return device_for_each_child(dev, NULL, resume_iter);
406 }
407 #endif /* PM */
408
409 static int remove_iter(struct device *dev, void *data)
410 {
411         if (dev->bus == &pcie_port_bus_type)
412                 device_unregister(dev);
413         return 0;
414 }
415
416 /**
417  * pcie_port_device_remove - unregister PCI Express port service devices
418  * @dev: PCI Express port the service devices to unregister are associated with
419  *
420  * Remove PCI Express port service devices associated with given port and
421  * disable MSI-X or MSI for the port.
422  */
423 void pcie_port_device_remove(struct pci_dev *dev)
424 {
425         device_for_each_child(&dev->dev, NULL, remove_iter);
426         pci_free_irq_vectors(dev);
427         pci_disable_device(dev);
428 }
429
430 /**
431  * pcie_port_probe_service - probe driver for given PCI Express port service
432  * @dev: PCI Express port service device to probe against
433  *
434  * If PCI Express port service driver is registered with
435  * pcie_port_service_register(), this function will be called by the driver core
436  * whenever match is found between the driver and a port service device.
437  */
438 static int pcie_port_probe_service(struct device *dev)
439 {
440         struct pcie_device *pciedev;
441         struct pcie_port_service_driver *driver;
442         int status;
443
444         if (!dev || !dev->driver)
445                 return -ENODEV;
446
447         driver = to_service_driver(dev->driver);
448         if (!driver || !driver->probe)
449                 return -ENODEV;
450
451         pciedev = to_pcie_device(dev);
452         status = driver->probe(pciedev);
453         if (status)
454                 return status;
455
456         get_device(dev);
457         return 0;
458 }
459
460 /**
461  * pcie_port_remove_service - detach driver from given PCI Express port service
462  * @dev: PCI Express port service device to handle
463  *
464  * If PCI Express port service driver is registered with
465  * pcie_port_service_register(), this function will be called by the driver core
466  * when device_unregister() is called for the port service device associated
467  * with the driver.
468  */
469 static int pcie_port_remove_service(struct device *dev)
470 {
471         struct pcie_device *pciedev;
472         struct pcie_port_service_driver *driver;
473
474         if (!dev || !dev->driver)
475                 return 0;
476
477         pciedev = to_pcie_device(dev);
478         driver = to_service_driver(dev->driver);
479         if (driver && driver->remove) {
480                 driver->remove(pciedev);
481                 put_device(dev);
482         }
483         return 0;
484 }
485
486 /**
487  * pcie_port_shutdown_service - shut down given PCI Express port service
488  * @dev: PCI Express port service device to handle
489  *
490  * If PCI Express port service driver is registered with
491  * pcie_port_service_register(), this function will be called by the driver core
492  * when device_shutdown() is called for the port service device associated
493  * with the driver.
494  */
495 static void pcie_port_shutdown_service(struct device *dev) {}
496
497 /**
498  * pcie_port_service_register - register PCI Express port service driver
499  * @new: PCI Express port service driver to register
500  */
501 int pcie_port_service_register(struct pcie_port_service_driver *new)
502 {
503         if (pcie_ports_disabled)
504                 return -ENODEV;
505
506         new->driver.name = new->name;
507         new->driver.bus = &pcie_port_bus_type;
508         new->driver.probe = pcie_port_probe_service;
509         new->driver.remove = pcie_port_remove_service;
510         new->driver.shutdown = pcie_port_shutdown_service;
511
512         return driver_register(&new->driver);
513 }
514 EXPORT_SYMBOL(pcie_port_service_register);
515
516 /**
517  * pcie_port_service_unregister - unregister PCI Express port service driver
518  * @drv: PCI Express port service driver to unregister
519  */
520 void pcie_port_service_unregister(struct pcie_port_service_driver *drv)
521 {
522         driver_unregister(&drv->driver);
523 }
524 EXPORT_SYMBOL(pcie_port_service_unregister);