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

Subversion Repositories or1k

[/] [or1k/] [branches/] [oc/] [gdb-5.0/] [gdb/] [rdi-share/] [serdrv.c] - Blame information for rev 106

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:45 $
 *
 *
 * serdrv.c - Synchronous Serial Driver for Angel.
 *            This is nice and simple just to get something going.
 */
 
#ifdef __hpux
#  define _POSIX_SOURCE 1
#endif
 
#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"
 
extern int baud_rate;   /* From gdb/top.c */
 
#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 SERIAL_FC_SET  ((1<<serial_XON)|(1<<serial_XOFF))
#define SERIAL_CTL_SET ((1<<serial_STX)|(1<<serial_ETX)|(1<<serial_ESC))
#define SERIAL_ESC_SET (SERIAL_FC_SET|SERIAL_CTL_SET)
 
static const struct re_config config = {
    serial_STX, serial_ETX, serial_ESC, /* self-explanatory?               */
    SERIAL_FC_SET,                      /* set of flow-control characters  */
    SERIAL_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;
 
typedef struct writestate {
  unsigned int wbindex;
  /*  static te_status testatus;*/
  unsigned char writebuf[MAXWRITESIZE];
  struct te_state txstate;
} writestate;
 
static struct writestate wstate;
 
/*
 * The set of parameter options supported by the device
 */
static unsigned int baud_options[] = {
#if defined(B115200) || defined(__hpux)
    115200,
#endif
#if defined(B57600) || defined(__hpux)
    57600,
#endif
    38400, 19200, 9600
};
 
static ParameterList param_list[] = {
    { AP_BAUD_RATE,
      sizeof(baud_options)/sizeof(unsigned int),
      baud_options }
};
 
static const ParameterOptions serial_options = {
    sizeof(param_list)/sizeof(ParameterList), param_list };
 
/*
 * The default parameter config for the device
 */
static Parameter param_default[] = {
    { AP_BAUD_RATE, 9600 }
};
 
static ParameterConfig serial_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)];
 
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 serial_reset( void );
static int serial_set_params( const ParameterConfig *config );
static int SerialMatch(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( &serial_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, &serial_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 SerialOpen(const char *name, const char *arg)
{
    const char *port_name = name;
 
#ifdef DEBUG
    printf("SerialOpen: name %s arg %s\n", name, arg ? arg : "<NULL>");
#endif
 
#ifdef COMPILING_ON_WINDOWS
    if (IsOpenSerial()) return -1;
#else
    if (Unix_IsSerialInUse()) return -1;
#endif
 
#ifdef COMPILING_ON_WINDOWS
    if (SerialMatch(name, arg) != adp_ok)
        return adp_failed;
#else
    port_name = Unix_MatchValidSerialDevice(port_name);
# ifdef DEBUG
    printf("translated port to %s\n", port_name == 0 ? "NULL" : port_name);
# endif
    if (port_name == 0) return adp_failed;
#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
    }
    else if (baud_rate > 0)
    {
      /* If the user specified a baud rate on the command line "-b" or via
         the "set remotebaud" command then try to use that one */
      process_baud_rate( baud_rate );
    }
 
#ifdef COMPILING_ON_WINDOWS
    {
        int port = IsValidDevice(name);
        if (OpenSerial(port, FALSE) != COM_OK)
            return -1;
    }
#else
    if (Unix_OpenSerial(port_name) < 0)
      return -1;
#endif
 
    serial_reset();
 
#if defined(__unix) || defined(__CYGWIN32__)
    Unix_ioctlNonBlocking();
#endif
 
    Angel_RxEngineInit(&config, &rxstate);
    /*
     * DANGER!: passing in NULL as the packet is ok for now as it is just
     * IGNOREd but this may well change
     */
    Angel_TxEngineInit(&config, NULL, &wstate.txstate);
    return 0;
}
 
static int SerialMatch(const char *name, const char *arg)
{
    UNUSED(arg);
#ifdef COMPILING_ON_WINDOWS
    if (IsValidDevice(name) == COM_DEVICENOTVALID)
        return -1;
    else
        return 0;
#else
    return Unix_MatchValidSerialDevice(name) == 0 ? -1 : 0;
#endif
}
 
static void SerialClose(void)
{
#ifdef DO_TRACE
    printf("SerialClose()\n");
#endif
 
#ifdef COMPILING_ON_WINDOWS
    CloseSerial();
#else
    Unix_CloseSerial();
#endif
}
 
static int SerialRead(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 */
 
  /* 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;
 
    if ((read_errno = ReadSerial(readbuf+rbindex, nread, &dummy)) == COM_READFAIL)
    {
        MessageBox(GetFocus(), "Read 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 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]);
      if (!(++c % 16))
          printf("\n");
#else
      c++;
#endif
    } while (c<rbindex &&
             ((restatus == RS_IN_PKT) || (restatus == RS_WAIT_PKT)));
 
#ifdef DO_TRACE
   if (c % 16)
        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("SerialRead() 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 serialRead()\n");
#endif
        break;
    }
  } else if (nread == 0)
    ret_code = 0;               /* nothing to read */
  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 serialRead()");
#endif
 
  return ret_code;
}
 
 
static int SerialWrite(DriverCall *dc) {
  int nwritten = 0;
  te_status testatus = TS_IN_PKT;
 
  if (dc->dc_context == NULL) {
    Angel_TxEngineInit(&config, &(dc->dc_packet), &(wstate.txstate));
    wstate.wbindex = 0;
    dc->dc_context = &wstate;
  }
 
  while ((testatus == TS_IN_PKT) && (wstate.wbindex < MAXWRITESIZE))
  {
    /* send the raw data through the tx engine to escape and encapsulate */
    testatus = Angel_TxEngine(&(dc->dc_packet), &(wstate.txstate),
                              &(wstate.writebuf)[wstate.wbindex]);
    if (testatus != TS_IDLE) wstate.wbindex++;
  }
 
  if (testatus == TS_IDLE) {
#ifdef DEBUG
    printf("SerialWrite: testatus is TS_IDLE during preprocessing\n");
#endif
  }
 
#ifdef DO_TRACE
  {
    int i = 0;
 
    while (i<wstate.wbindex)
    {
        printf(">%02X ",wstate.writebuf[i]);
 
        if (!(++i % 16))
            printf("\n");
    }
    if (i % 16)
        printf("\n");
  }
#endif
 
#ifdef COMPILING_ON_WINDOWS
  if (WriteSerial(wstate.writebuf, wstate.wbindex) == COM_OK)
  {
    nwritten = wstate.wbindex;
    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_WriteSerial(wstate.writebuf, wstate.wbindex);
 
  if (nwritten < 0) {
    nwritten=0;
  }
#endif
 
#ifdef DEBUG
  if (nwritten > 0)
    printf("Wrote %#04x bytes\n", nwritten);
#endif
 
  if ((unsigned) nwritten == wstate.wbindex &&
      (testatus == TS_DONE_PKT || testatus == TS_IDLE)) {
 
    /* finished sending the packet */
 
#ifdef DEBUG
    printf("SerialWrite: calling Angel_TxEngineInit after sending packet (len=%i)\n",wstate.wbindex);
#endif
    testatus = TS_IN_PKT;
    wstate.wbindex = 0;
    return 1;
  }
  else {
#ifdef DEBUG
    printf("SerialWrite: Wrote part of packet wbindex=%i, nwritten=%i\n",
           wstate.wbindex, nwritten);
#endif
 
    /*
     *  still some data left to send shuffle whats left down and reset
     * the ptr
     */
    memmove((char *) wstate.writebuf, (char *) (wstate.writebuf+nwritten),
            wstate.wbindex-nwritten);
    wstate.wbindex -= nwritten;
    return 0;
  }
  return -1;
}
 
 
static int serial_reset( void )
{
#ifdef DEBUG
    printf( "serial_reset\n" );
#endif
 
#ifdef COMPILING_ON_WINDOWS
    FlushSerial();
#else
    Unix_ResetSerial();
#endif
 
    return serial_set_params( &serial_defaults );
}
 
 
static int find_baud_rate( unsigned int *speed )
{
    static struct {
          unsigned int baud;
          int termiosValue;
    } possibleBaudRates[] = {
#if defined(__hpux)
        {115200,_B115200}, {57600,_B57600},
#else
#ifdef B115200
        {115200,B115200},
#endif
#ifdef B57600
        {57600,B57600},
#endif
#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 serial_set_params( const ParameterConfig *config )
{
    unsigned int speed;
    int termios_value;
 
#ifdef DEBUG
    printf( "serial_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 serial_get_user_params( ParameterOptions **p_options )
{
#ifdef DEBUG
    printf( "serial_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( ParameterConfig **p_config )
{
#ifdef DEBUG
    printf( "serial_get_default_params\n" );
#endif
 
    *p_config = (ParameterConfig *) &serial_defaults;
    return DE_OKAY;
}
 
 
static int SerialIoctl(const int opcode, void *args) {
 
    int ret_code;
 
#ifdef DEBUG
    printf( "SerialIoctl: op %d arg %p\n", opcode, args ? args : "<NULL>");
#endif
 
    switch (opcode)
    {
       case DC_RESET:
           ret_code = serial_reset();
           break;
 
       case DC_SET_PARAMS:
           ret_code = serial_set_params((const ParameterConfig *)args);
           break;
 
       case DC_GET_USER_PARAMS:
           ret_code = serial_get_user_params((ParameterOptions **)args);
           break;
 
       case DC_GET_DEFAULT_PARAMS:
           ret_code = serial_get_default_params((ParameterConfig **)args);
           break;
 
       default:
           ret_code = DE_BAD_OP;
           break;
    }
 
  return ret_code;
}
 
DeviceDescr angel_SerialDevice = {
    "SERIAL",
    SerialOpen,
    SerialMatch,
    SerialClose,
    SerialRead,
    SerialWrite,
    SerialIoctl
};

Browse

Tools

Subversion Repositories or1k

[/] [or1k/] [branches/] [oc/] [gdb-5.0/] [gdb/] [rdi-share/] [serdrv.c] - Blame information for rev 106

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:45 $`
13			`*`
14			`*`
15			`* serdrv.c - Synchronous Serial Driver for Angel.`
16			`* This is nice and simple just to get something going.`
17			`*/`
18
19			`#ifdef __hpux`
20			`# define _POSIX_SOURCE 1`
21			`#endif`
22
23			`#include <stdio.h>`
24			`#include <stdlib.h>`
25			`#include <string.h>`
26
27			`#include "crc.h"`
28			`#include "devices.h"`
29			`#include "buffers.h"`
30			`#include "rxtx.h"`
31			`#include "hostchan.h"`
32			`#include "params.h"`
33			`#include "logging.h"`
34
35			`extern int baud_rate; /* From gdb/top.c */`
36
37			`#ifdef COMPILING_ON_WINDOWS`
38			`# undef ERROR`
39			`# undef IGNORE`
40			`# include <windows.h>`
41			`# include "angeldll.h"`
42			`# include "comb_api.h"`
43			`#else`
44			`# ifdef __hpux`
45			`# define _TERMIOS_INCLUDED`
46			`# include <sys/termio.h>`
47			`# undef _TERMIOS_INCLUDED`
48			`# else`
49			`# include <termios.h>`
50			`# endif`
51			`# include "unixcomm.h"`
52			`#endif`
53
54			`#ifndef UNUSED`
55			`# define UNUSED(x) (x = x) /* Silence compiler warnings */`
56			`#endif`
57
58			`#define MAXREADSIZE 512`
59			`#define MAXWRITESIZE 512`
60
61			`#define SERIAL_FC_SET ((1<<serial_XON)\|(1<<serial_XOFF))`
62			`#define SERIAL_CTL_SET ((1<<serial_STX)\|(1<<serial_ETX)\|(1<<serial_ESC))`
63			`#define SERIAL_ESC_SET (SERIAL_FC_SET\|SERIAL_CTL_SET)`
64
65			`static const struct re_config config = {`
66			`serial_STX, serial_ETX, serial_ESC, /* self-explanatory? */`
67			`SERIAL_FC_SET, /* set of flow-control characters */`
68			`SERIAL_ESC_SET, /* set of characters to be escaped */`
69			`NULL /* serial_flow_control /, NULL , / what to do with FC chars */`
70			`angel_DD_RxEng_BufferAlloc, NULL /* how to get a buffer */`
71			`};`
72
73			`static struct re_state rxstate;`
74
75			`typedef struct writestate {`
76			`unsigned int wbindex;`
77			`/* static te_status testatus;*/`
78			`unsigned char writebuf[MAXWRITESIZE];`
79			`struct te_state txstate;`
80			`} writestate;`
81
82			`static struct writestate wstate;`
83
84			`/*`
85			`* The set of parameter options supported by the device`
86			`*/`
87			`static unsigned int baud_options[] = {`
88			`#if defined(B115200) \|\| defined(__hpux)`
89			`115200,`
90			`#endif`
91			`#if defined(B57600) \|\| defined(__hpux)`
92			`57600,`
93			`#endif`
94			`38400, 19200, 9600`
95			`};`
96
97			`static ParameterList param_list[] = {`
98			`{ AP_BAUD_RATE,`
99			`sizeof(baud_options)/sizeof(unsigned int),`
100			`baud_options }`
101			`};`
102
103			`static const ParameterOptions serial_options = {`
104			`sizeof(param_list)/sizeof(ParameterList), param_list };`
105
106			`/*`
107			`* The default parameter config for the device`
108			`*/`
109			`static Parameter param_default[] = {`
110			`{ AP_BAUD_RATE, 9600 }`
111			`};`
112
113			`static ParameterConfig serial_defaults = {`
114			`sizeof(param_default)/sizeof(Parameter), param_default };`
115
116			`/*`
117			`* The user-modified options for the device`
118			`*/`
119			`static unsigned int user_baud_options[sizeof(baud_options)/sizeof(unsigned)];`
120
121			`static ParameterList param_user_list[] = {`
122			`{ AP_BAUD_RATE,`
123			`sizeof(user_baud_options)/sizeof(unsigned),`
124			`user_baud_options }`
125			`};`
126
127			`static ParameterOptions user_options = {`
128			`sizeof(param_user_list)/sizeof(ParameterList), param_user_list };`
129
130			`static bool user_options_set;`
131
132			`/* forward declarations */`
133			`static int serial_reset( void );`
134			`static int serial_set_params( const ParameterConfig *config );`
135			`static int SerialMatch(const char name, const char arg);`
136
137			`static void process_baud_rate( unsigned int target_baud_rate )`
138			`{`
139			`const ParameterList *full_list;`
140			`ParameterList *user_list;`
141
142			`/* create subset of full options */`
143			`full_list = Angel_FindParamList( &serial_options, AP_BAUD_RATE );`
144			`user_list = Angel_FindParamList( &user_options, AP_BAUD_RATE );`
145
146			`if ( full_list != NULL && user_list != NULL )`
147			`{`
148			`unsigned int i, j;`
149			`unsigned int def_baud = 0;`
150
151			`/* find lower or equal to */`
152			`for ( i = 0; i < full_list->num_options; ++i )`
153			`if ( target_baud_rate >= full_list->option[i] )`
154			`{`
155			`/* copy remaining */`
156			`for ( j = 0; j < (full_list->num_options - i); ++j )`
157			`user_list->option[j] = full_list->option[i+j];`
158			`user_list->num_options = j;`
159
160			`/* check this is not the default */`
161			`Angel_FindParam( AP_BAUD_RATE, &serial_defaults, &def_baud );`
162			`if ( (j == 1) && (user_list->option[0] == def_baud) )`
163			`{`
164			`#ifdef DEBUG`
165			`printf( "user selected default\n" );`
166			`#endif`
167			`}`
168			`else`
169			`{`
170			`user_options_set = TRUE;`
171			`#ifdef DEBUG`
172			`printf( "user options are: " );`
173			`for ( j = 0; j < user_list->num_options; ++j )`
174			`printf( "%u ", user_list->option[j] );`
175			`printf( "\n" );`
176			`#endif`
177			`}`
178
179			`break; /* out of i loop */`
180			`}`
181
182			`#ifdef DEBUG`
183			`if ( i >= full_list->num_options )`
184			`printf( "couldn't match baud rate %u\n", target_baud_rate );`
185			`#endif`
186			`}`
187			`#ifdef DEBUG`
188			`else`
189			`printf( "failed to find lists\n" );`
190			`#endif`
191			`}`
192
193			`static int SerialOpen(const char name, const char arg)`
194			`{`
195			`const char *port_name = name;`
196
197			`#ifdef DEBUG`
198			`printf("SerialOpen: name %s arg %s\n", name, arg ? arg : "<NULL>");`
199			`#endif`
200
201			`#ifdef COMPILING_ON_WINDOWS`
202			`if (IsOpenSerial()) return -1;`
203			`#else`
204			`if (Unix_IsSerialInUse()) return -1;`
205			`#endif`
206
207			`#ifdef COMPILING_ON_WINDOWS`
208			`if (SerialMatch(name, arg) != adp_ok)`
209			`return adp_failed;`
210			`#else`
211			`port_name = Unix_MatchValidSerialDevice(port_name);`
212			`# ifdef DEBUG`
213			`printf("translated port to %s\n", port_name == 0 ? "NULL" : port_name);`
214			`# endif`
215			`if (port_name == 0) return adp_failed;`
216			`#endif`
217
218			`user_options_set = FALSE;`
219
220			`/* interpret and store the arguments */`
221			`if ( arg != NULL )`
222			`{`
223			`unsigned int target_baud_rate;`
224			`target_baud_rate = (unsigned int)strtoul(arg, NULL, 10);`
225			`if (target_baud_rate > 0)`
226			`{`
227			`#ifdef DEBUG`
228			`printf( "user selected baud rate %u\n", target_baud_rate );`
229			`#endif`
230			`process_baud_rate( target_baud_rate );`
231			`}`
232			`#ifdef DEBUG`
233			`else`
234			`printf( "could not understand baud rate %s\n", arg );`
235			`#endif`
236			`}`
237			`else if (baud_rate > 0)`
238			`{`
239			`/* If the user specified a baud rate on the command line "-b" or via`
240			`the "set remotebaud" command then try to use that one */`
241			`process_baud_rate( baud_rate );`
242			`}`
243
244			`#ifdef COMPILING_ON_WINDOWS`
245			`{`
246			`int port = IsValidDevice(name);`
247			`if (OpenSerial(port, FALSE) != COM_OK)`
248			`return -1;`
249			`}`
250			`#else`
251			`if (Unix_OpenSerial(port_name) < 0)`
252			`return -1;`
253			`#endif`
254
255			`serial_reset();`
256
257			`#if defined(__unix) \|\| defined(__CYGWIN32__)`
258			`Unix_ioctlNonBlocking();`
259			`#endif`
260
261			`Angel_RxEngineInit(&config, &rxstate);`
262			`/*`
263			`* DANGER!: passing in NULL as the packet is ok for now as it is just`
264			`* IGNOREd but this may well change`
265			`*/`
266			`Angel_TxEngineInit(&config, NULL, &wstate.txstate);`
267			`return 0;`
268			`}`
269
270			`static int SerialMatch(const char name, const char arg)`
271			`{`
272			`UNUSED(arg);`
273			`#ifdef COMPILING_ON_WINDOWS`
274			`if (IsValidDevice(name) == COM_DEVICENOTVALID)`
275			`return -1;`
276			`else`
277			`return 0;`
278			`#else`
279			`return Unix_MatchValidSerialDevice(name) == 0 ? -1 : 0;`
280			`#endif`
281			`}`
282
283			`static void SerialClose(void)`
284			`{`
285			`#ifdef DO_TRACE`
286			`printf("SerialClose()\n");`
287			`#endif`
288
289			`#ifdef COMPILING_ON_WINDOWS`
290			`CloseSerial();`
291			`#else`
292			`Unix_CloseSerial();`
293			`#endif`
294			`}`
295
296			`static int SerialRead(DriverCall *dc, bool block) {`
297			`static unsigned char readbuf[MAXREADSIZE];`
298			`static int rbindex=0;`
299
300			`int nread;`
301			`int read_errno;`
302			`int c=0;`
303			`re_status restatus;`
304			`int ret_code = -1; /* assume bad packet or error */`
305
306			`/* must not overflow buffer and must start after the existing data */`
307			`#ifdef COMPILING_ON_WINDOWS`
308			`{`
309			`BOOL dummy = FALSE;`
310			`nread = BytesInRXBufferSerial();`
311
312			`if (nread > MAXREADSIZE - rbindex)`
313			`nread = MAXREADSIZE - rbindex;`
314
315			`if ((read_errno = ReadSerial(readbuf+rbindex, nread, &dummy)) == COM_READFAIL)`
316			`{`
317			`MessageBox(GetFocus(), "Read error\n", "Angel", MB_OK \| MB_ICONSTOP);`
318			`return -1; /* SJ - This really needs to return a value, which is picked up in */`
319			`/* DevSW_Read as meaning stop debugger but don't kill. */`
320			`}`
321			`else if (pfnProgressCallback != NULL && read_errno == COM_OK)`
322			`{`
323			`progressInfo.nRead += nread;`
324			`(*pfnProgressCallback)(&progressInfo);`
325			`}`
326			`}`
327			`#else`
328			`nread = Unix_ReadSerial(readbuf+rbindex, MAXREADSIZE-rbindex, block);`
329			`read_errno = errno;`
330			`#endif`
331
332			`if ((nread > 0) \|\| (rbindex > 0)) {`
333
334			`#ifdef DO_TRACE`
335			`printf("[%d@%d] ", nread, rbindex);`
336			`#endif`
337
338			`if (nread>0)`
339			`rbindex = rbindex+nread;`
340
341			`do {`
342			`restatus = Angel_RxEngine(readbuf[c], &(dc->dc_packet), &rxstate);`
343			`#ifdef DO_TRACE`
344			`printf("<%02X ",readbuf[c]);`
345			`if (!(++c % 16))`
346			`printf("\n");`
347			`#else`
348			`c++;`
349			`#endif`
350			`} while (c<rbindex &&`
351			`((restatus == RS_IN_PKT) \|\| (restatus == RS_WAIT_PKT)));`
352
353			`#ifdef DO_TRACE`
354			`if (c % 16)`
355			`printf("\n");`
356			`#endif`
357
358			`switch(restatus) {`
359
360			`case RS_GOOD_PKT:`
361			`ret_code = 1;`
362			`/* fall through to: */`
363
364			`case RS_BAD_PKT:`
365			`/*`
366			`* We now need to shuffle any left over data down to the`
367			`* beginning of our private buffer ready to be used`
368			`*for the next packet`
369			`*/`
370			`#ifdef DO_TRACE`
371			`printf("SerialRead() processed %d, moving down %d\n", c, rbindex-c);`
372			`#endif`
373			`if (c != rbindex) memmove((char ) readbuf, (char ) (readbuf+c),`
374			`rbindex-c);`
375			`rbindex -= c;`
376			`break;`
377
378			`case RS_IN_PKT:`
379			`case RS_WAIT_PKT:`
380			`rbindex = 0; /* will have processed all we had */`
381			`ret_code = 0;`
382			`break;`
383
384			`default:`
385			`#ifdef DEBUG`
386			`printf("Bad re_status in serialRead()\n");`
387			`#endif`
388			`break;`
389			`}`
390			`} else if (nread == 0)`
391			`ret_code = 0; /* nothing to read */`
392			`else if (read_errno == ERRNO_FOR_BLOCKED_IO) /* nread < 0 */`
393			`ret_code = 0;`
394
395			`#ifdef DEBUG`
396			`if ((nread<0) && (read_errno!=ERRNO_FOR_BLOCKED_IO))`
397			`perror("read() error in serialRead()");`
398			`#endif`
399
400			`return ret_code;`
401			`}`
402
403
404			`static int SerialWrite(DriverCall *dc) {`
405			`int nwritten = 0;`
406			`te_status testatus = TS_IN_PKT;`
407
408			`if (dc->dc_context == NULL) {`
409			`Angel_TxEngineInit(&config, &(dc->dc_packet), &(wstate.txstate));`
410			`wstate.wbindex = 0;`
411			`dc->dc_context = &wstate;`
412			`}`
413
414			`while ((testatus == TS_IN_PKT) && (wstate.wbindex < MAXWRITESIZE))`
415			`{`
416			`/* send the raw data through the tx engine to escape and encapsulate */`
417			`testatus = Angel_TxEngine(&(dc->dc_packet), &(wstate.txstate),`
418			`&(wstate.writebuf)[wstate.wbindex]);`
419			`if (testatus != TS_IDLE) wstate.wbindex++;`
420			`}`
421
422			`if (testatus == TS_IDLE) {`
423			`#ifdef DEBUG`
424			`printf("SerialWrite: testatus is TS_IDLE during preprocessing\n");`
425			`#endif`
426			`}`
427
428			`#ifdef DO_TRACE`
429			`{`
430			`int i = 0;`
431
432			`while (i<wstate.wbindex)`
433			`{`
434			`printf(">%02X ",wstate.writebuf[i]);`
435
436			`if (!(++i % 16))`
437			`printf("\n");`
438			`}`
439			`if (i % 16)`
440			`printf("\n");`
441			`}`
442			`#endif`
443
444			`#ifdef COMPILING_ON_WINDOWS`
445			`if (WriteSerial(wstate.writebuf, wstate.wbindex) == COM_OK)`
446			`{`
447			`nwritten = wstate.wbindex;`
448			`if (pfnProgressCallback != NULL)`
449			`{`
450			`progressInfo.nWritten += nwritten;`
451			`(*pfnProgressCallback)(&progressInfo);`
452			`}`
453			`}`
454			`else`
455			`{`
456			`MessageBox(GetFocus(), "Write error\n", "Angel", MB_OK \| MB_ICONSTOP);`
457			`return -1; /* SJ - This really needs to return a value, which is picked up in */`
458			`/* DevSW_Read as meaning stop debugger but don't kill. */`
459			`}`
460			`#else`
461			`nwritten = Unix_WriteSerial(wstate.writebuf, wstate.wbindex);`
462
463			`if (nwritten < 0) {`
464			`nwritten=0;`
465			`}`
466			`#endif`
467
468			`#ifdef DEBUG`
469			`if (nwritten > 0)`
470			`printf("Wrote %#04x bytes\n", nwritten);`
471			`#endif`
472
473			`if ((unsigned) nwritten == wstate.wbindex &&`
474			`(testatus == TS_DONE_PKT \|\| testatus == TS_IDLE)) {`
475
476			`/* finished sending the packet */`
477
478			`#ifdef DEBUG`
479			`printf("SerialWrite: calling Angel_TxEngineInit after sending packet (len=%i)\n",wstate.wbindex);`
480			`#endif`
481			`testatus = TS_IN_PKT;`
482			`wstate.wbindex = 0;`
483			`return 1;`
484			`}`
485			`else {`
486			`#ifdef DEBUG`
487			`printf("SerialWrite: Wrote part of packet wbindex=%i, nwritten=%i\n",`
488			`wstate.wbindex, nwritten);`
489			`#endif`
490
491			`/*`
492			`* still some data left to send shuffle whats left down and reset`
493			`* the ptr`
494			`*/`
495			`memmove((char ) wstate.writebuf, (char ) (wstate.writebuf+nwritten),`
496			`wstate.wbindex-nwritten);`
497			`wstate.wbindex -= nwritten;`
498			`return 0;`
499			`}`
500			`return -1;`
501			`}`
502
503
504			`static int serial_reset( void )`
505			`{`
506			`#ifdef DEBUG`
507			`printf( "serial_reset\n" );`
508			`#endif`
509
510			`#ifdef COMPILING_ON_WINDOWS`
511			`FlushSerial();`
512			`#else`
513			`Unix_ResetSerial();`
514			`#endif`
515
516			`return serial_set_params( &serial_defaults );`
517			`}`
518
519
520			`static int find_baud_rate( unsigned int *speed )`
521			`{`
522			`static struct {`
523			`unsigned int baud;`
524			`int termiosValue;`
525			`} possibleBaudRates[] = {`
526			`#if defined(__hpux)`
527			`{115200,_B115200}, {57600,_B57600},`
528			`#else`
529			`#ifdef B115200`
530			`{115200,B115200},`
531			`#endif`
532			`#ifdef B57600`
533			`{57600,B57600},`
534			`#endif`
535			`#endif`
536			`#ifdef COMPILING_ON_WINDOWS`
537			`{38400,CBR_38400}, {19200,CBR_19200}, {9600, CBR_9600}, {0,0}`
538			`#else`
539			`{38400,B38400}, {19200,B19200}, {9600, B9600}, {0,0}`
540			`#endif`
541			`};`
542			`unsigned int i;`
543
544			`/* look for lower or matching -- will always terminate at 0 end marker */`
545			`for ( i = 0; possibleBaudRates[i].baud > *speed; ++i )`
546			`/* do nothing */ ;`
547
548			`if ( possibleBaudRates[i].baud > 0 )`
549			`*speed = possibleBaudRates[i].baud;`
550
551			`return possibleBaudRates[i].termiosValue;`
552			`}`
553
554
555			`static int serial_set_params( const ParameterConfig *config )`
556			`{`
557			`unsigned int speed;`
558			`int termios_value;`
559
560			`#ifdef DEBUG`
561			`printf( "serial_set_params\n" );`
562			`#endif`
563
564			`if ( ! Angel_FindParam( AP_BAUD_RATE, config, &speed ) )`
565			`{`
566			`#ifdef DEBUG`
567			`printf( "speed not found in config\n" );`
568			`#endif`
569			`return DE_OKAY;`
570			`}`
571
572			`termios_value = find_baud_rate( &speed );`
573			`if ( termios_value == 0 )`
574			`{`
575			`#ifdef DEBUG`
576			`printf( "speed not valid: %u\n", speed );`
577			`#endif`
578			`return DE_OKAY;`
579			`}`
580
581			`#ifdef DEBUG`
582			`printf( "setting speed to %u\n", speed );`
583			`#endif`
584
585			`#ifdef COMPILING_ON_WINDOWS`
586			`SetBaudRate((WORD)termios_value);`
587			`#else`
588			`Unix_SetSerialBaudRate(termios_value);`
589			`#endif`
590
591			`return DE_OKAY;`
592			`}`
593
594
595			`static int serial_get_user_params( ParameterOptions **p_options )`
596			`{`
597			`#ifdef DEBUG`
598			`printf( "serial_get_user_params\n" );`
599			`#endif`
600
601			`if ( user_options_set )`
602			`{`
603			`*p_options = &user_options;`
604			`}`
605			`else`
606			`{`
607			`*p_options = NULL;`
608			`}`
609
610			`return DE_OKAY;`
611			`}`
612
613
614			`static int serial_get_default_params( ParameterConfig **p_config )`
615			`{`
616			`#ifdef DEBUG`
617			`printf( "serial_get_default_params\n" );`
618			`#endif`
619
620			`p_config = (ParameterConfig ) &serial_defaults;`
621			`return DE_OKAY;`
622			`}`
623
624
625			`static int SerialIoctl(const int opcode, void *args) {`
626
627			`int ret_code;`
628
629			`#ifdef DEBUG`
630			`printf( "SerialIoctl: op %d arg %p\n", opcode, args ? args : "<NULL>");`
631			`#endif`
632
633			`switch (opcode)`
634			`{`
635			`case DC_RESET:`
636			`ret_code = serial_reset();`
637			`break;`
638
639			`case DC_SET_PARAMS:`
640			`ret_code = serial_set_params((const ParameterConfig *)args);`
641			`break;`
642
643			`case DC_GET_USER_PARAMS:`
644			`ret_code = serial_get_user_params((ParameterOptions **)args);`
645			`break;`
646
647			`case DC_GET_DEFAULT_PARAMS:`
648			`ret_code = serial_get_default_params((ParameterConfig **)args);`
649			`break;`
650
651			`default:`
652			`ret_code = DE_BAD_OP;`
653			`break;`
654			`}`
655
656			`return ret_code;`
657			`}`
658
659			`DeviceDescr angel_SerialDevice = {`
660			`"SERIAL",`
661			`SerialOpen,`
662			`SerialMatch,`
663			`SerialClose,`
664			`SerialRead,`
665			`SerialWrite,`
666			`SerialIoctl`
667			`};`