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	/*
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	* $Id: interrupt.c,v 1.13 2007/08/29 20:36:49 debug Exp $
29	*
30	* The interrupt subsystem.
31	*
32	* Interrupts have a "path", e.g. "machine[0].cpu.5". A device which
33	* 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	/* #define INTERRUPT_DEBUG */
53
54
55	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	* Name is of the form "machine[0].cpu[0].irq[3].isa[14]" etc.
80	*
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	#ifdef INTERRUPT_DEBUG
88	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	CHECK_ALLOCATION(interrupt_handlers = realloc(interrupt_handlers,
105	nr_of_interrupt_handlers * sizeof(struct interrupt_handler)));
106
107	interrupt_handlers[nr_of_interrupt_handlers-1].template = *template;
108	CHECK_ALLOCATION(interrupt_handlers[nr_of_interrupt_handlers-1].
109	template.name = strdup(template->name));
110	}
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	#ifdef INTERRUPT_DEBUG
125	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	#ifdef INTERRUPT_DEBUG
172	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	/* 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
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	#ifdef INTERRUPT_DEBUG
211	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