开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 操作系统开发 > 查看源码
SIO.C
资源名称：ertos.rar　[点击查看]
上传用户：sunrenlu
上传日期：2022-06-13
资源大小：1419k
文件大小：20k
源码类别：

操作系统开发

开发平台：

DOS

SIO.C：源码内容
  1. /*
  2.  * SIO - Serial port I/O
  3.  * Copyright (c) 1990, 2000 Erick Engelke
  4.  * Utilizes special interrupt handling to support
  5.  *      - multiple COM ports per irq
  6.  *      - low latency for other interrupts on system board
  7.  *          - does not disable interrupts for long like most serial code
  8.  */
  10. #define TERM
  11. #define NEW
  13. #include <dos.h>
  14. #include <stdio.h>
  15. #include <stdlib.h>
  16. #include <rtos.h>
  17. #include <sio.h>
  18. #include <mem.h>
  20. #ifdef __DJGPP__
  21. #include <go32.h>
  22. #include <pc.h>
  23. #endif
  25. //#define FIFO    /* Use FIFO if found */
  27. #define RBR 0   /* receive  buffer register */
  28. #define THR 0   /* transmit buffer register */
  29. #define IER 1   /* interrupt enable register */
  30. #define IIR 2   /* interrupt ID register */
  31. #define LCR 3   /* line control register */
  32. #define MCR 4   /* modem control register */
  33. #define LSR 5   /* line status register */
  34. #define MSR 6   /* modem status register */
  36. #define DLL 0   /* divisor latch LSB when DLAB=1 */
  37. #define DLM 1   /* divisor latch MSB when DLAB=1 */
  39. #define DLAB      0x80   /* divisor latch bit */
  40. #define OUT2      0x8    /* interrupt enable on PC compatibles */
  41. #define IIRMASK   0x7    /* valid bits in the IIR register */
  42. #define IERENABLE 0xf    /* enable all SIO interrupt conditions */
  43. #define FIFOMASK  0x8
  45. #define DTR     0x01   /* data terminal ready */
  46. #define RTS     0x02   /* ready to send */
  47. #define CTS     0x10   /* ready to send */
  48. #define DELTA_CTS 0x01 /* change in CTS */
  49. #define DELTA_DSR 0x02 /* change in DSR */
  50. #define SETBRK 0x40 /* Break control */
  52. #define OCW1    0x21    /* 8259 */
  53. #define OCW2    0x20
  55. /* Line Status Register bits
  56.  */
  57. #define LSR_DR     0x01  /* receive data ready */
  58. #define LSR_OVRRUN 0x02  
  59. #define LSR_PARITY 0x04
  60. #define LSR_FRAME  0x08
  61. #define LSR_BREAK  0x10
  62. #define LSR_THRE   0x20  /* transmit holding register empty */
  63. #define LSR_TSRE   0x40
  64. #define TX_READY   (LSR_THRE|LSR_TSRE)
  66. #define MAXIRQS 15
  68. #if defined(__DJGPP__)
  69.   #define IntrHandler   struct irq_handler_info
  70.   #define NULL_ISR      { {0,0}, {0,0} }
  72. #elif defined(__TURBOC__)
  73.   typedef void interrupt (*IntrHandler)(void);
  74.   #define NULL_HANDLER  ((void far*)0)
  75.   #define NULL_ISR      ((void far*)0)
  77. #elif defined(__BORLANDC__)
  78.   typedef void (cdecl interrupt *IntrHandler)(void);
  79.   #define NULL_HANDLER  ((void far*)0)
  80.   #define NULL_ISR      ((void far*)0)
  82. #else
  83.   #error Unsupported compiler
  84. #endif
  86. static IntrHandler oldisrs[ MAXIRQS + 1 ] =
  87.    { NULL_ISR, NULL_ISR, NULL_ISR, NULL_ISR,
  88.      NULL_ISR, NULL_ISR, NULL_ISR, NULL_ISR,
  89.      NULL_ISR, NULL_ISR, NULL_ISR, NULL_ISR,
  90.      NULL_ISR, NULL_ISR, NULL_ISR, NULL_ISR };
  93. typedef struct _sio_str {
  94.     WORD    sio_port;
  95.     WORD    sio_irq;
  96.     WORD    sio_int;    /* 8 + irq or ... */
  97.     IntrHandler sio_previsr;
  99.     bq_str *sio_rbq;    /* receive byte queue */
  100.     bq_str *sio_tbq;    /* transmit byte queue */
  102.     thread_x *sio_notify;
  103.     int     sio_message;
  104.     BYTE    sio_hwflow;             // Hardware flow control enable
  105.     BYTE    sio_modemstatus;
  106.     int     sio_highwater;  // Receive buffer high water mark
  107.     int     sio_lowwater;   // Receive buffer low water mark
  108. } sio_str;
  110. static sio_str sio[ MAXSIO ] = {
  111.         {0, 0, 0, NULL_ISR, NULL, NULL, NULL, 0, 0, 0, 0, 0},
  112.         {0, 0, 0, NULL_ISR, NULL, NULL, NULL, 0, 0, 0, 0, 0},
  113.         {0, 0, 0, NULL_ISR, NULL, NULL, NULL, 0, 0, 0, 0, 0},
  114.         {0, 0, 0, NULL_ISR, NULL, NULL, NULL, 0, 0, 0, 0, 0}};
  116. static char *sio_err = "SIO call with com port out of range";
  118. static struct {
  119.        DWORD num_rm_intr;
  120.        DWORD num_pm_intr;
  121.        DWORD num_thre;
  122.        DWORD num_rx_intr;
  123.        DWORD num_fifo_rx_intr;
  124.        DWORD num_modem_stat;
  125.        struct {
  126.          DWORD general;
  127.          DWORD overrun;
  128.          DWORD parity;
  129.          DWORD framing;
  130.          DWORD breaking;
  131.        } num_line_stat;
  132.      } sio_stats [MAXSIO];
  134. #define test_com_valid( n )  do {                      
  135.                                if (!n || (n > MAXSIO)) 
  136.                                   rt_halt (sio_err);   
  137.                              } while (0)
  140. #if defined(__BORLANDC__) || defined(__TURBOC__)
  141. #pragma option -N-   /* disable stack checking */
  142. #endif
  144. static int sio_isr(int irq)
  145. {
  146.     int com;
  147.     int handled = 0;
  148.     sio_str *s;
  149.     WORD intid;
  150.     WORD base;
  151.     BYTE b;
  152.     BYTE status;
  154.     for ( com = 0 ; com < MAXSIO ; ++com ) {
  155.         s = &sio[ com ];
  156.         base = s->sio_port;
  157.         if ( base == 0 )
  158.             continue;
  159.         if ( s->sio_irq != irq )
  160.             continue;
  162. #ifdef __DJGPP__
  163.         sio_stats[com].num_pm_intr++; /* to-do: use a bimodal handler */
  164. #else
  165.         sio_stats[com].num_rm_intr++;
  166. #endif
  168.         while ( 1 ) {
  170.             intid = inportb( base + IIR );
  172.             if ( intid & 1 )
  173.                 break;  /* no interrupt pending */
  175.             switch ( intid & IIRMASK ) {
  177.                 case 0  :   /* change in modem status */
  178.                             s->sio_modemstatus = inportb( base + MSR );
  179.                             sio_stats[com].num_modem_stat++;
  181.                             if (s->sio_notify)
  182.                                 ksendmessage (s->sio_notify , s->sio_message+2, s->sio_modemstatus);
  183.                             if (s->sio_hwflow) {
  184.                                 if (s->sio_modemstatus & CTS) {
  185.                                     if (inportb (base + LSR) & LSR_THRE) {
  186.                                         if (bq_getbyte (s->sio_tbq, &b))
  187.                                             outportb (base + THR, b);
  188.                                     }
  189.                                 }
  190.                             }
  191.                             break;
  192.                 case 2  :   /* ready to transmit */
  193.                             sio_stats[com].num_thre++;
  194.                             if (s->sio_hwflow) {
  195.                                 if (!(s->sio_modemstatus & CTS))
  196.                                     break;
  197.                             }
  199.                             if ( bq_getbyte( s->sio_tbq, &b ) )
  200.                                 outportb( base + THR, b );
  202.                             break;
  203.                 case 4  :   /* received data */
  204.                             if (intid & FIFOMASK)
  205.                                  sio_stats[com].num_fifo_rx_intr++;
  206.                             else sio_stats[com].num_rx_intr++;
  208.                             b = inportb( base + RBR );
  210.                             bq_sendbyte( s->sio_rbq , b );
  211. #if 0
  212.                             if (s->sio_notify)
  213.                                ksend1message (s->sio_notify , s->sio_message, b);
  214. #endif
  215.                             if (s->sio_hwflow) {
  216.                                 if (bq_readcount (s->sio_rbq) >= s->sio_highwater) {
  217.                                     status = inportb (base + MCR);
  218.                                     outportb (base + MCR, status & ~RTS);
  219.                                 }
  220.                             }
  222.                             break;
  223.                 case 6  :   /* line status */
  224.                             b = inportb( base + LSR );
  225.                             sio_stats[com].num_line_stat.general++;
  226.                             if (b & LSR_OVRRUN)
  227.                                sio_stats[com].num_line_stat.overrun++;
  228.                             if (b & LSR_PARITY)
  229.                                sio_stats[com].num_line_stat.parity++;
  230.                             if (b & LSR_FRAME)
  231.                                sio_stats[com].num_line_stat.framing++;
  232.                             if (b & LSR_BREAK)
  233.                                sio_stats[com].num_line_stat.breaking++;
  235. #if 0
  236.                             if (s->sio_notify)
  237.                               ksendmessage (s->sio_notify , s->sio_message+1, b);
  238. #endif
  239.                             break;
  240.                default :    /* ! added */
  241.                             (void) inportb (base + LSR);
  242.                             (void) inportb (base + MSR);
  243.                             handled--;
  244.                             break;
  245.             }
  246.             handled++;
  247.         }
  248.    }
  249.    return (handled);
  250. }
  252. //-----------------------------------------------------------------------
  253. // ----------------------------------------------------------------------
  254. #define IEC_PRIMARY 0x21
  255. #define IEC_SECONDARY 0xA1
  257. #if defined(__DJGPP__)
  258.   #define do_chain(irq)  ((void)0) /* never chain */
  260. #elif defined(__BORLANDC__) || defined(__TURBOC__)
  261.   #define do_chain(irq)  if (oldisrs[irq]) (*oldisrs[irq])()
  262. #endif
  264. /* this code produces low latency for other interrupt handlers */
  266. #define UART_INT( irqlevel, iec ) 
  267.     void interrupt uart_int##irqlevel ( void ) 
  268.     {           
  269.         kinisr++; 
  270.         outportb( iec , inportb( iec ) | ( 1 << irqlevel )); 
  271.         if ( iec == IEC_SECONDARY ) 
  272.             outportb( 0xA0, 0x60|irqlevel); /* specific EOI */  
  273.         outportb( 0x20, 0x60|irqlevel); 
  274.         enable(); 
  275.                   
  276.         /*!! Shouldn't EOI be sent after our work is done? */ 
  277.         if (!sio_isr( irqlevel )) 
  278.            do_chain (irqlevel);   
  279.         else { 
  280.           disable(); 
  281.           outportb( iec, inportb( iec ) & ~ ( 1 << irqlevel )); 
  282.         }  
  283.         kinisr--; 
  284.     }
  286. UART_INT( 3, IEC_PRIMARY )
  287. UART_INT( 4, IEC_PRIMARY )
  288. UART_INT( 5, IEC_PRIMARY )
  289. UART_INT( 6, IEC_PRIMARY )
  290. UART_INT( 7, IEC_PRIMARY )
  291. UART_INT( 9, IEC_SECONDARY )
  292. UART_INT(10, IEC_SECONDARY )
  293. UART_INT(11, IEC_SECONDARY )
  294. UART_INT(12, IEC_SECONDARY )
  295. UART_INT(13, IEC_SECONDARY )
  296. UART_INT(14, IEC_SECONDARY )
  297. UART_INT(15, IEC_SECONDARY )
  300. #if defined(__BORLANDC__) || defined(__TURBOC__)
  301. #pragma option -N.   /* default stack checking */
  302. #endif
  305. //---------------------------------------------------------------------------
  306. int uart_detect( WORD base )
  307. {
  308.     BYTE x, ov, scr = 1;
  310.     // check for LCR
  311.     ov = inportb( base + 3 );
  312.     outportb( base + 3, 0x1b );
  313.     if ( inportb( base + 3 ) != 0x1b ) return -1;
  315.     outportb( base + 3, 0x03 );
  316.     if ( inportb( base + 3 ) != 0x03 ) return -1;
  318.     // restore its value
  319.     outportb( base + 3, ov );
  321.     // look for scratch register
  322.     ov = inportb( base + 7 );
  323.     outportb( base + 7, 0x55 );
  324.     if ( inportb( base + 7 ) != 0x55 ) scr = 0;
  325.     outportb( base + 7, 0xAA ) ;
  326.     if ( inportb( base + 7 ) != 0xAA ) scr = 0;
  327.     outportb( base + 7, ov );
  329.     // look for FIFO
  330.     outportb( base +2, 0x01);
  331.     x = inportb( base + 2 );
  332.     outportb( base + 2, 0 );
  333.     if ( ! ( x & 0x80 ) ) return scr;
  334.     if ( ! ( x & 0x40 ) ) return scr + 2;
  335.     return scr + 4;
  336. }
  338. int uart_enable_fifo( WORD base, WORD trigger )
  339. {
  340.     // 0 on success or no FIFO
  341.     // -1 on error
  342.     BYTE x;
  344.     outportb( base + 2, 1 );        // key to getting C0 right
  345.     x = inportb( base + 2 ) & 0xC0 ;
  346.     if ( x == 0 ) return( -1 );
  347.     if ( x == 0x80 ) {
  348.         outportb( base + 2, 0 );
  349.         return -1;      // bad fifo, disabled it
  350.     }
  351.     outportb( base + 2, trigger & (0xc0 | 0x07) );
  352.     return 0 ;
  353. }
  354. void uart_disable_fifo( WORD base )
  355. {
  356.     outportb( base + 2, 0 );
  357. }
  358. //--------------------------------------------------------------------
  360. void sio_print_stats (int com)
  361. {
  362.   if (com < 1 || com >= MAXSIO-1)
  363.      return;
  365.   com--;
  366.   printf ("COM%d stats: intr %lu/%lu, THRE %lu, Rx-intr %lu, FIFO %lu, "
  367.           "modem %lu, line %lun",
  368.           com+1, sio_stats[com].num_rm_intr, sio_stats[com].num_pm_intr,
  369.           sio_stats[com].num_thre, sio_stats[com].num_rx_intr,
  370.           sio_stats[com].num_fifo_rx_intr, sio_stats[com].num_modem_stat,
  371.           sio_stats[com].num_line_stat.general);
  372.   printf ("  (overrun %lu, parity %lu, framing %lu, breaking %lu)n",
  373.           sio_stats[com].num_line_stat.overrun,
  374.           sio_stats[com].num_line_stat.parity,
  375.           sio_stats[com].num_line_stat.framing,
  376.           sio_stats[com].num_line_stat.breaking);
  377. }
  379. //----------------------------------------------------------------------
  382. void
  383. sio_init (int com, int port, int irq, int rbufsize, int tbufsize, thread_x *notify, int message)
  384. {
  385.     static int atexit_done = 0;
  386.     WORD flags;
  387.     sio_str *s;
  388.     void interrupt (*isr)() = NULL;
  390.     sio_close( com );   /* clean up any previous stuff */
  392.     test_com_valid (com);
  394.     rt_cpu_block( &flags );
  396.     s = &sio[ com - 1 ];
  397.     s->sio_port = port;
  398.     s->sio_irq = irq;
  400.     s->sio_notify = notify;
  401.     s->sio_message = message;
  402.     s->sio_highwater = (int)(((long)rbufsize * 90L)/100L);
  403.     s->sio_lowwater = (int)(((long)rbufsize * 10L)/100L);
  404.     s->sio_hwflow = 0;
  405.     s->sio_modemstatus = 0;
  407.     if ( s->sio_rbq != NULL ) bq_free( s->sio_rbq );
  408.     if ( s->sio_tbq != NULL ) bq_free( s->sio_tbq );
  410.     s->sio_rbq = bq_alloc( rbufsize );
  411.     s->sio_tbq = bq_alloc( tbufsize );
  413.     /* disable ints */
  414.     outportb (port + IER , 0);
  416.     switch ( irq ) {
  417.         case  3 : isr = uart_int3;    break;
  418.         case  4 : isr = uart_int4;    break;
  419.         case  5 : isr = uart_int5;    break;
  420.         case  6 : isr = uart_int6;    break;
  421.         case  7 : isr = uart_int7;    break;
  422.         case  9 : isr = uart_int9;    break;
  423.         case 10 : isr = uart_int10;   break;
  424.         case 11 : isr = uart_int11;   break;
  425.         case 12 : isr = uart_int12;   break;
  426.         case 13 : isr = uart_int13;   break;
  427.         case 14 : isr = uart_int14;   break;
  428.         case 15 : isr = uart_int15;   break;
  429.     }
  430. #ifdef OLD
  432. switch (com)
  433. {
  434. case 1:
  435.     isr = sio_isr1;
  436. break;
  437. case 2:
  438.     isr = sio_isr2;
  439. break;
  440. }
  441. #endif
  443. #ifdef __DJGPP__
  444.     if ( oldisrs[ irq ].new_handler.pm_offset == 0 ) {
  445.         irq_handler_info *inf = rt_enableirq( irq, isr );
  446.         if (!inf)
  447.         {
  448.           fprintf (stderr,"called to hook IRQ %dn", irq);
  449.           return;
  450.         }
  451.         oldisrs[irq] = *inf;
  452.     }
  453. #else
  454.     if ( oldisrs[ irq ] == NULL_HANDLER ) {
  455.         oldisrs[irq] = rt_enableirq( irq, isr );
  456.     }
  457. //  s->sio_previsr = rt_enableirq (irq, isr);
  458. #endif
  460.     if (!atexit_done)
  461.        atexit (sio_exit);
  462.     atexit_done = 1;
  463.     rt_cpu_unblock( &flags );
  464. }
  466. void sio_close( int com )
  467. {
  468.     WORD base;
  469.     sio_str *s;
  470.     int tempcom, count;
  472.     test_com_valid( com );
  473.     s = &sio[ com - 1 ];
  474.     base = s->sio_port;
  476.     if ( base ) {
  477.         /* disable sio ints */
  478.         outportb( base + IER, 0 );
  480.         for ( tempcom = count = 0; tempcom < MAXSIO ; ++tempcom )
  481.             if ( sio[ tempcom ].sio_irq == s->sio_irq ) count++;
  483.         /* only remove ISR if we are the last one using it */
  484.         if ( count == 1 )
  485.         {
  486. #ifdef __DJGPP__
  487.            if ( oldisrs[ s->sio_irq].new_handler.pm_offset)
  488.            {
  489.              rt_disableirq ( s->sio_irq, &oldisrs[ s->sio_irq ] );
  490.              oldisrs[ s->sio_irq ].new_handler.pm_offset = 0;
  491.            }
  492. #else
  493.            if ( oldisrs[ s->sio_irq] != NULL_HANDLER )
  494.            {
  495.              rt_disableirq ( s->sio_irq, oldisrs[ s->sio_irq ] );
  496.              oldisrs[ s->sio_irq ] = NULL_HANDLER;
  497.            }
  498. #endif
  499.         }
  501.         /* bring down com line  */
  502.         outportb (base + MCR , 0);
  503. #ifdef FIFO
  504.         uart_disable_fifo( base );
  505. #endif
  507.         s->sio_port = 0;
  508.         s->sio_irq = 0;     /* so last sio_close() on that IRQ knows it */
  509.     }
  510.     if ( s->sio_rbq != NULL ) {
  511.         bq_free( s->sio_rbq );
  512.         s->sio_rbq = NULL;
  513.     }
  514.     if ( s->sio_tbq != NULL ) {
  515.         bq_free( s->sio_tbq );
  516.         s->sio_tbq = NULL;
  517.     }
  520. }
  522. void
  523. sio_setup (int com, DWORD baud, int bits, int parity, int stop, BYTE hwflow)
  524. {
  525.     WORD flags;
  526.     WORD divisor;
  527.     WORD base;
  528.     BYTE parmbyte;
  529.     sio_str *s;
  530.     BYTE b;
  532.     test_com_valid( com );
  534. #define LOW(  x ) ( x & 255 )
  535. #define HIGH( x ) ( x >> 8 )
  536.     s = &sio[ com - 1];
  537.     divisor = (WORD) (115200L / baud);
  539.     /* word length from [5,8] gives results [0,3] */
  540.     if ( bits == 0 ) bits = 8;
  541.     parmbyte = bits - 5;
  542.     parmbyte |= (stop -1) << 2;
  543.     if (parity) parmbyte |= 8;
  544.     if (parity == SIO_PARITY_EVEN) parmbyte |= 16;
  546.     rt_cpu_block( &flags );
  547.     base = s->sio_port;
  548.     s->sio_hwflow = hwflow; // establish hardware flow control
  550.     /* disable sio int */
  551.     outportb( base + IER, 0 );  /* disable all serial interrupts */
  552.     /* disable adapter, DTR RTS */
  553.     outportb( base + MCR , 0 );
  555.     /* set DLAB for a moment */
  556.     outportb( base + LCR , inportb( base + LCR ) | DLAB );
  558.     /* pass the divisor */
  559.     outportb( base + DLL , LOW( divisor ));
  560.     outportb( base + DLM , HIGH( divisor ));
  562.     /* clear DLAB */
  563.     outportb( base + LCR , inportb( base + LCR ) & ~DLAB );
  565.     /* set word length and parity */
  566.     outportb( base + LCR, parmbyte );
  568.     /* clear any trash */
  569.     while (inportb (base + LSR) & LSR_DR)
  570.          inportb (base + RBR);
  572.     // Send the initial notification of the line status
  573.     b = inportb (base + LSR);
  574.     if (s->sio_notify)
  575.        ksendmessage (s->sio_notify , s->sio_message+1, b);
  577.     // Send the initial notification of the modem status
  578.     s->sio_modemstatus = inportb( base + MSR );
  579.     if (s->sio_notify)
  580.        ksendmessage (s->sio_notify , s->sio_message+2,
  581.                      s->sio_modemstatus | DELTA_CTS | DELTA_DSR);
  583.     /* enable adapter, DTR RTS */
  584.     outportb( base + MCR , DTR | RTS | OUT2 );
  586.     /* enable sio int */
  587.     outportb( base + IER, IERENABLE );  /* enable all serial interrupts */
  588. #ifdef FIFO
  589.     uart_enable_fifo( base, 0xC0 );
  590. #endif
  591.     rt_cpu_unblock( &flags );
  592. }
  594. int sio_recv_waiting( int com )
  595. {
  596.     test_com_valid( com );
  597.     return( bq_readcount( sio[ com - 1 ].sio_rbq ) );
  598. }
  600. int sio_tran_waiting( int com )
  601. {
  602.     test_com_valid( com );
  603.     return( bq_readcount( sio[ com - 1 ].sio_tbq ) );
  604. }
  606. BYTE sio_readbyte( int com )
  607. {
  608.     BYTE x;
  609.     BYTE status;
  610.     WORD base;
  611.     sio_str *s;
  613.     test_com_valid( com );
  614.     s = &sio[ com - 1];
  615.     base = s->sio_port;
  616.     bq_readbyte( s->sio_rbq , &x ) ;
  617.     if (s->sio_hwflow)
  618.     {
  619.       if (bq_readcount (s->sio_rbq) <= s->sio_lowwater)
  620.       {
  621.         status = inportb (base + MCR);
  622.         outportb (base + MCR, status | RTS);
  623.       }
  624.     }
  625.     return( x );
  626. }
  628. void sio_writebyte (int com, BYTE b)
  629. {
  630.     sio_str *s;
  631.     BYTE status;
  632.     WORD base;
  633.     WORD flags;
  635.     test_com_valid (com);
  636.     s = &sio[com - 1];
  637.     base = s->sio_port;
  639.     /* always send it to the queue */
  640.     bq_writebyte (s->sio_tbq, b);
  642.     /* now check if we need to start the UART siphon */
  643.     rt_cpu_block( &flags );
  645.     if (!(s->sio_hwflow) || (s->sio_modemstatus & CTS)) {
  646.         status = inportb (base + LSR);    /* get UART status */
  647.         if (status & LSR_THRE) {
  648.             /* holding register is empty, fill it if data is available */
  649.             if (bq_getbyte (s->sio_tbq, &b))
  650.                 outportb (base + THR, b);
  651.         }
  652.     }
  653.     rt_cpu_unblock (&flags);
  654. }
  656. void sio_exit (void)
  657. {
  658.     int i;
  659.     for (i = 1 ; i < MAXSIO ; ++i)
  660.     {
  661.         if (kdebug > 2)
  662.            sio_print_stats (i);
  663.         sio_close (i);
  664.     }
  665. }
  667. void sio_msg( int com, int xmit, int recv )
  668. {
  669.     sio_str *s;
  671.     test_com_valid( com );
  672.     s = &sio[ com - 1 ];
  674.     if ( xmit ) bq_msg( s->sio_tbq, EMSG_BQ_AVAIL );
  675.     if ( recv ) bq_msg( s->sio_rbq, EMSG_BQ_WAITING );
  676. }
  678. BYTE sio_getmcr (int com)
  679. {
  680.     sio_str *s;
  682.     test_com_valid (com);
  683.     s = &sio[com - 1];
  684.     return (inportb (s->sio_port + MCR));
  685. }
  687. void sio_setmcr (int com, BYTE mcr)
  688. {
  689.     sio_str *s;
  691.     test_com_valid (com);
  692.     s = &sio[com - 1];
  693.     outportb (s->sio_port + MCR, mcr);
  694. }
  696. void sio_setbreak (int com, BYTE brk)
  697. {
  698.     sio_str *s;
  700.     test_com_valid (com);
  701.     s = &sio[com - 1];
  702.     outportb (s->sio_port + LCR,
  703.               (inportb (s->sio_port + LCR) & ~SETBRK) | (brk & SETBRK));
  704. }