[nrf fromlist] treewide: Replace clock_control_nrf api with clock speciffic api

Replaced clock_control_nrf api with clock speciffic api and removed
clock_control_nrf api.

Upstream PR #: 99257

Signed-off-by: Michal Frankiewicz <[email protected]>

Author: mif1-nordic

drivers/clock_control/clock_control_nrf.c

@@ -14,7 +14,6 @@
 
 #define UPDATE_INTERVAL_S 10
 
-static const struct device *const clock0 = DEVICE_DT_GET_ONE(nordic_nrf_clock);
 static const struct device *const timer0 = DEVICE_DT_GET(DT_NODELABEL(timer0));
 static struct timeutil_sync_config sync_config;
 static uint64_t counter_ref;
@@ -100,14 +99,18 @@ static void show_clocks(const char *tag)
 	enum clock_control_status clkstat;
 	bool running;
 
-	clkstat = clock_control_get_status(clock0, CLOCK_CONTROL_NRF_SUBSYS_LF);
-	running = nrf_clock_is_running(NRF_CLOCK, NRF_CLOCK_DOMAIN_LFCLK,
-				       &src.lf);
+	clkstat = clock_control_get_status(DEVICE_DT_GET_ONE(nordic_nrf_clock_lfclk), NULL);
+	running = nrfx_clock_lfclk_running_check(&src.lf);
 	printk("%s: LFCLK[%s]: %s %s ; ", tag, clkstat_s[clkstat],
 	       running ? "Running" : "Off", lfsrc_s[src.lf]);
-	clkstat = clock_control_get_status(clock0, CLOCK_CONTROL_NRF_SUBSYS_HF);
-	running = nrf_clock_is_running(NRF_CLOCK, NRF_CLOCK_DOMAIN_HFCLK,
-				       &src.hf);
+	clkstat = clock_control_get_status(DEVICE_DT_GET_ONE(COND_CODE_1((NRF_CLOCK_HAS_HFCLK),
+									 (nordic_nrf_clock_hfclk),
+									 (nordic_nrf_clock_xo))),
+					   NULL);
+
+	running = COND_CODE_1((NRF_CLOCK_HAS_HFCLK), 
+			      (nrfx_clock_hfclk_running_check),
+			      (nrfx_clock_xo_running_check))(&src.hf);
 	printk("HFCLK[%s]: %s %s\n", clkstat_s[clkstat],
 	       running ? "Running" : "Off", hfsrc_s[src.hf]);
 }
@@ -196,19 +199,22 @@ static void sync_work_handler(struct k_work *work)
 
 int main(void)
 {
+	struct device *clock = DEVICE_DT_GET_ONE(COND_CODE_1((NRF_CLOCK_HAS_HFCLK),
+							     (nordic_nrf_clock_hfclk),
+							     (nordic_nrf_clock_xo)));
 	uint32_t top;
 	int rc;
 
 	/* Grab the clock driver */
-	if (!device_is_ready(clock0)) {
-		printk("%s: device not ready.\n", clock0->name);
+	if (!device_is_ready(clock)) {
+		printk("%s: device not ready.\n", clock->name);
 		return 0;
 	}
 
 	show_clocks("Power-up clocks");
 
 	if (IS_ENABLED(CONFIG_APP_ENABLE_HFXO)) {
-		rc = clock_control_on(clock0, CLOCK_CONTROL_NRF_SUBSYS_HF);
+		rc = clock_control_on(clock, NULL);
 		printk("Enable HFXO got %d\n", rc);
 	}
 

samples/boards/nordic/clock_skew/src/main.c

@@ -21,7 +21,7 @@ static int nrf53_cpu_boost(void)
 	int err;
 
 	/* For optimal performance, the CPU frequency should be set to 128 MHz */
-	err = nrfx_clock_divider_set(NRF_CLOCK_DOMAIN_HFCLK, NRF_CLOCK_HFCLK_DIV_1);
+	err = nrfx_clock_hfclk_divider_set(NRF_CLOCK_HFCLK_DIV_1);
 	err -= NRFX_ERROR_BASE_NUM;
 	if (err != 0) {
 		LOG_WRN("Failed to set 128 MHz: %d", err);

samples/net/zperf/src/nrf5340_cpu_boost.c

@@ -736,7 +736,7 @@ int bap_usb_init(void)
 		 * This may not be required, but reduces the risk of not decoding fast enough
 		 * to keep up with USB
 		 */
-		err = nrfx_clock_divider_set(NRF_CLOCK_DOMAIN_HFCLK, NRF_CLOCK_HFCLK_DIV_1);
+		err = nrfx_clock_hfclk_divider_set(NRF_CLOCK_HFCLK_DIV_1);
 
 		err -= NRFX_ERROR_BASE_NUM;
 		if (err != 0) {

subsys/bluetooth/audio/shell/bap_usb.c

@@ -10,23 +10,23 @@
 #if NRF_CLOCK_HAS_HFCLK
 static const struct device_subsys_data subsys_data_hfclk[] = {
 	{
-		.subsys = CLOCK_CONTROL_NRF_SUBSYS_HF,
+		.subsys = NULL,
 		.startup_us = CONFIG_TEST_NRF_HF_STARTUP_TIME_US
 	}
 };
 #endif /* NRF_CLOCK_HAS_HFCLK */
 #if NRF_CLOCK_HAS_XO
 static const struct device_subsys_data subsys_data_xo[] = {
 	{
-		.subsys = CLOCK_CONTROL_NRF_SUBSYS_HF,
+		.subsys = NULL,
 		.startup_us =  CONFIG_TEST_NRF_HF_STARTUP_TIME_US
 	}
 };
 #endif /* NRF_CLOCK_HAS_XO */
 #if !defined(CONFIG_SOC_NRF52832)
 static const struct device_subsys_data subsys_data_lfclk[] = {
 	{
-		.subsys = CLOCK_CONTROL_NRF_SUBSYS_LF,
+		.subsys = NULL,
 		.startup_us = (CLOCK_CONTROL_NRF_K32SRC ==
 			    NRF_CLOCK_LFCLK_RC) ? 1000 : 500000
 	}
@@ -35,23 +35,23 @@ static const struct device_subsys_data subsys_data_lfclk[] = {
 #if NRF_CLOCK_HAS_HFCLK192M
 static const struct device_subsys_data subsys_data_hfclk192m[] = {
 	{
-		.subsys = CLOCK_CONTROL_NRF_SUBSYS_HF192M,
+		.subsys = NULL,
 		.startup_us = 5
 	}
 };
 #endif /* NRF_CLOCK_HAS_HFCLK192M */
 #if NRF_CLOCK_HAS_HFCLKAUDIO
 static const struct device_subsys_data subsys_data_hfclkaudio[] = {
 	{
-		.subsys = CLOCK_CONTROL_NRF_SUBSYS_HFAUDIO,
+		.subsys = NULL,
 		.startup_us = 30
 	}
 };
 #endif /* NRF_CLOCK_HAS_HFCLKAUDIO */
 #if NRF_CLOCK_HAS_XO24M
 static const struct device_subsys_data subsys_data_xo24m[] = {
 	{
-		.subsys = CLOCK_CONTROL_NRF_SUBSYS_HF24M,
+		.subsys = NULL,
 		.startup_us = 5
 	}
 };

tests/drivers/clock_control/clock_control_api/src/nrf_device_subsys.h

@@ -74,13 +74,13 @@ ZTEST(nrf_lf_clock_start, test_wait_in_thread)
 	}
 
 	z_nrf_clock_control_lf_on(CLOCK_CONTROL_NRF_LF_START_AVAILABLE);
-	o = nrf_clock_is_running(NRF_CLOCK, NRF_CLOCK_DOMAIN_LFCLK, &t);
+	o = nrfx_clock_lfclk_running_check(&t);
 	zassert_false((t == NRF_CLOCK_LFCLK_XTAL) && o);
 	k_busy_wait(35);
 	zassert_true(k_cycle_get_32() > 0);
 
 	z_nrf_clock_control_lf_on(CLOCK_CONTROL_NRF_LF_START_STABLE);
-	o = nrf_clock_is_running(NRF_CLOCK, NRF_CLOCK_DOMAIN_LFCLK, &t);
+	o = nrfx_clock_lfclk_running_check(&t);
 	zassert_true((t == NRF_CLOCK_LFCLK_XTAL) && o);
 }
 
@@ -118,7 +118,7 @@ static int get_lfclk_state(void)
 	 * not valid, in that case read system clock to check if it has
 	 * progressed.
 	 */
-	clk_on = nrf_clock_is_running(NRF_CLOCK, NRF_CLOCK_DOMAIN_LFCLK, &clk_type);
+	clk_on = nrfx_clock_lfclk_running_check(&clk_type);
 	k_busy_wait(100);
 	rtc_cnt = k_cycle_get_32();
 

tests/drivers/clock_control/nrf_lf_clock_start/src/main.c

@@ -19,8 +19,10 @@ LOG_MODULE_REGISTER(test);
 static bool test_end;
 
 static const struct device *const entropy = DEVICE_DT_GET(DT_CHOSEN(zephyr_entropy));
-static const struct device *const clock_dev = DEVICE_DT_GET_ONE(nordic_nrf_clock);
-static struct device *hf_dev;
+static const struct device *const clock_dev = DEVICE_DT_GET_ONE(
+					      COND_CODE_1((NRF_CLOCK_HAS_HFCLK),
+							  (nordic_nrf_clock_hfclk),
+							  (nordic_nrf_clock_xo)));
 static struct onoff_client cli;
 static uint32_t iteration;
 
@@ -29,11 +31,6 @@ static void *setup(void)
 	zassert_true(device_is_ready(entropy));
 	zassert_true(device_is_ready(clock_dev));
 
-	hf_dev = DEVICE_DT_GET_ONE(COND_CODE_1((NRF_CLOCK_HAS_HFCLK),
-					       (nordic_nrf_clock_hfclk),
-					       (nordic_nrf_clock_xo)));
-	zassert_true(hf_dev);
-
 	return NULL;
 }
 
@@ -65,20 +62,21 @@ static void bt_timeout_handler(struct k_timer *timer)
 
 K_TIMER_DEFINE(timer1, bt_timeout_handler, NULL);
 
-static void check_hf_status(const struct device *dev, bool exp_on,
-			    bool sw_check)
+static void check_hf_status(bool exp_on, bool sw_check)
 {
 	nrf_clock_hfclk_t type;
 
-	nrf_clock_is_running(NRF_CLOCK, NRF_CLOCK_DOMAIN_HFCLK, &type);
+	COND_CODE_1((NRF_CLOCK_HAS_HFCLK),
+		    (nrfx_clock_hfclk_running_check),
+		    (nrfx_clock_xo_running_check))(&type);
+
 	zassert_equal(type, exp_on ? NRF_CLOCK_HFCLK_HIGH_ACCURACY :
 				NRF_CLOCK_HFCLK_LOW_ACCURACY,
 			"%d: Clock expected to be %s",
 			iteration, exp_on ? "on" : "off");
 
 	if (sw_check) {
-		enum clock_control_status status =
-		     clock_control_get_status(dev, CLOCK_CONTROL_NRF_SUBSYS_HF);
+		enum clock_control_status status = clock_control_get_status(clock_dev, NULL);
 
 		zassert_equal(status, exp_on ? CLOCK_CONTROL_STATUS_ON :
 						CLOCK_CONTROL_STATUS_OFF,
@@ -117,16 +115,16 @@ ZTEST(nrf_onoff_and_bt, test_onoff_interrupted)
 		backoff = 3 * rand;
 
 		sys_notify_init_spinwait(&cli.notify);
-		err = nrf_clock_control_request(hf_dev, NULL, &cli);
+		err = nrf_clock_control_request(clock_dev, NULL, &cli);
 		zassert_true(err >= 0);
 
 		k_busy_wait(backoff);
 
 		if (backoff > HF_STARTUP_TIME_US) {
-			check_hf_status(clock_dev, true, true);
+			check_hf_status(true, true);
 		}
 
-		err = nrf_clock_control_cancel_or_release(hf_dev, NULL, &cli);
+		err = nrf_clock_control_cancel_or_release(clock_dev, NULL, &cli);
 		zassert_true(err >= 0);
 
 		elapsed = k_uptime_get() - start_time;
@@ -138,7 +136,7 @@ ZTEST(nrf_onoff_and_bt, test_onoff_interrupted)
 
 	test_end = true;
 	k_msleep(100);
-	check_hf_status(clock_dev, false, true);
+	check_hf_status(false, true);
 }
 
 static void onoff_timeout_handler(struct k_timer *timer)
@@ -209,7 +207,7 @@ ZTEST(nrf_onoff_and_bt, test_bt_interrupted)
 		k_busy_wait(backoff);
 
 		if (backoff > HF_STARTUP_TIME_US) {
-			check_hf_status(clock_dev, true, false);
+			check_hf_status(true, false);
 		}
 
 		z_nrf_clock_bt_ctlr_hf_release();
@@ -223,6 +221,6 @@ ZTEST(nrf_onoff_and_bt, test_bt_interrupted)
 
 	test_end = true;
 	k_msleep(100);
-	check_hf_status(clock_dev, false, true);
+	check_hf_status(false, true);
 }
 ZTEST_SUITE(nrf_onoff_and_bt, NULL, setup, NULL, NULL, NULL);

tests/drivers/clock_control/nrf_onoff_and_bt/src/main.c

@@ -16,11 +16,13 @@ LOG_MODULE_REGISTER(test);
 
 static bool clock_is_off(void)
 {
-	const struct device *const clk = DEVICE_DT_GET_ONE(nordic_nrf_clock);
+	const struct device *const clk = DEVICE_DT_GET_ONE(COND_CODE_1((NRF_CLOCK_HAS_HFCLK),
+								       (nordic_nrf_clock_hfclk),
+								       (nordic_nrf_clock_xo)));
 
 	zassert_true(device_is_ready(clk), "Device is not ready");
 
-	return clock_control_get_status(clk, CLOCK_CONTROL_NRF_SUBSYS_HF) ==
+	return clock_control_get_status(clk, NULL) ==
 			CLOCK_CONTROL_STATUS_OFF;
 }