[nrf fromlist] dts: drivers: nordic: Don't manage hsfll120 from drivers

The hsfll120 is requested automatically by hardware. Remove
additional handling from device drivers.

Updates:
  - can_nrf
  - counter_nrfx_timer
  - uart_nrfx_uarte
  - spi_nrfx_spim
  - spi_nrfx_spis

Upstream PR #: 97452

Signed-off-by: Bjarki Arge Andreasen <[email protected]>

Author: bjarki-andreasen

drivers/can/can_nrf.c

@@ -29,7 +29,6 @@ struct can_nrf_config {
 	uint32_t mrba;
 	uint32_t mram;
 	const struct device *auxpll;
-	const struct device *hsfll;
 	const struct pinctrl_dev_config *pcfg;
 	void (*irq_configure)(void);
 	uint16_t irq;
@@ -133,40 +132,16 @@ static const struct can_mcan_ops can_mcan_nrf_ops = {
 	.clear_mram = can_nrf_clear_mram,
 };
 
-static int configure_hsfll(const struct device *dev, bool on)
-{
-	const struct can_mcan_config *mcan_config = dev->config;
-	const struct can_nrf_config *config = mcan_config->custom;
-	struct nrf_clock_spec spec = { 0 };
-
-	/* If CAN is on, HSFLL frequency >= AUXPLL frequency */
-	if (on) {
-		int ret;
-
-		ret = clock_control_get_rate(config->auxpll, NULL, &spec.frequency);
-		if (ret < 0) {
-			return ret;
-		}
-	}
-
-	return nrf_clock_control_request_sync(config->hsfll, &spec, K_FOREVER);
-}
-
 static int can_nrf_init(const struct device *dev)
 {
 	const struct can_mcan_config *mcan_config = dev->config;
 	const struct can_nrf_config *config = mcan_config->custom;
 	int ret;
 
-	if (!device_is_ready(config->auxpll) || !device_is_ready(config->hsfll)) {
+	if (!device_is_ready(config->auxpll)) {
 		return -ENODEV;
 	}
 
-	ret = configure_hsfll(dev, true);
-	if (ret < 0) {
-		return ret;
-	}
-
 	ret = nrf_clock_control_request_sync(config->auxpll, NULL, K_FOREVER);
 	if (ret < 0) {
 		return ret;
@@ -215,7 +190,6 @@ static int can_nrf_init(const struct device *dev)
 		.mram = CAN_MCAN_DT_INST_MRAM_ADDR(n),                                             \
 		.auxpll = DEVICE_DT_GET(DT_INST_CLOCKS_CTLR_BY_NAME(n, auxpll)),                   \
 		.pcfg = PINCTRL_DT_INST_DEV_CONFIG_GET(n),                                         \
-		.hsfll = DEVICE_DT_GET(DT_INST_CLOCKS_CTLR_BY_NAME(n, hsfll)),                     \
 		.irq = DT_INST_IRQN(n),                                                            \
 		.irq_configure = can_nrf_irq_configure##n,                                         \
 	};                                                                                         \

drivers/counter/counter_nrfx_timer.c

@@ -5,7 +5,6 @@
  */
 #include <soc.h>
 #include <zephyr/drivers/counter.h>
-#include <zephyr/drivers/clock_control/nrf_clock_control.h>
 #include <zephyr/devicetree.h>
 #include <hal/nrf_timer.h>
 #include <zephyr/sys/atomic.h>
@@ -35,21 +34,11 @@ LOG_MODULE_REGISTER(LOG_MODULE_NAME, LOG_LEVEL);
 #define MAYBE_CONST_CONFIG const
 #endif
 
-#if NRF_DT_INST_ANY_IS_FAST && CONFIG_CLOCK_CONTROL
-#define COUNTER_IS_FAST(idx) NRF_DT_INST_IS_FAST(idx)
-#define COUNTER_ANY_FAST
-#else
-#define COUNTER_IS_FAST(idx) 0
-#endif
-
 struct counter_nrfx_data {
 	counter_top_callback_t top_cb;
 	void *top_user_data;
 	uint32_t guard_period;
 	atomic_t cc_int_pending;
-#ifdef COUNTER_ANY_FAST
-	atomic_t active;
-#endif
 };
 
 struct counter_nrfx_ch_data {
@@ -61,10 +50,6 @@ struct counter_nrfx_config {
 	struct counter_config_info info;
 	struct counter_nrfx_ch_data *ch_data;
 	NRF_TIMER_Type *timer;
-#ifdef COUNTER_ANY_FAST
-	const struct device *clk_dev;
-	struct nrf_clock_spec clk_spec;
-#endif
 	LOG_INSTANCE_PTR_DECLARE(log);
 };
 
@@ -78,18 +63,6 @@ static int start(const struct device *dev)
 {
 	const struct counter_nrfx_config *config = dev->config;
 
-#ifdef COUNTER_ANY_FAST
-	struct counter_nrfx_data *data = dev->data;
-
-	if (config->clk_dev && atomic_cas(&data->active, 0, 1)) {
-		int err;
-
-		err = nrf_clock_control_request_sync(config->clk_dev, &config->clk_spec, K_FOREVER);
-		if (err < 0) {
-			return err;
-		}
-	}
-#endif
 	nrf_timer_task_trigger(config->timer, NRF_TIMER_TASK_START);
 
 	return 0;
@@ -106,19 +79,6 @@ static int stop(const struct device *dev)
 	nrf_timer_task_trigger(config->timer, NRF_TIMER_TASK_CLEAR);
 #endif
 
-#ifdef COUNTER_ANY_FAST
-	struct counter_nrfx_data *data = dev->data;
-
-	if (config->clk_dev && atomic_cas(&data->active, 1, 0)) {
-		int err;
-
-		err = nrf_clock_control_release(config->clk_dev, &config->clk_spec);
-		if (err < 0) {
-			return err;
-		}
-	}
-#endif
-
 	return 0;
 }
 
@@ -459,20 +419,6 @@ static DEVICE_API(counter, counter_nrfx_driver_api) = {
 	.set_guard_period = set_guard_period,
 };
 
-/* Get initialization level of an instance. Instances that requires clock control
- * which is using nrfs (IPC) are initialized later.
- */
-#define TIMER_INIT_LEVEL(idx) \
-	COND_CODE_1(COUNTER_IS_FAST(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 TIMER_INIT_PRIO(idx)								\
-	COND_CODE_1(COUNTER_IS_FAST(idx),						\
-		    (UTIL_INC(CONFIG_CLOCK_CONTROL_NRF_HSFLL_GLOBAL_INIT_PRIORITY)),	\
-		    (CONFIG_COUNTER_INIT_PRIORITY))
-
 /*
  * Device instantiation is done with node labels due to HAL API
  * requirements. In particular, TIMERx_MAX_SIZE values from HALs
@@ -525,22 +471,14 @@ static DEVICE_API(counter, counter_nrfx_driver_api) = {
 		},										\
 		.ch_data = counter##idx##_ch_data,						\
 		.timer = (NRF_TIMER_Type *)DT_INST_REG_ADDR(idx),				\
-		IF_ENABLED(COUNTER_IS_FAST(idx),						\
-			(.clk_dev = DEVICE_DT_GET_OR_NULL(DT_CLOCKS_CTLR(DT_DRV_INST(idx))),	\
-			 .clk_spec = {								\
-				.frequency = NRF_PERIPH_GET_FREQUENCY(DT_DRV_INST(idx)),	\
-				.accuracy = 0,							\
-				.precision = NRF_CLOCK_CONTROL_PRECISION_DEFAULT,		\
-				},								\
-			 ))									\
 		LOG_INSTANCE_PTR_INIT(log, LOG_MODULE_NAME, idx)				\
 	};											\
 	DEVICE_DT_INST_DEFINE(idx,								\
 			    counter_##idx##_init,						\
 			    NULL,								\
 			    &counter_##idx##_data,						\
 			    &nrfx_counter_##idx##_config.info,					\
-			    TIMER_INIT_LEVEL(idx), TIMER_INIT_PRIO(idx),			\
+			    PRE_KERNEL_1, CONFIG_COUNTER_INIT_PRIORITY,				\
 			    &counter_nrfx_driver_api);
 
 DT_INST_FOREACH_STATUS_OKAY(COUNTER_NRFX_TIMER_DEVICE)

drivers/pwm/pwm_nrfx.c

@@ -13,7 +13,6 @@
 #include <zephyr/linker/devicetree_regions.h>
 #include <zephyr/cache.h>
 #include <zephyr/mem_mgmt/mem_attr.h>
-#include <zephyr/drivers/clock_control/nrf_clock_control.h>
 
 #include <zephyr/logging/log.h>
 
@@ -36,20 +35,6 @@ LOG_MODULE_REGISTER(pwm_nrfx, CONFIG_PWM_LOG_LEVEL);
 #define PWM(dev_idx) DT_NODELABEL(pwm##dev_idx)
 #define PWM_PROP(dev_idx, prop) DT_PROP(PWM(dev_idx), prop)
 #define PWM_HAS_PROP(idx, prop) DT_NODE_HAS_PROP(PWM(idx), prop)
-#define PWM_NRFX_IS_FAST(idx) NRF_DT_IS_FAST(PWM(idx))
-
-#if NRF_DT_INST_ANY_IS_FAST
-#define PWM_NRFX_FAST_PRESENT 1
-/* If fast instances are used then system managed device PM cannot be used because
- * it may call PM actions from locked context and fast PWM PM actions can only be
- * called in a thread context.
- */
-BUILD_ASSERT(!IS_ENABLED(CONFIG_PM_DEVICE_SYSTEM_MANAGED));
-#endif
-
-#if defined(PWM_NRFX_FAST_PRESENT) && CONFIG_CLOCK_CONTROL_NRF_HSFLL_GLOBAL
-#define PWM_NRFX_USE_CLOCK_CONTROL 1
-#endif
 
 #define PWM_NRFX_CH_POLARITY_MASK BIT(15)
 #define PWM_NRFX_CH_COMPARE_MASK  BIT_MASK(15)
@@ -65,10 +50,6 @@ struct pwm_nrfx_config {
 #ifdef CONFIG_DCACHE
 	uint32_t mem_attr;
 #endif
-#ifdef PWM_NRFX_USE_CLOCK_CONTROL
-	const struct device *clk_dev;
-	struct nrf_clock_spec clk_spec;
-#endif
 };
 
 struct pwm_nrfx_data {
@@ -77,27 +58,12 @@ struct pwm_nrfx_data {
 	uint8_t  pwm_needed;
 	uint8_t  prescaler;
 	bool     stop_requested;
-#ifdef PWM_NRFX_USE_CLOCK_CONTROL
-	bool     clock_requested;
-#endif
 };
 /* Ensure the pwm_needed bit mask can accommodate all available channels. */
 #if (NRF_PWM_CHANNEL_COUNT > 8)
 #error "Current implementation supports maximum 8 channels."
 #endif
 
-#ifdef PWM_NRFX_FAST_PRESENT
-static bool pwm_is_fast(const struct pwm_nrfx_config *config)
-{
-	return config->clock_freq > MHZ(16);
-}
-#else
-static bool pwm_is_fast(const struct pwm_nrfx_config *config)
-{
-	return false;
-}
-#endif
-
 static uint16_t *seq_values_ptr_get(const struct device *dev)
 {
 	const struct pwm_nrfx_config *config = dev->config;
@@ -178,21 +144,6 @@ static int stop_pwm(const struct device *dev)
 	 */
 	nrfx_pwm_stop(&config->pwm, false);
 
-#if PWM_NRFX_USE_CLOCK_CONTROL
-	struct pwm_nrfx_data *data = dev->data;
-
-	if (data->clock_requested) {
-		int ret = nrf_clock_control_release(config->clk_dev, &config->clk_spec);
-
-		if (ret < 0) {
-			LOG_ERR("Global HSFLL release failed: %d", ret);
-			return ret;
-		}
-
-		data->clock_requested = false;
-	}
-#endif
-
 	return 0;
 }
 
@@ -232,9 +183,8 @@ static int pwm_nrfx_set_cycles(const struct device *dev, uint32_t channel,
 		/* Constantly active (duty 100%). */
 		/* This value is always greater than or equal to COUNTERTOP. */
 		compare_value = PWM_NRFX_CH_COMPARE_MASK;
-		needs_pwm = pwm_is_fast(config) ||
-			(IS_ENABLED(NRF_PWM_HAS_IDLEOUT) &&
-			 IS_ENABLED(CONFIG_PWM_NRFX_NO_GLITCH_DUTY_100));
+		needs_pwm = IS_ENABLED(NRF_PWM_HAS_IDLEOUT) &&
+			    IS_ENABLED(CONFIG_PWM_NRFX_NO_GLITCH_DUTY_100);
 	} else {
 		/* PWM generation needed. Check if the requested period matches
 		 * the one that is currently set, or the PWM peripheral can be
@@ -290,22 +240,6 @@ static int pwm_nrfx_set_cycles(const struct device *dev, uint32_t channel,
 	 * registers and drives its outputs accordingly.
 	 */
 	if (data->pwm_needed == 0) {
-		if (pwm_is_fast(config)) {
-#if PWM_NRFX_USE_CLOCK_CONTROL
-			if (data->clock_requested) {
-				int ret = nrf_clock_control_release(config->clk_dev,
-							    &config->clk_spec);
-
-				if (ret < 0) {
-					LOG_ERR("Global HSFLL release failed: %d", ret);
-					return ret;
-				}
-
-				data->clock_requested = false;
-			}
-#endif
-			return 0;
-		}
 		int ret = stop_pwm(dev);
 
 		if (ret < 0) {
@@ -332,20 +266,6 @@ static int pwm_nrfx_set_cycles(const struct device *dev, uint32_t channel,
 		 * until another playback is requested (new values will be
 		 * loaded then) or the PWM peripheral is stopped.
 		 */
-#if PWM_NRFX_USE_CLOCK_CONTROL
-		if (config->clk_dev && !data->clock_requested) {
-			int ret = nrf_clock_control_request_sync(config->clk_dev,
-								 &config->clk_spec,
-								 K_FOREVER);
-
-			if (ret < 0) {
-				LOG_ERR("Global HSFLL request failed: %d", ret);
-				return ret;
-			}
-
-			data->clock_requested = true;
-		}
-#endif
 		nrfx_pwm_simple_playback(&config->pwm, &config->seq, 1,
 					 NRFX_PWM_FLAG_NO_EVT_FINISHED);
 	}
@@ -463,21 +383,6 @@ static int pwm_nrfx_init(const struct device *dev)
 	COND_CODE_1(PWM_HAS_PROP(idx, memory_regions),			      \
 		(DT_PROP_OR(PWM_MEM_REGION(idx), zephyr_memory_attr, 0)), (0))
 
-/* Fast instances depend on the global HSFLL clock controller (as they need
- * to request the highest frequency from it to operate correctly), so they
- * must be initialized after that controller driver, hence the default PWM
- * initialization priority may be too early for them.
- */
-#if defined(CONFIG_CLOCK_CONTROL_NRF_HSFLL_GLOBAL_INIT_PRIORITY) && \
-	CONFIG_PWM_INIT_PRIORITY < CONFIG_CLOCK_CONTROL_NRF_HSFLL_GLOBAL_INIT_PRIORITY
-#define PWM_INIT_PRIORITY(idx)								\
-	COND_CODE_1(PWM_NRFX_IS_FAST(idx),						\
-		    (UTIL_INC(CONFIG_CLOCK_CONTROL_NRF_HSFLL_GLOBAL_INIT_PRIORITY)),	\
-		    (CONFIG_PWM_INIT_PRIORITY))
-#else
-#define PWM_INIT_PRIORITY(idx) CONFIG_PWM_INIT_PRIORITY
-#endif
-
 #define PWM_NRFX_DEVICE(idx)						      \
 	NRF_DT_CHECK_NODE_HAS_PINCTRL_SLEEP(PWM(idx));			      \
 	NRF_DT_CHECK_NODE_HAS_REQUIRED_MEMORY_REGIONS(PWM(idx));	      \
@@ -506,14 +411,6 @@ static int pwm_nrfx_init(const struct device *dev)
 			(16ul * 1000ul * 1000ul)),			      \
 		IF_ENABLED(CONFIG_DCACHE,				      \
 			(.mem_attr = PWM_GET_MEM_ATTR(idx),))		      \
-		IF_ENABLED(PWM_NRFX_USE_CLOCK_CONTROL,			      \
-			(.clk_dev = PWM_NRFX_IS_FAST(idx)		      \
-				    ? DEVICE_DT_GET(DT_CLOCKS_CTLR(PWM(idx))) \
-				    : NULL,				      \
-			 .clk_spec = {					      \
-				.frequency =				      \
-					NRF_PERIPH_GET_FREQUENCY(PWM(idx)),   \
-			 },))						      \
 	};								      \
 	static int pwm_nrfx_init##idx(const struct device *dev)		      \
 	{								      \
@@ -526,7 +423,7 @@ static int pwm_nrfx_init(const struct device *dev)
 			 pwm_nrfx_init##idx, PM_DEVICE_DT_GET(PWM(idx)),      \
 			 &pwm_nrfx_##idx##_data,			      \
 			 &pwm_nrfx_##idx##_config,			      \
-			 POST_KERNEL, PWM_INIT_PRIORITY(idx),		      \
+			 POST_KERNEL, CONFIG_PWM_INIT_PRIORITY,		      \
 			 &pwm_nrfx_drv_api_funcs)
 
 #define COND_PWM_NRFX_DEVICE(unused, prefix, i, _) \

drivers/serial/Kconfig.nrfx

@@ -28,13 +28,6 @@ config UART_NRFX_UARTE
 	imply NRFX_UARTE_CONFIG_SKIP_PSEL_CONFIG if !UART_NRFX_UARTE_LEGACY_SHIM
 	imply NRFX_UARTE_CONFIG_SKIP_GPIO_CONFIG if !UART_NRFX_UARTE_LEGACY_SHIM
 
-config UART_NRFX_UARTE_USE_CLOCK_CONTROL
-	def_bool y
-	depends on UART_NRFX_UARTE
-	depends on $(dt_nodelabel_enabled,uart120)
-	depends on !SOC_NRF54H20_CPUFLPR && !SOC_NRF54H20_CPUPPR
-	select CLOCK_CONTROL
-
 config UART_NRFX_UARTE_NO_IRQ
 	bool "Polling without interrupt"
 	depends on UART_NRFX_UARTE