/*---------------------------------------------------------------------------- 
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
//	980603	Tilakraj Roy	Ported to Win 95 
//
//////////////////////////////////////////////////////////////////////////////


//////////////////////////////////////////////////////////////////////////////
//				SYSTEM INCLUDE FILES
//////////////////////////////////////////////////////////////////////////////
#ifdef TMMAN_WIN95

#define WANTVXDWRAPS
#include <basedef.h>
#include <vmm.h>
#include <vmmreg.h>
#include <vxdwraps.h>
#include <vpicd.h>
#include <configmg.h>
#include <vwin32.h>

#endif


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

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

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


//////////////////////////////////////////////////////////////////////////////
//				TYPEDEFS
//////////////////////////////////////////////////////////////////////////////


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

TMStatus	tmmanKernelModeNegotiateVersion ( tmmanVersion* Version );

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

BOOL tmmanOpen(
	VOID )
{
	DWORD			NTStatus;
	UInt32			ClientIdx, DeviceIdx;
	ClientObject*	Client;
	PVOID			Process;

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

	// 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];
	Client->Process = Process;
	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	Dummy, Length;
		UInt32	AddrKernel;
		
		Client->Device[DeviceIdx].Device = TMManDevice;

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

		// map mmio so that it can be acessed from user mode
		 if ( ( Client->Device[DeviceIdx].MMIOAddrUser = 
			sectionMapPhysicalAddress ( 
			AddrKernel, 
			Length,
			&Client->Device[DeviceIdx].MMIOHandleUser ) ) == NULL )
		{
			DPF(0,("tmman:tmmanOpen:sectionMapPhysicalAddress:MMIO:FAIL\n" ));
			goto	tmmanOpenExit2;
		}

		if ( TMManGlobal->MapSDRAM )
		{
			halGetSDRAMInfo (
				TMManDevice->HalHandle,
				(Pointer*)&Dummy,
				(Pointer*)&AddrKernel,
				&Length );

			if ( ( Client->Device[DeviceIdx].SDRAMAddrUser = 
				sectionMapPhysicalAddress ( 
				AddrKernel, 
				Length,
				&Client->Device[DeviceIdx].SDRAMHandleUser ) ) == NULL )
			{
				DPF(0,("tmman:tmmanOpen:sectionMapPhysicalAddress:SDRAM:FAIL\n" ));

				sectionUnmapPhysicalAddress ( 
					Client->Device[DeviceIdx].MMIOAddrUser,
					Client->Device[DeviceIdx].MMIOHandleUser );

				goto	tmmanOpenExit2;
			}

		}

		if ( ( Client->Device[DeviceIdx].MemoryAddrUser = 
			sectionMapPhysicalAddress ( 
			(UInt32)TMManDevice->MemoryBlock, 
			TMManDevice->MemoryBlockSize,
			&Client->Device[DeviceIdx].MemoryHandleUser ) ) == NULL )
		{
			DPF(0,("tmman:tmmanOpen:sectionMapPhysicalAddress:MEMORY:FAIL\n" ));
		
			if ( TMManGlobal->MapSDRAM )
			{
				sectionUnmapPhysicalAddress ( 
					Client->Device[DeviceIdx].SDRAMAddrUser,
					Client->Device[DeviceIdx].SDRAMHandleUser );
			}

			sectionUnmapPhysicalAddress ( 
				Client->Device[DeviceIdx].MMIOAddrUser,
				Client->Device[DeviceIdx].MMIOHandleUser );
			goto	tmmanOpenExit2;
		}

	}

	TMManGlobal->ClientCount++;
	
	return 1;

tmmanOpenExit2:

	for ( /* use the current DeviceIdx */ ; DeviceIdx > 0 ; DeviceIdx-- )
	{
		sectionUnmapPhysicalAddress ( 
			Client->Device[DeviceIdx - 1].MemoryAddrUser,
			Client->Device[DeviceIdx - 1].MemoryHandleUser );

		if ( TMManGlobal->MapSDRAM )
		{
			sectionUnmapPhysicalAddress ( 
				Client->Device[DeviceIdx - 1].SDRAMAddrUser,
				Client->Device[DeviceIdx - 1].SDRAMHandleUser );
		}

		sectionUnmapPhysicalAddress ( 
			Client->Device[DeviceIdx - 1].MMIOAddrUser,
			Client->Device[DeviceIdx - 1].MMIOHandleUser );
	}

	memFree ( TMManGlobal->ClientList[ClientIdx] );

tmmanOpenExit1:
#ifdef TMMAN_WIN95
	return 0;
#endif
}

DWORD tmmanClose(
	VOID )
{
	UInt32				ClientIdx, DeviceIdx;
	ClientObject*		Client;
	PVOID				Process;

	Process = PsGetCurrentProcess();
	
	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 );

		sectionUnmapPhysicalAddress ( 
			Client->Device[DeviceIdx].MMIOAddrUser, 
			Client->Device[DeviceIdx].MMIOHandleUser );

		if ( TMManGlobal->MapSDRAM )
		{
			sectionUnmapPhysicalAddress ( 
				Client->Device[DeviceIdx].SDRAMAddrUser,
				Client->Device[DeviceIdx].SDRAMHandleUser );
		}

		sectionUnmapPhysicalAddress ( 
			Client->Device[DeviceIdx].MemoryAddrUser,
			Client->Device[DeviceIdx].MemoryHandleUser );
	}

	memFree ( TMManGlobal->ClientList[ClientIdx] );

	TMManGlobal->ClientList[ClientIdx] = NULL;
	
	TMManGlobal->ClientCount--;
#ifdef TMMAN_WIN95
	return 1;
#endif

tmmanCloseExit1:
#ifdef TMMAN_WIN95
	return 0;
#endif
}

DWORD _stdcall tmmanDeviceControl( 
	DWORD Service, 
	DWORD DDB, 
	DWORD Device, 
	PDIOCPARAMETERS DIOCParam )
{
	PVOID	IOParameters = (PVOID)DIOCParam->lpvInBuffer;
	DWORD	ReturnInformation = 0;
    
    
    // assume that IO Manager will be calling us only with IRP_MJ_DEVICE_CONTROL

	switch ( Service )
	{
		case DIOC_OPEN:
        	// Must return 0 to tell WIN32 that this VxD supports DEVIOCTL
			if  (!tmmanOpen())
				return 1;
			return 0;

		case DIOC_CLOSEHANDLE:
			return tmmanClose();

		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;
			PVOID				Process;
			ClientObject*		Client;

			Process = PsGetCurrentProcess();

			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