gdb/ser-go32.c

   1 /* Remote serial interface for local (hardwired) serial ports for GO32.
   2    Copyright 1992, 1993 Free Software Foundation, Inc.
   3
   4 This file is part of GDB.
   5
   6 This program is free software; you can redistribute it and/or modify
   7 it under the terms of the GNU General Public License as published by
   8 the Free Software Foundation; either version 2 of the License, or
   9 (at your option) any later version.
  10
  11 This program is distributed in the hope that it will be useful,
  12 but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14 GNU General Public License for more details.
  15
  16 You should have received a copy of the GNU General Public License
  17 along with this program; if not, write to the Free Software
  18 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */
  19
  20 #include "defs.h"
  21 #include "serial.h"
  22 #include <sys/dos.h>
  23
  24 /* This is unused for now.  We just return a placeholder. */
  25 struct go32_ttystate
  26 {
  27   int bogus;
  28 };
  29
  30 static int go32_open PARAMS ((serial_t scb, const char *name));
  31 static void go32_raw PARAMS ((serial_t scb));
  32 static int wait_for PARAMS ((serial_t scb, int timeout));
  33 static int go32_readchar PARAMS ((serial_t scb, int timeout));
  34 static int rate_to_code PARAMS ((int rate));
  35 static int go32_setbaudrate PARAMS ((serial_t scb, int rate));
  36 static int go32_write PARAMS ((serial_t scb, const char *str, int len));
  37 static void go32_restore PARAMS ((serial_t scb));
  38 static void go32_close PARAMS ((serial_t scb));
  39 serial_ttystate go32_get_tty_state PARAMS ((serial_t scb));
  40 static int go32_set_tty_state PARAMS ((serial_t scb, serial_ttystate state));
  41 static int strncasecmp PARAMS ((char *str1, char *str2, int len));
  42 static char *aptr PARAMS ((short p));
  43 static ASYNC_STRUCT *getivec PARAMS ((int which));
  44 static int dos_async_init PARAMS ((int port));
  45 static void dos_async_tx PARAMS ((const char c));
  46 static int dos_async_ready PARAMS (());
  47 static int dos_async_rx PARAMS (());
  48 static int dosasync_read PARAMS ((int fd, char *buf, int len, int timeout));
  49 static int dosasync_write PARAMS ((int fd, const char *buf, int len, int timeout));
  50
  51 #define SIGNATURE 0x4154
  52 #define VERSION 1
  53 #define OFFSET 0x104
  54
  55 #define peek(a,b) (*(unsigned short *)(0xe0000000 + (a)*16 + (b)))
  56
  57 typedef struct {
  58   short jmp_op;
  59   short signature;
  60   short version;
  61   short buffer_start;
  62   short buffer_end;
  63   short getp;
  64   short putp;
  65   short iov;
  66 } ASYNC_STRUCT;
  67
  68 static ASYNC_STRUCT *async;
  69 static int iov;
  70 #define com_rb  iov
  71 #define com_tb  iov
  72 #define com_ier iov+1
  73 #define com_ifr iov+2
  74 #define com_bfr iov+3
  75 #define com_mcr iov+4
  76 #define com_lsr iov+5
  77 #define com_msr iov+6
  78
  79 static int
  80 strncasecmp(str1, str2, len)
  81      char *str1, *str2;
  82      register int len;
  83 {
  84   unsigned char c1, c2;
  85
  86   for (; len != 0; --len)
  87     {
  88       c1 = *str1++;
  89       c2 = *str2++;
  90
  91       if (toupper(c1) != toupper(c2))
  92         return toupper(c1) - toupper(c2);
  93
  94       if (c1 == '\0')
  95         return 0;
  96     }
  97   return 0;
  98 }
  99
 100 static char *
 101 aptr(p)
 102      short p;
 103 {
 104   return (char *)((unsigned)async - OFFSET + p);
 105 }
 106
 107 static ASYNC_STRUCT *
 108 getivec(int which)
 109 {
 110   ASYNC_STRUCT *a;
 111
 112   if (peek(0, which*4) != OFFSET)
 113     return 0;
 114
 115   a = (ASYNC_STRUCT *)(0xe0000000 + peek(0, which*4+2)*16 + peek(0, which*4));
 116
 117   if (a->signature != SIGNATURE)
 118     return 0;
 119
 120   if (a->version != VERSION)
 121     return 0;
 122
 123   return a;
 124 }
 125
 126 static int
 127 dos_async_init(port)
 128      int port;
 129 {
 130   int i;
 131
 132   switch (port)
 133     {
 134     case 1:
 135       async = getivec (12);
 136       break;
 137     case 2:
 138       async = getivec (11);
 139       break;
 140     default:
 141       return 0;
 142     }
 143
 144   if (!async)
 145     {
 146       error("GDB can not connect to asynctsr program, check that it is installed\n\
 147 and that serial I/O is not being redirected (perhaps by NFS)\n\n\
 148 example configuration:\n\
 149 C> mode com2:9600,n,8,1,p\n\
 150 C> asynctsr 2\n\
 151 C> gdb \n");
 152
 153     }
 154
 155   iov = async->iov;
 156   outportb(com_ier, 0x0f);
 157   outportb(com_bfr, 0x03);
 158   outportb(com_mcr, 0x0b);
 159   async->getp = async->putp = async->buffer_start;
 160
 161   return 1;
 162 }
 163
 164 static void
 165 dos_async_tx(c)
 166      const char c;
 167 {
 168   while (~inportb(com_lsr) & 0x20);
 169
 170   outportb(com_tb, c);
 171 }
 172
 173 static int
 174 dos_async_ready()
 175 {
 176   return (async->getp != async->putp);
 177 }
 178
 179 static int
 180 dos_async_rx()
 181 {
 182   char rv;
 183
 184   while (!dos_async_ready())
 185     if (kbhit())
 186       {
 187         printf("abort!\n");
 188         return 0;
 189       }
 190
 191   rv = *aptr(async->getp++);
 192   if (async->getp >= async->buffer_end)
 193     async->getp = async->buffer_start;
 194
 195   return rv;
 196 }
 197
 198 static int
 199 dosasync_read (fd, buf, len, timeout)
 200      int fd;
 201      char *buf;
 202      int len;
 203      int timeout;
 204 {
 205   long now, then;
 206   int l = len;
 207
 208   time (&now);
 209   then = now + timeout;
 210
 211   while (l--)
 212     {
 213       if (timeout)
 214         {
 215           while (!dos_async_ready())
 216             {
 217               time (&now);
 218               if (now >= then)
 219                 return len - l - 1;
 220             }
 221         }
 222       *buf++ = dos_async_rx();
 223     }
 224
 225   return len;
 226 }
 227
 228 static int
 229 dosasync_write(fd, buf, len)
 230      int fd;
 231      const char *buf;
 232      int len;
 233 {
 234   int l = len;
 235
 236   while (l--)
 237     dos_async_tx (*buf++);
 238
 239   return len;
 240 }
 241
 242 static int
 243 go32_open (scb, name)
 244      serial_t scb;
 245      const char *name;
 246 {
 247   int port;
 248
 249   if (strncasecmp (name, "com", 3) != 0)
 250     {
 251       errno = ENOENT;
 252       return -1;
 253     }
 254
 255   port = name[3] - '0';
 256
 257   if ((port != 1) && (port != 2))
 258     {
 259       errno = ENOENT;
 260       return -11;
 261     }
 262
 263   scb->fd = dos_async_init(port);
 264   if (!scb->fd)
 265     return -1;
 266
 267   return 0;
 268 }
 269
 270 static void
 271 go32_raw (scb)
 272      serial_t scb;
 273 {
 274   /* Always in raw mode */
 275 }
 276
 277 static int
 278 go32_readchar (scb, timeout)
 279      serial_t scb;
 280      int timeout;
 281 {
 282   char buf;
 283
 284   if (dosasync_read(scb->fd, &buf, 1, timeout))
 285     return buf;
 286   else
 287     return SERIAL_TIMEOUT;
 288 }
 289
 290 /* go32_{get set}_tty_state() are both dummys to fill out the function
 291    vector.  Someday, they may do something real... */
 292
 293 static serial_ttystate
 294 go32_get_tty_state(scb)
 295      serial_t scb;
 296 {
 297   struct go32_ttystate *state;
 298
 299   state = (struct go32_ttystate *)xmalloc(sizeof *state);
 300
 301   return (serial_ttystate)state;
 302 }
 303
 304 static int
 305 go32_set_tty_state(scb, ttystate)
 306      serial_t scb;
 307      serial_ttystate ttystate;
 308 {
 309   struct go32_ttystate *state;
 310
 311   return 0;
 312 }
 313
 314 static int
 315 go32_setbaudrate (scb, rate)
 316      serial_t scb;
 317      int rate;
 318 {
 319   return 0;
 320 }
 321
 322 static int
 323 go32_write (scb, str, len)
 324      serial_t scb;
 325      const char *str;
 326      int len;
 327 {
 328   dosasync_write(scb->fd, str, len);
 329
 330   return 0;
 331 }
 332
 333 static void
 334 go32_close ()
 335 {
 336 }
 337
 338 static struct serial_ops go32_ops =
 339 {
 340   "hardwire",
 341   0,
 342   go32_open,
 343   go32_close,
 344   go32_readchar,
 345   go32_write,
 346   go32_raw,
 347   go32_get_tty_state,
 348   go32_set_tty_state,
 349   go32_setbaudrate
 350 };
 351
 352 _initialize_ser_go32 ()
 353 {
 354   serial_add_interface (&go32_ops);
 355 }