[crypto, drivers, tests] Refactor crypto API to use StartOp/Process/EndOp pattern. Add null checks to all drivers

Author: AlexLanzano

boards/stm32wb55xx_nucleo/board.c

@@ -237,22 +237,10 @@ whal_Rng g_whalRng = {
 };
 
 /* Crypto */
-static const whal_Crypto_OpFunc cryptoOps[BOARD_CRYPTO_OP_COUNT] = {
-    [BOARD_CRYPTO_AES_ECB]  = whal_Stm32wbAes_AesEcb,
-    [BOARD_CRYPTO_AES_CBC]  = whal_Stm32wbAes_AesCbc,
-    [BOARD_CRYPTO_AES_CTR]  = whal_Stm32wbAes_AesCtr,
-    [BOARD_CRYPTO_AES_GCM]  = whal_Stm32wbAes_AesGcm,
-    [BOARD_CRYPTO_AES_GMAC] = whal_Stm32wbAes_AesGmac,
-    [BOARD_CRYPTO_AES_CCM]  = whal_Stm32wbAes_AesCcm,
-};
-
 whal_Crypto g_whalCrypto = {
     .regmap = { WHAL_STM32WB55_AES1_REGMAP },
     /* .driver: direct API mapping */
 
-    .ops = cryptoOps,
-    .opsCount = BOARD_CRYPTO_OP_COUNT,
-
     .cfg = &(whal_Stm32wbAes_Cfg) {
         .timeout = &g_whalTimeout,
     },

boards/stm32wb55xx_nucleo/board.h

@@ -41,15 +41,6 @@ enum {
 #define BOARD_FLASH_TEST_ADDR     0x0807F000
 #define BOARD_FLASH_SECTOR_SZ     0x1000
 
-enum {
-    BOARD_CRYPTO_AES_ECB,
-    BOARD_CRYPTO_AES_CBC,
-    BOARD_CRYPTO_AES_CTR,
-    BOARD_CRYPTO_AES_GCM,
-    BOARD_CRYPTO_AES_GMAC,
-    BOARD_CRYPTO_AES_CCM,
-    BOARD_CRYPTO_OP_COUNT,
-};
 
 whal_Error Board_Init(void);
 whal_Error Board_Deinit(void);

docs/getting_started.md

@@ -230,7 +230,7 @@ operation completed. The error codes are:
 | `WHAL_ENOTREADY` | Resource is busy or not yet available |
 | `WHAL_EHARDWARE` | Hardware error (e.g., RNG entropy failure) |
 | `WHAL_ETIMEOUT` | Operation timed out waiting for hardware |
-| `WHAL_ENOTIMPL` | Operation not implemented by this driver |
+| `WHAL_ENOTSUP` | Operation or parameter not supported by this driver/hardware |
 
 ## Optimizing for Size
 
@@ -281,7 +281,7 @@ static const whal_GpioDriver myGpioDriver = {
     .Init   = whal_Stm32wbGpio_Init,
     .Deinit = whal_Stm32wbGpio_Deinit,
     .Set    = whal_Stm32wbGpio_Set,
-    /* Get left as NULL — calls return WHAL_ENOTIMPL, saves pulling in that code */
+    /* Get left as NULL — calls return WHAL_ENOTSUP, saves pulling in that code */
 };
 
 whal_Gpio g_whalGpio = {

docs/writing_a_driver.md

@@ -515,10 +515,10 @@ transfer. The buffer must remain valid until the transfer completes. The
 driver signals completion through a platform-specific mechanism.
 
 Drivers that do not support async should set SendAsync to NULL in the vtable.
-The dispatch layer returns WHAL_ENOTIMPL when the caller tries to use any
+The dispatch layer returns WHAL_ENOTSUP when the caller tries to use any
 NULL vtable entry (or when the driver pointer itself is NULL). When direct
 API mapping is active, polled drivers provide stub implementations that
-return WHAL_ENOTIMPL directly.
+return WHAL_ENOTSUP directly.
 
 ### RecvAsync
 
@@ -527,8 +527,8 @@ transfer. The buffer must remain valid until the transfer completes.
 
 The async variants are optional — a driver vtable only needs to populate
 them if the platform supports non-blocking transfers. Polled-only drivers
-leave these NULL (the dispatch layer returns WHAL_ENOTIMPL) or provide
-stubs returning WHAL_ENOTIMPL (direct API mapping).
+leave these NULL (the dispatch layer returns WHAL_ENOTSUP) or provide
+stubs returning WHAL_ENOTSUP (direct API mapping).
 
 ---
 

src/block/block.c

@@ -7,7 +7,7 @@ inline whal_Error whal_Block_Init(whal_Block *blockDev)
     if (!blockDev)
         return WHAL_EINVAL;
     if (!blockDev->driver || !blockDev->driver->Init)
-        return WHAL_ENOTIMPL;
+        return WHAL_ENOTSUP;
 
     return blockDev->driver->Init(blockDev);
 }
@@ -17,7 +17,7 @@ inline whal_Error whal_Block_Deinit(whal_Block *blockDev)
     if (!blockDev)
         return WHAL_EINVAL;
     if (!blockDev->driver || !blockDev->driver->Deinit)
-        return WHAL_ENOTIMPL;
+        return WHAL_ENOTSUP;
 
     return blockDev->driver->Deinit(blockDev);
 }
@@ -28,7 +28,7 @@ inline whal_Error whal_Block_Read(whal_Block *blockDev, uint32_t block,
     if (!blockDev || !data)
         return WHAL_EINVAL;
     if (!blockDev->driver || !blockDev->driver->Read)
-        return WHAL_ENOTIMPL;
+        return WHAL_ENOTSUP;
 
     return blockDev->driver->Read(blockDev, block, data, blockCount);
 }
@@ -39,7 +39,7 @@ inline whal_Error whal_Block_Write(whal_Block *blockDev, uint32_t block,
     if (!blockDev || !data)
         return WHAL_EINVAL;
     if (!blockDev->driver || !blockDev->driver->Write)
-        return WHAL_ENOTIMPL;
+        return WHAL_ENOTSUP;
 
     return blockDev->driver->Write(blockDev, block, data, blockCount);
 }
@@ -50,7 +50,7 @@ inline whal_Error whal_Block_Erase(whal_Block *blockDev, uint32_t block,
     if (!blockDev)
         return WHAL_EINVAL;
     if (!blockDev->driver || !blockDev->driver->Erase)
-        return WHAL_ENOTIMPL;
+        return WHAL_ENOTSUP;
 
     return blockDev->driver->Erase(blockDev, block, blockCount);
 }

src/clock/clock.c

@@ -6,7 +6,7 @@ inline whal_Error whal_Clock_Init(whal_Clock *clkDev)
     if (!clkDev)
         return WHAL_EINVAL;
     if (!clkDev->driver || !clkDev->driver->Init)
-        return WHAL_ENOTIMPL;
+        return WHAL_ENOTSUP;
 
     return clkDev->driver->Init(clkDev);
 }
@@ -16,27 +16,27 @@ inline whal_Error whal_Clock_Deinit(whal_Clock *clkDev)
     if (!clkDev)
         return WHAL_EINVAL;
     if (!clkDev->driver || !clkDev->driver->Deinit)
-        return WHAL_ENOTIMPL;
+        return WHAL_ENOTSUP;
 
     return clkDev->driver->Deinit(clkDev);
 }
 
 inline whal_Error whal_Clock_Enable(whal_Clock *clkDev, const void *clk)
 {
-    if (!clkDev)
+    if (!clkDev || !clk)
         return WHAL_EINVAL;
     if (!clkDev->driver || !clkDev->driver->Enable)
-        return WHAL_ENOTIMPL;
+        return WHAL_ENOTSUP;
 
     return clkDev->driver->Enable(clkDev, clk);
 }
 
 inline whal_Error whal_Clock_Disable(whal_Clock *clkDev, const void *clk)
 {
-    if (!clkDev)
+    if (!clkDev || !clk)
         return WHAL_EINVAL;
     if (!clkDev->driver || !clkDev->driver->Disable)
-        return WHAL_ENOTIMPL;
+        return WHAL_ENOTSUP;
 
     return clkDev->driver->Disable(clkDev, clk);
 }

src/clock/stm32wb_rcc.c

@@ -258,9 +258,14 @@ whal_Error whal_Stm32wbRccMsi_Deinit(whal_Clock *clkDev)
 
 whal_Error whal_Stm32wbRcc_Enable(whal_Clock *clkDev, const void *clk)
 {
-    whal_Stm32wbRcc_Clk *stClk = (whal_Stm32wbRcc_Clk *)clk;
+    whal_Stm32wbRcc_Clk *stClk;
+
+    if (!clkDev || !clk) {
+        return WHAL_EINVAL;
+    }
+
+    stClk = (whal_Stm32wbRcc_Clk *)clk;
 
-    /* Set the peripheral's enable bit in the appropriate RCC enable register */
     whal_Reg_Update(clkDev->regmap.base, stClk->regOffset, stClk->enableMask,
                     whal_SetBits(stClk->enableMask, stClk->enablePos, 1));
 
@@ -269,9 +274,14 @@ whal_Error whal_Stm32wbRcc_Enable(whal_Clock *clkDev, const void *clk)
 
 whal_Error whal_Stm32wbRcc_Disable(whal_Clock *clkDev, const void *clk)
 {
-    whal_Stm32wbRcc_Clk *stClk = (whal_Stm32wbRcc_Clk *)clk;
+    whal_Stm32wbRcc_Clk *stClk;
+
+    if (!clkDev || !clk) {
+        return WHAL_EINVAL;
+    }
+
+    stClk = (whal_Stm32wbRcc_Clk *)clk;
 
-    /* Clear the peripheral's enable bit to gate its clock */
     whal_Reg_Update(clkDev->regmap.base, stClk->regOffset, stClk->enableMask,
                     whal_SetBits(stClk->enableMask, stClk->enablePos, 0));
 

src/crypto/crypto.c

@@ -4,32 +4,54 @@
 #ifndef WHAL_CFG_CRYPTO_API_MAPPING_STM32WB_AES
 whal_Error whal_Crypto_Init(whal_Crypto *cryptoDev)
 {
-    if (!cryptoDev || !cryptoDev->driver || !cryptoDev->driver->Init) {
+    if (!cryptoDev)
         return WHAL_EINVAL;
-    }
+    if (!cryptoDev->driver || !cryptoDev->driver->Init)
+        return WHAL_ENOTSUP;
 
     return cryptoDev->driver->Init(cryptoDev);
 }
 
 whal_Error whal_Crypto_Deinit(whal_Crypto *cryptoDev)
 {
-    if (!cryptoDev || !cryptoDev->driver || !cryptoDev->driver->Deinit) {
+    if (!cryptoDev)
         return WHAL_EINVAL;
-    }
+    if (!cryptoDev->driver || !cryptoDev->driver->Deinit)
+        return WHAL_ENOTSUP;
 
     return cryptoDev->driver->Deinit(cryptoDev);
 }
-#endif
 
-whal_Error whal_Crypto_Op(whal_Crypto *cryptoDev, size_t op, void *opArgs)
+whal_Error whal_Crypto_StartOp(whal_Crypto *cryptoDev, size_t opId,
+                               void *opArgs)
+{
+    if (!cryptoDev || !opArgs)
+        return WHAL_EINVAL;
+    if (!cryptoDev->driver || !cryptoDev->driver->StartOp)
+        return WHAL_ENOTSUP;
+
+    return cryptoDev->driver->StartOp(cryptoDev, opId, opArgs);
+}
+
+whal_Error whal_Crypto_Process(whal_Crypto *cryptoDev, size_t opId,
+                               void *opArgs)
 {
-    if (!cryptoDev || !cryptoDev->ops || !opArgs) {
+    if (!cryptoDev || !opArgs)
         return WHAL_EINVAL;
-    }
+    if (!cryptoDev->driver || !cryptoDev->driver->Process)
+        return WHAL_ENOTSUP;
+
+    return cryptoDev->driver->Process(cryptoDev, opId, opArgs);
+}
 
-    if (op >= cryptoDev->opsCount || !cryptoDev->ops[op]) {
+whal_Error whal_Crypto_EndOp(whal_Crypto *cryptoDev, size_t opId,
+                             void *opArgs)
+{
+    if (!cryptoDev || !opArgs)
         return WHAL_EINVAL;
-    }
+    if (!cryptoDev->driver || !cryptoDev->driver->EndOp)
+        return WHAL_ENOTSUP;
 
-    return cryptoDev->ops[op](cryptoDev, opArgs);
+    return cryptoDev->driver->EndOp(cryptoDev, opId, opArgs);
 }
+#endif