From 2950a0a7b8316a742a7a67b5acb4f224a98397ff Mon Sep 17 00:00:00 2001 From: gdisirio Date: Sat, 1 Oct 2011 08:04:14 +0000 Subject: git-svn-id: svn://svn.code.sf.net/p/chibios/svn/trunk@3413 35acf78f-673a-0410-8e92-d51de3d6d3f4 --- os/hal/platforms/STM32/RTCv1/rtc_lld.c | 333 ++++++++++++++++----------------- os/hal/platforms/STM32/RTCv1/rtc_lld.h | 105 +++++++---- 2 files changed, 226 insertions(+), 212 deletions(-) (limited to 'os/hal/platforms/STM32/RTCv1') diff --git a/os/hal/platforms/STM32/RTCv1/rtc_lld.c b/os/hal/platforms/STM32/RTCv1/rtc_lld.c index df90bcc11..2876b990d 100644 --- a/os/hal/platforms/STM32/RTCv1/rtc_lld.c +++ b/os/hal/platforms/STM32/RTCv1/rtc_lld.c @@ -29,16 +29,16 @@ #include "ch.h" #include "hal.h" - #if HAL_USE_RTC || defined(__DOXYGEN__) /*===========================================================================*/ /* Driver exported variables. */ /*===========================================================================*/ -/** @brief RTC driver identifier.*/ -RTCDriver RTCD; - +/** + * @brief RTC driver identifier. + */ +RTCDriver RTCD1; /*===========================================================================*/ /* Driver local variables. */ @@ -55,33 +55,37 @@ RTCDriver RTCD; * * @notapi */ -#if RTC_SUPPORTS_CALLBACKS +static void rtc_lld_serve_interrupt(RTCDriver *rtcp) { -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); + if ((RTC->CRH & RTC_CRH_SECIE) && (RTC->CRL & RTC_CRL_SECF)) { + rtcp->rtc_cb(rtcp, RTC_EVENT_SECOND); RTC->CRL &= ~RTC_CRL_SECF; } - if ((RTC->CRH & RTC_CRH_ALRIE) && \ - (RTC->CRL & RTC_CRL_ALRF) && \ - (rtcp->alarm_cb != NULL)){ - rtcp->alarm_cb(rtcp); + if ((RTC->CRH & RTC_CRH_ALRIE) && (RTC->CRL & RTC_CRL_ALRF)) { + rtcp->rtc_cb(rtcp, RTC_EVENT_ALARM); RTC->CRL &= ~RTC_CRL_ALRF; } - if ((RTC->CRH & RTC_CRH_OWIE) && \ - (RTC->CRL & RTC_CRL_OWF) && \ - (rtcp->overflow_cb != NULL)){ - rtcp->overflow_cb(rtcp); + if ((RTC->CRH & RTC_CRH_OWIE) && (RTC->CRL & RTC_CRL_OWF)) { + rtcp->rtc_cb(rtcp, RTC_EVENT_OVERFLOW); RTC->CRL &= ~RTC_CRL_OWF; } chSysUnlockFromIsr(); } -#endif /* RTC_SUPPORTS_CALLBACKS */ + +/** + * @brief Waits for the previous registers write to finish. + * + * @notapi + */ +static void rtc_lld_wait_write(void) { + + /* Waits registers write completion.*/ + while (!(RTC->CRL & RTC_CRL_RTOFF)) + ; +} /*===========================================================================*/ /* Driver interrupt handlers. */ @@ -89,18 +93,18 @@ static void rtc_lld_serve_interrupt(RTCDriver *rtcp){ /** * @brief RTC interrupt handler. + * * @isr */ -#if RTC_SUPPORTS_CALLBACKS - CH_IRQ_HANDLER(RTC_IRQHandler) { + CH_IRQ_PROLOGUE(); - rtc_lld_serve_interrupt(&RTCD); + + rtc_lld_serve_interrupt(&RTCD1); + CH_IRQ_EPILOGUE(); } -#endif /* RTC_SUPPORTS_CALLBACKS */ - /*===========================================================================*/ /* Driver exported functions. */ /*===========================================================================*/ @@ -108,226 +112,207 @@ CH_IRQ_HANDLER(RTC_IRQHandler) { /** * @brief Enable access to registers and initialize RTC if BKP domain * was previously reseted. - * * @note: Cold start time of LSE oscillator on STM32 platform * takes about 3 seconds. * * @notapi */ void rtc_lld_init(void){ - uint32_t preload = 0; + uint32_t preload; rccEnableBKPInterface(FALSE); - /* enable access to BKP registers */ + /* Enables access to BKP registers.*/ PWR->CR |= PWR_CR_DBP; - /* select clock source */ - RCC->BDCR |= STM32_RTC; -#if STM32_RTC == STM32_RTC_LSE - if (! ((RCC->BDCR & RCC_BDCR_RTCEN) || (RCC->BDCR & RCC_BDCR_LSEON))){ - RCC->BDCR |= RCC_BDCR_LSEON; - while(!(RCC->BDCR & RCC_BDCR_LSERDY)) - ; - RCC->BDCR |= RCC_BDCR_RTCEN; - } - preload = STM32_LSECLK - 1; + /* If the RTC is not enabled then performs a reset of the backup domain.*/ + if (!(RCC->BDCR & RCC_BDCR_RTCEN)) { + RCC->BDCR = RCC_BDCR_BDRST; + RCC->BDCR = 0; + } -#elif STM32_RTC == STM32_RTC_LSI - RCC->CSR |= RCC_CSR_LSION; - while(!(RCC->CSR & RCC_CSR_LSIRDY)) - ; - /* According to errata sheet we must wait additional 100 uS for stabilization */ - uint32_t tmo = (STM32_SYSCLK / 1000000 ) * 100; - while(tmo--) +#if STM32_RTC == STM32_RTC_LSE + if (!(RCC->BDCR & RCC_BDCR_LSEON)) { + RCC->BDCR |= RCC_BDCR_LSEON; + while (!(RCC->BDCR & RCC_BDCR_LSERDY)) ; - RCC->BDCR |= RCC_BDCR_RTCEN; - preload = STM32_LSICLK - 1; - + } + preload = STM32_LSECLK - 1; +#elif STM32_RTC == STM32_RTC_LSI + /* TODO: Move the LSI clock initialization in the HAL low level driver.*/ + RCC->CSR |= RCC_CSR_LSION; + while (!(RCC->CSR & RCC_CSR_LSIRDY)) + ; + /* According to errata sheet we must wait additional 100 uS for + stabilization. + TODO: Change this code, software loops are not reliable.*/ + uint32_t tmo = (STM32_SYSCLK / 1000000) * 100; + while (tmo--) + ; + preload = STM32_LSICLK - 1; #elif STM32_RTC == STM32_RTC_HSE - preload = (STM32_HSICLK / 128) - 1; - -#else -#error "RTC clock source not selected" + preload = (STM32_HSICLK / 128) - 1; #endif + /* Selects clock source (previously enabled and stabilized.*/ + RCC->BDCR = (RCC->BDCR & ~RCC_BDCR_RTCSEL) | STM32_RTC; + + /* RTC enabled regardless its previous status.*/ + RCC->BDCR |= RCC_BDCR_RTCEN; + /* 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); + clocking on APB1, because these values only update when APB1 + functioning.*/ + RTC->CRL = 0; while (!(RTC->CRL & RTC_CRL_RSF)) ; - /* Write preload register only if its value changed */ - if (preload != ((((uint32_t)(RTC->PRLH)) << 16) + RTC->PRLL)){ - while(!(RTC->CRL & RTC_CRL_RTOFF)) - ; + /* Write preload register only if its value differs.*/ + if (preload != ((((uint32_t)(RTC->PRLH)) << 16) + (uint32_t)RTC->PRLL)) { - 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 */ + rtc_lld_wait_write(); - while(!(RTC->CRL & RTC_CRL_RTOFF)) /* wait for completion */ - ; + /* Enters configuration mode and writes PRLx registers then leaves the + configuration mode.*/ + RTC->CRL |= RTC_CRL_CNF; + RTC->PRLH = (uint16_t)(preload >> 16); + RTC->PRLL = (uint16_t)(preload & 0xFFFF); + RTC->CRL &= ~RTC_CRL_CNF; } - /* 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); + /* All interrupts initially disabled.*/ + RTC->CRH = 0; -#if RTC_SUPPORTS_CALLBACKS - RTCD.alarm_cb = NULL; - RTCD.overflow_cb = NULL; - RTCD.second_cb = NULL; -#endif /* RTC_SUPPORTS_CALLBACKS */ + /* Callback initially disabled.*/ + RTCD1.rtc_cb = NULL; } /** - * @brief Enables and disables callbacks on the fly. + * @brief Set current time. + * @note Fractional part will be silently ignored. There is no possibility + * to change it on STM32F1xx platform. * - * @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. + * @param[in] rtcp pointer to RTC driver structure + * @param[in] timespec pointer to a @p RTCTime structure * * @notapi */ -#if RTC_SUPPORTS_CALLBACKS -void rtc_lld_set_callback(RTCDriver *rtcp, rtccb_t overflowcb, - rtccb_t secondcb, rtccb_t alarmcb){ +void rtc_lld_set_time(RTCDriver *rtcp, const RTCTime *timespec) { - uint16_t isr_flags = 0; + (void)rtcp; - if (overflowcb != NULL){ - rtcp->overflow_cb = *overflowcb; - isr_flags |= RTC_CRH_OWIE; - } - else{ - rtcp->overflow_cb = NULL; - isr_flags &= ~RTC_CRH_OWIE; - } + rtc_lld_wait_write(); - 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; - } + RTC->CRL |= RTC_CRL_CNF; + RTC->CNTH = (uint16_t)(timespec->tv_sec >> 16); + RTC->CNTL = (uint16_t)(timespec->tv_sec & 0xFFFF); + RTC->CRL &= ~RTC_CRL_CNF; } -#endif /* RTC_SUPPORTS_CALLBACKS */ /** - * @brief Set current time. + * @brief Get current time. * - * @param[in] timespec pointer to variable storing time. + * @param[in] rtcp pointer to RTC driver structure + * @param[out] timespec pointer to a @p RTCTime structure * - * @note Fractional part will be silently ignored. There is no possibility - * to change it on STM32F1xx platform. * @notapi */ -void rtc_lld_set_time(RTCDateTime *timespec){ +void rtc_lld_get_time(RTCDriver *rtcp, RTCTime *timespec) { + uint32_t time_frac; - while(!(RTC->CRL & RTC_CRL_RTOFF)) - ; + (void)rtcp; - RTC->CRL |= RTC_CRL_CNF; /* switch on configure mode */ - RTC->CNTH = (uint16_t)((timespec->tv_sec >> 16) & 0xFFFF); - RTC->CNTL = (uint16_t)(timespec->tv_sec & 0xFFFF); - RTC->CRL &= ~RTC_CRL_CNF; /* switch off configure mode */ - - while(!(RTC->CRL & RTC_CRL_RTOFF)) /* wait for completion */ - ; + time_frac = (((uint32_t)RTC->DIVH) << 16) + (uint32_t)RTC->DIVL; + timespec->tv_msec = (uint16_t)(((STM32_LSECLK - time_frac) * 1000) / + STM32_LSECLK); + timespec->tv_sec = (RTC->CNTH << 16) + RTC->CNTL; } /** - * @brief Get current time. + * @brief Set alarm time. + * + * @note Default value after BKP domain reset is 0xFFFFFFFF * - * @param[in] msec pointer to variable for storing fractional part of - * time (milliseconds). + * @param[in] rtcp pointer to RTC driver structure + * @param[in] alarm alarm identifier + * @param[in] alarmspec pointer to a @p RTCAlarm structure * * @notapi */ -inline void rtc_lld_get_time(RTCDateTime *timespec){ - uint32_t time_frac = 0; - time_frac = (((uint32_t)RTC->DIVH) << 16) + (RTC->DIVL); +void rtc_lld_set_alarm(RTCDriver *rtcp, + rtcalarm_t alarm, + const RTCAlarm *alarmspec) { - timespec->tv_msec = (uint16_t)(((STM32_LSECLK - time_frac) * 1000) / STM32_LSECLK); - timespec->tv_sec = (RTC->CNTH << 16) + RTC->CNTL; + (void)rtcp; + (void)alarm; + + rtc_lld_wait_write(); + + /* Enters configuration mode and writes ALRHx registers then leaves the + configuration mode.*/ + RTC->CRL |= RTC_CRL_CNF; + if (alarmspec != NULL) { + RTC->ALRH = (uint16_t)(alarmspec->tv_sec >> 16); + RTC->ALRL = (uint16_t)(alarmspec->tv_sec & 0xFFFF); + } + else { + RTC->ALRH = 0; + RTC->ALRL = 0; + } + RTC->CRL &= ~RTC_CRL_CNF; } /** - * @brief Set alarm time. + * @brief Get current alarm. + * @note If an alarm has not been set then the returned alarm specification + * is not meaningful. * - * @param[in] timespec pointer to variable storing time of alarm. + * @note Default value after BKP domain reset is 0xFFFFFFFF. * - * @note Fractional part will be silently ignored. There is no possibility - * to change it on STM32F1xx platform. - * - * @note Default value after BKP domain reset is 0xFFFFFFFF + * @param[in] rtcp pointer to RTC driver structure + * @param[in] alarm alarm identifier + * @param[out] alarmspec pointer to a @p RTCAlarm structure * * @notapi */ -void rtc_lld_set_alarm(RTCDateTime *timespec){ +void rtc_lld_get_alarm(RTCDriver *rtcp, + rtcalarm_t alarm, + RTCAlarm *alarmspec) { - while(!(RTC->CRL & RTC_CRL_RTOFF)) - ; - - RTC->CRL |= RTC_CRL_CNF; /* switch on configure mode */ - RTC->ALRH = (uint16_t)((timespec->tv_sec >> 16) & 0xFFFF); - RTC->ALRL = (uint16_t)(timespec->tv_sec & 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) */ + (void)rtcp; + (void)alarm; - while(!(RTC->CRL & RTC_CRL_RTOFF)) /* wait for completion */ - ; + alarmspec->tv_sec = ((RTC->ALRH << 16) + RTC->ALRL); } /** - * @brief Get current alarm time. - * - * @param[in] timespec pointer to variable storing time of alarm. + * @brief Enables or disables RTC callbacks. + * @details This function enables or disables callbacks, use a @p NULL pointer + * in order to disable a callback. * - * @note Fractional part will be silently ignored. There is no possibility - * to change it on STM32F1xx platform. - * - * @note Default value after BKP domain reset is 0xFFFFFFFF + * @param[in] rtcp pointer to RTC driver structure + * @param[in] callback callback function pointer or @p NULL * * @notapi */ -inline void rtc_lld_get_alarm(RTCDateTime *timespec){ - timespec->tv_sec = ((RTC->ALRH << 16) + RTC->ALRL); -} +void rtc_lld_set_callback(RTCDriver *rtcp, rtccb_t callback) { + + if (callback != NULL) { + rtcp->rtc_cb = callback; + NVICEnableVector(RTC_IRQn, CORTEX_PRIORITY_MASK(STM32_RTC_IRQ_PRIORITY)); + /* Interrupts are enabled only after setting up the callback, this + way there is no need to check for the NULL callback pointer inside + the IRQ handler.*/ + RTC->CRL &= ~(RTC_CRL_OWF | RTC_CRL_ALRF | RTC_CRL_SECF); + RTC->CRH |= RTC_CRH_OWIE | RTC_CRH_ALRIE | RTC_CRH_SECIE; + } + else { + NVICDisableVector(RTC_IRQn); + RTC->CRL = 0; + RTC->CRH = 0; + } +} #endif /* HAL_USE_RTC */ diff --git a/os/hal/platforms/STM32/RTCv1/rtc_lld.h b/os/hal/platforms/STM32/RTCv1/rtc_lld.h index f8256ae31..e3ce0e365 100644 --- a/os/hal/platforms/STM32/RTCv1/rtc_lld.h +++ b/os/hal/platforms/STM32/RTCv1/rtc_lld.h @@ -35,17 +35,19 @@ /* Driver constants. */ /*===========================================================================*/ +/** + * @brief This RTC implementation supports callbacks. + */ +#define RTC_SUPPORTS_CALLBACKS TRUE + +/** + * @brief One alarm comparator available. + */ +#define RTC_ALARMS 1 + /*===========================================================================*/ /* Driver pre-compile time settings. */ /*===========================================================================*/ -/** - * @brief Switch to TRUE if you need callbacks from RTC. Switch to FALSE - * if you need only time keeping. - * @note Default is true. - */ -#if !defined(RTC_SUPPORTS_CALLBACKS) || defined(__DOXYGEN__) -#define RTC_SUPPORTS_CALLBACKS TRUE -#endif /*===========================================================================*/ /* Derived constants and error checks. */ @@ -55,46 +57,71 @@ #error "RTC not present in the selected device" #endif +#if !(STM32_RTC == STM32_RTC_LSE) && !(STM32_RTC == STM32_RTC_LSI) && \ + !(STM32_RTC == STM32_RTC_HSE) +#error "invalid source selected for RTC clock" +#endif + /*===========================================================================*/ /* Driver data structures and types. */ /*===========================================================================*/ /** - * @brief Structure representing an RTC time value. + * @brief Type of a structure representing an RTC alarm stamp. + */ +typedef struct RTCAlarm RTCAlarm; + +/** + * @brief Type of an RTC alarm. + */ +typedef uint32_t rtcalarm_t; + +/** + * @brief Type of an RTC event. + */ +typedef enum { + RTC_EVENT_SECOND = 0, /** Triggered every second. */ + RTC_EVENT_ALARM = 1, /** Triggered on alarm. */ + RTC_EVENT_OVERFLOW = 2 /** Triggered on counter overflow. */ +} rtcevent_t; + +/** + * @brief Type of a generic RTC callback. */ -typedef struct { +typedef void (*rtccb_t)(RTCDriver *rtcp, rtcevent_t event); + +/** + * @brief Structure representing an RTC time stamp. + */ +struct RTCTime { /** - * @brief Seconds sins UNIX epoch. + * @brief Seconds since UNIX epoch. */ uint32_t tv_sec; /** * @brief Fractional part. */ uint32_t tv_msec; -}RTCDateTime; - +}; /** - * @brief Structure representing an RTC driver. - * @note This driver is dummy when callbacks disabled. + * @brief Structure representing an RTC alarm specification. */ -struct RTCDriver{ -#if RTC_SUPPORTS_CALLBACKS +struct RTCAlarm { /** - * @brief Overflow callback. Set it to NULL if not used. + * @brief Seconds since UNIX epoch. */ - rtccb_t overflow_cb; - - /** - * @brief Every second callback. Set it to NULL if not used. - */ - rtccb_t second_cb; + uint32_t tv_sec; +}; +/** + * @brief Structure representing an RTC driver. + */ +struct RTCDriver{ /** - * @brief Alarm callback. Set it to NULL if not used. + * @brief Callback pointer. */ - rtccb_t alarm_cb; -#endif /* RTC_SUPPORTS_CALLBACKS */ + rtccb_t rtc_cb; }; /*===========================================================================*/ @@ -105,27 +132,29 @@ struct RTCDriver{ /* External declarations. */ /*===========================================================================*/ -extern RTCDriver RTCD; - +#if !defined(__DOXYGEN__) +extern RTCDriver RTCD1; +#endif #ifdef __cplusplus extern "C" { #endif void rtc_lld_init(void); - void rtc_lld_set_callback(RTCDriver *rtcp, rtccb_t overflow_cb, - rtccb_t second_cb, rtccb_t alarm_cb); - - void rtc_lld_set_time(RTCDateTime *timespec); - void rtc_lld_get_time(RTCDateTime *timespec); - - void rtc_lld_get_alarm(RTCDateTime *timespec); - void rtc_lld_set_alarm(RTCDateTime *timespec); + void rtc_lld_set_time(RTCDriver *rtcp, const RTCTime *timespec); + void rtc_lld_get_time(RTCDriver *rtcp, RTCTime *timespec); + void rtc_lld_set_alarm(RTCDriver *rtcp, + rtcalarm_t alarm, + const RTCAlarm *alarmspec); + void rtc_lld_get_alarm(RTCDriver *rtcp, + rtcalarm_t alarm, + RTCAlarm *alarmspec); + void rtc_lld_set_callback(RTCDriver *rtcp, rtccb_t callback); #ifdef __cplusplus } #endif - #endif /* HAL_USE_RTC */ + #endif /* _RTC_LLD_H_ */ /** @} */ -- cgit v1.2.3