pnp.cpp

vc开发的PCI总线加密卡 PCI开发卡主要由PCI9054、93C56、16M晶振和相应的跳线、控制地址数据线等部分组成。PCI9054是PLX公司的PCI主模式桥芯片

/******************************************************************************
 * * File Name:
 * *      PlugPlay.cpp
 * * Description:
 * *      Plug 'n' Play handler functions
 * * Revision History:
 * *      03-2-02 : PDC4000 v3.20
 *******************************************************************************/

#define INITGUID			// Initialize WDMIO_GUID in this module
#include "PDC4000.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;
	PDEVICE_OBJECT		fdo;
	PDEVICE_EXTENSION	pdx;

	KdPrint((DBG_NAME "AddDevice Start.\n"));

    //Create a functional device object to represent the hardware we're managing.
	//创建设备
	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
		KdPrint((DBG_NAME "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
	{						// Finish initialization
		//变量初始化
		pdx->pDeviceObject		   = fdo;
		pdx->pPhysicalDeviceObject = pdo;
		pdx->UsageCount            = 1;				// Locked until RemoveDevice
		KeInitializeEvent(&pdx->StoppingEvent,NotificationEvent,FALSE);
		pdx->bStopping			   = FALSE;

		pdx->GotResource=FALSE;					

		// Indicate the I/O Manager buffer management method
		//该变量初始化后，不能更改
		fdo->Flags |= DO_DIRECT_IO;	//DO_BUFFERED_IO;


		// Initialize DPC object
		IoInitializeDpcRequest(fdo, DpcForIsr);
		
		// Register a device interface
		status = IoRegisterDeviceInterface(pdo,&GUID_INTERFACE_PDC4000, 
											NULL,&pdx->InterfaceName);
		if (!NT_SUCCESS(status))
		{						// unable to register interface
			KdPrint((DBG_NAME "PDC4000: - IoRegisterDeviceInterface failed - %x.", 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
			KdPrint((DBG_NAME "IoAttachDeviceToDeviceStack failed.\n"));
			status = STATUS_DEVICE_REMOVED;
			__leave;
		}						// can't attach device
		//设置设备接口状态
		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;
		POWER_STATE state;
		state.DeviceState = PowerDeviceD0;
		PoSetPowerState(fdo, DevicePowerState, state);

		pdx->bSetWaitEvent = FALSE;
		pdx->pWaitEvent = NULL;
	
		KeInitializeSpinLock(&(pdx->DmaChannelLock));
		KeInitializeSpinLock(&(pdx->HardwareAccessLock));

		KdPrint((DBG_NAME "Adddevice End.\n"));
		// 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;

	KdPrint((DBG_NAME "Pnp Start.\n"));

	pdx = (PDEVICE_EXTENSION) fdo->DeviceExtension;

	if (!LockDevice(pdx))
	{
		return CompleteRequestInfo(pIrp,STATUS_DELETE_PENDING,0);
	}

    stack = IoGetCurrentIrpStackLocation(pIrp);

    // Check minor code
	//如果没有需要处理的，默认处理
    switch (stack->MinorFunction)
    {
        case IRP_MN_START_DEVICE:	//必须实现
            KdPrint((DBG_NAME "IRP_MN_START_DEVICE.\n"));
            status = PnpStartDevice(fdo,pIrp);
            break;

        case IRP_MN_STOP_DEVICE:
            KdPrint((DBG_NAME "IRP_MN_STOP_DEVICE.\n"));
            status = PnpStopDevice(fdo,pIrp);
            break;

        case IRP_MN_REMOVE_DEVICE:
            KdPrint((DBG_NAME "IRP_MN_REMOVE_DEVICE.\n"));
            status = PnpRemoveDevice(fdo,pIrp);
			return status;
            break;

        case IRP_MN_QUERY_REMOVE_DEVICE:
            KdPrint((DBG_NAME "IRP_MN_QUERY_REMOVE_DEVICE.\n"));
            status = DefaultPnpHandler(fdo,pIrp);
            break;

        case IRP_MN_CANCEL_REMOVE_DEVICE:
            KdPrint((DBG_NAME "IRP_MN_CANCEL_REMOVE_DEVICE.\n"));
            status = DefaultPnpHandler(fdo,pIrp);
            break;

        case IRP_MN_QUERY_STOP_DEVICE:
            KdPrint((DBG_NAME "IRP_MN_QUERY_STOP_DEVICE.\n"));
            status = DefaultPnpHandler(fdo,pIrp);
            break;

        case IRP_MN_CANCEL_STOP_DEVICE:
            KdPrint((DBG_NAME "IRP_MN_CANCEL_STOP_DEVICE.\n"));
            status = DefaultPnpHandler(fdo,pIrp);
            break;

        case IRP_MN_QUERY_DEVICE_RELATIONS:
            KdPrint((DBG_NAME "IRP_MN_QUERY_DEVICE_RELATIONS.\n"));
            status = DefaultPnpHandler(fdo,pIrp);
            break;

        case IRP_MN_QUERY_INTERFACE:
            KdPrint((DBG_NAME "IRP_MN_QUERY_INTERFACE.\n"));
            status = DefaultPnpHandler(fdo,pIrp);
            break;

        case IRP_MN_QUERY_CAPABILITIES:
            KdPrint((DBG_NAME "IRP_MN_QUERY_CAPABILITIES.\n"));
            status = DefaultPnpHandler(fdo,pIrp);
            break;

        case IRP_MN_QUERY_RESOURCES:
            KdPrint((DBG_NAME "IRP_MN_QUERY_RESOURCES.\n"));
            status = DefaultPnpHandler(fdo,pIrp);
            break;

        case IRP_MN_QUERY_RESOURCE_REQUIREMENTS:
            KdPrint((DBG_NAME "IRP_MN_QUERY_RESOURCE_REQUIREMENTS.\n"));
            status = DefaultPnpHandler(fdo,pIrp);
            break;

        case IRP_MN_QUERY_DEVICE_TEXT:
            KdPrint((DBG_NAME "IRP_MN_QUERY_DEVICE_TEXT.\n"));
            status = DefaultPnpHandler(fdo,pIrp);
            break;

        case IRP_MN_FILTER_RESOURCE_REQUIREMENTS:
            KdPrint((DBG_NAME "IRP_MN_FILTER_RESOURCE_REQUIREMENTS.\n"));
            status = DefaultPnpHandler(fdo,pIrp);
            break;

        case IRP_MN_READ_CONFIG:
            KdPrint((DBG_NAME "IRP_MN_READ_CONFIG.\n"));
            status = DefaultPnpHandler(fdo,pIrp);
            break;

        case IRP_MN_WRITE_CONFIG:
            KdPrint((DBG_NAME "IRP_MN_WRITE_CONFIG.\n"));
            status = DefaultPnpHandler(fdo,pIrp);
            break;

        case IRP_MN_EJECT:
            KdPrint((DBG_NAME "IRP_MN_EJECT.\n"));
            status = DefaultPnpHandler(fdo,pIrp);
            break;

        case IRP_MN_SET_LOCK:
            KdPrint((DBG_NAME "IRP_MN_SET_LOCK.\n"));
            status = DefaultPnpHandler(fdo,pIrp);
            break;

        case IRP_MN_QUERY_ID:
            KdPrint((DBG_NAME "IRP_MN_QUERY_ID.\n"));
            status = DefaultPnpHandler(fdo,pIrp);
            break;

        case IRP_MN_QUERY_PNP_DEVICE_STATE:
            KdPrint((DBG_NAME "IRP_MN_QUERY_PNP_DEVICE_STATE.\n"));
            status = DefaultPnpHandler(fdo,pIrp);
            break;

        case IRP_MN_QUERY_BUS_INFORMATION:
            KdPrint((DBG_NAME "IRP_MN_QUERY_BUS_INFORMATION.\n"));
            status = DefaultPnpHandler(fdo,pIrp);
            break;

        case IRP_MN_DEVICE_USAGE_NOTIFICATION:
            KdPrint((DBG_NAME "IRP_MN_DEVICE_USAGE_NOTIFICATION.\n"));
            status = DefaultPnpHandler(fdo,pIrp);
            break;

        case IRP_MN_SURPRISE_REMOVAL:
            KdPrint((DBG_NAME "IRP_MN_SURPRISE_REMOVAL.\n"));
            status = DefaultPnpHandler(fdo,pIrp);
            break;

//		case IRP_MN_QUERY_LEGACY_BUS_INFORMATION:
//			KdPrint(("IRP_MN_QUERY_LEGACY_BUS_INFORMATION\n")));
//			status = DefaultPnpHandler(fdo,pIrp);
//			break;

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

	UnlockDevice(pdx);

	KdPrint((DBG_NAME "Pnp End.\n"));

    return status;
}											//DispatchPnp

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

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

/******************************************************************************