device.c

深圳市微逻辑电子有限公司 巨果&#8226 Kingmos&reg 系统核心

			{
				goto _CLOSE_HKEY;
			}
			if( dwIndex > 9 )
			{
				goto _CLOSE_HKEY;
			}
			Device_RegisterDevice( tcPrefix, dwIndex, tcDll, 0 );
_CLOSE_HKEY:
			RegCloseKey( hDriverKey );
		}
		RegCloseKey( hSubKey );
	}
}

// *****************************************************************
// 声明：static BOOL CALLBACK DoPowerHandler( LPDEVICE_DATA lpDev, LPVOID lpParam )
// 参数：
//		IN lpDev - 设备驱动程序接口对象
//		IN lpParam - 假如非0，做开机动作；假如0，做关机动作
// 返回值：
//		TRUE
// 功能描述：
//		枚举所有的设备对象，通知其开机或关机
// 引用: 
//
// *****************************************************************

static BOOL CALLBACK DoPowerHandler( LPDEVICE_DATA lpDev, LPVOID lpParam )
{
	if( lpParam )
	{  //on
	    if( lpDev->lpDriver->lpPowerUp )
			lpDev->lpDriver->lpPowerUp(lpDev->hDevInit);
	}
	else
	{
	    if( lpDev->lpDriver->lpPowerDown )
			lpDev->lpDriver->lpPowerDown(lpDev->hDevInit);
	}
	return TRUE;
}

// **************************************************
// 声明：DWORD WINAPI Device_ServerHandler( HANDLE hServer, DWORD dwServerCode , DWORD dwParam, LPVOID lpParam )
// 参数：
//		IN hServer - 服务句柄
//		IN dwServerCode - 控制码
//		IN dwParam - 第一个参数
//		IN lpParam - 第二个参数
// 返回值：
//		依赖与不同的控制
// 功能描述：
//		服务总线控制，处理各种系统服务，通知功能
// 引用: 
//		系统API	
// ************************************************

DWORD WINAPI Device_ServerHandler( HANDLE hServer, DWORD dwServerCode , DWORD dwParam, LPVOID lpParam )
{
	extern void ShutDownDevice( void );
	switch( dwServerCode )
	{
	case SCC_BROADCAST_POWER:
		if( dwParam == SBP_APMSUSPEND )
		{
			EnumDevice( DoPowerHandler, 0 );
			SaveAsRegister(NULL);  //保存所有的注册表信息
		}
		else if( dwParam == SBP_APMRESUMESUSPEND )
		{
			EnumDevice( DoPowerHandler, (LPVOID)1 );
		}
		return TRUE;
	//case SCC_BROADCAST_POWERON:
		//EnumDevice( DoPowerHandler, (LPVOID)1 );
		//break;
	case SCC_BROADCAST_SHUTDOWN:
		ShutDownDevice();
		break;
	default:
		return Sys_DefServerProc( hServer, dwServerCode , dwParam, lpParam );
	}
	return 0;
}
/*
#define ACTIVE_KEY_PATH_LEN ( sizeof(szActiveKey) + 8 )
static BOOL ActiveAndLoadDriver( 
								LPCTSTR lpszDevKey,
								const REGINI * lpRegEnts, 
								DWORD cRegEnts, 
								LPVOID lpvParam,
								DWORD dwIndex,
								)
{
	UINT uiActiveNum;
    TCHAR szActiveKeyPath[ACTIVE_KEY_PATH_LEN];
	HKEY hActiveKey = NULL;
	DWORD dwDisposition;
	int n = 1;

    // 创建新的Active键
	while( n < 100 )
	{
		uiActiveNum = InterlockedIncrement( &uiCurrentActiveNum ) - 1;
		sprintf( szActiveKeyPath, "%s\\%02d", szActiveKey, uiActiveNum );
		
		// 创建新键
		if( ERROR_SUCCESS != RegCreateKeyEx(
			HKEY_HARDWARE_ROOT,
			szActiveKeyPath,
			0,
			NULL,
			0,
			0,
			NULL,
			&hActiveKey,     // HKEY result
			&dwDisposition) )
		{
			goto _error_return;
		}
		if( dwDisposition != REG_CREATED_NEW_KEY )
		{
			RegCloseKey( hActiveKey );
		}
		else
			break;
	}
	if( n == 100 )
		goto _error_return;
	// 写用户键值到 Active Keu
	if( lpRegEnts && cReg )
	{
		HANDLE hCallerProcess = GetCallerProcess();
        for( n = 0; n < cReg; n++ )
		{
            if( EEROR_SUCESS != RegSetValueEx(
									hActiveKey,
									MapPtrToProcess( lpReg[cReg].lpszVal, hCallerProcess ),
									0,
									lpReg[cReg].dwType,
									MapPtrToProcess( lpReg[cReg].pData, lpReg[cReg].dwLen ),
									lpReg[cReg].dwLen ) )
			{
				break;
			}
		}
		if( n != cReg )
			goto _error_return;
    }

	// 写驱动程序键值到 Active Keu的Load Key
    if( lpszDevKey != NULL )
	{    
        if( ERROR_SUCCESS != RegSetValueEx(
								hActiveKey,
								szPath,
								0,
								REG_SZ,
								(LPBYTE)lpszDevKey,
								strlen( lpszDevKey ) + 1 ) )
		{
			goto _error_return;
		}
    }

    if( dwIndex == -1 )
	{	// 由系统分配索引值
        dwIndex = 0;
		EnterCriticalSection( &csDeviceObjList ); // 进入冲突段	

        while( dwIndex < 10 )
		{
			if( FindDevice( lpszPrefix, dwIndex ) == NULL )
				break;
			dwIndex++;
		}
		LeaveCriticalSection( &csDeviceObjList );
	}
	if( dwIndex < 10 )
	{
         char szDevName[16];
		 int len;
		 
		 strcpy( szDevName, lpszPrefix );
		 len = strlen( szDevName );
		 szDevName[len]=dwIndex+'0';
		 szDevName[len+1]=':';
		 szDevName[len+2]=0;
         if( ERROR_SUCCESS == RegSetValueEx( 
			                       hActiveKey,
                                   szName,
                                   0,
                                   REG_SZ,
                                   (LPBYTE)szDevName,
                                   strlen( szDevName ) + 1 ) )
		 {
			 HANDLE hDev;
			 if( ( hDev = Device_Register( lpszPrefix, dwIndex, lpszDll, lpvParam ) ) != NULL )
			 {	// 设备注册成功
				 if( ERROR_SUCCESS != RegSetValueEx( 
											hActiveKey,
											szHandle,
											0,
											REG_DWORD,
											(LPBYTE)hDev,
											sizeof(hDev) ) )
				 {
					 ERRORMSG( 1, ( "Can't write registry!.\r\n" ) );
				 }
				 if( *lpszPrefix )
				     SendDeviceInitMsg( lpszPrefix, dwIndex, hDev );

				 PNP_NotifyHandler( szActiveKeyPath );
				 return TRUE;
			 }
		 }
	}
_error_return:
	if( hActiveKey )
	{
		RegCloseKey( hActiveKey );
		RegDeleteKey( HKEY_HARDWARE_ROOT, szActiveKeyPath );		
	}
	return FALSE;
}

// **************************************************
// 声明：

// 参数：
//		IN 
// 返回值：
//		假如成功，返回；否则，返回
// 功能描述：
// 引用: 
//		
// ************************************************

#define DEBUG_READ_DRIVER_REG 0
BOOL ReadDriverKeyFromRegistry( HKEY hDriverKey, 
							    DWORD * lpdwFlags,
								char * lpszDllBuf,
								UINT uiDllLen,
								char * lpszPrefixBuf,
								UINT uiPrefixLen，
								DWORD * lpdwIndex )
{
	DWORD dwValLen;	
    // 
    // 读 flags
    dwValLen = sizeof(*lpdwFlags);
    if( ERROR_SUCCESS != RegQueryValueEx(
        hDriverKey,
        szFlags,
        NULL,
        NULL,
        (LPBYTE)lpdwFlags,
        &dwValLen ) )
	{
        WARNMSG( DEBUG_READ_DRIVER_REG, ( "ReadDriverKeyFromRegistry: read flag error.\r\n") );
		goto _error_return;
	}

    // 读动态连接库名 read so name
    dwValLen = uiDllLen;
    if( ERROR_SUCCESS != RegQueryValueEx(
        hDriverKey,
        szDll,
        NULL,
        NULL,
        lpszDllBuf,
        &dwValLen ) )
	{
		WARNMSG( DEBUG_READ_DRIVER_REG, ( "ReadDriverKeyFromRegistry: read dll error.\r\n") );
		goto _error_return;
	}

    // 读前缀
    dwValLen = uiPrefixLen;
    if( ERROR_SUCCESS != RegQueryValueEx(
        hDriverKey,
        szPrefix,
        NULL,
        NULL,
        lpszPrefixBuf,
        &dwValLen ) )
	{
		WARNMSG( DEBUG_READ_DRIVER_REG, ( "ReadDriverKeyFromRegistry: read prefix error.\r\n") );
		goto _error_return;
	}

    // 读索引

    dwValLen = sizeof(*lpdwIndex);
    if( ERROR_SUCCESS != RegQueryValueEx(
        hDriverKey,
        szIndex,
        NULL,
        NULL,
        (LPBYTE)lpdwIndex,
        &dwValLen ) )
	{
		*lpdwIndex = -1;
	}
	return TRUE;
_error_return:
	return FALSE;
}


typedef struct _REGINI {
	LPCWSTR lpszVal;
	LPBYTE pData;
	DWORD dwLen;
	DWORD dwType;
} REGINI;

// **************************************************
// 声明：HANDLE WINAPI Device_ActivateEx(
//							LPCWSTR lpszDevKey, 
//							const REGINI * lpRegEnts, 
//							DWORD cRegEnts, 
//							LPVOID lpvParam
//							)

// 参数：
//		IN lpszDevKey - 需要注册的设备的注册键
//		IN lpRegEnts - REGINI结构数组指针，指向需要增加的键值
//		IN cRegEnts - 指明EGINI结构数组的个数
//		IN lpvParam - 传递给 XXX_Init( xxx, lpvParam ) 的参数
// 返回值：
//		假如成功，返回非NULL句柄；否则，返回NULL
// 功能描述：
//		将用户指定的键值写入注册表的[HKEY_HARDWARE_ROOT\Drivers\Active\(NO.xxx)]
//		通过lpszDevKey的设备名，前缀，索引号等加载设备
//		传递 lpvParam 给 XXX_init( xxx, lpvParam )
// 引用: 
//		系统API	
// ************************************************
//static TCHAR const szBuiltInDriver[] = "Drivers\\Active";

#define DEBUG_ACTIVATEEX 0
HANDLE WINAPI Device_ActivateEx(
							LPCWSTR lpszDevKey, 
							const REGINI * lpRegEnts, 
							DWORD cRegEnts, 
							LPVOID lpvParam
							)
{
	TCHAR tcActiveNum[sizeof(szActiveKey)+2];
	HKEY hDriverKey;

	// 打开/检查是否存在 lpszDevKey

    if( EEROR_SUCCESS != RegOpenKeyEx(
        HKEY_HARDWARE_ROOT,
        lpszDevKey,
        0,
        KEY_ALL_ACCESS,
        &hDriverKey ) )
	{
        WARNMSG( DEBUG_ACTIVATEEX, (TEXT("registry key lpszDevKey=(%s) is not exist!.\r\n"), lpszDevKey ) );
		return NULL;
	}

    if( DoWriteInitReg( lpRegEnts, cRegEnts, tcActiveNum+sizeof(szActiveKey) ) )
	{
		tcActiveNum[sizeof(tcActiveNum)-1] = 0;
		if( ActiveAndLoadDriver( lpszDevKey, lpvParam ) == FALSE )
		{
			RegDeleteKey( HKEY_HARDWARE_ROOT, tcActiveNum );
		}
	}
}
	HKEY hDriverKey;
	if( ERROR_SUCCESS != RegOpenKeyEx( 
							HKEY_HARDWARE_ROOT,
							lpszDevKey,
							0,
							KEY_ALL_ACCESS,
							&hDriverKey ) )
		continue;
	if( ERROR_SUCCESS != RegQueryValueEx( hDriverKey, szPrefix, NULL, NULL, tcPrefix, &dwPrefixSize ) )
	{
		goto _CLOSE_HKEY;
	}
	if( dwPrefixSize != 4 )
	{
		goto _CLOSE_HKEY;
	}
	if( ERROR_SUCCESS != RegQueryValueEx( hDriverKey, "Dll", NULL, NULL, tcDll, &dwDllSize ) )
	{
		goto _CLOSE_HKEY;
	}
	if( ERROR_SUCCESS != RegQueryValueEx( hDriverKey, "Index", NULL, NULL, (LPBYTE)&dwIndex, &dwIndexSize ) )
	{
		goto _CLOSE_HKEY;
	}
	if( dwIndex > 9 )
	{
		goto _CLOSE_HKEY;
	}
	Device_RegisterDevice( tcPrefix, dwIndex, tcDll, 0 );

}


// **************************************************
// 声明：BOOL WINAPI Device_Deactivate(
//							HANDLE hActiveDevice
//							)

// 参数：
//		IN hActiveDevice - 由Device_ActivateEx返回的句柄
// 返回值：
//		假如成功，返回TRUE；否则，返回FALSE
// 功能描述：
//		注销设备驱动程序
//		删除注册表的[HKEY_HARDWARE_ROOT\Drivers\Active\(NO.xxx)]
//		广播WM_DEVICECHANGE
// 引用: 
//		系统API	
// ************************************************

BOOL WINAPI Device_Deactivate(
								HANDLE hActiveDevice
							)
{
}
*/

extern BOOL OEM_GetSystemPowerStatusEx(PSYSTEM_POWER_STATUS_EX pstatus, BOOL fUpdate);
BOOL WINAPI Device_GetSystemPowerStatusEx(
				PSYSTEM_POWER_STATUS_EX pstatus, 
				BOOL fUpdate )
{
#ifndef EML_WIN32
	if( pstatus )
		return OEM_GetSystemPowerStatusEx( pstatus, fUpdate );
#endif
	return FALSE;
}