pnpmanagement.c

此驱动程序是SATA功能的PCI卡为例

/******************************************************************************
 * * File Name:
 * *      PlugPlay.c
 * * Description:
 * *      Plug 'n' Play handler functions
 * * Revision History:
 * *      10-11-07 : Silicon Image 1.00
 *******************************************************************************/

#define INITGUID			// Initialize WDMIO_GUID in this module
#include "Sil3124.h"
#include "GUIDs.h"
#pragma code_seg("PAGE")	// start PAGE section

/******************************************************************************
 *
 * Function   :  AddDevice
 *
 * Description:  Add a new functional device object for a physical one
 *
 ******************************************************************************/
NTSTATUS AddDevice(IN PDRIVER_OBJECT pDriverObject,
				   IN PDEVICE_OBJECT pdo)
{													// AddDevice
	NTSTATUS			status;
	POWER_STATE         state;
	PDEVICE_OBJECT		fdo;
	PDEVICE_EXTENSION	pdx;

	DebugPrint("AddDevice Start...............Version:1.0.0");

    //Create a functional device object to represent the hardware we're managing.
	//Create Device
	status = IoCreateDevice(pDriverObject, sizeof(DEVICE_EXTENSION), NULL,
				FILE_DEVICE_UNKNOWN, 0, FALSE, &fdo);	//DeviceCharacteristics be setted 0
  

	if (!NT_SUCCESS(status))
	{						// can't create device object
	    
		DebugPrint("Sil3124 IoCreateDevice failed %x\n",status);
		return(status);
	}						// can't create device object
	
    pdx = (PDEVICE_EXTENSION) fdo->DeviceExtension;

	// From this point forward, any error will have side effects that need to
	// be cleaned up. Using a try-finally block allows us to modify the program
	// easily without losing track of the side effects.
	__try
	{
		//Initialize device extension
		pdx->pDeviceObject		   = fdo;
		pdx->pPhysicalDeviceObject = pdo;	

		KeInitializeEvent(&pdx->StoppingEvent,NotificationEvent,FALSE);
		pdx->bStopping			   = FALSE;

		pdx->GotResource = FALSE;			

		// Indicate the I/O Manager buffer management method
		//once initial,can not be changed
		fdo->Flags |= DO_BUFFERED_IO;
 //       fdo->Flags |= DO_DIRECT_IO;

		// Initialize DPC object
		IoInitializeDpcRequest(fdo, DpcForIsr);
		
		// Register a device interface
		status = IoRegisterDeviceInterface(pdo,&GUID_INTERFACE_Sil3124, 
											NULL,&pdx->InterfaceName);
		if (!NT_SUCCESS(status))
		{						// unable to register interface
			DebugPrint("Sil3124: - IoRegisterDeviceInterface failed - %x.", status);
			//IoDeleteDevice(fdo);
			//return(status);
			__leave;
		}						// unable to register interface

		// Link our device object into the stack leading to the PDO
		pdx->pLowerDeviceObject = IoAttachDeviceToDeviceStack(fdo, pdo);
		if (!pdx->pLowerDeviceObject)
		{						// can't attach device
		    DebugPrint("Sil3124: - IoAttachDeviceToDeviceStack failed.");
			status = STATUS_DEVICE_REMOVED;
			//return(status);
			__leave;
		}						// can't attach device
		//set deviceInterface state
		IoSetDeviceInterfaceState(&pdx->InterfaceName, TRUE);

		// Indicate that our initial power state is D0 (fully on). Also indicate that
		// we have a pagable power handler (otherwise, we'll never get idle shutdown
		// messages!)
		pdx->SystemPower = PowerSystemWorking;
		pdx->DevicePower = PowerDeviceD0;
		fdo->Flags |= DO_POWER_PAGABLE;

		state.DeviceState = PowerDeviceD0;
		PoSetPowerState(fdo, DevicePowerState, state);

        DebugPrint("Adddevice End.");
		// Clear the "initializing" flag so that we can get IRPs
		fdo->Flags &= ~DO_DEVICE_INITIALIZING;

		
	}		// finish initialization
	__finally
	{			// cleanup side effects
		if (!NT_SUCCESS(status))
		{					// need to cleanup
			if (pdx->InterfaceName.Buffer)
				RtlFreeUnicodeString(&pdx->InterfaceName);
			if (pdx->pLowerDeviceObject)
				IoDetachDevice(pdx->pLowerDeviceObject);
			IoDeleteDevice(fdo);
		}					// need to cleanup
							// cleanup side effects
	}
	
    return(STATUS_SUCCESS);
}													// AddDevice
/******************************************************************************
 *
 * Function   :  DispatchPnp
 *
 * Description:  Handle PnP requests
 *
 ******************************************************************************/
NTSTATUS DispatchPnp(IN PDEVICE_OBJECT fdo,
					 IN PIRP pIrp)
{													//DispatchPnp
    NTSTATUS			status;
    PIO_STACK_LOCATION	stack;
	PDEVICE_EXTENSION	pdx;

	DebugPrint("Pnp Start....");

	pdx = (PDEVICE_EXTENSION) fdo->DeviceExtension;

    stack = IoGetCurrentIrpStackLocation(pIrp);

    // Check minor code
	//if check no exist,default handling 
    switch (stack->MinorFunction)
    {
        case IRP_MN_START_DEVICE:	//must be implemented
            DebugPrint("IRP_MN_START_DEVICE.");
            status = PnpStartDevice(fdo,pIrp);
			//status = DefaultPnpHandler(fdo,pIrp);
            break;

        case IRP_MN_STOP_DEVICE:
            DebugPrint("IRP_MN_STOP_DEVICE.");
            status = PnpStopDevice(fdo,pIrp);
			//status = DefaultPnpHandler(fdo,pIrp);
            break;

        case IRP_MN_REMOVE_DEVICE:
            DebugPrint("IRP_MN_REMOVE_DEVICE.");
            status = PnpRemoveDevice(fdo,pIrp);
			//status = DefaultPnpHandler(fdo,pIrp);
			return status;
            break;

        case IRP_MN_QUERY_REMOVE_DEVICE:
            DebugPrint("IRP_MN_QUERY_REMOVE_DEVICE.");
			status = PnpQueryRemoveDeviceHandler(fdo,pIrp);
            //status = DefaultPnpHandler(fdo,pIrp);
			break;

        case IRP_MN_CANCEL_REMOVE_DEVICE:
            DebugPrint("IRP_MN_CANCEL_REMOVE_DEVICE.");
            status = DefaultPnpHandler(fdo,pIrp);
            break;

        case IRP_MN_QUERY_STOP_DEVICE:
            DebugPrint("IRP_MN_QUERY_STOP_DEVICE.");
            status = DefaultPnpHandler(fdo,pIrp);
            break;

        case IRP_MN_CANCEL_STOP_DEVICE:
            DebugPrint("IRP_MN_CANCEL_STOP_DEVICE.");
            status = DefaultPnpHandler(fdo,pIrp);
            break;

        case IRP_MN_QUERY_DEVICE_RELATIONS:
            DebugPrint("IRP_MN_QUERY_DEVICE_RELATIONS.");
            status = DefaultPnpHandler(fdo,pIrp);
            break;

        case IRP_MN_QUERY_INTERFACE:
            DebugPrint("IRP_MN_QUERY_INTERFACE.");
            status = DefaultPnpHandler(fdo,pIrp);
            break;

        case IRP_MN_QUERY_CAPABILITIES:
            DebugPrint("IRP_MN_QUERY_CAPABILITIES.");
            status = DefaultPnpHandler(fdo,pIrp);
			//status = PnpQueryCapabilitiesHandler(fdo,pIrp);
            break;

        case IRP_MN_QUERY_RESOURCES:
            DebugPrint("IRP_MN_QUERY_RESOURCES.");
            status = DefaultPnpHandler(fdo,pIrp);
            break;

        case IRP_MN_QUERY_RESOURCE_REQUIREMENTS:
            DebugPrint("IRP_MN_QUERY_RESOURCE_REQUIREMENTS.");
            status = DefaultPnpHandler(fdo,pIrp);
            break;

        case IRP_MN_QUERY_DEVICE_TEXT:
            DebugPrint("IRP_MN_QUERY_DEVICE_TEXT.");
            status = DefaultPnpHandler(fdo,pIrp);
            break;

        case IRP_MN_FILTER_RESOURCE_REQUIREMENTS:
            DebugPrint("IRP_MN_FILTER_RESOURCE_REQUIREMENTS.");
            status = DefaultPnpHandler(fdo,pIrp);
            break;

        case IRP_MN_READ_CONFIG:
            DebugPrint("IRP_MN_READ_CONFIG.");
            status = DefaultPnpHandler(fdo,pIrp);
            break;

        case IRP_MN_WRITE_CONFIG:
            DebugPrint("IRP_MN_WRITE_CONFIG.");
            status = DefaultPnpHandler(fdo,pIrp);
            break;

        case IRP_MN_EJECT:
            DebugPrint("IRP_MN_EJECT.");
            status = DefaultPnpHandler(fdo,pIrp);
            break;

        case IRP_MN_SET_LOCK:
            DebugPrint("IRP_MN_SET_LOCK.");
            status = DefaultPnpHandler(fdo,pIrp);
            break;

        case IRP_MN_QUERY_ID:
            DebugPrint("IRP_MN_QUERY_ID.");
            status = DefaultPnpHandler(fdo,pIrp);
            break;

        case IRP_MN_QUERY_PNP_DEVICE_STATE:
            DebugPrint("IRP_MN_QUERY_PNP_DEVICE_STATE.");
            status = DefaultPnpHandler(fdo,pIrp);
            break;

        case IRP_MN_QUERY_BUS_INFORMATION:
            DebugPrint("IRP_MN_QUERY_BUS_INFORMATION.");
            status = DefaultPnpHandler(fdo,pIrp);
            break;

        case IRP_MN_DEVICE_USAGE_NOTIFICATION:
            DebugPrint("IRP_MN_DEVICE_USAGE_NOTIFICATION.");
            status = DefaultPnpHandler(fdo,pIrp);
            break;

        case IRP_MN_SURPRISE_REMOVAL:
            DebugPrint("IRP_MN_SURPRISE_REMOVAL.");
            status = DefaultPnpHandler(fdo,pIrp);
            break;

        default:
            DebugPrint("Unsupported IRP_MN_Xxx (0x%x).", stack->MinorFunction);
            status = DefaultPnpHandler(fdo,pIrp);
            break;
    }

	DebugPrint("Pnp End.");

    return(status);
}											//DispatchPnp

/******************************************************************************
 *
 * Function   :  DefaultPnpHandler
 *
 * Description:  Handle standard PnP requests
 *
 ******************************************************************************/
NTSTATUS DefaultPnpHandler(IN PDEVICE_OBJECT fdo,
						   IN PIRP  pIrp)
{												//DefaultPnpHandler
	DebugPrintMsg("PnpDefaultHandler");
    IoSkipCurrentIrpStackLocation(pIrp);

    return IoCallDriver(((DEVICE_EXTENSION *)fdo->DeviceExtension)->pLowerDeviceObject,
								pIrp);
}												//DefaultPnpHandler

/******************************************************************************
 *
 * Function   :  HandleStartDevice
 *
 * Description:  Handle the IRP_MN_START_DEVICE PnP request
 *
 ******************************************************************************/
NTSTATUS PnpStartDevice(IN PDEVICE_OBJECT fdo,
						   IN PIRP pIrp )
{												//HandleStartDevice
    NTSTATUS           status;
    PIO_STACK_LOCATION stack;

    
    //First let all lower-level drivers handle this request. 
	pIrp->IoStatus.Status = STATUS_SUCCESS;
    status = ForwardAndWait(fdo,pIrp);			//Send IRP to lower driver(Bus Driver) and wait for finishing 
    if (!NT_SUCCESS(status))
    {
        return(CompleteRequest(pIrp, status));
    }

    stack = IoGetCurrentIrpStackLocation(pIrp);

    // Assign resources to the devices
    status = StartDevice(fdo,
                 &stack->Parameters.StartDevice.AllocatedResources->List[0].PartialResourceList,
                 &stack->Parameters.StartDevice.AllocatedResourcesTranslated->List[0].PartialResourceList);

    return(CompleteRequestInfo(pIrp,status,0));
}													//HandleStartDevice
/******************************************************************************
 *
 * Function   :  StartDevice
 *
 * Description:  Start a device
 *
 ******************************************************************************/
NTSTATUS StartDevice(IN PDEVICE_OBJECT fdo,
					 IN PCM_PARTIAL_RESOURCE_LIST ResourceListRaw,
					 IN PCM_PARTIAL_RESOURCE_LIST ResourceList)
{													//StartDevice
    ULONG							i;
    ULONG                           m;   
    NTSTATUS						status;
    PDEVICE_EXTENSION				pdx;
	PUCHAR  MappedAddress;

    PCM_PARTIAL_RESOURCE_DESCRIPTOR	ResourceRaw;
    PCM_PARTIAL_RESOURCE_DESCRIPTOR	Resource;
    DEVICE_DESCRIPTION deviceDescription ;          // device descriptor 

    pdx         = (PDEVICE_EXTENSION)fdo->DeviceExtension;

    ResourceRaw = ResourceListRaw->PartialDescriptors;
    Resource    = ResourceList->PartialDescriptors;

    #define MAX_DMA_LENGTH	0x100000	// 0x100000 is 1 MB
	//initialize the device descriptor 
	// Zero the device descriptor struct before fill 
	RtlZeroMemory(&deviceDescription, sizeof(deviceDescription));

	deviceDescription.Version = DEVICE_DESCRIPTION_VERSION ;
    deviceDescription.Master = TRUE ;		    // bus master.
    deviceDescription.ScatterGather = TRUE ;	   
    deviceDescription.DemandMode = FALSE ;      //Indicates whether to use the system DMA controller's demand mode. Not used for busmaster DMA. 
    deviceDescription.AutoInitialize = FALSE ;	    // We don't use autoinitialize
    deviceDescription.Dma32BitAddresses = TRUE ;