int
adapt_decompress(void *src, uint64_t srclen, void *dst,
uint64_t *dstlen, int level, uchar_t chdr, int btype, void *data)
{
struct adapt_data *adat = (struct adapt_data *)(data);
uchar_t cmp_flags;
cmp_flags = CHDR_ALGO(chdr);
if (cmp_flags == ADAPT_COMPRESS_LZ4) {
return (lz4_decompress(src, srclen, dst, dstlen, 1, chdr, btype, adat->lz4_data));
} else if (cmp_flags == ADAPT_COMPRESS_LZMA) {
return (lzma_decompress(src, srclen, dst, dstlen, level, chdr, btype, adat->lzma_data));
} else if (cmp_flags == ADAPT_COMPRESS_BZIP2) {
return (bzip2_decompress(src, srclen, dst, dstlen, level, chdr, btype, NULL));
} else if (cmp_flags == ADAPT_COMPRESS_PPMD) {
return (ppmd_decompress(src, srclen, dst, dstlen, level, chdr, btype, adat->ppmd_data));
} else if (cmp_flags == ADAPT_COMPRESS_BSC) {
#ifdef ENABLE_PC_LIBBSC
return (libbsc_decompress(src, srclen, dst, dstlen, level, chdr, btype, adat->bsc_data));
#else
log_msg(LOG_ERR, 0, "Cannot decompress chunk. Libbsc support not present.\n");
return (-1);
#endif
} else {
log_msg(LOG_ERR, 0, "Unrecognized compression mode: %d, file corrupt.\n", cmp_flags);
}
return (-1);
}
void jump_app(u8 block_id)
{
u8 *p_data_buffer = NULL;
dmh_block_info_t block_dm_info = {0};
u8 *p_data_buffer2 = NULL;
u8 *p_zip_sys = NULL;
u32 out_size = 0;
dm_get_block_header(class_get_handle_by_id(DM_CLASS_ID),block_id,&block_dm_info) ;
OS_PRINTF("block_id %d size 0x%x \n",block_id,block_dm_info.size);
//dm_get_block_header(class_get_handle_by_id(DM_CLASS_ID),0x86,&block_dm_info) ;
//OS_PRINTF("%s size 0x%x \n",__FUNCTION__,block_dm_info.size);
p_data_buffer = (u8 *)mtos_malloc(MAINCODE_SIZE);
if(p_data_buffer == NULL)
{
OS_PRINTF("p_data_buffer malloc fail \n");
return;
}
memset(p_data_buffer,0,MAINCODE_SIZE);
p_zip_sys = (u8 *)mtos_malloc(320 * KBYTES);
if(p_zip_sys == NULL)
{
OS_PRINTF("p_zip_sys malloc fail \n");
return;
}
memset(p_zip_sys,0,320 * KBYTES);
p_data_buffer2 = (u8 *)(MAINCODE_RUN_ADDR);
memset(p_data_buffer2,0,MAINCODE_SIZE);
out_size = MAINCODE_OUT_ZIE;
dm_read(class_get_handle_by_id(DM_CLASS_ID), block_id, 0, 0, block_dm_info.size, p_data_buffer);
OS_PRINTF("\nblock_id :%d data :\n",block_id);
OS_PRINTF("0x%x 0x%x 0x%x 0x%x 0x%x \n\n",p_data_buffer[0],p_data_buffer[1],p_data_buffer[2],p_data_buffer[3],p_data_buffer[4]);
if((p_data_buffer[0] == 0x5d) && (p_data_buffer[1] == 0x00) && (p_data_buffer[2] == 0x00) && (p_data_buffer[3] == 0x80) )
{
init_fake_mem_lzma(p_zip_sys, 320 * KBYTES);
lzma_decompress((void *)p_data_buffer2, &out_size, p_data_buffer, block_dm_info.size);
OS_PRINTF("\nblock_id decompres data :\n");
OS_PRINTF("0x%x 0x%x 0x%x 0x%x 0x%x \n\n",p_data_buffer2[0],p_data_buffer2[1],p_data_buffer2[2],p_data_buffer2[3],p_data_buffer2[4]);
}
else
{
memcpy((void *)p_data_buffer2,(void *)p_data_buffer,block_dm_info.size);
}
hal_dcache_flush((void *)p_data_buffer2, out_size);
//mtos_task_sleep(10000);
_do_go_exec((p_entry)MAINCODE_RUN_ADDR,0,0);
//JUMP(MAINCODE_RUN_ADDR);
}
void loader_main(unsigned long reg_a0, unsigned long reg_a1,
unsigned long reg_a2, unsigned long reg_a3)
{
void (*kernel_entry) (unsigned long, unsigned long, unsigned long,
unsigned long);
int res;
board_init();
printf("\n\nOpenWrt kernel loader for Realtek 819X\n");
printf("Copyright (C) 2011 Gabor Juhos <*****@*****.**>\n");
lzma_init_data();
res = lzma_init_props();
if (res != LZMA_RESULT_OK) {
printf("Incorrect LZMA stream properties!\n");
halt();
}
printf("Decompressing kernel... ");
res = lzma_decompress((unsigned char *) kernel_la);
if (res != LZMA_RESULT_OK) {
printf("failed, ");
switch (res) {
case LZMA_RESULT_DATA_ERROR:
printf("data error!\n");
break;
default:
printf("unknown error %d!\n", res);
}
halt();
} else {
printf("done!\n");
}
//flush_cache(kernel_la, lzma_outsize); //mark_rtk
flush_cache();
printf("Starting kernel at %08x...\n\n", kernel_la);
#ifdef CONFIG_KERNEL_CMDLINE
reg_a0 = kernel_argc;
reg_a1 = (unsigned long) kernel_argv;
reg_a2 = 0;
reg_a3 = 0;
#endif
kernel_entry = (void *) kernel_la;
kernel_entry(reg_a0, reg_a1, reg_a2, reg_a3);
}
void *_tc_recdecode(const void *ptr, int size, int *sp, void *op){
return lzma_decompress(ptr, size, sp);
}
/*!
Get a decompressed resource data by it's head.
\param[in] rsc_head : resource head
\return : if failed, return NULL, otherwise return the buffer address of the data
*/
static u8 *rsc_decompress_data(handle_t rsc_handle, rsc_comm_type_t type)
{
u32 *p_buf_addr = NULL;
u32 data_addr = 0, org_size = 0, cmp_size = 0, buf_size = 0, out_size = 0;
rsc_bmp_info_t *p_bmp_info = NULL;
rsc_head_t *p_hdr_rsc = NULL;
rsc_comm_info_t *p_comm_info = NULL;
u8 *p_fake = NULL;
p_comm_info = _get_rsc_comm_info(rsc_handle, type);
if(p_comm_info == NULL)
{
OS_PRINTF("rsc_decompress_data: can NOT get comm_info(type = %d), ERROR\n",
type);
return NULL;
}
p_hdr_rsc = _get_rsc_comm_head(p_comm_info);
p_buf_addr = &p_comm_info->unzip_buf_addr;
buf_size = p_comm_info->unzip_buf_size;
switch(type)
{
case RSC_COMM_FONT:
data_addr = p_comm_info->rsc_hdr_addr + sizeof(rsc_font_t);
break;
case RSC_COMM_PAL:
data_addr = p_comm_info->rsc_hdr_addr + sizeof(rsc_palette_t);
break;
case RSC_COMM_BMP:
data_addr = p_comm_info->rsc_hdr_addr + sizeof(rsc_bitmap_t);
break;
case RSC_COMM_STRTAB:
data_addr = p_comm_info->rsc_hdr_addr + sizeof(rsc_string_t);
break;
case RSC_COMM_SCRIPT:
data_addr = p_comm_info->rsc_hdr_addr + sizeof(rsc_script_t);
break;
default:
MT_ASSERT(0);
return NULL;
}
org_size = p_hdr_rsc->org_size;
cmp_size = p_hdr_rsc->cmp_size;
switch(p_hdr_rsc->c_mode)
{
case CMP_MODE_NONE:
if(buf_size > 0)
{
/* buffer is ok, copy to buf */
if(org_size > buf_size)
{
RSC_PRINTF(
"RSC: buf_size is non-zero(%d), but NOT enough(%d), ERROR!\n",
org_size, buf_size);
MT_ASSERT(0);
}
else
{
rsc_read_data(rsc_handle, data_addr, (void *)(*p_buf_addr), org_size);
}
}
else
{
/* no buffer, return address on FLASH */
*p_buf_addr = data_addr;
}
break;
case CMP_MODE_RLE:
//os_mutex_lock(lock);
if(org_size > buf_size)
{
RSC_PRINTF(
"RSC: buf_size is non-zero(%d), but NOT enough(%d), ERROR!\n",
org_size, buf_size);
MT_ASSERT(0);
}
else
{
rsc_rle_decode(rsc_handle, (u8 *)data_addr, cmp_size, (u8 *)(*p_buf_addr));
}
break;
#if 0
case CMP_MODE_ZIP:
rsc_unzip(data, output);
break;
#endif
case CMP_MODE_LZ77:
rsc_lz77_decode(rsc_handle, (u8 *)data_addr, cmp_size, (u8 *)(*p_buf_addr));
break;
case CMP_MODE_LZMA:
out_size = buf_size;
p_fake = mtos_malloc(cmp_size);
MT_ASSERT(p_fake != NULL);
init_fake_mem_lzma(p_fake, cmp_size);
lzma_decompress((unsigned long *)(*p_buf_addr), &out_size, (void *)data_addr, cmp_size);
mtos_free(p_fake);
break;
case CMP_MODE_LZ4:
LZ4_decompress_fast((const char *)data_addr, (char *)(*p_buf_addr), org_size);
break;
case CMP_MODE_JPG: /*only for bitmap*/
if(RSC_TYPE_BITMAP != p_hdr_rsc->type)
{
return NULL;
}
p_bmp_info = (rsc_bmp_info_t *)_get_rsc_comm_info(rsc_handle, RSC_COMM_BMP);
MT_ASSERT(p_bmp_info != NULL);
p_bmp_info->hdr_bmp.pitch =
rsc_jpg_decode(rsc_handle, (u8 *)data_addr, cmp_size, (u8 *)(*p_buf_addr));
break;
default:
return NULL;
}
return (u8 *)(*p_buf_addr);
}
