开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 文章/文档 > 通讯编程文档 > 查看源码
pnp.c
资源名称：虚拟串口驱动程序.rar　[点击查看]
上传用户：zanmei2
上传日期：2010-03-06
资源大小：775k
文件大小：17k
源码类别：

通讯编程文档

开发平台：

C/C++

pnp.c：源码内容
  1. /*++
  3. Copyright (c) 2005  Changzhi Zhou All Rights Reserved
  5. Module Name:
  7.     pnp.c
  9. Abstract:
  11.     This module works for the handles Plug&Play dispatch.
  13. Environment:
  15.     Kernel mode
  17. Revision History:
  18. Changzhi Zhou Dec 20  2004
  20. --*/
  21. #include <ntddk.h>
  22. #include <initguid.h>
  23. #include "main.h"
  24. #include "tdiclient.h"
  25. #include "..incwdmioctl.h"
  27. NTSTATUS
  28. SamplePnpDispatch (
  29.     IN PDEVICE_OBJECT DeviceObject,
  30.     IN PIRP Irp
  31.     )
  32. /*++
  34. Routine Description:
  36.     The plug and play dispatch routines.
  38.     Most of these the driver will completely ignore.
  39.     In all cases it must pass on the IRP to the lower driver.
  41. Arguments:
  43.    DeviceObject - pointer to a device object.
  45.    Irp - pointer to an I/O Request Packet.
  47. Return Value:
  49.       NT status code
  51. --*/
  52. {
  53.     PDEVICE_EXTENSION   deviceExtension;
  54.     PIO_STACK_LOCATION  irpStack;
  55.     NTSTATUS            status;
  56.     KEVENT              event;
  57. KIRQL oldIrql;
  59.     PAGED_CODE();
  61.     deviceExtension = (PDEVICE_EXTENSION) DeviceObject->DeviceExtension;
  62. irpStack = IoGetCurrentIrpStackLocation(Irp);
  63.     DebugPrint(("Sample %s IRP:0x%x n", PnPMinorFunctionString(irpStack->MinorFunction), Irp));
  65. if ( Removed == deviceExtension->DevicePnPState) {
  66.         status = STATUS_DELETE_PENDING;
  67. return CompleteRequest(Irp, status, 0 );
  68.     }
  69. status = STATUS_SUCCESS;
  70. SampleIoIncrement( deviceExtension );
  71.     
  72.     switch (irpStack->MinorFunction) {
  73.     case IRP_MN_START_DEVICE:
  74. status = PnpStartDevice( DeviceObject, Irp);
  75. break;
  76.     case IRP_MN_QUERY_STOP_DEVICE:
  77. status = PnpQueryStopDevice( DeviceObject, Irp );
  78. return status;
  79.     case IRP_MN_CANCEL_STOP_DEVICE:
  80. status = PnpCancelStopDevice( DeviceObject, Irp );
  81. break;
  82.     case IRP_MN_STOP_DEVICE:
  83.         SET_NEW_PNP_STATE(deviceExtension, Stopped);
  84. SampleIoDecrement( deviceExtension );
  85.   status = DefaultPnpHandler( DeviceObject, Irp );
  86. return status;
  87.     case IRP_MN_QUERY_REMOVE_DEVICE:
  88. status = PnpQueryRemoveDevice( DeviceObject, Irp );
  89. return status;
  90.     case IRP_MN_CANCEL_REMOVE_DEVICE:
  91. status = PnpCancelRemoveDevice( DeviceObject, Irp );
  92. break;
  93.     case IRP_MN_REMOVE_DEVICE:
  94. status = PnpRemoveDevice( DeviceObject, Irp );        
  95.         return status;
  96.     case IRP_MN_SURPRISE_REMOVAL:
  97. status = PnpSurpriseRemoval( DeviceObject, Irp );
  98. SampleIoDecrement( deviceExtension );
  99.         return status;
  100. case IRP_MN_QUERY_CAPABILITIES:
  101. return PnpQueryCapabilities( DeviceObject, Irp );
  102.     default:
  103.         IoSkipCurrentIrpStackLocation(Irp);
  104.         status = IoCallDriver(deviceExtension->NextLowerDriver, Irp);
  105. SampleIoDecrement(deviceExtension);
  106. return status;
  107.     }
  108. CompleteRequest( Irp, status, 0 );
  109.     SampleIoDecrement(deviceExtension);
  110. return status;
  111. }
  113. NTSTATUS PnpStartDevice(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
  114. /*++
  116. Routine Description:
  118. Pnp handler to IRP_MN_START_DEVICE.
  120. Arguments:
  122.     deviceExtension - pointer to a device object extension.
  123. Irp - the pointer to PnP IRP_MN_START_DEVICE Irp.
  125. Return Value:
  127.     NT status code.
  129. --*/
  130. {
  131.     NTSTATUS status;
  132. PDEVICE_EXTENSION deviceExtension;
  133.     PIO_STACK_LOCATION irpStack;
  134. KIRQL oldIrql;
  136. deviceExtension = DeviceObject->DeviceExtension;
  137. status = ForwardAndWait( DeviceObject, Irp);
  138.     if ( !NT_SUCCESS( status ) )
  139.         return CompleteRequest(Irp, status, Irp->IoStatus.Information);
  141. irpStack = IoGetCurrentIrpStackLocation( Irp );
  142. //status = CreateWorkThread( deviceExtension );
  143. // Open transport address, set clienteventhandler and initialize recvContext.
  144. status = InitializeConnection( deviceExtension );
  145. if( NT_SUCCESS( status ) && NT_SUCCESS( Irp->IoStatus.Status ) ){
  147. status = IoSetDeviceInterfaceState( &deviceExtension->InterfaceName, TRUE );
  148. if( !NT_SUCCESS( status )){
  149. DebugPrint(( "StartDevice:  IoSetDeviceInterfaceState failed (%x)n", status ));
  150. }
  151. SET_NEW_PNP_STATE( deviceExtension, Working );
  152. }
  153.     return status;
  154. }
  155. NTSTATUS
  156. PnpQueryStopDevice(
  157.     IN PDEVICE_OBJECT DeviceObject,
  158.     IN PIRP           Irp
  159.     )
  160. /*++
  162. Routine Description:
  164. Pnp handler to IRP_MN_QUERY_STOP_DEVICE.
  166. Arguments:
  168.     deviceExtension - pointer to a device object extension.
  169. Irp - the pointer to PnP IRP_MN_START_DEVICE Irp.
  171. Return Value:
  173.     NT status code.
  175. --*/
  176. {
  177.     KIRQL             oldIrql;
  178.     NTSTATUS          status;
  179.     PDEVICE_EXTENSION deviceExtension;
  181.     deviceExtension = (PDEVICE_EXTENSION) DeviceObject->DeviceExtension;
  182.     //
  183.     // If we can stop the device, we need to set the QueueState to 
  184.     // PendingStop so further requests will be queued.
  185.     //
  186.     SET_NEW_PNP_STATE(deviceExtension, PendingStop);
  187.     SampleIoDecrement( deviceExtension );
  189.     KeWaitForSingleObject(&deviceExtension->StopEvent,
  190.                           Executive,
  191.                           KernelMode,
  192.                           FALSE,
  193.                           NULL);
  194. status = DefaultPnpHandler( DeviceObject, Irp );
  195.     return status;
  196. }
  198. NTSTATUS
  199. PnpCancelStopDevice(
  200.     IN PDEVICE_OBJECT DeviceObject,
  201.     IN PIRP           Irp
  202.     )
  203. /*++
  205. Routine Description:
  207. Pnp handler to IRP_MN_CANCEL_STOP_DEVICE.
  209. Arguments:
  211.     deviceExtension - pointer to a device object extension.
  212. Irp - the pointer to PnP IRP_MN_START_DEVICE Irp.
  214. Return Value:
  216.     NT status code.
  218. --*/
  219. {
  220.     KIRQL             oldIrql;    
  221.     KEVENT            event;
  222.     NTSTATUS          status;
  223.     PDEVICE_EXTENSION deviceExtension;
  225.     deviceExtension = (PDEVICE_EXTENSION) DeviceObject->DeviceExtension;
  226.     //
  227.     // Send this IRP down and wait for it to come back.
  228.     // Set the QueueState flag to AllowRequests, 
  229.     // and process all the previously queued up IRPs.
  230.     //
  232.     //
  233.     // First check to see whether you have received cancel-stop
  234.     // without first receiving a query-stop. This could happen if someone
  235.     // above us fails a query-stop and passes down the subsequent
  236.     // cancel-stop.
  237.     //
  238.     if(PendingStop == deviceExtension->DevicePnPState) {
  239. status = ForwardAndWait( DeviceObject, Irp );
  240.         if(NT_SUCCESS( status )) {
  241.             RESTORE_PREVIOUS_PNP_STATE(deviceExtension);
  242.         }
  243.     }
  244.     else {
  245.         status = STATUS_SUCCESS;
  246.     }
  247.     return status;
  248. }
  250. NTSTATUS
  251. PnpQueryRemoveDevice(
  252.     IN PDEVICE_OBJECT DeviceObject,
  253.     IN PIRP           Irp
  254.     )
  255. /*++
  257. Routine Description:
  259. Pnp handler to IRP_MN_QUERY_REMOVE_DEVICE.
  261. Arguments:
  263.     deviceExtension - pointer to a device object extension.
  264. Irp - the pointer to PnP IRP_MN_START_DEVICE Irp.
  266. Return Value:
  268.     NT status code.
  270. --*/
  272. {
  273. #define WDM_DELAY_VALUE            (ULONG)(-1 * 20000 * 1000)     // 2s
  274.     KIRQL             oldIrql;
  275.     NTSTATUS          status;
  276.     PDEVICE_EXTENSION deviceExtension;
  277.     LARGE_INTEGER deltaTime;
  280.     deviceExtension = (PDEVICE_EXTENSION) DeviceObject->DeviceExtension;
  281.     SampleIoDecrement( deviceExtension );
  283. deltaTime.LowPart = WDM_DELAY_VALUE;
  284. deltaTime.HighPart = -1;
  285.     //
  286.     // Wait deltaTime for all the requests to be completed.
  287.     // If timeout, that means some Irps haven't be completed.
  288. // So we will simply return Device_Busy and not pass down to lower driver.
  289. //
  290.     status = KeWaitForSingleObject(&deviceExtension->StopEvent, 
  291.                           Executive,
  292.                           KernelMode,
  293.                           FALSE,
  294.                           &deltaTime);
  295. if( STATUS_TIMEOUT == status )
  296. return CompleteRequest( Irp, STATUS_DEVICE_BUSY, 0 );
  297.     //
  298.     // If we can allow removal of the device, we should set the QueueState
  299.     // to HoldRequests so further requests will be queued. This is required
  300.     // so that we can process queued up requests in cancel-remove just in 
  301.     // case somebody else in the stack fails the query-remove. 
  302.     //
  303.     SET_NEW_PNP_STATE(deviceExtension, PendingRemove );
  305. status = DefaultPnpHandler( DeviceObject, Irp );
  306.     return status;
  307. }
  309. NTSTATUS
  310. PnpCancelRemoveDevice(
  311.     IN PDEVICE_OBJECT DeviceObject,
  312.     IN PIRP           Irp
  313.     )
  314. /*++
  316. Routine Description:
  318. Pnp handler to IRP_MN_CANEL_REMOVE_DEVICE.
  320. Arguments:
  322.     deviceExtension - pointer to a device object extension.
  323. Irp - the pointer to PnP IRP_MN_START_DEVICE Irp.
  325. Return Value:
  327.     NT status code.
  329. --*/
  330. {
  331.     NTSTATUS          status;
  332.     PDEVICE_EXTENSION deviceExtension;
  333. KIRQL oldIrql;
  334.     //
  335.     // initialize variables
  336.     //
  337.     deviceExtension = (PDEVICE_EXTENSION) DeviceObject->DeviceExtension;
  338.     //
  339.     // We need to reset the QueueState flag to ProcessRequest, 
  340.     // since the device resume its normal activities.
  341.     //
  342.     //
  343.     // First check to see whether you have received cancel-remove
  344.     // without first receiving a query-remove. This could happen if 
  345.     // someone above us fails a query-remove and passes down the 
  346.     // subsequent cancel-remove.
  347.     //
  348.     if(PendingRemove == deviceExtension->DevicePnPState) {
  349. status = ForwardAndWait( DeviceObject, Irp );
  350.         if(NT_SUCCESS( status )) {
  351.             RESTORE_PREVIOUS_PNP_STATE( deviceExtension );
  352.         }
  353. // Re-start workthread. omit now.
  354. //
  355.     }
  356.     else {
  357.         // 
  358.         // spurious cancel-remove
  359.         //
  360.         status = STATUS_SUCCESS;
  361.     }
  362.     return status;
  363. }
  365. NTSTATUS PnpRemoveDevice( IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
  366. /*++
  368. Routine Description:
  370. Pnp handler to IRP_MN_REMOVE_DEVICE.
  372. Arguments:
  374.     deviceExtension - pointer to a device object extension.
  375. Irp - the pointer to PnP IRP_MN_START_DEVICE Irp.
  377. Return Value:
  379.     NT status code.
  381. --*/
  382. {
  383. NTSTATUS status;
  384. PDEVICE_EXTENSION deviceExtension;
  385. KIRQL oldIrql;
  386. ULONG requestCount;
  388. DebugPrint(("+Enter RemoveDevice routinen" ));
  389. deviceExtension = DeviceObject->DeviceExtension;
  390. //  TODO: handle our remove work at first
  391. if ( SurpriseRemoved != deviceExtension->DevicePnPState )
  392. {
  393. //
  394. // If the device is not surprise removed, we should call set interface to FALSE.
  395. // If surprise removed, This step has been called in SurprisedRemoved handle.
  396. //
  397. status = IoSetDeviceInterfaceState( &deviceExtension->InterfaceName, FALSE );
  398. if( !NT_SUCCESS( status ) ){
  399. DebugPrint(( "RemoveDevice: IoSetDeviceInterfaceState failed (%x)n", status ));
  400. }
  401. }
  402. // set new PNP state
  403. SET_NEW_PNP_STATE(deviceExtension, Removed );
  404.     requestCount = SampleIoDecrement( deviceExtension );
  405.     ASSERT(requestCount > 0);
  406.     requestCount = SampleIoDecrement( deviceExtension );
  408.     KeWaitForSingleObject(&deviceExtension->RemoveEvent, 
  409.                           Executive, 
  410.                           KernelMode, 
  411.                           FALSE, 
  412.                           NULL);
  413. Disconnection( deviceExtension );
  414. // Unregister serial DosName and delete register
  415. SerialUndoExternalNaming( deviceExtension );
  416. // delete buffer pool used for device name , dos name and others.
  417. SerialRemoveDevObj( DeviceObject );
  418. RtlFreeUnicodeString( &deviceExtension->InterfaceName );
  420. Disconnection( deviceExtension );
  422. if ( deviceExtension->RxBuffer )
  423. ExFreePool ( deviceExtension->RxBuffer );
  424. if ( deviceExtension->recvContext.RemainderBuffer )
  425. ExFreePool ( deviceExtension->recvContext.RemainderBuffer );
  427. // Pass down the IRP
  428. status = DefaultPnpHandler( DeviceObject, Irp );
  430. IoDetachDevice( deviceExtension->NextLowerDriver );
  431. //
  432. // Free up interface memory
  433. //
  434. IoDeleteDevice( DeviceObject );
  435. DebugPrint(("-Exit RemoveDevice routinen"));
  436. return status;
  437. }
  439. NTSTATUS
  440. PnpSurpriseRemoval(
  441.     IN PDEVICE_OBJECT DeviceObject,
  442.     IN PIRP           Irp
  443. )
  444. /*++
  446. Routine Description:
  448. Pnp handler to IRP_MN_SURPRISE_REMOVAL.
  450. Arguments:
  452.     deviceExtension - pointer to a device object extension.
  453. Irp - the pointer to PnP IRP_MN_START_DEVICE Irp.
  455. Return Value:
  457.     NT status code.
  459. --*/
  460. {
  461. KIRQL             oldIrql;
  462.     NTSTATUS          status;
  463.     PDEVICE_EXTENSION deviceExtension;
  464.     deviceExtension = (PDEVICE_EXTENSION) DeviceObject->DeviceExtension;
  466. // set new PNP state
  467. SET_NEW_PNP_STATE(deviceExtension, SurpriseRemoved );
  468. status = IoSetDeviceInterfaceState( &deviceExtension->InterfaceName, FALSE );
  469. if( !NT_SUCCESS( status ) ){
  470. DebugPrint(( "RemoveDevice: IoSetDeviceInterfaceState failed (%x)n", status ));
  471. }
  472. status = DefaultPnpHandler( DeviceObject, Irp );
  473. return status;
  474. }
  477. NTSTATUS PnpQueryCapabilities( IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
  478. /*++
  480. Routine Description:
  482. Pnp handler to IRP_MN_QUERY_CAPABILITIES.
  484. Arguments:
  486.     deviceExtension - pointer to a device object extension.
  487. Irp - the pointer to PnP IRP_MN_START_DEVICE Irp.
  489. Return Value:
  491.     NT status code.
  493. --*/
  494. {
  495.     NTSTATUS status;
  496. PIO_STACK_LOCATION      stack;
  497.     PDEVICE_CAPABILITIES    deviceCapabilities;
  498.     PAGED_CODE ();
  500. status = ForwardAndWait( DeviceObject, Irp );
  502.     stack = IoGetCurrentIrpStackLocation (Irp);
  503.     //
  504.     // add our device's capabilities.
  505.     //
  506.     deviceCapabilities = stack->Parameters.DeviceCapabilities.Capabilities;
  507. //
  508. // thess mean the device is Removeable and NOT surprise removed.
  509. // If user force to surprise remove the device, "Unsafe remove device" dialog will appear.
  510. //
  511. deviceCapabilities->SurpriseRemovalOK = FALSE;
  512. //deviceCapabilities->Removable = TRUE;
  513. status = CompleteRequest( Irp, status, Irp->IoStatus.Information );
  514.     SampleIoDecrement( DeviceObject->DeviceExtension );
  515. return status;
  516. }
  517. NTSTATUS DefaultPnpHandler(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
  518. {
  519. PDEVICE_EXTENSION deviceExtension;
  520.     deviceExtension = (PDEVICE_EXTENSION)DeviceObject->DeviceExtension;
  521.     IoSkipCurrentIrpStackLocation( Irp );
  522.     return IoCallDriver( deviceExtension->NextLowerDriver, Irp);
  523. }
  525. NTSTATUS ForwardAndWait(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
  526. /*++
  528. Routine Description:
  530. pass down Irp to lower driver and wait for its completion.
  532. Arguments:
  534.     deviceExtension - pointer to a device object extension.
  535. Irp - the pointer to PnP IRP_MN_START_DEVICE Irp.
  537. Return Value:
  539.     NT status code.
  541. --*/
  542. {
  543.     KEVENT event;
  544.     NTSTATUS status;
  545. PDEVICE_EXTENSION deviceExtension;
  547. deviceExtension = ( PDEVICE_EXTENSION )DeviceObject->DeviceExtension;
  548.     
  549. KeInitializeEvent(&event, NotificationEvent, FALSE);
  551.     IoCopyCurrentIrpStackLocationToNext( Irp );
  553.     IoSetCompletionRoutine(Irp, (PIO_COMPLETION_ROUTINE) 
  554.         OnRequestComplete, (PVOID) &event, TRUE, TRUE, TRUE);
  556. status = IoCallDriver( deviceExtension->NextLowerDriver, Irp);
  557.     if (status == STATUS_PENDING)
  558.     {                       // wait for completion
  559.         KeWaitForSingleObject(
  560. &event,
  561. Executive, // Waiting for reasion of a driver
  562. KernelMode, // Waiting in kernel mode
  563. FALSE, // No alert
  564. NULL); // No timeout
  565.         status = Irp->IoStatus.Status;
  566.     }                       // wait for completion
  568.     return status;
  569. }
  570. NTSTATUS OnRequestComplete(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp,
  571.     IN PKEVENT event)
  572. {
  573.     KeSetEvent( event, 0, FALSE);
  574.     return STATUS_MORE_PROCESSING_REQUIRED;
  575. }
  577. #if DBG
  578. PCHAR
  579. PnPMinorFunctionString (
  580.     UCHAR MinorFunction
  581. )
  582. /*++
  584. Routine Description:
  586. Print PnP Irp's minor function informaion.
  588. Arguments:
  590.     deviceExtension - pointer to a device object extension.
  591. Irp - the pointer to PnP IRP_MN_START_DEVICE Irp.
  593. Return Value:
  595.     NT status code.
  597. --*/
  598. {
  599.     switch (MinorFunction)
  600.     {
  601.         case IRP_MN_START_DEVICE:
  602.             return "IRP_MN_START_DEVICE";
  603.         case IRP_MN_QUERY_REMOVE_DEVICE:
  604.             return "IRP_MN_QUERY_REMOVE_DEVICE";
  605.         case IRP_MN_REMOVE_DEVICE:
  606.             return "IRP_MN_REMOVE_DEVICE";
  607.         case IRP_MN_CANCEL_REMOVE_DEVICE:
  608.             return "IRP_MN_CANCEL_REMOVE_DEVICE";
  609.         case IRP_MN_STOP_DEVICE:
  610.             return "IRP_MN_STOP_DEVICE";
  611.         case IRP_MN_QUERY_STOP_DEVICE:
  612.             return "IRP_MN_QUERY_STOP_DEVICE";
  613.         case IRP_MN_CANCEL_STOP_DEVICE:
  614.             return "IRP_MN_CANCEL_STOP_DEVICE";
  615.         case IRP_MN_QUERY_DEVICE_RELATIONS:
  616.             return "IRP_MN_QUERY_DEVICE_RELATIONS";
  617.         case IRP_MN_QUERY_INTERFACE:
  618.             return "IRP_MN_QUERY_INTERFACE";
  619.         case IRP_MN_QUERY_CAPABILITIES:
  620.             return "IRP_MN_QUERY_CAPABILITIES";
  621.         case IRP_MN_QUERY_RESOURCES:
  622.             return "IRP_MN_QUERY_RESOURCES";
  623.         case IRP_MN_QUERY_RESOURCE_REQUIREMENTS:
  624.             return "IRP_MN_QUERY_RESOURCE_REQUIREMENTS";
  625.         case IRP_MN_QUERY_DEVICE_TEXT:
  626.             return "IRP_MN_QUERY_DEVICE_TEXT";
  627.         case IRP_MN_FILTER_RESOURCE_REQUIREMENTS:
  628.             return "IRP_MN_FILTER_RESOURCE_REQUIREMENTS";
  629.         case IRP_MN_READ_CONFIG:
  630.             return "IRP_MN_READ_CONFIG";
  631.         case IRP_MN_WRITE_CONFIG:
  632.             return "IRP_MN_WRITE_CONFIG";
  633.         case IRP_MN_EJECT:
  634.             return "IRP_MN_EJECT";
  635.         case IRP_MN_SET_LOCK:
  636.             return "IRP_MN_SET_LOCK";
  637.         case IRP_MN_QUERY_ID:
  638.             return "IRP_MN_QUERY_ID";
  639.         case IRP_MN_QUERY_PNP_DEVICE_STATE:
  640.             return "IRP_MN_QUERY_PNP_DEVICE_STATE";
  641.         case IRP_MN_QUERY_BUS_INFORMATION:
  642.             return "IRP_MN_QUERY_BUS_INFORMATION";
  643.         case IRP_MN_DEVICE_USAGE_NOTIFICATION:
  644.             return "IRP_MN_DEVICE_USAGE_NOTIFICATION";
  645.         case IRP_MN_SURPRISE_REMOVAL:
  646.             return "IRP_MN_SURPRISE_REMOVAL";
  647.             
  648.         default:
  649.             return "IRP_MN_?????";
  650.     }
  651. }
  652. #endif