power.c

6410BSP3

//
// Copyright (c) Microsoft Corporation.  All rights reserved.
//
//
// Use of this sample source code is subject to the terms of the Microsoft
// license agreement under which you licensed this sample source code. If
// you did not accept the terms of the license agreement, you are not
// authorized to use this sample source code. For the terms of the license,
// please see the license agreement between you and Microsoft or, if applicable,
// see the LICENSE.RTF on your install media or the root of your tools installation.
// THE SAMPLE SOURCE CODE IS PROVIDED "AS IS", WITH NO WARRANTIES OR INDEMNITIES.
//
//
// Copyright (c) Samsung Electronics. Co. LTD.  All rights reserved.
//
/*++
THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF
ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO
THE IMPLIED WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A
PARTICULAR PURPOSE.

Module Name:    Power.c

Abstract:       Implementation of Video Driver
                This module handle Power context data

Functions:


Notes:


--*/

#include <bsp.h>
#include "pmplatform.h"
#include "SVEngine.h"

void SVE_initialize_power_context(void)
{
    SVEnginePowerContext *pPMCtxt;

    VDE_MSG((_T("[VDE] SVE_initialize_context()\r\n")));

    pPMCtxt = SVE_get_power_context();

    memset(pPMCtxt, 0x0, sizeof(SVEnginePowerContext));

    pPMCtxt->bPowerOn = TRUE;    // Initially Power On

    // Invalidate All Stored Values
    pPMCtxt->bFIMDOutputParam = FALSE;
    pPMCtxt->bFIMDOutputTV = FALSE;
    pPMCtxt->bFIMDOutputEnable = FALSE;
    pPMCtxt->bFIMDWinMode[DISP_WIN0] = FALSE;
    pPMCtxt->bFIMDWinMode[DISP_WIN1] = FALSE;
    pPMCtxt->bFIMDWinMode[DISP_WIN2] = FALSE;
    pPMCtxt->bFIMDWinMode[DISP_WIN3] = FALSE;
    pPMCtxt->bFIMDWinMode[DISP_WIN4] = FALSE;
    pPMCtxt->bFIMDWinFBuffer[DISP_WIN0] = FALSE;
    pPMCtxt->bFIMDWinFBuffer[DISP_WIN1] = FALSE;
    pPMCtxt->bFIMDWinFBuffer[DISP_WIN2] = FALSE;
    pPMCtxt->bFIMDWinFBuffer[DISP_WIN3] = FALSE;
    pPMCtxt->bFIMDWinFBuffer[DISP_WIN4] = FALSE;
    pPMCtxt->bFIMDColorKey[DISP_WIN0] = FALSE;    // Never Used
    pPMCtxt->bFIMDColorKey[DISP_WIN1] = FALSE;
    pPMCtxt->bFIMDColorKey[DISP_WIN2] = FALSE;
    pPMCtxt->bFIMDColorKey[DISP_WIN3] = FALSE;
    pPMCtxt->bFIMDColorKey[DISP_WIN4] = FALSE;
    pPMCtxt->bFIMDAlpha[DISP_WIN0] = FALSE;        // Never Used
    pPMCtxt->bFIMDAlpha[DISP_WIN1] = FALSE;
    pPMCtxt->bFIMDAlpha[DISP_WIN2] = FALSE;
    pPMCtxt->bFIMDAlpha[DISP_WIN3] = FALSE;
    pPMCtxt->bFIMDAlpha[DISP_WIN4] = FALSE;
    pPMCtxt->bFIMDWinEnable[DISP_WIN0] = FALSE;
    pPMCtxt->bFIMDWinEnable[DISP_WIN1] = FALSE;
    pPMCtxt->bFIMDWinEnable[DISP_WIN2] = FALSE;
    pPMCtxt->bFIMDWinEnable[DISP_WIN3] = FALSE;
    pPMCtxt->bFIMDWinEnable[DISP_WIN4] = FALSE;
    pPMCtxt->bPostParam = FALSE;
    pPMCtxt->bPostSrcBuffer = FALSE;
    pPMCtxt->bPostDstBuffer = FALSE;
    pPMCtxt->bPostStart = FALSE;
    pPMCtxt->bLocalPathWin0Enable = FALSE;
    pPMCtxt->bLocalPathWin1Enable = FALSE;
    pPMCtxt->bLocalPathWin2Enable = FALSE;
    pPMCtxt->bRotatorParam = FALSE;
    pPMCtxt->bRotatorSrcBuffer = FALSE;
    pPMCtxt->bRotatorDstBuffer = FALSE;
    pPMCtxt->bRotatorStart = FALSE;
    pPMCtxt->bTVSCParam = FALSE;
    pPMCtxt->bTVSCSrcBuffer = FALSE;
    pPMCtxt->bTVSCDstBuffer = FALSE;
    pPMCtxt->bTVSCStart = FALSE;
    pPMCtxt->bTVEncParam = FALSE;
    pPMCtxt->bTVEncEnable = FALSE;
}

void SVE_deinitialize_power_context(void)
{
    // Currently, Power Context is static global variable
    // So, we don't need to any deinit procedure
    DEBUGMSG(VDE_ZONE_TEMP, (_T("[VDE] SVE_deinitialize_power_context()\r\n")));
    return;
}

void SVE_video_engine_power_on(void)
{
    SVEngineContext *pCtxt;
    SVEnginePowerContext *pPMCtxt;
    int iWinCnt;

    DEBUGMSG(VDE_ZONE_ENTER, (_T("[VDE] ++SVE_video_engine_power_on()\r\n")));

    pCtxt = SVE_get_context();
    pPMCtxt = SVE_get_power_context();

    if (pPMCtxt->bPowerOn)
    {
        DEBUGMSG(VDE_ZONE_TEMP,(_T("[VDE:INF] SVE_video_engine_power_on() : Video Engine is Already Power On\r\n")));
        goto CleanUp;
    }

    //-------------------------------
    // HW Block Power On and Clock On
    //-------------------------------
    SVE_hw_power_control(HWPWR_DISPLAY_ON);
    SVE_hw_power_control(HWPWR_2D_ON);
    SVE_hw_clock_control(HWCLK_DISPLAY_ON);
    SVE_hw_clock_control(HWCLK_2D_ON);

    //-------------------
    // FIMD Reconfiguration
    //-------------------
    if (pPMCtxt->bFIMDOutputParam)
    {
        Disp_set_output_device_information(&pPMCtxt->tFIMDOutputParam.tRGBDevInfo);
        Disp_set_output_TV_information(pPMCtxt->tFIMDOutputParam.dwTVOutScreenWidth, pPMCtxt->tFIMDOutputParam.dwTVOutScreenHeight);

        if (pPMCtxt->bFIMDOutputTV)
        {
            Disp_initialize_output_interface(DISP_VIDOUT_TVENCODER);
        }
        else
        {
            Disp_initialize_output_interface(DISP_VIDOUT_RGBIF);
        }
    }

    //---------------------------
    // FIMD Window Reconfiguration
    //---------------------------

    for (iWinCnt=DISP_WIN0; iWinCnt< DISP_WIN_MAX; iWinCnt++)
    {
        if (pPMCtxt->bFIMDWinMode[iWinCnt])
        {
            Disp_set_window_mode(pPMCtxt->tFIMDWinMode[iWinCnt].dwWinMode, pPMCtxt->tFIMDWinMode[iWinCnt].dwBPP,
                                    pPMCtxt->tFIMDWinMode[iWinCnt].dwWidth, pPMCtxt->tFIMDWinMode[iWinCnt].dwHeight,
                                    pPMCtxt->tFIMDWinMode[iWinCnt].dwOffsetX, pPMCtxt->tFIMDWinMode[iWinCnt].dwOffsetY);
        }

        if (pPMCtxt->bFIMDWinFBuffer[iWinCnt])
        {
            Disp_set_framebuffer(iWinCnt, pPMCtxt->tFIMDWinFBuffer[iWinCnt].dwFrameBuffer);
        }

        if (pPMCtxt->bFIMDColorKey[iWinCnt])
        {
            Disp_set_color_key(iWinCnt, pPMCtxt->tFIMDColorKey[iWinCnt].bOnOff, pPMCtxt->tFIMDColorKey[iWinCnt].dwDirection,
                                pPMCtxt->tFIMDColorKey[iWinCnt].dwColorKey, pPMCtxt->tFIMDColorKey[iWinCnt].dwCompareKey);
        }

        if (pPMCtxt->bFIMDAlpha[iWinCnt])
        {
            Disp_set_alpha_blending(iWinCnt, pPMCtxt->tFIMDAlpha[iWinCnt].dwMethod,
                                    pPMCtxt->tFIMDAlpha[iWinCnt].dwAlpha0, pPMCtxt->tFIMDAlpha[iWinCnt].dwAlpha1);
        }

        if (pPMCtxt->bFIMDWinEnable[iWinCnt])
        {
            Disp_window_onfoff(iWinCnt, DISP_WINDOW_ON);
            pCtxt->bWindowEnable[iWinCnt] = TRUE;
        }
    }

    //---------------------------
    // Post Processor Reconfiguration
    //---------------------------

    if (pPMCtxt->bPostParam)
    {
        SVE_hw_power_control(HWPWR_POST_ON);
        SVE_hw_clock_control(HWCLK_POST_ON);
        Post_initialize(pPMCtxt->tPostParam.dwOpMode, pPMCtxt->tPostParam.dwScanMode,
                    pPMCtxt->tPostParam.dwSrcType,
                    pPMCtxt->tPostParam.dwSrcBaseWidth, pPMCtxt->tPostParam.dwSrcBaseHeight,
                    pPMCtxt->tPostParam.dwSrcWidth, pPMCtxt->tPostParam.dwSrcHeight,
                    pPMCtxt->tPostParam.dwSrcOffsetX, pPMCtxt->tPostParam.dwSrcOffsetY,
                    pPMCtxt->tPostParam.dwDstType,
                    pPMCtxt->tPostParam.dwDstBaseWidth, pPMCtxt->tPostParam.dwDstBaseHeight,
                    pPMCtxt->tPostParam.dwDstWidth, pPMCtxt->tPostParam.dwDstHeight,
                    pPMCtxt->tPostParam.dwDstOffsetX, pPMCtxt->tPostParam.dwDstOffsetY);

        if (pPMCtxt->bPostSrcBuffer)
        {
            Post_set_source_buffer(pPMCtxt->tPostSrcBuffer.dwBufferRGBY,
                                        pPMCtxt->tPostSrcBuffer.dwBufferCb,
                                        pPMCtxt->tPostSrcBuffer.dwBufferCr);

            Post_set_next_source_buffer(pPMCtxt->tPostSrcBuffer.dwBufferRGBY,
                                        pPMCtxt->tPostSrcBuffer.dwBufferCb,
                                        pPMCtxt->tPostSrcBuffer.dwBufferCr);
        }

        if (pPMCtxt->bPostDstBuffer)
        {

            Post_set_destination_buffer(pPMCtxt->tPostDstBuffer.dwBufferRGBY,
                                        pPMCtxt->tPostDstBuffer.dwBufferCb,
                                        pPMCtxt->tPostDstBuffer.dwBufferCr);

            Post_set_next_destination_buffer(pPMCtxt->tPostDstBuffer.dwBufferRGBY,
                                        pPMCtxt->tPostDstBuffer.dwBufferCb,
                                        pPMCtxt->tPostDstBuffer.dwBufferCr);
        }

        if (pPMCtxt->bPostStart)
        {
            pPMCtxt->bTVSCStart  = FALSE;    // for Trigger Once
            Post_enable_interrupt();
            Post_processing_start();
        }
    }

    //-----------------------
    // TV Scaler Reconfiguration
    //-----------------------

    if (pPMCtxt->bTVSCParam)
    {
        SVE_hw_power_control(HWPWR_TV_ON);
        SVE_hw_clock_control(HWCLK_TV_ON);
        TVSC_initialize(pPMCtxt->tTVSCParam.dwOpMode, pPMCtxt->tTVSCParam.dwScanMode,
                    pPMCtxt->tTVSCParam.dwSrcType,
                    pPMCtxt->tTVSCParam.dwSrcBaseWidth, pPMCtxt->tTVSCParam.dwSrcBaseHeight,
                    pPMCtxt->tTVSCParam.dwSrcWidth, pPMCtxt->tTVSCParam.dwSrcHeight,
                    pPMCtxt->tTVSCParam.dwSrcOffsetX, pPMCtxt->tTVSCParam.dwSrcOffsetY,
                    pPMCtxt->tTVSCParam.dwDstType,
                    pPMCtxt->tTVSCParam.dwDstBaseWidth, pPMCtxt->tTVSCParam.dwDstBaseHeight,
                    pPMCtxt->tTVSCParam.dwDstWidth, pPMCtxt->tTVSCParam.dwDstHeight,
                    pPMCtxt->tTVSCParam.dwDstOffsetX, pPMCtxt->tTVSCParam.dwDstOffsetY);

        if (pPMCtxt->bTVSCSrcBuffer)
        {
            TVSC_set_source_buffer(pPMCtxt->tTVSCSrcBuffer.dwBufferRGBY,
                                        pPMCtxt->tTVSCSrcBuffer.dwBufferCb,
                                        pPMCtxt->tTVSCSrcBuffer.dwBufferCr);

            TVSC_set_next_source_buffer(pPMCtxt->tTVSCSrcBuffer.dwBufferRGBY,
                                        pPMCtxt->tTVSCSrcBuffer.dwBufferCb,
                                        pPMCtxt->tTVSCSrcBuffer.dwBufferCr);
        }

        if (pPMCtxt->bTVSCDstBuffer)
        {
            TVSC_set_destination_buffer(pPMCtxt->tTVSCDstBuffer.dwBufferRGBY,
                                        pPMCtxt->tTVSCDstBuffer.dwBufferCb,
                                        pPMCtxt->tTVSCDstBuffer.dwBufferCr);

            TVSC_set_next_destination_buffer(pPMCtxt->tTVSCDstBuffer.dwBufferRGBY,
                                        pPMCtxt->tTVSCDstBuffer.dwBufferCb,
                                        pPMCtxt->tTVSCDstBuffer.dwBufferCr);
        }

        if (pPMCtxt->bTVSCStart)
        {
            pPMCtxt->bTVSCStart  = FALSE;
            TVSC_enable_interrupt();