/*---------------------------------------------------------------------------- 
COPYRIGHT (c) 1997 by Philips Semiconductors

THIS SOFTWARE IS FURNISHED UNDER A LICENSE AND MAY ONLY BE USED AND COPIED IN 
ACCORDANCE WITH THE TERMS AND CONDITIONS OF SUCH A LICENSE AND WITH THE 
INCLUSION OF THE THIS COPY RIGHT NOTICE. THIS SOFTWARE OR ANY OTHER COPIES 
OF THIS SOFTWARE MAY NOT BE PROVIDED OR OTHERWISE MADE AVAILABLE TO ANY OTHER
PERSON. THE OWNERSHIP AND TITLE OF THIS SOFTWARE IS NOT TRANSFERRED. 

THE INFORMATION IN THIS SOFTWARE IS SUBJECT TO CHANGE WITHOUT ANY PRIOR NOTICE
AND SHOULD NOT BE CONSTRUED AS A COMMITMENT BY Philips Semiconductor. 

PHILIPS ASSUMES NO RESPONSIBILITY FOR THE USE OR RELIABILITY OF THIS SOFTWARE
ON PLATFORMS OTHER THAN THE ONE ON WHICH THIS SOFTWARE IS FURNISHED.
----------------------------------------------------------------------------*/

//////////////////////////////////////////////////////////////////////////////
//	HISTORY
//
//	960405	Tilakraj Roy 	Created
//	960710	Tilakraj Roy	Started adding code for tmman inteface 
//	961008	Tilakraj Roy	Added code for shared memory allocaiton interfaces.
//	961010	Tilakraj Roy	Added code for image loading, running & stopping
//	970806	Tilakraj Roy	Ported to Workstation V4.0
//	982005	Volker Schildwach	Ported to Windwos CE
//	981021	Tilakraj Roy	Changes for integrating into common source base
//
//////////////////////////////////////////////////////////////////////////////


//////////////////////////////////////////////////////////////////////////////
//				SYSTEM INCLUDE FILES
//////////////////////////////////////////////////////////////////////////////
#include <windows.h>
#include "ceddk.h"

//////////////////////////////////////////////////////////////////////////////
//				DRIVER INCLUDE FILES
//////////////////////////////////////////////////////////////////////////////

#include "tmmanapi.h"
#include "tmmanlib.h"
#include "platform.h"
#include "verinfo.h"
#include "tmif.h"

//////////////////////////////////////////////////////////////////////////////
//				MANIFEST CONSTANTS
//////////////////////////////////////////////////////////////////////////////


//////////////////////////////////////////////////////////////////////////////
//				TYPEDEFS
//////////////////////////////////////////////////////////////////////////////
#define tmmanDownloaderStatusToTMManStatus(x) \
	(((x)!=TMDwnLdr_OK)?(x+0x70):statusSuccess)

//////////////////////////////////////////////////////////////////////////////
//				PROTOTYPES
//////////////////////////////////////////////////////////////////////////////

TMStatus	tmmanKernelModeNegotiateVersion ( tmmanVersion* Version );



//////////////////////////////////////////////////////////////////////////////
//				IMPLEMENTATION
//////////////////////////////////////////////////////////////////////////////

DWORD
TMM_Open(
	DWORD	dwClientContext,
	DWORD	dwAccessCode,
	DWORD	dwShareMode
	)
{
	UInt32				ClientIdx, DeviceIdx;
	ClientObject*		Client;

    // search for an empty slot.
	DPF(1,("tmman:tmmanOpen:ClientList:"));
	for ( ClientIdx = 0 ; ClientIdx < TMManGlobal->MaximumClients ; ClientIdx ++ )
	{
		if ( TMManGlobal->ClientList[ClientIdx] )
		{
			DPF(1,("[#%x:%x]", 
				ClientIdx, ((ClientObject*)TMManGlobal->ClientList[ClientIdx])->Process ));
			continue;
		}
		else
		{
			break;
		}
	}

	DPF(1,("\n"));

	if ( ClientIdx == TMManGlobal->MaximumClients )
	{
		DPF(0,("tmman:tmmanOpen:NoMoreClientsFree\n"));
		goto tmmanOpenExit1;
	}
		
	TMManGlobal->ClientList[ClientIdx] = memAllocate ( 
		sizeof ( ClientObject ) + sizeof ( ClientDeviceObject ) * ( TMManGlobal->DeviceCount - 1 ) ); 

	if ( TMManGlobal->ClientList[ClientIdx] == Null )
	{
		DPF(0,("tmman:tmmanOpen:memAllocate:FAIL\n"));
		goto tmmanOpenExit1;	
	}
	
	Client = TMManGlobal->ClientList[ClientIdx];


    // the current process always is the same (device.exe) under Windows CE
    // and the alocated address space is specific for each client, we can use
    // the address to determine a client 
    Client->Process = (DWORD) Client;


	Client->DeviceCount = TMManGlobal->DeviceCount;

	// initialize the per device data structures
	// BUGCHECK - we have to go by Client->DeviceCount since devices could have
	// gone away Workstation 5.0 problem.
	for ( DeviceIdx = 0 ; DeviceIdx < TMManGlobal->DeviceCount ; DeviceIdx++ )
	{
		TMManDeviceObject* TMManDevice = TMManGlobal->DeviceList[DeviceIdx];
		UInt32	Length;
		PVOID	AddrKernel;
		PVOID	AddrPhys;
		
		Client->Device[DeviceIdx].Device = TMManDevice;

		halGetMMIOInfo (
			TMManDevice->HalHandle,
			(Pointer*)&AddrPhys,
			(Pointer*)&AddrKernel,
			&Length );

        Client->Device[DeviceIdx].MMIOAddrUser   = AddrKernel;
        Client->Device[DeviceIdx].MMIOAddrPhys   = AddrPhys;

		halGetSDRAMInfo (
			TMManDevice->HalHandle,
			(Pointer*)&AddrPhys,
			(Pointer*)&AddrKernel,
			&Length );

        Client->Device[DeviceIdx].SDRAMAddrUser  = AddrKernel;
        Client->Device[DeviceIdx].SDRAMAddrPhys  = AddrPhys;
        Client->Device[DeviceIdx].MemoryAddrUser = TMManDevice->MemoryBlock;

	}

	TMManGlobal->ClientCount++;

	// return identifier for this client
    return Client->Process;

tmmanOpenExit1:
    return 0;
}

BOOL
TMM_Close(
	DWORD	dwOpenContext)
{
	UInt32				ClientIdx, DeviceIdx;
	ClientObject*		Client;
	PEPROCESS			Process;


    Process = dwOpenContext;
	
	DPF(1,("tmman:tmmanClose:Process[%x]\n", Process ));

	for ( ClientIdx = 0 ; ClientIdx < TMManGlobal->MaximumClients ; ClientIdx ++ )
	{
		if ( !TMManGlobal->ClientList[ClientIdx] )
			continue;

		if ( ((ClientObject*)TMManGlobal->ClientList[ClientIdx])->Process != Process )
			continue;
		break;
	}

	if ( ClientIdx == TMManGlobal->MaximumClients )
	{
		DPF(0,("tmman:tmmanClose:PANIC:InvalidHandle:Process[%x]\n", Process ));
		goto tmmanCloseExit1;
	}
	// assume one open handle per process context		
	// if we have more than slot of a single process than
	// we are smoking something we are not supposed to
	// since tmman32.dll is the only one who calls CreateProcess
	// during ATTACH_PROCESS
	
	Client = TMManGlobal->ClientList[ClientIdx];

	

	// initialize the per device data structures
	// BUGCHECK - we have to go by Client->DeviceCount 
	for ( DeviceIdx = 0 ; DeviceIdx < TMManGlobal->DeviceCount ; DeviceIdx++ )
	{
		TMManDeviceObject* TMManDevice = TMManGlobal->DeviceList[DeviceIdx];

		memoryManagerDestroyMemoryByClient (
			TMManDevice->MemoryManagerHandle, 
			(UInt32)Process );

		messageManagerDestroyMessageByClient (
			TMManDevice->MessageManagerHandle, 
			(UInt32)Process );

		eventManagerDestroyEventByClient (
			TMManDevice->EventManagerHandle, 
			(UInt32)Process );

		sgbufferManagerDestroySGBufferByClient (
			TMManDevice->SGBufferManagerHandle, 
			(UInt32)Process );

	}


	memFree ( TMManGlobal->ClientList[ClientIdx] );

	TMManGlobal->ClientList[ClientIdx] = NULL;
	
	TMManGlobal->ClientCount--;


    return TRUE;

tmmanCloseExit1:
    return FALSE;
}

BOOL
TMM_IOControl(
	DWORD	   dwOpenContext,
	DWORD	   dwIoControlCode,
	LPVOID   lpBufIn,
	DWORD	   dwLenIn,
	LPVOID   lpBufOut,
	DWORD	   dwLenOut,
	PDWORD	pdwActualOut
	)
{

    PEPROCESS			Process;
	PVOID	IOParameters = lpBufIn;
	ULONG	ReturnInformation = 0;

    // if this function is called with an invalid context we just return
    if (!dwOpenContext)
        return TRUE;

    Process = dwOpenContext;

	switch ( dwIoControlCode )
	{

		case constIOCTLtmmanNegotiateVersion : // vxd callable
		{
			tmifNegotiateVersion* TMIF = 	
				(tmifNegotiateVersion*)IOParameters;

			TMIF->Status = tmmanKernelModeNegotiateVersion ( &TMIF->Version );
			ReturnInformation = sizeof ( tmifNegotiateVersion );
		}
		break;

		case constIOCTLtmmanDSPOpen : // vxd callable
		{
			tmifDSPOpen* TMIF = 	
				(tmifDSPOpen*)IOParameters;
			if ( TMIF->DSPNumber < TMManGlobal->DeviceCount )
			{
				TMIF->DSPHandle = (UInt32)TMManGlobal->DeviceList[TMIF->DSPNumber];
				TMIF->Status = statusSuccess;

			}
			else
			{
				TMIF->Status = statusDSPNumberOutofRange;
			}
			ReturnInformation = sizeof ( tmifDSPOpen );
			
		}
		break;

		case constIOCTLtmmanDSPClose : // vxd callable
		{
			tmifGenericFunction* TMIF = 	
				(tmifGenericFunction*)IOParameters;

			TMIF->Status = statusSuccess;
			ReturnInformation = sizeof ( tmifGenericFunction );

		}
		break;

		case constIOCTLtmmanDSPGetNum : // vxd callable
		{
			tmifDSPNum* TMIF = 	
				(tmifDSPNum*)IOParameters;
		
			TMIF->DSPCount = TMManGlobal->DeviceCount;
			TMIF->Status = statusSuccess;
			ReturnInformation = sizeof ( tmifDSPNum );

		}
		break;

		case	constIOCTLtmmanDSPInfo : // vxd callable
		{
			tmifDSPInfo*	TMIF =
				(tmifDSPInfo*)IOParameters;


			TMManDeviceObject* TMManDevice = (TMManDeviceObject*)TMIF->DSPHandle;
			UInt32	ClientIdx, DeviceIdx;
			UInt32	Dummy;
			ClientObject*		Client;

			for ( ClientIdx = 0 ; ClientIdx < TMManGlobal->MaximumClients ; ClientIdx ++ )
			{
				if ( !TMManGlobal->ClientList[ClientIdx] )
					continue;

				if ( ((ClientObject*)TMManGlobal->ClientList[ClientIdx])->Process != Process )
					continue;
				break;
			}

			if ( ClientIdx == TMManGlobal->MaximumClients )
			{
				DPF(0,("tmman:tmmanDeviceControl:PANIC:tmmanDSPInfo:InvalidHandle:Process[%x]\n", 
					Process));
				TMIF->Status = statusInvalidHandle;
				ReturnInformation = sizeof ( tmifDSPInfo );
				break;
			}

			Client = TMManGlobal->ClientList[ClientIdx];
			
			TMIF->Info.MMIO.MappedAddress = 
				(UInt32)Client->Device[TMManDevice->DSPNumber].MMIOAddrUser;

			TMIF->Info.SDRAM.MappedAddress = 
				(UInt32)Client->Device[TMManDevice->DSPNumber].SDRAMAddrUser;

			halGetMMIOInfo (
				TMManDevice->HalHandle,
				(Pointer*)&TMIF->Info.MMIO.PhysicalAddress,
				(Pointer*)&Dummy,
				&TMIF->Info.MMIO.Size );
	

			halGetSDRAMInfo (
				TMManDevice->HalHandle,
				(Pointer*)&TMIF->Info.SDRAM.PhysicalAddress,
				(Pointer*)&Dummy,
				&TMIF->Info.SDRAM.Size );


			halGetTMPCIInfo ( 
				TMManDevice->HalHandle,
				&TMIF->Info.TMDeviceVendorID,
				&TMIF->Info.TMSubSystemID,
				&TMIF->Info.TMClassRevisionID );

			halGetBridgePCIInfo ( 
				TMManDevice->HalHandle,
				&TMIF->Info.BridgeDeviceVendorID,
				&TMIF->Info.BridgeSubsystemID,
				&TMIF->Info.BridgeClassRevisionID );

			TMIF->Info.DSPNumber = TMManDevice->DSPNumber;
			TMIF->Status = statusSuccess;
			ReturnInformation = sizeof ( tmifDSPInfo );

		}
		break;


		case	constIOCTLtmmanDSPLoad :
		{
			tmifDSPLoad*	TMIF =
				(tmifDSPLoad*)IOParameters;
			TMManDeviceObject* TMManDevice = (TMManDeviceObject*)TMIF->DSPHandle;
			// don't do anything in kernel mode for now

			// BUGCHECK : set the hal endiannesss here
			// the endian ness swap has to be done here since it is only 
			// during loading that we will know what endianess the target 
			// is running in.
			halSwapEndianess ( 
				TMManDevice->HalHandle,
				( TMIF->Endianess == constTMManEndianessBig ) );

			halSetPeerVersion ( 
				TMManDevice->HalHandle,
				TMIF->PeerMajorVersion,
				TMIF->PeerMinorVersion );

			TMIF->Status = 	statusSuccess;
			ReturnInformation = sizeof ( tmifDSPLoad );
		}
		break;

		case	constIOCTLtmmanDSPStart :
		{
			tmifGenericFunction*	TMIF =
					(tmifGenericFunction*)IOParameters;
			TMManDeviceObject* TMManDevice = (TMManDeviceObject*)TMIF->Handle;

			UInt32		CPURevision, BoardRevision;

			LARGE_INTEGER	SystemTime;

			UInt32	TargetKernelMajorVersion;
			UInt32	TargetKernelMinorVersion;
			UInt32	DeviceVendorID;
			UInt32	SubsystemID;
			UInt32	ClassRevisionID;


			TMManDevice->Status = constTMManDSPStatusRunning;


			TMManDevice->SharedData->HostKernelMajorVersion = 
				halAccess32( TMManDevice->HalHandle, verGetFileMajorVersion() );
			TMManDevice->SharedData->HostKernelMinorVersion =
				halAccess32( TMManDevice->HalHandle, verGetFileMinorVersion() );

			TMManDevice->SharedData->HalShared = 
				halAccess32( TMManDevice->HalHandle, TMManDevice->HalSharedAddress.LowPart );
			TMManDevice->SharedData->ChannelShared = 
				halAccess32( TMManDevice->HalHandle, TMManDevice->ChannelSharedAddress.LowPart );
			TMManDevice->SharedData->VIntrShared =