counter.h

Go to the documentation of this file.

/*
 * Copyright (c) 2018 Nordic Semiconductor ASA
 * Copyright (c) 2016 Intel Corporation
 *
 * SPDX-License-Identifier: Apache-2.0
 */
 
#ifndef ZEPHYR_INCLUDE_DRIVERS_COUNTER_H_
#define ZEPHYR_INCLUDE_DRIVERS_COUNTER_H_
 
#include <errno.h>
 
#include <zephyr/types.h>
#include <stddef.h>
#include <zephyr/device.h>
#include <zephyr/sys_clock.h>
#include <stdbool.h>
 
#ifdef __cplusplus
extern "C" {
#endif
 
#define COUNTER_CONFIG_INFO_COUNT_UP BIT(0)
 
#define COUNTER_TOP_CFG_DONT_RESET BIT(0)
 
#define COUNTER_TOP_CFG_RESET_WHEN_LATE BIT(1)
 
#define COUNTER_ALARM_CFG_ABSOLUTE BIT(0)
 
#define COUNTER_ALARM_CFG_EXPIRE_WHEN_LATE  BIT(1)
 
#define COUNTER_GUARD_PERIOD_LATE_TO_SET BIT(0)
 
typedef void (*counter_alarm_callback_t)(const struct device *dev,
                                         uint8_t chan_id, uint32_t ticks,
                                         void *user_data);
 
struct counter_alarm_cfg {
        counter_alarm_callback_t callback;
        uint32_t ticks;
        void *user_data;
        uint32_t flags;
};
 
typedef void (*counter_top_callback_t)(const struct device *dev,
                                       void *user_data);
 
struct counter_top_cfg {
        uint32_t ticks;
        counter_top_callback_t callback;
        void *user_data;
        uint32_t flags;
};
 
struct counter_config_info {
        uint32_t max_top_value;
        uint32_t freq;
        uint8_t flags;
        uint8_t channels;
};
 
typedef int (*counter_api_start)(const struct device *dev);
typedef int (*counter_api_stop)(const struct device *dev);
typedef int (*counter_api_get_value)(const struct device *dev,
                                     uint32_t *ticks);
typedef int (*counter_api_get_value_64)(const struct device *dev,
                        uint64_t *ticks);
typedef int (*counter_api_reset)(const struct device *dev);
typedef int (*counter_api_set_alarm)(const struct device *dev,
                                     uint8_t chan_id,
                                     const struct counter_alarm_cfg *alarm_cfg);
typedef int (*counter_api_cancel_alarm)(const struct device *dev,
                                        uint8_t chan_id);
typedef int (*counter_api_set_top_value)(const struct device *dev,
                                         const struct counter_top_cfg *cfg);
typedef uint32_t (*counter_api_get_pending_int)(const struct device *dev);
typedef uint32_t (*counter_api_get_top_value)(const struct device *dev);
typedef uint32_t (*counter_api_get_guard_period)(const struct device *dev,
                                                 uint32_t flags);
typedef int (*counter_api_set_guard_period)(const struct device *dev,
                                                uint32_t ticks,
                                                uint32_t flags);
typedef uint32_t (*counter_api_get_freq)(const struct device *dev);
 
__subsystem struct counter_driver_api {
        counter_api_start start;
        counter_api_stop stop;
        counter_api_get_value get_value;
        counter_api_get_value_64 get_value_64;
        counter_api_reset reset;
        counter_api_set_alarm set_alarm;
        counter_api_cancel_alarm cancel_alarm;
        counter_api_set_top_value set_top_value;
        counter_api_get_pending_int get_pending_int;
        counter_api_get_top_value get_top_value;
        counter_api_get_guard_period get_guard_period;
        counter_api_set_guard_period set_guard_period;
        counter_api_get_freq get_freq;
};
 
__syscall bool counter_is_counting_up(const struct device *dev);
 
static inline bool z_impl_counter_is_counting_up(const struct device *dev)
{
        const struct counter_config_info *config =
                        (const struct counter_config_info *)dev->config;
 
        return config->flags & COUNTER_CONFIG_INFO_COUNT_UP;
}
 
__syscall uint8_t counter_get_num_of_channels(const struct device *dev);
 
static inline uint8_t z_impl_counter_get_num_of_channels(const struct device *dev)
{
        const struct counter_config_info *config =
                        (const struct counter_config_info *)dev->config;
 
        return config->channels;
}
 
__syscall uint32_t counter_get_frequency(const struct device *dev);
 
static inline uint32_t z_impl_counter_get_frequency(const struct device *dev)
{
        const struct counter_config_info *config =
                        (const struct counter_config_info *)dev->config;
        const struct counter_driver_api *api =
                                (struct counter_driver_api *)dev->api;
 
        return api->get_freq ? api->get_freq(dev) : config->freq;
}
 
__syscall uint32_t counter_us_to_ticks(const struct device *dev, uint64_t us);
 
static inline uint32_t z_impl_counter_us_to_ticks(const struct device *dev,
                                               uint64_t us)
{
        uint64_t ticks = (us * z_impl_counter_get_frequency(dev)) / USEC_PER_SEC;
 
        return (ticks > (uint64_t)UINT32_MAX) ? UINT32_MAX : ticks;
}
 
__syscall uint64_t counter_ticks_to_us(const struct device *dev, uint32_t ticks);
 
static inline uint64_t z_impl_counter_ticks_to_us(const struct device *dev,
                                               uint32_t ticks)
{
        return ((uint64_t)ticks * USEC_PER_SEC) / z_impl_counter_get_frequency(dev);
}
 
__syscall uint64_t counter_ticks_to_ns(const struct device *dev, uint32_t ticks);
 
static inline uint64_t z_impl_counter_ticks_to_ns(const struct device *dev,
                                               uint32_t ticks)
{
        return ((uint64_t)ticks * NSEC_PER_SEC) / z_impl_counter_get_frequency(dev);
}
 
__syscall uint32_t counter_get_max_top_value(const struct device *dev);
 
static inline uint32_t z_impl_counter_get_max_top_value(const struct device *dev)
{
        const struct counter_config_info *config =
                        (const struct counter_config_info *)dev->config;
 
        return config->max_top_value;
}
 
__syscall int counter_start(const struct device *dev);
 
static inline int z_impl_counter_start(const struct device *dev)
{
        const struct counter_driver_api *api =
                                (struct counter_driver_api *)dev->api;
 
        return api->start(dev);
}
 
__syscall int counter_stop(const struct device *dev);
 
static inline int z_impl_counter_stop(const struct device *dev)
{
        const struct counter_driver_api *api =
                                (struct counter_driver_api *)dev->api;
 
        return api->stop(dev);
}
 
__syscall int counter_get_value(const struct device *dev, uint32_t *ticks);
 
static inline int z_impl_counter_get_value(const struct device *dev,
                                           uint32_t *ticks)
{
        const struct counter_driver_api *api =
                                (struct counter_driver_api *)dev->api;
 
        return api->get_value(dev, ticks);
}
 
__syscall int counter_get_value_64(const struct device *dev, uint64_t *ticks);
 
static inline int z_impl_counter_get_value_64(const struct device *dev,
                                           uint64_t *ticks)
{
        const struct counter_driver_api *api =
                                (struct counter_driver_api *)dev->api;
 
        if (!api->get_value_64) {
                return -ENOSYS;
        }
 
        return api->get_value_64(dev, ticks);
}
 
__syscall int counter_reset(const struct device *dev);
 
static inline int z_impl_counter_reset(const struct device *dev)
{
        const struct counter_driver_api *api =
                                (struct counter_driver_api *)dev->api;
 
        if (!api->reset) {
                return -ENOSYS;
        }
 
        return api->reset(dev);
}
 
__syscall int counter_set_channel_alarm(const struct device *dev,
                                        uint8_t chan_id,
                                        const struct counter_alarm_cfg *alarm_cfg);
 
static inline int z_impl_counter_set_channel_alarm(const struct device *dev,
                                                   uint8_t chan_id,
                                                   const struct counter_alarm_cfg *alarm_cfg)
{
        const struct counter_driver_api *api =
                                (struct counter_driver_api *)dev->api;
 
        if (chan_id >= counter_get_num_of_channels(dev)) {
                return -ENOTSUP;
        }
 
        return api->set_alarm(dev, chan_id, alarm_cfg);
}
 
__syscall int counter_cancel_channel_alarm(const struct device *dev,
                                           uint8_t chan_id);
 
static inline int z_impl_counter_cancel_channel_alarm(const struct device *dev,
                                                      uint8_t chan_id)
{
        const struct counter_driver_api *api =
                                (struct counter_driver_api *)dev->api;
 
        if (chan_id >= counter_get_num_of_channels(dev)) {
                return -ENOTSUP;
        }
 
        return api->cancel_alarm(dev, chan_id);
}
 
__syscall int counter_set_top_value(const struct device *dev,
                                    const struct counter_top_cfg *cfg);
 
static inline int z_impl_counter_set_top_value(const struct device *dev,
                                               const struct counter_top_cfg
                                               *cfg)
{
        const struct counter_driver_api *api =
                                (struct counter_driver_api *)dev->api;
 
        if (cfg->ticks > counter_get_max_top_value(dev)) {
                return -EINVAL;
        }
 
        return api->set_top_value(dev, cfg);
}
 
__syscall int counter_get_pending_int(const struct device *dev);
 
static inline int z_impl_counter_get_pending_int(const struct device *dev)
{
        const struct counter_driver_api *api =
                                (struct counter_driver_api *)dev->api;
 
        return api->get_pending_int(dev);
}
 
__syscall uint32_t counter_get_top_value(const struct device *dev);
 
static inline uint32_t z_impl_counter_get_top_value(const struct device *dev)
{
        const struct counter_driver_api *api =
                                (struct counter_driver_api *)dev->api;
 
        return api->get_top_value(dev);
}
 
__syscall int counter_set_guard_period(const struct device *dev,
                                        uint32_t ticks,
                                        uint32_t flags);
 
static inline int z_impl_counter_set_guard_period(const struct device *dev,
                                                   uint32_t ticks, uint32_t flags)
{
        const struct counter_driver_api *api =
                                (struct counter_driver_api *)dev->api;
 
        if (!api->set_guard_period) {
                return -ENOSYS;
        }
 
        return api->set_guard_period(dev, ticks, flags);
}
 
__syscall uint32_t counter_get_guard_period(const struct device *dev,
                                            uint32_t flags);
 
static inline uint32_t z_impl_counter_get_guard_period(const struct device *dev,
                                                        uint32_t flags)
{
        const struct counter_driver_api *api =
                                (struct counter_driver_api *)dev->api;
 
        return (api->get_guard_period) ? api->get_guard_period(dev, flags) : 0;
}
 
#ifdef __cplusplus
}
#endif
 
#include <zephyr/syscalls/counter.h>
 
#endif /* ZEPHYR_INCLUDE_DRIVERS_COUNTER_H_ */