wolfSSL · AlexLanzano · Aug 31, 2026
diff --git a/.claude/skills/generate-driver-template/SKILL.md b/.claude/skills/generate-driver-template/SKILL.md
@@ -16,7 +16,7 @@ chosen automatically from the device type in Step 0:
 - **Mode B — board-level header-only driver** (clock, power, …): emits a single `.h` with a
   fixed `_BASE` macro and stubbed `static inline` helpers. No `.c`, no vtable, no device handle.
 
-This skill **only scaffolds one driver**. It does not touch `board.h`, the platform header,
+This skill **only scaffolds one driver**. It does not touch `wolfHAL_board.h`, the platform header,
 the Makefile, or CI. For a full chip-family port use `port-stm32-platform`.
 
 ## Inputs
@@ -157,15 +157,15 @@ the `timeout` field — use a peripheral-appropriate placeholder instead.
   ```c
   /*
    * @brief Fixed device instance. Defined in the driver TU
-   * from the WHAL_CFG_<PLAT>_<TYPE>_DEV initializer in board.h.
+   * from the WHAL_CFG_<PLAT>_<TYPE>_DEV initializer in wolfHAL_board.h.
    */
   extern const whal_<Type> whal_<Plat>_<Type>_Dev;
   ```
 - **multi**: guarded on the single-instance flag —
   ```c
   /*
    * @brief Fixed device instance. Defined in the driver TU
-   * from the WHAL_CFG_<PLAT>_<TYPE>_DEV initializer in board.h.
+   * from the WHAL_CFG_<PLAT>_<TYPE>_DEV initializer in wolfHAL_board.h.
    */
   #if defined(WHAL_CFG_<PLAT>_<TYPE>_SINGLE_INSTANCE)
   extern const whal_<Type> whal_<Plat>_<Type>_Dev;
@@ -210,11 +210,11 @@ const whal_<Type>Driver whal_<Plat>_<Type>_Driver = {
 ```
 
 `<BOARD_H_INCLUDE>`:
-- **single**: `#include "board.h"  /* provides WHAL_CFG_<PLAT>_<TYPE>_DEV initializer */`
+- **single**: `#include "wolfHAL_board.h"  /* provides WHAL_CFG_<PLAT>_<TYPE>_DEV initializer */`
 - **multi**:
   ```c
   #ifdef WHAL_CFG_<PLAT>_<TYPE>_SINGLE_INSTANCE
-  #include "board.h"  /* provides whal_<Plat>_<Type>_Dev device instance (possibly via platform alias macro) */
+  #include "wolfHAL_board.h"  /* provides whal_<Plat>_<Type>_Dev device instance (possibly via platform alias macro) */
   #endif
   ```
 
@@ -421,7 +421,7 @@ Print a short summary tailored to the mode:
 - The vtable members stubbed (so the user sees the surface they must implement).
 - What's intentionally left as TODO: register definitions, the `Cfg` fields, and each body.
 - That wiring this driver into a board still needs the platform-header base-address `#define`,
-  the `WHAL_CFG_<PLAT>_<TYPE>_DEV` initializer in `board.h`, and the Makefile/CI entries — point
+  the `WHAL_CFG_<PLAT>_<TYPE>_DEV` initializer in `wolfHAL_board.h`, and the Makefile/CI entries — point
   to `port-stm32-platform`.
 
 **Mode B:**

diff --git a/.claude/skills/port-stm32-platform/SKILL.md b/.claude/skills/port-stm32-platform/SKILL.md
@@ -55,11 +55,11 @@ The clock driver is almost always new per family. GPIO, I2C, and IWDG/WWDG are a
 
 **Clock is an architectural exception (2): no vtable, no device handle.** Unlike most driver types, the clock subsystem has no `whal_ClockDriver` vtable, no generic `whal_Clock_Init`/`Enable`/`Disable` API, and no `whal_Clock` handle at all. The chip's clock-controller `_BASE` macro lives at the top of the clock driver header (the platform header just includes the clock header and doesn't re-define `_BASE`). Chip clock drivers expose imperative `Enable*`/`Disable*`/`Set*` helpers (e.g. `whal_<Platform>_Rcc_EnableOsc`, `EnablePll`, `SetSysClock`, `EnablePeriphClk`) that take no device pointer; boards call them directly. The platform header does NOT define a `WHAL_<PLATFORM>_RCC_DRIVER` macro. Power follows the same shape — no handle, helpers take no device pointer, `_BASE` macro at the top of the power driver header.
 
-**Most other drivers are single-instance**, reading their cfg/base from a `whal_<Platform>_<Driver>_Dev` singleton that the driver `.c` defines from a `WHAL_CFG_<PLATFORM>_<DRIVER>_DEV` initializer macro in `board.h`. The driver header `extern`-declares the singleton. Two flavors:
+**Most other drivers are single-instance**, reading their cfg/base from a `whal_<Platform>_<Driver>_Dev` singleton that the driver `.c` defines from a `WHAL_CFG_<PLATFORM>_<DRIVER>_DEV` initializer macro in `wolfHAL_board.h`. The driver header `extern`-declares the singleton. Two flavors:
 - **Unconditional single-instance** for true singletons (one per chip): RNG, GPIO, NVIC, SysTick, Watchdog, Crypto, Hash, Ethernet, Flash. Driver body always reads from the singleton; NULL checks dropped. Examples: `src/rng/stm32wb_rng.c`, `src/eth/stm32n6_eth.c`.
 - **Conditional single-instance** gated on `WHAL_CFG_<PLATFORM>_<TYPE>_SINGLE_INSTANCE` for multi-instance peripherals (UART, SPI, I2C, DMA). Default builds keep the pointer-based path; boards opt in per device. Example: `src/uart/stm32wb_uart.c`.
 
-**Flash with peripheral coexistence (e.g. on-chip + SPI NOR W25Q64)**: the driver-owned singleton (defined in the driver `.c` from `WHAL_CFG_<PLATFORM>_FLASH_DEV` in `board.h`) carries `.driver`, `.base`, and `.cfg`. `BOARD_FLASH_DEV` casts its address (`((whal_Flash *)&whal_<Plat>_Flash_Dev)`) so generic `whal_Flash_*` calls can vtable-dispatch through it. There is no separate `g_whalFlash` stub. Reference: `boards/stm32wb55xx_nucleo/board.h` + `src/flash/stm32wb_flash.c`.
+**Flash with peripheral coexistence (e.g. on-chip + SPI NOR W25Q64)**: the driver-owned singleton (defined in the driver `.c` from `WHAL_CFG_<PLATFORM>_FLASH_DEV` in `wolfHAL_board.h`) carries `.driver`, `.base`, and `.cfg`. `BOARD_FLASH_DEV` casts its address (`((whal_Flash *)&whal_<Plat>_Flash_Dev)`) so generic `whal_Flash_*` calls can vtable-dispatch through it. There is no separate `g_whalFlash` stub. Reference: `boards/stm32wb55xx_nucleo/wolfHAL_board.h` + `src/flash/stm32wb_flash.c`.
 
 **Crypto is also an architectural exception.** Crypto uses per-algorithm device structs (`whal_AesGcm`, `whal_Sha256`, etc.) instead of a single `whal_Crypto` with generic dispatch. Each algo struct has `.crypto` (pointer to the hardware device), `.driver` (per-algo vtable with Oneshot/Start/Process/Finalize), and `.state` (driver-managed streaming state). `whal_Crypto` itself is a platform driver with just Init/Deinit for hardware lifecycle. Direct API mapping is per-algorithm (e.g. `WHAL_CFG_STM32WB_AES_GCM_DIRECT_API_MAPPING`), not per-device-type. See `docs/writing_a_driver.md` "Crypto" section. Reference: `wolfHAL/crypto/stm32wb_aes.h` and `wolfHAL/crypto/stm32wba_hash.h`.
 
@@ -84,7 +84,7 @@ Skeleton:
 #include <wolfHAL/uart/<platform>_uart.h>
 /* ...one include per device type... */
 
-/* Base addresses — referenced by board.h's WHAL_CFG_*_DEV initializers. */
+/* Base addresses — referenced by wolfHAL_board.h's WHAL_CFG_*_DEV initializers. */
 #define WHAL_<PLATFORM>_USART1_BASE  0x<addr>
 #define WHAL_<PLATFORM>_AES_BASE     0x<addr>
 #define WHAL_<PLATFORM>_FLASH_BASE   0x<addr>
@@ -139,7 +139,7 @@ typedef whal_<OrigPlatform><Type>_Cfg    whal_<NewPlatform><Type>_Cfg;
 typedef whal_<OrigPlatform><Type>_PinCfg whal_<NewPlatform><Type>_PinCfg;
 /* ...repeat for every exposed type... */
 
-/* Singleton alias — REQUIRED for any single-instance driver. board.h declares
+/* Singleton alias — REQUIRED for any single-instance driver. wolfHAL_board.h declares
  * the singleton using the new platform's name; this macro renames it at
  * preprocess time so the leaf driver's references resolve correctly. Place
  * unconditionally (not under any DIRECT_API_MAPPING guard). */
@@ -210,17 +210,17 @@ This is the same one-line pattern as the driver stub. The build system auto-disc
 
 Create `boards/<board_name>/` with:
 
-### `board.h`
+### `wolfHAL_board.h`
 
-Three concerns: extern declarations for pointer-based globals that still live in `board.c`, `WHAL_CFG_<PLAT>_<X>_DEV` initializer macros for each single-instance driver (the driver header `extern`-declares the singleton; the driver `.c` defines it from this initializer after `#include "board.h"`), and the `BOARD_<PERIPH>_DEV` macro block that lets tests/apps portably reach each peripheral. Follow `docs/adding_a_board.md`.
+Three concerns: extern declarations for pointer-based globals that still live in `wolfHAL_board.c`, `WHAL_CFG_<PLAT>_<X>_DEV` initializer macros for each single-instance driver (the driver header `extern`-declares the singleton; the driver `.c` defines it from this initializer after `#include "wolfHAL_board.h"`), and the `BOARD_<PERIPH>_DEV` macro block that lets tests/apps portably reach each peripheral. Follow `docs/adding_a_board.md`.
 
 Skeleton:
 
 ```c
 #include <wolfHAL/wolfHAL.h>
 #include <wolfHAL/platform/st/<chip>.h>
 
-/* Pointer-based globals — defined in board.c, declared here for reachability. */
+/* Pointer-based globals — defined in wolfHAL_board.c, declared here for reachability. */
 extern whal_Uart g_whalUart;
 
 extern whal_Timeout g_whalTimeout;
@@ -241,7 +241,7 @@ extern volatile uint32_t g_tick;
 /* Initializers for single-instance singletons. The driver header
  * extern-declares whal_<NewPlatform>_<X>_Dev; the driver .c writes
  *   const whal_<X> whal_<NewPlatform>_<X>_Dev = WHAL_CFG_<NEWPLATFORM>_<X>_DEV;
- * after #include "board.h". The board uses its own platform's prefix; if
+ * after #include "wolfHAL_board.h". The board uses its own platform's prefix; if
  * the driver is an alias of another platform's, the alias header bridges
  * the singleton name with a #define. */
 #define WHAL_CFG_<NEWPLATFORM>_GPIO_DEV { \
@@ -281,13 +281,13 @@ extern volatile uint32_t g_tick;
 }
 ```
 
-**Names follow the board's own platform.** `WHAL_CFG_STM32G4_IWDG_DEV` in a g4-board's board.h, with `whal_Stm32g4_Iwdg_Dev` as the singleton name. If the IWDG driver is an alias of wb's, the alias header bridges the singleton name (`#define whal_Stm32g4_Iwdg_Dev whal_Stm32wb_Iwdg_Dev`); the board supplies the initializer under the upstream platform's `WHAL_CFG_STM32WB_IWDG_DEV` name (because the leaf driver `.c` references that). Allowed cross-platform names: `whal_Nvic_Dev`, `whal_SysTick_Dev`, `whal_Lan8742a_Dev` (these are genuinely platform-agnostic).
+**Names follow the board's own platform.** `WHAL_CFG_STM32G4_IWDG_DEV` in a g4-board's wolfHAL_board.h, with `whal_Stm32g4_Iwdg_Dev` as the singleton name. If the IWDG driver is an alias of wb's, the alias header bridges the singleton name (`#define whal_Stm32g4_Iwdg_Dev whal_Stm32wb_Iwdg_Dev`); the board supplies the initializer under the upstream platform's `WHAL_CFG_STM32WB_IWDG_DEV` name (because the leaf driver `.c` references that). Allowed cross-platform names: `whal_Nvic_Dev`, `whal_SysTick_Dev`, `whal_Lan8742a_Dev` (these are genuinely platform-agnostic).
 
-**State for AEAD streaming** (AES GCM/CCM, HMAC) is a `static` variable in the driver `.c`. The `WHAL_CFG_<PLAT>_<ALGO>_DEV` initializer in board.h takes its address via the `.state` field.
+**State for AEAD streaming** (AES GCM/CCM, HMAC) is a `static` variable in the driver `.c`. The `WHAL_CFG_<PLAT>_<ALGO>_DEV` initializer in wolfHAL_board.h takes its address via the `.state` field.
 
-### `board.c`
+### `wolfHAL_board.c`
 
-Define remaining pointer-based globals (`g_whalUart` for the still-vtable-dispatched peripherals, `g_whalTimeout`, the SysTick handler) and implement `Board_Init`/`Board_Deinit`/`Board_WaitMs`. Single-instance singletons (flash included) live in their driver `.c` files, not here — `board.c` does not declare or initialize them.
+Define remaining pointer-based globals (`g_whalUart` for the still-vtable-dispatched peripherals, `g_whalTimeout`, the SysTick handler) and implement `Board_Init`/`Board_Deinit`/`Board_WaitMs`. Single-instance singletons (flash included) live in their driver `.c` files, not here — `wolfHAL_board.c` does not declare or initialize them.
 
 Init/Deinit call sites use `BOARD_<PERIPH>_DEV`, NOT the raw globals — this lets the board switch a peripheral between single-instance and pointer-based by flipping one macro:
 
@@ -300,10 +300,10 @@ err = whal_Timer_Init(BOARD_TIMER_DEV);
 
 Clock-tree bring-up is imperative — `whal_<Platform>_Rcc_EnableOsc(...)`, `EnablePll(...)`, `SetSysClock(...)`, `EnablePeriphClk(...)` take no device pointer (each reads the chip's fixed RCC base from the driver header).
 
-Implement `Board_Init` in dependency order: PWR → bring up clock tree imperatively (oscillator on, PLL configure+enable, sysclk switch) → enable peripheral clocks → GPIO → UART → Timer → the rest. Keep the watchdog out of `Board_Init` (the app starts it when ready to refresh) per `docs/adding_a_board.md`. Guard DMA-specific setup under `#ifdef BOARD_DMA`, matching `boards/stm32wba55cg_nucleo/board.c`.
+Implement `Board_Init` in dependency order: PWR → bring up clock tree imperatively (oscillator on, PLL configure+enable, sysclk switch) → enable peripheral clocks → GPIO → UART → Timer → the rest. Keep the watchdog out of `Board_Init` (the app starts it when ready to refresh) per `docs/adding_a_board.md`. Guard DMA-specific setup under `#ifdef BOARD_DMA`, matching `boards/stm32wba55cg_nucleo/wolfHAL_board.c`.
 
 ### GPIO pin conflict check
-After writing the `pinCfg` array in `board.c`, scan every entry pair and verify no two entries share the same physical port+pin. This is a common mistake when a pin serves double duty (e.g., PA5 used as both an LED and SPI1_SCK). If a conflict is found, consult the chip's alternate-function table in the datasheet and remap the conflicting peripheral to an alternate pin on a different port.
+After writing the `pinCfg` array in `wolfHAL_board.c`, scan every entry pair and verify no two entries share the same physical port+pin. This is a common mistake when a pin serves double duty (e.g., PA5 used as both an LED and SPI1_SCK). If a conflict is found, consult the chip's alternate-function table in the datasheet and remap the conflicting peripheral to an alternate pin on a different port.
 
 ### `board.mk`
 Model on `boards/stm32wba55cg_nucleo/board.mk`:
@@ -330,7 +330,7 @@ Add the new board to `.github/workflows/boards.yml` by appending it to the `boar
 
 1. `make BOARD=<board_name>` from the repo root. Fix errors in order. Typical failures:
    - Missing symbol for an aliased driver → the alias header is missing a `#define` for that function/type, or the stub `.c` isn't present.
-   - `'whal_Stm32<orig>_<Type>_Dev' undeclared` in a single-instance leaf driver → the alias header for the new platform is missing the `#define whal_Stm32<new>_<Type>_Dev whal_Stm32<orig>_<Type>_Dev` line, OR the board.h didn't provide `WHAL_CFG_STM32<ORIG>_<TYPE>_DEV` (the leaf `.c` defines the singleton from that name).
+   - `'whal_Stm32<orig>_<Type>_Dev' undeclared` in a single-instance leaf driver → the alias header for the new platform is missing the `#define whal_Stm32<new>_<Type>_Dev whal_Stm32<orig>_<Type>_Dev` line, OR the wolfHAL_board.h didn't provide `WHAL_CFG_STM32<ORIG>_<TYPE>_DEV` (the leaf `.c` defines the singleton from that name).
    - Duplicate symbol → the Makefile is picking up both `<newplatform>_*.c` and the original `<origplatform>_*.c`; restrict the wildcard to the new prefix only.
    - Implicit declaration warnings for `whal_Reg_*` / `whal_SetBits` in a stub include → you probably wrote `#include <wolfHAL/...>` with angle brackets in the stub instead of `#include "<origplatform>_<type>.c"` with quotes. The stub must use quoted include so the preprocessor finds the sibling `.c` in the same directory.
 2. Flash the binary (user runs this) and run the test suite. Each suite prints `PASS`, `FAIL`, or `SKIP`.

diff --git a/boards/README.md b/boards/README.md
@@ -34,13 +34,13 @@ Each board directory contains:
 - **`board.mk`** - Build configuration: toolchain, CPU flags, platform
   drivers, and linker script. Included by application Makefiles via
   `include $(BOARD_DIR)/board.mk`.
-- **`board.h`** - Board-level declarations: `extern` globals for vtable-dispatched
+- **`wolfHAL_board.h`** - Board-level declarations: `extern` globals for vtable-dispatched
   peripherals, `WHAL_CFG_<PLAT>_<X>_DEV` initializer macros consumed by each
   driver TU to define its `whal_<Plat>_<X>_Dev` singleton, `BOARD_<PERIPH>_DEV`
   macros that resolve to `WHAL_INTERNAL_DEV`, `&g_whal<X>`, or a cast pointer
   at one of those singletons (depending on how each peripheral is wired), pin
   definitions, and `Board_Init()`/`Board_Deinit()` prototypes.
-- **`board.c`** - Peripheral instantiation for vtable-dispatched drivers and
+- **`wolfHAL_board.c`** - Peripheral instantiation for vtable-dispatched drivers and
   `Board_Init()` implementation (power, clock, GPIO, UART, flash, timer).
 - **`linker.ld`** - Linker script defining memory regions (flash, RAM).
 - Any additional board-specific source files (e.g. interrupt vector table,
@@ -65,7 +65,7 @@ the base `board.mk` and adding additional sources.
 Board `board.mk` populates `BOARD_SOURCE` with all of the sources
 required to build the wolfHAL tests and sample applications for that board:
 
-- Board files: `board.c` and any additional board-specific source files
+- Board files: `wolfHAL_board.c` and any additional board-specific source files
 - Platform / SoC drivers: e.g. `pic32cz_*.c`, `stm32wb_*.c`
 - Architecture support: `systick.c` and any related startup / vector code
 - Core wolfHAL modules and common sources: generic dispatch sources such as
@@ -80,6 +80,6 @@ application Makefile to select a different set of modules.
 
 1. Create a new directory: `boards/<vendor>_<board>/`
 2. Add `board.mk` following the `_BOARD_DIR` pattern above
-3. Implement `board.h`, `board.c`, and `linker.ld`
+3. Implement `wolfHAL_board.h`, `wolfHAL_board.c`, and `linker.ld`
 4. Set `PLATFORM`, `TESTS`, toolchain variables, `CFLAGS`, and `BOARD_SOURCE`
 5. Build with `make BOARD=<your_board>`
diff --git a/boards/peripheral/block/sdhc_spi_sdcard32gb.c b/boards/peripheral/block/sdhc_spi_sdcard32gb.c
@@ -21,7 +21,7 @@
 
 #include "sdhc_spi_sdcard32gb.h"
 #include <wolfHAL/block/sdhc_spi_block.h>
-#include "board.h"
+#include "wolfHAL_board.h"
 
 static whal_Spi_ComCfg g_sdcardComCfg = {
     .freq = 25000000, /* 25 MHz */

diff --git a/boards/peripheral/board.mk b/boards/peripheral/board.mk
@@ -21,7 +21,7 @@
 
 _PERIPHERAL_DIR := $(patsubst %/,%,$(dir $(lastword $(MAKEFILE_LIST))))
 
-BOARD_SOURCE += $(_PERIPHERAL_DIR)/peripheral.c
+BOARD_SOURCE += $(_PERIPHERAL_DIR)/wolfHAL_peripheral.c
 
 ifneq ($(filter sdhc_spi_sdcard32gb,$(PERIPHERALS)),)
 CFLAGS += -DPERIPHERAL_SDHC_SPI_SDCARD32GB

diff --git a/boards/peripheral/display/sharp_ls013b7dh03.c b/boards/peripheral/display/sharp_ls013b7dh03.c
@@ -21,7 +21,7 @@
 
 #include "sharp_ls013b7dh03.h"
 #include <wolfHAL/display/sharp_memory_display.h>
-#include "board.h"
+#include "wolfHAL_board.h"
 
 /*
  * Sharp LS013B7DH03 - 128x128 monochrome memory LCD

diff --git a/boards/peripheral/flash/spi_nor_w25q64.c b/boards/peripheral/flash/spi_nor_w25q64.c
@@ -21,7 +21,7 @@
 
 #include "spi_nor_w25q64.h"
 #include <wolfHAL/flash/spi_nor_flash.h>
-#include "board.h"
+#include "wolfHAL_board.h"
 
 /*
  * Winbond W25Q64 — 64 Mbit (8 MB) SPI-NOR Flash

diff --git a/boards/peripheral/sensor/imu/bmi270.c b/boards/peripheral/sensor/imu/bmi270.c
@@ -21,7 +21,7 @@
 
 #include "bmi270.h"
 #include <wolfHAL/sensor/imu/bmi270_sensor.h>
-#include "board.h"
+#include "wolfHAL_board.h"
 
 /*
  * Bosch BMI270 — 6-axis IMU (accelerometer + gyroscope)
@@ -31,7 +31,7 @@
  * - Requires 8192-byte config blob upload during init
  *
  * The config blob is not bundled with wolfHAL. Obtain it from the Bosch
- * Sensortec BMI270_SensorAPI repository and provide it from your board.h:
+ * Sensortec BMI270_SensorAPI repository and provide it from your wolfHAL_board.h:
  *
  *     extern const uint8_t whal_bmi270_config_data[];
  *     #define WHAL_BMI270_CONFIG_DATA_SZ 8192

diff --git a/boards/peripheral/peripheral.c → boards/peripheral/wolfHAL_peripheral.c b/boards/peripheral/peripheral.c → boards/peripheral/wolfHAL_peripheral.c
@@ -1,4 +1,4 @@
-/* peripheral.c
+/* wolfHAL_peripheral.c
  *
  * Copyright (C) 2026 wolfSSL Inc.
  *
@@ -19,7 +19,7 @@
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335, USA
  */
 
-#include "peripheral.h"
+#include "wolfHAL_peripheral.h"
 
 #ifdef PERIPHERAL_SDHC_SPI_SDCARD32GB
 #include "block/sdhc_spi_sdcard32gb.h"

diff --git a/boards/peripheral/peripheral.h → boards/peripheral/wolfHAL_peripheral.h b/boards/peripheral/peripheral.h → boards/peripheral/wolfHAL_peripheral.h
@@ -1,4 +1,4 @@
-/* peripheral.h
+/* wolfHAL_peripheral.h
  *
  * Copyright (C) 2026 wolfSSL Inc.
  *
@@ -19,8 +19,8 @@
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335, USA
  */
 
-#ifndef BOARD_PERIPHERAL_H
-#define BOARD_PERIPHERAL_H
+#ifndef WOLFHAL_PERIPHERAL_H
+#define WOLFHAL_PERIPHERAL_H
 
 #include <wolfHAL/wolfHAL.h>
 #include <wolfHAL/block/block.h>
@@ -67,4 +67,4 @@ extern whal_PeripheralSensor_Cfg g_peripheralSensor[];
 whal_Error Peripheral_Init(void);
 whal_Error Peripheral_Deinit(void);
 
-#endif /* BOARD_PERIPHERAL_H */
+#endif /* WOLFHAL_PERIPHERAL_H */
diff --git a/boards/pic32cz_curiosity_ultra/board.mk b/boards/pic32cz_curiosity_ultra/board.mk
@@ -42,7 +42,7 @@ LINKER_SCRIPT ?= $(_BOARD_DIR)/linker.ld
 INCLUDE += -I$(_BOARD_DIR) -I$(WHAL_DIR)/boards/peripheral
 
 BOARD_SOURCE = $(_BOARD_DIR)/ivt.c
-BOARD_SOURCE += $(_BOARD_DIR)/board.c
+BOARD_SOURCE += $(_BOARD_DIR)/wolfHAL_board.c
 BOARD_SOURCE += $(wildcard $(WHAL_DIR)/src/*.c)
 BOARD_SOURCE += $(wildcard $(WHAL_DIR)/src/*/flash.c)
 BOARD_SOURCE += $(wildcard $(WHAL_DIR)/src/*/rng.c)