eeh.c 35.9 KB
Newer Older
L
Linus Torvalds 已提交
1 2
/*
 * eeh.c
3 4 5
 * Copyright IBM Corporation 2001, 2005, 2006
 * Copyright Dave Engebretsen & Todd Inglett 2001
 * Copyright Linas Vepstas 2005, 2006
L
Linas Vepstas 已提交
6
 *
L
Linus Torvalds 已提交
7 8 9 10
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
L
Linas Vepstas 已提交
11
 *
L
Linus Torvalds 已提交
12 13 14 15
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
L
Linas Vepstas 已提交
16
 *
L
Linus Torvalds 已提交
17 18 19
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * 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>
L
Linus Torvalds 已提交
22 23
 */

24
#include <linux/delay.h>
L
Linus Torvalds 已提交
25 26 27 28 29 30 31
#include <linux/init.h>
#include <linux/list.h>
#include <linux/pci.h>
#include <linux/proc_fs.h>
#include <linux/rbtree.h>
#include <linux/seq_file.h>
#include <linux/spinlock.h>
32 33
#include <linux/of.h>

L
Linas Vepstas 已提交
34
#include <asm/atomic.h>
L
Linus Torvalds 已提交
35
#include <asm/eeh.h>
36
#include <asm/eeh_event.h>
L
Linus Torvalds 已提交
37 38
#include <asm/io.h>
#include <asm/machdep.h>
39
#include <asm/ppc-pci.h>
L
Linus Torvalds 已提交
40 41 42 43 44 45 46 47 48 49 50 51 52 53 54
#include <asm/rtas.h>


/** Overview:
 *  EEH, or "Extended Error Handling" is a PCI bridge technology for
 *  dealing with PCI bus errors that can't be dealt with within the
 *  usual PCI framework, except by check-stopping the CPU.  Systems
 *  that are designed for high-availability/reliability cannot afford
 *  to crash due to a "mere" PCI error, thus the need for EEH.
 *  An EEH-capable bridge operates by converting a detected error
 *  into a "slot freeze", taking the PCI adapter off-line, making
 *  the slot behave, from the OS'es point of view, as if the slot
 *  were "empty": all reads return 0xff's and all writes are silently
 *  ignored.  EEH slot isolation events can be triggered by parity
 *  errors on the address or data busses (e.g. during posted writes),
L
Linas Vepstas 已提交
55 56
 *  which in turn might be caused by low voltage on the bus, dust,
 *  vibration, humidity, radioactivity or plain-old failed hardware.
L
Linus Torvalds 已提交
57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76
 *
 *  Note, however, that one of the leading causes of EEH slot
 *  freeze events are buggy device drivers, buggy device microcode,
 *  or buggy device hardware.  This is because any attempt by the
 *  device to bus-master data to a memory address that is not
 *  assigned to the device will trigger a slot freeze.   (The idea
 *  is to prevent devices-gone-wild from corrupting system memory).
 *  Buggy hardware/drivers will have a miserable time co-existing
 *  with EEH.
 *
 *  Ideally, a PCI device driver, when suspecting that an isolation
 *  event has occured (e.g. by reading 0xff's), will then ask EEH
 *  whether this is the case, and then take appropriate steps to
 *  reset the PCI slot, the PCI device, and then resume operations.
 *  However, until that day,  the checking is done here, with the
 *  eeh_check_failure() routine embedded in the MMIO macros.  If
 *  the slot is found to be isolated, an "EEH Event" is synthesized
 *  and sent out for processing.
 */

77
/* If a device driver keeps reading an MMIO register in an interrupt
L
Linus Torvalds 已提交
78 79 80 81
 * handler after a slot isolation event has occurred, we assume it
 * is broken and panic.  This sets the threshold for how many read
 * attempts we allow before panicking.
 */
82
#define EEH_MAX_FAILS	2100000
L
Linus Torvalds 已提交
83

84
/* Time to wait for a PCI slot to report status, in milliseconds */
85 86
#define PCI_BUS_RESET_WAIT_MSEC (60*1000)

L
Linus Torvalds 已提交
87 88 89 90 91 92
/* RTAS tokens */
static int ibm_set_eeh_option;
static int ibm_set_slot_reset;
static int ibm_read_slot_reset_state;
static int ibm_read_slot_reset_state2;
static int ibm_slot_error_detail;
93
static int ibm_get_config_addr_info;
94
static int ibm_get_config_addr_info2;
95
static int ibm_configure_bridge;
L
Linus Torvalds 已提交
96

97 98
int eeh_subsystem_enabled;
EXPORT_SYMBOL(eeh_subsystem_enabled);
L
Linus Torvalds 已提交
99

100 101 102
/* Lock to avoid races due to multiple reports of an error */
static DEFINE_SPINLOCK(confirm_error_lock);

103 104 105 106
/* Buffer for reporting slot-error-detail rtas calls. Its here
 * in BSS, and not dynamically alloced, so that it ends up in
 * RMO where RTAS can access it.
 */
L
Linus Torvalds 已提交
107 108 109 110
static unsigned char slot_errbuf[RTAS_ERROR_LOG_MAX];
static DEFINE_SPINLOCK(slot_errbuf_lock);
static int eeh_error_buf_size;

111 112 113 114
/* Buffer for reporting pci register dumps. Its here in BSS, and
 * not dynamically alloced, so that it ends up in RMO where RTAS
 * can access it.
 */
115 116 117
#define EEH_PCI_REGS_LOG_LEN 4096
static unsigned char pci_regs_buf[EEH_PCI_REGS_LOG_LEN];

L
Linus Torvalds 已提交
118
/* System monitoring statistics */
119 120 121 122 123 124 125
static unsigned long no_device;
static unsigned long no_dn;
static unsigned long no_cfg_addr;
static unsigned long ignored_check;
static unsigned long total_mmio_ffs;
static unsigned long false_positives;
static unsigned long slot_resets;
L
Linus Torvalds 已提交
126

127 128
#define IS_BRIDGE(class_code) (((class_code)<<16) == PCI_BASE_CLASS_BRIDGE)

L
Linus Torvalds 已提交
129
/* --------------------------------------------------------------- */
130
/* Below lies the EEH event infrastructure */
L
Linus Torvalds 已提交
131

132 133
static void rtas_slot_error_detail(struct pci_dn *pdn, int severity,
                                   char *driver_log, size_t loglen)
134
{
135
	int config_addr;
136 137 138 139 140 141 142
	unsigned long flags;
	int rc;

	/* Log the error with the rtas logger */
	spin_lock_irqsave(&slot_errbuf_lock, flags);
	memset(slot_errbuf, 0, eeh_error_buf_size);

143 144 145 146 147
	/* Use PE configuration address, if present */
	config_addr = pdn->eeh_config_addr;
	if (pdn->eeh_pe_config_addr)
		config_addr = pdn->eeh_pe_config_addr;

148
	rc = rtas_call(ibm_slot_error_detail,
149
	               8, 1, NULL, config_addr,
150
	               BUID_HI(pdn->phb->buid),
151 152
	               BUID_LO(pdn->phb->buid),
	               virt_to_phys(driver_log), loglen,
153 154 155 156 157 158 159 160 161
	               virt_to_phys(slot_errbuf),
	               eeh_error_buf_size,
	               severity);

	if (rc == 0)
		log_error(slot_errbuf, ERR_TYPE_RTAS_LOG, 0);
	spin_unlock_irqrestore(&slot_errbuf_lock, flags);
}

162 163 164 165 166 167 168 169 170 171 172
/**
 * gather_pci_data - copy assorted PCI config space registers to buff
 * @pdn: device to report data for
 * @buf: point to buffer in which to log
 * @len: amount of room in buffer
 *
 * This routine captures assorted PCI configuration space data,
 * and puts them into a buffer for RTAS error logging.
 */
static size_t gather_pci_data(struct pci_dn *pdn, char * buf, size_t len)
{
173
	struct pci_dev *dev = pdn->pcidev;
174
	u32 cfg;
175
	int cap, i;
176 177
	int n = 0;

178 179 180
	n += scnprintf(buf+n, len-n, "%s\n", pdn->node->full_name);
	printk(KERN_WARNING "EEH: of node=%s\n", pdn->node->full_name);

181
	rtas_read_config(pdn, PCI_VENDOR_ID, 4, &cfg);
182 183 184
	n += scnprintf(buf+n, len-n, "dev/vend:%08x\n", cfg);
	printk(KERN_WARNING "EEH: PCI device/vendor: %08x\n", cfg);

185 186
	rtas_read_config(pdn, PCI_COMMAND, 4, &cfg);
	n += scnprintf(buf+n, len-n, "cmd/stat:%x\n", cfg);
187 188
	printk(KERN_WARNING "EEH: PCI cmd/status register: %08x\n", cfg);

189 190 191 192 193
	if (!dev) {
		printk(KERN_WARNING "EEH: no PCI device for this of node\n");
		return n;
	}

194 195 196 197 198 199 200 201 202 203 204
	/* Gather bridge-specific registers */
	if (dev->class >> 16 == PCI_BASE_CLASS_BRIDGE) {
		rtas_read_config(pdn, PCI_SEC_STATUS, 2, &cfg);
		n += scnprintf(buf+n, len-n, "sec stat:%x\n", cfg);
		printk(KERN_WARNING "EEH: Bridge secondary status: %04x\n", cfg);

		rtas_read_config(pdn, PCI_BRIDGE_CONTROL, 2, &cfg);
		n += scnprintf(buf+n, len-n, "brdg ctl:%x\n", cfg);
		printk(KERN_WARNING "EEH: Bridge control: %04x\n", cfg);
	}

205
	/* Dump out the PCI-X command and status regs */
206
	cap = pci_find_capability(dev, PCI_CAP_ID_PCIX);
207 208 209 210 211 212 213 214 215 216 217
	if (cap) {
		rtas_read_config(pdn, cap, 4, &cfg);
		n += scnprintf(buf+n, len-n, "pcix-cmd:%x\n", cfg);
		printk(KERN_WARNING "EEH: PCI-X cmd: %08x\n", cfg);

		rtas_read_config(pdn, cap+4, 4, &cfg);
		n += scnprintf(buf+n, len-n, "pcix-stat:%x\n", cfg);
		printk(KERN_WARNING "EEH: PCI-X status: %08x\n", cfg);
	}

	/* If PCI-E capable, dump PCI-E cap 10, and the AER */
218
	cap = pci_find_capability(dev, PCI_CAP_ID_EXP);
219 220 221 222 223 224 225 226 227 228 229
	if (cap) {
		n += scnprintf(buf+n, len-n, "pci-e cap10:\n");
		printk(KERN_WARNING
		       "EEH: PCI-E capabilities and status follow:\n");

		for (i=0; i<=8; i++) {
			rtas_read_config(pdn, cap+4*i, 4, &cfg);
			n += scnprintf(buf+n, len-n, "%02x:%x\n", 4*i, cfg);
			printk(KERN_WARNING "EEH: PCI-E %02x: %08x\n", i, cfg);
		}

230
		cap = pci_find_ext_capability(dev, PCI_EXT_CAP_ID_ERR);
231 232 233 234 235 236 237 238 239 240 241 242
		if (cap) {
			n += scnprintf(buf+n, len-n, "pci-e AER:\n");
			printk(KERN_WARNING
			       "EEH: PCI-E AER capability register set follows:\n");

			for (i=0; i<14; i++) {
				rtas_read_config(pdn, cap+4*i, 4, &cfg);
				n += scnprintf(buf+n, len-n, "%02x:%x\n", 4*i, cfg);
				printk(KERN_WARNING "EEH: PCI-E AER %02x: %08x\n", i, cfg);
			}
		}
	}
243 244 245

	/* Gather status on devices under the bridge */
	if (dev->class >> 16 == PCI_BASE_CLASS_BRIDGE) {
246 247 248
		struct device_node *dn;

		for_each_child_of_node(pdn->node, dn) {
249 250 251 252 253 254
			pdn = PCI_DN(dn);
			if (pdn)
				n += gather_pci_data(pdn, buf+n, len-n);
		}
	}

255 256 257 258 259 260
	return n;
}

void eeh_slot_error_detail(struct pci_dn *pdn, int severity)
{
	size_t loglen = 0;
261
	pci_regs_buf[0] = 0;
262 263 264 265 266 267 268

	rtas_pci_enable(pdn, EEH_THAW_MMIO);
	loglen = gather_pci_data(pdn, pci_regs_buf, EEH_PCI_REGS_LOG_LEN);

	rtas_slot_error_detail(pdn, severity, pci_regs_buf, loglen);
}

L
Linus Torvalds 已提交
269 270 271 272 273
/**
 * read_slot_reset_state - Read the reset state of a device node's slot
 * @dn: device node to read
 * @rets: array to return results in
 */
L
Linas Vepstas 已提交
274
static int read_slot_reset_state(struct pci_dn *pdn, int rets[])
L
Linus Torvalds 已提交
275 276
{
	int token, outputs;
277
	int config_addr;
L
Linus Torvalds 已提交
278 279 280 281 282 283

	if (ibm_read_slot_reset_state2 != RTAS_UNKNOWN_SERVICE) {
		token = ibm_read_slot_reset_state2;
		outputs = 4;
	} else {
		token = ibm_read_slot_reset_state;
L
Linas Vepstas 已提交
284
		rets[2] = 0; /* fake PE Unavailable info */
L
Linus Torvalds 已提交
285 286 287
		outputs = 3;
	}

288 289 290 291 292 293
	/* Use PE configuration address, if present */
	config_addr = pdn->eeh_config_addr;
	if (pdn->eeh_pe_config_addr)
		config_addr = pdn->eeh_pe_config_addr;

	return rtas_call(token, 3, outputs, rets, config_addr,
294
			 BUID_HI(pdn->phb->buid), BUID_LO(pdn->phb->buid));
L
Linus Torvalds 已提交
295 296
}

297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325
/**
 * eeh_wait_for_slot_status - returns error status of slot
 * @pdn pci device node
 * @max_wait_msecs maximum number to millisecs to wait
 *
 * Return negative value if a permanent error, else return
 * Partition Endpoint (PE) status value.
 *
 * If @max_wait_msecs is positive, then this routine will
 * sleep until a valid status can be obtained, or until
 * the max allowed wait time is exceeded, in which case
 * a -2 is returned.
 */
int
eeh_wait_for_slot_status(struct pci_dn *pdn, int max_wait_msecs)
{
	int rc;
	int rets[3];
	int mwait;

	while (1) {
		rc = read_slot_reset_state(pdn, rets);
		if (rc) return rc;
		if (rets[1] == 0) return -1;  /* EEH is not supported */

		if (rets[0] != 5) return rets[0]; /* return actual status */

		if (rets[2] == 0) return -1; /* permanently unavailable */

326
		if (max_wait_msecs <= 0) break;
327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345

		mwait = rets[2];
		if (mwait <= 0) {
			printk (KERN_WARNING
			        "EEH: Firmware returned bad wait value=%d\n", mwait);
			mwait = 1000;
		} else if (mwait > 300*1000) {
			printk (KERN_WARNING
			        "EEH: Firmware is taking too long, time=%d\n", mwait);
			mwait = 300*1000;
		}
		max_wait_msecs -= mwait;
		msleep (mwait);
	}

	printk(KERN_WARNING "EEH: Timed out waiting for slot status\n");
	return -2;
}

L
Linus Torvalds 已提交
346 347
/**
 * eeh_token_to_phys - convert EEH address token to phys address
L
Linas Vepstas 已提交
348
 * @token i/o token, should be address in the form 0xA....
L
Linus Torvalds 已提交
349 350 351 352 353 354
 */
static inline unsigned long eeh_token_to_phys(unsigned long token)
{
	pte_t *ptep;
	unsigned long pa;

D
David Gibson 已提交
355
	ptep = find_linux_pte(init_mm.pgd, token);
L
Linus Torvalds 已提交
356 357 358 359 360 361 362
	if (!ptep)
		return token;
	pa = pte_pfn(*ptep) << PAGE_SHIFT;

	return pa | (token & (PAGE_SIZE-1));
}

363 364 365
/** 
 * Return the "partitionable endpoint" (pe) under which this device lies
 */
366
struct device_node * find_device_pe(struct device_node *dn)
367 368 369 370 371 372 373 374
{
	while ((dn->parent) && PCI_DN(dn->parent) &&
	      (PCI_DN(dn->parent)->eeh_mode & EEH_MODE_SUPPORTED)) {
		dn = dn->parent;
	}
	return dn;
}

375
/** Mark all devices that are children of this device as failed.
376 377 378 379 380 381 382
 *  Mark the device driver too, so that it can see the failure
 *  immediately; this is critical, since some drivers poll
 *  status registers in interrupts ... If a driver is polling,
 *  and the slot is frozen, then the driver can deadlock in
 *  an interrupt context, which is bad.
 */

383
static void __eeh_mark_slot(struct device_node *parent, int mode_flag)
384
{
385 386 387
	struct device_node *dn;

	for_each_child_of_node(parent, dn) {
L
Linas Vepstas 已提交
388
		if (PCI_DN(dn)) {
389 390
			/* Mark the pci device driver too */
			struct pci_dev *dev = PCI_DN(dn)->pcidev;
391 392 393

			PCI_DN(dn)->eeh_mode |= mode_flag;

394 395 396
			if (dev && dev->driver)
				dev->error_state = pci_channel_io_frozen;

397
			__eeh_mark_slot(dn, mode_flag);
L
Linas Vepstas 已提交
398
		}
399 400 401
	}
}

L
Linas Vepstas 已提交
402 403
void eeh_mark_slot (struct device_node *dn, int mode_flag)
{
404
	struct pci_dev *dev;
L
Linas Vepstas 已提交
405
	dn = find_device_pe (dn);
406 407

	/* Back up one, since config addrs might be shared */
408
	if (!pcibios_find_pci_bus(dn) && PCI_DN(dn->parent))
409 410
		dn = dn->parent;

L
Linas Vepstas 已提交
411
	PCI_DN(dn)->eeh_mode |= mode_flag;
412 413 414 415 416 417

	/* Mark the pci device too */
	dev = PCI_DN(dn)->pcidev;
	if (dev)
		dev->error_state = pci_channel_io_frozen;

418
	__eeh_mark_slot(dn, mode_flag);
L
Linas Vepstas 已提交
419 420
}

421
static void __eeh_clear_slot(struct device_node *parent, int mode_flag)
422
{
423 424 425
	struct device_node *dn;

	for_each_child_of_node(parent, dn) {
L
Linas Vepstas 已提交
426 427 428
		if (PCI_DN(dn)) {
			PCI_DN(dn)->eeh_mode &= ~mode_flag;
			PCI_DN(dn)->eeh_check_count = 0;
429
			__eeh_clear_slot(dn, mode_flag);
L
Linas Vepstas 已提交
430
		}
431 432 433
	}
}

L
Linas Vepstas 已提交
434
void eeh_clear_slot (struct device_node *dn, int mode_flag)
435 436 437
{
	unsigned long flags;
	spin_lock_irqsave(&confirm_error_lock, flags);
438
	
L
Linas Vepstas 已提交
439
	dn = find_device_pe (dn);
440 441
	
	/* Back up one, since config addrs might be shared */
442
	if (!pcibios_find_pci_bus(dn) && PCI_DN(dn->parent))
443 444
		dn = dn->parent;

L
Linas Vepstas 已提交
445 446
	PCI_DN(dn)->eeh_mode &= ~mode_flag;
	PCI_DN(dn)->eeh_check_count = 0;
447
	__eeh_clear_slot(dn, mode_flag);
448 449 450
	spin_unlock_irqrestore(&confirm_error_lock, flags);
}

L
Linus Torvalds 已提交
451 452 453 454 455 456 457 458 459 460 461
/**
 * eeh_dn_check_failure - check if all 1's data is due to EEH slot freeze
 * @dn device node
 * @dev pci device, if known
 *
 * Check for an EEH failure for the given device node.  Call this
 * routine if the result of a read was all 0xff's and you want to
 * find out if this is due to an EEH slot freeze.  This routine
 * will query firmware for the EEH status.
 *
 * Returns 0 if there has not been an EEH error; otherwise returns
L
Linas Vepstas 已提交
462
 * a non-zero value and queues up a slot isolation event notification.
L
Linus Torvalds 已提交
463 464 465 466 467 468 469 470
 *
 * It is safe to call this routine in an interrupt context.
 */
int eeh_dn_check_failure(struct device_node *dn, struct pci_dev *dev)
{
	int ret;
	int rets[3];
	unsigned long flags;
471
	struct pci_dn *pdn;
472
	int rc = 0;
L
Linus Torvalds 已提交
473

474
	total_mmio_ffs++;
L
Linus Torvalds 已提交
475 476 477 478

	if (!eeh_subsystem_enabled)
		return 0;

479
	if (!dn) {
480
		no_dn++;
L
Linus Torvalds 已提交
481
		return 0;
482
	}
483
	dn = find_device_pe(dn);
L
Linas Vepstas 已提交
484
	pdn = PCI_DN(dn);
L
Linus Torvalds 已提交
485 486

	/* Access to IO BARs might get this far and still not want checking. */
487
	if (!(pdn->eeh_mode & EEH_MODE_SUPPORTED) ||
488
	    pdn->eeh_mode & EEH_MODE_NOCHECK) {
489
		ignored_check++;
490
#ifdef DEBUG
491 492
		printk ("EEH:ignored check (%x) for %s %s\n", 
		        pdn->eeh_mode, pci_name (dev), dn->full_name);
493
#endif
L
Linus Torvalds 已提交
494 495 496
		return 0;
	}

497
	if (!pdn->eeh_config_addr && !pdn->eeh_pe_config_addr) {
498
		no_cfg_addr++;
L
Linus Torvalds 已提交
499 500 501
		return 0;
	}

502 503 504 505 506
	/* If we already have a pending isolation event for this
	 * slot, we know it's bad already, we don't need to check.
	 * Do this checking under a lock; as multiple PCI devices
	 * in one slot might report errors simultaneously, and we
	 * only want one error recovery routine running.
L
Linus Torvalds 已提交
507
	 */
508 509
	spin_lock_irqsave(&confirm_error_lock, flags);
	rc = 1;
510
	if (pdn->eeh_mode & EEH_MODE_ISOLATED) {
511 512 513 514 515
		pdn->eeh_check_count ++;
		if (pdn->eeh_check_count >= EEH_MAX_FAILS) {
			printk (KERN_ERR "EEH: Device driver ignored %d bad reads, panicing\n",
			        pdn->eeh_check_count);
			dump_stack();
L
Linas Vepstas 已提交
516
			msleep(5000);
517
			
L
Linus Torvalds 已提交
518
			/* re-read the slot reset state */
L
Linas Vepstas 已提交
519
			if (read_slot_reset_state(pdn, rets) != 0)
L
Linus Torvalds 已提交
520
				rets[0] = -1;	/* reset state unknown */
521 522 523

			/* If we are here, then we hit an infinite loop. Stop. */
			panic("EEH: MMIO halt (%d) on device:%s\n", rets[0], pci_name(dev));
L
Linus Torvalds 已提交
524
		}
525
		goto dn_unlock;
L
Linus Torvalds 已提交
526 527 528 529 530 531 532 533 534
	}

	/*
	 * Now test for an EEH failure.  This is VERY expensive.
	 * Note that the eeh_config_addr may be a parent device
	 * in the case of a device behind a bridge, or it may be
	 * function zero of a multi-function device.
	 * In any case they must share a common PHB.
	 */
L
Linas Vepstas 已提交
535
	ret = read_slot_reset_state(pdn, rets);
536 537 538 539 540

	/* If the call to firmware failed, punt */
	if (ret != 0) {
		printk(KERN_WARNING "EEH: read_slot_reset_state() failed; rc=%d dn=%s\n",
		       ret, dn->full_name);
541
		false_positives++;
542
		pdn->eeh_false_positives ++;
543 544
		rc = 0;
		goto dn_unlock;
545 546
	}

547 548
	/* Note that config-io to empty slots may fail;
	 * they are empty when they don't have children. */
549
	if ((rets[0] == 5) && (rets[2] == 0) && (dn->child == NULL)) {
550
		false_positives++;
551
		pdn->eeh_false_positives ++;
552 553 554 555
		rc = 0;
		goto dn_unlock;
	}

556 557 558 559
	/* If EEH is not supported on this device, punt. */
	if (rets[1] != 1) {
		printk(KERN_WARNING "EEH: event on unsupported device, rc=%d dn=%s\n",
		       ret, dn->full_name);
560
		false_positives++;
561
		pdn->eeh_false_positives ++;
562 563
		rc = 0;
		goto dn_unlock;
564 565 566
	}

	/* If not the kind of error we know about, punt. */
567
	if (rets[0] != 1 && rets[0] != 2 && rets[0] != 4 && rets[0] != 5) {
568
		false_positives++;
569
		pdn->eeh_false_positives ++;
570 571
		rc = 0;
		goto dn_unlock;
572 573
	}

574
	slot_resets++;
575 576 577 578
 
	/* Avoid repeated reports of this failure, including problems
	 * with other functions on this device, and functions under
	 * bridges. */
L
Linas Vepstas 已提交
579
	eeh_mark_slot (dn, EEH_MODE_ISOLATED);
580
	spin_unlock_irqrestore(&confirm_error_lock, flags);
L
Linus Torvalds 已提交
581

L
Linas Vepstas 已提交
582
	eeh_send_failure_event (dn, dev);
583

L
Linus Torvalds 已提交
584 585 586
	/* Most EEH events are due to device driver bugs.  Having
	 * a stack trace will help the device-driver authors figure
	 * out what happened.  So print that out. */
587
	dump_stack();
588 589 590 591 592
	return 1;

dn_unlock:
	spin_unlock_irqrestore(&confirm_error_lock, flags);
	return rc;
L
Linus Torvalds 已提交
593 594
}

595
EXPORT_SYMBOL_GPL(eeh_dn_check_failure);
L
Linus Torvalds 已提交
596 597 598 599 600 601 602 603 604 605 606 607 608 609 610 611 612 613 614 615 616 617

/**
 * eeh_check_failure - check if all 1's data is due to EEH slot freeze
 * @token i/o token, should be address in the form 0xA....
 * @val value, should be all 1's (XXX why do we need this arg??)
 *
 * Check for an EEH failure at the given token address.  Call this
 * routine if the result of a read was all 0xff's and you want to
 * find out if this is due to an EEH slot freeze event.  This routine
 * will query firmware for the EEH status.
 *
 * Note this routine is safe to call in an interrupt context.
 */
unsigned long eeh_check_failure(const volatile void __iomem *token, unsigned long val)
{
	unsigned long addr;
	struct pci_dev *dev;
	struct device_node *dn;

	/* Finding the phys addr + pci device; this is pretty quick. */
	addr = eeh_token_to_phys((unsigned long __force) token);
	dev = pci_get_device_by_addr(addr);
618
	if (!dev) {
619
		no_device++;
L
Linus Torvalds 已提交
620
		return val;
621
	}
L
Linus Torvalds 已提交
622 623 624 625 626 627 628 629 630 631

	dn = pci_device_to_OF_node(dev);
	eeh_dn_check_failure (dn, dev);

	pci_dev_put(dev);
	return val;
}

EXPORT_SYMBOL(eeh_check_failure);

632 633 634
/* ------------------------------------------------------------- */
/* The code below deals with error recovery */

635 636 637 638 639 640 641 642 643 644 645 646 647 648 649 650 651 652 653 654 655 656 657
/**
 * rtas_pci_enable - enable MMIO or DMA transfers for this slot
 * @pdn pci device node
 */

int
rtas_pci_enable(struct pci_dn *pdn, int function)
{
	int config_addr;
	int rc;

	/* Use PE configuration address, if present */
	config_addr = pdn->eeh_config_addr;
	if (pdn->eeh_pe_config_addr)
		config_addr = pdn->eeh_pe_config_addr;

	rc = rtas_call(ibm_set_eeh_option, 4, 1, NULL,
	               config_addr,
	               BUID_HI(pdn->phb->buid),
	               BUID_LO(pdn->phb->buid),
		            function);

	if (rc)
658
		printk(KERN_WARNING "EEH: Unexpected state change %d, err=%d dn=%s\n",
659 660
		        function, rc, pdn->node->full_name);

661 662 663 664
	rc = eeh_wait_for_slot_status (pdn, PCI_BUS_RESET_WAIT_MSEC);
	if ((rc == 4) && (function == EEH_THAW_MMIO))
		return 0;

665 666 667
	return rc;
}

668 669 670 671
/**
 * rtas_pci_slot_reset - raises/lowers the pci #RST line
 * @pdn pci device node
 * @state: 1/0 to raise/lower the #RST
672 673 674 675 676 677 678 679 680 681 682
 *
 * Clear the EEH-frozen condition on a slot.  This routine
 * asserts the PCI #RST line if the 'state' argument is '1',
 * and drops the #RST line if 'state is '0'.  This routine is
 * safe to call in an interrupt context.
 *
 */

static void
rtas_pci_slot_reset(struct pci_dn *pdn, int state)
{
683
	int config_addr;
684 685 686 687 688 689 690 691 692 693
	int rc;

	BUG_ON (pdn==NULL); 

	if (!pdn->phb) {
		printk (KERN_WARNING "EEH: in slot reset, device node %s has no phb\n",
		        pdn->node->full_name);
		return;
	}

694 695 696 697 698
	/* Use PE configuration address, if present */
	config_addr = pdn->eeh_config_addr;
	if (pdn->eeh_pe_config_addr)
		config_addr = pdn->eeh_pe_config_addr;

699
	rc = rtas_call(ibm_set_slot_reset,4,1, NULL,
700
	               config_addr,
701 702 703
	               BUID_HI(pdn->phb->buid),
	               BUID_LO(pdn->phb->buid),
	               state);
704 705 706
	if (rc)
		printk (KERN_WARNING "EEH: Unable to reset the failed slot,"
		        " (%d) #RST=%d dn=%s\n",
707 708 709
		        rc, state, pdn->node->full_name);
}

710 711 712 713 714 715 716 717 718 719 720 721 722 723 724 725 726 727 728 729 730 731 732 733 734 735 736 737 738 739
/**
 * pcibios_set_pcie_slot_reset - Set PCI-E reset state
 * @dev:	pci device struct
 * @state:	reset state to enter
 *
 * Return value:
 * 	0 if success
 **/
int pcibios_set_pcie_reset_state(struct pci_dev *dev, enum pcie_reset_state state)
{
	struct device_node *dn = pci_device_to_OF_node(dev);
	struct pci_dn *pdn = PCI_DN(dn);

	switch (state) {
	case pcie_deassert_reset:
		rtas_pci_slot_reset(pdn, 0);
		break;
	case pcie_hot_reset:
		rtas_pci_slot_reset(pdn, 1);
		break;
	case pcie_warm_reset:
		rtas_pci_slot_reset(pdn, 3);
		break;
	default:
		return -EINVAL;
	};

	return 0;
}

740 741 742
/**
 * rtas_set_slot_reset -- assert the pci #RST line for 1/4 second
 * @pdn: pci device node to be reset.
743 744
 *
 *  Return 0 if success, else a non-zero value.
745 746
 */

747
static void __rtas_set_slot_reset(struct pci_dn *pdn)
748 749 750 751 752 753 754 755
{
	rtas_pci_slot_reset (pdn, 1);

	/* The PCI bus requires that the reset be held high for at least
	 * a 100 milliseconds. We wait a bit longer 'just in case'.  */

#define PCI_BUS_RST_HOLD_TIME_MSEC 250
	msleep (PCI_BUS_RST_HOLD_TIME_MSEC);
L
Linas Vepstas 已提交
756 757 758 759 760 761
	
	/* We might get hit with another EEH freeze as soon as the 
	 * pci slot reset line is dropped. Make sure we don't miss
	 * these, and clear the flag now. */
	eeh_clear_slot (pdn->node, EEH_MODE_ISOLATED);

762 763 764 765 766 767 768
	rtas_pci_slot_reset (pdn, 0);

	/* After a PCI slot has been reset, the PCI Express spec requires
	 * a 1.5 second idle time for the bus to stabilize, before starting
	 * up traffic. */
#define PCI_BUS_SETTLE_TIME_MSEC 1800
	msleep (PCI_BUS_SETTLE_TIME_MSEC);
769 770 771 772 773 774
}

int rtas_set_slot_reset(struct pci_dn *pdn)
{
	int i, rc;

775 776 777
	/* Take three shots at resetting the bus */
	for (i=0; i<3; i++) {
		__rtas_set_slot_reset(pdn);
778

779
		rc = eeh_wait_for_slot_status(pdn, PCI_BUS_RESET_WAIT_MSEC);
780 781
		if (rc == 0)
			return 0;
782 783

		if (rc < 0) {
784 785
			printk(KERN_ERR "EEH: unrecoverable slot failure %s\n",
			       pdn->node->full_name);
786
			return -1;
787
		}
788 789
		printk(KERN_ERR "EEH: bus reset %d failed on slot %s, rc=%d\n",
		       i+1, pdn->node->full_name, rc);
790
	}
791

792
	return -1;
793 794
}

795 796 797 798 799 800 801 802 803 804 805
/* ------------------------------------------------------- */
/** Save and restore of PCI BARs
 *
 * Although firmware will set up BARs during boot, it doesn't
 * set up device BAR's after a device reset, although it will,
 * if requested, set up bridge configuration. Thus, we need to
 * configure the PCI devices ourselves.  
 */

/**
 * __restore_bars - Restore the Base Address Registers
806 807
 * @pdn: pci device node
 *
808 809 810 811 812 813 814
 * Loads the PCI configuration space base address registers,
 * the expansion ROM base address, the latency timer, and etc.
 * from the saved values in the device node.
 */
static inline void __restore_bars (struct pci_dn *pdn)
{
	int i;
815
	u32 cmd;
816 817 818 819 820 821 822 823 824 825 826 827 828 829 830 831 832 833 834 835

	if (NULL==pdn->phb) return;
	for (i=4; i<10; i++) {
		rtas_write_config(pdn, i*4, 4, pdn->config_space[i]);
	}

	/* 12 == Expansion ROM Address */
	rtas_write_config(pdn, 12*4, 4, pdn->config_space[12]);

#define BYTE_SWAP(OFF) (8*((OFF)/4)+3-(OFF))
#define SAVED_BYTE(OFF) (((u8 *)(pdn->config_space))[BYTE_SWAP(OFF)])

	rtas_write_config (pdn, PCI_CACHE_LINE_SIZE, 1,
	            SAVED_BYTE(PCI_CACHE_LINE_SIZE));

	rtas_write_config (pdn, PCI_LATENCY_TIMER, 1,
	            SAVED_BYTE(PCI_LATENCY_TIMER));

	/* max latency, min grant, interrupt pin and line */
	rtas_write_config(pdn, 15*4, 4, pdn->config_space[15]);
836 837 838 839 840 841 842 843 844 845 846 847 848

	/* Restore PERR & SERR bits, some devices require it,
	   don't touch the other command bits */
	rtas_read_config(pdn, PCI_COMMAND, 4, &cmd);
	if (pdn->config_space[1] & PCI_COMMAND_PARITY)
		cmd |= PCI_COMMAND_PARITY;
	else
		cmd &= ~PCI_COMMAND_PARITY;
	if (pdn->config_space[1] & PCI_COMMAND_SERR)
		cmd |= PCI_COMMAND_SERR;
	else
		cmd &= ~PCI_COMMAND_SERR;
	rtas_write_config(pdn, PCI_COMMAND, 4, cmd);
849 850 851 852 853 854 855 856 857 858 859 860 861 862
}

/**
 * eeh_restore_bars - restore the PCI config space info
 *
 * This routine performs a recursive walk to the children
 * of this device as well.
 */
void eeh_restore_bars(struct pci_dn *pdn)
{
	struct device_node *dn;
	if (!pdn) 
		return;
	
863
	if ((pdn->eeh_mode & EEH_MODE_SUPPORTED) && !IS_BRIDGE(pdn->class_code))
864 865
		__restore_bars (pdn);

866
	for_each_child_of_node(pdn->node, dn)
867 868 869 870 871 872 873 874 875 876 877
		eeh_restore_bars (PCI_DN(dn));
}

/**
 * eeh_save_bars - save device bars
 *
 * Save the values of the device bars. Unlike the restore
 * routine, this routine is *not* recursive. This is because
 * PCI devices are added individuallly; but, for the restore,
 * an entire slot is reset at a time.
 */
878
static void eeh_save_bars(struct pci_dn *pdn)
879 880 881
{
	int i;

882
	if (!pdn )
883 884 885
		return;
	
	for (i = 0; i < 16; i++)
886
		rtas_read_config(pdn, i * 4, 4, &pdn->config_space[i]);
887 888 889 890 891
}

void
rtas_configure_bridge(struct pci_dn *pdn)
{
892
	int config_addr;
893 894
	int rc;

895 896 897 898 899
	/* Use PE configuration address, if present */
	config_addr = pdn->eeh_config_addr;
	if (pdn->eeh_pe_config_addr)
		config_addr = pdn->eeh_pe_config_addr;

900
	rc = rtas_call(ibm_configure_bridge,3,1, NULL,
901
	               config_addr,
902 903 904 905 906 907 908 909
	               BUID_HI(pdn->phb->buid),
	               BUID_LO(pdn->phb->buid));
	if (rc) {
		printk (KERN_WARNING "EEH: Unable to configure device bridge (%d) for %s\n",
		        rc, pdn->node->full_name);
	}
}

910 911 912 913 914 915 916 917
/* ------------------------------------------------------------- */
/* The code below deals with enabling EEH for devices during  the
 * early boot sequence.  EEH must be enabled before any PCI probing
 * can be done.
 */

#define EEH_ENABLE 1

L
Linus Torvalds 已提交
918 919 920 921 922
struct eeh_early_enable_info {
	unsigned int buid_hi;
	unsigned int buid_lo;
};

923 924 925 926 927 928 929 930 931 932 933 934 935 936 937 938 939 940 941 942 943 944 945 946 947 948 949 950 951 952 953 954
static int get_pe_addr (int config_addr,
                        struct eeh_early_enable_info *info)
{
	unsigned int rets[3];
	int ret;

	/* Use latest config-addr token on power6 */
	if (ibm_get_config_addr_info2 != RTAS_UNKNOWN_SERVICE) {
		/* Make sure we have a PE in hand */
		ret = rtas_call (ibm_get_config_addr_info2, 4, 2, rets,
			config_addr, info->buid_hi, info->buid_lo, 1);
		if (ret || (rets[0]==0))
			return 0;

		ret = rtas_call (ibm_get_config_addr_info2, 4, 2, rets,
			config_addr, info->buid_hi, info->buid_lo, 0);
		if (ret)
			return 0;
		return rets[0];
	}

	/* Use older config-addr token on power5 */
	if (ibm_get_config_addr_info != RTAS_UNKNOWN_SERVICE) {
		ret = rtas_call (ibm_get_config_addr_info, 4, 2, rets,
			config_addr, info->buid_hi, info->buid_lo, 0);
		if (ret)
			return 0;
		return rets[0];
	}
	return 0;
}

L
Linus Torvalds 已提交
955 956 957
/* Enable eeh for the given device node. */
static void *early_enable_eeh(struct device_node *dn, void *data)
{
958
	unsigned int rets[3];
L
Linus Torvalds 已提交
959 960
	struct eeh_early_enable_info *info = data;
	int ret;
961 962 963
	const u32 *class_code = of_get_property(dn, "class-code", NULL);
	const u32 *vendor_id = of_get_property(dn, "vendor-id", NULL);
	const u32 *device_id = of_get_property(dn, "device-id", NULL);
964
	const u32 *regs;
L
Linus Torvalds 已提交
965
	int enable;
L
Linas Vepstas 已提交
966
	struct pci_dn *pdn = PCI_DN(dn);
L
Linus Torvalds 已提交
967

968
	pdn->class_code = 0;
969
	pdn->eeh_mode = 0;
970 971
	pdn->eeh_check_count = 0;
	pdn->eeh_freeze_count = 0;
972
	pdn->eeh_false_positives = 0;
L
Linus Torvalds 已提交
973

974 975
	if (!of_device_is_available(dn))
		return NULL;
L
Linus Torvalds 已提交
976 977 978 979 980 981 982

	/* Ignore bad nodes. */
	if (!class_code || !vendor_id || !device_id)
		return NULL;

	/* There is nothing to check on PCI to ISA bridges */
	if (dn->type && !strcmp(dn->type, "isa")) {
983
		pdn->eeh_mode |= EEH_MODE_NOCHECK;
L
Linus Torvalds 已提交
984 985
		return NULL;
	}
986
	pdn->class_code = *class_code;
L
Linus Torvalds 已提交
987 988 989

	/* Ok... see if this device supports EEH.  Some do, some don't,
	 * and the only way to find out is to check each and every one. */
990
	regs = of_get_property(dn, "reg", NULL);
L
Linus Torvalds 已提交
991 992 993 994
	if (regs) {
		/* First register entry is addr (00BBSS00)  */
		/* Try to enable eeh */
		ret = rtas_call(ibm_set_eeh_option, 4, 1, NULL,
995 996 997
		                regs[0], info->buid_hi, info->buid_lo,
		                EEH_ENABLE);

998
		enable = 0;
L
Linus Torvalds 已提交
999
		if (ret == 0) {
1000
			pdn->eeh_config_addr = regs[0];
1001 1002 1003

			/* If the newer, better, ibm,get-config-addr-info is supported, 
			 * then use that instead. */
1004
			pdn->eeh_pe_config_addr = get_pe_addr(pdn->eeh_config_addr, info);
1005 1006 1007 1008 1009 1010 1011 1012 1013 1014 1015 1016 1017 1018

			/* Some older systems (Power4) allow the
			 * ibm,set-eeh-option call to succeed even on nodes
			 * where EEH is not supported. Verify support
			 * explicitly. */
			ret = read_slot_reset_state(pdn, rets);
			if ((ret == 0) && (rets[1] == 1))
				enable = 1;
		}

		if (enable) {
			eeh_subsystem_enabled = 1;
			pdn->eeh_mode |= EEH_MODE_SUPPORTED;

L
Linus Torvalds 已提交
1019
#ifdef DEBUG
1020 1021
			printk(KERN_DEBUG "EEH: %s: eeh enabled, config=%x pe_config=%x\n",
			       dn->full_name, pdn->eeh_config_addr, pdn->eeh_pe_config_addr);
L
Linus Torvalds 已提交
1022 1023 1024 1025 1026
#endif
		} else {

			/* This device doesn't support EEH, but it may have an
			 * EEH parent, in which case we mark it as supported. */
L
Linas Vepstas 已提交
1027
			if (dn->parent && PCI_DN(dn->parent)
1028
			    && (PCI_DN(dn->parent)->eeh_mode & EEH_MODE_SUPPORTED)) {
L
Linus Torvalds 已提交
1029
				/* Parent supports EEH. */
1030 1031
				pdn->eeh_mode |= EEH_MODE_SUPPORTED;
				pdn->eeh_config_addr = PCI_DN(dn->parent)->eeh_config_addr;
L
Linus Torvalds 已提交
1032 1033 1034 1035 1036 1037 1038 1039
				return NULL;
			}
		}
	} else {
		printk(KERN_WARNING "EEH: %s: unable to get reg property.\n",
		       dn->full_name);
	}

1040
	eeh_save_bars(pdn);
L
Linas Vepstas 已提交
1041
	return NULL;
L
Linus Torvalds 已提交
1042 1043 1044 1045 1046 1047 1048 1049 1050 1051 1052 1053 1054 1055 1056 1057 1058 1059 1060 1061
}

/*
 * Initialize EEH by trying to enable it for all of the adapters in the system.
 * As a side effect we can determine here if eeh is supported at all.
 * Note that we leave EEH on so failed config cycles won't cause a machine
 * check.  If a user turns off EEH for a particular adapter they are really
 * telling Linux to ignore errors.  Some hardware (e.g. POWER5) won't
 * grant access to a slot if EEH isn't enabled, and so we always enable
 * EEH for all slots/all devices.
 *
 * The eeh-force-off option disables EEH checking globally, for all slots.
 * Even if force-off is set, the EEH hardware is still enabled, so that
 * newer systems can boot.
 */
void __init eeh_init(void)
{
	struct device_node *phb, *np;
	struct eeh_early_enable_info info;

1062
	spin_lock_init(&confirm_error_lock);
1063 1064
	spin_lock_init(&slot_errbuf_lock);

L
Linus Torvalds 已提交
1065 1066 1067 1068 1069 1070 1071 1072 1073
	np = of_find_node_by_path("/rtas");
	if (np == NULL)
		return;

	ibm_set_eeh_option = rtas_token("ibm,set-eeh-option");
	ibm_set_slot_reset = rtas_token("ibm,set-slot-reset");
	ibm_read_slot_reset_state2 = rtas_token("ibm,read-slot-reset-state2");
	ibm_read_slot_reset_state = rtas_token("ibm,read-slot-reset-state");
	ibm_slot_error_detail = rtas_token("ibm,slot-error-detail");
1074
	ibm_get_config_addr_info = rtas_token("ibm,get-config-addr-info");
1075
	ibm_get_config_addr_info2 = rtas_token("ibm,get-config-addr-info2");
1076
	ibm_configure_bridge = rtas_token ("ibm,configure-bridge");
L
Linus Torvalds 已提交
1077 1078 1079 1080 1081 1082 1083 1084 1085 1086 1087 1088 1089 1090 1091 1092 1093 1094 1095 1096

	if (ibm_set_eeh_option == RTAS_UNKNOWN_SERVICE)
		return;

	eeh_error_buf_size = rtas_token("rtas-error-log-max");
	if (eeh_error_buf_size == RTAS_UNKNOWN_SERVICE) {
		eeh_error_buf_size = 1024;
	}
	if (eeh_error_buf_size > RTAS_ERROR_LOG_MAX) {
		printk(KERN_WARNING "EEH: rtas-error-log-max is bigger than allocated "
		      "buffer ! (%d vs %d)", eeh_error_buf_size, RTAS_ERROR_LOG_MAX);
		eeh_error_buf_size = RTAS_ERROR_LOG_MAX;
	}

	/* Enable EEH for all adapters.  Note that eeh requires buid's */
	for (phb = of_find_node_by_name(NULL, "pci"); phb;
	     phb = of_find_node_by_name(phb, "pci")) {
		unsigned long buid;

		buid = get_phb_buid(phb);
L
Linas Vepstas 已提交
1097
		if (buid == 0 || PCI_DN(phb) == NULL)
L
Linus Torvalds 已提交
1098 1099 1100 1101 1102 1103 1104 1105 1106 1107 1108 1109 1110 1111 1112 1113 1114 1115 1116 1117 1118 1119 1120 1121 1122
			continue;

		info.buid_lo = BUID_LO(buid);
		info.buid_hi = BUID_HI(buid);
		traverse_pci_devices(phb, early_enable_eeh, &info);
	}

	if (eeh_subsystem_enabled)
		printk(KERN_INFO "EEH: PCI Enhanced I/O Error Handling Enabled\n");
	else
		printk(KERN_WARNING "EEH: No capable adapters found\n");
}

/**
 * eeh_add_device_early - enable EEH for the indicated device_node
 * @dn: device node for which to set up EEH
 *
 * This routine must be used to perform EEH initialization for PCI
 * devices that were added after system boot (e.g. hotplug, dlpar).
 * This routine must be called before any i/o is performed to the
 * adapter (inluding any config-space i/o).
 * Whether this actually enables EEH or not for this device depends
 * on the CEC architecture, type of the device, on earlier boot
 * command-line arguments & etc.
 */
1123
static void eeh_add_device_early(struct device_node *dn)
L
Linus Torvalds 已提交
1124 1125 1126 1127
{
	struct pci_controller *phb;
	struct eeh_early_enable_info info;

L
Linas Vepstas 已提交
1128
	if (!dn || !PCI_DN(dn))
L
Linus Torvalds 已提交
1129
		return;
1130
	phb = PCI_DN(dn)->phb;
1131 1132 1133

	/* USB Bus children of PCI devices will not have BUID's */
	if (NULL == phb || 0 == phb->buid)
L
Linus Torvalds 已提交
1134 1135 1136 1137 1138 1139 1140
		return;

	info.buid_hi = BUID_HI(phb->buid);
	info.buid_lo = BUID_LO(phb->buid);
	early_enable_eeh(dn, &info);
}

1141 1142 1143
void eeh_add_device_tree_early(struct device_node *dn)
{
	struct device_node *sib;
1144 1145

	for_each_child_of_node(dn, sib)
1146 1147 1148 1149 1150
		eeh_add_device_tree_early(sib);
	eeh_add_device_early(dn);
}
EXPORT_SYMBOL_GPL(eeh_add_device_tree_early);

L
Linus Torvalds 已提交
1151 1152 1153 1154 1155 1156 1157
/**
 * eeh_add_device_late - perform EEH initialization for the indicated pci device
 * @dev: pci device for which to set up EEH
 *
 * This routine must be used to complete EEH initialization for PCI
 * devices that were added after system boot (e.g. hotplug, dlpar).
 */
1158
static void eeh_add_device_late(struct pci_dev *dev)
L
Linus Torvalds 已提交
1159
{
1160
	struct device_node *dn;
1161
	struct pci_dn *pdn;
1162

L
Linus Torvalds 已提交
1163 1164 1165 1166
	if (!dev || !eeh_subsystem_enabled)
		return;

#ifdef DEBUG
1167
	printk(KERN_DEBUG "EEH: adding device %s\n", pci_name(dev));
L
Linus Torvalds 已提交
1168 1169
#endif

1170 1171
	pci_dev_get (dev);
	dn = pci_device_to_OF_node(dev);
1172 1173
	pdn = PCI_DN(dn);
	pdn->pcidev = dev;
1174

1175 1176
	pci_addr_cache_insert_device(dev);
	eeh_sysfs_add_device(dev);
L
Linus Torvalds 已提交
1177
}
1178 1179 1180 1181 1182 1183 1184 1185 1186 1187 1188 1189 1190 1191 1192

void eeh_add_device_tree_late(struct pci_bus *bus)
{
	struct pci_dev *dev;

	list_for_each_entry(dev, &bus->devices, bus_list) {
 		eeh_add_device_late(dev);
 		if (dev->hdr_type == PCI_HEADER_TYPE_BRIDGE) {
 			struct pci_bus *subbus = dev->subordinate;
 			if (subbus)
 				eeh_add_device_tree_late(subbus);
 		}
	}
}
EXPORT_SYMBOL_GPL(eeh_add_device_tree_late);
L
Linus Torvalds 已提交
1193 1194 1195 1196 1197

/**
 * eeh_remove_device - undo EEH setup for the indicated pci device
 * @dev: pci device to be removed
 *
1198 1199 1200 1201 1202
 * This routine should be called when a device is removed from
 * a running system (e.g. by hotplug or dlpar).  It unregisters
 * the PCI device from the EEH subsystem.  I/O errors affecting
 * this device will no longer be detected after this call; thus,
 * i/o errors affecting this slot may leave this device unusable.
L
Linus Torvalds 已提交
1203
 */
1204
static void eeh_remove_device(struct pci_dev *dev)
L
Linus Torvalds 已提交
1205
{
1206
	struct device_node *dn;
L
Linus Torvalds 已提交
1207 1208 1209 1210 1211
	if (!dev || !eeh_subsystem_enabled)
		return;

	/* Unregister the device with the EEH/PCI address search system */
#ifdef DEBUG
1212
	printk(KERN_DEBUG "EEH: remove device %s\n", pci_name(dev));
L
Linus Torvalds 已提交
1213 1214
#endif
	pci_addr_cache_remove_device(dev);
1215
	eeh_sysfs_remove_device(dev);
1216 1217

	dn = pci_device_to_OF_node(dev);
1218 1219 1220 1221
	if (PCI_DN(dn)->pcidev) {
		PCI_DN(dn)->pcidev = NULL;
		pci_dev_put (dev);
	}
L
Linus Torvalds 已提交
1222 1223
}

1224 1225
void eeh_remove_bus_device(struct pci_dev *dev)
{
1226 1227 1228
	struct pci_bus *bus = dev->subordinate;
	struct pci_dev *child, *tmp;

1229
	eeh_remove_device(dev);
1230 1231 1232 1233

	if (bus && dev->hdr_type == PCI_HEADER_TYPE_BRIDGE) {
		list_for_each_entry_safe(child, tmp, &bus->devices, bus_list)
			 eeh_remove_bus_device(child);
1234 1235 1236 1237
	}
}
EXPORT_SYMBOL_GPL(eeh_remove_bus_device);

L
Linus Torvalds 已提交
1238 1239 1240 1241
static int proc_eeh_show(struct seq_file *m, void *v)
{
	if (0 == eeh_subsystem_enabled) {
		seq_printf(m, "EEH Subsystem is globally disabled\n");
1242
		seq_printf(m, "eeh_total_mmio_ffs=%ld\n", total_mmio_ffs);
L
Linus Torvalds 已提交
1243 1244
	} else {
		seq_printf(m, "EEH Subsystem is enabled\n");
1245 1246 1247 1248 1249 1250 1251 1252
		seq_printf(m,
				"no device=%ld\n"
				"no device node=%ld\n"
				"no config address=%ld\n"
				"check not wanted=%ld\n"
				"eeh_total_mmio_ffs=%ld\n"
				"eeh_false_positives=%ld\n"
				"eeh_slot_resets=%ld\n",
1253 1254
				no_device, no_dn, no_cfg_addr, 
				ignored_check, total_mmio_ffs, 
L
Linas Vepstas 已提交
1255
				false_positives,
1256
				slot_resets);
L
Linus Torvalds 已提交
1257 1258 1259 1260 1261 1262 1263 1264 1265 1266
	}

	return 0;
}

static int proc_eeh_open(struct inode *inode, struct file *file)
{
	return single_open(file, proc_eeh_show, NULL);
}

1267
static const struct file_operations proc_eeh_operations = {
L
Linus Torvalds 已提交
1268 1269 1270 1271 1272 1273 1274 1275
	.open      = proc_eeh_open,
	.read      = seq_read,
	.llseek    = seq_lseek,
	.release   = single_release,
};

static int __init eeh_init_proc(void)
{
1276 1277
	if (machine_is(pseries))
		proc_create("ppc64/eeh", 0, NULL, &proc_eeh_operations);
L
Linus Torvalds 已提交
1278 1279 1280
	return 0;
}
__initcall(eeh_init_proc);