xref: /linux/drivers/scsi/aic7xxx/aic79xx_reg_print.c_shipped (revision cf40a76e7d5874bb25f4404eecc58a2e033af885)

/*
 * DO NOT EDIT - This file is automatically generated
 *		 from the following source files:
 *
 * $Id: //depot/aic7xxx/aic7xxx/aic79xx.seq#120 $
 * $Id: //depot/aic7xxx/aic7xxx/aic79xx.reg#77 $
 */

#include "aic79xx_osm.h"

static const ahd_reg_parse_entry_t INTSTAT_parse_table[] = {
	{ "SPLTINT",		0x01, 0x01 },
	{ "CMDCMPLT",		0x02, 0x02 },
	{ "SEQINT",		0x04, 0x04 },
	{ "SCSIINT",		0x08, 0x08 },
	{ "PCIINT",		0x10, 0x10 },
	{ "SWTMINT",		0x20, 0x20 },
	{ "BRKADRINT",		0x40, 0x40 },
	{ "HWERRINT",		0x80, 0x80 },
	{ "INT_PEND",		0xff, 0xff }
};

int
ahd_intstat_print(u_int regvalue, u_int *cur_col, u_int wrap)
{
	return (ahd_print_register(INTSTAT_parse_table, 9, "INTSTAT",
	    0x01, regvalue, cur_col, wrap));
}

static const ahd_reg_parse_entry_t HS_MAILBOX_parse_table[] = {
	{ "ENINT_COALESCE",	0x40, 0x40 },
	{ "HOST_TQINPOS",	0x80, 0x80 }
};

int
ahd_hs_mailbox_print(u_int regvalue, u_int *cur_col, u_int wrap)
{
	return (ahd_print_register(HS_MAILBOX_parse_table, 2, "HS_MAILBOX",
	    0x0b, regvalue, cur_col, wrap));
}

static const ahd_reg_parse_entry_t SEQINTSTAT_parse_table[] = {
	{ "SEQ_SPLTINT",	0x01, 0x01 },
	{ "SEQ_PCIINT",		0x02, 0x02 },
	{ "SEQ_SCSIINT",	0x04, 0x04 },
	{ "SEQ_SEQINT",		0x08, 0x08 },
	{ "SEQ_SWTMRTO",	0x10, 0x10 }
};

int
ahd_seqintstat_print(u_int regvalue, u_int *cur_col, u_int wrap)
{
	return (ahd_print_register(SEQINTSTAT_parse_table, 5, "SEQINTSTAT",
	    0x0c, regvalue, cur_col, wrap));
}

static const ahd_reg_parse_entry_t INTCTL_parse_table[] = {
	{ "SPLTINTEN",		0x01, 0x01 },
	{ "SEQINTEN",		0x02, 0x02 },
	{ "SCSIINTEN",		0x04, 0x04 },
	{ "PCIINTEN",		0x08, 0x08 },
	{ "AUTOCLRCMDINT",	0x10, 0x10 },
	{ "SWTIMER_START",	0x20, 0x20 },
	{ "SWTMINTEN",		0x40, 0x40 },
	{ "SWTMINTMASK",	0x80, 0x80 }
};

int
ahd_intctl_print(u_int regvalue, u_int *cur_col, u_int wrap)
{
	return (ahd_print_register(INTCTL_parse_table, 8, "INTCTL",
	    0x18, regvalue, cur_col, wrap));
}

static const ahd_reg_parse_entry_t DFCNTRL_parse_table[] = {
	{ "DIRECTIONEN",	0x01, 0x01 },
	{ "FIFOFLUSH",		0x02, 0x02 },
	{ "FIFOFLUSHACK",	0x02, 0x02 },
	{ "DIRECTION",		0x04, 0x04 },
	{ "DIRECTIONACK",	0x04, 0x04 },
	{ "HDMAEN",		0x08, 0x08 },
	{ "HDMAENACK",		0x08, 0x08 },
	{ "SCSIEN",		0x20, 0x20 },
	{ "SCSIENACK",		0x20, 0x20 },
	{ "SCSIENWRDIS",	0x40, 0x40 },
	{ "PRELOADEN",		0x80, 0x80 }
};

int
ahd_dfcntrl_print(u_int regvalue, u_int *cur_col, u_int wrap)
{
	return (ahd_print_register(DFCNTRL_parse_table, 11, "DFCNTRL",
	    0x19, regvalue, cur_col, wrap));
}

static const ahd_reg_parse_entry_t DFSTATUS_parse_table[] = {
	{ "FIFOEMP",		0x01, 0x01 },
	{ "FIFOFULL",		0x02, 0x02 },
	{ "DFTHRESH",		0x04, 0x04 },
	{ "HDONE",		0x08, 0x08 },
	{ "MREQPEND",		0x10, 0x10 },
	{ "PKT_PRELOAD_AVAIL",	0x40, 0x40 },
	{ "PRELOAD_AVAIL",	0x80, 0x80 }
};

int
ahd_dfstatus_print(u_int regvalue, u_int *cur_col, u_int wrap)
{
	return (ahd_print_register(DFSTATUS_parse_table, 7, "DFSTATUS",
	    0x1a, regvalue, cur_col, wrap));
}

static const ahd_reg_parse_entry_t SG_CACHE_SHADOW_parse_table[] = {
	{ "LAST_SEG_DONE",	0x01, 0x01 },
	{ "LAST_SEG",		0x02, 0x02 },
	{ "ODD_SEG",		0x04, 0x04 },
	{ "SG_ADDR_MASK",	0xf8, 0xf8 }
};

int
ahd_sg_cache_shadow_print(u_int regvalue, u_int *cur_col, u_int wrap)
{
	return (ahd_print_register(SG_CACHE_SHADOW_parse_table, 4, "SG_CACHE_SHADOW",
	    0x1b, regvalue, cur_col, wrap));
}

static const ahd_reg_parse_entry_t SCSISEQ0_parse_table[] = {
	{ "SCSIRSTO",		0x01, 0x01 },
	{ "FORCEBUSFREE",	0x10, 0x10 },
	{ "ENARBO",		0x20, 0x20 },
	{ "ENSELO",		0x40, 0x40 },
	{ "TEMODEO",		0x80, 0x80 }
};

int
ahd_scsiseq0_print(u_int regvalue, u_int *cur_col, u_int wrap)
{
	return (ahd_print_register(SCSISEQ0_parse_table, 5, "SCSISEQ0",
	    0x3a, regvalue, cur_col, wrap));
}

static const ahd_reg_parse_entry_t SCSISEQ1_parse_table[] = {
	{ "ALTSTIM",		0x01, 0x01 },
	{ "ENAUTOATNP",		0x02, 0x02 },
	{ "MANUALP",		0x0c, 0x0c },
	{ "ENRSELI",		0x10, 0x10 },
	{ "ENSELI",		0x20, 0x20 },
	{ "MANUALCTL",		0x40, 0x40 }
};

int
ahd_scsiseq1_print(u_int regvalue, u_int *cur_col, u_int wrap)
{
	return (ahd_print_register(SCSISEQ1_parse_table, 6, "SCSISEQ1",
	    0x3b, regvalue, cur_col, wrap));
}

static const ahd_reg_parse_entry_t DFFSTAT_parse_table[] = {
	{ "CURRFIFO_0",		0x00, 0x03 },
	{ "CURRFIFO_1",		0x01, 0x03 },
	{ "CURRFIFO_NONE",	0x03, 0x03 },
	{ "FIFO0FREE",		0x10, 0x10 },
	{ "FIFO1FREE",		0x20, 0x20 },
	{ "CURRFIFO",		0x03, 0x03 }
};

int
ahd_dffstat_print(u_int regvalue, u_int *cur_col, u_int wrap)
{
	return (ahd_print_register(DFFSTAT_parse_table, 6, "DFFSTAT",
	    0x3f, regvalue, cur_col, wrap));
}

static const ahd_reg_parse_entry_t SCSISIGI_parse_table[] = {
	{ "P_DATAOUT",		0x00, 0xe0 },
	{ "P_DATAOUT_DT",	0x20, 0xe0 },
	{ "P_DATAIN",		0x40, 0xe0 },
	{ "P_DATAIN_DT",	0x60, 0xe0 },
	{ "P_COMMAND",		0x80, 0xe0 },
	{ "P_MESGOUT",		0xa0, 0xe0 },
	{ "P_STATUS",		0xc0, 0xe0 },
	{ "P_MESGIN",		0xe0, 0xe0 },
	{ "ACKI",		0x01, 0x01 },
	{ "REQI",		0x02, 0x02 },
	{ "BSYI",		0x04, 0x04 },
	{ "SELI",		0x08, 0x08 },
	{ "ATNI",		0x10, 0x10 },
	{ "MSGI",		0x20, 0x20 },
	{ "IOI",		0x40, 0x40 },
	{ "CDI",		0x80, 0x80 },
	{ "PHASE_MASK",		0xe0, 0xe0 }
};

int
ahd_scsisigi_print(u_int regvalue, u_int *cur_col, u_int wrap)
{
	return (ahd_print_register(SCSISIGI_parse_table, 17, "SCSISIGI",
	    0x41, regvalue, cur_col, wrap));
}

static const ahd_reg_parse_entry_t SCSIPHASE_parse_table[] = {
	{ "DATA_OUT_PHASE",	0x01, 0x03 },
	{ "DATA_IN_PHASE",	0x02, 0x03 },
	{ "DATA_PHASE_MASK",	0x03, 0x03 },
	{ "MSG_OUT_PHASE",	0x04, 0x04 },
	{ "MSG_IN_PHASE",	0x08, 0x08 },
	{ "COMMAND_PHASE",	0x10, 0x10 },
	{ "STATUS_PHASE",	0x20, 0x20 }
};

int
ahd_scsiphase_print(u_int regvalue, u_int *cur_col, u_int wrap)
{
	return (ahd_print_register(SCSIPHASE_parse_table, 7, "SCSIPHASE",
	    0x42, regvalue, cur_col, wrap));
}

int
ahd_scsibus_print(u_int regvalue, u_int *cur_col, u_int wrap)
{
	return (ahd_print_register(NULL, 0, "SCSIBUS",
	    0x46, regvalue, cur_col, wrap));
}

static const ahd_reg_parse_entry_t SELID_parse_table[] = {
	{ "ONEBIT",		0x08, 0x08 },
	{ "SELID_MASK",		0xf0, 0xf0 }
};

int
ahd_selid_print(u_int regvalue, u_int *cur_col, u_int wrap)
{
	return (ahd_print_register(SELID_parse_table, 2, "SELID",
	    0x49, regvalue, cur_col, wrap));
}

static const ahd_reg_parse_entry_t SIMODE0_parse_table[] = {
	{ "ENARBDO",		0x01, 0x01 },
	{ "ENSPIORDY",		0x02, 0x02 },
	{ "ENOVERRUN",		0x04, 0x04 },
	{ "ENIOERR",		0x08, 0x08 },
	{ "ENSELINGO",		0x10, 0x10 },
	{ "ENSELDI",		0x20, 0x20 },
	{ "ENSELDO",		0x40, 0x40 }
};

int
ahd_simode0_print(u_int regvalue, u_int *cur_col, u_int wrap)
{
	return (ahd_print_register(SIMODE0_parse_table, 7, "SIMODE0",
	    0x4b, regvalue, cur_col, wrap));
}

static const ahd_reg_parse_entry_t SSTAT0_parse_table[] = {
	{ "ARBDO",		0x01, 0x01 },
	{ "SPIORDY",		0x02, 0x02 },
	{ "OVERRUN",		0x04, 0x04 },
	{ "IOERR",		0x08, 0x08 },
	{ "SELINGO",		0x10, 0x10 },
	{ "SELDI",		0x20, 0x20 },
	{ "SELDO",		0x40, 0x40 },
	{ "TARGET",		0x80, 0x80 }
};

int
ahd_sstat0_print(u_int regvalue, u_int *cur_col, u_int wrap)
{
	return (ahd_print_register(SSTAT0_parse_table, 8, "SSTAT0",
	    0x4b, regvalue, cur_col, wrap));
}

static const ahd_reg_parse_entry_t SSTAT1_parse_table[] = {
	{ "REQINIT",		0x01, 0x01 },
	{ "STRB2FAST",		0x02, 0x02 },
	{ "SCSIPERR",		0x04, 0x04 },
	{ "BUSFREE",		0x08, 0x08 },
	{ "PHASEMIS",		0x10, 0x10 },
	{ "SCSIRSTI",		0x20, 0x20 },
	{ "ATNTARG",		0x40, 0x40 },
	{ "SELTO",		0x80, 0x80 }
};

int
ahd_sstat1_print(u_int regvalue, u_int *cur_col, u_int wrap)
{
	return (ahd_print_register(SSTAT1_parse_table, 8, "SSTAT1",
	    0x4c, regvalue, cur_col, wrap));
}

static const ahd_reg_parse_entry_t SSTAT2_parse_table[] = {
	{ "BUSFREE_LQO",	0x40, 0xc0 },
	{ "BUSFREE_DFF0",	0x80, 0xc0 },
	{ "BUSFREE_DFF1",	0xc0, 0xc0 },
	{ "DMADONE",		0x01, 0x01 },
	{ "SDONE",		0x02, 0x02 },
	{ "WIDE_RES",		0x04, 0x04 },
	{ "BSYX",		0x08, 0x08 },
	{ "EXP_ACTIVE",		0x10, 0x10 },
	{ "NONPACKREQ",		0x20, 0x20 },
	{ "BUSFREETIME",	0xc0, 0xc0 }
};

int
ahd_sstat2_print(u_int regvalue, u_int *cur_col, u_int wrap)
{
	return (ahd_print_register(SSTAT2_parse_table, 10, "SSTAT2",
	    0x4d, regvalue, cur_col, wrap));
}

static const ahd_reg_parse_entry_t PERRDIAG_parse_table[] = {
	{ "DTERR",		0x01, 0x01 },
	{ "DGFORMERR",		0x02, 0x02 },
	{ "CRCERR",		0x04, 0x04 },
	{ "AIPERR",		0x08, 0x08 },
	{ "PARITYERR",		0x10, 0x10 },
	{ "PREVPHASE",		0x20, 0x20 },
	{ "HIPERR",		0x40, 0x40 },
	{ "HIZERO",		0x80, 0x80 }
};

int
ahd_perrdiag_print(u_int regvalue, u_int *cur_col, u_int wrap)
{
	return (ahd_print_register(PERRDIAG_parse_table, 8, "PERRDIAG",
	    0x4e, regvalue, cur_col, wrap));
}

int
ahd_soffcnt_print(u_int regvalue, u_int *cur_col, u_int wrap)
{
	return (ahd_print_register(NULL, 0, "SOFFCNT",
	    0x4f, regvalue, cur_col, wrap));
}

static const ahd_reg_parse_entry_t LQISTAT0_parse_table[] = {
	{ "LQIATNCMD",		0x01, 0x01 },
	{ "LQIATNLQ",		0x02, 0x02 },
	{ "LQIBADLQT",		0x04, 0x04 },
	{ "LQICRCT2",		0x08, 0x08 },
	{ "LQICRCT1",		0x10, 0x10 },
	{ "LQIATNQAS",		0x20, 0x20 }
};

int
ahd_lqistat0_print(u_int regvalue, u_int *cur_col, u_int wrap)
{
	return (ahd_print_register(LQISTAT0_parse_table, 6, "LQISTAT0",
	    0x50, regvalue, cur_col, wrap));
}

static const ahd_reg_parse_entry_t LQISTAT1_parse_table[] = {
	{ "LQIOVERI_NLQ",	0x01, 0x01 },
	{ "LQIOVERI_LQ",	0x02, 0x02 },
	{ "LQIBADLQI",		0x04, 0x04 },
	{ "LQICRCI_NLQ",	0x08, 0x08 },
	{ "LQICRCI_LQ",		0x10, 0x10 },
	{ "LQIABORT",		0x20, 0x20 },
	{ "LQIPHASE_NLQ",	0x40, 0x40 },
	{ "LQIPHASE_LQ",	0x80, 0x80 }
};

int
ahd_lqistat1_print(u_int regvalue, u_int *cur_col, u_int wrap)
{
	return (ahd_print_register(LQISTAT1_parse_table, 8, "LQISTAT1",
	    0x51, regvalue, cur_col, wrap));
}

static const ahd_reg_parse_entry_t LQISTAT2_parse_table[] = {
	{ "LQIGSAVAIL",		0x01, 0x01 },
	{ "LQISTOPCMD",		0x02, 0x02 },
	{ "LQISTOPLQ",		0x04, 0x04 },
	{ "LQISTOPPKT",		0x08, 0x08 },
	{ "LQIWAITFIFO",	0x10, 0x10 },
	{ "LQIWORKONLQ",	0x20, 0x20 },
	{ "LQIPHASE_OUTPKT",	0x40, 0x40 },
	{ "PACKETIZED",		0x80, 0x80 }
};

int
ahd_lqistat2_print(u_int regvalue, u_int *cur_col, u_int wrap)
{
	return (ahd_print_register(LQISTAT2_parse_table, 8, "LQISTAT2",
	    0x52, regvalue, cur_col, wrap));
}

static const ahd_reg_parse_entry_t SSTAT3_parse_table[] = {
	{ "OSRAMPERR",		0x01, 0x01 },
	{ "NTRAMPERR",		0x02, 0x02 }
};

int
ahd_sstat3_print(u_int regvalue, u_int *cur_col, u_int wrap)
{
	return (ahd_print_register(SSTAT3_parse_table, 2, "SSTAT3",
	    0x53, regvalue, cur_col, wrap));
}

static const ahd_reg_parse_entry_t LQOSTAT0_parse_table[] = {
	{ "LQOTCRC",		0x01, 0x01 },
	{ "LQOATNPKT",		0x02, 0x02 },
	{ "LQOATNLQ",		0x04, 0x04 },
	{ "LQOSTOPT2",		0x08, 0x08 },
	{ "LQOTARGSCBPERR",	0x10, 0x10 }
};

int
ahd_lqostat0_print(u_int regvalue, u_int *cur_col, u_int wrap)
{
	return (ahd_print_register(LQOSTAT0_parse_table, 5, "LQOSTAT0",
	    0x54, regvalue, cur_col, wrap));
}

static const ahd_reg_parse_entry_t LQOSTAT1_parse_table[] = {
	{ "LQOPHACHGINPKT",	0x01, 0x01 },
	{ "LQOBUSFREE",		0x02, 0x02 },
	{ "LQOBADQAS",		0x04, 0x04 },
	{ "LQOSTOPI2",		0x08, 0x08 },
	{ "LQOINITSCBPERR",	0x10, 0x10 }
};

int
ahd_lqostat1_print(u_int regvalue, u_int *cur_col, u_int wrap)
{
	return (ahd_print_register(LQOSTAT1_parse_table, 5, "LQOSTAT1",
	    0x55, regvalue, cur_col, wrap));
}

static const ahd_reg_parse_entry_t LQOSTAT2_parse_table[] = {
	{ "LQOSTOP0",		0x01, 0x01 },
	{ "LQOPHACHGOUTPKT",	0x02, 0x02 },
	{ "LQOWAITFIFO",	0x10, 0x10 },
	{ "LQOPKT",		0xe0, 0xe0 }
};

int
ahd_lqostat2_print(u_int regvalue, u_int *cur_col, u_int wrap)
{
	return (ahd_print_register(LQOSTAT2_parse_table, 4, "LQOSTAT2",
	    0x56, regvalue, cur_col, wrap));
}

static const ahd_reg_parse_entry_t SIMODE1_parse_table[] = {
	{ "ENREQINIT",		0x01, 0x01 },
	{ "ENSTRB2FAST",	0x02, 0x02 },
	{ "ENSCSIPERR",		0x04, 0x04 },
	{ "ENBUSFREE",		0x08, 0x08 },
	{ "ENPHASEMIS",		0x10, 0x10 },
	{ "ENSCSIRST",		0x20, 0x20 },
	{ "ENATNTARG",		0x40, 0x40 },
	{ "ENSELTIMO",		0x80, 0x80 }
};

int
ahd_simode1_print(u_int regvalue, u_int *cur_col, u_int wrap)
{
	return (ahd_print_register(SIMODE1_parse_table, 8, "SIMODE1",
	    0x57, regvalue, cur_col, wrap));
}

static const ahd_reg_parse_entry_t DFFSXFRCTL_parse_table[] = {
	{ "RSTCHN",		0x01, 0x01 },
	{ "CLRCHN",		0x02, 0x02 },
	{ "CLRSHCNT",		0x04, 0x04 },
	{ "DFFBITBUCKET",	0x08, 0x08 }
};

int
ahd_dffsxfrctl_print(u_int regvalue, u_int *cur_col, u_int wrap)
{
	return (ahd_print_register(DFFSXFRCTL_parse_table, 4, "DFFSXFRCTL",
	    0x5a, regvalue, cur_col, wrap));
}

static const ahd_reg_parse_entry_t SEQINTSRC_parse_table[] = {
	{ "CFG4TCMD",		0x01, 0x01 },
	{ "CFG4ICMD",		0x02, 0x02 },
	{ "CFG4TSTAT",		0x04, 0x04 },
	{ "CFG4ISTAT",		0x08, 0x08 },
	{ "CFG4DATA",		0x10, 0x10 },
	{ "SAVEPTRS",		0x20, 0x20 },
	{ "CTXTDONE",		0x40, 0x40 }
};

int
ahd_seqintsrc_print(u_int regvalue, u_int *cur_col, u_int wrap)
{
	return (ahd_print_register(SEQINTSRC_parse_table, 7, "SEQINTSRC",
	    0x5b, regvalue, cur_col, wrap));
}

static const ahd_reg_parse_entry_t SEQIMODE_parse_table[] = {
	{ "ENCFG4TCMD",		0x01, 0x01 },
	{ "ENCFG4ICMD",		0x02, 0x02 },
	{ "ENCFG4TSTAT",	0x04, 0x04 },
	{ "ENCFG4ISTAT",	0x08, 0x08 },
	{ "ENCFG4DATA",		0x10, 0x10 },
	{ "ENSAVEPTRS",		0x20, 0x20 },
	{ "ENCTXTDONE",		0x40, 0x40 }
};

int
ahd_seqimode_print(u_int regvalue, u_int *cur_col, u_int wrap)
{
	return (ahd_print_register(SEQIMODE_parse_table, 7, "SEQIMODE",
	    0x5c, regvalue, cur_col, wrap));
}

static const ahd_reg_parse_entry_t MDFFSTAT_parse_table[] = {
	{ "FIFOFREE",		0x01, 0x01 },
	{ "DATAINFIFO",		0x02, 0x02 },
	{ "DLZERO",		0x04, 0x04 },
	{ "SHVALID",		0x08, 0x08 },
	{ "LASTSDONE",		0x10, 0x10 },
	{ "SHCNTMINUS1",	0x20, 0x20 },
	{ "SHCNTNEGATIVE",	0x40, 0x40 }
};

int
ahd_mdffstat_print(u_int regvalue, u_int *cur_col, u_int wrap)
{
	return (ahd_print_register(MDFFSTAT_parse_table, 7, "MDFFSTAT",
	    0x5d, regvalue, cur_col, wrap));
}

int
ahd_seloid_print(u_int regvalue, u_int *cur_col, u_int wrap)
{
	return (ahd_print_register(NULL, 0, "SELOID",
	    0x6b, regvalue, cur_col, wrap));
}

static const ahd_reg_parse_entry_t SG_STATE_parse_table[] = {
	{ "SEGS_AVAIL",		0x01, 0x01 },
	{ "LOADING_NEEDED",	0x02, 0x02 },
	{ "FETCH_INPROG",	0x04, 0x04 }
};

int
ahd_sg_state_print(u_int regvalue, u_int *cur_col, u_int wrap)
{
	return (ahd_print_register(SG_STATE_parse_table, 3, "SG_STATE",
	    0xa6, regvalue, cur_col, wrap));
}

static const ahd_reg_parse_entry_t CCSCBCTL_parse_table[] = {
	{ "CCSCBRESET",		0x01, 0x01 },
	{ "CCSCBDIR",		0x04, 0x04 },
	{ "CCSCBEN",		0x08, 0x08 },
	{ "CCARREN",		0x10, 0x10 },
	{ "ARRDONE",		0x40, 0x40 },
	{ "CCSCBDONE",		0x80, 0x80 }
};

int
ahd_ccscbctl_print(u_int regvalue, u_int *cur_col, u_int wrap)
{
	return (ahd_print_register(CCSCBCTL_parse_table, 6, "CCSCBCTL",
	    0xad, regvalue, cur_col, wrap));
}

static const ahd_reg_parse_entry_t CCSGCTL_parse_table[] = {
	{ "CCSGRESET",		0x01, 0x01 },
	{ "SG_FETCH_REQ",	0x02, 0x02 },
	{ "CCSGENACK",		0x08, 0x08 },
	{ "SG_CACHE_AVAIL",	0x10, 0x10 },
	{ "CCSGDONE",		0x80, 0x80 },
	{ "CCSGEN",		0x0c, 0x0c }
};

int
ahd_ccsgctl_print(u_int regvalue, u_int *cur_col, u_int wrap)
{
	return (ahd_print_register(CCSGCTL_parse_table, 6, "CCSGCTL",
	    0xad, regvalue, cur_col, wrap));
}

static const ahd_reg_parse_entry_t SEQCTL0_parse_table[] = {
	{ "LOADRAM",		0x01, 0x01 },
	{ "SEQRESET",		0x02, 0x02 },
	{ "STEP",		0x04, 0x04 },
	{ "BRKADRINTEN",	0x08, 0x08 },
	{ "FASTMODE",		0x10, 0x10 },
	{ "FAILDIS",		0x20, 0x20 },
	{ "PAUSEDIS",		0x40, 0x40 },
	{ "PERRORDIS",		0x80, 0x80 }
};

int
ahd_seqctl0_print(u_int regvalue, u_int *cur_col, u_int wrap)
{
	return (ahd_print_register(SEQCTL0_parse_table, 8, "SEQCTL0",
	    0xd6, regvalue, cur_col, wrap));
}

static const ahd_reg_parse_entry_t SEQINTCTL_parse_table[] = {
	{ "IRET",		0x01, 0x01 },
	{ "INTMASK1",		0x02, 0x02 },
	{ "INTMASK2",		0x04, 0x04 },
	{ "SCS_SEQ_INT1M0",	0x08, 0x08 },
	{ "SCS_SEQ_INT1M1",	0x10, 0x10 },
	{ "INT1_CONTEXT",	0x20, 0x20 },
	{ "INTVEC1DSL",		0x80, 0x80 }
};

int
ahd_seqintctl_print(u_int regvalue, u_int *cur_col, u_int wrap)
{
	return (ahd_print_register(SEQINTCTL_parse_table, 7, "SEQINTCTL",
	    0xd9, regvalue, cur_col, wrap));
}

int
ahd_sram_base_print(u_int regvalue, u_int *cur_col, u_int wrap)
{
	return (ahd_print_register(NULL, 0, "SRAM_BASE",
	    0x100, regvalue, cur_col, wrap));
}

int
ahd_qfreeze_count_print(u_int regvalue, u_int *cur_col, u_int wrap)
{
	return (ahd_print_register(NULL, 0, "QFREEZE_COUNT",
	    0x132, regvalue, cur_col, wrap));
}

int
ahd_kernel_qfreeze_count_print(u_int regvalue, u_int *cur_col, u_int wrap)
{
	return (ahd_print_register(NULL, 0, "KERNEL_QFREEZE_COUNT",
	    0x134, regvalue, cur_col, wrap));
}

int
ahd_saved_mode_print(u_int regvalue, u_int *cur_col, u_int wrap)
{
	return (ahd_print_register(NULL, 0, "SAVED_MODE",
	    0x136, regvalue, cur_col, wrap));
}

static const ahd_reg_parse_entry_t SEQ_FLAGS_parse_table[] = {
	{ "NO_DISCONNECT",	0x01, 0x01 },
	{ "SPHASE_PENDING",	0x02, 0x02 },
	{ "DPHASE_PENDING",	0x04, 0x04 },
	{ "CMDPHASE_PENDING",	0x08, 0x08 },
	{ "TARG_CMD_PENDING",	0x10, 0x10 },
	{ "DPHASE",		0x20, 0x20 },
	{ "NO_CDB_SENT",	0x40, 0x40 },
	{ "TARGET_CMD_IS_TAGGED",0x40, 0x40 },
	{ "NOT_IDENTIFIED",	0x80, 0x80 }
};

int
ahd_seq_flags_print(u_int regvalue, u_int *cur_col, u_int wrap)
{
	return (ahd_print_register(SEQ_FLAGS_parse_table, 9, "SEQ_FLAGS",
	    0x139, regvalue, cur_col, wrap));
}

static const ahd_reg_parse_entry_t LASTPHASE_parse_table[] = {
	{ "P_DATAOUT",		0x00, 0xe0 },
	{ "P_DATAOUT_DT",	0x20, 0xe0 },
	{ "P_DATAIN",		0x40, 0xe0 },
	{ "P_DATAIN_DT",	0x60, 0xe0 },
	{ "P_COMMAND",		0x80, 0xe0 },
	{ "P_MESGOUT",		0xa0, 0xe0 },
	{ "P_STATUS",		0xc0, 0xe0 },
	{ "P_MESGIN",		0xe0, 0xe0 },
	{ "P_BUSFREE",		0x01, 0x01 },
	{ "MSGI",		0x20, 0x20 },
	{ "IOI",		0x40, 0x40 },
	{ "CDI",		0x80, 0x80 },
	{ "PHASE_MASK",		0xe0, 0xe0 }
};

int
ahd_lastphase_print(u_int regvalue, u_int *cur_col, u_int wrap)
{
	return (ahd_print_register(LASTPHASE_parse_table, 13, "LASTPHASE",
	    0x13c, regvalue, cur_col, wrap));
}

static const ahd_reg_parse_entry_t SEQ_FLAGS2_parse_table[] = {
	{ "PENDING_MK_MESSAGE",	0x01, 0x01 },
	{ "TARGET_MSG_PENDING",	0x02, 0x02 },
	{ "SELECTOUT_QFROZEN",	0x04, 0x04 }
};

int
ahd_seq_flags2_print(u_int regvalue, u_int *cur_col, u_int wrap)
{
	return (ahd_print_register(SEQ_FLAGS2_parse_table, 3, "SEQ_FLAGS2",
	    0x14d, regvalue, cur_col, wrap));
}

int
ahd_mk_message_scb_print(u_int regvalue, u_int *cur_col, u_int wrap)
{
	return (ahd_print_register(NULL, 0, "MK_MESSAGE_SCB",
	    0x160, regvalue, cur_col, wrap));
}

int
ahd_mk_message_scsiid_print(u_int regvalue, u_int *cur_col, u_int wrap)
{
	return (ahd_print_register(NULL, 0, "MK_MESSAGE_SCSIID",
	    0x162, regvalue, cur_col, wrap));
}

int
ahd_scb_base_print(u_int regvalue, u_int *cur_col, u_int wrap)
{
	return (ahd_print_register(NULL, 0, "SCB_BASE",
	    0x180, regvalue, cur_col, wrap));
}

static const ahd_reg_parse_entry_t SCB_CONTROL_parse_table[] = {
	{ "SCB_TAG_TYPE",	0x03, 0x03 },
	{ "DISCONNECTED",	0x04, 0x04 },
	{ "STATUS_RCVD",	0x08, 0x08 },
	{ "MK_MESSAGE",		0x10, 0x10 },
	{ "TAG_ENB",		0x20, 0x20 },
	{ "DISCENB",		0x40, 0x40 },
	{ "TARGET_SCB",		0x80, 0x80 }
};

int
ahd_scb_control_print(u_int regvalue, u_int *cur_col, u_int wrap)
{
	return (ahd_print_register(SCB_CONTROL_parse_table, 7, "SCB_CONTROL",
	    0x192, regvalue, cur_col, wrap));
}

static const ahd_reg_parse_entry_t SCB_SCSIID_parse_table[] = {
	{ "OID",		0x0f, 0x0f },
	{ "TID",		0xf0, 0xf0 }
};

int
ahd_scb_scsiid_print(u_int regvalue, u_int *cur_col, u_int wrap)
{
	return (ahd_print_register(SCB_SCSIID_parse_table, 2, "SCB_SCSIID",
	    0x193, regvalue, cur_col, wrap));
}