Loading...
Note: File does not exist in v6.8.
1/*
2 * File: portdrv_core.c
3 * Purpose: PCI Express Port Bus Driver's Core Functions
4 *
5 * Copyright (C) 2004 Intel
6 * Copyright (C) Tom Long Nguyen (tom.l.nguyen@intel.com)
7 */
8
9#include <linux/module.h>
10#include <linux/pci.h>
11#include <linux/kernel.h>
12#include <linux/errno.h>
13#include <linux/pm.h>
14#include <linux/string.h>
15#include <linux/slab.h>
16#include <linux/pcieport_if.h>
17#include <linux/aer.h>
18
19#include "../pci.h"
20#include "portdrv.h"
21
22bool pciehp_msi_disabled;
23
24static int __init pciehp_setup(char *str)
25{
26 if (!strncmp(str, "nomsi", 5))
27 pciehp_msi_disabled = true;
28
29 return 1;
30}
31__setup("pcie_hp=", pciehp_setup);
32
33/**
34 * release_pcie_device - free PCI Express port service device structure
35 * @dev: Port service device to release
36 *
37 * Invoked automatically when device is being removed in response to
38 * device_unregister(dev). Release all resources being claimed.
39 */
40static void release_pcie_device(struct device *dev)
41{
42 kfree(to_pcie_device(dev));
43}
44
45/**
46 * pcie_port_msix_add_entry - add entry to given array of MSI-X entries
47 * @entries: Array of MSI-X entries
48 * @new_entry: Index of the entry to add to the array
49 * @nr_entries: Number of entries already in the array
50 *
51 * Return value: Position of the added entry in the array
52 */
53static int pcie_port_msix_add_entry(
54 struct msix_entry *entries, int new_entry, int nr_entries)
55{
56 int j;
57
58 for (j = 0; j < nr_entries; j++)
59 if (entries[j].entry == new_entry)
60 return j;
61
62 entries[j].entry = new_entry;
63 return j;
64}
65
66/**
67 * pcie_port_enable_msix - try to set up MSI-X as interrupt mode for given port
68 * @dev: PCI Express port to handle
69 * @vectors: Array of interrupt vectors to populate
70 * @mask: Bitmask of port capabilities returned by get_port_device_capability()
71 *
72 * Return value: 0 on success, error code on failure
73 */
74static int pcie_port_enable_msix(struct pci_dev *dev, int *vectors, int mask)
75{
76 struct msix_entry *msix_entries;
77 int idx[PCIE_PORT_DEVICE_MAXSERVICES];
78 int nr_entries, status, pos, i, nvec;
79 u16 reg16;
80 u32 reg32;
81
82 nr_entries = pci_msix_vec_count(dev);
83 if (nr_entries < 0)
84 return nr_entries;
85 BUG_ON(!nr_entries);
86 if (nr_entries > PCIE_PORT_MAX_MSIX_ENTRIES)
87 nr_entries = PCIE_PORT_MAX_MSIX_ENTRIES;
88
89 msix_entries = kzalloc(sizeof(*msix_entries) * nr_entries, GFP_KERNEL);
90 if (!msix_entries)
91 return -ENOMEM;
92
93 /*
94 * Allocate as many entries as the port wants, so that we can check
95 * which of them will be useful. Moreover, if nr_entries is correctly
96 * equal to the number of entries this port actually uses, we'll happily
97 * go through without any tricks.
98 */
99 for (i = 0; i < nr_entries; i++)
100 msix_entries[i].entry = i;
101
102 status = pci_enable_msix(dev, msix_entries, nr_entries);
103 if (status)
104 goto Exit;
105
106 for (i = 0; i < PCIE_PORT_DEVICE_MAXSERVICES; i++)
107 idx[i] = -1;
108 status = -EIO;
109 nvec = 0;
110
111 if (mask & (PCIE_PORT_SERVICE_PME | PCIE_PORT_SERVICE_HP)) {
112 int entry;
113
114 /*
115 * The code below follows the PCI Express Base Specification 2.0
116 * stating in Section 6.1.6 that "PME and Hot-Plug Event
117 * interrupts (when both are implemented) always share the same
118 * MSI or MSI-X vector, as indicated by the Interrupt Message
119 * Number field in the PCI Express Capabilities register", where
120 * according to Section 7.8.2 of the specification "For MSI-X,
121 * the value in this field indicates which MSI-X Table entry is
122 * used to generate the interrupt message."
123 */
124 pcie_capability_read_word(dev, PCI_EXP_FLAGS, ®16);
125 entry = (reg16 & PCI_EXP_FLAGS_IRQ) >> 9;
126 if (entry >= nr_entries)
127 goto Error;
128
129 i = pcie_port_msix_add_entry(msix_entries, entry, nvec);
130 if (i == nvec)
131 nvec++;
132
133 idx[PCIE_PORT_SERVICE_PME_SHIFT] = i;
134 idx[PCIE_PORT_SERVICE_HP_SHIFT] = i;
135 }
136
137 if (mask & PCIE_PORT_SERVICE_AER) {
138 int entry;
139
140 /*
141 * The code below follows Section 7.10.10 of the PCI Express
142 * Base Specification 2.0 stating that bits 31-27 of the Root
143 * Error Status Register contain a value indicating which of the
144 * MSI/MSI-X vectors assigned to the port is going to be used
145 * for AER, where "For MSI-X, the value in this register
146 * indicates which MSI-X Table entry is used to generate the
147 * interrupt message."
148 */
149 pos = pci_find_ext_capability(dev, PCI_EXT_CAP_ID_ERR);
150 pci_read_config_dword(dev, pos + PCI_ERR_ROOT_STATUS, ®32);
151 entry = reg32 >> 27;
152 if (entry >= nr_entries)
153 goto Error;
154
155 i = pcie_port_msix_add_entry(msix_entries, entry, nvec);
156 if (i == nvec)
157 nvec++;
158
159 idx[PCIE_PORT_SERVICE_AER_SHIFT] = i;
160 }
161
162 /*
163 * If nvec is equal to the allocated number of entries, we can just use
164 * what we have. Otherwise, the port has some extra entries not for the
165 * services we know and we need to work around that.
166 */
167 if (nvec == nr_entries) {
168 status = 0;
169 } else {
170 /* Drop the temporary MSI-X setup */
171 pci_disable_msix(dev);
172
173 /* Now allocate the MSI-X vectors for real */
174 status = pci_enable_msix(dev, msix_entries, nvec);
175 if (status)
176 goto Exit;
177 }
178
179 for (i = 0; i < PCIE_PORT_DEVICE_MAXSERVICES; i++)
180 vectors[i] = idx[i] >= 0 ? msix_entries[idx[i]].vector : -1;
181
182 Exit:
183 kfree(msix_entries);
184 return status;
185
186 Error:
187 pci_disable_msix(dev);
188 goto Exit;
189}
190
191/**
192 * init_service_irqs - initialize irqs for PCI Express port services
193 * @dev: PCI Express port to handle
194 * @irqs: Array of irqs to populate
195 * @mask: Bitmask of port capabilities returned by get_port_device_capability()
196 *
197 * Return value: Interrupt mode associated with the port
198 */
199static int init_service_irqs(struct pci_dev *dev, int *irqs, int mask)
200{
201 int i, irq = -1;
202
203 /*
204 * If MSI cannot be used for PCIe PME or hotplug, we have to use
205 * INTx or other interrupts, e.g. system shared interrupt.
206 */
207 if (((mask & PCIE_PORT_SERVICE_PME) && pcie_pme_no_msi()) ||
208 ((mask & PCIE_PORT_SERVICE_HP) && pciehp_no_msi())) {
209 if (dev->irq)
210 irq = dev->irq;
211 goto no_msi;
212 }
213
214 /* Try to use MSI-X if supported */
215 if (!pcie_port_enable_msix(dev, irqs, mask))
216 return 0;
217
218 /*
219 * We're not going to use MSI-X, so try MSI and fall back to INTx.
220 * If neither MSI/MSI-X nor INTx available, try other interrupt. On
221 * some platforms, root port doesn't support MSI/MSI-X/INTx in RC mode.
222 */
223 if (!pci_enable_msi(dev) || dev->irq)
224 irq = dev->irq;
225
226 no_msi:
227 for (i = 0; i < PCIE_PORT_DEVICE_MAXSERVICES; i++)
228 irqs[i] = irq;
229 irqs[PCIE_PORT_SERVICE_VC_SHIFT] = -1;
230
231 if (irq < 0)
232 return -ENODEV;
233 return 0;
234}
235
236static void cleanup_service_irqs(struct pci_dev *dev)
237{
238 if (dev->msix_enabled)
239 pci_disable_msix(dev);
240 else if (dev->msi_enabled)
241 pci_disable_msi(dev);
242}
243
244/**
245 * get_port_device_capability - discover capabilities of a PCI Express port
246 * @dev: PCI Express port to examine
247 *
248 * The capabilities are read from the port's PCI Express configuration registers
249 * as described in PCI Express Base Specification 1.0a sections 7.8.2, 7.8.9 and
250 * 7.9 - 7.11.
251 *
252 * Return value: Bitmask of discovered port capabilities
253 */
254static int get_port_device_capability(struct pci_dev *dev)
255{
256 int services = 0;
257 u32 reg32;
258 int cap_mask = 0;
259 int err;
260
261 if (pcie_ports_disabled)
262 return 0;
263
264 cap_mask = PCIE_PORT_SERVICE_PME | PCIE_PORT_SERVICE_HP
265 | PCIE_PORT_SERVICE_VC;
266 if (pci_aer_available())
267 cap_mask |= PCIE_PORT_SERVICE_AER;
268
269 if (pcie_ports_auto) {
270 err = pcie_port_platform_notify(dev, &cap_mask);
271 if (err)
272 return 0;
273 }
274
275 /* Hot-Plug Capable */
276 if ((cap_mask & PCIE_PORT_SERVICE_HP) &&
277 pcie_caps_reg(dev) & PCI_EXP_FLAGS_SLOT) {
278 pcie_capability_read_dword(dev, PCI_EXP_SLTCAP, ®32);
279 if (reg32 & PCI_EXP_SLTCAP_HPC) {
280 services |= PCIE_PORT_SERVICE_HP;
281 /*
282 * Disable hot-plug interrupts in case they have been
283 * enabled by the BIOS and the hot-plug service driver
284 * is not loaded.
285 */
286 pcie_capability_clear_word(dev, PCI_EXP_SLTCTL,
287 PCI_EXP_SLTCTL_CCIE | PCI_EXP_SLTCTL_HPIE);
288 }
289 }
290 /* AER capable */
291 if ((cap_mask & PCIE_PORT_SERVICE_AER)
292 && pci_find_ext_capability(dev, PCI_EXT_CAP_ID_ERR)) {
293 services |= PCIE_PORT_SERVICE_AER;
294 /*
295 * Disable AER on this port in case it's been enabled by the
296 * BIOS (the AER service driver will enable it when necessary).
297 */
298 pci_disable_pcie_error_reporting(dev);
299 }
300 /* VC support */
301 if (pci_find_ext_capability(dev, PCI_EXT_CAP_ID_VC))
302 services |= PCIE_PORT_SERVICE_VC;
303 /* Root ports are capable of generating PME too */
304 if ((cap_mask & PCIE_PORT_SERVICE_PME)
305 && pci_pcie_type(dev) == PCI_EXP_TYPE_ROOT_PORT) {
306 services |= PCIE_PORT_SERVICE_PME;
307 /*
308 * Disable PME interrupt on this port in case it's been enabled
309 * by the BIOS (the PME service driver will enable it when
310 * necessary).
311 */
312 pcie_pme_interrupt_enable(dev, false);
313 }
314
315 return services;
316}
317
318/**
319 * pcie_device_init - allocate and initialize PCI Express port service device
320 * @pdev: PCI Express port to associate the service device with
321 * @service: Type of service to associate with the service device
322 * @irq: Interrupt vector to associate with the service device
323 */
324static int pcie_device_init(struct pci_dev *pdev, int service, int irq)
325{
326 int retval;
327 struct pcie_device *pcie;
328 struct device *device;
329
330 pcie = kzalloc(sizeof(*pcie), GFP_KERNEL);
331 if (!pcie)
332 return -ENOMEM;
333 pcie->port = pdev;
334 pcie->irq = irq;
335 pcie->service = service;
336
337 /* Initialize generic device interface */
338 device = &pcie->device;
339 device->bus = &pcie_port_bus_type;
340 device->release = release_pcie_device; /* callback to free pcie dev */
341 dev_set_name(device, "%s:pcie%02x",
342 pci_name(pdev),
343 get_descriptor_id(pci_pcie_type(pdev), service));
344 device->parent = &pdev->dev;
345 device_enable_async_suspend(device);
346
347 retval = device_register(device);
348 if (retval) {
349 put_device(device);
350 return retval;
351 }
352
353 return 0;
354}
355
356/**
357 * pcie_port_device_register - register PCI Express port
358 * @dev: PCI Express port to register
359 *
360 * Allocate the port extension structure and register services associated with
361 * the port.
362 */
363int pcie_port_device_register(struct pci_dev *dev)
364{
365 int status, capabilities, i, nr_service;
366 int irqs[PCIE_PORT_DEVICE_MAXSERVICES];
367
368 /* Enable PCI Express port device */
369 status = pci_enable_device(dev);
370 if (status)
371 return status;
372
373 /* Get and check PCI Express port services */
374 capabilities = get_port_device_capability(dev);
375 if (!capabilities)
376 return 0;
377
378 pci_set_master(dev);
379 /*
380 * Initialize service irqs. Don't use service devices that
381 * require interrupts if there is no way to generate them.
382 */
383 status = init_service_irqs(dev, irqs, capabilities);
384 if (status) {
385 capabilities &= PCIE_PORT_SERVICE_VC;
386 if (!capabilities)
387 goto error_disable;
388 }
389
390 /* Allocate child services if any */
391 status = -ENODEV;
392 nr_service = 0;
393 for (i = 0; i < PCIE_PORT_DEVICE_MAXSERVICES; i++) {
394 int service = 1 << i;
395 if (!(capabilities & service))
396 continue;
397 if (!pcie_device_init(dev, service, irqs[i]))
398 nr_service++;
399 }
400 if (!nr_service)
401 goto error_cleanup_irqs;
402
403 return 0;
404
405error_cleanup_irqs:
406 cleanup_service_irqs(dev);
407error_disable:
408 pci_disable_device(dev);
409 return status;
410}
411
412#ifdef CONFIG_PM
413static int suspend_iter(struct device *dev, void *data)
414{
415 struct pcie_port_service_driver *service_driver;
416
417 if ((dev->bus == &pcie_port_bus_type) && dev->driver) {
418 service_driver = to_service_driver(dev->driver);
419 if (service_driver->suspend)
420 service_driver->suspend(to_pcie_device(dev));
421 }
422 return 0;
423}
424
425/**
426 * pcie_port_device_suspend - suspend port services associated with a PCIe port
427 * @dev: PCI Express port to handle
428 */
429int pcie_port_device_suspend(struct device *dev)
430{
431 return device_for_each_child(dev, NULL, suspend_iter);
432}
433
434static int resume_iter(struct device *dev, void *data)
435{
436 struct pcie_port_service_driver *service_driver;
437
438 if ((dev->bus == &pcie_port_bus_type) &&
439 (dev->driver)) {
440 service_driver = to_service_driver(dev->driver);
441 if (service_driver->resume)
442 service_driver->resume(to_pcie_device(dev));
443 }
444 return 0;
445}
446
447/**
448 * pcie_port_device_suspend - resume port services associated with a PCIe port
449 * @dev: PCI Express port to handle
450 */
451int pcie_port_device_resume(struct device *dev)
452{
453 return device_for_each_child(dev, NULL, resume_iter);
454}
455#endif /* PM */
456
457static int remove_iter(struct device *dev, void *data)
458{
459 if (dev->bus == &pcie_port_bus_type)
460 device_unregister(dev);
461 return 0;
462}
463
464/**
465 * pcie_port_device_remove - unregister PCI Express port service devices
466 * @dev: PCI Express port the service devices to unregister are associated with
467 *
468 * Remove PCI Express port service devices associated with given port and
469 * disable MSI-X or MSI for the port.
470 */
471void pcie_port_device_remove(struct pci_dev *dev)
472{
473 device_for_each_child(&dev->dev, NULL, remove_iter);
474 cleanup_service_irqs(dev);
475 pci_disable_device(dev);
476}
477
478/**
479 * pcie_port_probe_service - probe driver for given PCI Express port service
480 * @dev: PCI Express port service device to probe against
481 *
482 * If PCI Express port service driver is registered with
483 * pcie_port_service_register(), this function will be called by the driver core
484 * whenever match is found between the driver and a port service device.
485 */
486static int pcie_port_probe_service(struct device *dev)
487{
488 struct pcie_device *pciedev;
489 struct pcie_port_service_driver *driver;
490 int status;
491
492 if (!dev || !dev->driver)
493 return -ENODEV;
494
495 driver = to_service_driver(dev->driver);
496 if (!driver || !driver->probe)
497 return -ENODEV;
498
499 pciedev = to_pcie_device(dev);
500 status = driver->probe(pciedev);
501 if (status)
502 return status;
503
504 dev_printk(KERN_DEBUG, dev, "service driver %s loaded\n", driver->name);
505 get_device(dev);
506 return 0;
507}
508
509/**
510 * pcie_port_remove_service - detach driver from given PCI Express port service
511 * @dev: PCI Express port service device to handle
512 *
513 * If PCI Express port service driver is registered with
514 * pcie_port_service_register(), this function will be called by the driver core
515 * when device_unregister() is called for the port service device associated
516 * with the driver.
517 */
518static int pcie_port_remove_service(struct device *dev)
519{
520 struct pcie_device *pciedev;
521 struct pcie_port_service_driver *driver;
522
523 if (!dev || !dev->driver)
524 return 0;
525
526 pciedev = to_pcie_device(dev);
527 driver = to_service_driver(dev->driver);
528 if (driver && driver->remove) {
529 dev_printk(KERN_DEBUG, dev, "unloading service driver %s\n",
530 driver->name);
531 driver->remove(pciedev);
532 put_device(dev);
533 }
534 return 0;
535}
536
537/**
538 * pcie_port_shutdown_service - shut down given PCI Express port service
539 * @dev: PCI Express port service device to handle
540 *
541 * If PCI Express port service driver is registered with
542 * pcie_port_service_register(), this function will be called by the driver core
543 * when device_shutdown() is called for the port service device associated
544 * with the driver.
545 */
546static void pcie_port_shutdown_service(struct device *dev) {}
547
548/**
549 * pcie_port_service_register - register PCI Express port service driver
550 * @new: PCI Express port service driver to register
551 */
552int pcie_port_service_register(struct pcie_port_service_driver *new)
553{
554 if (pcie_ports_disabled)
555 return -ENODEV;
556
557 new->driver.name = new->name;
558 new->driver.bus = &pcie_port_bus_type;
559 new->driver.probe = pcie_port_probe_service;
560 new->driver.remove = pcie_port_remove_service;
561 new->driver.shutdown = pcie_port_shutdown_service;
562
563 return driver_register(&new->driver);
564}
565EXPORT_SYMBOL(pcie_port_service_register);
566
567/**
568 * pcie_port_service_unregister - unregister PCI Express port service driver
569 * @drv: PCI Express port service driver to unregister
570 */
571void pcie_port_service_unregister(struct pcie_port_service_driver *drv)
572{
573 driver_unregister(&drv->driver);
574}
575EXPORT_SYMBOL(pcie_port_service_unregister);