hdecoder.c

ct952 source code use for Digital Frame Photo

        OS_YieldThread();
    }


    if (blFBRMode == TRUE)
    {
        // Unlock mutex earily since UV part filling is designed by F/W code (not JPU)
        OS_UnlockMutex(&__mutexGDIIdle);

        // Start fill UV part
        dwFrame_VSize /= 32;
        // Get source picture width
        // LLY2.31, always set source width as 720
        wSrcWidth = 720; // (WORD) REG_DISP_MAIN1_CR;
        wSrcWidth = wSrcWidth/16;

        while(dwFrame_VSize--)
        {
            BYTE bx, by;

            for(bx = 0; bx < wSrcWidth; bx++)
            {
                for(by = 0; by < 64; by+=4)
                {
                    (*(volatile DWORD *)(dwFrame_UV_Addr + by)) = 0x82108082;
                    (*(volatile DWORD *)(dwFrame_UV_Addr + by + 0x40)) = 0x08208210;
                    (*(volatile DWORD *)(dwFrame_UV_Addr + by + 0x80)) = 0x80820820;
                }
                dwFrame_UV_Addr += 192;
            }

            // LLY2.31, it's un-necessary to %4, since source width is always set as 720
            //if (wSrcWidth % 4)
            {
                dwFrame_UV_Addr += 64;
            }
        }
    }
    else
    {
        // fill U-part
        REG_JPU_CTRL       = TRANS_JPU_CTL(0, JPU_FC_U_OP, 1);
        REG_JPU_ADDR_W_ST  = dwFrame_UV_Addr;
        REG_JPU_CTRL |= JPU_GO;
        while (REG_JPU_CTRL & 1)
        {
            // do nothing, just polling
            OS_YieldThread();
        }

        // fill V-part
        REG_JPU_CTRL       = TRANS_JPU_CTL(0, JPU_FC_V_OP, 1);
        REG_JPU_ADDR_W_ST  = dwFrame_UV_Addr + 128;
        REG_JPU_CTRL |= JPU_GO;
        while (REG_JPU_CTRL & 1)
        {
            // do nothing, just polling
            OS_YieldThread();
        }

        // Notice: can unlock mutex after UV part filling is done (since is was done by JPU)
        OS_UnlockMutex(&__mutexGDIIdle);

    }

}


//************************************************************************************
// Description  :   Issue "JPU Preset Frame Buffer Command" to fill the display
//                  frame buffer with desired color
// Reference    :   JPU's JPEG_PresetFrameBuf()
// Argument     :   bColor: the desired color mode
//                  bMode: HAL_CLEAR_SCREEN_MPEG or HAL_CLEAR_SCREEN_JPEG
//                  dwFrameIdx: frame index for MPEG mode
// Return       :   None
//************************************************************************************
void    HAL_ClearScreen(BYTE bColor, BYTE bMode, DWORD dwFrameIdx) //test OK
{
    DWORD   dwColor=0;
    DWORD   dwY_Addr, dwUV_Addr;
    DWORD   dwFBRMode;

    extern WORD  __wFrameWidth;


    // wyc0.85a, set __dwClearBuffMode by the bMode for checking if need to clear frame buffer in HAL_RESET_VIDEO
    __dwClearBuffMode = bMode;
    switch(bColor)
    {
    case HAL_COLOR_USER_DEFINE: //CoCo1.05, Add this for CDG.
        dwColor = _dwHALUserDefinedColor;
        break;
    case    HAL_COLOR_BLUE:
        dwColor = 0x0023d460;
        break;
    case    HAL_COLOR_BLACK:
        dwColor = 0x00008080;
        break;
    case    HAL_COLOR_THUMB:
        dwColor = THUMBNAIL_BACKGROUND_COLOR;
        break;
    case    HAL_COLOR_BORDER:
    default:
#ifdef  BORDER_BLUE
        dwColor = 0x0023d460;
#else
        dwColor = 0x00008080;
#endif
        break;
    }

    if (dwFrameIdx == HAL_DISP_CURRENTFRAME)
    {
        HAL_ReadInfo(HAL_INFO_DISPFRAME_INDEX, &dwFrameIdx);
    }

    // Get the structure pointer of display frame related information.
    // Notice: must give the frame index at 2nd parameter first
    dwY_Addr = dwUV_Addr = dwFrameIdx;
    HAL_ReadInfo(HAL_INFO_DISPFRAME_YADDR, &dwY_Addr);
    HAL_ReadInfo(HAL_INFO_DISPFRAME_UVADDR, &dwUV_Addr);

    // Get FBR mode or not
    HAL_ReadInfo(HAL_INFO_FBR_MODE, &dwFBRMode);

    //DBG_Printf(DBG_THREAD_CHEERDVD, DBG_INFO_PRINTF,
    //    "ClearScreen, Idx: %lx, Y: %lx, UV: %lx, FBR: %lx\n", dwFrameIdx, dwY_Addr, dwUV_Addr, dwFBRMode);

    // LLY2.22, collect clear frame procedure into another API
    _ClearScreen(dwY_Addr, dwUV_Addr, (BOOL)dwFBRMode, __wFrameWidth, dwColor);
}


// LLY2.00, collect the procedure of waiting R/W AM command ACK
//  **************************************************************************
//  Function    :   _Wait_AccessAM_CMD_ACK
//  Description :   Wait access AM command ACK
//  Arguments   :   None
//  Return      :   TRUE, ACK ok
//                  FALSE, ACK fail
//  Notice      :   Only used for AM command ACK
//  **************************************************************************
BYTE    _Wait_AccessAM_CMD_ACK(void)
{
    DWORD   dwHALTemp;
    DWORD   dwAck=1;

    //Wait ACK
    dwHALTemp = OS_GetSysTimer();
    while( (OS_GetSysTimer() - dwHALTemp) < COUNT_200_MSEC )
    {
        dwAck = REG_PLAT_PARAMETER1>>30;
        if (! dwAck )
        {
            break;
        }

        //release CPU resource to other threads
        OS_YieldThread();
    }
    if (dwAck)
    {
        // LLY1.21a, read-back PROC2 PC by macro, don't access AIU directly
        DWORD   dwPC;
        MACRO_PLAT_GET_PROC2_PC(dwPC);

        DBG_Printf(DBG_THREAD_CHEERDVD, DBG_INFO_PRINTF, "\nWait no Proc2 ACK, PC: %lx!", dwPC);
        return FALSE;
    }
    return TRUE;

}


// J500CSC_2.05, for supporting runtime decompressed audio code
DWORD   HAL_LoadAudioCode( BYTE bAudioType, PDWORD pdwAudioTbl, PBYTE pbDstAddr, PBYTE dwWorkMem )
{
    DWORD   dwRet = 0;         // set return value as 0 (error)

#ifdef RUNTIME_UNZIP_AUDIO_CODE
    PSECTION_ENTRY pAudioTbl;

    switch (bAudioType)
    {
        // wyc2.15-909S, update audio decoder re-load mechansim.
        case HAL_AUDIO_PCM:
        case HAL_AUDIO_LPCM:
            pAudioTbl = ROMLD_GetSectionByName(0, "MPPC");
            break;
        case HAL_AUDIO_MPG:
        case HAL_AUDIO_MP3:
        case HAL_AUDIO_MP2:
            pAudioTbl = ROMLD_GetSectionByName(0, "MPPC");
            break;
        case HAL_AUDIO_AC3:
            pAudioTbl = ROMLD_GetSectionByName(0, "ACDT");
            break;
        case HAL_AUDIO_DTS:
            pAudioTbl = ROMLD_GetSectionByName(0, "ACDT");
            break;
        case HAL_AUDIO_WMA:
            pAudioTbl = ROMLD_GetSectionByName(0, "WMA ");
            break;
        case HAL_AUDIO_AAC:
            pAudioTbl = ROMLD_GetSectionByName(0, "AAC ");
            break;
// LLY2.38a, porting Chuan's code to load JPEG decoder @ PROC2
#ifdef SUPPORT_JPEGDEC_ON_PROC2
        case HAL_VIDEO_JPG:
            pAudioTbl = ROMLD_GetSectionByName(0, "JPEG");
            break;
#endif // #ifdef SUPPORT_JPEGDEC_ON_PROC2
        default:
            pAudioTbl = 0;
            break;
    }

    if (pAudioTbl == 0) // 0 means audio decoder does not exist
    {
        return dwRet;
    }

    if ((dwRet = ROMLD_LoadSectionTo(pAudioTbl, (DWORD)pbDstAddr, (DWORD)dwWorkMem)) == 0)
    {
        DBG_Printf(DBG_THREAD_CHEERDVD, DBG_INFO_PRINTF, "Load Audio Code Fail!!");
    }
    /*
    PBYTE   pbSrc;

    if( bAudioType > HAL_AUDIO_END )
    {
        return dwRet;
    }

    pbSrc = (PBYTE) (pdwAudioTbl[((DWORD) bAudioType) - 1]);
    if( (DWORD) pbSrc == 0 )        // 0 means audio decoder does not exist
    {
        return dwRet;
    }

    dwRet = UNZIP2006_DECODE( pbSrc, pbDstAddr, dwWorkMem );
    */

#endif  // RUNTIME_UNZIP_AUDIO_CODE

    return dwRet;
}

//*********************************************************************
// Description :   Reset (reboot) Proc2 and load new audio decoder code
// Arguments   :   bAudioType, specify the new audio type for loading audio code.
// Return      :   NONE
//*********************************************************************
//kevin0.95, create
void HAL_ReloadAudioDecoder(BYTE bAudioType)
{
#ifdef SUPPORT_RUNTIME_RESET_PROC2
#define FIFO_CLEAR         (*((volatile DWORD *) (REG_MCU_BASE+0x014)))
#define FIFO_INTEN         (*((volatile DWORD *) (REG_MCU_BASE+0x01c)))    // Interrupt Control Register 2

    DWORD dwAck=0;
    DWORD dwSaveInt;
    DWORD   dwTime;
    DWORD dwREG_PLAT_TIMER1_RELOAD;

#ifdef NO_PROC2
    return ;
#endif // #ifdef NO_PROC2

    // 1: can runtime reset Proc2 0: can't
    HAL_ReadInfo(HAL_INFO_CAN_RUNTIME_RESET_PROC2, &dwAck);
    if (dwAck==FALSE)
        return;

    // Chuan1.10, Force PROC2 enter debug mode on IU watchpoint, and any trap.
    MACRO_PLAT_HALT_PROC2();

    DBG_Printf(DBG_THREAD_CHEERDVD, DBG_INFO_PRINTF, "reset Proc2\n");

    MACRO_MCU_DISABLE_PROTECTION(MCU_WRITE_PROTECT_AREA1_ENABLE);

// Chuan1.08, Turn on PROM
#ifdef SUPPORT_PROM_DISABLE
    OS_DISABLE_INTERRUPTS( dwSaveInt );
    REG_PLAT_CLK_GENERATOR_CONTROL &= ~(PLAT_MCLK_PROM_DISABLE);
    OS_RESTORE_INTERRUPTS( dwSaveInt );
    // Notice: delay a while to wait PROM enable ok
    OS_DelayTime(COUNT_50_MSEC);
#endif  // #ifdef SUPPORT_PROM_DISABLE

    // LLY2.16, must disable PROC2 interrupt first, and clear the value
    // Since, PROC1 may R/W DM (send interrupt to PROC2) during proc2 disable --> load code
    // So, some un-expected phenomenone will happen.
    // Notice: those procedure can be removed after we remove old DM R/W procedure.
    REG_PLAT_PROC2_INT_MASK_PRIORITY = INT_CLEAR_ALL;
    REG_PLAT_PROC2_INT_CLEAR = INT_SET_ALL;

    //#define SECINTP2A_STAT (*(volatile int *)(0x800001b8))
    //SECINTP2A_STAT = -1;

    // J500KWShih_212, modify "clear audio HW" procedure for > CT909S
#if 0 // only for CT909
    //clear audio HW
	REG_MCU_A1REM=(1<<24)|2;
	FIFO_CLEAR |= (1<<2);
	REG_MCU_PCMREM=(1<<24)|2;
	FIFO_CLEAR |= (1<<3);
	REG_MCU_SPDIFREM=(1<<24)|2;
	FIFO_CLEAR |= ((1<<4)|1);

	REG_AIU_AIUEN &= 0x3;
	FIFO_CLEAR |= 0x7d;
	FIFO_INTEN = 0;

	REG_MCU_A1REM=(1<<24)|0x0;
	REG_MCU_PCMREM=(1<<24)|0x0;
	REG_MCU_SPDIFREM=(1<<24)|0x0;

    REG_MCU_A1REM=(1<<24)|0xffffff;
#endif
	REG_MCU_A1REM = (MCU_REMAINDER_INIT | 0x00);
	REG_MCU_PCMREM = (MCU_REMAINDER_INIT | 0x00);
	REG_MCU_SPDIFREM = (MCU_REMAINDER_INIT | 0x00);

	REG_MCU_MCR5 |= (MCU_RESET_AIU_MIC_WRITE_FIFO | MCU_RESET_AIU_UPK1_FIFO | MCU_RESET_AIU_PCM_READ_FIFO | MCU_RESET_AIU_SPDIF_READ_FIFO);

	REG_AIU_AIUEN &= 0x0303;
	REG_MCU_MCR5 |= 0x7d;
	REG_MCU_MCR7 = 0;


    // J500CSC_111, clear the semaphore for avoiding it is protected by PROC2
    MACRO_PLAT_KEY_UNLOCK( );

    //reset PC
    REG_PLAT_RESET_CONTROL_ENABLE = PLAT_RESET_PROC2_ENABLE; //reset PROC2

    // Chuan1.10, Reset error mode, and exit debug mode.
    MACRO_PLAT_RELEASE_PROC2();

    PROC2_SP = DS_PROC2_SP;
    PROC2_STARTADR = DS_PROC2_STARTADDR;

// J500CSC_2.05, for supporting runtime decompressed audio code
    HAL_LoadAudioCode( bAudioType, (PDWORD) DS_AUDIO_TABLE_ST, (PBYTE) DS_PROC2_STARTADDR,
            (PBYTE) DS_UNZIP_BUF_ST );

    // LLY2.21, Porting Chuan's code to keep time1 value first
    // Since, it will be updated by PROC2
    dwREG_PLAT_TIMER1_RELOAD = REG_PLAT_TIMER1_RELOAD;

    //audio start
    (*(volatile DWORD *)(0x800007e4)) = 0x10003;

    OS_REORDER_BARRIER();
    OS_DISABLE_INTERRUPTS( dwSaveInt );	// Disable INT to avoid different threads accessing

    REG_PLAT_RESET_CONTROL_DISABLE = PLAT_RESET_PROC2_DISABLE; //reset PROC2