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 assymetries 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         dev->error_state = pci_channel_io_frozen;
 211
 212         driver = eeh_pcid_get(dev);
 213         if (!driver) return NULL;
 214
 215         eeh_disable_irq(dev);
 216
 217         if (!driver->err_handler ||
 218             !driver->err_handler->error_detected) {
 219                 eeh_pcid_put(dev);
 220                 return NULL;
 221         }
 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         eeh_pcid_put(dev);
 231         return NULL;
 232 }
 233
 234 /**
 235  * eeh_report_mmio_enabled - Tell drivers that MMIO has been enabled
 236  * @data: eeh device
 237  * @userdata: return value
 238  *
 239  * Tells each device driver that IO ports, MMIO and config space I/O
 240  * are now enabled. Collects up and merges the device driver responses.
 241  * Cumulative response passed back in "userdata".
 242  */
 243 static void *eeh_report_mmio_enabled(void *data, void *userdata)
 244 {
 245         struct eeh_dev *edev = (struct eeh_dev *)data;
 246         struct pci_dev *dev = eeh_dev_to_pci_dev(edev);
 247         enum pci_ers_result rc, *res = userdata;
 248         struct pci_driver *driver;
 249
 250         if (!dev || eeh_dev_removed(edev) || eeh_pe_passed(edev->pe))
 251                 return NULL;
 252
 253         driver = eeh_pcid_get(dev);
 254         if (!driver) return NULL;
 255
 256         if (!driver->err_handler ||
 257             !driver->err_handler->mmio_enabled ||
 258             (edev->mode & EEH_DEV_NO_HANDLER)) {
 259                 eeh_pcid_put(dev);
 260                 return NULL;
 261         }
 262
 263         rc = driver->err_handler->mmio_enabled(dev);
 264
 265         /* A driver that needs a reset trumps all others */
 266         if (rc == PCI_ERS_RESULT_NEED_RESET) *res = rc;
 267         if (*res == PCI_ERS_RESULT_NONE) *res = rc;
 268
 269         eeh_pcid_put(dev);
 270         return NULL;
 271 }
 272
 273 /**
 274  * eeh_report_reset - Tell device that slot has been reset
 275  * @data: eeh device
 276  * @userdata: return value
 277  *
 278  * This routine must be called while EEH tries to reset particular
 279  * PCI device so that the associated PCI device driver could take
 280  * some actions, usually to save data the driver needs so that the
 281  * driver can work again while the device is recovered.
 282  */
 283 static void *eeh_report_reset(void *data, void *userdata)
 284 {
 285         struct eeh_dev *edev = (struct eeh_dev *)data;
 286         struct pci_dev *dev = eeh_dev_to_pci_dev(edev);
 287         enum pci_ers_result rc, *res = userdata;
 288         struct pci_driver *driver;
 289
 290         if (!dev || eeh_dev_removed(edev) || eeh_pe_passed(edev->pe))
 291                 return NULL;
 292         dev->error_state = pci_channel_io_normal;
 293
 294         driver = eeh_pcid_get(dev);
 295         if (!driver) return NULL;
 296
 297         eeh_enable_irq(dev);
 298
 299         if (!driver->err_handler ||
 300             !driver->err_handler->slot_reset ||
 301             (edev->mode & EEH_DEV_NO_HANDLER) ||
 302             (!edev->in_error)) {
 303                 eeh_pcid_put(dev);
 304                 return NULL;
 305         }
 306
 307         rc = driver->err_handler->slot_reset(dev);
 308         if ((*res == PCI_ERS_RESULT_NONE) ||
 309             (*res == PCI_ERS_RESULT_RECOVERED)) *res = rc;
 310         if (*res == PCI_ERS_RESULT_DISCONNECT &&
 311              rc == PCI_ERS_RESULT_NEED_RESET) *res = rc;
 312
 313         eeh_pcid_put(dev);
 314         return NULL;
 315 }
 316
 317 static void *eeh_dev_restore_state(void *data, void *userdata)
 318 {
 319         struct eeh_dev *edev = data;
 320         struct pci_dev *pdev;
 321
 322         if (!edev)
 323                 return NULL;
 324
 325         /*
 326          * The content in the config space isn't saved because
 327          * the blocked config space on some adapters. We have
 328          * to restore the initial saved config space when the
 329          * EEH device is created.
 330          */
 331         if (edev->pe && (edev->pe->state & EEH_PE_CFG_RESTRICTED)) {
 332                 if (list_is_last(&edev->list, &edev->pe->edevs))
 333                         eeh_pe_restore_bars(edev->pe);
 334
 335                 return NULL;
 336         }
 337
 338         pdev = eeh_dev_to_pci_dev(edev);
 339         if (!pdev)
 340                 return NULL;
 341
 342         pci_restore_state(pdev);
 343         return NULL;
 344 }
 345
 346 /**
 347  * eeh_report_resume - Tell device to resume normal operations
 348  * @data: eeh device
 349  * @userdata: return value
 350  *
 351  * This routine must be called to notify the device driver that it
 352  * could resume so that the device driver can do some initialization
 353  * to make the recovered device work again.
 354  */
 355 static void *eeh_report_resume(void *data, void *userdata)
 356 {
 357         struct eeh_dev *edev = (struct eeh_dev *)data;
 358         struct pci_dev *dev = eeh_dev_to_pci_dev(edev);
 359         bool was_in_error;
 360         struct pci_driver *driver;
 361
 362         if (!dev || eeh_dev_removed(edev) || eeh_pe_passed(edev->pe))
 363                 return NULL;
 364         dev->error_state = pci_channel_io_normal;
 365
 366         driver = eeh_pcid_get(dev);
 367         if (!driver) return NULL;
 368
 369         was_in_error = edev->in_error;
 370         edev->in_error = false;
 371         eeh_enable_irq(dev);
 372
 373         if (!driver->err_handler ||
 374             !driver->err_handler->resume ||
 375             (edev->mode & EEH_DEV_NO_HANDLER) || !was_in_error) {
 376                 edev->mode &= ~EEH_DEV_NO_HANDLER;
 377                 eeh_pcid_put(dev);
 378                 return NULL;
 379         }
 380
 381         driver->err_handler->resume(dev);
 382
 383         eeh_pcid_put(dev);
 384         return NULL;
 385 }
 386
 387 /**
 388  * eeh_report_failure - Tell device driver that device is dead.
 389  * @data: eeh device
 390  * @userdata: return value
 391  *
 392  * This informs the device driver that the device is permanently
 393  * dead, and that no further recovery attempts will be made on it.
 394  */
 395 static void *eeh_report_failure(void *data, void *userdata)
 396 {
 397         struct eeh_dev *edev = (struct eeh_dev *)data;
 398         struct pci_dev *dev = eeh_dev_to_pci_dev(edev);
 399         struct pci_driver *driver;
 400
 401         if (!dev || eeh_dev_removed(edev) || eeh_pe_passed(edev->pe))
 402                 return NULL;
 403         dev->error_state = pci_channel_io_perm_failure;
 404
 405         driver = eeh_pcid_get(dev);
 406         if (!driver) return NULL;
 407
 408         eeh_disable_irq(dev);
 409
 410         if (!driver->err_handler ||
 411             !driver->err_handler->error_detected) {
 412                 eeh_pcid_put(dev);
 413                 return NULL;
 414         }
 415
 416         driver->err_handler->error_detected(dev, pci_channel_io_perm_failure);
 417
 418         eeh_pcid_put(dev);
 419         return NULL;
 420 }
 421
 422 static void *eeh_add_virt_device(void *data, void *userdata)
 423 {
 424         struct pci_driver *driver;
 425         struct eeh_dev *edev = (struct eeh_dev *)data;
 426         struct pci_dev *dev = eeh_dev_to_pci_dev(edev);
 427         struct pci_dn *pdn = eeh_dev_to_pdn(edev);
 428
 429         if (!(edev->physfn)) {
 430                 pr_warn("%s: EEH dev %04x:%02x:%02x.%01x not for VF\n",
 431                         __func__, edev->phb->global_number, pdn->busno,
 432                         PCI_SLOT(pdn->devfn), PCI_FUNC(pdn->devfn));
 433                 return NULL;
 434         }
 435
 436         driver = eeh_pcid_get(dev);
 437         if (driver) {
 438                 eeh_pcid_put(dev);
 439                 if (driver->err_handler)
 440                         return NULL;
 441         }
 442
 443 #ifdef CONFIG_PPC_POWERNV
 444         pci_iov_add_virtfn(edev->physfn, pdn->vf_index, 0);
 445 #endif
 446         return NULL;
 447 }
 448
 449 static void *eeh_rmv_device(void *data, void *userdata)
 450 {
 451         struct pci_driver *driver;
 452         struct eeh_dev *edev = (struct eeh_dev *)data;
 453         struct pci_dev *dev = eeh_dev_to_pci_dev(edev);
 454         struct eeh_rmv_data *rmv_data = (struct eeh_rmv_data *)userdata;
 455         int *removed = rmv_data ? &rmv_data->removed : NULL;
 456
 457         /*
 458          * Actually, we should remove the PCI bridges as well.
 459          * However, that's lots of complexity to do that,
 460          * particularly some of devices under the bridge might
 461          * support EEH. So we just care about PCI devices for
 462          * simplicity here.
 463          */
 464         if (!dev || (dev->hdr_type == PCI_HEADER_TYPE_BRIDGE))
 465                 return NULL;
 466
 467         /*
 468          * We rely on count-based pcibios_release_device() to
 469          * detach permanently offlined PEs. Unfortunately, that's
 470          * not reliable enough. We might have the permanently
 471          * offlined PEs attached, but we needn't take care of
 472          * them and their child devices.
 473          */
 474         if (eeh_dev_removed(edev))
 475                 return NULL;
 476
 477         driver = eeh_pcid_get(dev);
 478         if (driver) {
 479                 eeh_pcid_put(dev);
 480                 if (removed &&
 481                     eeh_pe_passed(edev->pe))
 482                         return NULL;
 483                 if (removed &&
 484                     driver->err_handler &&
 485                     driver->err_handler->error_detected &&
 486                     driver->err_handler->slot_reset)
 487                         return NULL;
 488         }
 489
 490         /* Remove it from PCI subsystem */
 491         pr_debug("EEH: Removing %s without EEH sensitive driver\n",
 492                  pci_name(dev));
 493         edev->bus = dev->bus;
 494         edev->mode |= EEH_DEV_DISCONNECTED;
 495         if (removed)
 496                 (*removed)++;
 497
 498         if (edev->physfn) {
 499 #ifdef CONFIG_PPC_POWERNV
 500                 struct pci_dn *pdn = eeh_dev_to_pdn(edev);
 501
 502                 pci_iov_remove_virtfn(edev->physfn, pdn->vf_index, 0);
 503                 edev->pdev = NULL;
 504
 505                 /*
 506                  * We have to set the VF PE number to invalid one, which is
 507                  * required to plug the VF successfully.
 508                  */
 509                 pdn->pe_number = IODA_INVALID_PE;
 510 #endif
 511                 if (rmv_data)
 512                         list_add(&edev->rmv_list, &rmv_data->edev_list);
 513         } else {
 514                 pci_lock_rescan_remove();
 515                 pci_stop_and_remove_bus_device(dev);
 516                 pci_unlock_rescan_remove();
 517         }
 518
 519         return NULL;
 520 }
 521
 522 static void *eeh_pe_detach_dev(void *data, void *userdata)
 523 {
 524         struct eeh_pe *pe = (struct eeh_pe *)data;
 525         struct eeh_dev *edev, *tmp;
 526
 527         eeh_pe_for_each_dev(pe, edev, tmp) {
 528                 if (!(edev->mode & EEH_DEV_DISCONNECTED))
 529                         continue;
 530
 531                 edev->mode &= ~(EEH_DEV_DISCONNECTED | EEH_DEV_IRQ_DISABLED);
 532                 eeh_rmv_from_parent_pe(edev);
 533         }
 534
 535         return NULL;
 536 }
 537
 538 /*
 539  * Explicitly clear PE's frozen state for PowerNV where
 540  * we have frozen PE until BAR restore is completed. It's
 541  * harmless to clear it for pSeries. To be consistent with
 542  * PE reset (for 3 times), we try to clear the frozen state
 543  * for 3 times as well.
 544  */
 545 static void *__eeh_clear_pe_frozen_state(void *data, void *flag)
 546 {
 547         struct eeh_pe *pe = (struct eeh_pe *)data;
 548         bool *clear_sw_state = flag;
 549         int i, rc = 1;
 550
 551         for (i = 0; rc && i < 3; i++)
 552                 rc = eeh_unfreeze_pe(pe, clear_sw_state);
 553
 554         /* Stop immediately on any errors */
 555         if (rc) {
 556                 pr_warn("%s: Failure %d unfreezing PHB#%x-PE#%x\n",
 557                         __func__, rc, pe->phb->global_number, pe->addr);
 558                 return (void *)pe;
 559         }
 560
 561         return NULL;
 562 }
 563
 564 static int eeh_clear_pe_frozen_state(struct eeh_pe *pe,
 565                                      bool clear_sw_state)
 566 {
 567         void *rc;
 568
 569         rc = eeh_pe_traverse(pe, __eeh_clear_pe_frozen_state, &clear_sw_state);
 570         if (!rc)
 571                 eeh_pe_state_clear(pe, EEH_PE_ISOLATED);
 572
 573         return rc ? -EIO : 0;
 574 }
 575
 576 int eeh_pe_reset_and_recover(struct eeh_pe *pe)
 577 {
 578         int ret;
 579
 580         /* Bail if the PE is being recovered */
 581         if (pe->state & EEH_PE_RECOVERING)
 582                 return 0;
 583
 584         /* Put the PE into recovery mode */
 585         eeh_pe_state_mark(pe, EEH_PE_RECOVERING);
 586
 587         /* Save states */
 588         eeh_pe_dev_traverse(pe, eeh_dev_save_state, NULL);
 589
 590         /* Issue reset */
 591         ret = eeh_reset_pe(pe);
 592         if (ret) {
 593                 eeh_pe_state_clear(pe, EEH_PE_RECOVERING);
 594                 return ret;
 595         }
 596
 597         /* Unfreeze the PE */
 598         ret = eeh_clear_pe_frozen_state(pe, true);
 599         if (ret) {
 600                 eeh_pe_state_clear(pe, EEH_PE_RECOVERING);
 601                 return ret;
 602         }
 603
 604         /* Restore device state */
 605         eeh_pe_dev_traverse(pe, eeh_dev_restore_state, NULL);
 606
 607         /* Clear recovery mode */
 608         eeh_pe_state_clear(pe, EEH_PE_RECOVERING);
 609
 610         return 0;
 611 }
 612
 613 /**
 614  * eeh_reset_device - Perform actual reset of a pci slot
 615  * @pe: EEH PE
 616  * @bus: PCI bus corresponding to the isolcated slot
 617  *
 618  * This routine must be called to do reset on the indicated PE.
 619  * During the reset, udev might be invoked because those affected
 620  * PCI devices will be removed and then added.
 621  */
 622 static int eeh_reset_device(struct eeh_pe *pe, struct pci_bus *bus,
 623                                 struct eeh_rmv_data *rmv_data)
 624 {
 625         struct pci_bus *frozen_bus = eeh_pe_bus_get(pe);
 626         struct timeval tstamp;
 627         int cnt, rc;
 628         struct eeh_dev *edev;
 629
 630         /* pcibios will clear the counter; save the value */
 631         cnt = pe->freeze_count;
 632         tstamp = pe->tstamp;
 633
 634         /*
 635          * We don't remove the corresponding PE instances because
 636          * we need the information afterwords. The attached EEH
 637          * devices are expected to be attached soon when calling
 638          * into pci_hp_add_devices().
 639          */
 640         eeh_pe_state_mark(pe, EEH_PE_KEEP);
 641         if (bus) {
 642                 if (pe->type & EEH_PE_VF) {
 643                         eeh_pe_dev_traverse(pe, eeh_rmv_device, NULL);
 644                 } else {
 645                         eeh_pe_state_clear(pe, EEH_PE_PRI_BUS);
 646                         pci_lock_rescan_remove();
 647                         pci_hp_remove_devices(bus);
 648                         pci_unlock_rescan_remove();
 649                 }
 650         } else if (frozen_bus) {
 651                 eeh_pe_dev_traverse(pe, eeh_rmv_device, &rmv_data);
 652         }
 653
 654         /*
 655          * Reset the pci controller. (Asserts RST#; resets config space).
 656          * Reconfigure bridges and devices. Don't try to bring the system
 657          * up if the reset failed for some reason.
 658          *
 659          * During the reset, it's very dangerous to have uncontrolled PCI
 660          * config accesses. So we prefer to block them. However, controlled
 661          * PCI config accesses initiated from EEH itself are allowed.
 662          */
 663         rc = eeh_reset_pe(pe);
 664         if (rc)
 665                 return rc;
 666
 667         pci_lock_rescan_remove();
 668
 669         /* Restore PE */
 670         eeh_ops->configure_bridge(pe);
 671         eeh_pe_restore_bars(pe);
 672
 673         /* Clear frozen state */
 674         rc = eeh_clear_pe_frozen_state(pe, false);
 675         if (rc)
 676                 return rc;
 677
 678         /* Give the system 5 seconds to finish running the user-space
 679          * hotplug shutdown scripts, e.g. ifdown for ethernet.  Yes,
 680          * this is a hack, but if we don't do this, and try to bring
 681          * the device up before the scripts have taken it down,
 682          * potentially weird things happen.
 683          */
 684         if (bus) {
 685                 pr_info("EEH: Sleep 5s ahead of complete hotplug\n");
 686                 ssleep(5);
 687
 688                 /*
 689                  * The EEH device is still connected with its parent
 690                  * PE. We should disconnect it so the binding can be
 691                  * rebuilt when adding PCI devices.
 692                  */
 693                 edev = list_first_entry(&pe->edevs, struct eeh_dev, list);
 694                 eeh_pe_traverse(pe, eeh_pe_detach_dev, NULL);
 695                 if (pe->type & EEH_PE_VF)
 696                         eeh_add_virt_device(edev, NULL);
 697                 else
 698                         pci_hp_add_devices(bus);
 699         } else if (frozen_bus && rmv_data->removed) {
 700                 pr_info("EEH: Sleep 5s ahead of partial hotplug\n");
 701                 ssleep(5);
 702
 703                 edev = list_first_entry(&pe->edevs, struct eeh_dev, list);
 704                 eeh_pe_traverse(pe, eeh_pe_detach_dev, NULL);
 705                 if (pe->type & EEH_PE_VF)
 706                         eeh_add_virt_device(edev, NULL);
 707                 else
 708                         pci_hp_add_devices(frozen_bus);
 709         }
 710         eeh_pe_state_clear(pe, EEH_PE_KEEP);
 711
 712         pe->tstamp = tstamp;
 713         pe->freeze_count = cnt;
 714
 715         pci_unlock_rescan_remove();
 716         return 0;
 717 }
 718
 719 /* The longest amount of time to wait for a pci device
 720  * to come back on line, in seconds.
 721  */
 722 #define MAX_WAIT_FOR_RECOVERY 300
 723
 724 static void eeh_handle_normal_event(struct eeh_pe *pe)
 725 {
 726         struct pci_bus *frozen_bus;
 727         struct eeh_dev *edev, *tmp;
 728         int rc = 0;
 729         enum pci_ers_result result = PCI_ERS_RESULT_NONE;
 730         struct eeh_rmv_data rmv_data = {LIST_HEAD_INIT(rmv_data.edev_list), 0};
 731
 732         frozen_bus = eeh_pe_bus_get(pe);
 733         if (!frozen_bus) {
 734                 pr_err("%s: Cannot find PCI bus for PHB#%d-PE#%x\n",
 735                         __func__, pe->phb->global_number, pe->addr);
 736                 return;
 737         }
 738
 739         eeh_pe_update_time_stamp(pe);
 740         pe->freeze_count++;
 741         if (pe->freeze_count > eeh_max_freezes)
 742                 goto excess_failures;
 743         pr_warn("EEH: This PCI device has failed %d times in the last hour\n",
 744                 pe->freeze_count);
 745
 746         /* Walk the various device drivers attached to this slot through
 747          * a reset sequence, giving each an opportunity to do what it needs
 748          * to accomplish the reset.  Each child gets a report of the
 749          * status ... if any child can't handle the reset, then the entire
 750          * slot is dlpar removed and added.
 751          *
 752          * When the PHB is fenced, we have to issue a reset to recover from
 753          * the error. Override the result if necessary to have partially
 754          * hotplug for this case.
 755          */
 756         pr_info("EEH: Notify device drivers to shutdown\n");
 757         eeh_pe_dev_traverse(pe, eeh_report_error, &result);
 758         if ((pe->type & EEH_PE_PHB) &&
 759             result != PCI_ERS_RESULT_NONE &&
 760             result != PCI_ERS_RESULT_NEED_RESET)
 761                 result = PCI_ERS_RESULT_NEED_RESET;
 762
 763         /* Get the current PCI slot state. This can take a long time,
 764          * sometimes over 300 seconds for certain systems.
 765          */
 766         rc = eeh_ops->wait_state(pe, MAX_WAIT_FOR_RECOVERY*1000);
 767         if (rc < 0 || rc == EEH_STATE_NOT_SUPPORT) {
 768                 pr_warn("EEH: Permanent failure\n");
 769                 goto hard_fail;
 770         }
 771
 772         /* Since rtas may enable MMIO when posting the error log,
 773          * don't post the error log until after all dev drivers
 774          * have been informed.
 775          */
 776         pr_info("EEH: Collect temporary log\n");
 777         eeh_slot_error_detail(pe, EEH_LOG_TEMP);
 778
 779         /* If all device drivers were EEH-unaware, then shut
 780          * down all of the device drivers, and hope they
 781          * go down willingly, without panicing the system.
 782          */
 783         if (result == PCI_ERS_RESULT_NONE) {
 784                 pr_info("EEH: Reset with hotplug activity\n");
 785                 rc = eeh_reset_device(pe, frozen_bus, NULL);
 786                 if (rc) {
 787                         pr_warn("%s: Unable to reset, err=%d\n",
 788                                 __func__, rc);
 789                         goto hard_fail;
 790                 }
 791         }
 792
 793         /* If all devices reported they can proceed, then re-enable MMIO */
 794         if (result == PCI_ERS_RESULT_CAN_RECOVER) {
 795                 pr_info("EEH: Enable I/O for affected devices\n");
 796                 rc = eeh_pci_enable(pe, EEH_OPT_THAW_MMIO);
 797
 798                 if (rc < 0)
 799                         goto hard_fail;
 800                 if (rc) {
 801                         result = PCI_ERS_RESULT_NEED_RESET;
 802                 } else {
 803                         pr_info("EEH: Notify device drivers to resume I/O\n");
 804                         eeh_pe_dev_traverse(pe, eeh_report_mmio_enabled, &result);
 805                 }
 806         }
 807
 808         /* If all devices reported they can proceed, then re-enable DMA */
 809         if (result == PCI_ERS_RESULT_CAN_RECOVER) {
 810                 pr_info("EEH: Enabled DMA for affected devices\n");
 811                 rc = eeh_pci_enable(pe, EEH_OPT_THAW_DMA);
 812
 813                 if (rc < 0)
 814                         goto hard_fail;
 815                 if (rc) {
 816                         result = PCI_ERS_RESULT_NEED_RESET;
 817                 } else {
 818                         /*
 819                          * We didn't do PE reset for the case. The PE
 820                          * is still in frozen state. Clear it before
 821                          * resuming the PE.
 822                          */
 823                         eeh_pe_state_clear(pe, EEH_PE_ISOLATED);
 824                         result = PCI_ERS_RESULT_RECOVERED;
 825                 }
 826         }
 827
 828         /* If any device has a hard failure, then shut off everything. */
 829         if (result == PCI_ERS_RESULT_DISCONNECT) {
 830                 pr_warn("EEH: Device driver gave up\n");
 831                 goto hard_fail;
 832         }
 833
 834         /* If any device called out for a reset, then reset the slot */
 835         if (result == PCI_ERS_RESULT_NEED_RESET) {
 836                 pr_info("EEH: Reset without hotplug activity\n");
 837                 rc = eeh_reset_device(pe, NULL, &rmv_data);
 838                 if (rc) {
 839                         pr_warn("%s: Cannot reset, err=%d\n",
 840                                 __func__, rc);
 841                         goto hard_fail;
 842                 }
 843
 844                 pr_info("EEH: Notify device drivers "
 845                         "the completion of reset\n");
 846                 result = PCI_ERS_RESULT_NONE;
 847                 eeh_pe_dev_traverse(pe, eeh_report_reset, &result);
 848         }
 849
 850         /* All devices should claim they have recovered by now. */
 851         if ((result != PCI_ERS_RESULT_RECOVERED) &&
 852             (result != PCI_ERS_RESULT_NONE)) {
 853                 pr_warn("EEH: Not recovered\n");
 854                 goto hard_fail;
 855         }
 856
 857         /*
 858          * For those hot removed VFs, we should add back them after PF get
 859          * recovered properly.
 860          */
 861         list_for_each_entry_safe(edev, tmp, &rmv_data.edev_list, rmv_list) {
 862                 eeh_add_virt_device(edev, NULL);
 863                 list_del(&edev->rmv_list);
 864         }
 865
 866         /* Tell all device drivers that they can resume operations */
 867         pr_info("EEH: Notify device driver to resume\n");
 868         eeh_pe_dev_traverse(pe, eeh_report_resume, NULL);
 869
 870         return;
 871
 872 excess_failures:
 873         /*
 874          * About 90% of all real-life EEH failures in the field
 875          * are due to poorly seated PCI cards. Only 10% or so are
 876          * due to actual, failed cards.
 877          */
 878         pr_err("EEH: PHB#%d-PE#%x has failed %d times in the\n"
 879                "last hour and has been permanently disabled.\n"
 880                "Please try reseating or replacing it.\n",
 881                 pe->phb->global_number, pe->addr,
 882                 pe->freeze_count);
 883         goto perm_error;
 884
 885 hard_fail:
 886         pr_err("EEH: Unable to recover from failure from PHB#%d-PE#%x.\n"
 887                "Please try reseating or replacing it\n",
 888                 pe->phb->global_number, pe->addr);
 889
 890 perm_error:
 891         eeh_slot_error_detail(pe, EEH_LOG_PERM);
 892
 893         /* Notify all devices that they're about to go down. */
 894         eeh_pe_dev_traverse(pe, eeh_report_failure, NULL);
 895
 896         /* Mark the PE to be removed permanently */
 897         eeh_pe_state_mark(pe, EEH_PE_REMOVED);
 898
 899         /*
 900          * Shut down the device drivers for good. We mark
 901          * all removed devices correctly to avoid access
 902          * the their PCI config any more.
 903          */
 904         if (frozen_bus) {
 905                 if (pe->type & EEH_PE_VF) {
 906                         eeh_pe_dev_traverse(pe, eeh_rmv_device, NULL);
 907                         eeh_pe_dev_mode_mark(pe, EEH_DEV_REMOVED);
 908                 } else {
 909                         eeh_pe_state_clear(pe, EEH_PE_PRI_BUS);
 910                         eeh_pe_dev_mode_mark(pe, EEH_DEV_REMOVED);
 911
 912                         pci_lock_rescan_remove();
 913                         pci_hp_remove_devices(frozen_bus);
 914                         pci_unlock_rescan_remove();
 915                 }
 916         }
 917 }
 918
 919 static void eeh_handle_special_event(void)
 920 {
 921         struct eeh_pe *pe, *phb_pe;
 922         struct pci_bus *bus;
 923         struct pci_controller *hose;
 924         unsigned long flags;
 925         int rc;
 926
 927
 928         do {
 929                 rc = eeh_ops->next_error(&pe);
 930
 931                 switch (rc) {
 932                 case EEH_NEXT_ERR_DEAD_IOC:
 933                         /* Mark all PHBs in dead state */
 934                         eeh_serialize_lock(&flags);
 935
 936                         /* Purge all events */
 937                         eeh_remove_event(NULL, true);
 938
 939                         list_for_each_entry(hose, &hose_list, list_node) {
 940                                 phb_pe = eeh_phb_pe_get(hose);
 941                                 if (!phb_pe) continue;
 942
 943                                 eeh_pe_state_mark(phb_pe, EEH_PE_ISOLATED);
 944                         }
 945
 946                         eeh_serialize_unlock(flags);
 947
 948                         break;
 949                 case EEH_NEXT_ERR_FROZEN_PE:
 950                 case EEH_NEXT_ERR_FENCED_PHB:
 951                 case EEH_NEXT_ERR_DEAD_PHB:
 952                         /* Mark the PE in fenced state */
 953                         eeh_serialize_lock(&flags);
 954
 955                         /* Purge all events of the PHB */
 956                         eeh_remove_event(pe, true);
 957
 958                         if (rc == EEH_NEXT_ERR_DEAD_PHB)
 959                                 eeh_pe_state_mark(pe, EEH_PE_ISOLATED);
 960                         else
 961                                 eeh_pe_state_mark(pe,
 962                                         EEH_PE_ISOLATED | EEH_PE_RECOVERING);
 963
 964                         eeh_serialize_unlock(flags);
 965
 966                         break;
 967                 case EEH_NEXT_ERR_NONE:
 968                         return;
 969                 default:
 970                         pr_warn("%s: Invalid value %d from next_error()\n",
 971                                 __func__, rc);
 972                         return;
 973                 }
 974
 975                 /*
 976                  * For fenced PHB and frozen PE, it's handled as normal
 977                  * event. We have to remove the affected PHBs for dead
 978                  * PHB and IOC
 979                  */
 980                 if (rc == EEH_NEXT_ERR_FROZEN_PE ||
 981                     rc == EEH_NEXT_ERR_FENCED_PHB) {
 982                         eeh_handle_normal_event(pe);
 983                         eeh_pe_state_clear(pe, EEH_PE_RECOVERING);
 984                 } else {
 985                         pci_lock_rescan_remove();
 986                         list_for_each_entry(hose, &hose_list, list_node) {
 987                                 phb_pe = eeh_phb_pe_get(hose);
 988                                 if (!phb_pe ||
 989                                     !(phb_pe->state & EEH_PE_ISOLATED) ||
 990                                     (phb_pe->state & EEH_PE_RECOVERING))
 991                                         continue;
 992
 993                                 /* Notify all devices to be down */
 994                                 eeh_pe_state_clear(pe, EEH_PE_PRI_BUS);
 995                                 bus = eeh_pe_bus_get(phb_pe);
 996                                 eeh_pe_dev_traverse(pe,
 997                                         eeh_report_failure, NULL);
 998                                 pci_hp_remove_devices(bus);
 999                         }
1000                         pci_unlock_rescan_remove();
1001                 }
1002
1003                 /*
1004                  * If we have detected dead IOC, we needn't proceed
1005                  * any more since all PHBs would have been removed
1006                  */
1007                 if (rc == EEH_NEXT_ERR_DEAD_IOC)
1008                         break;
1009         } while (rc != EEH_NEXT_ERR_NONE);
1010 }
1011
1012 /**
1013  * eeh_handle_event - Reset a PCI device after hard lockup.
1014  * @pe: EEH PE
1015  *
1016  * While PHB detects address or data parity errors on particular PCI
1017  * slot, the associated PE will be frozen. Besides, DMA's occurring
1018  * to wild addresses (which usually happen due to bugs in device
1019  * drivers or in PCI adapter firmware) can cause EEH error. #SERR,
1020  * #PERR or other misc PCI-related errors also can trigger EEH errors.
1021  *
1022  * Recovery process consists of unplugging the device driver (which
1023  * generated hotplug events to userspace), then issuing a PCI #RST to
1024  * the device, then reconfiguring the PCI config space for all bridges
1025  * & devices under this slot, and then finally restarting the device
1026  * drivers (which cause a second set of hotplug events to go out to
1027  * userspace).
1028  */
1029 void eeh_handle_event(struct eeh_pe *pe)
1030 {
1031         if (pe)
1032                 eeh_handle_normal_event(pe);
1033         else
1034                 eeh_handle_special_event();
1035 }