[Feature]Upload Modem source code
Change-Id: Id4294f30faced84d3e6fd6d5e61e1111bf287a37
diff --git a/mcu/driver/devdrv/rtc/inc/drv_rtc.h b/mcu/driver/devdrv/rtc/inc/drv_rtc.h
new file mode 100644
index 0000000..2bf6026
--- /dev/null
+++ b/mcu/driver/devdrv/rtc/inc/drv_rtc.h
@@ -0,0 +1,12 @@
+/******************************************************************
+
+ NOTICE : We have no HW for this IP now,
+ But for SW complie request, temporarily add the 'fake api' to make compile success.
+
+ *****************************************************************/
+
+#ifndef _DRV_RTC_H_
+#define _DRV_RTC_H_
+
+
+#endif /* _DRV_RTC_H_ */
diff --git a/mcu/driver/devdrv/rtc/src/dcl_rtc.c b/mcu/driver/devdrv/rtc/src/dcl_rtc.c
new file mode 100644
index 0000000..895b545
--- /dev/null
+++ b/mcu/driver/devdrv/rtc/src/dcl_rtc.c
@@ -0,0 +1,1084 @@
+/******************************************************************
+
+ NOTICE : We have no HW for this IP now,
+ But for SW complie request, temporarily add the 'fake api' to make compile success.
+
+ *****************************************************************/
+
+/*****************************************************************************
+* Copyright Statement:
+* --------------------
+* This software is protected by Copyright and the information contained
+* herein is confidential. The software may not be copied and the information
+* contained herein may not be used or disclosed except with the written
+* permission of MediaTek Inc. (C) 2005
+*
+* BY OPENING THIS FILE, BUYER HEREBY UNEQUIVOCALLY ACKNOWLEDGES AND AGREES
+* THAT THE SOFTWARE/FIRMWARE AND ITS DOCUMENTATIONS ("MEDIATEK SOFTWARE")
+* RECEIVED FROM MEDIATEK AND/OR ITS REPRESENTATIVES ARE PROVIDED TO BUYER ON
+* AN "AS-IS" BASIS ONLY. MEDIATEK EXPRESSLY DISCLAIMS ANY AND ALL WARRANTIES,
+* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED WARRANTIES OF
+* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE OR NONINFRINGEMENT.
+* NEITHER DOES MEDIATEK PROVIDE ANY WARRANTY WHATSOEVER WITH RESPECT TO THE
+* SOFTWARE OF ANY THIRD PARTY WHICH MAY BE USED BY, INCORPORATED IN, OR
+* SUPPLIED WITH THE MEDIATEK SOFTWARE, AND BUYER AGREES TO LOOK ONLY TO SUCH
+* THIRD PARTY FOR ANY WARRANTY CLAIM RELATING THERETO. MEDIATEK SHALL ALSO
+* NOT BE RESPONSIBLE FOR ANY MEDIATEK SOFTWARE RELEASES MADE TO BUYER'S
+* SPECIFICATION OR TO CONFORM TO A PARTICULAR STANDARD OR OPEN FORUM.
+*
+* BUYER'S SOLE AND EXCLUSIVE REMEDY AND MEDIATEK'S ENTIRE AND CUMULATIVE
+* LIABILITY WITH RESPECT TO THE MEDIATEK SOFTWARE RELEASED HEREUNDER WILL BE,
+* AT MEDIATEK'S OPTION, TO REVISE OR REPLACE THE MEDIATEK SOFTWARE AT ISSUE,
+* OR REFUND ANY SOFTWARE LICENSE FEES OR SERVICE CHARGE PAID BY BUYER TO
+* MEDIATEK FOR SUCH MEDIATEK SOFTWARE AT ISSUE.
+*
+* THE TRANSACTION CONTEMPLATED HEREUNDER SHALL BE CONSTRUED IN ACCORDANCE
+* WITH THE LAWS OF THE STATE OF CALIFORNIA, USA, EXCLUDING ITS CONFLICT OF
+* LAWS PRINCIPLES. ANY DISPUTES, CONTROVERSIES OR CLAIMS ARISING THEREOF AND
+* RELATED THERETO SHALL BE SETTLED BY ARBITRATION IN SAN FRANCISCO, CA, UNDER
+* THE RULES OF THE INTERNATIONAL CHAMBER OF COMMERCE (ICC).
+*
+*****************************************************************************/
+
+/*****************************************************************************
+ *
+ * Filename:
+ * ---------
+ * dcl_rtc.c
+ *
+ * Project:
+ * --------
+ * Maui_Software
+ *
+ * Description:
+ * ------------
+ * This Module defines DCL (Driver Common Layer) of the RTC driver.
+ *
+ * Author:
+ * -------
+ * -------
+ *
+ *============================================================================
+ * HISTORY
+ * Below this line, this part is controlled by PVCS VM. DO NOT MODIFY!!
+ *------------------------------------------------------------------------------
+ *
+ * removed!
+ *------------------------------------------------------------------------------
+ * Upper this line, this part is controlled by PVCS VM. DO NOT MODIFY!!
+ *============================================================================
+ ****************************************************************************/
+
+#include "drv_features.h"
+#include "drv_comm.h"
+#include "dcl.h"
+#include "kal_general_types.h"
+#include "kal_public_api.h"
+
+//
+// #include "rtc_sw_new.h"
+// #ifdef DCL_RTC_INTERFACE
+//
+// #if !defined(DRV_RTC_OFF)
+// // This API is exported by rtc.c
+// extern void RTC_TCintr(void);
+// extern void RTC_ALintr(void);
+// extern kal_bool RTC_FT_PowerOff(void);
+// extern void RTC_HW_Init_(void);
+// extern void RTC_reload(void);
+// #ifdef RTC_TEST
+// extern void RTC_delay(void);
+// #endif
+// extern kal_bool RTC_PWIC_Check_PowerOn(void);
+// extern void RTC_setBBPU(kal_uint16 data);
+// extern void RTC_PWIC_First_PowerOn_INIT_RTCTime(t_rtc *rtctime);
+// extern void RTC_PWIC_Mask_AL(void);
+// extern void RTC_PWIC_PowerOff_RTC_INIT(void);
+// extern void RTC_PWIC_PowerOn_RTC_INIT(void);
+//
+// #if defined(DRV_RTC_DBING)
+// extern void RTC_wait_debounce(void);
+// #endif //#if defined(DRV_RTC_DBING)
+// extern void RTC_start_cali(void);
+// extern rtc_callbac RTC_CALLBAC;
+//
+// // Global variable for DCL RTC API usage
+// #define DCL_RTC_DEV_MAGIC_NUM (0x40000000)
+// #define MAX_DCL_RTC_HANDLE 2
+// kal_uint32 dcl_rtc_handle_count = 0;
+//
+// // The event is presented by 32-bit variable
+// #define MAX_DCL_RTC_EVENT_NUM 32
+// PFN_DCL_CALLBACK dcl_rtc_event_callback[MAX_DCL_RTC_EVENT_NUM];
+//
+// /*************************************************************************
+// * Non-exported DCL internal functions
+// *************************************************************************/
+// void dcl_rtc_tc_intr_handler(void){
+// kal_uint32 event_bit;
+// kal_uint32 i;
+// // Search event callback entry
+// for (i=0;i<MAX_DCL_RTC_EVENT_NUM;i++){
+// event_bit = 1 << i;
+// if (event_bit == EVENT_RTC_TC){
+// if (dcl_rtc_event_callback[i] != NULL){
+// dcl_rtc_event_callback[i](EVENT_RTC_TC);
+// }
+// break;
+// }
+// }
+// }
+// void dcl_rtc_al_intr_handler(void){
+// kal_uint32 event_bit;
+// kal_uint32 i;
+// // Search event callback entry
+// for (i=0;i<MAX_DCL_RTC_EVENT_NUM;i++){
+// event_bit = 1 << i;
+// if (event_bit == EVENT_RTC_ALARM){
+// if (dcl_rtc_event_callback[i] != NULL){
+// dcl_rtc_event_callback[i](EVENT_RTC_ALARM);
+// }
+// break;
+// }
+// }
+// }
+//
+// /*************************************************************************
+// * Non-exported DCL internal functions
+// *************************************************************************/
+//
+//
+//
+// /*************************************************************************
+// * FUNCTION
+// * DclRTC_Initialize
+// *
+// * DESCRIPTION
+// * This function is to initialize RTC module
+// *
+// * PARAMETERS
+// * None
+// *
+// * RETURNS
+// * STATUS_OK
+// *
+// *************************************************************************/
+//
+//
+// DCL_STATUS DclRTC_Initialize(void){
+//
+// #if defined(DRV_RTC_HW_CALI)
+// RTC_HW_Init_();
+// #endif // #if defined(DRV_RTC_HW_CALI)
+//
+// #if !defined(__FUE__) && !defined(__UBL__)
+// RTC_init_(RTC_TCintr,RTC_ALintr);
+// #endif
+//
+// // Init event callback mapping array
+// {
+// kal_uint32 i;
+// for (i=0;i<MAX_DCL_RTC_EVENT_NUM;i++){
+// dcl_rtc_event_callback[i] = NULL;
+// }
+// }
+//
+// // Hack/Register to RTC driver callback
+// #if !defined(__FUE__) && !defined(__UBL__)
+// RTC_CALLBAC.rtc_tcfunc = dcl_rtc_tc_intr_handler;
+// RTC_CALLBAC.rtc_alfunc = dcl_rtc_al_intr_handler;
+// #endif
+//
+// dcl_rtc_handle_count = 0;
+//
+//
+// return STATUS_OK;
+//
+//
+//
+// }
+//
+// /*************************************************************************
+// * FUNCTION
+// * DclRTC_Open
+// *
+// * DESCRIPTION
+// * This function is to open the RTC module and return a handle
+// *
+// * PARAMETERS
+// * dev: only valid for DCL_RTC
+// * flags: no sepcial flags is needed. Please use FLAGS_NONE
+// *
+// * RETURNS
+// * DCL_HANDLE_INVALID: Open failed
+// * Other value: A valid handle
+// *
+// *************************************************************************/
+//
+// DCL_HANDLE DclRTC_Open(DCL_DEV dev, DCL_FLAGS flags)
+// {
+// kal_uint32 handle;
+// kal_uint32 savedMask;
+//
+// // Check device type
+// if (dev != DCL_RTC){
+// ASSERT(0);
+// return DCL_HANDLE_INVALID; // Incorrecr device ID
+// }
+//
+// // Check allowed open number
+// if (dcl_rtc_handle_count >= MAX_DCL_RTC_HANDLE){
+// ASSERT(0);
+// return DCL_HANDLE_INVALID; // Too many opened handles
+// }
+//
+// savedMask = SaveAndSetIRQMask();
+// // dcl_rtc_handle_count ++;
+// dcl_rtc_handle_count = 1;
+// handle = (DCL_RTC_DEV_MAGIC_NUM | dcl_rtc_handle_count);
+// RestoreIRQMask(savedMask);
+//
+// return handle;
+// }
+//
+// /*************************************************************************
+// * FUNCTION
+// * DclRTC_ReadData
+// *
+// * DESCRIPTION
+// * This function is not supported for the RTC module now.
+// *
+// * PARAMETERS
+// * N/A
+// *
+// * RETURNS
+// * STATUS_UNSUPPORTED
+// *
+// *************************************************************************/
+// DCL_STATUS DclRTC_ReadData(DCL_HANDLE handle, DCL_BUFF *buff, DCL_BUFF_LEN *buf_len, DCL_OPTIONS options){
+// return STATUS_UNSUPPORTED;
+// }
+//
+// /*************************************************************************
+// * FUNCTION
+// * DclRTC_WriteData
+// *
+// * DESCRIPTION
+// * This function is not supported for the RTC module now.
+// *
+// * PARAMETERS
+// * N/A
+// *
+// * RETURNS
+// * STATUS_UNSUPPORTED
+// *
+// *************************************************************************/
+// extern DCL_STATUS DclRTC_WriteData(DCL_HANDLE handle, DCL_BUFF *buff, DCL_BUFF_LEN *buf_len, DCL_OPTIONS options){
+// return STATUS_UNSUPPORTED;
+// }
+//
+// /*************************************************************************
+// * FUNCTION
+// * DclRTC_Configure
+// *
+// * DESCRIPTION
+// * This function is not supported for the RTC module now.
+// *
+// * PARAMETERS
+// * N/A
+// *
+// * RETURNS
+// * STATUS_UNSUPPORTED
+// *
+// *************************************************************************/
+// DCL_STATUS DclRTC_Configure(DCL_HANDLE handle, DCL_CONFIGURE_T *configure){
+// return STATUS_UNSUPPORTED;
+// }
+//
+// /*************************************************************************
+// * FUNCTION
+// * DclRTC_RegisterCallback
+// *
+// * DESCRIPTION
+// * This function is to set callback function for the RTC module.
+// *
+// * PARAMETERS
+// * handle: the returned handle value of DclRTC_Open
+// * event: Supported events:
+// * EVENT_RTC_ALARM: RTC alarm interrupt
+// * EVENT_RTC_TC: RTC tick interrupt
+// * callback: the callback function for registered events
+// *
+// * RETURNS
+// * STATUS_OK: Successfully register the callback function.
+// * STATUS_INVALID_DCL_HANDLE: It's a invalid handle.
+// * STATUS_NOT_OPENED: The module has not been opened.
+// * STATUS_INVALID_EVENT: The event parameter is invalid.
+// *
+// *************************************************************************/
+// DCL_STATUS DclRTC_RegisterCallback(DCL_HANDLE handle, DCL_EVENT event, PFN_DCL_CALLBACK callback){
+//
+// // Check magic number
+// if ((handle & DCL_RTC_DEV_MAGIC_NUM) != DCL_RTC_DEV_MAGIC_NUM){
+// ASSERT(0);
+// return STATUS_INVALID_DCL_HANDLE;
+// }
+//
+// // Error check
+// if (dcl_rtc_handle_count == 0){
+// ASSERT(0);
+// return STATUS_NOT_OPENED;
+// }
+// // Check if the passed-in event bitmap is supported or NOT
+// if (((kal_uint32)event & (~(EVENT_RTC_ALARM | EVENT_RTC_TC))) != 0){
+// ASSERT(0);
+// return STATUS_INVALID_EVENT;
+// }
+//
+// // Search mapping array and assign callback to specofic array entry
+// {
+// kal_uint32 i;
+// kal_uint32 event_bit;
+// for (i=0;i<MAX_DCL_RTC_EVENT_NUM;i++){
+// event_bit = 1 << i;
+// if ((event_bit & event) != 0){
+// // 1. Check if a callback has been registered for the event
+// // Allow multiple registration for now
+// //ASSERT(dcl_rtc_event_callback[i] != NULL);
+// // 2. Register the callback
+// dcl_rtc_event_callback[i] = callback;
+// }
+// }
+// }
+// return STATUS_OK;
+// }
+//
+//
+// /*************************************************************************
+// * FUNCTION
+// * DclRTC_Control
+// *
+// * DESCRIPTION
+// * This function is to send command to control the RTC module.
+// *
+// * PARAMETERS
+// * handle: The handle value returned from DclRTC_Open
+// * cmd: A control command for RTC module
+// * 1. RTC_CMD_BOOTLOADER_POWERON: to check RTC Power On in bootloader
+// * 2. RTC_CMD_CLEAR_PDN_BITS: to clear RTC PDN bits
+// * 3. RTC_CMD_CONFIG_AL_TC: to set alarm mask and tick mask
+// * 4. RTC_CMD_DELAY: to Delay 2000 counts
+// * 5. RTC_CMD_GET_ALARM_TIME: to get alarm time
+// * 6. RTC_CMD_GET_TIME: to get time
+// * 7. RTC_CMD_GPIO_GET_INPUT: to get RTC_GPIO_GPI register value
+// * 8. RTC_CMD_GPIO_SET_EXPORT_32K: to export 32.768KHz clock on RTC_GPIO
+// * 9. RTC_CMD_GPIO_SET_EXPORT_COREDETB: to export COREDETB on RTC_GPIO
+// * 10. RTC_CMD_GPIO_SET_INPUT_MODE: to set RTC_GPIO input mode
+// * 11. RTC_CMD_GPIO_SET_OUTPUT_MODE: to set RTC_GPIO output mode
+// * 12. RTC_CMD_HW_INIT: to initialize RTC hardware
+// * 13. RTC_CMD_INIT: to initialize RTC software
+// * 14. RTC_CMD_INIT_TC_AL_INTR: to initialize RTC TC & AL INTR
+// * 15. RTC_CMD_IS_CONFIG_VALID: to check if RTC time and Alarm are valid
+// * 16. RTC_CMD_IS_FIRST_ON: to check if device is first on
+// * 17. RTC_CMD_IS_MS_FIRSTPOWERON: to check whether RTC is first power on(for MMI)
+// * 18. RTC_CMD_IS_TIME_VALID: to check if time are valid
+// * 19. RTC_CMD_PWIC_CHECK_POWERON: to check if power on (for PWIC)
+// * 20. RTC_CMD_PWIC_FIRST_POWERON_INIT_RTCTIME: to init RTC time at first power on (for PWIC)
+// * 21. RTC_CMD_PWIC_MASK_AL: to control RTC Alarm mask (for PWIC)
+// * 22. RTC_CMD_PWIC_POWEROFF_RTC_INIT: to init RTC at power off (for PWIC)
+// * 23. RTC_CMD_PWIC_POWERON_RTC_INIT: to init RTC at power on (for PWIC)
+// * 24. RTC_CMD_READ_PDN_BITS: to read RTC PDN bits
+// * 25. RTC_CMD_READ_XOSC_REG: to read RTC XOSCCALI register
+// * 26. RTC_CMD_RELOAD: to load RTC whole register info from RTC module
+// * 27. RTC_CMD_SET_ALARM_TIME: to set alarm time
+// * 28. RTC_CMD_SET_FIRST_POWERON: to set first power on
+// * 29. RTC_CMD_SET_PDN_BITS: to set RTC PDN bits
+// * 30. RTC_CMD_SET_PWR_KEY: to set PWR KEY
+// * 31. RTC_CMD_SET_TIME: to set time
+// * 32. RTC_CMD_SETBBPU: to set RTC_BBPU
+// * 33. RTC_CMD_SETXOSC: to set RTC XOSCCALI register
+// * 34. RTC_CMD_START_CALI: to start calibration process
+// * 35. RTC_CMD_WAIT_DEBOUNCE: to wait until debounce bit becomes 0
+// * 36. RTC_CMD_WRITE_PDN_BITS: to write RTC PDN bits
+// * 37. RTC_CMD_WRITE_TRIGGER: to set write trigger
+// * 38. RTC_CMD_WRITE_TRIGGER_WAIT: to set write trigger and wait until BUSY bit becomes 0
+// * 39. RTC_CMD_WRITE_XOSC_REG: to write RTC XOSCCALI register
+// *
+// * data: The data of the control command
+// * 1. RTC_CMD_BOOTLOADER_POWERON: pointer to a RTC_CTRL_BOOTLOADER_POWERON_T structure
+// * 2. RTC_CMD_CLEAR_PDN_BITS: pointer to a RTC_CTRL_CONFIG_PDN_BIT_T structure
+// * 3. RTC_CMD_CONFIG_AL_TC: pointer to a RTC_CTRL_CONFIG_AL_TC_T structure
+// * 4. RTC_CMD_DELAY: A null pointer
+// * 5. RTC_CMD_GET_ALARM_TIME: pointer to a RTC_CTRL_GET_ALARM_TIME_T structure
+// * 6. RTC_CMD_GET_TIME: pointer to a RTC_CTRL_GET_TIME_T structure
+// * 7. RTC_CMD_GPIO_GET_INPUT: pointer to a RTC_CTRL_GPIO_TIME_T structure
+// * 8. RTC_CMD_GPIO_SET_EXPORT_32K: pointer to a RTC_CTRL_GPIO_TIME_T structure
+// * 9. RTC_CMD_GPIO_SET_EXPORT_COREDETB: pointer to a RTC_CTRL_GPIO_TIME_T structure
+// * 10. RTC_CMD_GPIO_SET_INPUT_MODE: pointer to a RTC_CTRL_GPIO_TIME_T structure
+// * 11. RTC_CMD_GPIO_SET_OUTPUT_MODE: pointer to a RTC_CTRL_GPIO_TIME_T structure
+// * 12. RTC_CMD_HW_INIT: A null pointer
+// * 13. RTC_CMD_INIT: pointer to a RTC_CTRL_INIT_T structure
+// * 14. RTC_CMD_INIT_TC_AL_INTR: A null pointer
+// * 15. RTC_CMD_IS_CONFIG_VALID: pointer to a RTC_CTRL_IS_CONFIG_VALID_T structure
+// * 16. RTC_CMD_IS_FIRST_ON: pointer to a RTC_CTRL_IS_FIRST_ON_T structure
+// * 17. RTC_CMD_IS_MS_FIRSTPOWERON: pointer to a RTC_CTRL_IS_MS_FIRSTPOWERON_T structure
+// * 18. RTC_CMD_IS_TIME_VALID: pointer to a RTC_CTRL_IS_TIME_VALID_T structure
+// * 19. RTC_CMD_PWIC_CHECK_POWERON: pointer to a RTC_CTRL_PWIC_CHECK_POWERON_T structure
+// * 20. RTC_CMD_PWIC_FIRST_POWERON_INIT_RTCTIME: pointer to a RTC_CTRL_PWIC_FIRST_POWERON_INIT_RTCTIME_T structure
+// * 21. RTC_CMD_PWIC_MASK_AL: A null pointer
+// * 22. RTC_CMD_PWIC_POWEROFF_RTC_INIT: A null pointer
+// * 23. RTC_CMD_PWIC_POWERON_RTC_INIT: A null pointer
+// * 24. RTC_CMD_READ_PDN_BITS: pointer to a RTC_CTRL_CONFIG_PDN_BIT_T structure
+// * 25. RTC_CMD_READ_XOSC_REG: pointer to a RTC_CTRL_READ_XOSC_REG_T structure
+// * 26. RTC_CMD_RELOAD: A null pointer
+// * 27. RTC_CMD_SET_ALARM_TIME: pointer to a RTC_CTRL_SET_ALARM_TIME_T structure
+// * 28. RTC_CMD_SET_FIRST_POWERON: pointer to a RTC_CTRL_SET_FIRST_POWERON_T structure
+// * 29. RTC_CMD_SET_PDN_BITS: pointer to a RTC_CTRL_CONFIG_PDN_BIT_T structure
+// * 30. RTC_CMD_SET_PWR_KEY: A null pointer
+// * 31. RTC_CMD_SET_TIME: pointer to a RTC_CTRL_SET_TIME_T structure
+// * 32. RTC_CMD_SETBBPU: pointer to a RTC_CTRL_SETBBPU_T structure
+// * 33. RTC_CMD_SETXOSC: A null pointer
+// * 34. RTC_CMD_START_CALI: A null pointer
+// * 35. RTC_CMD_WAIT_DEBOUNCE: A null pointer
+// * 36. RTC_CMD_WRITE_PDN_BITS: pointer to a RTC_CTRL_CONFIG_PDN_BIT_T structure
+// * 37. RTC_CMD_WRITE_TRIGGER: A null pointer
+// * 38. RTC_CMD_WRITE_TRIGGER_WAIT: A null pointer
+// * 39. RTC_CMD_WRITE_XOSC_REG: pointer to a RTC_CTRL_WRITE_XOSC_REG_T structure
+// *
+// * RETURNS
+// * STATUS_OK: command is executed successfully.
+// * STATUS_FAIL: command is failed.
+// * STATUS_INVALID_CMD: It's a invalid command.
+// *
+// *************************************************************************/
+// DCL_STATUS DclRTC_Control(DCL_HANDLE handle, DCL_CTRL_CMD cmd, DCL_CTRL_DATA_T *data)
+// {
+// DCL_STATUS return_status;
+//
+// // Check magic number
+// if ((handle & DCL_RTC_DEV_MAGIC_NUM) != DCL_RTC_DEV_MAGIC_NUM){
+// ASSERT(0);
+// return STATUS_INVALID_DCL_HANDLE;
+// }
+//
+// // Error check
+// if (dcl_rtc_handle_count == 0){
+// ASSERT(0);
+// return STATUS_NOT_OPENED;
+// }
+//
+// switch (cmd)
+// {
+// case RTC_CMD_BOOTLOADER_POWERON:
+// {
+// RTC_CTRL_BOOTLOADER_POWERON_T *prBootloaderPowerOn;
+// prBootloaderPowerOn = &(data->rBootloaderPowerOn);
+// prBootloaderPowerOn->fgBootloaderPowerOn = (DCL_BOOLEAN)RTC_Bootloader_PowerOn_();
+// return_status = STATUS_OK;
+// }
+// break;
+//
+// case RTC_CMD_CLEAR_PDN_BITS:
+// {
+// RTC_CTRL_CONFIG_PDN_BIT_T *prConfigPDNBit;
+// prConfigPDNBit = &(data->rConfigPDNBit);
+// RTC_Clear_PDN_bits((RTC_PDN_INDEX)prConfigPDNBit->PDNIndex, prConfigPDNBit->fgConfigBit);
+// return_status = STATUS_OK;
+// }
+// break;
+//
+// case RTC_CMD_CONFIG_AL_TC:
+// {
+// #if !defined(__FUE__) && !defined(__UBL__)
+// RTC_CTRL_CONFIG_AL_TC_T *prConfigALTC;
+// prConfigALTC = &(data->rConfigALTC);
+// RTC_Config_(prConfigALTC->u1ALEn, prConfigALTC->u1TCEn);
+// return_status = STATUS_OK;
+// #else
+// return_status = STATUS_UNSUPPORTED;
+// #endif
+// }
+// break;
+//
+// case RTC_CMD_DELAY:
+// {
+// #ifdef RTC_TEST
+// RTC_delay();
+// return_status = STATUS_OK;
+// #else
+// return_status = STATUS_UNSUPPORTED;
+// #endif
+// }
+// break;
+//
+// case RTC_CMD_FT_POWEROFF:
+// {
+// RTC_CTRL_FT_POWEROFF_T *prFTPowerOff;
+// prFTPowerOff = &(data->rFTPowerOff);
+// prFTPowerOff->fgMetaReset =(DCL_BOOLEAN)RTC_FT_PowerOff();
+// return_status = STATUS_OK;
+// }
+// break;
+//
+// case RTC_CMD_GET_ALARM_TIME:
+// {
+// t_rtc rtc;
+// RTC_CTRL_GET_ALARM_TIME_T *prGetAlarmTime;
+// prGetAlarmTime = &(data->rGetAlarmTime);
+// prGetAlarmTime->ALEnBit = (DCL_BOOLEAN)RTC_GetALTime(&rtc);
+//
+// prGetAlarmTime->u1Sec = rtc.rtc_sec;
+// prGetAlarmTime->u1Min = rtc.rtc_min;
+// prGetAlarmTime->u1Hour = rtc.rtc_hour;
+// prGetAlarmTime->u1Day = rtc.rtc_day;
+// prGetAlarmTime->u1Mon = rtc.rtc_mon;
+// prGetAlarmTime->u1WDay = rtc.rtc_wday;
+// prGetAlarmTime->u1Year = rtc.rtc_year;
+//
+// return_status = STATUS_OK;
+// }
+// break;
+//
+// case RTC_CMD_GET_TIME:
+// {
+// t_rtc rtc;
+// RTC_CTRL_GET_TIME_T *prGetTime;
+// prGetTime = &(data->rGetTime);
+// RTC_GetTime_(&rtc);
+//
+// prGetTime->u1Sec = rtc.rtc_sec;
+// prGetTime->u1Min = rtc.rtc_min;
+// prGetTime->u1Hour = rtc.rtc_hour;
+// prGetTime->u1Day = rtc.rtc_day;
+// prGetTime->u1Mon = rtc.rtc_mon;
+// prGetTime->u1WDay = rtc.rtc_wday;
+// prGetTime->u1Year = rtc.rtc_year;
+//
+// return_status = STATUS_OK;
+// }
+// break;
+//
+// #if defined(DRV_RTC_GPIO)
+// case RTC_CMD_GPIO_GET_INPUT:
+// {
+// RTC_CTRL_GPIO_TIME_T *prGPIO;
+// prGPIO = &(data->rGPIO);
+// prGPIO->InputValue = (DCL_BOOLEAN)RTC_Get_GPIO_Input();
+// return_status = STATUS_OK;
+// }
+// break;
+//
+// case RTC_CMD_GPIO_SET_EXPORT_32K:
+// {
+// RTC_Set_GPIO_Mode(RTC_GPIO_EXPORT_32K);
+// return_status = STATUS_OK;
+// }
+// break;
+//
+// case RTC_CMD_GPIO_SET_EXPORT_COREDETB:
+// {
+// RTC_Set_GPIO_Mode(RTC_GPIO_EXPORT_COREDETB);
+// return_status = STATUS_OK;
+// }
+// break;
+//
+// case RTC_CMD_GPIO_SET_INPUT_MODE:
+// {
+// RTC_CTRL_GPIO_TIME_T *prGPIO;
+// prGPIO = &(data->rGPIO);
+// RTC_Set_GPIO_Input_Mode((RTC_GPIO_PULL_TYPE_enum) prGPIO->rPullType,
+// (RTC_GPIO_DRIVING_STRENGTH_enum) prGPIO->rPullStrength,(kal_bool)prGPIO->is_SmithTrigger);
+// return_status = STATUS_OK;
+// }
+// break;
+//
+// case RTC_CMD_GPIO_SET_OUTPUT_MODE:
+// {
+// RTC_CTRL_GPIO_TIME_T *prGPIO;
+// prGPIO = &(data->rGPIO);
+// RTC_Set_GPIO_Output_Mode((kal_bool)prGPIO->OutputValue,(kal_bool)prGPIO->is_SlewRateControl);
+// return_status = STATUS_OK;
+// }
+// break;
+//
+// #endif //#if defined(DRV_RTC_GPIO)
+// case RTC_CMD_HW_INIT:
+// {
+// RTC_HW_Init_();
+// return_status = STATUS_OK;
+// }
+// break;
+//
+// case RTC_CMD_INIT:
+// {
+// #if !defined(__FUE__) && !defined(__UBL__)
+// RTC_CTRL_INIT_T *prInit;
+// prInit = &(data->rInit);
+// RTC_init_(prInit->RTC_TCCallback, prInit->RTC_ALCallback);
+// return_status = STATUS_OK;
+// #else
+// return_status = STATUS_UNSUPPORTED;
+// #endif
+// }
+// break;
+//
+// case RTC_CMD_INIT_TC_AL_INTR:
+// {
+// #if !defined(__FUE__) && !defined(__UBL__)
+// RTC_init_(RTC_TCintr,RTC_ALintr);
+// return_status = STATUS_OK;
+// #else
+// return_status = STATUS_UNSUPPORTED;
+// #endif
+// }
+// break;
+//
+// case RTC_CMD_IS_CONFIG_VALID:
+// {
+// RTC_CTRL_IS_CONFIG_VALID_T *prIsConfigValid;
+// prIsConfigValid = &(data->rIsConfigValid);
+// prIsConfigValid->fgIsValid = (DCL_BOOLEAN)RTC_is_config_valid();
+// return_status = STATUS_OK;
+// }
+// break;
+//
+// case RTC_CMD_IS_FIRST_ON:
+// {
+// RTC_CTRL_IS_FIRST_ON_T *prIsFirstOn;
+// prIsFirstOn = &(data->rIsFirstOn);
+// prIsFirstOn->fgFirstOn = (DCL_BOOLEAN)RTC_isFisrtOn();
+// return_status = STATUS_OK;
+// }
+// break;
+//
+// case RTC_CMD_IS_MS_FIRSTPOWERON:
+// {
+// #if !defined(__FUE__) && !defined(__UBL__)
+// RTC_CTRL_IS_MS_FIRSTPOWERON_T *prIsMSFirstPowerOn;
+// prIsMSFirstPowerOn = &(data->rIsMSFirstPowerOn);
+// prIsMSFirstPowerOn->fgMSFirstPowerOn = (DCL_BOOLEAN)RTC_is_MS_FirstPowerOn_();
+// return_status = STATUS_OK;
+// #else
+// return_status = STATUS_UNSUPPORTED;
+// #endif
+// }
+// break;
+//
+// case RTC_CMD_IS_TIME_VALID:
+// {
+// t_rtc rtc;
+// RTC_CTRL_IS_TIME_VALID_T *prIsTimeValid;
+// prIsTimeValid = &(data->rIsTimeValid);
+//
+// rtc.rtc_sec = prIsTimeValid->u1Sec;
+// rtc.rtc_min = prIsTimeValid->u1Min;
+// rtc.rtc_hour = prIsTimeValid->u1Hour;
+// rtc.rtc_day = prIsTimeValid->u1Day;
+// rtc.rtc_mon = prIsTimeValid->u1Mon;
+// rtc.rtc_wday = prIsTimeValid->u1WDay;
+// rtc.rtc_year = prIsTimeValid->u1Year;
+//
+// prIsTimeValid->isTimeValid = (DCL_BOOLEAN)RTC_is_Time_Valid(&rtc);
+//
+// return_status = STATUS_OK;
+// }
+// break;
+//
+// case RTC_CMD_PWIC_CHECK_POWERON:
+// {
+// RTC_CTRL_PWIC_CHECK_POWERON_T *prPwicCheckPowerOn;
+// prPwicCheckPowerOn = &(data->rPwicCheckPowerOn);
+// prPwicCheckPowerOn->fgIsPowerOn = (DCL_BOOLEAN)RTC_PWIC_Check_PowerOn();
+// return_status = STATUS_OK;
+// }
+// break;
+//
+// case RTC_CMD_PWIC_FIRST_POWERON_INIT_RTCTIME:
+// {
+// t_rtc rtc;
+// RTC_CTRL_PWIC_FIRST_POWERON_INIT_RTCTIME_T *prPwicFirstPowerOnInitRTCTime;
+// prPwicFirstPowerOnInitRTCTime = &(data->rPwicFirstPowerOnInitRTCTime);
+//
+// rtc.rtc_sec = prPwicFirstPowerOnInitRTCTime->u1Sec;
+// rtc.rtc_min = prPwicFirstPowerOnInitRTCTime->u1Min;
+// rtc.rtc_hour = prPwicFirstPowerOnInitRTCTime->u1Hour;
+// rtc.rtc_day = prPwicFirstPowerOnInitRTCTime->u1Day;
+// rtc.rtc_mon = prPwicFirstPowerOnInitRTCTime->u1Mon;
+// rtc.rtc_wday = prPwicFirstPowerOnInitRTCTime->u1WDay;
+// rtc.rtc_year = prPwicFirstPowerOnInitRTCTime->u1Year;
+//
+// RTC_PWIC_First_PowerOn_INIT_RTCTime(&rtc);
+//
+// return_status = STATUS_OK;
+// }
+// break;
+//
+// case RTC_CMD_PWIC_MASK_AL:
+// {
+// RTC_PWIC_Mask_AL();
+// return_status = STATUS_OK;
+// }
+// break;
+//
+// case RTC_CMD_PWIC_POWEROFF_RTC_INIT:
+// {
+// RTC_PWIC_PowerOff_RTC_INIT();
+// return_status = STATUS_OK;
+// }
+// break;
+//
+// case RTC_CMD_PWIC_POWERON_RTC_INIT:
+// {
+// RTC_PWIC_PowerOn_RTC_INIT();
+// return_status = STATUS_OK;
+// }
+// break;
+//
+// case RTC_CMD_READ_PDN_BITS:
+// {
+// RTC_CTRL_CONFIG_PDN_BIT_T *prConfigPDNBit;
+// prConfigPDNBit = &(data->rConfigPDNBit);
+// prConfigPDNBit->PDNValue = RTC_Read_PDN((RTC_PDN_INDEX)prConfigPDNBit->PDNIndex);
+// return_status = STATUS_OK;
+// }
+// break;
+//
+// case RTC_CMD_READ_SPAR:
+// {
+// #if defined(DRV_RTC_REG_SPAR)
+// RTC_CTRL_CONFIG_SPAR_T *prConfigSPARReg;
+// prConfigSPARReg = &(data->rConfigSPARReg);
+// prConfigSPARReg->ReadValue = RTC_Read_SPAR((RTC_SPAR_INDEX)prConfigSPARReg->SPARIndex);
+// return_status = STATUS_OK;
+// #else
+// return_status = STATUS_UNSUPPORTED;
+// #endif // #if defined(DRV_RTC_REG_SPAR)
+// }
+// break;
+//
+// case RTC_CMD_READ_XOSC_REG:
+// {
+// RTC_CTRL_READ_XOSC_REG_T *prReadXOSCReg;
+// prReadXOSCReg = &(data->rReadXOSCReg);
+// prReadXOSCReg->XOSCValue = RTC_read_xosc_reg();
+// return_status = STATUS_OK;
+// }
+// break;
+//
+// case RTC_CMD_RELOAD:
+// {
+// #if defined(DRV_RTC_HW_CALI)
+// RTC_reload();
+// return_status = STATUS_OK;
+// #else
+// return_status = STATUS_UNSUPPORTED;
+// #endif // #if defined(DRV_RTC_HW_CALI)
+// }
+// break;
+//
+// case RTC_CMD_SET_ALARM_TIME:
+// {
+// t_rtc rtc;
+// RTC_CTRL_SET_ALARM_TIME_T *prSetAlarmTime;
+// prSetAlarmTime = &(data->rSetAlarmTime);
+//
+// rtc.rtc_sec = prSetAlarmTime->u1Sec;
+// rtc.rtc_min = prSetAlarmTime->u1Min;
+// rtc.rtc_hour = prSetAlarmTime->u1Hour;
+// rtc.rtc_day = prSetAlarmTime->u1Day;
+// rtc.rtc_mon = prSetAlarmTime->u1Mon;
+// rtc.rtc_wday = prSetAlarmTime->u1WDay;
+// rtc.rtc_year = prSetAlarmTime->u1Year;
+//
+// RTC_SetAlarm(&rtc);
+// return_status = STATUS_OK;
+// }
+// break;
+//
+// case RTC_CMD_SET_FIRST_POWERON:
+// {
+// #if !defined(__FUE__) && !defined(__UBL__)
+// RTC_CTRL_SET_FIRST_POWERON_T *prSetFirstPowerOn;
+// prSetFirstPowerOn = &(data->rSetFirstPowerOn);
+// RTC_set_First_PowerOn((kal_bool)prSetFirstPowerOn->fgPowerOn);
+// return_status = STATUS_OK;
+// #else
+// return_status = STATUS_UNSUPPORTED;
+// #endif
+// }
+// break;
+//
+// case RTC_CMD_SET_PDN_BITS:
+// {
+// RTC_CTRL_CONFIG_PDN_BIT_T *prConfigPDNBit;
+// prConfigPDNBit = &(data->rConfigPDNBit);
+// RTC_Set_PDN_bits((RTC_PDN_INDEX)prConfigPDNBit->PDNIndex, prConfigPDNBit->fgConfigBit);
+// return_status = STATUS_OK;
+// }
+// break;
+//
+// case RTC_CMD_SET_PWR_KEY:
+// {
+// RTC_setPWRKey();
+// return_status = STATUS_OK;
+// }
+// break;
+//
+// case RTC_CMD_SET_TIME:
+// {
+// t_rtc rtc;
+// RTC_CTRL_SET_TIME_T *prSetTime;
+// prSetTime = &(data->rSetTime);
+//
+// rtc.rtc_sec = prSetTime->u1Sec;
+// rtc.rtc_min = prSetTime->u1Min;
+// rtc.rtc_hour = prSetTime->u1Hour;
+// rtc.rtc_day = prSetTime->u1Day;
+// rtc.rtc_mon = prSetTime->u1Mon;
+// rtc.rtc_wday = prSetTime->u1WDay;
+// rtc.rtc_year = prSetTime->u1Year;
+//
+// RTC_InitTC_Time(&rtc);
+// return_status = STATUS_OK;
+// }
+// break;
+//
+// case RTC_CMD_SETBBPU:
+// {
+// #ifdef RTC_Test
+// RTC_CTRL_SETBBPU_T *prSetBBPU;
+// prSetBBPU = &(data->rSetBBPU);
+// RTC_setBBPU(prSetBBPU->BBPUReg);
+// return_status = STATUS_OK;
+// #else
+// return_status = STATUS_UNSUPPORTED;
+// #endif
+// }
+// break;
+//
+// case RTC_CMD_SETXOSC:
+// {
+// RTC_setXOSC_();
+// return_status = STATUS_OK;
+// }
+// break;
+//
+// case RTC_CMD_START_CALI:
+// {
+// #if !defined(__FUE__) && !defined(__UBL__)
+// RTC_start_cali();
+// return_status = STATUS_OK;
+// #else
+// return_status = STATUS_UNSUPPORTED;
+// #endif
+// }
+// break;
+//
+// case RTC_CMD_WAIT_DEBOUNCE:
+// {
+// #if defined(DRV_RTC_DBING)
+// RTC_wait_debounce();
+// return_status = STATUS_OK;
+// #else
+// return_status = STATUS_UNSUPPORTED;
+// #endif // #if defined(DRV_RTC_DBING)
+// }
+// break;
+//
+// case RTC_CMD_WRITE_PDN_BITS:
+// {
+// RTC_CTRL_CONFIG_PDN_BIT_T *prConfigPDNBit;
+// prConfigPDNBit = &(data->rConfigPDNBit);
+// RTC_Write_PDN_bits((RTC_PDN_INDEX)prConfigPDNBit->PDNIndex, prConfigPDNBit->fgConfigBit);
+// return_status = STATUS_OK;
+// }
+// break;
+//
+// case RTC_CMD_WRITE_TRIGGER:
+// {
+// #if defined(DRV_RTC_HW_CALI)
+// RTC_write_trigger();
+// return_status = STATUS_OK;
+// #else
+// return_status = STATUS_UNSUPPORTED;
+// #endif // #if defined(DRV_RTC_HW_CALI)
+// }
+// break;
+//
+// case RTC_CMD_WRITE_TRIGGER_WAIT:
+// {
+// #if defined(DRV_RTC_HW_CALI)
+// RTC_write_trigger_wait();
+// return_status = STATUS_OK;
+// #else
+// return_status = STATUS_UNSUPPORTED;
+// #endif // #if defined(DRV_RTC_HW_CALI)
+// }
+// break;
+//
+// case RTC_CMD_WRITE_SPAR:
+// {
+// #if defined(DRV_RTC_REG_SPAR)
+// RTC_CTRL_CONFIG_SPAR_T *prConfigSPARReg;
+// prConfigSPARReg = &(data->rConfigSPARReg);
+// RTC_Write_SPAR((RTC_SPAR_INDEX)prConfigSPARReg->SPARIndex, prConfigSPARReg->WriteValue);
+// return_status = STATUS_OK;
+// #else
+// return_status = STATUS_UNSUPPORTED;
+// #endif // #if defined(DRV_RTC_REG_SPAR)
+// }
+// break;
+//
+// case RTC_CMD_WRITE_XOSC_REG:
+// {
+// RTC_CTRL_WRITE_XOSC_REG_T *prWriteXOSCReg;
+// prWriteXOSCReg = &(data->rWriteXOSCRef);
+// RTC_write_xosc_reg(prWriteXOSCReg->XOSC_Reg);
+// return_status = STATUS_OK;
+// }
+// break;
+//
+// default:
+// return_status = STATUS_INVALID_CMD;
+// break;
+// }
+// return return_status;
+// // return STATUS_FAIL;
+// }
+//
+//
+// /*************************************************************************
+// * FUNCTION
+// * DclRTC_Close
+// *
+// * DESCRIPTION
+// * This function is to close the RTC module.
+// *
+// * PARAMETERS
+// * handle: the returned handle value of DclRTC_Open
+// *
+// * RETURNS
+// * STATUS_OK
+// *
+// *************************************************************************/
+// DCL_STATUS DclRTC_Close(DCL_HANDLE handle)
+// {
+// kal_uint32 savedMask;
+//
+// // Check magic number
+// if ((handle & DCL_RTC_DEV_MAGIC_NUM) != DCL_RTC_DEV_MAGIC_NUM){
+// ASSERT(0);
+// return STATUS_INVALID_DCL_HANDLE;
+// }
+//
+// // Error check
+// if (dcl_rtc_handle_count == 0){
+// ASSERT(0);
+// return STATUS_NOT_OPENED;
+// }
+// // Clear all registered event callbacks for the specific handle
+// // Note: If we support multiple handles, we need to take care of the clear
+// {
+// kal_uint32 i;
+// for (i=0;i<MAX_DCL_RTC_EVENT_NUM;i++){
+// dcl_rtc_event_callback[i] = NULL;
+// }
+// }
+//
+// savedMask = SaveAndSetIRQMask();
+// // dcl_rtc_handle_count --;
+// RestoreIRQMask(savedMask);
+//
+// return STATUS_OK;
+// }
+//
+// #else /*!defined(DRV_RTC_OFF)*/
+//
+// DCL_STATUS DclRTC_Initialize(void)
+// {
+// return STATUS_FAIL;
+// }
+//
+// DCL_HANDLE DclRTC_Open(DCL_DEV dev, DCL_FLAGS flags)
+// {
+// return DCL_HANDLE_INVALID;
+// }
+//
+// DCL_STATUS DclRTC_ReadData(DCL_HANDLE handle, DCL_BUFF *buff, DCL_BUFF_LEN *buf_len, DCL_OPTIONS options)
+// {
+// return STATUS_UNSUPPORTED;
+// }
+//
+// DCL_STATUS DclRTC_WriteData(DCL_HANDLE handle, DCL_BUFF *buff, DCL_BUFF_LEN *buf_len, DCL_OPTIONS options)
+// {
+// return STATUS_UNSUPPORTED;
+// }
+//
+// DCL_STATUS DclRTC_Configure(DCL_HANDLE handle, DCL_CONFIGURE_T *configure)
+// {
+// return STATUS_UNSUPPORTED;
+// }
+//
+// DCL_STATUS DclRTC_RegisterCallback(DCL_HANDLE handle, DCL_EVENT event, PFN_DCL_CALLBACK callback)
+// {
+// return STATUS_FAIL;
+// }
+//
+// DCL_STATUS DclRTC_Control(DCL_HANDLE handle, DCL_CTRL_CMD cmd, DCL_CTRL_DATA_T *data)
+// {
+// return STATUS_FAIL;
+// }
+//
+// DCL_STATUS DclRTC_Close(DCL_HANDLE handle)
+// {
+// return STATUS_FAIL;
+// }
+//
+//
+// #endif /*!defined(DRV_RTC_OFF)*/
+//
+// #else
+
+DCL_STATUS DclRTC_Initialize(void)
+{
+ return STATUS_FAIL;
+}
+
+DCL_HANDLE DclRTC_Open(DCL_DEV dev, DCL_FLAGS flags)
+{
+ return STATUS_UNSUPPORTED;
+}
+
+DCL_STATUS DclRTC_ReadData(DCL_HANDLE handle, DCL_BUFF *buff, DCL_BUFF_LEN *buf_len, DCL_OPTIONS options)
+{
+ return STATUS_UNSUPPORTED;
+}
+
+DCL_STATUS DclRTC_WriteData(DCL_HANDLE handle, DCL_BUFF *buff, DCL_BUFF_LEN *buf_len, DCL_OPTIONS options)
+{
+ return STATUS_UNSUPPORTED;
+}
+
+DCL_STATUS DclRTC_Configure(DCL_HANDLE handle, DCL_CONFIGURE_T *configure)
+{
+ return STATUS_UNSUPPORTED;
+}
+
+DCL_STATUS DclRTC_RegisterCallback(DCL_HANDLE handle, DCL_EVENT event, PFN_DCL_CALLBACK callback)
+{
+ return STATUS_FAIL;
+}
+
+DCL_STATUS DclRTC_Control(DCL_HANDLE handle, DCL_CTRL_CMD cmd, DCL_CTRL_DATA_T *data)
+{
+ return STATUS_FAIL;
+}
+
+DCL_STATUS DclRTC_Close(DCL_HANDLE handle)
+{
+ return STATUS_FAIL;
+}
+
+
+// #endif //#ifdef DCL_RTC_INTERFACE
+