simplelink: update hal to LPF3 SDK 8.10.00.55

Update simplelink lpf3 hal to the simplelink LPF3 SDK version
8.10.00.55.

Signed-off-by: Vebjorn Myklebust <[email protected]>

Author: vmyklebust

simplelink_lpf3/CMakeLists.txt

@@ -19,6 +19,7 @@ if(CONFIG_HAS_CC23X0_SDK)
 
     # Utils
     source/ti/drivers/utils/List.c
+    source/ti/drivers/utils/Random.c
 
     # Drivers
     source/ti/drivers/AESCCM.c
@@ -27,6 +28,7 @@ if(CONFIG_HAS_CC23X0_SDK)
     source/ti/drivers/AESCTRDRBG.c
     source/ti/drivers/AESECB.c
     source/ti/drivers/ECDH.c
+    source/ti/drivers/RNG.c
     source/ti/drivers/aesccm/AESCCMLPF3.c
     source/ti/drivers/aescmac/AESCMACLPF3.c
     source/ti/drivers/aesctr/AESCTRLPF3.c
@@ -37,6 +39,7 @@ if(CONFIG_HAS_CC23X0_SDK)
     source/ti/drivers/cryptoutils/sharedresources/CryptoResourceLPF3.c
     source/ti/drivers/cryptoutils/utils/CryptoUtils.c
     source/ti/drivers/dma/UDMALPF3.c
+    source/ti/drivers/rng/RNGLPF3RF.c
 
     source/ti/drivers/Temperature.c
     source/ti/drivers/power/PowerCC23X0.c

simplelink_lpf3/kernel/zephyr/dpl/EventP_zephyr.c

@@ -101,7 +101,6 @@ uint32_t EventP_pend(EventP_Handle event, uint32_t eventMask, bool waitForAll, u
 {
     uint32_t eventBits, tickPeriod;
     k_timeout_t eventTimeout;
-    uint64_t timeUS;
 
 
     if (timeout == EventP_WAIT_FOREVER)

simplelink_lpf3/source/ti/devices/cc23x0r5/driverlib/ckmd.h

@@ -560,65 +560,77 @@ __STATIC_INLINE uint32_t CKMDGetTargetAmplitudeThresholdTrim(void)
 
 //*****************************************************************************
 //
-//! \brief Gets the worst case LFOSC frequency jump due to RTN.
+//! \brief Gets the worst-case LFOSC frequency jump due to RTN.
 //!
-//! \return The absolute value of the worst case jump due to RTN in ppm.
+//! \return The absolute value of the worst-case jump due to RTN in ppm.
 //
 //*****************************************************************************
 __STATIC_INLINE uint_least16_t CKMDGetLfoscRtnPpm(void)
 {
-    uint8_t ppmRtn = 0x14;
+    // Only App trims revision 5 and newer has a ppmRtn field. For older
+    // revisions use a default value of 20 (equivalent to 600ppm)
+    uint8_t ppmRtn = 20;
     if (fcfg->appTrims.revision >= 0x5)
     {
         ppmRtn = fcfg->appTrims.cc23x0r5.lfOscParams.ppmRtn;
     }
+
+    // The ppmTempMid field uses units of 30ppm, convert to ppm
     return ppmRtn * 30;
 }
 
 //*****************************************************************************
 //
-//! \brief Gets the the worst case LFOSC temperature coefficient in the "middle"
+//! \brief Gets the the worst-case LFOSC temperature coefficient in the "middle"
 //! temperature range.
 //!
-//! This function can be used to determine the the worst case LFOSC temperature
+//! This function can be used to determine the the worst-case LFOSC temperature
 //! coefficient in units of ppm/C in the temperature range [
 //! \ref CKMD_LFOSC_MID_TEMP_COEFFICIENT_RANGE_MIN,
 //! \ref CKMD_LFOSC_MID_TEMP_COEFFICIENT_RANGE_MAX ].
 //!
-//! \return The absolute value of worst case temperature coefficient in ppm/C.
+//! \return The absolute value of worst-case temperature coefficient in ppm/C.
 //
 //*****************************************************************************
 __STATIC_INLINE uint_least16_t CKMDGetLfoscMidTempCoefficientPpmPerC(void)
 {
-    uint8_t ppmTempMid = 0x14;
+    // Only App trims revision 5 and newer has a ppmTempMid field. For older
+    // revisions use a default value of 20 (equivalent to 260ppm/C)
+    uint8_t ppmTempMid = 20;
     if (fcfg->appTrims.revision >= 0x5)
     {
         ppmTempMid = fcfg->appTrims.cc23x0r5.lfOscParams.ppmTempMid;
     }
+
+    // The ppmTempMid field uses units of 13ppm/C, convert to ppm/C
     return ppmTempMid * 13;
 }
 
 //*****************************************************************************
 //
-//! \brief Gets the the worst case LFOSC temperature coefficient in the
+//! \brief Gets the the worst-case LFOSC temperature coefficient in the
 //! "extended" temperature range.
 //!
-//! This function can be used to determine the the worst case LFOSC temperature
+//! This function can be used to determine the the worst-case LFOSC temperature
 //! coefficient in units of ppm/C when the temperature is outside of the
 //! temperature range [
 //! \ref CKMD_LFOSC_MID_TEMP_COEFFICIENT_RANGE_MIN,
 //! \ref CKMD_LFOSC_MID_TEMP_COEFFICIENT_RANGE_MAX ].
 //!
-//! \return The absolute value of worst case temperature coefficient in ppm/C.
+//! \return The absolute value of worst-case temperature coefficient in ppm/C.
 //
 //*****************************************************************************
 __STATIC_INLINE uint_least16_t CKMDGetLfoscExtTempCoefficientPpmPerC(void)
 {
-    uint8_t ppmTempExt = 0x14;
+    // Only App trims revision 5 and newer has a ppmTempExt field. For older
+    // revisions use a default value of 20 (equivalent to 700ppm/C)
+    uint8_t ppmTempExt = 20;
     if (fcfg->appTrims.revision >= 0x5)
     {
         ppmTempExt = fcfg->appTrims.cc23x0r5.lfOscParams.ppmTempExt;
     }
+
+    // The ppmTempExt field uses units of 35ppm/C, convert to ppm/C
     return ppmTempExt * 35;
 }
 

simplelink_lpf3/source/ti/devices/cc23x0r5/driverlib/cpu.c

@@ -4,7 +4,7 @@
  *  Description:    Instruction wrappers for special CPU instructions needed by
  *                  the drivers.
  *
- *  Copyright (c) 2022 Texas Instruments Incorporated
+ *  Copyright (c) 2022-2023 Texas Instruments Incorporated
  *
  *  Redistribution and use in source and binary forms, with or without
  *  modification, are permitted provided that the following conditions are met:
@@ -57,41 +57,36 @@ void CPUDelay(uint32_t count)
     #pragma diag_suppress = Pe940
 }
     #pragma diag_default  = Pe940
-
-#elif defined(__TI_COMPILER_VERSION__)
-// For CCS implement this function in pure assembly. This prevents the TI
-// compiler from doing funny things with the optimizer.
-
-// Loop the specified number of times
-__asm("    .sect \".text:CPUDelay\"\n"
-      "    .clink\n"
-      "    .thumbfunc CPUDelay\n"
-      "    .thumb\n"
-      "    .global CPUDelay\n"
-      "CPUDelay:\n"
-      "    subs r0, #1\n"
-      "    bne.n CPUDelay\n"
-      "    bx lr\n");
-
 #elif defined(__clang__)
-void CPUDelay(uint32_t count)
+void __attribute__((naked)) CPUDelay(uint32_t count)
 {
-    (void)count; // Linter does not see the use of r0 in asm.
-    // Loop the specified number of times
-    __asm("    subs    r0, #1\n"
-          "    bne.n   CPUDelay\n"
-          "    bx      lr");
+    // Loop the specified number of times.
+    // The naked attribute tells the compiler that the function is effectively
+    // hand-coded assembly implemented using inlined assembly without operands.
+    // As such, it assumes that the C calling conventions are obeyed, and we can
+    // assume count is in R0.
+    __asm volatile("CPUdel%=:\n"
+                   "    subs r0, #1\n"
+                   "    bne   CPUdel%=\n"
+                   "    bx    lr\n"
+                   :            /* No output */
+                   :            /* No input */
+                   : "r0", "cc" /* Clobbers. "cc" is the flags */
+    );
 }
-#else
-// GCC
+#elif defined(__GNUC__)
 void __attribute__((naked)) CPUDelay(uint32_t count)
 {
     // Loop the specified number of times
     __asm volatile(".syntax unified\n"
-                   "%=:  subs  %0, #1\n"
-                   "     bne   %=b\n"
-                   "     bx    lr\n"
-                   : /* No output */
-                   : "r"(count));
+                   "CPUdel%=:\n"
+                   "    subs  %0, #1\n"
+                   "    bne   CPUdel%=\n"
+                   "    bx    lr\n"
+                   :            /* No output */
+                   : "r"(count) /* Input */
+    );
 }
+#else
+    #error "Unsupported toolchain!"
 #endif

simplelink_lpf3/source/ti/devices/cc23x0r5/driverlib/cpu.h

@@ -4,7 +4,7 @@
  *  Description:    Defines and prototypes for the CPU instruction wrapper
  *                  functions.
  *
- *  Copyright (c) 2022 Texas Instruments Incorporated
+ *  Copyright (c) 2022-2023 Texas Instruments Incorporated
  *
  *  Redistribution and use in source and binary forms, with or without
  *  modification, are permitted provided that the following conditions are met:
@@ -69,31 +69,25 @@ extern "C" {
 //
 //! \brief Provide a small non-zero delay using a simple loop counter.
 //!
-//! This function provides means for generating a constant length delay. It
-//! is written in assembly to keep the delay consistent across tool chains,
+//! This function provides means for generating a constant length delay. It is
+//! written in assembly to keep the delay consistent across tool chains,
 //! avoiding the need to tune the delay based on the tool chain in use.
 //!
-//! \note It is not recommended using this function for long delays.
-//!
-//! Notice that interrupts can affect the delay if not manually disabled in advance.
-//!
-//! The delay depends on where code resides and the path for code fetching:
-//! - Code in flash, cache enabled, prefetch enabled  : 4 cycles per loop (Default)
-//! - Code in flash, cache enabled, prefetch disabled : 5 cycles per loop
-//! - Code in flash, cache disabled                   : 7 cycles per loop
-//! - Code in SRAM                                    : 6 cycles per loop
-//! - Code in GPRAM                                   : 3 cycles per loop
+//! \note It is not recommended using this function for long delays. For longer
+//! delays, consider using ROM function \ref HapiWaitUs().
 //!
 //! \note If using an RTOS, consider using RTOS provided delay functions because
 //! these will not block task scheduling and will potentially save power.
 //!
-//! Calculate delay count based on the wanted delay in microseconds (us):
-//! - count = [delay in us] * [CPU clock in MHz] / [cycles per loop]
+//! \note Interrupts can affect the delay if not manually disabled in advance.
+//!
+//! \note The delay depends on where code resides and the path for code
+//! fetching, consider using ROM function \ref HapiWaitUs().
 //!
-//! Example: 250 us delay with code in flash and with cache and prefetch enabled:
-//! - count = 250 * 48 / 4 = 3000
+//! \param count is the number of delay loop iterations to perform. Number must
+//! be greater than zero.
 //!
-//! \param count is the number of delay loop iterations to perform. Number must be greater than zero.
+//! \sa HapiWaitUs()
 //!
 //! \return None
 //

simplelink_lpf3/source/ti/devices/cc23x0r5/driverlib/hapi.h

@@ -86,7 +86,7 @@ typedef struct
     // 16: SHA256: Round constants
     const uint32_t (*sha256SW_K256)[64];
     // 17: SHA256: Initial constants
-    const uint32_t (*sha256SW_initialDigest256)[8];
+    const uint32_t (*sha256Sw_initialDigest256)[8];
     // 18: Busy loop that waits for nUs microseconds
     void (*waitUs)(uint32_t nUs);
     // 19: Count leading zeros
@@ -456,13 +456,13 @@ typedef struct
 #define HapiResetDevice() HAPI_TABLE_POINTER->resetDevice()
 
 // HAPI entry used for internal purposes
-#define HapiSha256SWProcessBlock(d, w) HAPI_TABLE_POINTER->pSHA256SWProcessBlock((d), (w))
+#define HapiSha256SwProcessBlock(d, w) HAPI_TABLE_POINTER->sha256SwProcessBlock((d), (w))
 
 // HAPI entry used for internal purposes
-#define HapiSha256SW_K256 (*HAPI_TABLE_POINTER->sha256SW_K256)
+#define HapiSha256Sw_K256 (*HAPI_TABLE_POINTER->sha256SW_K256)
 
 // HAPI entry used for internal purposes
-#define HapiSha256SW_initialDigest256 (*HAPI_TABLE_POINTER->sha256SW_initialDigest256)
+#define HapiSha256Sw_initialDigest256 (*HAPI_TABLE_POINTER->sha256Sw_initialDigest256)
 
 // void HapiWaitUs(uint32_t nUs)
 /*****************************************************************************

simplelink_lpf3/source/ti/devices/cc23x0r5/driverlib/lrfd.c

@@ -3,7 +3,7 @@
  *
  *  Description:    Driver for LRFD
  *
- *  Copyright (c) 2023 Texas Instruments Incorporated
+ *  Copyright (c) 2023-2024 Texas Instruments Incorporated
  *
  *  Redistribution and use in source and binary forms, with or without
  *  modification, are permitted provided that the following conditions are met:
@@ -44,7 +44,6 @@
 #include "../driverlib/interrupt.h"
 
 static uint16_t lrfdClockDependencySets[LRFD_NUM_CLK_DEP];
-static bool lrfdClocked = false;
 
 //*****************************************************************************
 //
@@ -81,21 +80,23 @@ void LRFDReleaseClockDependency(uint16_t mask, uint8_t dependencySetId)
 //*****************************************************************************
 void LRFDApplyClockDependencies(void)
 {
-    uint16_t clkctl = 0;
+    uint16_t clkctl  = 0;
+    bool lrfdClocked = (HWREG(CLKCTL_BASE + CLKCTL_O_CLKCFG0) & CLKCTL_CLKCFG0_LRFD_M) == CLKCTL_CLKCFG0_LRFD_CLK_EN;
     for (int i = 0; i < LRFD_NUM_CLK_DEP; i++)
     {
         clkctl |= lrfdClockDependencySets[i];
     }
 
     if (lrfdClocked)
     {
-        /* BRIDGE bit should not be needed, as hardware will automatically enable the clock when
-           needed. The bit should be always be 0 in the HW, and is thus cleared. */
+        // BRIDGE bit should not be needed, as hardware will automatically
+        // enable the clock when needed. The bit should be always be 0 in the
+        // HW, and is thus cleared.
         HWREG(LRFDDBELL_BASE + LRFDDBELL_O_CLKCTL) = clkctl & ~LRFDDBELL_CLKCTL_BRIDGE_M;
 
         if (clkctl == 0)
         {
-            /* Disable LRFD module clock */
+            // Disable LRFD module clock
             HWREG( CLKCTL_BASE + CLKCTL_O_CLKENCLR0 ) = CLKCTL_CLKENCLR0_LRFD;
             lrfdClocked                               = false;
         }
@@ -104,14 +105,19 @@ void LRFDApplyClockDependencies(void)
     {
         if (clkctl != 0)
         {
-            /* Enable LRFD module clock */
+            // Enable LRFD module clock
             HWREG( CLKCTL_BASE + CLKCTL_O_CLKENSET0 ) = CLKCTL_CLKENSET0_LRFD;
-            lrfdClocked                               = true;
 
-            /* BRIDGE bit should not be needed, as hardware will automatically enable the clock when
-               needed. The bit should be always be 0 in the HW, and is thus cleared. The bit can be
-               used in the input to indicate the need for the LRFD module clock to be enabled, but no
-               internal LRFD clocks. */
+            // Wait for LRFD clock to be enabled. It is not expected that the
+            // LRFD clock will ever not be enabled, but this will add sufficient
+            // delay before enabling the internal LRFD clocks below.
+            while ((HWREG(CLKCTL_BASE + CLKCTL_O_CLKCFG0) & CLKCTL_CLKCFG0_LRFD_M) != CLKCTL_CLKCFG0_LRFD_CLK_EN) {}
+
+            // BRIDGE bit should not be needed, as hardware will automatically
+            // enable the clock when needed. The bit should be always be 0 in
+            // the HW, and is thus cleared. The bit can be used in the input to
+            // indicate the need for the LRFD module clock to be enabled, but no
+            // internal LRFD clocks.
             HWREG(LRFDDBELL_BASE + LRFDDBELL_O_CLKCTL) = clkctl & ~LRFDDBELL_CLKCTL_BRIDGE_M;
         }
     }