arch/powerpc/platforms/pseries/eeh.c

   1 /*
   2  * eeh.c
   3  * Copyright (C) 2001 Dave Engebretsen & Todd Inglett IBM Corporation
   4  *
   5  * This program is free software; you can redistribute it and/or modify
   6  * it under the terms of the GNU General Public License as published by
   7  * the Free Software Foundation; either version 2 of the License, or
   8  * (at your option) any later version.
   9  *
  10  * This program is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13  * GNU General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU General Public License
  16  * along with this program; if not, write to the Free Software
  17  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  18  */
  19
  20 #include <linux/delay.h>
  21 #include <linux/init.h>
  22 #include <linux/list.h>
  23 #include <linux/pci.h>
  24 #include <linux/proc_fs.h>
  25 #include <linux/rbtree.h>
  26 #include <linux/seq_file.h>
  27 #include <linux/spinlock.h>
  28 #include <asm/atomic.h>
  29 #include <asm/eeh.h>
  30 #include <asm/eeh_event.h>
  31 #include <asm/io.h>
  32 #include <asm/machdep.h>
  33 #include <asm/ppc-pci.h>
  34 #include <asm/rtas.h>
  35
  36 #undef DEBUG
  37
  38 /** Overview:
  39  *  EEH, or "Extended Error Handling" is a PCI bridge technology for
  40  *  dealing with PCI bus errors that can't be dealt with within the
  41  *  usual PCI framework, except by check-stopping the CPU.  Systems
  42  *  that are designed for high-availability/reliability cannot afford
  43  *  to crash due to a "mere" PCI error, thus the need for EEH.
  44  *  An EEH-capable bridge operates by converting a detected error
  45  *  into a "slot freeze", taking the PCI adapter off-line, making
  46  *  the slot behave, from the OS'es point of view, as if the slot
  47  *  were "empty": all reads return 0xff's and all writes are silently
  48  *  ignored.  EEH slot isolation events can be triggered by parity
  49  *  errors on the address or data busses (e.g. during posted writes),
  50  *  which in turn might be caused by low voltage on the bus, dust,
  51  *  vibration, humidity, radioactivity or plain-old failed hardware.
  52  *
  53  *  Note, however, that one of the leading causes of EEH slot
  54  *  freeze events are buggy device drivers, buggy device microcode,
  55  *  or buggy device hardware.  This is because any attempt by the
  56  *  device to bus-master data to a memory address that is not
  57  *  assigned to the device will trigger a slot freeze.   (The idea
  58  *  is to prevent devices-gone-wild from corrupting system memory).
  59  *  Buggy hardware/drivers will have a miserable time co-existing
  60  *  with EEH.
  61  *
  62  *  Ideally, a PCI device driver, when suspecting that an isolation
  63  *  event has occured (e.g. by reading 0xff's), will then ask EEH
  64  *  whether this is the case, and then take appropriate steps to
  65  *  reset the PCI slot, the PCI device, and then resume operations.
  66  *  However, until that day,  the checking is done here, with the
  67  *  eeh_check_failure() routine embedded in the MMIO macros.  If
  68  *  the slot is found to be isolated, an "EEH Event" is synthesized
  69  *  and sent out for processing.
  70  */
  71
  72 /* If a device driver keeps reading an MMIO register in an interrupt
  73  * handler after a slot isolation event has occurred, we assume it
  74  * is broken and panic.  This sets the threshold for how many read
  75  * attempts we allow before panicking.
  76  */
  77 #define EEH_MAX_FAILS   2100000
  78
  79 /* Time to wait for a PCI slot to retport status, in milliseconds */
  80 #define PCI_BUS_RESET_WAIT_MSEC (60*1000)
  81
  82 /* RTAS tokens */
  83 static int ibm_set_eeh_option;
  84 static int ibm_set_slot_reset;
  85 static int ibm_read_slot_reset_state;
  86 static int ibm_read_slot_reset_state2;
  87 static int ibm_slot_error_detail;
  88 static int ibm_get_config_addr_info;
  89 static int ibm_get_config_addr_info2;
  90 static int ibm_configure_bridge;
  91
  92 int eeh_subsystem_enabled;
  93 EXPORT_SYMBOL(eeh_subsystem_enabled);
  94
  95 /* Lock to avoid races due to multiple reports of an error */
  96 static DEFINE_SPINLOCK(confirm_error_lock);
  97
  98 /* Buffer for reporting slot-error-detail rtas calls */
  99 static unsigned char slot_errbuf[RTAS_ERROR_LOG_MAX];
 100 static DEFINE_SPINLOCK(slot_errbuf_lock);
 101 static int eeh_error_buf_size;
 102
 103 #define EEH_PCI_REGS_LOG_LEN 4096
 104 static unsigned char pci_regs_buf[EEH_PCI_REGS_LOG_LEN];
 105
 106 /* System monitoring statistics */
 107 static unsigned long no_device;
 108 static unsigned long no_dn;
 109 static unsigned long no_cfg_addr;
 110 static unsigned long ignored_check;
 111 static unsigned long total_mmio_ffs;
 112 static unsigned long false_positives;
 113 static unsigned long ignored_failures;
 114 static unsigned long slot_resets;
 115
 116 #define IS_BRIDGE(class_code) (((class_code)<<16) == PCI_BASE_CLASS_BRIDGE)
 117
 118 /* --------------------------------------------------------------- */
 119 /* Below lies the EEH event infrastructure */
 120
 121 static void rtas_slot_error_detail(struct pci_dn *pdn, int severity,
 122                                    char *driver_log, size_t loglen)
 123 {
 124         int config_addr;
 125         unsigned long flags;
 126         int rc;
 127
 128         /* Log the error with the rtas logger */
 129         spin_lock_irqsave(&slot_errbuf_lock, flags);
 130         memset(slot_errbuf, 0, eeh_error_buf_size);
 131
 132         /* Use PE configuration address, if present */
 133         config_addr = pdn->eeh_config_addr;
 134         if (pdn->eeh_pe_config_addr)
 135                 config_addr = pdn->eeh_pe_config_addr;
 136
 137         rc = rtas_call(ibm_slot_error_detail,
 138                        8, 1, NULL, config_addr,
 139                        BUID_HI(pdn->phb->buid),
 140                        BUID_LO(pdn->phb->buid),
 141                        virt_to_phys(driver_log), loglen,
 142                        virt_to_phys(slot_errbuf),
 143                        eeh_error_buf_size,
 144                        severity);
 145
 146         if (rc == 0)
 147                 log_error(slot_errbuf, ERR_TYPE_RTAS_LOG, 0);
 148         spin_unlock_irqrestore(&slot_errbuf_lock, flags);
 149 }
 150
 151 /**
 152  * gather_pci_data - copy assorted PCI config space registers to buff
 153  * @pdn: device to report data for
 154  * @buf: point to buffer in which to log
 155  * @len: amount of room in buffer
 156  *
 157  * This routine captures assorted PCI configuration space data,
 158  * and puts them into a buffer for RTAS error logging.
 159  */
 160 static size_t gather_pci_data(struct pci_dn *pdn, char * buf, size_t len)
 161 {
 162         u32 cfg;
 163         int n = 0;
 164
 165         n += scnprintf(buf+n, len-n, "%s\n", pdn->node->name);
 166         rtas_read_config(pdn, PCI_VENDOR_ID, 4, &cfg);
 167         n += scnprintf(buf+n, len-n, "dev/vend:%x\n", cfg);
 168         rtas_read_config(pdn, PCI_COMMAND, 4, &cfg);
 169         n += scnprintf(buf+n, len-n, "cmd/stat:%x\n", cfg);
 170
 171         return n;
 172 }
 173
 174 void eeh_slot_error_detail(struct pci_dn *pdn, int severity)
 175 {
 176         size_t loglen = 0;
 177         memset(pci_regs_buf, 0, EEH_PCI_REGS_LOG_LEN);
 178
 179         rtas_pci_enable(pdn, EEH_THAW_MMIO);
 180         loglen = gather_pci_data(pdn, pci_regs_buf, EEH_PCI_REGS_LOG_LEN);
 181
 182         rtas_slot_error_detail(pdn, severity, pci_regs_buf, loglen);
 183 }
 184
 185 /**
 186  * read_slot_reset_state - Read the reset state of a device node's slot
 187  * @dn: device node to read
 188  * @rets: array to return results in
 189  */
 190 static int read_slot_reset_state(struct pci_dn *pdn, int rets[])
 191 {
 192         int token, outputs;
 193         int config_addr;
 194
 195         if (ibm_read_slot_reset_state2 != RTAS_UNKNOWN_SERVICE) {
 196                 token = ibm_read_slot_reset_state2;
 197                 outputs = 4;
 198         } else {
 199                 token = ibm_read_slot_reset_state;
 200                 rets[2] = 0; /* fake PE Unavailable info */
 201                 outputs = 3;
 202         }
 203
 204         /* Use PE configuration address, if present */
 205         config_addr = pdn->eeh_config_addr;
 206         if (pdn->eeh_pe_config_addr)
 207                 config_addr = pdn->eeh_pe_config_addr;
 208
 209         return rtas_call(token, 3, outputs, rets, config_addr,
 210                          BUID_HI(pdn->phb->buid), BUID_LO(pdn->phb->buid));
 211 }
 212
 213 /**
 214  * eeh_wait_for_slot_status - returns error status of slot
 215  * @pdn pci device node
 216  * @max_wait_msecs maximum number to millisecs to wait
 217  *
 218  * Return negative value if a permanent error, else return
 219  * Partition Endpoint (PE) status value.
 220  *
 221  * If @max_wait_msecs is positive, then this routine will
 222  * sleep until a valid status can be obtained, or until
 223  * the max allowed wait time is exceeded, in which case
 224  * a -2 is returned.
 225  */
 226 int
 227 eeh_wait_for_slot_status(struct pci_dn *pdn, int max_wait_msecs)
 228 {
 229         int rc;
 230         int rets[3];
 231         int mwait;
 232
 233         while (1) {
 234                 rc = read_slot_reset_state(pdn, rets);
 235                 if (rc) return rc;
 236                 if (rets[1] == 0) return -1;  /* EEH is not supported */
 237
 238                 if (rets[0] != 5) return rets[0]; /* return actual status */
 239
 240                 if (rets[2] == 0) return -1; /* permanently unavailable */
 241
 242                 if (max_wait_msecs <= 0) return -1;
 243
 244                 mwait = rets[2];
 245                 if (mwait <= 0) {
 246                         printk (KERN_WARNING
 247                                 "EEH: Firmware returned bad wait value=%d\n", mwait);
 248                         mwait = 1000;
 249                 } else if (mwait > 300*1000) {
 250                         printk (KERN_WARNING
 251                                 "EEH: Firmware is taking too long, time=%d\n", mwait);
 252                         mwait = 300*1000;
 253                 }
 254                 max_wait_msecs -= mwait;
 255                 msleep (mwait);
 256         }
 257
 258         printk(KERN_WARNING "EEH: Timed out waiting for slot status\n");
 259         return -2;
 260 }
 261
 262 /**
 263  * eeh_token_to_phys - convert EEH address token to phys address
 264  * @token i/o token, should be address in the form 0xA....
 265  */
 266 static inline unsigned long eeh_token_to_phys(unsigned long token)
 267 {
 268         pte_t *ptep;
 269         unsigned long pa;
 270
 271         ptep = find_linux_pte(init_mm.pgd, token);
 272         if (!ptep)
 273                 return token;
 274         pa = pte_pfn(*ptep) << PAGE_SHIFT;
 275
 276         return pa | (token & (PAGE_SIZE-1));
 277 }
 278
 279 /**
 280  * Return the "partitionable endpoint" (pe) under which this device lies
 281  */
 282 struct device_node * find_device_pe(struct device_node *dn)
 283 {
 284         while ((dn->parent) && PCI_DN(dn->parent) &&
 285               (PCI_DN(dn->parent)->eeh_mode & EEH_MODE_SUPPORTED)) {
 286                 dn = dn->parent;
 287         }
 288         return dn;
 289 }
 290
 291 /** Mark all devices that are peers of this device as failed.
 292  *  Mark the device driver too, so that it can see the failure
 293  *  immediately; this is critical, since some drivers poll
 294  *  status registers in interrupts ... If a driver is polling,
 295  *  and the slot is frozen, then the driver can deadlock in
 296  *  an interrupt context, which is bad.
 297  */
 298
 299 static void __eeh_mark_slot (struct device_node *dn, int mode_flag)
 300 {
 301         while (dn) {
 302                 if (PCI_DN(dn)) {
 303                         /* Mark the pci device driver too */
 304                         struct pci_dev *dev = PCI_DN(dn)->pcidev;
 305
 306                         PCI_DN(dn)->eeh_mode |= mode_flag;
 307
 308                         if (dev && dev->driver)
 309                                 dev->error_state = pci_channel_io_frozen;
 310
 311                         if (dn->child)
 312                                 __eeh_mark_slot (dn->child, mode_flag);
 313                 }
 314                 dn = dn->sibling;
 315         }
 316 }
 317
 318 void eeh_mark_slot (struct device_node *dn, int mode_flag)
 319 {
 320         struct pci_dev *dev;
 321         dn = find_device_pe (dn);
 322
 323         /* Back up one, since config addrs might be shared */
 324         if (!pcibios_find_pci_bus(dn) && PCI_DN(dn->parent))
 325                 dn = dn->parent;
 326
 327         PCI_DN(dn)->eeh_mode |= mode_flag;
 328
 329         /* Mark the pci device too */
 330         dev = PCI_DN(dn)->pcidev;
 331         if (dev)
 332                 dev->error_state = pci_channel_io_frozen;
 333
 334         __eeh_mark_slot (dn->child, mode_flag);
 335 }
 336
 337 static void __eeh_clear_slot (struct device_node *dn, int mode_flag)
 338 {
 339         while (dn) {
 340                 if (PCI_DN(dn)) {
 341                         PCI_DN(dn)->eeh_mode &= ~mode_flag;
 342                         PCI_DN(dn)->eeh_check_count = 0;
 343                         if (dn->child)
 344                                 __eeh_clear_slot (dn->child, mode_flag);
 345                 }
 346                 dn = dn->sibling;
 347         }
 348 }
 349
 350 void eeh_clear_slot (struct device_node *dn, int mode_flag)
 351 {
 352         unsigned long flags;
 353         spin_lock_irqsave(&confirm_error_lock, flags);
 354
 355         dn = find_device_pe (dn);
 356
 357         /* Back up one, since config addrs might be shared */
 358         if (!pcibios_find_pci_bus(dn) && PCI_DN(dn->parent))
 359                 dn = dn->parent;
 360
 361         PCI_DN(dn)->eeh_mode &= ~mode_flag;
 362         PCI_DN(dn)->eeh_check_count = 0;
 363         __eeh_clear_slot (dn->child, mode_flag);
 364         spin_unlock_irqrestore(&confirm_error_lock, flags);
 365 }
 366
 367 /**
 368  * eeh_dn_check_failure - check if all 1's data is due to EEH slot freeze
 369  * @dn device node
 370  * @dev pci device, if known
 371  *
 372  * Check for an EEH failure for the given device node.  Call this
 373  * routine if the result of a read was all 0xff's and you want to
 374  * find out if this is due to an EEH slot freeze.  This routine
 375  * will query firmware for the EEH status.
 376  *
 377  * Returns 0 if there has not been an EEH error; otherwise returns
 378  * a non-zero value and queues up a slot isolation event notification.
 379  *
 380  * It is safe to call this routine in an interrupt context.
 381  */
 382 int eeh_dn_check_failure(struct device_node *dn, struct pci_dev *dev)
 383 {
 384         int ret;
 385         int rets[3];
 386         unsigned long flags;
 387         struct pci_dn *pdn;
 388         int rc = 0;
 389
 390         total_mmio_ffs++;
 391
 392         if (!eeh_subsystem_enabled)
 393                 return 0;
 394
 395         if (!dn) {
 396                 no_dn++;
 397                 return 0;
 398         }
 399         pdn = PCI_DN(dn);
 400
 401         /* Access to IO BARs might get this far and still not want checking. */
 402         if (!(pdn->eeh_mode & EEH_MODE_SUPPORTED) ||
 403             pdn->eeh_mode & EEH_MODE_NOCHECK) {
 404                 ignored_check++;
 405 #ifdef DEBUG
 406                 printk ("EEH:ignored check (%x) for %s %s\n",
 407                         pdn->eeh_mode, pci_name (dev), dn->full_name);
 408 #endif
 409                 return 0;
 410         }
 411
 412         if (!pdn->eeh_config_addr && !pdn->eeh_pe_config_addr) {
 413                 no_cfg_addr++;
 414                 return 0;
 415         }
 416
 417         /* If we already have a pending isolation event for this
 418          * slot, we know it's bad already, we don't need to check.
 419          * Do this checking under a lock; as multiple PCI devices
 420          * in one slot might report errors simultaneously, and we
 421          * only want one error recovery routine running.
 422          */
 423         spin_lock_irqsave(&confirm_error_lock, flags);
 424         rc = 1;
 425         if (pdn->eeh_mode & EEH_MODE_ISOLATED) {
 426                 pdn->eeh_check_count ++;
 427                 if (pdn->eeh_check_count >= EEH_MAX_FAILS) {
 428                         printk (KERN_ERR "EEH: Device driver ignored %d bad reads, panicing\n",
 429                                 pdn->eeh_check_count);
 430                         dump_stack();
 431                         msleep(5000);
 432
 433                         /* re-read the slot reset state */
 434                         if (read_slot_reset_state(pdn, rets) != 0)
 435                                 rets[0] = -1;   /* reset state unknown */
 436
 437                         /* If we are here, then we hit an infinite loop. Stop. */
 438                         panic("EEH: MMIO halt (%d) on device:%s\n", rets[0], pci_name(dev));
 439                 }
 440                 goto dn_unlock;
 441         }
 442
 443         /*
 444          * Now test for an EEH failure.  This is VERY expensive.
 445          * Note that the eeh_config_addr may be a parent device
 446          * in the case of a device behind a bridge, or it may be
 447          * function zero of a multi-function device.
 448          * In any case they must share a common PHB.
 449          */
 450         ret = read_slot_reset_state(pdn, rets);
 451
 452         /* If the call to firmware failed, punt */
 453         if (ret != 0) {
 454                 printk(KERN_WARNING "EEH: read_slot_reset_state() failed; rc=%d dn=%s\n",
 455                        ret, dn->full_name);
 456                 false_positives++;
 457                 rc = 0;
 458                 goto dn_unlock;
 459         }
 460
 461         /* Note that config-io to empty slots may fail;
 462          * they are empty when they don't have children. */
 463         if ((rets[0] == 5) && (dn->child == NULL)) {
 464                 false_positives++;
 465                 rc = 0;
 466                 goto dn_unlock;
 467         }
 468
 469         /* If EEH is not supported on this device, punt. */
 470         if (rets[1] != 1) {
 471                 printk(KERN_WARNING "EEH: event on unsupported device, rc=%d dn=%s\n",
 472                        ret, dn->full_name);
 473                 false_positives++;
 474                 rc = 0;
 475                 goto dn_unlock;
 476         }
 477
 478         /* If not the kind of error we know about, punt. */
 479         if (rets[0] != 1 && rets[0] != 2 && rets[0] != 4 && rets[0] != 5) {
 480                 false_positives++;
 481                 rc = 0;
 482                 goto dn_unlock;
 483         }
 484
 485         slot_resets++;
 486
 487         /* Avoid repeated reports of this failure, including problems
 488          * with other functions on this device, and functions under
 489          * bridges. */
 490         eeh_mark_slot (dn, EEH_MODE_ISOLATED);
 491         spin_unlock_irqrestore(&confirm_error_lock, flags);
 492
 493         eeh_send_failure_event (dn, dev);
 494
 495         /* Most EEH events are due to device driver bugs.  Having
 496          * a stack trace will help the device-driver authors figure
 497          * out what happened.  So print that out. */
 498         dump_stack();
 499         return 1;
 500
 501 dn_unlock:
 502         spin_unlock_irqrestore(&confirm_error_lock, flags);
 503         return rc;
 504 }
 505
 506 EXPORT_SYMBOL_GPL(eeh_dn_check_failure);
 507
 508 /**
 509  * eeh_check_failure - check if all 1's data is due to EEH slot freeze
 510  * @token i/o token, should be address in the form 0xA....
 511  * @val value, should be all 1's (XXX why do we need this arg??)
 512  *
 513  * Check for an EEH failure at the given token address.  Call this
 514  * routine if the result of a read was all 0xff's and you want to
 515  * find out if this is due to an EEH slot freeze event.  This routine
 516  * will query firmware for the EEH status.
 517  *
 518  * Note this routine is safe to call in an interrupt context.
 519  */
 520 unsigned long eeh_check_failure(const volatile void __iomem *token, unsigned long val)
 521 {
 522         unsigned long addr;
 523         struct pci_dev *dev;
 524         struct device_node *dn;
 525
 526         /* Finding the phys addr + pci device; this is pretty quick. */
 527         addr = eeh_token_to_phys((unsigned long __force) token);
 528         dev = pci_get_device_by_addr(addr);
 529         if (!dev) {
 530                 no_device++;
 531                 return val;
 532         }
 533
 534         dn = pci_device_to_OF_node(dev);
 535         eeh_dn_check_failure (dn, dev);
 536
 537         pci_dev_put(dev);
 538         return val;
 539 }
 540
 541 EXPORT_SYMBOL(eeh_check_failure);
 542
 543 /* ------------------------------------------------------------- */
 544 /* The code below deals with error recovery */
 545
 546 /**
 547  * rtas_pci_enable - enable MMIO or DMA transfers for this slot
 548  * @pdn pci device node
 549  */
 550
 551 int
 552 rtas_pci_enable(struct pci_dn *pdn, int function)
 553 {
 554         int config_addr;
 555         int rc;
 556
 557         /* Use PE configuration address, if present */
 558         config_addr = pdn->eeh_config_addr;
 559         if (pdn->eeh_pe_config_addr)
 560                 config_addr = pdn->eeh_pe_config_addr;
 561
 562         rc = rtas_call(ibm_set_eeh_option, 4, 1, NULL,
 563                        config_addr,
 564                        BUID_HI(pdn->phb->buid),
 565                        BUID_LO(pdn->phb->buid),
 566                             function);
 567
 568         if (rc)
 569                 printk(KERN_WARNING "EEH: Unexpected state change %d, err=%d dn=%s\n",
 570                         function, rc, pdn->node->full_name);
 571
 572         rc = eeh_wait_for_slot_status (pdn, PCI_BUS_RESET_WAIT_MSEC);
 573         if ((rc == 4) && (function == EEH_THAW_MMIO))
 574                 return 0;
 575
 576         return rc;
 577 }
 578
 579 /**
 580  * rtas_pci_slot_reset - raises/lowers the pci #RST line
 581  * @pdn pci device node
 582  * @state: 1/0 to raise/lower the #RST
 583  *
 584  * Clear the EEH-frozen condition on a slot.  This routine
 585  * asserts the PCI #RST line if the 'state' argument is '1',
 586  * and drops the #RST line if 'state is '0'.  This routine is
 587  * safe to call in an interrupt context.
 588  *
 589  */
 590
 591 static void
 592 rtas_pci_slot_reset(struct pci_dn *pdn, int state)
 593 {
 594         int config_addr;
 595         int rc;
 596
 597         BUG_ON (pdn==NULL);
 598
 599         if (!pdn->phb) {
 600                 printk (KERN_WARNING "EEH: in slot reset, device node %s has no phb\n",
 601                         pdn->node->full_name);
 602                 return;
 603         }
 604
 605         /* Use PE configuration address, if present */
 606         config_addr = pdn->eeh_config_addr;
 607         if (pdn->eeh_pe_config_addr)
 608                 config_addr = pdn->eeh_pe_config_addr;
 609
 610         rc = rtas_call(ibm_set_slot_reset,4,1, NULL,
 611                        config_addr,
 612                        BUID_HI(pdn->phb->buid),
 613                        BUID_LO(pdn->phb->buid),
 614                        state);
 615         if (rc)
 616                 printk (KERN_WARNING "EEH: Unable to reset the failed slot,"
 617                         " (%d) #RST=%d dn=%s\n",
 618                         rc, state, pdn->node->full_name);
 619 }
 620
 621 /**
 622  * pcibios_set_pcie_slot_reset - Set PCI-E reset state
 623  * @dev:        pci device struct
 624  * @state:      reset state to enter
 625  *
 626  * Return value:
 627  *      0 if success
 628  **/
 629 int pcibios_set_pcie_reset_state(struct pci_dev *dev, enum pcie_reset_state state)
 630 {
 631         struct device_node *dn = pci_device_to_OF_node(dev);
 632         struct pci_dn *pdn = PCI_DN(dn);
 633
 634         switch (state) {
 635         case pcie_deassert_reset:
 636                 rtas_pci_slot_reset(pdn, 0);
 637                 break;
 638         case pcie_hot_reset:
 639                 rtas_pci_slot_reset(pdn, 1);
 640                 break;
 641         case pcie_warm_reset:
 642                 rtas_pci_slot_reset(pdn, 3);
 643                 break;
 644         default:
 645                 return -EINVAL;
 646         };
 647
 648         return 0;
 649 }
 650
 651 /**
 652  * rtas_set_slot_reset -- assert the pci #RST line for 1/4 second
 653  * @pdn: pci device node to be reset.
 654  *
 655  *  Return 0 if success, else a non-zero value.
 656  */
 657
 658 static void __rtas_set_slot_reset(struct pci_dn *pdn)
 659 {
 660         rtas_pci_slot_reset (pdn, 1);
 661
 662         /* The PCI bus requires that the reset be held high for at least
 663          * a 100 milliseconds. We wait a bit longer 'just in case'.  */
 664
 665 #define PCI_BUS_RST_HOLD_TIME_MSEC 250
 666         msleep (PCI_BUS_RST_HOLD_TIME_MSEC);
 667
 668         /* We might get hit with another EEH freeze as soon as the
 669          * pci slot reset line is dropped. Make sure we don't miss
 670          * these, and clear the flag now. */
 671         eeh_clear_slot (pdn->node, EEH_MODE_ISOLATED);
 672
 673         rtas_pci_slot_reset (pdn, 0);
 674
 675         /* After a PCI slot has been reset, the PCI Express spec requires
 676          * a 1.5 second idle time for the bus to stabilize, before starting
 677          * up traffic. */
 678 #define PCI_BUS_SETTLE_TIME_MSEC 1800
 679         msleep (PCI_BUS_SETTLE_TIME_MSEC);
 680 }
 681
 682 int rtas_set_slot_reset(struct pci_dn *pdn)
 683 {
 684         int i, rc;
 685
 686         /* Take three shots at resetting the bus */
 687         for (i=0; i<3; i++) {
 688                 __rtas_set_slot_reset(pdn);
 689
 690                 rc = eeh_wait_for_slot_status(pdn, PCI_BUS_RESET_WAIT_MSEC);
 691                 if (rc == 0)
 692                         return 0;
 693
 694                 if (rc < 0) {
 695                         printk (KERN_ERR "EEH: unrecoverable slot failure %s\n",
 696                                 pdn->node->full_name);
 697                         return -1;
 698                 }
 699                 printk (KERN_ERR "EEH: bus reset %d failed on slot %s\n",
 700                         i+1, pdn->node->full_name);
 701         }
 702
 703         return -1;
 704 }
 705
 706 /* ------------------------------------------------------- */
 707 /** Save and restore of PCI BARs
 708  *
 709  * Although firmware will set up BARs during boot, it doesn't
 710  * set up device BAR's after a device reset, although it will,
 711  * if requested, set up bridge configuration. Thus, we need to
 712  * configure the PCI devices ourselves.
 713  */
 714
 715 /**
 716  * __restore_bars - Restore the Base Address Registers
 717  * @pdn: pci device node
 718  *
 719  * Loads the PCI configuration space base address registers,
 720  * the expansion ROM base address, the latency timer, and etc.
 721  * from the saved values in the device node.
 722  */
 723 static inline void __restore_bars (struct pci_dn *pdn)
 724 {
 725         int i;
 726
 727         if (NULL==pdn->phb) return;
 728         for (i=4; i<10; i++) {
 729                 rtas_write_config(pdn, i*4, 4, pdn->config_space[i]);
 730         }
 731
 732         /* 12 == Expansion ROM Address */
 733         rtas_write_config(pdn, 12*4, 4, pdn->config_space[12]);
 734
 735 #define BYTE_SWAP(OFF) (8*((OFF)/4)+3-(OFF))
 736 #define SAVED_BYTE(OFF) (((u8 *)(pdn->config_space))[BYTE_SWAP(OFF)])
 737
 738         rtas_write_config (pdn, PCI_CACHE_LINE_SIZE, 1,
 739                     SAVED_BYTE(PCI_CACHE_LINE_SIZE));
 740
 741         rtas_write_config (pdn, PCI_LATENCY_TIMER, 1,
 742                     SAVED_BYTE(PCI_LATENCY_TIMER));
 743
 744         /* max latency, min grant, interrupt pin and line */
 745         rtas_write_config(pdn, 15*4, 4, pdn->config_space[15]);
 746 }
 747
 748 /**
 749  * eeh_restore_bars - restore the PCI config space info
 750  *
 751  * This routine performs a recursive walk to the children
 752  * of this device as well.
 753  */
 754 void eeh_restore_bars(struct pci_dn *pdn)
 755 {
 756         struct device_node *dn;
 757         if (!pdn)
 758                 return;
 759
 760         if ((pdn->eeh_mode & EEH_MODE_SUPPORTED) && !IS_BRIDGE(pdn->class_code))
 761                 __restore_bars (pdn);
 762
 763         dn = pdn->node->child;
 764         while (dn) {
 765                 eeh_restore_bars (PCI_DN(dn));
 766                 dn = dn->sibling;
 767         }
 768 }
 769
 770 /**
 771  * eeh_save_bars - save device bars
 772  *
 773  * Save the values of the device bars. Unlike the restore
 774  * routine, this routine is *not* recursive. This is because
 775  * PCI devices are added individuallly; but, for the restore,
 776  * an entire slot is reset at a time.
 777  */
 778 static void eeh_save_bars(struct pci_dn *pdn)
 779 {
 780         int i;
 781
 782         if (!pdn )
 783                 return;
 784
 785         for (i = 0; i < 16; i++)
 786                 rtas_read_config(pdn, i * 4, 4, &pdn->config_space[i]);
 787 }
 788
 789 void
 790 rtas_configure_bridge(struct pci_dn *pdn)
 791 {
 792         int config_addr;
 793         int rc;
 794
 795         /* Use PE configuration address, if present */
 796         config_addr = pdn->eeh_config_addr;
 797         if (pdn->eeh_pe_config_addr)
 798                 config_addr = pdn->eeh_pe_config_addr;
 799
 800         rc = rtas_call(ibm_configure_bridge,3,1, NULL,
 801                        config_addr,
 802                        BUID_HI(pdn->phb->buid),
 803                        BUID_LO(pdn->phb->buid));
 804         if (rc) {
 805                 printk (KERN_WARNING "EEH: Unable to configure device bridge (%d) for %s\n",
 806                         rc, pdn->node->full_name);
 807         }
 808 }
 809
 810 /* ------------------------------------------------------------- */
 811 /* The code below deals with enabling EEH for devices during  the
 812  * early boot sequence.  EEH must be enabled before any PCI probing
 813  * can be done.
 814  */
 815
 816 #define EEH_ENABLE 1
 817
 818 struct eeh_early_enable_info {
 819         unsigned int buid_hi;
 820         unsigned int buid_lo;
 821 };
 822
 823 static int get_pe_addr (int config_addr,
 824                         struct eeh_early_enable_info *info)
 825 {
 826         unsigned int rets[3];
 827         int ret;
 828
 829         /* Use latest config-addr token on power6 */
 830         if (ibm_get_config_addr_info2 != RTAS_UNKNOWN_SERVICE) {
 831                 /* Make sure we have a PE in hand */
 832                 ret = rtas_call (ibm_get_config_addr_info2, 4, 2, rets,
 833                         config_addr, info->buid_hi, info->buid_lo, 1);
 834                 if (ret || (rets[0]==0))
 835                         return 0;
 836
 837                 ret = rtas_call (ibm_get_config_addr_info2, 4, 2, rets,
 838                         config_addr, info->buid_hi, info->buid_lo, 0);
 839                 if (ret)
 840                         return 0;
 841                 return rets[0];
 842         }
 843
 844         /* Use older config-addr token on power5 */
 845         if (ibm_get_config_addr_info != RTAS_UNKNOWN_SERVICE) {
 846                 ret = rtas_call (ibm_get_config_addr_info, 4, 2, rets,
 847                         config_addr, info->buid_hi, info->buid_lo, 0);
 848                 if (ret)
 849                         return 0;
 850                 return rets[0];
 851         }
 852         return 0;
 853 }
 854
 855 /* Enable eeh for the given device node. */
 856 static void *early_enable_eeh(struct device_node *dn, void *data)
 857 {
 858         unsigned int rets[3];
 859         struct eeh_early_enable_info *info = data;
 860         int ret;
 861         const char *status = of_get_property(dn, "status", NULL);
 862         const u32 *class_code = of_get_property(dn, "class-code", NULL);
 863         const u32 *vendor_id = of_get_property(dn, "vendor-id", NULL);
 864         const u32 *device_id = of_get_property(dn, "device-id", NULL);
 865         const u32 *regs;
 866         int enable;
 867         struct pci_dn *pdn = PCI_DN(dn);
 868
 869         pdn->class_code = 0;
 870         pdn->eeh_mode = 0;
 871         pdn->eeh_check_count = 0;
 872         pdn->eeh_freeze_count = 0;
 873
 874         if (status && strcmp(status, "ok") != 0)
 875                 return NULL;    /* ignore devices with bad status */
 876
 877         /* Ignore bad nodes. */
 878         if (!class_code || !vendor_id || !device_id)
 879                 return NULL;
 880
 881         /* There is nothing to check on PCI to ISA bridges */
 882         if (dn->type && !strcmp(dn->type, "isa")) {
 883                 pdn->eeh_mode |= EEH_MODE_NOCHECK;
 884                 return NULL;
 885         }
 886         pdn->class_code = *class_code;
 887
 888         /*
 889          * Now decide if we are going to "Disable" EEH checking
 890          * for this device.  We still run with the EEH hardware active,
 891          * but we won't be checking for ff's.  This means a driver
 892          * could return bad data (very bad!), an interrupt handler could
 893          * hang waiting on status bits that won't change, etc.
 894          * But there are a few cases like display devices that make sense.
 895          */
 896         enable = 1;     /* i.e. we will do checking */
 897 #if 0
 898         if ((*class_code >> 16) == PCI_BASE_CLASS_DISPLAY)
 899                 enable = 0;
 900 #endif
 901
 902         if (!enable)
 903                 pdn->eeh_mode |= EEH_MODE_NOCHECK;
 904
 905         /* Ok... see if this device supports EEH.  Some do, some don't,
 906          * and the only way to find out is to check each and every one. */
 907         regs = of_get_property(dn, "reg", NULL);
 908         if (regs) {
 909                 /* First register entry is addr (00BBSS00)  */
 910                 /* Try to enable eeh */
 911                 ret = rtas_call(ibm_set_eeh_option, 4, 1, NULL,
 912                                 regs[0], info->buid_hi, info->buid_lo,
 913                                 EEH_ENABLE);
 914
 915                 enable = 0;
 916                 if (ret == 0) {
 917                         pdn->eeh_config_addr = regs[0];
 918
 919                         /* If the newer, better, ibm,get-config-addr-info is supported,
 920                          * then use that instead. */
 921                         pdn->eeh_pe_config_addr = get_pe_addr(pdn->eeh_config_addr, info);
 922
 923                         /* Some older systems (Power4) allow the
 924                          * ibm,set-eeh-option call to succeed even on nodes
 925                          * where EEH is not supported. Verify support
 926                          * explicitly. */
 927                         ret = read_slot_reset_state(pdn, rets);
 928                         if ((ret == 0) && (rets[1] == 1))
 929                                 enable = 1;
 930                 }
 931
 932                 if (enable) {
 933                         eeh_subsystem_enabled = 1;
 934                         pdn->eeh_mode |= EEH_MODE_SUPPORTED;
 935
 936 #ifdef DEBUG
 937                         printk(KERN_DEBUG "EEH: %s: eeh enabled, config=%x pe_config=%x\n",
 938                                dn->full_name, pdn->eeh_config_addr, pdn->eeh_pe_config_addr);
 939 #endif
 940                 } else {
 941
 942                         /* This device doesn't support EEH, but it may have an
 943                          * EEH parent, in which case we mark it as supported. */
 944                         if (dn->parent && PCI_DN(dn->parent)
 945                             && (PCI_DN(dn->parent)->eeh_mode & EEH_MODE_SUPPORTED)) {
 946                                 /* Parent supports EEH. */
 947                                 pdn->eeh_mode |= EEH_MODE_SUPPORTED;
 948                                 pdn->eeh_config_addr = PCI_DN(dn->parent)->eeh_config_addr;
 949                                 return NULL;
 950                         }
 951                 }
 952         } else {
 953                 printk(KERN_WARNING "EEH: %s: unable to get reg property.\n",
 954                        dn->full_name);
 955         }
 956
 957         eeh_save_bars(pdn);
 958         return NULL;
 959 }
 960
 961 /*
 962  * Initialize EEH by trying to enable it for all of the adapters in the system.
 963  * As a side effect we can determine here if eeh is supported at all.
 964  * Note that we leave EEH on so failed config cycles won't cause a machine
 965  * check.  If a user turns off EEH for a particular adapter they are really
 966  * telling Linux to ignore errors.  Some hardware (e.g. POWER5) won't
 967  * grant access to a slot if EEH isn't enabled, and so we always enable
 968  * EEH for all slots/all devices.
 969  *
 970  * The eeh-force-off option disables EEH checking globally, for all slots.
 971  * Even if force-off is set, the EEH hardware is still enabled, so that
 972  * newer systems can boot.
 973  */
 974 void __init eeh_init(void)
 975 {
 976         struct device_node *phb, *np;
 977         struct eeh_early_enable_info info;
 978
 979         spin_lock_init(&confirm_error_lock);
 980         spin_lock_init(&slot_errbuf_lock);
 981
 982         np = of_find_node_by_path("/rtas");
 983         if (np == NULL)
 984                 return;
 985
 986         ibm_set_eeh_option = rtas_token("ibm,set-eeh-option");
 987         ibm_set_slot_reset = rtas_token("ibm,set-slot-reset");
 988         ibm_read_slot_reset_state2 = rtas_token("ibm,read-slot-reset-state2");
 989         ibm_read_slot_reset_state = rtas_token("ibm,read-slot-reset-state");
 990         ibm_slot_error_detail = rtas_token("ibm,slot-error-detail");
 991         ibm_get_config_addr_info = rtas_token("ibm,get-config-addr-info");
 992         ibm_get_config_addr_info2 = rtas_token("ibm,get-config-addr-info2");
 993         ibm_configure_bridge = rtas_token ("ibm,configure-bridge");
 994
 995         if (ibm_set_eeh_option == RTAS_UNKNOWN_SERVICE)
 996                 return;
 997
 998         eeh_error_buf_size = rtas_token("rtas-error-log-max");
 999         if (eeh_error_buf_size == RTAS_UNKNOWN_SERVICE) {
1000                 eeh_error_buf_size = 1024;
1001         }
1002         if (eeh_error_buf_size > RTAS_ERROR_LOG_MAX) {
1003                 printk(KERN_WARNING "EEH: rtas-error-log-max is bigger than allocated "
1004                       "buffer ! (%d vs %d)", eeh_error_buf_size, RTAS_ERROR_LOG_MAX);
1005                 eeh_error_buf_size = RTAS_ERROR_LOG_MAX;
1006         }
1007
1008         /* Enable EEH for all adapters.  Note that eeh requires buid's */
1009         for (phb = of_find_node_by_name(NULL, "pci"); phb;
1010              phb = of_find_node_by_name(phb, "pci")) {
1011                 unsigned long buid;
1012
1013                 buid = get_phb_buid(phb);
1014                 if (buid == 0 || PCI_DN(phb) == NULL)
1015                         continue;
1016
1017                 info.buid_lo = BUID_LO(buid);
1018                 info.buid_hi = BUID_HI(buid);
1019                 traverse_pci_devices(phb, early_enable_eeh, &info);
1020         }
1021
1022         if (eeh_subsystem_enabled)
1023                 printk(KERN_INFO "EEH: PCI Enhanced I/O Error Handling Enabled\n");
1024         else
1025                 printk(KERN_WARNING "EEH: No capable adapters found\n");
1026 }
1027
1028 /**
1029  * eeh_add_device_early - enable EEH for the indicated device_node
1030  * @dn: device node for which to set up EEH
1031  *
1032  * This routine must be used to perform EEH initialization for PCI
1033  * devices that were added after system boot (e.g. hotplug, dlpar).
1034  * This routine must be called before any i/o is performed to the
1035  * adapter (inluding any config-space i/o).
1036  * Whether this actually enables EEH or not for this device depends
1037  * on the CEC architecture, type of the device, on earlier boot
1038  * command-line arguments & etc.
1039  */
1040 static void eeh_add_device_early(struct device_node *dn)
1041 {
1042         struct pci_controller *phb;
1043         struct eeh_early_enable_info info;
1044
1045         if (!dn || !PCI_DN(dn))
1046                 return;
1047         phb = PCI_DN(dn)->phb;
1048
1049         /* USB Bus children of PCI devices will not have BUID's */
1050         if (NULL == phb || 0 == phb->buid)
1051                 return;
1052
1053         info.buid_hi = BUID_HI(phb->buid);
1054         info.buid_lo = BUID_LO(phb->buid);
1055         early_enable_eeh(dn, &info);
1056 }
1057
1058 void eeh_add_device_tree_early(struct device_node *dn)
1059 {
1060         struct device_node *sib;
1061         for (sib = dn->child; sib; sib = sib->sibling)
1062                 eeh_add_device_tree_early(sib);
1063         eeh_add_device_early(dn);
1064 }
1065 EXPORT_SYMBOL_GPL(eeh_add_device_tree_early);
1066
1067 /**
1068  * eeh_add_device_late - perform EEH initialization for the indicated pci device
1069  * @dev: pci device for which to set up EEH
1070  *
1071  * This routine must be used to complete EEH initialization for PCI
1072  * devices that were added after system boot (e.g. hotplug, dlpar).
1073  */
1074 static void eeh_add_device_late(struct pci_dev *dev)
1075 {
1076         struct device_node *dn;
1077         struct pci_dn *pdn;
1078
1079         if (!dev || !eeh_subsystem_enabled)
1080                 return;
1081
1082 #ifdef DEBUG
1083         printk(KERN_DEBUG "EEH: adding device %s\n", pci_name(dev));
1084 #endif
1085
1086         pci_dev_get (dev);
1087         dn = pci_device_to_OF_node(dev);
1088         pdn = PCI_DN(dn);
1089         pdn->pcidev = dev;
1090
1091         pci_addr_cache_insert_device (dev);
1092 }
1093
1094 void eeh_add_device_tree_late(struct pci_bus *bus)
1095 {
1096         struct pci_dev *dev;
1097
1098         list_for_each_entry(dev, &bus->devices, bus_list) {
1099                 eeh_add_device_late(dev);
1100                 if (dev->hdr_type == PCI_HEADER_TYPE_BRIDGE) {
1101                         struct pci_bus *subbus = dev->subordinate;
1102                         if (subbus)
1103                                 eeh_add_device_tree_late(subbus);
1104                 }
1105         }
1106 }
1107 EXPORT_SYMBOL_GPL(eeh_add_device_tree_late);
1108
1109 /**
1110  * eeh_remove_device - undo EEH setup for the indicated pci device
1111  * @dev: pci device to be removed
1112  *
1113  * This routine should be called when a device is removed from
1114  * a running system (e.g. by hotplug or dlpar).  It unregisters
1115  * the PCI device from the EEH subsystem.  I/O errors affecting
1116  * this device will no longer be detected after this call; thus,
1117  * i/o errors affecting this slot may leave this device unusable.
1118  */
1119 static void eeh_remove_device(struct pci_dev *dev)
1120 {
1121         struct device_node *dn;
1122         if (!dev || !eeh_subsystem_enabled)
1123                 return;
1124
1125         /* Unregister the device with the EEH/PCI address search system */
1126 #ifdef DEBUG
1127         printk(KERN_DEBUG "EEH: remove device %s\n", pci_name(dev));
1128 #endif
1129         pci_addr_cache_remove_device(dev);
1130
1131         dn = pci_device_to_OF_node(dev);
1132         if (PCI_DN(dn)->pcidev) {
1133                 PCI_DN(dn)->pcidev = NULL;
1134                 pci_dev_put (dev);
1135         }
1136 }
1137
1138 void eeh_remove_bus_device(struct pci_dev *dev)
1139 {
1140         struct pci_bus *bus = dev->subordinate;
1141         struct pci_dev *child, *tmp;
1142
1143         eeh_remove_device(dev);
1144
1145         if (bus && dev->hdr_type == PCI_HEADER_TYPE_BRIDGE) {
1146                 list_for_each_entry_safe(child, tmp, &bus->devices, bus_list)
1147                          eeh_remove_bus_device(child);
1148         }
1149 }
1150 EXPORT_SYMBOL_GPL(eeh_remove_bus_device);
1151
1152 static int proc_eeh_show(struct seq_file *m, void *v)
1153 {
1154         if (0 == eeh_subsystem_enabled) {
1155                 seq_printf(m, "EEH Subsystem is globally disabled\n");
1156                 seq_printf(m, "eeh_total_mmio_ffs=%ld\n", total_mmio_ffs);
1157         } else {
1158                 seq_printf(m, "EEH Subsystem is enabled\n");
1159                 seq_printf(m,
1160                                 "no device=%ld\n"
1161                                 "no device node=%ld\n"
1162                                 "no config address=%ld\n"
1163                                 "check not wanted=%ld\n"
1164                                 "eeh_total_mmio_ffs=%ld\n"
1165                                 "eeh_false_positives=%ld\n"
1166                                 "eeh_ignored_failures=%ld\n"
1167                                 "eeh_slot_resets=%ld\n",
1168                                 no_device, no_dn, no_cfg_addr,
1169                                 ignored_check, total_mmio_ffs,
1170                                 false_positives, ignored_failures,
1171                                 slot_resets);
1172         }
1173
1174         return 0;
1175 }
1176
1177 static int proc_eeh_open(struct inode *inode, struct file *file)
1178 {
1179         return single_open(file, proc_eeh_show, NULL);
1180 }
1181
1182 static const struct file_operations proc_eeh_operations = {
1183         .open      = proc_eeh_open,
1184         .read      = seq_read,
1185         .llseek    = seq_lseek,
1186         .release   = single_release,
1187 };
1188
1189 static int __init eeh_init_proc(void)
1190 {
1191         struct proc_dir_entry *e;
1192
1193         if (machine_is(pseries)) {
1194                 e = create_proc_entry("ppc64/eeh", 0, NULL);
1195                 if (e)
1196                         e->proc_fops = &proc_eeh_operations;
1197         }
1198
1199         return 0;
1200 }
1201 __initcall(eeh_init_proc);