Return to rciol CVS log

Up to [Synchronet] / sbbs / steve

Annotation of sbbs/steve/rciol, revision 1.1.1.1

1.1       root        1: 
                      2: rioini(int,int);
                      3:     1st arg: can be 1-4 (com port) or base address, or 0 to terminate
                      4:     2nd arg: can be irq line (presently 1-7) or 0 (com1/3=4, com2/4=3)
                      5:     returns: -1 if error, else 0
                      6: setbaud(int);
                      7:     returns: -1 if rioini() not called first, else 0
                      8: dtr(char);
                      9:     argument: 0 off, 1 on, 2-n off then wait n seconds for dcd off
                     10:     returns: -1 if rioini() not called or timeout, else 0
                     11: outcom(int);
                     12:     argument: character to output (low 8 bits)
                     13:     returns: state (high 8 bits)
                     14: incom(void);
                     15:     returns: character from input buffer (low 8 bits), state (high 8 bits)
                     16: rioctl(int);
                     17:     argument: action (see below)
                     18:     returns: mode or state (high 8 bits), status (low 8 bits)
                     19: rioifc(char);
                     20:     argument: defines what interrupts to intercept (see below)
                     21:     returns: -1 if no action taken, else 0
                     22: 
                     23: 
                     24: prototypes and equates:
                     25: ------------------------------------------------------------------------------
                     26: int rioini(int com,int irq);          /* initialize com,irq */
                     27: int setbaud(int rate);                /* set baud rate */
                     28: int rioctl(int action);               /* remote i/o control */
                     29: int dtr(char onoff);                  /* set/reset dtr */
                     30: int outcom(int ch);                   /* send character */
                     31: int incom(void);                      /* receive character */
                     32: int rioifc(char intcode);             /* local i/o redirection */
                     33: 
                     34: /* i/o mode and state flags */
                     35: 
                     36: #define CTSCK 0x800     /* check cts (mode only) */
                     37: #define ABORT 0x400     /* check for ^C (mode), aborting (state) */
                     38: #define PAUSE 0x200     /* check for ^S (mode), pausing (state) */
                     39: #define NOINP 0x100     /* input buffer empty (incom only) */
                     40: 
                     41: /* status flags */
                     42: 
                     43: #define DCD 0x80        /* DCD on */
                     44: #define CTS 0x10        /* CTS on */
                     45: #define RXLOST 1        /* Receive buffer overflow */
                     46: 
                     47: /* rioctl() arguments */
                     48: /* returns mode or state flags in high 8 bits, status flags in low 8 bits */
                     49: 
                     50:                     /* the following return mode in high 8 bits */
                     51: #define IOMODE 0        /* no operation */
                     52: #define IOSM 1          /* i/o set mode flags */
                     53: #define IOCM 2          /* i/o clear mode flags */
                     54:                     /* the following return state in high 8 bits */
                     55: #define IOSTATE 4       /* no operation */
                     56: #define IOSS 5          /* i/o set state flags */
                     57: #define IOCS 6          /* i/o clear state flags */
                     58: #define IOFB 0x308      /* i/o buffer flush */
                     59: #define IOFI 0x208      /* input buffer flush */
                     60: #define IOFO 0x108      /* output buffer flush */
                     61: #define IOSE 9          /* i/o set error flags */
                     62: 
                     63: /* rioifc() arguments */
                     64: 
                     65: #define INT29 1         /* copy int 29h output to remote */
                     66: #define INT29B 3        /* copy int 29h, use BIOS locally (_putlc) */
                     67: #define INT16 0x10      /* return remote chars to int 16h calls */
                     68: #define INTCLR 0        /* release int 16h, int 29h */
                     69: ------------------------------------------------------------------------------
                     70: You can make whatever permutations of these make things easy, e.g.,
                     71: 
                     72: #define INCHK IOSM|PAUSE|ABORT   /* check for ^C and ^S (mode) */
                     73: #define NOCHK IOCM|PAUSE|ABORT   /* turn off ^C and ^S checking */
                     74: 
                     75: Then rioctl(INCHK); turns checking on, and rioctl(NOCHK); turns it off.
                     76: 
                     77: A sample calling sequence:
                     78: 
                     79:     rioini(3,0);
                     80:     setbaud(2400);
                     81:     rioctl(INCHK);
                     82:     i=incom();
                     83:     if (!i&NOINP) putlc(i);
                     84:     else if (i&ABORT) {
                     85:         rioctl(IOCS|ABORT);  /* reset abort flag */
                     86:         lprintf("YAAA!\n"); }
                     87:     rioifc(INT29B|INT16);
                     88:     spawn(or something);
                     89:     rioifc(INTCLR); /* this puts the original int29/int16 vectors back */
                     90:     rioini(0,0);  /* this puts the original int0b vector back
                     91:                      and will release the irq line */
                     92: 
                     93: Note: incom() returns 500h (not 400h) when in an abort wait, because the
                     94:       input buffer is always cleared.  If output is paused, incom may return
                     95:       2xxh or 300h, depending on whether there is a character in the input
                     96:       buffer.  Pause (200h) and abort (400h) will never be set at the same
                     97:       time.
                     98: 
                     99: No questions, right?  Clear as a sky of azure blue?

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.