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