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 typedef struct {
  31   short jmp_op;
  32   short signature;
  33   short version;
  34   short buffer_start;
  35   short buffer_end;
  36   short getp;
  37   short putp;
  38   short iov;
  39 } ASYNC_STRUCT;
  40
  41 static int go32_open PARAMS ((serial_t scb, const char *name));
  42 static void go32_raw PARAMS ((serial_t scb));
  43 static int wait_for PARAMS ((serial_t scb, int timeout));
  44 static int go32_readchar PARAMS ((serial_t scb, int timeout));
  45 static int rate_to_code PARAMS ((int rate));
  46 static int go32_setbaudrate PARAMS ((serial_t scb, int rate));
  47 static int go32_write PARAMS ((serial_t scb, const char *str, int len));
  48 static void go32_restore PARAMS ((serial_t scb));
  49 static void go32_close PARAMS ((serial_t scb));
  50 static serial_ttystate go32_get_tty_state PARAMS ((serial_t scb));
  51 static int go32_set_tty_state PARAMS ((serial_t scb, serial_ttystate state));
  52 static int strncasecmp PARAMS ((const char *str1, const char *str2, int len));
  53 static char *aptr PARAMS ((short p));
  54 static ASYNC_STRUCT *getivec PARAMS ((int which));
  55 static int dos_async_init PARAMS ((int port));
  56 static void dos_async_tx PARAMS ((const char c));
  57 static int dos_async_ready PARAMS (());
  58 static int dos_async_rx PARAMS (());
  59 static int dosasync_read PARAMS ((int fd, char *buf, int len, int timeout));
  60 static int dosasync_write PARAMS ((int fd, const char *buf, int len));
  61
  62 #define SIGNATURE 0x4154
  63 #define VERSION 1
  64 #define OFFSET 0x104
  65
  66 #define peek(a,b) (*(unsigned short *)(0xe0000000 + (a)*16 + (b)))
  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      const 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 cannot 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 com%d:9600,n,8,1,p\n\
 150 C> asynctsr %d\n\
 151 C> gdb \n", port, port);
 152     }
 153
 154   iov = async->iov;
 155   outportb(com_ier, 0x0f);
 156   outportb(com_bfr, 0x03);
 157   outportb(com_mcr, 0x0b);
 158   async->getp = async->putp = async->buffer_start;
 159
 160   return 1;
 161 }
 162
 163 static void
 164 dos_async_tx(c)
 165      const char c;
 166 {
 167   while (~inportb(com_lsr) & 0x20);
 168
 169   outportb(com_tb, c);
 170 }
 171
 172 static int
 173 dos_async_ready()
 174 {
 175   return (async->getp != async->putp);
 176 }
 177
 178 static int
 179 dos_async_rx()
 180 {
 181   char rv;
 182
 183   while (!dos_async_ready())
 184     if (kbhit())
 185       {
 186         printf("abort!\n");
 187         return 0;
 188       }
 189
 190   rv = *aptr(async->getp++);
 191   if (async->getp >= async->buffer_end)
 192     async->getp = async->buffer_start;
 193
 194   return rv;
 195 }
 196
 197 static int
 198 dosasync_read (fd, buf, len, timeout)
 199      int fd;
 200      char *buf;
 201      int len;
 202      int timeout;
 203 {
 204   long now, then;
 205   int l = len;
 206
 207   time (&now);
 208   then = now + timeout;
 209
 210   while (l--)
 211     {
 212       if (timeout)
 213         {
 214           while (!dos_async_ready())
 215             {
 216               time (&now);
 217               if (now >= then)
 218                 return len - l - 1;
 219             }
 220         }
 221       *buf++ = dos_async_rx();
 222     }
 223
 224   return len;
 225 }
 226
 227 static int
 228 dosasync_write(fd, buf, len)
 229      int fd;
 230      const char *buf;
 231      int len;
 232 {
 233   int l = len;
 234
 235   while (l--)
 236     dos_async_tx (*buf++);
 237
 238   return len;
 239 }
 240
 241 static int
 242 go32_open (scb, name)
 243      serial_t scb;
 244      const char *name;
 245 {
 246   int port;
 247
 248   if (strncasecmp (name, "com", 3) != 0)
 249     {
 250       errno = ENOENT;
 251       return -1;
 252     }
 253
 254   port = name[3] - '0';
 255
 256   if ((port != 1) && (port != 2))
 257     {
 258       errno = ENOENT;
 259       return -11;
 260     }
 261
 262   scb->fd = dos_async_init(port);
 263   if (!scb->fd)
 264     return -1;
 265
 266   return 0;
 267 }
 268
 269 static int
 270 go32_noop (scb)
 271      serial_t scb;
 272 {
 273   return 0;
 274 }
 275
 276 static void
 277 go32_raw (scb)
 278      serial_t scb;
 279 {
 280   /* Always in raw mode */
 281 }
 282
 283 static int
 284 go32_readchar (scb, timeout)
 285      serial_t scb;
 286      int timeout;
 287 {
 288   char buf;
 289
 290   if (dosasync_read(scb->fd, &buf, 1, timeout))
 291     return buf;
 292   else
 293     return SERIAL_TIMEOUT;
 294 }
 295
 296 /* go32_{get set}_tty_state() are both dummys to fill out the function
 297    vector.  Someday, they may do something real... */
 298
 299 static serial_ttystate
 300 go32_get_tty_state(scb)
 301      serial_t scb;
 302 {
 303   struct go32_ttystate *state;
 304
 305   state = (struct go32_ttystate *)xmalloc(sizeof *state);
 306
 307   return (serial_ttystate)state;
 308 }
 309
 310 static int
 311 go32_set_tty_state(scb, ttystate)
 312      serial_t scb;
 313      serial_ttystate ttystate;
 314 {
 315   struct go32_ttystate *state;
 316
 317   return 0;
 318 }
 319
 320 static int
 321 go32_noflush_set_tty_state (scb, new_ttystate, old_ttystate)
 322      serial_t scb;
 323      serial_ttystate new_ttystate;
 324      serial_ttystate old_ttystate;
 325 {
 326   return 0;
 327 }
 328
 329 static void
 330 go32_print_tty_state (scb, ttystate)
 331      serial_t scb;
 332      serial_ttystate ttystate;
 333 {
 334   /* Nothing to print.  */
 335   return;
 336 }
 337
 338 static int
 339 go32_setbaudrate (scb, rate)
 340      serial_t scb;
 341      int rate;
 342 {
 343   return 0;
 344 }
 345
 346 static int
 347 go32_write (scb, str, len)
 348      serial_t scb;
 349      const char *str;
 350      int len;
 351 {
 352   dosasync_write(scb->fd, str, len);
 353
 354   return 0;
 355 }
 356
 357 static void
 358 go32_close (scb)
 359      serial_t scb;
 360 {
 361 }
 362
 363 static struct serial_ops go32_ops =
 364 {
 365   "hardwire",
 366   0,
 367   go32_open,
 368   go32_close,
 369   go32_readchar,
 370   go32_write,
 371   go32_noop, /* flush output */
 372   go32_noop, /* flush input */
 373   go32_noop, /* send break -- currently used only for nindy */
 374   go32_raw,
 375   go32_get_tty_state,
 376   go32_set_tty_state,
 377   go32_print_tty_state,
 378   go32_noflush_set_tty_state,
 379   go32_setbaudrate,
 380 };
 381
 382 _initialize_ser_go32 ()
 383 {
 384   serial_add_interface (&go32_ops);
 385 }