Add the rt linux 4.1.3-rt3 as base
[kvmfornfv.git] / kernel / drivers / scsi / aic7xxx / aic79xx_reg_print.c_shipped
diff --git a/kernel/drivers/scsi/aic7xxx/aic79xx_reg_print.c_shipped b/kernel/drivers/scsi/aic7xxx/aic79xx_reg_print.c_shipped
new file mode 100644 (file)
index 0000000..f5ea715
--- /dev/null
@@ -0,0 +1,745 @@
+/*
+ * 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 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 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 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));
+}
+