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