307 lines
7.1 KiB
C
307 lines
7.1 KiB
C
/*
|
|
* nvt_eburner.c
|
|
*
|
|
* Author: Alvin lin
|
|
* Created: Mar 21, 2016
|
|
* Copyright: Novatek Inc.
|
|
*
|
|
*/
|
|
#include <common.h>
|
|
#include <config.h>
|
|
#include <fdt_support.h>
|
|
#include <asm/types.h>
|
|
#include <asm/arch/hardware.h>
|
|
#include <nvt_eburner.h>
|
|
#include <nvt_emmc_xbootdat.h>
|
|
#include <nvt_emmc_partition.h>
|
|
#include <nvt_emmc_utils.h>
|
|
#include <nvt_common_utils.h>
|
|
#include <nvt_panel_init.h>
|
|
#include <nvt_tzone.h>
|
|
|
|
|
|
#if defined(CONFIG_NVTTK_EBURNER_V2)
|
|
|
|
static panel_param_blk panel_cfgs[PANEL_PARM_NUM+1];
|
|
|
|
int nvt_eburner_load_img(void* dest_addr, char* img_name, char* update_img_fname)
|
|
{
|
|
int ret = 0;
|
|
char cmd[512] = {0};
|
|
unsigned long long offset = 0;
|
|
unsigned int align_shift = 0;
|
|
unsigned long long flen;
|
|
unsigned long long tmp_len;
|
|
nvt_eburner_whole_img_hdr *pwhdr;
|
|
nvt_eburner_per_img_hdr *pphdr;
|
|
|
|
//read whole image header
|
|
sprintf(cmd, "fatload usb 0:auto 0x%x %s 0x%x",
|
|
CONFIG_SYS_FWUPDATE_BUF, update_img_fname, sizeof(nvt_eburner_whole_img_hdr));
|
|
ret = run_command(cmd, 0);
|
|
|
|
if(ret < 0) {
|
|
printf("%s read whole image header fail !\n", __func__);
|
|
goto out;
|
|
}
|
|
|
|
//do little sanity check
|
|
pwhdr = (nvt_eburner_whole_img_hdr*)CONFIG_SYS_FWUPDATE_BUF;
|
|
if(memcmp(pwhdr->sign, NVT_EBURNER_WHOLE_IMG_HDR_SIGN, strlen(NVT_EBURNER_WHOLE_IMG_HDR_SIGN))) {
|
|
printf("%s invalid firmware image !\n", __func__);
|
|
ret = -1;
|
|
goto out;
|
|
}
|
|
|
|
offset += sizeof(nvt_eburner_whole_img_hdr);
|
|
|
|
//find specified image
|
|
do {
|
|
memset(cmd, 0, sizeof(cmd));
|
|
memset((void*)CONFIG_SYS_FWUPDATE_BUF, 0, sizeof(nvt_eburner_per_img_hdr));
|
|
|
|
//load pimg hdr
|
|
sprintf(cmd, "fatload usb 0:auto 0x%x %s 0x%x 0x%llx",
|
|
CONFIG_SYS_FWUPDATE_BUF, update_img_fname, sizeof(nvt_eburner_per_img_hdr), offset);
|
|
ret = run_command(cmd, 0);
|
|
|
|
if(ret < 0){
|
|
printf("%s read per image fail !\n", __func__);
|
|
goto out;
|
|
}
|
|
|
|
pphdr = (nvt_eburner_per_img_hdr*)CONFIG_SYS_FWUPDATE_BUF;
|
|
|
|
//do little sanity check
|
|
if(memcmp(pphdr->sign, NVT_EBURNER_PER_IMG_HDR_SIGN, strlen(NVT_EBURNER_PER_IMG_HDR_SIGN))) {
|
|
printf("%s invalid per image header !\n", __func__);
|
|
ret = -1;
|
|
goto out;
|
|
}
|
|
|
|
if(strcmp(pphdr->img_name, img_name)) {
|
|
offset += sizeof(nvt_eburner_per_img_hdr);
|
|
offset += pphdr->flen;
|
|
continue;
|
|
} else {
|
|
//load image to user buffer
|
|
memset(cmd, 0, sizeof(cmd));
|
|
offset += sizeof(nvt_eburner_per_img_hdr);
|
|
align_shift = offset & (ARCH_DMA_MINALIGN - 1);
|
|
tmp_len = pphdr->flen;
|
|
sprintf(cmd, "fatload usb 0:auto 0x%x %s 0x%llx 0x%llx",
|
|
CONFIG_SYS_FWUPDATE_BUF,
|
|
update_img_fname,
|
|
tmp_len + align_shift,
|
|
offset - align_shift);
|
|
ret = run_command(cmd, 0);
|
|
if(ret < 0) {
|
|
printf("%s read fdt fail !\n", __func__);
|
|
goto out;
|
|
}
|
|
memcpy(dest_addr,
|
|
(const void*)(CONFIG_SYS_FWUPDATE_BUF + align_shift),
|
|
tmp_len);
|
|
break;
|
|
}
|
|
} while (1);
|
|
|
|
out:
|
|
return ret;
|
|
|
|
}
|
|
|
|
int nvt_eburner_prepare_boot_cmd(void)
|
|
{
|
|
char cmd[512] = {0};
|
|
char buf[255] = {0};
|
|
int ret = 0,len;
|
|
unsigned char *ker_load_addr = 0;
|
|
unsigned char *ramdisk_load_addr = 0;
|
|
int block_cnt = 0;
|
|
struct boot_address addr;
|
|
int cpus;
|
|
|
|
memset(buf, 0, sizeof(buf));
|
|
|
|
if(NULL != env_get("console"))
|
|
sprintf(cmd, "console=%s,115200 ", env_get("console"));
|
|
else
|
|
sprintf(cmd, "%s ", "console=ttyS0,115200");
|
|
|
|
if (env_get("memstr") != NULL)
|
|
sprintf(buf,"%s ",env_get("memstr"));
|
|
else
|
|
sprintf(buf,"%s ","mem=512M");
|
|
|
|
strcat(cmd,buf);
|
|
|
|
if(env_get("usb") != NULL){
|
|
sprintf(buf,"root=%s rw ",env_get("usb"));
|
|
env_set("ramdisk_loadaddr", NULL);
|
|
}else {
|
|
sprintf(buf,"%s ","root=/dev/ram0 rw ");
|
|
}
|
|
|
|
|
|
strcat(buf,"rootfstype=ext4 ");
|
|
strcat(cmd,buf);
|
|
|
|
if(env_get_yesno("quiet"))
|
|
strcat(cmd,"quiet ");
|
|
|
|
env_set("no_secos", "y");
|
|
|
|
if(env_get("cpus") != NULL) {
|
|
cpus = simple_strtoul(env_get("cpus"),NULL,10);
|
|
if(cpus > 4 || cpus < 1)
|
|
cpus = 4;
|
|
} else {
|
|
cpus = 4;
|
|
}
|
|
sprintf(buf, "maxcpus=%d ",cpus);
|
|
strcat(cmd,buf);
|
|
|
|
if(env_get("kparam_addon") != NULL) {
|
|
sprintf(buf," %s ", env_get("kparam_addon"));
|
|
strcat(cmd, buf);
|
|
}
|
|
|
|
|
|
ker_load_addr = (unsigned char*)simple_strtoul(env_get("kernel_loadaddr"),NULL,16);
|
|
|
|
|
|
if(env_get("ramdisk_loadaddr") != NULL)
|
|
ramdisk_load_addr = (unsigned char*)simple_strtoul(env_get("ramdisk_loadaddr"),NULL,16);
|
|
else
|
|
ramdisk_load_addr = 0;
|
|
|
|
addr.kernel_addr = ker_load_addr;
|
|
addr.ramdisk_addr = ramdisk_load_addr;
|
|
|
|
env_set("bootargs",cmd);
|
|
|
|
return ret;
|
|
}
|
|
|
|
int __attribute__((weak)) nvt_eburner_panel_param_init(int *pindex, panel_param_blk *pparam)
|
|
{
|
|
int ret = 0;
|
|
int index;
|
|
panel_index_blk *ppidx;
|
|
|
|
if(pindex == NULL || pparam == NULL) {
|
|
printf("%s index or param buffer invalid !\n", __func__);
|
|
goto out;
|
|
}
|
|
|
|
ret = nvt_eburner_load_img(panel_cfgs, "xbootdat", NVT_EBURNER_IMG_FNAME);
|
|
|
|
if(ret < 0) {
|
|
printf("%s load panel config fail !\n", __func__);
|
|
goto out;
|
|
}
|
|
|
|
memcpy(pparam, panel_cfgs, sizeof(panel_index_blk));
|
|
ppidx = (panel_index_blk*)pparam;
|
|
index = ppidx->idx.index;
|
|
|
|
memcpy(pparam, (panel_cfgs + index + 1), sizeof(panel_param_blk));
|
|
|
|
out:
|
|
return ret;
|
|
}
|
|
|
|
int nvt_eburner_run_updater(void)
|
|
{
|
|
char cmd[512] = {0};
|
|
unsigned int fdt_high = 0;
|
|
int len;
|
|
int ret = 0;
|
|
panel_index_blk pidx;
|
|
panel_param_blk pparm;
|
|
nvt_emmc_image_info *pimg;
|
|
unsigned long *dtb_magic;
|
|
image_header_t *phdr;
|
|
unsigned int fdt_size;
|
|
|
|
#if defined(CONFIG_NVTTK_EBURNER_V2_PACK_EBURNER)
|
|
unsigned int kernel_loadaddr = simple_strtoul(env_get("kernel_loadaddr"), NULL, 16);
|
|
ret = nvt_eburner_load_img((void*)kernel_loadaddr, "eburner", NVT_EBURNER_IMG_FNAME);
|
|
if(ret < 0) {
|
|
printf("%s load eburner fail !\n", __func__);
|
|
ret = -1;
|
|
goto out;
|
|
}
|
|
#else
|
|
sprintf(cmd, "fatload usb 0:auto %s nvttk_eburner", env_get("kernel_loadaddr"));
|
|
run_command(cmd, 0);
|
|
#endif
|
|
fdt_high = simple_strtoul(env_get("kernel_loadaddr"),NULL,16) + 0x40 + 0x2000000;
|
|
|
|
memset(cmd, 0, sizeof(cmd));
|
|
sprintf(cmd, "0x%x", fdt_high);
|
|
env_set("fdt_high", cmd);
|
|
|
|
env_set("no_secos", "y");
|
|
|
|
//load fdt from image to buffer
|
|
ret = nvt_eburner_load_img((void*)fdt_high, "fdt0", NVT_EBURNER_IMG_FNAME);
|
|
if(ret < 0) {
|
|
printf("%s load fdt from firmware fail, load from device instead !\n", __func__);
|
|
|
|
pimg = nvt_emmc_get_img_by_name("fdt0");
|
|
if(pimg == NULL) {
|
|
printf("%s get fdt0 from device fail !\n", __func__);
|
|
goto out;
|
|
}
|
|
pimg->read_img(pimg, (unsigned char*)fdt_high, &len, NULL);
|
|
|
|
}
|
|
|
|
phdr = (image_header_t*)fdt_high;
|
|
if(image_get_magic(phdr) == IH_MAGIC) {
|
|
fdt_size = image_get_size(phdr);
|
|
memmove((void*)(fdt_high - sizeof(image_header_t)), (const void*)fdt_high, fdt_size + sizeof(image_header_t));
|
|
}
|
|
|
|
dtb_magic = (unsigned long*)fdt_high;
|
|
|
|
if(*dtb_magic != DTB_MAGIC) {
|
|
printf("%s invalid fdt0 data !\n", __func__);
|
|
goto out;
|
|
}
|
|
|
|
if(nvt_in_empty_burner_mode()) {
|
|
_VID_PowerON_Sequence();
|
|
}
|
|
|
|
panel_init_late();
|
|
|
|
//prepare boot argument
|
|
nvt_eburner_prepare_boot_cmd();
|
|
|
|
//boot to kernel
|
|
sprintf(cmd, "bootm %s - %s", env_get("kernel_loadaddr"), env_get("fdt_high"));
|
|
run_command(cmd, 0);
|
|
|
|
out:
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
int nvt_eburner_check_trigger(unsigned int adc_reg_base, unsigned int adc_val, unsigned int adc_range)
|
|
{
|
|
unsigned int reg_val = __REG(adc_reg_base);
|
|
int ret = 0;
|
|
|
|
if(reg_val >= (adc_val - adc_range) && reg_val <= (adc_val + adc_range))
|
|
ret = 1;
|
|
else
|
|
ret = 0;
|
|
|
|
return ret;
|
|
}
|
|
#endif//CONFIG_NVTTK_EBURNER_V2
|