drivers: clock_control: nrf2_lfclk: impl resolve and startup_time

Implement nrf_clock_control_resolve() and
nrf_clock_control_get_startup_time_us() APIs.

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

Author: bjarki-andreasen

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;

dts/bindings/clock/nordic,nrf-fll16m.yaml

@@ -32,4 +32,5 @@ 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

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.

dts/vendor/nordic/nrf54h20.dtsi

@@ -199,6 +199,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";
 		};