/*****************************************************************************
 Company 	:	Shree Ganesha Inc. 	
 File Name	:	SkyWalker1PnP.cpp
 Author		:	
 Date 		: 	
 Purpose 	:	PnP IRP Message Handler
 				
 Revision History:
===============================================================================
		DATE				VERSION		AUTHOR					REMARK
===============================================================================
	
	XXth April,2009			 01							 	Initial Version

*****************************************************************************/
/* Include the Library and Other header file				*/
#include "SkyWalker1Main.h"	//Common For all the Definitions,
							//Declarations and Library Routines
/* End of Inclusion the Library and Other header file		*/

/* Macro Definitions 										*/
/* End of Global & Static variables Declaration				*/

/* External Variable Declaration							*/
/* End of External Variable Declaration						*/

/* Declare Enumerations here								*/
/* End of Enumeration declaration							*/

/* Function Prototypes										*/
void PrintKSDeviceObject(IN PKSDEVICE pKSDeviceObject);
/* End of Function prototype definitions					*/

/*****************************************************************************
 Function		:	SkyWalker1AddDevice
 Description	:	This Function is called by the PnP Manager for each Device
					managed by the Driver.It is called during the System Initialization
					and any time a new Device is enumerated while the System is running.
 IN PARAM		:	<PKSDEVICE > Pointer to the Enumerated Physical Device
					KSDEVICE is a WDM Functional Device which is managed by the AVStream
 OUT PARAM		:	<NTSTATUS> Status of the Device Addition
					STATUS_SUCCESS when the Device added to the System
					Reason for Failure incase of Error
 PreCondition	:	Driver is Loaded without Functional/ Filter Device Objects
 PostCondtion	:	Functional Device Object [FDO] or Filter Device Object [FiDO] are created
 Logic			:	NONE
 Assumption 	:	NONE
 Note 			:	AddDevice is Must for the PnP Drivers
					This routine runs at PASSIVE_LEVEL_IRQL
 Revision History:	<REVISION HISTORY OF THE FUNCTION, MUST BE MAINTAINED BY MAINTAINER	>	
 *****************************************************************************/
NTSTATUS SkyWalker1AddDevice(IN PKSDEVICE pKSDeviceObject)
{
	NTSTATUS ntAddDeviceStatus = STATUS_SUCCESS;
	PKSFILTERFACTORY pFilterFactory = NULL;

	PrintFunctionEntry(__FUNCTION__);
	PrintKSDeviceObject(pKSDeviceObject);
	
	if(!IS_VALID(pKSDeviceObject))
	{
		SkyWalkerDebugPrint(ENTRY_LEVEL,("Invalid KS Device Object Received\n"));
		ntAddDeviceStatus = STATUS_UNSUCCESSFUL;
		goto FinishAddDevice;
	}
	
	//Allcate Memory for the SkyWalker1 Device
	CSkyWalker1Device * pDevice = new(NonPagedPool,TUNER_MEM_TAG)CSkyWalker1Device;
	if(!IS_VALID(pDevice))
	{
		SkyWalkerDebugPrint(ENTRY_LEVEL,("Can not allocate Memory for the SkyWalker1 Device\n"));
		ntAddDeviceStatus = STATUS_INSUFFICIENT_RESOURCES;
		goto FinishAddDevice;
	}

	ntAddDeviceStatus = pDevice->Create(pKSDeviceObject);

	PrintKSDeviceObject(pKSDeviceObject);

FinishAddDevice:

	PrintFunctionExit(__FUNCTION__,ntAddDeviceStatus);

	return ntAddDeviceStatus;
}
/*****************************************************************************
 Function		:	SkyWalker1Remove
 Description	:	This function is called when the IRP_MN_REMOVE_DEVICE is sent 
					by the PnP Manager during Device Removal
 IN PARAM		:	<PKSDEVICE > Pointer to the Enumerated Physical Device
					KSDEVICE is a WDM Functional Device which is managed by the AVStream
					<PIRP> Remove Device Io Request Packet
 OUT PARAM		:	NONE
 PreCondition	:	Started Device 
 PostCondtion	:	Device Removed
 Logic			:	NONE
 Assumption 	:	NONE
 Note 			:	NONE
 Revision History:	<REVISION HISTORY OF THE FUNCTION, MUST BE MAINTAINED BY MAINTAINER	>	
 *****************************************************************************/
VOID SkyWalker1Remove(	IN PKSDEVICE pKSDeviceObject,
						IN PIRP pIoRequestPacket)
{
	NTSTATUS ntDeviceRemoveStatus = STATUS_SUCCESS;
	CSkyWalker1Device * pDevice = NULL;
	PrintFunctionEntry(__FUNCTION__);

	//Get the SkyWalker1 Device Object from the Context Info.
	pDevice = reinterpret_cast<CSkyWalker1Device *>(pKSDeviceObject->Context);

	if(!IS_VALID(pDevice))
	{
		//Unexpected Remove for the Device
		SkyWalkerDebugPrint(ENTRY_LEVEL,("No Connection found with SkyWalker Device\n"));
		ntDeviceRemoveStatus = STATUS_UNSUCCESSFUL;
		goto ExitRemoveDevice;
	}
	
	ntDeviceRemoveStatus = pDevice->Close(pKSDeviceObject,pIoRequestPacket);

	//Deallocate the SkyWalker1 Device Object Memory
	delete pDevice;
	//Remove Reference of the SkyWalker1 Device from the KS Object
	pKSDeviceObject->Context = NULL;

ExitRemoveDevice:

	PrintFunctionExit(__FUNCTION__,ntDeviceRemoveStatus);

}

/*****************************************************************************
 Function		:	SkyWalker1Start
 Description	:	This function is called when the IRP_MN_START_DEVICE is sent 
					by the PnP Manager after Allocating Resources to the Device.
					IRP_MN_START_DEVICE is called once for each device created from
					the Driver using the IoCreateDevice() call.
					When BDA Device Starts operating Pnp Dispatches the IRP_MN_START_DEVICE to the ks.sys
					AvStream class Driver inturn calls the start routine of the BDA minidriver 
					associated with the BDA Device. This Start Routine retrives information about the 
					device from the registry, sets information about the Device and then calls the 
					BdaCreateFilterFactory() support function to 
					1) Create Filter Factory from the Initial Filter Descriptor (KSFILTER_DESCRIPTOR) 
					   for the Device.The Initial Filter Descriptor references Dispatch and Automation 
						 tables for the Filter and Input Pins
					2) Associate Filter Factory with the BDA_FILTER_TEMPLATE structure.This structure
						 references template filter descriptor for the Device and the list of possible 
						 pairs of the input and output pins.The Descriptor and list inturn reference.
						 a)	Static Template Structure that can be used by Network Provider to determine 
							BDA Driver topology
						 b) Static Template Structure that can be used by Network Provider to manipulate 
							BDA Filter
						 c) Nodes and Pins for a BDA Filter along with possible ways to connect the Filter
						 d) Routines that a Netwrok provider can use to Create and Close a Filter instance
					3) Register the Static Template structures that are specified by BDA_FILTER_TEMPLATE
						 with the BDA support library so that the library can provide default handling 
						 for a BDA MiniDriver's Properties and methods.
 IN PARAM		:	<PKSDEVICE> Reference to Device to be Started
					<PIRP> IoRequest Packet
 OUT PARAM		:	<NTSTATUS> Status of the Tuner Start
					STATUS_SUCCESS in case of successful execution
					Failure Code in other cases
 PreCondition	:	Stopped Device or Device Enumerated for the First Time
 PostCondtion	:	Device Initialized with the Newly allocated Resources,
 Logic			:	NONE
 Assumption 	:	NONE
 Note 			:	This is called from the PASSIVE_LEVEL_IRQL					
 Revision History:	<REVISION HISTORY OF THE FUNCTION, MUST BE MAINTAINED BY MAINTAINER	>	
 *****************************************************************************/
NTSTATUS SkyWalker1Start(IN PKSDEVICE pKSDeviceObject,
						 IN PIRP pIoRequestPacket,
						 IN PCM_RESOURCE_LIST pResourceList,
						 IN PCM_RESOURCE_LIST pResourceListTranslated)
{
	
	NTSTATUS ntStartStatus = STATUS_SUCCESS;
	CSkyWalker1Device *      pDevice = NULL;
	PrintFunctionEntry(__FUNCTION__);
	
	//Get the SkyWalker1 Device Object from the Context Info.
	pDevice = reinterpret_cast<CSkyWalker1Device *>(pKSDeviceObject->Context);

	if(!IS_VALID(pDevice))
	{
		//No Device Found
		SkyWalkerDebugPrint(ENTRY_LEVEL,("No Connection with SkyWalker Device\n"));
		ntStartStatus = STATUS_UNSUCCESSFUL;
		goto ExitStartDevice;
	}

	//Call the Start device function of the SkyWalker1 Device class
	ntStartStatus = pDevice->Start(	pKSDeviceObject,
									pIoRequestPacket,
									pResourceList,
									pResourceListTranslated);

ExitStartDevice:

	PrintFunctionExit(__FUNCTION__,ntStartStatus);
	return STATUS_SUCCESS;
}

/*****************************************************************************
 Function		:	SkyWalker1Stop
 Description	:	This function is called when the IRP_MN_STOP_DEVICE is sent 
					by the PnP Manager during Device Removal
 IN PARAM		:	<PKSDEVICE> Reference to Device to be Removed
					<PIRP> Stop Device Io Request Packet
 OUT PARAM		:	NONE
 PreCondition	:	Started Device 
 PostCondtion	:	Device Stopped
 Logic			:	NONE
 Assumption 	:	NONE
 Note 			:	NONE
 Revision History:	<REVISION HISTORY OF THE FUNCTION, MUST BE MAINTAINED BY MAINTAINER	>	
 *****************************************************************************/
VOID SkyWalker1Stop(IN PKSDEVICE pKSDeviceObject,
					IN PIRP pIoRequestPacket)
{
	
	NTSTATUS ntStopStatus = STATUS_SUCCESS;
	CSkyWalker1Device * pDevice = NULL;
	PrintFunctionEntry(__FUNCTION__);
		
	//Get the SkyWalker1 Device Object from the Context Info.
	pDevice = reinterpret_cast<CSkyWalker1Device *>(pKSDeviceObject->Context);

	if(!IS_VALID(pDevice))
	{
		SkyWalkerDebugPrint(ENTRY_LEVEL,("No Connection with SkyWalker Device\n"));
		goto ExitStopDevice;
	}

	//Call the Stop device function of the SkyWalker1 Device class
	ntStopStatus = pDevice->Stop(	pKSDeviceObject,
									pIoRequestPacket
									);
ExitStopDevice:	
	PrintFunctionExit(__FUNCTION__,ntStopStatus);
}

/*****************************************************************************
 Function		:	SkyWalker1QueryStop
 Description	:	This function is called when the IRP_MN_QUERY_STOP_DEVICE is sent 
					by the PnP Manager during Device Stop
 IN PARAM		:	<PKSDEVICE > Pointer to the Enumerated Physical Device
					KSDEVICE is a WDM Functional Device which is managed by the AVStream
					<PIRP> Remove Device Io Request Packet
 OUT PARAM		:	NONE
 PreCondition	:	Started Device 
 PostCondtion	:	Query for stopping device is returned
 Logic			:	NONE
 Assumption 	:	NONE
 Note 			:	All the Devices created by the Driver are connected with Each other
					with the NextDevice Member of the Device Object
 Revision History:	<REVISION HISTORY OF THE FUNCTION, MUST BE MAINTAINED BY MAINTAINER	>	
 *****************************************************************************/
NTSTATUS SkyWalker1QueryStop(	IN PKSDEVICE pKSDeviceObject,
								IN PIRP pIoRequestPacket)	
{
	PrintFunctionEntry(__FUNCTION__);
	
	PrintFunctionExit(__FUNCTION__,STATUS_SUCCESS);
	return STATUS_SUCCESS;

}

/*****************************************************************************
 Function		:	SkyWalker1SetPower
 Description	:	This function is called when the IRP_MJ_POWER is sent 
					by the PnP Manager during Power Management
 IN PARAM		:	<PKSDEVICE > Pointer to the Enumerated Physical Device
					KSDEVICE is a WDM Functional Device which is managed by the AVStream
					<PIRP> Power Device Io Request Packet
 OUT PARAM		:	NONE
 PreCondition	:	Started Device 
 PostCondtion	:	Query for stopping device is returned
 Logic			:	NONE
 Assumption 	:	NONE
 Note 			:	All the Devices created by the Driver are connected with Each other
					with the NextDevice Member of the Device Object
 Revision History:	<REVISION HISTORY OF THE FUNCTION, MUST BE MAINTAINED BY MAINTAINER	>	
 *****************************************************************************/
VOID SkyWalker1SetPower
(
    IN PKSDEVICE          pKSDeviceObject, //Pointer to the device object
                                     //provided by the system.
    IN PIRP               pIoRequestPacket,//Pointer to the IRP related to this request.
    IN DEVICE_POWER_STATE To,  //Requested power state.
    IN DEVICE_POWER_STATE From //Current power state.
)
{
	CSkyWalker1Device * pDevice = NULL;
	
	PrintFunctionEntry(__FUNCTION__);
	//Get the SkyWalker1 Device Object from the Context Info.
	pDevice = reinterpret_cast<CSkyWalker1Device *>(pKSDeviceObject->Context);

	if(!IS_VALID(pDevice))
	{
		SkyWalkerDebugPrint(ENTRY_LEVEL,("No Connection with SkyWalker Device\n"));
		goto ExitSetPower;
	}

	//Call the Set Power device function of the SkyWalker1 Device class
	pDevice->SetPower(	pKSDeviceObject,
						pIoRequestPacket,
						To,
						From
					);
ExitSetPower:

	PrintFunctionExit(__FUNCTION__,STATUS_SUCCESS);

}



void PrintKSDeviceObject(IN PKSDEVICE pKSDeviceObject)
{
	SkyWalkerDebugPrint(ENTRY_LEVEL, (__FUNCTION__"\n"));
	SkyWalkerDebugPrint(ENTRY_LEVEL, ("pKsDeviceObject->pDeviceDescriptor = 0x%p \n",pKSDeviceObject->Descriptor));
	SkyWalkerDebugPrint(ENTRY_LEVEL, ("pKsDeviceObject->pDeviceDescriptor->Dispatch = 0x%p \n",pKSDeviceObject->Descriptor->Dispatch));
	SkyWalkerDebugPrint(ENTRY_LEVEL, ("pKsDeviceObject->pDeviceDescriptor->FilterDescriptorsCount = %lu \n",pKSDeviceObject->Descriptor->FilterDescriptorsCount));
	SkyWalkerDebugPrint(ENTRY_LEVEL, ("pKsDeviceObject->pDeviceDescriptor->FilterDescriptors = 0x%p \n",pKSDeviceObject->Descriptor->FilterDescriptors));
	SkyWalkerDebugPrint(ENTRY_LEVEL, ("pKsDeviceObject->pDeviceDescriptor->Version = %lu \n",pKSDeviceObject->Descriptor->Version));
	
    SkyWalkerDebugPrint(ENTRY_LEVEL, ("pKsDeviceObject->Bag = 0x%p\n",pKSDeviceObject->Bag));
	SkyWalkerDebugPrint(ENTRY_LEVEL, ("pKsDeviceObject->Context = 0x%p\n",pKSDeviceObject->Context));
	SkyWalkerDebugPrint(ENTRY_LEVEL, ("pKsDeviceObject->FunctionalDeviceObject = 0x%p\n",pKSDeviceObject->FunctionalDeviceObject));
	SkyWalkerDebugPrint(ENTRY_LEVEL, ("pKsDeviceObject->PhysicalDeviceObject = 0x%p\n",pKSDeviceObject->PhysicalDeviceObject));
	SkyWalkerDebugPrint(ENTRY_LEVEL, ("pKsDeviceObject->NextDeviceObject = 0x%p\n",pKSDeviceObject->NextDeviceObject));
	SkyWalkerDebugPrint(ENTRY_LEVEL, ("pKsDeviceObject->Started = %d\n",pKSDeviceObject->Started));
	SkyWalkerDebugPrint(ENTRY_LEVEL, ("pKsDeviceObject->SystemPowerState = %d\n",pKSDeviceObject->SystemPowerState));
	SkyWalkerDebugPrint(ENTRY_LEVEL, ("pKsDeviceObject->DevicePowerState = %d\n",pKSDeviceObject->DevicePowerState));
}