/* 
 | 
 * DO NOT EDIT - This file is automatically generated 
 | 
 *         from the following source files: 
 | 
 * 
 | 
 * $Id: //depot/aic7xxx/aic7xxx/aic79xx.seq#120 $ 
 | 
 * $Id: //depot/aic7xxx/aic7xxx/aic79xx.reg#77 $ 
 | 
 */ 
 | 
  
 | 
#include "aic79xx_osm.h" 
 | 
  
 | 
static const ahd_reg_parse_entry_t INTSTAT_parse_table[] = { 
 | 
    { "SPLTINT",        0x01, 0x01 }, 
 | 
    { "CMDCMPLT",        0x02, 0x02 }, 
 | 
    { "SEQINT",        0x04, 0x04 }, 
 | 
    { "SCSIINT",        0x08, 0x08 }, 
 | 
    { "PCIINT",        0x10, 0x10 }, 
 | 
    { "SWTMINT",        0x20, 0x20 }, 
 | 
    { "BRKADRINT",        0x40, 0x40 }, 
 | 
    { "HWERRINT",        0x80, 0x80 }, 
 | 
    { "INT_PEND",        0xff, 0xff } 
 | 
}; 
 | 
  
 | 
int 
 | 
ahd_intstat_print(u_int regvalue, u_int *cur_col, u_int wrap) 
 | 
{ 
 | 
    return (ahd_print_register(INTSTAT_parse_table, 9, "INTSTAT", 
 | 
        0x01, regvalue, cur_col, wrap)); 
 | 
} 
 | 
  
 | 
static const ahd_reg_parse_entry_t HS_MAILBOX_parse_table[] = { 
 | 
    { "ENINT_COALESCE",    0x40, 0x40 }, 
 | 
    { "HOST_TQINPOS",    0x80, 0x80 } 
 | 
}; 
 | 
  
 | 
int 
 | 
ahd_hs_mailbox_print(u_int regvalue, u_int *cur_col, u_int wrap) 
 | 
{ 
 | 
    return (ahd_print_register(HS_MAILBOX_parse_table, 2, "HS_MAILBOX", 
 | 
        0x0b, regvalue, cur_col, wrap)); 
 | 
} 
 | 
  
 | 
static const ahd_reg_parse_entry_t SEQINTSTAT_parse_table[] = { 
 | 
    { "SEQ_SPLTINT",    0x01, 0x01 }, 
 | 
    { "SEQ_PCIINT",        0x02, 0x02 }, 
 | 
    { "SEQ_SCSIINT",    0x04, 0x04 }, 
 | 
    { "SEQ_SEQINT",        0x08, 0x08 }, 
 | 
    { "SEQ_SWTMRTO",    0x10, 0x10 } 
 | 
}; 
 | 
  
 | 
int 
 | 
ahd_seqintstat_print(u_int regvalue, u_int *cur_col, u_int wrap) 
 | 
{ 
 | 
    return (ahd_print_register(SEQINTSTAT_parse_table, 5, "SEQINTSTAT", 
 | 
        0x0c, regvalue, cur_col, wrap)); 
 | 
} 
 | 
  
 | 
static const ahd_reg_parse_entry_t INTCTL_parse_table[] = { 
 | 
    { "SPLTINTEN",        0x01, 0x01 }, 
 | 
    { "SEQINTEN",        0x02, 0x02 }, 
 | 
    { "SCSIINTEN",        0x04, 0x04 }, 
 | 
    { "PCIINTEN",        0x08, 0x08 }, 
 | 
    { "AUTOCLRCMDINT",    0x10, 0x10 }, 
 | 
    { "SWTIMER_START",    0x20, 0x20 }, 
 | 
    { "SWTMINTEN",        0x40, 0x40 }, 
 | 
    { "SWTMINTMASK",    0x80, 0x80 } 
 | 
}; 
 | 
  
 | 
int 
 | 
ahd_intctl_print(u_int regvalue, u_int *cur_col, u_int wrap) 
 | 
{ 
 | 
    return (ahd_print_register(INTCTL_parse_table, 8, "INTCTL", 
 | 
        0x18, regvalue, cur_col, wrap)); 
 | 
} 
 | 
  
 | 
static const ahd_reg_parse_entry_t DFCNTRL_parse_table[] = { 
 | 
    { "DIRECTIONEN",    0x01, 0x01 }, 
 | 
    { "FIFOFLUSH",        0x02, 0x02 }, 
 | 
    { "FIFOFLUSHACK",    0x02, 0x02 }, 
 | 
    { "DIRECTION",        0x04, 0x04 }, 
 | 
    { "DIRECTIONACK",    0x04, 0x04 }, 
 | 
    { "HDMAEN",        0x08, 0x08 }, 
 | 
    { "HDMAENACK",        0x08, 0x08 }, 
 | 
    { "SCSIEN",        0x20, 0x20 }, 
 | 
    { "SCSIENACK",        0x20, 0x20 }, 
 | 
    { "SCSIENWRDIS",    0x40, 0x40 }, 
 | 
    { "PRELOADEN",        0x80, 0x80 } 
 | 
}; 
 | 
  
 | 
int 
 | 
ahd_dfcntrl_print(u_int regvalue, u_int *cur_col, u_int wrap) 
 | 
{ 
 | 
    return (ahd_print_register(DFCNTRL_parse_table, 11, "DFCNTRL", 
 | 
        0x19, regvalue, cur_col, wrap)); 
 | 
} 
 | 
  
 | 
static const ahd_reg_parse_entry_t DFSTATUS_parse_table[] = { 
 | 
    { "FIFOEMP",        0x01, 0x01 }, 
 | 
    { "FIFOFULL",        0x02, 0x02 }, 
 | 
    { "DFTHRESH",        0x04, 0x04 }, 
 | 
    { "HDONE",        0x08, 0x08 }, 
 | 
    { "MREQPEND",        0x10, 0x10 }, 
 | 
    { "PKT_PRELOAD_AVAIL",    0x40, 0x40 }, 
 | 
    { "PRELOAD_AVAIL",    0x80, 0x80 } 
 | 
}; 
 | 
  
 | 
int 
 | 
ahd_dfstatus_print(u_int regvalue, u_int *cur_col, u_int wrap) 
 | 
{ 
 | 
    return (ahd_print_register(DFSTATUS_parse_table, 7, "DFSTATUS", 
 | 
        0x1a, regvalue, cur_col, wrap)); 
 | 
} 
 | 
  
 | 
static const ahd_reg_parse_entry_t SG_CACHE_SHADOW_parse_table[] = { 
 | 
    { "LAST_SEG_DONE",    0x01, 0x01 }, 
 | 
    { "LAST_SEG",        0x02, 0x02 }, 
 | 
    { "ODD_SEG",        0x04, 0x04 }, 
 | 
    { "SG_ADDR_MASK",    0xf8, 0xf8 } 
 | 
}; 
 | 
  
 | 
int 
 | 
ahd_sg_cache_shadow_print(u_int regvalue, u_int *cur_col, u_int wrap) 
 | 
{ 
 | 
    return (ahd_print_register(SG_CACHE_SHADOW_parse_table, 4, "SG_CACHE_SHADOW", 
 | 
        0x1b, regvalue, cur_col, wrap)); 
 | 
} 
 | 
  
 | 
static const ahd_reg_parse_entry_t SCSISEQ0_parse_table[] = { 
 | 
    { "SCSIRSTO",        0x01, 0x01 }, 
 | 
    { "FORCEBUSFREE",    0x10, 0x10 }, 
 | 
    { "ENARBO",        0x20, 0x20 }, 
 | 
    { "ENSELO",        0x40, 0x40 }, 
 | 
    { "TEMODEO",        0x80, 0x80 } 
 | 
}; 
 | 
  
 | 
int 
 | 
ahd_scsiseq0_print(u_int regvalue, u_int *cur_col, u_int wrap) 
 | 
{ 
 | 
    return (ahd_print_register(SCSISEQ0_parse_table, 5, "SCSISEQ0", 
 | 
        0x3a, regvalue, cur_col, wrap)); 
 | 
} 
 | 
  
 | 
static const ahd_reg_parse_entry_t SCSISEQ1_parse_table[] = { 
 | 
    { "ALTSTIM",        0x01, 0x01 }, 
 | 
    { "ENAUTOATNP",        0x02, 0x02 }, 
 | 
    { "MANUALP",        0x0c, 0x0c }, 
 | 
    { "ENRSELI",        0x10, 0x10 }, 
 | 
    { "ENSELI",        0x20, 0x20 }, 
 | 
    { "MANUALCTL",        0x40, 0x40 } 
 | 
}; 
 | 
  
 | 
int 
 | 
ahd_scsiseq1_print(u_int regvalue, u_int *cur_col, u_int wrap) 
 | 
{ 
 | 
    return (ahd_print_register(SCSISEQ1_parse_table, 6, "SCSISEQ1", 
 | 
        0x3b, regvalue, cur_col, wrap)); 
 | 
} 
 | 
  
 | 
static const ahd_reg_parse_entry_t DFFSTAT_parse_table[] = { 
 | 
    { "CURRFIFO_0",        0x00, 0x03 }, 
 | 
    { "CURRFIFO_1",        0x01, 0x03 }, 
 | 
    { "CURRFIFO_NONE",    0x03, 0x03 }, 
 | 
    { "FIFO0FREE",        0x10, 0x10 }, 
 | 
    { "FIFO1FREE",        0x20, 0x20 }, 
 | 
    { "CURRFIFO",        0x03, 0x03 } 
 | 
}; 
 | 
  
 | 
int 
 | 
ahd_dffstat_print(u_int regvalue, u_int *cur_col, u_int wrap) 
 | 
{ 
 | 
    return (ahd_print_register(DFFSTAT_parse_table, 6, "DFFSTAT", 
 | 
        0x3f, regvalue, cur_col, wrap)); 
 | 
} 
 | 
  
 | 
static const ahd_reg_parse_entry_t SCSISIGI_parse_table[] = { 
 | 
    { "P_DATAOUT",        0x00, 0xe0 }, 
 | 
    { "P_DATAOUT_DT",    0x20, 0xe0 }, 
 | 
    { "P_DATAIN",        0x40, 0xe0 }, 
 | 
    { "P_DATAIN_DT",    0x60, 0xe0 }, 
 | 
    { "P_COMMAND",        0x80, 0xe0 }, 
 | 
    { "P_MESGOUT",        0xa0, 0xe0 }, 
 | 
    { "P_STATUS",        0xc0, 0xe0 }, 
 | 
    { "P_MESGIN",        0xe0, 0xe0 }, 
 | 
    { "ACKI",        0x01, 0x01 }, 
 | 
    { "REQI",        0x02, 0x02 }, 
 | 
    { "BSYI",        0x04, 0x04 }, 
 | 
    { "SELI",        0x08, 0x08 }, 
 | 
    { "ATNI",        0x10, 0x10 }, 
 | 
    { "MSGI",        0x20, 0x20 }, 
 | 
    { "IOI",        0x40, 0x40 }, 
 | 
    { "CDI",        0x80, 0x80 }, 
 | 
    { "PHASE_MASK",        0xe0, 0xe0 } 
 | 
}; 
 | 
  
 | 
int 
 | 
ahd_scsisigi_print(u_int regvalue, u_int *cur_col, u_int wrap) 
 | 
{ 
 | 
    return (ahd_print_register(SCSISIGI_parse_table, 17, "SCSISIGI", 
 | 
        0x41, regvalue, cur_col, wrap)); 
 | 
} 
 | 
  
 | 
static const ahd_reg_parse_entry_t SCSIPHASE_parse_table[] = { 
 | 
    { "DATA_OUT_PHASE",    0x01, 0x03 }, 
 | 
    { "DATA_IN_PHASE",    0x02, 0x03 }, 
 | 
    { "DATA_PHASE_MASK",    0x03, 0x03 }, 
 | 
    { "MSG_OUT_PHASE",    0x04, 0x04 }, 
 | 
    { "MSG_IN_PHASE",    0x08, 0x08 }, 
 | 
    { "COMMAND_PHASE",    0x10, 0x10 }, 
 | 
    { "STATUS_PHASE",    0x20, 0x20 } 
 | 
}; 
 | 
  
 | 
int 
 | 
ahd_scsiphase_print(u_int regvalue, u_int *cur_col, u_int wrap) 
 | 
{ 
 | 
    return (ahd_print_register(SCSIPHASE_parse_table, 7, "SCSIPHASE", 
 | 
        0x42, regvalue, cur_col, wrap)); 
 | 
} 
 | 
  
 | 
int 
 | 
ahd_scsibus_print(u_int regvalue, u_int *cur_col, u_int wrap) 
 | 
{ 
 | 
    return (ahd_print_register(NULL, 0, "SCSIBUS", 
 | 
        0x46, regvalue, cur_col, wrap)); 
 | 
} 
 | 
  
 | 
static const ahd_reg_parse_entry_t SELID_parse_table[] = { 
 | 
    { "ONEBIT",        0x08, 0x08 }, 
 | 
    { "SELID_MASK",        0xf0, 0xf0 } 
 | 
}; 
 | 
  
 | 
int 
 | 
ahd_selid_print(u_int regvalue, u_int *cur_col, u_int wrap) 
 | 
{ 
 | 
    return (ahd_print_register(SELID_parse_table, 2, "SELID", 
 | 
        0x49, regvalue, cur_col, wrap)); 
 | 
} 
 | 
  
 | 
static const ahd_reg_parse_entry_t SIMODE0_parse_table[] = { 
 | 
    { "ENARBDO",        0x01, 0x01 }, 
 | 
    { "ENSPIORDY",        0x02, 0x02 }, 
 | 
    { "ENOVERRUN",        0x04, 0x04 }, 
 | 
    { "ENIOERR",        0x08, 0x08 }, 
 | 
    { "ENSELINGO",        0x10, 0x10 }, 
 | 
    { "ENSELDI",        0x20, 0x20 }, 
 | 
    { "ENSELDO",        0x40, 0x40 } 
 | 
}; 
 | 
  
 | 
int 
 | 
ahd_simode0_print(u_int regvalue, u_int *cur_col, u_int wrap) 
 | 
{ 
 | 
    return (ahd_print_register(SIMODE0_parse_table, 7, "SIMODE0", 
 | 
        0x4b, regvalue, cur_col, wrap)); 
 | 
} 
 | 
  
 | 
static const ahd_reg_parse_entry_t SSTAT0_parse_table[] = { 
 | 
    { "ARBDO",        0x01, 0x01 }, 
 | 
    { "SPIORDY",        0x02, 0x02 }, 
 | 
    { "OVERRUN",        0x04, 0x04 }, 
 | 
    { "IOERR",        0x08, 0x08 }, 
 | 
    { "SELINGO",        0x10, 0x10 }, 
 | 
    { "SELDI",        0x20, 0x20 }, 
 | 
    { "SELDO",        0x40, 0x40 }, 
 | 
    { "TARGET",        0x80, 0x80 } 
 | 
}; 
 | 
  
 | 
int 
 | 
ahd_sstat0_print(u_int regvalue, u_int *cur_col, u_int wrap) 
 | 
{ 
 | 
    return (ahd_print_register(SSTAT0_parse_table, 8, "SSTAT0", 
 | 
        0x4b, regvalue, cur_col, wrap)); 
 | 
} 
 | 
  
 | 
static const ahd_reg_parse_entry_t SSTAT1_parse_table[] = { 
 | 
    { "REQINIT",        0x01, 0x01 }, 
 | 
    { "STRB2FAST",        0x02, 0x02 }, 
 | 
    { "SCSIPERR",        0x04, 0x04 }, 
 | 
    { "BUSFREE",        0x08, 0x08 }, 
 | 
    { "PHASEMIS",        0x10, 0x10 }, 
 | 
    { "SCSIRSTI",        0x20, 0x20 }, 
 | 
    { "ATNTARG",        0x40, 0x40 }, 
 | 
    { "SELTO",        0x80, 0x80 } 
 | 
}; 
 | 
  
 | 
int 
 | 
ahd_sstat1_print(u_int regvalue, u_int *cur_col, u_int wrap) 
 | 
{ 
 | 
    return (ahd_print_register(SSTAT1_parse_table, 8, "SSTAT1", 
 | 
        0x4c, regvalue, cur_col, wrap)); 
 | 
} 
 | 
  
 | 
static const ahd_reg_parse_entry_t SSTAT2_parse_table[] = { 
 | 
    { "BUSFREE_LQO",    0x40, 0xc0 }, 
 | 
    { "BUSFREE_DFF0",    0x80, 0xc0 }, 
 | 
    { "BUSFREE_DFF1",    0xc0, 0xc0 }, 
 | 
    { "DMADONE",        0x01, 0x01 }, 
 | 
    { "SDONE",        0x02, 0x02 }, 
 | 
    { "WIDE_RES",        0x04, 0x04 }, 
 | 
    { "BSYX",        0x08, 0x08 }, 
 | 
    { "EXP_ACTIVE",        0x10, 0x10 }, 
 | 
    { "NONPACKREQ",        0x20, 0x20 }, 
 | 
    { "BUSFREETIME",    0xc0, 0xc0 } 
 | 
}; 
 | 
  
 | 
int 
 | 
ahd_sstat2_print(u_int regvalue, u_int *cur_col, u_int wrap) 
 | 
{ 
 | 
    return (ahd_print_register(SSTAT2_parse_table, 10, "SSTAT2", 
 | 
        0x4d, regvalue, cur_col, wrap)); 
 | 
} 
 | 
  
 | 
static const ahd_reg_parse_entry_t PERRDIAG_parse_table[] = { 
 | 
    { "DTERR",        0x01, 0x01 }, 
 | 
    { "DGFORMERR",        0x02, 0x02 }, 
 | 
    { "CRCERR",        0x04, 0x04 }, 
 | 
    { "AIPERR",        0x08, 0x08 }, 
 | 
    { "PARITYERR",        0x10, 0x10 }, 
 | 
    { "PREVPHASE",        0x20, 0x20 }, 
 | 
    { "HIPERR",        0x40, 0x40 }, 
 | 
    { "HIZERO",        0x80, 0x80 } 
 | 
}; 
 | 
  
 | 
int 
 | 
ahd_perrdiag_print(u_int regvalue, u_int *cur_col, u_int wrap) 
 | 
{ 
 | 
    return (ahd_print_register(PERRDIAG_parse_table, 8, "PERRDIAG", 
 | 
        0x4e, regvalue, cur_col, wrap)); 
 | 
} 
 | 
  
 | 
int 
 | 
ahd_soffcnt_print(u_int regvalue, u_int *cur_col, u_int wrap) 
 | 
{ 
 | 
    return (ahd_print_register(NULL, 0, "SOFFCNT", 
 | 
        0x4f, regvalue, cur_col, wrap)); 
 | 
} 
 | 
  
 | 
static const ahd_reg_parse_entry_t LQISTAT0_parse_table[] = { 
 | 
    { "LQIATNCMD",        0x01, 0x01 }, 
 | 
    { "LQIATNLQ",        0x02, 0x02 }, 
 | 
    { "LQIBADLQT",        0x04, 0x04 }, 
 | 
    { "LQICRCT2",        0x08, 0x08 }, 
 | 
    { "LQICRCT1",        0x10, 0x10 }, 
 | 
    { "LQIATNQAS",        0x20, 0x20 } 
 | 
}; 
 | 
  
 | 
int 
 | 
ahd_lqistat0_print(u_int regvalue, u_int *cur_col, u_int wrap) 
 | 
{ 
 | 
    return (ahd_print_register(LQISTAT0_parse_table, 6, "LQISTAT0", 
 | 
        0x50, regvalue, cur_col, wrap)); 
 | 
} 
 | 
  
 | 
static const ahd_reg_parse_entry_t LQISTAT1_parse_table[] = { 
 | 
    { "LQIOVERI_NLQ",    0x01, 0x01 }, 
 | 
    { "LQIOVERI_LQ",    0x02, 0x02 }, 
 | 
    { "LQIBADLQI",        0x04, 0x04 }, 
 | 
    { "LQICRCI_NLQ",    0x08, 0x08 }, 
 | 
    { "LQICRCI_LQ",        0x10, 0x10 }, 
 | 
    { "LQIABORT",        0x20, 0x20 }, 
 | 
    { "LQIPHASE_NLQ",    0x40, 0x40 }, 
 | 
    { "LQIPHASE_LQ",    0x80, 0x80 } 
 | 
}; 
 | 
  
 | 
int 
 | 
ahd_lqistat1_print(u_int regvalue, u_int *cur_col, u_int wrap) 
 | 
{ 
 | 
    return (ahd_print_register(LQISTAT1_parse_table, 8, "LQISTAT1", 
 | 
        0x51, regvalue, cur_col, wrap)); 
 | 
} 
 | 
  
 | 
static const ahd_reg_parse_entry_t LQISTAT2_parse_table[] = { 
 | 
    { "LQIGSAVAIL",        0x01, 0x01 }, 
 | 
    { "LQISTOPCMD",        0x02, 0x02 }, 
 | 
    { "LQISTOPLQ",        0x04, 0x04 }, 
 | 
    { "LQISTOPPKT",        0x08, 0x08 }, 
 | 
    { "LQIWAITFIFO",    0x10, 0x10 }, 
 | 
    { "LQIWORKONLQ",    0x20, 0x20 }, 
 | 
    { "LQIPHASE_OUTPKT",    0x40, 0x40 }, 
 | 
    { "PACKETIZED",        0x80, 0x80 } 
 | 
}; 
 | 
  
 | 
int 
 | 
ahd_lqistat2_print(u_int regvalue, u_int *cur_col, u_int wrap) 
 | 
{ 
 | 
    return (ahd_print_register(LQISTAT2_parse_table, 8, "LQISTAT2", 
 | 
        0x52, regvalue, cur_col, wrap)); 
 | 
} 
 | 
  
 | 
static const ahd_reg_parse_entry_t SSTAT3_parse_table[] = { 
 | 
    { "OSRAMPERR",        0x01, 0x01 }, 
 | 
    { "NTRAMPERR",        0x02, 0x02 } 
 | 
}; 
 | 
  
 | 
int 
 | 
ahd_sstat3_print(u_int regvalue, u_int *cur_col, u_int wrap) 
 | 
{ 
 | 
    return (ahd_print_register(SSTAT3_parse_table, 2, "SSTAT3", 
 | 
        0x53, regvalue, cur_col, wrap)); 
 | 
} 
 | 
  
 | 
static const ahd_reg_parse_entry_t LQOSTAT0_parse_table[] = { 
 | 
    { "LQOTCRC",        0x01, 0x01 }, 
 | 
    { "LQOATNPKT",        0x02, 0x02 }, 
 | 
    { "LQOATNLQ",        0x04, 0x04 }, 
 | 
    { "LQOSTOPT2",        0x08, 0x08 }, 
 | 
    { "LQOTARGSCBPERR",    0x10, 0x10 } 
 | 
}; 
 | 
  
 | 
int 
 | 
ahd_lqostat0_print(u_int regvalue, u_int *cur_col, u_int wrap) 
 | 
{ 
 | 
    return (ahd_print_register(LQOSTAT0_parse_table, 5, "LQOSTAT0", 
 | 
        0x54, regvalue, cur_col, wrap)); 
 | 
} 
 | 
  
 | 
static const ahd_reg_parse_entry_t LQOSTAT1_parse_table[] = { 
 | 
    { "LQOPHACHGINPKT",    0x01, 0x01 }, 
 | 
    { "LQOBUSFREE",        0x02, 0x02 }, 
 | 
    { "LQOBADQAS",        0x04, 0x04 }, 
 | 
    { "LQOSTOPI2",        0x08, 0x08 }, 
 | 
    { "LQOINITSCBPERR",    0x10, 0x10 } 
 | 
}; 
 | 
  
 | 
int 
 | 
ahd_lqostat1_print(u_int regvalue, u_int *cur_col, u_int wrap) 
 | 
{ 
 | 
    return (ahd_print_register(LQOSTAT1_parse_table, 5, "LQOSTAT1", 
 | 
        0x55, regvalue, cur_col, wrap)); 
 | 
} 
 | 
  
 | 
static const ahd_reg_parse_entry_t LQOSTAT2_parse_table[] = { 
 | 
    { "LQOSTOP0",        0x01, 0x01 }, 
 | 
    { "LQOPHACHGOUTPKT",    0x02, 0x02 }, 
 | 
    { "LQOWAITFIFO",    0x10, 0x10 }, 
 | 
    { "LQOPKT",        0xe0, 0xe0 } 
 | 
}; 
 | 
  
 | 
int 
 | 
ahd_lqostat2_print(u_int regvalue, u_int *cur_col, u_int wrap) 
 | 
{ 
 | 
    return (ahd_print_register(LQOSTAT2_parse_table, 4, "LQOSTAT2", 
 | 
        0x56, regvalue, cur_col, wrap)); 
 | 
} 
 | 
  
 | 
static const ahd_reg_parse_entry_t SIMODE1_parse_table[] = { 
 | 
    { "ENREQINIT",        0x01, 0x01 }, 
 | 
    { "ENSTRB2FAST",    0x02, 0x02 }, 
 | 
    { "ENSCSIPERR",        0x04, 0x04 }, 
 | 
    { "ENBUSFREE",        0x08, 0x08 }, 
 | 
    { "ENPHASEMIS",        0x10, 0x10 }, 
 | 
    { "ENSCSIRST",        0x20, 0x20 }, 
 | 
    { "ENATNTARG",        0x40, 0x40 }, 
 | 
    { "ENSELTIMO",        0x80, 0x80 } 
 | 
}; 
 | 
  
 | 
int 
 | 
ahd_simode1_print(u_int regvalue, u_int *cur_col, u_int wrap) 
 | 
{ 
 | 
    return (ahd_print_register(SIMODE1_parse_table, 8, "SIMODE1", 
 | 
        0x57, regvalue, cur_col, wrap)); 
 | 
} 
 | 
  
 | 
static const ahd_reg_parse_entry_t DFFSXFRCTL_parse_table[] = { 
 | 
    { "RSTCHN",        0x01, 0x01 }, 
 | 
    { "CLRCHN",        0x02, 0x02 }, 
 | 
    { "CLRSHCNT",        0x04, 0x04 }, 
 | 
    { "DFFBITBUCKET",    0x08, 0x08 } 
 | 
}; 
 | 
  
 | 
int 
 | 
ahd_dffsxfrctl_print(u_int regvalue, u_int *cur_col, u_int wrap) 
 | 
{ 
 | 
    return (ahd_print_register(DFFSXFRCTL_parse_table, 4, "DFFSXFRCTL", 
 | 
        0x5a, regvalue, cur_col, wrap)); 
 | 
} 
 | 
  
 | 
static const ahd_reg_parse_entry_t SEQINTSRC_parse_table[] = { 
 | 
    { "CFG4TCMD",        0x01, 0x01 }, 
 | 
    { "CFG4ICMD",        0x02, 0x02 }, 
 | 
    { "CFG4TSTAT",        0x04, 0x04 }, 
 | 
    { "CFG4ISTAT",        0x08, 0x08 }, 
 | 
    { "CFG4DATA",        0x10, 0x10 }, 
 | 
    { "SAVEPTRS",        0x20, 0x20 }, 
 | 
    { "CTXTDONE",        0x40, 0x40 } 
 | 
}; 
 | 
  
 | 
int 
 | 
ahd_seqintsrc_print(u_int regvalue, u_int *cur_col, u_int wrap) 
 | 
{ 
 | 
    return (ahd_print_register(SEQINTSRC_parse_table, 7, "SEQINTSRC", 
 | 
        0x5b, regvalue, cur_col, wrap)); 
 | 
} 
 | 
  
 | 
static const ahd_reg_parse_entry_t SEQIMODE_parse_table[] = { 
 | 
    { "ENCFG4TCMD",        0x01, 0x01 }, 
 | 
    { "ENCFG4ICMD",        0x02, 0x02 }, 
 | 
    { "ENCFG4TSTAT",    0x04, 0x04 }, 
 | 
    { "ENCFG4ISTAT",    0x08, 0x08 }, 
 | 
    { "ENCFG4DATA",        0x10, 0x10 }, 
 | 
    { "ENSAVEPTRS",        0x20, 0x20 }, 
 | 
    { "ENCTXTDONE",        0x40, 0x40 } 
 | 
}; 
 | 
  
 | 
int 
 | 
ahd_seqimode_print(u_int regvalue, u_int *cur_col, u_int wrap) 
 | 
{ 
 | 
    return (ahd_print_register(SEQIMODE_parse_table, 7, "SEQIMODE", 
 | 
        0x5c, regvalue, cur_col, wrap)); 
 | 
} 
 | 
  
 | 
static const ahd_reg_parse_entry_t MDFFSTAT_parse_table[] = { 
 | 
    { "FIFOFREE",        0x01, 0x01 }, 
 | 
    { "DATAINFIFO",        0x02, 0x02 }, 
 | 
    { "DLZERO",        0x04, 0x04 }, 
 | 
    { "SHVALID",        0x08, 0x08 }, 
 | 
    { "LASTSDONE",        0x10, 0x10 }, 
 | 
    { "SHCNTMINUS1",    0x20, 0x20 }, 
 | 
    { "SHCNTNEGATIVE",    0x40, 0x40 } 
 | 
}; 
 | 
  
 | 
int 
 | 
ahd_mdffstat_print(u_int regvalue, u_int *cur_col, u_int wrap) 
 | 
{ 
 | 
    return (ahd_print_register(MDFFSTAT_parse_table, 7, "MDFFSTAT", 
 | 
        0x5d, regvalue, cur_col, wrap)); 
 | 
} 
 | 
  
 | 
int 
 | 
ahd_seloid_print(u_int regvalue, u_int *cur_col, u_int wrap) 
 | 
{ 
 | 
    return (ahd_print_register(NULL, 0, "SELOID", 
 | 
        0x6b, regvalue, cur_col, wrap)); 
 | 
} 
 | 
  
 | 
static const ahd_reg_parse_entry_t SG_STATE_parse_table[] = { 
 | 
    { "SEGS_AVAIL",        0x01, 0x01 }, 
 | 
    { "LOADING_NEEDED",    0x02, 0x02 }, 
 | 
    { "FETCH_INPROG",    0x04, 0x04 } 
 | 
}; 
 | 
  
 | 
int 
 | 
ahd_sg_state_print(u_int regvalue, u_int *cur_col, u_int wrap) 
 | 
{ 
 | 
    return (ahd_print_register(SG_STATE_parse_table, 3, "SG_STATE", 
 | 
        0xa6, regvalue, cur_col, wrap)); 
 | 
} 
 | 
  
 | 
static const ahd_reg_parse_entry_t CCSCBCTL_parse_table[] = { 
 | 
    { "CCSCBRESET",        0x01, 0x01 }, 
 | 
    { "CCSCBDIR",        0x04, 0x04 }, 
 | 
    { "CCSCBEN",        0x08, 0x08 }, 
 | 
    { "CCARREN",        0x10, 0x10 }, 
 | 
    { "ARRDONE",        0x40, 0x40 }, 
 | 
    { "CCSCBDONE",        0x80, 0x80 } 
 | 
}; 
 | 
  
 | 
int 
 | 
ahd_ccscbctl_print(u_int regvalue, u_int *cur_col, u_int wrap) 
 | 
{ 
 | 
    return (ahd_print_register(CCSCBCTL_parse_table, 6, "CCSCBCTL", 
 | 
        0xad, regvalue, cur_col, wrap)); 
 | 
} 
 | 
  
 | 
static const ahd_reg_parse_entry_t CCSGCTL_parse_table[] = { 
 | 
    { "CCSGRESET",        0x01, 0x01 }, 
 | 
    { "SG_FETCH_REQ",    0x02, 0x02 }, 
 | 
    { "CCSGENACK",        0x08, 0x08 }, 
 | 
    { "SG_CACHE_AVAIL",    0x10, 0x10 }, 
 | 
    { "CCSGDONE",        0x80, 0x80 }, 
 | 
    { "CCSGEN",        0x0c, 0x0c } 
 | 
}; 
 | 
  
 | 
int 
 | 
ahd_ccsgctl_print(u_int regvalue, u_int *cur_col, u_int wrap) 
 | 
{ 
 | 
    return (ahd_print_register(CCSGCTL_parse_table, 6, "CCSGCTL", 
 | 
        0xad, regvalue, cur_col, wrap)); 
 | 
} 
 | 
  
 | 
static const ahd_reg_parse_entry_t SEQCTL0_parse_table[] = { 
 | 
    { "LOADRAM",        0x01, 0x01 }, 
 | 
    { "SEQRESET",        0x02, 0x02 }, 
 | 
    { "STEP",        0x04, 0x04 }, 
 | 
    { "BRKADRINTEN",    0x08, 0x08 }, 
 | 
    { "FASTMODE",        0x10, 0x10 }, 
 | 
    { "FAILDIS",        0x20, 0x20 }, 
 | 
    { "PAUSEDIS",        0x40, 0x40 }, 
 | 
    { "PERRORDIS",        0x80, 0x80 } 
 | 
}; 
 | 
  
 | 
int 
 | 
ahd_seqctl0_print(u_int regvalue, u_int *cur_col, u_int wrap) 
 | 
{ 
 | 
    return (ahd_print_register(SEQCTL0_parse_table, 8, "SEQCTL0", 
 | 
        0xd6, regvalue, cur_col, wrap)); 
 | 
} 
 | 
  
 | 
static const ahd_reg_parse_entry_t SEQINTCTL_parse_table[] = { 
 | 
    { "IRET",        0x01, 0x01 }, 
 | 
    { "INTMASK1",        0x02, 0x02 }, 
 | 
    { "INTMASK2",        0x04, 0x04 }, 
 | 
    { "SCS_SEQ_INT1M0",    0x08, 0x08 }, 
 | 
    { "SCS_SEQ_INT1M1",    0x10, 0x10 }, 
 | 
    { "INT1_CONTEXT",    0x20, 0x20 }, 
 | 
    { "INTVEC1DSL",        0x80, 0x80 } 
 | 
}; 
 | 
  
 | 
int 
 | 
ahd_seqintctl_print(u_int regvalue, u_int *cur_col, u_int wrap) 
 | 
{ 
 | 
    return (ahd_print_register(SEQINTCTL_parse_table, 7, "SEQINTCTL", 
 | 
        0xd9, regvalue, cur_col, wrap)); 
 | 
} 
 | 
  
 | 
int 
 | 
ahd_sram_base_print(u_int regvalue, u_int *cur_col, u_int wrap) 
 | 
{ 
 | 
    return (ahd_print_register(NULL, 0, "SRAM_BASE", 
 | 
        0x100, regvalue, cur_col, wrap)); 
 | 
} 
 | 
  
 | 
int 
 | 
ahd_qfreeze_count_print(u_int regvalue, u_int *cur_col, u_int wrap) 
 | 
{ 
 | 
    return (ahd_print_register(NULL, 0, "QFREEZE_COUNT", 
 | 
        0x132, regvalue, cur_col, wrap)); 
 | 
} 
 | 
  
 | 
int 
 | 
ahd_kernel_qfreeze_count_print(u_int regvalue, u_int *cur_col, u_int wrap) 
 | 
{ 
 | 
    return (ahd_print_register(NULL, 0, "KERNEL_QFREEZE_COUNT", 
 | 
        0x134, regvalue, cur_col, wrap)); 
 | 
} 
 | 
  
 | 
int 
 | 
ahd_saved_mode_print(u_int regvalue, u_int *cur_col, u_int wrap) 
 | 
{ 
 | 
    return (ahd_print_register(NULL, 0, "SAVED_MODE", 
 | 
        0x136, regvalue, cur_col, wrap)); 
 | 
} 
 | 
  
 | 
static const ahd_reg_parse_entry_t SEQ_FLAGS_parse_table[] = { 
 | 
    { "NO_DISCONNECT",    0x01, 0x01 }, 
 | 
    { "SPHASE_PENDING",    0x02, 0x02 }, 
 | 
    { "DPHASE_PENDING",    0x04, 0x04 }, 
 | 
    { "CMDPHASE_PENDING",    0x08, 0x08 }, 
 | 
    { "TARG_CMD_PENDING",    0x10, 0x10 }, 
 | 
    { "DPHASE",        0x20, 0x20 }, 
 | 
    { "NO_CDB_SENT",    0x40, 0x40 }, 
 | 
    { "TARGET_CMD_IS_TAGGED",0x40, 0x40 }, 
 | 
    { "NOT_IDENTIFIED",    0x80, 0x80 } 
 | 
}; 
 | 
  
 | 
int 
 | 
ahd_seq_flags_print(u_int regvalue, u_int *cur_col, u_int wrap) 
 | 
{ 
 | 
    return (ahd_print_register(SEQ_FLAGS_parse_table, 9, "SEQ_FLAGS", 
 | 
        0x139, regvalue, cur_col, wrap)); 
 | 
} 
 | 
  
 | 
static const ahd_reg_parse_entry_t LASTPHASE_parse_table[] = { 
 | 
    { "P_DATAOUT",        0x00, 0xe0 }, 
 | 
    { "P_DATAOUT_DT",    0x20, 0xe0 }, 
 | 
    { "P_DATAIN",        0x40, 0xe0 }, 
 | 
    { "P_DATAIN_DT",    0x60, 0xe0 }, 
 | 
    { "P_COMMAND",        0x80, 0xe0 }, 
 | 
    { "P_MESGOUT",        0xa0, 0xe0 }, 
 | 
    { "P_STATUS",        0xc0, 0xe0 }, 
 | 
    { "P_MESGIN",        0xe0, 0xe0 }, 
 | 
    { "P_BUSFREE",        0x01, 0x01 }, 
 | 
    { "MSGI",        0x20, 0x20 }, 
 | 
    { "IOI",        0x40, 0x40 }, 
 | 
    { "CDI",        0x80, 0x80 }, 
 | 
    { "PHASE_MASK",        0xe0, 0xe0 } 
 | 
}; 
 | 
  
 | 
int 
 | 
ahd_lastphase_print(u_int regvalue, u_int *cur_col, u_int wrap) 
 | 
{ 
 | 
    return (ahd_print_register(LASTPHASE_parse_table, 13, "LASTPHASE", 
 | 
        0x13c, regvalue, cur_col, wrap)); 
 | 
} 
 | 
  
 | 
static const ahd_reg_parse_entry_t SEQ_FLAGS2_parse_table[] = { 
 | 
    { "PENDING_MK_MESSAGE",    0x01, 0x01 }, 
 | 
    { "TARGET_MSG_PENDING",    0x02, 0x02 }, 
 | 
    { "SELECTOUT_QFROZEN",    0x04, 0x04 } 
 | 
}; 
 | 
  
 | 
int 
 | 
ahd_seq_flags2_print(u_int regvalue, u_int *cur_col, u_int wrap) 
 | 
{ 
 | 
    return (ahd_print_register(SEQ_FLAGS2_parse_table, 3, "SEQ_FLAGS2", 
 | 
        0x14d, regvalue, cur_col, wrap)); 
 | 
} 
 | 
  
 | 
int 
 | 
ahd_mk_message_scb_print(u_int regvalue, u_int *cur_col, u_int wrap) 
 | 
{ 
 | 
    return (ahd_print_register(NULL, 0, "MK_MESSAGE_SCB", 
 | 
        0x160, regvalue, cur_col, wrap)); 
 | 
} 
 | 
  
 | 
int 
 | 
ahd_mk_message_scsiid_print(u_int regvalue, u_int *cur_col, u_int wrap) 
 | 
{ 
 | 
    return (ahd_print_register(NULL, 0, "MK_MESSAGE_SCSIID", 
 | 
        0x162, regvalue, cur_col, wrap)); 
 | 
} 
 | 
  
 | 
int 
 | 
ahd_scb_base_print(u_int regvalue, u_int *cur_col, u_int wrap) 
 | 
{ 
 | 
    return (ahd_print_register(NULL, 0, "SCB_BASE", 
 | 
        0x180, regvalue, cur_col, wrap)); 
 | 
} 
 | 
  
 | 
static const ahd_reg_parse_entry_t SCB_CONTROL_parse_table[] = { 
 | 
    { "SCB_TAG_TYPE",    0x03, 0x03 }, 
 | 
    { "DISCONNECTED",    0x04, 0x04 }, 
 | 
    { "STATUS_RCVD",    0x08, 0x08 }, 
 | 
    { "MK_MESSAGE",        0x10, 0x10 }, 
 | 
    { "TAG_ENB",        0x20, 0x20 }, 
 | 
    { "DISCENB",        0x40, 0x40 }, 
 | 
    { "TARGET_SCB",        0x80, 0x80 } 
 | 
}; 
 | 
  
 | 
int 
 | 
ahd_scb_control_print(u_int regvalue, u_int *cur_col, u_int wrap) 
 | 
{ 
 | 
    return (ahd_print_register(SCB_CONTROL_parse_table, 7, "SCB_CONTROL", 
 | 
        0x192, regvalue, cur_col, wrap)); 
 | 
} 
 | 
  
 | 
static const ahd_reg_parse_entry_t SCB_SCSIID_parse_table[] = { 
 | 
    { "OID",        0x0f, 0x0f }, 
 | 
    { "TID",        0xf0, 0xf0 } 
 | 
}; 
 | 
  
 | 
int 
 | 
ahd_scb_scsiid_print(u_int regvalue, u_int *cur_col, u_int wrap) 
 | 
{ 
 | 
    return (ahd_print_register(SCB_SCSIID_parse_table, 2, "SCB_SCSIID", 
 | 
        0x193, regvalue, cur_col, wrap)); 
 | 
} 
 |