}
		break;

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

			TMIF->Status = eventSignal (
					TMIF->Handle );
			ReturnInformation = sizeof ( tmifGenericFunction );
		}
		break;

		//---------------------------------------------------------------------
		//	Debugging 
		//---------------------------------------------------------------------
		case constIOCTLtmmanGetDebugDPBuffers : //vxd callable
		{
			tmifDebugBuffers*	TMIF =
				(tmifDebugBuffers*)IOParameters;
			TMManDeviceObject* TMManDevice = (TMManDeviceObject*)TMIF->DSPHandle;
			UInt32	ClientIdx, DeviceIdx;
			UInt32			Dummy;
			Bool			Status;
			UInt32			SDRAMKernelBaseAddress;


			Status = debugDPBuffers (
				TMManDevice->HalHandle,
				&TMIF->FirstHalfPtr, 
				&TMIF->FirstHalfSize, 
				&TMIF->SecondHalfPtr, 
				&TMIF->SecondHalfSize );

			ReturnInformation = sizeof ( tmifDebugBuffers );

			if ( Status == True )
			{
				TMIF->Status = statusSuccess;
			}
			else
			{
				// we have nothing so exit out
				TMIF->Status = statusDebugNoDebugInformation;
				break;
			}

			halGetSDRAMInfo (
				TMManDevice->HalHandle,
				(Pointer*)&Dummy,
				(Pointer*)&SDRAMKernelBaseAddress,
				&Dummy );

			if ( TMIF->FirstHalfPtr )
			{
				TMIF->FirstHalfPtr = TMIF->FirstHalfPtr - SDRAMKernelBaseAddress;
			}

			if ( TMIF->SecondHalfPtr )
			{
				TMIF->SecondHalfPtr = TMIF->SecondHalfPtr - SDRAMKernelBaseAddress;
			}
		}
		break;

		case constIOCTLtmmanGetDebugTargetBuffers : //vxd callable
		{
			tmifDebugBuffers*	TMIF =
				(tmifDebugBuffers*)IOParameters;
			TMManDeviceObject* TMManDevice = (TMManDeviceObject*)TMIF->DSPHandle;
			UInt32	ClientIdx, DeviceIdx;
			UInt32			Dummy;
			Bool			Status;
			UInt32			SDRAMKernelBaseAddress;
			
			Status = debugTargetBuffers (
				TMManDevice->HalHandle,
				&TMIF->FirstHalfPtr, 
				&TMIF->FirstHalfSize, 
				&TMIF->SecondHalfPtr, 
				&TMIF->SecondHalfSize );

			ReturnInformation = sizeof ( tmifDebugBuffers );

			if ( Status == True )
			{
				TMIF->Status = statusSuccess;
			}
			else
			{
				// we have nothing so exit out
				TMIF->Status = statusDebugNoDebugInformation;
				break;
			}

			halGetSDRAMInfo (
				TMManDevice->HalHandle,
				(Pointer*)&Dummy,
				(Pointer*)&SDRAMKernelBaseAddress,
				&Dummy );

			if ( TMIF->FirstHalfPtr )
			{
				TMIF->FirstHalfPtr = TMIF->FirstHalfPtr - SDRAMKernelBaseAddress;
			}

			if ( TMIF->SecondHalfPtr )
			{
				TMIF->SecondHalfPtr = TMIF->SecondHalfPtr - SDRAMKernelBaseAddress;
			}
		}
		break;

		case constIOCTLtmmanGetDebugHostBuffers : //vxd callable
		{
			tmifDebugBuffers*	TMIF =
				(tmifDebugBuffers*)IOParameters;
			Bool	Status;

			Status = debugHostBuffers (
				&TMIF->FirstHalfPtr, 
				&TMIF->FirstHalfSize, 
				&TMIF->SecondHalfPtr, 
				&TMIF->SecondHalfSize );

			TMIF->Status = 
				( Status == True ) ? statusSuccess : statusDebugNoDebugInformation;
			ReturnInformation = sizeof ( tmifDebugBuffers );

		}
		break;

		case constIOCTLtmmanDebugPrintf : //vxd callable
		{
			//appliction stuff is printed only if level 31 is enabled.
			DPF(31,( IOParameters ));
		}
		break;

		//---------------------------------------------------------------------
		//	Shared Memory
		//---------------------------------------------------------------------
		case constIOCTLtmmanSharedMemoryCreate : //vxd callable
		{
			tmifSharedMemoryCreate*	TMIF =
				(tmifSharedMemoryCreate*)IOParameters;
			TMManDeviceObject* TMManDevice = (TMManDeviceObject*)TMIF->DSPHandle;
			UInt32			ClientIdx, DeviceIdx;
			UInt8*			KernelMemoryAddress;

			TMIF->Status = memoryCreate(
				TMManDevice->MemoryManagerHandle,
				Process, // client listhead struct
				TMIF->Name, 
				TMIF->Size, 
				&KernelMemoryAddress,
				&TMIF->SharedMemoryHandle);


			if ( TMIF->Status == statusSuccess )
			{
				TMIF->Address =	KernelMemoryAddress - TMManDevice->MemoryBlock;
			}

			ReturnInformation = sizeof ( tmifSharedMemoryCreate );

		}
		break;

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

			TMIF->Status = memoryDestroy(
				TMIF->Handle );
			ReturnInformation = sizeof ( tmifGenericFunction );

		}
		break;

		case constIOCTLtmmanSharedMemoryGetAddress : // vxd callable
		{
			tmifSharedMemoryAddress*	TMIF =
				(tmifSharedMemoryAddress*)IOParameters;

			PHYSICAL_ADDRESS	PhysicalAddress;
			UInt32				KernelMemoryAddress;
			UInt32				HalHandle;

			TMIF->Status = memoryGetAddress (
				TMIF->SharedMemoryHandle,
				&KernelMemoryAddress );

			if ( TMIF->Status == statusSuccess )
			{
				PhysicalAddress = MmGetPhysicalAddress((PVOID)KernelMemoryAddress);

				memoryGetHalHandle ( 
					TMIF->SharedMemoryHandle,
					&HalHandle );

				TMIF->PhysicalAddress = halTranslateTargetPhysicalAddress ( 
					HalHandle, 
					PhysicalAddress.LowPart );
			}

			ReturnInformation = sizeof ( tmifSharedMemoryAddress );

		}
		break;



		//---------------------------------------------------------------------
		//	DMA Buffer Locking
		//---------------------------------------------------------------------
		case constIOCTLtmmanSGBufferCreate :
		{
			tmifSGBufferCreate*	TMIF =
				(tmifSGBufferCreate*)lpBufIn;

			TMManDeviceObject* TMManDevice = (TMManDeviceObject*)TMIF->DSPHandle;
            // mapped address is passed in output buffer to ensure 
            // mapping to this process context!!!!!!!!!!!!!!!!!!!
            DWORD MappedAddress = (DWORD) lpBufOut;
            DWORD  Size          = dwLenOut;


			TMIF->Status = sgbufferCreate (
				TMManDevice->SGBufferManagerHandle,
				(Pointer)dwOpenContext, // client listhead struct
				TMIF->Name,
				MappedAddress,
				Size,
				TMIF->Flags,
				&TMIF->SGBufferHandle );


			ReturnInformation = sizeof ( tmifSGBufferCreate );

		}
		break;

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

			TMIF->Status = sgbufferDestroy ( TMIF->Handle );

			ReturnInformation = sizeof ( tmifGenericFunction );

		}
		break;
		// the following 2 DEVIOCTLS are protected in user 
		// mode by a Global Mutex.
		case constIOCTLtmmanXlateAdapterAddress1 : // vxd callable
		{
			tmifGenericFunction*	TMIF =
				(tmifGenericFunction*)lpBufIn;

            DWORD		AdapterPhysicalAddress;
            DWORD       dwSize;
    
			//store the tranalted address in a temporary global variable
			KernelIoControl( ( TMManGlobal->OEMIOCTLBase + TMM_IOCTL_GET_PHYS_ADDRESS_OFFSET ),
                 lpBufOut,
                 dwLenOut,
                 (PVOID)&AdapterPhysicalAddress,
                 sizeof(DWORD),
                 &dwSize);

			TMManGlobal->XlatedAddress = AdapterPhysicalAddress;
            // nothing to be returned as the output buffer is METHOD_OUT_DIRECT.
			*pdwActualOut = dwLenOut;

		}
		break;

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

			// retrieved the stored address
			TMIF->Handle = TMManGlobal->XlatedAddress;
			TMIF->Status = statusSuccess;

			ReturnInformation = sizeof ( tmifGenericFunction );

		}
		break;

		case constIOCTLtmmanMapSDRAM : // vxd callable
		{
			tmifGenericFunction*	TMIF =
				(tmifGenericFunction*)IOParameters;
			TMManDeviceObject* TMManDevice = (TMManDeviceObject*)TMIF->Handle;
			TMIF->Status = statusSuccess;
			ReturnInformation = sizeof ( tmifGenericFunction );

			if ( TMManGlobal->MapSDRAM )
				break;

			/* for WinCE we don't need to map SDRAM into user mode here*/
			if ( halMapSDRAM ( TMManDevice->HalHandle ) != TRUE )
			{
				TMIF->Status = statusMemoryUnavailable;
				DPF(0,("tmman:tmmanOpen:halMapAdapterMemory:SDRAM:FAIL\n" ));
				break;
			}

		}
		break;


		case constIOCTLtmmanUnmapSDRAM : // vxd callable
		{
			tmifGenericFunction*	TMIF =
				(tmifGenericFunction*)IOParameters;
			TMManDeviceObject* TMManDevice = (TMManDeviceObject*)TMIF->Handle;
			TMIF->Status = statusSuccess;
			ReturnInformation = sizeof ( tmifGenericFunction );

			if ( TMManGlobal->MapSDRAM )
				break;

			/* for WinCE we don't need to unmap SDRAM from user mode here */
			halUnmapSDRAM ( TMManDevice->HalHandle );
		}
		break;

        default :
		return TRUE;
	}


	return TRUE;
}

TMStatus	tmmanKernelModeNegotiateVersion ( 
	tmmanVersion* Version )
{
	TMStatus	Status = statusSuccess;

	if ( Version->Major != verGetFileMajorVersion() )
	{
		DPF(0,("tmman:tmmanKernelModeNegotiateVersion:MajorVersion:FAIL\n"));
		Status = statusMajorVersionError;
		goto tmifNegotiateVersionExit1;
	}

	if ( Version->Minor != verGetFileMinorVersion()  )
	{
		DPF(0,("tmman:tmmanKernelModeNegotiateVersion:MinorVersion:FAIL\n"));
		Status = statusMinorVersionError;
		goto tmifNegotiateVersionExit1;
	}

tmifNegotiateVersionExit1 :
	Version->Major = verGetFileMajorVersion();
	Version->Minor = verGetFileMinorVersion();
	Version->Build = verGetFileBuildVersion();
	return Status;
}


UInt32	tmmanPhysicalToMapped ( 
	tmmanMemoryBlock* MemoryBlock, 
	UInt32 PhysicalAddress )
{
	return MemoryBlock->MappedAddress + (PhysicalAddress - MemoryBlock->PhysicalAddress);
}


DWORD 
TMM_Read(
	DWORD	   dwOpenContext,
	LPVOID	pBuffer,
	DWORD	   dwCount
	)
{
   UNREFERENCED_PARAMETER(dwOpenContext);	
   UNREFERENCED_PARAMETER(pBuffer);	
   UNREFERENCED_PARAMETER(dwCount);	

   // return EOF.
   return (DWORD)0L;
}

DWORD
TMM_Write(
	DWORD	   dwOpenContext,
	LPCVOID	pSourceBytes,
	DWORD	   dwNumberOfBytes
	)
{
   UNREFERENCED_PARAMETER(dwOpenContext);	
   UNREFERENCED_PARAMETER(pSourceBytes);	
   UNREFERENCED_PARAMETER(dwNumberOfBytes);	

   // return 0 bytes written.
   return (DWORD)0L;
}

DWORD
TMM_Seek(
	DWORD	   dwOpenContext,
	long	   Amount,
	DWORD	   dwType
	)
{
   UNREFERENCED_PARAMETER(dwOpenContext);	
   UNREFERENCED_PARAMETER(Amount);	
   UNREFERENCED_PARAMETER(dwType);	

   // return position 0
   return (DWORD)0L;
}

void
TMM_PowerDown(
	DWORD	   dwOpenContext
	)
{
   UNREFERENCED_PARAMETER(dwOpenContext);	
   return;
}

void
TMM_PowerUp(
	DWORD	   dwOpenContext
	)
{
   UNREFERENCED_PARAMETER(dwOpenContext);
   return;	
}