s3c2443disp.cpp

2443 wince5.0 bsp, source code

	switch(vps)
	{
	case VideoPowerOn:
		pmDx = D0;
		break;

	case VideoPowerStandBy:
		pmDx = D1;
		break;

	case VideoPowerSuspend:
		pmDx = (CEDEVICE_POWER_STATE)D2;
		break;

	case VideoPowerOff:
		pmDx = (CEDEVICE_POWER_STATE)D4;
		break;

	default:
		pmDx = D0;
		RETAILMSG(0, (L"VideoToPmPowerState: mapping unknown video state %d to pm state %d\r\n",
		         vps, pmDx));
		break;
	}

	return pmDx;
}

#define ESC_SUCCESS             0x00000001
#define ESC_FAILED              0xFFFFFFFF
#define ESC_NOT_SUPPORTED       0x00000000
ULONG
S3C2443DISP::DrvEscape(
    SURFOBJ * pso,
    ULONG     iEsc,
    ULONG     cjIn,
    void    * pvIn,
    ULONG     cjOut,
    void    * pvOut
    )
{
    ULONG Result = 0;	
    if (iEsc == QUERYESCSUPPORT)
    {
        if (*(DWORD*)pvIn == GETGXINFO
            || *(DWORD*)pvIn == DRVESC_GETSCREENROTATION
            || *(DWORD*)pvIn == DRVESC_SETSCREENROTATION
            || *(DWORD*)pvIn == SETPOWERMANAGEMENT
            || *(DWORD*)pvIn == GETPOWERMANAGEMENT
			|| *(DWORD*)pvIn == IOCTL_POWER_CAPABILITIES
			|| *(DWORD*)pvIn == IOCTL_POWER_QUERY
			|| *(DWORD*)pvIn == IOCTL_POWER_SET
			|| *(DWORD*)pvIn == IOCTL_POWER_GET            
            )
        {
            // The escape is supported.
            return 1;
        }
        else
        {
            // The escape isn't supported.
            return 0;
        }
    }
    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;
	}

    return 0;
}

#undef ESC_NOT_SUPPORTED
#undef ESC_FAILED
#undef ESC_SUCCESS

void S3C2443DISP::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)
    {
        m_VideoPowerState = VideoPowerOff;
		
        m_CursorDisabled = TRUE;
        CursorOff();
		
        // Save video memory
        if (NULL == pVideoMemory)
        {
            pVideoMemory = new BYTE [m_FrameBufferSize];
        }
		
        if (NULL != pVideoMemory)
        {
            memcpy(pVideoMemory, m_pPrimarySurface->Buffer(), m_FrameBufferSize);
        }
		
        // Blank the screen
        memset ((void*)m_pPrimarySurface->Buffer(), 0x0, m_FrameBufferSize);
		
        // Swap the buffer in the primary surface with that of our off screen buffer.
        if (NULL != pVideoMemory)
        {
            BYTE * pTempBuffer = (BYTE*)m_pPrimarySurface->Buffer();

            m_pPrimarySurface->Init(m_nScreenWidth, m_nScreenHeight, pVideoMemory, m_cbScanLineLength, m_pMode->format);
			DynRotate(m_iRotate);
            pVideoMemory = pTempBuffer;
        }
		
        // Let the setting take effect before disabling the controller
        Sleep(100);
		
       // disable LCD controller
		RETAILMSG(0, (TEXT("SetDisplayPower: disable LCD controller \r\n")));
		
       // Set Board Control Register (BCR) for Sharp LCD mode
       //set_BCRVal (NOMASK, BCR_LCD_LQ039Q2DS01_16BPP | BCR_LCD_POWER_OFF | BCR_BACKLIGHT_OFF, INPOWERHANDLER);

    }
    else
    {

        m_VideoPowerState = VideoPowerOn;

        // init "palette" area - just has some flags for 16bpp active display mode
        ptr = (WORD*)m_VirtualFrameBuffer;
        ptr[0] = 0x2000;
        for(int index = 1; index < 16; index++)
        {
            ptr[index] = 0x00000000;
        }

        // clear rest of frame buffer out
        /*
        for(index = 0; index < LCD_XSIZE_TFT*LCD_YSIZE_TFT; index++)
        {
            if(index < 3200)
            {
                ptr[index + 16] = 0xf800;
            }
            else if(index < 6400)
            {
                ptr[index + 16] = 0x07e0;
            }
            else if(index < 9600)
            {
                ptr[index + 16] = 0x001f;
            }
            else
            {
                ptr[index + 16] = 0xffff;
            }
        }*/

        // Set Board Control Register (BCR) for Sharp LCD mode
        //set_BCRVal (BCR_LCD_LQ039Q2DS01_16BPP | BCR_LCD_POWER_ON | BCR_BACKLIGHT_ON, NOMASK, INPOWERHANDLER);

        //
        // The SA1111DB card used by the SA11X0BD platform provides a bit to 
        // allow us to choose between MQ200 and SA_LCD.  By default we assume 
        // the display will be a MQ200 (so we can have a generic MQ200 driver) 
        // and only override it if we want to use the LCD driver.  It's wrapped 
        // in a conditional so other SA-based systems can use this library.
        //
	// if (m_bClearAlternateVideoBCR != 0)
  	// {
    	//        set_BCRVal (0, 0x2, INPOWERHANDLER);
      //  }

        // Program GPIO register to enable GPIO lines 2 - 9 for use by the LCD controller
        // disable LCD controller
        // clear LCD Status Register
        // enable LCD controller


        // Restore the screen
        if (NULL != pVideoMemory)
        {
            // Swap the buffers.
            BYTE * pTempBuffer = (BYTE*)m_pPrimarySurface->Buffer();

	     m_pPrimarySurface->Init(m_nScreenWidth, m_nScreenHeight, pVideoMemory, m_cbScanLineLength, m_pMode->format);

            pVideoMemory = pTempBuffer;

            // Actually copy the bits.
            memcpy(m_pPrimarySurface->Buffer(), pVideoMemory, m_FrameBufferSize);

            delete [] pVideoMemory;
            pVideoMemory = NULL;
        }
        else
        {
            memset ((void*)m_pPrimarySurface->Buffer(), 0x0, m_FrameBufferSize);
        }
		DynRotate(m_iRotate);

        m_CursorDisabled = FALSE;
        //CursorOn();
        m_CursorVisible = TRUE;
    }
}

int
S3C2443DISP::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
S3C2443DISP::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
S3C2443DISP::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;
}

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