Gitiles
Code Review Sign In
192.168.1.100 / T800_MD / 0b80c7188a6089ae59f523c5d460adad05960e1d / . / mcu / driver / devdrv / rtc / src / dcl_rtc.c
blob: 895b545f5a6fc842490a818ec7d599fe09f3a22b [file] [log] [blame]
rjw6c1fd8f2022-11-30 14:33:01 +0800[diff] [blame]1/******************************************************************
2
3 NOTICE : We have no HW for this IP now,
4 But for SW complie request, temporarily add the 'fake api' to make compile success.
5
6 *****************************************************************/
7
8/*****************************************************************************
9* Copyright Statement:
10* --------------------
11* This software is protected by Copyright and the information contained
12* herein is confidential. The software may not be copied and the information
13* contained herein may not be used or disclosed except with the written
14* permission of MediaTek Inc. (C) 2005
15*
16* BY OPENING THIS FILE, BUYER HEREBY UNEQUIVOCALLY ACKNOWLEDGES AND AGREES
17* THAT THE SOFTWARE/FIRMWARE AND ITS DOCUMENTATIONS ("MEDIATEK SOFTWARE")
18* RECEIVED FROM MEDIATEK AND/OR ITS REPRESENTATIVES ARE PROVIDED TO BUYER ON
19* AN "AS-IS" BASIS ONLY. MEDIATEK EXPRESSLY DISCLAIMS ANY AND ALL WARRANTIES,
20* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED WARRANTIES OF
21* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE OR NONINFRINGEMENT.
22* NEITHER DOES MEDIATEK PROVIDE ANY WARRANTY WHATSOEVER WITH RESPECT TO THE
23* SOFTWARE OF ANY THIRD PARTY WHICH MAY BE USED BY, INCORPORATED IN, OR
24* SUPPLIED WITH THE MEDIATEK SOFTWARE, AND BUYER AGREES TO LOOK ONLY TO SUCH
25* THIRD PARTY FOR ANY WARRANTY CLAIM RELATING THERETO. MEDIATEK SHALL ALSO
26* NOT BE RESPONSIBLE FOR ANY MEDIATEK SOFTWARE RELEASES MADE TO BUYER'S
27* SPECIFICATION OR TO CONFORM TO A PARTICULAR STANDARD OR OPEN FORUM.
28*
29* BUYER'S SOLE AND EXCLUSIVE REMEDY AND MEDIATEK'S ENTIRE AND CUMULATIVE
30* LIABILITY WITH RESPECT TO THE MEDIATEK SOFTWARE RELEASED HEREUNDER WILL BE,
31* AT MEDIATEK'S OPTION, TO REVISE OR REPLACE THE MEDIATEK SOFTWARE AT ISSUE,
32* OR REFUND ANY SOFTWARE LICENSE FEES OR SERVICE CHARGE PAID BY BUYER TO
33* MEDIATEK FOR SUCH MEDIATEK SOFTWARE AT ISSUE.
34*
35* THE TRANSACTION CONTEMPLATED HEREUNDER SHALL BE CONSTRUED IN ACCORDANCE
36* WITH THE LAWS OF THE STATE OF CALIFORNIA, USA, EXCLUDING ITS CONFLICT OF
37* LAWS PRINCIPLES. ANY DISPUTES, CONTROVERSIES OR CLAIMS ARISING THEREOF AND
38* RELATED THERETO SHALL BE SETTLED BY ARBITRATION IN SAN FRANCISCO, CA, UNDER
39* THE RULES OF THE INTERNATIONAL CHAMBER OF COMMERCE (ICC).
40*
41*****************************************************************************/
42
43/*****************************************************************************
44 *
45 * Filename:
46 * ---------
47 * dcl_rtc.c
48 *
49 * Project:
50 * --------
51 * Maui_Software
52 *
53 * Description:
54 * ------------
55 * This Module defines DCL (Driver Common Layer) of the RTC driver.
56 *
57 * Author:
58 * -------
59 * -------
60 *
61 *============================================================================
62 * HISTORY
63 * Below this line, this part is controlled by PVCS VM. DO NOT MODIFY!!
64 *------------------------------------------------------------------------------
65 *
66 * removed!
67 *------------------------------------------------------------------------------
68 * Upper this line, this part is controlled by PVCS VM. DO NOT MODIFY!!
69 *============================================================================
70 ****************************************************************************/
71
72#include "drv_features.h"
73#include "drv_comm.h"
74#include "dcl.h"
75#include "kal_general_types.h"
76#include "kal_public_api.h"
77
78//
79// #include "rtc_sw_new.h"
80// #ifdef DCL_RTC_INTERFACE
81//
82// #if !defined(DRV_RTC_OFF)
83// // This API is exported by rtc.c
84// extern void RTC_TCintr(void);
85// extern void RTC_ALintr(void);
86// extern kal_bool RTC_FT_PowerOff(void);
87// extern void RTC_HW_Init_(void);
88// extern void RTC_reload(void);
89// #ifdef RTC_TEST
90// extern void RTC_delay(void);
91// #endif
92// extern kal_bool RTC_PWIC_Check_PowerOn(void);
93// extern void RTC_setBBPU(kal_uint16 data);
94// extern void RTC_PWIC_First_PowerOn_INIT_RTCTime(t_rtc *rtctime);
95// extern void RTC_PWIC_Mask_AL(void);
96// extern void RTC_PWIC_PowerOff_RTC_INIT(void);
97// extern void RTC_PWIC_PowerOn_RTC_INIT(void);
98//
99// #if defined(DRV_RTC_DBING)
100// extern void RTC_wait_debounce(void);
101// #endif //#if defined(DRV_RTC_DBING)
102// extern void RTC_start_cali(void);
103// extern rtc_callbac RTC_CALLBAC;
104//
105// // Global variable for DCL RTC API usage
106// #define DCL_RTC_DEV_MAGIC_NUM (0x40000000)
107// #define MAX_DCL_RTC_HANDLE 2
108// kal_uint32 dcl_rtc_handle_count = 0;
109//
110// // The event is presented by 32-bit variable
111// #define MAX_DCL_RTC_EVENT_NUM 32
112// PFN_DCL_CALLBACK dcl_rtc_event_callback[MAX_DCL_RTC_EVENT_NUM];
113//
114// /*************************************************************************
115// * Non-exported DCL internal functions
116// *************************************************************************/
117// void dcl_rtc_tc_intr_handler(void){
118// kal_uint32 event_bit;
119// kal_uint32 i;
120// // Search event callback entry
121// for (i=0;i<MAX_DCL_RTC_EVENT_NUM;i++){
122// event_bit = 1 << i;
123// if (event_bit == EVENT_RTC_TC){
124// if (dcl_rtc_event_callback[i] != NULL){
125// dcl_rtc_event_callback[i](EVENT_RTC_TC);
126// }
127// break;
128// }
129// }
130// }
131// void dcl_rtc_al_intr_handler(void){
132// kal_uint32 event_bit;
133// kal_uint32 i;
134// // Search event callback entry
135// for (i=0;i<MAX_DCL_RTC_EVENT_NUM;i++){
136// event_bit = 1 << i;
137// if (event_bit == EVENT_RTC_ALARM){
138// if (dcl_rtc_event_callback[i] != NULL){
139// dcl_rtc_event_callback[i](EVENT_RTC_ALARM);
140// }
141// break;
142// }
143// }
144// }
145//
146// /*************************************************************************
147// * Non-exported DCL internal functions
148// *************************************************************************/
149//
150//
151//
152// /*************************************************************************
153// * FUNCTION
154// * DclRTC_Initialize
155// *
156// * DESCRIPTION
157// * This function is to initialize RTC module
158// *
159// * PARAMETERS
160// * None
161// *
162// * RETURNS
163// * STATUS_OK
164// *
165// *************************************************************************/
166//
167//
168// DCL_STATUS DclRTC_Initialize(void){
169//
170// #if defined(DRV_RTC_HW_CALI)
171// RTC_HW_Init_();
172// #endif // #if defined(DRV_RTC_HW_CALI)
173//
174// #if !defined(__FUE__) && !defined(__UBL__)
175// RTC_init_(RTC_TCintr,RTC_ALintr);
176// #endif
177//
178// // Init event callback mapping array
179// {
180// kal_uint32 i;
181// for (i=0;i<MAX_DCL_RTC_EVENT_NUM;i++){
182// dcl_rtc_event_callback[i] = NULL;
183// }
184// }
185//
186// // Hack/Register to RTC driver callback
187// #if !defined(__FUE__) && !defined(__UBL__)
188// RTC_CALLBAC.rtc_tcfunc = dcl_rtc_tc_intr_handler;
189// RTC_CALLBAC.rtc_alfunc = dcl_rtc_al_intr_handler;
190// #endif
191//
192// dcl_rtc_handle_count = 0;
193//
194//
195// return STATUS_OK;
196//
197//
198//
199// }
200//
201// /*************************************************************************
202// * FUNCTION
203// * DclRTC_Open
204// *
205// * DESCRIPTION
206// * This function is to open the RTC module and return a handle
207// *
208// * PARAMETERS
209// * dev: only valid for DCL_RTC
210// * flags: no sepcial flags is needed. Please use FLAGS_NONE
211// *
212// * RETURNS
213// * DCL_HANDLE_INVALID: Open failed
214// * Other value: A valid handle
215// *
216// *************************************************************************/
217//
218// DCL_HANDLE DclRTC_Open(DCL_DEV dev, DCL_FLAGS flags)
219// {
220// kal_uint32 handle;
221// kal_uint32 savedMask;
222//
223// // Check device type
224// if (dev != DCL_RTC){
225// ASSERT(0);
226// return DCL_HANDLE_INVALID; // Incorrecr device ID
227// }
228//
229// // Check allowed open number
230// if (dcl_rtc_handle_count >= MAX_DCL_RTC_HANDLE){
231// ASSERT(0);
232// return DCL_HANDLE_INVALID; // Too many opened handles
233// }
234//
235// savedMask = SaveAndSetIRQMask();
236// // dcl_rtc_handle_count ++;
237// dcl_rtc_handle_count = 1;
238// handle = (DCL_RTC_DEV_MAGIC_NUM | dcl_rtc_handle_count);
239// RestoreIRQMask(savedMask);
240//
241// return handle;
242// }
243//
244// /*************************************************************************
245// * FUNCTION
246// * DclRTC_ReadData
247// *
248// * DESCRIPTION
249// * This function is not supported for the RTC module now.
250// *
251// * PARAMETERS
252// * N/A
253// *
254// * RETURNS
255// * STATUS_UNSUPPORTED
256// *
257// *************************************************************************/
258// DCL_STATUS DclRTC_ReadData(DCL_HANDLE handle, DCL_BUFF *buff, DCL_BUFF_LEN *buf_len, DCL_OPTIONS options){
259// return STATUS_UNSUPPORTED;
260// }
261//
262// /*************************************************************************
263// * FUNCTION
264// * DclRTC_WriteData
265// *
266// * DESCRIPTION
267// * This function is not supported for the RTC module now.
268// *
269// * PARAMETERS
270// * N/A
271// *
272// * RETURNS
273// * STATUS_UNSUPPORTED
274// *
275// *************************************************************************/
276// extern DCL_STATUS DclRTC_WriteData(DCL_HANDLE handle, DCL_BUFF *buff, DCL_BUFF_LEN *buf_len, DCL_OPTIONS options){
277// return STATUS_UNSUPPORTED;
278// }
279//
280// /*************************************************************************
281// * FUNCTION
282// * DclRTC_Configure
283// *
284// * DESCRIPTION
285// * This function is not supported for the RTC module now.
286// *
287// * PARAMETERS
288// * N/A
289// *
290// * RETURNS
291// * STATUS_UNSUPPORTED
292// *
293// *************************************************************************/
294// DCL_STATUS DclRTC_Configure(DCL_HANDLE handle, DCL_CONFIGURE_T *configure){
295// return STATUS_UNSUPPORTED;
296// }
297//
298// /*************************************************************************
299// * FUNCTION
300// * DclRTC_RegisterCallback
301// *
302// * DESCRIPTION
303// * This function is to set callback function for the RTC module.
304// *
305// * PARAMETERS
306// * handle: the returned handle value of DclRTC_Open
307// * event: Supported events:
308// * EVENT_RTC_ALARM: RTC alarm interrupt
309// * EVENT_RTC_TC: RTC tick interrupt
310// * callback: the callback function for registered events
311// *
312// * RETURNS
313// * STATUS_OK: Successfully register the callback function.
314// * STATUS_INVALID_DCL_HANDLE: It's a invalid handle.
315// * STATUS_NOT_OPENED: The module has not been opened.
316// * STATUS_INVALID_EVENT: The event parameter is invalid.
317// *
318// *************************************************************************/
319// DCL_STATUS DclRTC_RegisterCallback(DCL_HANDLE handle, DCL_EVENT event, PFN_DCL_CALLBACK callback){
320//
321// // Check magic number
322// if ((handle & DCL_RTC_DEV_MAGIC_NUM) != DCL_RTC_DEV_MAGIC_NUM){
323// ASSERT(0);
324// return STATUS_INVALID_DCL_HANDLE;
325// }
326//
327// // Error check
328// if (dcl_rtc_handle_count == 0){
329// ASSERT(0);
330// return STATUS_NOT_OPENED;
331// }
332// // Check if the passed-in event bitmap is supported or NOT
333// if (((kal_uint32)event & (~(EVENT_RTC_ALARM | EVENT_RTC_TC))) != 0){
334// ASSERT(0);
335// return STATUS_INVALID_EVENT;
336// }
337//
338// // Search mapping array and assign callback to specofic array entry
339// {
340// kal_uint32 i;
341// kal_uint32 event_bit;
342// for (i=0;i<MAX_DCL_RTC_EVENT_NUM;i++){
343// event_bit = 1 << i;
344// if ((event_bit & event) != 0){
345// // 1. Check if a callback has been registered for the event
346// // Allow multiple registration for now
347// //ASSERT(dcl_rtc_event_callback[i] != NULL);
348// // 2. Register the callback
349// dcl_rtc_event_callback[i] = callback;
350// }
351// }
352// }
353// return STATUS_OK;
354// }
355//
356//
357// /*************************************************************************
358// * FUNCTION
359// * DclRTC_Control
360// *
361// * DESCRIPTION
362// * This function is to send command to control the RTC module.
363// *
364// * PARAMETERS
365// * handle: The handle value returned from DclRTC_Open
366// * cmd: A control command for RTC module
367// * 1. RTC_CMD_BOOTLOADER_POWERON: to check RTC Power On in bootloader
368// * 2. RTC_CMD_CLEAR_PDN_BITS: to clear RTC PDN bits
369// * 3. RTC_CMD_CONFIG_AL_TC: to set alarm mask and tick mask
370// * 4. RTC_CMD_DELAY: to Delay 2000 counts
371// * 5. RTC_CMD_GET_ALARM_TIME: to get alarm time
372// * 6. RTC_CMD_GET_TIME: to get time
373// * 7. RTC_CMD_GPIO_GET_INPUT: to get RTC_GPIO_GPI register value
374// * 8. RTC_CMD_GPIO_SET_EXPORT_32K: to export 32.768KHz clock on RTC_GPIO
375// * 9. RTC_CMD_GPIO_SET_EXPORT_COREDETB: to export COREDETB on RTC_GPIO
376// * 10. RTC_CMD_GPIO_SET_INPUT_MODE: to set RTC_GPIO input mode
377// * 11. RTC_CMD_GPIO_SET_OUTPUT_MODE: to set RTC_GPIO output mode
378// * 12. RTC_CMD_HW_INIT: to initialize RTC hardware
379// * 13. RTC_CMD_INIT: to initialize RTC software
380// * 14. RTC_CMD_INIT_TC_AL_INTR: to initialize RTC TC & AL INTR
381// * 15. RTC_CMD_IS_CONFIG_VALID: to check if RTC time and Alarm are valid
382// * 16. RTC_CMD_IS_FIRST_ON: to check if device is first on
383// * 17. RTC_CMD_IS_MS_FIRSTPOWERON: to check whether RTC is first power on(for MMI)
384// * 18. RTC_CMD_IS_TIME_VALID: to check if time are valid
385// * 19. RTC_CMD_PWIC_CHECK_POWERON: to check if power on (for PWIC)
386// * 20. RTC_CMD_PWIC_FIRST_POWERON_INIT_RTCTIME: to init RTC time at first power on (for PWIC)
387// * 21. RTC_CMD_PWIC_MASK_AL: to control RTC Alarm mask (for PWIC)
388// * 22. RTC_CMD_PWIC_POWEROFF_RTC_INIT: to init RTC at power off (for PWIC)
389// * 23. RTC_CMD_PWIC_POWERON_RTC_INIT: to init RTC at power on (for PWIC)
390// * 24. RTC_CMD_READ_PDN_BITS: to read RTC PDN bits
391// * 25. RTC_CMD_READ_XOSC_REG: to read RTC XOSCCALI register
392// * 26. RTC_CMD_RELOAD: to load RTC whole register info from RTC module
393// * 27. RTC_CMD_SET_ALARM_TIME: to set alarm time
394// * 28. RTC_CMD_SET_FIRST_POWERON: to set first power on
395// * 29. RTC_CMD_SET_PDN_BITS: to set RTC PDN bits
396// * 30. RTC_CMD_SET_PWR_KEY: to set PWR KEY
397// * 31. RTC_CMD_SET_TIME: to set time
398// * 32. RTC_CMD_SETBBPU: to set RTC_BBPU
399// * 33. RTC_CMD_SETXOSC: to set RTC XOSCCALI register
400// * 34. RTC_CMD_START_CALI: to start calibration process
401// * 35. RTC_CMD_WAIT_DEBOUNCE: to wait until debounce bit becomes 0
402// * 36. RTC_CMD_WRITE_PDN_BITS: to write RTC PDN bits
403// * 37. RTC_CMD_WRITE_TRIGGER: to set write trigger
404// * 38. RTC_CMD_WRITE_TRIGGER_WAIT: to set write trigger and wait until BUSY bit becomes 0
405// * 39. RTC_CMD_WRITE_XOSC_REG: to write RTC XOSCCALI register
406// *
407// * data: The data of the control command
408// * 1. RTC_CMD_BOOTLOADER_POWERON: pointer to a RTC_CTRL_BOOTLOADER_POWERON_T structure
409// * 2. RTC_CMD_CLEAR_PDN_BITS: pointer to a RTC_CTRL_CONFIG_PDN_BIT_T structure
410// * 3. RTC_CMD_CONFIG_AL_TC: pointer to a RTC_CTRL_CONFIG_AL_TC_T structure
411// * 4. RTC_CMD_DELAY: A null pointer
412// * 5. RTC_CMD_GET_ALARM_TIME: pointer to a RTC_CTRL_GET_ALARM_TIME_T structure
413// * 6. RTC_CMD_GET_TIME: pointer to a RTC_CTRL_GET_TIME_T structure
414// * 7. RTC_CMD_GPIO_GET_INPUT: pointer to a RTC_CTRL_GPIO_TIME_T structure
415// * 8. RTC_CMD_GPIO_SET_EXPORT_32K: pointer to a RTC_CTRL_GPIO_TIME_T structure
416// * 9. RTC_CMD_GPIO_SET_EXPORT_COREDETB: pointer to a RTC_CTRL_GPIO_TIME_T structure
417// * 10. RTC_CMD_GPIO_SET_INPUT_MODE: pointer to a RTC_CTRL_GPIO_TIME_T structure
418// * 11. RTC_CMD_GPIO_SET_OUTPUT_MODE: pointer to a RTC_CTRL_GPIO_TIME_T structure
419// * 12. RTC_CMD_HW_INIT: A null pointer
420// * 13. RTC_CMD_INIT: pointer to a RTC_CTRL_INIT_T structure
421// * 14. RTC_CMD_INIT_TC_AL_INTR: A null pointer
422// * 15. RTC_CMD_IS_CONFIG_VALID: pointer to a RTC_CTRL_IS_CONFIG_VALID_T structure
423// * 16. RTC_CMD_IS_FIRST_ON: pointer to a RTC_CTRL_IS_FIRST_ON_T structure
424// * 17. RTC_CMD_IS_MS_FIRSTPOWERON: pointer to a RTC_CTRL_IS_MS_FIRSTPOWERON_T structure
425// * 18. RTC_CMD_IS_TIME_VALID: pointer to a RTC_CTRL_IS_TIME_VALID_T structure
426// * 19. RTC_CMD_PWIC_CHECK_POWERON: pointer to a RTC_CTRL_PWIC_CHECK_POWERON_T structure
427// * 20. RTC_CMD_PWIC_FIRST_POWERON_INIT_RTCTIME: pointer to a RTC_CTRL_PWIC_FIRST_POWERON_INIT_RTCTIME_T structure
428// * 21. RTC_CMD_PWIC_MASK_AL: A null pointer
429// * 22. RTC_CMD_PWIC_POWEROFF_RTC_INIT: A null pointer
430// * 23. RTC_CMD_PWIC_POWERON_RTC_INIT: A null pointer
431// * 24. RTC_CMD_READ_PDN_BITS: pointer to a RTC_CTRL_CONFIG_PDN_BIT_T structure
432// * 25. RTC_CMD_READ_XOSC_REG: pointer to a RTC_CTRL_READ_XOSC_REG_T structure
433// * 26. RTC_CMD_RELOAD: A null pointer
434// * 27. RTC_CMD_SET_ALARM_TIME: pointer to a RTC_CTRL_SET_ALARM_TIME_T structure
435// * 28. RTC_CMD_SET_FIRST_POWERON: pointer to a RTC_CTRL_SET_FIRST_POWERON_T structure
436// * 29. RTC_CMD_SET_PDN_BITS: pointer to a RTC_CTRL_CONFIG_PDN_BIT_T structure
437// * 30. RTC_CMD_SET_PWR_KEY: A null pointer
438// * 31. RTC_CMD_SET_TIME: pointer to a RTC_CTRL_SET_TIME_T structure
439// * 32. RTC_CMD_SETBBPU: pointer to a RTC_CTRL_SETBBPU_T structure
440// * 33. RTC_CMD_SETXOSC: A null pointer
441// * 34. RTC_CMD_START_CALI: A null pointer
442// * 35. RTC_CMD_WAIT_DEBOUNCE: A null pointer
443// * 36. RTC_CMD_WRITE_PDN_BITS: pointer to a RTC_CTRL_CONFIG_PDN_BIT_T structure
444// * 37. RTC_CMD_WRITE_TRIGGER: A null pointer
445// * 38. RTC_CMD_WRITE_TRIGGER_WAIT: A null pointer
446// * 39. RTC_CMD_WRITE_XOSC_REG: pointer to a RTC_CTRL_WRITE_XOSC_REG_T structure
447// *
448// * RETURNS
449// * STATUS_OK: command is executed successfully.
450// * STATUS_FAIL: command is failed.
451// * STATUS_INVALID_CMD: It's a invalid command.
452// *
453// *************************************************************************/
454// DCL_STATUS DclRTC_Control(DCL_HANDLE handle, DCL_CTRL_CMD cmd, DCL_CTRL_DATA_T *data)
455// {
456// DCL_STATUS return_status;
457//
458// // Check magic number
459// if ((handle & DCL_RTC_DEV_MAGIC_NUM) != DCL_RTC_DEV_MAGIC_NUM){
460// ASSERT(0);
461// return STATUS_INVALID_DCL_HANDLE;
462// }
463//
464// // Error check
465// if (dcl_rtc_handle_count == 0){
466// ASSERT(0);
467// return STATUS_NOT_OPENED;
468// }
469//
470// switch (cmd)
471// {
472// case RTC_CMD_BOOTLOADER_POWERON:
473// {
474// RTC_CTRL_BOOTLOADER_POWERON_T *prBootloaderPowerOn;
475// prBootloaderPowerOn = &(data->rBootloaderPowerOn);
476// prBootloaderPowerOn->fgBootloaderPowerOn = (DCL_BOOLEAN)RTC_Bootloader_PowerOn_();
477// return_status = STATUS_OK;
478// }
479// break;
480//
481// case RTC_CMD_CLEAR_PDN_BITS:
482// {
483// RTC_CTRL_CONFIG_PDN_BIT_T *prConfigPDNBit;
484// prConfigPDNBit = &(data->rConfigPDNBit);
485// RTC_Clear_PDN_bits((RTC_PDN_INDEX)prConfigPDNBit->PDNIndex, prConfigPDNBit->fgConfigBit);
486// return_status = STATUS_OK;
487// }
488// break;
489//
490// case RTC_CMD_CONFIG_AL_TC:
491// {
492// #if !defined(__FUE__) && !defined(__UBL__)
493// RTC_CTRL_CONFIG_AL_TC_T *prConfigALTC;
494// prConfigALTC = &(data->rConfigALTC);
495// RTC_Config_(prConfigALTC->u1ALEn, prConfigALTC->u1TCEn);
496// return_status = STATUS_OK;
497// #else
498// return_status = STATUS_UNSUPPORTED;
499// #endif
500// }
501// break;
502//
503// case RTC_CMD_DELAY:
504// {
505// #ifdef RTC_TEST
506// RTC_delay();
507// return_status = STATUS_OK;
508// #else
509// return_status = STATUS_UNSUPPORTED;
510// #endif
511// }
512// break;
513//
514// case RTC_CMD_FT_POWEROFF:
515// {
516// RTC_CTRL_FT_POWEROFF_T *prFTPowerOff;
517// prFTPowerOff = &(data->rFTPowerOff);
518// prFTPowerOff->fgMetaReset =(DCL_BOOLEAN)RTC_FT_PowerOff();
519// return_status = STATUS_OK;
520// }
521// break;
522//
523// case RTC_CMD_GET_ALARM_TIME:
524// {
525// t_rtc rtc;
526// RTC_CTRL_GET_ALARM_TIME_T *prGetAlarmTime;
527// prGetAlarmTime = &(data->rGetAlarmTime);
528// prGetAlarmTime->ALEnBit = (DCL_BOOLEAN)RTC_GetALTime(&rtc);
529//
530// prGetAlarmTime->u1Sec = rtc.rtc_sec;
531// prGetAlarmTime->u1Min = rtc.rtc_min;
532// prGetAlarmTime->u1Hour = rtc.rtc_hour;
533// prGetAlarmTime->u1Day = rtc.rtc_day;
534// prGetAlarmTime->u1Mon = rtc.rtc_mon;
535// prGetAlarmTime->u1WDay = rtc.rtc_wday;
536// prGetAlarmTime->u1Year = rtc.rtc_year;
537//
538// return_status = STATUS_OK;
539// }
540// break;
541//
542// case RTC_CMD_GET_TIME:
543// {
544// t_rtc rtc;
545// RTC_CTRL_GET_TIME_T *prGetTime;
546// prGetTime = &(data->rGetTime);
547// RTC_GetTime_(&rtc);
548//
549// prGetTime->u1Sec = rtc.rtc_sec;
550// prGetTime->u1Min = rtc.rtc_min;
551// prGetTime->u1Hour = rtc.rtc_hour;
552// prGetTime->u1Day = rtc.rtc_day;
553// prGetTime->u1Mon = rtc.rtc_mon;
554// prGetTime->u1WDay = rtc.rtc_wday;
555// prGetTime->u1Year = rtc.rtc_year;
556//
557// return_status = STATUS_OK;
558// }
559// break;
560//
561// #if defined(DRV_RTC_GPIO)
562// case RTC_CMD_GPIO_GET_INPUT:
563// {
564// RTC_CTRL_GPIO_TIME_T *prGPIO;
565// prGPIO = &(data->rGPIO);
566// prGPIO->InputValue = (DCL_BOOLEAN)RTC_Get_GPIO_Input();
567// return_status = STATUS_OK;
568// }
569// break;
570//
571// case RTC_CMD_GPIO_SET_EXPORT_32K:
572// {
573// RTC_Set_GPIO_Mode(RTC_GPIO_EXPORT_32K);
574// return_status = STATUS_OK;
575// }
576// break;
577//
578// case RTC_CMD_GPIO_SET_EXPORT_COREDETB:
579// {
580// RTC_Set_GPIO_Mode(RTC_GPIO_EXPORT_COREDETB);
581// return_status = STATUS_OK;
582// }
583// break;
584//
585// case RTC_CMD_GPIO_SET_INPUT_MODE:
586// {
587// RTC_CTRL_GPIO_TIME_T *prGPIO;
588// prGPIO = &(data->rGPIO);
589// RTC_Set_GPIO_Input_Mode((RTC_GPIO_PULL_TYPE_enum) prGPIO->rPullType,
590// (RTC_GPIO_DRIVING_STRENGTH_enum) prGPIO->rPullStrength,(kal_bool)prGPIO->is_SmithTrigger);
591// return_status = STATUS_OK;
592// }
593// break;
594//
595// case RTC_CMD_GPIO_SET_OUTPUT_MODE:
596// {
597// RTC_CTRL_GPIO_TIME_T *prGPIO;
598// prGPIO = &(data->rGPIO);
599// RTC_Set_GPIO_Output_Mode((kal_bool)prGPIO->OutputValue,(kal_bool)prGPIO->is_SlewRateControl);
600// return_status = STATUS_OK;
601// }
602// break;
603//
604// #endif //#if defined(DRV_RTC_GPIO)
605// case RTC_CMD_HW_INIT:
606// {
607// RTC_HW_Init_();
608// return_status = STATUS_OK;
609// }
610// break;
611//
612// case RTC_CMD_INIT:
613// {
614// #if !defined(__FUE__) && !defined(__UBL__)
615// RTC_CTRL_INIT_T *prInit;
616// prInit = &(data->rInit);
617// RTC_init_(prInit->RTC_TCCallback, prInit->RTC_ALCallback);
618// return_status = STATUS_OK;
619// #else
620// return_status = STATUS_UNSUPPORTED;
621// #endif
622// }
623// break;
624//
625// case RTC_CMD_INIT_TC_AL_INTR:
626// {
627// #if !defined(__FUE__) && !defined(__UBL__)
628// RTC_init_(RTC_TCintr,RTC_ALintr);
629// return_status = STATUS_OK;
630// #else
631// return_status = STATUS_UNSUPPORTED;
632// #endif
633// }
634// break;
635//
636// case RTC_CMD_IS_CONFIG_VALID:
637// {
638// RTC_CTRL_IS_CONFIG_VALID_T *prIsConfigValid;
639// prIsConfigValid = &(data->rIsConfigValid);
640// prIsConfigValid->fgIsValid = (DCL_BOOLEAN)RTC_is_config_valid();
641// return_status = STATUS_OK;
642// }
643// break;
644//
645// case RTC_CMD_IS_FIRST_ON:
646// {
647// RTC_CTRL_IS_FIRST_ON_T *prIsFirstOn;
648// prIsFirstOn = &(data->rIsFirstOn);
649// prIsFirstOn->fgFirstOn = (DCL_BOOLEAN)RTC_isFisrtOn();
650// return_status = STATUS_OK;
651// }
652// break;
653//
654// case RTC_CMD_IS_MS_FIRSTPOWERON:
655// {
656// #if !defined(__FUE__) && !defined(__UBL__)
657// RTC_CTRL_IS_MS_FIRSTPOWERON_T *prIsMSFirstPowerOn;
658// prIsMSFirstPowerOn = &(data->rIsMSFirstPowerOn);
659// prIsMSFirstPowerOn->fgMSFirstPowerOn = (DCL_BOOLEAN)RTC_is_MS_FirstPowerOn_();
660// return_status = STATUS_OK;
661// #else
662// return_status = STATUS_UNSUPPORTED;
663// #endif
664// }
665// break;
666//
667// case RTC_CMD_IS_TIME_VALID:
668// {
669// t_rtc rtc;
670// RTC_CTRL_IS_TIME_VALID_T *prIsTimeValid;
671// prIsTimeValid = &(data->rIsTimeValid);
672//
673// rtc.rtc_sec = prIsTimeValid->u1Sec;
674// rtc.rtc_min = prIsTimeValid->u1Min;
675// rtc.rtc_hour = prIsTimeValid->u1Hour;
676// rtc.rtc_day = prIsTimeValid->u1Day;
677// rtc.rtc_mon = prIsTimeValid->u1Mon;
678// rtc.rtc_wday = prIsTimeValid->u1WDay;
679// rtc.rtc_year = prIsTimeValid->u1Year;
680//
681// prIsTimeValid->isTimeValid = (DCL_BOOLEAN)RTC_is_Time_Valid(&rtc);
682//
683// return_status = STATUS_OK;
684// }
685// break;
686//
687// case RTC_CMD_PWIC_CHECK_POWERON:
688// {
689// RTC_CTRL_PWIC_CHECK_POWERON_T *prPwicCheckPowerOn;
690// prPwicCheckPowerOn = &(data->rPwicCheckPowerOn);
691// prPwicCheckPowerOn->fgIsPowerOn = (DCL_BOOLEAN)RTC_PWIC_Check_PowerOn();
692// return_status = STATUS_OK;
693// }
694// break;
695//
696// case RTC_CMD_PWIC_FIRST_POWERON_INIT_RTCTIME:
697// {
698// t_rtc rtc;
699// RTC_CTRL_PWIC_FIRST_POWERON_INIT_RTCTIME_T *prPwicFirstPowerOnInitRTCTime;
700// prPwicFirstPowerOnInitRTCTime = &(data->rPwicFirstPowerOnInitRTCTime);
701//
702// rtc.rtc_sec = prPwicFirstPowerOnInitRTCTime->u1Sec;
703// rtc.rtc_min = prPwicFirstPowerOnInitRTCTime->u1Min;
704// rtc.rtc_hour = prPwicFirstPowerOnInitRTCTime->u1Hour;
705// rtc.rtc_day = prPwicFirstPowerOnInitRTCTime->u1Day;
706// rtc.rtc_mon = prPwicFirstPowerOnInitRTCTime->u1Mon;
707// rtc.rtc_wday = prPwicFirstPowerOnInitRTCTime->u1WDay;
708// rtc.rtc_year = prPwicFirstPowerOnInitRTCTime->u1Year;
709//
710// RTC_PWIC_First_PowerOn_INIT_RTCTime(&rtc);
711//
712// return_status = STATUS_OK;
713// }
714// break;
715//
716// case RTC_CMD_PWIC_MASK_AL:
717// {
718// RTC_PWIC_Mask_AL();
719// return_status = STATUS_OK;
720// }
721// break;
722//
723// case RTC_CMD_PWIC_POWEROFF_RTC_INIT:
724// {
725// RTC_PWIC_PowerOff_RTC_INIT();
726// return_status = STATUS_OK;
727// }
728// break;
729//
730// case RTC_CMD_PWIC_POWERON_RTC_INIT:
731// {
732// RTC_PWIC_PowerOn_RTC_INIT();
733// return_status = STATUS_OK;
734// }
735// break;
736//
737// case RTC_CMD_READ_PDN_BITS:
738// {
739// RTC_CTRL_CONFIG_PDN_BIT_T *prConfigPDNBit;
740// prConfigPDNBit = &(data->rConfigPDNBit);
741// prConfigPDNBit->PDNValue = RTC_Read_PDN((RTC_PDN_INDEX)prConfigPDNBit->PDNIndex);
742// return_status = STATUS_OK;
743// }
744// break;
745//
746// case RTC_CMD_READ_SPAR:
747// {
748// #if defined(DRV_RTC_REG_SPAR)
749// RTC_CTRL_CONFIG_SPAR_T *prConfigSPARReg;
750// prConfigSPARReg = &(data->rConfigSPARReg);
751// prConfigSPARReg->ReadValue = RTC_Read_SPAR((RTC_SPAR_INDEX)prConfigSPARReg->SPARIndex);
752// return_status = STATUS_OK;
753// #else
754// return_status = STATUS_UNSUPPORTED;
755// #endif // #if defined(DRV_RTC_REG_SPAR)
756// }
757// break;
758//
759// case RTC_CMD_READ_XOSC_REG:
760// {
761// RTC_CTRL_READ_XOSC_REG_T *prReadXOSCReg;
762// prReadXOSCReg = &(data->rReadXOSCReg);
763// prReadXOSCReg->XOSCValue = RTC_read_xosc_reg();
764// return_status = STATUS_OK;
765// }
766// break;
767//
768// case RTC_CMD_RELOAD:
769// {
770// #if defined(DRV_RTC_HW_CALI)
771// RTC_reload();
772// return_status = STATUS_OK;
773// #else
774// return_status = STATUS_UNSUPPORTED;
775// #endif // #if defined(DRV_RTC_HW_CALI)
776// }
777// break;
778//
779// case RTC_CMD_SET_ALARM_TIME:
780// {
781// t_rtc rtc;
782// RTC_CTRL_SET_ALARM_TIME_T *prSetAlarmTime;
783// prSetAlarmTime = &(data->rSetAlarmTime);
784//
785// rtc.rtc_sec = prSetAlarmTime->u1Sec;
786// rtc.rtc_min = prSetAlarmTime->u1Min;
787// rtc.rtc_hour = prSetAlarmTime->u1Hour;
788// rtc.rtc_day = prSetAlarmTime->u1Day;
789// rtc.rtc_mon = prSetAlarmTime->u1Mon;
790// rtc.rtc_wday = prSetAlarmTime->u1WDay;
791// rtc.rtc_year = prSetAlarmTime->u1Year;
792//
793// RTC_SetAlarm(&rtc);
794// return_status = STATUS_OK;
795// }
796// break;
797//
798// case RTC_CMD_SET_FIRST_POWERON:
799// {
800// #if !defined(__FUE__) && !defined(__UBL__)
801// RTC_CTRL_SET_FIRST_POWERON_T *prSetFirstPowerOn;
802// prSetFirstPowerOn = &(data->rSetFirstPowerOn);
803// RTC_set_First_PowerOn((kal_bool)prSetFirstPowerOn->fgPowerOn);
804// return_status = STATUS_OK;
805// #else
806// return_status = STATUS_UNSUPPORTED;
807// #endif
808// }
809// break;
810//
811// case RTC_CMD_SET_PDN_BITS:
812// {
813// RTC_CTRL_CONFIG_PDN_BIT_T *prConfigPDNBit;
814// prConfigPDNBit = &(data->rConfigPDNBit);
815// RTC_Set_PDN_bits((RTC_PDN_INDEX)prConfigPDNBit->PDNIndex, prConfigPDNBit->fgConfigBit);
816// return_status = STATUS_OK;
817// }
818// break;
819//
820// case RTC_CMD_SET_PWR_KEY:
821// {
822// RTC_setPWRKey();
823// return_status = STATUS_OK;
824// }
825// break;
826//
827// case RTC_CMD_SET_TIME:
828// {
829// t_rtc rtc;
830// RTC_CTRL_SET_TIME_T *prSetTime;
831// prSetTime = &(data->rSetTime);
832//
833// rtc.rtc_sec = prSetTime->u1Sec;
834// rtc.rtc_min = prSetTime->u1Min;
835// rtc.rtc_hour = prSetTime->u1Hour;
836// rtc.rtc_day = prSetTime->u1Day;
837// rtc.rtc_mon = prSetTime->u1Mon;
838// rtc.rtc_wday = prSetTime->u1WDay;
839// rtc.rtc_year = prSetTime->u1Year;
840//
841// RTC_InitTC_Time(&rtc);
842// return_status = STATUS_OK;
843// }
844// break;
845//
846// case RTC_CMD_SETBBPU:
847// {
848// #ifdef RTC_Test
849// RTC_CTRL_SETBBPU_T *prSetBBPU;
850// prSetBBPU = &(data->rSetBBPU);
851// RTC_setBBPU(prSetBBPU->BBPUReg);
852// return_status = STATUS_OK;
853// #else
854// return_status = STATUS_UNSUPPORTED;
855// #endif
856// }
857// break;
858//
859// case RTC_CMD_SETXOSC:
860// {
861// RTC_setXOSC_();
862// return_status = STATUS_OK;
863// }
864// break;
865//
866// case RTC_CMD_START_CALI:
867// {
868// #if !defined(__FUE__) && !defined(__UBL__)
869// RTC_start_cali();
870// return_status = STATUS_OK;
871// #else
872// return_status = STATUS_UNSUPPORTED;
873// #endif
874// }
875// break;
876//
877// case RTC_CMD_WAIT_DEBOUNCE:
878// {
879// #if defined(DRV_RTC_DBING)
880// RTC_wait_debounce();
881// return_status = STATUS_OK;
882// #else
883// return_status = STATUS_UNSUPPORTED;
884// #endif // #if defined(DRV_RTC_DBING)
885// }
886// break;
887//
888// case RTC_CMD_WRITE_PDN_BITS:
889// {
890// RTC_CTRL_CONFIG_PDN_BIT_T *prConfigPDNBit;
891// prConfigPDNBit = &(data->rConfigPDNBit);
892// RTC_Write_PDN_bits((RTC_PDN_INDEX)prConfigPDNBit->PDNIndex, prConfigPDNBit->fgConfigBit);
893// return_status = STATUS_OK;
894// }
895// break;
896//
897// case RTC_CMD_WRITE_TRIGGER:
898// {
899// #if defined(DRV_RTC_HW_CALI)
900// RTC_write_trigger();
901// return_status = STATUS_OK;
902// #else
903// return_status = STATUS_UNSUPPORTED;
904// #endif // #if defined(DRV_RTC_HW_CALI)
905// }
906// break;
907//
908// case RTC_CMD_WRITE_TRIGGER_WAIT:
909// {
910// #if defined(DRV_RTC_HW_CALI)
911// RTC_write_trigger_wait();
912// return_status = STATUS_OK;
913// #else
914// return_status = STATUS_UNSUPPORTED;
915// #endif // #if defined(DRV_RTC_HW_CALI)
916// }
917// break;
918//
919// case RTC_CMD_WRITE_SPAR:
920// {
921// #if defined(DRV_RTC_REG_SPAR)
922// RTC_CTRL_CONFIG_SPAR_T *prConfigSPARReg;
923// prConfigSPARReg = &(data->rConfigSPARReg);
924// RTC_Write_SPAR((RTC_SPAR_INDEX)prConfigSPARReg->SPARIndex, prConfigSPARReg->WriteValue);
925// return_status = STATUS_OK;
926// #else
927// return_status = STATUS_UNSUPPORTED;
928// #endif // #if defined(DRV_RTC_REG_SPAR)
929// }
930// break;
931//
932// case RTC_CMD_WRITE_XOSC_REG:
933// {
934// RTC_CTRL_WRITE_XOSC_REG_T *prWriteXOSCReg;
935// prWriteXOSCReg = &(data->rWriteXOSCRef);
936// RTC_write_xosc_reg(prWriteXOSCReg->XOSC_Reg);
937// return_status = STATUS_OK;
938// }
939// break;
940//
941// default:
942// return_status = STATUS_INVALID_CMD;
943// break;
944// }
945// return return_status;
946// // return STATUS_FAIL;
947// }
948//
949//
950// /*************************************************************************
951// * FUNCTION
952// * DclRTC_Close
953// *
954// * DESCRIPTION
955// * This function is to close the RTC module.
956// *
957// * PARAMETERS
958// * handle: the returned handle value of DclRTC_Open
959// *
960// * RETURNS
961// * STATUS_OK
962// *
963// *************************************************************************/
964// DCL_STATUS DclRTC_Close(DCL_HANDLE handle)
965// {
966// kal_uint32 savedMask;
967//
968// // Check magic number
969// if ((handle & DCL_RTC_DEV_MAGIC_NUM) != DCL_RTC_DEV_MAGIC_NUM){
970// ASSERT(0);
971// return STATUS_INVALID_DCL_HANDLE;
972// }
973//
974// // Error check
975// if (dcl_rtc_handle_count == 0){
976// ASSERT(0);
977// return STATUS_NOT_OPENED;
978// }
979// // Clear all registered event callbacks for the specific handle
980// // Note: If we support multiple handles, we need to take care of the clear
981// {
982// kal_uint32 i;
983// for (i=0;i<MAX_DCL_RTC_EVENT_NUM;i++){
984// dcl_rtc_event_callback[i] = NULL;
985// }
986// }
987//
988// savedMask = SaveAndSetIRQMask();
989// // dcl_rtc_handle_count --;
990// RestoreIRQMask(savedMask);
991//
992// return STATUS_OK;
993// }
994//
995// #else /*!defined(DRV_RTC_OFF)*/
996//
997// DCL_STATUS DclRTC_Initialize(void)
998// {
999// return STATUS_FAIL;
1000// }
1001//
1002// DCL_HANDLE DclRTC_Open(DCL_DEV dev, DCL_FLAGS flags)
1003// {
1004// return DCL_HANDLE_INVALID;
1005// }
1006//
1007// DCL_STATUS DclRTC_ReadData(DCL_HANDLE handle, DCL_BUFF *buff, DCL_BUFF_LEN *buf_len, DCL_OPTIONS options)
1008// {
1009// return STATUS_UNSUPPORTED;
1010// }
1011//
1012// DCL_STATUS DclRTC_WriteData(DCL_HANDLE handle, DCL_BUFF *buff, DCL_BUFF_LEN *buf_len, DCL_OPTIONS options)
1013// {
1014// return STATUS_UNSUPPORTED;
1015// }
1016//
1017// DCL_STATUS DclRTC_Configure(DCL_HANDLE handle, DCL_CONFIGURE_T *configure)
1018// {
1019// return STATUS_UNSUPPORTED;
1020// }
1021//
1022// DCL_STATUS DclRTC_RegisterCallback(DCL_HANDLE handle, DCL_EVENT event, PFN_DCL_CALLBACK callback)
1023// {
1024// return STATUS_FAIL;
1025// }
1026//
1027// DCL_STATUS DclRTC_Control(DCL_HANDLE handle, DCL_CTRL_CMD cmd, DCL_CTRL_DATA_T *data)
1028// {
1029// return STATUS_FAIL;
1030// }
1031//
1032// DCL_STATUS DclRTC_Close(DCL_HANDLE handle)
1033// {
1034// return STATUS_FAIL;
1035// }
1036//
1037//
1038// #endif /*!defined(DRV_RTC_OFF)*/
1039//
1040// #else
1041
1042DCL_STATUS DclRTC_Initialize(void)
1043{
1044 return STATUS_FAIL;
1045}
1046
1047DCL_HANDLE DclRTC_Open(DCL_DEV dev, DCL_FLAGS flags)
1048{
1049 return STATUS_UNSUPPORTED;
1050}
1051
1052DCL_STATUS DclRTC_ReadData(DCL_HANDLE handle, DCL_BUFF *buff, DCL_BUFF_LEN *buf_len, DCL_OPTIONS options)
1053{
1054 return STATUS_UNSUPPORTED;
1055}
1056
1057DCL_STATUS DclRTC_WriteData(DCL_HANDLE handle, DCL_BUFF *buff, DCL_BUFF_LEN *buf_len, DCL_OPTIONS options)
1058{
1059 return STATUS_UNSUPPORTED;
1060}
1061
1062DCL_STATUS DclRTC_Configure(DCL_HANDLE handle, DCL_CONFIGURE_T *configure)
1063{
1064 return STATUS_UNSUPPORTED;
1065}
1066
1067DCL_STATUS DclRTC_RegisterCallback(DCL_HANDLE handle, DCL_EVENT event, PFN_DCL_CALLBACK callback)
1068{
1069 return STATUS_FAIL;
1070}
1071
1072DCL_STATUS DclRTC_Control(DCL_HANDLE handle, DCL_CTRL_CMD cmd, DCL_CTRL_DATA_T *data)
1073{
1074 return STATUS_FAIL;
1075}
1076
1077DCL_STATUS DclRTC_Close(DCL_HANDLE handle)
1078{
1079 return STATUS_FAIL;
1080}
1081
1082
1083// #endif //#ifdef DCL_RTC_INTERFACE
1084