| /* |
| * 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 */ |
