clock_monitor.h

Go to the documentation of this file.

/*
 * SPDX-FileCopyrightText: 2026 NXP
 *
 * SPDX-License-Identifier: Apache-2.0
 */

 
#ifndef ZEPHYR_INCLUDE_DRIVERS_CLOCK_MONITOR_H_
#define ZEPHYR_INCLUDE_DRIVERS_CLOCK_MONITOR_H_

 
#include <errno.h>
#include <stdbool.h>
#include <stdint.h>
 
#include <zephyr/device.h>
#include <zephyr/kernel.h>
#include <zephyr/sys/util.h>
 
#ifdef __cplusplus
extern "C" {
#endif

enum clock_monitor_mode {
        CLOCK_MONITOR_MODE_WINDOW = 1,
        CLOCK_MONITOR_MODE_MEASURE,
};

enum {
        CLOCK_MONITOR_EVT_FREQ_HIGH    = BIT(0),
        CLOCK_MONITOR_EVT_FREQ_LOW     = BIT(1),
        CLOCK_MONITOR_EVT_CLOCK_LOST   = BIT(2),
        CLOCK_MONITOR_EVT_MEASURE_DONE = BIT(3),
};

struct clock_monitor_window_cfg {
        uint32_t expected_hz;
        uint32_t tolerance_ppm;
        uint32_t window_ns;
};

struct clock_monitor_measure_cfg {
        uint32_t window_ns;
};

struct clock_monitor_event_data {
        uint32_t events;
        uint32_t measured_hz;
};

typedef void (*clock_monitor_callback_t)(const struct device *dev,
                                         const struct clock_monitor_event_data *evt,
                                         void *user_data);

struct clock_monitor_config {
        enum clock_monitor_mode mode;
        union {
                struct clock_monitor_window_cfg window;
                struct clock_monitor_measure_cfg measure;
        };
        clock_monitor_callback_t callback;
        void *user_data;
};


typedef int (*clock_monitor_api_configure)(const struct device *dev,
                                           const struct clock_monitor_config *cfg);

typedef int (*clock_monitor_api_start)(const struct device *dev);

typedef int (*clock_monitor_api_stop)(const struct device *dev);

typedef int (*clock_monitor_api_get_rate)(const struct device *dev,
                                          uint32_t *rate_hz);

typedef int (*clock_monitor_api_set_source)(const struct device *dev,
                                            uint32_t reference,
                                            uint32_t target);

__subsystem struct clock_monitor_driver_api {
        clock_monitor_api_configure      configure;
        clock_monitor_api_start          start;
        clock_monitor_api_stop           stop;
        clock_monitor_api_get_rate       get_rate;
        clock_monitor_api_set_source     set_source;
};


__syscall int clock_monitor_configure(const struct device *dev,
                                      const struct clock_monitor_config *cfg);
 
static inline int z_impl_clock_monitor_configure(const struct device *dev,
                                                 const struct clock_monitor_config *cfg)
{
        return DEVICE_API_GET(clock_monitor, dev)->configure(dev, cfg);
}

__syscall int clock_monitor_start(const struct device *dev);
 
static inline int z_impl_clock_monitor_start(const struct device *dev)
{
        return DEVICE_API_GET(clock_monitor, dev)->start(dev);
}

__syscall int clock_monitor_stop(const struct device *dev);
 
static inline int z_impl_clock_monitor_stop(const struct device *dev)
{
        return DEVICE_API_GET(clock_monitor, dev)->stop(dev);
}

__syscall int clock_monitor_get_rate(const struct device *dev,
                                     uint32_t *rate_hz);
 
static inline int z_impl_clock_monitor_get_rate(const struct device *dev,
                                                uint32_t *rate_hz)
{
        const struct clock_monitor_driver_api *api =
                DEVICE_API_GET(clock_monitor, dev);
 
        if (api->get_rate == NULL) {
                return -ENOSYS;
        }
        return api->get_rate(dev, rate_hz);
}

__syscall int clock_monitor_set_source(const struct device *dev,
                                       uint32_t reference, uint32_t target);
 
static inline int z_impl_clock_monitor_set_source(const struct device *dev,
                                                  uint32_t reference,
                                                  uint32_t target)
{
        const struct clock_monitor_driver_api *api =
                DEVICE_API_GET(clock_monitor, dev);
 
        if (api->set_source == NULL) {
                return -ENOSYS;
        }
        return api->set_source(dev, reference, target);
}
 
#ifdef __cplusplus
}
#endif

 
#include <zephyr/syscalls/clock_monitor.h>
 
#endif /* ZEPHYR_INCLUDE_DRIVERS_CLOCK_MONITOR_H_ */