/*
 * Copyright (c) Hisilicon Technologies Co., Ltd. 2019-2020. All rights reserved.
 * Description: pmoc sample
 */

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <pthread.h>
#include <sys/reboot.h>
#include <sys/mman.h>
#include <sys/ioctl.h>
#include <fcntl.h>
#include <signal.h>
#include <securec.h>
#include <linux/fb.h>

#include "uapi_pmoc.h"
#include "uapi_pdm.h"

#ifdef CONFIG_SUPPORT_CA_RELEASE
#define log_info_pmoc(format, arg ...)
#else
#define log_info_pmoc(format, arg ...) printf(format, ## arg)
#endif

#define pmoc_notice(format...)             printf("> "); printf(format);

#define modify_number(x) do { \
    td_u32 num; \
    if (get_input_number(&num) == 0) { \
        (x) = num; \
    } \
} while (0)

#define U32_MAX 0xFFFFFFFF
#define MESSAGE_LEN 32

#define unused(x) ((void)(x))

typedef struct {
    uapi_pmoc_wakeup_src source;
    td_char wakeup_source[MESSAGE_LEN];
    td_s32 (*f_set_suspend_param)(td_void);
    td_s32 (*f_get_suspend_param)(td_void);
} pmoc_wakeup_source_map;

typedef enum {
    EXT_KEYLED_TYPE_CT1642 = 0x0,   /* <KEYLED type: CT1642 */ /* <CNcomment:KEYLED型号：CT1642 */
    EXT_KEYLED_TYPE_FD650,          /* <KEYLED type: FD650 */ /* <CNcomment:KEYLED型号：FD650 */
    EXT_KEYLED_TYPE_GPIOKEY,        /* <KEYLED type: GPIOKEY */ /* <CNcomment:GPIO按键面板 */
    EXT_KEYLED_TYPE_MAX
} keyled_type;

static td_void show_usage_info(td_void)
{
    pmoc_notice("usage: sample_pmoc [-t trigger] [-s set] [-g get] [[command] arg].\n");
    pmoc_notice("command as follows:\n");
    pmoc_notice("sample_pmoc -t                     -- enter standby.\n");
    pmoc_notice("sample_pmoc -m                     -- enter memory standby.\n");
    pmoc_notice("sample_pmoc -s timer_wakeup        -- configure timer wakeup params.\n");
    pmoc_notice("sample_pmoc -s suspend_param       -- configure wakeup params.\n");
    pmoc_notice("sample_pmoc -s wakeup_type         -- configure wakeup type.\n");
    pmoc_notice("sample_pmoc -s display             -- configure keyled display params.\n");
    pmoc_notice("sample_pmoc -s power_off_gpio      -- configure power off gpio params.\n");
    pmoc_notice("sample_pmoc -s pmoc_poweron_flag   -- configure memory standby flag.\n");
    pmoc_notice("sample_pmoc -g pmoc_poweron_flag   -- get memory standby flag.\n");
    pmoc_notice("sample_pmoc -g suspend_param       -- get wakeup params.\n");
    pmoc_notice("sample_pmoc -g chip_temperature    -- get chip temperature.\n");
    pmoc_notice("sample_pmoc -s standby_led         -- set standby led.\n");
    pmoc_notice("sample_pmoc -s mcu_msg             -- set cutom mcu msg.\n");
    pmoc_notice("sample_pmoc -g mcu_msg             -- get cutom mcu msg.\n");

    return;
}

typedef struct {
    td_char cmd[MESSAGE_LEN];
    td_s32(*f_process)(void);
} pmoc_func_map;

static int get_input_number(td_u32 *num)
{
    size_t bytes;
    char buffer[128] = {0}; /* console I/O buffer, size: 128 */

    log_info_pmoc(" ? ");
    (void)fflush(stdout);
    read(0, buffer, 127); /* read size: 127 */

    bytes = strlen(buffer);
    if (bytes == 0) {
        return -1;
    } else {
        char *end = TD_NULL;
        /* hex */
        if (strncmp(buffer, "0x", sizeof("0x") - 1) == 0) {
            *num = strtoul(buffer, &end, 16); /* 16 system */
        } else {
            *num = strtoul(buffer, &end, 10); /* 10 system */
        }

        bytes = (size_t)(end - buffer);
        if (bytes != 0) {
            return 0;
        } else {
            return -1;
        }
    }
}

static td_void power_off(td_void)
{
    reboot(RB_POWER_OFF);
}

static td_s32 set_ir_wakeup_config(uapi_pmoc_suspend_param *param)
{
    td_s32 ret;

    log_info_pmoc("Select ir type(0-nec simple, 1-tc9012, 2-nec full, 3-sony_12bit, 4-raw, 5-not support)\n");
    pmoc_notice("Please input new ir type[%d]", param->ir_param.ir_type);
    ret = scanf_s("%u", &param->ir_param.ir_type);
    if (ret <= 0) {
        log_info_pmoc("scanf_s err!\n");
        return TD_FAILURE;
    }

    if (param->ir_param.ir_type == UAPI_IR_CODE_RAW) {
        /* Here is ir powerkey code values of support */
        param->ir_param.ir_num = 6; /* 6: Ir code raw support number */

        param->ir_param.ir_low_val[0] = 0x48140f00; /* XMP-1 short-IR */
        param->ir_param.ir_high_val[0] = 0x0;
        param->ir_param.ir_low_val[1] = 0x47180f00; /* XMP-1 long-IR */
        param->ir_param.ir_high_val[1] = 0x0;
        param->ir_param.ir_low_val[2] = 0x639cff00; /* nec simple, 2: array offset value */
        param->ir_param.ir_high_val[2] = 0x0; /* 2: array offset value */
        param->ir_param.ir_low_val[3] = 0x8010260c; /* RC6 32bit, 3: array offset value */
        param->ir_param.ir_high_val[3] = 0x0000001c; /* 3: array offset value */
        param->ir_param.ir_low_val[4] = 0x0000000c; /* RC5 14bit, 4: array offset value */
        param->ir_param.ir_high_val[4] = 0x00000000; /* 4: array offset value */
        param->ir_param.ir_low_val[5] = 0x58535754; /* nec full dezhou like, 5: array offset value */
        param->ir_param.ir_high_val[5] = 0x00005750; /* 5: array offset value */
    } else if (param->ir_param.ir_type == UAPI_IR_CODE_SONY_12BIT) {
        param->ir_param.ir_num = 1;
        param->ir_param.ir_low_val[0] = 0x00000095;
        param->ir_param.ir_high_val[0] = 0x0;
    } else if (param->ir_param.ir_type == UAPI_IR_CODE_NEC_FULL) {
        param->ir_param.ir_num = 1;
        param->ir_param.ir_low_val[0] = 0x58595a53;
        param->ir_param.ir_high_val[0] = 0x5750;
    } else if (param->ir_param.ir_type == UAPI_IR_CODE_TC9012) {
        param->ir_param.ir_num = 1;
        param->ir_param.ir_low_val[0] = 0xf30c0e0e;
        param->ir_param.ir_high_val[0] = 0x0;
    } else {
        param->ir_param.ir_num = 1;
        param->ir_param.ir_low_val[0] = 0x639cff00;
        param->ir_param.ir_high_val[0] = 0x0;
    }

    return TD_SUCCESS;
}

static td_s32 set_ir_suspend_param(td_void)
{
    td_s32 ret;
    td_u32 tmp;
    uapi_pmoc_wakeup_src source;
    td_bool enable;
    uapi_pmoc_suspend_param param;

    if (memset_s(&param, sizeof(param), 0, sizeof(param)) != EOK) {
        log_info_pmoc("param init failed");
        return TD_FAILURE;
    }

    pmoc_notice("================= Modify ir suspend param =================\n");

    source = UAPI_PMOC_WAKEUP_IR;
    ret = uapi_pmoc_get_suspend_param(source, &enable, &param);
    if (ret != TD_SUCCESS) {
        log_info_pmoc("uapi_pmoc_get_suspend_param err, 0x%08x !\n", ret);
        return ret;
    }

    pmoc_notice("Please input new ir wakeup enable flag[%d]", enable);
    ret = scanf_s("%u", &tmp);
    if (ret <= 0) {
        log_info_pmoc("scanf_s err!\n");
        return TD_FAILURE;
    }

    enable = (tmp != 0) ? TD_TRUE : TD_FALSE;

    if (enable) {
        ret = set_ir_wakeup_config(&param);
        if (ret != TD_SUCCESS) {
            log_info_pmoc("set_ir_wakeup_config err, 0x%08x !\n", ret);
            return ret;
        }
    }

    ret = uapi_pmoc_set_suspend_param(source, enable, &param);
    if (ret != TD_SUCCESS) {
        log_info_pmoc("uapi_pmoc_set_suspend_param err, 0x%08x !\n", ret);
        return ret;
    }

    return TD_SUCCESS;
}

static td_s32 set_keyled_suspend_param(td_void)
{
    td_s32 ret;
    td_u32 tmp;
    uapi_pmoc_wakeup_src source;
    td_bool enable;
    uapi_pmoc_suspend_param param;

    if (memset_s(&param, sizeof(param), 0, sizeof(param)) != EOK) {
        log_info_pmoc("param init failed");
        return TD_FAILURE;
    }

    pmoc_notice("================= Modify keyled suspend param =============\n");
    source = UAPI_PMOC_WAKEUP_KEYLED;
    ret = uapi_pmoc_get_suspend_param(source, &enable, &param);
    if (ret != TD_SUCCESS) {
        log_info_pmoc("uapi_pmoc_get_suspend_param err, 0x%08x !\n", ret);
        return ret;
    }

    pmoc_notice("Please input new keyled wakeup enable flag[%d]", enable);
    ret = scanf_s("%u", &tmp);
    if (ret <= 0) {
        log_info_pmoc("scanf_s err!\n");
        return TD_FAILURE;
    }

    enable = (tmp != 0) ? TD_TRUE : TD_FALSE;

    if (enable) {
        log_info_pmoc("Select keyled type(0-CT1642, 1-FD650, 2-gpiokey, 3-not support)\n");
        pmoc_notice("Please input new keyled type[%u]", param.keyled_param.keyled_type);
        ret = scanf_s("%u", &param.keyled_param.keyled_type);
        if (ret <= 0) {
            log_info_pmoc("scanf_s err!\n");
            return TD_FAILURE;
        }

        if (param.keyled_param.keyled_type < EXT_KEYLED_TYPE_GPIOKEY) {
            pmoc_notice("Please input new keyled wakeup key[%u]", param.keyled_param.wakeup_key);
            ret = scanf_s("%u", &param.keyled_param.wakeup_key);
            if (ret <= 0) {
                log_info_pmoc("scanf_s err!\n");
                return TD_FAILURE;
            }
        }
    }

    ret = uapi_pmoc_set_suspend_param(source, enable, &param);
    if (ret != TD_SUCCESS) {
        log_info_pmoc("uapi_pmoc_set_suspend_param err, 0x%08x !\n", ret);
        return ret;
    }

    return TD_SUCCESS;
}

static td_s32 set_gpio_wakeup_config(uapi_pmoc_suspend_param *param)
{
    td_u8 i;
    td_s32 ret;
    td_u32 tmp;

    pmoc_notice("Please input new gpio wakeup num[%u]", param->gpio_param.num);
    ret = scanf_s("%u", &param->gpio_param.num);
    if (ret <= 0) {
        log_info_pmoc("scanf_s err!\n");
        return TD_FAILURE;
    }

    if (param->gpio_param.num > UAPI_PMOC_WAKEUP_GPIO_MAXNUM) {
        log_info_pmoc("num is bigger than %d, force it to %d \n", UAPI_PMOC_WAKEUP_GPIO_MAXNUM,
            UAPI_PMOC_WAKEUP_GPIO_MAXNUM);
        param->gpio_param.num = UAPI_PMOC_WAKEUP_GPIO_MAXNUM;
    }

    for (i = 0; i < param->gpio_param.num; i++) {
        pmoc_notice("Please input num%d new wakeup group[%d]", i, param->gpio_param.group[i]);
        ret = scanf_s("%u", &tmp);
        if (ret <= 0) {
            log_info_pmoc("scanf_s err!\n");
            return TD_FAILURE;
        }

        param->gpio_param.group[i] = (td_u8)tmp;

        pmoc_notice("Please input num%d new wakeup bit[%d]", i, param->gpio_param.bit[i]);
        ret = scanf_s("%u", &tmp);
        if (ret <= 0) {
            log_info_pmoc("scanf_s err!\n");
            return TD_FAILURE;
        }

        param->gpio_param.bit[i] = (td_u8)tmp;

        log_info_pmoc("Select gpio interrupt type(0-up edge, 1-down edge, 2-both the up and down edge, ");
        log_info_pmoc("3-high level, 4-low level, 5-not support\n");
        pmoc_notice("Please input num%d new interrupt type[%d]", i, param->gpio_param.interrupt_type[i]);
        ret = scanf_s("%u", &tmp);
        if (ret <= 0) {
            log_info_pmoc("scanf_s err!\n");
            return TD_FAILURE;
        }

        param->gpio_param.interrupt_type[i] = tmp;
    }

    return TD_SUCCESS;
}

static td_s32 set_gpio_suspend_param(td_void)
{
    td_s32 ret;
    td_u32 tmp;
    uapi_pmoc_wakeup_src source;
    td_bool enable;
    uapi_pmoc_suspend_param param;

    if (memset_s(&param, sizeof(param), 0, sizeof(param)) != EOK) {
        log_info_pmoc("param init failed");
        return TD_FAILURE;
    }

    pmoc_notice("================= Modify gpio suspend param ===============\n");
    source = UAPI_PMOC_WAKEUP_GPIO;
    ret = uapi_pmoc_get_suspend_param(source, &enable, &param);
    if (ret != TD_SUCCESS) {
        log_info_pmoc("uapi_pmoc_get_suspend_param err, 0x%08x !\n", ret);
        return ret;
    }

    pmoc_notice("Please input new gpio wakeup enable flag[%d]", enable);
    ret = scanf_s("%u", &tmp);
    if (ret <= 0) {
        log_info_pmoc("scanf_s err!\n");
        return TD_FAILURE;
    }

    enable = (tmp != 0) ? TD_TRUE : TD_FALSE;

    if (enable) {
        ret = set_gpio_wakeup_config(&param);
        if (ret != TD_SUCCESS) {
            log_info_pmoc("set_gpio_wakeup_config err, 0x%08x !\n", ret);
            return ret;
        }
    }

    ret = uapi_pmoc_set_suspend_param(source, enable, &param);
    if (ret != TD_SUCCESS) {
        log_info_pmoc("uapi_pmoc_set_suspend_param err, 0x%08x !\n", ret);
        return ret;
    }

    return TD_SUCCESS;
}

static td_s32 set_lsadc_suspend_param(td_void)
{
    td_s32 ret;
    td_u32 tmp;
    td_bool enable;
    td_u8 i;
    uapi_pmoc_wakeup_src source;
    uapi_pmoc_suspend_param param;

    if (memset_s(&param, sizeof(param), 0, sizeof(param)) != EOK) {
        log_info_pmoc("param init failed");
        return TD_FAILURE;
    }

    pmoc_notice("================= Modify lsadc suspend param ===============\n");
    source = UAPI_PMOC_WAKEUP_LSADC;
    ret = uapi_pmoc_get_suspend_param(source, &enable, &param);
    if (ret != TD_SUCCESS) {
        log_info_pmoc("uapi_pmoc_get_suspend_param err, 0x%08x !\n", ret);
        return ret;
    }

    pmoc_notice("Please input lsadc wakeup enable flag[%d]", enable);
    ret = scanf_s("%u", &tmp);
    if (ret <= 0) {
        log_info_pmoc("scanf_s err!\n");
        return TD_FAILURE;
    }

    enable = (tmp != 0) ? TD_TRUE : TD_FALSE;

    pmoc_notice("Please input lsadc channel mask(bit0~3 means channel0~3): 0x");
    ret = scanf_s("%x", &param.lsadc_param.channel_mask);
    if (ret <= 0) {
        log_info_pmoc("scanf_s err!\n");
        return TD_FAILURE;
    }

    if (enable) {
        for (i = 0; i < UAPI_PMOC_LSADC_CHANNEL_MAXNUM; i++) {
            if ((param.lsadc_param.channel_mask & (1 << i)) == 0) {
                continue;
            }

            pmoc_notice("Please input channel%d key low value[%d]", i, param.lsadc_param.key_value_range[i].low);
            ret = scanf_s("%x", &param.lsadc_param.key_value_range[i].low);
            if (ret <= 0) {
                log_info_pmoc("scanf_s err!\n");
                return TD_FAILURE;
            }

            pmoc_notice("Please input channel%u key high value[%u]", i, param.lsadc_param.key_value_range[i].high);
            ret = scanf_s("%x", &param.lsadc_param.key_value_range[i].high);
            if (ret <= 0) {
                log_info_pmoc("scanf_s err!\n");
                return TD_FAILURE;
            }
        }
    }

    ret = uapi_pmoc_set_suspend_param(source, enable, &param);
    if (ret != TD_SUCCESS) {
        log_info_pmoc("uapi_pmoc_set_suspend_param err, 0x%08x !\n", ret);
        return ret;
    }

    return TD_SUCCESS;
}

static td_s32 set_uart_suspend_param(td_void)
{
    td_s32 ret;
    td_u32 tmp;
    uapi_pmoc_wakeup_src source;
    td_bool enable;
    uapi_pmoc_suspend_param param;

    if (memset_s(&param, sizeof(param), 0, sizeof(param)) != EOK) {
        log_info_pmoc("param init failed");
        return TD_FAILURE;
    }

    pmoc_notice("================= Modify uart suspend param ===============\n");
    source = UAPI_PMOC_WAKEUP_UART;
    ret = uapi_pmoc_get_suspend_param(source, &enable, &param);
    if (ret != TD_SUCCESS) {
        log_info_pmoc("uapi_pmoc_get_suspend_param err, 0x%08x !\n", ret);
        return ret;
    }

    pmoc_notice("Please input new uart wakeup enable flag[%d]", enable);
    ret = scanf_s("%u", &tmp);
    if (ret <= 0) {
        log_info_pmoc("scanf_s err!\n");
        return TD_FAILURE;
    }

    enable = (tmp != 0) ? TD_TRUE : TD_FALSE;

    if (enable) {
        pmoc_notice("Please input new uart wakeup key:0x");
        ret = scanf_s("%x", &tmp);
        if (ret <= 0) {
            log_info_pmoc("scanf_s err!\n");
            return TD_FAILURE;
        }

        param.uart_param.wakeup_key = (td_u8)tmp;
    }

    ret = uapi_pmoc_set_suspend_param(source, enable, &param);
    if (ret != TD_SUCCESS) {
        log_info_pmoc("uapi_pmoc_set_suspend_param err, 0x%08x !\n", ret);
        return ret;
    }

    return TD_SUCCESS;
}

static td_void set_frame_filter(uapi_pmoc_suspend_param *param)
{
    td_u8 i;

    /* normal filter */
    param->eth_param.frame[0].mask_bytes = U32_MAX;
    param->eth_param.frame[0].offset = 15; /* offset: 15 */
    param->eth_param.frame[0].filter_valid = TD_TRUE;

    for (i = 0; i < UAPI_PMOC_FILTER_VALUE_COUNT; i++) {
        param->eth_param.frame[0].value[i] = i;
    }

    /* enable part of mask bytes */
    param->eth_param.frame[1].mask_bytes = 0xf0ffffff;
    param->eth_param.frame[1].offset = 15; /* offset: 15 */
    param->eth_param.frame[1].filter_valid = TD_TRUE;

    for (i = 0; i < UAPI_PMOC_FILTER_VALUE_COUNT; i++) {
        param->eth_param.frame[1].value[i] = i;
    }

    /* offset > 128 */
    param->eth_param.frame[2].mask_bytes = U32_MAX; /* 2: array offset value */
    param->eth_param.frame[2].offset = 130; /* offset: 130, 2: array offset value */
    param->eth_param.frame[2].filter_valid = TD_TRUE; /* 2: array offset value */

    for (i = 0; i < UAPI_PMOC_FILTER_VALUE_COUNT; i++) {
        param->eth_param.frame[2].value[i] = 0x2; /* frame value: 0x2, 2: array offset value */
    }

    /* false filter, invalid */
    param->eth_param.frame[3].mask_bytes = U32_MAX; /* 3: array offset value */
    param->eth_param.frame[3].offset = 9; /* offset: 9, 3: array offset value */
    param->eth_param.frame[3].filter_valid = TD_FALSE; /* 3: array offset value */

    for (i = 0; i < UAPI_PMOC_FILTER_VALUE_COUNT; i++) {
        param->eth_param.frame[3].value[i] = 0x1; /* frame value: 0x1, 3: array offset value */
    }
}

static td_s32 set_eth_wakeup_config(uapi_pmoc_suspend_param *param)
{
    td_u32 tmp;

    param->eth_param.index = 0; /* 0-eth0, 1-eth1 */

    pmoc_notice("Please input new single packet wakeup enable flag[%d]", param->eth_param.unicast_packet_enable);
    if (scanf_s("%u", &tmp) <= 0) {
        log_info_pmoc("scanf_s err!\n");
        return TD_FAILURE;
    }

    param->eth_param.unicast_packet_enable = (tmp != 0) ? TD_TRUE : TD_FALSE;

    if (param->eth_param.unicast_packet_enable == TD_FALSE) {
        pmoc_notice("Please input new magic packet wakeup enable flag[%d]", param->eth_param.magic_packet_enable);
        if (scanf_s("%u", &tmp) <= 0) {
            log_info_pmoc("scanf_s err!\n");
            return TD_FAILURE;
        }

        param->eth_param.magic_packet_enable = (tmp != 0) ? TD_TRUE : TD_FALSE;

        if (param->eth_param.magic_packet_enable == TD_FALSE) {
            pmoc_notice("Please input magic frame wakeup enable flag[%d]", param->eth_param.wakeup_frame_enable);
            if (scanf_s("%u", &tmp) <= 0) {
                log_info_pmoc("scanf_s err!\n");
                return TD_FAILURE;
            }

            param->eth_param.wakeup_frame_enable = (tmp != 0) ? TD_TRUE : TD_FALSE;
        }
    }

    if (param->eth_param.wakeup_frame_enable) {
        set_frame_filter(param);
    }

    if (param->eth_param.unicast_packet_enable || param->eth_param.magic_packet_enable ||
        param->eth_param.wakeup_frame_enable) {
        pmoc_notice("Please input Eth wakeup to pasive standby time[%u]", param->eth_param.time_to_passive_standby);
        if (scanf_s("%u", &(param->eth_param.time_to_passive_standby)) <= 0) {
            log_info_pmoc("scanf_s err!\n");
            return TD_FAILURE;
        }

        pmoc_notice("Please input mute wakeup enable flag[%d]", param->eth_param.mute_wakeup_enable);
        if (scanf_s("%u", &tmp) <= 0) {
            log_info_pmoc("scanf_s err!\n");
            return TD_FAILURE;
        }

        param->eth_param.mute_wakeup_enable = (tmp != 0) ? TD_TRUE : TD_FALSE;
    }

    return TD_SUCCESS;
}

static td_s32 set_eth_suspend_param(td_void)
{
    td_s32 ret;
    td_u32 tmp;
    uapi_pmoc_wakeup_src source;
    td_bool enable;
    uapi_pmoc_suspend_param param;

    if (memset_s(&param, sizeof(param), 0, sizeof(param)) != EOK) {
        log_info_pmoc("param init failed");
        return TD_FAILURE;
    }

    pmoc_notice("================= Modify eth suspend param ================\n");
    source = UAPI_PMOC_WAKEUP_ETH;
    ret = uapi_pmoc_get_suspend_param(source, &enable, &param);
    if (ret != TD_SUCCESS) {
        log_info_pmoc("uapi_pmoc_get_suspend_param err, 0x%08x !\n", ret);
        return ret;
    }

    pmoc_notice("Please input new eth wakeup enable flag[%d]", enable);
    ret = scanf_s("%u", &tmp);
    if (ret <= 0) {
        log_info_pmoc("scanf_s err!\n");
        return TD_FAILURE;
    }

    enable = (tmp != 0) ? TD_TRUE : TD_FALSE;

    if (enable) {
        ret = set_eth_wakeup_config(&param);
        if (ret != TD_SUCCESS) {
            log_info_pmoc("set_eth_wakeup_config err, 0x%08x !\n", ret);
            return ret;
        }
    }

    ret = uapi_pmoc_set_suspend_param(source, enable, &param);
    if (ret != TD_SUCCESS) {
        log_info_pmoc("uapi_pmoc_set_suspend_param err, 0x%08x !\n", ret);
        return ret;
    }

    return TD_SUCCESS;
}

static td_s32 set_vga_suspend_param(td_void)
{
    td_s32 ret;
    td_u32 tmp;
    uapi_pmoc_wakeup_src source;
    td_bool enable;

    pmoc_notice("================= Modify vga suspend param ================\n");
    source = UAPI_PMOC_WAKEUP_VGA;
    ret = uapi_pmoc_get_suspend_param(source, &enable, NULL);
    if (ret != TD_SUCCESS) {
        log_info_pmoc("uapi_pmoc_get_suspend_param err, 0x%08x !\n", ret);
        return ret;
    }

    pmoc_notice("Please input new vga wakeup enable flag[%d]", enable);
    ret = scanf_s("%u", &tmp);
    if (ret <= 0) {
        log_info_pmoc("scanf_s err!\n");
        return TD_FAILURE;
    }

    enable = (tmp != 0) ? TD_TRUE : TD_FALSE;

    ret = uapi_pmoc_set_suspend_param(source, enable, NULL);
    if (ret != TD_SUCCESS) {
        log_info_pmoc("uapi_pmoc_set_suspend_param err, 0x%08x !\n", ret);
        return ret;
    }

    return TD_SUCCESS;
}

static td_s32 set_voice_suspend_param(td_void)
{
    td_s32 ret;
    td_u32 tmp;
    uapi_pmoc_wakeup_src source;
    td_bool enable;

    pmoc_notice("================ Modify voice suspend param ===============\n");
    source = UAPI_PMOC_WAKEUP_VOICE;
    ret = uapi_pmoc_get_suspend_param(source, &enable, NULL);
    if (ret != TD_SUCCESS) {
        log_info_pmoc("uapi_pmoc_get_suspend_param err, 0x%08x !\n", ret);
        return ret;
    }

    pmoc_notice("Please input new voice wakeup enable flag[%d]", enable);
    ret = scanf_s("%u", &tmp);
    if (ret <= 0) {
        log_info_pmoc("scanf_s err!\n");
        return TD_FAILURE;
    }

    enable = (tmp != 0) ? TD_TRUE : TD_FALSE;

    ret = uapi_pmoc_set_suspend_param(source, enable, NULL);
    if (ret != TD_SUCCESS) {
        log_info_pmoc("uapi_pmoc_set_suspend_param err, 0x%08x !\n", ret);
        return ret;
    }

    return TD_SUCCESS;
}

static td_s32 set_usb_suspend_param(td_void)
{
    td_s32 ret;
    td_u32 tmp;
    uapi_pmoc_wakeup_src source;
    td_bool enable;
    uapi_pmoc_suspend_param param;

    if (memset_s(&param, sizeof(param), 0, sizeof(param)) != EOK) {
        log_info_pmoc("param init failed");
        return TD_FAILURE;
    }

    pmoc_notice("================= Modify usb suspend param ================\n");
    source = UAPI_PMOC_WAKEUP_USB;
    ret = uapi_pmoc_get_suspend_param(source, &enable, &param);
    if (ret != TD_SUCCESS) {
        log_info_pmoc("uapi_pmoc_get_suspend_param err, 0x%08x !\n", ret);
        return ret;
    }

    pmoc_notice("Please input new usb wakeup enable flag[%d]", enable);
    ret = scanf_s("%u", &tmp);
    if (ret <= 0) {
        log_info_pmoc("scanf_s err!\n");
        return TD_FAILURE;
    }

    enable = (tmp != 0) ? TD_TRUE : TD_FALSE;

    ret = uapi_pmoc_set_suspend_param(source, enable, &param);
    if (ret != TD_SUCCESS) {
        log_info_pmoc("uapi_pmoc_set_suspend_param err, 0x%08x !\n", ret);
        return ret;
    }

    return TD_SUCCESS;
}

static td_s32 set_hdmirx_plugin_param(td_void)
{
    td_s32 ret;
    td_u32 tmp;
    uapi_pmoc_wakeup_src source;
    td_bool enable;
    uapi_pmoc_suspend_param param;

    if (memset_s(&param, sizeof(param), 0, sizeof(param)) != EOK) {
        log_info_pmoc("param init failed");
        return TD_FAILURE;
    }

    pmoc_notice("============= Modify hdmirx plugin suspend param===========\n");
    source = UAPI_PMOC_WAKEUP_HDMIRX_PLUGIN;
    ret = uapi_pmoc_get_suspend_param(source, &enable, &param);
    if (ret != TD_SUCCESS) {
        log_info_pmoc("uapi_pmoc_get_suspend_param err, 0x%08x !\n", ret);
        return ret;
    }

    pmoc_notice("Please input new hdmirx plugin wakeup enable flag[%d]", enable);
    ret = scanf_s("%u", &tmp);
    if (ret <= 0) {
        log_info_pmoc("scanf_s err!\n");
        return TD_FAILURE;
    }

    enable = (tmp != 0) ? TD_TRUE : TD_FALSE;

    if (enable) {
        pmoc_notice("Please input new hdmirx plugin port [%u]", param.hdmirx_plugin_param.port);
        ret = scanf_s("%u", &param.hdmirx_plugin_param.port);
        if (ret <= 0) {
            log_info_pmoc("scanf_s err!\n");
            return TD_FAILURE;
        }
    }

    ret = uapi_pmoc_set_suspend_param(source, enable, &param);
    if (ret != TD_SUCCESS) {
        log_info_pmoc("uapi_pmoc_set_suspend_param err, 0x%08x !\n", ret);
        return ret;
    }

    return TD_SUCCESS;
}

static td_s32 set_hdmirx_cec_suspend_param(td_void)
{
    td_s32 ret;
    td_u32 tmp;
    uapi_pmoc_wakeup_src source;
    td_bool enable;

    pmoc_notice("============= Modify hdmirx cec suspend param =============\n");
    source = UAPI_PMOC_WAKEUP_HDMIRX_CEC;
    ret = uapi_pmoc_get_suspend_param(source, &enable, NULL);
    if (ret != TD_SUCCESS) {
        log_info_pmoc("uapi_pmoc_get_suspend_param err, 0x%08x !\n", ret);
        return ret;
    }

    pmoc_notice("Please input new hdmirx cec wakeup enable flag[%d]", enable);
    ret = scanf_s("%u", &tmp);
    if (ret <= 0) {
        log_info_pmoc("scanf_s err!\n");
        return TD_FAILURE;
    }

    enable = (tmp != 0) ? TD_TRUE : TD_FALSE;

    ret = uapi_pmoc_set_suspend_param(source, enable, NULL);
    if (ret != TD_SUCCESS) {
        log_info_pmoc("uapi_pmoc_set_suspend_param err, 0x%08x !\n", ret);
        return ret;
    }

    return TD_SUCCESS;
}

static td_s32 set_hdmitx_cec_suspend_param(td_void)
{
    td_s32 ret;
    td_u32 tmp;
    uapi_pmoc_wakeup_src source;
    td_bool enable;
    uapi_pmoc_suspend_param param;

    if (memset_s(&param, sizeof(param), 0, sizeof(param)) != EOK) {
        log_info_pmoc("param init failed");
        return TD_FAILURE;
    }

    pmoc_notice("============= Modify hdmitx cec suspend param =============\n");
    source = UAPI_PMOC_WAKEUP_HDMITX_CEC;
    ret = uapi_pmoc_get_suspend_param(source, &enable, &param);
    if (ret != TD_SUCCESS) {
        log_info_pmoc("uapi_pmoc_get_suspend_param err, 0x%08x !\n", ret);
        return ret;
    }

    pmoc_notice("Please input new hdmitx cec wakeup enable flag[%d]", enable);
    ret = scanf_s("%u", &tmp);
    if (ret <= 0) {
        log_info_pmoc("scanf_s err!\n");
        return TD_FAILURE;
    }

    enable = (tmp != 0) ? TD_TRUE : TD_FALSE;

    if (enable) {
        param.hdmitx_cec_param.id[0] = 1;
        log_info_pmoc("Select cec control type(0-bilateral, 1-tv to chip, 2-chip to tv, 3-not support)\n");
        pmoc_notice("Please input new hdmitx cec control type [%d]", param.hdmitx_cec_param.cec_control[0]);
        ret = scanf_s("%u", &param.hdmitx_cec_param.cec_control[0]);
        if (ret <= 0) {
            log_info_pmoc("scanf_s err!\n");
            return TD_FAILURE;
        }
    }

    ret = uapi_pmoc_set_suspend_param(source, enable, &param);
    if (ret != TD_SUCCESS) {
        log_info_pmoc("uapi_pmoc_set_suspend_param err, 0x%08x !\n", ret);
        return ret;
    }

    return TD_SUCCESS;
}

static td_s32 set_timeout_suspend_param(td_void)
{
    td_s32 ret;
    td_u32 tmp;
    uapi_pmoc_wakeup_src source;
    td_bool enable;
    uapi_pmoc_suspend_param param;

    if (memset_s(&param, sizeof(param), 0, sizeof(param)) != EOK) {
        log_info_pmoc("param init failed");
        return TD_FAILURE;
    }

    pmoc_notice("================= Modify timeout suspend param ============\n");
    source = UAPI_PMOC_WAKEUP_TIMEOUT;
    ret = uapi_pmoc_get_suspend_param(source, &enable, &param);
    if (ret != TD_SUCCESS) {
        log_info_pmoc("uapi_pmoc_get_suspend_param err, 0x%08x !\n", ret);
        return ret;
    }

    pmoc_notice("Please input new timeout wakeup enable flag[%d]", enable);
    if (scanf_s("%u", &tmp) <= 0) {
        log_info_pmoc("scanf_s err!\n");
        return TD_FAILURE;
    }

    enable = (tmp != 0) ? TD_TRUE : TD_FALSE;

    if (enable) {
        pmoc_notice("Please input new suspend period[%u]", param.timeout_param.suspend_period);
        if (scanf_s("%u", &param.timeout_param.suspend_period) <= 0) {
            log_info_pmoc("scanf_s err!\n");
            return TD_FAILURE;
        }

        pmoc_notice("Please input new pvr enable flag[%d]", param.timeout_param.pvr_enable);
        if (scanf_s("%u", &tmp) <= 0) {
            log_info_pmoc("scanf_s err!\n");
            return TD_FAILURE;
        }

        param.timeout_param.pvr_enable = (tmp != 0) ? TD_TRUE : TD_FALSE;

        pmoc_notice("Please input mute wakeup enable flag[%d]", param.timeout_param.mute_wakeup_enable);
        if (scanf_s("%u", &tmp) <= 0) {
            log_info_pmoc("scanf_s err!\n");
            return TD_FAILURE;
        }

        param.timeout_param.mute_wakeup_enable = (tmp != 0) ? TD_TRUE : TD_FALSE;
    }

    ret = uapi_pmoc_set_suspend_param(source, enable, &param);
    if (ret != TD_SUCCESS) {
        log_info_pmoc("uapi_pmoc_set_suspend_param err, 0x%08x !\n", ret);
        return ret;
    }

    return TD_SUCCESS;
}

static td_s32 get_ir_suspend_param(td_void)
{
    td_s32 ret;
    td_u8 i;
    uapi_pmoc_wakeup_src source;
    td_bool enable;
    uapi_pmoc_suspend_param param;

    if (memset_s(&param, sizeof(param), 0, sizeof(param)) != EOK) {
        log_info_pmoc("param init failed");
        return TD_FAILURE;
    }

    pmoc_notice("================= ir suspend param ========================\n");
    source = UAPI_PMOC_WAKEUP_IR;
    ret = uapi_pmoc_get_suspend_param(source, &enable, &param);
    if (ret != TD_SUCCESS) {
        log_info_pmoc("uapi_pmoc_get_suspend_param err, 0x%08x !\n", ret);
        return ret;
    }

    log_info_pmoc("ir wakeup \t:%s \n", enable ? "enable" : "disable");

    if (enable) {
        log_info_pmoc("ir type \t:%d \n", param.ir_param.ir_type);

        for (i = 0; i < param.ir_param.ir_num; i++) {
            log_info_pmoc("IR wakeup key \t:High 32-bit(0x%08x), Low 32-bit(0x%08x)\n",
                param.ir_param.ir_high_val[i], param.ir_param.ir_low_val[i]);
        }
    }

    return TD_SUCCESS;
}

static td_s32 get_keyled_suspend_param(td_void)
{
    td_s32 ret;
    uapi_pmoc_wakeup_src source;
    td_bool enable;
    uapi_pmoc_suspend_param param;

    if (memset_s(&param, sizeof(param), 0, sizeof(param)) != EOK) {
        log_info_pmoc("param init failed");
        return TD_FAILURE;
    }

    pmoc_notice("================= keyled suspend param ====================\n");
    source = UAPI_PMOC_WAKEUP_KEYLED;
    ret = uapi_pmoc_get_suspend_param(source, &enable, &param);
    if (ret != TD_SUCCESS) {
        log_info_pmoc("uapi_pmoc_get_suspend_param err, 0x%08x !\n", ret);
        return ret;
    }

    log_info_pmoc("keyled wakeup \t:%s \n", enable ? "enable" : "disable");

    if (enable) {
        log_info_pmoc("keyled type \t:%u(0-CT1642, 1-FD650, 2-gpiokey, 3-not support)\n",
            param.keyled_param.keyled_type);

        if (param.keyled_param.keyled_type < EXT_KEYLED_TYPE_GPIOKEY) {
            log_info_pmoc("wakeup key \t:%u \n", param.keyled_param.wakeup_key);
        }
    }

    return TD_SUCCESS;
}

static td_s32 get_gpio_suspend_param(td_void)
{
    td_s32 ret;
    td_u8 i;
    uapi_pmoc_wakeup_src source;
    td_bool enable;
    uapi_pmoc_suspend_param param;

    if (memset_s(&param, sizeof(param), 0, sizeof(param)) != EOK) {
        log_info_pmoc("param init failed");
        return TD_FAILURE;
    }

    pmoc_notice("================= gpio suspend param ======================\n");
    source = UAPI_PMOC_WAKEUP_GPIO;
    ret = uapi_pmoc_get_suspend_param(source, &enable, &param);
    if (ret != TD_SUCCESS) {
        log_info_pmoc("uapi_pmoc_get_suspend_param err, 0x%08x !\n", ret);
        return ret;
    }

    log_info_pmoc("gpio wakeup \t:%s \n", enable ? "enable" : "disable");

    if (enable) {
        for (i = 0; i < param.gpio_param.num; i++) {
            log_info_pmoc("gpio port \t:%d_%d \n", param.gpio_param.group[i], param.gpio_param.bit[i]);
            log_info_pmoc("interrupt type \t:%d \n", param.gpio_param.interrupt_type[i]);
        }
    }

    return TD_SUCCESS;
}

static td_s32 get_lsadc_suspend_param(td_void)
{
    td_s32 ret;
    td_bool enable;
    td_u8 i;
    uapi_pmoc_wakeup_src source;
    uapi_pmoc_suspend_param param;

    if (memset_s(&param, sizeof(param), 0, sizeof(param)) != EOK) {
        log_info_pmoc("param init failed");
        return TD_FAILURE;
    }

    pmoc_notice("================= lsadc suspend param =====================\n");
    source = UAPI_PMOC_WAKEUP_LSADC;
    ret = uapi_pmoc_get_suspend_param(source, &enable, &param);
    if (ret != TD_SUCCESS) {
        log_info_pmoc("uapi_pmoc_get_suspend_param err, 0x%08x !\n", ret);
        return ret;
    }

    log_info_pmoc("lsadc wakeup \t:%s \n", enable ? "enable" : "disable");

    if (enable) {
        log_info_pmoc("lsadc channel mask \t:0x%x \n", param.lsadc_param.channel_mask);

        for (i = 0; i < UAPI_PMOC_LSADC_CHANNEL_MAXNUM; i++) {
            log_info_pmoc("lsadc key value range \t:Low (%u), High (%u)\n",
                param.lsadc_param.key_value_range[i].low, param.lsadc_param.key_value_range[i].high);
        }
    }

    return TD_SUCCESS;
}

static td_s32 get_uart_suspend_param(td_void)
{
    td_s32 ret;
    uapi_pmoc_wakeup_src source;
    td_bool enable;
    uapi_pmoc_suspend_param param;

    if (memset_s(&param, sizeof(param), 0, sizeof(param)) != EOK) {
        log_info_pmoc("param init failed");
        return TD_FAILURE;
    }

    pmoc_notice("================= uart suspend param ======================\n");
    source = UAPI_PMOC_WAKEUP_UART;
    ret = uapi_pmoc_get_suspend_param(source, &enable, &param);
    if (ret != TD_SUCCESS) {
        log_info_pmoc("uapi_pmoc_get_suspend_param err, 0x%08x !\n", ret);
        return ret;
    }

    log_info_pmoc("uart wakeup \t:%s \n", enable ? "enable" : "disable");

    if (enable) {
        log_info_pmoc("wakeup key \t:%u \n", param.uart_param.wakeup_key);
    }

    return TD_SUCCESS;
}

static td_s32 get_eth_suspend_param(td_void)
{
    td_s32 ret;
    uapi_pmoc_wakeup_src source;
    td_bool enable;
    uapi_pmoc_suspend_param param;

    if (memset_s(&param, sizeof(param), 0, sizeof(param)) != EOK) {
        log_info_pmoc("param init failed");
        return TD_FAILURE;
    }

    pmoc_notice("================= eth suspend param =======================\n");
    source = UAPI_PMOC_WAKEUP_ETH;
    param.eth_param.index = 0;

    ret = uapi_pmoc_get_suspend_param(source, &enable, &param);
    if (ret != TD_SUCCESS) {
        log_info_pmoc("uapi_pmoc_get_suspend_param err, 0x%08x !\n", ret);
        return ret;
    }

    if (enable) {
        log_info_pmoc("Magic packet wakeup \t:%s \n",
            param.eth_param.magic_packet_enable ? "enable" : "disable");
        log_info_pmoc("Unicast packet wakeup \t:%s \n",
            param.eth_param.unicast_packet_enable ? "enable" : "disable");
        log_info_pmoc("Wakeup frame wakeup \t:%s \n",
            param.eth_param.wakeup_frame_enable ? "enable" : "disable");
        log_info_pmoc("Eth wakeup mode to passive standby time \t:%u \n", param.eth_param.time_to_passive_standby);
        log_info_pmoc("mute wakeup \t:%s \n", param.eth_param.mute_wakeup_enable ? "enable" : "disable");
    } else {
        log_info_pmoc("eth wakeup \t:%s \n", enable ? "enable" : "disable");
    }

    return TD_SUCCESS;
}

static td_s32 get_voice_suspend_param(td_void)
{
    td_s32 ret;
    uapi_pmoc_wakeup_src source;
    td_bool enable;

    pmoc_notice("================= voice suspend param =====================\n");
    source = UAPI_PMOC_WAKEUP_VOICE;
    ret = uapi_pmoc_get_suspend_param(source, &enable, NULL);
    if (ret != TD_SUCCESS) {
        log_info_pmoc("uapi_pmoc_get_suspend_param err, 0x%08x !\n", ret);
        return ret;
    }

    log_info_pmoc("voice wakeup \t:%s \n", enable ? "enable" : "disable");

    return TD_SUCCESS;
}

static td_s32 get_vga_suspend_param(td_void)
{
    td_s32 ret;
    uapi_pmoc_wakeup_src source;
    td_bool enable;

    pmoc_notice("================== vga suspend param ======================\n");
    source = UAPI_PMOC_WAKEUP_VGA;
    ret = uapi_pmoc_get_suspend_param(source, &enable, NULL);
    if (ret != TD_SUCCESS) {
        log_info_pmoc("uapi_pmoc_get_suspend_param err, 0x%08x !\n", ret);
        return ret;
    }

    log_info_pmoc("vga wakeup \t:%s \n", enable ? "enable" : "disable");

    return TD_SUCCESS;
}

static td_s32 get_usb_suspend_param(td_void)
{
    td_s32 ret;
    uapi_pmoc_wakeup_src source;
    td_bool enable;
    uapi_pmoc_suspend_param param;

    if (memset_s(&param, sizeof(param), 0, sizeof(param)) != EOK) {
        log_info_pmoc("param init failed");
        return TD_FAILURE;
    }

    pmoc_notice("================= usb suspend param =======================\n");
    source = UAPI_PMOC_WAKEUP_USB;
    ret = uapi_pmoc_get_suspend_param(source, &enable, &param);
    if (ret != TD_SUCCESS) {
        log_info_pmoc("uapi_pmoc_get_suspend_param err, 0x%08x !\n", ret);
        return ret;
    }

    log_info_pmoc("usb wakeup \t:%s \n", enable ? "enable" : "disable");

    return TD_SUCCESS;
}

static td_s32 get_hdmirx_plugin_param(td_void)
{
    td_s32 ret;
    uapi_pmoc_wakeup_src source;
    td_bool enable;
    uapi_pmoc_suspend_param param;

    if (memset_s(&param, sizeof(param), 0, sizeof(param)) != EOK) {
        log_info_pmoc("param init failed");
        return TD_FAILURE;
    }

    pmoc_notice("================= hdmirx plugin suspend param =============\n");
    source = UAPI_PMOC_WAKEUP_HDMIRX_PLUGIN;
    ret = uapi_pmoc_get_suspend_param(source, &enable, &param);
    if (ret != TD_SUCCESS) {
        log_info_pmoc("uapi_pmoc_get_suspend_param err, 0x%08x !\n", ret);
        return ret;
    }

    log_info_pmoc("hdmirx plugin wakeup \t:%s \n", enable ? "enable" : "disable");

    if (enable) {
        log_info_pmoc("hdmirx plugin port \t:%u \n", param.hdmirx_plugin_param.port);
    }

    return TD_SUCCESS;
}

static td_s32 get_hdmirx_cec_suspend_param(td_void)
{
    td_s32 ret;
    uapi_pmoc_wakeup_src source;
    td_bool enable;

    pmoc_notice("================= hdmirx cec suspend param ================\n");
    source = UAPI_PMOC_WAKEUP_HDMIRX_CEC;
    ret = uapi_pmoc_get_suspend_param(source, &enable, NULL);
    if (ret != TD_SUCCESS) {
        log_info_pmoc("uapi_pmoc_get_suspend_param err, 0x%08x !\n", ret);
        return ret;
    }

    log_info_pmoc("hdmirx cec wakeup \t:%s \n", enable ? "enable" : "disable");

    return TD_SUCCESS;
}

static td_s32 get_hdmitx_cec_suspend_param(td_void)
{
    td_s32 ret;
    uapi_pmoc_wakeup_src source;
    td_bool enable;
    uapi_pmoc_suspend_param param;

    if (memset_s(&param, sizeof(param), 0, sizeof(param)) != EOK) {
        log_info_pmoc("param init failed");
        return TD_FAILURE;
    }

    pmoc_notice("================= hdmitx cec suspend param ================\n");
    source = UAPI_PMOC_WAKEUP_HDMITX_CEC;
    ret = uapi_pmoc_get_suspend_param(source, &enable, &param);
    if (ret != TD_SUCCESS) {
        log_info_pmoc("uapi_pmoc_get_suspend_param err, 0x%08x !\n", ret);
        return ret;
    }

    log_info_pmoc("hdmitx cec wakeup \t:%s \n", enable ? "enable" : "disable");

    if (enable) {
        log_info_pmoc("cec control type \t:%d \n", param.hdmitx_cec_param.cec_control[0]);
    }

    return TD_SUCCESS;
}

static td_s32 get_timeout_suspend_param(td_void)
{
    td_s32 ret;
    uapi_pmoc_wakeup_src source;
    td_bool enable;
    uapi_pmoc_suspend_param param;

    if (memset_s(&param, sizeof(param), 0, sizeof(param)) != EOK) {
        log_info_pmoc("param init failed");
        return TD_FAILURE;
    }

    pmoc_notice("================= timeout suspend param ===================\n");
    source = UAPI_PMOC_WAKEUP_TIMEOUT;
    ret = uapi_pmoc_get_suspend_param(source, &enable, &param);
    if (ret != TD_SUCCESS) {
        log_info_pmoc("uapi_pmoc_get_suspend_param err, 0x%08x !\n", ret);
        return ret;
    }

    log_info_pmoc("timeout wakeup \t:%s \n", enable ? "enable" : "disable");

    if (enable) {
        log_info_pmoc("suspend period \t:%u\n", param.timeout_param.suspend_period);
        log_info_pmoc("pvr enable flag \t:%s\n", param.timeout_param.pvr_enable ? "enable" : "disable");
        log_info_pmoc("mute enable flag \t:%s\n", param.timeout_param.mute_wakeup_enable ? "enable" : "disable");
    }

    return TD_SUCCESS;
}

static pmoc_wakeup_source_map g_wakeup_source_map[] = {
    { UAPI_PMOC_WAKEUP_TIMEOUT,       "TIMEOUT",       set_timeout_suspend_param,    get_timeout_suspend_param },
    { UAPI_PMOC_WAKEUP_IR,            "IR",            set_ir_suspend_param,         get_ir_suspend_param },
    { UAPI_PMOC_WAKEUP_KEYLED,        "KEYLED",        set_keyled_suspend_param,     get_keyled_suspend_param },
    { UAPI_PMOC_WAKEUP_GPIO,          "GPIO",          set_gpio_suspend_param,       get_gpio_suspend_param },
    { UAPI_PMOC_WAKEUP_LSADC,         "LSADC",         set_lsadc_suspend_param,      get_lsadc_suspend_param },
    { UAPI_PMOC_WAKEUP_UART,          "UART",          set_uart_suspend_param,       get_uart_suspend_param },
    { UAPI_PMOC_WAKEUP_ETH,           "ETH",           set_eth_suspend_param,        get_eth_suspend_param },
    { UAPI_PMOC_WAKEUP_USB,           "USB",           set_usb_suspend_param,        get_usb_suspend_param },
    { UAPI_PMOC_WAKEUP_VOICE,         "VOICE",         set_voice_suspend_param,      get_voice_suspend_param },
    { UAPI_PMOC_WAKEUP_VGA,           "VGA",           set_vga_suspend_param,        get_vga_suspend_param },
    { UAPI_PMOC_WAKEUP_HDMIRX_PLUGIN, "HDMIRX_PLUGIN", set_hdmirx_plugin_param,      get_hdmirx_plugin_param },
    { UAPI_PMOC_WAKEUP_HDMIRX_CEC,    "HDMIRX_CEC",    set_hdmirx_cec_suspend_param, get_hdmirx_cec_suspend_param },
    { UAPI_PMOC_WAKEUP_HDMITX_CEC,    "HDMITX_CEC",    set_hdmitx_cec_suspend_param, get_hdmitx_cec_suspend_param },
};

static td_s32 set_suspend_param(td_void)
{
    td_s32 ret;
    size_t i;
    size_t source_num;

    source_num = sizeof(g_wakeup_source_map) / sizeof(g_wakeup_source_map[0]);
    for (i = 0; i < source_num; i++) {
        ret = g_wakeup_source_map[i].f_set_suspend_param();
        if (ret != TD_SUCCESS) {
            log_info_pmoc("set %s suspend param err, 0x%08x !\n", g_wakeup_source_map[i].wakeup_source, ret);
            return ret;
        }
    }

    return TD_SUCCESS;
}

static td_s32 get_suspend_param(td_void)
{
    td_s32 ret;
    size_t i;
    size_t source_num;

    source_num = sizeof(g_wakeup_source_map) / sizeof(g_wakeup_source_map[0]);
    for (i = 0; i < source_num; i++) {
        ret = g_wakeup_source_map[i].f_get_suspend_param();
        if (ret != TD_SUCCESS) {
            log_info_pmoc("get %s suspend param err, 0x%08x !\n", g_wakeup_source_map[i].wakeup_source, ret);
            return ret;
        }
    }

    return TD_SUCCESS;
}

static td_s32 get_wakeup_attr(uapi_pmoc_wakeup_src source)
{
    td_s32 ret;
    td_u32 j;
    td_u32 standby_period;
    uapi_pmoc_wakeup_attr attr;

    for (j = 0; j < sizeof(g_wakeup_source_map) / sizeof(g_wakeup_source_map[0]); j++) {
        if (source == g_wakeup_source_map[j].source) {
            log_info_pmoc("wakeup by %s !!!\n", g_wakeup_source_map[j].wakeup_source);
        }
    }

    ret = uapi_pmoc_get_wakeup_attr(&attr);
    if (ret != TD_SUCCESS) {
        log_info_pmoc("uapi_pmoc_get_wakeup_attr err, 0x%08x !\n", ret);
        return ret;
    }

    if (attr.source == UAPI_PMOC_WAKEUP_IR) {
        log_info_pmoc("wakeup key(Low): 0x%x, key(High):0x%x \n", attr.wakeup_param.ir_param.ir_low_val,
            attr.wakeup_param.ir_param.ir_high_val);
    } else if (attr.source == UAPI_PMOC_WAKEUP_GPIO) {
        log_info_pmoc("wakeup by GPIO%d_%d \n", attr.wakeup_param.gpio_param.group,
            attr.wakeup_param.gpio_param.bit);
    }

    ret = uapi_pmoc_get_standby_period(&standby_period);
    if (ret != TD_SUCCESS) {
        log_info_pmoc("uapi_pmoc_get_standby_period err, 0x%08x !\n", ret);
        return ret;
    }

    log_info_pmoc("\nstandby period = %d \n", standby_period);

    return TD_SUCCESS;
}

static td_s32 tigger_standby(td_void)
{
    td_s32 ret;
    td_u32 runnint_count = 1;
    td_u32 i;
    td_bool enable;
    uapi_pmoc_suspend_param param;
    uapi_pmoc_wakeup_src source;

    if (memset_s(&param, sizeof(param), 0, sizeof(param)) != EOK) {
        log_info_pmoc("param init failed");
        return TD_FAILURE;
    }

    pmoc_notice("===================== enter standby ====================\n");
    pmoc_notice("Please input standby running count[%u]", runnint_count);
    modify_number(runnint_count);

    if (runnint_count > 1) {
        ret = uapi_pmoc_get_suspend_param(UAPI_PMOC_WAKEUP_TIMEOUT, &enable, &param);
        if (ret != TD_SUCCESS) {
            log_info_pmoc("uapi_pmoc_get_suspend_param err, 0x%08x !\n", ret);
            return ret;
        }

        if (!enable) {
            enable = TD_TRUE;

            pmoc_notice("Please input new standby period[%u s]", param.timeout_param.suspend_period);
            modify_number(param.timeout_param.suspend_period);

            ret = uapi_pmoc_set_suspend_param(UAPI_PMOC_WAKEUP_TIMEOUT, enable, &param);
            if (ret != TD_SUCCESS) {
                log_info_pmoc("uapi_pmoc_set_suspend_param err, 0x%08x !\n", ret);
                return ret;
            }
        }
    }

    for (i = 0; i < runnint_count; i++) {
        ret = uapi_pmoc_enter_standby(&source);
        if (ret != TD_SUCCESS) {
            log_info_pmoc("uapi_pmoc_enter_standby err, 0x%08x !\n", ret);
            return ret;
        }

        if (get_wakeup_attr(source) != TD_SUCCESS) {
            log_info_pmoc("get_wakeup_attr err!\n");
            return TD_FAILURE;
        }

        log_info_pmoc("%%%%%%%% cnt = %u %%%%%%%% \n", i);

        sleep(1);
    }

    pmoc_notice("========================================================\n");

    return TD_SUCCESS;
}

static td_s32 memory_standby(td_void)
{
    td_s32 ret;
    td_u32 j;
    uapi_pmoc_wakeup_src source;
    uapi_pdm_pmoc_param pmoc_param = {0};
    uapi_pdm_config_info info;

    if (memset_s(&info, sizeof(info), 0, sizeof(info)) != EOK) {
        log_info_pmoc("info init failed");
        return TD_FAILURE;
    }

    pmoc_notice("===================== memory standby ====================\n");

    if (uapi_pdm_get_pmoc_param(&pmoc_param) != TD_SUCCESS) {
        log_info_pmoc("uapi_pdm_get_pmoc_param err!\n");
        return TD_FAILURE;
    }

    if (pmoc_param.power_on_mode != UAPI_PDM_PMOC_MEMORY_STANDBY) {
        printf("memory standby flag has not been set\n");
        return TD_FAILURE;
    }

    if (uapi_pdm_get_cfg_info(&info) != TD_SUCCESS) {
        log_info_pmoc("uapi_pdm_get_cfg_info err!\n");
        return TD_FAILURE;
    }

    /* app should set memory flag when enter standby */
    info.pmoc_flag = UAPI_PDM_PMOC_MEMORY_FLAG_SUSPEND;
    if (uapi_pdm_update_cfg_info(&info) != TD_SUCCESS) {
        log_info_pmoc("uapi_pdm_update_cfg_info err!\n");
        return TD_FAILURE;
    }

    ret = uapi_pmoc_enter_standby(&source);
    if (ret != TD_SUCCESS) {
        log_info_pmoc("uapi_pmoc_enter_standby err, 0x%08x !\n", ret);
        return ret;
    }

    for (j = 0; j < sizeof(g_wakeup_source_map) / sizeof(g_wakeup_source_map[0]); j++) {
        if (source == g_wakeup_source_map[j].source) {
            log_info_pmoc("wakeup by %s !!!\n", g_wakeup_source_map[j].wakeup_source);
        }
    }

    /* app should clear memory flag when wakeup */
    info.pmoc_flag = UAPI_PDM_PMOC_MEMORY_FLAG_RUN;
    if (uapi_pdm_update_cfg_info(&info) != TD_SUCCESS) {
        log_info_pmoc("uapi_pdm_update_cfg_info err!\n");
        return TD_FAILURE;
    }

    pmoc_notice("========================================================\n");

    return TD_SUCCESS;
}

static td_s32 set_wakeup_type(td_void)
{
    td_s32 ret;
    uapi_pmoc_wakeup_type wakeup_type = {0};

    pmoc_notice("============= Modify wakeup type =============\n");
    pmoc_notice("(0-wakeup to ddr, 1-reset) Select wakeup type[%d]", wakeup_type);
    ret = scanf_s("%u", &wakeup_type);
    if (ret <= 0) {
        log_info_pmoc("scanf_s err!\n");
        return TD_FAILURE;
    }

    ret = uapi_pmoc_set_wakeup_type(wakeup_type);
    if (ret != TD_SUCCESS) {
        log_info_pmoc("get_timeout_suspend_param err, 0x%08x !\n", ret);
        return ret;
    }

    return TD_SUCCESS;
}

static td_s32 set_display_params(td_void)
{
    td_s32 ret;
    uapi_pmoc_display_param display_param = {0};

    pmoc_notice("============= Modify keyled display params =============\n");
    log_info_pmoc("Select keyled type(0-CT1642, 1-FD650, 3-gpiokey, 4-not support)");
    pmoc_notice("Please input new keyled type[%u]", display_param.keyled_type);
    ret = scanf_s("%u", &display_param.keyled_type);
    if (ret <= 0) {
        log_info_pmoc("scanf_s err!\n");
        return TD_FAILURE;
    }

    log_info_pmoc("Select display type(0-no display, 1-display number, 2-display time(in second))");
    pmoc_notice("Please input new display type[%d]", display_param.display_type);
    ret = scanf_s("%u", &display_param.display_type);
    if (ret <= 0) {
        log_info_pmoc("scanf_s err!\n");
        return TD_FAILURE;
    }

    if (display_param.display_type == UAPI_PMOC_DISPLAY_DIGIT) {
        pmoc_notice("Please input new display digit[%u]", display_param.display_value);
        ret = scanf_s("%u", &display_param.display_value);
        if (ret <= 0) {
            log_info_pmoc("scanf_s err!\n");
            return TD_FAILURE;
        }
    } else if (display_param.display_type == UAPI_PMOC_DISPLAY_TIME) {
        display_param.display_time_info.hour = 6; /* hour: 6 */
        display_param.display_time_info.minute = 9; /* minute: 9 */
        display_param.display_time_info.second = 36; /* second: 36 */
    }

    ret = uapi_pmoc_set_standby_display_param(&display_param);
    if (ret != TD_SUCCESS) {
        log_info_pmoc("uapi_pmoc_set_standby_display_param err, 0x%08x !\n", ret);
        return ret;
    }

    pmoc_notice("keyled display params modify success! \n");
    pmoc_notice("========================================================\n");

    return TD_SUCCESS;
}

static td_s32 set_gpio_power_off(td_void)
{
    td_s32 ret;
    td_u8 i;
    td_u32 tmp;
    uapi_pmoc_poweroff_gpio_param param = {0};

    pmoc_notice("============= Modify power off gpio params =============\n");

    pmoc_notice("Please input poweroff gpio num[%d]", param.num);
    ret = scanf_s("%u", &param.num);
    if (ret <= 0) {
        log_info_pmoc("scanf_s err!\n");
        return TD_FAILURE;
    }

    if (param.num > UAPI_PMOC_POWEROFF_GPIO_MAXNUM) {
        log_info_pmoc("num is bigger than %d, force it to %d", UAPI_PMOC_POWEROFF_GPIO_MAXNUM,
            UAPI_PMOC_POWEROFF_GPIO_MAXNUM);
        param.num = UAPI_PMOC_POWEROFF_GPIO_MAXNUM;
    }

    for (i = 0; i < param.num; i++) {
        pmoc_notice("Please input poweroff num%d group:[%d] ", i, param.group[i]);
        ret = scanf_s("%u", &tmp);
        if (ret <= 0) {
            log_info_pmoc("scanf_s err!\n");
            return TD_FAILURE;
        }

        param.group[i] = (td_u8)tmp;
        pmoc_notice("Please input poweroff num%d bit:[%d] ", i, param.bit[i]);
        ret = scanf_s("%u", &tmp);
        if (ret <= 0) {
            log_info_pmoc("scanf_s err!\n");
            return TD_FAILURE;
        }

        param.bit[i] = (td_u8)tmp;
        pmoc_notice("Please input poweroff num%u level:[%u] ", i, param.level[i]);
        ret = scanf_s("%u", &tmp);
        if (ret <= 0) {
            log_info_pmoc("scanf_s err!\n");
            return TD_FAILURE;
        }

        param.level[i] = (td_u8)tmp;
    }

    ret = uapi_pmoc_set_gpio_power_off(&param);
    if (ret != TD_SUCCESS) {
        log_info_pmoc("uapi_pmoc_set_gpio_power_off err, 0x%08x !\n", ret);
        return ret;
    }

    pmoc_notice("power off gpio params modify success! \n");
    pmoc_notice("========================================================\n");

    return TD_SUCCESS;
}

static td_s32 set_pmoc_poweron_flag(td_void)
{
    td_s32 ret;
    uapi_pdm_pmoc_param pmoc_param = {0};

    pmoc_notice("================ set poweron standby flag ==============\n");

    ret = uapi_pdm_get_pmoc_param(&pmoc_param);
    if (ret != TD_SUCCESS) {
        log_info_pmoc("uapi_pdm_get_pmoc_param err, 0x%08x !\n", ret);
        return ret;
    }

    log_info_pmoc("Select pmoc poweron flag(0-standby, 1-poweron, 2-memory standby)");
    pmoc_notice("Please input pmoc poweron flag:[%d] ", pmoc_param.power_on_mode);
    ret = scanf_s("%u", &pmoc_param.power_on_mode);
    if (ret <= 0) {
        log_info_pmoc("scanf_s err!\n");
        return TD_FAILURE;
    }

    ret = uapi_pdm_update_pmoc_param(&pmoc_param);
    if (ret != TD_SUCCESS) {
        log_info_pmoc("uapi_pdm_update_pmoc_param err, 0x%08x !\n", ret);
        return ret;
    }

    pmoc_notice("poweron standby flag modify success! \n");
    pmoc_notice("========================================================\n");

    return TD_SUCCESS;
}

static td_s32 get_pmoc_poweron_flag(td_void)
{
    td_s32 ret;
    uapi_pdm_pmoc_param pmoc_param = {0};
    uapi_pdm_config_info info;

    if (memset_s(&info, sizeof(info), 0, sizeof(info)) != EOK) {
        log_info_pmoc("info init failed");
        return TD_FAILURE;
    }

    ret = uapi_pdm_get_pmoc_param(&pmoc_param);
    if (ret != TD_SUCCESS) {
        log_info_pmoc("uapi_pdm_get_pmoc_param err, 0x%08x !\n", ret);
        return ret;
    }

    switch (pmoc_param.power_on_mode) {
        case UAPI_PDM_PMOC_STANDBY:
            printf("standby(when powerup) flag has been set\n");
            break;
        case UAPI_PDM_PMOC_POWERON:
            printf("poweron flag has been set\n");
            break;
        case UAPI_PDM_PMOC_MEMORY_STANDBY:
            printf("memory standby flag(when powerup) has been set\n");
            break;
        default:
            printf("not support flag\n");
            break;
    }

    ret = uapi_pdm_get_cfg_info(&info);
    if (ret != TD_SUCCESS) {
        log_info_pmoc("uapi_pdm_get_cfg_info err, 0x%08x !\n", ret);
        return ret;
    }

    switch (info.pmoc_flag) {
        case UAPI_PDM_PMOC_MEMORY_FLAG_RUN:
            printf("memorry flag has been set to UAPI_PDM_PMOC_MEMORY_FLAG_RUN\n");
            break;
        case UAPI_PDM_PMOC_MEMORY_FLAG_SUSPEND:
            printf("memorry flag has been set to UAPI_PDM_PMOC_MEMORY_FLAG_SUSPEND\n");
            break;
        default:
            printf("not support flag\n");
            break;
    }

    return TD_SUCCESS;
}

static td_s32 get_chip_temperature(td_void)
{
    td_s32 ret;
    uapi_pmoc_chip_temperature chip_temprature = {0};

    ret = uapi_pmoc_get_chip_temperature(&chip_temprature);
    if (ret != TD_SUCCESS) {
        log_info_pmoc("uapi_pmoc_get_chip_temperature err, 0x%08x !\n", ret);
        return ret;
    }

    pmoc_notice("==================== chip temperature ==================\n");
    pmoc_notice("chip temperature        \t:%d \n", chip_temprature.t_sensor1_temperature);
    pmoc_notice("========================================================\n");

    return TD_SUCCESS;
}

static td_s32 set_standby_led(td_void)
{
    td_s32 ret;
    td_u32 led_mode, tmp, led_breath_cycle;
    td_u8 group, bit, level;

    pmoc_notice("Select led mode in standby state(0-standby led, 1-breath led): ");
    ret = scanf_s("%u", &led_mode);
    if (ret <= 0) {
        log_info_pmoc("scanf_s err!\n");
        return TD_FAILURE;
    }

    pmoc_notice("Please input gpio group: ");
    ret = scanf_s("%u", &tmp);
    if (ret <= 0) {
        log_info_pmoc("scanf_s err!\n");
        return TD_FAILURE;
    }

    group = (td_u8)tmp;

    pmoc_notice("Please input gpio bit: ");
    ret = scanf_s("%u", &tmp);
    if (ret <= 0) {
        log_info_pmoc("scanf_s err!\n");
        return TD_FAILURE;
    }

    bit = (td_u8)tmp;

    if (led_mode == 0) {
        pmoc_notice("Please input gpio level(0/1): ");
        ret = scanf_s("%u", &tmp);
        if (ret <= 0) {
            log_info_pmoc("scanf_s err!\n");
            return TD_FAILURE;
        }

        level = (td_u8)tmp;

        ret = uapi_pmoc_set_standby_led(group, bit, level);
        if (ret != TD_SUCCESS) {
            log_info_pmoc("uapi_pmoc_set_standby_led err, 0x%08x !\n", ret);
            return ret;
        }
    } else {
        pmoc_notice("Please input led breath cycle(0~0xffffffff): ");
        ret = scanf_s("%u", &led_breath_cycle);
        if (ret <= 0) {
            log_info_pmoc("scanf_s err!\n");
            return TD_FAILURE;
        }

        ret = uapi_pmoc_set_breath_led(group, bit, led_breath_cycle);
        if (ret != TD_SUCCESS) {
            log_info_pmoc("uapi_pmoc_set_breath_led err, 0x%08x !\n", ret);
            return ret;
        }
    }

    return TD_SUCCESS;
}

static td_s32 set_mcu_msg(td_void)
{
    td_s32 ret;
    td_u32 msg_index, value;

    pmoc_notice("Input msg index(0~15): ");
    ret = scanf_s("%u", &msg_index);
    if (ret <= 0) {
        log_info_pmoc("scanf_s err!\n");
        return TD_FAILURE;
    }

    pmoc_notice("Input value: 0x");
    ret = scanf_s("%x", &value);
    if (ret <= 0) {
        log_info_pmoc("scanf_s err!\n");
        return TD_FAILURE;
    }

    ret = uapi_pmoc_set_mcu_msg(msg_index, value);
    if (ret != TD_SUCCESS) {
        log_info_pmoc("uapi_pmoc_set_mcu_msg err, 0x%08x !\n", ret);
        return ret;
    }

    return TD_SUCCESS;
}

static td_s32 get_mcu_msg(td_void)
{
    td_s32 ret;
    td_u32 msg_index, value;

    pmoc_notice("Input msg index(0~15): ");
    ret = scanf_s("%u", &msg_index);
    if (ret <= 0) {
        log_info_pmoc("scanf_s err!\n");
        return TD_FAILURE;
    }

    ret = uapi_pmoc_get_mcu_msg(msg_index, &value);
    if (ret != TD_SUCCESS) {
        log_info_pmoc("uapi_pmoc_get_mcu_msg err, 0x%08x !\n", ret);
        return ret;
    }

    printf("value: 0x%x\n", value);

    return TD_SUCCESS;
}

static td_s32 set_timer_wakeup_param(td_void)
{
    td_s32 ret;

    ret = set_timeout_suspend_param();
    if (ret != TD_SUCCESS) {
        log_info_pmoc("set_timeout_suspend_param err, 0x%08x !\n", ret);
        return ret;
    }

    return TD_SUCCESS;
}

static pmoc_func_map g_setting_functions[] = {
    { "timer_wakeup",       set_timer_wakeup_param },
    { "suspend_param",      set_suspend_param },
    { "wakeup_type",        set_wakeup_type },
    { "display",            set_display_params },
    { "power_off_gpio",     set_gpio_power_off },
    { "pmoc_poweron_flag",  set_pmoc_poweron_flag },
    { "standby_led",        set_standby_led },
    { "mcu_msg",            set_mcu_msg },
};

static pmoc_func_map g_getting_functions[] = {
    { "pmoc_poweron_flag",  get_pmoc_poweron_flag },
    { "suspend_param",      get_suspend_param },
    { "chip_temperature",   get_chip_temperature },
    { "mcu_msg",            get_mcu_msg },
};

static void sig_handler(int signo)
{
    unused(signo);
    _exit(0);
}

td_s32 main(td_s32 argc, td_char *argv[])
{
    td_s32 ret, result;
    td_u8 i;

    if (uapi_pmoc_init() != TD_SUCCESS) {
        return -1;
    }

    if (signal(SIGINT, sig_handler) == SIG_ERR) {
        log_info_pmoc("get SIGINT failed\n");
        return -1;
    }

    result = getopt(argc, argv, "tpms:g:");

    switch (result) {
        case 't':
            tigger_standby();
            uapi_pmoc_deinit();
            return 0;
        case 'p':
            power_off();
            uapi_pmoc_deinit();
            return 0;
        case 'm':
            memory_standby();
            uapi_pmoc_deinit();
            return 0;
        case 's':
            for (i = 0; i < sizeof(g_setting_functions) / sizeof(g_setting_functions[0]); i++) {
                if (strcmp(g_setting_functions[i].cmd, optarg) == 0) {
                    ret = g_setting_functions[i].f_process();
                    uapi_pmoc_deinit();
                    return ret;
                }
            }

            break;
        case 'g':
            for (i = 0; i < sizeof(g_getting_functions) / sizeof(g_getting_functions[0]); i++) {
                if (strcmp(g_getting_functions[i].cmd, optarg) == 0) {
                    ret = g_getting_functions[i].f_process();
                    uapi_pmoc_deinit();
                    return ret;
                }
            }

            break;
        default:
            break;
    }

    uapi_pmoc_deinit();

    show_usage_info();

    return -1;
}