tmif.c

PNX系列设备驱动 PNX系列设备驱动

				(tmifDSPLoad*)IOParameters;
			TMManDeviceObject* TMManDevice = (TMManDeviceObject*)TMIF->DSPHandle;
			// don't do anything in kernel mode for now

			// BUGCHECK : set the hal endiannesss here
			// the endian ness swap has to be done here since it is only 
			// during loading that we will know what endianess the target 
			// is running in.
			halSwapEndianess ( 
				TMManDevice->HalHandle,
				( TMIF->Endianess == constTMManEndianessBig ) );

			halSetPeerVersion ( 
				TMManDevice->HalHandle,
				TMIF->PeerMajorVersion,
				TMIF->PeerMinorVersion );

			TMIF->Status = 	statusSuccess;
			ReturnInformation = sizeof ( tmifDSPLoad );
		}
		break;

		case	constIOCTLtmmanDSPStart :
		{
			tmifGenericFunction*	TMIF =
					(tmifGenericFunction*)IOParameters;
			TMManDeviceObject* TMManDevice = (TMManDeviceObject*)TMIF->Handle;

			UInt32		CPURevision, BoardRevision;

			LARGE_INTEGER	SystemTime;

			UInt32	TargetKernelMajorVersion;
			UInt32	TargetKernelMinorVersion;
			UInt32	DeviceVendorID;
			UInt32	SubsystemID;
			UInt32	ClassRevisionID;


			TMManDevice->Status = constTMManDSPStatusRunning;


			TMManDevice->SharedData->HostKernelMajorVersion = 
				halAccess32( TMManDevice->HalHandle, verGetFileMajorVersion() );
			TMManDevice->SharedData->HostKernelMinorVersion =
				halAccess32( TMManDevice->HalHandle, verGetFileMinorVersion() );

			TMManDevice->SharedData->HalShared = 
				halAccess32( TMManDevice->HalHandle, TMManDevice->HalSharedAddress.LowPart );
			TMManDevice->SharedData->ChannelShared = 
				halAccess32( TMManDevice->HalHandle, TMManDevice->ChannelSharedAddress.LowPart );
			TMManDevice->SharedData->VIntrShared = 
				halAccess32( TMManDevice->HalHandle, TMManDevice->VIntrSharedAddress.LowPart );
			TMManDevice->SharedData->EventShared = 
				halAccess32( TMManDevice->HalHandle, TMManDevice->EventSharedAddress.LowPart );
			TMManDevice->SharedData->DebugShared = 
				halAccess32( TMManDevice->HalHandle, TMManDevice->DebugSharedAddress.LowPart );
			TMManDevice->SharedData->MemoryShared = 
				halAccess32( TMManDevice->HalHandle, TMManDevice->MemorySharedAddress.LowPart );
			TMManDevice->SharedData->MemoryBlock = 
				halAccess32( TMManDevice->HalHandle, TMManDevice->MemoryBlockAddress.LowPart );
			TMManDevice->SharedData->NameSpaceShared = 
				halAccess32( TMManDevice->HalHandle, TMManDevice->NameSpaceSharedAddress.LowPart );
			TMManDevice->SharedData->SGBufferShared = 
				halAccess32( TMManDevice->HalHandle, TMManDevice->SGBufferSharedAddress.LowPart );

			halGetTMPCIInfo ( 
				TMManDevice->HalHandle,
				&DeviceVendorID,
				&SubsystemID,
				&ClassRevisionID );

			TMManDevice->SharedData->TMDeviceVendorID =
				halAccess32( TMManDevice->HalHandle,
				DeviceVendorID );

			TMManDevice->SharedData->TMSubsystemID =
				halAccess32( TMManDevice->HalHandle,
				SubsystemID );

			TMManDevice->SharedData->TMClassRevisionID =
				halAccess32( TMManDevice->HalHandle,
				ClassRevisionID );

			halGetBridgePCIInfo ( 
				TMManDevice->HalHandle,
				&DeviceVendorID,
				&SubsystemID,
				&ClassRevisionID );

			TMManDevice->SharedData->BridgeDeviceVendorID =
				halAccess32( TMManDevice->HalHandle,
				DeviceVendorID );

			TMManDevice->SharedData->BridgeSubsystemID =
				halAccess32( TMManDevice->HalHandle,
				SubsystemID );

			TMManDevice->SharedData->BridgeClassRevisionID =
				halAccess32( TMManDevice->HalHandle,
				ClassRevisionID );

			TMManDevice->SharedData->TargetTraceBufferSize = 
				halAccess32( TMManDevice->HalHandle, 
				TMManGlobal->TargetTraceBufferSize );

			TMManDevice->SharedData->TargetTraceLeveBitmap = 
				halAccess32( TMManDevice->HalHandle, 
				TMManGlobal->TargetTraceLeveBitmap );

			TMManDevice->SharedData->TargetTraceType =
				halAccess32( TMManDevice->HalHandle, 
				TMManGlobal->TargetTraceType );

#if (defined TMMAN_WINNT) || ( defined TMMAN_WIN98 )			
			KeQuerySystemTime ( &SystemTime );
#endif

			TMManDevice->SharedData->DebuggingHi =
				halAccess32( TMManDevice->HalHandle,
				SystemTime.HighPart );
			TMManDevice->SharedData->DebuggingLo =
				halAccess32( TMManDevice->HalHandle, 
				SystemTime.LowPart );


			TMManDevice->SharedData->TMManMailboxCount = 
				halAccess32( TMManDevice->HalHandle,
				TMManGlobal->MailboxCount );

			TMManDevice->SharedData->TMManChannelCount = 
				halAccess32( TMManDevice->HalHandle,
				TMManGlobal->ChannelCount );

			TMManDevice->SharedData->TMManVIntrCount =
				halAccess32( TMManDevice->HalHandle,
				TMManGlobal->VIntrCount );

			TMManDevice->SharedData->TMManMessageCount =
				halAccess32( TMManDevice->HalHandle,
				TMManGlobal->MessageCount );

			TMManDevice->SharedData->TMManEventCount = 
				halAccess32( TMManDevice->HalHandle,
				TMManGlobal->EventCount );

			TMManDevice->SharedData->TMManStreamCount =
				halAccess32( TMManDevice->HalHandle,
				TMManGlobal->StreamCount );

			TMManDevice->SharedData->TMManNameSpaceCount = 
				halAccess32( TMManDevice->HalHandle,
				TMManGlobal->NameSpaceCount );

			TMManDevice->SharedData->TMManMemoryCount =
				halAccess32( TMManDevice->HalHandle,
				TMManGlobal->MemoryCount );

			TMManDevice->SharedData->TMManMemorySize =
				halAccess32( TMManDevice->HalHandle,
				TMManGlobal->MemorySize );

			TMManDevice->SharedData->TMManSGBufferCount =
				halAccess32( TMManDevice->HalHandle,
				TMManGlobal->SGBufferCount );

			TMManDevice->SharedData->SpeculativeLoadFix =
				halAccess32( TMManDevice->HalHandle,
				TMManGlobal->SpeculativeLoadFix );

			TMManDevice->SharedData->PCIInterruptNumber =
				halAccess32( TMManDevice->HalHandle,
				TMManGlobal->PCIInterruptNumber );

			TMManDevice->SharedData->MMIOInterruptNumber =
				halAccess32( TMManDevice->HalHandle,
				TMManGlobal->MMIOInterruptNumber );

			DPF(1,("tmman:tmmanDeviceControl:constIOCTLtmmanDSPStart:HostKernelMajorVersion[%x]\n",
				 verGetFileMajorVersion() ));

			DPF(1,("tmman:tmmanDeviceControl:constIOCTLtmmanDSPStart:HostKernelMinorVersion[%x]\n",
				verGetFileMinorVersion() ));
			
			halGetPeerVersion ( 
				TMManDevice->HalHandle,
				&TargetKernelMajorVersion,
				&TargetKernelMinorVersion );


			DPF(1,("tmman:tmmanDeviceControl:constIOCTLtmmanDSPStart:TargetKernelMajorVersion[%x]\n",
				TargetKernelMajorVersion));
			DPF(1,("tmman:tmmanDeviceControl:constIOCTLtmmanDSPStart:TargetKernelMinorVersion[%x]\n",
				TargetKernelMinorVersion));

			DPF(1,("tmman:tmmanDeviceControl:constIOCTLtmmanDSPStart:HalShared[%x]\n",
				TMManDevice->HalSharedAddress.LowPart ));
			DPF(1,("tmman:tmmanDeviceControl:constIOCTLtmmanDSPStart:ChannelShared[%x]\n",
				TMManDevice->ChannelSharedAddress.LowPart ));
			DPF(1,("tmman:tmmanDeviceControl:constIOCTLtmmanDSPStart:VIntrShared[%x]\n",
				TMManDevice->VIntrSharedAddress.LowPart ));
			DPF(1,("tmman:tmmanDeviceControl:constIOCTLtmmanDSPStart:EventShared[%x]\n",
				TMManDevice->EventSharedAddress.LowPart ));
			DPF(1,("tmman:tmmanDeviceControl:constIOCTLtmmanDSPStart:DebugShared[%x]\n",
				TMManDevice->DebugSharedAddress.LowPart ));
			DPF(1,("tmman:tmmanDeviceControl:constIOCTLtmmanDSPStart:MemoryShared[%x]\n",
				TMManDevice->MemorySharedAddress.LowPart ));
			DPF(1,("tmman:tmmanDeviceControl:constIOCTLtmmanDSPStart:MemoryBlock[%x]\n",
				TMManDevice->MemoryBlockAddress.LowPart ));
			DPF(1,("tmman:tmmanDeviceControl:constIOCTLtmmanDSPStart:NameSpaceShared[%x]\n",
				TMManDevice->NameSpaceSharedAddress.LowPart ));
			DPF(1,("tmman:tmmanDeviceControl:constIOCTLtmmanDSPStart:SGBufferShared[%x]\n",
				TMManDevice->SGBufferSharedAddress.LowPart ));

			halGetTMPCIInfo ( 
				TMManDevice->HalHandle,
				&DeviceVendorID,
				&SubsystemID,
				&ClassRevisionID );


			DPF(1,("tmman:tmmanDeviceControl:constIOCTLtmmanDSPStart:TM:DeviceVendorID[%x]\n",
				DeviceVendorID));
			DPF(1,("tmman:tmmanDeviceControl:constIOCTLtmmanDSPStart:TM:SubsystemID[%x]\n",
				SubsystemID));
			DPF(1,("tmman:tmmanDeviceControl:constIOCTLtmmanDSPStart:TM:ClassRevisionID[%x]\n",
				ClassRevisionID));

			halGetBridgePCIInfo ( 
				TMManDevice->HalHandle,
				&DeviceVendorID,
				&SubsystemID,
				&ClassRevisionID );

			DPF(1,("tmman:tmmanDeviceControl:constIOCTLtmmanDSPStart:Bridge:DeviceVendorID[%x]\n",
				DeviceVendorID));
			DPF(1,("tmman:tmmanDeviceControl:constIOCTLtmmanDSPStart:Bridge:SubsystemID[%x]\n",
				SubsystemID));
			DPF(1,("tmman:tmmanDeviceControl:constIOCTLtmmanDSPStart:Bridge:ClassRevisionID[%x]\n",
				ClassRevisionID));

			DPF(1,("tmman:tmmanDeviceControl:constIOCTLtmmanDSPStart:TargetTraceBufferSize[%x]\n",
				TMManGlobal->TargetTraceBufferSize  ));
			DPF(1,("tmman:tmmanDeviceControl:constIOCTLtmmanDSPStart:TargetTraceLeveBitmap[%x]\n",
				TMManGlobal->TargetTraceLeveBitmap ));
			DPF(1,("tmman:tmmanDeviceControl:constIOCTLtmmanDSPStart:TargetTraceType[%x]\n",
				TMManGlobal->TargetTraceType ));

			DPF(1,("tmman:tmmanDeviceControl:constIOCTLtmmanDSPStart:DebuggingHi[%x]\n",
				SystemTime.HighPart ));
			DPF(1,("tmman:tmmanDeviceControl:constIOCTLtmmanDSPStart:DebuggingLo[%x]\n",
				SystemTime.LowPart ));

			DPF(1,("tmman:tmmanDeviceControl:constIOCTLtmmanDSPStart:TMManMailboxCount[%x]\n",
				TMManGlobal->MailboxCount));
			DPF(1,("tmman:tmmanDeviceControl:constIOCTLtmmanDSPStart:TMManChannelCount[%x]\n",
				TMManGlobal->ChannelCount));
			DPF(1,("tmman:tmmanDeviceControl:constIOCTLtmmanDSPStart:TMManVIntrCount[%x]\n",
				TMManGlobal->VIntrCount));
			DPF(1,("tmman:tmmanDeviceControl:constIOCTLtmmanDSPStart:TMManMessageCount[%x]\n",
				TMManGlobal->MessageCount));
			DPF(1,("tmman:tmmanDeviceControl:constIOCTLtmmanDSPStart:TMManEventCount[%x]\n",
				TMManGlobal->EventCount));
			DPF(1,("tmman:tmmanDeviceControl:constIOCTLtmmanDSPStart:TMManStreamCount[%x]\n",
				TMManGlobal->StreamCount));
			DPF(1,("tmman:tmmanDeviceControl:constIOCTLtmmanDSPStart:TMManNameSpaceCount[%x]\n",
				TMManGlobal->NameSpaceCount));
			DPF(1,("tmman:tmmanDeviceControl:constIOCTLtmmanDSPStart:TMManMemoryCount[%x]\n",
				TMManGlobal->MemoryCount));
			DPF(1,("tmman:tmmanDeviceControl:constIOCTLtmmanDSPStart:TMManMemorySize[%x]\n",
				TMManGlobal->MemorySize));
			DPF(1,("tmman:tmmanDeviceControl:constIOCTLtmmanDSPStart:TMManSGBufferCount[%x]\n",
				TMManGlobal->SGBufferCount));
			DPF(1,("tmman:tmmanDeviceControl:constIOCTLtmmanDSPStart:SpeculativeLoadFix[%x]\n",
				TMManGlobal->SpeculativeLoadFix));
			DPF(1,("tmman:tmmanDeviceControl:constIOCTLtmmanDSPStart:PCIInterruptNumber[%x]\n",
				TMManGlobal->PCIInterruptNumber));
			DPF(1,("tmman:tmmanDeviceControl:constIOCTLtmmanDSPStart:MMIOInterruptNumber[%x]\n",
				TMManGlobal->MMIOInterruptNumber));

			halReset ( TMManDevice->HalHandle );
			channelManagerReset ( TMManDevice->ChannelManagerHandle );
			vintrManagerReset (	TMManDevice->VIntrManagerHandle );
			eventManagerReset (	TMManDevice->EventManagerHandle );
			namespaceManagerReset (	TMManDevice->NameSpaceManagerHandle );
			memoryManagerReset ( TMManDevice->MemoryManagerHandle );
			sgbufferManagerReset ( TMManDevice->SGBufferManagerHandle );

			TMIF->Status = 	halStartDSP ( TMManDevice->HalHandle );
			ReturnInformation = sizeof ( tmifGenericFunction );
		}
		break;

		case	constIOCTLtmmanDSPStop :
		{
			tmifGenericFunction*	TMIF =
					(tmifGenericFunction*)IOParameters;
			TMManDeviceObject* TMManDevice = (TMManDeviceObject*)TMIF->Handle;

			TMManDevice->Status = constTMManDSPStatusReset;
			TMIF->Status = 	halStopDSP ( TMManDevice->HalHandle );
			ReturnInformation = sizeof ( tmifGenericFunction );
		}
		break;

		case	constIOCTLtmmanDSPReset :
		{
			tmifGenericFunction*	TMIF =
					(tmifGenericFunction*)IOParameters;
			TMManDeviceObject* TMManDevice = (TMManDeviceObject*)TMIF->Handle;
			TMManDevice->Status = constTMManDSPStatusReset;
			TMIF->Status = halResetDSP( TMManDevice->HalHandle);
			ReturnInformation = sizeof ( tmifGenericFunction );
		}
		break;

		case constIOCTLtmmanDSPGetInternalInfo : // vxd callable
		{
			tmifDSPInternalInfo*	TMIF =
					(tmifDSPInternalInfo*)IOParameters;
			TMManDeviceObject* TMManDevice = (TMManDeviceObject*)TMIF->DSPHandle;
			UInt32				ClientIdx;
			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.Flags = TMManDevice->Flags;
			TMIF->Info.CRunTimeHandle = TMManDevice->CRunTimeHandle;
			TMIF->Info.DebugOptionBitmap = 0;

			halGetPeerVersion ( 
				TMManDevice->HalHandle,
				&TMIF->Info.PeerMajorVersion,
				&TMIF->Info.PeerMinorVersion );

			// BUGCHECK : should we swap endianess here
			TMIF->Info.TMManSharedPhysicalAddress = 
				TMManDevice->TMManSharedAddress.LowPart;

			TMIF->Info.Memory.MappedAddress = 
				(UInt32)Client->Device[TMManDevice->DSPNumber].MemoryAddrUser;
			TMIF->Info.Memory.PhysicalAddress = 
				(UInt32)((TMManDeviceObject*)Client->Device[TMManDevice->DSPNumber].Device)->MemoryBlockAddress.LowPart;
			TMIF->Info.Memory.Size = 
				(UInt32)((TMManDeviceObject*)Client->Device[TMManDevice->DSPNumber].Device)->MemoryBlockSize;

			TMIF->Status = statusSuccess;
			ReturnInformation = sizeof ( tmifDSPInternalInfo );

		}
		break;

		case constIOCTLtmmanDSPSetInternalInfo : // vxd callable
		{
			tmifDSPInternalInfo*	TMIF =
					(tmifDSPInternalInfo*)IOParameters;
			TMManDeviceObject* TMManDevice = (TMManDeviceObject*)TMIF->DSPHandle;
			// this function should change on the alterable fields
			TMManDevice->Flags = TMIF->Info.Flags;
			TMManDevice->CRunTimeHandle = TMIF->Info.CRunTimeHandle;

			TMIF->Status = statusSuccess;
			ReturnInformation = sizeof ( tmifDSPInternalInfo );
		}
		break;

		case	constIOCTLtmmanDSPStatus : // vxd callable
		{
			tmifDSPStatus*	TMIF =
				(tmifDSPStatus*)IOParameters;
			TMManDeviceObject* TMManDevice = (TMManDeviceObject*)TMIF->DSPHandle;
			TMIF->DSPStatus = TMManDevice->Status;
			TMIF->Status = statusSuccess;
			ReturnInformation = sizeof ( tmifDSPStatus );
		}
		break;

		case	constIOCTLtmmanDSPGetEndianess : // vxd callable
		{
			tmifDSPEndianess*	TMIF =
				(tmifDSPEndianess*)IOParameters;
			TMManDeviceObject* TMManDevice = (TMManDeviceObject*)TMIF->DSPHandle;
			Bool		SwapEnable;

			TMIF->Status = halGetEndianess ( TMManDevice->HalHandle,  &SwapEnable );

			TMIF->Endianess = 
				( ( SwapEnable ) ? 
				( constTMManEndianessBig ) : 
				( constTMManEndianessLittle ) );

			ReturnInformation = sizeof ( tmifDSPEndianess );
		}
		break;

		//---------------------------------------------------------------------
		//	Message
		//---------------------------------------------------------------------
		case constIOCTLtmmanMessageCreate : // vxd callable
		{
			tmifMessageCreate*	TMIF =
				(tmifMessageCreate*)IOParameters;
			TMManDeviceObject* TMManDevice = (TMManDeviceObject*)TMIF->DSPHandle;
			TMIF->Status = messageCreate ( 
				TMManDevice->MessageManagerHandle,
				PsGetCurrentProcess(), // client listhead struct
				TMIF->Name,
				TMIF->SynchObject,
				TMIF->SynchFlags,
				&TMIF->MessageHandle );
			ReturnInformation = sizeof ( tmifMessageCreate );
		}
		break;


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

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

		}
		break;

		case constIOCTLtmmanMessageSend : // vxd callable
		{
			tmifMessageSR*	TMIF =
				(tmifMessageSR*)IOParameters;

			TMIF->Status = messageSend (
					TMIF->MessageHandle,
					TMIF->Packet );
			ReturnInformation = sizeof ( tmifMessageSR );
		}
		break;

		case constIOCTLtmmanMessageReceive : // vxd callable
		{
			tmifMessageSR*	TMIF =
				(tmifMessageSR*)IOParameters;

			TMIF->Status = messageReceive ( 
					TMIF->MessageHandle,
					TMIF->Packet );
			ReturnInformation = sizeof ( tmifMessageSR );

		}
		break;

		//---------------------------------------------------------------------
		//	Event
		//---------------------------------------------------------------------
		case constIOCTLtmmanEventCreate : // vxd callable
		{
			tmifEventCreate*	TMIF =
				(tmifEventCreate*)IOParameters;
			TMManDeviceObject* TMManDevice = (TMManDeviceObject*)TMIF->DSPHandle;
			TMIF->Status = eventCreate (