Return to cmdcnst.h CVS log

Up to [WindowsNT SDKs] / ntddk / src / video / miniport / et4000

Annotation of ntddk/src/video/miniport/et4000/cmdcnst.h, revision 1.1

1.1     ! root        1: /*++
        !             2: 
        !             3: Copyright (c) 1992  Microsoft Corporation
        !             4: 
        !             5: Module Name:
        !             6: 
        !             7:     cmdcnst.h
        !             8: 
        !             9: Abstract:
        !            10: 
        !            11:     This is the command string interpreter definitions
        !            12: 
        !            13: Environment:
        !            14: 
        !            15:     kernel mode only
        !            16: 
        !            17: Notes:
        !            18: 
        !            19: Revision History:
        !            20: 
        !            21: --*/
        !            22: 
        !            23: //--------------------------------------------------------------------------
        !            24: //   Definition of the set/clear mode command language.
        !            25: //
        !            26: //   Each command is composed of a major portion and a minor portion.
        !            27: //   The major portion of a command can be found in the most significant
        !            28: //   nibble of a command byte, while the minor portion is in the least
        !            29: //   significant portion of a command byte.
        !            30: //
        !            31: //   maj  minor      Description
        !            32: //   ---- -----      --------------------------------------------
        !            33: //   00              End of data
        !            34: //
        !            35: //   10              in and out type commands as described by flags
        !            36: //        flags:
        !            37: //
        !            38: //        xxxx
        !            39: //        ||||
        !            40: //        |||+-------- unused
        !            41: //        ||+--------- 0/1 single/multiple values to output (in's are always 
        !            42: //        |+---------- 0/1 8/16 bit operation                  single)
        !            43: //        +----------- 0/1 out/in instruction
        !            44: //
        !            45: //       Outs
        !            46: //       ----------------------------------------------
        !            47: //       0           reg:W val:B
        !            48: //       2           reg:W cnt:W val1:B val2:B...valN:B
        !            49: //       4           reg:W val:W
        !            50: //       6           reg:W cnt:W val1:W val2:W...valN:W
        !            51: //
        !            52: //       Ins
        !            53: //       ----------------------------------------------
        !            54: //       8           reg:W
        !            55: //       a           reg:W cnt:W
        !            56: //       c           reg:W
        !            57: //       e           reg:W cnt:W
        !            58: //
        !            59: //   20              Special purpose outs
        !            60: //       00          do indexed outs for seq, crtc, and gdc
        !            61: //                   indexreg:W cnt:B startindex:B val1:B val2:B...valN:B
        !            62: //       01          do indexed outs for atc
        !            63: //                   index-data_reg:W cnt:B startindex:B val1:B val2:B...valN:B
        !            64: //       02          do masked outs
        !            65: //                   indexreg:W andmask:B xormask:B
        !            66: //
        !            67: //   F0              Nop
        !            68: //
        !            69: //---------------------------------------------------------------------------
        !            70: 
        !            71: // some useful equates - major commands
        !            72: 
        !            73: #define EOD     0x000                   // end of data
        !            74: #define INOUT   0x010                   // do ins or outs
        !            75: #define METAOUT 0x020                   // do special types of outs
        !            76: #define NCMD    0x0f0                   // Nop command
        !            77: 
        !            78: 
        !            79: // flags for INOUT major command
        !            80: 
        !            81: //#define UNUSED    0x01                    // reserved
        !            82: #define MULTI   0x02                    // multiple or single outs
        !            83: #define BW      0x04                    // byte/word size of operation
        !            84: #define IO      0x08                    // out/in instruction
        !            85: 
        !            86: // minor commands for metout
        !            87: 
        !            88: #define INDXOUT 0x00                    // do indexed outs
        !            89: #define ATCOUT  0x01                    // do indexed outs for atc
        !            90: #define MASKOUT 0x02                    // do masked outs using and-xor masks
        !            91: 
        !            92: 
        !            93: // composite inout type commands
        !            94: 
        !            95: #define OB      (INOUT)                 // output 8 bit value
        !            96: #define OBM     (INOUT+MULTI)           // output multiple bytes
        !            97: #define OW      (INOUT+BW)              // output single word value
        !            98: #define OWM     (INOUT+BW+MULTI)        // output multiple words
        !            99: 
        !           100: #define IB      (INOUT+IO)              // input byte
        !           101: #define IBM     (INOUT+IO+MULTI)        // input multiple bytes
        !           102: #define IW      (INOUT+IO+BW)           // input word
        !           103: #define IWM     (INOUT+IO+BW+MULTI)     // input multiple words

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.