tmif.c

wince host 和 target PCI驱动程序

				winVWIN32_GetCurrentProcessHandle(), &dwClientHandle ) != TMOK )
			{
				DP(0,"TM:vxdDeviceIoControlC:TMIF_DIOC_UNREGISTERCLIENT:NO MATCHING CLIENT FOUND\n");
				break;
			}
			

			if ( dwRing3ClientHandle != dwClientHandle )
			{
				DP(0,"TM:vxdDeviceIoControlC:TMIF_DIOC_UNREGISTERCLIENT:NO MATCHING CLIENT FOUND\n");
				break;
			}

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

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

		}
		break;

		case	TMIF_DIOC_BLOCKONADVISE :
		{
			DWORD	dwClientHandle  = *((PDWORD)pDIOCParam->lpvInBuffer);
			DP(6,"TM:vxdDeviceIoControlC:BLOCKONADVISE\n");
			clntWaitForAdvise ( dwClientHandle );
		}
		break;



		//---------------------------------------------------------------------
		//	Tasks or Modules
		//---------------------------------------------------------------------
		case	TMIF_DIOC_TASKCREATE :
		{
			PTMIF_STRUCT_TASKCREATE pTMIFIn =
				((PTMIF_STRUCT_TASKCREATE)pDIOCParam->lpvInBuffer);
			PTMIF_STRUCT_TASKCREATE pTMIFOut =
				((PTMIF_STRUCT_TASKCREATE)pDIOCParam->lpvOutBuffer);
			DP(6,"TM:vxdDeviceIoControlC:TASKCREATE\n");
			pTMIFOut->Status = taskmCreateTask ( 
				GetTaskMgrObject ( (PVOID)pTMIFIn->DSPHandle ),
				pTMIFIn, &pTMIFOut->TaskHandle );

		}
		break;

		case	TMIF_DIOC_TASKSTART :
		{
			PTMIF_STRUCT_TASKSTART pTMIFIn =
				((PTMIF_STRUCT_TASKSTART)pDIOCParam->lpvInBuffer);
			PTMIF_STRUCT_TASKSTART pTMIFOut =
				((PTMIF_STRUCT_TASKSTART)pDIOCParam->lpvOutBuffer);
			DP(6,"TM:vxdDeviceIoControlC:TASKSTART\n");
			pTMIFOut->Status = taskStart ( pTMIFIn->TaskHandle );
		}
		break;

		case	TMIF_DIOC_TASKSTOP :
		{
			PTMIF_STRUCT_TASKSTOP pTMIFIn =
				((PTMIF_STRUCT_TASKSTOP)pDIOCParam->lpvInBuffer);
			PTMIF_STRUCT_TASKSTOP pTMIFOut =
				((PTMIF_STRUCT_TASKSTOP)pDIOCParam->lpvOutBuffer);
			DP(6,"TM:vxdDeviceIoControlC:TASKSTOP\n");
			pTMIFOut->Status = taskStop ( pTMIFIn->TaskHandle );
		}
		break;

		case	TMIF_DIOC_TASKDESTROY :
		{
			PTMIF_STRUCT_TASKDESTROY pTMIFIn =
				((PTMIF_STRUCT_TASKDESTROY)pDIOCParam->lpvInBuffer);
			PTMIF_STRUCT_TASKDESTROY pTMIFOut =
				((PTMIF_STRUCT_TASKDESTROY)pDIOCParam->lpvOutBuffer);
			DP(6,"TM:vxdDeviceIoControlC:TASKDESTROY\n");
			pTMIFOut->Status = taskDestroy ( pTMIFIn->TaskHandle );
		}
		break;

		case	TMIF_DIOC_TASKSIGNAL :
		{
			PTMIF_STRUCT_TASKSIGNAL pTMIFIn =
				((PTMIF_STRUCT_TASKSIGNAL)pDIOCParam->lpvInBuffer);
			PTMIF_STRUCT_TASKSIGNAL pTMIFOut =
				((PTMIF_STRUCT_TASKSIGNAL)pDIOCParam->lpvOutBuffer);
			DP(6,"TM:vxdDeviceIoControlC:TASKSIGNAL\n");
			pTMIFOut->Status = taskSignal ( 
				pTMIFIn->TaskHandle, pTMIFOut->State );
		}
		break;

		//---------------------------------------------------------------------
		//	Message
		//---------------------------------------------------------------------
		case TMIF_DIOC_MSGCREATE : // vxd callable
		{
			PTMIF_STRUCT_MSGCREATE pTMIFIn =
				((PTMIF_STRUCT_MSGCREATE)pDIOCParam->lpvInBuffer);
			PTMIF_STRUCT_MSGCREATE pTMIFOut =
				((PTMIF_STRUCT_MSGCREATE)pDIOCParam->lpvOutBuffer);
			DP(6,"TM:vxdDeviceIoControlC:MSGCREATE\n");
			pTMIFOut->Status = msgmCreateMsg ( 
				GetMsgMgrObject ( (PVOID)pTMIFIn->DSPHandle ),
				pTMIFIn, (PVOID *)&pTMIFOut->MsgHandle );

		}
		break;


		case TMIF_DIOC_MSGDESTROY : // vxd callable
		{
			PTMIF_STRUCT_MSGDESTROY pTMIFIn =
				((PTMIF_STRUCT_MSGDESTROY)pDIOCParam->lpvInBuffer);
			PTMIF_STRUCT_MSGDESTROY pTMIFOut =
				((PTMIF_STRUCT_MSGDESTROY)pDIOCParam->lpvOutBuffer);
			DP(6,"TM:vxdDeviceIoControlC:MSGDESTROY\n");
			pTMIFOut->Status = msgDestroy ( (PVOID) pTMIFIn->MsgHandle);
		}
		break;

		case TMIF_DIOC_MSGSEND : // vxd callable
		{
			PTMIF_STRUCT_MSGSEND pTMIFIn =
				((PTMIF_STRUCT_MSGSEND)pDIOCParam->lpvInBuffer);
			PTMIF_STRUCT_MSGSEND pTMIFOut =
				((PTMIF_STRUCT_MSGSEND)pDIOCParam->lpvOutBuffer);
			DP(6,"TM:vxdDeviceIoControlC:MSGSEND\n");
			pTMIFOut->Status = msgSend ( (PVOID) pTMIFIn->MsgHandle,
				&pTMIFIn->Packet );
		}
		break;

		//---------------------------------------------------------------------
		//	Shared Memory
		//---------------------------------------------------------------------
		case TMIF_DIOC_SHMEMALLOCATE : //vxd callable
		{
			PTMIF_STRUCT_SHMEMALLOCATE pTMIFIn =
				((PTMIF_STRUCT_SHMEMALLOCATE)pDIOCParam->lpvInBuffer);
			PTMIF_STRUCT_SHMEMALLOCATE pTMIFOut =
				((PTMIF_STRUCT_SHMEMALLOCATE)pDIOCParam->lpvOutBuffer);
			DP(6,"TM:vxdDeviceIoControlC:SHMEMALLOCATE\n");
			pTMIFOut->Status = shmemAllocate ( 
				GetShMemObject( (PVOID)pTMIFIn->DSPHandle), pTMIFIn->Flags,
				pTMIFIn->Size,  &pTMIFOut->Linear, &pTMIFOut->Physical );
		}
		break;

		case TMIF_DIOC_SHMEMFREE : // vxd callable
		{
			PTMIF_STRUCT_SHMEMFREE pTMIFIn =
				((PTMIF_STRUCT_SHMEMFREE)pDIOCParam->lpvInBuffer);
			PTMIF_STRUCT_SHMEMFREE pTMIFOut =
				((PTMIF_STRUCT_SHMEMFREE)pDIOCParam->lpvOutBuffer);
			DP(6,"TM:vxdDeviceIoControlC:SHMEMFREE\n");
			pTMIFOut->Status = shmemFree ( 
				GetShMemObject( (PVOID)pTMIFIn->DSPHandle), pTMIFIn->Linear );
		}
		break;

		//---------------------------------------------------------------------
		//	Parameter DWORD
		//---------------------------------------------------------------------
		case TMIF_DIOC_DWORDPARAMSET : // vxd callable
		{
			PTMIF_STRUCT_DWORDPARAMGETSET pTMIFIn =
				((PTMIF_STRUCT_DWORDPARAMGETSET)pDIOCParam->lpvInBuffer);
			PTMIF_STRUCT_DWORDPARAMGETSET pTMIFOut =
				((PTMIF_STRUCT_DWORDPARAMGETSET)pDIOCParam->lpvOutBuffer);
			DP(6,"TM:vxdDeviceIoControlC:DWORDPARAMSET\n");

			pTMIFOut->Status = boardParameterDWORDSet (
				(PVOID)pTMIFIn->DSPHandle, pTMIFIn->ParamID, pTMIFIn->Value );
		}
		break;

		case TMIF_DIOC_DWORDPARAMGET : // vxd callable
		{
			PTMIF_STRUCT_DWORDPARAMGETSET pTMIFIn =
				((PTMIF_STRUCT_DWORDPARAMGETSET)pDIOCParam->lpvInBuffer);
			PTMIF_STRUCT_DWORDPARAMGETSET pTMIFOut =
				((PTMIF_STRUCT_DWORDPARAMGETSET)pDIOCParam->lpvOutBuffer);
			DP(6,"TM:vxdDeviceIoControlC:DWORDPARAMGET\n");

			pTMIFOut->Status = boardParameterDWORDGet (
				(PVOID)pTMIFIn->DSPHandle, pTMIFIn->ParamID, &pTMIFOut->Value );
		}
		break;

		//---------------------------------------------------------------------
		//	DMA Buffer Locking
		//---------------------------------------------------------------------
		case TMIF_DIOC_BUFFERPREPARE : // vxd callable
		{
			PTMIF_STRUCT_BUFFERPREPARE pTMIFIn =
				((PTMIF_STRUCT_BUFFERPREPARE)pDIOCParam->lpvInBuffer);
			PTMIF_STRUCT_BUFFERPREPARE pTMIFOut =
				((PTMIF_STRUCT_BUFFERPREPARE)pDIOCParam->lpvOutBuffer);
			DP(6,"TM:vxdDeviceIoControlC:BUFFERPREPARE\n");

			pTMIFOut->Status = buffermPrepare  ( 
				GetBufferMgrObject( (PVOID)pTMIFIn->DSPHandle), pTMIFIn,
				&((PVOID)pTMIFOut->dwBufferHandle) );
		}
		break;

		case TMIF_DIOC_BUFFERUNPREPARE : // vxd callable
		{
			PTMIF_STRUCT_BUFFERUNPREPARE pTMIFIn =
				((PTMIF_STRUCT_BUFFERUNPREPARE)pDIOCParam->lpvInBuffer);
			PTMIF_STRUCT_BUFFERUNPREPARE pTMIFOut =
				((PTMIF_STRUCT_BUFFERUNPREPARE)pDIOCParam->lpvOutBuffer);
			DP(6,"TM:vxdDeviceIoControlC:BUFFERUNPREPARE\n");

			pTMIFOut->Status = bufferUnprepare ( (PVOID)pTMIFIn->dwBufferHandle );
		}
		break;

		default :
		return 1;
	}
	return 0;

}


//
//		Interface implementations
//
STATUS	tmifNegotiateVersion ( PTMSTD_VERSION_INFO Version )
{
	STATUS	Status = TMOK;

	if ( Version->dwMajor < verGetFileMajorVersion() )
	{
		Status = TM_STATUS ( TMIF_ERR_MAJVERSIONERR );
		goto tmifNegotiateVersionExit1;
	}

	if ( Version->dwMinor < verGetFileMinorVersion()  )
	{
		Status = TM_STATUS ( TMIF_ERR_MINVERSIONERR );
		goto tmifNegotiateVersionExit1;
	}

tmifNegotiateVersionExit1 :
	Version->dwMajor = verGetFileMajorVersion();
	Version->dwMinor = verGetFileMinorVersion();
	Version->dwBuild = verGetFileBuildVersion();
	return Status;
}


//----------------------------------------------------------------------------
// tmman16 interface functions - TBD TR960829
//----------------------------------------------------------------------------

typedef	DWORD ( *PDLL16FUNC ) ( DWORD dwVMM, PVOID pInputBuf,
	DWORD 	dwInputBufSize, PVOID pOutputBuf, DWORD dwOutputBufSize );

/*
	dll16DispatcherC

 	dll16 Stack state :-
		[5]dwOutputBufferSize		ss:sp + 20
		[4]pOutputBuffer			ss:sp + 16
		[3]dwInputBufferSize		ss:sp + 12
		[2]pInputBuffer				ss:sp + 8
		[1]dwFunctionCode			ss:sp + 4	
		[0]dwReturnAddress			ss:sp + 0	
*/

DWORD dll16DispatcherC ( DWORD dwVM,  PDWORD pdwRing3Stack )
{
	PVOID	pInputBuffer;
	DWORD	dwInputBufferSize;
	PVOID	pOutputBuffer;
	DWORD	dwOutputBufferSize;
	DWORD	dwService;


	if ( ( pdwRing3Stack[2] ) ||
		( ( pInputBuffer =
		(PVOID)winSelectorMapFlat ( dwVM , pdwRing3Stack[2] , 0 ) ) == ~0 ) )
	{
		pInputBuffer = NULL;
	}

	if ( ( pdwRing3Stack[4] ) ||
		( ( pOutputBuffer =
		(PVOID)winSelectorMapFlat ( dwVM , pdwRing3Stack[4] , 0 ) ) == ~0 ) )
	{
		pInputBuffer = NULL;
	}

	dwInputBufferSize = pdwRing3Stack[3];
	dwOutputBufferSize = pdwRing3Stack[5];
	dwService = pdwRing3Stack[1];

	switch ( dwService - RING3_FUNC_BASE )
	{
		case	DIOC_OPEN :
		return 0;

		case	DIOC_CLOSEHANDLE :
		return 0;


		case 	DIOC_READMEM :
		/*
		halReadMem( pOutputBuffer, *((PDWORD)pInputBuffer) ,
			dwOutputBufferSize );
		*/
		break;

		case	DIOC_WRITEMEM :
		/*
		halWriteMem( pOutputBuffer, *((PDWORD)pInputBuffer) ,
			dwOutputBufferSize );
		*/
		break;

		default :
		return 1;

		/*
		if ( pdwRing3Stack[1] > SIZE_RING3_FUNC_TABLE + )
			return 1;
		if ( Ring3Service[pdwRing3Stack[1]] )
		{
			return ( *Ring3Service[ pdwRing3Stack[1]]  ) ( dwVM, pInputBuffer,
				pdwRing3Stack[3], pOutputBuffer, pdwRing3Stack[4] );
		}
		else
		{
			return 1;
		}
		*/
	}
	return 0;
}

// RING 0 entry point
BOOL tmifRing0Service(DWORD dwService,PVOID lpvBuffer)
{
	switch ( dwService )
	{
		//---------------------------------------------------------------------
		//	Sub class the Ring 0 client functionality
		//---------------------------------------------------------------------
		case	TMIF_DIOC_REGISTERCLIENT :
		{
			PTMIF_REGISTERCLIENT	pTMIFIn =
				(PTMIF_REGISTERCLIENT)lpvBuffer;
			PTMIF_REGISTERCLIENT	pTMIFOut =
				(PTMIF_REGISTERCLIENT)lpvBuffer;
			TMCLNT_CLIENT	Client;
			//STATUS	Status;
			DP(6,"TM:VTMMAN_Ring0Service:REGISTERCLIENT\n");

			Client.dwType = TMCLNT_CLIENT_TYPEVXD;
			Client.dwContext = pTMIFIn->dwContext;

			pTMIFOut->dwClientHandle = NULL;

			if ( ( pTMIFOut->Status =
				clntmCreateClnt ( pDriverObject->pClientManager,
				&Client, &pTMIFOut->dwClientHandle ) )!= TMOK )
			{
				DP(0, "TM:VTMMAN_Ring0Service:REGISTERCLIENT:clntmOpen:FAIL\n");
				break;
			}
			return TRUE;

		}
		break;

		case	TMIF_DIOC_UNREGISTERCLIENT :
		{
			DWORD	dwClientHandle  = *((PDWORD)lpvBuffer);
			DWORD	IdxBoard;
			DP(6,"TM:VTMMAN_Ring0Service:UNREGISTERCLIENT\n");

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

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

			clntDestroy ( dwClientHandle );

		}
		break;

		default :
		{
			DIOCPARAMETERS DIOCParam;
			DP(6,"TM:VTMMAN_Ring0Service:DEFAULT[%x]\n", dwService);
			DIOCParam.lpvInBuffer = (DWORD)lpvBuffer;
			DIOCParam.lpvOutBuffer = (DWORD)lpvBuffer;
			return vxdDeviceIoControlC(dwService,0,0,&DIOCParam);
		}
	}
	return FALSE;
}