/**************************************************************************** * arch/arm/src/stm32/stm32_rtc_lowerhalf.c * * Copyright (C) 2015 Gregory Nutt. All rights reserved. * Author: Gregory Nutt * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in * the documentation and/or other materials provided with the * distribution. * 3. Neither the name NuttX nor the names of its contributors may be * used to endorse or promote products derived from this software * without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE * POSSIBILITY OF SUCH DAMAGE. * ****************************************************************************/ /**************************************************************************** * Included Files ****************************************************************************/ #include #include #include #include #include #include #include #include "chip.h" #include "stm32_rtc.h" #ifdef CONFIG_RTC_DRIVER /**************************************************************************** * Pre-processor Definitions ****************************************************************************/ #ifdef CONFIG_STM32_STM32F40XX # define STM32_NALARMS 2 #else # define STM32_NALARMS 1 #endif /**************************************************************************** * Private Types ****************************************************************************/ #ifdef CONFIG_RTC_ALARM struct stm32_cbinfo_s { volatile rtc_alarm_callback_t cb; /* Callback when the alarm expires */ volatile FAR void *priv; /* Private argurment to accompany callback */ #ifdef CONFIG_STM32_STM32F40XX uint8_t id; /* Identifies the alarm */ #endif }; #endif /* This is the private type for the RTC state. It must be cast compatible * with struct rtc_lowerhalf_s. */ struct stm32_lowerhalf_s { /* This is the contained reference to the read-only, lower-half * operations vtable (which may lie in FLASH or ROM) */ FAR const struct rtc_ops_s *ops; /* Data following is private to this driver and not visible outside of * this file. */ #ifdef CONFIG_RTC_ALARM /* Alarm callback information */ struct stm32_cbinfo_s cbinfo[STM32_NALARMS]; #endif }; /**************************************************************************** * Private Function Prototypes ****************************************************************************/ /* Prototypes for static methods in struct rtc_ops_s */ static int stm32_rdtime(FAR struct rtc_lowerhalf_s *lower, FAR struct rtc_time *rtctime); static int stm32_settime(FAR struct rtc_lowerhalf_s *lower, FAR const struct rtc_time *rtctime); #ifdef CONFIG_RTC_ALARM static int stm32_setalarm(FAR struct rtc_lowerhalf_s *lower, FAR const struct lower_setalarm_s *alarminfo); static int stm32_setrelative(FAR struct rtc_lowerhalf_s *lower, FAR const struct lower_setrelative_s *alarminfo); static int stm32_cancelalarm(FAR struct rtc_lowerhalf_s *lower, int alarmid); #endif /**************************************************************************** * Private Data ****************************************************************************/ /* STM32 RTC driver operations */ static const struct rtc_ops_s g_rtc_ops = { .rdtime = stm32_rdtime, .settime = stm32_settime, #ifdef CONFIG_RTC_ALARM .setalarm = stm32_setalarm, .setrelative = stm32_setrelative, .cancelalarm = stm32_cancelalarm, #endif #ifdef CONFIG_RTC_IOCTL .ioctl = NULL, #endif #ifndef CONFIG_DISABLE_PSEUDOFS_OPERATIONS .destroy = NULL, #endif }; /* STM32 RTC device state */ static struct stm32_lowerhalf_s g_rtc_lowerhalf = { .ops = &g_rtc_ops, }; /**************************************************************************** * Private Functions ****************************************************************************/ /**************************************************************************** * Name: stm32_alarm_callback * * Description: * This is the function that is called from the RTC driver when the alarm * goes off. It just invokes the upper half drivers callback. * * Input Parameters: * None * * Returned Value: * None * ****************************************************************************/ #ifdef CONFIG_RTC_ALARM #ifdef CONFIG_STM32_STM32F40XX static void stm32_alarm_callback(FAR void *arg, unsigned int alarmid) { FAR struct stm32_lowerhalf_s *lower; FAR struct stm32_cbinfo_s *cbinfo; rtc_alarm_callback_t cb; FAR void *priv; DEBUGASSERT(priv != NULL); DEBUGASSERT(alarmid == RTC_ALARMA || alarmid == RTC_ALARMB); lower = (struct stm32_lowerhalf_s *)arg; cbinfo = &lower->cbinfo[alarmid]; /* Sample and clear the callback information to minimize the window in * time in which race conditions can occur. */ cb = (rtc_alarm_callback_t)cbinfo->cb; priv = (FAR void *)cbinfo->priv; cbinfo->cb = NULL; cbinfo->priv = NULL; /* Perform the callback */ if (cb != NULL) { cb(priv, alarmid); } } #else static void stm32_alarm_callback(void) { struct stm32_cbinfo_s *cbinfo = &g_rtc_lowerhalf.cbinfo[0]; /* Sample and clear the callback information to minimize the window in * time in which race conditions can occur. */ rtc_alarm_callback_t cb = (rtc_alarm_callback_t)cbinfo->cb; FAR void *arg = (FAR void *)cbinfo->priv; cbinfo->cb = NULL; cbinfo->priv = NULL; /* Perform the callback */ if (cb != NULL) { cb(arg, 0); } } #endif /* CONFIG_STM32_STM32F40XX */ #endif /* CONFIG_RTC_ALARM */ /**************************************************************************** * Name: stm32_rdtime * * Description: * Implements the rdtime() method of the RTC driver interface * * Input Parameters: * lower - A reference to RTC lower half driver state structure * rcttime - The location in which to return the current RTC time. * * Returned Value: * Zero (OK) is returned on success; a negated errno value is returned * on any failure. * ****************************************************************************/ static int stm32_rdtime(FAR struct rtc_lowerhalf_s *lower, FAR struct rtc_time *rtctime) { #if defined(CONFIG_RTC_DATETIME) /* This operation depends on the fact that struct rtc_time is cast * compatible with struct tm. */ return up_rtc_getdatetime((FAR struct tm *)rtctime); #elif defined(CONFIG_RTC_HIRES) FAR struct timespec ts; int ret; /* Get the higher resolution time */ ret = up_rtc_gettime(&ts); if (ret < 0) { goto errout_with_errno; } /* Convert the one second epoch time to a struct tm. This operation * depends on the fact that struct rtc_time and struct tm are cast * compatible. */ if (!gmtime_r(&ts.tv_sec, (FAR struct tm *)rtctime)) { goto errout_with_errno; } return OK; errout_with_errno: ret = get_errno(); DEBUGASSERT(ret > 0); return -ret; #else FAR struct time_t timer; /* The resolution of time is only 1 second */ timer = up_rtc_time(); /* Convert the one second epoch time to a struct tm */ if (!gmtime_r(&timer, rtctime) { int errcode = get_errno(); DEBUGASSERT(errcode > 0); return -errcode; } return OK; #endif } /**************************************************************************** * Name: stm32_settime * * Description: * Implements the settime() method of the RTC driver interface * * Input Parameters: * lower - A reference to RTC lower half driver state structure * rcttime - The new time to set * * Returned Value: * Zero (OK) is returned on success; a negated errno value is returned * on any failure. * ****************************************************************************/ static int stm32_settime(FAR struct rtc_lowerhalf_s *lower, FAR const struct rtc_time *rtctime) { #ifdef CONFIG_RTC_DATETIME /* This operation depends on the fact that struct rtc_time is cast * compatible with struct tm. */ return stm32_rtc_setdatetime((FAR const struct tm *)rtctime); #else struct timespec ts; /* Convert the struct rtc_time to a time_t. Here we assume that struct * rtc_time is cast compatible with struct tm. */ ts.tv_sec = mktime((FAR struct tm *)rtctime); ts.tv_nsec = 0; /* Now set the time (to one second accuracy) */ return up_rtc_settime(&ts); #endif } /**************************************************************************** * Name: stm32_setalarm * * Description: * Set a new alarm. This function implements the setalarm() method of the * RTC driver interface * * Input Parameters: * lower - A reference to RTC lower half driver state structure * alarminfo - Provided information needed to set the alarm * * Returned Value: * Zero (OK) is returned on success; a negated errno value is returned * on any failure. * ****************************************************************************/ #ifdef CONFIG_RTC_ALARM static int stm32_setalarm(FAR struct rtc_lowerhalf_s *lower, FAR const struct lower_setalarm_s *alarminfo) { #ifdef CONFIG_STM32_STM32F40XX FAR struct stm32_lowerhalf_s *priv; FAR struct stm32_cbinfo_s *cbinfo; struct alm_setalarm_s lowerinfo; int ret = -EINVAL; /* ID0-> Alarm A; ID1 -> Alarm B */ DEBUGASSERT(lower != NULL && alarminfo != NULL); DEBUGASSERT(alarminfo->id == RTC_ALARMA || alarminfo->id == RTC_ALARMB); priv = (FAR struct stm32_lowerhalf_s *)lower; if (alarminfo->id == RTC_ALARMA || alarminfo->id == RTC_ALARMB) { /* Remember the callback information */ cbinfo = &priv->cbinfo[alarminfo->id]; cbinfo->cb = alarminfo->cb; cbinfo->priv = alarminfo->priv; cbinfo->id = alarminfo->id; /* Set the alarm */ lowerinfo.as_id = alarminfo->id; lowerinfo.as_cb = stm32_alarm_callback; lowerinfo.as_arg = priv; memcpy(&lowerinfo.as_time, &alarminfo->time, sizeof(struct tm)); /* And set the alarm */ ret = stm32_rtc_setalarm(&lowerinfo); if (ret < 0) { cbinfo->cb = NULL; cbinfo->priv = NULL; } } return ret; #else FAR struct stm32_cbinfo_s *cbinfo; int ret = -EINVAL; DEBUGASSERT(lower != NULL && alarminfo != NULL && alarminfo->id == 0); if (alarminfo->id == 0) { struct timespec ts; /* Convert the RTC time to a timespec (1 second accuracy) */ ts.tv_sec = mktime((FAR struct tm *)&alarminfo->time); ts.tv_nsec = 0; /* Remember the callback information */ cbinfo = &priv->cbinfo[0]; cbinfo->cb = alarminfo->cb; cbinfo->priv = alarminfo->priv; /* And set the alarm */ ret = stm32_rtc_setalarm(&ts, stm32_alarm_callback); if (ret < 0) { cbinfo->cb = NULL; cbinfo->priv = NULL; } } return ret; #endif } #endif /**************************************************************************** * Name: stm32_setrelative * * Description: * Set a new alarm relative to the current time. This function implements * the setrelative() method of the RTC driver interface * * Input Parameters: * lower - A reference to RTC lower half driver state structure * alarminfo - Provided information needed to set the alarm * * Returned Value: * Zero (OK) is returned on success; a negated errno value is returned * on any failure. * ****************************************************************************/ #ifdef CONFIG_RTC_ALARM static int stm32_setrelative(FAR struct rtc_lowerhalf_s *lower, FAR const struct lower_setrelative_s *alarminfo) { #ifdef CONFIG_STM32_STM32F40XX FAR struct stm32_lowerhalf_s *priv; struct alm_setrelative_s lowerinfo; struct stm32_cbinfo_s *cbinfo; int ret = -EINVAL; /* ID0-> Alarm A; ID1 -> Alarm B */ DEBUGASSERT(lower != NULL && alarminfo != NULL); DEBUGASSERT(alarminfo->id == RTC_ALARMA || alarminfo->id == RTC_ALARMB); priv = (FAR struct stm32_lowerhalf_s *)lower; if (alarminfo->id == RTC_ALARMA || alarminfo->id == RTC_ALARMB) { /* Remember the callback information */ cbinfo = &priv->cbinfo[alarminfo->id]; cbinfo->cb = alarminfo->cb; cbinfo->priv = alarminfo->priv; cbinfo->id = alarminfo->id; /* Set the alarm */ lowerinfo.asr_id = alarminfo->id; lowerinfo.asr_minutes = alarminfo->reltime / 60; lowerinfo.asr_cb = stm32_alarm_callback; lowerinfo.asr_arg = priv; /* And set the alarm */ ret = stm32_rtc_setalarm_rel(&lowerinfo); if (ret < 0) { cbinfo->cb = NULL; cbinfo->priv = NULL; } } return ret; #else # warning Missing logic return -ENOSYS; #endif } #endif /**************************************************************************** * Name: stm32_cancelalarm * * Description: * Cancel the current alarm. This function implements the cancelalarm() * method of the RTC driver interface * * Input Parameters: * lower - A reference to RTC lower half driver state structure * alarminfo - Provided information needed to set the alarm * * Returned Value: * Zero (OK) is returned on success; a negated errno value is returned * on any failure. * ****************************************************************************/ #ifdef CONFIG_RTC_ALARM static int stm32_cancelalarm(FAR struct rtc_lowerhalf_s *lower, int alarmid) { #ifdef CONFIG_STM32_STM32F40XX /* ID0-> Alarm A; ID1 -> Alarm B */ DEBUGASSERT(lower != NULL); DEBUGASSERT(alarminfo->id == RTC_ALARMA || alarminfo->id == RTC_ALARMB); # warning Missing logic return -ENOSYS; #else FAR struct stm32_cbinfo_s *cbinfo; DEBUGASSERT(lower != NULL); DEBUGASSERT(alarmid == 0); /* Nullify callback information to reduce window for race conditions */ cbinfo = &priv->cbinfo[0]; cbinfo->cb = alarminfo->cb; cbinfo->priv = alarminfo->priv; return stm32_rtc_cancelalarm(); #endif } #endif /**************************************************************************** * Public Functions ****************************************************************************/ /**************************************************************************** * Name: stm32_rtc_lowerhalf * * Description: * Instantiate the RTC lower half driver for the STM32. General usage: * * #include * #include "stm32_rtc.h> * * struct rtc_lowerhalf_s *lower; * lower = stm32_rtc_lowerhalf(); * rtc_initialize(0, lower); * * Input Parameters: * None * * Returned Value: * On success, a non-NULL RTC lower interface is returned. NULL is * returned on any failure. * ****************************************************************************/ FAR struct rtc_lowerhalf_s *stm32_rtc_lowerhalf(void) { return (FAR struct rtc_lowerhalf_s *)&g_rtc_lowerhalf; } #endif /* CONFIG_RTC_DRIVER */