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         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 = *(bool *)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_pe_reset_full(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                         pci_lock_rescan_remove();
 646                         pci_hp_remove_devices(bus);
 647                         pci_unlock_rescan_remove();
 648                 }
 649         } else if (frozen_bus) {
 650                 eeh_pe_dev_traverse(pe, eeh_rmv_device, rmv_data);
 651         }
 652
 653         /*
 654          * Reset the pci controller. (Asserts RST#; resets config space).
 655          * Reconfigure bridges and devices. Don't try to bring the system
 656          * up if the reset failed for some reason.
 657          *
 658          * During the reset, it's very dangerous to have uncontrolled PCI
 659          * config accesses. So we prefer to block them. However, controlled
 660          * PCI config accesses initiated from EEH itself are allowed.
 661          */
 662         rc = eeh_pe_reset_full(pe);
 663         if (rc)
 664                 return rc;
 665
 666         pci_lock_rescan_remove();
 667
 668         /* Restore PE */
 669         eeh_ops->configure_bridge(pe);
 670         eeh_pe_restore_bars(pe);
 671
 672         /* Clear frozen state */
 673         rc = eeh_clear_pe_frozen_state(pe, false);
 674         if (rc) {
 675                 pci_unlock_rescan_remove();
 676                 return rc;
 677         }
 678
 679         /* Give the system 5 seconds to finish running the user-space
 680          * hotplug shutdown scripts, e.g. ifdown for ethernet.  Yes,
 681          * this is a hack, but if we don't do this, and try to bring
 682          * the device up before the scripts have taken it down,
 683          * potentially weird things happen.
 684          */
 685         if (bus) {
 686                 pr_info("EEH: Sleep 5s ahead of complete hotplug\n");
 687                 ssleep(5);
 688
 689                 /*
 690                  * The EEH device is still connected with its parent
 691                  * PE. We should disconnect it so the binding can be
 692                  * rebuilt when adding PCI devices.
 693                  */
 694                 edev = list_first_entry(&pe->edevs, struct eeh_dev, list);
 695                 eeh_pe_traverse(pe, eeh_pe_detach_dev, NULL);
 696                 if (pe->type & EEH_PE_VF) {
 697                         eeh_add_virt_device(edev, NULL);
 698                 } else {
 699                         eeh_pe_state_clear(pe, EEH_PE_PRI_BUS);
 700                         pci_hp_add_devices(bus);
 701                 }
 702         } else if (frozen_bus && rmv_data->removed) {
 703                 pr_info("EEH: Sleep 5s ahead of partial hotplug\n");
 704                 ssleep(5);
 705
 706                 edev = list_first_entry(&pe->edevs, struct eeh_dev, list);
 707                 eeh_pe_traverse(pe, eeh_pe_detach_dev, NULL);
 708                 if (pe->type & EEH_PE_VF)
 709                         eeh_add_virt_device(edev, NULL);
 710                 else
 711                         pci_hp_add_devices(frozen_bus);
 712         }
 713         eeh_pe_state_clear(pe, EEH_PE_KEEP);
 714
 715         pe->tstamp = tstamp;
 716         pe->freeze_count = cnt;
 717
 718         pci_unlock_rescan_remove();
 719         return 0;
 720 }
 721
 722 /* The longest amount of time to wait for a pci device
 723  * to come back on line, in seconds.
 724  */
 725 #define MAX_WAIT_FOR_RECOVERY 300
 726
 727 /**
 728  * eeh_handle_normal_event - Handle EEH events on a specific PE
 729  * @pe: EEH PE
 730  *
 731  * Attempts to recover the given PE.  If recovery fails or the PE has failed
 732  * too many times, remove the PE.
 733  *
 734  * Returns true if @pe should no longer be used, else false.
 735  */
 736 static bool eeh_handle_normal_event(struct eeh_pe *pe)
 737 {
 738         struct pci_bus *frozen_bus;
 739         struct eeh_dev *edev, *tmp;
 740         int rc = 0;
 741         enum pci_ers_result result = PCI_ERS_RESULT_NONE;
 742         struct eeh_rmv_data rmv_data = {LIST_HEAD_INIT(rmv_data.edev_list), 0};
 743
 744         frozen_bus = eeh_pe_bus_get(pe);
 745         if (!frozen_bus) {
 746                 pr_err("%s: Cannot find PCI bus for PHB#%x-PE#%x\n",
 747                         __func__, pe->phb->global_number, pe->addr);
 748                 return false;
 749         }
 750
 751         eeh_pe_update_time_stamp(pe);
 752         pe->freeze_count++;
 753         if (pe->freeze_count > eeh_max_freezes) {
 754                 pr_err("EEH: PHB#%x-PE#%x has failed %d times in the\n"
 755                        "last hour and has been permanently disabled.\n",
 756                        pe->phb->global_number, pe->addr,
 757                        pe->freeze_count);
 758                 goto hard_fail;
 759         }
 760         pr_warn("EEH: This PCI device has failed %d times in the last hour\n",
 761                 pe->freeze_count);
 762
 763         /* Walk the various device drivers attached to this slot through
 764          * a reset sequence, giving each an opportunity to do what it needs
 765          * to accomplish the reset.  Each child gets a report of the
 766          * status ... if any child can't handle the reset, then the entire
 767          * slot is dlpar removed and added.
 768          *
 769          * When the PHB is fenced, we have to issue a reset to recover from
 770          * the error. Override the result if necessary to have partially
 771          * hotplug for this case.
 772          */
 773         pr_info("EEH: Notify device drivers to shutdown\n");
 774         eeh_pe_dev_traverse(pe, eeh_report_error, &result);
 775         if ((pe->type & EEH_PE_PHB) &&
 776             result != PCI_ERS_RESULT_NONE &&
 777             result != PCI_ERS_RESULT_NEED_RESET)
 778                 result = PCI_ERS_RESULT_NEED_RESET;
 779
 780         /* Get the current PCI slot state. This can take a long time,
 781          * sometimes over 300 seconds for certain systems.
 782          */
 783         rc = eeh_ops->wait_state(pe, MAX_WAIT_FOR_RECOVERY*1000);
 784         if (rc < 0 || rc == EEH_STATE_NOT_SUPPORT) {
 785                 pr_warn("EEH: Permanent failure\n");
 786                 goto hard_fail;
 787         }
 788
 789         /* Since rtas may enable MMIO when posting the error log,
 790          * don't post the error log until after all dev drivers
 791          * have been informed.
 792          */
 793         pr_info("EEH: Collect temporary log\n");
 794         eeh_slot_error_detail(pe, EEH_LOG_TEMP);
 795
 796         /* If all device drivers were EEH-unaware, then shut
 797          * down all of the device drivers, and hope they
 798          * go down willingly, without panicing the system.
 799          */
 800         if (result == PCI_ERS_RESULT_NONE) {
 801                 pr_info("EEH: Reset with hotplug activity\n");
 802                 rc = eeh_reset_device(pe, frozen_bus, NULL);
 803                 if (rc) {
 804                         pr_warn("%s: Unable to reset, err=%d\n",
 805                                 __func__, rc);
 806                         goto hard_fail;
 807                 }
 808         }
 809
 810         /* If all devices reported they can proceed, then re-enable MMIO */
 811         if (result == PCI_ERS_RESULT_CAN_RECOVER) {
 812                 pr_info("EEH: Enable I/O for affected devices\n");
 813                 rc = eeh_pci_enable(pe, EEH_OPT_THAW_MMIO);
 814
 815                 if (rc < 0)
 816                         goto hard_fail;
 817                 if (rc) {
 818                         result = PCI_ERS_RESULT_NEED_RESET;
 819                 } else {
 820                         pr_info("EEH: Notify device drivers to resume I/O\n");
 821                         eeh_pe_dev_traverse(pe, eeh_report_mmio_enabled, &result);
 822                 }
 823         }
 824
 825         /* If all devices reported they can proceed, then re-enable DMA */
 826         if (result == PCI_ERS_RESULT_CAN_RECOVER) {
 827                 pr_info("EEH: Enabled DMA for affected devices\n");
 828                 rc = eeh_pci_enable(pe, EEH_OPT_THAW_DMA);
 829
 830                 if (rc < 0)
 831                         goto hard_fail;
 832                 if (rc) {
 833                         result = PCI_ERS_RESULT_NEED_RESET;
 834                 } else {
 835                         /*
 836                          * We didn't do PE reset for the case. The PE
 837                          * is still in frozen state. Clear it before
 838                          * resuming the PE.
 839                          */
 840                         eeh_pe_state_clear(pe, EEH_PE_ISOLATED);
 841                         result = PCI_ERS_RESULT_RECOVERED;
 842                 }
 843         }
 844
 845         /* If any device has a hard failure, then shut off everything. */
 846         if (result == PCI_ERS_RESULT_DISCONNECT) {
 847                 pr_warn("EEH: Device driver gave up\n");
 848                 goto hard_fail;
 849         }
 850
 851         /* If any device called out for a reset, then reset the slot */
 852         if (result == PCI_ERS_RESULT_NEED_RESET) {
 853                 pr_info("EEH: Reset without hotplug activity\n");
 854                 rc = eeh_reset_device(pe, NULL, &rmv_data);
 855                 if (rc) {
 856                         pr_warn("%s: Cannot reset, err=%d\n",
 857                                 __func__, rc);
 858                         goto hard_fail;
 859                 }
 860
 861                 pr_info("EEH: Notify device drivers "
 862                         "the completion of reset\n");
 863                 result = PCI_ERS_RESULT_NONE;
 864                 eeh_pe_dev_traverse(pe, eeh_report_reset, &result);
 865         }
 866
 867         /* All devices should claim they have recovered by now. */
 868         if ((result != PCI_ERS_RESULT_RECOVERED) &&
 869             (result != PCI_ERS_RESULT_NONE)) {
 870                 pr_warn("EEH: Not recovered\n");
 871                 goto hard_fail;
 872         }
 873
 874         /*
 875          * For those hot removed VFs, we should add back them after PF get
 876          * recovered properly.
 877          */
 878         list_for_each_entry_safe(edev, tmp, &rmv_data.edev_list, rmv_list) {
 879                 eeh_add_virt_device(edev, NULL);
 880                 list_del(&edev->rmv_list);
 881         }
 882
 883         /* Tell all device drivers that they can resume operations */
 884         pr_info("EEH: Notify device driver to resume\n");
 885         eeh_pe_dev_traverse(pe, eeh_report_resume, NULL);
 886
 887         return false;
 888
 889 hard_fail:
 890         /*
 891          * About 90% of all real-life EEH failures in the field
 892          * are due to poorly seated PCI cards. Only 10% or so are
 893          * due to actual, failed cards.
 894          */
 895         pr_err("EEH: Unable to recover from failure from PHB#%x-PE#%x.\n"
 896                "Please try reseating or replacing it\n",
 897                 pe->phb->global_number, pe->addr);
 898
 899         eeh_slot_error_detail(pe, EEH_LOG_PERM);
 900
 901         /* Notify all devices that they're about to go down. */
 902         eeh_pe_dev_traverse(pe, eeh_report_failure, NULL);
 903
 904         /* Mark the PE to be removed permanently */
 905         eeh_pe_state_mark(pe, EEH_PE_REMOVED);
 906
 907         /*
 908          * Shut down the device drivers for good. We mark
 909          * all removed devices correctly to avoid access
 910          * the their PCI config any more.
 911          */
 912         if (frozen_bus) {
 913                 if (pe->type & EEH_PE_VF) {
 914                         eeh_pe_dev_traverse(pe, eeh_rmv_device, NULL);
 915                         eeh_pe_dev_mode_mark(pe, EEH_DEV_REMOVED);
 916                 } else {
 917                         eeh_pe_state_clear(pe, EEH_PE_PRI_BUS);
 918                         eeh_pe_dev_mode_mark(pe, EEH_DEV_REMOVED);
 919
 920                         pci_lock_rescan_remove();
 921                         pci_hp_remove_devices(frozen_bus);
 922                         pci_unlock_rescan_remove();
 923
 924                         /* The passed PE should no longer be used */
 925                         return true;
 926                 }
 927         }
 928         return false;
 929 }
 930
 931 /**
 932  * eeh_handle_special_event - Handle EEH events without a specific failing PE
 933  *
 934  * Called when an EEH event is detected but can't be narrowed down to a
 935  * specific PE.  Iterates through possible failures and handles them as
 936  * necessary.
 937  */
 938 static void eeh_handle_special_event(void)
 939 {
 940         struct eeh_pe *pe, *phb_pe;
 941         struct pci_bus *bus;
 942         struct pci_controller *hose;
 943         unsigned long flags;
 944         int rc;
 945
 946
 947         do {
 948                 rc = eeh_ops->next_error(&pe);
 949
 950                 switch (rc) {
 951                 case EEH_NEXT_ERR_DEAD_IOC:
 952                         /* Mark all PHBs in dead state */
 953                         eeh_serialize_lock(&flags);
 954
 955                         /* Purge all events */
 956                         eeh_remove_event(NULL, true);
 957
 958                         list_for_each_entry(hose, &hose_list, list_node) {
 959                                 phb_pe = eeh_phb_pe_get(hose);
 960                                 if (!phb_pe) continue;
 961
 962                                 eeh_pe_state_mark(phb_pe, EEH_PE_ISOLATED);
 963                         }
 964
 965                         eeh_serialize_unlock(flags);
 966
 967                         break;
 968                 case EEH_NEXT_ERR_FROZEN_PE:
 969                 case EEH_NEXT_ERR_FENCED_PHB:
 970                 case EEH_NEXT_ERR_DEAD_PHB:
 971                         /* Mark the PE in fenced state */
 972                         eeh_serialize_lock(&flags);
 973
 974                         /* Purge all events of the PHB */
 975                         eeh_remove_event(pe, true);
 976
 977                         if (rc == EEH_NEXT_ERR_DEAD_PHB)
 978                                 eeh_pe_state_mark(pe, EEH_PE_ISOLATED);
 979                         else
 980                                 eeh_pe_state_mark(pe,
 981                                         EEH_PE_ISOLATED | EEH_PE_RECOVERING);
 982
 983                         eeh_serialize_unlock(flags);
 984
 985                         break;
 986                 case EEH_NEXT_ERR_NONE:
 987                         return;
 988                 default:
 989                         pr_warn("%s: Invalid value %d from next_error()\n",
 990                                 __func__, rc);
 991                         return;
 992                 }
 993
 994                 /*
 995                  * For fenced PHB and frozen PE, it's handled as normal
 996                  * event. We have to remove the affected PHBs for dead
 997                  * PHB and IOC
 998                  */
 999                 if (rc == EEH_NEXT_ERR_FROZEN_PE ||
1000                     rc == EEH_NEXT_ERR_FENCED_PHB) {
1001                         /*
1002                          * eeh_handle_normal_event() can make the PE stale if it
1003                          * determines that the PE cannot possibly be recovered.
1004                          * Don't modify the PE state if that's the case.
1005                          */
1006                         if (eeh_handle_normal_event(pe))
1007                                 continue;
1008
1009                         eeh_pe_state_clear(pe, EEH_PE_RECOVERING);
1010                 } else {
1011                         pci_lock_rescan_remove();
1012                         list_for_each_entry(hose, &hose_list, list_node) {
1013                                 phb_pe = eeh_phb_pe_get(hose);
1014                                 if (!phb_pe ||
1015                                     !(phb_pe->state & EEH_PE_ISOLATED) ||
1016                                     (phb_pe->state & EEH_PE_RECOVERING))
1017                                         continue;
1018
1019                                 /* Notify all devices to be down */
1020                                 eeh_pe_state_clear(pe, EEH_PE_PRI_BUS);
1021                                 eeh_pe_dev_traverse(pe,
1022                                         eeh_report_failure, NULL);
1023                                 bus = eeh_pe_bus_get(phb_pe);
1024                                 if (!bus) {
1025                                         pr_err("%s: Cannot find PCI bus for "
1026                                                "PHB#%x-PE#%x\n",
1027                                                __func__,
1028                                                pe->phb->global_number,
1029                                                pe->addr);
1030                                         break;
1031                                 }
1032                                 pci_hp_remove_devices(bus);
1033                         }
1034                         pci_unlock_rescan_remove();
1035                 }
1036
1037                 /*
1038                  * If we have detected dead IOC, we needn't proceed
1039                  * any more since all PHBs would have been removed
1040                  */
1041                 if (rc == EEH_NEXT_ERR_DEAD_IOC)
1042                         break;
1043         } while (rc != EEH_NEXT_ERR_NONE);
1044 }
1045
1046 /**
1047  * eeh_handle_event - Reset a PCI device after hard lockup.
1048  * @pe: EEH PE
1049  *
1050  * While PHB detects address or data parity errors on particular PCI
1051  * slot, the associated PE will be frozen. Besides, DMA's occurring
1052  * to wild addresses (which usually happen due to bugs in device
1053  * drivers or in PCI adapter firmware) can cause EEH error. #SERR,
1054  * #PERR or other misc PCI-related errors also can trigger EEH errors.
1055  *
1056  * Recovery process consists of unplugging the device driver (which
1057  * generated hotplug events to userspace), then issuing a PCI #RST to
1058  * the device, then reconfiguring the PCI config space for all bridges
1059  * & devices under this slot, and then finally restarting the device
1060  * drivers (which cause a second set of hotplug events to go out to
1061  * userspace).
1062  */
1063 void eeh_handle_event(struct eeh_pe *pe)
1064 {
1065         if (pe)
1066                 eeh_handle_normal_event(pe);
1067         else
1068                 eeh_handle_special_event();
1069 }