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
+