Sync with upstream Tock to have reproducible builds.

boards/nordic/nrf52840_mdk_dfu/Cargo.toml

@@ -0,0 +1,14 @@
+[package]
+name = "nrf52840_mdk_dfu"
+version = "0.1.0"
+authors = ["Yihui Xiong <yihui.xiong@hotmail.com>"]
+build = "build.rs"
+edition = "2018"
+
+[dependencies]
+components = { path = "../../components" }
+cortexm4 = { path = "../../../arch/cortex-m4" }
+capsules = { path = "../../../capsules" }
+kernel = { path = "../../../kernel" }
+nrf52840 = { path = "../../../chips/nrf52840" }
+nrf52dk_base = { path = "../nrf52dk_base" }

boards/nordic/nrf52840_mdk_dfu/Makefile

@@ -0,0 +1,29 @@
+# Makefile for building the tock kernel for the nRF development kit
+
+TOCK_ARCH=cortex-m4
+TARGET=thumbv7em-none-eabi
+PLATFORM=nrf52840_mdk_dfu
+
+include ../../Makefile.common
+
+TOCKLOADER=tockloader
+
+# Where in the nrf52 flash to load the kernel with `tockloader`
+KERNEL_ADDRESS=0x01000
+
+# Upload programs over uart with tockloader
+ifdef PORT
+  TOCKLOADER_GENERAL_FLAGS += --port $(PORT)
+endif
+
+TOCKLOADER_JTAG_FLAGS = --jlink --arch $(TOCK_ARCH) --board $(PLATFORM) --page-size 4096 --jlink-device nrf52840_xxaa
+
+# Upload the kernel over JTAG
+.PHONY: flash
+flash: $(TOCK_ROOT_DIRECTORY)target/$(TARGET)/release/$(PLATFORM).bin
+	$(TOCKLOADER) $(TOCKLOADER_GENERAL_FLAGS) flash --address $(KERNEL_ADDRESS) $(TOCKLOADER_JTAG_FLAGS) $<
+
+# Upload the kernel over serial/bootloader
+.PHONY: program
+program: $(TOCK_ROOT_DIRECTORY)target/$(TARGET)/release/$(PLATFORM).hex
+	$(error Cannot program nRF52840-MDK over USB. Use \`make flash\` and JTAG)

boards/nordic/nrf52840_mdk_dfu/build.rs

@@ -0,0 +1,4 @@
+fn main() {
+    println!("cargo:rerun-if-changed=layout.ld");
+    println!("cargo:rerun-if-changed=../../kernel_layout.ld");
+}

boards/nordic/nrf52840_mdk_dfu/layout.ld

@@ -0,0 +1,10 @@
+MEMORY
+{
+  rom (rx)  : ORIGIN = 0x00001000, LENGTH = 188K
+  prog (rx) : ORIGIN = 0x00030000, LENGTH = 832K
+  ram (rwx) : ORIGIN = 0x20000000, LENGTH = 256K
+}
+
+MPU_MIN_ALIGN = 8K;
+
+INCLUDE ../../kernel_layout.ld

boards/nordic/nrf52840_mdk_dfu/src/io.rs

@@ -0,0 +1,65 @@
+use core::fmt::Write;
+use core::panic::PanicInfo;
+use cortexm4;
+use kernel::debug;
+use kernel::debug::IoWrite;
+use kernel::hil::led;
+use kernel::hil::uart::{self, Configure};
+use nrf52840::gpio::Pin;
+
+use crate::CHIP;
+use crate::PROCESSES;
+
+struct Writer {
+    initialized: bool,
+}
+
+static mut WRITER: Writer = Writer { initialized: false };
+
+impl Write for Writer {
+    fn write_str(&mut self, s: &str) -> ::core::fmt::Result {
+        self.write(s.as_bytes());
+        Ok(())
+    }
+}
+
+impl IoWrite for Writer {
+    fn write(&mut self, buf: &[u8]) {
+        let uart = unsafe { &mut nrf52840::uart::UARTE0 };
+        if !self.initialized {
+            self.initialized = true;
+            uart.configure(uart::Parameters {
+                baud_rate: 115200,
+                stop_bits: uart::StopBits::One,
+                parity: uart::Parity::None,
+                hw_flow_control: false,
+                width: uart::Width::Eight,
+            });
+        }
+        for &c in buf {
+            unsafe {
+                uart.send_byte(c);
+            }
+            while !uart.tx_ready() {}
+        }
+    }
+}
+
+#[cfg(not(test))]
+#[no_mangle]
+#[panic_handler]
+/// Panic handler
+pub unsafe extern "C" fn panic_fmt(pi: &PanicInfo) -> ! {
+    // The nRF52840 Dongle LEDs (see back of board)
+    const LED1_PIN: Pin = Pin::P0_23;
+    let led = &mut led::LedLow::new(&mut nrf52840::gpio::PORT[LED1_PIN]);
+    let writer = &mut WRITER;
+    debug::panic(
+        &mut [led],
+        writer,
+        pi,
+        &cortexm4::support::nop,
+        &PROCESSES,
+        &CHIP,
+    )
+}

boards/nordic/nrf52840_mdk_dfu/src/main.rs

@@ -0,0 +1,123 @@
+//! Tock kernel for the Makerdiary nRF52840 MDK USB dongle.
+//!
+//! It is based on nRF52840 SoC (Cortex M4 core with a BLE transceiver) with
+//! many exported I/O and peripherals.
+
+#![no_std]
+#![no_main]
+#![deny(missing_docs)]
+
+use kernel::component::Component;
+#[allow(unused_imports)]
+use kernel::{debug, debug_gpio, debug_verbose, static_init};
+use nrf52840::gpio::Pin;
+use nrf52dk_base::{SpiPins, UartChannel, UartPins};
+
+// The nRF52840 MDK USB Dongle LEDs
+const LED1_R_PIN: Pin = Pin::P0_23;
+const LED1_G_PIN: Pin = Pin::P0_22;
+const LED1_B_PIN: Pin = Pin::P0_24;
+
+// The nRF52840 Dongle button
+const BUTTON_PIN: Pin = Pin::P0_18;
+const BUTTON_RST_PIN: Pin = Pin::P0_02;
+
+const UART_RTS: Option<Pin> = Some(Pin::P0_21);
+const UART_TXD: Pin = Pin::P0_20;
+const UART_CTS: Option<Pin> = Some(Pin::P0_03);
+const UART_RXD: Pin = Pin::P0_19;
+
+const SPI_MOSI: Pin = Pin::P0_05;
+const SPI_MISO: Pin = Pin::P0_06;
+const SPI_CLK: Pin = Pin::P0_07;
+
+/// UART Writer
+pub mod io;
+
+// State for loading and holding applications.
+// How should the kernel respond when a process faults.
+const FAULT_RESPONSE: kernel::procs::FaultResponse = kernel::procs::FaultResponse::Panic;
+
+// Number of concurrent processes this platform supports.
+const NUM_PROCS: usize = 8;
+
+// RAM to be shared by all application processes.
+#[link_section = ".app_memory"]
+static mut APP_MEMORY: [u8; 0x3C000] = [0; 0x3C000];
+
+static mut PROCESSES: [Option<&'static dyn kernel::procs::ProcessType>; NUM_PROCS] =
+    [None, None, None, None, None, None, None, None];
+
+// Static reference to chip for panic dumps
+static mut CHIP: Option<&'static nrf52840::chip::Chip> = None;
+
+/// Dummy buffer that causes the linker to reserve enough space for the stack.
+#[no_mangle]
+#[link_section = ".stack_buffer"]
+pub static mut STACK_MEMORY: [u8; 0x1000] = [0; 0x1000];
+
+/// Entry point in the vector table called on hard reset.
+#[no_mangle]
+pub unsafe fn reset_handler() {
+    // Loads relocations and clears BSS
+    nrf52840::init();
+
+    let board_kernel = static_init!(kernel::Kernel, kernel::Kernel::new(&PROCESSES));
+    // GPIOs
+    let gpio = components::gpio::GpioComponent::new(board_kernel).finalize(
+        components::gpio_component_helper!(
+            &nrf52840::gpio::PORT[Pin::P0_04],
+            &nrf52840::gpio::PORT[Pin::P0_05],
+            &nrf52840::gpio::PORT[Pin::P0_06],
+            &nrf52840::gpio::PORT[Pin::P0_07],
+            &nrf52840::gpio::PORT[Pin::P0_08]
+        ),
+    );
+    let button = components::button::ButtonComponent::new(board_kernel).finalize(
+        components::button_component_helper!((
+            &nrf52840::gpio::PORT[BUTTON_PIN],
+            kernel::hil::gpio::ActivationMode::ActiveLow,
+            kernel::hil::gpio::FloatingState::PullUp
+        )),
+    );
+
+    let led = components::led::LedsComponent::new().finalize(components::led_component_helper!(
+        (
+            &nrf52840::gpio::PORT[LED1_R_PIN],
+            kernel::hil::gpio::ActivationMode::ActiveLow
+        ),
+        (
+            &nrf52840::gpio::PORT[LED1_G_PIN],
+            kernel::hil::gpio::ActivationMode::ActiveLow
+        ),
+        (
+            &nrf52840::gpio::PORT[LED1_B_PIN],
+            kernel::hil::gpio::ActivationMode::ActiveLow
+        )
+    ));
+    let chip = static_init!(nrf52840::chip::Chip, nrf52840::chip::new());
+    CHIP = Some(chip);
+
+    nrf52dk_base::setup_board(
+        board_kernel,
+        BUTTON_RST_PIN,
+        &nrf52840::gpio::PORT,
+        gpio,
+        LED1_R_PIN,
+        LED1_G_PIN,
+        LED1_B_PIN,
+        led,
+        UartChannel::Pins(UartPins::new(UART_RTS, UART_TXD, UART_CTS, UART_RXD)),
+        &SpiPins::new(SPI_MOSI, SPI_MISO, SPI_CLK),
+        &None,
+        button,
+        true,
+        &mut APP_MEMORY,
+        &mut PROCESSES,
+        FAULT_RESPONSE,
+        nrf52840::uicr::Regulator0Output::V3_0,
+        false,
+        &Some(&nrf52840::usbd::USBD),
+        chip,
+    );
+}