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	#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 */