631 lines
21 KiB
C
631 lines
21 KiB
C
/*******************************************************************************
|
|
*
|
|
* (c) 1999 by Computone Corporation
|
|
*
|
|
********************************************************************************
|
|
*
|
|
*
|
|
* PACKAGE: Linux tty Device Driver for IntelliPort II family of multiport
|
|
* serial I/O controllers.
|
|
*
|
|
* DESCRIPTION: Definitions and support for In-line and Bypass commands.
|
|
* Applicable only when the standard loadware is active.
|
|
*
|
|
*******************************************************************************/
|
|
//------------------------------------------------------------------------------
|
|
// Revision History:
|
|
//
|
|
// 10 October 1991 MAG First Draft
|
|
// 7 November 1991 MAG Reflects some new commands
|
|
// 20 February 1992 MAG CMD_HOTACK corrected: no argument.
|
|
// 24 February 1992 MAG Support added for new commands for 1.4.x loadware.
|
|
// 11 March 1992 MAG Additional commands.
|
|
// 16 March 1992 MAG Additional commands.
|
|
// 30 March 1992 MAG Additional command: CMD_DSS_NOW
|
|
// 18 May 1992 MAG Changed CMD_OPOST
|
|
//
|
|
//------------------------------------------------------------------------------
|
|
#ifndef I2CMD_H // To prevent multiple includes
|
|
#define I2CMD_H 1
|
|
|
|
#include "ip2types.h"
|
|
|
|
// This module is designed to provide a uniform method of sending commands to
|
|
// the board through command packets. The difficulty is, some commands take
|
|
// parameters, others do not. Furthermore, it is often useful to send several
|
|
// commands to the same channel as part of the same packet. (See also i2pack.h.)
|
|
//
|
|
// This module is designed so that the caller should not be responsible for
|
|
// remembering the exact syntax of each command, or at least so that the
|
|
// compiler could check things somewhat. I'll explain as we go...
|
|
//
|
|
// First, a structure which can embody the syntax of each type of command.
|
|
//
|
|
typedef struct _cmdSyntax
|
|
{
|
|
UCHAR length; // Number of bytes in the command
|
|
UCHAR flags; // Information about the command (see below)
|
|
|
|
// The command and its parameters, which may be of arbitrary length. Don't
|
|
// worry yet how the parameters will be initialized; macros later take care
|
|
// of it. Also, don't worry about the arbitrary length issue; this structure
|
|
// is never used to allocate space (see i2cmd.c).
|
|
UCHAR cmd[2];
|
|
} cmdSyntax, *cmdSyntaxPtr;
|
|
|
|
// Bit assignments for flags
|
|
|
|
#define INL 1 // Set if suitable for inline commands
|
|
#define BYP 2 // Set if suitable for bypass commands
|
|
#define BTH (INL|BYP) // suitable for either!
|
|
#define END 4 // Set if this must be the last command in a block
|
|
#define VIP 8 // Set if this command is special in some way and really
|
|
// should only be sent from the library-level and not
|
|
// directly from user-level
|
|
#define VAR 0x10 // This command is of variable length!
|
|
|
|
// Declarations for the global arrays used to bear the commands and their
|
|
// arguments.
|
|
//
|
|
// Note: Since these are globals and the arguments might change, it is important
|
|
// that the library routine COPY these into buffers from whence they would be
|
|
// sent, rather than merely storing the pointers. In multi-threaded
|
|
// environments, important that the copy should obtain before any context switch
|
|
// is allowed. Also, for parameterized commands, DO NOT ISSUE THE SAME COMMAND
|
|
// MORE THAN ONCE WITH THE SAME PARAMETERS in the same call.
|
|
//
|
|
static UCHAR ct02[];
|
|
static UCHAR ct03[];
|
|
static UCHAR ct04[];
|
|
static UCHAR ct05[];
|
|
static UCHAR ct06[];
|
|
static UCHAR ct07[];
|
|
static UCHAR ct08[];
|
|
static UCHAR ct09[];
|
|
static UCHAR ct10[];
|
|
static UCHAR ct11[];
|
|
static UCHAR ct12[];
|
|
static UCHAR ct13[];
|
|
static UCHAR ct14[];
|
|
static UCHAR ct15[];
|
|
static UCHAR ct16[];
|
|
static UCHAR ct17[];
|
|
static UCHAR ct18[];
|
|
static UCHAR ct19[];
|
|
static UCHAR ct20[];
|
|
static UCHAR ct21[];
|
|
static UCHAR ct22[];
|
|
static UCHAR ct23[];
|
|
static UCHAR ct24[];
|
|
static UCHAR ct25[];
|
|
static UCHAR ct26[];
|
|
static UCHAR ct27[];
|
|
static UCHAR ct28[];
|
|
static UCHAR ct29[];
|
|
static UCHAR ct30[];
|
|
static UCHAR ct31[];
|
|
static UCHAR ct32[];
|
|
static UCHAR ct33[];
|
|
static UCHAR ct34[];
|
|
static UCHAR ct35[];
|
|
static UCHAR ct36[];
|
|
static UCHAR ct36a[];
|
|
static UCHAR ct41[];
|
|
static UCHAR ct42[];
|
|
static UCHAR ct43[];
|
|
static UCHAR ct44[];
|
|
static UCHAR ct45[];
|
|
static UCHAR ct46[];
|
|
static UCHAR ct48[];
|
|
static UCHAR ct49[];
|
|
static UCHAR ct50[];
|
|
static UCHAR ct51[];
|
|
static UCHAR ct52[];
|
|
static UCHAR ct56[];
|
|
static UCHAR ct57[];
|
|
static UCHAR ct58[];
|
|
static UCHAR ct59[];
|
|
static UCHAR ct60[];
|
|
static UCHAR ct61[];
|
|
static UCHAR ct62[];
|
|
static UCHAR ct63[];
|
|
static UCHAR ct64[];
|
|
static UCHAR ct65[];
|
|
static UCHAR ct66[];
|
|
static UCHAR ct67[];
|
|
static UCHAR ct68[];
|
|
static UCHAR ct69[];
|
|
static UCHAR ct70[];
|
|
static UCHAR ct71[];
|
|
static UCHAR ct72[];
|
|
static UCHAR ct73[];
|
|
static UCHAR ct74[];
|
|
static UCHAR ct75[];
|
|
static UCHAR ct76[];
|
|
static UCHAR ct77[];
|
|
static UCHAR ct78[];
|
|
static UCHAR ct79[];
|
|
static UCHAR ct80[];
|
|
static UCHAR ct81[];
|
|
static UCHAR ct82[];
|
|
static UCHAR ct83[];
|
|
static UCHAR ct84[];
|
|
static UCHAR ct85[];
|
|
static UCHAR ct86[];
|
|
static UCHAR ct87[];
|
|
static UCHAR ct88[];
|
|
static UCHAR ct89[];
|
|
static UCHAR ct90[];
|
|
static UCHAR ct91[];
|
|
static UCHAR cc01[];
|
|
static UCHAR cc02[];
|
|
|
|
// Now, refer to i2cmd.c, and see the character arrays defined there. They are
|
|
// cast here to cmdSyntaxPtr.
|
|
//
|
|
// There are library functions for issuing bypass or inline commands. These
|
|
// functions take one or more arguments of the type cmdSyntaxPtr. The routine
|
|
// then can figure out how long each command is supposed to be and easily add it
|
|
// to the list.
|
|
//
|
|
// For ease of use, we define manifests which return pointers to appropriate
|
|
// cmdSyntaxPtr things. But some commands also take arguments. If a single
|
|
// argument is used, we define a macro which performs the single assignment and
|
|
// (through the expedient of a comma expression) references the appropriate
|
|
// pointer. For commands requiring several arguments, we actually define a
|
|
// function to perform the assignments.
|
|
|
|
#define CMD_DTRUP (cmdSyntaxPtr)(ct02) // Raise DTR
|
|
#define CMD_DTRDN (cmdSyntaxPtr)(ct03) // Lower DTR
|
|
#define CMD_RTSUP (cmdSyntaxPtr)(ct04) // Raise RTS
|
|
#define CMD_RTSDN (cmdSyntaxPtr)(ct05) // Lower RTS
|
|
#define CMD_STARTFL (cmdSyntaxPtr)(ct06) // Start Flushing Data
|
|
|
|
#define CMD_DTRRTS_UP (cmdSyntaxPtr)(cc01) // Raise DTR and RTS
|
|
#define CMD_DTRRTS_DN (cmdSyntaxPtr)(cc02) // Lower DTR and RTS
|
|
|
|
// Set Baud Rate for transmit and receive
|
|
#define CMD_SETBAUD(arg) \
|
|
(((cmdSyntaxPtr)(ct07))->cmd[1] = (arg),(cmdSyntaxPtr)(ct07))
|
|
|
|
#define CBR_50 1
|
|
#define CBR_75 2
|
|
#define CBR_110 3
|
|
#define CBR_134 4
|
|
#define CBR_150 5
|
|
#define CBR_200 6
|
|
#define CBR_300 7
|
|
#define CBR_600 8
|
|
#define CBR_1200 9
|
|
#define CBR_1800 10
|
|
#define CBR_2400 11
|
|
#define CBR_4800 12
|
|
#define CBR_9600 13
|
|
#define CBR_19200 14
|
|
#define CBR_38400 15
|
|
#define CBR_2000 16
|
|
#define CBR_3600 17
|
|
#define CBR_7200 18
|
|
#define CBR_56000 19
|
|
#define CBR_57600 20
|
|
#define CBR_64000 21
|
|
#define CBR_76800 22
|
|
#define CBR_115200 23
|
|
#define CBR_C1 24 // Custom baud rate 1
|
|
#define CBR_C2 25 // Custom baud rate 2
|
|
#define CBR_153600 26
|
|
#define CBR_230400 27
|
|
#define CBR_307200 28
|
|
#define CBR_460800 29
|
|
#define CBR_921600 30
|
|
|
|
// Set Character size
|
|
//
|
|
#define CMD_SETBITS(arg) \
|
|
(((cmdSyntaxPtr)(ct08))->cmd[1] = (arg),(cmdSyntaxPtr)(ct08))
|
|
|
|
#define CSZ_5 0
|
|
#define CSZ_6 1
|
|
#define CSZ_7 2
|
|
#define CSZ_8 3
|
|
|
|
// Set number of stop bits
|
|
//
|
|
#define CMD_SETSTOP(arg) \
|
|
(((cmdSyntaxPtr)(ct09))->cmd[1] = (arg),(cmdSyntaxPtr)(ct09))
|
|
|
|
#define CST_1 0
|
|
#define CST_15 1 // 1.5 stop bits
|
|
#define CST_2 2
|
|
|
|
// Set parity option
|
|
//
|
|
#define CMD_SETPAR(arg) \
|
|
(((cmdSyntaxPtr)(ct10))->cmd[1] = (arg),(cmdSyntaxPtr)(ct10))
|
|
|
|
#define CSP_NP 0 // no parity
|
|
#define CSP_OD 1 // odd parity
|
|
#define CSP_EV 2 // Even parity
|
|
#define CSP_SP 3 // Space parity
|
|
#define CSP_MK 4 // Mark parity
|
|
|
|
// Define xon char for transmitter flow control
|
|
//
|
|
#define CMD_DEF_IXON(arg) \
|
|
(((cmdSyntaxPtr)(ct11))->cmd[1] = (arg),(cmdSyntaxPtr)(ct11))
|
|
|
|
// Define xoff char for transmitter flow control
|
|
//
|
|
#define CMD_DEF_IXOFF(arg) \
|
|
(((cmdSyntaxPtr)(ct12))->cmd[1] = (arg),(cmdSyntaxPtr)(ct12))
|
|
|
|
#define CMD_STOPFL (cmdSyntaxPtr)(ct13) // Stop Flushing data
|
|
|
|
// Acknowledge receipt of hotkey signal
|
|
//
|
|
#define CMD_HOTACK (cmdSyntaxPtr)(ct14)
|
|
|
|
// Define irq level to use. Should actually be sent by library-level code, not
|
|
// directly from user...
|
|
//
|
|
#define CMDVALUE_IRQ 15 // For library use at initialization. Until this command
|
|
// is sent, board processing doesn't really start.
|
|
#define CMD_SET_IRQ(arg) \
|
|
(((cmdSyntaxPtr)(ct15))->cmd[1] = (arg),(cmdSyntaxPtr)(ct15))
|
|
|
|
#define CIR_POLL 0 // No IRQ - Poll
|
|
#define CIR_3 3 // IRQ 3
|
|
#define CIR_4 4 // IRQ 4
|
|
#define CIR_5 5 // IRQ 5
|
|
#define CIR_7 7 // IRQ 7
|
|
#define CIR_10 10 // IRQ 10
|
|
#define CIR_11 11 // IRQ 11
|
|
#define CIR_12 12 // IRQ 12
|
|
#define CIR_15 15 // IRQ 15
|
|
|
|
// Select transmit flow xon/xoff options
|
|
//
|
|
#define CMD_IXON_OPT(arg) \
|
|
(((cmdSyntaxPtr)(ct16))->cmd[1] = (arg),(cmdSyntaxPtr)(ct16))
|
|
|
|
#define CIX_NONE 0 // Incoming Xon/Xoff characters not special
|
|
#define CIX_XON 1 // Xoff disable, Xon enable
|
|
#define CIX_XANY 2 // Xoff disable, any key enable
|
|
|
|
// Select receive flow xon/xoff options
|
|
//
|
|
#define CMD_OXON_OPT(arg) \
|
|
(((cmdSyntaxPtr)(ct17))->cmd[1] = (arg),(cmdSyntaxPtr)(ct17))
|
|
|
|
#define COX_NONE 0 // Don't send Xon/Xoff
|
|
#define COX_XON 1 // Send xon/xoff to start/stop incoming data
|
|
|
|
|
|
#define CMD_CTS_REP (cmdSyntaxPtr)(ct18) // Enable CTS reporting
|
|
#define CMD_CTS_NREP (cmdSyntaxPtr)(ct19) // Disable CTS reporting
|
|
|
|
#define CMD_DCD_REP (cmdSyntaxPtr)(ct20) // Enable DCD reporting
|
|
#define CMD_DCD_NREP (cmdSyntaxPtr)(ct21) // Disable DCD reporting
|
|
|
|
#define CMD_DSR_REP (cmdSyntaxPtr)(ct22) // Enable DSR reporting
|
|
#define CMD_DSR_NREP (cmdSyntaxPtr)(ct23) // Disable DSR reporting
|
|
|
|
#define CMD_RI_REP (cmdSyntaxPtr)(ct24) // Enable RI reporting
|
|
#define CMD_RI_NREP (cmdSyntaxPtr)(ct25) // Disable RI reporting
|
|
|
|
// Enable break reporting and select style
|
|
//
|
|
#define CMD_BRK_REP(arg) \
|
|
(((cmdSyntaxPtr)(ct26))->cmd[1] = (arg),(cmdSyntaxPtr)(ct26))
|
|
|
|
#define CBK_STAT 0x00 // Report breaks as a status (exception,irq)
|
|
#define CBK_NULL 0x01 // Report breaks as a good null
|
|
#define CBK_STAT_SEQ 0x02 // Report breaks as a status AND as in-band character
|
|
// sequence FFh, 01h, 10h
|
|
#define CBK_SEQ 0x03 // Report breaks as the in-band
|
|
//sequence FFh, 01h, 10h ONLY.
|
|
#define CBK_FLSH 0x04 // if this bit set also flush input data
|
|
#define CBK_POSIX 0x08 // if this bit set report as FF,0,0 sequence
|
|
#define CBK_SINGLE 0x10 // if this bit set with CBK_SEQ or CBK_STAT_SEQ
|
|
//then reports single null instead of triple
|
|
|
|
#define CMD_BRK_NREP (cmdSyntaxPtr)(ct27) // Disable break reporting
|
|
|
|
// Specify maximum block size for received data
|
|
//
|
|
#define CMD_MAX_BLOCK(arg) \
|
|
(((cmdSyntaxPtr)(ct28))->cmd[1] = (arg),(cmdSyntaxPtr)(ct28))
|
|
|
|
// -- COMMAND 29 is reserved --
|
|
|
|
#define CMD_CTSFL_ENAB (cmdSyntaxPtr)(ct30) // Enable CTS flow control
|
|
#define CMD_CTSFL_DSAB (cmdSyntaxPtr)(ct31) // Disable CTS flow control
|
|
#define CMD_RTSFL_ENAB (cmdSyntaxPtr)(ct32) // Enable RTS flow control
|
|
#define CMD_RTSFL_DSAB (cmdSyntaxPtr)(ct33) // Disable RTS flow control
|
|
|
|
// Specify istrip option
|
|
//
|
|
#define CMD_ISTRIP_OPT(arg) \
|
|
(((cmdSyntaxPtr)(ct34))->cmd[1] = (arg),(cmdSyntaxPtr)(ct34))
|
|
|
|
#define CIS_NOSTRIP 0 // Strip characters to character size
|
|
#define CIS_STRIP 1 // Strip any 8-bit characters to 7 bits
|
|
|
|
// Send a break of arg milliseconds
|
|
//
|
|
#define CMD_SEND_BRK(arg) \
|
|
(((cmdSyntaxPtr)(ct35))->cmd[1] = (arg),(cmdSyntaxPtr)(ct35))
|
|
|
|
// Set error reporting mode
|
|
//
|
|
#define CMD_SET_ERROR(arg) \
|
|
(((cmdSyntaxPtr)(ct36))->cmd[1] = (arg),(cmdSyntaxPtr)(ct36))
|
|
|
|
#define CSE_ESTAT 0 // Report error in a status packet
|
|
#define CSE_NOREP 1 // Treat character as though it were good
|
|
#define CSE_DROP 2 // Discard the character
|
|
#define CSE_NULL 3 // Replace with a null
|
|
#define CSE_MARK 4 // Replace with a 3-character sequence (as Unix)
|
|
|
|
#define CSE_REPLACE 0x8 // Replace the errored character with the
|
|
// replacement character defined here
|
|
|
|
#define CSE_STAT_REPLACE 0x18 // Replace the errored character with the
|
|
// replacement character defined here AND
|
|
// report the error as a status packet (as in
|
|
// CSE_ESTAT).
|
|
|
|
|
|
// COMMAND 37, to send flow control packets, is handled only by low-level
|
|
// library code in response to data movement and shouldn't ever be sent by the
|
|
// user code. See i2pack.h and the body of i2lib.c for details.
|
|
|
|
// Enable on-board post-processing, using options given in oflag argument.
|
|
// Formerly, this command was automatically preceded by a CMD_OPOST_OFF command
|
|
// because the loadware does not permit sending back-to-back CMD_OPOST_ON
|
|
// commands without an intervening CMD_OPOST_OFF. BUT, WE LEARN 18 MAY 92, that
|
|
// CMD_OPOST_ON and CMD_OPOST_OFF must each be at the end of a packet (or in a
|
|
// solo packet). This means the caller must specify separately CMD_OPOST_OFF,
|
|
// CMD_OPOST_ON(parm) when he calls i2QueueCommands(). That function will ensure
|
|
// each gets a separate packet. Extra CMD_OPOST_OFF's are always ok.
|
|
//
|
|
#define CMD_OPOST_ON(oflag) \
|
|
(*(USHORT *)(((cmdSyntaxPtr)(ct39))->cmd[1]) = (oflag), \
|
|
(cmdSyntaxPtr)(ct39))
|
|
|
|
#define CMD_OPOST_OFF (cmdSyntaxPtr)(ct40) // Disable on-board post-proc
|
|
|
|
#define CMD_RESUME (cmdSyntaxPtr)(ct41) // Resume: behave as though an XON
|
|
// were received;
|
|
|
|
// Set Transmit baud rate (see command 7 for arguments)
|
|
//
|
|
#define CMD_SETBAUD_TX(arg) \
|
|
(((cmdSyntaxPtr)(ct42))->cmd[1] = (arg),(cmdSyntaxPtr)(ct42))
|
|
|
|
// Set Receive baud rate (see command 7 for arguments)
|
|
//
|
|
#define CMD_SETBAUD_RX(arg) \
|
|
(((cmdSyntaxPtr)(ct43))->cmd[1] = (arg),(cmdSyntaxPtr)(ct43))
|
|
|
|
// Request interrupt from board each arg milliseconds. Interrupt will specify
|
|
// "received data", even though there may be no data present. If arg == 0,
|
|
// disables any such interrupts.
|
|
//
|
|
#define CMD_PING_REQ(arg) \
|
|
(((cmdSyntaxPtr)(ct44))->cmd[1] = (arg),(cmdSyntaxPtr)(ct44))
|
|
|
|
#define CMD_HOT_ENAB (cmdSyntaxPtr)(ct45) // Enable Hot-key checking
|
|
#define CMD_HOT_DSAB (cmdSyntaxPtr)(ct46) // Disable Hot-key checking
|
|
|
|
#if 0
|
|
// COMMAND 47: Send Protocol info via Unix flags:
|
|
// iflag = Unix tty t_iflag
|
|
// cflag = Unix tty t_cflag
|
|
// lflag = Unix tty t_lflag
|
|
// See System V Unix/Xenix documentation for the meanings of the bit fields
|
|
// within these flags
|
|
//
|
|
#define CMD_UNIX_FLAGS(iflag,cflag,lflag) i2cmdUnixFlags(iflag,cflag,lflag)
|
|
#endif /* 0 */
|
|
|
|
#define CMD_DSRFL_ENAB (cmdSyntaxPtr)(ct48) // Enable DSR receiver ctrl
|
|
#define CMD_DSRFL_DSAB (cmdSyntaxPtr)(ct49) // Disable DSR receiver ctrl
|
|
#define CMD_DTRFL_ENAB (cmdSyntaxPtr)(ct50) // Enable DTR flow control
|
|
#define CMD_DTRFL_DSAB (cmdSyntaxPtr)(ct51) // Disable DTR flow control
|
|
#define CMD_BAUD_RESET (cmdSyntaxPtr)(ct52) // Reset baudrate table
|
|
|
|
// COMMAND 54: Define custom rate #1
|
|
// rate = (short) 1/10 of the desired baud rate
|
|
//
|
|
#define CMD_BAUD_DEF1(rate) i2cmdBaudDef(1,rate)
|
|
|
|
// COMMAND 55: Define custom rate #2
|
|
// rate = (short) 1/10 of the desired baud rate
|
|
//
|
|
#define CMD_BAUD_DEF2(rate) i2cmdBaudDef(2,rate)
|
|
|
|
// Pause arg hundredths of seconds. (Note, this is NOT milliseconds.)
|
|
//
|
|
#define CMD_PAUSE(arg) \
|
|
(((cmdSyntaxPtr)(ct56))->cmd[1] = (arg),(cmdSyntaxPtr)(ct56))
|
|
|
|
#define CMD_SUSPEND (cmdSyntaxPtr)(ct57) // Suspend output
|
|
#define CMD_UNSUSPEND (cmdSyntaxPtr)(ct58) // Un-Suspend output
|
|
|
|
// Set parity-checking options
|
|
//
|
|
#define CMD_PARCHK(arg) \
|
|
(((cmdSyntaxPtr)(ct59))->cmd[1] = (arg),(cmdSyntaxPtr)(ct59))
|
|
|
|
#define CPK_ENAB 0 // Enable parity checking on input
|
|
#define CPK_DSAB 1 // Disable parity checking on input
|
|
|
|
#define CMD_BMARK_REQ (cmdSyntaxPtr)(ct60) // Bookmark request
|
|
|
|
|
|
// Enable/Disable internal loopback mode
|
|
//
|
|
#define CMD_INLOOP(arg) \
|
|
(((cmdSyntaxPtr)(ct61))->cmd[1] = (arg),(cmdSyntaxPtr)(ct61))
|
|
|
|
#define CIN_DISABLE 0 // Normal operation (default)
|
|
#define CIN_ENABLE 1 // Internal (local) loopback
|
|
#define CIN_REMOTE 2 // Remote loopback
|
|
|
|
// Specify timeout for hotkeys: Delay will be (arg x 10) milliseconds, arg == 0
|
|
// --> no timeout: wait forever.
|
|
//
|
|
#define CMD_HOT_TIME(arg) \
|
|
(((cmdSyntaxPtr)(ct62))->cmd[1] = (arg),(cmdSyntaxPtr)(ct62))
|
|
|
|
|
|
// Define (outgoing) xon for receive flow control
|
|
//
|
|
#define CMD_DEF_OXON(arg) \
|
|
(((cmdSyntaxPtr)(ct63))->cmd[1] = (arg),(cmdSyntaxPtr)(ct63))
|
|
|
|
// Define (outgoing) xoff for receiver flow control
|
|
//
|
|
#define CMD_DEF_OXOFF(arg) \
|
|
(((cmdSyntaxPtr)(ct64))->cmd[1] = (arg),(cmdSyntaxPtr)(ct64))
|
|
|
|
// Enable/Disable RTS on transmit (1/2 duplex-style)
|
|
//
|
|
#define CMD_RTS_XMIT(arg) \
|
|
(((cmdSyntaxPtr)(ct65))->cmd[1] = (arg),(cmdSyntaxPtr)(ct65))
|
|
|
|
#define CHD_DISABLE 0
|
|
#define CHD_ENABLE 1
|
|
|
|
// Set high-water-mark level (debugging use only)
|
|
//
|
|
#define CMD_SETHIGHWAT(arg) \
|
|
(((cmdSyntaxPtr)(ct66))->cmd[1] = (arg),(cmdSyntaxPtr)(ct66))
|
|
|
|
// Start flushing tagged data (tag = 0-14)
|
|
//
|
|
#define CMD_START_SELFL(tag) \
|
|
(((cmdSyntaxPtr)(ct67))->cmd[1] = (tag),(cmdSyntaxPtr)(ct67))
|
|
|
|
// End flushing tagged data (tag = 0-14)
|
|
//
|
|
#define CMD_END_SELFL(tag) \
|
|
(((cmdSyntaxPtr)(ct68))->cmd[1] = (tag),(cmdSyntaxPtr)(ct68))
|
|
|
|
#define CMD_HWFLOW_OFF (cmdSyntaxPtr)(ct69) // Disable HW TX flow control
|
|
#define CMD_ODSRFL_ENAB (cmdSyntaxPtr)(ct70) // Enable DSR output f/c
|
|
#define CMD_ODSRFL_DSAB (cmdSyntaxPtr)(ct71) // Disable DSR output f/c
|
|
#define CMD_ODCDFL_ENAB (cmdSyntaxPtr)(ct72) // Enable DCD output f/c
|
|
#define CMD_ODCDFL_DSAB (cmdSyntaxPtr)(ct73) // Disable DCD output f/c
|
|
|
|
// Set transmit interrupt load level. Count should be an even value 2-12
|
|
//
|
|
#define CMD_LOADLEVEL(count) \
|
|
(((cmdSyntaxPtr)(ct74))->cmd[1] = (count),(cmdSyntaxPtr)(ct74))
|
|
|
|
// If reporting DSS changes, map to character sequence FFh, 2, MSR
|
|
//
|
|
#define CMD_STATDATA(arg) \
|
|
(((cmdSyntaxPtr)(ct75))->cmd[1] = (arg),(cmdSyntaxPtr)(ct75))
|
|
|
|
#define CSTD_DISABLE// Report DSS changes as status packets only (default)
|
|
#define CSTD_ENABLE // Report DSS changes as in-band data sequence as well as
|
|
// by status packet.
|
|
|
|
#define CMD_BREAK_ON (cmdSyntaxPtr)(ct76)// Set break and stop xmit
|
|
#define CMD_BREAK_OFF (cmdSyntaxPtr)(ct77)// End break and restart xmit
|
|
#define CMD_GETFC (cmdSyntaxPtr)(ct78)// Request for flow control packet
|
|
// from board.
|
|
|
|
// Transmit this character immediately
|
|
//
|
|
#define CMD_XMIT_NOW(ch) \
|
|
(((cmdSyntaxPtr)(ct79))->cmd[1] = (ch),(cmdSyntaxPtr)(ct79))
|
|
|
|
// Set baud rate via "divisor latch"
|
|
//
|
|
#define CMD_DIVISOR_LATCH(which,value) \
|
|
(((cmdSyntaxPtr)(ct80))->cmd[1] = (which), \
|
|
*(USHORT *)(((cmdSyntaxPtr)(ct80))->cmd[2]) = (value), \
|
|
(cmdSyntaxPtr)(ct80))
|
|
|
|
#define CDL_RX 1 // Set receiver rate
|
|
#define CDL_TX 2 // Set transmit rate
|
|
// (CDL_TX | CDL_RX) Set both rates
|
|
|
|
// Request for special diagnostic status pkt from the board.
|
|
//
|
|
#define CMD_GET_STATUS (cmdSyntaxPtr)(ct81)
|
|
|
|
// Request time-stamped transmit character count packet.
|
|
//
|
|
#define CMD_GET_TXCNT (cmdSyntaxPtr)(ct82)
|
|
|
|
// Request time-stamped receive character count packet.
|
|
//
|
|
#define CMD_GET_RXCNT (cmdSyntaxPtr)(ct83)
|
|
|
|
// Request for box/board I.D. packet.
|
|
#define CMD_GET_BOXIDS (cmdSyntaxPtr)(ct84)
|
|
|
|
// Enable or disable multiple channels according to bit-mapped ushorts box 1-4
|
|
//
|
|
#define CMD_ENAB_MULT(enable, box1, box2, box3, box4) \
|
|
(((cmdSytaxPtr)(ct85))->cmd[1] = (enable), \
|
|
*(USHORT *)(((cmdSyntaxPtr)(ct85))->cmd[2]) = (box1), \
|
|
*(USHORT *)(((cmdSyntaxPtr)(ct85))->cmd[4]) = (box2), \
|
|
*(USHORT *)(((cmdSyntaxPtr)(ct85))->cmd[6]) = (box3), \
|
|
*(USHORT *)(((cmdSyntaxPtr)(ct85))->cmd[8]) = (box4), \
|
|
(cmdSyntaxPtr)(ct85))
|
|
|
|
#define CEM_DISABLE 0
|
|
#define CEM_ENABLE 1
|
|
|
|
// Enable or disable receiver or receiver interrupts (default both enabled)
|
|
//
|
|
#define CMD_RCV_ENABLE(ch) \
|
|
(((cmdSyntaxPtr)(ct86))->cmd[1] = (ch),(cmdSyntaxPtr)(ct86))
|
|
|
|
#define CRE_OFF 0 // Disable the receiver
|
|
#define CRE_ON 1 // Enable the receiver
|
|
#define CRE_INTOFF 2 // Disable receiver interrupts (to loadware)
|
|
#define CRE_INTON 3 // Enable receiver interrupts (to loadware)
|
|
|
|
// Starts up a hardware test process, which runs transparently, and sends a
|
|
// STAT_HWFAIL packet in case a hardware failure is detected.
|
|
//
|
|
#define CMD_HW_TEST (cmdSyntaxPtr)(ct87)
|
|
|
|
// Change receiver threshold and timeout value:
|
|
// Defaults: timeout = 20mS
|
|
// threshold count = 8 when DTRflow not in use,
|
|
// threshold count = 5 when DTRflow in use.
|
|
//
|
|
#define CMD_RCV_THRESHOLD(count,ms) \
|
|
(((cmdSyntaxPtr)(ct88))->cmd[1] = (count), \
|
|
((cmdSyntaxPtr)(ct88))->cmd[2] = (ms), \
|
|
(cmdSyntaxPtr)(ct88))
|
|
|
|
// Makes the loadware report DSS signals for this channel immediately.
|
|
//
|
|
#define CMD_DSS_NOW (cmdSyntaxPtr)(ct89)
|
|
|
|
// Set the receive silo parameters
|
|
// timeout is ms idle wait until delivery (~VTIME)
|
|
// threshold is max characters cause interrupt (~VMIN)
|
|
//
|
|
#define CMD_SET_SILO(timeout,threshold) \
|
|
(((cmdSyntaxPtr)(ct90))->cmd[1] = (timeout), \
|
|
((cmdSyntaxPtr)(ct90))->cmd[2] = (threshold), \
|
|
(cmdSyntaxPtr)(ct90))
|
|
|
|
// Set timed break in decisecond (1/10s)
|
|
//
|
|
#define CMD_LBREAK(ds) \
|
|
(((cmdSyntaxPtr)(ct91))->cmd[1] = (ds),(cmdSyntaxPtr)(ct66))
|
|
|
|
|
|
|
|
#endif // I2CMD_H
|