fimgse2d.cpp

SAMSUNG S3C6410 CPU BSP for winmobile6

//
// Copyright (c) Samsung Electronics. Co. LTD.  All rights reserved.
//
/*++
THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF
ANY KIND, EITHER IMPLIED, INCLUDING BUT NOT LIMITED TO
THE IMPLIED WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A
PARTICULAR PURPOSE.
--*/
/**
*    @file        fimgse2d.cpp
*    @brief    hardware control implementation for FIMGSE-2D v2.0, This class is a kind of adapter
*    @author    Jiwon Kim
*    
*    @note This version is made for S3C6410.
*/

#include <windows.h>
#include <winddi.h>
#include <emul.h>
#include <ceddk.h>
#include <nkintr.h>
#include <s3c6410.h>
#include <DrvLib.h>
#include <bsp.h>
#include "fimgse2d.h"
#include "regctrl_g2d.h"

#define     HW_PROBE        0
#define    ZONE_NONE        (0)
#define    ZONE_BITBLT    (1<<0)
#define    ZONE_STRETCHBLT    (1<<1)
#define    ZONE_LINE        (1<<2)
#define    ZONE_FLIPBLT    (1<<3)
#define    ZONE_TEMPORARY    (1<<4)
#define    DBG_ZONE        (ZONE_NONE)//(ZONE_BITBLT)
#define    ZONE_CHECK(checkedzone)        (((DBG_ZONE&(checkedzone))==(checkedzone)) ? (1) :(0))

#undef SWAP
#define SWAP(a,b,type) { type tmp=a; a=b; b=tmp; }

#if HW_PROBE    // For check HW consume time, insert GPIO LED triggering code.

static volatile S3C6410_GPIO_REG *g_pGPIORegs = NULL;
#define    PROBE_BIT        (13)
#define    PROBE_TRIGGER_OFF(structure, port)         {structure##->##port##DAT &= ~(1<<PROBE_BIT);}
#define    PROBE_TRIGGER_ON(structure, port)        {structure##->##port##DAT |= (1<<PROBE_BIT);}
#endif

FIMGSE2D::FIMGSE2D() : RegCtrlG2D()
{
//    Reset();
        m_iROPMapper[ROP_SRC_ONLY] = G2D_ROP_SRC_ONLY;
        m_iROPMapper[ROP_PAT_ONLY] = G2D_ROP_PAT_ONLY;
        m_iROPMapper[ROP_DST_ONLY] = G2D_ROP_DST_ONLY;
        m_iROPMapper[ROP_SRC_OR_DST] = G2D_ROP_SRC_OR_DST;
        m_iROPMapper[ROP_SRC_OR_PAT] = G2D_ROP_SRC_OR_PAT;
        m_iROPMapper[ROP_DST_OR_PAT] = G2D_ROP_DST_OR_PAT;
        m_iROPMapper[ROP_SRC_AND_DST] = G2D_ROP_SRC_AND_DST;
        m_iROPMapper[ROP_SRC_AND_PAT] = G2D_ROP_SRC_AND_PAT;
        m_iROPMapper[ROP_DST_AND_PAT] = G2D_ROP_DST_AND_PAT;
        m_iROPMapper[ROP_SRC_XOR_DST] = G2D_ROP_SRC_XOR_DST;
        m_iROPMapper[ROP_SRC_XOR_PAT] = G2D_ROP_SRC_XOR_PAT;
        m_iROPMapper[ROP_DST_XOR_PAT] = G2D_ROP_DST_XOR_PAT;
        m_iROPMapper[ROP_NOTSRCCOPY] = G2D_ROP_NOTSRCCOPY;
        m_iROPMapper[ROP_DSTINVERT] = G2D_ROP_DSTINVERT;
        m_iROPMapper[ROP_R2_NOTCOPYPEN] = G2D_ROP_R2_NOTCOPYPEN;

        m_iColorModeMapper[gpe1Bpp] = -1;
        m_iColorModeMapper[gpe2Bpp] = -1;
        m_iColorModeMapper[gpe4Bpp] = -1;
        m_iColorModeMapper[gpe8Bpp] = -1;
        m_iColorModeMapper[gpe16Bpp] = G2D_COLOR_RGB_565;
        m_iColorModeMapper[gpe24Bpp] = G2D_COLOR_XRGB_8888;
        m_iColorModeMapper[gpe32Bpp] = -1;
        m_iColorModeMapper[gpe16YCrCb] = -1;
        m_iColorModeMapper[gpeDeviceCompatible] = -1;        
        m_iColorModeMapper[gpeUndefined] = G2D_COLOR_UNUSED;                
            
}

FIMGSE2D::~FIMGSE2D()
{
}

// Set Ternary raster operation
// Support 256 raster operation
// Refer to ternary raster operation table if you know 256 ROP

// Set Alpha Value
void FIMGSE2D::SetAlphaValue(BYTE ucAlphaVal)
{
    ucAlphaVal &= 0xff;
    m_pG2DReg->ALPHA = (m_pG2DReg->ALPHA&(~0xff)) | ucAlphaVal;
}

// Set alpha blending mode
void FIMGSE2D::SetAlphaMode(G2D_ALPHA_BLENDING_MODE eMode)
{
    DWORD uAlphaBlend;

    uAlphaBlend =
        (eMode == G2D_NO_ALPHA_MODE) ? G2D_NO_ALPHA_BIT :
        (eMode == G2D_PP_ALPHA_SOURCE_MODE) ? G2D_PP_ALPHA_SOURCE_BIT :
        (eMode == G2D_ALPHA_MODE) ? G2D_ALPHA_BIT : 
        (eMode == G2D_FADING_MODE) ? G2D_FADING_BIT : G2D_NO_ALPHA_BIT;

    m_pG2DReg->ROP = (m_pG2DReg->ROP & ~(0x7<<10)) | uAlphaBlend;
}

// Set fade value
void FIMGSE2D::SetFadingValue(BYTE ucFadeVal)
{
    ucFadeVal &= 0xff;
    m_pG2DReg->ALPHA = (m_pG2DReg->ALPHA & ~(0xff<<8)) | (ucFadeVal<<8);
}

void FIMGSE2D::DisableEffect(void)
{
    m_pG2DReg->ROP &= ~(0x7<<10);
}

void FIMGSE2D::EnablePlaneAlphaBlending(BYTE ucAlphaVal)
{
    ucAlphaVal &= 0xff;

    // Set Alpha Blending Mode
    m_pG2DReg->ROP = ((m_pG2DReg->ROP) & ~(0x7<<10)) | G2D_ALPHA_BIT;


    // Set Alpha Value
    m_pG2DReg->ALPHA = ((m_pG2DReg->ALPHA) & ~(0xff)) | ucAlphaVal;

    m_ucAlphaVal = ucAlphaVal;
    m_bIsAlphaCall = true;
}

void FIMGSE2D::DisablePlaneAlphaBlending(void)
{
    DisableEffect();
}

void FIMGSE2D::EnablePixelAlphaBlending(void) // Only Support 24bpp and Only used in BitBlt
{

    Assert( (m_iColorModeMapper[m_descDstSurface.dwColorMode] != -1) && (m_iColorModeMapper[m_descDstSurface.dwColorMode] != gpe24Bpp) );

    m_pG2DReg->ROP = ((m_pG2DReg->ROP) & ~(0x7<<10)) | G2D_PP_ALPHA_SOURCE_BIT;
}

void FIMGSE2D::DisablePixelAlphaBlending(void) // Only Support 24bpp and only used in BitBlt
{
    Assert( (m_iColorModeMapper[m_descDstSurface.dwColorMode] != -1) && (m_iColorModeMapper[m_descDstSurface.dwColorMode] != gpe24Bpp) );
    DisableEffect();
}

void FIMGSE2D::EnableFadding(BYTE ucFadingVal)
{
    BYTE ucAlphaVal;

    ucAlphaVal = (m_bIsAlphaCall == true) ? m_ucAlphaVal : 255;

    ucFadingVal &= 0xff;

    // Set Fadding Mode    
    m_pG2DReg->ROP = ((m_pG2DReg->ROP) & ~(0x7<<10)) | G2D_FADING_BIT;

    // Set Fadding Value    
    m_pG2DReg->ALPHA = ((m_pG2DReg->ALPHA) & ~(0xff<<8)) | (ucFadingVal<<8) | (ucAlphaVal<<0);
}

void FIMGSE2D::DisableFadding(void)
{
    DisableEffect();
}



/**
*    @fn    FIMGSE2D::GetRotType(int m_iRotate)
*    @brief    This function convert rotation degree value to ROT_TYPE
*
*/
ROT_TYPE FIMGSE2D::GetRotType(int m_iRotate)
{
    switch(m_iRotate)
    {
        case DMDO_0:    
            return    ROT_0;
        case DMDO_90:
            return    ROT_270;
        case DMDO_180:
            return    ROT_180;
        case DMDO_270:
            return    ROT_90;
        default:    
            return    ROT_0;
    }
    return ROT_0;    
}

/**
*    @fn    DWORD FIMGSE2D::CalculateXYIncrFormat(DWORD uDividend, DWORD uDivisor)
*    @brief    This function returns x_incr or y_incr vaule in register format
*    @input    this function accept real pixel coordinate, ex) (0,0)~(9,9) means that 10pixel by pixel image
*    @return    Result value
*/
DWORD FIMGSE2D::CalculateXYIncrFormat(DWORD uDividend, DWORD uDivisor)
{
    int i;
    DWORD uQuotient;
    DWORD uUnderPoint=0;

//    printf("\nuDivend:%x(%d), uDivisor:%x(%d), uUnderPoint:%x(%d)", uDividend, uDividend, uDivisor, uDivisor,uUnderPoint, uUnderPoint);    

    Assert(uDivisor != 0);
    if(uDivisor == 0)
    {
        uDivisor = 1;    //< this will prevent data abort. but result is incorrect.
    }

    uQuotient = (DWORD)(uDividend/uDivisor);

    Assert(uQuotient <= 2048); // Quotient should be less than 2048.

    uDividend-=(uQuotient*uDivisor);

    /// Now under point is calculated.
    for (i=0; i<12; i++)
    {
        uDividend <<= 1;
        uUnderPoint <<= 1;
        
        if (uDividend >= uDivisor)
        {
            uUnderPoint = uUnderPoint | 1;
            uDividend -= uDivisor;
        }
//        printf("\nuDivend:%x(%d), uDivisor:%x(%d), uUnderPoint:%x(%d)", uDividend, uDividend, uDivisor, uDivisor,uUnderPoint, uUnderPoint);
    }

    uUnderPoint = (uUnderPoint + 1) >> 1;

    return ( uUnderPoint|(uQuotient<<11) );
}

/**
*    @fn    FIMGSE2D::BitBlt(PRECTL prclSrc, PRECTL prclDst, ROT_TYPE m_iRotate)
*    @param    prclSrc    Source Rectangle
*    @param    prclDst    Destination Rectangle
*    @param    m_iRotate    Rotatation Degree. See also ROT_TYPE type
*    @note This funciton performs real Bit blit using 2D HW. this functio can handle rotation case.
*            There's predefine macro type for presenting rotation register's setting value
*            G2D_ROTATION
@    @sa    ROT_TYPE    this can be set mixed value.
*/
void FIMGSE2D::BitBlt(PRECTL prclSrc, PRECTL prclDst, ROT_TYPE m_iRotate )
{
    DWORD uCmdRegVal=0;
    RECT    rectDst;            //< If rotation case this value must be corrected.
    
    RETAILMSG(ZONE_CHECK(ZONE_BITBLT),(TEXT("[2DHW] BitBlt Entry\r\n")));    

    /// Always LeftTop Coordinate is less than RightBottom for Source and Destination Region
    Assert( (prclSrc->left < prclSrc->right) && (prclSrc->top < prclSrc->bottom) );
    Assert( (prclDst->left < prclDst->right) && (prclDst->top < prclDst->bottom) );    

    /// Set Destination's Rotation mode
    SetRotationMode(m_iRotate);        
    SetCoordinateSrcBlock(prclSrc->left, prclSrc->top, prclSrc->right - 1, prclSrc->bottom - 1);    

    if(m_iRotate == ROT_180)        //< origin set to (x2,y2)
    {
        rectDst.left = prclDst->right - 1;                        //< x2
        rectDst.top = prclDst->bottom - 1;                        //< y2
        rectDst.right = 2 * (prclDst->right - 1) - prclDst->left ;        //< x2 + (x2 - x1)
        rectDst.bottom = 2 * (prclDst->bottom -1) - prclDst->top;    //< y2 + (y2 - y1)
    }
    else     if(m_iRotate == ROT_90)        //<In this time, Height and Width are swapped.    
    {
        rectDst.left = prclDst->right - 1;                        //< x2
        rectDst.right = prclDst->right - 1 + prclDst->bottom - 1 - prclDst->top;    //< x2 + (y2 - y1)
        rectDst.top = prclDst->top;                                        //< y1
        rectDst.bottom = prclDst->top + prclDst->right - 1 - prclDst->left;        //< y1 + (x2 - x1)
    }
    else     if(m_iRotate == ROT_270)        //<In this time, Height and Width are swapped.    
    {
        rectDst.left = prclDst->left;                            //< x1
        rectDst.right = prclDst->left + prclDst->bottom - 1- prclDst->top;        //< x1 + (y2 - y1)
        rectDst.top = prclDst->bottom - 1;                                    //< y2
        rectDst.bottom = prclDst->bottom - 1 + prclDst->right - 1- prclDst->left;    //< y2 + (x2 - x1)
    }    
    else        //< ROT_0
    {
        rectDst.left = prclDst->left;
        rectDst.top = prclDst->top;        
        rectDst.right = prclDst->right - 1;
        rectDst.bottom = prclDst->bottom - 1;
    }

    SetRotationOrg((WORD)rectDst.left, (WORD)rectDst.top);    
    SetCoordinateDstBlock(rectDst.left, rectDst.top, rectDst.right, rectDst.bottom);            

        RETAILMSG(ZONE_CHECK(ZONE_BITBLT),(TEXT("ROT:%d, Src:(%d,%d)~(%d,%d), Dst:(%d,%d)~(%d,%d)\r\n"), 
            m_iRotate, prclSrc->left, prclSrc->top, prclSrc->right, prclSrc->bottom, 
            rectDst.left, rectDst.top, rectDst.right, rectDst.bottom));

    uCmdRegVal = G2D_NORMAL_BITBLT_BIT;
    
//    WaitForIdleStatus();        //< When only Engine is idle, 2D Engine runs.    

#if    (G2D_CMDPROCESSING==G2D_FASTRETURN)
    WaitForEmptyFifo();        //< This is check fully empty command fifo.
    m_pG2DReg->CMDR1 = uCmdRegVal;        // Process Only One Instruction per bitblt request
#elif (G2D_CMDPROCESSING==G2D_INTERRUPT)
    CheckFifo(1);    

#if HW_PROBE    // For check HW consume time, insert GPIO LED triggering code.
    PROBE_TRIGGER_ON(g_pGPIORegs, GPN);
#endif
    IntEnable();    
//x    while(!WaitForFinish());                        // Polling Style    
    m_pG2DReg->CMDR1 = uCmdRegVal;        // Process Only One Instruction per bitblt request
    WaitForSingleObject(m_hInterrupt2D, INFINITE);

#if HW_PROBE    // For check HW consume time, insert GPIO LED triggering code.
    PROBE_TRIGGER_OFF(g_pGPIORegs, GPN);
#endif        

    IntDisable();    
    IntPendingClear();    

    InterruptDone(m_dwSysIntr2D);
#elif (G2D_CMDPROCESSING==G2D_BUSYWAITING)
    CheckFifo(1);
    
    IntEnable();    
    while(!WaitForFinish());                        // Polling Style    
    m_pG2DReg->CMDR1 = uCmdRegVal;        // Process Only One Instruction per bitblt request

    IntDisable();    
#else
    RETAILMSG(TRUE,(TEXT("CMDPROCESSING TYPE is invalid, Please Check Header Definition\n")));
    return FALSE;
#endif

    RETAILMSG(ZONE_CHECK(ZONE_BITBLT),(TEXT("[2DHW] BitBlt Exit\r\n")));            
    /// TODO: Resource Register clearing can be needed.

}

/**
*    @fn    FIMGSE2D::GetCompensatedOffset(PRECTL prclSrc, PRECTL prclDst, ROT_TYPE m_iRotate)