Rev 2117 | Rev 2292 | Go to most recent revision | Details | Compare with Previous | Last modification | View Log | RSS feed
Rev | Author | Line No. | Line |
---|---|---|---|
1919 | jermar | 1 | /* |
2071 | jermar | 2 | * Copyright (c) 2006 Jakub Jermar |
1919 | jermar | 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 | * |
||
9 | * - Redistributions of source code must retain the above copyright |
||
10 | * notice, this list of conditions and the following disclaimer. |
||
11 | * - 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 | * - The name of the author may not be used to endorse or promote products |
||
15 | * derived from this software without specific prior written permission. |
||
16 | * |
||
17 | * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
||
18 | * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
||
19 | * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
||
20 | * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
||
21 | * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
||
22 | * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
||
23 | * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
||
24 | * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
||
25 | * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
||
26 | * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
||
27 | */ |
||
28 | |||
1920 | jermar | 29 | /** @addtogroup genericddi |
1919 | jermar | 30 | * @{ |
31 | */ |
||
32 | /** |
||
33 | * @file |
||
1922 | jermar | 34 | * @brief IRQ dispatcher. |
1919 | jermar | 35 | * |
36 | * This file provides means of connecting IRQs with particular |
||
37 | * devices and logic for dispatching interrupts to IRQ handlers |
||
38 | * defined by those devices. |
||
39 | * |
||
40 | * This code is designed to support: |
||
41 | * - multiple devices sharing single IRQ |
||
42 | * - multiple IRQs per signle device |
||
43 | * |
||
44 | * |
||
45 | * Note about architectures. |
||
46 | * |
||
47 | * Some architectures has the term IRQ well defined. Examples |
||
48 | * of such architectures include amd64, ia32 and mips32. Some |
||
49 | * other architectures, such as sparc64, don't use the term |
||
50 | * at all. In those cases, we boldly step forward and define what |
||
51 | * an IRQ is. |
||
52 | * |
||
53 | * The implementation is generic enough and still allows the |
||
54 | * architectures to use the hardware layout effectively. |
||
55 | * For instance, on amd64 and ia32, where there is only 16 |
||
56 | * IRQs, the irq_hash_table can be optimized to a one-dimensional |
||
57 | * array. Next, when it is known that the IRQ numbers (aka INR's) |
||
58 | * are unique, the claim functions can always return IRQ_ACCEPT. |
||
1922 | jermar | 59 | * |
60 | * |
||
61 | * Note about the irq_hash_table. |
||
62 | * |
||
63 | * The hash table is configured to use two keys: inr and devno. |
||
64 | * However, the hash index is computed only from inr. Moreover, |
||
65 | * if devno is -1, the match is based on the return value of |
||
66 | * the claim() function instead of on devno. |
||
1919 | jermar | 67 | */ |
68 | |||
1920 | jermar | 69 | #include <ddi/irq.h> |
1919 | jermar | 70 | #include <adt/hash_table.h> |
71 | #include <arch/types.h> |
||
72 | #include <synch/spinlock.h> |
||
73 | #include <arch.h> |
||
74 | |||
1922 | jermar | 75 | #define KEY_INR 0 |
76 | #define KEY_DEVNO 1 |
||
77 | |||
1919 | jermar | 78 | /** |
79 | * Spinlock protecting the hash table. |
||
80 | * This lock must be taken only when interrupts are disabled. |
||
81 | */ |
||
82 | SPINLOCK_INITIALIZE(irq_hash_table_lock); |
||
83 | static hash_table_t irq_hash_table; |
||
84 | |||
85 | /** |
||
86 | * Hash table operations for cases when we know that |
||
87 | * there will be collisions between different keys. |
||
88 | */ |
||
89 | static index_t irq_ht_hash(unative_t *key); |
||
90 | static bool irq_ht_compare(unative_t *key, count_t keys, link_t *item); |
||
91 | |||
92 | static hash_table_operations_t irq_ht_ops = { |
||
93 | .hash = irq_ht_hash, |
||
94 | .compare = irq_ht_compare, |
||
95 | .remove_callback = NULL /* not used */ |
||
96 | }; |
||
97 | |||
98 | /** |
||
99 | * Hash table operations for cases when we know that |
||
100 | * there will be no collisions between different keys. |
||
101 | * However, there might be still collisions among |
||
102 | * elements with single key (sharing of one IRQ). |
||
103 | */ |
||
104 | static index_t irq_lin_hash(unative_t *key); |
||
105 | static bool irq_lin_compare(unative_t *key, count_t keys, link_t *item); |
||
106 | |||
107 | static hash_table_operations_t irq_lin_ops = { |
||
108 | .hash = irq_lin_hash, |
||
109 | .compare = irq_lin_compare, |
||
110 | .remove_callback = NULL /* not used */ |
||
111 | }; |
||
112 | |||
113 | /** Initialize IRQ subsystem. |
||
114 | * |
||
115 | * @param inrs Numbers of unique IRQ numbers or INRs. |
||
116 | * @param chains Number of chains in the hash table. |
||
117 | */ |
||
118 | void irq_init(count_t inrs, count_t chains) |
||
119 | { |
||
120 | /* |
||
121 | * Be smart about the choice of the hash table operations. |
||
122 | * In cases in which inrs equals the requested number of |
||
123 | * chains (i.e. where there is no collision between |
||
124 | * different keys), we can use optimized set of operations. |
||
125 | */ |
||
126 | if (inrs == chains) |
||
1922 | jermar | 127 | hash_table_create(&irq_hash_table, chains, 2, &irq_lin_ops); |
1919 | jermar | 128 | else |
1922 | jermar | 129 | hash_table_create(&irq_hash_table, chains, 2, &irq_ht_ops); |
1919 | jermar | 130 | } |
131 | |||
132 | /** Initialize one IRQ structure. |
||
133 | * |
||
134 | * @param irq Pointer to the IRQ structure to be initialized. |
||
135 | * |
||
136 | */ |
||
137 | void irq_initialize(irq_t *irq) |
||
138 | { |
||
139 | link_initialize(&irq->link); |
||
1921 | jermar | 140 | spinlock_initialize(&irq->lock, "irq.lock"); |
1919 | jermar | 141 | irq->inr = -1; |
142 | irq->devno = -1; |
||
2117 | decky | 143 | irq->trigger = (irq_trigger_t) 0; |
1919 | jermar | 144 | irq->claim = NULL; |
145 | irq->handler = NULL; |
||
146 | irq->arg = NULL; |
||
1933 | jermar | 147 | irq->notif_cfg.notify = false; |
1923 | jermar | 148 | irq->notif_cfg.answerbox = NULL; |
149 | irq->notif_cfg.code = NULL; |
||
150 | irq->notif_cfg.method = 0; |
||
151 | irq->notif_cfg.counter = 0; |
||
1933 | jermar | 152 | link_initialize(&irq->notif_cfg.link); |
1919 | jermar | 153 | } |
154 | |||
155 | /** Register IRQ for device. |
||
156 | * |
||
157 | * The irq structure must be filled with information |
||
158 | * about the interrupt source and with the claim() |
||
159 | * function pointer and irq_handler() function pointer. |
||
160 | * |
||
161 | * @param irq IRQ structure belonging to a device. |
||
162 | */ |
||
163 | void irq_register(irq_t *irq) |
||
164 | { |
||
165 | ipl_t ipl; |
||
1922 | jermar | 166 | unative_t key[] = { |
167 | (unative_t) irq->inr, |
||
168 | (unative_t) irq->devno |
||
169 | }; |
||
1919 | jermar | 170 | |
171 | ipl = interrupts_disable(); |
||
172 | spinlock_lock(&irq_hash_table_lock); |
||
1922 | jermar | 173 | hash_table_insert(&irq_hash_table, key, &irq->link); |
1919 | jermar | 174 | spinlock_unlock(&irq_hash_table_lock); |
175 | interrupts_restore(ipl); |
||
176 | } |
||
177 | |||
178 | /** Dispatch the IRQ. |
||
179 | * |
||
1922 | jermar | 180 | * We assume this function is only called from interrupt |
181 | * context (i.e. that interrupts are disabled prior to |
||
182 | * this call). |
||
183 | * |
||
184 | * This function attempts to lookup a fitting IRQ |
||
185 | * structure. In case of success, return with interrupts |
||
186 | * disabled and holding the respective structure. |
||
187 | * |
||
1919 | jermar | 188 | * @param inr Interrupt number (aka inr or irq). |
189 | * |
||
190 | * @return IRQ structure of the respective device or NULL. |
||
191 | */ |
||
1922 | jermar | 192 | irq_t *irq_dispatch_and_lock(inr_t inr) |
1919 | jermar | 193 | { |
194 | link_t *lnk; |
||
1922 | jermar | 195 | unative_t key[] = { |
196 | (unative_t) inr, |
||
197 | (unative_t) -1 /* search will use claim() instead of devno */ |
||
198 | }; |
||
1919 | jermar | 199 | |
200 | spinlock_lock(&irq_hash_table_lock); |
||
201 | |||
1922 | jermar | 202 | lnk = hash_table_find(&irq_hash_table, key); |
1919 | jermar | 203 | if (lnk) { |
204 | irq_t *irq; |
||
205 | |||
206 | irq = hash_table_get_instance(lnk, irq_t, link); |
||
207 | |||
208 | spinlock_unlock(&irq_hash_table_lock); |
||
209 | return irq; |
||
210 | } |
||
211 | |||
212 | spinlock_unlock(&irq_hash_table_lock); |
||
213 | |||
214 | return NULL; |
||
215 | } |
||
216 | |||
1922 | jermar | 217 | /** Find the IRQ structure corresponding to inr and devno. |
218 | * |
||
219 | * This functions attempts to lookup the IRQ structure |
||
220 | * corresponding to its arguments. On success, this |
||
221 | * function returns with interrups disabled, holding |
||
222 | * the lock of the respective IRQ structure. |
||
223 | * |
||
224 | * This function assumes interrupts are already disabled. |
||
225 | * |
||
226 | * @param inr INR being looked up. |
||
227 | * @param devno Devno being looked up. |
||
228 | * |
||
229 | * @return Locked IRQ structure on success or NULL on failure. |
||
230 | */ |
||
231 | irq_t *irq_find_and_lock(inr_t inr, devno_t devno) |
||
232 | { |
||
233 | link_t *lnk; |
||
234 | unative_t keys[] = { |
||
235 | (unative_t) inr, |
||
236 | (unative_t) devno |
||
237 | }; |
||
238 | |||
239 | spinlock_lock(&irq_hash_table_lock); |
||
240 | |||
241 | lnk = hash_table_find(&irq_hash_table, keys); |
||
242 | if (lnk) { |
||
243 | irq_t *irq; |
||
244 | |||
245 | irq = hash_table_get_instance(lnk, irq_t, link); |
||
246 | |||
247 | spinlock_unlock(&irq_hash_table_lock); |
||
248 | return irq; |
||
249 | } |
||
250 | |||
251 | spinlock_unlock(&irq_hash_table_lock); |
||
252 | |||
253 | return NULL; |
||
254 | } |
||
255 | |||
1919 | jermar | 256 | /** Compute hash index for the key. |
257 | * |
||
258 | * This function computes hash index into |
||
259 | * the IRQ hash table for which there |
||
260 | * can be collisions between different |
||
261 | * INRs. |
||
262 | * |
||
1922 | jermar | 263 | * The devno is not used to compute the hash. |
1919 | jermar | 264 | * |
1922 | jermar | 265 | * @param key The first of the keys is inr and the second is devno or -1. |
266 | * |
||
1919 | jermar | 267 | * @return Index into the hash table. |
268 | */ |
||
1922 | jermar | 269 | index_t irq_ht_hash(unative_t key[]) |
1919 | jermar | 270 | { |
1922 | jermar | 271 | inr_t inr = (inr_t) key[KEY_INR]; |
272 | return inr % irq_hash_table.entries; |
||
1919 | jermar | 273 | } |
274 | |||
275 | /** Compare hash table element with a key. |
||
276 | * |
||
1922 | jermar | 277 | * There are two things to note about this function. |
278 | * First, it is used for the more complex architecture setup |
||
279 | * in which there are way too many interrupt numbers (i.e. inr's) |
||
280 | * to arrange the hash table so that collisions occur only |
||
281 | * among same inrs of different devnos. So the explicit check |
||
282 | * for inr match must be done. |
||
283 | * Second, if devno is -1, the second key (i.e. devno) is not |
||
284 | * used for the match and the result of the claim() function |
||
285 | * is used instead. |
||
1919 | jermar | 286 | * |
1922 | jermar | 287 | * This function assumes interrupts are already disabled. |
288 | * |
||
289 | * @param key Keys (i.e. inr and devno). |
||
290 | * @param keys This is 2. |
||
1919 | jermar | 291 | * @param item The item to compare the key with. |
292 | * |
||
293 | * @return True on match or false otherwise. |
||
294 | */ |
||
1922 | jermar | 295 | bool irq_ht_compare(unative_t key[], count_t keys, link_t *item) |
1919 | jermar | 296 | { |
297 | irq_t *irq = hash_table_get_instance(item, irq_t, link); |
||
1922 | jermar | 298 | inr_t inr = (inr_t) key[KEY_INR]; |
299 | devno_t devno = (devno_t) key[KEY_DEVNO]; |
||
300 | |||
1921 | jermar | 301 | bool rv; |
1919 | jermar | 302 | |
1921 | jermar | 303 | spinlock_lock(&irq->lock); |
1922 | jermar | 304 | if (devno == -1) { |
2107 | jermar | 305 | /* Invoked by irq_dispatch_and_lock(). */ |
1922 | jermar | 306 | rv = ((irq->inr == inr) && (irq->claim() == IRQ_ACCEPT)); |
307 | } else { |
||
2107 | jermar | 308 | /* Invoked by irq_find_and_lock(). */ |
1922 | jermar | 309 | rv = ((irq->inr == inr) && (irq->devno == devno)); |
310 | } |
||
311 | |||
312 | /* unlock only on non-match */ |
||
313 | if (!rv) |
||
314 | spinlock_unlock(&irq->lock); |
||
1921 | jermar | 315 | |
316 | return rv; |
||
1919 | jermar | 317 | } |
318 | |||
319 | /** Compute hash index for the key. |
||
320 | * |
||
321 | * This function computes hash index into |
||
322 | * the IRQ hash table for which there |
||
323 | * are no collisions between different |
||
324 | * INRs. |
||
325 | * |
||
1922 | jermar | 326 | * @param key The first of the keys is inr and the second is devno or -1. |
1919 | jermar | 327 | * |
328 | * @return Index into the hash table. |
||
329 | */ |
||
1922 | jermar | 330 | index_t irq_lin_hash(unative_t key[]) |
1919 | jermar | 331 | { |
1922 | jermar | 332 | inr_t inr = (inr_t) key[KEY_INR]; |
333 | return inr; |
||
1919 | jermar | 334 | } |
335 | |||
336 | /** Compare hash table element with a key. |
||
337 | * |
||
1922 | jermar | 338 | * There are two things to note about this function. |
339 | * First, it is used for the less complex architecture setup |
||
340 | * in which there are not too many interrupt numbers (i.e. inr's) |
||
341 | * to arrange the hash table so that collisions occur only |
||
342 | * among same inrs of different devnos. So the explicit check |
||
343 | * for inr match is not done. |
||
344 | * Second, if devno is -1, the second key (i.e. devno) is not |
||
345 | * used for the match and the result of the claim() function |
||
346 | * is used instead. |
||
1919 | jermar | 347 | * |
1922 | jermar | 348 | * This function assumes interrupts are already disabled. |
349 | * |
||
350 | * @param key Keys (i.e. inr and devno). |
||
351 | * @param keys This is 2. |
||
1919 | jermar | 352 | * @param item The item to compare the key with. |
353 | * |
||
354 | * @return True on match or false otherwise. |
||
355 | */ |
||
1922 | jermar | 356 | bool irq_lin_compare(unative_t key[], count_t keys, link_t *item) |
1919 | jermar | 357 | { |
358 | irq_t *irq = list_get_instance(item, irq_t, link); |
||
1922 | jermar | 359 | devno_t devno = (devno_t) key[KEY_DEVNO]; |
1921 | jermar | 360 | bool rv; |
1919 | jermar | 361 | |
1921 | jermar | 362 | spinlock_lock(&irq->lock); |
1922 | jermar | 363 | if (devno == -1) { |
2107 | jermar | 364 | /* Invoked by irq_dispatch_and_lock() */ |
1922 | jermar | 365 | rv = (irq->claim() == IRQ_ACCEPT); |
366 | } else { |
||
2107 | jermar | 367 | /* Invoked by irq_find_and_lock() */ |
1922 | jermar | 368 | rv = (irq->devno == devno); |
369 | } |
||
1921 | jermar | 370 | |
1922 | jermar | 371 | /* unlock only on non-match */ |
372 | if (!rv) |
||
373 | spinlock_unlock(&irq->lock); |
||
374 | |||
1921 | jermar | 375 | return rv; |
1919 | jermar | 376 | } |
377 | |||
378 | /** @} |
||
379 | */ |