Merge master.kernel.org:/home/rmk/linux-2.6-arm
[linux-2.6] / 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   100000
78
79 /* Misc forward declaraions */
80 static void eeh_save_bars(struct pci_dev * pdev, struct pci_dn *pdn);
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
89 int eeh_subsystem_enabled;
90 EXPORT_SYMBOL(eeh_subsystem_enabled);
91
92 /* Lock to avoid races due to multiple reports of an error */
93 static DEFINE_SPINLOCK(confirm_error_lock);
94
95 /* Buffer for reporting slot-error-detail rtas calls */
96 static unsigned char slot_errbuf[RTAS_ERROR_LOG_MAX];
97 static DEFINE_SPINLOCK(slot_errbuf_lock);
98 static int eeh_error_buf_size;
99
100 /* System monitoring statistics */
101 static DEFINE_PER_CPU(unsigned long, no_device);
102 static DEFINE_PER_CPU(unsigned long, no_dn);
103 static DEFINE_PER_CPU(unsigned long, no_cfg_addr);
104 static DEFINE_PER_CPU(unsigned long, ignored_check);
105 static DEFINE_PER_CPU(unsigned long, total_mmio_ffs);
106 static DEFINE_PER_CPU(unsigned long, false_positives);
107 static DEFINE_PER_CPU(unsigned long, ignored_failures);
108 static DEFINE_PER_CPU(unsigned long, slot_resets);
109
110 /**
111  * The pci address cache subsystem.  This subsystem places
112  * PCI device address resources into a red-black tree, sorted
113  * according to the address range, so that given only an i/o
114  * address, the corresponding PCI device can be **quickly**
115  * found. It is safe to perform an address lookup in an interrupt
116  * context; this ability is an important feature.
117  *
118  * Currently, the only customer of this code is the EEH subsystem;
119  * thus, this code has been somewhat tailored to suit EEH better.
120  * In particular, the cache does *not* hold the addresses of devices
121  * for which EEH is not enabled.
122  *
123  * (Implementation Note: The RB tree seems to be better/faster
124  * than any hash algo I could think of for this problem, even
125  * with the penalty of slow pointer chases for d-cache misses).
126  */
127 struct pci_io_addr_range
128 {
129         struct rb_node rb_node;
130         unsigned long addr_lo;
131         unsigned long addr_hi;
132         struct pci_dev *pcidev;
133         unsigned int flags;
134 };
135
136 static struct pci_io_addr_cache
137 {
138         struct rb_root rb_root;
139         spinlock_t piar_lock;
140 } pci_io_addr_cache_root;
141
142 static inline struct pci_dev *__pci_get_device_by_addr(unsigned long addr)
143 {
144         struct rb_node *n = pci_io_addr_cache_root.rb_root.rb_node;
145
146         while (n) {
147                 struct pci_io_addr_range *piar;
148                 piar = rb_entry(n, struct pci_io_addr_range, rb_node);
149
150                 if (addr < piar->addr_lo) {
151                         n = n->rb_left;
152                 } else {
153                         if (addr > piar->addr_hi) {
154                                 n = n->rb_right;
155                         } else {
156                                 pci_dev_get(piar->pcidev);
157                                 return piar->pcidev;
158                         }
159                 }
160         }
161
162         return NULL;
163 }
164
165 /**
166  * pci_get_device_by_addr - Get device, given only address
167  * @addr: mmio (PIO) phys address or i/o port number
168  *
169  * Given an mmio phys address, or a port number, find a pci device
170  * that implements this address.  Be sure to pci_dev_put the device
171  * when finished.  I/O port numbers are assumed to be offset
172  * from zero (that is, they do *not* have pci_io_addr added in).
173  * It is safe to call this function within an interrupt.
174  */
175 static struct pci_dev *pci_get_device_by_addr(unsigned long addr)
176 {
177         struct pci_dev *dev;
178         unsigned long flags;
179
180         spin_lock_irqsave(&pci_io_addr_cache_root.piar_lock, flags);
181         dev = __pci_get_device_by_addr(addr);
182         spin_unlock_irqrestore(&pci_io_addr_cache_root.piar_lock, flags);
183         return dev;
184 }
185
186 #ifdef DEBUG
187 /*
188  * Handy-dandy debug print routine, does nothing more
189  * than print out the contents of our addr cache.
190  */
191 static void pci_addr_cache_print(struct pci_io_addr_cache *cache)
192 {
193         struct rb_node *n;
194         int cnt = 0;
195
196         n = rb_first(&cache->rb_root);
197         while (n) {
198                 struct pci_io_addr_range *piar;
199                 piar = rb_entry(n, struct pci_io_addr_range, rb_node);
200                 printk(KERN_DEBUG "PCI: %s addr range %d [%lx-%lx]: %s\n",
201                        (piar->flags & IORESOURCE_IO) ? "i/o" : "mem", cnt,
202                        piar->addr_lo, piar->addr_hi, pci_name(piar->pcidev));
203                 cnt++;
204                 n = rb_next(n);
205         }
206 }
207 #endif
208
209 /* Insert address range into the rb tree. */
210 static struct pci_io_addr_range *
211 pci_addr_cache_insert(struct pci_dev *dev, unsigned long alo,
212                       unsigned long ahi, unsigned int flags)
213 {
214         struct rb_node **p = &pci_io_addr_cache_root.rb_root.rb_node;
215         struct rb_node *parent = NULL;
216         struct pci_io_addr_range *piar;
217
218         /* Walk tree, find a place to insert into tree */
219         while (*p) {
220                 parent = *p;
221                 piar = rb_entry(parent, struct pci_io_addr_range, rb_node);
222                 if (ahi < piar->addr_lo) {
223                         p = &parent->rb_left;
224                 } else if (alo > piar->addr_hi) {
225                         p = &parent->rb_right;
226                 } else {
227                         if (dev != piar->pcidev ||
228                             alo != piar->addr_lo || ahi != piar->addr_hi) {
229                                 printk(KERN_WARNING "PIAR: overlapping address range\n");
230                         }
231                         return piar;
232                 }
233         }
234         piar = (struct pci_io_addr_range *)kmalloc(sizeof(struct pci_io_addr_range), GFP_ATOMIC);
235         if (!piar)
236                 return NULL;
237
238         piar->addr_lo = alo;
239         piar->addr_hi = ahi;
240         piar->pcidev = dev;
241         piar->flags = flags;
242
243 #ifdef DEBUG
244         printk(KERN_DEBUG "PIAR: insert range=[%lx:%lx] dev=%s\n",
245                           alo, ahi, pci_name (dev));
246 #endif
247
248         rb_link_node(&piar->rb_node, parent, p);
249         rb_insert_color(&piar->rb_node, &pci_io_addr_cache_root.rb_root);
250
251         return piar;
252 }
253
254 static void __pci_addr_cache_insert_device(struct pci_dev *dev)
255 {
256         struct device_node *dn;
257         struct pci_dn *pdn;
258         int i;
259         int inserted = 0;
260
261         dn = pci_device_to_OF_node(dev);
262         if (!dn) {
263                 printk(KERN_WARNING "PCI: no pci dn found for dev=%s\n", pci_name(dev));
264                 return;
265         }
266
267         /* Skip any devices for which EEH is not enabled. */
268         pdn = PCI_DN(dn);
269         if (!(pdn->eeh_mode & EEH_MODE_SUPPORTED) ||
270             pdn->eeh_mode & EEH_MODE_NOCHECK) {
271 #ifdef DEBUG
272                 printk(KERN_INFO "PCI: skip building address cache for=%s - %s\n",
273                        pci_name(dev), pdn->node->full_name);
274 #endif
275                 return;
276         }
277
278         /* The cache holds a reference to the device... */
279         pci_dev_get(dev);
280
281         /* Walk resources on this device, poke them into the tree */
282         for (i = 0; i < DEVICE_COUNT_RESOURCE; i++) {
283                 unsigned long start = pci_resource_start(dev,i);
284                 unsigned long end = pci_resource_end(dev,i);
285                 unsigned int flags = pci_resource_flags(dev,i);
286
287                 /* We are interested only bus addresses, not dma or other stuff */
288                 if (0 == (flags & (IORESOURCE_IO | IORESOURCE_MEM)))
289                         continue;
290                 if (start == 0 || ~start == 0 || end == 0 || ~end == 0)
291                          continue;
292                 pci_addr_cache_insert(dev, start, end, flags);
293                 inserted = 1;
294         }
295
296         /* If there was nothing to add, the cache has no reference... */
297         if (!inserted)
298                 pci_dev_put(dev);
299 }
300
301 /**
302  * pci_addr_cache_insert_device - Add a device to the address cache
303  * @dev: PCI device whose I/O addresses we are interested in.
304  *
305  * In order to support the fast lookup of devices based on addresses,
306  * we maintain a cache of devices that can be quickly searched.
307  * This routine adds a device to that cache.
308  */
309 static void pci_addr_cache_insert_device(struct pci_dev *dev)
310 {
311         unsigned long flags;
312
313         spin_lock_irqsave(&pci_io_addr_cache_root.piar_lock, flags);
314         __pci_addr_cache_insert_device(dev);
315         spin_unlock_irqrestore(&pci_io_addr_cache_root.piar_lock, flags);
316 }
317
318 static inline void __pci_addr_cache_remove_device(struct pci_dev *dev)
319 {
320         struct rb_node *n;
321         int removed = 0;
322
323 restart:
324         n = rb_first(&pci_io_addr_cache_root.rb_root);
325         while (n) {
326                 struct pci_io_addr_range *piar;
327                 piar = rb_entry(n, struct pci_io_addr_range, rb_node);
328
329                 if (piar->pcidev == dev) {
330                         rb_erase(n, &pci_io_addr_cache_root.rb_root);
331                         removed = 1;
332                         kfree(piar);
333                         goto restart;
334                 }
335                 n = rb_next(n);
336         }
337
338         /* The cache no longer holds its reference to this device... */
339         if (removed)
340                 pci_dev_put(dev);
341 }
342
343 /**
344  * pci_addr_cache_remove_device - remove pci device from addr cache
345  * @dev: device to remove
346  *
347  * Remove a device from the addr-cache tree.
348  * This is potentially expensive, since it will walk
349  * the tree multiple times (once per resource).
350  * But so what; device removal doesn't need to be that fast.
351  */
352 static void pci_addr_cache_remove_device(struct pci_dev *dev)
353 {
354         unsigned long flags;
355
356         spin_lock_irqsave(&pci_io_addr_cache_root.piar_lock, flags);
357         __pci_addr_cache_remove_device(dev);
358         spin_unlock_irqrestore(&pci_io_addr_cache_root.piar_lock, flags);
359 }
360
361 /**
362  * pci_addr_cache_build - Build a cache of I/O addresses
363  *
364  * Build a cache of pci i/o addresses.  This cache will be used to
365  * find the pci device that corresponds to a given address.
366  * This routine scans all pci busses to build the cache.
367  * Must be run late in boot process, after the pci controllers
368  * have been scaned for devices (after all device resources are known).
369  */
370 void __init pci_addr_cache_build(void)
371 {
372         struct device_node *dn;
373         struct pci_dev *dev = NULL;
374
375         if (!eeh_subsystem_enabled)
376                 return;
377
378         spin_lock_init(&pci_io_addr_cache_root.piar_lock);
379
380         while ((dev = pci_get_device(PCI_ANY_ID, PCI_ANY_ID, dev)) != NULL) {
381                 /* Ignore PCI bridges ( XXX why ??) */
382                 if ((dev->class >> 16) == PCI_BASE_CLASS_BRIDGE) {
383                         continue;
384                 }
385                 pci_addr_cache_insert_device(dev);
386
387                 /* Save the BAR's; firmware doesn't restore these after EEH reset */
388                 dn = pci_device_to_OF_node(dev);
389                 eeh_save_bars(dev, PCI_DN(dn));
390         }
391
392 #ifdef DEBUG
393         /* Verify tree built up above, echo back the list of addrs. */
394         pci_addr_cache_print(&pci_io_addr_cache_root);
395 #endif
396 }
397
398 /* --------------------------------------------------------------- */
399 /* Above lies the PCI Address Cache. Below lies the EEH event infrastructure */
400
401 void eeh_slot_error_detail (struct pci_dn *pdn, int severity)
402 {
403         unsigned long flags;
404         int rc;
405
406         /* Log the error with the rtas logger */
407         spin_lock_irqsave(&slot_errbuf_lock, flags);
408         memset(slot_errbuf, 0, eeh_error_buf_size);
409
410         rc = rtas_call(ibm_slot_error_detail,
411                        8, 1, NULL, pdn->eeh_config_addr,
412                        BUID_HI(pdn->phb->buid),
413                        BUID_LO(pdn->phb->buid), NULL, 0,
414                        virt_to_phys(slot_errbuf),
415                        eeh_error_buf_size,
416                        severity);
417
418         if (rc == 0)
419                 log_error(slot_errbuf, ERR_TYPE_RTAS_LOG, 0);
420         spin_unlock_irqrestore(&slot_errbuf_lock, flags);
421 }
422
423 /**
424  * read_slot_reset_state - Read the reset state of a device node's slot
425  * @dn: device node to read
426  * @rets: array to return results in
427  */
428 static int read_slot_reset_state(struct pci_dn *pdn, int rets[])
429 {
430         int token, outputs;
431
432         if (ibm_read_slot_reset_state2 != RTAS_UNKNOWN_SERVICE) {
433                 token = ibm_read_slot_reset_state2;
434                 outputs = 4;
435         } else {
436                 token = ibm_read_slot_reset_state;
437                 rets[2] = 0; /* fake PE Unavailable info */
438                 outputs = 3;
439         }
440
441         return rtas_call(token, 3, outputs, rets, pdn->eeh_config_addr,
442                          BUID_HI(pdn->phb->buid), BUID_LO(pdn->phb->buid));
443 }
444
445 /**
446  * eeh_token_to_phys - convert EEH address token to phys address
447  * @token i/o token, should be address in the form 0xA....
448  */
449 static inline unsigned long eeh_token_to_phys(unsigned long token)
450 {
451         pte_t *ptep;
452         unsigned long pa;
453
454         ptep = find_linux_pte(init_mm.pgd, token);
455         if (!ptep)
456                 return token;
457         pa = pte_pfn(*ptep) << PAGE_SHIFT;
458
459         return pa | (token & (PAGE_SIZE-1));
460 }
461
462 /** 
463  * Return the "partitionable endpoint" (pe) under which this device lies
464  */
465 static struct device_node * find_device_pe(struct device_node *dn)
466 {
467         while ((dn->parent) && PCI_DN(dn->parent) &&
468               (PCI_DN(dn->parent)->eeh_mode & EEH_MODE_SUPPORTED)) {
469                 dn = dn->parent;
470         }
471         return dn;
472 }
473
474 /** Mark all devices that are peers of this device as failed.
475  *  Mark the device driver too, so that it can see the failure
476  *  immediately; this is critical, since some drivers poll
477  *  status registers in interrupts ... If a driver is polling,
478  *  and the slot is frozen, then the driver can deadlock in
479  *  an interrupt context, which is bad.
480  */
481
482 static void __eeh_mark_slot (struct device_node *dn, int mode_flag)
483 {
484         while (dn) {
485                 if (PCI_DN(dn)) {
486                         PCI_DN(dn)->eeh_mode |= mode_flag;
487
488                         if (dn->child)
489                                 __eeh_mark_slot (dn->child, mode_flag);
490                 }
491                 dn = dn->sibling;
492         }
493 }
494
495 void eeh_mark_slot (struct device_node *dn, int mode_flag)
496 {
497         dn = find_device_pe (dn);
498         PCI_DN(dn)->eeh_mode |= mode_flag;
499         __eeh_mark_slot (dn->child, mode_flag);
500 }
501
502 static void __eeh_clear_slot (struct device_node *dn, int mode_flag)
503 {
504         while (dn) {
505                 if (PCI_DN(dn)) {
506                         PCI_DN(dn)->eeh_mode &= ~mode_flag;
507                         PCI_DN(dn)->eeh_check_count = 0;
508                         if (dn->child)
509                                 __eeh_clear_slot (dn->child, mode_flag);
510                 }
511                 dn = dn->sibling;
512         }
513 }
514
515 void eeh_clear_slot (struct device_node *dn, int mode_flag)
516 {
517         unsigned long flags;
518         spin_lock_irqsave(&confirm_error_lock, flags);
519         dn = find_device_pe (dn);
520         PCI_DN(dn)->eeh_mode &= ~mode_flag;
521         PCI_DN(dn)->eeh_check_count = 0;
522         __eeh_clear_slot (dn->child, mode_flag);
523         spin_unlock_irqrestore(&confirm_error_lock, flags);
524 }
525
526 /**
527  * eeh_dn_check_failure - check if all 1's data is due to EEH slot freeze
528  * @dn device node
529  * @dev pci device, if known
530  *
531  * Check for an EEH failure for the given device node.  Call this
532  * routine if the result of a read was all 0xff's and you want to
533  * find out if this is due to an EEH slot freeze.  This routine
534  * will query firmware for the EEH status.
535  *
536  * Returns 0 if there has not been an EEH error; otherwise returns
537  * a non-zero value and queues up a slot isolation event notification.
538  *
539  * It is safe to call this routine in an interrupt context.
540  */
541 int eeh_dn_check_failure(struct device_node *dn, struct pci_dev *dev)
542 {
543         int ret;
544         int rets[3];
545         unsigned long flags;
546         struct pci_dn *pdn;
547         int rc = 0;
548
549         __get_cpu_var(total_mmio_ffs)++;
550
551         if (!eeh_subsystem_enabled)
552                 return 0;
553
554         if (!dn) {
555                 __get_cpu_var(no_dn)++;
556                 return 0;
557         }
558         pdn = PCI_DN(dn);
559
560         /* Access to IO BARs might get this far and still not want checking. */
561         if (!(pdn->eeh_mode & EEH_MODE_SUPPORTED) ||
562             pdn->eeh_mode & EEH_MODE_NOCHECK) {
563                 __get_cpu_var(ignored_check)++;
564 #ifdef DEBUG
565                 printk ("EEH:ignored check (%x) for %s %s\n", 
566                         pdn->eeh_mode, pci_name (dev), dn->full_name);
567 #endif
568                 return 0;
569         }
570
571         if (!pdn->eeh_config_addr) {
572                 __get_cpu_var(no_cfg_addr)++;
573                 return 0;
574         }
575
576         /* If we already have a pending isolation event for this
577          * slot, we know it's bad already, we don't need to check.
578          * Do this checking under a lock; as multiple PCI devices
579          * in one slot might report errors simultaneously, and we
580          * only want one error recovery routine running.
581          */
582         spin_lock_irqsave(&confirm_error_lock, flags);
583         rc = 1;
584         if (pdn->eeh_mode & EEH_MODE_ISOLATED) {
585                 pdn->eeh_check_count ++;
586                 if (pdn->eeh_check_count >= EEH_MAX_FAILS) {
587                         printk (KERN_ERR "EEH: Device driver ignored %d bad reads, panicing\n",
588                                 pdn->eeh_check_count);
589                         dump_stack();
590                         
591                         /* re-read the slot reset state */
592                         if (read_slot_reset_state(pdn, rets) != 0)
593                                 rets[0] = -1;   /* reset state unknown */
594
595                         /* If we are here, then we hit an infinite loop. Stop. */
596                         panic("EEH: MMIO halt (%d) on device:%s\n", rets[0], pci_name(dev));
597                 }
598                 goto dn_unlock;
599         }
600
601         /*
602          * Now test for an EEH failure.  This is VERY expensive.
603          * Note that the eeh_config_addr may be a parent device
604          * in the case of a device behind a bridge, or it may be
605          * function zero of a multi-function device.
606          * In any case they must share a common PHB.
607          */
608         ret = read_slot_reset_state(pdn, rets);
609
610         /* If the call to firmware failed, punt */
611         if (ret != 0) {
612                 printk(KERN_WARNING "EEH: read_slot_reset_state() failed; rc=%d dn=%s\n",
613                        ret, dn->full_name);
614                 __get_cpu_var(false_positives)++;
615                 rc = 0;
616                 goto dn_unlock;
617         }
618
619         /* If EEH is not supported on this device, punt. */
620         if (rets[1] != 1) {
621                 printk(KERN_WARNING "EEH: event on unsupported device, rc=%d dn=%s\n",
622                        ret, dn->full_name);
623                 __get_cpu_var(false_positives)++;
624                 rc = 0;
625                 goto dn_unlock;
626         }
627
628         /* If not the kind of error we know about, punt. */
629         if (rets[0] != 2 && rets[0] != 4 && rets[0] != 5) {
630                 __get_cpu_var(false_positives)++;
631                 rc = 0;
632                 goto dn_unlock;
633         }
634
635         /* Note that config-io to empty slots may fail;
636          * we recognize empty because they don't have children. */
637         if ((rets[0] == 5) && (dn->child == NULL)) {
638                 __get_cpu_var(false_positives)++;
639                 rc = 0;
640                 goto dn_unlock;
641         }
642
643         __get_cpu_var(slot_resets)++;
644  
645         /* Avoid repeated reports of this failure, including problems
646          * with other functions on this device, and functions under
647          * bridges. */
648         eeh_mark_slot (dn, EEH_MODE_ISOLATED);
649         spin_unlock_irqrestore(&confirm_error_lock, flags);
650
651         eeh_send_failure_event (dn, dev, rets[0], rets[2]);
652         
653         /* Most EEH events are due to device driver bugs.  Having
654          * a stack trace will help the device-driver authors figure
655          * out what happened.  So print that out. */
656         if (rets[0] != 5) dump_stack();
657         return 1;
658
659 dn_unlock:
660         spin_unlock_irqrestore(&confirm_error_lock, flags);
661         return rc;
662 }
663
664 EXPORT_SYMBOL_GPL(eeh_dn_check_failure);
665
666 /**
667  * eeh_check_failure - check if all 1's data is due to EEH slot freeze
668  * @token i/o token, should be address in the form 0xA....
669  * @val value, should be all 1's (XXX why do we need this arg??)
670  *
671  * Check for an EEH failure at the given token address.  Call this
672  * routine if the result of a read was all 0xff's and you want to
673  * find out if this is due to an EEH slot freeze event.  This routine
674  * will query firmware for the EEH status.
675  *
676  * Note this routine is safe to call in an interrupt context.
677  */
678 unsigned long eeh_check_failure(const volatile void __iomem *token, unsigned long val)
679 {
680         unsigned long addr;
681         struct pci_dev *dev;
682         struct device_node *dn;
683
684         /* Finding the phys addr + pci device; this is pretty quick. */
685         addr = eeh_token_to_phys((unsigned long __force) token);
686         dev = pci_get_device_by_addr(addr);
687         if (!dev) {
688                 __get_cpu_var(no_device)++;
689                 return val;
690         }
691
692         dn = pci_device_to_OF_node(dev);
693         eeh_dn_check_failure (dn, dev);
694
695         pci_dev_put(dev);
696         return val;
697 }
698
699 EXPORT_SYMBOL(eeh_check_failure);
700
701 /* ------------------------------------------------------------- */
702 /* The code below deals with error recovery */
703
704 /** Return negative value if a permanent error, else return
705  * a number of milliseconds to wait until the PCI slot is
706  * ready to be used.
707  */
708 static int
709 eeh_slot_availability(struct pci_dn *pdn)
710 {
711         int rc;
712         int rets[3];
713
714         rc = read_slot_reset_state(pdn, rets);
715
716         if (rc) return rc;
717
718         if (rets[1] == 0) return -1;  /* EEH is not supported */
719         if (rets[0] == 0)  return 0;  /* Oll Korrect */
720         if (rets[0] == 5) {
721                 if (rets[2] == 0) return -1; /* permanently unavailable */
722                 return rets[2]; /* number of millisecs to wait */
723         }
724         return -1;
725 }
726
727 /** rtas_pci_slot_reset raises/lowers the pci #RST line
728  *  state: 1/0 to raise/lower the #RST
729  *
730  * Clear the EEH-frozen condition on a slot.  This routine
731  * asserts the PCI #RST line if the 'state' argument is '1',
732  * and drops the #RST line if 'state is '0'.  This routine is
733  * safe to call in an interrupt context.
734  *
735  */
736
737 static void
738 rtas_pci_slot_reset(struct pci_dn *pdn, int state)
739 {
740         int rc;
741
742         BUG_ON (pdn==NULL); 
743
744         if (!pdn->phb) {
745                 printk (KERN_WARNING "EEH: in slot reset, device node %s has no phb\n",
746                         pdn->node->full_name);
747                 return;
748         }
749
750         rc = rtas_call(ibm_set_slot_reset,4,1, NULL,
751                        pdn->eeh_config_addr,
752                        BUID_HI(pdn->phb->buid),
753                        BUID_LO(pdn->phb->buid),
754                        state);
755         if (rc) {
756                 printk (KERN_WARNING "EEH: Unable to reset the failed slot, (%d) #RST=%d dn=%s\n", 
757                         rc, state, pdn->node->full_name);
758                 return;
759         }
760 }
761
762 /** rtas_set_slot_reset -- assert the pci #RST line for 1/4 second
763  *  dn -- device node to be reset.
764  */
765
766 void
767 rtas_set_slot_reset(struct pci_dn *pdn)
768 {
769         int i, rc;
770
771         rtas_pci_slot_reset (pdn, 1);
772
773         /* The PCI bus requires that the reset be held high for at least
774          * a 100 milliseconds. We wait a bit longer 'just in case'.  */
775
776 #define PCI_BUS_RST_HOLD_TIME_MSEC 250
777         msleep (PCI_BUS_RST_HOLD_TIME_MSEC);
778         
779         /* We might get hit with another EEH freeze as soon as the 
780          * pci slot reset line is dropped. Make sure we don't miss
781          * these, and clear the flag now. */
782         eeh_clear_slot (pdn->node, EEH_MODE_ISOLATED);
783
784         rtas_pci_slot_reset (pdn, 0);
785
786         /* After a PCI slot has been reset, the PCI Express spec requires
787          * a 1.5 second idle time for the bus to stabilize, before starting
788          * up traffic. */
789 #define PCI_BUS_SETTLE_TIME_MSEC 1800
790         msleep (PCI_BUS_SETTLE_TIME_MSEC);
791
792         /* Now double check with the firmware to make sure the device is
793          * ready to be used; if not, wait for recovery. */
794         for (i=0; i<10; i++) {
795                 rc = eeh_slot_availability (pdn);
796                 if (rc <= 0) break;
797
798                 msleep (rc+100);
799         }
800 }
801
802 /* ------------------------------------------------------- */
803 /** Save and restore of PCI BARs
804  *
805  * Although firmware will set up BARs during boot, it doesn't
806  * set up device BAR's after a device reset, although it will,
807  * if requested, set up bridge configuration. Thus, we need to
808  * configure the PCI devices ourselves.  
809  */
810
811 /**
812  * __restore_bars - Restore the Base Address Registers
813  * Loads the PCI configuration space base address registers,
814  * the expansion ROM base address, the latency timer, and etc.
815  * from the saved values in the device node.
816  */
817 static inline void __restore_bars (struct pci_dn *pdn)
818 {
819         int i;
820
821         if (NULL==pdn->phb) return;
822         for (i=4; i<10; i++) {
823                 rtas_write_config(pdn, i*4, 4, pdn->config_space[i]);
824         }
825
826         /* 12 == Expansion ROM Address */
827         rtas_write_config(pdn, 12*4, 4, pdn->config_space[12]);
828
829 #define BYTE_SWAP(OFF) (8*((OFF)/4)+3-(OFF))
830 #define SAVED_BYTE(OFF) (((u8 *)(pdn->config_space))[BYTE_SWAP(OFF)])
831
832         rtas_write_config (pdn, PCI_CACHE_LINE_SIZE, 1,
833                     SAVED_BYTE(PCI_CACHE_LINE_SIZE));
834
835         rtas_write_config (pdn, PCI_LATENCY_TIMER, 1,
836                     SAVED_BYTE(PCI_LATENCY_TIMER));
837
838         /* max latency, min grant, interrupt pin and line */
839         rtas_write_config(pdn, 15*4, 4, pdn->config_space[15]);
840 }
841
842 /**
843  * eeh_restore_bars - restore the PCI config space info
844  *
845  * This routine performs a recursive walk to the children
846  * of this device as well.
847  */
848 void eeh_restore_bars(struct pci_dn *pdn)
849 {
850         struct device_node *dn;
851         if (!pdn) 
852                 return;
853         
854         if (! pdn->eeh_is_bridge)
855                 __restore_bars (pdn);
856
857         dn = pdn->node->child;
858         while (dn) {
859                 eeh_restore_bars (PCI_DN(dn));
860                 dn = dn->sibling;
861         }
862 }
863
864 /**
865  * eeh_save_bars - save device bars
866  *
867  * Save the values of the device bars. Unlike the restore
868  * routine, this routine is *not* recursive. This is because
869  * PCI devices are added individuallly; but, for the restore,
870  * an entire slot is reset at a time.
871  */
872 static void eeh_save_bars(struct pci_dev * pdev, struct pci_dn *pdn)
873 {
874         int i;
875
876         if (!pdev || !pdn )
877                 return;
878         
879         for (i = 0; i < 16; i++)
880                 pci_read_config_dword(pdev, i * 4, &pdn->config_space[i]);
881
882         if (pdev->hdr_type == PCI_HEADER_TYPE_BRIDGE)
883                 pdn->eeh_is_bridge = 1;
884 }
885
886 void
887 rtas_configure_bridge(struct pci_dn *pdn)
888 {
889         int token = rtas_token ("ibm,configure-bridge");
890         int rc;
891
892         if (token == RTAS_UNKNOWN_SERVICE)
893                 return;
894         rc = rtas_call(token,3,1, NULL,
895                        pdn->eeh_config_addr,
896                        BUID_HI(pdn->phb->buid),
897                        BUID_LO(pdn->phb->buid));
898         if (rc) {
899                 printk (KERN_WARNING "EEH: Unable to configure device bridge (%d) for %s\n",
900                         rc, pdn->node->full_name);
901         }
902 }
903
904 /* ------------------------------------------------------------- */
905 /* The code below deals with enabling EEH for devices during  the
906  * early boot sequence.  EEH must be enabled before any PCI probing
907  * can be done.
908  */
909
910 #define EEH_ENABLE 1
911
912 struct eeh_early_enable_info {
913         unsigned int buid_hi;
914         unsigned int buid_lo;
915 };
916
917 /* Enable eeh for the given device node. */
918 static void *early_enable_eeh(struct device_node *dn, void *data)
919 {
920         struct eeh_early_enable_info *info = data;
921         int ret;
922         char *status = get_property(dn, "status", NULL);
923         u32 *class_code = (u32 *)get_property(dn, "class-code", NULL);
924         u32 *vendor_id = (u32 *)get_property(dn, "vendor-id", NULL);
925         u32 *device_id = (u32 *)get_property(dn, "device-id", NULL);
926         u32 *regs;
927         int enable;
928         struct pci_dn *pdn = PCI_DN(dn);
929
930         pdn->eeh_mode = 0;
931         pdn->eeh_check_count = 0;
932         pdn->eeh_freeze_count = 0;
933
934         if (status && strcmp(status, "ok") != 0)
935                 return NULL;    /* ignore devices with bad status */
936
937         /* Ignore bad nodes. */
938         if (!class_code || !vendor_id || !device_id)
939                 return NULL;
940
941         /* There is nothing to check on PCI to ISA bridges */
942         if (dn->type && !strcmp(dn->type, "isa")) {
943                 pdn->eeh_mode |= EEH_MODE_NOCHECK;
944                 return NULL;
945         }
946
947         /*
948          * Now decide if we are going to "Disable" EEH checking
949          * for this device.  We still run with the EEH hardware active,
950          * but we won't be checking for ff's.  This means a driver
951          * could return bad data (very bad!), an interrupt handler could
952          * hang waiting on status bits that won't change, etc.
953          * But there are a few cases like display devices that make sense.
954          */
955         enable = 1;     /* i.e. we will do checking */
956         if ((*class_code >> 16) == PCI_BASE_CLASS_DISPLAY)
957                 enable = 0;
958
959         if (!enable)
960                 pdn->eeh_mode |= EEH_MODE_NOCHECK;
961
962         /* Ok... see if this device supports EEH.  Some do, some don't,
963          * and the only way to find out is to check each and every one. */
964         regs = (u32 *)get_property(dn, "reg", NULL);
965         if (regs) {
966                 /* First register entry is addr (00BBSS00)  */
967                 /* Try to enable eeh */
968                 ret = rtas_call(ibm_set_eeh_option, 4, 1, NULL,
969                                 regs[0], info->buid_hi, info->buid_lo,
970                                 EEH_ENABLE);
971
972                 if (ret == 0) {
973                         eeh_subsystem_enabled = 1;
974                         pdn->eeh_mode |= EEH_MODE_SUPPORTED;
975                         pdn->eeh_config_addr = regs[0];
976 #ifdef DEBUG
977                         printk(KERN_DEBUG "EEH: %s: eeh enabled\n", dn->full_name);
978 #endif
979                 } else {
980
981                         /* This device doesn't support EEH, but it may have an
982                          * EEH parent, in which case we mark it as supported. */
983                         if (dn->parent && PCI_DN(dn->parent)
984                             && (PCI_DN(dn->parent)->eeh_mode & EEH_MODE_SUPPORTED)) {
985                                 /* Parent supports EEH. */
986                                 pdn->eeh_mode |= EEH_MODE_SUPPORTED;
987                                 pdn->eeh_config_addr = PCI_DN(dn->parent)->eeh_config_addr;
988                                 return NULL;
989                         }
990                 }
991         } else {
992                 printk(KERN_WARNING "EEH: %s: unable to get reg property.\n",
993                        dn->full_name);
994         }
995
996         return NULL;
997 }
998
999 /*
1000  * Initialize EEH by trying to enable it for all of the adapters in the system.
1001  * As a side effect we can determine here if eeh is supported at all.
1002  * Note that we leave EEH on so failed config cycles won't cause a machine
1003  * check.  If a user turns off EEH for a particular adapter they are really
1004  * telling Linux to ignore errors.  Some hardware (e.g. POWER5) won't
1005  * grant access to a slot if EEH isn't enabled, and so we always enable
1006  * EEH for all slots/all devices.
1007  *
1008  * The eeh-force-off option disables EEH checking globally, for all slots.
1009  * Even if force-off is set, the EEH hardware is still enabled, so that
1010  * newer systems can boot.
1011  */
1012 void __init eeh_init(void)
1013 {
1014         struct device_node *phb, *np;
1015         struct eeh_early_enable_info info;
1016
1017         spin_lock_init(&confirm_error_lock);
1018         spin_lock_init(&slot_errbuf_lock);
1019
1020         np = of_find_node_by_path("/rtas");
1021         if (np == NULL)
1022                 return;
1023
1024         ibm_set_eeh_option = rtas_token("ibm,set-eeh-option");
1025         ibm_set_slot_reset = rtas_token("ibm,set-slot-reset");
1026         ibm_read_slot_reset_state2 = rtas_token("ibm,read-slot-reset-state2");
1027         ibm_read_slot_reset_state = rtas_token("ibm,read-slot-reset-state");
1028         ibm_slot_error_detail = rtas_token("ibm,slot-error-detail");
1029
1030         if (ibm_set_eeh_option == RTAS_UNKNOWN_SERVICE)
1031                 return;
1032
1033         eeh_error_buf_size = rtas_token("rtas-error-log-max");
1034         if (eeh_error_buf_size == RTAS_UNKNOWN_SERVICE) {
1035                 eeh_error_buf_size = 1024;
1036         }
1037         if (eeh_error_buf_size > RTAS_ERROR_LOG_MAX) {
1038                 printk(KERN_WARNING "EEH: rtas-error-log-max is bigger than allocated "
1039                       "buffer ! (%d vs %d)", eeh_error_buf_size, RTAS_ERROR_LOG_MAX);
1040                 eeh_error_buf_size = RTAS_ERROR_LOG_MAX;
1041         }
1042
1043         /* Enable EEH for all adapters.  Note that eeh requires buid's */
1044         for (phb = of_find_node_by_name(NULL, "pci"); phb;
1045              phb = of_find_node_by_name(phb, "pci")) {
1046                 unsigned long buid;
1047
1048                 buid = get_phb_buid(phb);
1049                 if (buid == 0 || PCI_DN(phb) == NULL)
1050                         continue;
1051
1052                 info.buid_lo = BUID_LO(buid);
1053                 info.buid_hi = BUID_HI(buid);
1054                 traverse_pci_devices(phb, early_enable_eeh, &info);
1055         }
1056
1057         if (eeh_subsystem_enabled)
1058                 printk(KERN_INFO "EEH: PCI Enhanced I/O Error Handling Enabled\n");
1059         else
1060                 printk(KERN_WARNING "EEH: No capable adapters found\n");
1061 }
1062
1063 /**
1064  * eeh_add_device_early - enable EEH for the indicated device_node
1065  * @dn: device node for which to set up EEH
1066  *
1067  * This routine must be used to perform EEH initialization for PCI
1068  * devices that were added after system boot (e.g. hotplug, dlpar).
1069  * This routine must be called before any i/o is performed to the
1070  * adapter (inluding any config-space i/o).
1071  * Whether this actually enables EEH or not for this device depends
1072  * on the CEC architecture, type of the device, on earlier boot
1073  * command-line arguments & etc.
1074  */
1075 void eeh_add_device_early(struct device_node *dn)
1076 {
1077         struct pci_controller *phb;
1078         struct eeh_early_enable_info info;
1079
1080         if (!dn || !PCI_DN(dn))
1081                 return;
1082         phb = PCI_DN(dn)->phb;
1083         if (NULL == phb || 0 == phb->buid) {
1084                 printk(KERN_WARNING "EEH: Expected buid but found none for %s\n",
1085                        dn->full_name);
1086                 dump_stack();
1087                 return;
1088         }
1089
1090         info.buid_hi = BUID_HI(phb->buid);
1091         info.buid_lo = BUID_LO(phb->buid);
1092         early_enable_eeh(dn, &info);
1093 }
1094 EXPORT_SYMBOL_GPL(eeh_add_device_early);
1095
1096 /**
1097  * eeh_add_device_late - perform EEH initialization for the indicated pci device
1098  * @dev: pci device for which to set up EEH
1099  *
1100  * This routine must be used to complete EEH initialization for PCI
1101  * devices that were added after system boot (e.g. hotplug, dlpar).
1102  */
1103 void eeh_add_device_late(struct pci_dev *dev)
1104 {
1105         struct device_node *dn;
1106         struct pci_dn *pdn;
1107
1108         if (!dev || !eeh_subsystem_enabled)
1109                 return;
1110
1111 #ifdef DEBUG
1112         printk(KERN_DEBUG "EEH: adding device %s\n", pci_name(dev));
1113 #endif
1114
1115         pci_dev_get (dev);
1116         dn = pci_device_to_OF_node(dev);
1117         pdn = PCI_DN(dn);
1118         pdn->pcidev = dev;
1119
1120         pci_addr_cache_insert_device (dev);
1121         eeh_save_bars(dev, pdn);
1122 }
1123 EXPORT_SYMBOL_GPL(eeh_add_device_late);
1124
1125 /**
1126  * eeh_remove_device - undo EEH setup for the indicated pci device
1127  * @dev: pci device to be removed
1128  *
1129  * This routine should be when a device is removed from a running
1130  * system (e.g. by hotplug or dlpar).
1131  */
1132 void eeh_remove_device(struct pci_dev *dev)
1133 {
1134         struct device_node *dn;
1135         if (!dev || !eeh_subsystem_enabled)
1136                 return;
1137
1138         /* Unregister the device with the EEH/PCI address search system */
1139 #ifdef DEBUG
1140         printk(KERN_DEBUG "EEH: remove device %s\n", pci_name(dev));
1141 #endif
1142         pci_addr_cache_remove_device(dev);
1143
1144         dn = pci_device_to_OF_node(dev);
1145         PCI_DN(dn)->pcidev = NULL;
1146         pci_dev_put (dev);
1147 }
1148 EXPORT_SYMBOL_GPL(eeh_remove_device);
1149
1150 static int proc_eeh_show(struct seq_file *m, void *v)
1151 {
1152         unsigned int cpu;
1153         unsigned long ffs = 0, positives = 0, failures = 0;
1154         unsigned long resets = 0;
1155         unsigned long no_dev = 0, no_dn = 0, no_cfg = 0, no_check = 0;
1156
1157         for_each_cpu(cpu) {
1158                 ffs += per_cpu(total_mmio_ffs, cpu);
1159                 positives += per_cpu(false_positives, cpu);
1160                 failures += per_cpu(ignored_failures, cpu);
1161                 resets += per_cpu(slot_resets, cpu);
1162                 no_dev += per_cpu(no_device, cpu);
1163                 no_dn += per_cpu(no_dn, cpu);
1164                 no_cfg += per_cpu(no_cfg_addr, cpu);
1165                 no_check += per_cpu(ignored_check, cpu);
1166         }
1167
1168         if (0 == eeh_subsystem_enabled) {
1169                 seq_printf(m, "EEH Subsystem is globally disabled\n");
1170                 seq_printf(m, "eeh_total_mmio_ffs=%ld\n", ffs);
1171         } else {
1172                 seq_printf(m, "EEH Subsystem is enabled\n");
1173                 seq_printf(m,
1174                                 "no device=%ld\n"
1175                                 "no device node=%ld\n"
1176                                 "no config address=%ld\n"
1177                                 "check not wanted=%ld\n"
1178                                 "eeh_total_mmio_ffs=%ld\n"
1179                                 "eeh_false_positives=%ld\n"
1180                                 "eeh_ignored_failures=%ld\n"
1181                                 "eeh_slot_resets=%ld\n",
1182                                 no_dev, no_dn, no_cfg, no_check,
1183                                 ffs, positives, failures, resets);
1184         }
1185
1186         return 0;
1187 }
1188
1189 static int proc_eeh_open(struct inode *inode, struct file *file)
1190 {
1191         return single_open(file, proc_eeh_show, NULL);
1192 }
1193
1194 static struct file_operations proc_eeh_operations = {
1195         .open      = proc_eeh_open,
1196         .read      = seq_read,
1197         .llseek    = seq_lseek,
1198         .release   = single_release,
1199 };
1200
1201 static int __init eeh_init_proc(void)
1202 {
1203         struct proc_dir_entry *e;
1204
1205         if (platform_is_pseries()) {
1206                 e = create_proc_entry("ppc64/eeh", 0, NULL);
1207                 if (e)
1208                         e->proc_fops = &proc_eeh_operations;
1209         }
1210
1211         return 0;
1212 }
1213 __initcall(eeh_init_proc);