eeh.c 30.7 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	100000
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_configure_bridge;
L
Linus Torvalds 已提交
87

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

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

L
Linus Torvalds 已提交
94 95 96 97 98 99
/* 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 */
100 101 102 103 104 105 106 107
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 已提交
108

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

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

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

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

129
	rc = rtas_call(ibm_slot_error_detail,
130
	               8, 1, NULL, config_addr,
131 132 133 134 135 136 137 138 139 140 141
	               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 已提交
142 143 144 145 146
/**
 * 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 已提交
147
static int read_slot_reset_state(struct pci_dn *pdn, int rets[])
L
Linus Torvalds 已提交
148 149
{
	int token, outputs;
150
	int config_addr;
L
Linus Torvalds 已提交
151 152 153 154 155 156

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

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

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

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

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

187 188 189
/** 
 * Return the "partitionable endpoint" (pe) under which this device lies
 */
190
struct device_node * find_device_pe(struct device_node *dn)
191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206
{
	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 已提交
207
static void __eeh_mark_slot (struct device_node *dn, int mode_flag)
208 209
{
	while (dn) {
L
Linas Vepstas 已提交
210
		if (PCI_DN(dn)) {
211 212
			/* Mark the pci device driver too */
			struct pci_dev *dev = PCI_DN(dn)->pcidev;
213 214 215

			PCI_DN(dn)->eeh_mode |= mode_flag;

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

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

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

	/* 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 已提交
235
	PCI_DN(dn)->eeh_mode |= mode_flag;
236 237 238 239 240 241

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

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

static void __eeh_clear_slot (struct device_node *dn, int mode_flag)
246 247
{
	while (dn) {
L
Linas Vepstas 已提交
248 249 250 251 252 253
		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);
		}
254 255 256 257
		dn = dn->sibling;
	}
}

L
Linas Vepstas 已提交
258
void eeh_clear_slot (struct device_node *dn, int mode_flag)
259 260 261
{
	unsigned long flags;
	spin_lock_irqsave(&confirm_error_lock, flags);
262
	
L
Linas Vepstas 已提交
263
	dn = find_device_pe (dn);
264 265 266 267 268
	
	/* 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 已提交
269 270 271
	PCI_DN(dn)->eeh_mode &= ~mode_flag;
	PCI_DN(dn)->eeh_check_count = 0;
	__eeh_clear_slot (dn->child, mode_flag);
272 273 274
	spin_unlock_irqrestore(&confirm_error_lock, flags);
}

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

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

	if (!eeh_subsystem_enabled)
		return 0;

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

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

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

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

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

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

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

	/* 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);
374
		false_positives++;
375 376
		rc = 0;
		goto dn_unlock;
377 378 379 380
	}

	/* If not the kind of error we know about, punt. */
	if (rets[0] != 2 && rets[0] != 4 && rets[0] != 5) {
381
		false_positives++;
382 383
		rc = 0;
		goto dn_unlock;
384 385 386 387 388
	}

	/* Note that config-io to empty slots may fail;
	 * we recognize empty because they don't have children. */
	if ((rets[0] == 5) && (dn->child == NULL)) {
389
		false_positives++;
390 391
		rc = 0;
		goto dn_unlock;
L
Linus Torvalds 已提交
392 393
	}

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

402 403 404 405 406 407 408
	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 已提交
409 410 411
	/* 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. */
412
	if (rets[0] != 5) dump_stack();
413 414 415 416 417
	return 1;

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

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

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

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

	pci_dev_put(dev);
	return val;
}

EXPORT_SYMBOL(eeh_check_failure);

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

460 461 462 463 464
/**
 * eeh_slot_availability - returns error status of slot
 * @pdn pci device node
 *
 * Return negative value if a permanent error, else return
465 466 467 468 469 470 471 472 473 474 475 476 477 478
 * 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 */
479
	if (rets[0] == 0) return 0;   /* Oll Korrect */
480 481 482 483
	if (rets[0] == 5) {
		if (rets[2] == 0) return -1; /* permanently unavailable */
		return rets[2]; /* number of millisecs to wait */
	}
484 485 486 487 488
	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]);
489
	return -2;
490 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
/**
 * 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;
}

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

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

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

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

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

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

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

	__rtas_set_slot_reset(pdn);
599 600 601 602 603

	/* 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);
604 605
		if (rc == 0)
			return 0;
606 607 608 609 610 611 612 613 614 615 616

		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);
617
			return -1;
618
		}
619 620 621

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

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

	return rc;
628 629
}

630 631 632 633 634 635 636 637 638 639 640
/* ------------------------------------------------------- */
/** 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
641 642
 * @pdn: pci device node
 *
643 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
 * 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;
	
684
	if ((pdn->eeh_mode & EEH_MODE_SUPPORTED) && !IS_BRIDGE(pdn->class_code))
685 686 687 688 689 690 691 692 693 694 695 696 697 698 699 700 701
		__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.
 */
702
static void eeh_save_bars(struct pci_dn *pdn)
703 704 705
{
	int i;

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

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

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

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

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

/* Enable eeh for the given device node. */
static void *early_enable_eeh(struct device_node *dn, void *data)
{
750
	unsigned int rets[3];
L
Linus Torvalds 已提交
751 752
	struct eeh_early_enable_info *info = data;
	int ret;
753 754 755 756 757
	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 已提交
758
	int enable;
L
Linas Vepstas 已提交
759
	struct pci_dn *pdn = PCI_DN(dn);
L
Linus Torvalds 已提交
760

761
	pdn->class_code = 0;
762
	pdn->eeh_mode = 0;
763 764
	pdn->eeh_check_count = 0;
	pdn->eeh_freeze_count = 0;
L
Linus Torvalds 已提交
765 766 767 768 769 770 771 772 773 774

	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")) {
775
		pdn->eeh_mode |= EEH_MODE_NOCHECK;
L
Linus Torvalds 已提交
776 777
		return NULL;
	}
778
	pdn->class_code = *class_code;
L
Linus Torvalds 已提交
779 780 781 782 783 784 785 786 787 788

	/*
	 * 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 */
789
#if 0
L
Linus Torvalds 已提交
790 791
	if ((*class_code >> 16) == PCI_BASE_CLASS_DISPLAY)
		enable = 0;
792
#endif
L
Linus Torvalds 已提交
793 794

	if (!enable)
795
		pdn->eeh_mode |= EEH_MODE_NOCHECK;
L
Linus Torvalds 已提交
796 797 798

	/* 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. */
799
	regs = get_property(dn, "reg", NULL);
L
Linus Torvalds 已提交
800 801 802 803
	if (regs) {
		/* First register entry is addr (00BBSS00)  */
		/* Try to enable eeh */
		ret = rtas_call(ibm_set_eeh_option, 4, 1, NULL,
804 805 806
		                regs[0], info->buid_hi, info->buid_lo,
		                EEH_ENABLE);

807
		enable = 0;
L
Linus Torvalds 已提交
808
		if (ret == 0) {
809
			pdn->eeh_config_addr = regs[0];
810 811 812 813 814 815 816 817 818 819 820 821

			/* If the newer, better, ibm,get-config-addr-info is supported, 
			 * then use that instead. */
			pdn->eeh_pe_config_addr = 0;
			if (ibm_get_config_addr_info != RTAS_UNKNOWN_SERVICE) {
				ret = rtas_call (ibm_get_config_addr_info, 4, 2, rets, 
					pdn->eeh_config_addr, 
					info->buid_hi, info->buid_lo,
					0);
				if (ret == 0)
					pdn->eeh_pe_config_addr = rets[0];
			}
822 823 824 825 826 827 828 829 830 831 832 833 834 835

			/* 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 已提交
836
#ifdef DEBUG
837 838
			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 已提交
839 840 841 842 843
#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 已提交
844
			if (dn->parent && PCI_DN(dn->parent)
845
			    && (PCI_DN(dn->parent)->eeh_mode & EEH_MODE_SUPPORTED)) {
L
Linus Torvalds 已提交
846
				/* Parent supports EEH. */
847 848
				pdn->eeh_mode |= EEH_MODE_SUPPORTED;
				pdn->eeh_config_addr = PCI_DN(dn->parent)->eeh_config_addr;
L
Linus Torvalds 已提交
849 850 851 852 853 854 855 856
				return NULL;
			}
		}
	} else {
		printk(KERN_WARNING "EEH: %s: unable to get reg property.\n",
		       dn->full_name);
	}

857
	eeh_save_bars(pdn);
L
Linas Vepstas 已提交
858
	return NULL;
L
Linus Torvalds 已提交
859 860 861 862 863 864 865 866 867 868 869 870 871 872 873 874 875 876 877 878
}

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

879
	spin_lock_init(&confirm_error_lock);
880 881
	spin_lock_init(&slot_errbuf_lock);

L
Linus Torvalds 已提交
882 883 884 885 886 887 888 889 890
	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");
891
	ibm_get_config_addr_info = rtas_token("ibm,get-config-addr-info");
892
	ibm_configure_bridge = rtas_token ("ibm,configure-bridge");
L
Linus Torvalds 已提交
893 894 895 896 897 898 899 900 901 902 903 904 905 906 907 908 909 910 911 912

	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 已提交
913
		if (buid == 0 || PCI_DN(phb) == NULL)
L
Linus Torvalds 已提交
914 915 916 917 918 919 920 921 922 923 924 925 926 927 928 929 930 931 932 933 934 935 936 937 938
			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.
 */
939
static void eeh_add_device_early(struct device_node *dn)
L
Linus Torvalds 已提交
940 941 942 943
{
	struct pci_controller *phb;
	struct eeh_early_enable_info info;

L
Linas Vepstas 已提交
944
	if (!dn || !PCI_DN(dn))
L
Linus Torvalds 已提交
945
		return;
946
	phb = PCI_DN(dn)->phb;
947 948 949

	/* USB Bus children of PCI devices will not have BUID's */
	if (NULL == phb || 0 == phb->buid)
L
Linus Torvalds 已提交
950 951 952 953 954 955 956
		return;

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

957 958 959 960 961 962 963 964 965
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 已提交
966 967 968 969 970 971 972
/**
 * 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).
 */
973
static void eeh_add_device_late(struct pci_dev *dev)
L
Linus Torvalds 已提交
974
{
975
	struct device_node *dn;
976
	struct pci_dn *pdn;
977

L
Linus Torvalds 已提交
978 979 980 981
	if (!dev || !eeh_subsystem_enabled)
		return;

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

985 986
	pci_dev_get (dev);
	dn = pci_device_to_OF_node(dev);
987 988
	pdn = PCI_DN(dn);
	pdn->pcidev = dev;
989

L
Linus Torvalds 已提交
990 991
	pci_addr_cache_insert_device (dev);
}
992 993 994 995 996 997 998 999 1000 1001 1002 1003 1004 1005 1006

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 已提交
1007 1008 1009 1010 1011

/**
 * eeh_remove_device - undo EEH setup for the indicated pci device
 * @dev: pci device to be removed
 *
1012 1013 1014 1015 1016
 * 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 已提交
1017
 */
1018
static void eeh_remove_device(struct pci_dev *dev)
L
Linus Torvalds 已提交
1019
{
1020
	struct device_node *dn;
L
Linus Torvalds 已提交
1021 1022 1023 1024 1025
	if (!dev || !eeh_subsystem_enabled)
		return;

	/* Unregister the device with the EEH/PCI address search system */
#ifdef DEBUG
1026
	printk(KERN_DEBUG "EEH: remove device %s\n", pci_name(dev));
L
Linus Torvalds 已提交
1027 1028
#endif
	pci_addr_cache_remove_device(dev);
1029 1030

	dn = pci_device_to_OF_node(dev);
1031 1032 1033 1034
	if (PCI_DN(dn)->pcidev) {
		PCI_DN(dn)->pcidev = NULL;
		pci_dev_put (dev);
	}
L
Linus Torvalds 已提交
1035 1036
}

1037 1038
void eeh_remove_bus_device(struct pci_dev *dev)
{
1039 1040 1041
	struct pci_bus *bus = dev->subordinate;
	struct pci_dev *child, *tmp;

1042
	eeh_remove_device(dev);
1043 1044 1045 1046

	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);
1047 1048 1049 1050
	}
}
EXPORT_SYMBOL_GPL(eeh_remove_bus_device);

L
Linus Torvalds 已提交
1051 1052 1053 1054
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");
1055
		seq_printf(m, "eeh_total_mmio_ffs=%ld\n", total_mmio_ffs);
L
Linus Torvalds 已提交
1056 1057
	} else {
		seq_printf(m, "EEH Subsystem is enabled\n");
1058 1059 1060 1061 1062 1063 1064 1065 1066
		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",
1067 1068 1069 1070
				no_device, no_dn, no_cfg_addr, 
				ignored_check, total_mmio_ffs, 
				false_positives, ignored_failures, 
				slot_resets);
L
Linus Torvalds 已提交
1071 1072 1073 1074 1075 1076 1077 1078 1079 1080 1081 1082 1083 1084 1085 1086 1087 1088 1089 1090 1091
	}

	return 0;
}

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

static struct file_operations proc_eeh_operations = {
	.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;

1092
	if (machine_is(pseries)) {
L
Linus Torvalds 已提交
1093 1094 1095 1096 1097 1098 1099 1100
		e = create_proc_entry("ppc64/eeh", 0, NULL);
		if (e)
			e->proc_fops = &proc_eeh_operations;
	}

	return 0;
}
__initcall(eeh_init_proc);