[nrf fromlist] drivers: serial: nrfx_uarte: Request hsfll clock for fast instance

Request fast global domain to run at 320 MHz during fast UARTE
activity. As request is asynchronous it cannot be called from
an ISR. Due to complexity to handle that without device runtime
power management a requirement is added so that if fast UARTE
is used device runtime PM must be enabled. Clock is request
and released in PM resume and suspended actions which in case
of fast UARTE are only called from thread context.

Upstream PR #: 82103

Signed-off-by: Krzysztof Chruściński <[email protected]>

Author: nordic-krch

drivers/serial/Kconfig.nrfx

@@ -101,6 +101,11 @@ rsource "Kconfig.nrfx_uart_instance"
 endif
 
 if HAS_HW_NRF_UARTE120
+
+config UART_NRFX_UARTE_USE_CLOCK_CONTROL
+	def_bool y
+	select CLOCK_CONTROL
+
 nrfx_uart_num = 120
 rsource "Kconfig.nrfx_uart_instance"
 endif

drivers/serial/uart_nrfx_uarte.c

@@ -23,10 +23,7 @@
 #include <zephyr/linker/devicetree_regions.h>
 #include <zephyr/irq.h>
 #include <zephyr/logging/log.h>
-
-#ifdef CONFIG_SOC_NRF54H20_GPD
-#include <nrf/gpd.h>
-#endif
+#include <zephyr/drivers/clock_control/nrf_clock_control.h>
 
 LOG_MODULE_REGISTER(uart_nrfx_uarte, CONFIG_UART_LOG_LEVEL);
 
@@ -110,18 +107,22 @@ LOG_MODULE_REGISTER(uart_nrfx_uarte, CONFIG_UART_LOG_LEVEL);
 #define UARTE_ANY_LOW_POWER 1
 #endif
 
-BUILD_ASSERT(NRF_GPD_FAST_ACTIVE1 == 0);
+#ifdef CONFIG_SOC_NRF54H20_GPD
+#include <nrf/gpd.h>
+
 /* Macro must resolve to literal 0 or 1 */
-#define INSTANCE_IS_FAST(unused, prefix, idx, _)					\
-	COND_CODE_1(DT_NODE_HAS_STATUS_OKAY(UARTE(idx)),				\
-		(COND_CODE_1(UTIL_AND(IS_ENABLED(CONFIG_SOC_NRF54H20_GPD),		\
-			     DT_NODE_HAS_PROP(UARTE(idx), power_domains)),		\
-			    (COND_CODE_0(DT_PHA(UARTE(idx), power_domains, id), (1), (0))),\
-			    (0))), (0))
+#define INSTANCE_IS_FAST(unused, prefix, idx, _)						\
+	COND_CODE_1(DT_NODE_HAS_STATUS_OKAY(UARTE(idx)),					\
+		    (COND_CODE_1(DT_NODE_HAS_PROP(UARTE(idx), power_domains),			\
+			(IS_EQ(DT_PHA(UARTE(idx), power_domains, id), NRF_GPD_FAST_ACTIVE1)),	\
+			(0))), (0))
 
 #if UARTE_FOR_EACH_INSTANCE(INSTANCE_IS_FAST, (||), (0))
+/* Fast instance requires special PM treatment so device runtime PM must be enabled. */
+BUILD_ASSERT(IS_ENABLED(CONFIG_PM_DEVICE_RUNTIME));
 #define UARTE_ANY_FAST 1
 #endif
+#endif
 
 #ifdef UARTE_ANY_CACHE
 /* uart120 instance does not retain BAUDRATE register when ENABLE=0. When this instance
@@ -308,6 +309,10 @@ struct uarte_nrfx_config {
 #ifdef CONFIG_HAS_NORDIC_DMM
 	void *mem_reg;
 #endif
+#ifdef UARTE_ANY_FAST
+	const struct device *clk_dev;
+	struct nrf_clock_spec clk_spec;
+#endif
 #ifdef CONFIG_UART_USE_RUNTIME_CONFIGURE
 	/* None-zero in case of high speed instances. Baudrate is adjusted by that ratio. */
 	uint32_t clock_freq;
@@ -619,6 +624,16 @@ static void uarte_periph_enable(const struct device *dev)
 	struct uarte_nrfx_data *data = dev->data;
 
 	(void)data;
+#ifdef UARTE_ANY_FAST
+	if (config->clk_dev) {
+		int err;
+
+		err = nrf_clock_control_request_sync(config->clk_dev, &config->clk_spec, K_FOREVER);
+		(void)err;
+		__ASSERT_NO_MSG(err >= 0);
+	}
+#endif
+
 	nrf_uarte_enable(uarte);
 #ifdef CONFIG_SOC_NRF54H20_GPD
 	nrf_gpd_retain_pins_set(config->pcfg, false);
@@ -700,7 +715,6 @@ static void tx_start(const struct device *dev, const uint8_t *buf, size_t len)
 	if (LOW_POWER_ENABLED(config)) {
 		uarte_enable_locked(dev, UARTE_FLAG_LOW_POWER_TX);
 	}
-
 	nrf_uarte_task_trigger(uarte, NRF_UARTE_TASK_STARTTX);
 }
 
@@ -2204,6 +2218,16 @@ static void uarte_pm_suspend(const struct device *dev)
 	struct uarte_nrfx_data *data = dev->data;
 
 	(void)data;
+#ifdef UARTE_ANY_FAST
+	if (cfg->clk_dev) {
+		int err;
+
+		err = nrf_clock_control_release(cfg->clk_dev, &cfg->clk_spec);
+		(void)err;
+		__ASSERT_NO_MSG(err >= 0);
+	}
+#endif
+
 #ifdef UARTE_ANY_ASYNC
 	if (data->async) {
 		/* Entering inactive state requires device to be no
@@ -2387,18 +2411,31 @@ static int uarte_instance_init(const struct device *dev,
 #define UARTE_DISABLE_RX_INIT(node_id) \
 	.disable_rx = DT_PROP(node_id, disable_rx)
 
-#define UARTE_GET_FREQ(idx) DT_PROP(DT_CLOCKS_CTLR(UARTE(idx)), clock_frequency)
-
-#define UARTE_GET_BAUDRATE_DIV(idx)						\
-	COND_CODE_1(DT_CLOCKS_HAS_IDX(UARTE(idx), 0),				\
-		   ((UARTE_GET_FREQ(idx) / NRF_UARTE_BASE_FREQUENCY_16MHZ)), (1))
+/* Get frequency of the clock that driver the UARTE peripheral. Clock node can
+ * have fixed or variable frequency. For fast UARTE use highest supported frequency.
+ */
+#define UARTE_GET_BAUDRATE_DIV(idx) \
+	(NRF_PERIPH_GET_FREQUENCY(UARTE(idx)) / NRF_UARTE_BASE_FREQUENCY_16MHZ)
 
 /* When calculating baudrate we need to take into account that high speed instances
  * must have baudrate adjust to the ratio between UARTE clocking frequency and 16 MHz.
  */
 #define UARTE_GET_BAUDRATE(idx) \
 	(NRF_BAUDRATE(UARTE_PROP(idx, current_speed)) / UARTE_GET_BAUDRATE_DIV(idx))
 
+/* Get initialization level of an instance. Instances that requires clock control
+ * which is using nrfs (IPC) are initialized later.
+ */
+#define UARTE_INIT_LEVEL(idx) \
+	COND_CODE_1(INSTANCE_IS_FAST(_, /*empty*/, idx, _), (POST_KERNEL), (PRE_KERNEL_1))
+
+/* Get initialization priority of an instance. Instances that requires clock control
+ * which is using nrfs (IPC) are initialized later.
+ */
+#define UARTE_INIT_PRIO(idx)								\
+	COND_CODE_1(INSTANCE_IS_FAST(_, /*empty*/, idx, _),				\
+		    (UTIL_INC(CONFIG_CLOCK_CONTROL_NRF2_GLOBAL_HSFLL_INIT_PRIORITY)),	\
+		    (CONFIG_SERIAL_INIT_PRIORITY))
 
 /* Macro for setting nRF specific configuration structures. */
 #define UARTE_NRF_CONFIG(idx) {							\
@@ -2454,7 +2491,7 @@ static int uarte_instance_init(const struct device *dev,
 	static const struct uarte_nrfx_config uarte_##idx##z_config = {	       \
 		COND_CODE_1(CONFIG_UART_USE_RUNTIME_CONFIGURE,		       \
 		    (IF_ENABLED(DT_CLOCKS_HAS_IDX(UARTE(idx), 0),	       \
-			   (.clock_freq = UARTE_GET_FREQ(idx),))),	       \
+			   (.clock_freq = NRF_PERIPH_GET_FREQUENCY(UARTE(idx)),))), \
 		    (IF_ENABLED(UARTE_HAS_FRAME_TIMEOUT,		       \
 			(.baudrate = UARTE_PROP(idx, current_speed),))	       \
 		     .nrf_baudrate = UARTE_GET_BAUDRATE(idx),		       \
@@ -2481,6 +2518,13 @@ static int uarte_instance_init(const struct device *dev,
 		IF_ENABLED(CONFIG_UART_##idx##_NRF_HW_ASYNC,		       \
 			(.timer = NRFX_TIMER_INSTANCE(			       \
 				CONFIG_UART_##idx##_NRF_HW_ASYNC_TIMER),))     \
+		IF_ENABLED(INSTANCE_IS_FAST(_, /*empty*/, idx, _),	       \
+			(.clk_dev = DEVICE_DT_GET(DT_CLOCKS_CTLR(UARTE(idx))), \
+			 .clk_spec = {					       \
+				.frequency = NRF_PERIPH_GET_FREQUENCY(UARTE(idx)),\
+				.accuracy = 0,				       \
+				.precision = NRF_CLOCK_CONTROL_PRECISION_DEFAULT,\
+				},))					       \
 	};								       \
 	static int uarte_##idx##_init(const struct device *dev)		       \
 	{								       \
@@ -2501,8 +2545,8 @@ static int uarte_instance_init(const struct device *dev,
 		      PM_DEVICE_DT_GET(UARTE(idx)),			       \
 		      &uarte_##idx##_data,				       \
 		      &uarte_##idx##z_config,				       \
-		      PRE_KERNEL_1,					       \
-		      CONFIG_SERIAL_INIT_PRIORITY,			       \
+		      UARTE_INIT_LEVEL(idx),				       \
+		      UARTE_INIT_PRIO(idx),				       \
 		      &uart_nrfx_uarte_driver_api)
 
 #define UARTE_INT_DRIVEN(idx)						       \