/*---------------------------------------------------------------------------- 
COPYRIGHT (c) 1998 by Philips Semiconductors

THIS SOFTWARE IS FURNISHED UNDER A LICENSE AND MAY ONLY BE USED AND COPIED IN 
ACCORDANCE WITH THE TERMS AND CONDITIONS OF SUCH A LICENSE AND WITH THE 
INCLUSION OF THE THIS COPY RIGHT NOTICE. THIS SOFTWARE OR ANY OTHER COPIES 
OF THIS SOFTWARE MAY NOT BE PROVIDED OR OTHERWISE MADE AVAILABLE TO ANY OTHER
PERSON. THE OWNERSHIP AND TITLE OF THIS SOFTWARE IS NOT TRANSFERRED. 

THE INFORMATION IN THIS SOFTWARE IS SUBJECT TO CHANGE WITHOUT ANY PRIOR NOTICE
AND SHOULD NOT BE CONSTRUED AS A COMMITMENT BY Philips Semiconductor. 

PHILIPS ASSUMES NO RESPONSIBILITY FOR THE USE OR RELIABILITY OF THIS SOFTWARE
ON PLATFORMS OTHER THAN THE ONE ON WHICH THIS SOFTWARE IS FURNISHED.
----------------------------------------------------------------------------*/
/*
	HISTORY
	960325	Tilakraj Roy 	Created
	960325	Tilakraj Roy 	Due to the PnP bug in TM-CTC we use the PCI Bios
							rather than	Win95 for retrieving PnP Settings.
	960326	Tilakraj Roy	Added conditional code for USE_CM
	960404	Tilakraj Roy	Added code for handling configuration
	960620	Tilakraj Roy	Added comments and remomed TMPNP_OBJECT dependency
							on TM_CONFIG
	981021	Tilakraj Roy	Ported to WDM PnP interfaces.
	010828	Wim de Haan		Changed code to remove compiler warnings:
							line 824: 'tmmanPnpStopDevice' : must return a value
							line 1051: 'tmmanDeviceProperty' : not all control paths return a value
*/

/*----------------------------------------------------------------------------
          SYSTEM INCLUDE FILES
----------------------------------------------------------------------------*/
#include "wdm.h"

/*----------------------------------------------------------------------------
          DRIVER SPECIFIC INCLUDE FILES
----------------------------------------------------------------------------*/
#include "tmmanapi.h"
#include "tmmanlib.h"
#include "platform.h"

#define SDRAM_LENGTH	(8 * 1024 * 1024)
#define MMIO_LENGTH		(2 * 1024 * 1024)

BOOLEAN	pnpGetPCIInformation ( 
	IN USHORT Vendor, 
	IN USHORT Device,
	IN ULONG  MMIOAddress,
	OUT	PULONG	BusNumberPtr,
	PPCI_SLOT_NUMBER SlotNumberPtr );

VOID	DumpPNPResources ( 
	PCM_RESOURCE_LIST	ResourceList );

/*----------------------------------------------------------------------------
          GENERIC PNP FUNCTIONS
----------------------------------------------------------------------------*/

NTSTATUS tmmanPnpComplete (
	PDEVICE_OBJECT DeviceObject,
	PIRP Irp,
	PVOID Context  );


char * tmmanPnpDumpMinorCode ( ULONG MinorFunction );
char * tmmanPnpDumpState ( ULONG State );

NTSTATUS
tmmanPnp(
	PDEVICE_OBJECT FunctionalDeviceObject, 
	PIRP Irp )
{
	NTSTATUS				Status = STATUS_SUCCESS;
	PIO_STACK_LOCATION		IoStack;
	KEVENT					StackDriverEvent;
	TMManDeviceObject*			DeviceExtension = 
		(TMManDeviceObject*)FunctionalDeviceObject->DeviceExtension;

	DPF (0,("tmmanPnp:FunctionalDeviceObject[%x]:Irp[%x]\n", 
		FunctionalDeviceObject, Irp ));	

	// Get a pointer to the current location in the Irp. This is where
	// the function codes and parameters are located.
	IoStack = IoGetCurrentIrpStackLocation(Irp);

	KeInitializeEvent ( &StackDriverEvent, NotificationEvent, FALSE );

	DPF(0, ("tmmanPnp:MinorCode[%s]:State[%s]\n", 
		tmmanPnpDumpMinorCode ( IoStack->MinorFunction ),
		tmmanPnpDumpState ( DeviceExtension->DeviceState ) ));
	
	switch(IoStack->MinorFunction)
	{
		case IRP_MN_START_DEVICE:
		switch ( DeviceExtension->DeviceState )
		{
			case constTMMan_DEVICE_STATE_NEVERSTARTED :
			case constTMMan_DEVICE_STATE_STARTED :
			IoCopyCurrentIrpStackLocationToNext ( Irp );

			IoSetCompletionRoutine (
				Irp,
				tmmanPnpComplete,
				&StackDriverEvent,
				TRUE,
				TRUE,
				TRUE );

			Status = IoCallDriver ( DeviceExtension->StackDeviceObject, Irp );

			if ( STATUS_PENDING == Status )
			{
				KeWaitForSingleObject (
					&StackDriverEvent,
					Executive,
					KernelMode,
					FALSE,
					NULL );

				Status = Irp->IoStatus.Status;

			}

			if ( NT_SUCCESS ( Status ) )
			{
				Status = tmmanPnpStartDevice ( FunctionalDeviceObject, Irp );

				if ( NT_SUCCESS ( Status ) )
				{
					DeviceExtension->DeviceState = constTMMan_DEVICE_STATE_STARTED;
				}

			}

			Irp->IoStatus.Status = Status;
			Irp->IoStatus.Information = 0;
			IoCompleteRequest ( Irp, IO_NO_INCREMENT );
			break;


			default :
			IoSkipCurrentIrpStackLocation ( Irp );
			Status = IoCallDriver ( DeviceExtension->StackDeviceObject, Irp );
			break;
		}
		break;
		
		case IRP_MN_QUERY_REMOVE_DEVICE:
		switch ( DeviceExtension->DeviceState )
		{
			case constTMMan_DEVICE_STATE_STARTED :
			Status = tmmanDeviceCanRemove ( DeviceExtension );

			Irp->IoStatus.Status = Status;

			if ( ! NT_SUCCESS ( Status ) )
			{
				IoCompleteRequest (Irp, IO_NO_INCREMENT);	
			}
			else
			{
				DeviceExtension->DeviceState = constTMMan_DEVICE_STATE_REMOVEPENDING;

				tmmanDeviceWaitForRemove ( DeviceExtension );

				IoSkipCurrentIrpStackLocation (Irp);

				Status = IoCallDriver ( DeviceExtension->StackDeviceObject, Irp );
			}
			break;

			default :
			IoSkipCurrentIrpStackLocation ( Irp );
			Status = IoCallDriver ( DeviceExtension->StackDeviceObject, Irp );
			break;
		}
		break;

		case IRP_MN_REMOVE_DEVICE:
		switch ( DeviceExtension->DeviceState )
		{
			case constTMMan_DEVICE_STATE_REMOVEPENDING :
			tmmanPnpStopDevice ( FunctionalDeviceObject );
			// fall through

			case constTMMan_DEVICE_STATE_SURPRISEREMOVED :
			case constTMMan_DEVICE_STATE_STARTED :
			DeviceExtension->Removed = TRUE;
			DeviceExtension->DeviceState = constTMMan_DEVICE_STATE_REMOVED;
			tmmanDeviceWaitForRemove ( DeviceExtension );
			
			IoSkipCurrentIrpStackLocation ( Irp );
			Status = IoCallDriver ( DeviceExtension->StackDeviceObject, Irp );

			tmmanPnpRemoveDevice(
				FunctionalDeviceObject );
			break;

			default :
			IoSkipCurrentIrpStackLocation ( Irp );
			Status = IoCallDriver ( DeviceExtension->StackDeviceObject, Irp );
			break;
		}
		break;
		// not suported under Win98
		/*
		case IRP_MN_SURPRISE_REMOVAL:
		DPF (0,("IRP_MN_SURPRISE_REMOVAL\n"));
		switch ( DeviceExtension->DeviceState )
		{
			case constTMMan_DEVICE_STATE_STARTED :
			DPF (0,("DEVICE_STATE_STARTED\n"));
			break;

			default :
			IoSkipCurrentIrpStackLocation ( Irp );
			Status = IoCallDrivers ( DeviceExtension->StackDeviceObject, Irp );
			break;
		}
		break;
		*/

		case IRP_MN_CANCEL_REMOVE_DEVICE:
		switch ( DeviceExtension->DeviceState )
		{
			case constTMMan_DEVICE_STATE_REMOVEPENDING :

			IoCopyCurrentIrpStackLocationToNext ( Irp );

			IoSetCompletionRoutine (
				Irp,
				tmmanPnpComplete,
				&StackDriverEvent,
				TRUE,
				TRUE,
				TRUE );

			Status = IoCallDriver ( DeviceExtension->StackDeviceObject, Irp );

			if ( STATUS_PENDING == Status )
			{
				KeWaitForSingleObject (
					&StackDriverEvent,
					Executive,
					KernelMode,
					FALSE,
					NULL );

			}
			DeviceExtension->DeviceState = constTMMan_DEVICE_STATE_STARTED;
			Irp->IoStatus.Status = Status;
			Irp->IoStatus.Information = 0;
			IoCompleteRequest(Irp, IO_NO_INCREMENT);
			break;

			default :
			IoSkipCurrentIrpStackLocation ( Irp );
			Status = IoCallDriver ( DeviceExtension->StackDeviceObject, Irp );
			break;
		}
		break;

		
		case IRP_MN_QUERY_STOP_DEVICE:
		switch ( DeviceExtension->DeviceState )
		{
			case constTMMan_DEVICE_STATE_STARTED :

			Status = tmmanDeviceCanRemove ( DeviceExtension );

			Irp->IoStatus.Status = Status;

			if ( ! NT_SUCCESS ( Status ) )
			{
				IoCompleteRequest (Irp, IO_NO_INCREMENT);	
			}
			else
			{
				DeviceExtension->DeviceState = constTMMan_DEVICE_STATE_STOPPENDING;

				tmmanDeviceWaitForRemove ( DeviceExtension );

				IoSkipCurrentIrpStackLocation (Irp);

				Status = IoCallDriver ( DeviceExtension->StackDeviceObject, Irp );
			}
			break;

			default :
			IoSkipCurrentIrpStackLocation ( Irp );
			Status = IoCallDriver ( DeviceExtension->StackDeviceObject, Irp );
			break;
		}
		break;


		case IRP_MN_CANCEL_STOP_DEVICE:
		switch ( DeviceExtension->DeviceState )
		{
			case constTMMan_DEVICE_STATE_STOPPENDING :
			IoCopyCurrentIrpStackLocationToNext ( Irp );

			IoSetCompletionRoutine (
				Irp,
				tmmanPnpComplete,
				&StackDriverEvent,
				TRUE,
				TRUE,
				TRUE );

			Status = IoCallDriver ( DeviceExtension->StackDeviceObject, Irp );

			if ( STATUS_PENDING == Status )
			{
				KeWaitForSingleObject (
					&StackDriverEvent,
					Executive,
					KernelMode,
					FALSE,
					NULL );

			}
			DeviceExtension->DeviceState = constTMMan_DEVICE_STATE_STARTED;
			Irp->IoStatus.Status = Status;
			Irp->IoStatus.Information = 0;
			IoCompleteRequest(Irp, IO_NO_INCREMENT);
			break;

			default :
			IoSkipCurrentIrpStackLocation ( Irp );
			Status = IoCallDriver ( DeviceExtension->StackDeviceObject, Irp );
			break;
		}
		break;

		case IRP_MN_STOP_DEVICE:
		switch ( DeviceExtension->DeviceState )
		{
			case constTMMan_DEVICE_STATE_STOPPENDING :
			DeviceExtension->Stopped = TRUE;
			DeviceExtension->DeviceState = constTMMan_DEVICE_STATE_STOPPED;
			tmmanPnpStopDevice ( FunctionalDeviceObject );
			tmmanDeviceWaitForStop ( DeviceExtension );
			IoSkipCurrentIrpStackLocation ( Irp );
			Status = IoCallDriver ( DeviceExtension->StackDeviceObject, Irp );
			break;

			default :
			IoSkipCurrentIrpStackLocation ( Irp );
			Status = IoCallDriver ( DeviceExtension->StackDeviceObject, Irp );
			break;
		}
		break;

		default:
		IoSkipCurrentIrpStackLocation ( Irp );
		Status = IoCallDriver ( DeviceExtension->StackDeviceObject, Irp );
		break;

	}

	return Status;
}
/*
NTSTATUS
tmmanPower(
	PDEVICE_OBJECT DeviceObject, 
	PIRP Irp )
{
	DPF (0,("tmmanPower:DeviceObject[%x]:Irp[%x]\n", DeviceObject, Irp ));	

	Irp->IoStatus.Status = STATUS_SUCCESS;
	Irp->IoStatus.Information = 0;
	IoCompleteRequest(Irp, IO_NO_INCREMENT);
	return STATUS_SUCCESS;
}
*/

NTSTATUS
tmmanPnpAddDevice(
	PDRIVER_OBJECT DriverObject,
	PDEVICE_OBJECT PhysicalDeviceObject )
{
    UNICODE_STRING		KernelDeviceNameUnicode;
	PDEVICE_OBJECT		FunctionalDeviceObject;
	PDEVICE_OBJECT		StackDeviceObject;
	ULONG				DeviceNumber;
	ULONG				Idx;
	NTSTATUS			Status;
	TMManDeviceObject*	DeviceExtension;

	ANSI_STRING			KernelDeviceNameANSI;
	CHAR				KernelDeviceName[32];


	for ( Idx = 0 ; Idx < TMManGlobal->MaximumDevices ; Idx ++ )
	{
		// find an empty slot
		if ( TMManGlobal->DeviceList[Idx] == NULL )
		{
			DeviceNumber = Idx;