drivers: timer: Provide radio timer driver for STM32WB0x SoCs

Provide radio timer driver for STM32WB0x SoCs.

Signed-off-by: Ali Hozhabri <[email protected]>

Author: HoZHel

drivers/timer/stm32_radio_timer.c

@@ -0,0 +1,199 @@
+/* stm32_radio_timer.c - STM32WB0x Radio Timer */
+
+/*
+ * Copyright (c) 2025 STMicroelectronics
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+#include <zephyr/kernel.h>
+#include <zephyr/init.h>
+#include <zephyr/drivers/timer/system_timer.h>
+#include <zephyr/sys_clock.h>
+#include <zephyr/spinlock.h>
+#include <cmsis_core.h>
+#include <zephyr/irq.h>
+#include <zephyr/sys/util.h>
+#include <zephyr/drivers/counter.h>
+#include "stm32wb0x_hal_radio_timer.h"
+
+#include <zephyr/logging/log.h>
+LOG_MODULE_REGISTER(radio_timer_driver);
+
+/* Max HS startup time expressed in system time (1953 us / 2.4414 us) */
+#define MAX_HS_STARTUP_TIME	320
+#define BLE_WKUP_PRIO		0
+#define BLE_WKUP_FLAGS		0
+#define CPU_WKUP_PRIO		1
+#define CPU_WKUP_FLAGS		0
+#define RADIO_TIMER_ERROR_PRIO	3
+#define RADIO_TIMER_ERROR_FLAGS	0
+
+#define MULT64_THR_FREQ		(806)
+#define TIMER_MAX_VALUE		(0xFFFFFFFFU)
+#define TIMER_WRAPPING_MARGIN	(4096)
+#define MAX_ALLOWED_DELAY	(TIMER_MAX_VALUE - TIMER_WRAPPING_MARGIN)
+
+
+BUILD_ASSERT(DT_NODE_HAS_STATUS(DT_NODELABEL(clk_lsi), disabled),
+	     "At the moment, LSI is not supported");
+
+/* Translate STU to MTU and vice versa. It is implemented by using integer operations. */
+uint32_t blue_unit_conversion(uint32_t time, uint32_t period_freq, uint32_t thr);
+static uint64_t announced_cycles;
+
+static void radio_timer_error_isr(void *args)
+{
+	volatile uint32_t debug_cmd;
+
+	ARG_UNUSED(args);
+
+	BLUE->DEBUGCMDREG |= 1;
+	/* If the device is configured with CLK_SYS = 64MHz
+	 * and BLE clock = 16MHz, a register read is necessary
+	 * to ensure interrupt register is properly cleared
+	 * due to AHB down converter latency
+	 */
+	debug_cmd = BLUE->DEBUGCMDREG;
+	LOG_ERR("Timer error");
+}
+
+static void radio_timer_cpu_wkup_isr(void *args)
+{
+	int32_t dticks;
+	uint64_t diff_cycles;
+
+	ARG_UNUSED(args);
+
+	HAL_RADIO_TIMER_TimeoutCallback();
+	if (IS_ENABLED(CONFIG_TICKLESS_KERNEL)) {
+		diff_cycles = HAL_RADIO_TIMER_GetCurrentSysTime() - announced_cycles;
+		dticks = (int32_t)k_cyc_to_ticks_near64(diff_cycles);
+		announced_cycles += k_ticks_to_cyc_near32(dticks);
+		sys_clock_announce(dticks);
+	} else {
+		sys_clock_announce(1);
+	}
+}
+
+volatile uint32_t ciccio_k = 0;
+#if defined(CONFIG_SOC_STM32WB06) || defined(CONFIG_SOC_STM32WB07)
+static void radio_timer_txrx_wkup_isr(void *args)
+{
+	ARG_UNUSED(args);
+
+	HAL_RADIO_TIMER_WakeUpCallback();
+}
+#endif /* CONFIG_SOC_STM32WB06 || CONFIG_SOC_STM32WB07 */
+
+void sys_clock_set_timeout(int32_t ticks, bool idle)
+{
+	ARG_UNUSED(idle);
+
+	if (ticks == K_TICKS_FOREVER) {
+		return;
+	}
+
+#if defined(CONFIG_TICKLESS_KERNEL)
+	uint32_t current_time, delay;
+
+	/* This value is only valid for the LSE with a frequency of 32768 Hz.
+	 * The implementation for the LSI will be done in the future.
+	 */
+	uint32_t calibrationData_freq1 = 0x0028F5C2;
+
+	if (ticks < 1) {
+		ticks = 1;
+	}
+	//CLAMP(ticks, 1, (int32_t)MAX_TICKS);
+	delay = blue_unit_conversion(k_ticks_to_cyc_near32(ticks), calibrationData_freq1, MULT64_THR_FREQ) ;
+	if (delay > MAX_ALLOWED_DELAY) {
+		delay = MAX_ALLOWED_DELAY;
+	} else {
+		/* If the delay is too small round to minimum 2 ticks */
+		delay = MAX(32, delay);
+	}
+	current_time = LL_RADIO_TIMER_GetAbsoluteTime(WAKEUP);
+	/* 4 least significant bits are not taken into account. Then let's round the value */
+	LL_RADIO_TIMER_SetCPUWakeupTime(WAKEUP, ((current_time + (delay + 8)) & TIMER_MAX_VALUE));
+	LL_RADIO_TIMER_EnableWakeupTimerLowPowerMode(WAKEUP);
+	LL_RADIO_TIMER_EnableCPUWakeupTimer(WAKEUP);
+
+#endif /* CONFIG_TICKLESS_KERNEL */
+}
+
+uint32_t sys_clock_elapsed(void)
+{
+	if (!IS_ENABLED(CONFIG_TICKLESS_KERNEL)) {
+		return 0;
+	}
+
+	return k_cyc_to_ticks_near32(HAL_RADIO_TIMER_GetCurrentSysTime() - announced_cycles);
+}
+
+uint32_t sys_clock_cycle_get_32(void)
+{
+	uint64_t val64;
+
+	val64 = sys_clock_cycle_get_64();
+	return val64 & 0xFFFFFFFF;
+}
+
+uint64_t sys_clock_cycle_get_64(void)
+{
+	uint64_t cycles;
+
+	cycles = HAL_RADIO_TIMER_GetCurrentSysTime();
+	return cycles;
+}
+
+void sys_clock_disable(void)
+{
+#if defined(CONFIG_SOC_STM32WB06) || defined(CONFIG_SOC_STM32WB07)
+	irq_disable(RADIO_TIMER_TXRX_WKUP_IRQn);
+#endif /* CONFIG_SOC_STM32WB06 || CONFIG_SOC_STM32WB07 */
+	irq_disable(RADIO_TIMER_CPU_WKUP_IRQn);
+	irq_disable(RADIO_TIMER_ERROR_IRQn);
+	__HAL_RCC_RADIO_CLK_DISABLE();
+}
+
+static int sys_clock_driver_init(void)
+{
+	RADIO_TIMER_InitTypeDef VTIMER_InitStruct = {MAX_HS_STARTUP_TIME, 0, 0};
+
+#if defined(CONFIG_SOC_STM32WB06) || defined(CONFIG_SOC_STM32WB07)
+	IRQ_CONNECT(RADIO_TIMER_TXRX_WKUP_IRQn,
+				BLE_WKUP_PRIO,
+				radio_timer_txrx_wkup_isr,
+				NULL,
+				BLE_WKUP_FLAGS);
+#endif /* CONFIG_SOC_STM32WB06 || CONFIG_SOC_STM32WB07 */
+
+	IRQ_CONNECT(RADIO_TIMER_CPU_WKUP_IRQn,
+				CPU_WKUP_PRIO,
+				radio_timer_cpu_wkup_isr,
+				NULL,
+				CPU_WKUP_FLAGS);
+	IRQ_CONNECT(RADIO_TIMER_ERROR_IRQn,
+				RADIO_TIMER_ERROR_PRIO,
+				radio_timer_error_isr,
+				NULL,
+				RADIO_TIMER_ERROR_FLAGS);
+
+	/* Peripheral clock enable */
+	if (__HAL_RCC_RADIO_IS_CLK_DISABLED()) {
+		/* Radio reset */
+		__HAL_RCC_RADIO_FORCE_RESET();
+		__HAL_RCC_RADIO_RELEASE_RESET();
+
+		/* Enable Radio peripheral clock */
+		__HAL_RCC_RADIO_CLK_ENABLE();
+	}
+
+	/* Wait to be sure that the Radio Timer is active */
+	while (LL_RADIO_TIMER_GetAbsoluteTime(WAKEUP) < 0x10) {
+	}
+	HAL_RADIO_TIMER_Init(&VTIMER_InitStruct);
+	return 0;
+}
+
+SYS_INIT(sys_clock_driver_init, PRE_KERNEL_2, CONFIG_SYSTEM_CLOCK_INIT_PRIORITY);