int part_load(blkdev_t *bdev, part_t *part, u32 *addr, u32 offset, u32 size)
{
int ret;
img_hdr_t *hdr = img_hdr_buf;
part_hdr_t *part_hdr = &hdr->part_hdr;
gfh_file_info_t *file_info_hdr = &hdr->file_info_hdr;
/* specify the read offset */
u64 src = part->startblk * bdev->blksz + offset;
u32 dsize = 0, maddr = 0;
u32 ms;
/* retrieve partition header. */
if (blkdev_read(bdev, src, sizeof(img_hdr_t), (u8*)hdr, part->part_id) != 0) {
print("[%s] bdev(%d) read error (%s)\n", MOD, bdev->type, part->name);
return -1;
}
if (part_hdr->info.magic == PART_MAGIC) {
/* load image with partition header */
part_hdr->info.name[31] = '\0';
print("[%s] Image with part header\n", MOD);
print("[%s] name : %s\n", MOD, part_hdr->info.name);
print("[%s] addr : %xh\n", MOD, part_hdr->info.maddr);
print("[%s] size : %d\n", MOD, part_hdr->info.dsize);
print("[%s] magic: %xh\n", MOD, part_hdr->info.magic);
maddr = part_hdr->info.maddr;
dsize = part_hdr->info.dsize;
src += sizeof(part_hdr_t);
memcpy(part_info + part_num, part_hdr, sizeof(part_hdr_t));
part_num++;
} else {
print("[%s] %s image doesn't exist\n", MOD, part->name);
return -1;
}
if (maddr == PART_HEADER_MEMADDR)
maddr = *addr;
ms = get_timer(0);
if (0 == (ret = blkdev_read(bdev, src, dsize, (u8*)maddr, part->part_id)))
*addr = maddr;
ms = get_timer(ms);
print("\n[%s] load \"%s\" from 0x%llx (dev) to 0x%x (mem) [%s]\n", MOD,
part->name, src, maddr, (ret == 0) ? "SUCCESS" : "FAILED");
if( ms == 0 )
ms+=1;
print("[%s] load speed: %dKB/s, %d bytes, %dms\n", MOD, ((dsize / ms) * 1000) / 1024, dsize, ms);
return ret;
}
BOOL is_lk_img(void)
{
part_hdr_t *part_hdr = (part_hdr_t*)COMMON_BUFFER_ADDR;
blkdev_t *bdev = blkdev_get(CFG_BOOT_DEV);
part_t *part;
u64 src;
if (NULL == (part = part_get(PART_UBOOT)))
goto error;
src = part->startblk * bdev->blksz;
/* retrieve partition header. */
if ((blkdev_read(bdev, src, sizeof(part_hdr_t), (u8*)part_hdr) == 0) &&
(!memcmp(part_hdr->info.name, "LK", strlen("LK")))) {
SMSG ("[%s] Found LK... \n",MOD);
return TRUE;
}else{
SMSG ("[%s] LK does not exist, use uboot... \n",MOD);
return FALSE;
}
error:
SMSG ("[%s] part_get (PART_UBOOT) Fail\n",MOD);
return FALSE;
}
static ssize_t _osprd_read(struct file *filp, char __user *usr, size_t size,
loff_t *loff) {
ssize_t read = blkdev_read(filp, usr, size, loff);
osprd_info_t *d = file2osprd(filp);
if (d == NULL) {
return read;
}
char *buf = (char*)kmalloc(size, GFP_KERNEL);
if (buf == NULL) {
return -ENOMEM;
}
if (copy_from_user(buf, usr, size) != 0) {
kfree(buf);
return -EFAULT;
}
//eprintk("READ buf: %s\npasswd_hash: %d\n", buf, d->passwd_hash);
xor_cipher(buf, size, d->passwd_hash);
//eprintk("READ buf: %s\npasswd_hash: %d\n", buf, d->passwd_hash);
if (copy_to_user(usr, buf, size) != 0) {
kfree(buf);
return -EFAULT;
}
kfree(buf);
return read;
}
int main(void)
{
uint32_t i;
const size_t block_size = blkdev_block_size();
const uint32_t n_sectors = blkdev_size();
const size_t crc_block_mul = block_size / 512;
uint8_t data[BLOCKS*block_size];
uint32_t crc = 0;
printf("Hello, world\n");
for ( i=0; i<n_sectors; i+=BLOCKS ) {
uint32_t x = expected_crc[(i+BLOCKS-1)*crc_block_mul];
blkdev_read(i, data, BLOCKS);
// et_hexdump(data, 512*BLOCKS);
crc = do_crc32(crc, data, block_size*BLOCKS);
printf("CRC of %d first blocks is 0x%x, expected: 0x%x\n", i, crc, x);
assert(crc == x);
}
printf("CRC of %d first blocks is 0x%x\n", n_sectors, crc);
for ( i=0; i<100000; ++i )
asm volatile("nop");
soclib_io_set(
base(SIMHELPER),
SIMHELPER_SC_STOP,
0);
while (1);
return 0;
}
/******************************************************************************
* READ IMAGE FOR S-BOOT CHECK (FROM NAND or eMMC DEVICE)
******************************************************************************/
U32 sec_util_read_image (U8* img_name, U8 *buf, U32 offset, U32 size)
{
BOOL ret = SEC_OK;
U32 i = 0;
U32 cnt = 0;
U32 now_offset = 0;
U32 total_pages = 0;
U32 start_offset = offset;
blkdev_t *bootdev = NULL;
part_t *part = NULL;
U64 src;
if (NULL == (bootdev = blkdev_get(CFG_BOOT_DEV)))
{
SMSG("[%s] can't find boot device(%d)\n", MOD, CFG_BOOT_DEV);
ASSERT(0);
}
/* ======================== */
/* get part info */
/* ======================== */
/* part_get should be device abstraction function */
if(NULL == (part = part_get (sec2plname(img_name))))
{
SMSG("[%s] part_get fail\n", MOD);
ASSERT(0);
}
/* ======================== */
/* read part data */
/* ======================== */
/* part_load should be device abstraction function */
if(TRUE == bDumpPartInfo)
{
SMSG("[%s] part load '0x%x'\n", MOD, part->startblk * bootdev->blksz);
bDumpPartInfo = FALSE;
}
src = part->startblk * bootdev->blksz + offset;
if (-1 == blkdev_read(bootdev, src, size, buf))
{
SMSG("[%s] part_load fail\n", MOD);
ASSERT(0);
}
return ret;
}
U8* sec_cfg_load (void)
{
U32 i = 0;
U8 *buf = (U8*)SEC_WORKING_BUFFER_START;
U32 seccfg_size = 0;
blkdev_t *bootdev = NULL;
/* --------------------- */
/* initialize buffer */
/* --------------------- */
seccfg_size = get_sec_cfg_cnt_size();
memset(buf, 0x0, seccfg_size);
/* --------------------- */
/* read sec cfg */
/* --------------------- */
SMSG("\n\n[%s] read '0x%x'\n",MOD,sec_cfg_info.addr);
if (NULL == (bootdev = blkdev_get(CFG_BOOT_DEV)))
{
SMSG("[%s] can't find boot device(%d)\n", MOD, CFG_BOOT_DEV);
return NULL;
}
blkdev_read(bootdev, sec_cfg_info.addr, seccfg_size, (u8*)buf, sec_cfg_info.part_id);
/* dump first 8 bytes for debugging */
for(i=0;i<8;i++)
SMSG("0x%x,",buf[i]);
SMSG("\n");
return buf;
}
int part_load(blkdev_t *bdev, part_t *part, u32 *addr, u32 offset, u32 size)
{
int ret;
img_hdr_t *hdr = img_hdr_buf;
part_hdr_t *part_hdr = &hdr->part_hdr;
gfh_file_info_t *file_info_hdr = &hdr->file_info_hdr;
/* specify the read offset */
u64 src = part->startblk * bdev->blksz + offset;
u32 dsize = 0, maddr = 0, mode = 0;
u32 ms;
/* retrieve partition header. */
if (blkdev_read(bdev, src, sizeof(img_hdr_t), (u8*)hdr) != 0) {
print("[%s] bdev(%d) read error (%s)\n", MOD, bdev->type, part->name);
return -1;
}
if (part_hdr->info.magic == PART_MAGIC) {
/* load image with partition header */
part_hdr->info.name[31] = '\0';
print("[%s] Image with part header\n", MOD);
print("[%s] name : %s\n", MOD, part_hdr->info.name);
print("[%s] addr : %xh mode : %d\n", MOD, part_hdr->info.maddr, part_hdr->info.mode);
print("[%s] size : %d\n", MOD, part_hdr->info.dsize);
print("[%s] magic: %xh\n", MOD, part_hdr->info.magic);
maddr = part_hdr->info.maddr;
dsize = part_hdr->info.dsize;
mode = part_hdr->info.mode;
src += sizeof(part_hdr_t);
memcpy(part_info + part_num, part_hdr, sizeof(part_hdr_t));
part_num++;
} else {
print("[%s] %s image doesn't exist\n", MOD, part->name);
return -1;
}
if (maddr == PART_HEADER_MEMADDR) {
maddr = *addr;
}
else if (mode == LOAD_ADDR_MODE_BACKWARD) {
/* note: if more than one TEE are loaded/verified, the later loaded tee
* MUST BE the active TEE due to secure momory allocation algorithm */
g_secure_dram_size = maddr;
/* secure memory is allocated to secure world already */
maddr = CFG_DRAM_ADDR + memory_size();
}
ms = get_timer(0);
if (0 == (ret = blkdev_read(bdev, src, dsize, (u8*)maddr)))
*addr = maddr;
ms = get_timer(ms);
print("\n[%s] load \"%s\" from 0x%llx (dev) to 0x%x (mem) [%s]\n", MOD,
part->name, src, maddr, (ret == 0) ? "SUCCESS" : "FAILED");
if( ms == 0 )
ms+=1;
print("[%s] load speed: %dKB/s, %d bytes, %dms\n", MOD, ((dsize / ms) * 1000) / 1024, dsize, ms);
#if CFG_TRUSTONIC_TEE_SUPPORT
if (part_is_TEE(part)) {
u32 tee_hdr_size = 0;
print("verifying TEE...");
/* verify TEE */
ret = trustonic_tee_verify(addr, dsize, tee_img_vfy_pubk);
if (ret) {
print("fail, ret = 0x%x\n", ret);
return ret;
}
print("ok\n");
ret = trustonic_tee_decrypt(maddr, dsize);
if (ret)
return ret;
/* return memory occupied by tee hdr to normal world */
tee_hdr_size = *addr - maddr;
g_secure_dram_size -= tee_hdr_size;
}
#endif
return ret;
}
