libs/rt-thread-official
libs
/
rt-thread-official
mirror of https://github.com/RT-Thread/rt-thread.git
4
0
Fork 0
Code Issues Releases Wiki Activity
rt-thread-official/bsp/nuvoton/libraries/n9h30/Driver/Source/nu_rtc.c

1154 lines
31 KiB
C
Raw Blame History

/**************************************************************************//**
* @file RTC.c
* @brief N9H30 RTC driver source file
*
* @note
* SPDX-License-Identifier: Apache-2.0
* Copyright (C) 2018 Nuvoton Technology Corp. All rights reserved.
*****************************************************************************/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "N9H30.h"
#include "nu_sys.h"
#include "nu_rtc.h"
/** @addtogroup N9H30_Device_Driver N9H30 Device Driver
@{
*/
/** @addtogroup N9H30_RTC_Driver RTC Driver
@{
*/
/** @addtogroup N9H30_RTC_EXPORTED_FUNCTIONS RTC Exported Functions
@{
*/
/// @cond HIDDEN_SYMBOLS
static CHAR g_chHourMode = 0;
static BOOL volatile g_bIsEnableTickInt = FALSE;
static BOOL volatile g_bIsEnableAlarmInt = FALSE;
static UINT32 volatile g_u32Reg, g_u32Reg1, g_u32hiYear, g_u32loYear, g_u32hiMonth, g_u32loMonth, g_u32hiDay, g_u32loDay;
static UINT32 volatile g_u32hiHour, g_u32loHour, g_u32hiMin, g_u32loMin, g_u32hiSec, g_u32loSec;
UINT32 volatile i, Wait;
VOID RTC_Check(void)
{
i = 0;
Wait = inp32(REG_RTC_INTSTS) & RTC_INTSTS_REGWRBUSY_Msk;
while (Wait == RTC_INTSTS_REGWRBUSY_Msk)
{
Wait = inp32(REG_RTC_INTSTS) & RTC_INTSTS_REGWRBUSY_Msk;
i++;
if (i > RTC_WAIT_COUNT)
{
break;
}
}
}
/// @endcond HIDDEN_SYMBOLS
/**
* @brief Set 32k Frequency Compensation Data
*
* @param[in] i32FrequencyX100 Specify the RTC clock X100, ex: 3277365 means 32773.65.
*
* @return E_RTC_ERR_FCR_VALUE Wrong Compensation VALUE
* E_RTC_SUCCESS Success
*
* @details This API is used to compensate the 32 kHz frequency by current LXT frequency for RTC application.
*/
UINT32 RTC_DoFrequencyCompensation(INT32 i32FrequencyX100)
{
INT32 i32RegInt, i32RegFra;
UINT32 u32Reg;
/* Compute integer and fraction for RTC FCR register */
i32RegInt = (i32FrequencyX100 / 100) - RTC_FCR_REFERENCE;
i32RegFra = (((i32FrequencyX100 % 100)) * 60) / 100;
/* Judge Integer part is reasonable */
if ((i32RegInt < 0) | (i32RegInt > 15))
{
return E_RTC_ERR_FCR_VALUE;
}
u32Reg = (uint32_t)((i32RegInt << 8) | i32RegFra);
RTC_WriteEnable(1);
outp32(REG_RTC_FREQADJ, u32Reg);
RTC_Check();
return E_RTC_SUCCESS;
}
/**
* @brief RTC access register enable
*
* @param[in] bEnable 1: Enable access register
* 0: Disable access register
*
* @retval E_RTC_ERR_EIO Time-out error
* @retval E_RTC_SUCCESS Success
*
*/
UINT32 RTC_WriteEnable(BOOL bEnable)
{
INT32 volatile i32i;
RTC_Check();
if (bEnable)
{
outp32(REG_RTC_RWEN, RTC_WRITE_KEY);
RTC_Check();
for (i32i = 0 ; i32i < RTC_WAIT_COUNT ; i32i++)
{
/*-------------------------------------------------------------------------------------------------*/
/* check RTC_RWEN[16] to find out RTC write enable */
/*-------------------------------------------------------------------------------------------------*/
if (inp32(REG_RTC_RWEN) & 0x10000)
{
break;
}
}
if (i32i == RTC_WAIT_COUNT)
{
//sysprintf ("\nRTC: 3, set write enable FAILED!\n");
return E_RTC_ERR_EIO;
}
}
else
{
for (i32i = 0 ; i32i < RTC_WAIT_COUNT ; i32i++)
{
if (inp32(REG_RTC_RWEN) == 0)
{
break;
}
}
}
return E_RTC_SUCCESS;
}
/**
* @brief Initial RTC and install ISR
* @retval E_RTC_ERR_EIO Initial RTC time-out
* @retval E_RTC_SUCCESS Success
*
*/
UINT32 RTC_Init(void)
{
INT32 i32i;
/*-----------------------------------------------------------------------------------------------------*/
/* When RTC is power on, write 0xa5eb1357 to RTC_INIR to reset all logic. */
/*-----------------------------------------------------------------------------------------------------*/
outp32(REG_RTC_INIT, RTC_INIT_KEY);
RTC_Check();
for (i32i = 0 ; i32i < RTC_WAIT_COUNT ; i32i++)
{
if (inp32(REG_RTC_INIT) & 0x01)
{
/* Check RTC_INIR[0] to find out RTC reset signal */
break;
}
}
if (i32i == RTC_WAIT_COUNT)
{
return E_RTC_ERR_EIO;
}
/*-----------------------------------------------------------------------------------------------------*/
/* Install RTC ISR */
/*-----------------------------------------------------------------------------------------------------*/
outp32(REG_RTC_RWEN, RTC_WRITE_KEY);
RTC_Check();
for (i32i = 0 ; i32i < RTC_WAIT_COUNT ; i32i++)
{
/*-------------------------------------------------------------------------------------------------*/
/* check RTC_RWEN[16] to find out RTC write enable */
/*-------------------------------------------------------------------------------------------------*/
if (inp32(REG_RTC_RWEN) & 0x10000)
{
break;
}
}
if (i32i == RTC_WAIT_COUNT)
{
return E_RTC_ERR_EIO;
}
return E_RTC_SUCCESS;
}
/**
* @brief Set Current Timer
*
* @param[in] *sPt Specify the time property and current time. It includes:
* - u8cClockDisplay: \ref RTC_CLOCK_12 / \ref RTC_CLOCK_24
* - u8cAmPm: \ref RTC_AM / \ref RTC_PM
* - u32cSecond: Second value
* - u32cMinute: Minute value
* - u32cHour: Hour value
* - u32cDayOfWeek: Day of week
* - u32cDay: Day value
* - u32cMonth: Month value
* - u32Year: Year value
* - u32AlarmMaskSecond: Mask second alarm
* - u32AlarmMaskMinute: Mask minute alarm
* - u32AlarmMaskHour: Mask hour alarm
* - *pfnAlarmCallBack: Call back function
*
* @retval E_RTC_ERR_EIO Initial RTC time-out
* @retval E_RTC_SUCCESS Success
*
*/
UINT32 RTC_Open(S_RTC_TIME_DATA_T *sPt)
{
UINT32 volatile u32Reg;
/*-----------------------------------------------------------------------------------------------------*/
/* DO BASIC JUDGEMENT TO Check RTC time data value is reasonable or not. */
/*-----------------------------------------------------------------------------------------------------*/
if (((sPt->u32Year - RTC_YEAR2000) > 99) |
((sPt->u32cMonth == 0) || (sPt->u32cMonth > 12)) |
((sPt->u32cDay == 0) || (sPt->u32cDay > 31)))
{
return E_RTC_ERR_CALENDAR_VALUE;
}
if (sPt->u8cClockDisplay == RTC_CLOCK_12)
{
if ((sPt->u32cHour == 0) || (sPt->u32cHour > 12))
{
return E_RTC_ERR_TIMESACLE_VALUE ;
}
}
else if (sPt->u8cClockDisplay == RTC_CLOCK_24)
{
if (sPt->u32cHour > 23)
{
return E_RTC_ERR_TIMESACLE_VALUE ;
}
}
else
{
return E_RTC_ERR_TIMESACLE_VALUE ;
}
if ((sPt->u32cMinute > 59) |
(sPt->u32cSecond > 59) |
(sPt->u32cSecond > 59))
{
return E_RTC_ERR_TIME_VALUE ;
}
if (sPt->u32cDayOfWeek > 6)
{
return E_RTC_ERR_DWR_VALUE ;
}
/*-----------------------------------------------------------------------------------------------------*/
/* Second, set RTC time data. */
/*-----------------------------------------------------------------------------------------------------*/
if (sPt->u8cClockDisplay == RTC_CLOCK_12)
{
g_chHourMode = RTC_CLOCK_12;
RTC_WriteEnable(1);
outp32(REG_RTC_TIMEFMT, RTC_CLOCK_12);
RTC_Check();
/*-------------------------------------------------------------------------------------------------*/
/* important, range of 12-hour PM mode is 21 upto 32 */
/*-------------------------------------------------------------------------------------------------*/
if (sPt->u8cAmPm == RTC_PM)
sPt->u32cHour += 20;
}
else /* RTC_CLOCK_24 */
{
g_chHourMode = RTC_CLOCK_24;
RTC_WriteEnable(1);
outp32(REG_RTC_TIMEFMT, RTC_CLOCK_24);
RTC_Check();
}
g_u32hiHour = sPt->u32cHour / 10;
g_u32loHour = sPt->u32cHour % 10;
g_u32hiMin = sPt->u32cMinute / 10;
g_u32loMin = sPt->u32cMinute % 10;
g_u32hiSec = sPt->u32cSecond / 10;
g_u32loSec = sPt->u32cSecond % 10;
u32Reg = (g_u32hiHour << 20);
u32Reg |= (g_u32loHour << 16);
u32Reg |= (g_u32hiMin << 12);
u32Reg |= (g_u32loMin << 8);
u32Reg |= (g_u32hiSec << 4);
u32Reg |= g_u32loSec;
g_u32Reg = u32Reg;
RTC_WriteEnable(1);
outp32(REG_RTC_TIME, (UINT32)g_u32Reg);
RTC_Check();
if (sPt->u8cClockDisplay == RTC_CLOCK_12)
{
if (sPt->u8cAmPm == RTC_PM)
sPt->u32cHour -= 20;
}
g_u32hiYear = (sPt->u32Year - RTC_YEAR2000) / 10;
g_u32loYear = (sPt->u32Year - RTC_YEAR2000) % 10;
g_u32hiMonth = sPt->u32cMonth / 10;
g_u32loMonth = sPt->u32cMonth % 10;
g_u32hiDay = sPt->u32cDay / 10;
g_u32loDay = sPt->u32cDay % 10;
u32Reg = (g_u32hiYear << 20);
u32Reg |= (g_u32loYear << 16);
u32Reg |= (g_u32hiMonth << 12);
u32Reg |= (g_u32loMonth << 8);
u32Reg |= (g_u32hiDay << 4);
u32Reg |= g_u32loDay;
g_u32Reg = u32Reg;
RTC_WriteEnable(1);
outp32(REG_RTC_CAL, (UINT32)g_u32Reg);
RTC_Check();
RTC_WriteEnable(1);
outp32(REG_RTC_WEEKDAY, (UINT32)sPt->u32cDayOfWeek);
RTC_Check();
return E_RTC_SUCCESS;
}
/**
* @brief Read current date/time or alarm date/time from RTC
*
* @param[in] eTime \ref RTC_CURRENT_TIME / \ref RTC_ALARM_TIME
* @param[out] *sPt Specify the time property and current time. It includes:
* - u8cClockDisplay: \ref RTC_CLOCK_12 / \ref RTC_CLOCK_24
* - u8cAmPm: \ref RTC_AM / \ref RTC_PM
* - u32cSecond: Second value
* - u32cMinute: Minute value
* - u32cHour: Hour value
* - u32cDayOfWeek: Day of week
* - u32cDay: Day value
* - u32cMonth: Month value
* - u32Year: Year value
* - u32AlarmMaskSecond: Mask second alarm
* - u32AlarmMaskMinute: Mask minute alarm
* - u32AlarmMaskHour: Mask hour alarm
* - *pfnAlarmCallBack: Call back function
*
* @retval E_RTC_ERR_ENOTTY Wrong select time
* @retval E_RTC_SUCCESS Success
*
*/
UINT32 RTC_Read(E_RTC_TIME_SELECT eTime, S_RTC_TIME_DATA_T *sPt)
{
UINT32 u32Tmp;
sPt->u8cClockDisplay = inp32(REG_RTC_TIMEFMT); /* 12/24-hour */
sPt->u32cDayOfWeek = inp32(REG_RTC_WEEKDAY); /* Day of week */
switch (eTime)
{
case RTC_CURRENT_TIME:
{
g_u32Reg = inp32(REG_RTC_CAL);
g_u32Reg1 = inp32(REG_RTC_TIME);
break;
}
case RTC_ALARM_TIME:
{
g_u32Reg = inp32(REG_RTC_CALM);
g_u32Reg1 = inp32(REG_RTC_TALM);
break;
}
default:
{
return E_RTC_ERR_ENOTTY;
}
}
g_u32hiYear = (g_u32Reg & 0xF00000) >> 20;
g_u32loYear = (g_u32Reg & 0xF0000) >> 16;
g_u32hiMonth = (g_u32Reg & 0x1000) >> 12;
g_u32loMonth = (g_u32Reg & 0xF00) >> 8;
g_u32hiDay = (g_u32Reg & 0x30) >> 4;
g_u32loDay = g_u32Reg & 0xF;
u32Tmp = (g_u32hiYear * 10);
u32Tmp += g_u32loYear;
sPt->u32Year = u32Tmp + RTC_YEAR2000;
u32Tmp = (g_u32hiMonth * 10);
sPt->u32cMonth = u32Tmp + g_u32loMonth;
u32Tmp = (g_u32hiDay * 10);
sPt->u32cDay = u32Tmp + g_u32loDay;
g_u32hiHour = (g_u32Reg1 & 0x300000) >> 20;
g_u32loHour = (g_u32Reg1 & 0xF0000) >> 16;
g_u32hiMin = (g_u32Reg1 & 0x7000) >> 12;
g_u32loMin = (g_u32Reg1 & 0xF00) >> 8;
g_u32hiSec = (g_u32Reg1 & 0x70) >> 4;
g_u32loSec = g_u32Reg1 & 0xF;
if (sPt->u8cClockDisplay == RTC_CLOCK_12)
{
u32Tmp = (g_u32hiHour * 10);
u32Tmp += g_u32loHour;
sPt->u32cHour = u32Tmp; /* AM: 1~12. PM: 21~32. */
if (eTime == RTC_CURRENT_TIME)
{
if (sPt->u32cHour >= 21)
{
sPt->u8cAmPm = RTC_PM;
sPt->u32cHour -= 20;
}
else
{
sPt->u8cAmPm = RTC_AM;
}
}
else
{
if (sPt->u32cHour < 12)
{
if (sPt->u32cHour == 0)
sPt->u32cHour = 12;
sPt->u8cAmPm = RTC_AM;
}
else
{
sPt->u32cHour -= 12;
sPt->u8cAmPm = RTC_PM;
}
}
u32Tmp = (g_u32hiMin * 10);
u32Tmp += g_u32loMin;
sPt->u32cMinute = u32Tmp;
u32Tmp = (g_u32hiSec * 10);
u32Tmp += g_u32loSec;
sPt->u32cSecond = u32Tmp;
}
else
{
/* RTC_CLOCK_24 */
u32Tmp = (g_u32hiHour * 10);
u32Tmp += g_u32loHour;
sPt->u32cHour = u32Tmp;
u32Tmp = (g_u32hiMin * 10);
u32Tmp += g_u32loMin;
sPt->u32cMinute = u32Tmp;
u32Tmp = (g_u32hiSec * 10);
u32Tmp += g_u32loSec;
sPt->u32cSecond = u32Tmp;
}
return E_RTC_SUCCESS;
}
/**
* @brief Write current date/time or alarm date/time from RTC
*
* @param[in] eTime \ref RTC_CURRENT_TIME / \ref RTC_ALARM_TIME
* @param[in] *sPt Specify the time property and current time. It includes:
* - u8cClockDisplay: \ref RTC_CLOCK_12 / \ref RTC_CLOCK_24
* - u8cAmPm: \ref RTC_AM / \ref RTC_PM
* - u32cSecond: Second value
* - u32cMinute: Minute value
* - u32cHour: Hour value
* - u32cDayOfWeek: Day of week
* - u32cDay: Day value
* - u32cMonth: Month value
* - u32Year: Year value
* - u32AlarmMaskSecond: Mask second alarm
* - u32AlarmMaskMinute: Mask minute alarm
* - u32AlarmMaskHour: Mask hour alarm
* - *pfnAlarmCallBack: Call back function
*
* @retval E_RTC_ERR_ENOTTY Wrong select time
* @retval E_RTC_ERR_CALENDAR_VALUE Wrong calender value
* @retval E_RTC_ERR_TIME_VALUE Wrong time value
* @retval E_RTC_ERR_DWR_VALUE Wrong day of week value
* @retval E_RTC_SUCCESS Success
*
*/
UINT32 RTC_Write(E_RTC_TIME_SELECT eTime, S_RTC_TIME_DATA_T *sPt)
{
UINT32 u32Reg;
/*-----------------------------------------------------------------------------------------------------*/
/* Check RTC time data value is reasonable or not. */
/*-----------------------------------------------------------------------------------------------------*/
if (((sPt->u32Year - RTC_YEAR2000) > 99) |
((sPt->u32cMonth == 0) || (sPt->u32cMonth > 12)) |
((sPt->u32cDay == 0) || (sPt->u32cDay > 31)))
{
return E_RTC_ERR_CALENDAR_VALUE;
}
if ((sPt->u32Year - RTC_YEAR2000) > 99)
{
return E_RTC_ERR_CALENDAR_VALUE;
}
if ((sPt->u32cMonth == 0) || (sPt->u32cMonth > 12))
{
return E_RTC_ERR_CALENDAR_VALUE;
}
if ((sPt->u32cDay == 0) || (sPt->u32cDay > 31))
{
return E_RTC_ERR_CALENDAR_VALUE;
}
if (sPt->u8cClockDisplay == RTC_CLOCK_12)
{
if ((sPt->u32cHour == 0) || (sPt->u32cHour > 12))
{
return E_RTC_ERR_TIME_VALUE;
}
}
else if (sPt->u8cClockDisplay == RTC_CLOCK_24)
{
if (sPt->u32cHour > 23)
{
return E_RTC_ERR_TIME_VALUE;
}
}
else
{
return E_RTC_ERR_TIME_VALUE;
}
if (sPt->u32cMinute > 59)
{
return E_RTC_ERR_TIME_VALUE;
}
if (sPt->u32cSecond > 59)
{
return E_RTC_ERR_TIME_VALUE;
}
if (sPt->u32cDayOfWeek > 6)
{
return E_RTC_ERR_DWR_VALUE;
}
switch (eTime)
{
case RTC_CURRENT_TIME:
{
/*---------------------------------------------------------------------------------------------*/
/* Second, set RTC time data. */
/*---------------------------------------------------------------------------------------------*/
if (sPt->u8cClockDisplay == RTC_CLOCK_12)
{
g_chHourMode = RTC_CLOCK_12;
RTC_WriteEnable(1);
outp32(REG_RTC_TIMEFMT, RTC_CLOCK_12);
RTC_Check();
/*-----------------------------------------------------------------------------------------*/
/* important, range of 12-hour PM mode is 21 upto 32 */
/*-----------------------------------------------------------------------------------------*/
if (sPt->u8cAmPm == RTC_PM)
{
sPt->u32cHour += 20;
}
}
else /* RTC_CLOCK_24 */
{
g_chHourMode = RTC_CLOCK_24;
RTC_WriteEnable(1);
outp32(REG_RTC_TIMEFMT, RTC_CLOCK_24);
RTC_Check();
}
g_u32hiHour = sPt->u32cHour / 10;
g_u32loHour = sPt->u32cHour % 10;
g_u32hiMin = sPt->u32cMinute / 10;
g_u32loMin = sPt->u32cMinute % 10;
g_u32hiSec = sPt->u32cSecond / 10;
g_u32loSec = sPt->u32cSecond % 10;
u32Reg = (g_u32hiHour << 20);
u32Reg |= (g_u32loHour << 16);
u32Reg |= (g_u32hiMin << 12);
u32Reg |= (g_u32loMin << 8);
u32Reg |= (g_u32hiSec << 4);
u32Reg |= g_u32loSec;
g_u32Reg = u32Reg;
RTC_WriteEnable(1);
outp32(REG_RTC_TIME, (UINT32)g_u32Reg);
RTC_Check();
g_u32hiYear = (sPt->u32Year - RTC_YEAR2000) / 10;
g_u32loYear = (sPt->u32Year - RTC_YEAR2000) % 10;
g_u32hiMonth = sPt->u32cMonth / 10;
g_u32loMonth = sPt->u32cMonth % 10;
g_u32hiDay = sPt->u32cDay / 10;
g_u32loDay = sPt->u32cDay % 10;
u32Reg = (g_u32hiYear << 20);
u32Reg |= (g_u32loYear << 16);
u32Reg |= (g_u32hiMonth << 12);
u32Reg |= (g_u32loMonth << 8);
u32Reg |= (g_u32hiDay << 4);
u32Reg |= g_u32loDay;
g_u32Reg = u32Reg;
RTC_WriteEnable(1);
outp32(REG_RTC_CAL, (UINT32)g_u32Reg);
RTC_Check();
RTC_WriteEnable(1);
outp32(REG_RTC_WEEKDAY, (UINT32) sPt->u32cDayOfWeek);
RTC_Check();
if (sPt->u8cClockDisplay == RTC_CLOCK_12)
{
if (sPt->u8cAmPm == RTC_PM)
{
sPt->u32cHour -= 20;
}
}
return E_RTC_SUCCESS;
}
case RTC_ALARM_TIME:
{
RTC_WriteEnable(1);
outp32(REG_RTC_PWRCTL, inp32(REG_RTC_PWRCTL) & ~RTC_PWRCTL_ALARM_EN_Msk);
RTC_Check();
/*---------------------------------------------------------------------------------------------*/
/* Second, set alarm time data. */
/*---------------------------------------------------------------------------------------------*/
g_u32hiYear = (sPt->u32Year - RTC_YEAR2000) / 10;
g_u32loYear = (sPt->u32Year - RTC_YEAR2000) % 10;
g_u32hiMonth = sPt->u32cMonth / 10;
g_u32loMonth = sPt->u32cMonth % 10;
g_u32hiDay = sPt->u32cDay / 10;
g_u32loDay = sPt->u32cDay % 10;
//u32Reg = ((sPt->u32AlarmMaskDayOfWeek & 0x1) << 31);
u32Reg = ((sPt->u32cDayOfWeek & 0x7) << 24);
//u32Reg|= ((sPt->u32AlarmMaskYear & 0x1) << 30);
u32Reg |= (g_u32hiYear << 20);
u32Reg |= (g_u32loYear << 16);
//u32Reg|= ((sPt->u32AlarmMaskMonth & 0x1) << 29);
u32Reg |= (g_u32hiMonth << 12);
u32Reg |= (g_u32loMonth << 8);
//u32Reg|= ((sPt->u32AlarmMaskDay & 0x1) << 28);
u32Reg |= (g_u32hiDay << 4);
u32Reg |= g_u32loDay;
g_u32Reg = u32Reg;
RTC_WriteEnable(1);
outp32(REG_RTC_CALM, (UINT32)g_u32Reg);
RTC_Check();
if (g_chHourMode == RTC_CLOCK_12)
{
if (sPt->u8cAmPm == RTC_PM) /* important, range of 12-hour PM mode is 21 upto 32 */
{
sPt->u32cHour += 20;
}
}
g_u32hiHour = sPt->u32cHour / 10;
g_u32loHour = sPt->u32cHour % 10;
g_u32hiMin = sPt->u32cMinute / 10;
g_u32loMin = sPt->u32cMinute % 10;
g_u32hiSec = sPt->u32cSecond / 10;
g_u32loSec = sPt->u32cSecond % 10;
u32Reg = ((sPt->u32AlarmMaskHour & 0x1) << 30);
u32Reg |= (g_u32hiHour << 20);
u32Reg |= (g_u32loHour << 16);
u32Reg |= ((sPt->u32AlarmMaskMinute & 0x1) << 29);
u32Reg |= (g_u32hiMin << 12);
u32Reg |= (g_u32loMin << 8);
u32Reg |= ((sPt->u32AlarmMaskSecond & 0x1) << 28);
u32Reg |= (g_u32hiSec << 4);
u32Reg |= g_u32loSec;
g_u32Reg = u32Reg;
RTC_WriteEnable(1);
outp32(REG_RTC_TALM, (UINT32)g_u32Reg);
RTC_Check();
if (sPt->u8cClockDisplay == RTC_CLOCK_12)
{
if (sPt->u8cAmPm == RTC_PM)
{
sPt->u32cHour -= 20;
}
}
/*---------------------------------------------------------------------------------------------*/
/* Finally, enable alarm interrupt. */
/*---------------------------------------------------------------------------------------------*/
RTC_Ioctl(0, RTC_IOC_ENABLE_INT, RTC_ALARM_INT, 0);
RTC_WriteEnable(1);
outp32(REG_RTC_PWRCTL, inp32(REG_RTC_PWRCTL) | RTC_PWRCTL_ALARM_EN_Msk);
RTC_Check();
return E_RTC_SUCCESS;
}
default:
{
return E_RTC_ERR_ENOTTY;
}
}
}
/**
* @brief Support some commands for application.
*
* @param[in] i32Num Interface number. always set 0
* @param[in] eCmd Command
* @param[in] u32Arg0 Arguments for the command
* @param[in] u32Arg1 Arguments for the command.
*
* @retval E_RTC_ERR_ENOTTY Wrong command or argument
* @retval E_RTC_ERR_ENODEV Interface number incorrect
* @retval E_RTC_SUCCESS Success
*
*/
UINT32 RTC_Ioctl(INT32 i32Num, E_RTC_CMD eCmd, UINT32 u32Arg0, UINT32 u32Arg1)
{
INT32 i32Ret;
UINT32 u32Reg;
RTC_TICK_T *ptick;
UINT32 u32Tmp;
if (i32Num != 0)
return E_RTC_ERR_ENODEV;
switch (eCmd)
{
case RTC_IOC_IDENTIFY_LEAP_YEAR:
{
u32Reg = inp32(REG_RTC_LEAPYEAR);
if (u32Reg & 0x01)
{
*(PUINT32)u32Arg0 = RTC_LEAP_YEAR;
}
else
{
*(PUINT32)u32Arg0 = 0;
}
break;
}
case RTC_IOC_SET_TICK_MODE:
{
ptick = (RTC_TICK_T *) u32Arg0;
if (g_bIsEnableTickInt == TRUE)
{
RTC_Ioctl(0, RTC_IOC_DISABLE_INT, RTC_TICK_INT, 0);
g_bIsEnableTickInt = TRUE;
}
if (ptick->ucMode > RTC_TICK_1_128_SEC) /*Tick mode 0 to 7 */
{
return E_RTC_ERR_ENOTTY ;
}
RTC_WriteEnable(1);
outp32(REG_RTC_TICK, ptick->ucMode);
RTC_Check();
/*---------------------------------------------------------------------------------------------*/
/* Reset tick interrupt status if program enable tick interrupt before. */
/*---------------------------------------------------------------------------------------------*/
if (g_bIsEnableTickInt == TRUE)
{
RTC_Ioctl(0, RTC_IOC_ENABLE_INT, RTC_TICK_INT, 0);
return E_RTC_SUCCESS;
}
break;
}
case RTC_IOC_GET_TICK:
{
break;
}
case RTC_IOC_RESTORE_TICK:
{
break;
}
case RTC_IOC_ENABLE_INT:
{
switch ((RTC_INT_SOURCE)u32Arg0)
{
case RTC_TICK_INT:
{
g_bIsEnableTickInt = TRUE;
u32Tmp = inp32(REG_RTC_INTEN) | RTC_TICK_INT;
break;
}
case RTC_ALARM_INT:
{
g_bIsEnableAlarmInt = TRUE;
RTC_WriteEnable(1);
u32Tmp = inp32(REG_RTC_PWRCTL) | RTC_PWRCTL_ALARM_EN_Msk;
outp32(REG_RTC_PWRCTL, u32Tmp);
outp32(REG_RTC_INTEN, inp32(REG_RTC_INTEN) | RTC_INTEN_ALMIEN_Msk);
RTC_Check();
u32Tmp = inp32(REG_RTC_INTEN) | RTC_ALARM_INT;
break;
}
case RTC_RELATIVE_ALARM_INT:
{
g_bIsEnableAlarmInt = TRUE;
RTC_WriteEnable(1);
u32Tmp = inp32(REG_RTC_PWRCTL) | RTC_PWRCTL_REL_ALARM_EN_Msk;
outp32(REG_RTC_PWRCTL, u32Tmp);
RTC_Check();
u32Tmp = inp32(REG_RTC_INTEN) | RTC_RELATIVE_ALARM_INT;
break;
}
case RTC_PSWI_INT:
{
g_bIsEnableAlarmInt = TRUE;
u32Tmp = inp32(REG_RTC_INTEN) | RTC_PSWI_INT;
break;
}
default:
{
return E_RTC_ERR_ENOTTY;
}
}
RTC_WriteEnable(1);
outp32(REG_RTC_INTEN, u32Tmp);
RTC_Check();
break;
}
case RTC_IOC_DISABLE_INT:
{
switch ((RTC_INT_SOURCE)u32Arg0)
{
case RTC_TICK_INT:
{
g_bIsEnableTickInt = FALSE;
RTC_WriteEnable(1);
u32Tmp = inp32(REG_RTC_INTEN) & (~RTC_TICK_INT);
outp32(REG_RTC_INTEN, u32Tmp);
outp32(REG_RTC_INTSTS, RTC_TICK_INT);
RTC_Check();
break;
}
case RTC_ALARM_INT:
{
g_bIsEnableAlarmInt = FALSE;
RTC_WriteEnable(1);
u32Tmp = inp32(REG_RTC_INTEN) & (~RTC_ALARM_INT);
outp32(REG_RTC_INTEN, u32Tmp);
RTC_Check();
RTC_WriteEnable(1);
u32Tmp = inp32(REG_RTC_PWRCTL) & ~RTC_PWRCTL_ALARM_EN_Msk;
outp32(REG_RTC_PWRCTL, u32Tmp);
RTC_Check();
outp32(REG_RTC_INTSTS, RTC_ALARM_INT);
break;
}
case RTC_RELATIVE_ALARM_INT:
{
g_bIsEnableAlarmInt = FALSE;
RTC_WriteEnable(1);
u32Tmp = inp32(REG_RTC_INTEN) & (~RTC_RELATIVE_ALARM_INT);
outp32(REG_RTC_INTEN, u32Tmp);
RTC_Check();
RTC_WriteEnable(1);
u32Tmp = inp32(REG_RTC_PWRCTL) & ~RTC_PWRCTL_REL_ALARM_EN_Msk;
outp32(REG_RTC_PWRCTL, u32Tmp);
RTC_Check();
outp32(REG_RTC_INTSTS, RTC_RELATIVE_ALARM_INT);
break;
}
case RTC_PSWI_INT:
{
g_bIsEnableAlarmInt = FALSE;
RTC_WriteEnable(1);
u32Tmp = inp32(REG_RTC_INTEN) & (~RTC_PSWI_INT);
outp32(REG_RTC_INTEN, u32Tmp);
RTC_Check();
outp32(REG_RTC_INTSTS, RTC_PSWI_INT);
break;
}
case RTC_ALL_INT:
{
g_bIsEnableTickInt = FALSE;
g_bIsEnableAlarmInt = FALSE;
RTC_WriteEnable(1);
outp32(REG_RTC_INTEN, 0);
outp32(REG_RTC_INTSTS, RTC_ALL_INT);
RTC_Check();
break;
}
default:
{
return E_RTC_ERR_ENOTTY;
}
}
break;
}
case RTC_IOC_SET_FREQUENCY:
{
i32Ret = RTC_DoFrequencyCompensation(u32Arg0) ;
if (i32Ret != 0)
{
return E_RTC_ERR_ENOTTY;
}
break;
}
case RTC_IOC_SET_POWER_ON:
{
RTC_WriteEnable(1);
u32Tmp = inp32(REG_RTC_PWRCTL) | 0x01;
outp32(REG_RTC_PWRCTL, u32Tmp);
RTC_Check();
while ((inp32(REG_RTC_PWRCTL) & 0x01) != 0x1);
break;
}
case RTC_IOC_SET_POWER_OFF:
{
RTC_WriteEnable(1);
outp32(REG_RTC_PWRCTL, (inp32(REG_RTC_PWRCTL) & ~0x01) | 2);
RTC_Check();
while (1);
//break;
}
case RTC_IOC_SET_POWER_OFF_PERIOD:
{
if (u32Arg0 < 4) u32Arg0 = 4;
u32Arg0 = u32Arg0 - 4;
RTC_WriteEnable(1);
outp32(REG_RTC_PWRCTL, (inp32(REG_RTC_PWRCTL) & ~0xF000) | ((u32Arg0 & 0xF) << 12));
RTC_Check();
break;
}
case RTC_IOC_ENABLE_HW_POWEROFF:
{
RTC_WriteEnable(1);
outp32(REG_RTC_PWRCTL, (inp32(REG_RTC_PWRCTL) | 0x04));
RTC_Check();
break;
}
case RTC_IOC_DISABLE_HW_POWEROFF:
{
RTC_WriteEnable(1);
outp32(REG_RTC_PWRCTL, (inp32(REG_RTC_PWRCTL) & ~0x04));
RTC_Check();
break;
}
case RTC_IOC_SET_PSWI_CALLBACK:
{
RTC_Ioctl(0, RTC_IOC_ENABLE_INT, RTC_PSWI_INT, 0);
break;
}
case RTC_IOC_GET_POWERKEY_STATUS:
{
RTC_WriteEnable(1);
if (inp32(REG_RTC_PWRCTL) & 0x80)
*(PUINT32)u32Arg0 = 1;
else
*(PUINT32)u32Arg0 = 0;
break;
}
case RTC_IOC_SET_RELEATIVE_ALARM:
{
g_bIsEnableAlarmInt = TRUE;
RTC_WriteEnable(1);
outp32(REG_RTC_PWRCTL, (inp32(REG_RTC_PWRCTL) & ~0xFFF0010));
RTC_Check();
RTC_WriteEnable(1);
u32Tmp = (inp32(REG_RTC_PWRCTL) & ~0xFFF0000) | ((u32Arg0 & 0xFFF) << 16) | RTC_PWRCTL_REL_ALARM_EN_Msk;
outp32(REG_RTC_PWRCTL, u32Tmp);
RTC_Check();
g_bIsEnableAlarmInt = TRUE;
RTC_WriteEnable(1);
u32Tmp = inp32(REG_RTC_INTEN) | RTC_RELATIVE_ALARM_INT;
outp32(REG_RTC_INTEN, u32Tmp);
RTC_Check();
break;
}
default:
{
return E_RTC_ERR_ENOTTY;
}
}
return E_RTC_SUCCESS;
}
/**
* @brief Disable AIC channel of RTC and both tick and alarm interrupt.
*
* @param[in] None
*
* @retval E_RTC_SUCCESS Success
*
*/
UINT32 RTC_Close(void)
{
g_bIsEnableTickInt = FALSE;
sysDisableInterrupt(RTC_IRQn);
RTC_Ioctl(0, RTC_IOC_DISABLE_INT, RTC_ALL_INT, 0);
return E_RTC_SUCCESS;
}
/**
* @brief Enable RTC clock.
*
* @param[in] bEnable 1: Enable \n
* 2: Disable
*
* @return None
*
*/
void RTC_EnableClock(BOOL bEnable)
{
if (bEnable)
outp32(REG_CLK_PCLKEN0, inp32(REG_CLK_PCLKEN0) | (1 << 2));
else
outp32(REG_CLK_PCLKEN0, inp32(REG_CLK_PCLKEN0) & ~(1 << 2));
}
/*@}*/ /* end of group N9H30_RTC_EXPORTED_FUNCTIONS */
/*@}*/ /* end of group N9H30_RTC_Driver */
/*@}*/ /* end of group N9H30_Device_Driver */
/*** (C) COPYRIGHT 2018 Nuvoton Technology Corp. ***/
View Git Blame Copy Permalink