msapi_miu.c

mstar 776 开发的车载dvd

        // calc for next font table starting address
        fontaddr = GE_ADDR_ALIGNMENT(fontaddr + FontSdramInfo.u32SdramLen);
    }
    else
    {
        msWarning(ERR_FONT_OUT_OF_BUFFER);
    }

    return handle;
}

#if 0
/******************************************************************************/
/// MIU Load Bitmap
/// Copy bitmap table from flash to SDRAM
/// @param u16ID \b IN ID of the bitmap
/// @param u16width \b IN Bitmap width
/// @param u16height \b IN Bitmap height
/******************************************************************************/
BMPHANDLE msAPI_MIU_LoadFlashBitmap(U16 u16ID, U16 u16width, U16 u16height)
{
    BMPHANDLE   handle = INVALID_BMPHANDLE;
    BINFORMAT   BinInfo;

    BinInfo.B_ID = u16ID;
    if (msAPI_MIU_Get_BinInfo(&BinInfo) != PASS)
    {
        //APIMIU_DBG(printf("Error msAPI_MIU_LoadFlashBitmap: ID=0x%X\n", u16ID));
        return INVALID_BMPHANDLE;
    }

    if (bmpaddr + BinInfo.B_Len <= BMP_START_ADR + BMP_LEN)
    {
        MDrv_MIU_XCopy(MCPY_LOADBITMAP, BinInfo.B_FAddr, bmpaddr, BinInfo.B_Len);
        handle = MDrv_GE_LoadBitmap( bmpaddr, BinInfo.B_Len, u16width, u16height, MIU_SDRAM );
        bmpaddr = GE_ADDR_ALIGNMENT(bmpaddr + BinInfo.B_Len);
    }
    else
    {
        msWarning(ERR_BMP_OUT_OF_BUFFER);
        //APIMIU_DBG(printf("not enough, bmpaddr=%x Binfo.B_Len=%x \r\n", bmpaddr, BinInfo.B_Len));
        //printf("BMP_START_ADR=%x, BMP_LEN=%x \r\n", BMP_START_ADR, BMP_LEN));
    }

    return handle;
}
#endif

#if 1
//OSDCOMPOSER
BMPHANDLE msAPI_MIU_LoadFlashBitmap_Osdcp(U32 u32addr, U16 u16width, U16 u16height, GE_Buffer_Format fmt)
{
    U32 u32dstaddr = bmpaddr;
    // Addy - fix the bug if width * height > 65535
    //U32 u32len = (U32)((U32)(u16width*u16height)*2);
    U32 u32len = (U32)u16width*u16height*2;

    //MDrv_MIU_XCopy(MCPY_LOADBITMAP, u32addr, u32dstaddr, u32len);
    msAPI_MIU_Copy(u32addr, u32dstaddr, u32len, MIU_FLASH2SDRAM);
    bmpaddr = GE_ADDR_ALIGNMENT(bmpaddr + u32len);

    return MDrv_GE_LoadBitmap2( u32dstaddr, u32len, u16width, u16height, fmt, MIU_SDRAM );
}

/******************************************************************************/
/// API for MIU Store Database::
/// Copy database information from SDRAM to flash
/// @param u32srcaddr \b IN SDRAM address for Database information
/// @param s32size \b IN Database information size
/******************************************************************************/
void msAPI_MIU_StoreDataBase2Flash(U8 u8Bank, U32 u32srcaddr, S32 s32size)    // SRAM2Flash
{
    U32 dst;
    U16 count;
    U8 *flash_buf;

    flash_buf = (U8*)msAPI_Memory_Allocate(FLASH_BUF_SIZE);
    if (flash_buf == NULL)
    {
        APIMIU_DBG(printf("malloc flash_buf fail!\r\n"));
        return;
    }

    APIMIU_DBG(printf("StoreDataBase2Flash, src=0x%Lx, dst=0x%Lx,, size=0x%Lx\n", u32srcaddr, (U32)(SYSTEM_BANK_SIZE * u8Bank), s32size));

#if (FLASH_WP_PIN_CONTROL == ENABLE)
    Flash_Write_Protect_Disable();
#endif

    dst = SYSTEM_BANK_SIZE * u8Bank;
    //dst = SYSTEM_BANK_DATADASE_BASE;
   //MDrv_Flash_Erase(SYSTEM_BANK_DATADASE_BASE, SYSTEM_BANK_DATADASE_BASE+0xFFFF);
	MDrv_Flash_WriteProtect(DISABLE);
    #if ENABLE_QUICK_DATABASE
    if (!((g_u8QuickDataBase & (QUICK_DB_UPDATE | QUICK_DB_MASK)) == (QUICK_DB_UPDATE | QUICK_DB_ERASE_DONE)))
    #endif
    {
//	MDrv_Flash_Erase((U16)(dst/SERFLASH_SECTOR_SIZE), (U16)((dst+0xFFFF)/SERFLASH_SECTOR_SIZE) );
	MDrv_Flash_Erase((U16)(dst/SERFLASH_BLOCK_SIZE), (U16)((dst+0xFFFF)/SERFLASH_BLOCK_SIZE), TRUE);
    }
    while (s32size > 0)
    {
        count = MIN(s32size, FLASH_BUF_SIZE);

        MDrv_MIU_Copy(u32srcaddr, (U16)flash_buf, count, MIU_SDRAM2SDRAM);
        u32srcaddr += count;

        MDrv_Flash_Write(dst,count, flash_buf);
        dst += count;
        s32size -= count;
    }

    MDrv_Flash_WriteProtect(ENABLE);

#if (FLASH_WP_PIN_CONTROL == ENABLE)
    Flash_Write_Protect_Enable();
#endif

    MSAPI_MEMORY_FREE(flash_buf);
}

#if ENABLE_QUICK_DATABASE
/******************************************************************************/
/// API for MIU Store Database::
/// Copy database information from SDRAM to flash
/// @param u32srcaddr \b IN SDRAM address for Database information
/// @param s32size \b IN Database information size
/******************************************************************************/
void msAPI_MIU_QuickDataBaseErase(U8 u8Bank)
{
    U32 dst;

    dst = SYSTEM_BANK_SIZE * u8Bank;
    APIMIU_DBG(printf("msAPI_MIU_QuickDataBaseErase, dst=0x%Lx \r\n", (U32)dst));
#if (FLASH_WP_PIN_CONTROL == ENABLE)
    Flash_Write_Protect_Disable();
#endif
    MDrv_Flash_WriteProtect(DISABLE);
    MDrv_Flash_Erase((U16)(dst/SERFLASH_BLOCK_SIZE), (U16)((dst+0xFFFF)/SERFLASH_BLOCK_SIZE), FALSE);
}

/******************************************************************************/
/// API for MIU Store Database::
/// Copy database information from SDRAM to flash
/// @param u32srcaddr \b IN SDRAM address for Database information
/// @param s32size \b IN Database information size
/******************************************************************************/
BOOLEAN msAPI_MIU_QuickDataBaseCheck(void)
{
    return MDrv_Flash_CheckWriteDone();
}

/******************************************************************************/
/// API for MIU Store Database::
/// Copy database information from SDRAM to flash
/// @param u32srcaddr \b IN SDRAM address for Database information
/// @param s32size \b IN Database information size
/******************************************************************************/
void msAPI_MIU_QuickGenSettingLoad(U8 u8Bank)    // SRAM2Flash
{
    U32 dst;
    U16 count;
    U8 *flash_buf;
    U8 u8i;

    g_u16QuickGenSettingIdx = QUICK_DB_GENST_INVALID_IDX;

    flash_buf = (U8*)msAPI_Memory_Allocate(FLASH_BUF_SIZE);
    if (flash_buf == NULL)
    {
        APIMIU_DBG(printf("malloc flash_buf fail!\r\n"));
        return;
    }

    APIMIU_DBG(printf("StoreDataBase2Flash, src=0x%Lx, dst=0x%Lx,, size=0x%Lx\n", u32srcaddr, (U32)(SYSTEM_BANK_SIZE * u8Bank), s32size));

    dst = (SYSTEM_BANK_SIZE * u8Bank);
    count = QUICK_DB_GENST_NUM;
    MDrv_Flash_Read(dst,count, flash_buf);

    for(u8i = 0; u8i<QUICK_DB_GENST_NUM; u8i++)
    {
       if(flash_buf[u8i] == QUICK_DB_GENST_GOOD)
       {
           g_u16QuickGenSettingIdx = u8i;
           break;
       }
    }


    MSAPI_MEMORY_FREE(flash_buf);
}

/******************************************************************************/
/// API for MIU Store Database::
/// Copy database information from SDRAM to flash
/// @param u32srcaddr \b IN SDRAM address for Database information
/// @param s32size \b IN Database information size
/******************************************************************************/
void msAPI_MIU_QuickGenSettingErase(U8 u8Bank, U8 u8Wait)
{
    U32 dst;

    dst = SYSTEM_BANK_SIZE * u8Bank;
    APIMIU_DBG(printf("msAPI_MIU_QuickGenSettingErase, dst=0x%Lx \r\n", (U32)dst));
#if (FLASH_WP_PIN_CONTROL == ENABLE)
    Flash_Write_Protect_Disable();
#endif
    MDrv_Flash_WriteProtect(DISABLE);
    MDrv_Flash_Erase((U16)(dst/SERFLASH_BLOCK_SIZE), (U16)((dst+0x1FFFF)/SERFLASH_BLOCK_SIZE), u8Wait);
}

/******************************************************************************/
/// API for MIU Store Database::
/// Copy database information from SDRAM to flash
/// @param u32srcaddr \b IN SDRAM address for Database information
/// @param s32size \b IN Database information size
/******************************************************************************/
void msAPI_MIU_QuickGenSettingWrite(U8 u8Bank, U32 u32srcaddr, S32 s32size)    // SRAM2Flash
{
    U32 dst;
    U16 count;
    U8 *flash_buf;

    flash_buf = (U8*)msAPI_Memory_Allocate(FLASH_BUF_SIZE);
    if (flash_buf == NULL)
    {
        APIMIU_DBG(printf("malloc flash_buf fail!\r\n"));
        return;
    }

    APIMIU_DBG(printf("StoreDataBase2Flash, src=0x%Lx, dst=0x%Lx,, size=0x%Lx\n", u32srcaddr, (U32)(SYSTEM_BANK_SIZE * u8Bank), s32size));

#if (FLASH_WP_PIN_CONTROL == ENABLE)
    Flash_Write_Protect_Disable();
#endif

	MDrv_Flash_WriteProtect(DISABLE);

//=====
    dst = (SYSTEM_BANK_SIZE * u8Bank) + (g_u16QuickGenSettingIdx);
    flash_buf[0] = QUICK_DB_GENST_WRITING;
    count = 1;
    MDrv_Flash_Write(dst,count, flash_buf);
//=====

    dst = (SYSTEM_BANK_SIZE * u8Bank) + ((U32)QUICK_DB_GENST_SIZE * (U32)g_u16QuickGenSettingIdx);

    while (s32size > 0)
    {
        count = MIN(s32size, FLASH_BUF_SIZE);

        MDrv_MIU_Copy(u32srcaddr, (U16)flash_buf, count, MIU_SDRAM2SDRAM);
        u32srcaddr += count;

        MDrv_Flash_Write(dst,count, flash_buf);
        dst += count;
        s32size -= count;
    }

//=====
    dst = (SYSTEM_BANK_SIZE * u8Bank) + (g_u16QuickGenSettingIdx);
    flash_buf[0] = QUICK_DB_GENST_GOOD;
    count = 1;
    MDrv_Flash_Write(dst,count, flash_buf);
//=====
    dst = (SYSTEM_BANK_SIZE * u8Bank) + (g_u16QuickGenSettingIdx - 1);
    flash_buf[0] = QUICK_DB_GENST_OBSOLETE;
    count = 1;
    MDrv_Flash_Write(dst,count, flash_buf);
//=====

    MDrv_Flash_WriteProtect(ENABLE);

#if (FLASH_WP_PIN_CONTROL == ENABLE)
    Flash_Write_Protect_Enable();
#endif

    MSAPI_MEMORY_FREE(flash_buf);
}

#endif

/******************************************************************************/
/// API for Database Copy::
/// Memory Copy Interface
/// @param srcaddr \b IN Source address
/// @param dstaddr \b IN Destination address
/// @param len \b IN Size
/******************************************************************************/
void msAPI_MIU_CopyDatabase(U32 srcaddr, U32 dstaddr, U32 len)
{
    MDrv_MIU_XCopy(MCPY_DATABASE, srcaddr, dstaddr, len);
}
#endif

/******************************************************************************/
void msAPI_MIU_SDRAM2Flash(U32 u32srcaddr, U32 u32desaddr, S32 s32size)    // SRAM2Flash
{
    U16 count;
    U8 *flash_buf;

    flash_buf = (U8*)msAPI_Memory_Allocate(FLASH_BUF_SIZE);
    if (flash_buf == NULL)
    {
        //printf("malloc flash_buf fail!\r\n");
        return;
    }

    APIMIU_DBG(printf("StoreSDRAM2Flash, src=0x%Lx, dst=0x%Lx, size=0x%Lx\n", u32srcaddr, u32desaddr, s32size));
    //MDrv_Flash_Erase(u32desaddr, u32desaddr+s32size-1);   //need modify
    MDrv_Flash_Erase((U16)(u32desaddr/SERFLASH_SECTOR_SIZE), (U16)((u32desaddr+s32size-1)/SERFLASH_SECTOR_SIZE), TRUE);
    while (s32size > 0)
    {
        count = MIN(s32size, FLASH_BUF_SIZE);

        MDrv_MIU_Copy(u32srcaddr, (U16)flash_buf, count, MIU_SDRAM2SDRAM);
        u32srcaddr += count;

        MDrv_Flash_Write(u32desaddr, count, flash_buf);
        u32desaddr += count;
        s32size -= count;
    }

    MSAPI_MEMORY_FREE(flash_buf);
}

/******************************************************************************/
void msAPI_MIU_Flash2Xdata(U32 u32srcaddr, U32 u32size, U8* pdat)
{
	MDrv_Flash_Read(u32srcaddr, u32size, pdat);
}

/******************************************************************************/
/// Convert XDATA address in 0x2800-0xBFFF to physical SDRAM address
/// @param u16addr \r\n IN address in XDATA
/// @return physical address in SDRAM
/******************************************************************************/
U32 msAPI_MIU_XData2SDRAMAddr(U16 u16addr)
{
    return (u16addr - XDATASDRAM_START_ADDR);