eeh.c 28.8 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 211
		if (PCI_DN(dn)) {
			PCI_DN(dn)->eeh_mode |= mode_flag;
212

213 214 215 216 217
			/* Mark the pci device driver too */
			struct pci_dev *dev = PCI_DN(dn)->pcidev;
			if (dev && dev->driver)
				dev->error_state = pci_channel_io_frozen;

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

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

	/* 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 已提交
233 234 235 236 237
	PCI_DN(dn)->eeh_mode |= mode_flag;
	__eeh_mark_slot (dn->child, mode_flag);
}

static void __eeh_clear_slot (struct device_node *dn, int mode_flag)
238 239
{
	while (dn) {
L
Linas Vepstas 已提交
240 241 242 243 244 245
		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);
		}
246 247 248 249
		dn = dn->sibling;
	}
}

L
Linas Vepstas 已提交
250
void eeh_clear_slot (struct device_node *dn, int mode_flag)
251 252 253
{
	unsigned long flags;
	spin_lock_irqsave(&confirm_error_lock, flags);
254
	
L
Linas Vepstas 已提交
255
	dn = find_device_pe (dn);
256 257 258 259 260
	
	/* 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 已提交
261 262 263
	PCI_DN(dn)->eeh_mode &= ~mode_flag;
	PCI_DN(dn)->eeh_check_count = 0;
	__eeh_clear_slot (dn->child, mode_flag);
264 265 266
	spin_unlock_irqrestore(&confirm_error_lock, flags);
}

L
Linus Torvalds 已提交
267 268 269 270 271 272 273 274 275 276 277
/**
 * 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 已提交
278
 * a non-zero value and queues up a slot isolation event notification.
L
Linus Torvalds 已提交
279 280 281 282 283 284 285 286
 *
 * 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;
287
	struct pci_dn *pdn;
288
	enum pci_channel_state state;
289
	int rc = 0;
L
Linus Torvalds 已提交
290

291
	total_mmio_ffs++;
L
Linus Torvalds 已提交
292 293 294 295

	if (!eeh_subsystem_enabled)
		return 0;

296
	if (!dn) {
297
		no_dn++;
L
Linus Torvalds 已提交
298
		return 0;
299
	}
L
Linas Vepstas 已提交
300
	pdn = PCI_DN(dn);
L
Linus Torvalds 已提交
301 302

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

313
	if (!pdn->eeh_config_addr && !pdn->eeh_pe_config_addr) {
314
		no_cfg_addr++;
L
Linus Torvalds 已提交
315 316 317
		return 0;
	}

318 319 320 321 322
	/* 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 已提交
323
	 */
324 325
	spin_lock_irqsave(&confirm_error_lock, flags);
	rc = 1;
326
	if (pdn->eeh_mode & EEH_MODE_ISOLATED) {
327 328 329 330 331 332
		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
Linus Torvalds 已提交
333
			/* re-read the slot reset state */
L
Linas Vepstas 已提交
334
			if (read_slot_reset_state(pdn, rets) != 0)
L
Linus Torvalds 已提交
335
				rets[0] = -1;	/* reset state unknown */
336 337 338

			/* 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 已提交
339
		}
340
		goto dn_unlock;
L
Linus Torvalds 已提交
341 342 343 344 345 346 347 348 349
	}

	/*
	 * 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 已提交
350
	ret = read_slot_reset_state(pdn, rets);
351 352 353 354 355

	/* 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);
356
		false_positives++;
357 358
		rc = 0;
		goto dn_unlock;
359 360 361 362 363 364
	}

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

	/* If not the kind of error we know about, punt. */
	if (rets[0] != 2 && rets[0] != 4 && rets[0] != 5) {
372
		false_positives++;
373 374
		rc = 0;
		goto dn_unlock;
375 376 377 378 379
	}

	/* 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)) {
380
		false_positives++;
381 382
		rc = 0;
		goto dn_unlock;
L
Linus Torvalds 已提交
383 384
	}

385
	slot_resets++;
386 387 388 389
 
	/* Avoid repeated reports of this failure, including problems
	 * with other functions on this device, and functions under
	 * bridges. */
L
Linas Vepstas 已提交
390
	eeh_mark_slot (dn, EEH_MODE_ISOLATED);
391
	spin_unlock_irqrestore(&confirm_error_lock, flags);
L
Linus Torvalds 已提交
392

393 394 395 396 397 398 399
	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 已提交
400 401 402
	/* 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. */
403
	if (rets[0] != 5) dump_stack();
404 405 406 407 408
	return 1;

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

411
EXPORT_SYMBOL_GPL(eeh_dn_check_failure);
L
Linus Torvalds 已提交
412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433

/**
 * 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);
434
	if (!dev) {
435
		no_device++;
L
Linus Torvalds 已提交
436
		return val;
437
	}
L
Linus Torvalds 已提交
438 439 440 441 442 443 444 445 446 447

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

	pci_dev_put(dev);
	return val;
}

EXPORT_SYMBOL(eeh_check_failure);

448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465
/* ------------------------------------------------------------- */
/* The code below deals with error recovery */

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

/** rtas_pci_slot_reset raises/lowers the pci #RST line
 *  state: 1/0 to raise/lower the #RST
 *
 * 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)
{
492
	int config_addr;
493 494 495 496 497 498 499 500 501 502
	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;
	}

503 504 505 506 507
	/* 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;

508
	rc = rtas_call(ibm_set_slot_reset,4,1, NULL,
509
	               config_addr,
510 511 512 513 514 515 516 517 518 519 520 521
	               BUID_HI(pdn->phb->buid),
	               BUID_LO(pdn->phb->buid),
	               state);
	if (rc) {
		printk (KERN_WARNING "EEH: Unable to reset the failed slot, (%d) #RST=%d dn=%s\n", 
		        rc, state, pdn->node->full_name);
		return;
	}
}

/** rtas_set_slot_reset -- assert the pci #RST line for 1/4 second
 *  dn -- device node to be reset.
522 523
 *
 *  Return 0 if success, else a non-zero value.
524 525
 */

526
int
527 528 529 530 531 532 533 534 535 536 537
rtas_set_slot_reset(struct pci_dn *pdn)
{
	int i, rc;

	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 已提交
538 539 540 541 542 543
	
	/* 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);

544 545 546 547 548 549 550 551 552 553 554 555
	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);

	/* 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);
556 557 558 559 560 561
		if (rc < 0)
			printk (KERN_ERR "EEH: failed (%d) to reset slot %s\n", rc, pdn->node->full_name);
		if (rc == 0)
			return 0;
		if (rc < 0)
			return -1;
562 563 564

		msleep (rc+100);
	}
565 566 567 568 569 570

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

	return rc;
571 572
}

573 574 575 576 577 578 579 580 581 582 583 584 585 586 587 588 589 590 591 592 593 594 595 596 597 598 599 600 601 602 603 604 605 606 607 608 609 610 611 612 613 614 615 616 617 618 619 620 621 622 623 624
/* ------------------------------------------------------- */
/** 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
 * 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;
	
625
	if ((pdn->eeh_mode & EEH_MODE_SUPPORTED) && !IS_BRIDGE(pdn->class_code))
626 627 628 629 630 631 632 633 634 635 636 637 638 639 640 641 642
		__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.
 */
643
static void eeh_save_bars(struct pci_dn *pdn)
644 645 646
{
	int i;

647
	if (!pdn )
648 649 650
		return;
	
	for (i = 0; i < 16; i++)
651
		rtas_read_config(pdn, i * 4, 4, &pdn->config_space[i]);
652 653 654 655 656
}

void
rtas_configure_bridge(struct pci_dn *pdn)
{
657
	int config_addr;
658 659
	int rc;

660 661 662 663 664
	/* 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;

665
	rc = rtas_call(ibm_configure_bridge,3,1, NULL,
666
	               config_addr,
667 668 669 670 671 672 673 674
	               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);
	}
}

675 676 677 678 679 680 681 682
/* ------------------------------------------------------------- */
/* 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 已提交
683 684 685 686 687 688 689 690 691 692 693 694 695 696 697 698
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)
{
	struct eeh_early_enable_info *info = data;
	int ret;
	char *status = get_property(dn, "status", NULL);
	u32 *class_code = (u32 *)get_property(dn, "class-code", NULL);
	u32 *vendor_id = (u32 *)get_property(dn, "vendor-id", NULL);
	u32 *device_id = (u32 *)get_property(dn, "device-id", NULL);
	u32 *regs;
	int enable;
L
Linas Vepstas 已提交
699
	struct pci_dn *pdn = PCI_DN(dn);
L
Linus Torvalds 已提交
700

701
	pdn->class_code = *class_code;
702
	pdn->eeh_mode = 0;
703 704
	pdn->eeh_check_count = 0;
	pdn->eeh_freeze_count = 0;
L
Linus Torvalds 已提交
705 706 707 708 709 710 711 712 713 714

	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")) {
715
		pdn->eeh_mode |= EEH_MODE_NOCHECK;
L
Linus Torvalds 已提交
716 717 718 719 720 721 722 723 724 725 726 727
		return NULL;
	}

	/*
	 * 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 */
728
#if 0
L
Linus Torvalds 已提交
729 730
	if ((*class_code >> 16) == PCI_BASE_CLASS_DISPLAY)
		enable = 0;
731
#endif
L
Linus Torvalds 已提交
732 733

	if (!enable)
734
		pdn->eeh_mode |= EEH_MODE_NOCHECK;
L
Linus Torvalds 已提交
735 736 737 738 739 740 741 742

	/* 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. */
	regs = (u32 *)get_property(dn, "reg", NULL);
	if (regs) {
		/* First register entry is addr (00BBSS00)  */
		/* Try to enable eeh */
		ret = rtas_call(ibm_set_eeh_option, 4, 1, NULL,
743 744 745
		                regs[0], info->buid_hi, info->buid_lo,
		                EEH_ENABLE);

L
Linus Torvalds 已提交
746 747
		if (ret == 0) {
			eeh_subsystem_enabled = 1;
748 749
			pdn->eeh_mode |= EEH_MODE_SUPPORTED;
			pdn->eeh_config_addr = regs[0];
750 751 752 753 754 755 756 757 758 759 760 761 762

			/* 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) {
				unsigned int rets[2];
				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];
			}
L
Linus Torvalds 已提交
763
#ifdef DEBUG
764 765
			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 已提交
766 767 768 769 770
#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 已提交
771
			if (dn->parent && PCI_DN(dn->parent)
772
			    && (PCI_DN(dn->parent)->eeh_mode & EEH_MODE_SUPPORTED)) {
L
Linus Torvalds 已提交
773
				/* Parent supports EEH. */
774 775
				pdn->eeh_mode |= EEH_MODE_SUPPORTED;
				pdn->eeh_config_addr = PCI_DN(dn->parent)->eeh_config_addr;
L
Linus Torvalds 已提交
776 777 778 779 780 781 782 783
				return NULL;
			}
		}
	} else {
		printk(KERN_WARNING "EEH: %s: unable to get reg property.\n",
		       dn->full_name);
	}

784
	eeh_save_bars(pdn);
L
Linas Vepstas 已提交
785
	return NULL;
L
Linus Torvalds 已提交
786 787 788 789 790 791 792 793 794 795 796 797 798 799 800 801 802 803 804 805
}

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

806
	spin_lock_init(&confirm_error_lock);
807 808
	spin_lock_init(&slot_errbuf_lock);

L
Linus Torvalds 已提交
809 810 811 812 813 814 815 816 817
	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");
818
	ibm_get_config_addr_info = rtas_token("ibm,get-config-addr-info");
819
	ibm_configure_bridge = rtas_token ("ibm,configure-bridge");
L
Linus Torvalds 已提交
820 821 822 823 824 825 826 827 828 829 830 831 832 833 834 835 836 837 838 839

	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 已提交
840
		if (buid == 0 || PCI_DN(phb) == NULL)
L
Linus Torvalds 已提交
841 842 843 844 845 846 847 848 849 850 851 852 853 854 855 856 857 858 859 860 861 862 863 864 865 866 867 868 869 870
			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.
 */
void eeh_add_device_early(struct device_node *dn)
{
	struct pci_controller *phb;
	struct eeh_early_enable_info info;

L
Linas Vepstas 已提交
871
	if (!dn || !PCI_DN(dn))
L
Linus Torvalds 已提交
872
		return;
873
	phb = PCI_DN(dn)->phb;
874 875 876

	/* USB Bus children of PCI devices will not have BUID's */
	if (NULL == phb || 0 == phb->buid)
L
Linus Torvalds 已提交
877 878 879 880 881 882
		return;

	info.buid_hi = BUID_HI(phb->buid);
	info.buid_lo = BUID_LO(phb->buid);
	early_enable_eeh(dn, &info);
}
883
EXPORT_SYMBOL_GPL(eeh_add_device_early);
L
Linus Torvalds 已提交
884

885 886 887 888 889 890 891 892 893
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 已提交
894 895 896 897 898 899 900 901 902
/**
 * 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).
 */
void eeh_add_device_late(struct pci_dev *dev)
{
903
	struct device_node *dn;
904
	struct pci_dn *pdn;
905

L
Linus Torvalds 已提交
906 907 908 909
	if (!dev || !eeh_subsystem_enabled)
		return;

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

913 914
	pci_dev_get (dev);
	dn = pci_device_to_OF_node(dev);
915 916
	pdn = PCI_DN(dn);
	pdn->pcidev = dev;
917

L
Linus Torvalds 已提交
918 919
	pci_addr_cache_insert_device (dev);
}
920
EXPORT_SYMBOL_GPL(eeh_add_device_late);
L
Linus Torvalds 已提交
921 922 923 924 925 926 927 928 929 930

/**
 * eeh_remove_device - undo EEH setup for the indicated pci device
 * @dev: pci device to be removed
 *
 * This routine should be when a device is removed from a running
 * system (e.g. by hotplug or dlpar).
 */
void eeh_remove_device(struct pci_dev *dev)
{
931
	struct device_node *dn;
L
Linus Torvalds 已提交
932 933 934 935 936
	if (!dev || !eeh_subsystem_enabled)
		return;

	/* Unregister the device with the EEH/PCI address search system */
#ifdef DEBUG
937
	printk(KERN_DEBUG "EEH: remove device %s\n", pci_name(dev));
L
Linus Torvalds 已提交
938 939
#endif
	pci_addr_cache_remove_device(dev);
940 941 942 943

	dn = pci_device_to_OF_node(dev);
	PCI_DN(dn)->pcidev = NULL;
	pci_dev_put (dev);
L
Linus Torvalds 已提交
944
}
945
EXPORT_SYMBOL_GPL(eeh_remove_device);
L
Linus Torvalds 已提交
946

947 948 949 950 951 952 953 954 955 956 957 958 959 960 961 962 963
void eeh_remove_bus_device(struct pci_dev *dev)
{
	eeh_remove_device(dev);
	if (dev->hdr_type == PCI_HEADER_TYPE_BRIDGE) {
		struct pci_bus *bus = dev->subordinate;
		struct list_head *ln;
		if (!bus)
			return; 
		for (ln = bus->devices.next; ln != &bus->devices; ln = ln->next) {
			struct pci_dev *pdev = pci_dev_b(ln);
			if (pdev)
				eeh_remove_bus_device(pdev);
		}
	}
}
EXPORT_SYMBOL_GPL(eeh_remove_bus_device);

L
Linus Torvalds 已提交
964 965 966 967
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");
968
		seq_printf(m, "eeh_total_mmio_ffs=%ld\n", total_mmio_ffs);
L
Linus Torvalds 已提交
969 970
	} else {
		seq_printf(m, "EEH Subsystem is enabled\n");
971 972 973 974 975 976 977 978 979
		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",
980 981 982 983
				no_device, no_dn, no_cfg_addr, 
				ignored_check, total_mmio_ffs, 
				false_positives, ignored_failures, 
				slot_resets);
L
Linus Torvalds 已提交
984 985 986 987 988 989 990 991 992 993 994 995 996 997 998 999 1000 1001 1002 1003 1004
	}

	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;

1005
	if (platform_is_pseries()) {
L
Linus Torvalds 已提交
1006 1007 1008 1009 1010 1011 1012 1013
		e = create_proc_entry("ppc64/eeh", 0, NULL);
		if (e)
			e->proc_fops = &proc_eeh_operations;
	}

	return 0;
}
__initcall(eeh_init_proc);