Rev 2183 | Rev 2626 | Go to most recent revision | Show entire file | Regard whitespace | Details | Blame | Last modification | View Log | RSS feed
Rev 2183 | Rev 2471 | ||
---|---|---|---|
Line 122... | Line 122... | ||
122 | call->data.args[code->cmds[i].dstarg] = dstval; |
122 | call->data.args[code->cmds[i].dstarg] = dstval; |
123 | } |
123 | } |
124 | } |
124 | } |
125 | } |
125 | } |
126 | 126 | ||
- | 127 | /** Free top-half pseudocode. |
|
- | 128 | * |
|
- | 129 | * @param code Pointer to the top-half pseudocode. |
|
- | 130 | */ |
|
127 | static void code_free(irq_code_t *code) |
131 | static void code_free(irq_code_t *code) |
128 | { |
132 | { |
129 | if (code) { |
133 | if (code) { |
130 | free(code->cmds); |
134 | free(code->cmds); |
131 | free(code); |
135 | free(code); |
132 | } |
136 | } |
133 | } |
137 | } |
134 | 138 | ||
- | 139 | /** Copy top-half pseudocode from userspace into the kernel. |
|
- | 140 | * |
|
- | 141 | * @param ucode Userspace address of the top-half pseudocode. |
|
- | 142 | * |
|
- | 143 | * @return Kernel address of the copied pseudocode. |
|
- | 144 | */ |
|
135 | static irq_code_t * code_from_uspace(irq_code_t *ucode) |
145 | static irq_code_t *code_from_uspace(irq_code_t *ucode) |
136 | { |
146 | { |
137 | irq_code_t *code; |
147 | irq_code_t *code; |
138 | irq_cmd_t *ucmds; |
148 | irq_cmd_t *ucmds; |
139 | int rc; |
149 | int rc; |
Line 148... | Line 158... | ||
148 | if (code->cmdcount > IRQ_MAX_PROG_SIZE) { |
158 | if (code->cmdcount > IRQ_MAX_PROG_SIZE) { |
149 | free(code); |
159 | free(code); |
150 | return NULL; |
160 | return NULL; |
151 | } |
161 | } |
152 | ucmds = code->cmds; |
162 | ucmds = code->cmds; |
153 | code->cmds = malloc(sizeof(code->cmds[0]) * (code->cmdcount), 0); |
163 | code->cmds = malloc(sizeof(code->cmds[0]) * code->cmdcount, 0); |
- | 164 | rc = copy_from_uspace(code->cmds, ucmds, |
|
154 | rc = copy_from_uspace(code->cmds, ucmds, sizeof(code->cmds[0]) * (code->cmdcount)); |
165 | sizeof(code->cmds[0]) * code->cmdcount); |
155 | if (rc != 0) { |
166 | if (rc != 0) { |
156 | free(code->cmds); |
167 | free(code->cmds); |
157 | free(code); |
168 | free(code); |
158 | return NULL; |
169 | return NULL; |
159 | } |
170 | } |
Line 162... | Line 173... | ||
162 | } |
173 | } |
163 | 174 | ||
164 | /** Unregister task from IRQ notification. |
175 | /** Unregister task from IRQ notification. |
165 | * |
176 | * |
166 | * @param box Answerbox associated with the notification. |
177 | * @param box Answerbox associated with the notification. |
167 | * @param inr IRQ numbe. |
178 | * @param inr IRQ number. |
168 | * @param devno Device number. |
179 | * @param devno Device number. |
169 | */ |
180 | */ |
170 | void ipc_irq_unregister(answerbox_t *box, inr_t inr, devno_t devno) |
181 | void ipc_irq_unregister(answerbox_t *box, inr_t inr, devno_t devno) |
171 | { |
182 | { |
172 | ipl_t ipl; |
183 | ipl_t ipl; |
Line 201... | Line 212... | ||
201 | * @param method Method to be associated with the notification. |
212 | * @param method Method to be associated with the notification. |
202 | * @param ucode Uspace pointer to top-half pseudocode. |
213 | * @param ucode Uspace pointer to top-half pseudocode. |
203 | * |
214 | * |
204 | * @return EBADMEM, ENOENT or EEXISTS on failure or 0 on success. |
215 | * @return EBADMEM, ENOENT or EEXISTS on failure or 0 on success. |
205 | */ |
216 | */ |
206 | int ipc_irq_register(answerbox_t *box, inr_t inr, devno_t devno, unative_t method, irq_code_t *ucode) |
217 | int ipc_irq_register(answerbox_t *box, inr_t inr, devno_t devno, |
- | 218 | unative_t method, irq_code_t *ucode) |
|
207 | { |
219 | { |
208 | ipl_t ipl; |
220 | ipl_t ipl; |
209 | irq_code_t *code; |
221 | irq_code_t *code; |
210 | irq_t *irq; |
222 | irq_t *irq; |
211 | 223 | ||
212 | if (ucode) { |
224 | if (ucode) { |
213 | code = code_from_uspace(ucode); |
225 | code = code_from_uspace(ucode); |
214 | if (!code) |
226 | if (!code) |
215 | return EBADMEM; |
227 | return EBADMEM; |
216 | } else |
228 | } else { |
217 | code = NULL; |
229 | code = NULL; |
- | 230 | } |
|
218 | 231 | ||
219 | ipl = interrupts_disable(); |
232 | ipl = interrupts_disable(); |
220 | irq = irq_find_and_lock(inr, devno); |
233 | irq = irq_find_and_lock(inr, devno); |
221 | if (!irq) { |
234 | if (!irq) { |
222 | interrupts_restore(ipl); |
235 | interrupts_restore(ipl); |
Line 245... | Line 258... | ||
245 | interrupts_restore(ipl); |
258 | interrupts_restore(ipl); |
246 | 259 | ||
247 | return 0; |
260 | return 0; |
248 | } |
261 | } |
249 | 262 | ||
250 | /** Add call to proper answerbox queue. |
263 | /** Add a call to the proper answerbox queue. |
251 | * |
264 | * |
252 | * Assume irq->lock is locked. |
265 | * Assume irq->lock is locked. |
253 | * |
266 | * |
- | 267 | * @param irq IRQ structure referencing the target answerbox. |
|
- | 268 | * @param call IRQ notification call. |
|
254 | */ |
269 | */ |
255 | static void send_call(irq_t *irq, call_t *call) |
270 | static void send_call(irq_t *irq, call_t *call) |
256 | { |
271 | { |
257 | spinlock_lock(&irq->notif_cfg.answerbox->irq_lock); |
272 | spinlock_lock(&irq->notif_cfg.answerbox->irq_lock); |
258 | list_append(&call->link, &irq->notif_cfg.answerbox->irq_notifs); |
273 | list_append(&call->link, &irq->notif_cfg.answerbox->irq_notifs); |
259 | spinlock_unlock(&irq->notif_cfg.answerbox->irq_lock); |
274 | spinlock_unlock(&irq->notif_cfg.answerbox->irq_lock); |
260 | 275 | ||
261 | waitq_wakeup(&irq->notif_cfg.answerbox->wq, WAKEUP_FIRST); |
276 | waitq_wakeup(&irq->notif_cfg.answerbox->wq, WAKEUP_FIRST); |
262 | } |
277 | } |
263 | 278 | ||
264 | /** Send notification message |
279 | /** Send notification message. |
265 | * |
280 | * |
- | 281 | * @param irq IRQ structure. |
|
- | 282 | * @param a1 Driver-specific payload argument. |
|
- | 283 | * @param a2 Driver-specific payload argument. |
|
- | 284 | * @param a3 Driver-specific payload argument. |
|
266 | */ |
285 | */ |
267 | void ipc_irq_send_msg(irq_t *irq, unative_t a1, unative_t a2, unative_t a3) |
286 | void ipc_irq_send_msg(irq_t *irq, unative_t a1, unative_t a2, unative_t a3) |
268 | { |
287 | { |
269 | call_t *call; |
288 | call_t *call; |
270 | 289 | ||
Line 287... | Line 306... | ||
287 | send_call(irq, call); |
306 | send_call(irq, call); |
288 | } |
307 | } |
289 | spinlock_unlock(&irq->lock); |
308 | spinlock_unlock(&irq->lock); |
290 | } |
309 | } |
291 | 310 | ||
292 | /** Notify task that an irq had occurred. |
311 | /** Notify a task that an IRQ had occurred. |
293 | * |
312 | * |
294 | * We expect interrupts to be disabled and the irq->lock already held. |
313 | * We expect interrupts to be disabled and the irq->lock already held. |
- | 314 | * |
|
- | 315 | * @param irq IRQ structure. |
|
295 | */ |
316 | */ |
296 | void ipc_irq_send_notif(irq_t *irq) |
317 | void ipc_irq_send_notif(irq_t *irq) |
297 | { |
318 | { |
298 | call_t *call; |
319 | call_t *call; |
299 | 320 |