Subversion Repositories or1k

static char _[] = "@(#)serial.c	5.21 93/10/26 09:47:06, Srini, AMD.";
/******************************************************************************
 * Copyright 1991 Advanced Micro Devices, Inc.
 *
 * This software is the property of Advanced Micro Devices, Inc  (AMD)  which
 * specifically  grants the user the right to modify, use and distribute this
 * software provided this notice is not removed or altered.  All other rights
 * are reserved by AMD.
 *
 * AMD MAKES NO WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, WITH REGARD TO THIS
 * SOFTWARE.  IN NO EVENT SHALL AMD BE LIABLE FOR INCIDENTAL OR CONSEQUENTIAL
 * DAMAGES IN CONNECTION WITH OR ARISING FROM THE FURNISHING, PERFORMANCE, OR
 * USE OF THIS SOFTWARE.
 *
 * So that all may benefit from your experience, please report  any  problems
 * or  suggestions about this software to the 29K Technical Support Center at
 * 800-29-29-AMD (800-292-9263) in the USA, or 0800-89-1131  in  the  UK,  or
 * 0031-11-1129 in Japan, toll free.  The direct dial number is 512-462-4118.
 *
 * Advanced Micro Devices, Inc.
 * 29K Support Products
 * Mail Stop 573
 * 5900 E. Ben White Blvd.
 * Austin, TX 78741
 * 800-292-9263
 *****************************************************************************
 *      Engineer: Srini Subramanian.
 *****************************************************************************
 * This module contains the functions to initialize, read, and write to the
 * serial ports (COM1, COM2,...) on a PC.
 *****************************************************************************
 */
 
#include <stdio.h>
#include <conio.h>
#include <bios.h>
#include <dos.h>  
#include <string.h>
#include "types.h"
#include "memspcs.h"
#include "messages.h"
#include "mtip.h"
#include "tdfunc.h"
 
/* Serial Port Defs */
 /*
 * Divisors for different baud rates to be used to initialize DLA
 * register.
 */
#define	_DIV_COM_110	1047
#define	_DIV_COM_150	768
#define	_DIV_COM_300	384
#define	_DIV_COM_600	192
#define	_DIV_COM_1200	96
#define	_DIV_COM_2400	48
#define	_DIV_COM_4800	24
#define	_DIV_COM_9600	12
#define	_DIV_COM_19200	6
#define	_DIV_COM_38400	3
#define	_DIV_COM_115200	1
 
#define	LCR_DLAB	0x80
 
#define	DLA_LOW_OFFSET	0x0
 
 
/*
** Definitions
*/
 
#define BUF_SIZE               2048
 
/*
** This data structure is used by the interrupt driven
** serial I/O.
*/
 
struct serial_io_t {
   int error;                      /* Error code */
   unsigned int    port;           /* Port number */
   unsigned int    port_code;      /* Port code (for bios calls) */
   unsigned int    int_number;     /* Port interrupt number      */
   unsigned int    int_mask;       /* Port interrupt mask        */
   unsigned int    baud;           /* Port baud rate             */
   unsigned int    old_vector_ds;  /* Interrupt vector (old)     */
   unsigned int    old_vector_dx;
   volatile
   unsigned char  *start;          /* Start of ring buffer       */
   volatile
   unsigned char  *end;            /* End of ring buffer         */
   };
 
static unsigned char   serial_io_buffer[BUF_SIZE];
 
/* These definitions are from bios.h */
#define CHAR_SIZE         _COM_CHR8
#define STOP_BITS        _COM_STOP1
#define PARITY        _COM_NOPARITY
 
/*
** Serial port definitions
*/
 
#define INTR_MASK    0x21    /* 8259 Interrupt Mask Port */
#define INTR_EOI     0x20    /* 8259 EOI Port */
 
#define COM1         0x3f8   /* COM1 Port Base */
#define COM1_CODE    0x00    /* COM1 Port Code */
#define COM1_INT     0x0c    /* COM1 Interrupt Number */
#define COM1_MASK    0x10    /* COM1 Interrupt Mask (IRQ4) */
 
#define COM2         0x2f8   /* COM2 Port Base */
#define COM2_CODE    0x01    /* COM2 Port Code */
#define COM2_INT     0x0b    /* COM2 Interrupt Number */
#define COM2_MASK    0x08    /* COM2 Interrupt Mask (IRQ3) */
 
#define MSR_OFFSET   0x6     /* Modem Status Register offset */
#define LSR_OFFSET   0x5     /* Line status Register offset */
#define MCR_OFFSET   0x4     /* Modem Control Register offset */
#define LCR_OFFSET   0x3     /* Line Control Register offest */
#define	IID_OFFSET   0x2     /* Interrupt pending register */
#define IER_OFFSET   0x1     /* Interrupt Enable Register offest */
 
/* Bits in Line Status Register (LSR) */
#define AC1   0x80    /* Always clear */
#define TSRE  0x40    /* Transmitter Shift Register Empty */
#define THRE  0x20    /* Transmitter Holding Register Empty */
#define BI    0x10    /* Break Interrupt */
#define FE    0x08    /* Framing Error */
#define PE    0x04    /* Parity Error */
#define OE    0x02    /* Overrun Error */
#define DR    0x01    /* Data Ready */
 
/* Bits in Modem Control Register */
#define CD    0x80
#define RI    0x40
#define DSR   0x20
#define CTS   0x10
#define OUT2  0x08
#define RTS   0x02
#define DTR   0x01
 
#define MAX_BLOCK  	1000	
 
/*  function prototypes */
 
void   endian_cvt PARAMS((union msg_t *, int));
void   tip_convert32 PARAMS((BYTE *));
INT32	init_parport (char *);
 
void   interrupt far serial_int PARAMS((void));
void	(interrupt far *OldVector)();
int    get_byte_serial PARAMS((void));
 
extern	int	BlockCount;
extern	int	lpt_initialize;
/* globals */
 
struct serial_io_t serial_io;
 
INT32  in_msg_length=0;
INT32  in_byte_count=0;
 
/*
** Serial Port functions
*/
 
/*
** This function is used to initialize the communication
** channel.  First the serial_io data structure is
** initialized.  Then the new interrupt vector is installed.
** Finally, the port is initialized, with DTR, RTS and OUT2
** set.
**
*/
 
INT32 write_memory_serial (ignore1, ignore2, ignore3, ignore4, ignore5, ignore6)
	INT32 ignore1;
	ADDR32 ignore2;
	BYTE *ignore3;
	INT32 ignore4; 
	INT32 ignore5;
	INT32 ignore6; 
{ 
	return(-1); }
 
INT32 read_memory_serial (ignore1, ignore2, ignore3, ignore4, ignore5, ignore6)
	INT32 ignore1;
	ADDR32 ignore2;
	BYTE *ignore3;
	INT32 ignore4;
	INT32 ignore5;
	INT32 ignore6;
{ return(-1); }
 
INT32 fill_memory_serial() { return(-1); }
 
INT32
init_comm_serial(ignore1, ignore2)
INT32 ignore1;
INT32 ignore2;
   {
   unsigned result;
   unsigned config;
   unsigned   int comm_status;
 
   /* Initialize serial_io */
   serial_io.error = FALSE;
 
   /* Set up port number */
   if ((strcmp(tip_config.comm_port, "com1") == 0) ||
       (strcmp(tip_config.comm_port, "com1:") == 0)) {
      serial_io.port = COM1;
      serial_io.port_code = COM1_CODE;
      serial_io.int_number = COM1_INT;
      serial_io.int_mask = COM1_MASK;
      }
   else
   if ((strcmp(tip_config.comm_port, "com2") == 0) ||
       (strcmp(tip_config.comm_port, "com2:") == 0)) {
      serial_io.port = COM2;
      serial_io.port_code = COM2_CODE;
      serial_io.int_number = COM2_INT;
      serial_io.int_mask = COM2_MASK;
      }
   else
      return((INT32) -1);
 
    /* Check status */
    comm_status = inp(serial_io.port+LSR_OFFSET);
#if 0
    /* reset any communication errors */
    outp(serial_io.port+LSR_OFFSET, 
		       (unsigned int) (comm_status & ~(FE|PE|OE)));
#endif
 
 
   /* Get baud rate (Note: MS-DOS only goes to 9600) */
   outp (serial_io.port+LCR_OFFSET, LCR_DLAB);
 
   if (strcmp(tip_config.baud_rate, "110") == 0)
      outpw (serial_io.port+DLA_LOW_OFFSET, _DIV_COM_110);
   else
   if (strcmp(tip_config.baud_rate, "150") == 0)
      outpw (serial_io.port+DLA_LOW_OFFSET, _DIV_COM_150);
   else
   if (strcmp(tip_config.baud_rate, "300") == 0)
      outpw (serial_io.port+DLA_LOW_OFFSET, _DIV_COM_300);
   else
   if (strcmp(tip_config.baud_rate, "600") == 0)
      outpw (serial_io.port+DLA_LOW_OFFSET, _DIV_COM_600);
   else
   if (strcmp(tip_config.baud_rate, "1200") == 0)
      outpw (serial_io.port+DLA_LOW_OFFSET, _DIV_COM_1200);
   else
   if (strcmp(tip_config.baud_rate, "2400") == 0)
      outpw (serial_io.port+DLA_LOW_OFFSET, _DIV_COM_2400);
   else
   if (strcmp(tip_config.baud_rate, "4800") == 0)
      outpw (serial_io.port+DLA_LOW_OFFSET, _DIV_COM_4800);
   else
   if (strcmp(tip_config.baud_rate, "9600") == 0)
      outpw (serial_io.port+DLA_LOW_OFFSET, _DIV_COM_9600);
   else
   if (strcmp(tip_config.baud_rate, "19200") == 0)
      outpw (serial_io.port+DLA_LOW_OFFSET, _DIV_COM_19200);
   else
   if (strcmp(tip_config.baud_rate, "38400") == 0)
      outpw (serial_io.port+DLA_LOW_OFFSET, _DIV_COM_38400);
   else
   if (strcmp(tip_config.baud_rate, "115200") == 0)
      outpw (serial_io.port+DLA_LOW_OFFSET, _DIV_COM_115200);
   else
      return((INT32) -1);  /* EMBAUD); */
 
   /* Set LCR */
   outp (serial_io.port+LCR_OFFSET, 
		(unsigned int) (_COM_CHR8|_COM_STOP1|_COM_NOPARITY));
 
   /* Save old interrupt vector */
   OldVector = _dos_getvect (serial_io.int_number);
 
   /* Initialize ring buffer */
   serial_io.start = serial_io_buffer;
   serial_io.end = serial_io_buffer;
 
   /* Install interrupt vector */
   /* Note:  the interrupt handler should be in the same code */
   /*        segment as this function.  We will use CS for    */
   /*        the segment offset value.                        */
 
   _dos_setvect(serial_io.int_number, serial_int); /* new handler */
 
   /* Turn on DTR, RTS and OUT2 */
   result = outp((serial_io.port+MCR_OFFSET), (DTR | RTS | OUT2));
 
   /* Enable interrupt on serial port controller */
   result = outp((serial_io.port+IER_OFFSET), 0x01);
 
   /* Set interrupt mask on 8259 */
   config = inp(INTR_MASK);  /* Get current 8259 mask */
   result = outp(INTR_MASK, (config & ~serial_io.int_mask));
 
   /* Set global message indices */
   in_msg_length = 0;
   in_byte_count = 0;
 
   /* initialize parallel port */
   if (lpt_initialize)
      return (init_parport(tip_config.par_port));
 
   return((INT32) 0);
   }  /* end init_comm_serial() */
 
/*
** This function is used to send bytes over the serial line.
** If the bytes are successfully sent, a zero is returned.  
** If the bytes are not sent, a -1 is returned.
*/
 
INT32
send_bfr_serial(bfr_ptr, length, port_base, comm_err)
   BYTE   *bfr_ptr;
   INT32  length;
   INT32  port_base;
   INT32  *comm_err;
   {
   int        retries;
   INT32      byte_count = 0;
   unsigned   int comm_status;
   unsigned   int result;
 
   /* Send message */
   retries = 0;
   do {
 
      /* check user interrupt */
      SIGINT_POLL
      /* Check if data ready */
      comm_status = inp(serial_io.port+LSR_OFFSET);
 
      /* Check for communication errors */
      if ((comm_status & (FE | PE | OE)) != 0) {
	  *comm_err = 1;
	  return (-1);
      }
 
      /* If Transmitter Holding Register Empty (THRE) */
      /* send out data */
      if ((comm_status & THRE) != 0) {
         result = outp(serial_io.port, bfr_ptr[byte_count]);
         byte_count = byte_count + 1;
         retries = 0;
         } else {
            retries = retries + 1;
            if (retries >= 20000)   
               return (-1);   /* EMNOSEND); */
            }
 
      } while (byte_count < length );  
 
   return(0);
   }  /* end send_bfr_serial() */
 
/*
** This function is used to receive bytes over a serial line.
**
** If block equals NONBLOCK then the function returns as soon
** there are no bytes remaining in the UART.           
** If block equals BLOCK then the function waits until all
** bytes are gotten before returning.
** 
** If all bytes requested are gotten, 0 is returned, else -1.
*/
 
INT32
recv_bfr_serial(bfr_ptr, length, block, port_base, comm_err)
   BYTE   *bfr_ptr;
   INT32  length;
   INT32  block;
   INT32  port_base;
   INT32  *comm_err;
   {
   int        comm_status;
   int        c;
   int        result;  
   int        bytes_free;
 
   int      block_count = 0;
 
   /* Loop as long as characters keep coming */
   for (;;) {
 
      /* Check for communication errors */
      comm_status = inp(serial_io.port+LSR_OFFSET);
      if ((comm_status & (FE | PE | OE)) != 0)
	  {
	  *comm_err = 1;
	  return (-1);
	  }
 
      /* Check for buffer overflow */
      if (serial_io.error == TRUE)
 	  {
	  *comm_err = 1;
	  return (-1);
 	  }
 
      /* Do flow control.  If the buffer is 9/10 full, */
      /* deassert DTR and RTS.  If the buffer becomes */
      /* 1/10 full, reassert DTR and RTS.              */
      bytes_free = (int) (serial_io.start - serial_io.end);
      if (bytes_free <= 0)
         bytes_free = BUF_SIZE + bytes_free;
 
      comm_status = inp(serial_io.port+MCR_OFFSET);
      if (bytes_free <= (BUF_SIZE/10))
         result = outp((serial_io.port+MCR_OFFSET),
                       (comm_status & ~DTR & ~RTS));
 
      if (bytes_free >= ((9*BUF_SIZE)/10))
         result = outp((serial_io.port+MCR_OFFSET),
                       (comm_status | DTR | RTS));
 
      /* Get character */
      c = get_byte_serial();
 
      /* return if no char & not blocking */
      if ((c == -1) && (block == NONBLOCK))
         return (-1);  
 
      /* return if no char, blocking, and past block count */
      if ((c == -1) && (block == BLOCK) && (block_count++ > BlockCount))
         return (-1);  
 
      /* Save byte in bfr_ptr buffer */
      if (c != -1) {
      	  bfr_ptr[in_byte_count] = (BYTE) c;
	  block_count = 0;
      	  in_byte_count = in_byte_count + 1;
	  }
 
      /* Message received ? */
      if (in_byte_count == length) {
         in_byte_count = 0;
         return(0);
         }
      }  	/* end for(;;) */
   }  		/* end recv_bfr_serial() */
 
 
/*
** This function is used to reset the communication
** channel.  This is used when resyncing the host and
** target and when exiting the monitor.
*/
 
INT32
reset_comm_serial(ignore1, ignore2)
INT32	ignore1;
INT32	ignore2;
   {
   unsigned   int status;
 
#define	CLEAR_STAT	(int) 1
 
  do {
    /* Clear LSR */
    inp(serial_io.port+LSR_OFFSET);
    /* Clear RX reg */
    inp (serial_io.port);
    /* Clear MSR */
    inp (serial_io.port+MSR_OFFSET);
    /* interrupt pending ? */
    status = inp(serial_io.port+IID_OFFSET);
  } while (status != CLEAR_STAT);
 
#if 0
    /* reset any communication errors */
    outp(serial_io.port+LSR_OFFSET, 
		       (unsigned int) (comm_status & ~(FE|PE|OE)));
#endif
 
   /* Initialize serial_io */
   serial_io.error = FALSE;
 
   /* Initialize ring buffer */
   serial_io.start = serial_io_buffer;
   serial_io.end = serial_io_buffer;
 
   /* Set global message indices */
   in_msg_length = 0;
   in_byte_count = 0;
 
   return((INT32) 0);
   }  /* end reset_comm_serial() */
 
 
INT32
exit_comm_serial(ignore1, ignore2)
INT32	ignore1;
INT32	ignore2;
   {
   /* Initialize serial_io */
   serial_io.error = FALSE;
 
   /* Initialize ring buffer */
   serial_io.start = serial_io_buffer;
   serial_io.end = serial_io_buffer;
 
   /* Set global message indices */
   in_msg_length = 0;
   in_byte_count = 0;
 
   /* install old handler back */
   _dos_setvect(serial_io.int_number, OldVector);
 
   return((INT32) 0);
   }  /* end reset_comm_serial() */
 
/*
** This function is usually used to "kick-start" the target.
** This is nesessary when targets are shared memory boards.
** With serial communications, this function does nothing.
*/
 
void
go_serial(ignore1, ignore2)
INT32 ignore1;
INT32 ignore2;
   {
   return;
   }  /* end go_serial() */
 
 
 
/*
** This function is used to get a byte from the the
** serial_io_buffer.  The data in this buffer is written
** by the interrupt handler.
**
** If no data is available, a -1 is returned.  Otherwise
** a character is returned.
*/
 
int
get_byte_serial()
   {
   int result=-1;
 
      /* Turn interrupts off while reading buffer */
     _disable();
 
   /* No bytes available */
   if (serial_io.start == serial_io.end)
      result = -1;
   else {
 
      /* Return character */
      result = (int) *serial_io.start;
      serial_io.start++;
      /* Check for wrap around */
      if (serial_io.start >= (serial_io_buffer+BUF_SIZE)) {
         serial_io.start = serial_io_buffer;         
      }
 
    }
      /* Turn interrupts back on */
      _enable();
 
   return (result);
   }  /* end get_byte_serial() */
 
 
 
/*
** This function is the interrupt handler which buffers
** incoming characters.
**
** Note:  The "interrupt" keyword is not well documented.
**        It produces a procedure which returns with an
**        "iret" instead of the usual "ret".
*/
 
void interrupt serial_int()
   {
   int c;
 
   /* Get character */
   c = inp(serial_io.port);
 
   *serial_io.end = (unsigned char) c;
   serial_io.end++;
   /* Check for wrap around */
   if (serial_io.end >= (serial_io_buffer+BUF_SIZE))
      serial_io.end = serial_io_buffer;         
 
   /* Has the buffer overflowed? */
   if (serial_io.start == serial_io.end)
      serial_io.error = TRUE;
 
   /* Send EOI to 8259 */
   (void) outp(INTR_EOI, 0x20);
 
   }  /* end serial_int() */