Merge branch 'master' into for-linus
[linux-2.6] / drivers / pci / pcie / portdrv_pci.c
1 /*
2  * File:        portdrv_pci.c
3  * Purpose:     PCI Express Port Bus Driver
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/init.h>
15 #include <linux/slab.h>
16 #include <linux/pcieport_if.h>
17 #include <linux/aer.h>
18
19 #include "portdrv.h"
20 #include "aer/aerdrv.h"
21
22 /*
23  * Version Information
24  */
25 #define DRIVER_VERSION "v1.0"
26 #define DRIVER_AUTHOR "tom.l.nguyen@intel.com"
27 #define DRIVER_DESC "PCIE Port Bus Driver"
28 MODULE_AUTHOR(DRIVER_AUTHOR);
29 MODULE_DESCRIPTION(DRIVER_DESC);
30 MODULE_LICENSE("GPL");
31
32 /* global data */
33 static const char device_name[] = "pcieport-driver";
34
35 static int pcie_portdrv_restore_config(struct pci_dev *dev)
36 {
37         int retval;
38
39         retval = pci_enable_device(dev);
40         if (retval)
41                 return retval;
42         pci_set_master(dev);
43         return 0;
44 }
45
46 #ifdef CONFIG_PM
47 static struct dev_pm_ops pcie_portdrv_pm_ops = {
48         .suspend        = pcie_port_device_suspend,
49         .resume         = pcie_port_device_resume,
50         .freeze         = pcie_port_device_suspend,
51         .thaw           = pcie_port_device_resume,
52         .poweroff       = pcie_port_device_suspend,
53         .restore        = pcie_port_device_resume,
54 };
55
56 #define PCIE_PORTDRV_PM_OPS     (&pcie_portdrv_pm_ops)
57
58 #else /* !PM */
59
60 #define PCIE_PORTDRV_PM_OPS     NULL
61 #endif /* !PM */
62
63 /*
64  * pcie_portdrv_probe - Probe PCI-Express port devices
65  * @dev: PCI-Express port device being probed
66  *
67  * If detected invokes the pcie_port_device_register() method for 
68  * this port device.
69  *
70  */
71 static int __devinit pcie_portdrv_probe (struct pci_dev *dev, 
72                                 const struct pci_device_id *id )
73 {
74         int                     status;
75
76         status = pcie_port_device_probe(dev);
77         if (status)
78                 return status;
79
80         if (!dev->irq && dev->pin) {
81                 dev_warn(&dev->dev, "device [%04x:%04x] has invalid IRQ; "
82                          "check vendor BIOS\n", dev->vendor, dev->device);
83         }
84         status = pcie_port_device_register(dev);
85         if (status)
86                 return status;
87
88         pci_save_state(dev);
89
90         return 0;
91 }
92
93 static void pcie_portdrv_remove (struct pci_dev *dev)
94 {
95         pcie_port_device_remove(dev);
96         pci_disable_device(dev);
97 }
98
99 static int error_detected_iter(struct device *device, void *data)
100 {
101         struct pcie_device *pcie_device;
102         struct pcie_port_service_driver *driver;
103         struct aer_broadcast_data *result_data;
104         pci_ers_result_t status;
105
106         result_data = (struct aer_broadcast_data *) data;
107
108         if (device->bus == &pcie_port_bus_type && device->driver) {
109                 driver = to_service_driver(device->driver);
110                 if (!driver ||
111                         !driver->err_handler ||
112                         !driver->err_handler->error_detected)
113                         return 0;
114
115                 pcie_device = to_pcie_device(device);
116
117                 /* Forward error detected message to service drivers */
118                 status = driver->err_handler->error_detected(
119                         pcie_device->port,
120                         result_data->state);
121                 result_data->result =
122                         merge_result(result_data->result, status);
123         }
124
125         return 0;
126 }
127
128 static pci_ers_result_t pcie_portdrv_error_detected(struct pci_dev *dev,
129                                         enum pci_channel_state error)
130 {
131         struct aer_broadcast_data result_data =
132                         {error, PCI_ERS_RESULT_CAN_RECOVER};
133         int retval;
134
135         /* can not fail */
136         retval = device_for_each_child(&dev->dev, &result_data, error_detected_iter);
137
138         return result_data.result;
139 }
140
141 static int mmio_enabled_iter(struct device *device, void *data)
142 {
143         struct pcie_device *pcie_device;
144         struct pcie_port_service_driver *driver;
145         pci_ers_result_t status, *result;
146
147         result = (pci_ers_result_t *) data;
148
149         if (device->bus == &pcie_port_bus_type && device->driver) {
150                 driver = to_service_driver(device->driver);
151                 if (driver &&
152                         driver->err_handler &&
153                         driver->err_handler->mmio_enabled) {
154                         pcie_device = to_pcie_device(device);
155
156                         /* Forward error message to service drivers */
157                         status = driver->err_handler->mmio_enabled(
158                                         pcie_device->port);
159                         *result = merge_result(*result, status);
160                 }
161         }
162
163         return 0;
164 }
165
166 static pci_ers_result_t pcie_portdrv_mmio_enabled(struct pci_dev *dev)
167 {
168         pci_ers_result_t status = PCI_ERS_RESULT_RECOVERED;
169         int retval;
170
171         /* get true return value from &status */
172         retval = device_for_each_child(&dev->dev, &status, mmio_enabled_iter);
173         return status;
174 }
175
176 static int slot_reset_iter(struct device *device, void *data)
177 {
178         struct pcie_device *pcie_device;
179         struct pcie_port_service_driver *driver;
180         pci_ers_result_t status, *result;
181
182         result = (pci_ers_result_t *) data;
183
184         if (device->bus == &pcie_port_bus_type && device->driver) {
185                 driver = to_service_driver(device->driver);
186                 if (driver &&
187                         driver->err_handler &&
188                         driver->err_handler->slot_reset) {
189                         pcie_device = to_pcie_device(device);
190
191                         /* Forward error message to service drivers */
192                         status = driver->err_handler->slot_reset(
193                                         pcie_device->port);
194                         *result = merge_result(*result, status);
195                 }
196         }
197
198         return 0;
199 }
200
201 static pci_ers_result_t pcie_portdrv_slot_reset(struct pci_dev *dev)
202 {
203         pci_ers_result_t status = PCI_ERS_RESULT_NONE;
204         int retval;
205
206         /* If fatal, restore cfg space for possible link reset at upstream */
207         if (dev->error_state == pci_channel_io_frozen) {
208                 pci_restore_state(dev);
209                 pcie_portdrv_restore_config(dev);
210                 pci_enable_pcie_error_reporting(dev);
211         }
212
213         /* get true return value from &status */
214         retval = device_for_each_child(&dev->dev, &status, slot_reset_iter);
215
216         return status;
217 }
218
219 static int resume_iter(struct device *device, void *data)
220 {
221         struct pcie_device *pcie_device;
222         struct pcie_port_service_driver *driver;
223
224         if (device->bus == &pcie_port_bus_type && device->driver) {
225                 driver = to_service_driver(device->driver);
226                 if (driver &&
227                         driver->err_handler &&
228                         driver->err_handler->resume) {
229                         pcie_device = to_pcie_device(device);
230
231                         /* Forward error message to service drivers */
232                         driver->err_handler->resume(pcie_device->port);
233                 }
234         }
235
236         return 0;
237 }
238
239 static void pcie_portdrv_err_resume(struct pci_dev *dev)
240 {
241         int retval;
242         /* nothing to do with error value, if it ever happens */
243         retval = device_for_each_child(&dev->dev, NULL, resume_iter);
244 }
245
246 /*
247  * LINUX Device Driver Model
248  */
249 static const struct pci_device_id port_pci_ids[] = { {
250         /* handle any PCI-Express port */
251         PCI_DEVICE_CLASS(((PCI_CLASS_BRIDGE_PCI << 8) | 0x00), ~0),
252         }, { /* end: all zeroes */ }
253 };
254 MODULE_DEVICE_TABLE(pci, port_pci_ids);
255
256 static struct pci_error_handlers pcie_portdrv_err_handler = {
257                 .error_detected = pcie_portdrv_error_detected,
258                 .mmio_enabled = pcie_portdrv_mmio_enabled,
259                 .slot_reset = pcie_portdrv_slot_reset,
260                 .resume = pcie_portdrv_err_resume,
261 };
262
263 static struct pci_driver pcie_portdriver = {
264         .name           = (char *)device_name,
265         .id_table       = &port_pci_ids[0],
266
267         .probe          = pcie_portdrv_probe,
268         .remove         = pcie_portdrv_remove,
269
270         .err_handler    = &pcie_portdrv_err_handler,
271
272         .driver.pm      = PCIE_PORTDRV_PM_OPS,
273 };
274
275 static int __init pcie_portdrv_init(void)
276 {
277         int retval;
278
279         retval = pcie_port_bus_register();
280         if (retval) {
281                 printk(KERN_WARNING "PCIE: bus_register error: %d\n", retval);
282                 goto out;
283         }
284         retval = pci_register_driver(&pcie_portdriver);
285         if (retval)
286                 pcie_port_bus_unregister();
287  out:
288         return retval;
289 }
290
291 static void __exit pcie_portdrv_exit(void) 
292 {
293         pci_unregister_driver(&pcie_portdriver);
294         pcie_port_bus_unregister();
295 }
296
297 module_init(pcie_portdrv_init);
298 module_exit(pcie_portdrv_exit);