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_RECOVERED;
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);
299
|
This page was automatically generated by the
LXR engine.
|