Subversion Repositories HelenOS

Rev

Rev 2265 | Rev 2307 | Go to most recent revision | Show entire file | Ignore whitespace | Details | Blame | Last modification | View Log | RSS feed

Rev 2265 Rev 2292
Line 1... Line 1...
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 signle device
42
 * - multiple IRQs per signle device
43
 *
43
 *
44
 *
44
 *
45
 * Note about architectures.
45
 * Note about architectures.
46
 *
46
 *
47
 * Some architectures has the term IRQ well defined. Examples
47
 * Some architectures has the term IRQ well defined. Examples
48
 * of such architectures include amd64, ia32 and mips32. Some
48
 * of such architectures include amd64, ia32 and mips32. Some
49
 * other architectures, such as sparc64, don't use the term
49
 * other architectures, such as sparc64, don't use the term
50
 * at all. In those cases, we boldly step forward and define what
50
 * at all. In those cases, we boldly step forward and define what
51
 * an IRQ is.
51
 * an IRQ is.
52
 *
52
 *
53
 * The implementation is generic enough and still allows the
53
 * The implementation is generic enough and still allows the
54
 * architectures to use the hardware layout effectively.
54
 * architectures to use the hardware layout effectively.
55
 * For instance, on amd64 and ia32, where there is only 16
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
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)
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.
58
 * are unique, the claim functions can always return IRQ_ACCEPT.
59
 *
59
 *
60
 *
60
 *
61
 * Note about the irq_hash_table.
61
 * Note about the irq_hash_table.
62
 *
62
 *
63
 * The hash table is configured to use two keys: inr and devno.
63
 * The hash table is configured to use two keys: inr and devno.
64
 * However, the hash index is computed only from inr. Moreover,
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
65
 * if devno is -1, the match is based on the return value of
66
 * the claim() function instead of on devno.
66
 * the claim() function instead of on devno.
67
 */
67
 */
68
 
68
 
69
#include <ddi/irq.h>
69
#include <ddi/irq.h>
70
#include <adt/hash_table.h>
70
#include <adt/hash_table.h>
71
#include <arch/types.h>
71
#include <arch/types.h>
72
#include <synch/spinlock.h>
72
#include <synch/spinlock.h>
73
#include <arch.h>
73
#include <arch.h>
74
 
74
 
75
#define KEY_INR     0
75
#define KEY_INR     0
76
#define KEY_DEVNO   1
76
#define KEY_DEVNO   1
77
 
77
 
78
/**
78
/**
79
 * Spinlock protecting the hash table.
79
 * Spinlock protecting the hash table.
80
 * This lock must be taken only when interrupts are disabled.
80
 * This lock must be taken only when interrupts are disabled.
81
 */
81
 */
82
SPINLOCK_INITIALIZE(irq_hash_table_lock);
82
SPINLOCK_INITIALIZE(irq_hash_table_lock);
83
static hash_table_t irq_hash_table;
83
static hash_table_t irq_hash_table;
84
 
84
 
85
/**
85
/**
86
 * Hash table operations for cases when we know that
86
 * Hash table operations for cases when we know that
87
 * there will be collisions between different keys.
87
 * there will be collisions between different keys.
88
 */
88
 */
89
static index_t irq_ht_hash(unative_t *key);
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);
90
static bool irq_ht_compare(unative_t *key, count_t keys, link_t *item);
91
 
91
 
92
static hash_table_operations_t irq_ht_ops = {
92
static hash_table_operations_t irq_ht_ops = {
93
    .hash = irq_ht_hash,
93
    .hash = irq_ht_hash,
94
    .compare = irq_ht_compare,
94
    .compare = irq_ht_compare,
95
    .remove_callback = NULL     /* not used */
95
    .remove_callback = NULL     /* not used */
96
};
96
};
97
 
97
 
98
/**
98
/**
99
 * Hash table operations for cases when we know that
99
 * Hash table operations for cases when we know that
100
 * there will be no collisions between different keys.
100
 * there will be no collisions between different keys.
101
 * However, there might be still collisions among
101
 * However, there might be still collisions among
102
 * elements with single key (sharing of one IRQ).
102
 * elements with single key (sharing of one IRQ).
103
 */
103
 */
104
static index_t irq_lin_hash(unative_t *key);
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);
105
static bool irq_lin_compare(unative_t *key, count_t keys, link_t *item);
106
 
106
 
107
static hash_table_operations_t irq_lin_ops = {
107
static hash_table_operations_t irq_lin_ops = {
108
    .hash = irq_lin_hash,
108
    .hash = irq_lin_hash,
109
    .compare = irq_lin_compare,
109
    .compare = irq_lin_compare,
110
    .remove_callback = NULL     /* not used */
110
    .remove_callback = NULL     /* not used */
111
};
111
};
112
 
112
 
113
/** Initialize IRQ subsystem.
113
/** Initialize IRQ subsystem.
114
 *
114
 *
115
 * @param inrs Numbers of unique IRQ numbers or INRs.
115
 * @param inrs Numbers of unique IRQ numbers or INRs.
116
 * @param chains Number of chains in the hash table.
116
 * @param chains Number of chains in the hash table.
117
 */
117
 */
118
void irq_init(count_t inrs, count_t chains)
118
void irq_init(count_t inrs, count_t chains)
119
{
119
{
120
    /*
120
    /*
121
     * Be smart about the choice of the hash table operations.
121
     * Be smart about the choice of the hash table operations.
122
     * In cases in which inrs equals the requested number of
122
     * In cases in which inrs equals the requested number of
123
     * chains (i.e. where there is no collision between
123
     * chains (i.e. where there is no collision between
124
     * different keys), we can use optimized set of operations.
124
     * different keys), we can use optimized set of operations.
125
     */
125
     */
126
    if (inrs == chains)
126
    if (inrs == chains)
127
        hash_table_create(&irq_hash_table, chains, 2, &irq_lin_ops);
127
        hash_table_create(&irq_hash_table, chains, 2, &irq_lin_ops);
128
    else
128
    else
129
        hash_table_create(&irq_hash_table, chains, 2, &irq_ht_ops);
129
        hash_table_create(&irq_hash_table, chains, 2, &irq_ht_ops);
130
}
130
}
131
 
131
 
132
/** Initialize one IRQ structure.
132
/** Initialize one IRQ structure.
133
 *
133
 *
134
 * @param irq Pointer to the IRQ structure to be initialized.
134
 * @param irq Pointer to the IRQ structure to be initialized.
135
 *
135
 *
136
 */
136
 */
137
void irq_initialize(irq_t *irq)
137
void irq_initialize(irq_t *irq)
138
{
138
{
139
    link_initialize(&irq->link);
139
    link_initialize(&irq->link);
140
    spinlock_initialize(&irq->lock, "irq.lock");
140
    spinlock_initialize(&irq->lock, "irq.lock");
141
    irq->preack = false;
141
    irq->inr = -1;
142
    irq->inr = -1;
142
    irq->devno = -1;
143
    irq->devno = -1;
143
    irq->trigger = (irq_trigger_t) 0;
144
    irq->trigger = (irq_trigger_t) 0;
144
    irq->claim = NULL;
145
    irq->claim = NULL;
145
    irq->handler = NULL;
146
    irq->handler = NULL;
146
    irq->arg = NULL;
147
    irq->arg = NULL;
147
    irq->notif_cfg.notify = false;
148
    irq->notif_cfg.notify = false;
148
    irq->notif_cfg.answerbox = NULL;
149
    irq->notif_cfg.answerbox = NULL;
149
    irq->notif_cfg.code = NULL;
150
    irq->notif_cfg.code = NULL;
150
    irq->notif_cfg.method = 0;
151
    irq->notif_cfg.method = 0;
151
    irq->notif_cfg.counter = 0;
152
    irq->notif_cfg.counter = 0;
152
    link_initialize(&irq->notif_cfg.link);
153
    link_initialize(&irq->notif_cfg.link);
153
}
154
}
154
 
155
 
155
/** Register IRQ for device.
156
/** Register IRQ for device.
156
 *
157
 *
157
 * The irq structure must be filled with information
158
 * The irq structure must be filled with information
158
 * about the interrupt source and with the claim()
159
 * about the interrupt source and with the claim()
159
 * function pointer and irq_handler() function pointer.
160
 * function pointer and irq_handler() function pointer.
160
 *
161
 *
161
 * @param irq IRQ structure belonging to a device.
162
 * @param irq IRQ structure belonging to a device.
162
 */
163
 */
163
void irq_register(irq_t *irq)
164
void irq_register(irq_t *irq)
164
{
165
{
165
    ipl_t ipl;
166
    ipl_t ipl;
166
    unative_t key[] = {
167
    unative_t key[] = {
167
        (unative_t) irq->inr,
168
        (unative_t) irq->inr,
168
        (unative_t) irq->devno
169
        (unative_t) irq->devno
169
    };
170
    };
170
   
171
   
171
    ipl = interrupts_disable();
172
    ipl = interrupts_disable();
172
    spinlock_lock(&irq_hash_table_lock);
173
    spinlock_lock(&irq_hash_table_lock);
173
    hash_table_insert(&irq_hash_table, key, &irq->link);
174
    hash_table_insert(&irq_hash_table, key, &irq->link);
174
    spinlock_unlock(&irq_hash_table_lock);
175
    spinlock_unlock(&irq_hash_table_lock);
175
    interrupts_restore(ipl);
176
    interrupts_restore(ipl);
176
}
177
}
177
 
178
 
178
/** Dispatch the IRQ.
179
/** Dispatch the IRQ.
179
 *
180
 *
180
 * We assume this function is only called from interrupt
181
 * We assume this function is only called from interrupt
181
 * context (i.e. that interrupts are disabled prior to
182
 * context (i.e. that interrupts are disabled prior to
182
 * this call).
183
 * this call).
183
 *
184
 *
184
 * This function attempts to lookup a fitting IRQ
185
 * This function attempts to lookup a fitting IRQ
185
 * structure. In case of success, return with interrupts
186
 * structure. In case of success, return with interrupts
186
 * disabled and holding the respective structure.
187
 * disabled and holding the respective structure.
187
 *
188
 *
188
 * @param inr Interrupt number (aka inr or irq).
189
 * @param inr Interrupt number (aka inr or irq).
189
 *
190
 *
190
 * @return IRQ structure of the respective device or NULL.
191
 * @return IRQ structure of the respective device or NULL.
191
 */
192
 */
192
irq_t *irq_dispatch_and_lock(inr_t inr)
193
irq_t *irq_dispatch_and_lock(inr_t inr)
193
{
194
{
194
    link_t *lnk;
195
    link_t *lnk;
195
    unative_t key[] = {
196
    unative_t key[] = {
196
        (unative_t) inr,
197
        (unative_t) inr,
197
        (unative_t) -1      /* search will use claim() instead of devno */
198
        (unative_t) -1      /* search will use claim() instead of devno */
198
    };
199
    };
199
   
200
   
200
    spinlock_lock(&irq_hash_table_lock);
201
    spinlock_lock(&irq_hash_table_lock);
201
 
202
 
202
    lnk = hash_table_find(&irq_hash_table, key);
203
    lnk = hash_table_find(&irq_hash_table, key);
203
    if (lnk) {
204
    if (lnk) {
204
        irq_t *irq;
205
        irq_t *irq;
205
       
206
       
206
        irq = hash_table_get_instance(lnk, irq_t, link);
207
        irq = hash_table_get_instance(lnk, irq_t, link);
207
 
208
 
208
        spinlock_unlock(&irq_hash_table_lock);
209
        spinlock_unlock(&irq_hash_table_lock);
209
        return irq;
210
        return irq;
210
    }
211
    }
211
   
212
   
212
    spinlock_unlock(&irq_hash_table_lock);
213
    spinlock_unlock(&irq_hash_table_lock);
213
 
214
 
214
    return NULL;   
215
    return NULL;   
215
}
216
}
216
 
217
 
217
/** Find the IRQ structure corresponding to inr and devno.
218
/** Find the IRQ structure corresponding to inr and devno.
218
 *
219
 *
219
 * This functions attempts to lookup the IRQ structure
220
 * This functions attempts to lookup the IRQ structure
220
 * corresponding to its arguments. On success, this
221
 * corresponding to its arguments. On success, this
221
 * function returns with interrups disabled, holding
222
 * function returns with interrups disabled, holding
222
 * the lock of the respective IRQ structure.
223
 * the lock of the respective IRQ structure.
223
 *
224
 *
224
 * This function assumes interrupts are already disabled.
225
 * This function assumes interrupts are already disabled.
225
 *
226
 *
226
 * @param inr INR being looked up.
227
 * @param inr INR being looked up.
227
 * @param devno Devno being looked up.
228
 * @param devno Devno being looked up.
228
 *
229
 *
229
 * @return Locked IRQ structure on success or NULL on failure.
230
 * @return Locked IRQ structure on success or NULL on failure.
230
 */
231
 */
231
irq_t *irq_find_and_lock(inr_t inr, devno_t devno)
232
irq_t *irq_find_and_lock(inr_t inr, devno_t devno)
232
{
233
{
233
    link_t *lnk;
234
    link_t *lnk;
234
    unative_t keys[] = {
235
    unative_t keys[] = {
235
        (unative_t) inr,
236
        (unative_t) inr,
236
        (unative_t) devno
237
        (unative_t) devno
237
    };
238
    };
238
   
239
   
239
    spinlock_lock(&irq_hash_table_lock);
240
    spinlock_lock(&irq_hash_table_lock);
240
 
241
 
241
    lnk = hash_table_find(&irq_hash_table, keys);
242
    lnk = hash_table_find(&irq_hash_table, keys);
242
    if (lnk) {
243
    if (lnk) {
243
        irq_t *irq;
244
        irq_t *irq;
244
       
245
       
245
        irq = hash_table_get_instance(lnk, irq_t, link);
246
        irq = hash_table_get_instance(lnk, irq_t, link);
246
 
247
 
247
        spinlock_unlock(&irq_hash_table_lock);
248
        spinlock_unlock(&irq_hash_table_lock);
248
        return irq;
249
        return irq;
249
    }
250
    }
250
   
251
   
251
    spinlock_unlock(&irq_hash_table_lock);
252
    spinlock_unlock(&irq_hash_table_lock);
252
 
253
 
253
    return NULL;   
254
    return NULL;   
254
}
255
}
255
 
256
 
256
/** Compute hash index for the key.
257
/** Compute hash index for the key.
257
 *
258
 *
258
 * This function computes hash index into
259
 * This function computes hash index into
259
 * the IRQ hash table for which there
260
 * the IRQ hash table for which there
260
 * can be collisions between different
261
 * can be collisions between different
261
 * INRs.
262
 * INRs.
262
 *
263
 *
263
 * The devno is not used to compute the hash.
264
 * The devno is not used to compute the hash.
264
 *
265
 *
265
 * @param key The first of the keys is inr and the second is devno or -1.
266
 * @param key The first of the keys is inr and the second is devno or -1.
266
 *
267
 *
267
 * @return Index into the hash table.
268
 * @return Index into the hash table.
268
 */
269
 */
269
index_t irq_ht_hash(unative_t key[])
270
index_t irq_ht_hash(unative_t key[])
270
{
271
{
271
    inr_t inr = (inr_t) key[KEY_INR];
272
    inr_t inr = (inr_t) key[KEY_INR];
272
    return inr % irq_hash_table.entries;
273
    return inr % irq_hash_table.entries;
273
}
274
}
274
 
275
 
275
/** Compare hash table element with a key.
276
/** Compare hash table element with a key.
276
 *
277
 *
277
 * There are two things to note about this function.
278
 * There are two things to note about this function.
278
 * First, it is used for the more complex architecture setup
279
 * 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
 * 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
 * to arrange the hash table so that collisions occur only
281
 * among same inrs of different devnos. So the explicit check
282
 * among same inrs of different devnos. So the explicit check
282
 * for inr match must be done.
283
 * for inr match must be done.
283
 * Second, if devno is -1, the second key (i.e. devno) is not
284
 * 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
 * used for the match and the result of the claim() function
285
 * is used instead.
286
 * is used instead.
286
 *
287
 *
287
 * This function assumes interrupts are already disabled.
288
 * This function assumes interrupts are already disabled.
288
 *
289
 *
289
 * @param key Keys (i.e. inr and devno).
290
 * @param key Keys (i.e. inr and devno).
290
 * @param keys This is 2.
291
 * @param keys This is 2.
291
 * @param item The item to compare the key with.
292
 * @param item The item to compare the key with.
292
 *
293
 *
293
 * @return True on match or false otherwise.
294
 * @return True on match or false otherwise.
294
 */
295
 */
295
bool irq_ht_compare(unative_t key[], count_t keys, link_t *item)
296
bool irq_ht_compare(unative_t key[], count_t keys, link_t *item)
296
{
297
{
297
    irq_t *irq = hash_table_get_instance(item, irq_t, link);
298
    irq_t *irq = hash_table_get_instance(item, irq_t, link);
298
    inr_t inr = (inr_t) key[KEY_INR];
299
    inr_t inr = (inr_t) key[KEY_INR];
299
    devno_t devno = (devno_t) key[KEY_DEVNO];
300
    devno_t devno = (devno_t) key[KEY_DEVNO];
300
 
301
 
301
    bool rv;
302
    bool rv;
302
   
303
   
303
    spinlock_lock(&irq->lock);
304
    spinlock_lock(&irq->lock);
304
    if (devno == -1) {
305
    if (devno == -1) {
305
        /* Invoked by irq_dispatch_and_lock(). */
306
        /* Invoked by irq_dispatch_and_lock(). */
306
        rv = ((irq->inr == inr) && (irq->claim() == IRQ_ACCEPT));
307
        rv = ((irq->inr == inr) && (irq->claim() == IRQ_ACCEPT));
307
    } else {
308
    } else {
308
        /* Invoked by irq_find_and_lock(). */
309
        /* Invoked by irq_find_and_lock(). */
309
        rv = ((irq->inr == inr) && (irq->devno == devno));
310
        rv = ((irq->inr == inr) && (irq->devno == devno));
310
    }
311
    }
311
   
312
   
312
    /* unlock only on non-match */
313
    /* unlock only on non-match */
313
    if (!rv)
314
    if (!rv)
314
        spinlock_unlock(&irq->lock);
315
        spinlock_unlock(&irq->lock);
315
 
316
 
316
    return rv;
317
    return rv;
317
}
318
}
318
 
319
 
319
/** Compute hash index for the key.
320
/** Compute hash index for the key.
320
 *
321
 *
321
 * This function computes hash index into
322
 * This function computes hash index into
322
 * the IRQ hash table for which there
323
 * the IRQ hash table for which there
323
 * are no collisions between different
324
 * are no collisions between different
324
 * INRs.
325
 * INRs.
325
 *
326
 *
326
 * @param key The first of the keys is inr and the second is devno or -1.
327
 * @param key The first of the keys is inr and the second is devno or -1.
327
 *
328
 *
328
 * @return Index into the hash table.
329
 * @return Index into the hash table.
329
 */
330
 */
330
index_t irq_lin_hash(unative_t key[])
331
index_t irq_lin_hash(unative_t key[])
331
{
332
{
332
    inr_t inr = (inr_t) key[KEY_INR];
333
    inr_t inr = (inr_t) key[KEY_INR];
333
    return inr;
334
    return inr;
334
}
335
}
335
 
336
 
336
/** Compare hash table element with a key.
337
/** Compare hash table element with a key.
337
 *
338
 *
338
 * There are two things to note about this function.
339
 * There are two things to note about this function.
339
 * First, it is used for the less complex architecture setup
340
 * 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
 * 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
 * to arrange the hash table so that collisions occur only
342
 * among same inrs of different devnos. So the explicit check
343
 * among same inrs of different devnos. So the explicit check
343
 * for inr match is not done.
344
 * for inr match is not done.
344
 * Second, if devno is -1, the second key (i.e. devno) is not
345
 * 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
 * used for the match and the result of the claim() function
346
 * is used instead.
347
 * is used instead.
347
 *
348
 *
348
 * This function assumes interrupts are already disabled.
349
 * This function assumes interrupts are already disabled.
349
 *
350
 *
350
 * @param key Keys (i.e. inr and devno).
351
 * @param key Keys (i.e. inr and devno).
351
 * @param keys This is 2.
352
 * @param keys This is 2.
352
 * @param item The item to compare the key with.
353
 * @param item The item to compare the key with.
353
 *
354
 *
354
 * @return True on match or false otherwise.
355
 * @return True on match or false otherwise.
355
 */
356
 */
356
bool irq_lin_compare(unative_t key[], count_t keys, link_t *item)
357
bool irq_lin_compare(unative_t key[], count_t keys, link_t *item)
357
{
358
{
358
    irq_t *irq = list_get_instance(item, irq_t, link);
359
    irq_t *irq = list_get_instance(item, irq_t, link);
359
    devno_t devno = (devno_t) key[KEY_DEVNO];
360
    devno_t devno = (devno_t) key[KEY_DEVNO];
360
    bool rv;
361
    bool rv;
361
   
362
   
362
    spinlock_lock(&irq->lock);
363
    spinlock_lock(&irq->lock);
363
    if (devno == -1) {
364
    if (devno == -1) {
364
        /* Invoked by irq_dispatch_and_lock() */
365
        /* Invoked by irq_dispatch_and_lock() */
365
        rv = (irq->claim() == IRQ_ACCEPT);
366
        rv = (irq->claim() == IRQ_ACCEPT);
366
    } else {
367
    } else {
367
        /* Invoked by irq_find_and_lock() */
368
        /* Invoked by irq_find_and_lock() */
368
        rv = (irq->devno == devno);
369
        rv = (irq->devno == devno);
369
    }
370
    }
370
   
371
   
371
    /* unlock only on non-match */
372
    /* unlock only on non-match */
372
    if (!rv)
373
    if (!rv)
373
        spinlock_unlock(&irq->lock);
374
        spinlock_unlock(&irq->lock);
374
   
375
   
375
    return rv;
376
    return rv;
376
}
377
}
377
 
378
 
378
/** @}
379
/** @}
379
 */
380
 */
-