nrf_clock_control.h

Go to the documentation of this file.

/*
 * Copyright (c) 2016 Nordic Semiconductor ASA
 *
 * SPDX-License-Identifier: Apache-2.0
 */

 
#ifndef ZEPHYR_INCLUDE_DRIVERS_CLOCK_CONTROL_NRF_CLOCK_CONTROL_H_
#define ZEPHYR_INCLUDE_DRIVERS_CLOCK_CONTROL_NRF_CLOCK_CONTROL_H_
 
#include <zephyr/device.h>
#include <zephyr/sys/onoff.h>
#include <zephyr/drivers/clock_control.h>

 
#ifdef __cplusplus
extern "C" {
#endif
 
#if !(defined(CONFIG_SOC_SERIES_NRF54H) || defined(CONFIG_SOC_SERIES_NRF92))
 
#include <hal/nrf_clock.h>
 
#if defined(CONFIG_CLOCK_CONTROL_NRF)
enum __deprecated clock_control_nrf_type {
        CLOCK_CONTROL_NRF_TYPE_HFCLK, 
        CLOCK_CONTROL_NRF_TYPE_LFCLK, 
#if NRF_CLOCK_HAS_HFCLK24M
        CLOCK_CONTROL_NRF_TYPE_HFCLK24M, 
#endif
#if NRF_CLOCK_HAS_HFCLK192M
        CLOCK_CONTROL_NRF_TYPE_HFCLK192M, 
#endif
#if NRF_CLOCK_HAS_HFCLKAUDIO
        CLOCK_CONTROL_NRF_TYPE_HFCLKAUDIO, 
#endif
        CLOCK_CONTROL_NRF_TYPE_COUNT 
};

#define CLOCK_CONTROL_NRF_SUBSYS_HF \
        ((clock_control_subsys_t)CLOCK_CONTROL_NRF_TYPE_HFCLK) __DEPRECATED_MACRO
#define CLOCK_CONTROL_NRF_SUBSYS_LF \
        ((clock_control_subsys_t)CLOCK_CONTROL_NRF_TYPE_LFCLK) __DEPRECATED_MACRO
#define CLOCK_CONTROL_NRF_SUBSYS_HF24M \
        ((clock_control_subsys_t)CLOCK_CONTROL_NRF_TYPE_HFCLK24M) __DEPRECATED_MACRO
#define CLOCK_CONTROL_NRF_SUBSYS_HF192M \
        ((clock_control_subsys_t)CLOCK_CONTROL_NRF_TYPE_HFCLK192M) __DEPRECATED_MACRO
#define CLOCK_CONTROL_NRF_SUBSYS_HFAUDIO \
        ((clock_control_subsys_t)CLOCK_CONTROL_NRF_TYPE_HFCLKAUDIO) __DEPRECATED_MACRO

 
/* Define 32KHz clock source */
#ifdef CONFIG_CLOCK_CONTROL_NRF_K32SRC_RC
#define CLOCK_CONTROL_NRF_K32SRC NRF_CLOCK_LFCLK_RC __DEPRECATED_MACRO
#endif
#ifdef CONFIG_CLOCK_CONTROL_NRF_K32SRC_XTAL
#define CLOCK_CONTROL_NRF_K32SRC NRF_CLOCK_LFCLK_XTAL __DEPRECATED_MACRO
#endif
#ifdef CONFIG_CLOCK_CONTROL_NRF_K32SRC_SYNTH
#define CLOCK_CONTROL_NRF_K32SRC NRF_CLOCK_LFCLK_SYNTH __DEPRECATED_MACRO
#endif
#ifdef CONFIG_CLOCK_CONTROL_NRF_K32SRC_EXT_LOW_SWING
#define CLOCK_CONTROL_NRF_K32SRC NRF_CLOCK_LFCLK_XTAL_LOW_SWING __DEPRECATED_MACRO
#endif
#ifdef CONFIG_CLOCK_CONTROL_NRF_K32SRC_EXT_FULL_SWING
#define CLOCK_CONTROL_NRF_K32SRC NRF_CLOCK_LFCLK_XTAL_FULL_SWING __DEPRECATED_MACRO
#endif
 
/* Define 32KHz clock accuracy */
#ifdef CONFIG_CLOCK_CONTROL_NRF_K32SRC_500PPM
#define CLOCK_CONTROL_NRF_K32SRC_ACCURACY 0 __DEPRECATED_MACRO
#endif
#ifdef CONFIG_CLOCK_CONTROL_NRF_K32SRC_250PPM
#define CLOCK_CONTROL_NRF_K32SRC_ACCURACY 1 __DEPRECATED_MACRO
#endif
#ifdef CONFIG_CLOCK_CONTROL_NRF_K32SRC_150PPM
#define CLOCK_CONTROL_NRF_K32SRC_ACCURACY 2 __DEPRECATED_MACRO
#endif
#ifdef CONFIG_CLOCK_CONTROL_NRF_K32SRC_100PPM
#define CLOCK_CONTROL_NRF_K32SRC_ACCURACY 3 __DEPRECATED_MACRO
#endif
#ifdef CONFIG_CLOCK_CONTROL_NRF_K32SRC_75PPM
#define CLOCK_CONTROL_NRF_K32SRC_ACCURACY 4 __DEPRECATED_MACRO
#endif
#ifdef CONFIG_CLOCK_CONTROL_NRF_K32SRC_50PPM
#define CLOCK_CONTROL_NRF_K32SRC_ACCURACY 5 __DEPRECATED_MACRO
#endif
#ifdef CONFIG_CLOCK_CONTROL_NRF_K32SRC_30PPM
#define CLOCK_CONTROL_NRF_K32SRC_ACCURACY 6 __DEPRECATED_MACRO
#endif
#ifdef CONFIG_CLOCK_CONTROL_NRF_K32SRC_20PPM
#define CLOCK_CONTROL_NRF_K32SRC_ACCURACY 7 __DEPRECATED_MACRO
#endif

 
#endif /* defined(CONFIG_CLOCK_CONTROL_NRF) */

enum nrf_lfclk_start_mode {
        CLOCK_CONTROL_NRF_LF_START_NOWAIT,    
        CLOCK_CONTROL_NRF_LF_START_AVAILABLE, 
        CLOCK_CONTROL_NRF_LF_START_STABLE,    
};


void z_nrf_clock_calibration_force_start(void);

int z_nrf_clock_calibration_count(void);

int z_nrf_clock_calibration_skips_count(void);
 

bool z_nrf_clock_calibration_is_in_progress(void);
 
#if defined(CONFIG_CLOCK_CONTROL_NRF)
struct onoff_manager __deprecated *z_nrf_clock_control_get_onoff(clock_control_subsys_t sys);
#endif

void z_nrf_clock_control_lf_on(enum nrf_lfclk_start_mode start_mode);

void z_nrf_clock_bt_ctlr_hf_request(void);

void z_nrf_clock_bt_ctlr_hf_release(void);

uint32_t z_nrf_clock_bt_ctlr_hf_get_startup_time_us(void);

 
#endif /* !(defined(CONFIG_SOC_SERIES_NRF54H) || defined(CONFIG_SOC_SERIES_NRF92)) */

#define NRF_CLOCK_CONTROL_FREQUENCY_MAX UINT32_MAX

#define NRF_CLOCK_CONTROL_ACCURACY_MAX      1
#define NRF_CLOCK_CONTROL_ACCURACY_PPM(ppm) (ppm)

#define NRF_CLOCK_CONTROL_PRECISION_HIGH    1
#define NRF_CLOCK_CONTROL_PRECISION_DEFAULT 0

#define CLOCK_CONTROL_NRF_AUXPLL_FREQ_OUT_MIN_HZ        80000000
#define CLOCK_CONTROL_NRF_AUXPLL_FREQ_OUT_AUDIO_44K1_HZ 11289591
#define CLOCK_CONTROL_NRF_AUXPLL_FREQ_OUT_USB24M_HZ     24000000
#define CLOCK_CONTROL_NRF_AUXPLL_FREQ_OUT_AUDIO_48K_HZ  12287963

 
/* Internal helper macro to map DT property value to output frequency */
#define _CLOCK_CONTROL_NRF_AUXPLL_MAP_FREQ(freq_val)                      \
        ((freq_val) == NRF_AUXPLL_FREQ_DIV_MIN ?                          \
                       CLOCK_CONTROL_NRF_AUXPLL_FREQ_OUT_MIN_HZ :         \
         (freq_val) == NRF_AUXPLL_FREQ_DIV_AUDIO_44K1 ?                   \
                       CLOCK_CONTROL_NRF_AUXPLL_FREQ_OUT_AUDIO_44K1_HZ :  \
         (freq_val) == NRF_AUXPLL_FREQ_DIV_USB24M ?                       \
                       CLOCK_CONTROL_NRF_AUXPLL_FREQ_OUT_USB24M_HZ :      \
         (freq_val) == NRF_AUXPLL_FREQ_DIV_AUDIO_48K ?                    \
                       CLOCK_CONTROL_NRF_AUXPLL_FREQ_OUT_AUDIO_48K_HZ : 0)


#define CLOCK_CONTROL_NRF_AUXPLL_GET_FREQ(node) \
        COND_CODE_1(DT_NODE_HAS_PROP(node, nordic_frequency), \
                (_CLOCK_CONTROL_NRF_AUXPLL_MAP_FREQ(DT_PROP(node, nordic_frequency))), \
                (0))

 
struct nrf_clock_spec {
        uint32_t frequency;
        uint16_t accuracy : 15;
        uint16_t precision : 1;
};
 
__subsystem struct nrf_clock_control_driver_api {
        struct clock_control_driver_api std_api;
 
        int (*request)(const struct device *dev,
                       const struct nrf_clock_spec *spec,
                       struct onoff_client *cli);
        int (*release)(const struct device *dev,
                       const struct nrf_clock_spec *spec);
        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);
};
 
DEVICE_API_EXTENDS(nrf_clock_control, clock_control, std_api);


static inline
int nrf_clock_control_request(const struct device *dev,
                              const struct nrf_clock_spec *spec,
                              struct onoff_client *cli)
{
        return DEVICE_API_GET(nrf_clock_control, dev)->request(dev, spec, cli);
}

int nrf_clock_control_request_sync(const struct device *dev,
                                   const struct nrf_clock_spec *spec,
                                   k_timeout_t timeout);

static inline
int nrf_clock_control_release(const struct device *dev,
                              const struct nrf_clock_spec *spec)
{
        return DEVICE_API_GET(nrf_clock_control, dev)->release(dev, spec);
}

static inline
int nrf_clock_control_cancel_or_release(const struct device *dev,
                                        const struct nrf_clock_spec *spec,
                                        struct onoff_client *cli)
{
        return DEVICE_API_GET(nrf_clock_control, dev)->cancel_or_release(dev, spec, cli);
}

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 = DEVICE_API_GET(nrf_clock_control, dev);
 
        if (api->resolve == NULL) {
                return -ENOSYS;
        }
 
        return api->resolve(dev, req_spec, res_spec);
}

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 = DEVICE_API_GET(nrf_clock_control, dev);
 
        if (api->get_startup_time == NULL) {
                return -ENOSYS;
        }
 
        return api->get_startup_time(dev, spec, startup_time_us);
}

void nrf_clock_control_hfxo_request(void);

void nrf_clock_control_hfxo_release(void);
 
#ifdef __cplusplus
}
#endif

 
#endif /* ZEPHYR_INCLUDE_DRIVERS_CLOCK_CONTROL_NRF_CLOCK_CONTROL_H_ */