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