Merge branch 'main' into feat/stable-rustc

Author: luojia65

.cargo/config.toml

@@ -1,2 +1,5 @@
 [alias]
 blri = "run --package blri --release --"
+
+[target.'cfg(target_os = "none")']
+runner = "cargo blri run"

.github/workflows/Cargo.yml

@@ -35,16 +35,35 @@ jobs:
       - name: Run tests
         run: cargo test -p ${{ MATRIX.PACKAGE }}
 
-  build-bouffalo-hal:
-    name: Build
+  build-bouffalo-hal-riscv64:
+    name: Build for riscv64
     needs: fmt
     runs-on: ubuntu-latest
     strategy:
       matrix:
         TARGET: [riscv64imac-unknown-none-elf]
-        TOOLCHAIN: [stable]
-        EXAMPLES: [gpio-demo, i2c-demo, jtag-demo, lz4d-demo, pwm-demo, 
-          sdcard-demo, sdcard-gpt-demo, spi-demo, uart-demo, uart-async-demo, uart-cli-demo]
+        # TOOLCHAIN: [stable] # TODO
+        TOOLCHAIN: [nightly]
+        EXAMPLES: [gpio-demo, i2c-demo, jtag-demo, lz4d-demo, psram-demo, pwm-demo, 
+          sdcard-demo, sdcard-gpt-demo, sdh-demo, sdh-dma-demo, spi-demo, uart-demo, uart-async-demo, uart-cli-demo]
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions-rust-lang/setup-rust-toolchain@v1
+        with:
+          target: ${{ MATRIX.TARGET }}
+          toolchain: ${{ MATRIX.TOOLCHAIN }}
+      - name: Run build
+        run: cargo build --target ${{ MATRIX.TARGET }} --release -p ${{ MATRIX.EXAMPLES }}
+
+  build-bouffalo-hal-riscv32:
+    name: Build for riscv32
+    needs: fmt
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        TARGET: [riscv32imac-unknown-none-elf]
+        TOOLCHAIN: [nightly]
+        EXAMPLES: [uart-dma-demo]
     steps:
       - uses: actions/checkout@v4
       - uses: actions-rust-lang/setup-rust-toolchain@v1

Cargo.toml

@@ -17,9 +17,11 @@ members = [
     "examples/peripherals/uart-demo",
     "examples/peripherals/uart-async-demo",
     "examples/peripherals/uart-cli-demo",
+    "examples/peripherals/uart-dma-demo",
     "examples/peripherals/sdcard-demo",
     "examples/peripherals/sdcard-gpt-demo",
     "examples/peripherals/psram-demo",
     "examples/peripherals/sdh-demo",
+    "examples/peripherals/sdh-dma-demo",
 ]
 resolver = "3"

README.md

@@ -1,23 +1,70 @@
-# Bouffalo chip Rust Hardware Abstraction Layer (HAL)
+# Bouffalo HAL
 
-This repository contains `bouffalo-hal` and `bouffalo-rt` packages.
+**Rust Hardware Abstraction Layer for Bouffalo chips**
+
+[![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](https://opensource.org/licenses/MIT)
+[![License: Mulan PSL v2](https://img.shields.io/badge/License-Mulan%20PSL%20v2-blue.svg)](https://opensource.org/license/mulanpsl-2-0)
+[![GitHub Actions Workflow Status](https://img.shields.io/github/actions/workflow/status/rustsbi/bouffalo-hal/Cargo.yml)](https://github.com/rustsbi/bouffalo-hal/actions)
+
+## Overview
+
+This repository contains three main components that provide comprehensive support for Bouffalo chips development in Rust:
+
+- **bouffalo-hal**: Hardware Abstraction Layer for Bouffalo IoT chips, providing safe and efficient interfaces to various peripherals. This component abstracts hardware-specific details and offers a consistent API for interacting with the chip's features.
+
+- **bouffalo-rt**: Runtime support for Bouffalo chips, including the `#[entry]` macro and other essential runtime functionalities. This component handles the low-level initialization required before the main application code runs.
+
+- **blri**: A utility for firmware image verification, patching, and flashing assistance. It helps with the firmware burning process for Bouffalo chips.
+
+Together, these components form a complete ecosystem for embedded development on Bouffalo hardware.
+
+## Features
+
+- Rust-native implementation with memory safety guarantees
+- Safe and efficient hardware abstractions
+- Support for various peripherals: GPIO, UART, SPI, I2C, PWM, and more
+- Rich examples demonstrating peripheral usage
+- Seamless integration with the embedded Rust ecosystem
+
+## Examples
+
+<table>
+  <tr>
+    <td align="center" width="32%">
+      <a href="examples/peripherals/uart-cli-demo">UART CLI Demo</a>
+      <br>
+      <img src="docs/uart-cli-demo.gif" width="100%" alt="UART CLI Demo">
+    </td>
+    <td align="center" width="32%">
+      <a href="examples/peripherals/pwm-demo">PWM Demo</a>
+      <br>
+      <img src="docs/pwm-demo.gif" width="100%" alt="PWM Demo">
+    </td>
+    <td align="center" width="32%">
+      <a href="examples/peripherals/spi-demo">SPI Demo</a>
+      <br>
+      <img src="docs/spi-demo.gif" width="100%" alt="SPI Demo">
+    </td>
+  </tr>
+</table>
+
+You can find all example code in the `examples/` directory.
+
+## Contributing
+
+Contributions are welcome! 
+
+For bugs or suggestions, please [submit an issue](https://github.com/rustsbi/bouffalo-hal/issues/new).
+
+To contribute code, please follow our [contribution guidelines](https://github.com/rustsbi/slides/blob/main/2025/reports/Contributing%20to%20RustSBI.md). 
 
 ## Minimum supported Rust version
 
 To compile the `bouffalo-hal` crates, you need at least stable Rust version of `rustc 1.85.0`.
 
 ## License
 
-Project is dual licensed under MIT or Mulan-PSL v2.
-
-```
-Copyright (c) 2023 RustSBI Team
-bouffalo-hal is licensed under Mulan PSL v2.
-You can use this software according to the terms and conditions of the Mulan PSL v2.
-You may obtain a copy of Mulan PSL v2 at:
-         http://license.coscl.org.cn/MulanPSL2
-THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
-EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
-MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
-See the Mulan PSL v2 for more details.
-```
+This project is licensed under either of
+
+- MIT license ([LICENSE-MIT](LICENSE-MIT) or [https://opensource.org/licenses/MIT](https://opensource.org/licenses/MIT))
+- Mulan PSL v2 ([LICENSE-MULAN](LICENSE-MULAN) or [https://opensource.org/licenses/MulanPSL-2.0](https://opensource.org/licenses/MulanPSL-2.0))

blri/Cargo.toml

@@ -11,6 +11,10 @@ clap = { version = "4.5.18", features = ["derive"] }
 crc = "3.2.1"
 sha2 = "0.10.8"
 thiserror = "2.0.3"
+inquire = "0.7.5"
+serialport = { version = "4.3", default-features = false }
+object = "0.36.7"
+same-file = "1.0.6"
 
 [dev-dependencies]
 tempfile = "3.12.0"

blri/src/isp.rs

@@ -0,0 +1,164 @@
+const GET_BOOT_INFO: u8 = 0x10;
+const DEVICE_RESET: u8 = 0x21;
+const ERASE_FLASH: u8 = 0x30;
+const WRITE_FLASH: u8 = 0x31;
+
+#[derive(thiserror::Error, Debug)]
+pub enum IspError {
+    #[error("Wrong response length: {wrong_length}")]
+    ResponseLength { wrong_length: usize },
+}
+
+pub trait IspCommand {
+    type Response;
+    const COMMAND: u8;
+    const RESPONSE_PAYLOAD: bool;
+    fn data_size(&self) -> usize;
+    fn write_packet_data(&self, buf: &mut [u8]);
+    fn parse_response(bytes: &[u8]) -> Result<Self::Response, IspError>;
+}
+
+// Ref: https://github.com/pine64/blisp/blob/e45941c45e2418b2bb7e3dab49468a8f4d132439/include/blisp.h#L26
+#[repr(C)]
+pub struct BootInfo {
+    pub boot_rom_version: [u8; 4],
+    _reserved1: [u8; 4],
+    pub flash_info_from_boot: u32,
+    pub chip_id: [u8; 6],
+    _reserved2: [u8; 6],
+}
+
+impl BootInfo {
+    pub fn flash_pin(&self) -> u32 {
+        (self.flash_info_from_boot >> 14) & 0x1f
+    }
+}
+
+pub struct GetBootInfo;
+
+// Ref: https://github.com/pine64/blisp/blob/e45941c45e2418b2bb7e3dab49468a8f4d132439/lib/blisp.c#L234
+impl IspCommand for GetBootInfo {
+    type Response = BootInfo;
+    const COMMAND: u8 = GET_BOOT_INFO;
+    const RESPONSE_PAYLOAD: bool = true;
+    fn data_size(&self) -> usize {
+        0
+    }
+    fn write_packet_data(&self, buf: &mut [u8]) {
+        assert!(buf.len() == 0);
+        // nothing to write
+    }
+    fn parse_response(bytes: &[u8]) -> Result<Self::Response, IspError> {
+        if bytes.len() != 24 {
+            return Err(IspError::ResponseLength {
+                wrong_length: bytes.len(),
+            });
+        }
+        Ok(BootInfo {
+            boot_rom_version: bytes[0..4].try_into().unwrap(),
+            _reserved1: bytes[4..8].try_into().unwrap(),
+            flash_info_from_boot: u32::from_le_bytes(bytes[8..12].try_into().unwrap()),
+            chip_id: bytes[12..18].try_into().unwrap(),
+            _reserved2: bytes[18..24].try_into().unwrap(),
+        })
+    }
+}
+
+pub struct DeviceReset;
+
+// Ref: https://github.com/pine64/blisp/blob/e45941c45e2418b2bb7e3dab49468a8f4d132439/lib/blisp.c#L403
+impl IspCommand for DeviceReset {
+    type Response = ();
+    const COMMAND: u8 = DEVICE_RESET;
+    const RESPONSE_PAYLOAD: bool = false;
+    fn data_size(&self) -> usize {
+        0
+    }
+    fn write_packet_data(&self, buf: &mut [u8]) {
+        assert!(buf.len() == 0);
+        // nothing to write
+    }
+    fn parse_response(bytes: &[u8]) -> Result<Self::Response, IspError> {
+        if bytes.len() != 0 {
+            return Err(IspError::ResponseLength {
+                wrong_length: bytes.len(),
+            });
+        }
+        Ok(())
+    }
+}
+
+#[repr(C)]
+pub struct EraseFlash {
+    start: [u8; 4],
+    end: [u8; 4],
+}
+
+impl EraseFlash {
+    pub fn new(start_addr: u32, end_addr: u32) -> Self {
+        Self {
+            start: start_addr.to_le_bytes(),
+            end: end_addr.to_le_bytes(),
+        }
+    }
+}
+
+// Ref: https://github.com/pine64/blisp/blob/e45941c45e2418b2bb7e3dab49468a8f4d132439/lib/blisp.c#L355
+impl IspCommand for EraseFlash {
+    type Response = ();
+    const COMMAND: u8 = ERASE_FLASH;
+    const RESPONSE_PAYLOAD: bool = false;
+    fn data_size(&self) -> usize {
+        8
+    }
+    fn write_packet_data(&self, buf: &mut [u8]) {
+        assert!(buf.len() == 8);
+        buf[0..4].clone_from_slice(&self.start);
+        buf[4..8].clone_from_slice(&self.end);
+    }
+    fn parse_response(bytes: &[u8]) -> Result<Self::Response, IspError> {
+        if bytes.len() != 0 {
+            return Err(IspError::ResponseLength {
+                wrong_length: bytes.len(),
+            });
+        }
+        Ok(())
+    }
+}
+
+#[repr(C)]
+pub struct WriteFlash<'a> {
+    start: [u8; 4],
+    payload: &'a [u8],
+}
+
+impl<'a> WriteFlash<'a> {
+    pub fn new(start_addr: u32, payload: &'a [u8]) -> Self {
+        Self {
+            start: start_addr.to_le_bytes(),
+            payload,
+        }
+    }
+}
+
+// Ref: https://github.com/pine64/blisp/blob/e45941c45e2418b2bb7e3dab49468a8f4d132439/lib/blisp.c#L372
+impl<'a> IspCommand for WriteFlash<'a> {
+    type Response = ();
+    const COMMAND: u8 = WRITE_FLASH;
+    const RESPONSE_PAYLOAD: bool = false;
+    fn data_size(&self) -> usize {
+        4 + self.payload.len()
+    }
+    fn write_packet_data(&self, buf: &mut [u8]) {
+        buf[0..4].clone_from_slice(&self.start);
+        buf[4..].clone_from_slice(&self.payload);
+    }
+    fn parse_response(bytes: &[u8]) -> Result<Self::Response, IspError> {
+        if bytes.len() != 0 {
+            return Err(IspError::ResponseLength {
+                wrong_length: bytes.len(),
+            });
+        }
+        Ok(())
+    }
+}