Saving work on USB

Author: firelizzard18

.gitignore

@@ -7,6 +7,7 @@ src/device/nrf/*.go
 src/device/nrf/*.s
 src/device/nxp/*.go
 src/device/nxp/*.s
+!src/device/nxp/nxp.go
 src/device/sam/*.go
 src/device/sam/*.s
 src/device/sifive/*.go

src/device/nxp/nxp.go

@@ -0,0 +1,82 @@
+// Derivative work of Teensyduino Core Library
+// http://www.pjrc.com/teensy/
+// Copyright (c) 2017 PJRC.COM, LLC.
+//
+// Permission is hereby granted, free of charge, to any person obtaining
+// a copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to
+// permit persons to whom the Software is furnished to do so, subject to
+// the following conditions:
+//
+// 1. The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+//
+// 2. If the Software is incorporated into a build system that allows
+// selection among a list of target devices, then similar target
+// devices manufactured by PJRC.COM must be included in the list of
+// target devices and selectable in the same manner.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
+// BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+// ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+// CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
+
+// +build nxp
+
+package nxp
+
+const (
+	_SMC_PMCTRL_RUN   = 0 << SMC_PMCTRL_RUNM_Pos
+	_SMC_PMCTRL_HSRUN = 3 << SMC_PMCTRL_RUNM_Pos
+	_SMC_PMSTAT_RUN   = 0x01 << SMC_PMSTAT_PMSTAT_Pos
+	_SMC_PMSTAT_HSRUN = 0x80 << SMC_PMSTAT_PMSTAT_Pos
+)
+
+func KinetisHSRunDisable() bool {
+	// from: kinetis_hsrun_disable
+
+	if SMC.PMSTAT.Get() != _SMC_PMSTAT_HSRUN {
+		return false
+	}
+
+	// First, reduce the CPU clock speed, but do not change
+	// the peripheral speed (F_BUS).  Serial1 & Serial2 baud
+	// rates will be impacted, but most other peripherals
+	// will continue functioning at the same speed.
+	SIM.CLKDIV1.Set((2 << SIM_CLKDIV1_OUTDIV1_Pos) | (2 << SIM_CLKDIV1_OUTDIV2_Pos) | (2 << SIM_CLKDIV1_OUTDIV1_Pos) | (8 << SIM_CLKDIV1_OUTDIV4_Pos))
+
+	// Then turn off HSRUN mode
+	SMC.PMCTRL.Set(_SMC_PMCTRL_RUN)
+
+	// Wait for HSRUN to end
+	for SMC.PMSTAT.Get() == _SMC_PMSTAT_HSRUN {
+	}
+
+	return false
+}
+
+func KinetisHSRunEnable() bool {
+	// from: kinetis_hsrun_enable
+
+	if SMC.PMSTAT.Get() != _SMC_PMSTAT_RUN {
+		return false
+	}
+
+	// Turn HSRUN mode on
+	SMC.PMCTRL.Set(_SMC_PMCTRL_HSRUN)
+
+	// Wait for HSRUN to start
+	for SMC.PMSTAT.Get() != _SMC_PMSTAT_HSRUN {
+	}
+
+	// Then configure clock for full speed
+	SIM.CLKDIV1.Set((0 << SIM_CLKDIV1_OUTDIV1_Pos) | (2 << SIM_CLKDIV1_OUTDIV2_Pos) | (0 << SIM_CLKDIV1_OUTDIV1_Pos) | (6 << SIM_CLKDIV1_OUTDIV4_Pos))
+
+	return true
+}

src/machine/board_teensy36.go

@@ -2,6 +2,21 @@
 
 package machine
 
+import (
+	"device/arm"
+	"device/nxp"
+	"runtime/volatile"
+	"strconv"
+	"sync/atomic"
+	"unsafe"
+)
+
+// F_CPU = 180 MHz
+// F_PLL = 180 MHz
+// F_BUS =  60 MHz
+// clock =  16 MHz
+// F_MEM = 25714286 Hz
+
 // CPUFrequency returns the frequency of the ARM core clock (180MHz)
 func CPUFrequency() uint32 { return 180000000 }
 
@@ -11,6 +26,37 @@ func ClockFrequency() uint32 { return 16000000 }
 // LED on the Teensy
 const LED = PC05
 
+const (
+	usb_STRING_MANUFACTURER = "Teensy"
+	usb_STRING_PRODUCT      = "Teensy 3.6 USB Serial"
+
+	usb_DEVICE_CLASS    = 0x02
+	usb_DEVICE_SUBCLASS = 0
+	usb_DEVICE_PROTOCOL = 0
+
+	usb_EP0_SIZE    = 64
+	usb_BUFFER_SIZE = usb_EP0_SIZE
+
+	usb_VID        = 0x16C0
+	usb_PID        = 0x0483 // teensy usb serial
+	usb_BCD_DEVICE = 0x0277 // teensy 3.6
+
+	// rev should appear as 0x0277
+
+	usb_InterfaceID_CDC_Status = 0
+	usb_InterfaceID_CDC_Data   = 1
+	usb_InterfaceCount         = 2
+
+	usb_EndpointID_CDC_ACM       = 2
+	usb_EndpointID_CDC_RX        = 3
+	usb_EndpointID_CDC_TX        = 4
+	usb_EndpointCount_CDC_Status = 1
+	usb_EndpointCount_CDC_Data   = 2
+	usb_EndpointCount            = 4
+)
+
+var usb_STRING_SERIAL string
+
 // Port E is unavailable pending resolution of
 // https://github.com/tinygo-org/tinygo/issues/1190
 
@@ -105,3 +151,189 @@ const (
 	defaultUART4TX = NoPin // D33
 )
 
+func EnterBootloader() {
+	arm.Asm("bkpt")
+}
+
+//go:linkname sleepTicks runtime.sleepTicks
+func sleepTicks(int64)
+
+var initted int32
+
+func init() {
+	atomic.StoreInt32(&initted, 0)
+}
+
+func InitPlatform() {
+	if !atomic.CompareAndSwapInt32(&initted, 0, 1) {
+		return
+	}
+
+	// for background about this startup delay, please see these conversations
+	// https://forum.pjrc.com/threads/36606-startup-time-(400ms)?p=113980&viewfull=1#post113980
+	// https://forum.pjrc.com/threads/31290-Teensey-3-2-Teensey-Loader-1-24-Issues?p=87273&viewfull=1#post87273
+	const millis = 1000
+	sleepTicks(25 * millis) // 50 for TeensyDuino < 142
+	usb_STRING_SERIAL = readSerialNumber()
+	setupUSB()
+	sleepTicks(275 * millis) // 350 for TeensyDuino < 142
+}
+
+func getUSBDescriptor(value, index uint16) ([]byte, bool) {
+	// from: usb_desc.c, usb_desc.h
+
+	if value == 0x0100 && index == 0x0000 {
+		return NewDeviceDescriptor(
+			usb_DEVICE_CLASS, usb_DEVICE_SUBCLASS, usb_DEVICE_PROTOCOL,
+			usb_EP0_SIZE,
+			usb_VID, usb_PID, usb_BCD_DEVICE,
+			usb_IMANUFACTURER, usb_IPRODUCT, usb_ISERIAL,
+			1,
+		).Bytes(), true
+	}
+
+	if value == 0x0200 && index == 0x0000 {
+		const cdcACMSize = 16
+		const cdcRXSize = 64
+		const cdcTXSize = 64
+
+		b := []byte{
+			configDescriptorSize,              // bLength
+			usb_CONFIGURATION_DESCRIPTOR_TYPE, // bDescriptorType
+			0,                                 // wTotalLength LSB
+			0,                                 //              MSB
+			usb_InterfaceCount,                // bNumInterfaces
+			1,                                 // bConfigurationValue
+			0,                                 // iConfiguration
+			0xC0,                              // bmAttributes
+			50,                                // bMaxPower
+
+			// Interface Descriptor, USB spec 9.6.5, page 267-269, Table 9-12
+			interfaceDescriptorSize,               // bLength
+			usb_INTERFACE_DESCRIPTOR_TYPE,         // bDescriptorType
+			usb_InterfaceID_CDC_Status,            // bInterfaceNumber
+			0,                                     // bAlternateSetting
+			usb_EndpointCount_CDC_Status,          // bNumEndpoints
+			usb_CDC_COMMUNICATION_INTERFACE_CLASS, // bInterfaceClass
+			usb_CDC_ABSTRACT_CONTROL_MODEL,        // bInterfaceSubClass
+			0x01,                                  // bInterfaceProtocol
+			0,                                     // iInterface
+
+			// CDC Header Functional Descriptor, CDC Spec 5.2.3.1, Table 26
+			5,          // bFunctionLength
+			0x24,       // bDescriptorType
+			0x00,       // bDescriptorSubtype
+			0x10, 0x01, // bcdCDC
+
+			// Call Management Functional Descriptor, CDC Spec 5.2.3.2, Table 27
+			5,    // bFunctionLength
+			0x24, // bDescriptorType
+			0x01, // bDescriptorSubtype
+			0x01, // bmCapabilities
+			1,    // bDataInterface
+
+			// Abstract Control Management Functional Descriptor, CDC Spec 5.2.3.3, Table 28
+			4,    // bFunctionLength
+			0x24, // bDescriptorType
+			0x02, // bDescriptorSubtype
+			0x06, // bmCapabilities
+
+			// Union Functional Descriptor, CDC Spec 5.2.3.8, Table 33
+			5,                          // bFunctionLength
+			0x24,                       // bDescriptorType
+			0x06,                       // bDescriptorSubtype
+			usb_InterfaceID_CDC_Status, // bMasterInterface
+			usb_InterfaceID_CDC_Data,   // bSlaveInterface0
+
+			// Endpoint Descriptor, USB spec 9.6.6, page 269-271, Table 9-13
+			endpointDescriptorSize,        // bLength
+			usb_ENDPOINT_DESCRIPTOR_TYPE,  // bDescriptorType
+			usb_EndpointID_CDC_ACM | 0x80, // bEndpointAddress
+			0x03,                          // bmAttributes (0x03=intr)
+			cdcACMSize,                    // wMaxPacketSize LSB
+			0,                             //                MSB
+			64,                            // bInterval
+
+			// Interface Descriptor, USB spec 9.6.5, page 267-269, Table 9-12
+			interfaceDescriptorSize,       // bLength
+			usb_INTERFACE_DESCRIPTOR_TYPE, // bDescriptorType
+			usb_InterfaceID_CDC_Data,      // bInterfaceNumber
+			0,                             // bAlternateSetting
+			usb_EndpointCount_CDC_Data,    // bNumEndpoints
+			usb_CDC_DATA_INTERFACE_CLASS,  // bInterfaceClass
+			0x00,                          // bInterfaceSubClass
+			0x00,                          // bInterfaceProtocol
+			0,                             // iInterface
+
+			// Endpoint Descriptor, USB spec 9.6.6, page 269-271, Table 9-13
+			endpointDescriptorSize,       // bLength
+			usb_ENDPOINT_DESCRIPTOR_TYPE, // bDescriptorType
+			usb_EndpointID_CDC_RX,        // bEndpointAddress
+			0x02,                         // bmAttributes (0x02=bulk)
+			cdcRXSize,                    // wMaxPacketSize LSB
+			0,                            //                MSB
+			0,                            // bInterval
+
+			// Endpoint Descriptor, USB spec 9.6.6, page 269-271, Table 9-13
+			endpointDescriptorSize,       // bLength
+			usb_ENDPOINT_DESCRIPTOR_TYPE, // bDescriptorType
+			usb_EndpointID_CDC_TX | 0x80, // bEndpointAddress
+			0x02,                         // bmAttributes (0x02=bulk)
+			cdcTXSize,                    // wMaxPacketSize LSB
+			0,                            //                MSB
+			0,                            // bInterval
+		}
+
+		b[2] = byte(len(b))      // wTotalLength LSB
+		b[3] = byte(len(b) >> 8) //              MSB
+		return b, true
+	}
+
+	if value == 0x0300 && index == 0x0000 {
+		return []byte{4, 3, 0x04, 0x09}, true
+	}
+
+	if value == 0x0301 && index == 0x0409 {
+		return newStringDescriptor(usb_STRING_MANUFACTURER), true
+	}
+
+	if value == 0x0302 && index == 0x0409 {
+		return newStringDescriptor(usb_STRING_PRODUCT), true
+	}
+
+	if value == 0x0303 && index == 0x0409 {
+		return newStringDescriptor(usb_STRING_SERIAL), true
+	}
+
+	return nil, false
+}
+
+var usbEndpointConfigTable = [usb_EndpointCount]uint8{
+	0: 0,
+	1: nxp.USB0_ENDPT_EPCTLDIS | nxp.USB0_ENDPT_EPTXEN | nxp.USB0_ENDPT_EPHSHK,
+	2: nxp.USB0_ENDPT_EPCTLDIS | nxp.USB0_ENDPT_EPRXEN | nxp.USB0_ENDPT_EPHSHK,
+	3: nxp.USB0_ENDPT_EPCTLDIS | nxp.USB0_ENDPT_EPTXEN | nxp.USB0_ENDPT_EPHSHK,
+}
+
+func readSerialNumber() string {
+	// from: usb_init_serialnumber
+
+	flags := arm.DisableInterrupts()
+	nxp.KinetisHSRunDisable()
+	nxp.FTFE.FSTAT.Set(nxp.FTFE_FSTAT_RDCOLERR | nxp.FTFE_FSTAT_ACCERR | nxp.FTFE_FSTAT_FPVIOL)
+	((*volatile.Register32)(unsafe.Pointer(&nxp.FTFE.FCCOB3))).Set(0x41070000)
+	nxp.FTFE.FSTAT.Set(nxp.FTFE_FSTAT_CCIF)
+	for !nxp.FTFE.FSTAT.HasBits(nxp.FTFE_FSTAT_CCIF) {
+	} // wait
+	num := ((*volatile.Register32)(unsafe.Pointer(&nxp.FTFE.FCCOBB))).Get()
+	nxp.KinetisHSRunEnable()
+	arm.EnableInterrupts(flags)
+
+	// add extra zero to work around OS-X CDC-ACM driver bug
+	if num < 10000000 {
+		num *= 10
+	}
+
+	// can't allocate during startup
+	return strconv.FormatInt(int64(num), 10)
+}

src/machine/machine_nxpmk66f18.go

@@ -284,3 +284,17 @@ func (p FastPin) Clear()       { p.PCOR.Set(true) }
 func (p FastPin) Toggle()      { p.PTOR.Set(true) }
 func (p FastPin) Write(v bool) { p.PDOR.Set(v) }
 func (p FastPin) Read() bool   { return p.PDIR.Get() }
+
+// SysTick is configured in runtime_nxpmk66f18.go
+
+// number of systick irqs (milliseconds) since boot
+var systickCount volatile.Register32
+
+//go:export SysTick_Handler
+func tick() {
+	systickCount.Set(systickCount.Get() + 1)
+}
+
+func MillisSinceBoot() uint32 {
+	return systickCount.Get()
+}