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 661