void up_timerinit(void) { /* Configure and enable TIMER1. Used the computed TCKPS divider and timer * match valude. The source will be either the internal PBCLOCK (TCS=0) or * the external SOSC (TCS=1) */ putreg32((TIMER1_CON_TCKPS|TIMER1_CON_TCS), PIC32MX_TIMER1_CON); putreg32(0, PIC32MX_TIMER1_CNT); putreg32(TIMER1_MATCH-1, PIC32MX_TIMER1_PR); putreg32(TIMER_CON_ON, PIC32MX_TIMER1_CONSET); /* Configure the timer interrupt */ up_clrpend_irq(PIC32MX_IRQSRC_T1); (void)up_prioritize_irq(PIC32MX_IRQ_T1, CONFIG_PIC32MX_T1PRIO); /* Attach the timer interrupt vector */ (void)irq_attach(PIC32MX_IRQ_T1, (xcpt_t)up_timerisr); /* And enable the timer interrupt */ up_enable_irq(PIC32MX_IRQSRC_T1); }
int up_swint0(int irq, FAR void *context) { uint32_t *regs = (uint32_t*)context; uint32_t cause; DEBUGASSERT(regs && regs == current_regs); /* Software interrupt 0 is invoked with REG_A0 (REG_R4) = system call * command and REG_A1-3 and REG_T0-2 (REG_R5-10) = variable number of * arguments depending on the system call. */ #ifdef CONFIG_DEBUG_SYSCALL swidbg("Entry: regs: %p cmd: %d\n", regs, regs[REG_R4]); up_registerdump(regs); #endif /* Handle the SWInt according to the command in $4 */ switch (regs[REG_R4]) { /* R4=SYS_restore_context: This a restore context command: * * void up_fullcontextrestore(uint32_t *restoreregs) noreturn_function; * * At this point, the following values are saved in context: * * R4 = SYS_restore_context * R5 = restoreregs * * In this case, we simply need to set current_regs to restore register * area referenced in the saved R1. context == current_regs is the normal * exception return. By setting current_regs = context[R1], we force * the return to the saved context referenced in R1. */ case SYS_restore_context: { DEBUGASSERT(regs[REG_A1] != 0); current_regs = (uint32_t*)regs[REG_A1]; } break; /* R4=SYS_switch_context: This a switch context command: * * void up_switchcontext(uint32_t *saveregs, uint32_t *restoreregs); * * At this point, the following values are saved in context: * * R4 = SYS_switch_context * R5 = saveregs * R6 = restoreregs * * In this case, we save the context registers to the save register * area reference by the saved contents of R5 and then set * current_regs to to the save register area referenced by the saved * contents of R6. */ case SYS_switch_context: { DEBUGASSERT(regs[REG_A1] != 0 && regs[REG_A2] != 0); up_copystate((uint32_t*)regs[REG_A1], regs); current_regs = (uint32_t*)regs[REG_A2]; } break; /* R0=SYS_syscall_return: This a switch context command: * * void up_sycall_return(void); * * At this point, the following values are saved in context: * * R0 = SYS_syscall_return * * We need to restore the saved return address and return in * unprivileged thread mode. */ #ifdef CONFIG_BUILD_KERNEL case SYS_syscall_return: { struct tcb_s *rtcb = sched_self(); int index = (int)rtcb->xcp.nsyscalls - 1; /* Make sure that there is a saved syscall return address. */ DEBUGASSERT(index >= 0); /* Setup to return to the saved syscall return address in * the original mode. */ current_regs[REG_EPC] = rtcb->xcp.syscall[index].sysreturn; #error "Missing logic -- need to restore the original mode" rtcb->xcp.nsyscalls = index; } break; #endif /* This is not an architecture-specify system call. If NuttX is built * as a standalone kernel with a system call interface, then all of the * additional system calls must be handled as in the default case. */ default: { #ifdef CONFIG_BUILD_KERNEL FAR struct tcb_s *rtcb = sched_self(); int index = rtcb->xcp.nsyscalls; /* Verify that the SYS call number is within range */ DEBUGASSERT(current_regs[REG_A0] < SYS_maxsyscall); /* Make sure that we got here that there is a no saved syscall * return address. We cannot yet handle nested system calls. */ DEBUGASSERT(index < CONFIG_SYS_NNEST); /* Setup to return to dispatch_syscall in privileged mode. */ rtcb->xcpsyscall[index].sysreturn = regs[REG_EPC]; #error "Missing logic -- Need to save mode" rtcb->xcp.nsyscalls = index + 1; regs[REG_EPC] = (uint32_t)dispatch_syscall; #error "Missing logic -- Need to set privileged mode" /* Offset R0 to account for the reserved values */ current_regs[REG_R0] -= CONFIG_SYS_RESERVED; #else slldbg("ERROR: Bad SYS call: %d\n", regs[REG_A0]); #endif } break; } /* Report what happened. That might difficult in the case of a context switch */ #ifdef CONFIG_DEBUG_SYSCALL if (regs != current_regs) { swidbg("SWInt Return: Context switch!\n"); up_registerdump((const uint32_t*)current_regs); } else { swidbg("SWInt Return: %d\n", regs[REG_V0]); } #endif /* Clear the pending software interrupt 0 in the PIC32 interrupt block */ up_clrpend_irq(PIC32MX_IRQSRC_CS0); /* And reset the software interrupt bit in the MIPS CAUSE register */ cause = cp0_getcause(); cause &= ~CP0_CAUSE_IP0; cp0_putcause(cause); return OK; }
static int pic32mx_cninterrupt(int irq, FAR void *context) { int status; int ret = OK; int i; /* Call all attached handlers */ for (i = 0; i < IOPORT_NUMCN; i++) { /* Is this one attached */ if (g_cnisrs[i]) { /* Call the attached handler */ status = g_cnisrs[i](irq, context); /* Keep track of the status of the last handler that failed */ if (status < 0) { ret = status; } } /* Clear the pending interrupt */ up_clrpend_irq(PIC32MX_IRQ_CN); return ret; } /**************************************************************************** * Public Functions ****************************************************************************/ /**************************************************************************** * Name: pic32mx_gpioirqinitialize * * Description: * Initialize logic to support a GPIO change notification interrupts. * This function is called internally by the system on power up and should * not be called again. * ****************************************************************************/ void pic32mx_gpioirqinitialize(void) { int ret; /* Attach the change notice interrupt handler */ ret = irqattach(PIC32MX_IRQ_CN, pic32mx_cninterrupt); DEBUGASSERT(ret == OK); /* Set the interrupt priority */ #ifdef CONFIG_ARCH_IRQPRIO ret = up_prioritize_irq(PIC32MX_IRQ_CN, CONFIG_PIC32MX_CNPRIO); DEBUGASSERT(ret == OK); #endif /* Reset all registers and enable the CN module */ putreg32(IOPORT_CN_ALL, PIC32MX_IOPORT_CNENCLR); putreg32(IOPORT_CN_ALL, PIC32MX_IOPORT_CNPUECLR); putreg32(IOPORT_CNCON_ON, PIC32MX_IOPORT_CNCON); /* And enable the GPIO interrupt */ ret = up_enable_irq(PIC32MX_IRQSRC_CN); DEBUGASSERT(ret == OK); }
int up_swint0(int irq, FAR void *context) { uint32_t *regs = (uint32_t*)context; DEBUGASSERT(regs && regs == current_regs); /* Software interrupt 0 is invoked with REG_A0 (REG_R4) = system call * command and REG_A1-3 and REG_T0-2 (REG_R5-10) = variable number of * arguments depending on the system call. */ #ifdef DEBUG_SWINT0 swidbg("Entry: regs: %p cmd: %d\n", regs, regs[REG_R4]); up_registerdump(regs); #endif /* Handle the SWInt according to the command in $4 */ switch (regs[REG_R4]) { /* R4=SYS_restore_context: This a restore context command: * * void up_fullcontextrestore(uint32_t *restoreregs) __attribute__ ((noreturn)); * * At this point, the following values are saved in context: * * R4 = SYS_restore_context * R5 = restoreregs * * In this case, we simply need to set current_regs to restore register * area referenced in the saved R1. context == current_regs is the normal * exception return. By setting current_regs = context[R1], we force * the return to the saved context referenced in R1. */ case SYS_restore_context: { DEBUGASSERT(regs[REG_A1] != 0); current_regs = (uint32_t*)regs[REG_A1]; } break; /* R4=SYS_switch_context: This a switch context command: * * void up_switchcontext(uint32_t *saveregs, uint32_t *restoreregs); * * At this point, the following values are saved in context: * * R4 = SYS_switch_context * R5 = saveregs * R6 = restoreregs * * In this case, we save the context registers to the save register * area reference by the saved contents of R5 and then set * current_regs to to the save register area referenced by the saved * contents of R6. */ case SYS_switch_context: { DEBUGASSERT(regs[REG_A1] != 0 && regs[REG_A2] != 0); up_copystate((uint32_t*)regs[REG_A1], regs); current_regs = (uint32_t*)regs[REG_A2]; } break; /* This is not an architecture-specify system call. If NuttX is built * as a standalone kernel with a system call interface, then all of the * additional system calls must be handled as in the default case. */ default: #ifdef CONFIG_NUTTX_KERNEL dispatch_syscall(regs); #else slldbg("ERROR: Bad SYS call: %d\n", regs[REG_A0]); #endif break; } /* Report what happened. That might difficult in the case of a context switch */ #ifdef DEBUG_SWINT0 if (regs != current_regs) { swidbg("SWInt Return: Context switch!\n"); up_registerdump(current_regs); } else { swidbg("SWInt Return: %d\n", regs[REG_V0]); } #endif /* Clear the pending software interrupt 0 */ up_clrpend_irq(PIC32MX_IRQSRC_CS0); return OK; }