/* ChibiOS/RT - Copyright (C) 2006,2007,2008,2009,2010, 2011 Giovanni Di Sirio. This file is part of ChibiOS/RT. ChibiOS/RT is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 3 of the License, or (at your option) any later version. ChibiOS/RT is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program. If not, see . */ /** * @file STM32/rtc_lld.c * @brief STM32 RTC subsystem low level driver header. * * @addtogroup RTC * @{ */ #include "ch.h" #include "hal.h" #if HAL_USE_RTC || defined(__DOXYGEN__) /*===========================================================================*/ /* Driver exported variables. */ /*===========================================================================*/ /** @brief RTC driver identifier.*/ RTCDriver RTCD; /*===========================================================================*/ /* Driver local variables. */ /*===========================================================================*/ /*===========================================================================*/ /* Driver local functions. */ /*===========================================================================*/ /** * @brief Shared IRQ handler. * * @param[in] rtcp pointer to a @p RTCDriver object * * @notapi */ #if RTC_SUPPORTS_CALLBACKS static void rtc_lld_serve_interrupt(RTCDriver *rtcp){ chSysLockFromIsr(); if ((RTC->CRH & RTC_CRH_SECIE) && \ (RTC->CRL & RTC_CRL_SECF) && \ (rtcp->second_cb != NULL)){ rtcp->second_cb(rtcp); RTC->CRL &= ~RTC_CRL_SECF; } if ((RTC->CRH & RTC_CRH_ALRIE) && \ (RTC->CRL & RTC_CRL_ALRF) && \ (rtcp->alarm_cb != NULL)){ rtcp->alarm_cb(rtcp); RTC->CRL &= ~RTC_CRL_ALRF; } if ((RTC->CRH & RTC_CRH_OWIE) && \ (RTC->CRL & RTC_CRL_OWF) && \ (rtcp->overflow_cb != NULL)){ rtcp->overflow_cb(rtcp); RTC->CRL &= ~RTC_CRL_OWF; } chSysUnlockFromIsr(); } #endif /* RTC_SUPPORTS_CALLBACKS */ /*===========================================================================*/ /* Driver interrupt handlers. */ /*===========================================================================*/ /** * @brief RTC interrupt handler. * @isr */ #if RTC_SUPPORTS_CALLBACKS CH_IRQ_HANDLER(RTC_IRQHandler) { CH_IRQ_PROLOGUE(); rtc_lld_serve_interrupt(&RTCD); CH_IRQ_EPILOGUE(); } #endif /* RTC_SUPPORTS_CALLBACKS */ /*===========================================================================*/ /* Driver exported functions. */ /*===========================================================================*/ /** * @brief Enable access to registers and initialize RTC if BKP domain * was previously reseted. * * @notapi */ void rtc_lld_init(void){ rccEnableBKPInterface(FALSE); /* Ensure that RTC_CNT and RTC_DIV contain actual values after enabling * clocking on APB1, because these values only update when APB1 functioning.*/ RTC->CRL &= ~(RTC_CRL_RSF); while (!(RTC->CRL & RTC_CRL_RSF)) ; /* enable access to BKP registers */ PWR->CR |= PWR_CR_DBP; if (! ((RCC->BDCR & RCC_BDCR_RTCEN) || (RCC->BDCR & RCC_BDCR_LSEON))){ RCC->BDCR |= RTC_CLOCK_SOURCE; /* for LSE source we must wait until source became stable */ #if defined(RTC_CLOCK_SOURCE) == defined(RCC_BDCR_RTCSEL_LSE) RCC->BDCR |= RCC_BDCR_LSEON; while(!(RCC->BDCR & RCC_BDCR_LSERDY)) ; #endif RCC->BDCR |= RCC_BDCR_RTCEN; } #if defined(RTC_CLOCK_SOURCE) == defined(RCC_BDCR_RTCSEL_LSE) uint32_t preload = STM32_LSECLK - 1; #elif defined(RTC_CLOCK_SOURCE) == defined(RCC_BDCR_RTCSEL_LSI) uint32_t preload = STM32_LSICLK - 1; #elif defined(RTC_CLOCK_SOURCE) == defined(RCC_BDCR_RTCSEL_HSE) uint32_t preload = (STM32_HSICLK / 128) - 1; #else #error "RTC clock source not selected" #endif /* RTC_CLOCK_SOURCE == RCC_BDCR_RTCSEL_LSE */ /* Write preload register only if value changed */ if (preload != ((((uint32_t)(RTC->PRLH)) << 16) + RTC->PRLL)){ while(!(RTC->CRL & RTC_CRL_RTOFF)) ; RTC->CRL |= RTC_CRL_CNF; /* switch on configure mode */ RTC->PRLH = (uint16_t)((preload >> 16) & 0b1111); /* write preloader */ RTC->PRLL = (uint16_t)(preload & 0xFFFF); RTC->CRL &= ~RTC_CRL_CNF; /* switch off configure mode */ while(!(RTC->CRL & RTC_CRL_RTOFF)) /* wait for completion */ ; } /* disable all interrupts and clear all even flags just to be safe */ RTC->CRH &= ~(RTC_CRH_OWIE | RTC_CRH_ALRIE | RTC_CRH_SECIE); RTC->CRL &= ~(RTC_CRL_SECF | RTC_CRL_ALRF | RTC_CRL_OWF); #if RTC_SUPPORTS_CALLBACKS RTCD.alarm_cb = NULL; RTCD.overflow_cb = NULL; RTCD.second_cb = NULL; #endif /* RTC_SUPPORTS_CALLBACKS */ } /** * @brief Enables and disables callbacks on the fly. * * @details Pass callback function(s) in argument(s) to enable callback(s). * Pass NULL to disable callback. * * @pre To use this function you must set @p RTC_SUPPORTS_CALLBACKS * to @p TRUE. * * @param[in] rtcp pointer to RTC driver structure. * @param[in] overflowcb overflow callback function. * @param[in] secondcb every second callback function. * @param[in] alarmcb alarm callback function. * * @notapi */ #if RTC_SUPPORTS_CALLBACKS void rtc_lld_set_callback(RTCDriver *rtcp, rtccb_t overflowcb, rtccb_t secondcb, rtccb_t alarmcb){ uint16_t isr_flags = 0; if (overflowcb != NULL){ rtcp->overflow_cb = *overflowcb; isr_flags |= RTC_CRH_OWIE; } else{ rtcp->overflow_cb = NULL; isr_flags &= ~RTC_CRH_OWIE; } if (alarmcb != NULL){ rtcp->alarm_cb = *alarmcb; isr_flags |= RTC_CRH_ALRIE; } else{ rtcp->alarm_cb = NULL; isr_flags &= ~RTC_CRH_ALRIE; } if (secondcb != NULL){ rtcp->second_cb = *secondcb; isr_flags |= RTC_CRH_SECIE; } else{ rtcp->second_cb = NULL; isr_flags &= ~RTC_CRH_SECIE; } if(isr_flags != 0){ NVICEnableVector(RTC_IRQn, CORTEX_PRIORITY_MASK(STM32_RTC_IRQ_PRIORITY)); RTC->CRH |= isr_flags; } else{ NVICDisableVector(RTC_IRQn); RTC->CRH = 0; } } #endif /* RTC_SUPPORTS_CALLBACKS */ /** * @brief Set current time. * * @param[in] tv_sec time value in UNIX notation. * * @notapi */ void rtc_lld_set_time(uint32_t tv_sec){ while(!(RTC->CRL & RTC_CRL_RTOFF)) ; RTC->CRL |= RTC_CRL_CNF; /* switch on configure mode */ RTC->CNTH = (uint16_t)((tv_sec >> 16) & 0xFFFF); /* write time */ RTC->CNTL = (uint16_t)(tv_sec & 0xFFFF); RTC->CRL &= ~RTC_CRL_CNF; /* switch off configure mode */ while(!(RTC->CRL & RTC_CRL_RTOFF)) /* wait for completion */ ; } /** * @brief Return current time in UNIX notation. * * @notapi */ inline uint32_t rtc_lld_get_sec(void){ return ((RTC->CNTH << 16) + RTC->CNTL); } /** * @brief Return fractional part of current time (milliseconds). * * @notapi */ inline uint16_t rtc_lld_get_msec(void){ uint32_t time_frac = 0; time_frac = (((uint32_t)RTC->DIVH) << 16) + (RTC->DIVL); return(((STM32_LSECLK - time_frac) * 1000) / STM32_LSECLK); } /** * @brief Set alarm date in UNIX notation. * @note Default value after BKP domain reset is 0xFFFFFFFF * * @notapi */ void rtc_lld_set_alarm(uint32_t tv_alarm){ while(!(RTC->CRL & RTC_CRL_RTOFF)) ; RTC->CRL |= RTC_CRL_CNF; /* switch on configure mode */ RTC->ALRH = (uint16_t)((tv_alarm >> 16) & 0xFFFF); /* write time */ RTC->ALRL = (uint16_t)(tv_alarm & 0xFFFF); RTC->CRL &= ~RTC_CRL_CNF; /* switch off configure mode */ #if !(RTC_SUPPORTS_CALLBACKS) RTC->CRL &= ~RTC_CRL_ALRF; RTC->CRH |= RTC_CRH_ALRIE; #endif /* !(RTC_SUPPORTS_CALLBACKS) */ while(!(RTC->CRL & RTC_CRL_RTOFF)) /* wait for completion */ ; } /** * @brief Get current alarm date in UNIX notation. * @note Default value after BKP domain reset is 0xFFFFFFFF * * @notapi */ inline uint32_t rtc_lld_get_alarm(void){ return ((RTC->ALRH << 16) + RTC->ALRL); } #endif /* HAL_USE_RTC */ /** @} */