tmman.c

wince host 和 target PCI驱动程序

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

UInt32		tmmanDSPGetNum ( void )
{
	return  1; /*HARDCODED */
}

TMStatus  tmmanDSPGetInfo ( 
	UInt32 DSPHandle, 
	tmmanDSPInfo* DSPInfo )
{
	TMManObject* TMMan = (TMManObject*)DSPHandle;
	UInt32		Dummy;

	halGetMMIOInfo (
		TMMan->HalHandle,
		(Pointer*)&DSPInfo->MMIO.PhysicalAddress,
		(Pointer*)&DSPInfo->MMIO.MappedAddress,
		&DSPInfo->MMIO.Size );

	halGetSDRAMInfo (
		TMMan->HalHandle,
		(Pointer*)&DSPInfo->SDRAM.PhysicalAddress,
		(Pointer*)&DSPInfo->SDRAM.MappedAddress,
		&DSPInfo->SDRAM.Size );

	halGetTMPCIInfo ( 
		TMMan->HalHandle,
		&DSPInfo->TMDeviceVendorID,
		&DSPInfo->TMSubSystemID,
		&DSPInfo->TMClassRevisionID );

	halGetBridgePCIInfo ( 
		TMMan->HalHandle,
		&DSPInfo->BridgeDeviceVendorID,
		&DSPInfo->BridgeSubsystemID,
		&DSPInfo->BridgeClassRevisionID );
	
	DSPInfo->DSPNumber = 0;

	return statusSuccess;
}
/* DSP FUNCTIONS */
TMStatus  tmmanDSPGetStatus ( 
	UInt32 DSPHandle, 
	UInt32* StatusFlags )
{
	*StatusFlags = constTMManDSPStatusRunning;
	return statusSuccess;
}


TMStatus  tmmanDSPMapSDRAM ( 
	UInt32 DSPHandle )
{
	return statusUnsupportedOnThisPlatform;
}

TMStatus  tmmanDSPUnmapSDRAM ( 
	UInt32 DSPHandle )
{
	return statusUnsupportedOnThisPlatform;
}

TMStatus  tmmanDSPGetEndianess ( 
	UInt32 DSPHandle, 
	UInt32* EndianessFlags )
{
	return statusUnsupportedOnThisPlatform;
}

	
TMStatus  tmmanDSPOpen ( 
	UInt32 DSPNumber, 
	UInt32* DSPHandlePointer )
{
	if ( DSPNumber > 0 )
	{
		return statusDSPNumberOutofRange;
	}
	*DSPHandlePointer = (UInt32)&TMManArray[DSPNumber];
	return statusSuccess;
}

TMStatus  tmmanDSPClose ( 
	UInt32 DSPHandle )
{
	return statusSuccess;
}

TMStatus  tmmanDSPLoad ( 
	UInt32 DSPHandle, 
	UInt32 LoadAddress,
	Int8* ImagePath )
{
	return statusUnsupportedOnThisPlatform;
}

TMStatus  tmmanDSPStart ( 
	UInt32 DSPHandle )
{
	return statusUnsupportedOnThisPlatform;
}


TMStatus  tmmanDSPStop ( 
	UInt32 DSPHandle )
{
	return statusUnsupportedOnThisPlatform;
}

TMStatus  tmmanDSPReset ( 
	UInt32 DSPHandle )
{
	return statusUnsupportedOnThisPlatform;
}



UInt32	tmmanMappedToPhysical ( 
	tmmanMemoryBlock* MemoryBlock, 
	UInt32 MappedAddress )
{
	return MappedAddress;
}

UInt32	tmmanPhysicalToMapped ( 
	tmmanMemoryBlock* MemoryBlock, 
	UInt32 PhysicalAddress )
{
	return PhysicalAddress;
}


Bool    tmmanValidateAddressAndLength ( 
	tmmanMemoryBlock* MemoryBlock, 
	UInt32 Address, 
	UInt32 Length )
{

    /* assumes that MMIO and SDRAM are not contigious. */
    if ( ( Address >= MemoryBlock->PhysicalAddress ) &&
        ( Address < (MemoryBlock->PhysicalAddress + MemoryBlock->Size - 1) ) )
    {
        if ( ( Address + Length ) <=
            (MemoryBlock->PhysicalAddress + MemoryBlock->Size - 1))
            return True;
        else
            return False;
    }
    return False;
}


TMStatus  tmmanMessageCreate ( 
	UInt32	DSPHandle,
	Int8*	Name,
	UInt32	SynchronizationHandle,
	UInt32	SynchronizationFlags,
	UInt32* MessageHandlePointer )
{
	TMManObject* TMMan = (TMManObject*)DSPHandle;

	return messageCreate ( 
		TMMan->MessageManagerHandle,
		Null, /* client listhead struct */
		Name,
		SynchronizationHandle,
		SynchronizationFlags,
		MessageHandlePointer );
}

TMStatus  tmmanMessageDestroy ( 
	UInt32 MessageHandle )
{
	return	messageDestroy (
		MessageHandle );
}

TMStatus  tmmanMessageSend ( 
	UInt32 MessageHandle, 
	void *DataPointer )
{
	return messageSend (
		MessageHandle,
		DataPointer );
}

TMStatus  tmmanMessageReceive ( 
	UInt32 MessageHandle, 
	void *DataPointer )
{
	return messageReceive ( 
		MessageHandle,
		DataPointer );
}

TMStatus	tmmanEventCreate (
	UInt32	DSPHandle,						
	Int8*	Name,
	UInt32	SynchronizationHandle,
	UInt32	SynchronizationFlags,
	UInt32* EventHandlePointer )
{
	TMManObject* TMMan = (TMManObject*)DSPHandle;

	return eventCreate (
		TMMan->EventManagerHandle,						
		Null, 
		Name,
		SynchronizationHandle,
		SynchronizationFlags,
		EventHandlePointer );
}

TMStatus	tmmanEventSignal (
	UInt32 EventHandle )
{
	return eventSignal (
		EventHandle );
}

TMStatus	tmmanEventDestroy (
	UInt32 EventHandle )
{
	return eventDestroy (
		EventHandle );
}

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

TMStatus  tmmanSharedMemoryDestroy ( 
	UInt32	SharedMemoryHandle )
{
	return statusUnsupportedOnThisPlatform;
}


TMStatus  tmmanSharedMemoryOpen ( 
	UInt32 DSPHandle, 
	Int8*	Name,
	UInt32* LengthPtr,
	UInt32*	AddressPointer,
	UInt32*	SharedMemoryHandlePointer )
{
	TMManObject* TMMan = (TMManObject*)DSPHandle;

	return memoryOpen ( 
		TMMan->MemoryManagerHandle, 
		Null, /* client listhead struct */
		Name,
		LengthPtr,
		(Pointer*)AddressPointer,
		SharedMemoryHandlePointer );
}

TMStatus  tmmanSharedMemoryClose (
	UInt32	SharedMemoryHandle )
{
	return memoryClose (
		SharedMemoryHandle );
}

TMStatus  tmmanSGBufferCreate ( 
	UInt32	DSPHandle, 
	Int8*	Name,
	UInt32	MappedAddress,
	UInt32	Size,
	UInt32	Flags,
	UInt32* BufferHandlePointer )
{
	return statusUnsupportedOnThisPlatform;
}

TMStatus  tmmanSGBufferDestroy ( 
	UInt32	BufferHandle )
{
	return statusUnsupportedOnThisPlatform;
}

TMStatus  tmmanSGBufferOpen ( 
	UInt32	DSPHandle, 
	Int8*	Name,
	UInt32*	EntryCountPointer,
	UInt32* SizePointer,
	UInt32* BufferHandlePointer )
{
	TMManObject* TMMan = (TMManObject*)DSPHandle;

	return sgbufferOpen ( 
		TMMan->SGBufferManagerHandle, 
		Null,
		Name,
		EntryCountPointer,
		SizePointer,
		BufferHandlePointer );
}

TMStatus  tmmanSGBufferClose ( 
	UInt32 BufferHandle )
{
	return sgbufferClose (
		BufferHandle );
}

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

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

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

TMStatus	tmmanDebugOptions (
	UInt32	DSPHandle, 
	UInt32	Option )
{
	debugLevel ( Option );
	return statusSuccess;
}


TMStatus	tmmanDebugDPBuffers (
	UInt32	DSPHandle, 
	UInt8*	*FirstHalfPtr, 
	UInt32*	FirstHalfSizePtr, 
	UInt8*	*SecondHalfPtr, 
	UInt32*	SecondHalfSizePtr )
{
	return statusUnsupportedOnThisPlatform;
}

TMStatus	tmmanDebugHostBuffers (
	UInt8*	*FirstHalfPtr, 
	UInt32*	FirstHalfSizePtr, 
	UInt8*	*SecondHalfPtr, 
	UInt32*	SecondHalfSizePtr )
{
	return statusUnsupportedOnThisPlatform;
}

TMStatus	tmmanDebugTargetBuffers (
 	UInt32	DSPHandle, 
	UInt8*	*FirstHalfPtr, 
	UInt32*	FirstHalfSizePtr, 
	UInt8*	*SecondHalfPtr, 
	UInt32*	SecondHalfSizePtr )
{
	return statusUnsupportedOnThisPlatform;
}

UInt32 tmmanDebugPrintf ( 
	Int8 *Format, ... )
{
    UInt32  Items;
    Int8   Buffer[constTMManDebugStringLength];

    va_list Arguments;

    va_start ( Arguments, Format );

    Items = vsprintf ( (Int8*) Buffer,  Format, Arguments );

    va_end ( Arguments );

    DPF(31,((Int8*)Buffer));

    return Items;
}