Merge #529 into sdk602patch0626 from refs/changes/529/head

合并cywee新固件，添加获取cywee激活状态接口

* refs/changes/529/head: (1 commits squashed)

  - 合并cywee新固件，添加获取cywee激活状态接口

Signed-off-by: aliyun6865282430 <1624952103@qq.com>
Reviewed-by: snickersun@163.com <accounts_62b90f7fcf51ade33b6f628e@mail.teambition.com>
Merged-by: snickersun@163.com <accounts_62b90f7fcf51ade33b6f628e@mail.teambition.com>
link: https://codeup.aliyun.com/64191456b9581d62e8f81ac0/FD230/change/529

diff --git a/code/sdk/drivers/peripheral/cywee/Inc/custom_factory.h b/code/sdk/drivers/peripheral/cywee/Inc/custom_factory.h
index fe7749c..647249a 100644 (file)
--- a/code/sdk/drivers/peripheral/cywee/Inc/custom_factory.h
+++ b/code/sdk/drivers/peripheral/cywee/Inc/custom_factory.h
@@ -26,7 +26,7 @@ typedef struct {
 
 typedef void (*FN_SENSOR_LISTEN)(pSensorEVT_t);
 
-//void CWM_LibPostInit(FN_SENSOR_LISTEN pfn);
+void CWM_LibPostInit(FN_SENSOR_LISTEN pfn);
 #endif //__CWM_LIB_H__
 
 
@@ -34,15 +34,20 @@ typedef void (*FN_SENSOR_LISTEN)(pSensorEVT_t);
 
 typedef struct {
     int sec_write_len;
-    int sec_empty_value;
-    int sec_rewritable;
+    int sec_bytes_per_write;
+    int sec_blank_value;
+    int sec_erasable;
+    int force_write_even_dirty;
     char *chip_name;
+    int (*p_func_write_ex)(unsigned int offset, unsigned char *buf, unsigned int len);
 } reburn_prepare_t;
 
 typedef struct {
     void (*log_print)(const char* str);
 } print_api_t;
 
+void reburn_setup_api(print_api_t *api);
+
 int secFactory_init(int rand_seed);
 int secFactory_make_sec(char version, char *code, int *pCode);
 int secFactory_make_chipInfo(char *strChipInfo);
@@ -60,4 +65,4 @@ int impl_sec_read(unsigned char *buf, unsigned int len);
 int impl_sec_erase(void);
 int impl_sec_write(unsigned char *buf, unsigned int len);
 
-#endif //__CM_SIMPLE_FACTORY_H__
+#endif //__CUSTOM_FACTORY_H__

diff --git a/code/sdk/drivers/peripheral/cywee/Inc/cywee_hal.h b/code/sdk/drivers/peripheral/cywee/Inc/cywee_hal.h
index 69529db..f9538fa 100644 (file)
--- a/code/sdk/drivers/peripheral/cywee/Inc/cywee_hal.h
+++ b/code/sdk/drivers/peripheral/cywee/Inc/cywee_hal.h
@@ -557,6 +557,7 @@ void cywee_set_sedentary_interval(int time);
 void cywee_set_sedentary_switch(int cmd);
 void cywee_get_acc_switch(int cmd);
 void cywee_stop(void);
+uint8_t cywee_get_active_state(void);
 
 extern uint8_t hrs_mode_state;
 

diff --git a/code/sdk/drivers/peripheral/cywee/src/custom_factory_core.c b/code/sdk/drivers/peripheral/cywee/src/custom_factory_core.c
index 480aae8..67558ba 100644 (file)
--- a/code/sdk/drivers/peripheral/cywee/src/custom_factory_core.c
+++ b/code/sdk/drivers/peripheral/cywee/src/custom_factory_core.c
@@ -42,17 +42,6 @@ void reburn_log_printf(const char* fmt, ...) {
     m_reburn_print_api.log_print((const char*)localBuf);\r
 }\r
 \r
-static int is_sec_empty(uint8_t* buf, uint32_t len) {\r
-    for (int i = 0 ; i < len ; i++) {\r
-        if (buf[i] != m_var.sec_empty_value) {\r
-            printf("is_sec_empty(): block %d not empty(0x%02x)\n", i, buf[i]);\r
-            return 0;\r
-        }\r
-    }\r
-\r
-    return 1;\r
-}\r
-\r
 static void dump_sec(uint8_t* buf, uint32_t len) {\r
     uint32_t offset = 0, remainBytes = len;\r
 \r
@@ -60,7 +49,7 @@ static void dump_sec(uint8_t* buf, uint32_t len) {
         return;\r
 \r
     while (remainBytes >= 16) {\r
-        printf("%08x  | %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x\n", offset,\r
+        reburn_log_printf("%08x  | %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x\n", offset,\r
             *(buf + (offset) + 0 ), *(buf + (offset) + 1 ), *(buf + (offset) + 2 ), *(buf + (offset) + 3 ),\r
             *(buf + (offset) + 4 ), *(buf + (offset) + 5 ), *(buf + (offset) + 6 ), *(buf + (offset) + 7 ),\r
             *(buf + (offset) + 8 ), *(buf + (offset) + 9 ), *(buf + (offset) + 10), *(buf + (offset) + 11),\r
@@ -70,18 +59,123 @@ static void dump_sec(uint8_t* buf, uint32_t len) {
     }\r
 }\r
 \r
+static int is_block_blank(uint8_t* buf, uint32_t len, int show_msg) {\r
+    dump_sec(buf, len);\r
+\r
+    for (int i = 0 ; i < len ; i++) {\r
+        if (buf[i] != m_var.sec_blank_value) {\r
+            if (show_msg)\r
+                reburn_log_printf("[is_block_blank] block %d not empty(0x%02x)\n", i, buf[i]);\r
+            return 0;\r
+        }\r
+    }\r
+\r
+    return 1;\r
+}\r
+\r
+static int write_sec(unsigned int sec_is_blank, unsigned char *p_rbuf, unsigned char *p_wbuf, int len) {\r
+    int ret;\r
+    int total = m_var.sec_write_len;\r
+    int bytes_per_write = m_var.sec_bytes_per_write;\r
+    unsigned char blank_val = m_var.sec_blank_value;\r
+\r
+    if (sec_is_blank) {\r
+        reburn_log_printf("[write_sec] mode:write all\n");\r
+\r
+        if (m_var.p_func_write_ex) {\r
+            ret = m_var.p_func_write_ex(0, p_wbuf, total);\r
+            if (ret != 1) {\r
+                reburn_log_printf("[write_sec] write_ex failed(%d)\n", ret);\r
+                return -1;\r
+            }\r
+        } else {\r
+            ret = impl_sec_write(p_wbuf, total);\r
+            if ( ret != 1) {\r
+                reburn_log_printf("[write_sec] write failed(%d)\n", ret);\r
+                return -2;\r
+            }\r
+        }\r
+    } else {\r
+        reburn_log_printf("[write_sec] mode:%d byte \n", bytes_per_write);\r
+\r
+        if (m_var.p_func_write_ex && bytes_per_write > 0) {\r
+        } else {\r
+            reburn_log_printf("[write_sec] error, not support partial write\n");\r
+            return -3;\r
+        }\r
+\r
+        for (int i = 0; i < total / bytes_per_write; i ++) {\r
+            int offset, block_blank, block_the_same, do_write;\r
+\r
+            offset = (i * bytes_per_write);\r
+            block_blank = is_block_blank(p_rbuf + offset, bytes_per_write, 0);\r
+            do_write = 0;\r
+\r
+            if (memcmp(p_rbuf + offset, p_wbuf + offset, bytes_per_write) == 0)\r
+                block_the_same = 1;\r
+            else\r
+                block_the_same = 0;\r
+\r
+            if (block_the_same == 0 && block_blank == 0 && m_var.force_write_even_dirty == 0) {\r
+                reburn_log_printf("[write_sec] error, force_write_even_dirty=0\n", *(p_rbuf + offset), blank_val);\r
+                return -4;\r
+            }\r
+\r
+            if (block_the_same == 0) {\r
+               if (block_blank == 1 || m_var.force_write_even_dirty == 1)\r
+                  do_write = 1;\r
+            }\r
+\r
+            if (do_write) {\r
+                ret = m_var.p_func_write_ex(offset, p_wbuf + offset, bytes_per_write);\r
+                if (ret != 1) {\r
+                    reburn_log_printf("[write_sec] write_ex failed(%d)\n", ret);\r
+                    return -5;\r
+                }\r
+            }\r
+        }\r
+    }\r
+\r
+    return 1;\r
+}\r
+\r
+int erase_and_confirm(unsigned char *pbuf, unsigned int len) {\r
+    int ret;\r
+\r
+    ret = impl_sec_erase();\r
+    if (ret != 1) {\r
+        reburn_log_printf("[erase_and_confirm] erase error(%d)\n", ret);\r
+        return -1;\r
+    }\r
+\r
+    memset(pbuf, 0x0, len);\r
+    ret = impl_sec_read(pbuf, len);\r
+    if (ret != 1) {\r
+        reburn_log_printf("[erase_and_confirm] read error(%d)\n", ret);\r
+        return -2;\r
+    }\r
+\r
+    if (!is_block_blank(pbuf, len, 1)) {\r
+        reburn_log_printf("[erase_and_confirm] block is not cleaned\n");\r
+        return -3;\r
+    }\r
+\r
+    return 1;\r
+}\r
+\r
 int reburn_second_dev(void) {\r
     SettingControl_t scl;\r
     char str_chipInfo[48];\r
-    unsigned char buf[256];\r
-    char EncodeData[512];\r
-    int len = 0, ret = 0;\r
+    unsigned char sec_from_device[512];\r
+    unsigned char sec_from_lib[512];\r
+    int len = 0, ret = 0, sec_is_blank = 0;\r
 \r
     impl_prepare(&m_var);\r
-    printf("[reburn_second_dev] Built at %s %s\n", __DATE__, __TIME__);\r
+\r
+    reburn_log_printf("[reburn_second_dev] Built at %s %s\n", __DATE__, __TIME__);\r
 \r
     if (!impl_checkMcuModel()) {\r
-        printf("cannot reburn: wrong model \r\n");\r
+        reburn_log_printf("cannot reburn: wrong model\n");\r
         return STS_ERR_WRONG_MODEL;\r
     }\r
 \r
@@ -89,24 +183,19 @@ int reburn_second_dev(void) {
     scl.iData[0] = 1;\r
     CWM_SettingControl(SCL_GET_LIB_INFO, &scl);\r
     if (scl.iData[5] < 3000) {\r
-        printf("%d Not a valid reburn library\n", scl.iData[5]);\r
+        reburn_log_printf("cannot reburn: %d not a valid reburn library\n", scl.iData[5]);\r
         return STS_ERR_INVALID_LIB;\r
     }\r
-    printf("model:%s version:%d.%d.%d.%d product:%d\n", m_var.chip_name, scl.iData[1], scl.iData[2], scl.iData[3], scl.iData[4], scl.iData[5]);\r
+    reburn_log_printf("model:%s version:%d.%d.%d.%d product:%d\n", m_var.chip_name, scl.iData[1], scl.iData[2], scl.iData[3], scl.iData[4], scl.iData[5]);\r
 \r
     impl_sec_env_init();\r
 \r
     impl_stick_env_init();\r
-    // uint8_t buffer[80] = {0};\r
-    // uapi_efuse_read_buffer(buffer, 0x100, 80);\r
-    // printf("reburn buffer : ");\r
-    // for(int i = 0 ; i < 80 ; i++)\r
-    //     printf("%d",buffer[i]);\r
-    // printf("\n");\r
+\r
     CWM_LibPostInit(NULL);\r
 \r
     if (secFactory_init(0) != 1) {\r
-        printf("secFactory_init fail\n");\r
+        reburn_log_printf("cannot reburn: secFactory_init fail\n");\r
         return STS_ERR_SEC_INIT;\r
     }\r
 \r
@@ -123,63 +212,64 @@ int reburn_second_dev(void) {
     scl.iData[5] = 0;\r
     scl.iData[6] = 0;\r
     CWM_SettingControl(SCL_GET_CHIP_INFO, &scl);\r
-    printf("have_security = %d.%d ret_buff_size = %d\n", scl.iData[5], scl.iData[6], scl.iData[4]);\r
-    printf("[getinfo]chipInfo=%s\n", str_chipInfo);\r
+    reburn_log_printf("have_security = %d.%d ret_buff_size = %d\n", scl.iData[5], scl.iData[6], scl.iData[4]);\r
+    reburn_log_printf("[getinfo]chipInfo=%s\n", str_chipInfo);\r
     if (scl.iData[5] == 1) {\r
-        printf("valid security found\n");\r
+        reburn_log_printf("valid security found\n");\r
         return STS_OK;\r
     }\r
 \r
-    memset(buf, 0x0, sizeof(buf));\r
-    ret = impl_sec_read(buf, m_var.sec_write_len);\r
-    if (ret != 1) {\r
-        printf("cannot reburn: read error(%d)\n", ret);\r
-        return STS_ERR_SEC_READ_FAIL;\r
-    }\r
-    dump_sec(buf, m_var.sec_write_len);\r
-\r
     if (impl_sec_is_locked()) {\r
-        printf("cannot reburn: locked\n");\r
+        reburn_log_printf("cannot reburn: locked\n");\r
         return STS_ERR_MEDIUM_LOCKED;\r
     }\r
 \r
-    if (!is_sec_empty(buf, m_var.sec_write_len)) {\r
-        if (!m_var.sec_rewritable) {\r
-            printf("cannot reburn: block not empty\n");\r
-            return STS_ERR_BLOCK_NOT_EMPTY;\r
-        }\r
-        ret = impl_sec_erase();\r
-        if (ret != 1) {\r
-            printf("cannot reburn: erase error(%d)\n", ret);\r
-            return STS_ERR_ERASE_FAILED;\r
+    memset(sec_from_device, 0x0, sizeof(sec_from_device));\r
+    ret = impl_sec_read(sec_from_device, m_var.sec_write_len);\r
+    if (ret != 1) {\r
+        reburn_log_printf("cannot reburn: read error(%d)\n", ret);\r
+        return STS_ERR_SEC_READ_FAIL;\r
+    }\r
+\r
+    if (is_block_blank(sec_from_device, m_var.sec_write_len, 1)) {\r
+        sec_is_blank = 1;\r
+    } else {\r
+        if (m_var.sec_erasable) {\r
+            ret = erase_and_confirm(sec_from_device, m_var.sec_write_len);\r
+            if (ret != 1) {\r
+                reburn_log_printf("cannot reburn: erase not success (%d)\n", ret);\r
+                return STS_ERR_ERASE_FAILED;\r
+            } else {\r
+                sec_is_blank = 1;\r
+            }\r
         }\r
     }\r
 \r
     if (secFactory_make_chipInfo(str_chipInfo) != 1) {\r
-        printf("secFactory_make_chipInfo fail\n");\r
+        reburn_log_printf("secFactory_make_chipInfo fail\n");\r
         return STS_ERR_SEC_MAKE_CHIPINFO;\r
     }\r
-    printf("[makesec]chipInfo=%s\n", str_chipInfo);\r
+    reburn_log_printf("[makesec]chipInfo=%s\n", str_chipInfo);\r
 \r
-    memset(EncodeData, 0, sizeof(EncodeData));\r
-    ret = secFactory_make_sec(0x01, EncodeData, &len);\r
+    memset(sec_from_lib, 0, sizeof(sec_from_lib));\r
+    ret = secFactory_make_sec(0x01, (char*)sec_from_lib, &len);\r
     if (ret != 1) {\r
-        printf("secFactory_make_sec fail\n");\r
+        reburn_log_printf("secFactory_make_sec fail\n");\r
         return STS_ERR_SEC_MAKE_SEC;\r
     }\r
 \r
     if (len < m_var.sec_write_len) {\r
-        printf("sec length error(%d/%d)\n", len, m_var.sec_write_len);\r
+        reburn_log_printf("sec length error(%d/%d)\n", len, m_var.sec_write_len);\r
         return STS_ERR_SEC_WRITE_LEN;\r
     }\r
 \r
-    ret = impl_sec_write((uint8_t*)&EncodeData[0], len);\r
+    ret = write_sec(sec_is_blank, sec_from_device, sec_from_lib, m_var.sec_write_len);\r
     if (ret != 1) {\r
-        printf("cannot reburn: write error(%d)\n", ret);\r
+        reburn_log_printf("cannot reburn: write error(%d)\n", ret);\r
         return STS_ERR_SEC_WRITE;\r
     }\r
 \r
-    printf("reburn complete\n");\r
+    reburn_log_printf("reburn complete\n");\r
 \r
     return STS_OK;\r
 }\r

diff --git a/code/sdk/drivers/peripheral/cywee/src/custom_factory_impl.c b/code/sdk/drivers/peripheral/cywee/src/custom_factory_impl.c
index 0e88bc3..d8c5d8c 100644 (file)
--- a/code/sdk/drivers/peripheral/cywee/src/custom_factory_impl.c
+++ b/code/sdk/drivers/peripheral/cywee/src/custom_factory_impl.c
@@ -14,8 +14,8 @@ extern int cm__hs1__deinit(void);
 \r
 static reburn_prepare_t m_chipCfg = {\r
     .sec_write_len   = 16,\r
-    .sec_empty_value = 0x00,\r
-    .sec_rewritable  = 0,\r
+    .sec_blank_value = 0x00,\r
+    .sec_erasable    = 0,\r
     .chip_name       = "YH601S"\r
 };\r
 \r

diff --git a/code/sdk/drivers/peripheral/cywee/src/main_dml.c b/code/sdk/drivers/peripheral/cywee/src/main_dml.c
index c0bf8f0..cbdea31 100644 (file)
--- a/code/sdk/drivers/peripheral/cywee/src/main_dml.c
+++ b/code/sdk/drivers/peripheral/cywee/src/main_dml.c
@@ -72,10 +72,16 @@ static int cywee_switch = 1;
 #else
 static int cywee_switch = 0;
 #endif
+static uint8_t cywee_is_active = 0;
 
 int cm__hs1__init(void);
 int cm__hs1__deinit(void);
 
+uint8_t cywee_get_active_state(void)
+{
+    return cywee_is_active;
+}
+
 void cywee_stop(void)
 {
     cywee_switch = 0;
@@ -990,6 +996,10 @@ int cywee_main_dml(void)
     CWM_OS_dbgPrintf("have_security = %d.%d ret_buff_size = %d  chipInfo = %s\n", scl.iData[5], scl.iData[6], scl.iData[4], chipInfo);
     CWM_OS_dbgPrintf("chip_settings = %d, %d, %d\n", scl.iData[9], scl.iData[10], scl.iData[11]);
     //CWM_OS_dbgPrintf("[DBG] %s %d\n", __func__,__LINE__);
+    if(scl.iData[5] == 1 && scl.iData[6] == 31010100)
+    {
+        cywee_is_active = 1;
+    }
 
     CWM_Dml_LibInit();
     //CWM_OS_dbgPrintf("[DBG] %s %d\n", __func__,__LINE__);

diff --git a/code/sdk/drivers/peripheral/utils/custom_utils.c b/code/sdk/drivers/peripheral/utils/custom_utils.c
index 1efe4b2..1a6769c 100644 (file)
--- a/code/sdk/drivers/peripheral/utils/custom_utils.c
+++ b/code/sdk/drivers/peripheral/utils/custom_utils.c
@@ -2347,3 +2347,8 @@ void uapi_gei_btmac_and_chipinfo(void)
 
     wstp_print("^^^^ BTMAC=%s ^^^^ CyweeChipInfo=%s\n",btaddr_str,chipinfo);
 }
+
+uint8_t uapi_get_cywee_active_state(void)
+{
+    return cywee_get_active_state();
+}

diff --git a/code/sdk/drivers/peripheral/utils/custom_utils.h b/code/sdk/drivers/peripheral/utils/custom_utils.h
index 47f82bb..86f1b74 100644 (file)
--- a/code/sdk/drivers/peripheral/utils/custom_utils.h
+++ b/code/sdk/drivers/peripheral/utils/custom_utils.h
@@ -233,6 +233,7 @@ void uapi_factorytest_hide_test_tp_button(void);
 void uapi_efuse_test_write(uint8_t *data,uint32_t byte_number,uint8_t len);
 void uapi_efuse_test_read(uint32_t byte_number,uint8_t len);
 void uapi_gei_btmac_and_chipinfo(void);
+uint8_t uapi_get_cywee_active_state(void);
 #include "custom_utilscpp.h"
 
 

diff --git a/code/sdk/drivers/peripheral/utils/custom_utils_at_cmd.c b/code/sdk/drivers/peripheral/utils/custom_utils_at_cmd.c
index ab31c60..90ba3fb 100644 (file)
--- a/code/sdk/drivers/peripheral/utils/custom_utils_at_cmd.c
+++ b/code/sdk/drivers/peripheral/utils/custom_utils_at_cmd.c
@@ -782,7 +782,19 @@ static uint32_t custom_lsfd(uint8_t *para, uint32_t paraLen, char *strCommonCmd)
     lsfd();
     return ERRCODE_SUCC;
 }
- 
+
+static uint32_t custom_get_cywee_active_state(uint8_t *para, uint32_t paraLen, char *strCommonCmd)
+{
+    UNUSED(strCommonCmd);
+
+    uint8_t ret = uapi_get_cywee_active_state();
+    if(ret == 1)
+        wstp_print("cywee is active !!!\n");
+    else
+        wstp_print("cywee is not active !!!\n");
+    return ERRCODE_SUCC;
+}
+
 static const at_cmd_table_t g_custom_utils_cmd[] = {
     { (char *)"AT^CUSTOM_SN",      custom_utils_setsn, (char *)"123456789ABCDEF2345678" },
     { (char *)"AT^CUSTOM_SN_REQ",  custom_utils_getsn, (char *)" " },
@@ -841,6 +853,7 @@ static const at_cmd_table_t g_custom_utils_cmd[] = {
     {(char *)"AT^GETMAC", custom_get_bt_addr, (char *)" "},
     {(char *)"AT^GETIMEI", custom_get_imei, (char *)" "},
     {(char *)"AT^GETCHIPINFO", custom_get_cywee_chip_info, (char *)" "},
+    {(char *)"AT^GETCYWEEACTIVE", custom_get_cywee_active_state, (char *)" "},
 
 };