drivers/char/ip2/i2cmd.h

   1 /*******************************************************************************
   2 *
   3 *   (c) 1999 by Computone Corporation
   4 *
   5 ********************************************************************************
   6 *
   7 *
   8 *   PACKAGE:     Linux tty Device Driver for IntelliPort II family of multiport
   9 *                serial I/O controllers.
  10 *
  11 *   DESCRIPTION: Definitions and support for In-line and Bypass commands.
  12 *                Applicable only when the standard loadware is active.
  13 *
  14 *******************************************************************************/
  15 //------------------------------------------------------------------------------
  16 // Revision History:
  17 //
  18 // 10 October 1991   MAG First Draft
  19 //  7 November 1991  MAG Reflects some new commands
  20 // 20 February 1992  MAG CMD_HOTACK corrected: no argument.
  21 // 24 February 1992  MAG Support added for new commands for 1.4.x loadware.
  22 // 11 March 1992     MAG Additional commands.
  23 // 16 March 1992     MAG Additional commands.
  24 // 30 March 1992     MAG Additional command: CMD_DSS_NOW
  25 // 18 May   1992     MAG Changed CMD_OPOST
  26 //
  27 //------------------------------------------------------------------------------
  28 #ifndef I2CMD_H      // To prevent multiple includes
  29 #define I2CMD_H   1
  30
  31 #include "ip2types.h"
  32
  33 // This module is designed to provide a uniform method of sending commands to
  34 // the board through command packets. The difficulty is, some commands take
  35 // parameters, others do not. Furthermore, it is often useful to send several
  36 // commands to the same channel as part of the same packet. (See also i2pack.h.)
  37 //
  38 // This module is designed so that the caller should not be responsible for
  39 // remembering the exact syntax of each command, or at least so that the
  40 // compiler could check things somewhat. I'll explain as we go...
  41 //
  42 // First, a structure which can embody the syntax of each type of command.
  43 //
  44 typedef struct _cmdSyntax
  45 {
  46         UCHAR length;   // Number of bytes in the command
  47         UCHAR flags;    // Information about the command (see below)
  48
  49         // The command and its parameters, which may be of arbitrary length. Don't
  50         // worry yet how the parameters will be initialized; macros later take care
  51         // of it. Also, don't worry about the arbitrary length issue; this structure
  52         // is never used to allocate space (see i2cmd.c).
  53         UCHAR cmd[2];
  54 } cmdSyntax, *cmdSyntaxPtr;
  55
  56 // Bit assignments for flags
  57
  58 #define INL 1           // Set if suitable for inline commands
  59 #define BYP 2           // Set if suitable for bypass commands
  60 #define BTH (INL|BYP)   // suitable for either!
  61 #define END 4           // Set if this must be the last command in a block
  62 #define VIP 8           // Set if this command is special in some way and really
  63                                                 // should only be sent from the library-level and not
  64                                                 // directly from user-level
  65 #define VAR 0x10        // This command is of variable length!
  66
  67 //-----------------------------------
  68 // External declarations for i2cmd.c
  69 //-----------------------------------
  70 // Routine to set up parameters for the "define hot-key sequence" command. Since
  71 // there is more than one parameter to assign, we must use a function rather
  72 // than a macro (used usually).
  73 //
  74 extern cmdSyntaxPtr i2cmdSetSeq(UCHAR seqno, UCHAR size, UCHAR *string);
  75 extern cmdSyntaxPtr i2cmdUnixFlags(USHORT iflag,USHORT cflag,USHORT lflag);
  76 extern cmdSyntaxPtr i2cmdBaudRemap(UCHAR dest, UCHAR src);
  77 extern cmdSyntaxPtr i2cmdBaudDef(int which, USHORT rate);
  78
  79 // Declarations for the global arrays used to bear the commands and their
  80 // arguments.
  81 //
  82 // Note: Since these are globals and the arguments might change, it is important
  83 // that the library routine COPY these into buffers from whence they would be
  84 // sent, rather than merely storing the pointers. In multi-threaded
  85 // environments, important that the copy should obtain before any context switch
  86 // is allowed. Also, for parameterized commands, DO NOT ISSUE THE SAME COMMAND
  87 // MORE THAN ONCE WITH THE SAME PARAMETERS in the same call.
  88 //
  89 static UCHAR ct02[];
  90 static UCHAR ct03[];
  91 static UCHAR ct04[];
  92 static UCHAR ct05[];
  93 static UCHAR ct06[];
  94 static UCHAR ct07[];
  95 static UCHAR ct08[];
  96 static UCHAR ct09[];
  97 static UCHAR ct10[];
  98 static UCHAR ct11[];
  99 static UCHAR ct12[];
 100 static UCHAR ct13[];
 101 static UCHAR ct14[];
 102 static UCHAR ct15[];
 103 static UCHAR ct16[];
 104 static UCHAR ct17[];
 105 static UCHAR ct18[];
 106 static UCHAR ct19[];
 107 static UCHAR ct20[];
 108 static UCHAR ct21[];
 109 static UCHAR ct22[];
 110 static UCHAR ct23[];
 111 static UCHAR ct24[];
 112 static UCHAR ct25[];
 113 static UCHAR ct26[];
 114 static UCHAR ct27[];
 115 static UCHAR ct28[];
 116 static UCHAR ct29[];
 117 static UCHAR ct30[];
 118 static UCHAR ct31[];
 119 static UCHAR ct32[];
 120 static UCHAR ct33[];
 121 static UCHAR ct34[];
 122 static UCHAR ct35[];
 123 static UCHAR ct36[];
 124 static UCHAR ct36a[];
 125 static UCHAR ct41[];
 126 static UCHAR ct42[];
 127 static UCHAR ct43[];
 128 static UCHAR ct44[];
 129 static UCHAR ct45[];
 130 static UCHAR ct46[];
 131 static UCHAR ct48[];
 132 static UCHAR ct49[];
 133 static UCHAR ct50[];
 134 static UCHAR ct51[];
 135 static UCHAR ct52[];
 136 static UCHAR ct56[];
 137 static UCHAR ct57[];
 138 static UCHAR ct58[];
 139 static UCHAR ct59[];
 140 static UCHAR ct60[];
 141 static UCHAR ct61[];
 142 static UCHAR ct62[];
 143 static UCHAR ct63[];
 144 static UCHAR ct64[];
 145 static UCHAR ct65[];
 146 static UCHAR ct66[];
 147 static UCHAR ct67[];
 148 static UCHAR ct68[];
 149 static UCHAR ct69[];
 150 static UCHAR ct70[];
 151 static UCHAR ct71[];
 152 static UCHAR ct72[];
 153 static UCHAR ct73[];
 154 static UCHAR ct74[];
 155 static UCHAR ct75[];
 156 static UCHAR ct76[];
 157 static UCHAR ct77[];
 158 static UCHAR ct78[];
 159 static UCHAR ct79[];
 160 static UCHAR ct80[];
 161 static UCHAR ct81[];
 162 static UCHAR ct82[];
 163 static UCHAR ct83[];
 164 static UCHAR ct84[];
 165 static UCHAR ct85[];
 166 static UCHAR ct86[];
 167 static UCHAR ct87[];
 168 static UCHAR ct88[];
 169 static UCHAR ct89[];
 170 static UCHAR ct90[];
 171 static UCHAR ct91[];
 172 static UCHAR cc01[];
 173 static UCHAR cc02[];
 174
 175 // Now, refer to i2cmd.c, and see the character arrays defined there. They are
 176 // cast here to cmdSyntaxPtr.
 177 //
 178 // There are library functions for issuing bypass or inline commands. These
 179 // functions take one or more arguments of the type cmdSyntaxPtr. The routine
 180 // then can figure out how long each command is supposed to be and easily add it
 181 // to the list.
 182 //
 183 // For ease of use, we define manifests which return pointers to appropriate
 184 // cmdSyntaxPtr things. But some commands also take arguments. If a single
 185 // argument is used, we define a macro which performs the single assignment and
 186 // (through the expedient of a comma expression) references the appropriate
 187 // pointer. For commands requiring several arguments, we actually define a
 188 // function to perform the assignments.
 189
 190 #define CMD_DTRUP       (cmdSyntaxPtr)(ct02)    // Raise DTR
 191 #define CMD_DTRDN       (cmdSyntaxPtr)(ct03)    // Lower DTR
 192 #define CMD_RTSUP       (cmdSyntaxPtr)(ct04)    // Raise RTS
 193 #define CMD_RTSDN       (cmdSyntaxPtr)(ct05)    // Lower RTS
 194 #define CMD_STARTFL     (cmdSyntaxPtr)(ct06)    // Start Flushing Data
 195
 196 #define CMD_DTRRTS_UP (cmdSyntaxPtr)(cc01)      // Raise DTR and RTS
 197 #define CMD_DTRRTS_DN (cmdSyntaxPtr)(cc02)      // Lower DTR and RTS
 198
 199 // Set Baud Rate for transmit and receive
 200 #define CMD_SETBAUD(arg) \
 201         (((cmdSyntaxPtr)(ct07))->cmd[1] = (arg),(cmdSyntaxPtr)(ct07))
 202
 203 #define CBR_50       1
 204 #define CBR_75       2
 205 #define CBR_110      3
 206 #define CBR_134      4
 207 #define CBR_150      5
 208 #define CBR_200      6
 209 #define CBR_300      7
 210 #define CBR_600      8
 211 #define CBR_1200     9
 212 #define CBR_1800     10
 213 #define CBR_2400     11
 214 #define CBR_4800     12
 215 #define CBR_9600     13
 216 #define CBR_19200    14
 217 #define CBR_38400    15
 218 #define CBR_2000     16
 219 #define CBR_3600     17
 220 #define CBR_7200     18
 221 #define CBR_56000    19
 222 #define CBR_57600    20
 223 #define CBR_64000    21
 224 #define CBR_76800    22
 225 #define CBR_115200   23
 226 #define CBR_C1       24    // Custom baud rate 1
 227 #define CBR_C2       25    // Custom baud rate 2
 228 #define CBR_153600   26
 229 #define CBR_230400   27
 230 #define CBR_307200   28
 231 #define CBR_460800   29
 232 #define CBR_921600   30
 233
 234 // Set Character size
 235 //
 236 #define CMD_SETBITS(arg) \
 237         (((cmdSyntaxPtr)(ct08))->cmd[1] = (arg),(cmdSyntaxPtr)(ct08))
 238
 239 #define CSZ_5  0
 240 #define CSZ_6  1
 241 #define CSZ_7  2
 242 #define CSZ_8  3
 243
 244 // Set number of stop bits
 245 //
 246 #define CMD_SETSTOP(arg) \
 247         (((cmdSyntaxPtr)(ct09))->cmd[1] = (arg),(cmdSyntaxPtr)(ct09))
 248
 249 #define CST_1  0
 250 #define CST_15 1  // 1.5 stop bits
 251 #define CST_2  2
 252
 253 // Set parity option
 254 //
 255 #define CMD_SETPAR(arg) \
 256         (((cmdSyntaxPtr)(ct10))->cmd[1] = (arg),(cmdSyntaxPtr)(ct10))
 257
 258 #define CSP_NP 0  // no parity
 259 #define CSP_OD 1  // odd parity
 260 #define CSP_EV 2  // Even parity
 261 #define CSP_SP 3  // Space parity
 262 #define CSP_MK 4  // Mark parity
 263
 264 // Define xon char for transmitter flow control
 265 //
 266 #define CMD_DEF_IXON(arg) \
 267         (((cmdSyntaxPtr)(ct11))->cmd[1] = (arg),(cmdSyntaxPtr)(ct11))
 268
 269 // Define xoff char for transmitter flow control
 270 //
 271 #define CMD_DEF_IXOFF(arg) \
 272         (((cmdSyntaxPtr)(ct12))->cmd[1] = (arg),(cmdSyntaxPtr)(ct12))
 273
 274 #define CMD_STOPFL   (cmdSyntaxPtr)(ct13) // Stop Flushing data
 275
 276 // Acknowledge receipt of hotkey signal
 277 //
 278 #define CMD_HOTACK   (cmdSyntaxPtr)(ct14)
 279
 280 // Define irq level to use. Should actually be sent by library-level code, not
 281 // directly from user...
 282 //
 283 #define CMDVALUE_IRQ 15 // For library use at initialization. Until this command
 284                                                 // is sent, board processing doesn't really start.
 285 #define CMD_SET_IRQ(arg) \
 286         (((cmdSyntaxPtr)(ct15))->cmd[1] = (arg),(cmdSyntaxPtr)(ct15))
 287
 288 #define CIR_POLL  0  // No IRQ - Poll
 289 #define CIR_3     3  // IRQ 3
 290 #define CIR_4     4  // IRQ 4
 291 #define CIR_5     5  // IRQ 5
 292 #define CIR_7     7  // IRQ 7
 293 #define CIR_10    10 // IRQ 10
 294 #define CIR_11    11 // IRQ 11
 295 #define CIR_12    12 // IRQ 12
 296 #define CIR_15    15 // IRQ 15
 297
 298 // Select transmit flow xon/xoff options
 299 //
 300 #define CMD_IXON_OPT(arg) \
 301         (((cmdSyntaxPtr)(ct16))->cmd[1] = (arg),(cmdSyntaxPtr)(ct16))
 302
 303 #define CIX_NONE  0  // Incoming Xon/Xoff characters not special
 304 #define CIX_XON   1  // Xoff disable, Xon enable
 305 #define CIX_XANY  2  // Xoff disable, any key enable
 306
 307 // Select receive flow xon/xoff options
 308 //
 309 #define CMD_OXON_OPT(arg) \
 310         (((cmdSyntaxPtr)(ct17))->cmd[1] = (arg),(cmdSyntaxPtr)(ct17))
 311
 312 #define COX_NONE  0  // Don't send Xon/Xoff
 313 #define COX_XON   1  // Send xon/xoff to start/stop incoming data
 314
 315
 316 #define CMD_CTS_REP  (cmdSyntaxPtr)(ct18) // Enable  CTS reporting
 317 #define CMD_CTS_NREP (cmdSyntaxPtr)(ct19) // Disable CTS reporting
 318
 319 #define CMD_DCD_REP  (cmdSyntaxPtr)(ct20) // Enable  DCD reporting
 320 #define CMD_DCD_NREP (cmdSyntaxPtr)(ct21) // Disable DCD reporting
 321
 322 #define CMD_DSR_REP  (cmdSyntaxPtr)(ct22) // Enable  DSR reporting
 323 #define CMD_DSR_NREP (cmdSyntaxPtr)(ct23) // Disable DSR reporting
 324
 325 #define CMD_RI_REP   (cmdSyntaxPtr)(ct24) // Enable  RI  reporting
 326 #define CMD_RI_NREP  (cmdSyntaxPtr)(ct25) // Disable RI  reporting
 327
 328 // Enable break reporting and select style
 329 //
 330 #define CMD_BRK_REP(arg) \
 331         (((cmdSyntaxPtr)(ct26))->cmd[1] = (arg),(cmdSyntaxPtr)(ct26))
 332
 333 #define CBK_STAT     0x00  // Report breaks as a status (exception,irq)
 334 #define CBK_NULL     0x01  // Report breaks as a good null
 335 #define CBK_STAT_SEQ 0x02  // Report breaks as a status AND as in-band character
 336                            //  sequence FFh, 01h, 10h
 337 #define CBK_SEQ      0x03  // Report breaks as the in-band
 338                                                    //sequence FFh, 01h, 10h ONLY.
 339 #define CBK_FLSH     0x04  // if this bit set also flush input data
 340 #define CBK_POSIX    0x08  // if this bit set report as FF,0,0 sequence
 341 #define CBK_SINGLE   0x10  // if this bit set with CBK_SEQ or CBK_STAT_SEQ
 342                                                    //then reports single null instead of triple
 343
 344 #define CMD_BRK_NREP (cmdSyntaxPtr)(ct27) // Disable break reporting
 345
 346 // Specify maximum block size for received data
 347 //
 348 #define CMD_MAX_BLOCK(arg) \
 349         (((cmdSyntaxPtr)(ct28))->cmd[1] = (arg),(cmdSyntaxPtr)(ct28))
 350
 351 // -- COMMAND 29 is reserved --
 352
 353 #define CMD_CTSFL_ENAB  (cmdSyntaxPtr)(ct30) // Enable  CTS flow control
 354 #define CMD_CTSFL_DSAB  (cmdSyntaxPtr)(ct31) // Disable CTS flow control
 355 #define CMD_RTSFL_ENAB  (cmdSyntaxPtr)(ct32) // Enable  RTS flow control
 356 #define CMD_RTSFL_DSAB  (cmdSyntaxPtr)(ct33) // Disable RTS flow control
 357
 358 // Specify istrip option
 359 //
 360 #define CMD_ISTRIP_OPT(arg) \
 361         (((cmdSyntaxPtr)(ct34))->cmd[1] = (arg),(cmdSyntaxPtr)(ct34))
 362
 363 #define CIS_NOSTRIP  0  // Strip characters to character size
 364 #define CIS_STRIP    1  // Strip any 8-bit characters to 7 bits
 365
 366 // Send a break of arg milliseconds
 367 //
 368 #define CMD_SEND_BRK(arg) \
 369         (((cmdSyntaxPtr)(ct35))->cmd[1] = (arg),(cmdSyntaxPtr)(ct35))
 370
 371 // Set error reporting mode
 372 //
 373 #define CMD_SET_ERROR(arg) \
 374         (((cmdSyntaxPtr)(ct36))->cmd[1] = (arg),(cmdSyntaxPtr)(ct36))
 375
 376 #define CSE_ESTAT 0  // Report error in a status packet
 377 #define CSE_NOREP 1  // Treat character as though it were good
 378 #define CSE_DROP  2  // Discard the character
 379 #define CSE_NULL  3  // Replace with a null
 380 #define CSE_MARK  4  // Replace with a 3-character sequence (as Unix)
 381
 382 #define  CMD_SET_REPLACEMENT(arg,ch)   \
 383                         (((cmdSyntaxPtr)(ct36a))->cmd[1] = (arg), \
 384                         (((cmdSyntaxPtr)(ct36a))->cmd[2] = (ch),  \
 385                         (cmdSyntaxPtr)(ct36a))
 386
 387 #define CSE_REPLACE  0x8        // Replace the errored character with the
 388                                                         // replacement character defined here
 389
 390 #define CSE_STAT_REPLACE   0x18 // Replace the errored character with the
 391                                                                 // replacement character defined here AND
 392                                                                 // report the error as a status packet (as in
 393                                                                 // CSE_ESTAT).
 394
 395
 396 // COMMAND 37, to send flow control packets, is handled only by low-level
 397 // library code in response to data movement and shouldn't ever be sent by the
 398 // user code. See i2pack.h and the body of i2lib.c for details.
 399
 400 // COMMAND 38: Define the hot-key sequence
 401 // seqno:  sequence number 0-15
 402 // size:   number of characters in sequence (1-8)
 403 // string: pointer to the characters
 404 // (if size == 0, "undefines" this sequence
 405 //
 406 #define CMD_SET_SEQ(seqno,size,string) i2cmdSetSeq(seqno,size,string)
 407
 408 // Enable on-board post-processing, using options given in oflag argument.
 409 // Formerly, this command was automatically preceded by a CMD_OPOST_OFF command
 410 // because the loadware does not permit sending back-to-back CMD_OPOST_ON
 411 // commands without an intervening CMD_OPOST_OFF. BUT, WE LEARN 18 MAY 92, that
 412 // CMD_OPOST_ON and CMD_OPOST_OFF must each be at the end of a packet (or in a
 413 // solo packet). This means the caller must specify separately CMD_OPOST_OFF,
 414 // CMD_OPOST_ON(parm) when he calls i2QueueCommands(). That function will ensure
 415 // each gets a separate packet. Extra CMD_OPOST_OFF's are always ok.
 416 //
 417 #define CMD_OPOST_ON(oflag)   \
 418         (*(USHORT *)(((cmdSyntaxPtr)(ct39))->cmd[1]) = (oflag), \
 419                 (cmdSyntaxPtr)(ct39))
 420
 421 #define CMD_OPOST_OFF   (cmdSyntaxPtr)(ct40) // Disable on-board post-proc
 422
 423 #define CMD_RESUME   (cmdSyntaxPtr)(ct41)       // Resume: behave as though an XON
 424                                                                                         // were received;
 425
 426 // Set Transmit baud rate (see command 7 for arguments)
 427 //
 428 #define CMD_SETBAUD_TX(arg) \
 429         (((cmdSyntaxPtr)(ct42))->cmd[1] = (arg),(cmdSyntaxPtr)(ct42))
 430
 431 // Set Receive baud rate (see command 7 for arguments)
 432 //
 433 #define CMD_SETBAUD_RX(arg) \
 434         (((cmdSyntaxPtr)(ct43))->cmd[1] = (arg),(cmdSyntaxPtr)(ct43))
 435
 436 // Request interrupt from board each arg milliseconds. Interrupt will specify
 437 // "received data", even though there may be no data present. If arg == 0,
 438 // disables any such interrupts.
 439 //
 440 #define CMD_PING_REQ(arg) \
 441         (((cmdSyntaxPtr)(ct44))->cmd[1] = (arg),(cmdSyntaxPtr)(ct44))
 442
 443 #define CMD_HOT_ENAB (cmdSyntaxPtr)(ct45) // Enable Hot-key checking
 444 #define CMD_HOT_DSAB (cmdSyntaxPtr)(ct46) // Disable Hot-key checking
 445
 446 // COMMAND 47: Send Protocol info via Unix flags:
 447 // iflag = Unix tty t_iflag
 448 // cflag = Unix tty t_cflag
 449 // lflag = Unix tty t_lflag
 450 // See System V Unix/Xenix documentation for the meanings of the bit fields
 451 // within these flags
 452 //
 453 #define CMD_UNIX_FLAGS(iflag,cflag,lflag) i2cmdUnixFlags(iflag,cflag,lflag)
 454
 455 #define CMD_DSRFL_ENAB  (cmdSyntaxPtr)(ct48) // Enable  DSR receiver ctrl
 456 #define CMD_DSRFL_DSAB  (cmdSyntaxPtr)(ct49) // Disable DSR receiver ctrl
 457 #define CMD_DTRFL_ENAB  (cmdSyntaxPtr)(ct50) // Enable  DTR flow control
 458 #define CMD_DTRFL_DSAB  (cmdSyntaxPtr)(ct51) // Disable DTR flow control
 459 #define CMD_BAUD_RESET  (cmdSyntaxPtr)(ct52) // Reset baudrate table
 460
 461 // COMMAND 53: Remap baud rate table
 462 // dest = index of table entry to be changed
 463 // src  = index value to substitute.
 464 // at default mapping table is f(x) = x
 465 //
 466 #define CMD_BAUD_REMAP(dest,src) i2cmdBaudRemap(dest,src)
 467
 468 // COMMAND 54: Define custom rate #1
 469 // rate = (short) 1/10 of the desired baud rate
 470 //
 471 #define CMD_BAUD_DEF1(rate) i2cmdBaudDef(1,rate)
 472
 473 // COMMAND 55: Define custom rate #2
 474 // rate = (short) 1/10 of the desired baud rate
 475 //
 476 #define CMD_BAUD_DEF2(rate) i2cmdBaudDef(2,rate)
 477
 478 // Pause arg hundredths of seconds. (Note, this is NOT milliseconds.)
 479 //
 480 #define CMD_PAUSE(arg) \
 481         (((cmdSyntaxPtr)(ct56))->cmd[1] = (arg),(cmdSyntaxPtr)(ct56))
 482
 483 #define CMD_SUSPEND     (cmdSyntaxPtr)(ct57) // Suspend output
 484 #define CMD_UNSUSPEND   (cmdSyntaxPtr)(ct58) // Un-Suspend output
 485
 486 // Set parity-checking options
 487 //
 488 #define CMD_PARCHK(arg) \
 489         (((cmdSyntaxPtr)(ct59))->cmd[1] = (arg),(cmdSyntaxPtr)(ct59))
 490
 491 #define CPK_ENAB  0     // Enable parity checking on input
 492 #define CPK_DSAB  1     // Disable parity checking on input
 493
 494 #define CMD_BMARK_REQ   (cmdSyntaxPtr)(ct60) // Bookmark request
 495
 496
 497 // Enable/Disable internal loopback mode
 498 //
 499 #define CMD_INLOOP(arg) \
 500         (((cmdSyntaxPtr)(ct61))->cmd[1] = (arg),(cmdSyntaxPtr)(ct61))
 501
 502 #define CIN_DISABLE  0  // Normal operation (default)
 503 #define CIN_ENABLE   1  // Internal (local) loopback
 504 #define CIN_REMOTE   2  // Remote loopback
 505
 506 // Specify timeout for hotkeys: Delay will be (arg x 10) milliseconds, arg == 0
 507 // --> no timeout: wait forever.
 508 //
 509 #define CMD_HOT_TIME(arg) \
 510         (((cmdSyntaxPtr)(ct62))->cmd[1] = (arg),(cmdSyntaxPtr)(ct62))
 511
 512
 513 // Define (outgoing) xon for receive flow control
 514 //
 515 #define CMD_DEF_OXON(arg) \
 516         (((cmdSyntaxPtr)(ct63))->cmd[1] = (arg),(cmdSyntaxPtr)(ct63))
 517
 518 // Define (outgoing) xoff for receiver flow control
 519 //
 520 #define CMD_DEF_OXOFF(arg) \
 521         (((cmdSyntaxPtr)(ct64))->cmd[1] = (arg),(cmdSyntaxPtr)(ct64))
 522
 523 // Enable/Disable RTS on transmit (1/2 duplex-style)
 524 //
 525 #define CMD_RTS_XMIT(arg) \
 526         (((cmdSyntaxPtr)(ct65))->cmd[1] = (arg),(cmdSyntaxPtr)(ct65))
 527
 528 #define CHD_DISABLE  0
 529 #define CHD_ENABLE   1
 530
 531 // Set high-water-mark level (debugging use only)
 532 //
 533 #define CMD_SETHIGHWAT(arg) \
 534         (((cmdSyntaxPtr)(ct66))->cmd[1] = (arg),(cmdSyntaxPtr)(ct66))
 535
 536 // Start flushing tagged data (tag = 0-14)
 537 //
 538 #define CMD_START_SELFL(tag) \
 539         (((cmdSyntaxPtr)(ct67))->cmd[1] = (tag),(cmdSyntaxPtr)(ct67))
 540
 541 // End flushing tagged data (tag = 0-14)
 542 //
 543 #define CMD_END_SELFL(tag) \
 544         (((cmdSyntaxPtr)(ct68))->cmd[1] = (tag),(cmdSyntaxPtr)(ct68))
 545
 546 #define CMD_HWFLOW_OFF  (cmdSyntaxPtr)(ct69) // Disable HW TX flow control
 547 #define CMD_ODSRFL_ENAB (cmdSyntaxPtr)(ct70) // Enable DSR output f/c
 548 #define CMD_ODSRFL_DSAB (cmdSyntaxPtr)(ct71) // Disable DSR output f/c
 549 #define CMD_ODCDFL_ENAB (cmdSyntaxPtr)(ct72) // Enable DCD output f/c
 550 #define CMD_ODCDFL_DSAB (cmdSyntaxPtr)(ct73) // Disable DCD output f/c
 551
 552 // Set transmit interrupt load level. Count should be an even value 2-12
 553 //
 554 #define CMD_LOADLEVEL(count) \
 555         (((cmdSyntaxPtr)(ct74))->cmd[1] = (count),(cmdSyntaxPtr)(ct74))
 556
 557 // If reporting DSS changes, map to character sequence FFh, 2, MSR
 558 //
 559 #define CMD_STATDATA(arg) \
 560         (((cmdSyntaxPtr)(ct75))->cmd[1] = (arg),(cmdSyntaxPtr)(ct75))
 561
 562 #define CSTD_DISABLE// Report DSS changes as status packets only (default)
 563 #define CSTD_ENABLE     // Report DSS changes as in-band data sequence as well as
 564                                         // by status packet.
 565
 566 #define CMD_BREAK_ON    (cmdSyntaxPtr)(ct76)// Set break and stop xmit
 567 #define CMD_BREAK_OFF   (cmdSyntaxPtr)(ct77)// End break and restart xmit
 568 #define CMD_GETFC       (cmdSyntaxPtr)(ct78)// Request for flow control packet
 569                                                                                         // from board.
 570
 571 // Transmit this character immediately
 572 //
 573 #define CMD_XMIT_NOW(ch) \
 574         (((cmdSyntaxPtr)(ct79))->cmd[1] = (ch),(cmdSyntaxPtr)(ct79))
 575
 576 // Set baud rate via "divisor latch"
 577 //
 578 #define CMD_DIVISOR_LATCH(which,value) \
 579                         (((cmdSyntaxPtr)(ct80))->cmd[1] = (which), \
 580                         *(USHORT *)(((cmdSyntaxPtr)(ct80))->cmd[2]) = (value), \
 581                         (cmdSyntaxPtr)(ct80))
 582
 583 #define CDL_RX 1        // Set receiver rate
 584 #define CDL_TX 2        // Set transmit rate
 585                                         // (CDL_TX | CDL_RX) Set both rates
 586
 587 // Request for special diagnostic status pkt from the board.
 588 //
 589 #define CMD_GET_STATUS (cmdSyntaxPtr)(ct81)
 590
 591 // Request time-stamped transmit character count packet.
 592 //
 593 #define CMD_GET_TXCNT  (cmdSyntaxPtr)(ct82)
 594
 595 // Request time-stamped receive character count packet.
 596 //
 597 #define CMD_GET_RXCNT  (cmdSyntaxPtr)(ct83)
 598
 599 // Request for box/board I.D. packet.
 600 #define CMD_GET_BOXIDS (cmdSyntaxPtr)(ct84)
 601
 602 // Enable or disable multiple channels according to bit-mapped ushorts box 1-4
 603 //
 604 #define CMD_ENAB_MULT(enable, box1, box2, box3, box4)    \
 605                         (((cmdSytaxPtr)(ct85))->cmd[1] = (enable),            \
 606                         *(USHORT *)(((cmdSyntaxPtr)(ct85))->cmd[2]) = (box1), \
 607                         *(USHORT *)(((cmdSyntaxPtr)(ct85))->cmd[4]) = (box2), \
 608                         *(USHORT *)(((cmdSyntaxPtr)(ct85))->cmd[6]) = (box3), \
 609                         *(USHORT *)(((cmdSyntaxPtr)(ct85))->cmd[8]) = (box4), \
 610                         (cmdSyntaxPtr)(ct85))
 611
 612 #define CEM_DISABLE  0
 613 #define CEM_ENABLE   1
 614
 615 // Enable or disable receiver or receiver interrupts (default both enabled)
 616 //
 617 #define CMD_RCV_ENABLE(ch) \
 618         (((cmdSyntaxPtr)(ct86))->cmd[1] = (ch),(cmdSyntaxPtr)(ct86))
 619
 620 #define CRE_OFF      0  // Disable the receiver
 621 #define CRE_ON       1  // Enable the receiver
 622 #define CRE_INTOFF   2  // Disable receiver interrupts (to loadware)
 623 #define CRE_INTON    3  // Enable receiver interrupts (to loadware)
 624
 625 // Starts up a hardware test process, which runs transparently, and sends a
 626 // STAT_HWFAIL packet in case a hardware failure is detected.
 627 //
 628 #define CMD_HW_TEST  (cmdSyntaxPtr)(ct87)
 629
 630 // Change receiver threshold and timeout value:
 631 // Defaults: timeout = 20mS
 632 // threshold count = 8 when DTRflow not in use,
 633 // threshold count = 5 when DTRflow in use.
 634 //
 635 #define CMD_RCV_THRESHOLD(count,ms) \
 636                         (((cmdSyntaxPtr)(ct88))->cmd[1] = (count), \
 637                         ((cmdSyntaxPtr)(ct88))->cmd[2] = (ms), \
 638                         (cmdSyntaxPtr)(ct88))
 639
 640 // Makes the loadware report DSS signals for this channel immediately.
 641 //
 642 #define CMD_DSS_NOW (cmdSyntaxPtr)(ct89)
 643
 644 // Set the receive silo parameters
 645 //      timeout is ms idle wait until delivery       (~VTIME)
 646 //      threshold is max characters cause interrupt  (~VMIN)
 647 //
 648 #define CMD_SET_SILO(timeout,threshold) \
 649                         (((cmdSyntaxPtr)(ct90))->cmd[1] = (timeout), \
 650                         ((cmdSyntaxPtr)(ct90))->cmd[2]  = (threshold), \
 651                         (cmdSyntaxPtr)(ct90))
 652
 653 // Set timed break in decisecond (1/10s)
 654 //
 655 #define CMD_LBREAK(ds) \
 656         (((cmdSyntaxPtr)(ct91))->cmd[1] = (ds),(cmdSyntaxPtr)(ct66))
 657
 658
 659
 660 #endif // I2CMD_H