Rev 2098 | Rev 2471 | 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 | * |
||
63 | * @param call Notification call. |
||
64 | * @param code Top-half pseudocode. |
||
65 | */ |
||
1281 | palkovsky | 66 | static void code_execute(call_t *call, irq_code_t *code) |
67 | { |
||
68 | int i; |
||
1780 | jermar | 69 | unative_t dstval = 0; |
1628 | decky | 70 | |
1281 | palkovsky | 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: |
||
1780 | jermar | 77 | dstval = *((uint8_t *)code->cmds[i].addr); |
1281 | palkovsky | 78 | break; |
79 | case CMD_MEM_READ_2: |
||
1780 | jermar | 80 | dstval = *((uint16_t *)code->cmds[i].addr); |
1281 | palkovsky | 81 | break; |
82 | case CMD_MEM_READ_4: |
||
1780 | jermar | 83 | dstval = *((uint32_t *)code->cmds[i].addr); |
1281 | palkovsky | 84 | break; |
85 | case CMD_MEM_READ_8: |
||
1780 | jermar | 86 | dstval = *((uint64_t *)code->cmds[i].addr); |
1281 | palkovsky | 87 | break; |
88 | case CMD_MEM_WRITE_1: |
||
1780 | jermar | 89 | *((uint8_t *)code->cmds[i].addr) = code->cmds[i].value; |
1281 | palkovsky | 90 | break; |
91 | case CMD_MEM_WRITE_2: |
||
1780 | jermar | 92 | *((uint16_t *)code->cmds[i].addr) = code->cmds[i].value; |
1281 | palkovsky | 93 | break; |
94 | case CMD_MEM_WRITE_4: |
||
1780 | jermar | 95 | *((uint32_t *)code->cmds[i].addr) = code->cmds[i].value; |
1281 | palkovsky | 96 | break; |
97 | case CMD_MEM_WRITE_8: |
||
1780 | jermar | 98 | *((uint64_t *)code->cmds[i].addr) = code->cmds[i].value; |
1281 | palkovsky | 99 | break; |
1284 | palkovsky | 100 | #if defined(ia32) || defined(amd64) |
101 | case CMD_PORT_READ_1: |
||
1693 | palkovsky | 102 | dstval = inb((long)code->cmds[i].addr); |
1284 | palkovsky | 103 | break; |
104 | case CMD_PORT_WRITE_1: |
||
105 | outb((long)code->cmds[i].addr, code->cmds[i].value); |
||
106 | break; |
||
107 | #endif |
||
2064 | vana | 108 | #if defined(ia64) && defined(SKI) |
1507 | vana | 109 | case CMD_IA64_GETCHAR: |
1693 | palkovsky | 110 | dstval = _getc(&ski_uconsole); |
1507 | vana | 111 | break; |
112 | #endif |
||
1628 | decky | 113 | #if defined(ppc32) |
1625 | decky | 114 | case CMD_PPC32_GETCHAR: |
1693 | palkovsky | 115 | dstval = cuda_get_scancode(); |
1625 | decky | 116 | break; |
117 | #endif |
||
1281 | palkovsky | 118 | default: |
119 | break; |
||
120 | } |
||
1693 | palkovsky | 121 | if (code->cmds[i].dstarg && code->cmds[i].dstarg < 4) { |
122 | call->data.args[code->cmds[i].dstarg] = dstval; |
||
123 | } |
||
1281 | palkovsky | 124 | } |
125 | } |
||
126 | |||
127 | static void code_free(irq_code_t *code) |
||
128 | { |
||
129 | if (code) { |
||
130 | free(code->cmds); |
||
131 | free(code); |
||
132 | } |
||
133 | } |
||
134 | |||
135 | static irq_code_t * code_from_uspace(irq_code_t *ucode) |
||
136 | { |
||
137 | irq_code_t *code; |
||
138 | irq_cmd_t *ucmds; |
||
1288 | jermar | 139 | int rc; |
1281 | palkovsky | 140 | |
141 | code = malloc(sizeof(*code), 0); |
||
1288 | jermar | 142 | rc = copy_from_uspace(code, ucode, sizeof(*code)); |
143 | if (rc != 0) { |
||
144 | free(code); |
||
145 | return NULL; |
||
146 | } |
||
1281 | palkovsky | 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); |
||
1288 | jermar | 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 | } |
||
1281 | palkovsky | 160 | |
161 | return code; |
||
162 | } |
||
163 | |||
1923 | jermar | 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 | */ |
||
170 | void ipc_irq_unregister(answerbox_t *box, inr_t inr, devno_t devno) |
||
1281 | palkovsky | 171 | { |
172 | ipl_t ipl; |
||
1923 | jermar | 173 | irq_t *irq; |
1281 | palkovsky | 174 | |
175 | ipl = interrupts_disable(); |
||
1923 | jermar | 176 | irq = irq_find_and_lock(inr, devno); |
177 | if (irq) { |
||
178 | if (irq->notif_cfg.answerbox == box) { |
||
1933 | jermar | 179 | code_free(irq->notif_cfg.code); |
1932 | jermar | 180 | irq->notif_cfg.notify = false; |
181 | irq->notif_cfg.answerbox = NULL; |
||
1923 | jermar | 182 | irq->notif_cfg.code = NULL; |
183 | irq->notif_cfg.method = 0; |
||
184 | irq->notif_cfg.counter = 0; |
||
1933 | jermar | 185 | |
186 | spinlock_lock(&box->irq_lock); |
||
187 | list_remove(&irq->notif_cfg.link); |
||
188 | spinlock_unlock(&box->irq_lock); |
||
189 | |||
1923 | jermar | 190 | spinlock_unlock(&irq->lock); |
191 | } |
||
1281 | palkovsky | 192 | } |
193 | interrupts_restore(ipl); |
||
194 | } |
||
195 | |||
1923 | jermar | 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 | */ |
||
1933 | jermar | 206 | int ipc_irq_register(answerbox_t *box, inr_t inr, devno_t devno, unative_t method, irq_code_t *ucode) |
1281 | palkovsky | 207 | { |
208 | ipl_t ipl; |
||
209 | irq_code_t *code; |
||
1923 | jermar | 210 | irq_t *irq; |
1281 | palkovsky | 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(); |
||
1923 | jermar | 220 | irq = irq_find_and_lock(inr, devno); |
221 | if (!irq) { |
||
1281 | palkovsky | 222 | interrupts_restore(ipl); |
223 | code_free(code); |
||
1923 | jermar | 224 | return ENOENT; |
225 | } |
||
226 | |||
227 | if (irq->notif_cfg.answerbox) { |
||
228 | spinlock_unlock(&irq->lock); |
||
229 | interrupts_restore(ipl); |
||
230 | code_free(code); |
||
1281 | palkovsky | 231 | return EEXISTS; |
232 | } |
||
1923 | jermar | 233 | |
1932 | jermar | 234 | irq->notif_cfg.notify = true; |
1923 | jermar | 235 | irq->notif_cfg.answerbox = box; |
236 | irq->notif_cfg.method = method; |
||
237 | irq->notif_cfg.code = code; |
||
238 | irq->notif_cfg.counter = 0; |
||
1933 | jermar | 239 | |
240 | spinlock_lock(&box->irq_lock); |
||
241 | list_append(&irq->notif_cfg.link, &box->irq_head); |
||
242 | spinlock_unlock(&box->irq_lock); |
||
243 | |||
1923 | jermar | 244 | spinlock_unlock(&irq->lock); |
1281 | palkovsky | 245 | interrupts_restore(ipl); |
246 | |||
247 | return 0; |
||
248 | } |
||
249 | |||
1923 | jermar | 250 | /** Add call to proper answerbox queue. |
1595 | palkovsky | 251 | * |
1923 | jermar | 252 | * Assume irq->lock is locked. |
253 | * |
||
254 | */ |
||
255 | static void send_call(irq_t *irq, call_t *call) |
||
1595 | palkovsky | 256 | { |
1923 | jermar | 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); |
||
1595 | palkovsky | 260 | |
1923 | jermar | 261 | waitq_wakeup(&irq->notif_cfg.answerbox->wq, WAKEUP_FIRST); |
1595 | palkovsky | 262 | } |
263 | |||
264 | /** Send notification message |
||
265 | * |
||
266 | */ |
||
1923 | jermar | 267 | void ipc_irq_send_msg(irq_t *irq, unative_t a1, unative_t a2, unative_t a3) |
1595 | palkovsky | 268 | { |
269 | call_t *call; |
||
270 | |||
1923 | jermar | 271 | spinlock_lock(&irq->lock); |
1595 | palkovsky | 272 | |
1923 | jermar | 273 | if (irq->notif_cfg.answerbox) { |
1595 | palkovsky | 274 | call = ipc_call_alloc(FRAME_ATOMIC); |
275 | if (!call) { |
||
1923 | jermar | 276 | spinlock_unlock(&irq->lock); |
1595 | palkovsky | 277 | return; |
278 | } |
||
279 | call->flags |= IPC_CALL_NOTIF; |
||
1923 | jermar | 280 | IPC_SET_METHOD(call->data, irq->notif_cfg.method); |
1693 | palkovsky | 281 | IPC_SET_ARG1(call->data, a1); |
1595 | palkovsky | 282 | IPC_SET_ARG2(call->data, a2); |
283 | IPC_SET_ARG3(call->data, a3); |
||
1693 | palkovsky | 284 | /* Put a counter to the message */ |
2098 | decky | 285 | call->priv = ++irq->notif_cfg.counter; |
1595 | palkovsky | 286 | |
1923 | jermar | 287 | send_call(irq, call); |
1595 | palkovsky | 288 | } |
1923 | jermar | 289 | spinlock_unlock(&irq->lock); |
1595 | palkovsky | 290 | } |
291 | |||
1698 | jermar | 292 | /** Notify task that an irq had occurred. |
1281 | palkovsky | 293 | * |
1923 | jermar | 294 | * We expect interrupts to be disabled and the irq->lock already held. |
1281 | palkovsky | 295 | */ |
1923 | jermar | 296 | void ipc_irq_send_notif(irq_t *irq) |
1281 | palkovsky | 297 | { |
298 | call_t *call; |
||
299 | |||
1923 | jermar | 300 | ASSERT(irq); |
1281 | palkovsky | 301 | |
1923 | jermar | 302 | if (irq->notif_cfg.answerbox) { |
1281 | palkovsky | 303 | call = ipc_call_alloc(FRAME_ATOMIC); |
1591 | palkovsky | 304 | if (!call) { |
305 | return; |
||
306 | } |
||
1281 | palkovsky | 307 | call->flags |= IPC_CALL_NOTIF; |
1693 | palkovsky | 308 | /* Put a counter to the message */ |
2098 | decky | 309 | call->priv = ++irq->notif_cfg.counter; |
1693 | palkovsky | 310 | /* Set up args */ |
1923 | jermar | 311 | IPC_SET_METHOD(call->data, irq->notif_cfg.method); |
1281 | palkovsky | 312 | |
313 | /* Execute code to handle irq */ |
||
1923 | jermar | 314 | code_execute(call, irq->notif_cfg.code); |
1595 | palkovsky | 315 | |
1923 | jermar | 316 | send_call(irq, call); |
1281 | palkovsky | 317 | } |
318 | } |
||
319 | |||
1923 | jermar | 320 | /** Disconnect all IRQ notifications from an answerbox. |
1595 | palkovsky | 321 | * |
1933 | jermar | 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 | * |
||
1923 | jermar | 326 | * @param box Answerbox for which we want to carry out the cleanup. |
1595 | palkovsky | 327 | */ |
1281 | palkovsky | 328 | void ipc_irq_cleanup(answerbox_t *box) |
329 | { |
||
1933 | jermar | 330 | ipl_t ipl; |
331 | |||
332 | loop: |
||
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; |
||
2183 | jermar | 339 | DEADLOCK_PROBE_INIT(p_irqlock); |
1933 | jermar | 340 | |
341 | irq = list_get_instance(cur, irq_t, notif_cfg.link); |
||
342 | if (!spinlock_trylock(&irq->lock)) { |
||
343 | /* |
||
344 | * Avoid deadlock by trying again. |
||
345 | */ |
||
346 | spinlock_unlock(&box->irq_lock); |
||
347 | interrupts_restore(ipl); |
||
2183 | jermar | 348 | DEADLOCK_PROBE(p_irqlock, DEADLOCK_THRESHOLD); |
1933 | jermar | 349 | goto loop; |
350 | } |
||
351 | |||
352 | ASSERT(irq->notif_cfg.answerbox == box); |
||
353 | |||
354 | list_remove(&irq->notif_cfg.link); |
||
355 | |||
356 | /* |
||
357 | * Don't forget to free any top-half pseudocode. |
||
358 | */ |
||
359 | code_free(irq->notif_cfg.code); |
||
360 | |||
361 | irq->notif_cfg.notify = false; |
||
362 | irq->notif_cfg.answerbox = NULL; |
||
363 | irq->notif_cfg.code = NULL; |
||
364 | irq->notif_cfg.method = 0; |
||
365 | irq->notif_cfg.counter = 0; |
||
366 | |||
367 | spinlock_unlock(&irq->lock); |
||
368 | } |
||
369 | |||
370 | spinlock_unlock(&box->irq_lock); |
||
371 | interrupts_restore(ipl); |
||
1281 | palkovsky | 372 | } |
1702 | cejka | 373 | |
1757 | jermar | 374 | /** @} |
1702 | cejka | 375 | */ |