a3efda28be
* rdi-share/serpardr.c: Ditto. * rdi-share/unixcomm.c: Ditto. * rdi-share/serdrv.c: Ditto. * rdi-share/hostchan.h: Ditto. * rdi-share/hostchan.c: Ditto. * rdi-share/host.h: Ditto. * rdi-share/devsw.c: Ditto.
730 lines
17 KiB
C
730 lines
17 KiB
C
/*
|
|
* Copyright (C) 1995 Advanced RISC Machines Limited. All rights reserved.
|
|
*
|
|
* This software may be freely used, copied, modified, and distributed
|
|
* provided that the above copyright notice is preserved in all copies of the
|
|
* software.
|
|
*/
|
|
|
|
/* -*-C-*-
|
|
*
|
|
* $Revision$
|
|
* $Date$
|
|
*
|
|
*
|
|
* serpardv.c - Serial/Parallel Driver for Angel.
|
|
*/
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
|
|
#include "crc.h"
|
|
#include "devices.h"
|
|
#include "buffers.h"
|
|
#include "rxtx.h"
|
|
#include "hostchan.h"
|
|
#include "params.h"
|
|
#include "logging.h"
|
|
#include "hsys.h"
|
|
|
|
#ifdef COMPILING_ON_WINDOWS
|
|
# undef ERROR
|
|
# undef IGNORE
|
|
# include <windows.h>
|
|
# include "angeldll.h"
|
|
# include "comb_api.h"
|
|
#else
|
|
# ifdef __hpux
|
|
# define _TERMIOS_INCLUDED
|
|
# include <sys/termio.h>
|
|
# undef _TERMIOS_INCLUDED
|
|
# else
|
|
# include <termios.h>
|
|
# endif
|
|
# include "unixcomm.h"
|
|
#endif
|
|
|
|
#ifndef UNUSED
|
|
# define UNUSED(x) (x = x) /* Silence compiler warnings */
|
|
#endif
|
|
|
|
#define MAXREADSIZE 512
|
|
#define MAXWRITESIZE 512
|
|
|
|
#define SERPAR_FC_SET ((1 << serial_XON) | (1 << serial_XOFF))
|
|
#define SERPAR_CTL_SET ((1 << serial_STX) | (1 << serial_ETX) | \
|
|
(1 << serial_ESC))
|
|
#define SERPAR_ESC_SET (SERPAR_FC_SET | SERPAR_CTL_SET)
|
|
|
|
static const struct re_config config = {
|
|
serial_STX, serial_ETX, serial_ESC, /* self-explanatory? */
|
|
SERPAR_FC_SET, /* set of flow-control characters */
|
|
SERPAR_ESC_SET, /* set of characters to be escaped */
|
|
NULL, /* serial_flow_control */
|
|
NULL, /* what to do with FC chars */
|
|
angel_DD_RxEng_BufferAlloc, NULL /* how to get a buffer */
|
|
};
|
|
|
|
static struct re_state rxstate;
|
|
|
|
/*
|
|
* structure used for manipulating transmit data
|
|
*/
|
|
typedef struct TxState
|
|
{
|
|
struct te_state state;
|
|
unsigned int index;
|
|
unsigned char writebuf[MAXWRITESIZE];
|
|
} TxState;
|
|
|
|
/*
|
|
* The set of parameter options supported by the device
|
|
*/
|
|
static unsigned int baud_options[] =
|
|
{
|
|
#ifdef __hpux
|
|
115200, 57600,
|
|
#endif
|
|
38400, 19200, 9600
|
|
};
|
|
|
|
static ParameterList param_list[] =
|
|
{
|
|
{
|
|
AP_BAUD_RATE,
|
|
sizeof(baud_options) / sizeof(unsigned int),
|
|
baud_options
|
|
}
|
|
};
|
|
|
|
static const ParameterOptions serpar_options =
|
|
{
|
|
sizeof(param_list) / sizeof(ParameterList),
|
|
param_list
|
|
};
|
|
|
|
/*
|
|
* The default parameter config for the device
|
|
*/
|
|
static Parameter param_default[] =
|
|
{
|
|
{ AP_BAUD_RATE, 9600 }
|
|
};
|
|
|
|
static const ParameterConfig serpar_defaults =
|
|
{
|
|
sizeof(param_default)/sizeof(Parameter),
|
|
param_default
|
|
};
|
|
|
|
/*
|
|
* The user-modified options for the device
|
|
*/
|
|
static unsigned int user_baud_options[sizeof(baud_options) /
|
|
sizeof(unsigned int)];
|
|
|
|
static ParameterList param_user_list[] =
|
|
{
|
|
{
|
|
AP_BAUD_RATE,
|
|
sizeof(user_baud_options) / sizeof(unsigned),
|
|
user_baud_options
|
|
}
|
|
};
|
|
|
|
static ParameterOptions user_options =
|
|
{
|
|
sizeof(param_user_list) / sizeof(ParameterList),
|
|
param_user_list
|
|
};
|
|
|
|
static bool user_options_set;
|
|
|
|
/* forward declarations */
|
|
static int serpar_reset(void);
|
|
static int serpar_set_params(const ParameterConfig *config);
|
|
static int SerparMatch(const char *name, const char *arg);
|
|
|
|
static void process_baud_rate(unsigned int target_baud_rate)
|
|
{
|
|
const ParameterList *full_list;
|
|
ParameterList *user_list;
|
|
|
|
/* create subset of full options */
|
|
full_list = Angel_FindParamList(&serpar_options, AP_BAUD_RATE);
|
|
user_list = Angel_FindParamList(&user_options, AP_BAUD_RATE);
|
|
|
|
if (full_list != NULL && user_list != NULL)
|
|
{
|
|
unsigned int i, j;
|
|
unsigned int def_baud = 0;
|
|
|
|
/* find lower or equal to */
|
|
for (i = 0; i < full_list->num_options; ++i)
|
|
if (target_baud_rate >= full_list->option[i])
|
|
{
|
|
/* copy remaining */
|
|
for (j = 0; j < (full_list->num_options - i); ++j)
|
|
user_list->option[j] = full_list->option[i+j];
|
|
user_list->num_options = j;
|
|
|
|
/* check this is not the default */
|
|
Angel_FindParam(AP_BAUD_RATE, &serpar_defaults, &def_baud);
|
|
if ((j == 1) && (user_list->option[0] == def_baud))
|
|
{
|
|
#ifdef DEBUG
|
|
printf("user selected default\n");
|
|
#endif
|
|
}
|
|
else
|
|
{
|
|
user_options_set = TRUE;
|
|
#ifdef DEBUG
|
|
printf("user options are: ");
|
|
for (j = 0; j < user_list->num_options; ++j)
|
|
printf("%u ", user_list->option[j]);
|
|
printf("\n");
|
|
#endif
|
|
}
|
|
|
|
break; /* out of i loop */
|
|
}
|
|
|
|
#ifdef DEBUG
|
|
if (i >= full_list->num_options)
|
|
printf("couldn't match baud rate %u\n", target_baud_rate);
|
|
#endif
|
|
}
|
|
#ifdef DEBUG
|
|
else
|
|
printf("failed to find lists\n");
|
|
#endif
|
|
}
|
|
|
|
static int SerparOpen(const char *name, const char *arg)
|
|
{
|
|
char *sername = NULL;
|
|
char *parname = NULL;
|
|
|
|
#ifdef DEBUG
|
|
printf("SerparOpen: name %s arg %s\n", name, arg ? arg : "<NULL>");
|
|
#endif
|
|
|
|
#ifdef COMPILING_ON_WINDOWS
|
|
if (IsOpenSerial() || IsOpenParallel()) return -1;
|
|
#else
|
|
if (Unix_IsSerialInUse() || Unix_IsParallelInUse()) return -1;
|
|
#endif
|
|
|
|
#ifdef COMPILING_ON_WINDOWS
|
|
if (SerparMatch(name, arg) == -1)
|
|
return -1;
|
|
#else
|
|
Unix_IsValidParallelDevice(name,&sername,&parname);
|
|
# ifdef DEBUG
|
|
printf("translated %s to serial %s and parallel %s\n",
|
|
name==0 ? "NULL" : name,
|
|
sername==0 ? "NULL" : sername,
|
|
parname==0 ? "NULL" : parname);
|
|
# endif
|
|
if (sername==NULL || parname==NULL) return -1;
|
|
#endif
|
|
|
|
user_options_set = FALSE;
|
|
|
|
/* interpret and store the arguments */
|
|
if (arg != NULL)
|
|
{
|
|
unsigned int target_baud_rate;
|
|
|
|
target_baud_rate = (unsigned int)strtoul(arg, NULL, 10);
|
|
|
|
if (target_baud_rate > 0)
|
|
{
|
|
#ifdef DEBUG
|
|
printf("user selected baud rate %u\n", target_baud_rate);
|
|
#endif
|
|
process_baud_rate(target_baud_rate);
|
|
}
|
|
#ifdef DEBUG
|
|
else
|
|
printf("could not understand baud rate %s\n", arg);
|
|
#endif
|
|
}
|
|
|
|
#ifdef COMPILING_ON_WINDOWS
|
|
{
|
|
/*
|
|
* The serial port number is in name[0] followed by
|
|
* the parallel port number in name[1]
|
|
*/
|
|
|
|
int sport = name[0] - '0';
|
|
int pport = name[1] - '0';
|
|
|
|
if (OpenParallel(pport) != COM_OK)
|
|
return -1;
|
|
|
|
if (OpenSerial(sport, FALSE) != COM_OK)
|
|
{
|
|
CloseParallel();
|
|
return -1;
|
|
}
|
|
}
|
|
#else
|
|
Unix_OpenParallel(parname);
|
|
Unix_OpenSerial(sername);
|
|
#endif
|
|
|
|
serpar_reset();
|
|
|
|
#if defined(__unix) || defined(__CYGWIN__)
|
|
Unix_ioctlNonBlocking();
|
|
#endif
|
|
|
|
Angel_RxEngineInit(&config, &rxstate);
|
|
|
|
return 0;
|
|
}
|
|
|
|
#ifdef COMPILING_ON_WINDOWS
|
|
static int SerparMatch(const char *name, const char *arg)
|
|
{
|
|
char sername[2];
|
|
char parname[2];
|
|
|
|
UNUSED(arg);
|
|
|
|
sername[0] = name[0];
|
|
parname[0] = name[1];
|
|
sername[1] = parname[1] = 0;
|
|
|
|
if (IsValidDevice(sername) == COM_DEVICENOTVALID ||
|
|
IsValidDevice(parname) == COM_DEVICENOTVALID)
|
|
return -1;
|
|
else
|
|
return 0;
|
|
}
|
|
#else
|
|
static int SerparMatch(const char *portstring, const char *arg)
|
|
{
|
|
char *sername=NULL, *parname=NULL;
|
|
UNUSED(arg);
|
|
|
|
Unix_IsValidParallelDevice(portstring,&sername,&parname);
|
|
|
|
/* Match failed if either sername or parname are still NULL */
|
|
if (sername==NULL || parname==NULL) return -1;
|
|
return 0;
|
|
}
|
|
#endif
|
|
|
|
static void SerparClose(void)
|
|
{
|
|
#ifdef COMPILING_ON_WINDOWS
|
|
CloseParallel();
|
|
CloseSerial();
|
|
#else
|
|
Unix_CloseParallel();
|
|
Unix_CloseSerial();
|
|
#endif
|
|
}
|
|
|
|
static int SerparRead(DriverCall *dc, bool block)
|
|
{
|
|
static unsigned char readbuf[MAXREADSIZE];
|
|
static int rbindex = 0;
|
|
|
|
int nread;
|
|
int read_errno;
|
|
int c = 0;
|
|
re_status restatus;
|
|
int ret_code = -1; /* assume bad packet or error */
|
|
|
|
/*
|
|
* we must not overflow buffer, and must start after
|
|
* the existing data
|
|
*/
|
|
#ifdef COMPILING_ON_WINDOWS
|
|
{
|
|
BOOL dummy = FALSE;
|
|
nread = BytesInRXBufferSerial();
|
|
|
|
if (nread > MAXREADSIZE - rbindex)
|
|
nread = MAXREADSIZE - rbindex;
|
|
read_errno = ReadSerial(readbuf+rbindex, nread, &dummy);
|
|
if (pfnProgressCallback != NULL && read_errno == COM_OK)
|
|
{
|
|
progressInfo.nRead += nread;
|
|
(*pfnProgressCallback)(&progressInfo);
|
|
}
|
|
}
|
|
#else
|
|
nread = Unix_ReadSerial(readbuf+rbindex, MAXREADSIZE-rbindex, block);
|
|
read_errno = errno;
|
|
#endif
|
|
|
|
if ((nread > 0) || (rbindex > 0))
|
|
{
|
|
#ifdef DO_TRACE
|
|
printf("[%d@%d] ", nread, rbindex);
|
|
#endif
|
|
|
|
if (nread > 0)
|
|
rbindex = rbindex + nread;
|
|
|
|
do
|
|
{
|
|
restatus = Angel_RxEngine(readbuf[c], &(dc->dc_packet), &rxstate);
|
|
|
|
#ifdef DO_TRACE
|
|
printf("<%02X ",readbuf[c]);
|
|
#endif
|
|
c++;
|
|
} while (c < rbindex &&
|
|
((restatus == RS_IN_PKT) || (restatus == RS_WAIT_PKT)));
|
|
|
|
#ifdef DO_TRACE
|
|
printf("\n");
|
|
#endif
|
|
|
|
switch(restatus)
|
|
{
|
|
case RS_GOOD_PKT:
|
|
ret_code = 1;
|
|
/* fall through to: */
|
|
|
|
case RS_BAD_PKT:
|
|
/*
|
|
* We now need to shuffle any left over data down to the
|
|
* beginning of our private buffer ready to be used
|
|
*for the next packet
|
|
*/
|
|
#ifdef DO_TRACE
|
|
printf("SerparRead() processed %d, moving down %d\n",
|
|
c, rbindex - c);
|
|
#endif
|
|
|
|
if (c != rbindex)
|
|
memmove((char *) readbuf, (char *) (readbuf + c), rbindex - c);
|
|
|
|
rbindex -= c;
|
|
|
|
break;
|
|
|
|
case RS_IN_PKT:
|
|
case RS_WAIT_PKT:
|
|
rbindex = 0; /* will have processed all we had */
|
|
ret_code = 0;
|
|
break;
|
|
|
|
default:
|
|
#ifdef DEBUG
|
|
printf("Bad re_status in SerparRead()\n");
|
|
#endif
|
|
break;
|
|
}
|
|
}
|
|
else if (nread == 0)
|
|
/* nothing to read */
|
|
ret_code = 0;
|
|
else if (read_errno == ERRNO_FOR_BLOCKED_IO) /* nread < 0 */
|
|
ret_code = 0;
|
|
|
|
#ifdef DEBUG
|
|
if ((nread < 0) && (read_errno != ERRNO_FOR_BLOCKED_IO))
|
|
perror("read() error in SerparRead()");
|
|
#endif
|
|
|
|
return ret_code;
|
|
}
|
|
|
|
/*
|
|
* Function: send_packet
|
|
* Purpose: Send a stream of bytes to Angel through the parallel port
|
|
*
|
|
* Algorithm: We need to present the data in a form that all boards can
|
|
* swallow. With the PID board, this is a problem: for reasons
|
|
* described in the driver (angel/pid/st16c552.c), data are
|
|
* sent a nybble at a time on D0-D2 and D4; D3 is wired to ACK,
|
|
* which generates an interrupt when it goes low. This routine
|
|
* fills in an array of nybbles, with ACK clear in all but the
|
|
* last one. If, for whatever reason, the write fails, then
|
|
* ACK is forced high (thereby enabling the next write a chance
|
|
* to be noticed when the falling edge of ACK generates an
|
|
* interrupt (hopefully).
|
|
*
|
|
* Params:
|
|
* Input: txstate Contains the packet to be sent
|
|
*
|
|
* Returns: Number of *complete* bytes written
|
|
*/
|
|
|
|
static int SerparWrite(DriverCall *dc)
|
|
{
|
|
te_status status;
|
|
int nwritten = 0;
|
|
static TxState txstate;
|
|
|
|
/*
|
|
* is this a new packet?
|
|
*/
|
|
if (dc->dc_context == NULL)
|
|
{
|
|
/*
|
|
* yes - initialise TxEngine
|
|
*/
|
|
Angel_TxEngineInit(&config, &dc->dc_packet, &txstate.state);
|
|
|
|
txstate.index = 0;
|
|
dc->dc_context = &txstate;
|
|
}
|
|
|
|
/*
|
|
* fill the buffer using the Tx Engine
|
|
*/
|
|
do
|
|
{
|
|
status = Angel_TxEngine(&dc->dc_packet, &txstate.state,
|
|
&txstate.writebuf[txstate.index]);
|
|
if (status != TS_IDLE) txstate.index++;
|
|
|
|
} while (status == TS_IN_PKT && txstate.index < MAXWRITESIZE);
|
|
|
|
#ifdef DO_TRACE
|
|
{
|
|
unsigned int i = 0;
|
|
|
|
while (i < txstate.index)
|
|
{
|
|
printf(">%02X ", txstate.writebuf[i]);
|
|
|
|
if (!(++i % 16))
|
|
putc('\n', stdout);
|
|
}
|
|
|
|
if (i % 16)
|
|
putc('\n', stdout);
|
|
}
|
|
#endif
|
|
|
|
/*
|
|
* the data are ready, all we need now is to send them out
|
|
* in a form that Angel can swallow.
|
|
*/
|
|
#ifdef COMPILING_ON_WINDOWS
|
|
if (WriteParallel(txstate.writebuf, txstate.index) == COM_OK)
|
|
{
|
|
nwritten = txstate.index;
|
|
if (pfnProgressCallback != NULL)
|
|
{
|
|
progressInfo.nWritten += nwritten;
|
|
(*pfnProgressCallback)(&progressInfo);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
MessageBox(GetFocus(), "Write error\n", "Angel", MB_OK | MB_ICONSTOP);
|
|
return -1; /* SJ - This really needs to return a value, which is picked up in */
|
|
/* DevSW_Read as meaning stop debugger but don't kill. */
|
|
}
|
|
#else
|
|
nwritten = Unix_WriteParallel(txstate.writebuf, txstate.index);
|
|
#endif
|
|
|
|
if (nwritten < 0) nwritten = 0;
|
|
|
|
#ifdef DO_TRACE
|
|
printf("SerparWrite: wrote %d out of %d bytes\n",
|
|
nwritten, txstate.index);
|
|
#endif
|
|
|
|
/*
|
|
* has the whole packet gone?
|
|
*/
|
|
if (nwritten == (int)txstate.index &&
|
|
(status == TS_DONE_PKT || status == TS_IDLE))
|
|
/*
|
|
* yes it has
|
|
*/
|
|
return 1;
|
|
else
|
|
{
|
|
/*
|
|
* if some data are left, shuffle them
|
|
* to the start of the buffer
|
|
*/
|
|
if (nwritten != (int)txstate.index && nwritten != 0)
|
|
{
|
|
txstate.index -= nwritten;
|
|
(void)memmove((char *) txstate.writebuf,
|
|
(char *) (txstate.writebuf + nwritten),
|
|
txstate.index);
|
|
}
|
|
else if (nwritten == (int)txstate.index)
|
|
txstate.index = 0;
|
|
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
static int serpar_reset(void)
|
|
{
|
|
#ifdef COMPILING_ON_WINDOWS
|
|
FlushParallel();
|
|
FlushSerial();
|
|
#else
|
|
Unix_ResetParallel();
|
|
Unix_ResetSerial();
|
|
#endif
|
|
|
|
return serpar_set_params(&serpar_defaults);
|
|
}
|
|
|
|
static int find_baud_rate(unsigned int *speed)
|
|
{
|
|
static struct
|
|
{
|
|
unsigned int baud;
|
|
int termiosValue;
|
|
} possibleBaudRates[] =
|
|
{
|
|
#if defined(__hpux)
|
|
{115200, _B115200}, {57600, _B57600},
|
|
#endif
|
|
#ifdef COMPILING_ON_WINDOWS
|
|
{38400, CBR_38400}, {19200, CBR_19200}, {9600, CBR_9600}, {0, 0}
|
|
#else
|
|
{38400, B38400}, {19200, B19200}, {9600, B9600}, {0, 0}
|
|
#endif
|
|
};
|
|
unsigned int i;
|
|
|
|
/* look for lower or matching -- will always terminate at 0 end marker */
|
|
for (i = 0; possibleBaudRates[i].baud > *speed; ++i)
|
|
/* do nothing */
|
|
;
|
|
|
|
if (possibleBaudRates[i].baud > 0)
|
|
*speed = possibleBaudRates[i].baud;
|
|
|
|
return possibleBaudRates[i].termiosValue;
|
|
}
|
|
|
|
static int serpar_set_params(const ParameterConfig *config)
|
|
{
|
|
unsigned int speed;
|
|
int termios_value;
|
|
|
|
#ifdef DEBUG
|
|
printf("serpar_set_params\n");
|
|
#endif
|
|
|
|
if (!Angel_FindParam(AP_BAUD_RATE, config, &speed))
|
|
{
|
|
#ifdef DEBUG
|
|
printf("speed not found in config\n");
|
|
#endif
|
|
return DE_OKAY;
|
|
}
|
|
|
|
termios_value = find_baud_rate(&speed);
|
|
if (termios_value == 0)
|
|
{
|
|
#ifdef DEBUG
|
|
printf("speed not valid: %u\n", speed);
|
|
#endif
|
|
return DE_OKAY;
|
|
}
|
|
|
|
#ifdef DEBUG
|
|
printf("setting speed to %u\n", speed);
|
|
#endif
|
|
|
|
#ifdef COMPILING_ON_WINDOWS
|
|
SetBaudRate((WORD)termios_value);
|
|
#else
|
|
Unix_SetSerialBaudRate(termios_value);
|
|
#endif
|
|
|
|
return DE_OKAY;
|
|
}
|
|
|
|
|
|
static int serpar_get_user_params(ParameterOptions **p_options)
|
|
{
|
|
#ifdef DEBUG
|
|
printf("serpar_get_user_params\n");
|
|
#endif
|
|
|
|
if (user_options_set)
|
|
{
|
|
*p_options = &user_options;
|
|
}
|
|
else
|
|
{
|
|
*p_options = NULL;
|
|
}
|
|
|
|
return DE_OKAY;
|
|
}
|
|
|
|
|
|
static int serial_get_default_params( const ParameterConfig **p_config )
|
|
{
|
|
#ifdef DEBUG
|
|
printf( "serial_get_default_params\n" );
|
|
#endif
|
|
|
|
*p_config = &serpar_defaults;
|
|
return DE_OKAY;
|
|
}
|
|
|
|
|
|
static int SerparIoctl(const int opcode, void *args)
|
|
{
|
|
int ret_code;
|
|
|
|
#ifdef DEBUG
|
|
printf("SerparIoctl: op %d arg %p\n", opcode, args ? args : "<NULL>");
|
|
#endif
|
|
|
|
switch (opcode)
|
|
{
|
|
case DC_RESET:
|
|
ret_code = serpar_reset();
|
|
break;
|
|
|
|
case DC_SET_PARAMS:
|
|
ret_code = serpar_set_params((const ParameterConfig *)args);
|
|
break;
|
|
|
|
case DC_GET_USER_PARAMS:
|
|
ret_code = serpar_get_user_params((ParameterOptions **)args);
|
|
break;
|
|
|
|
case DC_GET_DEFAULT_PARAMS:
|
|
ret_code =
|
|
serial_get_default_params((const ParameterConfig **)args);
|
|
break;
|
|
|
|
default:
|
|
ret_code = DE_BAD_OP;
|
|
break;
|
|
}
|
|
|
|
return ret_code;
|
|
}
|
|
|
|
DeviceDescr angel_SerparDevice =
|
|
{
|
|
"SERPAR",
|
|
SerparOpen,
|
|
SerparMatch,
|
|
SerparClose,
|
|
SerparRead,
|
|
SerparWrite,
|
|
SerparIoctl
|
|
};
|
|
|
|
/* EOF serpardr.c */
|