s3c2450disp.cpp

SMDK2416_BSP

			)
		{
			// The escape is supported.
			return 1;
		}
		else
		{
			// The escape isn't supported.
#if DO_DISPPERF
			return DispPerfQueryEsc(*(DWORD*)pvIn);;
#else
			return 0;
#endif
		}

	}
    else if (iEsc == DRVESC_GETSCREENROTATION)
    {
        *(int *)pvOut = ((DMDO_0 | DMDO_90 | DMDO_180 | DMDO_270) << 8) | ((BYTE)m_iRotate);
        return DISP_CHANGE_SUCCESSFUL;
    }
    else if (iEsc == DRVESC_SETSCREENROTATION)
    {
        if ((cjIn == DMDO_0)   ||
            (cjIn == DMDO_90)  ||
            (cjIn == DMDO_180) ||
            (cjIn == DMDO_270) )
            {
                return DynRotate(cjIn);
            }

        return DISP_CHANGE_BADMODE;
    }
    else if (iEsc == GETGXINFO)
    {
        return GetGameXInfo(iEsc, cjIn, pvIn, cjOut, pvOut);
    }
    else if (iEsc == SETPOWERMANAGEMENT)
    {
        if ((cjIn >= sizeof (VIDEO_POWER_MANAGEMENT)) && (pvIn != NULL))
        {
            PVIDEO_POWER_MANAGEMENT pvpm = (PVIDEO_POWER_MANAGEMENT)pvIn;
			
            if (pvpm->Length >= sizeof (VIDEO_POWER_MANAGEMENT))
            {
                switch (pvpm->PowerState)
                {
				case VideoPowerStandBy:
				case VideoPowerOn:
					SetDisplayPower(VideoPowerOn);
					Result = ESC_SUCCESS;
                    break;
					
				case VideoPowerOff:
				case VideoPowerSuspend:
					SetDisplayPower(VideoPowerOff);
					Result = ESC_SUCCESS;
                    break;
                }
            }
        }
		
        if (Result != ESC_SUCCESS)
        {
            // Shouldn't get here if everything was ok.
            SetLastError(ERROR_INVALID_PARAMETER);
            Result = ESC_FAILED;
        }
		return Result;
	}
	else if (iEsc == GETPOWERMANAGEMENT)
	{
		RETAILMSG(1, (L"GETPOWERMANAGEMENT\n"));
        if ((cjOut >= sizeof (VIDEO_POWER_MANAGEMENT)) && (pvOut != NULL))
        {
            PVIDEO_POWER_MANAGEMENT pvpm = (PVIDEO_POWER_MANAGEMENT)pvOut;
			
            pvpm->Length = sizeof (VIDEO_POWER_MANAGEMENT);
            pvpm->DPMSVersion = 0;
			
            pvpm->PowerState = m_VideoPowerState;
			
            Result = ESC_SUCCESS;
        }
        else
        {
            // Shouldn't get here if everything was ok.
            SetLastError(ERROR_INVALID_PARAMETER);
            Result = ESC_FAILED;
        }
		return Result;
    }
    else if (iEsc == IOCTL_POWER_CAPABILITIES)
    {
        // tell the power manager about ourselves
 //       RETAILMSG(0, (L"%s: IOCTL_POWER_CAPABILITIES\r\n", pszFname));
        if (pvOut != NULL && cjOut == sizeof(POWER_CAPABILITIES))
        {
            __try
            {
                PPOWER_CAPABILITIES ppc = (PPOWER_CAPABILITIES) pvOut;
                memset(ppc, 0, sizeof(*ppc));
                ppc->DeviceDx = 0x11;	// support D0 and D4
                Result = ESC_SUCCESS;
            }
            __except(EXCEPTION_EXECUTE_HANDLER)
            {
                RETAILMSG(0, (L"%s: exception in ioctl1\r\n"));
            }
        }
        return Result;
    }
	else if(iEsc == IOCTL_POWER_QUERY)
	{
        if(pvOut != NULL && cjOut == sizeof(CEDEVICE_POWER_STATE))
        {
            // return a good status on any valid query, since we are always ready to
            // change power states.
            __try
            {
                CEDEVICE_POWER_STATE NewDx = *(PCEDEVICE_POWER_STATE) pvOut;
                if(VALID_DX(NewDx))
                {
                    // this is a valid Dx state so return a good status
                    Result = ESC_SUCCESS;
                }
//                RETAILMSG(0, (L"%s: IOCTL_POWER_QUERY %u %s\r\n", pszFname, 
//					NewDx, Result == ESC_SUCCESS ? L"succeeded" : L"failed"));
            }
            __except(EXCEPTION_EXECUTE_HANDLER)
            {
                RETAILMSG(0, (L"%s: exception in ioctl2\r\n"));
            }
        }
        return Result;
	}
	else if(iEsc == IOCTL_POWER_SET)	
	{		
        if(pvOut != NULL && cjOut == sizeof(CEDEVICE_POWER_STATE))
        {
            __try
            {
                CEDEVICE_POWER_STATE NewDx = *(PCEDEVICE_POWER_STATE) pvOut;
                CEDEVICE_POWER_STATE CurrentDx;
                if(VALID_DX(NewDx))
                {
                    VIDEO_POWER_STATE ulPowerState = PmToVideoPowerState(NewDx);

                    SetDisplayPower(ulPowerState);

                    CurrentDx = VideoToPmPowerState((VIDEO_POWER_STATE)m_VideoPowerState);

                    Result = ESC_SUCCESS;
 //                   RETAILMSG(0, (L"%s: IOCTL_POWER_SET %u: passing back %u\r\n", pszFname,
//						NewDx, CurrentDx));
                }
                else
                {
//                    RETAILMSG(0, 
//						(L"%s: IOCTL_POWER_SET: invalid state request %u\r\n", pszFname, NewDx));
                }
            }
            __except(EXCEPTION_EXECUTE_HANDLER)
            {
                RETAILMSG(0, (L"%s: exception in ioctl3\r\n"));
            }
        }
        return Result;
	}
	else if(iEsc == IOCTL_POWER_GET)
	{
        if(pvOut != NULL && cjOut == sizeof(CEDEVICE_POWER_STATE))
        {
            __try
            {
                CEDEVICE_POWER_STATE CurrentDx = D0;//VideoToPmPowerState((VIDEO_POWER_STATE)m_VideoPowerState);
                *(PCEDEVICE_POWER_STATE) pvOut = D0; //CurrentDx;
                Result = ESC_SUCCESS;
//                RETAILMSG(0, (L"%s: IOCTL_POWER_GET: passing back %u\r\n", pszFname, 
//					CurrentDx));
            }
            __except(EXCEPTION_EXECUTE_HANDLER)
            {
                RETAILMSG(0, (L"%s: exception in ioctl4\r\n"));
            }
        }
        return Result;
	}
#if DO_DISPPERF	
	else {
		return DispPerfDrvEscape(iEsc, cjIn, pvIn, cjOut,pvOut);
	}
#else
	return 0;
#endif
}

#undef ESC_NOT_SUPPORTED
#undef ESC_FAILED
#undef ESC_SUCCESS

void S3C2450DISP::SetDisplayPower(ULONG PowerState)
{
	static BYTE * pVideoMemory = NULL;
//	WORD *ptr;
	RETAILMSG(0,(_T("++SetDisplayPower\r\n")));

    // If we're already in the appropriate state, just return 
    if (m_VideoPowerState == PowerState)
    {
        return;
    }

    if (PowerState == VideoPowerOff)
    {
    	RETAILMSG(0,(TEXT("VideoPowerOff\n")));
        m_VideoPowerState = VideoPowerOff;
		m_pLCDReg->WIN0MAP |= 1<<24;
		m_pLCDReg->WIN1MAP |= 1<<24;
		Sleep(100);

    }
    else
    {
		RETAILMSG(0,(TEXT("VideoPowerOn\n")));
        m_VideoPowerState = VideoPowerOn;
		m_pLCDReg->WIN0MAP &= ~(1<<24);
		m_pLCDReg->WIN1MAP &= ~(1<<24);

    }
}

int
S3C2450DISP::GetRotateModeFromReg()
{
    HKEY hKey;

    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:
                return DMDO_0;

            case 90:
                return DMDO_90;

            case 180:
                return DMDO_180;

            case 270:
                return DMDO_270;

            default:
                return DMDO_0;
            }
        }

        RegCloseKey(hKey);
    }

    return DMDO_0;
}

void
S3C2450DISP::SetRotateParams()
{
    int iswap;

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

    case DMDO_180:
        m_nScreenHeightSave = m_nScreenHeight;
        m_nScreenWidthSave  = m_nScreenWidth;
        break;

    case DMDO_90:
    case DMDO_270:
        iswap               = m_nScreenHeight;
        m_nScreenHeight     = m_nScreenWidth;
        m_nScreenWidth      = iswap;
        m_nScreenHeightSave = m_nScreenWidth;
        m_nScreenWidthSave  = m_nScreenHeight;
        break;

    default:
        m_nScreenHeightSave = m_nScreenHeight;
        m_nScreenWidthSave  = m_nScreenWidth;
        break;
    }

    return;
}


LONG
S3C2450DISP::DynRotate(
    int angle
    )
{
    GPESurfRotate * pSurf = (GPESurfRotate *)m_pPrimarySurface;
	
    // DirectDraw and rotation can't co-exist.
    if (m_InDDraw)
    {
        return DISP_CHANGE_BADMODE;
    }
/*
    if (angle == m_iRotate)
    {
        return DISP_CHANGE_SUCCESSFUL;
    }*/

    CursorOff();

    m_iRotate = angle;

    switch(m_iRotate)
    {
    case DMDO_0:
    case DMDO_180:
        m_nScreenHeight = m_nScreenHeightSave;
        m_nScreenWidth  = m_nScreenWidthSave;
        break;

    case DMDO_90:
    case DMDO_270:
        m_nScreenHeight = m_nScreenWidthSave;
        m_nScreenWidth  = m_nScreenHeightSave;
        break;
    }

    m_pMode->width  = m_nScreenWidth;
    m_pMode->height = m_nScreenHeight;

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

    CursorOn();

    return DISP_CHANGE_SUCCESSFUL;
}

void S3C2450DISP::EnableInterrupt()
{
	m_pLCDReg->VIDINTCON |= (0x1<<12)|(0x1<<0);	/// Video Frame Disalbe
	/*
    m_pIntrReg->INTSUBMSK &= ~(1 << IRQ_SUB_LCD3);							// Disable Interrupt
    m_pIntrReg->INTMSK &= ~(1 << IRQ_LCD);									// Disable Interrupt
	*/
}

void S3C2450DISP::DisableInterrupt()
{
	m_pLCDReg->VIDINTCON &= ~((0x1<<12)|(0x1<<0));	/// Video Frame Disalbe
	/*
    m_pIntrReg->INTSUBMSK |= 1 << IRQ_SUB_LCD3;							// Disable Interrupt
    m_pIntrReg->INTMSK |= 1 << IRQ_LCD;									// Disable Interrupt	
    */
}


ULONG *
APIENTRY
DrvGetMasks(
    DHPDEV dhpdev
    )
{
    return gBitMasks;
}