s3c2443disp.cpp

s3c2443的display driver.

				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)
    {
    	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
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;
}

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

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

void S3C2443DISP::EnableOverlay()
{
	m_pLCDReg->WINCON1 |= (1<<0);	
}

void S3C2443DISP::DisableOverlay()
{
	//RETAILMSG(1,(TEXT("DisableOverlay\n")));
	m_pLCDReg->WINCON1 &= ~(1<<0);
}

void S3C2443DISP::InitOverlay(S3C2443Surf* pOverlaySurface, RECTL rcSrc)
{
	m_pLCDReg->WINCON1 = (1<<WINCON_SWAP_S)|(WINCONx_16WORD_BURST<<WINCON_BURSTLEN_S)|(WINCONx_16BPP_565<<WINCON_BPP_S); // 4word burst, 16bpp,  
	
	m_pLCDReg->VIDW01ADD0 = (UINT32)(pOverlaySurface->OffsetInVideoMemory() + IMAGE_FRAMEBUFFER_DMA_BASE);		
			// buffer end address
	m_pLCDReg->VIDW01ADD1 = (UINT32)(pOverlaySurface->OffsetInVideoMemory() + IMAGE_FRAMEBUFFER_DMA_BASE) + 
													(pOverlaySurface->Width()*pOverlaySurface->Height()*2);
			// buffer size 
	m_pLCDReg->VIDW01ADD2 = (0<<VIDWxADD2_OFFSET_SIZE_S)|(pOverlaySurface->Width()*2);
	
	m_pLCDReg->VIDOSD1C = (0xF << 20) | (0xF << 16) | (0xF << 12) | (0x0 << 8) | (0x0 << 4) | (0x0 << 0);
	
	
	
	
}

void	S3C2443DISP::SetOverlayPosition(UINT32 x,UINT32 y,UINT32 width,UINT32 height)
{
	//RETAILMSG(1,(TEXT("%d %d %d %d\n"),x,y,width,height));
	m_pLCDReg->VIDOSD1A = ((x)<<11) | ((y)<<0);
	m_pLCDReg->VIDOSD1B = ((x+width-1)<<11) | ((y+height-1)<<0);
}

void	S3C2443DISP::SetOverlayColorKey(BOOL bUseColorKey, DWORD colorKey)
{
	BYTE R,G,B;
	R = (BYTE)((colorKey & m_pModeEx->dwRBitMask) >> m_RedMaskPosition);
	G = (BYTE)((colorKey & m_pModeEx->dwGBitMask) >> m_GreenMaskPosition);
	B = (BYTE)((colorKey & m_pModeEx->dwBBitMask) >> m_BlueMaskPosition);
	//RETAILMSG(1,(TEXT("R=%d G=%d B=%d\n"),R,G,B));
	if(bUseColorKey)
	{
		m_pLCDReg->W1KEYCON0 |= (0x1<<25) | (0x0<<24) | (0x7<<16) | (0x3<<8) | (0x7<<0);
		m_pLCDReg->W1KEYCON1 = (R<<19) | (G<<10) | (B<<3);
		m_bIsOverlayColorKey = TRUE;
	}
	else
	{
		m_pLCDReg->W1KEYCON0 &= ~(0x1<<25);
		m_bIsOverlayColorKey = FALSE;
	}
}

void	S3C2443DISP::SetOverlayAlpha(BOOL bUseAlpha, BOOL bUsePixelBlend, DWORD color)
{
	BYTE R,G,B;
	if(bUseAlpha)
	{
		R = (BYTE)((color & 0xF00) >> 8);
		G = (BYTE)((color & 0x0F0) >> 4);
		B = (BYTE)((color & 0x00F) >> 0);
		
		if(bUsePixelBlend == TRUE)
		{
			m_pLCDReg->WINCON1 |= (0x1<<6)|(0x1<<1);
		}
		else
		{
			m_pLCDReg->VIDOSD1C &= ~((0xF << 20) | (0xF << 16) | (0xF << 12));
			m_pLCDReg->VIDOSD1C |= ((R << 20) | (G << 16) | (B << 12));
			m_pLCDReg->WINCON1 &= ~((0x1<<6)|(0x1<<1));
		}
		if(m_bIsOverlayColorKey)
		{
			if(bUsePixelBlend == FALSE)
			{
				m_pLCDReg->WINCON1 |= (0x1<<6);
			}
			
			m_pLCDReg->W1KEYCON0 |= (0x1<<26);
		}
		else
		{
			m_pLCDReg->W1KEYCON0 &= ~(0x1<<26);
		}		
	}
	else
	{
		m_pLCDReg->W1KEYCON0 &= ~(0x1<<26);
		m_pLCDReg->WINCON1 &= ~((0x1<<6)|(0x1<<1));
		m_pLCDReg->VIDOSD1C = (0xF << 20) | (0xF << 16) | (0xF << 12) | (0x0 << 8) | (0x0 << 4) | (0x0 << 0);
	}
}

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