/*
Copyright (C) Magna Carta Software, Inc. 1990-1991. All Rights Reserved.
Routines to support the Star Gate ACL series of multiport boards.
ACL01.C -- This file contains routines that interface the ACL board to the
CCT COMM_PORT structure.
*/
#define CCT_DEVELOPMENT
#include <dos.h>
#include <comm.h>
#include <acl.h>
/*
ACL_GET -- General purpose parameter retriever for the ACL series of
multiport cards.
Return values:
Success: The value of the UART register that sets stopbits;
EOF : Invalid parameter;
*/
short acl_get(COMM_PORT *p, short cmd)
{
short ret = 0;
char *cba = p->cba;
switch (cmd) {
/* DATA FORMAT */
case DATABITS:
ret = acl_get_databits(cba);
break;
case PARITY:
ret = acl_get_parity(cba);
break;
case STOPBITS:
ret = acl_get_stopbits(cba);
break;
/* RS-232 */
case CTS:
ret = acl_ch_get_modem_status(cba) & 1;
break;
case DCD:
ret = (acl_ch_get_modem_status(cba) & 8) >> 3;
break;
case DSR:
ret = (acl_ch_get_modem_status(cba) & 2) >> 1;
break;
case DTR:
ret = acl_ch_get_modem_ctl(cba) & 1;
break;
case RI:
ret = (acl_ch_get_modem_status(cba) & 4) >> 2;
break;
case RTS:
ret = (acl_ch_get_modem_ctl(cba) & 2) >> 1;
break;
default:
ret = EOF;
}
return (ret);
}
/*
ACL_GET_SPEED -- Return the current data transfer rate of the channel.
*/
long acl_get_speed(COMM_PORT *p)
{
return ((long) acl_ch_get(p->cba, ACL_BAUD_RATE));
}
/*
ACL_GET_RX_XLAT -- Query the setting of each of the input translation
variables used in c_getc().
*/
short acl_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);
}
/*
ACL_GET_TX_XLAT -- Return the value of various transmit data translation
parameters.
*/
short acl_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 = acl_ch_get(p->cba, ACL_LINE_PROTOCOL);
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);
}
/*
ACL_INIT_CHANNEL -- Set the parameters for an ACL channel.
Note: The Stargate defaults are shown on p.27 of the "ACL Family Technical
Reference Manual" (Jan. 1990) as:
9600 8-N-1;
No flow ctl;
Return Value:
0 -- success;
PORT_OPEN -- port already initialized;
NO_PORT -- MAX_PORTS already in use;
-2 -- ACL board not initialized;
*/
short acl_init_channel(COMM_PORT *p, ACL *acl, WORD portnum, long speed,
WORD databits, WORD parity, WORD stopbits)
{
short i;
if (p->open) return (PORT_OPEN);
if (!acl->base_addr) return (-2);
/* INITIALIZE DATA IN THE COMM_PORT STRUCTURE */
p->utype = STARGATE_ACL;
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->cba = acl->cba + acl_ccb_size(acl)*portnum;
p->rxbuf = (BYTE FAR_ *) acl->base_addr;
p->rxbufend = (BYTE FAR_ *) acl->base_addr + acl_ch_get_ibuf_ea(p->cba);
p->rxbufhead = acl->base_addr + acl_ch_get_nctib(p->cba);
p->rxbuftail = acl->base_addr + acl_ch_get_ncfib(p->cba);
p->txbuf = (BYTE FAR_ *) acl->base_addr;
p->txbufend = (BYTE FAR_ *) acl->base_addr + acl_ch_get_obuf_ea(p->cba);
p->txbufhead = acl->base_addr + acl_ch_get_nctob(p->cba);
p->txbuftail = acl->base_addr + acl_ch_get_ncfob(p->cba);
for (i=0; i < 4; i++) p->a_ipr[i] = (void FAR_ *) com_dummy_;
/* INITIALIZE DEVICE-SPECIFIC FUNCTION POINTERS */
p->set = acl_set;
p->get = acl_get;
p->get_rx_xlat = acl_get_rx_xlat;
p->set_rx_xlat = acl_set_rx_xlat;
p->get_tx_xlat = acl_get_tx_xlat;
p->set_tx_xlat = acl_set_tx_xlat;
p->set_speed = acl_set_speed;
p->get_speed = acl_get_speed;
p->rxstat = acl_rxstat;
p->txstat = acl_txstat;
p->c_read = acl_read;
p->c_write = acl_write;
#if 0
p->install_ipr = acl_install_ipr;
p->deinstall_ipr = acl_deinstall_ipr;
p->deinit_port = acl_deinit;
p->enable_comm_int = acl_enable_comm_int;
p->disable_comm_int = acl_disable_comm_int;
#endif
/* OPEN THE PORT */
return (c_open_(p));
}
/*
ACL_READ -- read a byte from a channel of the ACL board.
Return: the byte read.
*/
short acl_read(COMM_PORT *p)
{
BYTE c;
WORD addr;
void *cba = p->cba;
addr = acl_ch_get_ncfib(cba);
c = *(addr++ + p->rxbuf);
if (addr > acl_ch_get_ibuf_ea(cba))
acl_ch_set_ncfib(cba, acl_ch_get_ibuf_sa(cba));
else acl_ch_set_ncfib(cba, addr);
if (p->rxdatabits == 7) c &= 0X7F;
else if (p->rxdatabits == 6) c &= 0X3F;
else if (p->rxdatabits == 5) c &= 0X1F;
return (c);
}
/*
ACL_RXSTAT -- report whether a character is ready in the channel
receive buffer.
Return value:
FALSE (NULL) if no byte is ready. Else TRUE.
*/
short acl_rxstat(COMM_PORT *p)
{
return (acl_ch_get_ncfib(p->cba) != acl_ch_get_nctib(p->cba));
}
/*
ACL_SET -- General purpose command dispatcher for the ACL board.
Return values:
0 -- Success;
EOF -- Invalid parameter;
*/
short acl_set(COMM_PORT *p, short cmd, short value)
{
short ret = 0;
char *cba = p->cba;
switch (cmd) {
/* DATA FORMAT */
case DATABITS:
ret = acl_ch_set_databits(cba, value);
break;
case PARITY:
ret = acl_ch_set_parity(cba, value);
break;
case STOPBITS:
ret = acl_ch_set_stopbits(cba, value);
break;
case BREAK:
ret = acl_ch_get_modem_ctl(cba) | ACL_BREAK;
ret = acl_ch_set_modem_ctl(cba, ret);
break;
/* RS-232 */
case DTR:
ret = (acl_ch_get_modem_ctl(cba) & ~ACL_DTR) | value;
acl_ch_set_modem_ctl(cba, ret);
break;
case OUT1:
case OUT2:
ret = EOF;
break;
case RTS:
value <<= 1;
ret = (acl_ch_get_modem_ctl(cba) & ~ACL_RTS) | value;
acl_ch_set(cba, ACL_MODEM_CONTROL, ret);
break;
/* DIAGNOSTIC/OTHER */
case LOOPBACK:
ret = acl_set_channel_mode(p, value);
break;
default:
ret = EOF;
}
return (ret);
}
/*
ACL_SET_CHANNEL_MODE -- Set the mode for an ACL channel.
Parameters:
ACL *acl -- ptr. to the ACL structure;
WORD mode -- desired operating mode;
Return Value:
the value of the Channel Status Word;
*/
short acl_set_channel_mode(COMM_PORT *p, WORD mode)
{
WORD format = (acl_ch_get(p->cba, ACL_DATA_FORMAT) & 0X3F) | mode;
return (acl_ch_set_data_format(p->cba, format));
}
/*
ACL_SET_RX_XLAT -- Specify the type of input translation used by c_getc()
and c_gets().
*/
short acl_set_rx_xlat(COMM_PORT *p, short item, short value)
{
WORD format;
short 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:
if (value) p->flowctl |= (value >> 4);
else p->flowctl &= ~RX;
break;
case FLOWHIGH:
p->flowhigh = value;
break;
case XONCHAR: /* value to be considered an XON */
format = acl_ch_get(p->cba, ACL_LINE_PROTOCOL);
if (value == XON_ALL) acl_ch_set_line_protocol(p->cba, format | ACL_XON_ALL);
else {
acl_ch_set_line_protocol(p->cba, format & ~ACL_XON_ALL);
format = acl_ch_get(p->cba, ACL_IXON_CHARACTERS) & 0X00FF;
acl_ch_set_ixon_chars(p->cba, format | (value << 8));
}
p->xonchar = value; /* a specific char. */
break;
case XOFFCHAR:
format = acl_ch_get(p->cba, ACL_IXON_CHARACTERS) & 0XFF00;
acl_ch_set_ixon_chars(p->cba, format | value);
p->xoffchar = value;
break;
/* SCAN CODE/CHARACTER CODE OF KEY TO ABORT */
case ABORT_KEY: p->abort_key = value; break;
/* INTERRUPT THRESHOLD LEVEL */
case ACL_INPUT_BUFFER_TRIGGER_RATE:
ret = acl_ch_set_ibuf_trig(p->cba, value);
break;
case ACL_INPUT_BUFFER_LWM:
ret = acl_ch_set_ibuf_lwm(p->cba, value);
break;
case ACL_INPUT_BUFFER_HWM:
ret = acl_ch_set_ibuf_hwm(p->cba, value);
break;
default: ret = EOF; break;
}
if (!ret) {
if (value) p->rx_xlat = 1;
else p->rx_xlat = isrxxlat(p);
}
return (ret);
}
/*
ACL_SET_SPEED -- Set the speed of an ACL channel.
Parameters:
ACL_GCB *acl -- ptr. to the Global Control Block structure;
long speed -- desired port speed;
Return Value:
the value of the Channel Status Word;
*/
short acl_set_speed(COMM_PORT *p, long speed)
{
return (acl_ch_set(p->cba, ACL_BAUD_RATE, (WORD) speed));
}
/*
ACL_SET_TX_XLAT -- Assign values to data translation parameters.
*/
short acl_set_tx_xlat(COMM_PORT *p, short item, short value)
{
WORD format;
short 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:
format = acl_ch_get(p->cba, ACL_LINE_PROTOCOL);
if (value) switch (value) {
case XONXOFF:
acl_ch_set_line_protocol(p->cba, format | ACL_XONXOFF_ASSERT);
break;
case RTS_CTS:
acl_ch_set_line_protocol(p->cba, format | ACL_RTS_CTS_ASSERT);
break;
default:
ret = EOF;
break;
}
else switch (value) {
case XONXOFF:
acl_ch_set_line_protocol(p->cba, format & ~ACL_XONXOFF_ASSERT);
break;
case RTS_CTS:
acl_ch_set_line_protocol(p->cba, format & ~ACL_RTS_CTS_ASSERT);
break;
default:
ret = EOF;
break;
}
break;
case XONCHAR: /* value to be considered an XON */
format = acl_ch_get(p->cba, ACL_IXOFF_CHARACTERS) & 0X00FF;
acl_ch_set_ixoff_chars(p->cba, format | (value << 8));
p->xonchar = value; /* a specific char. */
break;
case XOFFCHAR:
format = acl_ch_get(p->cba, ACL_IXOFF_CHARACTERS) & 0XFF00;
acl_ch_set_ixoff_chars(p->cba, format | 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 ACL_OUTPUT_BUFFER_LWM:
ret = acl_ch_set_obuf_lwm(p->cba, value);
break;
default:
ret = EOF;
break;
}
if (!ret) {
if (value) p->tx_xlat = 1;
else p->tx_xlat = istxxlat(p);
}
return (ret);
}
/*
ACL_TXSTAT -- report whether ACL transmit buffer is ready for a byte.
Return: FALSE if transmit buffer is not empty
TRUE if transmit buffer is empty.
*/
short acl_txstat(COMM_PORT *p)
{
return(acl_ch_get_ncfob(p->cba) != acl_ch_get_nctob(p->cba) + 1);
}
/*
ACL_WRITE -- write a byte to the output buffer of an ACL channel.
*/
void acl_write(COMM_PORT *p, short c)
{
char *cba = p->cba;
WORD addr = acl_ch_get_nctob(cba);
*(p->txbuf + addr++) = (BYTE) c;
if (addr > acl_ch_get_obuf_ea(cba))
acl_ch_set_nctob(cba, acl_ch_get_obuf_sa(cba));
else acl_ch_set_nctob(cba, addr);
}
