CBD_TN/CBD_FOTA_BootLoader/applications/rt_fota.c

/*
 * Copyright (c) 2006-2018, RT-Thread Development Team
 *
 * SPDX-License-Identifier: Apache-2.0
 *
 * Change Logs:
 * Date           Author       Notes
 * 2019-09-22     Warfalcon    first version
 */

#include <stdint.h>
#include <stdio.h>
#include <string.h>
#include <rtthread.h>
#include <rtdevice.h>
#include <board.h>
#include <fal.h>
#include <tinycrypt.h>
#include <fastlz.h>
#include <quicklz.h>
#include <rt_fota.h>
#include <signal_led.h>
#include "sys_config.h"
#include "easyflash.h"
#if defined(RT_USING_FINSH) && defined(FINSH_USING_MSH)
#include <finsh.h>
#include <shell.h>
#endif
#include <rt_fota.h>
#define DBG_ENABLE
#define DBG_SECTION_NAME                    "fota"

#ifdef RT_FOTA_DEBUG
#define DBG_LEVEL                           DBG_LOG
#else
#define DBG_LEVEL                           DBG_INFO
#endif

#define DBG_COLOR
#include <rtdbg.h>

#ifndef RT_FOTA_THREAD_STACK_SIZE			
#define RT_FOTA_THREAD_STACK_SIZE			4096
#endif

#ifndef RT_FOTA_THREAD_PRIORITY			
#define RT_FOTA_THREAD_PRIORITY				(RT_THREAD_PRIORITY_MAX - 3)
#endif

#ifndef RT_FOTA_ALGO_BUFF_SIZE
#define RT_FOTA_ALGO_BUFF_SIZE				2048    // STM32 此处需要设置为2048 因为一个扇区是2K大小
#endif

/**
 * AES256 encryption algorithm option
 */
#ifndef RT_FOTA_ALGO_AES_IV
#define RT_FOTA_ALGO_AES_IV  				"0123456789ABCDEF"
#endif

#ifndef RT_FOTA_ALGO_AES_KEY
#define RT_FOTA_ALGO_AES_KEY 				"0123456789ABCDEF0123456789ABCDEF"
#endif

#ifndef RT_FOTA_BLOCK_HEADER_SIZE
#define RT_FOTA_BLOCK_HEADER_SIZE			4
#endif

#ifndef RT_FOTA_CMPRS_BUFFER_SIZE			
#define RT_FOTA_CMPRS_BUFFER_SIZE			4096
#endif

#ifndef RT_FOTA_FASTLZ_BUFFER_PADDING
#define RT_FOTA_FASTLZ_BUFFER_PADDING 		FASTLZ_BUFFER_PADDING(RT_FOTA_CMPRS_BUFFER_SIZE)
#endif

#ifndef RT_FOTA_QUICKLZ_BUFFER_PADDING
#define RT_FOTA_QUICKLZ_BUFFER_PADDING		QLZ_BUFFER_PADDING
#endif

#ifndef RT_FOTA_ENTER_SHELL_KEY
#define RT_FOTA_ENTER_SHELL_KEY				0x0d
#endif

#ifndef RT_FOTA_GET_CHAR_WAITTIGN
#define RT_FOTA_GET_CHAR_WAITTIGN			(RT_TICK_PER_SECOND * 5)
#endif

#ifndef RT_FOTA_SIGNAL_LED_PIN
#define RT_FOTA_SIGNAL_LED_PIN				GET_PIN(B, 3)
#endif

#ifndef RT_FOTA_SIGNAL_LED_THREAD_STACK_SIZE			
#define RT_FOTA_SIGNAL_LED_THREAD_STACK_SIZE	1024
#endif

#ifndef RT_FOTA_SIGNAL_LED_THREAD_PRIORITY			
#define RT_FOTA_SIGNAL_LED_THREAD_PRIORITY		(RT_THREAD_PRIORITY_MAX - 4)
#endif

/* For signal led */
static led_t *signal_led =  NULL;
static led_mem_opreation_t signal_led_mem_op;
const char *led_shell_mode   = "500,500,"; 		/* 1Hz  ��˸ */
const char *led_upgrade_mode = "50,50,";   		/* 10Hz ��˸ */
const char *led_off_mode     = "0,100,";   		/* ���� */
const char *led_on_mode      = "100,0,";   		/* ���� */
static int stop_in_bootloader=0;
/* For shell */
static rt_sem_t shell_sem = RT_NULL;
static rt_device_t shell_dev = RT_NULL;

typedef struct {
	char type[4];
	rt_uint16_t fota_algo;
	rt_uint8_t fm_time[6];
	char app_part_name[16];
	char download_version[24];
	char current_version[24];
	rt_uint32_t code_crc;
	rt_uint32_t hash_val;
	rt_uint32_t raw_size;
	rt_uint32_t com_size;
	rt_uint32_t head_crc;
} rt_fota_part_head, *rt_fota_part_head_t;

typedef void (*rt_fota_app_func)(void);	
static rt_fota_app_func app_func = RT_NULL;

static rt_fota_part_head fota_part_head;


static void rt_fota_signal_led_on(void)
{
	rt_pin_write(RT_FOTA_SIGNAL_LED_PIN, PIN_LOW);
}

static void rt_fota_signal_led_off(void)
{
	rt_pin_write(RT_FOTA_SIGNAL_LED_PIN, PIN_HIGH);
}

static void rt_fota_signal_led_entry(void *arg)
{
	while(1)
    {
        led_ticks();
        rt_thread_mdelay(LED_TICK_TIME);
    }
}

static void rt_fota_signal_led_init(void)
{
	rt_pin_mode(RT_FOTA_SIGNAL_LED_PIN, PIN_MODE_OUTPUT);

	signal_led_mem_op.malloc_fn = (void* (*)(size_t))rt_malloc;
    signal_led_mem_op.free_fn = rt_free;
    led_set_mem_operation(&signal_led_mem_op);

	signal_led = led_create(rt_fota_signal_led_on, rt_fota_signal_led_off);

	/* Config signal led mode */
    led_set_mode(signal_led, LOOP_PERMANENT, (char *)led_on_mode);
    led_set_blink_over_callback(signal_led, RT_NULL);   
    led_start(signal_led);

	rt_thread_t tid;
	tid = rt_thread_create("sig_led", rt_fota_signal_led_entry, RT_NULL, RT_FOTA_SIGNAL_LED_THREAD_STACK_SIZE, RT_FOTA_SIGNAL_LED_THREAD_PRIORITY, 10);
	if (tid)
		rt_thread_startup(tid);
}

static void rt_fota_signal_led_mode(const char *led_cfg)
{
	RT_ASSERT(led_cfg != RT_NULL);
	
	led_set_mode(signal_led, LOOP_PERMANENT, (char *)led_cfg);
}

static int rt_fota_boot_verify(void)
{
	int fota_res = RT_FOTA_NO_ERR;

	rt_memset(&fota_part_head, 0x0, sizeof(rt_fota_part_head));
	
	/* partition initial */
	fal_init(); 

	extern int fal_init_check(void);
	/* verify partition */
	if (fal_init_check() != 1)
    {
    	LOG_D("Partition initialized failed!");
		fota_res = RT_FOTA_GENERAL_ERR;
		goto __exit_boot_verify;
    }

__exit_boot_verify:
	return fota_res;
}

int rt_fota_part_fw_verify(const char *part_name)
{
#define RT_FOTA_CRC_BUFF_SIZE		4096
#define RT_FOTA_CRC_INIT_VAL		0xffffffff

	int fota_res = RT_FOTA_NO_ERR;
	const struct fal_partition *part;
	rt_fota_part_head part_head;
	rt_uint8_t *body_buf = RT_NULL;
	rt_uint32_t body_crc = RT_FOTA_CRC_INIT_VAL;
	rt_uint32_t hdr_crc;

	if (part_name == RT_NULL)
	{
		LOG_D("Invaild paramenter input!");
		fota_res = RT_FOTA_GENERAL_ERR;
		goto __exit_partition_verify;
	}

	part = fal_partition_find(part_name);
	if (part == RT_NULL)
	{		
		LOG_D("Partition[%s] not found.", part_name);
		fota_res = RT_FOTA_GENERAL_ERR;
		goto __exit_partition_verify;
	}

	/* read the head of RBL files */
	if (fal_partition_read(part, 0, (rt_uint8_t *)&part_head, sizeof(rt_fota_part_head)) < 0)
	{
		LOG_D("Partition[%s] read error!", part->name);
		fota_res = RT_FOTA_PART_READ_ERR;
		goto __exit_partition_verify;
	}

	extern rt_uint32_t rt_fota_crc(rt_uint8_t *buf, rt_uint32_t len);
	hdr_crc = rt_fota_crc((rt_uint8_t *)&part_head, sizeof(rt_fota_part_head) - 4);
	if (hdr_crc != part_head.head_crc)
	{
		LOG_D("Partition[%s] head CRC32 error!", part->name);
		fota_res = RT_FOTA_FW_VERIFY_FAILED;
		goto __exit_partition_verify;
	}
	
	if (rt_strcmp(part_head.type, "RBL") != 0)
	{
		LOG_D("Partition[%s] type[%s] not surport.", part->name, part_head.type);
		fota_res = RT_FOTA_CHECK_FAILED;
		goto __exit_partition_verify;
	}

	if (fal_partition_find(part_head.app_part_name) == RT_NULL)
	{
		LOG_D("Partition[%s] not found.", part_head.app_part_name);
		fota_res = RT_FOTA_FW_VERIFY_FAILED;
		goto __exit_partition_verify;
	}

	body_buf = rt_malloc(RT_FOTA_CRC_BUFF_SIZE);
	if (body_buf == RT_NULL)
	{
		LOG_D("Not enough memory for body CRC32 verify.");	
		fota_res = RT_FOTA_NO_MEM_ERR;
		goto __exit_partition_verify;
	}

	for (int body_pos = 0; body_pos < part_head.com_size;)
	{	
		int body_read_len = fal_partition_read(part, sizeof(rt_fota_part_head) + body_pos, body_buf, RT_FOTA_CRC_BUFF_SIZE);      
		if (body_read_len > 0) 
		{
            if ((body_pos + body_read_len) > part_head.com_size)
            {
                body_read_len = part_head.com_size - body_pos;
            }
            
			extern rt_uint32_t rt_fota_step_crc(rt_uint32_t crc, rt_uint8_t *buf, rt_uint32_t len);
			body_crc = rt_fota_step_crc(body_crc, body_buf, body_read_len);	
			body_pos = body_pos + body_read_len;
		}
		else
		{
			LOG_D("Partition[%s] read error!", part->name);		
			fota_res = RT_FOTA_PART_READ_ERR;
			goto __exit_partition_verify;
		}
	}
	body_crc = body_crc ^ RT_FOTA_CRC_INIT_VAL;
	
	if (body_crc != part_head.code_crc)
	{
		LOG_D("Partition[%s] firmware integrity verify failed.", part->name);		
		fota_res = RT_FOTA_FW_VERIFY_FAILED;
		goto __exit_partition_verify;
	}

__exit_partition_verify:
	if (fota_res == RT_FOTA_NO_ERR)
	{
		rt_enter_critical();
		rt_memcpy(&fota_part_head, &part_head, sizeof(rt_fota_part_head));
		rt_exit_critical();

		LOG_D("partition[%s] verify success!", part->name);
	}
	else
	{
		rt_enter_critical();
		rt_memset(&fota_part_head, 0x0, sizeof(rt_fota_part_head));
		rt_exit_critical();
		
		LOG_D("Partition[%s] verify failed!", part->name);
	}

	if (body_buf)
		rt_free(body_buf);
	
	return fota_res;
}

int rt_fota_check_upgrade(void)
{
	int is_upgrade = 0;

	if (rt_strcmp(fota_part_head.download_version, fota_part_head.current_version) != 0)
	{
		is_upgrade = 1;
		LOG_D("Application need upgrade.");
		goto __exit_check_upgrade;
	}

__exit_check_upgrade:
	return is_upgrade;
}

int rt_fota_copy_version(const char *part_name)
{
#define THE_NOR_FLASH_GRANULARITY		4096

	int fota_res = RT_FOTA_NO_ERR;
	const struct fal_partition *part;
    
    rt_fota_part_head_t part_head = RT_NULL;
    rt_uint8_t *cache_buf = RT_NULL;

	part = fal_partition_find(part_name);
	if (part == RT_NULL)
	{
		LOG_D("Find partition[%s] not found.", part_name);
		fota_res = RT_FOTA_FW_VERIFY_FAILED;
		goto __exit_copy_version;
	}
	    
    cache_buf = rt_malloc(THE_NOR_FLASH_GRANULARITY);
    if (cache_buf == RT_NULL)
    {
        LOG_D("Not enough memory for head erase.");
        fota_res = RT_FOTA_NO_MEM_ERR;
        goto __exit_copy_version;
    }
    part_head = (rt_fota_part_head_t)cache_buf;
	
	if (fal_partition_read(part, 0, cache_buf, THE_NOR_FLASH_GRANULARITY) < 0)
	{
		LOG_I("Read partition[%s] failed.", part_name);
		fota_res = RT_FOTA_PART_READ_ERR;
		goto __exit_copy_version;
	}
	
	rt_memcpy(part_head->current_version, part_head->download_version, sizeof(part_head->current_version));
	extern rt_uint32_t rt_fota_crc(rt_uint8_t *buf, rt_uint32_t len);
	part_head->head_crc = rt_fota_crc((rt_uint8_t *)part_head, sizeof(rt_fota_part_head) - 4);
	
    if (fal_partition_erase(part, 0, THE_NOR_FLASH_GRANULARITY) < 0)
    {
		LOG_D("Erase partition[%s] failed.", part_name);
		fota_res = RT_FOTA_PART_ERASE_ERR;
		goto __exit_copy_version;
    }
	
	if (fal_partition_write(part, 0, (const rt_uint8_t *)cache_buf, THE_NOR_FLASH_GRANULARITY) < 0)
	{
		LOG_I("Write partition[%s] failed.", part_name);
		fota_res = RT_FOTA_PART_WRITE_ERR;
		goto __exit_copy_version;
	}
__exit_copy_version:
	if (cache_buf)
		rt_free(cache_buf);
	
	if (fota_res != RT_FOTA_NO_ERR)
		LOG_I("Copy firmware version failed!");
	else
		LOG_I("Copy firmware version Success!");
	
	return fota_res;
}


int rt_fota_erase_app_part(void)
{
	int fota_res = RT_FOTA_NO_ERR;
	const struct fal_partition *part;

	part = fal_partition_find(fota_part_head.app_part_name);
	if (part == RT_NULL)
	{
		LOG_D("Erase partition[%s] not found.", fota_part_head.app_part_name);
		fota_res = RT_FOTA_FW_VERIFY_FAILED;
		goto __exit_partition_erase;
	}
    
    LOG_I("Partition[%s] erase start:", part->name);
	if (fal_partition_erase(part, 0, fota_part_head.raw_size) < 0)
	{
		LOG_D("Partition[%s] erase failed!", part->name);
		fota_res = RT_FOTA_PART_ERASE_ERR;
		goto __exit_partition_erase;
	}

__exit_partition_erase:
	if (fota_res == RT_FOTA_NO_ERR)
	{
		LOG_D("Partition[%s] erase %d bytes success!", part->name, fota_part_head.raw_size);
	}
	return fota_res;
}

int rt_fota_write_app_part(int fw_pos, rt_uint8_t *fw_buf, int fw_len)
{
	int rt_fota_res = RT_FOTA_NO_ERR;
	const struct fal_partition *part;

	part = fal_partition_find(fota_part_head.app_part_name);
	if (part == RT_NULL)
	{
		LOG_D("Erase partition[%s] not found.", fota_part_head.app_part_name);
		rt_fota_res = RT_FOTA_FW_VERIFY_FAILED;
		goto __partition_write_exit;
	}

	if (fal_partition_write(part, fw_pos, fw_buf, fw_len) < 0)
	{
		LOG_D("Partition[%s] write failed!", part->name);
		rt_fota_res = RT_FOTA_PART_WRITE_ERR;
		goto __partition_write_exit;
	}
__partition_write_exit:
	if (rt_fota_res == RT_FOTA_NO_ERR)
	{
		LOG_D("Partition[%s] write %d bytes success!", part->name, fw_len);
	}
	return rt_fota_res;
}

static int rt_fota_read_part(const struct fal_partition *part, int read_pos, tiny_aes_context *aes_ctx, rt_uint8_t *aes_iv, rt_uint8_t *decrypt_buf, rt_uint32_t decrypt_len)
{
	int fota_err = RT_FOTA_NO_ERR;
	rt_uint8_t *encrypt_buf = RT_NULL;

	if ((part == RT_NULL) || (decrypt_buf == RT_NULL) 
		|| (decrypt_len % 16 != 0) || (decrypt_len > RT_FOTA_ALGO_BUFF_SIZE))
	{
		fota_err = RT_FOTA_GENERAL_ERR;
		goto __exit_read_decrypt;
	}

	rt_memset(decrypt_buf, 0x0, decrypt_len);

	/* Not use AES256 algorithm */
	if (aes_ctx == RT_NULL || aes_iv == RT_NULL)
	{
		fota_err = fal_partition_read(part, sizeof(rt_fota_part_head) + read_pos, decrypt_buf, decrypt_len);
		if (fota_err <= 0)
		{
			fota_err = RT_FOTA_PART_READ_ERR;
		}
		goto __exit_read_decrypt;
	}

	encrypt_buf = rt_malloc(decrypt_len);
	if (encrypt_buf == RT_NULL)
	{
		fota_err = RT_FOTA_GENERAL_ERR;
		goto __exit_read_decrypt;
	}
	rt_memset(encrypt_buf, 0x0, decrypt_len);

	fota_err = fal_partition_read(part, sizeof(rt_fota_part_head) + read_pos, encrypt_buf, decrypt_len);
	if (fota_err <= 0 || fota_err % 16 != 0)
	{
		fota_err = RT_FOTA_PART_READ_ERR;
		goto __exit_read_decrypt;
	}

	tiny_aes_crypt_cbc(aes_ctx, AES_DECRYPT, fota_err, aes_iv, encrypt_buf, decrypt_buf);
__exit_read_decrypt:
	if (encrypt_buf)
		rt_free(encrypt_buf);
	
	return fota_err;
}

int rt_fota_upgrade(const char *part_name)
{
	int fota_err = RT_FOTA_NO_ERR;
	
	const struct fal_partition *part;
	rt_fota_part_head_t part_head = RT_NULL;
	
	tiny_aes_context *aes_ctx = RT_NULL;
	rt_uint8_t *aes_iv = RT_NULL;
	rt_uint8_t *crypt_buf = RT_NULL;
	
	int fw_raw_pos = 0;
	int fw_raw_len = 0;
	rt_uint32_t total_copy_size = 0;

	rt_uint8_t block_hdr_buf[RT_FOTA_BLOCK_HEADER_SIZE];	
	rt_uint32_t block_hdr_pos = RT_FOTA_ALGO_BUFF_SIZE;
	rt_uint32_t block_size = 0;
	rt_uint32_t dcprs_size = 0;
	
	qlz_state_decompress *dcprs_state = RT_NULL;
	rt_uint8_t *cmprs_buff = RT_NULL;
	rt_uint8_t *dcprs_buff = RT_NULL;
	rt_uint32_t padding_size = 0;

	if (part_name == RT_NULL)
	{
		LOG_D("Invaild paramenter input!");
		fota_err = RT_FOTA_GENERAL_ERR;
		goto __exit_upgrade;
	}

	part = fal_partition_find(part_name);
	if (part == RT_NULL)
	{		
		LOG_D("Upgrade partition[%s] not found.", part_name);
		fota_err = RT_FOTA_GENERAL_ERR;
		goto __exit_upgrade;
	}
	
	/* Application partition erase */
	fota_err = rt_fota_erase_app_part();
	if (fota_err != RT_FOTA_NO_ERR)
	{
		goto __exit_upgrade;
	}

	/* rt_fota_erase_app_part() has check fota_part_head vaild already */
	part_head = &fota_part_head;

	crypt_buf = rt_malloc(RT_FOTA_ALGO_BUFF_SIZE);
	if (crypt_buf == RT_NULL)
	{
		LOG_D("Not enough memory for firmware buffer.");
		fota_err = RT_FOTA_NO_MEM_ERR;
		goto __exit_upgrade;
	}

	/* AES256 algorithm enable */
	if ((part_head->fota_algo & RT_FOTA_CRYPT_STAT_MASK) == RT_FOTA_CRYPT_ALGO_AES256)
	{
		aes_ctx = rt_malloc(sizeof(tiny_aes_context));	
		aes_iv = rt_malloc(rt_strlen(RT_FOTA_ALGO_AES_IV) + 1);		
		if (aes_ctx == RT_NULL || aes_iv == RT_NULL)
		{
			LOG_D("Not enough memory for firmware hash verify.");
			fota_err = RT_FOTA_NO_MEM_ERR;
			goto __exit_upgrade;
		}

		rt_memset(aes_iv, 0x0, rt_strlen(RT_FOTA_ALGO_AES_IV) + 1);
		rt_memcpy(aes_iv, RT_FOTA_ALGO_AES_IV, rt_strlen(RT_FOTA_ALGO_AES_IV));
		tiny_aes_setkey_dec(aes_ctx, (rt_uint8_t *)RT_FOTA_ALGO_AES_KEY, 256);
	}
	else if ((part_head->fota_algo & RT_FOTA_CRYPT_STAT_MASK) == RT_FOTA_CRYPT_ALGO_XOR)
	{
		LOG_I("Not surpport XOR.");
		fota_err = RT_FOTA_GENERAL_ERR;
		goto __exit_upgrade;
	}
	
	/* If enable fastlz compress function */	
	if ((part_head->fota_algo & RT_FOTA_CMPRS_STAT_MASK) == RT_FOTA_CMPRS_ALGO_FASTLZ) 
	{
		cmprs_buff = rt_malloc(RT_FOTA_CMPRS_BUFFER_SIZE + RT_FOTA_FASTLZ_BUFFER_PADDING);
		dcprs_buff = rt_malloc(RT_FOTA_CMPRS_BUFFER_SIZE);	
		if (cmprs_buff == RT_NULL || dcprs_buff == RT_NULL)
		{
			LOG_D("Not enough memory for firmware hash verify.");
			fota_err = RT_FOTA_NO_MEM_ERR;
			goto __exit_upgrade;
		}

		padding_size = RT_FOTA_FASTLZ_BUFFER_PADDING;
	}
	else if ((part_head->fota_algo & RT_FOTA_CMPRS_STAT_MASK) == RT_FOTA_CMPRS_ALGO_QUICKLZ) 
	{
		cmprs_buff = rt_malloc(RT_FOTA_CMPRS_BUFFER_SIZE + RT_FOTA_QUICKLZ_BUFFER_PADDING);
		dcprs_buff = rt_malloc(RT_FOTA_CMPRS_BUFFER_SIZE);	
		dcprs_state = rt_malloc(sizeof(qlz_state_decompress));
		if (cmprs_buff == RT_NULL || dcprs_buff == RT_NULL || dcprs_state == RT_NULL)
		{
			LOG_D("Not enough memory for firmware hash verify.");
			fota_err = RT_FOTA_NO_MEM_ERR;
			goto __exit_upgrade;
		}

		padding_size = RT_FOTA_QUICKLZ_BUFFER_PADDING;
		rt_memset(dcprs_state, 0x0, sizeof(qlz_state_decompress));
	}
	else if ((part_head->fota_algo & RT_FOTA_CMPRS_STAT_MASK) == RT_FOTA_CMPRS_ALGO_GZIP) 
	{
		LOG_I("Not surpport GZIP.");
		fota_err = RT_FOTA_GENERAL_ERR;
		goto __exit_upgrade;
	}

	LOG_I("Start to copy firmware from %s to %s partition:", part->name, part_head->app_part_name);

	rt_kprintf("fw_raw_pos %X part_head->com_size %X\n", fw_raw_pos , part_head->com_size);

	while (fw_raw_pos < part_head->com_size)
	{

		if ((part_head->fota_algo & RT_FOTA_CMPRS_STAT_MASK) != RT_FOTA_CRYPT_ALGO_NONE) 
		{		
			if (block_hdr_pos >= RT_FOTA_ALGO_BUFF_SIZE)
			{
				fw_raw_len = rt_fota_read_part(part, fw_raw_pos, aes_ctx, aes_iv, crypt_buf, RT_FOTA_ALGO_BUFF_SIZE);
				if (fw_raw_len < 0)
				{
					LOG_D("AES256 algorithm failed.");
					fota_err = RT_FOTA_PART_READ_ERR;
					goto __exit_upgrade;
				}
				fw_raw_pos += fw_raw_len;

				rt_memcpy(block_hdr_buf, crypt_buf, RT_FOTA_BLOCK_HEADER_SIZE);
				block_size = block_hdr_buf[0] * (1 << 24) + block_hdr_buf[1] * (1 << 16) + block_hdr_buf[2] * (1 << 8) + block_hdr_buf[3];
				rt_memset(cmprs_buff, 0x0, RT_FOTA_CMPRS_BUFFER_SIZE + padding_size);
				rt_memcpy(cmprs_buff, &crypt_buf[RT_FOTA_BLOCK_HEADER_SIZE], block_size);

				block_hdr_pos = RT_FOTA_BLOCK_HEADER_SIZE + block_size;
			}
			else
			{
				rt_uint8_t hdr_tmp_pos = 0;
				while (block_hdr_pos < RT_FOTA_ALGO_BUFF_SIZE)
				{
					if (hdr_tmp_pos < RT_FOTA_BLOCK_HEADER_SIZE)
					{
						block_hdr_buf[hdr_tmp_pos++] = crypt_buf[block_hdr_pos++];
					}
					else
					{
						block_size = block_hdr_buf[0] * (1 << 24) + block_hdr_buf[1] * (1 << 16) + block_hdr_buf[2] * (1 << 8) + block_hdr_buf[3];
						
						rt_memset(cmprs_buff, 0x0, RT_FOTA_CMPRS_BUFFER_SIZE + padding_size);
						if (block_size > (RT_FOTA_ALGO_BUFF_SIZE - block_hdr_pos))
						{								
							rt_memcpy(cmprs_buff, &crypt_buf[block_hdr_pos], (RT_FOTA_ALGO_BUFF_SIZE - block_hdr_pos));
							fw_raw_len = rt_fota_read_part(part, fw_raw_pos, aes_ctx, aes_iv, crypt_buf, RT_FOTA_ALGO_BUFF_SIZE);
							if (fw_raw_len < 0)
							{
								LOG_D("AES256 algorithm failed.");
								fota_err = RT_FOTA_PART_READ_ERR;
								goto __exit_upgrade;
							}
							fw_raw_pos += fw_raw_len;

							rt_memcpy(&cmprs_buff[RT_FOTA_ALGO_BUFF_SIZE - block_hdr_pos], &crypt_buf[0], (block_size +  block_hdr_pos) - RT_FOTA_ALGO_BUFF_SIZE);
							block_hdr_pos = (block_size +  block_hdr_pos) - RT_FOTA_ALGO_BUFF_SIZE;
						}
						else
						{
							rt_memcpy(cmprs_buff, &crypt_buf[block_hdr_pos], block_size);
							block_hdr_pos = block_hdr_pos + block_size;
						}						
						break;
					}
				}
				
				if (hdr_tmp_pos < RT_FOTA_BLOCK_HEADER_SIZE)
				{				
					fw_raw_len = rt_fota_read_part(part, fw_raw_pos, aes_ctx, aes_iv, crypt_buf, RT_FOTA_ALGO_BUFF_SIZE);
					if (fw_raw_len < 0)
					{
						LOG_D("AES256 algorithm failed.");
						fota_err = RT_FOTA_PART_READ_ERR;
						goto __exit_upgrade;
					}
					fw_raw_pos += fw_raw_len;

					block_hdr_pos = 0;
					while (hdr_tmp_pos < RT_FOTA_BLOCK_HEADER_SIZE)
					{
						block_hdr_buf[hdr_tmp_pos++] = crypt_buf[block_hdr_pos++];
					}
					block_size = block_hdr_buf[0] * (1 << 24) + block_hdr_buf[1] * (1 << 16) + block_hdr_buf[2] * (1 << 8) + block_hdr_buf[3];

					rt_memset(cmprs_buff, 0x0, RT_FOTA_CMPRS_BUFFER_SIZE + padding_size);
					rt_memcpy(cmprs_buff, &crypt_buf[block_hdr_pos], block_size);

					block_hdr_pos = (block_hdr_pos + block_size) % RT_FOTA_ALGO_BUFF_SIZE;
				}
			}

			rt_memset(dcprs_buff, 0x0, RT_FOTA_CMPRS_BUFFER_SIZE);		
			if ((part_head->fota_algo & RT_FOTA_CMPRS_STAT_MASK) == RT_FOTA_CMPRS_ALGO_FASTLZ) 
			{
				dcprs_size = fastlz_decompress((const void *)&cmprs_buff[0], block_size, &dcprs_buff[0], RT_FOTA_CMPRS_BUFFER_SIZE);
			}
			else if ((part_head->fota_algo & RT_FOTA_CMPRS_STAT_MASK) == RT_FOTA_CMPRS_ALGO_QUICKLZ) 
			{
				dcprs_size = qlz_decompress((const char *)&cmprs_buff[0], &dcprs_buff[0], dcprs_state);
			}
			
			if (dcprs_size <= 0)
			{
				LOG_D("Decompress failed: %d.", dcprs_size);
				fota_err = RT_FOTA_GENERAL_ERR;
				goto __exit_upgrade;
			}

			if (rt_fota_write_app_part(total_copy_size, dcprs_buff, dcprs_size) < 0)
			{
				fota_err = RT_FOTA_COPY_FAILED;
				goto __exit_upgrade;
			}

			total_copy_size += dcprs_size;
			rt_kprintf("#");
		}
		/* no compress option */
		else
		{
			fw_raw_len = rt_fota_read_part(part, fw_raw_pos, aes_ctx, aes_iv, crypt_buf, RT_FOTA_ALGO_BUFF_SIZE);
			if (fw_raw_len < 0)
			{
				LOG_D("AES256 algorithm failed.");
				fota_err = RT_FOTA_PART_READ_ERR;
				goto __exit_upgrade;
			}		
			fw_raw_pos += fw_raw_len;

			//rt_kprintf("rt_fota_write_app_part addr  > %X size %X\n" , total_copy_size + 0x32000 , fw_raw_len);
			if (rt_fota_write_app_part(total_copy_size, crypt_buf, fw_raw_len) < 0)
			{
				fota_err = RT_FOTA_COPY_FAILED;
				goto __exit_upgrade;
			}
			
			total_copy_size += fw_raw_len;
			rt_kprintf("#");
		}
	}

	/* it has compress option */
	if ((part_head->fota_algo & RT_FOTA_CMPRS_STAT_MASK) != RT_FOTA_CRYPT_ALGO_NONE)
	{
        while (total_copy_size < part_head->raw_size)
        {
            if ((block_hdr_pos < fw_raw_len) && ((fw_raw_len - block_hdr_pos) > RT_FOTA_BLOCK_HEADER_SIZE))
            {
                rt_memcpy(block_hdr_buf, &crypt_buf[block_hdr_pos], RT_FOTA_BLOCK_HEADER_SIZE);
                block_size = block_hdr_buf[0] * (1 << 24) + block_hdr_buf[1] * (1 << 16) + block_hdr_buf[2] * (1 << 8) + block_hdr_buf[3];
                if ((fw_raw_len - block_hdr_pos - RT_FOTA_BLOCK_HEADER_SIZE) >= block_size)
                {
                    rt_memset(cmprs_buff, 0x0, RT_FOTA_CMPRS_BUFFER_SIZE + padding_size);				
                    rt_memcpy(cmprs_buff, &crypt_buf[block_hdr_pos + RT_FOTA_BLOCK_HEADER_SIZE], block_size);
                    rt_memset(dcprs_buff, 0x0, RT_FOTA_CMPRS_BUFFER_SIZE);
                    
                    block_hdr_pos += (block_size + RT_FOTA_BLOCK_HEADER_SIZE);

                    if ((part_head->fota_algo & RT_FOTA_CMPRS_STAT_MASK) == RT_FOTA_CMPRS_ALGO_FASTLZ) 
                    {
                        dcprs_size = fastlz_decompress((const void *)&cmprs_buff[0], block_size, &dcprs_buff[0], RT_FOTA_CMPRS_BUFFER_SIZE);
                    }
                    else if ((part_head->fota_algo & RT_FOTA_CMPRS_STAT_MASK) == RT_FOTA_CMPRS_ALGO_QUICKLZ) 
                    {
                        dcprs_size = qlz_decompress((const char *)&cmprs_buff[0], &dcprs_buff[0], dcprs_state);
                    }

                    if (dcprs_size <= 0)
                    {
                        LOG_D("Decompress failed: %d.", dcprs_size);
                        fota_err = RT_FOTA_GENERAL_ERR;
                        goto __exit_upgrade;
                    }

                    if (rt_fota_write_app_part(total_copy_size, dcprs_buff, dcprs_size) < 0)
                    {
                        fota_err = RT_FOTA_COPY_FAILED;
                        goto __exit_upgrade;
                    }

                    total_copy_size += dcprs_size;
                    rt_kprintf("#");
                }
                else
                {
                    break;
                }                                
            }
            else
            {
                break;
            }
        }
	}
    rt_kprintf("\r\n");

	/* �п�������ֵ�����,��ΪAES��Ҫ���16�ֽ�����,�����Ľ��ܽ�ѹֵ�Ĵ������������Ǵ��ڵ���raw_size */
	/* �ȽϺõķ�������һ��У��,Ŀǰ��������HASH_CODE�㷨��֪�� */
	if (total_copy_size < part_head->raw_size)
	{
		LOG_D("Decompress check failed.");
		fota_err = RT_FOTA_GENERAL_ERR;
	}

__exit_upgrade:
	if (aes_ctx)
		rt_free(aes_ctx);

	if (aes_iv)
		rt_free(aes_iv);

	if (crypt_buf)
		rt_free(crypt_buf);

	if (cmprs_buff)
		rt_free(cmprs_buff);

	if (dcprs_buff)
		rt_free(dcprs_buff);

	if (dcprs_state)
		rt_free(dcprs_state);

	if (fota_err == RT_FOTA_NO_ERR)
	{
    	LOG_I("Upgrade success, total %d bytes.", total_copy_size);
	}
	return fota_err;
}

//int rt_fota_start_application(void)
//{
//	int fota_res = RT_FOTA_NO_ERR;
//	const struct fal_partition *part;
//	rt_uint32_t app_addr;
//
//	part = fal_partition_find(RT_FOTA_APP_PART_NAME);
//	if (part == RT_NULL)
//	{
//		LOG_D("Partition[%s] not found.", fota_part_head.app_part_name);
//		fota_res = RT_FOTA_GENERAL_ERR;
//		goto __exit_start_application;
//	}
//
//	app_addr = part->offset + 0x08000000;
//	//�ж��Ƿ�Ϊ0x08XXXXXX.
//	if (((*(__IO uint32_t *)(app_addr + 4)) & 0xff000000) != 0x08000000)
//	{
//		LOG_I("Illegal Flash code.");
//		fota_res = RT_FOTA_GENERAL_ERR;
//		goto __exit_start_application;
//	}
//	// ���ջ����ַ�Ƿ�Ϸ�.
//	if (((*(__IO uint32_t *)app_addr) & 0x2ffe0000) != 0x20000000)
//	{
//		LOG_I("Illegal Stack code.");
//		fota_res = RT_FOTA_GENERAL_ERR;
//		goto __exit_start_application;
//	}
//
//	LOG_I("Implement application now. %X addr.  250424 NEW" , app_addr);
//
//	__disable_irq();
//	HAL_DeInit();
//
//	// 禁用所有NVIC中断并清除挂起位
//	for (IRQn_Type irq = WWDG_IRQn; irq <= DMA2_Channel4_5_IRQn; irq++) {
//	    HAL_NVIC_DisableIRQ(irq);
//	    HAL_NVIC_ClearPendingIRQ(irq);
//	}
//
//	HAL_RCC_DeInit();
//	SysTick->CTRL = 0;
//	SysTick->LOAD = 0;
//	SysTick->VAL = 0;
//
//	// 确保使用MSP并处于特权模式
//	__set_CONTROL(0);
//	__ISB();
//
//
//	//用户代码区第二个字为程序开始地址(复位地址)
//	app_func = (rt_fota_app_func)*(__IO uint32_t *)(app_addr + 4);
//	/* Configure main stack */
//	__set_MSP(*(__IO uint32_t *)app_addr);
//
//	__set_CONTROL(0);
//
//	/* jump to application */
//	app_func();
//	rt_kprintf("Implement application fail.");
//__exit_start_application:
//	LOG_I("Implement application failed.");
//	HMI_WRITE("Implement application failed.");
//	return fota_res;
//}

/***  250430 测试此前的BL失效原因的进度  **/
//int rt_fota_start_application(void)
//{
//    int fota_res = RT_FOTA_NO_ERR;
//    rt_uint32_t app_addr = 0x08032000;
//    typedef void (*pFunction)(void);
//    pFunction JumpToApplication;
//
//    // 1. 验证栈指针
//    uint32_t stackPointer = *(__IO uint32_t *)app_addr;
//    if (stackPointer < 0x20000000 || stackPointer > (0x20000000 + 0x5000)) {
//        LOG_I("Invalid Stack Pointer: 0x%08X", stackPointer);
//        fota_res = RT_FOTA_GENERAL_ERR;
//        goto __exit;
//    }
//
//    // 2. 验证复位地址
//    uint32_t resetHandler = *(__IO uint32_t *)(app_addr + 4);
//    if ((resetHandler & 0xFF000000) != 0x08000000) {
//        LOG_I("Invalid Reset Handler: 0x%08X", resetHandler);
//        fota_res = RT_FOTA_GENERAL_ERR;
//        goto __exit;
//    }
//
//    LOG_I("Jumping to APP: MSP=0x%08X, Reset=0x%08X", stackPointer, resetHandler);
//
//    LOG_I("BL V1.10 250430.");      // 250430 修复升级完成不能正常跳转的问题
//
//
//    // 3. 关闭所有外设和中断
//    __disable_irq();
//    HAL_DeInit();
//
//    // 4. 禁用所有中断
////    for (int i = 0; i < 8; i++) {
////        NVIC->ICER[i] = 0xFFFFFFFF; // 禁用中断
////        NVIC->ICPR[i] = 0xFFFFFFFF; // 清除挂起位
////    }
//
//    //  // 禁用所有NVIC中断并清除挂起位
//      for (IRQn_Type irq = WWDG_IRQn; irq <= DMA2_Channel4_5_IRQn; irq++) {
//          HAL_NVIC_DisableIRQ(irq);
//          HAL_NVIC_ClearPendingIRQ(irq);
//      }
//
//    // 5. 复位时钟和SysTick
//    HAL_RCC_DeInit();
//    SysTick->CTRL = 0;
//    SysTick->LOAD = 0;
//    SysTick->VAL = 0;
//
//    // 6. 设置向量表
////    SCB->VTOR = app_addr;
////    __DSB();
////    __ISB();
//
//    // 7. 准备跳转
//    JumpToApplication = (pFunction)(*(__IO uint32_t *)(app_addr + 4));
//    __set_MSP(stackPointer);
//    __set_CONTROL(0); // 确保使用MSP
//
//    // 8. 最终屏障
////    __ASM volatile("DSB");
////    __ASM volatile("ISB");
//
//    // 9. 跳转
//    JumpToApplication();
//
//    // 如果执行到这里说明跳转失败
//    LOG_I("Jump to APP failed!");
//
//__exit:
//    LOG_I("APP start failed, system will reboot");
//    NVIC_SystemReset();
//    return fota_res;
//}

int rt_fota_start_application(void)
{
    int fota_res = RT_FOTA_NO_ERR;
    rt_uint32_t app_addr = 0x08032000;
    typedef void (*pFunction)(void);
    pFunction JumpToApplication;

    // 1. 验证栈指针
    uint32_t stackPointer = *(__IO uint32_t *)app_addr;
    if (stackPointer < 0x20000000 || stackPointer > (0x20000000 + 0x5000)) {
        LOG_I("Invalid Stack Pointer: 0x%08X", stackPointer);
        fota_res = RT_FOTA_GENERAL_ERR;
        goto __exit;
    }

    // 2. 验证复位地址
    uint32_t resetHandler = *(__IO uint32_t *)(app_addr + 4);
    if ((resetHandler & 0xFF000000) != 0x08000000) {
        LOG_I("Invalid Reset Handler: 0x%08X", resetHandler);
        fota_res = RT_FOTA_GENERAL_ERR;
        goto __exit;
    }

    LOG_I("Jumping to APP: MSP=0x%08X, Reset=0x%08X", stackPointer, resetHandler);

    LOG_I("BL V1.10 250430.");      // 250430 修复升级完成不能正常跳转的问题


    // 3. 关闭所有外设和中断
    __disable_irq();
    HAL_DeInit();

    // 4. 禁用所有中断
    for (int i = 0; i < 8; i++) {
        NVIC->ICER[i] = 0xFFFFFFFF; // 禁用中断
        NVIC->ICPR[i] = 0xFFFFFFFF; // 清除挂起位
    }



    // 5. 复位时钟和SysTick
    HAL_RCC_DeInit();
    SysTick->CTRL = 0;
    SysTick->LOAD = 0;
    SysTick->VAL = 0;

    // 6. 设置向量表
    SCB->VTOR = app_addr;
    __DSB();
    __ISB();

    // 7. 准备跳转
    JumpToApplication = (pFunction)(*(__IO uint32_t *)(app_addr + 4));
    __set_MSP(stackPointer);
    __set_CONTROL(0); // 确保使用MSP

    // 8. 最终屏障
    __ASM volatile("DSB");
    __ASM volatile("ISB");

    // 9. 跳转
    JumpToApplication();

    // 如果执行到这里说明跳转失败
    LOG_I("Jump to APP failed!");

__exit:
    LOG_I("APP start failed, system will reboot");
    NVIC_SystemReset();
    return fota_res;
}

static rt_err_t rt_fota_get_shell_key(void)
{
	char ch;
	rt_err_t res = RT_EOK;
	rt_uint32_t timeout = RT_FOTA_GET_CHAR_WAITTIGN;
	rt_tick_t tick_start, tick_stop;

	RT_ASSERT(shell_dev != RT_NULL);
	RT_ASSERT(shell_sem != RT_NULL);

	rt_tick_set(0);
	tick_start = rt_tick_get();	
	while (1)
	{
		if (rt_device_read(shell_dev, -1, &ch, 1) != 1)
		{			
			if (rt_sem_take(shell_sem, timeout) != RT_EOK)
			{
				res = RT_ERROR;
				goto __exit_get_shell_key;
			}
		}		
		
		if (ch == 0x0d)
			goto __exit_get_shell_key;

		tick_stop = rt_tick_get();
		if ((tick_stop - tick_start) > RT_FOTA_GET_CHAR_WAITTIGN)
		{
			res = RT_ERROR;
			goto __exit_get_shell_key;
		}

		timeout = RT_FOTA_GET_CHAR_WAITTIGN - tick_stop + tick_start;
	}

__exit_get_shell_key:
    if(stop_in_bootloader!=0)
    {
        res = RT_EOK;
    }
	return res;
}

static rt_err_t rt_fota_rx_ind(rt_device_t dev, rt_size_t size)
{
	RT_ASSERT(shell_sem != RT_NULL);
    /* release semaphore to let fota thread rx data */
    rt_sem_release(shell_sem);

    return RT_EOK;
}

static rt_err_t rt_fota_set_device(const char *device_name)
{
	rt_device_t dev;

	RT_ASSERT(device_name != RT_NULL);
	
	dev = rt_device_find(device_name);
	if (dev == RT_NULL)
	{
		LOG_D("Can not find device: %s.", device_name);
		return RT_ERROR;
	}

	if (shell_sem)
		rt_sem_delete(shell_sem);
    
    shell_sem = rt_sem_create("shell_sem", 0, RT_IPC_FLAG_FIFO);
	if (shell_sem == RT_NULL)
		return RT_ERROR;

	if (dev == shell_dev)
		return RT_EOK;
	
	if (rt_device_open(dev, RT_DEVICE_OFLAG_RDWR | RT_DEVICE_FLAG_INT_RX | RT_DEVICE_FLAG_STREAM) == RT_EOK)
    {
        if (shell_dev != RT_NULL)
        {
            /* close old finsh device */
            rt_device_close(shell_dev);
            rt_device_set_rx_indicate(shell_dev, RT_NULL);
        }

        shell_dev = dev;
        rt_device_set_rx_indicate(dev, rt_fota_rx_ind);
        
        LOG_D("Shell device %s open success.", device_name);
        return RT_EOK;
    }
	
	LOG_D("Shell device %s open failed.", device_name);
	return RT_ERROR;
}


#if defined(RT_FOTA_DEFAULT_KEY_PIN) && defined(RT_FOTA_DEFAULT_KEY_CHK_TIME)
static rt_err_t rt_fota_check_defalut_key(void)
{   
    int chk_idx;
    
	/* GPIO initialized */
	rt_pin_mode(RT_FOTA_DEFAULT_KEY_PIN, PIN_MODE_INPUT_PULLUP);
	/* Delay for power up */
	rt_thread_mdelay(500);

	if (rt_pin_read(RT_FOTA_DEFAULT_KEY_PIN) == PIN_LOW)
		rt_kprintf("Default firmware key pressed:\n");
	
	/* Check GPIO status */
	for (chk_idx = 0; (rt_pin_read(RT_FOTA_DEFAULT_KEY_PIN) == PIN_LOW) && (chk_idx < RT_FOTA_DEFAULT_KEY_CHK_TIME); chk_idx++)
	{
		rt_thread_mdelay(RT_TICK_PER_SECOND);
		rt_kprintf(">");
	}

	if (chk_idx < RT_FOTA_DEFAULT_KEY_CHK_TIME)
		return RT_ERROR;
	else
		return RT_EOK;
}
#endif

void rt_fota_thread_entry(void *arg)
{
	int fota_err = RT_FOTA_NO_ERR;
    extern int finsh_system_init(void);

	/* Signal led initialized */
	rt_fota_signal_led_init();

	/* Partition initialized */
	fota_err = rt_fota_boot_verify();
	if (fota_err != RT_FOTA_NO_ERR)
	{
		LOG_I("Partition initialized failed.");
	}

#if defined(RT_FOTA_DEFAULT_KEY_PIN) && defined(RT_FOTA_DEFAULT_KEY_CHK_TIME)
	/* Default key check */
	if (rt_fota_check_defalut_key() == RT_EOK)
	{
		/* enter to defalut key mode */
		rt_fota_signal_led_mode(led_upgrade_mode);
		goto __exit_default_entry;
	}
#endif

	/* Shell initialized */
	if (rt_fota_set_device(RT_CONSOLE_DEVICE_NAME) == RT_EOK)
	{

	    if(easyflash_init()==EF_NO_ERR) //初始化成功
	    {
	        ef_get_env_blob("stop_in_bootloader", &stop_in_bootloader, sizeof(stop_in_bootloader), NULL); //读出reboot_time的值
	        rt_kprintf("stop_in_bootloader:%d\n",stop_in_bootloader);
	    }
		rt_kprintf("Please press [Enter] key into shell mode in %d secs:\r\n", RT_FOTA_GET_CHAR_WAITTIGN / RT_TICK_PER_SECOND);
		if (rt_fota_get_shell_key() == RT_EOK)
		{	
		    if(stop_in_bootloader!=0)
		    {
		        stop_in_bootloader = 0;
		        ef_set_env_blob("stop_in_bootloader", &stop_in_bootloader, sizeof(stop_in_bootloader));
		    }
			goto __exit_shell_entry;
		}
	}
	else
	{
		LOG_I("Shell device config failed.");
	}	

	/* Firmware partition verify */
	fota_err = rt_fota_part_fw_verify(RT_FOTA_FM_PART_NAME);
	if (fota_err != RT_FOTA_NO_ERR)
		goto __exit_boot_entry;

	/* Check upgrade status */
	if (rt_fota_check_upgrade() <= 0)
		goto __exit_boot_entry;

	/* enter to upgrade mode */
	rt_fota_signal_led_mode(led_upgrade_mode);

	/* Implement upgrade, copy firmware partition to app partition */
	fota_err = rt_fota_upgrade(RT_FOTA_FM_PART_NAME);
	if (fota_err != RT_FOTA_NO_ERR)
		goto __exit_boot_entry;

	/* Update new application verison in RBL file of firmware partition */
	fota_err = rt_fota_copy_version(RT_FOTA_FM_PART_NAME);	
	if (fota_err != RT_FOTA_NO_ERR)
		goto __exit_boot_entry;

__exit_boot_entry:
	/* Implement application */
	rt_fota_start_application();
#if defined(RT_FOTA_DEFAULT_KEY_PIN) && defined(RT_FOTA_DEFAULT_KEY_CHK_TIME)
__exit_default_entry:
#endif

	/* Implement upgrade, copy default partition to app partition */
	if (rt_fota_part_fw_verify(RT_FOTA_DF_PART_NAME) == RT_FOTA_NO_ERR)
	{
		if (rt_fota_upgrade(RT_FOTA_DF_PART_NAME) == RT_FOTA_NO_ERR)
		{		
			rt_fota_start_application();
		}
	}
	LOG_I("Boot application failed, entry shell mode.");
	
__exit_shell_entry:	
	/* enter to shell mode */
	rt_fota_signal_led_mode(led_shell_mode);
	/* Implement shell */
	finsh_system_init();
}

void rt_fota_init(void)
{
	rt_thread_t tid;

	tid = rt_thread_create("rt-boot", rt_fota_thread_entry, RT_NULL, RT_FOTA_THREAD_STACK_SIZE, RT_FOTA_THREAD_PRIORITY, 10);
	if (tid != RT_NULL)
	{
		rt_thread_startup(tid);

	}
	else
	{
		LOG_I("rt-fota thread create failed.");
	}
}

void rt_fota_info(rt_uint8_t argc, char **argv)
{
	char put_buf[24];
	char part_name[2][FAL_DEV_NAME_MAX] = 
    {
        {RT_FOTA_FM_PART_NAME}, 
        {RT_FOTA_DF_PART_NAME}
    };
		
	const char* help_info[] =
    {
            [0]     = "fota probe                       - probe RBL file of partiton",
            [1]     = "fota show partition addr size    - show 'size' bytes starting at 'addr'",
            [2]     = "fota clone des_part src_part     - clone src partition to des partiton",
            [3]     = "fota exec                        - execute application program",
    };

	if (argc < 2)
    {
        rt_kprintf("Usage:\n");
        for (int i = 0; i < sizeof(help_info) / sizeof(char*); i++)
        {
            rt_kprintf("%s\n", help_info[i]);
        }
        rt_kprintf("\n");
    }
    else
    {    	
    	const char *operator = argv[1];		
		if (!rt_strcmp(operator, "probe"))
		{
	    	for (int i = 0; i < 2; i++)
	    	{
	    		if (rt_fota_part_fw_verify(&part_name[i][0]) == RT_FOTA_NO_ERR)
		    	{
		    		LOG_I("===== RBL of %s partition =====", &part_name[i][0]);
		    		LOG_I("| App partition name | %*.s |", 11, fota_part_head.app_part_name);

					rt_memset(put_buf, 0x0, sizeof(put_buf));
					if ((fota_part_head.fota_algo & RT_FOTA_CRYPT_STAT_MASK) == RT_FOTA_CRYPT_ALGO_AES256)
					{
						rt_strncpy(put_buf, " AES", 4);
					}
					else if ((fota_part_head.fota_algo & RT_FOTA_CRYPT_STAT_MASK) == RT_FOTA_CRYPT_ALGO_XOR)
					{
						rt_strncpy(put_buf, " XOR", 4);
					}
                    else
                    {
                        rt_strncpy(put_buf, "NONE", 4);
                    }

					if ((fota_part_head.fota_algo & RT_FOTA_CMPRS_STAT_MASK) == RT_FOTA_CMPRS_ALGO_GZIP)
					{
						rt_strncpy(&put_buf[rt_strlen(put_buf)], " && GLZ", 7);
					}
					else if ((fota_part_head.fota_algo & RT_FOTA_CMPRS_STAT_MASK) == RT_FOTA_CMPRS_ALGO_QUICKLZ)
					{
						rt_strncpy(&put_buf[rt_strlen(put_buf)], " && QLZ", 7);
					}
					else if ((fota_part_head.fota_algo & RT_FOTA_CMPRS_STAT_MASK) == RT_FOTA_CMPRS_ALGO_FASTLZ)
					{
						rt_strncpy(&put_buf[rt_strlen(put_buf)], " && FLZ", 7);
					}

					if (rt_strlen(put_buf) <= 0)
					{
						rt_strncpy(put_buf, "None", 4);
					}
					LOG_I("| Algorithm mode     | %*.s |", 11, put_buf);
					LOG_I("| Firmware version   | %*.s |", 11, fota_part_head.download_version);
					LOG_I("| Code raw size      | %11d |", fota_part_head.raw_size);
	                LOG_I("| Code package size  | %11d |", fota_part_head.com_size);
					LOG_I("| Build Timestamp    | %11d |", *((rt_uint32_t *)(&fota_part_head.fm_time[2])));			
		    	}
	    	} 			
		}
       	else if (!rt_strcmp(operator, "show"))
       	{
       		const struct fal_partition *part;
       		const char *part_name = argv[2];
			
			rt_uint32_t addr = strtol(argv[3], NULL, 0);
			rt_uint32_t size = strtol(argv[4], NULL, 0);
			rt_uint8_t buf[16];
			
			
			part = fal_partition_find(part_name);
			if (part != RT_NULL)
			{
				while (size > 16)
				{
					fal_partition_read(part, addr, buf, 16);					
					
					rt_kprintf("%08X: ", addr);
					for (int i = 0; i < 16; i++)
					{
						rt_kprintf("%02X ", buf[i]);
					}
					rt_kprintf("\n");

					size -= 16;
					addr += 16;
				}

				fal_partition_read(part, addr, buf, size);
				rt_kprintf("%08X: ", addr);
				for (int i = 0; i < size; i++)
				{
					rt_kprintf("%02X ", buf[i]);
				}
				rt_kprintf("\n");
			}       
			else
			{
				rt_kprintf("%s partition is not exist!\n", part_name);
			}
       	}
		else if (!rt_strcmp(operator, "clone"))
		{
       		const char *dst_part_name = argv[2];
			const char *src_part_name = argv[3];
			const struct fal_partition *dst_part;
			const struct fal_partition *src_part;

			dst_part = fal_partition_find(dst_part_name);
			src_part = fal_partition_find(src_part_name);
			if (dst_part == RT_NULL || src_part == RT_NULL)
			{
				if (dst_part == RT_NULL)
					rt_kprintf("%s partition is not exist!\n", dst_part_name);

				if (src_part == RT_NULL)
					rt_kprintf("%s partition is not exist!\n", src_part_name);
			}
			else
			{
				rt_kprintf("Clone %s partition to %s partition:\n", src_part_name, dst_part_name);
				if (fal_partition_erase(dst_part, 0, dst_part->len) >= 0)
				{
					int clone_pos = 0;
					int clone_len = 0, clone_tol_len;
					rt_uint8_t *buf = rt_malloc(4096);

					if (dst_part->len < src_part->len)
						clone_tol_len = dst_part->len;
					else
						clone_tol_len = src_part->len;
					
					while ((clone_pos < clone_tol_len) && (buf != RT_NULL))
					{
						clone_len = fal_partition_read(src_part, clone_pos, buf, 4096);
						if (clone_len < 0)
						{
							rt_kprintf("\nread %s partition failed, clone stop!\n", src_part_name);
							break;
						}
						
						if (fal_partition_write(dst_part, clone_pos, buf, clone_len) < 0)
						{
							rt_kprintf("\nwrite %s partition failed, clone stop!\n", dst_part_name);
							break;
						}

						rt_kprintf("#");
						clone_pos += clone_len;
					}
					
					if (clone_pos >= clone_tol_len)
						rt_kprintf("\nClone partition success, total %d bytes!\n", clone_tol_len);	
					else
						rt_kprintf("\nClone partition failed!\n");

					if (buf)
						rt_free(buf);
				}
			}
		}
		else if (!rt_strcmp(operator, "exec"))
		{
			rt_fota_start_application();
		}
		else
		{
			rt_kprintf("Usage:\n");
	        for (int i = 0; i < sizeof(help_info) / sizeof(char*); i++)
	        {
	            rt_kprintf("%s\n", help_info[i]);
	        }
	        rt_kprintf("\n");
		}
    }
}
/**
 * rt-fota />ymodem_ota
*/
MSH_CMD_EXPORT_ALIAS(rt_fota_info, fota, Check RBL file of partition);