[RFC] Integrate wolfHAL

.github/workflows/test-configs.yml

@@ -546,6 +546,12 @@ jobs:
       arch: arm
       config-file: ./config/examples/stm32wb.config
 
+  stm32wb_wolfhal_test:
+    uses: ./.github/workflows/test-build.yml
+    with:
+      arch: arm
+      config-file: ./config/examples/stm32wb-wolfhal.config
+
   # TODO: ti-tms570lc435.config requires F021 Flash API (Windows installer only)
   # ti_tms570lc435_test:
   #   uses: ./.github/workflows/test-build-ti-hercules.yml

.gitmodules

@@ -13,3 +13,6 @@
 [submodule "lib/wolfPSA"]
 	path = lib/wolfPSA
 	url = https://github.com/wolfSSL/wolfPSA.git
+[submodule "lib/wolfHAL"]
+	path = lib/wolfHAL
+	url = https://github.com/wolfSSL/wolfHAL.git

Makefile

@@ -142,20 +142,23 @@ WOLFBOOT_LIB_WOLFTPM?=lib/wolfTPM
 WOLFBOOT_LIB_WOLFPKCS11?=lib/wolfPKCS11
 WOLFBOOT_LIB_WOLFPSA?=lib/wolfPSA
 WOLFBOOT_LIB_WOLFHSM?=lib/wolfHSM
+WOLFBOOT_LIB_WOLFHAL?=lib/wolfHAL
 
 # Convert to absolute paths using abspath function
 WOLFBOOT_LIB_WOLFSSL:=$(abspath $(WOLFBOOT_LIB_WOLFSSL))
 WOLFBOOT_LIB_WOLFTPM:=$(abspath $(WOLFBOOT_LIB_WOLFTPM))
 WOLFBOOT_LIB_WOLFPKCS11:=$(abspath $(WOLFBOOT_LIB_WOLFPKCS11))
 WOLFBOOT_LIB_WOLFPSA:=$(abspath $(WOLFBOOT_LIB_WOLFPSA))
 WOLFBOOT_LIB_WOLFHSM:=$(abspath $(WOLFBOOT_LIB_WOLFHSM))
+WOLFBOOT_LIB_WOLFHAL:=$(abspath $(WOLFBOOT_LIB_WOLFHAL))
 
 # Export variables so they are available to sub-makefiles
 export WOLFBOOT_LIB_WOLFSSL
 export WOLFBOOT_LIB_WOLFTPM
 export WOLFBOOT_LIB_WOLFPKCS11
 export WOLFBOOT_LIB_WOLFPSA
 export WOLFBOOT_LIB_WOLFHSM
+export WOLFBOOT_LIB_WOLFHAL
 
 ## Architecture/CPU configuration
 include arch.mk
@@ -227,6 +230,13 @@ ifeq ($(TARGET),stm32h5)
 endif
 endif # TZEN=1
 
+ifeq ($(TARGET),wolfhal)
+	LSCRIPT_IN:=hal/$(WOLFHAL_TARGET).ld
+	CFLAGS+= -I$(WOLFBOOT_LIB_WOLFHAL)
+	OBJS+=hal/wolfHAL/$(WOLFHAL_BOARD).o
+	include hal/wolfHAL/$(WOLFHAL_BOARD).mk
+endif
+
 ifeq ($(TARGET),x86_64_efi)
     MAIN_TARGET:=wolfboot.efi
 endif

arch.mk

@@ -203,6 +203,12 @@ ifeq ($(ARCH),ARM)
     endif
   endif
 
+  ifeq ($(TARGET),wolfhal)
+	ifeq ($(WOLFHAL_TARGET),stm32wb)
+		ARCH_FLASH_OFFSET=0x08000000
+		SPI_TARGET=stm32
+	endif
+  endif
 
   ifeq ($(TARGET),stm32l5)
     CORTEX_M33=1

config/examples/stm32wb-wolfhal.config

@@ -0,0 +1,15 @@
+TARGET=wolfhal
+SIGN=ECC256
+HASH=SHA256
+WOLFBOOT_SECTOR_SIZE=0x1000
+WOLFBOOT_PARTITION_SIZE=0x20000
+WOLFBOOT_PARTITION_BOOT_ADDRESS=0x08010000
+WOLFBOOT_PARTITION_UPDATE_ADDRESS=0x08028000
+WOLFBOOT_PARTITION_SWAP_ADDRESS=0x08048000
+NVM_FLASH_WRITEONCE=1
+PKA=0
+WOLFHAL_TARGET=stm32wb
+WOLFHAL_BOARD=stm32wb55_nucleo
+WOLFHAL_FLASH_START=0x08000000
+WOLFHAL_FLASH_SIZE=0x100000
+WOLFHAL_NO_GPIO=1

hal/uart/uart_drv_wolfhal.c

@@ -0,0 +1,75 @@
+/* uart_drv_wolfhal.c
+ *
+ * A generic UART driver using the wolfHAL API module.
+ *
+ * Copyright (C) 2025 wolfSSL Inc.
+ *
+ * This file is part of wolfBoot.
+ *
+ * wolfBoot is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * wolfBoot is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335, USA
+ */
+
+#ifdef TARGET_wolfhal
+
+#include <stdint.h>
+#include <wolfHAL/wolfHAL.h>
+
+extern whal_Uart g_whalUart;
+
+int uart_tx(const uint8_t c)
+{
+    whal_Error err;
+    err = whal_Uart_Send(&g_whalUart, &c, 1);
+    if (err) {
+        return err;
+    }
+    return 1;
+}
+
+int uart_rx(uint8_t *c)
+{
+    whal_Error err;
+    err = whal_Uart_Recv(&g_whalUart, c, 1);
+    if (err) {
+        return err;
+    }
+    return 1;
+}
+
+int uart_init(uint32_t bitrate, uint8_t data, char parity, uint8_t stop)
+{
+    /* Handle these configure options in the wolfHAL UART config */
+    (void)bitrate;
+    (void)data;
+    (void)parity;
+    (void)stop;
+
+    whal_Error err;
+    err = whal_Uart_Init(&g_whalUart);
+    if (err) {
+        return err;
+    }
+
+    return 0;
+}
+
+#ifdef DEBUG_UART
+void uart_write(const char *buf, unsigned int len)
+{
+    whal_Uart_Send(&g_whalUart, (uint8_t *)buf, len);
+}
+#endif
+
+#endif /* TARGET_wolfhal */

hal/wolfHAL/stm32wb55_nucleo.c

@@ -0,0 +1,109 @@
+#include <wolfHAL/platform/st/stm32wb55xx.h>
+
+/*
+ * STM32WB55 Nucleo board configuration for wolfHAL.
+ *
+ * This file wires up the board-level clock, flash, GPIO, and optional UART
+ * instances used by wolfBoot. Most values are board defaults; override with
+ * build-time defines (e.g., DEBUG_UART/UART_FLASH) as needed.
+ */
+
+whal_Clock g_whalClock;
+whal_Flash g_whalFlash;
+
+/* Core clock controller (MSI -> PLL -> SYSCLK at 64 MHz). */
+whal_Clock g_whalClock = {
+    WHAL_STM32WB55_RCC_PLL_DEVICE,
+
+    .cfg = &(whal_Stm32wbRcc_Cfg) {
+        .flash = &g_whalFlash,
+        .flashLatency = WHAL_STM32WB_FLASH_LATENCY_3,
+
+        .sysClkSrc = WHAL_STM32WB_RCC_SYSCLK_SRC_PLL,
+        .sysClkCfg = &(whal_Stm32wbRcc_PllClkCfg)
+        {
+            .clkSrc = WHAL_STM32WB_RCC_PLLCLK_SRC_MSI,
+            /* 64 MHz */
+            .n = 32,
+            .m = 0,
+            .r = 1,
+            .q = 0,
+            .p = 0,
+        },
+    },
+};
+
+/* Internal flash mapping used by wolfBoot. */
+whal_Flash g_whalFlash = {
+    WHAL_STM32WB55_FLASH_DEVICE,
+
+    .cfg = &(whal_Stm32wbFlash_Cfg) {
+        .clkCtrl = &g_whalClock,
+        .clk = &(whal_Stm32wbRcc_Clk){WHAL_STM32WB55_FLASH_CLOCK},
+
+        .startAddr = 0x08000000,
+        .size = 0x100000,
+    },
+};
+
+#ifndef WOLFHAL_NO_GPIO
+/* GPIO pin configuration: LED on PB5 and optional UART1 pins. */
+whal_Stm32wbGpio_PinCfg g_whalPinCfg[] = {
+        { /* LED */
+            .port = WHAL_STM32WB_GPIO_PORT_B,
+            .pin = 5,
+            .mode = WHAL_STM32WB_GPIO_MODE_OUT,
+            .outType = WHAL_STM32WB_GPIO_OUTTYPE_PUSHPULL,
+            .speed = WHAL_STM32WB_GPIO_SPEED_LOW,
+            .pull = WHAL_STM32WB_GPIO_PULL_UP,
+            .altFn = 0,
+        },
+#if defined(DEBUG_UART) || defined(UART_FLASH)
+        { /* UART1 TX */
+            .port = WHAL_STM32WB_GPIO_PORT_B,
+            .pin = 6,
+            .mode = WHAL_STM32WB_GPIO_MODE_ALTFN,
+            .outType = WHAL_STM32WB_GPIO_OUTTYPE_PUSHPULL,
+            .speed = WHAL_STM32WB_GPIO_SPEED_FAST,
+            .pull = WHAL_STM32WB_GPIO_PULL_UP,
+            .altFn = 7,
+        },
+        { /* UART1 RX */
+            .port = WHAL_STM32WB_GPIO_PORT_B,
+            .pin = 7,
+            .mode = WHAL_STM32WB_GPIO_MODE_ALTFN,
+            .outType = WHAL_STM32WB_GPIO_OUTTYPE_PUSHPULL,
+            .speed = WHAL_STM32WB_GPIO_SPEED_FAST,
+            .pull = WHAL_STM32WB_GPIO_PULL_UP,
+            .altFn = 7,
+        },
+#endif /* DEBUG_UART || UART_FLASH */
+};
+
+/* GPIO controller for configured pins. */
+whal_Gpio g_whalGpio = {
+    WHAL_STM32WB55_GPIO_DEVICE,
+
+    .cfg = &(whal_Stm32wbGpio_Cfg) {
+        .clkCtrl = &g_whalClock,
+        .clk = &(whal_Stm32wbRcc_Clk) {WHAL_STM32WB55_GPIOB_CLOCK},
+
+        .pinCfg = g_whalPinCfg,
+        .pinCount = sizeof(g_whalPinCfg) / sizeof(whal_Stm32wbGpio_PinCfg),
+    },
+};
+#endif
+
+#if defined(DEBUG_UART) || defined(UART_FLASH)
+/* UART1 configuration for debug/flash operations. */
+whal_Uart g_whalUart = {
+    WHAL_STM32WB55_UART1_DEVICE,
+
+    .cfg = &(whal_Stm32wbUart_Cfg){
+        .clkCtrl = &g_whalClock,
+        .clk = &(whal_Stm32wbRcc_Clk) {WHAL_STM32WB55_UART1_CLOCK},
+
+        .baud = 115200,
+    },
+};
+#endif /* DEBUG_UART || UART_FLASH */

hal/wolfHAL/stm32wb55_nucleo.mk

@@ -0,0 +1,21 @@
+CFLAGS += -DWHAL_CFG_NO_CALLBACKS=1
+
+OBJS += $(WOLFBOOT_LIB_WOLFHAL)/src/reg.o
+
+OBJS += $(WOLFBOOT_LIB_WOLFHAL)/src/clock/stm32wb_rcc.o 	\
+		$(WOLFBOOT_LIB_WOLFHAL)/src/flash/stm32wb_flash.o
+
+APP_OBJS += $(WOLFBOOT_LIB_WOLFHAL)/src/reg.o
+
+APP_OBJS += $(WOLFBOOT_LIB_WOLFHAL)/src/clock/stm32wb_rcc.o 	\
+			$(WOLFBOOT_LIB_WOLFHAL)/src/flash/stm32wb_flash.o
+
+ifeq ($(WOLFHAL_NO_GPIO),)
+	OBJS += $(WOLFBOOT_LIB_WOLFHAL)/src/gpio/stm32wb_gpio.o
+	APP_OBJS += $(WOLFBOOT_LIB_WOLFHAL)/src/gpio/stm32wb_gpio.o
+endif
+
+ifeq ($(DEBUG_UART),1)
+	OBJS += $(WOLFBOOT_LIB_WOLFHAL)/src/uart/stm32wb_uart.o
+	APP_OBJS += $(WOLFBOOT_LIB_WOLFHAL)/src/uart/stm32wb_uart.o
+endif

hal/wolfhal.c

@@ -0,0 +1,78 @@
+/* stm32wb.c
+ *
+ * Copyright (C) 2025 wolfSSL Inc.
+ *
+ * This file is part of wolfBoot.
+ *
+ * wolfBoot is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * wolfBoot is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335, USA
+ */
+
+#include <stdint.h>
+#include <wolfHAL/wolfHAL.h>
+#include "image.h"
+
+extern whal_Clock g_whalClock;
+#ifndef WOLFHAL_NO_GPIO
+extern whal_Gpio g_whalGpio;
+#endif
+extern whal_Flash g_whalFlash;
+#if defined(DEBUG_UART) || defined(UART_FLASH)
+extern whal_Uart g_whalUart;
+#endif /* DEBUG_UART || UART_FLASH */
+
+void hal_init(void)
+{
+    whal_Error err;
+
+    err = whal_Clock_Init(&g_whalClock);
+    if (err) {
+        return;
+    }
+
+#ifndef WOLFHAL_NO_GPIO
+    err = whal_Gpio_Init(&g_whalGpio);
+    if (err) {
+        return;
+    }
+#endif
+
+    err = whal_Flash_Init(&g_whalFlash);
+    if (err) {
+        return;
+    }
+
+#if defined(DEBUG_UART) || defined(UART_FLASH)
+    err = whal_Uart_Init(&g_whalUart);
+    if (err) {
+        return;
+    }
+#endif /* DEBUG_UART || UART_FLASH */
+
+}
+
+void hal_prepare_boot(void)
+{
+#if defined(DEBUG_UART) || defined(UART_FLASH)
+    whal_Uart_Deinit(&g_whalUart);
+#endif /* DEBUG_UART || UART_FLASH */
+
+    whal_Flash_Deinit(&g_whalFlash);
+
+#ifndef WOLFHAL_NO_GPIO
+    whal_Gpio_Deinit(&g_whalGpio);
+#endif
+
+    whal_Clock_Deinit(&g_whalClock);
+}