home *** CD-ROM | disk | FTP | other *** search
/ Fresh Fish 9 / FreshFishVol9-CD2.bin / bbs / gnu / gdb-4.14-src.lha / gdb-4.14 / gdb / ser-e7kpc.c < prev    next >
Encoding:
C/C++ Source or Header  |  1994-06-27  |  8.4 KB  |  421 lines
  1. /* Remote serial interface using Hitachi E7000 PC ISA card in a PC
  2.  
  3.    Copyright 1994 Free Software Foundation, Inc.
  4.  
  5.    This file is part of GDB.
  6.  
  7.    This program is free software; you can redistribute it and/or modify
  8.    it under the terms of the GNU General Public License as published by
  9.    the Free Software Foundation; either version 2 of the License, or
  10.    (at your option) any later version.
  11.  
  12.    This program is distributed in the hope that it will be useful,
  13.    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14.    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15.    GNU General Public License for more details.
  16.  
  17.    You should have received a copy of the GNU General Public License
  18.    along with this program; if not, write to the Free Software
  19.    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */
  20.  
  21. #ifdef __GO32__
  22. #include "defs.h"
  23. #include "serial.h"
  24. #include <sys/dos.h>
  25.  
  26.  
  27.  
  28. static int e7000pc_open PARAMS ((serial_t scb, const char *name));
  29. static void e7000pc_raw PARAMS ((serial_t scb));
  30. static int e7000pc_readchar PARAMS ((serial_t scb, int timeout));
  31. static int e7000pc_setbaudrate PARAMS ((serial_t scb, int rate));
  32. static int e7000pc_write PARAMS ((serial_t scb, const char *str, int len));
  33. static void e7000pc_close PARAMS ((serial_t scb));
  34. static serial_ttystate e7000pc_get_tty_state PARAMS ((serial_t scb));
  35. static int e7000pc_set_tty_state PARAMS ((serial_t scb, serial_ttystate state));
  36. static char *aptr PARAMS ((short p));
  37.  
  38. static int dos_async_init PARAMS ((int port));
  39. static void dos_async_tx PARAMS ((const char c));
  40. static int dos_async_rx PARAMS (());
  41.  
  42.  
  43.  
  44. #define OFF_DPD     0x0000
  45. #define OFF_DDP     0x1000
  46. #define OFF_CPD     0x2000
  47. #define OFF_CDP     0x2400
  48. #define OFF_FA      0x3000
  49. #define OFF_FB      0x3002
  50. #define OFF_FC      0x3004
  51. #define OFF_IRQTOD    0x3008
  52. #define OFF_IRQTOP     0x300a
  53. #define OFF_READY      0x300c
  54. #define OFF_PON        0x300e
  55.  
  56. #define IDLE       0x0000           
  57. #define CMD_CI     0x4349           
  58. #define CMD_CO     0x434f           
  59. #define CMD_LO     0x4c4f           
  60. #define CMD_LS     0x4c53           
  61. #define CMD_SV     0x5356           
  62. #define CMD_SS     0x5353           
  63. #define CMD_OK     0x4f4b           
  64. #define CMD_ER     0x4552           
  65. #define CMD_NF     0x4e46           
  66. #define CMD_AB     0x4142           
  67. #define CMD_ED     0x4544           
  68. #define CMD_CE     0x4345           
  69.  
  70. static unsigned long fa;
  71. static unsigned long irqtod;
  72. static unsigned long ready;
  73. static unsigned long fb;
  74. static unsigned long cpd ;
  75. static unsigned long cdp ;
  76. static unsigned long ready;
  77. static unsigned long pon;
  78. static unsigned long irqtop;
  79. static unsigned long board_at;
  80.  
  81. #define SET_BYTE(x,y)   { char _buf = y;dosmemput(&_buf,1, x);}
  82. #define SET_WORD(x,y)   { short _buf = y;dosmemput(&_buf,2, x);}
  83. #define GET_BYTE(x)     ( dosmemget(x,1,&bb), bb)
  84. #define GET_WORD(x)     ( dosmemget(x,2,&sb), sb)
  85.  
  86. static unsigned char bb;
  87. static unsigned short sb;
  88.  
  89.  
  90. static struct sw 
  91. {
  92.   int sw;
  93.   int addr;
  94. } sigs[] = {
  95.   {0x14, 0xd0000},
  96.   {0x15, 0xd4000},
  97.   {0x16, 0xd8000},
  98.   {0x17, 0xdc000},
  99.   0};
  100.  
  101. static int
  102. e7000pc_init ()
  103. {
  104.   /* Look around in memory for the board's signature */
  105.  
  106.   int try;
  107.   
  108.   for (try = 0; sigs[try].sw; try++)
  109.  
  110.     {
  111.       int val;
  112.       board_at = sigs[try].addr;
  113.       fa = board_at + OFF_FA;
  114.       fb = board_at + OFF_FB;
  115.       cpd = board_at + OFF_CPD;
  116.       cdp = board_at + OFF_CDP;
  117.       ready =board_at + OFF_READY;
  118.       pon = board_at + OFF_PON;          
  119.       irqtop = board_at + OFF_IRQTOP;
  120.       irqtod = board_at + OFF_IRQTOD;
  121.       
  122.       val = GET_WORD (ready);
  123.  
  124.       if (val == (0xaaa0  | sigs[try].sw))
  125.     {
  126.       if (GET_BYTE (pon) & 0xf)
  127.         {
  128.           SET_BYTE(fa, 0);
  129.           SET_BYTE (fb, 0);
  130.  
  131.           SET_BYTE (irqtop, 1); /* Disable interrupts from e7000 */
  132.           SET_WORD (ready, 1);
  133.           printf_filtered ("\nConnected to the E7000PC at address 0x%x\n", 
  134.                    sigs[try].addr);
  135.           return 1;          
  136.         }
  137.       error ("The E7000 PC board is working, but the E7000 is turned off.\n");
  138.       return 0;
  139.     }
  140.     }
  141.  
  142.   error ("GDB cannot connect to the E7000 PC board, check that it is installed\n\
  143. and that the switch settings are correct.  Some other DOS programs can \n\
  144. stop the board from working.  Try starting from a very minimal boot, \n\
  145. perhaps you need to disable EMM386 over the region where the board has\n\
  146. its I/O space, remove other unneeded cards, etc etc\n");
  147.   return 0;
  148.  
  149. }
  150.  
  151. static int pbuf_size;
  152. static int pbuf_index;
  153.  
  154. static 
  155. int 
  156. e7000_get ()
  157. {
  158.   static char pbuf[1000];
  159.   char tmp[1000];
  160.   int x;
  161.   if (pbuf_index < pbuf_size) 
  162.     {
  163.       x = pbuf[pbuf_index++];
  164.     }
  165.   else if ((GET_BYTE (fb)  & 1))
  166.     {
  167.       int i;
  168.       pbuf_size = GET_WORD(cdp + 2);
  169.  
  170.       dosmemget (cdp + 8, pbuf_size + 1, tmp);
  171.  
  172.       /* Tell the E7000 we've eaten */
  173.       SET_BYTE(fb,0);    
  174.       /* Swap it around */
  175.       for (i = 0; i < pbuf_size; i++) 
  176.     {
  177.       pbuf[i] = tmp[i^1];
  178.     }
  179.       pbuf_index = 0;
  180.       x =  pbuf[pbuf_index++];
  181.     }
  182.   else 
  183.     { 
  184.       x = -1;
  185.     }
  186.   return x;
  187. }
  188.  
  189. static int
  190. dosasync_read (fd, buf, len, timeout)
  191.      int fd;
  192.      char *buf;
  193.      int len;
  194.      int timeout;
  195.  
  196. {
  197.   long now;
  198.   long then;
  199.   int i = 0;
  200.   int p;
  201.  
  202.   /* Then look for some more if we're still hungry */
  203.   time (&now);
  204.   then = now + timeout;
  205.   while (i < len)
  206.     {
  207.       int ch = e7000_get();
  208.       
  209.       /* While there's room in the buffer, and we've already
  210.      read the stuff in, suck it over */
  211.       if (ch != -1) 
  212.     {
  213.       buf[i++] = ch;
  214.       while (i < len && pbuf_index < pbuf_size )
  215.         {
  216.           ch = e7000_get();
  217.           if (ch == -1)
  218.         break;
  219.           buf[i++] = ch;
  220.         }
  221.     }
  222.  
  223.       time (&now);
  224.  
  225.       if (timeout == 0)
  226.     return i;
  227.       if (now >= then && timeout > 0)
  228.     {
  229.       return i;
  230.     }
  231.     }
  232.   return len;
  233. }
  234.  
  235.  
  236. static int
  237. dosasync_write (fd, buf, len)
  238.      int fd;
  239.      const char *buf;
  240.      int len;
  241. {
  242.   int i;
  243.   char dummy[1000];  
  244.  
  245.   
  246.   /* Construct copy locally */
  247.   ((short *)dummy)[0] = CMD_CI;
  248.   ((short *)dummy)[1] = len;
  249.   ((short *)dummy)[2] = 0;
  250.   ((short *)dummy)[3] = 0;
  251.   for (i = 0; i < len ; i++) 
  252.     {
  253.       dummy[8 + i ^ 1] = buf[i];
  254.     }
  255.  
  256.   /* Wait for the card to get ready */
  257.   while ((GET_BYTE(fa) & 1) != 0)
  258.     ;
  259.  
  260.   /* Blast onto the ISA card */
  261.   dosmemput (dummy, 8 + len + 1,  cpd);
  262.  
  263.   SET_BYTE(fa, 1);
  264.   SET_BYTE(irqtod, 1); /* Interrupt the E7000 */
  265.  
  266.   return len;
  267. }
  268.  
  269. static int
  270. e7000pc_open (scb, name)
  271.      serial_t scb;
  272.      const char *name;
  273. {
  274.   if (strncasecmp (name, "pc", 2) != 0)
  275.     {
  276.       errno = ENOENT;
  277.       return -1;
  278.     }
  279.  
  280.   scb->fd = e7000pc_init ();
  281.  
  282.   if (!scb->fd)
  283.     return -1;
  284.  
  285.   return 0;
  286. }
  287.  
  288. static int
  289. e7000pc_noop (scb)
  290.      serial_t scb;
  291. {
  292.   return 0;
  293. }
  294.  
  295. static void
  296. e7000pc_raw (scb)
  297.      serial_t scb;
  298. {
  299.   /* Always in raw mode */
  300. }
  301.  
  302. static int
  303. e7000pc_readchar (scb, timeout)
  304.      serial_t scb;
  305.      int timeout;
  306. {
  307.   char buf;
  308.  
  309.  top:
  310.  
  311.   if (dosasync_read (scb->fd, &buf, 1, timeout))
  312.     {
  313.       if (buf == 0) goto top;
  314.       return buf;
  315.     }
  316.   else
  317.     return SERIAL_TIMEOUT;
  318. }
  319.  
  320. struct e7000pc_ttystate {
  321.   int dummy;
  322. };
  323.  
  324. /* e7000pc_{get set}_tty_state() are both dummys to fill out the function
  325.    vector.  Someday, they may do something real... */
  326.  
  327. static serial_ttystate
  328. e7000pc_get_tty_state (scb)
  329.      serial_t scb;
  330. {
  331.   struct e7000pc_ttystate *state;
  332.  
  333.   state = (struct e7000pc_ttystate *) xmalloc (sizeof *state);
  334.  
  335.   return (serial_ttystate) state;
  336. }
  337.  
  338. static int
  339. e7000pc_set_tty_state (scb, ttystate)
  340.      serial_t scb;
  341.      serial_ttystate ttystate;
  342. {
  343.   return 0;
  344. }
  345.  
  346. static int
  347. e7000pc_noflush_set_tty_state (scb, new_ttystate, old_ttystate)
  348.      serial_t scb;
  349.      serial_ttystate new_ttystate;
  350.      serial_ttystate old_ttystate;
  351. {
  352.   return 0;
  353. }
  354.  
  355. static void
  356. e7000pc_print_tty_state (scb, ttystate)
  357.      serial_t scb;
  358.      serial_ttystate ttystate;
  359. {
  360.   /* Nothing to print.  */
  361.   return;
  362. }
  363.  
  364. static int
  365. e7000pc_setbaudrate (scb, rate)
  366.      serial_t scb;
  367.      int rate;
  368. {
  369.   return 0;
  370. }
  371.  
  372. static int
  373. e7000pc_write (scb, str, len)
  374.      serial_t scb;
  375.      const char *str;
  376.      int len;
  377. {
  378.   dosasync_write (scb->fd, str, len);
  379.  
  380.   return 0;
  381. }
  382.  
  383. static void
  384. e7000pc_close (scb)
  385.      serial_t scb;
  386. {
  387. }
  388.  
  389. static struct serial_ops e7000pc_ops =
  390. {
  391.   "pc",
  392.   0,
  393.   e7000pc_open,
  394.   e7000pc_close,
  395.   e7000pc_readchar,
  396.   e7000pc_write,
  397.   e7000pc_noop,            /* flush output */
  398.   e7000pc_noop,            /* flush input */
  399.   e7000pc_noop,            /* send break -- currently used only for nindy */
  400.   e7000pc_raw,
  401.   e7000pc_get_tty_state,
  402.   e7000pc_set_tty_state,
  403.   e7000pc_print_tty_state,
  404.   e7000pc_noflush_set_tty_state,
  405.   e7000pc_setbaudrate,
  406. };
  407.  
  408. void
  409. _initialize_ser_e7000pc ()
  410. {
  411.   serial_add_interface (&e7000pc_ops);
  412. }
  413. #else
  414.  
  415. void
  416. _initialize_ser_e7000pc ()
  417. {
  418.  
  419. }
  420. #endif
  421.