arch/powerpc/kernel/eeh_driver.c

   1 /*
   2  * PCI Error Recovery Driver for RPA-compliant PPC64 platform.
   3  * Copyright IBM Corp. 2004 2005
   4  * Copyright Linas Vepstas <linas@linas.org> 2004, 2005
   5  *
   6  * All rights reserved.
   7  *
   8  * This program is free software; you can redistribute it and/or modify
   9  * it under the terms of the GNU General Public License as published by
  10  * the Free Software Foundation; either version 2 of the License, or (at
  11  * your option) any later version.
  12  *
  13  * This program is distributed in the hope that it will be useful, but
  14  * WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE, GOOD TITLE or
  16  * NON INFRINGEMENT.  See the GNU General Public License for more
  17  * details.
  18  *
  19  * You should have received a copy of the GNU General Public License
  20  * along with this program; if not, write to the Free Software
  21  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  22  *
  23  * Send comments and feedback to Linas Vepstas <linas@austin.ibm.com>
  24  */
  25 #include <linux/delay.h>
  26 #include <linux/interrupt.h>
  27 #include <linux/irq.h>
  28 #include <linux/module.h>
  29 #include <linux/pci.h>
  30 #include <asm/eeh.h>
  31 #include <asm/eeh_event.h>
  32 #include <asm/ppc-pci.h>
  33 #include <asm/pci-bridge.h>
  34 #include <asm/prom.h>
  35 #include <asm/rtas.h>
  36
  37 struct eeh_rmv_data {
  38         struct list_head edev_list;
  39         int removed;
  40 };
  41
  42 /**
  43  * eeh_pcid_name - Retrieve name of PCI device driver
  44  * @pdev: PCI device
  45  *
  46  * This routine is used to retrieve the name of PCI device driver
  47  * if that's valid.
  48  */
  49 static inline const char *eeh_pcid_name(struct pci_dev *pdev)
  50 {
  51         if (pdev && pdev->dev.driver)
  52                 return pdev->dev.driver->name;
  53         return "";
  54 }
  55
  56 /**
  57  * eeh_pcid_get - Get the PCI device driver
  58  * @pdev: PCI device
  59  *
  60  * The function is used to retrieve the PCI device driver for
  61  * the indicated PCI device. Besides, we will increase the reference
  62  * of the PCI device driver to prevent that being unloaded on
  63  * the fly. Otherwise, kernel crash would be seen.
  64  */
  65 static inline struct pci_driver *eeh_pcid_get(struct pci_dev *pdev)
  66 {
  67         if (!pdev || !pdev->driver)
  68                 return NULL;
  69
  70         if (!try_module_get(pdev->driver->driver.owner))
  71                 return NULL;
  72
  73         return pdev->driver;
  74 }
  75
  76 /**
  77  * eeh_pcid_put - Dereference on the PCI device driver
  78  * @pdev: PCI device
  79  *
  80  * The function is called to do dereference on the PCI device
  81  * driver of the indicated PCI device.
  82  */
  83 static inline void eeh_pcid_put(struct pci_dev *pdev)
  84 {
  85         if (!pdev || !pdev->driver)
  86                 return;
  87
  88         module_put(pdev->driver->driver.owner);
  89 }
  90
  91 /**
  92  * eeh_disable_irq - Disable interrupt for the recovering device
  93  * @dev: PCI device
  94  *
  95  * This routine must be called when reporting temporary or permanent
  96  * error to the particular PCI device to disable interrupt of that
  97  * device. If the device has enabled MSI or MSI-X interrupt, we needn't
  98  * do real work because EEH should freeze DMA transfers for those PCI
  99  * devices encountering EEH errors, which includes MSI or MSI-X.
 100  */
 101 static void eeh_disable_irq(struct pci_dev *dev)
 102 {
 103         struct eeh_dev *edev = pci_dev_to_eeh_dev(dev);
 104
 105         /* Don't disable MSI and MSI-X interrupts. They are
 106          * effectively disabled by the DMA Stopped state
 107          * when an EEH error occurs.
 108          */
 109         if (dev->msi_enabled || dev->msix_enabled)
 110                 return;
 111
 112         if (!irq_has_action(dev->irq))
 113                 return;
 114
 115         edev->mode |= EEH_DEV_IRQ_DISABLED;
 116         disable_irq_nosync(dev->irq);
 117 }
 118
 119 /**
 120  * eeh_enable_irq - Enable interrupt for the recovering device
 121  * @dev: PCI device
 122  *
 123  * This routine must be called to enable interrupt while failed
 124  * device could be resumed.
 125  */
 126 static void eeh_enable_irq(struct pci_dev *dev)
 127 {
 128         struct eeh_dev *edev = pci_dev_to_eeh_dev(dev);
 129
 130         if ((edev->mode) & EEH_DEV_IRQ_DISABLED) {
 131                 edev->mode &= ~EEH_DEV_IRQ_DISABLED;
 132                 /*
 133                  * FIXME !!!!!
 134                  *
 135                  * This is just ass backwards. This maze has
 136                  * unbalanced irq_enable/disable calls. So instead of
 137                  * finding the root cause it works around the warning
 138                  * in the irq_enable code by conditionally calling
 139                  * into it.
 140                  *
 141                  * That's just wrong.The warning in the core code is
 142                  * there to tell people to fix their asymmetries in
 143                  * their own code, not by abusing the core information
 144                  * to avoid it.
 145                  *
 146                  * I so wish that the assymetry would be the other way
 147                  * round and a few more irq_disable calls render that
 148                  * shit unusable forever.
 149                  *
 150                  *      tglx
 151                  */
 152                 if (irqd_irq_disabled(irq_get_irq_data(dev->irq)))
 153                         enable_irq(dev->irq);
 154         }
 155 }
 156
 157 static bool eeh_dev_removed(struct eeh_dev *edev)
 158 {
 159         /* EEH device removed ? */
 160         if (!edev || (edev->mode & EEH_DEV_REMOVED))
 161                 return true;
 162
 163         return false;
 164 }
 165
 166 static void *eeh_dev_save_state(void *data, void *userdata)
 167 {
 168         struct eeh_dev *edev = data;
 169         struct pci_dev *pdev;
 170
 171         if (!edev)
 172                 return NULL;
 173
 174         /*
 175          * We cannot access the config space on some adapters.
 176          * Otherwise, it will cause fenced PHB. We don't save
 177          * the content in their config space and will restore
 178          * from the initial config space saved when the EEH
 179          * device is created.
 180          */
 181         if (edev->pe && (edev->pe->state & EEH_PE_CFG_RESTRICTED))
 182                 return NULL;
 183
 184         pdev = eeh_dev_to_pci_dev(edev);
 185         if (!pdev)
 186                 return NULL;
 187
 188         pci_save_state(pdev);
 189         return NULL;
 190 }
 191
 192 /**
 193  * eeh_report_error - Report pci error to each device driver
 194  * @data: eeh device
 195  * @userdata: return value
 196  *
 197  * Report an EEH error to each device driver, collect up and
 198  * merge the device driver responses. Cumulative response
 199  * passed back in "userdata".
 200  */
 201 static void *eeh_report_error(void *data, void *userdata)
 202 {
 203         struct eeh_dev *edev = (struct eeh_dev *)data;
 204         struct pci_dev *dev = eeh_dev_to_pci_dev(edev);
 205         enum pci_ers_result rc, *res = userdata;
 206         struct pci_driver *driver;
 207
 208         if (!dev || eeh_dev_removed(edev) || eeh_pe_passed(edev->pe))
 209                 return NULL;
 210
 211         device_lock(&dev->dev);
 212         dev->error_state = pci_channel_io_frozen;
 213
 214         driver = eeh_pcid_get(dev);
 215         if (!driver) goto out_no_dev;
 216
 217         eeh_disable_irq(dev);
 218
 219         if (!driver->err_handler ||
 220             !driver->err_handler->error_detected)
 221                 goto out;
 222
 223         rc = driver->err_handler->error_detected(dev, pci_channel_io_frozen);
 224
 225         /* A driver that needs a reset trumps all others */
 226         if (rc == PCI_ERS_RESULT_NEED_RESET) *res = rc;
 227         if (*res == PCI_ERS_RESULT_NONE) *res = rc;
 228
 229         edev->in_error = true;
 230 out:
 231         eeh_pcid_put(dev);
 232 out_no_dev:
 233         device_unlock(&dev->dev);
 234         return NULL;
 235 }
 236
 237 /**
 238  * eeh_report_mmio_enabled - Tell drivers that MMIO has been enabled
 239  * @data: eeh device
 240  * @userdata: return value
 241  *
 242  * Tells each device driver that IO ports, MMIO and config space I/O
 243  * are now enabled. Collects up and merges the device driver responses.
 244  * Cumulative response passed back in "userdata".
 245  */
 246 static void *eeh_report_mmio_enabled(void *data, void *userdata)
 247 {
 248         struct eeh_dev *edev = (struct eeh_dev *)data;
 249         struct pci_dev *dev = eeh_dev_to_pci_dev(edev);
 250         enum pci_ers_result rc, *res = userdata;
 251         struct pci_driver *driver;
 252
 253         if (!dev || eeh_dev_removed(edev) || eeh_pe_passed(edev->pe))
 254                 return NULL;
 255
 256         device_lock(&dev->dev);
 257         driver = eeh_pcid_get(dev);
 258         if (!driver) goto out_no_dev;
 259
 260         if (!driver->err_handler ||
 261             !driver->err_handler->mmio_enabled ||
 262             (edev->mode & EEH_DEV_NO_HANDLER))
 263                 goto out;
 264
 265         rc = driver->err_handler->mmio_enabled(dev);
 266
 267         /* A driver that needs a reset trumps all others */
 268         if (rc == PCI_ERS_RESULT_NEED_RESET) *res = rc;
 269         if (*res == PCI_ERS_RESULT_NONE) *res = rc;
 270
 271 out:
 272         eeh_pcid_put(dev);
 273 out_no_dev:
 274         device_unlock(&dev->dev);
 275         return NULL;
 276 }
 277
 278 /**
 279  * eeh_report_reset - Tell device that slot has been reset
 280  * @data: eeh device
 281  * @userdata: return value
 282  *
 283  * This routine must be called while EEH tries to reset particular
 284  * PCI device so that the associated PCI device driver could take
 285  * some actions, usually to save data the driver needs so that the
 286  * driver can work again while the device is recovered.
 287  */
 288 static void *eeh_report_reset(void *data, void *userdata)
 289 {
 290         struct eeh_dev *edev = (struct eeh_dev *)data;
 291         struct pci_dev *dev = eeh_dev_to_pci_dev(edev);
 292         enum pci_ers_result rc, *res = userdata;
 293         struct pci_driver *driver;
 294
 295         if (!dev || eeh_dev_removed(edev) || eeh_pe_passed(edev->pe))
 296                 return NULL;
 297
 298         device_lock(&dev->dev);
 299         dev->error_state = pci_channel_io_normal;
 300
 301         driver = eeh_pcid_get(dev);
 302         if (!driver) goto out_no_dev;
 303
 304         eeh_enable_irq(dev);
 305
 306         if (!driver->err_handler ||
 307             !driver->err_handler->slot_reset ||
 308             (edev->mode & EEH_DEV_NO_HANDLER) ||
 309             (!edev->in_error))
 310                 goto out;
 311
 312         rc = driver->err_handler->slot_reset(dev);
 313         if ((*res == PCI_ERS_RESULT_NONE) ||
 314             (*res == PCI_ERS_RESULT_RECOVERED)) *res = rc;
 315         if (*res == PCI_ERS_RESULT_DISCONNECT &&
 316              rc == PCI_ERS_RESULT_NEED_RESET) *res = rc;
 317
 318 out:
 319         eeh_pcid_put(dev);
 320 out_no_dev:
 321         device_unlock(&dev->dev);
 322         return NULL;
 323 }
 324
 325 static void *eeh_dev_restore_state(void *data, void *userdata)
 326 {
 327         struct eeh_dev *edev = data;
 328         struct pci_dev *pdev;
 329
 330         if (!edev)
 331                 return NULL;
 332
 333         /*
 334          * The content in the config space isn't saved because
 335          * the blocked config space on some adapters. We have
 336          * to restore the initial saved config space when the
 337          * EEH device is created.
 338          */
 339         if (edev->pe && (edev->pe->state & EEH_PE_CFG_RESTRICTED)) {
 340                 if (list_is_last(&edev->list, &edev->pe->edevs))
 341                         eeh_pe_restore_bars(edev->pe);
 342
 343                 return NULL;
 344         }
 345
 346         pdev = eeh_dev_to_pci_dev(edev);
 347         if (!pdev)
 348                 return NULL;
 349
 350         pci_restore_state(pdev);
 351         return NULL;
 352 }
 353
 354 /**
 355  * eeh_report_resume - Tell device to resume normal operations
 356  * @data: eeh device
 357  * @userdata: return value
 358  *
 359  * This routine must be called to notify the device driver that it
 360  * could resume so that the device driver can do some initialization
 361  * to make the recovered device work again.
 362  */
 363 static void *eeh_report_resume(void *data, void *userdata)
 364 {
 365         struct eeh_dev *edev = (struct eeh_dev *)data;
 366         struct pci_dev *dev = eeh_dev_to_pci_dev(edev);
 367         bool was_in_error;
 368         struct pci_driver *driver;
 369
 370         if (!dev || eeh_dev_removed(edev) || eeh_pe_passed(edev->pe))
 371                 return NULL;
 372
 373         device_lock(&dev->dev);
 374         dev->error_state = pci_channel_io_normal;
 375
 376         driver = eeh_pcid_get(dev);
 377         if (!driver) goto out_no_dev;
 378
 379         was_in_error = edev->in_error;
 380         edev->in_error = false;
 381         eeh_enable_irq(dev);
 382
 383         if (!driver->err_handler ||
 384             !driver->err_handler->resume ||
 385             (edev->mode & EEH_DEV_NO_HANDLER) || !was_in_error) {
 386                 edev->mode &= ~EEH_DEV_NO_HANDLER;
 387                 goto out;
 388         }
 389
 390         driver->err_handler->resume(dev);
 391
 392 out:
 393         eeh_pcid_put(dev);
 394 out_no_dev:
 395         device_unlock(&dev->dev);
 396         return NULL;
 397 }
 398
 399 /**
 400  * eeh_report_failure - Tell device driver that device is dead.
 401  * @data: eeh device
 402  * @userdata: return value
 403  *
 404  * This informs the device driver that the device is permanently
 405  * dead, and that no further recovery attempts will be made on it.
 406  */
 407 static void *eeh_report_failure(void *data, void *userdata)
 408 {
 409         struct eeh_dev *edev = (struct eeh_dev *)data;
 410         struct pci_dev *dev = eeh_dev_to_pci_dev(edev);
 411         struct pci_driver *driver;
 412
 413         if (!dev || eeh_dev_removed(edev) || eeh_pe_passed(edev->pe))
 414                 return NULL;
 415
 416         device_lock(&dev->dev);
 417         dev->error_state = pci_channel_io_perm_failure;
 418
 419         driver = eeh_pcid_get(dev);
 420         if (!driver) goto out_no_dev;
 421
 422         eeh_disable_irq(dev);
 423
 424         if (!driver->err_handler ||
 425             !driver->err_handler->error_detected)
 426                 goto out;
 427
 428         driver->err_handler->error_detected(dev, pci_channel_io_perm_failure);
 429
 430 out:
 431         eeh_pcid_put(dev);
 432 out_no_dev:
 433         device_unlock(&dev->dev);
 434         return NULL;
 435 }
 436
 437 static void *eeh_add_virt_device(void *data, void *userdata)
 438 {
 439         struct pci_driver *driver;
 440         struct eeh_dev *edev = (struct eeh_dev *)data;
 441         struct pci_dev *dev = eeh_dev_to_pci_dev(edev);
 442         struct pci_dn *pdn = eeh_dev_to_pdn(edev);
 443
 444         if (!(edev->physfn)) {
 445                 pr_warn("%s: EEH dev %04x:%02x:%02x.%01x not for VF\n",
 446                         __func__, edev->phb->global_number, pdn->busno,
 447                         PCI_SLOT(pdn->devfn), PCI_FUNC(pdn->devfn));
 448                 return NULL;
 449         }
 450
 451         driver = eeh_pcid_get(dev);
 452         if (driver) {
 453                 if (driver->err_handler) {
 454                         eeh_pcid_put(dev);
 455                         return NULL;
 456                 }
 457                 eeh_pcid_put(dev);
 458         }
 459
 460 #ifdef CONFIG_PPC_POWERNV
 461         pci_iov_add_virtfn(edev->physfn, pdn->vf_index, 0);
 462 #endif
 463         return NULL;
 464 }
 465
 466 static void *eeh_rmv_device(void *data, void *userdata)
 467 {
 468         struct pci_driver *driver;
 469         struct eeh_dev *edev = (struct eeh_dev *)data;
 470         struct pci_dev *dev = eeh_dev_to_pci_dev(edev);
 471         struct eeh_rmv_data *rmv_data = (struct eeh_rmv_data *)userdata;
 472         int *removed = rmv_data ? &rmv_data->removed : NULL;
 473
 474         /*
 475          * Actually, we should remove the PCI bridges as well.
 476          * However, that's lots of complexity to do that,
 477          * particularly some of devices under the bridge might
 478          * support EEH. So we just care about PCI devices for
 479          * simplicity here.
 480          */
 481         if (!dev || (dev->hdr_type == PCI_HEADER_TYPE_BRIDGE))
 482                 return NULL;
 483
 484         /*
 485          * We rely on count-based pcibios_release_device() to
 486          * detach permanently offlined PEs. Unfortunately, that's
 487          * not reliable enough. We might have the permanently
 488          * offlined PEs attached, but we needn't take care of
 489          * them and their child devices.
 490          */
 491         if (eeh_dev_removed(edev))
 492                 return NULL;
 493
 494         if (removed) {
 495                 if (eeh_pe_passed(edev->pe))
 496                         return NULL;
 497                 driver = eeh_pcid_get(dev);
 498                 if (driver) {
 499                         if (driver->err_handler &&
 500                             driver->err_handler->error_detected &&
 501                             driver->err_handler->slot_reset) {
 502                                 eeh_pcid_put(dev);
 503                                 return NULL;
 504                         }
 505                         eeh_pcid_put(dev);
 506                 }
 507         }
 508
 509         /* Remove it from PCI subsystem */
 510         pr_debug("EEH: Removing %s without EEH sensitive driver\n",
 511                  pci_name(dev));
 512         edev->bus = dev->bus;
 513         edev->mode |= EEH_DEV_DISCONNECTED;
 514         if (removed)
 515                 (*removed)++;
 516
 517         if (edev->physfn) {
 518 #ifdef CONFIG_PPC_POWERNV
 519                 struct pci_dn *pdn = eeh_dev_to_pdn(edev);
 520
 521                 pci_iov_remove_virtfn(edev->physfn, pdn->vf_index, 0);
 522                 edev->pdev = NULL;
 523 #endif
 524                 if (rmv_data)
 525                         list_add(&edev->rmv_list, &rmv_data->edev_list);
 526         } else {
 527                 pci_lock_rescan_remove();
 528                 pci_stop_and_remove_bus_device(dev);
 529                 pci_unlock_rescan_remove();
 530         }
 531
 532         return NULL;
 533 }
 534
 535 static void *eeh_pe_detach_dev(void *data, void *userdata)
 536 {
 537         struct eeh_pe *pe = (struct eeh_pe *)data;
 538         struct eeh_dev *edev, *tmp;
 539
 540         eeh_pe_for_each_dev(pe, edev, tmp) {
 541                 if (!(edev->mode & EEH_DEV_DISCONNECTED))
 542                         continue;
 543
 544                 edev->mode &= ~(EEH_DEV_DISCONNECTED | EEH_DEV_IRQ_DISABLED);
 545                 eeh_rmv_from_parent_pe(edev);
 546         }
 547
 548         return NULL;
 549 }
 550
 551 /*
 552  * Explicitly clear PE's frozen state for PowerNV where
 553  * we have frozen PE until BAR restore is completed. It's
 554  * harmless to clear it for pSeries. To be consistent with
 555  * PE reset (for 3 times), we try to clear the frozen state
 556  * for 3 times as well.
 557  */
 558 static void *__eeh_clear_pe_frozen_state(void *data, void *flag)
 559 {
 560         struct eeh_pe *pe = (struct eeh_pe *)data;
 561         bool clear_sw_state = *(bool *)flag;
 562         int i, rc = 1;
 563
 564         for (i = 0; rc && i < 3; i++)
 565                 rc = eeh_unfreeze_pe(pe, clear_sw_state);
 566
 567         /* Stop immediately on any errors */
 568         if (rc) {
 569                 pr_warn("%s: Failure %d unfreezing PHB#%x-PE#%x\n",
 570                         __func__, rc, pe->phb->global_number, pe->addr);
 571                 return (void *)pe;
 572         }
 573
 574         return NULL;
 575 }
 576
 577 static int eeh_clear_pe_frozen_state(struct eeh_pe *pe,
 578                                      bool clear_sw_state)
 579 {
 580         void *rc;
 581
 582         rc = eeh_pe_traverse(pe, __eeh_clear_pe_frozen_state, &clear_sw_state);
 583         if (!rc)
 584                 eeh_pe_state_clear(pe, EEH_PE_ISOLATED);
 585
 586         return rc ? -EIO : 0;
 587 }
 588
 589 int eeh_pe_reset_and_recover(struct eeh_pe *pe)
 590 {
 591         int ret;
 592
 593         /* Bail if the PE is being recovered */
 594         if (pe->state & EEH_PE_RECOVERING)
 595                 return 0;
 596
 597         /* Put the PE into recovery mode */
 598         eeh_pe_state_mark(pe, EEH_PE_RECOVERING);
 599
 600         /* Save states */
 601         eeh_pe_dev_traverse(pe, eeh_dev_save_state, NULL);
 602
 603         /* Issue reset */
 604         ret = eeh_reset_pe(pe);
 605         if (ret) {
 606                 eeh_pe_state_clear(pe, EEH_PE_RECOVERING);
 607                 return ret;
 608         }
 609
 610         /* Unfreeze the PE */
 611         ret = eeh_clear_pe_frozen_state(pe, true);
 612         if (ret) {
 613                 eeh_pe_state_clear(pe, EEH_PE_RECOVERING);
 614                 return ret;
 615         }
 616
 617         /* Restore device state */
 618         eeh_pe_dev_traverse(pe, eeh_dev_restore_state, NULL);
 619
 620         /* Clear recovery mode */
 621         eeh_pe_state_clear(pe, EEH_PE_RECOVERING);
 622
 623         return 0;
 624 }
 625
 626 /**
 627  * eeh_reset_device - Perform actual reset of a pci slot
 628  * @pe: EEH PE
 629  * @bus: PCI bus corresponding to the isolcated slot
 630  *
 631  * This routine must be called to do reset on the indicated PE.
 632  * During the reset, udev might be invoked because those affected
 633  * PCI devices will be removed and then added.
 634  */
 635 static int eeh_reset_device(struct eeh_pe *pe, struct pci_bus *bus,
 636                                 struct eeh_rmv_data *rmv_data)
 637 {
 638         struct pci_bus *frozen_bus = eeh_pe_bus_get(pe);
 639         struct timeval tstamp;
 640         int cnt, rc;
 641         struct eeh_dev *edev;
 642
 643         /* pcibios will clear the counter; save the value */
 644         cnt = pe->freeze_count;
 645         tstamp = pe->tstamp;
 646
 647         /*
 648          * We don't remove the corresponding PE instances because
 649          * we need the information afterwords. The attached EEH
 650          * devices are expected to be attached soon when calling
 651          * into pci_hp_add_devices().
 652          */
 653         eeh_pe_state_mark(pe, EEH_PE_KEEP);
 654         if (bus) {
 655                 if (pe->type & EEH_PE_VF) {
 656                         eeh_pe_dev_traverse(pe, eeh_rmv_device, NULL);
 657                 } else {
 658                         pci_lock_rescan_remove();
 659                         pci_hp_remove_devices(bus);
 660                         pci_unlock_rescan_remove();
 661                 }
 662         } else if (frozen_bus) {
 663                 eeh_pe_dev_traverse(pe, eeh_rmv_device, rmv_data);
 664         }
 665
 666         /*
 667          * Reset the pci controller. (Asserts RST#; resets config space).
 668          * Reconfigure bridges and devices. Don't try to bring the system
 669          * up if the reset failed for some reason.
 670          *
 671          * During the reset, it's very dangerous to have uncontrolled PCI
 672          * config accesses. So we prefer to block them. However, controlled
 673          * PCI config accesses initiated from EEH itself are allowed.
 674          */
 675         rc = eeh_reset_pe(pe);
 676         if (rc)
 677                 return rc;
 678
 679         pci_lock_rescan_remove();
 680
 681         /* Restore PE */
 682         eeh_ops->configure_bridge(pe);
 683         eeh_pe_restore_bars(pe);
 684
 685         /* Clear frozen state */
 686         rc = eeh_clear_pe_frozen_state(pe, false);
 687         if (rc) {
 688                 pci_unlock_rescan_remove();
 689                 return rc;
 690         }
 691
 692         /* Give the system 5 seconds to finish running the user-space
 693          * hotplug shutdown scripts, e.g. ifdown for ethernet.  Yes,
 694          * this is a hack, but if we don't do this, and try to bring
 695          * the device up before the scripts have taken it down,
 696          * potentially weird things happen.
 697          */
 698         if (bus) {
 699                 pr_info("EEH: Sleep 5s ahead of complete hotplug\n");
 700                 ssleep(5);
 701
 702                 /*
 703                  * The EEH device is still connected with its parent
 704                  * PE. We should disconnect it so the binding can be
 705                  * rebuilt when adding PCI devices.
 706                  */
 707                 edev = list_first_entry(&pe->edevs, struct eeh_dev, list);
 708                 eeh_pe_traverse(pe, eeh_pe_detach_dev, NULL);
 709                 if (pe->type & EEH_PE_VF) {
 710                         eeh_add_virt_device(edev, NULL);
 711                 } else {
 712                         eeh_pe_state_clear(pe, EEH_PE_PRI_BUS);
 713                         pci_hp_add_devices(bus);
 714                 }
 715         } else if (frozen_bus && rmv_data->removed) {
 716                 pr_info("EEH: Sleep 5s ahead of partial hotplug\n");
 717                 ssleep(5);
 718
 719                 edev = list_first_entry(&pe->edevs, struct eeh_dev, list);
 720                 eeh_pe_traverse(pe, eeh_pe_detach_dev, NULL);
 721                 if (pe->type & EEH_PE_VF)
 722                         eeh_add_virt_device(edev, NULL);
 723                 else
 724                         pci_hp_add_devices(frozen_bus);
 725         }
 726         eeh_pe_state_clear(pe, EEH_PE_KEEP);
 727
 728         pe->tstamp = tstamp;
 729         pe->freeze_count = cnt;
 730
 731         pci_unlock_rescan_remove();
 732         return 0;
 733 }
 734
 735 /* The longest amount of time to wait for a pci device
 736  * to come back on line, in seconds.
 737  */
 738 #define MAX_WAIT_FOR_RECOVERY 300
 739
 740 static bool eeh_handle_normal_event(struct eeh_pe *pe)
 741 {
 742         struct pci_bus *frozen_bus;
 743         struct eeh_dev *edev, *tmp;
 744         int rc = 0;
 745         enum pci_ers_result result = PCI_ERS_RESULT_NONE;
 746         struct eeh_rmv_data rmv_data = {LIST_HEAD_INIT(rmv_data.edev_list), 0};
 747
 748         frozen_bus = eeh_pe_bus_get(pe);
 749         if (!frozen_bus) {
 750                 pr_err("%s: Cannot find PCI bus for PHB#%d-PE#%x\n",
 751                         __func__, pe->phb->global_number, pe->addr);
 752                 return false;
 753         }
 754
 755         eeh_pe_update_time_stamp(pe);
 756         pe->freeze_count++;
 757         if (pe->freeze_count > eeh_max_freezes)
 758                 goto excess_failures;
 759         pr_warn("EEH: This PCI device has failed %d times in the last hour\n",
 760                 pe->freeze_count);
 761
 762         /* Walk the various device drivers attached to this slot through
 763          * a reset sequence, giving each an opportunity to do what it needs
 764          * to accomplish the reset.  Each child gets a report of the
 765          * status ... if any child can't handle the reset, then the entire
 766          * slot is dlpar removed and added.
 767          *
 768          * When the PHB is fenced, we have to issue a reset to recover from
 769          * the error. Override the result if necessary to have partially
 770          * hotplug for this case.
 771          */
 772         pr_info("EEH: Notify device drivers to shutdown\n");
 773         eeh_pe_dev_traverse(pe, eeh_report_error, &result);
 774         if ((pe->type & EEH_PE_PHB) &&
 775             result != PCI_ERS_RESULT_NONE &&
 776             result != PCI_ERS_RESULT_NEED_RESET)
 777                 result = PCI_ERS_RESULT_NEED_RESET;
 778
 779         /* Get the current PCI slot state. This can take a long time,
 780          * sometimes over 300 seconds for certain systems.
 781          */
 782         rc = eeh_ops->wait_state(pe, MAX_WAIT_FOR_RECOVERY*1000);
 783         if (rc < 0 || rc == EEH_STATE_NOT_SUPPORT) {
 784                 pr_warn("EEH: Permanent failure\n");
 785                 goto hard_fail;
 786         }
 787
 788         /* Since rtas may enable MMIO when posting the error log,
 789          * don't post the error log until after all dev drivers
 790          * have been informed.
 791          */
 792         pr_info("EEH: Collect temporary log\n");
 793         eeh_slot_error_detail(pe, EEH_LOG_TEMP);
 794
 795         /* If all device drivers were EEH-unaware, then shut
 796          * down all of the device drivers, and hope they
 797          * go down willingly, without panicing the system.
 798          */
 799         if (result == PCI_ERS_RESULT_NONE) {
 800                 pr_info("EEH: Reset with hotplug activity\n");
 801                 rc = eeh_reset_device(pe, frozen_bus, NULL);
 802                 if (rc) {
 803                         pr_warn("%s: Unable to reset, err=%d\n",
 804                                 __func__, rc);
 805                         goto hard_fail;
 806                 }
 807         }
 808
 809         /* If all devices reported they can proceed, then re-enable MMIO */
 810         if (result == PCI_ERS_RESULT_CAN_RECOVER) {
 811                 pr_info("EEH: Enable I/O for affected devices\n");
 812                 rc = eeh_pci_enable(pe, EEH_OPT_THAW_MMIO);
 813
 814                 if (rc < 0)
 815                         goto hard_fail;
 816                 if (rc) {
 817                         result = PCI_ERS_RESULT_NEED_RESET;
 818                 } else {
 819                         pr_info("EEH: Notify device drivers to resume I/O\n");
 820                         eeh_pe_dev_traverse(pe, eeh_report_mmio_enabled, &result);
 821                 }
 822         }
 823
 824         /* If all devices reported they can proceed, then re-enable DMA */
 825         if (result == PCI_ERS_RESULT_CAN_RECOVER) {
 826                 pr_info("EEH: Enabled DMA for affected devices\n");
 827                 rc = eeh_pci_enable(pe, EEH_OPT_THAW_DMA);
 828
 829                 if (rc < 0)
 830                         goto hard_fail;
 831                 if (rc) {
 832                         result = PCI_ERS_RESULT_NEED_RESET;
 833                 } else {
 834                         /*
 835                          * We didn't do PE reset for the case. The PE
 836                          * is still in frozen state. Clear it before
 837                          * resuming the PE.
 838                          */
 839                         eeh_pe_state_clear(pe, EEH_PE_ISOLATED);
 840                         result = PCI_ERS_RESULT_RECOVERED;
 841                 }
 842         }
 843
 844         /* If any device has a hard failure, then shut off everything. */
 845         if (result == PCI_ERS_RESULT_DISCONNECT) {
 846                 pr_warn("EEH: Device driver gave up\n");
 847                 goto hard_fail;
 848         }
 849
 850         /* If any device called out for a reset, then reset the slot */
 851         if (result == PCI_ERS_RESULT_NEED_RESET) {
 852                 pr_info("EEH: Reset without hotplug activity\n");
 853                 rc = eeh_reset_device(pe, NULL, &rmv_data);
 854                 if (rc) {
 855                         pr_warn("%s: Cannot reset, err=%d\n",
 856                                 __func__, rc);
 857                         goto hard_fail;
 858                 }
 859
 860                 pr_info("EEH: Notify device drivers "
 861                         "the completion of reset\n");
 862                 result = PCI_ERS_RESULT_NONE;
 863                 eeh_pe_dev_traverse(pe, eeh_report_reset, &result);
 864         }
 865
 866         /* All devices should claim they have recovered by now. */
 867         if ((result != PCI_ERS_RESULT_RECOVERED) &&
 868             (result != PCI_ERS_RESULT_NONE)) {
 869                 pr_warn("EEH: Not recovered\n");
 870                 goto hard_fail;
 871         }
 872
 873         /*
 874          * For those hot removed VFs, we should add back them after PF get
 875          * recovered properly.
 876          */
 877         list_for_each_entry_safe(edev, tmp, &rmv_data.edev_list, rmv_list) {
 878                 eeh_add_virt_device(edev, NULL);
 879                 list_del(&edev->rmv_list);
 880         }
 881
 882         /* Tell all device drivers that they can resume operations */
 883         pr_info("EEH: Notify device driver to resume\n");
 884         eeh_pe_dev_traverse(pe, eeh_report_resume, NULL);
 885
 886         return false;
 887
 888 excess_failures:
 889         /*
 890          * About 90% of all real-life EEH failures in the field
 891          * are due to poorly seated PCI cards. Only 10% or so are
 892          * due to actual, failed cards.
 893          */
 894         pr_err("EEH: PHB#%d-PE#%x has failed %d times in the\n"
 895                "last hour and has been permanently disabled.\n"
 896                "Please try reseating or replacing it.\n",
 897                 pe->phb->global_number, pe->addr,
 898                 pe->freeze_count);
 899         goto perm_error;
 900
 901 hard_fail:
 902         pr_err("EEH: Unable to recover from failure from PHB#%d-PE#%x.\n"
 903                "Please try reseating or replacing it\n",
 904                 pe->phb->global_number, pe->addr);
 905
 906 perm_error:
 907         eeh_slot_error_detail(pe, EEH_LOG_PERM);
 908
 909         /* Notify all devices that they're about to go down. */
 910         eeh_pe_dev_traverse(pe, eeh_report_failure, NULL);
 911
 912         /* Mark the PE to be removed permanently */
 913         eeh_pe_state_mark(pe, EEH_PE_REMOVED);
 914
 915         /*
 916          * Shut down the device drivers for good. We mark
 917          * all removed devices correctly to avoid access
 918          * the their PCI config any more.
 919          */
 920         if (frozen_bus) {
 921                 if (pe->type & EEH_PE_VF) {
 922                         eeh_pe_dev_traverse(pe, eeh_rmv_device, NULL);
 923                         eeh_pe_dev_mode_mark(pe, EEH_DEV_REMOVED);
 924                 } else {
 925                         eeh_pe_state_clear(pe, EEH_PE_PRI_BUS);
 926                         eeh_pe_dev_mode_mark(pe, EEH_DEV_REMOVED);
 927
 928                         pci_lock_rescan_remove();
 929                         pci_hp_remove_devices(frozen_bus);
 930                         pci_unlock_rescan_remove();
 931
 932                         /* The passed PE should no longer be used */
 933                         return true;
 934                 }
 935         }
 936         return false;
 937 }
 938
 939 static void eeh_handle_special_event(void)
 940 {
 941         struct eeh_pe *pe, *phb_pe;
 942         struct pci_bus *bus;
 943         struct pci_controller *hose;
 944         unsigned long flags;
 945         int rc;
 946
 947
 948         do {
 949                 rc = eeh_ops->next_error(&pe);
 950
 951                 switch (rc) {
 952                 case EEH_NEXT_ERR_DEAD_IOC:
 953                         /* Mark all PHBs in dead state */
 954                         eeh_serialize_lock(&flags);
 955
 956                         /* Purge all events */
 957                         eeh_remove_event(NULL, true);
 958
 959                         list_for_each_entry(hose, &hose_list, list_node) {
 960                                 phb_pe = eeh_phb_pe_get(hose);
 961                                 if (!phb_pe) continue;
 962
 963                                 eeh_pe_state_mark(phb_pe, EEH_PE_ISOLATED);
 964                         }
 965
 966                         eeh_serialize_unlock(flags);
 967
 968                         break;
 969                 case EEH_NEXT_ERR_FROZEN_PE:
 970                 case EEH_NEXT_ERR_FENCED_PHB:
 971                 case EEH_NEXT_ERR_DEAD_PHB:
 972                         /* Mark the PE in fenced state */
 973                         eeh_serialize_lock(&flags);
 974
 975                         /* Purge all events of the PHB */
 976                         eeh_remove_event(pe, true);
 977
 978                         if (rc == EEH_NEXT_ERR_DEAD_PHB)
 979                                 eeh_pe_state_mark(pe, EEH_PE_ISOLATED);
 980                         else
 981                                 eeh_pe_state_mark(pe,
 982                                         EEH_PE_ISOLATED | EEH_PE_RECOVERING);
 983
 984                         eeh_serialize_unlock(flags);
 985
 986                         break;
 987                 case EEH_NEXT_ERR_NONE:
 988                         return;
 989                 default:
 990                         pr_warn("%s: Invalid value %d from next_error()\n",
 991                                 __func__, rc);
 992                         return;
 993                 }
 994
 995                 /*
 996                  * For fenced PHB and frozen PE, it's handled as normal
 997                  * event. We have to remove the affected PHBs for dead
 998                  * PHB and IOC
 999                  */
1000                 if (rc == EEH_NEXT_ERR_FROZEN_PE ||
1001                     rc == EEH_NEXT_ERR_FENCED_PHB) {
1002                         /*
1003                          * eeh_handle_normal_event() can make the PE stale if it
1004                          * determines that the PE cannot possibly be recovered.
1005                          * Don't modify the PE state if that's the case.
1006                          */
1007                         if (eeh_handle_normal_event(pe))
1008                                 continue;
1009
1010                         eeh_pe_state_clear(pe, EEH_PE_RECOVERING);
1011                 } else {
1012                         pci_lock_rescan_remove();
1013                         list_for_each_entry(hose, &hose_list, list_node) {
1014                                 phb_pe = eeh_phb_pe_get(hose);
1015                                 if (!phb_pe ||
1016                                     !(phb_pe->state & EEH_PE_ISOLATED) ||
1017                                     (phb_pe->state & EEH_PE_RECOVERING))
1018                                         continue;
1019
1020                                 /* Notify all devices to be down */
1021                                 eeh_pe_state_clear(pe, EEH_PE_PRI_BUS);
1022                                 eeh_pe_dev_traverse(pe,
1023                                         eeh_report_failure, NULL);
1024                                 bus = eeh_pe_bus_get(phb_pe);
1025                                 if (!bus) {
1026                                         pr_err("%s: Cannot find PCI bus for "
1027                                                "PHB#%d-PE#%x\n",
1028                                                __func__,
1029                                                pe->phb->global_number,
1030                                                pe->addr);
1031                                         break;
1032                                 }
1033                                 pci_hp_remove_devices(bus);
1034                         }
1035                         pci_unlock_rescan_remove();
1036                 }
1037
1038                 /*
1039                  * If we have detected dead IOC, we needn't proceed
1040                  * any more since all PHBs would have been removed
1041                  */
1042                 if (rc == EEH_NEXT_ERR_DEAD_IOC)
1043                         break;
1044         } while (rc != EEH_NEXT_ERR_NONE);
1045 }
1046
1047 /**
1048  * eeh_handle_event - Reset a PCI device after hard lockup.
1049  * @pe: EEH PE
1050  *
1051  * While PHB detects address or data parity errors on particular PCI
1052  * slot, the associated PE will be frozen. Besides, DMA's occurring
1053  * to wild addresses (which usually happen due to bugs in device
1054  * drivers or in PCI adapter firmware) can cause EEH error. #SERR,
1055  * #PERR or other misc PCI-related errors also can trigger EEH errors.
1056  *
1057  * Recovery process consists of unplugging the device driver (which
1058  * generated hotplug events to userspace), then issuing a PCI #RST to
1059  * the device, then reconfiguring the PCI config space for all bridges
1060  * & devices under this slot, and then finally restarting the device
1061  * drivers (which cause a second set of hotplug events to go out to
1062  * userspace).
1063  */
1064 void eeh_handle_event(struct eeh_pe *pe)
1065 {
1066         if (pe)
1067                 eeh_handle_normal_event(pe);
1068         else
1069                 eeh_handle_special_event();
1070 }