Working on NXP/Teensy support

src/runtime/interrupt/interrupt_cortexm.go

@@ -12,6 +12,11 @@ func (irq Interrupt) Enable() {
 	arm.EnableIRQ(uint32(irq.num))
 }
 
+// Disable disables this interrupt.
+func (irq Interrupt) Disable() {
+	arm.DisableIRQ(uint32(irq.num))
+}
+
 // SetPriority sets the interrupt priority for this interrupt. A lower number
 // means a higher priority. Additionally, most hardware doesn't implement all
 // priority bits (only the uppoer bits).

src/runtime/runtime_nxpmk66f18.go

@@ -52,9 +52,31 @@ var (
 	SMC_PMSTAT_HSRUN   = nxp.SMC_PMSTAT_PMSTAT(0x80)
 )
 
+var bootMsg = []byte("\r\n\r\nStartup complete, running main\r\n\r\n")
+
 //go:section .resetHandler
 //go:export Reset_Handler
 func main() {
+	initSystem()
+	arm.Asm("CPSIE i")
+	initInternal()
+	startupLateHook()
+
+	initAll()
+	machine.UART1.Configure(machine.UARTConfig{BaudRate: 115200})
+	for _, c := range bootMsg {
+		for !machine.UART1.S1.HasBits(nxp.UART_S1_TDRE) {
+		}
+		machine.UART1.D.Set(c)
+	}
+
+	callMain()
+	abort()
+}
+
+// ported ResetHandler from mk20dx128.c from teensy3 core libraries
+//go:noinline
+func initSystem() {
 	nxp.WDOG.UNLOCK.Set(WDOG_UNLOCK_SEQ1)
 	nxp.WDOG.UNLOCK.Set(WDOG_UNLOCK_SEQ2)
 	arm.Asm("nop")
@@ -156,22 +178,11 @@ func main() {
 	nxp.SysTick.CVR.Set(0)
 	nxp.SysTick.CSR.Set(nxp.SysTick_CSR_CLKSOURCE | nxp.SysTick_CSR_TICKINT | nxp.SysTick_CSR_ENABLE)
 	nxp.SystemControl.SHPR3.Set(0x20200000) // Systick = priority 32
-
-	arm.Asm("CPSIE i")
-	initTeensyInternal()
-	startupLateHook()
-
-	// initAll()
-	runMain()
-	// abort()
-
-	for {
-
-	}
 }
 
 // ported _init_Teensyduino_internal_ from pins_teensy.c from teensy3 core libraries
-func initTeensyInternal() {
+//go:noinline
+func initInternal() {
 	arm.EnableIRQ(nxp.IRQ_PORTA)
 	arm.EnableIRQ(nxp.IRQ_PORTB)
 	arm.EnableIRQ(nxp.IRQ_PORTC)
@@ -225,6 +236,11 @@ func initTeensyInternal() {
 	nxp.TPM1.C1SC.Set(0x28)
 	nxp.TPM1.SC.Set(nxp.FTM_SC_CLKS(1) | nxp.FTM_SC_PS(0))
 
+	// configure the low-power timer
+	// nxp.LPTMR0.CSR.Set(nxp.LPTMR0_CSR_TIE)
+	// nxp.LPTMR0.PSR.Set(nxp.LPTMR0_PSR_PCS(3) | nxp.LPTMR0_PSR_PRESCALE(1)) // use main (external) clock, divided by 4
+	// arm.EnableIRQ(nxp.IRQ_LPTMR0)
+
 	// 	analog_init();
 
 	// #if !defined(TEENSY_INIT_USB_DELAY_BEFORE)
@@ -264,13 +280,8 @@ func startupLateHook() {
 	// TODO allow override
 }
 
-//go:noinline
-func runMain() {
-	// this is a separate function to ensure that Reset_Handler fits in 0x230 bytes regardless of whether (user) main requires scheduling
-	callMain()
-}
-
 func putchar(c byte) {
+	machine.UART1.WriteByte(c)
 }
 
 // ???
@@ -280,18 +291,18 @@ const asyncScheduler = false
 const tickMicros = 1000
 
 // number of ticks since boot
-var tickMilliCount uint32
+var tickMilliCount volatile.Register32
 
 //go:export SysTick_Handler
 func tickHandler() {
-	volatile.StoreUint32(&tickMilliCount, volatile.LoadUint32(&tickMilliCount)+1)
+	tickMilliCount.Set(tickMilliCount.Get() + 1)
 }
 
 // ticks are in microseconds
 func ticks() timeUnit {
 	m := arm.DisableInterrupts()
 	current := nxp.SysTick.CVR.Get()
-	count := tickMilliCount
+	count := tickMilliCount.Get()
 	istatus := nxp.SystemControl.ICSR.Get()
 	arm.EnableInterrupts(m)
 
@@ -322,7 +333,7 @@ func sleepTicks(d timeUnit) {
 			}
 			start += 1000
 		}
-		// Gosched()
+		arm.Asm("wfi")
 	}
 }
 

src/runtime/volatile/register_nxpmk66f18.go

@@ -10,14 +10,14 @@ const bitbandBase = 0x42000000
 const ptrBytes = unsafe.Sizeof(uintptr(0))
 
 //go:inline
-func bitbandAddress(reg uintptr, bit uintptr) uintptr {
-	if bit > ptrBytes*8 {
+func bitbandAddress(reg uintptr, bit uint8) uintptr {
+	if uintptr(bit) > ptrBytes*8 {
 		panic("invalid bit position")
 	}
 	if reg < registerBase || reg >= registerEnd {
 		panic("register is out of range")
 	}
-	return (reg-registerBase)*ptrBytes*8 + bit*ptrBytes + bitbandBase
+	return (reg-registerBase)*ptrBytes*8 + uintptr(bit)*ptrBytes + bitbandBase
 }
 
 // Special types that causes loads/stores to be volatile (necessary for
@@ -40,17 +40,12 @@ func (r *BitRegister) Get() bool {
 //     *r.Reg = 1
 //
 //go:inline
-func (r *BitRegister) Set() {
-	StoreUint32(&r.Reg, 1)
-}
-
-// Clear clears the mapped register bit. It is the volatile equivalent of:
-//
-//     *r.Reg = 0
-//
-//go:inline
-func (r *BitRegister) Clear() {
-	StoreUint32(&r.Reg, 0)
+func (r *BitRegister) Set(v bool) {
+	var i uint32
+	if v {
+		i = 1
+	}
+	StoreUint32(&r.Reg, i)
 }
 
 // Bit maps bit N of register R to the corresponding bitband address. Bit panics
@@ -58,7 +53,7 @@ func (r *BitRegister) Clear() {
 // the number of bits in a register minus one).
 //
 // go:inline
-func (r *Register8) Bit(bit uintptr) *BitRegister {
+func (r *Register8) Bit(bit uint8) *BitRegister {
 	ptr := bitbandAddress(uintptr(unsafe.Pointer(&r.Reg)), bit)
 	return (*BitRegister)(unsafe.Pointer(ptr))
 }
@@ -68,7 +63,7 @@ func (r *Register8) Bit(bit uintptr) *BitRegister {
 // the number of bits in a register minus one).
 //
 // go:inline
-func (r *Register16) Bit(bit uintptr) *BitRegister {
+func (r *Register16) Bit(bit uint8) *BitRegister {
 	ptr := bitbandAddress(uintptr(unsafe.Pointer(&r.Reg)), bit)
 	return (*BitRegister)(unsafe.Pointer(ptr))
 }
@@ -78,7 +73,7 @@ func (r *Register16) Bit(bit uintptr) *BitRegister {
 // the number of bits in a register minus one).
 //
 // go:inline
-func (r *Register32) Bit(bit uintptr) *BitRegister {
+func (r *Register32) Bit(bit uint8) *BitRegister {
 	ptr := bitbandAddress(uintptr(unsafe.Pointer(&r.Reg)), bit)
 	return (*BitRegister)(unsafe.Pointer(ptr))
 }