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