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

Subversion Repositories or1k_old

[/] [or1k_old/] [trunk/] [gdb-5.3/] [gdb/] [rdi-share/] [unixcomm.c] - Blame information for rev 1181

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: 2003-08-14 22:51:55 $
 *
 */
 
#ifdef __hpux
#  define _POSIX_SOURCE 1
#endif
 
#include <stdio.h>
#include <unistd.h>
#include <ctype.h>
 
#ifdef __hpux
#  define _TERMIOS_INCLUDED
#  include <sys/termio.h>
#  undef _TERMIOS_INCLUDED
#else
#  include <termios.h>
#endif
 
#include <string.h>
#include <fcntl.h>
#include <errno.h>
#include <stdarg.h>
#include <sys/types.h>
#include <sys/time.h>
 
#if defined (__FreeBSD__) || defined (__NetBSD__) || defined (__OpenBSD__) || defined (bsdi)
#undef BSD
#include <sys/ioctl.h>
#endif
 
#ifdef sun
# include <sys/ioccom.h>
# ifdef __svr4__
#  include <sys/bpp_io.h>
# else
#  include <sbusdev/bpp_io.h>
# endif
#endif
 
#ifdef BSD
# ifdef sun
#  include <sys/ttydev.h>
# endif
# ifdef __alpha 
#  include <sys/ioctl.h>
# else
#  include <sys/filio.h>
# endif
#endif
 
#ifdef __hpux
#  define _INCLUDE_HPUX_SOURCE
#  include <sys/ioctl.h>
#  undef _INCLUDE_HPUX_SOURCE
#endif
 
#include "host.h"
#include "unixcomm.h"
 
#define PP_TIMEOUT      1              /* seconds */
 
#ifdef sun
#define SERIAL_PREFIX "/dev/tty"
#define SERPORT1   "/dev/ttya"
#define SERPORT2   "/dev/ttyb"
#define PARPORT1   "/dev/bpp0"
#define PARPORT2   "/dev/bpp1"
#endif
 
#ifdef __hpux
#define SERIAL_PREFIX "/dev/tty"
#define SERPORT1   "/dev/tty00"
#define SERPORT2   "/dev/tty01"
#define PARPORT1   "/dev/ptr_parallel"
#define PARPORT2   "/dev/ptr_parallel"
#endif
 
#ifdef __linux__
#define SERIAL_PREFIX "/dev/ttyS"
#define SERPORT1   "/dev/ttyS0"
#define SERPORT2   "/dev/ttyS1"
#define PARPORT1   "/dev/par0"
#define PARPORT2   "/dev/par1"
#endif
 
#if defined(_WIN32) || defined (__CYGWIN__) 
#define SERIAL_PREFIX "com"
#define SERPORT1   "com1"
#define SERPORT2   "com2"
#define PARPORT1   "lpt1"
#define PARPORT2   "lpt2"
#endif
 
#if !defined (SERIAL_PREFIX)
#define SERIAL_PREFIX "/dev/cuaa"
#define SERPORT1   "/dev/cuaa0"
#define SERPORT2   "/dev/cuaa1"
#define PARPORT1   "/dev/lpt0"
#define PARPORT2   "/dev/lpt1"
#endif
 
 
 
 
/*
 * Parallel port output pins, used for signalling to target
 */
 
#ifdef sun
struct bpp_pins bp;
#endif
 
static int serpfd = -1;
static int parpfd = -1;
 
extern const char *Unix_MatchValidSerialDevice(const char *name)
{
  int i=0;
  char *sername=NULL;
 
  /* Accept no name as the default serial port */
  if (name == NULL) {
    return SERPORT1;
  }
 
  /* Look for the simple cases - 1,2,s,S,/dev/... first, and
   * afterwards look for S=... clauses, which need parsing properly.
   */
 
  /* Accept /dev/tty* where * is limited */
  if (strlen(name) == strlen(SERPORT1)
      && strncmp(name, SERIAL_PREFIX, strlen (SERIAL_PREFIX)) == 0)
      {
        return name;
      }
 
  /* Accept "1" or "2" or "S" - S is equivalent to "1" */
  if (strcmp(name, "1") == 0 ||
      strcmp(name, "S") == 0 || strcmp(name, "s") == 0) {
    return SERPORT1;
  }
  if (strcmp(name, "2") == 0) return SERPORT2;
 
  /* It wasn't one of the simple cases, so now we have to parse it
   * properly
   */
 
  do {
    switch (name[i]) {
      case ',':
        /* Skip over commas */
        i++;
        break;
 
      default:
        return 0;
        /* Unexpected character => error - not matched */
 
      case 0:
        /* End of string means return whatever we have matched */
        return sername;
 
      case 's':
      case 'S':
      case 'h':
      case 'H': {
        char ch = tolower(name[i]);
        int j, continue_from, len;
 
        /* If the next character is a comma or a NULL then this is
         * a request for the default Serial port
         */
        if (name[++i] == 0 || name[i] == ',') {
          if (ch=='s')
              sername=SERPORT1;
          break;
        }
 
        /* Next character must be an = */
        if (name[i] != '=') return 0;
        /* Search for the end of the port spec. (ends in NULL or ,) */
        for (j= ++i; name[j] != 0 && name[j] != ','; j++)
          ; /* Do nothing */
        /* Notice whether this is the last thing to parse or not
         * and also calaculate the length of the string
         */
        if (name[j] == '0') continue_from = -1;
        else continue_from = j;
        len=(j-i);
 
        /* And now try to match the serial / parallel port */
        switch (ch) {
          case 's': {
            /* Match serial port */
            if (len==1) {
              if (name[i]=='1')
                  sername=SERPORT1;
              else if (name[i]=='2')
                  sername=SERPORT2;
            } else if (len==strlen(SERPORT1)) {
              if (strncmp(name+i,SERPORT1,strlen(SERPORT1)) == 0)
                sername=SERPORT1;
              else if (strncmp(name+i,SERPORT2,strlen(SERPORT2)) == 0)
                sername=SERPORT2;
            }
 
            break;
          }
 
          case 'h':
            /* We don't actually deal with the H case here, we just
             * match it and allow it through.
             */
            break;
        }
 
        if (continue_from == -1) return sername;
        i = continue_from;
        break;
      }
    }
  } while (1);
 
  return 0;
}
 
 
extern int Unix_IsSerialInUse(void)
{
    if (serpfd >= 0)
        return -1;
 
    return 0;
}
 
extern int Unix_OpenSerial(const char *name)
{
#if defined(BSD) || defined(__CYGWIN__)
    serpfd = open(name, O_RDWR);
#else
    serpfd = open(name, O_RDWR | O_NONBLOCK);
#endif
 
    if (serpfd < 0) {
        perror("open");
        return -1;
    }
#ifdef TIOCEXCL
    if (ioctl(serpfd, TIOCEXCL) < 0) {
        close(serpfd);
        perror("ioctl: TIOCEXCL");
        return -1;
    }
#endif
 
    return 0;
}
 
extern void Unix_CloseSerial(void)
{
    if (serpfd >= 0)
    {
        (void)close(serpfd);
        serpfd = -1;
    }
}
 
extern int Unix_ReadSerial(unsigned char *buf, int n, bool block)
{
    fd_set fdset;
    struct timeval tv;
    int err;
 
    FD_ZERO(&fdset);
    FD_SET(serpfd, &fdset);
 
    tv.tv_sec = 0;
    tv.tv_usec = (block ? 10000 : 0);
 
    err = select(serpfd + 1, &fdset, NULL, NULL, &tv);
 
    if (err < 0 && errno != EINTR)
    {
#ifdef DEBUG
        perror("select");
#endif
        panic("select failure");
        return -1;
    }
    else if (err > 0 && FD_ISSET(serpfd, &fdset))
      {
        int s;
 
        s = read(serpfd, buf, n);
        if (s < 0)
          perror("read:");
        return s;
      }
    else /* err == 0 || FD_CLR(serpfd, &fdset) */
    {
        errno = ERRNO_FOR_BLOCKED_IO;
        return -1;
    }
}
 
extern int Unix_WriteSerial(unsigned char *buf, int n)
{
    return write(serpfd, buf, n);
}
 
extern void Unix_ResetSerial(void)
{
    struct termios terminfo;
 
    tcgetattr(serpfd, &terminfo);
    terminfo.c_lflag &= ~(ICANON | ISIG | ECHO | IEXTEN);
    terminfo.c_iflag &= ~(IGNCR | INPCK | ISTRIP | ICRNL | BRKINT);
    terminfo.c_iflag |= (IXON | IXOFF | IGNBRK);
    terminfo.c_cflag = (terminfo.c_cflag & ~CSIZE) | CS8 | CREAD;
    terminfo.c_cflag &= ~PARENB;
    terminfo.c_cc[VMIN] = 1;
    terminfo.c_cc[VTIME] = 0;
    terminfo.c_oflag &= ~OPOST;
    tcsetattr(serpfd, TCSAFLUSH, &terminfo);
}
 
extern void Unix_SetSerialBaudRate(int baudrate)
{
    struct termios terminfo;
 
    tcgetattr(serpfd, &terminfo);
    cfsetospeed(&terminfo, baudrate);
    cfsetispeed(&terminfo, baudrate);
    tcsetattr(serpfd, TCSAFLUSH, &terminfo);
}
 
extern void Unix_ioctlNonBlocking(void)
{
#if defined(BSD)
    int nonblockingIO = 1;
    (void)ioctl(serpfd, FIONBIO, &nonblockingIO);
 
    if (parpfd != -1)
        (void)ioctl(parpfd, FIONBIO, &nonblockingIO);
#endif
}
 
extern void Unix_IsValidParallelDevice(
  const char *portstring, char **sername, char **parname)
{
  int i=0;
  *sername=NULL;
  *parname=NULL;
 
  /* Do not recognise a NULL portstring */
  if (portstring==NULL) return;
 
  do {
    switch (portstring[i]) {
      case ',':
        /* Skip over commas */
        i++;
        break;
 
      default:
      case 0:
        /* End of string or bad characcter means we have finished */
        return;
 
      case 's':
      case 'S':
      case 'p':
      case 'P':
      case 'h':
      case 'H': {
        char ch = tolower(portstring[i]);
        int j, continue_from, len;
 
        /* If the next character is a comma or a NULL then this is
         * a request for the default Serial or Parallel port
         */
        if (portstring[++i] == 0 || portstring[i] == ',') {
          if (ch=='s') *sername=SERPORT1;
          else if (ch=='p') *parname=PARPORT1;
          break;
        }
 
        /* Next character must be an = */
        if (portstring[i] != '=') return;
        /* Search for the end of the port spec. (ends in NULL or ,) */
        for (j= ++i; portstring[j] != 0 && portstring[j] != ','; j++)
          ; /* Do nothing */
        /* Notice whether this is the last thing to parse or not
         * and also calaculate the length of the string
         */
        if (portstring[j] == '0') continue_from = -1;
        else continue_from = j;
        len=(j-i);
 
        /* And now try to match the serial / parallel port */
        switch (ch) {
          case 's': {
            /* Match serial port */
            if (len==1) {
              if (portstring[i]=='1') *sername=SERPORT1;
              else if (portstring[i]=='2') *sername=SERPORT2;
            } else if (len==strlen(SERPORT1)) {
              if (strncmp(portstring+i,SERPORT1,strlen(SERPORT1)) == 0)
                *sername=SERPORT1;
              else if (strncmp(portstring+i,SERPORT2,strlen(SERPORT2)) == 0)
                *sername=SERPORT2;
            }
            break;
          }
 
          case 'p': {
            /* Match parallel port */
            if (len==1) {
              if (portstring[i]=='1') *parname=PARPORT1;
              else if (portstring[i]=='2') *parname=PARPORT2;
            } else if (len==strlen(PARPORT1)) {
              if (strncmp(portstring+i,PARPORT1,strlen(PARPORT1)) == 0)
                *parname=PARPORT1;
              else if (strncmp(portstring+i,PARPORT2,strlen(PARPORT2)) == 0)
                *parname=PARPORT2;
            }
            break;
          }
 
          case 'h':
            /* We don't actually deal with the H case here, we just
             * match it and allow it through.
             */
            break;
        }
 
        if (continue_from == -1) return;
        i = continue_from;
        break;
      }
    }
  } while (1);
  return;  /* Will never get here */
}
 
extern int Unix_IsParallelInUse(void)
{
    if (parpfd >= 0)
        return -1;
 
    return 0;
}
 
extern int Unix_OpenParallel(const char *name)
{
#if defined(BSD)
    parpfd = open(name, O_RDWR);
#else
    parpfd = open(name, O_RDWR | O_NONBLOCK);
#endif
 
    if (parpfd < 0)
    {
        char errbuf[256];
 
        sprintf(errbuf, "open %s", name);
        perror(errbuf);
 
        return -1;
    }
 
    return 0;
}
 
extern void Unix_CloseParallel(void)
{
    if (parpfd >= 0)
    {
        (void)close(parpfd);
        parpfd = -1;
    }
}
 
 
extern unsigned int Unix_WriteParallel(unsigned char *buf, int n)
{
    int ngone;
 
    if ((ngone = write(parpfd, buf, n)) < 0)
    {
        /*
         * we ignore errors (except for debug purposes)
         */
#ifdef DEBUG
        char errbuf[256];
 
        sprintf(errbuf, "send_packet: write");
        perror(errbuf);
#endif
        ngone = 0;
    }
 
    /* finished */
    return (unsigned int)ngone;
}
 
 
#ifdef sun
extern void Unix_ResetParallel(void)
{
    struct bpp_transfer_parms tp;
 
#ifdef DEBUG
    printf("serpar_reset\n");
#endif
 
    /*
     * we need to set the parallel port up for BUSY handshaking,
     * and select the timeout
     */
    if (ioctl(parpfd, BPPIOC_GETPARMS, &tp) < 0)
    {
#ifdef DEBUG
        perror("ioctl(BPPIOCGETPARMS)");
#endif
        panic("serpar_reset: cannot get BPP parameters");
    }
 
    tp.write_handshake = BPP_BUSY_HS;
    tp.write_timeout = PP_TIMEOUT;
 
    if (ioctl(parpfd, BPPIOC_SETPARMS, &tp) < 0)
    {
#ifdef DEBUG
        perror("ioctl(BPPIOC_SETPARMS)");
#endif
        panic("serpar_reset: cannot set BPP parameters");
    }
}
 
#else
 
/* Parallel not supported on HP */
 
extern void Unix_ResetParallel(void)
{
}
 
#endif
 

Browse

Tools

Subversion Repositories or1k_old

[/] [or1k_old/] [trunk/] [gdb-5.3/] [gdb/] [rdi-share/] [unixcomm.c] - Blame information for rev 1181

Line No.	Rev	Author	Line
1	1181	sfurman	`/*`
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: 2003-08-14 22:51:55 $`
13			`*`
14			`*/`
15
16			`#ifdef __hpux`
17			`# define _POSIX_SOURCE 1`
18			`#endif`
19
20			`#include <stdio.h>`
21			`#include <unistd.h>`
22			`#include <ctype.h>`
23
24			`#ifdef __hpux`
25			`# define _TERMIOS_INCLUDED`
26			`# include <sys/termio.h>`
27			`# undef _TERMIOS_INCLUDED`
28			`#else`
29			`# include <termios.h>`
30			`#endif`
31
32			`#include <string.h>`
33			`#include <fcntl.h>`
34			`#include <errno.h>`
35			`#include <stdarg.h>`
36			`#include <sys/types.h>`
37			`#include <sys/time.h>`
38
39			`#if defined (__FreeBSD__) \|\| defined (__NetBSD__) \|\| defined (__OpenBSD__) \|\| defined (bsdi)`
40			`#undef BSD`
41			`#include <sys/ioctl.h>`
42			`#endif`
43
44			`#ifdef sun`
45			`# include <sys/ioccom.h>`
46			`# ifdef __svr4__`
47			`# include <sys/bpp_io.h>`
48			`# else`
49			`# include <sbusdev/bpp_io.h>`
50			`# endif`
51			`#endif`
52
53			`#ifdef BSD`
54			`# ifdef sun`
55			`# include <sys/ttydev.h>`
56			`# endif`
57			`# ifdef __alpha`
58			`# include <sys/ioctl.h>`
59			`# else`
60			`# include <sys/filio.h>`
61			`# endif`
62			`#endif`
63
64			`#ifdef __hpux`
65			`# define _INCLUDE_HPUX_SOURCE`
66			`# include <sys/ioctl.h>`
67			`# undef _INCLUDE_HPUX_SOURCE`
68			`#endif`
69
70			`#include "host.h"`
71			`#include "unixcomm.h"`
72
73			`#define PP_TIMEOUT 1 /* seconds */`
74
75			`#ifdef sun`
76			`#define SERIAL_PREFIX "/dev/tty"`
77			`#define SERPORT1 "/dev/ttya"`
78			`#define SERPORT2 "/dev/ttyb"`
79			`#define PARPORT1 "/dev/bpp0"`
80			`#define PARPORT2 "/dev/bpp1"`
81			`#endif`
82
83			`#ifdef __hpux`
84			`#define SERIAL_PREFIX "/dev/tty"`
85			`#define SERPORT1 "/dev/tty00"`
86			`#define SERPORT2 "/dev/tty01"`
87			`#define PARPORT1 "/dev/ptr_parallel"`
88			`#define PARPORT2 "/dev/ptr_parallel"`
89			`#endif`
90
91			`#ifdef __linux__`
92			`#define SERIAL_PREFIX "/dev/ttyS"`
93			`#define SERPORT1 "/dev/ttyS0"`
94			`#define SERPORT2 "/dev/ttyS1"`
95			`#define PARPORT1 "/dev/par0"`
96			`#define PARPORT2 "/dev/par1"`
97			`#endif`
98
99			`#if defined(_WIN32) \|\| defined (__CYGWIN__)`
100			`#define SERIAL_PREFIX "com"`
101			`#define SERPORT1 "com1"`
102			`#define SERPORT2 "com2"`
103			`#define PARPORT1 "lpt1"`
104			`#define PARPORT2 "lpt2"`
105			`#endif`
106
107			`#if !defined (SERIAL_PREFIX)`
108			`#define SERIAL_PREFIX "/dev/cuaa"`
109			`#define SERPORT1 "/dev/cuaa0"`
110			`#define SERPORT2 "/dev/cuaa1"`
111			`#define PARPORT1 "/dev/lpt0"`
112			`#define PARPORT2 "/dev/lpt1"`
113			`#endif`
114
115
116
117
118			`/*`
119			`* Parallel port output pins, used for signalling to target`
120			`*/`
121
122			`#ifdef sun`
123			`struct bpp_pins bp;`
124			`#endif`
125
126			`static int serpfd = -1;`
127			`static int parpfd = -1;`
128
129			`extern const char Unix_MatchValidSerialDevice(const char name)`
130			`{`
131			`int i=0;`
132			`char *sername=NULL;`
133
134			`/* Accept no name as the default serial port */`
135			`if (name == NULL) {`
136			`return SERPORT1;`
137			`}`
138
139			`/* Look for the simple cases - 1,2,s,S,/dev/... first, and`
140			`* afterwards look for S=... clauses, which need parsing properly.`
141			`*/`
142
143			`/* Accept /dev/tty* where * is limited */`
144			`if (strlen(name) == strlen(SERPORT1)`
145			`&& strncmp(name, SERIAL_PREFIX, strlen (SERIAL_PREFIX)) == 0)`
146			`{`
147			`return name;`
148			`}`
149
150			`/* Accept "1" or "2" or "S" - S is equivalent to "1" */`
151			`if (strcmp(name, "1") == 0 \|\|`
152			`strcmp(name, "S") == 0 \|\| strcmp(name, "s") == 0) {`
153			`return SERPORT1;`
154			`}`
155			`if (strcmp(name, "2") == 0) return SERPORT2;`
156
157			`/* It wasn't one of the simple cases, so now we have to parse it`
158			`* properly`
159			`*/`
160
161			`do {`
162			`switch (name[i]) {`
163			`case ',':`
164			`/* Skip over commas */`
165			`i++;`
166			`break;`
167
168			`default:`
169			`return 0;`
170			`/* Unexpected character => error - not matched */`
171
172			`case 0:`
173			`/* End of string means return whatever we have matched */`
174			`return sername;`
175
176			`case 's':`
177			`case 'S':`
178			`case 'h':`
179			`case 'H': {`
180			`char ch = tolower(name[i]);`
181			`int j, continue_from, len;`
182
183			`/* If the next character is a comma or a NULL then this is`
184			`* a request for the default Serial port`
185			`*/`
186			`if (name[++i] == 0 \|\| name[i] == ',') {`
187			`if (ch=='s')`
188			`sername=SERPORT1;`
189			`break;`
190			`}`
191
192			`/* Next character must be an = */`
193			`if (name[i] != '=') return 0;`
194			`/* Search for the end of the port spec. (ends in NULL or ,) */`
195			`for (j= ++i; name[j] != 0 && name[j] != ','; j++)`
196			`; /* Do nothing */`
197			`/* Notice whether this is the last thing to parse or not`
198			`* and also calaculate the length of the string`
199			`*/`
200			`if (name[j] == '0') continue_from = -1;`
201			`else continue_from = j;`
202			`len=(j-i);`
203
204			`/* And now try to match the serial / parallel port */`
205			`switch (ch) {`
206			`case 's': {`
207			`/* Match serial port */`
208			`if (len==1) {`
209			`if (name[i]=='1')`
210			`sername=SERPORT1;`
211			`else if (name[i]=='2')`
212			`sername=SERPORT2;`
213			`} else if (len==strlen(SERPORT1)) {`
214			`if (strncmp(name+i,SERPORT1,strlen(SERPORT1)) == 0)`
215			`sername=SERPORT1;`
216			`else if (strncmp(name+i,SERPORT2,strlen(SERPORT2)) == 0)`
217			`sername=SERPORT2;`
218			`}`
219
220			`break;`
221			`}`
222
223			`case 'h':`
224			`/* We don't actually deal with the H case here, we just`
225			`* match it and allow it through.`
226			`*/`
227			`break;`
228			`}`
229
230			`if (continue_from == -1) return sername;`
231			`i = continue_from;`
232			`break;`
233			`}`
234			`}`
235			`} while (1);`
236
237			`return 0;`
238			`}`
239
240
241			`extern int Unix_IsSerialInUse(void)`
242			`{`
243			`if (serpfd >= 0)`
244			`return -1;`
245
246			`return 0;`
247			`}`
248
249			`extern int Unix_OpenSerial(const char *name)`
250			`{`
251			`#if defined(BSD) \|\| defined(__CYGWIN__)`
252			`serpfd = open(name, O_RDWR);`
253			`#else`
254			`serpfd = open(name, O_RDWR \| O_NONBLOCK);`
255			`#endif`
256
257			`if (serpfd < 0) {`
258			`perror("open");`
259			`return -1;`
260			`}`
261			`#ifdef TIOCEXCL`
262			`if (ioctl(serpfd, TIOCEXCL) < 0) {`
263			`close(serpfd);`
264			`perror("ioctl: TIOCEXCL");`
265			`return -1;`
266			`}`
267			`#endif`
268
269			`return 0;`
270			`}`
271
272			`extern void Unix_CloseSerial(void)`
273			`{`
274			`if (serpfd >= 0)`
275			`{`
276			`(void)close(serpfd);`
277			`serpfd = -1;`
278			`}`
279			`}`
280
281			`extern int Unix_ReadSerial(unsigned char *buf, int n, bool block)`
282			`{`
283			`fd_set fdset;`
284			`struct timeval tv;`
285			`int err;`
286
287			`FD_ZERO(&fdset);`
288			`FD_SET(serpfd, &fdset);`
289
290			`tv.tv_sec = 0;`
291			`tv.tv_usec = (block ? 10000 : 0);`
292
293			`err = select(serpfd + 1, &fdset, NULL, NULL, &tv);`
294
295			`if (err < 0 && errno != EINTR)`
296			`{`
297			`#ifdef DEBUG`
298			`perror("select");`
299			`#endif`
300			`panic("select failure");`
301			`return -1;`
302			`}`
303			`else if (err > 0 && FD_ISSET(serpfd, &fdset))`
304			`{`
305			`int s;`
306
307			`s = read(serpfd, buf, n);`
308			`if (s < 0)`
309			`perror("read:");`
310			`return s;`
311			`}`
312			`else /* err == 0 \|\| FD_CLR(serpfd, &fdset) */`
313			`{`
314			`errno = ERRNO_FOR_BLOCKED_IO;`
315			`return -1;`
316			`}`
317			`}`
318
319			`extern int Unix_WriteSerial(unsigned char *buf, int n)`
320			`{`
321			`return write(serpfd, buf, n);`
322			`}`
323
324			`extern void Unix_ResetSerial(void)`
325			`{`
326			`struct termios terminfo;`
327
328			`tcgetattr(serpfd, &terminfo);`
329			`terminfo.c_lflag &= ~(ICANON \| ISIG \| ECHO \| IEXTEN);`
330			`terminfo.c_iflag &= ~(IGNCR \| INPCK \| ISTRIP \| ICRNL \| BRKINT);`
331			`terminfo.c_iflag \|= (IXON \| IXOFF \| IGNBRK);`
332			`terminfo.c_cflag = (terminfo.c_cflag & ~CSIZE) \| CS8 \| CREAD;`
333			`terminfo.c_cflag &= ~PARENB;`
334			`terminfo.c_cc[VMIN] = 1;`
335			`terminfo.c_cc[VTIME] = 0;`
336			`terminfo.c_oflag &= ~OPOST;`
337			`tcsetattr(serpfd, TCSAFLUSH, &terminfo);`
338			`}`
339
340			`extern void Unix_SetSerialBaudRate(int baudrate)`
341			`{`
342			`struct termios terminfo;`
343
344			`tcgetattr(serpfd, &terminfo);`
345			`cfsetospeed(&terminfo, baudrate);`
346			`cfsetispeed(&terminfo, baudrate);`
347			`tcsetattr(serpfd, TCSAFLUSH, &terminfo);`
348			`}`
349
350			`extern void Unix_ioctlNonBlocking(void)`
351			`{`
352			`#if defined(BSD)`
353			`int nonblockingIO = 1;`
354			`(void)ioctl(serpfd, FIONBIO, &nonblockingIO);`
355
356			`if (parpfd != -1)`
357			`(void)ioctl(parpfd, FIONBIO, &nonblockingIO);`
358			`#endif`
359			`}`
360
361			`extern void Unix_IsValidParallelDevice(`
362			`const char portstring, char sername, char *parname)`
363			`{`
364			`int i=0;`
365			`*sername=NULL;`
366			`*parname=NULL;`
367
368			`/* Do not recognise a NULL portstring */`
369			`if (portstring==NULL) return;`
370
371			`do {`
372			`switch (portstring[i]) {`
373			`case ',':`
374			`/* Skip over commas */`
375			`i++;`
376			`break;`
377
378			`default:`
379			`case 0:`
380			`/* End of string or bad characcter means we have finished */`
381			`return;`
382
383			`case 's':`
384			`case 'S':`
385			`case 'p':`
386			`case 'P':`
387			`case 'h':`
388			`case 'H': {`
389			`char ch = tolower(portstring[i]);`
390			`int j, continue_from, len;`
391
392			`/* If the next character is a comma or a NULL then this is`
393			`* a request for the default Serial or Parallel port`
394			`*/`
395			`if (portstring[++i] == 0 \|\| portstring[i] == ',') {`
396			`if (ch=='s') *sername=SERPORT1;`
397			`else if (ch=='p') *parname=PARPORT1;`
398			`break;`
399			`}`
400
401			`/* Next character must be an = */`
402			`if (portstring[i] != '=') return;`
403			`/* Search for the end of the port spec. (ends in NULL or ,) */`
404			`for (j= ++i; portstring[j] != 0 && portstring[j] != ','; j++)`
405			`; /* Do nothing */`
406			`/* Notice whether this is the last thing to parse or not`
407			`* and also calaculate the length of the string`
408			`*/`
409			`if (portstring[j] == '0') continue_from = -1;`
410			`else continue_from = j;`
411			`len=(j-i);`
412
413			`/* And now try to match the serial / parallel port */`
414			`switch (ch) {`
415			`case 's': {`
416			`/* Match serial port */`
417			`if (len==1) {`
418			`if (portstring[i]=='1') *sername=SERPORT1;`
419			`else if (portstring[i]=='2') *sername=SERPORT2;`
420			`} else if (len==strlen(SERPORT1)) {`
421			`if (strncmp(portstring+i,SERPORT1,strlen(SERPORT1)) == 0)`
422			`*sername=SERPORT1;`
423			`else if (strncmp(portstring+i,SERPORT2,strlen(SERPORT2)) == 0)`
424			`*sername=SERPORT2;`
425			`}`
426			`break;`
427			`}`
428
429			`case 'p': {`
430			`/* Match parallel port */`
431			`if (len==1) {`
432			`if (portstring[i]=='1') *parname=PARPORT1;`
433			`else if (portstring[i]=='2') *parname=PARPORT2;`
434			`} else if (len==strlen(PARPORT1)) {`
435			`if (strncmp(portstring+i,PARPORT1,strlen(PARPORT1)) == 0)`
436			`*parname=PARPORT1;`
437			`else if (strncmp(portstring+i,PARPORT2,strlen(PARPORT2)) == 0)`
438			`*parname=PARPORT2;`
439			`}`
440			`break;`
441			`}`
442
443			`case 'h':`
444			`/* We don't actually deal with the H case here, we just`
445			`* match it and allow it through.`
446			`*/`
447			`break;`
448			`}`
449
450			`if (continue_from == -1) return;`
451			`i = continue_from;`
452			`break;`
453			`}`
454			`}`
455			`} while (1);`
456			`return; /* Will never get here */`
457			`}`
458
459			`extern int Unix_IsParallelInUse(void)`
460			`{`
461			`if (parpfd >= 0)`
462			`return -1;`
463
464			`return 0;`
465			`}`
466
467			`extern int Unix_OpenParallel(const char *name)`
468			`{`
469			`#if defined(BSD)`
470			`parpfd = open(name, O_RDWR);`
471			`#else`
472			`parpfd = open(name, O_RDWR \| O_NONBLOCK);`
473			`#endif`
474
475			`if (parpfd < 0)`
476			`{`
477			`char errbuf[256];`
478
479			`sprintf(errbuf, "open %s", name);`
480			`perror(errbuf);`
481
482			`return -1;`
483			`}`
484
485			`return 0;`
486			`}`
487
488			`extern void Unix_CloseParallel(void)`
489			`{`
490			`if (parpfd >= 0)`
491			`{`
492			`(void)close(parpfd);`
493			`parpfd = -1;`
494			`}`
495			`}`
496
497
498			`extern unsigned int Unix_WriteParallel(unsigned char *buf, int n)`
499			`{`
500			`int ngone;`
501
502			`if ((ngone = write(parpfd, buf, n)) < 0)`
503			`{`
504			`/*`
505			`* we ignore errors (except for debug purposes)`
506			`*/`
507			`#ifdef DEBUG`
508			`char errbuf[256];`
509
510			`sprintf(errbuf, "send_packet: write");`
511			`perror(errbuf);`
512			`#endif`
513			`ngone = 0;`
514			`}`
515
516			`/* finished */`
517			`return (unsigned int)ngone;`
518			`}`
519
520
521			`#ifdef sun`
522			`extern void Unix_ResetParallel(void)`
523			`{`
524			`struct bpp_transfer_parms tp;`
525
526			`#ifdef DEBUG`
527			`printf("serpar_reset\n");`
528			`#endif`
529
530			`/*`
531			`* we need to set the parallel port up for BUSY handshaking,`
532			`* and select the timeout`
533			`*/`
534			`if (ioctl(parpfd, BPPIOC_GETPARMS, &tp) < 0)`
535			`{`
536			`#ifdef DEBUG`
537			`perror("ioctl(BPPIOCGETPARMS)");`
538			`#endif`
539			`panic("serpar_reset: cannot get BPP parameters");`
540			`}`
541
542			`tp.write_handshake = BPP_BUSY_HS;`
543			`tp.write_timeout = PP_TIMEOUT;`
544
545			`if (ioctl(parpfd, BPPIOC_SETPARMS, &tp) < 0)`
546			`{`
547			`#ifdef DEBUG`
548			`perror("ioctl(BPPIOC_SETPARMS)");`
549			`#endif`
550			`panic("serpar_reset: cannot set BPP parameters");`
551			`}`
552			`}`
553
554			`#else`
555
556			`/* Parallel not supported on HP */`
557
558			`extern void Unix_ResetParallel(void)`
559			`{`
560			`}`
561
562			`#endif`
563