[binutils.git] / gdb / rdi-share / unixcomm.c

/* 
 * Copyright (C) 1995 Advanced RISC Machines Limited. All rights reserved.
 * 
 * This software may be freely used, copied, modified, and distributed
 * provided that the above copyright notice is preserved in all copies of the
 * software.
 */

/* -*-C-*-
 *
 * $Revision$
 *     $Date$
 *
 */

#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 (__FreeBSD__) || defined (__NetBSD__) || defined (__OpenBSD__) || defined (bsdi)
#define SERIAL_PREFIX "/dev/cuaa"
#define SERPORT1   "/dev/cuaa0"
#define SERPORT2   "/dev/cuaa1"
#define PARPORT1   "/dev/lpt0"
#define PARPORT2   "/dev/lpt1"
#endif


#if defined(_WIN32) || defined (__CYGWIN32__) 
#define SERIAL_PREFIX "com"
#define SERPORT1   "com1"
#define SERPORT2   "com2"
#define PARPORT1   "lpt1"
#define PARPORT2   "lpt2"
#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(__CYGWIN32__)
    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
Commit	Line	Data
c906108c SS	1	/*
	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$
	12	* $Date$
	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
608d5915 FN	39	#if defined (__FreeBSD__) \|\| defined (__NetBSD__) \|\| defined (__OpenBSD__) \|\| defined (bsdi)
	40	#undef BSD
	41	#include <sys/ioctl.h>
	42	#endif
	43
c906108c SS	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
0d06e24b	76	#define SERIAL_PREFIX "/dev/tty"
c906108c SS	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
0d06e24b	84	#define SERIAL_PREFIX "/dev/tty"
c906108c SS	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__
0d06e24b	92	#define SERIAL_PREFIX "/dev/ttyS"
adf40b2e JM	93	#define SERPORT1 "/dev/ttyS0"
adf40b2e JM	94	#define SERPORT2 "/dev/ttyS1"
c906108c SS	95	#define PARPORT1 "/dev/par0"
	96	#define PARPORT2 "/dev/par1"
	97	#endif
	98
	99	#if defined (__FreeBSD__) \|\| defined (__NetBSD__) \|\| defined (__OpenBSD__) \|\| defined (bsdi)
0d06e24b	100	#define SERIAL_PREFIX "/dev/cuaa"
c906108c SS	101	#define SERPORT1 "/dev/cuaa0"
	102	#define SERPORT2 "/dev/cuaa1"
	103	#define PARPORT1 "/dev/lpt0"
	104	#define PARPORT2 "/dev/lpt1"
	105	#endif
	106
	107
c906108c	108	#if defined(_WIN32) \|\| defined (__CYGWIN32__)
0d06e24b	109	#define SERIAL_PREFIX "com"
c906108c SS	110	#define SERPORT1 "com1"
	111	#define SERPORT2 "com2"
	112	#define PARPORT1 "lpt1"
	113	#define PARPORT2 "lpt2"
c906108c SS	114	#endif
	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(__CYGWIN32__)
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	}
608d5915 FN	261	#ifdef TIOCEXCL
	262	if (ioctl(serpfd, TIOCEXCL) < 0) {
	263	close(serpfd);
	264	perror("ioctl: TIOCEXCL");
	265	return -1;
	266	}
	267	#endif
c906108c SS	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))
5c44784c JM	304	{
	305	int s;
	306
	307	s = read(serpfd, buf, n);
	308	if (s < 0)
	309	perror("read:");
	310	return s;
	311	}
c906108c SS	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);
c906108c SS	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;
c906108c SS	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