tmman32.c

wince host 和 target PCI驱动程序

	
	LeaveCriticalSection ( &Global.MessageCriticalSection );


	return TMIF.Status;
}

TMStatus  tmmanMessageSend ( 
	UInt32 MessageHandle, 
	void *DataPointer )
{
	tmifMessageSR	TMIF;
	UInt32		BytesReturned;

	TMIF.MessageHandle = MessageHandle;

	// the user is supposed to take care of endianess
	memcpy ( TMIF.Packet, DataPointer, constTMManPacketSize );

	
	EnterCriticalSection ( &Global.MessageCriticalSection );
	

	//TMIF.ClientHandle = Global.dwClientHandle;
	if ( DeviceIoControl ( Global.hDevice,
		constIOCTLtmmanMessageSend,
		(PVOID)&TMIF, sizeof (tmifMessageSR),
		(PVOID)&TMIF, sizeof (tmifMessageSR),
		&BytesReturned, NULL ) != TRUE )
	{
		LeaveCriticalSection ( &Global.MessageCriticalSection );
		return statusDeviceIoCtlFail;
	}

	
	LeaveCriticalSection ( &Global.MessageCriticalSection );


	return TMIF.Status;
}

TMStatus  tmmanMessageReceive ( 
	UInt32 MessageHandle, 
	void *DataPointer )
{
	tmifMessageSR	TMIF;
	UInt32		BytesReturned;

	TMIF.MessageHandle = MessageHandle;


	
	EnterCriticalSection ( &Global.MessageCriticalSection );


	//TMIF.ClientHandle = Global.dwClientHandle;
	if ( DeviceIoControl ( Global.hDevice,
		constIOCTLtmmanMessageReceive,
		(PVOID)&TMIF, sizeof (tmifMessageSR),
		(PVOID)&TMIF, sizeof (tmifMessageSR),
		&BytesReturned, NULL ) != TRUE )
	{
		LeaveCriticalSection ( &Global.MessageCriticalSection );
		return statusDeviceIoCtlFail;
	}
	// the user is supposed to take care of endianess
	memcpy ( DataPointer, TMIF.Packet, constTMManPacketSize );

	
	LeaveCriticalSection ( &Global.MessageCriticalSection );


	return TMIF.Status;
}

//  Event API

TMStatus  tmmanEventCreate ( 
	UInt32	DSPHandle,
	Int8*	Name,
	UInt32	SynchronizationHandle,
	UInt32	SynchronizationFlags,
	UInt32* EventHandlePointer )
{
	tmifEventCreate	TMIF;
	UInt32			BytesReturned;

	TMIF.DSPHandle = DSPHandle;

	if ( strlen ( Name ) >= constTMManNameSpaceNameLength )
	{
		return statusNameSpaceLengthExceeded;
	}

	strcpy ( TMIF.Name, Name );

	switch ( WindowsVersion )
	{
		case WINDOWS_OS_WIN98 :
		case WINDOWS_OS_WINNT40 :
		case WINDOWS_OS_WINNT50 :
		case WINDOWS_OS_WINCE2X :
		TMIF.SynchObject = SynchronizationHandle;
		break;

		case WINDOWS_OS_WIN95 :
		{
			HMODULE		InstanceHandle;
			FARPROC		ProcAddress;

			if ( ( InstanceHandle = LoadLibrary (TEXT("Kernel32.dll")) ) == NULL )
			{
				OutputDebugString( TEXT("tmman32:LoadLibrary:FAIL\n") );
				//return statusCannotLoadKernel32DLL;
				return statusDeviceIoCtlFail;
			}

			if ( ( ProcAddress = GetProcAddress(InstanceHandle, TEXT("OpenVxDHandle") ) ) == NULL )
			{
				OutputDebugString( TEXT("tmman32:LoadLibrary:FAIL\n") );
				FreeLibrary (InstanceHandle);
				//return statusCannotLoadKernel32DLL;
				return statusDeviceIoCtlFail;

			}

			TMIF.SynchObject = (ProcAddress)(SynchronizationHandle);

			FreeLibrary (InstanceHandle);
		}
		break;
	}
	
	TMIF.SynchFlags = SynchronizationFlags;


	//TMIF.ClientHandle = Global.dwClientHandle;

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

	*EventHandlePointer = TMIF.EventHandle;
	return TMIF.Status;
}

TMStatus  tmmanEventDestroy ( 
	UInt32 EventHandle )
{
	tmifGenericFunction	TMIF;
	UInt32				BytesReturned;

	TMIF.Handle = EventHandle;

	//TMIF.ClientHandle = Global.dwClientHandle;

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

	return TMIF.Status;
}

TMStatus  tmmanEventSignal ( 
	UInt32 EventHandle )
{
	tmifGenericFunction	TMIF;
	UInt32				BytesReturned;

	TMIF.Handle = EventHandle;


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

	return TMIF.Status;
}



TMStatus  tmmanSharedMemoryCreate ( 
	UInt32	DSPHandle, 
	Int8*	Name,
	UInt32	Length,
	UInt32*	AddressPointer,
	UInt32* SharedMemoryHandlePointer )
{
	tmifSharedMemoryCreate	TMIF;
	UInt32		BytesReturned;
	tmifDSPInfo		DSPInfo;

	TMIF.DSPHandle = DSPHandle;

	if ( strlen ( Name ) >= constTMManNameSpaceNameLength )
	{
		return statusNameSpaceLengthExceeded;
	}

	DSPInfo.DSPHandle = DSPHandle;

	if ( DeviceIoControl ( Global.hDevice, 
		constIOCTLtmmanDSPInfo,
		(PVOID)&DSPInfo, sizeof( tmifDSPInfo) ,
		(PVOID)&DSPInfo, sizeof( tmifDSPInfo) ,
		&BytesReturned, NULL ) != TRUE )
	{
		return statusDeviceIoCtlFail;
	}
	
	
	strcpy ( TMIF.Name, Name );
	TMIF.Size = Length;


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

	*AddressPointer = 
		(UInt32)TMIF.Address + (DWORD)Global.Memory[DSPInfo.Info.DSPNumber].MappedAddress; 
	*SharedMemoryHandlePointer = TMIF.SharedMemoryHandle;

	return TMIF.Status;
}

TMStatus  tmmanSharedMemoryGetAddress ( 
	UInt32	SharedMemoryHandle,
	UInt32*	PhysicalAddressPointer )
{
	tmifSharedMemoryAddress	TMIF;
	UInt32		BytesReturned;

	TMIF.SharedMemoryHandle = SharedMemoryHandle;

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

	*PhysicalAddressPointer = TMIF.PhysicalAddress;

	return TMIF.Status;
}

TMStatus  tmmanSharedMemoryDestroy ( 
	UInt32	SharedMemoryHandle )
{
	tmifGenericFunction	TMIF;
	UInt32		BytesReturned;

	TMIF.Handle = SharedMemoryHandle;

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

	return TMIF.Status;
}


TMStatus  tmmanSharedMemoryOpen ( 
	UInt32 DSPHandle, 
	Int8*	Name,
	UInt32*	LengthPtr,
	UInt32*	AddressPointer,
	UInt32*	SharedMemoryHandlePointer )
{
	return statusUnsupportedOnThisPlatform;
}

TMStatus  tmmanSharedMemoryClose (
	UInt32	SharedMemoryHandle )
{
	return statusUnsupportedOnThisPlatform;
}


/*
tmmanSGBufferCreate
Implementation Notes :
This is probably the only function that is going to queue an IRP for
deferred processing. The problem that arises is that we have to create
a user mode event or APC that will will get signalled when the IRP 
completes in KM. 
In all the other calls we are not maintaining any User Mode context
but fot this call we have to maintain some context to store the event.
And pass that event in the overlapped structure to the KMD.

Temporarily the problem is circumvented by using a single overlapped 
structure for all tmSGBufferCreate calls. We don't care about the 
Overlapped Event since we are not going to be blocked on it anyways.
	
*/
TMStatus  tmmanSGBufferCreate ( 
	UInt32	DSPHandle, 
	Int8*	Name,
	UInt32	MappedAddress,
	UInt32	Size,
	UInt32	Flags,
	UInt32* BufferHandlePointer )
{
	tmifSGBufferCreate	TMIF;
	UInt32		BytesReturned;
	UInt32		OldProtection;

	TMIF.DSPHandle = DSPHandle;

	if ( strlen ( Name ) >= constTMManNameSpaceNameLength )
	{
		return statusNameSpaceLengthExceeded;
	}

	strcpy ( TMIF.Name, Name );

	TMIF.Size			= Size;
	TMIF.MappedAddress	= MappedAddress;
	TMIF.Flags			= Flags;

#ifdef UNDER_CE
    // 1)make sure buffer is page aligned and non cached
    // 2)as process context is different in the device driver
    //   we have to pass the Mapped and its size as aq buffer
    //   parameter in the DeviceIoControl call. In that case
    //   the memory will be mapped into the new context

    if (VirtualProtect((void*)MappedAddress, Size, PAGE_READWRITE|PAGE_NOCACHE, 
        &OldProtection) == FALSE)
    {
        return statusMemoryUnavailable;
    }

	if ( DeviceIoControl ( Global.hDevice,
		constIOCTLtmmanSGBufferCreate,
		(PVOID)&TMIF, sizeof (tmifSGBufferCreate),
		(PVOID)MappedAddress, Size,
		&BytesReturned, NULL ) != TRUE )//&Global.Overlapped ) != TRUE )
	{
		return statusDeviceIoCtlFail;
	}
#else

	if ( DeviceIoControl ( Global.hDevice,
		constIOCTLtmmanSGBufferCreate,
		(PVOID)&TMIF, sizeof (tmifSGBufferCreate),
		(PVOID)&TMIF, sizeof (tmifSGBufferCreate),
		&BytesReturned, NULL ) != TRUE )//&Global.Overlapped ) != TRUE )
	{
		return statusDeviceIoCtlFail;
	}
#endif

	*BufferHandlePointer = TMIF.SGBufferHandle;
	return TMIF.Status;
}

TMStatus  tmmanSGBufferDestroy ( 
	UInt32	BufferHandle )
{
	tmifGenericFunction	TMIF;
	UInt32		BytesReturned;

	TMIF.Handle = BufferHandle;

	//TMIF.ClientHandle = Global.dwClientHandle;

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

	return TMIF.Status;
}
TMStatus  tmmanSGBufferOpen ( 
	UInt32	DSPHandle, 
	Int8*	Name,
	UInt32*	EntryCountPointer,
	UInt32* SizePointer,
	UInt32* BufferHandlePointer )
{
	return statusUnsupportedOnThisPlatform;
}

TMStatus  tmmanSGBufferClose ( 
	UInt32	BufferHandle )
{
	return statusUnsupportedOnThisPlatform;
}

TMStatus	tmmanSGBufferFirstBlock ( 
	UInt32	BufferHandle,
	UInt32* OffsetPointer, 
	UInt32* AddressPointer, 
	UInt32* SizePointer )
{
	return statusUnsupportedOnThisPlatform;
}

TMStatus	tmmanSGBufferNextBlock ( 
	UInt32	BufferHandle,
	UInt32* OffsetPointer, 
	UInt32* AddressPointer, 
	UInt32* SizePointer )
{
	return statusUnsupportedOnThisPlatform;
}

TMStatus	tmmanSGBufferCopy ( 
	UInt32	BufferHandle,
	UInt32	Offset,
	UInt32	Address, 
	UInt32	Size, 
	UInt32	Direction )
{
	return statusUnsupportedOnThisPlatform;
}

Bool	tmmanGetImageInfo (
	Int8*	ImagePath,
	UInt32*	TypePtr,
	UInt32*	EndianPtr )
{
	HANDLE				ImageFileHandle;
	TMObj_Module_Rec	ExecutableHeader;
	UInt32				BytesReturned;
	TCHAR*				UnicodeImagePath;

	// BEGIN APPLOAD

	if ( ( UnicodeImagePath = CreateUnicodeStr(ImagePath) ) == NULL )
	{
		goto tmmanGetImageInfoExit1;
	}

	if ( ( ImageFileHandle = CreateFile ( 
		UnicodeImagePath,
		GENERIC_READ,
		FILE_SHARE_READ | FILE_SHARE_WRITE,
		NULL,
		OPEN_EXISTING,
		FILE_ATTRIBUTE_NORMAL,
		NULL ) ) == INVALID_HANDLE_VALUE )
	{
		OutputDebugString ( TEXT("tmman32:tmmanGetModuleInfo:CreateFile:FAIL\n") );
		goto tmmanGetImageInfoExit2;
	}


	if ( ReadFile( ImageFileHandle,
		&ExecutableHeader,
		sizeof(TMObj_Module_Rec),
		&BytesReturned, 
		NULL ) == FALSE )
	{
		OutputDebugString ( TEXT("tmman32:tmmanGetModuleInfo:ReadFile:FAIL\n") );
		goto tmmanGetImageInfoExit3;
	}

	if ( BytesReturned != sizeof(TMObj_Module_Rec) )
	{
		OutputDebugString ( TEXT("tmman32:tmmanGetModuleInfo:ReadFile:sizeof(TMObj_Module_Rec):FAIL\n") );
		goto tmmanGetImageInfoExit3;
		return False;
	}

	CloseHandle ( ImageFileHandle );
	DeleteUnicodeStr ( UnicodeImagePath );

	*TypePtr = (UInt32)ExecutableHeader.type ;
	*EndianPtr = (UInt32)ExecutableHeader.code_endian;
	return True;


tmmanGetImageInfoExit3:
	CloseHandle(ImageFileHandle );

tmmanGetImageInfoExit2:
	DeleteUnicodeStr ( UnicodeImagePath );

tmmanGetImageInfoExit1:
	return False;
}

Bool	tmmanGetTCSPath ( 
	Int8*	TCSPathBuffer,
	UInt32	TCSPathBufferLength )
{
	HKEY	RegistryHandle;
	ULONG	BytesXfered;

	if ( ERROR_SUCCESS != RegOpenKeyEx(  
		HKEY_LOCAL_MACHINE,
		constTMManRegistryPath,
		0,
		KEY_READ,
		&RegistryHandle ) )
	{
		return False;
	}
		
	BytesXfered = TCSPathBufferLength;

	if ( ERROR_SUCCESS != RegQueryValueEx(
		RegistryHandle,
		TEXT("TCSPath"),
		NULL,
		NULL,
		TCSPathBuffer,
		&BytesXfered ) )
	{
		return False;
	}

	RegCloseKey ( RegistryHandle );

	return True;
}


HANDLE	tmmanGetDriverHandle ( VOID )
{
	return Global.hDevice;
}

//////////////////////////////////////////////////////
//		WINCE ADDED FUNCTIONALITY
//////////////////////////////////////////////////////
#ifdef TMMAN_WINCE

TCHAR* CreateUnicodeStr(char* szString)
{
    TCHAR* wsString;
    wsString = (TCHAR*)LocalAlloc(LMEM_ZEROINIT, 2*strlen(szString)+16 );

    //BUGBUG: we have to alllocate one character more than necessary and zero it out
    //        WINCE UNICODE bug!
    MultiByteToWideChar(  CP_ACP,           // code page
                          MB_PRECOMPOSED,   // character-type options
                          szString,         // address of string to map
                          strlen(szString), // number of bytes in string
                          wsString,         // address of wide-character buffer
                          2*strlen(szString));// size of buffer);

    return ( wsString );
}

void DeleteUnicodeStr( TCHAR* wsString)
{
    LocalFree(wsString);
}

BOOL SetConsoleCtrlHandler ( 
	PHANDLER_ROUTINE HandlerRoutine, 
	BOOL Add )
{
	return TRUE;
}
 
BOOL WINAPI tmmanControlHandler ( DWORD dwCtrlType )
{
	return TRUE;
}
#else	//TMMAN_WINCE

HANDLE RegisterDevice( 
	TCHAR* lpszType,
	DWORD dwIndex,
	TCHAR* lpszLib, 
	DWORD dwInfo )
{
	return NULL;
}

BOOL DeregisterDevice( HANDLE hDevice )
{
	return TRUE;
}

TCHAR* CreateUnicodeStr(char* szString)
{	
	return szString;
}

void DeleteUnicodeStr( TCHAR* wsString)
{

}

BOOL WINAPI tmmanControlHandler ( DWORD dwCtrlType )
{
	
	wsprintf ( szTemp, "\ntmman32:tmmanControlHandler [%x]\n", dwCtrlType );
	OutputDebugString ( szTemp );
	switch ( dwCtrlType )
	{
		case	CTRL_C_EVENT :
		case	CTRL_BREAK_EVENT :
		case	CTRL_CLOSE_EVENT :
		case	CTRL_LOGOFF_EVENT :
		case	CTRL_SHUTDOWN_EVENT :
		break;
	}
	return FALSE;
}


#endif	//TMMAN_WINCE