Quelle  aic79xx_reg_print.c_shipped   Sprache: unbekannt

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