src/lynq/lib/liblynq-fota/rock_ua/rock_ua.c

// 2017-07-31 carota Rock FOTA ua porting file


#define ROCK_FOTA_SUPPORT

#ifdef ROCK_FOTA_SUPPORT


#include "iot_rock.h"
#include "iot_rock_ipl.h"
#include "sha.h"

#include <stdarg.h>
#include <errno.h>
#include <fcntl.h>
#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
//#include <hardware/hardware.h>

//#define off64_t __off64_t


#include <hardware/boot_control.h>
#include <hardware/hardware.h>
#include <sys/reboot.h>



#include "liblog/lynq_deflog.h"
#include "mtk_device_wrap.h"

#define ROCK_DEFAULT_BLOCK_SIZE 0x20000
#define ROCK_RAM_LEN  (1024*1024)


#define ROCK_BACKUP_LEN ROCK_DEFAULT_BLOCK_SIZE


#define DEV_SYSTEM_A    "/dev/disk/by-partlabel/system_a"
#define DEV_SYSTEM_B    "/dev/disk/by-partlabel/system_b"
#define DEV_BOOT_A      "/dev/disk/by-partlabel/boot_a"
#define DEV_BOOT_B      "/dev/disk/by-partlabel/boot_b"

#define DEV_MD1IMG_A    "/dev/disk/by-partlabel/md1img_a"
#define DEV_MD1IMG_B    "/dev/disk/by-partlabel/md1img_b"

#define DEV_TEE_A       "/dev/disk/by-partlabel/tee_a"
#define DEV_TEE_B       "/dev/disk/by-partlabel/tee_b" 

#define DEV_VBMETA_A       "/dev/disk/by-partlabel/vbmeta_a"
#define DEV_VBMETA_B       "/dev/disk/by-partlabel/vbmeta_b" 
#define DEV_BL2         "/dev/disk/by-partlabel/bl2"
#define DEV_BL33        "/dev/disk/by-partlabel/bl33"

#define DEV_MISC        "/dev/disk/by-partlabel/misc"



//#define DEV_DELTA       "/dev/disk/by-partlabel/delta"
#define DEV_DELTA       "/dev/disk/by-partlabel/delta"



#define FILE_UPDATE_STATE  "/data/.update_status"
#define FILE_FOTA_STATE    "/data/.fota_status"

#define NAND_PAGE_SIZE  2048


#define BOOTDEV_TYPE_NAND 1

#define BACKUP_ADDR_FLAG    0xffffffff
#define FILE_BACKUP      "/data/.backup"

#define SLOT_A    0
#define SLOT_B    1

#define FULL_HEAD "full-ota"


int fd_system_a,fd_system_b,fd_boot_a,fd_boot_b,fd_tee_a,fd_tee_b,fd_bl2,fd_bl33,fd_delta,fd_curr,fd_log,fd_update_status,fd_md1img_a,fd_md1img_b,fd_fota_status,fd_vbmeta_a,fd_vbmeta_b;
int fd_write,fd_read;

static unsigned int  delta_offset = 0;
static unsigned int  now_patch = 0;
unsigned int  current_slot = 0;
unsigned char rock_debug_buffer[512];

DELTA_HEAD  da_head;

OTA_STATUS  fota_status;


extern const hw_module_t HAL_MODULE_INFO_SYM;
boot_control_module_t* module;


int rock_mismatch(void* ctx, unsigned char* buf, unsigned int start, unsigned int size, 
					        unsigned int source_hash,unsigned int target_hash) {

	  return 0;
}
							
int rock_fatal(void* ctx, int error_code) {
    return 0;
}

void rock_trace(void* ctx, const char* fmt, ...) {

    va_list     ap;
	memset(rock_debug_buffer,0x0,sizeof(rock_debug_buffer));
    va_start (ap, fmt);

    
    vsnprintf(rock_debug_buffer,sizeof(rock_debug_buffer),fmt,ap);
	LYDBGLOG("+[UA]: %s",rock_debug_buffer);
	

    va_end (ap);

}

static int save_fota_status()
{
	int err;
    fd_fota_status = open(FILE_FOTA_STATE,O_RDWR | O_CREAT,0777);
	//fd_update_status = open(FILE_UPDATE_STATE,O_RDWR);

    if (fd_fota_status < 0) {
        err = errno;
        LYERRLOG("+[UA]: Error opening metadata file: %s\n",strerror(errno));
        return -err;
    }
    
	write(fd_fota_status, &fota_status,sizeof(fota_status));
	sync();
	
	close(fd_fota_status);
}


void rock_progress(void* ctx, int percent) {
	int i = 0;
    rock_trace(ctx, "rock update progress %d\n", percent);
	if (percent > 20) {
        i = fota_status.ota_run;
		if (fota_status.update_status[i-1].check_delta != PASS) {
			fota_status.update_status[i-1].check_delta = PASS;
			fota_status.update_status[i-1].check_rom= PASS;
			save_fota_status();
		}
	}
}

int rock_process_block(void* ctx, unsigned char* data, unsigned int start, unsigned int size){
    //rock_trace(ctx, "rock update progress block %d\n", size);

    int writen = 0;
    int ret,err;
	
	
	if (start == BACKUP_ADDR_FLAG) {
	    int fd_backup = open(FILE_BACKUP,O_RDWR | O_CREAT,0777);
		while (writen < size) {
		    write(fd_backup,data,ROCK_DEFAULT_BLOCK_SIZE);
		    sync();
		    writen += ROCK_DEFAULT_BLOCK_SIZE;
		}
		close(fd_backup);
		return size;
	}
	
	
	
	writen = 0;
   
    if (mtk_device_wrap_seek(fd_write, start, SEEK_SET) < 0) {
        err = errno;
        rock_trace(ctx, "mtk_device_wrap_seek write\n");
		return err;
    } 

    while (writen < size) {
        ret = mtk_device_wrap_write(fd_write,data+writen, ROCK_DEFAULT_BLOCK_SIZE);
        writen += ROCK_DEFAULT_BLOCK_SIZE;
    }   	
	
	
    return size;
}
int rock_write_block(void* ctx, unsigned char* src, unsigned int start, unsigned int size){

#if 0

    int writen = 0;
    int ret,err;
	
	
	if (start == BACKUP_ADDR_FLAG) {
	    int fd_backup = open(FILE_BACKUP,O_RDWR | O_CREAT,0777);
		while (writen < size) {
		    write(fd_backup,src,ROCK_DEFAULT_BLOCK_SIZE);
		    sync();
		    writen += ROCK_DEFAULT_BLOCK_SIZE;
		}
		close(fd_backup);
		return size;
	}
	
	writen = 0;
   
    if (mtk_device_wrap_seek(fd_curr, start, SEEK_SET) < 0) {
        err = errno;
        rock_trace(ctx, "mtk_device_wrap_seek write\n");
		return err;
    } 

    while (writen < size) {
        ret = mtk_device_wrap_write(fd_curr,src+writen, ROCK_DEFAULT_BLOCK_SIZE);
        writen += ROCK_DEFAULT_BLOCK_SIZE;
    }    

#endif

    return size;

}

int rock_read_block(void* ctx, unsigned char* dest, unsigned int start, unsigned int size){


    int ret,err;
	

	if (start == BACKUP_ADDR_FLAG) {
	    int fd_backup = open(FILE_BACKUP,O_RDONLY);
		read(fd_backup,dest,size);
		sync();
		close(fd_backup);
		return size;
	}
	


    if (mtk_device_wrap_seek(fd_read, start, SEEK_SET) < 0) {
        err = errno;
        rock_trace(ctx, "mtk_device_wrap_seek read block err\n");
    }

    do {

        ret = mtk_device_wrap_read(fd_read, dest, size);

        if (ret == 0) {
            break;
        } else if (ret < 0) {
            if (errno == EINTR) {
                continue;
            }
            err = -errno;
            rock_trace(ctx,"%s Error reading metadata file\n");

            mtk_device_wrap_close(fd_read);

            return err;
        }
        size -= ret;
        dest += ret;
    } while(size > 0);


    return ret;    
   
    
}


int rock_read_delta(void* ctx, unsigned char* dest, unsigned int offset, unsigned int size){

    int ret = 0,err = 0;
	
    
    if (mtk_device_wrap_seek(fd_delta, offset + delta_offset, SEEK_SET) < 0) {
        err = -errno;
        rock_trace(ctx, "mtk_device_wrap_seek df_delta err\n");
		return err;
    }

    do {

        ret = mtk_device_wrap_read(fd_delta, dest, size);

        if (ret == 0) {
            break;
        } else if (ret < 0) {
            if (errno == EINTR) {
                continue;
            }
            err = -errno;
            rock_trace(ctx," Error reading metadata file\n");

            mtk_device_wrap_close(fd_delta);

            return err;
        }
        size -= ret;
        dest += ret;
    } while(size > 0);

    return ret;    

}

int rock_get_blocksize(void* ctx) {
	return ROCK_DEFAULT_BLOCK_SIZE;
}

int rock_read_file(void* ctx,  void* name, unsigned char* dest, unsigned int offset, unsigned int size){return 0;}
int rock_write_file(void* ctx,  void* name, unsigned char* src, unsigned int offset, unsigned int size){return 0;}
int rock_delete_file(void* ctx, void* name){return 0;}
/* ROCK IPL end */



static int init_dev_fd()
{

    int err;

    //fd_delta = mtk_device_wrap_open(DEV_DELTA,O_RDONLY);
    fd_delta = mtk_device_wrap_open(DEV_DELTA,O_RDWR);

    if (fd_delta < 0) {
        err = errno;
        LYERRLOG("+[UA]: Error opening metadata file: %s\n",strerror(errno));
        return -err;
    }

    fd_update_status = open(FILE_UPDATE_STATE,O_RDWR | O_CREAT,0777);
	//fd_update_status = open(FILE_UPDATE_STATE,O_RDWR);

    if (fd_update_status < 0) {
        err = errno;
        LYERRLOG("+[UA]: Error opening metadata file: %s\n",strerror(errno));
        return -err;
    }

    return 0;
}





static int close_dev_fd(int fd)
{
    mtk_device_wrap_close(fd);
}



static int reboot_device() {
	
  reboot(RB_AUTOBOOT);
  
  while (1) pause();
}



int test_write_delta(char *source, char *target)
{
    int fd_source,fd_target,size;
	 
	char delta_data[ROCK_DEFAULT_BLOCK_SIZE];
	 
	fd_source = open(source,O_RDONLY);
	 
	if (fd_source < 0) {
	    LYERRLOG("+[UA]: open source  error\n");
	    return 1;
	}

    fd_target = mtk_device_wrap_open(target,O_RDWR);
 
    if (fd_target < 0) {
        mtk_device_wrap_close(fd_target);
	    close(fd_source);
        LYERRLOG("+[UA]: open target  error\n");
        return 1;
    } 
	
	while(( size = read(fd_source,delta_data,ROCK_DEFAULT_BLOCK_SIZE))>0) {
    	   mtk_device_wrap_write(fd_target,delta_data,ROCK_DEFAULT_BLOCK_SIZE);
    }
	
	mtk_device_wrap_close(fd_target);
	close(fd_source);
	return 0;
}


int nand_copyto_nand(char *source, char *target)
{
    int fd_source,fd_target,size;
	 
	char delta_data[ROCK_DEFAULT_BLOCK_SIZE];
	 
	fd_source = mtk_device_wrap_open(source,O_RDONLY);
	 
	if (fd_source < 0) {
	    LYERRLOG("+[UA]: open source  error\n");
	    return 1;
	}

    fd_target = mtk_device_wrap_open(target,O_RDWR);
 
    if (fd_target < 0) {
        mtk_device_wrap_close(fd_target);
		mtk_device_wrap_close(fd_source);
        LYERRLOG("+[UA]: open target  error\n");
        return 1;
    } 
	
	while(( size = mtk_device_wrap_read(fd_source,delta_data,ROCK_DEFAULT_BLOCK_SIZE))>0) {
    	   mtk_device_wrap_write(fd_target,delta_data,ROCK_DEFAULT_BLOCK_SIZE);
    }
	
	mtk_device_wrap_close(fd_target);
	mtk_device_wrap_close(fd_source);
	return 0;
}

int delta_copyto_nand(unsigned int start,int size)
{
 
    char delta_data[NAND_PAGE_SIZE];
	unsigned int ret = 0;
	int err;


	if (mtk_device_wrap_seek(fd_delta, start, SEEK_SET) < 0) {
        LYERRLOG("+[UA]: delta_copyto_nand seek err\n");
		return -1;
    }
 
 	if (mtk_device_wrap_seek(fd_curr, 0, SEEK_SET) < 0) {
        LYERRLOG("+[UA]: delta_copyto_nand seek err\n");
		return -1;
    }
 
 
    do {

        ret = mtk_device_wrap_read(fd_delta, delta_data, NAND_PAGE_SIZE);

        if (ret == 0) {
            break;
        } else if (ret < 0) {
            if (errno == EINTR) {
                continue;
            }
            err = -errno;

            return err;
        }
  
        size -= NAND_PAGE_SIZE;
		//mtk_device_wrap_write(fd_curr,delta_data,NAND_PAGE_SIZE);
		mtk_device_wrap_write(fd_curr,delta_data,ret);

    } while(size > 0);
  
 
 return 0;
 
}





unsigned char ram_buffer[ROCK_RAM_LEN];




static int rock_update_main(unsigned int rom_base,  unsigned int backup_base, unsigned int backup_len, int read_rom_directly, int first_run) {
	int status,err,start;
    int ret = 0;
	int i = 0;
	int retry_cnt = 0;
	
	IOT_UPDATA_CONTEXT ctx;
	UPDATE_INFO up_info;
	//OTA_STATUS  fota_status;


    const hw_module_t* hw_module;
    unsigned int  slot;
	unsigned int  update_mode = MODE_NORMAL;
	unsigned int  delta_size;
    unsigned char full_header[9];
	
	char digest_s[SHA_DIGEST_SIZE];
	char digest_t[SHA_DIGEST_SIZE];

	
    hw_module = &HAL_MODULE_INFO_SYM;

    if (!hw_module ||
        strcmp(BOOT_CONTROL_HARDWARE_MODULE_ID, hw_module->id) != 0) {
        ret = -EINVAL;
    }
    if (ret != 0) {
        LYERRLOG("+[UA]: Error loading boot_control HAL implementation.\n");
        return -1;
    }

    module = (boot_control_module_t*)hw_module;
    module->init(module);


    if (module == NULL) {
        LYERRLOG("+[UA]: Error getting bootctrl module.\n");
	    return  -1;
    }
     /*************    Bootctrl Init  End  *************/

    current_slot = module->getCurrentSlot(module);
    
    int is_successful = module->isSlotMarkedSuccessful(module, current_slot);
  
    LYVERBLOG("Booting slot = %d, : isSlotMarkedSuccessful= %d\n",current_slot,is_successful);  
		


	memset(&ctx, 0, sizeof(ctx));
	ctx.rom_base = 0;
	ctx.ram_base =(unsigned char *)&ram_buffer[0];
	ctx.ram_len = ROCK_RAM_LEN;
	ctx.backup_base = BACKUP_ADDR_FLAG;
	ctx.backup_len = ROCK_DEFAULT_BLOCK_SIZE;	
	ctx.update_nvram = 0;
	ctx.read_rom_directly = read_rom_directly;
    //ctx.first_run = first_run;
    ctx.first_run = 1;

	
    init_dev_fd();
	

    memset(&up_info, 0, sizeof(up_info));
	
	memset(&fota_status,0,sizeof(fota_status));

	
    lseek(fd_update_status,0,SEEK_SET);
    read(fd_update_status,(unsigned char *)&up_info,sizeof(up_info));

	LYVERBLOG("+[UA]: up_info.ota_run = %d\n",up_info.ota_run);
	
	
	if ((up_info.ota_run>PATCH_BL33)||(up_info.ota_run<PATCH_SYSTEM))
	{
		up_info.ota_run = 0;
	}	
	
	up_info.ota_run = 0;
	
	if((up_info.fota_flag[0]=='A')&&(up_info.fota_flag[1]=='-')&&(up_info.fota_flag[2]=='B')){
		update_mode = MODE_A2B;
	}else if((up_info.fota_flag[0]=='B')&&(up_info.fota_flag[1]=='-')&&(up_info.fota_flag[2]=='A')){
		update_mode = MODE_B2A;
	}else{
		update_mode = MODE_NORMAL;
	}
	
	LYVERBLOG("+[UA]: up_info.fota_flag = %s\n",up_info.fota_flag);
	LYVERBLOG("+[UA]: update_mode = %d\n",update_mode);
	
    memset(&da_head, 0, sizeof(da_head));

	mtk_device_wrap_read(fd_delta, (unsigned char*)&da_head, sizeof(da_head));


    rock_trace(&ctx, "da_head.sys:%d,da_head.boot:%d,da_head.tee:%d,da_head.md1img=%d,da_head.vbmeta=%d,da_head.bl33=%d\n", da_head.sys, da_head.boot,da_head.tee,da_head.md1img,da_head.vbmeta,da_head.bl33);
    rock_trace(&ctx, "da_head.fullsys:%d,da_head.fullboot:%d,da_head.fulltee:%d,da_head.fullmd1img=%d,da_head.fullvbmeta=%d,da_head.fullbl33=%d\n", da_head.full_sys, da_head.full_boot,da_head.full_tee, da_head.full_md1img,da_head.full_vbmeta,da_head.full_bl33);

    
    if (da_head.sys>0) {
	    fota_status.update_status[PATCH_SYSTEM - 1].need_update = 1;
	}
	if (da_head.boot>0) {
		fota_status.update_status[PATCH_BOOT - 1].need_update = 1;
	}
	if (da_head.tee>0) {
		fota_status.update_status[PATCH_TEE - 1].need_update = 1;
	}
	if (da_head.md1img>0) {
		fota_status.update_status[PATCH_MD1IMG - 1].need_update = 1;
	}
	
	if (da_head.vbmeta>0) {
		fota_status.update_status[PATCH_VBMETA - 1].need_update = 1;
	}
	if (da_head.bl33>0) {
		fota_status.update_status[PATCH_BL33 - 1].need_update = 1;
	}
	
	if (da_head.full_sys>0) {
		fota_status.update_status[FULL_SYSTEM - 1].need_update = 1;
	}
	if (da_head.full_boot>0) {
		fota_status.update_status[FULL_BOOT - 1].need_update = 1;
	}
	if (da_head.full_tee>0) {
		fota_status.update_status[FULL_TEE - 1].need_update = 1;
	}
	if (da_head.full_md1img>0) {
		fota_status.update_status[FULL_MD1IMG - 1].need_update = 1;
	}
	if (da_head.full_bl33>0) {
		fota_status.update_status[FULL_BL33 - 1].need_update = 1;
	}

	if(da_head.full_vbmeta>0) {
		fota_status.update_status[FULL_VBMETA - 1].need_update = 1;
	}
	fota_status.switch_slot = WAIT;
	save_fota_status();

    delta_size = da_head.sys + da_head.boot + da_head.tee + da_head.md1img + da_head.vbmeta + da_head.bl33;
	

    if ((da_head.sys>0) && (up_info.ota_run <= PATCH_SYSTEM))
	{

        now_patch = PATCH_SYSTEM;
        delta_offset = DELTA_HEARD_SIZE;
  
#if 0		
		if (up_info.ota_run == PATCH_SYSTEM) 
		{
			ctx.first_run = 0;

		}else{
		    ctx.first_run = 1;
		}

		//up_info.ota_run = 0;

		

        if(current_slot==SLOT_B) {
	        fd_system_a = mtk_device_wrap_open(DEV_SYSTEM_A,O_RDWR);
            if (fd_system_a < 0) {
                err = errno;
                LYERRLOG("+[UA]: Error opening metadata file: %s\n",strerror(errno));
                return -err;
            }
			fd_curr = fd_system_a;
		}else{
	        fd_system_b = mtk_device_wrap_open(DEV_SYSTEM_B,O_RDWR);
            if (fd_system_b < 0) {
                err = errno;
                LYERRLOG("+[UA]: Error opening metadata file: %s\n",strerror(errno));
                return -err;
            }
			fd_curr = fd_system_b;			
		}

#endif 


        ctx.first_run = 1;   // always
		
	
		
		if(current_slot==SLOT_B) {
		    system("flash_eraseall /dev/disk/by-partlabel/system_a");
		} else {
			system("flash_eraseall /dev/disk/by-partlabel/system_b");
		}

		
//        if(current_slot==SLOT_B) {
	        fd_system_a = mtk_device_wrap_open(DEV_SYSTEM_A,O_RDWR);
            if (fd_system_a < 0) {
                err = errno;
                LYERRLOG("+[UA]: Error opening metadata file: %s\n",strerror(errno));
                return -err;
            }
//			fd_curr = fd_system_a;
//		}else{
	        fd_system_b = mtk_device_wrap_open(DEV_SYSTEM_B,O_RDWR);
            if (fd_system_b < 0) {
                err = errno;
                LYERRLOG("+[UA]: Error opening metadata file: %s\n",strerror(errno));
                return -err;
            }
//			fd_curr = fd_system_b;			
//		}
		
		if(current_slot==SLOT_B){
			fd_read  = fd_system_b;
			fd_write = fd_system_a;	
		} else {
			fd_read  = fd_system_a;
			fd_write = fd_system_b;
		}

		
		fota_status.ota_run = PATCH_SYSTEM;
        fota_status.update_status[PATCH_SYSTEM -1].check_delta = WAIT;
		fota_status.update_status[PATCH_SYSTEM -1].check_rom = WAIT;
		fota_status.update_status[PATCH_SYSTEM-1].update_result= WAIT;

		save_fota_status();
		
		up_info.ota_run = PATCH_SYSTEM;
		lseek(fd_update_status,0,SEEK_SET);
	    write(fd_update_status, &up_info,sizeof(up_info));
		sync();
		LYVERBLOG("+[UA]: Start upgrading system.\n");
        status = iot_patch(&ctx);
		LYVERBLOG("+[UA]: system upgrade result:%d\n",status);
		
        //fota_status.ota_run = 0;
		fota_status.update_status[PATCH_SYSTEM -1].update_result= status; 
		fota_status.update_result= status;

        if((status == 0)||(status ==1))
        {

            fota_status.update_status[PATCH_SYSTEM -1].check_delta = PASS;
		    fota_status.update_status[PATCH_SYSTEM -1].check_rom = PASS;
               
		}else if(status == E_ROCK_INVALID_DELTA) {
            fota_status.update_status[PATCH_SYSTEM -1].check_delta = ERROR;
		    fota_status.update_status[PATCH_SYSTEM -1].check_rom = WAIT;
		}else if((status == E_ROCK_DELTA_MISMATCH)||(status == E_ROCK_DELTA_CHUNK_MISMATCH)) {
            fota_status.update_status[PATCH_SYSTEM -1].check_delta = PASS;
		    fota_status.update_status[PATCH_SYSTEM -1].check_rom = ERROR;

		}else{
		
			//fota_status.update_status[PATCH_SYSTEM -1].check_delta = PASS;
			//fota_status.update_status[PATCH_SYSTEM -1].check_rom = WAIT;
		}

		save_fota_status();

		
		if ((status != 0) &&(status != 1))
		{

		    up_info.fota_flag[0] = 'e';
	        up_info.fota_flag[1] = 'n';
	        up_info.fota_flag[2] = 'd';
	        up_info.update_result = status;
            up_info.ota_run = 0;
            lseek(fd_update_status,0,SEEK_SET);
			write(fd_update_status, &up_info,sizeof(up_info));
			sync();
            close(fd_update_status);
			
			mtk_device_wrap_close(fd_read);
			mtk_device_wrap_close(fd_write);
	
            return status;
		}
			mtk_device_wrap_close(fd_read);
			mtk_device_wrap_close(fd_write);
		

    }
	
	
	
	

    if ((da_head.boot>0) && (up_info.ota_run <= PATCH_BOOT))
	{

        now_patch = PATCH_BOOT;
        delta_offset = DELTA_HEARD_SIZE + da_head.sys;

		
		if (up_info.ota_run == PATCH_BOOT)
		{
			ctx.first_run = 0;

		}else{
		    ctx.first_run = 1;
		}

		if(current_slot==SLOT_B) {
		    system("flash_eraseall /dev/disk/by-partlabel/boot_a");
		} else {
			system("flash_eraseall /dev/disk/by-partlabel/boot_b");
		}
		
        //if(current_slot==SLOT_B) {
	        fd_boot_a = mtk_device_wrap_open(DEV_BOOT_A,O_RDWR);
            if (fd_boot_a < 0) {
                err = errno;
                LYERRLOG("+[UA]: Error opening metadata file: %s\n",strerror(errno));
                return -err;
            }
//			fd_curr = fd_boot_a;
//		}else{
	        fd_boot_b = mtk_device_wrap_open(DEV_BOOT_B,O_RDWR);
            if (fd_boot_b < 0) {
                err = errno;
                LYERRLOG("+[UA]: Error opening metadata file: %s\n",strerror(errno));
                return -err;
            }
//			fd_curr = fd_boot_b;			
//		}


		if(current_slot==SLOT_B){
			fd_read  = fd_boot_b;
			fd_write = fd_boot_a;	
		} else {
			fd_read  = fd_boot_a;
			fd_write = fd_boot_b;
		}

		fota_status.ota_run = PATCH_BOOT;
        fota_status.update_status[PATCH_BOOT-1].check_delta = WAIT;
		fota_status.update_status[PATCH_BOOT-1].check_rom = WAIT;
		fota_status.update_status[PATCH_BOOT-1].update_result= WAIT;

		save_fota_status();

		
	    up_info.ota_run = PATCH_BOOT;
		lseek(fd_update_status,0,SEEK_SET);
	    write(fd_update_status, &up_info,sizeof(up_info));
		sync();
		
		
		
        LYVERBLOG("+[UA]: Start upgrading boot.\n");
        status = iot_patch(&ctx);
		LYVERBLOG("+[UA]: boot upgrade result:%d\n",status);
        //up_info.ota_run = 0;

        //fota_status.ota_run = 0;
		fota_status.update_status[PATCH_BOOT-1].update_result= status; 
		fota_status.update_result= status;

        if((status == 0)||(status ==1))
        {

            fota_status.update_status[PATCH_BOOT-1].check_delta = PASS;
		    fota_status.update_status[PATCH_BOOT-1].check_rom = PASS;
               
		}else if(status == E_ROCK_INVALID_DELTA) {
            fota_status.update_status[PATCH_BOOT-1].check_delta = ERROR;
		    fota_status.update_status[PATCH_BOOT-1].check_rom = WAIT;
		}else if((status == E_ROCK_DELTA_MISMATCH)||(status == E_ROCK_DELTA_CHUNK_MISMATCH)) {
            fota_status.update_status[PATCH_BOOT-1].check_delta = PASS;
		    fota_status.update_status[PATCH_BOOT-1].check_rom = ERROR;

		}else{
		
			//fota_status.update_status[PATCH_SYSTEM -1].check_delta = PASS;
			//fota_status.update_status[PATCH_SYSTEM -1].check_rom = WAIT;
		}

		save_fota_status();



		if ((status != 0) &&(status != 1))
		{

		    up_info.fota_flag[0] = 'e';
	        up_info.fota_flag[1] = 'n';
	        up_info.fota_flag[2] = 'd';
	        up_info.update_result = status;
            up_info.ota_run = 0;
            lseek(fd_update_status,0,SEEK_SET);
			write(fd_update_status, &up_info,sizeof(up_info));
			sync();
            close(fd_update_status);
			mtk_device_wrap_close(fd_read);
			mtk_device_wrap_close(fd_write);
	
            return status;
		}
			mtk_device_wrap_close(fd_read);
			mtk_device_wrap_close(fd_write);

    }
	
	
	
	

    if ((da_head.tee>0) && (up_info.ota_run <= PATCH_TEE))
	{

        now_patch = PATCH_TEE;
        delta_offset = DELTA_HEARD_SIZE + da_head.sys + da_head.boot;
 
		
		if (up_info.ota_run == PATCH_TEE) 
		{
			ctx.first_run = 0;

		}else{
		    ctx.first_run = 1;
		}


		if(current_slot==SLOT_B) {
		    system("flash_eraseall /dev/disk/by-partlabel/tee_a");
		} else {
			system("flash_eraseall /dev/disk/by-partlabel/tee_b");
		}
//        if(current_slot==SLOT_B) {
	        fd_tee_a = mtk_device_wrap_open(DEV_TEE_A,O_RDWR);
            if (fd_tee_a < 0) {
                err = errno;
                LYERRLOG("+[UA]: Error opening metadata file: %s\n",strerror(errno));
                return -err;
            }
//			fd_curr = fd_tee_a;
//		}else{
	        fd_tee_b = mtk_device_wrap_open(DEV_TEE_B,O_RDWR);
            if (fd_tee_b < 0) {
                err = errno;
                LYERRLOG("+[UA]: Error opening metadata file: %s\n",strerror(errno));
                return -err;
            }
//			fd_curr = fd_tee_b;			
//		}


		if(current_slot==SLOT_B){
			fd_read  = fd_tee_b;
			fd_write = fd_tee_a;	
		} else {
			fd_read  = fd_tee_a;
			fd_write = fd_tee_b;
		}

		fota_status.ota_run = PATCH_TEE;
        fota_status.update_status[PATCH_TEE-1].check_delta = WAIT;
		fota_status.update_status[PATCH_TEE-1].check_rom = WAIT;
		fota_status.update_status[PATCH_TEE-1].update_result= WAIT;
		
		save_fota_status();
		
		up_info.ota_run = PATCH_TEE;

		lseek(fd_update_status,0,SEEK_SET);
	    write(fd_update_status, &up_info,sizeof(up_info));
		sync();

        LYVERBLOG("+[UA]: Start upgrading tee.\n");
        status = iot_patch(&ctx);
		LYVERBLOG("+[UA]: tee upgrade result:%d\n",status);
        //up_info.ota_run = 0;
        //fota_status.ota_run = 0;
		fota_status.update_status[PATCH_TEE-1].update_result= status; 
		fota_status.update_result= status;

        if((status == 0)||(status ==1))
        {

            fota_status.update_status[PATCH_TEE-1].check_delta = PASS;
		    fota_status.update_status[PATCH_TEE-1].check_rom = PASS;
               
		}else if(status == E_ROCK_INVALID_DELTA) {
            fota_status.update_status[PATCH_TEE-1].check_delta = ERROR;
		    fota_status.update_status[PATCH_TEE-1].check_rom = WAIT;
		}else if((status == E_ROCK_DELTA_MISMATCH)||(status == E_ROCK_DELTA_CHUNK_MISMATCH)) {
            fota_status.update_status[PATCH_TEE-1].check_delta = PASS;
		    fota_status.update_status[PATCH_TEE-1].check_rom = ERROR;

		}else{
		
			//fota_status.update_status[PATCH_SYSTEM -1].check_delta = PASS;
			//fota_status.update_status[PATCH_SYSTEM -1].check_rom = WAIT;
		}

		save_fota_status();


		if ((status != 0) &&(status != 1))
		{

		    up_info.fota_flag[0] = 'e';
	        up_info.fota_flag[1] = 'n';
	        up_info.fota_flag[2] = 'd';
	        up_info.update_result = status;
            up_info.ota_run = 0;
            lseek(fd_update_status,0,SEEK_SET);
			write(fd_update_status, &up_info,sizeof(up_info));
			sync();
			close(fd_update_status);
			mtk_device_wrap_close(fd_read);
			mtk_device_wrap_close(fd_write);
            return status;
		}
		mtk_device_wrap_close(fd_read);
		mtk_device_wrap_close(fd_write);

    }
	
	
	

    if ((da_head.md1img>0) && (up_info.ota_run <= PATCH_MD1IMG))
	{

        now_patch = PATCH_MD1IMG;
        delta_offset = DELTA_HEARD_SIZE + da_head.sys + da_head.boot + da_head.tee;

		
		if (up_info.ota_run == PATCH_MD1IMG) 
		{
			ctx.first_run = 0;

		}else{
		    ctx.first_run = 1;
		}


		if(current_slot==SLOT_B) {
		    system("flash_eraseall /dev/disk/by-partlabel/md1img_a");
		} else {
			system("flash_eraseall /dev/disk/by-partlabel/md1img_b");
		}
//        if(current_slot==SLOT_B) {
	        fd_md1img_a = mtk_device_wrap_open(DEV_MD1IMG_A,O_RDWR);
            if (fd_md1img_a < 0) {
                err = errno;
                LYERRLOG("+[UA]: Error opening metadata file: %s\n",strerror(errno));
                return -err;
            }
//			fd_curr = fd_md1img_a;
//		}else{
	        fd_md1img_b = mtk_device_wrap_open(DEV_MD1IMG_B,O_RDWR);
            if (fd_md1img_b < 0) {
                err = errno;
                LYERRLOG("+[UA]: Error opening metadata file: %s\n",strerror(errno));
                return -err;
            }
//			fd_curr = fd_md1img_b;			
//		}


		if(current_slot==SLOT_B){
			fd_read  = fd_md1img_b;
			fd_write = fd_md1img_a;	
		} else {
			fd_read  = fd_md1img_a;
			fd_write = fd_md1img_b;
		}

		fota_status.ota_run = PATCH_MD1IMG;
        fota_status.update_status[PATCH_MD1IMG-1].check_delta = WAIT;
		fota_status.update_status[PATCH_MD1IMG-1].check_rom = WAIT;
		fota_status.update_status[PATCH_MD1IMG-1].update_result= WAIT;

		save_fota_status();
		
		up_info.ota_run = PATCH_MD1IMG;

		lseek(fd_update_status,0,SEEK_SET);
	    write(fd_update_status, &up_info,sizeof(up_info));
		sync();		
		

        LYVERBLOG("+[UA]: Start upgrading md1img.\n");
        status = iot_patch(&ctx);
		LYVERBLOG("+[UA]: md1img upgrade result:%d\n",status);

        //fota_status.ota_run = 0;
		fota_status.update_status[PATCH_MD1IMG-1].update_result= status; 
		fota_status.update_result= status;

        if((status == 0)||(status ==1))
        {

            fota_status.update_status[PATCH_MD1IMG-1].check_delta = PASS;
		    fota_status.update_status[PATCH_MD1IMG-1].check_rom = PASS;
               
		}else if(status == E_ROCK_INVALID_DELTA) {
            fota_status.update_status[PATCH_MD1IMG-1].check_delta = ERROR;
		    fota_status.update_status[PATCH_MD1IMG-1].check_rom = WAIT;
		}else if((status == E_ROCK_DELTA_MISMATCH)||(status == E_ROCK_DELTA_CHUNK_MISMATCH)) {
            fota_status.update_status[PATCH_MD1IMG-1].check_delta = PASS;
		    fota_status.update_status[PATCH_MD1IMG-1].check_rom = ERROR;

		}else{
		
			//fota_status.update_status[PATCH_MD1IMG -1].check_delta = PASS;
			//fota_status.update_status[PATCH_MD1IMG -1].check_rom = WAIT;
		}

		save_fota_status();


		if ((status != 0) &&(status != 1))
		{

		    up_info.fota_flag[0] = 'e';
	        up_info.fota_flag[1] = 'n';
	        up_info.fota_flag[2] = 'd';
	        up_info.update_result = status;
            up_info.ota_run = 0;
            lseek(fd_update_status,0,SEEK_SET);
			write(fd_update_status, &up_info,sizeof(up_info));
			sync();
			close(fd_update_status);
	        mtk_device_wrap_close(fd_read);
			mtk_device_wrap_close(fd_write);
            return status;
		}
        mtk_device_wrap_close(fd_read);
		mtk_device_wrap_close(fd_write);


    }
	
	
	
	
    

	if ((da_head.vbmeta>0) && (up_info.ota_run <= PATCH_VBMETA))
	{

        now_patch = PATCH_VBMETA;
        delta_offset = DELTA_HEARD_SIZE + da_head.sys + da_head.boot + da_head.tee + da_head.md1img;

		
		if (up_info.ota_run == PATCH_VBMETA) 
		{
			ctx.first_run = 0;

		}else{
		    ctx.first_run = 1;
		
		}

		if(current_slot==SLOT_B) {
		    system("flash_eraseall /dev/disk/by-partlabel/vbmeta_a");
		} else {
			system("flash_eraseall /dev/disk/by-partlabel/vbmeta_b");
		}
//		if(current_slot==SLOT_B) {
	        fd_vbmeta_a = mtk_device_wrap_open(DEV_VBMETA_A,O_RDWR);
            if (fd_vbmeta_a < 0) {
                err = errno;
                LYERRLOG("+[UA]: Error opening metadata file: %s\n",strerror(errno));
                return -err;
            }
//			fd_curr = fd_vbmeta_a;
//		}else{
	        fd_vbmeta_b = mtk_device_wrap_open(DEV_VBMETA_B,O_RDWR);
            if (fd_vbmeta_b < 0) {
                err = errno;
                LYERRLOG("+[UA]: Error opening metadata file: %s\n",strerror(errno));
                return -err;
            }
//			fd_curr = fd_vbmeta_b;			
//		}

		if(current_slot==SLOT_B){
			fd_read  = fd_vbmeta_b;
			fd_write = fd_vbmeta_a;	
		} else {
			fd_read  = fd_vbmeta_a;
			fd_write = fd_vbmeta_b;
		}
		fota_status.ota_run = PATCH_VBMETA;
        fota_status.update_status[PATCH_VBMETA-1].check_delta = WAIT;
		fota_status.update_status[PATCH_VBMETA-1].check_rom = WAIT;
		fota_status.update_status[PATCH_VBMETA-1].update_result= WAIT;

		save_fota_status();
		
		up_info.ota_run = PATCH_VBMETA;

		lseek(fd_update_status,0,SEEK_SET);
	    write(fd_update_status, &up_info,sizeof(up_info));
		sync();

        LYVERBLOG("+[UA]: Start upgrading vbmeta.\n");
        status = iot_patch(&ctx);
		LYVERBLOG("+[UA]: vbmeta upgrade result:%d\n",status);
		up_info.ota_run = 0;
		//fota_status.ota_run = 0;
		fota_status.update_status[PATCH_VBMETA-1].update_result= status; 
		fota_status.update_result= status;

        
		if((status == 0)||(status ==1))
        {
			fota_status.update_status[PATCH_VBMETA-1].check_delta = PASS;
		    fota_status.update_status[PATCH_VBMETA-1].check_rom = PASS;
               
		}else if(status == E_ROCK_INVALID_DELTA) {
            fota_status.update_status[PATCH_VBMETA-1].check_delta = ERROR;
		    fota_status.update_status[PATCH_VBMETA-1].check_rom = WAIT;
		}else if((status == E_ROCK_DELTA_MISMATCH)||(status == E_ROCK_DELTA_CHUNK_MISMATCH)) {
            fota_status.update_status[PATCH_VBMETA-1].check_delta = PASS;
		    fota_status.update_status[PATCH_VBMETA-1].check_rom = ERROR;
		}else{
		
			//fota_status.update_status[PATCH_MD1IMG -1].check_delta = PASS;
			//fota_status.update_status[PATCH_MD1IMG -1].check_rom = WAIT;
		}

		save_fota_status();
		if ((status != 0) &&(status != 1))
		{

			up_info.fota_flag[0] = 'e';
	        up_info.fota_flag[1] = 'n';
	        up_info.fota_flag[2] = 'd';
	        up_info.update_result = status;
            up_info.ota_run = 0;
            
			lseek(fd_update_status,0,SEEK_SET);
			write(fd_update_status, &up_info,sizeof(up_info));
			sync();
			close(fd_update_status);
	        mtk_device_wrap_close(fd_read);
			mtk_device_wrap_close(fd_write); 
            return status;
		}
        mtk_device_wrap_close(fd_read);
		mtk_device_wrap_close(fd_write);


    }

    if ((da_head.bl33>0) && (up_info.ota_run <= PATCH_BL33))
	{

        now_patch = PATCH_BL33;
        delta_offset = DELTA_HEARD_SIZE + da_head.sys + da_head.boot + da_head.tee + da_head.md1img + da_head.vbmeta;

		if (up_info.ota_run == PATCH_BL33) 
		{
			ctx.first_run = 0;

		}else{
		    ctx.first_run = 1;
		}

	    fd_bl33 = mtk_device_wrap_open(DEV_BL33,O_RDWR);
        if (fd_bl33 < 0) {
            err = errno;
            LYERRLOG("+[UA]: Error opening metadata file: %s\n",strerror(errno));
            return -err;
        }
	    fd_curr = fd_bl33;

		fota_status.ota_run = PATCH_BL33;
        fota_status.update_status[PATCH_BL33-1].check_delta = WAIT;
		fota_status.update_status[PATCH_BL33-1].check_rom = WAIT;
		fota_status.update_status[PATCH_BL33-1].update_result= WAIT;

		save_fota_status();
		up_info.ota_run = PATCH_BL33;

		lseek(fd_update_status,0,SEEK_SET);
	    write(fd_update_status, &up_info,sizeof(up_info));
		sync();
        LYVERBLOG("+[UA]: Start upgrading bl33.\n");
        status = iot_patch(&ctx);
		LYVERBLOG("+[UA]: bl33 upgrade result:%d\n",status);

		up_info.ota_run = 0;
        //fota_status.ota_run = 0;
		fota_status.update_status[PATCH_BL33-1].update_result= status; 
        fota_status.update_result= status;
        if((status == 0)||(status ==1))
        {

            fota_status.update_status[PATCH_BL33-1].check_delta = PASS;
		    fota_status.update_status[PATCH_BL33-1].check_rom = PASS;
               
		}else if(status == E_ROCK_INVALID_DELTA) {
            fota_status.update_status[PATCH_BL33-1].check_delta = ERROR;
		    fota_status.update_status[PATCH_BL33-1].check_rom = WAIT;
		}else if((status == E_ROCK_DELTA_MISMATCH)||(status == E_ROCK_DELTA_CHUNK_MISMATCH)) {
            fota_status.update_status[PATCH_BL33-1].check_delta = PASS;
		    fota_status.update_status[PATCH_BL33-1].check_rom = ERROR;

		}else{
		
			//fota_status.update_status[PATCH_BL33 -1].check_delta = PASS;
			//fota_status.update_status[PATCH_BL33 -1].check_rom = WAIT;
		}

		save_fota_status();		

		if ((status != 0) &&(status != 1))
		{

		    up_info.fota_flag[0] = 'e';
	        up_info.fota_flag[1] = 'n';
	        up_info.fota_flag[2] = 'd';
	        up_info.update_result = status;
            up_info.ota_run = 0;
            lseek(fd_update_status,0,SEEK_SET);
			write(fd_update_status, &up_info,sizeof(up_info));
	        mtk_device_wrap_close(fd_curr);
			sync();
			close(fd_update_status);
            return status;
		}
        mtk_device_wrap_close(fd_curr);

    }
		

    
	//if(current_slot==SLOT_B)
		
    
	
	if ((da_head.full_sys>0)|| (da_head.full_boot>0)|| (da_head.full_tee>0)||(da_head.full_md1img>0)||(da_head.full_vbmeta>0)||(da_head.full_bl33>0))
	{

	    now_patch = 0;
		up_info.ota_run = 0;
		
		memset(&fota_status,0,sizeof(fota_status));
		fota_status.switch_slot = WAIT;
		save_fota_status();
		
	    if (mtk_device_wrap_seek(fd_delta, DELTA_HEARD_SIZE + delta_size, SEEK_SET) < 0) {
            err = errno;
            LYERRLOG("+[UA]: mtk_device_wrap_seek df_delta err\n");
		    return -1;
        }
		
		mtk_device_wrap_read(fd_delta, full_header, DELTA_FULL_HEARD_SIZE);
		

	    if (memcmp(full_header, "full-ota", DELTA_FULL_HEARD_SIZE) != 0) {
	        LYERRLOG("+[UA]: invalid full delta header\r\n");
		    up_info.fota_flag[0] = 'e';
	        up_info.fota_flag[1] = 'n';
	        up_info.fota_flag[2] = 'd';
	        up_info.update_result = -1;
            up_info.ota_run = 0;
            lseek(fd_update_status,0,SEEK_SET);
			write(fd_update_status, &up_info,sizeof(up_info));
	        //mtk_device_wrap_close(fd_curr);
			sync();
			close(fd_update_status);

			for (i = FULL_SYSTEM;i<=FULL_BL33;i++){
                if (fota_status.update_status[i-1].need_update ==1) {
                    fota_status.ota_run = i;
					fota_status.update_status[i-1].check_delta = ERROR;
					fota_status.update_status[i-1].check_rom= WAIT;
					fota_status.update_status[i-1].update_result= ERROR;
				}
			}
            fota_status.update_result = ERROR;
			save_fota_status();
	        return -1;
	    }
	}
	
	

	
	
	if(da_head.full_sys>0) {
	
	    delta_offset = DELTA_HEARD_SIZE + delta_size + DELTA_FULL_HEARD_SIZE;
	    
		if(current_slot==SLOT_B) {
	        fd_system_a = mtk_device_wrap_open(DEV_SYSTEM_A,O_RDWR);
            if (fd_system_a < 0) {
                err = errno;
                LYERRLOG("+[UA]: Error opening metadata file: %s\n",strerror(errno));
                return -err;
            }
			fd_curr = fd_system_a;
		}else{
	        fd_system_b = mtk_device_wrap_open(DEV_SYSTEM_B,O_RDWR);
            if (fd_system_b < 0) {
                err = errno;
                LYERRLOG("+[UA]: Error opening metadata file: %s\n",strerror(errno));
                return -err;
            }
			fd_curr = fd_system_b;			
		}
        fota_status.ota_run = FULL_SYSTEM;
        save_fota_status();
		
		retry_cnt = 0;
		LYVERBLOG("+[UA]: Start upgrading system full.\n");
        do {
            status = delta_copyto_nand(delta_offset,da_head.full_sys);
		
	        ROCK_SHA_FILE(fd_delta,delta_offset,da_head.full_sys,digest_s);
		    ROCK_SHA_FILE(fd_curr,0,da_head.full_sys,digest_t);
		    retry_cnt++;
        }while((strncmp(digest_s,digest_t,SHA_DIGEST_SIZE)!=0)&&(retry_cnt <= 3));
		
		mtk_device_wrap_close(fd_curr);
		
		LYVERBLOG("+[UA]: system full retry_cnt = %d\n",retry_cnt);
        
		if (retry_cnt>3) {
		    if (status == 0) {
				status = retry_cnt;
			}
			if(current_slot==SLOT_B) {
			    nand_copyto_nand(DEV_SYSTEM_B,DEV_SYSTEM_A);
			}
		    else{
				nand_copyto_nand(DEV_SYSTEM_A,DEV_SYSTEM_B);
			}
		}
		
		LYVERBLOG("+[UA]: system full upgrade result:%d\n",status);

		fota_status.update_result = status;
		fota_status.update_status[FULL_SYSTEM-1].update_result = status;
		save_fota_status();

		if (status != 0)
		{

		    up_info.fota_flag[0] = 'e';
	        up_info.fota_flag[1] = 'n';
	        up_info.fota_flag[2] = 'd';
	        up_info.update_result = status;
            up_info.ota_run = 0;
            lseek(fd_update_status,0,SEEK_SET);
			write(fd_update_status, &up_info,sizeof(up_info));
			sync();
			close(fd_update_status);
            return status;
		}		
		
	
	}
	
	
	
	if(da_head.full_boot>0) {
	
	    delta_offset = DELTA_HEARD_SIZE + delta_size + DELTA_FULL_HEARD_SIZE + da_head.full_sys;
	    
		if(current_slot==SLOT_B) {
	        fd_boot_a = mtk_device_wrap_open(DEV_BOOT_A,O_RDWR);
            if (fd_boot_a < 0) {
                err = errno;
                LYERRLOG("+[UA]: Error opening metadata file: %s\n",strerror(errno));
                return -err;
            }
			fd_curr = fd_boot_a;
		}else{
	        fd_boot_b = mtk_device_wrap_open(DEV_BOOT_B,O_RDWR);
            if (fd_boot_b < 0) {
                err = errno;
                LYERRLOG("+[UA]: Error opening metadata file: %s\n",strerror(errno));
                return -err;
            }
			fd_curr = fd_boot_b;					
		}
		fota_status.ota_run = FULL_BOOT;
        save_fota_status();
        retry_cnt = 0;
		LYVERBLOG("+[UA]: Start upgrading boot full.\n");
        do {
            status = delta_copyto_nand(delta_offset,da_head.full_boot);
			ROCK_SHA_FILE(fd_delta,delta_offset,da_head.full_boot,digest_s);
		    ROCK_SHA_FILE(fd_curr,0,da_head.full_boot,digest_t);
		    retry_cnt++;	
		}while((strncmp(digest_s,digest_t,SHA_DIGEST_SIZE)!=0)&&(retry_cnt <= 3));
		
		LYVERBLOG("+[UA]: boot full retry_cnt = %d\n",retry_cnt);
		mtk_device_wrap_close(fd_curr);
		
		if (retry_cnt>3) {
		    if (status == 0) {
				status = retry_cnt;
			}
			if(current_slot==SLOT_B) {
			    nand_copyto_nand(DEV_BOOT_B,DEV_BOOT_A);
			}
		    else{
				nand_copyto_nand(DEV_BOOT_A,DEV_BOOT_B);
			}
		}
		
		
		LYVERBLOG("+[UA]: boot full upgrade result:%d\n",status);
		fota_status.update_result = status;
		fota_status.update_status[FULL_BOOT-1].update_result = status;
		save_fota_status();
		

		if (status != 0)
		{

		    up_info.fota_flag[0] = 'e';
	        up_info.fota_flag[1] = 'n';
	        up_info.fota_flag[2] = 'd';
	        up_info.update_result = status;
            up_info.ota_run = 0;
            lseek(fd_update_status,0,SEEK_SET);
			write(fd_update_status, &up_info,sizeof(up_info));
			sync();
			close(fd_update_status);
            return status;
		}			
	
	}
	
	
	if(da_head.full_tee>0) {
	
	    delta_offset = DELTA_HEARD_SIZE + delta_size + DELTA_FULL_HEARD_SIZE + da_head.full_sys + da_head.full_boot;
	    
		if(current_slot==SLOT_B) {
	        fd_tee_a = mtk_device_wrap_open(DEV_TEE_A,O_RDWR);
            if (fd_tee_a < 0) {
                err = errno;
                LYERRLOG("+[UA]: Error opening metadata file: %s\n",strerror(errno));
                return -err;
            }
			fd_curr = fd_tee_a;
		}else{
	        fd_tee_b = mtk_device_wrap_open(DEV_TEE_B,O_RDWR);
            if (fd_tee_b < 0) {
                err = errno;
                LYERRLOG("+[UA]: Error opening metadata file: %s\n",strerror(errno));
                return -err;
            }
			fd_curr = fd_tee_b;			
		}
		fota_status.ota_run = FULL_TEE;
        save_fota_status();
        retry_cnt = 0;
		LYVERBLOG("+[UA]: Start upgrading tee full.\n");
        do {
            status = delta_copyto_nand(delta_offset,da_head.full_tee);
			ROCK_SHA_FILE(fd_delta,delta_offset,da_head.full_tee,digest_s);
		    ROCK_SHA_FILE(fd_curr,0,da_head.full_tee,digest_t);
		    retry_cnt++;	
		}while((strncmp(digest_s,digest_t,SHA_DIGEST_SIZE)!=0)&&(retry_cnt <= 3));
		mtk_device_wrap_close(fd_curr);
		LYVERBLOG("+[UA]: tee full retry_cnt = %d\n",retry_cnt);		
		if (retry_cnt>3) {
		    if (status == 0) {
				status = retry_cnt;
			}
			if(current_slot==SLOT_B) {
			    nand_copyto_nand(DEV_TEE_B,DEV_TEE_A);
			}
		    else{
				nand_copyto_nand(DEV_TEE_A,DEV_TEE_B);
			}
		}
		
		printf("+[UA] tee full upgrade result:%d\n",status);
		fota_status.update_result = status;
		fota_status.update_status[FULL_TEE-1].update_result = status;
		save_fota_status();

		if (status != 0)
		{

		    up_info.fota_flag[0] = 'e';
	        up_info.fota_flag[1] = 'n';
	        up_info.fota_flag[2] = 'd';
	        up_info.update_result = status;
            up_info.ota_run = 0;
            lseek(fd_update_status,0,SEEK_SET);
			write(fd_update_status, &up_info,sizeof(up_info));
			sync();
			close(fd_update_status);
            return status;
		}		

	
	}
	

	if(da_head.full_md1img>0) {
	
	    delta_offset = DELTA_HEARD_SIZE + delta_size + DELTA_FULL_HEARD_SIZE + da_head.full_sys + da_head.full_tee;
	    
		if(current_slot==SLOT_B) {
	        fd_md1img_a = mtk_device_wrap_open(DEV_MD1IMG_A,O_RDWR);
            if (fd_md1img_a < 0) {
                err = errno;
                LYERRLOG("+[UA]: Error opening metadata file: %s\n",strerror(errno));
                return -err;
            }
			fd_curr = fd_md1img_a;
		}else{
	        fd_md1img_b = mtk_device_wrap_open(DEV_MD1IMG_B,O_RDWR);
            if (fd_md1img_b < 0) {
                err = errno;
                LYERRLOG("+[UA]: Error opening metadata file: %s\n",strerror(errno));
                return -err;
            }
			fd_curr = fd_md1img_b;			
		}
		fota_status.ota_run = FULL_MD1IMG;
        save_fota_status();
        retry_cnt = 0;
		LYVERBLOG("+[UA]: Start upgrading md1img full.\n");
        do {       
		    status = delta_copyto_nand(delta_offset,da_head.full_md1img);
			ROCK_SHA_FILE(fd_delta,delta_offset,da_head.full_md1img,digest_s);
		    ROCK_SHA_FILE(fd_curr,0,da_head.full_md1img,digest_t);
		    retry_cnt++;	
		}while((strncmp(digest_s,digest_t,SHA_DIGEST_SIZE)!=0)&&(retry_cnt <= 3));
		mtk_device_wrap_close(fd_curr);
		
		LYVERBLOG("+[UA]: md1img full retry_cnt = %d\n",retry_cnt);
		if (retry_cnt>3) {
		    if (status == 0) {
				status = retry_cnt;
			}
			if(current_slot==SLOT_B) {
			    nand_copyto_nand(DEV_MD1IMG_B,DEV_MD1IMG_A);
			}
		    else{
				nand_copyto_nand(DEV_MD1IMG_A,DEV_MD1IMG_B);
			}
		}
				
		LYVERBLOG("+[UA]: md1img upgrade result:%d\n",status);
		fota_status.update_result = status;
		fota_status.update_status[FULL_MD1IMG-1].update_result = status;
		save_fota_status();

		if (status != 0)
		{

		    up_info.fota_flag[0] = 'e';
	        up_info.fota_flag[1] = 'n';
	        up_info.fota_flag[2] = 'd';
	        up_info.update_result = status;
            up_info.ota_run = 0;
            lseek(fd_update_status,0,SEEK_SET);
			write(fd_update_status, &up_info,sizeof(up_info));
			sync();
			close(fd_update_status);
            return status;
		}
		
	
	}
		
	
	if(da_head.full_vbmeta>0) {
	
	    delta_offset = DELTA_HEARD_SIZE + delta_size + DELTA_FULL_HEARD_SIZE + da_head.full_sys + da_head.full_tee + da_head.full_md1img;
	    
		if(current_slot==SLOT_B) {
	        fd_vbmeta_a = mtk_device_wrap_open(DEV_VBMETA_A,O_RDWR);
            if (fd_vbmeta_a < 0) {
                err = errno;
                LYERRLOG("+[UA]: Error opening metadata file: %s\n",strerror(errno));
                return -err;
            }
			fd_curr = fd_vbmeta_a;
		}else{
	        fd_vbmeta_b = mtk_device_wrap_open(DEV_VBMETA_B,O_RDWR);
            if (fd_vbmeta_b < 0) {
                err = errno;
                LYERRLOG("+[UA]: Error opening metadata file: %s\n",strerror(errno));
                return -err;
            }
			fd_curr = fd_vbmeta_b;			
		}
		fota_status.ota_run = FULL_VBMETA;
        save_fota_status();
        retry_cnt = 0;
		LYVERBLOG("+[UA]: Start upgrading vbmeta full.\n");
		do {       
		    status = delta_copyto_nand(delta_offset,da_head.full_vbmeta);
			ROCK_SHA_FILE(fd_delta,delta_offset,da_head.full_vbmeta,digest_s);
		    ROCK_SHA_FILE(fd_curr,0,da_head.full_vbmeta,digest_t);
		    retry_cnt++;	
		}while((strncmp(digest_s,digest_t,SHA_DIGEST_SIZE)!=0)&&(retry_cnt <= 3));
		mtk_device_wrap_close(fd_curr);
		
		LYVERBLOG("+[UA]: vbmeta full retry_cnt = %d\n",retry_cnt);
		if (retry_cnt>3) {
		    if (status == 0) {
				status = retry_cnt;
			}
			if(current_slot==SLOT_B) {
			    nand_copyto_nand(DEV_VBMETA_B,DEV_VBMETA_A);
			}
		    else{
				nand_copyto_nand(DEV_VBMETA_A,DEV_VBMETA_B);
			}
		}
				
		LYVERBLOG("+[UA]: vbmeta upgrade result:%d\n",status);
		fota_status.update_result = status;
		fota_status.update_status[FULL_VBMETA-1].update_result = status;
		save_fota_status();

		if (status != 0)
		{

		    up_info.fota_flag[0] = 'e';
	        up_info.fota_flag[1] = 'n';
	        up_info.fota_flag[2] = 'd';
	        up_info.update_result = status;
            up_info.ota_run = 0;
            lseek(fd_update_status,0,SEEK_SET);
			write(fd_update_status, &up_info,sizeof(up_info));
			sync();
			close(fd_update_status);
            return status;
		}
		
	
	}	
	
	if(da_head.full_bl33>0) {
		
	}



    if(update_mode == MODE_NORMAL){ //need A VS B
	    if(current_slot == SLOT_A) {

	        up_info.fota_flag[0] = 'B';
	        up_info.fota_flag[1] = '-';
	        up_info.fota_flag[2] = 'A';		
		
		}else{
			
	        up_info.fota_flag[0] = 'A';
	        up_info.fota_flag[1] = '-';
	        up_info.fota_flag[2] = 'B';	
			
		}
	
	}else{
	    up_info.fota_flag[0] = 'e';
	    up_info.fota_flag[1] = 'n';
	    up_info.fota_flag[2] = 'd';		
		
	}


	up_info.update_result = status;
    up_info.ota_run = 0;
    lseek(fd_update_status,0,SEEK_SET);       
	write(fd_update_status, &up_info,sizeof(up_info));
    sync();
           
    close_dev_fd(fd_delta);

    //close_dev_fd(fd_curr);
	

	
    close(fd_update_status);
	sync();
	

	slot = (current_slot == 0) ? 1 : 0;
	
	LYVERBLOG("+[UA]: slot SLOT = %d\n\n",slot);
	
	if(update_mode==MODE_NORMAL){
	    module->setActiveBootSlot(module,slot);
		LYVERBLOG("+[UA]: upgrade is success!!!!\n");
	}

    fota_status.ota_run = 0;
	fota_status.switch_slot = PASS;
	fota_status.update_result = status;
    save_fota_status();
	
	if(update_mode==MODE_NORMAL){
	LYVERBLOG("+[UA]: reboot_device\n");
	reboot_device();
	}	
	
	return status;
}



static void rock_fail_handler() {
	
}




/* main entrpoint */
int lynq_rock_main(int first_run)  {

	int ret = 0;
    
#if 0
	
	printf("-********copy delta ***-\n");
	test_write_delta("/data/delta",DEV_DELTA);

#endif 
	
	ret = rock_update_main(0, 0, 0, 0, first_run);
	if(ret) {
		rock_fail_handler();
	}
	return ret;
}

#endif

//lt add @2021.9.23 for  deal with power down \ backup or upgrade.
int lynq_fota_func(void) 
{

 int fd;
 int first_run = 1;   
 UPDATE_INFO lynq_up_info;

 memset(&lynq_up_info, 0, sizeof(lynq_up_info));

 fd = open(FILE_UPDATE_STATE,O_RDWR | O_CREAT,0777);

 if (fd < 0) {
  return -1;
 }

 read(fd,(unsigned char *)&lynq_up_info,sizeof(lynq_up_info));
 close(fd);

 if(lynq_up_info.ota_run != 0) { 
      //Power off, call UA
	    LYVERBLOG("[+UP]: ***Power off, call UA***\n");
	   lynq_rock_main(first_run);
 }else if (((lynq_up_info.fota_flag[0]=='A')&&(lynq_up_info.fota_flag[1]=='-')&&(lynq_up_info.fota_flag[2]=='B'))||((lynq_up_info.fota_flag[0]=='B')&&(lynq_up_info.fota_flag[1]=='-')&&(lynq_up_info.fota_flag[2]=='A'))){
      //Upgrade the other side and call UA
	  LYVERBLOG("[+UP]: ***Upgrade the other side and call UA***\n");
	   lynq_rock_main(first_run);
 }
/*
 else{
      //Normal procedure before, to check the upgrade package
//	LYVERBLOG("[+UP]: ***Normal procedure before, to check the upgrade package***\n");
//	lynq_rock_main(first_run);
 }*/
 return 0;
}