Subversion Repositories or1k

/* $Id: ioerror.h,v 1.1.1.1 2004-04-15 02:42:31 phoenix Exp $
 *
 * This file is subject to the terms and conditions of the GNU General Public
 * License.  See the file "COPYING" in the main directory of this archive
 * for more details.
 *
 * Copyright (C) 1992 - 1997, 2000-2003 Silicon Graphics, Inc. All rights reserved.
 */
#ifndef _ASM_IA64_SN_IOERROR_H
#define _ASM_IA64_SN_IOERROR_H
 
#ifndef __ASSEMBLY__
 
#include <linux/types.h>
#include <asm/sn/types.h>
 
/*
 * Macros defining the various Errors to be handled as part of
 * IO Error handling.
 */
 
/*
 * List of errors to be handled by each subsystem.
 * "error_code" field will take one of these values.
 * The error code is built up of single bits expressing
 * our confidence that the error was that type; note
 * that it is possible to have a PIO or DMA error where
 * we don't know whether it was a READ or a WRITE, or
 * even a READ or WRITE error that we're not sure whether
 * to call a PIO or DMA.
 *
 * It is also possible to set both PIO and DMA, and possible
 * to set both READ and WRITE; the first may be nonsensical
 * but the second *could* be used to designate an access
 * that is known to be a read-modify-write cycle. It is
 * quite possible that nobody will ever use PIO|DMA or
 * READ|WRITE ... but being flexible is good.
 */
#define	IOECODE_UNSPEC		0
#define	IOECODE_READ		1
#define	IOECODE_WRITE		2
#define	IOECODE_PIO		4
#define	IOECODE_DMA		8
 
#define	IOECODE_PIO_READ	(IOECODE_PIO|IOECODE_READ)
#define	IOECODE_PIO_WRITE	(IOECODE_PIO|IOECODE_WRITE)
#define	IOECODE_DMA_READ	(IOECODE_DMA|IOECODE_READ)
#define	IOECODE_DMA_WRITE	(IOECODE_DMA|IOECODE_WRITE)
 
/* support older names, but try to move everything
 * to using new names that identify which package
 * controls their values ...
 */
#define	PIO_READ_ERROR		IOECODE_PIO_READ
#define	PIO_WRITE_ERROR		IOECODE_PIO_WRITE
#define	DMA_READ_ERROR		IOECODE_DMA_READ
#define	DMA_WRITE_ERROR		IOECODE_DMA_WRITE
 
/*
 * List of error numbers returned by error handling sub-system.
 */
 
#define	IOERROR_HANDLED		0	/* Error Properly handled.        */
#define	IOERROR_NODEV		0x1	/* No such device attached        */
#define	IOERROR_BADHANDLE	0x2	/* Received bad handle            */
#define	IOERROR_BADWIDGETNUM	0x3	/* Bad widget number              */
#define	IOERROR_BADERRORCODE	0x4	/* Bad error code passed in       */
#define	IOERROR_INVALIDADDR	0x5	/* Invalid address specified      */
 
#define	IOERROR_WIDGETLEVEL	0x6	/* Some failure at widget level    */
#define	IOERROR_XTALKLEVEL	0x7
 
#define	IOERROR_HWGRAPH_LOOKUP	0x8	/* hwgraph lookup failed for path  */
#define	IOERROR_UNHANDLED	0x9	/* handler rejected error          */
 
#define	IOERROR_PANIC		0xA	/* subsidiary handler has already
					 * started decode: continue error
					 * data dump, and panic from top
					 * caller in error chain.
					 */
 
/*
 * IO errors at the bus/device driver level
 */
 
#define	IOERROR_DEV_NOTFOUND	0x10	/* Device matching bus addr not found */
#define	IOERROR_DEV_SHUTDOWN	0x11	/* Device has been shutdown        */
 
/*
 * Type of address.
 * Indicates the direction of transfer that caused the error.
 */
#define	IOERROR_ADDR_PIO	1	/* Error Address generated due to PIO */
#define	IOERROR_ADDR_DMA	2	/* Error address generated due to DMA */
 
/*
 * IO error structure.
 *
 * This structure would expand to hold the information retrieved from
 * all IO related error registers.
 *
 * This structure is defined to hold all system specific
 * information related to a single error.
 *
 * This serves a couple of purpose.
 *      - Error handling often involves translating one form of address to other
 *        form. So, instead of having different data structures at each level,
 *        we have a single structure, and the appropriate fields get filled in
 *        at each layer.
 *      - This provides a way to dump all error related information in any layer
 *        of erorr handling (debugging aid).
 *
 * A second possibility is to allow each layer to define its own error
 * data structure, and fill in the proper fields. This has the advantage
 * of isolating the layers.
 * A big concern is the potential stack usage (and overflow), if each layer
 * defines these structures on stack (assuming we don't want to do kmalloc.
 *
 * Any layer wishing to pass extra information to a layer next to it in
 * error handling hierarchy, can do so as a separate parameter.
 */
 
typedef struct io_error_s {
    /* Bit fields indicating which structure fields are valid */
    union {
	struct {
	    unsigned                ievb_errortype:1;
	    unsigned                ievb_widgetnum:1;
	    unsigned                ievb_widgetdev:1;
	    unsigned                ievb_srccpu:1;
	    unsigned                ievb_srcnode:1;
	    unsigned                ievb_errnode:1;
	    unsigned                ievb_sysioaddr:1;
	    unsigned                ievb_xtalkaddr:1;
	    unsigned                ievb_busspace:1;
	    unsigned                ievb_busaddr:1;
	    unsigned                ievb_vaddr:1;
	    unsigned                ievb_memaddr:1;
	    unsigned		    ievb_epc:1;
	    unsigned		    ievb_ef:1;
	    unsigned		    ievb_tnum:1;
	} iev_b;
	unsigned                iev_a;
    } ie_v;
 
    short                   ie_errortype;	/* error type: extra info about error */
    short                   ie_widgetnum;	/* Widget number that's in error */
    short                   ie_widgetdev;	/* Device within widget in error */
    cpuid_t                 ie_srccpu;	/* CPU on srcnode generating error */
    cnodeid_t               ie_srcnode;		/* Node which caused the error   */
    cnodeid_t               ie_errnode;		/* Node where error was noticed  */
    iopaddr_t               ie_sysioaddr;	/* Sys specific IO address       */
    iopaddr_t               ie_xtalkaddr;	/* Xtalk (48bit) addr of Error   */
    iopaddr_t               ie_busspace;	/* Bus specific address space    */
    iopaddr_t               ie_busaddr;		/* Bus specific address          */
    caddr_t                 ie_vaddr;	/* Virtual address of error      */
    paddr_t                 ie_memaddr;		/* Physical memory address       */
    caddr_t		    ie_epc;		/* pc when error reported	 */
    caddr_t		    ie_ef;		/* eframe when error reported	 */
    short		    ie_tnum;		/* Xtalk TNUM field */
} ioerror_t;
 
#define	IOERROR_INIT(e)		do { (e)->ie_v.iev_a = 0; } while (0)
#define	IOERROR_SETVALUE(e,f,v)	do { (e)->ie_ ## f = (v); (e)->ie_v.iev_b.ievb_ ## f = 1; } while (0)
#define	IOERROR_FIELDVALID(e,f)	((unsigned long long)((e)->ie_v.iev_b.ievb_ ## f) != (unsigned long long) 0)
#define	IOERROR_NOGETVALUE(e,f)	(ASSERT(IOERROR_FIELDVALID(e,f)), ((e)->ie_ ## f))
#define	IOERROR_GETVALUE(p,e,f)	ASSERT(IOERROR_FIELDVALID(e,f)); p=((e)->ie_ ## f)
 
/* hub code likes to call the SysAD address "hubaddr" ... */
#define	ie_hubaddr	ie_sysioaddr
#define	ievb_hubaddr	ievb_sysioaddr
#endif
 
/*
 * Error handling Modes.
 */
typedef enum {
    MODE_DEVPROBE,		/* Probing mode. Errors not fatal */
    MODE_DEVERROR,		/* Error while system is running */
    MODE_DEVUSERERROR,		/* Device Error created due to user mode access */
    MODE_DEVREENABLE		/* Reenable pass                */
} ioerror_mode_t;
 
 
typedef int             error_handler_f(void *, int, ioerror_mode_t, ioerror_t *);
typedef void           *error_handler_arg_t;
 
extern void             snia_ioerror_dump(char *, int, int, ioerror_t *);
 
#ifdef	ERROR_DEBUG
#define	IOERROR_DUMP(x, y, z, t)	snia_ioerror_dump((x), (y), (z), (t))
#define	IOERR_PRINTF(x)	(x)
#else
#define	IOERROR_DUMP(x, y, z, t)
#define	IOERR_PRINTF(x)
#endif				/* ERROR_DEBUG */
 
#endif /* _ASM_IA64_SN_IOERROR_H */