hslink: Support upgrade bootloader (#38)

Author: kaidegit

.gitmodules

@@ -22,3 +22,6 @@
 [submodule "projects/HSLink-Pro/third_party_components/flashdb/FlashDB"]
 	path = projects/HSLink-Pro/third_party_components/flashdb/FlashDB
 	url = https://github.com/armink/FlashDB.git
+[submodule "projects/HSLink-Pro/third_party_components/b64.c/b64.c"]
+	path = projects/HSLink-Pro/third_party_components/b64.c/b64.c
+	url = https://github.com/HSLink/b64.c.git

projects/HSLink-Pro/common/hslinkpro/board.h

@@ -25,9 +25,6 @@
 #define BOARD_NAME          "hslinkpro"
 #define BOARD_UF2_SIGNATURE (0x0A4D5048UL)
 
-#define BL_SIZE (128 * 1024)
-#define BL_B_SLOT_SIZE BL_SIZE
-
 static const uint32_t HARDWARE_VER_ADDR = 70;
 
 typedef struct {

projects/HSLink-Pro/common/user_config.h

@@ -644,13 +644,21 @@ __STATIC_FORCEINLINE uint32_t PIN_nRESET_IN(void)
 */
 __STATIC_FORCEINLINE void PIN_nRESET_OUT(uint32_t bit)
 {
+    static uint8_t SRST_Level = 0xFF;
+    if (SRST_Level == 0xFF) {
+        if (CheckHardwareVersion(1, 2, UINT8_MAX)) {
+            SRST_Level = 0;
+        } else {
+            SRST_Level = 1;
+        }
+    }
     if (bit & 0x01) {
         if (SETTING_GET_RESET_MODE(HSLink_Setting.reset, RESET_NRST)) {
-            gpio_write_pin(PIN_GPIO, GPIO_GET_PORT_INDEX(PIN_SRST), GPIO_GET_PIN_INDEX(PIN_SRST), Setting_GetSRSTLevel());
+            gpio_write_pin(PIN_GPIO, GPIO_GET_PORT_INDEX(PIN_SRST), GPIO_GET_PIN_INDEX(PIN_SRST), SRST_Level);
         }
     } else {
         if (SETTING_GET_RESET_MODE(HSLink_Setting.reset, RESET_NRST)) {
-            gpio_write_pin(PIN_GPIO, GPIO_GET_PORT_INDEX(PIN_SRST), GPIO_GET_PIN_INDEX(PIN_SRST), !Setting_GetSRSTLevel());
+            gpio_write_pin(PIN_GPIO, GPIO_GET_PORT_INDEX(PIN_SRST), GPIO_GET_PIN_INDEX(PIN_SRST), !SRST_Level);
         }
         if (SETTING_GET_RESET_MODE(HSLink_Setting.reset, RESET_ARM_SWD_SOFT)) {
             software_reset();

projects/HSLink-Pro/src/DAP_config.h

@@ -4,6 +4,13 @@
 #include "setting.h"
 #include "usb_configuration.h"
 #include "HSLink_Pro_expansion.h"
+#include "fal.h"
+#include "fal_cfg.h"
+#include <b64.h>
+#include "crc32.h"
+
+#define LOG_TAG "HID_COMM"
+#include "elog.h"
 
 #ifdef CONFIG_USE_HID_CONFIG
 
@@ -13,8 +20,8 @@
 
 using namespace rapidjson;
 
-#include <unordered_map>
 #include <functional>
+#include <unordered_map>
 
 USB_NOCACHE_RAM_SECTION USB_MEM_ALIGNX uint8_t HID_read_buffer[HID_PACKET_SIZE];
 USB_NOCACHE_RAM_SECTION USB_MEM_ALIGNX uint8_t HID_write_buffer[HID_PACKET_SIZE];
@@ -34,6 +41,8 @@ const char *response_str[] = {
         "failed"
 };
 
+std::string_view filed_miss_msg = "Some fields are missing";
+
 static volatile HID_State_t HID_ReadState = HID_STATE_BUSY;
 
 /*!< custom hid report descriptor */
@@ -93,6 +102,26 @@ struct usbd_endpoint hid_custom_out_ep = {
         .ep_cb = usbd_hid_custom_out_callback,
 };
 
+static bool CheckField(const Value &object, std::pair<std::string_view, Type> field) {
+    auto &[field_name, field_type] = field;
+    if (!object.HasMember(field_name.data())) {
+        return false;
+    }
+    if (object[field_name.data()].GetType() != field_type) {
+        return false;
+    }
+    return true;
+}
+
+static bool CheckFields(const Value &object, std::vector<std::pair<std::string_view, Type>> fields) {
+    for (auto &field: fields) {
+        if (!CheckField(object, field)) {
+            return false;
+        }
+    }
+    return true;
+}
+
 static void FillStatus(HID_Response_t status, char *res, const char *message) {
     StringBuffer buffer;
     Writer writer(buffer);
@@ -105,6 +134,10 @@ static void FillStatus(HID_Response_t status, char *res, const char *message) {
     std::strcpy(res, buffer.GetString());
 }
 
+static void FillStatus(HID_Response_t status, char *res, std::string_view message) {
+    FillStatus(status, res, message.data());
+}
+
 static void FillStatus(HID_Response_t status, char *res) {
     FillStatus(status, res, "");
 }
@@ -327,6 +360,151 @@ static void get_setting(Document &root, char *res) {
     std::strcpy(res, buffer.GetString());
 }
 
+static void erase_bl_b(Document &root, char *res) {
+    fal_partition_erase(bl_b_part,0, bl_b_part->len);
+    FillStatus(HID_RESPONSE_SUCCESS, res);
+}
+
+static void write_bl_b(Document &root, char *res) {
+#define PACK_SIZE 512
+    if (!CheckFields(root,
+                     {{"addr", Type::kNumberType},
+                      {"len",  Type::kNumberType},
+                      {"data", Type::kStringType}})) {
+        FillStatus(HID_RESPONSE_FAILED, res, filed_miss_msg);
+        return;
+    }
+    auto addr = root["addr"].GetInt();
+    auto len = root["len"].GetInt();
+    auto data_b64 = root["data"].GetString();
+    auto data_b64_len = root["data"].GetStringLength();
+    log_d("addr: 0x%X, len: %d, data_len: %d", addr, len, data_b64_len);
+    //    elog_hexdump("b64", 16, data_b64, data_b64_len);
+    if (addr + len > bl_b_part->len) {
+        const char *message = "addr out of range";
+        USB_LOG_WRN("%s\n", message);
+        FillStatus(HID_RESPONSE_FAILED, res, message);
+        return;
+    }
+    if (len % 4 != 0) {
+        char msg[64];
+        snprintf(msg, sizeof(msg), "len %d not multiple of 4", len);
+        log_w(msg);
+        FillStatus(HID_RESPONSE_FAILED, res, msg);
+        return;
+    }
+    if (addr % 512 != 0) {
+        log_w("addr %d not multiple of 512", addr);
+        return;
+    }
+    log_i("addr: 0x%X, len: %d", addr, len);
+    size_t data_len = 0;
+    uint8_t *data = b64_decode_ex(data_b64, data_b64_len, &data_len);
+    log_d("solve b64 data_len: %d", data_len);
+    //    elog_hexdump(LOG_TAG, 16, data, data_len);
+    if (data_len != len) {
+        log_w("data_len != len");
+        FillStatus(HID_RESPONSE_FAILED, res, "data_len != len");
+        return;
+    }
+    if (data_len > PACK_SIZE) {
+        char msg[64];
+        snprintf(msg, sizeof(msg), "data_len %d > %d", data_len, PACK_SIZE);
+        log_w(msg);
+        FillStatus(HID_RESPONSE_FAILED, res, msg);
+        return;
+    }
+    fal_partition_write(bl_b_part, addr, data, len);
+    log_i("write %d bytes to 0x%X done", len, addr + bl_b_part->offset);
+    FillStatus(HID_RESPONSE_SUCCESS, res);
+    free(data);
+}
+
+static void upgrade_bl(Document &root, char *res) {
+    if (!CheckFields(root,
+                     {{"len", Type::kNumberType},
+                      {"crc", Type::kStringType}})) {
+        FillStatus(HID_RESPONSE_FAILED, res, filed_miss_msg);
+        return;
+    }
+    auto len = root["len"].GetInt();
+    auto crc_str = root["crc"].GetString();
+    auto crc = strtoul(crc_str + 2, nullptr, 16);
+    if (len > bl_b_part->len) {
+        char msg[64];
+        snprintf(msg, sizeof(msg), "len %d > %d", len, bl_b_part->len);
+        log_w(msg);
+        FillStatus(HID_RESPONSE_FAILED, res, msg);
+        return;
+    }
+    if (len % 4) {
+        log_w("len %% 4 != 0");
+        FillStatus(HID_RESPONSE_FAILED, res, "len %% 4 != 0");
+        return;
+    }
+
+    {
+        uint32_t crc_calc = 0xFFFFFFFF;
+        const uint32_t CRC_CALC_LEN = 8 * 1024;
+        auto buf = std::make_unique<uint8_t[]>(CRC_CALC_LEN);
+        for (uint32_t i = 0; i < len; i += CRC_CALC_LEN) {
+            auto calc_len = std::min(CRC_CALC_LEN, len - i);
+            fal_partition_read(bl_b_part, i, buf.get(), calc_len);
+            crc_calc = CRC_CalcArray_Software(buf.get(), calc_len, crc_calc);
+            //        log_d("crc calc 0x%x", crc_calc);
+        }
+        if (crc != crc_calc) {
+            log_w("crc != crc_calc recv 0x%x calc 0x%x", crc, crc_calc);
+            FillStatus(HID_RESPONSE_FAILED, res, "crc != crc_calc");
+            return;
+        }
+    }
+
+    log_d("crc check pass, start copy...");
+    {
+        constexpr uint32_t COPY_LEN = 4 * 1024;
+        auto buf = std::make_unique<uint8_t[]>(COPY_LEN);
+        fal_partition_erase(bl_part, 0, bl_part->len);
+        for (size_t i = 0; i < bl_part->len; i += COPY_LEN) {
+            auto copy_len = std::min(COPY_LEN, (uint32_t)(bl_part->len - i));
+            log_d("copy from 0x%X to 0x%X, size 0x%X",
+                  i + bl_b_part->offset,
+                  i + bl_part->offset,
+                  copy_len);
+            fal_partition_read(bl_b_part, i, buf.get(), copy_len);
+            fal_partition_write(bl_part, i, buf.get(), copy_len);
+        }
+    }
+    log_d("copy done");
+    {
+        const uint32_t COMP_LEN = 1024;
+        auto buf_1 = std::make_unique<uint8_t[]>(COMP_LEN);
+        auto buf_2 = std::make_unique<uint8_t[]>(COMP_LEN);
+        for (size_t i = 0; i < bl_part->len; i += COMP_LEN) {
+            auto comp_len = std::min(COMP_LEN, (uint32_t)(bl_part->len - i));
+            fal_partition_read(bl_b_part, i, buf_1.get(), comp_len);
+            fal_partition_read(bl_part, i, buf_2.get(), comp_len);
+            if (memcmp(buf_1.get(), buf_2.get(), comp_len) != 0) {
+                log_w("copy fail at 0x%X", i);
+                FillStatus(HID_RESPONSE_FAILED, res, "copy done check failed");
+                log_d("in b slot");
+                elog_hexdump(LOG_TAG, 16, buf_1.get(), comp_len);
+                log_d("in bl");
+                elog_hexdump(LOG_TAG, 16, buf_2.get(), comp_len);
+                // TODO should we roll back bl? or copy it again?
+            }
+        }
+    }
+
+    log_d("check done");
+
+    FillStatus(HID_RESPONSE_SUCCESS, res);
+
+    board_delay_ms(1000);
+
+    HSP_Reboot();
+}
+
 static void HID_Write(const std::string &res) {
     std::strcpy(reinterpret_cast<char *>(HID_write_buffer + 1), res.c_str());
 }
@@ -351,7 +529,10 @@ void HID_Handle() {
             {"upgrade",         upgrade},
             {"entry_sys_bl",    entry_sys_bl},
             {"entry_hslink_bl", entry_hslink_bl},
-            {"set_hw_ver",      set_hw_ver}
+            {"set_hw_ver",      set_hw_ver},
+            {"erase_bl_b",      erase_bl_b},
+            {"write_bl_b",      write_bl_b},
+            {"upgrade_bl",      upgrade_bl}
     };
 
     Document root;

projects/HSLink-Pro/src/HID_COMM/hid_comm.cpp

@@ -461,6 +461,27 @@ extern "C" void HSP_Loop(void) {
     }
 }
 
+extern "C" void HSP_Reboot(void) {
+    bl_setting.keep_bootloader = 0;
+    neopixel->SetPixel(0, 0, 0, 0);
+    neopixel->Flush();
+    disable_global_irq(CSR_MSTATUS_MIE_MASK);
+    //disable_global_irq(CSR_MSTATUS_SIE_MASK);
+    disable_global_irq(CSR_MSTATUS_UIE_MASK);
+    l1c_dc_invalidate_all();
+    l1c_dc_disable();
+    fencei();
+
+    api_boot_arg_t boot_arg = {
+            .index = 0,
+            .peripheral = API_BOOT_PERIPH_AUTO,
+            .src = API_BOOT_SRC_PRIMARY,
+            .tag = API_BOOT_TAG,
+    };
+
+    ROM_API_TABLE_ROOT->run_bootloader(&boot_arg);
+}
+
 extern "C" void HSP_EnterHSLinkBootloader(void) {
     bl_setting.keep_bootloader = 1;
     neopixel->SetPixel(0, 0, 0, 0);

projects/HSLink-Pro/src/HSLink_Pro_expansion.cpp

@@ -35,6 +35,8 @@ void HSP_Init(void);
  */
 void HSP_Loop(void);
 
+void HSP_Reboot(void);
+
 void HSP_EnterHSLinkBootloader(void);
 
 void HSP_EntrySysBootloader(void);

projects/HSLink-Pro/src/HSLink_Pro_expansion.h

@@ -92,8 +92,13 @@ void SPI_PORT_JTAG_SETUP(void)
     gpiom_configure_pin_control_setting(PIN_SRST);
     gpiom_configure_pin_control_setting(PIN_JTAG_TRST);
 
+    static uint8_t SRST_Level = 1;
+    if (CheckHardwareVersion(1, 2, UINT8_MAX)) {
+        SRST_Level = 0;
+    }
+
     gpio_set_pin_output(PIN_GPIO, GPIO_GET_PORT_INDEX(PIN_SRST), GPIO_GET_PIN_INDEX(PIN_SRST));
-    gpio_write_pin(PIN_GPIO, GPIO_GET_PORT_INDEX(PIN_SRST), GPIO_GET_PIN_INDEX(PIN_SRST), Setting_GetSRSTLevel());
+    gpio_write_pin(PIN_GPIO, GPIO_GET_PORT_INDEX(PIN_SRST), GPIO_GET_PIN_INDEX(PIN_SRST), SRST_Level);
     gpio_set_pin_output(PIN_GPIO, GPIO_GET_PORT_INDEX(PIN_JTAG_TRST), GPIO_GET_PIN_INDEX(PIN_JTAG_TRST));
     gpio_write_pin(PIN_GPIO, GPIO_GET_PORT_INDEX(PIN_JTAG_TRST), GPIO_GET_PIN_INDEX(PIN_JTAG_TRST), 1);
 

projects/HSLink-Pro/src/JTAG_DP/JTAG_DP_SPI.c

@@ -43,8 +43,14 @@ void SPI_PORT_SWD_SETUP(void)
     HPM_IOC->PAD[PIN_SRST].FUNC_CTL = IOC_PAD_FUNC_CTL_ALT_SELECT_SET(0);
     HPM_IOC->PAD[PIN_SRST].PAD_CTL = IOC_PAD_PAD_CTL_PRS_SET(2) | IOC_PAD_PAD_CTL_PE_SET(1) | IOC_PAD_PAD_CTL_PS_SET(1) | IOC_PAD_PAD_CTL_SPD_SET(3);
     gpiom_configure_pin_control_setting(PIN_SRST);
+
+    static uint8_t SRST_Level = 1;
+    if (CheckHardwareVersion(1, 2, UINT8_MAX)) {
+        SRST_Level = 0;
+    }
+
     gpio_set_pin_output(PIN_GPIO, GPIO_GET_PORT_INDEX(PIN_SRST), GPIO_GET_PIN_INDEX(PIN_SRST));
-    gpio_write_pin(PIN_GPIO, GPIO_GET_PORT_INDEX(PIN_SRST), GPIO_GET_PIN_INDEX(PIN_SRST), Setting_GetSRSTLevel());
+    gpio_write_pin(PIN_GPIO, GPIO_GET_PORT_INDEX(PIN_SRST), GPIO_GET_PIN_INDEX(PIN_SRST), SRST_Level);
 
     gpio_write_pin(PIN_SWDIO_DIR_GPIO, GPIO_GET_PORT_INDEX(SWDIO_DIR), GPIO_GET_PIN_INDEX(SWDIO_DIR), 0); // 默认SWDIO为输入
 

projects/HSLink-Pro/src/SW_DP/SW_DP_SPI.c

@@ -178,11 +178,3 @@ void Setting_SaveHardwareVersion(version_t hw_ver) {
             std::to_string(hw_ver.patch);
     fdb_kv_set(&env_db, "hw_ver", hw_ver_str.c_str());
 }
-
-uint8_t Setting_GetSRSTLevel(void) {
-    uint8_t level = 1;
-    if (CheckHardwareVersion(1, 2, UINT8_MAX)) {
-        level = 0;
-    }
-    return level;
-}