eeh.c 31.4 KB
Newer Older
L
Linus Torvalds 已提交
1 2 3
/*
 * eeh.c
 * Copyright (C) 2001 Dave Engebretsen & Todd Inglett IBM Corporation
L
Linas Vepstas 已提交
4
 *
L
Linus Torvalds 已提交
5 6 7 8
 * 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 已提交
9
 *
L
Linus Torvalds 已提交
10 11 12 13
 * 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 已提交
14
 *
L
Linus Torvalds 已提交
15 16 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
#include <linux/delay.h>
L
Linus Torvalds 已提交
21 22 23 24 25 26 27
#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>
L
Linas Vepstas 已提交
28
#include <asm/atomic.h>
L
Linus Torvalds 已提交
29
#include <asm/eeh.h>
30
#include <asm/eeh_event.h>
L
Linus Torvalds 已提交
31 32
#include <asm/io.h>
#include <asm/machdep.h>
33
#include <asm/ppc-pci.h>
L
Linus Torvalds 已提交
34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49
#include <asm/rtas.h>

#undef DEBUG

/** 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 已提交
50 51
 *  which in turn might be caused by low voltage on the bus, dust,
 *  vibration, humidity, radioactivity or plain-old failed hardware.
L
Linus Torvalds 已提交
52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71
 *
 *  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.
 */

72
/* If a device driver keeps reading an MMIO register in an interrupt
L
Linus Torvalds 已提交
73 74 75 76
 * 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.
 */
77
#define EEH_MAX_FAILS	2100000
L
Linus Torvalds 已提交
78 79 80 81 82 83 84

/* 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;
85
static int ibm_get_config_addr_info;
86
static int ibm_get_config_addr_info2;
87
static int ibm_configure_bridge;
L
Linus Torvalds 已提交
88

89 90
int eeh_subsystem_enabled;
EXPORT_SYMBOL(eeh_subsystem_enabled);
L
Linus Torvalds 已提交
91

92 93 94
/* Lock to avoid races due to multiple reports of an error */
static DEFINE_SPINLOCK(confirm_error_lock);

L
Linus Torvalds 已提交
95 96 97 98 99 100
/* Buffer for reporting slot-error-detail rtas calls */
static unsigned char slot_errbuf[RTAS_ERROR_LOG_MAX];
static DEFINE_SPINLOCK(slot_errbuf_lock);
static int eeh_error_buf_size;

/* System monitoring statistics */
101 102 103 104 105 106 107 108
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 ignored_failures;
static unsigned long slot_resets;
L
Linus Torvalds 已提交
109

110 111
#define IS_BRIDGE(class_code) (((class_code)<<16) == PCI_BASE_CLASS_BRIDGE)

L
Linus Torvalds 已提交
112
/* --------------------------------------------------------------- */
113
/* Below lies the EEH event infrastructure */
L
Linus Torvalds 已提交
114

115 116
void eeh_slot_error_detail (struct pci_dn *pdn, int severity)
{
117
	int config_addr;
118 119 120 121 122 123 124
	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);

125 126 127 128 129
	/* 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;

130
	rc = rtas_call(ibm_slot_error_detail,
131
	               8, 1, NULL, config_addr,
132 133 134 135 136 137 138 139 140 141 142
	               BUID_HI(pdn->phb->buid),
	               BUID_LO(pdn->phb->buid), NULL, 0,
	               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);
}

L
Linus Torvalds 已提交
143 144 145 146 147
/**
 * 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 已提交
148
static int read_slot_reset_state(struct pci_dn *pdn, int rets[])
L
Linus Torvalds 已提交
149 150
{
	int token, outputs;
151
	int config_addr;
L
Linus Torvalds 已提交
152 153 154 155 156 157

	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 已提交
158
		rets[2] = 0; /* fake PE Unavailable info */
L
Linus Torvalds 已提交
159 160 161
		outputs = 3;
	}

162 163 164 165 166 167
	/* 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,
168
			 BUID_HI(pdn->phb->buid), BUID_LO(pdn->phb->buid));
L
Linus Torvalds 已提交
169 170 171 172
}

/**
 * eeh_token_to_phys - convert EEH address token to phys address
L
Linas Vepstas 已提交
173
 * @token i/o token, should be address in the form 0xA....
L
Linus Torvalds 已提交
174 175 176 177 178 179
 */
static inline unsigned long eeh_token_to_phys(unsigned long token)
{
	pte_t *ptep;
	unsigned long pa;

D
David Gibson 已提交
180
	ptep = find_linux_pte(init_mm.pgd, token);
L
Linus Torvalds 已提交
181 182 183 184 185 186 187
	if (!ptep)
		return token;
	pa = pte_pfn(*ptep) << PAGE_SHIFT;

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

188 189 190
/** 
 * Return the "partitionable endpoint" (pe) under which this device lies
 */
191
struct device_node * find_device_pe(struct device_node *dn)
192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207
{
	while ((dn->parent) && PCI_DN(dn->parent) &&
	      (PCI_DN(dn->parent)->eeh_mode & EEH_MODE_SUPPORTED)) {
		dn = dn->parent;
	}
	return dn;
}

/** Mark all devices that are peers of this device as failed.
 *  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.
 */

L
Linas Vepstas 已提交
208
static void __eeh_mark_slot (struct device_node *dn, int mode_flag)
209 210
{
	while (dn) {
L
Linas Vepstas 已提交
211
		if (PCI_DN(dn)) {
212 213
			/* Mark the pci device driver too */
			struct pci_dev *dev = PCI_DN(dn)->pcidev;
214 215 216

			PCI_DN(dn)->eeh_mode |= mode_flag;

217 218 219
			if (dev && dev->driver)
				dev->error_state = pci_channel_io_frozen;

L
Linas Vepstas 已提交
220 221 222
			if (dn->child)
				__eeh_mark_slot (dn->child, mode_flag);
		}
223 224 225 226
		dn = dn->sibling;
	}
}

L
Linas Vepstas 已提交
227 228
void eeh_mark_slot (struct device_node *dn, int mode_flag)
{
229
	struct pci_dev *dev;
L
Linas Vepstas 已提交
230
	dn = find_device_pe (dn);
231 232 233 234 235

	/* Back up one, since config addrs might be shared */
	if (PCI_DN(dn) && PCI_DN(dn)->eeh_pe_config_addr)
		dn = dn->parent;

L
Linas Vepstas 已提交
236
	PCI_DN(dn)->eeh_mode |= mode_flag;
237 238 239 240 241 242

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

L
Linas Vepstas 已提交
243 244 245 246
	__eeh_mark_slot (dn->child, mode_flag);
}

static void __eeh_clear_slot (struct device_node *dn, int mode_flag)
247 248
{
	while (dn) {
L
Linas Vepstas 已提交
249 250 251 252 253 254
		if (PCI_DN(dn)) {
			PCI_DN(dn)->eeh_mode &= ~mode_flag;
			PCI_DN(dn)->eeh_check_count = 0;
			if (dn->child)
				__eeh_clear_slot (dn->child, mode_flag);
		}
255 256 257 258
		dn = dn->sibling;
	}
}

L
Linas Vepstas 已提交
259
void eeh_clear_slot (struct device_node *dn, int mode_flag)
260 261 262
{
	unsigned long flags;
	spin_lock_irqsave(&confirm_error_lock, flags);
263
	
L
Linas Vepstas 已提交
264
	dn = find_device_pe (dn);
265 266 267 268 269
	
	/* Back up one, since config addrs might be shared */
	if (PCI_DN(dn) && PCI_DN(dn)->eeh_pe_config_addr)
		dn = dn->parent;

L
Linas Vepstas 已提交
270 271 272
	PCI_DN(dn)->eeh_mode &= ~mode_flag;
	PCI_DN(dn)->eeh_check_count = 0;
	__eeh_clear_slot (dn->child, mode_flag);
273 274 275
	spin_unlock_irqrestore(&confirm_error_lock, flags);
}

L
Linus Torvalds 已提交
276 277 278 279 280 281 282 283 284 285 286
/**
 * 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 已提交
287
 * a non-zero value and queues up a slot isolation event notification.
L
Linus Torvalds 已提交
288 289 290 291 292 293 294 295
 *
 * 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;
296
	struct pci_dn *pdn;
297
	enum pci_channel_state state;
298
	int rc = 0;
L
Linus Torvalds 已提交
299

300
	total_mmio_ffs++;
L
Linus Torvalds 已提交
301 302 303 304

	if (!eeh_subsystem_enabled)
		return 0;

305
	if (!dn) {
306
		no_dn++;
L
Linus Torvalds 已提交
307
		return 0;
308
	}
L
Linas Vepstas 已提交
309
	pdn = PCI_DN(dn);
L
Linus Torvalds 已提交
310 311

	/* Access to IO BARs might get this far and still not want checking. */
312
	if (!(pdn->eeh_mode & EEH_MODE_SUPPORTED) ||
313
	    pdn->eeh_mode & EEH_MODE_NOCHECK) {
314
		ignored_check++;
315
#ifdef DEBUG
316 317
		printk ("EEH:ignored check (%x) for %s %s\n", 
		        pdn->eeh_mode, pci_name (dev), dn->full_name);
318
#endif
L
Linus Torvalds 已提交
319 320 321
		return 0;
	}

322
	if (!pdn->eeh_config_addr && !pdn->eeh_pe_config_addr) {
323
		no_cfg_addr++;
L
Linus Torvalds 已提交
324 325 326
		return 0;
	}

327 328 329 330 331
	/* 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 已提交
332
	 */
333 334
	spin_lock_irqsave(&confirm_error_lock, flags);
	rc = 1;
335
	if (pdn->eeh_mode & EEH_MODE_ISOLATED) {
336 337 338 339 340
		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 已提交
341
			msleep(5000);
342
			
L
Linus Torvalds 已提交
343
			/* re-read the slot reset state */
L
Linas Vepstas 已提交
344
			if (read_slot_reset_state(pdn, rets) != 0)
L
Linus Torvalds 已提交
345
				rets[0] = -1;	/* reset state unknown */
346 347 348

			/* 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 已提交
349
		}
350
		goto dn_unlock;
L
Linus Torvalds 已提交
351 352 353 354 355 356 357 358 359
	}

	/*
	 * 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 已提交
360
	ret = read_slot_reset_state(pdn, rets);
361 362 363 364 365

	/* 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);
366
		false_positives++;
367 368
		rc = 0;
		goto dn_unlock;
369 370
	}

371 372 373 374 375 376 377 378
	/* Note that config-io to empty slots may fail;
	 * they are empty when they don't have children. */
	if ((rets[0] == 5) && (dn->child == NULL)) {
		false_positives++;
		rc = 0;
		goto dn_unlock;
	}

379 380 381 382
	/* 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);
383
		false_positives++;
384 385
		rc = 0;
		goto dn_unlock;
386 387 388 389
	}

	/* If not the kind of error we know about, punt. */
	if (rets[0] != 2 && rets[0] != 4 && rets[0] != 5) {
390
		false_positives++;
391 392
		rc = 0;
		goto dn_unlock;
393 394
	}

395
	slot_resets++;
396 397 398 399
 
	/* Avoid repeated reports of this failure, including problems
	 * with other functions on this device, and functions under
	 * bridges. */
L
Linas Vepstas 已提交
400
	eeh_mark_slot (dn, EEH_MODE_ISOLATED);
401
	spin_unlock_irqrestore(&confirm_error_lock, flags);
L
Linus Torvalds 已提交
402

403 404 405 406 407 408 409
	state = pci_channel_io_normal;
	if ((rets[0] == 2) || (rets[0] == 4))
		state = pci_channel_io_frozen;
	if (rets[0] == 5)
		state = pci_channel_io_perm_failure;
	eeh_send_failure_event (dn, dev, state, rets[2]);

L
Linus Torvalds 已提交
410 411 412
	/* 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. */
413
	if (rets[0] != 5) dump_stack();
414 415 416 417 418
	return 1;

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

421
EXPORT_SYMBOL_GPL(eeh_dn_check_failure);
L
Linus Torvalds 已提交
422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443

/**
 * 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);
444
	if (!dev) {
445
		no_device++;
L
Linus Torvalds 已提交
446
		return val;
447
	}
L
Linus Torvalds 已提交
448 449 450 451 452 453 454 455 456 457

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

	pci_dev_put(dev);
	return val;
}

EXPORT_SYMBOL(eeh_check_failure);

458 459 460
/* ------------------------------------------------------------- */
/* The code below deals with error recovery */

461 462 463 464 465
/**
 * eeh_slot_availability - returns error status of slot
 * @pdn pci device node
 *
 * Return negative value if a permanent error, else return
466 467 468 469 470 471 472 473 474 475 476 477 478 479
 * a number of milliseconds to wait until the PCI slot is
 * ready to be used.
 */
static int
eeh_slot_availability(struct pci_dn *pdn)
{
	int rc;
	int rets[3];

	rc = read_slot_reset_state(pdn, rets);

	if (rc) return rc;

	if (rets[1] == 0) return -1;  /* EEH is not supported */
480
	if (rets[0] == 0) return 0;   /* Oll Korrect */
481 482 483 484
	if (rets[0] == 5) {
		if (rets[2] == 0) return -1; /* permanently unavailable */
		return rets[2]; /* number of millisecs to wait */
	}
485 486 487 488 489
	if (rets[0] == 1)
		return 250;

	printk (KERN_ERR "EEH: Slot unavailable: rc=%d, rets=%d %d %d\n",
		rc, rets[0], rets[1], rets[2]);
490
	return -2;
491 492
}

493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521
/**
 * 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)
		printk(KERN_WARNING "EEH: Cannot enable function %d, err=%d dn=%s\n",
		        function, rc, pdn->node->full_name);

	return rc;
}

522 523 524 525
/**
 * rtas_pci_slot_reset - raises/lowers the pci #RST line
 * @pdn pci device node
 * @state: 1/0 to raise/lower the #RST
526 527 528 529 530 531 532 533 534 535 536
 *
 * 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)
{
537
	int config_addr;
538 539 540 541 542 543 544 545 546 547
	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;
	}

548 549 550 551 552
	/* 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;

553
	rc = rtas_call(ibm_set_slot_reset,4,1, NULL,
554
	               config_addr,
555 556 557
	               BUID_HI(pdn->phb->buid),
	               BUID_LO(pdn->phb->buid),
	               state);
558 559 560
	if (rc)
		printk (KERN_WARNING "EEH: Unable to reset the failed slot,"
		        " (%d) #RST=%d dn=%s\n",
561 562 563
		        rc, state, pdn->node->full_name);
}

564 565 566
/**
 * rtas_set_slot_reset -- assert the pci #RST line for 1/4 second
 * @pdn: pci device node to be reset.
567 568
 *
 *  Return 0 if success, else a non-zero value.
569 570
 */

571
static void __rtas_set_slot_reset(struct pci_dn *pdn)
572 573 574 575 576 577 578 579
{
	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 已提交
580 581 582 583 584 585
	
	/* 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);

586 587 588 589 590 591 592
	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);
593 594 595 596 597 598 599
}

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

	__rtas_set_slot_reset(pdn);
600 601 602 603 604

	/* Now double check with the firmware to make sure the device is
	 * ready to be used; if not, wait for recovery. */
	for (i=0; i<10; i++) {
		rc = eeh_slot_availability (pdn);
605 606
		if (rc == 0)
			return 0;
607 608 609 610 611 612 613 614 615 616 617

		if (rc == -2) {
			printk (KERN_ERR "EEH: failed (%d) to reset slot %s\n",
			        i, pdn->node->full_name);
			__rtas_set_slot_reset(pdn);
			continue;
		}

		if (rc < 0) {
			printk (KERN_ERR "EEH: unrecoverable slot failure %s\n",
			        pdn->node->full_name);
618
			return -1;
619
		}
620 621 622

		msleep (rc+100);
	}
623 624 625 626 627 628

	rc = eeh_slot_availability (pdn);
	if (rc)
		printk (KERN_ERR "EEH: timeout resetting slot %s\n", pdn->node->full_name);

	return rc;
629 630
}

631 632 633 634 635 636 637 638 639 640 641
/* ------------------------------------------------------- */
/** 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
642 643
 * @pdn: pci device node
 *
644 645 646 647 648 649 650 651 652 653 654 655 656 657 658 659 660 661 662 663 664 665 666 667 668 669 670 671 672 673 674 675 676 677 678 679 680 681 682 683 684
 * 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;

	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]);
}

/**
 * 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;
	
685
	if ((pdn->eeh_mode & EEH_MODE_SUPPORTED) && !IS_BRIDGE(pdn->class_code))
686 687 688 689 690 691 692 693 694 695 696 697 698 699 700 701 702
		__restore_bars (pdn);

	dn = pdn->node->child;
	while (dn) {
		eeh_restore_bars (PCI_DN(dn));
		dn = dn->sibling;
	}
}

/**
 * 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.
 */
703
static void eeh_save_bars(struct pci_dn *pdn)
704 705 706
{
	int i;

707
	if (!pdn )
708 709 710
		return;
	
	for (i = 0; i < 16; i++)
711
		rtas_read_config(pdn, i * 4, 4, &pdn->config_space[i]);
712 713 714 715 716
}

void
rtas_configure_bridge(struct pci_dn *pdn)
{
717
	int config_addr;
718 719
	int rc;

720 721 722 723 724
	/* 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;

725
	rc = rtas_call(ibm_configure_bridge,3,1, NULL,
726
	               config_addr,
727 728 729 730 731 732 733 734
	               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);
	}
}

735 736 737 738 739 740 741 742
/* ------------------------------------------------------------- */
/* 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 已提交
743 744 745 746 747
struct eeh_early_enable_info {
	unsigned int buid_hi;
	unsigned int buid_lo;
};

748 749 750 751 752 753 754 755 756 757 758 759 760 761 762 763 764 765 766 767 768 769 770 771 772 773 774 775 776 777 778 779
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 已提交
780 781 782
/* Enable eeh for the given device node. */
static void *early_enable_eeh(struct device_node *dn, void *data)
{
783
	unsigned int rets[3];
L
Linus Torvalds 已提交
784 785
	struct eeh_early_enable_info *info = data;
	int ret;
786 787 788 789 790
	const char *status = get_property(dn, "status", NULL);
	const u32 *class_code = get_property(dn, "class-code", NULL);
	const u32 *vendor_id = get_property(dn, "vendor-id", NULL);
	const u32 *device_id = get_property(dn, "device-id", NULL);
	const u32 *regs;
L
Linus Torvalds 已提交
791
	int enable;
L
Linas Vepstas 已提交
792
	struct pci_dn *pdn = PCI_DN(dn);
L
Linus Torvalds 已提交
793

794
	pdn->class_code = 0;
795
	pdn->eeh_mode = 0;
796 797
	pdn->eeh_check_count = 0;
	pdn->eeh_freeze_count = 0;
L
Linus Torvalds 已提交
798 799 800 801 802 803 804 805 806 807

	if (status && strcmp(status, "ok") != 0)
		return NULL;	/* ignore devices with bad status */

	/* 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")) {
808
		pdn->eeh_mode |= EEH_MODE_NOCHECK;
L
Linus Torvalds 已提交
809 810
		return NULL;
	}
811
	pdn->class_code = *class_code;
L
Linus Torvalds 已提交
812 813 814 815 816 817 818 819 820 821

	/*
	 * Now decide if we are going to "Disable" EEH checking
	 * for this device.  We still run with the EEH hardware active,
	 * but we won't be checking for ff's.  This means a driver
	 * could return bad data (very bad!), an interrupt handler could
	 * hang waiting on status bits that won't change, etc.
	 * But there are a few cases like display devices that make sense.
	 */
	enable = 1;	/* i.e. we will do checking */
822
#if 0
L
Linus Torvalds 已提交
823 824
	if ((*class_code >> 16) == PCI_BASE_CLASS_DISPLAY)
		enable = 0;
825
#endif
L
Linus Torvalds 已提交
826 827

	if (!enable)
828
		pdn->eeh_mode |= EEH_MODE_NOCHECK;
L
Linus Torvalds 已提交
829 830 831

	/* 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. */
832
	regs = get_property(dn, "reg", NULL);
L
Linus Torvalds 已提交
833 834 835 836
	if (regs) {
		/* First register entry is addr (00BBSS00)  */
		/* Try to enable eeh */
		ret = rtas_call(ibm_set_eeh_option, 4, 1, NULL,
837 838 839
		                regs[0], info->buid_hi, info->buid_lo,
		                EEH_ENABLE);

840
		enable = 0;
L
Linus Torvalds 已提交
841
		if (ret == 0) {
842
			pdn->eeh_config_addr = regs[0];
843 844 845

			/* If the newer, better, ibm,get-config-addr-info is supported, 
			 * then use that instead. */
846
			pdn->eeh_pe_config_addr = get_pe_addr(pdn->eeh_config_addr, info);
847 848 849 850 851 852 853 854 855 856 857 858 859 860

			/* 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 已提交
861
#ifdef DEBUG
862 863
			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 已提交
864 865 866 867 868
#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 已提交
869
			if (dn->parent && PCI_DN(dn->parent)
870
			    && (PCI_DN(dn->parent)->eeh_mode & EEH_MODE_SUPPORTED)) {
L
Linus Torvalds 已提交
871
				/* Parent supports EEH. */
872 873
				pdn->eeh_mode |= EEH_MODE_SUPPORTED;
				pdn->eeh_config_addr = PCI_DN(dn->parent)->eeh_config_addr;
L
Linus Torvalds 已提交
874 875 876 877 878 879 880 881
				return NULL;
			}
		}
	} else {
		printk(KERN_WARNING "EEH: %s: unable to get reg property.\n",
		       dn->full_name);
	}

882
	eeh_save_bars(pdn);
L
Linas Vepstas 已提交
883
	return NULL;
L
Linus Torvalds 已提交
884 885 886 887 888 889 890 891 892 893 894 895 896 897 898 899 900 901 902 903
}

/*
 * 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;

904
	spin_lock_init(&confirm_error_lock);
905 906
	spin_lock_init(&slot_errbuf_lock);

L
Linus Torvalds 已提交
907 908 909 910 911 912 913 914 915
	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");
916
	ibm_get_config_addr_info = rtas_token("ibm,get-config-addr-info");
917
	ibm_get_config_addr_info2 = rtas_token("ibm,get-config-addr-info2");
918
	ibm_configure_bridge = rtas_token ("ibm,configure-bridge");
L
Linus Torvalds 已提交
919 920 921 922 923 924 925 926 927 928 929 930 931 932 933 934 935 936 937 938

	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 已提交
939
		if (buid == 0 || PCI_DN(phb) == NULL)
L
Linus Torvalds 已提交
940 941 942 943 944 945 946 947 948 949 950 951 952 953 954 955 956 957 958 959 960 961 962 963 964
			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.
 */
965
static void eeh_add_device_early(struct device_node *dn)
L
Linus Torvalds 已提交
966 967 968 969
{
	struct pci_controller *phb;
	struct eeh_early_enable_info info;

L
Linas Vepstas 已提交
970
	if (!dn || !PCI_DN(dn))
L
Linus Torvalds 已提交
971
		return;
972
	phb = PCI_DN(dn)->phb;
973 974 975

	/* USB Bus children of PCI devices will not have BUID's */
	if (NULL == phb || 0 == phb->buid)
L
Linus Torvalds 已提交
976 977 978 979 980 981 982
		return;

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

983 984 985 986 987 988 989 990 991
void eeh_add_device_tree_early(struct device_node *dn)
{
	struct device_node *sib;
	for (sib = dn->child; sib; sib = sib->sibling)
		eeh_add_device_tree_early(sib);
	eeh_add_device_early(dn);
}
EXPORT_SYMBOL_GPL(eeh_add_device_tree_early);

L
Linus Torvalds 已提交
992 993 994 995 996 997 998
/**
 * 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).
 */
999
static void eeh_add_device_late(struct pci_dev *dev)
L
Linus Torvalds 已提交
1000
{
1001
	struct device_node *dn;
1002
	struct pci_dn *pdn;
1003

L
Linus Torvalds 已提交
1004 1005 1006 1007
	if (!dev || !eeh_subsystem_enabled)
		return;

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

1011 1012
	pci_dev_get (dev);
	dn = pci_device_to_OF_node(dev);
1013 1014
	pdn = PCI_DN(dn);
	pdn->pcidev = dev;
1015

L
Linus Torvalds 已提交
1016 1017
	pci_addr_cache_insert_device (dev);
}
1018 1019 1020 1021 1022 1023 1024 1025 1026 1027 1028 1029 1030 1031 1032

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 已提交
1033 1034 1035 1036 1037

/**
 * eeh_remove_device - undo EEH setup for the indicated pci device
 * @dev: pci device to be removed
 *
1038 1039 1040 1041 1042
 * 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 已提交
1043
 */
1044
static void eeh_remove_device(struct pci_dev *dev)
L
Linus Torvalds 已提交
1045
{
1046
	struct device_node *dn;
L
Linus Torvalds 已提交
1047 1048 1049 1050 1051
	if (!dev || !eeh_subsystem_enabled)
		return;

	/* Unregister the device with the EEH/PCI address search system */
#ifdef DEBUG
1052
	printk(KERN_DEBUG "EEH: remove device %s\n", pci_name(dev));
L
Linus Torvalds 已提交
1053 1054
#endif
	pci_addr_cache_remove_device(dev);
1055 1056

	dn = pci_device_to_OF_node(dev);
1057 1058 1059 1060
	if (PCI_DN(dn)->pcidev) {
		PCI_DN(dn)->pcidev = NULL;
		pci_dev_put (dev);
	}
L
Linus Torvalds 已提交
1061 1062
}

1063 1064
void eeh_remove_bus_device(struct pci_dev *dev)
{
1065 1066 1067
	struct pci_bus *bus = dev->subordinate;
	struct pci_dev *child, *tmp;

1068
	eeh_remove_device(dev);
1069 1070 1071 1072

	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);
1073 1074 1075 1076
	}
}
EXPORT_SYMBOL_GPL(eeh_remove_bus_device);

L
Linus Torvalds 已提交
1077 1078 1079 1080
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");
1081
		seq_printf(m, "eeh_total_mmio_ffs=%ld\n", total_mmio_ffs);
L
Linus Torvalds 已提交
1082 1083
	} else {
		seq_printf(m, "EEH Subsystem is enabled\n");
1084 1085 1086 1087 1088 1089 1090 1091 1092
		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_ignored_failures=%ld\n"
				"eeh_slot_resets=%ld\n",
1093 1094 1095 1096
				no_device, no_dn, no_cfg_addr, 
				ignored_check, total_mmio_ffs, 
				false_positives, ignored_failures, 
				slot_resets);
L
Linus Torvalds 已提交
1097 1098 1099 1100 1101 1102 1103 1104 1105 1106
	}

	return 0;
}

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

1107
static const struct file_operations proc_eeh_operations = {
L
Linus Torvalds 已提交
1108 1109 1110 1111 1112 1113 1114 1115 1116 1117
	.open      = proc_eeh_open,
	.read      = seq_read,
	.llseek    = seq_lseek,
	.release   = single_release,
};

static int __init eeh_init_proc(void)
{
	struct proc_dir_entry *e;

1118
	if (machine_is(pseries)) {
L
Linus Torvalds 已提交
1119 1120 1121 1122 1123 1124 1125 1126
		e = create_proc_entry("ppc64/eeh", 0, NULL);
		if (e)
			e->proc_fops = &proc_eeh_operations;
	}

	return 0;
}
__initcall(eeh_init_proc);