[Bugfix][R306][bug-view-2169][secure] sync AT+RSCYINFO base
Change-Id: Ife273aed0db5fdcabb3b8170aa551bf30db3d600
diff --git a/lynq/MD310EU/ap/lib/libatext/ext_amt_func.c b/lynq/MD310EU/ap/lib/libatext/ext_amt_func.c
new file mode 100755
index 0000000..3791fd7
--- /dev/null
+++ b/lynq/MD310EU/ap/lib/libatext/ext_amt_func.c
@@ -0,0 +1,2134 @@
+/**
+ *
+ * @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 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);
+ return 0;
+}