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#93 $
   6  * $Id: //depot/aic7xxx/aic7xxx/aic79xx.reg#68 $
   7  */
   8
   9 #include "aic79xx_osm.h"
  10
  11 static 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 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 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 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 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 ahd_reg_parse_entry_t CLRERR_parse_table[] = {
 115         { "CLRDSCTMOUT",        0x02, 0x02 },
 116         { "CLRILLOPCODE",       0x04, 0x04 },
 117         { "CLRSQPARERR",        0x08, 0x08 },
 118         { "CLRDPARERR",         0x10, 0x10 },
 119         { "CLRMPARERR",         0x20, 0x20 },
 120         { "CLRCIOACCESFAIL",    0x40, 0x40 },
 121         { "CLRCIOPARERR",       0x80, 0x80 }
 122 };
 123
 124 int
 125 ahd_clrerr_print(u_int regvalue, u_int *cur_col, u_int wrap)
 126 {
 127         return (ahd_print_register(CLRERR_parse_table, 7, "CLRERR",
 128             0x04, regvalue, cur_col, wrap));
 129 }
 130
 131 static ahd_reg_parse_entry_t HCNTRL_parse_table[] = {
 132         { "CHIPRST",            0x01, 0x01 },
 133         { "CHIPRSTACK",         0x01, 0x01 },
 134         { "INTEN",              0x02, 0x02 },
 135         { "PAUSE",              0x04, 0x04 },
 136         { "SWTIMER_START_B",    0x08, 0x08 },
 137         { "SWINT",              0x10, 0x10 },
 138         { "POWRDN",             0x40, 0x40 },
 139         { "SEQ_RESET",          0x80, 0x80 }
 140 };
 141
 142 int
 143 ahd_hcntrl_print(u_int regvalue, u_int *cur_col, u_int wrap)
 144 {
 145         return (ahd_print_register(HCNTRL_parse_table, 8, "HCNTRL",
 146             0x05, regvalue, cur_col, wrap));
 147 }
 148
 149 int
 150 ahd_hnscb_qoff_print(u_int regvalue, u_int *cur_col, u_int wrap)
 151 {
 152         return (ahd_print_register(NULL, 0, "HNSCB_QOFF",
 153             0x06, regvalue, cur_col, wrap));
 154 }
 155
 156 int
 157 ahd_hescb_qoff_print(u_int regvalue, u_int *cur_col, u_int wrap)
 158 {
 159         return (ahd_print_register(NULL, 0, "HESCB_QOFF",
 160             0x08, regvalue, cur_col, wrap));
 161 }
 162
 163 static ahd_reg_parse_entry_t HS_MAILBOX_parse_table[] = {
 164         { "ENINT_COALESCE",     0x40, 0x40 },
 165         { "HOST_TQINPOS",       0x80, 0x80 }
 166 };
 167
 168 int
 169 ahd_hs_mailbox_print(u_int regvalue, u_int *cur_col, u_int wrap)
 170 {
 171         return (ahd_print_register(HS_MAILBOX_parse_table, 2, "HS_MAILBOX",
 172             0x0b, regvalue, cur_col, wrap));
 173 }
 174
 175 static ahd_reg_parse_entry_t CLRSEQINTSTAT_parse_table[] = {
 176         { "CLRSEQ_SPLTINT",     0x01, 0x01 },
 177         { "CLRSEQ_PCIINT",      0x02, 0x02 },
 178         { "CLRSEQ_SCSIINT",     0x04, 0x04 },
 179         { "CLRSEQ_SEQINT",      0x08, 0x08 },
 180         { "CLRSEQ_SWTMRTO",     0x10, 0x10 }
 181 };
 182
 183 int
 184 ahd_clrseqintstat_print(u_int regvalue, u_int *cur_col, u_int wrap)
 185 {
 186         return (ahd_print_register(CLRSEQINTSTAT_parse_table, 5, "CLRSEQINTSTAT",
 187             0x0c, regvalue, cur_col, wrap));
 188 }
 189
 190 static ahd_reg_parse_entry_t SEQINTSTAT_parse_table[] = {
 191         { "SEQ_SPLTINT",        0x01, 0x01 },
 192         { "SEQ_PCIINT",         0x02, 0x02 },
 193         { "SEQ_SCSIINT",        0x04, 0x04 },
 194         { "SEQ_SEQINT",         0x08, 0x08 },
 195         { "SEQ_SWTMRTO",        0x10, 0x10 }
 196 };
 197
 198 int
 199 ahd_seqintstat_print(u_int regvalue, u_int *cur_col, u_int wrap)
 200 {
 201         return (ahd_print_register(SEQINTSTAT_parse_table, 5, "SEQINTSTAT",
 202             0x0c, regvalue, cur_col, wrap));
 203 }
 204
 205 int
 206 ahd_swtimer_print(u_int regvalue, u_int *cur_col, u_int wrap)
 207 {
 208         return (ahd_print_register(NULL, 0, "SWTIMER",
 209             0x0e, regvalue, cur_col, wrap));
 210 }
 211
 212 int
 213 ahd_snscb_qoff_print(u_int regvalue, u_int *cur_col, u_int wrap)
 214 {
 215         return (ahd_print_register(NULL, 0, "SNSCB_QOFF",
 216             0x10, regvalue, cur_col, wrap));
 217 }
 218
 219 int
 220 ahd_sescb_qoff_print(u_int regvalue, u_int *cur_col, u_int wrap)
 221 {
 222         return (ahd_print_register(NULL, 0, "SESCB_QOFF",
 223             0x12, regvalue, cur_col, wrap));
 224 }
 225
 226 int
 227 ahd_sdscb_qoff_print(u_int regvalue, u_int *cur_col, u_int wrap)
 228 {
 229         return (ahd_print_register(NULL, 0, "SDSCB_QOFF",
 230             0x14, regvalue, cur_col, wrap));
 231 }
 232
 233 static ahd_reg_parse_entry_t QOFF_CTLSTA_parse_table[] = {
 234         { "SCB_QSIZE_4",        0x00, 0x0f },
 235         { "SCB_QSIZE_8",        0x01, 0x0f },
 236         { "SCB_QSIZE_16",       0x02, 0x0f },
 237         { "SCB_QSIZE_32",       0x03, 0x0f },
 238         { "SCB_QSIZE_64",       0x04, 0x0f },
 239         { "SCB_QSIZE_128",      0x05, 0x0f },
 240         { "SCB_QSIZE_256",      0x06, 0x0f },
 241         { "SCB_QSIZE_512",      0x07, 0x0f },
 242         { "SCB_QSIZE_1024",     0x08, 0x0f },
 243         { "SCB_QSIZE_2048",     0x09, 0x0f },
 244         { "SCB_QSIZE_4096",     0x0a, 0x0f },
 245         { "SCB_QSIZE_8192",     0x0b, 0x0f },
 246         { "SCB_QSIZE_16384",    0x0c, 0x0f },
 247         { "SCB_QSIZE",          0x0f, 0x0f },
 248         { "HS_MAILBOX_ACT",     0x10, 0x10 },
 249         { "SDSCB_ROLLOVR",      0x20, 0x20 },
 250         { "NEW_SCB_AVAIL",      0x40, 0x40 },
 251         { "EMPTY_SCB_AVAIL",    0x80, 0x80 }
 252 };
 253
 254 int
 255 ahd_qoff_ctlsta_print(u_int regvalue, u_int *cur_col, u_int wrap)
 256 {
 257         return (ahd_print_register(QOFF_CTLSTA_parse_table, 18, "QOFF_CTLSTA",
 258             0x16, regvalue, cur_col, wrap));
 259 }
 260
 261 static ahd_reg_parse_entry_t INTCTL_parse_table[] = {
 262         { "SPLTINTEN",          0x01, 0x01 },
 263         { "SEQINTEN",           0x02, 0x02 },
 264         { "SCSIINTEN",          0x04, 0x04 },
 265         { "PCIINTEN",           0x08, 0x08 },
 266         { "AUTOCLRCMDINT",      0x10, 0x10 },
 267         { "SWTIMER_START",      0x20, 0x20 },
 268         { "SWTMINTEN",          0x40, 0x40 },
 269         { "SWTMINTMASK",        0x80, 0x80 }
 270 };
 271
 272 int
 273 ahd_intctl_print(u_int regvalue, u_int *cur_col, u_int wrap)
 274 {
 275         return (ahd_print_register(INTCTL_parse_table, 8, "INTCTL",
 276             0x18, regvalue, cur_col, wrap));
 277 }
 278
 279 static ahd_reg_parse_entry_t DFCNTRL_parse_table[] = {
 280         { "DIRECTIONEN",        0x01, 0x01 },
 281         { "FIFOFLUSH",          0x02, 0x02 },
 282         { "FIFOFLUSHACK",       0x02, 0x02 },
 283         { "DIRECTION",          0x04, 0x04 },
 284         { "DIRECTIONACK",       0x04, 0x04 },
 285         { "HDMAEN",             0x08, 0x08 },
 286         { "HDMAENACK",          0x08, 0x08 },
 287         { "SCSIEN",             0x20, 0x20 },
 288         { "SCSIENACK",          0x20, 0x20 },
 289         { "SCSIENWRDIS",        0x40, 0x40 },
 290         { "PRELOADEN",          0x80, 0x80 }
 291 };
 292
 293 int
 294 ahd_dfcntrl_print(u_int regvalue, u_int *cur_col, u_int wrap)
 295 {
 296         return (ahd_print_register(DFCNTRL_parse_table, 11, "DFCNTRL",
 297             0x19, regvalue, cur_col, wrap));
 298 }
 299
 300 static ahd_reg_parse_entry_t DSCOMMAND0_parse_table[] = {
 301         { "CIOPARCKEN",         0x01, 0x01 },
 302         { "DISABLE_TWATE",      0x02, 0x02 },
 303         { "EXTREQLCK",          0x10, 0x10 },
 304         { "MPARCKEN",           0x20, 0x20 },
 305         { "DPARCKEN",           0x40, 0x40 },
 306         { "CACHETHEN",          0x80, 0x80 }
 307 };
 308
 309 int
 310 ahd_dscommand0_print(u_int regvalue, u_int *cur_col, u_int wrap)
 311 {
 312         return (ahd_print_register(DSCOMMAND0_parse_table, 6, "DSCOMMAND0",
 313             0x19, regvalue, cur_col, wrap));
 314 }
 315
 316 static ahd_reg_parse_entry_t DFSTATUS_parse_table[] = {
 317         { "FIFOEMP",            0x01, 0x01 },
 318         { "FIFOFULL",           0x02, 0x02 },
 319         { "DFTHRESH",           0x04, 0x04 },
 320         { "HDONE",              0x08, 0x08 },
 321         { "MREQPEND",           0x10, 0x10 },
 322         { "PKT_PRELOAD_AVAIL",  0x40, 0x40 },
 323         { "PRELOAD_AVAIL",      0x80, 0x80 }
 324 };
 325
 326 int
 327 ahd_dfstatus_print(u_int regvalue, u_int *cur_col, u_int wrap)
 328 {
 329         return (ahd_print_register(DFSTATUS_parse_table, 7, "DFSTATUS",
 330             0x1a, regvalue, cur_col, wrap));
 331 }
 332
 333 static ahd_reg_parse_entry_t SG_CACHE_SHADOW_parse_table[] = {
 334         { "LAST_SEG_DONE",      0x01, 0x01 },
 335         { "LAST_SEG",           0x02, 0x02 },
 336         { "ODD_SEG",            0x04, 0x04 },
 337         { "SG_ADDR_MASK",       0xf8, 0xf8 }
 338 };
 339
 340 int
 341 ahd_sg_cache_shadow_print(u_int regvalue, u_int *cur_col, u_int wrap)
 342 {
 343         return (ahd_print_register(SG_CACHE_SHADOW_parse_table, 4, "SG_CACHE_SHADOW",
 344             0x1b, regvalue, cur_col, wrap));
 345 }
 346
 347 static ahd_reg_parse_entry_t ARBCTL_parse_table[] = {
 348         { "USE_TIME",           0x07, 0x07 },
 349         { "RETRY_SWEN",         0x08, 0x08 },
 350         { "RESET_HARB",         0x80, 0x80 }
 351 };
 352
 353 int
 354 ahd_arbctl_print(u_int regvalue, u_int *cur_col, u_int wrap)
 355 {
 356         return (ahd_print_register(ARBCTL_parse_table, 3, "ARBCTL",
 357             0x1b, regvalue, cur_col, wrap));
 358 }
 359
 360 static ahd_reg_parse_entry_t SG_CACHE_PRE_parse_table[] = {
 361         { "LAST_SEG",           0x02, 0x02 },
 362         { "ODD_SEG",            0x04, 0x04 },
 363         { "SG_ADDR_MASK",       0xf8, 0xf8 }
 364 };
 365
 366 int
 367 ahd_sg_cache_pre_print(u_int regvalue, u_int *cur_col, u_int wrap)
 368 {
 369         return (ahd_print_register(SG_CACHE_PRE_parse_table, 3, "SG_CACHE_PRE",
 370             0x1b, regvalue, cur_col, wrap));
 371 }
 372
 373 int
 374 ahd_lqin_print(u_int regvalue, u_int *cur_col, u_int wrap)
 375 {
 376         return (ahd_print_register(NULL, 0, "LQIN",
 377             0x20, regvalue, cur_col, wrap));
 378 }
 379
 380 int
 381 ahd_typeptr_print(u_int regvalue, u_int *cur_col, u_int wrap)
 382 {
 383         return (ahd_print_register(NULL, 0, "TYPEPTR",
 384             0x20, regvalue, cur_col, wrap));
 385 }
 386
 387 int
 388 ahd_tagptr_print(u_int regvalue, u_int *cur_col, u_int wrap)
 389 {
 390         return (ahd_print_register(NULL, 0, "TAGPTR",
 391             0x21, regvalue, cur_col, wrap));
 392 }
 393
 394 int
 395 ahd_lunptr_print(u_int regvalue, u_int *cur_col, u_int wrap)
 396 {
 397         return (ahd_print_register(NULL, 0, "LUNPTR",
 398             0x22, regvalue, cur_col, wrap));
 399 }
 400
 401 int
 402 ahd_datalenptr_print(u_int regvalue, u_int *cur_col, u_int wrap)
 403 {
 404         return (ahd_print_register(NULL, 0, "DATALENPTR",
 405             0x23, regvalue, cur_col, wrap));
 406 }
 407
 408 int
 409 ahd_statlenptr_print(u_int regvalue, u_int *cur_col, u_int wrap)
 410 {
 411         return (ahd_print_register(NULL, 0, "STATLENPTR",
 412             0x24, regvalue, cur_col, wrap));
 413 }
 414
 415 int
 416 ahd_cmdlenptr_print(u_int regvalue, u_int *cur_col, u_int wrap)
 417 {
 418         return (ahd_print_register(NULL, 0, "CMDLENPTR",
 419             0x25, regvalue, cur_col, wrap));
 420 }
 421
 422 int
 423 ahd_attrptr_print(u_int regvalue, u_int *cur_col, u_int wrap)
 424 {
 425         return (ahd_print_register(NULL, 0, "ATTRPTR",
 426             0x26, regvalue, cur_col, wrap));
 427 }
 428
 429 int
 430 ahd_flagptr_print(u_int regvalue, u_int *cur_col, u_int wrap)
 431 {
 432         return (ahd_print_register(NULL, 0, "FLAGPTR",
 433             0x27, regvalue, cur_col, wrap));
 434 }
 435
 436 int
 437 ahd_cmdptr_print(u_int regvalue, u_int *cur_col, u_int wrap)
 438 {
 439         return (ahd_print_register(NULL, 0, "CMDPTR",
 440             0x28, regvalue, cur_col, wrap));
 441 }
 442
 443 int
 444 ahd_qnextptr_print(u_int regvalue, u_int *cur_col, u_int wrap)
 445 {
 446         return (ahd_print_register(NULL, 0, "QNEXTPTR",
 447             0x29, regvalue, cur_col, wrap));
 448 }
 449
 450 int
 451 ahd_idptr_print(u_int regvalue, u_int *cur_col, u_int wrap)
 452 {
 453         return (ahd_print_register(NULL, 0, "IDPTR",
 454             0x2a, regvalue, cur_col, wrap));
 455 }
 456
 457 int
 458 ahd_abrtbyteptr_print(u_int regvalue, u_int *cur_col, u_int wrap)
 459 {
 460         return (ahd_print_register(NULL, 0, "ABRTBYTEPTR",
 461             0x2b, regvalue, cur_col, wrap));
 462 }
 463
 464 int
 465 ahd_abrtbitptr_print(u_int regvalue, u_int *cur_col, u_int wrap)
 466 {
 467         return (ahd_print_register(NULL, 0, "ABRTBITPTR",
 468             0x2c, regvalue, cur_col, wrap));
 469 }
 470
 471 int
 472 ahd_maxcmdbytes_print(u_int regvalue, u_int *cur_col, u_int wrap)
 473 {
 474         return (ahd_print_register(NULL, 0, "MAXCMDBYTES",
 475             0x2d, regvalue, cur_col, wrap));
 476 }
 477
 478 int
 479 ahd_maxcmd2rcv_print(u_int regvalue, u_int *cur_col, u_int wrap)
 480 {
 481         return (ahd_print_register(NULL, 0, "MAXCMD2RCV",
 482             0x2e, regvalue, cur_col, wrap));
 483 }
 484
 485 int
 486 ahd_shortthresh_print(u_int regvalue, u_int *cur_col, u_int wrap)
 487 {
 488         return (ahd_print_register(NULL, 0, "SHORTTHRESH",
 489             0x2f, regvalue, cur_col, wrap));
 490 }
 491
 492 int
 493 ahd_lunlen_print(u_int regvalue, u_int *cur_col, u_int wrap)
 494 {
 495         return (ahd_print_register(NULL, 0, "LUNLEN",
 496             0x30, regvalue, cur_col, wrap));
 497 }
 498
 499 int
 500 ahd_cdblimit_print(u_int regvalue, u_int *cur_col, u_int wrap)
 501 {
 502         return (ahd_print_register(NULL, 0, "CDBLIMIT",
 503             0x31, regvalue, cur_col, wrap));
 504 }
 505
 506 int
 507 ahd_maxcmd_print(u_int regvalue, u_int *cur_col, u_int wrap)
 508 {
 509         return (ahd_print_register(NULL, 0, "MAXCMD",
 510             0x32, regvalue, cur_col, wrap));
 511 }
 512
 513 int
 514 ahd_maxcmdcnt_print(u_int regvalue, u_int *cur_col, u_int wrap)
 515 {
 516         return (ahd_print_register(NULL, 0, "MAXCMDCNT",
 517             0x33, regvalue, cur_col, wrap));
 518 }
 519
 520 int
 521 ahd_lqrsvd01_print(u_int regvalue, u_int *cur_col, u_int wrap)
 522 {
 523         return (ahd_print_register(NULL, 0, "LQRSVD01",
 524             0x34, regvalue, cur_col, wrap));
 525 }
 526
 527 int
 528 ahd_lqrsvd16_print(u_int regvalue, u_int *cur_col, u_int wrap)
 529 {
 530         return (ahd_print_register(NULL, 0, "LQRSVD16",
 531             0x35, regvalue, cur_col, wrap));
 532 }
 533
 534 int
 535 ahd_lqrsvd17_print(u_int regvalue, u_int *cur_col, u_int wrap)
 536 {
 537         return (ahd_print_register(NULL, 0, "LQRSVD17",
 538             0x36, regvalue, cur_col, wrap));
 539 }
 540
 541 int
 542 ahd_cmdrsvd0_print(u_int regvalue, u_int *cur_col, u_int wrap)
 543 {
 544         return (ahd_print_register(NULL, 0, "CMDRSVD0",
 545             0x37, regvalue, cur_col, wrap));
 546 }
 547
 548 static ahd_reg_parse_entry_t LQCTL0_parse_table[] = {
 549         { "LQ0INITGCLT",        0x03, 0x03 },
 550         { "LQ0TARGCLT",         0x0c, 0x0c },
 551         { "LQIINITGCLT",        0x30, 0x30 },
 552         { "LQITARGCLT",         0xc0, 0xc0 }
 553 };
 554
 555 int
 556 ahd_lqctl0_print(u_int regvalue, u_int *cur_col, u_int wrap)
 557 {
 558         return (ahd_print_register(LQCTL0_parse_table, 4, "LQCTL0",
 559             0x38, regvalue, cur_col, wrap));
 560 }
 561
 562 static ahd_reg_parse_entry_t LQCTL1_parse_table[] = {
 563         { "ABORTPENDING",       0x01, 0x01 },
 564         { "SINGLECMD",          0x02, 0x02 },
 565         { "PCI2PCI",            0x04, 0x04 }
 566 };
 567
 568 int
 569 ahd_lqctl1_print(u_int regvalue, u_int *cur_col, u_int wrap)
 570 {
 571         return (ahd_print_register(LQCTL1_parse_table, 3, "LQCTL1",
 572             0x38, regvalue, cur_col, wrap));
 573 }
 574
 575 static ahd_reg_parse_entry_t SCSBIST0_parse_table[] = {
 576         { "OSBISTRUN",          0x01, 0x01 },
 577         { "OSBISTDONE",         0x02, 0x02 },
 578         { "OSBISTERR",          0x04, 0x04 },
 579         { "GSBISTRUN",          0x10, 0x10 },
 580         { "GSBISTDONE",         0x20, 0x20 },
 581         { "GSBISTERR",          0x40, 0x40 }
 582 };
 583
 584 int
 585 ahd_scsbist0_print(u_int regvalue, u_int *cur_col, u_int wrap)
 586 {
 587         return (ahd_print_register(SCSBIST0_parse_table, 6, "SCSBIST0",
 588             0x39, regvalue, cur_col, wrap));
 589 }
 590
 591 static ahd_reg_parse_entry_t LQCTL2_parse_table[] = {
 592         { "LQOPAUSE",           0x01, 0x01 },
 593         { "LQOTOIDLE",          0x02, 0x02 },
 594         { "LQOCONTINUE",        0x04, 0x04 },
 595         { "LQORETRY",           0x08, 0x08 },
 596         { "LQIPAUSE",           0x10, 0x10 },
 597         { "LQITOIDLE",          0x20, 0x20 },
 598         { "LQICONTINUE",        0x40, 0x40 },
 599         { "LQIRETRY",           0x80, 0x80 }
 600 };
 601
 602 int
 603 ahd_lqctl2_print(u_int regvalue, u_int *cur_col, u_int wrap)
 604 {
 605         return (ahd_print_register(LQCTL2_parse_table, 8, "LQCTL2",
 606             0x39, regvalue, cur_col, wrap));
 607 }
 608
 609 static ahd_reg_parse_entry_t SCSBIST1_parse_table[] = {
 610         { "NTBISTRUN",          0x01, 0x01 },
 611         { "NTBISTDONE",         0x02, 0x02 },
 612         { "NTBISTERR",          0x04, 0x04 }
 613 };
 614
 615 int
 616 ahd_scsbist1_print(u_int regvalue, u_int *cur_col, u_int wrap)
 617 {
 618         return (ahd_print_register(SCSBIST1_parse_table, 3, "SCSBIST1",
 619             0x3a, regvalue, cur_col, wrap));
 620 }
 621
 622 static ahd_reg_parse_entry_t SCSISEQ0_parse_table[] = {
 623         { "SCSIRSTO",           0x01, 0x01 },
 624         { "FORCEBUSFREE",       0x10, 0x10 },
 625         { "ENARBO",             0x20, 0x20 },
 626         { "ENSELO",             0x40, 0x40 },
 627         { "TEMODEO",            0x80, 0x80 }
 628 };
 629
 630 int
 631 ahd_scsiseq0_print(u_int regvalue, u_int *cur_col, u_int wrap)
 632 {
 633         return (ahd_print_register(SCSISEQ0_parse_table, 5, "SCSISEQ0",
 634             0x3a, regvalue, cur_col, wrap));
 635 }
 636
 637 static ahd_reg_parse_entry_t SCSISEQ1_parse_table[] = {
 638         { "ALTSTIM",            0x01, 0x01 },
 639         { "ENAUTOATNP",         0x02, 0x02 },
 640         { "MANUALP",            0x0c, 0x0c },
 641         { "ENRSELI",            0x10, 0x10 },
 642         { "ENSELI",             0x20, 0x20 },
 643         { "MANUALCTL",          0x40, 0x40 }
 644 };
 645
 646 int
 647 ahd_scsiseq1_print(u_int regvalue, u_int *cur_col, u_int wrap)
 648 {
 649         return (ahd_print_register(SCSISEQ1_parse_table, 6, "SCSISEQ1",
 650             0x3b, regvalue, cur_col, wrap));
 651 }
 652
 653 static ahd_reg_parse_entry_t SXFRCTL0_parse_table[] = {
 654         { "SPIOEN",             0x08, 0x08 },
 655         { "BIOSCANCELEN",       0x10, 0x10 },
 656         { "DFPEXP",             0x40, 0x40 },
 657         { "DFON",               0x80, 0x80 }
 658 };
 659
 660 int
 661 ahd_sxfrctl0_print(u_int regvalue, u_int *cur_col, u_int wrap)
 662 {
 663         return (ahd_print_register(SXFRCTL0_parse_table, 4, "SXFRCTL0",
 664             0x3c, regvalue, cur_col, wrap));
 665 }
 666
 667 int
 668 ahd_businitid_print(u_int regvalue, u_int *cur_col, u_int wrap)
 669 {
 670         return (ahd_print_register(NULL, 0, "BUSINITID",
 671             0x3c, regvalue, cur_col, wrap));
 672 }
 673
 674 int
 675 ahd_dlcount_print(u_int regvalue, u_int *cur_col, u_int wrap)
 676 {
 677         return (ahd_print_register(NULL, 0, "DLCOUNT",
 678             0x3c, regvalue, cur_col, wrap));
 679 }
 680
 681 static ahd_reg_parse_entry_t SXFRCTL1_parse_table[] = {
 682         { "STPWEN",             0x01, 0x01 },
 683         { "ACTNEGEN",           0x02, 0x02 },
 684         { "ENSTIMER",           0x04, 0x04 },
 685         { "STIMESEL",           0x18, 0x18 },
 686         { "ENSPCHK",            0x20, 0x20 },
 687         { "ENSACHK",            0x40, 0x40 },
 688         { "BITBUCKET",          0x80, 0x80 }
 689 };
 690
 691 int
 692 ahd_sxfrctl1_print(u_int regvalue, u_int *cur_col, u_int wrap)
 693 {
 694         return (ahd_print_register(SXFRCTL1_parse_table, 7, "SXFRCTL1",
 695             0x3d, regvalue, cur_col, wrap));
 696 }
 697
 698 int
 699 ahd_bustargid_print(u_int regvalue, u_int *cur_col, u_int wrap)
 700 {
 701         return (ahd_print_register(NULL, 0, "BUSTARGID",
 702             0x3e, regvalue, cur_col, wrap));
 703 }
 704
 705 static ahd_reg_parse_entry_t SXFRCTL2_parse_table[] = {
 706         { "ASU",                0x07, 0x07 },
 707         { "CMDDMAEN",           0x08, 0x08 },
 708         { "AUTORSTDIS",         0x10, 0x10 }
 709 };
 710
 711 int
 712 ahd_sxfrctl2_print(u_int regvalue, u_int *cur_col, u_int wrap)
 713 {
 714         return (ahd_print_register(SXFRCTL2_parse_table, 3, "SXFRCTL2",
 715             0x3e, regvalue, cur_col, wrap));
 716 }
 717
 718 static ahd_reg_parse_entry_t DFFSTAT_parse_table[] = {
 719         { "CURRFIFO_0",         0x00, 0x03 },
 720         { "CURRFIFO_1",         0x01, 0x03 },
 721         { "CURRFIFO_NONE",      0x03, 0x03 },
 722         { "FIFO0FREE",          0x10, 0x10 },
 723         { "FIFO1FREE",          0x20, 0x20 },
 724         { "CURRFIFO",           0x03, 0x03 }
 725 };
 726
 727 int
 728 ahd_dffstat_print(u_int regvalue, u_int *cur_col, u_int wrap)
 729 {
 730         return (ahd_print_register(DFFSTAT_parse_table, 6, "DFFSTAT",
 731             0x3f, regvalue, cur_col, wrap));
 732 }
 733
 734 static ahd_reg_parse_entry_t SCSISIGO_parse_table[] = {
 735         { "P_DATAOUT",          0x00, 0xe0 },
 736         { "P_DATAOUT_DT",       0x20, 0xe0 },
 737         { "P_DATAIN",           0x40, 0xe0 },
 738         { "P_DATAIN_DT",        0x60, 0xe0 },
 739         { "P_COMMAND",          0x80, 0xe0 },
 740         { "P_MESGOUT",          0xa0, 0xe0 },
 741         { "P_STATUS",           0xc0, 0xe0 },
 742         { "P_MESGIN",           0xe0, 0xe0 },
 743         { "ACKO",               0x01, 0x01 },
 744         { "REQO",               0x02, 0x02 },
 745         { "BSYO",               0x04, 0x04 },
 746         { "SELO",               0x08, 0x08 },
 747         { "ATNO",               0x10, 0x10 },
 748         { "MSGO",               0x20, 0x20 },
 749         { "IOO",                0x40, 0x40 },
 750         { "CDO",                0x80, 0x80 },
 751         { "PHASE_MASK",         0xe0, 0xe0 }
 752 };
 753
 754 int
 755 ahd_scsisigo_print(u_int regvalue, u_int *cur_col, u_int wrap)
 756 {
 757         return (ahd_print_register(SCSISIGO_parse_table, 17, "SCSISIGO",
 758             0x40, regvalue, cur_col, wrap));
 759 }
 760
 761 int
 762 ahd_multargid_print(u_int regvalue, u_int *cur_col, u_int wrap)
 763 {
 764         return (ahd_print_register(NULL, 0, "MULTARGID",
 765             0x40, regvalue, cur_col, wrap));
 766 }
 767
 768 static ahd_reg_parse_entry_t SCSISIGI_parse_table[] = {
 769         { "P_DATAOUT",          0x00, 0xe0 },
 770         { "P_DATAOUT_DT",       0x20, 0xe0 },
 771         { "P_DATAIN",           0x40, 0xe0 },
 772         { "P_DATAIN_DT",        0x60, 0xe0 },
 773         { "P_COMMAND",          0x80, 0xe0 },
 774         { "P_MESGOUT",          0xa0, 0xe0 },
 775         { "P_STATUS",           0xc0, 0xe0 },
 776         { "P_MESGIN",           0xe0, 0xe0 },
 777         { "ACKI",               0x01, 0x01 },
 778         { "REQI",               0x02, 0x02 },
 779         { "BSYI",               0x04, 0x04 },
 780         { "SELI",               0x08, 0x08 },
 781         { "ATNI",               0x10, 0x10 },
 782         { "MSGI",               0x20, 0x20 },
 783         { "IOI",                0x40, 0x40 },
 784         { "CDI",                0x80, 0x80 },
 785         { "PHASE_MASK",         0xe0, 0xe0 }
 786 };
 787
 788 int
 789 ahd_scsisigi_print(u_int regvalue, u_int *cur_col, u_int wrap)
 790 {
 791         return (ahd_print_register(SCSISIGI_parse_table, 17, "SCSISIGI",
 792             0x41, regvalue, cur_col, wrap));
 793 }
 794
 795 static ahd_reg_parse_entry_t SCSIPHASE_parse_table[] = {
 796         { "DATA_OUT_PHASE",     0x01, 0x03 },
 797         { "DATA_IN_PHASE",      0x02, 0x03 },
 798         { "DATA_PHASE_MASK",    0x03, 0x03 },
 799         { "MSG_OUT_PHASE",      0x04, 0x04 },
 800         { "MSG_IN_PHASE",       0x08, 0x08 },
 801         { "COMMAND_PHASE",      0x10, 0x10 },
 802         { "STATUS_PHASE",       0x20, 0x20 }
 803 };
 804
 805 int
 806 ahd_scsiphase_print(u_int regvalue, u_int *cur_col, u_int wrap)
 807 {
 808         return (ahd_print_register(SCSIPHASE_parse_table, 7, "SCSIPHASE",
 809             0x42, regvalue, cur_col, wrap));
 810 }
 811
 812 int
 813 ahd_scsidat0_img_print(u_int regvalue, u_int *cur_col, u_int wrap)
 814 {
 815         return (ahd_print_register(NULL, 0, "SCSIDAT0_IMG",
 816             0x43, regvalue, cur_col, wrap));
 817 }
 818
 819 int
 820 ahd_scsidat_print(u_int regvalue, u_int *cur_col, u_int wrap)
 821 {
 822         return (ahd_print_register(NULL, 0, "SCSIDAT",
 823             0x44, regvalue, cur_col, wrap));
 824 }
 825
 826 int
 827 ahd_scsibus_print(u_int regvalue, u_int *cur_col, u_int wrap)
 828 {
 829         return (ahd_print_register(NULL, 0, "SCSIBUS",
 830             0x46, regvalue, cur_col, wrap));
 831 }
 832
 833 static ahd_reg_parse_entry_t TARGIDIN_parse_table[] = {
 834         { "TARGID",             0x0f, 0x0f },
 835         { "CLKOUT",             0x80, 0x80 }
 836 };
 837
 838 int
 839 ahd_targidin_print(u_int regvalue, u_int *cur_col, u_int wrap)
 840 {
 841         return (ahd_print_register(TARGIDIN_parse_table, 2, "TARGIDIN",
 842             0x48, regvalue, cur_col, wrap));
 843 }
 844
 845 static ahd_reg_parse_entry_t SELID_parse_table[] = {
 846         { "ONEBIT",             0x08, 0x08 },
 847         { "SELID_MASK",         0xf0, 0xf0 }
 848 };
 849
 850 int
 851 ahd_selid_print(u_int regvalue, u_int *cur_col, u_int wrap)
 852 {
 853         return (ahd_print_register(SELID_parse_table, 2, "SELID",
 854             0x49, regvalue, cur_col, wrap));
 855 }
 856
 857 static ahd_reg_parse_entry_t SBLKCTL_parse_table[] = {
 858         { "SELWIDE",            0x02, 0x02 },
 859         { "ENAB20",             0x04, 0x04 },
 860         { "ENAB40",             0x08, 0x08 },
 861         { "DIAGLEDON",          0x40, 0x40 },
 862         { "DIAGLEDEN",          0x80, 0x80 }
 863 };
 864
 865 int
 866 ahd_sblkctl_print(u_int regvalue, u_int *cur_col, u_int wrap)
 867 {
 868         return (ahd_print_register(SBLKCTL_parse_table, 5, "SBLKCTL",
 869             0x4a, regvalue, cur_col, wrap));
 870 }
 871
 872 static ahd_reg_parse_entry_t OPTIONMODE_parse_table[] = {
 873         { "AUTO_MSGOUT_DE",     0x02, 0x02 },
 874         { "ENDGFORMCHK",        0x04, 0x04 },
 875         { "BUSFREEREV",         0x10, 0x10 },
 876         { "BIASCANCTL",         0x20, 0x20 },
 877         { "AUTOACKEN",          0x40, 0x40 },
 878         { "BIOSCANCTL",         0x80, 0x80 },
 879         { "OPTIONMODE_DEFAULTS",0x02, 0x02 }
 880 };
 881
 882 int
 883 ahd_optionmode_print(u_int regvalue, u_int *cur_col, u_int wrap)
 884 {
 885         return (ahd_print_register(OPTIONMODE_parse_table, 7, "OPTIONMODE",
 886             0x4a, regvalue, cur_col, wrap));
 887 }
 888
 889 static ahd_reg_parse_entry_t SSTAT0_parse_table[] = {
 890         { "ARBDO",              0x01, 0x01 },
 891         { "SPIORDY",            0x02, 0x02 },
 892         { "OVERRUN",            0x04, 0x04 },
 893         { "IOERR",              0x08, 0x08 },
 894         { "SELINGO",            0x10, 0x10 },
 895         { "SELDI",              0x20, 0x20 },
 896         { "SELDO",              0x40, 0x40 },
 897         { "TARGET",             0x80, 0x80 }
 898 };
 899
 900 int
 901 ahd_sstat0_print(u_int regvalue, u_int *cur_col, u_int wrap)
 902 {
 903         return (ahd_print_register(SSTAT0_parse_table, 8, "SSTAT0",
 904             0x4b, regvalue, cur_col, wrap));
 905 }
 906
 907 static ahd_reg_parse_entry_t CLRSINT0_parse_table[] = {
 908         { "CLRARBDO",           0x01, 0x01 },
 909         { "CLRSPIORDY",         0x02, 0x02 },
 910         { "CLROVERRUN",         0x04, 0x04 },
 911         { "CLRIOERR",           0x08, 0x08 },
 912         { "CLRSELINGO",         0x10, 0x10 },
 913         { "CLRSELDI",           0x20, 0x20 },
 914         { "CLRSELDO",           0x40, 0x40 }
 915 };
 916
 917 int
 918 ahd_clrsint0_print(u_int regvalue, u_int *cur_col, u_int wrap)
 919 {
 920         return (ahd_print_register(CLRSINT0_parse_table, 7, "CLRSINT0",
 921             0x4b, regvalue, cur_col, wrap));
 922 }
 923
 924 static ahd_reg_parse_entry_t SIMODE0_parse_table[] = {
 925         { "ENARBDO",            0x01, 0x01 },
 926         { "ENSPIORDY",          0x02, 0x02 },
 927         { "ENOVERRUN",          0x04, 0x04 },
 928         { "ENIOERR",            0x08, 0x08 },
 929         { "ENSELINGO",          0x10, 0x10 },
 930         { "ENSELDI",            0x20, 0x20 },
 931         { "ENSELDO",            0x40, 0x40 }
 932 };
 933
 934 int
 935 ahd_simode0_print(u_int regvalue, u_int *cur_col, u_int wrap)
 936 {
 937         return (ahd_print_register(SIMODE0_parse_table, 7, "SIMODE0",
 938             0x4b, regvalue, cur_col, wrap));
 939 }
 940
 941 static ahd_reg_parse_entry_t CLRSINT1_parse_table[] = {
 942         { "CLRREQINIT",         0x01, 0x01 },
 943         { "CLRSTRB2FAST",       0x02, 0x02 },
 944         { "CLRSCSIPERR",        0x04, 0x04 },
 945         { "CLRBUSFREE",         0x08, 0x08 },
 946         { "CLRSCSIRSTI",        0x20, 0x20 },
 947         { "CLRATNO",            0x40, 0x40 },
 948         { "CLRSELTIMEO",        0x80, 0x80 }
 949 };
 950
 951 int
 952 ahd_clrsint1_print(u_int regvalue, u_int *cur_col, u_int wrap)
 953 {
 954         return (ahd_print_register(CLRSINT1_parse_table, 7, "CLRSINT1",
 955             0x4c, regvalue, cur_col, wrap));
 956 }
 957
 958 static ahd_reg_parse_entry_t SSTAT1_parse_table[] = {
 959         { "REQINIT",            0x01, 0x01 },
 960         { "STRB2FAST",          0x02, 0x02 },
 961         { "SCSIPERR",           0x04, 0x04 },
 962         { "BUSFREE",            0x08, 0x08 },
 963         { "PHASEMIS",           0x10, 0x10 },
 964         { "SCSIRSTI",           0x20, 0x20 },
 965         { "ATNTARG",            0x40, 0x40 },
 966         { "SELTO",              0x80, 0x80 }
 967 };
 968
 969 int
 970 ahd_sstat1_print(u_int regvalue, u_int *cur_col, u_int wrap)
 971 {
 972         return (ahd_print_register(SSTAT1_parse_table, 8, "SSTAT1",
 973             0x4c, regvalue, cur_col, wrap));
 974 }
 975
 976 static ahd_reg_parse_entry_t SSTAT2_parse_table[] = {
 977         { "BUSFREE_LQO",        0x40, 0xc0 },
 978         { "BUSFREE_DFF0",       0x80, 0xc0 },
 979         { "BUSFREE_DFF1",       0xc0, 0xc0 },
 980         { "DMADONE",            0x01, 0x01 },
 981         { "SDONE",              0x02, 0x02 },
 982         { "WIDE_RES",           0x04, 0x04 },
 983         { "BSYX",               0x08, 0x08 },
 984         { "EXP_ACTIVE",         0x10, 0x10 },
 985         { "NONPACKREQ",         0x20, 0x20 },
 986         { "BUSFREETIME",        0xc0, 0xc0 }
 987 };
 988
 989 int
 990 ahd_sstat2_print(u_int regvalue, u_int *cur_col, u_int wrap)
 991 {
 992         return (ahd_print_register(SSTAT2_parse_table, 10, "SSTAT2",
 993             0x4d, regvalue, cur_col, wrap));
 994 }
 995
 996 static ahd_reg_parse_entry_t CLRSINT2_parse_table[] = {
 997         { "CLRDMADONE",         0x01, 0x01 },
 998         { "CLRSDONE",           0x02, 0x02 },
 999         { "CLRWIDE_RES",        0x04, 0x04 },
1000         { "CLRNONPACKREQ",      0x20, 0x20 }
1001 };
1002
1003 int
1004 ahd_clrsint2_print(u_int regvalue, u_int *cur_col, u_int wrap)
1005 {
1006         return (ahd_print_register(CLRSINT2_parse_table, 4, "CLRSINT2",
1007             0x4d, regvalue, cur_col, wrap));
1008 }
1009
1010 static ahd_reg_parse_entry_t SIMODE2_parse_table[] = {
1011         { "ENDMADONE",          0x01, 0x01 },
1012         { "ENSDONE",            0x02, 0x02 },
1013         { "ENWIDE_RES",         0x04, 0x04 }
1014 };
1015
1016 int
1017 ahd_simode2_print(u_int regvalue, u_int *cur_col, u_int wrap)
1018 {
1019         return (ahd_print_register(SIMODE2_parse_table, 3, "SIMODE2",
1020             0x4d, regvalue, cur_col, wrap));
1021 }
1022
1023 static ahd_reg_parse_entry_t PERRDIAG_parse_table[] = {
1024         { "DTERR",              0x01, 0x01 },
1025         { "DGFORMERR",          0x02, 0x02 },
1026         { "CRCERR",             0x04, 0x04 },
1027         { "AIPERR",             0x08, 0x08 },
1028         { "PARITYERR",          0x10, 0x10 },
1029         { "PREVPHASE",          0x20, 0x20 },
1030         { "HIPERR",             0x40, 0x40 },
1031         { "HIZERO",             0x80, 0x80 }
1032 };
1033
1034 int
1035 ahd_perrdiag_print(u_int regvalue, u_int *cur_col, u_int wrap)
1036 {
1037         return (ahd_print_register(PERRDIAG_parse_table, 8, "PERRDIAG",
1038             0x4e, regvalue, cur_col, wrap));
1039 }
1040
1041 int
1042 ahd_lqistate_print(u_int regvalue, u_int *cur_col, u_int wrap)
1043 {
1044         return (ahd_print_register(NULL, 0, "LQISTATE",
1045             0x4e, regvalue, cur_col, wrap));
1046 }
1047
1048 int
1049 ahd_soffcnt_print(u_int regvalue, u_int *cur_col, u_int wrap)
1050 {
1051         return (ahd_print_register(NULL, 0, "SOFFCNT",
1052             0x4f, regvalue, cur_col, wrap));
1053 }
1054
1055 int
1056 ahd_lqostate_print(u_int regvalue, u_int *cur_col, u_int wrap)
1057 {
1058         return (ahd_print_register(NULL, 0, "LQOSTATE",
1059             0x4f, regvalue, cur_col, wrap));
1060 }
1061
1062 static ahd_reg_parse_entry_t LQISTAT0_parse_table[] = {
1063         { "LQIATNCMD",          0x01, 0x01 },
1064         { "LQIATNLQ",           0x02, 0x02 },
1065         { "LQIBADLQT",          0x04, 0x04 },
1066         { "LQICRCT2",           0x08, 0x08 },
1067         { "LQICRCT1",           0x10, 0x10 },
1068         { "LQIATNQAS",          0x20, 0x20 }
1069 };
1070
1071 int
1072 ahd_lqistat0_print(u_int regvalue, u_int *cur_col, u_int wrap)
1073 {
1074         return (ahd_print_register(LQISTAT0_parse_table, 6, "LQISTAT0",
1075             0x50, regvalue, cur_col, wrap));
1076 }
1077
1078 static ahd_reg_parse_entry_t CLRLQIINT0_parse_table[] = {
1079         { "CLRLQIATNCMD",       0x01, 0x01 },
1080         { "CLRLQIATNLQ",        0x02, 0x02 },
1081         { "CLRLQIBADLQT",       0x04, 0x04 },
1082         { "CLRLQICRCT2",        0x08, 0x08 },
1083         { "CLRLQICRCT1",        0x10, 0x10 },
1084         { "CLRLQIATNQAS",       0x20, 0x20 }
1085 };
1086
1087 int
1088 ahd_clrlqiint0_print(u_int regvalue, u_int *cur_col, u_int wrap)
1089 {
1090         return (ahd_print_register(CLRLQIINT0_parse_table, 6, "CLRLQIINT0",
1091             0x50, regvalue, cur_col, wrap));
1092 }
1093
1094 static ahd_reg_parse_entry_t LQIMODE0_parse_table[] = {
1095         { "ENLQIATNCMD",        0x01, 0x01 },
1096         { "ENLQIATNLQ",         0x02, 0x02 },
1097         { "ENLQIBADLQT",        0x04, 0x04 },
1098         { "ENLQICRCT2",         0x08, 0x08 },
1099         { "ENLQICRCT1",         0x10, 0x10 },
1100         { "ENLQIATNQASK",       0x20, 0x20 }
1101 };
1102
1103 int
1104 ahd_lqimode0_print(u_int regvalue, u_int *cur_col, u_int wrap)
1105 {
1106         return (ahd_print_register(LQIMODE0_parse_table, 6, "LQIMODE0",
1107             0x50, regvalue, cur_col, wrap));
1108 }
1109
1110 static ahd_reg_parse_entry_t LQIMODE1_parse_table[] = {
1111         { "ENLQIOVERI_NLQ",     0x01, 0x01 },
1112         { "ENLQIOVERI_LQ",      0x02, 0x02 },
1113         { "ENLQIBADLQI",        0x04, 0x04 },
1114         { "ENLQICRCI_NLQ",      0x08, 0x08 },
1115         { "ENLQICRCI_LQ",       0x10, 0x10 },
1116         { "ENLIQABORT",         0x20, 0x20 },
1117         { "ENLQIPHASE_NLQ",     0x40, 0x40 },
1118         { "ENLQIPHASE_LQ",      0x80, 0x80 }
1119 };
1120
1121 int
1122 ahd_lqimode1_print(u_int regvalue, u_int *cur_col, u_int wrap)
1123 {
1124         return (ahd_print_register(LQIMODE1_parse_table, 8, "LQIMODE1",
1125             0x51, regvalue, cur_col, wrap));
1126 }
1127
1128 static ahd_reg_parse_entry_t LQISTAT1_parse_table[] = {
1129         { "LQIOVERI_NLQ",       0x01, 0x01 },
1130         { "LQIOVERI_LQ",        0x02, 0x02 },
1131         { "LQIBADLQI",          0x04, 0x04 },
1132         { "LQICRCI_NLQ",        0x08, 0x08 },
1133         { "LQICRCI_LQ",         0x10, 0x10 },
1134         { "LQIABORT",           0x20, 0x20 },
1135         { "LQIPHASE_NLQ",       0x40, 0x40 },
1136         { "LQIPHASE_LQ",        0x80, 0x80 }
1137 };
1138
1139 int
1140 ahd_lqistat1_print(u_int regvalue, u_int *cur_col, u_int wrap)
1141 {
1142         return (ahd_print_register(LQISTAT1_parse_table, 8, "LQISTAT1",
1143             0x51, regvalue, cur_col, wrap));
1144 }
1145
1146 static ahd_reg_parse_entry_t CLRLQIINT1_parse_table[] = {
1147         { "CLRLQIOVERI_NLQ",    0x01, 0x01 },
1148         { "CLRLQIOVERI_LQ",     0x02, 0x02 },
1149         { "CLRLQIBADLQI",       0x04, 0x04 },
1150         { "CLRLQICRCI_NLQ",     0x08, 0x08 },
1151         { "CLRLQICRCI_LQ",      0x10, 0x10 },
1152         { "CLRLIQABORT",        0x20, 0x20 },
1153         { "CLRLQIPHASE_NLQ",    0x40, 0x40 },
1154         { "CLRLQIPHASE_LQ",     0x80, 0x80 }
1155 };
1156
1157 int
1158 ahd_clrlqiint1_print(u_int regvalue, u_int *cur_col, u_int wrap)
1159 {
1160         return (ahd_print_register(CLRLQIINT1_parse_table, 8, "CLRLQIINT1",
1161             0x51, regvalue, cur_col, wrap));
1162 }
1163
1164 static ahd_reg_parse_entry_t LQISTAT2_parse_table[] = {
1165         { "LQIGSAVAIL",         0x01, 0x01 },
1166         { "LQISTOPCMD",         0x02, 0x02 },
1167         { "LQISTOPLQ",          0x04, 0x04 },
1168         { "LQISTOPPKT",         0x08, 0x08 },
1169         { "LQIWAITFIFO",        0x10, 0x10 },
1170         { "LQIWORKONLQ",        0x20, 0x20 },
1171         { "LQIPHASE_OUTPKT",    0x40, 0x40 },
1172         { "PACKETIZED",         0x80, 0x80 }
1173 };
1174
1175 int
1176 ahd_lqistat2_print(u_int regvalue, u_int *cur_col, u_int wrap)
1177 {
1178         return (ahd_print_register(LQISTAT2_parse_table, 8, "LQISTAT2",
1179             0x52, regvalue, cur_col, wrap));
1180 }
1181
1182 static ahd_reg_parse_entry_t SSTAT3_parse_table[] = {
1183         { "OSRAMPERR",          0x01, 0x01 },
1184         { "NTRAMPERR",          0x02, 0x02 }
1185 };
1186
1187 int
1188 ahd_sstat3_print(u_int regvalue, u_int *cur_col, u_int wrap)
1189 {
1190         return (ahd_print_register(SSTAT3_parse_table, 2, "SSTAT3",
1191             0x53, regvalue, cur_col, wrap));
1192 }
1193
1194 static ahd_reg_parse_entry_t SIMODE3_parse_table[] = {
1195         { "ENOSRAMPERR",        0x01, 0x01 },
1196         { "ENNTRAMPERR",        0x02, 0x02 }
1197 };
1198
1199 int
1200 ahd_simode3_print(u_int regvalue, u_int *cur_col, u_int wrap)
1201 {
1202         return (ahd_print_register(SIMODE3_parse_table, 2, "SIMODE3",
1203             0x53, regvalue, cur_col, wrap));
1204 }
1205
1206 static ahd_reg_parse_entry_t CLRSINT3_parse_table[] = {
1207         { "CLROSRAMPERR",       0x01, 0x01 },
1208         { "CLRNTRAMPERR",       0x02, 0x02 }
1209 };
1210
1211 int
1212 ahd_clrsint3_print(u_int regvalue, u_int *cur_col, u_int wrap)
1213 {
1214         return (ahd_print_register(CLRSINT3_parse_table, 2, "CLRSINT3",
1215             0x53, regvalue, cur_col, wrap));
1216 }
1217
1218 static ahd_reg_parse_entry_t LQOMODE0_parse_table[] = {
1219         { "ENLQOTCRC",          0x01, 0x01 },
1220         { "ENLQOATNPKT",        0x02, 0x02 },
1221         { "ENLQOATNLQ",         0x04, 0x04 },
1222         { "ENLQOSTOPT2",        0x08, 0x08 },
1223         { "ENLQOTARGSCBPERR",   0x10, 0x10 }
1224 };
1225
1226 int
1227 ahd_lqomode0_print(u_int regvalue, u_int *cur_col, u_int wrap)
1228 {
1229         return (ahd_print_register(LQOMODE0_parse_table, 5, "LQOMODE0",
1230             0x54, regvalue, cur_col, wrap));
1231 }
1232
1233 static ahd_reg_parse_entry_t LQOSTAT0_parse_table[] = {
1234         { "LQOTCRC",            0x01, 0x01 },
1235         { "LQOATNPKT",          0x02, 0x02 },
1236         { "LQOATNLQ",           0x04, 0x04 },
1237         { "LQOSTOPT2",          0x08, 0x08 },
1238         { "LQOTARGSCBPERR",     0x10, 0x10 }
1239 };
1240
1241 int
1242 ahd_lqostat0_print(u_int regvalue, u_int *cur_col, u_int wrap)
1243 {
1244         return (ahd_print_register(LQOSTAT0_parse_table, 5, "LQOSTAT0",
1245             0x54, regvalue, cur_col, wrap));
1246 }
1247
1248 static ahd_reg_parse_entry_t CLRLQOINT0_parse_table[] = {
1249         { "CLRLQOTCRC",         0x01, 0x01 },
1250         { "CLRLQOATNPKT",       0x02, 0x02 },
1251         { "CLRLQOATNLQ",        0x04, 0x04 },
1252         { "CLRLQOSTOPT2",       0x08, 0x08 },
1253         { "CLRLQOTARGSCBPERR",  0x10, 0x10 }
1254 };
1255
1256 int
1257 ahd_clrlqoint0_print(u_int regvalue, u_int *cur_col, u_int wrap)
1258 {
1259         return (ahd_print_register(CLRLQOINT0_parse_table, 5, "CLRLQOINT0",
1260             0x54, regvalue, cur_col, wrap));
1261 }
1262
1263 static ahd_reg_parse_entry_t LQOSTAT1_parse_table[] = {
1264         { "LQOPHACHGINPKT",     0x01, 0x01 },
1265         { "LQOBUSFREE",         0x02, 0x02 },
1266         { "LQOBADQAS",          0x04, 0x04 },
1267         { "LQOSTOPI2",          0x08, 0x08 },
1268         { "LQOINITSCBPERR",     0x10, 0x10 }
1269 };
1270
1271 int
1272 ahd_lqostat1_print(u_int regvalue, u_int *cur_col, u_int wrap)
1273 {
1274         return (ahd_print_register(LQOSTAT1_parse_table, 5, "LQOSTAT1",
1275             0x55, regvalue, cur_col, wrap));
1276 }
1277
1278 static ahd_reg_parse_entry_t CLRLQOINT1_parse_table[] = {
1279         { "CLRLQOPHACHGINPKT",  0x01, 0x01 },
1280         { "CLRLQOBUSFREE",      0x02, 0x02 },
1281         { "CLRLQOBADQAS",       0x04, 0x04 },
1282         { "CLRLQOSTOPI2",       0x08, 0x08 },
1283         { "CLRLQOINITSCBPERR",  0x10, 0x10 }
1284 };
1285
1286 int
1287 ahd_clrlqoint1_print(u_int regvalue, u_int *cur_col, u_int wrap)
1288 {
1289         return (ahd_print_register(CLRLQOINT1_parse_table, 5, "CLRLQOINT1",
1290             0x55, regvalue, cur_col, wrap));
1291 }
1292
1293 static ahd_reg_parse_entry_t LQOMODE1_parse_table[] = {
1294         { "ENLQOPHACHGINPKT",   0x01, 0x01 },
1295         { "ENLQOBUSFREE",       0x02, 0x02 },
1296         { "ENLQOBADQAS",        0x04, 0x04 },
1297         { "ENLQOSTOPI2",        0x08, 0x08 },
1298         { "ENLQOINITSCBPERR",   0x10, 0x10 }
1299 };
1300
1301 int
1302 ahd_lqomode1_print(u_int regvalue, u_int *cur_col, u_int wrap)
1303 {
1304         return (ahd_print_register(LQOMODE1_parse_table, 5, "LQOMODE1",
1305             0x55, regvalue, cur_col, wrap));
1306 }
1307
1308 static ahd_reg_parse_entry_t LQOSTAT2_parse_table[] = {
1309         { "LQOSTOP0",           0x01, 0x01 },
1310         { "LQOPHACHGOUTPKT",    0x02, 0x02 },
1311         { "LQOWAITFIFO",        0x10, 0x10 },
1312         { "LQOPKT",             0xe0, 0xe0 }
1313 };
1314
1315 int
1316 ahd_lqostat2_print(u_int regvalue, u_int *cur_col, u_int wrap)
1317 {
1318         return (ahd_print_register(LQOSTAT2_parse_table, 4, "LQOSTAT2",
1319             0x56, regvalue, cur_col, wrap));
1320 }
1321
1322 int
1323 ahd_os_space_cnt_print(u_int regvalue, u_int *cur_col, u_int wrap)
1324 {
1325         return (ahd_print_register(NULL, 0, "OS_SPACE_CNT",
1326             0x56, regvalue, cur_col, wrap));
1327 }
1328
1329 static ahd_reg_parse_entry_t SIMODE1_parse_table[] = {
1330         { "ENREQINIT",          0x01, 0x01 },
1331         { "ENSTRB2FAST",        0x02, 0x02 },
1332         { "ENSCSIPERR",         0x04, 0x04 },
1333         { "ENBUSFREE",          0x08, 0x08 },
1334         { "ENPHASEMIS",         0x10, 0x10 },
1335         { "ENSCSIRST",          0x20, 0x20 },
1336         { "ENATNTARG",          0x40, 0x40 },
1337         { "ENSELTIMO",          0x80, 0x80 }
1338 };
1339
1340 int
1341 ahd_simode1_print(u_int regvalue, u_int *cur_col, u_int wrap)
1342 {
1343         return (ahd_print_register(SIMODE1_parse_table, 8, "SIMODE1",
1344             0x57, regvalue, cur_col, wrap));
1345 }
1346
1347 int
1348 ahd_gsfifo_print(u_int regvalue, u_int *cur_col, u_int wrap)
1349 {
1350         return (ahd_print_register(NULL, 0, "GSFIFO",
1351             0x58, regvalue, cur_col, wrap));
1352 }
1353
1354 static ahd_reg_parse_entry_t DFFSXFRCTL_parse_table[] = {
1355         { "RSTCHN",             0x01, 0x01 },
1356         { "CLRCHN",             0x02, 0x02 },
1357         { "CLRSHCNT",           0x04, 0x04 },
1358         { "DFFBITBUCKET",       0x08, 0x08 }
1359 };
1360
1361 int
1362 ahd_dffsxfrctl_print(u_int regvalue, u_int *cur_col, u_int wrap)
1363 {
1364         return (ahd_print_register(DFFSXFRCTL_parse_table, 4, "DFFSXFRCTL",
1365             0x5a, regvalue, cur_col, wrap));
1366 }
1367
1368 static ahd_reg_parse_entry_t LQOSCSCTL_parse_table[] = {
1369         { "LQONOCHKOVER",       0x01, 0x01 },
1370         { "LQOH2A_VERSION",     0x80, 0x80 }
1371 };
1372
1373 int
1374 ahd_lqoscsctl_print(u_int regvalue, u_int *cur_col, u_int wrap)
1375 {
1376         return (ahd_print_register(LQOSCSCTL_parse_table, 2, "LQOSCSCTL",
1377             0x5a, regvalue, cur_col, wrap));
1378 }
1379
1380 int
1381 ahd_nextscb_print(u_int regvalue, u_int *cur_col, u_int wrap)
1382 {
1383         return (ahd_print_register(NULL, 0, "NEXTSCB",
1384             0x5a, regvalue, cur_col, wrap));
1385 }
1386
1387 static ahd_reg_parse_entry_t CLRSEQINTSRC_parse_table[] = {
1388         { "CLRCFG4TCMD",        0x01, 0x01 },
1389         { "CLRCFG4ICMD",        0x02, 0x02 },
1390         { "CLRCFG4TSTAT",       0x04, 0x04 },
1391         { "CLRCFG4ISTAT",       0x08, 0x08 },
1392         { "CLRCFG4DATA",        0x10, 0x10 },
1393         { "CLRSAVEPTRS",        0x20, 0x20 },
1394         { "CLRCTXTDONE",        0x40, 0x40 }
1395 };
1396
1397 int
1398 ahd_clrseqintsrc_print(u_int regvalue, u_int *cur_col, u_int wrap)
1399 {
1400         return (ahd_print_register(CLRSEQINTSRC_parse_table, 7, "CLRSEQINTSRC",
1401             0x5b, regvalue, cur_col, wrap));
1402 }
1403
1404 static ahd_reg_parse_entry_t SEQINTSRC_parse_table[] = {
1405         { "CFG4TCMD",           0x01, 0x01 },
1406         { "CFG4ICMD",           0x02, 0x02 },
1407         { "CFG4TSTAT",          0x04, 0x04 },
1408         { "CFG4ISTAT",          0x08, 0x08 },
1409         { "CFG4DATA",           0x10, 0x10 },
1410         { "SAVEPTRS",           0x20, 0x20 },
1411         { "CTXTDONE",           0x40, 0x40 }
1412 };
1413
1414 int
1415 ahd_seqintsrc_print(u_int regvalue, u_int *cur_col, u_int wrap)
1416 {
1417         return (ahd_print_register(SEQINTSRC_parse_table, 7, "SEQINTSRC",
1418             0x5b, regvalue, cur_col, wrap));
1419 }
1420
1421 int
1422 ahd_currscb_print(u_int regvalue, u_int *cur_col, u_int wrap)
1423 {
1424         return (ahd_print_register(NULL, 0, "CURRSCB",
1425             0x5c, regvalue, cur_col, wrap));
1426 }
1427
1428 static ahd_reg_parse_entry_t SEQIMODE_parse_table[] = {
1429         { "ENCFG4TCMD",         0x01, 0x01 },
1430         { "ENCFG4ICMD",         0x02, 0x02 },
1431         { "ENCFG4TSTAT",        0x04, 0x04 },
1432         { "ENCFG4ISTAT",        0x08, 0x08 },
1433         { "ENCFG4DATA",         0x10, 0x10 },
1434         { "ENSAVEPTRS",         0x20, 0x20 },
1435         { "ENCTXTDONE",         0x40, 0x40 }
1436 };
1437
1438 int
1439 ahd_seqimode_print(u_int regvalue, u_int *cur_col, u_int wrap)
1440 {
1441         return (ahd_print_register(SEQIMODE_parse_table, 7, "SEQIMODE",
1442             0x5c, regvalue, cur_col, wrap));
1443 }
1444
1445 static ahd_reg_parse_entry_t MDFFSTAT_parse_table[] = {
1446         { "FIFOFREE",           0x01, 0x01 },
1447         { "DATAINFIFO",         0x02, 0x02 },
1448         { "DLZERO",             0x04, 0x04 },
1449         { "SHVALID",            0x08, 0x08 },
1450         { "LASTSDONE",          0x10, 0x10 },
1451         { "SHCNTMINUS1",        0x20, 0x20 },
1452         { "SHCNTNEGATIVE",      0x40, 0x40 }
1453 };
1454
1455 int
1456 ahd_mdffstat_print(u_int regvalue, u_int *cur_col, u_int wrap)
1457 {
1458         return (ahd_print_register(MDFFSTAT_parse_table, 7, "MDFFSTAT",
1459             0x5d, regvalue, cur_col, wrap));
1460 }
1461
1462 static ahd_reg_parse_entry_t CRCCONTROL_parse_table[] = {
1463         { "CRCVALCHKEN",        0x40, 0x40 }
1464 };
1465
1466 int
1467 ahd_crccontrol_print(u_int regvalue, u_int *cur_col, u_int wrap)
1468 {
1469         return (ahd_print_register(CRCCONTROL_parse_table, 1, "CRCCONTROL",
1470             0x5d, regvalue, cur_col, wrap));
1471 }
1472
1473 int
1474 ahd_dfftag_print(u_int regvalue, u_int *cur_col, u_int wrap)
1475 {
1476         return (ahd_print_register(NULL, 0, "DFFTAG",
1477             0x5e, regvalue, cur_col, wrap));
1478 }
1479
1480 int
1481 ahd_lastscb_print(u_int regvalue, u_int *cur_col, u_int wrap)
1482 {
1483         return (ahd_print_register(NULL, 0, "LASTSCB",
1484             0x5e, regvalue, cur_col, wrap));
1485 }
1486
1487 static ahd_reg_parse_entry_t SCSITEST_parse_table[] = {
1488         { "SEL_TXPLL_DEBUG",    0x04, 0x04 },
1489         { "CNTRTEST",           0x08, 0x08 }
1490 };
1491
1492 int
1493 ahd_scsitest_print(u_int regvalue, u_int *cur_col, u_int wrap)
1494 {
1495         return (ahd_print_register(SCSITEST_parse_table, 2, "SCSITEST",
1496             0x5e, regvalue, cur_col, wrap));
1497 }
1498
1499 static ahd_reg_parse_entry_t IOPDNCTL_parse_table[] = {
1500         { "PDN_DIFFSENSE",      0x01, 0x01 },
1501         { "PDN_IDIST",          0x04, 0x04 },
1502         { "DISABLE_OE",         0x80, 0x80 }
1503 };
1504
1505 int
1506 ahd_iopdnctl_print(u_int regvalue, u_int *cur_col, u_int wrap)
1507 {
1508         return (ahd_print_register(IOPDNCTL_parse_table, 3, "IOPDNCTL",
1509             0x5f, regvalue, cur_col, wrap));
1510 }
1511
1512 int
1513 ahd_shaddr_print(u_int regvalue, u_int *cur_col, u_int wrap)
1514 {
1515         return (ahd_print_register(NULL, 0, "SHADDR",
1516             0x60, regvalue, cur_col, wrap));
1517 }
1518
1519 int
1520 ahd_negoaddr_print(u_int regvalue, u_int *cur_col, u_int wrap)
1521 {
1522         return (ahd_print_register(NULL, 0, "NEGOADDR",
1523             0x60, regvalue, cur_col, wrap));
1524 }
1525
1526 int
1527 ahd_dgrpcrci_print(u_int regvalue, u_int *cur_col, u_int wrap)
1528 {
1529         return (ahd_print_register(NULL, 0, "DGRPCRCI",
1530             0x60, regvalue, cur_col, wrap));
1531 }
1532
1533 int
1534 ahd_negperiod_print(u_int regvalue, u_int *cur_col, u_int wrap)
1535 {
1536         return (ahd_print_register(NULL, 0, "NEGPERIOD",
1537             0x61, regvalue, cur_col, wrap));
1538 }
1539
1540 int
1541 ahd_packcrci_print(u_int regvalue, u_int *cur_col, u_int wrap)
1542 {
1543         return (ahd_print_register(NULL, 0, "PACKCRCI",
1544             0x62, regvalue, cur_col, wrap));
1545 }
1546
1547 int
1548 ahd_negoffset_print(u_int regvalue, u_int *cur_col, u_int wrap)
1549 {
1550         return (ahd_print_register(NULL, 0, "NEGOFFSET",
1551             0x62, regvalue, cur_col, wrap));
1552 }
1553
1554 static ahd_reg_parse_entry_t NEGPPROPTS_parse_table[] = {
1555         { "PPROPT_IUT",         0x01, 0x01 },
1556         { "PPROPT_DT",          0x02, 0x02 },
1557         { "PPROPT_QAS",         0x04, 0x04 },
1558         { "PPROPT_PACE",        0x08, 0x08 }
1559 };
1560
1561 int
1562 ahd_negppropts_print(u_int regvalue, u_int *cur_col, u_int wrap)
1563 {
1564         return (ahd_print_register(NEGPPROPTS_parse_table, 4, "NEGPPROPTS",
1565             0x63, regvalue, cur_col, wrap));
1566 }
1567
1568 static ahd_reg_parse_entry_t NEGCONOPTS_parse_table[] = {
1569         { "WIDEXFER",           0x01, 0x01 },
1570         { "ENAUTOATNO",         0x02, 0x02 },
1571         { "ENAUTOATNI",         0x04, 0x04 },
1572         { "ENSLOWCRC",          0x08, 0x08 },
1573         { "RTI_OVRDTRN",        0x10, 0x10 },
1574         { "RTI_WRTDIS",         0x20, 0x20 },
1575         { "ENSNAPSHOT",         0x40, 0x40 }
1576 };
1577
1578 int
1579 ahd_negconopts_print(u_int regvalue, u_int *cur_col, u_int wrap)
1580 {
1581         return (ahd_print_register(NEGCONOPTS_parse_table, 7, "NEGCONOPTS",
1582             0x64, regvalue, cur_col, wrap));
1583 }
1584
1585 int
1586 ahd_annexcol_print(u_int regvalue, u_int *cur_col, u_int wrap)
1587 {
1588         return (ahd_print_register(NULL, 0, "ANNEXCOL",
1589             0x65, regvalue, cur_col, wrap));
1590 }
1591
1592 static ahd_reg_parse_entry_t SCSCHKN_parse_table[] = {
1593         { "LSTSGCLRDIS",        0x01, 0x01 },
1594         { "SHVALIDSTDIS",       0x02, 0x02 },
1595         { "DFFACTCLR",          0x04, 0x04 },
1596         { "SDONEMSKDIS",        0x08, 0x08 },
1597         { "WIDERESEN",          0x10, 0x10 },
1598         { "CURRFIFODEF",        0x20, 0x20 },
1599         { "STSELSKIDDIS",       0x40, 0x40 }
1600 };
1601
1602 int
1603 ahd_scschkn_print(u_int regvalue, u_int *cur_col, u_int wrap)
1604 {
1605         return (ahd_print_register(SCSCHKN_parse_table, 7, "SCSCHKN",
1606             0x66, regvalue, cur_col, wrap));
1607 }
1608
1609 int
1610 ahd_annexdat_print(u_int regvalue, u_int *cur_col, u_int wrap)
1611 {
1612         return (ahd_print_register(NULL, 0, "ANNEXDAT",
1613             0x66, regvalue, cur_col, wrap));
1614 }
1615
1616 int
1617 ahd_iownid_print(u_int regvalue, u_int *cur_col, u_int wrap)
1618 {
1619         return (ahd_print_register(NULL, 0, "IOWNID",
1620             0x67, regvalue, cur_col, wrap));
1621 }
1622
1623 static ahd_reg_parse_entry_t PLL960CTL0_parse_table[] = {
1624         { "PLL_ENFBM",          0x01, 0x01 },
1625         { "PLL_DLPF",           0x02, 0x02 },
1626         { "PLL_ENLPF",          0x04, 0x04 },
1627         { "PLL_ENLUD",          0x08, 0x08 },
1628         { "PLL_NS",             0x30, 0x30 },
1629         { "PLL_PWDN",           0x40, 0x40 },
1630         { "PLL_VCOSEL",         0x80, 0x80 }
1631 };
1632
1633 int
1634 ahd_pll960ctl0_print(u_int regvalue, u_int *cur_col, u_int wrap)
1635 {
1636         return (ahd_print_register(PLL960CTL0_parse_table, 7, "PLL960CTL0",
1637             0x68, regvalue, cur_col, wrap));
1638 }
1639
1640 int
1641 ahd_shcnt_print(u_int regvalue, u_int *cur_col, u_int wrap)
1642 {
1643         return (ahd_print_register(NULL, 0, "SHCNT",
1644             0x68, regvalue, cur_col, wrap));
1645 }
1646
1647 int
1648 ahd_townid_print(u_int regvalue, u_int *cur_col, u_int wrap)
1649 {
1650         return (ahd_print_register(NULL, 0, "TOWNID",
1651             0x69, regvalue, cur_col, wrap));
1652 }
1653
1654 static ahd_reg_parse_entry_t PLL960CTL1_parse_table[] = {
1655         { "PLL_RST",            0x01, 0x01 },
1656         { "PLL_CNTCLR",         0x40, 0x40 },
1657         { "PLL_CNTEN",          0x80, 0x80 }
1658 };
1659
1660 int
1661 ahd_pll960ctl1_print(u_int regvalue, u_int *cur_col, u_int wrap)
1662 {
1663         return (ahd_print_register(PLL960CTL1_parse_table, 3, "PLL960CTL1",
1664             0x69, regvalue, cur_col, wrap));
1665 }
1666
1667 int
1668 ahd_pll960cnt0_print(u_int regvalue, u_int *cur_col, u_int wrap)
1669 {
1670         return (ahd_print_register(NULL, 0, "PLL960CNT0",
1671             0x6a, regvalue, cur_col, wrap));
1672 }
1673
1674 int
1675 ahd_xsig_print(u_int regvalue, u_int *cur_col, u_int wrap)
1676 {
1677         return (ahd_print_register(NULL, 0, "XSIG",
1678             0x6a, regvalue, cur_col, wrap));
1679 }
1680
1681 int
1682 ahd_seloid_print(u_int regvalue, u_int *cur_col, u_int wrap)
1683 {
1684         return (ahd_print_register(NULL, 0, "SELOID",
1685             0x6b, regvalue, cur_col, wrap));
1686 }
1687
1688 static ahd_reg_parse_entry_t PLL400CTL0_parse_table[] = {
1689         { "PLL_ENFBM",          0x01, 0x01 },
1690         { "PLL_DLPF",           0x02, 0x02 },
1691         { "PLL_ENLPF",          0x04, 0x04 },
1692         { "PLL_ENLUD",          0x08, 0x08 },
1693         { "PLL_NS",             0x30, 0x30 },
1694         { "PLL_PWDN",           0x40, 0x40 },
1695         { "PLL_VCOSEL",         0x80, 0x80 }
1696 };
1697
1698 int
1699 ahd_pll400ctl0_print(u_int regvalue, u_int *cur_col, u_int wrap)
1700 {
1701         return (ahd_print_register(PLL400CTL0_parse_table, 7, "PLL400CTL0",
1702             0x6c, regvalue, cur_col, wrap));
1703 }
1704
1705 int
1706 ahd_fairness_print(u_int regvalue, u_int *cur_col, u_int wrap)
1707 {
1708         return (ahd_print_register(NULL, 0, "FAIRNESS",
1709             0x6c, regvalue, cur_col, wrap));
1710 }
1711
1712 static ahd_reg_parse_entry_t PLL400CTL1_parse_table[] = {
1713         { "PLL_RST",            0x01, 0x01 },
1714         { "PLL_CNTCLR",         0x40, 0x40 },
1715         { "PLL_CNTEN",          0x80, 0x80 }
1716 };
1717
1718 int
1719 ahd_pll400ctl1_print(u_int regvalue, u_int *cur_col, u_int wrap)
1720 {
1721         return (ahd_print_register(PLL400CTL1_parse_table, 3, "PLL400CTL1",
1722             0x6d, regvalue, cur_col, wrap));
1723 }
1724
1725 int
1726 ahd_pll400cnt0_print(u_int regvalue, u_int *cur_col, u_int wrap)
1727 {
1728         return (ahd_print_register(NULL, 0, "PLL400CNT0",
1729             0x6e, regvalue, cur_col, wrap));
1730 }
1731
1732 int
1733 ahd_unfairness_print(u_int regvalue, u_int *cur_col, u_int wrap)
1734 {
1735         return (ahd_print_register(NULL, 0, "UNFAIRNESS",
1736             0x6e, regvalue, cur_col, wrap));
1737 }
1738
1739 int
1740 ahd_haddr_print(u_int regvalue, u_int *cur_col, u_int wrap)
1741 {
1742         return (ahd_print_register(NULL, 0, "HADDR",
1743             0x70, regvalue, cur_col, wrap));
1744 }
1745
1746 static ahd_reg_parse_entry_t PLLDELAY_parse_table[] = {
1747         { "SPLIT_DROP_REQ",     0x80, 0x80 }
1748 };
1749
1750 int
1751 ahd_plldelay_print(u_int regvalue, u_int *cur_col, u_int wrap)
1752 {
1753         return (ahd_print_register(PLLDELAY_parse_table, 1, "PLLDELAY",
1754             0x70, regvalue, cur_col, wrap));
1755 }
1756
1757 int
1758 ahd_hodmaadr_print(u_int regvalue, u_int *cur_col, u_int wrap)
1759 {
1760         return (ahd_print_register(NULL, 0, "HODMAADR",
1761             0x70, regvalue, cur_col, wrap));
1762 }
1763
1764 int
1765 ahd_hodmacnt_print(u_int regvalue, u_int *cur_col, u_int wrap)
1766 {
1767         return (ahd_print_register(NULL, 0, "HODMACNT",
1768             0x78, regvalue, cur_col, wrap));
1769 }
1770
1771 int
1772 ahd_hcnt_print(u_int regvalue, u_int *cur_col, u_int wrap)
1773 {
1774         return (ahd_print_register(NULL, 0, "HCNT",
1775             0x78, regvalue, cur_col, wrap));
1776 }
1777
1778 int
1779 ahd_hodmaen_print(u_int regvalue, u_int *cur_col, u_int wrap)
1780 {
1781         return (ahd_print_register(NULL, 0, "HODMAEN",
1782             0x7a, regvalue, cur_col, wrap));
1783 }
1784
1785 int
1786 ahd_sghaddr_print(u_int regvalue, u_int *cur_col, u_int wrap)
1787 {
1788         return (ahd_print_register(NULL, 0, "SGHADDR",
1789             0x7c, regvalue, cur_col, wrap));
1790 }
1791
1792 int
1793 ahd_scbhaddr_print(u_int regvalue, u_int *cur_col, u_int wrap)
1794 {
1795         return (ahd_print_register(NULL, 0, "SCBHADDR",
1796             0x7c, regvalue, cur_col, wrap));
1797 }
1798
1799 int
1800 ahd_sghcnt_print(u_int regvalue, u_int *cur_col, u_int wrap)
1801 {
1802         return (ahd_print_register(NULL, 0, "SGHCNT",
1803             0x84, regvalue, cur_col, wrap));
1804 }
1805
1806 int
1807 ahd_scbhcnt_print(u_int regvalue, u_int *cur_col, u_int wrap)
1808 {
1809         return (ahd_print_register(NULL, 0, "SCBHCNT",
1810             0x84, regvalue, cur_col, wrap));
1811 }
1812
1813 static ahd_reg_parse_entry_t DFF_THRSH_parse_table[] = {
1814         { "WR_DFTHRSH_MIN",     0x00, 0x70 },
1815         { "RD_DFTHRSH_MIN",     0x00, 0x07 },
1816         { "RD_DFTHRSH_25",      0x01, 0x07 },
1817         { "RD_DFTHRSH_50",      0x02, 0x07 },
1818         { "RD_DFTHRSH_63",      0x03, 0x07 },
1819         { "RD_DFTHRSH_75",      0x04, 0x07 },
1820         { "RD_DFTHRSH_85",      0x05, 0x07 },
1821         { "RD_DFTHRSH_90",      0x06, 0x07 },
1822         { "RD_DFTHRSH_MAX",     0x07, 0x07 },
1823         { "WR_DFTHRSH_25",      0x10, 0x70 },
1824         { "WR_DFTHRSH_50",      0x20, 0x70 },
1825         { "WR_DFTHRSH_63",      0x30, 0x70 },
1826         { "WR_DFTHRSH_75",      0x40, 0x70 },
1827         { "WR_DFTHRSH_85",      0x50, 0x70 },
1828         { "WR_DFTHRSH_90",      0x60, 0x70 },
1829         { "WR_DFTHRSH_MAX",     0x70, 0x70 },
1830         { "RD_DFTHRSH",         0x07, 0x07 },
1831         { "WR_DFTHRSH",         0x70, 0x70 }
1832 };
1833
1834 int
1835 ahd_dff_thrsh_print(u_int regvalue, u_int *cur_col, u_int wrap)
1836 {
1837         return (ahd_print_register(DFF_THRSH_parse_table, 18, "DFF_THRSH",
1838             0x88, regvalue, cur_col, wrap));
1839 }
1840
1841 int
1842 ahd_romaddr_print(u_int regvalue, u_int *cur_col, u_int wrap)
1843 {
1844         return (ahd_print_register(NULL, 0, "ROMADDR",
1845             0x8a, regvalue, cur_col, wrap));
1846 }
1847
1848 static ahd_reg_parse_entry_t ROMCNTRL_parse_table[] = {
1849         { "RDY",                0x01, 0x01 },
1850         { "REPEAT",             0x02, 0x02 },
1851         { "ROMSPD",             0x18, 0x18 },
1852         { "ROMOP",              0xe0, 0xe0 }
1853 };
1854
1855 int
1856 ahd_romcntrl_print(u_int regvalue, u_int *cur_col, u_int wrap)
1857 {
1858         return (ahd_print_register(ROMCNTRL_parse_table, 4, "ROMCNTRL",
1859             0x8d, regvalue, cur_col, wrap));
1860 }
1861
1862 int
1863 ahd_romdata_print(u_int regvalue, u_int *cur_col, u_int wrap)
1864 {
1865         return (ahd_print_register(NULL, 0, "ROMDATA",
1866             0x8e, regvalue, cur_col, wrap));
1867 }
1868
1869 static ahd_reg_parse_entry_t CMCRXMSG0_parse_table[] = {
1870         { "CFNUM",              0x07, 0x07 },
1871         { "CDNUM",              0xf8, 0xf8 }
1872 };
1873
1874 int
1875 ahd_cmcrxmsg0_print(u_int regvalue, u_int *cur_col, u_int wrap)
1876 {
1877         return (ahd_print_register(CMCRXMSG0_parse_table, 2, "CMCRXMSG0",
1878             0x90, regvalue, cur_col, wrap));
1879 }
1880
1881 static ahd_reg_parse_entry_t ROENABLE_parse_table[] = {
1882         { "DCH0ROEN",           0x01, 0x01 },
1883         { "DCH1ROEN",           0x02, 0x02 },
1884         { "SGROEN",             0x04, 0x04 },
1885         { "CMCROEN",            0x08, 0x08 },
1886         { "OVLYROEN",           0x10, 0x10 },
1887         { "MSIROEN",            0x20, 0x20 }
1888 };
1889
1890 int
1891 ahd_roenable_print(u_int regvalue, u_int *cur_col, u_int wrap)
1892 {
1893         return (ahd_print_register(ROENABLE_parse_table, 6, "ROENABLE",
1894             0x90, regvalue, cur_col, wrap));
1895 }
1896
1897 static ahd_reg_parse_entry_t OVLYRXMSG0_parse_table[] = {
1898         { "CFNUM",              0x07, 0x07 },
1899         { "CDNUM",              0xf8, 0xf8 }
1900 };
1901
1902 int
1903 ahd_ovlyrxmsg0_print(u_int regvalue, u_int *cur_col, u_int wrap)
1904 {
1905         return (ahd_print_register(OVLYRXMSG0_parse_table, 2, "OVLYRXMSG0",
1906             0x90, regvalue, cur_col, wrap));
1907 }
1908
1909 static ahd_reg_parse_entry_t DCHRXMSG0_parse_table[] = {
1910         { "CFNUM",              0x07, 0x07 },
1911         { "CDNUM",              0xf8, 0xf8 }
1912 };
1913
1914 int
1915 ahd_dchrxmsg0_print(u_int regvalue, u_int *cur_col, u_int wrap)
1916 {
1917         return (ahd_print_register(DCHRXMSG0_parse_table, 2, "DCHRXMSG0",
1918             0x90, regvalue, cur_col, wrap));
1919 }
1920
1921 static ahd_reg_parse_entry_t OVLYRXMSG1_parse_table[] = {
1922         { "CBNUM",              0xff, 0xff }
1923 };
1924
1925 int
1926 ahd_ovlyrxmsg1_print(u_int regvalue, u_int *cur_col, u_int wrap)
1927 {
1928         return (ahd_print_register(OVLYRXMSG1_parse_table, 1, "OVLYRXMSG1",
1929             0x91, regvalue, cur_col, wrap));
1930 }
1931
1932 static ahd_reg_parse_entry_t NSENABLE_parse_table[] = {
1933         { "DCH0NSEN",           0x01, 0x01 },
1934         { "DCH1NSEN",           0x02, 0x02 },
1935         { "SGNSEN",             0x04, 0x04 },
1936         { "CMCNSEN",            0x08, 0x08 },
1937         { "OVLYNSEN",           0x10, 0x10 },
1938         { "MSINSEN",            0x20, 0x20 }
1939 };
1940
1941 int
1942 ahd_nsenable_print(u_int regvalue, u_int *cur_col, u_int wrap)
1943 {
1944         return (ahd_print_register(NSENABLE_parse_table, 6, "NSENABLE",
1945             0x91, regvalue, cur_col, wrap));
1946 }
1947
1948 static ahd_reg_parse_entry_t DCHRXMSG1_parse_table[] = {
1949         { "CBNUM",              0xff, 0xff }
1950 };
1951
1952 int
1953 ahd_dchrxmsg1_print(u_int regvalue, u_int *cur_col, u_int wrap)
1954 {
1955         return (ahd_print_register(DCHRXMSG1_parse_table, 1, "DCHRXMSG1",
1956             0x91, regvalue, cur_col, wrap));
1957 }
1958
1959 static ahd_reg_parse_entry_t CMCRXMSG1_parse_table[] = {
1960         { "CBNUM",              0xff, 0xff }
1961 };
1962
1963 int
1964 ahd_cmcrxmsg1_print(u_int regvalue, u_int *cur_col, u_int wrap)
1965 {
1966         return (ahd_print_register(CMCRXMSG1_parse_table, 1, "CMCRXMSG1",
1967             0x91, regvalue, cur_col, wrap));
1968 }
1969
1970 static ahd_reg_parse_entry_t DCHRXMSG2_parse_table[] = {
1971         { "MINDEX",             0xff, 0xff }
1972 };
1973
1974 int
1975 ahd_dchrxmsg2_print(u_int regvalue, u_int *cur_col, u_int wrap)
1976 {
1977         return (ahd_print_register(DCHRXMSG2_parse_table, 1, "DCHRXMSG2",
1978             0x92, regvalue, cur_col, wrap));
1979 }
1980
1981 static ahd_reg_parse_entry_t OVLYRXMSG2_parse_table[] = {
1982         { "MINDEX",             0xff, 0xff }
1983 };
1984
1985 int
1986 ahd_ovlyrxmsg2_print(u_int regvalue, u_int *cur_col, u_int wrap)
1987 {
1988         return (ahd_print_register(OVLYRXMSG2_parse_table, 1, "OVLYRXMSG2",
1989             0x92, regvalue, cur_col, wrap));
1990 }
1991
1992 static ahd_reg_parse_entry_t CMCRXMSG2_parse_table[] = {
1993         { "MINDEX",             0xff, 0xff }
1994 };
1995
1996 int
1997 ahd_cmcrxmsg2_print(u_int regvalue, u_int *cur_col, u_int wrap)
1998 {
1999         return (ahd_print_register(CMCRXMSG2_parse_table, 1, "CMCRXMSG2",
2000             0x92, regvalue, cur_col, wrap));
2001 }
2002
2003 int
2004 ahd_ost_print(u_int regvalue, u_int *cur_col, u_int wrap)
2005 {
2006         return (ahd_print_register(NULL, 0, "OST",
2007             0x92, regvalue, cur_col, wrap));
2008 }
2009
2010 static ahd_reg_parse_entry_t DCHRXMSG3_parse_table[] = {
2011         { "MCLASS",             0x0f, 0x0f }
2012 };
2013
2014 int
2015 ahd_dchrxmsg3_print(u_int regvalue, u_int *cur_col, u_int wrap)
2016 {
2017         return (ahd_print_register(DCHRXMSG3_parse_table, 1, "DCHRXMSG3",
2018             0x93, regvalue, cur_col, wrap));
2019 }
2020
2021 static ahd_reg_parse_entry_t CMCRXMSG3_parse_table[] = {
2022         { "MCLASS",             0x0f, 0x0f }
2023 };
2024
2025 int
2026 ahd_cmcrxmsg3_print(u_int regvalue, u_int *cur_col, u_int wrap)
2027 {
2028         return (ahd_print_register(CMCRXMSG3_parse_table, 1, "CMCRXMSG3",
2029             0x93, regvalue, cur_col, wrap));
2030 }
2031
2032 static ahd_reg_parse_entry_t PCIXCTL_parse_table[] = {
2033         { "CMPABCDIS",          0x01, 0x01 },
2034         { "TSCSERREN",          0x02, 0x02 },
2035         { "SRSPDPEEN",          0x04, 0x04 },
2036         { "SPLTSTADIS",         0x08, 0x08 },
2037         { "SPLTSMADIS",         0x10, 0x10 },
2038         { "UNEXPSCIEN",         0x20, 0x20 },
2039         { "SERRPULSE",          0x80, 0x80 }
2040 };
2041
2042 int
2043 ahd_pcixctl_print(u_int regvalue, u_int *cur_col, u_int wrap)
2044 {
2045         return (ahd_print_register(PCIXCTL_parse_table, 7, "PCIXCTL",
2046             0x93, regvalue, cur_col, wrap));
2047 }
2048
2049 static ahd_reg_parse_entry_t OVLYRXMSG3_parse_table[] = {
2050         { "MCLASS",             0x0f, 0x0f }
2051 };
2052
2053 int
2054 ahd_ovlyrxmsg3_print(u_int regvalue, u_int *cur_col, u_int wrap)
2055 {
2056         return (ahd_print_register(OVLYRXMSG3_parse_table, 1, "OVLYRXMSG3",
2057             0x93, regvalue, cur_col, wrap));
2058 }
2059
2060 int
2061 ahd_ovlyseqbcnt_print(u_int regvalue, u_int *cur_col, u_int wrap)
2062 {
2063         return (ahd_print_register(NULL, 0, "OVLYSEQBCNT",
2064             0x94, regvalue, cur_col, wrap));
2065 }
2066
2067 int
2068 ahd_cmcseqbcnt_print(u_int regvalue, u_int *cur_col, u_int wrap)
2069 {
2070         return (ahd_print_register(NULL, 0, "CMCSEQBCNT",
2071             0x94, regvalue, cur_col, wrap));
2072 }
2073
2074 int
2075 ahd_dchseqbcnt_print(u_int regvalue, u_int *cur_col, u_int wrap)
2076 {
2077         return (ahd_print_register(NULL, 0, "DCHSEQBCNT",
2078             0x94, regvalue, cur_col, wrap));
2079 }
2080
2081 static ahd_reg_parse_entry_t CMCSPLTSTAT0_parse_table[] = {
2082         { "RXSPLTRSP",          0x01, 0x01 },
2083         { "RXSCEMSG",           0x02, 0x02 },
2084         { "RXOVRUN",            0x04, 0x04 },
2085         { "CNTNOTCMPLT",        0x08, 0x08 },
2086         { "SCDATBUCKET",        0x10, 0x10 },
2087         { "SCADERR",            0x20, 0x20 },
2088         { "SCBCERR",            0x40, 0x40 },
2089         { "STAETERM",           0x80, 0x80 }
2090 };
2091
2092 int
2093 ahd_cmcspltstat0_print(u_int regvalue, u_int *cur_col, u_int wrap)
2094 {
2095         return (ahd_print_register(CMCSPLTSTAT0_parse_table, 8, "CMCSPLTSTAT0",
2096             0x96, regvalue, cur_col, wrap));
2097 }
2098
2099 static ahd_reg_parse_entry_t OVLYSPLTSTAT0_parse_table[] = {
2100         { "RXSPLTRSP",          0x01, 0x01 },
2101         { "RXSCEMSG",           0x02, 0x02 },
2102         { "RXOVRUN",            0x04, 0x04 },
2103         { "CNTNOTCMPLT",        0x08, 0x08 },
2104         { "SCDATBUCKET",        0x10, 0x10 },
2105         { "SCADERR",            0x20, 0x20 },
2106         { "SCBCERR",            0x40, 0x40 },
2107         { "STAETERM",           0x80, 0x80 }
2108 };
2109
2110 int
2111 ahd_ovlyspltstat0_print(u_int regvalue, u_int *cur_col, u_int wrap)
2112 {
2113         return (ahd_print_register(OVLYSPLTSTAT0_parse_table, 8, "OVLYSPLTSTAT0",
2114             0x96, regvalue, cur_col, wrap));
2115 }
2116
2117 static ahd_reg_parse_entry_t DCHSPLTSTAT0_parse_table[] = {
2118         { "RXSPLTRSP",          0x01, 0x01 },
2119         { "RXSCEMSG",           0x02, 0x02 },
2120         { "RXOVRUN",            0x04, 0x04 },
2121         { "CNTNOTCMPLT",        0x08, 0x08 },
2122         { "SCDATBUCKET",        0x10, 0x10 },
2123         { "SCADERR",            0x20, 0x20 },
2124         { "SCBCERR",            0x40, 0x40 },
2125         { "STAETERM",           0x80, 0x80 }
2126 };
2127
2128 int
2129 ahd_dchspltstat0_print(u_int regvalue, u_int *cur_col, u_int wrap)
2130 {
2131         return (ahd_print_register(DCHSPLTSTAT0_parse_table, 8, "DCHSPLTSTAT0",
2132             0x96, regvalue, cur_col, wrap));
2133 }
2134
2135 static ahd_reg_parse_entry_t DCHSPLTSTAT1_parse_table[] = {
2136         { "RXDATABUCKET",       0x01, 0x01 }
2137 };
2138
2139 int
2140 ahd_dchspltstat1_print(u_int regvalue, u_int *cur_col, u_int wrap)
2141 {
2142         return (ahd_print_register(DCHSPLTSTAT1_parse_table, 1, "DCHSPLTSTAT1",
2143             0x97, regvalue, cur_col, wrap));
2144 }
2145
2146 static ahd_reg_parse_entry_t CMCSPLTSTAT1_parse_table[] = {
2147         { "RXDATABUCKET",       0x01, 0x01 }
2148 };
2149
2150 int
2151 ahd_cmcspltstat1_print(u_int regvalue, u_int *cur_col, u_int wrap)
2152 {
2153         return (ahd_print_register(CMCSPLTSTAT1_parse_table, 1, "CMCSPLTSTAT1",
2154             0x97, regvalue, cur_col, wrap));
2155 }
2156
2157 static ahd_reg_parse_entry_t OVLYSPLTSTAT1_parse_table[] = {
2158         { "RXDATABUCKET",       0x01, 0x01 }
2159 };
2160
2161 int
2162 ahd_ovlyspltstat1_print(u_int regvalue, u_int *cur_col, u_int wrap)
2163 {
2164         return (ahd_print_register(OVLYSPLTSTAT1_parse_table, 1, "OVLYSPLTSTAT1",
2165             0x97, regvalue, cur_col, wrap));
2166 }
2167
2168 static ahd_reg_parse_entry_t SGRXMSG0_parse_table[] = {
2169         { "CFNUM",              0x07, 0x07 },
2170         { "CDNUM",              0xf8, 0xf8 }
2171 };
2172
2173 int
2174 ahd_sgrxmsg0_print(u_int regvalue, u_int *cur_col, u_int wrap)
2175 {
2176         return (ahd_print_register(SGRXMSG0_parse_table, 2, "SGRXMSG0",
2177             0x98, regvalue, cur_col, wrap));
2178 }
2179
2180 static ahd_reg_parse_entry_t SLVSPLTOUTADR0_parse_table[] = {
2181         { "LOWER_ADDR",         0x7f, 0x7f }
2182 };
2183
2184 int
2185 ahd_slvspltoutadr0_print(u_int regvalue, u_int *cur_col, u_int wrap)
2186 {
2187         return (ahd_print_register(SLVSPLTOUTADR0_parse_table, 1, "SLVSPLTOUTADR0",
2188             0x98, regvalue, cur_col, wrap));
2189 }
2190
2191 static ahd_reg_parse_entry_t SGRXMSG1_parse_table[] = {
2192         { "CBNUM",              0xff, 0xff }
2193 };
2194
2195 int
2196 ahd_sgrxmsg1_print(u_int regvalue, u_int *cur_col, u_int wrap)
2197 {
2198         return (ahd_print_register(SGRXMSG1_parse_table, 1, "SGRXMSG1",
2199             0x99, regvalue, cur_col, wrap));
2200 }
2201
2202 static ahd_reg_parse_entry_t SLVSPLTOUTADR1_parse_table[] = {
2203         { "REQ_FNUM",           0x07, 0x07 },
2204         { "REQ_DNUM",           0xf8, 0xf8 }
2205 };
2206
2207 int
2208 ahd_slvspltoutadr1_print(u_int regvalue, u_int *cur_col, u_int wrap)
2209 {
2210         return (ahd_print_register(SLVSPLTOUTADR1_parse_table, 2, "SLVSPLTOUTADR1",
2211             0x99, regvalue, cur_col, wrap));
2212 }
2213
2214 static ahd_reg_parse_entry_t SGRXMSG2_parse_table[] = {
2215         { "MINDEX",             0xff, 0xff }
2216 };
2217
2218 int
2219 ahd_sgrxmsg2_print(u_int regvalue, u_int *cur_col, u_int wrap)
2220 {
2221         return (ahd_print_register(SGRXMSG2_parse_table, 1, "SGRXMSG2",
2222             0x9a, regvalue, cur_col, wrap));
2223 }
2224
2225 static ahd_reg_parse_entry_t SLVSPLTOUTADR2_parse_table[] = {
2226         { "REQ_BNUM",           0xff, 0xff }
2227 };
2228
2229 int
2230 ahd_slvspltoutadr2_print(u_int regvalue, u_int *cur_col, u_int wrap)
2231 {
2232         return (ahd_print_register(SLVSPLTOUTADR2_parse_table, 1, "SLVSPLTOUTADR2",
2233             0x9a, regvalue, cur_col, wrap));
2234 }
2235
2236 static ahd_reg_parse_entry_t SGRXMSG3_parse_table[] = {
2237         { "MCLASS",             0x0f, 0x0f }
2238 };
2239
2240 int
2241 ahd_sgrxmsg3_print(u_int regvalue, u_int *cur_col, u_int wrap)
2242 {
2243         return (ahd_print_register(SGRXMSG3_parse_table, 1, "SGRXMSG3",
2244             0x9b, regvalue, cur_col, wrap));
2245 }
2246
2247 static ahd_reg_parse_entry_t SLVSPLTOUTADR3_parse_table[] = {
2248         { "RLXORD",             0x10, 0x10 },
2249         { "TAG_NUM",            0x1f, 0x1f }
2250 };
2251
2252 int
2253 ahd_slvspltoutadr3_print(u_int regvalue, u_int *cur_col, u_int wrap)
2254 {
2255         return (ahd_print_register(SLVSPLTOUTADR3_parse_table, 2, "SLVSPLTOUTADR3",
2256             0x9b, regvalue, cur_col, wrap));
2257 }
2258
2259 int
2260 ahd_sgseqbcnt_print(u_int regvalue, u_int *cur_col, u_int wrap)
2261 {
2262         return (ahd_print_register(NULL, 0, "SGSEQBCNT",
2263             0x9c, regvalue, cur_col, wrap));
2264 }
2265
2266 static ahd_reg_parse_entry_t SLVSPLTOUTATTR0_parse_table[] = {
2267         { "LOWER_BCNT",         0xff, 0xff }
2268 };
2269
2270 int
2271 ahd_slvspltoutattr0_print(u_int regvalue, u_int *cur_col, u_int wrap)
2272 {
2273         return (ahd_print_register(SLVSPLTOUTATTR0_parse_table, 1, "SLVSPLTOUTATTR0",
2274             0x9c, regvalue, cur_col, wrap));
2275 }
2276
2277 static ahd_reg_parse_entry_t SLVSPLTOUTATTR1_parse_table[] = {
2278         { "CMPLT_FNUM",         0x07, 0x07 },
2279         { "CMPLT_DNUM",         0xf8, 0xf8 }
2280 };
2281
2282 int
2283 ahd_slvspltoutattr1_print(u_int regvalue, u_int *cur_col, u_int wrap)
2284 {
2285         return (ahd_print_register(SLVSPLTOUTATTR1_parse_table, 2, "SLVSPLTOUTATTR1",
2286             0x9d, regvalue, cur_col, wrap));
2287 }
2288
2289 static ahd_reg_parse_entry_t SLVSPLTOUTATTR2_parse_table[] = {
2290         { "CMPLT_BNUM",         0xff, 0xff }
2291 };
2292
2293 int
2294 ahd_slvspltoutattr2_print(u_int regvalue, u_int *cur_col, u_int wrap)
2295 {
2296         return (ahd_print_register(SLVSPLTOUTATTR2_parse_table, 1, "SLVSPLTOUTATTR2",
2297             0x9e, regvalue, cur_col, wrap));
2298 }
2299
2300 static ahd_reg_parse_entry_t SGSPLTSTAT0_parse_table[] = {
2301         { "RXSPLTRSP",          0x01, 0x01 },
2302         { "RXSCEMSG",           0x02, 0x02 },
2303         { "RXOVRUN",            0x04, 0x04 },
2304         { "CNTNOTCMPLT",        0x08, 0x08 },
2305         { "SCDATBUCKET",        0x10, 0x10 },
2306         { "SCADERR",            0x20, 0x20 },
2307         { "SCBCERR",            0x40, 0x40 },
2308         { "STAETERM",           0x80, 0x80 }
2309 };
2310
2311 int
2312 ahd_sgspltstat0_print(u_int regvalue, u_int *cur_col, u_int wrap)
2313 {
2314         return (ahd_print_register(SGSPLTSTAT0_parse_table, 8, "SGSPLTSTAT0",
2315             0x9e, regvalue, cur_col, wrap));
2316 }
2317
2318 static ahd_reg_parse_entry_t SFUNCT_parse_table[] = {
2319         { "TEST_NUM",           0x0f, 0x0f },
2320         { "TEST_GROUP",         0xf0, 0xf0 }
2321 };
2322
2323 int
2324 ahd_sfunct_print(u_int regvalue, u_int *cur_col, u_int wrap)
2325 {
2326         return (ahd_print_register(SFUNCT_parse_table, 2, "SFUNCT",
2327             0x9f, regvalue, cur_col, wrap));
2328 }
2329
2330 static ahd_reg_parse_entry_t SGSPLTSTAT1_parse_table[] = {
2331         { "RXDATABUCKET",       0x01, 0x01 }
2332 };
2333
2334 int
2335 ahd_sgspltstat1_print(u_int regvalue, u_int *cur_col, u_int wrap)
2336 {
2337         return (ahd_print_register(SGSPLTSTAT1_parse_table, 1, "SGSPLTSTAT1",
2338             0x9f, regvalue, cur_col, wrap));
2339 }
2340
2341 static ahd_reg_parse_entry_t DF0PCISTAT_parse_table[] = {
2342         { "DPR",                0x01, 0x01 },
2343         { "TWATERR",            0x02, 0x02 },
2344         { "RDPERR",             0x04, 0x04 },
2345         { "SCAAPERR",           0x08, 0x08 },
2346         { "RTA",                0x10, 0x10 },
2347         { "RMA",                0x20, 0x20 },
2348         { "SSE",                0x40, 0x40 },
2349         { "DPE",                0x80, 0x80 }
2350 };
2351
2352 int
2353 ahd_df0pcistat_print(u_int regvalue, u_int *cur_col, u_int wrap)
2354 {
2355         return (ahd_print_register(DF0PCISTAT_parse_table, 8, "DF0PCISTAT",
2356             0xa0, regvalue, cur_col, wrap));
2357 }
2358
2359 int
2360 ahd_reg0_print(u_int regvalue, u_int *cur_col, u_int wrap)
2361 {
2362         return (ahd_print_register(NULL, 0, "REG0",
2363             0xa0, regvalue, cur_col, wrap));
2364 }
2365
2366 static ahd_reg_parse_entry_t DF1PCISTAT_parse_table[] = {
2367         { "DPR",                0x01, 0x01 },
2368         { "TWATERR",            0x02, 0x02 },
2369         { "RDPERR",             0x04, 0x04 },
2370         { "SCAAPERR",           0x08, 0x08 },
2371         { "RTA",                0x10, 0x10 },
2372         { "RMA",                0x20, 0x20 },
2373         { "SSE",                0x40, 0x40 },
2374         { "DPE",                0x80, 0x80 }
2375 };
2376
2377 int
2378 ahd_df1pcistat_print(u_int regvalue, u_int *cur_col, u_int wrap)
2379 {
2380         return (ahd_print_register(DF1PCISTAT_parse_table, 8, "DF1PCISTAT",
2381             0xa1, regvalue, cur_col, wrap));
2382 }
2383
2384 static ahd_reg_parse_entry_t SGPCISTAT_parse_table[] = {
2385         { "DPR",                0x01, 0x01 },
2386         { "RDPERR",             0x04, 0x04 },
2387         { "SCAAPERR",           0x08, 0x08 },
2388         { "RTA",                0x10, 0x10 },
2389         { "RMA",                0x20, 0x20 },
2390         { "SSE",                0x40, 0x40 },
2391         { "DPE",                0x80, 0x80 }
2392 };
2393
2394 int
2395 ahd_sgpcistat_print(u_int regvalue, u_int *cur_col, u_int wrap)
2396 {
2397         return (ahd_print_register(SGPCISTAT_parse_table, 7, "SGPCISTAT",
2398             0xa2, regvalue, cur_col, wrap));
2399 }
2400
2401 int
2402 ahd_reg1_print(u_int regvalue, u_int *cur_col, u_int wrap)
2403 {
2404         return (ahd_print_register(NULL, 0, "REG1",
2405             0xa2, regvalue, cur_col, wrap));
2406 }
2407
2408 static ahd_reg_parse_entry_t CMCPCISTAT_parse_table[] = {
2409         { "DPR",                0x01, 0x01 },
2410         { "TWATERR",            0x02, 0x02 },
2411         { "RDPERR",             0x04, 0x04 },
2412         { "SCAAPERR",           0x08, 0x08 },
2413         { "RTA",                0x10, 0x10 },
2414         { "RMA",                0x20, 0x20 },
2415         { "SSE",                0x40, 0x40 },
2416         { "DPE",                0x80, 0x80 }
2417 };
2418
2419 int
2420 ahd_cmcpcistat_print(u_int regvalue, u_int *cur_col, u_int wrap)
2421 {
2422         return (ahd_print_register(CMCPCISTAT_parse_table, 8, "CMCPCISTAT",
2423             0xa3, regvalue, cur_col, wrap));
2424 }
2425
2426 static ahd_reg_parse_entry_t OVLYPCISTAT_parse_table[] = {
2427         { "DPR",                0x01, 0x01 },
2428         { "RDPERR",             0x04, 0x04 },
2429         { "SCAAPERR",           0x08, 0x08 },
2430         { "RTA",                0x10, 0x10 },
2431         { "RMA",                0x20, 0x20 },
2432         { "SSE",                0x40, 0x40 },
2433         { "DPE",                0x80, 0x80 }
2434 };
2435
2436 int
2437 ahd_ovlypcistat_print(u_int regvalue, u_int *cur_col, u_int wrap)
2438 {
2439         return (ahd_print_register(OVLYPCISTAT_parse_table, 7, "OVLYPCISTAT",
2440             0xa4, regvalue, cur_col, wrap));
2441 }
2442
2443 int
2444 ahd_reg_isr_print(u_int regvalue, u_int *cur_col, u_int wrap)
2445 {
2446         return (ahd_print_register(NULL, 0, "REG_ISR",
2447             0xa4, regvalue, cur_col, wrap));
2448 }
2449
2450 static ahd_reg_parse_entry_t SG_STATE_parse_table[] = {
2451         { "SEGS_AVAIL",         0x01, 0x01 },
2452         { "LOADING_NEEDED",     0x02, 0x02 },
2453         { "FETCH_INPROG",       0x04, 0x04 }
2454 };
2455
2456 int
2457 ahd_sg_state_print(u_int regvalue, u_int *cur_col, u_int wrap)
2458 {
2459         return (ahd_print_register(SG_STATE_parse_table, 3, "SG_STATE",
2460             0xa6, regvalue, cur_col, wrap));
2461 }
2462
2463 static ahd_reg_parse_entry_t MSIPCISTAT_parse_table[] = {
2464         { "DPR",                0x01, 0x01 },
2465         { "TWATERR",            0x02, 0x02 },
2466         { "CLRPENDMSI",         0x08, 0x08 },
2467         { "RTA",                0x10, 0x10 },
2468         { "RMA",                0x20, 0x20 },
2469         { "SSE",                0x40, 0x40 }
2470 };
2471
2472 int
2473 ahd_msipcistat_print(u_int regvalue, u_int *cur_col, u_int wrap)
2474 {
2475         return (ahd_print_register(MSIPCISTAT_parse_table, 6, "MSIPCISTAT",
2476             0xa6, regvalue, cur_col, wrap));
2477 }
2478
2479 static ahd_reg_parse_entry_t TARGPCISTAT_parse_table[] = {
2480         { "TWATERR",            0x02, 0x02 },
2481         { "STA",                0x08, 0x08 },
2482         { "SSE",                0x40, 0x40 },
2483         { "DPE",                0x80, 0x80 }
2484 };
2485
2486 int
2487 ahd_targpcistat_print(u_int regvalue, u_int *cur_col, u_int wrap)
2488 {
2489         return (ahd_print_register(TARGPCISTAT_parse_table, 4, "TARGPCISTAT",
2490             0xa7, regvalue, cur_col, wrap));
2491 }
2492
2493 int
2494 ahd_data_count_odd_print(u_int regvalue, u_int *cur_col, u_int wrap)
2495 {
2496         return (ahd_print_register(NULL, 0, "DATA_COUNT_ODD",
2497             0xa7, regvalue, cur_col, wrap));
2498 }
2499
2500 int
2501 ahd_scbptr_print(u_int regvalue, u_int *cur_col, u_int wrap)
2502 {
2503         return (ahd_print_register(NULL, 0, "SCBPTR",
2504             0xa8, regvalue, cur_col, wrap));
2505 }
2506
2507 int
2508 ahd_ccscbacnt_print(u_int regvalue, u_int *cur_col, u_int wrap)
2509 {
2510         return (ahd_print_register(NULL, 0, "CCSCBACNT",
2511             0xab, regvalue, cur_col, wrap));
2512 }
2513
2514 static ahd_reg_parse_entry_t SCBAUTOPTR_parse_table[] = {
2515         { "SCBPTR_OFF",         0x07, 0x07 },
2516         { "SCBPTR_ADDR",        0x38, 0x38 },
2517         { "AUSCBPTR_EN",        0x80, 0x80 }
2518 };
2519
2520 int
2521 ahd_scbautoptr_print(u_int regvalue, u_int *cur_col, u_int wrap)
2522 {
2523         return (ahd_print_register(SCBAUTOPTR_parse_table, 3, "SCBAUTOPTR",
2524             0xab, regvalue, cur_col, wrap));
2525 }
2526
2527 int
2528 ahd_ccsgaddr_print(u_int regvalue, u_int *cur_col, u_int wrap)
2529 {
2530         return (ahd_print_register(NULL, 0, "CCSGADDR",
2531             0xac, regvalue, cur_col, wrap));
2532 }
2533
2534 int
2535 ahd_ccscbaddr_print(u_int regvalue, u_int *cur_col, u_int wrap)
2536 {
2537         return (ahd_print_register(NULL, 0, "CCSCBADDR",
2538             0xac, regvalue, cur_col, wrap));
2539 }
2540
2541 int
2542 ahd_ccscbadr_bk_print(u_int regvalue, u_int *cur_col, u_int wrap)
2543 {
2544         return (ahd_print_register(NULL, 0, "CCSCBADR_BK",
2545             0xac, regvalue, cur_col, wrap));
2546 }
2547
2548 static ahd_reg_parse_entry_t CMC_RAMBIST_parse_table[] = {
2549         { "CMC_BUFFER_BIST_EN", 0x01, 0x01 },
2550         { "CMC_BUFFER_BIST_FAIL",0x02, 0x02 },
2551         { "SG_BIST_EN",         0x10, 0x10 },
2552         { "SG_BIST_FAIL",       0x20, 0x20 },
2553         { "SCBRAMBIST_FAIL",    0x40, 0x40 },
2554         { "SG_ELEMENT_SIZE",    0x80, 0x80 }
2555 };
2556
2557 int
2558 ahd_cmc_rambist_print(u_int regvalue, u_int *cur_col, u_int wrap)
2559 {
2560         return (ahd_print_register(CMC_RAMBIST_parse_table, 6, "CMC_RAMBIST",
2561             0xad, regvalue, cur_col, wrap));
2562 }
2563
2564 static ahd_reg_parse_entry_t CCSGCTL_parse_table[] = {
2565         { "CCSGRESET",          0x01, 0x01 },
2566         { "SG_FETCH_REQ",       0x02, 0x02 },
2567         { "CCSGENACK",          0x08, 0x08 },
2568         { "SG_CACHE_AVAIL",     0x10, 0x10 },
2569         { "CCSGDONE",           0x80, 0x80 },
2570         { "CCSGEN",             0x0c, 0x0c }
2571 };
2572
2573 int
2574 ahd_ccsgctl_print(u_int regvalue, u_int *cur_col, u_int wrap)
2575 {
2576         return (ahd_print_register(CCSGCTL_parse_table, 6, "CCSGCTL",
2577             0xad, regvalue, cur_col, wrap));
2578 }
2579
2580 static ahd_reg_parse_entry_t CCSCBCTL_parse_table[] = {
2581         { "CCSCBRESET",         0x01, 0x01 },
2582         { "CCSCBDIR",           0x04, 0x04 },
2583         { "CCSCBEN",            0x08, 0x08 },
2584         { "CCARREN",            0x10, 0x10 },
2585         { "ARRDONE",            0x40, 0x40 },
2586         { "CCSCBDONE",          0x80, 0x80 }
2587 };
2588
2589 int
2590 ahd_ccscbctl_print(u_int regvalue, u_int *cur_col, u_int wrap)
2591 {
2592         return (ahd_print_register(CCSCBCTL_parse_table, 6, "CCSCBCTL",
2593             0xad, regvalue, cur_col, wrap));
2594 }
2595
2596 int
2597 ahd_ccsgram_print(u_int regvalue, u_int *cur_col, u_int wrap)
2598 {
2599         return (ahd_print_register(NULL, 0, "CCSGRAM",
2600             0xb0, regvalue, cur_col, wrap));
2601 }
2602
2603 int
2604 ahd_flexadr_print(u_int regvalue, u_int *cur_col, u_int wrap)
2605 {
2606         return (ahd_print_register(NULL, 0, "FLEXADR",
2607             0xb0, regvalue, cur_col, wrap));
2608 }
2609
2610 int
2611 ahd_ccscbram_print(u_int regvalue, u_int *cur_col, u_int wrap)
2612 {
2613         return (ahd_print_register(NULL, 0, "CCSCBRAM",
2614             0xb0, regvalue, cur_col, wrap));
2615 }
2616
2617 int
2618 ahd_flexcnt_print(u_int regvalue, u_int *cur_col, u_int wrap)
2619 {
2620         return (ahd_print_register(NULL, 0, "FLEXCNT",
2621             0xb3, regvalue, cur_col, wrap));
2622 }
2623
2624 static ahd_reg_parse_entry_t FLEXDMASTAT_parse_table[] = {
2625         { "FLEXDMADONE",        0x01, 0x01 },
2626         { "FLEXDMAERR",         0x02, 0x02 }
2627 };
2628
2629 int
2630 ahd_flexdmastat_print(u_int regvalue, u_int *cur_col, u_int wrap)
2631 {
2632         return (ahd_print_register(FLEXDMASTAT_parse_table, 2, "FLEXDMASTAT",
2633             0xb5, regvalue, cur_col, wrap));
2634 }
2635
2636 int
2637 ahd_flexdata_print(u_int regvalue, u_int *cur_col, u_int wrap)
2638 {
2639         return (ahd_print_register(NULL, 0, "FLEXDATA",
2640             0xb6, regvalue, cur_col, wrap));
2641 }
2642
2643 int
2644 ahd_brddat_print(u_int regvalue, u_int *cur_col, u_int wrap)
2645 {
2646         return (ahd_print_register(NULL, 0, "BRDDAT",
2647             0xb8, regvalue, cur_col, wrap));
2648 }
2649
2650 static ahd_reg_parse_entry_t BRDCTL_parse_table[] = {
2651         { "BRDSTB",             0x01, 0x01 },
2652         { "BRDRW",              0x02, 0x02 },
2653         { "BRDEN",              0x04, 0x04 },
2654         { "BRDADDR",            0x38, 0x38 },
2655         { "FLXARBREQ",          0x40, 0x40 },
2656         { "FLXARBACK",          0x80, 0x80 }
2657 };
2658
2659 int
2660 ahd_brdctl_print(u_int regvalue, u_int *cur_col, u_int wrap)
2661 {
2662         return (ahd_print_register(BRDCTL_parse_table, 6, "BRDCTL",
2663             0xb9, regvalue, cur_col, wrap));
2664 }
2665
2666 int
2667 ahd_seeadr_print(u_int regvalue, u_int *cur_col, u_int wrap)
2668 {
2669         return (ahd_print_register(NULL, 0, "SEEADR",
2670             0xba, regvalue, cur_col, wrap));
2671 }
2672
2673 int
2674 ahd_seedat_print(u_int regvalue, u_int *cur_col, u_int wrap)
2675 {
2676         return (ahd_print_register(NULL, 0, "SEEDAT",
2677             0xbc, regvalue, cur_col, wrap));
2678 }
2679
2680 static ahd_reg_parse_entry_t SEECTL_parse_table[] = {
2681         { "SEEOP_ERAL",         0x40, 0x70 },
2682         { "SEEOP_WRITE",        0x50, 0x70 },
2683         { "SEEOP_READ",         0x60, 0x70 },
2684         { "SEEOP_ERASE",        0x70, 0x70 },
2685         { "SEESTART",           0x01, 0x01 },
2686         { "SEERST",             0x02, 0x02 },
2687         { "SEEOPCODE",          0x70, 0x70 },
2688         { "SEEOP_EWEN",         0x40, 0x40 },
2689         { "SEEOP_WALL",         0x40, 0x40 },
2690         { "SEEOP_EWDS",         0x40, 0x40 }
2691 };
2692
2693 int
2694 ahd_seectl_print(u_int regvalue, u_int *cur_col, u_int wrap)
2695 {
2696         return (ahd_print_register(SEECTL_parse_table, 10, "SEECTL",
2697             0xbe, regvalue, cur_col, wrap));
2698 }
2699
2700 static ahd_reg_parse_entry_t SEESTAT_parse_table[] = {
2701         { "SEESTART",           0x01, 0x01 },
2702         { "SEEBUSY",            0x02, 0x02 },
2703         { "SEEARBACK",          0x04, 0x04 },
2704         { "LDALTID_L",          0x08, 0x08 },
2705         { "SEEOPCODE",          0x70, 0x70 },
2706         { "INIT_DONE",          0x80, 0x80 }
2707 };
2708
2709 int
2710 ahd_seestat_print(u_int regvalue, u_int *cur_col, u_int wrap)
2711 {
2712         return (ahd_print_register(SEESTAT_parse_table, 6, "SEESTAT",
2713             0xbe, regvalue, cur_col, wrap));
2714 }
2715
2716 int
2717 ahd_scbcnt_print(u_int regvalue, u_int *cur_col, u_int wrap)
2718 {
2719         return (ahd_print_register(NULL, 0, "SCBCNT",
2720             0xbf, regvalue, cur_col, wrap));
2721 }
2722
2723 int
2724 ahd_dfwaddr_print(u_int regvalue, u_int *cur_col, u_int wrap)
2725 {
2726         return (ahd_print_register(NULL, 0, "DFWADDR",
2727             0xc0, regvalue, cur_col, wrap));
2728 }
2729
2730 static ahd_reg_parse_entry_t DSPFLTRCTL_parse_table[] = {
2731         { "DSPFCNTSEL",         0x0f, 0x0f },
2732         { "EDGESENSE",          0x10, 0x10 },
2733         { "FLTRDISABLE",        0x20, 0x20 }
2734 };
2735
2736 int
2737 ahd_dspfltrctl_print(u_int regvalue, u_int *cur_col, u_int wrap)
2738 {
2739         return (ahd_print_register(DSPFLTRCTL_parse_table, 3, "DSPFLTRCTL",
2740             0xc0, regvalue, cur_col, wrap));
2741 }
2742
2743 static ahd_reg_parse_entry_t DSPDATACTL_parse_table[] = {
2744         { "XMITOFFSTDIS",       0x02, 0x02 },
2745         { "RCVROFFSTDIS",       0x04, 0x04 },
2746         { "DESQDIS",            0x10, 0x10 },
2747         { "BYPASSENAB",         0x80, 0x80 }
2748 };
2749
2750 int
2751 ahd_dspdatactl_print(u_int regvalue, u_int *cur_col, u_int wrap)
2752 {
2753         return (ahd_print_register(DSPDATACTL_parse_table, 4, "DSPDATACTL",
2754             0xc1, regvalue, cur_col, wrap));
2755 }
2756
2757 int
2758 ahd_dfraddr_print(u_int regvalue, u_int *cur_col, u_int wrap)
2759 {
2760         return (ahd_print_register(NULL, 0, "DFRADDR",
2761             0xc2, regvalue, cur_col, wrap));
2762 }
2763
2764 static ahd_reg_parse_entry_t DSPREQCTL_parse_table[] = {
2765         { "MANREQDLY",          0x3f, 0x3f },
2766         { "MANREQCTL",          0xc0, 0xc0 }
2767 };
2768
2769 int
2770 ahd_dspreqctl_print(u_int regvalue, u_int *cur_col, u_int wrap)
2771 {
2772         return (ahd_print_register(DSPREQCTL_parse_table, 2, "DSPREQCTL",
2773             0xc2, regvalue, cur_col, wrap));
2774 }
2775
2776 static ahd_reg_parse_entry_t DSPACKCTL_parse_table[] = {
2777         { "MANACKDLY",          0x3f, 0x3f },
2778         { "MANACKCTL",          0xc0, 0xc0 }
2779 };
2780
2781 int
2782 ahd_dspackctl_print(u_int regvalue, u_int *cur_col, u_int wrap)
2783 {
2784         return (ahd_print_register(DSPACKCTL_parse_table, 2, "DSPACKCTL",
2785             0xc3, regvalue, cur_col, wrap));
2786 }
2787
2788 int
2789 ahd_dfdat_print(u_int regvalue, u_int *cur_col, u_int wrap)
2790 {
2791         return (ahd_print_register(NULL, 0, "DFDAT",
2792             0xc4, regvalue, cur_col, wrap));
2793 }
2794
2795 static ahd_reg_parse_entry_t DSPSELECT_parse_table[] = {
2796         { "DSPSEL",             0x1f, 0x1f },
2797         { "AUTOINCEN",          0x80, 0x80 }
2798 };
2799
2800 int
2801 ahd_dspselect_print(u_int regvalue, u_int *cur_col, u_int wrap)
2802 {
2803         return (ahd_print_register(DSPSELECT_parse_table, 2, "DSPSELECT",
2804             0xc4, regvalue, cur_col, wrap));
2805 }
2806
2807 static ahd_reg_parse_entry_t WRTBIASCTL_parse_table[] = {
2808         { "XMITMANVAL",         0x3f, 0x3f },
2809         { "AUTOXBCDIS",         0x80, 0x80 }
2810 };
2811
2812 int
2813 ahd_wrtbiasctl_print(u_int regvalue, u_int *cur_col, u_int wrap)
2814 {
2815         return (ahd_print_register(WRTBIASCTL_parse_table, 2, "WRTBIASCTL",
2816             0xc5, regvalue, cur_col, wrap));
2817 }
2818
2819 static ahd_reg_parse_entry_t RCVRBIOSCTL_parse_table[] = {
2820         { "RCVRMANVAL",         0x3f, 0x3f },
2821         { "AUTORBCDIS",         0x80, 0x80 }
2822 };
2823
2824 int
2825 ahd_rcvrbiosctl_print(u_int regvalue, u_int *cur_col, u_int wrap)
2826 {
2827         return (ahd_print_register(RCVRBIOSCTL_parse_table, 2, "RCVRBIOSCTL",
2828             0xc6, regvalue, cur_col, wrap));
2829 }
2830
2831 int
2832 ahd_wrtbiascalc_print(u_int regvalue, u_int *cur_col, u_int wrap)
2833 {
2834         return (ahd_print_register(NULL, 0, "WRTBIASCALC",
2835             0xc7, regvalue, cur_col, wrap));
2836 }
2837
2838 int
2839 ahd_dfptrs_print(u_int regvalue, u_int *cur_col, u_int wrap)
2840 {
2841         return (ahd_print_register(NULL, 0, "DFPTRS",
2842             0xc8, regvalue, cur_col, wrap));
2843 }
2844
2845 int
2846 ahd_rcvrbiascalc_print(u_int regvalue, u_int *cur_col, u_int wrap)
2847 {
2848         return (ahd_print_register(NULL, 0, "RCVRBIASCALC",
2849             0xc8, regvalue, cur_col, wrap));
2850 }
2851
2852 int
2853 ahd_dfbkptr_print(u_int regvalue, u_int *cur_col, u_int wrap)
2854 {
2855         return (ahd_print_register(NULL, 0, "DFBKPTR",
2856             0xc9, regvalue, cur_col, wrap));
2857 }
2858
2859 int
2860 ahd_skewcalc_print(u_int regvalue, u_int *cur_col, u_int wrap)
2861 {
2862         return (ahd_print_register(NULL, 0, "SKEWCALC",
2863             0xc9, regvalue, cur_col, wrap));
2864 }
2865
2866 static ahd_reg_parse_entry_t DFDBCTL_parse_table[] = {
2867         { "DFF_RAMBIST_EN",     0x01, 0x01 },
2868         { "DFF_RAMBIST_DONE",   0x02, 0x02 },
2869         { "DFF_RAMBIST_FAIL",   0x04, 0x04 },
2870         { "DFF_DIR_ERR",        0x08, 0x08 },
2871         { "DFF_CIO_RD_RDY",     0x10, 0x10 },
2872         { "DFF_CIO_WR_RDY",     0x20, 0x20 }
2873 };
2874
2875 int
2876 ahd_dfdbctl_print(u_int regvalue, u_int *cur_col, u_int wrap)
2877 {
2878         return (ahd_print_register(DFDBCTL_parse_table, 6, "DFDBCTL",
2879             0xcb, regvalue, cur_col, wrap));
2880 }
2881
2882 int
2883 ahd_dfscnt_print(u_int regvalue, u_int *cur_col, u_int wrap)
2884 {
2885         return (ahd_print_register(NULL, 0, "DFSCNT",
2886             0xcc, regvalue, cur_col, wrap));
2887 }
2888
2889 int
2890 ahd_dfbcnt_print(u_int regvalue, u_int *cur_col, u_int wrap)
2891 {
2892         return (ahd_print_register(NULL, 0, "DFBCNT",
2893             0xce, regvalue, cur_col, wrap));
2894 }
2895
2896 int
2897 ahd_ovlyaddr_print(u_int regvalue, u_int *cur_col, u_int wrap)
2898 {
2899         return (ahd_print_register(NULL, 0, "OVLYADDR",
2900             0xd4, regvalue, cur_col, wrap));
2901 }
2902
2903 static ahd_reg_parse_entry_t SEQCTL0_parse_table[] = {
2904         { "LOADRAM",            0x01, 0x01 },
2905         { "SEQRESET",           0x02, 0x02 },
2906         { "STEP",               0x04, 0x04 },
2907         { "BRKADRINTEN",        0x08, 0x08 },
2908         { "FASTMODE",           0x10, 0x10 },
2909         { "FAILDIS",            0x20, 0x20 },
2910         { "PAUSEDIS",           0x40, 0x40 },
2911         { "PERRORDIS",          0x80, 0x80 }
2912 };
2913
2914 int
2915 ahd_seqctl0_print(u_int regvalue, u_int *cur_col, u_int wrap)
2916 {
2917         return (ahd_print_register(SEQCTL0_parse_table, 8, "SEQCTL0",
2918             0xd6, regvalue, cur_col, wrap));
2919 }
2920
2921 static ahd_reg_parse_entry_t SEQCTL1_parse_table[] = {
2922         { "RAMBIST_EN",         0x01, 0x01 },
2923         { "RAMBIST_FAIL",       0x02, 0x02 },
2924         { "RAMBIST_DONE",       0x04, 0x04 },
2925         { "OVRLAY_DATA_CHK",    0x08, 0x08 }
2926 };
2927
2928 int
2929 ahd_seqctl1_print(u_int regvalue, u_int *cur_col, u_int wrap)
2930 {
2931         return (ahd_print_register(SEQCTL1_parse_table, 4, "SEQCTL1",
2932             0xd7, regvalue, cur_col, wrap));
2933 }
2934
2935 static ahd_reg_parse_entry_t FLAGS_parse_table[] = {
2936         { "CARRY",              0x01, 0x01 },
2937         { "ZERO",               0x02, 0x02 }
2938 };
2939
2940 int
2941 ahd_flags_print(u_int regvalue, u_int *cur_col, u_int wrap)
2942 {
2943         return (ahd_print_register(FLAGS_parse_table, 2, "FLAGS",
2944             0xd8, regvalue, cur_col, wrap));
2945 }
2946
2947 static ahd_reg_parse_entry_t SEQINTCTL_parse_table[] = {
2948         { "IRET",               0x01, 0x01 },
2949         { "INTMASK1",           0x02, 0x02 },
2950         { "INTMASK2",           0x04, 0x04 },
2951         { "SCS_SEQ_INT1M0",     0x08, 0x08 },
2952         { "SCS_SEQ_INT1M1",     0x10, 0x10 },
2953         { "INT1_CONTEXT",       0x20, 0x20 },
2954         { "INTVEC1DSL",         0x80, 0x80 }
2955 };
2956
2957 int
2958 ahd_seqintctl_print(u_int regvalue, u_int *cur_col, u_int wrap)
2959 {
2960         return (ahd_print_register(SEQINTCTL_parse_table, 7, "SEQINTCTL",
2961             0xd9, regvalue, cur_col, wrap));
2962 }
2963
2964 int
2965 ahd_seqram_print(u_int regvalue, u_int *cur_col, u_int wrap)
2966 {
2967         return (ahd_print_register(NULL, 0, "SEQRAM",
2968             0xda, regvalue, cur_col, wrap));
2969 }
2970
2971 int
2972 ahd_prgmcnt_print(u_int regvalue, u_int *cur_col, u_int wrap)
2973 {
2974         return (ahd_print_register(NULL, 0, "PRGMCNT",
2975             0xde, regvalue, cur_col, wrap));
2976 }
2977
2978 int
2979 ahd_accum_print(u_int regvalue, u_int *cur_col, u_int wrap)
2980 {
2981         return (ahd_print_register(NULL, 0, "ACCUM",
2982             0xe0, regvalue, cur_col, wrap));
2983 }
2984
2985 int
2986 ahd_sindex_print(u_int regvalue, u_int *cur_col, u_int wrap)
2987 {
2988         return (ahd_print_register(NULL, 0, "SINDEX",
2989             0xe2, regvalue, cur_col, wrap));
2990 }
2991
2992 int
2993 ahd_dindex_print(u_int regvalue, u_int *cur_col, u_int wrap)
2994 {
2995         return (ahd_print_register(NULL, 0, "DINDEX",
2996             0xe4, regvalue, cur_col, wrap));
2997 }
2998
2999 static ahd_reg_parse_entry_t BRKADDR1_parse_table[] = {
3000         { "BRKDIS",             0x80, 0x80 }
3001 };
3002
3003 int
3004 ahd_brkaddr1_print(u_int regvalue, u_int *cur_col, u_int wrap)
3005 {
3006         return (ahd_print_register(BRKADDR1_parse_table, 1, "BRKADDR1",
3007             0xe6, regvalue, cur_col, wrap));
3008 }
3009
3010 int
3011 ahd_brkaddr0_print(u_int regvalue, u_int *cur_col, u_int wrap)
3012 {
3013         return (ahd_print_register(NULL, 0, "BRKADDR0",
3014             0xe6, regvalue, cur_col, wrap));
3015 }
3016
3017 int
3018 ahd_allones_print(u_int regvalue, u_int *cur_col, u_int wrap)
3019 {
3020         return (ahd_print_register(NULL, 0, "ALLONES",
3021             0xe8, regvalue, cur_col, wrap));
3022 }
3023
3024 int
3025 ahd_allzeros_print(u_int regvalue, u_int *cur_col, u_int wrap)
3026 {
3027         return (ahd_print_register(NULL, 0, "ALLZEROS",
3028             0xea, regvalue, cur_col, wrap));
3029 }
3030
3031 int
3032 ahd_none_print(u_int regvalue, u_int *cur_col, u_int wrap)
3033 {
3034         return (ahd_print_register(NULL, 0, "NONE",
3035             0xea, regvalue, cur_col, wrap));
3036 }
3037
3038 int
3039 ahd_sindir_print(u_int regvalue, u_int *cur_col, u_int wrap)
3040 {
3041         return (ahd_print_register(NULL, 0, "SINDIR",
3042             0xec, regvalue, cur_col, wrap));
3043 }
3044
3045 int
3046 ahd_dindir_print(u_int regvalue, u_int *cur_col, u_int wrap)
3047 {
3048         return (ahd_print_register(NULL, 0, "DINDIR",
3049             0xed, regvalue, cur_col, wrap));
3050 }
3051
3052 int
3053 ahd_function1_print(u_int regvalue, u_int *cur_col, u_int wrap)
3054 {
3055         return (ahd_print_register(NULL, 0, "FUNCTION1",
3056             0xf0, regvalue, cur_col, wrap));
3057 }
3058
3059 int
3060 ahd_stack_print(u_int regvalue, u_int *cur_col, u_int wrap)
3061 {
3062         return (ahd_print_register(NULL, 0, "STACK",
3063             0xf2, regvalue, cur_col, wrap));
3064 }
3065
3066 int
3067 ahd_curaddr_print(u_int regvalue, u_int *cur_col, u_int wrap)
3068 {
3069         return (ahd_print_register(NULL, 0, "CURADDR",
3070             0xf4, regvalue, cur_col, wrap));
3071 }
3072
3073 int
3074 ahd_intvec1_addr_print(u_int regvalue, u_int *cur_col, u_int wrap)
3075 {
3076         return (ahd_print_register(NULL, 0, "INTVEC1_ADDR",
3077             0xf4, regvalue, cur_col, wrap));
3078 }
3079
3080 int
3081 ahd_intvec2_addr_print(u_int regvalue, u_int *cur_col, u_int wrap)
3082 {
3083         return (ahd_print_register(NULL, 0, "INTVEC2_ADDR",
3084             0xf6, regvalue, cur_col, wrap));
3085 }
3086
3087 int
3088 ahd_lastaddr_print(u_int regvalue, u_int *cur_col, u_int wrap)
3089 {
3090         return (ahd_print_register(NULL, 0, "LASTADDR",
3091             0xf6, regvalue, cur_col, wrap));
3092 }
3093
3094 int
3095 ahd_longjmp_addr_print(u_int regvalue, u_int *cur_col, u_int wrap)
3096 {
3097         return (ahd_print_register(NULL, 0, "LONGJMP_ADDR",
3098             0xf8, regvalue, cur_col, wrap));
3099 }
3100
3101 int
3102 ahd_accum_save_print(u_int regvalue, u_int *cur_col, u_int wrap)
3103 {
3104         return (ahd_print_register(NULL, 0, "ACCUM_SAVE",
3105             0xfa, regvalue, cur_col, wrap));
3106 }
3107
3108 int
3109 ahd_waiting_scb_tails_print(u_int regvalue, u_int *cur_col, u_int wrap)
3110 {
3111         return (ahd_print_register(NULL, 0, "WAITING_SCB_TAILS",
3112             0x100, regvalue, cur_col, wrap));
3113 }
3114
3115 int
3116 ahd_ahd_pci_config_base_print(u_int regvalue, u_int *cur_col, u_int wrap)
3117 {
3118         return (ahd_print_register(NULL, 0, "AHD_PCI_CONFIG_BASE",
3119             0x100, regvalue, cur_col, wrap));
3120 }
3121
3122 int
3123 ahd_sram_base_print(u_int regvalue, u_int *cur_col, u_int wrap)
3124 {
3125         return (ahd_print_register(NULL, 0, "SRAM_BASE",
3126             0x100, regvalue, cur_col, wrap));
3127 }
3128
3129 int
3130 ahd_waiting_tid_head_print(u_int regvalue, u_int *cur_col, u_int wrap)
3131 {
3132         return (ahd_print_register(NULL, 0, "WAITING_TID_HEAD",
3133             0x120, regvalue, cur_col, wrap));
3134 }
3135
3136 int
3137 ahd_waiting_tid_tail_print(u_int regvalue, u_int *cur_col, u_int wrap)
3138 {
3139         return (ahd_print_register(NULL, 0, "WAITING_TID_TAIL",
3140             0x122, regvalue, cur_col, wrap));
3141 }
3142
3143 int
3144 ahd_next_queued_scb_addr_print(u_int regvalue, u_int *cur_col, u_int wrap)
3145 {
3146         return (ahd_print_register(NULL, 0, "NEXT_QUEUED_SCB_ADDR",
3147             0x124, regvalue, cur_col, wrap));
3148 }
3149
3150 int
3151 ahd_complete_scb_head_print(u_int regvalue, u_int *cur_col, u_int wrap)
3152 {
3153         return (ahd_print_register(NULL, 0, "COMPLETE_SCB_HEAD",
3154             0x128, regvalue, cur_col, wrap));
3155 }
3156
3157 int
3158 ahd_complete_scb_dmainprog_head_print(u_int regvalue, u_int *cur_col, u_int wrap)
3159 {
3160         return (ahd_print_register(NULL, 0, "COMPLETE_SCB_DMAINPROG_HEAD",
3161             0x12a, regvalue, cur_col, wrap));
3162 }
3163
3164 int
3165 ahd_complete_dma_scb_head_print(u_int regvalue, u_int *cur_col, u_int wrap)
3166 {
3167         return (ahd_print_register(NULL, 0, "COMPLETE_DMA_SCB_HEAD",
3168             0x12c, regvalue, cur_col, wrap));
3169 }
3170
3171 int
3172 ahd_qfreeze_count_print(u_int regvalue, u_int *cur_col, u_int wrap)
3173 {
3174         return (ahd_print_register(NULL, 0, "QFREEZE_COUNT",
3175             0x12e, regvalue, cur_col, wrap));
3176 }
3177
3178 int
3179 ahd_saved_mode_print(u_int regvalue, u_int *cur_col, u_int wrap)
3180 {
3181         return (ahd_print_register(NULL, 0, "SAVED_MODE",
3182             0x130, regvalue, cur_col, wrap));
3183 }
3184
3185 int
3186 ahd_msg_out_print(u_int regvalue, u_int *cur_col, u_int wrap)
3187 {
3188         return (ahd_print_register(NULL, 0, "MSG_OUT",
3189             0x131, regvalue, cur_col, wrap));
3190 }
3191
3192 static ahd_reg_parse_entry_t DMAPARAMS_parse_table[] = {
3193         { "FIFORESET",          0x01, 0x01 },
3194         { "FIFOFLUSH",          0x02, 0x02 },
3195         { "DIRECTION",          0x04, 0x04 },
3196         { "HDMAEN",             0x08, 0x08 },
3197         { "HDMAENACK",          0x08, 0x08 },
3198         { "SDMAEN",             0x10, 0x10 },
3199         { "SDMAENACK",          0x10, 0x10 },
3200         { "SCSIEN",             0x20, 0x20 },
3201         { "WIDEODD",            0x40, 0x40 },
3202         { "PRELOADEN",          0x80, 0x80 }
3203 };
3204
3205 int
3206 ahd_dmaparams_print(u_int regvalue, u_int *cur_col, u_int wrap)
3207 {
3208         return (ahd_print_register(DMAPARAMS_parse_table, 10, "DMAPARAMS",
3209             0x132, regvalue, cur_col, wrap));
3210 }
3211
3212 static ahd_reg_parse_entry_t SEQ_FLAGS_parse_table[] = {
3213         { "NO_DISCONNECT",      0x01, 0x01 },
3214         { "SPHASE_PENDING",     0x02, 0x02 },
3215         { "DPHASE_PENDING",     0x04, 0x04 },
3216         { "CMDPHASE_PENDING",   0x08, 0x08 },
3217         { "TARG_CMD_PENDING",   0x10, 0x10 },
3218         { "DPHASE",             0x20, 0x20 },
3219         { "NO_CDB_SENT",        0x40, 0x40 },
3220         { "TARGET_CMD_IS_TAGGED",0x40, 0x40 },
3221         { "NOT_IDENTIFIED",     0x80, 0x80 }
3222 };
3223
3224 int
3225 ahd_seq_flags_print(u_int regvalue, u_int *cur_col, u_int wrap)
3226 {
3227         return (ahd_print_register(SEQ_FLAGS_parse_table, 9, "SEQ_FLAGS",
3228             0x133, regvalue, cur_col, wrap));
3229 }
3230
3231 int
3232 ahd_saved_scsiid_print(u_int regvalue, u_int *cur_col, u_int wrap)
3233 {
3234         return (ahd_print_register(NULL, 0, "SAVED_SCSIID",
3235             0x134, regvalue, cur_col, wrap));
3236 }
3237
3238 int
3239 ahd_saved_lun_print(u_int regvalue, u_int *cur_col, u_int wrap)
3240 {
3241         return (ahd_print_register(NULL, 0, "SAVED_LUN",
3242             0x135, regvalue, cur_col, wrap));
3243 }
3244
3245 static ahd_reg_parse_entry_t LASTPHASE_parse_table[] = {
3246         { "P_DATAOUT",          0x00, 0xe0 },
3247         { "P_DATAOUT_DT",       0x20, 0xe0 },
3248         { "P_DATAIN",           0x40, 0xe0 },
3249         { "P_DATAIN_DT",        0x60, 0xe0 },
3250         { "P_COMMAND",          0x80, 0xe0 },
3251         { "P_MESGOUT",          0xa0, 0xe0 },
3252         { "P_STATUS",           0xc0, 0xe0 },
3253         { "P_MESGIN",           0xe0, 0xe0 },
3254         { "P_BUSFREE",          0x01, 0x01 },
3255         { "MSGI",               0x20, 0x20 },
3256         { "IOI",                0x40, 0x40 },
3257         { "CDI",                0x80, 0x80 },
3258         { "PHASE_MASK",         0xe0, 0xe0 }
3259 };
3260
3261 int
3262 ahd_lastphase_print(u_int regvalue, u_int *cur_col, u_int wrap)
3263 {
3264         return (ahd_print_register(LASTPHASE_parse_table, 13, "LASTPHASE",
3265             0x136, regvalue, cur_col, wrap));
3266 }
3267
3268 int
3269 ahd_qoutfifo_entry_valid_tag_print(u_int regvalue, u_int *cur_col, u_int wrap)
3270 {
3271         return (ahd_print_register(NULL, 0, "QOUTFIFO_ENTRY_VALID_TAG",
3272             0x137, regvalue, cur_col, wrap));
3273 }
3274
3275 int
3276 ahd_shared_data_addr_print(u_int regvalue, u_int *cur_col, u_int wrap)
3277 {
3278         return (ahd_print_register(NULL, 0, "SHARED_DATA_ADDR",
3279             0x138, regvalue, cur_col, wrap));
3280 }
3281
3282 int
3283 ahd_qoutfifo_next_addr_print(u_int regvalue, u_int *cur_col, u_int wrap)
3284 {
3285         return (ahd_print_register(NULL, 0, "QOUTFIFO_NEXT_ADDR",
3286             0x13c, regvalue, cur_col, wrap));
3287 }
3288
3289 int
3290 ahd_kernel_tqinpos_print(u_int regvalue, u_int *cur_col, u_int wrap)
3291 {
3292         return (ahd_print_register(NULL, 0, "KERNEL_TQINPOS",
3293             0x140, regvalue, cur_col, wrap));
3294 }
3295
3296 int
3297 ahd_tqinpos_print(u_int regvalue, u_int *cur_col, u_int wrap)
3298 {
3299         return (ahd_print_register(NULL, 0, "TQINPOS",
3300             0x141, regvalue, cur_col, wrap));
3301 }
3302
3303 static ahd_reg_parse_entry_t ARG_1_parse_table[] = {
3304         { "CONT_MSG_LOOP_TARG", 0x02, 0x02 },
3305         { "CONT_MSG_LOOP_READ", 0x03, 0x03 },
3306         { "CONT_MSG_LOOP_WRITE",0x04, 0x04 },
3307         { "EXIT_MSG_LOOP",      0x08, 0x08 },
3308         { "MSGOUT_PHASEMIS",    0x10, 0x10 },
3309         { "SEND_REJ",           0x20, 0x20 },
3310         { "SEND_SENSE",         0x40, 0x40 },
3311         { "SEND_MSG",           0x80, 0x80 }
3312 };
3313
3314 int
3315 ahd_arg_1_print(u_int regvalue, u_int *cur_col, u_int wrap)
3316 {
3317         return (ahd_print_register(ARG_1_parse_table, 8, "ARG_1",
3318             0x142, regvalue, cur_col, wrap));
3319 }
3320
3321 int
3322 ahd_arg_2_print(u_int regvalue, u_int *cur_col, u_int wrap)
3323 {
3324         return (ahd_print_register(NULL, 0, "ARG_2",
3325             0x143, regvalue, cur_col, wrap));
3326 }
3327
3328 int
3329 ahd_last_msg_print(u_int regvalue, u_int *cur_col, u_int wrap)
3330 {
3331         return (ahd_print_register(NULL, 0, "LAST_MSG",
3332             0x144, regvalue, cur_col, wrap));
3333 }
3334
3335 static ahd_reg_parse_entry_t SCSISEQ_TEMPLATE_parse_table[] = {
3336         { "ALTSTIM",            0x01, 0x01 },
3337         { "ENAUTOATNP",         0x02, 0x02 },
3338         { "MANUALP",            0x0c, 0x0c },
3339         { "ENRSELI",            0x10, 0x10 },
3340         { "ENSELI",             0x20, 0x20 },
3341         { "MANUALCTL",          0x40, 0x40 }
3342 };
3343
3344 int
3345 ahd_scsiseq_template_print(u_int regvalue, u_int *cur_col, u_int wrap)
3346 {
3347         return (ahd_print_register(SCSISEQ_TEMPLATE_parse_table, 6, "SCSISEQ_TEMPLATE",
3348             0x145, regvalue, cur_col, wrap));
3349 }
3350
3351 int
3352 ahd_initiator_tag_print(u_int regvalue, u_int *cur_col, u_int wrap)
3353 {
3354         return (ahd_print_register(NULL, 0, "INITIATOR_TAG",
3355             0x146, regvalue, cur_col, wrap));
3356 }
3357
3358 static ahd_reg_parse_entry_t SEQ_FLAGS2_parse_table[] = {
3359         { "TARGET_MSG_PENDING", 0x02, 0x02 },
3360         { "SELECTOUT_QFROZEN",  0x04, 0x04 }
3361 };
3362
3363 int
3364 ahd_seq_flags2_print(u_int regvalue, u_int *cur_col, u_int wrap)
3365 {
3366         return (ahd_print_register(SEQ_FLAGS2_parse_table, 2, "SEQ_FLAGS2",
3367             0x147, regvalue, cur_col, wrap));
3368 }
3369
3370 int
3371 ahd_allocfifo_scbptr_print(u_int regvalue, u_int *cur_col, u_int wrap)
3372 {
3373         return (ahd_print_register(NULL, 0, "ALLOCFIFO_SCBPTR",
3374             0x148, regvalue, cur_col, wrap));
3375 }
3376
3377 int
3378 ahd_int_coalescing_timer_print(u_int regvalue, u_int *cur_col, u_int wrap)
3379 {
3380         return (ahd_print_register(NULL, 0, "INT_COALESCING_TIMER",
3381             0x14a, regvalue, cur_col, wrap));
3382 }
3383
3384 int
3385 ahd_int_coalescing_maxcmds_print(u_int regvalue, u_int *cur_col, u_int wrap)
3386 {
3387         return (ahd_print_register(NULL, 0, "INT_COALESCING_MAXCMDS",
3388             0x14c, regvalue, cur_col, wrap));
3389 }
3390
3391 int
3392 ahd_int_coalescing_mincmds_print(u_int regvalue, u_int *cur_col, u_int wrap)
3393 {
3394         return (ahd_print_register(NULL, 0, "INT_COALESCING_MINCMDS",
3395             0x14d, regvalue, cur_col, wrap));
3396 }
3397
3398 int
3399 ahd_cmds_pending_print(u_int regvalue, u_int *cur_col, u_int wrap)
3400 {
3401         return (ahd_print_register(NULL, 0, "CMDS_PENDING",
3402             0x14e, regvalue, cur_col, wrap));
3403 }
3404
3405 int
3406 ahd_int_coalescing_cmdcount_print(u_int regvalue, u_int *cur_col, u_int wrap)
3407 {
3408         return (ahd_print_register(NULL, 0, "INT_COALESCING_CMDCOUNT",
3409             0x150, regvalue, cur_col, wrap));
3410 }
3411
3412 int
3413 ahd_local_hs_mailbox_print(u_int regvalue, u_int *cur_col, u_int wrap)
3414 {
3415         return (ahd_print_register(NULL, 0, "LOCAL_HS_MAILBOX",
3416             0x151, regvalue, cur_col, wrap));
3417 }
3418
3419 int
3420 ahd_cmdsize_table_print(u_int regvalue, u_int *cur_col, u_int wrap)
3421 {
3422         return (ahd_print_register(NULL, 0, "CMDSIZE_TABLE",
3423             0x152, regvalue, cur_col, wrap));
3424 }
3425
3426 int
3427 ahd_scb_base_print(u_int regvalue, u_int *cur_col, u_int wrap)
3428 {
3429         return (ahd_print_register(NULL, 0, "SCB_BASE",
3430             0x180, regvalue, cur_col, wrap));
3431 }
3432
3433 int
3434 ahd_scb_residual_datacnt_print(u_int regvalue, u_int *cur_col, u_int wrap)
3435 {
3436         return (ahd_print_register(NULL, 0, "SCB_RESIDUAL_DATACNT",
3437             0x180, regvalue, cur_col, wrap));
3438 }
3439
3440 static ahd_reg_parse_entry_t SCB_RESIDUAL_SGPTR_parse_table[] = {
3441         { "SG_LIST_NULL",       0x01, 0x01 },
3442         { "SG_OVERRUN_RESID",   0x02, 0x02 },
3443         { "SG_ADDR_MASK",       0xf8, 0xf8 }
3444 };
3445
3446 int
3447 ahd_scb_residual_sgptr_print(u_int regvalue, u_int *cur_col, u_int wrap)
3448 {
3449         return (ahd_print_register(SCB_RESIDUAL_SGPTR_parse_table, 3, "SCB_RESIDUAL_SGPTR",
3450             0x184, regvalue, cur_col, wrap));
3451 }
3452
3453 int
3454 ahd_scb_scsi_status_print(u_int regvalue, u_int *cur_col, u_int wrap)
3455 {
3456         return (ahd_print_register(NULL, 0, "SCB_SCSI_STATUS",
3457             0x188, regvalue, cur_col, wrap));
3458 }
3459
3460 int
3461 ahd_scb_target_phases_print(u_int regvalue, u_int *cur_col, u_int wrap)
3462 {
3463         return (ahd_print_register(NULL, 0, "SCB_TARGET_PHASES",
3464             0x189, regvalue, cur_col, wrap));
3465 }
3466
3467 int
3468 ahd_scb_target_data_dir_print(u_int regvalue, u_int *cur_col, u_int wrap)
3469 {
3470         return (ahd_print_register(NULL, 0, "SCB_TARGET_DATA_DIR",
3471             0x18a, regvalue, cur_col, wrap));
3472 }
3473
3474 int
3475 ahd_scb_target_itag_print(u_int regvalue, u_int *cur_col, u_int wrap)
3476 {
3477         return (ahd_print_register(NULL, 0, "SCB_TARGET_ITAG",
3478             0x18b, regvalue, cur_col, wrap));
3479 }
3480
3481 int
3482 ahd_scb_sense_busaddr_print(u_int regvalue, u_int *cur_col, u_int wrap)
3483 {
3484         return (ahd_print_register(NULL, 0, "SCB_SENSE_BUSADDR",
3485             0x18c, regvalue, cur_col, wrap));
3486 }
3487
3488 int
3489 ahd_scb_dataptr_print(u_int regvalue, u_int *cur_col, u_int wrap)
3490 {
3491         return (ahd_print_register(NULL, 0, "SCB_DATAPTR",
3492             0x190, regvalue, cur_col, wrap));
3493 }
3494
3495 static ahd_reg_parse_entry_t SCB_DATACNT_parse_table[] = {
3496         { "SG_HIGH_ADDR_BITS",  0x7f, 0x7f },
3497         { "SG_LAST_SEG",        0x80, 0x80 }
3498 };
3499
3500 int
3501 ahd_scb_datacnt_print(u_int regvalue, u_int *cur_col, u_int wrap)
3502 {
3503         return (ahd_print_register(SCB_DATACNT_parse_table, 2, "SCB_DATACNT",
3504             0x198, regvalue, cur_col, wrap));
3505 }
3506
3507 static ahd_reg_parse_entry_t SCB_SGPTR_parse_table[] = {
3508         { "SG_LIST_NULL",       0x01, 0x01 },
3509         { "SG_FULL_RESID",      0x02, 0x02 },
3510         { "SG_STATUS_VALID",    0x04, 0x04 }
3511 };
3512
3513 int
3514 ahd_scb_sgptr_print(u_int regvalue, u_int *cur_col, u_int wrap)
3515 {
3516         return (ahd_print_register(SCB_SGPTR_parse_table, 3, "SCB_SGPTR",
3517             0x19c, regvalue, cur_col, wrap));
3518 }
3519
3520 int
3521 ahd_scb_busaddr_print(u_int regvalue, u_int *cur_col, u_int wrap)
3522 {
3523         return (ahd_print_register(NULL, 0, "SCB_BUSADDR",
3524             0x1a0, regvalue, cur_col, wrap));
3525 }
3526
3527 int
3528 ahd_scb_next_print(u_int regvalue, u_int *cur_col, u_int wrap)
3529 {
3530         return (ahd_print_register(NULL, 0, "SCB_NEXT",
3531             0x1a4, regvalue, cur_col, wrap));
3532 }
3533
3534 int
3535 ahd_scb_next2_print(u_int regvalue, u_int *cur_col, u_int wrap)
3536 {
3537         return (ahd_print_register(NULL, 0, "SCB_NEXT2",
3538             0x1a6, regvalue, cur_col, wrap));
3539 }
3540
3541 static ahd_reg_parse_entry_t SCB_CONTROL_parse_table[] = {
3542         { "SCB_TAG_TYPE",       0x03, 0x03 },
3543         { "DISCONNECTED",       0x04, 0x04 },
3544         { "STATUS_RCVD",        0x08, 0x08 },
3545         { "MK_MESSAGE",         0x10, 0x10 },
3546         { "TAG_ENB",            0x20, 0x20 },
3547         { "DISCENB",            0x40, 0x40 },
3548         { "TARGET_SCB",         0x80, 0x80 }
3549 };
3550
3551 int
3552 ahd_scb_control_print(u_int regvalue, u_int *cur_col, u_int wrap)
3553 {
3554         return (ahd_print_register(SCB_CONTROL_parse_table, 7, "SCB_CONTROL",
3555             0x1a8, regvalue, cur_col, wrap));
3556 }
3557
3558 static ahd_reg_parse_entry_t SCB_SCSIID_parse_table[] = {
3559         { "OID",                0x0f, 0x0f },
3560         { "TID",                0xf0, 0xf0 }
3561 };
3562
3563 int
3564 ahd_scb_scsiid_print(u_int regvalue, u_int *cur_col, u_int wrap)
3565 {
3566         return (ahd_print_register(SCB_SCSIID_parse_table, 2, "SCB_SCSIID",
3567             0x1a9, regvalue, cur_col, wrap));
3568 }
3569
3570 static ahd_reg_parse_entry_t SCB_LUN_parse_table[] = {
3571         { "LID",                0xff, 0xff }
3572 };
3573
3574 int
3575 ahd_scb_lun_print(u_int regvalue, u_int *cur_col, u_int wrap)
3576 {
3577         return (ahd_print_register(SCB_LUN_parse_table, 1, "SCB_LUN",
3578             0x1aa, regvalue, cur_col, wrap));
3579 }
3580
3581 int
3582 ahd_scb_task_attribute_print(u_int regvalue, u_int *cur_col, u_int wrap)
3583 {
3584         return (ahd_print_register(NULL, 0, "SCB_TASK_ATTRIBUTE",
3585             0x1ab, regvalue, cur_col, wrap));
3586 }
3587
3588 static ahd_reg_parse_entry_t SCB_CDB_LEN_parse_table[] = {
3589         { "SCB_CDB_LEN_PTR",    0x80, 0x80 }
3590 };
3591
3592 int
3593 ahd_scb_cdb_len_print(u_int regvalue, u_int *cur_col, u_int wrap)
3594 {
3595         return (ahd_print_register(SCB_CDB_LEN_parse_table, 1, "SCB_CDB_LEN",
3596             0x1ac, regvalue, cur_col, wrap));
3597 }
3598
3599 int
3600 ahd_scb_task_management_print(u_int regvalue, u_int *cur_col, u_int wrap)
3601 {
3602         return (ahd_print_register(NULL, 0, "SCB_TASK_MANAGEMENT",
3603             0x1ad, regvalue, cur_col, wrap));
3604 }
3605
3606 int
3607 ahd_scb_tag_print(u_int regvalue, u_int *cur_col, u_int wrap)
3608 {
3609         return (ahd_print_register(NULL, 0, "SCB_TAG",
3610             0x1ae, regvalue, cur_col, wrap));
3611 }
3612
3613 int
3614 ahd_scb_spare_print(u_int regvalue, u_int *cur_col, u_int wrap)
3615 {
3616         return (ahd_print_register(NULL, 0, "SCB_SPARE",
3617             0x1b0, regvalue, cur_col, wrap));
3618 }
3619
3620 int
3621 ahd_scb_disconnected_lists_print(u_int regvalue, u_int *cur_col, u_int wrap)
3622 {
3623         return (ahd_print_register(NULL, 0, "SCB_DISCONNECTED_LISTS",
3624             0x1b8, regvalue, cur_col, wrap));
3625 }
3626