/*
* implementation of the C_SWI_Handler
* @param: swi_num- swi number
* @param: sp- stack pointer that points to block of user registers
* @return: return value form swi on success, -1 on failure (swi num not
supported)
*/
void C_SWI_Handler(int swi_num, unsigned int *sp)
{
unsigned int r0, r1, r2;
switch(swi_num) {
case READ_SWI:
enable_interrupts();
r0 = *sp;
r1 = *(sp + 1);
r2 = *(sp + 2);
*sp = read_syscall((int)r0, (void *)r1, (size_t)r2);
break;
case WRITE_SWI:
enable_interrupts();
r0 = *sp;
r1 = *(sp + 1);
r2 = *(sp + 2);
*sp = write_syscall((int)r0, (const void *)r1, (size_t)r2);
break;
case TIME_SWI:
enable_interrupts();
*sp = time_syscall();
break;
case SLEEP_SWI:
// enable_interrupts();
r0 = *sp;
sleep_syscall((unsigned long)r0);
break;
case CREATE_SWI:
r0 = *sp;
r1 = *(sp + 1);
*sp = task_create((task_t *)r0, (size_t)r1);
break;
case EVENT_WAIT:
printf("calling event_wait sp is %p\n", sp);
r0 = *sp;
*sp = event_wait((unsigned int)r0);
// while(1);
printf("returned from event_wait\n");
break;
case MUTEX_CREATE:
*sp = mutex_create();
break;
case MUTEX_LOCK:
r0 = *sp;
*sp = mutex_lock((int)r0);
break;
case MUTEX_UNLOCK:
r0 = *sp;
*sp = mutex_unlock((int)r0);
break;
default:
printf("\n C_SWI_Handler:invalid SWI call, panic\n");
invalid_syscall(swi_num);
}
return;
}
//call the appropriate method based on the swi
int c_swi_handler(unsigned swi_num, unsigned * regs){
int ret = 0;
//if(debug_enabled ==1) printf ("c_swi_handler:: swi_num = %d\n", swi_num ) ;
switch(swi_num){
case EXIT_SWI:
c_exit(regs[0]);
break;
case READ_SWI:
ret = read_syscall(regs[0], (void *) regs[1], regs[2]);
break;
case WRITE_SWI:
ret = write_syscall(regs[0], (void *) regs[1], regs[2]);
break;
case TIME_SWI:
ret = time_syscall();
break;
case SLEEP_SWI:
sleep_syscall(regs[0]);
break;
case CREATE_SWI:
ret = task_create((task_t*)regs[0], regs[1]);
break;
case MUTEX_CREATE:
ret = mutex_create();
break;
case MUTEX_LOCK:
ret = mutex_lock(regs[0]);
break;
case MUTEX_UNLOCK:
ret = mutex_unlock(regs[0]);
break;
case EVENT_WAIT:
ret = event_wait(regs[0]);
break;
default:
invalid_syscall(0x0badc0de);
break;
}
return ret;
}
/* Called by assembly Swi_Handler, with a swi number and a pointer to
* register values on the stack.
* requires valid swi_Num, this check is done in kernel.
* returns a return value, depending on which swi_handler was called.
*/
int C_SWI_Handler(int swi_Num, unsigned int *regs) {
switch( swi_Num ) {
case READ_SWI: return read_syscall((int)regs[0], (char *)regs[1], (size_t)regs[2]);
case WRITE_SWI: return write_syscall((int)regs[0], (char *)regs[1], (size_t)regs[2]);
case TIME_SWI: return time_syscall();
case SLEEP_SWI:
sleep_syscall((unsigned long)regs[0]);
return 0;
case CREATE_SWI: return task_create((task_t *)regs[0], (size_t)regs[1]);
case MUTEX_CREATE: return mutex_create();
case MUTEX_LOCK: return mutex_lock((int)regs[0]);
case MUTEX_UNLOCK: return mutex_unlock((int)regs[0]);
case EVENT_WAIT: return event_wait((unsigned int)regs[0]);
default:
invalid_syscall(swi_Num);
}
assert(0); //Should not reach here
return(0);
}
void C_SWI_Handler(unsigned swi_num, unsigned *regs){
unsigned *value;
value=regs;
switch (swi_num) {
case READ_SWI:
*value= read_syscall(regs[0],(void *)regs[1],regs[2]);
break;
case WRITE_SWI:
*value=write_syscall(regs[0],(void *)regs[1],regs[2]);
break;
case TIME_SWI:
*value=time_syscall();
break;
case SLEEP_SWI:
sleep_syscall(regs[0]);
break;
case CREATE_SWI:
task_create((task_t *)regs[0],regs[1]);
break;
case MUTEX_CREATE:
*value=mutex_create();
break;
case MUTEX_LOCK:
*value=mutex_lock(regs[0]);
break;
case MUTEX_UNLOCK:
*value=mutex_unlock(regs[0]);
break;
case EVENT_WAIT:
event_wait(regs[0]);
break;
default:
invalid_syscall(swi_num);
} /* end switch */
return;
}
void time_swi(unsigned *regs) {
*(unsigned long*) regs = time_syscall();
}
