src/include/interrupt.h

#ifndef INTERRUPT_H
#define INTERRUPT_H

/*
 *  Copyright (C) 2006-2007  Anders Gavare.  All rights reserved.
 *
 *  Redistribution and use in source and binary forms, with or without
 *  modification, are permitted provided that the following conditions are met:
 *
 *  1. Redistributions of source code must retain the above copyright
 *     notice, this list of conditions and the following disclaimer.
 *  2. Redistributions in binary form must reproduce the above copyright  
 *     notice, this list of conditions and the following disclaimer in the 
 *     documentation and/or other materials provided with the distribution.
 *  3. The name of the author may not be used to endorse or promote products
 *     derived from this software without specific prior written permission.
 *
 *  THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
 *  ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 *  IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 *  ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE   
 *  FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 *  DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
 *  OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 *  HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 *  LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
 *  OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 *  SUCH DAMAGE.
 *
 *
 *  $Id: interrupt.h,v 1.4 2007/02/03 16:18:56 debug Exp $
 *
 *  Definitions related to the Interrupt subsystem.
 */

#include "misc.h"

struct interrupt {
        /*  Functions used to assert and deassert the interrupt.  */
        void            (*interrupt_assert)(struct interrupt *);
        void            (*interrupt_deassert)(struct interrupt *);

        /*
         *  The interrupt "line" number, or "pin" number, is an internal number
         *  used by interrupt_assert() and interrupt_deassert(). It may
         *  correspond to a physical interrupt number, or it may be ignored
         *  completely.
         *
         *  This can either be a small integer corresponding to the interrupt
         *  pin number, or an entire interrupt mask (for controllers with at
         *  most 32 interrupts).
         */
        uint32_t        line;

        /*
         *  The extra pointer is a pointer to the (conceptual) interrupt
         *  handler. For a CPU interrupt, this is a pointer to the CPU. For
         *  e.g. a 8259 interrupt, it is a pointer to the dev_8259 which will
         *  handle it.
         */
        void            *extra;

        /*
         *  Actual name of the interrupt. This is a complete "path", e.g.
         *  "emul[0].machine[0].cpu[1].irq[3].isa[14]". It is used for
         *  connecting/disconnecting, and debug output.
         */
        char            *name;
};


/*
 *  Macros to make code using the interrupt struct a bit more consise:
 */

#define INTERRUPT_ASSERT(istruct)       (istruct).interrupt_assert(&(istruct))
#define INTERRUPT_DEASSERT(istruct)     (istruct).interrupt_deassert(&(istruct))

#define INTERRUPT_CONNECT(name,istruct)         {               \
        interrupt_handler_lookup(name, &(istruct));             \
        interrupt_connect(&(istruct), 0);                       \
        }

#define INTERRUPT_CONNECT_EXCLUSIVE(name,istruct)       {       \
        interrupt_handler_lookup(name, &(istruct));             \
        interrupt_connect(&(istruct), 1);                       \
        }


/*
 *  Registration of interrupt handlers:
 *
 *  Each interrupt handler (i.e. CPUs, interrupt controllers, various bus
 *  controllers) should call interrupt_handler_register() to register itself.
 */

void interrupt_handler_register(struct interrupt *template);
void interrupt_handler_remove(char *name);
int interrupt_handler_lookup(char *name, struct interrupt *template);


/*
 *  Functions used to keep track of exclusive and non-exclusive users,
 *  respectively, of an interrupt.
 *
 *  If interrupt_connect() returns, it means it succeeded. On failure, the
 *  emulator exits. There may be up to 1 exclusive user and no non-exclusive
 *  users, or 0 exclusive users and any number of non-exclusive users.
 */

void interrupt_connect(struct interrupt *i, int exclusive);
void interrupt_disconnect(struct interrupt *i, int exclusive);


#endif  /*  INTERRUPT_H  */
1	dpavlin	34	#ifndef INTERRUPT_H
2			#define INTERRUPT_H
3
4			/*
5			* Copyright (C) 2006-2007 Anders Gavare. All rights reserved.
6			*
7			* Redistribution and use in source and binary forms, with or without
8			* modification, are permitted provided that the following conditions are met:
9			*
10			* 1. Redistributions of source code must retain the above copyright
11			* notice, this list of conditions and the following disclaimer.
12			* 2. Redistributions in binary form must reproduce the above copyright
13			* notice, this list of conditions and the following disclaimer in the
14			* documentation and/or other materials provided with the distribution.
15			* 3. The name of the author may not be used to endorse or promote products
16			* derived from this software without specific prior written permission.
17			*
18			* THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
19			* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
20			* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
21			* ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
22			* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
23			* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
24			* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
25			* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
26			* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
27			* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
28			* SUCH DAMAGE.
29			*
30			*
31			* $Id: interrupt.h,v 1.4 2007/02/03 16:18:56 debug Exp $
32			*
33			* Definitions related to the Interrupt subsystem.
34			*/
35
36			#include "misc.h"
37
38			struct interrupt {
39			/* Functions used to assert and deassert the interrupt. */
40			void (interrupt_assert)(struct interrupt );
41			void (interrupt_deassert)(struct interrupt );
42
43			/*
44			* The interrupt "line" number, or "pin" number, is an internal number
45			* used by interrupt_assert() and interrupt_deassert(). It may
46			* correspond to a physical interrupt number, or it may be ignored
47			* completely.
48			*
49			* This can either be a small integer corresponding to the interrupt
50			* pin number, or an entire interrupt mask (for controllers with at
51			* most 32 interrupts).
52			*/
53			uint32_t line;
54
55			/*
56			* The extra pointer is a pointer to the (conceptual) interrupt
57			* handler. For a CPU interrupt, this is a pointer to the CPU. For
58			* e.g. a 8259 interrupt, it is a pointer to the dev_8259 which will
59			* handle it.
60			*/
61			void *extra;
62
63			/*
64			* Actual name of the interrupt. This is a complete "path", e.g.
65			* "emul[0].machine[0].cpu[1].irq[3].isa[14]". It is used for
66			* connecting/disconnecting, and debug output.
67			*/
68			char *name;
69			};
70
71
72			/*
73			* Macros to make code using the interrupt struct a bit more consise:
74			*/
75
76			#define INTERRUPT_ASSERT(istruct) (istruct).interrupt_assert(&(istruct))
77			#define INTERRUPT_DEASSERT(istruct) (istruct).interrupt_deassert(&(istruct))
78
79			#define INTERRUPT_CONNECT(name,istruct) { \
80			interrupt_handler_lookup(name, &(istruct)); \
81			interrupt_connect(&(istruct), 0); \
82			}
83
84			#define INTERRUPT_CONNECT_EXCLUSIVE(name,istruct) { \
85			interrupt_handler_lookup(name, &(istruct)); \
86			interrupt_connect(&(istruct), 1); \
87			}
88
89
90			/*
91			* Registration of interrupt handlers:
92			*
93			* Each interrupt handler (i.e. CPUs, interrupt controllers, various bus
94			* controllers) should call interrupt_handler_register() to register itself.
95			*/
96
97			void interrupt_handler_register(struct interrupt *template);
98			void interrupt_handler_remove(char *name);
99			int interrupt_handler_lookup(char name, struct interrupt template);
100
101
102			/*
103			* Functions used to keep track of exclusive and non-exclusive users,
104			* respectively, of an interrupt.
105			*
106			* If interrupt_connect() returns, it means it succeeded. On failure, the
107			* emulator exits. There may be up to 1 exclusive user and no non-exclusive
108			* users, or 0 exclusive users and any number of non-exclusive users.
109			*/
110
111			void interrupt_connect(struct interrupt *i, int exclusive);
112			void interrupt_disconnect(struct interrupt *i, int exclusive);
113
114
115			#endif /* INTERRUPT_H */