Create the esp32c6-hal package

esp-hal.code-workspace

@@ -15,6 +15,9 @@
     {
       "path": "esp32c3-hal"
     },
+    {
+      "path": "esp32c6-hal"
+    },
     {
       "path": "esp32s2-hal"
     },

esp32c6-hal/.cargo/config.toml

@@ -0,0 +1,20 @@
+[target.riscv32imc-unknown-none-elf]
+runner = "espflash --monitor"
+rustflags = [
+  "-C", "link-arg=-Tlinkall.x",
+  "-C", "force-frame-pointers",
+]
+
+# for testing: you can specify this target to see atomic emulation in action
+[target.riscv32imac-unknown-none-elf]
+runner = "espflash --monitor"
+rustflags = [
+  "-C", "link-arg=-Tlinkall.x",
+  "-C", "force-frame-pointers",
+]
+
+[build]
+target = "riscv32imc-unknown-none-elf"
+
+[unstable]
+build-std = [ "core" ]

esp32c6-hal/Cargo.toml

@@ -0,0 +1,76 @@
+[package]
+name    = "esp32c6-hal"
+version = "0.3.0"
+authors = [
+    "Jesse Braham <[email protected]>",
+    "Björn Quentin <[email protected]>",
+]
+edition      = "2021"
+rust-version = "1.60.0"
+description  = "HAL for ESP32-C3 microcontrollers"
+repository   = "https://github.com/esp-rs/esp-hal"
+license      = "MIT OR Apache-2.0"
+
+keywords = [
+    "embedded",
+    "embedded-hal",
+    "esp",
+    "esp32c3",
+    "no-std",
+]
+categories = [
+    "embedded",
+    "hardware-support",
+    "no-std",
+]
+
+[dependencies]
+cfg-if             = "1.0.0"
+embassy-time       = { version = "0.1.0", features = ["nightly"], optional = true }
+embedded-hal       = { version = "0.2.7", features = ["unproven"] }
+embedded-hal-1     = { version = "=1.0.0-alpha.9", optional = true, package = "embedded-hal" }
+embedded-hal-async = { version = "0.1.0-alpha.3", optional = true }
+embedded-hal-nb    = { version = "=1.0.0-alpha.1", optional = true }
+esp-hal-common     = { version = "0.4.0",  features = ["esp32c6"], path = "../esp-hal-common" }
+r0                 = "1.0.0"
+riscv              = "0.10.0"
+riscv-rt           = { version = "0.10.0", optional = true }
+
+[dev-dependencies]
+critical-section  = "1.1.1"
+embassy-executor  = { package = "embassy-executor", git = "https://github.com/embassy-rs/embassy/", rev = "eed34f9", features = ["nightly", "integrated-timers"] }
+embedded-graphics = "0.7.1"
+esp-backtrace     = { git = "https://github.com/jessebraham/esp-backtrace", branch = "feature/chip-support", features = ["esp32c6", "panic-handler", "exception-handler", "print-uart"] }
+esp-println       = { git = "https://github.com/esp-rs/esp-println", rev = "fc4e9cf", features = ["esp32c6"] }
+sha2              = { version = "0.10.6", default-features = false}
+smart-leds        = "0.3.0"
+ssd1306           = "0.7.1"
+static_cell       = "1.0.0"
+
+[features]
+default              = ["rt", "vectored"]
+direct-boot          = []
+eh1                  = ["esp-hal-common/eh1", "dep:embedded-hal-1", "dep:embedded-hal-nb"]
+rt                   = ["riscv-rt"]
+smartled             = ["esp-hal-common/smartled"]
+ufmt                 = ["esp-hal-common/ufmt"]
+vectored             = ["esp-hal-common/vectored"]
+async                = ["esp-hal-common/async", "embedded-hal-async"]
+embassy              = ["esp-hal-common/embassy"]
+embassy-time-systick = ["esp-hal-common/embassy-time-systick", "embassy-time/tick-hz-16_000_000"]
+
+# [[example]]
+# name              = "hello_rgb"
+# required-features = ["smartled"]
+
+# [[example]]
+# name              = "spi_eh1_loopback"
+# required-features = ["eh1"]
+
+# [[example]]
+# name              = "spi_eh1_device_loopback"
+# required-features = ["eh1"]
+
+# [[example]]
+# name              = "embassy_hello_world"
+# required-features = ["embassy"]

esp32c6-hal/README.md

@@ -0,0 +1,76 @@
+# esp32c6-hal
+
+[![Crates.io](https://img.shields.io/crates/v/esp32c6-hal?labelColor=1C2C2E&color=C96329&logo=Rust&style=flat-square)](https://crates.io/crates/esp32c6-hal)
+[![docs.rs](https://img.shields.io/docsrs/esp32c6-hal?labelColor=1C2C2E&color=C96329&logo=rust&style=flat-square)](https://docs.rs/esp32c6-hal)
+![Crates.io](https://img.shields.io/crates/l/esp32c6-hal?labelColor=1C2C2E&style=flat-square)
+[![Matrix](https://img.shields.io/matrix/esp-rs:matrix.org?label=join%20matrix&labelColor=1C2C2E&color=BEC5C9&logo=matrix&style=flat-square)](https://matrix.to/#/#esp-rs:matrix.org)
+
+`no_std` HAL for the ESP32-C6 from Espressif. Implements a number of the traits defined by [embedded-hal](https://github.com/rust-embedded/embedded-hal).
+
+This device uses the RISC-V ISA, which is officially supported by the Rust compiler via the `riscv32imc-unknown-none-elf` target. Refer to the [Getting Stared](#getting-started) section below for more information.
+
+## [Documentation]
+
+[documentation]: https://docs.rs/esp32c6-hal/
+
+## Getting Started
+
+### Installing the Rust Compiler Target
+
+The compilation target for this device is officially supported via the `stable` release channel and can be installed via [rustup](https://rustup.rs/):
+
+```shell
+$ rustup target add riscv32imc-unknown-none-elf
+```
+
+### Supported boot methods
+
+#### IDF Bootloader
+
+The [IDF second stage bootloader](https://docs.espressif.com/projects/esp-idf/en/latest/esp32c6/api-guides/startup.html#second-stage-bootloader) is the default bootloader solution.
+
+By default, [espflash](https://github.com/esp-rs/espflash) fetches the required binaries (Bootloader and Partition Table) and flashes them onto the target device together with the Rust-based application firmware image.
+
+#### Direct Boot
+
+[Direct Boot](https://github.com/espressif/esp32c6-direct-boot-example#direct-boot-in-esp32-c6) allows an application stored in the External Flash to be executed directly, without being copied into Internal RAM.
+
+##### Booting the Hello World example using Direct Boot
+
+Build the Hello World example with support for Direct Boot:
+
+```shell
+cargo build --release --example hello_world --features direct-boot
+```
+
+Then proceed to generating the application binary and flashing it onto the target device:
+
+```shell
+cargo espflash --release --format direct-boot --features direct-boot --example hello_world --monitor
+```
+
+The ROM Bootloader will identify the firmware image built with Direct Boot support and load it appropriately from the External Flash:
+
+```shell
+ESP-ROM:esp32c6-api1-20210207
+Build:Feb  7 2021
+rst:0x1 (POWERON),boot:0xc (SPI_FAST_FLASH_BOOT)
+Hello world!
+Hello world!
+Hello world!
+```
+
+## License
+
+Licensed under either of:
+
+- Apache License, Version 2.0 ([LICENSE-APACHE](../LICENSE-APACHE) or http://www.apache.org/licenses/LICENSE-2.0)
+- MIT license ([LICENSE-MIT](../LICENSE-MIT) or http://opensource.org/licenses/MIT)
+
+at your option.
+
+### Contribution
+
+Unless you explicitly state otherwise, any contribution intentionally submitted for inclusion in
+the work by you, as defined in the Apache-2.0 license, shall be dual licensed as above, without
+any additional terms or conditions.

esp32c6-hal/build.rs

@@ -0,0 +1,74 @@
+use std::{env, fs::File, io::Write, path::PathBuf};
+
+#[cfg(feature = "direct-boot")]
+fn main() {
+    // Put the linker script somewhere the linker can find it
+    let out = &PathBuf::from(env::var_os("OUT_DIR").unwrap());
+
+    File::create(out.join("memory.x"))
+        .unwrap()
+        .write_all(include_bytes!("ld/db-esp32c6-memory.x"))
+        .unwrap();
+
+    File::create(out.join("esp32c6-link.x"))
+        .unwrap()
+        .write_all(include_bytes!("ld/db-esp32c6-link.x"))
+        .unwrap();
+
+    File::create(out.join("riscv-link.x"))
+        .unwrap()
+        .write_all(include_bytes!("ld/db-riscv-link.x"))
+        .unwrap();
+
+    File::create(out.join("linkall.x"))
+        .unwrap()
+        .write_all(include_bytes!("ld/db-linkall.x"))
+        .unwrap();
+
+    println!("cargo:rustc-link-search={}", out.display());
+
+    // Only re-run the build script when memory.x is changed,
+    // instead of when any part of the source code changes.
+    println!("cargo:rerun-if-changed=ld/memory.x");
+
+    add_defaults();
+}
+
+#[cfg(not(feature = "direct-boot"))]
+fn main() {
+    // Put the linker script somewhere the linker can find it
+    let out = &PathBuf::from(env::var_os("OUT_DIR").unwrap());
+    File::create(out.join("memory.x"))
+        .unwrap()
+        .write_all(include_bytes!("ld/bl-esp32c6-memory.x"))
+        .unwrap();
+
+    File::create(out.join("bl-riscv-link.x"))
+        .unwrap()
+        .write_all(include_bytes!("ld/bl-riscv-link.x"))
+        .unwrap();
+
+    File::create(out.join("linkall.x"))
+        .unwrap()
+        .write_all(include_bytes!("ld/bl-linkall.x"))
+        .unwrap();
+
+    println!("cargo:rustc-link-search={}", out.display());
+
+    // Only re-run the build script when memory.x is changed,
+    // instead of when any part of the source code changes.
+    println!("cargo:rerun-if-changed=ld/memory.x");
+
+    add_defaults();
+}
+
+fn add_defaults() {
+    let out = &PathBuf::from(env::var_os("OUT_DIR").unwrap());
+
+    File::create(out.join("hal-defaults.x"))
+        .unwrap()
+        .write_all(include_bytes!("ld/hal-defaults.x"))
+        .unwrap();
+
+    println!("cargo:rustc-link-search={}", out.display());
+}

esp32c6-hal/ld/bl-esp32c6-memory.x

@@ -0,0 +1,43 @@
+MEMORY
+{
+     /* MEMORY_MAP = [
+        [0x00000000, 0x00010000, "PADDING"],
+        [0x42800000, 0x43000000, "DROM"],
+        [0x40800000, 0x40880000, "DRAM"],
+        [0x40800000, 0x40880000, "BYTE_ACCESSIBLE"],
+        [0x4004AC00, 0x40050000, "DROM_MASK"],
+        [0x40000000, 0x4004AC00, "IROM_MASK"],
+        [0x42000000, 0x42800000, "IROM"],
+        [0x40800000, 0x40880000, "IRAM"],
+        [0x50000000, 0x50004000, "RTC_IRAM"],
+        [0x50000000, 0x50004000, "RTC_DRAM"],
+        [0x600FE000, 0x60100000, "MEM_INTERNAL2"],
+    ] */
+
+    /* 512K of on soc RAM, 32K reserved for cache */
+    ICACHE : ORIGIN = 0x40800000,  LENGTH = 32K
+    /* Instruction RAM */
+    IRAM : ORIGIN = 0x40800000 + 32K, LENGTH = 512K - 32K
+    /* Data RAM */
+    DRAM : ORIGIN = 0x40800000 + 32K, LENGTH = 512K - 32K
+
+    /* External flash */
+    /* Instruction ROM */
+    IROM : ORIGIN =   0x42000000 + 0x20, LENGTH = 0x400000 - 0x20
+    /* Data ROM */
+    DROM : ORIGIN = 0x42800000, LENGTH = 0x400000
+
+    /* RTC fast memory (executable). Persists over deep sleep. */
+    RTC_FAST : ORIGIN = 0x50000000, LENGTH = 16K /*- ESP_BOOTLOADER_RESERVE_RTC*/    
+}
+
+REGION_ALIAS("REGION_TEXT", IROM);
+REGION_ALIAS("REGION_RODATA", DROM);
+
+REGION_ALIAS("REGION_DATA", DRAM);
+REGION_ALIAS("REGION_BSS", DRAM);
+REGION_ALIAS("REGION_HEAP", DRAM);
+REGION_ALIAS("REGION_STACK", DRAM);
+
+REGION_ALIAS("REGION_RWTEXT", IRAM);
+REGION_ALIAS("REGION_RTC_FAST", RTC_FAST);

esp32c6-hal/ld/bl-linkall.x

@@ -0,0 +1,3 @@
+INCLUDE "memory.x"
+INCLUDE "bl-riscv-link.x"
+INCLUDE "hal-defaults.x"