Subversion Repositories HelenOS

Rev

Rev 3902 | Rev 3947 | Go to most recent revision | Details | Compare with Previous | Last modification | View Log | RSS feed

Rev Author Line No. Line
1281 palkovsky 1
/*
2071 jermar 2
 * Copyright (c) 2006 Ondrej Palkovsky
3
 * Copyright (c) 2006 Jakub Jermar
1281 palkovsky 4
 * All rights reserved.
5
 *
6
 * Redistribution and use in source and binary forms, with or without
7
 * modification, are permitted provided that the following conditions
8
 * are met:
9
 *
10
 * - Redistributions of source code must retain the above copyright
11
 *   notice, this list of conditions and the following disclaimer.
12
 * - Redistributions in binary form must reproduce the above copyright
13
 *   notice, this list of conditions and the following disclaimer in the
14
 *   documentation and/or other materials provided with the distribution.
15
 * - The name of the author may not be used to endorse or promote products
16
 *   derived from this software without specific prior written permission.
17
 *
18
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
19
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
20
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
21
 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
22
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
23
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
24
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
25
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
26
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
27
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
28
 */
29
 
1757 jermar 30
/** @addtogroup genericipc
1702 cejka 31
 * @{
32
 */
1757 jermar 33
/**
34
 * @file
35
 * @brief IRQ notification framework.
1284 palkovsky 36
 *
37
 * This framework allows applications to register to receive a notification
38
 * when interrupt is detected. The application may provide a simple 'top-half'
39
 * handler as part of its registration, which can perform simple operations
40
 * (read/write port/memory, add information to notification ipc message).
41
 *
42
 * The structure of a notification message is as follows:
1923 jermar 43
 * - METHOD: method as registered by the SYS_IPC_REGISTER_IRQ syscall
1693 palkovsky 44
 * - ARG1: payload modified by a 'top-half' handler
1923 jermar 45
 * - ARG2: payload modified by a 'top-half' handler
46
 * - ARG3: payload modified by a 'top-half' handler
1693 palkovsky 47
 * - in_phone_hash: interrupt counter (may be needed to assure correct order
1284 palkovsky 48
 *         in multithreaded drivers)
49
 */
50
 
1281 palkovsky 51
#include <arch.h>
52
#include <mm/slab.h>
53
#include <errno.h>
1923 jermar 54
#include <ddi/irq.h>
1281 palkovsky 55
#include <ipc/ipc.h>
56
#include <ipc/irq.h>
1288 jermar 57
#include <syscall/copy.h>
1507 vana 58
#include <console/console.h>
1875 jermar 59
#include <print.h>
1281 palkovsky 60
 
1923 jermar 61
/** Execute code associated with IRQ notification.
62
 *
2471 jermar 63
 * @param call      Notification call.
64
 * @param code      Top-half pseudocode.
1923 jermar 65
 */
1281 palkovsky 66
static void code_execute(call_t *call, irq_code_t *code)
67
{
2745 decky 68
    unsigned int i;
1780 jermar 69
    unative_t dstval = 0;
1628 decky 70
 
1281 palkovsky 71
    if (!code)
72
        return;
73
 
2471 jermar 74
    for (i = 0; i < code->cmdcount; i++) {
1281 palkovsky 75
        switch (code->cmds[i].cmd) {
76
        case CMD_MEM_READ_1:
2471 jermar 77
            dstval = *((uint8_t *) code->cmds[i].addr);
1281 palkovsky 78
            break;
79
        case CMD_MEM_READ_2:
2471 jermar 80
            dstval = *((uint16_t *) code->cmds[i].addr);
1281 palkovsky 81
            break;
82
        case CMD_MEM_READ_4:
2471 jermar 83
            dstval = *((uint32_t *) code->cmds[i].addr);
1281 palkovsky 84
            break;
85
        case CMD_MEM_READ_8:
2471 jermar 86
            dstval = *((uint64_t *) code->cmds[i].addr);
1281 palkovsky 87
            break;
88
        case CMD_MEM_WRITE_1:
2471 jermar 89
            *((uint8_t *) code->cmds[i].addr) = code->cmds[i].value;
1281 palkovsky 90
            break;
91
        case CMD_MEM_WRITE_2:
2626 jermar 92
            *((uint16_t *) code->cmds[i].addr) =
93
                code->cmds[i].value;
1281 palkovsky 94
            break;
95
        case CMD_MEM_WRITE_4:
2626 jermar 96
            *((uint32_t *) code->cmds[i].addr) =
97
                code->cmds[i].value;
1281 palkovsky 98
            break;
99
        case CMD_MEM_WRITE_8:
2626 jermar 100
            *((uint64_t *) code->cmds[i].addr) =
101
                code->cmds[i].value;
1281 palkovsky 102
            break;
1284 palkovsky 103
        case CMD_PORT_READ_1:
3930 jermar 104
            dstval = pio_read_8((ioport8_t *) code->cmds[i].addr);
1284 palkovsky 105
            break;
106
        case CMD_PORT_WRITE_1:
3930 jermar 107
            pio_write_8((ioport8_t *) code->cmds[i].addr, code->cmds[i].value);
1284 palkovsky 108
            break;
1281 palkovsky 109
        default:
110
            break;
111
        }
2626 jermar 112
        if (code->cmds[i].dstarg && code->cmds[i].dstarg <
113
            IPC_CALL_LEN) {
1693 palkovsky 114
            call->data.args[code->cmds[i].dstarg] = dstval;
115
        }
1281 palkovsky 116
    }
117
}
118
 
2471 jermar 119
/** Free top-half pseudocode.
120
 *
121
 * @param code      Pointer to the top-half pseudocode.
122
 */
1281 palkovsky 123
static void code_free(irq_code_t *code)
124
{
125
    if (code) {
126
        free(code->cmds);
127
        free(code);
128
    }
129
}
130
 
2471 jermar 131
/** Copy top-half pseudocode from userspace into the kernel.
132
 *
133
 * @param ucode     Userspace address of the top-half pseudocode.
134
 *
135
 * @return      Kernel address of the copied pseudocode.
136
 */
137
static irq_code_t *code_from_uspace(irq_code_t *ucode)
1281 palkovsky 138
{
139
    irq_code_t *code;
140
    irq_cmd_t *ucmds;
1288 jermar 141
    int rc;
1281 palkovsky 142
 
143
    code = malloc(sizeof(*code), 0);
1288 jermar 144
    rc = copy_from_uspace(code, ucode, sizeof(*code));
145
    if (rc != 0) {
146
        free(code);
147
        return NULL;
148
    }
1281 palkovsky 149
 
150
    if (code->cmdcount > IRQ_MAX_PROG_SIZE) {
151
        free(code);
152
        return NULL;
153
    }
154
    ucmds = code->cmds;
2471 jermar 155
    code->cmds = malloc(sizeof(code->cmds[0]) * code->cmdcount, 0);
156
    rc = copy_from_uspace(code->cmds, ucmds,
157
        sizeof(code->cmds[0]) * code->cmdcount);
1288 jermar 158
    if (rc != 0) {
159
        free(code->cmds);
160
        free(code);
161
        return NULL;
162
    }
1281 palkovsky 163
 
164
    return code;
165
}
166
 
1923 jermar 167
/** Unregister task from IRQ notification.
168
 *
2471 jermar 169
 * @param box       Answerbox associated with the notification.
170
 * @param inr       IRQ number.
171
 * @param devno     Device number.
1923 jermar 172
 */
173
void ipc_irq_unregister(answerbox_t *box, inr_t inr, devno_t devno)
1281 palkovsky 174
{
175
    ipl_t ipl;
1923 jermar 176
    irq_t *irq;
1281 palkovsky 177
 
178
    ipl = interrupts_disable();
1923 jermar 179
    irq = irq_find_and_lock(inr, devno);
180
    if (irq) {
181
        if (irq->notif_cfg.answerbox == box) {
1933 jermar 182
            code_free(irq->notif_cfg.code);
1932 jermar 183
            irq->notif_cfg.notify = false;
184
            irq->notif_cfg.answerbox = NULL;
1923 jermar 185
            irq->notif_cfg.code = NULL;
186
            irq->notif_cfg.method = 0;
187
            irq->notif_cfg.counter = 0;
1933 jermar 188
 
189
            spinlock_lock(&box->irq_lock);
190
            list_remove(&irq->notif_cfg.link);
191
            spinlock_unlock(&box->irq_lock);
192
 
1923 jermar 193
            spinlock_unlock(&irq->lock);
194
        }
1281 palkovsky 195
    }
196
    interrupts_restore(ipl);
197
}
198
 
1923 jermar 199
/** Register an answerbox as a receiving end for IRQ notifications.
200
 *
2471 jermar 201
 * @param box       Receiving answerbox.
202
 * @param inr       IRQ number.
203
 * @param devno     Device number.
204
 * @param method    Method to be associated with the notification.
205
 * @param ucode     Uspace pointer to top-half pseudocode.
1923 jermar 206
 *
2471 jermar 207
 * @return      EBADMEM, ENOENT or EEXISTS on failure or 0 on success.
1923 jermar 208
 */
2471 jermar 209
int ipc_irq_register(answerbox_t *box, inr_t inr, devno_t devno,
210
    unative_t method, irq_code_t *ucode)
1281 palkovsky 211
{
212
    ipl_t ipl;
213
    irq_code_t *code;
1923 jermar 214
    irq_t *irq;
1281 palkovsky 215
 
216
    if (ucode) {
217
        code = code_from_uspace(ucode);
218
        if (!code)
219
            return EBADMEM;
2471 jermar 220
    } else {
1281 palkovsky 221
        code = NULL;
2471 jermar 222
    }
1281 palkovsky 223
 
224
    ipl = interrupts_disable();
1923 jermar 225
    irq = irq_find_and_lock(inr, devno);
226
    if (!irq) {
1281 palkovsky 227
        interrupts_restore(ipl);
228
        code_free(code);
1923 jermar 229
        return ENOENT;
230
    }
231
 
232
    if (irq->notif_cfg.answerbox) {
233
        spinlock_unlock(&irq->lock);
234
        interrupts_restore(ipl);
235
        code_free(code);
1281 palkovsky 236
        return EEXISTS;
237
    }
1923 jermar 238
 
1932 jermar 239
    irq->notif_cfg.notify = true;
1923 jermar 240
    irq->notif_cfg.answerbox = box;
241
    irq->notif_cfg.method = method;
242
    irq->notif_cfg.code = code;
243
    irq->notif_cfg.counter = 0;
1933 jermar 244
 
245
    spinlock_lock(&box->irq_lock);
246
    list_append(&irq->notif_cfg.link, &box->irq_head);
247
    spinlock_unlock(&box->irq_lock);
248
 
1923 jermar 249
    spinlock_unlock(&irq->lock);
1281 palkovsky 250
    interrupts_restore(ipl);
251
 
252
    return 0;
253
}
254
 
2471 jermar 255
/** Add a call to the proper answerbox queue.
1595 palkovsky 256
 *
1923 jermar 257
 * Assume irq->lock is locked.
258
 *
2471 jermar 259
 * @param irq       IRQ structure referencing the target answerbox.
260
 * @param call      IRQ notification call.
1923 jermar 261
 */
262
static void send_call(irq_t *irq, call_t *call)
1595 palkovsky 263
{
1923 jermar 264
    spinlock_lock(&irq->notif_cfg.answerbox->irq_lock);
265
    list_append(&call->link, &irq->notif_cfg.answerbox->irq_notifs);
266
    spinlock_unlock(&irq->notif_cfg.answerbox->irq_lock);
1595 palkovsky 267
 
1923 jermar 268
    waitq_wakeup(&irq->notif_cfg.answerbox->wq, WAKEUP_FIRST);
1595 palkovsky 269
}
270
 
2471 jermar 271
/** Send notification message.
1595 palkovsky 272
 *
2471 jermar 273
 * @param irq       IRQ structure.
274
 * @param a1        Driver-specific payload argument.
275
 * @param a2        Driver-specific payload argument.
276
 * @param a3        Driver-specific payload argument.
2626 jermar 277
 * @param a4        Driver-specific payload argument.
278
 * @param a5        Driver-specific payload argument.
1595 palkovsky 279
 */
2626 jermar 280
void ipc_irq_send_msg(irq_t *irq, unative_t a1, unative_t a2, unative_t a3,
281
    unative_t a4, unative_t a5)
1595 palkovsky 282
{
283
    call_t *call;
284
 
1923 jermar 285
    spinlock_lock(&irq->lock);
1595 palkovsky 286
 
1923 jermar 287
    if (irq->notif_cfg.answerbox) {
1595 palkovsky 288
        call = ipc_call_alloc(FRAME_ATOMIC);
289
        if (!call) {
1923 jermar 290
            spinlock_unlock(&irq->lock);
1595 palkovsky 291
            return;
292
        }
293
        call->flags |= IPC_CALL_NOTIF;
1923 jermar 294
        IPC_SET_METHOD(call->data, irq->notif_cfg.method);
1693 palkovsky 295
        IPC_SET_ARG1(call->data, a1);
1595 palkovsky 296
        IPC_SET_ARG2(call->data, a2);
297
        IPC_SET_ARG3(call->data, a3);
2626 jermar 298
        IPC_SET_ARG4(call->data, a4);
299
        IPC_SET_ARG5(call->data, a5);
1693 palkovsky 300
        /* Put a counter to the message */
2098 decky 301
        call->priv = ++irq->notif_cfg.counter;
1595 palkovsky 302
 
1923 jermar 303
        send_call(irq, call);
1595 palkovsky 304
    }
1923 jermar 305
    spinlock_unlock(&irq->lock);
1595 palkovsky 306
}
307
 
2471 jermar 308
/** Notify a task that an IRQ had occurred.
1281 palkovsky 309
 *
1923 jermar 310
 * We expect interrupts to be disabled and the irq->lock already held.
2471 jermar 311
 *
312
 * @param irq       IRQ structure.
1281 palkovsky 313
 */
1923 jermar 314
void ipc_irq_send_notif(irq_t *irq)
1281 palkovsky 315
{
316
    call_t *call;
317
 
1923 jermar 318
    ASSERT(irq);
1281 palkovsky 319
 
1923 jermar 320
    if (irq->notif_cfg.answerbox) {
1281 palkovsky 321
        call = ipc_call_alloc(FRAME_ATOMIC);
1591 palkovsky 322
        if (!call) {
323
            return;
324
        }
1281 palkovsky 325
        call->flags |= IPC_CALL_NOTIF;
1693 palkovsky 326
        /* Put a counter to the message */
2098 decky 327
        call->priv = ++irq->notif_cfg.counter;
1693 palkovsky 328
        /* Set up args */
1923 jermar 329
        IPC_SET_METHOD(call->data, irq->notif_cfg.method);
1281 palkovsky 330
 
331
        /* Execute code to handle irq */
1923 jermar 332
        code_execute(call, irq->notif_cfg.code);
1595 palkovsky 333
 
1923 jermar 334
        send_call(irq, call);
1281 palkovsky 335
    }
336
}
337
 
1923 jermar 338
/** Disconnect all IRQ notifications from an answerbox.
1595 palkovsky 339
 *
1933 jermar 340
 * This function is effective because the answerbox contains
341
 * list of all irq_t structures that are registered to
342
 * send notifications to it.
343
 *
2471 jermar 344
 * @param box       Answerbox for which we want to carry out the cleanup.
1595 palkovsky 345
 */
1281 palkovsky 346
void ipc_irq_cleanup(answerbox_t *box)
347
{
1933 jermar 348
    ipl_t ipl;
349
 
350
loop:
351
    ipl = interrupts_disable();
352
    spinlock_lock(&box->irq_lock);
353
 
354
    while (box->irq_head.next != &box->irq_head) {
355
        link_t *cur = box->irq_head.next;
356
        irq_t *irq;
2183 jermar 357
        DEADLOCK_PROBE_INIT(p_irqlock);
1933 jermar 358
 
359
        irq = list_get_instance(cur, irq_t, notif_cfg.link);
360
        if (!spinlock_trylock(&irq->lock)) {
361
            /*
362
             * Avoid deadlock by trying again.
363
             */
364
            spinlock_unlock(&box->irq_lock);
365
            interrupts_restore(ipl);
2183 jermar 366
            DEADLOCK_PROBE(p_irqlock, DEADLOCK_THRESHOLD);
1933 jermar 367
            goto loop;
368
        }
369
 
370
        ASSERT(irq->notif_cfg.answerbox == box);
371
 
372
        list_remove(&irq->notif_cfg.link);
373
 
374
        /*
375
         * Don't forget to free any top-half pseudocode.
376
         */
377
        code_free(irq->notif_cfg.code);
378
 
379
        irq->notif_cfg.notify = false;
380
        irq->notif_cfg.answerbox = NULL;
381
        irq->notif_cfg.code = NULL;
382
        irq->notif_cfg.method = 0;
383
        irq->notif_cfg.counter = 0;
384
 
385
        spinlock_unlock(&irq->lock);
386
    }
387
 
388
    spinlock_unlock(&box->irq_lock);
389
    interrupts_restore(ipl);
1281 palkovsky 390
}
1702 cejka 391
 
1757 jermar 392
/** @}
1702 cejka 393
 */