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