registry.c

Lido PXA270平台开发板的最新BSP,包括源代码

/*******************************************************************************
<header>
* Name         : registry.c
* Title        : platform related function header
* Author(s)    : Imagination Technologies
* Created      : 30th October 2003
*
* Copyright    : 2002-2003 by Imagination Technologies Limited.
*                All rights reserved.  No part of this software, either
*                material or conceptual may be copied or distributed,
*                transmitted, transcribed, stored in a retrieval system
*                or translated into any human or computer language in any
*                form by any means, electronic, mechanical, manual or
*                other-wise, or disclosed to third parties without the
*                express written permission of Imagination Technologies
*                Limited, Unit 8, HomePark Industrial Estate,
*                King's Langley, Hertfordshire, WD4 8LZ, U.K.
*
* Description  : Platform related function templated and definitions
*
* Platform     : Windows CE
*
</header>
*******************************************************************************/

#include <windows.h>
#include "img_types.h"
#include "tstring.h"
#include "regpaths.h"
#include "services_headers.h"
#include "devload.h"

/* Maximum length of registry key or value name */
#define WCE_MAX_REGNAME_SIZE MAX_PATH

/* Maximum size of registry value from Windows CE limitations */
#define WCE_MAX_REGVALUE_SIZE 4096

/*****************************************************************************
 FUNCTION	: 	HostReadRegistryString
 PURPOSE	:	
 PARAMETERS	: 	
 RETURNS	: 	
*****************************************************************************/

IMG_BOOL HostReadRegistryString( IMG_UINT32 ui32DevCookie, IMG_CHAR *pszKey, IMG_CHAR *pszValue, IMG_CHAR *pszOutBuf, IMG_UINT32 ui32OutBufSize )
{
TCHAR szTemp[WCE_MAX_REGVALUE_SIZE];
HKEY hKey;

	UNREFERENCED_PARAMETER( ui32DevCookie );

#ifdef _DEBUG
	ASSERT( (pszKey && *pszKey && strlen( pszKey ) < sizeof( szTemp )/sizeof( TCHAR )) );
	ASSERT( (pszValue && *pszValue && strlen( pszValue ) < sizeof( szTemp )/sizeof( TCHAR )) );
	ASSERT( (pszOutBuf && ui32OutBufSize) );
#endif

	if (!pszKey || !*pszKey || !pszValue || !*pszValue || !pszOutBuf || !ui32OutBufSize)
	{
		SetLastError( ERROR_INVALID_PARAMETER );
		return FALSE;
	}

	ASCIITOTSTR( szTemp, pszKey, 0 );
	if (RegOpenKeyEx( HKEY_LOCAL_MACHINE , szTemp, 0, 0, &hKey ) == ERROR_SUCCESS)
	{
	DWORD dwType, dwLen = sizeof( szTemp );
	IMG_BOOL bSuccess = FALSE;

		ASCIITOTSTR( szTemp, pszValue, 0 );
		if (RegQueryValueEx( hKey, szTemp, NULL, &dwType, (LPBYTE) szTemp, &dwLen ) == ERROR_SUCCESS)
		{
#ifdef _DEBUG
			ASSERT( dwType == REG_SZ );
			ASSERT( dwLen < sizeof( szTemp ) );
			ASSERT( dwLen / sizeof( TCHAR ) < ui32OutBufSize );
#endif
			if (dwLen / sizeof( TCHAR ) < ui32OutBufSize)
			{
				TSTRTOASCII( pszOutBuf, szTemp, dwLen );
				bSuccess = TRUE;
			}
			else SetLastError( ERROR_INSUFFICIENT_BUFFER );
		}

		RegCloseKey( hKey );

		return bSuccess;
	}
	else return FALSE;
}

/*****************************************************************************
 FUNCTION	: 	HostReadRegistryBinary
 PURPOSE	:	
 PARAMETERS	: 	
 RETURNS	: 	
*****************************************************************************/

IMG_BOOL HostReadRegistryBinary( IMG_UINT32 ui32DevCookie, IMG_CHAR *pszKey, IMG_CHAR *pszValue, IMG_VOID *pszOutBuf, IMG_UINT32 *pui32OutBufSize )
{
TCHAR szTemp[WCE_MAX_REGNAME_SIZE];
HKEY hKey;

	UNREFERENCED_PARAMETER( ui32DevCookie );

#ifdef _DEBUG
	ASSERT( (pszKey && *pszKey && strlen( pszKey ) < sizeof( szTemp )/sizeof( TCHAR )) );
	ASSERT( (pszValue && *pszValue && strlen( pszValue ) < sizeof( szTemp )/sizeof( TCHAR )) );
	ASSERT( (pszOutBuf && ui32OutBufSize) );
#endif

	if (!pszKey || !*pszKey || !pszValue || !*pszValue || !pszOutBuf || !pui32OutBufSize)
	{
		SetLastError( ERROR_INVALID_PARAMETER );
		return FALSE;
	}

	ASCIITOTSTR( szTemp, pszKey, 0 );
	if (RegOpenKeyEx( HKEY_LOCAL_MACHINE , szTemp, 0, 0, &hKey ) == ERROR_SUCCESS)
	{
	DWORD dwType, dwLen = *pui32OutBufSize;
	IMG_BOOL bSuccess = FALSE;

		ASCIITOTSTR( szTemp, pszValue, 0 );
		if (RegQueryValueEx( hKey, szTemp, NULL, &dwType, pszOutBuf, &dwLen ) == ERROR_SUCCESS)
		{
#ifdef _DEBUG
			ASSERT( dwType == REG_BINARY );
			ASSERT( dwLen <= *pui32OutBufSize );
#endif
			*pui32OutBufSize = dwLen;
			bSuccess = TRUE;
		}

		RegCloseKey( hKey );

		return bSuccess;
	}
	else return FALSE;
}

/*****************************************************************************
 FUNCTION	: 	HostReadRegistryInt
 PURPOSE	:	
 PARAMETERS	: 	
 RETURNS	: 	
*****************************************************************************/

IMG_BOOL HostReadRegistryInt( IMG_UINT32 ui32DevCookie, IMG_CHAR *pszKey, IMG_CHAR *pszValue, IMG_UINT32 *pui32Data )
{
TCHAR szTemp1[WCE_MAX_REGNAME_SIZE];
HKEY hKey;

	UNREFERENCED_PARAMETER( ui32DevCookie );

#ifdef _DEBUG
	ASSERT( (pszKey && *pszKey && strlen( pszKey ) < sizeof( szTemp1 )/sizeof( TCHAR )) );
	ASSERT( (pszValue && *pszValue && strlen( pszValue ) < sizeof( szTemp1 )/sizeof( TCHAR )) );
	ASSERT( (pui32Data) );
#endif

	if (!pszKey || !*pszKey || !pszValue || !*pszValue || !pui32Data)
	{
		SetLastError( ERROR_INVALID_PARAMETER );
		return FALSE;
	}

	ASCIITOTSTR( szTemp1, pszKey, 0 );
	if (RegOpenKeyEx( HKEY_LOCAL_MACHINE , szTemp1, 0, 0, &hKey ) == ERROR_SUCCESS)
	{
	TCHAR szTemp2[WCE_MAX_REGVALUE_SIZE];
	DWORD dwType, dwLen = sizeof( szTemp2 );
	IMG_BOOL bSuccess = FALSE;

		ASCIITOTSTR( szTemp1, pszValue, 0 );
		if (RegQueryValueEx( hKey, szTemp1, NULL, &dwType, (LPBYTE) szTemp2, &dwLen ) == ERROR_SUCCESS)
		{
#ifdef _DEBUG
			ASSERT( (dwType == REG_SZ || dwType == REG_DWORD) );
			ASSERT( dwLen < sizeof( szTemp2 ) );
#endif
			switch (dwType)
			{
			case REG_SZ:
				*pui32Data = TTOI( szTemp2 );
				bSuccess = TRUE;
				break;
			case REG_DWORD:
				*pui32Data = *((DWORD *) szTemp2);
				bSuccess = TRUE;
				break;
			default:
				SetLastError( ERROR_INVALID_DATA );
				break;
			}
		}

		RegCloseKey( hKey );

		return bSuccess;
	}
	else return FALSE;
}

/*****************************************************************************
 FUNCTION	: 	HostWriteRegistryString
 PURPOSE	:	
 PARAMETERS	: 	
 RETURNS	: 	
*****************************************************************************/

IMG_BOOL HostWriteRegistryString( IMG_UINT32 ui32DevCookie, IMG_CHAR *pszKey, IMG_CHAR *pszValue, IMG_CHAR *pszInBuf )
{
TCHAR szTemp1[WCE_MAX_REGNAME_SIZE], szTemp2[WCE_MAX_REGVALUE_SIZE];
DWORD dwLen;
HKEY hKey;

	UNREFERENCED_PARAMETER( ui32DevCookie );

#ifdef _DEBUG
	ASSERT( (pszKey && *pszKey && strlen( pszKey ) < sizeof( szTemp1 )/sizeof( TCHAR )) );
	ASSERT( (pszValue && *pszValue && strlen( pszValue ) < sizeof( szTemp1 )/sizeof( TCHAR )) );
	ASSERT( (pszInBuf && strlen( pszInBuf ) < sizeof( szTemp2 )/sizeof( TCHAR )) );
#endif

	if (!pszKey || !*pszKey || !pszValue || !*pszValue || !pszInBuf)
	{
		SetLastError( ERROR_INVALID_PARAMETER );
		return FALSE;
	}

	dwLen = strlen( pszInBuf )+1;
	if (dwLen > sizeof( szTemp2 )/sizeof( TCHAR ))
	{
		SetLastError( ERROR_BAD_LENGTH );
		return FALSE;
	}

	ASCIITOTSTR( szTemp1, pszKey, 0 );
	if (RegOpenKeyEx( HKEY_LOCAL_MACHINE , szTemp1, 0, 0, &hKey ) == ERROR_SUCCESS)
	{
	IMG_BOOL bSuccess;

		ASCIITOTSTR( szTemp1, pszValue, 0 );
		ASCIITOTSTR( szTemp2, pszInBuf, 0 );
		bSuccess = (RegSetValueEx( hKey, szTemp1, 0, REG_SZ, (LPBYTE) szTemp2, dwLen ) == ERROR_SUCCESS);

		RegCloseKey( hKey );

		return bSuccess;
	}
	else return FALSE;
}

/*****************************************************************************
 FUNCTION	: 	HostWriteRegistryBinary
 PURPOSE	:	
 PARAMETERS	: 	
 RETURNS	: 	
*****************************************************************************/

IMG_BOOL HostWriteRegistryBinary( IMG_UINT32 ui32DevCookie, IMG_CHAR *pszKey, IMG_CHAR *pszValue, IMG_CHAR *pszInBuf, IMG_UINT32 ui32InBufSize )
{
TCHAR szTemp[WCE_MAX_REGNAME_SIZE];
HKEY hKey;

	UNREFERENCED_PARAMETER( ui32DevCookie );

#ifdef _DEBUG
	ASSERT( (pszKey && *pszKey && strlen( pszKey ) < sizeof( szTemp )/sizeof( TCHAR )) );
	ASSERT( (pszValue && *pszValue && strlen( pszValue ) < sizeof( szTemp )/sizeof( TCHAR )) );
	ASSERT( (pszInBuf && ui32InBufSize) );
#endif

	if (!pszKey || !*pszKey || !pszValue || !*pszValue || !pszInBuf || !ui32InBufSize)
	{
		SetLastError( ERROR_INVALID_PARAMETER );
		return FALSE;
	}

	if (ui32InBufSize > WCE_MAX_REGVALUE_SIZE)
	{
		SetLastError( ERROR_BAD_LENGTH );
		return FALSE;
	}

	ASCIITOTSTR( szTemp, pszKey, 0 );
	if (RegOpenKeyEx( HKEY_LOCAL_MACHINE , szTemp, 0, 0, &hKey ) == ERROR_SUCCESS)
	{
	IMG_BOOL bSuccess;

		ASCIITOTSTR( szTemp, pszValue, 0 );
		bSuccess = (RegSetValueEx( hKey, szTemp, 0, REG_BINARY, (LPBYTE) pszInBuf, ui32InBufSize ) == ERROR_SUCCESS);

		RegCloseKey( hKey );

		return bSuccess;
	}
	else return FALSE;
}

#undef WCE_MAX_REGNAME_SIZE
#undef WCE_MAX_REGVALUE_SIZE

/*****************************************************************************
 FUNCTION	: 	GetRegistryConfig
 PURPOSE	:	
 PARAMETERS	: 	
 RETURNS	: 	
*****************************************************************************/

IMG_UINT32 GetRegistryConfig(IMG_BOOL * bInstallIsr,     /* OUT - TRUE if ISR Handler found in registry */
									LPWSTR pszwIsrDll,      /* OUT - Name of ISR Handler dll */
									LPWSTR pszwIsrHandler)  /* OUT - Name of ISR Handler routine */
{
	IMG_UINT32 ui32Ret, ui32Size, ui32Type = 0;

	HKEY hConfig = (HKEY)INVALID_HANDLE_VALUE;

	*bInstallIsr = FALSE;

	/* Open Device key in the registry */

	ui32Ret = RegOpenKeyEx(HKEY_LOCAL_MACHINE, TEXT(POWERVR_REG_ROOT), 0, 0, &hConfig);

	if(ui32Ret != PVRSRV_OK)
	{
		PVR_DPF((PVR_DBG_WARNING,"GetRegistryConfig RegOpenKeyEx(%s) failed - %d\n", TEXT(POWERVR_REG_ROOT), ui32Ret));
		goto EXIT;
	}

	/* Read installable ISR dll name from registry, if it exists */

	ui32Size	= DEVDLL_LEN * sizeof(WCHAR);
	ui32Ret	= RegQueryValueEx(hConfig, DEVLOAD_ISRDLL_VALNAME, 0, &ui32Type, (PUCHAR)pszwIsrDll, &ui32Size);

	if(ui32Ret == ERROR_SUCCESS)
	{
		/* ISR dll name found, now look for ISR handler routine name */

		ui32Size	= DEVENTRY_LEN * sizeof(WCHAR);
		ui32Ret	= RegQueryValueEx(hConfig, DEVLOAD_ISRHANDLER_VALNAME, 0, &ui32Type, (PUCHAR)pszwIsrHandler, &ui32Size);

		if(ui32Ret == ERROR_SUCCESS)
		{
			*bInstallIsr = TRUE;
		}
		else
		{
			PVR_DPF((PVR_DBG_WARNING,"GetRegistryConfig RegQueryValueEx(%s) failed - %d", DEVLOAD_ISRHANDLER_VALNAME, ui32Ret));
			goto EXIT;
		}
	}
	else
	{
		PVR_DPF((PVR_DBG_WARNING,"GetRegistryConfig RegQueryValueEx(%s) failed - %d", DEVLOAD_ISRDLL_VALNAME, ui32Ret));
		goto EXIT;
	}

	ui32Ret = ERROR_SUCCESS;

EXIT:
	if(hConfig != INVALID_HANDLE_VALUE)
	{
		RegCloseKey(hConfig);
	}

	return(ui32Ret);
}