home *** CD-ROM | disk | FTP | other *** search
/ Power-Programmierung / CD2.mdf / c / library / dos / communic / rsdrv / rsdrv.c next >
Encoding:
C/C++ Source or Header  |  1990-03-05  |  7.7 KB  |  303 lines
  1. /* rsdrv.c : interrupt driven serial communiaction routines
  2.  *
  3.  * by J. Leppäjärvi (so-jml@stekt.oulu.fi) (C) 1990
  4.  *
  5.  * Comments, suggestions and bug fixes are welcome.
  6.  *
  7.  * For Borland's turbo C, all memory models.
  8.  *
  9.  * This program can be used, copied and modified freely. It 
  10.  * is provided 'as is' with no warranty of any kind.
  11.  *
  12.  * Last update: 1.3. 1990
  13.  */
  14.  
  15. #include "rsdrv.h"
  16. #include <dos.h>
  17.  
  18. /* 8250 registers */
  19.  
  20. #define ASYNC_BASE (_async_param[_port].async_base)
  21. #define VECT       (_async_param[_port].vect)
  22. #define PICBIT     (_async_param[_port].picbit)
  23.  
  24. #define TX_BUF    ASYNC_BASE             /* transmit buffer  */
  25. #define RX_BUF    ASYNC_BASE             /* receive buffer   */
  26. #define DIVISOR   ASYNC_BASE             /* 16-bit divisor   */
  27. #define INT_CNTL  (ASYNC_BASE + 0x01)    /* interrupt enable */
  28. #define INT_ID    (ASYNC_BASE + 0x02)    /* interrupt id     */
  29. #define LINE_CNTL (ASYNC_BASE + 0x03)    /* line control     */
  30. #define MOD_CNTL  (ASYNC_BASE + 0x04)    /* modem control    */
  31. #define LINE_STAT (ASYNC_BASE + 0x05)    /* line status reg  */
  32.  
  33. /* 8250 interrupt identification flags */
  34.  
  35. #define INT_DET   0x01                   /* detect int bit (0 = int pending) */
  36. #define INT_MSTAT 0x00                   /* modem status */
  37. #define INT_TX    0x02                   /* ready to transfer */
  38. #define INT_RX    0x04                   /* received char waiting */
  39. #define INT_LSTAT 0x06                   /* receiver line status */
  40.  
  41. /* 8250 int enable flags */
  42.  
  43. #define ENAB_RX    0x01                  /* received char waiting */
  44. #define ENAB_TX    0x02                  /* ready to trasfer */
  45. #define ENAB_LSTAT 0x04                  /* line status */
  46. #define ENAB_MSTAT 0x08                  /* modem status */
  47.  
  48. /* 8250 modem control bits */
  49.  
  50. #define MCNTL_OUT2 0x08
  51. #define MCNTL_OUT1 0x04
  52. #define MCNTL_RTS  0x02
  53. #define MCNTL_DTR  0x01
  54.  
  55. /* 8250 status reg bits */
  56.  
  57. #define RX_READY 0x01
  58. #define TX_IDLE  0x20
  59.  
  60. /* line control reg */
  61.  
  62. #define BREAK    0x40
  63. #define DLAB     0x80
  64.  
  65. /* parameters for com1 - com4 */
  66.  
  67. static struct param
  68. {
  69.  unsigned async_base;
  70.  unsigned char vect;
  71.  unsigned char picbit;
  72. } _async_param[4] = {\
  73. {0x3f8,0x0c,0x10}, \
  74. {0x2f8,0x0b,0x08}, \
  75. {0x3e8,0x0c,0x10}, \
  76. {0x2e8,0x0b,0x08}};
  77.  
  78. static int _port;                      /* port number  (0 - 3) */
  79. static void interrupt (*_oldvect)();   /* int vector previous value */
  80.  
  81. /* in / out fifos */
  82.  
  83. #define RXBUF 0x80
  84. #define TXBUF 0x80
  85.  
  86. static unsigned char _rx_top[RXBUF];
  87. static unsigned char *_rx_end = &_rx_top[RXBUF - 1];
  88. static unsigned char *_rx_head = _rx_top;
  89. static unsigned char *_rx_tail = _rx_top;
  90.  
  91. static unsigned char _tx_top[TXBUF];
  92. static unsigned char *_tx_end = &_tx_top[TXBUF - 1];
  93. static unsigned char *_tx_head = _tx_top;
  94. static unsigned char *_tx_tail = _tx_top;
  95.  
  96.  
  97. /* The interrupt handler is invoked every time a char arrives
  98.  * or when the 8250's transmit buffer becomes empty. Incoming
  99.  * characters are placed in a fifo buffer from which they can
  100.  * be read with rsgetc(). The characters to be sent are placed
  101.  * in their fifo with rsputc() and sent by the interrupt handler,
  102.  * if they cannot be sent right away (transmitter busy).
  103.  *
  104.  * The oldest entry in the input fifo is lost if the fifo
  105.  * overflows.
  106.  *
  107.  * An interrupt condition triggered by the 8250 might occur
  108.  * during the processing of a previous interrupt from the
  109.  * same source since both rx and tx interrupts are used.
  110.  * The PIC, however, ignores further interrupts from the
  111.  * same source. This combination causes a situation in which
  112.  * the interrupts from the 8250 might 'dry up', because the
  113.  * interrupt identification register is never read, and so
  114.  * further interrupts from the 8250 are effectively disabled.
  115.  * To correct this, the interrupt handler polls the int id reg
  116.  * until no interrupts are pending. It is essential to do this
  117.  * check after EOI to PIC. On the other hand, no extra EOI's are
  118.  * send to the PIC. (This is the cause of using the somewhat 
  119.  * clumsy eoi_flag.) This techique creates a situation in which
  120.  * the actual interrupt calls might nest. However, the same cause
  121.  * shouldn't trigger an interrupt before a communication speed
  122.  * depend time constant has elapsed. In general, this constant must
  123.  * be significantly greater than the time spend in the interrupt
  124.  * routine for this to work anyway, so I figure this is ok.
  125.  */
  126.  
  127. static void interrupt rstrap()
  128. {
  129.  unsigned char int_id, eoi_flag = 0;
  130.  
  131.  enable();
  132.  
  133.  while (!((int_id = inportb(INT_ID)) & INT_DET))
  134.  {
  135.   switch(int_id)
  136.   {
  137.    case INT_TX:
  138.     if (_tx_tail != _tx_head)
  139.     {
  140.      outportb(TX_BUF,*_tx_tail);
  141.      if ((++_tx_tail) > _tx_end)
  142.       _tx_tail = _tx_top;
  143.     }
  144.    break;
  145.  
  146.    case INT_RX:
  147.     *(_rx_head++) = inportb(RX_BUF);
  148.     if (_rx_head > _rx_end)
  149.      _rx_head = _rx_top;
  150.      
  151.     if (_rx_head == _rx_tail)
  152.      if (++_rx_tail > _rx_end)
  153.       _rx_tail = _rx_top;
  154.    break;
  155.   }
  156.  
  157.   /* a non-specific eoi to PIC in the first round */
  158.  
  159.   if (!eoi_flag)
  160.   {
  161.    outportb(0x20,0x20);
  162.    eoi_flag = 1;
  163.   } 
  164.  }
  165. } 
  166.  
  167.  
  168. /* rsputc() transmits the character c, either directly
  169.  * or by placing it in the transmit buffer. The interrupts
  170.  * are disabled during this function, since the tx interrupt 
  171.  * might occur during the fifo manipulation.
  172.  *
  173.  * returns:  0 success
  174.  *          -1 buffer full, can't transmit
  175.  */
  176.  
  177. int rsputc(c)
  178. unsigned char c;
  179. {
  180.  disable();
  181.  
  182.  /* write directly to 8250 if nothing is currently being sent */
  183.  
  184.  if (inportb(LINE_STAT) & TX_IDLE)
  185.   outportb(TX_BUF,c);
  186.  else
  187.  {
  188.   *_tx_head = c;
  189.   if ((++_tx_head) > _tx_end)
  190.    _tx_head = _tx_top;
  191.   if (_tx_head == _tx_tail)
  192.   {
  193.    _tx_head--;
  194.    enable();
  195.    return(-1);
  196.   }
  197.  }
  198.  enable();
  199.  return(0);
  200. }
  201.  
  202.  
  203. /* rsgetc() reads a character from the incoming character fifo.
  204.  * Since the rx interrupt might occur during the call, interrupts
  205.  * are disabled.
  206.  *
  207.  * returns : the character read, -1 if none available
  208.  */
  209.  
  210. int rsgetc()
  211. {
  212.  unsigned char ch;
  213.  
  214.  disable();
  215.  
  216.  if (_rx_head != _rx_tail)
  217.  {
  218.   ch = *(_rx_tail++);
  219.   if (_rx_tail > _rx_end)
  220.    _rx_tail = _rx_top;
  221.   enable(); 
  222.   return(ch);
  223.  }
  224.  enable();
  225.  return(-1);
  226. }
  227.  
  228.  
  229. /* rsbreak() is used to transmit break. (Timing is up to
  230.  * the caller, 250 ms should be ok.)
  231.  *
  232.  * isbreak = 1 : activate break
  233.  *         = 0 : end break
  234.  */
  235.  
  236. void rsbreak(isbreak)
  237. int isbreak;
  238. {
  239.  unsigned char pbyte;
  240.  
  241.  pbyte = inportb(LINE_CNTL);
  242.  
  243.  if (isbreak) pbyte |= BREAK;
  244.  else pbyte &= ~BREAK;
  245.  
  246.  outportb(LINE_CNTL,pbyte);
  247. }
  248.  
  249.  
  250. /* rsinit() intializes the serial port and sets up the interrupt handler. 
  251.  *
  252.  * port  : 1 = com1, 2 = com2, 3 = com3, 4 = com4
  253.  * speed : communication speed
  254.  * pbyte : mode byte, see rsio.h for constants to
  255.  *         join together with bitwize-or
  256.  *
  257.  * returns: zero on success, -1 if port number out of range
  258.  */
  259.  
  260. int rsinit(port,speed,pbyte)
  261. int port, speed;
  262. unsigned char pbyte;
  263. {
  264.  if (port < 1 || port > 4)
  265.   return(-1);
  266.  
  267.  _port = port - 1;
  268.  
  269.  /* store, then modify the int vector */
  270.  
  271.  _oldvect = getvect(VECT);
  272.  setvect(VECT,rstrap);
  273.  
  274.  /* set communication parameters */
  275.  
  276.  speed = 0x180 / (speed / 300);
  277.  outportb(LINE_CNTL,DLAB);
  278.  outport(DIVISOR,speed);
  279.  outportb(LINE_CNTL,pbyte & ~DLAB);
  280.  
  281.  /* set DTR, RTS and OUT2 in modem control register */
  282.  
  283.  outportb(MOD_CNTL,MCNTL_DTR | MCNTL_RTS | MCNTL_OUT2);
  284.  
  285.  /* enable interrupts from 8250 and PIC 8259A */
  286.  
  287.  outportb(INT_CNTL,ENAB_RX | ENAB_TX);
  288.  outportb(0x21,~PICBIT & inportb(0x21));
  289.  
  290.  return(0);
  291. }
  292.  
  293.  
  294. /* rsend() 'turns off' the serial communications interrupt and restores
  295.  * the related interrupt vector.
  296.  */
  297.  
  298. void rsend()
  299. {
  300.  outportb(INT_CNTL,0x00);
  301.  outportb(0x21,PICBIT | inportb(0x21));
  302.  setvect(VECT,_oldvect);
  303. }