Return to _irq386.h CVS log

Up to [Witchaven II] / gcl520h

Annotation of gcl520h/_irq386.h, revision 1.1

1.1     ! root        1: #ifndef _IRQ32_DOT_H
        !             2: #define _IRQ32_DOT_H
        !             3: 
        !             4: /*
        !             5:  * _IRQ386.H          5.20A  June 8, 1995
        !             6:  *
        !             7:  * The Greenleaf Comm Library
        !             8:  *
        !             9:  * Copyright (C) 1984-1995 Greenleaf Software Inc.  All Rights Reserved.
        !            10:  *
        !            11:  * NOTES
        !            12:  *
        !            13:  *  This file contains all the structures and constants used by
        !            14:  *  the 32 bit IRQ Manager internal functions.  End users should never
        !            15:  *  have to include this file in any of their source modules.
        !            16:  *
        !            17:  * MODIFICATIONS
        !            18:  *
        !            19:  *  December 1, 1994   5.10A :  Initial release.
        !            20:  *
        !            21:  */
        !            22: 
        !            23: #define MAXIMUM_HANDLERS 10
        !            24: 
        !            25: #pragma pack( 1 )
        !            26: 
        !            27: typedef struct _tag_irqdata {
        !            28:     GF_FARPTR32 old_handler;
        !            29:     GF_FARPTR16 old_real_handler;
        !            30:     GF_FARPTR32 handler;
        !            31:     GF_FARPTR16 real_handler;
        !            32:     GF_FARPTR32 handler_data;
        !            33:     GF_FARPTR16 real_handler_data;
        !            34:     void ( GF_CONV *tear_down_function )( GF_FARPTR32 data );
        !            35:     int interrupt_number;
        !            36:     int saved_8259_bit;
        !            37:     int primary_8259;
        !            38:     int secondary_8259;
        !            39:     int mask_8259;
        !            40:     int int_count;
        !            41:     int real_int_count;
        !            42: } IRQDATA;
        !            43: 
        !            44: #pragma pack()
        !            45: 
        !            46: #ifdef __cplusplus
        !            47: extern "C" {
        !            48: #endif
        !            49: 
        !            50: int GF_CONV HookInterrupt( int interrupt_number,
        !            51:                            void ( GF_CDECL *handler )( GF_FARPTR32 data ),
        !            52:                            GF_FARPTR16 real_handler,
        !            53:                            GF_FARPTR32 handler_data,
        !            54:                            void ( GF_CONV *tear_down_function ) ( GF_FARPTR32 data ),
        !            55:                            int primary_8259,
        !            56:                            int secondary_8259,
        !            57:                            int mask_8259 );
        !            58: int GF_CONV UnHookInterrupt( int interrupt_number );
        !            59: GF_FARPTR32 GF_CONV _GetInterruptData( int interrupt_number );
        !            60: int GF_CONV RelocateIsrData( void );
        !            61: 
        !            62: #ifdef __cplusplus
        !            63: }
        !            64: #endif
        !            65: 
        !            66: /*
        !            67:  * These two extern definitions are really important.  When
        !            68:  * the 32 bit IRQ manager is initialized, it relocates the real portion
        !            69:  * of the IRQ manager, plus the table of IRQDATA blocks down to
        !            70:  * a block of real memory.  Thse two pointers let everyone else
        !            71:  * know where that memory block is.
        !            72:  */
        !            73: 
        !            74: extern GF_FARPTR16 RealBlockPtr16;
        !            75: extern GF_FARPTR32 RealBlockPtr32;
        !            76: /*
        !            77:  * Anything that is stored in the reloacted real section of memory
        !            78:  * can't be addressed directly.  Instead, we calculate an offset
        !            79:  * into the real mode segment by subtracting _SegmentStartRR16.  It
        !            80:  * is the first address in the real segment.  The next value defined
        !            81:  * here marks the end of the relocated real segment.  We only need it
        !            82:  * so we can figure out how much memory to relocate.
        !            83:  */
        !            84: 
        !            85: extern char _SegmentStartRR16;
        !            86: extern char _SegmentEndRR16;
        !            87: 
        !            88: /*
        !            89:  * This is a dummy stub real mode interrupt that I use
        !            90:  * to handle Ctrl-Break and Ctrl-C in real mode under PowerPack.
        !            91:  *
        !            92:  */
        !            93: 
        !            94: void GF_CDECL _RealIret( GF_FARPTR16 int_flag );
        !            95: void GF_CDECL kbd_int_handler( GF_FARPTR32 data );
        !            96: 
        !            97: 
        !            98: #endif /* #ifndef _IRQ32_DOT_H */
        !            99: 

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