home *** CD-ROM | disk | FTP | other *** search
/ Il CD di internet / CD.iso / SOURCE / D / GDB / GDB-4.13 / GDB-4 / gdb-4.13 / gdb / ser-go32.c < prev    next >
Encoding:
C/C++ Source or Header  |  1994-06-29  |  8.1 KB  |  424 lines
  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. #define disable() asm("cli")
  25. #define enable() asm("sti")
  26.  
  27. struct go32_ttystate
  28.   {
  29.     int bogus;
  30.   };
  31. typedef struct
  32.   {
  33.     short jmp_op;
  34.     short signature;
  35.     short version;
  36.     short buffer_start;
  37.     short buffer_end;
  38.     short getp;
  39.     short putp;
  40.     short iov;
  41.     short count;
  42.     short overflow;
  43.     short buffer_size;
  44.     short ovflushes;
  45.   }
  46. ASYNC_STRUCT;
  47.  
  48. #define AOFF_JMP_OP         0
  49. #define AOFF_SIGNATURE         2
  50. #define AOFF_VERSION         4
  51. #define AOFF_BUFFER_START     6
  52. #define AOFF_BUFFER_END     8
  53. #define AOFF_GETP         10
  54. #define AOFF_PUTP         12
  55. #define AOFF_IOV         14
  56. #define AOFF_COUNT         16
  57. #define AOFF_OVERFLOW         18
  58. #define AOFF_BUFFER_SIZE     20
  59. #define AOFF_OVFLUSHES         22
  60.  
  61.  
  62. static ASYNC_STRUCT a;        /* Copy in our mem of the struct */
  63. static long aindex;        /* index into dos space of struct */
  64.  
  65. static int go32_open PARAMS ((serial_t scb, const char *name));
  66. static void go32_raw PARAMS ((serial_t scb));
  67. static int go32_readchar PARAMS ((serial_t scb, int timeout));
  68. static int go32_setbaudrate PARAMS ((serial_t scb, int rate));
  69. static int go32_write PARAMS ((serial_t scb, const char *str, int len));
  70. static void go32_close PARAMS ((serial_t scb));
  71. static serial_ttystate go32_get_tty_state PARAMS ((serial_t scb));
  72. static int go32_set_tty_state PARAMS ((serial_t scb, serial_ttystate state));
  73. static unsigned char aptr PARAMS ((short p));
  74. static unsigned long getivec PARAMS ((int which));
  75. static int dos_async_init PARAMS ((int port));
  76. static void dos_async_tx PARAMS ((const char c));
  77. static int dos_async_rx PARAMS (());
  78. static int dosasync_read PARAMS ((int fd, char *buf, int len, int timeout));
  79. static int dosasync_write PARAMS ((int fd, const char *buf, int len));
  80.  
  81. #define SIGNATURE 0x4154
  82. #define VERSION 1
  83. #define OFFSET 0x104
  84.  
  85. unsigned char bb;
  86. unsigned short sb;
  87. unsigned long sl;
  88.  
  89. #define SET_BYTE(x,y)   { char _buf = y;dosmemput(&_buf,1, x);}
  90. #define SET_WORD(x,y)   { short _buf = y;dosmemput(&_buf,2, x);}
  91. #define GET_BYTE(x)     ( dosmemget((x),1,&bb), bb)
  92.  
  93.  
  94. #define GET_LONG(x)     ( dosmemget((x),4,&sl), sl)
  95.  
  96. static
  97. unsigned short 
  98. GET_WORD (x)
  99. {
  100.   unsigned short sb;
  101.   dosmemget ((x), 2, &sb);
  102.   return sb;
  103. }
  104.  
  105. static int iov[2];
  106.  
  107. #define com_rb(n)    iov[n]
  108. #define com_tb(n)    iov[n]
  109. #define com_ier(n)    iov[n]+1
  110. #define com_ifr(n)    iov[n]+2
  111. #define com_bfr(n)    iov[n]+3
  112. #define com_mcr(n)    iov[n]+4
  113. #define com_lsr(n)    iov[n]+5
  114. #define com_msr(n)    iov[n]+6
  115.  
  116. static unsigned char
  117. aptr (p)
  118.      short p;
  119. {
  120.   return GET_BYTE (aindex - OFFSET + p);
  121. }
  122.  
  123. static unsigned long
  124. getivec (int which)
  125. {
  126.   long tryaindex;
  127.  
  128.   if (GET_WORD (which * 4) != OFFSET)
  129.     return 0;
  130.  
  131.   /* Find out where in memory this lives */
  132.   tryaindex = GET_WORD (which * 4 + 2) * 16 + GET_WORD (which * 4);
  133.  
  134.   if (GET_WORD (tryaindex + 2) != SIGNATURE)
  135.     return 0;
  136.   if (GET_WORD (tryaindex + 4) != VERSION)
  137.     return 0;
  138.   return tryaindex;
  139. }
  140.  
  141. static int
  142. dos_async_init (port)
  143.      int port;
  144. {
  145.   switch (port)
  146.     {
  147.     case 1:
  148.       aindex = getivec (12);
  149.       break;
  150.     case 2:
  151.       aindex = getivec (11);
  152.       break;
  153.     default:
  154.       return 0;
  155.     }
  156.  
  157.   if (!aindex)
  158.     {
  159.       error ("GDB cannot connect to asynctsr program, check that it is installed\n\
  160. and that serial I/O is not being redirected (perhaps by NFS)\n\n\
  161. example configuration:\n\
  162. C> mode com%d:9600,n,8,1,p\n\
  163. C> asynctsr %d\n\
  164. C> gdb \n", port, port);
  165.     }
  166.  
  167.   iov[0] = GET_WORD (aindex + AOFF_IOV);
  168.   outportb (com_ier (0), 0x0f);
  169.   outportb (com_bfr (0), 0x03);
  170.   outportb (com_mcr (0), 0x0b);
  171.   return 1;
  172. }
  173.  
  174. static void
  175. dos_async_tx (c)
  176.      const char c;
  177. {
  178.   while (~inportb (com_lsr (0)) & 0x20)
  179.     ;
  180.   outportb (com_tb (0), c);
  181. }
  182.  
  183. static int
  184. dos_async_ready ()
  185. {
  186.   int ret;
  187.  
  188.   disable ();
  189. #if RDY_CNT
  190.   ret = GET_WORD (aindex + AOFF_COUNT);
  191. #else
  192.   ret = GET_WORD (aindex + AOFF_GETP) != GET_WORD (aindex + AOFF_PUTP);
  193. #endif
  194.   enable ();
  195.   return ret;
  196.  
  197.  
  198. }
  199.  
  200. static int
  201. dos_async_rx ()
  202. {
  203.   char rv;
  204.   short idx;
  205.  
  206.   while (!dos_async_ready ())
  207.     {
  208.       if (kbhit ())
  209.     {
  210.       printf_unfiltered ("abort!\n");
  211.       return 0;
  212.     }
  213.     }
  214.   disable ();
  215.   idx = GET_WORD (aindex + AOFF_GETP);
  216.   idx++;
  217.   SET_WORD (aindex + AOFF_GETP, idx);
  218.   rv = aptr (idx - 1);
  219.   SET_WORD (aindex + AOFF_COUNT, GET_WORD (aindex + AOFF_COUNT) - 1);
  220.   if (GET_WORD (aindex + AOFF_GETP) > GET_WORD (aindex + AOFF_BUFFER_END))
  221.     SET_WORD (aindex + AOFF_GETP, GET_WORD (aindex + AOFF_BUFFER_START));
  222.   enable ();
  223.   return rv;
  224. }
  225.  
  226.  
  227. static int
  228. dosasync_read (fd, buf, len, timeout)
  229.      int fd;
  230.      char *buf;
  231.      int len;
  232.      int timeout;
  233. {
  234.   long now, then;
  235.   int i;
  236.  
  237.   time (&now);
  238.   then = now + timeout;
  239.  
  240.   for (i = 0; i < len; i++)
  241.     {
  242.       if (timeout)
  243.     {
  244.       while (!dos_async_ready ())
  245.         {
  246.           time (&now);
  247.           if (now >= then && timeout > 0)
  248.         return i;
  249.         }
  250.     }
  251.       *buf++ = dos_async_rx ();
  252.     }
  253.   return len;
  254. }
  255.  
  256. static int
  257. dosasync_write (fd, buf, len)
  258.      int fd;
  259.      const char *buf;
  260.      int len;
  261. {
  262.   int l;
  263.  
  264.   for (l = 0; l < len; l++)
  265.     dos_async_tx (*buf++);
  266.  
  267.   return len;
  268. }
  269.  
  270. static int
  271. go32_open (scb, name)
  272.      serial_t scb;
  273.      const char *name;
  274. {
  275.   int port;
  276.  
  277.   if (strncasecmp (name, "com", 3) != 0)
  278.     {
  279.       errno = ENOENT;
  280.       return -1;
  281.     }
  282.  
  283.   port = name[3] - '0';
  284.  
  285.   if ((port != 1) && (port != 2))
  286.     {
  287.       errno = ENOENT;
  288.       return -11;
  289.     }
  290.  
  291.   scb->fd = dos_async_init (port);
  292.   if (!scb->fd)
  293.     return -1;
  294.  
  295.   return 0;
  296. }
  297.  
  298. static int
  299. go32_noop (scb)
  300.      serial_t scb;
  301. {
  302.   return 0;
  303. }
  304.  
  305. static void
  306. go32_raw (scb)
  307.      serial_t scb;
  308. {
  309.   /* Always in raw mode */
  310. }
  311.  
  312. static int
  313. go32_readchar (scb, timeout)
  314.      serial_t scb;
  315.      int timeout;
  316. {
  317.   char buf;
  318.  
  319.   /* Shortcut for polling */
  320.   if (timeout == 0)
  321.     {
  322.       if (dos_async_ready ())
  323.     {
  324.       return dos_async_rx ();
  325.     }
  326.       return SERIAL_TIMEOUT;
  327.     }
  328.  
  329.   if (dosasync_read (scb->fd, &buf, 1, timeout))
  330.     return buf;
  331.   else
  332.     return SERIAL_TIMEOUT;
  333. }
  334.  
  335. /* go32_{get set}_tty_state() are both dummys to fill out the function
  336.    vector.  Someday, they may do something real... */
  337.  
  338. static serial_ttystate
  339. go32_get_tty_state (scb)
  340.      serial_t scb;
  341. {
  342.   struct go32_ttystate *state;
  343.  
  344.   state = (struct go32_ttystate *) xmalloc (sizeof *state);
  345.  
  346.   return (serial_ttystate) state;
  347. }
  348.  
  349. static int
  350. go32_set_tty_state (scb, ttystate)
  351.      serial_t scb;
  352.      serial_ttystate ttystate;
  353. {
  354.   return 0;
  355. }
  356.  
  357. static int
  358. go32_noflush_set_tty_state (scb, new_ttystate, old_ttystate)
  359.      serial_t scb;
  360.      serial_ttystate new_ttystate;
  361.      serial_ttystate old_ttystate;
  362. {
  363.   return 0;
  364. }
  365.  
  366. static void
  367. go32_print_tty_state (scb, ttystate)
  368.      serial_t scb;
  369.      serial_ttystate ttystate;
  370. {
  371.   /* Nothing to print.  */
  372.   return;
  373. }
  374.  
  375. static int
  376. go32_setbaudrate (scb, rate)
  377.      serial_t scb;
  378.      int rate;
  379. {
  380.   return 0;
  381. }
  382.  
  383. static int
  384. go32_write (scb, str, len)
  385.      serial_t scb;
  386.      const char *str;
  387.      int len;
  388. {
  389.   dosasync_write (scb->fd, str, len);
  390.  
  391.   return 0;
  392. }
  393.  
  394. static void
  395. go32_close (scb)
  396.      serial_t scb;
  397. {
  398. }
  399.  
  400. static struct serial_ops go32_ops =
  401. {
  402.   "hardwire",
  403.   0,
  404.   go32_open,
  405.   go32_close,
  406.   go32_readchar,
  407.   go32_write,
  408.   go32_noop,            /* flush output */
  409.   go32_noop,            /* flush input */
  410.   go32_noop,            /* send break -- currently used only for nindy */
  411.   go32_raw,
  412.   go32_get_tty_state,
  413.   go32_set_tty_state,
  414.   go32_print_tty_state,
  415.   go32_noflush_set_tty_state,
  416.   go32_setbaudrate,
  417. };
  418.  
  419. void
  420. _initialize_ser_go32 ()
  421. {
  422.   serial_add_interface (&go32_ops);
  423. }
  424.