1 /* $NetBSD: intr.h,v 1.3 2005/04/16 22:49:37 bouyer Exp $ */ 2 /* NetBSD intr.h,v 1.15 2004/10/31 10:39:34 yamt Exp */ 3 4 /*- 5 * Copyright (c) 1998, 2001 The NetBSD Foundation, Inc. 6 * All rights reserved. 7 * 8 * This code is derived from software contributed to The NetBSD Foundation 9 * by Charles M. Hannum, and by Jason R. Thorpe. 10 * 11 * Redistribution and use in source and binary forms, with or without 12 * modification, are permitted provided that the following conditions 13 * are met: 14 * 1. Redistributions of source code must retain the above copyright 15 * notice, this list of conditions and the following disclaimer. 16 * 2. Redistributions in binary form must reproduce the above copyright 17 * notice, this list of conditions and the following disclaimer in the 18 * documentation and/or other materials provided with the distribution. 19 * 3. All advertising materials mentioning features or use of this software 20 * must display the following acknowledgement: 21 * This product includes software developed by the NetBSD 22 * Foundation, Inc. and its contributors. 23 * 4. Neither the name of The NetBSD Foundation nor the names of its 24 * contributors may be used to endorse or promote products derived 25 * from this software without specific prior written permission. 26 * 27 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS 28 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED 29 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR 30 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS 31 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 32 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 33 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 34 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 35 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 36 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 37 * POSSIBILITY OF SUCH DAMAGE. 38 */ 39 40 41 #ifndef _XEN_INTR_H_ 42 #define _XEN_INTR_H_ 43 44 #include <machine/intrdefs.h> 45 46 #ifndef _LOCORE 47 #include <machine/cpu.h> 48 #include <machine/pic.h> 49 50 /* 51 * Struct describing an event channel. 52 */ 53 54 struct evtsource { 55 int ev_maxlevel; /* max. IPL for this source */ 56 u_int32_t ev_imask; /* interrupt mask */ 57 struct intrhand *ev_handlers; /* handler chain */ 58 struct evcnt ev_evcnt; /* interrupt counter */ 59 char ev_evname[32]; /* event counter name */ 60 }; 61 62 /* 63 * Structure describing an interrupt level. struct cpu_info has an array of 64 * IPL_MAX of theses. The index in the array is equal to the stub number of 65 * the stubcode as present in vector.s 66 */ 67 68 struct intrstub { 69 #if 0 70 void *ist_entry; 71 #endif 72 void *ist_recurse; 73 void *ist_resume; 74 }; 75 76 struct iplsource { 77 struct intrhand *ipl_handlers; /* handler chain */ 78 void *ipl_recurse; /* entry for spllower */ 79 void *ipl_resume; /* entry for doreti */ 80 u_int32_t ipl_evt_mask1; /* pending events for this IPL */ 81 u_int32_t ipl_evt_mask2[NR_EVENT_CHANNELS]; 82 }; 83 84 85 86 /* 87 * Interrupt handler chains. These are linked in both the evtsource and 88 * the iplsource. 89 * The handler is called with its (single) argument. 90 */ 91 92 struct intrhand { 93 int (*ih_fun)(void *); 94 void *ih_arg; 95 int ih_level; 96 struct intrhand *ih_ipl_next; 97 struct intrhand *ih_evt_next; 98 struct cpu_info *ih_cpu; 99 }; 100 101 102 extern struct intrstub xenev_stubs[]; 103 104 #define IUNMASK(ci,level) (ci)->ci_iunmask[(level)] 105 106 extern void Xspllower(int); 107 108 static __inline int splraise(int); 109 static __inline void spllower(int); 110 static __inline void softintr(int); 111 112 /* 113 * Add a mask to cpl, and return the old value of cpl. 114 */ 115 static __inline int 116 splraise(int nlevel) 117 { 118 int olevel; 119 struct cpu_info *ci = curcpu(); 120 121 olevel = ci->ci_ilevel; 122 if (nlevel > olevel) 123 ci->ci_ilevel = nlevel; 124 __insn_barrier(); 125 return (olevel); 126 } 127 128 /* 129 * Restore a value to cpl (unmasking interrupts). If any unmasked 130 * interrupts are pending, call Xspllower() to process them. 131 */ 132 static __inline void 133 spllower(int nlevel) 134 { 135 struct cpu_info *ci = curcpu(); 136 u_int32_t imask; 137 u_long psl; 138 139 __insn_barrier(); 140 141 imask = IUNMASK(ci, nlevel); 142 psl = read_psl(); 143 disable_intr(); 144 if (ci->ci_ipending & imask) { 145 Xspllower(nlevel); 146 /* Xspllower does enable_intr() */ 147 } else { 148 ci->ci_ilevel = nlevel; 149 write_psl(psl); 150 } 151 } 152 153 /* 154 * Hardware interrupt masks 155 */ 156 #define splbio() splraise(IPL_BIO) 157 #define splnet() splraise(IPL_NET) 158 #define spltty() splraise(IPL_TTY) 159 #define splaudio() splraise(IPL_AUDIO) 160 #define splclock() splraise(IPL_CLOCK) 161 #define splstatclock() splclock() 162 #define splserial() splraise(IPL_SERIAL) 163 164 #define spllpt() spltty() 165 166 #define SPL_ASSERT_BELOW(x) KDASSERT(curcpu()->ci_ilevel < (x)) 167 #define spllpt() spltty() 168 169 /* 170 * Software interrupt masks 171 * 172 * NOTE: spllowersoftclock() is used by hardclock() to lower the priority from 173 * clock to softclock before it calls softclock(). 174 */ 175 #define spllowersoftclock() spllower(IPL_SOFTCLOCK) 176 177 #define splsoftclock() splraise(IPL_SOFTCLOCK) 178 #define splsoftnet() splraise(IPL_SOFTNET) 179 #define splsoftserial() splraise(IPL_SOFTSERIAL) 180 #define splsoftxenevt() splraise(IPL_SOFTXENEVT) 181 182 /* 183 * Miscellaneous 184 */ 185 #define splvm() splraise(IPL_VM) 186 #define splhigh() splraise(IPL_HIGH) 187 #define spl0() spllower(IPL_NONE) 188 #define splsched() splraise(IPL_SCHED) 189 #define spllock() splhigh() 190 #ifndef MULTIPROCESSOR 191 #define splipi() splhigh() 192 #endif 193 #define splx(x) spllower(x) 194 195 /* 196 * Software interrupt registration 197 * 198 * We hand-code this to ensure that it's atomic. 199 * 200 * XXX always scheduled on the current CPU. 201 */ 202 static __inline void 203 softintr(int sir) 204 { 205 struct cpu_info *ci = curcpu(); 206 207 __asm __volatile("lock ; orl %1, %0" : 208 "=m"(ci->ci_ipending) : "ir" (1 << sir)); 209 } 210 211 /* 212 * XXX 213 */ 214 #define setsoftnet() softintr(SIR_NET) 215 216 /* 217 * Stub declarations. 218 */ 219 220 extern void Xsoftclock(void); 221 extern void Xsoftnet(void); 222 extern void Xsoftserial(void); 223 extern void Xsoftxenevt(void); 224 225 struct cpu_info; 226 227 extern char idt_allocmap[]; 228 229 struct pcibus_attach_args; 230 231 void intr_default_setup(void); 232 int x86_nmi(void); 233 void intr_calculatemasks(struct evtsource *); 234 void *intr_establish(int, struct pic *, int, int, int, int (*)(void *), void *); 235 void intr_disestablish(struct intrhand *); 236 const char *intr_string(int); 237 void cpu_intr_init(struct cpu_info *); 238 #ifdef INTRDEBUG 239 void intr_printconfig(void); 240 #endif 241 242 #endif /* !_LOCORE */ 243 244 /* 245 * Generic software interrupt support. 246 */ 247 248 #define X86_SOFTINTR_SOFTCLOCK 0 249 #define X86_SOFTINTR_SOFTNET 1 250 #define X86_SOFTINTR_SOFTSERIAL 2 251 #define X86_NSOFTINTR 3 252 253 #ifndef _LOCORE 254 #include <sys/queue.h> 255 256 struct x86_soft_intrhand { 257 TAILQ_ENTRY(x86_soft_intrhand) 258 sih_q; 259 struct x86_soft_intr *sih_intrhead; 260 void (*sih_fn)(void *); 261 void *sih_arg; 262 int sih_pending; 263 }; 264 265 struct x86_soft_intr { 266 TAILQ_HEAD(, x86_soft_intrhand) 267 softintr_q; 268 int softintr_ssir; 269 struct simplelock softintr_slock; 270 }; 271 272 #define x86_softintr_lock(si, s) \ 273 do { \ 274 (s) = splhigh(); \ 275 simple_lock(&si->softintr_slock); \ 276 } while (/*CONSTCOND*/ 0) 277 278 #define x86_softintr_unlock(si, s) \ 279 do { \ 280 simple_unlock(&si->softintr_slock); \ 281 splx((s)); \ 282 } while (/*CONSTCOND*/ 0) 283 284 void *softintr_establish(int, void (*)(void *), void *); 285 void softintr_disestablish(void *); 286 void softintr_init(void); 287 void softintr_dispatch(int); 288 289 #define softintr_schedule(arg) \ 290 do { \ 291 struct x86_soft_intrhand *__sih = (arg); \ 292 struct x86_soft_intr *__si = __sih->sih_intrhead; \ 293 int __s; \ 294 \ 295 x86_softintr_lock(__si, __s); \ 296 if (__sih->sih_pending == 0) { \ 297 TAILQ_INSERT_TAIL(&__si->softintr_q, __sih, sih_q); \ 298 __sih->sih_pending = 1; \ 299 softintr(__si->softintr_ssir); \ 300 } \ 301 x86_softintr_unlock(__si, __s); \ 302 } while (/*CONSTCOND*/ 0) 303 #endif /* _LOCORE */ 304 305 #endif /* _XEN_INTR_H_ */ 306