git.oblomov.eu Git - linux-2.6/blob - drivers/pci/pcie/aer/aerdrv_core.c

   1 /*
   2  * drivers/pci/pcie/aer/aerdrv_core.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 core part of PCI-Express AER. When an pci-express
   9  * error is delivered, an error message will be collected and printed to
  10  * console, then, an error recovery procedure will be executed by following
  11  * the pci error recovery rules.
  12  *
  13  * Copyright (C) 2006 Intel Corp.
  14  *      Tom Long Nguyen (tom.l.nguyen@intel.com)
  15  *      Zhang Yanmin (yanmin.zhang@intel.com)
  16  *
  17  */
  18
  19 #include <linux/module.h>
  20 #include <linux/pci.h>
  21 #include <linux/kernel.h>
  22 #include <linux/errno.h>
  23 #include <linux/pm.h>
  24 #include <linux/suspend.h>
  25 #include <linux/delay.h>
  26 #include "aerdrv.h"
  27
  28 static int forceload;
  29 module_param(forceload, bool, 0);
  30
  31 int pci_enable_pcie_error_reporting(struct pci_dev *dev)
  32 {
  33         u16 reg16 = 0;
  34         int pos;
  35
  36         pos = pci_find_ext_capability(dev, PCI_EXT_CAP_ID_ERR);
  37         if (!pos)
  38                 return -EIO;
  39
  40         pos = pci_find_capability(dev, PCI_CAP_ID_EXP);
  41         if (!pos)
  42                 return -EIO;
  43
  44         pci_read_config_word(dev, pos+PCI_EXP_DEVCTL, &reg16);
  45         reg16 = reg16 |
  46                 PCI_EXP_DEVCTL_CERE |
  47                 PCI_EXP_DEVCTL_NFERE |
  48                 PCI_EXP_DEVCTL_FERE |
  49                 PCI_EXP_DEVCTL_URRE;
  50         pci_write_config_word(dev, pos+PCI_EXP_DEVCTL,
  51                         reg16);
  52         return 0;
  53 }
  54
  55 int pci_disable_pcie_error_reporting(struct pci_dev *dev)
  56 {
  57         u16 reg16 = 0;
  58         int pos;
  59
  60         pos = pci_find_capability(dev, PCI_CAP_ID_EXP);
  61         if (!pos)
  62                 return -EIO;
  63
  64         pci_read_config_word(dev, pos+PCI_EXP_DEVCTL, &reg16);
  65         reg16 = reg16 & ~(PCI_EXP_DEVCTL_CERE |
  66                         PCI_EXP_DEVCTL_NFERE |
  67                         PCI_EXP_DEVCTL_FERE |
  68                         PCI_EXP_DEVCTL_URRE);
  69         pci_write_config_word(dev, pos+PCI_EXP_DEVCTL,
  70                         reg16);
  71         return 0;
  72 }
  73
  74 int pci_cleanup_aer_uncorrect_error_status(struct pci_dev *dev)
  75 {
  76         int pos;
  77         u32 status, mask;
  78
  79         pos = pci_find_ext_capability(dev, PCI_EXT_CAP_ID_ERR);
  80         if (!pos)
  81                 return -EIO;
  82
  83         pci_read_config_dword(dev, pos + PCI_ERR_UNCOR_STATUS, &status);
  84         pci_read_config_dword(dev, pos + PCI_ERR_UNCOR_SEVER, &mask);
  85         if (dev->error_state == pci_channel_io_normal)
  86                 status &= ~mask; /* Clear corresponding nonfatal bits */
  87         else
  88                 status &= mask; /* Clear corresponding fatal bits */
  89         pci_write_config_dword(dev, pos + PCI_ERR_UNCOR_STATUS, status);
  90
  91         return 0;
  92 }
  93
  94 #if 0
  95 int pci_cleanup_aer_correct_error_status(struct pci_dev *dev)
  96 {
  97         int pos;
  98         u32 status;
  99
 100         pos = pci_find_ext_capability(dev, PCI_EXT_CAP_ID_ERR);
 101         if (!pos)
 102                 return -EIO;
 103
 104         pci_read_config_dword(dev, pos + PCI_ERR_COR_STATUS, &status);
 105         pci_write_config_dword(dev, pos + PCI_ERR_COR_STATUS, status);
 106
 107         return 0;
 108 }
 109 #endif  /*  0  */
 110
 111
 112 static int set_device_error_reporting(struct pci_dev *dev, void *data)
 113 {
 114         bool enable = *((bool *)data);
 115
 116         if (dev->pcie_type == PCIE_RC_PORT ||
 117             dev->pcie_type == PCIE_SW_UPSTREAM_PORT ||
 118             dev->pcie_type == PCIE_SW_DOWNSTREAM_PORT) {
 119                 if (enable)
 120                         pci_enable_pcie_error_reporting(dev);
 121                 else
 122                         pci_disable_pcie_error_reporting(dev);
 123         }
 124
 125         if (enable)
 126                 pcie_set_ecrc_checking(dev);
 127
 128         return 0;
 129 }
 130
 131 /**
 132  * set_downstream_devices_error_reporting - enable/disable the error reporting  bits on the root port and its downstream ports.
 133  * @dev: pointer to root port's pci_dev data structure
 134  * @enable: true = enable error reporting, false = disable error reporting.
 135  */
 136 static void set_downstream_devices_error_reporting(struct pci_dev *dev,
 137                                                    bool enable)
 138 {
 139         set_device_error_reporting(dev, &enable);
 140
 141         if (!dev->subordinate)
 142                 return;
 143         pci_walk_bus(dev->subordinate, set_device_error_reporting, &enable);
 144 }
 145
 146 static int find_device_iter(struct device *device, void *data)
 147 {
 148         struct pci_dev *dev;
 149         u16 id = *(unsigned long *)data;
 150         u8 secondary, subordinate, d_bus = id >> 8;
 151
 152         if (device->bus == &pci_bus_type) {
 153                 dev = to_pci_dev(device);
 154                 if (id == ((dev->bus->number << 8) | dev->devfn)) {
 155                         /*
 156                          * Device ID match
 157                          */
 158                         *(unsigned long*)data = (unsigned long)device;
 159                         return 1;
 160                 }
 161
 162                 /*
 163                  * If device is P2P, check if it is an upstream?
 164                  */
 165                 if (dev->hdr_type & PCI_HEADER_TYPE_BRIDGE) {
 166                         pci_read_config_byte(dev, PCI_SECONDARY_BUS,
 167                                 &secondary);
 168                         pci_read_config_byte(dev, PCI_SUBORDINATE_BUS,
 169                                 &subordinate);
 170                         if (d_bus >= secondary && d_bus <= subordinate) {
 171                                 *(unsigned long*)data = (unsigned long)device;
 172                                 return 1;
 173                         }
 174                 }
 175         }
 176
 177         return 0;
 178 }
 179
 180 /**
 181  * find_source_device - search through device hierarchy for source device
 182  * @parent: pointer to Root Port pci_dev data structure
 183  * @id: device ID of agent who sends an error message to this Root Port
 184  *
 185  * Invoked when error is detected at the Root Port.
 186  */
 187 static struct device* find_source_device(struct pci_dev *parent, u16 id)
 188 {
 189         struct pci_dev *dev = parent;
 190         struct device *device;
 191         unsigned long device_addr;
 192         int status;
 193
 194         /* Is Root Port an agent that sends error message? */
 195         if (id == ((dev->bus->number << 8) | dev->devfn))
 196                 return &dev->dev;
 197
 198         do {
 199                 device_addr = id;
 200                 if ((status = device_for_each_child(&dev->dev,
 201                         &device_addr, find_device_iter))) {
 202                         device = (struct device*)device_addr;
 203                         dev = to_pci_dev(device);
 204                         if (id == ((dev->bus->number << 8) | dev->devfn))
 205                                 return device;
 206                 }
 207         }while (status);
 208
 209         return NULL;
 210 }
 211
 212 static int report_error_detected(struct pci_dev *dev, void *data)
 213 {
 214         pci_ers_result_t vote;
 215         struct pci_error_handlers *err_handler;
 216         struct aer_broadcast_data *result_data;
 217         result_data = (struct aer_broadcast_data *) data;
 218
 219         dev->error_state = result_data->state;
 220
 221         if (!dev->driver ||
 222                 !dev->driver->err_handler ||
 223                 !dev->driver->err_handler->error_detected) {
 224                 if (result_data->state == pci_channel_io_frozen &&
 225                         !(dev->hdr_type & PCI_HEADER_TYPE_BRIDGE)) {
 226                         /*
 227                          * In case of fatal recovery, if one of down-
 228                          * stream device has no driver. We might be
 229                          * unable to recover because a later insmod
 230                          * of a driver for this device is unaware of
 231                          * its hw state.
 232                          */
 233                         dev_printk(KERN_DEBUG, &dev->dev, "device has %s\n",
 234                                    dev->driver ?
 235                                    "no AER-aware driver" : "no driver");
 236                 }
 237                 return 0;
 238         }
 239
 240         err_handler = dev->driver->err_handler;
 241         vote = err_handler->error_detected(dev, result_data->state);
 242         result_data->result = merge_result(result_data->result, vote);
 243         return 0;
 244 }
 245
 246 static int report_mmio_enabled(struct pci_dev *dev, void *data)
 247 {
 248         pci_ers_result_t vote;
 249         struct pci_error_handlers *err_handler;
 250         struct aer_broadcast_data *result_data;
 251         result_data = (struct aer_broadcast_data *) data;
 252
 253         if (!dev->driver ||
 254                 !dev->driver->err_handler ||
 255                 !dev->driver->err_handler->mmio_enabled)
 256                 return 0;
 257
 258         err_handler = dev->driver->err_handler;
 259         vote = err_handler->mmio_enabled(dev);
 260         result_data->result = merge_result(result_data->result, vote);
 261         return 0;
 262 }
 263
 264 static int report_slot_reset(struct pci_dev *dev, void *data)
 265 {
 266         pci_ers_result_t vote;
 267         struct pci_error_handlers *err_handler;
 268         struct aer_broadcast_data *result_data;
 269         result_data = (struct aer_broadcast_data *) data;
 270
 271         if (!dev->driver ||
 272                 !dev->driver->err_handler ||
 273                 !dev->driver->err_handler->slot_reset)
 274                 return 0;
 275
 276         err_handler = dev->driver->err_handler;
 277         vote = err_handler->slot_reset(dev);
 278         result_data->result = merge_result(result_data->result, vote);
 279         return 0;
 280 }
 281
 282 static int report_resume(struct pci_dev *dev, void *data)
 283 {
 284         struct pci_error_handlers *err_handler;
 285
 286         dev->error_state = pci_channel_io_normal;
 287
 288         if (!dev->driver ||
 289                 !dev->driver->err_handler ||
 290                 !dev->driver->err_handler->resume)
 291                 return 0;
 292
 293         err_handler = dev->driver->err_handler;
 294         err_handler->resume(dev);
 295         return 0;
 296 }
 297
 298 /**
 299  * broadcast_error_message - handle message broadcast to downstream drivers
 300  * @dev: pointer to from where in a hierarchy message is broadcasted down
 301  * @state: error state
 302  * @error_mesg: message to print
 303  * @cb: callback to be broadcasted
 304  *
 305  * Invoked during error recovery process. Once being invoked, the content
 306  * of error severity will be broadcasted to all downstream drivers in a
 307  * hierarchy in question.
 308  */
 309 static pci_ers_result_t broadcast_error_message(struct pci_dev *dev,
 310         enum pci_channel_state state,
 311         char *error_mesg,
 312         int (*cb)(struct pci_dev *, void *))
 313 {
 314         struct aer_broadcast_data result_data;
 315
 316         dev_printk(KERN_DEBUG, &dev->dev, "broadcast %s message\n", error_mesg);
 317         result_data.state = state;
 318         if (cb == report_error_detected)
 319                 result_data.result = PCI_ERS_RESULT_CAN_RECOVER;
 320         else
 321                 result_data.result = PCI_ERS_RESULT_RECOVERED;
 322
 323         if (dev->hdr_type & PCI_HEADER_TYPE_BRIDGE) {
 324                 /*
 325                  * If the error is reported by a bridge, we think this error
 326                  * is related to the downstream link of the bridge, so we
 327                  * do error recovery on all subordinates of the bridge instead
 328                  * of the bridge and clear the error status of the bridge.
 329                  */
 330                 if (cb == report_error_detected)
 331                         dev->error_state = state;
 332                 pci_walk_bus(dev->subordinate, cb, &result_data);
 333                 if (cb == report_resume) {
 334                         pci_cleanup_aer_uncorrect_error_status(dev);
 335                         dev->error_state = pci_channel_io_normal;
 336                 }
 337         }
 338         else {
 339                 /*
 340                  * If the error is reported by an end point, we think this
 341                  * error is related to the upstream link of the end point.
 342                  */
 343                 pci_walk_bus(dev->bus, cb, &result_data);
 344         }
 345
 346         return result_data.result;
 347 }
 348
 349 struct find_aer_service_data {
 350         struct pcie_port_service_driver *aer_driver;
 351         int is_downstream;
 352 };
 353
 354 static int find_aer_service_iter(struct device *device, void *data)
 355 {
 356         struct device_driver *driver;
 357         struct pcie_port_service_driver *service_driver;
 358         struct find_aer_service_data *result;
 359
 360         result = (struct find_aer_service_data *) data;
 361
 362         if (device->bus == &pcie_port_bus_type) {
 363                 struct pcie_port_data *port_data;
 364
 365                 port_data = pci_get_drvdata(to_pcie_device(device)->port);
 366                 if (port_data->port_type == PCIE_SW_DOWNSTREAM_PORT)
 367                         result->is_downstream = 1;
 368
 369                 driver = device->driver;
 370                 if (driver) {
 371                         service_driver = to_service_driver(driver);
 372                         if (service_driver->service == PCIE_PORT_SERVICE_AER) {
 373                                 result->aer_driver = service_driver;
 374                                 return 1;
 375                         }
 376                 }
 377         }
 378
 379         return 0;
 380 }
 381
 382 static void find_aer_service(struct pci_dev *dev,
 383                 struct find_aer_service_data *data)
 384 {
 385         int retval;
 386         retval = device_for_each_child(&dev->dev, data, find_aer_service_iter);
 387 }
 388
 389 static pci_ers_result_t reset_link(struct pcie_device *aerdev,
 390                 struct pci_dev *dev)
 391 {
 392         struct pci_dev *udev;
 393         pci_ers_result_t status;
 394         struct find_aer_service_data data;
 395
 396         if (dev->hdr_type & PCI_HEADER_TYPE_BRIDGE)
 397                 udev = dev;
 398         else
 399                 udev= dev->bus->self;
 400
 401         data.is_downstream = 0;
 402         data.aer_driver = NULL;
 403         find_aer_service(udev, &data);
 404
 405         /*
 406          * Use the aer driver of the error agent firstly.
 407          * If it hasn't the aer driver, use the root port's
 408          */
 409         if (!data.aer_driver || !data.aer_driver->reset_link) {
 410                 if (data.is_downstream &&
 411                         aerdev->device.driver &&
 412                         to_service_driver(aerdev->device.driver)->reset_link) {
 413                         data.aer_driver =
 414                                 to_service_driver(aerdev->device.driver);
 415                 } else {
 416                         dev_printk(KERN_DEBUG, &dev->dev, "no link-reset "
 417                                    "support\n");
 418                         return PCI_ERS_RESULT_DISCONNECT;
 419                 }
 420         }
 421
 422         status = data.aer_driver->reset_link(udev);
 423         if (status != PCI_ERS_RESULT_RECOVERED) {
 424                 dev_printk(KERN_DEBUG, &dev->dev, "link reset at upstream "
 425                            "device %s failed\n", pci_name(udev));
 426                 return PCI_ERS_RESULT_DISCONNECT;
 427         }
 428
 429         return status;
 430 }
 431
 432 /**
 433  * do_recovery - handle nonfatal/fatal error recovery process
 434  * @aerdev: pointer to a pcie_device data structure of root port
 435  * @dev: pointer to a pci_dev data structure of agent detecting an error
 436  * @severity: error severity type
 437  *
 438  * Invoked when an error is nonfatal/fatal. Once being invoked, broadcast
 439  * error detected message to all downstream drivers within a hierarchy in
 440  * question and return the returned code.
 441  */
 442 static pci_ers_result_t do_recovery(struct pcie_device *aerdev,
 443                 struct pci_dev *dev,
 444                 int severity)
 445 {
 446         pci_ers_result_t status, result = PCI_ERS_RESULT_RECOVERED;
 447         enum pci_channel_state state;
 448
 449         if (severity == AER_FATAL)
 450                 state = pci_channel_io_frozen;
 451         else
 452                 state = pci_channel_io_normal;
 453
 454         status = broadcast_error_message(dev,
 455                         state,
 456                         "error_detected",
 457                         report_error_detected);
 458
 459         if (severity == AER_FATAL) {
 460                 result = reset_link(aerdev, dev);
 461                 if (result != PCI_ERS_RESULT_RECOVERED) {
 462                         /* TODO: Should panic here? */
 463                         return result;
 464                 }
 465         }
 466
 467         if (status == PCI_ERS_RESULT_CAN_RECOVER)
 468                 status = broadcast_error_message(dev,
 469                                 state,
 470                                 "mmio_enabled",
 471                                 report_mmio_enabled);
 472
 473         if (status == PCI_ERS_RESULT_NEED_RESET) {
 474                 /*
 475                  * TODO: Should call platform-specific
 476                  * functions to reset slot before calling
 477                  * drivers' slot_reset callbacks?
 478                  */
 479                 status = broadcast_error_message(dev,
 480                                 state,
 481                                 "slot_reset",
 482                                 report_slot_reset);
 483         }
 484
 485         if (status == PCI_ERS_RESULT_RECOVERED)
 486                 broadcast_error_message(dev,
 487                                 state,
 488                                 "resume",
 489                                 report_resume);
 490
 491         return status;
 492 }
 493
 494 /**
 495  * handle_error_source - handle logging error into an event log
 496  * @aerdev: pointer to pcie_device data structure of the root port
 497  * @dev: pointer to pci_dev data structure of error source device
 498  * @info: comprehensive error information
 499  *
 500  * Invoked when an error being detected by Root Port.
 501  */
 502 static void handle_error_source(struct pcie_device * aerdev,
 503         struct pci_dev *dev,
 504         struct aer_err_info info)
 505 {
 506         pci_ers_result_t status = 0;
 507         int pos;
 508
 509         if (info.severity == AER_CORRECTABLE) {
 510                 /*
 511                  * Correctable error does not need software intevention.
 512                  * No need to go through error recovery process.
 513                  */
 514                 pos = pci_find_ext_capability(dev, PCI_EXT_CAP_ID_ERR);
 515                 if (pos)
 516                         pci_write_config_dword(dev, pos + PCI_ERR_COR_STATUS,
 517                                         info.status);
 518         } else {
 519                 status = do_recovery(aerdev, dev, info.severity);
 520                 if (status == PCI_ERS_RESULT_RECOVERED) {
 521                         dev_printk(KERN_DEBUG, &dev->dev, "AER driver "
 522                                    "successfully recovered\n");
 523                 } else {
 524                         /* TODO: Should kernel panic here? */
 525                         dev_printk(KERN_DEBUG, &dev->dev, "AER driver didn't "
 526                                    "recover\n");
 527                 }
 528         }
 529 }
 530
 531 /**
 532  * aer_enable_rootport - enable Root Port's interrupts when receiving messages
 533  * @rpc: pointer to a Root Port data structure
 534  *
 535  * Invoked when PCIE bus loads AER service driver.
 536  */
 537 void aer_enable_rootport(struct aer_rpc *rpc)
 538 {
 539         struct pci_dev *pdev = rpc->rpd->port;
 540         int pos, aer_pos;
 541         u16 reg16;
 542         u32 reg32;
 543
 544         pos = pci_find_capability(pdev, PCI_CAP_ID_EXP);
 545         /* Clear PCIE Capability's Device Status */
 546         pci_read_config_word(pdev, pos+PCI_EXP_DEVSTA, &reg16);
 547         pci_write_config_word(pdev, pos+PCI_EXP_DEVSTA, reg16);
 548
 549         /* Disable system error generation in response to error messages */
 550         pci_read_config_word(pdev, pos + PCI_EXP_RTCTL, &reg16);
 551         reg16 &= ~(SYSTEM_ERROR_INTR_ON_MESG_MASK);
 552         pci_write_config_word(pdev, pos + PCI_EXP_RTCTL, reg16);
 553
 554         aer_pos = pci_find_ext_capability(pdev, PCI_EXT_CAP_ID_ERR);
 555         /* Clear error status */
 556         pci_read_config_dword(pdev, aer_pos + PCI_ERR_ROOT_STATUS, &reg32);
 557         pci_write_config_dword(pdev, aer_pos + PCI_ERR_ROOT_STATUS, reg32);
 558         pci_read_config_dword(pdev, aer_pos + PCI_ERR_COR_STATUS, &reg32);
 559         pci_write_config_dword(pdev, aer_pos + PCI_ERR_COR_STATUS, reg32);
 560         pci_read_config_dword(pdev, aer_pos + PCI_ERR_UNCOR_STATUS, &reg32);
 561         pci_write_config_dword(pdev, aer_pos + PCI_ERR_UNCOR_STATUS, reg32);
 562
 563         /*
 564          * Enable error reporting for the root port device and downstream port
 565          * devices.
 566          */
 567         set_downstream_devices_error_reporting(pdev, true);
 568
 569         /* Enable Root Port's interrupt in response to error messages */
 570         pci_write_config_dword(pdev,
 571                 aer_pos + PCI_ERR_ROOT_COMMAND,
 572                 ROOT_PORT_INTR_ON_MESG_MASK);
 573 }
 574
 575 /**
 576  * disable_root_aer - disable Root Port's interrupts when receiving messages
 577  * @rpc: pointer to a Root Port data structure
 578  *
 579  * Invoked when PCIE bus unloads AER service driver.
 580  */
 581 static void disable_root_aer(struct aer_rpc *rpc)
 582 {
 583         struct pci_dev *pdev = rpc->rpd->port;
 584         u32 reg32;
 585         int pos;
 586
 587         /*
 588          * Disable error reporting for the root port device and downstream port
 589          * devices.
 590          */
 591         set_downstream_devices_error_reporting(pdev, false);
 592
 593         pos = pci_find_ext_capability(pdev, PCI_EXT_CAP_ID_ERR);
 594         /* Disable Root's interrupt in response to error messages */
 595         pci_write_config_dword(pdev, pos + PCI_ERR_ROOT_COMMAND, 0);
 596
 597         /* Clear Root's error status reg */
 598         pci_read_config_dword(pdev, pos + PCI_ERR_ROOT_STATUS, &reg32);
 599         pci_write_config_dword(pdev, pos + PCI_ERR_ROOT_STATUS, reg32);
 600 }
 601
 602 /**
 603  * get_e_source - retrieve an error source
 604  * @rpc: pointer to the root port which holds an error
 605  *
 606  * Invoked by DPC handler to consume an error.
 607  */
 608 static struct aer_err_source* get_e_source(struct aer_rpc *rpc)
 609 {
 610         struct aer_err_source *e_source;
 611         unsigned long flags;
 612
 613         /* Lock access to Root error producer/consumer index */
 614         spin_lock_irqsave(&rpc->e_lock, flags);
 615         if (rpc->prod_idx == rpc->cons_idx) {
 616                 spin_unlock_irqrestore(&rpc->e_lock, flags);
 617                 return NULL;
 618         }
 619         e_source = &rpc->e_sources[rpc->cons_idx];
 620         rpc->cons_idx++;
 621         if (rpc->cons_idx == AER_ERROR_SOURCES_MAX)
 622                 rpc->cons_idx = 0;
 623         spin_unlock_irqrestore(&rpc->e_lock, flags);
 624
 625         return e_source;
 626 }
 627
 628 static int get_device_error_info(struct pci_dev *dev, struct aer_err_info *info)
 629 {
 630         int pos;
 631
 632         pos = pci_find_ext_capability(dev, PCI_EXT_CAP_ID_ERR);
 633
 634         /* The device might not support AER */
 635         if (!pos)
 636                 return AER_SUCCESS;
 637
 638         if (info->severity == AER_CORRECTABLE) {
 639                 pci_read_config_dword(dev, pos + PCI_ERR_COR_STATUS,
 640                         &info->status);
 641                 if (!(info->status & ERR_CORRECTABLE_ERROR_MASK))
 642                         return AER_UNSUCCESS;
 643         } else if (dev->hdr_type & PCI_HEADER_TYPE_BRIDGE ||
 644                 info->severity == AER_NONFATAL) {
 645
 646                 /* Link is still healthy for IO reads */
 647                 pci_read_config_dword(dev, pos + PCI_ERR_UNCOR_STATUS,
 648                         &info->status);
 649                 if (!(info->status & ERR_UNCORRECTABLE_ERROR_MASK))
 650                         return AER_UNSUCCESS;
 651
 652                 if (info->status & AER_LOG_TLP_MASKS) {
 653                         info->flags |= AER_TLP_HEADER_VALID_FLAG;
 654                         pci_read_config_dword(dev,
 655                                 pos + PCI_ERR_HEADER_LOG, &info->tlp.dw0);
 656                         pci_read_config_dword(dev,
 657                                 pos + PCI_ERR_HEADER_LOG + 4, &info->tlp.dw1);
 658                         pci_read_config_dword(dev,
 659                                 pos + PCI_ERR_HEADER_LOG + 8, &info->tlp.dw2);
 660                         pci_read_config_dword(dev,
 661                                 pos + PCI_ERR_HEADER_LOG + 12, &info->tlp.dw3);
 662                 }
 663         }
 664
 665         return AER_SUCCESS;
 666 }
 667
 668 /**
 669  * aer_isr_one_error - consume an error detected by root port
 670  * @p_device: pointer to error root port service device
 671  * @e_src: pointer to an error source
 672  */
 673 static void aer_isr_one_error(struct pcie_device *p_device,
 674                 struct aer_err_source *e_src)
 675 {
 676         struct device *s_device;
 677         struct aer_err_info e_info = {0, 0, 0,};
 678         int i;
 679         u16 id;
 680
 681         /*
 682          * There is a possibility that both correctable error and
 683          * uncorrectable error being logged. Report correctable error first.
 684          */
 685         for (i = 1; i & ROOT_ERR_STATUS_MASKS ; i <<= 2) {
 686                 if (i > 4)
 687                         break;
 688                 if (!(e_src->status & i))
 689                         continue;
 690
 691                 /* Init comprehensive error information */
 692                 if (i & PCI_ERR_ROOT_COR_RCV) {
 693                         id = ERR_COR_ID(e_src->id);
 694                         e_info.severity = AER_CORRECTABLE;
 695                 } else {
 696                         id = ERR_UNCOR_ID(e_src->id);
 697                         e_info.severity = ((e_src->status >> 6) & 1);
 698                 }
 699                 if (e_src->status &
 700                         (PCI_ERR_ROOT_MULTI_COR_RCV |
 701                          PCI_ERR_ROOT_MULTI_UNCOR_RCV))
 702                         e_info.flags |= AER_MULTI_ERROR_VALID_FLAG;
 703                 if (!(s_device = find_source_device(p_device->port, id))) {
 704                         printk(KERN_DEBUG "%s->can't find device of ID%04x\n",
 705                                 __func__, id);
 706                         continue;
 707                 }
 708                 if (get_device_error_info(to_pci_dev(s_device), &e_info) ==
 709                                 AER_SUCCESS) {
 710                         aer_print_error(to_pci_dev(s_device), &e_info);
 711                         handle_error_source(p_device,
 712                                 to_pci_dev(s_device),
 713                                 e_info);
 714                 }
 715         }
 716 }
 717
 718 /**
 719  * aer_isr - consume errors detected by root port
 720  * @work: definition of this work item
 721  *
 722  * Invoked, as DPC, when root port records new detected error
 723  */
 724 void aer_isr(struct work_struct *work)
 725 {
 726         struct aer_rpc *rpc = container_of(work, struct aer_rpc, dpc_handler);
 727         struct pcie_device *p_device = rpc->rpd;
 728         struct aer_err_source *e_src;
 729
 730         mutex_lock(&rpc->rpc_mutex);
 731         e_src = get_e_source(rpc);
 732         while (e_src) {
 733                 aer_isr_one_error(p_device, e_src);
 734                 e_src = get_e_source(rpc);
 735         }
 736         mutex_unlock(&rpc->rpc_mutex);
 737
 738         wake_up(&rpc->wait_release);
 739 }
 740
 741 /**
 742  * aer_delete_rootport - disable root port aer and delete service data
 743  * @rpc: pointer to a root port device being deleted
 744  *
 745  * Invoked when AER service unloaded on a specific Root Port
 746  */
 747 void aer_delete_rootport(struct aer_rpc *rpc)
 748 {
 749         /* Disable root port AER itself */
 750         disable_root_aer(rpc);
 751
 752         kfree(rpc);
 753 }
 754
 755 /**
 756  * aer_init - provide AER initialization
 757  * @dev: pointer to AER pcie device
 758  *
 759  * Invoked when AER service driver is loaded.
 760  */
 761 int aer_init(struct pcie_device *dev)
 762 {
 763         if (aer_osc_setup(dev) && !forceload)
 764                 return -ENXIO;
 765
 766         return AER_SUCCESS;
 767 }
 768
 769 EXPORT_SYMBOL_GPL(pci_enable_pcie_error_reporting);
 770 EXPORT_SYMBOL_GPL(pci_disable_pcie_error_reporting);
 771 EXPORT_SYMBOL_GPL(pci_cleanup_aer_uncorrect_error_status);
 772