Return to _fast.h CVS log

Up to [Witchaven II] / gcl520h

Annotation of gcl520h/_fast.h, revision 1.1.1.1

1.1       root        1: #ifndef __FAST_DOT_H
                      2: #define __FAST_DOT_H
                      3: 
                      4: /*
                      5:  * _FAST.H      5.20A  June 8, 1995
                      6:  *
                      7:  *  The Greenleaf Comm Library
                      8:  *
                      9:  *  Copyright (C) 1991-1995 Greenleaf Software Inc.  All Rights Reserved.
                     10:  *
                     11:  * NOTES
                     12:  *
                     13:  * This header file contains constants, structures, and definitions
                     14:  * used by the Greenleaf Fast interface code.  There should generally
                     15:  * not be any reason for an end user of the library to include this file.
                     16:  *
                     17:  * MODIFICATIONS
                     18:  *
                     19:  * December 12, 1992  4.00A : Initial release
                     20:  */
                     21: 
                     22: /*
                     23:  * In order to change the buffer size, you need to edit the line here
                     24:  * and change the 1024 to some other power of 2.  Then change the
                     25:  * equivalent line in _FISRASM.EQU to the same number.  Finally,
                     26:  * BUILD X FAST_*.C F_*.ASM, and you have a new buffer size.
                     27:  */
                     28: 
                     29: #define FAST_BUFFER_SIZE      1024
                     30: #define FAST_HIGH_WATER_MARK  ( ( FAST_BUFFER_SIZE * 3 ) / 4 )
                     31: #define FAST_LOW_WATER_MARK   ( FAST_BUFFER_SIZE / 4 )
                     32: 
                     33: /*
                     34:  * #define FAST_ISR_IN_C
                     35:  */
                     36: 
                     37: /*
                     38:  * Note that real far pointers are saved as unsigned longs.  This
                     39:  * prevents protected mode code from accidentally choking if and
                     40:  * when it treats a real mode address as a pointer
                     41:  */
                     42: 
                     43: #define FAST_PORT  struct _tag_fast_port
                     44: 
                     45: #if defined( GF_X32 )
                     46: #pragma pack( 1 )
                     47: #endif
                     48: 
                     49: struct _tag_fast_port {
                     50: #if defined( GF_X32 )
                     51:     GF_FARPTR32 next_fast_port;
                     52:     GF_FARPTR16 real_next_fast_port;
                     53: #elif defined( GF_X16 )
                     54:     struct _tag_fast_port far *next_fast_port;
                     55:     GF_REALPTR16 real_next_fast_port;
                     56: #else
                     57:     struct _tag_fast_port GF_FAR *next_fast_port;
                     58:     unsigned long real_next_fast_port;
                     59: #endif
                     60:     int fast_id;
                     61:     int uart_base;
                     62:     int head_pointer;
                     63:     int tail_pointer;
                     64:     int interrupt_number;
                     65:     int line_status;
                     66:     int mcr_rx_handshake_bit;
                     67:     int msr_tx_handshake_bit;
                     68:     int blocking;
                     69:     int is_16550;
                     70:     int use_16550_TX_fifo;
                     71:     int trigger_level;
                     72:     char buffer[ FAST_BUFFER_SIZE ];
                     73: };
                     74: 
                     75: #undef FAST_PORT
                     76: 
                     77: typedef struct _tag_fast_port FAST_PORT;
                     78: 
                     79: /*
                     80:  * A short port is just the fast port minus the buffer.  I use this
                     81:  * a lot under the 32 bit DOS extenders, when I copy the port structure
                     82:  * into a shadow structure to dink with it.
                     83:  */
                     84: 
                     85: typedef struct _tag_short_fast_port {
                     86: #if defined( GF_X32 )
                     87:     GF_FARPTR32 next_fast_port;
                     88:     GF_FARPTR16 real_next_fast_port;
                     89: #elif defined( GF_X16 )
                     90:     struct _tag_fast_port far *next_fast_port;
                     91:     GF_REALPTR16 real_next_fast_port;
                     92: #else
                     93:     struct _tag_fast_port GF_FAR *next_fast_port;
                     94:     unsigned long real_next_fast_port;
                     95: #endif
                     96:     int fast_id;
                     97:     int uart_base;
                     98:     int head_pointer;
                     99:     int tail_pointer;
                    100:     int interrupt_number;
                    101:     int line_status;
                    102:     int mcr_rx_handshake_bit;
                    103:     int msr_tx_handshake_bit;
                    104:     int blocking;
                    105:     int is_16550;
                    106:     int use_16550_TX_fifo;
                    107:     int trigger_level;
                    108: } SHORT_FAST_PORT;
                    109: int GF_CONV _DumpPortStatusGreenleafFast( PORT *port, PORT_DUMPER printer );
                    110: 
                    111: #if defined( GF_X32 )
                    112:   void GF_CDECL _GreenleafFastRealIsr( GF_FARPTR16 fast_port );
                    113:   void GF_CDECL _GreenleafFastIsr( GF_FARPTR32 fast_port );
                    114: #elif defined( GF_X16 )
                    115:   void GF_CDECL far _GreenleafFastRealIsr( FAST_PORT far *fast_port );
                    116:   void GF_CDECL far _GreenleafFastIsr( FAST_PORT far *fast_port );
                    117: #else
                    118:   void GF_CDECL GF_FAR _GreenleafFastIsr( FAST_PORT GF_FAR *fast_port );
                    119: #endif
                    120: 
                    121: #if defined( GF_X32 )
                    122: #pragma pack()
                    123: #endif
                    124: 
                    125: #endif  /* #ifndef __FAST_DOT_H */
                    126: 

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