ap/app/zte_comm/rtc-service/rtc-service.c

/**
 * @file rtc-service.c
 * @brief Implementation of Sanechips
 *
 * Copyright (C) 2017 Sanechips Technology Co., Ltd.
 * @author linxu Gebin
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 as
 * published by the Free Software Foundation.
 *
 */

/*******************************************************************************
 *                           Include header files                              *
 ******************************************************************************/
#include "rtc-service.h"
#include "hotplug.h"
#include <limits.h>

/*******************************************************************************
 *                        Global variable definitions                          *
 ******************************************************************************/
int g_rtc_fd = 0;
struct list_head rtc_timer_list;
struct list_head rtc_alarm_list;
#define RTC_ALARM_TIMEOUT_MSG  "PMIC RTC ALARM IRQ COME"
#define RTC_TIMER_TIMEOUT_MSG  "PMIC RTC TIMER IRQ COME"

#ifdef PRODUCT_NOT_USE_RTC
time_t g_set_softtime;
#define RTC_USE_SOFTTIMER_ID      300 //µ±Ã»ÓÐrtcʱ£¬Ô­ÏÈʹÓÃrtc¶¨Ê±Æ÷µÄÓÐrtcͳһÊÊÅäµ½softtimerÉÏ£¬Õû¸ö¿ò¼Ü²»±ä
#endif
/*******************************************************************************
 *                         Local variable definitions                          *
 ******************************************************************************/
static pthread_t rtc_looper_id = 0;
static int g_clean_flag = 0;
static int g_time_offset = 2;   //ÔÊÐíÎó²î·¶Î§£¬ÊÊÅärtcºÍOSʱÖÓƵÂʲ»Ò»ÖÂÎÊÌâ
/*******************************************************************************
 *                      Local function implementations                         *
 ******************************************************************************/
static int open_rtc(void);
static void close_rtc(int fd);
static void* rtc_looper();
static int start_rtc_thread();
static int handle_get_time(MSG_BUF *pmsg_buf);
static int handle_set_time(MSG_BUF *pmsg_buf);
static int handle_alarm_add(MSG_BUF *pmsg_buf);
static int handle_alarm_del(MSG_BUF *pmsg_buf);
static int handle_alarm_timeout(MSG_BUF *pmsg_buf);
static int process_msg(MSG_BUF *pmsg_buf);
static int process_msg_rtc_cap(MSG_BUF *pmsg_buf);
static void msg_looper(void);
static void update_timer_remain(int new_remian);
static void alarm_fix_value(struct list_head *rtc_list);
static void alarm_restart(struct list_head *rtc_list);
static void  update_alarm();
static void alarm_adjust_value(int time);
static long get_RtcTime();
static void convert_time(time_t timeSec, struct tm * tmTime, TIME_CONVERT_TYPE type);
static void convert_time(time_t timeSec, struct tm * tmTime, TIME_CONVERT_TYPE type)
{
    time_t tmpTime = 0;
    if (tmTime == NULL)
    {
        slog(RTC_PRINT, SLOG_ERR, "rtc-service: wrong input param, check it! \n");
        return ;
    }
    tmpTime = timeSec;

    if (type == CONVERT_TYPE_RTC)
    {
        gmtime_r((time_t*)&tmpTime, tmTime);
    }
    else
    {
        localtime_r((time_t*)&tmpTime, tmTime);
    }

    slog(RTC_PRINT, SLOG_DEBUG,
         "Time:%ld, tm_year:%d, tm_mon:%d, tm_hour:%d, tm_min:%d, tm_sec:%d, tm_yday:%d, tm_mday:%d, tm_wday:%d \n",
         mktime(tmTime), tmTime->tm_year, tmTime->tm_mon, tmTime->tm_hour, tmTime->tm_min, tmTime->tm_sec, tmTime->tm_yday,
         tmTime->tm_mday, tmTime->tm_wday);

}

static long get_RtcTime()
{
    long curRtcTime = 0;
    struct rtc_time rtc_tm = {0};
    struct tm tmp = {0};
    if (g_rtc_fd <= 0)
    {
        slog(RTC_PRINT, SLOG_ERR, "rtc-service: g_rtc_fd: %d , invalid fd. \n", g_rtc_fd);
        return -1;
    }

    if (ioctl(g_rtc_fd, RTC_RD_TIME, &rtc_tm) < 0) // cov M CHECKED_RETURN
    {
        slog(RTC_PRINT, SLOG_ERR, "ioctl fail.\n");
    }
    tmp.tm_sec = rtc_tm.tm_sec;
    tmp.tm_min = rtc_tm.tm_min;
    tmp.tm_hour = rtc_tm.tm_hour;
    tmp.tm_mon = rtc_tm.tm_mon;
    tmp.tm_year = rtc_tm.tm_year;
    tmp.tm_mday = rtc_tm.tm_mday;
    tmp.tm_wday = rtc_tm.tm_wday;
    tmp.tm_yday = rtc_tm.tm_yday;
    tmp.tm_isdst = rtc_tm.tm_isdst;

    curRtcTime = mktime(&tmp);
    slog(RTC_PRINT, SLOG_DEBUG, "rtc-service: curRtcTime: %ld . \n", curRtcTime);
    return curRtcTime;
}
static void write_lockfile(char *filepath, char *setbuf)
{
    int f, len = 0;

    f = open(filepath, O_RDWR);
    if (f == -1)
    {
        return;
    }

    len = strlen(setbuf);
    if (write(f, setbuf, len) != len)
    {
    }
    else
    {
    }
    close(f);
}


static void wake_rtc_lock()
{
    write_lockfile("/sys/power/wake_lock", "rtc_lock");
}

static void wake_rtc_unlock()
{
    write_lockfile("/sys/power/wake_unlock", "rtc_lock");
}

static void wake_rtc_io_lock()
{
    write_lockfile("/sys/power/wake_lock", "rtc_io_lock");
}

static void wake_rtc_io_unlock()
{
    write_lockfile("/sys/power/wake_unlock", "rtc_io_lock");
}

static void wake_timeout_lock(char *lockname, unsigned long interval)
{
    char cmd[100] = {0};
    sprintf(cmd, "echo %s %lu > /sys/power/wake_lock", lockname, interval);
    soft_system(cmd);
}

static int init_rtc_alarm(void)
{
    FILE* fp = NULL;
    int gap_start = 0;
    int gap_end = 0;
    size_t size = 0;
    long cur_rtc_time = 0;
    ALARM_T* iter = NULL;
    RTC_DATA_BUF  buf = {0};
    int ret = -1;

    //	cur_rtc_time = get_RtcTime();
    cur_rtc_time = time(0);
    if ((fp = (FILE*)fopen(RTC_ALARM_DATA, "rb")) == NULL)
    {
        slog(RTC_PRINT, SLOG_ERR, "rtc-service: failed to open %s \n", RTC_ALARM_DATA);
        return -1;
    }

    while (1)
    {
        size = fread(&gap_start, sizeof(int), 1, fp);//0xa5a5
        if (0 == size || gap_start != DATA_S || feof(fp) != 0 )
        {
            break;
        }

        iter = (ALARM_T*)malloc(sizeof(ALARM_T));
        if (iter)
        {
            memset(iter, 0, sizeof(ALARM_T));
        }
        else
        {
            fclose(fp);
            return -1;
        }

        size = fread(iter, sizeof(ALARM_T), 1, fp);//struct
        if (0 == size || feof(fp) != 0) //check the end of the file
        {
            memset(iter, 0, sizeof(ALARM_T));//kw
            free(iter);
            break;
        }

        size = fread(&gap_end, sizeof(int), 1, fp);//0x5a5a
        if (0 == size || gap_end != DATA_E  || feof(fp) != 0)
        {
            memset(iter, 0, sizeof(ALARM_T));//kw
            free(iter);
            break;
        }

        if (iter->interval < 0 || iter->interval > LONG_MAX - 1)
        {
            iter->interval = 0 ;
        }


        if (iter->time_val < 0 || iter->time_val > LONG_MAX - 1)
        {
            iter->time_val = 0 ;
        }


        if (cur_rtc_time > iter->interval + iter->time_val)
        {
            buf.module = iter->rtc_id;
            buf.time_val = iter->time_val + iter->interval;
            slog(RTC_PRINT, SLOG_NORMAL, "rtc-service: handle_alarm_timeout: target:0x%x, rtc_id:0x%x, utc:%d, cur_rtc_time:%ld \n",
                 iter->module_id, buf.module, iter->is_utc, cur_rtc_time);
            ret = ipc_send_message2(MODULE_ID_RTC_SERVICE, iter->module_id, RTC_MSG_ALARM_ELAPSED, sizeof(RTC_DATA_BUF),
                                    (unsigned char*)&buf, 0);
            if (ret != 0)
            {
                slog(RTC_PRINT, SLOG_ERR, "rtc-service: ipc_send_message unexpected\n");
            }
        }
        list_add_tail(&iter->list, &rtc_alarm_list);
        if (feof(fp) != 0) //check the end of the file
        {
            break;
        }
    }
    fclose(fp);

    return 0;
}

static int save_rtc_alarm(void)
{
    FILE* fp = NULL;
    int gap_start = DATA_S;
    int gap_end = DATA_E;
    ALARM_T *temp = NULL;

    if ((fp = (FILE*)fopen(RTC_ALARM_DATA, "wb")) == NULL)
    {
        slog(RTC_PRINT, SLOG_ERR, "rtc-service: failed to open %s \n", RTC_ALARM_DATA);
        return -1;
    }

    if (!list_empty(&rtc_alarm_list))
    {
        list_for_each_entry(temp, &rtc_alarm_list, list)
        {
            if (temp->wakeup)
            {
                fwrite(&gap_start, sizeof(int), 1, fp);
                fwrite(temp, sizeof(ALARM_T), 1, fp);
                fwrite(&gap_end, sizeof(int), 1, fp);
            }
        }
    }

    fflush(fp);
    if (fsync(fileno(fp)) < 0)
    {
        // todo: cov M
    }
    fclose(fp);

    return 0;
}

/********************************************
 ¹¦ÄÜ:´ò¿ªrtc
 *******************************************/
static int open_rtc(void)
{
    int fd = 0;
    fd = open(RTC_DEV_NAME, O_RDWR);

    if (fd < 0)
    {
        slog(RTC_PRINT, SLOG_ERR, "rtc-service: Open %s error!\n", RTC_DEV_NAME);
        return fd;
    }
    slog(RTC_PRINT, SLOG_DEBUG, "rtc-service: Open %s OK!\n", RTC_DEV_NAME);
    return fd;
}

/********************************************
 ¹¦ÄÜ:¹Ø±Õrtc
 *******************************************/
static void close_rtc(int fd)
{
    if (fd < 0)
    {
        return;
    }

    close(fd);
}


/********************************************
 * handle_get_time
 * get RTC time.
 *******************************************/
static int handle_get_time(MSG_BUF *pmsg_buf)
{
    struct rtc_time rtc_tm = {0};
    int ret = 0;
    RTC_DATA_BUF * buf = pmsg_buf->aucDataBuf;

    slog(RTC_PRINT, SLOG_DEBUG, "rtc-service: handle_get_time NOOPS.\n");

    if (buf->cpu == RTC_CPU_CAP)
    {
        int cmd = RTC_MSG_GET_TIME;
        RTC_DATA_BUF  sendbuf = {0};
        unsigned long cur_sec = 0;

        ret = ioctl(g_rtc_fd, RTC_RD_TIME, &rtc_tm);
        slog(RTC_PRINT, SLOG_NORMAL,
             "rtc-service: handle_get_time tm_year:%d, tm_mon:%d, tm_hour:%d, tm_min:%d, tm_yday:%d, tm_mday:%d, tm_wday:%d.\n",
             rtc_tm.tm_year, rtc_tm.tm_mon, rtc_tm.tm_hour, rtc_tm.tm_min, rtc_tm.tm_yday, rtc_tm.tm_mday, rtc_tm.tm_wday);
        slog(RTC_PRINT, SLOG_NORMAL, "rtc-service: handle_get_time src_id:0x%x, buf->cpu:%d.\n", buf->srcModule, buf->cpu);

        cur_sec = mktime(&rtc_tm);
        sendbuf.srcModule = buf->srcModule;
        sendbuf.cpu = RTC_CPU_AP;
        sendbuf.ulSec = cur_sec;

        slog(RTC_PRINT, SLOG_NORMAL, "[rtc] handle_get_time: send to cap cmd:0x%x, srcMod:0x%x, cur_sec:%lu \n", cmd,
             sendbuf.srcModule, sendbuf.ulSec);
        ret = send_soc_msg(FAR_PS, MODULE_ID_RTC_SERVICE, cmd, sizeof(RTC_DATA_BUF), (void *)&sendbuf);
        if (ret != 0)
        {
            slog(RTC_PRINT, SLOG_ERR, "rtc-service: ipc_send_message unexpected,ret:%d\n", ret);;
        }
    }

    return 0;
}

/********************************************
 * ¹¦ÄÜ:ÉèÖÃrtcʱ¼ä
 *******************************************/
static int handle_set_time(MSG_BUF *pmsg_buf)
{
    time_t os_time = 0;
    struct tm tmTime = {0};
    struct rtc_time rtc_tm = {0};
    int ret = 0;

    slog(RTC_PRINT, SLOG_DEBUG, "rtc-service: handle_set_time enter.\n");
    memcpy(&os_time, pmsg_buf->aucDataBuf, sizeof(time_t));
    slog(RTC_PRINT, SLOG_DEBUG, "rtc-service: handle_set_time enter: set time: %ld \n", os_time);
    convert_time(os_time, &tmTime, CONVERT_TYPE_RTC);
    memcpy(&rtc_tm, &tmTime, sizeof(struct rtc_time));
    slog(RTC_PRINT, SLOG_ERR,
         "Time:%ld, tm_year:%d, tm_mon:%d, tm_hour:%d, tm_min:%d, tm_sec:%d, tm_yday:%d, tm_mday:%d, tm_wday:%d \n",
         mktime(&tmTime), rtc_tm.tm_year, rtc_tm.tm_mon, rtc_tm.tm_hour, rtc_tm.tm_min, tmTime.tm_sec, rtc_tm.tm_yday,
         rtc_tm.tm_mday, rtc_tm.tm_wday);

    ret = ioctl(g_rtc_fd, RTC_SET_TIME, &rtc_tm);
    slog(RTC_PRINT, SLOG_DEBUG, "rtc-service: RTC_SET_TIME ioctl ret = %d  exit.\n", ret);
    {
        char buf[32] = {0};
        snprintf(buf, 32, "AT+ZMMI=2,%d,%d\r\n", 1900 + rtc_tm.tm_year, 1 + rtc_tm.tm_mon);
        ret = get_modem_info(buf, NULL,  NULL);
        slog(RTC_PRINT, SLOG_ERR, "rtc-service: handle_set_time ret=%d %s\n", ret, buf);
    }
    return 0;
}

/********************************************
 * ¹¦ÄÜ:sntpͬ²½ÏµÍ³Ê±¼ä
 *******************************************/
static int handle_sntp_update(MSG_BUF *pmsg_buf)
{
    time_t os_time = 0;
    struct timeval time_tv = {0};
    int ret = 0;

    memcpy(&os_time, pmsg_buf->aucDataBuf, sizeof(time_t));

    time_tv.tv_sec = os_time;
    ret = settimeofday(&time_tv, NULL);
    if (ret != 0)
    {
        slog(RTC_PRINT, SLOG_ERR, "handle_sntp_update is fail,ret:%d \n", ret);
    }
    return 0;
}

/********************************************
 * ¹¦ÄÜ:Ôö¼Ó¶¨Ê±Æ÷
 *******************************************/
static int handle_alarm_add(MSG_BUF *pmsg_buf)
{
    //long cur_rtc_time = 0;

    struct rtc_time rtc_tm = {0};
    ALARM_T *pAlarm = 0;

    RTC_DATA_BUF *buf = pmsg_buf->aucDataBuf;
    ALARM_T *temp = NULL;
    int mark = 0;

    slog(RTC_PRINT, SLOG_DEBUG, "rtc-service: handle_alarm_add enter.\n");

    if (buf->ulSec <= 0)
    {
        slog(RTC_PRINT, SLOG_ERR, "rtc-service: handle_alarm_add invalid interval.\n");
        return -1;
    }

    pAlarm = malloc(sizeof(ALARM_T));
    if (pAlarm == NULL)
    {
        slog(RTC_PRINT, SLOG_ERR, "rtc-service: handle_alarm_add no memory.\n");
        return -1;
    }

    //»ñÈ¡µ±Ç°Ê±¼ä second
    if (ioctl(g_rtc_fd, RTC_RD_TIME, &rtc_tm) < 0) // cov M CHECKED_RETURN
    {
        slog(RTC_PRINT, SLOG_ERR, "ioctl fail.\n");
    }
    memcpy(&pAlarm->rtc_tm, &rtc_tm, sizeof(rtc_tm));

    pAlarm->rtc_id = buf->module;
    pAlarm->module_id = buf->srcModule;
    pAlarm->interval = buf->ulSec ;   //  count down time
    pAlarm->remain_time = buf->ulSec; // remain count down time
    pAlarm->wakeup = buf->wakeup;
    pAlarm->is_utc = buf->is_utc;
    pAlarm->cpu = buf->cpu;
    pAlarm->time_val = buf->time_val;// cur_rtc_time is mktime(&local_tm)
    //pAlarm->time_val = get_RtcTime();// cur_rtc_time is mktime(&local_tm)

    slog(RTC_PRINT, SLOG_NORMAL,
         "rtc-service: handle_alarm_add pAlarm->interval is %ld ,pAlarm->time_val() is %ld, is_utc:%d.\n",
         pAlarm->interval, pAlarm->time_val, pAlarm->is_utc);
    /*
    	if (pAlarm->time_val + pAlarm->remain_time < cur_rtc_time) {
    		slog(RTC_PRINT, SLOG_NORMAL, "rtc-service handle_alarm_add error, pAlarm->remain_time = %ld, pAlarm->time_val = %ld, current= %ld\n", pAlarm->remain_time, pAlarm->time_val, cur_rtc_time);
    	}
    */

#ifdef PRODUCT_NOT_USE_RTC
    pAlarm->is_utc = 0; //´Ëģʽ϶¼°´timerÉèÖö¨Ê±Æ÷£¬²»Ö§³Öutc
    pAlarm->wakeup = 0;
#endif

    if (pAlarm->is_utc == 0)
    {
        if (!list_empty(&rtc_timer_list))
        {
            //update_timer_remain(pAlarm->remain_time);
            list_for_each_entry(temp, &rtc_timer_list, list)
            {
                if (temp->remain_time > pAlarm->remain_time)
                {
                    mark = 1;
                    list_add(&pAlarm->list, temp->list.prev);
                    break;
                }
            }
        }
        if (mark == 0)
        {
            list_add_tail(&pAlarm->list, &rtc_timer_list);
        }
        slog(RTC_PRINT, SLOG_DEBUG, "rtc-service: add rtc timer\n");
        alarm_restart(&rtc_timer_list);
    }
    else
    {
        if (!list_empty(&rtc_alarm_list))
        {
            list_for_each_entry(temp, &rtc_alarm_list, list)
            {
                if (temp->interval + temp->time_val > pAlarm->interval + pAlarm->time_val)
                {
                    mark = 1;
                    list_add(&pAlarm->list, temp->list.prev);
                    break;
                }
            }
        }
        if (mark == 0)
        {
            list_add_tail(&pAlarm->list, &rtc_alarm_list);
        }

        if (pAlarm->wakeup)
        {
            save_rtc_alarm();
        }

        slog(RTC_PRINT, SLOG_DEBUG, "rtc-service: add rtc alarm \n");
        alarm_restart(&rtc_alarm_list);
    }

    return 0;
}

/********************************************
 * ¹¦ÄÜ:°´µ±Ç°¶¨Ê±Æ÷Ê£Óàʱ¼ä¸üж¨Ê±Æ÷
 *******************************************/
static void update_timer_remain(int new_remian)
{
    if (list_empty(&rtc_timer_list))
    {
        return;
    }
    int ret, remain_time;
    ALARM_T *pTmp;
    //list_entry(pTmp, &rtc_timer_list, list);
    pTmp = list_entry(rtc_timer_list.next, ALARM_T, list);

#ifdef PRODUCT_NOT_USE_RTC
    time_t cur = time(NULL);
    remain_time = g_set_softtime + pTmp->remain_time - cur;
    if ((remain_time > pTmp->remain_time) || (remain_time <= 0))
    {
        slog(RTC_PRINT, SLOG_ERR, "rtc-service: cur:%u, set:%u, remain:%u, inveral:%u\n", cur, g_set_softtime, remain_time,
             pTmp->remain_time);
        //ʱ¼ä·¢Éú¹ýÖØÖõȣ¬Ö±½ÓÉèÖö¨Ê±Æ÷µ½£¬¸÷Ä£¿éÓ¦ÔÚÊÕµ½RTC_MSG_TIME_CHANGEDÏûϢʱ¼°Ê±¸üж¨Ê±Æ÷
        remain_time = 0;
    }
#else
    ret = ioctl(g_rtc_fd, ZX234290_GET_TIMER_REMAIN, &remain_time);
#endif
    if (ret < 0)
    {
        slog(RTC_PRINT, SLOG_ERR, "rtc-service: handle_alarm_add no free alarm remain_time %d  %s errno.\n", errno,
             strerror(errno));
        //  return -1;
    }
    //if(remain_time > new_remian)
    {
        slog(RTC_PRINT, SLOG_NORMAL, "rtc-service: pTmp->remain_time: %d, rtc remain_time: %d \n", pTmp->remain_time,
             remain_time);
        alarm_adjust_value(pTmp->remain_time - remain_time);
        alarm_fix_value(&rtc_timer_list);
    }
}

/********************************************
 * ¹¦ÄÜ:ɾ³ýÏûÏ¢Ô´Ä£¿éµÄËùÓж¨Ê±Æ÷
 *******************************************/
static int handle_alarm_del(MSG_BUF *pmsg_buf)
{
    RTC_DATA_BUF * buf = pmsg_buf->aucDataBuf;
    ALARM_T *pTmp, *pTmp1;
    int wakeup = 0;

    slog(RTC_PRINT, SLOG_DEBUG, "rtc-service: handle_alarm_del enter.\n");
    list_for_each_entry_safe(pTmp, pTmp1, &rtc_timer_list, list)
    {
        slog(RTC_PRINT, SLOG_DEBUG, "rtc-service: handle_alarm_del timer module:0x%x - 0x%x, src:0x%x - 0x%x.\n",
             buf->module, pTmp->rtc_id, buf->srcModule, pTmp->module_id);
        if ((buf->module == pTmp->rtc_id) && (buf->srcModule == pTmp->module_id) && (buf->cpu == pTmp->cpu))
        {
            slog(RTC_PRINT, SLOG_NORMAL, "rtc-service: handle_alarm_del timer module:0x%x , src:0x%x , cpu:%d \n",
                 buf->module, buf->srcModule, buf->cpu);
            list_del(&pTmp->list);
            free(pTmp);
            break;
        }
    }

    list_for_each_entry_safe(pTmp, pTmp1, &rtc_alarm_list, list)
    {
        slog(RTC_PRINT, SLOG_DEBUG, "rtc-service: handle_alarm_del alarm module:0x%x - 0x%x, src:0x%x - 0x%x.\n",
             buf->module, pTmp->rtc_id, buf->srcModule, pTmp->module_id);
        if ((buf->module == pTmp->rtc_id) && (buf->srcModule == pTmp->module_id) && (buf->cpu == pTmp->cpu))
        {
            slog(RTC_PRINT, SLOG_NORMAL, "rtc-service: handle_alarm_del alarm module:0x%x , src:0x%x , cpu:%d \n",
                 buf->module, buf->srcModule, buf->cpu);
            wakeup = pTmp->wakeup;
            list_del(&pTmp->list);
            free(pTmp);
            break;
        }
    }

    if (wakeup)
    {
        save_rtc_alarm();
    }

    slog(RTC_PRINT, SLOG_DEBUG, "rtc-service: handle_alarm_del exit.\n");

    return 0;
}

void send_ok_del_rsp(MSG_BUF *pmsg_buf)
{
    RTC_DATA_BUF * buf = pmsg_buf->aucDataBuf;

    if (buf->cpu == RTC_CPU_CAP)
    {
        int ret = 0;
        RTC_DATA_BUF sendbuf = {0};
        sendbuf.cpu = RTC_CPU_AP;
        sendbuf.module = buf->module;
        sendbuf.srcModule = buf->srcModule;
        ret = send_soc_msg(FAR_PS, MODULE_ID_RTC_SERVICE, RTC_MSG_DEL_ALARM, sizeof(RTC_DATA_BUF), (void *)&sendbuf);
        if (ret != 0)
        {
            slog(RTC_PRINT, SLOG_ERR, "send_ok_del_rsp: failed,ret:%d\n", ret);
        }
    }
}
/********************************************
 *¹¦ÄÜ:¶¨Ê±Æ÷³¬Ê±´¦Àí
 *******************************************/
static int handle_alarm_timeout(MSG_BUF *pmsg_buf)
{
    long ret = -1;
    ALARM_T *pAlarm;
    RTC_DATA_BUF  buf = {0};
    long rtc_report_time = 0;
    long alarm_node_time = 0;
    enum RTC_MSG_CMD cmd = pmsg_buf->usMsgCmd;
    int wakeup = 0;

    if (cmd == RTC_MSG_TIMER_TIMEOUT && !list_empty(&rtc_timer_list))
    {
        slog(RTC_PRINT, SLOG_DEBUG, "rtc-service: rtc timer timeout\n");
        pAlarm = list_entry(rtc_timer_list.next, ALARM_T, list);
    }
    else if (cmd == RTC_MSG_ALARM_TIMEOUT && !list_empty(&rtc_alarm_list))
    {
        slog(RTC_PRINT, SLOG_DEBUG, "rtc-service: rtc alarm timeout\n");
        pAlarm = list_entry(rtc_alarm_list.next, ALARM_T, list);
        rtc_report_time = atol(pmsg_buf->aucDataBuf);
        if (rtc_report_time < 0 || rtc_report_time > LONG_MAX - 1)
        {
            rtc_report_time = 0;
        }
        alarm_node_time = pAlarm->interval + pAlarm->time_val;
        if ((rtc_report_time > alarm_node_time && (rtc_report_time - alarm_node_time) > g_time_offset)
                || (alarm_node_time > rtc_report_time && (alarm_node_time - rtc_report_time) > g_time_offset))
        {
            slog(RTC_PRINT, SLOG_ERR, "rtc-service: rtc node was deleted, timeout unexpected; node:%ld, rtc:%ld \n",
                 alarm_node_time, rtc_report_time);
            alarm_fix_value(&rtc_alarm_list);

            if (pAlarm->wakeup)
            {
                save_rtc_alarm();
            }

            alarm_restart(&rtc_alarm_list);
            slog(RTC_PRINT, SLOG_DEBUG, "rtc-service: handle_alarm_timeout restart alarm.\n");
            return 0;
        }
        buf.time_val = alarm_node_time;
    }
    else
    {
        slog(RTC_PRINT, SLOG_ERR, "rtc-service: timeout unexpected\n");
        return -1;
    }

    wakeup = pAlarm->wakeup;
    list_del(&pAlarm->list);
    buf.module = pAlarm->rtc_id;
    buf.srcModule = pAlarm->module_id;
    slog(RTC_PRINT, SLOG_NORMAL, "rtc-service: handle_alarm_timeout: target:0x%x, rtc_id:0x%x, utc:%d \n",
         pAlarm->module_id, buf.module, pAlarm->is_utc);
    if (pAlarm->cpu == RTC_CPU_AP)
    {
        ret = ipc_send_message2(MODULE_ID_RTC_SERVICE, pAlarm->module_id, RTC_MSG_ALARM_ELAPSED, sizeof(RTC_DATA_BUF),
                                (unsigned char*)&buf, 0);
        if (ret != 0)
        {
            slog(RTC_PRINT, SLOG_ERR, "rtc-service: ipc_send_message unexpected,ret:%d\n", ret);
        }
    }
    else
    {
        buf.module = pAlarm->rtc_id;
        buf.srcModule = pAlarm->module_id;
        buf.cpu = RTC_CPU_AP;
        buf.is_utc = pAlarm->is_utc;

        slog(RTC_PRINT, SLOG_NORMAL, "[rtc] handle_alarm_timeout: send to cap cmd:0x%x, srcMod:0x%x, module:0x%x, utc:%d \n",
             cmd, buf.srcModule, buf.module, pAlarm->is_utc);
        ret = send_soc_msg(FAR_PS, MODULE_ID_RTC_SERVICE, cmd, sizeof(RTC_DATA_BUF), (void *)&buf);
        if (ret != 0)
        {
            slog(RTC_PRINT, SLOG_ERR, "rtc-service: ipc_send_message unexpected,ret:%d\n", ret);;
        }
    }
    if (pAlarm->is_utc == 0)
    {
        alarm_adjust_value(pAlarm->remain_time);
        alarm_fix_value(&rtc_timer_list);
        alarm_restart(&rtc_timer_list);
        slog(RTC_PRINT, SLOG_DEBUG, "rtc-service: handle_alarm_timeout restart imer.\n");
    }
    else
    {
        alarm_fix_value(&rtc_alarm_list);
        if (wakeup)
        {
            save_rtc_alarm();
        }
        alarm_restart(&rtc_alarm_list);
        slog(RTC_PRINT, SLOG_DEBUG, "rtc-service: handle_alarm_timeout restart alarm.\n");
    }

    free(pAlarm);
    slog(RTC_PRINT, SLOG_DEBUG, "rtc-service: handle_alarm_timeout exit.\n");
    return 0;
}

/********************************************
 * ¹¦ÄÜ:ɾ³ý¹Ø»ú²»±£´æµÄ¶¨Ê±Æ÷
 *******************************************/
static void handle_del_all(MSG_BUF *pmsg_buf)
{
    ALARM_T *pTmp, *pTmp1;

    update_timer_remain(0);
    list_for_each_entry_safe(pTmp, pTmp1, &rtc_timer_list, list)
    {
        if (pTmp->wakeup == 0)
        {
            list_del(&pTmp->list);
            free(pTmp);
        }
    }
    alarm_restart(&rtc_timer_list);

    list_for_each_entry_safe(pTmp, pTmp1, &rtc_alarm_list, list)
    {
        if (pTmp->wakeup == 0)
        {
            list_del(&pTmp->list);
            free(pTmp);
        }
    }
    alarm_restart(&rtc_alarm_list);
}

/********************************************
 * ¹¦ÄÜ:sntpͬ²½³É¹¦ºó£¬¸üÐÂalarm_list
 *******************************************/
static void  update_alarm()
{
    ALARM_T *pTmp, *pTmp1;
    //long sec = get_RtcTime();
    long sec = time(0);
    RTC_DATA_BUF  buf = {0};

#ifdef PRODUCT_NOT_USE_RTC
    list_for_each_entry_safe(pTmp, pTmp1, &rtc_timer_list, list)
    {
        buf.module = pTmp->rtc_id;
        ipc_send_message2(MODULE_ID_RTC_SERVICE, pTmp->module_id, RTC_MSG_TIME_CHANGED, sizeof(RTC_DATA_BUF),
                          (unsigned char*)&buf, 0);
        if (pTmp->is_utc)
        {
            if (pTmp->interval + pTmp->time_val < sec)
            {
                list_del(&pTmp->list);
                slog(RTC_PRINT, SLOG_NORMAL, "rtc-service: delete  ELAPSED timer, alarm_id(%d), alarm_time(%ld).\n", pTmp->rtc_id,
                     (pTmp->interval + pTmp->time_val));
                free(pTmp);
            }
            else
            {
                pTmp->remain_time = pTmp->interval + pTmp->time_val - sec;
                slog(RTC_PRINT, SLOG_NORMAL, "rtc-service: timer adjust, alarm_id(%d), alarm_time(%ld), remain(%ld).\n", pTmp->rtc_id,
                     (pTmp->interval + pTmp->time_val), pTmp->remain_time);
            }
        }
    }
    alarm_restart(&rtc_timer_list);
#else
    list_for_each_entry_safe(pTmp, pTmp1, &rtc_alarm_list, list)
    {
        buf.module = pTmp->rtc_id;
        ipc_send_message2(MODULE_ID_RTC_SERVICE, pTmp->module_id, RTC_MSG_TIME_CHANGED, sizeof(RTC_DATA_BUF),
                          (unsigned char*)&buf, 0);
        if (pTmp->interval + pTmp->time_val < sec)
        {
            list_del(&pTmp->list);
            slog(RTC_PRINT, SLOG_NORMAL, "rtc-service: delete  ELAPSED alarm, alarm_id(%d), alarm_time(%ld).\n", pTmp->rtc_id,
                 (pTmp->interval + pTmp->time_val));
            free(pTmp);
        }
    }
    alarm_restart(&rtc_alarm_list);
#endif
    slog(RTC_PRINT, SLOG_NORMAL, "rtc-service: update_alarm exit cur_rtc_time: % ld.\n", sec);
}

/********************************************
 * ¹¦ÄÜ:¸üж¨Ê±Æ÷Ê£Óàʱ¼ä
 *******************************************/
static void alarm_adjust_value(int time)
{
    ALARM_T * temp;
    list_for_each_entry(temp, &rtc_timer_list, list)
    {
        temp->remain_time -= time;
    }
}

/********************************************
 *¹¦ÄÜ: ɾ³ýÎÞЧ¶¨Ê±Æ÷
 *******************************************/
static void alarm_fix_value(struct list_head *rtc_list)
{
    ALARM_T *pTmp, *pTmp1;
    RTC_DATA_BUF  buf = {0};
    int wakeup = 0;
    int ret = 0;
    enum RTC_MSG_CMD cmd = 0;

    if (rtc_list == &rtc_timer_list)
    {
        list_for_each_entry_safe(pTmp, pTmp1, rtc_list, list)
        {
            if (pTmp->remain_time <= 0)
            {
                buf.module = pTmp->rtc_id;
                if (pTmp->cpu == RTC_CPU_CAP)
                {
                    buf.srcModule = pTmp->module_id;
                    buf.cpu = RTC_CPU_AP;
                    buf.is_utc = pTmp->is_utc;
                    cmd = RTC_MSG_TIMER_TIMEOUT;
                    slog(RTC_PRINT, SLOG_NORMAL, "[rtc] handle_alarm_timeout: send to cap cmd:0x%x, srcMod:0x%x, module:0x%x, utc:%d \n",
                         cmd, buf.srcModule, buf.module, buf.is_utc);
                    ret = send_soc_msg(FAR_PS, MODULE_ID_RTC_SERVICE, cmd, sizeof(RTC_DATA_BUF), (void *)&buf);
                    if (ret != 0)
                    {
                        slog(RTC_PRINT, SLOG_ERR, "rtc-service: send_soc_msg unexpected,ret:%d\n", ret);;
                    }
                }
                else
                {
                    ipc_send_message2(MODULE_ID_RTC_SERVICE, pTmp->module_id, RTC_MSG_ALARM_ELAPSED, sizeof(RTC_DATA_BUF),
                                      (unsigned char*)&buf, 0);
                }
                list_del(&pTmp->list);
                free(pTmp);
            }
        }
    }
    else if (rtc_list == &rtc_alarm_list)
    {
        list_for_each_entry_safe(pTmp, pTmp1, rtc_list, list)
        {
            if (pTmp->time_val + pTmp->interval <= (time(0) + g_time_offset))
            {
                if (pTmp->wakeup)
                {
                    wakeup = pTmp->wakeup;
                }

                buf.module = pTmp->rtc_id;
                buf.time_val = pTmp->time_val + pTmp->interval;
                if (pTmp->cpu == RTC_CPU_CAP)
                {
                    buf.srcModule = pTmp->module_id;
                    buf.cpu = RTC_CPU_AP;
                    buf.is_utc = pTmp->is_utc;
                    cmd = RTC_MSG_ALARM_TIMEOUT;
                    slog(RTC_PRINT, SLOG_NORMAL, "[rtc] handle_alarm_timeout: send to cap cmd:0x%x, srcMod:0x%x, module:0x%x, utc:%d \n",
                         cmd, buf.srcModule, buf.module, buf.is_utc);
                    ret = send_soc_msg(FAR_PS, MODULE_ID_RTC_SERVICE, cmd, sizeof(RTC_DATA_BUF), (void *)&buf);
                    if (ret != 0)
                    {
                        slog(RTC_PRINT, SLOG_ERR, "rtc-service: send_soc_msg unexpected,ret:%d\n", ret);;
                    }
                }
                else
                {
                    ipc_send_message2(MODULE_ID_RTC_SERVICE, pTmp->module_id, RTC_MSG_ALARM_ELAPSED, sizeof(RTC_DATA_BUF),
                                      (unsigned char*)&buf, 0);
                }
                list_del(&pTmp->list);
                free(pTmp);
            }
        }

        if (wakeup)
        {
            save_rtc_alarm();
        }
    }
    slog(RTC_PRINT, SLOG_DEBUG, "rtc-service: alarm_fix_value exit.\n");
}

#ifdef PRODUCT_NOT_USE_RTC
/*¶ÔӦûÓÐrtcµÄ²úÆ·£¬rtc¶¨Ê±Æ÷ÊÊÅäµ½softtimerµÄ»Øµ÷º¯Êý*/
static void rtc_set_softtimer_cb(void *param)
{
    int ret = -1;

    slog(NET_PRINT, SLOG_ERR, "rtc-service: rtc_adapt_softtimer_cb \n");

    ret = ipc_send_message(MODULE_ID_RTC_SERVICE, MODULE_ID_RTC_SERVICE, RTC_MSG_TIMER_TIMEOUT, 0, 0, 0);;
    if (ret != 0)
    {
        slog(MISC_PRINT, SLOG_ERR, "rtc-service: set rtc timer send msg failed \n");
    }
    return 0;
}
#endif

/********************************************
 * ¹¦ÄÜ:ÖØÆô¶¨Ê±Æ÷£¬Ã»ÓÐÔò¹Ø±Õ¶¨Ê±Æ÷
 *******************************************/
static void alarm_restart(struct list_head *rtc_list)
{
    int ret = 0;
    //struct tm *p_tm = 0;
    struct tm ret_tm = {0};
    struct rtc_wkalrm alarm = {0};
    long tVal = 0;
    long remain = -1;
    ALARM_T *ptmp = NULL;
    long cur_rtc_time = time(0);
    RTC_DATA_BUF  buf = {0};
NEXT:
    if (!list_empty(rtc_list))
    {
        ptmp = list_entry(rtc_list->next, ALARM_T, list);
        slog(RTC_PRINT, SLOG_DEBUG, "rtc-service: alarm_restart enter.\n");
        memset(&buf, 0, sizeof(RTC_DATA_BUF));
        if (ptmp->is_utc == 0)
        {
#ifdef PRODUCT_NOT_USE_RTC
            g_set_softtime = time(NULL);
            sc_timer_delete(RTC_USE_SOFTTIMER_ID);
            ret = sc_timer_create(RTC_USE_SOFTTIMER_ID, TIMER_FLAG_ONCE, ptmp->remain_time * 1000, rtc_set_softtimer_cb, NULL);
#else
            ret = ioctl(g_rtc_fd, ZX234290_SET_TIMER, ptmp->remain_time);
#endif
            if (ret != 0)
            {
                slog(RTC_PRINT, SLOG_ERR, "rtc-service: alarm_restart timer: set failed, ret:%d \n", ret);
                return;
            }
            slog(RTC_PRINT, SLOG_NORMAL,
                 "rtc-service: alarm_restart: set timer ok, remain_time:%ld, cur_rtc_time:%ld, module:0x%x, rtc_id:0x%x\n",
                 ptmp->remain_time, cur_rtc_time, ptmp->module_id, ptmp->rtc_id);
        }
        else
        {
            tVal = ptmp->interval + ptmp->time_val;
            remain = tVal - cur_rtc_time;
            if (remain <= g_time_offset)
            {
                //¹ýʱ¶¨Ê±Æ÷¶ªÆú´¦Àí£¬Èç¹û¶àÄ£¿éÕýºÃÉèµÄ»ù±¾ÔÚͬһ¸öʱ¼äµã£¬ºóÕ߻ᱻ¶ªÆú£¬¿¼ÂÇÐ޸ijÉÖ±½Ó֪ͨģ¿éʱ¼äµ½
                slog(RTC_PRINT, SLOG_ERR,
                     "rtc-service: remain time error, time_set:%ld, remain:%ld, alarmer:%ld, interval:%ld, current:%ld, module:0x%x, rtc_id:0x%x\n",
                     ptmp->time_val, remain, tVal, ptmp->interval, cur_rtc_time, ptmp->module_id, ptmp->rtc_id);
                buf.module = ptmp->rtc_id;
                buf.time_val = ptmp->time_val + ptmp->interval;
                ipc_send_message2(MODULE_ID_RTC_SERVICE, ptmp->module_id, RTC_MSG_ALARM_ELAPSED, sizeof(RTC_DATA_BUF),
                                  (unsigned char*)&buf, 0);
                list_del(&ptmp->list);
                free(ptmp);
                ptmp = NULL;
                goto NEXT;
            }

            //localtime_r(&tVal, &ret_tm);
            gmtime_r(&tVal, &ret_tm);
            memcpy(&alarm.time, &ret_tm, sizeof(struct rtc_time));
            alarm.enabled = 1;

            /*Ê×ÏÈ´ò¿ªalarm ÖжÏ*/
            ret = ioctl(g_rtc_fd, RTC_AIE_ON);
            if (ret != 0)
            {
                slog(RTC_PRINT, SLOG_ERR, "rtc-service: open alarm failed, ret:%d\n", ret);
                return;
            }

            /*ÉèÖÃalarm ʱ¼ä*/
            ret = ioctl(g_rtc_fd, RTC_WKALM_SET, &alarm);
            if (ret != 0)
            {
                slog(RTC_PRINT, SLOG_ERR, "rtc-service: set alarm failed, ret:%d\n", ret);
                return;
            }
            slog(RTC_PRINT, SLOG_NORMAL,
                 "rtc-service: alarm_restart set alarm ok, remain_time:%ld, cur_rtc_time:%ld, module:0x%x, rtc_id:0x%x \n", remain,
                 cur_rtc_time, ptmp->module_id, ptmp->rtc_id);
        }
    }
    else
    {
        if (rtc_list == &rtc_timer_list)
        {
            //¹Ø±Õrtc time, Éè¼ä¸ôʱ¼äΪ0
            ret = ioctl(g_rtc_fd, ZX234290_TIMER_ENABLED, 0);
            if (ret != 0)
            {
                slog(RTC_PRINT, SLOG_ERR, "rtc-service: disable timer failed, ret:%d\n", ret);
                return;
            }
            slog(RTC_PRINT, SLOG_NORMAL, "rtc-service: alarm_restart disable timer ok \n");
        }
        else
        {
            /*¹Ø±Õalarm ÖжÏ*/
            ret = ioctl(g_rtc_fd, RTC_AIE_OFF);
            if (ret != 0)
            {
                slog(RTC_PRINT, SLOG_ERR, "rtc-service: disable alarm failed, ret:%d\n", ret);
                return;
            }
            slog(RTC_PRINT, SLOG_NORMAL, "rtc-service: alarm_restart disable alarm ok \n");
        }
    }
    slog(RTC_PRINT, SLOG_DEBUG, "rtc-service: alarm_restart exit.\n");
}

static void rtc_set_local_time(MSG_BUF *msg)
{
    struct tm set_tm = {0};
    struct timeval time_tv;

    slog(RTC_PRINT, SLOG_DEBUG, "rtc_set_local_time, %d, %d \n", sizeof(struct tm), msg->usDataLen);

    memcpy(&set_tm, msg->aucDataBuf, msg->usDataLen);

    slog(RTC_PRINT, SLOG_ERR, "rtc_set_local_time, year:%d, month:%d, day:%d, hour:%d, min:%d, sec:%d, wday:%d \n",
         set_tm.tm_year, set_tm.tm_mon, set_tm.tm_mday, set_tm.tm_hour, set_tm.tm_min, set_tm.tm_sec, set_tm.tm_wday);

    time_tv.tv_sec = mktime(&set_tm);
    if (time_tv.tv_sec < 0)
    {

        slog(RTC_PRINT, SLOG_DEBUG, "mktime fail, set time_tv.tv_sec to 0 \n");
        time_tv.tv_sec = 0;
    }
    time_tv.tv_usec = 0;

    if (0 != settimeofday(&time_tv, NULL))
    {
        slog(RTC_PRINT, SLOG_ERR, "rtc_set_local_time failed \n");
    }
}

/********************************************
 * process_msg
 * handle the specified MSG.
 *******************************************/
static int process_msg(MSG_BUF *pmsg_buf)
{
    enum RTC_MSG_CMD cmd = pmsg_buf->usMsgCmd;
    unsigned short req_cmd = 0;

    switch (cmd)
    {
        case RTC_MSG_GET_TIME:
            slog(RTC_PRINT, SLOG_NORMAL, "rtc-service: process_msg RTC_MSG_GET_TIME, src:0x%x.\n", pmsg_buf->src_id);
            handle_get_time(pmsg_buf);
            break;
        case RTC_MSG_SET_TIME:
            security_log(pmsg_buf->src_id, "set time");
            slog(RTC_PRINT, SLOG_NORMAL, "rtc-service: process_msg RTC_MSG_SET_TIME, src:0x%x.\n", pmsg_buf->src_id);
            handle_set_time(pmsg_buf);
            update_alarm();
            break;
        case RTC_MSG_SNTP_UPDATE:
            handle_sntp_update(pmsg_buf);
            break;
        case RTC_MSG_ADD_ALARM:
            slog(RTC_PRINT, SLOG_NORMAL, "rtc-service: process_msg RTC_MSG_ADD_ALARM, src:0x%x, g_clean_flag = %d.\n",
                 pmsg_buf->src_id, g_clean_flag);
            //Ìí¼ÓrtcÇ°ÏÈɾ³ý´Ërtc_idÒÑÌí¼Ó¼Ç¼£¬Ã¿¸örtc_idÖ»±£Áô1¸ö¶¨Ê±Æ÷
            if (0 == g_clean_flag)
            {
                update_timer_remain(0);
                handle_alarm_del(pmsg_buf);
                handle_alarm_add(pmsg_buf);
            }
            else
            {
                slog(RTC_PRINT, SLOG_DEBUG, "rtc-service: g_clean_flag is nonzero:0x%x, dont add alarm.\n", g_clean_flag);
            }

            //wifi´¦ÀíÍêÇ°²»ÄÜÐÝÃߣ¬ÔÝʱʹÓÃÑÓʱËø£¬´ý·½°¸×é¸ø³ö·½°¸ºóÔÙµ÷Õû
            //if (pmsg_buf->usSourceModuleID == MODULE_ID_WDT)
            //write_lockfile("/sys/power/wake_unlock", "rtc_io_time_timeout_lock");

            break;
        case RTC_MSG_DEL_ALARM:
            slog(RTC_PRINT, SLOG_NORMAL, "rtc-service: process_msg RTC_MSG_DEL_ALARM, src:0x%x.\n", pmsg_buf->src_id);
            update_timer_remain(0);
            handle_alarm_del(pmsg_buf);
            send_ok_del_rsp(pmsg_buf);
            alarm_restart(&rtc_timer_list);
            alarm_restart(&rtc_alarm_list);
            break;
        case RTC_MSG_ALARM_TIMEOUT:
        case RTC_MSG_TIMER_TIMEOUT:
            slog(RTC_PRINT, SLOG_NORMAL, "rtc-service: process_msg RTC_TIMEOUT, src:0x%x, cmd:0x%x.\n", pmsg_buf->src_id, cmd);
            handle_alarm_timeout(pmsg_buf);
            break;
        case RTC_MSG_DEL_ALL:
            slog(RTC_PRINT, SLOG_NORMAL, "rtc-service: process_msg RTC_MSG_DEL_ALL, src:0x%x.\n", pmsg_buf->src_id);
            memcpy(&req_cmd, pmsg_buf->aucDataBuf, sizeof(unsigned short));
            if (MSG_CMD_RESET_RSP == req_cmd || MSG_CMD_POWEROFF_RSP == req_cmd || MSG_CMD_RESTART_RSP == req_cmd)
            {
                g_clean_flag = req_cmd;
            }
            handle_del_all(pmsg_buf);
            save_rtc_alarm();
            //ÕâÀﻹÐèҪ֪ͨÖ÷¿Ø
            ipc_send_message(MODULE_ID_RTC_SERVICE, pmsg_buf->src_id, req_cmd, 0, 0, 0);
            break;

        default:
            break;
    }
    return 0;
}

/********************************************
 * process_msg_rtc_ap
 * handle the specified MSG to cap, because rtc driver is at cap
 *******************************************/
static int process_msg_rtc_cap(MSG_BUF *pmsg_buf)
{
    enum RTC_MSG_CMD cmd = pmsg_buf->usMsgCmd;
    unsigned short req_cmd = 0;
    int ret = 0;
    struct tm *ptm = NULL;
    RTC_DATA_BUF *buf = NULL;
    int dst_id = 0;

    switch (cmd)
    {
        case RTC_MSG_GET_TIME:
            buf = (RTC_DATA_BUF *)pmsg_buf->aucDataBuf;
            slog(RTC_PRINT, SLOG_NORMAL, "to cap: RTC_MSG_GET_TIME \n");
            if (buf->cpu == RTC_CPU_AP)
            {
                ret = send_soc_msg(FAR_PS, MODULE_ID_RTC_SERVICE, cmd, pmsg_buf->usDataLen, (void *)pmsg_buf->aucDataBuf);
                if (ret != 0)
                {
                    slog(RTC_PRINT, SLOG_ERR, "process_msg_to_cap: ipc_send_message unexpected,ret:%d\n", ret);
                }
            }
            else
            {
                slog(RTC_PRINT, SLOG_NORMAL, "receive rtc time from cap core : RTC_MSG_GET_TIME :%lu \n", buf->ulSec);

            }
            break;
        case RTC_MSG_SET_TIME:
            ptm = (struct tm *)pmsg_buf->aucDataBuf;
            if (pmsg_buf->src_id == MODULE_ID_CP_RTC_SERVICE)
            {
                rtc_set_local_time(pmsg_buf);
            }
            else
            {
                /*
                slog(RTC_PRINT, SLOG_NORMAL, "to cap: cmd:0x%x, %d-%d-%d %d:%d:%d \n", cmd, ptm->tm_year, ptm->tm_mon, ptm->tm_mday, ptm->tm_hour, ptm->tm_min, ptm->tm_sec);
                ret = send_soc_msg(FAR_PS, MODULE_ID_RTC_SERVICE, cmd, pmsg_buf->usDataLen, (void *)pmsg_buf->aucDataBuf);
                if (ret != 0)
                {
                	slog(RTC_PRINT, SLOG_ERR, "process_msg_to_cap: ipc_send_message unexpected,ret:%d\n",ret);
                }
                */
            }
            break;
        case RTC_MSG_SNTP_UPDATE:
            handle_sntp_update(pmsg_buf);
            break;
        case RTC_MSG_ADD_ALARM:
        case RTC_MSG_DEL_ALARM:
            buf = (RTC_DATA_BUF *)pmsg_buf->aucDataBuf;
            if (buf->cpu == RTC_CPU_AP)
            {
                slog(RTC_PRINT, SLOG_NORMAL, "to cap: cmd:0x%x, module:0x%x, msg_id:0x%x, sec:%ld: cpu:%d, utc:%d, wakeup:%d \n", cmd,
                     buf->module, buf->srcModule, buf->ulSec, buf->cpu, buf->is_utc, buf->wakeup);
                ret = send_soc_msg(FAR_PS, MODULE_ID_RTC_SERVICE, cmd, pmsg_buf->usDataLen, (void *)pmsg_buf->aucDataBuf);
                if (ret != 0)
                {
                    slog(RTC_PRINT, SLOG_ERR, "process_msg_to_cap: ipc_send_message unexpected,ret:%d\n", ret);
                }
            }
            else
            {
                slog(RTC_PRINT, SLOG_NORMAL, "from cap: cmd:0x%x, module:0x%x, msg_id:0x%x, del ok \n", cmd, buf->module,
                     buf->srcModule);
            }
            break;
        case RTC_MSG_ALARM_TIMEOUT:
        case RTC_MSG_TIMER_TIMEOUT:
            buf = (RTC_DATA_BUF *)pmsg_buf->aucDataBuf;
            if (buf->cpu == RTC_CPU_CAP)
            {
                slog(RTC_PRINT, SLOG_NORMAL, "from cap: cmd:0x%x(timeout), module:0x%x, msg_id:0x%x, sec:%ld: %d, %d, %d \n", cmd,
                     buf->module, buf->srcModule, buf->ulSec, buf->cpu, buf->is_utc, buf->wakeup);

                ret = ipc_send_message(MODULE_ID_RTC_SERVICE, buf->srcModule, RTC_MSG_ALARM_ELAPSED, sizeof(RTC_DATA_BUF), buf, 0);
                if (ret != 0)
                {
                    slog(RTC_PRINT, SLOG_ERR, "process_msg_to_cap: ipc_send_message unexpected,ret:%d\n", ret);
                }
            }
            break;
        case RTC_MSG_DEL_ALL:
            slog(RTC_PRINT, SLOG_NORMAL, "process_msg_to_cap RTC_MSG_DEL_ALL, src:0x%x.\n", pmsg_buf->src_id);
            memcpy(&req_cmd, pmsg_buf->aucDataBuf, sizeof(unsigned short));
            //ÕâÀﻹÐèҪ֪ͨÖ÷¿Ø
            ipc_send_message(MODULE_ID_RTC_SERVICE, pmsg_buf->src_id, req_cmd, 0, 0, 0);
            ret = send_soc_msg(FAR_PS, MODULE_ID_RTC_SERVICE, cmd, pmsg_buf->usDataLen, (void *)pmsg_buf->aucDataBuf);
            if (ret != 0)
            {
                slog(RTC_PRINT, SLOG_ERR, "process_msg_to_cap: ipc_send_message unexpected,ret:%d\n", ret);
            }
            break;
        case RTC_MSG_TIME_CHANGED:
            buf = (RTC_DATA_BUF *)pmsg_buf->aucDataBuf;
            slog(RTC_PRINT, SLOG_ERR, "process_msg_to_cap: RTC_MSG_TIME_CHANGED, dst_id:0x%x.\n", buf->srcModule);
            ipc_send_message(MODULE_ID_RTC_SERVICE, buf->srcModule, RTC_MSG_TIME_CHANGED, 0, 0, 0);
            break;
        default:
            break;
    }
    return 0;
}

static int rtc_service_sock_init()
{
    int sockfd = 0;
    int ret;
    struct sockaddr_nl snl;

    bzero(&snl, sizeof(struct sockaddr_nl));
    snl.nl_family = AF_NETLINK;
    snl.nl_pid = getpid();
    snl.nl_groups = 1;

    if (signal(SIGPIPE, SIG_IGN) == SIG_ERR)
    {
        perror ("signal");
    }

    sockfd = socket(PF_NETLINK, SOCK_DGRAM, NETLINK_KOBJECT_UEVENT);
    if (sockfd < 0)
    {
        slog(RTC_PRINT, SLOG_ERR, "create rtc service socket failed!\n");
        return -1;
    }
    //  setsockopt(sockfd, SOL_SOCKET, SO_RCVBUF, &buffersize, sizeof(buffersize));

    ret = bind(sockfd, (struct sockaddr *)&snl, sizeof(struct sockaddr_nl));
    if (ret < 0)
    {
        slog(RTC_PRINT, SLOG_ERR, "rtc service socket bind fail!\n");
        close(sockfd);
        return -1;
    }

    return sockfd;
}
//change@/devices/platform/zx29_i2c.0/i2c-0/0-0012/zx234290-rtc
static int rtc_time_msg_parse(const char *msg, int msglen)
{
    int offlen = 0;
    const char *keys = NULL;
    char* timeStr = NULL;
    char *pSec = NULL;
    slog(RTC_PRINT, SLOG_ERR, "[%s][%d] zx234290-rtc \n", __func__, __LINE__);

    offlen += strlen((char *)msg) + 1;
    while (offlen <= msglen)
    {
        keys = (char *)(msg + offlen);
        //slog(NET_PRINT,SLOG_ERR, "[%s][%d] zx234290-rtc%s, %d\n", __func__, __LINE__, keys, offlen);
        if (strncmp(keys, RTC_ALARM_TIMEOUT_MSG, strlen(RTC_ALARM_TIMEOUT_MSG)) == 0)
        {
#if 1    // cov M	DEADCODE
            pSec = strstr(keys, "sec:");
            if (pSec == NULL)
            {
                slog(RTC_PRINT, SLOG_ERR, "zx234290-rtc event no sec \n");
                return -1;
            }
            timeStr = pSec + strlen("sec:");

#else
            timeStr = strstr(keys, "sec:") + strlen("sec:");
            if (timeStr == NULL)
            {
                slog(RTC_PRINT, SLOG_ERR, "zx234290-rtc event no sec \n");
                return -1;
            }
#endif
            ipc_send_message2(MODULE_ID_HOTPLUG, MODULE_ID_RTC_SERVICE, RTC_MSG_ALARM_TIMEOUT, strlen(timeStr), timeStr, 0);
            slog(RTC_PRINT, SLOG_NORMAL, "zx234290-rtc alarm timeout \n");
            return 0;
        }
        else if (strncmp(keys, RTC_TIMER_TIMEOUT_MSG, strlen(keys)) == 0)
        {
            ipc_send_message2(MODULE_ID_HOTPLUG, MODULE_ID_RTC_SERVICE, RTC_MSG_TIMER_TIMEOUT, 0, NULL, 0);
            slog(RTC_PRINT, SLOG_NORMAL, "zx234290-rtc timer timeout \n");
            return 0;
        }
        offlen += strlen((char *)keys) + 1;
    }
    slog(RTC_PRINT, SLOG_ERR, "zx234290-rtc event not supported \n");
    return -1;
}

/********************************************
 * rtc_service_thread_process
 * looper for processing zx234290-rtc msg.
 *******************************************/
void rtc_event_process(void)
{
    int rtc_service_fd = 0;
    fd_set readfds;
    int maxfd = 0;
    char buf[RTC_MSG_BUFFER_SIZE] = {0};
    int len = 0;
    int ret = 0;
    prctl(PR_SET_NAME, "rtceventhandle", 0, 0, 0);
    rtc_service_fd = rtc_service_sock_init();
    if (rtc_service_fd < 0)
    {
        slog(RTC_PRINT, SLOG_ERR, "rtc service socket init fail!\n");
        return ;
    }

    maxfd = rtc_service_fd;
    while (1)
    {
        FD_ZERO(&readfds);
        FD_SET(rtc_service_fd, &readfds);

        ret = select(maxfd + 1, &readfds, NULL, NULL, NULL);
        if (ret == -1 && errno == EINTR)
        {
            continue;
        }

        if (FD_ISSET(rtc_service_fd, &readfds))
        {
            memset(buf, 0, sizeof(buf));
            len = recv(rtc_service_fd, &buf, sizeof(buf), 0);
            if (len <= 0)
            {
                slog(RTC_PRINT, SLOG_ERR, "rtc service socket recv msg fail!\n");
                continue;
            }

            /*½øÐÐueventÏûÏ¢½âÎö£¬·µ»Ø½âÎö½á¹û*/
            if (strstr(buf, "zx234290-rtc"))
            {
                rtc_time_msg_parse(buf, len);
            }
            continue;
        }
    }
}

/********************************************
 * msg_looper
 * main looper for processing MSG.
 *******************************************/
static void msg_looper(void)
{
    int ret = 0;
    int msg_id = 0;
    MSG_BUF msg_buf = {0};
    //    key_t msgkey = get_msg_key();

    msg_id = msgget(MODULE_ID_RTC_SERVICE, IPC_CREAT | 0600);

    memset(&msg_buf, 0, sizeof(msg_buf));

    slog(RTC_PRINT, SLOG_DEBUG, "rtc-service: msg_looper enter(msgid=%d)&waiting...\n", msg_id);
    while (1)
    {
        ret = msgrcv(msg_id, &msg_buf, sizeof(MSG_BUF) - sizeof(long), 0, 0);
        wake_rtc_lock();
        if (ret <= 0)
        {
            slog(RTC_PRINT, SLOG_ERR, "rtc-service: msg_looper recv msg break(%d)\n", ret);
            wake_rtc_unlock();
            continue;
        }
        slog(RTC_PRINT, SLOG_DEBUG, "rtc-service: msg_looper process_msg in, src:0x%x, target:0x%x.\n", msg_buf.src_id,
             msg_buf.dst_id);

#ifdef USE_CAP_SUPPORT
        process_msg_rtc_cap(&msg_buf);
#else
        process_msg(&msg_buf);
#endif

        slog(RTC_PRINT, SLOG_ERR, "rtc-service: msg_looper process_msg out.\n");
        wake_rtc_unlock();
    }
}

static void print_rtc_list_info(void)
{
    ALARM_T *temp = NULL;
    int remain_time;

    if (ioctl(g_rtc_fd, ZX234290_GET_TIMER_REMAIN, &remain_time) < 0) // cov M CHECKED_RETURN
    {
        slog(RTC_PRINT, SLOG_ERR, "ioctl fail.\n");
    }


    slog(RTC_PRINT, SLOG_ERR, "rtc-service: rtc remain_time :%ld \n", remain_time);

    if (!list_empty(&rtc_timer_list))
    {
        list_for_each_entry(temp, &rtc_timer_list, list)
        {
            slog(RTC_PRINT, SLOG_ERR,
                 "rtc-service rtc_alarm_list node rtc_id:0x%x, module_id:0x%x, time_val:%ld, remain_time:%ld, cpu:%d\n",
                 temp->rtc_id,
                 temp->module_id,
                 temp->time_val,
                 temp->remain_time,
                 temp->cpu);
        }
    }
    else
    {
        slog(RTC_PRINT, SLOG_ERR, "rtc-service rtc_timer_list is empty!");
    }

    if (!list_empty(&rtc_alarm_list))
    {
        list_for_each_entry(temp, &rtc_alarm_list, list)
        {
            slog(RTC_PRINT, SLOG_ERR,
                 "rtc-service rtc_alarm_list node rtc_id:0x%x, module_id:0x%x, time_val:%ld, remain_time:%ld, cpu:%d, \
				rtc_tm.tm_year:%d, rtc_tm.tm_mon:%d, rtc_tm.tm_mday:%d, rtc_tm.tm_min:%d, rtc_tm.tm_sec:%d \n",
                 temp->rtc_id,
                 temp->module_id,
                 temp->time_val,
                 temp->remain_time,
                 temp->cpu,
                 temp->rtc_tm.tm_year, temp->rtc_tm.tm_mon, temp->rtc_tm.tm_mday, temp->rtc_tm.tm_min, temp->rtc_tm.tm_sec);
        }
    }
    else
    {
        slog(RTC_PRINT, SLOG_ERR, "rtc-service rtc_alarm_list is empty!");
    }
}

/* ÐźŴ¦Àí*/
static void sig_usr(int signo)
{
#if 0//(APP_OS_TYPE == APP_OS_LINUX)
    if (signo == SIGUSR1)
    {
        slog(RTC_PRINT, SLOG_NORMAL, "rtc-service receive SIGUSR1! \n");
        print_rtc_list_info();
    }
    else
    {
        slog(RTC_PRINT, SLOG_ERR, "rtc-service receive signo:%d", signo);
    }
#endif
}

/*RTCÏûÏ¢½âÎö*/
int rtc_app_msg_parse(const char *msg, int msglen, struct hotplug_event *event)
{
    if (strstr(msg, "zx234290-rtc"))
    {
        rtc_time_msg_parse(msg, msglen);
    }
    return -1;
}

/********************************************
 * main
 * entry of RTC-Service!
 *******************************************/
int rtc_service_main(int argc, char **argv)
{

    slog(RTC_PRINT, SLOG_DEBUG, "rtc-service enter...\n");
    pthread_t  rtcservice_thread_id;
    pthread_attr_t attr;
    int  result = 0;
    prctl(PR_SET_NAME, "rtc-service", 0, 0, 0);

    //¸ù¾ÝNV³õʼ»¯´òÓ¡¼¶±ð£¬²¢×¢²á¶¯Ì¬µ÷Õû´òÓ¡¼¶±ðÐźÅÁ¿
    loglevel_init();

    if (signal(SIGUSR1, sig_usr) == SIG_ERR)
    {
        slog(RTC_PRINT, SLOG_ERR, "rtc-service not catch SIGUSR1 \n");
    }

    INIT_LIST_HEAD(&rtc_timer_list);
    INIT_LIST_HEAD(&rtc_alarm_list);

    g_clean_flag = 0;

    //rtcÔÚAPʱ£¬½Úµã±ØÐë´ò¿ª³É¹¦£»ÔÚÆäËûºËʱÓÉÆäËûºËÅжÏ
#ifndef USE_CAP_SUPPORT
    if ((g_rtc_fd = open_rtc()) < 0)
    {
        slog(RTC_PRINT, SLOG_ERR, "Cannt open rtc dev!\n");
        return -1;
    }
    init_rtc_alarm();
#endif
    /*
    	pthread_attr_init(&attr);
    	pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
    	result = pthread_create(&rtcservice_thread_id, &attr, rtc_event_process, NULL);
    	pthread_attr_destroy(&attr);
    	if(result != 0)
    	{
    		slog(RTC_PRINT,SLOG_ERR, "[rtc-service] rtcservice_thread pthread_create faild!\n");
    		return -1;
    	}
    	else
    	{
    		printf("[rtc-service] rtcservice_thread pthread_create  SUCCESS!\n");
    	}
    */
    hotplug_parse_register(DEVICE_TYPE_APP_RTC, rtc_app_msg_parse);
    msg_looper();
    //klocwork
    //close_rtc(g_rtc_fd);

    //slog(RTC_PRINT, SLOG_ERR, "rtc-service exit...\n");

    return 0;
}