FreeBSD/Linux Kernel Cross Reference
sys/dev/aic7xxx/aic79xx_reg_print.c

     /*
      * DO NOT EDIT - This file is automatically generated
      *               from the following source files:
      *
      * $Id: //depot/aic7xxx/aic7xxx/aic79xx.seq#119 $
      * $Id: //depot/aic7xxx/aic7xxx/aic79xx.reg#76 $
      */
     
     #include <sys/cdefs.h>
    __FBSDID("$FreeBSD: releng/11.2/sys/dev/aic7xxx/aic79xx_reg_print.c 260401 2014-01-07 19:33:17Z scottl $");
    #include <dev/aic7xxx/aic79xx_osm.h>
    
    static ahd_reg_parse_entry_t MODE_PTR_parse_table[] = {
            { "SRC_MODE",           0x07, 0x07 },
            { "DST_MODE",           0x70, 0x70 }
    };
    
    int
    ahd_mode_ptr_print(u_int regvalue, u_int *cur_col, u_int wrap)
    {
            return (ahd_print_register(MODE_PTR_parse_table, 2, "MODE_PTR",
                0x00, regvalue, cur_col, wrap));
    }
    
    static 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 ahd_reg_parse_entry_t SEQINTCODE_parse_table[] = {
            { "NO_SEQINT",          0x00, 0xff },
            { "BAD_PHASE",          0x01, 0xff },
            { "SEND_REJECT",        0x02, 0xff },
            { "PROTO_VIOLATION",    0x03, 0xff },
            { "NO_MATCH",           0x04, 0xff },
            { "IGN_WIDE_RES",       0x05, 0xff },
            { "PDATA_REINIT",       0x06, 0xff },
            { "HOST_MSG_LOOP",      0x07, 0xff },
            { "BAD_STATUS",         0x08, 0xff },
            { "DATA_OVERRUN",       0x09, 0xff },
            { "MKMSG_FAILED",       0x0a, 0xff },
            { "MISSED_BUSFREE",     0x0b, 0xff },
            { "DUMP_CARD_STATE",    0x0c, 0xff },
            { "ILLEGAL_PHASE",      0x0d, 0xff },
            { "INVALID_SEQINT",     0x0e, 0xff },
            { "CFG4ISTAT_INTR",     0x0f, 0xff },
            { "STATUS_OVERRUN",     0x10, 0xff },
            { "CFG4OVERRUN",        0x11, 0xff },
            { "ENTERING_NONPACK",   0x12, 0xff },
            { "TASKMGMT_FUNC_COMPLETE",0x13, 0xff },
            { "TASKMGMT_CMD_CMPLT_OKAY",0x14, 0xff },
            { "TRACEPOINT0",        0x15, 0xff },
            { "TRACEPOINT1",        0x16, 0xff },
            { "TRACEPOINT2",        0x17, 0xff },
            { "TRACEPOINT3",        0x18, 0xff },
            { "SAW_HWERR",          0x19, 0xff },
            { "BAD_SCB_STATUS",     0x1a, 0xff }
    };
    
    int
    ahd_seqintcode_print(u_int regvalue, u_int *cur_col, u_int wrap)
    {
            return (ahd_print_register(SEQINTCODE_parse_table, 27, "SEQINTCODE",
                0x02, regvalue, cur_col, wrap));
    }
    
    static ahd_reg_parse_entry_t CLRINT_parse_table[] = {
            { "CLRSPLTINT",         0x01, 0x01 },
            { "CLRCMDINT",          0x02, 0x02 },
            { "CLRSEQINT",          0x04, 0x04 },
            { "CLRSCSIINT",         0x08, 0x08 },
            { "CLRPCIINT",          0x10, 0x10 },
            { "CLRSWTMINT",         0x20, 0x20 },
            { "CLRBRKADRINT",       0x40, 0x40 },
            { "CLRHWERRINT",        0x80, 0x80 }
    };
    
    int
    ahd_clrint_print(u_int regvalue, u_int *cur_col, u_int wrap)
    {
            return (ahd_print_register(CLRINT_parse_table, 8, "CLRINT",
                0x03, regvalue, cur_col, wrap));
    }
    
    static ahd_reg_parse_entry_t ERROR_parse_table[] = {
           { "DSCTMOUT",           0x02, 0x02 },
           { "ILLOPCODE",          0x04, 0x04 },
           { "SQPARERR",           0x08, 0x08 },
           { "DPARERR",            0x10, 0x10 },
           { "MPARERR",            0x20, 0x20 },
           { "CIOACCESFAIL",       0x40, 0x40 },
           { "CIOPARERR",          0x80, 0x80 }
   };
   
   int
   ahd_error_print(u_int regvalue, u_int *cur_col, u_int wrap)
   {
           return (ahd_print_register(ERROR_parse_table, 7, "ERROR",
               0x04, regvalue, cur_col, wrap));
   }
   
   static ahd_reg_parse_entry_t CLRERR_parse_table[] = {
           { "CLRDSCTMOUT",        0x02, 0x02 },
           { "CLRILLOPCODE",       0x04, 0x04 },
           { "CLRSQPARERR",        0x08, 0x08 },
           { "CLRDPARERR",         0x10, 0x10 },
           { "CLRMPARERR",         0x20, 0x20 },
           { "CLRCIOACCESFAIL",    0x40, 0x40 },
           { "CLRCIOPARERR",       0x80, 0x80 }
   };
   
   int
   ahd_clrerr_print(u_int regvalue, u_int *cur_col, u_int wrap)
   {
           return (ahd_print_register(CLRERR_parse_table, 7, "CLRERR",
               0x04, regvalue, cur_col, wrap));
   }
   
   static ahd_reg_parse_entry_t HCNTRL_parse_table[] = {
           { "CHIPRST",            0x01, 0x01 },
           { "CHIPRSTACK",         0x01, 0x01 },
           { "INTEN",              0x02, 0x02 },
           { "PAUSE",              0x04, 0x04 },
           { "SWTIMER_START_B",    0x08, 0x08 },
           { "SWINT",              0x10, 0x10 },
           { "POWRDN",             0x40, 0x40 },
           { "SEQ_RESET",          0x80, 0x80 }
   };
   
   int
   ahd_hcntrl_print(u_int regvalue, u_int *cur_col, u_int wrap)
   {
           return (ahd_print_register(HCNTRL_parse_table, 8, "HCNTRL",
               0x05, regvalue, cur_col, wrap));
   }
   
   int
   ahd_hnscb_qoff_print(u_int regvalue, u_int *cur_col, u_int wrap)
   {
           return (ahd_print_register(NULL, 0, "HNSCB_QOFF",
               0x06, regvalue, cur_col, wrap));
   }
   
   int
   ahd_hescb_qoff_print(u_int regvalue, u_int *cur_col, u_int wrap)
   {
           return (ahd_print_register(NULL, 0, "HESCB_QOFF",
               0x08, regvalue, cur_col, wrap));
   }
   
   static 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 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 ahd_reg_parse_entry_t CLRSEQINTSTAT_parse_table[] = {
           { "CLRSEQ_SPLTINT",     0x01, 0x01 },
           { "CLRSEQ_PCIINT",      0x02, 0x02 },
           { "CLRSEQ_SCSIINT",     0x04, 0x04 },
           { "CLRSEQ_SEQINT",      0x08, 0x08 },
           { "CLRSEQ_SWTMRTO",     0x10, 0x10 }
   };
   
   int
   ahd_clrseqintstat_print(u_int regvalue, u_int *cur_col, u_int wrap)
   {
           return (ahd_print_register(CLRSEQINTSTAT_parse_table, 5, "CLRSEQINTSTAT",
               0x0c, regvalue, cur_col, wrap));
   }
   
   int
   ahd_swtimer_print(u_int regvalue, u_int *cur_col, u_int wrap)
   {
           return (ahd_print_register(NULL, 0, "SWTIMER",
               0x0e, regvalue, cur_col, wrap));
   }
   
   int
   ahd_snscb_qoff_print(u_int regvalue, u_int *cur_col, u_int wrap)
   {
           return (ahd_print_register(NULL, 0, "SNSCB_QOFF",
               0x10, regvalue, cur_col, wrap));
   }
   
   int
   ahd_sescb_qoff_print(u_int regvalue, u_int *cur_col, u_int wrap)
   {
           return (ahd_print_register(NULL, 0, "SESCB_QOFF",
               0x12, regvalue, cur_col, wrap));
   }
   
   int
   ahd_sdscb_qoff_print(u_int regvalue, u_int *cur_col, u_int wrap)
   {
           return (ahd_print_register(NULL, 0, "SDSCB_QOFF",
               0x14, regvalue, cur_col, wrap));
   }
   
   static ahd_reg_parse_entry_t QOFF_CTLSTA_parse_table[] = {
           { "SCB_QSIZE_4",        0x00, 0x0f },
           { "SCB_QSIZE_8",        0x01, 0x0f },
           { "SCB_QSIZE_16",       0x02, 0x0f },
           { "SCB_QSIZE_32",       0x03, 0x0f },
           { "SCB_QSIZE_64",       0x04, 0x0f },
           { "SCB_QSIZE_128",      0x05, 0x0f },
           { "SCB_QSIZE_256",      0x06, 0x0f },
           { "SCB_QSIZE_512",      0x07, 0x0f },
           { "SCB_QSIZE_1024",     0x08, 0x0f },
           { "SCB_QSIZE_2048",     0x09, 0x0f },
           { "SCB_QSIZE_4096",     0x0a, 0x0f },
           { "SCB_QSIZE_8192",     0x0b, 0x0f },
           { "SCB_QSIZE_16384",    0x0c, 0x0f },
           { "SCB_QSIZE",          0x0f, 0x0f },
           { "HS_MAILBOX_ACT",     0x10, 0x10 },
           { "SDSCB_ROLLOVR",      0x20, 0x20 },
           { "NEW_SCB_AVAIL",      0x40, 0x40 },
           { "EMPTY_SCB_AVAIL",    0x80, 0x80 }
   };
   
   int
   ahd_qoff_ctlsta_print(u_int regvalue, u_int *cur_col, u_int wrap)
   {
           return (ahd_print_register(QOFF_CTLSTA_parse_table, 18, "QOFF_CTLSTA",
               0x16, regvalue, cur_col, wrap));
   }
   
   static 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 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 ahd_reg_parse_entry_t DSCOMMAND0_parse_table[] = {
           { "CIOPARCKEN",         0x01, 0x01 },
           { "DISABLE_TWATE",      0x02, 0x02 },
           { "EXTREQLCK",          0x10, 0x10 },
           { "MPARCKEN",           0x20, 0x20 },
           { "DPARCKEN",           0x40, 0x40 },
           { "CACHETHEN",          0x80, 0x80 }
   };
   
   int
   ahd_dscommand0_print(u_int regvalue, u_int *cur_col, u_int wrap)
   {
           return (ahd_print_register(DSCOMMAND0_parse_table, 6, "DSCOMMAND0",
               0x19, regvalue, cur_col, wrap));
   }
   
   static 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 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 ahd_reg_parse_entry_t SG_CACHE_PRE_parse_table[] = {
           { "LAST_SEG",           0x02, 0x02 },
           { "ODD_SEG",            0x04, 0x04 },
           { "SG_ADDR_MASK",       0xf8, 0xf8 }
   };
   
   int
   ahd_sg_cache_pre_print(u_int regvalue, u_int *cur_col, u_int wrap)
   {
           return (ahd_print_register(SG_CACHE_PRE_parse_table, 3, "SG_CACHE_PRE",
               0x1b, regvalue, cur_col, wrap));
   }
   
   static ahd_reg_parse_entry_t ARBCTL_parse_table[] = {
           { "USE_TIME",           0x07, 0x07 },
           { "RETRY_SWEN",         0x08, 0x08 },
           { "RESET_HARB",         0x80, 0x80 }
   };
   
   int
   ahd_arbctl_print(u_int regvalue, u_int *cur_col, u_int wrap)
   {
           return (ahd_print_register(ARBCTL_parse_table, 3, "ARBCTL",
               0x1b, regvalue, cur_col, wrap));
   }
   
   int
   ahd_lqin_print(u_int regvalue, u_int *cur_col, u_int wrap)
   {
           return (ahd_print_register(NULL, 0, "LQIN",
               0x20, regvalue, cur_col, wrap));
   }
   
   int
   ahd_typeptr_print(u_int regvalue, u_int *cur_col, u_int wrap)
   {
           return (ahd_print_register(NULL, 0, "TYPEPTR",
               0x20, regvalue, cur_col, wrap));
   }
   
   int
   ahd_tagptr_print(u_int regvalue, u_int *cur_col, u_int wrap)
   {
           return (ahd_print_register(NULL, 0, "TAGPTR",
               0x21, regvalue, cur_col, wrap));
   }
   
   int
   ahd_lunptr_print(u_int regvalue, u_int *cur_col, u_int wrap)
   {
           return (ahd_print_register(NULL, 0, "LUNPTR",
               0x22, regvalue, cur_col, wrap));
   }
   
   int
   ahd_datalenptr_print(u_int regvalue, u_int *cur_col, u_int wrap)
   {
           return (ahd_print_register(NULL, 0, "DATALENPTR",
               0x23, regvalue, cur_col, wrap));
   }
   
   int
   ahd_statlenptr_print(u_int regvalue, u_int *cur_col, u_int wrap)
   {
           return (ahd_print_register(NULL, 0, "STATLENPTR",
               0x24, regvalue, cur_col, wrap));
   }
   
   int
   ahd_cmdlenptr_print(u_int regvalue, u_int *cur_col, u_int wrap)
   {
           return (ahd_print_register(NULL, 0, "CMDLENPTR",
               0x25, regvalue, cur_col, wrap));
   }
   
   int
   ahd_attrptr_print(u_int regvalue, u_int *cur_col, u_int wrap)
   {
           return (ahd_print_register(NULL, 0, "ATTRPTR",
               0x26, regvalue, cur_col, wrap));
   }
   
   int
   ahd_flagptr_print(u_int regvalue, u_int *cur_col, u_int wrap)
   {
           return (ahd_print_register(NULL, 0, "FLAGPTR",
               0x27, regvalue, cur_col, wrap));
   }
   
   int
   ahd_cmdptr_print(u_int regvalue, u_int *cur_col, u_int wrap)
   {
           return (ahd_print_register(NULL, 0, "CMDPTR",
               0x28, regvalue, cur_col, wrap));
   }
   
   int
   ahd_qnextptr_print(u_int regvalue, u_int *cur_col, u_int wrap)
   {
           return (ahd_print_register(NULL, 0, "QNEXTPTR",
               0x29, regvalue, cur_col, wrap));
   }
   
   int
   ahd_idptr_print(u_int regvalue, u_int *cur_col, u_int wrap)
   {
           return (ahd_print_register(NULL, 0, "IDPTR",
               0x2a, regvalue, cur_col, wrap));
   }
   
   int
   ahd_abrtbyteptr_print(u_int regvalue, u_int *cur_col, u_int wrap)
   {
           return (ahd_print_register(NULL, 0, "ABRTBYTEPTR",
               0x2b, regvalue, cur_col, wrap));
   }
   
   int
   ahd_abrtbitptr_print(u_int regvalue, u_int *cur_col, u_int wrap)
   {
           return (ahd_print_register(NULL, 0, "ABRTBITPTR",
               0x2c, regvalue, cur_col, wrap));
   }
   
   int
   ahd_maxcmdbytes_print(u_int regvalue, u_int *cur_col, u_int wrap)
   {
           return (ahd_print_register(NULL, 0, "MAXCMDBYTES",
               0x2d, regvalue, cur_col, wrap));
   }
   
   int
   ahd_maxcmd2rcv_print(u_int regvalue, u_int *cur_col, u_int wrap)
   {
           return (ahd_print_register(NULL, 0, "MAXCMD2RCV",
               0x2e, regvalue, cur_col, wrap));
   }
   
   int
   ahd_shortthresh_print(u_int regvalue, u_int *cur_col, u_int wrap)
   {
           return (ahd_print_register(NULL, 0, "SHORTTHRESH",
               0x2f, regvalue, cur_col, wrap));
   }
   
   static ahd_reg_parse_entry_t LUNLEN_parse_table[] = {
           { "ILUNLEN",            0x0f, 0x0f },
           { "TLUNLEN",            0xf0, 0xf0 }
   };
   
   int
   ahd_lunlen_print(u_int regvalue, u_int *cur_col, u_int wrap)
   {
           return (ahd_print_register(LUNLEN_parse_table, 2, "LUNLEN",
               0x30, regvalue, cur_col, wrap));
   }
   
   int
   ahd_cdblimit_print(u_int regvalue, u_int *cur_col, u_int wrap)
   {
           return (ahd_print_register(NULL, 0, "CDBLIMIT",
               0x31, regvalue, cur_col, wrap));
   }
   
   int
   ahd_maxcmd_print(u_int regvalue, u_int *cur_col, u_int wrap)
   {
           return (ahd_print_register(NULL, 0, "MAXCMD",
               0x32, regvalue, cur_col, wrap));
   }
   
   int
   ahd_maxcmdcnt_print(u_int regvalue, u_int *cur_col, u_int wrap)
   {
           return (ahd_print_register(NULL, 0, "MAXCMDCNT",
               0x33, regvalue, cur_col, wrap));
   }
   
   int
   ahd_lqrsvd01_print(u_int regvalue, u_int *cur_col, u_int wrap)
   {
           return (ahd_print_register(NULL, 0, "LQRSVD01",
               0x34, regvalue, cur_col, wrap));
   }
   
   int
   ahd_lqrsvd16_print(u_int regvalue, u_int *cur_col, u_int wrap)
   {
           return (ahd_print_register(NULL, 0, "LQRSVD16",
               0x35, regvalue, cur_col, wrap));
   }
   
   int
   ahd_lqrsvd17_print(u_int regvalue, u_int *cur_col, u_int wrap)
   {
           return (ahd_print_register(NULL, 0, "LQRSVD17",
               0x36, regvalue, cur_col, wrap));
   }
   
   int
   ahd_cmdrsvd0_print(u_int regvalue, u_int *cur_col, u_int wrap)
   {
           return (ahd_print_register(NULL, 0, "CMDRSVD0",
               0x37, regvalue, cur_col, wrap));
   }
   
   static ahd_reg_parse_entry_t LQCTL0_parse_table[] = {
           { "LQ0INITGCLT",        0x03, 0x03 },
           { "LQ0TARGCLT",         0x0c, 0x0c },
           { "LQIINITGCLT",        0x30, 0x30 },
           { "LQITARGCLT",         0xc0, 0xc0 }
   };
   
   int
   ahd_lqctl0_print(u_int regvalue, u_int *cur_col, u_int wrap)
   {
           return (ahd_print_register(LQCTL0_parse_table, 4, "LQCTL0",
               0x38, regvalue, cur_col, wrap));
   }
   
   static ahd_reg_parse_entry_t LQCTL1_parse_table[] = {
           { "ABORTPENDING",       0x01, 0x01 },
           { "SINGLECMD",          0x02, 0x02 },
           { "PCI2PCI",            0x04, 0x04 }
   };
   
   int
   ahd_lqctl1_print(u_int regvalue, u_int *cur_col, u_int wrap)
   {
           return (ahd_print_register(LQCTL1_parse_table, 3, "LQCTL1",
               0x38, regvalue, cur_col, wrap));
   }
   
   static ahd_reg_parse_entry_t LQCTL2_parse_table[] = {
           { "LQOPAUSE",           0x01, 0x01 },
           { "LQOTOIDLE",          0x02, 0x02 },
           { "LQOCONTINUE",        0x04, 0x04 },
           { "LQORETRY",           0x08, 0x08 },
           { "LQIPAUSE",           0x10, 0x10 },
           { "LQITOIDLE",          0x20, 0x20 },
           { "LQICONTINUE",        0x40, 0x40 },
           { "LQIRETRY",           0x80, 0x80 }
   };
   
   int
   ahd_lqctl2_print(u_int regvalue, u_int *cur_col, u_int wrap)
   {
           return (ahd_print_register(LQCTL2_parse_table, 8, "LQCTL2",
               0x39, regvalue, cur_col, wrap));
   }
   
   static ahd_reg_parse_entry_t SCSBIST0_parse_table[] = {
           { "OSBISTRUN",          0x01, 0x01 },
           { "OSBISTDONE",         0x02, 0x02 },
           { "OSBISTERR",          0x04, 0x04 },
           { "GSBISTRUN",          0x10, 0x10 },
           { "GSBISTDONE",         0x20, 0x20 },
           { "GSBISTERR",          0x40, 0x40 }
   };
   
   int
   ahd_scsbist0_print(u_int regvalue, u_int *cur_col, u_int wrap)
   {
           return (ahd_print_register(SCSBIST0_parse_table, 6, "SCSBIST0",
               0x39, regvalue, cur_col, wrap));
   }
   
   static 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 ahd_reg_parse_entry_t SCSBIST1_parse_table[] = {
           { "NTBISTRUN",          0x01, 0x01 },
           { "NTBISTDONE",         0x02, 0x02 },
           { "NTBISTERR",          0x04, 0x04 }
   };
   
   int
   ahd_scsbist1_print(u_int regvalue, u_int *cur_col, u_int wrap)
   {
           return (ahd_print_register(SCSBIST1_parse_table, 3, "SCSBIST1",
               0x3a, regvalue, cur_col, wrap));
   }
   
   static 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));
   }
   
   int
   ahd_businitid_print(u_int regvalue, u_int *cur_col, u_int wrap)
   {
           return (ahd_print_register(NULL, 0, "BUSINITID",
               0x3c, regvalue, cur_col, wrap));
   }
   
   static ahd_reg_parse_entry_t SXFRCTL0_parse_table[] = {
           { "SPIOEN",             0x08, 0x08 },
           { "BIOSCANCELEN",       0x10, 0x10 },
           { "DFPEXP",             0x40, 0x40 },
           { "DFON",               0x80, 0x80 }
   };
   
   int
   ahd_sxfrctl0_print(u_int regvalue, u_int *cur_col, u_int wrap)
   {
           return (ahd_print_register(SXFRCTL0_parse_table, 4, "SXFRCTL0",
               0x3c, regvalue, cur_col, wrap));
   }
   
   int
   ahd_dlcount_print(u_int regvalue, u_int *cur_col, u_int wrap)
   {
           return (ahd_print_register(NULL, 0, "DLCOUNT",
               0x3c, regvalue, cur_col, wrap));
   }
   
   static ahd_reg_parse_entry_t SXFRCTL1_parse_table[] = {
           { "STPWEN",             0x01, 0x01 },
           { "ACTNEGEN",           0x02, 0x02 },
           { "ENSTIMER",           0x04, 0x04 },
           { "STIMESEL",           0x18, 0x18 },
           { "ENSPCHK",            0x20, 0x20 },
           { "ENSACHK",            0x40, 0x40 },
           { "BITBUCKET",          0x80, 0x80 }
   };
   
   int
   ahd_sxfrctl1_print(u_int regvalue, u_int *cur_col, u_int wrap)
   {
           return (ahd_print_register(SXFRCTL1_parse_table, 7, "SXFRCTL1",
               0x3d, regvalue, cur_col, wrap));
   }
   
   int
   ahd_bustargid_print(u_int regvalue, u_int *cur_col, u_int wrap)
   {
           return (ahd_print_register(NULL, 0, "BUSTARGID",
               0x3e, regvalue, cur_col, wrap));
   }
   
   static ahd_reg_parse_entry_t SXFRCTL2_parse_table[] = {
           { "ASU",                0x07, 0x07 },
           { "CMDDMAEN",           0x08, 0x08 },
           { "AUTORSTDIS",         0x10, 0x10 }
   };
   
   int
   ahd_sxfrctl2_print(u_int regvalue, u_int *cur_col, u_int wrap)
   {
           return (ahd_print_register(SXFRCTL2_parse_table, 3, "SXFRCTL2",
               0x3e, regvalue, cur_col, wrap));
   }
   
   static 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 ahd_reg_parse_entry_t SCSISIGO_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 },
           { "ACKO",               0x01, 0x01 },
           { "REQO",               0x02, 0x02 },
           { "BSYO",               0x04, 0x04 },
           { "SELO",               0x08, 0x08 },
           { "ATNO",               0x10, 0x10 },
           { "MSGO",               0x20, 0x20 },
           { "IOO",                0x40, 0x40 },
           { "CDO",                0x80, 0x80 },
           { "PHASE_MASK",         0xe0, 0xe0 }
   };
   
   int
   ahd_scsisigo_print(u_int regvalue, u_int *cur_col, u_int wrap)
   {
           return (ahd_print_register(SCSISIGO_parse_table, 17, "SCSISIGO",
               0x40, regvalue, cur_col, wrap));
   }
   
   int
   ahd_multargid_print(u_int regvalue, u_int *cur_col, u_int wrap)
   {
           return (ahd_print_register(NULL, 0, "MULTARGID",
               0x40, regvalue, cur_col, wrap));
   }
   
   static 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 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_scsidat0_img_print(u_int regvalue, u_int *cur_col, u_int wrap)
   {
           return (ahd_print_register(NULL, 0, "SCSIDAT0_IMG",
               0x43, regvalue, cur_col, wrap));
   }
   
   int
   ahd_scsidat_print(u_int regvalue, u_int *cur_col, u_int wrap)
   {
           return (ahd_print_register(NULL, 0, "SCSIDAT",
               0x44, 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 ahd_reg_parse_entry_t TARGIDIN_parse_table[] = {
           { "TARGID",             0x0f, 0x0f },
           { "CLKOUT",             0x80, 0x80 }
   };
   
   int
   ahd_targidin_print(u_int regvalue, u_int *cur_col, u_int wrap)
   {
           return (ahd_print_register(TARGIDIN_parse_table, 2, "TARGIDIN",
               0x48, regvalue, cur_col, wrap));
   }
   
   static 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 ahd_reg_parse_entry_t OPTIONMODE_parse_table[] = {
           { "AUTO_MSGOUT_DE",     0x02, 0x02 },
           { "ENDGFORMCHK",        0x04, 0x04 },
           { "BUSFREEREV",         0x10, 0x10 },
           { "BIASCANCTL",         0x20, 0x20 },
           { "AUTOACKEN",          0x40, 0x40 },
           { "BIOSCANCTL",         0x80, 0x80 },
           { "OPTIONMODE_DEFAULTS",0x02, 0x02 }
   };
   
   int
   ahd_optionmode_print(u_int regvalue, u_int *cur_col, u_int wrap)
   {
           return (ahd_print_register(OPTIONMODE_parse_table, 7, "OPTIONMODE",
               0x4a, regvalue, cur_col, wrap));
   }
   
   static ahd_reg_parse_entry_t SBLKCTL_parse_table[] = {
           { "SELWIDE",            0x02, 0x02 },
           { "ENAB20",             0x04, 0x04 },
           { "ENAB40",             0x08, 0x08 },
           { "DIAGLEDON",          0x40, 0x40 },
           { "DIAGLEDEN",          0x80, 0x80 }
   };
   
   int
   ahd_sblkctl_print(u_int regvalue, u_int *cur_col, u_int wrap)
   {
           return (ahd_print_register(SBLKCTL_parse_table, 5, "SBLKCTL",
               0x4a, regvalue, cur_col, wrap));
   }
   
   static 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 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 ahd_reg_parse_entry_t CLRSINT0_parse_table[] = {
           { "CLRARBDO",           0x01, 0x01 },
           { "CLRSPIORDY",         0x02, 0x02 },
           { "CLROVERRUN",         0x04, 0x04 },
           { "CLRIOERR",           0x08, 0x08 },
           { "CLRSELINGO",         0x10, 0x10 },
           { "CLRSELDI",           0x20, 0x20 },
           { "CLRSELDO",           0x40, 0x40 }
   };
   
   int
   ahd_clrsint0_print(u_int regvalue, u_int *cur_col, u_int wrap)
   {
           return (ahd_print_register(CLRSINT0_parse_table, 7, "CLRSINT0",
               0x4b, regvalue, cur_col, wrap));
   }
   
   static 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 ahd_reg_parse_entry_t CLRSINT1_parse_table[] = {
           { "CLRREQINIT",         0x01, 0x01 },
           { "CLRSTRB2FAST",       0x02, 0x02 },
           { "CLRSCSIPERR",        0x04, 0x04 },
           { "CLRBUSFREE",         0x08, 0x08 },
           { "CLRSCSIRSTI",        0x20, 0x20 },
           { "CLRATNO",            0x40, 0x40 },
           { "CLRSELTIMEO",        0x80, 0x80 }
   };
   
   int
   ahd_clrsint1_print(u_int regvalue, u_int *cur_col, u_int wrap)
   {
           return (ahd_print_register(CLRSINT1_parse_table, 7, "CLRSINT1",
               0x4c, regvalue, cur_col, wrap));
   }
   
   static 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 ahd_reg_parse_entry_t CLRSINT2_parse_table[] = {
          { "CLRDMADONE",         0x01, 0x01 },
          { "CLRSDONE",           0x02, 0x02 },
          { "CLRWIDE_RES",        0x04, 0x04 },
          { "CLRNONPACKREQ",      0x20, 0x20 }
  };
  
  int
  ahd_clrsint2_print(u_int regvalue, u_int *cur_col, u_int wrap)
  {
          return (ahd_print_register(CLRSINT2_parse_table, 4, "CLRSINT2",
              0x4d, regvalue, cur_col, wrap));
  }
  
  static ahd_reg_parse_entry_t SIMODE2_parse_table[] = {
          { "ENDMADONE",          0x01, 0x01 },
          { "ENSDONE",            0x02, 0x02 },
          { "ENWIDE_RES",         0x04, 0x04 }
  };
  
  int
  ahd_simode2_print(u_int regvalue, u_int *cur_col, u_int wrap)
  {
          return (ahd_print_register(SIMODE2_parse_table, 3, "SIMODE2",
              0x4d, regvalue, cur_col, wrap));
  }
  
  static 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_lqistate_print(u_int regvalue, u_int *cur_col, u_int wrap)
  {
          return (ahd_print_register(NULL, 0, "LQISTATE",
              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));
  }
  
  int
  ahd_lqostate_print(u_int regvalue, u_int *cur_col, u_int wrap)
  {
          return (ahd_print_register(NULL, 0, "LQOSTATE",
              0x4f, regvalue, cur_col, wrap));
  }
  
  static 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 ahd_reg_parse_entry_t CLRLQIINT0_parse_table[] = {
          { "CLRLQIATNCMD",       0x01, 0x01 },
          { "CLRLQIATNLQ",        0x02, 0x02 },
          { "CLRLQIBADLQT",       0x04, 0x04 },
          { "CLRLQICRCT2",        0x08, 0x08 },
          { "CLRLQICRCT1",        0x10, 0x10 },
          { "CLRLQIATNQAS",       0x20, 0x20 }
  };
  
  int
  ahd_clrlqiint0_print(u_int regvalue, u_int *cur_col, u_int wrap)
  {
          return (ahd_print_register(CLRLQIINT0_parse_table, 6, "CLRLQIINT0",
              0x50, regvalue, cur_col, wrap));
  }
  
  static ahd_reg_parse_entry_t LQIMODE0_parse_table[] = {
          { "ENLQIATNCMD",        0x01, 0x01 },
          { "ENLQIATNLQ",         0x02, 0x02 },
          { "ENLQIBADLQT",        0x04, 0x04 },
          { "ENLQICRCT2",         0x08, 0x08 },
          { "ENLQICRCT1",         0x10, 0x10 },
          { "ENLQIATNQASK",       0x20, 0x20 }
  };
  
  int
  ahd_lqimode0_print(u_int regvalue, u_int *cur_col, u_int wrap)
  {
          return (ahd_print_register(LQIMODE0_parse_table, 6, "LQIMODE0",
              0x50, regvalue, cur_col, wrap));
  }
  
  static 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 ahd_reg_parse_entry_t CLRLQIINT1_parse_table[] = {
          { "CLRLQIOVERI_NLQ",    0x01, 0x01 },
          { "CLRLQIOVERI_LQ",     0x02, 0x02 },
          { "CLRLQIBADLQI",       0x04, 0x04 },
          { "CLRLQICRCI_NLQ",     0x08, 0x08 },
          { "CLRLQICRCI_LQ",      0x10, 0x10 },
          { "CLRLIQABORT",        0x20, 0x20 },
          { "CLRLQIPHASE_NLQ",    0x40, 0x40 },
          { "CLRLQIPHASE_LQ",     0x80, 0x80 }
  };
  
  int
  ahd_clrlqiint1_print(u_int regvalue, u_int *cur_col, u_int wrap)
  {
          return (ahd_print_register(CLRLQIINT1_parse_table, 8, "CLRLQIINT1",
              0x51, regvalue, cur_col, wrap));
  }
  
  static ahd_reg_parse_entry_t LQIMODE1_parse_table[] = {
          { "ENLQIOVERI_NLQ",     0x01, 0x01 },
          { "ENLQIOVERI_LQ",      0x02, 0x02 },
          { "ENLQIBADLQI",        0x04, 0x04 },
          { "ENLQICRCI_NLQ",      0x08, 0x08 },
          { "ENLQICRCI_LQ",       0x10, 0x10 },
          { "ENLIQABORT",         0x20, 0x20 },
          { "ENLQIPHASE_NLQ",     0x40, 0x40 },
          { "ENLQIPHASE_LQ",      0x80, 0x80 }
  };
  
  int
  ahd_lqimode1_print(u_int regvalue, u_int *cur_col, u_int wrap)
  {
          return (ahd_print_register(LQIMODE1_parse_table, 8, "LQIMODE1",
              0x51, regvalue, cur_col, wrap));
  }
  
  static 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 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 ahd_reg_parse_entry_t CLRSINT3_parse_table[] = {
          { "CLROSRAMPERR",       0x01, 0x01 },
          { "CLRNTRAMPERR",       0x02, 0x02 }
  };
  
  int
  ahd_clrsint3_print(u_int regvalue, u_int *cur_col, u_int wrap)
  {
          return (ahd_print_register(CLRSINT3_parse_table, 2, "CLRSINT3",
              0x53, regvalue, cur_col, wrap));
  }
  
  static ahd_reg_parse_entry_t SIMODE3_parse_table[] = {
          { "ENOSRAMPERR",        0x01, 0x01 },
          { "ENNTRAMPERR",        0x02, 0x02 }
  };
  
  int
  ahd_simode3_print(u_int regvalue, u_int *cur_col, u_int wrap)
  {
          return (ahd_print_register(SIMODE3_parse_table, 2, "SIMODE3",
              0x53, regvalue, cur_col, wrap));
  }
  
  static ahd_reg_parse_entry_t LQOMODE0_parse_table[] = {
          { "ENLQOTCRC",          0x01, 0x01 },
          { "ENLQOATNPKT",        0x02, 0x02 },
          { "ENLQOATNLQ",         0x04, 0x04 },
          { "ENLQOSTOPT2",        0x08, 0x08 },
          { "ENLQOTARGSCBPERR",   0x10, 0x10 }
  };
  
  int
  ahd_lqomode0_print(u_int regvalue, u_int *cur_col, u_int wrap)
  {
          return (ahd_print_register(LQOMODE0_parse_table, 5, "LQOMODE0",
              0x54, regvalue, cur_col, wrap));
  }
  
  static 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 ahd_reg_parse_entry_t CLRLQOINT0_parse_table[] = {
          { "CLRLQOTCRC",         0x01, 0x01 },
          { "CLRLQOATNPKT",       0x02, 0x02 },
          { "CLRLQOATNLQ",        0x04, 0x04 },
          { "CLRLQOSTOPT2",       0x08, 0x08 },
          { "CLRLQOTARGSCBPERR",  0x10, 0x10 }
  };
  
  int
  ahd_clrlqoint0_print(u_int regvalue, u_int *cur_col, u_int wrap)
  {
          return (ahd_print_register(CLRLQOINT0_parse_table, 5, "CLRLQOINT0",
              0x54, regvalue, cur_col, wrap));
  }
  
  static ahd_reg_parse_entry_t LQOMODE1_parse_table[] = {
          { "ENLQOPHACHGINPKT",   0x01, 0x01 },
          { "ENLQOBUSFREE",       0x02, 0x02 },
          { "ENLQOBADQAS",        0x04, 0x04 },
          { "ENLQOSTOPI2",        0x08, 0x08 },
          { "ENLQOINITSCBPERR",   0x10, 0x10 }
  };
  
  int
  ahd_lqomode1_print(u_int regvalue, u_int *cur_col, u_int wrap)
  {
          return (ahd_print_register(LQOMODE1_parse_table, 5, "LQOMODE1",
              0x55, regvalue, cur_col, wrap));
  }
  
  static 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 ahd_reg_parse_entry_t CLRLQOINT1_parse_table[] = {
          { "CLRLQOPHACHGINPKT",  0x01, 0x01 },
          { "CLRLQOBUSFREE",      0x02, 0x02 },
          { "CLRLQOBADQAS",       0x04, 0x04 },
          { "CLRLQOSTOPI2",       0x08, 0x08 },
          { "CLRLQOINITSCBPERR",  0x10, 0x10 }
  };
  
  int
  ahd_clrlqoint1_print(u_int regvalue, u_int *cur_col, u_int wrap)
  {
          return (ahd_print_register(CLRLQOINT1_parse_table, 5, "CLRLQOINT1",
              0x55, regvalue, cur_col, wrap));
  }
  
  int
  ahd_os_space_cnt_print(u_int regvalue, u_int *cur_col, u_int wrap)
  {
          return (ahd_print_register(NULL, 0, "OS_SPACE_CNT",
              0x56, regvalue, cur_col, wrap));
  }
  
  static 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 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));
  }
  
  int
  ahd_gsfifo_print(u_int regvalue, u_int *cur_col, u_int wrap)
  {
          return (ahd_print_register(NULL, 0, "GSFIFO",
              0x58, regvalue, cur_col, wrap));
  }
  
  static 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));
  }
  
  int
  ahd_nextscb_print(u_int regvalue, u_int *cur_col, u_int wrap)
  {
          return (ahd_print_register(NULL, 0, "NEXTSCB",
              0x5a, regvalue, cur_col, wrap));
  }
  
  static ahd_reg_parse_entry_t LQOSCSCTL_parse_table[] = {
          { "LQONOCHKOVER",       0x01, 0x01 },
          { "LQOH2A_VERSION",     0x80, 0x80 }
  };
  
  int
  ahd_lqoscsctl_print(u_int regvalue, u_int *cur_col, u_int wrap)
  {
          return (ahd_print_register(LQOSCSCTL_parse_table, 2, "LQOSCSCTL",
              0x5a, regvalue, cur_col, wrap));
  }
  
  static 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 ahd_reg_parse_entry_t CLRSEQINTSRC_parse_table[] = {
          { "CLRCFG4TCMD",        0x01, 0x01 },
          { "CLRCFG4ICMD",        0x02, 0x02 },
          { "CLRCFG4TSTAT",       0x04, 0x04 },
          { "CLRCFG4ISTAT",       0x08, 0x08 },
          { "CLRCFG4DATA",        0x10, 0x10 },
          { "CLRSAVEPTRS",        0x20, 0x20 },
          { "CLRCTXTDONE",        0x40, 0x40 }
  };
  
  int
  ahd_clrseqintsrc_print(u_int regvalue, u_int *cur_col, u_int wrap)
  {
          return (ahd_print_register(CLRSEQINTSRC_parse_table, 7, "CLRSEQINTSRC",
              0x5b, regvalue, cur_col, wrap));
  }
  
  int
  ahd_currscb_print(u_int regvalue, u_int *cur_col, u_int wrap)
  {
          return (ahd_print_register(NULL, 0, "CURRSCB",
              0x5c, regvalue, cur_col, wrap));
  }
  
  static 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 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));
  }
  
  static ahd_reg_parse_entry_t CRCCONTROL_parse_table[] = {
          { "CRCVALCHKEN",        0x40, 0x40 }
  };
  
  int
  ahd_crccontrol_print(u_int regvalue, u_int *cur_col, u_int wrap)
  {
          return (ahd_print_register(CRCCONTROL_parse_table, 1, "CRCCONTROL",
              0x5d, regvalue, cur_col, wrap));
  }
  
  static ahd_reg_parse_entry_t SCSITEST_parse_table[] = {
          { "SEL_TXPLL_DEBUG",    0x04, 0x04 },
          { "CNTRTEST",           0x08, 0x08 }
  };
  
  int
  ahd_scsitest_print(u_int regvalue, u_int *cur_col, u_int wrap)
  {
          return (ahd_print_register(SCSITEST_parse_table, 2, "SCSITEST",
              0x5e, regvalue, cur_col, wrap));
  }
  
  int
  ahd_dfftag_print(u_int regvalue, u_int *cur_col, u_int wrap)
  {
          return (ahd_print_register(NULL, 0, "DFFTAG",
              0x5e, regvalue, cur_col, wrap));
  }
  
  int
  ahd_lastscb_print(u_int regvalue, u_int *cur_col, u_int wrap)
  {
          return (ahd_print_register(NULL, 0, "LASTSCB",
              0x5e, regvalue, cur_col, wrap));
  }
  
  static ahd_reg_parse_entry_t IOPDNCTL_parse_table[] = {
          { "PDN_DIFFSENSE",      0x01, 0x01 },
          { "PDN_IDIST",          0x04, 0x04 },
          { "DISABLE_OE",         0x80, 0x80 }
  };
  
  int
  ahd_iopdnctl_print(u_int regvalue, u_int *cur_col, u_int wrap)
  {
          return (ahd_print_register(IOPDNCTL_parse_table, 3, "IOPDNCTL",
              0x5f, regvalue, cur_col, wrap));
  }
  
  int
  ahd_negoaddr_print(u_int regvalue, u_int *cur_col, u_int wrap)
  {
          return (ahd_print_register(NULL, 0, "NEGOADDR",
              0x60, regvalue, cur_col, wrap));
  }
  
  int
  ahd_shaddr_print(u_int regvalue, u_int *cur_col, u_int wrap)
  {
          return (ahd_print_register(NULL, 0, "SHADDR",
              0x60, regvalue, cur_col, wrap));
  }
  
  int
  ahd_dgrpcrci_print(u_int regvalue, u_int *cur_col, u_int wrap)
  {
          return (ahd_print_register(NULL, 0, "DGRPCRCI",
              0x60, regvalue, cur_col, wrap));
  }
  
  int
  ahd_negperiod_print(u_int regvalue, u_int *cur_col, u_int wrap)
  {
          return (ahd_print_register(NULL, 0, "NEGPERIOD",
              0x61, regvalue, cur_col, wrap));
  }
  
  int
  ahd_packcrci_print(u_int regvalue, u_int *cur_col, u_int wrap)
  {
          return (ahd_print_register(NULL, 0, "PACKCRCI",
              0x62, regvalue, cur_col, wrap));
  }
  
  int
  ahd_negoffset_print(u_int regvalue, u_int *cur_col, u_int wrap)
  {
          return (ahd_print_register(NULL, 0, "NEGOFFSET",
              0x62, regvalue, cur_col, wrap));
  }
  
  static ahd_reg_parse_entry_t NEGPPROPTS_parse_table[] = {
          { "PPROPT_IUT",         0x01, 0x01 },
          { "PPROPT_DT",          0x02, 0x02 },
          { "PPROPT_QAS",         0x04, 0x04 },
          { "PPROPT_PACE",        0x08, 0x08 }
  };
  
  int
  ahd_negppropts_print(u_int regvalue, u_int *cur_col, u_int wrap)
  {
          return (ahd_print_register(NEGPPROPTS_parse_table, 4, "NEGPPROPTS",
              0x63, regvalue, cur_col, wrap));
  }
  
  static ahd_reg_parse_entry_t NEGCONOPTS_parse_table[] = {
          { "WIDEXFER",           0x01, 0x01 },
          { "ENAUTOATNO",         0x02, 0x02 },
          { "ENAUTOATNI",         0x04, 0x04 },
          { "ENSLOWCRC",          0x08, 0x08 },
          { "RTI_OVRDTRN",        0x10, 0x10 },
          { "RTI_WRTDIS",         0x20, 0x20 },
          { "ENSNAPSHOT",         0x40, 0x40 }
  };
  
  int
  ahd_negconopts_print(u_int regvalue, u_int *cur_col, u_int wrap)
  {
          return (ahd_print_register(NEGCONOPTS_parse_table, 7, "NEGCONOPTS",
              0x64, regvalue, cur_col, wrap));
  }
  
  int
  ahd_annexcol_print(u_int regvalue, u_int *cur_col, u_int wrap)
  {
          return (ahd_print_register(NULL, 0, "ANNEXCOL",
              0x65, regvalue, cur_col, wrap));
  }
  
  int
  ahd_annexdat_print(u_int regvalue, u_int *cur_col, u_int wrap)
  {
          return (ahd_print_register(NULL, 0, "ANNEXDAT",
              0x66, regvalue, cur_col, wrap));
  }
  
  static ahd_reg_parse_entry_t SCSCHKN_parse_table[] = {
          { "LSTSGCLRDIS",        0x01, 0x01 },
          { "SHVALIDSTDIS",       0x02, 0x02 },
          { "DFFACTCLR",          0x04, 0x04 },
          { "SDONEMSKDIS",        0x08, 0x08 },
          { "WIDERESEN",          0x10, 0x10 },
          { "CURRFIFODEF",        0x20, 0x20 },
          { "STSELSKIDDIS",       0x40, 0x40 }
  };
  
  int
  ahd_scschkn_print(u_int regvalue, u_int *cur_col, u_int wrap)
  {
          return (ahd_print_register(SCSCHKN_parse_table, 7, "SCSCHKN",
              0x66, regvalue, cur_col, wrap));
  }
  
  int
  ahd_iownid_print(u_int regvalue, u_int *cur_col, u_int wrap)
  {
          return (ahd_print_register(NULL, 0, "IOWNID",
              0x67, regvalue, cur_col, wrap));
  }
  
  int
  ahd_shcnt_print(u_int regvalue, u_int *cur_col, u_int wrap)
  {
          return (ahd_print_register(NULL, 0, "SHCNT",
              0x68, regvalue, cur_col, wrap));
  }
  
  static ahd_reg_parse_entry_t PLL960CTL0_parse_table[] = {
          { "PLL_ENFBM",          0x01, 0x01 },
          { "PLL_DLPF",           0x02, 0x02 },
          { "PLL_ENLPF",          0x04, 0x04 },
          { "PLL_ENLUD",          0x08, 0x08 },
          { "PLL_NS",             0x30, 0x30 },
          { "PLL_PWDN",           0x40, 0x40 },
          { "PLL_VCOSEL",         0x80, 0x80 }
  };
  
  int
  ahd_pll960ctl0_print(u_int regvalue, u_int *cur_col, u_int wrap)
  {
          return (ahd_print_register(PLL960CTL0_parse_table, 7, "PLL960CTL0",
              0x68, regvalue, cur_col, wrap));
  }
  
  static ahd_reg_parse_entry_t PLL960CTL1_parse_table[] = {
          { "PLL_RST",            0x01, 0x01 },
          { "PLL_CNTCLR",         0x40, 0x40 },
          { "PLL_CNTEN",          0x80, 0x80 }
  };
  
  int
  ahd_pll960ctl1_print(u_int regvalue, u_int *cur_col, u_int wrap)
  {
          return (ahd_print_register(PLL960CTL1_parse_table, 3, "PLL960CTL1",
              0x69, regvalue, cur_col, wrap));
  }
  
  int
  ahd_townid_print(u_int regvalue, u_int *cur_col, u_int wrap)
  {
          return (ahd_print_register(NULL, 0, "TOWNID",
              0x69, regvalue, cur_col, wrap));
  }
  
  int
  ahd_xsig_print(u_int regvalue, u_int *cur_col, u_int wrap)
  {
          return (ahd_print_register(NULL, 0, "XSIG",
              0x6a, regvalue, cur_col, wrap));
  }
  
  int
  ahd_pll960cnt0_print(u_int regvalue, u_int *cur_col, u_int wrap)
  {
          return (ahd_print_register(NULL, 0, "PLL960CNT0",
              0x6a, 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));
  }
  
  int
  ahd_fairness_print(u_int regvalue, u_int *cur_col, u_int wrap)
  {
          return (ahd_print_register(NULL, 0, "FAIRNESS",
              0x6c, regvalue, cur_col, wrap));
  }
  
  static ahd_reg_parse_entry_t PLL400CTL0_parse_table[] = {
          { "PLL_ENFBM",          0x01, 0x01 },
          { "PLL_DLPF",           0x02, 0x02 },
          { "PLL_ENLPF",          0x04, 0x04 },
          { "PLL_ENLUD",          0x08, 0x08 },
          { "PLL_NS",             0x30, 0x30 },
          { "PLL_PWDN",           0x40, 0x40 },
          { "PLL_VCOSEL",         0x80, 0x80 }
  };
  
  int
  ahd_pll400ctl0_print(u_int regvalue, u_int *cur_col, u_int wrap)
  {
          return (ahd_print_register(PLL400CTL0_parse_table, 7, "PLL400CTL0",
              0x6c, regvalue, cur_col, wrap));
  }
  
  static ahd_reg_parse_entry_t PLL400CTL1_parse_table[] = {
          { "PLL_RST",            0x01, 0x01 },
          { "PLL_CNTCLR",         0x40, 0x40 },
          { "PLL_CNTEN",          0x80, 0x80 }
  };
  
  int
  ahd_pll400ctl1_print(u_int regvalue, u_int *cur_col, u_int wrap)
  {
          return (ahd_print_register(PLL400CTL1_parse_table, 3, "PLL400CTL1",
              0x6d, regvalue, cur_col, wrap));
  }
  
  int
  ahd_pll400cnt0_print(u_int regvalue, u_int *cur_col, u_int wrap)
  {
          return (ahd_print_register(NULL, 0, "PLL400CNT0",
              0x6e, regvalue, cur_col, wrap));
  }
  
  int
  ahd_unfairness_print(u_int regvalue, u_int *cur_col, u_int wrap)
  {
          return (ahd_print_register(NULL, 0, "UNFAIRNESS",
              0x6e, regvalue, cur_col, wrap));
  }
  
  int
  ahd_hodmaadr_print(u_int regvalue, u_int *cur_col, u_int wrap)
  {
          return (ahd_print_register(NULL, 0, "HODMAADR",
              0x70, regvalue, cur_col, wrap));
  }
  
  int
  ahd_haddr_print(u_int regvalue, u_int *cur_col, u_int wrap)
  {
          return (ahd_print_register(NULL, 0, "HADDR",
              0x70, regvalue, cur_col, wrap));
  }
  
  static ahd_reg_parse_entry_t PLLDELAY_parse_table[] = {
          { "SPLIT_DROP_REQ",     0x80, 0x80 }
  };
  
  int
  ahd_plldelay_print(u_int regvalue, u_int *cur_col, u_int wrap)
  {
          return (ahd_print_register(PLLDELAY_parse_table, 1, "PLLDELAY",
              0x70, regvalue, cur_col, wrap));
  }
  
  int
  ahd_hcnt_print(u_int regvalue, u_int *cur_col, u_int wrap)
  {
          return (ahd_print_register(NULL, 0, "HCNT",
              0x78, regvalue, cur_col, wrap));
  }
  
  int
  ahd_hodmacnt_print(u_int regvalue, u_int *cur_col, u_int wrap)
  {
          return (ahd_print_register(NULL, 0, "HODMACNT",
              0x78, regvalue, cur_col, wrap));
  }
  
  int
  ahd_hodmaen_print(u_int regvalue, u_int *cur_col, u_int wrap)
  {
          return (ahd_print_register(NULL, 0, "HODMAEN",
              0x7a, regvalue, cur_col, wrap));
  }
  
  int
  ahd_scbhaddr_print(u_int regvalue, u_int *cur_col, u_int wrap)
  {
          return (ahd_print_register(NULL, 0, "SCBHADDR",
              0x7c, regvalue, cur_col, wrap));
  }
  
  int
  ahd_sghaddr_print(u_int regvalue, u_int *cur_col, u_int wrap)
  {
          return (ahd_print_register(NULL, 0, "SGHADDR",
              0x7c, regvalue, cur_col, wrap));
  }
  
  int
  ahd_scbhcnt_print(u_int regvalue, u_int *cur_col, u_int wrap)
  {
          return (ahd_print_register(NULL, 0, "SCBHCNT",
              0x84, regvalue, cur_col, wrap));
  }
  
  int
  ahd_sghcnt_print(u_int regvalue, u_int *cur_col, u_int wrap)
  {
          return (ahd_print_register(NULL, 0, "SGHCNT",
              0x84, regvalue, cur_col, wrap));
  }
  
  static ahd_reg_parse_entry_t DFF_THRSH_parse_table[] = {
          { "WR_DFTHRSH_MIN",     0x00, 0x70 },
          { "RD_DFTHRSH_MIN",     0x00, 0x07 },
          { "RD_DFTHRSH_25",      0x01, 0x07 },
          { "RD_DFTHRSH_50",      0x02, 0x07 },
          { "RD_DFTHRSH_63",      0x03, 0x07 },
          { "RD_DFTHRSH_75",      0x04, 0x07 },
          { "RD_DFTHRSH_85",      0x05, 0x07 },
          { "RD_DFTHRSH_90",      0x06, 0x07 },
          { "RD_DFTHRSH_MAX",     0x07, 0x07 },
          { "WR_DFTHRSH_25",      0x10, 0x70 },
          { "WR_DFTHRSH_50",      0x20, 0x70 },
          { "WR_DFTHRSH_63",      0x30, 0x70 },
          { "WR_DFTHRSH_75",      0x40, 0x70 },
          { "WR_DFTHRSH_85",      0x50, 0x70 },
          { "WR_DFTHRSH_90",      0x60, 0x70 },
          { "WR_DFTHRSH_MAX",     0x70, 0x70 },
          { "RD_DFTHRSH",         0x07, 0x07 },
          { "WR_DFTHRSH",         0x70, 0x70 }
  };
  
  int
  ahd_dff_thrsh_print(u_int regvalue, u_int *cur_col, u_int wrap)
  {
          return (ahd_print_register(DFF_THRSH_parse_table, 18, "DFF_THRSH",
              0x88, regvalue, cur_col, wrap));
  }
  
  int
  ahd_romaddr_print(u_int regvalue, u_int *cur_col, u_int wrap)
  {
          return (ahd_print_register(NULL, 0, "ROMADDR",
              0x8a, regvalue, cur_col, wrap));
  }
  
  static ahd_reg_parse_entry_t ROMCNTRL_parse_table[] = {
          { "RDY",                0x01, 0x01 },
          { "REPEAT",             0x02, 0x02 },
          { "ROMSPD",             0x18, 0x18 },
          { "ROMOP",              0xe0, 0xe0 }
  };
  
  int
  ahd_romcntrl_print(u_int regvalue, u_int *cur_col, u_int wrap)
  {
          return (ahd_print_register(ROMCNTRL_parse_table, 4, "ROMCNTRL",
              0x8d, regvalue, cur_col, wrap));
  }
  
  int
  ahd_romdata_print(u_int regvalue, u_int *cur_col, u_int wrap)
  {
          return (ahd_print_register(NULL, 0, "ROMDATA",
              0x8e, regvalue, cur_col, wrap));
  }
  
  static ahd_reg_parse_entry_t DCHRXMSG0_parse_table[] = {
          { "CFNUM",              0x07, 0x07 },
          { "CDNUM",              0xf8, 0xf8 }
  };
  
  int
  ahd_dchrxmsg0_print(u_int regvalue, u_int *cur_col, u_int wrap)
  {
          return (ahd_print_register(DCHRXMSG0_parse_table, 2, "DCHRXMSG0",
              0x90, regvalue, cur_col, wrap));
  }
  
  static ahd_reg_parse_entry_t OVLYRXMSG0_parse_table[] = {
          { "CFNUM",              0x07, 0x07 },
          { "CDNUM",              0xf8, 0xf8 }
  };
  
  int
  ahd_ovlyrxmsg0_print(u_int regvalue, u_int *cur_col, u_int wrap)
  {
          return (ahd_print_register(OVLYRXMSG0_parse_table, 2, "OVLYRXMSG0",
              0x90, regvalue, cur_col, wrap));
  }
  
  static ahd_reg_parse_entry_t CMCRXMSG0_parse_table[] = {
          { "CFNUM",              0x07, 0x07 },
          { "CDNUM",              0xf8, 0xf8 }
  };
  
  int
  ahd_cmcrxmsg0_print(u_int regvalue, u_int *cur_col, u_int wrap)
  {
          return (ahd_print_register(CMCRXMSG0_parse_table, 2, "CMCRXMSG0",
              0x90, regvalue, cur_col, wrap));
  }
  
  static ahd_reg_parse_entry_t ROENABLE_parse_table[] = {
          { "DCH0ROEN",           0x01, 0x01 },
          { "DCH1ROEN",           0x02, 0x02 },
          { "SGROEN",             0x04, 0x04 },
          { "CMCROEN",            0x08, 0x08 },
          { "OVLYROEN",           0x10, 0x10 },
          { "MSIROEN",            0x20, 0x20 }
  };
  
  int
  ahd_roenable_print(u_int regvalue, u_int *cur_col, u_int wrap)
  {
          return (ahd_print_register(ROENABLE_parse_table, 6, "ROENABLE",
              0x90, regvalue, cur_col, wrap));
  }
  
  static ahd_reg_parse_entry_t DCHRXMSG1_parse_table[] = {
          { "CBNUM",              0xff, 0xff }
  };
  
  int
  ahd_dchrxmsg1_print(u_int regvalue, u_int *cur_col, u_int wrap)
  {
          return (ahd_print_register(DCHRXMSG1_parse_table, 1, "DCHRXMSG1",
              0x91, regvalue, cur_col, wrap));
  }
  
  static ahd_reg_parse_entry_t OVLYRXMSG1_parse_table[] = {
          { "CBNUM",              0xff, 0xff }
  };
  
  int
  ahd_ovlyrxmsg1_print(u_int regvalue, u_int *cur_col, u_int wrap)
  {
          return (ahd_print_register(OVLYRXMSG1_parse_table, 1, "OVLYRXMSG1",
              0x91, regvalue, cur_col, wrap));
  }
  
  static ahd_reg_parse_entry_t CMCRXMSG1_parse_table[] = {
          { "CBNUM",              0xff, 0xff }
  };
  
  int
  ahd_cmcrxmsg1_print(u_int regvalue, u_int *cur_col, u_int wrap)
  {
          return (ahd_print_register(CMCRXMSG1_parse_table, 1, "CMCRXMSG1",
              0x91, regvalue, cur_col, wrap));
  }
  
  static ahd_reg_parse_entry_t NSENABLE_parse_table[] = {
          { "DCH0NSEN",           0x01, 0x01 },
          { "DCH1NSEN",           0x02, 0x02 },
          { "SGNSEN",             0x04, 0x04 },
          { "CMCNSEN",            0x08, 0x08 },
          { "OVLYNSEN",           0x10, 0x10 },
          { "MSINSEN",            0x20, 0x20 }
  };
  
  int
  ahd_nsenable_print(u_int regvalue, u_int *cur_col, u_int wrap)
  {
          return (ahd_print_register(NSENABLE_parse_table, 6, "NSENABLE",
              0x91, regvalue, cur_col, wrap));
  }
  
  static ahd_reg_parse_entry_t DCHRXMSG2_parse_table[] = {
          { "MINDEX",             0xff, 0xff }
  };
  
  int
  ahd_dchrxmsg2_print(u_int regvalue, u_int *cur_col, u_int wrap)
  {
          return (ahd_print_register(DCHRXMSG2_parse_table, 1, "DCHRXMSG2",
              0x92, regvalue, cur_col, wrap));
  }
  
  static ahd_reg_parse_entry_t OVLYRXMSG2_parse_table[] = {
          { "MINDEX",             0xff, 0xff }
  };
  
  int
  ahd_ovlyrxmsg2_print(u_int regvalue, u_int *cur_col, u_int wrap)
  {
          return (ahd_print_register(OVLYRXMSG2_parse_table, 1, "OVLYRXMSG2",
              0x92, regvalue, cur_col, wrap));
  }
  
  static ahd_reg_parse_entry_t CMCRXMSG2_parse_table[] = {
          { "MINDEX",             0xff, 0xff }
  };
  
  int
  ahd_cmcrxmsg2_print(u_int regvalue, u_int *cur_col, u_int wrap)
  {
          return (ahd_print_register(CMCRXMSG2_parse_table, 1, "CMCRXMSG2",
              0x92, regvalue, cur_col, wrap));
  }
  
  int
  ahd_ost_print(u_int regvalue, u_int *cur_col, u_int wrap)
  {
          return (ahd_print_register(NULL, 0, "OST",
              0x92, regvalue, cur_col, wrap));
  }
  
  static ahd_reg_parse_entry_t DCHRXMSG3_parse_table[] = {
          { "MCLASS",             0x0f, 0x0f }
  };
  
  int
  ahd_dchrxmsg3_print(u_int regvalue, u_int *cur_col, u_int wrap)
  {
          return (ahd_print_register(DCHRXMSG3_parse_table, 1, "DCHRXMSG3",
              0x93, regvalue, cur_col, wrap));
  }
  
  static ahd_reg_parse_entry_t OVLYRXMSG3_parse_table[] = {
          { "MCLASS",             0x0f, 0x0f }
  };
  
  int
  ahd_ovlyrxmsg3_print(u_int regvalue, u_int *cur_col, u_int wrap)
  {
          return (ahd_print_register(OVLYRXMSG3_parse_table, 1, "OVLYRXMSG3",
              0x93, regvalue, cur_col, wrap));
  }
  
  static ahd_reg_parse_entry_t CMCRXMSG3_parse_table[] = {
          { "MCLASS",             0x0f, 0x0f }
  };
  
  int
  ahd_cmcrxmsg3_print(u_int regvalue, u_int *cur_col, u_int wrap)
  {
          return (ahd_print_register(CMCRXMSG3_parse_table, 1, "CMCRXMSG3",
              0x93, regvalue, cur_col, wrap));
  }
  
  static ahd_reg_parse_entry_t PCIXCTL_parse_table[] = {
          { "CMPABCDIS",          0x01, 0x01 },
          { "TSCSERREN",          0x02, 0x02 },
          { "SRSPDPEEN",          0x04, 0x04 },
          { "SPLTSTADIS",         0x08, 0x08 },
          { "SPLTSMADIS",         0x10, 0x10 },
          { "UNEXPSCIEN",         0x20, 0x20 },
          { "SERRPULSE",          0x80, 0x80 }
  };
  
  int
  ahd_pcixctl_print(u_int regvalue, u_int *cur_col, u_int wrap)
  {
          return (ahd_print_register(PCIXCTL_parse_table, 7, "PCIXCTL",
              0x93, regvalue, cur_col, wrap));
  }
  
  int
  ahd_cmcseqbcnt_print(u_int regvalue, u_int *cur_col, u_int wrap)
  {
          return (ahd_print_register(NULL, 0, "CMCSEQBCNT",
              0x94, regvalue, cur_col, wrap));
  }
  
  int
  ahd_dchseqbcnt_print(u_int regvalue, u_int *cur_col, u_int wrap)
  {
          return (ahd_print_register(NULL, 0, "DCHSEQBCNT",
              0x94, regvalue, cur_col, wrap));
  }
  
  int
  ahd_ovlyseqbcnt_print(u_int regvalue, u_int *cur_col, u_int wrap)
  {
          return (ahd_print_register(NULL, 0, "OVLYSEQBCNT",
              0x94, regvalue, cur_col, wrap));
  }
  
  static ahd_reg_parse_entry_t CMCSPLTSTAT0_parse_table[] = {
          { "RXSPLTRSP",          0x01, 0x01 },
          { "RXSCEMSG",           0x02, 0x02 },
          { "RXOVRUN",            0x04, 0x04 },
          { "CNTNOTCMPLT",        0x08, 0x08 },
          { "SCDATBUCKET",        0x10, 0x10 },
          { "SCADERR",            0x20, 0x20 },
          { "SCBCERR",            0x40, 0x40 },
          { "STAETERM",           0x80, 0x80 }
  };
  
  int
  ahd_cmcspltstat0_print(u_int regvalue, u_int *cur_col, u_int wrap)
  {
          return (ahd_print_register(CMCSPLTSTAT0_parse_table, 8, "CMCSPLTSTAT0",
              0x96, regvalue, cur_col, wrap));
  }
  
  static ahd_reg_parse_entry_t DCHSPLTSTAT0_parse_table[] = {
          { "RXSPLTRSP",          0x01, 0x01 },
          { "RXSCEMSG",           0x02, 0x02 },
          { "RXOVRUN",            0x04, 0x04 },
          { "CNTNOTCMPLT",        0x08, 0x08 },
          { "SCDATBUCKET",        0x10, 0x10 },
          { "SCADERR",            0x20, 0x20 },
          { "SCBCERR",            0x40, 0x40 },
          { "STAETERM",           0x80, 0x80 }
  };
  
  int
  ahd_dchspltstat0_print(u_int regvalue, u_int *cur_col, u_int wrap)
  {
          return (ahd_print_register(DCHSPLTSTAT0_parse_table, 8, "DCHSPLTSTAT0",
              0x96, regvalue, cur_col, wrap));
  }
  
  static ahd_reg_parse_entry_t OVLYSPLTSTAT0_parse_table[] = {
          { "RXSPLTRSP",          0x01, 0x01 },
          { "RXSCEMSG",           0x02, 0x02 },
          { "RXOVRUN",            0x04, 0x04 },
          { "CNTNOTCMPLT",        0x08, 0x08 },
          { "SCDATBUCKET",        0x10, 0x10 },
          { "SCADERR",            0x20, 0x20 },
          { "SCBCERR",            0x40, 0x40 },
          { "STAETERM",           0x80, 0x80 }
  };
  
  int
  ahd_ovlyspltstat0_print(u_int regvalue, u_int *cur_col, u_int wrap)
  {
          return (ahd_print_register(OVLYSPLTSTAT0_parse_table, 8, "OVLYSPLTSTAT0",
              0x96, regvalue, cur_col, wrap));
  }
  
  static ahd_reg_parse_entry_t CMCSPLTSTAT1_parse_table[] = {
          { "RXDATABUCKET",       0x01, 0x01 }
  };
  
  int
  ahd_cmcspltstat1_print(u_int regvalue, u_int *cur_col, u_int wrap)
  {
          return (ahd_print_register(CMCSPLTSTAT1_parse_table, 1, "CMCSPLTSTAT1",
              0x97, regvalue, cur_col, wrap));
  }
  
  static ahd_reg_parse_entry_t DCHSPLTSTAT1_parse_table[] = {
          { "RXDATABUCKET",       0x01, 0x01 }
  };
  
  int
  ahd_dchspltstat1_print(u_int regvalue, u_int *cur_col, u_int wrap)
  {
          return (ahd_print_register(DCHSPLTSTAT1_parse_table, 1, "DCHSPLTSTAT1",
              0x97, regvalue, cur_col, wrap));
  }
  
  static ahd_reg_parse_entry_t OVLYSPLTSTAT1_parse_table[] = {
          { "RXDATABUCKET",       0x01, 0x01 }
  };
  
  int
  ahd_ovlyspltstat1_print(u_int regvalue, u_int *cur_col, u_int wrap)
  {
          return (ahd_print_register(OVLYSPLTSTAT1_parse_table, 1, "OVLYSPLTSTAT1",
              0x97, regvalue, cur_col, wrap));
  }
  
  static ahd_reg_parse_entry_t SGRXMSG0_parse_table[] = {
          { "CFNUM",              0x07, 0x07 },
          { "CDNUM",              0xf8, 0xf8 }
  };
  
  int
  ahd_sgrxmsg0_print(u_int regvalue, u_int *cur_col, u_int wrap)
  {
          return (ahd_print_register(SGRXMSG0_parse_table, 2, "SGRXMSG0",
              0x98, regvalue, cur_col, wrap));
  }
  
  static ahd_reg_parse_entry_t SLVSPLTOUTADR0_parse_table[] = {
          { "LOWER_ADDR",         0x7f, 0x7f }
  };
  
  int
  ahd_slvspltoutadr0_print(u_int regvalue, u_int *cur_col, u_int wrap)
  {
          return (ahd_print_register(SLVSPLTOUTADR0_parse_table, 1, "SLVSPLTOUTADR0",
              0x98, regvalue, cur_col, wrap));
  }
  
  static ahd_reg_parse_entry_t SGRXMSG1_parse_table[] = {
          { "CBNUM",              0xff, 0xff }
  };
  
  int
  ahd_sgrxmsg1_print(u_int regvalue, u_int *cur_col, u_int wrap)
  {
          return (ahd_print_register(SGRXMSG1_parse_table, 1, "SGRXMSG1",
              0x99, regvalue, cur_col, wrap));
  }
  
  static ahd_reg_parse_entry_t SLVSPLTOUTADR1_parse_table[] = {
          { "REQ_FNUM",           0x07, 0x07 },
          { "REQ_DNUM",           0xf8, 0xf8 }
  };
  
  int
  ahd_slvspltoutadr1_print(u_int regvalue, u_int *cur_col, u_int wrap)
  {
          return (ahd_print_register(SLVSPLTOUTADR1_parse_table, 2, "SLVSPLTOUTADR1",
              0x99, regvalue, cur_col, wrap));
  }
  
  static ahd_reg_parse_entry_t SGRXMSG2_parse_table[] = {
          { "MINDEX",             0xff, 0xff }
  };
  
  int
  ahd_sgrxmsg2_print(u_int regvalue, u_int *cur_col, u_int wrap)
  {
          return (ahd_print_register(SGRXMSG2_parse_table, 1, "SGRXMSG2",
              0x9a, regvalue, cur_col, wrap));
  }
  
  static ahd_reg_parse_entry_t SLVSPLTOUTADR2_parse_table[] = {
          { "REQ_BNUM",           0xff, 0xff }
  };
  
  int
  ahd_slvspltoutadr2_print(u_int regvalue, u_int *cur_col, u_int wrap)
  {
          return (ahd_print_register(SLVSPLTOUTADR2_parse_table, 1, "SLVSPLTOUTADR2",
              0x9a, regvalue, cur_col, wrap));
  }
  
  static ahd_reg_parse_entry_t SGRXMSG3_parse_table[] = {
          { "MCLASS",             0x0f, 0x0f }
  };
  
  int
  ahd_sgrxmsg3_print(u_int regvalue, u_int *cur_col, u_int wrap)
  {
          return (ahd_print_register(SGRXMSG3_parse_table, 1, "SGRXMSG3",
              0x9b, regvalue, cur_col, wrap));
  }
  
  static ahd_reg_parse_entry_t SLVSPLTOUTADR3_parse_table[] = {
          { "RLXORD",             0x10, 0x10 },
          { "TAG_NUM",            0x1f, 0x1f }
  };
  
  int
  ahd_slvspltoutadr3_print(u_int regvalue, u_int *cur_col, u_int wrap)
  {
          return (ahd_print_register(SLVSPLTOUTADR3_parse_table, 2, "SLVSPLTOUTADR3",
              0x9b, regvalue, cur_col, wrap));
  }
  
  static ahd_reg_parse_entry_t SLVSPLTOUTATTR0_parse_table[] = {
          { "LOWER_BCNT",         0xff, 0xff }
  };
  
  int
  ahd_slvspltoutattr0_print(u_int regvalue, u_int *cur_col, u_int wrap)
  {
          return (ahd_print_register(SLVSPLTOUTATTR0_parse_table, 1, "SLVSPLTOUTATTR0",
              0x9c, regvalue, cur_col, wrap));
  }
  
  int
  ahd_sgseqbcnt_print(u_int regvalue, u_int *cur_col, u_int wrap)
  {
          return (ahd_print_register(NULL, 0, "SGSEQBCNT",
              0x9c, regvalue, cur_col, wrap));
  }
  
  static ahd_reg_parse_entry_t SLVSPLTOUTATTR1_parse_table[] = {
          { "CMPLT_FNUM",         0x07, 0x07 },
          { "CMPLT_DNUM",         0xf8, 0xf8 }
  };
  
  int
  ahd_slvspltoutattr1_print(u_int regvalue, u_int *cur_col, u_int wrap)
  {
          return (ahd_print_register(SLVSPLTOUTATTR1_parse_table, 2, "SLVSPLTOUTATTR1",
              0x9d, regvalue, cur_col, wrap));
  }
  
  static ahd_reg_parse_entry_t SLVSPLTOUTATTR2_parse_table[] = {
          { "CMPLT_BNUM",         0xff, 0xff }
  };
  
  int
  ahd_slvspltoutattr2_print(u_int regvalue, u_int *cur_col, u_int wrap)
  {
          return (ahd_print_register(SLVSPLTOUTATTR2_parse_table, 1, "SLVSPLTOUTATTR2",
              0x9e, regvalue, cur_col, wrap));
  }
  
  static ahd_reg_parse_entry_t SGSPLTSTAT0_parse_table[] = {
          { "RXSPLTRSP",          0x01, 0x01 },
          { "RXSCEMSG",           0x02, 0x02 },
          { "RXOVRUN",            0x04, 0x04 },
          { "CNTNOTCMPLT",        0x08, 0x08 },
          { "SCDATBUCKET",        0x10, 0x10 },
          { "SCADERR",            0x20, 0x20 },
          { "SCBCERR",            0x40, 0x40 },
          { "STAETERM",           0x80, 0x80 }
  };
  
  int
  ahd_sgspltstat0_print(u_int regvalue, u_int *cur_col, u_int wrap)
  {
          return (ahd_print_register(SGSPLTSTAT0_parse_table, 8, "SGSPLTSTAT0",
              0x9e, regvalue, cur_col, wrap));
  }
  
  static ahd_reg_parse_entry_t SFUNCT_parse_table[] = {
          { "TEST_NUM",           0x0f, 0x0f },
          { "TEST_GROUP",         0xf0, 0xf0 }
  };
  
  int
  ahd_sfunct_print(u_int regvalue, u_int *cur_col, u_int wrap)
  {
          return (ahd_print_register(SFUNCT_parse_table, 2, "SFUNCT",
              0x9f, regvalue, cur_col, wrap));
  }
  
  static ahd_reg_parse_entry_t SGSPLTSTAT1_parse_table[] = {
          { "RXDATABUCKET",       0x01, 0x01 }
  };
  
  int
  ahd_sgspltstat1_print(u_int regvalue, u_int *cur_col, u_int wrap)
  {
          return (ahd_print_register(SGSPLTSTAT1_parse_table, 1, "SGSPLTSTAT1",
              0x9f, regvalue, cur_col, wrap));
  }
  
  static ahd_reg_parse_entry_t DF0PCISTAT_parse_table[] = {
          { "DPR",                0x01, 0x01 },
          { "TWATERR",            0x02, 0x02 },
          { "RDPERR",             0x04, 0x04 },
          { "SCAAPERR",           0x08, 0x08 },
          { "RTA",                0x10, 0x10 },
          { "RMA",                0x20, 0x20 },
          { "SSE",                0x40, 0x40 },
          { "DPE",                0x80, 0x80 }
  };
  
  int
  ahd_df0pcistat_print(u_int regvalue, u_int *cur_col, u_int wrap)
  {
          return (ahd_print_register(DF0PCISTAT_parse_table, 8, "DF0PCISTAT",
              0xa0, regvalue, cur_col, wrap));
  }
  
  int
  ahd_reg0_print(u_int regvalue, u_int *cur_col, u_int wrap)
  {
          return (ahd_print_register(NULL, 0, "REG0",
              0xa0, regvalue, cur_col, wrap));
  }
  
  static ahd_reg_parse_entry_t DF1PCISTAT_parse_table[] = {
          { "DPR",                0x01, 0x01 },
          { "TWATERR",            0x02, 0x02 },
          { "RDPERR",             0x04, 0x04 },
          { "SCAAPERR",           0x08, 0x08 },
          { "RTA",                0x10, 0x10 },
          { "RMA",                0x20, 0x20 },
          { "SSE",                0x40, 0x40 },
          { "DPE",                0x80, 0x80 }
  };
  
  int
  ahd_df1pcistat_print(u_int regvalue, u_int *cur_col, u_int wrap)
  {
          return (ahd_print_register(DF1PCISTAT_parse_table, 8, "DF1PCISTAT",
              0xa1, regvalue, cur_col, wrap));
  }
  
  static ahd_reg_parse_entry_t SGPCISTAT_parse_table[] = {
          { "DPR",                0x01, 0x01 },
          { "RDPERR",             0x04, 0x04 },
          { "SCAAPERR",           0x08, 0x08 },
          { "RTA",                0x10, 0x10 },
          { "RMA",                0x20, 0x20 },
          { "SSE",                0x40, 0x40 },
          { "DPE",                0x80, 0x80 }
  };
  
  int
  ahd_sgpcistat_print(u_int regvalue, u_int *cur_col, u_int wrap)
  {
          return (ahd_print_register(SGPCISTAT_parse_table, 7, "SGPCISTAT",
              0xa2, regvalue, cur_col, wrap));
  }
  
  int
  ahd_reg1_print(u_int regvalue, u_int *cur_col, u_int wrap)
  {
          return (ahd_print_register(NULL, 0, "REG1",
              0xa2, regvalue, cur_col, wrap));
  }
  
  static ahd_reg_parse_entry_t CMCPCISTAT_parse_table[] = {
          { "DPR",                0x01, 0x01 },
          { "TWATERR",            0x02, 0x02 },
          { "RDPERR",             0x04, 0x04 },
          { "SCAAPERR",           0x08, 0x08 },
          { "RTA",                0x10, 0x10 },
          { "RMA",                0x20, 0x20 },
          { "SSE",                0x40, 0x40 },
          { "DPE",                0x80, 0x80 }
  };
  
  int
  ahd_cmcpcistat_print(u_int regvalue, u_int *cur_col, u_int wrap)
  {
          return (ahd_print_register(CMCPCISTAT_parse_table, 8, "CMCPCISTAT",
              0xa3, regvalue, cur_col, wrap));
  }
  
  static ahd_reg_parse_entry_t OVLYPCISTAT_parse_table[] = {
          { "DPR",                0x01, 0x01 },
          { "RDPERR",             0x04, 0x04 },
          { "SCAAPERR",           0x08, 0x08 },
          { "RTA",                0x10, 0x10 },
          { "RMA",                0x20, 0x20 },
          { "SSE",                0x40, 0x40 },
          { "DPE",                0x80, 0x80 }
  };
  
  int
  ahd_ovlypcistat_print(u_int regvalue, u_int *cur_col, u_int wrap)
  {
          return (ahd_print_register(OVLYPCISTAT_parse_table, 7, "OVLYPCISTAT",
              0xa4, regvalue, cur_col, wrap));
  }
  
  int
  ahd_reg_isr_print(u_int regvalue, u_int *cur_col, u_int wrap)
  {
          return (ahd_print_register(NULL, 0, "REG_ISR",
              0xa4, regvalue, cur_col, wrap));
  }
  
  static ahd_reg_parse_entry_t MSIPCISTAT_parse_table[] = {
          { "DPR",                0x01, 0x01 },
          { "TWATERR",            0x02, 0x02 },
          { "CLRPENDMSI",         0x08, 0x08 },
          { "RTA",                0x10, 0x10 },
          { "RMA",                0x20, 0x20 },
          { "SSE",                0x40, 0x40 }
  };
  
  int
  ahd_msipcistat_print(u_int regvalue, u_int *cur_col, u_int wrap)
  {
          return (ahd_print_register(MSIPCISTAT_parse_table, 6, "MSIPCISTAT",
              0xa6, regvalue, cur_col, wrap));
  }
  
  static 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 ahd_reg_parse_entry_t TARGPCISTAT_parse_table[] = {
          { "TWATERR",            0x02, 0x02 },
          { "STA",                0x08, 0x08 },
          { "SSE",                0x40, 0x40 },
          { "DPE",                0x80, 0x80 }
  };
  
  int
  ahd_targpcistat_print(u_int regvalue, u_int *cur_col, u_int wrap)
  {
          return (ahd_print_register(TARGPCISTAT_parse_table, 4, "TARGPCISTAT",
              0xa7, regvalue, cur_col, wrap));
  }
  
  int
  ahd_data_count_odd_print(u_int regvalue, u_int *cur_col, u_int wrap)
  {
          return (ahd_print_register(NULL, 0, "DATA_COUNT_ODD",
              0xa7, regvalue, cur_col, wrap));
  }
  
  int
  ahd_scbptr_print(u_int regvalue, u_int *cur_col, u_int wrap)
  {
          return (ahd_print_register(NULL, 0, "SCBPTR",
              0xa8, regvalue, cur_col, wrap));
  }
  
  int
  ahd_ccscbacnt_print(u_int regvalue, u_int *cur_col, u_int wrap)
  {
          return (ahd_print_register(NULL, 0, "CCSCBACNT",
              0xab, regvalue, cur_col, wrap));
  }
  
  static ahd_reg_parse_entry_t SCBAUTOPTR_parse_table[] = {
          { "SCBPTR_OFF",         0x07, 0x07 },
          { "SCBPTR_ADDR",        0x38, 0x38 },
          { "AUSCBPTR_EN",        0x80, 0x80 }
  };
  
  int
  ahd_scbautoptr_print(u_int regvalue, u_int *cur_col, u_int wrap)
  {
          return (ahd_print_register(SCBAUTOPTR_parse_table, 3, "SCBAUTOPTR",
              0xab, regvalue, cur_col, wrap));
  }
  
  int
  ahd_ccscbadr_bk_print(u_int regvalue, u_int *cur_col, u_int wrap)
  {
          return (ahd_print_register(NULL, 0, "CCSCBADR_BK",
              0xac, regvalue, cur_col, wrap));
  }
  
  int
  ahd_ccsgaddr_print(u_int regvalue, u_int *cur_col, u_int wrap)
  {
          return (ahd_print_register(NULL, 0, "CCSGADDR",
              0xac, regvalue, cur_col, wrap));
  }
  
  int
  ahd_ccscbaddr_print(u_int regvalue, u_int *cur_col, u_int wrap)
  {
          return (ahd_print_register(NULL, 0, "CCSCBADDR",
              0xac, regvalue, cur_col, wrap));
  }
  
  static 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 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 ahd_reg_parse_entry_t CMC_RAMBIST_parse_table[] = {
          { "CMC_BUFFER_BIST_EN", 0x01, 0x01 },
          { "CMC_BUFFER_BIST_FAIL",0x02, 0x02 },
          { "SG_BIST_EN",         0x10, 0x10 },
          { "SG_BIST_FAIL",       0x20, 0x20 },
          { "SCBRAMBIST_FAIL",    0x40, 0x40 },
          { "SG_ELEMENT_SIZE",    0x80, 0x80 }
  };
  
  int
  ahd_cmc_rambist_print(u_int regvalue, u_int *cur_col, u_int wrap)
  {
          return (ahd_print_register(CMC_RAMBIST_parse_table, 6, "CMC_RAMBIST",
              0xad, regvalue, cur_col, wrap));
  }
  
  int
  ahd_ccsgram_print(u_int regvalue, u_int *cur_col, u_int wrap)
  {
          return (ahd_print_register(NULL, 0, "CCSGRAM",
              0xb0, regvalue, cur_col, wrap));
  }
  
  int
  ahd_ccscbram_print(u_int regvalue, u_int *cur_col, u_int wrap)
  {
          return (ahd_print_register(NULL, 0, "CCSCBRAM",
              0xb0, regvalue, cur_col, wrap));
  }
  
  int
  ahd_flexadr_print(u_int regvalue, u_int *cur_col, u_int wrap)
  {
          return (ahd_print_register(NULL, 0, "FLEXADR",
              0xb0, regvalue, cur_col, wrap));
  }
  
  int
  ahd_flexcnt_print(u_int regvalue, u_int *cur_col, u_int wrap)
  {
          return (ahd_print_register(NULL, 0, "FLEXCNT",
              0xb3, regvalue, cur_col, wrap));
  }
  
  static ahd_reg_parse_entry_t FLEXDMASTAT_parse_table[] = {
          { "FLEXDMADONE",        0x01, 0x01 },
          { "FLEXDMAERR",         0x02, 0x02 }
  };
  
  int
  ahd_flexdmastat_print(u_int regvalue, u_int *cur_col, u_int wrap)
  {
          return (ahd_print_register(FLEXDMASTAT_parse_table, 2, "FLEXDMASTAT",
              0xb5, regvalue, cur_col, wrap));
  }
  
  int
  ahd_flexdata_print(u_int regvalue, u_int *cur_col, u_int wrap)
  {
          return (ahd_print_register(NULL, 0, "FLEXDATA",
              0xb6, regvalue, cur_col, wrap));
  }
  
  int
  ahd_brddat_print(u_int regvalue, u_int *cur_col, u_int wrap)
  {
          return (ahd_print_register(NULL, 0, "BRDDAT",
              0xb8, regvalue, cur_col, wrap));
  }
  
  static ahd_reg_parse_entry_t BRDCTL_parse_table[] = {
          { "BRDSTB",             0x01, 0x01 },
          { "BRDRW",              0x02, 0x02 },
          { "BRDEN",              0x04, 0x04 },
          { "BRDADDR",            0x38, 0x38 },
          { "FLXARBREQ",          0x40, 0x40 },
          { "FLXARBACK",          0x80, 0x80 }
  };
  
  int
  ahd_brdctl_print(u_int regvalue, u_int *cur_col, u_int wrap)
  {
          return (ahd_print_register(BRDCTL_parse_table, 6, "BRDCTL",
              0xb9, regvalue, cur_col, wrap));
  }
  
  int
  ahd_seeadr_print(u_int regvalue, u_int *cur_col, u_int wrap)
  {
          return (ahd_print_register(NULL, 0, "SEEADR",
              0xba, regvalue, cur_col, wrap));
  }
  
  int
  ahd_seedat_print(u_int regvalue, u_int *cur_col, u_int wrap)
  {
          return (ahd_print_register(NULL, 0, "SEEDAT",
              0xbc, regvalue, cur_col, wrap));
  }
  
  static ahd_reg_parse_entry_t SEECTL_parse_table[] = {
          { "SEEOP_ERAL",         0x40, 0x70 },
          { "SEEOP_WRITE",        0x50, 0x70 },
          { "SEEOP_READ",         0x60, 0x70 },
          { "SEEOP_ERASE",        0x70, 0x70 },
          { "SEESTART",           0x01, 0x01 },
          { "SEERST",             0x02, 0x02 },
          { "SEEOPCODE",          0x70, 0x70 },
          { "SEEOP_EWEN",         0x40, 0x40 },
          { "SEEOP_WALL",         0x40, 0x40 },
          { "SEEOP_EWDS",         0x40, 0x40 }
  };
  
  int
  ahd_seectl_print(u_int regvalue, u_int *cur_col, u_int wrap)
  {
          return (ahd_print_register(SEECTL_parse_table, 10, "SEECTL",
              0xbe, regvalue, cur_col, wrap));
  }
  
  static ahd_reg_parse_entry_t SEESTAT_parse_table[] = {
          { "SEESTART",           0x01, 0x01 },
          { "SEEBUSY",            0x02, 0x02 },
          { "SEEARBACK",          0x04, 0x04 },
          { "LDALTID_L",          0x08, 0x08 },
          { "SEEOPCODE",          0x70, 0x70 },
          { "INIT_DONE",          0x80, 0x80 }
  };
  
  int
  ahd_seestat_print(u_int regvalue, u_int *cur_col, u_int wrap)
  {
          return (ahd_print_register(SEESTAT_parse_table, 6, "SEESTAT",
              0xbe, regvalue, cur_col, wrap));
  }
  
  int
  ahd_scbcnt_print(u_int regvalue, u_int *cur_col, u_int wrap)
  {
          return (ahd_print_register(NULL, 0, "SCBCNT",
              0xbf, regvalue, cur_col, wrap));
  }
  
  static ahd_reg_parse_entry_t DSPFLTRCTL_parse_table[] = {
          { "DSPFCNTSEL",         0x0f, 0x0f },
          { "EDGESENSE",          0x10, 0x10 },
          { "FLTRDISABLE",        0x20, 0x20 }
  };
  
  int
  ahd_dspfltrctl_print(u_int regvalue, u_int *cur_col, u_int wrap)
  {
          return (ahd_print_register(DSPFLTRCTL_parse_table, 3, "DSPFLTRCTL",
              0xc0, regvalue, cur_col, wrap));
  }
  
  int
  ahd_dfwaddr_print(u_int regvalue, u_int *cur_col, u_int wrap)
  {
          return (ahd_print_register(NULL, 0, "DFWADDR",
              0xc0, regvalue, cur_col, wrap));
  }
  
  static ahd_reg_parse_entry_t DSPDATACTL_parse_table[] = {
          { "XMITOFFSTDIS",       0x02, 0x02 },
          { "RCVROFFSTDIS",       0x04, 0x04 },
          { "DESQDIS",            0x10, 0x10 },
          { "BYPASSENAB",         0x80, 0x80 }
  };
  
  int
  ahd_dspdatactl_print(u_int regvalue, u_int *cur_col, u_int wrap)
  {
          return (ahd_print_register(DSPDATACTL_parse_table, 4, "DSPDATACTL",
              0xc1, regvalue, cur_col, wrap));
  }
  
  static ahd_reg_parse_entry_t DSPREQCTL_parse_table[] = {
          { "MANREQDLY",          0x3f, 0x3f },
          { "MANREQCTL",          0xc0, 0xc0 }
  };
  
  int
  ahd_dspreqctl_print(u_int regvalue, u_int *cur_col, u_int wrap)
  {
          return (ahd_print_register(DSPREQCTL_parse_table, 2, "DSPREQCTL",
              0xc2, regvalue, cur_col, wrap));
  }
  
  int
  ahd_dfraddr_print(u_int regvalue, u_int *cur_col, u_int wrap)
  {
          return (ahd_print_register(NULL, 0, "DFRADDR",
              0xc2, regvalue, cur_col, wrap));
  }
  
  static ahd_reg_parse_entry_t DSPACKCTL_parse_table[] = {
          { "MANACKDLY",          0x3f, 0x3f },
          { "MANACKCTL",          0xc0, 0xc0 }
  };
  
  int
  ahd_dspackctl_print(u_int regvalue, u_int *cur_col, u_int wrap)
  {
          return (ahd_print_register(DSPACKCTL_parse_table, 2, "DSPACKCTL",
              0xc3, regvalue, cur_col, wrap));
  }
  
  int
  ahd_dfdat_print(u_int regvalue, u_int *cur_col, u_int wrap)
  {
          return (ahd_print_register(NULL, 0, "DFDAT",
              0xc4, regvalue, cur_col, wrap));
  }
  
  static ahd_reg_parse_entry_t DSPSELECT_parse_table[] = {
          { "DSPSEL",             0x1f, 0x1f },
          { "AUTOINCEN",          0x80, 0x80 }
  };
  
  int
  ahd_dspselect_print(u_int regvalue, u_int *cur_col, u_int wrap)
  {
          return (ahd_print_register(DSPSELECT_parse_table, 2, "DSPSELECT",
              0xc4, regvalue, cur_col, wrap));
  }
  
  static ahd_reg_parse_entry_t WRTBIASCTL_parse_table[] = {
          { "XMITMANVAL",         0x3f, 0x3f },
          { "AUTOXBCDIS",         0x80, 0x80 }
  };
  
  int
  ahd_wrtbiasctl_print(u_int regvalue, u_int *cur_col, u_int wrap)
  {
          return (ahd_print_register(WRTBIASCTL_parse_table, 2, "WRTBIASCTL",
              0xc5, regvalue, cur_col, wrap));
  }
  
  static ahd_reg_parse_entry_t RCVRBIOSCTL_parse_table[] = {
          { "RCVRMANVAL",         0x3f, 0x3f },
          { "AUTORBCDIS",         0x80, 0x80 }
  };
  
  int
  ahd_rcvrbiosctl_print(u_int regvalue, u_int *cur_col, u_int wrap)
  {
          return (ahd_print_register(RCVRBIOSCTL_parse_table, 2, "RCVRBIOSCTL",
              0xc6, regvalue, cur_col, wrap));
  }
  
  int
  ahd_wrtbiascalc_print(u_int regvalue, u_int *cur_col, u_int wrap)
  {
          return (ahd_print_register(NULL, 0, "WRTBIASCALC",
              0xc7, regvalue, cur_col, wrap));
  }
  
  int
  ahd_dfptrs_print(u_int regvalue, u_int *cur_col, u_int wrap)
  {
          return (ahd_print_register(NULL, 0, "DFPTRS",
              0xc8, regvalue, cur_col, wrap));
  }
  
  int
  ahd_rcvrbiascalc_print(u_int regvalue, u_int *cur_col, u_int wrap)
  {
          return (ahd_print_register(NULL, 0, "RCVRBIASCALC",
              0xc8, regvalue, cur_col, wrap));
  }
  
  int
  ahd_dfbkptr_print(u_int regvalue, u_int *cur_col, u_int wrap)
  {
          return (ahd_print_register(NULL, 0, "DFBKPTR",
              0xc9, regvalue, cur_col, wrap));
  }
  
  int
  ahd_skewcalc_print(u_int regvalue, u_int *cur_col, u_int wrap)
  {
          return (ahd_print_register(NULL, 0, "SKEWCALC",
              0xc9, regvalue, cur_col, wrap));
  }
  
  static ahd_reg_parse_entry_t DFDBCTL_parse_table[] = {
          { "DFF_RAMBIST_EN",     0x01, 0x01 },
          { "DFF_RAMBIST_DONE",   0x02, 0x02 },
          { "DFF_RAMBIST_FAIL",   0x04, 0x04 },
          { "DFF_DIR_ERR",        0x08, 0x08 },
          { "DFF_CIO_RD_RDY",     0x10, 0x10 },
          { "DFF_CIO_WR_RDY",     0x20, 0x20 }
  };
  
  int
  ahd_dfdbctl_print(u_int regvalue, u_int *cur_col, u_int wrap)
  {
          return (ahd_print_register(DFDBCTL_parse_table, 6, "DFDBCTL",
              0xcb, regvalue, cur_col, wrap));
  }
  
  int
  ahd_dfscnt_print(u_int regvalue, u_int *cur_col, u_int wrap)
  {
          return (ahd_print_register(NULL, 0, "DFSCNT",
              0xcc, regvalue, cur_col, wrap));
  }
  
  int
  ahd_dfbcnt_print(u_int regvalue, u_int *cur_col, u_int wrap)
  {
          return (ahd_print_register(NULL, 0, "DFBCNT",
              0xce, regvalue, cur_col, wrap));
  }
  
  int
  ahd_ovlyaddr_print(u_int regvalue, u_int *cur_col, u_int wrap)
  {
          return (ahd_print_register(NULL, 0, "OVLYADDR",
              0xd4, regvalue, cur_col, wrap));
  }
  
  static 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 ahd_reg_parse_entry_t SEQCTL1_parse_table[] = {
          { "RAMBIST_EN",         0x01, 0x01 },
          { "RAMBIST_FAIL",       0x02, 0x02 },
          { "RAMBIST_DONE",       0x04, 0x04 },
          { "OVRLAY_DATA_CHK",    0x08, 0x08 }
  };
  
  int
  ahd_seqctl1_print(u_int regvalue, u_int *cur_col, u_int wrap)
  {
          return (ahd_print_register(SEQCTL1_parse_table, 4, "SEQCTL1",
              0xd7, regvalue, cur_col, wrap));
  }
  
  static ahd_reg_parse_entry_t FLAGS_parse_table[] = {
          { "CARRY",              0x01, 0x01 },
          { "ZERO",               0x02, 0x02 }
  };
  
  int
  ahd_flags_print(u_int regvalue, u_int *cur_col, u_int wrap)
  {
          return (ahd_print_register(FLAGS_parse_table, 2, "FLAGS",
              0xd8, regvalue, cur_col, wrap));
  }
  
  static 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_seqram_print(u_int regvalue, u_int *cur_col, u_int wrap)
  {
          return (ahd_print_register(NULL, 0, "SEQRAM",
              0xda, regvalue, cur_col, wrap));
  }
  
  int
  ahd_prgmcnt_print(u_int regvalue, u_int *cur_col, u_int wrap)
  {
          return (ahd_print_register(NULL, 0, "PRGMCNT",
              0xde, regvalue, cur_col, wrap));
  }
  
  int
  ahd_accum_print(u_int regvalue, u_int *cur_col, u_int wrap)
  {
          return (ahd_print_register(NULL, 0, "ACCUM",
              0xe0, regvalue, cur_col, wrap));
  }
  
  int
  ahd_sindex_print(u_int regvalue, u_int *cur_col, u_int wrap)
  {
          return (ahd_print_register(NULL, 0, "SINDEX",
              0xe2, regvalue, cur_col, wrap));
  }
  
  int
  ahd_dindex_print(u_int regvalue, u_int *cur_col, u_int wrap)
  {
          return (ahd_print_register(NULL, 0, "DINDEX",
              0xe4, regvalue, cur_col, wrap));
  }
  
  static ahd_reg_parse_entry_t BRKADDR1_parse_table[] = {
          { "BRKDIS",             0x80, 0x80 }
  };
  
  int
  ahd_brkaddr1_print(u_int regvalue, u_int *cur_col, u_int wrap)
  {
          return (ahd_print_register(BRKADDR1_parse_table, 1, "BRKADDR1",
              0xe6, regvalue, cur_col, wrap));
  }
  
  int
  ahd_brkaddr0_print(u_int regvalue, u_int *cur_col, u_int wrap)
  {
          return (ahd_print_register(NULL, 0, "BRKADDR0",
              0xe6, regvalue, cur_col, wrap));
  }
  
  int
  ahd_allones_print(u_int regvalue, u_int *cur_col, u_int wrap)
  {
          return (ahd_print_register(NULL, 0, "ALLONES",
              0xe8, regvalue, cur_col, wrap));
  }
  
  int
  ahd_none_print(u_int regvalue, u_int *cur_col, u_int wrap)
  {
          return (ahd_print_register(NULL, 0, "NONE",
              0xea, regvalue, cur_col, wrap));
  }
  
  int
  ahd_allzeros_print(u_int regvalue, u_int *cur_col, u_int wrap)
  {
          return (ahd_print_register(NULL, 0, "ALLZEROS",
              0xea, regvalue, cur_col, wrap));
  }
  
  int
  ahd_sindir_print(u_int regvalue, u_int *cur_col, u_int wrap)
  {
          return (ahd_print_register(NULL, 0, "SINDIR",
              0xec, regvalue, cur_col, wrap));
  }
  
  int
  ahd_dindir_print(u_int regvalue, u_int *cur_col, u_int wrap)
  {
          return (ahd_print_register(NULL, 0, "DINDIR",
              0xed, regvalue, cur_col, wrap));
  }
  
  int
  ahd_function1_print(u_int regvalue, u_int *cur_col, u_int wrap)
  {
          return (ahd_print_register(NULL, 0, "FUNCTION1",
              0xf0, regvalue, cur_col, wrap));
  }
  
  int
  ahd_stack_print(u_int regvalue, u_int *cur_col, u_int wrap)
  {
          return (ahd_print_register(NULL, 0, "STACK",
              0xf2, regvalue, cur_col, wrap));
  }
  
  int
  ahd_intvec1_addr_print(u_int regvalue, u_int *cur_col, u_int wrap)
  {
          return (ahd_print_register(NULL, 0, "INTVEC1_ADDR",
              0xf4, regvalue, cur_col, wrap));
  }
  
  int
  ahd_curaddr_print(u_int regvalue, u_int *cur_col, u_int wrap)
  {
          return (ahd_print_register(NULL, 0, "CURADDR",
              0xf4, regvalue, cur_col, wrap));
  }
  
  int
  ahd_intvec2_addr_print(u_int regvalue, u_int *cur_col, u_int wrap)
  {
          return (ahd_print_register(NULL, 0, "INTVEC2_ADDR",
              0xf6, regvalue, cur_col, wrap));
  }
  
  int
  ahd_lastaddr_print(u_int regvalue, u_int *cur_col, u_int wrap)
  {
          return (ahd_print_register(NULL, 0, "LASTADDR",
              0xf6, regvalue, cur_col, wrap));
  }
  
  int
  ahd_longjmp_addr_print(u_int regvalue, u_int *cur_col, u_int wrap)
  {
          return (ahd_print_register(NULL, 0, "LONGJMP_ADDR",
              0xf8, regvalue, cur_col, wrap));
  }
  
  int
  ahd_accum_save_print(u_int regvalue, u_int *cur_col, u_int wrap)
  {
          return (ahd_print_register(NULL, 0, "ACCUM_SAVE",
              0xfa, 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_waiting_scb_tails_print(u_int regvalue, u_int *cur_col, u_int wrap)
  {
          return (ahd_print_register(NULL, 0, "WAITING_SCB_TAILS",
              0x100, regvalue, cur_col, wrap));
  }
  
  int
  ahd_ahd_pci_config_base_print(u_int regvalue, u_int *cur_col, u_int wrap)
  {
          return (ahd_print_register(NULL, 0, "AHD_PCI_CONFIG_BASE",
              0x100, regvalue, cur_col, wrap));
  }
  
  int
  ahd_waiting_tid_head_print(u_int regvalue, u_int *cur_col, u_int wrap)
  {
          return (ahd_print_register(NULL, 0, "WAITING_TID_HEAD",
              0x120, regvalue, cur_col, wrap));
  }
  
  int
  ahd_waiting_tid_tail_print(u_int regvalue, u_int *cur_col, u_int wrap)
  {
          return (ahd_print_register(NULL, 0, "WAITING_TID_TAIL",
              0x122, regvalue, cur_col, wrap));
  }
  
  int
  ahd_next_queued_scb_addr_print(u_int regvalue, u_int *cur_col, u_int wrap)
  {
          return (ahd_print_register(NULL, 0, "NEXT_QUEUED_SCB_ADDR",
              0x124, regvalue, cur_col, wrap));
  }
  
  int
  ahd_complete_scb_head_print(u_int regvalue, u_int *cur_col, u_int wrap)
  {
          return (ahd_print_register(NULL, 0, "COMPLETE_SCB_HEAD",
              0x128, regvalue, cur_col, wrap));
  }
  
  int
  ahd_complete_scb_dmainprog_head_print(u_int regvalue, u_int *cur_col, u_int wrap)
  {
          return (ahd_print_register(NULL, 0, "COMPLETE_SCB_DMAINPROG_HEAD",
              0x12a, regvalue, cur_col, wrap));
  }
  
  int
  ahd_complete_dma_scb_head_print(u_int regvalue, u_int *cur_col, u_int wrap)
  {
          return (ahd_print_register(NULL, 0, "COMPLETE_DMA_SCB_HEAD",
              0x12c, regvalue, cur_col, wrap));
  }
  
  int
  ahd_complete_dma_scb_tail_print(u_int regvalue, u_int *cur_col, u_int wrap)
  {
          return (ahd_print_register(NULL, 0, "COMPLETE_DMA_SCB_TAIL",
              0x12e, regvalue, cur_col, wrap));
  }
  
  int
  ahd_complete_on_qfreeze_head_print(u_int regvalue, u_int *cur_col, u_int wrap)
  {
          return (ahd_print_register(NULL, 0, "COMPLETE_ON_QFREEZE_HEAD",
              0x130, 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));
  }
  
  int
  ahd_msg_out_print(u_int regvalue, u_int *cur_col, u_int wrap)
  {
          return (ahd_print_register(NULL, 0, "MSG_OUT",
              0x137, regvalue, cur_col, wrap));
  }
  
  static ahd_reg_parse_entry_t DMAPARAMS_parse_table[] = {
          { "FIFORESET",          0x01, 0x01 },
          { "FIFOFLUSH",          0x02, 0x02 },
          { "DIRECTION",          0x04, 0x04 },
          { "HDMAEN",             0x08, 0x08 },
          { "HDMAENACK",          0x08, 0x08 },
          { "SDMAEN",             0x10, 0x10 },
          { "SDMAENACK",          0x10, 0x10 },
          { "SCSIEN",             0x20, 0x20 },
          { "WIDEODD",            0x40, 0x40 },
          { "PRELOADEN",          0x80, 0x80 }
  };
  
  int
  ahd_dmaparams_print(u_int regvalue, u_int *cur_col, u_int wrap)
  {
          return (ahd_print_register(DMAPARAMS_parse_table, 10, "DMAPARAMS",
              0x138, regvalue, cur_col, wrap));
  }
  
  static 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));
  }
  
  int
  ahd_saved_scsiid_print(u_int regvalue, u_int *cur_col, u_int wrap)
  {
          return (ahd_print_register(NULL, 0, "SAVED_SCSIID",
              0x13a, regvalue, cur_col, wrap));
  }
  
  int
  ahd_saved_lun_print(u_int regvalue, u_int *cur_col, u_int wrap)
  {
          return (ahd_print_register(NULL, 0, "SAVED_LUN",
              0x13b, regvalue, cur_col, wrap));
  }
  
  static 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));
  }
  
  int
  ahd_qoutfifo_entry_valid_tag_print(u_int regvalue, u_int *cur_col, u_int wrap)
  {
          return (ahd_print_register(NULL, 0, "QOUTFIFO_ENTRY_VALID_TAG",
              0x13d, regvalue, cur_col, wrap));
  }
  
  int
  ahd_kernel_tqinpos_print(u_int regvalue, u_int *cur_col, u_int wrap)
  {
          return (ahd_print_register(NULL, 0, "KERNEL_TQINPOS",
              0x13e, regvalue, cur_col, wrap));
  }
  
  int
  ahd_tqinpos_print(u_int regvalue, u_int *cur_col, u_int wrap)
  {
          return (ahd_print_register(NULL, 0, "TQINPOS",
              0x13f, regvalue, cur_col, wrap));
  }
  
  int
  ahd_shared_data_addr_print(u_int regvalue, u_int *cur_col, u_int wrap)
  {
          return (ahd_print_register(NULL, 0, "SHARED_DATA_ADDR",
              0x140, regvalue, cur_col, wrap));
  }
  
  int
  ahd_qoutfifo_next_addr_print(u_int regvalue, u_int *cur_col, u_int wrap)
  {
          return (ahd_print_register(NULL, 0, "QOUTFIFO_NEXT_ADDR",
              0x144, regvalue, cur_col, wrap));
  }
  
  static ahd_reg_parse_entry_t ARG_1_parse_table[] = {
          { "CONT_MSG_LOOP_TARG", 0x02, 0x02 },
          { "CONT_MSG_LOOP_READ", 0x03, 0x03 },
          { "CONT_MSG_LOOP_WRITE",0x04, 0x04 },
          { "EXIT_MSG_LOOP",      0x08, 0x08 },
          { "MSGOUT_PHASEMIS",    0x10, 0x10 },
          { "SEND_REJ",           0x20, 0x20 },
          { "SEND_SENSE",         0x40, 0x40 },
          { "SEND_MSG",           0x80, 0x80 }
  };
  
  int
  ahd_arg_1_print(u_int regvalue, u_int *cur_col, u_int wrap)
  {
          return (ahd_print_register(ARG_1_parse_table, 8, "ARG_1",
              0x148, regvalue, cur_col, wrap));
  }
  
  int
  ahd_arg_2_print(u_int regvalue, u_int *cur_col, u_int wrap)
  {
          return (ahd_print_register(NULL, 0, "ARG_2",
              0x149, regvalue, cur_col, wrap));
  }
  
  int
  ahd_last_msg_print(u_int regvalue, u_int *cur_col, u_int wrap)
  {
          return (ahd_print_register(NULL, 0, "LAST_MSG",
              0x14a, regvalue, cur_col, wrap));
  }
  
  static ahd_reg_parse_entry_t SCSISEQ_TEMPLATE_parse_table[] = {
          { "ALTSTIM",            0x01, 0x01 },
          { "ENAUTOATNP",         0x02, 0x02 },
          { "MANUALP",            0x0c, 0x0c },
          { "ENRSELI",            0x10, 0x10 },
          { "ENSELI",             0x20, 0x20 },
          { "MANUALCTL",          0x40, 0x40 }
  };
  
  int
  ahd_scsiseq_template_print(u_int regvalue, u_int *cur_col, u_int wrap)
  {
          return (ahd_print_register(SCSISEQ_TEMPLATE_parse_table, 6, "SCSISEQ_TEMPLATE",
              0x14b, regvalue, cur_col, wrap));
  }
  
  int
  ahd_initiator_tag_print(u_int regvalue, u_int *cur_col, u_int wrap)
  {
          return (ahd_print_register(NULL, 0, "INITIATOR_TAG",
              0x14c, regvalue, cur_col, wrap));
  }
  
  static 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_allocfifo_scbptr_print(u_int regvalue, u_int *cur_col, u_int wrap)
  {
          return (ahd_print_register(NULL, 0, "ALLOCFIFO_SCBPTR",
              0x14e, regvalue, cur_col, wrap));
  }
  
  int
  ahd_int_coalescing_timer_print(u_int regvalue, u_int *cur_col, u_int wrap)
  {
          return (ahd_print_register(NULL, 0, "INT_COALESCING_TIMER",
              0x150, regvalue, cur_col, wrap));
  }
  
  int
  ahd_int_coalescing_maxcmds_print(u_int regvalue, u_int *cur_col, u_int wrap)
  {
          return (ahd_print_register(NULL, 0, "INT_COALESCING_MAXCMDS",
              0x152, regvalue, cur_col, wrap));
  }
  
  int
  ahd_int_coalescing_mincmds_print(u_int regvalue, u_int *cur_col, u_int wrap)
  {
          return (ahd_print_register(NULL, 0, "INT_COALESCING_MINCMDS",
              0x153, regvalue, cur_col, wrap));
  }
  
  int
  ahd_cmds_pending_print(u_int regvalue, u_int *cur_col, u_int wrap)
  {
          return (ahd_print_register(NULL, 0, "CMDS_PENDING",
              0x154, regvalue, cur_col, wrap));
  }
  
  int
  ahd_int_coalescing_cmdcount_print(u_int regvalue, u_int *cur_col, u_int wrap)
  {
          return (ahd_print_register(NULL, 0, "INT_COALESCING_CMDCOUNT",
              0x156, regvalue, cur_col, wrap));
  }
  
  int
  ahd_local_hs_mailbox_print(u_int regvalue, u_int *cur_col, u_int wrap)
  {
          return (ahd_print_register(NULL, 0, "LOCAL_HS_MAILBOX",
              0x157, regvalue, cur_col, wrap));
  }
  
  int
  ahd_cmdsize_table_print(u_int regvalue, u_int *cur_col, u_int wrap)
  {
          return (ahd_print_register(NULL, 0, "CMDSIZE_TABLE",
              0x158, 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));
  }
  
  int
  ahd_scb_residual_datacnt_print(u_int regvalue, u_int *cur_col, u_int wrap)
  {
          return (ahd_print_register(NULL, 0, "SCB_RESIDUAL_DATACNT",
              0x180, regvalue, cur_col, wrap));
  }
  
  static ahd_reg_parse_entry_t SCB_RESIDUAL_SGPTR_parse_table[] = {
          { "SG_LIST_NULL",       0x01, 0x01 },
          { "SG_OVERRUN_RESID",   0x02, 0x02 },
          { "SG_ADDR_BIT",        0x04, 0x04 },
          { "SG_ADDR_MASK",       0xf8, 0xf8 }
  };
  
  int
  ahd_scb_residual_sgptr_print(u_int regvalue, u_int *cur_col, u_int wrap)
  {
          return (ahd_print_register(SCB_RESIDUAL_SGPTR_parse_table, 4, "SCB_RESIDUAL_SGPTR",
              0x184, regvalue, cur_col, wrap));
  }
  
  int
  ahd_scb_scsi_status_print(u_int regvalue, u_int *cur_col, u_int wrap)
  {
          return (ahd_print_register(NULL, 0, "SCB_SCSI_STATUS",
              0x188, regvalue, cur_col, wrap));
  }
  
  int
  ahd_scb_target_phases_print(u_int regvalue, u_int *cur_col, u_int wrap)
  {
          return (ahd_print_register(NULL, 0, "SCB_TARGET_PHASES",
              0x189, regvalue, cur_col, wrap));
  }
  
  int
  ahd_scb_target_data_dir_print(u_int regvalue, u_int *cur_col, u_int wrap)
  {
          return (ahd_print_register(NULL, 0, "SCB_TARGET_DATA_DIR",
              0x18a, regvalue, cur_col, wrap));
  }
  
  int
  ahd_scb_target_itag_print(u_int regvalue, u_int *cur_col, u_int wrap)
  {
          return (ahd_print_register(NULL, 0, "SCB_TARGET_ITAG",
              0x18b, regvalue, cur_col, wrap));
  }
  
  int
  ahd_scb_sense_busaddr_print(u_int regvalue, u_int *cur_col, u_int wrap)
  {
          return (ahd_print_register(NULL, 0, "SCB_SENSE_BUSADDR",
              0x18c, regvalue, cur_col, wrap));
  }
  
  int
  ahd_scb_tag_print(u_int regvalue, u_int *cur_col, u_int wrap)
  {
          return (ahd_print_register(NULL, 0, "SCB_TAG",
              0x190, regvalue, cur_col, wrap));
  }
  
  static 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 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));
  }
  
  static ahd_reg_parse_entry_t SCB_LUN_parse_table[] = {
          { "LID",                0xff, 0xff }
  };
  
  int
  ahd_scb_lun_print(u_int regvalue, u_int *cur_col, u_int wrap)
  {
          return (ahd_print_register(SCB_LUN_parse_table, 1, "SCB_LUN",
              0x194, regvalue, cur_col, wrap));
  }
  
  static ahd_reg_parse_entry_t SCB_TASK_ATTRIBUTE_parse_table[] = {
          { "SCB_XFERLEN_ODD",    0x01, 0x01 }
  };
  
  int
  ahd_scb_task_attribute_print(u_int regvalue, u_int *cur_col, u_int wrap)
  {
          return (ahd_print_register(SCB_TASK_ATTRIBUTE_parse_table, 1, "SCB_TASK_ATTRIBUTE",
              0x195, regvalue, cur_col, wrap));
  }
  
  static ahd_reg_parse_entry_t SCB_CDB_LEN_parse_table[] = {
          { "SCB_CDB_LEN_PTR",    0x80, 0x80 }
  };
  
  int
  ahd_scb_cdb_len_print(u_int regvalue, u_int *cur_col, u_int wrap)
  {
          return (ahd_print_register(SCB_CDB_LEN_parse_table, 1, "SCB_CDB_LEN",
              0x196, regvalue, cur_col, wrap));
  }
  
  int
  ahd_scb_task_management_print(u_int regvalue, u_int *cur_col, u_int wrap)
  {
          return (ahd_print_register(NULL, 0, "SCB_TASK_MANAGEMENT",
              0x197, regvalue, cur_col, wrap));
  }
  
  int
  ahd_scb_dataptr_print(u_int regvalue, u_int *cur_col, u_int wrap)
  {
          return (ahd_print_register(NULL, 0, "SCB_DATAPTR",
              0x198, regvalue, cur_col, wrap));
  }
  
  static ahd_reg_parse_entry_t SCB_DATACNT_parse_table[] = {
          { "SG_HIGH_ADDR_BITS",  0x7f, 0x7f },
          { "SG_LAST_SEG",        0x80, 0x80 }
  };
  
  int
  ahd_scb_datacnt_print(u_int regvalue, u_int *cur_col, u_int wrap)
  {
          return (ahd_print_register(SCB_DATACNT_parse_table, 2, "SCB_DATACNT",
              0x1a0, regvalue, cur_col, wrap));
  }
  
  static ahd_reg_parse_entry_t SCB_SGPTR_parse_table[] = {
          { "SG_LIST_NULL",       0x01, 0x01 },
          { "SG_FULL_RESID",      0x02, 0x02 },
          { "SG_STATUS_VALID",    0x04, 0x04 }
  };
  
  int
  ahd_scb_sgptr_print(u_int regvalue, u_int *cur_col, u_int wrap)
  {
          return (ahd_print_register(SCB_SGPTR_parse_table, 3, "SCB_SGPTR",
              0x1a4, regvalue, cur_col, wrap));
  }
  
  int
  ahd_scb_busaddr_print(u_int regvalue, u_int *cur_col, u_int wrap)
  {
          return (ahd_print_register(NULL, 0, "SCB_BUSADDR",
              0x1a8, regvalue, cur_col, wrap));
  }
  
  int
  ahd_scb_next_print(u_int regvalue, u_int *cur_col, u_int wrap)
  {
          return (ahd_print_register(NULL, 0, "SCB_NEXT",
              0x1ac, regvalue, cur_col, wrap));
  }
  
  int
  ahd_scb_next2_print(u_int regvalue, u_int *cur_col, u_int wrap)
  {
          return (ahd_print_register(NULL, 0, "SCB_NEXT2",
              0x1ae, regvalue, cur_col, wrap));
  }
  
  int
  ahd_scb_spare_print(u_int regvalue, u_int *cur_col, u_int wrap)
  {
          return (ahd_print_register(NULL, 0, "SCB_SPARE",
              0x1b0, regvalue, cur_col, wrap));
  }
  
  int
  ahd_scb_disconnected_lists_print(u_int regvalue, u_int *cur_col, u_int wrap)
  {
          return (ahd_print_register(NULL, 0, "SCB_DISCONNECTED_LISTS",
              0x1b8, regvalue, cur_col, wrap));
  }
  

Cache object: 76a20d70818e2a162dd8e17775c39f61