开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Linux/Unix编程 > 查看源码
i2cmd.h
资源名称：linux-2.4.20.tar.gz　[点击查看]
上传用户：jlfgdled
上传日期：2013-04-10
资源大小：33168k
文件大小：22k
源码类别：

Linux/Unix编程

开发平台：

Unix_Linux

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
  31. #include "ip2types.h"
  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)
  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;
  56. // Bit assignments for flags
  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!
  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);
  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[];
  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.
  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
  196. #define CMD_DTRRTS_UP (cmdSyntaxPtr)(cc01) // Raise DTR and RTS
  197. #define CMD_DTRRTS_DN (cmdSyntaxPtr)(cc02) // Lower DTR and RTS
  199. // Set Baud Rate for transmit and receive
  200. #define CMD_SETBAUD(arg) 
  201. (((cmdSyntaxPtr)(ct07))->cmd[1] = (arg),(cmdSyntaxPtr)(ct07))
  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
  234. // Set Character size
  235. //
  236. #define CMD_SETBITS(arg) 
  237. (((cmdSyntaxPtr)(ct08))->cmd[1] = (arg),(cmdSyntaxPtr)(ct08))
  239. #define CSZ_5  0
  240. #define CSZ_6  1
  241. #define CSZ_7  2
  242. #define CSZ_8  3
  244. // Set number of stop bits
  245. //
  246. #define CMD_SETSTOP(arg) 
  247. (((cmdSyntaxPtr)(ct09))->cmd[1] = (arg),(cmdSyntaxPtr)(ct09))
  249. #define CST_1  0
  250. #define CST_15 1  // 1.5 stop bits
  251. #define CST_2  2
  253. // Set parity option
  254. //
  255. #define CMD_SETPAR(arg) 
  256. (((cmdSyntaxPtr)(ct10))->cmd[1] = (arg),(cmdSyntaxPtr)(ct10))
  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
  264. // Define xon char for transmitter flow control
  265. //
  266. #define CMD_DEF_IXON(arg) 
  267. (((cmdSyntaxPtr)(ct11))->cmd[1] = (arg),(cmdSyntaxPtr)(ct11))
  269. // Define xoff char for transmitter flow control
  270. //
  271. #define CMD_DEF_IXOFF(arg) 
  272. (((cmdSyntaxPtr)(ct12))->cmd[1] = (arg),(cmdSyntaxPtr)(ct12))
  274. #define CMD_STOPFL   (cmdSyntaxPtr)(ct13) // Stop Flushing data
  276. // Acknowledge receipt of hotkey signal
  277. //
  278. #define CMD_HOTACK   (cmdSyntaxPtr)(ct14)
  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))
  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
  298. // Select transmit flow xon/xoff options
  299. //
  300. #define CMD_IXON_OPT(arg) 
  301. (((cmdSyntaxPtr)(ct16))->cmd[1] = (arg),(cmdSyntaxPtr)(ct16))
  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
  307. // Select receive flow xon/xoff options
  308. //
  309. #define CMD_OXON_OPT(arg) 
  310. (((cmdSyntaxPtr)(ct17))->cmd[1] = (arg),(cmdSyntaxPtr)(ct17))
  312. #define COX_NONE  0  // Don't send Xon/Xoff
  313. #define COX_XON   1  // Send xon/xoff to start/stop incoming data
  316. #define CMD_CTS_REP  (cmdSyntaxPtr)(ct18) // Enable  CTS reporting
  317. #define CMD_CTS_NREP (cmdSyntaxPtr)(ct19) // Disable CTS reporting
  319. #define CMD_DCD_REP  (cmdSyntaxPtr)(ct20) // Enable  DCD reporting
  320. #define CMD_DCD_NREP (cmdSyntaxPtr)(ct21) // Disable DCD reporting
  322. #define CMD_DSR_REP  (cmdSyntaxPtr)(ct22) // Enable  DSR reporting
  323. #define CMD_DSR_NREP (cmdSyntaxPtr)(ct23) // Disable DSR reporting
  325. #define CMD_RI_REP   (cmdSyntaxPtr)(ct24) // Enable  RI  reporting
  326. #define CMD_RI_NREP  (cmdSyntaxPtr)(ct25) // Disable RI  reporting
  328. // Enable break reporting and select style
  329. //
  330. #define CMD_BRK_REP(arg) 
  331. (((cmdSyntaxPtr)(ct26))->cmd[1] = (arg),(cmdSyntaxPtr)(ct26))
  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
  344. #define CMD_BRK_NREP (cmdSyntaxPtr)(ct27) // Disable break reporting
  346. // Specify maximum block size for received data
  347. //
  348. #define CMD_MAX_BLOCK(arg) 
  349. (((cmdSyntaxPtr)(ct28))->cmd[1] = (arg),(cmdSyntaxPtr)(ct28))
  351. // -- COMMAND 29 is reserved --
  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
  358. // Specify istrip option
  359. //
  360. #define CMD_ISTRIP_OPT(arg) 
  361. (((cmdSyntaxPtr)(ct34))->cmd[1] = (arg),(cmdSyntaxPtr)(ct34))
  363. #define CIS_NOSTRIP  0  // Strip characters to character size
  364. #define CIS_STRIP    1  // Strip any 8-bit characters to 7 bits
  366. // Send a break of arg milliseconds
  367. //
  368. #define CMD_SEND_BRK(arg) 
  369. (((cmdSyntaxPtr)(ct35))->cmd[1] = (arg),(cmdSyntaxPtr)(ct35))
  371. // Set error reporting mode
  372. //
  373. #define CMD_SET_ERROR(arg) 
  374. (((cmdSyntaxPtr)(ct36))->cmd[1] = (arg),(cmdSyntaxPtr)(ct36))
  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)
  382. #define  CMD_SET_REPLACEMENT(arg,ch)   
  383. (((cmdSyntaxPtr)(ct36a))->cmd[1] = (arg), 
  384. (((cmdSyntaxPtr)(ct36a))->cmd[2] = (ch),  
  385. (cmdSyntaxPtr)(ct36a))
  387. #define CSE_REPLACE  0x8 // Replace the errored character with the
  388. // replacement character defined here
  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).
  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.
  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)
  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))
  421. #define CMD_OPOST_OFF   (cmdSyntaxPtr)(ct40) // Disable on-board post-proc
  423. #define CMD_RESUME   (cmdSyntaxPtr)(ct41) // Resume: behave as though an XON
  424. // were received;
  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))
  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))
  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))
  443. #define CMD_HOT_ENAB (cmdSyntaxPtr)(ct45) // Enable Hot-key checking
  444. #define CMD_HOT_DSAB (cmdSyntaxPtr)(ct46) // Disable Hot-key checking
  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)
  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
  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)
  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)
  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)
  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))
  483. #define CMD_SUSPEND     (cmdSyntaxPtr)(ct57) // Suspend output
  484. #define CMD_UNSUSPEND   (cmdSyntaxPtr)(ct58) // Un-Suspend output
  486. // Set parity-checking options
  487. //
  488. #define CMD_PARCHK(arg) 
  489. (((cmdSyntaxPtr)(ct59))->cmd[1] = (arg),(cmdSyntaxPtr)(ct59))
  491. #define CPK_ENAB  0     // Enable parity checking on input
  492. #define CPK_DSAB  1     // Disable parity checking on input
  494. #define CMD_BMARK_REQ   (cmdSyntaxPtr)(ct60) // Bookmark request
  497. // Enable/Disable internal loopback mode
  498. //
  499. #define CMD_INLOOP(arg) 
  500. (((cmdSyntaxPtr)(ct61))->cmd[1] = (arg),(cmdSyntaxPtr)(ct61))
  502. #define CIN_DISABLE  0  // Normal operation (default)
  503. #define CIN_ENABLE   1  // Internal (local) loopback
  504. #define CIN_REMOTE   2  // Remote loopback
  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))
  513. // Define (outgoing) xon for receive flow control
  514. //
  515. #define CMD_DEF_OXON(arg) 
  516. (((cmdSyntaxPtr)(ct63))->cmd[1] = (arg),(cmdSyntaxPtr)(ct63))
  518. // Define (outgoing) xoff for receiver flow control
  519. //
  520. #define CMD_DEF_OXOFF(arg) 
  521. (((cmdSyntaxPtr)(ct64))->cmd[1] = (arg),(cmdSyntaxPtr)(ct64))
  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))
  528. #define CHD_DISABLE  0
  529. #define CHD_ENABLE   1
  531. // Set high-water-mark level (debugging use only)
  532. //
  533. #define CMD_SETHIGHWAT(arg) 
  534. (((cmdSyntaxPtr)(ct66))->cmd[1] = (arg),(cmdSyntaxPtr)(ct66))
  536. // Start flushing tagged data (tag = 0-14)
  537. //
  538. #define CMD_START_SELFL(tag) 
  539. (((cmdSyntaxPtr)(ct67))->cmd[1] = (tag),(cmdSyntaxPtr)(ct67))
  541. // End flushing tagged data (tag = 0-14)
  542. //
  543. #define CMD_END_SELFL(tag) 
  544. (((cmdSyntaxPtr)(ct68))->cmd[1] = (tag),(cmdSyntaxPtr)(ct68))
  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
  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))
  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))
  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.
  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.
  571. // Transmit this character immediately
  572. //
  573. #define CMD_XMIT_NOW(ch) 
  574. (((cmdSyntaxPtr)(ct79))->cmd[1] = (ch),(cmdSyntaxPtr)(ct79))
  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))
  583. #define CDL_RX 1 // Set receiver rate
  584. #define CDL_TX 2 // Set transmit rate
  585. // (CDL_TX | CDL_RX) Set both rates
  587. // Request for special diagnostic status pkt from the board.
  588. //
  589. #define CMD_GET_STATUS (cmdSyntaxPtr)(ct81)
  591. // Request time-stamped transmit character count packet.
  592. //
  593. #define CMD_GET_TXCNT  (cmdSyntaxPtr)(ct82)
  595. // Request time-stamped receive character count packet.
  596. //
  597. #define CMD_GET_RXCNT  (cmdSyntaxPtr)(ct83)
  599. // Request for box/board I.D. packet.
  600. #define CMD_GET_BOXIDS (cmdSyntaxPtr)(ct84)
  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))
  612. #define CEM_DISABLE  0
  613. #define CEM_ENABLE   1
  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))
  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)
  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)
  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))
  640. // Makes the loadware report DSS signals for this channel immediately.
  641. //
  642. #define CMD_DSS_NOW (cmdSyntaxPtr)(ct89)
  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))
  653. // Set timed break in decisecond (1/10s)
  654. //
  655. #define CMD_LBREAK(ds) 
  656. (((cmdSyntaxPtr)(ct91))->cmd[1] = (ds),(cmdSyntaxPtr)(ct66))
  660. #endif // I2CMD_H