diff --git a/drivers/clock_control/clock_control_nrf2_fll16m.c b/drivers/clock_control/clock_control_nrf2_fll16m.c
index 7bb10263d5b..92b09804b8a 100644
--- a/drivers/clock_control/clock_control_nrf2_fll16m.c
+++ b/drivers/clock_control/clock_control_nrf2_fll16m.c
@@ -34,6 +34,7 @@ BUILD_ASSERT(FLL16M_MODE_CLOSED_LOOP == NRF_LRCCONF_CLK_SRC_CLOSED_LOOP);
 #define FLL16M_HFXO_ACCURACY DT_PROP(FLL16M_HFXO_NODE, accuracy_ppm)
 #define FLL16M_OPEN_LOOP_ACCURACY DT_INST_PROP(0, open_loop_accuracy_ppm)
 #define FLL16M_MAX_ACCURACY FLL16M_HFXO_ACCURACY
+#define FLL16M_OPEN_LOOP_STARTUP_TIME_US DT_INST_PROP(0, open_loop_startup_time_us)
 
 #define BICR (NRF_BICR_Type *)DT_REG_ADDR(DT_NODELABEL(bicr))
 
@@ -57,6 +58,7 @@ struct fll16m_dev_data {
 	STRUCT_CLOCK_CONFIG(fll16m, ARRAY_SIZE(clock_options)) clk_cfg;
 	struct onoff_client hfxo_cli;
 	sys_snode_t fll16m_node;
+	uint32_t bypass_startup_time_us;
 };
 
 struct fll16m_dev_config {
@@ -133,49 +135,98 @@ static void fll16m_work_handler(struct k_work *work)
 	}
 }
 
-static struct onoff_manager *fll16m_find_mgr(const struct device *dev,
-					     const struct nrf_clock_spec *spec)
+static int fll16m_resolve_spec_to_idx(const struct device *dev,
+				      const struct nrf_clock_spec *req_spec)
 {
-	struct fll16m_dev_data *dev_data = dev->data;
 	const struct fll16m_dev_config *dev_config = dev->config;
-	uint16_t accuracy;
-
-	if (!spec) {
-		return &dev_data->clk_cfg.onoff[0].mgr;
-	}
+	uint16_t req_accuracy;
 
-	if (spec->frequency > dev_config->fixed_frequency) {
+	if (req_spec->frequency > dev_config->fixed_frequency) {
 		LOG_ERR("invalid frequency");
-		return NULL;
+		return -EINVAL;
 	}
 
-	if (spec->precision) {
+	if (req_spec->precision) {
 		LOG_ERR("invalid precision");
-		return NULL;
+		return -EINVAL;
 	}
 
-	accuracy = spec->accuracy == NRF_CLOCK_CONTROL_ACCURACY_MAX
-		 ? FLL16M_MAX_ACCURACY
-		 : spec->accuracy;
+	req_accuracy = req_spec->accuracy == NRF_CLOCK_CONTROL_ACCURACY_MAX
+		     ? FLL16M_MAX_ACCURACY
+		     : req_spec->accuracy;
 
 	for (int i = 0; i < ARRAY_SIZE(clock_options); ++i) {
-		if (accuracy &&
-		    accuracy < clock_options[i].accuracy) {
+		if (req_accuracy &&
+		    req_accuracy < clock_options[i].accuracy) {
 			continue;
 		}
 
-		return &dev_data->clk_cfg.onoff[i].mgr;
+		return i;
 	}
 
 	LOG_ERR("invalid accuracy");
-	return NULL;
+	return -EINVAL;
+}
+
+static void fll16m_get_spec_by_idx(const struct device *dev,
+				   uint8_t idx,
+				   struct nrf_clock_spec *spec)
+{
+	const struct fll16m_dev_config *dev_config = dev->config;
+
+	spec->frequency = dev_config->fixed_frequency;
+	spec->accuracy = clock_options[idx].accuracy;
+	spec->precision = NRF_CLOCK_CONTROL_PRECISION_DEFAULT;
+}
+
+static int fll16m_get_startup_time_by_idx(const struct device *dev,
+					  uint8_t idx,
+					  uint32_t *startup_time_us)
+{
+	const struct fll16m_dev_data *dev_data = dev->data;
+	uint8_t mode = clock_options[idx].mode;
+
+	switch (mode) {
+	case FLL16M_MODE_OPEN_LOOP:
+		*startup_time_us = FLL16M_OPEN_LOOP_STARTUP_TIME_US;
+		return 0;
+
+	case FLL16M_MODE_BYPASS:
+		*startup_time_us = dev_data->bypass_startup_time_us;
+		return 0;
+
+	default:
+		break;
+	}
+
+	return -EINVAL;
+}
+
+static struct onoff_manager *fll16m_get_mgr_by_idx(const struct device *dev, uint8_t idx)
+{
+	struct fll16m_dev_data *dev_data = dev->data;
+
+	return &dev_data->clk_cfg.onoff[idx].mgr;
+}
+
+static struct onoff_manager *fll16m_find_mgr_by_spec(const struct device *dev,
+						     const struct nrf_clock_spec *spec)
+{
+	int idx;
+
+	if (!spec) {
+		return fll16m_get_mgr_by_idx(dev, 0);
+	}
+
+	idx = fll16m_resolve_spec_to_idx(dev, spec);
+	return idx < 0 ? NULL : fll16m_get_mgr_by_idx(dev, idx);
 }
 
 static int api_request_fll16m(const struct device *dev,
 			      const struct nrf_clock_spec *spec,
 			      struct onoff_client *cli)
 {
-	struct onoff_manager *mgr = fll16m_find_mgr(dev, spec);
+	struct onoff_manager *mgr = fll16m_find_mgr_by_spec(dev, spec);
 
 	if (mgr) {
 		return clock_config_request(mgr, cli);
@@ -187,7 +238,7 @@ static int api_request_fll16m(const struct device *dev,
 static int api_release_fll16m(const struct device *dev,
 			      const struct nrf_clock_spec *spec)
 {
-	struct onoff_manager *mgr = fll16m_find_mgr(dev, spec);
+	struct onoff_manager *mgr = fll16m_find_mgr_by_spec(dev, spec);
 
 	if (mgr) {
 		return onoff_release(mgr);
@@ -200,7 +251,7 @@ static int api_cancel_or_release_fll16m(const struct device *dev,
 					const struct nrf_clock_spec *spec,
 					struct onoff_client *cli)
 {
-	struct onoff_manager *mgr = fll16m_find_mgr(dev, spec);
+	struct onoff_manager *mgr = fll16m_find_mgr_by_spec(dev, spec);
 
 	if (mgr) {
 		return onoff_cancel_or_release(mgr, cli);
@@ -222,10 +273,45 @@ static int api_get_rate_fll16m(const struct device *dev,
 	return 0;
 }
 
+static int api_resolve(const struct device *dev,
+		       const struct nrf_clock_spec *req_spec,
+		       struct nrf_clock_spec *res_spec)
+{
+	int idx;
+
+	idx = fll16m_resolve_spec_to_idx(dev, req_spec);
+	if (idx < 0) {
+		return -EINVAL;
+	}
+
+	fll16m_get_spec_by_idx(dev, idx, res_spec);
+	return 0;
+}
+
+static int api_get_startup_time(const struct device *dev,
+				const struct nrf_clock_spec *spec,
+				uint32_t *startup_time_us)
+{
+	int idx;
+
+	idx = fll16m_resolve_spec_to_idx(dev, spec);
+	if (idx < 0) {
+		return -EINVAL;
+	}
+
+	return fll16m_get_startup_time_by_idx(dev, idx, startup_time_us);
+}
+
 static int fll16m_init(const struct device *dev)
 {
 	struct fll16m_dev_data *dev_data = dev->data;
 
+	dev_data->bypass_startup_time_us = nrf_bicr_hfxo_startup_time_us_get(BICR);
+	if (dev_data->bypass_startup_time_us == NRF_BICR_HFXO_STARTUP_TIME_UNCONFIGURED) {
+		LOG_ERR("BICR HFXO startup time invalid");
+		return -ENODEV;
+	}
+
 	return clock_config_init(&dev_data->clk_cfg,
 				 ARRAY_SIZE(dev_data->clk_cfg.onoff),
 				 fll16m_work_handler);
@@ -240,6 +326,8 @@ static DEVICE_API(nrf_clock_control, fll16m_drv_api) = {
 	.request = api_request_fll16m,
 	.release = api_release_fll16m,
 	.cancel_or_release = api_cancel_or_release_fll16m,
+	.resolve = api_resolve,
+	.get_startup_time = api_get_startup_time,
 };
 
 static struct fll16m_dev_data fll16m_data;
diff --git a/drivers/clock_control/clock_control_nrf2_global_hsfll.c b/drivers/clock_control/clock_control_nrf2_global_hsfll.c
index 50f3396429c..30a64ea9fdc 100644
--- a/drivers/clock_control/clock_control_nrf2_global_hsfll.c
+++ b/drivers/clock_control/clock_control_nrf2_global_hsfll.c
@@ -62,43 +62,69 @@ static uint32_t global_hsfll_get_max_clock_frequency(const struct device *dev)
 	return dev_config->clock_frequencies[ARRAY_SIZE(dev_config->clock_frequencies) - 1];
 }
 
-static struct onoff_manager *global_hsfll_find_mgr(const struct device *dev,
-						   const struct nrf_clock_spec *spec)
+static int global_hsfll_resolve_spec_to_idx(const struct device *dev,
+					    const struct nrf_clock_spec *req_spec)
 {
-	struct global_hsfll_dev_data *dev_data = dev->data;
 	const struct global_hsfll_dev_config *dev_config = dev->config;
-	uint32_t frequency;
-
-	if (!spec) {
-		return &dev_data->clk_cfg.onoff[0].mgr;
-	}
+	uint32_t req_frequency;
 
-	if (spec->accuracy || spec->precision) {
+	if (req_spec->accuracy || req_spec->precision) {
 		LOG_ERR("invalid specification of accuracy or precision");
-		return NULL;
+		return -EINVAL;
 	}
 
-	frequency = spec->frequency == NRF_CLOCK_CONTROL_FREQUENCY_MAX
-		  ? global_hsfll_get_max_clock_frequency(dev)
-		  : spec->frequency;
+	req_frequency = req_spec->frequency == NRF_CLOCK_CONTROL_FREQUENCY_MAX
+		      ? global_hsfll_get_max_clock_frequency(dev)
+		      : req_spec->frequency;
 
 	for (uint8_t i = 0; i < ARRAY_SIZE(dev_config->clock_frequencies); i++) {
-		if (dev_config->clock_frequencies[i] < frequency) {
+		if (dev_config->clock_frequencies[i] < req_frequency) {
 			continue;
 		}
 
-		return &dev_data->clk_cfg.onoff[i].mgr;
+		return i;
 	}
 
 	LOG_ERR("invalid frequency");
-	return NULL;
+	return -EINVAL;
+}
+
+static void global_hsfll_get_spec_by_idx(const struct device *dev,
+					 uint8_t idx,
+					 struct nrf_clock_spec *spec)
+{
+	const struct global_hsfll_dev_config *dev_config = dev->config;
+
+	spec->frequency = dev_config->clock_frequencies[idx];
+	spec->accuracy = 0;
+	spec->precision = 0;
+}
+
+static struct onoff_manager *global_hsfll_get_mgr_by_idx(const struct device *dev, uint8_t idx)
+{
+	struct global_hsfll_dev_data *dev_data = dev->data;
+
+	return &dev_data->clk_cfg.onoff[idx].mgr;
+}
+
+static struct onoff_manager *global_hsfll_find_mgr_by_spec(const struct device *dev,
+							   const struct nrf_clock_spec *spec)
+{
+	int idx;
+
+	if (!spec) {
+		return global_hsfll_get_mgr_by_idx(dev, 0);
+	}
+
+	idx = global_hsfll_resolve_spec_to_idx(dev, spec);
+	return idx < 0 ? NULL : global_hsfll_get_mgr_by_idx(dev, idx);
 }
 
 static int api_request_global_hsfll(const struct device *dev,
 				    const struct nrf_clock_spec *spec,
 				    struct onoff_client *cli)
 {
-	struct onoff_manager *mgr = global_hsfll_find_mgr(dev, spec);
+	struct onoff_manager *mgr = global_hsfll_find_mgr_by_spec(dev, spec);
 
 	if (mgr) {
 		return clock_config_request(mgr, cli);
@@ -110,7 +136,7 @@ static int api_request_global_hsfll(const struct device *dev,
 static int api_release_global_hsfll(const struct device *dev,
 				    const struct nrf_clock_spec *spec)
 {
-	struct onoff_manager *mgr = global_hsfll_find_mgr(dev, spec);
+	struct onoff_manager *mgr = global_hsfll_find_mgr_by_spec(dev, spec);
 
 	if (mgr) {
 		return onoff_release(mgr);
@@ -123,7 +149,7 @@ static int api_cancel_or_release_global_hsfll(const struct device *dev,
 					      const struct nrf_clock_spec *spec,
 					      struct onoff_client *cli)
 {
-	struct onoff_manager *mgr = global_hsfll_find_mgr(dev, spec);
+	struct onoff_manager *mgr = global_hsfll_find_mgr_by_spec(dev, spec);
 
 	if (mgr) {
 		return onoff_cancel_or_release(mgr, cli);
@@ -132,6 +158,21 @@ static int api_cancel_or_release_global_hsfll(const struct device *dev,
 	return -EINVAL;
 }
 
+static int api_resolve_global_hsfll(const struct device *dev,
+				    const struct nrf_clock_spec *req_spec,
+				    struct nrf_clock_spec *res_spec)
+{
+	int idx;
+
+	idx = global_hsfll_resolve_spec_to_idx(dev, req_spec);
+	if (idx < 0) {
+		return -EINVAL;
+	}
+
+	global_hsfll_get_spec_by_idx(dev, idx, res_spec);
+	return 0;
+}
+
 static DEVICE_API(nrf_clock_control, driver_api) = {
 	.std_api = {
 		.on = api_nosys_on_off,
@@ -140,6 +181,7 @@ static DEVICE_API(nrf_clock_control, driver_api) = {
 	.request = api_request_global_hsfll,
 	.release = api_release_global_hsfll,
 	.cancel_or_release = api_cancel_or_release_global_hsfll,
+	.resolve = api_resolve_global_hsfll,
 };
 
 static enum gdfs_frequency_setting global_hsfll_freq_idx_to_nrfs_freq(const struct device *dev,
diff --git a/drivers/clock_control/clock_control_nrf2_hfxo.c b/drivers/clock_control/clock_control_nrf2_hfxo.c
index 21d3d33f7e8..1c8d6f8ed18 100644
--- a/drivers/clock_control/clock_control_nrf2_hfxo.c
+++ b/drivers/clock_control/clock_control_nrf2_hfxo.c
@@ -271,6 +271,39 @@ static int init_hfxo(const struct device *dev)
 	return 0;
 }
 
+static int api_resolve(const struct device *dev,
+		       const struct nrf_clock_spec *req_spec,
+		       struct nrf_clock_spec *res_spec)
+{
+	const struct dev_config_hfxo *dev_config = dev->config;
+
+	if (!is_clock_spec_valid(dev, req_spec)) {
+		return -EINVAL;
+	}
+
+	res_spec->frequency = dev_config->fixed_frequency;
+	res_spec->accuracy = dev_config->fixed_accuracy;
+	res_spec->precision = NRF_CLOCK_CONTROL_PRECISION_HIGH;
+	return 0;
+}
+
+static int api_get_startup_time(const struct device *dev,
+				const struct nrf_clock_spec *spec,
+				uint32_t *startup_time_us)
+{
+	if (!is_clock_spec_valid(dev, spec)) {
+		return -EINVAL;
+	}
+
+	*startup_time_us = nrf_bicr_hfxo_startup_time_us_get(BICR);
+
+	if (*startup_time_us == NRF_BICR_HFXO_STARTUP_TIME_UNCONFIGURED) {
+		return -EINVAL;
+	}
+
+	return 0;
+}
+
 static DEVICE_API(nrf_clock_control, drv_api_hfxo) = {
 	.std_api = {
 		.on = api_nosys_on_off,
@@ -280,6 +313,8 @@ static DEVICE_API(nrf_clock_control, drv_api_hfxo) = {
 	.request = api_request_hfxo,
 	.release = api_release_hfxo,
 	.cancel_or_release = api_cancel_or_release_hfxo,
+	.resolve = api_resolve,
+	.get_startup_time = api_get_startup_time,
 };
 
 static struct dev_data_hfxo data_hfxo;
diff --git a/drivers/clock_control/clock_control_nrf2_hsfll.c b/drivers/clock_control/clock_control_nrf2_hsfll.c
index eb2dfde989c..e8f8449b24d 100644
--- a/drivers/clock_control/clock_control_nrf2_hsfll.c
+++ b/drivers/clock_control/clock_control_nrf2_hsfll.c
@@ -100,35 +100,56 @@ static void hsfll_work_handler(struct k_work *work)
 	k_timer_start(&dev_data->timer, NRFS_DVFS_TIMEOUT, K_NO_WAIT);
 }
 
-static struct onoff_manager *hsfll_find_mgr(const struct device *dev,
-					    const struct nrf_clock_spec *spec)
+static int hsfll_resolve_spec_to_idx(const struct nrf_clock_spec *req_spec)
 {
-	struct hsfll_dev_data *dev_data = dev->data;
-	uint32_t frequency;
-
-	if (!spec) {
-		return &dev_data->clk_cfg.onoff[0].mgr;
-	}
+	uint32_t req_frequency;
 
-	if (spec->accuracy || spec->precision) {
+	if (req_spec->accuracy || req_spec->precision) {
 		LOG_ERR("invalid specification of accuracy or precision");
-		return NULL;
+		return -EINVAL;
 	}
 
-	frequency = spec->frequency == NRF_CLOCK_CONTROL_FREQUENCY_MAX
-		  ? HSFLL_FREQ_HIGH
-		  : spec->frequency;
+	req_frequency = req_spec->frequency == NRF_CLOCK_CONTROL_FREQUENCY_MAX
+		      ? HSFLL_FREQ_HIGH
+		      : req_spec->frequency;
 
 	for (int i = 0; i < ARRAY_SIZE(clock_options); ++i) {
-		if (frequency > clock_options[i].frequency) {
+		if (req_frequency > clock_options[i].frequency) {
 			continue;
 		}
 
-		return &dev_data->clk_cfg.onoff[i].mgr;
+		return i;
 	}
 
 	LOG_ERR("invalid frequency");
-	return NULL;
+	return -EINVAL;
+}
+
+static void hsfll_get_spec_by_idx(uint8_t idx, struct nrf_clock_spec *spec)
+{
+	spec->frequency = clock_options[idx].frequency;
+	spec->accuracy = 0;
+	spec->precision = 0;
+}
+
+static struct onoff_manager *hsfll_get_mgr_by_idx(const struct device *dev, uint8_t idx)
+{
+	struct hsfll_dev_data *dev_data = dev->data;
+
+	return &dev_data->clk_cfg.onoff[idx].mgr;
+}
+
+static struct onoff_manager *hsfll_find_mgr_by_spec(const struct device *dev,
+						    const struct nrf_clock_spec *spec)
+{
+	int idx;
+
+	if (!spec) {
+		return hsfll_get_mgr_by_idx(dev, 0);
+	}
+
+	idx = hsfll_resolve_spec_to_idx(spec);
+	return idx < 0 ? NULL : hsfll_get_mgr_by_idx(dev, idx);
 }
 #endif /* CONFIG_NRFS_DVFS_LOCAL_DOMAIN */
 
@@ -137,7 +158,7 @@ static int api_request_hsfll(const struct device *dev,
 			     struct onoff_client *cli)
 {
 #ifdef CONFIG_NRFS_DVFS_LOCAL_DOMAIN
-	struct onoff_manager *mgr = hsfll_find_mgr(dev, spec);
+	struct onoff_manager *mgr = hsfll_find_mgr_by_spec(dev, spec);
 
 	if (mgr) {
 		return clock_config_request(mgr, cli);
@@ -153,7 +174,7 @@ static int api_release_hsfll(const struct device *dev,
 			     const struct nrf_clock_spec *spec)
 {
 #ifdef CONFIG_NRFS_DVFS_LOCAL_DOMAIN
-	struct onoff_manager *mgr = hsfll_find_mgr(dev, spec);
+	struct onoff_manager *mgr = hsfll_find_mgr_by_spec(dev, spec);
 
 	if (mgr) {
 		return onoff_release(mgr);
@@ -170,7 +191,7 @@ static int api_cancel_or_release_hsfll(const struct device *dev,
 				       struct onoff_client *cli)
 {
 #ifdef CONFIG_NRFS_DVFS_LOCAL_DOMAIN
-	struct onoff_manager *mgr = hsfll_find_mgr(dev, spec);
+	struct onoff_manager *mgr = hsfll_find_mgr_by_spec(dev, spec);
 
 	if (mgr) {
 		return onoff_cancel_or_release(mgr, cli);
@@ -182,6 +203,25 @@ static int api_cancel_or_release_hsfll(const struct device *dev,
 #endif
 }
 
+static int api_resolve_hsfll(const struct device *dev,
+			     const struct nrf_clock_spec *req_spec,
+			     struct nrf_clock_spec *res_spec)
+{
+#ifdef CONFIG_NRFS_DVFS_LOCAL_DOMAIN
+	int idx;
+
+	idx = hsfll_resolve_spec_to_idx(req_spec);
+	if (idx < 0) {
+		return -EINVAL;
+	}
+
+	hsfll_get_spec_by_idx(idx, res_spec);
+	return 0;
+#else
+	return -ENOTSUP;
+#endif
+}
+
 static int hsfll_init(const struct device *dev)
 {
 #ifdef CONFIG_NRFS_DVFS_LOCAL_DOMAIN
@@ -212,6 +252,7 @@ static DEVICE_API(nrf_clock_control, hsfll_drv_api) = {
 	.request = api_request_hsfll,
 	.release = api_release_hsfll,
 	.cancel_or_release = api_cancel_or_release_hsfll,
+	.resolve = api_resolve_hsfll,
 };
 
 #ifdef CONFIG_NRFS_DVFS_LOCAL_DOMAIN
diff --git a/drivers/clock_control/clock_control_nrf2_lfclk.c b/drivers/clock_control/clock_control_nrf2_lfclk.c
index c5f70c1497b..6be9deee657 100644
--- a/drivers/clock_control/clock_control_nrf2_lfclk.c
+++ b/drivers/clock_control/clock_control_nrf2_lfclk.c
@@ -22,6 +22,8 @@ BUILD_ASSERT(DT_NUM_INST_STATUS_OKAY(DT_DRV_COMPAT) == 1,
 #define LFCLK_LFLPRC_ACCURACY DT_INST_PROP(0, lflprc_accuracy_ppm)
 #define LFCLK_LFRC_ACCURACY DT_INST_PROP(0, lfrc_accuracy_ppm)
 #define LFCLK_HFXO_ACCURACY DT_PROP(LFCLK_HFXO_NODE, accuracy_ppm)
+#define LFCLK_LFLPRC_STARTUP_TIME_US DT_INST_PROP(0, lflprc_startup_time_us)
+#define LFCLK_LFRC_STARTUP_TIME_US DT_INST_PROP(0, lfrc_startup_time_us)
 
 #define LFCLK_MAX_OPTS 5
 #define LFCLK_DEF_OPTS 3
@@ -59,6 +61,8 @@ struct lfclk_dev_data {
 	struct k_timer timer;
 	uint16_t max_accuracy;
 	uint8_t clock_options_cnt;
+	uint32_t hfxo_startup_time_us;
+	uint32_t lfxo_startup_time_us;
 };
 
 struct lfclk_dev_config {
@@ -105,45 +109,108 @@ static void lfclk_work_handler(struct k_work *work)
 	}
 }
 
-static struct onoff_manager *lfclk_find_mgr(const struct device *dev,
-					    const struct nrf_clock_spec *spec)
+static int lfclk_resolve_spec_to_idx(const struct device *dev,
+				     const struct nrf_clock_spec *req_spec)
 {
 	struct lfclk_dev_data *dev_data = dev->data;
 	const struct lfclk_dev_config *dev_config = dev->config;
-	uint16_t accuracy;
+	uint16_t req_accuracy;
 
-	if (!spec) {
-		return &dev_data->clk_cfg.onoff[0].mgr;
-	}
-
-	if (spec->frequency > dev_config->fixed_frequency) {
+	if (req_spec->frequency > dev_config->fixed_frequency) {
 		LOG_ERR("invalid frequency");
-		return NULL;
+		return -EINVAL;
 	}
 
-	accuracy = spec->accuracy == NRF_CLOCK_CONTROL_ACCURACY_MAX
-		 ? dev_data->max_accuracy
-		 : spec->accuracy;
+	req_accuracy = req_spec->accuracy == NRF_CLOCK_CONTROL_ACCURACY_MAX
+		     ? dev_data->max_accuracy
+		     : req_spec->accuracy;
 
 	for (int i = 0; i < dev_data->clock_options_cnt; ++i) {
-		if ((accuracy &&
-		     accuracy < clock_options[i].accuracy) ||
-		    spec->precision > clock_options[i].precision) {
+		if ((req_accuracy &&
+		     req_accuracy < clock_options[i].accuracy) ||
+		     req_spec->precision > clock_options[i].precision) {
 			continue;
 		}
 
-		return &dev_data->clk_cfg.onoff[i].mgr;
+		return i;
 	}
 
 	LOG_ERR("invalid accuracy or precision");
-	return NULL;
+	return -EINVAL;
+}
+
+static void lfclk_get_spec_by_idx(const struct device *dev,
+				  uint8_t idx,
+				  struct nrf_clock_spec *spec)
+{
+	const struct lfclk_dev_config *dev_config = dev->config;
+
+	spec->frequency = dev_config->fixed_frequency;
+	spec->accuracy = clock_options[idx].accuracy;
+	spec->precision = clock_options[idx].precision;
+}
+
+static struct onoff_manager *lfclk_get_mgr_by_idx(const struct device *dev, uint8_t idx)
+{
+	struct lfclk_dev_data *dev_data = dev->data;
+
+	return &dev_data->clk_cfg.onoff[idx].mgr;
+}
+
+static int lfclk_get_startup_time_by_idx(const struct device *dev,
+					 uint8_t idx,
+					 uint32_t *startup_time_us)
+{
+	struct lfclk_dev_data *dev_data = dev->data;
+	nrfs_clock_src_t src = clock_options[idx].src;
+
+	switch (src) {
+	case NRFS_CLOCK_SRC_LFCLK_LFLPRC:
+		*startup_time_us = LFCLK_LFLPRC_STARTUP_TIME_US;
+		return 0;
+
+	case NRFS_CLOCK_SRC_LFCLK_LFRC:
+		*startup_time_us = LFCLK_LFRC_STARTUP_TIME_US;
+		return 0;
+
+	case NRFS_CLOCK_SRC_LFCLK_XO_PIXO:
+	case NRFS_CLOCK_SRC_LFCLK_XO_PIERCE:
+	case NRFS_CLOCK_SRC_LFCLK_XO_EXT_SINE:
+	case NRFS_CLOCK_SRC_LFCLK_XO_EXT_SQUARE:
+	case NRFS_CLOCK_SRC_LFCLK_XO_PIERCE_HP:
+	case NRFS_CLOCK_SRC_LFCLK_XO_EXT_SINE_HP:
+		*startup_time_us = dev_data->lfxo_startup_time_us;
+		return 0;
+
+	case NRFS_CLOCK_SRC_LFCLK_SYNTH:
+		*startup_time_us = dev_data->hfxo_startup_time_us;
+		return 0;
+
+	default:
+		break;
+	}
+
+	return -EINVAL;
+}
+
+static struct onoff_manager *lfclk_find_mgr_by_spec(const struct device *dev,
+						    const struct nrf_clock_spec *spec)
+{
+	int idx;
+
+	if (!spec) {
+		return lfclk_get_mgr_by_idx(dev, 0);
+	}
+
+	idx = lfclk_resolve_spec_to_idx(dev, spec);
+	return idx < 0 ? NULL : lfclk_get_mgr_by_idx(dev, idx);
 }
 
 static int api_request_lfclk(const struct device *dev,
 			     const struct nrf_clock_spec *spec,
 			     struct onoff_client *cli)
 {
-	struct onoff_manager *mgr = lfclk_find_mgr(dev, spec);
+	struct onoff_manager *mgr = lfclk_find_mgr_by_spec(dev, spec);
 
 	if (mgr) {
 		return clock_config_request(mgr, cli);
@@ -155,7 +222,7 @@ static int api_request_lfclk(const struct device *dev,
 static int api_release_lfclk(const struct device *dev,
 			     const struct nrf_clock_spec *spec)
 {
-	struct onoff_manager *mgr = lfclk_find_mgr(dev, spec);
+	struct onoff_manager *mgr = lfclk_find_mgr_by_spec(dev, spec);
 
 	if (mgr) {
 		return onoff_release(mgr);
@@ -168,7 +235,7 @@ static int api_cancel_or_release_lfclk(const struct device *dev,
 				       const struct nrf_clock_spec *spec,
 				       struct onoff_client *cli)
 {
-	struct onoff_manager *mgr = lfclk_find_mgr(dev, spec);
+	struct onoff_manager *mgr = lfclk_find_mgr_by_spec(dev, spec);
 
 	if (mgr) {
 		return onoff_cancel_or_release(mgr, cli);
@@ -177,6 +244,36 @@ static int api_cancel_or_release_lfclk(const struct device *dev,
 	return -EINVAL;
 }
 
+
+static int api_resolve(const struct device *dev,
+		       const struct nrf_clock_spec *req_spec,
+		       struct nrf_clock_spec *res_spec)
+{
+	int idx;
+
+	idx = lfclk_resolve_spec_to_idx(dev, req_spec);
+	if (idx < 0) {
+		return -EINVAL;
+	}
+
+	lfclk_get_spec_by_idx(dev, idx, res_spec);
+	return 0;
+}
+
+static int api_get_startup_time(const struct device *dev,
+				const struct nrf_clock_spec *spec,
+				uint32_t *startup_time_us)
+{
+	int idx;
+
+	idx = lfclk_resolve_spec_to_idx(dev, spec);
+	if (idx < 0) {
+		return -EINVAL;
+	}
+
+	return lfclk_get_startup_time_by_idx(dev, idx, startup_time_us);
+}
+
 static int api_get_rate_lfclk(const struct device *dev,
 			      clock_control_subsys_t sys,
 			      uint32_t *rate)
@@ -251,6 +348,19 @@ static int lfclk_init(const struct device *dev)
 			LOG_ERR("Unexpected LFOSC mode");
 			return -EINVAL;
 		}
+
+		dev_data->lfxo_startup_time_us = nrf_bicr_lfosc_startup_time_ms_get(BICR)
+					       * USEC_PER_MSEC;
+		if (dev_data->lfxo_startup_time_us == NRF_BICR_LFOSC_STARTUP_TIME_UNCONFIGURED) {
+			LOG_ERR("BICR LFXO startup time invalid");
+			return -ENODEV;
+		}
+	}
+
+	dev_data->hfxo_startup_time_us = nrf_bicr_hfxo_startup_time_us_get(BICR);
+	if (dev_data->hfxo_startup_time_us == NRF_BICR_HFXO_STARTUP_TIME_UNCONFIGURED) {
+		LOG_ERR("BICR HFXO startup time invalid");
+		return -ENODEV;
 	}
 
 	k_timer_init(&dev_data->timer, lfclk_update_timeout_handler, NULL);
@@ -269,6 +379,8 @@ static DEVICE_API(nrf_clock_control, lfclk_drv_api) = {
 	.request = api_request_lfclk,
 	.release = api_release_lfclk,
 	.cancel_or_release = api_cancel_or_release_lfclk,
+	.resolve = api_resolve,
+	.get_startup_time = api_get_startup_time,
 };
 
 static struct lfclk_dev_data lfclk_data;
diff --git a/dts/bindings/clock/nordic,nrf-fll16m.yaml b/dts/bindings/clock/nordic,nrf-fll16m.yaml
index 8c7187965ae..cfbbb0c4093 100644
--- a/dts/bindings/clock/nordic,nrf-fll16m.yaml
+++ b/dts/bindings/clock/nordic,nrf-fll16m.yaml
@@ -18,6 +18,7 @@ description: |
 
     fll16m {
             open-loop-accuracy-ppm = <20000>;
+            open-loop-startup-time-us = <400>;
             clocks = <&hfxo>, <&lfxo>;
             clock-names = "hfxo", "lfxo";
     };
@@ -32,4 +33,10 @@ properties:
 
   open-loop-accuracy-ppm:
     type: int
-    description: Clock accuracy in parts per million if open-loop clock source is used.
+    description: Clock accuracy in parts per million
+    required: true
+
+  open-loop-startup-time-us:
+    type: int
+    description: Clock startup time if open-loop clock source is used.
+    required: true
diff --git a/dts/bindings/clock/nordic,nrf-lfclk.yaml b/dts/bindings/clock/nordic,nrf-lfclk.yaml
index f7df4d8a435..a0f95d6c927 100644
--- a/dts/bindings/clock/nordic,nrf-lfclk.yaml
+++ b/dts/bindings/clock/nordic,nrf-lfclk.yaml
@@ -21,6 +21,8 @@ description: |
     lfclk {
             lfrc-accuracy-ppm = <500>;
             lflprc-accuracy-ppm = <1000>;
+            lfrc-startup-time-us = <400>;
+            lflprc-startup-time-us = <400>;
             clocks = <&hfxo>, <&lfxo>;
             clock-names = "hfxo", "lfxo";
     };
@@ -40,3 +42,11 @@ properties:
   lflprc-accuracy-ppm:
     type: int
     description: Clock accuracy in parts per million if LFLPRC clock source is used.
+
+  lfrc-startup-time-us:
+    type: int
+    description: Clock startup time in microseconds if LFRC clock source is used.
+
+  lflprc-startup-time-us:
+    type: int
+    description: Clock startup time in microseconds if LFLPRC clock source is used.
diff --git a/dts/vendor/nordic/nrf54h20.dtsi b/dts/vendor/nordic/nrf54h20.dtsi
index f5e92434b7c..a48942b4cda 100644
--- a/dts/vendor/nordic/nrf54h20.dtsi
+++ b/dts/vendor/nordic/nrf54h20.dtsi
@@ -177,6 +177,7 @@
 			#clock-cells = <0>;
 			clock-frequency = <DT_FREQ_M(16)>;
 			open-loop-accuracy-ppm = <20000>;
+			open-loop-startup-time-us = <200>; /* To be measured */
 			clocks = <&hfxo>, <&lfxo>;
 			clock-names = "hfxo", "lfxo";
 		};
@@ -199,6 +200,8 @@
 			status = "okay";
 			lfrc-accuracy-ppm = <500>;
 			lflprc-accuracy-ppm = <1000>;
+			lfrc-startup-time-us = <200>; /* To be measured */
+			lflprc-startup-time-us = <200>; /* To be measured */
 			clocks = <&hfxo>, <&lfxo>;
 			clock-names = "hfxo", "lfxo";
 		};
diff --git a/include/zephyr/drivers/clock_control/nrf_clock_control.h b/include/zephyr/drivers/clock_control/nrf_clock_control.h
index bbc581f96c4..d12dca3c074 100644
--- a/include/zephyr/drivers/clock_control/nrf_clock_control.h
+++ b/include/zephyr/drivers/clock_control/nrf_clock_control.h
@@ -204,6 +204,12 @@ __subsystem struct nrf_clock_control_driver_api {
 	int (*cancel_or_release)(const struct device *dev,
 				 const struct nrf_clock_spec *spec,
 				 struct onoff_client *cli);
+	int (*resolve)(const struct device *dev,
+		       const struct nrf_clock_spec *req_spec,
+		       struct nrf_clock_spec *res_spec);
+	int (*get_startup_time)(const struct device *dev,
+				const struct nrf_clock_spec *spec,
+				uint32_t *startup_time_us);
 };
 
 /**
@@ -324,6 +330,53 @@ int nrf_clock_control_cancel_or_release(const struct device *dev,
 	return api->cancel_or_release(dev, spec, cli);
 }
 
+/**
+ * @brief Resolve a requested clock spec to resulting spec.
+ *
+ * @param dev Device structure.
+ * @param req_spec The requested clock specification.
+ * @param res_spec Destination for the resulting clock specification.
+ *
+ * @retval Successful if successful.
+ * @retval -errno code if failure
+ */
+static inline int nrf_clock_control_resolve(const struct device *dev,
+					    const struct nrf_clock_spec *req_spec,
+					    struct nrf_clock_spec *res_spec)
+{
+	const struct nrf_clock_control_driver_api *api =
+		(const struct nrf_clock_control_driver_api *)dev->api;
+
+	if (api->resolve == NULL) {
+		return -ENOSYS;
+	}
+
+	return api->resolve(dev, req_spec, res_spec);
+}
+
+/**
+ * @brief Get the startup timme of a clock.
+ *
+ * @param dev Device structure.
+ * @param startup_time_us Destination for startup time in microseconds.
+ *
+ * @retval Successful if successful.
+ * @retval -errno code if failure.
+ */
+static inline int nrf_clock_control_get_startup_time(const struct device *dev,
+						     const struct nrf_clock_spec *spec,
+						     uint32_t *startup_time_us)
+{
+	const struct nrf_clock_control_driver_api *api =
+		(const struct nrf_clock_control_driver_api *)dev->api;
+
+	if (api->get_startup_time == NULL) {
+		return -ENOSYS;
+	}
+
+	return api->get_startup_time(dev, spec, startup_time_us);
+}
+
 /** @brief Request the HFXO from Zero Latency Interrupt context.
  *
  * Function is optimized for use in Zero Latency Interrupt context.
diff --git a/samples/boards/nordic/clock_control/src/main.c b/samples/boards/nordic/clock_control/src/main.c
index ebaaa0cecbd..d2823db92ac 100644
--- a/samples/boards/nordic/clock_control/src/main.c
+++ b/samples/boards/nordic/clock_control/src/main.c
@@ -45,6 +45,13 @@ int main(void)
 	int res;
 	int64_t req_start_uptime;
 	int64_t req_stop_uptime;
+	struct nrf_clock_spec res_spec;
+	const struct nrf_clock_spec req_spec = {
+		.frequency = CONFIG_SAMPLE_CLOCK_FREQUENCY_HZ,
+		.accuracy = CONFIG_SAMPLE_CLOCK_ACCURACY_PPM,
+		.precision = CONFIG_SAMPLE_CLOCK_PRECISION,
+	};
+	uint32_t startup_time_us;
 
 	printk("\n");
 	printk("clock name: %s\n", SAMPLE_CLOCK_NAME);
@@ -52,11 +59,29 @@ int main(void)
 	printk("minimum accuracy request: %uPPM\n", CONFIG_SAMPLE_CLOCK_ACCURACY_PPM);
 	printk("minimum precision request: %u\n", CONFIG_SAMPLE_CLOCK_PRECISION);
 
-	const struct nrf_clock_spec spec = {
-		.frequency = CONFIG_SAMPLE_CLOCK_FREQUENCY_HZ,
-		.accuracy = CONFIG_SAMPLE_CLOCK_ACCURACY_PPM,
-		.precision = CONFIG_SAMPLE_CLOCK_PRECISION,
-	};
+	printk("\n");
+	ret = nrf_clock_control_resolve(sample_clock_dev, &req_spec, &res_spec);
+	if (ret == 0) {
+		printk("resolved frequency request: %uHz\n", res_spec.frequency);
+		printk("resolved accuracy request: %uPPM\n", res_spec.accuracy);
+		printk("resolved precision request: %u\n", res_spec.precision);
+	} else if (ret == -ENOSYS) {
+		printk("resolve not supported\n");
+	} else {
+		printk("minimum clock specs could not be resolved\n");
+		return 0;
+	}
+
+	printk("\n");
+	ret = nrf_clock_control_get_startup_time(sample_clock_dev, &req_spec, &startup_time_us);
+	if (ret == 0) {
+		printk("startup time for requested spec: %uus\n", startup_time_us);
+	} else if (ret == -ENOSYS) {
+		printk("get startup time not supported\n");
+	} else {
+		printk("failed to get startup time\n");
+		return 0;
+	}
 
 	sys_notify_init_callback(&cli.notify, sample_notify_cb);
 
@@ -65,7 +90,7 @@ int main(void)
 	printk("\n");
 	printk("requesting minimum clock specs\n");
 	req_start_uptime = k_uptime_get();
-	ret = nrf_clock_control_request(sample_clock_dev, &spec, &cli);
+	ret = nrf_clock_control_request(sample_clock_dev, &req_spec, &cli);
 	if (ret < 0) {
 		printk("minimum clock specs could not be met\n");
 		return 0;
@@ -95,7 +120,7 @@ int main(void)
 
 	printk("\n");
 	printk("releasing requested clock specs\n");
-	ret = nrf_clock_control_release(sample_clock_dev, &spec);
+	ret = nrf_clock_control_release(sample_clock_dev, &req_spec);
 	if (ret < 0) {
 		printk("failed to release requested clock specs\n");
 		return 0;