lynq/R305/ap/lib/libatext/ext_amt_func.c

/**
 * 
 * @file      ext_amt_func.c
 * @brief     
 *            This file is part of FTM.
 *            AMTÄ£¿éÏà¹ØATÃüÁî
 *            
 * @details   
 * @author    Tools Team.
 * @email     
 * @copyright Copyright (C) 2013 Sanechips Technology Co., Ltd.
 * @warning   
 * @date      2019/02/02
 * @version   1.1
 * @pre       
 * @post      
 *            
 * @par       
 * Change History :
 * ---------------------------------------------------------------------------
 * date        version  author         description
 * ---------------------------------------------------------------------------
 * 2018/04/28  1.0      liu.xin        Create file
 * 2019/02/02  1.1      jiang.fenglin  ÐÞ¸Ä×¢ÊÍ·½Ê½Îªdoxygen
 * ---------------------------------------------------------------------------
 * 
 * 
 */

#include "ext_regist.h"
#include "at_com.h"
#include <unistd.h>
#include <sys/syscall.h> 
#include "RONvParam_AMT.h"
#include "ref_nv_def.h"
#include "nv_api.h"
#include "amtnv.h"
#include <linux/soc/zte/efuse/efuse_zx.h>
#include "NvParam_drv.h"
#include "libkey.h"

//mdlÓû§Ä£Ê½ÇÐÑз¢Ä£Ê½¼øȨ½á¹û
static int auth_device_key_result = 0;

#define GET_LCD_INFO   378
#define GET_WIFI_INFO  379
#define GET_FLASH_INFO 380
#define GET_CPU_INFO   381
#define GET_DDR_INFO   382
//CP
typedef unsigned char  BYTE;

#define DC_MacLen               (BYTE)12
#define DC_ImeiLen              (BYTE)8
#define MSN_MAX_NVINFO_LEN      20
#define MSINFO_MAX_NVINFO_LEN   200
#define MDMVERSION_MAX_LEN      64
#define bInside(data, up, down) (((data) <= (up) && (data) >= (down)) || \
                                                  ((data) >= (up) && (data) <= (down)))
typedef unsigned long u32_t;
	
#ifndef SMEMCPY
#define SMEMCPY(dst,src,len)            memcpy(dst,src,len)
#endif

/**
 * @brief ZMDMVERSIONÏìÓ¦ÏûÏ¢½á¹¹Ìå
 * @param result  ½á¹ûÂë AT_RSP_OK/AT_RSP_ERR
 * @param mdmVer  modem°æ±¾ºÅ
 */
typedef struct
{
    char mdmVer[MDMVERSION_MAX_LEN]; 
    int result;
}AT_MDMVERSION_RSP_INFO;

//static char mdmVer[MDMVERSION_MAX_LEN] = {0};//ÓÃÓڼǼZGMR »Ø¸´½á¹û

struct flash_ddr_info{
    char manu[32];
    char model[32];
    char size[32];
    char other[32];
};

struct lcd_info
{
    char manu[32];
    char ic[32];
    char resolution[32];
};

struct wifi_info
{
    char manu[32];
    char ic[32];
};
struct cpu_info{
    char manu[32];
    char model[32];
};

/* Data structure for MD5 (Message-Digest) computation */
typedef struct {
  u32_t i[2];               /* number of _bits_ handled mod 2^64 */
  u32_t buf[4];             /* scratch buffer */
  unsigned char in[64];     /* input buffer */
  unsigned char digest[16]; /* actual digest after md5_final call */
} md5_ctx;


extern void at_context_chn_info_mod(char *at_paras);

/*
 ***********************************************************************
 **  Message-digest routines:                                         **
 **  To form the message digest for a message M                       **
 **    (1) Initialize a context buffer ctx using md5_init             **
 **    (2) Call md5_update on ctx and M                               **
 **    (3) Call md5_final on ctx                                      **
 **  The message digest is now in ctx->digest[0...15]                 **
 ***********************************************************************
 */

/* forward declaration */
static void transform(u32_t *buf, u32_t *in);

static unsigned char PADDING[64] = {
  0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
};

/* F, G, H and I are basic MD5 functions */
#define F(x, y, z) (((x) & (y)) | ((~x) & (z)))
#define G(x, y, z) (((x) & (z)) | ((y) & (~z)))
#define H(x, y, z) ((x) ^ (y) ^ (z))
#define I(x, y, z) ((y) ^ ((x) | (~z)))

/* ROTATE_LEFT rotates x left n bits */
#define ROTATE_LEFT(x, n) (((x) << (n)) | ((x) >> (32-(n))))

/* FF, GG, HH, and II transformations for rounds 1, 2, 3, and 4 */
/* Rotation is separate from addition to prevent recomputation */
#define FF(a, b, c, d, x, s, ac) \
  {(a) += F ((b), (c), (d)) + (x) + (u32_t)(ac); \
   (a) = ROTATE_LEFT ((a), (s)); \
   (a) += (b); \
  }
#define GG(a, b, c, d, x, s, ac) \
  {(a) += G ((b), (c), (d)) + (x) + (u32_t)(ac); \
   (a) = ROTATE_LEFT ((a), (s)); \
   (a) += (b); \
  }
#define HH(a, b, c, d, x, s, ac) \
  {(a) += H ((b), (c), (d)) + (x) + (u32_t)(ac); \
   (a) = ROTATE_LEFT ((a), (s)); \
   (a) += (b); \
  }
#define II(a, b, c, d, x, s, ac) \
  {(a) += I ((b), (c), (d)) + (x) + (u32_t)(ac); \
   (a) = ROTATE_LEFT ((a), (s)); \
   (a) += (b); \
  }

#ifdef __STDC__
#define UL(x) x##UL
#else
#ifdef WIN32
#define UL(x) x##UL
#else
#define UL(x) x
#endif
#endif

/* The routine md5_init initializes the message-digest context
   mdContext. All fields are set to zero.
 */
void md5_init(md5_ctx *ctx)
{
	ctx->i[0] = ctx->i[1] = (u32_t)0;

  /* Load magic initialization constants. */
    ctx->buf[0] = (u32_t)0x67452301UL;
    ctx->buf[1] = (u32_t)0xefcdab89UL;
    ctx->buf[2] = (u32_t)0x98badcfeUL;
    ctx->buf[3] = (u32_t)0x10325476UL;
}

/* The routine md5_update updates the message-digest context to
   account for the presence of each of the characters buf[0..inLen-1]
   in the message whose digest is being computed.
 */

void md5_update(md5_ctx *ctx, unsigned char *buf, unsigned int len)
{
  u32_t in[16];
  int mdi;
  unsigned int i, ii;

#if 0
  ppp_trace(LOG_INFO, "MD5Update: %u:%.*H\n", len, MIN(len, 20) * 2, buf);
  ppp_trace(LOG_INFO, "MD5Update: %u:%s\n", len, buf);
#endif

  /* compute number of bytes mod 64 */
  mdi = (int)((ctx->i[0] >> 3) & 0x3F);

  /* update number of bits */
  if ((ctx->i[0] + ((u32_t)len << 3)) < ctx->i[0]) {
    ctx->i[1]++;
  }
  ctx->i[0] += ((u32_t)len << 3);
  ctx->i[1] += ((u32_t)len >> 29);

  while (len--) {
    /* add new character to buffer, increment mdi */
    ctx->in[mdi++] = *buf++;

    /* transform if necessary */
    if (mdi == 0x40) {
      for (i = 0, ii = 0; i < 16; i++, ii += 4) {
        in[i] = (((u32_t)ctx->in[ii+3]) << 24) |
                (((u32_t)ctx->in[ii+2]) << 16) |
                (((u32_t)ctx->in[ii+1]) << 8)  |
                ((u32_t)ctx->in[ii]);
      }
      transform (ctx->buf, in);
      mdi = 0;
    }
  }
}

/* The routine md5_final terminates the message-digest computation and
   ends with the desired message digest in ctx->digest[0...15].
 */

void md5_final(unsigned char hash[], md5_ctx *ctx)
{
  u32_t in[16];
  int mdi;
  unsigned int i, ii;
  unsigned int pad_len;

  /* save number of bits */
  in[14] = ctx->i[0];
  in[15] = ctx->i[1];

  /* compute number of bytes mod 64 */
  mdi = (int)((ctx->i[0] >> 3) & 0x3F);

  /* pad out to 56 mod 64 */
  pad_len = (mdi < 56) ? (56 - mdi) : (120 - mdi);
  md5_update (ctx, PADDING, pad_len);

  /* append length in bits and transform */
  for (i = 0, ii = 0; i < 14; i++, ii += 4) {
    in[i] = (((u32_t)ctx->in[ii+3]) << 24) |
            (((u32_t)ctx->in[ii+2]) << 16) |
            (((u32_t)ctx->in[ii+1]) << 8)  |
            ((u32_t)ctx->in[ii]);
  }
  transform (ctx->buf, in);

  /* store buffer in digest */
  for (i = 0, ii = 0; i < 4; i++, ii += 4) {
    ctx->digest[ii]   = (unsigned char)(ctx->buf[i] & 0xFF);
    ctx->digest[ii+1] =
      (unsigned char)((ctx->buf[i] >> 8)  & 0xFF);
    ctx->digest[ii+2] =
      (unsigned char)((ctx->buf[i] >> 16) & 0xFF);
    ctx->digest[ii+3] =
      (unsigned char)((ctx->buf[i] >> 24) & 0xFF);
  }
  SMEMCPY(hash, ctx->digest, 16);
}

/* Basic MD5 step. Transforms buf based on in.
 */
static void transform (u32_t *buf, u32_t *in)
{
  u32_t a = buf[0], b = buf[1], c = buf[2], d = buf[3];

  /* Round 1 */
  #define S11 7
  #define S12 12
  #define S13 17
  #define S14 22
  FF ( a, b, c, d, in[ 0], S11, UL(3614090360)); /* 1 */
  FF ( d, a, b, c, in[ 1], S12, UL(3905402710)); /* 2 */
  FF ( c, d, a, b, in[ 2], S13, UL( 606105819)); /* 3 */
  FF ( b, c, d, a, in[ 3], S14, UL(3250441966)); /* 4 */
  FF ( a, b, c, d, in[ 4], S11, UL(4118548399)); /* 5 */
  FF ( d, a, b, c, in[ 5], S12, UL(1200080426)); /* 6 */
  FF ( c, d, a, b, in[ 6], S13, UL(2821735955)); /* 7 */
  FF ( b, c, d, a, in[ 7], S14, UL(4249261313)); /* 8 */
  FF ( a, b, c, d, in[ 8], S11, UL(1770035416)); /* 9 */
  FF ( d, a, b, c, in[ 9], S12, UL(2336552879)); /* 10 */
  FF ( c, d, a, b, in[10], S13, UL(4294925233)); /* 11 */
  FF ( b, c, d, a, in[11], S14, UL(2304563134)); /* 12 */
  FF ( a, b, c, d, in[12], S11, UL(1804603682)); /* 13 */
  FF ( d, a, b, c, in[13], S12, UL(4254626195)); /* 14 */
  FF ( c, d, a, b, in[14], S13, UL(2792965006)); /* 15 */
  FF ( b, c, d, a, in[15], S14, UL(1236535329)); /* 16 */

  /* Round 2 */
  #define S21 5
  #define S22 9
  #define S23 14
  #define S24 20
  GG ( a, b, c, d, in[ 1], S21, UL(4129170786)); /* 17 */
  GG ( d, a, b, c, in[ 6], S22, UL(3225465664)); /* 18 */
  GG ( c, d, a, b, in[11], S23, UL( 643717713)); /* 19 */
  GG ( b, c, d, a, in[ 0], S24, UL(3921069994)); /* 20 */
  GG ( a, b, c, d, in[ 5], S21, UL(3593408605)); /* 21 */
  GG ( d, a, b, c, in[10], S22, UL(  38016083)); /* 22 */
  GG ( c, d, a, b, in[15], S23, UL(3634488961)); /* 23 */
  GG ( b, c, d, a, in[ 4], S24, UL(3889429448)); /* 24 */
  GG ( a, b, c, d, in[ 9], S21, UL( 568446438)); /* 25 */
  GG ( d, a, b, c, in[14], S22, UL(3275163606)); /* 26 */
  GG ( c, d, a, b, in[ 3], S23, UL(4107603335)); /* 27 */
  GG ( b, c, d, a, in[ 8], S24, UL(1163531501)); /* 28 */
  GG ( a, b, c, d, in[13], S21, UL(2850285829)); /* 29 */
  GG ( d, a, b, c, in[ 2], S22, UL(4243563512)); /* 30 */
  GG ( c, d, a, b, in[ 7], S23, UL(1735328473)); /* 31 */
  GG ( b, c, d, a, in[12], S24, UL(2368359562)); /* 32 */

  /* Round 3 */
  #define S31 4
  #define S32 11
  #define S33 16
  #define S34 23
  HH ( a, b, c, d, in[ 5], S31, UL(4294588738)); /* 33 */
  HH ( d, a, b, c, in[ 8], S32, UL(2272392833)); /* 34 */
  HH ( c, d, a, b, in[11], S33, UL(1839030562)); /* 35 */
  HH ( b, c, d, a, in[14], S34, UL(4259657740)); /* 36 */
  HH ( a, b, c, d, in[ 1], S31, UL(2763975236)); /* 37 */
  HH ( d, a, b, c, in[ 4], S32, UL(1272893353)); /* 38 */
  HH ( c, d, a, b, in[ 7], S33, UL(4139469664)); /* 39 */
  HH ( b, c, d, a, in[10], S34, UL(3200236656)); /* 40 */
  HH ( a, b, c, d, in[13], S31, UL( 681279174)); /* 41 */
  HH ( d, a, b, c, in[ 0], S32, UL(3936430074)); /* 42 */
  HH ( c, d, a, b, in[ 3], S33, UL(3572445317)); /* 43 */
  HH ( b, c, d, a, in[ 6], S34, UL(  76029189)); /* 44 */
  HH ( a, b, c, d, in[ 9], S31, UL(3654602809)); /* 45 */
  HH ( d, a, b, c, in[12], S32, UL(3873151461)); /* 46 */
  HH ( c, d, a, b, in[15], S33, UL( 530742520)); /* 47 */
  HH ( b, c, d, a, in[ 2], S34, UL(3299628645)); /* 48 */

  /* Round 4 */
  #define S41 6
  #define S42 10
  #define S43 15
  #define S44 21
  II ( a, b, c, d, in[ 0], S41, UL(4096336452)); /* 49 */
  II ( d, a, b, c, in[ 7], S42, UL(1126891415)); /* 50 */
  II ( c, d, a, b, in[14], S43, UL(2878612391)); /* 51 */
  II ( b, c, d, a, in[ 5], S44, UL(4237533241)); /* 52 */
  II ( a, b, c, d, in[12], S41, UL(1700485571)); /* 53 */
  II ( d, a, b, c, in[ 3], S42, UL(2399980690)); /* 54 */
  II ( c, d, a, b, in[10], S43, UL(4293915773)); /* 55 */
  II ( b, c, d, a, in[ 1], S44, UL(2240044497)); /* 56 */
  II ( a, b, c, d, in[ 8], S41, UL(1873313359)); /* 57 */
  II ( d, a, b, c, in[15], S42, UL(4264355552)); /* 58 */
  II ( c, d, a, b, in[ 6], S43, UL(2734768916)); /* 59 */
  II ( b, c, d, a, in[13], S44, UL(1309151649)); /* 60 */
  II ( a, b, c, d, in[ 4], S41, UL(4149444226)); /* 61 */
  II ( d, a, b, c, in[11], S42, UL(3174756917)); /* 62 */
  II ( c, d, a, b, in[ 2], S43, UL( 718787259)); /* 63 */
  II ( b, c, d, a, in[ 9], S44, UL(3951481745)); /* 64 */

  buf[0] += a;
  buf[1] += b;
  buf[2] += c;
  buf[3] += d;
}

static int is_mac_valid(char*macStr)
{
    int Macindex = 0;
	for (; (macStr[Macindex] != '\0') && (Macindex < OS_FLASH_AMT_COMM_RO_WIFIMAC_SIZE); Macindex++)
    {
        char chmac = macStr[Macindex];
        if (!(bInside(chmac, '0', '9') || bInside(chmac, 'a', 'f') || bInside(chmac, 'A', 'F')))
        {
            at_print(AT_DEBUG,"mac is not hex str\r");
            return FALSE;
        }
	}
    return TRUE;
}
static char Ascii2BCD(char iAscii)
{
    char iBCD;

    if ( bInside(iAscii, '0', '9'))
    {
        iBCD = iAscii - '0';

    }
    else if (bInside(iAscii, 'a', 'f'))
    {
        iBCD = iAscii - 'a' + 0x0a;

    }
    else if (bInside(iAscii, 'A', 'F'))
    {
        iBCD = iAscii - 'A' + 0x0a;
    }
    else
    {
        return -1;
    }

    return iBCD;

}

static char BCD2Ascii(char iBCD)
{
    char iAscii;

    if (bInside(iBCD, 0x00, 0x09))
    {
        iAscii = (unsigned char)(iBCD + '0');
    }
    else if (bInside(iBCD, 0x0a, 0x0f))
    {
        iAscii = (unsigned char)((iBCD - 0x0a) + 'A');
    }
    else
    {
        return -1;
    }
    return iAscii;
}

static int IsImeiStrValid(char* imeiStr)
{
    int i = 0;
    for (; i < 15; ++i)
    {
        if (imeiStr[i] < '0' || imeiStr[i] > '9')
        {
            return FALSE;
        }
    }
    return TRUE;
}

static long Char2Int(char chr)
{
    long value = 0;
    value =  (chr - '0');
    return value;
}

static char Int2Char(long value)
{
    char ch = '0'+value;
    return ch;
}

static unsigned long DC_Writeimei(char * imeistr)
{
    int     Imeiindex =0,checkindex=0;
    BYTE    abImei[DC_ImeiLen]={0};
    BYTE    Index1=0,Index2=0;
    
    for(Imeiindex=0;imeistr[Imeiindex]!='\0';Imeiindex+=2)
    {    
        at_print(AT_DEBUG,"Imeiindex= %d\r\n",Imeiindex);
        at_print(AT_DEBUG,"imeistr[%d]= %c\r\n",Imeiindex,imeistr[Imeiindex]);

        Index1=Char2Int((char)imeistr[Imeiindex]);      
        at_print(AT_DEBUG,"Index1= %d\r",Index1);
        
        if((imeistr[Imeiindex+1])!='\0')
        {
        
            Index2= Char2Int((char)imeistr[Imeiindex+1]);
            at_print(AT_DEBUG,"Index2= %d, Index2<<4 =%x , (Index2<<4)&Index1 = %x\r\n",Index2,Index2<<4,(Index2<<4)|Index1);

            abImei[Imeiindex/2]=(Index2<<4)|Index1;
            at_print(AT_DEBUG,"abImei[%d]= %x\r\n",Imeiindex/2,abImei[Imeiindex/2]);
        }
        else
        {
            abImei[Imeiindex/2]=0xF0|Index1;
            at_print(AT_DEBUG,"abImei[%d]= %x\r\n",Imeiindex/2,abImei[Imeiindex/2]);
            break;
        }
    }
    for(checkindex=0;checkindex<8;checkindex++)
    {
        at_print(AT_DEBUG,"abImei[%d] = %x\r\n",checkindex,abImei[checkindex]);
    }

    if(CPNV_ERROR == amt_nvro_write(OS_FLASH_AMT_COMM_RO_IMEI_ADDRESS, sizeof(abImei), abImei))
    {
        at_print(AT_ERR,"Write amt imei failed\r\n");
        return  -1;
    }

    return 0;
}


/**************************************************************************
* º¯ÊýÃû³Æ: DC_WriteMacAddr
* ¹¦ÄÜÃèÊö: ASCIIÂëת»»³ÉBCDÂ룬²¢ ½«MACµØַдÈëµ½NVÖÐ
* ²ÎÊý˵Ã÷: (IN)
*                         (OUT)
* ·µ »Ø Öµ: ÎÞ
* ÆäËü˵Ã÷:
**************************************************************************/
static unsigned long DC_WriteMacAddr(char *macstr)
{
    unsigned long   Macindex = 0;
    unsigned char   abMac[OS_FLASH_AMT_COMM_RO_WIFIMAC_SIZE] = {0};
    unsigned char   Index1 = 0;
    unsigned char   Index2 = 0;

	if(!is_mac_valid(macstr))
	{
	     at_print(AT_DEBUG,"mac is not hex str\r");
         return -1;
	}

    /*ASCIIÂëת»»³ÉBCDÂë*/
    for (Macindex = 0; macstr[Macindex] != '\0' && (Macindex < OS_FLASH_AMT_COMM_RO_WIFIMAC_SIZE); Macindex += 2)
    {
        Index1 = (unsigned char)Ascii2BCD((char)macstr[Macindex]);
        Index2 = (unsigned char)Ascii2BCD((char)macstr[Macindex + 1]);
        abMac[Macindex/2]=(Index1<<4)|Index2;
    }
    
    if (CPNV_ERROR == amt_nvro_write(OS_FLASH_AMT_COMM_RO_WIFIMAC_ADDRESS, OS_FLASH_AMT_COMM_RO_WIFIMAC_SIZE, abMac))
    {
        at_print(AT_DEBUG,"Write amt mac failed\r");
        return  -1;
    }

    return  0;
}

/**************************************************************************
* º¯ÊýÃû³Æ: DC_WriteMac2Addr
* ¹¦ÄÜÃèÊö: ASCIIÂëת»»³ÉBCDÂ룬²¢ ½«MACµØַдÈëµ½NVÖÐ
* ²ÎÊý˵Ã÷: (IN)
*                         (OUT)
* ·µ »Ø Öµ: ÎÞ
* ÆäËü˵Ã÷:
**************************************************************************/
static unsigned long DC_WriteMac2Addr(char *macstr)
{
    unsigned long   Macindex = 0;
    unsigned char   abMac[OS_FLASH_AMT_COMM_RO_WIFIMAC2_SIZE] = {0};
    unsigned char   Index1 = 0;
    unsigned char   Index2 = 0;
	
	if(!is_mac_valid(macstr))
	{
	     at_print(AT_DEBUG,"mac is not hex str\r");
         return -1;
	}

    /*ASCIIÂëת»»³ÉBCDÂë*/
    for (Macindex = 0; macstr[Macindex] != '\0' && (Macindex < OS_FLASH_AMT_COMM_RO_WIFIMAC2_SIZE); Macindex += 2)
    {
        Index1 = (unsigned char)Ascii2BCD((char)macstr[Macindex]);
        Index2 = (unsigned char)Ascii2BCD((char)macstr[Macindex + 1]);
		abMac[Macindex/2]=(Index1<<4)|Index2;
    }
    
    if (CPNV_ERROR== amt_nvro_write(OS_FLASH_AMT_COMM_RO_WIFIMAC2_ADDRESS, OS_FLASH_AMT_COMM_RO_WIFIMAC2_SIZE, abMac))
    {
        at_print(AT_DEBUG,"Write amt mac failed\r");
        return -1;
    }

    return 0;
}

/**************************************************************************
* º¯ÊýÃû³Æ: DC_WriteRJ45MacAddr
* ¹¦ÄÜÃèÊö: ASCIIÂëת»»³ÉBCDÂ룬²¢ ½«MACµØַдÈëµ½NVÖÐ
* ²ÎÊý˵Ã÷: (IN)
*                         (OUT)
* ·µ »Ø Öµ: ÎÞ
* ÆäËü˵Ã÷:
**************************************************************************/
unsigned long DC_WriteRJ45MacAddr(char *macstr)
{
    unsigned long   Macindex = 0;
    unsigned char   abMac[OS_FLASH_AMT_COMM_RO_ETHMAC_SIZE] = {0};
    unsigned char   Index1 = 0;
    unsigned char   Index2 = 0;

	if(!is_mac_valid(macstr))
	{
	     at_print(AT_DEBUG,"mac is not hex str\r");
         return -1;
	}

    /*ASCIIÂëת»»³ÉBCDÂë*/
    for (Macindex = 0; macstr[Macindex] != '\0' && (Macindex < OS_FLASH_AMT_COMM_RO_ETHMAC_SIZE); Macindex += 2)
    {
        Index1 = (unsigned char)Ascii2BCD((char)macstr[Macindex]);
        Index2 = (unsigned char)Ascii2BCD((char)macstr[Macindex + 1]);
        abMac[Macindex/2]=(Index1<<4)|Index2;
    }

    if (CPNV_ERROR== amt_nvro_write(OS_FLASH_AMT_COMM_RO_ETHMAC_ADDRESS, OS_FLASH_AMT_COMM_RO_ETHMAC_SIZE, abMac))
    {
        at_print(AT_DEBUG,"Write amt ethmac failed\r");
        return -1;
    }

    return 0;
}


/**************************************************************************
* º¯ÊýÃû³Æ: DC_WriteMacAddr
* ¹¦ÄÜÃèÊö: ASCIIÂëת»»³ÉBCDÂ룬²¢ ½«USB MACµØַдÈëµ½NVÖÐ
* ²ÎÊý˵Ã÷: (IN)
*                         (OUT)
* ·µ »Ø Öµ: ÎÞ
* ÆäËü˵Ã÷:
**************************************************************************/
static unsigned long DC_WriteUSBMacAddr(char *macstr)
{
    unsigned long   Macindex = 0;
    unsigned char   abMac[OS_FLASH_AMT_COMM_RO_USBMAC_SIZE] = {0};
    unsigned char   Index1 = 0;
    unsigned char   Index2 = 0;

	if(!is_mac_valid(macstr))
	{
	     at_print(AT_DEBUG,"mac is not hex str\r");
         return -1;
	}

    /*ASCIIÂëת»»³ÉBCDÂë*/
    for (Macindex = 0; macstr[Macindex] != '\0' && (Macindex < OS_FLASH_AMT_COMM_RO_USBMAC_SIZE); Macindex += 2)
    {
        Index1 = (unsigned char)Ascii2BCD((char)macstr[Macindex]);
        Index2 = (unsigned char)Ascii2BCD((char)macstr[Macindex + 1]);
        abMac[Macindex/2]=(Index1<<4)|Index2;
    }
    
    if (CPNV_ERROR == amt_nvro_write(OS_FLASH_AMT_COMM_RO_USBMAC_ADDRESS, OS_FLASH_AMT_COMM_RO_USBMAC_SIZE, abMac))
    {
        at_print(AT_DEBUG,"Write amt usb mac failed\r");
        return  -1;
    }

    return  0;
}

/**************************************************************************
* º¯ÊýÃû³Æ: DC_WriteMacAddr
* ¹¦ÄÜÃèÊö: ASCIIÂëת»»³ÉBCDÂ룬²¢ ½«GMACµØַдÈëµ½NVÖÐ
* ²ÎÊý˵Ã÷: (IN)
*                         (OUT)
* ·µ »Ø Öµ: ÎÞ
* ÆäËü˵Ã÷:
**************************************************************************/
static unsigned long DC_WriteGmacAddr(char *macstr)
{
    unsigned long   Macindex = 0;
    unsigned char   abMac[OS_FLASH_AMT_COMM_RO_GMAC_SIZE] = {0};
    unsigned char   Index1 = 0;
    unsigned char   Index2 = 0;

	if(!is_mac_valid(macstr))
	{
	     at_print(AT_DEBUG,"mac is not hex str\r");
         return -1;
	}

    /*ASCIIÂëת»»³ÉBCDÂë*/
    for (Macindex = 0; macstr[Macindex] != '\0' && (Macindex < OS_FLASH_AMT_COMM_RO_GMAC_SIZE); Macindex += 2)
    {
        Index1 = (unsigned char)Ascii2BCD((char)macstr[Macindex]);
        Index2 = (unsigned char)Ascii2BCD((char)macstr[Macindex + 1]);
        abMac[Macindex/2]=(Index1<<4)|Index2;
    }

    if (CPNV_ERROR == amt_nvro_write(OS_FLASH_AMT_COMM_RO_GMAC_ADDRESS, OS_FLASH_AMT_COMM_RO_GMAC_SIZE, abMac))
    {
        at_print(AT_DEBUG,"Write amt Gmac failed\r");
        return  -1;
    }

    return  0;
}


static int rkeydc_act_func(int at_fd,char * at_paras,void **res_msg,int * res_msglen)
{
    int retCode = -1;
    //char pStr[8] = {0};
    char *at_str = NULL;
    struct flash_ddr_info flashInfo = {{0}};
    struct flash_ddr_info ddrInfo = {{0}};
    struct cpu_info cpuInfo = {{0}};
    struct wifi_info wifiInfo = {{0}};
    struct lcd_info lcdInfo = {{0}};
    
    at_print(AT_ERR,"rkeydc_act_func: \n");
    at_str = malloc(64);
	if(at_str == NULL)
		return AT_END;
    memset(at_str,0,64);
    if(strstr(at_paras, "DDR"))
    {
        retCode = syscall(GET_DDR_INFO,ddrInfo.manu,ddrInfo.size,ddrInfo.model);
        if(retCode < 0)
        {
            at_print(AT_ERR,"rkeydc_act_func: syscall GET_DDR_INFO failed \n");
			free(at_str);
            return AT_END;
        }
        at_print(AT_ERR,"rkeydc_act_func: ddrInfo.manu = %s,size = %s,model =%s\n",ddrInfo.manu,ddrInfo.size,ddrInfo.model);
        snprintf((char*)at_str,64,"\r\n%s?NA?NA?%s?%s\r\n",ddrInfo.manu,ddrInfo.size,ddrInfo.model);
        *res_msg = at_str;
        *res_msglen = strlen(*res_msg);
    }
    else if(strstr(at_paras, "FLASH"))
    {
        retCode = syscall(GET_FLASH_INFO,flashInfo.manu,flashInfo.model,flashInfo.size);
        if(retCode < 0)
        {
            at_print(AT_ERR,"rkeydc_act_func: syscall GET_FLASH_INFO failed \n");
			free(at_str);
            return AT_END;
        }
        at_print(AT_ERR,"rkeydc_act_func: flashInfo.manu = %s,model = %s,size =%s\n",flashInfo.manu,flashInfo.model,flashInfo.size);
        snprintf((char*)at_str,64,"\r\n%s?%s?NA?%s?NA\r\n",flashInfo.manu,flashInfo.model,flashInfo.size);
        *res_msg = at_str;
        *res_msglen = strlen(*res_msg);
    }
    else if(strstr(at_paras, "LCD"))
    {   
        retCode = syscall(GET_LCD_INFO,lcdInfo.manu,lcdInfo.ic,lcdInfo.resolution);
        if(retCode < 0)
        {
            at_print(AT_ERR,"rkeydc_act_func: syscall GET_LCD_INFO failed \n");
		    free(at_str);
            return AT_END;
        }
        at_print(AT_ERR,"rkeydc_act_func: lcdInfo.manu = %s,ic = %s,resolution =%s\n",lcdInfo.manu,lcdInfo.ic,lcdInfo.resolution);
        snprintf((char*)at_str,64,"\r\n%s?%s?NA?NA?%s\r\n",lcdInfo.manu,lcdInfo.ic,lcdInfo.resolution);
        *res_msg = at_str;
        *res_msglen = strlen(*res_msg);
    }
    else if(strstr(at_paras, "WIFI"))
    {   
        retCode = syscall(GET_WIFI_INFO,wifiInfo.manu,wifiInfo.ic);
        if(retCode < 0)
        {
            at_print(AT_ERR,"rkeydc_act_func: syscall GET_WIFI_INFO failed \n");
			free(at_str);
            return AT_END;
        }
        at_print(AT_ERR,"rkeydc_act_func: wifiInfo.manu = %s,ic = %s\n",wifiInfo.manu,wifiInfo.ic);
        snprintf((char*)at_str,64,"\r\n%s?%s?NA?NA?NA\r\n",wifiInfo.manu,wifiInfo.ic);
        *res_msg = at_str;
        *res_msglen = strlen(*res_msg);
    }
    else if(strstr(at_paras, "CPU"))
    {   
        retCode = syscall(GET_CPU_INFO,cpuInfo.manu,cpuInfo.model);
        if(retCode < 0)
        {
            at_print(AT_ERR,"rkeydc_act_func: syscall GET_CPU_INFO failed \n");
			free(at_str);
            return AT_END;
        }
        at_print(AT_ERR,"rkeydc_act_func: cpuInfo.manu = %s,model =%s\n",cpuInfo.manu,cpuInfo.model);
        snprintf((char*)at_str,64,"\r\n%s?%s?NA?NA?NA\r\n",cpuInfo.manu,cpuInfo.model);
        *res_msg = at_str;
        *res_msglen = strlen(*res_msg);
    }
	else
	{
	    free(at_str);
	}
    
    return AT_END;
    
}

int poweroff_act_func(int at_fd,char * at_paras,void **res_msg,int * res_msglen)
{
    system("poweroff");
    // add by houweifeng for zhangwei 20200707, systemº¯Êý²¢²»ÊÇÒ»¶¨Í¬²½Ö´ÐÐ
    *res_msg = at_ok_build();
    *res_msglen = strlen(*res_msg);
    return AT_END;
}

/**************************************************************************
* º¯ÊýÃû³Æ: chip_platform_read_act_func
* ¹¦ÄÜÃèÊö: return chip platform 1:7520V3 2:7100
* ²ÎÊý˵Ã÷: (IN)
*                         (OUT)
* ·µ »Ø Öµ: ÎÞ
* ÆäËü˵Ã÷:
**************************************************************************/
int chip_platform_read_act_func(int at_fd,char * at_paras,void * *res_msg,int * res_msglen)
{
    char TmpChipPlatform[32]    ={0};
    snprintf((char *)TmpChipPlatform, 32,"1");
    *res_msg = at_query_result_build("PLATFORM",TmpChipPlatform);
    *res_msglen = strlen(*res_msg);
       
    return AT_END;
}

/**************************************************************************
* º¯ÊýÃû³Æ: imeiRead_act_func
* ¹¦ÄÜÃèÊö: ¶ÁimeiºÅ
* ²ÎÊý˵Ã÷: (IN)
*                         (OUT)
* ·µ »Ø Öµ: ÎÞ
* ÆäËü˵Ã÷:
**************************************************************************/
int imeiRead_act_func(int at_fd,char * at_paras,void * *res_msg,int * res_msglen)
{
    unsigned int retCode =  -1;
    char TmpImei[DC_ImeiLen]= {0}; //imei³¤¶È×î´óÖµ
    int abImeiindex = 0,imeistrindex = 0;
    static char imeistr[2*DC_ImeiLen] = {0};
    char *at_str = NULL;
    
    retCode = cpnv_NvItemRead(OS_FLASH_AMT_COMM_RO_IMEI_ADDRESS, (unsigned char *)TmpImei, OS_FLASH_AMT_COMM_RO_IMEI_SIZE);
    at_print(AT_DEBUG,"retCode = %d\r\n",retCode );
    if(CPNV_ERROR == retCode )
    {
        *res_msg = at_err_build(ATERR_PROC_FAILED);
        *res_msglen = strlen(*res_msg);     
        return AT_END;  
    }
    
    for (abImeiindex=0; abImeiindex<DC_ImeiLen-1; abImeiindex++,imeistrindex+=2)
    {
        imeistr[imeistrindex] = Int2Char(TmpImei[abImeiindex]&0x0F);
        imeistr[imeistrindex+1] = Int2Char((TmpImei[abImeiindex]&0xF0)>>4);
    }
    
    imeistr[2*DC_ImeiLen-2]=Int2Char(TmpImei[DC_ImeiLen-1]&0x0F);
    imeistr[2*DC_ImeiLen-1] = '\0';

    //*res_msg = at_query_result_build(NULL,imeistr);
    at_str = malloc(32);
	if(at_str)
	{
	    sprintf(at_str,"\r\n%s\r\nOK\r\n",imeistr);
	    *res_msg = at_str;
	    *res_msglen = strlen(*res_msg);
	}
    return AT_END;
}


/**************************************************************************
* º¯ÊýÃû³Æ: imeiWrite_act_func
* ¹¦ÄÜÃèÊö: дimeiºÅ
* ²ÎÊý˵Ã÷: (IN)
*                         (OUT)
* ·µ »Ø Öµ: ÎÞ
* ÆäËü˵Ã÷:
**************************************************************************/
int imeiWrite_act_func(int at_fd,char * at_paras,void * *res_msg,int * res_msglen)
{
    //long retCode = -1;
    char *at_str = NULL; 
    char Imeistr[2*DC_ImeiLen]= {0};

    
    at_str = at_paras;  
    
    at_print(AT_DEBUG,"imeiWrite_act_func = %s.\n", at_str);

    //if ((strstr((const char *)at_str,"\r")-(char *)at_str)!= (2*DC_ImeiLen-1) || !IsImeiStrValid(at_str))
    if (strlen(at_paras) != (2*DC_ImeiLen-1) || !IsImeiStrValid(at_str))
    {
        *res_msg = at_err_build(ATERR_PARAM_INVALID);
        *res_msglen = strlen(*res_msg);     
    }
    else
    {
        if (-1 ==DC_Writeimei((char *)at_str))
        {
            *res_msg = at_err_build(ATERR_PROC_FAILED);
            *res_msglen = strlen(*res_msg);     
            return AT_END;  
        }
        
        memcpy(Imeistr,at_str,2*DC_ImeiLen-1);
        Imeistr[2*DC_ImeiLen-1] = '\0';
        *res_msg = at_query_result_build("MODIMEI",Imeistr);
        *res_msglen = strlen(*res_msg);
    }

    return AT_END;  
}

/**************************************************************************
* º¯ÊýÃû³Æ: ssidRead_act_func
* ¹¦ÄÜÃèÊö: »ñÈ¡SSIDºÅ
* ²ÎÊý˵Ã÷: (IN)
*                         (OUT)
* ·µ »Ø Öµ: ÎÞ
* ÆäËü˵Ã÷:
**************************************************************************/
int ssidRead_act_func(int at_fd,char * at_paras,void * *res_msg,int * res_msglen)
{
    unsigned int retCode = CPNV_ERROR;
    char TmpSSID[ZPS_REF_MSINFO_MAX_SSID_LEN+1]={0};
    
    retCode = cpnv_NvItemRead(ZPS_REF_MSINFO_SSID_BASE_ADDR, (unsigned char*)TmpSSID, ZPS_REF_MSINFO_MAX_SSID_LEN);
	TmpSSID[ZPS_REF_MSINFO_MAX_SSID_LEN] = '\0';
	if(CPNV_ERROR == retCode)
    {
         at_print(AT_ERR,"cpnv_NvItemRead ssid fail !\n");
        *res_msg = at_err_build(ATERR_PROC_FAILED);
        *res_msglen = strlen(*res_msg);     
         return AT_END; 
    }
    //strcpy(TmpSSID, (const char*)cfg_get("zssid"));

    *res_msg = at_query_result_build("SSID",TmpSSID);
    *res_msglen = strlen(*res_msg);
    return AT_END;
}

/**************************************************************************
* º¯ÊýÃû³Æ: ssidWrite_act_func
* ¹¦ÄÜÃèÊö: дSSIDºÅ
* ²ÎÊý˵Ã÷: (IN)
*                         (OUT)
* ·µ »Ø Öµ: ÎÞ
* ÆäËü˵Ã÷: µ±SSIDºÅ¸Ä±äʱatserverÖ÷¶¯Éϱ¨¸øctrm£¬ctrm½«SSIDºÅдÈëNVÖÐ
**************************************************************************/
int ssidWrite_act_func(int at_fd,char * at_paras,void * *res_msg,int * res_msglen)
{
    unsigned int retCode = CPNV_ERROR;
    char *at_str = NULL; 

    at_print(AT_ERR,"at_paras=%s\n",at_paras);
    
    at_str = at_paras;  

    retCode = cpnv_NvItemWrite(ZPS_REF_MSINFO_SSID_BASE_ADDR, (unsigned char*)at_str, strlen(at_str));
    at_print(AT_ERR,"at_str=%s\n",at_str);
    at_print(AT_ERR,"retCode=%d\n",retCode);

    if(CPNV_ERROR == retCode)
    {
        at_print(AT_ERR,"cpnv_NvItemWrite ssid fail !\n");
        *res_msg = at_err_build(ATERR_PROC_FAILED);
        *res_msglen = strlen(*res_msg);     
        return AT_END;  
    }
    else
    {
        at_print(AT_ERR,"cpnv_NvItemWrite ssid success !\n");
    }

    cfg_set("zssid",at_str);    

    retCode = cpnv_NvramFlush();
    
    if (retCode == CPNV_OK)
    {
        *res_msg = at_query_result_build("SSID",at_str);
    }
    else
    {   
        at_print(AT_ERR,"cpnv_NvramFlush ssid fail !\n");
        *res_msg = at_err_build(ATERR_PROC_FAILED);
    }
    *res_msglen = strlen(*res_msg);

    return AT_END;

}


/**************************************************************************
* º¯ÊýÃû³Æ: versionTypeSet_act_func
* ¹¦ÄÜÃèÊö: ÉèÖð汾ÀàÐÍ£¬AMT°æ±¾/´ó°æ±¾
* ²ÎÊý˵Ã÷: (IN)
*                         (OUT)
* ·µ »Ø Öµ: ÎÞ
* ÆäËü˵Ã÷: AT+ZVERSIONTYPE=0Ϊ´ó°æ±¾£¬AT+ZVERSIONTYPE=1ΪAMT°æ±¾
**************************************************************************/
int versionTypeSet_act_func(int at_fd, char * at_paras,void **res_msg, int * res_msglen)
{
    long    retCode =  -1;
    char   *at_str  = NULL; 
    int     ntype   = -1;   
    
    at_print(AT_ERR,"at_paras=%s\n", at_paras);
    at_str = at_paras;  

    unsigned char bootmode[] = {0x54, 0x4D};
	unsigned char atmode[] = {0x41, 0x54};
    get_at_cmd_param_int(at_str, &ntype, (const char **)&at_str);
    
    if(!is_at_cmd_end(at_str))
    {
        *res_msg = at_err_build(ATERR_PARAM_INVALID); 
        *res_msglen = strlen(*res_msg);
        return AT_END;
    }   

    if(ntype == 1)
    {
        retCode = amt_set_bootmode(bootmode);
    }
    else if(ntype == 0)
    {
        memset(bootmode, 0xFF, 2);
        retCode = amt_set_bootmode(bootmode);
    }
	else if(ntype == 2)
	{
		retCode = amt_set_amt_atmode(bootmode,atmode);
    }
    else
    {
        *res_msg = at_err_build(ATERR_PARAM_INVALID); 
        *res_msglen = strlen(*res_msg);
        return AT_END;
    }
    if (retCode == 0)
    {
        if (ntype == 0)
        {
            *res_msg = at_query_result_build("versionType","0");
        }
        else if(ntype == 1)
        {
            *res_msg = at_query_result_build("versionType","1");
        }
		else if(ntype == 2)
        {
            *res_msg = at_query_result_build("versionType","2");
        }
    }
    else
    {
        *res_msg = at_err_build(ATERR_PROC_FAILED); 
    }  
    
    *res_msglen = strlen(*res_msg);
    
    return AT_END;
}

/**************************************************************************
* º¯ÊýÃû³Æ: macRead_act_func
* ¹¦ÄÜÃèÊö: ¶ÁMACµØÖ·
* ²ÎÊý˵Ã÷: (IN)
*                         (OUT)
* ·µ »Ø Öµ: ÎÞ
* ÆäËü˵Ã÷: NVÖÐMACµØַΪBCDÂ룬ÐèҪת³ÉASCIIÂë
**************************************************************************/
int macRead_act_func(int at_fd,char * at_paras,void * *res_msg,int * res_msglen)
{
    unsigned int retCode = CPNV_ERROR;
    char TmpMacAddr[Comm_DEV_MSINFO_MAX_WIFIMAC_Area_Len] = {0};//imei³¤¶È×î´óÖµ
    char str[13];
    unsigned long abMacindex = 0;
    static char macstr[2 * AT_CMD_MAX - 1] = {0};

    retCode = cpnv_NvItemRead(OS_FLASH_AMT_COMM_RO_WIFIMAC_ADDRESS, (unsigned char *)TmpMacAddr, OS_FLASH_AMT_COMM_RO_WIFIMAC_SIZE);
    at_print(AT_DEBUG,"retCode = %d\r\n",retCode );
    if(CPNV_ERROR == retCode )
    {
        *res_msg = at_err_build(ATERR_PROC_FAILED);
        *res_msglen = strlen(*res_msg);     
        return AT_END;  
    }
    
    /* MACµØַת»»BCDÂëת»»ÎªAscii  */
    memset(str, 0, 13);

    for (abMacindex = 0; abMacindex< 12; abMacindex += 2)
    {
        str[abMacindex] = ((TmpMacAddr[abMacindex/2]) >> 4) & 0x0F;
        str[abMacindex+1] = TmpMacAddr[abMacindex/2] & 0x0F;

        macstr[abMacindex] = BCD2Ascii(str[abMacindex]);
        macstr[abMacindex+1] = BCD2Ascii(str[abMacindex+1]);
    }

    *res_msg = at_query_result_build("MAC",macstr);
    *res_msglen = strlen(*res_msg);

    return AT_END;

}

/**************************************************************************
* º¯ÊýÃû³Æ: macWrite_act_func
* ¹¦ÄÜÃèÊö: дMACµØÖ·
* ²ÎÊý˵Ã÷: (IN)
*                         (OUT)
* ·µ »Ø Öµ: ÎÞ
* ÆäËü˵Ã÷:
**************************************************************************/
int macWrite_act_func(int at_fd,char * at_paras,void * *res_msg,int * res_msglen)
{
    //long retCode = CPNV_ERROR;
    char *at_str = NULL; 

    //zOss_ASSERT(at_paras!=NULL);
    at_str = at_paras;  

    if (strlen(at_str) != DC_MacLen)
    {
        *res_msg = at_err_build(ATERR_PARAM_INVALID);
    }
    else
    {
        if (-1 == DC_WriteMacAddr((char *)at_str))
        {                
            *res_msg = at_err_build(ATERR_PROC_FAILED);
        }
        else
        {
            //*res_msg = at_query_result_build("MAC",at_str);
            *res_msg = at_ok_build();
        }
    }   
    
    *res_msglen = strlen(*res_msg);

    return AT_END;
}

/**************************************************************************
* º¯ÊýÃû³Æ: wifikeyRead_act_func
* ¹¦ÄÜÃèÊö: »ñÈ¡WifiKeyµÄÖµ
* ²ÎÊý˵Ã÷: (IN)
*                         (OUT)
* ·µ »Ø Öµ: ÎÞ
* ÆäËü˵Ã÷:
**************************************************************************/
int wifikeyRead_act_func(int at_fd,char * at_paras,void * *res_msg,int * res_msglen)
{
    unsigned int retCode = CPNV_ERROR;
    char TmpWifiKey[ZPS_REF_MSINFO_MAX_NEWWIFIKEY_LEN+1]={0};
    
    retCode = cpnv_NvItemRead(ZPS_REF_MSINFO_NEWWIFIKEY_BASE_ADDR, (unsigned char *)TmpWifiKey, ZPS_REF_MSINFO_MAX_NEWWIFIKEY_LEN);
	TmpWifiKey[ZPS_REF_MSINFO_MAX_NEWWIFIKEY_LEN] = '\0';
	//zOss_ASSERT(retCode!=ZOSS_ERROR); 
    if(CPNV_ERROR == retCode)
    {
         at_print(AT_ERR,"cpnv_NvItemRead wifikey fail !\n");
        *res_msg = at_err_build(ATERR_PROC_FAILED);
        *res_msglen = strlen(*res_msg);     
         return AT_END; 
    }
    //strcpy(TmpWifiKey, (const char*)cfg_get("zwifikey"));

    *res_msg = at_query_result_build("WIFIKEY",TmpWifiKey);
    *res_msglen = strlen(*res_msg);

    return AT_END;
}

/**************************************************************************
* º¯ÊýÃû³Æ: wifikeyWrite_act_func
* ¹¦ÄÜÃèÊö: дWIFI KEYµÄÖµ
* ²ÎÊý˵Ã÷: (IN)
*                         (OUT)
* ·µ »Ø Öµ: ÎÞ
* ÆäËü˵Ã÷:
**************************************************************************/
int wifikeyWrite_act_func(int at_fd,char * at_paras,void * *res_msg,int * res_msglen)
{
    char *at_str = NULL;
    //char *pStrValue = NULL;
    unsigned long retCode = CPNV_ERROR;

    //zOss_ASSERT(at_paras!=NULL);
    at_str = at_paras;  
    if(strlen(at_str)> ZPS_REF_MSINFO_MAX_NEWWIFIKEY_LEN)
    {       
        *res_msg = at_err_build(ATERR_PARAM_INVALID);       
        *res_msglen = strlen(*res_msg);     
        return AT_END;
    }

    retCode = cpnv_NvItemWrite(ZPS_REF_MSINFO_NEWWIFIKEY_BASE_ADDR, (unsigned char *)at_str, strlen(at_str));
    //cfg_set("zwifikey",at_str);
    
    if (retCode == CPNV_OK)
    {
        retCode = cpnv_NvramFlush();

        if (retCode == CPNV_OK)
        {
            *res_msg = at_query_result_build("WIFIKEY",at_str);
        }
        else
        {
            *res_msg = at_err_build(ATERR_PROC_FAILED);
        }
       
    }
    else
    {
        *res_msg = at_err_build(ATERR_PROC_FAILED);
    }

    *res_msglen = strlen(*res_msg);
    return AT_END;
}

/**************************************************************************
* º¯ÊýÃû³Æ: rj45MacAddrRead_act_func
* ¹¦ÄÜÃèÊö: ¶ÁMACµØÖ·
* ²ÎÊý˵Ã÷: (IN)
*                         (OUT)
* ·µ »Ø Öµ: ÎÞ
* ÆäËü˵Ã÷: NVÖÐMACµØַΪBCDÂ룬ÐèҪת³ÉASCIIÂë
**************************************************************************/
int rj45MacAddrRead_act_func(int at_fd,char * at_paras,void * *res_msg,int * res_msglen)
{
    unsigned long   retCode = CPNV_ERROR;
    char            TmpMacAddr[OS_FLASH_AMT_COMM_RO_ETHMAC_SIZE] = {0};
    char            str[13];
    long            abMacindex = 0;
    static char     macstr[2 * OS_FLASH_AMT_COMM_RO_ETHMAC_SIZE - 1] = {0};
    
    retCode = cpnv_NvItemRead(OS_FLASH_AMT_COMM_RO_ETHMAC_ADDRESS, (unsigned char *)TmpMacAddr, OS_FLASH_AMT_COMM_RO_ETHMAC_SIZE);
    at_print(AT_DEBUG,"retCode = %d\r\n",retCode );
    if(CPNV_ERROR == retCode )
    {
        *res_msg = at_err_build(ATERR_PROC_FAILED);
        *res_msglen = strlen(*res_msg); 
        return AT_END;  
    }

    /* MACµØַת»»BCDÂëת»»ÎªAscii  */
    memset(str, 0, 13);

    for (abMacindex = 0; abMacindex< 12; abMacindex += 2)
    {
        str[abMacindex] = ((TmpMacAddr[abMacindex/2]) >> 4) & 0x0F;
        str[abMacindex+1] = TmpMacAddr[abMacindex/2] & 0x0F;

        macstr[abMacindex] = BCD2Ascii(str[abMacindex]);
        macstr[abMacindex+1] = BCD2Ascii(str[abMacindex+1]);
    }

    /* MACµØַת»»½áÊø*/
    *res_msg = at_query_result_build("ETHMAC",macstr);
    *res_msglen = strlen(*res_msg);

    return AT_END;
}

/**************************************************************************
* º¯ÊýÃû³Æ: rj45MacAddWrite_act_func
* ¹¦ÄÜÃèÊö: дMACµØÖ·
* ²ÎÊý˵Ã÷: (IN)
*                         (OUT)
* ·µ »Ø Öµ: ÎÞ
* ÆäËü˵Ã÷: NVÖÐMACµØַΪBCDÂ룬ÐèҪת³ÉASCIIÂë
**************************************************************************/
int rj45MacAddWrite_act_func(int at_fd,char * at_paras,void * *res_msg,int * res_msglen)
{
    //long retCode = CPNV_ERROR;
    char *at_str = NULL; 

    //zOss_ASSERT(at_paras!=NULL);
    at_str = at_paras;  

    if (strlen(at_str)!= DC_MacLen)
    {
        *res_msg = at_err_build(ATERR_PARAM_INVALID);
    }
    else
    {
        if (-1 == DC_WriteRJ45MacAddr((char *)at_str))
        {                
            *res_msg = at_err_build(ATERR_PROC_FAILED);
        }
        else
        {
            *res_msg = at_query_result_build("ETHMAC",at_str);
        }
    }   
    
    *res_msglen = strlen(*res_msg);

    return AT_END;
}

/**************************************************************************
* º¯ÊýÃû³Æ: mac2Read_act_func
* ¹¦ÄÜÃèÊö: ¶ÁMACµØÖ·
* ²ÎÊý˵Ã÷: (IN)
*                         (OUT)
* ·µ »Ø Öµ: ÎÞ
* ÆäËü˵Ã÷: NVÖÐMACµØַΪBCDÂ룬ÐèҪת³ÉASCIIÂë
**************************************************************************/
int mac2Read_act_func(int at_fd,char * at_paras,void * *res_msg,int * res_msglen)
{
    unsigned long   retCode = CPNV_ERROR;
    char            TmpMacAddr[OS_FLASH_AMT_COMM_RO_WIFIMAC2_SIZE] = {0};//imei³¤¶È×î´óÖµ
    char            str[13];
    long            abMacindex = 0;
    static char     macstr[2 * OS_FLASH_AMT_COMM_RO_WIFIMAC2_SIZE - 1] = {0};

    retCode = cpnv_NvItemRead(OS_FLASH_AMT_COMM_RO_WIFIMAC2_ADDRESS, (UINT8 *)TmpMacAddr, OS_FLASH_AMT_COMM_RO_WIFIMAC2_SIZE);
    
    if (CPNV_ERROR == retCode )
    {
        *res_msg = at_err_build(ATERR_PROC_FAILED);
        *res_msglen = strlen(*res_msg);     
        return AT_END;
    }

    /* MACµØַת»»BCDÂëת»»ÎªAscii  */
    memset(str, 0, 13);

    for (abMacindex = 0; abMacindex< 12; abMacindex += 2)
    {
        str[abMacindex] = ((TmpMacAddr[abMacindex/2]) >> 4) & 0x0F;
        str[abMacindex+1] = TmpMacAddr[abMacindex/2] & 0x0F;

        macstr[abMacindex] = BCD2Ascii(str[abMacindex]);
        macstr[abMacindex+1] = BCD2Ascii(str[abMacindex+1]);
    }

    /* MACµØַת»»½áÊø*/
    *res_msg = at_query_result_build("MAC2",macstr);
    *res_msglen = strlen(*res_msg);
    return AT_END;
}

/**************************************************************************
* º¯ÊýÃû³Æ: mac2Write_act_func
* ¹¦ÄÜÃèÊö: дMACµØÖ·
* ²ÎÊý˵Ã÷: (IN)
*                         (OUT)
* ·µ »Ø Öµ: ÎÞ
* ÆäËü˵Ã÷:
**************************************************************************/
int mac2Write_act_func(int at_fd,char * at_paras,void * *res_msg,int * res_msglen)
{
    //long     retCode = CPNV_ERROR;
    char     *at_str = NULL; 

    //zOss_ASSERT(at_paras!=NULL);
    at_str = at_paras;  

    if (strlen(at_str)!= DC_MacLen)
    {
        *res_msg = at_err_build(ATERR_PARAM_INVALID);
    }
    else
    {
        if (-1 == DC_WriteMac2Addr((char *)at_str))
        {                
            *res_msg = at_err_build(ATERR_PROC_FAILED);
        }
        else
        {
            *res_msg = at_query_result_build("MAC2",at_str);
        }
    }   
    
    *res_msglen = strlen(*res_msg);

    return AT_END;
}

/**************************************************************************
* º¯ÊýÃû³Æ: usbmacRead_act_func
* ¹¦ÄÜÃèÊö: ¶ÁUSB MACµØÖ·
* ²ÎÊý˵Ã÷: (IN)
*                         (OUT)
* ·µ »Ø Öµ: ÎÞ
* ÆäËü˵Ã÷: NVÖÐMACµØַΪBCDÂ룬ÐèҪת³ÉASCIIÂë
**************************************************************************/
int usbmacRead_act_func(int at_fd,char * at_paras,void * *res_msg,int * res_msglen)
{
    unsigned long   retCode = CPNV_ERROR;
    char            TmpMacAddr[OS_FLASH_AMT_COMM_RO_USBMAC_SIZE] = {0};//imei³¤¶È×î´óÖµ
    char            str[13];
    long            abMacindex = 0;
    static char     macstr[2 * OS_FLASH_AMT_COMM_RO_USBMAC_SIZE - 1] = {0};

    retCode = cpnv_NvItemRead(OS_FLASH_AMT_COMM_RO_USBMAC_ADDRESS, (UINT8 *)TmpMacAddr, OS_FLASH_AMT_COMM_RO_USBMAC_SIZE);
    
    if (CPNV_ERROR == retCode )
    {
        *res_msg = at_err_build(ATERR_PROC_FAILED);
        *res_msglen = strlen(*res_msg);     
        return AT_END;
    }

    /* MACµØַת»»BCDÂëת»»ÎªAscii  */
    memset(str, 0, 13);

    for (abMacindex = 0; abMacindex< 12; abMacindex += 2)
    {
        str[abMacindex] = ((TmpMacAddr[abMacindex/2]) >> 4) & 0x0F;
        str[abMacindex+1] = TmpMacAddr[abMacindex/2] & 0x0F;

        macstr[abMacindex] = BCD2Ascii(str[abMacindex]);
        macstr[abMacindex+1] = BCD2Ascii(str[abMacindex+1]);
    }

    /* MACµØַת»»½áÊø*/
    *res_msg = at_query_result_build("USBMAC",macstr);
    *res_msglen = strlen(*res_msg);
    return AT_END;
}

/**************************************************************************
* º¯ÊýÃû³Æ: usbmacWrite_act_func
* ¹¦ÄÜÃèÊö: дUSB MACµØÖ·
* ²ÎÊý˵Ã÷: (IN)
*                         (OUT)
* ·µ »Ø Öµ: ÎÞ
* ÆäËü˵Ã÷:
**************************************************************************/
int usbmacWrite_act_func(int at_fd,char * at_paras,void * *res_msg,int * res_msglen)
{
    //long retCode = CPNV_ERROR;
    char *at_str = NULL; 

    //zOss_ASSERT(at_paras!=NULL);
    at_str = at_paras;  

    if (strlen(at_str)!= DC_MacLen)
    {
        *res_msg = at_err_build(ATERR_PARAM_INVALID);
    }
    else
    {
        if (-1 == DC_WriteUSBMacAddr((char *)at_str))
        {                
            *res_msg = at_err_build(ATERR_PROC_FAILED);
        }
        else
        {
            *res_msg = at_query_result_build("USBMAC",at_str);
        }
    }   
    
    *res_msglen = strlen(*res_msg);

    return AT_END;

}

/**************************************************************************
* º¯ÊýÃû³Æ: gmacRead_act_func
* ¹¦ÄÜÃèÊö: ¶ÁGMACµØÖ·
* ²ÎÊý˵Ã÷: (IN)
*                         (OUT)
* ·µ »Ø Öµ: ÎÞ
* ÆäËü˵Ã÷: NVÖÐMACµØַΪBCDÂ룬ÐèҪת³ÉASCIIÂë
**************************************************************************/

int gmacRead_act_func(int at_fd,char * at_paras,void * *res_msg,int * res_msglen)
{
    unsigned long   retCode = CPNV_ERROR;
    char            TmpMacAddr[OS_FLASH_AMT_COMM_RO_GMAC_SIZE] = {0};//imei³¤¶È×î´óÖµ
    char            str[13];
    long            abMacindex = 0;
    static char     macstr[2 * OS_FLASH_AMT_COMM_RO_GMAC_SIZE - 1] = {0};

    retCode = cpnv_NvItemRead(OS_FLASH_AMT_COMM_RO_GMAC_ADDRESS, (UINT8 *)TmpMacAddr, OS_FLASH_AMT_COMM_RO_GMAC_SIZE);
    
    if (CPNV_ERROR == retCode )
    {
        *res_msg = at_err_build(ATERR_PROC_FAILED);
        *res_msglen = strlen(*res_msg);     
        return AT_END;
    }

    /* MACµØַת»»BCDÂëת»»ÎªAscii  */
    memset(str, 0, 13);

    for (abMacindex = 0; abMacindex< 12; abMacindex += 2)
    {
        str[abMacindex] = ((TmpMacAddr[abMacindex/2]) >> 4) & 0x0F;
        str[abMacindex+1] = TmpMacAddr[abMacindex/2] & 0x0F;

        macstr[abMacindex] = BCD2Ascii(str[abMacindex]);
        macstr[abMacindex+1] = BCD2Ascii(str[abMacindex+1]);
    }

    /* MACµØַת»»½áÊø*/
    *res_msg = at_query_result_build("GMAC",macstr);
    *res_msglen = strlen(*res_msg);
    return AT_END;
}

/**************************************************************************
* º¯ÊýÃû³Æ: gmacWrite_act_func
* ¹¦ÄÜÃèÊö: дGMACµØÖ·
* ²ÎÊý˵Ã÷: (IN)
*                         (OUT)
* ·µ »Ø Öµ: ÎÞ
* ÆäËü˵Ã÷:
**************************************************************************/
int gmacWrite_act_func(int at_fd,char * at_paras,void * *res_msg,int * res_msglen)
{
    //long retCode = CPNV_ERROR;
    char *at_str = NULL; 

    //zOss_ASSERT(at_paras!=NULL);
    at_str = at_paras;  

    if (strlen(at_str)!= DC_MacLen)
    {
        *res_msg = at_err_build(ATERR_PARAM_INVALID);
    }
    else
    {
        if (-1 == DC_WriteGmacAddr((char *)at_str))
        {                
            *res_msg = at_err_build(ATERR_PROC_FAILED);
        }
        else
        {
            *res_msg = at_query_result_build("GMAC",at_str);
        }
    }   
    
    *res_msglen = strlen(*res_msg);

    return AT_END;
   
}

/**************************************************************************
* º¯ÊýÃû³Æ: batdetRead_act_func
* ¹¦ÄÜÃèÊö: »ñÈ¡BATDETµÄÖµ
* ²ÎÊý˵Ã÷: (IN)
*                         (OUT)
* ·µ »Ø Öµ: ÎÞ
* ÆäËü˵Ã÷:
**************************************************************************/
int batdetRead_act_func(int at_fd,char * at_paras,void * *res_msg,int * res_msglen)
{
    unsigned int retCode        = CPNV_ERROR;
    char TmpBatdet[32]  = {0};
    int  nv_value       =  0;
        
    retCode = cpnv_NvItemRead(DRV_PERI_NV_ADDR, (unsigned char *)&nv_value, 1);
    
    at_print(AT_DEBUG, "batdetRead_act_func:nv_value = %d\n", nv_value);
    
    snprintf((char *)TmpBatdet, 32, "%d", nv_value);
	if(retCode != CPNV_ERROR)
	{
    	*res_msg = at_query_result_build("BATDET", TmpBatdet);
    	*res_msglen = strlen(*res_msg);
	}
	else
	{
		*res_msg = at_err_build(ATERR_PROC_FAILED);
        *res_msglen = strlen(*res_msg);
	}
    return AT_END;
}

/**************************************************************************
* º¯ÊýÃû³Æ: batdetWrite_act_func
* ¹¦ÄÜÃèÊö: дBATDETµÄÖµ
* ²ÎÊý˵Ã÷: (IN)
*                         (OUT)
* ·µ »Ø Öµ: ÎÞ
* ÆäËü˵Ã÷:
**************************************************************************/
int batdetWrite_act_func(int at_fd,char * at_paras,void **res_msg,int * res_msglen)
{
	char          *at_str         = NULL;
    //char          *pStrValue      = NULL;
    //char           TmpBatdet[32]  = {0};
    unsigned long  retCode        = CPNV_ERROR;
    int            nv_value       = -1;
        
    at_str = at_paras;  
    at_print(AT_DEBUG, "batdetWrite_act_func:at_str = %s\n", at_str);
             
    get_at_cmd_param_int(at_str, &nv_value, (const char **)&at_str);
         
    at_print(AT_DEBUG,"batdetWrite_act_func:at_str = %s\n", at_str);
    at_print(AT_DEBUG,"batdetWrite_act_func:nv_value = %d\n", nv_value);
         
    if(!(0 == nv_value || 1 == nv_value)) // szLanEnableÖ»ÓÐ0ºÍ1Á½¸öÖµ
    {
    	*res_msg = at_err_build(ATERR_PARAM_INVALID);
        *res_msglen = strlen(*res_msg);
        return AT_END;
    }
    
    retCode =amt_set_batdet_flag(nv_value);   
    
    if (retCode == CPNV_OK)
    {
    	if(nv_value == 1)
        {
        	*res_msg = at_query_result_build("BATDET","1");
        }
        else
        {
            *res_msg = at_query_result_build("BATDET","0");
        }
	}
    else
    {
    	*res_msg = at_err_build(ATERR_PROC_FAILED);
    }
                
    *res_msglen = strlen(*res_msg);
    return AT_END;
}

int msnRead_act_func(int at_fd,char * at_paras,void * *res_msg,int * res_msglen)
{
    unsigned int retCode = CPNV_ERROR;
    char TmpMSN[MSN_MAX_NVINFO_LEN+1]= {0};
     
    retCode = cpnv_NvItemRead(OS_FLASH_AMT_COMM_RO_MSerialNum_ADDRESS, (UINT8 *)TmpMSN, MSN_MAX_NVINFO_LEN);
	TmpMSN[MSN_MAX_NVINFO_LEN] = '\0';
    if(retCode != CPNV_ERROR)
    {
        *res_msg = at_query_result_build("MSN",TmpMSN);
        *res_msglen = strlen(*res_msg);
    }
    else
    {   
        *res_msg = at_err_build(ATERR_PROC_FAILED);
        *res_msglen = strlen(*res_msg);
    }
    return AT_END;
}

int msnWrite_act_func(int at_fd,char * at_paras,void * *res_msg,int * res_msglen)
{
    unsigned int retCode = CPNV_ERROR;
    char *at_str = NULL; 

    if(NULL !=at_paras)
    {
        at_str = at_paras; 
        at_print(AT_DEBUG,"msnWrite_act_func = %s.\n", at_str);
        if((strlen(at_str) >= 12) && (strlen(at_str) <= 20))
        {
            retCode = amt_nvro_write(OS_FLASH_AMT_COMM_RO_MSerialNum_ADDRESS, MSN_MAX_NVINFO_LEN, (unsigned char *)at_str);
            if(retCode != CPNV_ERROR)
            {
                *res_msg = at_ok_build();
                *res_msglen = strlen(*res_msg);
                return AT_END;
            }
        }
    }
    *res_msg = at_err_build(ATERR_PROC_FAILED);
    *res_msglen = strlen(*res_msg);
    return AT_END;
    
}

int testInfoRead_act_func(int at_fd,char * at_paras,void * *res_msg,int * res_msglen)
{
    unsigned int retCode = CPNV_ERROR;
    char TmpTestInfo[MSINFO_MAX_NVINFO_LEN+1] = {0};
     
    retCode = cpnv_NvItemRead(OS_FLASH_AMT_COMM_RO_TestInfo_ADDRESS, (UINT8 *)TmpTestInfo, MSINFO_MAX_NVINFO_LEN);
	TmpTestInfo[MSINFO_MAX_NVINFO_LEN] = '\0';
    if(retCode != CPNV_ERROR)
    {
        *res_msg = at_query_result_build("RTESTINFO",TmpTestInfo);
        *res_msglen = strlen(*res_msg);
    }
    else
    {   
        *res_msg = at_err_build(ATERR_PROC_FAILED);
        *res_msglen = strlen(*res_msg);
    }
    return AT_END;
}

int closeAutoInd_act_func(int at_fd,char * at_paras,void * *res_msg,int * res_msglen)
{
    if('1' == at_paras[0])
    {
        at_context_chn_info_mod("none");
        *res_msg = at_ok_build();
        *res_msglen = strlen(*res_msg);
    }
    else
    {   
        *res_msg = at_err_build(ATERR_PROC_FAILED);
        *res_msglen = strlen(*res_msg);
    }
    return AT_END;
}



int zphone_mode_query_req_act(int at_fd, char *at_paras,void ** res_msg, int *res_msglen)
{
    UINT32  retCode = CPNV_ERROR;
    UINT8   TmpPhoneMode = 0;
    char *pPtr = NULL;

    pPtr = malloc(256);
    if(pPtr == NULL)
	{
		softap_assert("");
		return AT_END;
	}
    memset(pPtr, 0x00, 256);
    
    retCode = cpnv_NvItemRead(ZPS_REF_MSINFO_VERSIONMODE_BASE_ADDR, &TmpPhoneMode, sizeof(UINT8));
    if(retCode == CPNV_ERROR){softap_assert("");}

    if( 1 == (TmpPhoneMode & 0x1)) //×îºóһλÊÇ1  ´¿modem°æ±¾
    {
        snprintf((char *)pPtr, 64,"\r\n+PHONEMODE: %d", 0);
    }
    else if (0 == (TmpPhoneMode & 0x1)) //×îºóһλÊÇ 0 Õý³£°æ±¾
    {
        snprintf((char *)pPtr, 64,"\r\n+PHONEMODE: %d", 1);  
    }

    strcat((char *)pPtr,"\r\n\r\nOK\r\n");
    

    *res_msg = pPtr;
    *res_msglen = strlen(pPtr);
    
    return AT_END;
}

int zphone_mode_set_req_act(int at_fd, char *at_paras,void ** res_msg, int *res_msglen)
{
    UINT8 phoneModeStatus = 0;
    UINT32 retCode = CPNV_ERROR;

    retCode = cpnv_NvItemRead(ZPS_REF_MSINFO_VERSIONMODE_BASE_ADDR,&phoneModeStatus,sizeof(UINT8));
	if(retCode == CPNV_ERROR)
	{
	    softap_assert("");
	}

    //Õý³£°æ±¾
    if('1' == at_paras[0])
    {
        phoneModeStatus = (0xfe & phoneModeStatus);    // ºóһλ0±íʾÕý³£°æ±¾
        cfg_set("version_mode","0");
    }
    //´¿modem°æ±¾
    else if('0' == at_paras[0])
    {
        phoneModeStatus = (0x1 | phoneModeStatus);   // ºóһλ1±íʾÊÇ´¿modem°æ±¾
        cfg_set("version_mode","1");                 //version_mode==1 phonemode==0 Ϊ´¿modem°æ±¾
    }
    else
    {       
        *res_msg = at_err_build(ATERR_PARAM_INVALID);
        *res_msglen = strlen(*res_msg);
        return AT_END;
    }
    retCode = cpnv_NvItemWrite(ZPS_REF_MSINFO_VERSIONMODE_BASE_ADDR,&phoneModeStatus,sizeof(UINT8));
    if(retCode == CPNV_ERROR){softap_assert("");}
    retCode = cpnv_NvramFlush();
    if(retCode == CPNV_ERROR){softap_assert("");}

    *res_msg = at_ok_build();   
    *res_msglen = strlen(*res_msg);
    return AT_END;    
}

/**************************************************************************
* º¯ÊýÃû³Æ: zsoftreset_act_func
* ¹¦ÄÜÃèÊö: ÉèÖÃÈí¼þÖØÆô
* ²ÎÊý˵Ã÷: (IN)
*                         (OUT)
* ·µ »Ø Öµ: ÎÞ
* ÆäËü˵Ã÷: 
**************************************************************************/
int zsoftreset_act_func(int at_fd,char * at_paras,void * *res_msg,int * res_msglen)
{
    //char *pPtr = NULL; 
    
    //zOss_SysSoftReset(SYS_RESET_TO_NORMAL);  
    ipc_send_message(MODULE_ID_AT_CTL,MODULE_ID_MAIN_CTRL, MSG_CMD_RESTART_REQUEST, 0, NULL,0);

    *res_msg = at_query_result_build("ZSOFTRESET", "");
    *res_msglen = strlen(*res_msg);
    
    return AT_END;  
}

int ext_ramdump_func(char *at_paras, void ** res_msg)
{
    assert(0);
    return AT_END;
}

int zmodeSet_act_func_check_mode(char *at_paras, void ** res_msg, int *res_msglen)
{
    int   iUsbMode = -1;
    char* at_str = NULL;
    
    
    if(at_paras==NULL)
        softap_assert("zmodeSet_act_func:at_paras is null");
    
    at_str = at_paras;
    get_at_cmd_param_int(at_str, &iUsbMode, (const char **)&at_str);
    at_print(AT_DEBUG,"zmodeSet_act_func:iUsbMode == %d\n", iUsbMode);
    
	char strCfgGetItem[AT_CMD_MAX] = {0};
	nv_get_item(NV_RO, "usb_modetype", strCfgGetItem, sizeof(strCfgGetItem));
    at_print(AT_ERR,"current usb mode type = %s\n", strCfgGetItem); 

    //´ÓÓû§Ä£Ê½Çе½ÆäËû·ÇÓû§Ä£Ê½¶¼ÐèÒª¼øȨ
/*	if((strcmp(strCfgGetItem,"user")== 0)&&(iUsbMode != 0))
	{
	 	if(auth_device_key_result != 1 && auth_device_key_init_value() != 1)
	    {
	    	at_print(AT_ERR,"auth_device_key_result=%d,device key verify fail!\n", auth_device_key_result);
	        *res_msg = at_err_build(ATERR_NOT_ALLOWED);
            *res_msglen = strlen(*res_msg);

			iUsbMode = -1;
	    }
	}*/

	return iUsbMode;
}


int zmodeSet_act_func(int at_fd, char *at_paras,void ** res_msg, int *res_msglen)
{
    int   iUsbMode = 0;
    UINT8 bootmode[] = {0x54,0x4D};
    long  retCode = -1;

    at_print(AT_DEBUG,"ext_amt_func.c:zmodeSet_act_func\n");

	iUsbMode = zmodeSet_act_func_check_mode(at_paras, res_msg, res_msglen);
	if(iUsbMode < 0)
	{
		return AT_END;
	}

    switch(iUsbMode)
    {
        case 0: //user mode
        {   
            nv_set_item(NV_RO, "usb_modetype", "user", 1);
            bootmode[1] =0x00;
            retCode = amt_set_bootmode(bootmode);
            break;
        }
        case 1://debug mode
        {
            nv_set_item(NV_RO, "usb_modetype", "debug", 1);
            bootmode[1] =0x01;
            retCode = amt_set_bootmode(bootmode);
            break;
        }
        case 2://factory mode
        {
            nv_set_item(NV_RO, "usb_modetype", "factory", 1);
            bootmode[1] =0x02;
            retCode = amt_set_bootmode(bootmode);
            break;
        }
        case 3://amt mode
        {
            //nv_set_item(NV_RO, "usb_modetype", "amt", 1);
            retCode = amt_set_bootmode(bootmode);
            break;
        }
        default:
        {
            *res_msg = at_err_build(ATERR_PARAM_INVALID);
            *res_msglen = strlen(*res_msg);
            return AT_END;
        }
    }

    nv_commit(NV_RO);
    
    at_print(AT_DEBUG,"zmodeSet_act_func:retCode == %d\n", retCode);
    if (retCode == 0)
    {
        *res_msg = at_ok_build();   
    }
    else
    {       
        *res_msg = at_err_build(ATERR_PROC_FAILED); 
    }  
    *res_msglen = strlen(*res_msg);
    return AT_END;
}

int write_security_info(int at_fd, char *at_paras, void **res_msg, int *res_msglen)
{
    UINT32 pubKeyHash[4] = {0};
    UINT32 secureFlag = 0xFF;
    T_ZDrvEfuse_Secure efuseInfo = {{0}};
    char strValue[16];
    char strLog[256] = {0};
    md5_ctx stStc;
    int i;
	int efuse_fd = -1;
	//int ret = -1;

    /*************************»ñÈ¡¹«Ô¿hash**************************/
    // »ñÈ¡¹«Ô¿
	efuse_fd = open("/dev/efuse", O_RDWR);
	if (efuse_fd < 0) {
		at_print(AT_ERR,"open %s fail.\n","/dev/efuse");
		*res_msg = at_err_build(ATERR_PROC_FAILED);
		*res_msglen = strlen(*res_msg);
		return AT_END;
	}

	if(ioctl(efuse_fd , EFUSE_GET_DATA, &efuseInfo)!= 0)
	{
	    at_print(AT_ERR,"ioctl: EFUSE_GET_DATA fail.\n");
		*res_msg = at_err_build(ATERR_PROC_FAILED);
		*res_msglen = strlen(*res_msg);
		close(efuse_fd);
		return AT_END;
	}
	at_print(AT_NORMAL, "security flag in efuse: %08X\r", efuseInfo.secureFlag);
	
    // ¼ÆË㹫ԿhashÖµ
    md5_init(&stStc);
    md5_update(&stStc, (unsigned char *)efuseInfo.pubKeyRsaE, sizeof(efuseInfo.pubKeyRsaE));
    md5_update(&stStc, (unsigned char *)efuseInfo.pubKeyRsaN, sizeof(efuseInfo.pubKeyRsaN));
    md5_final((UINT8 *)pubKeyHash, &stStc);

    // ´òÓ¡¹«Ô¿hash
    strLog[0] = '\0';
    for (i = 0; i < sizeof(pubKeyHash)/sizeof(UINT32); i++)
    {
        pubKeyHash[i] = ((pubKeyHash[i] & 0xff000000) >> 24)
                        | ((pubKeyHash[i] & 0x00ff0000) >>	8)
                        | ((pubKeyHash[i] & 0x0000ff00) <<	8)
                        | ((pubKeyHash[i] & 0x000000ff) << 24) ;

        sprintf(strValue, "%08lX", pubKeyHash[i]);
        strcat(strLog, strValue);
    }

    at_print(AT_NORMAL, "Public key hash: %s\r", strLog);
	
	/*************************½«°²È«ÐÅϢдÈëefuse**************************/
	
	if (memcmp(efuseInfo.pubKeyHash, pubKeyHash, sizeof(pubKeyHash)) != 0)
	{
		// ¹«Ô¿hashֵдÈëefuse
		if (ioctl(efuse_fd , EFUSE_SET_PUB_KEY_HASH, pubKeyHash) != 0)
		{
	    	at_print(AT_ERR, "Write public key hash to efuse fail!\r");
			*res_msg = at_err_build(ATERR_PROC_FAILED);
			*res_msglen = strlen(*res_msg);
			close(efuse_fd);
			return AT_END;
		}
		else
		{
			at_print(AT_NORMAL, "Write public key hash to efuse success!\r");
		}
    }
	else
	{
		at_print(AT_NORMAL, "Public key's hash value already exists!\r");
	}
	/*efuseInfo.secureFlagÇ°Ãæ3¸ö×Ö½ÚÊÇchip flag,×îºóÒ»¸ö×Ö½ÚÊÇ°²È«Ê¹ÄܱêÖ¾*/
	
    if ((efuseInfo.secureFlag&0xff) != secureFlag)
    {
        // ʹÄܱêʶλдÈëefuse
        if (ioctl(efuse_fd , EFUSE_SET_SECURE_EN, &secureFlag) != 0)
        {
            at_print(AT_ERR, "Write security flag to efuse fail!\r");
            *res_msg = at_err_build(ATERR_PROC_FAILED);
            *res_msglen = strlen(*res_msg);
			close(efuse_fd);
            return AT_END;
        }
        else
        {
            at_print(AT_NORMAL, "Write security flag to efuse success!\r");
        }
    }

    else
    {
        at_print(AT_NORMAL, "Secure flag already exists!\r");
    }
	
    /*************************ÅжÏдÈëµÄÐÅÏ¢ÊÇ·ñÕýÈ·**************************/
    // ´Óefuse¶ÁÈ¡
    memset(&efuseInfo, 0, sizeof(efuseInfo));
    if(ioctl(efuse_fd , EFUSE_GET_DATA, &efuseInfo)!= 0)
    {
        at_print(AT_ERR,"ioctl: EFUSE_GET_DATA fail.\n");
		*res_msg = at_err_build(ATERR_PROC_FAILED);
		*res_msglen = strlen(*res_msg);
		close(efuse_fd);
		return AT_END;
    }

    if ((efuseInfo.secureFlag&0xff) != secureFlag)
    {
        at_print(AT_ERR, "Security flag(%#08X) is not consistent!\r", efuseInfo.secureFlag);
        *res_msg = at_err_build(ATERR_PROC_FAILED);
        *res_msglen = strlen(*res_msg);
		close(efuse_fd);
        return AT_END;
    }

    if (memcmp(efuseInfo.pubKeyHash, pubKeyHash, sizeof(pubKeyHash)) != 0)
    {
        at_print(AT_ERR, "Public key hash is not consistent!\r");
        *res_msg = at_err_build(ATERR_PROC_FAILED);
        *res_msglen = strlen(*res_msg);
		close(efuse_fd);
        return AT_END;
    }

    *res_msg = at_query_result_build("write security infomation", NULL);
    *res_msglen = strlen(*res_msg);
	close(efuse_fd);
    return AT_END;
}

int read_security_info(int at_fd, char *at_paras, void **res_msg, int *res_msglen)
{
    char strValue[16];
    char strLog[256] = {0};
    int i;
	int ret = 0;
	T_ZDrvEfuse_Secure efuseInfo = {{0}};
	int efuse_fd = -1;
	
    efuse_fd = open("/dev/efuse", O_RDWR);
	if (efuse_fd < 0) 
	{
		at_print(AT_ERR,"open %s fail.\n","/dev/efuse");
		*res_msg = at_err_build(ATERR_PROC_FAILED);
		*res_msglen = strlen(*res_msg);
		return AT_END;
	}

	at_print(AT_ERR,"open %s success.\n","/dev/efuse");

	 // ´Óefuse¶ÁÈ¡
    if(ioctl(efuse_fd , EFUSE_GET_DATA, &efuseInfo)!= 0)
    {
        at_print(AT_ERR,"ioctl: EFUSE_GET_DATA fail.\n");
		*res_msg = at_err_build(ATERR_PROC_FAILED);
		*res_msglen = strlen(*res_msg);
		close(efuse_fd);
		return AT_END;
    }
	else
	{
	    at_print(AT_ERR,"ioctl: EFUSE_GET_DATA success.\n");
		strLog[0] = '\0';
		sprintf(strValue, "%02X,", efuseInfo.secureFlag&0xFF);
		strcat(strLog, strValue);
    	for (i = 0; i < sizeof(efuseInfo.pubKeyHash)/sizeof(UINT32); i++)
    	{
    	    sprintf(strValue, "%08lX", efuseInfo.pubKeyHash[i]);
        	strcat(strLog, strValue);
    	}
		at_print(AT_ERR, "Secure Flag,Public key hash: %s\n", strLog);
		close(efuse_fd);
		*res_msg = at_query_result_build("read security information", strLog);
        *res_msglen = strlen(*res_msg);
		return AT_END;
		
	}
}

/*
int auth_device_key(int at_fd, char *at_paras,void ** res_msg, int *res_msglen)
{
	char *at_str = NULL; 
	
	at_print(AT_ERR,"at_paras=%s\n",at_paras);
		
	at_str = at_paras;	
	char seed[] = SEED;
	auth_device_key_result = verify_device_key(at_str,strlen(at_str),seed,strlen(seed));
	at_print(AT_ERR,"auth_device_key_result=%d\n",auth_device_key_result);
	
	if (auth_device_key_result == 1)
	{
		*res_msg = at_ok_build();
	}
	else
	{	
		at_print(AT_ERR,"verify device key fail !\n");
		*res_msg = at_err_build(ATERR_PROC_FAILED);
	}
	*res_msglen = strlen(*res_msg);
	
	return AT_END;
}
*/

int ext_amt_regist(void)
{
	if(!ext_is_usermode())
	{
		register_serv_func2("MODIMEI=",0,0,0,imeiWrite_act_func,NULL);
		register_serv_func2("PHONEMODE=",0,0,0,zphone_mode_set_req_act, 0);
		register_serv_func("ramdump",0,ext_ramdump_func);
		// дÈ밲ȫÐÅÏ¢
		register_serv_func2("WSCYINFO",0,0,0,write_security_info,NULL);
	}
    register_serv_func2("RKEYDC=",0,0,0,rkeydc_act_func,NULL);
    register_serv_func2("ZPOWEROFF",0,0,0,poweroff_act_func,NULL);
    register_serv_func2("PLATFORM?",0,0,0,chip_platform_read_act_func,NULL);
    register_serv_func2("READIMEI",0,0,0,imeiRead_act_func,NULL);
    register_serv_func2("READIMEI?",0,0,0,imeiRead_act_func,NULL);
    register_serv_func2("SSID?",0,0,0,ssidRead_act_func,NULL);
    register_serv_func2("SSID=",0,0,0,ssidWrite_act_func,NULL);
    register_serv_func2("ZVERSIONTYPE=",0,0,0,versionTypeSet_act_func,NULL);
    register_serv_func2("MAC?",0,0,0,macRead_act_func,NULL);
    register_serv_func2("MAC=",0,0,0,macWrite_act_func,NULL);
    register_serv_func2("WIFIKEY?",0,0,0,wifikeyRead_act_func,NULL);
    register_serv_func2("WIFIKEY=",0,0,0,wifikeyWrite_act_func,NULL);
    register_serv_func2("ETHMAC?",0,0,0,rj45MacAddrRead_act_func,NULL);
    register_serv_func2("ETHMAC=",0,0,0,rj45MacAddWrite_act_func,NULL); 
    register_serv_func2("MAC2?",0,0,0,mac2Read_act_func,NULL);
    register_serv_func2("MAC2=",0,0,0,mac2Write_act_func,NULL);
    register_serv_func2("USBMAC?",0,0,0,usbmacRead_act_func,NULL);
    register_serv_func2("USBMAC=",0,0,0,usbmacWrite_act_func,NULL); 
    register_serv_func2("GMAC?",0,0,0,gmacRead_act_func,NULL);
    register_serv_func2("GMAC=",0,0,0,gmacWrite_act_func,NULL); 
    register_serv_func2("BATDET?",0,0,0,batdetRead_act_func,NULL); 
    register_serv_func2("BATDET=",0,0,0,batdetWrite_act_func,NULL); 
    register_serv_func2("MSN?",0,0,0,msnRead_act_func,NULL);
    register_serv_func2("MSN=",0,0,0,msnWrite_act_func,NULL);
    register_serv_func2("RTESTINFO",0,0,0,testInfoRead_act_func,NULL);
    register_serv_func2("ZAMTMODE=",0,0,0,closeAutoInd_act_func,NULL);
    
    //Çл»Õý³£°æ±¾ºÍ´¿modem°æ±¾
    register_serv_func2("PHONEMODE?",0,0,0,zphone_mode_query_req_act, 0);
    
    register_serv_func2("ZSOFTRESET",0,0,0,zsoftreset_act_func,NULL);
    
    register_serv_func2("zmode=",0,0,0,zmodeSet_act_func,NULL); 
	//mdlÓû§Ä£Ê½ÇÐÑз¢Ä£Ê½¼øȨAT+ZAUTH=KEY
	//register_serv_func2("ZAUTH=",0,0,0,auth_device_key,NULL);
    register_serv_func2("RSCYINFO",0,0,0,read_security_info,NULL);
    return 0;
}