source: mainline/kernel/generic/src/ipc/irq.c@ 49319ac

lfn serial ticket/834-toolchain-update topic/msim-upgrade topic/simplify-dev-export
Last change on this file since 49319ac was 49319ac, checked in by Jakub Vana <jakub.vana@…>, 18 years ago

SIMICS added as a simulator kernel runs on
  • Property mode set to 100644
File size: 9.3 KB
Line 
1/*
2 * Copyright (C) 2006 Ondrej Palkovsky
3 * Copyright (C) 2006 Jakub Jermar
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
30/** @addtogroup genericipc
31 * @{
32 */
33/**
34 * @file
35 * @brief IRQ notification framework.
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:
43 * - METHOD: method as registered by the SYS_IPC_REGISTER_IRQ syscall
44 * - ARG1: payload modified by a 'top-half' handler
45 * - ARG2: payload modified by a 'top-half' handler
46 * - ARG3: payload modified by a 'top-half' handler
47 * - in_phone_hash: interrupt counter (may be needed to assure correct order
48 * in multithreaded drivers)
49 */
50
51#include <arch.h>
52#include <mm/slab.h>
53#include <errno.h>
54#include <ddi/irq.h>
55#include <ipc/ipc.h>
56#include <ipc/irq.h>
57#include <syscall/copy.h>
58#include <console/console.h>
59#include <print.h>
60
61/** Execute code associated with IRQ notification.
62 *
63 * @param call Notification call.
64 * @param code Top-half pseudocode.
65 */
66static void code_execute(call_t *call, irq_code_t *code)
67{
68 int i;
69 unative_t dstval = 0;
70
71 if (!code)
72 return;
73
74 for (i=0; i < code->cmdcount;i++) {
75 switch (code->cmds[i].cmd) {
76 case CMD_MEM_READ_1:
77 dstval = *((uint8_t *)code->cmds[i].addr);
78 break;
79 case CMD_MEM_READ_2:
80 dstval = *((uint16_t *)code->cmds[i].addr);
81 break;
82 case CMD_MEM_READ_4:
83 dstval = *((uint32_t *)code->cmds[i].addr);
84 break;
85 case CMD_MEM_READ_8:
86 dstval = *((uint64_t *)code->cmds[i].addr);
87 break;
88 case CMD_MEM_WRITE_1:
89 *((uint8_t *)code->cmds[i].addr) = code->cmds[i].value;
90 break;
91 case CMD_MEM_WRITE_2:
92 *((uint16_t *)code->cmds[i].addr) = code->cmds[i].value;
93 break;
94 case CMD_MEM_WRITE_4:
95 *((uint32_t *)code->cmds[i].addr) = code->cmds[i].value;
96 break;
97 case CMD_MEM_WRITE_8:
98 *((uint64_t *)code->cmds[i].addr) = code->cmds[i].value;
99 break;
100#if defined(ia32) || defined(amd64)
101 case CMD_PORT_READ_1:
102 dstval = inb((long)code->cmds[i].addr);
103 break;
104 case CMD_PORT_WRITE_1:
105 outb((long)code->cmds[i].addr, code->cmds[i].value);
106 break;
107#endif
108#if defined(ia64) && defined(SKI)
109 case CMD_IA64_GETCHAR:
110 dstval = _getc(&ski_uconsole);
111 break;
112#endif
113#if defined(ppc32)
114 case CMD_PPC32_GETCHAR:
115 dstval = cuda_get_scancode();
116 break;
117#endif
118 default:
119 break;
120 }
121 if (code->cmds[i].dstarg && code->cmds[i].dstarg < 4) {
122 call->data.args[code->cmds[i].dstarg] = dstval;
123 }
124 }
125}
126
127static void code_free(irq_code_t *code)
128{
129 if (code) {
130 free(code->cmds);
131 free(code);
132 }
133}
134
135static irq_code_t * code_from_uspace(irq_code_t *ucode)
136{
137 irq_code_t *code;
138 irq_cmd_t *ucmds;
139 int rc;
140
141 code = malloc(sizeof(*code), 0);
142 rc = copy_from_uspace(code, ucode, sizeof(*code));
143 if (rc != 0) {
144 free(code);
145 return NULL;
146 }
147
148 if (code->cmdcount > IRQ_MAX_PROG_SIZE) {
149 free(code);
150 return NULL;
151 }
152 ucmds = code->cmds;
153 code->cmds = malloc(sizeof(code->cmds[0]) * (code->cmdcount), 0);
154 rc = copy_from_uspace(code->cmds, ucmds, sizeof(code->cmds[0]) * (code->cmdcount));
155 if (rc != 0) {
156 free(code->cmds);
157 free(code);
158 return NULL;
159 }
160
161 return code;
162}
163
164/** Unregister task from IRQ notification.
165 *
166 * @param box Answerbox associated with the notification.
167 * @param inr IRQ numbe.
168 * @param devno Device number.
169 */
170void ipc_irq_unregister(answerbox_t *box, inr_t inr, devno_t devno)
171{
172 ipl_t ipl;
173 irq_t *irq;
174
175 ipl = interrupts_disable();
176 irq = irq_find_and_lock(inr, devno);
177 if (irq) {
178 if (irq->notif_cfg.answerbox == box) {
179 code_free(irq->notif_cfg.code);
180 irq->notif_cfg.notify = false;
181 irq->notif_cfg.answerbox = NULL;
182 irq->notif_cfg.code = NULL;
183 irq->notif_cfg.method = 0;
184 irq->notif_cfg.counter = 0;
185
186 spinlock_lock(&box->irq_lock);
187 list_remove(&irq->notif_cfg.link);
188 spinlock_unlock(&box->irq_lock);
189
190 spinlock_unlock(&irq->lock);
191 }
192 }
193 interrupts_restore(ipl);
194}
195
196/** Register an answerbox as a receiving end for IRQ notifications.
197 *
198 * @param box Receiving answerbox.
199 * @param inr IRQ number.
200 * @param devno Device number.
201 * @param method Method to be associated with the notification.
202 * @param ucode Uspace pointer to top-half pseudocode.
203 *
204 * @return EBADMEM, ENOENT or EEXISTS on failure or 0 on success.
205 */
206int ipc_irq_register(answerbox_t *box, inr_t inr, devno_t devno, unative_t method, irq_code_t *ucode)
207{
208 ipl_t ipl;
209 irq_code_t *code;
210 irq_t *irq;
211
212 if (ucode) {
213 code = code_from_uspace(ucode);
214 if (!code)
215 return EBADMEM;
216 } else
217 code = NULL;
218
219 ipl = interrupts_disable();
220 irq = irq_find_and_lock(inr, devno);
221 if (!irq) {
222 interrupts_restore(ipl);
223 code_free(code);
224 return ENOENT;
225 }
226
227 if (irq->notif_cfg.answerbox) {
228 spinlock_unlock(&irq->lock);
229 interrupts_restore(ipl);
230 code_free(code);
231 return EEXISTS;
232 }
233
234 irq->notif_cfg.notify = true;
235 irq->notif_cfg.answerbox = box;
236 irq->notif_cfg.method = method;
237 irq->notif_cfg.code = code;
238 irq->notif_cfg.counter = 0;
239
240 spinlock_lock(&box->irq_lock);
241 list_append(&irq->notif_cfg.link, &box->irq_head);
242 spinlock_unlock(&box->irq_lock);
243
244 spinlock_unlock(&irq->lock);
245 interrupts_restore(ipl);
246
247 return 0;
248}
249
250/** Add call to proper answerbox queue.
251 *
252 * Assume irq->lock is locked.
253 *
254 */
255static void send_call(irq_t *irq, call_t *call)
256{
257 spinlock_lock(&irq->notif_cfg.answerbox->irq_lock);
258 list_append(&call->link, &irq->notif_cfg.answerbox->irq_notifs);
259 spinlock_unlock(&irq->notif_cfg.answerbox->irq_lock);
260
261 waitq_wakeup(&irq->notif_cfg.answerbox->wq, WAKEUP_FIRST);
262}
263
264/** Send notification message
265 *
266 */
267void ipc_irq_send_msg(irq_t *irq, unative_t a1, unative_t a2, unative_t a3)
268{
269 call_t *call;
270
271 spinlock_lock(&irq->lock);
272
273 if (irq->notif_cfg.answerbox) {
274 call = ipc_call_alloc(FRAME_ATOMIC);
275 if (!call) {
276 spinlock_unlock(&irq->lock);
277 return;
278 }
279 call->flags |= IPC_CALL_NOTIF;
280 IPC_SET_METHOD(call->data, irq->notif_cfg.method);
281 IPC_SET_ARG1(call->data, a1);
282 IPC_SET_ARG2(call->data, a2);
283 IPC_SET_ARG3(call->data, a3);
284 /* Put a counter to the message */
285 call->private = ++irq->notif_cfg.counter;
286
287 send_call(irq, call);
288 }
289 spinlock_unlock(&irq->lock);
290}
291
292/** Notify task that an irq had occurred.
293 *
294 * We expect interrupts to be disabled and the irq->lock already held.
295 */
296void ipc_irq_send_notif(irq_t *irq)
297{
298 call_t *call;
299
300 ASSERT(irq);
301
302 if (irq->notif_cfg.answerbox) {
303 call = ipc_call_alloc(FRAME_ATOMIC);
304 if (!call) {
305 return;
306 }
307 call->flags |= IPC_CALL_NOTIF;
308 /* Put a counter to the message */
309 call->private = ++irq->notif_cfg.counter;
310 /* Set up args */
311 IPC_SET_METHOD(call->data, irq->notif_cfg.method);
312
313 /* Execute code to handle irq */
314 code_execute(call, irq->notif_cfg.code);
315
316 send_call(irq, call);
317 }
318}
319
320/** Disconnect all IRQ notifications from an answerbox.
321 *
322 * This function is effective because the answerbox contains
323 * list of all irq_t structures that are registered to
324 * send notifications to it.
325 *
326 * @param box Answerbox for which we want to carry out the cleanup.
327 */
328void ipc_irq_cleanup(answerbox_t *box)
329{
330 ipl_t ipl;
331
332loop:
333 ipl = interrupts_disable();
334 spinlock_lock(&box->irq_lock);
335
336 while (box->irq_head.next != &box->irq_head) {
337 link_t *cur = box->irq_head.next;
338 irq_t *irq;
339
340 irq = list_get_instance(cur, irq_t, notif_cfg.link);
341 if (!spinlock_trylock(&irq->lock)) {
342 /*
343 * Avoid deadlock by trying again.
344 */
345 spinlock_unlock(&box->irq_lock);
346 interrupts_restore(ipl);
347 goto loop;
348 }
349
350 ASSERT(irq->notif_cfg.answerbox == box);
351
352 list_remove(&irq->notif_cfg.link);
353
354 /*
355 * Don't forget to free any top-half pseudocode.
356 */
357 code_free(irq->notif_cfg.code);
358
359 irq->notif_cfg.notify = false;
360 irq->notif_cfg.answerbox = NULL;
361 irq->notif_cfg.code = NULL;
362 irq->notif_cfg.method = 0;
363 irq->notif_cfg.counter = 0;
364
365 spinlock_unlock(&irq->lock);
366 }
367
368 spinlock_unlock(&box->irq_lock);
369 interrupts_restore(ipl);
370}
371
372/** @}
373 */
Note: See TracBrowser for help on using the repository browser.