tmif.c

wince host 和 target PCI驱动程序

/*---------------------------------------------------------------------------- 
COPYRIGHT (c) 1995 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
	#define	TR	Tilakraj Roy
	960405	TR 	Created
	960710	TR	Started adding code for tmman inteface 
	961008	TR	Added code for shared memory allocaiton interfaces.
	961010	TR	Added code for image loading, running & stopping
	
	Contains the ring 3 16/32 bit dll interfacing routines.
	Contains all the API calls that are made to TMMan from the outside world

	The following is the sequence of object intialization :

	VXMAIN->DeviceInit
		clntmCreate

	DLL_PROCESS_ATTACH->TMIF->RegisterClient
		clntCreate

	DLL_PROCESS_DETACH->TMIF->UnregisterClient
		clntDestroy

	TMPNP->ConfigManager->CONFIG_START 
		boardmCreate
		halCreate ( SDRAM, MMIO )
		ipcCreate ( TM_CONFIG )

	TMIF->LoadExecutable
		ipcExecutableRegister

	TMIF->UnloadExecutable
		ipcExecutableUnregister

	TMIF->LoadRTOS 
		chnlmCreate
			ipcRTOSRegister
		msgmCreate
		strmCreate
		taskmCreate
			msgCreate 
			strCreate 

	TMIF->UnloadRTOS
		taskmDestroy
			msgDestroy
			strDestroy
		strmDestroy
		msgmDestroy
		chnlmDestroy
			ipcRTOSUnregister

	TMPNP->ConfigManager->CONFIG_START 
		boardmDestroy
		halDestroy 
		ipcDestroy

	VXMAIN->DeviceExit
		clntmDestroy

*/

#define WANTVXDWRAPS
#include "basedef.h"
#include "vmm.h"
#include <vxdwraps.h>
#include <vwin32.h>


#include "vxstd.h"
#include "vxwin.h"
#include "vxdbg.h"


#include "tmwincom.h"

#include "tmmmio.h"
#include "tmhd.h"

#include "tmman32.h"
#include "tmif.h"
#include "tmshare.h"

#include "verinfo.h"

#pragma	VxD_LOCKED_CODE_SEG
#pragma VxD_LOCKED_DATA_SEG


STATUS	tmifNegotiateVersion ( PTMSTD_VERSION_INFO Version );


/*
	vxdDeviceIoControlC
	The Win32 DevIoCtl entry point into the VxD. Currently only one
	function is supported but it is extensible and can be used to support
	more functions.

	Every call that is made the this fucniton has to have  at least the
	Client Handle
	DSP Handle 

*/

BOOL	vxdDeviceIoControlC ( DWORD dwService, DWORD dwDDB, DWORD hDevice,
	PDIOCPARAMETERS pDIOCParam )
{

	REFERENCE ( hDevice );
	REFERENCE ( dwDDB );

	switch ( dwService )
	{
		// open the device driver
        case    DIOC_OPEN : // vxd callable
		{
			DWORD dwClientHandle;

			DP(6,"TM:vxdDeviceIoControlC:OPEN\n");

			if ( clntmVMHandleToClnt ( pDriverObject->pClientManager,
				winVWIN32_GetCurrentProcessHandle(), &dwClientHandle ) != TMOK )
			{
			
			}
			else
			{
				clntIncrementReference ( dwClientHandle );
			}

		}
		return 0;
		break;
		
		case	TMIF_DIOC_LIN2PHYS :
		{
			DWORD	dwLinear = ((PDWORD)pDIOCParam->lpvInBuffer)[0];
			PDWORD	pdwPhysical = (PDWORD)pDIOCParam->lpvOutBuffer;
			DP(6,"TM:vxdDeviceIoControlC:LIN2PHYS\n");
			*pdwPhysical = vxdLinearToPhysical ( dwLinear );
		}
		break;

		case	TMIF_DIOC_PHYS2LIN :
		{
			DWORD	dwPhysical = ((PDWORD)pDIOCParam->lpvInBuffer)[0];
			DWORD	dwSize	= ((PDWORD)pDIOCParam->lpvInBuffer)[1];
			PDWORD	pdwLinear = (PDWORD)pDIOCParam->lpvOutBuffer;
			DP(6,"TM:vxdDeviceIoControlC:PHYS2LIN\n");
			*pdwLinear = winMapPhysToLinear ( dwPhysical, dwSize, 0 );
		}
		break;

		case	DIOC_CLOSEHANDLE : // vxd callable
		{
			DWORD	dwClientHandle;
			DWORD	IdxBoard;

			DP(6,"TM:vxdDeviceIoControlC:CLOSEHANDLE\n");

			// if the DOS VM has been killed by the user using the [X]
			// button on the title bar. No use mode code runs, so 
			// UNREGISTER will never be called, however windows will release
			// the VxD via a CLOSEHANDLE call. 
			// We use this opportunity to free up all the resources claimed by
			// this cleint

			if ( clntmVMHandleToClnt ( pDriverObject->pClientManager,
				winVWIN32_GetCurrentProcessHandle(), &dwClientHandle ) != TMOK )
			{
				DP(0,"TM:vxdDeviceIoControlC:CLOSEHANDLE:NO MATCHING CLIENT FOUND\n");
				break;
			}


			// we now have a handle for which we should free all resources
			// on all boards that have been allocated to this client.

			for ( IdxBoard = 0 ; IdxBoard < pDriverObject->wDeviceCount;
				IdxBoard ++ )
			{
				msgmDestroyMsgByClnt ( 
					GetMsgMgrObject ( pDriverObject->pDeviceList[IdxBoard] ),
					dwClientHandle );

				taskmDestroyTaskByClnt ( 
					GetTaskMgrObject ( pDriverObject->pDeviceList[IdxBoard] ), 
					dwClientHandle );
			}

			//clntDecrementReference ( dwClientHandle );

			clntDestroy ( dwClientHandle );
		}
		break;

		case TMIF_DIOC_NEGOTIATEVERSION : // vxd callable
		{
			PTMIF_STRUCT_NEGOTIATEVERSION pTMIFIn = 	
				((PTMIF_STRUCT_NEGOTIATEVERSION)pDIOCParam->lpvInBuffer);
			PTMIF_STRUCT_NEGOTIATEVERSION pTMIFOut = 	
				((PTMIF_STRUCT_NEGOTIATEVERSION)pDIOCParam->lpvOutBuffer);
			pTMIFOut->Version = pTMIFIn->Version;

			pTMIFOut->Status = tmifNegotiateVersion ( &pTMIFOut->Version );
		}
		break;


		//-----------------------------------------------------------
		// All calls below this require the client and the DSP Handle
		//-----------------------------------------------------------
		//---------------------------------------------------------------------
		//	Ring3 32 bit clients
		//---------------------------------------------------------------------

		//---------------------------------------------------------------------
		//	DSP OBJECT FUNCTIONS
		//---------------------------------------------------------------------
		case	TMIF_DIOC_DSPGETNUM : // vxd callable
		{
			PTMIF_STRUCT_DSPGETNUM	pTMIFIn = 
				((PTMIF_STRUCT_DSPGETNUM)pDIOCParam->lpvInBuffer);
			pTMIFIn->DSPCount = pDriverObject->wDeviceCount;
			pTMIFIn->Status = TMOK;
		}
		break;

		case	TMIF_DIOC_DSPGETCAPS : // vxd callable
		{
			PTMIF_STRUCT_DSPGETCAPS	pTMIFIn =
				((PTMIF_STRUCT_DSPGETCAPS)pDIOCParam->lpvInBuffer);
			pTMIFIn->Status = boardGetCaps (
				//pDriverObject->pDeviceList[0],// FIXME: remove HARDCODING
				(PVOID)pTMIFIn->DSPHandle, //FIXME:Validate handle
				&pTMIFIn->DSPCaps );
		}
		break;

		case	TMIF_DIOC_DSPOPEN : // vxd callable
		{
			PTMIF_STRUCT_DSPOPEN pTMIFIn =
				((PTMIF_STRUCT_DSPOPEN)pDIOCParam->lpvInBuffer);
			DWORD	DSPNumber;

			if ( pTMIFIn->DSPNumber == TMMAN_DEFAULT )
				DSPNumber = 0;
			else
				DSPNumber = pTMIFIn->DSPNumber;

			if ( DSPNumber >= pDriverObject->wDeviceCount )
			{
				return TM_STATUS ( 	TMIF_ERR_DSPNUMOUTOFRANGE );	
			}

			pTMIFIn->Status = boardOpen (
				pDriverObject->pDeviceList[DSPNumber] );

			pTMIFIn->DSPHandle = (DWORD)pDriverObject->pDeviceList[DSPNumber];
		}
		break;

		case	TMIF_DIOC_DSPCLOSE : // vxd callable
		{
			PTMIF_STRUCT_DSPCLOSE pTMIFIn =
				((PTMIF_STRUCT_DSPCLOSE)pDIOCParam->lpvInBuffer);

			pTMIFIn->Status = boardClose ( (PVOID) pTMIFIn->DSPHandle );
		}
		break;

		case	TMIF_DIOC_DSPEXECUTABLELOAD :
		{
			PTMIF_STRUCT_DSPEXECUTABLELOAD	pTMIFIn =
				(PTMIF_STRUCT_DSPEXECUTABLELOAD)pDIOCParam->lpvInBuffer;
			PTMIF_STRUCT_DSPEXECUTABLELOAD	pTMIFOut =
				(PTMIF_STRUCT_DSPEXECUTABLELOAD)pDIOCParam->lpvOutBuffer;

			pTMIFOut->Status = boardImageLoad ( (PVOID)pTMIFIn->DSPHandle, 
				pTMIFIn->PhysLoadAddr, pTMIFIn->ImageSize,
				(PVOID)pTMIFIn->ImageAddr, pTMIFIn->ArgC, (PCHAR *)pTMIFIn->ArgV );

			halSetTargetVersion ( 
				GetHALObject ( (PVOID)pTMIFIn->DSPHandle ) ,
				pTMIFIn->TargetMajorVersion,
				pTMIFIn->TargetMinorVersion ); 
		}
		break;

		case	TMIF_DIOC_DSPEXECUTABLERUN :
		{
			PTMIF_STRUCT_DSPEXECUTABLERUN	pTMIFIn =
				(PTMIF_STRUCT_DSPEXECUTABLERUN)pDIOCParam->lpvInBuffer;
			PTMIF_STRUCT_DSPEXECUTABLERUN	pTMIFOut =
				(PTMIF_STRUCT_DSPEXECUTABLERUN)pDIOCParam->lpvOutBuffer;

			pTMIFOut->Status = boardImageRun ( (PVOID)pTMIFIn->DSPHandle, 
				pTMIFIn->PhysStartAddr );
		}
		break;

		case	TMIF_DIOC_DSPEXECUTABLESTOP :
		{
			PTMIF_STRUCT_DSPEXECUTABLESTOP	pTMIFIn =
				(PTMIF_STRUCT_DSPEXECUTABLESTOP)pDIOCParam->lpvInBuffer;
			PTMIF_STRUCT_DSPEXECUTABLESTOP	pTMIFOut =
				(PTMIF_STRUCT_DSPEXECUTABLESTOP)pDIOCParam->lpvOutBuffer;

			pTMIFOut->Status = boardImageStop ( (PVOID)pTMIFIn->DSPHandle );
		}
		break;

		case	TMIF_DIOC_DSPRESET :
		{
			PTMIF_STRUCT_DSPRESET	pTMIFIn =
				(PTMIF_STRUCT_DSPRESET)pDIOCParam->lpvInBuffer;
			PTMIF_STRUCT_DSPRESET	pTMIFOut =
				(PTMIF_STRUCT_DSPRESET)pDIOCParam->lpvOutBuffer;

			pTMIFOut->Status = boardReset ( (PVOID)pTMIFIn->DSPHandle );
		}
		break;

		case TMIF_DIOC_DSPGETMISCINFO : // vxd callable
		{
			PTMIF_STRUCT_DSPMISCINFO pTMIFIn =
				((PTMIF_STRUCT_DSPMISCINFO)pDIOCParam->lpvInBuffer);
			PTMIF_STRUCT_DSPMISCINFO pTMIFOut =
				((PTMIF_STRUCT_DSPMISCINFO)pDIOCParam->lpvOutBuffer);

			pTMIFOut->Status = boardGetMiscInfo ( (PVOID)pTMIFIn->DSPHandle,
				&pTMIFOut->Info );
		}
		break;

		case TMIF_DIOC_DSPSETMISCINFO : // vxd callable
		{
			PTMIF_STRUCT_DSPMISCINFO pTMIFIn =
				((PTMIF_STRUCT_DSPMISCINFO)pDIOCParam->lpvInBuffer);
			PTMIF_STRUCT_DSPMISCINFO pTMIFOut =
				((PTMIF_STRUCT_DSPMISCINFO)pDIOCParam->lpvOutBuffer);

			pTMIFOut->Status = boardSetMiscInfo ( (PVOID)pTMIFIn->DSPHandle,
				&pTMIFOut->Info );
		}
		break;

		case TMIF_DIOC_DSPGETSTATUS : // vxd callable
		{
			PTMIF_STRUCT_DSPGETSTATUS pTMIFIn =
				((PTMIF_STRUCT_DSPGETSTATUS)pDIOCParam->lpvInBuffer);
			PTMIF_STRUCT_DSPGETSTATUS pTMIFOut =
				((PTMIF_STRUCT_DSPGETSTATUS)pDIOCParam->lpvOutBuffer);

			pTMIFOut->Status = boardGetStatus ( (PVOID)pTMIFIn->DSPHandle,
				&pTMIFOut->DSPStatus );
		}
        break;


		//---------------------------------------------------------------------
		//	Ring3 32 bit clients
		//---------------------------------------------------------------------

		case	TMIF_DIOC_REGISTERCLIENT :
		{
			PTMIF_REGISTERCLIENT	pTMIFIn =
				(PTMIF_REGISTERCLIENT)pDIOCParam->lpvInBuffer;
			PTMIF_REGISTERCLIENT	pTMIFOut =
				(PTMIF_REGISTERCLIENT)pDIOCParam->lpvOutBuffer;
			TMCLNT_CLIENT	Client;

			DP(6,"TM:vxdDeviceIoControlC:REGISTERCLIENT\n");

			Client.dwType = TMCLNT_CLIENT_TYPEDLL32;
			Client.dwContext = pTMIFIn->dwContext;
			Client.Client.DLL32.dwModuleHandle = 
				pTMIFIn->dwModuleHandle;
			Client.Client.DLL32.dwVMHandle = 
				winVWIN32_GetCurrentProcessHandle();

			pTMIFOut->dwClientHandle = NULL;

			if ( ( pTMIFOut->Status =
				clntmCreateClnt ( pDriverObject->pClientManager,
				&Client, &pTMIFOut->dwClientHandle ) )!= TMOK )
			{
				DP(6, "TM:vxdDeviceIOControlC:REGISTERCLIENT:clntmOpen:FAIL\n");
				break;
			}
			// check here if tmldr has been started - in DriverObject
			if ( 1 )
				pTMIFOut->FlagTMLDRStarted = FALSE;
			else
				pTMIFOut->FlagTMLDRStarted = TRUE;

			// copy the returned parameters in the Clients address space
			pTMIFOut->pvAdvisoryQueue = 
				Client.Client.DLL32.pvAdvisoryQueue;
			pTMIFOut->pvOverlapped = 
				Client.Client.DLL32.pvOverlappedObject;
		}
		break;

		case	TMIF_DIOC_UNREGISTERCLIENT :
		{
			DWORD	dwRing3ClientHandle  = *((PDWORD)pDIOCParam->lpvInBuffer);
			DWORD	dwClientHandle;
			DWORD	IdxBoard;
			DP(6,"TM:vxdDeviceIoControlC:UNREGISTERCLIENT\n");

			if ( clntmVMHandleToClnt ( pDriverObject->pClientManager,