/* * Copyright (c) HiSilicon (Shanghai) Technologies Co., Ltd. 2021-2021. All rights reserved. * Description: main * * Create: 2021-03-09 */ #include "boot_serial.h" #include "boot_init.h" #include "boot_reset.h" #include "boot_verify.h" #include "secure_verify_boot.h" #include "efuse.h" #include "efuse_porting.h" #include "chip_io.h" #include "pinctrl.h" #include "boot_flash.h" #include "sfc.h" #include "boot_delay.h" #include "boot_jump.h" #include "tcxo.h" #include "watchdog.h" #include "drv_pmp.h" #include "pmp_cfg.h" #include "malloc_porting.h" #include "upg_porting.h" #include "upg_common.h" #include "upg_alloc.h" #include "soc_porting.h" #include "drv_flashboot_cipher.h" #ifdef CONFIG_MIDDLEWARE_SUPPORT_UPG_AB #include "upg_ab.h" #endif #include "factory.h" #include "sfc_protect.h" #include "reset_porting.h" #define FLASHBOOT_UART_DEFAULT_PARAM {115200, 8, 1, 0, 0, 2, 1, 4, 0} #define APP_START_INSTRUCTION 0x40006f #define DELAY_100MS 100 #define REG_CMU_CFG0 0x40003408 #define APP_IMAGE_HEADER_LEN ((KEY_AREA_STRUCTURE_LENGTH) + (CODE_INFO_STRUCTURE_LENGTH)) #define BOOT_WATCH_DOG_TIMOUT 7 // 7s #define FLASH_KEY_SALT_LEN 28 #define FLASH_ENCRY_ADDR_ALINE 256 #define FLASH_NO_ENCRY_FLAG 0x3C7896E1 #define FLASHBOOT_RAM_ADDR 0xA28000 #define FLASH_BOOT_TYPE_REG 0x40000024 #define FLASH_BOOT_TYPE_REG_MAIN 0xA5A5A5A5 #define FLASH_BOOT_TYPE_REG_BKUP 0x5A5A5A5A const sfc_flash_config_t sfc_cfg = { .read_type = FAST_READ_QUAD_OUTPUT, .write_type = PAGE_PROGRAM, .mapping_addr = 0x200000, .mapping_size = 0x800000, }; #if 1 //ADD LYL 2024 1122 -------- #define USERPAGE 0x003F2000 //AT参数存储区 #define BLE_CONKEYLEN 16 #pragma pack(push) #pragma pack(1) typedef struct { int8_t updateflag; //update flag int8_t validflag; //valid flag int8_t tmode_mode; int8_t wmode_mode; //STA, 140 bytes uint8_t sta_ssid[33]; uint8_t sta_key[65]; int8_t wsauth; int8_t wsencry; uint8_t wslko; uint8_t pmk_av; uint8_t sta_padding[6]; uint8_t pmk[32]; //AP, 144 bytes int8_t wap_mode; int8_t wap_channel; int8_t waauth; int8_t waencry; uint8_t walk_led; uint8_t max_sta_num; uint8_t ap_enable_hide; uint8_t ap_ssid[33]; uint8_t ap_key[65]; uint8_t ap_pmk_av; uint8_t ap_pmk[32]; uint8_t ap_padding[6]; //UART, 20 bytes int8_t baudrate; int8_t data_bits; int8_t stop_bits; int8_t parity; int8_t ctsrts; int8_t uart1_baudrate; int8_t uart1_data_bits; int8_t uart1_stop_bits; int8_t uart1_parity; int8_t uart1_debug; int8_t uartfable; int8_t fuartte_mode; uint16_t uarttm; uint16_t uartbuf; uint8_t uart_padding[4]; //NETP, 108 bytes int8_t protocol; int8_t app_mode; uint8_t maxsocket; char cipadd[101]; uint16_t pro_port; uint16_t tcpto; //SOCKB, 112 bytes uint16_t sockb_port; uint16_t sockb_tcpto; int8_t sockb_pro; char sockb_cipadd[101]; int8_t tcpdis; int8_t tcpdisb; uint16_t udp_localporta; uint16_t udp_localportb; //NETWORK, 108 bytes char wann_ipaddr[16]; char wann_mask[16]; char wann_gateway[16]; char lann_ipaddr[16]; char lann_mask[16]; uint8_t wann_mode; uint8_t network_padding[2]; uint8_t domain_name[21]; uint32_t dns_addr; //UTILS, 124 bytes int8_t echo; int8_t rlden; uint8_t debug_level; char wel_msg[11]; uint8_t event_onoff; uint8_t noise_filter; uint8_t wifi_switch; uint8_t sta_dtim; uint8_t utils_padding[40]; uint8_t dis_power_saving; int8_t modechange; uint8_t ps_interval; uint8_t mid[21]; uint8_t aswd[21]; uint8_t cmdpw[21]; //HTTPD, 36 bytes char user_name[16]; char user_password[16]; int8_t web_switch; uint8_t web_language; uint8_t web_encode_format; uint8_t httpd_padding; //DHCPD, 4 bytes int8_t dhcpsw; uint8_t dhcpd_addr_start; uint8_t dhcpd_addr_end; uint8_t dhcpd_padding; //UPDATE, 124 bytes char update_url[101]; char update_file[21]; uint8_t update_padding[2]; //NTP, 8 bytes uint8_t ntp_time; uint8_t ntp_enable; uint8_t ntp_padding; int8_t time_zone; uint32_t ntpserver; //SMTLK, 16 bytes uint32_t smtlk_sign; uint8_t smtlk_mode; uint8_t smtlk_protocol; uint8_t smtlk_rtype; uint8_t smtlk_ak_random; uint8_t connect_flag; uint8_t sta_channel; uint8_t sta_bssid[6]; //SMARTAPLINK, 44 bytes uint8_t smartaplink_enable; uint8_t smartaplink_padding; uint8_t smartaplink_prefix[21]; uint8_t smartaplink_key[21]; //NETPID, 24 bytes uint8_t netpa_iden; char netpa_id[11]; uint8_t netpb_iden; char netpb_id[11]; //NETPREG, 264 bytes uint8_t netpa_regen; uint8_t netpa_regtype; uint8_t netpa_reg_padding; char netpa_regdata[129]; uint8_t netpb_regen; uint8_t netpb_regtype; uint8_t netpb_reg_padding; char netpb_regdata[129]; //HEART, 124 bytes uint16_t heart_netp_time; uint16_t heart_sockb_time; uint16_t heart_uart_time; char heart_netp_data[39]; char heart_sockb_data[39]; char heart_uart_data[39]; uint8_t heart_padding; //HTTP, 236 bytes uint8_t http_type; uint8_t http_version; uint8_t http_connect_type; uint8_t http_recv_time; char http_url[51]; char http_header[181]; //MQTT, 224 bytes char mqtt_username[33]; char mqtt_password[33]; char mqtt_clientid[33]; char mqtt_pub_topic[61]; char mqtt_sub_topic[61]; uint8_t mqtt_qos; uint16_t mqtt_heart_time; //BLE, 188 bytes uint16_t conn_min; uint16_t conn_max; uint16_t conn_latency; uint16_t supervisionTO; uint16_t adver_min; uint16_t adver_max; uint8_t ble_name[27]; //BLE广播名 uint8_t ble_dms_name[27]; //BLE配网名 uint8_t ble_adver_data[27]; uint8_t ble_adver_data_len; uint8_t ble_switch; uint8_t ble_uuid_server; uint8_t dms_type; uint8_t ble_padding; uint8_t uuid_ntf_server[17]; uint8_t uuid_ntf_read[17]; uint8_t uuid_ntf_write[17]; uint8_t uuid_ind_server[17]; uint8_t uuid_ind_read[17]; uint8_t uuid_ind_write[17]; uint8_t adver_type; uint8_t adver_channel; uint8_t ble_ind; uint8_t smartconfiglink; uint8_t ble_conenable; uint8_t ble_conkey[BLE_CONKEYLEN]; uint8_t ble_contimeout; uint8_t netpc_iden; char netpc_id[11]; uint8_t netpc_idflag; uint8_t ble_padding2[17]; uint8_t mqtt_tls; uint8_t mqtt_padding[3]; char iot_productkey[12]; char iot_devicename[48]; char iot_devicesecret[48]; char iot_pubtopic[96]; char iot_subtopic[96]; char iot_mode; char iot_padding[3]; uint8_t product_mode; int8_t ctsrts_pin; char instance_flag; char instance_id[32]; char ntp_domain_server[33]; int8_t smk_find; uint32_t mcu_ota_size; uint8_t scan_ch14; uint32_t module_reset_reason; uint8_t reserved1[60+512-4]; uint8_t validflag_magic; int8_t validflag_end; //valid flag }HF_CONFIG_FILE; #pragma pack(pop) HF_CONFIG_FILE g_hf_config_file_boot = {0}; int hfdbg_get_sw(void) { if(g_hf_config_file_boot.debug_level > 0 && g_hf_config_file_boot.debug_level<=20) //1~20允许打印 return 0; if(g_hf_config_file_boot.uart1_debug == 1) //1允许打印 return 1; return 0; } #endif static uint32_t sfc_flash_init(void) { return uapi_sfc_init((sfc_flash_config_t *)&sfc_cfg); } static uint32_t sfc_flash_read(uint32_t flash_addr, uint32_t read_size, uint8_t *read_buffer) { return uapi_sfc_reg_read(flash_addr, read_buffer, read_size); } static uint32_t sfc_flash_write(uint32_t flash_addr, uint32_t flash_write_size, const uint8_t *p_flash_write_data, bool do_erase) { unused(do_erase); return uapi_sfc_reg_write(flash_addr, (uint8_t *)p_flash_write_data, flash_write_size); } static uint32_t sfc_flash_erase(uint32_t flash_addr, uint32_t flash_erase_size) { return uapi_sfc_reg_erase(flash_addr - sfc_cfg.mapping_addr, flash_erase_size); } static void boot_flash_init(void) { flash_cmd_func flash_funcs = {0}; flash_funcs.init = sfc_flash_init; flash_funcs.read = sfc_flash_read; flash_funcs.write = sfc_flash_write; flash_funcs.erase = sfc_flash_erase; boot_regist_flash_cmd(&flash_funcs); uint32_t ret = sfc_flash_init(); if (ret != ERRCODE_SUCC) { boot_msg1("Flash Init Fail! ret = ", ret); } else { uapi_sfc_reg_read(USERPAGE, (unsigned char *)&g_hf_config_file_boot, sizeof(HF_CONFIG_FILE)); boot_msg0("Flash Init Succ!"); } hf_boot_msg1("BootLoader debug_level = ", g_hf_config_file_boot.debug_level); switch_flash_clock_to_pll(); config_sfc_ctrl_ds(); } #define FAMA_REMAP_SRC_BASE_ADDR 0x44007800 #define FAMA_REMAP_LEN_BASE_ADDR 0x44007820 #define FAMA_REMAP_DST_BASE_ADDR 0x44007840 #define FAMA_REMAP_REGION_OFFSET 0x4 #define FAMA_REMAP_LOW_BITS 12 static void dmmu_set(uint32_t src_start_addr, uint32_t src_end_addr, uint32_t dst_start_addr, uint32_t region) { uint32_t src_reg_addr = FAMA_REMAP_SRC_BASE_ADDR + region * FAMA_REMAP_REGION_OFFSET; uint32_t len_reg_addr = FAMA_REMAP_LEN_BASE_ADDR + region * FAMA_REMAP_REGION_OFFSET; uint32_t dst_reg_addr = FAMA_REMAP_DST_BASE_ADDR + region * FAMA_REMAP_REGION_OFFSET; uint32_t src_start_align_addr = src_start_addr >> FAMA_REMAP_LOW_BITS; uint32_t src_end_align_addr = src_end_addr >> FAMA_REMAP_LOW_BITS; uint32_t dst_start_align_addr = dst_start_addr >> FAMA_REMAP_LOW_BITS; uint32_t dst_src_offset = 0; if (region >= FAMA_REMAP_LOW_BITS) { return ; } writel(src_reg_addr, src_start_align_addr); writel(len_reg_addr, src_end_align_addr); if (src_start_align_addr > dst_start_align_addr) { dst_src_offset = src_start_align_addr - dst_start_align_addr; dst_src_offset = ~dst_src_offset; dst_src_offset = dst_src_offset + 1; } else { dst_src_offset = dst_start_align_addr - src_start_align_addr; } writel(dst_reg_addr, dst_src_offset); } static bool flashboot_need_recovery(void) { uint32_t reg = readl(FLASH_BOOT_TYPE_REG); writel(FLASH_BOOT_TYPE_REG, 0); return (reg == FLASH_BOOT_TYPE_REG_BKUP) ? true : false; } static void ws63_flashboot_recovery(void) { if (!flashboot_need_recovery()) { return; } uapi_watchdog_kick(); boot_msg0("Flashboot backup is working!"); partition_information_t src_img_info = {0}; partition_information_t dst_img_info = {0}; errcode_t ret; ret = uapi_partition_get_info(PARTITION_FLASH_BOOT_IMAGE_BACKUP, &src_img_info); ret |= uapi_partition_get_info(PARTITION_FLASH_BOOT_IMAGE, &dst_img_info); if (ret != ERRCODE_SUCC) { boot_msg0("Flashboot partition info get fail!"); return; } ret = uapi_sfc_reg_erase(dst_img_info.part_info.addr_info.addr, dst_img_info.part_info.addr_info.size); if (ret != ERRCODE_SUCC) { boot_msg1("flashboot recovery erase failed!! ret = ", ret); } ret = uapi_sfc_reg_write(dst_img_info.part_info.addr_info.addr, (uint8_t *)(uintptr_t)(src_img_info.part_info.addr_info.addr + FLASH_START), src_img_info.part_info.addr_info.size); if (ret != ERRCODE_SUCC) { boot_msg1("flashboot recovery write failed!! ret = ", ret); } boot_msg0("Flashboot fix ok!"); } #define UPG_FIX_RETRY_CNT_REG RESET_COUNT_REG #define VERIFY_RETRY_CNT_THRES 0x3 #define UPG_FIX_RETRY_CNT_THRES (VERIFY_RETRY_CNT_THRES + 0x3) #define UPG_AB_RETRY_CNT_THRES (VERIFY_RETRY_CNT_THRES + 0x3) static uint8_t ws63_get_try_fix_cnt(void) { gp_reg1_union gp; gp.u32 = readl(UPG_FIX_RETRY_CNT_REG); return gp.bits.fota_fix_app_cnt; } static void ws63_set_try_fix_cnt(uint8_t cnt) { gp_reg1_union gp; gp.u32 = readl(UPG_FIX_RETRY_CNT_REG); gp.bits.fota_fix_app_cnt = cnt & 0xF; writel(UPG_FIX_RETRY_CNT_REG, gp.u32); } #ifdef CONFIG_MIDDLEWARE_SUPPORT_UPG_AB static void ws63_try_fix_app(void) { uint8_t try_cnt = ws63_get_try_fix_cnt() + 1; ws63_set_try_fix_cnt(try_cnt); /* 启动分区连续验签失败次数等于阈值倍数时，切换启动分区 */ if (try_cnt % VERIFY_RETRY_CNT_THRES) { // 1 2 4 5 7 8 a b d e return; } else { // 3 6 9 c f boot_msg0("switch booting"); upg_set_run_region(upg_get_upg_region()); return; } } #else // 压缩 /* 尝试ota修复运行区镜像 */ static void ws63_try_fix_app(void) { uint8_t try_cnt = ws63_get_try_fix_cnt(); /* 连续验签失败次数小于阈值不做处理 */ if (try_cnt < VERIFY_RETRY_CNT_THRES) { ws63_set_try_fix_cnt(try_cnt + 1); return; } /* 修复app超次数阈值后不再尝试 */ if (try_cnt >= UPG_FIX_RETRY_CNT_THRES) { return; } ws63_set_try_fix_cnt(try_cnt + 1); /* 重置升级标记 */ errcode_t ret = uapi_upg_reset_upgrade_flag(); if (ret != ERRCODE_SUCC) { boot_msg1("reset_upgrade_flag fail, ret = ", ret); return; } /* 请求升级 */ ret = uapi_upg_request_upgrade(false); if (ret != ERRCODE_SUCC) { boot_msg0("request_upgrade fail, fota_pkt_not_exit."); return; } boot_msg0("fota_pkt exit, try_fota_fix_app."); } #endif static bool ws63_upg_need_upgrade(void) { uint32_t fota_address = 0; partition_information_t info; errcode_t ret_val = uapi_partition_get_info(PARTITION_FOTA_DATA, &info); if (ret_val != ERRCODE_SUCC || info.type != PARTITION_BY_ADDRESS) { boot_msg1("uapi_partition_get_info failed ", __LINE__); return false; } upg_get_upgrade_flag_flash_start_addr(&fota_address); fota_upgrade_flag_area_t upg_flag_info; ret_val = upg_flash_read(fota_address, sizeof(fota_upgrade_flag_area_t), (uint8_t *)(&upg_flag_info)); if (ret_val != ERRCODE_SUCC) { boot_msg1("upg_flash_read failed ", ret_val); return false; } if (!(upg_flag_info.head_magic == UPG_HEAD_MAGIC && upg_flag_info.head_end_magic == UPG_END_MAGIC && upg_flag_info.complete_flag != 0)) { /* 不需要升级直接返回 */ boot_msg0("No need to upgrade..."); return false; } return true; } static void ws63_upg_check(void) { (void)ws63_upg_init(); #ifdef CONFIG_MIDDLEWARE_SUPPORT_UPG_AB return; #endif if (ws63_upg_need_upgrade()) { boot_msg0("need upgrade"); errcode_t ret = uapi_upg_start(); // 1, 没有升级包、或者升级标记区结果已经设置的情况不需要重启 // 2, 升级模块没有初始化不需要重启 // 3, 升级成功需要重启 // 4, 升级失败的时候需要重启重新进入升级流程，尝试三次未成功，后会变为1的情况 if (!(ret == ERRCODE_UPG_NOT_NEED_TO_UPDATE || ret == ERRCODE_UPG_NOT_INIT || ret == ERRCODE_SUCC)) { boot_msg0("--------------------------"); boot_msg0("upgrade failed, reset now"); } else { // 升级后重启 boot_msg0("--------------------------"); boot_msg0("upgrade success, reset now"); } reset(); } } #define PMU_CMU_CTL_POC_COEX 0x40003238 #define RG_POC_SEL_SW_MODE 0x2 #define PMU_VDD_FLAG_3V3 0 #define POC_SEL_SW_MODE 1 #define POC_VALUE_3V3 0 #define LEVEL_3V3 0x33 #define LEVEL_1V8 0x18 typedef union { struct { uint32_t rg_poc_value : 1; /* [0] */ uint32_t rg_poc_sel : 1; /* [1] */ uint32_t pmu_vdd3318_flag : 1; /* [2] */ uint32_t ms1c : 1; /* [3] */ uint32_t rsv : 28; /* [31:4] */ } bits; uint32_t u32; } u_poc_coex; static void fix_io_level(void) { u_poc_coex poc_coex = {0}; poc_coex.u32 = readl(PMU_CMU_CTL_POC_COEX); if (poc_coex.bits.ms1c == poc_coex.bits.pmu_vdd3318_flag) { return; } if (poc_coex.bits.pmu_vdd3318_flag != PMU_VDD_FLAG_3V3) { return; } poc_coex.bits.rg_poc_value = POC_VALUE_3V3; poc_coex.bits.rg_poc_sel = POC_SEL_SW_MODE; writel(PMU_CMU_CTL_POC_COEX, poc_coex.u32); } static void dump_io_level(void) { u_poc_coex poc_coex = {0}; uint32_t chip_level = LEVEL_3V3; uint32_t sw_level = LEVEL_3V3; poc_coex.u32 = readl(PMU_CMU_CTL_POC_COEX); if (poc_coex.bits.rg_poc_sel == POC_SEL_SW_MODE) { sw_level = (poc_coex.bits.rg_poc_value == POC_VALUE_3V3) ? LEVEL_3V3 : LEVEL_1V8; chip_level = (poc_coex.bits.ms1c == POC_VALUE_3V3) ? LEVEL_3V3 : LEVEL_1V8; boot_msg2("io level work in sw mode, level[sw:chip]:", sw_level, chip_level); } else { chip_level = (poc_coex.bits.ms1c == POC_VALUE_3V3) ? LEVEL_3V3 : LEVEL_1V8; boot_msg1("io level work in hw mode, level[chip]:", chip_level); } } #define FASTBOOT_PWM 1 //CONFIG_PWM_USING_V151 #if FASTBOOT_PWM #define e_printf print_str #include "pwm.h" #ifndef __SPOTLIGHT_H__ #define __SPOTLIGHT_H__ typedef enum elightMode { LIGHT_MODE_CUSTOMER = 0, // 非情景模式 LIGHT_MODE_RELAX, // 休闲模式 LIGHT_MODE_MOVIE, // 观影模式 LIGHT_MODE_DINING, // 用餐模式 LIGHT_MODE_HOME, // 回家模式 LIGHT_MODE_WINTER, // 冬天模式 LIGHT_MODE_SUMMER, // 夏天模式 LIGHT_MODE_LEAVE, // 离家模式 LIGHT_MODE_MAX // 模式数量 } lightMode_e; // 位掩码定义 #define LIGHT_MODE_LEAVE_BIT (1 << 7) // 离家模式位 #define LIGHT_MODE_MASK (0x7F) // 基础模式掩码（7位） #define LIGHT_MODE_IS_LEAVE(mode) ((mode) & LIGHT_MODE_LEAVE_BIT) #define LIGHT_MODE_GET_BASE(mode) ((mode) & LIGHT_MODE_MASK) #define LIGHT_MODE_SET_LEAVE(base_mode) ((base_mode) | LIGHT_MODE_LEAVE_BIT) typedef enum { INIT_POWER_ON, NET_CONFIGING, BIND_OK, }eDeviceBindStatus; // 服务ID定义 #define SVC_ID_SWITCH "switch" // 开关控制 #define SVC_ID_BRIGHTNESS "brightness" // 亮度控制 #define SVC_ID_CCT "cct" // 色温控制 #define SVC_ID_LIGHT_MODE "lightMode" // 场景模式控制 #define SVC_ID_FADE_TIME "progressSwitch" // 渐变时长的控制 #define SVC_ID_COLOUR_MODE "colourMode" // 色温模式控制 // JSON字段名定义 #define JSON_FIELD_ON "on" // 开关状态字段 #define JSON_FIELD_BRIGHTNESS "brightness" // 亮度字段 #define JSON_FIELD_CCT "colorTemperature" // 色温字段 #define JSON_FIELD_MODE "mode" // 场景模式字段 #define JSON_FIELD_FADE_TIME "fadeTime" // 渐变时长字段 #define JSON_FIELD_COLOUR_MODE "mode" // 色温模式字段 typedef enum { REPORT_SWITCH = 1 << 0, REPORT_BRIGHTNESS = 1 << 1, REPORT_CCT = 1 << 2, REPORT_LIGHT_MODE = 1 << 3, REPORT_FADE_TIME = 1 << 4, REPORT_COLOUR_MODE = 1 << 5, REPORT_ALL = REPORT_SWITCH | REPORT_BRIGHTNESS | REPORT_CCT | REPORT_LIGHT_MODE | REPORT_FADE_TIME | REPORT_COLOUR_MODE, } report_mask_e; // 色温模式定义 typedef enum { COLOUR_MODE_SINGLE = 0, // 单色温模式 COLOUR_MODE_DUAL = 1, // 双色温模式 } colourMode_e; // 当前亮度和色温状态 typedef struct __attribute__((packed, aligned(1))) { // 物模型同步需要 持久化维持 uint8_t on; // 开关状态 lightMode_e elightMode; uint16_t brightness_local; // 当前亮度 (0-1000) uint16_t fade_time; // 渐变时长(s) uint16_t cct_local; // 当前色温 (2700-6500) uint8_t colourMode; // 色温模式 (0:单色温, 1:双色温) // 持久化维持 int32_t power_on_cnt; // 上电次数计数 uint8_t is_networked; // 是否已配网 uint8_t is_net_configured; // 设备是否曾经配网成功过 uint32_t reserve[10]; // 保留字段 //运行时的数据 uint16_t duty_cw; // 冷白LED占空比 uint16_t duty_ww; // 暖白LED占空比 uint8_t read_done; // 读取数据done } device_control_t; // 色温范围定义 #define CCT_MIN 2700 // 最小色温 2700K (暖白) #define CCT_MAX 6000 // 最大色温 6000K (冷白) #define CCT_RANGE (CCT_MAX - CCT_MIN) #define CCT_LOCAL_MIN 0 // 最小色温 0K (暖白) #define CCT_LOCAL_MAX (CCT_LOCAL_MIN + CCT_RANGE) // 最大色温 6000K (冷白) #define CCT_LOCAL2REMOTE(x) (x + (CCT_MIN - CCT_LOCAL_MIN)) #define CCT_REMOTE2LOCAL(x) (x - (CCT_MIN - CCT_LOCAL_MIN)) #define CCT_LITME_RANGE(x) do { \ if (x > CCT_LOCAL_MAX) x = CCT_LOCAL_MAX; \ if (x < CCT_LOCAL_MIN) x = CCT_LOCAL_MIN; \ } while (0) // 亮度范围定义 #define BRIGHTNESS_MIN 0 // 最小亮度 #define BRIGHTNESS_MAX 100 // 最大亮度 #define BRIGHTNESS_LOCAL_MIN 0 // 最小亮度 #define BRIGHTNESS_LOCAL_MAX 1000 // 最大亮度 #define BRIGHTNESS_REMOTE2LOCAL(x) (x * 10) //变化范围0 -1000 #define BRIGHTNESS_LOCAL2REMOTE(x) (x / 10) #define BRIGHTNESS_LITME_RANGE(x) do { \ if (x > BRIGHTNESS_LOCAL_MAX) x = BRIGHTNESS_LOCAL_MAX; \ if (x < BRIGHTNESS_LOCAL_MIN) x = BRIGHTNESS_LOCAL_MIN; \ } while (0) // 设备上电并未进入配网的状态 #define INIT_STA__LIGHT_MODE LIGHT_MODE_CUSTOMER #define INIT_STA__BRIGHTNESS 50 #define INIT_STA__CCT 4000 #define INIT_NET_CFG_PWOER_ON_KEEP_TIME (5 * 1000) // 统计进入配网每次打开状态的保持时间 #define NET_CFG_ENTRY_CNT 6 // 配网进入的上电次数 #define NET_CFG_BREATH_DURATION 1*60*1000 // 配网呼吸灯持续时间(ms) #define NET_CFG_TOTAL_TIMEOUT 10*60*1000 // 配网总超时时间(ms) // 配网成功后的默认值 #define NET_CFG_DEFAULT_BRIGHTNESS 80 // 默认亮度 #define NET_CFG_DEFAULT_CCT 6000 // 默认色温 #define NET_CFG_DEFAULT_FADE_TIME 1 // 默认渐变时长(s) #define NET_CFG_DEFAULT_LIGHTMODE LIGHT_MODE_CUSTOMER // 默认模式 // 配网超时后的默认值 #define NET_CFG_TIMEOUT_BRIGHTNESS 50 // 呼吸灯超时后的亮度 #define NET_CFG_TIMEOUT_CCT 4000 // 呼吸灯超时后的色温 #define FADE_INTERVAL_MIN (10*1000) //us #define NORMAL_FADE_TIME 3 //s #define PWM_DUTY_RATIO_MAX 1000 //呼吸灯定义 #define BREARTH_PERIOD (3*1000*1000) //呼吸灯周期(Us) #define BREARTH_INTERVAL (3*1000) //更新pwm的间隔 us #define BREARTH_STEP ((PWM_DUTY_RATIO_MAX) * 2) / (BREARTH_PERIOD / BREARTH_INTERVAL) //每次变化的幅度 // PWM频率和周期定义 #define PWM_FREQUENCY 3000 // PWM频率 2KHz //渐变范围 #define SMOOTH_TIME_MAX 30 #define SMOOTH_TIME_MIN 0 #define SUPPORT_SAVE_TO_FLASH 1 // 定义Flash存储地址和大小 #define DEVICE_DATA_FLASH_ADDR 0x000000 // 主数据区地址 #define DEVICE_DATA_BACKUP_ADDR 0x001000 // 备份数据区地址 #define DEVICE_DATA_FLASH_SIZE 0x001000 // 使用一个页的大小 // 设备数据结构 typedef struct __attribute__((packed, aligned(1))) { uint8_t checksum; // 校验和 uint32_t magic; // 魔数，用于验证数据有效性 uint32_t version; // 数据版本号 device_control_t control; // 设备控制状态 } device_data_t; #define DEVICE_DATA_MAGIC 0x4C505426 // "LPT&"的ASCII码 #define DEVICE_DATA_VERSION 1 // 数据版本号 // 保存任务相关定义 #define SAVE_TASK_PRIO 25 #define SAVE_TASK_STACK_SIZE 0x1000 #define SAVE_TASK_SLEEP_TIME 100 // 100ms // 保存任务状态 typedef enum { SAVE_STATE_IDLE = 0, // 空闲状态 SAVE_STATE_SAVING, // 正在保存 SAVE_STATE_WAITING // 等待保存 } save_state_e; typedef enum { APP_CHANGE_LIGHT_MODE = 0, APP_CHANGE_LIGHT_BRIGHTNESS_CCT, APP_CLOSE_LIGHT, APP_OPEN_LIGHT, DEV_POWER_ON, } light_ctrl_source_e; // 单色温模式的固定色温值 #define SINGLE_COLOUR_CCT 6000 // 单色温模式固定色温 6000K #define SINGLE_COLOUR_CCT_LOCAL CCT_REMOTE2LOCAL(SINGLE_COLOUR_CCT) // 转换为本地值 #define BRIGHTNESS_PIN GPIO_04 // 冷白LED (CW) #define CCT_PIN GPIO_00 // 暖白LED (WW) #define SWITCH_PIN GPIO_13 #define CONFIG_PWM_GROUP_ID 2 #define DEFAULT_DEVICE_DATA { \ .read_done = false, \ .on = true, \ .elightMode = INIT_STA__LIGHT_MODE, \ .cct_local = CCT_REMOTE2LOCAL(INIT_STA__CCT), \ .brightness_local = BRIGHTNESS_REMOTE2LOCAL(INIT_STA__BRIGHTNESS), \ .fade_time = NET_CFG_DEFAULT_FADE_TIME, \ .colourMode = COLOUR_MODE_DUAL, \ .is_networked = false, \ .is_net_configured = false, \ .duty_cw = 0, \ .duty_ww = 0, \ }; int spotlight_main(void); int set_light(light_ctrl_source_e source, int32_t brightness_local_target, int32_t cct_local_target); int set_smooth_time(uint32_t smooth_time); // 设置渐变时长 void update_pwm_output(bool on_state, uint16_t duty_cw, uint16_t duty_ww); // 模式转换函数 lightMode_e convert_mode_for_report(lightMode_e current_mode); // 将bitmask转换为上报用的枚举值 void stop_net_config(void); extern int fast_report(const char* svc_id); #endif // __SPOTLIGHT_H__ device_control_t g_device_control = DEFAULT_DEVICE_DATA; static uint32_t pwm_period_cnt = 0; // PWM周期 40us static uint8_t channel_id_cw = 0; // 冷白LED通道ID static uint8_t channel_id_ww = 0; // 暖白LED通道ID // 计算PWM占空比 void calculate_pwm_duty(device_control_t* pdevice_control) { // 如果开关关闭，则占空比为0 uint32_t total_brightness_pwm = pdevice_control->brightness_local; if (pdevice_control->colourMode == COLOUR_MODE_SINGLE) { // 单色模式，色温设置为最大值 pdevice_control->cct_local = SINGLE_COLOUR_CCT_LOCAL; } // 根据色温比例计算CW和WW的占空比 // 计算色温比例 (0-10000) uint16_t cct_ratio = ((pdevice_control->cct_local - CCT_LOCAL_MIN) * 10000) / CCT_RANGE; // 根据色温比例计算CW和WW的占空比 // 总亮度保持不变，只调整CW和WW的比例 pdevice_control->duty_cw = (total_brightness_pwm * cct_ratio) / 10000; pdevice_control->duty_ww = total_brightness_pwm - pdevice_control->duty_cw; } // 更新PWM输出 void update_pwm_output(bool on_state, uint16_t duty_cw_val, uint16_t duty_ww_val) { pwm_config_t cfg_repeat = {0}; cfg_repeat.repeat = true; uint16_t current_duty_cw = duty_cw_val; uint16_t current_duty_ww = duty_ww_val; if (current_duty_cw > PWM_DUTY_RATIO_MAX) { current_duty_cw = PWM_DUTY_RATIO_MAX; } if (current_duty_ww > PWM_DUTY_RATIO_MAX) { current_duty_ww = PWM_DUTY_RATIO_MAX; } uint32_t high_cnt_cw = (pwm_period_cnt * current_duty_cw) / PWM_DUTY_RATIO_MAX; uint32_t low_cnt_cw = pwm_period_cnt - high_cnt_cw; uint32_t high_cnt_ww = (pwm_period_cnt * current_duty_ww) / PWM_DUTY_RATIO_MAX; uint32_t low_cnt_ww = pwm_period_cnt - high_cnt_ww; if (!on_state) { high_cnt_cw = 0; low_cnt_cw = pwm_period_cnt; // Ensure low_cnt is full period if off high_cnt_ww = 0; low_cnt_ww = pwm_period_cnt; // Ensure low_cnt is full period if off } // uapi_pwm_stop_group(CONFIG_PWM_GROUP_ID); cfg_repeat.high_time = high_cnt_cw; cfg_repeat.low_time = low_cnt_cw; uapi_pwm_open(channel_id_cw, &cfg_repeat); // uapi_pwm_update_duty_ratio(channel_id_cw, cfg_repeat.low_time, cfg_repeat.high_time); cfg_repeat.high_time = high_cnt_ww; cfg_repeat.low_time = low_cnt_ww; cfg_repeat.offset_time = high_cnt_cw; // WW PWM starts after CW PWM high time uapi_pwm_open(channel_id_ww, &cfg_repeat); // uapi_pwm_update_duty_ratio(channel_id_ww, cfg_repeat.low_time, cfg_repeat.high_time); uapi_pwm_start_group(CONFIG_PWM_GROUP_ID); } static void pwm_init(pin_t pin, pin_t pin1) { // uapi_pin_set_mode(pin, PIN_MODE_1); // uapi_pin_set_mode(pin1, PIN_MODE_1); writel(0x4400d000, 1); //设置GPIO00引脚PWM输出 寄存器地址和io复用号参考文档 writel(0x4400d010, 1); //设置GPIO04引脚PWM输出 寄存器地址和io复用号参考文档 uapi_pwm_init(); // uint32_t frequency = uapi_pwm_get_frequency(pin%8); // uint32_t pwm_base_period_ns = 1000 * 1000 * 1000 / frequency; // uint32_t pwm_base_period_ns = 1000 * 1000 * 1000 / (80 * 1000 * 1000);// 80MHZ // uint32_t pwm_target_period_ns = 1000 * 1000 * 1000 / PWM_FREQUENCY; pwm_period_cnt = ((80 * 1000 * 1000) / PWM_FREQUENCY); // 设置PWM组 channel_id_cw = pin%8; channel_id_ww = pin1%8; uint8_t channel_ids[2] = {channel_id_cw, channel_id_ww}; pwm_config_t cfg_repeat = {0}; cfg_repeat.repeat = true; cfg_repeat.low_time = pwm_period_cnt; uapi_pwm_open(channel_id_cw, &cfg_repeat); uapi_pwm_open(channel_id_ww, &cfg_repeat); uapi_pwm_set_group(CONFIG_PWM_GROUP_ID, channel_ids, sizeof(channel_ids)); uapi_pwm_start_group(CONFIG_PWM_GROUP_ID); // 计算PWM占空比 calculate_pwm_duty(&g_device_control); // 更新PWM输出 update_pwm_output(g_device_control.on, g_device_control.duty_cw, g_device_control.duty_ww); boot_msg0("PWM init success!"); } // 计算校验和 static uint8_t calculate_checksum(const device_data_t* data) { uint8_t sum = 0; const uint8_t* ptr = (const uint8_t*)(((char*)data) + sizeof(data->checksum)); size_t len = sizeof(device_data_t) - sizeof(data->checksum); // 减去checksum字段的大小 for (size_t i = 0; i < len; i++) { sum ^= ptr[i]; } return sum; } // 验证数据有效性 static bool verify_device_data(const device_data_t* data) { if (data->magic != DEVICE_DATA_MAGIC) { e_printf("magic error:%x\n", data->magic); return false; } if (data->version > DEVICE_DATA_VERSION) { e_printf("versoin missmatch:%x\n", data->version); return false; } uint8_t checksum = calculate_checksum(data); if (checksum != data->checksum) { e_printf("check sum error:%x\n", data->version); return false; } return true; } // 从指定地址读取设备数据 static bool read_device_data_from_addr(uint32_t addr, device_data_t* data) { int ret = uapi_sfc_reg_read(addr, (uint8_t*)data, sizeof(device_data_t)); if (ret != 0) { print_str("read device data from address 0x%x failed, actual read length: %d\r\n", addr, ret); return false; } if (!verify_device_data(data)) { print_str("address 0x%x data is invalid\r\n", addr); return false; } return true; } void read_device_data(void) { #if SUPPORT_SAVE_TO_FLASH device_data_t data; bool main_valid = false; bool backup_valid = false; // 尝试读取主数据区 main_valid = read_device_data_from_addr(DEVICE_DATA_FLASH_ADDR + 0x003DE000, &data); // 如果主数据区无效，尝试读取备份区 if (!main_valid) { backup_valid = read_device_data_from_addr(DEVICE_DATA_BACKUP_ADDR + 0x003DE000, &data); } if (!main_valid && backup_valid) { // 如果主数据区无效但备份区有效，从备份区恢复 print_str("restore data from backup\r\n"); } else if (!main_valid && !backup_valid) { // 如果两个区域都无效，使用默认值 print_str("main and backup data are invalid, use default value\r\n"); goto lab_exit; } // 更新设备控制状态 print_str("restore device status:\r\n"); print_str("on: %d => %d\r\n", g_device_control.on, data.control.on); print_str("brightness: %d => %d\r\n", g_device_control.brightness_local, data.control.brightness_local); print_str("cct: %d => %d\r\n", g_device_control.cct_local, data.control.cct_local); e_printf("colourMode: %d => %d\r\n", g_device_control.colourMode, data.control.colourMode); data.control.read_done = false; g_device_control = data.control; lab_exit: #endif g_device_control.read_done = true; print_str("read device data success\r\n"); } #endif // end of FASTBOOT_PWM static uint32_t ws63_flashboot_init(void) { errcode_t err; uart_param_stru uart_param = FLASHBOOT_UART_DEFAULT_PARAM; uapi_tcxo_init(); hiburn_uart_init(uart_param, HIBURN_CODELOADER_UART); boot_msg0("Flashboot Uart Init Succ!"); uapi_partition_init(); pmp_enable(); malloc_port_init(); boot_flash_init(); boot_msg0("Flashboot Uart Init Succ!"); boot_msg0("Flashboot Malloc Init Succ!"); err = sfc_port_fix_sr(); if (err != ERRCODE_SUCC) { boot_msg1("SFC fix SR ret =", err); } dump_io_level(); #if FASTBOOT_PWM read_device_data(); pwm_init(BRIGHTNESS_PIN, CCT_PIN); #endif print_str("flashboot version : %s\r\n", SDK_VERSION); return 0; } static errcode_t ws63_verify_app(uint32_t addr) { errcode_t ret = ERRCODE_SUCC; image_key_area_t *flashboot_key_area = (image_key_area_t *)(FLASHBOOT_RAM_ADDR); ret = verify_image_head(APP_BOOT_TYPE, (uint32_t)(uintptr_t)flashboot_key_area->ext_pulic_key_area, addr); if (ret != ERRCODE_SUCC) { boot_msg1("flashboot verify_image_app_head failed!! ret = ", ret); return ret; } ret = verify_image_body(addr, addr + APP_IMAGE_HEADER_LEN); if (ret != ERRCODE_SUCC) { boot_msg1("verify_image_app_body failed!! ret = ", ret); return ret; } return ERRCODE_SUCC; } static void ws63_verify_app_handle(uint32_t addr) { errcode_t ret = ws63_verify_app(addr); if (ret != ERRCODE_SUCC) { ws63_try_fix_app(); reset(); } set_reset_count(0); ws63_set_try_fix_cnt(0); } static void ws63_flash_encrypt_config(uint32_t image_addr, uint32_t image_size) { image_code_info_t *img_info = (image_code_info_t *)(uintptr_t)(image_addr + sizeof(image_key_area_t)); crypto_klad_effective_key flash_key = {0}; uint32_t start_addr = image_addr + APP_IMAGE_HEADER_LEN; uint32_t end_addr = image_addr + image_size; int32_t ret = ERRCODE_SUCC; if (img_info->code_enc_flag == FLASH_NO_ENCRY_FLAG) { boot_msg0("flash_encrypt disable."); return; } if (start_addr % FLASH_ENCRY_ADDR_ALINE != 0 || end_addr % FLASH_ENCRY_ADDR_ALINE != 0) { boot_msg2("app_image start or end addr err, must 256byte alignment ", image_addr, end_addr); reset(); } boot_msg0("flash_encrypt enable."); flash_key.kdf_hard_alg = CRYPTO_KDF_HARD_ALG_SHA256; flash_key.key_parity = TD_FALSE; flash_key.key_size = CRYPTO_KLAD_KEY_SIZE_128BIT; flash_key.salt = img_info->protection_key_l1; flash_key.salt_length = FLASH_KEY_SALT_LEN; flash_key.oneway = TD_TRUE; ret = drv_rom_cipher_config_odrk1(flash_key); if (ret != ERRCODE_SUCC) { boot_msg1("fapc_set_config drv_rom_cipher_config_odrk1 err = ", (uint32_t)ret); reset(); } ret = drv_rom_cipher_fapc_config(0, start_addr, end_addr, img_info->iv, IV_LEN); if (ret != ERRCODE_SUCC) { boot_msg1("fapc_set_config drv_rom_cipher_fapc_config err = ", (uint32_t)ret); reset(); } ret = drv_rom_cipher_fapc_bypass_config(1, end_addr, FLASH_MAX_END, TD_TRUE); if (ret != ERRCODE_SUCC) { boot_msg1("fapc_set_config drv_rom_cipher_fapc_bypass_config err = ", (uint32_t)ret); reset(); } } static uint32_t ws63_ftm_mode_init(uint32_t image_addr) { uint32_t image_size = 0; uint32_t jump_addr = 0; mfg_factory_config_t mfg_factory_cfg = {0}; uint32_t run_region = mfg_get_ftm_run_region(&mfg_factory_cfg); if (run_region == FTM_REGION_SERVICE) { return 0; } jump_addr = mfg_factory_cfg.factory_addr_start; image_size = mfg_factory_cfg.factory_size; image_key_area_t *mfg_key_area = (image_key_area_t *)(uintptr_t)(jump_addr); if (mfg_key_area->image_id == FACTORYBOOT_KEY_AREA_IMAGE_ID && mfg_factory_cfg.factory_valid == MFG_FACTORY_VALID) { dmmu_set(image_addr, image_addr + image_size, jump_addr, 0); } return 0; } /* the entry of C. */ void start_fastboot(void) { partition_information_t img_info = {0}; uint32_t image_addr = 0; uint32_t image_size = 0; errcode_t err; fix_io_level(); // 关闭CMU假负载 uapi_reg_setbits(REG_CMU_CFG0, 3, 3, 0x7); // 0x7 -> 0x40003408 bit 5:3 (3 bits) boot_clock_adapt(); dmmu_set(0, 0, 0, FAMA_REMAP_LOW_BITS); uapi_watchdog_init(BOOT_WATCH_DOG_TIMOUT); uapi_watchdog_enable(WDT_MODE_RESET); ws63_flashboot_init(); set_efuse_period(); uapi_efuse_init(); ws63_upg_check(); // 升级模式判断 err = uapi_partition_get_info(PARTITION_APP_IMAGE, &img_info); if (err != ERRCODE_SUCC) { boot_msg0("Flashboot get app partition failed!, boot abort!"); reset(); } image_addr = img_info.part_info.addr_info.addr + FLASH_START; image_size = img_info.part_info.addr_info.size; #ifdef CONFIG_MIDDLEWARE_SUPPORT_UPG_AB char *boot_str = "A"; uint32_t jump_addr = upg_get_region_addr(upg_get_run_region()) + FLASH_START; *boot_str = (image_addr == jump_addr) ? 'A' : 'B'; boot_msg0(boot_str); ws63_flash_encrypt_config(jump_addr, image_size); // flash在线加解密配置 ws63_verify_app_handle(jump_addr); // A/B验签 if (image_addr != jump_addr) { // 0x1000: dmmu配置都是闭区间，且需要是4K对齐的地址, 0: 第0组dmmu配置 dmmu_set(image_addr, image_addr + image_size - 0x1000, jump_addr, 0); // 0x1000: dmmu配置都是闭区间，且需要是4K对齐的地址, 1: 第1组dmmu配置 dmmu_set(jump_addr, jump_addr + image_size - 0x1000, image_addr, 1); } #else // 压缩 ws63_flash_encrypt_config(image_addr, image_size); // flash在线加解密配置 ws63_verify_app_handle(image_addr); // app验签 #endif ws63_ftm_mode_init(image_addr); ws63_flashboot_recovery(); uapi_watchdog_kick(); jump_to_execute_addr(image_addr + APP_IMAGE_HEADER_LEN); }