drivers/scsi/aic7xxx/aic7xxx_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/aic7xxx.seq#58 $
   6  * $Id: //depot/aic7xxx/aic7xxx/aic7xxx.reg#40 $
   7  */
   8
   9 #include "aic7xxx_osm.h"
  10
  11 static const ahc_reg_parse_entry_t SCSISEQ_parse_table[] = {
  12         { "SCSIRSTO",           0x01, 0x01 },
  13         { "ENAUTOATNP",         0x02, 0x02 },
  14         { "ENAUTOATNI",         0x04, 0x04 },
  15         { "ENAUTOATNO",         0x08, 0x08 },
  16         { "ENRSELI",            0x10, 0x10 },
  17         { "ENSELI",             0x20, 0x20 },
  18         { "ENSELO",             0x40, 0x40 },
  19         { "TEMODE",             0x80, 0x80 }
  20 };
  21
  22 int
  23 ahc_scsiseq_print(u_int regvalue, u_int *cur_col, u_int wrap)
  24 {
  25         return (ahc_print_register(SCSISEQ_parse_table, 8, "SCSISEQ",
  26             0x00, regvalue, cur_col, wrap));
  27 }
  28
  29 static const ahc_reg_parse_entry_t SXFRCTL0_parse_table[] = {
  30         { "CLRCHN",             0x02, 0x02 },
  31         { "SCAMEN",             0x04, 0x04 },
  32         { "SPIOEN",             0x08, 0x08 },
  33         { "CLRSTCNT",           0x10, 0x10 },
  34         { "FAST20",             0x20, 0x20 },
  35         { "DFPEXP",             0x40, 0x40 },
  36         { "DFON",               0x80, 0x80 }
  37 };
  38
  39 int
  40 ahc_sxfrctl0_print(u_int regvalue, u_int *cur_col, u_int wrap)
  41 {
  42         return (ahc_print_register(SXFRCTL0_parse_table, 7, "SXFRCTL0",
  43             0x01, regvalue, cur_col, wrap));
  44 }
  45
  46 static const ahc_reg_parse_entry_t SCSISIGI_parse_table[] = {
  47         { "ACKI",               0x01, 0x01 },
  48         { "REQI",               0x02, 0x02 },
  49         { "BSYI",               0x04, 0x04 },
  50         { "SELI",               0x08, 0x08 },
  51         { "ATNI",               0x10, 0x10 },
  52         { "MSGI",               0x20, 0x20 },
  53         { "IOI",                0x40, 0x40 },
  54         { "CDI",                0x80, 0x80 },
  55         { "P_DATAOUT",          0x00, 0x00 },
  56         { "P_DATAOUT_DT",       0x20, 0x20 },
  57         { "P_DATAIN",           0x40, 0x40 },
  58         { "P_DATAIN_DT",        0x60, 0x60 },
  59         { "P_COMMAND",          0x80, 0x80 },
  60         { "P_MESGOUT",          0xa0, 0xa0 },
  61         { "P_STATUS",           0xc0, 0xc0 },
  62         { "PHASE_MASK",         0xe0, 0xe0 },
  63         { "P_MESGIN",           0xe0, 0xe0 }
  64 };
  65
  66 int
  67 ahc_scsisigi_print(u_int regvalue, u_int *cur_col, u_int wrap)
  68 {
  69         return (ahc_print_register(SCSISIGI_parse_table, 17, "SCSISIGI",
  70             0x03, regvalue, cur_col, wrap));
  71 }
  72
  73 static const ahc_reg_parse_entry_t SCSIRATE_parse_table[] = {
  74         { "SINGLE_EDGE",        0x10, 0x10 },
  75         { "ENABLE_CRC",         0x40, 0x40 },
  76         { "WIDEXFER",           0x80, 0x80 },
  77         { "SXFR_ULTRA2",        0x0f, 0x0f },
  78         { "SOFS",               0x0f, 0x0f },
  79         { "SXFR",               0x70, 0x70 }
  80 };
  81
  82 int
  83 ahc_scsirate_print(u_int regvalue, u_int *cur_col, u_int wrap)
  84 {
  85         return (ahc_print_register(SCSIRATE_parse_table, 6, "SCSIRATE",
  86             0x04, regvalue, cur_col, wrap));
  87 }
  88
  89 static const ahc_reg_parse_entry_t SSTAT0_parse_table[] = {
  90         { "DMADONE",            0x01, 0x01 },
  91         { "SPIORDY",            0x02, 0x02 },
  92         { "SDONE",              0x04, 0x04 },
  93         { "SWRAP",              0x08, 0x08 },
  94         { "IOERR",              0x08, 0x08 },
  95         { "SELINGO",            0x10, 0x10 },
  96         { "SELDI",              0x20, 0x20 },
  97         { "SELDO",              0x40, 0x40 },
  98         { "TARGET",             0x80, 0x80 }
  99 };
 100
 101 int
 102 ahc_sstat0_print(u_int regvalue, u_int *cur_col, u_int wrap)
 103 {
 104         return (ahc_print_register(SSTAT0_parse_table, 9, "SSTAT0",
 105             0x0b, regvalue, cur_col, wrap));
 106 }
 107
 108 static const ahc_reg_parse_entry_t SSTAT1_parse_table[] = {
 109         { "REQINIT",            0x01, 0x01 },
 110         { "PHASECHG",           0x02, 0x02 },
 111         { "SCSIPERR",           0x04, 0x04 },
 112         { "BUSFREE",            0x08, 0x08 },
 113         { "PHASEMIS",           0x10, 0x10 },
 114         { "SCSIRSTI",           0x20, 0x20 },
 115         { "ATNTARG",            0x40, 0x40 },
 116         { "SELTO",              0x80, 0x80 }
 117 };
 118
 119 int
 120 ahc_sstat1_print(u_int regvalue, u_int *cur_col, u_int wrap)
 121 {
 122         return (ahc_print_register(SSTAT1_parse_table, 8, "SSTAT1",
 123             0x0c, regvalue, cur_col, wrap));
 124 }
 125
 126 static const ahc_reg_parse_entry_t SSTAT2_parse_table[] = {
 127         { "DUAL_EDGE_ERR",      0x01, 0x01 },
 128         { "CRCREQERR",          0x02, 0x02 },
 129         { "CRCENDERR",          0x04, 0x04 },
 130         { "CRCVALERR",          0x08, 0x08 },
 131         { "EXP_ACTIVE",         0x10, 0x10 },
 132         { "SHVALID",            0x40, 0x40 },
 133         { "OVERRUN",            0x80, 0x80 },
 134         { "SFCNT",              0x1f, 0x1f }
 135 };
 136
 137 int
 138 ahc_sstat2_print(u_int regvalue, u_int *cur_col, u_int wrap)
 139 {
 140         return (ahc_print_register(SSTAT2_parse_table, 8, "SSTAT2",
 141             0x0d, regvalue, cur_col, wrap));
 142 }
 143
 144 static const ahc_reg_parse_entry_t SSTAT3_parse_table[] = {
 145         { "OFFCNT",             0x0f, 0x0f },
 146         { "U2OFFCNT",           0x7f, 0x7f },
 147         { "SCSICNT",            0xf0, 0xf0 }
 148 };
 149
 150 int
 151 ahc_sstat3_print(u_int regvalue, u_int *cur_col, u_int wrap)
 152 {
 153         return (ahc_print_register(SSTAT3_parse_table, 3, "SSTAT3",
 154             0x0e, regvalue, cur_col, wrap));
 155 }
 156
 157 static const ahc_reg_parse_entry_t SIMODE0_parse_table[] = {
 158         { "ENDMADONE",          0x01, 0x01 },
 159         { "ENSPIORDY",          0x02, 0x02 },
 160         { "ENSDONE",            0x04, 0x04 },
 161         { "ENSWRAP",            0x08, 0x08 },
 162         { "ENIOERR",            0x08, 0x08 },
 163         { "ENSELINGO",          0x10, 0x10 },
 164         { "ENSELDI",            0x20, 0x20 },
 165         { "ENSELDO",            0x40, 0x40 }
 166 };
 167
 168 int
 169 ahc_simode0_print(u_int regvalue, u_int *cur_col, u_int wrap)
 170 {
 171         return (ahc_print_register(SIMODE0_parse_table, 8, "SIMODE0",
 172             0x10, regvalue, cur_col, wrap));
 173 }
 174
 175 static const ahc_reg_parse_entry_t SIMODE1_parse_table[] = {
 176         { "ENREQINIT",          0x01, 0x01 },
 177         { "ENPHASECHG",         0x02, 0x02 },
 178         { "ENSCSIPERR",         0x04, 0x04 },
 179         { "ENBUSFREE",          0x08, 0x08 },
 180         { "ENPHASEMIS",         0x10, 0x10 },
 181         { "ENSCSIRST",          0x20, 0x20 },
 182         { "ENATNTARG",          0x40, 0x40 },
 183         { "ENSELTIMO",          0x80, 0x80 }
 184 };
 185
 186 int
 187 ahc_simode1_print(u_int regvalue, u_int *cur_col, u_int wrap)
 188 {
 189         return (ahc_print_register(SIMODE1_parse_table, 8, "SIMODE1",
 190             0x11, regvalue, cur_col, wrap));
 191 }
 192
 193 int
 194 ahc_scsibusl_print(u_int regvalue, u_int *cur_col, u_int wrap)
 195 {
 196         return (ahc_print_register(NULL, 0, "SCSIBUSL",
 197             0x12, regvalue, cur_col, wrap));
 198 }
 199
 200 static const ahc_reg_parse_entry_t SBLKCTL_parse_table[] = {
 201         { "XCVR",               0x01, 0x01 },
 202         { "SELWIDE",            0x02, 0x02 },
 203         { "ENAB20",             0x04, 0x04 },
 204         { "SELBUSB",            0x08, 0x08 },
 205         { "ENAB40",             0x08, 0x08 },
 206         { "AUTOFLUSHDIS",       0x20, 0x20 },
 207         { "DIAGLEDON",          0x40, 0x40 },
 208         { "DIAGLEDEN",          0x80, 0x80 }
 209 };
 210
 211 int
 212 ahc_sblkctl_print(u_int regvalue, u_int *cur_col, u_int wrap)
 213 {
 214         return (ahc_print_register(SBLKCTL_parse_table, 8, "SBLKCTL",
 215             0x1f, regvalue, cur_col, wrap));
 216 }
 217
 218 static const ahc_reg_parse_entry_t SEQ_FLAGS_parse_table[] = {
 219         { "NO_DISCONNECT",      0x01, 0x01 },
 220         { "SPHASE_PENDING",     0x02, 0x02 },
 221         { "DPHASE_PENDING",     0x04, 0x04 },
 222         { "CMDPHASE_PENDING",   0x08, 0x08 },
 223         { "TARG_CMD_PENDING",   0x10, 0x10 },
 224         { "DPHASE",             0x20, 0x20 },
 225         { "NO_CDB_SENT",        0x40, 0x40 },
 226         { "TARGET_CMD_IS_TAGGED",0x40, 0x40 },
 227         { "NOT_IDENTIFIED",     0x80, 0x80 }
 228 };
 229
 230 int
 231 ahc_seq_flags_print(u_int regvalue, u_int *cur_col, u_int wrap)
 232 {
 233         return (ahc_print_register(SEQ_FLAGS_parse_table, 9, "SEQ_FLAGS",
 234             0x3c, regvalue, cur_col, wrap));
 235 }
 236
 237 static const ahc_reg_parse_entry_t LASTPHASE_parse_table[] = {
 238         { "MSGI",               0x20, 0x20 },
 239         { "IOI",                0x40, 0x40 },
 240         { "CDI",                0x80, 0x80 },
 241         { "P_DATAOUT",          0x00, 0x00 },
 242         { "P_BUSFREE",          0x01, 0x01 },
 243         { "P_DATAIN",           0x40, 0x40 },
 244         { "P_COMMAND",          0x80, 0x80 },
 245         { "P_MESGOUT",          0xa0, 0xa0 },
 246         { "P_STATUS",           0xc0, 0xc0 },
 247         { "PHASE_MASK",         0xe0, 0xe0 },
 248         { "P_MESGIN",           0xe0, 0xe0 }
 249 };
 250
 251 int
 252 ahc_lastphase_print(u_int regvalue, u_int *cur_col, u_int wrap)
 253 {
 254         return (ahc_print_register(LASTPHASE_parse_table, 11, "LASTPHASE",
 255             0x3f, regvalue, cur_col, wrap));
 256 }
 257
 258 static const ahc_reg_parse_entry_t SEQCTL_parse_table[] = {
 259         { "LOADRAM",            0x01, 0x01 },
 260         { "SEQRESET",           0x02, 0x02 },
 261         { "STEP",               0x04, 0x04 },
 262         { "BRKADRINTEN",        0x08, 0x08 },
 263         { "FASTMODE",           0x10, 0x10 },
 264         { "FAILDIS",            0x20, 0x20 },
 265         { "PAUSEDIS",           0x40, 0x40 },
 266         { "PERRORDIS",          0x80, 0x80 }
 267 };
 268
 269 int
 270 ahc_seqctl_print(u_int regvalue, u_int *cur_col, u_int wrap)
 271 {
 272         return (ahc_print_register(SEQCTL_parse_table, 8, "SEQCTL",
 273             0x60, regvalue, cur_col, wrap));
 274 }
 275
 276 int
 277 ahc_sram_base_print(u_int regvalue, u_int *cur_col, u_int wrap)
 278 {
 279         return (ahc_print_register(NULL, 0, "SRAM_BASE",
 280             0x70, regvalue, cur_col, wrap));
 281 }
 282
 283 static const ahc_reg_parse_entry_t ERROR_parse_table[] = {
 284         { "ILLHADDR",           0x01, 0x01 },
 285         { "ILLSADDR",           0x02, 0x02 },
 286         { "ILLOPCODE",          0x04, 0x04 },
 287         { "SQPARERR",           0x08, 0x08 },
 288         { "DPARERR",            0x10, 0x10 },
 289         { "MPARERR",            0x20, 0x20 },
 290         { "PCIERRSTAT",         0x40, 0x40 },
 291         { "CIOPARERR",          0x80, 0x80 }
 292 };
 293
 294 int
 295 ahc_error_print(u_int regvalue, u_int *cur_col, u_int wrap)
 296 {
 297         return (ahc_print_register(ERROR_parse_table, 8, "ERROR",
 298             0x92, regvalue, cur_col, wrap));
 299 }
 300
 301 static const ahc_reg_parse_entry_t DFCNTRL_parse_table[] = {
 302         { "FIFORESET",          0x01, 0x01 },
 303         { "FIFOFLUSH",          0x02, 0x02 },
 304         { "DIRECTION",          0x04, 0x04 },
 305         { "HDMAEN",             0x08, 0x08 },
 306         { "HDMAENACK",          0x08, 0x08 },
 307         { "SDMAEN",             0x10, 0x10 },
 308         { "SDMAENACK",          0x10, 0x10 },
 309         { "SCSIEN",             0x20, 0x20 },
 310         { "WIDEODD",            0x40, 0x40 },
 311         { "PRELOADEN",          0x80, 0x80 }
 312 };
 313
 314 int
 315 ahc_dfcntrl_print(u_int regvalue, u_int *cur_col, u_int wrap)
 316 {
 317         return (ahc_print_register(DFCNTRL_parse_table, 10, "DFCNTRL",
 318             0x93, regvalue, cur_col, wrap));
 319 }
 320
 321 static const ahc_reg_parse_entry_t DFSTATUS_parse_table[] = {
 322         { "FIFOEMP",            0x01, 0x01 },
 323         { "FIFOFULL",           0x02, 0x02 },
 324         { "DFTHRESH",           0x04, 0x04 },
 325         { "HDONE",              0x08, 0x08 },
 326         { "MREQPEND",           0x10, 0x10 },
 327         { "FIFOQWDEMP",         0x20, 0x20 },
 328         { "DFCACHETH",          0x40, 0x40 },
 329         { "PRELOAD_AVAIL",      0x80, 0x80 }
 330 };
 331
 332 int
 333 ahc_dfstatus_print(u_int regvalue, u_int *cur_col, u_int wrap)
 334 {
 335         return (ahc_print_register(DFSTATUS_parse_table, 8, "DFSTATUS",
 336             0x94, regvalue, cur_col, wrap));
 337 }
 338
 339 static const ahc_reg_parse_entry_t SCSIPHASE_parse_table[] = {
 340         { "DATA_OUT_PHASE",     0x01, 0x01 },
 341         { "DATA_IN_PHASE",      0x02, 0x02 },
 342         { "MSG_OUT_PHASE",      0x04, 0x04 },
 343         { "MSG_IN_PHASE",       0x08, 0x08 },
 344         { "COMMAND_PHASE",      0x10, 0x10 },
 345         { "STATUS_PHASE",       0x20, 0x20 },
 346         { "DATA_PHASE_MASK",    0x03, 0x03 }
 347 };
 348
 349 int
 350 ahc_scsiphase_print(u_int regvalue, u_int *cur_col, u_int wrap)
 351 {
 352         return (ahc_print_register(SCSIPHASE_parse_table, 7, "SCSIPHASE",
 353             0x9e, regvalue, cur_col, wrap));
 354 }
 355
 356 int
 357 ahc_scb_base_print(u_int regvalue, u_int *cur_col, u_int wrap)
 358 {
 359         return (ahc_print_register(NULL, 0, "SCB_BASE",
 360             0xa0, regvalue, cur_col, wrap));
 361 }
 362
 363 static const ahc_reg_parse_entry_t SCB_CONTROL_parse_table[] = {
 364         { "DISCONNECTED",       0x04, 0x04 },
 365         { "ULTRAENB",           0x08, 0x08 },
 366         { "MK_MESSAGE",         0x10, 0x10 },
 367         { "TAG_ENB",            0x20, 0x20 },
 368         { "DISCENB",            0x40, 0x40 },
 369         { "TARGET_SCB",         0x80, 0x80 },
 370         { "STATUS_RCVD",        0x80, 0x80 },
 371         { "SCB_TAG_TYPE",       0x03, 0x03 }
 372 };
 373
 374 int
 375 ahc_scb_control_print(u_int regvalue, u_int *cur_col, u_int wrap)
 376 {
 377         return (ahc_print_register(SCB_CONTROL_parse_table, 8, "SCB_CONTROL",
 378             0xb8, regvalue, cur_col, wrap));
 379 }
 380
 381 static const ahc_reg_parse_entry_t SCB_SCSIID_parse_table[] = {
 382         { "TWIN_CHNLB",         0x80, 0x80 },
 383         { "OID",                0x0f, 0x0f },
 384         { "TWIN_TID",           0x70, 0x70 },
 385         { "TID",                0xf0, 0xf0 }
 386 };
 387
 388 int
 389 ahc_scb_scsiid_print(u_int regvalue, u_int *cur_col, u_int wrap)
 390 {
 391         return (ahc_print_register(SCB_SCSIID_parse_table, 4, "SCB_SCSIID",
 392             0xb9, regvalue, cur_col, wrap));
 393 }
 394
 395 static const ahc_reg_parse_entry_t SCB_LUN_parse_table[] = {
 396         { "SCB_XFERLEN_ODD",    0x80, 0x80 },
 397         { "LID",                0x3f, 0x3f }
 398 };
 399
 400 int
 401 ahc_scb_lun_print(u_int regvalue, u_int *cur_col, u_int wrap)
 402 {
 403         return (ahc_print_register(SCB_LUN_parse_table, 2, "SCB_LUN",
 404             0xba, regvalue, cur_col, wrap));
 405 }
 406
 407 int
 408 ahc_scb_tag_print(u_int regvalue, u_int *cur_col, u_int wrap)
 409 {
 410         return (ahc_print_register(NULL, 0, "SCB_TAG",
 411             0xbb, regvalue, cur_col, wrap));
 412 }
 413