home *** CD-ROM | disk | FTP | other *** search
/ Geek Gadgets 1 / ADE-1.bin / ade-dist / gdb-4.16-base.tgz / gdb-4.16-base.tar / fsf / gdb / utils / amd-udi / montip / tdfunc.c < prev    next >
Encoding:
C/C++ Source or Header  |  1993-12-23  |  13.0 KB  |  522 lines
  1. static char _[] = "@(#)tdfunc.c    5.25 93/10/28 08:44:32, Srini, AMD.";
  2. /******************************************************************************
  3.  * Copyright 1991 Advanced Micro Devices, Inc.
  4.  *
  5.  * This software is the property of Advanced Micro Devices, Inc  (AMD)  which
  6.  * specifically  grants the user the right to modify, use and distribute this
  7.  * software provided this notice is not removed or altered.  All other rights
  8.  * are reserved by AMD.
  9.  *
  10.  * AMD MAKES NO WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, WITH REGARD TO THIS
  11.  * SOFTWARE.  IN NO EVENT SHALL AMD BE LIABLE FOR INCIDENTAL OR CONSEQUENTIAL
  12.  * DAMAGES IN CONNECTION WITH OR ARISING FROM THE FURNISHING, PERFORMANCE, OR
  13.  * USE OF THIS SOFTWARE.
  14.  *
  15.  * So that all may benefit from your experience, please report  any  problems
  16.  * or  suggestions about this software to the 29K Technical Support Center at
  17.  * 800-29-29-AMD (800-292-9263) in the USA, or 0800-89-1131  in  the  UK,  or
  18.  * 0031-11-1129 in Japan, toll free.  The direct dial number is 512-462-4118.
  19.  *
  20.  * Advanced Micro Devices, Inc.
  21.  * 29K Support Products
  22.  * Mail Stop 573
  23.  * 5900 E. Ben White Blvd.
  24.  * Austin, TX 78741
  25.  * 800-292-9263
  26.  *****************************************************************************
  27.  *      Engineer: Srini Subramanian.
  28.  *****************************************************************************
  29.  * This module contains the functions to initialize, read, and write to the
  30.  * serial port on an Unix-based machine.
  31.  *****************************************************************************
  32.  */
  33.  
  34. /* This file contains the Target Dependent Functions used by Minimon's
  35.  * Message System.
  36.  */
  37.  
  38. #include  <stdio.h>
  39.  
  40. #include  <fcntl.h>
  41. #include  <termio.h>
  42.  
  43. #ifdef __hpux
  44. #include <sys/modem.h>
  45. #endif
  46.  
  47. #include  "messages.h"
  48. #include  "tdfunc.h"
  49. #include  "mtip.h"
  50. #include  "macros.h"
  51.  
  52. /* Serial connection */
  53. /* 
  54. ** Serial port routines
  55. */
  56.  
  57. /*definitions */
  58. #define BAUD_RATE       B9600
  59. #define CHAR_SIZE         CS8
  60. #define STOP_BITS           0
  61. #define PARITY_ENABLE       0
  62. #define PARITY              0
  63.  
  64. #define CH0_BUFFER_SIZE  1024
  65.  
  66. #define BLOCK 1
  67. #define NOBLOCK 0
  68.  
  69. /* Global for serial */
  70.  
  71. static    int   msg_port;
  72. static    INT32  in_byte_count=0;
  73.  
  74. extern    int    BlockCount;
  75.  
  76. /*
  77. ** This function is used to initialize the communication
  78. ** channel.  This consists of basically opening the com
  79. ** port for reading and writing.
  80. **
  81. ** With Sun UNIX, each time the port is opened, the communication
  82. ** parameters are reset to default values.  These default values for
  83. ** the serial port are currently 9600 baud, 7 bits, even parity.
  84. */
  85.  
  86. INT32
  87. init_comm_serial(ignore1, ignore2)
  88. INT32 ignore1;
  89. INT32 ignore2;
  90.    {
  91.    int      result;
  92.    unsigned short  baud;
  93.    struct   termio tbuf;
  94. #ifdef __hpux
  95.    mflag    mbits;
  96. #else
  97.    int        mbits;
  98. #endif
  99.    int        cd;    /* carrier detect */
  100.  
  101.    /* Open serial port */   
  102.    if ((msg_port = open(tip_config.comm_port, O_NDELAY|O_RDWR)) == -1) {
  103.       return (-1);
  104.    }
  105.  
  106.    /* Get baud rate */
  107.    if (strcmp(tip_config.baud_rate, "300") == 0)
  108.       baud = B300;
  109.    else
  110.    if (strcmp(tip_config.baud_rate, "600") == 0)
  111.       baud = B600;
  112.    else
  113.    if (strcmp(tip_config.baud_rate, "1200") == 0)
  114.       baud = B1200;
  115.    else
  116.    if (strcmp(tip_config.baud_rate, "2400") == 0)
  117.       baud = B2400;
  118.    else
  119.    if (strcmp(tip_config.baud_rate, "4800") == 0)
  120.       baud = B4800;
  121.    else
  122.    if (strcmp(tip_config.baud_rate, "9600") == 0)
  123.       baud = B9600;
  124.    else
  125.    if (strcmp(tip_config.baud_rate, "19200") == 0)
  126.       baud = B19200;
  127.    else
  128.    if (strcmp(tip_config.baud_rate, "38400") == 0)
  129.       baud = B38400;
  130.    else
  131.       return(-1);
  132.  
  133.  
  134.    /* Set up new parameters */
  135.    /* Get termio (for modification) */
  136.    result = ioctl(msg_port, TCGETA, &tbuf);
  137.    if (result == -1)
  138.       return (-1);
  139.  
  140.    /*
  141.    ** Note:  On a Sun III, the port comes up at 9600 baud,
  142.    ** 7 bits, even parity, with read enabled.  We will change
  143.    ** this to 8 bits, no parity (with RTS/CTS handshaking).
  144.    ** We will also set I/O to "raw" mode.
  145.    */
  146.  
  147.    /* Set up new parameters */
  148.    tbuf.c_iflag = 0;
  149.    tbuf.c_oflag = 0;
  150.    tbuf.c_cflag = (baud          | CHAR_SIZE | STOP_BITS | CREAD |
  151.                    PARITY_ENABLE | PARITY   );
  152.    tbuf.c_lflag = 0;
  153.    tbuf.c_cc[VMIN] = 0;  /* Number of characters to satisfy read */
  154. #ifdef __hpux
  155.    tbuf.c_cc[VTIME] = 100;  /* intercharacter timer interval in seconds */
  156. #else
  157.    tbuf.c_cc[VTIME] = 1;  /* intercharacter timer interval in seconds */
  158. #endif
  159.  
  160.    /* Set termio to new mode */
  161.    result = ioctl(msg_port, TCSETA, &tbuf);
  162.    if (result == -1)
  163.       return (-1);
  164.  
  165. #ifdef __hpux
  166.    /* modem status */
  167.    (void) ioctl (msg_port, MCGETA, &mbits);
  168.    mbits = (MDSR|MDTR|MRTS);
  169.    (void) ioctl (msg_port, MCSETA, &mbits);
  170. #else
  171.    /* modem status */
  172.    (void) ioctl (msg_port, TIOCMGET, &mbits);
  173.    mbits  = (TIOCM_DTR|TIOCM_RTS);
  174.    (void) ioctl (msg_port, TIOCMSET, &mbits);
  175. #endif
  176.  
  177.    /* FLush queue */
  178.    if (ioctl(msg_port, TCFLSH, 2) == -1)
  179.       return (-1);
  180.  
  181.    return(0);
  182.    }  /* end init_comm_serial() */
  183.  
  184.  
  185. /*
  186. ** This function is used to send a message over the
  187. ** serial line.
  188. **
  189. ** If the message is successfully sent, a zero is
  190. ** returned.  If the message was not sendable, a -1
  191. ** is returned.  This function blocks.  That is, it
  192. ** does not return until the message is completely
  193. ** sent, or until an error is encountered.
  194. **
  195. */
  196.  
  197. INT32
  198. send_bfr_serial(bfr_ptr, length, port_base, comm_err)
  199.    BYTE  *bfr_ptr;
  200.    INT32 length;
  201.    INT32 port_base;
  202.    INT32 *comm_err;
  203.    {
  204.    int    result;
  205.  
  206.    /* Send message */
  207.    result = write(msg_port, (char *)bfr_ptr, length);
  208.    if (result != length)
  209.       return (-1);
  210.    else
  211.       return (0);
  212.  
  213.    }  /* end msg_send_serial() */
  214.  
  215.  
  216. /*
  217. ** This function is used to receive a message over a
  218. ** serial line.
  219. **
  220. ** If the message is waiting in the buffer, a zero is
  221. ** returned and the buffer pointed to by msg_ptr is filled
  222. ** in.  If no message was available, a -1 is returned.
  223. **
  224. */
  225.  
  226. /* Read as many characters as are coming and return the number of character
  227.  * read into the buffer.
  228.  * Buffer : pointer to the receiving buffer.
  229.  * nbytes : number of bytes requested.
  230.  * Mode   : Blocking/Non-blocking mode. In blocking mode, this will not
  231.  *          return until atleast a character is received. It is used when
  232.  *          the TIP is to wait for a response from the target, and there is
  233.  *          no need to poll the keyboard.
  234.  * PortBase : not used.
  235.  * CommError : Error during communication.
  236.  */
  237. INT32
  238. recv_bfr_serial(Buffer, nbytes, Mode, PortBase, CommError)
  239.    BYTE  *Buffer;
  240.    INT32 nbytes;
  241.    INT32 Mode;
  242.    INT32 PortBase;
  243.    INT32 *CommError;
  244.    {
  245.    int    result;
  246.    unsigned char      ch;
  247.    INT32    count;
  248.    int    bcount;
  249.    struct termio    OrigTBuf, NewTBuf;
  250.  
  251.      count = 0;
  252.      do {
  253.     if (Mode == BLOCK) {
  254.       bcount = 0;
  255.       while (bcount++ < BlockCount) {
  256.         if ((result = read(msg_port, (char *)&ch, 1)) == 1) { /* success */
  257.               *Buffer++ = (BYTE) ch;
  258.           count = count + 1;
  259.           bcount = 0;
  260.         };
  261.         if (count == nbytes)
  262.           return (0);
  263.       };
  264.       return ((INT32) -1);
  265.     } else { /* non-block */
  266.       if ((result = read(msg_port, (char *)&ch, 1)) == 1) { /* success */
  267.             *Buffer++ = (BYTE) ch;
  268.         count = count + 1;
  269.       } else { /* Timed out */
  270.             return ((INT32) -1);
  271.       }
  272.     }
  273.      } while (count < nbytes);
  274.      return (0);
  275.  
  276. #ifdef DEBUG
  277.    if (Mode) { /* BLOCK while reading */
  278.      /*
  279.       * Set blocking mode by set MIN=0 and TIME > 0
  280.       * Here we set TIME to block for 60 seconds.
  281.       */
  282.       (void) ioctl (msg_port, TCGETA, &OrigTBuf);
  283.       (void) ioctl (msg_port, TCGETA, &NewTBuf);
  284.       NewTBuf.c_cc[4] = 0;    /* set MIN to 0 */
  285.       NewTBuf.c_cc[5] = 1;    /* 600 * 0.1 seconds */
  286.       (void) ioctl (msg_port, TCSETA, &NewTBuf);
  287.      count = 0;
  288.      do {
  289.     if (read(msg_port, (char *)&ch, 1) == 1) { /* success */
  290.           *Buffer++ = (BYTE) ch;
  291.       count = count + 1;
  292.     } else { /* Timed out */
  293.           (void) ioctl (msg_port, TCSETA, &OrigTBuf); /* restore termio */
  294.           return ((INT32) -1);
  295.     }
  296.      } while (count < nbytes);
  297.      (void) ioctl (msg_port, TCSETA, &OrigTBuf); /* restore termio */
  298.      return (0);
  299.    } else { /* Non blocking */
  300.      result = (INT32) -1;
  301.      count = 0;
  302.      while ((count < nbytes) && (read(msg_port, (char *)&ch, 1) == 1)) {
  303.        *Buffer++ = (BYTE) ch;
  304.        count = count + 1;
  305.        result = 0;
  306.      }
  307.      if (count == nbytes) /* read enough */
  308.        return (0);
  309.      else    /* not enough chars read */
  310.        return ((INT32) -1);
  311.    }
  312. #endif
  313. #if 0
  314.    result = read(msg_port, (char *) Buffer, nbytes); /* read as many */
  315.    if (result == nbytes) {
  316.      return (0);
  317.    } else {
  318.      return (-1);
  319.    }
  320.        if (result > 0) {
  321.               in_byte_count = in_byte_count + result;
  322.         block_count = 0;
  323.            if (in_byte_count >= length) {
  324.                   /* Message received */
  325.                   in_byte_count = 0;
  326.                   return(0);
  327.                   }
  328.     } else {
  329.  
  330.               /* return if no char & not blocking */
  331.               if (block == NOBLOCK) return (-1);  
  332.  
  333.               /* return if no char, blocking, and past block count */
  334.               if ((block == BLOCK) && (block_count++ > BlockCount))
  335.                  return (-1);  
  336.               }
  337. #endif
  338.  
  339.    }  /* end msg_recv_serial() */
  340.  
  341.  
  342. #ifndef    MSDOS
  343. /*
  344. ** This function is used to close the communication
  345. ** channel.  This is used when resyncing the host and
  346. ** target and when exiting the monitor.
  347. */
  348.  
  349. INT32
  350. reset_comm_pcserver(ignore1, ignore2)
  351. INT32    ignore1;
  352. INT32    ignore2;
  353.    {
  354.    unsigned char      ch;
  355. #ifdef __hpux
  356.     mflag  mbits;
  357. #else
  358.     int  mbits;
  359. #endif
  360.  
  361.    printf("reset:\n");
  362.    /* Reset message buffer counters */
  363.    in_byte_count = 0;
  364.  
  365. #ifdef __hpux
  366.    mbits = (MDSR|MDTR|MRTS);
  367.    (void) ioctl (msg_port, MCSETA, &mbits);
  368. #else
  369.    mbits  = (TIOCM_DTR|TIOCM_RTS);
  370.    (void) ioctl (msg_port, TIOCMGET, &mbits);
  371. #endif
  372.  
  373.    /* Clear data from buffer */
  374.    if (ioctl(msg_port, TCFLSH, 2) == -1) {
  375.      return (-1);
  376.    }
  377.  
  378.    return(0);
  379.    }  /* end reset_comm_serial() */
  380. #endif
  381.  
  382. /*
  383. ** This function is used to close the communication
  384. ** channel.  This is used when resyncing the host and
  385. ** target and when exiting the monitor.
  386. */
  387.  
  388. INT32
  389. reset_comm_serial(ignore1, ignore2)
  390. INT32    ignore1;
  391. INT32    ignore2;
  392.    {
  393. #ifdef __hpux
  394.    mflag    mbits;
  395. #else
  396.     int  mbits;
  397. #endif
  398.  
  399.    /* Reset message buffer counters */
  400.    in_byte_count = 0;
  401.  
  402. #ifdef __hpux
  403.    (void) ioctl (msg_port, MCGETA, &mbits);
  404.    mbits = (MDSR|MDTR|MRTS);
  405.    (void) ioctl (msg_port, MCSETA, &mbits);
  406. #else
  407.    (void) ioctl (msg_port, TIOCMGET, &mbits);
  408.    mbits  = (TIOCM_DTR|TIOCM_RTS);
  409.    (void) ioctl (msg_port, TIOCMSET, &mbits);
  410. #endif
  411.  
  412.    /* Clear data from buffer */
  413.    if (ioctl(msg_port, TCFLSH, 2) == -1) {
  414.      return (-1);
  415.    }
  416.  
  417.    return(0);
  418.    }  /* end reset_comm_serial() */
  419.  
  420.  
  421. INT32
  422. exit_comm_serial(ignore1, ignore2)
  423. INT32    ignore1;
  424. INT32    ignore2;
  425.    {
  426.    /* Reset message buffer counters */
  427.    in_byte_count = 0;
  428.  
  429.    (void) close(msg_port);
  430.  
  431.    return(0);
  432.    }  /* end reset_comm_serial() */
  433. /*
  434. ** This function is usually used to "kick-start" the target.
  435. ** This is nesessary when targets are shared memory boards.
  436. ** With serial communications, this function does nothing.
  437. */
  438.  
  439. void
  440. go_serial(port_base, msg_seg)
  441. INT32 port_base;
  442. INT32 msg_seg;
  443.    { return; }
  444.  
  445.  
  446. INT32 
  447. write_memory_serial (ignore1, ignore2, ignore3, ignore4, ignore5, ignore6)
  448.     INT32 ignore1;
  449.     ADDR32 ignore2;
  450.     BYTE *ignore3;
  451.     INT32 ignore4; 
  452.     INT32 ignore5;
  453.     INT32 ignore6; 
  454. { 
  455.     return(-1); }
  456.  
  457. INT32 
  458. read_memory_serial (ignore1, ignore2, ignore3, ignore4, ignore5, ignore6)
  459.     INT32 ignore1;
  460.     ADDR32 ignore2;
  461.     BYTE *ignore3;
  462.     INT32 ignore4;
  463.     INT32 ignore5;
  464.     INT32 ignore6;
  465. { return(-1); }
  466.  
  467. INT32
  468. fill_memory_serial()
  469.    { return(-1); }
  470.  
  471. /*
  472. ** Stubs for PC plug-in board routines
  473. */
  474.  
  475. /* EB29K */
  476.  
  477. INT32  init_comm_eb29k()    {return (FAILURE);}
  478. INT32  msg_send_eb29k()     {return (-1);}
  479. INT32  msg_recv_eb29k()     {return (-1);}
  480. INT32  reset_comm_eb29k()   {return (-1);}
  481. INT32  exit_comm_eb29k()   {return (-1);}
  482. void   go_eb29k()           {}
  483. INT32  read_memory_eb29k()  {return (-1);}
  484. INT32  write_memory_eb29k() {return (-1);}
  485. INT32  fill_memory_eb29k()  {return (-1);}
  486.  
  487. /* LCB29K */
  488.  
  489. INT32  init_comm_lcb29k()   {return (FAILURE);}
  490. INT32  msg_send_lcb29k()    {return (-1);}
  491. INT32  msg_recv_lcb29k()    {return (-1);}
  492. INT32  reset_comm_lcb29k()  {return (-1);}
  493. INT32  exit_comm_lcb29k()  {return (-1);}
  494. void   go_lcb29k()          {}
  495. INT32  read_memory_lcb29k() {return (-1);}
  496. INT32  write_memory_lcb29k(){return (-1);}
  497. INT32  fill_memory_lcb29k() {return (-1);}
  498.  
  499. /* PCEB */
  500.  
  501. INT32  init_comm_pceb()     {return (FAILURE);}
  502. INT32  msg_send_pceb()      {return (-1);}
  503. INT32  msg_recv_pceb()      {return (-1);}
  504. INT32  reset_comm_pceb()    {return (-1);}
  505. INT32  exit_comm_pceb()    {return (-1);}
  506. void   go_pceb()            {}
  507. INT32  read_memory_pceb()   {return (-1);}
  508. INT32  write_memory_pceb()  {return (-1);}
  509. INT32  fill_memory_pceb()   {return (-1);}
  510.  
  511. /* EB030 */
  512.  
  513. INT32  init_comm_eb030()    {return (FAILURE);}
  514. INT32  msg_send_eb030()     {return (-1);}
  515. INT32  msg_recv_eb030()     {return (-1);}
  516. INT32  reset_comm_eb030()   {return (-1);}
  517. INT32  exit_comm_eb030()   {return (-1);}
  518. void   go_eb030()           {}
  519. INT32  read_memory_eb030()  {return (-1);}
  520. INT32  write_memory_eb030() {return (-1);}
  521. INT32  fill_memory_eb030()  {return (-1);}
  522.