Annotation of sys/arch/alpha/dev/shared_intr.c, Revision 1.1.1.1
1.1 nbrk 1: /* $OpenBSD: shared_intr.c,v 1.15 2006/06/15 20:08:29 brad Exp $ */
2: /* $NetBSD: shared_intr.c,v 1.13 2000/03/19 01:46:18 thorpej Exp $ */
3:
4: /*
5: * Copyright (c) 1996 Carnegie-Mellon University.
6: * All rights reserved.
7: *
8: * Authors: Chris G. Demetriou
9: *
10: * Permission to use, copy, modify and distribute this software and
11: * its documentation is hereby granted, provided that both the copyright
12: * notice and this permission notice appear in all copies of the
13: * software, derivative works or modified versions, and any portions
14: * thereof, and that both notices appear in supporting documentation.
15: *
16: * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
17: * CONDITION. CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND
18: * FOR ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
19: *
20: * Carnegie Mellon requests users of this software to return to
21: *
22: * Software Distribution Coordinator or Software.Distribution@CS.CMU.EDU
23: * School of Computer Science
24: * Carnegie Mellon University
25: * Pittsburgh PA 15213-3890
26: *
27: * any improvements or extensions that they make and grant Carnegie the
28: * rights to redistribute these changes.
29: */
30:
31: /*
32: * Common shared-interrupt-line functionality.
33: */
34:
35: #include <sys/param.h>
36: #include <sys/kernel.h>
37: #include <sys/systm.h>
38: #include <sys/malloc.h>
39: #include <sys/syslog.h>
40: #include <sys/queue.h>
41:
42: #include <machine/intr.h>
43:
44: static const char *intr_typename(int);
45:
46: static const char *
47: intr_typename(type)
48: int type;
49: {
50:
51: switch (type) {
52: case IST_UNUSABLE:
53: return ("disabled");
54: case IST_NONE:
55: return ("none");
56: case IST_PULSE:
57: return ("pulsed");
58: case IST_EDGE:
59: return ("edge-triggered");
60: case IST_LEVEL:
61: return ("level-triggered");
62: }
63: panic("intr_typename: unknown type %d", type);
64: }
65:
66: struct alpha_shared_intr *
67: alpha_shared_intr_alloc(n)
68: unsigned int n;
69: {
70: struct alpha_shared_intr *intr;
71: unsigned int i;
72:
73: intr = malloc(n * sizeof (struct alpha_shared_intr), M_DEVBUF,
74: cold ? M_NOWAIT : M_WAITOK);
75: if (intr == NULL)
76: panic("alpha_shared_intr_alloc: couldn't malloc intr");
77:
78: for (i = 0; i < n; i++) {
79: TAILQ_INIT(&intr[i].intr_q);
80: intr[i].intr_sharetype = IST_NONE;
81: intr[i].intr_dfltsharetype = IST_NONE;
82: intr[i].intr_nstrays = 0;
83: intr[i].intr_maxstrays = 5;
84: intr[i].intr_private = NULL;
85: }
86:
87: return (intr);
88: }
89:
90: int
91: alpha_shared_intr_dispatch(intr, num)
92: struct alpha_shared_intr *intr;
93: unsigned int num;
94: {
95: struct alpha_shared_intrhand *ih;
96: int rv, handled;
97:
98: handled = 0;
99: TAILQ_FOREACH(ih, &intr[num].intr_q, ih_q) {
100: /*
101: * The handler returns one of three values:
102: * 0: This interrupt wasn't for me.
103: * 1: This interrupt was for me.
104: * -1: This interrupt might have been for me, but I can't say
105: * for sure.
106: */
107: if ((rv = (*ih->ih_fn)(ih->ih_arg)))
108: ih->ih_count.ec_count++;
109:
110: handled = handled || (rv != 0);
111: }
112:
113: return (handled);
114: }
115:
116: void *
117: alpha_shared_intr_establish(intr, num, type, level, fn, arg, basename)
118: struct alpha_shared_intr *intr;
119: unsigned int num;
120: int type, level;
121: int (*fn)(void *);
122: void *arg;
123: const char *basename;
124: {
125: struct alpha_shared_intrhand *ih;
126:
127: if (intr[num].intr_sharetype == IST_UNUSABLE) {
128: printf("alpha_shared_intr_establish: %s %d: unusable\n",
129: basename, num);
130: return NULL;
131: }
132:
133: /* no point in sleeping unless someone can free memory. */
134: ih = malloc(sizeof *ih, M_DEVBUF, cold ? M_NOWAIT : M_WAITOK);
135: if (ih == NULL)
136: panic("alpha_shared_intr_establish: can't malloc intrhand");
137:
138: #ifdef DIAGNOSTIC
139: if (type == IST_NONE)
140: panic("alpha_shared_intr_establish: bogus type");
141: #endif
142:
143: switch (intr[num].intr_sharetype) {
144: case IST_EDGE:
145: case IST_LEVEL:
146: if (type == intr[num].intr_sharetype)
147: break;
148: case IST_PULSE:
149: if (type != IST_NONE) {
150: if (TAILQ_EMPTY(&intr[num].intr_q)) {
151: printf("alpha_shared_intr_establish: %s %d: warning: using %s on %s\n",
152: basename, num, intr_typename(type),
153: intr_typename(intr[num].intr_sharetype));
154: type = intr[num].intr_sharetype;
155: } else {
156: panic("alpha_shared_intr_establish: %s %d: can't share %s with %s",
157: basename, num, intr_typename(type),
158: intr_typename(intr[num].intr_sharetype));
159: }
160: }
161: break;
162:
163: case IST_NONE:
164: /* not currently used; safe */
165: break;
166: }
167:
168: ih->ih_intrhead = intr;
169: ih->ih_fn = fn;
170: ih->ih_arg = arg;
171: ih->ih_level = level;
172: ih->ih_num = num;
173: evcount_attach(&ih->ih_count, basename, (void *)&ih->ih_num,
174: &evcount_intr);
175:
176: intr[num].intr_sharetype = type;
177: TAILQ_INSERT_TAIL(&intr[num].intr_q, ih, ih_q);
178:
179: return (ih);
180: }
181:
182: void
183: alpha_shared_intr_disestablish(intr, cookie, basename)
184: struct alpha_shared_intr *intr;
185: void *cookie;
186: const char *basename;
187: {
188: struct alpha_shared_intrhand *ih = cookie;
189: unsigned int num = ih->ih_num;
190:
191: /*
192: * Just remove it from the list and free the entry. We let
193: * the caller deal with resetting the share type, if appropriate.
194: */
195: evcount_detach(&ih->ih_count);
196: TAILQ_REMOVE(&intr[num].intr_q, ih, ih_q);
197: free(ih, M_DEVBUF);
198: }
199:
200: int
201: alpha_shared_intr_get_sharetype(intr, num)
202: struct alpha_shared_intr *intr;
203: unsigned int num;
204: {
205:
206: return (intr[num].intr_sharetype);
207: }
208:
209: int
210: alpha_shared_intr_isactive(intr, num)
211: struct alpha_shared_intr *intr;
212: unsigned int num;
213: {
214:
215: return (!TAILQ_EMPTY(&intr[num].intr_q));
216: }
217:
218: int
219: alpha_shared_intr_firstactive(struct alpha_shared_intr *intr, unsigned int num)
220: {
221:
222: return (!TAILQ_EMPTY(&intr[num].intr_q) &&
223: TAILQ_NEXT(intr[num].intr_q.tqh_first, ih_q) == NULL);
224: }
225:
226: void
227: alpha_shared_intr_set_dfltsharetype(intr, num, newdfltsharetype)
228: struct alpha_shared_intr *intr;
229: unsigned int num;
230: int newdfltsharetype;
231: {
232:
233: #ifdef DIAGNOSTIC
234: if (alpha_shared_intr_isactive(intr, num))
235: panic("alpha_shared_intr_set_dfltsharetype on active intr");
236: #endif
237:
238: intr[num].intr_dfltsharetype = newdfltsharetype;
239: intr[num].intr_sharetype = intr[num].intr_dfltsharetype;
240: }
241:
242: void
243: alpha_shared_intr_set_maxstrays(intr, num, newmaxstrays)
244: struct alpha_shared_intr *intr;
245: unsigned int num;
246: int newmaxstrays;
247: {
248: int s = splhigh();
249: intr[num].intr_maxstrays = newmaxstrays;
250: intr[num].intr_nstrays = 0;
251: splx(s);
252: }
253:
254: void
255: alpha_shared_intr_reset_strays(intr, num)
256: struct alpha_shared_intr *intr;
257: unsigned int num;
258: {
259:
260: /*
261: * Don't bother blocking interrupts; this doesn't have to be
262: * precise, but it does need to be fast.
263: */
264: intr[num].intr_nstrays = 0;
265: }
266:
267: void
268: alpha_shared_intr_stray(intr, num, basename)
269: struct alpha_shared_intr *intr;
270: unsigned int num;
271: const char *basename;
272: {
273:
274: intr[num].intr_nstrays++;
275:
276: if (intr[num].intr_maxstrays == 0)
277: return;
278:
279: if (intr[num].intr_nstrays <= intr[num].intr_maxstrays)
280: log(LOG_ERR, "stray %s %d%s\n", basename, num,
281: intr[num].intr_nstrays >= intr[num].intr_maxstrays ?
282: "; stopped logging" : "");
283: }
284:
285: void
286: alpha_shared_intr_set_private(intr, num, v)
287: struct alpha_shared_intr *intr;
288: unsigned int num;
289: void *v;
290: {
291:
292: intr[num].intr_private = v;
293: }
294:
295: void *
296: alpha_shared_intr_get_private(intr, num)
297: struct alpha_shared_intr *intr;
298: unsigned int num;
299: {
300:
301: return (intr[num].intr_private);
302: }
CVSweb
![[BACK]](/icons/back.gif){kind=icon}
Return to shared_intr.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / arch / alpha / dev