tmman32.c

wince host 和 target PCI驱动程序

		case DLL_PROCESS_DETACH :
		//remove the console handler
		DeleteCriticalSection ( &Global.SDRAMCriticalSection );
		DeleteCriticalSection ( &Global.MessageCriticalSection );

		switch ( WindowsVersion )
		{
			case	WINDOWS_OS_WINCE2X :
			for ( DeviceIdx = 0 ; DeviceIdx < constTMMANMaximumDeviceCount ; DeviceIdx++ )
			{
				if ( ( Global.MapSDRAM ) && ( Global.SDRAMMapped[DeviceIdx] ) )
				{
					VirtualFree(
						(void*)Global.SDRAM[DeviceIdx].MappedAddress,
						0,
						MEM_RELEASE);

					Global.SDRAMMapped[DeviceIdx] = 0;
				}

				if ( Global.MemoryMapped[DeviceIdx] )
				{
					VirtualFree(
						(void*)Global.Memory[DeviceIdx].MappedAddress,
						0,
						MEM_RELEASE);
					Global.MemoryMapped[DeviceIdx] = 0;

				}

				if ( Global.MMIOMapped[DeviceIdx] )
				{
					VirtualFree(
						(void*)Global.MMIO[DeviceIdx].MappedAddress,
						0,
						MEM_RELEASE);

					Global.MMIOMapped[DeviceIdx] = 0;
				}
			}

			if ( --dwInstanceCtr == 0)
			{
				if(m_hRegTmm)
					DeregisterDevice(m_hRegTmm);
			}
			break;

			default :
			break;
		}

		SetConsoleCtrlHandler  ( tmmanControlHandler, FALSE );


		if ( Global.hDevice != INVALID_HANDLE_VALUE)
		{
			CloseHandle ( Global.hDevice );
		}

		break;

	}
	return TRUE;
}



//-----------------------------------------------------------------------------
//	API IMPLEMENTATION 
//-----------------------------------------------------------------------------


// DSP related API.


TMStatus  tmmanNegotiateVersion ( 
	UInt32	ModuleID, 
	tmmanVersion* Version )
{
	TMStatus				Status = statusSuccess;
	tmifNegotiateVersion	TMIF;
	tmmanVersion			ReturnedVersion;
	UInt32					BytesReturned;


	switch ( ModuleID )
	{
		case	constTMManModuleHostUser :
		case	constTMManDefault :

		ReturnedVersion.Major = verGetFileMajorVersion();
		ReturnedVersion.Minor = verGetFileMinorVersion();
		ReturnedVersion.Build = verGetFileBuildVersion();

		if ( Version->Major != verGetFileMajorVersion()  )
		{
			Status = statusMajorVersionError;
			goto tmmanNegotiateVersionExit1;
		}

		if ( Version->Minor != verGetFileMinorVersion() )
		{
			Status = statusMinorVersionError;
			goto tmmanNegotiateVersionExit1;
		}
		break;

		case constTMManModuleHostKernel :
		TMIF.Version.Major = Version->Major;
		TMIF.Version.Minor = Version->Minor;
		TMIF.Version.Build = Version->Build;
		TMIF.ModuleID = ModuleID;

		// perform the version control 
		if ( DeviceIoControl ( Global.hDevice,
			constIOCTLtmmanNegotiateVersion,
			(PVOID)&TMIF, sizeof (tmifNegotiateVersion),
			(PVOID)&TMIF, sizeof (tmifNegotiateVersion),
			&BytesReturned, NULL ) != TRUE )
		{	
			Status = statusDeviceIoCtlFail;
		}
		else
		{
			Status = TMIF.Status;
		}

		ReturnedVersion.Major = TMIF.Version.Major;
		ReturnedVersion.Minor = TMIF.Version.Minor;
		ReturnedVersion.Build = TMIF.Version.Build;
		break;

		case constTMManModuleTargetKernel :
		case constTMManModuleTargetUser :
		default :
		Status  = statusUnknownComponent;
		break;
	}


tmmanNegotiateVersionExit1:
	Version->Major = ReturnedVersion.Major;
	Version->Minor = ReturnedVersion.Minor;
	Version->Build = ReturnedVersion.Build;
	return Status;
}

UInt32		tmmanDSPGetNum ( void )
{
	tmifDSPNum	TMIF;
	UInt32		BytesReturned;

	//TMIF.ClientHandle = Global.dwClientHandle;

	if ( DeviceIoControl ( Global.hDevice, 
		constIOCTLtmmanDSPGetNum,
		(PVOID)&TMIF, sizeof( tmifDSPNum) ,
		(PVOID)&TMIF, sizeof( tmifDSPNum) ,
		&BytesReturned, NULL ) != TRUE )
	{
		return statusDeviceIoCtlFail;
	}

	return  TMIF.DSPCount;
}

TMStatus  tmmanDSPGetInfo ( 
	UInt32 DSPHandle, 
	tmmanDSPInfo* DSPInfo )
{
	tmifDSPInfo	TMIF;
	UInt32		BytesReturned;

	//TMIF.ClientHandle = Global.dwClientHandle;
	TMIF.DSPHandle = DSPHandle;

	if ( DeviceIoControl ( Global.hDevice, 
		constIOCTLtmmanDSPInfo,
		(PVOID)&TMIF, sizeof( tmifDSPInfo) ,
		(PVOID)&TMIF, sizeof( tmifDSPInfo) ,
		&BytesReturned, NULL ) != TRUE )
	{
		return statusDeviceIoCtlFail;
	}
#ifdef TMMAN_WINCE
	// report mapped addresses that were allocated in this process context
	// this is requried only for windows CE.
    TMIF.Info.MMIO.MappedAddress  = Global.MMIO[TMIF.Info.DSPNumber].MappedAddress;
    TMIF.Info.SDRAM.MappedAddress = Global.SDRAM[TMIF.Info.DSPNumber].MappedAddress;
#endif

	*DSPInfo = TMIF.Info;
	return TMIF.Status;
}
// DSP FUNCTIONS
TMStatus  tmmanDSPGetStatus ( 
	UInt32 DSPHandle, 
	UInt32* StatusFlags )
{
	tmifDSPStatus	TMIF;
	UInt32	BytesReturned;

	TMIF.DSPHandle = DSPHandle;
	//TMIF.ClientHandle = Global.dwClientHandle;

	if ( DeviceIoControl ( Global.hDevice,
		constIOCTLtmmanDSPStatus,
		(PVOID)&TMIF, sizeof (tmifDSPStatus),
		(PVOID)&TMIF, sizeof (tmifDSPStatus),
		&BytesReturned, NULL ) != TRUE )
	{
		return statusDeviceIoCtlFail;
	}

	*StatusFlags = TMIF.DSPStatus;
	return statusSuccess;
}

TMStatus  tmmanDSPGetEndianess ( 
	UInt32 DSPHandle, 
	UInt32* EndianFlags )
{
	tmifDSPEndianess	TMIF;
	UInt32	BytesReturned;

	TMIF.DSPHandle = DSPHandle;
	//TMIF.ClientHandle = Global.dwClientHandle;

	if ( DeviceIoControl ( Global.hDevice,
		constIOCTLtmmanDSPGetEndianess,
		(PVOID)&TMIF, sizeof (tmifDSPEndianess),
		(PVOID)&TMIF, sizeof (tmifDSPEndianess),
		&BytesReturned, NULL ) != TRUE )
	{
		return statusDeviceIoCtlFail;
	}

	*EndianFlags = TMIF.Endianess;
	return statusSuccess;
}

TMStatus  tmmanDSPGetInternalInfo ( 
	UInt32 DSPHandle, 
	tmmanDSPInternalInfo* DSPInfo )
{
	tmifDSPInternalInfo	TMIF;
	UInt32	BytesReturned;

	TMIF.DSPHandle = DSPHandle;
	//TMIF.ClientHandle = Global.dwClientHandle;

	if ( DeviceIoControl ( Global.hDevice,
		constIOCTLtmmanDSPGetInternalInfo,
		(PVOID)&TMIF, sizeof (tmifDSPInternalInfo),
		(PVOID)&TMIF, sizeof (tmifDSPInternalInfo),
		&BytesReturned, NULL ) != TRUE )
	{
		return statusDeviceIoCtlFail;
	}

	*DSPInfo = TMIF.Info;
	return TMIF.Status;
}

TMStatus  tmmanDSPSetInternalInfo ( 
	UInt32 DSPHandle, 
	tmmanDSPInternalInfo* DSPInfo )
{
	tmifDSPInternalInfo	TMIF;
	UInt32	BytesReturned;

	TMIF.DSPHandle = DSPHandle;
	//TMIF.ClientHandle = Global.dwClientHandle;
	
	TMIF.Info = *DSPInfo;

	if ( DeviceIoControl ( Global.hDevice,
		constIOCTLtmmanDSPSetInternalInfo,
		(PVOID)&TMIF, sizeof (tmifDSPInternalInfo),
		(PVOID)&TMIF, sizeof (tmifDSPInternalInfo),
		&BytesReturned, NULL ) != TRUE )
	{
		return statusDeviceIoCtlFail;
	}

	
	return TMIF.Status;
}
	
TMStatus  tmmanDSPOpen ( 
	UInt32 DSPNumber, 
	UInt32* DSPHandlePointer )
{
	tmifDSPOpen	TMIF;
	UInt32		BytesReturned;

	//TMIF.ClientHandle	= Global.dwClientHandle;
	TMIF.DSPNumber		= DSPNumber;

	if ( DeviceIoControl ( Global.hDevice, 
		constIOCTLtmmanDSPOpen,
		(PVOID)&TMIF, sizeof( tmifDSPOpen),
		(PVOID)&TMIF, sizeof( tmifDSPOpen),
		&BytesReturned, NULL ) != TRUE )
	{
		return statusDeviceIoCtlFail;
	}

	*DSPHandlePointer = TMIF.DSPHandle;
	return TMIF.Status;
}

TMStatus  tmmanDSPClose ( 
	UInt32 DSPHandle )
{
	tmifGenericFunction		TMIF;
	UInt32					BytesReturned;

	//TMIF.ClientHandle	= Global.dwClientHandle;
	TMIF.Handle		= DSPHandle;


	if ( DeviceIoControl ( Global.hDevice, 
		constIOCTLtmmanDSPClose,
		(PVOID)&TMIF, sizeof( tmifGenericFunction),
		(PVOID)&TMIF, sizeof( tmifGenericFunction),
		&BytesReturned, NULL ) != TRUE )
	{
		return statusDeviceIoCtlFail;
	}

	return TMIF.Status;
}

TMStatus  tmmanDSPMapSDRAM ( 
	UInt32 DSPHandle )
{
	tmifGenericFunction		TMIF;
	UInt32					BytesReturned;
	tmmanDSPInfo			DSPInfo;
	TMStatus				Status;

	//TMIF.ClientHandle	= Global.dwClientHandle;
	TMIF.Handle		= DSPHandle;

	if ( DeviceIoControl ( Global.hDevice, 
		constIOCTLtmmanMapSDRAM,
		(PVOID)&TMIF, sizeof( tmifGenericFunction),
		(PVOID)&TMIF, sizeof( tmifGenericFunction),
		&BytesReturned, NULL ) != TRUE )
	{
		return statusDeviceIoCtlFail;
	}

#ifdef TMMAN_WINCE

	if ( Global.MapSDRAM )
	{
		return TMIF.Status;
	}

	if ( ( Status = tmmanDSPGetInfo ( 
		DSPHandle, 
		&DSPInfo ) ) != statusSuccess )
	{
		return Status;
	}

	EnterCriticalSection (  &Global.SDRAMCriticalSection );

	if ( Global.SDRAMMapped[DSPInfo.DSPNumber] != 0 )
	{
		Global.SDRAMMapped[DSPInfo.DSPNumber]++;

		LeaveCriticalSection ( &Global.SDRAMCriticalSection );

		return statusSuccess;
	}

	// Map SDRAM into process V.A.S
	if ( ( Global.SDRAM[DSPInfo.DSPNumber].MappedAddress = (DWORD)VirtualAlloc(
		0,
		DSPInfo.SDRAM.Size,
		MEM_RESERVE,PAGE_NOACCESS) ) == 0 )
	{
		wsprintf ( szTemp,
			TEXT("tmman32:DLLInitialize:VirtualAlloc:SDRAM:FAIL[%x]\n"),GetLastError());
		OutputDebugString ( szTemp );

		LeaveCriticalSection ( &Global.SDRAMCriticalSection );		

		return statusOutOfVirtualAddresses;
	}

	if( ! VirtualCopy (
		(void *)Global.SDRAM[DSPInfo.DSPNumber].MappedAddress,
		(void *)(Global.SDRAM[DSPInfo.DSPNumber].PhysicalAddress>>8),
		Global.SDRAM[DSPInfo.DSPNumber].Size,
		PAGE_READWRITE|PAGE_PHYSICAL|PAGE_NOCACHE ) )
	{
		wsprintf ( szTemp,
			TEXT("tmman32:DLLInitialize:VirtualCopy:SDRAM:FAIL[%x]\n"),  GetLastError());
		OutputDebugString ( szTemp );

		VirtualFree(
			(void*)Global.SDRAM[DSPInfo.DSPNumber].MappedAddress,
			0,
			MEM_RELEASE );

		LeaveCriticalSection ( &Global.SDRAMCriticalSection );		

		return statusOutOfVirtualAddresses;
	}

	Global.SDRAMMapped[DSPInfo.DSPNumber]++;	

	LeaveCriticalSection ( &Global.SDRAMCriticalSection );

#endif

	return TMIF.Status;
}

TMStatus  tmmanDSPUnmapSDRAM ( 
	UInt32 DSPHandle )
{
	tmifGenericFunction		TMIF;
	UInt32					BytesReturned;
	tmmanDSPInfo			DSPInfo;
	TMStatus				Status;

	//TMIF.ClientHandle	= Global.dwClientHandle;
	TMIF.Handle		= DSPHandle;

	if ( DeviceIoControl ( Global.hDevice, 
		constIOCTLtmmanUnmapSDRAM,
		(PVOID)&TMIF, sizeof( tmifGenericFunction),
		(PVOID)&TMIF, sizeof( tmifGenericFunction),
		&BytesReturned, NULL ) != TRUE )
	{
		return statusDeviceIoCtlFail;
	}

#ifdef TMMAN_WINCE

	if ( Global.MapSDRAM )
	{
		return TMIF.Status;
	}

	if ( ( Status = tmmanDSPGetInfo ( 
		DSPHandle, 
		&DSPInfo ) ) != statusSuccess )
	{
		return Status;
	}

	EnterCriticalSection (  &Global.SDRAMCriticalSection );

	if ( Global.SDRAMMapped[DSPInfo.DSPNumber] == 0 )
	{
		LeaveCriticalSection ( &Global.SDRAMCriticalSection );
		return statusIncorrectParameter;
	}

	if ( Global.SDRAMMapped[DSPInfo.DSPNumber] != 1 )
	{
		LeaveCriticalSection ( &Global.SDRAMCriticalSection );
		Global.SDRAMMapped[DSPInfo.DSPNumber]--;
		return statusSuccess;
	}

	VirtualFree(
		(void*)Global.SDRAM[DSPInfo.DSPNumber].MappedAddress,
		0,
		MEM_RELEASE);
	
	Global.SDRAMMapped[DSPInfo.DSPNumber] = 0;

	LeaveCriticalSection ( &Global.SDRAMCriticalSection );

#endif

	return TMIF.Status;
}

TMStatus  tmmanDSPLoad ( 
	UInt32 DSPHandle, 
	UInt32 LoadAddress,
	Int8* ImagePath )
{
	tmmanDSPInfo				DSPInfo;
	tmmanDSPInternalInfo		DSPInternalInfo;
	TMStatus					Status  = statusSuccess;
	tmifDSPLoad					TMIF;
	TMDwnLdr_Object_Handle		ObjectHandle;
	UInt32	ImageSize;
	UInt32	Alignment;
	UInt32	AlignedDownloadAddress;
	UInt32	DownLoaderStatus;
	Endian	endian;
	UInt32	HostType = tmWinNTHost;
	UInt32	BytesReturned;
	UInt32	TargetVersion;

	// registry stuff
	UInt32	ClockSpeed =  100000000;
	UInt32	CacheOption = TMDwnLdr_LeaveCachingToDownloader;
	UInt32	INIEndianess = True; // little endian
	HKEY	RegistryHandle;
	HKEY	RegistryHandleDevice;

	TCHAR	szDeviceName[0x10];
	if ( ( Status = tmmanDSPMapSDRAM ( DSPHandle ) ) != statusSuccess )
	{
		OutputDebugString ( TEXT("tmman32:tmmanDSPMapSDRAM::FAIL\n"));
		goto tmmanDSPLoadExit1;		
	}

	tmmanDSPGetInfo ( 
		DSPHandle, 
		&DSPInfo );

	tmmanDSPGetInternalInfo ( 
		DSPHandle, 
		&DSPInternalInfo );
	

	if ( ERROR_SUCCESS == RegOpenKeyEx(  
		HKEY_LOCAL_MACHINE,
		constTMManRegistryPath,
		0,
		KEY_READ,
		&RegistryHandle ) )
	{
		ULONG	BytesXfered;
		
		BytesXfered = sizeof ( ULONG );

		if ( ERROR_SUCCESS != RegQueryValueEx(
			RegistryHandle,
			TEXT("DefaultEndianness"),
			NULL,
			NULL,
			(BYTE*)&INIEndianess,
			&BytesXfered ) )
		{
			INIEndianess = True;
		}

		wsprintf ( szDeviceName, TEXT("Device%x"), DSPInfo.DSPNumber );

		if ( ERROR_SUCCESS == RegOpenKeyEx(  
			RegistryHandle,
			szDeviceName,
			0,
			KEY_READ,
			&RegistryHandleDevice ) )
		{
			BytesXfered = sizeof ( ULONG );

			if ( ERROR_SUCCESS != RegQueryValueEx(
				RegistryHandleDevice,
				TEXT("ClockSpeed"),
				NULL,
				NULL,
				(BYTE*)&ClockSpeed,
				&BytesXfered ) )
			{
				ClockSpeed = 100000000;
			}

			BytesXfered = sizeof ( ULONG );

			if ( ERROR_SUCCESS != RegQueryValueEx(
				RegistryHandleDevice,
				TEXT("CacheOption"),
				NULL,
				NULL,
				(BYTE*)&CacheOption,
				&BytesXfered ) )
			{
				CacheOption = TMDwnLdr_LeaveCachingToDownloader;
			}

			RegCloseKey ( RegistryHandleDevice );
		}

		RegCloseKey ( RegistryHandle );
	}

	if ( LoadAddress == constTMManDefault )
	{
		LoadAddress = DSPInfo.SDRAM.PhysicalAddress;
	}

	if ( ( DownLoaderStatus = TMDwnLdr_load_object_from_file ( 
		ImagePath,
		NULL, 
		&ObjectHandle ) ) != TMDwnLdr_OK )
	{
		Status = tmmanDownloaderStatusToTMManStatus(DownLoaderStatus);
		goto tmmanDSPLoadExit2;
	}

	// BEGIN symbol patching

	if ( ( TMDwnLdr_resolve_symbol( 
		ObjectHandle, 
		"_TMManShared", 
		DSPInternalInfo.TMManSharedPhysicalAddress ) ) != TMDwnLdr_OK )
	{
		OutputDebugString( TEXT("tmman32:tmmanDSPLoad:WARNING:TMDwnLdr_resolve_symbol[_TMManShared]:FAIL\n") );
		HostType = tmNoHost;

		if ( ! Global.DisableDialogBox )
		{
			WarningBox(TEXT("Target Executable has not been linked with [-host Win95] or [-host WinNT]\n"));
		}
	}

  	if ( ( DownLoaderStatus = TMDwnLdr_get_image_size ( ObjectHandle, 
		&ImageSize, &Alignment 	) )!= TMDwnLdr_OK )
	{
		Status = tmmanDownloaderStatusToTMManStatus(DownLoaderStatus);
		goto tmmanDSPLoadExit3; 
	}

	AlignedDownloadAddress = ( (LoadAddress + Alignment -1 ) & ( ~( Alignment - 1 ) ) );
#define FIX_NODE_NUMBER
#ifdef FIX_NODE_NUMBER
	{
 
		#define MAXIMUM_NODES			256

		int   iDSPCount =0; 
		DWORD		MMIOPhysicalAddressArray[MAXIMUM_NODES];

		MMIOPhysicalAddressArray[DSPInfo.DSPNumber] = DSPInfo.MMIO.PhysicalAddress;
		iDSPCount = tmmanDSPGetNum();