/*************************************************************************
|
> File Name: update.cpp
|
> Author: jkand.huang
|
> Mail: jkand.huang@rock-chips.com
|
> Created Time: Mon 20 May 2019 09:59:19 AM CST
|
************************************************************************/
|
#include <stdlib.h>
|
#include <stdio.h>
|
#include <string.h>
|
#include "update.h"
|
#include "log.h"
|
#include "download.h"
|
#include "rkimage.h"
|
#include "flash_image.h"
|
#include "rktools.h"
|
#include "md5sum.h"
|
#include "defineHeader.h"
|
|
#include <unistd.h>
|
#include <sys/stat.h>
|
#include <fcntl.h>
|
#include <errno.h>
|
#include <libgen.h>
|
|
extern "C" {
|
#include "../mtdutils/mtdutils.h"
|
}
|
|
#define CMD4RECOVERY_FILENAME "/mnt/sdcard/cmd4recovery"
|
static char * _url = NULL;
|
static char const * _save_path = NULL;
|
static char _url_dir[128];
|
double processvalue = 0;
|
|
void RK_ota_set_url(char *url, char *savepath) {
|
LOGI("start RK_ota_url url [%s] save path [%s].\n", url, savepath);
|
if ( url == NULL ) {
|
LOGE("RK_ota_set_url : url is NULL.\n");
|
return ;
|
}
|
if (savepath == NULL) {
|
_save_path = DEFAULT_DOWNLOAD_PATH;
|
} else {
|
_save_path = savepath;
|
}
|
LOGI("save image to %s.\n", _save_path);
|
_url = url;
|
|
sprintf(_url_dir, "%s", _url);
|
dirname(_url_dir);
|
}
|
|
bool is_sdboot = false;
|
|
UPDATE_CMD update_cmd[] = {
|
{"bootloader" , false , false , 0 , 0 , 0 , "" , flash_bootloader} ,
|
{"parameter" , false , false , 0 , 0 , 0 , "" , flash_parameter} ,
|
{"uboot" , false , false , 0 , 0 , 0 , "" , flash_normal} ,
|
{"trust" , false , false , 0 , 0 , 0 , "" , flash_normal} ,
|
{"boot" , false , true , 0 , 0 , 0 , "" , flash_normal} ,
|
{"recovery" , false , false , 0 , 0 , 0 , "" , flash_normal} ,
|
{"rootfs" , false , true , 0 , 0 , 0 , "" , flash_normal} ,
|
{"oem" , false , false , 0 , 0 , 0 , "" , flash_normal} ,
|
{"uboot_a" , false , false , 0 , 0 , 0 , "" , flash_normal} ,
|
{"uboot_b" , false , false , 0 , 0 , 0 , "" , flash_normal} ,
|
{"boot_a" , false , false , 0 , 0 , 0 , "" , flash_normal} ,
|
{"boot_b" , false , false , 0 , 0 , 0 , "" , flash_normal} ,
|
{"system_a" , false , false , 0 , 0 , 0 , "" , flash_normal} ,
|
{"system_b" , false , false , 0 , 0 , 0 , "" , flash_normal} ,
|
{"misc" , false , false , 0 , 0 , 0 , "" , flash_normal} ,
|
{"userdata" , false , false , 0 , 0 , 0 , "" , flash_normal} ,
|
};
|
|
bool RK_ota_set_partition(int partition) {
|
//000000000000000000000000: 没有升级分区
|
//100000000000000000000000: 升级loader分区
|
//010000000000000000000000: 升级parameter分区
|
//001000000000000000000000: 升级uboot分区
|
//000100000000000000000000: 升级trust分区
|
//000010000000000000000000: 升级boot分区
|
//000001000000000000000000: 升级recovery分区
|
//000000100000000000000000: 升级rootfs分区
|
//000000010000000000000000: 升级oem分区
|
//000000001000000000000000: 升级uboot_a分区
|
//000000000100000000000000: 升级uboot_b分区
|
//000000000010000000000000: 升级boot_a分区
|
//000000000001000000000000: 升级boot_b分区
|
//000000000000100000000000: 升级system_a分区
|
//000000000000010000000000: 升级system_b分区
|
//000000000000001000000000: 升级misc分区，sdboot使用
|
//000000000000000100000000: 升级userdata分区
|
|
int num = sizeof(update_cmd)/sizeof(UPDATE_CMD);
|
LOGI("[%s:%d] num [%d]\n", __func__, __LINE__, num);
|
|
if (partition == -1) {
|
//设置目标分区大小
|
RKIMAGE_HDR rkimage_hdr;
|
if( analyticImage(_url, &rkimage_hdr) != 0){
|
LOGE("analyticImage error.\n");
|
return false;
|
}
|
|
for (int i = 0; i < num; i++) {
|
if ( update_cmd[i].need_update || is_sdboot) {
|
update_cmd[i].need_update = false;
|
for (int j = 0; j < rkimage_hdr.item_count; j++) {
|
if (strcmp(rkimage_hdr.item[j].name, update_cmd[i].name) == 0) {
|
LOGI("found rkimage_hdr.item[%d].name = %s.\n", j, update_cmd[i].name);
|
if (rkimage_hdr.item[j].file[50]=='H') {
|
update_cmd[i].offset = *((DWORD *)(&rkimage_hdr.item[j].file[51]));
|
update_cmd[i].offset <<= 32;
|
update_cmd[i].offset += rkimage_hdr.item[j].offset;
|
LOGI("offset more than 4G, after adjusting is %lld.\n", update_cmd[i].offset);
|
} else {
|
update_cmd[i].offset = rkimage_hdr.item[j].offset;
|
}
|
|
if (rkimage_hdr.item[j].file[55]=='H') {
|
update_cmd[i].size = *((DWORD *)(&rkimage_hdr.item[j].file[56]));
|
update_cmd[i].size <<= 32;
|
update_cmd[i].size += rkimage_hdr.item[j].size;
|
LOGI("size more than 4G, after adjusting is %lld.\n", update_cmd[i].size);
|
} else {
|
update_cmd[i].size = rkimage_hdr.item[j].size;
|
}
|
|
if (is_sdboot) {
|
update_cmd[i].flash_offset = (long long)rkimage_hdr.item[j].flash_offset * SECTOR_SIZE;
|
}
|
update_cmd[i].need_update = true;
|
continue ;
|
}
|
}
|
}
|
}
|
|
if (!is_sdboot) {
|
for ( int i=0; i<num; i++ ) {
|
if (*update_cmd[i].dest_path && (update_cmd[i].need_update == false)) {
|
|
unsigned char len = strlen(update_cmd[i].name);
|
if (update_cmd[i].name[len-2] == '_' && (update_cmd[i].name[len-1] == 'a' || update_cmd[i].name[len-1] == 'b'))
|
{
|
|
char slot_find = (update_cmd[i].name[len-1] == 'a')? 'b':'a';
|
|
update_cmd[i].name[len-1] = slot_find;
|
for (int j = 0; j < rkimage_hdr.item_count; j++) {
|
if (strcmp(rkimage_hdr.item[j].name, update_cmd[i].name) == 0) {
|
LOGI("again found rkimage_hdr.item[%d].name = %s.\n", j, update_cmd[i].name);
|
if (rkimage_hdr.item[j].file[50]=='H') {
|
update_cmd[i].offset = *((DWORD *)(&rkimage_hdr.item[j].file[51]));
|
update_cmd[i].offset <<= 32;
|
update_cmd[i].offset += rkimage_hdr.item[j].offset;
|
LOGI("offset more than 4G, after adjusting is %lld.\n", update_cmd[i].offset);
|
} else {
|
update_cmd[i].offset = rkimage_hdr.item[j].offset;
|
}
|
|
if (rkimage_hdr.item[j].file[55]=='H') {
|
update_cmd[i].size = *((DWORD *)(&rkimage_hdr.item[j].file[56]));
|
update_cmd[i].size <<= 32;
|
update_cmd[i].size += rkimage_hdr.item[j].size;
|
LOGI("size more than 4G, after adjusting is %lld.\n", update_cmd[i].size);
|
} else {
|
update_cmd[i].size = rkimage_hdr.item[j].size;
|
}
|
|
update_cmd[i].need_update = true;
|
continue ;
|
}
|
}
|
}
|
}
|
}
|
}
|
// for ( int i=0; i<num; i++ ) {
|
// printf ( "[%s:%d] update_cmd[%d].name [%s] dest path [%s] flash offset [%#llx] offset [%#llx] size [%#llx] \n",
|
// __func__, __LINE__, i, update_cmd[i].name, update_cmd[i].dest_path, update_cmd[i].flash_offset, update_cmd[i].offset, update_cmd[i].size);
|
// }
|
|
return true;
|
}
|
|
for (int i = 0; i < num; i++) {
|
// For OTA and SD update MUST read gpt from update***.img
|
if ( (partition & 0x800000 || is_sdboot || (strcmp(update_cmd[i].name, "parameter") == 0) ) ) {
|
LOGI("need update %s.\n", update_cmd[i].name);
|
update_cmd[i].need_update = true;
|
|
if (is_sdboot) {
|
memset(update_cmd[i].dest_path, 0, sizeof(update_cmd[i].dest_path)/sizeof(update_cmd[i].dest_path[0]));
|
if (strcmp(update_cmd[i].name, "parameter") == 0) {
|
sprintf(update_cmd[i].dest_path, "%s/gpt", _url_dir);
|
} else {
|
sprintf(update_cmd[i].dest_path, "%s/%s", _url_dir, update_cmd[i].name);
|
}
|
} else {
|
if (strcmp(update_cmd[i].name, "parameter") == 0) {
|
sprintf(update_cmd[i].dest_path, "/dev/block/by-name/gpt");
|
} else {
|
if (!isMtdDevice()) {
|
sprintf(update_cmd[i].dest_path, "/dev/block/by-name/%s", update_cmd[i].name);
|
} else {
|
if ( update_cmd[i].need_update && (mtd_scan_partitions() > 0) ) {
|
const MtdPartition *mtdp = mtd_find_partition_by_name(update_cmd[i].name);
|
if (mtdp) {
|
sprintf(update_cmd[i].dest_path, "/dev/mtd%d", mtdp->device_index);
|
LOGI("need update %s ,.dest_path: %s.\n", update_cmd[i].name,update_cmd[i].dest_path);
|
}
|
} else {
|
sprintf(update_cmd[i].dest_path, "/dev/block/by-name/%s", update_cmd[i].name);
|
}
|
}
|
}
|
}
|
}
|
partition = (partition << 1);
|
}
|
|
return true;
|
|
}
|
|
static int ota_recovery_cmds (long long flash_offset, const char *dest_path)
|
{
|
char data_buf[256];
|
unsigned int write_count = 0;
|
|
if (dest_path == NULL) {
|
LOGE("[%s-%d] error dest path is NULL.\n", __func__, __LINE__);
|
return -1;
|
}
|
|
LOGI("[%s:%d] parameter flash offset %#llx dest path %s\n", __func__, __LINE__, flash_offset, dest_path);
|
memset(data_buf, 0, sizeof(data_buf)/sizeof(data_buf[0]));
|
int fd = open(CMD4RECOVERY_FILENAME, O_CREAT|O_RDWR|O_SYNC|O_APPEND, 0644);
|
if (fd < 0) {
|
LOGE("[%s-%d] error opening %s.\n", __func__, __LINE__, CMD4RECOVERY_FILENAME);
|
return -1;
|
}
|
|
if (isMtdDevice()) {
|
sprintf(data_buf, "nandwrite -p /dev/mtd0 -s %#llx %s; \n", flash_offset, dest_path);
|
} else {
|
char flash_name[20];
|
getFlashPoint(flash_name);
|
|
#define DD_MALLOC_MAX_SIZE (0x100000*10) /* 10MB */
|
|
unsigned int dd_bs = 0;
|
long long dd_seek = 1;
|
|
for ( int j=DD_MALLOC_MAX_SIZE/SECTOR_SIZE; j>0 ; j-- ) {
|
dd_bs = j*SECTOR_SIZE;
|
if ( !(flash_offset % dd_bs) ) {
|
dd_seek = flash_offset / dd_bs;
|
printf ( "flash offset = [%#llx] j=%d bs=%#x seek = %#llx result = [%s]\n",
|
flash_offset , j, dd_bs, dd_seek , (dd_bs*dd_seek == flash_offset)? "YES":"NO" );
|
break;
|
} else {
|
dd_bs = 1;
|
dd_seek = flash_offset;
|
}
|
}
|
sprintf(data_buf, "dd of=%s if=%s bs=%d seek=%lld; \t###flash offset [%#10llx] \n", flash_name, dest_path, dd_bs, dd_seek, flash_offset);
|
}
|
|
write_count = strlen(data_buf);
|
|
if (write(fd, data_buf, write_count) != write_count) {
|
close(fd);
|
LOGE("[%s:%d] Write failed(%s)\n", __func__, __LINE__, strerror(errno));
|
return -2;
|
}
|
|
close(fd);
|
return 0;
|
}
|
|
void RK_ota_start(RK_upgrade_callback cb, RK_print_callback print_cb) {
|
LOGI("start RK_ota_start.\n");
|
processvalue = 95;
|
cb(NULL, RK_UPGRADE_START);
|
|
//确认升级路径
|
if (_url == NULL) {
|
LOGE("url is NULL\n");
|
cb(NULL, RK_UPGRADE_ERR);
|
return ;
|
}
|
|
// 1. 获取文件
|
int res = download_file(_url, _save_path);
|
if (res == 0) {
|
_url = (char *)_save_path;
|
} else if (res == -1) {
|
LOGE("download_file error.\n");
|
cb(NULL, RK_UPGRADE_ERR);
|
return ;
|
}
|
|
// 2. 获取文件信息
|
if (!RK_ota_set_partition(-1)) {
|
LOGE("RK_ota_set_partition failed.\n");
|
cb(NULL, RK_UPGRADE_ERR);
|
return ;
|
}
|
|
STRUCT_PARAM_ITEM param_item[20] = {0};
|
long long gpt_backup_offset = -1;
|
memset(param_item, 0, sizeof(param_item));
|
flash_register_partition_data(param_item, &gpt_backup_offset);
|
|
int is_mtd_flag = isMtdDevice();
|
|
// 3. 下载文件到分区并校验
|
int num = sizeof(update_cmd)/sizeof(UPDATE_CMD);
|
char prompt[128] = {0};
|
for (int i = 0; i < num; i++ ) {
|
if (update_cmd[i].need_update) {
|
if (update_cmd[i].cmd != NULL) {
|
LOGI("now write %s to %s.\n", update_cmd[i].name, update_cmd[i].dest_path);
|
sprintf(prompt,"[%s] upgrade start...\n", update_cmd[i].name);
|
print_cb(prompt);
|
if (!is_sdboot &&
|
( (strcmp(update_cmd[i].name, "misc") == 0) ||
|
(strcmp(update_cmd[i].name, "parameter") == 0) )) {
|
LOGI("ingore misc.\n");
|
continue;
|
}
|
// 下载固件到分区
|
printf("update_cmd.flash_offset = %lld.\n", update_cmd[i].flash_offset);
|
if (update_cmd[i].cmd(_url, (void*)(&update_cmd[i])) != 0) {
|
LOGE("update %s error.\n", update_cmd[i].dest_path);
|
sprintf(prompt,"[%s] upgrade fail\n", update_cmd[i].name);
|
print_cb(prompt);
|
cb(NULL, RK_UPGRADE_ERR);
|
return ;
|
} else {
|
sprintf(prompt, "[%s] upgraede success!\n", update_cmd[i].name);
|
print_cb(prompt);
|
}
|
if (is_sdboot) {
|
if (ota_recovery_cmds(update_cmd[i].flash_offset, update_cmd[i].dest_path)) {
|
LOGE("write recovery cmds to %s failed.\n", CMD4RECOVERY_FILENAME);
|
cb(NULL, RK_UPGRADE_ERR);
|
return ;
|
}
|
LOGI("not check in sdboot.\n");
|
continue;
|
}
|
// parameter 和loader 先不校验
|
if (strcmp(update_cmd[i].name, "parameter") == 0 || strcmp(update_cmd[i].name, "bootloader") == 0) {
|
LOGI("not check parameter and loader.\n");
|
continue;
|
}
|
// 校验分区
|
if (comparefile(update_cmd[i].dest_path, _url, update_cmd[i].flash_offset, update_cmd[i].offset, update_cmd[i].size))
|
{
|
LOGI("check %s ok.\n", update_cmd[i].dest_path);
|
} else {
|
LOGE("check %s failed.\n", update_cmd[i].dest_path);
|
cb(NULL, RK_UPGRADE_ERR);
|
return ;
|
}
|
}
|
}
|
}
|
|
/*
|
* Fix if update_xxx.img not found some A/B partition image.
|
*/
|
if (is_sdboot) {
|
for (int i = 0; i < num; i++) {
|
if ( (!update_cmd[i].need_update) || (update_cmd[i].cmd == NULL)) {
|
continue;
|
}
|
unsigned char len = strlen(update_cmd[i].name);
|
if (update_cmd[i].name[len-2] == '_' && (update_cmd[i].name[len-1] == 'a' || update_cmd[i].name[len-1] == 'b') ) {
|
char slot_find = (update_cmd[i].name[len-1] == 'a')? 'b':'a';
|
int part_need_fix = 1;
|
char part_name[32];
|
memset(part_name, 0, sizeof(part_name)/sizeof(part_name[0]));
|
memcpy(part_name, update_cmd[i].name, len);
|
part_name[len-1] = slot_find;
|
|
for (int k = 0; k < num; k++) {
|
if ( (!update_cmd[k].need_update) || (update_cmd[k].cmd == NULL)) {
|
continue;
|
}
|
if ( (strcmp(update_cmd[k].name, part_name) == 0) ) {
|
part_need_fix = 0;
|
}
|
}
|
|
if (part_need_fix) {
|
for (int j = 0; j < sizeof(param_item)/sizeof(param_item[0]); j++) {
|
if (strcmp(param_item[j].name, part_name) == 0) {
|
if (ota_recovery_cmds(param_item[j].offset * SECTOR_SIZE, update_cmd[i].dest_path)) {
|
LOGE("sdboot fix write recovery cmds to %s failed.\n", CMD4RECOVERY_FILENAME);
|
cb(NULL, RK_UPGRADE_ERR);
|
return ;
|
}
|
}
|
}
|
}
|
}
|
}
|
|
// write gpt backup
|
/*
|
* char gpt_backup_img_path[100] = {0};
|
* sprintf(gpt_backup_img_path, "%s/%s", _url_dir, GPT_BACKUP_FILE_NAME);
|
* if (ota_recovery_cmds(gpt_backup_offset, gpt_backup_img_path)) {
|
* LOGE("write gpt backup to recovery cmds failed (%s).\n", gpt_backup_img_path);
|
* cb(NULL, RK_UPGRADE_ERR);
|
* return ;
|
* }
|
*/
|
|
}
|
|
// 4. 是否设置misc
|
|
LOGI("RK_ota_start is ok!");
|
processvalue = 100;
|
cb(NULL, RK_UPGRADE_FINISHED);
|
print_cb((char *)"updateEngine upgrade OK!\n");
|
}
|
|
int RK_ota_get_progress() {
|
return processvalue;
|
}
|
|
void RK_ota_get_sw_version(char *buffer, int maxLength) {
|
getLocalVersion(buffer, maxLength);
|
}
|
|
bool RK_ota_check_version(char *url) {
|
char source_version[20] = {0};
|
char target_version[20] = {0};
|
if (!getLocalVersion(source_version, sizeof(source_version))) {
|
return false;
|
}
|
|
if (strncmp(url, "http", 4) == 0) {
|
//如果是远程文件，从远程获取版本号
|
if (!getRemoteVersion(url, target_version, sizeof(target_version))) {
|
return false;
|
}
|
} else {
|
//如果是本地文件，从固件获取版本号
|
if (!getImageVersion(url, target_version, sizeof(target_version))) {
|
return false;
|
}
|
}
|
|
LOGI("check version new:%s old:%s", target_version, source_version);
|
if (strcmp(target_version, source_version) > 0) {
|
return true;
|
}
|
return false;
|
}
|
