tmmanr0.c

wince host 和 target PCI驱动程序

/*
	tmmanr0.c
		
	provides services to Win32 vxd clients for communicating with the DSP.

	HISTORY
	961218	NM	Created
	
*/

/*----------------------------------------------------------------------------
          SYSTEM INCLUDE FILES
----------------------------------------------------------------------------*/
#define WANTVXDWRAPS
#include <basedef.h>
#include <vmm.h>
#include <vwin32.h>
#include <vxdwraps.h>

/*----------------------------------------------------------------------------
          DRIVER SPECIFIC INCLUDE FILES
----------------------------------------------------------------------------*/
#include "tmman32.h"
#include "verinfo.h"
#include "tmwincom.h"
#include "tmif.h"

DWORD ring0Call(DWORD,PVOID);

typedef struct  _TMMAN_GLOBAL
{
    DWORD	dwClientHandle;
}   TMMAN_GLOBAL, *PTMMAN_GLOBAL;

TMMAN_GLOBAL  Global;

//-----------------------------------------------------------------------------
//	LEGACY SUPPORT 
//-----------------------------------------------------------------------------

// DSP related API.

// TBD : add the tmOpenVxD and tmCloseVxD functions.
STATUS	tmVxDOpen ( VOID )
{
	TMIF_REGISTERCLIENT	TMIF;
    if(ring0Call((DWORD)(TMIF_DIOC_REGISTERCLIENT),&TMIF) != TRUE)
	{
		return TM_STATUS ( TMMAN32_ERR_DEVIOCTLFAIL );
	}

    Global.dwClientHandle = TMIF.dwClientHandle;
	return TMIF.Status;
}

STATUS	tmVxDClose ( VOID )
{
    if(ring0Call((DWORD)(TMIF_DIOC_UNREGISTERCLIENT),&Global.dwClientHandle) != TRUE)
	{
		return TM_STATUS ( TMMAN32_ERR_DEVIOCTLFAIL );
	}
	return TMOK;
}

STATUS	tmNegotiateVersion ( DWORD dwModuleID, PTMSTD_VERSION_INFO pVersion )
{

	TMIF_STRUCT_NEGOTIATEVERSION	TMIF;
	STATUS	Status  = TMOK;

	return TMIF.Status;

	switch ( dwModuleID )
	{
		case TMMAN_MODULE_HOST_VTMMAN :
		case	TMMAN_DEFAULT :
		
		TMIF.Version = *pVersion;

		if(ring0Call((DWORD)(TMIF_DIOC_NEGOTIATEVERSION),&TMIF) != TRUE)
		{
			/* don't clobber the version the caller has passed */
			return TM_STATUS ( TMMAN32_ERR_DEVIOCTLFAIL );
		}

		if ( pVersion->dwMajor >= TMIF.Version.dwMajor )
		{
			Status = TM_STATUS ( TMMAN32_ERR_MAJVERSIONERROR );
			break;
		}

		if ( pVersion->dwMinor >= TMIF.Version.dwMinor )
		{
			Status = TM_STATUS ( TMMAN32_ERR_MINVERSIONERROR );
			break;
		}
		break;


		case TMMAN_MODULE_HOST_TMMAN32 :
		case TMMAN_MODULE_DSP_TMMAN :
		default :
		Status  = TM_STATUS ( TMMAN32_ERR_UNKNOWNCOMPONENT );
		break;
	}

//tmNegotiateVersionExit1:
	pVersion->dwMajor = TMIF.Version.dwMajor;
	pVersion->dwMinor = TMIF.Version.dwMinor;
	pVersion->dwBuild = TMIF.Version.dwBuild;
	return Status;
}


STATUS	tmDSPGetNum ( PDWORD DSPCount )
{
	TMIF_STRUCT_DSPGETNUM	TMIF;

    TMIF.ClientHandle = Global.dwClientHandle;

    if(ring0Call((DWORD)(TMIF_DIOC_DSPGETNUM),&TMIF) != TRUE)
	{
		return TM_STATUS ( TMMAN32_ERR_DEVIOCTLFAIL );
	}

	*DSPCount = TMIF.DSPCount;
	return TMIF.Status;
}


STATUS	tmDSPGetCaps ( DWORD dwHandle, PTMMAN_DSP_CAPS DSPCaps )
{
	TMIF_STRUCT_DSPGETCAPS	TMIF;

	TMIF.ClientHandle = Global.dwClientHandle;
	TMIF.DSPHandle = dwHandle;

    if(ring0Call((DWORD)(TMIF_DIOC_DSPGETCAPS),&TMIF) != TRUE)
	{
		return TM_STATUS ( TMMAN32_ERR_DEVIOCTLFAIL );
	}

	*DSPCaps = TMIF.DSPCaps;
	return TMIF.Status;
}
	
STATUS	tmDSPOpen ( DWORD dwDSPNumber, PDWORD DSPHandle )
{
	TMIF_STRUCT_DSPOPEN	TMIF;

    TMIF.ClientHandle     = Global.dwClientHandle;
	TMIF.DSPNumber		= dwDSPNumber;

    if(ring0Call((DWORD)(TMIF_DIOC_DSPOPEN),&TMIF) != TRUE)
	{
		return TM_STATUS ( TMMAN32_ERR_DEVIOCTLFAIL );
	}

	*DSPHandle = TMIF.DSPHandle;
	return TMIF.Status;
}

STATUS	tmDSPClose ( DWORD dwHandle )
{
	TMIF_STRUCT_DSPCLOSE	TMIF;

	TMIF.ClientHandle	= Global.dwClientHandle;
	TMIF.DSPHandle		= dwHandle;
	if(ring0Call((DWORD)(TMIF_DIOC_DSPCLOSE),&TMIF) != TRUE)
	{
		return TM_STATUS ( TMMAN32_ERR_DEVIOCTLFAIL );
	}

	return TMIF.Status;
}
// Task Related API

STATUS	tmTaskCreate ( DWORD dwDSPHandle, PTMMAN_TASK_CREATE pTaskAttrib, 
	PDWORD pdwHandle )
{
	DWORD	Idx;
	TMIF_STRUCT_TASKCREATE	TMIF;

	TMIF.ClientHandle	= Global.dwClientHandle;
	TMIF.DSPHandle 		= dwDSPHandle;
	TMIF.dwFlags		= pTaskAttrib->dwFlags;
	TMIF.dwCallback		= pTaskAttrib->dwCallback;
	TMIF.pvContext		= pTaskAttrib->pvContext;
	TMIF.dwPriority		= pTaskAttrib->dwPriority;
	TMIF.dwStackSize	= pTaskAttrib->dwStackSize;
	TMIF.dwArgumentCount	= pTaskAttrib->dwArgumentCount;
	TMIF.ppbArgumentVector	= pTaskAttrib->ppbArgumentVector;
	for ( Idx = 0; 
		(pTaskAttrib->szTaskFile[Idx]) && (Idx < (TMSTD_PATH_LENGTH - 1 ) ) ; 
		Idx ++ )
	{
		TMIF.szTaskFile[Idx] = pTaskAttrib->szTaskFile[Idx];
	}
	TMIF.szTaskFile[Idx] = 0;

	if(ring0Call((DWORD)(TMIF_DIOC_TASKCREATE),&TMIF) != TRUE)
	{
		return TM_STATUS ( TMMAN32_ERR_DEVIOCTLFAIL );
	}

	*pdwHandle = TMIF.TaskHandle;
	return TMIF.Status;
}


STATUS	tmTaskStart ( DWORD dwHandle )
{
	TMIF_STRUCT_TASKSTART	TMIF;

	TMIF.TaskHandle = dwHandle;
	TMIF.ClientHandle = Global.dwClientHandle;

	if(ring0Call((DWORD)(TMIF_DIOC_TASKSTART),&TMIF) != TRUE)
	{
		return TM_STATUS ( TMMAN32_ERR_DEVIOCTLFAIL );
	}
	return TMIF.Status;
	
}

STATUS	tmTaskDestroy ( DWORD dwHandle )
{
	TMIF_STRUCT_TASKDESTROY	TMIF;

	TMIF.TaskHandle = dwHandle;
	TMIF.ClientHandle = Global.dwClientHandle;

	if(ring0Call((DWORD)(TMIF_DIOC_TASKDESTROY),&TMIF) != TRUE)
	{
		return TM_STATUS ( TMMAN32_ERR_DEVIOCTLFAIL );
	}
	return TMIF.Status;
}


// Message Interface
STATUS	tmMsgCreate ( DWORD dwHandle, PTMMAN_MESSAGE_DESC pMessageAttrib, 
	PDWORD pdwMessageHandle  )
{
	TMIF_STRUCT_MSGCREATE	TMIF;

	TMIF.DSPHandle = dwHandle;
	TMIF.ClientHandle = Global.dwClientHandle;
	TMIF.CallbackFunction = pMessageAttrib->dwCallback;
	TMIF.CallbackContext = (DWORD)pMessageAttrib->pvContext;
	TMIF.Slots = pMessageAttrib->dwMessageSlots;
	TMIF.ChannelID = pMessageAttrib->dwID;

	if(ring0Call((DWORD)(TMIF_DIOC_MSGCREATE),&TMIF) != TRUE)
	{
		return TM_STATUS ( TMMAN32_ERR_DEVIOCTLFAIL );
	}
	*pdwMessageHandle = TMIF.MsgHandle;
	return TMIF.Status;
}

STATUS	tmMsgDestroy ( DWORD dwHandle )
{
	TMIF_STRUCT_MSGDESTROY	TMIF;

	TMIF.MsgHandle = dwHandle;
	TMIF.ClientHandle = Global.dwClientHandle;

	if(ring0Call((DWORD)(TMIF_DIOC_MSGDESTROY),&TMIF) != TRUE)
	{
		return TM_STATUS ( TMMAN32_ERR_DEVIOCTLFAIL );
	}
	return TMIF.Status;
}


STATUS	tmMsgSend ( DWORD dwHandle, PTMSTD_PACKET pPacket )
{
	TMIF_STRUCT_MSGSEND	TMIF;

	TMIF.MsgHandle = dwHandle;
	TMIF.Packet = *pPacket;
	TMIF.ClientHandle = Global.dwClientHandle;

	if(ring0Call((DWORD)(TMIF_DIOC_MSGSEND),&TMIF) != TRUE)
	{
		return TM_STATUS ( TMMAN32_ERR_DEVIOCTLFAIL );
	}

	return TMIF.Status;
}

// SHARED MEMORY ALLOCAITON AND FREE FUNCTIONS
STATUS	tmShmemAllocate ( DWORD DSPHandle, DWORD Flags, DWORD Length,
	PVOID *ppLinear, PDWORD pPhysical )
{
	TMIF_STRUCT_SHMEMALLOCATE	TMIF;

	TMIF.DSPHandle = DSPHandle;
	TMIF.ClientHandle = Global.dwClientHandle;
	TMIF.Flags = Flags;
	TMIF.Size = Length;

	if(ring0Call((DWORD)(TMIF_DIOC_SHMEMALLOCATE),&TMIF) != TRUE)
	{
		return TM_STATUS ( TMMAN32_ERR_DEVIOCTLFAIL );
	}
	*ppLinear = TMIF.Linear;
	*pPhysical = TMIF.Physical;
	return TMIF.Status;
}

STATUS	tmShmemFree ( DWORD DSPHandle, PVOID pLinear )
{
	TMIF_STRUCT_SHMEMFREE	TMIF;

	TMIF.DSPHandle = DSPHandle;
	TMIF.ClientHandle = Global.dwClientHandle;
	TMIF.Linear = pLinear;
	
	if(ring0Call((DWORD)(TMIF_DIOC_SHMEMFREE),&TMIF) != TRUE)
	{
		return TM_STATUS ( TMMAN32_ERR_DEVIOCTLFAIL );
	}
	return TMIF.Status;
}


STATUS	tmDSPGetMiscInfo ( DWORD DSPHandle, PTMMAN_DSP_INFO pDSPInfo )
{
	TMIF_STRUCT_DSPMISCINFO	TMIF;

	TMIF.DSPHandle = DSPHandle;
	TMIF.ClientHandle = Global.dwClientHandle;

	if(ring0Call((DWORD)(TMIF_DIOC_DSPGETMISCINFO),&TMIF) != TRUE)
	{
		return TM_STATUS ( TMMAN32_ERR_DEVIOCTLFAIL );
	}

	*pDSPInfo = TMIF.Info;
	return TMIF.Status;
}



// BUFFER FUNCTIONS 
STATUS	tmBufferPrepare ( DWORD DSPHandle, PVOID pvBufferAddr,
	DWORD dwBufferSize, PDWORD	pdwPhysicalAddress, PDWORD pdwHandle )
{
	TMIF_STRUCT_BUFFERPREPARE	TMIF;
	STATUS	Status = TMOK;

	TMIF.DSPHandle = DSPHandle;
	TMIF.ClientHandle = Global.dwClientHandle;
	TMIF.dwAddress = (DWORD)pvBufferAddr;
	TMIF.dwSize = dwBufferSize;

	if(ring0Call((DWORD)(TMIF_DIOC_BUFFERPREPARE),&TMIF) != TRUE)
	{
		Status = TM_STATUS ( TMMAN32_ERR_DEVIOCTLFAIL );
	}
	else
	{
		Status = TMIF.Status;
		*pdwPhysicalAddress = TMIF.dwPhysicalAddress;
		*pdwHandle = TMIF.dwBufferHandle;
	}
	return Status;
}

STATUS	tmBufferUnprepare ( DWORD dwHandle )
{
	TMIF_STRUCT_BUFFERUNPREPARE	TMIF;
	STATUS	Status = TMOK;
	
	TMIF.ClientHandle = Global.dwClientHandle;
	TMIF.dwBufferHandle = dwHandle;
	
	if(ring0Call((DWORD)(TMIF_DIOC_BUFFERUNPREPARE),&TMIF) != TRUE)
	{
		Status = TM_STATUS ( TMMAN32_ERR_DEVIOCTLFAIL );
	}
	else
	{
		Status = TMIF.Status;
	}
	return Status;
}

// PARAMETER SET & GET FUNCTIONS 
STATUS	tmParameterDWORDSet ( DWORD	DSPHandle, DWORD ID, DWORD Value )
{
	TMIF_STRUCT_DWORDPARAMGETSET	TMIF;
	STATUS	Status = TMOK;

	TMIF.ClientHandle = Global.dwClientHandle;
	TMIF.DSPHandle = DSPHandle;
	TMIF.ParamID = ID;
	TMIF.Value = Value;
	
	if(ring0Call((DWORD)(TMIF_DIOC_DWORDPARAMSET),&TMIF) != TRUE)
	{
		Status = TM_STATUS ( TMMAN32_ERR_DEVIOCTLFAIL );
	}
	else
	{
		Status = TMIF.Status;
	}
	return Status;
}

/* 
	tmParameterDWORDGet
	get parameters for counterparts running on DSP 
*/
STATUS	tmParameterDWORDGet ( DWORD	DSPHandle, DWORD ID, PDWORD pValue )
{
	TMIF_STRUCT_DWORDPARAMGETSET	TMIF;
	STATUS	Status = TMOK;

	TMIF.ClientHandle = Global.dwClientHandle;
	TMIF.DSPHandle = DSPHandle;
	TMIF.ParamID = ID;
	
	if(ring0Call((DWORD)(TMIF_DIOC_DWORDPARAMGET),&TMIF) != TRUE)
	{
		Status = TM_STATUS ( TMMAN32_ERR_DEVIOCTLFAIL );
	}
	else
	{
		Status = TMIF.Status;
		*pValue = TMIF.Value;
	}
	return Status;
}

// DSP FUNCTIONS
STATUS	tmDSPGetStatus ( DWORD dwHandle, PDWORD pdwFlags );