rtc.h

Go to the documentation of this file.

/*
 * Copyright (c) 2023 Trackunit Corporation
 * Copyright (c) 2023 Bjarki Arge Andreasen
 *
 * SPDX-License-Identifier: Apache-2.0
 */
 
#ifndef ZEPHYR_INCLUDE_DRIVERS_RTC_H_
#define ZEPHYR_INCLUDE_DRIVERS_RTC_H_
 
#include <zephyr/kernel.h>
#include <zephyr/device.h>
#include <errno.h>
 
#ifdef __cplusplus
extern "C" {
#endif
 
#define RTC_ALARM_TIME_MASK_SECOND      BIT(0)
#define RTC_ALARM_TIME_MASK_MINUTE      BIT(1)
#define RTC_ALARM_TIME_MASK_HOUR        BIT(2)
#define RTC_ALARM_TIME_MASK_MONTHDAY    BIT(3)
#define RTC_ALARM_TIME_MASK_MONTH       BIT(4)
#define RTC_ALARM_TIME_MASK_YEAR        BIT(5)
#define RTC_ALARM_TIME_MASK_WEEKDAY     BIT(6)
#define RTC_ALARM_TIME_MASK_YEARDAY     BIT(7)
#define RTC_ALARM_TIME_MASK_NSEC        BIT(8)
struct rtc_time {
        int tm_sec;     
        int tm_min;     
        int tm_hour;    
        int tm_mday;    
        int tm_mon;     
        int tm_year;    
        int tm_wday;    
        int tm_yday;    
        int tm_isdst;   
        int tm_nsec;    
};
 
typedef void (*rtc_update_callback)(const struct device *dev, void *user_data);
 
typedef void (*rtc_alarm_callback)(const struct device *dev, uint16_t id, void *user_data);
 
typedef int (*rtc_api_set_time)(const struct device *dev, const struct rtc_time *timeptr);
 
typedef int (*rtc_api_get_time)(const struct device *dev, struct rtc_time *timeptr);
 
typedef int (*rtc_api_alarm_get_supported_fields)(const struct device *dev, uint16_t id,
                                                  uint16_t *mask);
 
typedef int (*rtc_api_alarm_set_time)(const struct device *dev, uint16_t id, uint16_t mask,
                                      const struct rtc_time *timeptr);
 
typedef int (*rtc_api_alarm_get_time)(const struct device *dev, uint16_t id, uint16_t *mask,
                                      struct rtc_time *timeptr);
 
typedef int (*rtc_api_alarm_is_pending)(const struct device *dev, uint16_t id);
 
typedef int (*rtc_api_alarm_set_callback)(const struct device *dev, uint16_t id,
                                          rtc_alarm_callback callback, void *user_data);
 
typedef int (*rtc_api_update_set_callback)(const struct device *dev,
                                           rtc_update_callback callback, void *user_data);
 
typedef int (*rtc_api_set_calibration)(const struct device *dev, int32_t calibration);
 
typedef int (*rtc_api_get_calibration)(const struct device *dev, int32_t *calibration);
 
__subsystem struct rtc_driver_api {
        rtc_api_set_time set_time;
        rtc_api_get_time get_time;
#if defined(CONFIG_RTC_ALARM) || defined(__DOXYGEN__)
        rtc_api_alarm_get_supported_fields alarm_get_supported_fields;
        rtc_api_alarm_set_time alarm_set_time;
        rtc_api_alarm_get_time alarm_get_time;
        rtc_api_alarm_is_pending alarm_is_pending;
        rtc_api_alarm_set_callback alarm_set_callback;
#endif /* CONFIG_RTC_ALARM */
#if defined(CONFIG_RTC_UPDATE) || defined(__DOXYGEN__)
        rtc_api_update_set_callback update_set_callback;
#endif /* CONFIG_RTC_UPDATE */
#if defined(CONFIG_RTC_CALIBRATION) || defined(__DOXYGEN__)
        rtc_api_set_calibration set_calibration;
        rtc_api_get_calibration get_calibration;
#endif /* CONFIG_RTC_CALIBRATION */
};
 
__syscall int rtc_set_time(const struct device *dev, const struct rtc_time *timeptr);
 
static inline int z_impl_rtc_set_time(const struct device *dev, const struct rtc_time *timeptr)
{
        return DEVICE_API_GET(rtc, dev)->set_time(dev, timeptr);
}
 
__syscall int rtc_get_time(const struct device *dev, struct rtc_time *timeptr);
 
static inline int z_impl_rtc_get_time(const struct device *dev, struct rtc_time *timeptr)
{
        return DEVICE_API_GET(rtc, dev)->get_time(dev, timeptr);
}
 
#if defined(CONFIG_RTC_ALARM) || defined(__DOXYGEN__)
 
__syscall int rtc_alarm_get_supported_fields(const struct device *dev, uint16_t id,
                                             uint16_t *mask);
 
static inline int z_impl_rtc_alarm_get_supported_fields(const struct device *dev, uint16_t id,
                                                        uint16_t *mask)
{
        if (DEVICE_API_GET(rtc, dev)->alarm_get_supported_fields == NULL) {
                return -ENOSYS;
        }
 
        return DEVICE_API_GET(rtc, dev)->alarm_get_supported_fields(dev, id, mask);
}
 
__syscall int rtc_alarm_set_time(const struct device *dev, uint16_t id, uint16_t mask,
                                 const struct rtc_time *timeptr);
 
static inline int z_impl_rtc_alarm_set_time(const struct device *dev, uint16_t id, uint16_t mask,
                                            const struct rtc_time *timeptr)
{
        if (DEVICE_API_GET(rtc, dev)->alarm_set_time == NULL) {
                return -ENOSYS;
        }
 
        return DEVICE_API_GET(rtc, dev)->alarm_set_time(dev, id, mask, timeptr);
}
 
__syscall int rtc_alarm_get_time(const struct device *dev, uint16_t id, uint16_t *mask,
                                 struct rtc_time *timeptr);
 
static inline int z_impl_rtc_alarm_get_time(const struct device *dev, uint16_t id, uint16_t *mask,
                                            struct rtc_time *timeptr)
{
        if (DEVICE_API_GET(rtc, dev)->alarm_get_time == NULL) {
                return -ENOSYS;
        }
 
        return DEVICE_API_GET(rtc, dev)->alarm_get_time(dev, id, mask, timeptr);
}
 
__syscall int rtc_alarm_is_pending(const struct device *dev, uint16_t id);
 
static inline int z_impl_rtc_alarm_is_pending(const struct device *dev, uint16_t id)
{
        if (DEVICE_API_GET(rtc, dev)->alarm_is_pending == NULL) {
                return -ENOSYS;
        }
 
        return DEVICE_API_GET(rtc, dev)->alarm_is_pending(dev, id);
}
 
static inline int rtc_alarm_set_callback(const struct device *dev, uint16_t id,
                                         rtc_alarm_callback callback, void *user_data)
{
        if (DEVICE_API_GET(rtc, dev)->alarm_set_callback == NULL) {
                return -ENOSYS;
        }
 
        return DEVICE_API_GET(rtc, dev)->alarm_set_callback(dev, id, callback, user_data);
}
 
#endif /* CONFIG_RTC_ALARM */
#if defined(CONFIG_RTC_UPDATE) || defined(__DOXYGEN__)
 
static inline int rtc_update_set_callback(const struct device *dev,
                                          rtc_update_callback callback, void *user_data)
{
        if (DEVICE_API_GET(rtc, dev)->update_set_callback == NULL) {
                return -ENOSYS;
        }
 
        return DEVICE_API_GET(rtc, dev)->update_set_callback(dev, callback, user_data);
}
 
#endif /* CONFIG_RTC_UPDATE */
#if defined(CONFIG_RTC_CALIBRATION) || defined(__DOXYGEN__)
 
__syscall int rtc_set_calibration(const struct device *dev, int32_t calibration);
 
static inline int z_impl_rtc_set_calibration(const struct device *dev, int32_t calibration)
{
        if (DEVICE_API_GET(rtc, dev)->set_calibration == NULL) {
                return -ENOSYS;
        }
 
        return DEVICE_API_GET(rtc, dev)->set_calibration(dev, calibration);
}
 
__syscall int rtc_get_calibration(const struct device *dev, int32_t *calibration);
 
static inline int z_impl_rtc_get_calibration(const struct device *dev, int32_t *calibration)
{
        if (DEVICE_API_GET(rtc, dev)->get_calibration == NULL) {
                return -ENOSYS;
        }
 
        return DEVICE_API_GET(rtc, dev)->get_calibration(dev, calibration);
}
 
#endif /* CONFIG_RTC_CALIBRATION */
struct tm;
 
static inline struct tm *rtc_time_to_tm(struct rtc_time *timeptr)
{
        return (struct tm *)timeptr;
}
 
static inline int32_t rtc_calibration_from_frequency(uint32_t frequency)
{
        __ASSERT_NO_MSG(frequency > 0);
 
        return (int32_t)((1000000000000000000LL / frequency) - 1000000000);
}
 
#ifdef __cplusplus
}
#endif
 
#include <zephyr/syscalls/rtc.h>
 
#endif /* ZEPHYR_INCLUDE_DRIVERS_RTC_H_ */