simplelink: ti: devices: Add support for CC2340R5

Add initial lpf3 content to support cc2340r5. Currently, this includes
files necessary to support power management and drivers.
All files are added seperately from lpf2 content, which introduces a new
folder structure in the TI HAL.

Signed-off-by: Vebjorn Myklebust <[email protected]>
Signed-off-by: Lars Thalian Morstad <[email protected]>
Signed-off-by: Stoyan Bogdanov <[email protected]>

Author: vmyklebust

CMakeLists.txt

@@ -1 +1,2 @@
 add_subdirectory(simplelink)
+add_subdirectory(simplelink_lpf3)

simplelink_lpf3/CMakeLists.txt

@@ -0,0 +1,31 @@
+add_subdirectory(source/ti/devices)
+
+if(CONFIG_HAS_CC23X0_SDK)
+
+  if(CONFIG_SOC_CC2340R5)
+    zephyr_compile_definitions(DeviceFamily_CC23X0R5 ${COMPILER})
+  endif()
+
+  zephyr_include_directories(
+    .
+    source
+    )
+
+  zephyr_library()
+  zephyr_library_compile_definitions(${COMPILER})
+  zephyr_library_sources(
+    # Utils
+    source/ti/drivers/utils/List.c
+
+    # Drivers
+    source/ti/drivers/Temperature.c
+    source/ti/drivers/power/PowerCC23X0.c
+    source/ti/drivers/temperature/TemperatureLPF3.c
+    source/ti/drivers/batterymonitor/BatMonSupportLPF3.c
+    source/ti/drivers/batterymonitor/BatteryMonitorLPF3.c
+
+    # DPL
+    kernel/zephyr/dpl/ClockP_zephyr.c
+    kernel/zephyr/dpl/HwiP_zephyr.c
+    )
+endif()

simplelink_lpf3/kernel/zephyr/dpl/ClockP_zephyr.c

@@ -0,0 +1,200 @@
+/*
+ * Copyright (c) 2024, Texas Instruments Incorporated
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+#include <zephyr/kernel.h>
+#include <zephyr/sys/__assert.h>
+#include <zephyr/sys_clock.h>
+#include <ti/drivers/dpl/ClockP.h>
+
+/*
+ * ClockP_STRUCT_SIZE in ClockP.h must be updated to match the size of this
+ * struct
+ */
+typedef struct _ClockP_Obj
+{
+    struct k_timer timer;
+    ClockP_Fxn clock_fxn;
+    uintptr_t arg;
+    uint32_t timeout;
+    uint32_t period;
+    bool active;
+} ClockP_Obj;
+
+static ClockP_Params ClockP_defaultParams = {
+    .startFlag = false,
+    .period    = 0,
+    .arg       = 0,
+};
+
+static void expiry_fxn(struct k_timer *timer_id)
+{
+    ClockP_Obj *obj = (ClockP_Obj *)k_timer_user_data_get(timer_id);
+
+    obj->clock_fxn(obj->arg);
+}
+
+/*
+ *  ======== ClockP_construct ========
+ */
+ClockP_Handle ClockP_construct(ClockP_Struct *handle, ClockP_Fxn clockFxn, uint32_t timeout, ClockP_Params *params)
+{
+    ClockP_Obj *obj = (ClockP_Obj *)handle;
+
+    if (handle == NULL)
+    {
+        return NULL;
+    }
+
+    if (params == NULL)
+    {
+        params = &ClockP_defaultParams;
+    }
+
+    obj->clock_fxn = clockFxn;
+    obj->arg       = params->arg;
+    obj->period    = params->period * ClockP_getSystemTickPeriod() / USEC_PER_MSEC;
+    obj->timeout   = timeout;
+    obj->active    = false;
+
+    k_timer_init(&obj->timer, expiry_fxn, NULL);
+    k_timer_user_data_set(&obj->timer, obj);
+
+    if (params->startFlag)
+    {
+        ClockP_start(obj);
+    }
+
+    return ((ClockP_Handle)handle);
+}
+
+/*
+ *  ======== ClockP_getSystemTickPeriod ========
+ */
+uint32_t ClockP_tickPeriod = (USEC_PER_SEC / CONFIG_SYS_CLOCK_TICKS_PER_SEC);
+uint32_t ClockP_getSystemTickPeriod()
+{
+    return ClockP_tickPeriod;
+}
+
+uint32_t ClockP_getSystemTicks()
+{
+    return (uint32_t)k_ms_to_ticks_ceil32(k_uptime_get_32());
+}
+
+/*
+ *  ======== ClockP_Params_init ========
+ */
+void ClockP_Params_init(ClockP_Params *params)
+{
+    params->arg       = 0;
+    params->startFlag = false;
+    params->period    = 0;
+}
+
+/*
+ *  ======== ClockP_setTimeout ========
+ */
+void ClockP_setTimeout(ClockP_Handle handle, uint32_t timeout)
+{
+    ClockP_Obj *obj = (ClockP_Obj *)handle;
+
+    obj->timeout = timeout;
+}
+
+/*
+ *  ======== ClockP_start ========
+ */
+void ClockP_start(ClockP_Handle handle)
+{
+    ClockP_Obj *obj = (ClockP_Obj *)handle;
+    int32_t timeout;
+    int32_t period;
+
+    __ASSERT_NO_MSG(obj->timeout / CONFIG_SYS_CLOCK_TICKS_PER_SEC <= UINT32_MAX / USEC_PER_MSEC);
+    __ASSERT_NO_MSG(obj->period / CONFIG_SYS_CLOCK_TICKS_PER_SEC <= UINT32_MAX / USEC_PER_MSEC);
+
+    /* Avoid overflow */
+    if (obj->timeout > UINT32_MAX / USEC_PER_MSEC)
+    {
+        timeout = obj->timeout / CONFIG_SYS_CLOCK_TICKS_PER_SEC * USEC_PER_MSEC;
+    }
+    else if ((obj->timeout != 0) && (obj->timeout < CONFIG_SYS_CLOCK_TICKS_PER_SEC / USEC_PER_MSEC))
+    {
+        /* For small timeouts we use 1 msec */
+        timeout = 1;
+    }
+    else
+    {
+        timeout = obj->timeout * USEC_PER_MSEC / CONFIG_SYS_CLOCK_TICKS_PER_SEC;
+    }
+
+    if (obj->period > UINT32_MAX / USEC_PER_MSEC)
+    {
+        period = obj->period / CONFIG_SYS_CLOCK_TICKS_PER_SEC * USEC_PER_MSEC;
+    }
+    else if ((obj->period != 0) && (obj->period < CONFIG_SYS_CLOCK_TICKS_PER_SEC / USEC_PER_MSEC))
+    {
+        period = 1;
+    }
+    else
+    {
+        period = obj->period * USEC_PER_MSEC / CONFIG_SYS_CLOCK_TICKS_PER_SEC;
+    }
+
+    k_timer_start(&obj->timer, K_MSEC(timeout), K_MSEC(period));
+
+    obj->active = true;
+}
+
+/*
+ *  ======== ClockP_stop ========
+ */
+void ClockP_stop(ClockP_Handle handle)
+{
+    ClockP_Obj *obj = (ClockP_Obj *)handle;
+
+    k_timer_stop(&obj->timer);
+    obj->active = false;
+}
+
+/*
+ *  ======== ClockP_usleep ========
+ */
+void ClockP_usleep(uint32_t usec)
+{
+    k_sleep(K_USEC(usec));
+}
+
+/*
+ *  ======== ClockP_getTimeout ========
+ */
+uint32_t ClockP_getTimeout(ClockP_Handle handle)
+{
+    ClockP_Obj *obj = (ClockP_Obj *)handle;
+    return k_timer_remaining_get(&obj->timer) * CONFIG_SYS_CLOCK_TICKS_PER_SEC / USEC_PER_MSEC;
+}
+
+/*
+ *  ======== ClockP_isActive ========
+ */
+bool ClockP_isActive(ClockP_Handle handle)
+{
+    ClockP_Obj *obj = (ClockP_Obj *)handle;
+    return obj->active;
+}
+
+void ClockP_destruct(ClockP_Struct *clockP)
+{
+    ClockP_Obj *obj = (ClockP_Obj *)clockP->data;
+
+    obj->clock_fxn = NULL;
+    obj->arg       = 0;
+    obj->period    = 0;
+    obj->timeout   = 0;
+    obj->active    = false;
+
+    k_timer_stop(&obj->timer);
+}