* ser-go32.c: First cut at adapting to new serial interface.

1 files changed, 108 insertions, 173 deletions

diff --git a/gdb/ser-go32.c b/gdb/ser-go32.c
index 195f1d2..e2b3a93 100644
--- a/gdb/ser-go32.c
+++ b/gdb/ser-go32.c
@@ -1,5 +1,5 @@
-/* Remote serial interface for GO32, for GDB, the GNU Debugger.
-   Copyright 1992 Free Software Foundation, Inc.
+/* Remote serial interface for local (hardwired) serial ports for GO32.
+   Copyright 1992, 1993 Free Software Foundation, Inc.
 
 This file is part of GDB.
 
@@ -17,30 +17,15 @@ You should have received a copy of the GNU General Public License
 along with this program; if not, write to the Free Software
 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */
 
-/* This file shows most of the obvious problems of code written for
-   the IBM PC.  FIXME.    -- gnu@cygnus.com, Sep92 */
-
 #include "defs.h"
-
-/* dummy */
-struct ttystate;  
-
 #include "serial.h"
-
 #include <sys/dos.h>
 
 #define SIGNATURE 0x4154
 #define VERSION 1
 #define OFFSET 0x104
 
-/*#define MONO 1*/
-
-#define dprintf if(0)printf
-
-#ifdef __GNUC__
-#define far
 #define peek(a,b) (*(unsigned short *)(0xe0000000 + (a)*16 + (b)))
-#endif
 
 typedef struct {
   short jmp_op;
@@ -53,7 +38,7 @@ typedef struct {
   short iov;
 } ASYNC_STRUCT;
 
-static ASYNC_STRUCT far *async;
+static ASYNC_STRUCT *async;
 static int iov;
 #define com_rb	iov
 #define com_tb	iov
@@ -66,46 +51,22 @@ static int iov;
 
 static int fd;
 
-
-#if MONO
-#include <sys/pc.h>
-static int mono_pos=0;
-#define mono_rx 0x07
-#define mono_tx 0x70
-
-void
-mono_put(char byte, char attr)
+static char *
+aptr(p)
+     short p;
 {
-  ScreenSecondary[320+mono_pos+80] = 0x0720;
-  ScreenSecondary[320+mono_pos] = (attr<<8) | (byte&0xff);
-  mono_pos = (mono_pos+1) % 1200;
-}
-
-#endif
-
-static char far *
-aptr(short p)
-{
-#ifdef __GNUC__
   return (char *)((unsigned)async - OFFSET + p);
-#else
-  return (char far *)MK_FP(FP_SEG(async), p);
-#endif
 }
 
-static ASYNC_STRUCT far *
+static ASYNC_STRUCT *
 getivec(int which)
 {
-  ASYNC_STRUCT far *a;
+  ASYNC_STRUCT *a;
 
   if (peek(0, which*4) != OFFSET)
     return 0;
-#ifdef __GNUC__
   a = (ASYNC_STRUCT *)(0xe0000000 + peek(0, which*4+2)*16 + peek(0, which*4));
 
-#else
-  a = (ASYNC_STRUCT far *)MK_FP(peek(0,which*4+2),peek(0,which*4));
-#endif
   if (a->signature != SIGNATURE)
     return 0;
   if (a->version != VERSION)
@@ -113,12 +74,12 @@ getivec(int which)
   return a;
 }
 
-int
+static int
 dos_async_init()
 {
   int i;
-  ASYNC_STRUCT far *a1;
-  ASYNC_STRUCT far *a2;
+  ASYNC_STRUCT *a1;
+  ASYNC_STRUCT *a2;
   a1 = getivec(12);
   a2 = getivec(11);
   async = 0;
@@ -149,190 +110,164 @@ C> gdb \n");
   outportb(com_mcr, 0x0b);
   async->getp = async->putp = async->buffer_start;
   
-#if MONO
-  for (i=0; i<1200; i++)
-    ScreenSecondary[320+i] = 0x0720;
-#endif
   if (iov > 0x300)
     return 1;
   else
     return 2;
 }
 
-void
-dos_async_tx(char c)
+static void
+dos_async_tx(c)
+     const char c;
 {
-  dprintf("dos_async_tx: enter %x - with IOV %x", c, com_lsr);
-  fflush(stdout);
   while (~inportb(com_lsr) & 0x20);
+
   outportb(com_tb, c);
-#if MONO
-  mono_put(c, mono_tx);
-#endif
-  dprintf("exit\n");
 }
 
-int
+static int
 dos_async_ready()
 {
   return (async->getp != async->putp);
 }
 
-int
+static int
 dos_async_rx()
 {
   char rv;
-  dprintf("dos_async_rx: enter - ");
-  fflush(stdout);
+
   while (!dos_async_ready())
-   if (kbhit())
-   {
-     printf("abort!\n");
-     return 0;
-   }
-  dprintf("async=%x getp=%x\n", async, async->getp);
-  fflush(stdout);
+    if (kbhit())
+      {
+	printf("abort!\n");
+	return 0;
+      }
+
   rv = *aptr(async->getp++);
-#if MONO
-  mono_put(rv, mono_rx);
-#endif
   if (async->getp >= async->buffer_end)
-   async->getp = async->buffer_start;
-  dprintf("exit %x\n", rv);
-  return rv;
-}
-
-int
-dos_kb_ready()
-{
-  return (peek(0x40,0x1a) != peek(0x40,0x1c));
-}
+    async->getp = async->buffer_start;
 
-int
-dos_kb_rx()
-{
-#ifdef __GNUC__
-  return getkey();
-#else
-  return getch();
-#endif
+  return rv;
 }
 
-int
-dosasync_read (int fd, char *buffer, int length, int timeout)
+static int
+dosasync_read (fd, buf, len, timeout)
+     int fd;
+     char *buf;
+     int len;
+     int timeout;
 {
   long now, then;
-  int l = length;
+  int l = len;
+
   time (&now);
-  then = now+timeout;
-  dprintf("dosasync_read: enter(%d,%d)\n", length, timeout);
+  then = now + timeout;
+
   while (l--)
-  {
-    if (timeout)
     {
-      while (!dos_async_ready())
-      {
-        time (&now);
-        if (now == then)
-        {
-          dprintf("dosasync_read: timeout(%d)\n", length-l-1);
-          return length-l-1;
-        }
-      }
+      if (timeout)
+	{
+	  while (!dos_async_ready())
+	    {
+	      time (&now);
+	      if (now >= then)
+		return len - l - 1;
+	    }
+	}
+      *buf++ = dos_async_rx();
     }
-    *buffer++ = dos_async_rx();
-  }
-  dprintf("dosasync_read: exit %d\n", length);
-  return length;
-}
 
-int
-dosasync_write(int fd, const char *buffer, int length)
-{
-  int l = length;
-  while (l--)
-   dos_async_tx(*buffer++);
-  return length;
+  return len;
 }
 
+static int
+dosasync_write(fd, buf, len)
+     int fd;
+     const char *buf;
+     int len;
+{
+  int l = len;
 
+  while (l--)
+    dos_async_tx (*buf++);
 
-char *
-strlwr(char *s)
-{
-  char *p = s;
-  while (*s)
-  {
-    if ((*s >= 'A') && (*s <= 'Z'))
-      *s += 'a'-'A';
-    s++;
-  }
-  return p;
+  return len;
 }
 
-sigsetmask()
+static int
+go32_open (scb, name)
+     serial_t scb;
+     const char *name;
 {
-}
-
-const char *
-serial_default_name ()
-{
-  return "com1";
-}
-
+  scb->fd = dos_async_init();
+  if (scb->fd)
+    return 1;
 
-void
-serial_raw (fd, old)
-int fd;
-struct ttystate *old;
-{
-  /* Always in raw mode */
+  return 0;
 }
 
-
-int
-serial_open (name)
-      const char *name;
+static void
+go32_raw (scb)
+     serial_t scb;
 {
-  fd = dos_async_init();
-  if (fd) return 1;
-  return 0;
+  /* Always in raw mode */
 }
 
-int
-serial_readchar (to)
-      int to;
+static int
+go32_readchar (scb, timeout)
+     serial_t scb;
+     int timeout;
 {
   char buf;
-  if (dosasync_read(fd, &buf, 1, to))  
+
+  if (dosasync_read(scb->fd, &buf, 1, timeout))  
     return buf;
   else
     return -2; /* Timeout, I guess */
 }
 
-int
-serial_setbaudrate (rate)
-      int rate;
+static int
+go32_setbaudrate (scb, rate)
+     serial_t scb;
+     int rate;
 {
   return 0;
 }
 
-int
-serial_nextbaudrate (rate)
-      int rate;
+static int
+go32_write (scb, str, len)
+     serial_t scb;
+     const char *str;
+     int len;
+{
+  dosasync_write(scb->fd, str, len);
+}
+
+static void
+go32_close ()
 {
-  return 0;
 }
 
-int
-serial_write (str, len)
-      const char *str;
-      int len;
+static void
+go32_restore (scb)
+     serial_t scb;
 {
-  dosasync_write(fd, str, len);
 }
 
-void
-serial_close ()
+static struct serial_ops go32_ops =
+{
+  "hardwire",
+  0,
+  go32_open,
+  go32_close,
+  go32_readchar,
+  go32_write,
+  go32_raw,
+  go32_restore,
+  go32_setbaudrate
+};
+
+_initialize_ser_go32 ()
 {
+  serial_add_interface (&go32_ops);
 }