michaelh/zephyr
1
0
Fork 0
Code Releases Activity

drivers: clock_control: nrf2_lfclk: impl resolve and startup_time

Browse source 
Implement nrf_clock_control_resolve() and
nrf_clock_control_get_startup_time_us() APIs.

Signed-off-by: Bjarki Arge Andreasen <bjarki.andreasen@nordicsemi.no>
This commit is contained in:
Bjarki Arge Andreasen 2025-05-22 18:28:08 +02:00 • committed by Benjamin Cabé
commit b20a233b05
4 changed files with 146 additions and 21 deletions
Download patch file Download diff file Expand all files Collapse all files

152
drivers/clock_control/clock_control_nrf2_lfclk.c
View file

@ -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;

3
dts/bindings/clock/nordic,nrf-fll16m.yaml
View file

@ -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

10
dts/bindings/clock/nordic,nrf-lfclk.yaml
View file

@ -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.

2
dts/vendor/nordic/nrf54h20.dtsi vendored
View file

@ -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";
};