WebSVN – HelenOS – Diff – /trunk/kernel/generic/src/ipc/irq.c



            call->data.args[code->cmds[i].dstarg] = dstval;
        }
    }
}
 
/** Free top-half pseudocode.
 *
 * @param code      Pointer to the top-half pseudocode.
 */
static void code_free(irq_code_t *code)
{
    if (code) {
        free(code->cmds);
        free(code);
    }
}
 
/** Copy top-half pseudocode from userspace into the kernel.
 *
 * @param ucode     Userspace address of the top-half pseudocode.
 *
 * @return      Kernel address of the copied pseudocode.
 */
static irq_code_t *code_from_uspace(irq_code_t *ucode)
{
    irq_code_t *code;
    irq_cmd_t *ucmds;
    int rc;

    if (code->cmdcount > IRQ_MAX_PROG_SIZE) {
        free(code);
        return NULL;
    }
    ucmds = code->cmds;
    code->cmds = malloc(sizeof(code->cmds[0]) * code->cmdcount, 0);
    rc = copy_from_uspace(code->cmds, ucmds,
        sizeof(code->cmds[0]) * code->cmdcount);
    if (rc != 0) {
        free(code->cmds);
        free(code);
        return NULL;
    }

}
 
/** Unregister task from IRQ notification.
 *
 * @param box       Answerbox associated with the notification.
 * @param inr       IRQ number.
 * @param devno     Device number.
 */
void ipc_irq_unregister(answerbox_t *box, inr_t inr, devno_t devno)
{
    ipl_t ipl;

 * @param method    Method to be associated with the notification.
 * @param ucode     Uspace pointer to top-half pseudocode.
 *
 * @return      EBADMEM, ENOENT or EEXISTS on failure or 0 on success.
 */
int ipc_irq_register(answerbox_t *box, inr_t inr, devno_t devno,
    unative_t method, irq_code_t *ucode)
{
    ipl_t ipl;
    irq_code_t *code;
    irq_t *irq;
 
    if (ucode) {
        code = code_from_uspace(ucode);
        if (!code)
            return EBADMEM;
    } else {
        code = NULL;
    }
 
    ipl = interrupts_disable();
    irq = irq_find_and_lock(inr, devno);
    if (!irq) {
        interrupts_restore(ipl);

    interrupts_restore(ipl);
 
    return 0;
}
 
/** Add a call to the proper answerbox queue.
 *
 * Assume irq->lock is locked.
 *
 * @param irq       IRQ structure referencing the target answerbox.
 * @param call      IRQ notification call.
 */
static void send_call(irq_t *irq, call_t *call)
{
    spinlock_lock(&irq->notif_cfg.answerbox->irq_lock);
    list_append(&call->link, &irq->notif_cfg.answerbox->irq_notifs);
    spinlock_unlock(&irq->notif_cfg.answerbox->irq_lock);
       
    waitq_wakeup(&irq->notif_cfg.answerbox->wq, WAKEUP_FIRST);
}
 
/** Send notification message.
 *
 * @param irq       IRQ structure.
 * @param a1        Driver-specific payload argument.
 * @param a2        Driver-specific payload argument.
 * @param a3        Driver-specific payload argument.
 */
void ipc_irq_send_msg(irq_t *irq, unative_t a1, unative_t a2, unative_t a3)
{
    call_t *call;
 

        send_call(irq, call);
    }
    spinlock_unlock(&irq->lock);
}
 
/** Notify a task that an IRQ had occurred.
 *
 * We expect interrupts to be disabled and the irq->lock already held.
 *
 * @param irq       IRQ structure.
 */
void ipc_irq_send_notif(irq_t *irq)
{
    call_t *call;
 

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

Subversion Repositories HelenOS

(root)/trunk/kernel/generic/src/ipc/irq.c – Rev 2183 → 2471