484cc55194b8841809218cb15d5f2ccccdffd582
[linux-2.6.git] / drivers / pci / pcie / aer / aerdrv.c
1 /*
2  * drivers/pci/pcie/aer/aerdrv.c
3  *
4  * This file is subject to the terms and conditions of the GNU General Public
5  * License.  See the file "COPYING" in the main directory of this archive
6  * for more details.
7  *
8  * This file implements the AER root port service driver. The driver will
9  * register an irq handler. When root port triggers an AER interrupt, the irq
10  * handler will collect root port status and schedule a work.
11  *
12  * Copyright (C) 2006 Intel Corp.
13  *      Tom Long Nguyen (tom.l.nguyen@intel.com)
14  *      Zhang Yanmin (yanmin.zhang@intel.com)
15  *
16  */
17
18 #include <linux/module.h>
19 #include <linux/pci.h>
20 #include <linux/sched.h>
21 #include <linux/kernel.h>
22 #include <linux/errno.h>
23 #include <linux/pm.h>
24 #include <linux/init.h>
25 #include <linux/interrupt.h>
26 #include <linux/delay.h>
27 #include <linux/pcieport_if.h>
28 #include <linux/slab.h>
29
30 #include "aerdrv.h"
31 #include "../../pci.h"
32
33 /*
34  * Version Information
35  */
36 #define DRIVER_VERSION "v1.0"
37 #define DRIVER_AUTHOR "tom.l.nguyen@intel.com"
38 #define DRIVER_DESC "Root Port Advanced Error Reporting Driver"
39 MODULE_AUTHOR(DRIVER_AUTHOR);
40 MODULE_DESCRIPTION(DRIVER_DESC);
41 MODULE_LICENSE("GPL");
42
43 static int __devinit aer_probe(struct pcie_device *dev);
44 static void aer_remove(struct pcie_device *dev);
45 static pci_ers_result_t aer_error_detected(struct pci_dev *dev,
46         enum pci_channel_state error);
47 static void aer_error_resume(struct pci_dev *dev);
48 static pci_ers_result_t aer_root_reset(struct pci_dev *dev);
49
50 static struct pci_error_handlers aer_error_handlers = {
51         .error_detected = aer_error_detected,
52         .resume         = aer_error_resume,
53 };
54
55 static struct pcie_port_service_driver aerdriver = {
56         .name           = "aer",
57         .port_type      = PCI_EXP_TYPE_ROOT_PORT,
58         .service        = PCIE_PORT_SERVICE_AER,
59
60         .probe          = aer_probe,
61         .remove         = aer_remove,
62
63         .err_handler    = &aer_error_handlers,
64
65         .reset_link     = aer_root_reset,
66 };
67
68 static int pcie_aer_disable;
69
70 void pci_no_aer(void)
71 {
72         pcie_aer_disable = 1;   /* has priority over 'forceload' */
73 }
74
75 static int set_device_error_reporting(struct pci_dev *dev, void *data)
76 {
77         bool enable = *((bool *)data);
78
79         if ((dev->pcie_type == PCI_EXP_TYPE_ROOT_PORT) ||
80             (dev->pcie_type == PCI_EXP_TYPE_UPSTREAM) ||
81             (dev->pcie_type == PCI_EXP_TYPE_DOWNSTREAM)) {
82                 if (enable)
83                         pci_enable_pcie_error_reporting(dev);
84                 else
85                         pci_disable_pcie_error_reporting(dev);
86         }
87
88         if (enable)
89                 pcie_set_ecrc_checking(dev);
90
91         return 0;
92 }
93
94 /**
95  * set_downstream_devices_error_reporting - enable/disable the error reporting  bits on the root port and its downstream ports.
96  * @dev: pointer to root port's pci_dev data structure
97  * @enable: true = enable error reporting, false = disable error reporting.
98  */
99 static void set_downstream_devices_error_reporting(struct pci_dev *dev,
100                                                    bool enable)
101 {
102         set_device_error_reporting(dev, &enable);
103
104         if (!dev->subordinate)
105                 return;
106         pci_walk_bus(dev->subordinate, set_device_error_reporting, &enable);
107 }
108
109 /**
110  * aer_enable_rootport - enable Root Port's interrupts when receiving messages
111  * @rpc: pointer to a Root Port data structure
112  *
113  * Invoked when PCIe bus loads AER service driver.
114  */
115 static void aer_enable_rootport(struct aer_rpc *rpc)
116 {
117         struct pci_dev *pdev = rpc->rpd->port;
118         int pos, aer_pos;
119         u16 reg16;
120         u32 reg32;
121
122         pos = pci_pcie_cap(pdev);
123         /* Clear PCIe Capability's Device Status */
124         pci_read_config_word(pdev, pos+PCI_EXP_DEVSTA, &reg16);
125         pci_write_config_word(pdev, pos+PCI_EXP_DEVSTA, reg16);
126
127         /* Disable system error generation in response to error messages */
128         pci_read_config_word(pdev, pos + PCI_EXP_RTCTL, &reg16);
129         reg16 &= ~(SYSTEM_ERROR_INTR_ON_MESG_MASK);
130         pci_write_config_word(pdev, pos + PCI_EXP_RTCTL, reg16);
131
132         aer_pos = pci_find_ext_capability(pdev, PCI_EXT_CAP_ID_ERR);
133         /* Clear error status */
134         pci_read_config_dword(pdev, aer_pos + PCI_ERR_ROOT_STATUS, &reg32);
135         pci_write_config_dword(pdev, aer_pos + PCI_ERR_ROOT_STATUS, reg32);
136         pci_read_config_dword(pdev, aer_pos + PCI_ERR_COR_STATUS, &reg32);
137         pci_write_config_dword(pdev, aer_pos + PCI_ERR_COR_STATUS, reg32);
138         pci_read_config_dword(pdev, aer_pos + PCI_ERR_UNCOR_STATUS, &reg32);
139         pci_write_config_dword(pdev, aer_pos + PCI_ERR_UNCOR_STATUS, reg32);
140
141         /*
142          * Enable error reporting for the root port device and downstream port
143          * devices.
144          */
145         set_downstream_devices_error_reporting(pdev, true);
146
147         /* Enable Root Port's interrupt in response to error messages */
148         pci_read_config_dword(pdev, aer_pos + PCI_ERR_ROOT_COMMAND, &reg32);
149         reg32 |= ROOT_PORT_INTR_ON_MESG_MASK;
150         pci_write_config_dword(pdev, aer_pos + PCI_ERR_ROOT_COMMAND, reg32);
151 }
152
153 /**
154  * aer_disable_rootport - disable Root Port's interrupts when receiving messages
155  * @rpc: pointer to a Root Port data structure
156  *
157  * Invoked when PCIe bus unloads AER service driver.
158  */
159 static void aer_disable_rootport(struct aer_rpc *rpc)
160 {
161         struct pci_dev *pdev = rpc->rpd->port;
162         u32 reg32;
163         int pos;
164
165         /*
166          * Disable error reporting for the root port device and downstream port
167          * devices.
168          */
169         set_downstream_devices_error_reporting(pdev, false);
170
171         pos = pci_find_ext_capability(pdev, PCI_EXT_CAP_ID_ERR);
172         /* Disable Root's interrupt in response to error messages */
173         pci_read_config_dword(pdev, pos + PCI_ERR_ROOT_COMMAND, &reg32);
174         reg32 &= ~ROOT_PORT_INTR_ON_MESG_MASK;
175         pci_write_config_dword(pdev, pos + PCI_ERR_ROOT_COMMAND, reg32);
176
177         /* Clear Root's error status reg */
178         pci_read_config_dword(pdev, pos + PCI_ERR_ROOT_STATUS, &reg32);
179         pci_write_config_dword(pdev, pos + PCI_ERR_ROOT_STATUS, reg32);
180 }
181
182 /**
183  * aer_irq - Root Port's ISR
184  * @irq: IRQ assigned to Root Port
185  * @context: pointer to Root Port data structure
186  *
187  * Invoked when Root Port detects AER messages.
188  */
189 irqreturn_t aer_irq(int irq, void *context)
190 {
191         unsigned int status, id;
192         struct pcie_device *pdev = (struct pcie_device *)context;
193         struct aer_rpc *rpc = get_service_data(pdev);
194         int next_prod_idx;
195         unsigned long flags;
196         int pos;
197
198         pos = pci_find_ext_capability(pdev->port, PCI_EXT_CAP_ID_ERR);
199         /*
200          * Must lock access to Root Error Status Reg, Root Error ID Reg,
201          * and Root error producer/consumer index
202          */
203         spin_lock_irqsave(&rpc->e_lock, flags);
204
205         /* Read error status */
206         pci_read_config_dword(pdev->port, pos + PCI_ERR_ROOT_STATUS, &status);
207         if (!(status & (PCI_ERR_ROOT_UNCOR_RCV|PCI_ERR_ROOT_COR_RCV))) {
208                 spin_unlock_irqrestore(&rpc->e_lock, flags);
209                 return IRQ_NONE;
210         }
211
212         /* Read error source and clear error status */
213         pci_read_config_dword(pdev->port, pos + PCI_ERR_ROOT_ERR_SRC, &id);
214         pci_write_config_dword(pdev->port, pos + PCI_ERR_ROOT_STATUS, status);
215
216         /* Store error source for later DPC handler */
217         next_prod_idx = rpc->prod_idx + 1;
218         if (next_prod_idx == AER_ERROR_SOURCES_MAX)
219                 next_prod_idx = 0;
220         if (next_prod_idx == rpc->cons_idx) {
221                 /*
222                  * Error Storm Condition - possibly the same error occurred.
223                  * Drop the error.
224                  */
225                 spin_unlock_irqrestore(&rpc->e_lock, flags);
226                 return IRQ_HANDLED;
227         }
228         rpc->e_sources[rpc->prod_idx].status =  status;
229         rpc->e_sources[rpc->prod_idx].id = id;
230         rpc->prod_idx = next_prod_idx;
231         spin_unlock_irqrestore(&rpc->e_lock, flags);
232
233         /*  Invoke DPC handler */
234         schedule_work(&rpc->dpc_handler);
235
236         return IRQ_HANDLED;
237 }
238 EXPORT_SYMBOL_GPL(aer_irq);
239
240 /**
241  * aer_alloc_rpc - allocate Root Port data structure
242  * @dev: pointer to the pcie_dev data structure
243  *
244  * Invoked when Root Port's AER service is loaded.
245  */
246 static struct aer_rpc *aer_alloc_rpc(struct pcie_device *dev)
247 {
248         struct aer_rpc *rpc;
249
250         rpc = kzalloc(sizeof(struct aer_rpc), GFP_KERNEL);
251         if (!rpc)
252                 return NULL;
253
254         /* Initialize Root lock access, e_lock, to Root Error Status Reg */
255         spin_lock_init(&rpc->e_lock);
256
257         rpc->rpd = dev;
258         INIT_WORK(&rpc->dpc_handler, aer_isr);
259         mutex_init(&rpc->rpc_mutex);
260         init_waitqueue_head(&rpc->wait_release);
261
262         /* Use PCIe bus function to store rpc into PCIe device */
263         set_service_data(dev, rpc);
264
265         return rpc;
266 }
267
268 /**
269  * aer_remove - clean up resources
270  * @dev: pointer to the pcie_dev data structure
271  *
272  * Invoked when PCI Express bus unloads or AER probe fails.
273  */
274 static void aer_remove(struct pcie_device *dev)
275 {
276         struct aer_rpc *rpc = get_service_data(dev);
277
278         if (rpc) {
279                 /* If register interrupt service, it must be free. */
280                 if (rpc->isr)
281                         free_irq(dev->irq, dev);
282
283                 wait_event(rpc->wait_release, rpc->prod_idx == rpc->cons_idx);
284
285                 aer_disable_rootport(rpc);
286                 kfree(rpc);
287                 set_service_data(dev, NULL);
288         }
289 }
290
291 /**
292  * aer_probe - initialize resources
293  * @dev: pointer to the pcie_dev data structure
294  * @id: pointer to the service id data structure
295  *
296  * Invoked when PCI Express bus loads AER service driver.
297  */
298 static int __devinit aer_probe(struct pcie_device *dev)
299 {
300         int status;
301         struct aer_rpc *rpc;
302         struct device *device = &dev->device;
303
304         /* Init */
305         status = aer_init(dev);
306         if (status)
307                 return status;
308
309         /* Alloc rpc data structure */
310         rpc = aer_alloc_rpc(dev);
311         if (!rpc) {
312                 dev_printk(KERN_DEBUG, device, "alloc rpc failed\n");
313                 aer_remove(dev);
314                 return -ENOMEM;
315         }
316
317         /* Request IRQ ISR */
318         status = request_irq(dev->irq, aer_irq, IRQF_SHARED, "aerdrv", dev);
319         if (status) {
320                 dev_printk(KERN_DEBUG, device, "request IRQ failed\n");
321                 aer_remove(dev);
322                 return status;
323         }
324
325         rpc->isr = 1;
326
327         aer_enable_rootport(rpc);
328
329         return status;
330 }
331
332 /**
333  * aer_root_reset - reset link on Root Port
334  * @dev: pointer to Root Port's pci_dev data structure
335  *
336  * Invoked by Port Bus driver when performing link reset at Root Port.
337  */
338 static pci_ers_result_t aer_root_reset(struct pci_dev *dev)
339 {
340         u32 reg32;
341         int pos;
342
343         pos = pci_find_ext_capability(dev, PCI_EXT_CAP_ID_ERR);
344
345         /* Disable Root's interrupt in response to error messages */
346         pci_read_config_dword(dev, pos + PCI_ERR_ROOT_COMMAND, &reg32);
347         reg32 &= ~ROOT_PORT_INTR_ON_MESG_MASK;
348         pci_write_config_dword(dev, pos + PCI_ERR_ROOT_COMMAND, reg32);
349
350         aer_do_secondary_bus_reset(dev);
351         dev_printk(KERN_DEBUG, &dev->dev, "Root Port link has been reset\n");
352
353         /* Clear Root Error Status */
354         pci_read_config_dword(dev, pos + PCI_ERR_ROOT_STATUS, &reg32);
355         pci_write_config_dword(dev, pos + PCI_ERR_ROOT_STATUS, reg32);
356
357         /* Enable Root Port's interrupt in response to error messages */
358         pci_read_config_dword(dev, pos + PCI_ERR_ROOT_COMMAND, &reg32);
359         reg32 |= ROOT_PORT_INTR_ON_MESG_MASK;
360         pci_write_config_dword(dev, pos + PCI_ERR_ROOT_COMMAND, reg32);
361
362         return PCI_ERS_RESULT_RECOVERED;
363 }
364
365 /**
366  * aer_error_detected - update severity status
367  * @dev: pointer to Root Port's pci_dev data structure
368  * @error: error severity being notified by port bus
369  *
370  * Invoked by Port Bus driver during error recovery.
371  */
372 static pci_ers_result_t aer_error_detected(struct pci_dev *dev,
373                         enum pci_channel_state error)
374 {
375         /* Root Port has no impact. Always recovers. */
376         return PCI_ERS_RESULT_CAN_RECOVER;
377 }
378
379 /**
380  * aer_error_resume - clean up corresponding error status bits
381  * @dev: pointer to Root Port's pci_dev data structure
382  *
383  * Invoked by Port Bus driver during nonfatal recovery.
384  */
385 static void aer_error_resume(struct pci_dev *dev)
386 {
387         int pos;
388         u32 status, mask;
389         u16 reg16;
390
391         /* Clean up Root device status */
392         pos = pci_pcie_cap(dev);
393         pci_read_config_word(dev, pos + PCI_EXP_DEVSTA, &reg16);
394         pci_write_config_word(dev, pos + PCI_EXP_DEVSTA, reg16);
395
396         /* Clean AER Root Error Status */
397         pos = pci_find_ext_capability(dev, PCI_EXT_CAP_ID_ERR);
398         pci_read_config_dword(dev, pos + PCI_ERR_UNCOR_STATUS, &status);
399         pci_read_config_dword(dev, pos + PCI_ERR_UNCOR_SEVER, &mask);
400         if (dev->error_state == pci_channel_io_normal)
401                 status &= ~mask; /* Clear corresponding nonfatal bits */
402         else
403                 status &= mask; /* Clear corresponding fatal bits */
404         pci_write_config_dword(dev, pos + PCI_ERR_UNCOR_STATUS, status);
405 }
406
407 /**
408  * aer_service_init - register AER root service driver
409  *
410  * Invoked when AER root service driver is loaded.
411  */
412 static int __init aer_service_init(void)
413 {
414         if (pcie_aer_disable)
415                 return -ENXIO;
416         if (!pci_msi_enabled())
417                 return -ENXIO;
418         return pcie_port_service_register(&aerdriver);
419 }
420
421 /**
422  * aer_service_exit - unregister AER root service driver
423  *
424  * Invoked when AER root service driver is unloaded.
425  */
426 static void __exit aer_service_exit(void)
427 {
428         pcie_port_service_unregister(&aerdriver);
429 }
430
431 module_init(aer_service_init);
432 module_exit(aer_service_exit);