boards: Add Seeeduino XIAO support

Add Seeed Studio Seeedunio XIAO support. The `blink` and `usb_serial`
examples were tested on hardware.

Author: gkelly

.travis.yml

@@ -28,6 +28,7 @@ env:
   - CRATE=boards/pfza_proto1 EXAMPLES="--example=blinky_basic" FEATURES="--features=unproven"
   - CRATE=boards/serpente EXAMPLES="--example=blinky_basic --example=pwm" FEATURES="--features=unproven"
   - CRATE=boards/edgebadge FEATURES="--features=unproven"
+  - CRATE=boards/xiao_m0 EXAMPLES="--example=blink --example=usb_serial" FEATURES="--features=usb"
 
 matrix:
   allow_failures:

boards/xiao_m0/.cargo/config

@@ -0,0 +1,8 @@
+[build]
+target = "thumbv6m-none-eabi"
+
+[target.thumbv6m-none-eabi]
+runner = 'arm-none-eabi-gdb'
+rustflags = [
+  "-C", "link-arg=-Tlink.x",
+]

boards/xiao_m0/Cargo.toml

@@ -0,0 +1,54 @@
+[package]
+name = "xiao_m0"
+version = "0.6.1"
+authors = ["Garret Kelly <gdk@google.com>"]
+description = "Board support crate for the Seeed Studio Seeeduino XIAO"
+keywords = ["no-std", "arm", "cortex-m", "embedded-hal"]
+license = "MIT OR Apache-2.0"
+repository = "https://github.com/atsamd-rs/atsamd"
+readme = "README.md"
+documentation = "https://atsamd-rs.github.io/atsamd/atsamd21g18a/xiao_m0/"
+edition = "2018"
+
+[dependencies]
+cortex-m = "~0.6.2"
+embedded-hal = "~0.2.3"
+nb = "~0.1"
+
+[dependencies.cortex-m-rt]
+version = "~0.6.12"
+optional = true
+
+[dependencies.atsamd-hal]
+path = "../../hal"
+version = "~0.8"
+default-features = false
+
+[dependencies.usb-device]
+version = "~0.2"
+optional = true
+
+[dependencies.usbd-serial]
+version = "~0.1"
+optional = true
+
+[dev-dependencies]
+panic-halt = "~0.2"
+
+[features]
+default = ["rt", "atsamd-hal/samd21g18a"]
+rt = ["cortex-m-rt", "atsamd-hal/samd21g18a-rt"]
+unproven = ["atsamd-hal/unproven"]
+usb = ["atsamd-hal/usb", "usb-device", "usbd-serial"]
+
+[[example]]
+name = "blink"
+
+[[example]]
+name = "usb_serial"
+required-features = ["usb"]
+
+[profile.release]
+debug = true
+lto = true
+opt-level = "s"

boards/xiao_m0/README.md

@@ -0,0 +1,23 @@
+# Seeeduino XIAO Board Support Crate
+
+This crate provides a type-safe API for working with the [Seeed Studio
+Seeeduino XIAO](http://wiki.seeedstudio.com/Seeeduino-XIAO/).
+
+## Prerequisites
+* Install the cross compile toolchain `rustup target add thumbv6m-none-eabi`
+* Install the [cargo-hf2 tool](https://crates.io/crates/cargo-hf2) however your
+  platform requires
+
+## Uploading an example
+Check out [the
+repository](https://github.com/atsamd-rs/atsamd/tree/master/boards/xiao_m0/examples)
+for examples.
+
+* Be in this directory `cd boards/xiao_m0`
+* Put your device in bootloader mode by bridging the `RST` pads _twice_ in
+  quick succession. The orange LED will pulse when the device is in bootloader
+  mode.
+* Build and upload in one step: `cargo hf2 --release --example blink`
+  * Note that if you're using an older `cargo-hf2` that you'll need to specify
+    the VID/PID when flashing: `cargo hf2 --vid 0x2886 --pid 0x002f --release
+    --example blink`

boards/xiao_m0/examples/blink.rs

@@ -0,0 +1,44 @@
+#![no_main]
+#![no_std]
+
+extern crate cortex_m;
+extern crate panic_halt;
+extern crate xiao_m0 as hal;
+
+use hal::clock::GenericClockController;
+use hal::delay::Delay;
+use hal::entry;
+use hal::pac::{CorePeripherals, Peripherals};
+use hal::prelude::*;
+
+#[entry]
+fn main() -> ! {
+    let mut peripherals = Peripherals::take().unwrap();
+    let core = CorePeripherals::take().unwrap();
+    let mut clocks = GenericClockController::with_external_32kosc(
+        peripherals.GCLK,
+        &mut peripherals.PM,
+        &mut peripherals.SYSCTRL,
+        &mut peripherals.NVMCTRL,
+    );
+    let mut pins = hal::Pins::new(peripherals.PORT);
+    let mut led0 = pins.led0.into_open_drain_output(&mut pins.port);
+    let mut led1 = pins.led1.into_open_drain_output(&mut pins.port);
+    let mut led2 = pins.led2.into_open_drain_output(&mut pins.port);
+    let mut delay = Delay::new(core.SYST, &mut clocks);
+
+    let mut counter = 0u8;
+    loop {
+        counter = counter.wrapping_add(1);
+        delay.delay_ms(100u8);
+        if counter & (1 << 0) != 0 {
+            led0.toggle();
+        }
+        if counter & (1 << 1) != 0 {
+            led1.toggle();
+        }
+        if counter & (1 << 2) != 0 {
+            led2.toggle();
+        }
+    }
+}

boards/xiao_m0/examples/usb_serial.rs

@@ -0,0 +1,104 @@
+#![no_std]
+#![no_main]
+
+extern crate cortex_m;
+extern crate panic_halt;
+extern crate usb_device;
+extern crate usbd_serial;
+extern crate xiao_m0 as hal;
+
+use hal::clock::GenericClockController;
+use hal::entry;
+use hal::gpio::{OpenDrain, Output, Pa18};
+use hal::pac::{interrupt, CorePeripherals, Peripherals};
+
+use hal::usb::UsbBus;
+use usb_device::bus::UsbBusAllocator;
+
+use usb_device::prelude::*;
+use usbd_serial::{SerialPort, USB_CLASS_CDC};
+
+use cortex_m::asm::delay as cycle_delay;
+use cortex_m::peripheral::NVIC;
+
+#[entry]
+fn main() -> ! {
+    let mut peripherals = Peripherals::take().unwrap();
+    let mut core = CorePeripherals::take().unwrap();
+    let mut clocks = GenericClockController::with_internal_32kosc(
+        peripherals.GCLK,
+        &mut peripherals.PM,
+        &mut peripherals.SYSCTRL,
+        &mut peripherals.NVMCTRL,
+    );
+    let mut pins = hal::Pins::new(peripherals.PORT);
+    let mut led0 = pins.led0.into_open_drain_output(&mut pins.port);
+
+    let bus_allocator = unsafe {
+        USB_ALLOCATOR = Some(hal::usb_allocator(
+            peripherals.USB,
+            &mut clocks,
+            &mut peripherals.PM,
+            pins.usb_dm,
+            pins.usb_dp,
+            &mut pins.port,
+        ));
+        USB_ALLOCATOR.as_ref().unwrap()
+    };
+
+    unsafe {
+        USB_SERIAL = Some(SerialPort::new(&bus_allocator));
+        USB_BUS = Some(
+            UsbDeviceBuilder::new(&bus_allocator, UsbVidPid(0x16c0, 0x27dd))
+                .manufacturer("Fake company")
+                .product("Serial port")
+                .serial_number("TEST")
+                .device_class(USB_CLASS_CDC)
+                .build(),
+        );
+        LED = Some(pins.led1.into_open_drain_output(&mut pins.port));
+    }
+
+    unsafe {
+        core.NVIC.set_priority(interrupt::USB, 1);
+        NVIC::unmask(interrupt::USB);
+    }
+
+    // Flash the LED in a spin loop to demonstrate that USB is
+    // entirely interrupt driven.
+    loop {
+        cycle_delay(15 * 1024 * 1024);
+        led0.toggle();
+    }
+}
+
+static mut USB_ALLOCATOR: Option<UsbBusAllocator<UsbBus>> = None;
+static mut USB_BUS: Option<UsbDevice<UsbBus>> = None;
+static mut USB_SERIAL: Option<SerialPort<UsbBus>> = None;
+static mut LED: Option<Pa18<Output<OpenDrain>>> = None;
+
+fn poll_usb() {
+    unsafe {
+        USB_BUS.as_mut().map(|usb_dev| {
+            USB_SERIAL.as_mut().map(|serial| {
+                usb_dev.poll(&mut [serial]);
+                let mut buf = [0u8; 64];
+
+                if let Ok(count) = serial.read(&mut buf) {
+                    for (i, c) in buf.iter().enumerate() {
+                        if i >= count {
+                            break;
+                        }
+                        serial.write(&[c.clone()]).unwrap();
+                        LED.as_mut().map(|led| led.toggle());
+                    }
+                };
+            });
+        });
+    };
+}
+
+#[interrupt]
+fn USB() {
+    poll_usb();
+}

boards/xiao_m0/memory.x

@@ -0,0 +1,7 @@
+MEMORY
+{
+  /* Leave 8k for the default bootloader on the Seeeduino XIAO */
+  FLASH (rx) : ORIGIN = 0x00000000 + 8K, LENGTH = 256K - 8K
+  RAM (xrw)  : ORIGIN = 0x20000000, LENGTH = 32K
+}
+_stack_start = ORIGIN(RAM) + LENGTH(RAM);