Subversion Repositories HelenOS

Rev

Rev 4274 | Only display areas with differences | Ignore whitespace | Details | Blame | Last modification | View Log | RSS feed

Rev 4274 Rev 4490
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 <console/console.h>
75
#include <console/console.h>
76
#include <memstr.h>
76
#include <memstr.h>
77
#include <arch.h>
77
#include <arch.h>
78
 
78
 
79
#define KEY_INR     0
79
#define KEY_INR     0
80
#define KEY_DEVNO   1
80
#define KEY_DEVNO   1
81
 
81
 
82
/**
82
/**
83
 * Spinlock protecting the kernel IRQ hash table.
83
 * Spinlock protecting the kernel IRQ hash table.
84
 * This lock must be taken only when interrupts are disabled.
84
 * This lock must be taken only when interrupts are disabled.
85
 */
85
 */
86
SPINLOCK_INITIALIZE(irq_kernel_hash_table_lock);
86
SPINLOCK_INITIALIZE(irq_kernel_hash_table_lock);
87
/** The kernel IRQ hash table. */
87
/** The kernel IRQ hash table. */
88
static hash_table_t irq_kernel_hash_table;
88
static hash_table_t irq_kernel_hash_table;
89
 
89
 
90
/**
90
/**
91
 * Spinlock protecting the uspace IRQ hash table.
91
 * Spinlock protecting the uspace IRQ hash table.
92
 * This lock must be taken only when interrupts are disabled.
92
 * This lock must be taken only when interrupts are disabled.
93
 */
93
 */
94
SPINLOCK_INITIALIZE(irq_uspace_hash_table_lock);
94
SPINLOCK_INITIALIZE(irq_uspace_hash_table_lock);
95
/** The uspace IRQ hash table. */
95
/** The uspace IRQ hash table. */
96
hash_table_t irq_uspace_hash_table;
96
hash_table_t irq_uspace_hash_table;
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 collisions between different keys.
100
 * there will be collisions between different keys.
101
 */
101
 */
102
static index_t irq_ht_hash(unative_t *key);
102
static size_t irq_ht_hash(unative_t *key);
103
static bool irq_ht_compare(unative_t *key, count_t keys, link_t *item);
103
static bool irq_ht_compare(unative_t *key, size_t keys, link_t *item);
104
static void irq_ht_remove(link_t *item);
104
static void irq_ht_remove(link_t *item);
105
 
105
 
106
static hash_table_operations_t irq_ht_ops = {
106
static hash_table_operations_t irq_ht_ops = {
107
    .hash = irq_ht_hash,
107
    .hash = irq_ht_hash,
108
    .compare = irq_ht_compare,
108
    .compare = irq_ht_compare,
109
    .remove_callback = irq_ht_remove,
109
    .remove_callback = irq_ht_remove,
110
};
110
};
111
 
111
 
112
/**
112
/**
113
 * Hash table operations for cases when we know that
113
 * Hash table operations for cases when we know that
114
 * there will be no collisions between different keys.
114
 * there will be no collisions between different keys.
115
 * However, there might be still collisions among
115
 * However, there might be still collisions among
116
 * elements with single key (sharing of one IRQ).
116
 * elements with single key (sharing of one IRQ).
117
 */
117
 */
118
static index_t irq_lin_hash(unative_t *key);
118
static size_t irq_lin_hash(unative_t *key);
119
static bool irq_lin_compare(unative_t *key, count_t keys, link_t *item);
119
static bool irq_lin_compare(unative_t *key, size_t keys, link_t *item);
120
static void irq_lin_remove(link_t *item);
120
static void irq_lin_remove(link_t *item);
121
 
121
 
122
static hash_table_operations_t irq_lin_ops = {
122
static hash_table_operations_t irq_lin_ops = {
123
    .hash = irq_lin_hash,
123
    .hash = irq_lin_hash,
124
    .compare = irq_lin_compare,
124
    .compare = irq_lin_compare,
125
    .remove_callback = irq_lin_remove,
125
    .remove_callback = irq_lin_remove,
126
};
126
};
127
 
127
 
128
/** Number of buckets in either of the hash tables. */
128
/** Number of buckets in either of the hash tables. */
129
static count_t buckets;
129
static size_t buckets;
130
 
130
 
131
/** Initialize IRQ subsystem.
131
/** Initialize IRQ subsystem.
132
 *
132
 *
133
 * @param inrs Numbers of unique IRQ numbers or INRs.
133
 * @param inrs Numbers of unique IRQ numbers or INRs.
134
 * @param chains Number of chains in the hash table.
134
 * @param chains Number of chains in the hash table.
135
 */
135
 */
136
void irq_init(count_t inrs, count_t chains)
136
void irq_init(size_t inrs, size_t chains)
137
{
137
{
138
    buckets = chains;
138
    buckets = chains;
139
    /*
139
    /*
140
     * Be smart about the choice of the hash table operations.
140
     * Be smart about the choice of the hash table operations.
141
     * In cases in which inrs equals the requested number of
141
     * In cases in which inrs equals the requested number of
142
     * chains (i.e. where there is no collision between
142
     * chains (i.e. where there is no collision between
143
     * different keys), we can use optimized set of operations.
143
     * different keys), we can use optimized set of operations.
144
     */
144
     */
145
    if (inrs == chains) {
145
    if (inrs == chains) {
146
        hash_table_create(&irq_uspace_hash_table, chains, 2,
146
        hash_table_create(&irq_uspace_hash_table, chains, 2,
147
            &irq_lin_ops);
147
            &irq_lin_ops);
148
        hash_table_create(&irq_kernel_hash_table, chains, 2,
148
        hash_table_create(&irq_kernel_hash_table, chains, 2,
149
            &irq_lin_ops);
149
            &irq_lin_ops);
150
    } else {
150
    } else {
151
        hash_table_create(&irq_uspace_hash_table, chains, 2,
151
        hash_table_create(&irq_uspace_hash_table, chains, 2,
152
            &irq_ht_ops);
152
            &irq_ht_ops);
153
        hash_table_create(&irq_kernel_hash_table, chains, 2,
153
        hash_table_create(&irq_kernel_hash_table, chains, 2,
154
            &irq_ht_ops);
154
            &irq_ht_ops);
155
    }
155
    }
156
}
156
}
157
 
157
 
158
/** Initialize one IRQ structure.
158
/** Initialize one IRQ structure.
159
 *
159
 *
160
 * @param irq Pointer to the IRQ structure to be initialized.
160
 * @param irq Pointer to the IRQ structure to be initialized.
161
 *
161
 *
162
 */
162
 */
163
void irq_initialize(irq_t *irq)
163
void irq_initialize(irq_t *irq)
164
{
164
{
165
    memsetb(irq, sizeof(irq_t), 0);
165
    memsetb(irq, sizeof(irq_t), 0);
166
    link_initialize(&irq->link);
166
    link_initialize(&irq->link);
167
    spinlock_initialize(&irq->lock, "irq.lock");
167
    spinlock_initialize(&irq->lock, "irq.lock");
168
    link_initialize(&irq->notif_cfg.link);
168
    link_initialize(&irq->notif_cfg.link);
169
    irq->inr = -1;
169
    irq->inr = -1;
170
    irq->devno = -1;
170
    irq->devno = -1;
171
}
171
}
172
 
172
 
173
/** Register IRQ for device.
173
/** Register IRQ for device.
174
 *
174
 *
175
 * The irq structure must be filled with information
175
 * The irq structure must be filled with information
176
 * about the interrupt source and with the claim()
176
 * about the interrupt source and with the claim()
177
 * function pointer and handler() function pointer.
177
 * function pointer and handler() function pointer.
178
 *
178
 *
179
 * @param irq       IRQ structure belonging to a device.
179
 * @param irq       IRQ structure belonging to a device.
180
 * @return      True on success, false on failure.
180
 * @return      True on success, false on failure.
181
 */
181
 */
182
void irq_register(irq_t *irq)
182
void irq_register(irq_t *irq)
183
{
183
{
184
    ipl_t ipl;
184
    ipl_t ipl;
185
    unative_t key[] = {
185
    unative_t key[] = {
186
        (unative_t) irq->inr,
186
        (unative_t) irq->inr,
187
        (unative_t) irq->devno
187
        (unative_t) irq->devno
188
    };
188
    };
189
   
189
   
190
    ipl = interrupts_disable();
190
    ipl = interrupts_disable();
191
    spinlock_lock(&irq_kernel_hash_table_lock);
191
    spinlock_lock(&irq_kernel_hash_table_lock);
192
    spinlock_lock(&irq->lock);
192
    spinlock_lock(&irq->lock);
193
    hash_table_insert(&irq_kernel_hash_table, key, &irq->link);
193
    hash_table_insert(&irq_kernel_hash_table, key, &irq->link);
194
    spinlock_unlock(&irq->lock);   
194
    spinlock_unlock(&irq->lock);   
195
    spinlock_unlock(&irq_kernel_hash_table_lock);
195
    spinlock_unlock(&irq_kernel_hash_table_lock);
196
    interrupts_restore(ipl);
196
    interrupts_restore(ipl);
197
}
197
}
198
 
198
 
199
/** Search and lock the uspace IRQ hash table.
199
/** Search and lock the uspace IRQ hash table.
200
 *
200
 *
201
 */
201
 */
202
static irq_t *irq_dispatch_and_lock_uspace(inr_t inr)
202
static irq_t *irq_dispatch_and_lock_uspace(inr_t inr)
203
{
203
{
204
    link_t *lnk;
204
    link_t *lnk;
205
    unative_t key[] = {
205
    unative_t key[] = {
206
        (unative_t) inr,
206
        (unative_t) inr,
207
        (unative_t) -1    /* search will use claim() instead of devno */
207
        (unative_t) -1    /* search will use claim() instead of devno */
208
    };
208
    };
209
   
209
   
210
    spinlock_lock(&irq_uspace_hash_table_lock);
210
    spinlock_lock(&irq_uspace_hash_table_lock);
211
    lnk = hash_table_find(&irq_uspace_hash_table, key);
211
    lnk = hash_table_find(&irq_uspace_hash_table, key);
212
    if (lnk) {
212
    if (lnk) {
213
        irq_t *irq;
213
        irq_t *irq;
214
       
214
       
215
        irq = hash_table_get_instance(lnk, irq_t, link);
215
        irq = hash_table_get_instance(lnk, irq_t, link);
216
        spinlock_unlock(&irq_uspace_hash_table_lock);
216
        spinlock_unlock(&irq_uspace_hash_table_lock);
217
        return irq;
217
        return irq;
218
    }
218
    }
219
    spinlock_unlock(&irq_uspace_hash_table_lock);
219
    spinlock_unlock(&irq_uspace_hash_table_lock);
220
   
220
   
221
    return NULL;
221
    return NULL;
222
}
222
}
223
 
223
 
224
/** Search and lock the kernel IRQ hash table.
224
/** Search and lock the kernel IRQ hash table.
225
 *
225
 *
226
 */
226
 */
227
static irq_t *irq_dispatch_and_lock_kernel(inr_t inr)
227
static irq_t *irq_dispatch_and_lock_kernel(inr_t inr)
228
{
228
{
229
    link_t *lnk;
229
    link_t *lnk;
230
    unative_t key[] = {
230
    unative_t key[] = {
231
        (unative_t) inr,
231
        (unative_t) inr,
232
        (unative_t) -1    /* search will use claim() instead of devno */
232
        (unative_t) -1    /* search will use claim() instead of devno */
233
    };
233
    };
234
   
234
   
235
    spinlock_lock(&irq_kernel_hash_table_lock);
235
    spinlock_lock(&irq_kernel_hash_table_lock);
236
    lnk = hash_table_find(&irq_kernel_hash_table, key);
236
    lnk = hash_table_find(&irq_kernel_hash_table, key);
237
    if (lnk) {
237
    if (lnk) {
238
        irq_t *irq;
238
        irq_t *irq;
239
       
239
       
240
        irq = hash_table_get_instance(lnk, irq_t, link);
240
        irq = hash_table_get_instance(lnk, irq_t, link);
241
        spinlock_unlock(&irq_kernel_hash_table_lock);
241
        spinlock_unlock(&irq_kernel_hash_table_lock);
242
        return irq;
242
        return irq;
243
    }
243
    }
244
    spinlock_unlock(&irq_kernel_hash_table_lock);
244
    spinlock_unlock(&irq_kernel_hash_table_lock);
245
   
245
   
246
    return NULL;
246
    return NULL;
247
}
247
}
248
 
248
 
249
/** Dispatch the IRQ.
249
/** Dispatch the IRQ.
250
 *
250
 *
251
 * We assume this function is only called from interrupt
251
 * We assume this function is only called from interrupt
252
 * context (i.e. that interrupts are disabled prior to
252
 * context (i.e. that interrupts are disabled prior to
253
 * this call).
253
 * this call).
254
 *
254
 *
255
 * This function attempts to lookup a fitting IRQ
255
 * This function attempts to lookup a fitting IRQ
256
 * structure. In case of success, return with interrupts
256
 * structure. In case of success, return with interrupts
257
 * disabled and holding the respective structure.
257
 * disabled and holding the respective structure.
258
 *
258
 *
259
 * @param inr Interrupt number (aka inr or irq).
259
 * @param inr Interrupt number (aka inr or irq).
260
 *
260
 *
261
 * @return IRQ structure of the respective device or NULL.
261
 * @return IRQ structure of the respective device or NULL.
262
 */
262
 */
263
irq_t *irq_dispatch_and_lock(inr_t inr)
263
irq_t *irq_dispatch_and_lock(inr_t inr)
264
{
264
{
265
    irq_t *irq;
265
    irq_t *irq;
266
   
266
   
267
    /*
267
    /*
268
     * If the kernel console is silenced,
268
     * If the kernel console is silenced,
269
     * then try first the uspace handlers,
269
     * then try first the uspace handlers,
270
     * eventually fall back to kernel handlers.
270
     * eventually fall back to kernel handlers.
271
     *
271
     *
272
     * If the kernel console is active,
272
     * If the kernel console is active,
273
     * then do it the other way around.
273
     * then do it the other way around.
274
     */
274
     */
275
    if (silent) {
275
    if (silent) {
276
        irq = irq_dispatch_and_lock_uspace(inr);
276
        irq = irq_dispatch_and_lock_uspace(inr);
277
        if (irq)
277
        if (irq)
278
            return irq;
278
            return irq;
279
        return irq_dispatch_and_lock_kernel(inr);
279
        return irq_dispatch_and_lock_kernel(inr);
280
    }
280
    }
281
   
281
   
282
    irq = irq_dispatch_and_lock_kernel(inr);
282
    irq = irq_dispatch_and_lock_kernel(inr);
283
    if (irq)
283
    if (irq)
284
        return irq;
284
        return irq;
285
    return irq_dispatch_and_lock_uspace(inr);
285
    return irq_dispatch_and_lock_uspace(inr);
286
}
286
}
287
 
287
 
288
/** Compute hash index for the key.
288
/** Compute hash index for the key.
289
 *
289
 *
290
 * This function computes hash index into
290
 * This function computes hash index into
291
 * the IRQ hash table for which there
291
 * the IRQ hash table for which there
292
 * can be collisions between different
292
 * can be collisions between different
293
 * INRs.
293
 * INRs.
294
 *
294
 *
295
 * The devno is not used to compute the hash.
295
 * The devno is not used to compute the hash.
296
 *
296
 *
297
 * @param key The first of the keys is inr and the second is devno or -1.
297
 * @param key The first of the keys is inr and the second is devno or -1.
298
 *
298
 *
299
 * @return Index into the hash table.
299
 * @return Index into the hash table.
300
 */
300
 */
301
index_t irq_ht_hash(unative_t key[])
301
size_t irq_ht_hash(unative_t key[])
302
{
302
{
303
    inr_t inr = (inr_t) key[KEY_INR];
303
    inr_t inr = (inr_t) key[KEY_INR];
304
    return inr % buckets;
304
    return inr % buckets;
305
}
305
}
306
 
306
 
307
/** Compare hash table element with a key.
307
/** Compare hash table element with a key.
308
 *
308
 *
309
 * There are two things to note about this function.
309
 * There are two things to note about this function.
310
 * First, it is used for the more complex architecture setup
310
 * First, it is used for the more complex architecture setup
311
 * in which there are way too many interrupt numbers (i.e. inr's)
311
 * in which there are way too many interrupt numbers (i.e. inr's)
312
 * to arrange the hash table so that collisions occur only
312
 * to arrange the hash table so that collisions occur only
313
 * among same inrs of different devnos. So the explicit check
313
 * among same inrs of different devnos. So the explicit check
314
 * for inr match must be done.
314
 * for inr match must be done.
315
 * Second, if devno is -1, the second key (i.e. devno) is not
315
 * Second, if devno is -1, the second key (i.e. devno) is not
316
 * used for the match and the result of the claim() function
316
 * used for the match and the result of the claim() function
317
 * is used instead.
317
 * is used instead.
318
 *
318
 *
319
 * This function assumes interrupts are already disabled.
319
 * This function assumes interrupts are already disabled.
320
 *
320
 *
321
 * @param key Keys (i.e. inr and devno).
321
 * @param key Keys (i.e. inr and devno).
322
 * @param keys This is 2.
322
 * @param keys This is 2.
323
 * @param item The item to compare the key with.
323
 * @param item The item to compare the key with.
324
 *
324
 *
325
 * @return True on match or false otherwise.
325
 * @return True on match or false otherwise.
326
 */
326
 */
327
bool irq_ht_compare(unative_t key[], count_t keys, link_t *item)
327
bool irq_ht_compare(unative_t key[], size_t keys, link_t *item)
328
{
328
{
329
    irq_t *irq = hash_table_get_instance(item, irq_t, link);
329
    irq_t *irq = hash_table_get_instance(item, irq_t, link);
330
    inr_t inr = (inr_t) key[KEY_INR];
330
    inr_t inr = (inr_t) key[KEY_INR];
331
    devno_t devno = (devno_t) key[KEY_DEVNO];
331
    devno_t devno = (devno_t) key[KEY_DEVNO];
332
 
332
 
333
    bool rv;
333
    bool rv;
334
   
334
   
335
    spinlock_lock(&irq->lock);
335
    spinlock_lock(&irq->lock);
336
    if (devno == -1) {
336
    if (devno == -1) {
337
        /* Invoked by irq_dispatch_and_lock(). */
337
        /* Invoked by irq_dispatch_and_lock(). */
338
        rv = ((irq->inr == inr) &&
338
        rv = ((irq->inr == inr) &&
339
            (irq->claim(irq) == IRQ_ACCEPT));
339
            (irq->claim(irq) == IRQ_ACCEPT));
340
    } else {
340
    } else {
341
        /* Invoked by irq_find_and_lock(). */
341
        /* Invoked by irq_find_and_lock(). */
342
        rv = ((irq->inr == inr) && (irq->devno == devno));
342
        rv = ((irq->inr == inr) && (irq->devno == devno));
343
    }
343
    }
344
   
344
   
345
    /* unlock only on non-match */
345
    /* unlock only on non-match */
346
    if (!rv)
346
    if (!rv)
347
        spinlock_unlock(&irq->lock);
347
        spinlock_unlock(&irq->lock);
348
 
348
 
349
    return rv;
349
    return rv;
350
}
350
}
351
 
351
 
352
/** Unlock IRQ structure after hash_table_remove().
352
/** Unlock IRQ structure after hash_table_remove().
353
 *
353
 *
354
 * @param lnk Link in the removed and locked IRQ structure.
354
 * @param lnk Link in the removed and locked IRQ structure.
355
 */
355
 */
356
void irq_ht_remove(link_t *lnk)
356
void irq_ht_remove(link_t *lnk)
357
{
357
{
358
    irq_t *irq __attribute__((unused))
358
    irq_t *irq __attribute__((unused))
359
        = hash_table_get_instance(lnk, irq_t, link);
359
        = hash_table_get_instance(lnk, irq_t, link);
360
    spinlock_unlock(&irq->lock);
360
    spinlock_unlock(&irq->lock);
361
}
361
}
362
 
362
 
363
/** Compute hash index for the key.
363
/** Compute hash index for the key.
364
 *
364
 *
365
 * This function computes hash index into
365
 * This function computes hash index into
366
 * the IRQ hash table for which there
366
 * the IRQ hash table for which there
367
 * are no collisions between different
367
 * are no collisions between different
368
 * INRs.
368
 * INRs.
369
 *
369
 *
370
 * @param key The first of the keys is inr and the second is devno or -1.
370
 * @param key The first of the keys is inr and the second is devno or -1.
371
 *
371
 *
372
 * @return Index into the hash table.
372
 * @return Index into the hash table.
373
 */
373
 */
374
index_t irq_lin_hash(unative_t key[])
374
size_t irq_lin_hash(unative_t key[])
375
{
375
{
376
    inr_t inr = (inr_t) key[KEY_INR];
376
    inr_t inr = (inr_t) key[KEY_INR];
377
    return inr;
377
    return inr;
378
}
378
}
379
 
379
 
380
/** Compare hash table element with a key.
380
/** Compare hash table element with a key.
381
 *
381
 *
382
 * There are two things to note about this function.
382
 * There are two things to note about this function.
383
 * First, it is used for the less complex architecture setup
383
 * First, it is used for the less complex architecture setup
384
 * in which there are not too many interrupt numbers (i.e. inr's)
384
 * in which there are not too many interrupt numbers (i.e. inr's)
385
 * to arrange the hash table so that collisions occur only
385
 * to arrange the hash table so that collisions occur only
386
 * among same inrs of different devnos. So the explicit check
386
 * among same inrs of different devnos. So the explicit check
387
 * for inr match is not done.
387
 * for inr match is not done.
388
 * Second, if devno is -1, the second key (i.e. devno) is not
388
 * Second, if devno is -1, the second key (i.e. devno) is not
389
 * used for the match and the result of the claim() function
389
 * used for the match and the result of the claim() function
390
 * is used instead.
390
 * is used instead.
391
 *
391
 *
392
 * This function assumes interrupts are already disabled.
392
 * This function assumes interrupts are already disabled.
393
 *
393
 *
394
 * @param key Keys (i.e. inr and devno).
394
 * @param key Keys (i.e. inr and devno).
395
 * @param keys This is 2.
395
 * @param keys This is 2.
396
 * @param item The item to compare the key with.
396
 * @param item The item to compare the key with.
397
 *
397
 *
398
 * @return True on match or false otherwise.
398
 * @return True on match or false otherwise.
399
 */
399
 */
400
bool irq_lin_compare(unative_t key[], count_t keys, link_t *item)
400
bool irq_lin_compare(unative_t key[], size_t keys, link_t *item)
401
{
401
{
402
    irq_t *irq = list_get_instance(item, irq_t, link);
402
    irq_t *irq = list_get_instance(item, irq_t, link);
403
    devno_t devno = (devno_t) key[KEY_DEVNO];
403
    devno_t devno = (devno_t) key[KEY_DEVNO];
404
    bool rv;
404
    bool rv;
405
   
405
   
406
    spinlock_lock(&irq->lock);
406
    spinlock_lock(&irq->lock);
407
    if (devno == -1) {
407
    if (devno == -1) {
408
        /* Invoked by irq_dispatch_and_lock() */
408
        /* Invoked by irq_dispatch_and_lock() */
409
        rv = (irq->claim(irq) == IRQ_ACCEPT);
409
        rv = (irq->claim(irq) == IRQ_ACCEPT);
410
    } else {
410
    } else {
411
        /* Invoked by irq_find_and_lock() */
411
        /* Invoked by irq_find_and_lock() */
412
        rv = (irq->devno == devno);
412
        rv = (irq->devno == devno);
413
    }
413
    }
414
   
414
   
415
    /* unlock only on non-match */
415
    /* unlock only on non-match */
416
    if (!rv)
416
    if (!rv)
417
        spinlock_unlock(&irq->lock);
417
        spinlock_unlock(&irq->lock);
418
   
418
   
419
    return rv;
419
    return rv;
420
}
420
}
421
 
421
 
422
/** Unlock IRQ structure after hash_table_remove().
422
/** Unlock IRQ structure after hash_table_remove().
423
 *
423
 *
424
 * @param lnk       Link in the removed and locked IRQ structure.
424
 * @param lnk       Link in the removed and locked IRQ structure.
425
 */
425
 */
426
void irq_lin_remove(link_t *lnk)
426
void irq_lin_remove(link_t *lnk)
427
{
427
{
428
    irq_t *irq __attribute__((unused))
428
    irq_t *irq __attribute__((unused))
429
        = hash_table_get_instance(lnk, irq_t, link);
429
        = hash_table_get_instance(lnk, irq_t, link);
430
    spinlock_unlock(&irq->lock);
430
    spinlock_unlock(&irq->lock);
431
}
431
}
432
 
432
 
433
/** @}
433
/** @}
434
 */
434
 */
435
 
435