src/lynq/framework/lynq-atsvc/src/lynq_common.cpp

/*============================================================================= 
**     FileName: lynq_common.cpp
**     Desc: lynq common
**     Author: Warren
**     Version: V1.0
**     LastChange: 2021-09-27 
**     History: 
**=============================================================================*/
#include <sys/types.h>
#include <signal.h>
#include <stdio.h>
#include <string.h>
#include <log/log.h>
#include "lynq_common.h"
#include "lynq_user.h"
#include "common.h"
#include <pthread.h>
#define USB_BUF_SIZE 8192
#include <liblog/lynq_deflog.h>
#include <sys/time.h>
#include "Phone_utils.h"
usb_cmd_t Usb_commands[] = {
#include "lynq_commands.h"
};

usb_at_transfer_t Usb_transfer_commands[] = {
#include "lynq_at_transfer_table.h"
};
#undef LOG_TAG
#define LOG_TAG "LYNQ_COMMON"

extern apn_table_t apn_table[LYNQ_APN_CHANNEL_MAX] = {};
extern int apn_count = 0;
extern char lynq_at[LYNQ_AT_LEN_MAX]= {};
pthread_cond_t lynq_at_cond = PTHREAD_COND_INITIALIZER;
pthread_mutex_t lynq_at_mutex= PTHREAD_MUTEX_INITIALIZER;

/*lei add for PMS szzt*/
int g_lynq_csclk = 0;
int g_lynq_mpwrsm = 0;//at+mpwrsm need
int g_lynq_mwakeupcfg = 0;//at+mwakeupcfg need
/*lei add for PMS szzt*/

//int lynqSendToRil(int argc,char *argv[],int uToken);
usb_at_transfer_t *lynqFindId(char *cmd)
{
    if(cmd==NULL)
    {
        RLOGD("lynqFindId CMD is NULL!!!");
        return ((usb_at_transfer_t*)NULL);
    }
    for(int i=0;Usb_transfer_commands[i].cmdName;i++)
    {
        if (strcmp (cmd, Usb_transfer_commands[i].cmdName) == 0)
        return (&Usb_transfer_commands[i]);
    }
    return ((usb_at_transfer_t*)NULL);
}

usb_cmd_t * lynqFindUsbEvent(char *cmd)
{
    if(cmd==NULL)
    {
        RLOGD("lynqFindUsbEvent CMD is NULL!!!");
        return ((usb_cmd_t*)NULL);
    }
    printf("cmd =%s\n",cmd);
    for(int i=0;Usb_commands[i].cmdName;i++)
    {
        if (strcmp (cmd, Usb_commands[i].cmdName) == 0)
        return (&Usb_commands[i]);
    }
    return ((usb_cmd_t *)NULL);
}

int routeCmd(int request)
{
    switch (request)
    {
        case LYNQ_REQUEST_CGMI:
        case LYNQ_REQUEST_GMI:
        case LYNQ_REQUEST_CGACT:
        case LYNQ_REQUEST_CGDCONT:
        case LYNQ_REQUEST_CFSN:
        {
             return LYNQ_GOTO_AT;
        }
        /*lei add szzt*/
        case LYNQ_REQUEST_CSCLK:
        case LYNQ_REQUEST_MPWRSM:
        case LYNQ_REQUEST_MWAKEUPCFG:
        {
            return LYNQ_GOTO_PMS;
        }
        /*lei add szzt*/
        case LYNQ_REQUEST_ATD:
        case LYNQ_REQUEST_LAPNACT:
        case LYNQ_REQUEST_ELAPNACT:
        case LYNQ_REQUEST_SCREEN_STATE:
        case LYNQ_REQUEST_SWITCH_SIM:
        {
            return LYNQ_GOTO_TELE_REQ;
        }
        case LYNQ_REQUEST_SEND_LOG_DATA:
        {
            return LYNQ_GOTO_PLAT_REQ;
        }
        case LYNQ_USER_REQUEST_GNSS:
        case LYNQ_USER_REQUEST_OTHRE:
        case LYNQ_REQUEST_RST:
        case LYNQ_PLAT_LGMDS:
        {
            return LYNQ_GOTO_USER_REQ;
        }
        case LYNQ_REQUEST_RNDIS:
        {

            return LYNQ_GOTO_RNDIS_REQ;
        }
        case LYNQ_REQUEST_LINFO:
            return LYNQ_GOTO_LINFO_REQ;
        case LYNQ_REQUEST_FACTORY:
            return LYNQ_GOTO_FACTORY;
        case LYNQ_REQUEST_FOTA:
            return LYNQ_GOTO_FOTA;
        default:
            return -1;
    }
}
int g_number(const char *p){
    int cnt = 0;
    while(*p != '\0'){
        if(*p == ','){
            cnt++;
        }
        *p++;
    }
    return cnt+4;//for count character string

}
int syncRespToUsb(int error_code)
{
    char BUF[32] = {};
    int ret = -1;
    int len = 0;
    if(error_code==0)
    {
        len = write(ttyGS3_fd,"\nOK\n",4);
    }
    else
    {
        sprintf(BUF,"+CME ERROR: %d\n\0",error_code);
        len = write(ttyGS3_fd,BUF,strlen(BUF));
    }
    if(len < 0)
    {
        perror("lynq resp write:");
        return -1;
    }
    return 0;
}
void lynqSetArgv(char **argv, char** Point,const char* value)
{
    *argv=*Point;
     sprintf(*argv, "%s", value);    
     (*Point) += (strlen(value)+1);
}
//argv[2]:0 send,1 list,2 get
int lynqParseUsbCommand(const char* cmd,char *argv[],char test[],char* parser_buf,int maxArgc)
{
    char *token;
    char *str = test;
    char *string;
    char *parameter;
    char* Point=parser_buf;
    int cnt = g_number(cmd);
    memcpy(test, cmd, strlen(cmd));
    test[strlen(cmd)] = '\0';
    argv[1] = (char *)cmd;
    if(strstr(cmd,"=?"))
    {
        token = strtok(str, "=?");
        //argv[0] = token;
        argv[0] = strstr(token, "+")+1; 
        lynqSetArgv(&(argv[2]),&Point,"1");
        while (token != NULL)
        {
            string = token;
            token = strtok(NULL, "=?");
        }
        parameter = strtok(string, ",");
        int i = 3;
        while (parameter != NULL)
        {
            argv[i++] = parameter;
            parameter = strtok(NULL, ",");
        }
    }
    else if(strstr(cmd,"="))
    {
        lynqSetArgv(&(argv[2]),&Point,"0");
        token = strtok(str, "=");
        //argv[0] = token;
        if(strstr(token, "+"))
        {
            argv[0] = strstr(token, "+")+1;
            while (token != NULL)
            {
                string = token;
                token = strtok(NULL, "=");
            }
            parameter = strtok(string, ",");
            int i = 3;
            while (parameter != NULL)
            {
                argv[i++] = parameter;
                parameter = strtok(NULL, ",");
            }
        }
        else
        {
            argv[0] = token;
        }
    }
    else if(strstr(cmd,"?"))
    {
        lynqSetArgv(&(argv[2]),&Point,"2");
        token = strtok(str, "?");
        //argv[0] = token;
        argv[0] = strstr(token, "+")+1;
        while (token != NULL)
        {
            string = token;
            token = strtok(NULL, "?");
        }
        parameter = strtok(string, ",");
        int i = 3;
        while (parameter != NULL)
        {
            argv[i++] = parameter;
            parameter = strtok(NULL, ",");
        }
    }
    else
    {
        lynqSetArgv(&(argv[2]),&Point,"0");
        if(strstr(cmd,"+"))
        {
            argv[0] = test+3;
            return 3;
        }
        else
        {
            RLOGD("sp test 01");
            if(!strcmp(cmd, "ATA")){
                lynqSetArgv(&(argv[0]),&Point,"ATA");
                return 3;
            }
            if(!strcmp(cmd, "AT")){
                lynqSetArgv(&(argv[0]),&Point,"AT");
                return 3;
            }
            /*UNKNOW*/
            else if(!strncmp(cmd, "ATD", 3)){
                lynqSetArgv(&(argv[0]),&Point,"ATD");
                argv[3] = test+3;
                return 4;
            }
            else if(!strncmp(cmd, "ATE", 3)){
                lynqSetArgv(&(argv[0]),&Point,"ATE");
                argv[3] = test+3;
                return 4;
            }
            else if(!strcmp(cmd, "ATH")){
                lynqSetArgv(&(argv[0]),&Point,"ATH");
                return 3;
            }
            else if(!strncmp(cmd, "ATI", 3)){
                lynqSetArgv(&(argv[0]),&Point,"ATI");
                argv[3] = test+3;
                return 4;
            }
            else if(!strncmp(cmd, "ATL", 3)){
                lynqSetArgv(&(argv[0]),&Point,"ATL");
                argv[3] = test+3;
                return 4;
            }
            else if(!strncmp(cmd, "ATO", 3)){
                lynqSetArgv(&(argv[0]),&Point,"ATO");
                argv[3] = test+3;
                return 3;
            }
            /*ATP*/
            /*
            */
            else if(!strncmp(cmd, "ATQ", 3)){
                lynqSetArgv(&(argv[0]),&Point,"ATQ");
                argv[3] = test+3;
                return 4;
            }
            else if(!strncmp(cmd, "ATS3", 4)){
                lynqSetArgv(&(argv[0]),&Point,"ATS3");
                argv[3] = test+4;
                return 4;
            }
            else if(!strncmp(cmd, "ATS4", 4)){
                lynqSetArgv(&(argv[0]),&Point,"ATS4");
                argv[3] = test+4;
                return 4;
            }
            else if(!strncmp(cmd, "ATS5", 4)){
                lynqSetArgv(&(argv[0]),&Point,"ATS5");
                argv[3] = test+4;
                return 4;
            }
            /*ATS6*/
            /*
            */
            else if(!strncmp(cmd, "ATS7", 4)){
                lynqSetArgv(&(argv[0]),&Point,"ATS7");
                argv[3] = test+4;
                return 4;
            }
            else if(!strncmp(cmd, "ATS8", 4)){
                lynqSetArgv(&(argv[0]),&Point,"ATS8");
                argv[3] = test+4;
                return 4;
            }
            else if(!strncmp(cmd, "ATS10", 5)){
                lynqSetArgv(&(argv[0]),&Point,"ATS10");
                argv[3] = test+5;
                return 4;
            }
            /*ATT*/
            /*



            */
            else if(!strncmp(cmd, "ATV", 3)){
                lynqSetArgv(&(argv[0]),&Point,"ATV");
                argv[3] = test+3;
                return 4;
            }
            /*ATX*/
            /*



            */
            else if(!strncmp(cmd, "ATZ", 3)){
                lynqSetArgv(&(argv[0]),&Point,"ATZ");
                argv[3] = test+3;
                return 4;
            }
            else if(!strncmp(cmd, "AT&F", 4)){
                lynqSetArgv(&(argv[0]),&Point,"AT&F");
                argv[3] = test+4;
                return 4;
            }
            else
            {
                RLOGD("can't find this command");
                return -1;
            }
        }
    }
    //char *testtest = strstr(argv[0], "+")+1;
    //printf("testtest:%s\n", testtest);
    //argv[0] = testtest;
    //printf("%d\n", __FUNCTION__);
    if(cnt > maxArgc)
        return -1;
    return cnt;
}

int CGMI(int argc,char*argv[],char *rilReq, int uToken)
{
    return 0;
}
int dialACall(int argc,char*argv[],char *rilReq, int uToken)
{
    if(argc < 4)
    {
        RLOGD("parameter error!!!");
        return 1;
    }
    char *new_argv[3] = {};
    new_argv[0] = (char *)rilReq;
    new_argv[1] = argv[3];
    new_argv[2] = "0";
    android::lynqSendToRil(3,new_argv,uToken);
    return 0;
}
int checkDataRegistration(int uToken)
{
    /*chech radio status*/
    int ret = -1;
    char *argv_temp[3]={};
    argv_temp[0] = "RIL_REQUEST_DATA_REGISTRATION_STATE";
    android::lynqSendToRil(1,argv_temp,uToken);
    ret = lynqATWaitWithTime(10);
    printf("ret=%d\n,current_data_reg=%d\n",ret,current_data_reg);
    /*
    if(ret == ETIMEDOUT)
    {
        int n = write(ttyGS3_fd,"+CME:ERROR 8004\n",strlen("+CME:ERROR 8004\n"));
        if(n<0)
        {
            perror("lynq resp write:");
        }
        return -1;
    }
    */
    if(current_data_reg!=0)
    {
        int n = write(ttyGS3_fd,"+CME ERROR: 1\n",strlen("+CME ERROR: 1\n"));
        if(n<0)
        {
            perror("lynq resp write:");
        }
        return -1;
    }
    return 0;
}
int setupData(int argc,char*argv[],char *rilReq, int uToken)
{
    int status = 0;
    int ret = -1;
    if(argc < 4)
    {
        RLOGD("parameter error!!!");
        return -1;
    }
    bzero(lynq_at,LYNQ_AT_LEN_MAX);
    sprintf(lynq_at,"LAPNACT");
    status = atoi(argv[3]);
    char *new_argv[3] = {};
    if(status==1)
    {
        ret = checkDataRegistration(uToken);
        if(ret != 0)
        {
            RLOGD("[setupData] radio is not available!!!");
            return -1;
        }
        new_argv[0] = (char *)rilReq;
        android::lynqSendToRil(1,new_argv,uToken);
        syncRespToUsb(0);
    }
    else if(status == 0)
    {
        new_argv[0] = "RIL_REQUEST_DEACTIVATE_DATA_CALL";
        android::lynqSendToRil(1,new_argv,uToken);
    }
    return 0;
}
int setupData_e(int argc,char*argv[],char *rilReq, int uToken)
{
    int status = 0;
    int ret = -1;
    if(argc < 5)
    {
        RLOGD("parameter error!!!");
        return 1;
    }
    bzero(lynq_at,LYNQ_AT_LEN_MAX);
    sprintf(lynq_at,"ELAPNACT");
    char *new_argv[10] = {};
    status = atoi(argv[3]);
    if(status == 1 )
    {
        ret = checkDataRegistration(uToken);
        if(ret != 0)
        {
            RLOGD("[setupData] radio is not available!!!");
            return -1;
        }
        new_argv[0] = (char *)rilReq;
        new_argv[1] = argv[4];//apn
        new_argv[2] = argv[5];//apntype
        new_argv[3] = argv[6];//user
        new_argv[4] = argv[7];//password
        new_argv[5] = argv[8];//authType
        new_argv[6] = argv[9];//normalprotocol
        new_argv[7] = argv[10];//roamingprotocol
        //memcpy(apn_table[apn_count].apn,argv[4],strlen(argv[4]));
        //apn_count++;
        android::lynqSendToRil(8,new_argv,uToken);
        syncRespToUsb(0);
    }
    else if(status == 0)
    {
        new_argv[0] = "RIL_REQUEST_DEACTIVATE_DATA_CALL";
        new_argv[1] = argv[4];//apntype
        android::lynqSendToRil(2,new_argv,uToken);
    }
    return 0;
}
int switchSim(int argc,char*argv[],char *rilReq, int uToken)
{
    int slot = 0;
    int ret = -1;
    char *new_argv[10] = {};
    if(argc < 4)
    {
        RLOGD("parameter error!!!");
        return 1;
    }
    slot = atoi(argv[3]);
    new_argv[0] = (char *)rilReq;
    new_argv[1] = argv[3];
    android::lynqSendToRil(2,new_argv,uToken);
    return 0;
}

void * thread_test(void * arg)
{
    FILE *fp;
    char buf[1024*3] = {0};
    sprintf(buf, "echo 11 | emdlogger_ctrl 2>&1");
    fp=popen(buf, "r");
    if(!fp){
        perror("popen:");
    }
    while(fgets(buf, 4072, fp) != NULL){}
    pclose(fp);
    return 0;
}

int lynq_screen(int argc,char*argv[],char *rilReq, int uToken){
    char eBuf[64] = {0};
    sprintf(eBuf,"\nOK\n\0");
    int n = write(ttyGS3_fd,eBuf,strlen(eBuf));
    if(n<0)
    {
        perror("lynq resp write:");
    }
    pthread_t thid;
    int ret = pthread_create(&thid, NULL, thread_test, NULL);
    if(ret != 0){
        RLOGD("pthread_create error!!!");
        return ret;
    }
    system("mdlogctl stop");
    system("echo mem > /sys/power/autosleep");
    system("echo 0 > /dev/wmtWifi");
    system("echo 7 9 0 > /proc/driver/wmt_dbg");
    char *new_argv[2] = {};
    if(argc < 4)
    {
        RLOGD("parameter error!!!");
        return -1;
    }
    new_argv[0] = (char *)rilReq;
    new_argv[1] = argv[3];
    android::lynqSendToRil(2,new_argv,uToken);
    system("disown -a");
    ret = pthread_join(thid,NULL);
    if(ret != 0){
        RLOGD("pthread_join error!!!");
        return ret;
    }
    return 0;
}

void* getMDstate(int argc,char*argv[],int uToken)
{
    FILE *FP;
    char BUFFER[64]={};
    char BUF[32] = {};
    int ret = -1;
    int len = 0;
    FP = popen("cat /sys/kernel/ccci/boot","r");
    fgets(BUFFER,sizeof(BUFFER),FP);
    printf("buffer %s",BUFFER);
    modemStatus = atoi(&BUFFER[4]);
    sprintf(BUF,"+LGMDS:%d\n\0",modemStatus);
    len = write(ttyGS3_fd,BUF,strlen(BUF));
    if(len < 0)
    {
        perror("lynq resp write:");
        return 0;
    }
    syncRespToUsb(0);
    return 0;
}

void* rst(int argc,char*argv[],int uToken)
{
    system("reboot");
    syncRespToUsb(0);
    kill(0, SIGKILL);
    return 0;
}

int lynqATWaitWithTime(int time)
{
    int ret = 0;
    struct timespec start_tm;
    //struct timespec end_tm;
    //int timeout_ms = 2500;
    clock_gettime(CLOCK_MONOTONIC, &start_tm);
    //struct timeval now;
    struct timespec outTime;
    //gettimeofday(&now, NULL);//now.tv_sec(s),now.tv_usec(Micro s)
    outTime.tv_sec = start_tm.tv_sec + time;
    pthread_mutex_lock(&lynq_at_mutex);
    //ret = pthread_cond_timedwait(&lynq_at_cond,&lynq_at_mutex,&outTime);
    pthread_cond_wait(&lynq_at_cond,&lynq_at_mutex);
    pthread_mutex_unlock(&lynq_at_mutex);
    return ret;
}
void lynqAtRespWatingEvent()
{
    pthread_mutex_lock(&lynq_at_mutex);
    pthread_cond_signal(&lynq_at_cond);
    pthread_mutex_unlock(&lynq_at_mutex);
    return;
}
void lynqInfo(char*argv[])
{
    int type = atoi(argv[2]);
    if(type==2){
        lynq_output_LINFO_all();
        syncRespToUsb(0);
    }
    else if(type==0){
        int status = atoi(argv[3]);
        if(status==1 || status==0){
            lynq_output_LINFO_enable=status;
            lynq_output_info("+LINFO: Report switch when key information changed is set: %d\n",lynq_output_LINFO_enable);
            syncRespToUsb(0);
        }
        else {
            lynq_output_info("parameter error\n"); 
            syncRespToUsb(100);    
        }
    }
    else if(type==1){
        lynq_output_info("+LINFO: (0-1)\n");
        syncRespToUsb(0);
    }
    else {
        lynq_output_info("parameter error\n");
        syncRespToUsb(100);
    }
}


/**
 * @brief auto_suspend
 * @param  argv        [Type]:in     My Param doc
 */
static void auto_suspend(char *argv)
{
    if(NULL == argv)
    {
        return;
    }
    #if 0
    char buf[128] = {0};
    char cmd[64] = {0};
    sprintf(buf, "%s%s%s", "uci set lynq_uci.lynq_autosuspend.auto_enable=\'", argv, "\'");
    system(buf);
    system("commit");
    system("systemctl stop autosuspend.service");
    system("systemctl start autosuspend.service");
    usleep(1000*100);
    sprintf(cmd, "%s %s", "autosuspend-client-demo", argv);
    system(cmd);
    #endif
    pthread_t thid;
    int ret = pthread_create(&thid, NULL, thread_test, NULL);
    if(ret != 0){
        RLOGD("pthread_create error!!!");
        return;
    }
    system("mdlogctl stop");
    system("echo 0 > /dev/wmtWifi");
    system("echo 7 9 0 > /proc/driver/wmt_dbg");
    char *new_argv[2] = {};
    new_argv[0] = "RIL_REQUEST_SCREEN_STATE";
    new_argv[1] = "0";
    android::lynqSendToRil(2,new_argv,666);
    if(!strcmp(argv,"1"))
    {
        //autosleep
        system("echo mem > /sys/power/autosleep");
        
    }
    else if (!strcmp(argv,"0"))
    {
        //state
        system("echo mem > /sys/power/state");
    }
    return;
}

/**
 * @brief check_pin_level
 * @param  buf              Type:[in]
 * @param  flag             Type:[in]
 * @return int 
 */
static int check_pin_level(char *buf, int flag)
{
    if(NULL == buf)
    {
        return -1;
    }
    if(flag > strlen(buf))
    {
        return -1;
    }
    char *p = buf;
    int tmp = 0;
    while(*p != '\0')
    {
        if(tmp != flag)
        {
            tmp++;
            *p ++;
        }
        else
        {
            if(*p == '1')
            {
                return 0;
            }
            else
            {
                return 1;
            }
        }
    }
}

/**
 * @brief check_dtr_level 0 is low, 1 is high
 * @return int 
 */
static int cat_pin_level(char *pin)
{
    FILE *fp;
    char buf[32] = {0};
    char cmd[64] = {0};
    sprintf(cmd,"%s %s %s", "cat /sys/devices/platform/10005000.pinctrl/mt_gpio |grep", pin, "2>&1");
    fp = popen(cmd, "r");
    if(NULL == fp)
    {
        return -1;
    }
    fgets(buf, sizeof(buf), fp);
    //lynq_output_info("test: %c\n", buf[8]);
    if(!check_pin_level(buf, 8))//mean high level
    {
        pclose(fp);
        return 1;
    }
    //mean low level
    pclose(fp);
    return 0;
}

/**
 * @brief display_get_mode
 * @param  argv      [Type]:in       My Param doc
 */
static void display_get_mode(char *argv[])
{
    RLOGD("display_get_mode");
    if(!strcmp(argv[0], "CSCLK"))
    {
        lynq_output_info("+CSCLK: %d\n", g_lynq_csclk);
    }
    else if(!strcmp(argv[0], "MPWRSM"))
    {
        lynq_output_info("+MPWRSM: %d\n", g_lynq_mpwrsm);
    }
    else if(!strcmp(argv[0], "MWAKEUPCFG"))
    {
        lynq_output_info("+MWAKEUPCFG: %d\n", g_lynq_mwakeupcfg);
    }
    syncRespToUsb(0);
    return;
}

/**
 * @brief display_list_modeget_mode
 * @param  argv      [Type]:in       My Param doc
 */
static void display_list_mode(char *argv[])
{
    RLOGD("display_list_mode\n");
    if(!strcmp(argv[0], "CSCLK"))
    {
        RLOGD("CSCLK list mode\n");
        lynq_output_info("+CSCLK: (0-1)\n");
    }
    else if(!strcmp(argv[0], "MPWRSM"))
    {
        RLOGD("MPWRSM list mode\n");
        lynq_output_info("+MPWRSM: (0-1)\n");
    }
    else if(!strcmp(argv[0], "MWAKEUPCFG"))
    {
        RLOGD("MWAKEUPCFG list mode\n");
        lynq_output_info("+MWAKEUPCFG: (0-1)\n");
    }
    RLOGD("get list mode\n");
    syncRespToUsb(0);
    return;
}

/**
 * @brief display_set_mode
 * @param  argv      [Type]:in       My Param doc
 */
static void display_set_mode(char *argv[])
{
    RLOGD("display_set_mode\n");
    if(!strcmp(argv[0], "CSCLK"))
    {
        g_lynq_csclk = atoi(argv[3]);
        if(g_lynq_csclk == 1)
        {
            /*if dtr is 1, at+mpwrsm will check dtr pin level*/
            RLOGD("dtr is 1, at+mpwrsm will check dtr pin level\n");
        }
        else if(g_lynq_csclk == 0)
        {
            /*if dtr is 1, at+mpwrsm will't check dtr pin level*/
            RLOGD("dtr is 0, at+mpwrsm will't check dtr pin level\n");
        }
        #if 0
        else if(g_lynq_csclk == 2)
        {
            /*g_lynq_wakeup_in*/
            g_lynq_wakeup_in = 1;
        }
        #endif
    }
    else if(!strcmp(argv[0], "MPWRSM"))
    {
        RLOGD("at+MPWRSM begin\n");
        g_lynq_mpwrsm = atoi(argv[3]);
        /*AT+MPWRSM state*/
        if(!strcmp(argv[3], "0"))
        {
            /*if module entry sleep mode, need to pull ring pin low level*/
            system("echo out 63 0 >/sys/devices/platform/10005000.pinctrl/mt_gpio");
            #ifdef CV2X_SUPPORT
            /*DSR pin pull high level to wake up host*/
            system("echo out 62 0 >/sys/devices/platform/10005000.pinctrl/mt_gpio");
            //lynq_output_info("test: DSR\n");
            #endif
            /*quit sleep mode*/
            auto_suspend(argv[3]);
            return;
        }
        /*AT+MPWRSM autosleep*/
        else if(!strcmp(argv[3], "1"))
        {
            RLOGD("at+MPWRSM begin and value is 1\n");
            if(g_lynq_csclk == 0)
            {
                /*if module entry sleep mode, need to pull ring pin low level*/
                system("echo out 63 0 >/sys/devices/platform/10005000.pinctrl/mt_gpio");
                #ifdef CV2X_SUPPORT
                /*DSR pin pull high level to wake up host*/
                system("echo out 62 0 >/sys/devices/platform/10005000.pinctrl/mt_gpio");
                //lynq_output_info("test: DSR\n");
                #endif
                RLOGD("g_lynq_csclk = 0, entry sleep mode, dont't check dtr pin level\n");
                auto_suspend(argv[3]);
                return;
            }
            /*DTR pin*/
            else if(g_lynq_csclk == 1)
            {
                RLOGD("g_lynq_csclk = 1, entry sleep mode, check dtr pin level\n");
                /*check dtr level*/
                if(cat_pin_level("061"))//cat dtr pin level
                {
                    /*if module entry sleep mode, need to pull ring pin low level*/
                    system("echo out 63 0 >/sys/devices/platform/10005000.pinctrl/mt_gpio");
                    #ifdef CV2X_SUPPORT
                    /*DSR pin pull high level to wake up host*/
                    system("echo out 62 0 >/sys/devices/platform/10005000.pinctrl/mt_gpio");
                    #endif
                    auto_suspend(argv[3]);
                    return;
                }
                else
                {
                    syncRespToUsb(10);//dtr pin is high level, so can't entry sleep mode
                    return; 
                }
            }
            #if 0
            /*WAKEUP_IN pin*/
            else if(g_lynq_csclk == 2)
            {
                if(g_lynq_wakeup_in == 0)
                {
                    /*don't check WAKEUP_IN level*/
                    auto_suspend(argv[3]);
                    /*if module entry sleep mode, need to pull ring pin high level*/
                    system("echo out 4 1 >/sys/devices/platform/10005000.pinctrl/mt_gpio");
                }
                /*check WAKEUP_IN level*/
                else if (g_lynq_wakeup_in == 1)
                {
                    if(cat_pin_level("xxx"))
                    {
                        auto_suspend(argv[3]);
                        /*if module entry sleep mode, need to pull ring pin high level*/
                        system("echo out 4 1 >/sys/devices/platform/10005000.pinctrl/mt_gpio");
                    }
                    else
                    {
                        syncRespToUsb(10);//WAKEUP_IN pin is low level, so can't entry sleep mode
                        return;
                    }
                }
            }
            #endif
        }
        /*invalid value*/
        else
        {
            syncRespToUsb(100);
            return;
        }
    }
    else if(!strcmp(argv[0], "MWAKEUPCFG"))
    {
        g_lynq_mwakeupcfg = atoi(argv[3]);
    }
    syncRespToUsb(0);
}

/**
 * @brief when user input at of sleep,it will work
 * @param  argv             My Param doc
 */
void lynq_pms(char *argv[])
{
    RLOGD("lynq_pms works\n");
    int type = atoi(argv[2]);
    if(type == 2)//get mode
    {
        RLOGD("get mode\n");
        display_get_mode(argv);
    }
    else if(type == 0)//set mode
    {
        RLOGD("set mode\n");
        display_set_mode(argv);
    }
    else if(type == 1)//get list mode
    {
        RLOGD("get list mode\n");
        display_list_mode(argv);
    }
    return;
}