File: /usr/src/linux/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
661