smi.cpp

VoyagerGX display driver for Windows CE .NET 5.XX Silicon Motion, Inc. VoyagerGX Driver is architec

		DEBUGMSG(GPE_ZONE_INIT, (TEXT("SMIVGX - VGXDMA buffer Base = %d.\r\n"),
				dwVal));
		RETAILMSG(1, (TEXT("SMIVGX - VGXDMA buffer Base = 0x%08X.\r\n"),
				dwVal));
		lpSettings->m_VGXDMA_address = dwVal;
	}
	if (RegQueryValueEx(hkDrv, TEXT("VGXDMABUF_SIZE"), NULL, &dwType,
						(LPBYTE)&dwVal, &dwSize) == ERROR_SUCCESS)
	{
		DEBUGMSG(GPE_ZONE_INIT, (TEXT("SMIVGX - VGXDMA buffer size = %d.\r\n"),
				dwVal));
		RETAILMSG(1, (TEXT("SMIVGX - VGXDMA buffer size  = 0x%08X.\r\n"),
				dwVal));
		lpSettings->m_VGXDMA_size = dwVal;
	}	
#endif

#ifndef DISABLE_INTERRUPT_MANAGEMENT
	lpSettings->m_IntInfo.SYSINTR = GetSingleValue(hkDrv, TEXT("VgxSysIntr"));
#endif

	// Read Power Monitor initial state
#ifdef FORCE_INITIAL_OFF
	lpSettings->m_bEnablePowerMonitor = FALSE;
	MESSAGE(MESSAGE_ZONE, (TEXT("QueryRegistrySetting() - Initial state of Power Monitor: forced %s\r\n"),
		lpSettings->m_bEnablePowerMonitor? TEXT("ON") : TEXT("OFF")));
#else
	if (RegQueryValueEx(hkDrv, TEXT("PowerMonitor"), NULL, &dwType,
						(LPBYTE)&dwVal, &dwSize) == ERROR_SUCCESS)
	{
		lpSettings->m_bEnablePowerMonitor = dwVal? TRUE : FALSE;
		MESSAGE(MESSAGE_ZONE, (TEXT("QueryRegistrySettingLoadcepc() - Initial state of Power Monitor: %s\r\n"),
			lpSettings->m_bEnablePowerMonitor? TEXT("ON") : TEXT("OFF")));
	}
	else
	{
		// Default value is PCIBus
		lpSettings->m_bEnablePowerMonitor = FALSE;
		MESSAGE(MESSAGE_ZONE, (TEXT("QueryRegistrySettingLoadcepc() - Initial state of Power Monitor: auto %s\r\n"),
			lpSettings->m_bEnablePowerMonitor? TEXT("ON") : TEXT("OFF")));
	}
#endif

	RegCloseKey(hkDrv);
}

//
// EnableAllSMICards
//
// Detect and create an SMI class for each one of the SMI video card
//
static BOOL EnableAllSMICards()
{
	BOOL bRet = TRUE;
	DWORD dwMonitors;
#ifndef HOST_ENABLE
	DWORD oldMode;
    PBOOT_ARGS args; // Pointer to structure containing boot arguments provided by Loadcepc

    /* Switch to kernel mode */
	oldMode = SetKMode(TRUE);

    args = (PBOOT_ARGS)(*(PBYTE *)BOOT_ARG_PTR_LOCATION);
    args = (PBOOT_ARGS)((DWORD)args | 0x80000000);

#ifndef BOOTARG_UNAVAIL
    // Use boot arguments resolution if available; otherwise get resolution settings from registry
    if (args->ucVideoMode != 0) // args->ucVideoMode is 0xff if boot args resolution available, 0x00 otherwise
    {
	    // Copy needed parameters from boot args
	    g_DefaultSettings.m_dwCxPanel = (DWORD)args->cxDisplayScreen;
	    g_DefaultSettings.m_dwCyPanel = (DWORD)args->cyDisplayScreen;
	    g_DefaultSettings.m_dwCxScreen = (DWORD)args->cxPhysicalScreen;
	    g_DefaultSettings.m_dwCyScreen = (DWORD)args->cyPhysicalScreen;
        g_DefaultSettings.m_dwBpp = (DWORD)args->bppScreen;

        // Read additional settings from registry
        QueryRegistrySettingLoadcepc(DRIVER_REGISTRY_STRING, &g_DefaultSettings);
    }
    else
#endif // BOOTARG_UNAVAIL
    {
        QueryRegistrySetting(DRIVER_REGISTRY_STRING, &g_DefaultSettings);
    }

    /* Restore old kernel/user mode */
	SetKMode(oldMode);

#else // HOST_ENABLE
    QueryRegistrySetting(DRIVER_REGISTRY_STRING, &g_DefaultSettings);
#ifdef UMA
	g_DefaultSettings.m_bUMA = 1;
	g_DefaultSettings.m_nLAWPhysical = DISPLAY_BASE_C_VIRTUAL;
	g_DefaultSettings.m_nUMAOffset = DISPLAY_DMA_OFFSET;
#endif
#endif

	// look for all the monitors we are supposed to support
	for (dwMonitors = 0; dwMonitors < g_dwMonitorsExpected; dwMonitors++) 
	{
		TCHAR szRegString[256];
		SMISETTINGS ssTemp(g_DefaultSettings);

        wsprintf(szRegString, TEXT("%s%i"), DRIVER_MULTIMON_REGISTRY_STRING, dwMonitors);

#ifndef HOST_ENABLE
        /* Switch to kernel mode */
	    oldMode = SetKMode(TRUE);

#ifndef BOOTARG_UNAVAIL
        // Use boot arguments resolution if available; otherwise get monitor settings from registry
        if (args->ucVideoMode != 0) // args->ucVideoMode is 0xff if boot args resolution available, 0x00 otherwise
        {
	        // Copy needed parameters from boot args
	        ssTemp.m_dwCxPanel = (DWORD)args->cxDisplayScreen;
	        ssTemp.m_dwCyPanel = (DWORD)args->cyDisplayScreen;
	        ssTemp.m_dwCxScreen = (DWORD)args->cxPhysicalScreen;
	        ssTemp.m_dwCyScreen = (DWORD)args->cyPhysicalScreen;
            ssTemp.m_dwBpp = (DWORD)args->bppScreen;

            // Read additional settings from registry
            QueryRegistrySettingLoadcepc(szRegString, &ssTemp);
        }
        else
#endif // BOOTARG_UNAVAIL
        {
            QueryRegistrySetting(szRegString, &ssTemp);
        }

        /* Restore old kernel/user mode */
	    SetKMode(oldMode);

#else // HOST_ENABLE
        QueryRegistrySetting(szRegString, &ssTemp);
#endif

		// Make sure that bpp is the same across the MULTIMON
		ssTemp.m_dwBpp = g_DefaultSettings.m_dwBpp;

#ifdef MULTIMONEMU_ENABLE
		if (dwMonitors % 2 == 1)
			ssTemp.m_nDualMonEnabled = 1;
		else if (dwMonitors+1 < g_dwMonitorsExpected)
				ssTemp.m_nDualMonEnabled = 1;
		bRet = DetectCard(dwMonitors/2,&ssTemp);
#else // MULTIMONEMU_ENABLE
		bRet = DetectCard(dwMonitors,&ssTemp);		
#endif // MULTIMONEMU_ENABLE

		DEBUGMSG(GPE_ZONE_INIT, (TEXT("SMIVGX - MONITOR #%d\r\n"),dwMonitors));
		DEBUGMSG(GPE_ZONE_INIT, (TEXT("m_nChipID = 0x%08X\r\n"),ssTemp.m_nChipID));
 		DEBUGMSG(GPE_ZONE_INIT, (TEXT("m_nLAWPhysical = 0x%08X\r\n"),ssTemp.m_nLAWPhysical));
		DEBUGMSG(GPE_ZONE_INIT, (TEXT("m_pLAW = 0x%08X\r\n"),ssTemp.m_pLAW));
 		DEBUGMSG(GPE_ZONE_INIT, (TEXT("m_nREGPhysical = 0x%08X\r\n"),ssTemp.m_nREGPhysical));
		DEBUGMSG(GPE_ZONE_INIT, (TEXT("m_pREG = 0x%08X\r\n"),ssTemp.m_pREG));
/*
		RETAILMSG(1, (TEXT("SMIVGX - MONITOR #%d\r\n"),dwMonitors));
		RETAILMSG(1, (TEXT("m_nChipID = 0x%08X\r\n"),ssTemp.m_nChipID));
 		RETAILMSG(1, (TEXT("m_nLAWPhysical = 0x%08X\r\n"),ssTemp.m_nLAWPhysical));
		RETAILMSG(1, (TEXT("m_pLAW = 0x%08X\r\n"),ssTemp.m_pLAW));
 		RETAILMSG(1, (TEXT("m_nREGPhysical = 0x%08X\r\n"),ssTemp.m_nREGPhysical));
		RETAILMSG(1, (TEXT("m_pREG = 0x%08X\r\n"),ssTemp.m_pREG));
*/
		switch (ssTemp.m_nChipID)
		{
		case CHIPID_SM501:
#ifdef MULTIMONEMU_ENABLE
			if (dwMonitors % 2 == 1)
				pSMI[dwMonitors] = new SMIVGXEmu(&ssTemp,pSMI[dwMonitors-1]);
			else
#endif // MULTIMONEMU_ENABLE
				pSMI[dwMonitors] = new SMI(&ssTemp);

			break;

		default:
			pSMI[dwMonitors] = NULL;
			bRet = FALSE;
			break;
		}

		if (!bRet)
			break;

	}
	
	// did we find any monitors?
	if(bRet == TRUE && dwMonitors == 0)
		bRet = FALSE;

	// let the user know if there's a problem
	if(bRet == FALSE) 
	{
		// Couldn't find an SMI card, what to do now?
		RETAILMSG (1, (_T("No available SMI Voyager card found!\r\n")));
	}
	
	return bRet;
}

//
// GetGPE
//
// Main entry point for a GPE-compliant driver
//
GPE *GetGPE()
{
    if (!pGPE)
	{
	    if (!EnableAllSMICards())
			return NULL;
	    pGPE = pSMI[0];

	}

#ifdef ENABLE_DIRECT3D
        ppdev = (SMI*) pGPE;  
#endif // ENABLE_DIRECT3D

	return	pGPE;    
}

//
// GetGPE
//
// Main entry point for a MULTIMON GPE-compliant driver
//
GPE *GetGPEPerCard(int iCard)
{
    if (!pGPE)
    {
		if (!EnableAllSMICards())
		    return NULL;
		pGPE = pSMI[0];
    }

#ifdef ENABLE_DIRECT3D
        ppdev = (SMI*) pSMI[iCard];  
#endif // ENABLE_DIRECT3D
    
    return pSMI[iCard];
}

EGPEFormat eFormat[] =
{
	gpe8Bpp,
	gpe16Bpp,
	gpe24Bpp,
	gpe32Bpp,
};

#ifdef DD_ENABLE
EDDGPEPixelFormat ePixelFormat[4] = 
{
	ddgpePixelFormat_8bpp,
	ddgpePixelFormat_565,
	ddgpePixelFormat_8880,
	ddgpePixelFormat_8888,
};
#endif // DD_ENABLE

ULONG BitMasks[][3] =
{
	{ 0, 0, 0 },
	{ 0xF800, 0x07E0, 0x001F },
	{ 0xFF0000, 0x00FF00, 0x0000FF },
	{ 0x00FF0000, 0x0000FF00, 0x000000FF }
};

// 
// DrvGetMasks
//
// Returns the bitmasks of the primary monitor
//
PULONG APIENTRY DrvGetMasks(DHPDEV dhpdev)
{
	if (pGPE == NULL)
		return(BitMasks[0]);

	int nBPP = ((SMI *)pGPE)->GetBpp()/8 - 1;
	switch (((SMI *)pGPE)->GetBpp())
	{
		case 8:
		case 16:
		case 24:
		case 32:
			return(BitMasks[nBPP]);
			break;
	}

	return(BitMasks[0]);
}

//
// GetBpp
//
// Return the Bpp of the current monitor
//
int SMI::GetBpp(void)
{
	return m_nScreenBpp;
}

// InitCard
//
// Initialize the card to the default mode
//
void SMI::InitCard(void)
{
	//unsigned long gate, clock;
	//unsigned long value;

	// Setup hardware pointer
	m_pLAW = m_SMISettings.m_pLAW;
	m_nLAWPhysical = m_SMISettings.m_nLAWPhysical;
	m_pREG = g_pREG = m_SMISettings.m_pREG;
	m_nREGPhysical = m_SMISettings.m_nREGPhysical;

	m_pDPR = m_pREG + DE_SOURCE;
    m_pMMIO = m_pREG + DE_DATAPORT;
#ifdef CMDLIST
    m_cmdlist_address=m_SMISettings.m_cmdlist_address;
    m_cmdlist_size=m_SMISettings.m_cmdlist_size;
#endif // CMDLIST
    m_sdrambase=m_SMISettings.m_sdrambase;
#ifdef VGXDMA
    m_VGXDMA_address=m_SMISettings.m_VGXDMA_address;
    m_VGXDMA_size=m_SMISettings.m_VGXDMA_size;
#endif // VGXDMA

}

ULONG g_nPanelSize[][2] =
{
	{640,480},
	{800,600},
	{1024,768},
	{800,480},
};
#define MAX_PANELID		(sizeof(g_nPanelSize)/(2*sizeof(ULONG)))

//
// GetPanelID
// 
// Returns the Panel ID as indicated by dipswitch settings, 
// according to the table g_nPanelSize
//
BYTE SMI::GetPanelID(void)
{
	return 1; 
}

// AdjustDefaultMode
// 
// Adjust the Windows CE Registry, as stored by m_SMISettings
//
void SMI::AdjustDefaultMode(void)
{
	if ((m_SMISettings.m_dwCxPanel == 0) || (m_SMISettings.m_dwCyPanel == 0))
	{
		// Read board dipswitch
		BYTE nID = GetPanelID();
		if (nID < MAX_PANELID)
		{
			m_SMISettings.m_dwCxPanel = g_nPanelSize[nID][0];
			m_SMISettings.m_dwCyPanel = g_nPanelSize[nID][1];
		}
		else
		{
			m_SMISettings.m_dwCxPanel = g_nPanelSize[0][0];
			m_SMISettings.m_dwCyPanel = g_nPanelSize[0][1];
		}
	}

	// CxScreen smaller than CxPanel, assumed auto-zoom
	if (m_SMISettings.m_dwCxScreen == 0)
		m_SMISettings.m_dwCxScreen = m_SMISettings.m_dwCxPanel;

	if (m_SMISettings.m_dwCxScreen < m_SMISettings.m_dwCxPanel)
	{
		if (m_SMISettings.m_dwCxZoom ==0)
			m_SMISettings.m_dwCxZoom = m_SMISettings.m_dwCxScreen;
	}

	// CyScreen smaller than CyPanel, assumed auto-zoom
	if (m_SMISettings.m_dwCyScreen == 0)
		m_SMISettings.m_dwCyScreen = m_SMISettings.m_dwCyPanel;
	if (m_SMISettings.m_dwCyScreen <  m_SMISettings.m_dwCyPanel)
	{
		if (m_SMISettings.m_dwCyZoom ==0)
			m_SMISettings.m_dwCyZoom = m_SMISettings.m_dwCyScreen;
	}

	// Adjust CxZoom & CyZoom
	if (m_SMISettings.m_dwCxZoom ==0) m_SMISettings.m_dwCxZoom = m_SMISettings.m_dwCxPanel;
	if (m_SMISettings.m_dwCyZoom ==0) m_SMISettings.m_dwCyZoom = m_SMISettings.m_dwCyPanel;
	if (m_SMISettings.m_dwCxZoom > m_SMISettings.m_dwCxScreen)
		m_SMISettings.m_dwCxZoom = m_SMISettings.m_dwCxScreen;
	if (m_SMISettings.m_dwCyZoom > m_SMISettings.m_dwCyScreen)
		m_SMISettings.m_dwCyZoom = m_SMISettings.m_dwCyScreen;


	// Adjust Bpp
	if (m_SMISettings.m_dwBpp == 0) m_SMISettings.m_dwBpp = SSBPP_DEFAULT;

	// Adjust Frequency
	if (m_SMISettings.m_nFrequency == 0) m_SMISettings.m_nFrequency = SSFREQ_DEFAULT;

	// Need to adjust ModeId in the future
	m_SMISettings.m_nModeId = 0; 
}

// Init
// 
// First and main initialization routine of the SMI class 
// (Should not be done by SMI constructor, due to future inheritance issues)
//
// Inputs:		pss		= Hardware info & Windows CE Registry Settings 
//
void SMI::Init(SMISETTINGS *pss)
{
	// Adjust all SMI Settings to make sure that we have valid values
	m_SMISettings = *pss;

	// Init internal flags
	m_bAlphaEnabled = FALSE;
	m_bZoomEnabled = FALSE;
	m_bPWMEnabled = FALSE;
	m_bI2CEnabled = FALSE;
	m_bGPIOEnabled = FALSE;
#ifndef DISABLE_INTERRUPT_MANAGEMENT
	m_bIntInitDone = FALSE;
#endif

	// Init Power Management
	InitPowerManagement();

	// Initialize card
	InitCard();

	AdjustDefaultMode();

 	m_bSetMode = FALSE;
	m_pPrimarySurface = NULL;

#ifdef DD_ENABLE
	m_pVideoMemoryHeap = NULL;

	m_pModeEx = &m_ModeInfoEx;
	m_pMode = &m_ModeInfoEx.modeInfo;
	memset(m_pModeEx, 0, sizeof(GPEModeEx));
	m_pModeEx->dwSize = sizeof(GPEModeEx);
	m_pModeEx->dwVersion = GPEMODEEX_CURRENTVERSION;
#else
	m_p2DVideoMemory = NULL;

	m_pMode = &m_ModeInfo;
#endif

	// Setup main ModeInfo
	m_pMode->modeId = m_SMISettings.m_nModeId; 
	m_pMode->Bpp = m_SMISettings.m_dwBpp;
	m_pMode->frequency = m_SMISettings.m_nFrequency;
	m_pMode->width = m_SMISettings.m_dwCxScreen;
	m_pMode->height = m_SMISettings.m_dwCyScreen;

	int nBPP = m_pMode->Bpp/8 - 1;
	switch (m_pMode->Bpp)
	{
		case	8:
		case	16:
		case	32:
			m_pMode->format = eFormat[nBPP];
#ifdef DD_ENABLE
			m_pModeEx->ePixelFormat = ePixelFormat[nBPP];
			m_pModeEx->lPitch = m_pMode->width * m_SMISettings.m_dwBpp / 8;
			m_pModeEx->dwRBitMask = BitMasks[nBPP][0];
			m_pModeEx->dwGBitMask = BitMasks[nBPP][1];
			m_pModeEx->dwBBitMask = BitMasks[nBPP][2];
#endif
			break;

		default:
			RETAILMSG(1,(TEXT("SMIVGX - Invalid BPP value passed to driver - Bpp = %d\r\n"), m_pMode->Bpp));
			m_pMode->format = gpeUndefined;
			break;
	}

	// Check Video Memory Size
	SetupVideoMemory();
	
	// Set-up Cursor Memory
	SetupCursor();

	// Allocate buffer to save panel cursor memory
	m_pPanelHwcBuffer = (PUCHAR) VirtualAlloc(NULL, 2048, MEM_COMMIT, PAGE_READWRITE);
	if (m_pPanelHwcBuffer == NULL)
    {
		RETAILMSG(1, (TEXT("System memory allocation for panel cursor failed!\r\n")));
    }

#ifdef CMDLIST
	// Set-up Command List Buffer
	SetupCmdListBuffer();