[mirror_ubuntu-zesty-kernel.git] / drivers / message / i2o / debug.c

#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/pci.h>
#include <linux/i2o.h>

static void i2o_report_util_cmd(u8 cmd);
static void i2o_report_exec_cmd(u8 cmd);
static void i2o_report_fail_status(u8 req_status, u32 * msg);
static void i2o_report_common_status(u8 req_status);
static void i2o_report_common_dsc(u16 detailed_status);

/*
 * Used for error reporting/debugging purposes.
 * Report Cmd name, Request status, Detailed Status.
 */
void i2o_report_status(const char *severity, const char *str,
		       struct i2o_message *m)
{
	u32 *msg = (u32 *) m;
	u8 cmd = (msg[1] >> 24) & 0xFF;
	u8 req_status = (msg[4] >> 24) & 0xFF;
	u16 detailed_status = msg[4] & 0xFFFF;

	if (cmd == I2O_CMD_UTIL_EVT_REGISTER)
		return;		// No status in this reply

	printk("%s%s: ", severity, str);

	if (cmd < 0x1F)		// Utility cmd
		i2o_report_util_cmd(cmd);

	else if (cmd >= 0xA0 && cmd <= 0xEF)	// Executive cmd
		i2o_report_exec_cmd(cmd);
	else
		printk("Cmd = %0#2x, ", cmd);	// Other cmds

	if (msg[0] & MSG_FAIL) {
		i2o_report_fail_status(req_status, msg);
		return;
	}

	i2o_report_common_status(req_status);

	if (cmd < 0x1F || (cmd >= 0xA0 && cmd <= 0xEF))
		i2o_report_common_dsc(detailed_status);
	else
		printk(" / DetailedStatus = %0#4x.\n",
		       detailed_status);
}

/* Used to dump a message to syslog during debugging */
void i2o_dump_message(struct i2o_message *m)
{
#ifdef DEBUG
	u32 *msg = (u32 *) m;
	int i;
	printk(KERN_INFO "Dumping I2O message size %d @ %p\n",
	       msg[0] >> 16 & 0xffff, msg);
	for (i = 0; i < ((msg[0] >> 16) & 0xffff); i++)
		printk(KERN_INFO "  msg[%d] = %0#10x\n", i, msg[i]);
#endif
}

/*
 * Used for error reporting/debugging purposes.
 * Following fail status are common to all classes.
 * The preserved message must be handled in the reply handler.
 */
static void i2o_report_fail_status(u8 req_status, u32 * msg)
{
	static char *FAIL_STATUS[] = {
		"0x80",		/* not used */
		"SERVICE_SUSPENDED",	/* 0x81 */
		"SERVICE_TERMINATED",	/* 0x82 */
		"CONGESTION",
		"FAILURE",
		"STATE_ERROR",
		"TIME_OUT",
		"ROUTING_FAILURE",
		"INVALID_VERSION",
		"INVALID_OFFSET",
		"INVALID_MSG_FLAGS",
		"FRAME_TOO_SMALL",
		"FRAME_TOO_LARGE",
		"INVALID_TARGET_ID",
		"INVALID_INITIATOR_ID",
		"INVALID_INITIATOR_CONTEX",	/* 0x8F */
		"UNKNOWN_FAILURE"	/* 0xFF */
	};

	if (req_status == I2O_FSC_TRANSPORT_UNKNOWN_FAILURE)
		printk("TRANSPORT_UNKNOWN_FAILURE (%0#2x).\n",
		       req_status);
	else
		printk("TRANSPORT_%s.\n",
		       FAIL_STATUS[req_status & 0x0F]);

	/* Dump some details */

	printk(KERN_ERR "  InitiatorId = %d, TargetId = %d\n",
	       (msg[1] >> 12) & 0xFFF, msg[1] & 0xFFF);
	printk(KERN_ERR "  LowestVersion = 0x%02X, HighestVersion = 0x%02X\n",
	       (msg[4] >> 8) & 0xFF, msg[4] & 0xFF);
	printk(KERN_ERR "  FailingHostUnit = 0x%04X,  FailingIOP = 0x%03X\n",
	       msg[5] >> 16, msg[5] & 0xFFF);

	printk(KERN_ERR "  Severity:  0x%02X\n", (msg[4] >> 16) & 0xFF);
	if (msg[4] & (1 << 16))
		printk(KERN_DEBUG "(FormatError), "
		       "this msg can never be delivered/processed.\n");
	if (msg[4] & (1 << 17))
		printk(KERN_DEBUG "(PathError), "
		       "this msg can no longer be delivered/processed.\n");
	if (msg[4] & (1 << 18))
		printk(KERN_DEBUG "(PathState), "
		       "the system state does not allow delivery.\n");
	if (msg[4] & (1 << 19))
		printk(KERN_DEBUG
		       "(Congestion), resources temporarily not available;"
		       "do not retry immediately.\n");
}

/*
 * Used for error reporting/debugging purposes.
 * Following reply status are common to all classes.
 */
static void i2o_report_common_status(u8 req_status)
{
	static char *REPLY_STATUS[] = {
		"SUCCESS",
		"ABORT_DIRTY",
		"ABORT_NO_DATA_TRANSFER",
		"ABORT_PARTIAL_TRANSFER",
		"ERROR_DIRTY",
		"ERROR_NO_DATA_TRANSFER",
		"ERROR_PARTIAL_TRANSFER",
		"PROCESS_ABORT_DIRTY",
		"PROCESS_ABORT_NO_DATA_TRANSFER",
		"PROCESS_ABORT_PARTIAL_TRANSFER",
		"TRANSACTION_ERROR",
		"PROGRESS_REPORT"
	};

	if (req_status >= ARRAY_SIZE(REPLY_STATUS))
		printk("RequestStatus = %0#2x", req_status);
	else
		printk("%s", REPLY_STATUS[req_status]);
}

/*
 * Used for error reporting/debugging purposes.
 * Following detailed status are valid  for executive class,
 * utility class, DDM class and for transaction error replies.
 */
static void i2o_report_common_dsc(u16 detailed_status)
{
	static char *COMMON_DSC[] = {
		"SUCCESS",
		"0x01",		// not used
		"BAD_KEY",
		"TCL_ERROR",
		"REPLY_BUFFER_FULL",
		"NO_SUCH_PAGE",
		"INSUFFICIENT_RESOURCE_SOFT",
		"INSUFFICIENT_RESOURCE_HARD",
		"0x08",		// not used
		"CHAIN_BUFFER_TOO_LARGE",
		"UNSUPPORTED_FUNCTION",
		"DEVICE_LOCKED",
		"DEVICE_RESET",
		"INAPPROPRIATE_FUNCTION",
		"INVALID_INITIATOR_ADDRESS",
		"INVALID_MESSAGE_FLAGS",
		"INVALID_OFFSET",
		"INVALID_PARAMETER",
		"INVALID_REQUEST",
		"INVALID_TARGET_ADDRESS",
		"MESSAGE_TOO_LARGE",
		"MESSAGE_TOO_SMALL",
		"MISSING_PARAMETER",
		"TIMEOUT",
		"UNKNOWN_ERROR",
		"UNKNOWN_FUNCTION",
		"UNSUPPORTED_VERSION",
		"DEVICE_BUSY",
		"DEVICE_NOT_AVAILABLE"
	};

	if (detailed_status > I2O_DSC_DEVICE_NOT_AVAILABLE)
		printk(" / DetailedStatus = %0#4x.\n",
		       detailed_status);
	else
		printk(" / %s.\n", COMMON_DSC[detailed_status]);
}

/*
 * Used for error reporting/debugging purposes
 */
static void i2o_report_util_cmd(u8 cmd)
{
	switch (cmd) {
	case I2O_CMD_UTIL_NOP:
		printk("UTIL_NOP, ");
		break;
	case I2O_CMD_UTIL_ABORT:
		printk("UTIL_ABORT, ");
		break;
	case I2O_CMD_UTIL_CLAIM:
		printk("UTIL_CLAIM, ");
		break;
	case I2O_CMD_UTIL_RELEASE:
		printk("UTIL_CLAIM_RELEASE, ");
		break;
	case I2O_CMD_UTIL_CONFIG_DIALOG:
		printk("UTIL_CONFIG_DIALOG, ");
		break;
	case I2O_CMD_UTIL_DEVICE_RESERVE:
		printk("UTIL_DEVICE_RESERVE, ");
		break;
	case I2O_CMD_UTIL_DEVICE_RELEASE:
		printk("UTIL_DEVICE_RELEASE, ");
		break;
	case I2O_CMD_UTIL_EVT_ACK:
		printk("UTIL_EVENT_ACKNOWLEDGE, ");
		break;
	case I2O_CMD_UTIL_EVT_REGISTER:
		printk("UTIL_EVENT_REGISTER, ");
		break;
	case I2O_CMD_UTIL_LOCK:
		printk("UTIL_LOCK, ");
		break;
	case I2O_CMD_UTIL_LOCK_RELEASE:
		printk("UTIL_LOCK_RELEASE, ");
		break;
	case I2O_CMD_UTIL_PARAMS_GET:
		printk("UTIL_PARAMS_GET, ");
		break;
	case I2O_CMD_UTIL_PARAMS_SET:
		printk("UTIL_PARAMS_SET, ");
		break;
	case I2O_CMD_UTIL_REPLY_FAULT_NOTIFY:
		printk("UTIL_REPLY_FAULT_NOTIFY, ");
		break;
	default:
		printk("Cmd = %0#2x, ", cmd);
	}
}

/*
 * Used for error reporting/debugging purposes
 */
static void i2o_report_exec_cmd(u8 cmd)
{
	switch (cmd) {
	case I2O_CMD_ADAPTER_ASSIGN:
		printk("EXEC_ADAPTER_ASSIGN, ");
		break;
	case I2O_CMD_ADAPTER_READ:
		printk("EXEC_ADAPTER_READ, ");
		break;
	case I2O_CMD_ADAPTER_RELEASE:
		printk("EXEC_ADAPTER_RELEASE, ");
		break;
	case I2O_CMD_BIOS_INFO_SET:
		printk("EXEC_BIOS_INFO_SET, ");
		break;
	case I2O_CMD_BOOT_DEVICE_SET:
		printk("EXEC_BOOT_DEVICE_SET, ");
		break;
	case I2O_CMD_CONFIG_VALIDATE:
		printk("EXEC_CONFIG_VALIDATE, ");
		break;
	case I2O_CMD_CONN_SETUP:
		printk("EXEC_CONN_SETUP, ");
		break;
	case I2O_CMD_DDM_DESTROY:
		printk("EXEC_DDM_DESTROY, ");
		break;
	case I2O_CMD_DDM_ENABLE:
		printk("EXEC_DDM_ENABLE, ");
		break;
	case I2O_CMD_DDM_QUIESCE:
		printk("EXEC_DDM_QUIESCE, ");
		break;
	case I2O_CMD_DDM_RESET:
		printk("EXEC_DDM_RESET, ");
		break;
	case I2O_CMD_DDM_SUSPEND:
		printk("EXEC_DDM_SUSPEND, ");
		break;
	case I2O_CMD_DEVICE_ASSIGN:
		printk("EXEC_DEVICE_ASSIGN, ");
		break;
	case I2O_CMD_DEVICE_RELEASE:
		printk("EXEC_DEVICE_RELEASE, ");
		break;
	case I2O_CMD_HRT_GET:
		printk("EXEC_HRT_GET, ");
		break;
	case I2O_CMD_ADAPTER_CLEAR:
		printk("EXEC_IOP_CLEAR, ");
		break;
	case I2O_CMD_ADAPTER_CONNECT:
		printk("EXEC_IOP_CONNECT, ");
		break;
	case I2O_CMD_ADAPTER_RESET:
		printk("EXEC_IOP_RESET, ");
		break;
	case I2O_CMD_LCT_NOTIFY:
		printk("EXEC_LCT_NOTIFY, ");
		break;
	case I2O_CMD_OUTBOUND_INIT:
		printk("EXEC_OUTBOUND_INIT, ");
		break;
	case I2O_CMD_PATH_ENABLE:
		printk("EXEC_PATH_ENABLE, ");
		break;
	case I2O_CMD_PATH_QUIESCE:
		printk("EXEC_PATH_QUIESCE, ");
		break;
	case I2O_CMD_PATH_RESET:
		printk("EXEC_PATH_RESET, ");
		break;
	case I2O_CMD_STATIC_MF_CREATE:
		printk("EXEC_STATIC_MF_CREATE, ");
		break;
	case I2O_CMD_STATIC_MF_RELEASE:
		printk("EXEC_STATIC_MF_RELEASE, ");
		break;
	case I2O_CMD_STATUS_GET:
		printk("EXEC_STATUS_GET, ");
		break;
	case I2O_CMD_SW_DOWNLOAD:
		printk("EXEC_SW_DOWNLOAD, ");
		break;
	case I2O_CMD_SW_UPLOAD:
		printk("EXEC_SW_UPLOAD, ");
		break;
	case I2O_CMD_SW_REMOVE:
		printk("EXEC_SW_REMOVE, ");
		break;
	case I2O_CMD_SYS_ENABLE:
		printk("EXEC_SYS_ENABLE, ");
		break;
	case I2O_CMD_SYS_MODIFY:
		printk("EXEC_SYS_MODIFY, ");
		break;
	case I2O_CMD_SYS_QUIESCE:
		printk("EXEC_SYS_QUIESCE, ");
		break;
	case I2O_CMD_SYS_TAB_SET:
		printk("EXEC_SYS_TAB_SET, ");
		break;
	default:
		printk("Cmd = %#02x, ", cmd);
	}
}

void i2o_debug_state(struct i2o_controller *c)
{
	printk(KERN_INFO "%s: State = ", c->name);
	switch (((i2o_status_block *) c->status_block.virt)->iop_state) {
	case 0x01:
		printk("INIT\n");
		break;
	case 0x02:
		printk("RESET\n");
		break;
	case 0x04:
		printk("HOLD\n");
		break;
	case 0x05:
		printk("READY\n");
		break;
	case 0x08:
		printk("OPERATIONAL\n");
		break;
	case 0x10:
		printk("FAILED\n");
		break;
	case 0x11:
		printk("FAULTED\n");
		break;
	default:
		printk("%x (unknown !!)\n",
		       ((i2o_status_block *) c->status_block.virt)->iop_state);
	}
};

void i2o_dump_hrt(struct i2o_controller *c)
{
	u32 *rows = (u32 *) c->hrt.virt;
	u8 *p = (u8 *) c->hrt.virt;
	u8 *d;
	int count;
	int length;
	int i;
	int state;

	if (p[3] != 0) {
		printk(KERN_ERR
		       "%s: HRT table for controller is too new a version.\n",
		       c->name);
		return;
	}

	count = p[0] | (p[1] << 8);
	length = p[2];

	printk(KERN_INFO "%s: HRT has %d entries of %d bytes each.\n",
	       c->name, count, length << 2);

	rows += 2;

	for (i = 0; i < count; i++) {
		printk(KERN_INFO "Adapter %08X: ", rows[0]);
		p = (u8 *) (rows + 1);
		d = (u8 *) (rows + 2);
		state = p[1] << 8 | p[0];

		printk("TID %04X:[", state & 0xFFF);
		state >>= 12;
		if (state & (1 << 0))
			printk("H");	/* Hidden */
		if (state & (1 << 2)) {
			printk("P");	/* Present */
			if (state & (1 << 1))
				printk("C");	/* Controlled */
		}
		if (state > 9)
			printk("*");	/* Hard */

		printk("]:");

		switch (p[3] & 0xFFFF) {
		case 0:
			/* Adapter private bus - easy */
			printk("Local bus %d: I/O at 0x%04X Mem 0x%08X", p[2],
			       d[1] << 8 | d[0], *(u32 *) (d + 4));
			break;
		case 1:
			/* ISA bus */
			printk("ISA %d: CSN %d I/O at 0x%04X Mem 0x%08X", p[2],
			       d[2], d[1] << 8 | d[0], *(u32 *) (d + 4));
			break;

		case 2:	/* EISA bus */
			printk("EISA %d: Slot %d I/O at 0x%04X Mem 0x%08X",
			       p[2], d[3], d[1] << 8 | d[0], *(u32 *) (d + 4));
			break;

		case 3:	/* MCA bus */
			printk("MCA %d: Slot %d I/O at 0x%04X Mem 0x%08X", p[2],
			       d[3], d[1] << 8 | d[0], *(u32 *) (d + 4));
			break;

		case 4:	/* PCI bus */
			printk("PCI %d: Bus %d Device %d Function %d", p[2],
			       d[2], d[1], d[0]);
			break;

		case 0x80:	/* Other */
		default:
			printk("Unsupported bus type.");
			break;
		}
		printk("\n");
		rows += length;
	}
}

EXPORT_SYMBOL(i2o_dump_message);
Commit	Line	Data
1da177e4 LT	1	#include <linux/module.h>
	2	#include <linux/kernel.h>
	3	#include <linux/pci.h>
	4	#include <linux/i2o.h>
	5
1da177e4 LT	6	static void i2o_report_util_cmd(u8 cmd);
	7	static void i2o_report_exec_cmd(u8 cmd);
	8	static void i2o_report_fail_status(u8 req_status, u32 * msg);
	9	static void i2o_report_common_status(u8 req_status);
	10	static void i2o_report_common_dsc(u16 detailed_status);
	11
	12	/*
	13	* Used for error reporting/debugging purposes.
	14	* Report Cmd name, Request status, Detailed Status.
	15	*/
	16	void i2o_report_status(const char severity, const char str,
	17	struct i2o_message *m)
	18	{
	19	u32 msg = (u32 ) m;
	20	u8 cmd = (msg[1] >> 24) & 0xFF;
	21	u8 req_status = (msg[4] >> 24) & 0xFF;
	22	u16 detailed_status = msg[4] & 0xFFFF;
1da177e4 LT	23
	24	if (cmd == I2O_CMD_UTIL_EVT_REGISTER)
	25	return; // No status in this reply
	26
6dd4ac3b	27	printk("%s%s: ", severity, str);
1da177e4 LT	28
	29	if (cmd < 0x1F) // Utility cmd
	30	i2o_report_util_cmd(cmd);
	31
	32	else if (cmd >= 0xA0 && cmd <= 0xEF) // Executive cmd
	33	i2o_report_exec_cmd(cmd);
	34	else
6dd4ac3b	35	printk("Cmd = %0#2x, ", cmd); // Other cmds
1da177e4 LT	36
	37	if (msg[0] & MSG_FAIL) {
	38	i2o_report_fail_status(req_status, msg);
	39	return;
	40	}
	41
	42	i2o_report_common_status(req_status);
	43
	44	if (cmd < 0x1F \|\| (cmd >= 0xA0 && cmd <= 0xEF))
	45	i2o_report_common_dsc(detailed_status);
	46	else
6dd4ac3b	47	printk(" / DetailedStatus = %0#4x.\n",
1da177e4 LT	48	detailed_status);
	49	}
	50
	51	/* Used to dump a message to syslog during debugging */
	52	void i2o_dump_message(struct i2o_message *m)
	53	{
	54	#ifdef DEBUG
	55	u32 msg = (u32 ) m;
	56	int i;
	57	printk(KERN_INFO "Dumping I2O message size %d @ %p\n",
	58	msg[0] >> 16 & 0xffff, msg);
	59	for (i = 0; i < ((msg[0] >> 16) & 0xffff); i++)
	60	printk(KERN_INFO " msg[%d] = %0#10x\n", i, msg[i]);
	61	#endif
	62	}
	63
	64	/*
	65	* Used for error reporting/debugging purposes.
	66	* Following fail status are common to all classes.
	67	* The preserved message must be handled in the reply handler.
	68	*/
	69	static void i2o_report_fail_status(u8 req_status, u32 * msg)
	70	{
	71	static char *FAIL_STATUS[] = {
	72	"0x80", /* not used */
	73	"SERVICE_SUSPENDED", /* 0x81 */
	74	"SERVICE_TERMINATED", /* 0x82 */
	75	"CONGESTION",
	76	"FAILURE",
	77	"STATE_ERROR",
	78	"TIME_OUT",
	79	"ROUTING_FAILURE",
	80	"INVALID_VERSION",
	81	"INVALID_OFFSET",
	82	"INVALID_MSG_FLAGS",
	83	"FRAME_TOO_SMALL",
	84	"FRAME_TOO_LARGE",
	85	"INVALID_TARGET_ID",
	86	"INVALID_INITIATOR_ID",
	87	"INVALID_INITIATOR_CONTEX", /* 0x8F */
	88	"UNKNOWN_FAILURE" /* 0xFF */
	89	};
	90
	91	if (req_status == I2O_FSC_TRANSPORT_UNKNOWN_FAILURE)
6dd4ac3b	92	printk("TRANSPORT_UNKNOWN_FAILURE (%0#2x).\n",
1da177e4 LT	93	req_status);
1da177e4 LT	94	else
6dd4ac3b	95	printk("TRANSPORT_%s.\n",
1da177e4 LT	96	FAIL_STATUS[req_status & 0x0F]);
	97
	98	/* Dump some details */
	99
	100	printk(KERN_ERR " InitiatorId = %d, TargetId = %d\n",
	101	(msg[1] >> 12) & 0xFFF, msg[1] & 0xFFF);
	102	printk(KERN_ERR " LowestVersion = 0x%02X, HighestVersion = 0x%02X\n",
	103	(msg[4] >> 8) & 0xFF, msg[4] & 0xFF);
	104	printk(KERN_ERR " FailingHostUnit = 0x%04X, FailingIOP = 0x%03X\n",
	105	msg[5] >> 16, msg[5] & 0xFFF);
	106
6dd4ac3b	107	printk(KERN_ERR " Severity: 0x%02X\n", (msg[4] >> 16) & 0xFF);
1da177e4 LT	108	if (msg[4] & (1 << 16))
	109	printk(KERN_DEBUG "(FormatError), "
	110	"this msg can never be delivered/processed.\n");
	111	if (msg[4] & (1 << 17))
	112	printk(KERN_DEBUG "(PathError), "
	113	"this msg can no longer be delivered/processed.\n");
	114	if (msg[4] & (1 << 18))
	115	printk(KERN_DEBUG "(PathState), "
	116	"the system state does not allow delivery.\n");
	117	if (msg[4] & (1 << 19))
	118	printk(KERN_DEBUG
	119	"(Congestion), resources temporarily not available;"
	120	"do not retry immediately.\n");
	121	}
	122
	123	/*
	124	* Used for error reporting/debugging purposes.
	125	* Following reply status are common to all classes.
	126	*/
	127	static void i2o_report_common_status(u8 req_status)
	128	{
	129	static char *REPLY_STATUS[] = {
	130	"SUCCESS",
	131	"ABORT_DIRTY",
	132	"ABORT_NO_DATA_TRANSFER",
	133	"ABORT_PARTIAL_TRANSFER",
	134	"ERROR_DIRTY",
	135	"ERROR_NO_DATA_TRANSFER",
	136	"ERROR_PARTIAL_TRANSFER",
	137	"PROCESS_ABORT_DIRTY",
	138	"PROCESS_ABORT_NO_DATA_TRANSFER",
	139	"PROCESS_ABORT_PARTIAL_TRANSFER",
	140	"TRANSACTION_ERROR",
	141	"PROGRESS_REPORT"
	142	};
	143
	144	if (req_status >= ARRAY_SIZE(REPLY_STATUS))
6dd4ac3b	145	printk("RequestStatus = %0#2x", req_status);
1da177e4	146	else
6dd4ac3b	147	printk("%s", REPLY_STATUS[req_status]);
1da177e4 LT	148	}
	149
	150	/*
	151	* Used for error reporting/debugging purposes.
	152	* Following detailed status are valid for executive class,
	153	* utility class, DDM class and for transaction error replies.
	154	*/
	155	static void i2o_report_common_dsc(u16 detailed_status)
	156	{
	157	static char *COMMON_DSC[] = {
	158	"SUCCESS",
	159	"0x01", // not used
	160	"BAD_KEY",
	161	"TCL_ERROR",
	162	"REPLY_BUFFER_FULL",
	163	"NO_SUCH_PAGE",
	164	"INSUFFICIENT_RESOURCE_SOFT",
	165	"INSUFFICIENT_RESOURCE_HARD",
	166	"0x08", // not used
	167	"CHAIN_BUFFER_TOO_LARGE",
	168	"UNSUPPORTED_FUNCTION",
	169	"DEVICE_LOCKED",
	170	"DEVICE_RESET",
	171	"INAPPROPRIATE_FUNCTION",
	172	"INVALID_INITIATOR_ADDRESS",
	173	"INVALID_MESSAGE_FLAGS",
	174	"INVALID_OFFSET",
	175	"INVALID_PARAMETER",
	176	"INVALID_REQUEST",
	177	"INVALID_TARGET_ADDRESS",
	178	"MESSAGE_TOO_LARGE",
	179	"MESSAGE_TOO_SMALL",
	180	"MISSING_PARAMETER",
	181	"TIMEOUT",
	182	"UNKNOWN_ERROR",
	183	"UNKNOWN_FUNCTION",
	184	"UNSUPPORTED_VERSION",
	185	"DEVICE_BUSY",
	186	"DEVICE_NOT_AVAILABLE"
	187	};
	188
	189	if (detailed_status > I2O_DSC_DEVICE_NOT_AVAILABLE)
6dd4ac3b	190	printk(" / DetailedStatus = %0#4x.\n",
1da177e4 LT	191	detailed_status);
1da177e4 LT	192	else
6dd4ac3b	193	printk(" / %s.\n", COMMON_DSC[detailed_status]);
1da177e4 LT	194	}
	195
	196	/*
	197	* Used for error reporting/debugging purposes
	198	*/
	199	static void i2o_report_util_cmd(u8 cmd)
	200	{
	201	switch (cmd) {
	202	case I2O_CMD_UTIL_NOP:
6dd4ac3b	203	printk("UTIL_NOP, ");
1da177e4 LT	204	break;
1da177e4 LT	205	case I2O_CMD_UTIL_ABORT:
6dd4ac3b	206	printk("UTIL_ABORT, ");
1da177e4 LT	207	break;
1da177e4 LT	208	case I2O_CMD_UTIL_CLAIM:
6dd4ac3b	209	printk("UTIL_CLAIM, ");
1da177e4 LT	210	break;
1da177e4 LT	211	case I2O_CMD_UTIL_RELEASE:
6dd4ac3b	212	printk("UTIL_CLAIM_RELEASE, ");
1da177e4 LT	213	break;
1da177e4 LT	214	case I2O_CMD_UTIL_CONFIG_DIALOG:
6dd4ac3b	215	printk("UTIL_CONFIG_DIALOG, ");
1da177e4 LT	216	break;
1da177e4 LT	217	case I2O_CMD_UTIL_DEVICE_RESERVE:
6dd4ac3b	218	printk("UTIL_DEVICE_RESERVE, ");
1da177e4 LT	219	break;
1da177e4 LT	220	case I2O_CMD_UTIL_DEVICE_RELEASE:
6dd4ac3b	221	printk("UTIL_DEVICE_RELEASE, ");
1da177e4 LT	222	break;
1da177e4 LT	223	case I2O_CMD_UTIL_EVT_ACK:
6dd4ac3b	224	printk("UTIL_EVENT_ACKNOWLEDGE, ");
1da177e4 LT	225	break;
1da177e4 LT	226	case I2O_CMD_UTIL_EVT_REGISTER:
6dd4ac3b	227	printk("UTIL_EVENT_REGISTER, ");
1da177e4 LT	228	break;
1da177e4 LT	229	case I2O_CMD_UTIL_LOCK:
6dd4ac3b	230	printk("UTIL_LOCK, ");
1da177e4 LT	231	break;
1da177e4 LT	232	case I2O_CMD_UTIL_LOCK_RELEASE:
6dd4ac3b	233	printk("UTIL_LOCK_RELEASE, ");
1da177e4 LT	234	break;
1da177e4 LT	235	case I2O_CMD_UTIL_PARAMS_GET:
6dd4ac3b	236	printk("UTIL_PARAMS_GET, ");
1da177e4 LT	237	break;
1da177e4 LT	238	case I2O_CMD_UTIL_PARAMS_SET:
6dd4ac3b	239	printk("UTIL_PARAMS_SET, ");
1da177e4 LT	240	break;
1da177e4 LT	241	case I2O_CMD_UTIL_REPLY_FAULT_NOTIFY:
6dd4ac3b	242	printk("UTIL_REPLY_FAULT_NOTIFY, ");
1da177e4 LT	243	break;
1da177e4 LT	244	default:
6dd4ac3b	245	printk("Cmd = %0#2x, ", cmd);
1da177e4 LT	246	}
	247	}
	248
	249	/*
	250	* Used for error reporting/debugging purposes
	251	*/
	252	static void i2o_report_exec_cmd(u8 cmd)
	253	{
	254	switch (cmd) {
	255	case I2O_CMD_ADAPTER_ASSIGN:
6dd4ac3b	256	printk("EXEC_ADAPTER_ASSIGN, ");
1da177e4 LT	257	break;
1da177e4 LT	258	case I2O_CMD_ADAPTER_READ:
6dd4ac3b	259	printk("EXEC_ADAPTER_READ, ");
1da177e4 LT	260	break;
1da177e4 LT	261	case I2O_CMD_ADAPTER_RELEASE:
6dd4ac3b	262	printk("EXEC_ADAPTER_RELEASE, ");
1da177e4 LT	263	break;
1da177e4 LT	264	case I2O_CMD_BIOS_INFO_SET:
6dd4ac3b	265	printk("EXEC_BIOS_INFO_SET, ");
1da177e4 LT	266	break;
1da177e4 LT	267	case I2O_CMD_BOOT_DEVICE_SET:
6dd4ac3b	268	printk("EXEC_BOOT_DEVICE_SET, ");
1da177e4 LT	269	break;
1da177e4 LT	270	case I2O_CMD_CONFIG_VALIDATE:
6dd4ac3b	271	printk("EXEC_CONFIG_VALIDATE, ");
1da177e4 LT	272	break;
1da177e4 LT	273	case I2O_CMD_CONN_SETUP:
6dd4ac3b	274	printk("EXEC_CONN_SETUP, ");
1da177e4 LT	275	break;
1da177e4 LT	276	case I2O_CMD_DDM_DESTROY:
6dd4ac3b	277	printk("EXEC_DDM_DESTROY, ");
1da177e4 LT	278	break;
1da177e4 LT	279	case I2O_CMD_DDM_ENABLE:
6dd4ac3b	280	printk("EXEC_DDM_ENABLE, ");
1da177e4 LT	281	break;
1da177e4 LT	282	case I2O_CMD_DDM_QUIESCE:
6dd4ac3b	283	printk("EXEC_DDM_QUIESCE, ");
1da177e4 LT	284	break;
1da177e4 LT	285	case I2O_CMD_DDM_RESET:
6dd4ac3b	286	printk("EXEC_DDM_RESET, ");
1da177e4 LT	287	break;
1da177e4 LT	288	case I2O_CMD_DDM_SUSPEND:
6dd4ac3b	289	printk("EXEC_DDM_SUSPEND, ");
1da177e4 LT	290	break;
1da177e4 LT	291	case I2O_CMD_DEVICE_ASSIGN:
6dd4ac3b	292	printk("EXEC_DEVICE_ASSIGN, ");
1da177e4 LT	293	break;
1da177e4 LT	294	case I2O_CMD_DEVICE_RELEASE:
6dd4ac3b	295	printk("EXEC_DEVICE_RELEASE, ");
1da177e4 LT	296	break;
1da177e4 LT	297	case I2O_CMD_HRT_GET:
6dd4ac3b	298	printk("EXEC_HRT_GET, ");
1da177e4 LT	299	break;
1da177e4 LT	300	case I2O_CMD_ADAPTER_CLEAR:
6dd4ac3b	301	printk("EXEC_IOP_CLEAR, ");
1da177e4 LT	302	break;
1da177e4 LT	303	case I2O_CMD_ADAPTER_CONNECT:
6dd4ac3b	304	printk("EXEC_IOP_CONNECT, ");
1da177e4 LT	305	break;
1da177e4 LT	306	case I2O_CMD_ADAPTER_RESET:
6dd4ac3b	307	printk("EXEC_IOP_RESET, ");
1da177e4 LT	308	break;
1da177e4 LT	309	case I2O_CMD_LCT_NOTIFY:
6dd4ac3b	310	printk("EXEC_LCT_NOTIFY, ");
1da177e4 LT	311	break;
1da177e4 LT	312	case I2O_CMD_OUTBOUND_INIT:
6dd4ac3b	313	printk("EXEC_OUTBOUND_INIT, ");
1da177e4 LT	314	break;
1da177e4 LT	315	case I2O_CMD_PATH_ENABLE:
6dd4ac3b	316	printk("EXEC_PATH_ENABLE, ");
1da177e4 LT	317	break;
1da177e4 LT	318	case I2O_CMD_PATH_QUIESCE:
6dd4ac3b	319	printk("EXEC_PATH_QUIESCE, ");
1da177e4 LT	320	break;
1da177e4 LT	321	case I2O_CMD_PATH_RESET:
6dd4ac3b	322	printk("EXEC_PATH_RESET, ");
1da177e4 LT	323	break;
1da177e4 LT	324	case I2O_CMD_STATIC_MF_CREATE:
6dd4ac3b	325	printk("EXEC_STATIC_MF_CREATE, ");
1da177e4 LT	326	break;
1da177e4 LT	327	case I2O_CMD_STATIC_MF_RELEASE:
6dd4ac3b	328	printk("EXEC_STATIC_MF_RELEASE, ");
1da177e4 LT	329	break;
1da177e4 LT	330	case I2O_CMD_STATUS_GET:
6dd4ac3b	331	printk("EXEC_STATUS_GET, ");
1da177e4 LT	332	break;
1da177e4 LT	333	case I2O_CMD_SW_DOWNLOAD:
6dd4ac3b	334	printk("EXEC_SW_DOWNLOAD, ");
1da177e4 LT	335	break;
1da177e4 LT	336	case I2O_CMD_SW_UPLOAD:
6dd4ac3b	337	printk("EXEC_SW_UPLOAD, ");
1da177e4 LT	338	break;
1da177e4 LT	339	case I2O_CMD_SW_REMOVE:
6dd4ac3b	340	printk("EXEC_SW_REMOVE, ");
1da177e4 LT	341	break;
1da177e4 LT	342	case I2O_CMD_SYS_ENABLE:
6dd4ac3b	343	printk("EXEC_SYS_ENABLE, ");
1da177e4 LT	344	break;
1da177e4 LT	345	case I2O_CMD_SYS_MODIFY:
6dd4ac3b	346	printk("EXEC_SYS_MODIFY, ");
1da177e4 LT	347	break;
1da177e4 LT	348	case I2O_CMD_SYS_QUIESCE:
6dd4ac3b	349	printk("EXEC_SYS_QUIESCE, ");
1da177e4 LT	350	break;
1da177e4 LT	351	case I2O_CMD_SYS_TAB_SET:
6dd4ac3b	352	printk("EXEC_SYS_TAB_SET, ");
1da177e4 LT	353	break;
1da177e4 LT	354	default:
6dd4ac3b	355	printk("Cmd = %#02x, ", cmd);
1da177e4 LT	356	}
	357	}
	358
	359	void i2o_debug_state(struct i2o_controller *c)
	360	{
	361	printk(KERN_INFO "%s: State = ", c->name);
	362	switch (((i2o_status_block *) c->status_block.virt)->iop_state) {
	363	case 0x01:
6dd4ac3b	364	printk("INIT\n");
1da177e4 LT	365	break;
1da177e4 LT	366	case 0x02:
6dd4ac3b	367	printk("RESET\n");
1da177e4 LT	368	break;
1da177e4 LT	369	case 0x04:
6dd4ac3b	370	printk("HOLD\n");
1da177e4 LT	371	break;
1da177e4 LT	372	case 0x05:
6dd4ac3b	373	printk("READY\n");
1da177e4 LT	374	break;
1da177e4 LT	375	case 0x08:
6dd4ac3b	376	printk("OPERATIONAL\n");
1da177e4 LT	377	break;
1da177e4 LT	378	case 0x10:
6dd4ac3b	379	printk("FAILED\n");
1da177e4 LT	380	break;
1da177e4 LT	381	case 0x11:
6dd4ac3b	382	printk("FAULTED\n");
1da177e4 LT	383	break;
1da177e4 LT	384	default:
6dd4ac3b	385	printk("%x (unknown !!)\n",
1da177e4 LT	386	((i2o_status_block *) c->status_block.virt)->iop_state);
	387	}
	388	};
	389
	390	void i2o_dump_hrt(struct i2o_controller *c)
	391	{
	392	u32 rows = (u32 ) c->hrt.virt;
	393	u8 p = (u8 ) c->hrt.virt;
	394	u8 *d;
	395	int count;
	396	int length;
	397	int i;
	398	int state;
	399
	400	if (p[3] != 0) {
	401	printk(KERN_ERR
	402	"%s: HRT table for controller is too new a version.\n",
	403	c->name);
	404	return;
	405	}
	406
	407	count = p[0] \| (p[1] << 8);
	408	length = p[2];
	409
	410	printk(KERN_INFO "%s: HRT has %d entries of %d bytes each.\n",
	411	c->name, count, length << 2);
	412
	413	rows += 2;
	414
	415	for (i = 0; i < count; i++) {
	416	printk(KERN_INFO "Adapter %08X: ", rows[0]);
	417	p = (u8 *) (rows + 1);
	418	d = (u8 *) (rows + 2);
	419	state = p[1] << 8 \| p[0];
	420
30087baf	421	printk("TID %04X:[", state & 0xFFF);
1da177e4 LT	422	state >>= 12;
1da177e4 LT	423	if (state & (1 << 0))
30087baf	424	printk("H"); /* Hidden */
1da177e4	425	if (state & (1 << 2)) {
30087baf	426	printk("P"); /* Present */
1da177e4	427	if (state & (1 << 1))
30087baf	428	printk("C"); /* Controlled */
1da177e4 LT	429	}
1da177e4 LT	430	if (state > 9)
30087baf	431	printk(""); / Hard */
1da177e4	432
30087baf	433	printk("]:");
1da177e4 LT	434
	435	switch (p[3] & 0xFFFF) {
	436	case 0:
	437	/* Adapter private bus - easy */
30087baf	438	printk("Local bus %d: I/O at 0x%04X Mem 0x%08X", p[2],
1da177e4 LT	439	d[1] << 8 \| d[0], (u32 ) (d + 4));
	440	break;
	441	case 1:
	442	/* ISA bus */
30087baf	443	printk("ISA %d: CSN %d I/O at 0x%04X Mem 0x%08X", p[2],
1da177e4 LT	444	d[2], d[1] << 8 \| d[0], (u32 ) (d + 4));
	445	break;
	446
	447	case 2: /* EISA bus */
30087baf	448	printk("EISA %d: Slot %d I/O at 0x%04X Mem 0x%08X",
1da177e4 LT	449	p[2], d[3], d[1] << 8 \| d[0], (u32 ) (d + 4));
	450	break;
	451
	452	case 3: /* MCA bus */
30087baf	453	printk("MCA %d: Slot %d I/O at 0x%04X Mem 0x%08X", p[2],
1da177e4 LT	454	d[3], d[1] << 8 \| d[0], (u32 ) (d + 4));
	455	break;
	456
	457	case 4: /* PCI bus */
30087baf	458	printk("PCI %d: Bus %d Device %d Function %d", p[2],
1da177e4 LT	459	d[2], d[1], d[0]);
	460	break;
	461
	462	case 0x80: /* Other */
	463	default:
30087baf	464	printk("Unsupported bus type.");
1da177e4 LT	465	break;
1da177e4 LT	466	}
30087baf	467	printk("\n");
1da177e4 LT	468	rows += length;
	469	}
	470	}
	471
	472	EXPORT_SYMBOL(i2o_dump_message);