Johannes Stratmann / mbed-dev

added prescaler for 16 bit pwm in LPC1347 target

Fork of mbed-dev by mbed official

targets/hal/TARGET_Freescale/TARGET_KSDK2_MCUS/TARGET_K66F/drivers/fsl_rtc.c@144:ef7eb2e8f9f7, 2016-09-02 (annotated)

Committer:
<>
Date:
Fri Sep 02 15:07:44 2016 +0100
Revision:
144:ef7eb2e8f9f7
This updates the lib to the mbed lib v125

Who changed what in which revision?

UserRevisionLine numberNew contents of line
<> 144:ef7eb2e8f9f7 1 /*
<> 144:ef7eb2e8f9f7 2 * Copyright (c) 2015, Freescale Semiconductor, Inc.
<> 144:ef7eb2e8f9f7 3 * All rights reserved.
<> 144:ef7eb2e8f9f7 4 *
<> 144:ef7eb2e8f9f7 5 * Redistribution and use in source and binary forms, with or without modification,
<> 144:ef7eb2e8f9f7 6 * are permitted provided that the following conditions are met:
<> 144:ef7eb2e8f9f7 7 *
<> 144:ef7eb2e8f9f7 8 * o Redistributions of source code must retain the above copyright notice, this list
<> 144:ef7eb2e8f9f7 9 * of conditions and the following disclaimer.
<> 144:ef7eb2e8f9f7 10 *
<> 144:ef7eb2e8f9f7 11 * o Redistributions in binary form must reproduce the above copyright notice, this
<> 144:ef7eb2e8f9f7 12 * list of conditions and the following disclaimer in the documentation and/or
<> 144:ef7eb2e8f9f7 13 * other materials provided with the distribution.
<> 144:ef7eb2e8f9f7 14 *
<> 144:ef7eb2e8f9f7 15 * o Neither the name of Freescale Semiconductor, Inc. nor the names of its
<> 144:ef7eb2e8f9f7 16 * contributors may be used to endorse or promote products derived from this
<> 144:ef7eb2e8f9f7 17 * software without specific prior written permission.
<> 144:ef7eb2e8f9f7 18 *
<> 144:ef7eb2e8f9f7 19 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
<> 144:ef7eb2e8f9f7 20 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
<> 144:ef7eb2e8f9f7 21 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
<> 144:ef7eb2e8f9f7 22 * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
<> 144:ef7eb2e8f9f7 23 * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
<> 144:ef7eb2e8f9f7 24 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
<> 144:ef7eb2e8f9f7 25 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
<> 144:ef7eb2e8f9f7 26 * ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
<> 144:ef7eb2e8f9f7 27 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
<> 144:ef7eb2e8f9f7 28 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
<> 144:ef7eb2e8f9f7 29 */
<> 144:ef7eb2e8f9f7 30
<> 144:ef7eb2e8f9f7 31 #include "fsl_rtc.h"
<> 144:ef7eb2e8f9f7 32
<> 144:ef7eb2e8f9f7 33 /*******************************************************************************
<> 144:ef7eb2e8f9f7 34 * Definitions
<> 144:ef7eb2e8f9f7 35 ******************************************************************************/
<> 144:ef7eb2e8f9f7 36 #define SECONDS_IN_A_DAY (86400U)
<> 144:ef7eb2e8f9f7 37 #define SECONDS_IN_A_HOUR (3600U)
<> 144:ef7eb2e8f9f7 38 #define SECONDS_IN_A_MINUTE (60U)
<> 144:ef7eb2e8f9f7 39 #define DAYS_IN_A_YEAR (365U)
<> 144:ef7eb2e8f9f7 40 #define YEAR_RANGE_START (1970U)
<> 144:ef7eb2e8f9f7 41 #define YEAR_RANGE_END (2099U)
<> 144:ef7eb2e8f9f7 42
<> 144:ef7eb2e8f9f7 43 /*******************************************************************************
<> 144:ef7eb2e8f9f7 44 * Prototypes
<> 144:ef7eb2e8f9f7 45 ******************************************************************************/
<> 144:ef7eb2e8f9f7 46 /*!
<> 144:ef7eb2e8f9f7 47 * @brief Checks whether the date and time passed in is valid
<> 144:ef7eb2e8f9f7 48 *
<> 144:ef7eb2e8f9f7 49 * @param datetime Pointer to structure where the date and time details are stored
<> 144:ef7eb2e8f9f7 50 *
<> 144:ef7eb2e8f9f7 51 * @return Returns false if the date & time details are out of range; true if in range
<> 144:ef7eb2e8f9f7 52 */
<> 144:ef7eb2e8f9f7 53 static bool RTC_CheckDatetimeFormat(const rtc_datetime_t *datetime);
<> 144:ef7eb2e8f9f7 54
<> 144:ef7eb2e8f9f7 55 /*!
<> 144:ef7eb2e8f9f7 56 * @brief Converts time data from datetime to seconds
<> 144:ef7eb2e8f9f7 57 *
<> 144:ef7eb2e8f9f7 58 * @param datetime Pointer to datetime structure where the date and time details are stored
<> 144:ef7eb2e8f9f7 59 *
<> 144:ef7eb2e8f9f7 60 * @return The result of the conversion in seconds
<> 144:ef7eb2e8f9f7 61 */
<> 144:ef7eb2e8f9f7 62 static uint32_t RTC_ConvertDatetimeToSeconds(const rtc_datetime_t *datetime);
<> 144:ef7eb2e8f9f7 63
<> 144:ef7eb2e8f9f7 64 /*!
<> 144:ef7eb2e8f9f7 65 * @brief Converts time data from seconds to a datetime structure
<> 144:ef7eb2e8f9f7 66 *
<> 144:ef7eb2e8f9f7 67 * @param seconds Seconds value that needs to be converted to datetime format
<> 144:ef7eb2e8f9f7 68 * @param datetime Pointer to the datetime structure where the result of the conversion is stored
<> 144:ef7eb2e8f9f7 69 */
<> 144:ef7eb2e8f9f7 70 static void RTC_ConvertSecondsToDatetime(uint32_t seconds, rtc_datetime_t *datetime);
<> 144:ef7eb2e8f9f7 71
<> 144:ef7eb2e8f9f7 72 /*******************************************************************************
<> 144:ef7eb2e8f9f7 73 * Code
<> 144:ef7eb2e8f9f7 74 ******************************************************************************/
<> 144:ef7eb2e8f9f7 75 static bool RTC_CheckDatetimeFormat(const rtc_datetime_t *datetime)
<> 144:ef7eb2e8f9f7 76 {
<> 144:ef7eb2e8f9f7 77 /* Table of days in a month for a non leap year. First entry in the table is not used,
<> 144:ef7eb2e8f9f7 78 * valid months start from 1
<> 144:ef7eb2e8f9f7 79 */
<> 144:ef7eb2e8f9f7 80 uint8_t daysPerMonth[] = {0U, 31U, 28U, 31U, 30U, 31U, 30U, 31U, 31U, 30U, 31U, 30U, 31U};
<> 144:ef7eb2e8f9f7 81
<> 144:ef7eb2e8f9f7 82 /* Check year, month, hour, minute, seconds */
<> 144:ef7eb2e8f9f7 83 if ((datetime->year < YEAR_RANGE_START) || (datetime->year > YEAR_RANGE_END) || (datetime->month > 12U) ||
<> 144:ef7eb2e8f9f7 84 (datetime->month < 1U) || (datetime->hour >= 24U) || (datetime->minute >= 60U) || (datetime->second >= 60U))
<> 144:ef7eb2e8f9f7 85 {
<> 144:ef7eb2e8f9f7 86 /* If not correct then error*/
<> 144:ef7eb2e8f9f7 87 return false;
<> 144:ef7eb2e8f9f7 88 }
<> 144:ef7eb2e8f9f7 89
<> 144:ef7eb2e8f9f7 90 /* Adjust the days in February for a leap year */
<> 144:ef7eb2e8f9f7 91 if (!(datetime->year & 3U))
<> 144:ef7eb2e8f9f7 92 {
<> 144:ef7eb2e8f9f7 93 daysPerMonth[2] = 29U;
<> 144:ef7eb2e8f9f7 94 }
<> 144:ef7eb2e8f9f7 95
<> 144:ef7eb2e8f9f7 96 /* Check the validity of the day */
<> 144:ef7eb2e8f9f7 97 if (datetime->day > daysPerMonth[datetime->month])
<> 144:ef7eb2e8f9f7 98 {
<> 144:ef7eb2e8f9f7 99 return false;
<> 144:ef7eb2e8f9f7 100 }
<> 144:ef7eb2e8f9f7 101
<> 144:ef7eb2e8f9f7 102 return true;
<> 144:ef7eb2e8f9f7 103 }
<> 144:ef7eb2e8f9f7 104
<> 144:ef7eb2e8f9f7 105 static uint32_t RTC_ConvertDatetimeToSeconds(const rtc_datetime_t *datetime)
<> 144:ef7eb2e8f9f7 106 {
<> 144:ef7eb2e8f9f7 107 /* Number of days from begin of the non Leap-year*/
<> 144:ef7eb2e8f9f7 108 uint16_t monthDays[] = {0U, 0U, 31U, 59U, 90U, 120U, 151U, 181U, 212U, 243U, 273U, 304U, 334U};
<> 144:ef7eb2e8f9f7 109 uint32_t seconds;
<> 144:ef7eb2e8f9f7 110
<> 144:ef7eb2e8f9f7 111 /* Compute number of days from 1970 till given year*/
<> 144:ef7eb2e8f9f7 112 seconds = (datetime->year - 1970U) * DAYS_IN_A_YEAR;
<> 144:ef7eb2e8f9f7 113 /* Add leap year days */
<> 144:ef7eb2e8f9f7 114 seconds += ((datetime->year / 4) - (1970U / 4));
<> 144:ef7eb2e8f9f7 115 /* Add number of days till given month*/
<> 144:ef7eb2e8f9f7 116 seconds += monthDays[datetime->month];
<> 144:ef7eb2e8f9f7 117 /* Add days in given month. We subtract the current day as it is
<> 144:ef7eb2e8f9f7 118 * represented in the hours, minutes and seconds field*/
<> 144:ef7eb2e8f9f7 119 seconds += (datetime->day - 1);
<> 144:ef7eb2e8f9f7 120 /* For leap year if month less than or equal to Febraury, decrement day counter*/
<> 144:ef7eb2e8f9f7 121 if ((!(datetime->year & 3U)) && (datetime->month <= 2U))
<> 144:ef7eb2e8f9f7 122 {
<> 144:ef7eb2e8f9f7 123 seconds--;
<> 144:ef7eb2e8f9f7 124 }
<> 144:ef7eb2e8f9f7 125
<> 144:ef7eb2e8f9f7 126 seconds = (seconds * SECONDS_IN_A_DAY) + (datetime->hour * SECONDS_IN_A_HOUR) +
<> 144:ef7eb2e8f9f7 127 (datetime->minute * SECONDS_IN_A_MINUTE) + datetime->second;
<> 144:ef7eb2e8f9f7 128
<> 144:ef7eb2e8f9f7 129 return seconds;
<> 144:ef7eb2e8f9f7 130 }
<> 144:ef7eb2e8f9f7 131
<> 144:ef7eb2e8f9f7 132 static void RTC_ConvertSecondsToDatetime(uint32_t seconds, rtc_datetime_t *datetime)
<> 144:ef7eb2e8f9f7 133 {
<> 144:ef7eb2e8f9f7 134 uint32_t x;
<> 144:ef7eb2e8f9f7 135 uint32_t secondsRemaining, days;
<> 144:ef7eb2e8f9f7 136 uint16_t daysInYear;
<> 144:ef7eb2e8f9f7 137 /* Table of days in a month for a non leap year. First entry in the table is not used,
<> 144:ef7eb2e8f9f7 138 * valid months start from 1
<> 144:ef7eb2e8f9f7 139 */
<> 144:ef7eb2e8f9f7 140 uint8_t daysPerMonth[] = {0U, 31U, 28U, 31U, 30U, 31U, 30U, 31U, 31U, 30U, 31U, 30U, 31U};
<> 144:ef7eb2e8f9f7 141
<> 144:ef7eb2e8f9f7 142 /* Start with the seconds value that is passed in to be converted to date time format */
<> 144:ef7eb2e8f9f7 143 secondsRemaining = seconds;
<> 144:ef7eb2e8f9f7 144
<> 144:ef7eb2e8f9f7 145 /* Calcuate the number of days, we add 1 for the current day which is represented in the
<> 144:ef7eb2e8f9f7 146 * hours and seconds field
<> 144:ef7eb2e8f9f7 147 */
<> 144:ef7eb2e8f9f7 148 days = secondsRemaining / SECONDS_IN_A_DAY + 1;
<> 144:ef7eb2e8f9f7 149
<> 144:ef7eb2e8f9f7 150 /* Update seconds left*/
<> 144:ef7eb2e8f9f7 151 secondsRemaining = secondsRemaining % SECONDS_IN_A_DAY;
<> 144:ef7eb2e8f9f7 152
<> 144:ef7eb2e8f9f7 153 /* Calculate the datetime hour, minute and second fields */
<> 144:ef7eb2e8f9f7 154 datetime->hour = secondsRemaining / SECONDS_IN_A_HOUR;
<> 144:ef7eb2e8f9f7 155 secondsRemaining = secondsRemaining % SECONDS_IN_A_HOUR;
<> 144:ef7eb2e8f9f7 156 datetime->minute = secondsRemaining / 60U;
<> 144:ef7eb2e8f9f7 157 datetime->second = secondsRemaining % SECONDS_IN_A_MINUTE;
<> 144:ef7eb2e8f9f7 158
<> 144:ef7eb2e8f9f7 159 /* Calculate year */
<> 144:ef7eb2e8f9f7 160 daysInYear = DAYS_IN_A_YEAR;
<> 144:ef7eb2e8f9f7 161 datetime->year = YEAR_RANGE_START;
<> 144:ef7eb2e8f9f7 162 while (days > daysInYear)
<> 144:ef7eb2e8f9f7 163 {
<> 144:ef7eb2e8f9f7 164 /* Decrease day count by a year and increment year by 1 */
<> 144:ef7eb2e8f9f7 165 days -= daysInYear;
<> 144:ef7eb2e8f9f7 166 datetime->year++;
<> 144:ef7eb2e8f9f7 167
<> 144:ef7eb2e8f9f7 168 /* Adjust the number of days for a leap year */
<> 144:ef7eb2e8f9f7 169 if (datetime->year & 3U)
<> 144:ef7eb2e8f9f7 170 {
<> 144:ef7eb2e8f9f7 171 daysInYear = DAYS_IN_A_YEAR;
<> 144:ef7eb2e8f9f7 172 }
<> 144:ef7eb2e8f9f7 173 else
<> 144:ef7eb2e8f9f7 174 {
<> 144:ef7eb2e8f9f7 175 daysInYear = DAYS_IN_A_YEAR + 1;
<> 144:ef7eb2e8f9f7 176 }
<> 144:ef7eb2e8f9f7 177 }
<> 144:ef7eb2e8f9f7 178
<> 144:ef7eb2e8f9f7 179 /* Adjust the days in February for a leap year */
<> 144:ef7eb2e8f9f7 180 if (!(datetime->year & 3U))
<> 144:ef7eb2e8f9f7 181 {
<> 144:ef7eb2e8f9f7 182 daysPerMonth[2] = 29U;
<> 144:ef7eb2e8f9f7 183 }
<> 144:ef7eb2e8f9f7 184
<> 144:ef7eb2e8f9f7 185 for (x = 1U; x <= 12U; x++)
<> 144:ef7eb2e8f9f7 186 {
<> 144:ef7eb2e8f9f7 187 if (days <= daysPerMonth[x])
<> 144:ef7eb2e8f9f7 188 {
<> 144:ef7eb2e8f9f7 189 datetime->month = x;
<> 144:ef7eb2e8f9f7 190 break;
<> 144:ef7eb2e8f9f7 191 }
<> 144:ef7eb2e8f9f7 192 else
<> 144:ef7eb2e8f9f7 193 {
<> 144:ef7eb2e8f9f7 194 days -= daysPerMonth[x];
<> 144:ef7eb2e8f9f7 195 }
<> 144:ef7eb2e8f9f7 196 }
<> 144:ef7eb2e8f9f7 197
<> 144:ef7eb2e8f9f7 198 datetime->day = days;
<> 144:ef7eb2e8f9f7 199 }
<> 144:ef7eb2e8f9f7 200
<> 144:ef7eb2e8f9f7 201 void RTC_Init(RTC_Type *base, const rtc_config_t *config)
<> 144:ef7eb2e8f9f7 202 {
<> 144:ef7eb2e8f9f7 203 assert(config);
<> 144:ef7eb2e8f9f7 204
<> 144:ef7eb2e8f9f7 205 uint32_t reg;
<> 144:ef7eb2e8f9f7 206
<> 144:ef7eb2e8f9f7 207 CLOCK_EnableClock(kCLOCK_Rtc0);
<> 144:ef7eb2e8f9f7 208
<> 144:ef7eb2e8f9f7 209 /* Issue a software reset if timer is invalid */
<> 144:ef7eb2e8f9f7 210 if (RTC_GetStatusFlags(RTC) & kRTC_TimeInvalidFlag)
<> 144:ef7eb2e8f9f7 211 {
<> 144:ef7eb2e8f9f7 212 RTC_Reset(RTC);
<> 144:ef7eb2e8f9f7 213 }
<> 144:ef7eb2e8f9f7 214
<> 144:ef7eb2e8f9f7 215 reg = base->CR;
<> 144:ef7eb2e8f9f7 216 /* Setup the update mode and supervisor access mode */
<> 144:ef7eb2e8f9f7 217 reg &= ~(RTC_CR_UM_MASK | RTC_CR_SUP_MASK);
<> 144:ef7eb2e8f9f7 218 reg |= RTC_CR_UM(config->updateMode) | RTC_CR_SUP(config->supervisorAccess);
<> 144:ef7eb2e8f9f7 219 #if defined(FSL_FEATURE_RTC_HAS_WAKEUP_PIN) && FSL_FEATURE_RTC_HAS_WAKEUP_PIN
<> 144:ef7eb2e8f9f7 220 /* Setup the wakeup pin select */
<> 144:ef7eb2e8f9f7 221 reg &= ~(RTC_CR_WPS_MASK);
<> 144:ef7eb2e8f9f7 222 reg |= RTC_CR_WPS(config->wakeupSelect);
<> 144:ef7eb2e8f9f7 223 #endif /* FSL_FEATURE_RTC_HAS_WAKEUP_PIN */
<> 144:ef7eb2e8f9f7 224 base->CR = reg;
<> 144:ef7eb2e8f9f7 225
<> 144:ef7eb2e8f9f7 226 /* Configure the RTC time compensation register */
<> 144:ef7eb2e8f9f7 227 base->TCR = (RTC_TCR_CIR(config->compensationInterval) | RTC_TCR_TCR(config->compensationTime));
<> 144:ef7eb2e8f9f7 228 }
<> 144:ef7eb2e8f9f7 229
<> 144:ef7eb2e8f9f7 230 void RTC_GetDefaultConfig(rtc_config_t *config)
<> 144:ef7eb2e8f9f7 231 {
<> 144:ef7eb2e8f9f7 232 assert(config);
<> 144:ef7eb2e8f9f7 233
<> 144:ef7eb2e8f9f7 234 /* Wakeup pin will assert if the RTC interrupt asserts or if the wakeup pin is turned on */
<> 144:ef7eb2e8f9f7 235 config->wakeupSelect = false;
<> 144:ef7eb2e8f9f7 236 /* Registers cannot be written when locked */
<> 144:ef7eb2e8f9f7 237 config->updateMode = false;
<> 144:ef7eb2e8f9f7 238 /* Non-supervisor mode write accesses are not supported and will generate a bus error */
<> 144:ef7eb2e8f9f7 239 config->supervisorAccess = false;
<> 144:ef7eb2e8f9f7 240 /* Compensation interval used by the crystal compensation logic */
<> 144:ef7eb2e8f9f7 241 config->compensationInterval = 0;
<> 144:ef7eb2e8f9f7 242 /* Compensation time used by the crystal compensation logic */
<> 144:ef7eb2e8f9f7 243 config->compensationTime = 0;
<> 144:ef7eb2e8f9f7 244 }
<> 144:ef7eb2e8f9f7 245
<> 144:ef7eb2e8f9f7 246 status_t RTC_SetDatetime(RTC_Type *base, const rtc_datetime_t *datetime)
<> 144:ef7eb2e8f9f7 247 {
<> 144:ef7eb2e8f9f7 248 assert(datetime);
<> 144:ef7eb2e8f9f7 249
<> 144:ef7eb2e8f9f7 250 /* Return error if the time provided is not valid */
<> 144:ef7eb2e8f9f7 251 if (!(RTC_CheckDatetimeFormat(datetime)))
<> 144:ef7eb2e8f9f7 252 {
<> 144:ef7eb2e8f9f7 253 return kStatus_InvalidArgument;
<> 144:ef7eb2e8f9f7 254 }
<> 144:ef7eb2e8f9f7 255
<> 144:ef7eb2e8f9f7 256 /* Set time in seconds */
<> 144:ef7eb2e8f9f7 257 base->TSR = RTC_ConvertDatetimeToSeconds(datetime);
<> 144:ef7eb2e8f9f7 258
<> 144:ef7eb2e8f9f7 259 return kStatus_Success;
<> 144:ef7eb2e8f9f7 260 }
<> 144:ef7eb2e8f9f7 261
<> 144:ef7eb2e8f9f7 262 void RTC_GetDatetime(RTC_Type *base, rtc_datetime_t *datetime)
<> 144:ef7eb2e8f9f7 263 {
<> 144:ef7eb2e8f9f7 264 assert(datetime);
<> 144:ef7eb2e8f9f7 265
<> 144:ef7eb2e8f9f7 266 uint32_t seconds = 0;
<> 144:ef7eb2e8f9f7 267
<> 144:ef7eb2e8f9f7 268 seconds = base->TSR;
<> 144:ef7eb2e8f9f7 269 RTC_ConvertSecondsToDatetime(seconds, datetime);
<> 144:ef7eb2e8f9f7 270 }
<> 144:ef7eb2e8f9f7 271
<> 144:ef7eb2e8f9f7 272 status_t RTC_SetAlarm(RTC_Type *base, const rtc_datetime_t *alarmTime)
<> 144:ef7eb2e8f9f7 273 {
<> 144:ef7eb2e8f9f7 274 assert(alarmTime);
<> 144:ef7eb2e8f9f7 275
<> 144:ef7eb2e8f9f7 276 uint32_t alarmSeconds = 0;
<> 144:ef7eb2e8f9f7 277 uint32_t currSeconds = 0;
<> 144:ef7eb2e8f9f7 278
<> 144:ef7eb2e8f9f7 279 /* Return error if the alarm time provided is not valid */
<> 144:ef7eb2e8f9f7 280 if (!(RTC_CheckDatetimeFormat(alarmTime)))
<> 144:ef7eb2e8f9f7 281 {
<> 144:ef7eb2e8f9f7 282 return kStatus_InvalidArgument;
<> 144:ef7eb2e8f9f7 283 }
<> 144:ef7eb2e8f9f7 284
<> 144:ef7eb2e8f9f7 285 alarmSeconds = RTC_ConvertDatetimeToSeconds(alarmTime);
<> 144:ef7eb2e8f9f7 286
<> 144:ef7eb2e8f9f7 287 /* Get the current time */
<> 144:ef7eb2e8f9f7 288 currSeconds = base->TSR;
<> 144:ef7eb2e8f9f7 289
<> 144:ef7eb2e8f9f7 290 /* Return error if the alarm time has passed */
<> 144:ef7eb2e8f9f7 291 if (alarmSeconds < currSeconds)
<> 144:ef7eb2e8f9f7 292 {
<> 144:ef7eb2e8f9f7 293 return kStatus_Fail;
<> 144:ef7eb2e8f9f7 294 }
<> 144:ef7eb2e8f9f7 295
<> 144:ef7eb2e8f9f7 296 /* Set alarm in seconds*/
<> 144:ef7eb2e8f9f7 297 base->TAR = alarmSeconds;
<> 144:ef7eb2e8f9f7 298
<> 144:ef7eb2e8f9f7 299 return kStatus_Success;
<> 144:ef7eb2e8f9f7 300 }
<> 144:ef7eb2e8f9f7 301
<> 144:ef7eb2e8f9f7 302 void RTC_GetAlarm(RTC_Type *base, rtc_datetime_t *datetime)
<> 144:ef7eb2e8f9f7 303 {
<> 144:ef7eb2e8f9f7 304 assert(datetime);
<> 144:ef7eb2e8f9f7 305
<> 144:ef7eb2e8f9f7 306 uint32_t alarmSeconds = 0;
<> 144:ef7eb2e8f9f7 307
<> 144:ef7eb2e8f9f7 308 /* Get alarm in seconds */
<> 144:ef7eb2e8f9f7 309 alarmSeconds = base->TAR;
<> 144:ef7eb2e8f9f7 310
<> 144:ef7eb2e8f9f7 311 RTC_ConvertSecondsToDatetime(alarmSeconds, datetime);
<> 144:ef7eb2e8f9f7 312 }
<> 144:ef7eb2e8f9f7 313
<> 144:ef7eb2e8f9f7 314 void RTC_ClearStatusFlags(RTC_Type *base, uint32_t mask)
<> 144:ef7eb2e8f9f7 315 {
<> 144:ef7eb2e8f9f7 316 /* The alarm flag is cleared by writing to the TAR register */
<> 144:ef7eb2e8f9f7 317 if (mask & kRTC_AlarmFlag)
<> 144:ef7eb2e8f9f7 318 {
<> 144:ef7eb2e8f9f7 319 base->TAR = 0U;
<> 144:ef7eb2e8f9f7 320 }
<> 144:ef7eb2e8f9f7 321
<> 144:ef7eb2e8f9f7 322 /* The timer overflow flag is cleared by initializing the TSR register.
<> 144:ef7eb2e8f9f7 323 * The time counter should be disabled for this write to be successful
<> 144:ef7eb2e8f9f7 324 */
<> 144:ef7eb2e8f9f7 325 if (mask & kRTC_TimeOverflowFlag)
<> 144:ef7eb2e8f9f7 326 {
<> 144:ef7eb2e8f9f7 327 base->TSR = 1U;
<> 144:ef7eb2e8f9f7 328 }
<> 144:ef7eb2e8f9f7 329
<> 144:ef7eb2e8f9f7 330 /* The timer overflow flag is cleared by initializing the TSR register.
<> 144:ef7eb2e8f9f7 331 * The time counter should be disabled for this write to be successful
<> 144:ef7eb2e8f9f7 332 */
<> 144:ef7eb2e8f9f7 333 if (mask & kRTC_TimeInvalidFlag)
<> 144:ef7eb2e8f9f7 334 {
<> 144:ef7eb2e8f9f7 335 base->TSR = 1U;
<> 144:ef7eb2e8f9f7 336 }
<> 144:ef7eb2e8f9f7 337 }
<> 144:ef7eb2e8f9f7 338
<> 144:ef7eb2e8f9f7 339 #if defined(FSL_FEATURE_RTC_HAS_MONOTONIC) && (FSL_FEATURE_RTC_HAS_MONOTONIC)
<> 144:ef7eb2e8f9f7 340
<> 144:ef7eb2e8f9f7 341 void RTC_GetMonotonicCounter(RTC_Type *base, uint64_t *counter)
<> 144:ef7eb2e8f9f7 342 {
<> 144:ef7eb2e8f9f7 343 *counter = (((uint64_t)base->MCHR << 32) | ((uint64_t)base->MCLR));
<> 144:ef7eb2e8f9f7 344 }
<> 144:ef7eb2e8f9f7 345
<> 144:ef7eb2e8f9f7 346 void RTC_SetMonotonicCounter(RTC_Type *base, uint64_t counter)
<> 144:ef7eb2e8f9f7 347 {
<> 144:ef7eb2e8f9f7 348 /* Prepare to initialize the register with the new value written */
<> 144:ef7eb2e8f9f7 349 base->MER &= ~RTC_MER_MCE_MASK;
<> 144:ef7eb2e8f9f7 350
<> 144:ef7eb2e8f9f7 351 base->MCHR = (uint32_t)((counter) >> 32);
<> 144:ef7eb2e8f9f7 352 base->MCLR = (uint32_t)(counter);
<> 144:ef7eb2e8f9f7 353 }
<> 144:ef7eb2e8f9f7 354
<> 144:ef7eb2e8f9f7 355 status_t RTC_IncrementMonotonicCounter(RTC_Type *base)
<> 144:ef7eb2e8f9f7 356 {
<> 144:ef7eb2e8f9f7 357 if (base->SR & (RTC_SR_MOF_MASK | RTC_SR_TIF_MASK))
<> 144:ef7eb2e8f9f7 358 {
<> 144:ef7eb2e8f9f7 359 return kStatus_Fail;
<> 144:ef7eb2e8f9f7 360 }
<> 144:ef7eb2e8f9f7 361
<> 144:ef7eb2e8f9f7 362 /* Prepare to switch to increment mode */
<> 144:ef7eb2e8f9f7 363 base->MER |= RTC_MER_MCE_MASK;
<> 144:ef7eb2e8f9f7 364 /* Write anything so the counter increments*/
<> 144:ef7eb2e8f9f7 365 base->MCLR = 1U;
<> 144:ef7eb2e8f9f7 366
<> 144:ef7eb2e8f9f7 367 return kStatus_Success;
<> 144:ef7eb2e8f9f7 368 }
<> 144:ef7eb2e8f9f7 369
<> 144:ef7eb2e8f9f7 370 #endif /* FSL_FEATURE_RTC_HAS_MONOTONIC */