display_main.cpp

来自「6410BSP3」· C++ 代码 · 共 1,962 行 · 第 1/5 页

            {
                RETAILMSG(DISP_ZONE_ERROR, (_T("[DISPDRV:ERR] DrvEscape() : IOCTL_POWER_QUERY Exception Occurs\n\r")));
                Result = ESC_FAILED;
            }
        }

        return Result;
    }
    else if(iEsc == IOCTL_POWER_SET)
    {
        RETAILMSG(DISP_ZONE_TEMP, (_T("[DISPDRV] DrvEscape() : IOCTL_POWER_SET\n\r")));

        if(pvOut != NULL && cjOut == sizeof(CEDEVICE_POWER_STATE))
        {
            __try
            {
                CEDEVICE_POWER_STATE NewDx = *(PCEDEVICE_POWER_STATE) pvOut;
                if(VALID_DX(NewDx))
                {
                    RETAILMSG(DISP_ZONE_TEMP, (_T("[DISPDRV] DrvEscape() : IOCTL_POWER_SET(D%d)\n\r"), NewDx));
                    SetDisplayPowerState(PmToVideoPowerState(NewDx));
                    Result = ESC_SUCCESS;
                }
                else
                {
                    RETAILMSG(DISP_ZONE_ERROR, (_T("[DISPDRV:ERR] DrvEscape() : IOCTL_POWER_SET Fail\n\r")));
                    Result = ESC_FAILED;
                }
            }
            __except(GetExceptionCode()==STATUS_ACCESS_VIOLATION ?
               EXCEPTION_EXECUTE_HANDLER : EXCEPTION_CONTINUE_SEARCH)
            {
                RETAILMSG(DISP_ZONE_ERROR, (_T("[DISPDRV:ERR] DrvEscape() : IOCTL_POWER_SET Exception Occurs\n\r")));
                Result = ESC_FAILED;
            }
        }

        return Result;
    }
    else if(iEsc == IOCTL_POWER_GET)
    {
        RETAILMSG(DISP_ZONE_TEMP, (_T("[DISPDRV] DrvEscape() : IOCTL_POWER_GET\n\r")));

        if(pvOut != NULL && cjOut == sizeof(CEDEVICE_POWER_STATE))
        {
            __try
            {
                *(PCEDEVICE_POWER_STATE) pvOut = VideoToPmPowerState(GetDisplayPowerState());

                Result = ESC_SUCCESS;
            }
            __except(GetExceptionCode()==STATUS_ACCESS_VIOLATION ?
               EXCEPTION_EXECUTE_HANDLER : EXCEPTION_CONTINUE_SEARCH)
            {
                RETAILMSG(DISP_ZONE_ERROR, (_T("[DISPDRV:ERR] DrvEscape() : IOCTL_POWER_GET Exception Occurs\n\r")));
                Result = ESC_FAILED;
            }
        }

        return Result;
    }
    else if(iEsc == DRVESC_OUTPUT_RGB)
    {
        if (DevChangeOutputInterface(OUTPUT_IF_RGB))
        {
            return ESC_SUCCESS;
        }
        else
        {
            return ESC_FAILED;
        }
    }
    else if(iEsc == DRVESC_OUTPUT_TV)
    {
        if (DevChangeOutputInterface(OUTPUT_IF_TV))
        {
            return ESC_SUCCESS;
        }
        else
        {
            return ESC_FAILED;
        }
    }
    else if (iEsc == DRVESC_OUTPUT_SWITCH)
    {
        if (m_eOutputInterface == OUTPUT_IF_RGB)
        {
            if (DevChangeOutputInterface(OUTPUT_IF_TV))
            {
                return ESC_SUCCESS;
            }
            else
            {
                return ESC_FAILED;
            }
        }
        else
        {
            if (DevChangeOutputInterface(OUTPUT_IF_RGB))
            {
                return ESC_SUCCESS;
            }
            else
            {
                return ESC_FAILED;
            }
        }
    }
    else if(iEsc == DRVESC_TV_DMA_DISABLE)
    {
        // TODO: We need to implement wrapper OutputDisableTVDMA()...
        EnterCriticalSection(&m_csDevice);
        DevOutputDisableTVDMA();
        m_eTVDMAMode = TV_DMA_DISABLE;
        TVOutReleaseResource();
        LeaveCriticalSection(&m_csDevice);

        return ESC_SUCCESS;
    }
    else if(iEsc == DRVESC_TV_DMA_PRIMARY)
    {
        if (TVOutAllocResource())
        {
            EnterCriticalSection(&m_csDevice);
            DevSetTVDMAMode(TV_DMA_PRIMARY);
            LeaveCriticalSection(&m_csDevice);

            return ESC_SUCCESS;
        }
        else
        {
            return ESC_FAILED;
        }
    }
    else if(iEsc == DRVESC_TV_DMA_OVERLAY)
    {
        if (TVOutAllocResource())
        {
            EnterCriticalSection(&m_csDevice);
            DevSetTVDMAMode(TV_DMA_OVERLAY);
            LeaveCriticalSection(&m_csDevice);

            return ESC_SUCCESS;
        }
        else
        {
            return ESC_FAILED;
        }
    }
    else if(iEsc == DRVESC_G2D_ACCEL_SET)
    {
        RETAILMSG(DISP_ZONE_TEMP, (_T("[DISPDRV] DrvEscape() : DRVESC_G2D_ACCEL\n\r")));
        /// Control Accelerator On/Off
        /// Adjust Acceleration Level (0~0xF0) : Predefined configuration, (0xF1~0xFE) : Reserved, (0xFF) : Force Setting
        ///     L0   0x00      No Accelration and Optimization
        ///     L1   0x01      Only SW Acceleratoin
        ///     L2   0x02      HW BitBlt
        ///     L3   0x04      HW BitBlt + HW Line
        ///     L4   0x08      HW Line + HW BitBlt + HW FillRect

        /// Return Value : Acceleration Level
        ///        Succeed : Accerleration Level ( 1 ~ 3 )
        ///        Fail : 0 (default no accleration)
        if(pvIn != NULL && cjIn == sizeof(G2D_ACCEL_CONTROL_ARGS) && pvOut != NULL && cjOut == sizeof(DWORD))
        {
            __try
            {
                G2D_ACCEL_CONTROL_ARGS NewSetting = *(G2D_ACCEL_CONTROL_ARGS *) pvIn;
                RETAILMSG(DISP_ZONE_TEMP, (_T("[DISPDRV] DrvEscape() : IOCTL_POWER_SET(D%d)\n\r"), NewSetting));
                
                // Detailed Setting.
                if(NewSetting.AccelLevel == 0xFF)
                {
                    m_G2DControlArgs = NewSetting;
                }
                else
                {
                    // Decode Accleration LEVEL
                    switch(NewSetting.AccelLevel & 0xF)
                    {
                    case 0x0:
                        m_G2DControlArgs.AccelLevel = NewSetting.AccelLevel;
                        m_G2DControlArgs.UseSWAccel = 0;
                        m_G2DControlArgs.HWOnOff = 0;
                        m_G2DControlArgs.UseBitBlt = 0;
                        m_G2DControlArgs.UseLineDraw = 0;
                        m_G2DControlArgs.UseAlphaBlend = 0;
                        m_G2DControlArgs.UseFillRect = 0;
                        break;
                    case 0x1:
                        m_G2DControlArgs.AccelLevel = NewSetting.AccelLevel;
                        m_G2DControlArgs.UseSWAccel = 1;
                        m_G2DControlArgs.HWOnOff = 0;
                        m_G2DControlArgs.UseBitBlt = 0;
                        m_G2DControlArgs.UseLineDraw = 0;
                        m_G2DControlArgs.UseAlphaBlend = 0;
                        m_G2DControlArgs.UseFillRect = 0;
                        break;
                    case 0x2:
                        m_G2DControlArgs.AccelLevel = NewSetting.AccelLevel;
                        m_G2DControlArgs.UseSWAccel = 1;
                        m_G2DControlArgs.HWOnOff = 1;
                        m_G2DControlArgs.UseBitBlt = 1;
                        m_G2DControlArgs.UseLineDraw = 0;
                        m_G2DControlArgs.UseAlphaBlend = 0;
                        m_G2DControlArgs.UseFillRect = 0;
                        break;
                    case 0x4:
                        m_G2DControlArgs.AccelLevel = NewSetting.AccelLevel;
                        m_G2DControlArgs.UseSWAccel = 1;
                        m_G2DControlArgs.HWOnOff = 1;
                        m_G2DControlArgs.UseBitBlt = 1;
                        m_G2DControlArgs.UseLineDraw = 1;
                        m_G2DControlArgs.UseAlphaBlend = 1;
                        m_G2DControlArgs.UseFillRect = 0;
                        break;
                    case 0x8:
                        m_G2DControlArgs.AccelLevel = NewSetting.AccelLevel;
                        m_G2DControlArgs.UseSWAccel = 1;
                        m_G2DControlArgs.HWOnOff = 1;
                        m_G2DControlArgs.UseBitBlt = 1;
                        m_G2DControlArgs.UseLineDraw = 1;
                        m_G2DControlArgs.UseAlphaBlend = 1;
                        m_G2DControlArgs.UseFillRect = 1;
                        break;
                    default:
                        //This is invalid level, so we ignore it.
                        Result = ESC_FAILED;
                        break;
                    }

                }
                Result = ESC_SUCCESS;
            }
            __except(GetExceptionCode()==STATUS_ACCESS_VIOLATION ? 
               EXCEPTION_EXECUTE_HANDLER : EXCEPTION_CONTINUE_SEARCH)
            {
                RETAILMSG(DISP_ZONE_ERROR, (_T("[DISPDRV:ERR] DrvEscape() : DRVESC_G2D_ACCEL_SET Exception Occurs\n\r")));
                Result = ESC_FAILED;
            }
        }
        
        return ESC_FAILED;
    }
#if DO_DISPPERF
    else
    {
        return DispPerfDrvEscape(iEsc, cjIn, pvIn, cjOut,pvOut);
    }
#endif

    return 0;
}

int
S3C6410Disp::GetRotateModeFromReg()
{
    HKEY hKey;
    int iRet = DMDO_0;

    RETAILMSG(DISP_ZONE_ENTER, (_T("[DISPDRV] ++%s()\n\r"), _T(__FUNCTION__)));

    if (ERROR_SUCCESS == RegOpenKeyEx(HKEY_LOCAL_MACHINE, TEXT("SYSTEM\\GDI\\ROTATION"), 0, 0, &hKey))
    {
        DWORD dwSize, dwAngle, dwType = REG_DWORD;

        dwSize = sizeof(DWORD);
        if (ERROR_SUCCESS == RegQueryValueEx(hKey, TEXT("ANGLE"), NULL, &dwType, (LPBYTE)&dwAngle, &dwSize))
        {
            switch (dwAngle)
            {
            case 0:
                iRet = DMDO_0;
                break;

            case 90:
                iRet = DMDO_90;
                break;

            case 180:
                iRet = DMDO_180;
                break;

            case 270:
                iRet = DMDO_270;
                break;

            default:
                iRet = DMDO_0;
                break;
            }
        }

        RegCloseKey(hKey);
    }
    else
    {
        RETAILMSG(DISP_ZONE_ERROR, (_T("[DISPDRV:ERR] GetRotateModeFromReg() : RegOpenKeyEx() Fail\n\r")));
    }

    RETAILMSG(DISP_ZONE_ENTER, (_T("[DISPDRV] --%s() = %d\n\r"), _T(__FUNCTION__),iRet));

    return iRet;
}

void
S3C6410Disp::SetRotateParams()
{
    RETAILMSG(DISP_ZONE_ENTER, (_T("[DISPDRV:INF] %s() : Angle = %d\n\r"), _T(__FUNCTION__), m_iRotate));

    switch(m_iRotate)
    {
    case DMDO_90:
    case DMDO_270:
        m_nScreenHeight = m_nScreenWidthSave;
        m_nScreenWidth = m_nScreenHeightSave;
        break;

    case DMDO_0:
    case DMDO_180:
    default:
        m_nScreenWidth = m_nScreenWidthSave;
        m_nScreenHeight = m_nScreenHeightSave;
        break;
    }

    return;
}

LONG
S3C6410Disp::DynRotate(int angle)
{
    GPESurfRotate * pSurf = (GPESurfRotate *)m_pPrimarySurface;

    RETAILMSG(DISP_ZONE_ENTER, (_T("[DISPDRV] ++%s(%d)\n\r"), _T(__FUNCTION__), angle));

    // DirectDraw and rotation can't co-exist.
    if (m_InDDraw)
    {
        RETAILMSG(DISP_ZONE_ERROR, (_T("[DISPDRV:ERR] DynRotate() : Can NOT Rotate in DirectDraw Mode\n\r")));
        return DISP_CHANGE_BADMODE;
    }

    CursorOff();

    // ensure that the angle is not negative and does not exceed 360 degree rotation
    m_iRotate = abs(angle) % 360;

    SetRotateParams();

    m_pMode->width  = m_nScreenWidthSave;
    m_pMode->height = m_nScreenHeightSave;

    pSurf->SetRotation(m_nScreenWidth, m_nScreenHeight, angle);

    CursorOn();

    RETAILMSG(DISP_ZONE_ENTER, (_T("[DISPDRV] --%s()\n\r"), _T(__FUNCTION__)));

    return DISP_CHANGE_SUCCESSFUL;
}


BOOL
S3C6410Disp::AllocResource(void)
{
    PHYSICAL_ADDRESS    ioPhysicalBase = { 0, 0};

    DWORD dwBytes;
    RETAILMSG(DISP_ZONE_ENTER, (_T("[DISPDRV] ++%s\n\r"),_T(__FUNCTION__)));

    ioPhysicalBase.LowPart = S3C6410_BASE_REG_PA_DISPLAY;
    m_pDispConReg = (S3C6410_DISPLAY_REG *)MmMapIoSpace(ioPhysicalBase, sizeof(S3C6410_DISPLAY_REG), FALSE);
    if (m_pDispConReg == NULL)
    {
        goto CleanUp;
    }
    
    ioPhysicalBase.LowPart = S3C6410_BASE_REG_PA_GPIO;
    m_pGPIOReg = (S3C6410_GPIO_REG *)MmMapIoSpace(ioPhysicalBase, sizeof(S3C6410_GPIO_REG), FALSE);
    if (m_pGPIOReg == NULL)
    {
        goto CleanUp;
    }

    ioPhysicalBase.LowPart = S3C6410_BASE_REG_PA_SPI0;
    m_pSPIReg = (S3C6410_SPI_REG *)MmMapIoSpace(ioPhysicalBase, sizeof(S3C6410_SPI_REG), FALSE);
    if (m_pSPIReg == NULL)
    {
        goto CleanUp;
    }

    // Open Video Engine Driver