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