/*
Copyright (C) Magna Carta Software, Inc. 1990, 1991. All Rights Reserved.
Code for the DigiBoard DigiCHANNEL COM/Xi family of products (i.e. the
COM/4i & COM/8i).
This file contains functions that interface the DigiBoard, Inc. M232.DOC
source code to Magna Carta Software's C Communications Toolkit. This file
is the DigiBoard analog of INS8250.C. Each function begins with the prefix
"comxi_" to indicate that it is specific to the DigiBoard COM/Xi series of
FEP cards.
*/
#if (defined(__TURBOC__) || defined(__POWERC))
#include <dos.h>
#else
#include <conio.h>
#endif
#include <digixi0.h>
#undef RTS
#undef DTR
#include <comm.h>
#include <digixi1.h>
static WORD baud_xlat_table[][2] = {{50, 9}, {75, 10}, {110, 1}, {134, 11},
{150, 2}, {200, 12}, {300, 3}, {600, 4}, {1200, 5}, {1800, 13},
{2000, 14}, {2400, 6}, {3600, 15}, {4800, 7}, {7200, 16}, {9600, 8},
{19200, 17}, {0X9600, 18}};
static short comxi_xlat_parity[] = {NPARITY, OPARITY, EPARITY, (OPARITY | SPARITY), (EPARITY | SPARITY)};
static short nelem = sizeof(baud_xlat_table)/(sizeof(WORD) * 2);
/*
COMXI_GET -- General purpose function to return values for the DigiBoard
COM/Xi family.
Return values:
Success: The value of the UART register that sets stopbits;
EOF : Invalid number of stopbits specified;
*/
short comxi_get(COMM_PORT *p, short cmd)
{
short ret = EOF;
switch (cmd) {
/* DATA FORMAT */
case SPEED:
break;
case DATABITS:
ret = p->rxdatabits;
break;
case STOPBITS:
ret = p->stopbits;
break;
case PARITY:
ret = p->parity;
break;
/* RS-232 */
case CTS:
break;
case DCD:
break;
case DSR:
break;
case DTR:
ret = p->dtr;
break;
case RI:
break;
case RTS:
ret = p->rts;
break;
case OUT1:
break;
case OUT2:
break;
}
return (ret);
}
/*
COMXI_GET_RX_XLAT -- Query the setting of each of the input translation
variables used in c_getc().
*/
short comxi_get_rx_xlat(COMM_PORT *p, short item)
{
short ret = 0;
switch (item) {
case XLAT: ret = isrxxlat(p); break; /* OFF or ON */
case LOCAL_ECHO: ret = isrxecholocal(p); break; /* OFF or ON */
case REMOTE_ECHO: ret = isrxechoremote(p); break;/* OFF or ON */
case PRINTER_ECHO: ret = isrxechoprn(p); break; /* OFF or ON */
case CAPTURE_BUFFER_ECHO: ret = isrxechobuf(p); break; /* OFF or ON */
/*
EOL is one of: FALSE, LF2CR, CR2LF, EOL2SP,
STRIPEOL, LF2CRLF, CR2CRLF, CRLF2LF, CRLF2CR
*/
case EOL: ret = p->rx_eol; break;
case CASE: ret = p->rx_case_convert; break;
case ASCII_ONLY: ret = p->rx_ascii_only; break;
case INTERBYTE_DELAY: ret = p->rx_ibdelay; break;
case FLOWCTL: ret = p->flowctl & RX; break; /* OFF or ON */
case XONCHAR: ret = p->xonchar; break; /* ASCII value */
case XOFFCHAR: ret = p->xoffchar; break; /* ASCII value */
case ABORT_KEY: ret = p->abort_key; break;
default: ret = EOF; break;
}
return (ret);
}
/*
COMXI_GET_TX_XLAT -- Return the value of various transmit data translation
parameters.
*/
short comxi_get_tx_xlat(COMM_PORT *p, short item)
{
short ret = 0;
switch (item) {
case LOCAL_ECHO: ret = istxecholocal(p); break; /* OFF or ON */
case REMOTE_ECHO: ret = istxechoremote(p);break; /* OFF or ON */
case PRINTER_ECHO: ret = istxechoprn(p); break; /* OFF or ON */
case CAPTURE_BUFFER_ECHO:
ret = istxechobuf(p); break; /* OFF or ON */
case XLAT: ret = istxxlat(p); break; /* OFF or ON */
/*
EOL is one of: FALSE, LF2CR, CR2LF, EOL2SP,
STRIPEOL, LF2CRLF, CR2CRLF, CRLF2LF, CRLF2CR
*/
case EOL: ret = p->tx_eol; break;
case CASE: ret = p->tx_case_convert; break;
case ASCII_ONLY: ret = p->tx_ascii_only; break;
/* INTERBYTE AND INTERLINE DELAYS (in ms.). */
case INTERBYTE_DELAY: ret = p->tx_ibdelay; break;
case INTERLINE_DELAY: ret = p->tx_ildelay; break;
/* CHARACTER TO TRIGGER INTERLINE DELAY */
case INTERLINE_DELAY_CHAR: ret = p->tx_ildelay_ch; break;
case FLOWCTL:
ret = p->flowctl & TX;
break;
case TX_DELAY:
ret = p->tx_delay;
break;
case TX_DELAYCHAR:
ret = p->tx_delaych;
break;
case XONCHAR: ret = p->xonchar; break; /* ASCII value */
case XOFFCHAR: ret = p->xoffchar; break; /* ASCII value */
/* ASCII CODE OF KEY TO ABORT XOFF */
case ABORT_KEY: ret = p->abort_key; break;
default: ret = EOF; break;
}
return (ret);
}
/*
COMXI_INIT -- Initialize the COM/Xi board and integrate it into the toolkit.
Parameters:
WORD port -- board I/O port address;
WORD seg -- board memory address to use;
WORD size -- board RX,TX buffer size (0-2 for M232);
Return value:
0 -- success;
NOTWARM (-4) -- Module not loaded;
BADVERSN (-8) -- ?
BUSYHML (-5) -- FEP busy (0h not written to "mailbox");
TMOERROR (-2) -- Module did not start executing;
or ... -- timeout error during initialization;
*/
short comxi_init(COMXI *c, WORD port, WORD seg, WORD size)
{
short ret;
ret = resetcomxi(port, seg);
if (!ret) {
ret = excM232(port, seg, size);
if (!ret) {
c->base_addr = seg;
c->port_addr = port;
}
}
return (ret);
}
/*
COMXI_INIT_CHANNEL -- Initialize one port on the COM/Xi board.
Parameters:
COMM_PORT *p -- pointer to the COMM_PORT structure for this port;
Return value:
*/
short comxi_init_channel(COMM_PORT *p, COMXI *c, WORD portnum, long speed,
WORD databits, WORD parity, WORD stopbits)
{
if (p->open) return (PORT_OPEN);
if (c->base_addr == 0) return (-2);
p->utype = DIGIBOARD_COMXI;
p->rxdatabits = databits;
p->txdatabits = databits;
p->parity = parity;
p->stopbits = stopbits;
p->speed = speed;
p->dtr = HIGH;
p->rts = HIGH;
p->abort_key = ESCAPE;
p->ubase_addr = c->port_addr; /* "port" is assigned to ubase_addr */
p->user1 = c->base_addr; /* "seg" is assigned to p->user1 */
p->user2 = portnum; /* channel # assigned to p->user2 */
/* INITIALIZE DEVICE-SPECIFIC FUNCTION POINTERS */
p->set = comxi_set;
p->get = comxi_get;
p->get_rx_xlat = comxi_get_rx_xlat;
p->set_rx_xlat = comxi_set_rx_xlat;
p->get_tx_xlat = comxi_get_tx_xlat;
p->set_tx_xlat = comxi_set_tx_xlat;
p->set_speed = comxi_set_speed;
p->get_speed = (long (*)(struct comm_port *)) comxi_get;
p->rxstat = (short (*)(struct comm_port *)) comxi_ret;
p->txstat = comxi_txstat;
p->c_read = comxi_read;
p->c_write = comxi_write;
p->enable_comm_int = (short (*)(struct comm_port *, WORD)) comxi_ret;
p->disable_comm_int = (short (*)(struct comm_port *, WORD))comxi_ret;
p->install_ipr = (short (*)(struct comm_port *, WORD, void FAR_ *, BYTE FAR_ *, WORD))comxi_ret;
p->deinstall_ipr = (short (*)(struct comm_port *, WORD))comxi_ret;
p->deinit_port = (short (*)(struct comm_port *)) comxi_ret;
p->enable_comm_int = (short (*)(struct comm_port *, WORD))comxi_ret;
p->disable_comm_int = (short (*)(struct comm_port *, WORD))comxi_ret;
/* OPEN THE PORT */
return (c_open_(p));
}
short comxi_read(COMM_PORT *p)
{
short ret;
ret = rdch(p->ubase_addr, p->user1, p->user2);
if (ret < 0) {
global_com_error = ret;
ret = EOF;
}
return (ret);
}
/*
COMXI_RET -- Dummy do-nothing function to handle COMM_PORT function pointers
not supported by the COM/Xi.
*/
short comxi_ret(void)
{
return (EOF);
}
short comxi_rxstat(COMM_PORT *p)
{
short ret;
ret = rdch(p->ubase_addr, p->user1, p->user2);
if (ret < 0) {
global_com_error = ret;
ret = EOF;
}
return (ret);
}
/*
COMXI_SEND_BREAK -- Send a BREAK signal to the designated port of the COM/Xi.
Parameters:
COMM_PORT *p -- ptr. to the COMM_PORT structure;
WORD duration -- duration in ms. (calibrated to nearest 55ms.);
Return values:
0 -- success;
CMDQFUL (-9) -- Command buffer full;
*/
short comxi_send_break(COMM_PORT *p, WORD duration)
{
duration = (duration < 55) ? 1 : duration/18;
wrtbcmd(p->user1, SBRKCNT, p->user2, duration, 0);
return(wrtbcmd(p->user1, SBREAK, p->user2, 0, 0));
}
/*
COMXI_SET -- General purpose command dispatcher for the DigiBoard COM/Xi
family.
Return values:
0 -- success;
EOF -- invalid 'cmd' specified;
*/
short comxi_set(COMM_PORT *p, short cmd, short value)
{
short ret = EOF;
switch (cmd) {
/* DATA FORMAT */
case DATABITS:
ret = comxi_set_databits(p, value);
break;
case STOPBITS:
ret = comxi_set_stopbits(p, value);
break;
case PARITY:
ret = comxi_set_parity(p, value);
break;
/* RS-232 */
case DTR:
comxi_set_dtr(p, value);
break;
case RTS:
comxi_set_rts(p, value);
break;
case BREAK:
comxi_send_break(p, value);
break;
case LOOPBACK:
break;
case OUT1:
break;
case OUT2:
break;
}
return (ret);
}
/*
COMXI_SET_DATABITS -- Set the number of databits for the designated serial
port to the designated value.
Return values:
Success: The value of the UART register that sets stopbits;
EOF : Invalid number of stopbits specified;
*/
short comxi_set_databits(COMM_PORT *p, short value)
{
short stops, parity;
switch (value) {
case DATABITS5: value = DATA5; break;
case DATABITS6: value = DATA6; break;
case DATABITS7: value = DATA7; break;
case DATABITS8: value = DATA8; break;
default: return (EOF);
}
parity = comxi_xlat_parity[p->parity];
stops = (p->stopbits == 1) ? 0 : 4;
value = parity | stops | value;
wrtbcmd(p->user1, SBAUDATA, p->user2, comxi_xlat_baud(p->speed), value);
return (0);
}
/*
COMXI_SET_DTR -- Set the value of the DTR line for the designated serial
port to the designated value.
Return values:
Success: The value of the UART register that sets stopbits;
EOF : Invalid value for "value" specified;
*/
short comxi_set_dtr(COMM_PORT *p, short value)
{
if (value == HIGH) wrtbcmd(p->user1, SMODEM, p->user2, '\x1', 0);
else if (value == LOW) wrtbcmd(p->user1, SMODEM, p->user2, '\x0', '\x1');
else return (EOF);
return (0);
}
/*
COMXI_SET_FLOWCTL -- Set flow control off or on.
"flowtype" is an ORing of the values in DIGIXI0.H for function 0X1B.
"state"
*/
short comxi_set_flowctl(COMM_PORT *p, short flowtype, short state)
{
short ret;
if (state == OFF) ret = wrtbcmd(p->user1, SHNDSHK, p->user2, '\0', flowtype);
else ret = wrtbcmd(p->user1, SHNDSHK, p->user2, flowtype, '\0');
return (ret);
}
/*
COMXI_SET_PARITY -- Set the parity of the designated serial port to the
designated value.
Return values:
Success: The value of the UART register that sets stopbits;
EOF : Invalid number of stopbits specified;
*/
short comxi_set_parity(COMM_PORT *p, short value)
{
short stops;
switch (value) {
case PARITY_NONE: value = NPARITY; break;
case PARITY_ODD: value = OPARITY; break;
case PARITY_EVEN: value = EPARITY; break;
case PARITY_MARK: value = (OPARITY | SPARITY); break;
case PARITY_SPACE: value = (EPARITY | SPARITY); break;
default:
return (EOF);
}
stops = (p->stopbits == 1) ? 0 : 4;
value = (p->rxdatabits - 5) | stops | value;
wrtbcmd(p->user1, SBAUDATA, p->user2, comxi_xlat_baud(p->speed), value);
return (0);
}
/*
COMXI_SET_RTS -- Set the value of the RTS line for the designated serial
port to the designated value.
Return values:
Success: The value of the UART register that sets stopbits;
EOF : Invalid value for "value" specified;
*/
short comxi_set_rts(COMM_PORT *p, short value)
{
if (value == HIGH) wrtbcmd(p->user1, SMODEM, p->user2, '\x2', 0);
else if (value == LOW) wrtbcmd(p->user1, SMODEM, p->user2, '\x0', '\x2');
else return (EOF);
return (0);
}
/*
COMXI_SET_RX_XLAT -- Specify the type of input translation used by c_getc()
and c_gets().
*/
short comxi_set_rx_xlat(COMM_PORT *p, short item, short value)
{
short parm, ret = 0;
switch (item) {
case LOCAL_ECHO:
case REMOTE_ECHO:
case PRINTER_ECHO:
case CAPTURE_BUFFER_ECHO:
if (value) p->echo |= item;
else p->echo &= ~item;
break;
/*
EOL is one of: FALSE, LF2CR, CR2LF, EOL2SP,
STRIPEOL, LF2CRLF, CR2CRLF, CRLF2LF, CRLF2CR
*/
case EOL:
p->rx_eol = value;
break;
case CASE: /* UPPER, LOWER, FALSE */
p->rx_case_convert = value; break;
case ASCII_ONLY:
p->rx_ascii_only = value; break;
case INTERBYTE_DELAY:
p->rx_ibdelay = value; break;
case TRAILINGBYTE_DELAY:
p->rx_tbdelay = value; break;
case FLOWCTL:
switch(value) {
case XONXOFF:
parm = (SHND | OHND);
break;
case RTS_CTS:
parm = (HHND | OHND);
break;
default:
ret = EOF;
}
if (!ret) comxi_set_flowctl(p, parm, value);
break;
case FLOWHIGH:
p->flowhigh = value;
break;
case XONCHAR: /* value to be considered an XON */
if (value == XON_ALL) comxi_set_flowctl(p, (SHND | OHND | XAKP), value);
else ret = wrtbcmd(p->user1, SONOFF, p->user2, (BYTE) value, (BYTE) p->xoffchar);
p->xonchar = value; /* a specific char. */
break;
case XOFFCHAR:
ret = wrtbcmd(p->user1, SONOFF, p->user2, p->xonchar, value);
p->xoffchar = value;
break;
case RX_BUFFER_LWM:
wrtbcmd(p->user1, SRXLWTR, p->user2, value & 0XFF, value >> 8);
ret = EOF;
break;
case RX_BUFFER_HWM:
/* work in progress */
ret = EOF;
break;
/* SCAN CODE/CHARACTER CODE OF KEY TO ABORT */
case ABORT_KEY: p->abort_key = value; break;
default: ret = EOF; break;
}
if (!ret) {
if (value) p->rx_xlat = 1;
else p->rx_xlat = isrxxlat(p);
}
return (ret);
}
/*
COMXI_SET_SPEED -- Set the data rate (bps) for the deignated port.
Return value:
SUCCESS (0) -- OK;
EOF -- Invalid speed value;
CMDQFUL (-9) -- Command buffer full;
*/
short comxi_set_speed(COMM_PORT *p, long value)
{
short stops, parity, parms;
parity = comxi_xlat_parity[p->parity];
stops = (p->stopbits == 1) ? 0 : 4;
parms = (p->rxdatabits - 5) | stops | parity;
if ((value = comxi_xlat_baud(value)) != EOF)
return (wrtbcmd(p->user1, SBAUDATA, p->user2, (WORD) value, parms));
return (EOF);
}
/*
COMXI_SET_STOPBITS -- Set the number of stopbits for the designated serial
port to the designated value.
Return values:
Success: The value of the UART register that sets stopbits;
EOF : Invalid number of stopbits specified;
*/
short comxi_set_stopbits(COMM_PORT *p, short value)
{
short parity;
switch (value) {
case STOPBITS1: value = STOP1; break;
case STOPBITS2: value = STOP2; break;
case STOPBITS15:
default:
return (EOF);
}
parity = comxi_xlat_parity[p->parity];
value = (p->rxdatabits - 5) | parity | value;
wrtbcmd(p->user1, SBAUDATA, p->user2, comxi_xlat_baud(p->speed), (BYTE) value);
return (0);
}
/*
COMXI_SET_TX_XLAT -- Assign values to data translation parameters.
*/
short comxi_set_tx_xlat(COMM_PORT *p, short item, short value)
{
short parm, ret = 0;
switch (item) {
case LOCAL_ECHO:
case REMOTE_ECHO:
case PRINTER_ECHO:
case CAPTURE_BUFFER_ECHO:
if (value) p->echo |= (item << 4);
else p->echo &= ~(item << 4);
break;
/*
EOL is one of: FALSE, LF2CR, CR2LF, EOL2SP,
STRIPEOL, LF2CRLF, CR2CRLF, CRLF2LF, CRLF2CR
*/
case EOL:
p->tx_eol = value;
break;
case CASE: /* UPPER, LOWER, NORMAL */
p->tx_case_convert = value;
break;
case ASCII_ONLY:
p->tx_ascii_only = value;
break;
case INTERBYTE_DELAY:
p->tx_ibdelay = value;
break;
case TX_DELAY:
p->tx_delay = value;
break;
case TX_DELAYCHAR:
p->tx_delaych = value;
break;
case INTERLINE_DELAY:
p->tx_ildelay = value;
break;
case INTERLINE_DELAY_CHAR:
p->tx_ildelay_ch = value;
break;
case FLOWCTL:
switch(value) {
case XONXOFF:
parm = (SHND | IHND);
break;
case RTS_CTS:
parm = (HHND | IHND);
break;
default:
ret = EOF;
}
if (!ret) comxi_set_flowctl(p, parm, value);
break;
case XONCHAR: /* value to be considered an XON */
ret = wrtbcmd(p->user1, SONOFF, p->user2, value, p->xoffchar);
p->xonchar = value; /* a specific char. */
break;
case XOFFCHAR:
ret = wrtbcmd(p->user1, SONOFF, p->user2, p->xonchar, value);
p->xoffchar = value;
break; /* ASCII value */
/* SCAN CODE/CHARACTER CODE OF KEY TO ABORT XOFF */
case ABORT_KEY:
p->abort_key = value;
break;
case TX_BUFFER_LWM:
/* work in progress */
ret = EOF;
break;
default:
ret = EOF;
break;
}
if (!ret) {
if (value) p->tx_xlat = 1;
else p->tx_xlat = istxxlat(p);
}
return (ret);
}
short comxi_txstat(COMM_PORT *p)
{
WORD port = p->ubase_addr;
WORD seg = p->user1;
WORD chn = p->user2;
WORD a;
a = btbl(seg)[chn].BWIND;
if (a != (inp(port) & 0X0f)) {
if (swindow(port, seg, a)) return (FALSE);
}
a = btbl(seg)[chn].TXHD;
if (++a > btbl(seg)[chn].TXMAX) a = btbl(seg)[chn].TXSTRT;
if (a != btbl(seg)[chn].TXTL) return (TRUE);
else return (FALSE);
}
/*
COMXI_WRITE -- Low level function to write a byte. This function is just a
binding function to call wrtch().
*/
void comxi_write(COMM_PORT *p, short ch)
{
wrtch(p->ubase_addr, p->user1, p->user2, ch);
}
/*
COMXI_XLAT_BAUD -- Convert a data transfer rate expressed as a number to a
DigiBoard manifest constant.
Return value:
>0 -- DigiBoard speed specification;
EOF -- Invalid value for "value";
*/
short comxi_xlat_baud(long value)
{
short i;
for (i=0; i < nelem; i++) {
if (baud_xlat_table[i][0] == (WORD) value) return (baud_xlat_table[i][1]);
}
return (EOF);
}
#if defined(CCT_TEST)
/* NOT USER-RUNABLE -- RUN CCTDIGIx.C TO TEST CCT WITH THE BOARD */
#include <conio.h>
#include <ctype.h>
#define MENU ALT_M /* key for command summary */
/* FUNCTION PROTOTYPES */
void term(COMM_PORT *p); /* the main program loop */
short menu(void); /* the function that handles the menu */
/* GLOBAL VARIABLES */
short vers = 0; /* the version number of "CCT-COMM" */
COMM_PORT d0, d1, d2, d3, d4, d5, d6, d7;
COMM_PORT *digi[] = {&d0, &d1, &d2, &d3, &d4, &d5, &d6, &d7, NULL};
void main(void)
{
short ret;
clrscr();
ret = comxi_init(digi, 0X320, 0XD800, 0);
printf("\nResult of comxi_init() is: %d", ret);
set_speed(digi[0], 2400L);
set_databits(digi[0], 8);
set_stopbits(digi[0], 1);
set_parity(digi[0], PARITY_NONE);
set_rts(digi[0], HIGH);
set_dtr(digi[0], HIGH);
printf("\nCCT-COMM Version %d: Press Alt-M for a list of commands\n", vers);
term(digi[0]);
printf("\nEnd of CCT-COMM%d\n", vers);
set_rts(digi[0], LOW);
set_dtr(digi[0], LOW);
}
/*
TERM -- The terminal emulation routine. Simply polls the COM port and the
keyboard alternately for characters.
*/
void term(COMM_PORT *p_port)
{
short c; /* must be int to detect a -1 return */
for (;;) {
/* CHECK SERIAL PORT FOR BYTE */
if ( (c = c_inchar(p_port)) != EOF)
putchar(c);
/* CHECK KEYBOARD FOR A KEY PRESS */
if ( (c = inkey()) != EOF) {
if (c == MENU) {
if (menu()) break;
}
else c_putc(p_port, c);
}
}
}
#define EXIT 'Q' /* key to exit from menu */
short menu(void)
{
int c, retval = 0;
static char *menus[] = {
"\tQ. EXIT from TERM.",
NULL /* null string terminates list */
};
char **menup;
c = !EXIT;
while (c != EXIT) {
puts("\n\n");
for (menup = menus; *menup != NULL; menup++) printf("%s\n", *menup);
printf("\n\t\t Enter selection (CR to quit menu) : ");
if ( (c = getch()) == CR) break; /* return to term */
c = toupper(c);
switch (c) {
case EXIT:
retval = 1;
break;
default:
puts("Invalid choice\n\007");
break;
}
}
puts("\nExiting menu");
return (retval); /* will be zero except if EXIT */
}
#endif
