1 /* 2 * Copyright (c) 1997, Stefan Esser <se@freebsd.org> 3 * All rights reserved. 4 * 5 * Redistribution and use in source and binary forms, with or without 6 * modification, are permitted provided that the following conditions 7 * are met: 8 * 1. Redistributions of source code must retain the above copyright 9 * notice unmodified, this list of conditions, and the following 10 * disclaimer. 11 * 2. Redistributions in binary form must reproduce the above copyright 12 * notice, this list of conditions and the following disclaimer in the 13 * documentation and/or other materials provided with the distribution. 14 * 15 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR 16 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 17 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 18 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, 19 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 20 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 21 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 22 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 23 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF 24 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 25 * 26 * $FreeBSD$ 27 * 28 */ 29 30 31 #include <sys/param.h> 32 #include <sys/systm.h> 33 #include <sys/malloc.h> 34 35 #include <machine/ipl.h> 36 37 #include <sys/interrupt.h> 38 39 struct swilist { 40 swihand_t *sl_handler; 41 struct swilist *sl_next; 42 }; 43 44 static struct swilist swilists[NSWI]; 45 46 void 47 register_swi(intr, handler) 48 int intr; 49 swihand_t *handler; 50 { 51 struct swilist *slp, *slq; 52 int s; 53 54 if (intr < NHWI || intr >= NHWI + NSWI) 55 panic("register_swi: bad intr %d", intr); 56 if (handler == swi_generic || handler == swi_null) 57 panic("register_swi: bad handler %p", (void *)handler); 58 slp = &swilists[intr - NHWI]; 59 s = splhigh(); 60 if (ihandlers[intr] == swi_null) 61 ihandlers[intr] = handler; 62 else { 63 if (slp->sl_next == NULL) { 64 slp->sl_handler = ihandlers[intr]; 65 ihandlers[intr] = swi_generic; 66 } 67 slq = malloc(sizeof(*slq), M_DEVBUF, M_NOWAIT); 68 if (slq == NULL) 69 panic("register_swi: malloc failed"); 70 slq->sl_handler = handler; 71 slq->sl_next = NULL; 72 while (slp->sl_next != NULL) 73 slp = slp->sl_next; 74 slp->sl_next = slq; 75 } 76 splx(s); 77 } 78 79 void 80 swi_dispatcher(intr) 81 int intr; 82 { 83 struct swilist *slp; 84 85 slp = &swilists[intr - NHWI]; 86 do { 87 (*slp->sl_handler)(); 88 slp = slp->sl_next; 89 } while (slp != NULL); 90 } 91 92 void 93 unregister_swi(intr, handler) 94 int intr; 95 swihand_t *handler; 96 { 97 struct swilist *slfoundpred, *slp, *slq; 98 int s; 99 100 if (intr < NHWI || intr >= NHWI + NSWI) 101 panic("unregister_swi: bad intr %d", intr); 102 if (handler == swi_generic || handler == swi_null) 103 panic("unregister_swi: bad handler %p", (void *)handler); 104 slp = &swilists[intr - NHWI]; 105 s = splhigh(); 106 if (ihandlers[intr] == handler) 107 ihandlers[intr] = swi_null; 108 else if (slp->sl_next != NULL) { 109 slfoundpred = NULL; 110 for (slq = slp->sl_next; slq != NULL; 111 slp = slq, slq = slp->sl_next) 112 if (slq->sl_handler == handler) 113 slfoundpred = slp; 114 slp = &swilists[intr - NHWI]; 115 if (slfoundpred != NULL) { 116 slq = slfoundpred->sl_next; 117 slfoundpred->sl_next = slq->sl_next; 118 free(slq, M_DEVBUF); 119 } else if (slp->sl_handler == handler) { 120 slq = slp->sl_next; 121 slp->sl_next = slq->sl_next; 122 slp->sl_handler = slq->sl_handler; 123 free(slq, M_DEVBUF); 124 } 125 if (slp->sl_next == NULL) 126 ihandlers[intr] = slp->sl_handler; 127 } 128 splx(s); 129 } 130 131