git.sur5r.net Git - freertos/blob - FreeRTOS/Demo/CORTEX_MPU_M23_Nuvoton_NuMaker_PFM_M2351_IAR_GCC/Nuvoton_Code/StdDriver/src/rtc.c

   1 /**************************************************************************//**\r
   2  * @file     rtc.c\r
   3  * @version  V3.00\r
   4  * @brief    Real Time Clock(RTC) driver source file\r
   5  *\r
   6  * @copyright (C) 2016 Nuvoton Technology Corp. All rights reserved.\r
   7 *****************************************************************************/\r
   8 #include "NuMicro.h"\r
   9 \r
  10 \r
  11 /** @cond HIDDEN_SYMBOLS */\r
  12 \r
  13 /*---------------------------------------------------------------------------------------------------------*/\r
  14 /* Macro, type and constant definitions                                                                    */\r
  15 /*---------------------------------------------------------------------------------------------------------*/\r
  16 #define RTC_GLOBALS\r
  17 \r
  18 /*---------------------------------------------------------------------------------------------------------*/\r
  19 /* Global file scope (static) variables                                                                    */\r
  20 /*---------------------------------------------------------------------------------------------------------*/\r
  21 static volatile uint32_t g_u32hiYear, g_u32loYear, g_u32hiMonth, g_u32loMonth, g_u32hiDay, g_u32loDay;\r
  22 static volatile uint32_t g_u32hiHour, g_u32loHour, g_u32hiMin, g_u32loMin, g_u32hiSec, g_u32loSec;\r
  23 \r
  24 /** @endcond HIDDEN_SYMBOLS */\r
  25 \r
  26 \r
  27 /** @addtogroup Standard_Driver Standard Driver\r
  28   @{\r
  29 */\r
  30 \r
  31 /** @addtogroup RTC_Driver RTC Driver\r
  32   @{\r
  33 */\r
  34 \r
  35 /** @addtogroup RTC_EXPORTED_FUNCTIONS RTC Exported Functions\r
  36   @{\r
  37 */\r
  38 \r
  39 /**\r
  40   * @brief      Initialize RTC module and start counting\r
  41   *\r
  42   * @param[in]  sPt     Specify the time property and current date and time. It includes:           \n\r
  43   *                     u32Year: Year value, range between 2000 ~ 2099.                             \n\r
  44   *                     u32Month: Month value, range between 1 ~ 12.                                \n\r
  45   *                     u32Day: Day value, range between 1 ~ 31.                                    \n\r
  46   *                     u32DayOfWeek: Day of the week. [RTC_SUNDAY / RTC_MONDAY / RTC_TUESDAY /\r
  47   *                                                     RTC_WEDNESDAY / RTC_THURSDAY / RTC_FRIDAY /\r
  48   *                                                     RTC_SATURDAY]                               \n\r
  49   *                     u32Hour: Hour value, range between 0 ~ 23.                                  \n\r
  50   *                     u32Minute: Minute value, range between 0 ~ 59.                              \n\r
  51   *                     u32Second: Second value, range between 0 ~ 59.                              \n\r
  52   *                     u32TimeScale: [RTC_CLOCK_12 / RTC_CLOCK_24]                                 \n\r
  53   *                     u8AmPm: [RTC_AM / RTC_PM]                                                   \n\r
  54   *\r
  55   * @return     None\r
  56   *\r
  57   * @details    This function is used to: \n\r
  58   *                 1. Write initial key to let RTC start count.  \n\r
  59   *                 2. Input parameter indicates start date/time. \n\r
  60   *                 3. User has to make sure that parameters of RTC date/time are reasonable. \n\r
  61   * @note       Null pointer for using default starting date/time.\r
  62   */\r
  63 void RTC_Open(S_RTC_TIME_DATA_T *sPt)\r
  64 {\r
  65     RTC_T *pRTC;\r
  66 \r
  67     if((__PC()&NS_OFFSET) == NS_OFFSET)\r
  68     {\r
  69         pRTC = RTC_NS;\r
  70     }\r
  71     else\r
  72     {\r
  73         pRTC = RTC;\r
  74     }\r
  75 \r
  76     pRTC->INIT = RTC_INIT_KEY;\r
  77 \r
  78     if(pRTC->INIT != RTC_INIT_ACTIVE_Msk)\r
  79     {\r
  80         pRTC->INIT = RTC_INIT_KEY;\r
  81         while(pRTC->INIT != RTC_INIT_ACTIVE_Msk) {}\r
  82     }\r
  83 \r
  84     if(sPt == 0)\r
  85     {\r
  86         ; /* No RTC date/time data */\r
  87     }\r
  88     else\r
  89     {\r
  90         /* Set RTC date and time */\r
  91         RTC_SetDateAndTime(sPt);\r
  92     }\r
  93 }\r
  94 \r
  95 /**\r
  96   * @brief      Disable RTC Clock\r
  97   *\r
  98   * @param      None\r
  99   *\r
 100   * @return     None\r
 101   *\r
 102   * @details    This API will disable RTC peripheral clock and stops RTC counting.\r
 103   */\r
 104 void RTC_Close(void)\r
 105 {\r
 106     if((__PC()&NS_OFFSET) == NS_OFFSET)\r
 107     {\r
 108         ; /* Disable RTC clock in secure mode only */\r
 109     }\r
 110     else\r
 111     {\r
 112         CLK->APBCLK0 &= ~CLK_APBCLK0_RTCCKEN_Msk;\r
 113     }\r
 114 }\r
 115 \r
 116 /**\r
 117   * @brief      Set 32k Frequency Compensation Data\r
 118   *\r
 119   *  @param[in]    i32FrequencyX10000    Specify the RTC clock X10000, ex: 327736512 means 32773.6512.\r
 120   *\r
 121   * @return     None\r
 122   *\r
 123   * @details    This API is used to compensate the 32 kHz frequency by current LXT frequency for RTC application.\r
 124   */\r
 125 void RTC_32KCalibration(int32_t i32FrequencyX10000)\r
 126 {\r
 127     uint64_t u64Compensate;\r
 128     RTC_T *pRTC;\r
 129 \r
 130     if((__PC()&NS_OFFSET) == NS_OFFSET)\r
 131     {\r
 132         pRTC = RTC_NS;\r
 133     }\r
 134     else\r
 135     {\r
 136         pRTC = RTC;\r
 137     }\r
 138 \r
 139     /* u64Compensate = (uint64_t)(0x64000000000); */\r
 140     u64Compensate = (uint64_t)(0x2710000000000);\r
 141     u64Compensate = (uint64_t)(u64Compensate / (uint64_t)i32FrequencyX10000);\r
 142     /*\r
 143         Formula for 32K compensation is\r
 144             FREQADJ = 0x200000 * (32768 / LXT_freq)\r
 145     */\r
 146     if(u64Compensate >= (uint64_t)0x400000)\r
 147     {\r
 148         u64Compensate = (uint64_t)0x3FFFFF;\r
 149     }\r
 150 \r
 151     RTC_WaitAccessEnable();\r
 152     pRTC->FREQADJ = (uint32_t)u64Compensate;\r
 153 }\r
 154 \r
 155 /**\r
 156   * @brief      Get Current RTC Date and Time\r
 157   *\r
 158   * @param[out] sPt     The returned pointer is specified the current RTC value. It includes: \n\r
 159   *                     u32Year: Year value                                                   \n\r
 160   *                     u32Month: Month value                                                 \n\r
 161   *                     u32Day: Day value                                                     \n\r
 162   *                     u32DayOfWeek: Day of week                                             \n\r
 163   *                     u32Hour: Hour value                                                   \n\r
 164   *                     u32Minute: Minute value                                               \n\r
 165   *                     u32Second: Second value                                               \n\r
 166   *                     u32TimeScale: [RTC_CLOCK_12 / RTC_CLOCK_24]                           \n\r
 167   *                     u8AmPm: [RTC_AM / RTC_PM]                                             \n\r
 168   *\r
 169   * @return     None\r
 170   *\r
 171   * @details    This API is used to get the current RTC date and time value.\r
 172   */\r
 173 void RTC_GetDateAndTime(S_RTC_TIME_DATA_T *sPt)\r
 174 {\r
 175     uint32_t u32Tmp;\r
 176     RTC_T *pRTC;\r
 177 \r
 178     if((__PC()&NS_OFFSET) == NS_OFFSET)\r
 179     {\r
 180         pRTC = RTC_NS;\r
 181     }\r
 182     else\r
 183     {\r
 184         pRTC = RTC;\r
 185     }\r
 186 \r
 187     sPt->u32TimeScale = pRTC->CLKFMT & RTC_CLKFMT_24HEN_Msk;     /* 12/24-hour */\r
 188     sPt->u32DayOfWeek = pRTC->WEEKDAY & RTC_WEEKDAY_WEEKDAY_Msk; /* Day of the week */\r
 189 \r
 190     /* Get [Date digit] data */\r
 191     g_u32hiYear  = (pRTC->CAL & RTC_CAL_TENYEAR_Msk) >> RTC_CAL_TENYEAR_Pos;\r
 192     g_u32loYear  = (pRTC->CAL & RTC_CAL_YEAR_Msk) >> RTC_CAL_YEAR_Pos;\r
 193     g_u32hiMonth = (pRTC->CAL & RTC_CAL_TENMON_Msk) >> RTC_CAL_TENMON_Pos;\r
 194     g_u32loMonth = (pRTC->CAL & RTC_CAL_MON_Msk) >> RTC_CAL_MON_Pos;\r
 195     g_u32hiDay   = (pRTC->CAL & RTC_CAL_TENDAY_Msk) >> RTC_CAL_TENDAY_Pos;\r
 196     g_u32loDay   = (pRTC->CAL & RTC_CAL_DAY_Msk) >> RTC_CAL_DAY_Pos;\r
 197 \r
 198     /* Get [Time digit] data */\r
 199     g_u32hiHour = (pRTC->TIME & RTC_TIME_TENHR_Msk) >> RTC_TIME_TENHR_Pos;\r
 200     g_u32loHour = (pRTC->TIME & RTC_TIME_HR_Msk) >> RTC_TIME_HR_Pos;\r
 201     g_u32hiMin  = (pRTC->TIME & RTC_TIME_TENMIN_Msk) >> RTC_TIME_TENMIN_Pos;\r
 202     g_u32loMin  = (pRTC->TIME & RTC_TIME_MIN_Msk) >> RTC_TIME_MIN_Pos;\r
 203     g_u32hiSec  = (pRTC->TIME & RTC_TIME_TENSEC_Msk) >> RTC_TIME_TENSEC_Pos;\r
 204     g_u32loSec  = (pRTC->TIME & RTC_TIME_SEC_Msk) >> RTC_TIME_SEC_Pos;\r
 205 \r
 206     /* Compute to 20XX year */\r
 207     u32Tmp  = (g_u32hiYear * 10UL);\r
 208     u32Tmp += g_u32loYear;\r
 209     sPt->u32Year = u32Tmp + (uint32_t)RTC_YEAR2000;\r
 210 \r
 211     /* Compute 0~12 month */\r
 212     u32Tmp = (g_u32hiMonth * 10UL);\r
 213     sPt->u32Month = u32Tmp + g_u32loMonth;\r
 214 \r
 215     /* Compute 0~31 day */\r
 216     u32Tmp = (g_u32hiDay * 10UL);\r
 217     sPt->u32Day =  u32Tmp  + g_u32loDay;\r
 218 \r
 219     /* Compute 12/24 hour */\r
 220     if(sPt->u32TimeScale == (uint32_t)RTC_CLOCK_12)\r
 221     {\r
 222         u32Tmp = (g_u32hiHour * 10UL);\r
 223         u32Tmp += g_u32loHour;\r
 224         sPt->u32Hour = u32Tmp;          /* AM: 1~12. PM: 21~32. */\r
 225 \r
 226         if(sPt->u32Hour >= 21UL)\r
 227         {\r
 228             sPt->u32AmPm  = (uint32_t)RTC_PM;\r
 229             sPt->u32Hour -= 20UL;\r
 230         }\r
 231         else\r
 232         {\r
 233             sPt->u32AmPm = (uint32_t)RTC_AM;\r
 234         }\r
 235 \r
 236         u32Tmp  = (g_u32hiMin  * 10UL);\r
 237         u32Tmp += g_u32loMin;\r
 238         sPt->u32Minute = u32Tmp;\r
 239 \r
 240         u32Tmp  = (g_u32hiSec  * 10UL);\r
 241         u32Tmp += g_u32loSec;\r
 242         sPt->u32Second = u32Tmp;\r
 243     }\r
 244     else\r
 245     {\r
 246         u32Tmp  = (g_u32hiHour * 10UL);\r
 247         u32Tmp += g_u32loHour;\r
 248         sPt->u32Hour = u32Tmp;\r
 249 \r
 250         u32Tmp  = (g_u32hiMin * 10UL);\r
 251         u32Tmp +=  g_u32loMin;\r
 252         sPt->u32Minute = u32Tmp;\r
 253 \r
 254         u32Tmp  = (g_u32hiSec * 10UL);\r
 255         u32Tmp += g_u32loSec;\r
 256         sPt->u32Second = u32Tmp;\r
 257     }\r
 258 }\r
 259 \r
 260 /**\r
 261   * @brief      Get RTC Alarm Date and Time\r
 262   *\r
 263   * @param[out] sPt     The returned pointer is specified the RTC alarm value. It includes: \n\r
 264   *                     u32Year: Year value                                                 \n\r
 265   *                     u32Month: Month value                                               \n\r
 266   *                     u32Day: Day value                                                   \n\r
 267   *                     u32DayOfWeek: Day of week                                           \n\r
 268   *                     u32Hour: Hour value                                                 \n\r
 269   *                     u32Minute: Minute value                                             \n\r
 270   *                     u32Second: Second value                                             \n\r
 271   *                     u32TimeScale: [RTC_CLOCK_12 / RTC_CLOCK_24]                         \n\r
 272   *                     u8AmPm: [RTC_AM / RTC_PM]                                           \n\r
 273   *\r
 274   * @return     None\r
 275   *\r
 276   * @details    This API is used to get the RTC alarm date and time setting.\r
 277   */\r
 278 void RTC_GetAlarmDateAndTime(S_RTC_TIME_DATA_T *sPt)\r
 279 {\r
 280     uint32_t u32Tmp;\r
 281     RTC_T *pRTC;\r
 282 \r
 283     if((__PC()&NS_OFFSET) == NS_OFFSET)\r
 284     {\r
 285         pRTC = RTC_NS;\r
 286     }\r
 287     else\r
 288     {\r
 289         pRTC = RTC;\r
 290     }\r
 291 \r
 292     sPt->u32TimeScale = pRTC->CLKFMT & RTC_CLKFMT_24HEN_Msk;     /* 12/24-hour */\r
 293     sPt->u32DayOfWeek = pRTC->WEEKDAY & RTC_WEEKDAY_WEEKDAY_Msk; /* Day of the week */\r
 294 \r
 295     /* Get alarm [Date digit] data */\r
 296     RTC_WaitAccessEnable();\r
 297     g_u32hiYear  = (pRTC->CALM & RTC_CALM_TENYEAR_Msk) >> RTC_CALM_TENYEAR_Pos;\r
 298     g_u32loYear  = (pRTC->CALM & RTC_CALM_YEAR_Msk) >> RTC_CALM_YEAR_Pos;\r
 299     g_u32hiMonth = (pRTC->CALM & RTC_CALM_TENMON_Msk) >> RTC_CALM_TENMON_Pos;\r
 300     g_u32loMonth = (pRTC->CALM & RTC_CALM_MON_Msk) >> RTC_CALM_MON_Pos;\r
 301     g_u32hiDay   = (pRTC->CALM & RTC_CALM_TENDAY_Msk) >> RTC_CALM_TENDAY_Pos;\r
 302     g_u32loDay   = (pRTC->CALM & RTC_CALM_DAY_Msk) >> RTC_CALM_DAY_Pos;\r
 303 \r
 304     /* Get alarm [Time digit] data */\r
 305     RTC_WaitAccessEnable();\r
 306     g_u32hiHour = (pRTC->TALM & RTC_TALM_TENHR_Msk) >> RTC_TALM_TENHR_Pos;\r
 307     g_u32loHour = (pRTC->TALM & RTC_TALM_HR_Msk) >> RTC_TALM_HR_Pos;\r
 308     g_u32hiMin  = (pRTC->TALM & RTC_TALM_TENMIN_Msk) >> RTC_TALM_TENMIN_Pos;\r
 309     g_u32loMin  = (pRTC->TALM & RTC_TALM_MIN_Msk) >> RTC_TALM_MIN_Pos;\r
 310     g_u32hiSec  = (pRTC->TALM & RTC_TALM_TENSEC_Msk) >> RTC_TALM_TENSEC_Pos;\r
 311     g_u32loSec  = (pRTC->TALM & RTC_TALM_SEC_Msk) >> RTC_TALM_SEC_Pos;\r
 312 \r
 313     /* Compute to 20XX year */\r
 314     u32Tmp  = (g_u32hiYear * 10UL);\r
 315     u32Tmp += g_u32loYear;\r
 316     sPt->u32Year = u32Tmp + (uint32_t)RTC_YEAR2000;\r
 317 \r
 318     /* Compute 0~12 month */\r
 319     u32Tmp = (g_u32hiMonth * 10UL);\r
 320     sPt->u32Month = u32Tmp + g_u32loMonth;\r
 321 \r
 322     /* Compute 0~31 day */\r
 323     u32Tmp = (g_u32hiDay * 10UL);\r
 324     sPt->u32Day = u32Tmp + g_u32loDay;\r
 325 \r
 326     /* Compute 12/24 hour */\r
 327     if(sPt->u32TimeScale == (uint32_t)RTC_CLOCK_12)\r
 328     {\r
 329         u32Tmp  = (g_u32hiHour * 10UL);\r
 330         u32Tmp += g_u32loHour;\r
 331         sPt->u32Hour = u32Tmp;          /* AM: 1~12. PM: 21~32. */\r
 332 \r
 333         if(sPt->u32Hour >= 21UL)\r
 334         {\r
 335             sPt->u32AmPm  = (uint32_t)RTC_PM;\r
 336             sPt->u32Hour -= 20UL;\r
 337         }\r
 338         else\r
 339         {\r
 340             sPt->u32AmPm = (uint32_t)RTC_AM;\r
 341         }\r
 342 \r
 343         u32Tmp  = (g_u32hiMin * 10UL);\r
 344         u32Tmp += g_u32loMin;\r
 345         sPt->u32Minute = u32Tmp;\r
 346 \r
 347         u32Tmp  = (g_u32hiSec * 10UL);\r
 348         u32Tmp += g_u32loSec;\r
 349         sPt->u32Second = u32Tmp;\r
 350     }\r
 351     else\r
 352     {\r
 353         u32Tmp  = (g_u32hiHour * 10UL);\r
 354         u32Tmp +=  g_u32loHour;\r
 355         sPt->u32Hour = u32Tmp;\r
 356 \r
 357         u32Tmp  = (g_u32hiMin * 10UL);\r
 358         u32Tmp += g_u32loMin;\r
 359         sPt->u32Minute = u32Tmp;\r
 360 \r
 361         u32Tmp  = (g_u32hiSec * 10UL);\r
 362         u32Tmp += g_u32loSec;\r
 363         sPt->u32Second = u32Tmp;\r
 364     }\r
 365 }\r
 366 \r
 367 /**\r
 368   * @brief      Update Current RTC Date and Time\r
 369   *\r
 370   * @param[in]  sPt     Specify the time property and current date and time. It includes:           \n\r
 371   *                     u32Year: Year value, range between 2000 ~ 2099.                             \n\r
 372   *                     u32Month: Month value, range between 1 ~ 12.                                \n\r
 373   *                     u32Day: Day value, range between 1 ~ 31.                                    \n\r
 374   *                     u32DayOfWeek: Day of the week. [RTC_SUNDAY / RTC_MONDAY / RTC_TUESDAY /\r
 375   *                                                     RTC_WEDNESDAY / RTC_THURSDAY / RTC_FRIDAY /\r
 376   *                                                     RTC_SATURDAY]                               \n\r
 377   *                     u32Hour: Hour value, range between 0 ~ 23.                                  \n\r
 378   *                     u32Minute: Minute value, range between 0 ~ 59.                              \n\r
 379   *                     u32Second: Second value, range between 0 ~ 59.                              \n\r
 380   *                     u32TimeScale: [RTC_CLOCK_12 / RTC_CLOCK_24]                                 \n\r
 381   *                     u8AmPm: [RTC_AM / RTC_PM]                                                   \n\r
 382   *\r
 383   * @return     None\r
 384   *\r
 385   * @details    This API is used to update current date and time to RTC.\r
 386   */\r
 387 void RTC_SetDateAndTime(S_RTC_TIME_DATA_T *sPt)\r
 388 {\r
 389     uint32_t u32RegCAL, u32RegTIME;\r
 390     RTC_T *pRTC;\r
 391 \r
 392     if((__PC()&NS_OFFSET) == NS_OFFSET)\r
 393     {\r
 394         pRTC = RTC_NS;\r
 395     }\r
 396     else\r
 397     {\r
 398         pRTC = RTC;\r
 399     }\r
 400 \r
 401     if(sPt == 0)\r
 402     {\r
 403         ; /* No RTC date/time data */\r
 404     }\r
 405     else\r
 406     {\r
 407         /*-----------------------------------------------------------------------------------------------------*/\r
 408         /* Set RTC 24/12 hour setting and Day of the Week                                                      */\r
 409         /*-----------------------------------------------------------------------------------------------------*/\r
 410         RTC_WaitAccessEnable();\r
 411         if(sPt->u32TimeScale == (uint32_t)RTC_CLOCK_12)\r
 412         {\r
 413             pRTC->CLKFMT &= ~RTC_CLKFMT_24HEN_Msk;\r
 414 \r
 415             /*-------------------------------------------------------------------------------------------------*/\r
 416             /* Important, range of 12-hour PM mode is 21 up to 32                                               */\r
 417             /*-------------------------------------------------------------------------------------------------*/\r
 418             if(sPt->u32AmPm == (uint32_t)RTC_PM)\r
 419             {\r
 420                 sPt->u32Hour += 20UL;\r
 421             }\r
 422         }\r
 423         else\r
 424         {\r
 425             pRTC->CLKFMT |= RTC_CLKFMT_24HEN_Msk;\r
 426         }\r
 427 \r
 428         /* Set Day of the Week */\r
 429         pRTC->WEEKDAY = sPt->u32DayOfWeek;\r
 430 \r
 431         /*-----------------------------------------------------------------------------------------------------*/\r
 432         /* Set RTC Current Date and Time                                                                       */\r
 433         /*-----------------------------------------------------------------------------------------------------*/\r
 434         u32RegCAL  = ((sPt->u32Year - (uint32_t)RTC_YEAR2000) / 10UL) << 20;\r
 435         u32RegCAL |= (((sPt->u32Year - (uint32_t)RTC_YEAR2000) % 10UL) << 16);\r
 436         u32RegCAL |= ((sPt->u32Month  / 10UL) << 12);\r
 437         u32RegCAL |= ((sPt->u32Month  % 10UL) << 8);\r
 438         u32RegCAL |= ((sPt->u32Day    / 10UL) << 4);\r
 439         u32RegCAL |= (sPt->u32Day     % 10UL);\r
 440 \r
 441         u32RegTIME  = ((sPt->u32Hour   / 10UL) << 20);\r
 442         u32RegTIME |= ((sPt->u32Hour   % 10UL) << 16);\r
 443         u32RegTIME |= ((sPt->u32Minute / 10UL) << 12);\r
 444         u32RegTIME |= ((sPt->u32Minute % 10UL) << 8);\r
 445         u32RegTIME |= ((sPt->u32Second / 10UL) << 4);\r
 446         u32RegTIME |= (sPt->u32Second % 10UL);\r
 447 \r
 448         /*-----------------------------------------------------------------------------------------------------*/\r
 449         /* Set RTC Calender and Time Loading                                                                   */\r
 450         /*-----------------------------------------------------------------------------------------------------*/\r
 451         RTC_WaitAccessEnable();\r
 452         pRTC->CAL  = (uint32_t)u32RegCAL;\r
 453         RTC_WaitAccessEnable();\r
 454         pRTC->TIME = (uint32_t)u32RegTIME;\r
 455     }\r
 456 }\r
 457 \r
 458 /**\r
 459   * @brief      Update RTC Alarm Date and Time\r
 460   *\r
 461   * @param[in]  sPt     Specify the time property and alarm date and time. It includes:             \n\r
 462   *                     u32Year: Year value, range between 2000 ~ 2099.                             \n\r
 463   *                     u32Month: Month value, range between 1 ~ 12.                                \n\r
 464   *                     u32Day: Day value, range between 1 ~ 31.                                    \n\r
 465   *                     u32DayOfWeek: Day of the week. [RTC_SUNDAY / RTC_MONDAY / RTC_TUESDAY /\r
 466   *                                                     RTC_WEDNESDAY / RTC_THURSDAY / RTC_FRIDAY /\r
 467   *                                                     RTC_SATURDAY]                               \n\r
 468   *                     u32Hour: Hour value, range between 0 ~ 23.                                  \n\r
 469   *                     u32Minute: Minute value, range between 0 ~ 59.                              \n\r
 470   *                     u32Second: Second value, range between 0 ~ 59.                              \n\r
 471   *                     u32TimeScale: [RTC_CLOCK_12 / RTC_CLOCK_24]                                 \n\r
 472   *                     u8AmPm: [RTC_AM / RTC_PM]                                                   \n\r
 473   *\r
 474   * @return     None\r
 475   *\r
 476   * @details    This API is used to update alarm date and time setting to RTC.\r
 477   */\r
 478 void RTC_SetAlarmDateAndTime(S_RTC_TIME_DATA_T *sPt)\r
 479 {\r
 480     uint32_t u32RegCALM, u32RegTALM;\r
 481     RTC_T *pRTC;\r
 482 \r
 483     if((__PC()&NS_OFFSET) == NS_OFFSET)\r
 484     {\r
 485         pRTC = RTC_NS;\r
 486     }\r
 487     else\r
 488     {\r
 489         pRTC = RTC;\r
 490     }\r
 491 \r
 492     if(sPt == 0)\r
 493     {\r
 494         ; /* No RTC date/time data */\r
 495     }\r
 496     else\r
 497     {\r
 498         /*-----------------------------------------------------------------------------------------------------*/\r
 499         /* Set RTC 24/12 hour setting and Day of the Week                                                      */\r
 500         /*-----------------------------------------------------------------------------------------------------*/\r
 501         RTC_WaitAccessEnable();\r
 502         if(sPt->u32TimeScale == (uint32_t)RTC_CLOCK_12)\r
 503         {\r
 504             pRTC->CLKFMT &= ~RTC_CLKFMT_24HEN_Msk;\r
 505 \r
 506             /*-------------------------------------------------------------------------------------------------*/\r
 507             /* Important, range of 12-hour PM mode is 21 up to 32                                               */\r
 508             /*-------------------------------------------------------------------------------------------------*/\r
 509             if(sPt->u32AmPm == (uint32_t)RTC_PM)\r
 510             {\r
 511                 sPt->u32Hour += 20UL;\r
 512             }\r
 513         }\r
 514         else\r
 515         {\r
 516             pRTC->CLKFMT |= RTC_CLKFMT_24HEN_Msk;\r
 517         }\r
 518 \r
 519         /*-----------------------------------------------------------------------------------------------------*/\r
 520         /* Set RTC Alarm Date and Time                                                                         */\r
 521         /*-----------------------------------------------------------------------------------------------------*/\r
 522         u32RegCALM  = ((sPt->u32Year - (uint32_t)RTC_YEAR2000) / 10UL) << 20;\r
 523         u32RegCALM |= (((sPt->u32Year - (uint32_t)RTC_YEAR2000) % 10UL) << 16);\r
 524         u32RegCALM |= ((sPt->u32Month  / 10UL) << 12);\r
 525         u32RegCALM |= ((sPt->u32Month  % 10UL) << 8);\r
 526         u32RegCALM |= ((sPt->u32Day    / 10UL) << 4);\r
 527         u32RegCALM |= (sPt->u32Day    % 10UL);\r
 528 \r
 529         u32RegTALM  = ((sPt->u32Hour   / 10UL) << 20);\r
 530         u32RegTALM |= ((sPt->u32Hour   % 10UL) << 16);\r
 531         u32RegTALM |= ((sPt->u32Minute / 10UL) << 12);\r
 532         u32RegTALM |= ((sPt->u32Minute % 10UL) << 8);\r
 533         u32RegTALM |= ((sPt->u32Second / 10UL) << 4);\r
 534         u32RegTALM |= (sPt->u32Second % 10UL);\r
 535 \r
 536         RTC_WaitAccessEnable();\r
 537         pRTC->CALM = (uint32_t)u32RegCALM;\r
 538         RTC_WaitAccessEnable();\r
 539         pRTC->TALM = (uint32_t)u32RegTALM;\r
 540     }\r
 541 }\r
 542 \r
 543 /**\r
 544   * @brief      Update RTC Current Date\r
 545   *\r
 546   * @param[in]  u32Year         The year calendar digit of current RTC setting.\r
 547   * @param[in]  u32Month        The month calendar digit of current RTC setting.\r
 548   * @param[in]  u32Day          The day calendar digit of current RTC setting.\r
 549   * @param[in]  u32DayOfWeek    The Day of the week. [RTC_SUNDAY / RTC_MONDAY / RTC_TUESDAY /\r
 550   *                                                   RTC_WEDNESDAY / RTC_THURSDAY / RTC_FRIDAY /\r
 551   *                                                   RTC_SATURDAY]\r
 552   *\r
 553   * @return     None\r
 554   *\r
 555   * @details    This API is used to update current date to RTC.\r
 556   */\r
 557 void RTC_SetDate(uint32_t u32Year, uint32_t u32Month, uint32_t u32Day, uint32_t u32DayOfWeek)\r
 558 {\r
 559     uint32_t u32RegCAL;\r
 560     RTC_T *pRTC;\r
 561 \r
 562     if((__PC()&NS_OFFSET) == NS_OFFSET)\r
 563     {\r
 564         pRTC = RTC_NS;\r
 565     }\r
 566     else\r
 567     {\r
 568         pRTC = RTC;\r
 569     }\r
 570 \r
 571     u32RegCAL  = ((u32Year - (uint32_t)RTC_YEAR2000) / 10UL) << 20;\r
 572     u32RegCAL |= (((u32Year - (uint32_t)RTC_YEAR2000) % 10UL) << 16);\r
 573     u32RegCAL |= ((u32Month / 10UL) << 12);\r
 574     u32RegCAL |= ((u32Month % 10UL) << 8);\r
 575     u32RegCAL |= ((u32Day   / 10UL) << 4);\r
 576     u32RegCAL |= (u32Day   % 10UL);\r
 577 \r
 578     RTC_WaitAccessEnable();\r
 579 \r
 580     /* Set Day of the Week */\r
 581     pRTC->WEEKDAY = u32DayOfWeek & RTC_WEEKDAY_WEEKDAY_Msk;\r
 582 \r
 583     /* Set RTC Calender Loading */\r
 584     RTC_WaitAccessEnable();\r
 585     pRTC->CAL = (uint32_t)u32RegCAL;\r
 586 }\r
 587 \r
 588 /**\r
 589   * @brief      Update RTC Current Time\r
 590   *\r
 591   * @param[in]  u32Hour         The hour time digit of current RTC setting.\r
 592   * @param[in]  u32Minute       The minute time digit of current RTC setting.\r
 593   * @param[in]  u32Second       The second time digit of current RTC setting.\r
 594   * @param[in]  u32TimeMode     The 24-Hour / 12-Hour Time Scale Selection. [RTC_CLOCK_12 / RTC_CLOCK_24]\r
 595   * @param[in]  u32AmPm         12-hour time scale with AM and PM indication. Only Time Scale select 12-hour used. [RTC_AM / RTC_PM]\r
 596   *\r
 597   * @return     None\r
 598   *\r
 599   * @details    This API is used to update current time to RTC.\r
 600   */\r
 601 void RTC_SetTime(uint32_t u32Hour, uint32_t u32Minute, uint32_t u32Second, uint32_t u32TimeMode, uint32_t u32AmPm)\r
 602 {\r
 603     uint32_t u32RegTIME;\r
 604     RTC_T *pRTC;\r
 605 \r
 606     if((__PC()&NS_OFFSET) == NS_OFFSET)\r
 607     {\r
 608         pRTC = RTC_NS;\r
 609     }\r
 610     else\r
 611     {\r
 612         pRTC = RTC;\r
 613     }\r
 614 \r
 615     /* Important, range of 12-hour PM mode is 21 up to 32 */\r
 616     if((u32TimeMode == (uint32_t)RTC_CLOCK_12) && (u32AmPm == (uint32_t)RTC_PM))\r
 617     {\r
 618         u32Hour += 20UL;\r
 619     }\r
 620 \r
 621     u32RegTIME  = ((u32Hour   / 10UL) << 20);\r
 622     u32RegTIME |= ((u32Hour   % 10UL) << 16);\r
 623     u32RegTIME |= ((u32Minute / 10UL) << 12);\r
 624     u32RegTIME |= ((u32Minute % 10UL) << 8);\r
 625     u32RegTIME |= ((u32Second / 10UL) << 4);\r
 626     u32RegTIME |= (u32Second % 10UL);\r
 627 \r
 628     /*-----------------------------------------------------------------------------------------------------*/\r
 629     /* Set RTC 24/12 hour setting and Day of the Week                                                      */\r
 630     /*-----------------------------------------------------------------------------------------------------*/\r
 631     RTC_WaitAccessEnable();\r
 632     if(u32TimeMode == (uint32_t)RTC_CLOCK_12)\r
 633     {\r
 634         pRTC->CLKFMT &= ~RTC_CLKFMT_24HEN_Msk;\r
 635     }\r
 636     else\r
 637     {\r
 638         pRTC->CLKFMT |= RTC_CLKFMT_24HEN_Msk;\r
 639     }\r
 640 \r
 641     RTC_WaitAccessEnable();\r
 642     pRTC->TIME = (uint32_t)u32RegTIME;\r
 643 }\r
 644 \r
 645 /**\r
 646   * @brief      Update RTC Alarm Date\r
 647   *\r
 648   * @param[in]  u32Year         The year calendar digit of RTC alarm setting.\r
 649   * @param[in]  u32Month        The month calendar digit of RTC alarm setting.\r
 650   * @param[in]  u32Day          The day calendar digit of RTC alarm setting.\r
 651   *\r
 652   * @return     None\r
 653   *\r
 654   * @details    This API is used to update alarm date setting to RTC.\r
 655   */\r
 656 void RTC_SetAlarmDate(uint32_t u32Year, uint32_t u32Month, uint32_t u32Day)\r
 657 {\r
 658     uint32_t u32RegCALM;\r
 659     RTC_T *pRTC;\r
 660 \r
 661     if((__PC()&NS_OFFSET) == NS_OFFSET)\r
 662     {\r
 663         pRTC = RTC_NS;\r
 664     }\r
 665     else\r
 666     {\r
 667         pRTC = RTC;\r
 668     }\r
 669 \r
 670     u32RegCALM  = ((u32Year - (uint32_t)RTC_YEAR2000) / 10UL) << 20;\r
 671     u32RegCALM |= (((u32Year - (uint32_t)RTC_YEAR2000) % 10UL) << 16);\r
 672     u32RegCALM |= ((u32Month / 10UL) << 12);\r
 673     u32RegCALM |= ((u32Month % 10UL) << 8);\r
 674     u32RegCALM |= ((u32Day   / 10UL) << 4);\r
 675     u32RegCALM |= (u32Day   % 10UL);\r
 676 \r
 677     RTC_WaitAccessEnable();\r
 678 \r
 679     /* Set RTC Alarm Date */\r
 680     pRTC->CALM = (uint32_t)u32RegCALM;\r
 681 }\r
 682 \r
 683 /**\r
 684   * @brief      Update RTC Alarm Time\r
 685   *\r
 686   * @param[in]  u32Hour         The hour time digit of RTC alarm setting.\r
 687   * @param[in]  u32Minute       The minute time digit of RTC alarm setting.\r
 688   * @param[in]  u32Second       The second time digit of RTC alarm setting.\r
 689   * @param[in]  u32TimeMode     The 24-Hour / 12-Hour Time Scale Selection. [RTC_CLOCK_12 / RTC_CLOCK_24]\r
 690   * @param[in]  u32AmPm         12-hour time scale with AM and PM indication. Only Time Scale select 12-hour used. [RTC_AM / RTC_PM]\r
 691   *\r
 692   * @return     None\r
 693   *\r
 694   * @details    This API is used to update alarm time setting to RTC.\r
 695   */\r
 696 void RTC_SetAlarmTime(uint32_t u32Hour, uint32_t u32Minute, uint32_t u32Second, uint32_t u32TimeMode, uint32_t u32AmPm)\r
 697 {\r
 698     uint32_t u32RegTALM;\r
 699     RTC_T *pRTC;\r
 700 \r
 701     if((__PC()&NS_OFFSET) == NS_OFFSET)\r
 702     {\r
 703         pRTC = RTC_NS;\r
 704     }\r
 705     else\r
 706     {\r
 707         pRTC = RTC;\r
 708     }\r
 709 \r
 710     /* Important, range of 12-hour PM mode is 21 up to 32 */\r
 711     if((u32TimeMode == (uint32_t)RTC_CLOCK_12) && (u32AmPm == (uint32_t)RTC_PM))\r
 712     {\r
 713         u32Hour += 20UL;\r
 714     }\r
 715 \r
 716     u32RegTALM  = ((u32Hour   / 10UL) << 20);\r
 717     u32RegTALM |= ((u32Hour   % 10UL) << 16);\r
 718     u32RegTALM |= ((u32Minute / 10UL) << 12);\r
 719     u32RegTALM |= ((u32Minute % 10UL) << 8);\r
 720     u32RegTALM |= ((u32Second / 10UL) << 4);\r
 721     u32RegTALM |= (u32Second % 10UL);\r
 722 \r
 723     /*-----------------------------------------------------------------------------------------------------*/\r
 724     /* Set RTC 24/12 hour setting and Day of the Week                                                      */\r
 725     /*-----------------------------------------------------------------------------------------------------*/\r
 726     RTC_WaitAccessEnable();\r
 727     if(u32TimeMode == (uint32_t)RTC_CLOCK_12)\r
 728     {\r
 729         pRTC->CLKFMT &= ~RTC_CLKFMT_24HEN_Msk;\r
 730     }\r
 731     else\r
 732     {\r
 733         pRTC->CLKFMT |= RTC_CLKFMT_24HEN_Msk;\r
 734     }\r
 735 \r
 736     /* Set RTC Alarm Time */\r
 737     RTC_WaitAccessEnable();\r
 738     pRTC->TALM = (uint32_t)u32RegTALM;\r
 739 }\r
 740 \r
 741 /**\r
 742   * @brief      Set RTC Alarm Date Mask Function\r
 743   *\r
 744   * @param[in]  u8IsTenYMsk     1: enable 10-Year digit alarm mask; 0: disabled.\r
 745   * @param[in]  u8IsYMsk        1: enable 1-Year digit alarm mask; 0: disabled.\r
 746   * @param[in]  u8IsTenMMsk     1: enable 10-Mon digit alarm mask; 0: disabled.\r
 747   * @param[in]  u8IsMMsk        1: enable 1-Mon digit alarm mask; 0: disabled.\r
 748   * @param[in]  u8IsTenDMsk     1: enable 10-Day digit alarm mask; 0: disabled.\r
 749   * @param[in]  u8IsDMsk        1: enable 1-Day digit alarm mask; 0: disabled.\r
 750   *\r
 751   * @return     None\r
 752   *\r
 753   * @details    This API is used to enable or disable RTC alarm date mask function.\r
 754   */\r
 755 void RTC_SetAlarmDateMask(uint8_t u8IsTenYMsk, uint8_t u8IsYMsk, uint8_t u8IsTenMMsk, uint8_t u8IsMMsk, uint8_t u8IsTenDMsk, uint8_t u8IsDMsk)\r
 756 {\r
 757     RTC_T *pRTC;\r
 758 \r
 759     if((__PC()&NS_OFFSET) == NS_OFFSET)\r
 760     {\r
 761         pRTC = RTC_NS;\r
 762     }\r
 763     else\r
 764     {\r
 765         pRTC = RTC;\r
 766     }\r
 767 \r
 768     RTC_WaitAccessEnable();\r
 769     pRTC->CAMSK = ((uint32_t)u8IsTenYMsk << RTC_CAMSK_MTENYEAR_Pos) |\r
 770                   ((uint32_t)u8IsYMsk    << RTC_CAMSK_MYEAR_Pos) |\r
 771                   ((uint32_t)u8IsTenMMsk << RTC_CAMSK_MTENMON_Pos) |\r
 772                   ((uint32_t)u8IsMMsk    << RTC_CAMSK_MMON_Pos) |\r
 773                   ((uint32_t)u8IsTenDMsk << RTC_CAMSK_MTENDAY_Pos) |\r
 774                   ((uint32_t)u8IsDMsk    << RTC_CAMSK_MDAY_Pos);\r
 775 }\r
 776 \r
 777 /**\r
 778   * @brief      Set RTC Alarm Time Mask Function\r
 779   *\r
 780   * @param[in]  u8IsTenHMsk     1: enable 10-Hour digit alarm mask; 0: disabled.\r
 781   * @param[in]  u8IsHMsk        1: enable 1-Hour digit alarm mask; 0: disabled.\r
 782   * @param[in]  u8IsTenMMsk     1: enable 10-Min digit alarm mask; 0: disabled.\r
 783   * @param[in]  u8IsMMsk        1: enable 1-Min digit alarm mask; 0: disabled.\r
 784   * @param[in]  u8IsTenSMsk     1: enable 10-Sec digit alarm mask; 0: disabled.\r
 785   * @param[in]  u8IsSMsk        1: enable 1-Sec digit alarm mask; 0: disabled.\r
 786   *\r
 787   * @return     None\r
 788   *\r
 789   * @details    This API is used to enable or disable RTC alarm time mask function.\r
 790   */\r
 791 void RTC_SetAlarmTimeMask(uint8_t u8IsTenHMsk, uint8_t u8IsHMsk, uint8_t u8IsTenMMsk, uint8_t u8IsMMsk, uint8_t u8IsTenSMsk, uint8_t u8IsSMsk)\r
 792 {\r
 793     RTC_T *pRTC;\r
 794 \r
 795     if((__PC()&NS_OFFSET) == NS_OFFSET)\r
 796     {\r
 797         pRTC = RTC_NS;\r
 798     }\r
 799     else\r
 800     {\r
 801         pRTC = RTC;\r
 802     }\r
 803 \r
 804     RTC_WaitAccessEnable();\r
 805     pRTC->TAMSK = ((uint32_t)u8IsTenHMsk << RTC_TAMSK_MTENHR_Pos) |\r
 806                   ((uint32_t)u8IsHMsk    << RTC_TAMSK_MHR_Pos) |\r
 807                   ((uint32_t)u8IsTenMMsk << RTC_TAMSK_MTENMIN_Pos) |\r
 808                   ((uint32_t)u8IsMMsk    << RTC_TAMSK_MMIN_Pos) |\r
 809                   ((uint32_t)u8IsTenSMsk << RTC_TAMSK_MTENSEC_Pos) |\r
 810                   ((uint32_t)u8IsSMsk    << RTC_TAMSK_MSEC_Pos);\r
 811 }\r
 812 \r
 813 /**\r
 814   * @brief      Get Day of the Week\r
 815   *\r
 816   * @param      None\r
 817   *\r
 818   * @retval     0   Sunday\r
 819   * @retval     1   Monday\r
 820   * @retval     2   Tuesday\r
 821   * @retval     3   Wednesday\r
 822   * @retval     4   Thursday\r
 823   * @retval     5   Friday\r
 824   * @retval     6   Saturday\r
 825   *\r
 826   * @details    This API is used to get day of the week of current RTC date.\r
 827   */\r
 828 uint32_t RTC_GetDayOfWeek(void)\r
 829 {\r
 830     RTC_T *pRTC;\r
 831 \r
 832     if((__PC()&NS_OFFSET) == NS_OFFSET)\r
 833     {\r
 834         pRTC = RTC_NS;\r
 835     }\r
 836     else\r
 837     {\r
 838         pRTC = RTC;\r
 839     }\r
 840 \r
 841     return (pRTC->WEEKDAY & RTC_WEEKDAY_WEEKDAY_Msk);\r
 842 }\r
 843 \r
 844 /**\r
 845   * @brief      Set RTC Tick Period Time\r
 846   *\r
 847   * @param[in]  u32TickSelection    It is used to set the RTC tick period time for Periodic Time Tick request. \n\r
 848   *                                 It consists of:\r
 849   *                                     - \ref RTC_TICK_1_SEC     : Time tick is 1 second\r
 850   *                                     - \ref RTC_TICK_1_2_SEC   : Time tick is 1/2 second\r
 851   *                                     - \ref RTC_TICK_1_4_SEC   : Time tick is 1/4 second\r
 852   *                                     - \ref RTC_TICK_1_8_SEC   : Time tick is 1/8 second\r
 853   *                                     - \ref RTC_TICK_1_16_SEC  : Time tick is 1/16 second\r
 854   *                                     - \ref RTC_TICK_1_32_SEC  : Time tick is 1/32 second\r
 855   *                                     - \ref RTC_TICK_1_64_SEC  : Time tick is 1/64 second\r
 856   *                                     - \ref RTC_TICK_1_128_SEC : Time tick is 1/128 second\r
 857   *\r
 858   * @return     None\r
 859   *\r
 860   * @details    This API is used to set RTC tick period time for each tick interrupt.\r
 861   */\r
 862 void RTC_SetTickPeriod(uint32_t u32TickSelection)\r
 863 {\r
 864     RTC_T *pRTC;\r
 865 \r
 866     if((__PC()&NS_OFFSET) == NS_OFFSET)\r
 867     {\r
 868         pRTC = RTC_NS;\r
 869     }\r
 870     else\r
 871     {\r
 872         pRTC = RTC;\r
 873     }\r
 874 \r
 875     RTC_WaitAccessEnable();\r
 876 \r
 877     pRTC->TICK = (pRTC->TICK & ~RTC_TICK_TICK_Msk) | u32TickSelection;\r
 878 }\r
 879 \r
 880 /**\r
 881   * @brief      Enable RTC Interrupt\r
 882   *\r
 883   * @param[in]  u32IntFlagMask      Specify the interrupt source. It consists of:\r
 884   *                                     - \ref RTC_INTEN_ALMIEN_Msk   : Alarm interrupt\r
 885   *                                     - \ref RTC_INTEN_TICKIEN_Msk  : Tick interrupt\r
 886   *                                     - \ref RTC_INTEN_TAMP0IEN_Msk : Tamper 0 Pin Event Detection interrupt\r
 887   *                                     - \ref RTC_INTEN_TAMP1IEN_Msk : Tamper 1 or Pair 0 Pin Event Detection interrupt\r
 888   *                                     - \ref RTC_INTEN_TAMP2IEN_Msk : Tamper 2 Pin Event Detection interrupt\r
 889   *                                     - \ref RTC_INTEN_TAMP3IEN_Msk : Tamper 3 or Pair 1 Pin Event Detection interrupt\r
 890   *                                     - \ref RTC_INTEN_TAMP4IEN_Msk : Tamper 4 Pin Event Detection interrupt\r
 891   *                                     - \ref RTC_INTEN_TAMP5IEN_Msk : Tamper 5 or Pair 2 Pin Event Detection interrupt\r
 892   *                                     - \ref RTC_INTEN_CLKFIEN_Msk  : LXT Clock Frequency Monitor Fail interrupt\r
 893   *                                     - \ref RTC_INTEN_CLKSPIEN_Msk : LXT Clock Frequency Monitor Stop interrupt\r
 894   *\r
 895   * @return     None\r
 896   *\r
 897   * @details    This API is used to enable the specify RTC interrupt function.\r
 898   */\r
 899 void RTC_EnableInt(uint32_t u32IntFlagMask)\r
 900 {\r
 901     RTC_T *pRTC;\r
 902 \r
 903     if((__PC()&NS_OFFSET) == NS_OFFSET)\r
 904     {\r
 905         pRTC = RTC_NS;\r
 906     }\r
 907     else\r
 908     {\r
 909         pRTC = RTC;\r
 910     }\r
 911 \r
 912     pRTC->INTEN |= u32IntFlagMask;\r
 913 }\r
 914 \r
 915 /**\r
 916   * @brief      Disable RTC Interrupt\r
 917   *\r
 918   * @param[in]  u32IntFlagMask      Specify the interrupt source. It consists of:\r
 919   *                                     - \ref RTC_INTEN_ALMIEN_Msk   : Alarm interrupt\r
 920   *                                     - \ref RTC_INTEN_TICKIEN_Msk  : Tick interrupt\r
 921   *                                     - \ref RTC_INTEN_TAMP0IEN_Msk : Tamper 0 Pin Event Detection interrupt\r
 922   *                                     - \ref RTC_INTEN_TAMP1IEN_Msk : Tamper 1 or Pair 0 Pin Event Detection interrupt\r
 923   *                                     - \ref RTC_INTEN_TAMP2IEN_Msk : Tamper 2 Pin Event Detection interrupt\r
 924   *                                     - \ref RTC_INTEN_TAMP3IEN_Msk : Tamper 3 or Pair 1 Pin Event Detection interrupt\r
 925   *                                     - \ref RTC_INTEN_TAMP4IEN_Msk : Tamper 4 Pin Event Detection interrupt\r
 926   *                                     - \ref RTC_INTEN_TAMP5IEN_Msk : Tamper 5 or Pair 2 Pin Event Detection interrupt\r
 927   *                                     - \ref RTC_INTEN_CLKFIEN_Msk  : LXT Clock Frequency Monitor Fail interrupt\r
 928   *                                     - \ref RTC_INTEN_CLKSPIEN_Msk : LXT Clock Frequency Monitor Stop interrupt\r
 929   *\r
 930   * @return     None\r
 931   *\r
 932   * @details    This API is used to disable the specify RTC interrupt function.\r
 933   */\r
 934 void RTC_DisableInt(uint32_t u32IntFlagMask)\r
 935 {\r
 936     RTC_T *pRTC;\r
 937 \r
 938     if((__PC()&NS_OFFSET) == NS_OFFSET)\r
 939     {\r
 940         pRTC = RTC_NS;\r
 941     }\r
 942     else\r
 943     {\r
 944         pRTC = RTC;\r
 945     }\r
 946 \r
 947     pRTC->INTEN  &= ~u32IntFlagMask;\r
 948     pRTC->INTSTS = u32IntFlagMask;\r
 949 }\r
 950 \r
 951 /**\r
 952   * @brief      Enable Spare Registers Access\r
 953   *\r
 954   * @param      None\r
 955   *\r
 956   * @return     None\r
 957   *\r
 958   * @details    This API is used to enable the spare registers 0~19 can be accessed.\r
 959   */\r
 960 void RTC_EnableSpareAccess(void)\r
 961 {\r
 962     RTC_T *pRTC;\r
 963 \r
 964     if((__PC()&NS_OFFSET) == NS_OFFSET)\r
 965     {\r
 966         pRTC = RTC_NS;\r
 967     }\r
 968     else\r
 969     {\r
 970         pRTC = RTC;\r
 971     }\r
 972 \r
 973     RTC_WaitAccessEnable();\r
 974 \r
 975     pRTC->SPRCTL |= RTC_SPRCTL_SPRRWEN_Msk;\r
 976 }\r
 977 \r
 978 /**\r
 979   * @brief      Disable Spare Register\r
 980   *\r
 981   * @param      None\r
 982   *\r
 983   * @return     None\r
 984   *\r
 985   * @details    This API is used to disable the spare register 0~19 cannot be accessed.\r
 986   */\r
 987 void RTC_DisableSpareRegister(void)\r
 988 {\r
 989     RTC_T *pRTC;\r
 990 \r
 991     if((__PC()&NS_OFFSET) == NS_OFFSET)\r
 992     {\r
 993         pRTC = RTC_NS;\r
 994     }\r
 995     else\r
 996     {\r
 997         pRTC = RTC;\r
 998     }\r
 999 \r
1000     RTC_WaitAccessEnable();\r
1001 \r
1002     pRTC->SPRCTL &= ~RTC_SPRCTL_SPRRWEN_Msk;\r
1003 }\r
1004 \r
1005 /**\r
1006   * @brief      Static Tamper Detect\r
1007   *\r
1008   * @param[in]  u32TamperSelect     Tamper pin select. Possible options are\r
1009   *                                 - \ref RTC_TAMPER5_SELECT\r
1010   *                                 - \ref RTC_TAMPER4_SELECT\r
1011   *                                 - \ref RTC_TAMPER3_SELECT\r
1012   *                                 - \ref RTC_TAMPER2_SELECT\r
1013   *                                 - \ref RTC_TAMPER1_SELECT\r
1014   *                                 - \ref RTC_TAMPER0_SELECT\r
1015   *\r
1016   * @param[in]  u32DetecLevel       Tamper pin detection level select. Possible options are\r
1017   *                                 - \ref RTC_TAMPER_HIGH_LEVEL_DETECT\r
1018   *                                 - \ref RTC_TAMPER_LOW_LEVEL_DETECT\r
1019   *\r
1020   * @param[in]  u32DebounceEn       Tamper pin de-bounce enable\r
1021   *                                 - \ref RTC_TAMPER_DEBOUNCE_ENABLE\r
1022   *                                 - \ref RTC_TAMPER_DEBOUNCE_DISABLE\r
1023   *\r
1024   * @return     None\r
1025   *\r
1026   * @details    This API is used to enable the tamper pin detect function with specify trigger condition.\r
1027   *             User need disable dynamic tamper function before use this API.\r
1028   */\r
1029 void RTC_StaticTamperEnable(uint32_t u32TamperSelect, uint32_t u32DetecLevel, uint32_t u32DebounceEn)\r
1030 {\r
1031     uint32_t i;\r
1032     uint32_t u32Reg;\r
1033     uint32_t u32TmpReg;\r
1034     RTC_T *pRTC;\r
1035 \r
1036     if((__PC()&NS_OFFSET) == NS_OFFSET)\r
1037     {\r
1038         pRTC = RTC_NS;\r
1039     }\r
1040     else\r
1041     {\r
1042         pRTC = RTC;\r
1043     }\r
1044 \r
1045     RTC_WaitAccessEnable();\r
1046     u32Reg = pRTC->TAMPCTL;\r
1047 \r
1048     u32TmpReg = (RTC_TAMPCTL_TAMP0EN_Msk | (u32DetecLevel << RTC_TAMPCTL_TAMP0LV_Pos) |\r
1049                  (u32DebounceEn << RTC_TAMPCTL_TAMP0DBEN_Pos));\r
1050 \r
1051     for(i = 0UL; i < (uint32_t)MAX_TAMPER_PIN_NUM; i++)\r
1052     {\r
1053         if(u32TamperSelect & (0x1UL << i))\r
1054         {\r
1055             u32Reg &= ~((RTC_TAMPCTL_TAMP0EN_Msk | RTC_TAMPCTL_TAMP0LV_Msk | RTC_TAMPCTL_TAMP0DBEN_Msk) << (i * 4UL));\r
1056             u32Reg |= (u32TmpReg << (i * 4UL));\r
1057         }\r
1058     }\r
1059 \r
1060     RTC_WaitAccessEnable();\r
1061     pRTC->TAMPCTL = u32Reg;\r
1062 \r
1063 }\r
1064 \r
1065 /**\r
1066   * @brief      Static Tamper Disable\r
1067   *\r
1068   * @param[in]  u32TamperSelect     Tamper pin select. Possible options are\r
1069   *                                 - \ref RTC_TAMPER5_SELECT\r
1070   *                                 - \ref RTC_TAMPER4_SELECT\r
1071   *                                 - \ref RTC_TAMPER3_SELECT\r
1072   *                                 - \ref RTC_TAMPER2_SELECT\r
1073   *                                 - \ref RTC_TAMPER1_SELECT\r
1074   *                                 - \ref RTC_TAMPER0_SELECT\r
1075   *\r
1076   * @return     None\r
1077   *\r
1078   * @details    This API is used to disable the static tamper pin detect.\r
1079   */\r
1080 void RTC_StaticTamperDisable(uint32_t u32TamperSelect)\r
1081 {\r
1082     uint32_t i;\r
1083     uint32_t u32Reg;\r
1084     uint32_t u32TmpReg;\r
1085     RTC_T *pRTC;\r
1086 \r
1087     if((__PC()&NS_OFFSET) == NS_OFFSET)\r
1088     {\r
1089         pRTC = RTC_NS;\r
1090     }\r
1091     else\r
1092     {\r
1093         pRTC = RTC;\r
1094     }\r
1095 \r
1096     RTC_WaitAccessEnable();\r
1097     u32Reg = pRTC->TAMPCTL;\r
1098 \r
1099     u32TmpReg = (RTC_TAMPCTL_TAMP0EN_Msk);\r
1100 \r
1101     for(i = 0UL; i < (uint32_t)MAX_TAMPER_PIN_NUM; i++)\r
1102     {\r
1103         if(u32TamperSelect & (0x1UL << i))\r
1104         {\r
1105             u32Reg &= ~(u32TmpReg << (i * 4UL));\r
1106         }\r
1107     }\r
1108 \r
1109     RTC_WaitAccessEnable();\r
1110     pRTC->TAMPCTL = u32Reg;\r
1111 }\r
1112 \r
1113 /**\r
1114   * @brief      Dynamic Tamper Detect\r
1115   *\r
1116   * @param[in]  u32PairSel          Tamper pin detection enable. Possible options are\r
1117   *                                 - \ref RTC_PAIR0_SELECT\r
1118   *                                 - \ref RTC_PAIR1_SELECT\r
1119   *                                 - \ref RTC_PAIR2_SELECT\r
1120   *\r
1121   * @param[in]  u32DebounceEn       Tamper pin de-bounce enable\r
1122   *                                 - \ref RTC_TAMPER_DEBOUNCE_ENABLE\r
1123   *                                 - \ref RTC_TAMPER_DEBOUNCE_DISABLE\r
1124   *\r
1125   *  @param[in]  u32Pair1Source     Dynamic Pair 1 Input Source Select\r
1126   *                                 0: Pair 1 source select tamper 2\r
1127   *                                 1: Pair 1 source select tamper 0\r
1128   *\r
1129   *  @param[in]  u32Pair2Source     Dynamic Pair 2 Input Source Select\r
1130   *                                 0: Pair 2 source select tamper 4\r
1131   *                                 1: Pair 2 source select tamper 0\r
1132   *\r
1133   * @return     None\r
1134   *\r
1135   * @details    This API is used to enable the dynamic tamper.\r
1136   */\r
1137 void RTC_DynamicTamperEnable(uint32_t u32PairSel, uint32_t u32DebounceEn, uint32_t u32Pair1Source, uint32_t u32Pair2Source)\r
1138 {\r
1139     uint32_t i;\r
1140     uint32_t u32Reg;\r
1141     uint32_t u32TmpReg;\r
1142     uint32_t u32Tamper2Debounce, u32Tamper4Debounce;\r
1143     RTC_T *pRTC;\r
1144 \r
1145     if((__PC()&NS_OFFSET) == NS_OFFSET)\r
1146     {\r
1147         pRTC = RTC_NS;\r
1148     }\r
1149     else\r
1150     {\r
1151         pRTC = RTC;\r
1152     }\r
1153 \r
1154     RTC_WaitAccessEnable();\r
1155     u32Reg = pRTC->TAMPCTL;\r
1156     u32Reg &= ~(RTC_TAMPCTL_TAMP0EN_Msk | RTC_TAMPCTL_TAMP1EN_Msk | RTC_TAMPCTL_TAMP2EN_Msk |\r
1157                 RTC_TAMPCTL_TAMP3EN_Msk | RTC_TAMPCTL_TAMP4EN_Msk | RTC_TAMPCTL_TAMP5EN_Msk);\r
1158 \r
1159     u32Tamper2Debounce = u32Reg & RTC_TAMPCTL_TAMP2DBEN_Msk;\r
1160     u32Tamper4Debounce = u32Reg & RTC_TAMPCTL_TAMP4DBEN_Msk;\r
1161 \r
1162     u32Reg &= ~(RTC_TAMPCTL_TAMP0EN_Msk | RTC_TAMPCTL_TAMP1EN_Msk | RTC_TAMPCTL_TAMP2EN_Msk |\r
1163                 RTC_TAMPCTL_TAMP3EN_Msk | RTC_TAMPCTL_TAMP4EN_Msk | RTC_TAMPCTL_TAMP5EN_Msk);\r
1164     u32Reg &= ~(RTC_TAMPCTL_DYN1ISS_Msk | RTC_TAMPCTL_DYN2ISS_Msk);\r
1165     u32Reg |= ((u32Pair1Source & 0x1UL) << RTC_TAMPCTL_DYN1ISS_Pos) | ((u32Pair2Source & 0x1UL) << RTC_TAMPCTL_DYN2ISS_Pos);\r
1166 \r
1167     if(u32DebounceEn)\r
1168     {\r
1169         u32TmpReg = (RTC_TAMPCTL_TAMP0EN_Msk | RTC_TAMPCTL_TAMP1EN_Msk |\r
1170                      RTC_TAMPCTL_TAMP0DBEN_Msk | RTC_TAMPCTL_TAMP1DBEN_Msk | RTC_TAMPCTL_DYNPR0EN_Msk);\r
1171     }\r
1172     else\r
1173     {\r
1174         u32TmpReg = (RTC_TAMPCTL_TAMP0EN_Msk | RTC_TAMPCTL_TAMP1EN_Msk | RTC_TAMPCTL_DYNPR0EN_Msk);\r
1175     }\r
1176 \r
1177     for(i = 0UL; i < (uint32_t)MAX_PAIR_NUM; i++)\r
1178     {\r
1179         if(u32PairSel & (0x1UL << i))\r
1180         {\r
1181             u32Reg &= ~((RTC_TAMPCTL_TAMP0DBEN_Msk | RTC_TAMPCTL_TAMP1DBEN_Msk) << (i * 8UL));\r
1182             u32Reg |= (u32TmpReg << (i * 8UL));\r
1183         }\r
1184     }\r
1185 \r
1186     if((u32Pair1Source) && (u32PairSel & (uint32_t)RTC_PAIR1_SELECT))\r
1187     {\r
1188         u32Reg &= ~RTC_TAMPCTL_TAMP2EN_Msk;\r
1189         u32Reg |= u32Tamper2Debounce;\r
1190     }\r
1191 \r
1192     if((u32Pair2Source) && (u32PairSel & (uint32_t)RTC_PAIR2_SELECT))\r
1193     {\r
1194         u32Reg &= ~RTC_TAMPCTL_TAMP4EN_Msk;\r
1195         u32Reg |= u32Tamper4Debounce;\r
1196     }\r
1197 \r
1198     RTC_WaitAccessEnable();\r
1199     pRTC->TAMPCTL = u32Reg;\r
1200 }\r
1201 \r
1202 /**\r
1203   * @brief      Dynamic Tamper Disable\r
1204   *\r
1205   * @param[in]  u32PairSel          Tamper pin detection enable. Possible options are\r
1206   *                                 - \ref RTC_PAIR0_SELECT\r
1207   *                                 - \ref RTC_PAIR1_SELECT\r
1208   *                                 - \ref RTC_PAIR2_SELECT\r
1209   *\r
1210   * @return     None\r
1211   *\r
1212   * @details    This API is used to disable the dynamic tamper.\r
1213   */\r
1214 void RTC_DynamicTamperDisable(uint32_t u32PairSel)\r
1215 {\r
1216     uint32_t i;\r
1217     uint32_t u32Reg;\r
1218     uint32_t u32TmpReg;\r
1219     uint32_t u32Tamper2En = 0UL, u32Tamper4En = 0UL;\r
1220     RTC_T *pRTC;\r
1221 \r
1222     if((__PC()&NS_OFFSET) == NS_OFFSET)\r
1223     {\r
1224         pRTC = RTC_NS;\r
1225     }\r
1226     else\r
1227     {\r
1228         pRTC = RTC;\r
1229     }\r
1230 \r
1231     RTC_WaitAccessEnable();\r
1232     u32Reg = pRTC->TAMPCTL;\r
1233 \r
1234     if((u32Reg & (uint32_t)RTC_TAMPCTL_DYN1ISS_Msk) && (u32PairSel & (uint32_t)RTC_PAIR1_SELECT))\r
1235     {\r
1236         u32Tamper2En = u32Reg & RTC_TAMPCTL_TAMP2EN_Msk;\r
1237     }\r
1238 \r
1239     if((u32Reg & (uint32_t)RTC_TAMPCTL_DYN2ISS_Msk) && (u32PairSel & (uint32_t)RTC_PAIR2_SELECT))\r
1240     {\r
1241         u32Tamper4En = u32Reg & RTC_TAMPCTL_TAMP4EN_Msk;\r
1242     }\r
1243 \r
1244     u32TmpReg = (RTC_TAMPCTL_TAMP0EN_Msk | RTC_TAMPCTL_TAMP1EN_Msk | RTC_TAMPCTL_DYNPR0EN_Msk);\r
1245 \r
1246     for(i = 0UL; i < (uint32_t)MAX_PAIR_NUM; i++)\r
1247     {\r
1248         if(u32PairSel & (0x1UL << i))\r
1249         {\r
1250             u32Reg &= ~(u32TmpReg << ((i * 8UL)));\r
1251         }\r
1252     }\r
1253 \r
1254     u32Reg |= (u32Tamper2En | u32Tamper4En);\r
1255 \r
1256     RTC_WaitAccessEnable();\r
1257     pRTC->TAMPCTL = u32Reg;\r
1258 }\r
1259 \r
1260 /**\r
1261   * @brief      Config dynamic tamper\r
1262   *\r
1263   * @param[in]  u32ChangeRate       The dynamic tamper output change rate\r
1264   *                                 - \ref RTC_2POW10_CLK\r
1265   *                                 - \ref RTC_2POW11_CLK\r
1266   *                                 - \ref RTC_2POW12_CLK\r
1267   *                                 - \ref RTC_2POW13_CLK\r
1268   *                                 - \ref RTC_2POW14_CLK\r
1269   *                                 - \ref RTC_2POW15_CLK\r
1270   *                                 - \ref RTC_2POW16_CLK\r
1271   *                                 - \ref RTC_2POW17_CLK\r
1272   *\r
1273   * @param[in]  u32SeedReload       Reload new seed or not\r
1274   *                                 0: not reload new seed\r
1275   *                                 1: reload new seed\r
1276   *\r
1277   * @param[in]  u32RefPattern       Reference pattern\r
1278   *                                 - \ref REF_RANDOM_PATTERN\r
1279   *                                 - \ref REF_PREVIOUS_PATTERN\r
1280   *                                 - \ref REF_SEED\r
1281   *\r
1282   * @param[in]  u32Seed             Seed Value (0x0 ~ 0xFFFFFFFF)\r
1283   *\r
1284   * @return     None\r
1285   *\r
1286   * @details    This API is used to config dynamic tamper setting.\r
1287   */\r
1288 void RTC_DynamicTamperConfig(uint32_t u32ChangeRate, uint32_t u32SeedReload, uint32_t u32RefPattern, uint32_t u32Seed)\r
1289 {\r
1290     uint32_t u32Reg;\r
1291     RTC_T *pRTC;\r
1292 \r
1293     if((__PC()&NS_OFFSET) == NS_OFFSET)\r
1294     {\r
1295         pRTC = RTC_NS;\r
1296     }\r
1297     else\r
1298     {\r
1299         pRTC = RTC;\r
1300     }\r
1301 \r
1302     RTC_WaitAccessEnable();\r
1303     u32Reg = pRTC->TAMPCTL;\r
1304 \r
1305     u32Reg &= ~(RTC_TAMPCTL_DYNSRC_Msk | RTC_TAMPCTL_SEEDRLD_Msk | RTC_TAMPCTL_DYNRATE_Msk);\r
1306 \r
1307     u32Reg |= (u32ChangeRate) | ((u32SeedReload & 0x1UL) << RTC_TAMPCTL_SEEDRLD_Pos) |\r
1308               ((u32RefPattern & 0x3UL) << RTC_TAMPCTL_DYNSRC_Pos);\r
1309 \r
1310     RTC_WaitAccessEnable();\r
1311     pRTC->TAMPSEED = u32Seed; /* need set seed value before re-loade seed */\r
1312     pRTC->TAMPCTL = u32Reg;\r
1313 }\r
1314 \r
1315 /*@}*/ /* end of group RTC_EXPORTED_FUNCTIONS */\r
1316 \r
1317 /*@}*/ /* end of group RTC_Driver */\r
1318 \r
1319 /*@}*/ /* end of group Standard_Driver */\r
1320 \r
1321 /*** (C) COPYRIGHT 2016 Nuvoton Technology Corp. ***/\r
1322 \r