Example #1
0
void draw_jpg(BltConfigParams stConfig,U32 JPD_OUTADDR)
{

    GFX_BufferInfo src_info;
    GFX_Block Blk;
    
    UBOOT_TRACE("IN\n");

    src_info.u32Addr = JPD_OUTADDR;
    UBOOT_DEBUG("src_info.u32Addr=0x%x\n",(unsigned int)src_info.u32Addr);

    src_info.u32ColorFmt = GFX_FMT_YUV422;
    UBOOT_DEBUG("src_info.u32ColorFmt=0x%x\n",(unsigned int)src_info.u32ColorFmt);

    src_info.u32Width = (U32)JPG_GetAlignmentWidth();
    UBOOT_DEBUG("src_info.u32Width=0x%x\n",(unsigned int)src_info.u32Width);

    src_info.u32Height = (U32)JPG_GetAlignmentHeight();
    UBOOT_DEBUG("src_info.u32Height=0x%x\n",(unsigned int)src_info.u32Height);

    src_info.u32Pitch = (U32)JPG_GetAlignmentPitch()<<1;
    UBOOT_DEBUG("src_info.u32Pitch=0x%x\n",(unsigned int)src_info.u32Pitch);

    Blk.x = (U16)((stConfig.u16DispX+15)&0xFFFFF0);
    Blk.y = stConfig.u16DispY;
    Blk.width = (U16)((stConfig.u16DispW+15)&0xFFFFF0);;
    Blk.height = stConfig.u16DispH;
    MsApiDrawJPG(src_info,Blk);
    UBOOT_TRACE("OK\n");
}
Example #2
0
int MsApiChunkHeader_GetValue(EN_CHUNK_HEADER_ITEM enItem,unsigned int *puValue)
{
    UBOOT_TRACE("IN\n");
    
    //UBOOT_DUMP(gu8ChunkHeader,CH_ITEM_LAST);
    if(puValue==NULL)
    {
        UBOOT_ERROR("puValue is a null pointer\n");
        return -1;
    }
    
    if(ChunkHeaderReady != TRUE)
    {
        if(MsApiChunkHeader_Init() !=0)
        {
            UBOOT_ERROR("MsApiChunkHeader_Init fail\n");
            return -1;
        }
    }


    if((enItem>=CH_ITEM_FIRST) && (enItem<=CH_ITEM_LAST))
    {
        *puValue = gu32ChunkHeader[enItem];
        UBOOT_DEBUG("ChunkHeaderOffset(0x%x): 0x%x\n",enItem,*puValue);
    }
    else
    {
        UBOOT_ERROR("ERROR: Out of chunk header bound : %d \n",enItem);
        return -1;
    }

    UBOOT_TRACE("OK\n");
    return 0;    
}
Example #3
0
int do_spi_wrc (cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
{
    unsigned int dram_addr=0;
    unsigned int flash_addr=0;
    unsigned int len=0;
    int ret=0;
    UBOOT_TRACE("IN\n");


    /* check argc */
    if (argc != WRITE_CODE_INPUT_LEN)
    {
        UBOOT_ERROR("Usage:\n%s\n", cmdtp->usage);
        return 1;
    }

    arg_off_size_nor(argc - 2, argv + 2, &flash_addr, &len);
	dram_addr = (0 == strncmp(argv[1], UPGRADE_ADDR_STR, strlen(UPGRADE_ADDR_STR))) ? UPGRADE_BUFFER_ADDR : simple_strtoul(argv[1], NULL, 16);

    ret=_spi_wrc(dram_addr,flash_addr,len);

    if(ret==0)
    {
        UBOOT_TRACE("OK\n");    
    }
    else
    {
        UBOOT_ERROR("write partition fail\n");    
    }
    return ret;
}
int setUpgradePartition(int partitionId)
{
    UBOOT_TRACE("IN\n");
    g_partition=partitionId;
    UBOOT_TRACE("OK\n");            
    return 0;
}
int clearScritSizeOfUpgradeImage(void)
{
    UBOOT_TRACE("IN\n");
    scriptSizeOfUpgradeImage=0;
    UBOOT_TRACE("OK\n");    
    return 0;
}
int setUpgradeMode(EN_UPDATE_MODE enMode)
{
    UBOOT_TRACE("IN\n");
    s_UpdateMode=enMode;
    UBOOT_TRACE("OK\n");            
    return 0;
}
int deleteUpgradeFileName(void)
{
    char *buffer=NULL;
    int ret=0;
    UBOOT_TRACE("IN\n");
    buffer=malloc(CMD_BUF);
    if(buffer==NULL)
    {
        UBOOT_ERROR("malloc fail \n");
        return -1;
    }
    memset(buffer,0,CMD_BUF);
    
    snprintf(buffer,CMD_BUF, "setenv %s ",ENV_UPGRADE_NAME);
    UBOOT_DEBUG("cmd: %s \n",buffer);
    ret=run_command(buffer,0);
    if(ret==-1)
    {
        free(buffer);
        UBOOT_ERROR("delete ENV_UPGRADE_NAME fail\n");
    }
    else
    {
        free(buffer);
        UBOOT_TRACE("OK\n");
    }
    return ret;

}
int setScritSizeOfUpgradeImage(unsigned int size)
{
    UBOOT_TRACE("IN\n");
    scriptSizeOfUpgradeImage=size;
    UBOOT_TRACE("OK\n");
    return 0;
}
int do_check_file_partition(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
{
    char *cFile =NULL;
    int partition=0;
    int device=0;
    int ret=-1;
    UBOOT_TRACE("IN\n");     
     if(argc < 2)
    {
        cmd_usage(cmdtp);
        return -1;
    }
    cFile=argv[1];
    if(check_file_partition(cFile,&partition,&device)!= 0)
    {
        UBOOT_INFO("FAIL: no file in usb or Usb no init!\n");
        ret =-1;
    }
    else
    {
        UBOOT_INFO("file:%s is existed.[device:%d partition:%d]\n",cFile,device,partition);
        ret = 0;
    }
    UBOOT_TRACE("OK\n");     
    return ret;
}
int check_file_partition(char *upgradeFile,int *device, int *partition)
{
    char buffer[CMD_BUF] = "\0";
    UBOOT_TRACE("IN\n");      
    for(g_device = 0 ; g_device < MAX_DEVICE ;g_device++)
    {
        for(g_partition = 0 ; g_partition < MAX_PARTITION ; g_partition++)
        {
            snprintf(buffer, CMD_BUF, "fatload usb %d:%d  %X %s 1",g_device, g_partition, UPGRADE_BUFFER_ADDR, upgradeFile);
            UBOOT_DEBUG("cmd: %s \n",buffer);
            if(run_command(buffer, 0) == 0)
            {
               if((device != NULL) && (partition != NULL))
               {
                   *device=g_device;
                   *partition=g_partition;
               }
               UBOOT_TRACE("OK\n");                
               return 0;
            }    
        }
    }    
    UBOOT_TRACE("OK\n");      
    return -1;
}
// if is_dont_overwrite_cmd return TRUE, we skip this line.
// if is_dont_overwrite_cmd return FALSE, we execute this line.
BOOLEAN check_skip_cmd(char *next_line)
{
    char *pLine = NULL;
    UBOOT_TRACE("IN\n");
    
    if(next_line==NULL)
    {
        UBOOT_ERROR("The input parameter 'next_line' is a null pointer\n");
        return FALSE;
    }

    if(is_dont_overwrite_cmd(next_line)==TRUE)
    {
            
        if(is_force_overwrite_cmd(next_line)==TRUE)
        {
            goto END;
        }
        
        UBOOT_TRACE("OK\n");     
        return TRUE;
}
    
END:    
    //This part is for filter command.
    pLine=strstr(next_line,"#");
    if(pLine!=NULL){
        *pLine='\0';
    }
    UBOOT_TRACE("OK\n");     
    return FALSE;
}
int do_force_overwrite(char *partionName)
{
    UBOOT_TRACE("IN\n");
    
    if(partionName==NULL)
    {
        UBOOT_ERROR("The input parameter 'partionName' is a null pointer\n");
        return -1;
    }
    
    if(force_overwrite_count==MAX_FORCEWRIE_COUNT){
        UBOOT_ERROR("The number os 'fore overwrite' is up to max vaulue:%d\n",MAX_FORCEWRIE_COUNT);
        return -1;
    }

    if(force_overwrite_flag!=TRUE){
        UBOOT_DEBUG("The function of 'force overwrite' is not enable\n");
        UBOOT_TRACE("OK\n");
        return 0;
    }

    pforce_overwrite_partition[force_overwrite_count]=malloc(strlen(partionName)+1);
    if(pforce_overwrite_partition[force_overwrite_count]==NULL){
        UBOOT_ERROR("malloc for %s fail\n",partionName);
        return -1;
    }
    memset(pforce_overwrite_partition[force_overwrite_count],0,strlen(partionName)+1);
    strncpy(pforce_overwrite_partition[force_overwrite_count],partionName, strlen(partionName));

    force_overwrite_count++;

    UBOOT_TRACE("OK\n");

    return 0;
}
Example #13
0
int Secure_AES_ECB_Encrypt(MS_U32 u32Addr, MS_U32 u32Len, MS_U8 *bKey)
{
    AES_ParamStruct AESParam;
    int ret=0;
    UBOOT_TRACE("IN\n");

    AESParam.eMode = E_DRVAESDMA_CIPHER_ECB;
    AESParam.pChiperBuf = u32Addr;
    AESParam.pPlainBuf = u32Addr;
    AESParam.pKey = (MS_U32 *)bKey;
    AESParam.u32Len = u32Len;
    AESParam.pIV= (MS_U32 *)NULL;
    AESParam.bIsDecrypt = FALSE;

    ret=CommonAES128(&AESParam);
    if(ret==0)
    {
        UBOOT_TRACE("OK\n");
    }
    else
    {
        UBOOT_ERROR("Secure_AES_Encrypt fail\n");
    }

    return ret;
}
Example #14
0
int do_spi_create (cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
{
#if defined (CONFIG_APP_IN_SPI)
    unsigned int size=0;
    int ret=0;
    UBOOT_TRACE("IN\n");
    if(argc!=CREATE_PARTITION_INPUT_LEN)
    {
        cmd_usage(cmdtp);
        return -1;
    }
    size=simple_strtol(argv[2], NULL,16);
    ret=add_partition(argv[1],size);
    if(ret==0)
    {
        UBOOT_TRACE("OK\n");    
    }
    else
    {
        UBOOT_ERROR("create partition fail\n");
    }
    return ret;
#else
    UBOOT_TRACE("IN\n");
    UBOOT_ERROR("This function doesn't support\n");
    return -1;
#endif
}
int setUpgradeDevice(int deviceId)
{
    UBOOT_TRACE("IN\n");
    g_device=deviceId;
    UBOOT_TRACE("OK\n");            
    return 0;
}
Example #16
0
int do_spi_init_partition (cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
{
#if defined (CONFIG_APP_IN_SPI)
    int ret=0;
    UBOOT_TRACE("IN\n");
    if(argc!=1)
    {
        cmd_usage(cmdtp);
        return -1;
    }
    ret=init_spi_partition();
    if(ret==0)
    {
        UBOOT_TRACE("OK\n");
    }
    else
    {   UBOOT_ERROR("init spi partition fail\n");
    }
    return ret;
#else
    UBOOT_TRACE("IN\n");
    UBOOT_ERROR("This function doesn't support\n");
    return -1;
#endif
}
Example #17
0
int do_spi_rmgpt(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
{
#if defined (CONFIG_APP_IN_SPI)
    int ret=0;
    UBOOT_TRACE("IN\n");
    if(argc!=RMGPT_INPUT_LEN)
    {
        cmd_usage(cmdtp);
        return -1;
    }
    
    ret=del_all_partitions();
    if(ret==0)
    {
        ret=add_mboot_partition();
        if(ret==-1)
        {
            UBOOT_ERROR("add mboot partition fail\n");
            return -1;
        }    
    }
    else
    {
        UBOOT_ERROR("remove partition fail\n");
    }
    
    return ret;
#else
    UBOOT_TRACE("IN\n");
    UBOOT_ERROR("This function doesn't support\n");
    return -1;
#endif
}
Example #18
0
int get_addr_from_mmap(char *id, U32 *addr)
{
    MMapInfo_s mmapInfo;
    UBOOT_TRACE("IN\n");
    if((id==NULL)||(addr==NULL))
    {
        UBOOT_ERROR("One of the parameters is a null pointer\n");
        return -1;
    }
    UBOOT_DEBUG("id=%s\n",id);
    if(get_mmap(id,&mmapInfo)!=0)
    {
        UBOOT_ERROR("get mmap fail\n");
        return -1;
    }
    if(mmapInfo.b_is_miu0==0)
    {
        UBOOT_DEBUG("In MIU0\n");
        *addr=mmapInfo.u32Addr+miu_interval;
    }
    else
    {
        UBOOT_DEBUG("In MIU1\n");
        *addr=mmapInfo.u32Addr;
    }
    UBOOT_DEBUG("addr=0x%x\n",*addr);     
    UBOOT_TRACE("OK\n");
    return 0;
}
Example #19
0
MS_BOOL MsDrv_MIU_Protect(MS_U8  u8Blockx, MS_U8  *pu8ProtectId, MS_U32 u32Start, MS_U32 u32End, MS_BOOL bSetFlag)

{
    MS_BOOL isProtect=FALSE;
    MS_U32 u32PageShift;
	UBOOT_TRACE("IN\n");
    UBOOT_DEBUG("MsDrv_MIU_Protect Index[%d] LX[0x%lx][0x%lx] \n",u8Blockx,u32Start,u32End);

    if(!MDrv_MIU_ProtectAlign(&u32PageShift))
    {
        UBOOT_ERROR("ERROR MDrv_MIU_ProtectAlign FAIL \n");
    }

    isProtect=MDrv_MIU_Protect(u8Blockx, pu8ProtectId, MIU_ALIGN(u32Start, u32PageShift), MIU_ALIGN(u32End, u32PageShift), bSetFlag);
    
    if(!isProtect)
    {
        UBOOT_ERROR("ERROR MDrv_MIU_Protect FAIL \n");
    }

	UBOOT_TRACE("OK\n");

    return isProtect;

}
Example #20
0
int do_spi_remove (cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
{
#if defined (CONFIG_APP_IN_SPI)
    int ret=0;
    UBOOT_TRACE("IN\n");
    if(argc!=REMOVE_PARTITION_INPUT_LEN)
    {
        cmd_usage(cmdtp);
        return -1;
    }
    
    ret=del_partition(argv[1]);
    if(ret==0)
    {
        UBOOT_TRACE("OK\n");    
    }
    else
    {
        UBOOT_ERROR("remove partition fail\n");
    }
    return ret;
#else
    UBOOT_TRACE("IN\n");
    UBOOT_ERROR("This function doesn't support\n");
    return -1;
#endif
}
Example #21
0
char* loadscript(char *filedir,U32 *filesize)
{
    char *script = NULL;
    UBOOT_TRACE("IN\n");

    *filesize = vfs_getsize(filedir);
    if( (*filesize > SCRIPT_BUFSIZE) || (*filesize == 0) )
    {
        UBOOT_ERROR("No enough buffer or path fail(%s) :\n[%s] [%s]\n",filedir,__FILE__,__FUNCTION__);
        return NULL;
    }

    script = (char *)malloc(*filesize);
    if(script == NULL)
    {
        UBOOT_ERROR("No enough buffer %s %s\n",__FILE__,__FUNCTION__);
        return NULL;
    }
    if(vfs_read((void *)script,filedir,0,(unsigned int)(*filesize))==-1)
    {
        free(script);
        UBOOT_ERROR("Error: vfs_read Fail \n");
        return NULL;
    }
    UBOOT_TRACE("OK\n");
    return script;
}
Example #22
0
int appInitUsbDisk(void)
{
    char idx=0;

#if defined(ENABLE_THIRD_EHC)
    const char u8UsbPortCount = 3;
#elif defined(ENABLE_SECOND_EHC)
    const char u8UsbPortCount = 2;
#else
    const char u8UsbPortCount = 1;
#endif
    UBOOT_TRACE("IN\n");

    for(idx=0; idx<u8UsbPortCount; idx++)
    {
        if (usb_init(idx) == 0)
        {
            if (usb_stor_scan(1) == 0)
            {
                UBOOT_TRACE("OK\n");
                return 0 ;
            }
        }
    }
    UBOOT_TRACE("OK\n");
    return -1;
}
Example #23
0
//--------------------------------------------------------------------------------------------------
///Entry function for JPD testing.
//--------------------------------------------------------------------------------------------------
int MsDrv_JPD_Decode(MS_U32 u32SrcAddr, MS_U32 u32SrcSize)
{
    UBOOT_TRACE("IN\n");

    TARGET_LOGO_ADDR =MS_PA2KSEG1(u32SrcAddr) ;
    TARGET_LOGO_SIZE = u32SrcSize;

    MsDrv_JpdInit();
	if(u32ReadBuffPA==0xFFFF || u32WriteBuffPA==0xFFFF ||u32InterBuffPA==0xFFFF)
	{
		UBOOT_ERROR("Get Mmap for JPD Fail Skip JPD Decode !!! \n");
		return -1;

	}

    //Preload data for init JPEG decoder data.
    s32InitByteRead = MsDrv_FILE_read((MS_U8 *)u32ReadBuffVirAddr, u32ReadBuffSize, &u8EOF_flag);

    if(s32InitByteRead < 0)
    {
        UBOOT_ERROR("Initial read file error!!\n");
		return -1;
    }

    MsDrv_JpdStartDecode(E_JPD_MAIN_DECODE);

    UBOOT_TRACE("OK\n");
	return 1;

}
Example #24
0
U32 vfs_getsize(char *filedir)
{
	U32 filesize = 0;
    int ret = 0;
    char *buffer=NULL;
    
    UBOOT_TRACE("IN\n"); 

    if(filedir==NULL)
    {
        UBOOT_ERROR("filedir is a null pointer\n");
        return -1;
    }

    if(bVfsReady==FALSE)
    {
        UBOOT_ERROR("filesystem is not mounted\n");
        return -1;
    }
    
    buffer=malloc(CMD_BUF);
    if(buffer==NULL)
    {
        UBOOT_ERROR("malloc buffer fail\n");
        return -1;
    }
    memset(buffer,0,CMD_BUF);
#ifdef KONKA_BOOT_CFG
    printf("mingwu_mboot----vfs_getsize->filedir = %s\n",filedir);
    if(strncmp(filedir, "/customercfg/",13)==0)
    {
        printf("mingwu_mboot----------vfs_getsize--=000=\n");
        filedir +=13;//skip /customercfg
        mmc_volume="customercfg";
        snprintf(buffer, CMD_BUF, "ext4filesize mmc 0:0xA %s %x",filedir,(U32)&filesize);
    }
    else
	{
		printf("mingwu_mboot----------vfs_getsize--=111=\n");
	    snprintf(buffer, CMD_BUF, "ext4filesize mmc 0:%s %s %x",mmc_volume,filedir,(U32)&filesize);
	}
#else
    //snprintf(cmd, CMD_BUF, "ext4filesize mmc 0:%s %s",mmc_partition,filedir);
    snprintf(buffer, CMD_BUF, "ext4filesize mmc 0:%s %s %x",mmc_volume,filedir,(U32)&filesize);
#endif
    UBOOT_DEBUG("cmd=%s\n",buffer);
    ret=run_command(buffer, 0);
    if(ret==-1)
    {
        UBOOT_DEBUG("ext4filesize mmc fail\n");
        filesize=0;
    }
    else
    {
        UBOOT_TRACE("OK\n");
    }
    free(buffer);
	return filesize;
}
Example #25
0
void MsDrv_kernelProtect(MS_U8  u8Blockx,MS_U32 u32Lx1Start, MS_U32 u32Lx1End)

{
	UBOOT_TRACE("IN\n");

    MsDrv_MiuInit();

    MS_U8 u8MIUProtectkernel_ID[16]={0};

    // ==== Linux kernel ID Protect
    UBOOT_DEBUG("Kernel Protect Index[%d] LX[0x%lx][0x%lx] \n",u8Blockx,u32Lx1Start,u32Lx1End);
#if ENABLE_NIKON  

    u8MIUProtectkernel_ID[0] = MIU_CLIENT_MIPS_RW; //MIPS W

    u8MIUProtectkernel_ID[1] = MIU_CLIENT_BDMA_RW;//MIU_CLIENT_NAND_RW;//MIU_CLIENT_BDMA_RW; //BDMA    

    u8MIUProtectkernel_ID[2] = MIU_CLIENT_USB_UHC0_RW; //USB0

    u8MIUProtectkernel_ID[3] = MIU_CLIENT_USB_UHC1_RW; //USB1

    u8MIUProtectkernel_ID[4] = MIU_CLIENT_USB_UHC2_RW; //USB2

    u8MIUProtectkernel_ID[5] = MIU_CLIENT_FCIE_RW;//MIU_CLIENT_G3D_RW; //G3D     

   // u8MIUProtectkernel_ID[6] = MIU_CLIENT_USB3_RW; //USB3.0      

   // u8MIUProtectkernel_ID[7] = MIU_CLIENT_SDIO_RW; //SD IO        

   // u8MIUProtectkernel_ID[8] = MIU_CLIENT_SATA_RW; //SATA       
#else
    u8MIUProtectkernel_ID[0] = MIU_CLIENT_MIPS_RW; //MIPS W

    u8MIUProtectkernel_ID[1] = MIU_CLIENT_NAND_RW;//MIU_CLIENT_BDMA_RW; //BDMA

    u8MIUProtectkernel_ID[2] = MIU_CLIENT_USB_UHC0_RW; //USB0

    u8MIUProtectkernel_ID[3] = MIU_CLIENT_USB_UHC1_RW; //USB1

    u8MIUProtectkernel_ID[4] = MIU_CLIENT_USB_UHC2_RW; //USB2

    u8MIUProtectkernel_ID[5] = MIU_CLIENT_G3D_RW; //G3D

    u8MIUProtectkernel_ID[6] = MIU_CLIENT_USB3_RW; //USB3.0

    u8MIUProtectkernel_ID[7] = MIU_CLIENT_SDIO_RW; //SD IO

    u8MIUProtectkernel_ID[8] = MIU_CLIENT_SATA_RW; //SATA

    u8MIUProtectkernel_ID[9] = MIU_CLIENT_USB_UHC3_RW; //USB3
#endif
    MsDrv_MIU_Protect(u8Blockx, &u8MIUProtectkernel_ID[0], u32Lx1Start, u32Lx1End, ENABLE);

	UBOOT_TRACE("OK\n");


}
Example #26
0
int vfs_umount(void)
{
    int ret = 0;
    UBOOT_TRACE("IN\n");
    mmc_volume = "";
    bVfsReady=FALSE;
    UBOOT_TRACE("OK\n");
	return ret;
}
Example #27
0
//--------------------------------------------------------------------------------------------------
static void MsDrv_SetStatus(void)
{
	UBOOT_TRACE("IN\n");
    if( g_state == E_JPEG_DECODE_DONE )
    {
        UBOOT_DEBUG("MsDrv_SetStatus:E_JPEG_DECODE_DONE\n");
        //u16ImageWidth = MApi_JPEG_GetWidth();
        //u16ImageHeight = MApi_JPEG_GetHeight();
        //bIsProgressive = MApi_JPEG_IsProgressive();
        //u16ImageOriWidth = MApi_JPEG_GetOriginalWidth();
        //u16ImageOriHeight = MApi_JPEG_GetOriginalHeight();
        //u16ImageNonAlignWidth = MApi_JPEG_GetNonAlignmentWidth();
        //u16ImageNonAlignHeight = MApi_JPEG_GetNonAlignmentHeight();
        //u8ScaleDownFactor = MApi_JPEG_GetScaleDownFactor();
        //u8DebugLevel = MApi_JPEG_GetDbgLevel();
        MApi_JPEG_GetInfo(&stJPEG_Info);
        MApi_JPEG_GetStatus(&stJPEG_Status);
        MApi_JPEG_GetLibVer(&pu8JPEG_Ver);
        u16ImageAlignPitch = MApi_JPEG_GetAlignedPitch(),
        u16ImageAlignWidth = MApi_JPEG_GetAlignedWidth(),
        u16ImageAlignHeight = MApi_JPEG_GetAlignedHeight();
//        bThumbnailFound = MApi_JPEG_ThumbnailFound();

        UBOOT_DEBUG("MsDrv_SetStatus >>>>>>>>>>> w:%d,  h:%d,  p:%d\n",u16ImageAlignWidth,u16ImageAlignHeight,u16ImageAlignPitch);
        g_JpgPitch = MApi_JPEG_GetAlignedPitch();
        g_JpgHeight = MApi_JPEG_GetAlignedHeight();
        g_JpgWidth = MApi_JPEG_GetAlignedWidth();

        MApi_JPEG_GetEXIFDateTime(&_gEXIF_DateTime);
        MApi_JPEG_GetEXIFOrientation(&_gEXIF_Orientation);
    }
    else if( g_state == E_JPEG_DECODE_ERR )
    {
        UBOOT_ERROR("MsDrv_SetStatus:E_JPEG_DECODE_ERR\n");
        //u16ImageWidth = MApi_JPEG_GetWidth();
        //u16ImageHeight = MApi_JPEG_GetHeight();
        //bIsProgressive = MApi_JPEG_IsProgressive();
        //u16ImageOriWidth = MApi_JPEG_GetOriginalWidth();
        //u16ImageOriHeight = MApi_JPEG_GetOriginalHeight();
        //u16ImageNonAlignWidth = MApi_JPEG_GetNonAlignmentWidth();
        //u16ImageNonAlignHeight = MApi_JPEG_GetNonAlignmentHeight();
        //u8ScaleDownFactor = MApi_JPEG_GetScaleDownFactor();
        //u16ErrorCode = MApi_JPEG_GetErrorCode();
        //u8DebugLevel = MApi_JPEG_GetDbgLevel();
        MApi_JPEG_GetInfo(&stJPEG_Info);
        MApi_JPEG_GetStatus(&stJPEG_Status);
        MApi_JPEG_GetLibVer(&pu8JPEG_Ver);
        u16ImageAlignPitch = MApi_JPEG_GetAlignedPitch(),
        u16ImageAlignWidth = MApi_JPEG_GetAlignedWidth(),
        u16ImageAlignHeight = MApi_JPEG_GetAlignedHeight();
//        bThumbnailFound = MApi_JPEG_ThumbnailFound();
        MApi_JPEG_GetEXIFDateTime(&_gEXIF_DateTime);
        MApi_JPEG_GetEXIFOrientation(&_gEXIF_Orientation);
    }
	UBOOT_TRACE("OK\n");
}
Example #28
0
int do_spi_erase_partition ( cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
{
#if defined (CONFIG_APP_IN_SPI)
    #define PARTITION_NAME argv[1]
    int ret=0;
    unsigned int partiton_size=0;
    unsigned int partiton_offset=0;
    UBOOT_TRACE("IN\n");
    if(argc!=ERASE_PARTITION_INPUT_LEN)
    {
        cmd_usage(cmdtp);
        return -1;
    }

    ret=get_spi_partition_info(PARTITION_NAME,&partiton_offset,&partiton_size);
    if(ret!=0)
    {
        UBOOT_ERROR("get %s info fail\n",PARTITION_NAME);
        return -1;
    }
    UBOOT_DEBUG("partiton_offset=0x%x\n",partiton_offset);
    UBOOT_DEBUG("partiton_size=0x%x\n",partiton_size);    

    if(MDrv_SERFLASH_WriteProtect(0)==0)
    {
        UBOOT_ERROR ("SPI write protect diable fail\n");
        return -1;
    }
   
    ret=MDrv_SERFLASH_AddressErase (partiton_offset, partiton_size, TRUE) ? 0 : -1;
    if(ret!=0)
    {
        UBOOT_ERROR("erase partition fail\n");
    }

    // even erase fail, we still have to enable write protect function
    if(MDrv_SERFLASH_WriteProtect(1)==0)
    {
        UBOOT_ERROR ("SPI write protect enable fail\n");
        return -1;
    }
    
    if(ret==0)
    {
        UBOOT_TRACE("OK\n");
    }
    
    return ret;

   #undef PARTITION_NAME
#else
    UBOOT_TRACE("IN\n");
    UBOOT_ERROR("This function doesn't support\n");
    return -1;
#endif
}
Example #29
0
int vfs_mount(char *volume)
{
    int ret = 0;
    UBOOT_TRACE("IN\n");
    mmc_volume = volume;
    UBOOT_INFO("mmc change mount : %s\n",mmc_volume);
    bVfsReady=TRUE;
    UBOOT_TRACE("OK\n");
	return ret;
}
Example #30
0
int MsApiChunkHeader_Init(void)
{
    U32 u32ChunkHeaderOffset = 0;
    int ret = -1;

    UBOOT_TRACE("IN\n");
    raw_io_config_push();
    ret = mboot_raw_io_Config();
    if(ret != 0)
    {
        UBOOT_ERROR("raw_io_config setting fail!\n");
        raw_io_config_pop();
        return ret;
    }

    if(get_raw_status()==E_RAW_DATA_IN_SPI)
    {
        if(IsHouseKeepingBootingMode()==FALSE){
             u32ChunkHeaderOffset = 0x30000;
        }
        else
        {
            #if(CONFIG_MSTAR_RT_PM_IN_SPI==1)
                u32ChunkHeaderOffset = 0x30000;
            #else
#if defined(CONFIG_PM_SIZE_KB_FORCED) && (0!=CONFIG_PM_SIZE_KB_FORCED)
                u32ChunkHeaderOffset = 0x10000+(CONFIG_PM_SIZE_KB_FORCED*0x400);
#else
                u32ChunkHeaderOffset = 0x20000;
#endif
            #endif
        }

        #if(ENABLE_MSTAR_PUMABOOT)
        u32ChunkHeaderOffset = u32ChunkHeaderOffset + CONFIG_PUMABOOT_SIZE;
        #endif
    }
    else
    {
         u32ChunkHeaderOffset = 0;
    }
    ret = raw_read((U32)gu32ChunkHeader,u32ChunkHeaderOffset,(CH_ITEM_LAST+1)*4);
    
    raw_io_config_pop();
 
    if(ret != 0)
    {
         UBOOT_ERROR("raw_read gu8ChunkHeader fail\n");
         return -1;
    }
    
    ChunkHeaderReady = TRUE; 
    UBOOT_TRACE("OK\n");
    return 0;    
}