PCI: portdrv: minor cleanup for pcie_port_device_register
[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 + PCIE_CAPABILITIES_REG, &reg16);
113                 entry = (reg16 >> 9) & PCIE_PORT_MSI_VECTOR_MASK;
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;
190
191         /* Try to use MSI-X if supported */
192         if (!pcie_port_enable_msix(dev, irqs, mask))
193                 return 0;
194         /* We're not going to use MSI-X, so try MSI and fall back to INTx */
195         irq = -1;
196         if (!pci_enable_msi(dev) || dev->pin)
197                 irq = dev->irq;
198
199         for (i = 0; i < PCIE_PORT_DEVICE_MAXSERVICES; i++)
200                 irqs[i] = irq;
201         irqs[PCIE_PORT_SERVICE_VC_SHIFT] = -1;
202
203         if (irq < 0)
204                 return -ENODEV;
205         return 0;
206 }
207
208 static void cleanup_service_irqs(struct pci_dev *dev)
209 {
210         if (dev->msix_enabled)
211                 pci_disable_msix(dev);
212         else if (dev->msi_enabled)
213                 pci_disable_msi(dev);
214 }
215
216 /**
217  * get_port_device_capability - discover capabilities of a PCI Express port
218  * @dev: PCI Express port to examine
219  *
220  * The capabilities are read from the port's PCI Express configuration registers
221  * as described in PCI Express Base Specification 1.0a sections 7.8.2, 7.8.9 and
222  * 7.9 - 7.11.
223  *
224  * Return value: Bitmask of discovered port capabilities
225  */
226 static int get_port_device_capability(struct pci_dev *dev)
227 {
228         int services = 0, pos;
229         u16 reg16;
230         u32 reg32;
231
232         pos = pci_pcie_cap(dev);
233         pci_read_config_word(dev, pos + PCIE_CAPABILITIES_REG, &reg16);
234         /* Hot-Plug Capable */
235         if (reg16 & PORT_TO_SLOT_MASK) {
236                 pci_read_config_dword(dev, 
237                         pos + PCIE_SLOT_CAPABILITIES_REG, &reg32);
238                 if (reg32 & SLOT_HP_CAPABLE_MASK)
239                         services |= PCIE_PORT_SERVICE_HP;
240         }
241         /* AER capable */
242         if (pci_find_ext_capability(dev, PCI_EXT_CAP_ID_ERR))
243                 services |= PCIE_PORT_SERVICE_AER;
244         /* VC support */
245         if (pci_find_ext_capability(dev, PCI_EXT_CAP_ID_VC))
246                 services |= PCIE_PORT_SERVICE_VC;
247         /* Root ports are capable of generating PME too */
248         if (dev->pcie_type == PCI_EXP_TYPE_ROOT_PORT)
249                 services |= PCIE_PORT_SERVICE_PME;
250
251         return services;
252 }
253
254 /**
255  * pcie_device_init - allocate and initialize PCI Express port service device
256  * @pdev: PCI Express port to associate the service device with
257  * @service: Type of service to associate with the service device
258  * @irq: Interrupt vector to associate with the service device
259  */
260 static int pcie_device_init(struct pci_dev *pdev, int service, int irq)
261 {
262         int retval;
263         struct pcie_device *pcie;
264         struct device *device;
265
266         pcie = kzalloc(sizeof(*pcie), GFP_KERNEL);
267         if (!pcie)
268                 return -ENOMEM;
269         pcie->port = pdev;
270         pcie->irq = irq;
271         pcie->service = service;
272
273         /* Initialize generic device interface */
274         device = &pcie->device;
275         device->bus = &pcie_port_bus_type;
276         device->release = release_pcie_device;  /* callback to free pcie dev */
277         dev_set_name(device, "%s:pcie%02x",
278                      pci_name(pdev),
279                      get_descriptor_id(pdev->pcie_type, service));
280         device->parent = &pdev->dev;
281
282         retval = device_register(device);
283         if (retval)
284                 kfree(pcie);
285         else
286                 get_device(device);
287         return retval;
288 }
289
290 /**
291  * pcie_port_device_register - register PCI Express port
292  * @dev: PCI Express port to register
293  *
294  * Allocate the port extension structure and register services associated with
295  * the port.
296  */
297 int pcie_port_device_register(struct pci_dev *dev)
298 {
299         struct pcie_port_data *port_data;
300         int status, capabilities, i, nr_service;
301         int irqs[PCIE_PORT_DEVICE_MAXSERVICES];
302
303         /* Get and check PCI Express port services */
304         capabilities = get_port_device_capability(dev);
305         if (!capabilities)
306                 return -ENODEV;
307
308         /* Allocate driver data for port device */
309         port_data = kzalloc(sizeof(*port_data), GFP_KERNEL);
310         if (!port_data)
311                 return -ENOMEM;
312         port_data->port_type = dev->pcie_type;
313         pci_set_drvdata(dev, port_data);
314
315         /* Enable PCI Express port device */
316         status = pci_enable_device(dev);
317         if (status)
318                 goto error_kfree;
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 error_kfree:
351         kfree(port_data);
352         return status;
353 }
354
355 #ifdef CONFIG_PM
356 static int suspend_iter(struct device *dev, void *data)
357 {
358         struct pcie_port_service_driver *service_driver;
359
360         if ((dev->bus == &pcie_port_bus_type) &&
361             (dev->driver)) {
362                 service_driver = to_service_driver(dev->driver);
363                 if (service_driver->suspend)
364                         service_driver->suspend(to_pcie_device(dev));
365         }
366         return 0;
367 }
368
369 /**
370  * pcie_port_device_suspend - suspend port services associated with a PCIe port
371  * @dev: PCI Express port to handle
372  */
373 int pcie_port_device_suspend(struct device *dev)
374 {
375         return device_for_each_child(dev, NULL, suspend_iter);
376 }
377
378 static int resume_iter(struct device *dev, void *data)
379 {
380         struct pcie_port_service_driver *service_driver;
381
382         if ((dev->bus == &pcie_port_bus_type) &&
383             (dev->driver)) {
384                 service_driver = to_service_driver(dev->driver);
385                 if (service_driver->resume)
386                         service_driver->resume(to_pcie_device(dev));
387         }
388         return 0;
389 }
390
391 /**
392  * pcie_port_device_suspend - resume port services associated with a PCIe port
393  * @dev: PCI Express port to handle
394  */
395 int pcie_port_device_resume(struct device *dev)
396 {
397         return device_for_each_child(dev, NULL, resume_iter);
398 }
399 #endif /* PM */
400
401 static int remove_iter(struct device *dev, void *data)
402 {
403         if (dev->bus == &pcie_port_bus_type) {
404                 put_device(dev);
405                 device_unregister(dev);
406         }
407         return 0;
408 }
409
410 /**
411  * pcie_port_device_remove - unregister PCI Express port service devices
412  * @dev: PCI Express port the service devices to unregister are associated with
413  *
414  * Remove PCI Express port service devices associated with given port and
415  * disable MSI-X or MSI for the port.
416  */
417 void pcie_port_device_remove(struct pci_dev *dev)
418 {
419         struct pcie_port_data *port_data = pci_get_drvdata(dev);
420
421         device_for_each_child(&dev->dev, NULL, remove_iter);
422         cleanup_service_irqs(dev);
423         pci_disable_device(dev);
424         kfree(port_data);
425 }
426
427 /**
428  * pcie_port_probe_service - probe driver for given PCI Express port service
429  * @dev: PCI Express port service device to probe against
430  *
431  * If PCI Express port service driver is registered with
432  * pcie_port_service_register(), this function will be called by the driver core
433  * whenever match is found between the driver and a port service device.
434  */
435 static int pcie_port_probe_service(struct device *dev)
436 {
437         struct pcie_device *pciedev;
438         struct pcie_port_service_driver *driver;
439         int status;
440
441         if (!dev || !dev->driver)
442                 return -ENODEV;
443
444         driver = to_service_driver(dev->driver);
445         if (!driver || !driver->probe)
446                 return -ENODEV;
447
448         pciedev = to_pcie_device(dev);
449         status = driver->probe(pciedev);
450         if (!status) {
451                 dev_printk(KERN_DEBUG, dev, "service driver %s loaded\n",
452                         driver->name);
453                 get_device(dev);
454         }
455         return status;
456 }
457
458 /**
459  * pcie_port_remove_service - detach driver from given PCI Express port service
460  * @dev: PCI Express port service device to handle
461  *
462  * If PCI Express port service driver is registered with
463  * pcie_port_service_register(), this function will be called by the driver core
464  * when device_unregister() is called for the port service device associated
465  * with the driver.
466  */
467 static int pcie_port_remove_service(struct device *dev)
468 {
469         struct pcie_device *pciedev;
470         struct pcie_port_service_driver *driver;
471
472         if (!dev || !dev->driver)
473                 return 0;
474
475         pciedev = to_pcie_device(dev);
476         driver = to_service_driver(dev->driver);
477         if (driver && driver->remove) {
478                 dev_printk(KERN_DEBUG, dev, "unloading service driver %s\n",
479                         driver->name);
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         new->driver.name = (char *)new->name;
504         new->driver.bus = &pcie_port_bus_type;
505         new->driver.probe = pcie_port_probe_service;
506         new->driver.remove = pcie_port_remove_service;
507         new->driver.shutdown = pcie_port_shutdown_service;
508
509         return driver_register(&new->driver);
510 }
511
512 /**
513  * pcie_port_service_unregister - unregister PCI Express port service driver
514  * @drv: PCI Express port service driver to unregister
515  */
516 void pcie_port_service_unregister(struct pcie_port_service_driver *drv)
517 {
518         driver_unregister(&drv->driver);
519 }
520
521 EXPORT_SYMBOL(pcie_port_service_register);
522 EXPORT_SYMBOL(pcie_port_service_unregister);