0.4.4/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.7 2007/02/03 16:41:42 debug Exp $
 *
 *  The interrupt subsystem.
 *
 *  Interrupts have a "path", e.g. "emul[0].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"


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 "emul[0].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 UNSTABLE_DEVEL
        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 ++;
        interrupt_handlers = realloc(interrupt_handlers,
            nr_of_interrupt_handlers * sizeof(struct interrupt_handler));
        if (interrupt_handlers == NULL) {
                fprintf(stderr, "out of memory in "
                    "ninterrupt_handler_register().\n");
                exit(1);
        }

        interrupt_handlers[nr_of_interrupt_handlers-1].template = *template;
        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 UNSTABLE_DEVEL
        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 UNSTABLE_DEVEL
        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;
        }

        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 UNSTABLE_DEVEL
        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.7 2007/02/03 16:41:42 debug Exp $
29	*
30	* The interrupt subsystem.
31	*
32	* Interrupts have a "path", e.g. "emul[0].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	struct interrupt_handler {
53	struct interrupt template;
54	int nr_of_exclusive_users;
55	int nr_of_nonexclusive_users;
56	};
57
58
59	static int nr_of_interrupt_handlers = 0;
60	static struct interrupt_handler *interrupt_handlers = NULL;
61
62
63	/*
64	* Dummy interrupt assert/deassert for "no interrupt" interrupts:
65	*/
66	static void no_interrupt_assert(struct interrupt *i) { }
67	static void no_interrupt_deassert(struct interrupt *i) { }
68
69
70	/*
71	* interrupt_handler_register():
72	*
73	* Add an interrupt handler to the interrupt subsystem. The 'template'
74	* needs to have all members set.
75	*
76	* Name is of the form "emul[0].machine[0].cpu[0].irq[3].isa[14]" etc.
77	*
78	* If there already is a handler with this name, the emulator aborts.
79	*/
80	void interrupt_handler_register(struct interrupt *template)
81	{
82	int i;
83
84	#ifdef UNSTABLE_DEVEL
85	printf("interrupt_handler_register(\"%s\")\n", template->name);
86	#endif
87
88	/* See if the name is already registered: */
89	for (i=0; i<nr_of_interrupt_handlers; i++) {
90	if (strcmp(template->name,
91	interrupt_handlers[i].template.name) != 0)
92	continue;
93
94	fatal("\ninterrupt_handler_register(): An interrupt handler"
95	" using the name '%s' is already registered.\n",
96	template->name);
97	exit(1);
98	}
99
100	nr_of_interrupt_handlers ++;
101	interrupt_handlers = realloc(interrupt_handlers,
102	nr_of_interrupt_handlers * sizeof(struct interrupt_handler));
103	if (interrupt_handlers == NULL) {
104	fprintf(stderr, "out of memory in "
105	"ninterrupt_handler_register().\n");
106	exit(1);
107	}
108
109	interrupt_handlers[nr_of_interrupt_handlers-1].template = *template;
110	interrupt_handlers[nr_of_interrupt_handlers-1].template.name =
111	strdup(template->name);
112	}
113
114
115	/*
116	* interrupt_handler_remove():
117	*
118	* Remove an interrupt handler from the interrupt subsystem. If there are
119	* still connected users of this interrupt, then an error message is printed
120	* and the emulator aborts.
121	*/
122	void interrupt_handler_remove(char *name)
123	{
124	int i;
125
126	#ifdef UNSTABLE_DEVEL
127	printf("interrupt_handler_remove(\"%s\")\n", name);
128	#endif
129
130	for (i=0; i<nr_of_interrupt_handlers; i++) {
131	if (strcmp(name, interrupt_handlers[i].template.name) != 0)
132	continue;
133
134	/*
135	* Remove handler i, and return:
136	*/
137	if (interrupt_handlers[i].nr_of_exclusive_users > 0 \|\|
138	interrupt_handlers[i].nr_of_nonexclusive_users > 0) {
139	fatal("interrupt_handler_remove(): Attempt to "
140	"remove interrupt handler '%s' which has %i "
141	"exclusive and %i non-exclusive users. Aborting.\n",
142	name, interrupt_handlers[i].nr_of_exclusive_users,
143	interrupt_handlers[i].nr_of_nonexclusive_users);
144	exit(1);
145	}
146
147	if (i != nr_of_interrupt_handlers-1)
148	memcpy(&interrupt_handlers[i],
149	&interrupt_handlers[i + 1],
150	nr_of_interrupt_handlers - i - 1);
151
152	nr_of_interrupt_handlers --;
153
154	return;
155	}
156
157	fatal("interrupt_handler_remove(): '%s' not found? Aborting.\n", name);
158	exit(1);
159	}
160
161
162	/*
163	* interrupt_handler_lookup():
164	*
165	* Scans the list of registered interrupt handlers for a given name. If the
166	* name is found, the template is filled with valid data, and 1 is returned.
167	* If the name is not found, 0 is returned.
168	*/
169	int interrupt_handler_lookup(char name, struct interrupt template)
170	{
171	int i;
172
173	#ifdef UNSTABLE_DEVEL
174	printf("interrupt_handler_lookup(\"%s\")\n", name);
175	#endif
176
177	if (name[0] == '\0') {
178	/* No interrupt: */
179	memset(template, 0, sizeof(struct interrupt));
180	template->interrupt_assert = no_interrupt_assert;
181	template->interrupt_deassert = no_interrupt_deassert;
182	}
183
184	for (i=0; i<nr_of_interrupt_handlers; i++) {
185	if (strcmp(name, interrupt_handlers[i].template.name) != 0)
186	continue;
187
188	*template = interrupt_handlers[i].template;
189	return 1;
190	}
191
192	printf("interrupt_handler_lookup(\"%s\") failed. Aborting.\n", name);
193	abort();
194
195	return 0;
196	}
197
198
199	/*
200	* interrupt_connect():
201	*
202	* Increases the exclusive or nonexclusive nr or users of an interrupt.
203	*/
204	void interrupt_connect(struct interrupt *in, int exclusive)
205	{
206	int i;
207
208	#ifdef UNSTABLE_DEVEL
209	printf("interrupt_connect(\"%s\")\n", in->name);
210	#endif
211
212	if (in->name == NULL \|\| in->name[0] == '\0')
213	return;
214
215	for (i=0; i<nr_of_interrupt_handlers; i++) {
216	if (strcmp(in->name, interrupt_handlers[i].template.name) != 0)
217	continue;
218
219	if (exclusive) {
220	interrupt_handlers[i].nr_of_exclusive_users ++;
221	if (interrupt_handlers[i].nr_of_exclusive_users > 1) {
222	fatal("Fatal error in interrupt_connect(): "
223	"more than 1 exclusive user. Dumping "
224	"core for backtrace.\n");
225	abort();
226	}
227	} else {
228	interrupt_handlers[i].nr_of_nonexclusive_users ++;
229	}
230
231	return;
232	}
233
234	fatal("Internal error in interrupt_connect(): name '%s' not "
235	"found? Dumping core for debugging.\n", in->name);
236	abort();
237	}
238
239
240	/*
241	* interrupt_disconnect():
242	*
243	* Decreases the exclusive or nonexclusive nr or users of an interrupt.
244	*/
245	void interrupt_disconnect(struct interrupt *in, int exclusive)
246	{
247	int i;
248
249	if (in->name == NULL \|\| in->name[0] == '\0')
250	return;
251
252	for (i=0; i<nr_of_interrupt_handlers; i++) {
253	if (strcmp(in->name, interrupt_handlers[i].template.name) != 0)
254	continue;
255
256	if (exclusive) {
257	interrupt_handlers[i].nr_of_exclusive_users --;
258	if (interrupt_handlers[i].nr_of_exclusive_users < 0) {
259	fatal("Fatal error in interrupt_disconnect():"
260	"nr of exclusive users < 0?\n");
261	exit(1);
262	}
263	} else {
264	interrupt_handlers[i].nr_of_nonexclusive_users --;
265	if (interrupt_handlers[i].nr_of_nonexclusive_users<0) {
266	fatal("Fatal error in interrupt_disconnect():"
267	"nr of non-exclusive users < 0?\n");
268	exit(1);
269	}
270	}
271
272	return;
273	}
274
275	fatal("Internal error in interrupt_disconnect(): name '%s' not "
276	"found?\n", in->name);
277	exit(1);
278	}
279
280