URL https://opencores.org/ocsvn/or1k/or1k/trunk

Subversion Repositories or1k

[/] [or1k/] [trunk/] [gdb-5.0/] [gdb/] [rdi-share/] [serpardr.c] - Blame information for rev 1774

Go to most recent revision | Details | Compare with Previous | View Log


/*
 * 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: 1.1.1.1 $
 *     $Date: 2001-05-18 11:16:46 $
 *
 *
 * 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(__CYGWIN32__)
    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 */

Browse

Tools

Subversion Repositories or1k

[/] [or1k/] [trunk/] [gdb-5.0/] [gdb/] [rdi-share/] [serpardr.c] - Blame information for rev 1774

Line No.	Rev	Author	Line
1	106	markom	`/*`
2			`* Copyright (C) 1995 Advanced RISC Machines Limited. All rights reserved.`
3			`*`
4			`* This software may be freely used, copied, modified, and distributed`
5			`* provided that the above copyright notice is preserved in all copies of the`
6			`* software.`
7			`*/`
8
9			`/* --C--`
10			`*`
11			`* $Revision: 1.1.1.1 $`
12			`* $Date: 2001-05-18 11:16:46 $`
13			`*`
14			`*`
15			`* serpardv.c - Serial/Parallel Driver for Angel.`
16			`*/`
17			`#include <stdio.h>`
18			`#include <stdlib.h>`
19			`#include <string.h>`
20
21			`#include "crc.h"`
22			`#include "devices.h"`
23			`#include "buffers.h"`
24			`#include "rxtx.h"`
25			`#include "hostchan.h"`
26			`#include "params.h"`
27			`#include "logging.h"`
28			`#include "hsys.h"`
29
30			`#ifdef COMPILING_ON_WINDOWS`
31			`# undef ERROR`
32			`# undef IGNORE`
33			`# include <windows.h>`
34			`# include "angeldll.h"`
35			`# include "comb_api.h"`
36			`#else`
37			`# ifdef __hpux`
38			`# define _TERMIOS_INCLUDED`
39			`# include <sys/termio.h>`
40			`# undef _TERMIOS_INCLUDED`
41			`# else`
42			`# include <termios.h>`
43			`# endif`
44			`# include "unixcomm.h"`
45			`#endif`
46
47			`#ifndef UNUSED`
48			`# define UNUSED(x) (x = x) /* Silence compiler warnings */`
49			`#endif`
50
51			`#define MAXREADSIZE 512`
52			`#define MAXWRITESIZE 512`
53
54			`#define SERPAR_FC_SET ((1 << serial_XON) \| (1 << serial_XOFF))`
55			`#define SERPAR_CTL_SET ((1 << serial_STX) \| (1 << serial_ETX) \| \`
56			`(1 << serial_ESC))`
57			`#define SERPAR_ESC_SET (SERPAR_FC_SET \| SERPAR_CTL_SET)`
58
59			`static const struct re_config config = {`
60			`serial_STX, serial_ETX, serial_ESC, /* self-explanatory? */`
61			`SERPAR_FC_SET, /* set of flow-control characters */`
62			`SERPAR_ESC_SET, /* set of characters to be escaped */`
63			`NULL, /* serial_flow_control */`
64			`NULL, /* what to do with FC chars */`
65			`angel_DD_RxEng_BufferAlloc, NULL /* how to get a buffer */`
66			`};`
67
68			`static struct re_state rxstate;`
69
70			`/*`
71			`* structure used for manipulating transmit data`
72			`*/`
73			`typedef struct TxState`
74			`{`
75			`struct te_state state;`
76			`unsigned int index;`
77			`unsigned char writebuf[MAXWRITESIZE];`
78			`} TxState;`
79
80			`/*`
81			`* The set of parameter options supported by the device`
82			`*/`
83			`static unsigned int baud_options[] =`
84			`{`
85			`#ifdef __hpux`
86			`115200, 57600,`
87			`#endif`
88			`38400, 19200, 9600`
89			`};`
90
91			`static ParameterList param_list[] =`
92			`{`
93			`{`
94			`AP_BAUD_RATE,`
95			`sizeof(baud_options) / sizeof(unsigned int),`
96			`baud_options`
97			`}`
98			`};`
99
100			`static const ParameterOptions serpar_options =`
101			`{`
102			`sizeof(param_list) / sizeof(ParameterList),`
103			`param_list`
104			`};`
105
106			`/*`
107			`* The default parameter config for the device`
108			`*/`
109			`static Parameter param_default[] =`
110			`{`
111			`{ AP_BAUD_RATE, 9600 }`
112			`};`
113
114			`static const ParameterConfig serpar_defaults =`
115			`{`
116			`sizeof(param_default)/sizeof(Parameter),`
117			`param_default`
118			`};`
119
120			`/*`
121			`* The user-modified options for the device`
122			`*/`
123			`static unsigned int user_baud_options[sizeof(baud_options) /`
124			`sizeof(unsigned int)];`
125
126			`static ParameterList param_user_list[] =`
127			`{`
128			`{`
129			`AP_BAUD_RATE,`
130			`sizeof(user_baud_options) / sizeof(unsigned),`
131			`user_baud_options`
132			`}`
133			`};`
134
135			`static ParameterOptions user_options =`
136			`{`
137			`sizeof(param_user_list) / sizeof(ParameterList),`
138			`param_user_list`
139			`};`
140
141			`static bool user_options_set;`
142
143			`/* forward declarations */`
144			`static int serpar_reset(void);`
145			`static int serpar_set_params(const ParameterConfig *config);`
146			`static int SerparMatch(const char name, const char arg);`
147
148			`static void process_baud_rate(unsigned int target_baud_rate)`
149			`{`
150			`const ParameterList *full_list;`
151			`ParameterList *user_list;`
152
153			`/* create subset of full options */`
154			`full_list = Angel_FindParamList(&serpar_options, AP_BAUD_RATE);`
155			`user_list = Angel_FindParamList(&user_options, AP_BAUD_RATE);`
156
157			`if (full_list != NULL && user_list != NULL)`
158			`{`
159			`unsigned int i, j;`
160			`unsigned int def_baud = 0;`
161
162			`/* find lower or equal to */`
163			`for (i = 0; i < full_list->num_options; ++i)`
164			`if (target_baud_rate >= full_list->option[i])`
165			`{`
166			`/* copy remaining */`
167			`for (j = 0; j < (full_list->num_options - i); ++j)`
168			`user_list->option[j] = full_list->option[i+j];`
169			`user_list->num_options = j;`
170
171			`/* check this is not the default */`
172			`Angel_FindParam(AP_BAUD_RATE, &serpar_defaults, &def_baud);`
173			`if ((j == 1) && (user_list->option[0] == def_baud))`
174			`{`
175			`#ifdef DEBUG`
176			`printf("user selected default\n");`
177			`#endif`
178			`}`
179			`else`
180			`{`
181			`user_options_set = TRUE;`
182			`#ifdef DEBUG`
183			`printf("user options are: ");`
184			`for (j = 0; j < user_list->num_options; ++j)`
185			`printf("%u ", user_list->option[j]);`
186			`printf("\n");`
187			`#endif`
188			`}`
189
190			`break; /* out of i loop */`
191			`}`
192
193			`#ifdef DEBUG`
194			`if (i >= full_list->num_options)`
195			`printf("couldn't match baud rate %u\n", target_baud_rate);`
196			`#endif`
197			`}`
198			`#ifdef DEBUG`
199			`else`
200			`printf("failed to find lists\n");`
201			`#endif`
202			`}`
203
204			`static int SerparOpen(const char name, const char arg)`
205			`{`
206			`char *sername = NULL;`
207			`char *parname = NULL;`
208
209			`#ifdef DEBUG`
210			`printf("SerparOpen: name %s arg %s\n", name, arg ? arg : "<NULL>");`
211			`#endif`
212
213			`#ifdef COMPILING_ON_WINDOWS`
214			`if (IsOpenSerial() \|\| IsOpenParallel()) return -1;`
215			`#else`
216			`if (Unix_IsSerialInUse() \|\| Unix_IsParallelInUse()) return -1;`
217			`#endif`
218
219			`#ifdef COMPILING_ON_WINDOWS`
220			`if (SerparMatch(name, arg) == -1)`
221			`return -1;`
222			`#else`
223			`Unix_IsValidParallelDevice(name,&sername,&parname);`
224			`# ifdef DEBUG`
225			`printf("translated %s to serial %s and parallel %s\n",`
226			`name==0 ? "NULL" : name,`
227			`sername==0 ? "NULL" : sername,`
228			`parname==0 ? "NULL" : parname);`
229			`# endif`
230			`if (sername==NULL \|\| parname==NULL) return -1;`
231			`#endif`
232
233			`user_options_set = FALSE;`
234
235			`/* interpret and store the arguments */`
236			`if (arg != NULL)`
237			`{`
238			`unsigned int target_baud_rate;`
239
240			`target_baud_rate = (unsigned int)strtoul(arg, NULL, 10);`
241
242			`if (target_baud_rate > 0)`
243			`{`
244			`#ifdef DEBUG`
245			`printf("user selected baud rate %u\n", target_baud_rate);`
246			`#endif`
247			`process_baud_rate(target_baud_rate);`
248			`}`
249			`#ifdef DEBUG`
250			`else`
251			`printf("could not understand baud rate %s\n", arg);`
252			`#endif`
253			`}`
254
255			`#ifdef COMPILING_ON_WINDOWS`
256			`{`
257			`/*`
258			`* The serial port number is in name[0] followed by`
259			`* the parallel port number in name[1]`
260			`*/`
261
262			`int sport = name[0] - '0';`
263			`int pport = name[1] - '0';`
264
265			`if (OpenParallel(pport) != COM_OK)`
266			`return -1;`
267
268			`if (OpenSerial(sport, FALSE) != COM_OK)`
269			`{`
270			`CloseParallel();`
271			`return -1;`
272			`}`
273			`}`
274			`#else`
275			`Unix_OpenParallel(parname);`
276			`Unix_OpenSerial(sername);`
277			`#endif`
278
279			`serpar_reset();`
280
281			`#if defined(__unix) \|\| defined(__CYGWIN32__)`
282			`Unix_ioctlNonBlocking();`
283			`#endif`
284
285			`Angel_RxEngineInit(&config, &rxstate);`
286
287			`return 0;`
288			`}`
289
290			`#ifdef COMPILING_ON_WINDOWS`
291			`static int SerparMatch(const char name, const char arg)`
292			`{`
293			`char sername[2];`
294			`char parname[2];`
295
296			`UNUSED(arg);`
297
298			`sername[0] = name[0];`
299			`parname[0] = name[1];`
300			`sername[1] = parname[1] = 0;`
301
302			`if (IsValidDevice(sername) == COM_DEVICENOTVALID \|\|`
303			`IsValidDevice(parname) == COM_DEVICENOTVALID)`
304			`return -1;`
305			`else`
306			`return 0;`
307			`}`
308			`#else`
309			`static int SerparMatch(const char portstring, const char arg)`
310			`{`
311			`char sername=NULL, parname=NULL;`
312			`UNUSED(arg);`
313
314			`Unix_IsValidParallelDevice(portstring,&sername,&parname);`
315
316			`/* Match failed if either sername or parname are still NULL */`
317			`if (sername==NULL \|\| parname==NULL) return -1;`
318			`return 0;`
319			`}`
320			`#endif`
321
322			`static void SerparClose(void)`
323			`{`
324			`#ifdef COMPILING_ON_WINDOWS`
325			`CloseParallel();`
326			`CloseSerial();`
327			`#else`
328			`Unix_CloseParallel();`
329			`Unix_CloseSerial();`
330			`#endif`
331			`}`
332
333			`static int SerparRead(DriverCall *dc, bool block)`
334			`{`
335			`static unsigned char readbuf[MAXREADSIZE];`
336			`static int rbindex = 0;`
337
338			`int nread;`
339			`int read_errno;`
340			`int c = 0;`
341			`re_status restatus;`
342			`int ret_code = -1; /* assume bad packet or error */`
343
344			`/*`
345			`* we must not overflow buffer, and must start after`
346			`* the existing data`
347			`*/`
348			`#ifdef COMPILING_ON_WINDOWS`
349			`{`
350			`BOOL dummy = FALSE;`
351			`nread = BytesInRXBufferSerial();`
352
353			`if (nread > MAXREADSIZE - rbindex)`
354			`nread = MAXREADSIZE - rbindex;`
355			`read_errno = ReadSerial(readbuf+rbindex, nread, &dummy);`
356			`if (pfnProgressCallback != NULL && read_errno == COM_OK)`
357			`{`
358			`progressInfo.nRead += nread;`
359			`(*pfnProgressCallback)(&progressInfo);`
360			`}`
361			`}`
362			`#else`
363			`nread = Unix_ReadSerial(readbuf+rbindex, MAXREADSIZE-rbindex, block);`
364			`read_errno = errno;`
365			`#endif`
366
367			`if ((nread > 0) \|\| (rbindex > 0))`
368			`{`
369			`#ifdef DO_TRACE`
370			`printf("[%d@%d] ", nread, rbindex);`
371			`#endif`
372
373			`if (nread > 0)`
374			`rbindex = rbindex + nread;`
375
376			`do`
377			`{`
378			`restatus = Angel_RxEngine(readbuf[c], &(dc->dc_packet), &rxstate);`
379
380			`#ifdef DO_TRACE`
381			`printf("<%02X ",readbuf[c]);`
382			`#endif`
383			`c++;`
384			`} while (c < rbindex &&`
385			`((restatus == RS_IN_PKT) \|\| (restatus == RS_WAIT_PKT)));`
386
387			`#ifdef DO_TRACE`
388			`printf("\n");`
389			`#endif`
390
391			`switch(restatus)`
392			`{`
393			`case RS_GOOD_PKT:`
394			`ret_code = 1;`
395			`/* fall through to: */`
396
397			`case RS_BAD_PKT:`
398			`/*`
399			`* We now need to shuffle any left over data down to the`
400			`* beginning of our private buffer ready to be used`
401			`*for the next packet`
402			`*/`
403			`#ifdef DO_TRACE`
404			`printf("SerparRead() processed %d, moving down %d\n",`
405			`c, rbindex - c);`
406			`#endif`
407
408			`if (c != rbindex)`
409			`memmove((char ) readbuf, (char ) (readbuf + c), rbindex - c);`
410
411			`rbindex -= c;`
412
413			`break;`
414
415			`case RS_IN_PKT:`
416			`case RS_WAIT_PKT:`
417			`rbindex = 0; /* will have processed all we had */`
418			`ret_code = 0;`
419			`break;`
420
421			`default:`
422			`#ifdef DEBUG`
423			`printf("Bad re_status in SerparRead()\n");`
424			`#endif`
425			`break;`
426			`}`
427			`}`
428			`else if (nread == 0)`
429			`/* nothing to read */`
430			`ret_code = 0;`
431			`else if (read_errno == ERRNO_FOR_BLOCKED_IO) /* nread < 0 */`
432			`ret_code = 0;`
433
434			`#ifdef DEBUG`
435			`if ((nread < 0) && (read_errno != ERRNO_FOR_BLOCKED_IO))`
436			`perror("read() error in SerparRead()");`
437			`#endif`
438
439			`return ret_code;`
440			`}`
441
442			`/*`
443			`* Function: send_packet`
444			`* Purpose: Send a stream of bytes to Angel through the parallel port`
445			`*`
446			`* Algorithm: We need to present the data in a form that all boards can`
447			`* swallow. With the PID board, this is a problem: for reasons`
448			`* described in the driver (angel/pid/st16c552.c), data are`
449			`* sent a nybble at a time on D0-D2 and D4; D3 is wired to ACK,`
450			`* which generates an interrupt when it goes low. This routine`
451			`* fills in an array of nybbles, with ACK clear in all but the`
452			`* last one. If, for whatever reason, the write fails, then`
453			`* ACK is forced high (thereby enabling the next write a chance`
454			`* to be noticed when the falling edge of ACK generates an`
455			`* interrupt (hopefully).`
456			`*`
457			`* Params:`
458			`* Input: txstate Contains the packet to be sent`
459			`*`
460			`* Returns: Number of complete bytes written`
461			`*/`
462
463			`static int SerparWrite(DriverCall *dc)`
464			`{`
465			`te_status status;`
466			`int nwritten = 0;`
467			`static TxState txstate;`
468
469			`/*`
470			`* is this a new packet?`
471			`*/`
472			`if (dc->dc_context == NULL)`
473			`{`
474			`/*`
475			`* yes - initialise TxEngine`
476			`*/`
477			`Angel_TxEngineInit(&config, &dc->dc_packet, &txstate.state);`
478
479			`txstate.index = 0;`
480			`dc->dc_context = &txstate;`
481			`}`
482
483			`/*`
484			`* fill the buffer using the Tx Engine`
485			`*/`
486			`do`
487			`{`
488			`status = Angel_TxEngine(&dc->dc_packet, &txstate.state,`
489			`&txstate.writebuf[txstate.index]);`
490			`if (status != TS_IDLE) txstate.index++;`
491
492			`} while (status == TS_IN_PKT && txstate.index < MAXWRITESIZE);`
493
494			`#ifdef DO_TRACE`
495			`{`
496			`unsigned int i = 0;`
497
498			`while (i < txstate.index)`
499			`{`
500			`printf(">%02X ", txstate.writebuf[i]);`
501
502			`if (!(++i % 16))`
503			`putc('\n', stdout);`
504			`}`
505
506			`if (i % 16)`
507			`putc('\n', stdout);`
508			`}`
509			`#endif`
510
511			`/*`
512			`* the data are ready, all we need now is to send them out`
513			`* in a form that Angel can swallow.`
514			`*/`
515			`#ifdef COMPILING_ON_WINDOWS`
516			`if (WriteParallel(txstate.writebuf, txstate.index) == COM_OK)`
517			`{`
518			`nwritten = txstate.index;`
519			`if (pfnProgressCallback != NULL)`
520			`{`
521			`progressInfo.nWritten += nwritten;`
522			`(*pfnProgressCallback)(&progressInfo);`
523			`}`
524			`}`
525			`else`
526			`{`
527			`MessageBox(GetFocus(), "Write error\n", "Angel", MB_OK \| MB_ICONSTOP);`
528			`return -1; /* SJ - This really needs to return a value, which is picked up in */`
529			`/* DevSW_Read as meaning stop debugger but don't kill. */`
530			`}`
531			`#else`
532			`nwritten = Unix_WriteParallel(txstate.writebuf, txstate.index);`
533			`#endif`
534
535			`if (nwritten < 0) nwritten = 0;`
536
537			`#ifdef DO_TRACE`
538			`printf("SerparWrite: wrote %d out of %d bytes\n",`
539			`nwritten, txstate.index);`
540			`#endif`
541
542			`/*`
543			`* has the whole packet gone?`
544			`*/`
545			`if (nwritten == (int)txstate.index &&`
546			`(status == TS_DONE_PKT \|\| status == TS_IDLE))`
547			`/*`
548			`* yes it has`
549			`*/`
550			`return 1;`
551			`else`
552			`{`
553			`/*`
554			`* if some data are left, shuffle them`
555			`* to the start of the buffer`
556			`*/`
557			`if (nwritten != (int)txstate.index && nwritten != 0)`
558			`{`
559			`txstate.index -= nwritten;`
560			`(void)memmove((char *) txstate.writebuf,`
561			`(char *) (txstate.writebuf + nwritten),`
562			`txstate.index);`
563			`}`
564			`else if (nwritten == (int)txstate.index)`
565			`txstate.index = 0;`
566
567			`return 0;`
568			`}`
569			`}`
570
571			`static int serpar_reset(void)`
572			`{`
573			`#ifdef COMPILING_ON_WINDOWS`
574			`FlushParallel();`
575			`FlushSerial();`
576			`#else`
577			`Unix_ResetParallel();`
578			`Unix_ResetSerial();`
579			`#endif`
580
581			`return serpar_set_params(&serpar_defaults);`
582			`}`
583
584			`static int find_baud_rate(unsigned int *speed)`
585			`{`
586			`static struct`
587			`{`
588			`unsigned int baud;`
589			`int termiosValue;`
590			`} possibleBaudRates[] =`
591			`{`
592			`#if defined(__hpux)`
593			`{115200, _B115200}, {57600, _B57600},`
594			`#endif`
595			`#ifdef COMPILING_ON_WINDOWS`
596			`{38400, CBR_38400}, {19200, CBR_19200}, {9600, CBR_9600}, {0, 0}`
597			`#else`
598			`{38400, B38400}, {19200, B19200}, {9600, B9600}, {0, 0}`
599			`#endif`
600			`};`
601			`unsigned int i;`
602
603			`/* look for lower or matching -- will always terminate at 0 end marker */`
604			`for (i = 0; possibleBaudRates[i].baud > *speed; ++i)`
605			`/* do nothing */`
606			`;`
607
608			`if (possibleBaudRates[i].baud > 0)`
609			`*speed = possibleBaudRates[i].baud;`
610
611			`return possibleBaudRates[i].termiosValue;`
612			`}`
613
614			`static int serpar_set_params(const ParameterConfig *config)`
615			`{`
616			`unsigned int speed;`
617			`int termios_value;`
618
619			`#ifdef DEBUG`
620			`printf("serpar_set_params\n");`
621			`#endif`
622
623			`if (!Angel_FindParam(AP_BAUD_RATE, config, &speed))`
624			`{`
625			`#ifdef DEBUG`
626			`printf("speed not found in config\n");`
627			`#endif`
628			`return DE_OKAY;`
629			`}`
630
631			`termios_value = find_baud_rate(&speed);`
632			`if (termios_value == 0)`
633			`{`
634			`#ifdef DEBUG`
635			`printf("speed not valid: %u\n", speed);`
636			`#endif`
637			`return DE_OKAY;`
638			`}`
639
640			`#ifdef DEBUG`
641			`printf("setting speed to %u\n", speed);`
642			`#endif`
643
644			`#ifdef COMPILING_ON_WINDOWS`
645			`SetBaudRate((WORD)termios_value);`
646			`#else`
647			`Unix_SetSerialBaudRate(termios_value);`
648			`#endif`
649
650			`return DE_OKAY;`
651			`}`
652
653
654			`static int serpar_get_user_params(ParameterOptions **p_options)`
655			`{`
656			`#ifdef DEBUG`
657			`printf("serpar_get_user_params\n");`
658			`#endif`
659
660			`if (user_options_set)`
661			`{`
662			`*p_options = &user_options;`
663			`}`
664			`else`
665			`{`
666			`*p_options = NULL;`
667			`}`
668
669			`return DE_OKAY;`
670			`}`
671
672
673			`static int serial_get_default_params( const ParameterConfig **p_config )`
674			`{`
675			`#ifdef DEBUG`
676			`printf( "serial_get_default_params\n" );`
677			`#endif`
678
679			`*p_config = &serpar_defaults;`
680			`return DE_OKAY;`
681			`}`
682
683
684			`static int SerparIoctl(const int opcode, void *args)`
685			`{`
686			`int ret_code;`
687
688			`#ifdef DEBUG`
689			`printf("SerparIoctl: op %d arg %p\n", opcode, args ? args : "<NULL>");`
690			`#endif`
691
692			`switch (opcode)`
693			`{`
694			`case DC_RESET:`
695			`ret_code = serpar_reset();`
696			`break;`
697
698			`case DC_SET_PARAMS:`
699			`ret_code = serpar_set_params((const ParameterConfig *)args);`
700			`break;`
701
702			`case DC_GET_USER_PARAMS:`
703			`ret_code = serpar_get_user_params((ParameterOptions **)args);`
704			`break;`
705
706			`case DC_GET_DEFAULT_PARAMS:`
707			`ret_code =`
708			`serial_get_default_params((const ParameterConfig **)args);`
709			`break;`
710
711			`default:`
712			`ret_code = DE_BAD_OP;`
713			`break;`
714			`}`
715
716			`return ret_code;`
717			`}`
718
719			`DeviceDescr angel_SerparDevice =`
720			`{`
721			`"SERPAR",`
722			`SerparOpen,`
723			`SerparMatch,`
724			`SerparClose,`
725			`SerparRead,`
726			`SerparWrite,`
727			`SerparIoctl`
728			`};`
729
730			`/* EOF serpardr.c */`