eeh.c 31.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	2100000
L
Linus Torvalds 已提交
78

79 80 81
/* Time to wait for a PCI slot to retport status, in milliseconds */
#define PCI_BUS_RESET_WAIT_MSEC (60*1000)

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

92 93
int eeh_subsystem_enabled;
EXPORT_SYMBOL(eeh_subsystem_enabled);
L
Linus Torvalds 已提交
94

95 96 97
/* Lock to avoid races due to multiple reports of an error */
static DEFINE_SPINLOCK(confirm_error_lock);

L
Linus Torvalds 已提交
98 99 100 101 102 103
/* 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 */
104 105 106 107 108 109 110 111
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 已提交
112

113 114
#define IS_BRIDGE(class_code) (((class_code)<<16) == PCI_BASE_CLASS_BRIDGE)

L
Linus Torvalds 已提交
115
/* --------------------------------------------------------------- */
116
/* Below lies the EEH event infrastructure */
L
Linus Torvalds 已提交
117

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

128 129 130 131 132
	/* 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;

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

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

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

174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222
/**
 * 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 */

		if (max_wait_msecs <= 0) return -1;

		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 已提交
223 224
/**
 * eeh_token_to_phys - convert EEH address token to phys address
L
Linas Vepstas 已提交
225
 * @token i/o token, should be address in the form 0xA....
L
Linus Torvalds 已提交
226 227 228 229 230 231
 */
static inline unsigned long eeh_token_to_phys(unsigned long token)
{
	pte_t *ptep;
	unsigned long pa;

D
David Gibson 已提交
232
	ptep = find_linux_pte(init_mm.pgd, token);
L
Linus Torvalds 已提交
233 234 235 236 237 238 239
	if (!ptep)
		return token;
	pa = pte_pfn(*ptep) << PAGE_SHIFT;

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

240 241 242
/** 
 * Return the "partitionable endpoint" (pe) under which this device lies
 */
243
struct device_node * find_device_pe(struct device_node *dn)
244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259
{
	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 已提交
260
static void __eeh_mark_slot (struct device_node *dn, int mode_flag)
261 262
{
	while (dn) {
L
Linas Vepstas 已提交
263
		if (PCI_DN(dn)) {
264 265
			/* Mark the pci device driver too */
			struct pci_dev *dev = PCI_DN(dn)->pcidev;
266 267 268

			PCI_DN(dn)->eeh_mode |= mode_flag;

269 270 271
			if (dev && dev->driver)
				dev->error_state = pci_channel_io_frozen;

L
Linas Vepstas 已提交
272 273 274
			if (dn->child)
				__eeh_mark_slot (dn->child, mode_flag);
		}
275 276 277 278
		dn = dn->sibling;
	}
}

L
Linas Vepstas 已提交
279 280
void eeh_mark_slot (struct device_node *dn, int mode_flag)
{
281
	struct pci_dev *dev;
L
Linas Vepstas 已提交
282
	dn = find_device_pe (dn);
283 284

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

L
Linas Vepstas 已提交
288
	PCI_DN(dn)->eeh_mode |= mode_flag;
289 290 291 292 293 294

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

L
Linas Vepstas 已提交
295 296 297 298
	__eeh_mark_slot (dn->child, mode_flag);
}

static void __eeh_clear_slot (struct device_node *dn, int mode_flag)
299 300
{
	while (dn) {
L
Linas Vepstas 已提交
301 302 303 304 305 306
		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);
		}
307 308 309 310
		dn = dn->sibling;
	}
}

L
Linas Vepstas 已提交
311
void eeh_clear_slot (struct device_node *dn, int mode_flag)
312 313 314
{
	unsigned long flags;
	spin_lock_irqsave(&confirm_error_lock, flags);
315
	
L
Linas Vepstas 已提交
316
	dn = find_device_pe (dn);
317 318
	
	/* Back up one, since config addrs might be shared */
319
	if (!pcibios_find_pci_bus(dn) && PCI_DN(dn->parent))
320 321
		dn = dn->parent;

L
Linas Vepstas 已提交
322 323 324
	PCI_DN(dn)->eeh_mode &= ~mode_flag;
	PCI_DN(dn)->eeh_check_count = 0;
	__eeh_clear_slot (dn->child, mode_flag);
325 326 327
	spin_unlock_irqrestore(&confirm_error_lock, flags);
}

L
Linus Torvalds 已提交
328 329 330 331 332 333 334 335 336 337 338
/**
 * 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 已提交
339
 * a non-zero value and queues up a slot isolation event notification.
L
Linus Torvalds 已提交
340 341 342 343 344 345 346 347
 *
 * 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;
348
	struct pci_dn *pdn;
349
	int rc = 0;
L
Linus Torvalds 已提交
350

351
	total_mmio_ffs++;
L
Linus Torvalds 已提交
352 353 354 355

	if (!eeh_subsystem_enabled)
		return 0;

356
	if (!dn) {
357
		no_dn++;
L
Linus Torvalds 已提交
358
		return 0;
359
	}
L
Linas Vepstas 已提交
360
	pdn = PCI_DN(dn);
L
Linus Torvalds 已提交
361 362

	/* Access to IO BARs might get this far and still not want checking. */
363
	if (!(pdn->eeh_mode & EEH_MODE_SUPPORTED) ||
364
	    pdn->eeh_mode & EEH_MODE_NOCHECK) {
365
		ignored_check++;
366
#ifdef DEBUG
367 368
		printk ("EEH:ignored check (%x) for %s %s\n", 
		        pdn->eeh_mode, pci_name (dev), dn->full_name);
369
#endif
L
Linus Torvalds 已提交
370 371 372
		return 0;
	}

373
	if (!pdn->eeh_config_addr && !pdn->eeh_pe_config_addr) {
374
		no_cfg_addr++;
L
Linus Torvalds 已提交
375 376 377
		return 0;
	}

378 379 380 381 382
	/* 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 已提交
383
	 */
384 385
	spin_lock_irqsave(&confirm_error_lock, flags);
	rc = 1;
386
	if (pdn->eeh_mode & EEH_MODE_ISOLATED) {
387 388 389 390 391
		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 已提交
392
			msleep(5000);
393
			
L
Linus Torvalds 已提交
394
			/* re-read the slot reset state */
L
Linas Vepstas 已提交
395
			if (read_slot_reset_state(pdn, rets) != 0)
L
Linus Torvalds 已提交
396
				rets[0] = -1;	/* reset state unknown */
397 398 399

			/* 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 已提交
400
		}
401
		goto dn_unlock;
L
Linus Torvalds 已提交
402 403 404 405 406 407 408 409 410
	}

	/*
	 * 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 已提交
411
	ret = read_slot_reset_state(pdn, rets);
412 413 414 415 416

	/* 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);
417
		false_positives++;
418 419
		rc = 0;
		goto dn_unlock;
420 421
	}

422 423 424 425 426 427 428 429
	/* 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;
	}

430 431 432 433
	/* 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);
434
		false_positives++;
435 436
		rc = 0;
		goto dn_unlock;
437 438 439
	}

	/* If not the kind of error we know about, punt. */
440
	if (rets[0] != 1 && rets[0] != 2 && rets[0] != 4 && rets[0] != 5) {
441
		false_positives++;
442 443
		rc = 0;
		goto dn_unlock;
444 445
	}

446
	slot_resets++;
447 448 449 450
 
	/* Avoid repeated reports of this failure, including problems
	 * with other functions on this device, and functions under
	 * bridges. */
L
Linas Vepstas 已提交
451
	eeh_mark_slot (dn, EEH_MODE_ISOLATED);
452
	spin_unlock_irqrestore(&confirm_error_lock, flags);
L
Linus Torvalds 已提交
453

L
Linas Vepstas 已提交
454
	eeh_send_failure_event (dn, dev);
455

L
Linus Torvalds 已提交
456 457 458
	/* 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. */
459
	dump_stack();
460 461 462 463 464
	return 1;

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

467
EXPORT_SYMBOL_GPL(eeh_dn_check_failure);
L
Linus Torvalds 已提交
468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489

/**
 * 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);
490
	if (!dev) {
491
		no_device++;
L
Linus Torvalds 已提交
492
		return val;
493
	}
L
Linus Torvalds 已提交
494 495 496 497 498 499 500 501 502 503

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

	pci_dev_put(dev);
	return val;
}

EXPORT_SYMBOL(eeh_check_failure);

504 505 506
/* ------------------------------------------------------------- */
/* The code below deals with error recovery */

507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529
/**
 * 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)
530
		printk(KERN_WARNING "EEH: Unexpected state change %d, err=%d dn=%s\n",
531 532
		        function, rc, pdn->node->full_name);

533 534 535 536
	rc = eeh_wait_for_slot_status (pdn, PCI_BUS_RESET_WAIT_MSEC);
	if ((rc == 4) && (function == EEH_THAW_MMIO))
		return 0;

537 538 539
	return rc;
}

540 541 542 543
/**
 * rtas_pci_slot_reset - raises/lowers the pci #RST line
 * @pdn pci device node
 * @state: 1/0 to raise/lower the #RST
544 545 546 547 548 549 550 551 552 553 554
 *
 * 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)
{
555
	int config_addr;
556 557 558 559 560 561 562 563 564 565
	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;
	}

566 567 568 569 570
	/* 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;

571
	rc = rtas_call(ibm_set_slot_reset,4,1, NULL,
572
	               config_addr,
573 574 575
	               BUID_HI(pdn->phb->buid),
	               BUID_LO(pdn->phb->buid),
	               state);
576 577 578
	if (rc)
		printk (KERN_WARNING "EEH: Unable to reset the failed slot,"
		        " (%d) #RST=%d dn=%s\n",
579 580 581
		        rc, state, pdn->node->full_name);
}

582 583 584
/**
 * rtas_set_slot_reset -- assert the pci #RST line for 1/4 second
 * @pdn: pci device node to be reset.
585 586
 *
 *  Return 0 if success, else a non-zero value.
587 588
 */

589
static void __rtas_set_slot_reset(struct pci_dn *pdn)
590 591 592 593 594 595 596 597
{
	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 已提交
598 599 600 601 602 603
	
	/* 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);

604 605 606 607 608 609 610
	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);
611 612 613 614 615 616
}

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

617 618 619
	/* Take three shots at resetting the bus */
	for (i=0; i<3; i++) {
		__rtas_set_slot_reset(pdn);
620

621
		rc = eeh_wait_for_slot_status(pdn, PCI_BUS_RESET_WAIT_MSEC);
622 623
		if (rc == 0)
			return 0;
624 625 626 627

		if (rc < 0) {
			printk (KERN_ERR "EEH: unrecoverable slot failure %s\n",
			        pdn->node->full_name);
628
			return -1;
629
		}
630 631
		printk (KERN_ERR "EEH: bus reset %d failed on slot %s\n",
		        i+1, pdn->node->full_name);
632
	}
633

634
	return -1;
635 636
}

637 638 639 640 641 642 643 644 645 646 647
/* ------------------------------------------------------- */
/** 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
648 649
 * @pdn: pci device node
 *
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 685 686 687 688 689 690
 * 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;
	
691
	if ((pdn->eeh_mode & EEH_MODE_SUPPORTED) && !IS_BRIDGE(pdn->class_code))
692 693 694 695 696 697 698 699 700 701 702 703 704 705 706 707 708
		__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.
 */
709
static void eeh_save_bars(struct pci_dn *pdn)
710 711 712
{
	int i;

713
	if (!pdn )
714 715 716
		return;
	
	for (i = 0; i < 16; i++)
717
		rtas_read_config(pdn, i * 4, 4, &pdn->config_space[i]);
718 719 720 721 722
}

void
rtas_configure_bridge(struct pci_dn *pdn)
{
723
	int config_addr;
724 725
	int rc;

726 727 728 729 730
	/* 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;

731
	rc = rtas_call(ibm_configure_bridge,3,1, NULL,
732
	               config_addr,
733 734 735 736 737 738 739 740
	               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);
	}
}

741 742 743 744 745 746 747 748
/* ------------------------------------------------------------- */
/* 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 已提交
749 750 751 752 753
struct eeh_early_enable_info {
	unsigned int buid_hi;
	unsigned int buid_lo;
};

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 780 781 782 783 784 785
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 已提交
786 787 788
/* Enable eeh for the given device node. */
static void *early_enable_eeh(struct device_node *dn, void *data)
{
789
	unsigned int rets[3];
L
Linus Torvalds 已提交
790 791
	struct eeh_early_enable_info *info = data;
	int ret;
792 793 794 795
	const char *status = of_get_property(dn, "status", NULL);
	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);
796
	const u32 *regs;
L
Linus Torvalds 已提交
797
	int enable;
L
Linas Vepstas 已提交
798
	struct pci_dn *pdn = PCI_DN(dn);
L
Linus Torvalds 已提交
799

800
	pdn->class_code = 0;
801
	pdn->eeh_mode = 0;
802 803
	pdn->eeh_check_count = 0;
	pdn->eeh_freeze_count = 0;
L
Linus Torvalds 已提交
804 805 806 807 808 809 810 811 812 813

	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")) {
814
		pdn->eeh_mode |= EEH_MODE_NOCHECK;
L
Linus Torvalds 已提交
815 816
		return NULL;
	}
817
	pdn->class_code = *class_code;
L
Linus Torvalds 已提交
818 819 820 821 822 823 824 825 826 827

	/*
	 * 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 */
828
#if 0
L
Linus Torvalds 已提交
829 830
	if ((*class_code >> 16) == PCI_BASE_CLASS_DISPLAY)
		enable = 0;
831
#endif
L
Linus Torvalds 已提交
832 833

	if (!enable)
834
		pdn->eeh_mode |= EEH_MODE_NOCHECK;
L
Linus Torvalds 已提交
835 836 837

	/* 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. */
838
	regs = of_get_property(dn, "reg", NULL);
L
Linus Torvalds 已提交
839 840 841 842
	if (regs) {
		/* First register entry is addr (00BBSS00)  */
		/* Try to enable eeh */
		ret = rtas_call(ibm_set_eeh_option, 4, 1, NULL,
843 844 845
		                regs[0], info->buid_hi, info->buid_lo,
		                EEH_ENABLE);

846
		enable = 0;
L
Linus Torvalds 已提交
847
		if (ret == 0) {
848
			pdn->eeh_config_addr = regs[0];
849 850 851

			/* If the newer, better, ibm,get-config-addr-info is supported, 
			 * then use that instead. */
852
			pdn->eeh_pe_config_addr = get_pe_addr(pdn->eeh_config_addr, info);
853 854 855 856 857 858 859 860 861 862 863 864 865 866

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

888
	eeh_save_bars(pdn);
L
Linas Vepstas 已提交
889
	return NULL;
L
Linus Torvalds 已提交
890 891 892 893 894 895 896 897 898 899 900 901 902 903 904 905 906 907 908 909
}

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

910
	spin_lock_init(&confirm_error_lock);
911 912
	spin_lock_init(&slot_errbuf_lock);

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

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

L
Linas Vepstas 已提交
976
	if (!dn || !PCI_DN(dn))
L
Linus Torvalds 已提交
977
		return;
978
	phb = PCI_DN(dn)->phb;
979 980 981

	/* USB Bus children of PCI devices will not have BUID's */
	if (NULL == phb || 0 == phb->buid)
L
Linus Torvalds 已提交
982 983 984 985 986 987 988
		return;

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

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

L
Linus Torvalds 已提交
1010 1011 1012 1013
	if (!dev || !eeh_subsystem_enabled)
		return;

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

1017 1018
	pci_dev_get (dev);
	dn = pci_device_to_OF_node(dev);
1019 1020
	pdn = PCI_DN(dn);
	pdn->pcidev = dev;
1021

L
Linus Torvalds 已提交
1022 1023
	pci_addr_cache_insert_device (dev);
}
1024 1025 1026 1027 1028 1029 1030 1031 1032 1033 1034 1035 1036 1037 1038

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 已提交
1039 1040 1041 1042 1043

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

	/* Unregister the device with the EEH/PCI address search system */
#ifdef DEBUG
1058
	printk(KERN_DEBUG "EEH: remove device %s\n", pci_name(dev));
L
Linus Torvalds 已提交
1059 1060
#endif
	pci_addr_cache_remove_device(dev);
1061 1062

	dn = pci_device_to_OF_node(dev);
1063 1064 1065 1066
	if (PCI_DN(dn)->pcidev) {
		PCI_DN(dn)->pcidev = NULL;
		pci_dev_put (dev);
	}
L
Linus Torvalds 已提交
1067 1068
}

1069 1070
void eeh_remove_bus_device(struct pci_dev *dev)
{
1071 1072 1073
	struct pci_bus *bus = dev->subordinate;
	struct pci_dev *child, *tmp;

1074
	eeh_remove_device(dev);
1075 1076 1077 1078

	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);
1079 1080 1081 1082
	}
}
EXPORT_SYMBOL_GPL(eeh_remove_bus_device);

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

	return 0;
}

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

1113
static const struct file_operations proc_eeh_operations = {
L
Linus Torvalds 已提交
1114 1115 1116 1117 1118 1119 1120 1121 1122 1123
	.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;

1124
	if (machine_is(pseries)) {
L
Linus Torvalds 已提交
1125 1126 1127 1128 1129 1130 1131 1132
		e = create_proc_entry("ppc64/eeh", 0, NULL);
		if (e)
			e->proc_fops = &proc_eeh_operations;
	}

	return 0;
}
__initcall(eeh_init_proc);