/* ************************************************************************************************************ * * function * * name : usb-recovery 写入misc分区对应的命令 * * parmeters : * * return : * * note : [email protected] * * ************************************************************************************************************ */ int write_usb_recovery_to_misc(void) { u32 misc_offset = 0; char misc_args[2048]; static struct bootloader_message *misc_message; int ret; memset(misc_args, 0x0, 2048); misc_message = (struct bootloader_message *)misc_args; misc_offset = sunxi_partition_get_offset_byname("misc"); if(!misc_offset) { printf("no misc partition\n"); return 0; } ret = sunxi_flash_read(misc_offset, 2048/512, misc_args); if (!ret) { printf("error: read misc partition\n"); return 0; } strcpy(misc_message->command, "usb-recovery"); sunxi_flash_write(misc_offset, 2048/512, misc_args); return 0; }
static void flash_env_relocate_spec(int workmode)
{
#if !defined(ENV_IS_EMBEDDED)
char buf[CONFIG_ENV_SIZE];
u32 start;
if((workmode & WORK_MODE_PRODUCT) && (!(workmode & WORK_MODE_UPDATE)))
{
flash_use_efex_env();
}
else
{
start = sunxi_partition_get_offset_byname(CONFIG_SUNXI_ENV_PARTITION);
if(!start){
printf("fail to find part named %s\n", CONFIG_SUNXI_ENV_PARTITION);
use_default();
return;
}
if(!sunxi_flash_read(start, CONFIG_ENV_SIZE/512, buf))
{
use_default();
return;
}
env_import(buf, 1);
}
#endif
}
DRESULT disk_write (
BYTE pdrv, /* Physical drive nmuber (0..) */
const BYTE *buff, /* Data to be written */
DWORD sector, /* Sector address (LBA) */
DWORD count /* Number of sectors to write (1..128) */
)
{
// DRESULT res;
int result;
int start_block;
#ifndef CONFIG_ALLWINNER
switch (pdrv) {
case ATA :
// translate the arguments here
result = ATA_disk_write(buff, sector, count);
// translate the reslut code here
return res;
case MMC :
// translate the arguments here
result = MMC_disk_write(buff, sector, count);
// translate the reslut code here
return res;
case USB :
// translate the arguments here
result = USB_disk_write(buff, sector, count);
// translate the reslut code here
return res;
}
return RES_PARERR;
#else
start_block = sunxi_partition_get_offset_byname(PART_NAME[pdrv]);
if (!start_block)
{
printf("[disk_write] no the partition\n");
return RES_ERROR;
}
// printf("write part %s\n", PART_NAME[pdrv]);
// result = sunxi_test_nand_write(sector+start_block,count,buff);
result = sunxi_flash_write(sector+start_block,count,(void *)buff);
if(!result){
printf("[%s] err in sector %lx count %x buff %x\n",__func__,sector,(unsigned int)count,(unsigned int)buff);
return RES_ERROR;
}
return RES_OK;
#endif
}
/*
*******************************************************************************
* __erase_part
*
* Description:
* void
*
* Parameters:
* void
*
* Return value:
* void
*
* note:
* void
*
*******************************************************************************
*/
static int __erase_part(char *name)
{
void *addr = (void *)FASTBOOT_ERASE_BUFFER;
u32 start, unerased_sectors;
u32 nblock = FASTBOOT_ERASE_BUFFER_SIZE/512;
char response[68];
start = sunxi_partition_get_offset_byname(name);
unerased_sectors = sunxi_partition_get_size_byname(name);
if((!start) || (!unerased_sectors))
{
printf("sunxi fastboot erase FAIL: partition %s does not exist\n", name);
sprintf(response, "FAILerase: partition %s does not exist", name);
__sunxi_fastboot_send_status(response, strlen(response));
return -1;
}
memset(addr, 0xff, FASTBOOT_ERASE_BUFFER_SIZE);
while(unerased_sectors >= nblock)
{
if(!sunxi_flash_write(start, nblock, addr))
{
printf("sunxi fastboot erase FAIL: failed to erase partition %s \n", name);
sprintf(response,"FAILerase: failed to erase partition %s", name);
__sunxi_fastboot_send_status(response, strlen(response));
return -1;
}
start += nblock;
unerased_sectors -= nblock;
}
if(unerased_sectors)
{
if(!sunxi_flash_write(start, unerased_sectors, addr))
{
printf("sunxi fastboot erase FAIL: failed to erase partition %s \n", name);
sprintf(response,"FAILerase: failed to erase partition %s", name);
__sunxi_fastboot_send_status(response, strlen(response));
return -1;
}
}
printf("sunxi fastboot: partition '%s' erased\n", name);
sprintf(response, "OKAY");
__sunxi_fastboot_send_status(response, strlen(response));
return 0;
}
int do_sunxi_boot_signature(cmd_tbl_t * cmdtp, int flag, int argc, char * const argv[])
{
int ret;
int m_ok = 1;
ret = signature_verify("boot");
if(!ret)
{
ret = signature_verify("system");
}
if(ret)
{
printf("signature verify failed\n");
__u32 private_start;
__u32 private_size;
__u32 erase_block_once=SIG_ERASE_BUFFER_SIZE;
char last_back[SIG_SMALL_BUFFER_SIZE];
char* private_data = NULL;
private_start = sunxi_partition_get_offset_byname("private");
private_size = sunxi_partition_get_size_byname("private") * 512;
private_data = malloc(SIG_ERASE_BUFFER_SIZE);
if(!private_data)
{
printf("not enough memory for sig erase\n");
private_data = last_back;
erase_block_once = SIG_SMALL_BUFFER_SIZE;
m_ok = 0;
}
memset(private_data,0xff,erase_block_once);
while(private_size>=erase_block_once)
{
sunxi_flash_write(private_start,erase_block_once/512,private_data);
private_start += erase_block_once/512;
private_size -= erase_block_once;
}
if(private_size)
{
sunxi_flash_write(private_start,private_size/512,private_data);
}
if(m_ok)
{
free(private_data);
}
}
return 0;
}
int sunxi_flash_read_bootlogo(u32 start, int buf, const char *part_name)
{
int ret;
u32 rblock;
u32 start_block = start;
void *addr;
addr = (void *)buf;
start_block = sunxi_partition_get_offset_byname((const char *)part_name);
rblock = sunxi_partition_get_size_byname((const char *)part_name);
ret = sunxi_flash_read(start_block, rblock, (void *)addr);
if(ret != 0) {
printf("read bootlogo partition successful,start_block=0x%x,rblock=0x%x ,ret=%d\n",start_block,rblock,ret);
}
else {
printf("read bootlogo partition fail,start_block=0x%x,rblock=0x%x ,ret=%d\n",start_block,rblock,ret);
}
return ret;
}
static int flash_saveenv(void)
{
env_t env_new;
ssize_t len;
char *res;
u32 start;
start = sunxi_partition_get_offset_byname(CONFIG_SUNXI_ENV_PARTITION);
if(!start){
printf("fail to find part named %s\n", CONFIG_SUNXI_ENV_PARTITION);
return -1;
}
res = (char *)&env_new.data;
len = hexport_r(&env_htab, '\0', &res, ENV_SIZE);
if (len < 0) {
error("Cannot export environment: errno = %d\n", errno);
return 1;
}
env_new.crc = crc32(0, env_new.data, ENV_SIZE);
return sunxi_flash_write(start, env_size/512, &env_new);
}
/*
************************************************************************************************************
*
* function
*
* name :
*
* parmeters :
*
* return :
*
* note :
*
*
************************************************************************************************************
*/
int check_android_misc(void)
{
int mode;
int pmu_value;
u32 misc_offset = 0;
char misc_args[2048];
char misc_fill[2048];
char boot_commond[128];
static struct bootloader_message *misc_message;
if(uboot_spare_head.boot_data.work_mode != WORK_MODE_BOOT)
{
return 0;
}
if(gd->force_shell)
{
char delaytime[8];
sprintf(delaytime, "%d", 3);
setenv("bootdelay", delaytime);
}
//if enter debug mode,set loglevel = 8
check_debug_mode();
memset(boot_commond, 0x0, 128);
strcpy(boot_commond, getenv("bootcmd"));
printf("base bootcmd=%s\n", boot_commond);
//判断存储介质
if((uboot_spare_head.boot_data.storage_type == 1) || (uboot_spare_head.boot_data.storage_type == 2))
{
sunxi_str_replace(boot_commond, "setargs_nand", "setargs_mmc");
printf("bootcmd set setargs_mmc\n");
}
else
{
printf("bootcmd set setargs_nand\n");
}
misc_message = (struct bootloader_message *)misc_args;
memset(misc_args, 0x0, 2048);
memset(misc_fill, 0xff, 2048);
mode = detect_other_boot_mode();
if(mode == ANDROID_NULL_MODE)
{
pmu_value = axp_probe_pre_sys_mode();
if(pmu_value == PMU_PRE_FASTBOOT_MODE)
{
puts("PMU : ready to enter fastboot mode\n");
strcpy(misc_message->command, "bootloader");
}
else if(pmu_value == PMU_PRE_RECOVERY_MODE)
{
puts("PMU : ready to enter recovery mode\n");
strcpy(misc_message->command, "boot-recovery");
}
else
{
misc_offset = sunxi_partition_get_offset_byname("misc");
debug("misc_offset = %x\n",misc_offset);
if(!misc_offset)
{
printf("no misc partition is found\n");
}
else
{
printf("misc partition found\n");
sunxi_flash_read(misc_offset, 2048/512, misc_args); //read misc partition data
}
}
}
else if(mode == ANDROID_RECOVERY_MODE)
{
strcpy(misc_message->command, "boot-recovery");
}
else if( mode == ANDROID_FASTBOOT_MODE)
{
strcpy(misc_message->command, "bootloader");
}
//最终统一判断命令
if(!loglel_change_flag) //add by young,if you want to enter debug_mode ,so do enter boot_normal
{
if(!strcmp(misc_message->command, "efex"))
{
/* there is a recovery command */
puts("find efex cmd\n");
sunxi_flash_write(misc_offset, 2048/512, misc_fill);
sunxi_board_run_fel();
return 0;
}
if(!strcmp(misc_message->command, "boot-resignature"))
{
puts("find boot-resignature cmd\n");
sunxi_flash_write(misc_offset, 2048/512, misc_fill);
sunxi_oem_op_lock(SUNXI_LOCKING, NULL, 1);
}
else if(!strcmp(misc_message->command, "boot-recovery"))
{
if(!strcmp(misc_message->recovery, "sysrecovery"))
{
puts("recovery detected, will sprite recovery\n");
strncpy(boot_commond, "sprite_recovery", sizeof("sprite_recovery"));
sunxi_flash_write(misc_offset, 2048/512, misc_fill);
}
else
{
puts("Recovery detected, will boot recovery\n");
sunxi_str_replace(boot_commond, "boot_normal", "boot_recovery");
}
/* android recovery will clean the misc */
}
else if(!strcmp(misc_message->command, "bootloader"))
{
puts("Fastboot detected, will boot fastboot\n");
sunxi_str_replace(boot_commond, "boot_normal", "boot_fastboot");
if(misc_offset)
sunxi_flash_write(misc_offset, 2048/512, misc_fill);
}
else if(!strcmp(misc_message->command, "usb-recovery"))
{
puts("Recovery detected, will usb recovery\n");
sunxi_str_replace(boot_commond, "boot_normal", "boot_recovery");
}
}
if(!strcmp(misc_message->command ,"debug_mode"))
{
puts("debug_mode detected ,will enter debug_mode");
if(!change_to_debug_mode())
{
check_debug_mode();
}
sunxi_flash_write(misc_offset,2048/512,misc_fill);
}
setenv("bootcmd", boot_commond);
printf("to be run cmd=%s\n", boot_commond);
return 0;
}
DRESULT disk_read_fs (
BYTE pdrv, /* Physical drive nmuber (0..) */
BYTE *buff, /* Data buffer to store read data */
DWORD sector, /* Sector address (LBA) */
DWORD count /* Number of sectors to read (1..128) */
)
{
#ifndef CONFIG_ALLWINNER
DRESULT res;
#endif
int result;
unsigned int start_block;
#ifndef CONFIG_ALLWINNER
switch (pdrv) {
case ATA :
// translate the arguments here
result = ATA_disk_read(buff, sector, count);
// translate the reslut code here
return res;
case MMC :
// translate the arguments here
result = MMC_disk_read(buff, sector, count);
// translate the reslut code here
return res;
case USB :
// translate the arguments here
result = USB_disk_read(buff, sector, count);
// translate the reslut code here
return res;
}
return RES_PARERR;
#else
// result = sunxi_test_mmc_read(sector+0x12000, count, buff);
start_block = sunxi_partition_get_offset_byname(PART_NAME[pdrv]);
if (!start_block)
{
printf("[disk_read_fs] no the partition\n");
return RES_ERROR;
}
// printf("read part %s\n", PART_NAME[pdrv]);
// result = sunxi_test_nand_read((unsigned int)(sector+start_block),(unsigned int)count,buff);
result = sunxi_flash_read(sector+start_block,count, buff);
if(!result)
{
printf("read all error: start=%lx, addr=0x%x count=0x%x\n", sector, (unsigned int)buff,(unsigned int)count);
return 1;
}
return RES_OK;
#endif
}
int sunxi_keydata_burn_by_usb(void)
{
char buffer[512];
#ifdef CONFIG_SUNXI_SECURE_STORAGE
#ifndef SUNXI_SECURESTORAGE_TEST_ERASE
int data_len;
#endif
#endif
int ret;
uint burn_private_start, burn_private_len;
int workmode = uboot_spare_head.boot_data.work_mode;
int if_need_burn_key=0;
ret = script_parser_fetch("target", "burn_key", &if_need_burn_key, 1);
if((ret) || (if_need_burn_key != 1))
{
return 0;
}
if(workmode != WORK_MODE_BOOT) //非启动模式，不执行
{
puts("out of usb burn from boot: not boot mode\n");
return 0;
}
if(gd->vbus_status == SUNXI_VBUS_NOT_EXIST) //vbus不存在，不执行
{
puts("out of usb burn from boot: without usb\n");
return 0;
}
if(gd->power_step_level == BATTERY_RATIO_TOO_LOW_WITH_DCIN)
{
puts("out of usb burn from boot: not enough energy\n");
return 0;
}
memset(buffer, 0, 512);
#ifdef CONFIG_SUNXI_SECURE_STORAGE
if(sunxi_secure_storage_init())
#endif
{
printf("sunxi secure storage is not supported\n");
burn_private_start = sunxi_partition_get_offset_byname("private");
burn_private_len = sunxi_partition_get_size_byname("private");
if(!burn_private_start)
{
printf("private partition is not exist\n");
return -1;
}
else
{
ret = sunxi_flash_read(burn_private_start + burn_private_len - (8192+512)/512, 1, buffer);
if(ret != 1)
{
printf("cant read private part\n");
return -1;
}
if(!strcmp(buffer, "key_burned"))
{
printf("find key burned flag\n");
return 0;
}
}
}
#ifdef CONFIG_SUNXI_SECURE_STORAGE
else
{
#ifndef SUNXI_SECURESTORAGE_TEST_ERASE
ret = sunxi_secure_storage_read("key_burned_flag", buffer, 512, &data_len);
if(ret)
{
printf("sunxi secure storage has no flag\n");
}
else
{
if(!strcmp(buffer, "key_burned"))
{
printf("wrn: data has clean\n");
return 0;
}
}
#else
if(!sunxi_secure_storage_erase_data_only("key_burned_flag"))
sunxi_secure_storage_exit();
return 0;
#endif
}
#endif
return do_burn_from_boot(NULL, 0, 0, NULL);
}
int android_misc_flash_check(void) {
u32 misc_offset = 0;
char buffer[2048];
misc_offset = (u32)sunxi_partition_get_offset_byname("misc");
if(misc_offset == (u32)(-1))
{
puts("no misc partition is found\n");
return 0;
}
memset(buffer, 0, 2048);
#ifdef DEBUG
printf("misc_offset : %x\n", (int )misc_offset);
#endif
sunxi_flash_read(misc_offset, 2048/512, buffer);
memcpy(&misc_message, buffer, sizeof(misc_message));
#ifdef DEBUG
// printf("misc.command : %s\n", misc_message.command);
// printf("misc.status : %s\n", misc_message.status);
// printf("misc.recovery : %s\n", misc_message.recovery);
#endif
if(storage_type)
{
if(!strcmp(misc_message.command, "boot-recovery")) {
/* there is a recovery command */
puts("find boot recovery\n");
setenv("bootcmd", "run setargs_mmc boot_recovery");
puts("Recovery detected, will boot recovery\n");
/* android recovery will clean the misc */
}
else{
printf("bootcmd set setargs_mmc\n");
setenv("bootcmd", "run setargs_mmc boot_normal");
}
if(!strcmp(misc_message.command, "boot-fastboot")) {
/* there is a fastboot command */
setenv("bootcmd", "run setargs_mmc boot_fastboot");
puts("Fastboot detected, will enter fastboot\n");
/* clean the misc partition ourself */
memset(buffer, 0, 2048);
sunxi_flash_write(misc_offset, 2048/512, buffer);
}
}
else
{
if(!strcmp(misc_message.command, "boot-recovery")) {
/* there is a recovery command */
puts("find boot recovery\n");
setenv("bootcmd", "run setargs_nand boot_recovery");
puts("Recovery detected, will boot recovery\n");
/* android recovery will clean the misc */
}
else
if (!strcmp(misc_message.command, "usb-recovery")) {
/* there is a recovery command */
puts("find usb recovery\n");
setenv("bootcmd", "run setargs_nand boot_recovery");
puts("Recovery detected, will usb recovery\n");
/* android recovery will clean the misc */
}
else{
printf("bootcmd set setargs_nand\n");
setenv("bootcmd", "run setargs_nand boot_normal");
}
if(!strcmp(misc_message.command, "boot-fastboot")) {
/* there is a fastboot command */
setenv("bootcmd", "run setargs_nand boot_fastboot");
puts("Fastboot detected, will enter fastboot\n");
/* clean the misc partition ourself */
memset(buffer, 0, 2048);
sunxi_flash_write(misc_offset, 2048/512, buffer);
}
}
return 0;
}
/*
*******************************************************************************
* __flash_to_part
*
* Description:
* void
*
* Parameters:
* void
*
* Return value:
* void
*
* note:
* void
*
*******************************************************************************
*/
static int __flash_to_part(char *name)
{
char *addr = trans_data.base_recv_buffer;
u32 start, data_sectors;
u32 part_sectors;
u32 nblock = FASTBOOT_TRANSFER_BUFFER_SIZE/512;
char response[68];
start = sunxi_partition_get_offset_byname(name);
part_sectors = sunxi_partition_get_size_byname(name);
if((!start) || (!part_sectors))
{
uint addr_in_hex;
int ret;
printf("sunxi fastboot download FAIL: partition %s does not exist\n", name);
printf("probe it as a dram address\n");
ret = strict_strtoul((const char *)name, 16, (long unsigned int*)&addr_in_hex);
if(ret)
{
printf("sunxi fatboot download FAIL: it is not a dram address\n");
sprintf(response, "FAILdownload: partition %s does not exist", name);
__sunxi_fastboot_send_status(response, strlen(response));
return -1;
}
else
{
printf("ready to move data to 0x%x, bytes 0x%x\n", addr_in_hex, trans_data.try_to_recv);
memcpy((void *)addr_in_hex, addr, trans_data.try_to_recv);
}
}
else
{
int format;
printf("ready to download bytes 0x%x\n", trans_data.try_to_recv);
format = unsparse_probe(addr, trans_data.try_to_recv, start);
if(ANDROID_FORMAT_DETECT == format)
{
if(unsparse_direct_write(addr, trans_data.try_to_recv))
{
printf("sunxi fastboot download FAIL: failed to write partition %s \n", name);
sprintf(response,"FAILdownload: write partition %s err", name);
return -1;
}
}
else
{
data_sectors = (trans_data.try_to_recv + 511)/512;
if(data_sectors > part_sectors)
{
printf("sunxi fastboot download FAIL: partition %s size 0x%x is smaller than data size 0x%x\n", name, trans_data.act_recv, data_sectors * 512);
sprintf(response, "FAILdownload: partition size < data size");
__sunxi_fastboot_send_status(response, strlen(response));
return -1;
}
while(data_sectors >= nblock)
{
if(!sunxi_flash_write(start, nblock, addr))
{
printf("sunxi fastboot download FAIL: failed to write partition %s \n", name);
sprintf(response,"FAILdownload: write partition %s err", name);
__sunxi_fastboot_send_status(response, strlen(response));
return -1;
}
start += nblock;
data_sectors -= nblock;
addr += FASTBOOT_TRANSFER_BUFFER_SIZE;
}
if(data_sectors)
{
if(!sunxi_flash_write(start, data_sectors, addr))
{
printf("sunxi fastboot download FAIL: failed to write partition %s \n", name);
sprintf(response,"FAILdownload: write partition %s err", name);
__sunxi_fastboot_send_status(response, strlen(response));
return -1;
}
}
}
}
printf("sunxi fastboot: successed in downloading partition '%s'\n", name);
sprintf(response, "OKAY");
__sunxi_fastboot_send_status(response, strlen(response));
return 0;
}
int mmc_get_env_addr(struct mmc *mmc, u32 *env_addr) {
*env_addr = sunxi_partition_get_offset_byname(CONFIG_SUNXI_ENV_PARTITION);
return 0;
}
/*
************************************************************************************************************
*
* function
*
* name :
*
* parmeters :
*
* return :
*
* note :
*
*
************************************************************************************************************
*/
static int sunxi_pburn_state_loop(void *buffer)
{
static struct umass_bbb_cbw_t *cbw;
static struct umass_bbb_csw_t csw;
static uint pburn_flash_start = 0;
//static uint pburn_flash_sectors = 0;
int ret;
sunxi_ubuf_t *sunxi_ubuf = (sunxi_ubuf_t *)buffer;
switch(sunxi_usb_pburn_status)
{
case SUNXI_USB_PBURN_IDLE:
if(sunxi_ubuf->rx_ready_for_data == 1)
{
sunxi_usb_pburn_status = SUNXI_USB_PBURN_SETUP;
}
break;
case SUNXI_USB_PBURN_SETUP:
sunxi_usb_dbg("SUNXI_USB_PBURN_SETUP\n");
if(sunxi_ubuf->rx_req_length != sizeof(struct umass_bbb_cbw_t))
{
printf("sunxi usb error: received bytes 0x%x is not equal cbw struct size 0x%zx\n", sunxi_ubuf->rx_req_length, sizeof(struct umass_bbb_cbw_t));
sunxi_ubuf->rx_ready_for_data = 0;
sunxi_usb_pburn_status = SUNXI_USB_PBURN_IDLE;
break;
}
cbw = (struct umass_bbb_cbw_t *)sunxi_ubuf->rx_req_buffer;
if(CBWSIGNATURE != cbw->dCBWSignature)
{
printf("sunxi usb error: the cbw signature 0x%x is bad, need 0x%x\n", cbw->dCBWSignature, CBWSIGNATURE);
sunxi_ubuf->rx_ready_for_data = 0;
sunxi_usb_pburn_status = SUNXI_USB_PBURN_IDLE;
break;
}
csw.dCSWSignature = CSWSIGNATURE;
csw.dCSWTag = cbw->dCBWTag;
#if defined(SUNXI_USB_30)
sunxi_usb_pburn_status_enable = 1;
#endif
sunxi_usb_dbg("usb cbw command = 0x%x\n", cbw->CBWCDB[0]);
switch(cbw->CBWCDB[0])
{
#ifdef CONFIG_SUNXI_SECURE_STORAGE
case 0xf0: //自定义命令，用于烧录用户数据
sunxi_usb_dbg("usb burn secure storage data\n");
printf("usb command = %d\n", cbw->CBWCDB[1]);
switch(cbw->CBWCDB[1])
{
case 0: //握手
{
__usb_handshake_sec_t *handshake = (__usb_handshake_sec_t *)trans_data.base_send_buffer;
memset(handshake, 0, sizeof(__usb_handshake_sec_t));
strcpy(handshake->magic, "usb_burn_handshake");
sunxi_usb_pburn_status = SUNXI_USB_PBURN_SEND_DATA;
trans_data.act_send_buffer = trans_data.base_send_buffer;
trans_data.send_size = min(cbw->dCBWDataTransferLength, sizeof(__usb_handshake_sec_t));
sunxi_usb_burn_from_boot_setup = 1;
private_data_ext_buff = (u8 *)malloc(4 * 1024 * 1024);
if(private_data_ext_buff == NULL)
{
printf("there is no memorfy to store all user key data\n");
csw.bCSWStatus = -1;
}
else
{
csw.bCSWStatus = 0;
sunxi_usb_burn_from_boot_handshake = 1;
}
private_data_ext_buff_step = private_data_ext_buff;
}
break;
case 1: //小机端接收数据
{
trans_data.recv_size = cbw->dCBWDataTransferLength;
sunxi_usb_pburn_write_enable = 0;
sunxi_udc_start_recv_by_dma(private_data_ext_buff_step, trans_data.recv_size); //start dma to receive data
printf("recv_size=%d\n", trans_data.recv_size);
sunxi_dump(private_data_ext_buff, trans_data.recv_size);
sunxi_usb_pburn_status = SUNXI_USB_PBURN_RECEIVE_NULL;
}
break;
case 2: //工具端声明数据传输已经完毕，要求获取烧录状态
{
__usb_handshake_ext_t *handshake = (__usb_handshake_ext_t *)trans_data.base_send_buffer;
memset(handshake, 0, sizeof(__usb_handshake_ext_t));
//strcpy(handshake->magic, "usb_burn_receive_data_all");
sunxi_usb_pburn_status = SUNXI_USB_PBURN_SEND_DATA;
printf("recv_size=%d\n", trans_data.recv_size);
sunxi_dump(private_data_ext_buff, trans_data.recv_size);
int ret = __sunxi_burn_key(private_data_ext_buff, trans_data.recv_size);
trans_data.act_send_buffer = trans_data.base_send_buffer;
trans_data.send_size = min(cbw->dCBWDataTransferLength, sizeof(__usb_handshake_ext_t));
//开始根据数据类型进行烧录动作
if(!ret) //数据烧写成功
{
strcpy(handshake->magic, "usb_burn_success");
csw.bCSWStatus = 0;
}
else //数据烧写失败
{
strcpy(handshake->magic, "usb_burn_error");
csw.bCSWStatus = -1;
}
if(private_data_ext_buff)
{
free(private_data_ext_buff);
}
}
break;
// case 3: //小机端读取每个key
// {
// uint start, sectors;
// uint offset;
//
// start = *(int *)(cbw->CBWCDB + 4); //读数据的偏移量
// sectors = *(int *)(cbw->CBWCDB + 8); //扇区数;
//
// trans_data.send_size = min(cbw->dCBWDataTransferLength, sectors * 512);
// trans_data.act_send_buffer = (uint)trans_data.base_send_buffer;
//
// offset = burn_private_start;
// ret = sunxi_flash_read(start + offset, sectors, trans_data.base_send_buffer);
// if(!ret)
// {
// printf("sunxi flash read err: start,0x%x sectors 0x%x\n", start, sectors);
//
// csw.bCSWStatus = 1;
// }
// else
// {
// csw.bCSWStatus = 0;
// }
//
// sunxi_usb_pburn_status = SUNXI_USB_PBURN_SEND_DATA;
// }
// break;
case 4: //关闭usb
{
__usb_handshake_ext_t *handshake = (__usb_handshake_ext_t *)trans_data.base_send_buffer;
memset(handshake, 0, sizeof(__usb_handshake_ext_t));
strcpy(handshake->magic, "usb_burn_finish");
trans_data.act_send_buffer = trans_data.base_send_buffer;
trans_data.send_size = min(cbw->dCBWDataTransferLength, sizeof(__usb_handshake_ext_t));
sunxi_udc_send_data((void *)trans_data.act_send_buffer, trans_data.send_size);
csw.bCSWStatus = 0;
sunxi_usb_pburn_status = SUNXI_USB_PBURN_EXIT;
}
break;
case 5:
{
__usb_handshake_ext_t *handshake = (__usb_handshake_ext_t *)trans_data.base_send_buffer;
memset(handshake, 0, sizeof(__usb_handshake_ext_t));
strcpy(handshake->magic, "usb_burn_saved");
trans_data.act_send_buffer = trans_data.base_send_buffer;
trans_data.send_size = min(cbw->dCBWDataTransferLength, sizeof(__usb_handshake_ext_t));
csw.bCSWStatus = 0;
sunxi_usb_pburn_status = SUNXI_USB_PBURN_SEND_DATA;
if(sunxi_secure_storage_write("key_burned_flag", "key_burned", strlen("key_burned")))
{
printf("save burned flag err\n");
csw.bCSWStatus = -1;
}
sunxi_secure_storage_exit();
}
break;
default:
break;
}
break;
#endif
case 0xf3: //自定义命令，用于烧录用户数据
sunxi_usb_dbg("usb burn private\n");
printf("usb command = %d\n", cbw->CBWCDB[1]);
switch(cbw->CBWCDB[1])
{
case 0: //握手
{
__usb_handshake_t *handshake = (__usb_handshake_t *)trans_data.base_send_buffer;
burn_private_start = sunxi_partition_get_offset_byname("private");
burn_private_len = sunxi_partition_get_size_byname("private");
if(!burn_private_start)
{
printf("private partition is not exist\n");
csw.bCSWStatus = -1;
}
else
{
csw.bCSWStatus = 0;
}
memset(handshake, 0, sizeof(__usb_handshake_t));
strcpy(handshake->magic, "usb_burn_handshake");
handshake->sizelo = burn_private_len;
handshake->sizehi = 0;
sunxi_usb_pburn_status = SUNXI_USB_PBURN_SEND_DATA;
sunxi_usb_burn_from_boot_setup = 1;
sunxi_usb_burn_from_boot_handshake = 1;
trans_data.act_send_buffer = trans_data.base_send_buffer;
trans_data.send_size = min(cbw->dCBWDataTransferLength, sizeof(__usb_handshake_t));
}
break;
case 1: //小机端接收数据
{
//pburn_flash_sectors = *(int *)(cbw->CBWCDB + 8);
//pburn_flash_start = *(int *)(cbw->CBWCDB + 4);
memcpy(&pburn_flash_start,(cbw->CBWCDB + 4),4);
trans_data.recv_size = cbw->dCBWDataTransferLength;
trans_data.act_recv_buffer = trans_data.base_recv_buffer;
pburn_flash_start += burn_private_start;
sunxi_usb_pburn_write_enable = 0;
sunxi_udc_start_recv_by_dma(trans_data.act_recv_buffer, trans_data.recv_size); //start dma to receive data
sunxi_usb_pburn_status = SUNXI_USB_PBURN_RECEIVE_DATA;
}
break;
case 3: //小机端发送数据
{
uint start, sectors;
//start = *(int *)(cbw->CBWCDB + 4); //读数据的偏移量
//sectors = *(int *)(cbw->CBWCDB + 8); //扇区数;
memcpy(&start,(cbw->CBWCDB + 4),4);
memcpy(§ors,(cbw->CBWCDB + 8),4);
printf("start=%d, sectors=%d\n", start, sectors);
trans_data.send_size = min(cbw->dCBWDataTransferLength, sectors * 512);
trans_data.act_send_buffer = trans_data.base_send_buffer;
printf("send size=%d\n", trans_data.send_size);
ret = sunxi_flash_read(start + burn_private_start, sectors, trans_data.base_send_buffer);
if(!ret)
{
printf("sunxi flash read err: start,0x%x sectors 0x%x\n", start, sectors);
csw.bCSWStatus = 1;
}
else
{
csw.bCSWStatus = 0;
}
sunxi_usb_pburn_status = SUNXI_USB_PBURN_SEND_DATA;
}
break;
case 4: //关闭usb
{
__usb_handshake_ext_t *handshake = (__usb_handshake_ext_t *)trans_data.base_send_buffer;
memset(handshake, 0, sizeof(__usb_handshake_ext_t));
strcpy(handshake->magic, "usb_burn_finish");
trans_data.act_send_buffer = trans_data.base_send_buffer;
trans_data.send_size = min(cbw->dCBWDataTransferLength, sizeof(__usb_handshake_ext_t));
sunxi_udc_send_data((void *)trans_data.act_send_buffer, trans_data.send_size);
csw.bCSWStatus = 0;
sunxi_flash_flush();
sunxi_usb_pburn_status = SUNXI_USB_PBURN_EXIT;
}
break;
case 5:
{
__usb_handshake_ext_t *handshake = (__usb_handshake_ext_t *)trans_data.base_send_buffer;
char buffer[512];
memset(handshake, 0, sizeof(__usb_handshake_ext_t));
strcpy(handshake->magic, "usb_burn_saved");
trans_data.act_send_buffer = trans_data.base_send_buffer;
trans_data.send_size = min(cbw->dCBWDataTransferLength, sizeof(__usb_handshake_ext_t));
csw.bCSWStatus = 0;
sunxi_usb_pburn_status = SUNXI_USB_PBURN_SEND_DATA;
memset(buffer, 0, 512);
strcpy(buffer, "key_burned");
if(!sunxi_flash_write(burn_private_start + burn_private_len - (8192+512)/512, 1, buffer))
{
printf("save burned flag err\n");
csw.bCSWStatus = -1;
}
sunxi_flash_flush();
#ifdef CONFIG_SUNXI_SECURE_STORAGE
if(sunxi_secure_storage_init())
{
printf("init secure storage failed\n");
csw.bCSWStatus = -1;
}
else
{
if(sunxi_secure_storage_write("key_burned_flag", "key_burned", strlen("key_burned")))
{
printf("save burned flag err\n");
csw.bCSWStatus = -1;
}
}
sunxi_secure_storage_exit();
#endif
}
break;
default:
break;
}
break;
default:
sunxi_usb_dbg("not supported command 0x%x now\n", cbw->CBWCDB[0]);
sunxi_usb_dbg("asked size 0x%x\n", cbw->dCBWDataTransferLength);
csw.bCSWStatus = 1;
sunxi_usb_pburn_status = SUNXI_USB_PBURN_STATUS;
break;
}
break;
case SUNXI_USB_PBURN_SEND_DATA:
sunxi_usb_dbg("SUNXI_USB_SEND_DATA\n");
sunxi_usb_pburn_status = SUNXI_USB_PBURN_STATUS;
printf("SUNXI_USB_SEND_DATA=%d\n", trans_data.send_size);
sunxi_udc_send_data((void *)trans_data.act_send_buffer, trans_data.send_size);
#if defined(SUNXI_USB_30)
sunxi_usb_pburn_status_enable = 0;
#endif
break;
case SUNXI_USB_PBURN_RECEIVE_DATA:
sunxi_usb_dbg("SUNXI_USB_RECEIVE_DATA\n");
if(sunxi_usb_pburn_write_enable == 1)
{
sunxi_usb_dbg("write flash, start 0x%x, sectors 0x%x\n", pburn_flash_start, trans_data.recv_size/512);
ret = sunxi_flash_write(pburn_flash_start, (trans_data.recv_size+511)/512, (void *)trans_data.act_recv_buffer);
if(!ret)
{
printf("sunxi flash write err: start,0x%x sectors 0x%x\n", pburn_flash_start, (trans_data.recv_size+511)/512);
csw.bCSWStatus = 1;
}
else
{
csw.bCSWStatus = 0;
}
sunxi_usb_pburn_write_enable = 0;
sunxi_usb_pburn_status = SUNXI_USB_PBURN_STATUS;
}
break;
case SUNXI_USB_PBURN_STATUS:
sunxi_usb_dbg("SUNXI_USB_PBURN_STATUS\n");
#if defined(SUNXI_USB_30)
if(sunxi_usb_pburn_status_enable)
#endif
{
sunxi_usb_pburn_status = SUNXI_USB_PBURN_IDLE;
sunxi_ubuf->rx_ready_for_data = 0;
__sunxi_pburn_send_status(&csw, sizeof(struct umass_bbb_csw_t));
}
break;
case SUNXI_USB_PBURN_EXIT:
printf("SUNXI_USB_PBURN_EXIT\n");
sunxi_usb_pburn_status = SUNXI_USB_PBURN_IDLE;
sunxi_ubuf->rx_ready_for_data = 0;
__sunxi_pburn_send_status(&csw, sizeof(struct umass_bbb_csw_t));
printf("Device will shutdown in 3 Secends...\n");
__msdelay(3000);
return SUNXI_UPDATE_NEXT_ACTION_SHUTDOWN;
case SUNXI_USB_PBURN_RECEIVE_NULL:
sunxi_usb_dbg("SUNXI_USB_PBURN_RECEIVE_NULL\n");
if(sunxi_usb_pburn_write_enable == 1)
{
csw.bCSWStatus = 0;
sunxi_usb_pburn_write_enable = 0;
sunxi_usb_pburn_status = SUNXI_USB_PBURN_STATUS;
}
break;
default:
break;
}
return 0;
}
/*
************************************************************************************************************
*
* function
*
* name :
*
* parmeters :
*
* return :
*
* note :
*
*
************************************************************************************************************
*/
int check_android_misc(void)
{
int mode;
u32 misc_offset = 0;
char misc_args[2048];
char misc_fill[2048];
char boot_commond[128];
static struct bootloader_message *misc_message;
if(uboot_spare_head.boot_data.work_mode != WORK_MODE_BOOT)
{
return 0;
}
if(gd->force_shell)
{
char delaytime[8];
sprintf(delaytime, "%d", 3);
setenv("bootdelay", delaytime);
}
memset(boot_commond, 0x0, 128);
set_boot_type_cmd(boot_commond);
printf("base bootcmd=%s\n", boot_commond);
//判断存储介质
if((uboot_spare_head.boot_data.storage_type == 1) || (uboot_spare_head.boot_data.storage_type == 2))
{
sunxi_str_replace(boot_commond, "setargs_nand", "setargs_mmc");
printf("bootcmd set setargs_mmc\n");
}
else
{
printf("bootcmd set setargs_nand\n");
}
//判断是否存在按键进入其它模式
memset(misc_args, 0x0, 2048);
mode = detect_other_boot_mode();
misc_message = (struct bootloader_message *)misc_args;
if(mode == ANDROID_NULL_MODE)
{
misc_offset = sunxi_partition_get_offset_byname("misc");
if(!misc_offset)
{
int pmu_value;
puts("no misc partition is found\n");
pmu_value = axp_probe_pre_sys_mode();
if(pmu_value == PMU_PRE_FASTBOOT_MODE)
{
puts("ready to enter fastboot mode\n");
setenv("bootcmd", "run boot_fastboot");
return 0;
}
else
{
printf("to be run cmd=%s\n", boot_commond);
setenv("bootcmd", boot_commond);
return 0;
}
}
memset(misc_fill, 0xff, 2048);
#ifdef DEBUG
tick_printf("misc_offset : %d\n", (int )misc_offset);
#endif
sunxi_flash_read(misc_offset, 2048/512, misc_args);
}
else if(mode == ANDROID_RECOVERY_MODE)
{
strcpy(misc_message->command, "boot-recovery");
}
else if(mode == ANDROID_FASTBOOT_MODE)
{
strcpy(misc_message->command, "bootloader");
}
#ifdef DEBUG
{
uint *dump_value;
dump_value = *(uint *)misc_message->command;
if(dump_value != 0xffffffff)
printf("misc.command : %s\n", misc_message->command);
else
printf("misc.command : NULL\n");
dump_value = *(uint *)misc_message->status;
if(dump_value != 0xffffffff)
printf("misc.status : %s\n", misc_message->status);
else
printf("misc.status : NULL\n");
dump_value = *(uint *)misc_message->recovery;
if(dump_value != 0xffffffff)
printf("misc.recovery : %s\n", misc_message->recovery);
else
printf("misc.recovery : NULL\n");
}
#endif
//判断命令
if(!strcmp(misc_message->command, "efex"))
{
/* there is a recovery command */
puts("find efex cmd\n");
sunxi_flash_write(misc_offset, 2048/512, misc_fill);
sunxi_board_run_fel();
return 0;
}
if(!strcmp(misc_message->command, "boot-resignature"))
{
puts("find boot-resignature cmd\n");
sunxi_flash_write(misc_offset, 2048/512, misc_fill);
sunxi_oem_op_lock(SUNXI_LOCKING, NULL, 1);
}
else if(!strcmp(misc_message->command, "boot-recovery"))
{
puts("Recovery detected, will boot recovery\n");
sunxi_str_replace(boot_commond, "boot_normal", "boot_recovery");
/* android recovery will clean the misc */
}
else if(!strcmp(misc_message->command, "bootloader"))
{
puts("Fastboot detected, will boot fastboot\n");
sunxi_str_replace(boot_commond, "boot_normal", "boot_fastboot");
if(misc_offset)
sunxi_flash_write(misc_offset, 2048/512, misc_fill);
}
setenv("bootcmd", boot_commond);
printf("to be run cmd=%s\n", boot_commond);
return 0;
}
static int signature_verify(const char *part_name)
{
unsigned int tmp_start;
unsigned int summary1, summary2;
unsigned int s_value[4], h_value[4];
unsigned char buffer[HASH_BUFFER_BYTES];
unsigned int read_bytes;
memset(buffer, 0, HASH_BUFFER_BYTES);
//计算hash值
prepareCryptTable(); //准备hash表
//获取签名
printf("ras init\n");
rsa_init();
printf("ras start\n");
if(!strcmp("boot", part_name))
{
tmp_start = sunxi_partition_get_offset_byname(part_name);
printf("find part %s\n", part_name);
read_bytes = sizeof(struct fastboot_boot_img_hdr);
if(!sunxi_flash_read(tmp_start, (read_bytes + 511)/512, buffer))
{
printf("signature0 read flash sig1 err\n");
return -1;
}
summary1 = HashString(buffer, 1, read_bytes); //1类hash
read_bytes = sizeof(struct image_header);
if(!sunxi_flash_read(tmp_start + CFG_FASTBOOT_MKBOOTIMAGE_PAGE_SIZE/512, (read_bytes + 511)/512, buffer))
{
printf("signature0 read flash sig2 err\n");
return -1;
}
summary1 = HashString(buffer, 1, read_bytes); //1类hash
//获取保存的签名
if(!sunxi_flash_read(tmp_start, 2, buffer))
{
printf("signature0 read flash sig3 err\n");
return -1;
}
s_value[0] = *(unsigned int *)(buffer + 608);
s_value[1] = *(unsigned int *)(buffer + 612);
s_value[2] = *(unsigned int *)(buffer + 616);
s_value[3] = *(unsigned int *)(buffer + 620);
rsa_decrypt( s_value, 4, h_value );
summary2 = (h_value[0]<<0) | (h_value[1]<<8) | (h_value[2]<<16) | (h_value[3]<<24);
#if 0
for(j=0;j<4;j++)
{
printf("s_value[%d] = %x\n", j, s_value[j]);
}
for(j=0;j<4;j++)
{
printf("h_value[%d] = %x\n", j, h_value[j]);
}
#endif
printf("summary by hash %x\n", summary1);
printf("summary by rsa %x\n", summary2);
if(summary1 != summary2)
{
printf("boot signature invalid\n");
return -1;
}
}
else if(!strcmp("system", part_name))
{
struct ext4_super_block *sblock;
tmp_start = sunxi_partition_get_offset_byname(part_name);
printf("find part %s\n", part_name);
printf("find system part\n");
HashString_init();
read_bytes = sizeof(struct ext4_super_block);
if(!sunxi_flash_read(tmp_start + CFG_SUPER_BLOCK_SECTOR, (read_bytes + 511)/512, buffer))
{
printf("signature1 read flash sig1 err\n");
return -1;
}
sblock = (struct ext4_super_block *)buffer;
#if 0
{
int k;
printf("s_inodes_count = %x\n", sblock->s_inodes_count);
printf("s_blocks_count_lo = %x\n", sblock->s_blocks_count_lo);
printf("s_r_blocks_count_lo = %x\n", sblock->s_r_blocks_count_lo);
printf("s_free_blocks_count_lo= %x\n", sblock->s_free_blocks_count_lo);
printf("s_free_inodes_count = %x\n", sblock->s_free_inodes_count);
printf("s_first_data_block = %x\n", sblock->s_first_data_block);
printf("s_log_block_size = %x\n", sblock->s_log_block_size);
printf("s_log_cluster_size = %x\n", sblock->s_log_cluster_size);
printf("s_blocks_per_group = %x\n", sblock->s_blocks_per_group);
printf("s_clusters_per_group = %x\n", sblock->s_clusters_per_group);
printf("s_inodes_per_group = %x\n", sblock->s_inodes_per_group);
printf("s_mtime = %x\n", sblock->s_mtime);
printf("s_wtime = %x\n", sblock->s_wtime);
printf("s_mnt_count = %x\n", sblock->s_mnt_count);
printf("s_max_mnt_count = %x\n", sblock->s_max_mnt_count);
printf("s_magic = %x\n", sblock->s_magic);
printf("s_state = %x\n", sblock->s_state);
printf("s_errors = %x\n", sblock->s_errors);
printf("s_minor_rev_level = %x\n", sblock->s_minor_rev_level);
printf("s_lastcheck = %x\n", sblock->s_lastcheck);
printf("s_checkinterval = %x\n", sblock->s_checkinterval);
printf("s_creator_os = %x\n", sblock->s_creator_os);
printf("s_rev_level = %x\n", sblock->s_rev_level);
printf("s_def_resuid = %x\n", sblock->s_def_resuid);
printf("s_def_resgid = %x\n", sblock->s_def_resgid);
printf("s_first_ino = %x\n", sblock->s_first_ino);
printf("s_inode_size = %x\n", sblock->s_inode_size);
printf("s_block_group_nr = %x\n", sblock->s_block_group_nr);
printf("s_feature_compat = %x\n", sblock->s_feature_compat);
printf("s_feature_incompat = %x\n", sblock->s_feature_incompat);
printf("s_feature_ro_compat = %x\n", sblock->s_feature_ro_compat);
for(k=0;k<16;k++)
{
printf("s_uuid[%d] = %x\n", k, sblock->s_uuid[k]);
}
for(k=0;k<16;k++)
{
printf("s_volume_name[%d] = %x\n", k, sblock->s_volume_name[k]);
}
for(k=0;k<64;k++)
{
printf("s_last_mounted[%d]= %x\n", k, sblock->s_last_mounted[k]);
}
printf("s_algorithm_usage_bitmap= %x\n", sblock->s_algorithm_usage_bitmap);
printf("s_prealloc_blocks = %x\n", sblock->s_prealloc_blocks);
printf("s_prealloc_dir_blocks = %x\n", sblock->s_prealloc_dir_blocks);
printf("s_reserved_gdt_blocks = %x\n", sblock->s_reserved_gdt_blocks);
for(k=0;k<16;k++)
{
printf("s_journal_uuid[%d]= %x\n", k, sblock->s_journal_uuid[k]);
}
printf("s_journal_inum = %x\n", sblock->s_journal_inum);
printf("s_journal_dev = %x\n", sblock->s_journal_dev);
printf("s_last_orphan = %x\n", sblock->s_last_orphan);
for(k=0;k<16;k++)
{
printf("s_hash_seed[%d] = %x\n", k, sblock->s_hash_seed[k]);
}
printf("s_def_hash_version = %x\n", sblock->s_def_hash_version);
printf("s_jnl_backup_type = %x\n", sblock->s_jnl_backup_type);
printf("s_desc_size = %x\n", sblock->s_desc_size);
printf("s_default_mount_opts = %x\n", sblock->s_default_mount_opts);
printf("s_first_meta_bg = %x\n", sblock->s_first_meta_bg);
printf("s_mkfs_time = %x\n", sblock->s_mkfs_time);
for(k=0;k<17;k++)
{
printf("s_jnl_blocks[%d] = %x\n", k, sblock->s_jnl_blocks[k]);
}
printf("s_blocks_count_hi = %x\n", sblock->s_blocks_count_hi);
printf("s_r_blocks_count_hi = %x\n", sblock->s_r_blocks_count_hi);
printf("s_free_blocks_count_hi= %x\n", sblock->s_free_blocks_count_hi);
printf("s_min_extra_isize = %x\n", sblock->s_min_extra_isize);
printf("s_want_extra_isize = %x\n", sblock->s_want_extra_isize);
printf("s_flags = %x\n", sblock->s_flags);
printf("s_raid_stride = %x\n", sblock->s_raid_stride);
printf("s_mmp_update_interval = %x\n", sblock->s_mmp_update_interval);
printf("s_mmp_block = %x\n", sblock->s_mmp_block);
printf("s_raid_stripe_width = %x\n", sblock->s_raid_stripe_width);
printf("s_log_groups_per_flex = %x\n", sblock->s_log_groups_per_flex);
printf("s_reserved_char_pad = %x\n", sblock->s_reserved_char_pad);
printf("s_reserved_pad = %x\n", sblock->s_reserved_pad);
printf("s_kbytes_written = %x\n", sblock->s_kbytes_written);
printf("s_snapshot_inum = %x\n", sblock->s_snapshot_inum);
printf("s_snapshot_id = %x\n", sblock->s_snapshot_id);
printf("s_snapshot_r_blocks_count= %x\n", sblock->s_snapshot_r_blocks_count);
printf("s_snapshot_list = %x\n", sblock->s_snapshot_list);
}
#endif
sblock->s_mtime = CFG_SUPER_BLOCK_STAMP_VALUE;
sblock->s_mnt_count = CFG_SUPER_BLOCK_STAMP_VALUE & 0xffff;
memset(sblock->s_last_mounted, 0, 64);
summary1 = HashString(buffer, 1, (unsigned int)&(((struct ext4_super_block *)0)->s_snapshot_list)); //1类hash
//获取保存的签名
if(!sunxi_flash_read(tmp_start, 2, buffer))
{
printf("signature1 read flash sig3 err\n");
return -1;
}
s_value[0] = *(unsigned int *)(buffer + 1000 - 10 * 4 + 0);
s_value[1] = *(unsigned int *)(buffer + 1000 - 10 * 4 + 4);
s_value[2] = *(unsigned int *)(buffer + 1000 - 10 * 4 + 8);
s_value[3] = *(unsigned int *)(buffer + 1000 - 10 * 4 + 12);
rsa_decrypt( s_value, 4, h_value );
summary2 = (h_value[0]<<0) | (h_value[1]<<8) | (h_value[2]<<16) | (h_value[3]<<24);
#if 0
for(j=0;j<4;j++)
{
printf("s_value[%d] = %x\n", j, s_value[j]);
}
for(j=0;j<4;j++)
{
printf("h_value[%d] = %x\n", j, h_value[j]);
}
#endif
printf("summary by hash %x\n", summary1);
printf("summary by rsa %x\n", summary2);
if(summary1 != summary2)
{
printf("system signature invalid\n");
return -1;
}
}
return 0;
}
int check_android_misc(void)
{
int mode;
int pmu_value;
u32 misc_offset = 0;
char misc_args[2048];
char misc_fill[2048];
char boot_commond[128];
static struct bootloader_message *misc_message;
if(uboot_spare_head.boot_data.work_mode != WORK_MODE_BOOT)
{
return 0;
}
if(gd->force_shell)
{
char delaytime[8];
sprintf(delaytime, "%d", 3);
setenv("bootdelay", delaytime);
}
//if enter debug mode,set loglevel = 8
check_debug_mode();
memset(boot_commond, 0x0, 128);
strcpy(boot_commond, getenv("bootcmd"));
printf("base bootcmd=%s\n", boot_commond);
//判断存储介质
if((uboot_spare_head.boot_data.storage_type == 1) || (uboot_spare_head.boot_data.storage_type == 2))
{
sunxi_str_replace(boot_commond, "setargs_nand", "setargs_mmc");
printf("bootcmd set setargs_mmc\n");
}
else
{
printf("bootcmd set setargs_nand\n");
}
//判断是否存在按键进入其它模式
misc_message = (struct bootloader_message *)misc_args;
memset(misc_args, 0x0, 2048);
memset(misc_fill, 0xff, 2048);
mode = detect_other_boot_mode();
misc_offset = sunxi_partition_get_offset_byname("misc");
//先判断上一次系统是否有写入数据到pmu寄存器
pmu_value = axp_probe_pre_sys_mode();
if(pmu_value == PMU_PRE_FASTBOOT_MODE)
{
puts("PMU : ready to enter fastboot mode\n");
strcpy(misc_message->command, "bootloader");
}
else if(pmu_value == PMU_PRE_RECOVERY_MODE)
{
puts("PMU : ready to enter recovery mode\n");
strcpy(misc_message->command, "boot-recovery");
}
//get the part --"misc"
else
{
debug("misc_offset = %x\n",misc_offset);
if(!misc_offset)
{
printf("no misc partition is found\n");
}
else
{
printf("misc partition found\n");
sunxi_flash_read(misc_offset, 2048/512, misc_args); //read misc partition data
}
}
if((misc_message->command[0] == 0x00) ||(misc_message->command[0] == 0xff))
{
printf("misc_message->command = %x \n",misc_message->command[0]);
if(mode == USER_SELECT_MODE) //说明探测阶段有按键按下
{
printf("enter user_select_mode\n");
#if 0
//如果misc分区没有上次系统写入数据，并且检测到有按键按下，那么进入图片显示菜单
user_select_current_status = FASTBOOT_MODE;
show_user_select_menu_ui(); //显示当前模式的ui
while(status != POWERON_KEY_PRESSED)//图片显示菜单
{
status = sunxi_probe_key_pressed();
if(( status == KEY_PRESSED))
{
debug("key_ststus = 0x%x\n ",status);
user_mode_status_update(status); //更新菜单的选项
show_user_select_menu_ui(); //显示当前模式的ui
}
}
if(user_select_current_status == RECOVERY_MODE )
{
printf("misc_message->command = boot-recovery\n");
strcpy(misc_message->command, "boot-recovery");
}
else if(user_select_current_status == FASTBOOT_MODE)
{
printf("misc_message->command = bootloader\n");
strcpy(misc_message->command, "bootloader");
}
#endif
}
else if(mode == ANDROID_RECOVERY_MODE)
{
strcpy(misc_message->command, "boot-recovery");
}
else if( mode == ANDROID_FASTBOOT_MODE)
{
strcpy(misc_message->command, "bootloader");
}
}
//最终统一判断命令
if(!loglel_change_flag) //add by young,if you want to enter debug_mode ,so do enter boot_normal
{
if(!strcmp(misc_message->command, "efex"))
{
/* there is a recovery command */
puts("find efex cmd\n");
sunxi_flash_write(misc_offset, 2048/512, misc_fill);
sunxi_board_run_fel();
return 0;
}
if(!strcmp(misc_message->command, "boot-resignature"))
{
puts("find boot-resignature cmd\n");
sunxi_flash_write(misc_offset, 2048/512, misc_fill);
sunxi_oem_op_lock(SUNXI_LOCKING, NULL, 1);
}
else if(!strcmp(misc_message->command, "boot-recovery"))
{
puts("Recovery detected, will boot recovery\n");
sunxi_str_replace(boot_commond, "boot_normal", "boot_recovery");
/* android recovery will clean the misc */
}
else if(!strcmp(misc_message->command, "bootloader"))
{
puts("Fastboot detected, will boot fastboot\n");
sunxi_str_replace(boot_commond, "boot_normal", "boot_fastboot");
if(misc_offset)
sunxi_flash_write(misc_offset, 2048/512, misc_fill);
}
else if(!strcmp(misc_message->command, "usb-recovery"))
{
puts("Recovery detected, will usb recovery\n");
sunxi_str_replace(boot_commond, "boot_normal", "boot_recovery");
}
}
if(!strcmp(misc_message->command ,"debug_mode"))
{
puts("debug_mode detected ,will enter debug_mode");
if(!change_to_debug_mode())
{
check_debug_mode();
}
sunxi_flash_write(misc_offset,2048/512,misc_fill);
}
setenv("bootcmd", boot_commond);
printf("to be run cmd=%s\n", boot_commond);
#if 0
misc_message = (struct bootloader_message *)misc_args;
if(mode == ANDROID_NULL_MODE)
{
misc_offset = sunxi_partition_get_offset_byname("misc");
if(!misc_offset)
{
int pmu_value;
puts("no misc partition is found\n");
pmu_value = axp_probe_pre_sys_mode();
if(pmu_value == PMU_PRE_FASTBOOT_MODE)
{
puts("ready to enter fastboot mode\n");
setenv("bootcmd", "run boot_fastboot");
return 0;
}
else
{
printf("to be run cmd=%s\n", boot_commond);
setenv("bootcmd", boot_commond);
return 0;
}
}
memset(misc_fill, 0xff, 2048);
#ifdef DEBUG
tick_printf("misc_offset : %d\n", (int )misc_offset);
#endif
sunxi_flash_read(misc_offset, 2048/512, misc_args);
}
else if(mode == ANDROID_RECOVERY_MODE)
{
strcpy(misc_message->command, "boot-recovery");
}
else if(mode == ANDROID_FASTBOOT_MODE)
{
strcpy(misc_message->command, "bootloader");
}
#ifdef DEBUG
{
uint *dump_value;
dump_value = *(uint *)misc_message->command;
if(dump_value != 0xffffffff)
printf("misc.command : %s\n", misc_message->command);
else
printf("misc.command : NULL\n");
dump_value = *(uint *)misc_message->status;
if(dump_value != 0xffffffff)
printf("misc.status : %s\n", misc_message->status);
else
printf("misc.status : NULL\n");
dump_value = *(uint *)misc_message->recovery;
if(dump_value != 0xffffffff)
printf("misc.recovery : %s\n", misc_message->recovery);
else
printf("misc.recovery : NULL\n");
}
#endif
//判断命令
if(!strcmp(misc_message->command, "efex"))
{
/* there is a recovery command */
puts("find efex cmd\n");
sunxi_flash_write(misc_offset, 2048/512, misc_fill);
sunxi_board_run_fel();
return 0;
}
if(!strcmp(misc_message->command, "boot-resignature"))
{
puts("find boot-resignature cmd\n");
sunxi_flash_write(misc_offset, 2048/512, misc_fill);
sunxi_oem_op_lock(SUNXI_LOCKING, NULL, 1);
}
else if(!strcmp(misc_message->command, "boot-recovery"))
{
puts("Recovery detected, will boot recovery\n");
sunxi_str_replace(boot_commond, "boot_normal", "boot_recovery");
/* android recovery will clean the misc */
}
else if(!strcmp(misc_message->command, "bootloader"))
{
puts("Fastboot detected, will boot fastboot\n");
sunxi_str_replace(boot_commond, "boot_normal", "boot_fastboot");
if(misc_offset)
sunxi_flash_write(misc_offset, 2048/512, misc_fill);
}
setenv("bootcmd", boot_commond);
printf("to be run cmd=%s\n", boot_commond);
#endif
return 0;
}
