git.oblomov.eu Git - linux-2.6/blob - drivers/scsi/aic7xxx/aic79xx_reg_print.c_shipped

   1 /*
   2  * DO NOT EDIT - This file is automatically generated
   3  *               from the following source files:
   4  *
   5  * $Id: //depot/aic7xxx/aic7xxx/aic79xx.seq#120 $
   6  * $Id: //depot/aic7xxx/aic7xxx/aic79xx.reg#77 $
   7  */
   8
   9 #include "aic79xx_osm.h"
  10
  11 static const ahd_reg_parse_entry_t MODE_PTR_parse_table[] = {
  12         { "SRC_MODE",           0x07, 0x07 },
  13         { "DST_MODE",           0x70, 0x70 }
  14 };
  15
  16 int
  17 ahd_mode_ptr_print(u_int regvalue, u_int *cur_col, u_int wrap)
  18 {
  19         return (ahd_print_register(MODE_PTR_parse_table, 2, "MODE_PTR",
  20             0x00, regvalue, cur_col, wrap));
  21 }
  22
  23 static const ahd_reg_parse_entry_t INTSTAT_parse_table[] = {
  24         { "SPLTINT",            0x01, 0x01 },
  25         { "CMDCMPLT",           0x02, 0x02 },
  26         { "SEQINT",             0x04, 0x04 },
  27         { "SCSIINT",            0x08, 0x08 },
  28         { "PCIINT",             0x10, 0x10 },
  29         { "SWTMINT",            0x20, 0x20 },
  30         { "BRKADRINT",          0x40, 0x40 },
  31         { "HWERRINT",           0x80, 0x80 },
  32         { "INT_PEND",           0xff, 0xff }
  33 };
  34
  35 int
  36 ahd_intstat_print(u_int regvalue, u_int *cur_col, u_int wrap)
  37 {
  38         return (ahd_print_register(INTSTAT_parse_table, 9, "INTSTAT",
  39             0x01, regvalue, cur_col, wrap));
  40 }
  41
  42 static const ahd_reg_parse_entry_t SEQINTCODE_parse_table[] = {
  43         { "NO_SEQINT",          0x00, 0xff },
  44         { "BAD_PHASE",          0x01, 0xff },
  45         { "SEND_REJECT",        0x02, 0xff },
  46         { "PROTO_VIOLATION",    0x03, 0xff },
  47         { "NO_MATCH",           0x04, 0xff },
  48         { "IGN_WIDE_RES",       0x05, 0xff },
  49         { "PDATA_REINIT",       0x06, 0xff },
  50         { "HOST_MSG_LOOP",      0x07, 0xff },
  51         { "BAD_STATUS",         0x08, 0xff },
  52         { "DATA_OVERRUN",       0x09, 0xff },
  53         { "MKMSG_FAILED",       0x0a, 0xff },
  54         { "MISSED_BUSFREE",     0x0b, 0xff },
  55         { "DUMP_CARD_STATE",    0x0c, 0xff },
  56         { "ILLEGAL_PHASE",      0x0d, 0xff },
  57         { "INVALID_SEQINT",     0x0e, 0xff },
  58         { "CFG4ISTAT_INTR",     0x0f, 0xff },
  59         { "STATUS_OVERRUN",     0x10, 0xff },
  60         { "CFG4OVERRUN",        0x11, 0xff },
  61         { "ENTERING_NONPACK",   0x12, 0xff },
  62         { "TASKMGMT_FUNC_COMPLETE",0x13, 0xff },
  63         { "TASKMGMT_CMD_CMPLT_OKAY",0x14, 0xff },
  64         { "TRACEPOINT0",        0x15, 0xff },
  65         { "TRACEPOINT1",        0x16, 0xff },
  66         { "TRACEPOINT2",        0x17, 0xff },
  67         { "TRACEPOINT3",        0x18, 0xff },
  68         { "SAW_HWERR",          0x19, 0xff },
  69         { "BAD_SCB_STATUS",     0x1a, 0xff }
  70 };
  71
  72 int
  73 ahd_seqintcode_print(u_int regvalue, u_int *cur_col, u_int wrap)
  74 {
  75         return (ahd_print_register(SEQINTCODE_parse_table, 27, "SEQINTCODE",
  76             0x02, regvalue, cur_col, wrap));
  77 }
  78
  79 static const ahd_reg_parse_entry_t CLRINT_parse_table[] = {
  80         { "CLRSPLTINT",         0x01, 0x01 },
  81         { "CLRCMDINT",          0x02, 0x02 },
  82         { "CLRSEQINT",          0x04, 0x04 },
  83         { "CLRSCSIINT",         0x08, 0x08 },
  84         { "CLRPCIINT",          0x10, 0x10 },
  85         { "CLRSWTMINT",         0x20, 0x20 },
  86         { "CLRBRKADRINT",       0x40, 0x40 },
  87         { "CLRHWERRINT",        0x80, 0x80 }
  88 };
  89
  90 int
  91 ahd_clrint_print(u_int regvalue, u_int *cur_col, u_int wrap)
  92 {
  93         return (ahd_print_register(CLRINT_parse_table, 8, "CLRINT",
  94             0x03, regvalue, cur_col, wrap));
  95 }
  96
  97 static const ahd_reg_parse_entry_t ERROR_parse_table[] = {
  98         { "DSCTMOUT",           0x02, 0x02 },
  99         { "ILLOPCODE",          0x04, 0x04 },
 100         { "SQPARERR",           0x08, 0x08 },
 101         { "DPARERR",            0x10, 0x10 },
 102         { "MPARERR",            0x20, 0x20 },
 103         { "CIOACCESFAIL",       0x40, 0x40 },
 104         { "CIOPARERR",          0x80, 0x80 }
 105 };
 106
 107 int
 108 ahd_error_print(u_int regvalue, u_int *cur_col, u_int wrap)
 109 {
 110         return (ahd_print_register(ERROR_parse_table, 7, "ERROR",
 111             0x04, regvalue, cur_col, wrap));
 112 }
 113
 114 static const ahd_reg_parse_entry_t HCNTRL_parse_table[] = {
 115         { "CHIPRST",            0x01, 0x01 },
 116         { "CHIPRSTACK",         0x01, 0x01 },
 117         { "INTEN",              0x02, 0x02 },
 118         { "PAUSE",              0x04, 0x04 },
 119         { "SWTIMER_START_B",    0x08, 0x08 },
 120         { "SWINT",              0x10, 0x10 },
 121         { "POWRDN",             0x40, 0x40 },
 122         { "SEQ_RESET",          0x80, 0x80 }
 123 };
 124
 125 int
 126 ahd_hcntrl_print(u_int regvalue, u_int *cur_col, u_int wrap)
 127 {
 128         return (ahd_print_register(HCNTRL_parse_table, 8, "HCNTRL",
 129             0x05, regvalue, cur_col, wrap));
 130 }
 131
 132 int
 133 ahd_hnscb_qoff_print(u_int regvalue, u_int *cur_col, u_int wrap)
 134 {
 135         return (ahd_print_register(NULL, 0, "HNSCB_QOFF",
 136             0x06, regvalue, cur_col, wrap));
 137 }
 138
 139 int
 140 ahd_hescb_qoff_print(u_int regvalue, u_int *cur_col, u_int wrap)
 141 {
 142         return (ahd_print_register(NULL, 0, "HESCB_QOFF",
 143             0x08, regvalue, cur_col, wrap));
 144 }
 145
 146 static const ahd_reg_parse_entry_t HS_MAILBOX_parse_table[] = {
 147         { "ENINT_COALESCE",     0x40, 0x40 },
 148         { "HOST_TQINPOS",       0x80, 0x80 }
 149 };
 150
 151 int
 152 ahd_hs_mailbox_print(u_int regvalue, u_int *cur_col, u_int wrap)
 153 {
 154         return (ahd_print_register(HS_MAILBOX_parse_table, 2, "HS_MAILBOX",
 155             0x0b, regvalue, cur_col, wrap));
 156 }
 157
 158 static const ahd_reg_parse_entry_t SEQINTSTAT_parse_table[] = {
 159         { "SEQ_SPLTINT",        0x01, 0x01 },
 160         { "SEQ_PCIINT",         0x02, 0x02 },
 161         { "SEQ_SCSIINT",        0x04, 0x04 },
 162         { "SEQ_SEQINT",         0x08, 0x08 },
 163         { "SEQ_SWTMRTO",        0x10, 0x10 }
 164 };
 165
 166 int
 167 ahd_seqintstat_print(u_int regvalue, u_int *cur_col, u_int wrap)
 168 {
 169         return (ahd_print_register(SEQINTSTAT_parse_table, 5, "SEQINTSTAT",
 170             0x0c, regvalue, cur_col, wrap));
 171 }
 172
 173 static const ahd_reg_parse_entry_t CLRSEQINTSTAT_parse_table[] = {
 174         { "CLRSEQ_SPLTINT",     0x01, 0x01 },
 175         { "CLRSEQ_PCIINT",      0x02, 0x02 },
 176         { "CLRSEQ_SCSIINT",     0x04, 0x04 },
 177         { "CLRSEQ_SEQINT",      0x08, 0x08 },
 178         { "CLRSEQ_SWTMRTO",     0x10, 0x10 }
 179 };
 180
 181 int
 182 ahd_clrseqintstat_print(u_int regvalue, u_int *cur_col, u_int wrap)
 183 {
 184         return (ahd_print_register(CLRSEQINTSTAT_parse_table, 5, "CLRSEQINTSTAT",
 185             0x0c, regvalue, cur_col, wrap));
 186 }
 187
 188 int
 189 ahd_swtimer_print(u_int regvalue, u_int *cur_col, u_int wrap)
 190 {
 191         return (ahd_print_register(NULL, 0, "SWTIMER",
 192             0x0e, regvalue, cur_col, wrap));
 193 }
 194
 195 int
 196 ahd_snscb_qoff_print(u_int regvalue, u_int *cur_col, u_int wrap)
 197 {
 198         return (ahd_print_register(NULL, 0, "SNSCB_QOFF",
 199             0x10, regvalue, cur_col, wrap));
 200 }
 201
 202 int
 203 ahd_sescb_qoff_print(u_int regvalue, u_int *cur_col, u_int wrap)
 204 {
 205         return (ahd_print_register(NULL, 0, "SESCB_QOFF",
 206             0x12, regvalue, cur_col, wrap));
 207 }
 208
 209 int
 210 ahd_sdscb_qoff_print(u_int regvalue, u_int *cur_col, u_int wrap)
 211 {
 212         return (ahd_print_register(NULL, 0, "SDSCB_QOFF",
 213             0x14, regvalue, cur_col, wrap));
 214 }
 215
 216 static const ahd_reg_parse_entry_t QOFF_CTLSTA_parse_table[] = {
 217         { "SCB_QSIZE_4",        0x00, 0x0f },
 218         { "SCB_QSIZE_8",        0x01, 0x0f },
 219         { "SCB_QSIZE_16",       0x02, 0x0f },
 220         { "SCB_QSIZE_32",       0x03, 0x0f },
 221         { "SCB_QSIZE_64",       0x04, 0x0f },
 222         { "SCB_QSIZE_128",      0x05, 0x0f },
 223         { "SCB_QSIZE_256",      0x06, 0x0f },
 224         { "SCB_QSIZE_512",      0x07, 0x0f },
 225         { "SCB_QSIZE_1024",     0x08, 0x0f },
 226         { "SCB_QSIZE_2048",     0x09, 0x0f },
 227         { "SCB_QSIZE_4096",     0x0a, 0x0f },
 228         { "SCB_QSIZE_8192",     0x0b, 0x0f },
 229         { "SCB_QSIZE_16384",    0x0c, 0x0f },
 230         { "SCB_QSIZE",          0x0f, 0x0f },
 231         { "HS_MAILBOX_ACT",     0x10, 0x10 },
 232         { "SDSCB_ROLLOVR",      0x20, 0x20 },
 233         { "NEW_SCB_AVAIL",      0x40, 0x40 },
 234         { "EMPTY_SCB_AVAIL",    0x80, 0x80 }
 235 };
 236
 237 int
 238 ahd_qoff_ctlsta_print(u_int regvalue, u_int *cur_col, u_int wrap)
 239 {
 240         return (ahd_print_register(QOFF_CTLSTA_parse_table, 18, "QOFF_CTLSTA",
 241             0x16, regvalue, cur_col, wrap));
 242 }
 243
 244 static const ahd_reg_parse_entry_t INTCTL_parse_table[] = {
 245         { "SPLTINTEN",          0x01, 0x01 },
 246         { "SEQINTEN",           0x02, 0x02 },
 247         { "SCSIINTEN",          0x04, 0x04 },
 248         { "PCIINTEN",           0x08, 0x08 },
 249         { "AUTOCLRCMDINT",      0x10, 0x10 },
 250         { "SWTIMER_START",      0x20, 0x20 },
 251         { "SWTMINTEN",          0x40, 0x40 },
 252         { "SWTMINTMASK",        0x80, 0x80 }
 253 };
 254
 255 int
 256 ahd_intctl_print(u_int regvalue, u_int *cur_col, u_int wrap)
 257 {
 258         return (ahd_print_register(INTCTL_parse_table, 8, "INTCTL",
 259             0x18, regvalue, cur_col, wrap));
 260 }
 261
 262 static const ahd_reg_parse_entry_t DFCNTRL_parse_table[] = {
 263         { "DIRECTIONEN",        0x01, 0x01 },
 264         { "FIFOFLUSH",          0x02, 0x02 },
 265         { "FIFOFLUSHACK",       0x02, 0x02 },
 266         { "DIRECTION",          0x04, 0x04 },
 267         { "DIRECTIONACK",       0x04, 0x04 },
 268         { "HDMAEN",             0x08, 0x08 },
 269         { "HDMAENACK",          0x08, 0x08 },
 270         { "SCSIEN",             0x20, 0x20 },
 271         { "SCSIENACK",          0x20, 0x20 },
 272         { "SCSIENWRDIS",        0x40, 0x40 },
 273         { "PRELOADEN",          0x80, 0x80 }
 274 };
 275
 276 int
 277 ahd_dfcntrl_print(u_int regvalue, u_int *cur_col, u_int wrap)
 278 {
 279         return (ahd_print_register(DFCNTRL_parse_table, 11, "DFCNTRL",
 280             0x19, regvalue, cur_col, wrap));
 281 }
 282
 283 static const ahd_reg_parse_entry_t DSCOMMAND0_parse_table[] = {
 284         { "CIOPARCKEN",         0x01, 0x01 },
 285         { "DISABLE_TWATE",      0x02, 0x02 },
 286         { "EXTREQLCK",          0x10, 0x10 },
 287         { "MPARCKEN",           0x20, 0x20 },
 288         { "DPARCKEN",           0x40, 0x40 },
 289         { "CACHETHEN",          0x80, 0x80 }
 290 };
 291
 292 int
 293 ahd_dscommand0_print(u_int regvalue, u_int *cur_col, u_int wrap)
 294 {
 295         return (ahd_print_register(DSCOMMAND0_parse_table, 6, "DSCOMMAND0",
 296             0x19, regvalue, cur_col, wrap));
 297 }
 298
 299 static const ahd_reg_parse_entry_t DFSTATUS_parse_table[] = {
 300         { "FIFOEMP",            0x01, 0x01 },
 301         { "FIFOFULL",           0x02, 0x02 },
 302         { "DFTHRESH",           0x04, 0x04 },
 303         { "HDONE",              0x08, 0x08 },
 304         { "MREQPEND",           0x10, 0x10 },
 305         { "PKT_PRELOAD_AVAIL",  0x40, 0x40 },
 306         { "PRELOAD_AVAIL",      0x80, 0x80 }
 307 };
 308
 309 int
 310 ahd_dfstatus_print(u_int regvalue, u_int *cur_col, u_int wrap)
 311 {
 312         return (ahd_print_register(DFSTATUS_parse_table, 7, "DFSTATUS",
 313             0x1a, regvalue, cur_col, wrap));
 314 }
 315
 316 static const ahd_reg_parse_entry_t SG_CACHE_SHADOW_parse_table[] = {
 317         { "LAST_SEG_DONE",      0x01, 0x01 },
 318         { "LAST_SEG",           0x02, 0x02 },
 319         { "ODD_SEG",            0x04, 0x04 },
 320         { "SG_ADDR_MASK",       0xf8, 0xf8 }
 321 };
 322
 323 int
 324 ahd_sg_cache_shadow_print(u_int regvalue, u_int *cur_col, u_int wrap)
 325 {
 326         return (ahd_print_register(SG_CACHE_SHADOW_parse_table, 4, "SG_CACHE_SHADOW",
 327             0x1b, regvalue, cur_col, wrap));
 328 }
 329
 330 static const ahd_reg_parse_entry_t SG_CACHE_PRE_parse_table[] = {
 331         { "LAST_SEG",           0x02, 0x02 },
 332         { "ODD_SEG",            0x04, 0x04 },
 333         { "SG_ADDR_MASK",       0xf8, 0xf8 }
 334 };
 335
 336 int
 337 ahd_sg_cache_pre_print(u_int regvalue, u_int *cur_col, u_int wrap)
 338 {
 339         return (ahd_print_register(SG_CACHE_PRE_parse_table, 3, "SG_CACHE_PRE",
 340             0x1b, regvalue, cur_col, wrap));
 341 }
 342
 343 int
 344 ahd_lqin_print(u_int regvalue, u_int *cur_col, u_int wrap)
 345 {
 346         return (ahd_print_register(NULL, 0, "LQIN",
 347             0x20, regvalue, cur_col, wrap));
 348 }
 349
 350 int
 351 ahd_lunptr_print(u_int regvalue, u_int *cur_col, u_int wrap)
 352 {
 353         return (ahd_print_register(NULL, 0, "LUNPTR",
 354             0x22, regvalue, cur_col, wrap));
 355 }
 356
 357 int
 358 ahd_cmdlenptr_print(u_int regvalue, u_int *cur_col, u_int wrap)
 359 {
 360         return (ahd_print_register(NULL, 0, "CMDLENPTR",
 361             0x25, regvalue, cur_col, wrap));
 362 }
 363
 364 int
 365 ahd_attrptr_print(u_int regvalue, u_int *cur_col, u_int wrap)
 366 {
 367         return (ahd_print_register(NULL, 0, "ATTRPTR",
 368             0x26, regvalue, cur_col, wrap));
 369 }
 370
 371 int
 372 ahd_flagptr_print(u_int regvalue, u_int *cur_col, u_int wrap)
 373 {
 374         return (ahd_print_register(NULL, 0, "FLAGPTR",
 375             0x27, regvalue, cur_col, wrap));
 376 }
 377
 378 int
 379 ahd_cmdptr_print(u_int regvalue, u_int *cur_col, u_int wrap)
 380 {
 381         return (ahd_print_register(NULL, 0, "CMDPTR",
 382             0x28, regvalue, cur_col, wrap));
 383 }
 384
 385 int
 386 ahd_qnextptr_print(u_int regvalue, u_int *cur_col, u_int wrap)
 387 {
 388         return (ahd_print_register(NULL, 0, "QNEXTPTR",
 389             0x29, regvalue, cur_col, wrap));
 390 }
 391
 392 int
 393 ahd_abrtbyteptr_print(u_int regvalue, u_int *cur_col, u_int wrap)
 394 {
 395         return (ahd_print_register(NULL, 0, "ABRTBYTEPTR",
 396             0x2b, regvalue, cur_col, wrap));
 397 }
 398
 399 int
 400 ahd_abrtbitptr_print(u_int regvalue, u_int *cur_col, u_int wrap)
 401 {
 402         return (ahd_print_register(NULL, 0, "ABRTBITPTR",
 403             0x2c, regvalue, cur_col, wrap));
 404 }
 405
 406 static const ahd_reg_parse_entry_t LUNLEN_parse_table[] = {
 407         { "ILUNLEN",            0x0f, 0x0f },
 408         { "TLUNLEN",            0xf0, 0xf0 }
 409 };
 410
 411 int
 412 ahd_lunlen_print(u_int regvalue, u_int *cur_col, u_int wrap)
 413 {
 414         return (ahd_print_register(LUNLEN_parse_table, 2, "LUNLEN",
 415             0x30, regvalue, cur_col, wrap));
 416 }
 417
 418 int
 419 ahd_cdblimit_print(u_int regvalue, u_int *cur_col, u_int wrap)
 420 {
 421         return (ahd_print_register(NULL, 0, "CDBLIMIT",
 422             0x31, regvalue, cur_col, wrap));
 423 }
 424
 425 int
 426 ahd_maxcmd_print(u_int regvalue, u_int *cur_col, u_int wrap)
 427 {
 428         return (ahd_print_register(NULL, 0, "MAXCMD",
 429             0x32, regvalue, cur_col, wrap));
 430 }
 431
 432 int
 433 ahd_maxcmdcnt_print(u_int regvalue, u_int *cur_col, u_int wrap)
 434 {
 435         return (ahd_print_register(NULL, 0, "MAXCMDCNT",
 436             0x33, regvalue, cur_col, wrap));
 437 }
 438
 439 static const ahd_reg_parse_entry_t LQCTL1_parse_table[] = {
 440         { "ABORTPENDING",       0x01, 0x01 },
 441         { "SINGLECMD",          0x02, 0x02 },
 442         { "PCI2PCI",            0x04, 0x04 }
 443 };
 444
 445 int
 446 ahd_lqctl1_print(u_int regvalue, u_int *cur_col, u_int wrap)
 447 {
 448         return (ahd_print_register(LQCTL1_parse_table, 3, "LQCTL1",
 449             0x38, regvalue, cur_col, wrap));
 450 }
 451
 452 static const ahd_reg_parse_entry_t LQCTL2_parse_table[] = {
 453         { "LQOPAUSE",           0x01, 0x01 },
 454         { "LQOTOIDLE",          0x02, 0x02 },
 455         { "LQOCONTINUE",        0x04, 0x04 },
 456         { "LQORETRY",           0x08, 0x08 },
 457         { "LQIPAUSE",           0x10, 0x10 },
 458         { "LQITOIDLE",          0x20, 0x20 },
 459         { "LQICONTINUE",        0x40, 0x40 },
 460         { "LQIRETRY",           0x80, 0x80 }
 461 };
 462
 463 int
 464 ahd_lqctl2_print(u_int regvalue, u_int *cur_col, u_int wrap)
 465 {
 466         return (ahd_print_register(LQCTL2_parse_table, 8, "LQCTL2",
 467             0x39, regvalue, cur_col, wrap));
 468 }
 469
 470 static const ahd_reg_parse_entry_t SCSISEQ0_parse_table[] = {
 471         { "SCSIRSTO",           0x01, 0x01 },
 472         { "FORCEBUSFREE",       0x10, 0x10 },
 473         { "ENARBO",             0x20, 0x20 },
 474         { "ENSELO",             0x40, 0x40 },
 475         { "TEMODEO",            0x80, 0x80 }
 476 };
 477
 478 int
 479 ahd_scsiseq0_print(u_int regvalue, u_int *cur_col, u_int wrap)
 480 {
 481         return (ahd_print_register(SCSISEQ0_parse_table, 5, "SCSISEQ0",
 482             0x3a, regvalue, cur_col, wrap));
 483 }
 484
 485 static const ahd_reg_parse_entry_t SCSISEQ1_parse_table[] = {
 486         { "ALTSTIM",            0x01, 0x01 },
 487         { "ENAUTOATNP",         0x02, 0x02 },
 488         { "MANUALP",            0x0c, 0x0c },
 489         { "ENRSELI",            0x10, 0x10 },
 490         { "ENSELI",             0x20, 0x20 },
 491         { "MANUALCTL",          0x40, 0x40 }
 492 };
 493
 494 int
 495 ahd_scsiseq1_print(u_int regvalue, u_int *cur_col, u_int wrap)
 496 {
 497         return (ahd_print_register(SCSISEQ1_parse_table, 6, "SCSISEQ1",
 498             0x3b, regvalue, cur_col, wrap));
 499 }
 500
 501 static const ahd_reg_parse_entry_t SXFRCTL0_parse_table[] = {
 502         { "SPIOEN",             0x08, 0x08 },
 503         { "BIOSCANCELEN",       0x10, 0x10 },
 504         { "DFPEXP",             0x40, 0x40 },
 505         { "DFON",               0x80, 0x80 }
 506 };
 507
 508 int
 509 ahd_sxfrctl0_print(u_int regvalue, u_int *cur_col, u_int wrap)
 510 {
 511         return (ahd_print_register(SXFRCTL0_parse_table, 4, "SXFRCTL0",
 512             0x3c, regvalue, cur_col, wrap));
 513 }
 514
 515 static const ahd_reg_parse_entry_t SXFRCTL1_parse_table[] = {
 516         { "STPWEN",             0x01, 0x01 },
 517         { "ACTNEGEN",           0x02, 0x02 },
 518         { "ENSTIMER",           0x04, 0x04 },
 519         { "STIMESEL",           0x18, 0x18 },
 520         { "ENSPCHK",            0x20, 0x20 },
 521         { "ENSACHK",            0x40, 0x40 },
 522         { "BITBUCKET",          0x80, 0x80 }
 523 };
 524
 525 int
 526 ahd_sxfrctl1_print(u_int regvalue, u_int *cur_col, u_int wrap)
 527 {
 528         return (ahd_print_register(SXFRCTL1_parse_table, 7, "SXFRCTL1",
 529             0x3d, regvalue, cur_col, wrap));
 530 }
 531
 532 static const ahd_reg_parse_entry_t DFFSTAT_parse_table[] = {
 533         { "CURRFIFO_0",         0x00, 0x03 },
 534         { "CURRFIFO_1",         0x01, 0x03 },
 535         { "CURRFIFO_NONE",      0x03, 0x03 },
 536         { "FIFO0FREE",          0x10, 0x10 },
 537         { "FIFO1FREE",          0x20, 0x20 },
 538         { "CURRFIFO",           0x03, 0x03 }
 539 };
 540
 541 int
 542 ahd_dffstat_print(u_int regvalue, u_int *cur_col, u_int wrap)
 543 {
 544         return (ahd_print_register(DFFSTAT_parse_table, 6, "DFFSTAT",
 545             0x3f, regvalue, cur_col, wrap));
 546 }
 547
 548 int
 549 ahd_multargid_print(u_int regvalue, u_int *cur_col, u_int wrap)
 550 {
 551         return (ahd_print_register(NULL, 0, "MULTARGID",
 552             0x40, regvalue, cur_col, wrap));
 553 }
 554
 555 static const ahd_reg_parse_entry_t SCSISIGO_parse_table[] = {
 556         { "P_DATAOUT",          0x00, 0xe0 },
 557         { "P_DATAOUT_DT",       0x20, 0xe0 },
 558         { "P_DATAIN",           0x40, 0xe0 },
 559         { "P_DATAIN_DT",        0x60, 0xe0 },
 560         { "P_COMMAND",          0x80, 0xe0 },
 561         { "P_MESGOUT",          0xa0, 0xe0 },
 562         { "P_STATUS",           0xc0, 0xe0 },
 563         { "P_MESGIN",           0xe0, 0xe0 },
 564         { "ACKO",               0x01, 0x01 },
 565         { "REQO",               0x02, 0x02 },
 566         { "BSYO",               0x04, 0x04 },
 567         { "SELO",               0x08, 0x08 },
 568         { "ATNO",               0x10, 0x10 },
 569         { "MSGO",               0x20, 0x20 },
 570         { "IOO",                0x40, 0x40 },
 571         { "CDO",                0x80, 0x80 },
 572         { "PHASE_MASK",         0xe0, 0xe0 }
 573 };
 574
 575 int
 576 ahd_scsisigo_print(u_int regvalue, u_int *cur_col, u_int wrap)
 577 {
 578         return (ahd_print_register(SCSISIGO_parse_table, 17, "SCSISIGO",
 579             0x40, regvalue, cur_col, wrap));
 580 }
 581
 582 static const ahd_reg_parse_entry_t SCSISIGI_parse_table[] = {
 583         { "P_DATAOUT",          0x00, 0xe0 },
 584         { "P_DATAOUT_DT",       0x20, 0xe0 },
 585         { "P_DATAIN",           0x40, 0xe0 },
 586         { "P_DATAIN_DT",        0x60, 0xe0 },
 587         { "P_COMMAND",          0x80, 0xe0 },
 588         { "P_MESGOUT",          0xa0, 0xe0 },
 589         { "P_STATUS",           0xc0, 0xe0 },
 590         { "P_MESGIN",           0xe0, 0xe0 },
 591         { "ACKI",               0x01, 0x01 },
 592         { "REQI",               0x02, 0x02 },
 593         { "BSYI",               0x04, 0x04 },
 594         { "SELI",               0x08, 0x08 },
 595         { "ATNI",               0x10, 0x10 },
 596         { "MSGI",               0x20, 0x20 },
 597         { "IOI",                0x40, 0x40 },
 598         { "CDI",                0x80, 0x80 },
 599         { "PHASE_MASK",         0xe0, 0xe0 }
 600 };
 601
 602 int
 603 ahd_scsisigi_print(u_int regvalue, u_int *cur_col, u_int wrap)
 604 {
 605         return (ahd_print_register(SCSISIGI_parse_table, 17, "SCSISIGI",
 606             0x41, regvalue, cur_col, wrap));
 607 }
 608
 609 static const ahd_reg_parse_entry_t SCSIPHASE_parse_table[] = {
 610         { "DATA_OUT_PHASE",     0x01, 0x03 },
 611         { "DATA_IN_PHASE",      0x02, 0x03 },
 612         { "DATA_PHASE_MASK",    0x03, 0x03 },
 613         { "MSG_OUT_PHASE",      0x04, 0x04 },
 614         { "MSG_IN_PHASE",       0x08, 0x08 },
 615         { "COMMAND_PHASE",      0x10, 0x10 },
 616         { "STATUS_PHASE",       0x20, 0x20 }
 617 };
 618
 619 int
 620 ahd_scsiphase_print(u_int regvalue, u_int *cur_col, u_int wrap)
 621 {
 622         return (ahd_print_register(SCSIPHASE_parse_table, 7, "SCSIPHASE",
 623             0x42, regvalue, cur_col, wrap));
 624 }
 625
 626 int
 627 ahd_scsidat_print(u_int regvalue, u_int *cur_col, u_int wrap)
 628 {
 629         return (ahd_print_register(NULL, 0, "SCSIDAT",
 630             0x44, regvalue, cur_col, wrap));
 631 }
 632
 633 int
 634 ahd_scsibus_print(u_int regvalue, u_int *cur_col, u_int wrap)
 635 {
 636         return (ahd_print_register(NULL, 0, "SCSIBUS",
 637             0x46, regvalue, cur_col, wrap));
 638 }
 639
 640 static const ahd_reg_parse_entry_t TARGIDIN_parse_table[] = {
 641         { "TARGID",             0x0f, 0x0f },
 642         { "CLKOUT",             0x80, 0x80 }
 643 };
 644
 645 int
 646 ahd_targidin_print(u_int regvalue, u_int *cur_col, u_int wrap)
 647 {
 648         return (ahd_print_register(TARGIDIN_parse_table, 2, "TARGIDIN",
 649             0x48, regvalue, cur_col, wrap));
 650 }
 651
 652 static const ahd_reg_parse_entry_t SELID_parse_table[] = {
 653         { "ONEBIT",             0x08, 0x08 },
 654         { "SELID_MASK",         0xf0, 0xf0 }
 655 };
 656
 657 int
 658 ahd_selid_print(u_int regvalue, u_int *cur_col, u_int wrap)
 659 {
 660         return (ahd_print_register(SELID_parse_table, 2, "SELID",
 661             0x49, regvalue, cur_col, wrap));
 662 }
 663
 664 static const ahd_reg_parse_entry_t OPTIONMODE_parse_table[] = {
 665         { "AUTO_MSGOUT_DE",     0x02, 0x02 },
 666         { "ENDGFORMCHK",        0x04, 0x04 },
 667         { "BUSFREEREV",         0x10, 0x10 },
 668         { "BIASCANCTL",         0x20, 0x20 },
 669         { "AUTOACKEN",          0x40, 0x40 },
 670         { "BIOSCANCTL",         0x80, 0x80 },
 671         { "OPTIONMODE_DEFAULTS",0x02, 0x02 }
 672 };
 673
 674 int
 675 ahd_optionmode_print(u_int regvalue, u_int *cur_col, u_int wrap)
 676 {
 677         return (ahd_print_register(OPTIONMODE_parse_table, 7, "OPTIONMODE",
 678             0x4a, regvalue, cur_col, wrap));
 679 }
 680
 681 static const ahd_reg_parse_entry_t SBLKCTL_parse_table[] = {
 682         { "SELWIDE",            0x02, 0x02 },
 683         { "ENAB20",             0x04, 0x04 },
 684         { "ENAB40",             0x08, 0x08 },
 685         { "DIAGLEDON",          0x40, 0x40 },
 686         { "DIAGLEDEN",          0x80, 0x80 }
 687 };
 688
 689 int
 690 ahd_sblkctl_print(u_int regvalue, u_int *cur_col, u_int wrap)
 691 {
 692         return (ahd_print_register(SBLKCTL_parse_table, 5, "SBLKCTL",
 693             0x4a, regvalue, cur_col, wrap));
 694 }
 695
 696 static const ahd_reg_parse_entry_t SSTAT0_parse_table[] = {
 697         { "ARBDO",              0x01, 0x01 },
 698         { "SPIORDY",            0x02, 0x02 },
 699         { "OVERRUN",            0x04, 0x04 },
 700         { "IOERR",              0x08, 0x08 },
 701         { "SELINGO",            0x10, 0x10 },
 702         { "SELDI",              0x20, 0x20 },
 703         { "SELDO",              0x40, 0x40 },
 704         { "TARGET",             0x80, 0x80 }
 705 };
 706
 707 int
 708 ahd_sstat0_print(u_int regvalue, u_int *cur_col, u_int wrap)
 709 {
 710         return (ahd_print_register(SSTAT0_parse_table, 8, "SSTAT0",
 711             0x4b, regvalue, cur_col, wrap));
 712 }
 713
 714 static const ahd_reg_parse_entry_t SIMODE0_parse_table[] = {
 715         { "ENARBDO",            0x01, 0x01 },
 716         { "ENSPIORDY",          0x02, 0x02 },
 717         { "ENOVERRUN",          0x04, 0x04 },
 718         { "ENIOERR",            0x08, 0x08 },
 719         { "ENSELINGO",          0x10, 0x10 },
 720         { "ENSELDI",            0x20, 0x20 },
 721         { "ENSELDO",            0x40, 0x40 }
 722 };
 723
 724 int
 725 ahd_simode0_print(u_int regvalue, u_int *cur_col, u_int wrap)
 726 {
 727         return (ahd_print_register(SIMODE0_parse_table, 7, "SIMODE0",
 728             0x4b, regvalue, cur_col, wrap));
 729 }
 730
 731 static const ahd_reg_parse_entry_t CLRSINT0_parse_table[] = {
 732         { "CLRARBDO",           0x01, 0x01 },
 733         { "CLRSPIORDY",         0x02, 0x02 },
 734         { "CLROVERRUN",         0x04, 0x04 },
 735         { "CLRIOERR",           0x08, 0x08 },
 736         { "CLRSELINGO",         0x10, 0x10 },
 737         { "CLRSELDI",           0x20, 0x20 },
 738         { "CLRSELDO",           0x40, 0x40 }
 739 };
 740
 741 int
 742 ahd_clrsint0_print(u_int regvalue, u_int *cur_col, u_int wrap)
 743 {
 744         return (ahd_print_register(CLRSINT0_parse_table, 7, "CLRSINT0",
 745             0x4b, regvalue, cur_col, wrap));
 746 }
 747
 748 static const ahd_reg_parse_entry_t SSTAT1_parse_table[] = {
 749         { "REQINIT",            0x01, 0x01 },
 750         { "STRB2FAST",          0x02, 0x02 },
 751         { "SCSIPERR",           0x04, 0x04 },
 752         { "BUSFREE",            0x08, 0x08 },
 753         { "PHASEMIS",           0x10, 0x10 },
 754         { "SCSIRSTI",           0x20, 0x20 },
 755         { "ATNTARG",            0x40, 0x40 },
 756         { "SELTO",              0x80, 0x80 }
 757 };
 758
 759 int
 760 ahd_sstat1_print(u_int regvalue, u_int *cur_col, u_int wrap)
 761 {
 762         return (ahd_print_register(SSTAT1_parse_table, 8, "SSTAT1",
 763             0x4c, regvalue, cur_col, wrap));
 764 }
 765
 766 static const ahd_reg_parse_entry_t CLRSINT1_parse_table[] = {
 767         { "CLRREQINIT",         0x01, 0x01 },
 768         { "CLRSTRB2FAST",       0x02, 0x02 },
 769         { "CLRSCSIPERR",        0x04, 0x04 },
 770         { "CLRBUSFREE",         0x08, 0x08 },
 771         { "CLRSCSIRSTI",        0x20, 0x20 },
 772         { "CLRATNO",            0x40, 0x40 },
 773         { "CLRSELTIMEO",        0x80, 0x80 }
 774 };
 775
 776 int
 777 ahd_clrsint1_print(u_int regvalue, u_int *cur_col, u_int wrap)
 778 {
 779         return (ahd_print_register(CLRSINT1_parse_table, 7, "CLRSINT1",
 780             0x4c, regvalue, cur_col, wrap));
 781 }
 782
 783 static const ahd_reg_parse_entry_t SSTAT2_parse_table[] = {
 784         { "BUSFREE_LQO",        0x40, 0xc0 },
 785         { "BUSFREE_DFF0",       0x80, 0xc0 },
 786         { "BUSFREE_DFF1",       0xc0, 0xc0 },
 787         { "DMADONE",            0x01, 0x01 },
 788         { "SDONE",              0x02, 0x02 },
 789         { "WIDE_RES",           0x04, 0x04 },
 790         { "BSYX",               0x08, 0x08 },
 791         { "EXP_ACTIVE",         0x10, 0x10 },
 792         { "NONPACKREQ",         0x20, 0x20 },
 793         { "BUSFREETIME",        0xc0, 0xc0 }
 794 };
 795
 796 int
 797 ahd_sstat2_print(u_int regvalue, u_int *cur_col, u_int wrap)
 798 {
 799         return (ahd_print_register(SSTAT2_parse_table, 10, "SSTAT2",
 800             0x4d, regvalue, cur_col, wrap));
 801 }
 802
 803 static const ahd_reg_parse_entry_t CLRSINT2_parse_table[] = {
 804         { "CLRDMADONE",         0x01, 0x01 },
 805         { "CLRSDONE",           0x02, 0x02 },
 806         { "CLRWIDE_RES",        0x04, 0x04 },
 807         { "CLRNONPACKREQ",      0x20, 0x20 }
 808 };
 809
 810 int
 811 ahd_clrsint2_print(u_int regvalue, u_int *cur_col, u_int wrap)
 812 {
 813         return (ahd_print_register(CLRSINT2_parse_table, 4, "CLRSINT2",
 814             0x4d, regvalue, cur_col, wrap));
 815 }
 816
 817 static const ahd_reg_parse_entry_t PERRDIAG_parse_table[] = {
 818         { "DTERR",              0x01, 0x01 },
 819         { "DGFORMERR",          0x02, 0x02 },
 820         { "CRCERR",             0x04, 0x04 },
 821         { "AIPERR",             0x08, 0x08 },
 822         { "PARITYERR",          0x10, 0x10 },
 823         { "PREVPHASE",          0x20, 0x20 },
 824         { "HIPERR",             0x40, 0x40 },
 825         { "HIZERO",             0x80, 0x80 }
 826 };
 827
 828 int
 829 ahd_perrdiag_print(u_int regvalue, u_int *cur_col, u_int wrap)
 830 {
 831         return (ahd_print_register(PERRDIAG_parse_table, 8, "PERRDIAG",
 832             0x4e, regvalue, cur_col, wrap));
 833 }
 834
 835 int
 836 ahd_lqistate_print(u_int regvalue, u_int *cur_col, u_int wrap)
 837 {
 838         return (ahd_print_register(NULL, 0, "LQISTATE",
 839             0x4e, regvalue, cur_col, wrap));
 840 }
 841
 842 int
 843 ahd_soffcnt_print(u_int regvalue, u_int *cur_col, u_int wrap)
 844 {
 845         return (ahd_print_register(NULL, 0, "SOFFCNT",
 846             0x4f, regvalue, cur_col, wrap));
 847 }
 848
 849 int
 850 ahd_lqostate_print(u_int regvalue, u_int *cur_col, u_int wrap)
 851 {
 852         return (ahd_print_register(NULL, 0, "LQOSTATE",
 853             0x4f, regvalue, cur_col, wrap));
 854 }
 855
 856 static const ahd_reg_parse_entry_t LQISTAT0_parse_table[] = {
 857         { "LQIATNCMD",          0x01, 0x01 },
 858         { "LQIATNLQ",           0x02, 0x02 },
 859         { "LQIBADLQT",          0x04, 0x04 },
 860         { "LQICRCT2",           0x08, 0x08 },
 861         { "LQICRCT1",           0x10, 0x10 },
 862         { "LQIATNQAS",          0x20, 0x20 }
 863 };
 864
 865 int
 866 ahd_lqistat0_print(u_int regvalue, u_int *cur_col, u_int wrap)
 867 {
 868         return (ahd_print_register(LQISTAT0_parse_table, 6, "LQISTAT0",
 869             0x50, regvalue, cur_col, wrap));
 870 }
 871
 872 static const ahd_reg_parse_entry_t LQIMODE0_parse_table[] = {
 873         { "ENLQIATNCMD",        0x01, 0x01 },
 874         { "ENLQIATNLQ",         0x02, 0x02 },
 875         { "ENLQIBADLQT",        0x04, 0x04 },
 876         { "ENLQICRCT2",         0x08, 0x08 },
 877         { "ENLQICRCT1",         0x10, 0x10 },
 878         { "ENLQIATNQASK",       0x20, 0x20 }
 879 };
 880
 881 int
 882 ahd_lqimode0_print(u_int regvalue, u_int *cur_col, u_int wrap)
 883 {
 884         return (ahd_print_register(LQIMODE0_parse_table, 6, "LQIMODE0",
 885             0x50, regvalue, cur_col, wrap));
 886 }
 887
 888 static const ahd_reg_parse_entry_t CLRLQIINT0_parse_table[] = {
 889         { "CLRLQIATNCMD",       0x01, 0x01 },
 890         { "CLRLQIATNLQ",        0x02, 0x02 },
 891         { "CLRLQIBADLQT",       0x04, 0x04 },
 892         { "CLRLQICRCT2",        0x08, 0x08 },
 893         { "CLRLQICRCT1",        0x10, 0x10 },
 894         { "CLRLQIATNQAS",       0x20, 0x20 }
 895 };
 896
 897 int
 898 ahd_clrlqiint0_print(u_int regvalue, u_int *cur_col, u_int wrap)
 899 {
 900         return (ahd_print_register(CLRLQIINT0_parse_table, 6, "CLRLQIINT0",
 901             0x50, regvalue, cur_col, wrap));
 902 }
 903
 904 static const ahd_reg_parse_entry_t LQIMODE1_parse_table[] = {
 905         { "ENLQIOVERI_NLQ",     0x01, 0x01 },
 906         { "ENLQIOVERI_LQ",      0x02, 0x02 },
 907         { "ENLQIBADLQI",        0x04, 0x04 },
 908         { "ENLQICRCI_NLQ",      0x08, 0x08 },
 909         { "ENLQICRCI_LQ",       0x10, 0x10 },
 910         { "ENLIQABORT",         0x20, 0x20 },
 911         { "ENLQIPHASE_NLQ",     0x40, 0x40 },
 912         { "ENLQIPHASE_LQ",      0x80, 0x80 }
 913 };
 914
 915 int
 916 ahd_lqimode1_print(u_int regvalue, u_int *cur_col, u_int wrap)
 917 {
 918         return (ahd_print_register(LQIMODE1_parse_table, 8, "LQIMODE1",
 919             0x51, regvalue, cur_col, wrap));
 920 }
 921
 922 static const ahd_reg_parse_entry_t LQISTAT1_parse_table[] = {
 923         { "LQIOVERI_NLQ",       0x01, 0x01 },
 924         { "LQIOVERI_LQ",        0x02, 0x02 },
 925         { "LQIBADLQI",          0x04, 0x04 },
 926         { "LQICRCI_NLQ",        0x08, 0x08 },
 927         { "LQICRCI_LQ",         0x10, 0x10 },
 928         { "LQIABORT",           0x20, 0x20 },
 929         { "LQIPHASE_NLQ",       0x40, 0x40 },
 930         { "LQIPHASE_LQ",        0x80, 0x80 }
 931 };
 932
 933 int
 934 ahd_lqistat1_print(u_int regvalue, u_int *cur_col, u_int wrap)
 935 {
 936         return (ahd_print_register(LQISTAT1_parse_table, 8, "LQISTAT1",
 937             0x51, regvalue, cur_col, wrap));
 938 }
 939
 940 static const ahd_reg_parse_entry_t CLRLQIINT1_parse_table[] = {
 941         { "CLRLQIOVERI_NLQ",    0x01, 0x01 },
 942         { "CLRLQIOVERI_LQ",     0x02, 0x02 },
 943         { "CLRLQIBADLQI",       0x04, 0x04 },
 944         { "CLRLQICRCI_NLQ",     0x08, 0x08 },
 945         { "CLRLQICRCI_LQ",      0x10, 0x10 },
 946         { "CLRLIQABORT",        0x20, 0x20 },
 947         { "CLRLQIPHASE_NLQ",    0x40, 0x40 },
 948         { "CLRLQIPHASE_LQ",     0x80, 0x80 }
 949 };
 950
 951 int
 952 ahd_clrlqiint1_print(u_int regvalue, u_int *cur_col, u_int wrap)
 953 {
 954         return (ahd_print_register(CLRLQIINT1_parse_table, 8, "CLRLQIINT1",
 955             0x51, regvalue, cur_col, wrap));
 956 }
 957
 958 static const ahd_reg_parse_entry_t LQISTAT2_parse_table[] = {
 959         { "LQIGSAVAIL",         0x01, 0x01 },
 960         { "LQISTOPCMD",         0x02, 0x02 },
 961         { "LQISTOPLQ",          0x04, 0x04 },
 962         { "LQISTOPPKT",         0x08, 0x08 },
 963         { "LQIWAITFIFO",        0x10, 0x10 },
 964         { "LQIWORKONLQ",        0x20, 0x20 },
 965         { "LQIPHASE_OUTPKT",    0x40, 0x40 },
 966         { "PACKETIZED",         0x80, 0x80 }
 967 };
 968
 969 int
 970 ahd_lqistat2_print(u_int regvalue, u_int *cur_col, u_int wrap)
 971 {
 972         return (ahd_print_register(LQISTAT2_parse_table, 8, "LQISTAT2",
 973             0x52, regvalue, cur_col, wrap));
 974 }
 975
 976 static const ahd_reg_parse_entry_t SSTAT3_parse_table[] = {
 977         { "OSRAMPERR",          0x01, 0x01 },
 978         { "NTRAMPERR",          0x02, 0x02 }
 979 };
 980
 981 int
 982 ahd_sstat3_print(u_int regvalue, u_int *cur_col, u_int wrap)
 983 {
 984         return (ahd_print_register(SSTAT3_parse_table, 2, "SSTAT3",
 985             0x53, regvalue, cur_col, wrap));
 986 }
 987
 988 static const ahd_reg_parse_entry_t SIMODE3_parse_table[] = {
 989         { "ENOSRAMPERR",        0x01, 0x01 },
 990         { "ENNTRAMPERR",        0x02, 0x02 }
 991 };
 992
 993 int
 994 ahd_simode3_print(u_int regvalue, u_int *cur_col, u_int wrap)
 995 {
 996         return (ahd_print_register(SIMODE3_parse_table, 2, "SIMODE3",
 997             0x53, regvalue, cur_col, wrap));
 998 }
 999
1000 static const ahd_reg_parse_entry_t CLRSINT3_parse_table[] = {
1001         { "CLROSRAMPERR",       0x01, 0x01 },
1002         { "CLRNTRAMPERR",       0x02, 0x02 }
1003 };
1004
1005 int
1006 ahd_clrsint3_print(u_int regvalue, u_int *cur_col, u_int wrap)
1007 {
1008         return (ahd_print_register(CLRSINT3_parse_table, 2, "CLRSINT3",
1009             0x53, regvalue, cur_col, wrap));
1010 }
1011
1012 static const ahd_reg_parse_entry_t LQOSTAT0_parse_table[] = {
1013         { "LQOTCRC",            0x01, 0x01 },
1014         { "LQOATNPKT",          0x02, 0x02 },
1015         { "LQOATNLQ",           0x04, 0x04 },
1016         { "LQOSTOPT2",          0x08, 0x08 },
1017         { "LQOTARGSCBPERR",     0x10, 0x10 }
1018 };
1019
1020 int
1021 ahd_lqostat0_print(u_int regvalue, u_int *cur_col, u_int wrap)
1022 {
1023         return (ahd_print_register(LQOSTAT0_parse_table, 5, "LQOSTAT0",
1024             0x54, regvalue, cur_col, wrap));
1025 }
1026
1027 static const ahd_reg_parse_entry_t CLRLQOINT0_parse_table[] = {
1028         { "CLRLQOTCRC",         0x01, 0x01 },
1029         { "CLRLQOATNPKT",       0x02, 0x02 },
1030         { "CLRLQOATNLQ",        0x04, 0x04 },
1031         { "CLRLQOSTOPT2",       0x08, 0x08 },
1032         { "CLRLQOTARGSCBPERR",  0x10, 0x10 }
1033 };
1034
1035 int
1036 ahd_clrlqoint0_print(u_int regvalue, u_int *cur_col, u_int wrap)
1037 {
1038         return (ahd_print_register(CLRLQOINT0_parse_table, 5, "CLRLQOINT0",
1039             0x54, regvalue, cur_col, wrap));
1040 }
1041
1042 static const ahd_reg_parse_entry_t LQOMODE0_parse_table[] = {
1043         { "ENLQOTCRC",          0x01, 0x01 },
1044         { "ENLQOATNPKT",        0x02, 0x02 },
1045         { "ENLQOATNLQ",         0x04, 0x04 },
1046         { "ENLQOSTOPT2",        0x08, 0x08 },
1047         { "ENLQOTARGSCBPERR",   0x10, 0x10 }
1048 };
1049
1050 int
1051 ahd_lqomode0_print(u_int regvalue, u_int *cur_col, u_int wrap)
1052 {
1053         return (ahd_print_register(LQOMODE0_parse_table, 5, "LQOMODE0",
1054             0x54, regvalue, cur_col, wrap));
1055 }
1056
1057 static const ahd_reg_parse_entry_t LQOMODE1_parse_table[] = {
1058         { "ENLQOPHACHGINPKT",   0x01, 0x01 },
1059         { "ENLQOBUSFREE",       0x02, 0x02 },
1060         { "ENLQOBADQAS",        0x04, 0x04 },
1061         { "ENLQOSTOPI2",        0x08, 0x08 },
1062         { "ENLQOINITSCBPERR",   0x10, 0x10 }
1063 };
1064
1065 int
1066 ahd_lqomode1_print(u_int regvalue, u_int *cur_col, u_int wrap)
1067 {
1068         return (ahd_print_register(LQOMODE1_parse_table, 5, "LQOMODE1",
1069             0x55, regvalue, cur_col, wrap));
1070 }
1071
1072 static const ahd_reg_parse_entry_t LQOSTAT1_parse_table[] = {
1073         { "LQOPHACHGINPKT",     0x01, 0x01 },
1074         { "LQOBUSFREE",         0x02, 0x02 },
1075         { "LQOBADQAS",          0x04, 0x04 },
1076         { "LQOSTOPI2",          0x08, 0x08 },
1077         { "LQOINITSCBPERR",     0x10, 0x10 }
1078 };
1079
1080 int
1081 ahd_lqostat1_print(u_int regvalue, u_int *cur_col, u_int wrap)
1082 {
1083         return (ahd_print_register(LQOSTAT1_parse_table, 5, "LQOSTAT1",
1084             0x55, regvalue, cur_col, wrap));
1085 }
1086
1087 static const ahd_reg_parse_entry_t CLRLQOINT1_parse_table[] = {
1088         { "CLRLQOPHACHGINPKT",  0x01, 0x01 },
1089         { "CLRLQOBUSFREE",      0x02, 0x02 },
1090         { "CLRLQOBADQAS",       0x04, 0x04 },
1091         { "CLRLQOSTOPI2",       0x08, 0x08 },
1092         { "CLRLQOINITSCBPERR",  0x10, 0x10 }
1093 };
1094
1095 int
1096 ahd_clrlqoint1_print(u_int regvalue, u_int *cur_col, u_int wrap)
1097 {
1098         return (ahd_print_register(CLRLQOINT1_parse_table, 5, "CLRLQOINT1",
1099             0x55, regvalue, cur_col, wrap));
1100 }
1101
1102 static const ahd_reg_parse_entry_t LQOSTAT2_parse_table[] = {
1103         { "LQOSTOP0",           0x01, 0x01 },
1104         { "LQOPHACHGOUTPKT",    0x02, 0x02 },
1105         { "LQOWAITFIFO",        0x10, 0x10 },
1106         { "LQOPKT",             0xe0, 0xe0 }
1107 };
1108
1109 int
1110 ahd_lqostat2_print(u_int regvalue, u_int *cur_col, u_int wrap)
1111 {
1112         return (ahd_print_register(LQOSTAT2_parse_table, 4, "LQOSTAT2",
1113             0x56, regvalue, cur_col, wrap));
1114 }
1115
1116 int
1117 ahd_os_space_cnt_print(u_int regvalue, u_int *cur_col, u_int wrap)
1118 {
1119         return (ahd_print_register(NULL, 0, "OS_SPACE_CNT",
1120             0x56, regvalue, cur_col, wrap));
1121 }
1122
1123 static const ahd_reg_parse_entry_t SIMODE1_parse_table[] = {
1124         { "ENREQINIT",          0x01, 0x01 },
1125         { "ENSTRB2FAST",        0x02, 0x02 },
1126         { "ENSCSIPERR",         0x04, 0x04 },
1127         { "ENBUSFREE",          0x08, 0x08 },
1128         { "ENPHASEMIS",         0x10, 0x10 },
1129         { "ENSCSIRST",          0x20, 0x20 },
1130         { "ENATNTARG",          0x40, 0x40 },
1131         { "ENSELTIMO",          0x80, 0x80 }
1132 };
1133
1134 int
1135 ahd_simode1_print(u_int regvalue, u_int *cur_col, u_int wrap)
1136 {
1137         return (ahd_print_register(SIMODE1_parse_table, 8, "SIMODE1",
1138             0x57, regvalue, cur_col, wrap));
1139 }
1140
1141 int
1142 ahd_gsfifo_print(u_int regvalue, u_int *cur_col, u_int wrap)
1143 {
1144         return (ahd_print_register(NULL, 0, "GSFIFO",
1145             0x58, regvalue, cur_col, wrap));
1146 }
1147
1148 static const ahd_reg_parse_entry_t DFFSXFRCTL_parse_table[] = {
1149         { "RSTCHN",             0x01, 0x01 },
1150         { "CLRCHN",             0x02, 0x02 },
1151         { "CLRSHCNT",           0x04, 0x04 },
1152         { "DFFBITBUCKET",       0x08, 0x08 }
1153 };
1154
1155 int
1156 ahd_dffsxfrctl_print(u_int regvalue, u_int *cur_col, u_int wrap)
1157 {
1158         return (ahd_print_register(DFFSXFRCTL_parse_table, 4, "DFFSXFRCTL",
1159             0x5a, regvalue, cur_col, wrap));
1160 }
1161
1162 static const ahd_reg_parse_entry_t LQOSCSCTL_parse_table[] = {
1163         { "LQONOCHKOVER",       0x01, 0x01 },
1164         { "LQONOHOLDLACK",      0x02, 0x02 },
1165         { "LQOBUSETDLY",        0x40, 0x40 },
1166         { "LQOH2A_VERSION",     0x80, 0x80 }
1167 };
1168
1169 int
1170 ahd_lqoscsctl_print(u_int regvalue, u_int *cur_col, u_int wrap)
1171 {
1172         return (ahd_print_register(LQOSCSCTL_parse_table, 4, "LQOSCSCTL",
1173             0x5a, regvalue, cur_col, wrap));
1174 }
1175
1176 int
1177 ahd_nextscb_print(u_int regvalue, u_int *cur_col, u_int wrap)
1178 {
1179         return (ahd_print_register(NULL, 0, "NEXTSCB",
1180             0x5a, regvalue, cur_col, wrap));
1181 }
1182
1183 static const ahd_reg_parse_entry_t CLRSEQINTSRC_parse_table[] = {
1184         { "CLRCFG4TCMD",        0x01, 0x01 },
1185         { "CLRCFG4ICMD",        0x02, 0x02 },
1186         { "CLRCFG4TSTAT",       0x04, 0x04 },
1187         { "CLRCFG4ISTAT",       0x08, 0x08 },
1188         { "CLRCFG4DATA",        0x10, 0x10 },
1189         { "CLRSAVEPTRS",        0x20, 0x20 },
1190         { "CLRCTXTDONE",        0x40, 0x40 }
1191 };
1192
1193 int
1194 ahd_clrseqintsrc_print(u_int regvalue, u_int *cur_col, u_int wrap)
1195 {
1196         return (ahd_print_register(CLRSEQINTSRC_parse_table, 7, "CLRSEQINTSRC",
1197             0x5b, regvalue, cur_col, wrap));
1198 }
1199
1200 static const ahd_reg_parse_entry_t SEQINTSRC_parse_table[] = {
1201         { "CFG4TCMD",           0x01, 0x01 },
1202         { "CFG4ICMD",           0x02, 0x02 },
1203         { "CFG4TSTAT",          0x04, 0x04 },
1204         { "CFG4ISTAT",          0x08, 0x08 },
1205         { "CFG4DATA",           0x10, 0x10 },
1206         { "SAVEPTRS",           0x20, 0x20 },
1207         { "CTXTDONE",           0x40, 0x40 }
1208 };
1209
1210 int
1211 ahd_seqintsrc_print(u_int regvalue, u_int *cur_col, u_int wrap)
1212 {
1213         return (ahd_print_register(SEQINTSRC_parse_table, 7, "SEQINTSRC",
1214             0x5b, regvalue, cur_col, wrap));
1215 }
1216
1217 static const ahd_reg_parse_entry_t SEQIMODE_parse_table[] = {
1218         { "ENCFG4TCMD",         0x01, 0x01 },
1219         { "ENCFG4ICMD",         0x02, 0x02 },
1220         { "ENCFG4TSTAT",        0x04, 0x04 },
1221         { "ENCFG4ISTAT",        0x08, 0x08 },
1222         { "ENCFG4DATA",         0x10, 0x10 },
1223         { "ENSAVEPTRS",         0x20, 0x20 },
1224         { "ENCTXTDONE",         0x40, 0x40 }
1225 };
1226
1227 int
1228 ahd_seqimode_print(u_int regvalue, u_int *cur_col, u_int wrap)
1229 {
1230         return (ahd_print_register(SEQIMODE_parse_table, 7, "SEQIMODE",
1231             0x5c, regvalue, cur_col, wrap));
1232 }
1233
1234 int
1235 ahd_currscb_print(u_int regvalue, u_int *cur_col, u_int wrap)
1236 {
1237         return (ahd_print_register(NULL, 0, "CURRSCB",
1238             0x5c, regvalue, cur_col, wrap));
1239 }
1240
1241 static const ahd_reg_parse_entry_t MDFFSTAT_parse_table[] = {
1242         { "FIFOFREE",           0x01, 0x01 },
1243         { "DATAINFIFO",         0x02, 0x02 },
1244         { "DLZERO",             0x04, 0x04 },
1245         { "SHVALID",            0x08, 0x08 },
1246         { "LASTSDONE",          0x10, 0x10 },
1247         { "SHCNTMINUS1",        0x20, 0x20 },
1248         { "SHCNTNEGATIVE",      0x40, 0x40 }
1249 };
1250
1251 int
1252 ahd_mdffstat_print(u_int regvalue, u_int *cur_col, u_int wrap)
1253 {
1254         return (ahd_print_register(MDFFSTAT_parse_table, 7, "MDFFSTAT",
1255             0x5d, regvalue, cur_col, wrap));
1256 }
1257
1258 int
1259 ahd_lastscb_print(u_int regvalue, u_int *cur_col, u_int wrap)
1260 {
1261         return (ahd_print_register(NULL, 0, "LASTSCB",
1262             0x5e, regvalue, cur_col, wrap));
1263 }
1264
1265 int
1266 ahd_shaddr_print(u_int regvalue, u_int *cur_col, u_int wrap)
1267 {
1268         return (ahd_print_register(NULL, 0, "SHADDR",
1269             0x60, regvalue, cur_col, wrap));
1270 }
1271
1272 int
1273 ahd_negoaddr_print(u_int regvalue, u_int *cur_col, u_int wrap)
1274 {
1275         return (ahd_print_register(NULL, 0, "NEGOADDR",
1276             0x60, regvalue, cur_col, wrap));
1277 }
1278
1279 int
1280 ahd_negperiod_print(u_int regvalue, u_int *cur_col, u_int wrap)
1281 {
1282         return (ahd_print_register(NULL, 0, "NEGPERIOD",
1283             0x61, regvalue, cur_col, wrap));
1284 }
1285
1286 int
1287 ahd_negoffset_print(u_int regvalue, u_int *cur_col, u_int wrap)
1288 {
1289         return (ahd_print_register(NULL, 0, "NEGOFFSET",
1290             0x62, regvalue, cur_col, wrap));
1291 }
1292
1293 static const ahd_reg_parse_entry_t NEGPPROPTS_parse_table[] = {
1294         { "PPROPT_IUT",         0x01, 0x01 },
1295         { "PPROPT_DT",          0x02, 0x02 },
1296         { "PPROPT_QAS",         0x04, 0x04 },
1297         { "PPROPT_PACE",        0x08, 0x08 }
1298 };
1299
1300 int
1301 ahd_negppropts_print(u_int regvalue, u_int *cur_col, u_int wrap)
1302 {
1303         return (ahd_print_register(NEGPPROPTS_parse_table, 4, "NEGPPROPTS",
1304             0x63, regvalue, cur_col, wrap));
1305 }
1306
1307 static const ahd_reg_parse_entry_t NEGCONOPTS_parse_table[] = {
1308         { "WIDEXFER",           0x01, 0x01 },
1309         { "ENAUTOATNO",         0x02, 0x02 },
1310         { "ENAUTOATNI",         0x04, 0x04 },
1311         { "ENSLOWCRC",          0x08, 0x08 },
1312         { "RTI_OVRDTRN",        0x10, 0x10 },
1313         { "RTI_WRTDIS",         0x20, 0x20 },
1314         { "ENSNAPSHOT",         0x40, 0x40 }
1315 };
1316
1317 int
1318 ahd_negconopts_print(u_int regvalue, u_int *cur_col, u_int wrap)
1319 {
1320         return (ahd_print_register(NEGCONOPTS_parse_table, 7, "NEGCONOPTS",
1321             0x64, regvalue, cur_col, wrap));
1322 }
1323
1324 int
1325 ahd_annexcol_print(u_int regvalue, u_int *cur_col, u_int wrap)
1326 {
1327         return (ahd_print_register(NULL, 0, "ANNEXCOL",
1328             0x65, regvalue, cur_col, wrap));
1329 }
1330
1331 int
1332 ahd_annexdat_print(u_int regvalue, u_int *cur_col, u_int wrap)
1333 {
1334         return (ahd_print_register(NULL, 0, "ANNEXDAT",
1335             0x66, regvalue, cur_col, wrap));
1336 }
1337
1338 static const ahd_reg_parse_entry_t SCSCHKN_parse_table[] = {
1339         { "LSTSGCLRDIS",        0x01, 0x01 },
1340         { "SHVALIDSTDIS",       0x02, 0x02 },
1341         { "DFFACTCLR",          0x04, 0x04 },
1342         { "SDONEMSKDIS",        0x08, 0x08 },
1343         { "WIDERESEN",          0x10, 0x10 },
1344         { "CURRFIFODEF",        0x20, 0x20 },
1345         { "STSELSKIDDIS",       0x40, 0x40 },
1346         { "BIDICHKDIS",         0x80, 0x80 }
1347 };
1348
1349 int
1350 ahd_scschkn_print(u_int regvalue, u_int *cur_col, u_int wrap)
1351 {
1352         return (ahd_print_register(SCSCHKN_parse_table, 8, "SCSCHKN",
1353             0x66, regvalue, cur_col, wrap));
1354 }
1355
1356 int
1357 ahd_iownid_print(u_int regvalue, u_int *cur_col, u_int wrap)
1358 {
1359         return (ahd_print_register(NULL, 0, "IOWNID",
1360             0x67, regvalue, cur_col, wrap));
1361 }
1362
1363 int
1364 ahd_shcnt_print(u_int regvalue, u_int *cur_col, u_int wrap)
1365 {
1366         return (ahd_print_register(NULL, 0, "SHCNT",
1367             0x68, regvalue, cur_col, wrap));
1368 }
1369
1370 int
1371 ahd_townid_print(u_int regvalue, u_int *cur_col, u_int wrap)
1372 {
1373         return (ahd_print_register(NULL, 0, "TOWNID",
1374             0x69, regvalue, cur_col, wrap));
1375 }
1376
1377 int
1378 ahd_seloid_print(u_int regvalue, u_int *cur_col, u_int wrap)
1379 {
1380         return (ahd_print_register(NULL, 0, "SELOID",
1381             0x6b, regvalue, cur_col, wrap));
1382 }
1383
1384 int
1385 ahd_haddr_print(u_int regvalue, u_int *cur_col, u_int wrap)
1386 {
1387         return (ahd_print_register(NULL, 0, "HADDR",
1388             0x70, regvalue, cur_col, wrap));
1389 }
1390
1391 int
1392 ahd_hcnt_print(u_int regvalue, u_int *cur_col, u_int wrap)
1393 {
1394         return (ahd_print_register(NULL, 0, "HCNT",
1395             0x78, regvalue, cur_col, wrap));
1396 }
1397
1398 int
1399 ahd_sghaddr_print(u_int regvalue, u_int *cur_col, u_int wrap)
1400 {
1401         return (ahd_print_register(NULL, 0, "SGHADDR",
1402             0x7c, regvalue, cur_col, wrap));
1403 }
1404
1405 int
1406 ahd_scbhaddr_print(u_int regvalue, u_int *cur_col, u_int wrap)
1407 {
1408         return (ahd_print_register(NULL, 0, "SCBHADDR",
1409             0x7c, regvalue, cur_col, wrap));
1410 }
1411
1412 int
1413 ahd_sghcnt_print(u_int regvalue, u_int *cur_col, u_int wrap)
1414 {
1415         return (ahd_print_register(NULL, 0, "SGHCNT",
1416             0x84, regvalue, cur_col, wrap));
1417 }
1418
1419 int
1420 ahd_scbhcnt_print(u_int regvalue, u_int *cur_col, u_int wrap)
1421 {
1422         return (ahd_print_register(NULL, 0, "SCBHCNT",
1423             0x84, regvalue, cur_col, wrap));
1424 }
1425
1426 static const ahd_reg_parse_entry_t DFF_THRSH_parse_table[] = {
1427         { "WR_DFTHRSH_MIN",     0x00, 0x70 },
1428         { "RD_DFTHRSH_MIN",     0x00, 0x07 },
1429         { "RD_DFTHRSH_25",      0x01, 0x07 },
1430         { "RD_DFTHRSH_50",      0x02, 0x07 },
1431         { "RD_DFTHRSH_63",      0x03, 0x07 },
1432         { "RD_DFTHRSH_75",      0x04, 0x07 },
1433         { "RD_DFTHRSH_85",      0x05, 0x07 },
1434         { "RD_DFTHRSH_90",      0x06, 0x07 },
1435         { "RD_DFTHRSH_MAX",     0x07, 0x07 },
1436         { "WR_DFTHRSH_25",      0x10, 0x70 },
1437         { "WR_DFTHRSH_50",      0x20, 0x70 },
1438         { "WR_DFTHRSH_63",      0x30, 0x70 },
1439         { "WR_DFTHRSH_75",      0x40, 0x70 },
1440         { "WR_DFTHRSH_85",      0x50, 0x70 },
1441         { "WR_DFTHRSH_90",      0x60, 0x70 },
1442         { "WR_DFTHRSH_MAX",     0x70, 0x70 },
1443         { "RD_DFTHRSH",         0x07, 0x07 },
1444         { "WR_DFTHRSH",         0x70, 0x70 }
1445 };
1446
1447 int
1448 ahd_dff_thrsh_print(u_int regvalue, u_int *cur_col, u_int wrap)
1449 {
1450         return (ahd_print_register(DFF_THRSH_parse_table, 18, "DFF_THRSH",
1451             0x88, regvalue, cur_col, wrap));
1452 }
1453
1454 static const ahd_reg_parse_entry_t PCIXCTL_parse_table[] = {
1455         { "CMPABCDIS",          0x01, 0x01 },
1456         { "TSCSERREN",          0x02, 0x02 },
1457         { "SRSPDPEEN",          0x04, 0x04 },
1458         { "SPLTSTADIS",         0x08, 0x08 },
1459         { "SPLTSMADIS",         0x10, 0x10 },
1460         { "UNEXPSCIEN",         0x20, 0x20 },
1461         { "SERRPULSE",          0x80, 0x80 }
1462 };
1463
1464 int
1465 ahd_pcixctl_print(u_int regvalue, u_int *cur_col, u_int wrap)
1466 {
1467         return (ahd_print_register(PCIXCTL_parse_table, 7, "PCIXCTL",
1468             0x93, regvalue, cur_col, wrap));
1469 }
1470
1471 static const ahd_reg_parse_entry_t DCHSPLTSTAT0_parse_table[] = {
1472         { "RXSPLTRSP",          0x01, 0x01 },
1473         { "RXSCEMSG",           0x02, 0x02 },
1474         { "RXOVRUN",            0x04, 0x04 },
1475         { "CNTNOTCMPLT",        0x08, 0x08 },
1476         { "SCDATBUCKET",        0x10, 0x10 },
1477         { "SCADERR",            0x20, 0x20 },
1478         { "SCBCERR",            0x40, 0x40 },
1479         { "STAETERM",           0x80, 0x80 }
1480 };
1481
1482 int
1483 ahd_dchspltstat0_print(u_int regvalue, u_int *cur_col, u_int wrap)
1484 {
1485         return (ahd_print_register(DCHSPLTSTAT0_parse_table, 8, "DCHSPLTSTAT0",
1486             0x96, regvalue, cur_col, wrap));
1487 }
1488
1489 static const ahd_reg_parse_entry_t DCHSPLTSTAT1_parse_table[] = {
1490         { "RXDATABUCKET",       0x01, 0x01 }
1491 };
1492
1493 int
1494 ahd_dchspltstat1_print(u_int regvalue, u_int *cur_col, u_int wrap)
1495 {
1496         return (ahd_print_register(DCHSPLTSTAT1_parse_table, 1, "DCHSPLTSTAT1",
1497             0x97, regvalue, cur_col, wrap));
1498 }
1499
1500 static const ahd_reg_parse_entry_t SGSPLTSTAT0_parse_table[] = {
1501         { "RXSPLTRSP",          0x01, 0x01 },
1502         { "RXSCEMSG",           0x02, 0x02 },
1503         { "RXOVRUN",            0x04, 0x04 },
1504         { "CNTNOTCMPLT",        0x08, 0x08 },
1505         { "SCDATBUCKET",        0x10, 0x10 },
1506         { "SCADERR",            0x20, 0x20 },
1507         { "SCBCERR",            0x40, 0x40 },
1508         { "STAETERM",           0x80, 0x80 }
1509 };
1510
1511 int
1512 ahd_sgspltstat0_print(u_int regvalue, u_int *cur_col, u_int wrap)
1513 {
1514         return (ahd_print_register(SGSPLTSTAT0_parse_table, 8, "SGSPLTSTAT0",
1515             0x9e, regvalue, cur_col, wrap));
1516 }
1517
1518 static const ahd_reg_parse_entry_t SGSPLTSTAT1_parse_table[] = {
1519         { "RXDATABUCKET",       0x01, 0x01 }
1520 };
1521
1522 int
1523 ahd_sgspltstat1_print(u_int regvalue, u_int *cur_col, u_int wrap)
1524 {
1525         return (ahd_print_register(SGSPLTSTAT1_parse_table, 1, "SGSPLTSTAT1",
1526             0x9f, regvalue, cur_col, wrap));
1527 }
1528
1529 static const ahd_reg_parse_entry_t DF0PCISTAT_parse_table[] = {
1530         { "DPR",                0x01, 0x01 },
1531         { "TWATERR",            0x02, 0x02 },
1532         { "RDPERR",             0x04, 0x04 },
1533         { "SCAAPERR",           0x08, 0x08 },
1534         { "RTA",                0x10, 0x10 },
1535         { "RMA",                0x20, 0x20 },
1536         { "SSE",                0x40, 0x40 },
1537         { "DPE",                0x80, 0x80 }
1538 };
1539
1540 int
1541 ahd_df0pcistat_print(u_int regvalue, u_int *cur_col, u_int wrap)
1542 {
1543         return (ahd_print_register(DF0PCISTAT_parse_table, 8, "DF0PCISTAT",
1544             0xa0, regvalue, cur_col, wrap));
1545 }
1546
1547 int
1548 ahd_reg0_print(u_int regvalue, u_int *cur_col, u_int wrap)
1549 {
1550         return (ahd_print_register(NULL, 0, "REG0",
1551             0xa0, regvalue, cur_col, wrap));
1552 }
1553
1554 int
1555 ahd_reg_isr_print(u_int regvalue, u_int *cur_col, u_int wrap)
1556 {
1557         return (ahd_print_register(NULL, 0, "REG_ISR",
1558             0xa4, regvalue, cur_col, wrap));
1559 }
1560
1561 static const ahd_reg_parse_entry_t SG_STATE_parse_table[] = {
1562         { "SEGS_AVAIL",         0x01, 0x01 },
1563         { "LOADING_NEEDED",     0x02, 0x02 },
1564         { "FETCH_INPROG",       0x04, 0x04 }
1565 };
1566
1567 int
1568 ahd_sg_state_print(u_int regvalue, u_int *cur_col, u_int wrap)
1569 {
1570         return (ahd_print_register(SG_STATE_parse_table, 3, "SG_STATE",
1571             0xa6, regvalue, cur_col, wrap));
1572 }
1573
1574 static const ahd_reg_parse_entry_t TARGPCISTAT_parse_table[] = {
1575         { "TWATERR",            0x02, 0x02 },
1576         { "STA",                0x08, 0x08 },
1577         { "SSE",                0x40, 0x40 },
1578         { "DPE",                0x80, 0x80 }
1579 };
1580
1581 int
1582 ahd_targpcistat_print(u_int regvalue, u_int *cur_col, u_int wrap)
1583 {
1584         return (ahd_print_register(TARGPCISTAT_parse_table, 4, "TARGPCISTAT",
1585             0xa7, regvalue, cur_col, wrap));
1586 }
1587
1588 int
1589 ahd_scbptr_print(u_int regvalue, u_int *cur_col, u_int wrap)
1590 {
1591         return (ahd_print_register(NULL, 0, "SCBPTR",
1592             0xa8, regvalue, cur_col, wrap));
1593 }
1594
1595 static const ahd_reg_parse_entry_t SCBAUTOPTR_parse_table[] = {
1596         { "SCBPTR_OFF",         0x07, 0x07 },
1597         { "SCBPTR_ADDR",        0x38, 0x38 },
1598         { "AUSCBPTR_EN",        0x80, 0x80 }
1599 };
1600
1601 int
1602 ahd_scbautoptr_print(u_int regvalue, u_int *cur_col, u_int wrap)
1603 {
1604         return (ahd_print_register(SCBAUTOPTR_parse_table, 3, "SCBAUTOPTR",
1605             0xab, regvalue, cur_col, wrap));
1606 }
1607
1608 int
1609 ahd_ccsgaddr_print(u_int regvalue, u_int *cur_col, u_int wrap)
1610 {
1611         return (ahd_print_register(NULL, 0, "CCSGADDR",
1612             0xac, regvalue, cur_col, wrap));
1613 }
1614
1615 int
1616 ahd_ccscbaddr_print(u_int regvalue, u_int *cur_col, u_int wrap)
1617 {
1618         return (ahd_print_register(NULL, 0, "CCSCBADDR",
1619             0xac, regvalue, cur_col, wrap));
1620 }
1621
1622 static const ahd_reg_parse_entry_t CCSCBCTL_parse_table[] = {
1623         { "CCSCBRESET",         0x01, 0x01 },
1624         { "CCSCBDIR",           0x04, 0x04 },
1625         { "CCSCBEN",            0x08, 0x08 },
1626         { "CCARREN",            0x10, 0x10 },
1627         { "ARRDONE",            0x40, 0x40 },
1628         { "CCSCBDONE",          0x80, 0x80 }
1629 };
1630
1631 int
1632 ahd_ccscbctl_print(u_int regvalue, u_int *cur_col, u_int wrap)
1633 {
1634         return (ahd_print_register(CCSCBCTL_parse_table, 6, "CCSCBCTL",
1635             0xad, regvalue, cur_col, wrap));
1636 }
1637
1638 static const ahd_reg_parse_entry_t CCSGCTL_parse_table[] = {
1639         { "CCSGRESET",          0x01, 0x01 },
1640         { "SG_FETCH_REQ",       0x02, 0x02 },
1641         { "CCSGENACK",          0x08, 0x08 },
1642         { "SG_CACHE_AVAIL",     0x10, 0x10 },
1643         { "CCSGDONE",           0x80, 0x80 },
1644         { "CCSGEN",             0x0c, 0x0c }
1645 };
1646
1647 int
1648 ahd_ccsgctl_print(u_int regvalue, u_int *cur_col, u_int wrap)
1649 {
1650         return (ahd_print_register(CCSGCTL_parse_table, 6, "CCSGCTL",
1651             0xad, regvalue, cur_col, wrap));
1652 }
1653
1654 int
1655 ahd_ccsgram_print(u_int regvalue, u_int *cur_col, u_int wrap)
1656 {
1657         return (ahd_print_register(NULL, 0, "CCSGRAM",
1658             0xb0, regvalue, cur_col, wrap));
1659 }
1660
1661 int
1662 ahd_ccscbram_print(u_int regvalue, u_int *cur_col, u_int wrap)
1663 {
1664         return (ahd_print_register(NULL, 0, "CCSCBRAM",
1665             0xb0, regvalue, cur_col, wrap));
1666 }
1667
1668 int
1669 ahd_brddat_print(u_int regvalue, u_int *cur_col, u_int wrap)
1670 {
1671         return (ahd_print_register(NULL, 0, "BRDDAT",
1672             0xb8, regvalue, cur_col, wrap));
1673 }
1674
1675 static const ahd_reg_parse_entry_t BRDCTL_parse_table[] = {
1676         { "BRDSTB",             0x01, 0x01 },
1677         { "BRDRW",              0x02, 0x02 },
1678         { "BRDEN",              0x04, 0x04 },
1679         { "BRDADDR",            0x38, 0x38 },
1680         { "FLXARBREQ",          0x40, 0x40 },
1681         { "FLXARBACK",          0x80, 0x80 }
1682 };
1683
1684 int
1685 ahd_brdctl_print(u_int regvalue, u_int *cur_col, u_int wrap)
1686 {
1687         return (ahd_print_register(BRDCTL_parse_table, 6, "BRDCTL",
1688             0xb9, regvalue, cur_col, wrap));
1689 }
1690
1691 int
1692 ahd_seeadr_print(u_int regvalue, u_int *cur_col, u_int wrap)
1693 {
1694         return (ahd_print_register(NULL, 0, "SEEADR",
1695             0xba, regvalue, cur_col, wrap));
1696 }
1697
1698 int
1699 ahd_seedat_print(u_int regvalue, u_int *cur_col, u_int wrap)
1700 {
1701         return (ahd_print_register(NULL, 0, "SEEDAT",
1702             0xbc, regvalue, cur_col, wrap));
1703 }
1704
1705 static const ahd_reg_parse_entry_t SEECTL_parse_table[] = {
1706         { "SEEOP_ERAL",         0x40, 0x70 },
1707         { "SEEOP_WRITE",        0x50, 0x70 },
1708         { "SEEOP_READ",         0x60, 0x70 },
1709         { "SEEOP_ERASE",        0x70, 0x70 },
1710         { "SEESTART",           0x01, 0x01 },
1711         { "SEERST",             0x02, 0x02 },
1712         { "SEEOPCODE",          0x70, 0x70 },
1713         { "SEEOP_EWEN",         0x40, 0x40 },
1714         { "SEEOP_WALL",         0x40, 0x40 },
1715         { "SEEOP_EWDS",         0x40, 0x40 }
1716 };
1717
1718 int
1719 ahd_seectl_print(u_int regvalue, u_int *cur_col, u_int wrap)
1720 {
1721         return (ahd_print_register(SEECTL_parse_table, 10, "SEECTL",
1722             0xbe, regvalue, cur_col, wrap));
1723 }
1724
1725 static const ahd_reg_parse_entry_t SEESTAT_parse_table[] = {
1726         { "SEESTART",           0x01, 0x01 },
1727         { "SEEBUSY",            0x02, 0x02 },
1728         { "SEEARBACK",          0x04, 0x04 },
1729         { "LDALTID_L",          0x08, 0x08 },
1730         { "SEEOPCODE",          0x70, 0x70 },
1731         { "INIT_DONE",          0x80, 0x80 }
1732 };
1733
1734 int
1735 ahd_seestat_print(u_int regvalue, u_int *cur_col, u_int wrap)
1736 {
1737         return (ahd_print_register(SEESTAT_parse_table, 6, "SEESTAT",
1738             0xbe, regvalue, cur_col, wrap));
1739 }
1740
1741 static const ahd_reg_parse_entry_t DSPDATACTL_parse_table[] = {
1742         { "XMITOFFSTDIS",       0x02, 0x02 },
1743         { "RCVROFFSTDIS",       0x04, 0x04 },
1744         { "DESQDIS",            0x10, 0x10 },
1745         { "BYPASSENAB",         0x80, 0x80 }
1746 };
1747
1748 int
1749 ahd_dspdatactl_print(u_int regvalue, u_int *cur_col, u_int wrap)
1750 {
1751         return (ahd_print_register(DSPDATACTL_parse_table, 4, "DSPDATACTL",
1752             0xc1, regvalue, cur_col, wrap));
1753 }
1754
1755 int
1756 ahd_dfdat_print(u_int regvalue, u_int *cur_col, u_int wrap)
1757 {
1758         return (ahd_print_register(NULL, 0, "DFDAT",
1759             0xc4, regvalue, cur_col, wrap));
1760 }
1761
1762 static const ahd_reg_parse_entry_t DSPSELECT_parse_table[] = {
1763         { "DSPSEL",             0x1f, 0x1f },
1764         { "AUTOINCEN",          0x80, 0x80 }
1765 };
1766
1767 int
1768 ahd_dspselect_print(u_int regvalue, u_int *cur_col, u_int wrap)
1769 {
1770         return (ahd_print_register(DSPSELECT_parse_table, 2, "DSPSELECT",
1771             0xc4, regvalue, cur_col, wrap));
1772 }
1773
1774 static const ahd_reg_parse_entry_t WRTBIASCTL_parse_table[] = {
1775         { "XMITMANVAL",         0x3f, 0x3f },
1776         { "AUTOXBCDIS",         0x80, 0x80 }
1777 };
1778
1779 int
1780 ahd_wrtbiasctl_print(u_int regvalue, u_int *cur_col, u_int wrap)
1781 {
1782         return (ahd_print_register(WRTBIASCTL_parse_table, 2, "WRTBIASCTL",
1783             0xc5, regvalue, cur_col, wrap));
1784 }
1785
1786 static const ahd_reg_parse_entry_t SEQCTL0_parse_table[] = {
1787         { "LOADRAM",            0x01, 0x01 },
1788         { "SEQRESET",           0x02, 0x02 },
1789         { "STEP",               0x04, 0x04 },
1790         { "BRKADRINTEN",        0x08, 0x08 },
1791         { "FASTMODE",           0x10, 0x10 },
1792         { "FAILDIS",            0x20, 0x20 },
1793         { "PAUSEDIS",           0x40, 0x40 },
1794         { "PERRORDIS",          0x80, 0x80 }
1795 };
1796
1797 int
1798 ahd_seqctl0_print(u_int regvalue, u_int *cur_col, u_int wrap)
1799 {
1800         return (ahd_print_register(SEQCTL0_parse_table, 8, "SEQCTL0",
1801             0xd6, regvalue, cur_col, wrap));
1802 }
1803
1804 static const ahd_reg_parse_entry_t FLAGS_parse_table[] = {
1805         { "CARRY",              0x01, 0x01 },
1806         { "ZERO",               0x02, 0x02 }
1807 };
1808
1809 int
1810 ahd_flags_print(u_int regvalue, u_int *cur_col, u_int wrap)
1811 {
1812         return (ahd_print_register(FLAGS_parse_table, 2, "FLAGS",
1813             0xd8, regvalue, cur_col, wrap));
1814 }
1815
1816 static const ahd_reg_parse_entry_t SEQINTCTL_parse_table[] = {
1817         { "IRET",               0x01, 0x01 },
1818         { "INTMASK1",           0x02, 0x02 },
1819         { "INTMASK2",           0x04, 0x04 },
1820         { "SCS_SEQ_INT1M0",     0x08, 0x08 },
1821         { "SCS_SEQ_INT1M1",     0x10, 0x10 },
1822         { "INT1_CONTEXT",       0x20, 0x20 },
1823         { "INTVEC1DSL",         0x80, 0x80 }
1824 };
1825
1826 int
1827 ahd_seqintctl_print(u_int regvalue, u_int *cur_col, u_int wrap)
1828 {
1829         return (ahd_print_register(SEQINTCTL_parse_table, 7, "SEQINTCTL",
1830             0xd9, regvalue, cur_col, wrap));
1831 }
1832
1833 int
1834 ahd_seqram_print(u_int regvalue, u_int *cur_col, u_int wrap)
1835 {
1836         return (ahd_print_register(NULL, 0, "SEQRAM",
1837             0xda, regvalue, cur_col, wrap));
1838 }
1839
1840 int
1841 ahd_prgmcnt_print(u_int regvalue, u_int *cur_col, u_int wrap)
1842 {
1843         return (ahd_print_register(NULL, 0, "PRGMCNT",
1844             0xde, regvalue, cur_col, wrap));
1845 }
1846
1847 int
1848 ahd_accum_print(u_int regvalue, u_int *cur_col, u_int wrap)
1849 {
1850         return (ahd_print_register(NULL, 0, "ACCUM",
1851             0xe0, regvalue, cur_col, wrap));
1852 }
1853
1854 int
1855 ahd_sindex_print(u_int regvalue, u_int *cur_col, u_int wrap)
1856 {
1857         return (ahd_print_register(NULL, 0, "SINDEX",
1858             0xe2, regvalue, cur_col, wrap));
1859 }
1860
1861 int
1862 ahd_dindex_print(u_int regvalue, u_int *cur_col, u_int wrap)
1863 {
1864         return (ahd_print_register(NULL, 0, "DINDEX",
1865             0xe4, regvalue, cur_col, wrap));
1866 }
1867
1868 int
1869 ahd_allones_print(u_int regvalue, u_int *cur_col, u_int wrap)
1870 {
1871         return (ahd_print_register(NULL, 0, "ALLONES",
1872             0xe8, regvalue, cur_col, wrap));
1873 }
1874
1875 int
1876 ahd_allzeros_print(u_int regvalue, u_int *cur_col, u_int wrap)
1877 {
1878         return (ahd_print_register(NULL, 0, "ALLZEROS",
1879             0xea, regvalue, cur_col, wrap));
1880 }
1881
1882 int
1883 ahd_none_print(u_int regvalue, u_int *cur_col, u_int wrap)
1884 {
1885         return (ahd_print_register(NULL, 0, "NONE",
1886             0xea, regvalue, cur_col, wrap));
1887 }
1888
1889 int
1890 ahd_sindir_print(u_int regvalue, u_int *cur_col, u_int wrap)
1891 {
1892         return (ahd_print_register(NULL, 0, "SINDIR",
1893             0xec, regvalue, cur_col, wrap));
1894 }
1895
1896 int
1897 ahd_dindir_print(u_int regvalue, u_int *cur_col, u_int wrap)
1898 {
1899         return (ahd_print_register(NULL, 0, "DINDIR",
1900             0xed, regvalue, cur_col, wrap));
1901 }
1902
1903 int
1904 ahd_stack_print(u_int regvalue, u_int *cur_col, u_int wrap)
1905 {
1906         return (ahd_print_register(NULL, 0, "STACK",
1907             0xf2, regvalue, cur_col, wrap));
1908 }
1909
1910 int
1911 ahd_intvec1_addr_print(u_int regvalue, u_int *cur_col, u_int wrap)
1912 {
1913         return (ahd_print_register(NULL, 0, "INTVEC1_ADDR",
1914             0xf4, regvalue, cur_col, wrap));
1915 }
1916
1917 int
1918 ahd_curaddr_print(u_int regvalue, u_int *cur_col, u_int wrap)
1919 {
1920         return (ahd_print_register(NULL, 0, "CURADDR",
1921             0xf4, regvalue, cur_col, wrap));
1922 }
1923
1924 int
1925 ahd_intvec2_addr_print(u_int regvalue, u_int *cur_col, u_int wrap)
1926 {
1927         return (ahd_print_register(NULL, 0, "INTVEC2_ADDR",
1928             0xf6, regvalue, cur_col, wrap));
1929 }
1930
1931 int
1932 ahd_longjmp_addr_print(u_int regvalue, u_int *cur_col, u_int wrap)
1933 {
1934         return (ahd_print_register(NULL, 0, "LONGJMP_ADDR",
1935             0xf8, regvalue, cur_col, wrap));
1936 }
1937
1938 int
1939 ahd_accum_save_print(u_int regvalue, u_int *cur_col, u_int wrap)
1940 {
1941         return (ahd_print_register(NULL, 0, "ACCUM_SAVE",
1942             0xfa, regvalue, cur_col, wrap));
1943 }
1944
1945 int
1946 ahd_sram_base_print(u_int regvalue, u_int *cur_col, u_int wrap)
1947 {
1948         return (ahd_print_register(NULL, 0, "SRAM_BASE",
1949             0x100, regvalue, cur_col, wrap));
1950 }
1951
1952 int
1953 ahd_waiting_scb_tails_print(u_int regvalue, u_int *cur_col, u_int wrap)
1954 {
1955         return (ahd_print_register(NULL, 0, "WAITING_SCB_TAILS",
1956             0x100, regvalue, cur_col, wrap));
1957 }
1958
1959 int
1960 ahd_waiting_tid_head_print(u_int regvalue, u_int *cur_col, u_int wrap)
1961 {
1962         return (ahd_print_register(NULL, 0, "WAITING_TID_HEAD",
1963             0x120, regvalue, cur_col, wrap));
1964 }
1965
1966 int
1967 ahd_waiting_tid_tail_print(u_int regvalue, u_int *cur_col, u_int wrap)
1968 {
1969         return (ahd_print_register(NULL, 0, "WAITING_TID_TAIL",
1970             0x122, regvalue, cur_col, wrap));
1971 }
1972
1973 int
1974 ahd_next_queued_scb_addr_print(u_int regvalue, u_int *cur_col, u_int wrap)
1975 {
1976         return (ahd_print_register(NULL, 0, "NEXT_QUEUED_SCB_ADDR",
1977             0x124, regvalue, cur_col, wrap));
1978 }
1979
1980 int
1981 ahd_complete_scb_head_print(u_int regvalue, u_int *cur_col, u_int wrap)
1982 {
1983         return (ahd_print_register(NULL, 0, "COMPLETE_SCB_HEAD",
1984             0x128, regvalue, cur_col, wrap));
1985 }
1986
1987 int
1988 ahd_complete_scb_dmainprog_head_print(u_int regvalue, u_int *cur_col, u_int wrap)
1989 {
1990         return (ahd_print_register(NULL, 0, "COMPLETE_SCB_DMAINPROG_HEAD",
1991             0x12a, regvalue, cur_col, wrap));
1992 }
1993
1994 int
1995 ahd_complete_dma_scb_head_print(u_int regvalue, u_int *cur_col, u_int wrap)
1996 {
1997         return (ahd_print_register(NULL, 0, "COMPLETE_DMA_SCB_HEAD",
1998             0x12c, regvalue, cur_col, wrap));
1999 }
2000
2001 int
2002 ahd_complete_dma_scb_tail_print(u_int regvalue, u_int *cur_col, u_int wrap)
2003 {
2004         return (ahd_print_register(NULL, 0, "COMPLETE_DMA_SCB_TAIL",
2005             0x12e, regvalue, cur_col, wrap));
2006 }
2007
2008 int
2009 ahd_complete_on_qfreeze_head_print(u_int regvalue, u_int *cur_col, u_int wrap)
2010 {
2011         return (ahd_print_register(NULL, 0, "COMPLETE_ON_QFREEZE_HEAD",
2012             0x130, regvalue, cur_col, wrap));
2013 }
2014
2015 int
2016 ahd_qfreeze_count_print(u_int regvalue, u_int *cur_col, u_int wrap)
2017 {
2018         return (ahd_print_register(NULL, 0, "QFREEZE_COUNT",
2019             0x132, regvalue, cur_col, wrap));
2020 }
2021
2022 int
2023 ahd_kernel_qfreeze_count_print(u_int regvalue, u_int *cur_col, u_int wrap)
2024 {
2025         return (ahd_print_register(NULL, 0, "KERNEL_QFREEZE_COUNT",
2026             0x134, regvalue, cur_col, wrap));
2027 }
2028
2029 int
2030 ahd_saved_mode_print(u_int regvalue, u_int *cur_col, u_int wrap)
2031 {
2032         return (ahd_print_register(NULL, 0, "SAVED_MODE",
2033             0x136, regvalue, cur_col, wrap));
2034 }
2035
2036 int
2037 ahd_msg_out_print(u_int regvalue, u_int *cur_col, u_int wrap)
2038 {
2039         return (ahd_print_register(NULL, 0, "MSG_OUT",
2040             0x137, regvalue, cur_col, wrap));
2041 }
2042
2043 static const ahd_reg_parse_entry_t DMAPARAMS_parse_table[] = {
2044         { "FIFORESET",          0x01, 0x01 },
2045         { "FIFOFLUSH",          0x02, 0x02 },
2046         { "DIRECTION",          0x04, 0x04 },
2047         { "HDMAEN",             0x08, 0x08 },
2048         { "HDMAENACK",          0x08, 0x08 },
2049         { "SDMAEN",             0x10, 0x10 },
2050         { "SDMAENACK",          0x10, 0x10 },
2051         { "SCSIEN",             0x20, 0x20 },
2052         { "WIDEODD",            0x40, 0x40 },
2053         { "PRELOADEN",          0x80, 0x80 }
2054 };
2055
2056 int
2057 ahd_dmaparams_print(u_int regvalue, u_int *cur_col, u_int wrap)
2058 {
2059         return (ahd_print_register(DMAPARAMS_parse_table, 10, "DMAPARAMS",
2060             0x138, regvalue, cur_col, wrap));
2061 }
2062
2063 static const ahd_reg_parse_entry_t SEQ_FLAGS_parse_table[] = {
2064         { "NO_DISCONNECT",      0x01, 0x01 },
2065         { "SPHASE_PENDING",     0x02, 0x02 },
2066         { "DPHASE_PENDING",     0x04, 0x04 },
2067         { "CMDPHASE_PENDING",   0x08, 0x08 },
2068         { "TARG_CMD_PENDING",   0x10, 0x10 },
2069         { "DPHASE",             0x20, 0x20 },
2070         { "NO_CDB_SENT",        0x40, 0x40 },
2071         { "TARGET_CMD_IS_TAGGED",0x40, 0x40 },
2072         { "NOT_IDENTIFIED",     0x80, 0x80 }
2073 };
2074
2075 int
2076 ahd_seq_flags_print(u_int regvalue, u_int *cur_col, u_int wrap)
2077 {
2078         return (ahd_print_register(SEQ_FLAGS_parse_table, 9, "SEQ_FLAGS",
2079             0x139, regvalue, cur_col, wrap));
2080 }
2081
2082 int
2083 ahd_saved_scsiid_print(u_int regvalue, u_int *cur_col, u_int wrap)
2084 {
2085         return (ahd_print_register(NULL, 0, "SAVED_SCSIID",
2086             0x13a, regvalue, cur_col, wrap));
2087 }
2088
2089 int
2090 ahd_saved_lun_print(u_int regvalue, u_int *cur_col, u_int wrap)
2091 {
2092         return (ahd_print_register(NULL, 0, "SAVED_LUN",
2093             0x13b, regvalue, cur_col, wrap));
2094 }
2095
2096 static const ahd_reg_parse_entry_t LASTPHASE_parse_table[] = {
2097         { "P_DATAOUT",          0x00, 0xe0 },
2098         { "P_DATAOUT_DT",       0x20, 0xe0 },
2099         { "P_DATAIN",           0x40, 0xe0 },
2100         { "P_DATAIN_DT",        0x60, 0xe0 },
2101         { "P_COMMAND",          0x80, 0xe0 },
2102         { "P_MESGOUT",          0xa0, 0xe0 },
2103         { "P_STATUS",           0xc0, 0xe0 },
2104         { "P_MESGIN",           0xe0, 0xe0 },
2105         { "P_BUSFREE",          0x01, 0x01 },
2106         { "MSGI",               0x20, 0x20 },
2107         { "IOI",                0x40, 0x40 },
2108         { "CDI",                0x80, 0x80 },
2109         { "PHASE_MASK",         0xe0, 0xe0 }
2110 };
2111
2112 int
2113 ahd_lastphase_print(u_int regvalue, u_int *cur_col, u_int wrap)
2114 {
2115         return (ahd_print_register(LASTPHASE_parse_table, 13, "LASTPHASE",
2116             0x13c, regvalue, cur_col, wrap));
2117 }
2118
2119 int
2120 ahd_qoutfifo_entry_valid_tag_print(u_int regvalue, u_int *cur_col, u_int wrap)
2121 {
2122         return (ahd_print_register(NULL, 0, "QOUTFIFO_ENTRY_VALID_TAG",
2123             0x13d, regvalue, cur_col, wrap));
2124 }
2125
2126 int
2127 ahd_kernel_tqinpos_print(u_int regvalue, u_int *cur_col, u_int wrap)
2128 {
2129         return (ahd_print_register(NULL, 0, "KERNEL_TQINPOS",
2130             0x13e, regvalue, cur_col, wrap));
2131 }
2132
2133 int
2134 ahd_tqinpos_print(u_int regvalue, u_int *cur_col, u_int wrap)
2135 {
2136         return (ahd_print_register(NULL, 0, "TQINPOS",
2137             0x13f, regvalue, cur_col, wrap));
2138 }
2139
2140 int
2141 ahd_shared_data_addr_print(u_int regvalue, u_int *cur_col, u_int wrap)
2142 {
2143         return (ahd_print_register(NULL, 0, "SHARED_DATA_ADDR",
2144             0x140, regvalue, cur_col, wrap));
2145 }
2146
2147 int
2148 ahd_qoutfifo_next_addr_print(u_int regvalue, u_int *cur_col, u_int wrap)
2149 {
2150         return (ahd_print_register(NULL, 0, "QOUTFIFO_NEXT_ADDR",
2151             0x144, regvalue, cur_col, wrap));
2152 }
2153
2154 static const ahd_reg_parse_entry_t ARG_1_parse_table[] = {
2155         { "CONT_MSG_LOOP_TARG", 0x02, 0x02 },
2156         { "CONT_MSG_LOOP_READ", 0x03, 0x03 },
2157         { "CONT_MSG_LOOP_WRITE",0x04, 0x04 },
2158         { "EXIT_MSG_LOOP",      0x08, 0x08 },
2159         { "MSGOUT_PHASEMIS",    0x10, 0x10 },
2160         { "SEND_REJ",           0x20, 0x20 },
2161         { "SEND_SENSE",         0x40, 0x40 },
2162         { "SEND_MSG",           0x80, 0x80 }
2163 };
2164
2165 int
2166 ahd_arg_1_print(u_int regvalue, u_int *cur_col, u_int wrap)
2167 {
2168         return (ahd_print_register(ARG_1_parse_table, 8, "ARG_1",
2169             0x148, regvalue, cur_col, wrap));
2170 }
2171
2172 int
2173 ahd_arg_2_print(u_int regvalue, u_int *cur_col, u_int wrap)
2174 {
2175         return (ahd_print_register(NULL, 0, "ARG_2",
2176             0x149, regvalue, cur_col, wrap));
2177 }
2178
2179 int
2180 ahd_last_msg_print(u_int regvalue, u_int *cur_col, u_int wrap)
2181 {
2182         return (ahd_print_register(NULL, 0, "LAST_MSG",
2183             0x14a, regvalue, cur_col, wrap));
2184 }
2185
2186 static const ahd_reg_parse_entry_t SCSISEQ_TEMPLATE_parse_table[] = {
2187         { "ALTSTIM",            0x01, 0x01 },
2188         { "ENAUTOATNP",         0x02, 0x02 },
2189         { "MANUALP",            0x0c, 0x0c },
2190         { "ENRSELI",            0x10, 0x10 },
2191         { "ENSELI",             0x20, 0x20 },
2192         { "MANUALCTL",          0x40, 0x40 }
2193 };
2194
2195 int
2196 ahd_scsiseq_template_print(u_int regvalue, u_int *cur_col, u_int wrap)
2197 {
2198         return (ahd_print_register(SCSISEQ_TEMPLATE_parse_table, 6, "SCSISEQ_TEMPLATE",
2199             0x14b, regvalue, cur_col, wrap));
2200 }
2201
2202 int
2203 ahd_initiator_tag_print(u_int regvalue, u_int *cur_col, u_int wrap)
2204 {
2205         return (ahd_print_register(NULL, 0, "INITIATOR_TAG",
2206             0x14c, regvalue, cur_col, wrap));
2207 }
2208
2209 static const ahd_reg_parse_entry_t SEQ_FLAGS2_parse_table[] = {
2210         { "PENDING_MK_MESSAGE", 0x01, 0x01 },
2211         { "TARGET_MSG_PENDING", 0x02, 0x02 },
2212         { "SELECTOUT_QFROZEN",  0x04, 0x04 }
2213 };
2214
2215 int
2216 ahd_seq_flags2_print(u_int regvalue, u_int *cur_col, u_int wrap)
2217 {
2218         return (ahd_print_register(SEQ_FLAGS2_parse_table, 3, "SEQ_FLAGS2",
2219             0x14d, regvalue, cur_col, wrap));
2220 }
2221
2222 int
2223 ahd_allocfifo_scbptr_print(u_int regvalue, u_int *cur_col, u_int wrap)
2224 {
2225         return (ahd_print_register(NULL, 0, "ALLOCFIFO_SCBPTR",
2226             0x14e, regvalue, cur_col, wrap));
2227 }
2228
2229 int
2230 ahd_int_coalescing_timer_print(u_int regvalue, u_int *cur_col, u_int wrap)
2231 {
2232         return (ahd_print_register(NULL, 0, "INT_COALESCING_TIMER",
2233             0x150, regvalue, cur_col, wrap));
2234 }
2235
2236 int
2237 ahd_int_coalescing_maxcmds_print(u_int regvalue, u_int *cur_col, u_int wrap)
2238 {
2239         return (ahd_print_register(NULL, 0, "INT_COALESCING_MAXCMDS",
2240             0x152, regvalue, cur_col, wrap));
2241 }
2242
2243 int
2244 ahd_int_coalescing_mincmds_print(u_int regvalue, u_int *cur_col, u_int wrap)
2245 {
2246         return (ahd_print_register(NULL, 0, "INT_COALESCING_MINCMDS",
2247             0x153, regvalue, cur_col, wrap));
2248 }
2249
2250 int
2251 ahd_cmds_pending_print(u_int regvalue, u_int *cur_col, u_int wrap)
2252 {
2253         return (ahd_print_register(NULL, 0, "CMDS_PENDING",
2254             0x154, regvalue, cur_col, wrap));
2255 }
2256
2257 int
2258 ahd_int_coalescing_cmdcount_print(u_int regvalue, u_int *cur_col, u_int wrap)
2259 {
2260         return (ahd_print_register(NULL, 0, "INT_COALESCING_CMDCOUNT",
2261             0x156, regvalue, cur_col, wrap));
2262 }
2263
2264 int
2265 ahd_local_hs_mailbox_print(u_int regvalue, u_int *cur_col, u_int wrap)
2266 {
2267         return (ahd_print_register(NULL, 0, "LOCAL_HS_MAILBOX",
2268             0x157, regvalue, cur_col, wrap));
2269 }
2270
2271 int
2272 ahd_cmdsize_table_print(u_int regvalue, u_int *cur_col, u_int wrap)
2273 {
2274         return (ahd_print_register(NULL, 0, "CMDSIZE_TABLE",
2275             0x158, regvalue, cur_col, wrap));
2276 }
2277
2278 int
2279 ahd_mk_message_scb_print(u_int regvalue, u_int *cur_col, u_int wrap)
2280 {
2281         return (ahd_print_register(NULL, 0, "MK_MESSAGE_SCB",
2282             0x160, regvalue, cur_col, wrap));
2283 }
2284
2285 int
2286 ahd_mk_message_scsiid_print(u_int regvalue, u_int *cur_col, u_int wrap)
2287 {
2288         return (ahd_print_register(NULL, 0, "MK_MESSAGE_SCSIID",
2289             0x162, regvalue, cur_col, wrap));
2290 }
2291
2292 int
2293 ahd_scb_residual_datacnt_print(u_int regvalue, u_int *cur_col, u_int wrap)
2294 {
2295         return (ahd_print_register(NULL, 0, "SCB_RESIDUAL_DATACNT",
2296             0x180, regvalue, cur_col, wrap));
2297 }
2298
2299 int
2300 ahd_scb_base_print(u_int regvalue, u_int *cur_col, u_int wrap)
2301 {
2302         return (ahd_print_register(NULL, 0, "SCB_BASE",
2303             0x180, regvalue, cur_col, wrap));
2304 }
2305
2306 static const ahd_reg_parse_entry_t SCB_RESIDUAL_SGPTR_parse_table[] = {
2307         { "SG_LIST_NULL",       0x01, 0x01 },
2308         { "SG_OVERRUN_RESID",   0x02, 0x02 },
2309         { "SG_ADDR_MASK",       0xf8, 0xf8 }
2310 };
2311
2312 int
2313 ahd_scb_residual_sgptr_print(u_int regvalue, u_int *cur_col, u_int wrap)
2314 {
2315         return (ahd_print_register(SCB_RESIDUAL_SGPTR_parse_table, 3, "SCB_RESIDUAL_SGPTR",
2316             0x184, regvalue, cur_col, wrap));
2317 }
2318
2319 int
2320 ahd_scb_scsi_status_print(u_int regvalue, u_int *cur_col, u_int wrap)
2321 {
2322         return (ahd_print_register(NULL, 0, "SCB_SCSI_STATUS",
2323             0x188, regvalue, cur_col, wrap));
2324 }
2325
2326 int
2327 ahd_scb_sense_busaddr_print(u_int regvalue, u_int *cur_col, u_int wrap)
2328 {
2329         return (ahd_print_register(NULL, 0, "SCB_SENSE_BUSADDR",
2330             0x18c, regvalue, cur_col, wrap));
2331 }
2332
2333 int
2334 ahd_scb_tag_print(u_int regvalue, u_int *cur_col, u_int wrap)
2335 {
2336         return (ahd_print_register(NULL, 0, "SCB_TAG",
2337             0x190, regvalue, cur_col, wrap));
2338 }
2339
2340 static const ahd_reg_parse_entry_t SCB_CONTROL_parse_table[] = {
2341         { "SCB_TAG_TYPE",       0x03, 0x03 },
2342         { "DISCONNECTED",       0x04, 0x04 },
2343         { "STATUS_RCVD",        0x08, 0x08 },
2344         { "MK_MESSAGE",         0x10, 0x10 },
2345         { "TAG_ENB",            0x20, 0x20 },
2346         { "DISCENB",            0x40, 0x40 },
2347         { "TARGET_SCB",         0x80, 0x80 }
2348 };
2349
2350 int
2351 ahd_scb_control_print(u_int regvalue, u_int *cur_col, u_int wrap)
2352 {
2353         return (ahd_print_register(SCB_CONTROL_parse_table, 7, "SCB_CONTROL",
2354             0x192, regvalue, cur_col, wrap));
2355 }
2356
2357 static const ahd_reg_parse_entry_t SCB_SCSIID_parse_table[] = {
2358         { "OID",                0x0f, 0x0f },
2359         { "TID",                0xf0, 0xf0 }
2360 };
2361
2362 int
2363 ahd_scb_scsiid_print(u_int regvalue, u_int *cur_col, u_int wrap)
2364 {
2365         return (ahd_print_register(SCB_SCSIID_parse_table, 2, "SCB_SCSIID",
2366             0x193, regvalue, cur_col, wrap));
2367 }
2368
2369 static const ahd_reg_parse_entry_t SCB_LUN_parse_table[] = {
2370         { "LID",                0xff, 0xff }
2371 };
2372
2373 int
2374 ahd_scb_lun_print(u_int regvalue, u_int *cur_col, u_int wrap)
2375 {
2376         return (ahd_print_register(SCB_LUN_parse_table, 1, "SCB_LUN",
2377             0x194, regvalue, cur_col, wrap));
2378 }
2379
2380 static const ahd_reg_parse_entry_t SCB_TASK_ATTRIBUTE_parse_table[] = {
2381         { "SCB_XFERLEN_ODD",    0x01, 0x01 }
2382 };
2383
2384 int
2385 ahd_scb_task_attribute_print(u_int regvalue, u_int *cur_col, u_int wrap)
2386 {
2387         return (ahd_print_register(SCB_TASK_ATTRIBUTE_parse_table, 1, "SCB_TASK_ATTRIBUTE",
2388             0x195, regvalue, cur_col, wrap));
2389 }
2390
2391 static const ahd_reg_parse_entry_t SCB_CDB_LEN_parse_table[] = {
2392         { "SCB_CDB_LEN_PTR",    0x80, 0x80 }
2393 };
2394
2395 int
2396 ahd_scb_cdb_len_print(u_int regvalue, u_int *cur_col, u_int wrap)
2397 {
2398         return (ahd_print_register(SCB_CDB_LEN_parse_table, 1, "SCB_CDB_LEN",
2399             0x196, regvalue, cur_col, wrap));
2400 }
2401
2402 int
2403 ahd_scb_task_management_print(u_int regvalue, u_int *cur_col, u_int wrap)
2404 {
2405         return (ahd_print_register(NULL, 0, "SCB_TASK_MANAGEMENT",
2406             0x197, regvalue, cur_col, wrap));
2407 }
2408
2409 int
2410 ahd_scb_dataptr_print(u_int regvalue, u_int *cur_col, u_int wrap)
2411 {
2412         return (ahd_print_register(NULL, 0, "SCB_DATAPTR",
2413             0x198, regvalue, cur_col, wrap));
2414 }
2415
2416 static const ahd_reg_parse_entry_t SCB_DATACNT_parse_table[] = {
2417         { "SG_HIGH_ADDR_BITS",  0x7f, 0x7f },
2418         { "SG_LAST_SEG",        0x80, 0x80 }
2419 };
2420
2421 int
2422 ahd_scb_datacnt_print(u_int regvalue, u_int *cur_col, u_int wrap)
2423 {
2424         return (ahd_print_register(SCB_DATACNT_parse_table, 2, "SCB_DATACNT",
2425             0x1a0, regvalue, cur_col, wrap));
2426 }
2427
2428 static const ahd_reg_parse_entry_t SCB_SGPTR_parse_table[] = {
2429         { "SG_LIST_NULL",       0x01, 0x01 },
2430         { "SG_FULL_RESID",      0x02, 0x02 },
2431         { "SG_STATUS_VALID",    0x04, 0x04 }
2432 };
2433
2434 int
2435 ahd_scb_sgptr_print(u_int regvalue, u_int *cur_col, u_int wrap)
2436 {
2437         return (ahd_print_register(SCB_SGPTR_parse_table, 3, "SCB_SGPTR",
2438             0x1a4, regvalue, cur_col, wrap));
2439 }
2440
2441 int
2442 ahd_scb_busaddr_print(u_int regvalue, u_int *cur_col, u_int wrap)
2443 {
2444         return (ahd_print_register(NULL, 0, "SCB_BUSADDR",
2445             0x1a8, regvalue, cur_col, wrap));
2446 }
2447
2448 int
2449 ahd_scb_next_print(u_int regvalue, u_int *cur_col, u_int wrap)
2450 {
2451         return (ahd_print_register(NULL, 0, "SCB_NEXT",
2452             0x1ac, regvalue, cur_col, wrap));
2453 }
2454
2455 int
2456 ahd_scb_next2_print(u_int regvalue, u_int *cur_col, u_int wrap)
2457 {
2458         return (ahd_print_register(NULL, 0, "SCB_NEXT2",
2459             0x1ae, regvalue, cur_col, wrap));
2460 }
2461
2462 int
2463 ahd_scb_disconnected_lists_print(u_int regvalue, u_int *cur_col, u_int wrap)
2464 {
2465         return (ahd_print_register(NULL, 0, "SCB_DISCONNECTED_LISTS",
2466             0x1b8, regvalue, cur_col, wrap));
2467 }
2468