trunk/src/interrupt.c

/*
 *  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.c,v 1.13 2007/08/29 20:36:49 debug Exp $
 *
 *  The interrupt subsystem.
 *
 *  Interrupts have a "path", e.g. "machine[0].cpu.5". A device which
 *  wishes to cause this interrupt needs to connect to it.
 *
 *  The possible interrupt paths are registered by CPUs, interrupt controllers,
 *  etc., that have a way of receiving interrupt requests. The physical
 *  version of an interrupt path is usually a "pin" on the CPU, or similar.
 *
 *  Once connected, the interrupt can be asserted or deasserted.
 *
 *  For examples on how it is used, see the various devices in src/devices/.
 */

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#include "interrupt.h"
#include "misc.h"


/*  #define INTERRUPT_DEBUG  */


struct interrupt_handler {
        struct interrupt        template;
        int                     nr_of_exclusive_users;
        int                     nr_of_nonexclusive_users;
};


static int nr_of_interrupt_handlers = 0;
static struct interrupt_handler *interrupt_handlers = NULL;


/*
 *  Dummy interrupt assert/deassert for "no interrupt" interrupts:
 */
static void no_interrupt_assert(struct interrupt *i) { }
static void no_interrupt_deassert(struct interrupt *i) { }


/*
 *  interrupt_handler_register():
 *
 *  Add an interrupt handler to the interrupt subsystem. The 'template'
 *  needs to have all members set.
 *
 *  Name is of the form "machine[0].cpu[0].irq[3].isa[14]" etc.
 *
 *  If there already is a handler with this name, the emulator aborts.
 */
void interrupt_handler_register(struct interrupt *template)
{
        int i;

#ifdef INTERRUPT_DEBUG
        printf("interrupt_handler_register(\"%s\")\n", template->name);
#endif

        /*  See if the name is already registered:  */
        for (i=0; i<nr_of_interrupt_handlers; i++) {
                if (strcmp(template->name,
                    interrupt_handlers[i].template.name) != 0)
                        continue;

                fatal("\ninterrupt_handler_register(): An interrupt handler"
                    " using the name '%s' is already registered.\n",
                    template->name);
                exit(1);
        }

        nr_of_interrupt_handlers ++;
        CHECK_ALLOCATION(interrupt_handlers = realloc(interrupt_handlers,
            nr_of_interrupt_handlers * sizeof(struct interrupt_handler)));

        interrupt_handlers[nr_of_interrupt_handlers-1].template = *template;
        CHECK_ALLOCATION(interrupt_handlers[nr_of_interrupt_handlers-1].
            template.name = strdup(template->name));
}


/*
 *  interrupt_handler_remove():
 *
 *  Remove an interrupt handler from the interrupt subsystem. If there are
 *  still connected users of this interrupt, then an error message is printed
 *  and the emulator aborts.
 */
void interrupt_handler_remove(char *name)
{
        int i;

#ifdef INTERRUPT_DEBUG
        printf("interrupt_handler_remove(\"%s\")\n", name);
#endif

        for (i=0; i<nr_of_interrupt_handlers; i++) {
                if (strcmp(name, interrupt_handlers[i].template.name) != 0)
                        continue;

                /*
                 *  Remove handler i, and return:
                 */
                if (interrupt_handlers[i].nr_of_exclusive_users > 0 ||
                    interrupt_handlers[i].nr_of_nonexclusive_users > 0) {
                        fatal("interrupt_handler_remove(): Attempt to "
                            "remove interrupt handler '%s' which has %i "
                            "exclusive and %i non-exclusive users. Aborting.\n",
                            name, interrupt_handlers[i].nr_of_exclusive_users,
                            interrupt_handlers[i].nr_of_nonexclusive_users);
                        exit(1);
                }

                if (i != nr_of_interrupt_handlers-1)
                        memcpy(&interrupt_handlers[i],
                            &interrupt_handlers[i + 1],
                            nr_of_interrupt_handlers - i - 1);

                nr_of_interrupt_handlers --;

                return;
        }

        fatal("interrupt_handler_remove(): '%s' not found? Aborting.\n", name);
        exit(1);
}


/*
 *  interrupt_handler_lookup():
 *
 *  Scans the list of registered interrupt handlers for a given name. If the
 *  name is found, the template is filled with valid data, and 1 is returned.
 *  If the name is not found, 0 is returned.
 */
int interrupt_handler_lookup(char *name, struct interrupt *template)
{
        int i;

#ifdef INTERRUPT_DEBUG
        printf("interrupt_handler_lookup(\"%s\")\n", name);
#endif

        if (name[0] == '\0') {
                /*  No interrupt:  */
                memset(template, 0, sizeof(struct interrupt));
                template->interrupt_assert = no_interrupt_assert;
                template->interrupt_deassert = no_interrupt_deassert;
        }

        for (i=0; i<nr_of_interrupt_handlers; i++) {
                if (strcmp(name, interrupt_handlers[i].template.name) != 0)
                        continue;

                *template = interrupt_handlers[i].template;
                return 1;
        }

        /*  The 'if' is an ugly hack to prevent a Compaq CC warning.  */
        if (i >= nr_of_interrupt_handlers) {
                printf("interrupt_handler_lookup(\"%s\") failed. "
                    "Aborting.\n", name);
                abort();
        }

        return 0;
}


/*
 *  interrupt_connect():
 *
 *  Increases the exclusive or nonexclusive nr or users of an interrupt.
 */
void interrupt_connect(struct interrupt *in, int exclusive)
{
        int i;

#ifdef INTERRUPT_DEBUG
        printf("interrupt_connect(\"%s\")\n", in->name);
#endif

        if (in->name == NULL || in->name[0] == '\0')
                return;

        for (i=0; i<nr_of_interrupt_handlers; i++) {
                if (strcmp(in->name, interrupt_handlers[i].template.name) != 0)
                        continue;

                if (exclusive) {
                        interrupt_handlers[i].nr_of_exclusive_users ++;
                        if (interrupt_handlers[i].nr_of_exclusive_users > 1) {
                                fatal("Fatal error in interrupt_connect(): "
                                    "more than 1 exclusive user. Dumping "
                                    "core for backtrace.\n");
                                abort();
                        }
                } else {
                        interrupt_handlers[i].nr_of_nonexclusive_users ++;
                }

                return;
        }

        fatal("Internal error in interrupt_connect(): name '%s' not "
            "found? Dumping core for debugging.\n", in->name);
        abort();
}


/*
 *  interrupt_disconnect():
 *
 *  Decreases the exclusive or nonexclusive nr or users of an interrupt.
 */
void interrupt_disconnect(struct interrupt *in, int exclusive)
{
        int i;

        if (in->name == NULL || in->name[0] == '\0')
                return;

        for (i=0; i<nr_of_interrupt_handlers; i++) {
                if (strcmp(in->name, interrupt_handlers[i].template.name) != 0)
                        continue;

                if (exclusive) {
                        interrupt_handlers[i].nr_of_exclusive_users --;
                        if (interrupt_handlers[i].nr_of_exclusive_users < 0) {
                                fatal("Fatal error in interrupt_disconnect():"
                                    "nr of exclusive users < 0?\n");
                                exit(1);
                        }
                } else {
                        interrupt_handlers[i].nr_of_nonexclusive_users --;
                        if (interrupt_handlers[i].nr_of_nonexclusive_users<0) {
                                fatal("Fatal error in interrupt_disconnect():"
                                    "nr of non-exclusive users < 0?\n");
                                exit(1);
                        }
                }

                return;
        }

        fatal("Internal error in interrupt_disconnect(): name '%s' not "
            "found?\n", in->name);
        exit(1);
}


1	dpavlin	34	/*
2			* Copyright (C) 2006-2007 Anders Gavare. All rights reserved.
3			*
4			* Redistribution and use in source and binary forms, with or without
5			* modification, are permitted provided that the following conditions are met:
6			*
7			* 1. Redistributions of source code must retain the above copyright
8			* notice, this list of conditions and the following disclaimer.
9			* 2. Redistributions in binary form must reproduce the above copyright
10			* notice, this list of conditions and the following disclaimer in the
11			* documentation and/or other materials provided with the distribution.
12			* 3. The name of the author may not be used to endorse or promote products
13			* derived from this software without specific prior written permission.
14			*
15			* THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
16			* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
17			* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
18			* ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
19			* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
20			* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
21			* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
22			* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
23			* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
24			* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
25			* SUCH DAMAGE.
26			*
27			*
28	dpavlin	44	* $Id: interrupt.c,v 1.13 2007/08/29 20:36:49 debug Exp $
29	dpavlin	34	*
30			* The interrupt subsystem.
31			*
32	dpavlin	44	* Interrupts have a "path", e.g. "machine[0].cpu.5". A device which
33	dpavlin	34	* wishes to cause this interrupt needs to connect to it.
34			*
35			* The possible interrupt paths are registered by CPUs, interrupt controllers,
36			* etc., that have a way of receiving interrupt requests. The physical
37			* version of an interrupt path is usually a "pin" on the CPU, or similar.
38			*
39			* Once connected, the interrupt can be asserted or deasserted.
40			*
41			* For examples on how it is used, see the various devices in src/devices/.
42			*/
43
44			#include <stdio.h>
45			#include <stdlib.h>
46			#include <string.h>
47
48			#include "interrupt.h"
49			#include "misc.h"
50
51
52	dpavlin	42	/* #define INTERRUPT_DEBUG */
53
54
55	dpavlin	34	struct interrupt_handler {
56			struct interrupt template;
57			int nr_of_exclusive_users;
58			int nr_of_nonexclusive_users;
59			};
60
61
62			static int nr_of_interrupt_handlers = 0;
63			static struct interrupt_handler *interrupt_handlers = NULL;
64
65
66			/*
67			* Dummy interrupt assert/deassert for "no interrupt" interrupts:
68			*/
69			static void no_interrupt_assert(struct interrupt *i) { }
70			static void no_interrupt_deassert(struct interrupt *i) { }
71
72
73			/*
74			* interrupt_handler_register():
75			*
76			* Add an interrupt handler to the interrupt subsystem. The 'template'
77			* needs to have all members set.
78			*
79	dpavlin	44	* Name is of the form "machine[0].cpu[0].irq[3].isa[14]" etc.
80	dpavlin	34	*
81			* If there already is a handler with this name, the emulator aborts.
82			*/
83			void interrupt_handler_register(struct interrupt *template)
84			{
85			int i;
86
87	dpavlin	42	#ifdef INTERRUPT_DEBUG
88	dpavlin	34	printf("interrupt_handler_register(\"%s\")\n", template->name);
89			#endif
90
91			/* See if the name is already registered: */
92			for (i=0; i<nr_of_interrupt_handlers; i++) {
93			if (strcmp(template->name,
94			interrupt_handlers[i].template.name) != 0)
95			continue;
96
97			fatal("\ninterrupt_handler_register(): An interrupt handler"
98			" using the name '%s' is already registered.\n",
99			template->name);
100			exit(1);
101			}
102
103			nr_of_interrupt_handlers ++;
104	dpavlin	42	CHECK_ALLOCATION(interrupt_handlers = realloc(interrupt_handlers,
105			nr_of_interrupt_handlers * sizeof(struct interrupt_handler)));
106	dpavlin	34
107			interrupt_handlers[nr_of_interrupt_handlers-1].template = *template;
108	dpavlin	42	CHECK_ALLOCATION(interrupt_handlers[nr_of_interrupt_handlers-1].
109			template.name = strdup(template->name));
110	dpavlin	34	}
111
112
113			/*
114			* interrupt_handler_remove():
115			*
116			* Remove an interrupt handler from the interrupt subsystem. If there are
117			* still connected users of this interrupt, then an error message is printed
118			* and the emulator aborts.
119			*/
120			void interrupt_handler_remove(char *name)
121			{
122			int i;
123
124	dpavlin	42	#ifdef INTERRUPT_DEBUG
125	dpavlin	34	printf("interrupt_handler_remove(\"%s\")\n", name);
126			#endif
127
128			for (i=0; i<nr_of_interrupt_handlers; i++) {
129			if (strcmp(name, interrupt_handlers[i].template.name) != 0)
130			continue;
131
132			/*
133			* Remove handler i, and return:
134			*/
135			if (interrupt_handlers[i].nr_of_exclusive_users > 0 \|\|
136			interrupt_handlers[i].nr_of_nonexclusive_users > 0) {
137			fatal("interrupt_handler_remove(): Attempt to "
138			"remove interrupt handler '%s' which has %i "
139			"exclusive and %i non-exclusive users. Aborting.\n",
140			name, interrupt_handlers[i].nr_of_exclusive_users,
141			interrupt_handlers[i].nr_of_nonexclusive_users);
142			exit(1);
143			}
144
145			if (i != nr_of_interrupt_handlers-1)
146			memcpy(&interrupt_handlers[i],
147			&interrupt_handlers[i + 1],
148			nr_of_interrupt_handlers - i - 1);
149
150			nr_of_interrupt_handlers --;
151
152			return;
153			}
154
155			fatal("interrupt_handler_remove(): '%s' not found? Aborting.\n", name);
156			exit(1);
157			}
158
159
160			/*
161			* interrupt_handler_lookup():
162			*
163			* Scans the list of registered interrupt handlers for a given name. If the
164			* name is found, the template is filled with valid data, and 1 is returned.
165			* If the name is not found, 0 is returned.
166			*/
167			int interrupt_handler_lookup(char name, struct interrupt template)
168			{
169			int i;
170
171	dpavlin	42	#ifdef INTERRUPT_DEBUG
172	dpavlin	34	printf("interrupt_handler_lookup(\"%s\")\n", name);
173			#endif
174
175			if (name[0] == '\0') {
176			/* No interrupt: */
177			memset(template, 0, sizeof(struct interrupt));
178			template->interrupt_assert = no_interrupt_assert;
179			template->interrupt_deassert = no_interrupt_deassert;
180			}
181
182			for (i=0; i<nr_of_interrupt_handlers; i++) {
183			if (strcmp(name, interrupt_handlers[i].template.name) != 0)
184			continue;
185
186			*template = interrupt_handlers[i].template;
187			return 1;
188			}
189
190	dpavlin	42	/* The 'if' is an ugly hack to prevent a Compaq CC warning. */
191			if (i >= nr_of_interrupt_handlers) {
192			printf("interrupt_handler_lookup(\"%s\") failed. "
193			"Aborting.\n", name);
194			abort();
195			}
196	dpavlin	34
197			return 0;
198			}
199
200
201			/*
202			* interrupt_connect():
203			*
204			* Increases the exclusive or nonexclusive nr or users of an interrupt.
205			*/
206			void interrupt_connect(struct interrupt *in, int exclusive)
207			{
208			int i;
209
210	dpavlin	42	#ifdef INTERRUPT_DEBUG
211	dpavlin	34	printf("interrupt_connect(\"%s\")\n", in->name);
212			#endif
213
214			if (in->name == NULL \|\| in->name[0] == '\0')
215			return;
216
217			for (i=0; i<nr_of_interrupt_handlers; i++) {
218			if (strcmp(in->name, interrupt_handlers[i].template.name) != 0)
219			continue;
220
221			if (exclusive) {
222			interrupt_handlers[i].nr_of_exclusive_users ++;
223			if (interrupt_handlers[i].nr_of_exclusive_users > 1) {
224			fatal("Fatal error in interrupt_connect(): "
225			"more than 1 exclusive user. Dumping "
226			"core for backtrace.\n");
227			abort();
228			}
229			} else {
230			interrupt_handlers[i].nr_of_nonexclusive_users ++;
231			}
232
233			return;
234			}
235
236			fatal("Internal error in interrupt_connect(): name '%s' not "
237			"found? Dumping core for debugging.\n", in->name);
238			abort();
239			}
240
241
242			/*
243			* interrupt_disconnect():
244			*
245			* Decreases the exclusive or nonexclusive nr or users of an interrupt.
246			*/
247			void interrupt_disconnect(struct interrupt *in, int exclusive)
248			{
249			int i;
250
251			if (in->name == NULL \|\| in->name[0] == '\0')
252			return;
253
254			for (i=0; i<nr_of_interrupt_handlers; i++) {
255			if (strcmp(in->name, interrupt_handlers[i].template.name) != 0)
256			continue;
257
258			if (exclusive) {
259			interrupt_handlers[i].nr_of_exclusive_users --;
260			if (interrupt_handlers[i].nr_of_exclusive_users < 0) {
261			fatal("Fatal error in interrupt_disconnect():"
262			"nr of exclusive users < 0?\n");
263			exit(1);
264			}
265			} else {
266			interrupt_handlers[i].nr_of_nonexclusive_users --;
267			if (interrupt_handlers[i].nr_of_nonexclusive_users<0) {
268			fatal("Fatal error in interrupt_disconnect():"
269			"nr of non-exclusive users < 0?\n");
270			exit(1);
271			}
272			}
273
274			return;
275			}
276
277			fatal("Internal error in interrupt_disconnect(): name '%s' not "
278			"found?\n", in->name);
279			exit(1);
280			}
281
282