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

源码开发语言/平台
当前位置：首页 > 源码/资料 > Windows编程 > 驱动编程 > 查看源码
isodev.c
资源名称：isousb.rar　[点击查看]
上传用户：leituo004
上传日期：2014-11-03
资源大小：159k
文件大小：37k
源码类别：

驱动编程

开发平台：

Visual C++

isodev.c：源码内容
  1. /*++
  3. Copyright (c) 2000  Microsoft Corporation
  5. Module Name:
  7.     isodev.c
  9. Abstract:
  11.     This file contains dispatch routines 
  12.     for create and close. This file also 
  13.     contains routines to selectively suspend 
  14.     the device. The selective suspend feature
  15.     is usb specific and not hardware specific.
  17. Environment:
  19.     Kernel mode
  21. Notes:
  23.     Copyright (c) 2000 Microsoft Corporation.  
  24.     All Rights Reserved.
  26. --*/
  28. #include "isousb.h"
  29. #include "isopnp.h"
  30. #include "isopwr.h"
  31. #include "isodev.h"
  32. #include "isousr.h"
  33. #include "isowmi.h"
  34. #include "isorwr.h"
  35. #include "isostrm.h"
  37. NTSTATUS
  38. IsoUsb_DispatchCreate(
  39.     IN PDEVICE_OBJECT DeviceObject,
  40.     IN PIRP           Irp
  41.     )
  42. /*++
  43.  
  44. Routine Description:
  46.     Dispatch routine for create.
  48. Arguments:
  50.     DeviceObject - pointer to device object
  51.     Irp - I/O request packet.
  53. Return Value:
  55.     NT status value
  57. --*/
  58. {
  60.     LONG                        i;
  61.     NTSTATUS                    ntStatus;
  62.     PFILE_OBJECT                fileObject;
  63.     PDEVICE_EXTENSION           deviceExtension;
  64.     PIO_STACK_LOCATION          irpStack;
  65.     PFILE_OBJECT_CONTENT        fileObjectContent;
  66.     PUSBD_INTERFACE_INFORMATION interface;
  69.     i = 0;
  70.     irpStack = IoGetCurrentIrpStackLocation(Irp);
  71.     fileObject = irpStack->FileObject;
  72.     deviceExtension = (PDEVICE_EXTENSION) DeviceObject->DeviceExtension;
  74.     PAGED_CODE();
  76.     IsoUsb_DbgPrint(3, ("IsoUsb_DispatchCreate - beginsn"));
  78.     if(deviceExtension->DeviceState != Working) {
  80.         ntStatus = STATUS_INVALID_DEVICE_STATE;
  81.         goto IsoUsb_DispatchCreate_Exit;
  82.     }
  84.     if(deviceExtension->UsbInterface) {
  85.     
  86.         interface = deviceExtension->UsbInterface;    
  87.     }
  88.     else {
  90.         IsoUsb_DbgPrint(1, ("UsbInterface not foundn"));
  92.         ntStatus = STATUS_INVALID_DEVICE_STATE;
  93.         goto IsoUsb_DispatchCreate_Exit;
  94.     }
  96.     if(fileObject) {
  97.         
  98.         fileObject->FsContext = NULL;
  99.     }
  100.     else {
  102.         ntStatus = STATUS_INVALID_PARAMETER;
  103.         goto IsoUsb_DispatchCreate_Exit;
  104.     }
  106.     fileObject->FsContext = ExAllocatePool(NonPagedPool,
  107.                                            sizeof(FILE_OBJECT_CONTENT));
  109.     if(NULL == fileObject->FsContext) {
  111.         IsoUsb_DbgPrint(1, ("failed to alloc memory for FILE_OBJECT_CONTENTn"));
  113.         ntStatus = STATUS_INSUFFICIENT_RESOURCES;
  114.         goto IsoUsb_DispatchCreate_Exit;
  115.     }
  117.     fileObjectContent = (PFILE_OBJECT_CONTENT) fileObject->FsContext;
  118.     fileObjectContent->PipeInformation = NULL;
  119.     fileObjectContent->StreamInformation = NULL;
  121.     if(0 != fileObject->FileName.Length) {
  123.         i = IsoUsb_ParseStringForPipeNumber(&fileObject->FileName);
  125.         IsoUsb_DbgPrint(3, ("create request for pipe # %Xn", i));
  127.         if((i < 0) || 
  128.            (i >= (LONG)(deviceExtension->UsbInterface->NumberOfPipes))) {
  129.     
  130.             ntStatus = STATUS_INVALID_PARAMETER;
  132.             IsoUsb_DbgPrint(1, ("invalid pipe numbern"));
  133.             ExFreePool(fileObject->FsContext);
  134.             fileObject->FsContext = NULL;
  135.             goto IsoUsb_DispatchCreate_Exit;
  136.         }
  138.         fileObjectContent->PipeInformation = (PVOID) &interface->Pipes[i];
  139.     }
  141.     ntStatus = STATUS_SUCCESS;
  143.     InterlockedIncrement(&deviceExtension->OpenHandleCount);
  144.         
  145.     //
  146.     // the device is idle if it has no open handles or pending PnP Irps
  147.     // since we just received an open handle request, cancel idle req.
  148.     //
  149.     if(deviceExtension->SSEnable) {
  150.     
  151.         CancelSelectSuspend(deviceExtension);
  152.     }
  154. IsoUsb_DispatchCreate_Exit:
  156.     Irp->IoStatus.Status = ntStatus;
  157.     Irp->IoStatus.Information = 0;
  159.     IoCompleteRequest(Irp, IO_NO_INCREMENT);
  161.     IsoUsb_DbgPrint(3, ("IsoUsb_DispatchCreate - endsn"));
  162.     
  163.     return ntStatus;
  164. }
  166. NTSTATUS
  167. IsoUsb_DispatchClose(
  168.     IN PDEVICE_OBJECT DeviceObject,
  169.     IN PIRP           Irp
  170.     )
  171. /*++
  172.  
  173. Routine Description:
  175.     Dispatch routine for close.
  177. Arguments:
  179.     DeviceObject - pointer to device object
  180.     Irp - I/O request packet
  182. Return Value:
  184.     NT status value
  186. --*/
  187. {
  188.     NTSTATUS             ntStatus;
  189.     PFILE_OBJECT         fileObject;
  190.     PDEVICE_EXTENSION    deviceExtension;
  191.     PIO_STACK_LOCATION   irpStack;
  192.     PFILE_OBJECT_CONTENT fileObjectContent;
  193.     
  194.     PAGED_CODE();
  196.     //
  197.     // initialize variables
  198.     //
  199.     irpStack = IoGetCurrentIrpStackLocation(Irp);
  200.     fileObject = irpStack->FileObject;
  201.     deviceExtension = (PDEVICE_EXTENSION) DeviceObject->DeviceExtension;
  202.     
  203.     IsoUsb_DbgPrint(3, ("IsoUsb_DispatchClose - beginsn"));
  205.     if(fileObject && fileObject->FsContext) {
  207.         fileObjectContent = (PFILE_OBJECT_CONTENT) fileObject->FsContext;
  209.         ASSERT(NULL == fileObjectContent->StreamInformation);
  211.         ExFreePool(fileObjectContent);
  213.         fileObject->FsContext = NULL;
  214.     }
  216.     //
  217.     // set ntStatus to STATUS_SUCCESS 
  218.     //
  219.     ntStatus = STATUS_SUCCESS;
  221.     Irp->IoStatus.Status = ntStatus;
  222.     Irp->IoStatus.Information = 0;
  224.     IoCompleteRequest(Irp, IO_NO_INCREMENT);
  226.     InterlockedDecrement(&deviceExtension->OpenHandleCount);
  228.     IsoUsb_DbgPrint(3, ("IsoUsb_DispatchClose - endsn"));
  230.     return ntStatus;
  231. }
  233. NTSTATUS
  234. IsoUsb_DispatchDevCtrl(
  235.     IN PDEVICE_OBJECT DeviceObject,
  236.     IN PIRP Irp
  237.     )
  238. /*++
  239.  
  240. Routine Description:
  242.     Dispatch routine for IRP_MJ_DEVICE_CONTROL
  244. Arguments:
  246.     DeviceObject - pointer to device object
  247.     Irp - I/O request packet
  249. Return Value:
  251.     NT status value
  253. --*/
  254. {
  255.     ULONG              code;
  256.     PVOID              ioBuffer;
  257.     ULONG              inputBufferLength;
  258.     ULONG              outputBufferLength;
  259.     ULONG              info;
  260.     NTSTATUS           ntStatus;
  261.     PFILE_OBJECT       fileObject;
  262.     PDEVICE_EXTENSION  deviceExtension;
  263.     PIO_STACK_LOCATION irpStack;
  265.     //
  266.     // initialize variables
  267.     //
  268.     info = 0;
  269.     irpStack = IoGetCurrentIrpStackLocation(Irp);
  270.     fileObject = irpStack->FileObject;
  271.     code = irpStack->Parameters.DeviceIoControl.IoControlCode;
  272.     deviceExtension = (PDEVICE_EXTENSION) DeviceObject->DeviceExtension;
  274.     ioBuffer           = Irp->AssociatedIrp.SystemBuffer;
  275.     inputBufferLength  = irpStack->Parameters.DeviceIoControl.InputBufferLength;
  276.     outputBufferLength = irpStack->Parameters.DeviceIoControl.OutputBufferLength;
  278.     if(deviceExtension->DeviceState != Working) {
  280.         IsoUsb_DbgPrint(1, ("Invalid device staten"));
  282.         Irp->IoStatus.Status = ntStatus = STATUS_INVALID_DEVICE_STATE;
  283.         Irp->IoStatus.Information = info;
  285.         IoCompleteRequest(Irp, IO_NO_INCREMENT);
  286.         return ntStatus;
  287.     }
  289.     IsoUsb_DbgPrint(3, ("IsoUsb_DispatchDevCtrl::"));
  290.     IsoUsb_IoIncrement(deviceExtension);
  292.     //
  293.     // make sure that the selective suspend request has been completed.
  294.     //
  295.     if(deviceExtension->SSEnable) {
  297.         //
  298.         // It is true that the client driver cancelled the selective suspend
  299.         // request in the dispatch routine for create.
  300.         // But there is no guarantee that it has indeed been completed.
  301.         // so wait on the NoIdleReqPendEvent and proceed only if this event
  302.         // is signalled.
  303.         //
  304.         IsoUsb_DbgPrint(3, ("Waiting on the IdleReqPendEventn"));
  305.         
  306.         KeWaitForSingleObject(&deviceExtension->NoIdleReqPendEvent, 
  307.                               Executive, 
  308.                               KernelMode, 
  309.                               FALSE, 
  310.                               NULL);
  311.     }
  313.     switch(code) {
  315.     case IOCTL_ISOUSB_RESET_PIPE:
  316.     {
  317.         PUSBD_PIPE_INFORMATION pipe;
  319.         pipe = NULL;
  321.         if(fileObject && fileObject->FsContext) {
  322.             
  323.             pipe = (PUSBD_PIPE_INFORMATION)
  324.                    ((PFILE_OBJECT_CONTENT)fileObject->FsContext)->PipeInformation;
  325.         }
  327.         if(pipe == NULL) {
  329.             ntStatus = STATUS_INVALID_PARAMETER;
  330.         }
  331.         else {
  332.             
  333.             ntStatus = IsoUsb_ResetPipe(DeviceObject, pipe);
  334.         }
  336.         break;
  337.     }
  339.     case IOCTL_ISOUSB_GET_CONFIG_DESCRIPTOR:
  340.     {
  341.         ULONG length;
  343.         if(deviceExtension->UsbConfigurationDescriptor) {
  345.             length = deviceExtension->UsbConfigurationDescriptor->wTotalLength;
  347.             if(outputBufferLength >= length) {
  349.                 RtlCopyMemory(ioBuffer,
  350.                               deviceExtension->UsbConfigurationDescriptor,
  351.                               length);
  353.                 info = length;
  355.                 ntStatus = STATUS_SUCCESS;
  356.             }
  357.             else {
  358.                 
  359.                 ntStatus = STATUS_INVALID_BUFFER_SIZE;
  360.             }
  361.         }
  362.         else {
  363.             
  364.             ntStatus = STATUS_UNSUCCESSFUL;
  365.         }
  367.         break;
  368.     }
  370.     case IOCTL_ISOUSB_RESET_DEVICE:
  371.         
  372.         ntStatus = IsoUsb_ResetDevice(DeviceObject);
  374.         break;
  376.     case IOCTL_ISOUSB_START_ISO_STREAM:
  378.         ntStatus = IsoUsb_StartIsoStream(DeviceObject, Irp);
  380.         return STATUS_SUCCESS;
  382.     case IOCTL_ISOUSB_STOP_ISO_STREAM:
  383.     {
  384.            
  385.         PFILE_OBJECT_CONTENT fileObjectContent;
  386.         
  387.         if(fileObject && fileObject->FsContext) {
  389.             fileObjectContent = (PFILE_OBJECT_CONTENT)
  390.                                 fileObject->FsContext;
  392.             ntStatus = IsoUsb_StopIsoStream(
  393.                             DeviceObject,
  394.                             InterlockedExchangePointer(
  395.                                 &fileObjectContent->StreamInformation,
  396.                                 NULL),
  397.                             Irp);
  398.         }
  399.         else {
  401.             ntStatus = STATUS_UNSUCCESSFUL;
  402.         }
  404.         break;
  405.     }
  407.     default :
  409.         ntStatus = STATUS_INVALID_DEVICE_REQUEST;
  411.         break;
  412.     }
  414.     Irp->IoStatus.Status = ntStatus;
  415.     Irp->IoStatus.Information = info;
  417.     IoCompleteRequest(Irp, IO_NO_INCREMENT);
  419.     IsoUsb_DbgPrint(3, ("IsoUsb_DispatchDevCtrl::"));
  420.     IsoUsb_IoDecrement(deviceExtension);
  422.     return ntStatus;
  423. }
  425. LONG
  426. IsoUsb_ParseStringForPipeNumber(
  427.     IN PUNICODE_STRING PipeName
  428.     )
  429. /*++
  430.  
  431. Routine Description:
  433.     This routine parses the PipeName for the Pipe#
  435. Arguments:
  437.     PipeName - Unicode string for the pipe name
  439. Return Value:
  441.     Pipe number
  443. --*/
  444. {
  445.     LONG  bufferIndex;
  446.     ULONG uval;
  447.     ULONG umultiplier;
  449.     if(PipeName->Length == 0) {
  451.         return -1;
  452.     }
  454.     bufferIndex = (PipeName->Length / sizeof(WCHAR)) - 1;
  456.     while((bufferIndex > -1) && 
  457.           ((PipeName->Buffer[bufferIndex] < (WCHAR) '0')  ||
  458.            (PipeName->Buffer[bufferIndex] > (WCHAR) '9')))           {
  459.         
  460.         bufferIndex--;
  461.     }
  463.     if(bufferIndex > -1) {
  465.         uval = 0;
  466.         umultiplier = 1;
  468.         while((bufferIndex > -1) &&
  469.               (PipeName->Buffer[bufferIndex] >= (WCHAR) '0') &&
  470.               (PipeName->Buffer[bufferIndex] <= (WCHAR) '9'))        {
  472.             uval += (umultiplier *
  473.                      (ULONG) (PipeName->Buffer[bufferIndex] - (WCHAR) '0'));
  474.             bufferIndex--;
  475.             umultiplier *= 10;
  476.         }
  478.         return uval;
  479.     }
  481.     return -1;
  482. }
  484. NTSTATUS
  485. IsoUsb_ResetPipe(
  486.     IN PDEVICE_OBJECT         DeviceObject,
  487.     IN PUSBD_PIPE_INFORMATION PipeInfo
  488.     )
  489. /*++
  490.  
  491. Routine Description:
  493.     This routine submits an irp/urb pair synchronously
  494.     with function code URB_FUNCTION_RESET_PIPE to reset
  495.     the pipe
  497. Arguments:
  499.     DeviceObject - pointer to device object
  500.     PipeInfo - pointer to USBD_PIPE_INFORMATION
  502. Return Value:
  504.     NT status value
  506. --*/
  507. {
  508.     PURB              urb;
  509.     NTSTATUS          ntStatus;
  510.     USBD_STATUS       usbdStatus;
  511.     PDEVICE_EXTENSION deviceExtension;
  513.     //
  514.     // initialize variables
  515.     //
  517.     urb = NULL;
  518.     deviceExtension = (PDEVICE_EXTENSION) DeviceObject->DeviceExtension;
  521.     urb = ExAllocatePool(NonPagedPool, 
  522.                          sizeof(struct _URB_PIPE_REQUEST));
  524.     if(urb) {
  526.         urb->UrbHeader.Length = (USHORT) sizeof(struct _URB_PIPE_REQUEST);
  527.         urb->UrbHeader.Function = URB_FUNCTION_RESET_PIPE;
  528.         urb->UrbPipeRequest.PipeHandle = PipeInfo->PipeHandle;
  530.         ntStatus = CallUSBD(DeviceObject, urb);
  532.         usbdStatus = urb->UrbHeader.Status;
  534.         ExFreePool(urb);
  535.     }
  536.     else {
  538.         ntStatus = STATUS_INSUFFICIENT_RESOURCES;
  539.     }
  541.     if(NT_SUCCESS(ntStatus) &&
  542.        USBD_SUCCESS(usbdStatus)) {
  543.     
  544.         IsoUsb_DbgPrint(3, ("IsoUsb_ResetPipe - successn"));
  545.         ntStatus = STATUS_SUCCESS;
  546.     }
  547.     else {
  549.         IsoUsb_DbgPrint(1, ("IsoUsb_ResetPipe - failed with "
  550.                             "Irp status = %X and Urb status = %Xn",
  551.                             ntStatus,
  552.                             usbdStatus));
  553.     }
  555.     return ntStatus;
  556. }
  558. NTSTATUS
  559. IsoUsb_ResetDevice(
  560.     IN PDEVICE_OBJECT DeviceObject
  561.     )
  562. /*++
  563.  
  564. Routine Description:
  566.     This routine resets the device
  568. Arguments:
  570.     DeviceObject - pointer to device object
  572. Return Value:
  574.     NT status value
  576. --*/
  577. {
  578.     NTSTATUS ntStatus;
  579.     ULONG    portStatus;
  581.     IsoUsb_DbgPrint(3, ("IsoUsb_ResetDevice - beginsn"));
  583.     ntStatus = IsoUsb_GetPortStatus(DeviceObject, &portStatus);
  585.     if((NT_SUCCESS(ntStatus))                 &&
  586.        (!(portStatus & USBD_PORT_ENABLED))    &&
  587.        (portStatus & USBD_PORT_CONNECTED)) {
  589.         ntStatus = IsoUsb_ResetParentPort(DeviceObject);
  590.     }
  592.     IsoUsb_DbgPrint(3, ("IsoUsb_ResetDevice - endsn"));
  594.     return ntStatus;
  595. }
  597. NTSTATUS
  598. IsoUsb_GetPortStatus(
  599.     IN PDEVICE_OBJECT DeviceObject,
  600.     IN OUT PULONG     PortStatus
  601.     )
  602. /*++
  603.  
  604. Routine Description:
  606.     This routine fetches the port status value
  608. Arguments:
  610.     DeviceObject - pointer to device object
  611.     PortStatus - pointer to ULONG to contain the status value
  613. Return Value:
  615.     NT status value
  617. --*/
  618. {
  619.     NTSTATUS           ntStatus;
  620.     KEVENT             event;
  621.     PIRP               irp;
  622.     IO_STATUS_BLOCK    ioStatus;
  623.     PIO_STACK_LOCATION nextStack;
  624.     PDEVICE_EXTENSION  deviceExtension;
  626.     //
  627.     // initialize variables
  628.     //
  629.     deviceExtension = (PDEVICE_EXTENSION) DeviceObject->DeviceExtension;
  630.     *PortStatus = 0;
  632.     IsoUsb_DbgPrint(3, ("IsoUsb_GetPortStatus - beginsn"));
  634.     KeInitializeEvent(&event, NotificationEvent, FALSE);
  636.     irp = IoBuildDeviceIoControlRequest(
  637.                     IOCTL_INTERNAL_USB_GET_PORT_STATUS,
  638.                     deviceExtension->TopOfStackDeviceObject,
  639.                     NULL,
  640.                     0,
  641.                     NULL,
  642.                     0,
  643.                     TRUE,
  644.                     &event,
  645.                     &ioStatus);
  647.     if(NULL == irp) {
  649.         IsoUsb_DbgPrint(1, ("memory alloc for irp failedn"));
  650.         return STATUS_INSUFFICIENT_RESOURCES;
  651.     }
  653.     nextStack = IoGetNextIrpStackLocation(irp);
  655.     ASSERT(nextStack != NULL);
  657.     nextStack->Parameters.Others.Argument1 = PortStatus;
  659.     IsoUsb_DbgPrint(3, ("IsoUsb_GetPortStatus::"));
  660.     IsoUsb_IoIncrement(deviceExtension);
  662.     ntStatus = IoCallDriver(deviceExtension->TopOfStackDeviceObject, irp);
  664.     if(STATUS_PENDING == ntStatus) {
  666.         KeWaitForSingleObject(&event, Executive, KernelMode, FALSE, NULL);
  667.     }
  668.     else {
  670.         ioStatus.Status = ntStatus;
  671.     }
  673.     IsoUsb_DbgPrint(3, ("IsoUsb_GetPortStatus::"));
  674.     IsoUsb_IoDecrement(deviceExtension);
  676.     ntStatus = ioStatus.Status;
  678.     IsoUsb_DbgPrint(3, ("IsoUsb_GetPortStatus - endsn"));
  680.     return ntStatus;
  681. }
  683. NTSTATUS
  684. IsoUsb_ResetParentPort(
  685.     IN PDEVICE_OBJECT DeviceObject
  686.     )
  687. /*++
  688.  
  689. Routine Description:
  691.     This routine will submit an IOCTL_INTERNAL_USB_RESET_PORT,
  692.     down the stack
  694. Arguments:
  696.     DeviceObject - pointer to device object
  698. Return Value:
  700.     NT status value
  702. --*/
  703. {
  704.     NTSTATUS           ntStatus;
  705.     KEVENT             event;
  706.     PIRP               irp;
  707.     IO_STATUS_BLOCK    ioStatus;
  708.     PIO_STACK_LOCATION nextStack;
  709.     PDEVICE_EXTENSION  deviceExtension;
  711.     //
  712.     // initialize variables
  713.     //
  714.     deviceExtension = (PDEVICE_EXTENSION) DeviceObject->DeviceExtension;
  716.     IsoUsb_DbgPrint(3, ("IsoUsb_ResetParentPort - beginsn"));
  718.     KeInitializeEvent(&event, NotificationEvent, FALSE);
  720.     irp = IoBuildDeviceIoControlRequest(
  721.                     IOCTL_INTERNAL_USB_RESET_PORT,
  722.                     deviceExtension->TopOfStackDeviceObject,
  723.                     NULL,
  724.                     0,
  725.                     NULL,
  726.                     0,
  727.                     TRUE,
  728.                     &event,
  729.                     &ioStatus);
  731.     if(NULL == irp) {
  733.         IsoUsb_DbgPrint(1, ("memory alloc for irp failedn"));
  734.         return STATUS_INSUFFICIENT_RESOURCES;
  735.     }
  737.     nextStack = IoGetNextIrpStackLocation(irp);
  739.     ASSERT(nextStack != NULL);
  741.     IsoUsb_DbgPrint(3, ("IsoUsb_ResetParentPort"));
  742.     IsoUsb_IoIncrement(deviceExtension);
  744.     ntStatus = IoCallDriver(deviceExtension->TopOfStackDeviceObject, irp);
  746.     if(STATUS_PENDING == ntStatus) {
  748.         KeWaitForSingleObject(&event, Executive, KernelMode, FALSE, NULL);
  749.     }
  750.     else {
  752.         ioStatus.Status = ntStatus;
  753.     }
  755.     IsoUsb_DbgPrint(3, ("IsoUsb_ResetParentPort"));
  756.     IsoUsb_IoDecrement(deviceExtension);
  758.     ntStatus = ioStatus.Status;
  760.     IsoUsb_DbgPrint(3, ("IsoUsb_ResetParentPort - endsn"));
  762.     return ntStatus;
  763. }
  766. NTSTATUS
  767. SubmitIdleRequestIrp(
  768.     IN PDEVICE_EXTENSION DeviceExtension
  769.     )
  770. /*++
  771.  
  772. Routine Description:
  774.     This routine builds an idle request irp with an associated callback routine
  775.     and a completion routine in the driver and passes the irp down the stack.
  777. Arguments:
  779.     DeviceExtension - pointer to device extension
  781. Return Value:
  783.     NT status value
  785. --*/
  786. {
  787.     PIRP                    irp;
  788.     NTSTATUS                ntStatus;
  789.     KIRQL                   oldIrql;
  790.     PUSB_IDLE_CALLBACK_INFO idleCallbackInfo;
  791.     PIO_STACK_LOCATION      nextStack;
  793.     //
  794.     // initialize variables
  795.     //
  796.     
  797.     irp = NULL;
  798.     idleCallbackInfo = NULL;
  800.     IsoUsb_DbgPrint(3, ("SubmitIdleRequest - beginsn"));
  802.     ASSERT(KeGetCurrentIrql() == PASSIVE_LEVEL);
  804.     if(PowerDeviceD0 != DeviceExtension->DevPower) {
  806.         ntStatus = STATUS_POWER_STATE_INVALID;
  807.         goto SubmitIdleRequestIrp_Exit;
  808.     }
  810.     KeAcquireSpinLock(&DeviceExtension->IdleReqStateLock, &oldIrql);
  812.     if(InterlockedExchange(&DeviceExtension->IdleReqPend, 1)) {
  814.         IsoUsb_DbgPrint(1, ("Idle request pending..n"));
  816.         KeReleaseSpinLock(&DeviceExtension->IdleReqStateLock, oldIrql);
  818.         ntStatus = STATUS_DEVICE_BUSY;
  820.         goto SubmitIdleRequestIrp_Exit;
  821.     }
  823.     //
  824.     // clear the NoIdleReqPendEvent because we are about 
  825.     // to submit an idle request. Since we are so early
  826.     // to clear this event, make sure that if we fail this
  827.     // request we set back the event.
  828.     //
  829.     KeClearEvent(&DeviceExtension->NoIdleReqPendEvent);
  831.     idleCallbackInfo = ExAllocatePool(NonPagedPool, 
  832.                                       sizeof(struct _USB_IDLE_CALLBACK_INFO));
  834.     if(idleCallbackInfo) {
  836.         idleCallbackInfo->IdleCallback = IdleNotificationCallback;
  838.         idleCallbackInfo->IdleContext = (PVOID)DeviceExtension;
  840.         ASSERT(DeviceExtension->IdleCallbackInfo == NULL);
  842.         DeviceExtension->IdleCallbackInfo = idleCallbackInfo;
  843.         //
  844.         // we use IoAllocateIrp to create an irp to selectively suspend the 
  845.         // device. This irp lies pending with the hub driver. When appropriate
  846.         // the hub driver will invoked callback, where we power down. The completion
  847.         // routine is invoked when we power back.
  848.         //
  849.         irp = IoAllocateIrp(DeviceExtension->TopOfStackDeviceObject->StackSize,
  850.                             FALSE);
  852.         if(irp == NULL) {
  854.             IsoUsb_DbgPrint(1, ("cannot build idle request irpn"));
  856.             KeSetEvent(&DeviceExtension->NoIdleReqPendEvent,
  857.                        IO_NO_INCREMENT,
  858.                        FALSE);
  860.             InterlockedExchange(&DeviceExtension->IdleReqPend, 0);
  862.             KeReleaseSpinLock(&DeviceExtension->IdleReqStateLock, oldIrql);
  864.             ExFreePool(idleCallbackInfo);
  866.             ntStatus = STATUS_INSUFFICIENT_RESOURCES;
  868.             goto SubmitIdleRequestIrp_Exit;
  869.         }
  871.         nextStack = IoGetNextIrpStackLocation(irp);
  873.         nextStack->MajorFunction = 
  874.                     IRP_MJ_INTERNAL_DEVICE_CONTROL;
  876.         nextStack->Parameters.DeviceIoControl.IoControlCode = 
  877.                     IOCTL_INTERNAL_USB_SUBMIT_IDLE_NOTIFICATION;
  879.         nextStack->Parameters.DeviceIoControl.Type3InputBuffer =
  880.                     idleCallbackInfo;
  882.         nextStack->Parameters.DeviceIoControl.InputBufferLength =
  883.                     sizeof(struct _USB_IDLE_CALLBACK_INFO);
  886.         IoSetCompletionRoutine(irp, 
  887.                                IdleNotificationRequestComplete,
  888.                                DeviceExtension, 
  889.                                TRUE, 
  890.                                TRUE, 
  891.                                TRUE);
  893.         DeviceExtension->PendingIdleIrp = irp;
  894.         //
  895.         // we initialize the count to 2.
  896.         // The reason is, if the CancelSelectSuspend routine manages
  897.         // to grab the irp from the device extension, then the last of the
  898.         // CancelSelectSuspend routine/IdleNotificationRequestComplete routine 
  899.         // to execute will free this irp. We need to have this schema so that
  900.         // 1. completion routine does not attempt to touch the irp freed by 
  901.         //    CancelSelectSuspend routine.
  902.         // 2. CancelSelectSuspend routine doesnt wait for ever for the completion
  903.         //    routine to complete!
  904.         //
  905.         DeviceExtension->FreeIdleIrpCount = 2;
  907.         KeReleaseSpinLock(&DeviceExtension->IdleReqStateLock, oldIrql);
  909.         //
  910.         // check if the device is idle.
  911.         // A check here ensures that a race condition did not 
  912.         // completely reverse the call sequence of SubmitIdleRequestIrp
  913.         // and CancelSelectiveSuspend
  914.         //
  916.         if(!CanDeviceSuspend(DeviceExtension) ||
  917.            PowerDeviceD0 != DeviceExtension->DevPower) {
  919.             //
  920.             // device cannot suspend - abort.
  921.             // also irps created using IoAllocateIrp 
  922.             // needs to be deallocated.
  923.             //
  924.      
  925.             IsoUsb_DbgPrint(1, ("Device is not idlen"));
  927.             KeAcquireSpinLock(&DeviceExtension->IdleReqStateLock, &oldIrql);
  929.             DeviceExtension->IdleCallbackInfo = NULL;
  931.             DeviceExtension->PendingIdleIrp = NULL;
  933.             KeSetEvent(&DeviceExtension->NoIdleReqPendEvent,
  934.                        IO_NO_INCREMENT,
  935.                        FALSE);
  937.             InterlockedExchange(&DeviceExtension->IdleReqPend, 0);
  939.             KeReleaseSpinLock(&DeviceExtension->IdleReqStateLock, oldIrql);
  941.             if(idleCallbackInfo) {
  943.                 ExFreePool(idleCallbackInfo);
  944.             }
  946.             //
  947.             // it is still safe to touch the local variable "irp" here.
  948.             // the irp has not been passed down the stack, the irp has
  949.             // no cancellation routine. The worse position is that the
  950.             // CancelSelectSuspend has run after we released the spin 
  951.             // lock above. It is still essential to free the irp.
  952.             //
  954.             if(irp) {
  955.             
  956.                 IoFreeIrp(irp);
  957.             }
  959.             goto SubmitIdleRequestIrp_Exit;
  960.         }
  962.         IsoUsb_DbgPrint(3, ("Cancel the timersn"));
  964.         //
  965.         // Cancel the timer so that the DPCs are no longer fired.
  966.         // Thus, we are making judicious usage of our resources.
  967.         // we do not need DPCs because we already have an idle irp pending.
  968.         // The timers are re-initialized in the completion routine.
  969.         //
  970.         KeCancelTimer(&DeviceExtension->Timer);
  972.         ntStatus = IoCallDriver(DeviceExtension->TopOfStackDeviceObject, irp);
  974.         if(!NT_SUCCESS(ntStatus)) {
  976.             IsoUsb_DbgPrint(1, ("IoCallDriver failedn"));
  978.             goto SubmitIdleRequestIrp_Exit;
  979.         }
  980.     }
  981.     else {
  983.         IsoUsb_DbgPrint(1, ("Memory allocation for idleCallbackInfo failedn"));
  985.         KeSetEvent(&DeviceExtension->NoIdleReqPendEvent,
  986.                    IO_NO_INCREMENT,
  987.                    FALSE);
  989.         InterlockedExchange(&DeviceExtension->IdleReqPend, 0);
  991.         KeReleaseSpinLock(&DeviceExtension->IdleReqStateLock, oldIrql);
  993.         ntStatus = STATUS_INSUFFICIENT_RESOURCES;
  994.     }
  996. SubmitIdleRequestIrp_Exit:
  998.     IsoUsb_DbgPrint(3, ("SubmitIdleRequest - endsn"));
  1000.     return ntStatus;
  1001. }
  1004. VOID
  1005. IdleNotificationCallback(
  1006.     IN PDEVICE_EXTENSION DeviceExtension
  1007.     )
  1008. /*++
  1009.  
  1010. Routine Description:
  1012.   "A pointer to a callback function in your driver is passed down the stack with
  1013.    this IOCTL, and it is this callback function that is called by USBHUB when it
  1014.    safe for your device to power down."
  1016.   "When the callback in your driver is called, all you really need to do is to
  1017.    to first ensure that a WaitWake Irp has been submitted for your device, if 
  1018.    remote wake is possible for your device and then request a SetD2 (or DeviceWake)"
  1020. Arguments:
  1022. Return Value:
  1024. --*/
  1025. {
  1026.     NTSTATUS                ntStatus;
  1027.     POWER_STATE             powerState;
  1028.     KEVENT                  irpCompletionEvent;
  1029.     PIRP_COMPLETION_CONTEXT irpContext;
  1031.     IsoUsb_DbgPrint(3, ("IdleNotificationCallback - beginsn"));
  1033.     //
  1034.     // Dont idle, if the device was just disconnected or being stopped
  1035.     // i.e. return for the following DeviceState(s)
  1036.     // NotStarted, Stopped, PendingStop, PendingRemove, SurpriseRemoved, Removed
  1037.     //
  1039.     if(DeviceExtension->DeviceState != Working) {
  1041.         return;
  1042.     }
  1044.     //
  1045.     // If there is not already a WW IRP pending, submit one now
  1046.     //
  1047.     if(DeviceExtension->WaitWakeEnable) {
  1049.         IssueWaitWake(DeviceExtension);
  1050.     }
  1053.     //
  1054.     // power down the device
  1055.     //
  1057.     irpContext = (PIRP_COMPLETION_CONTEXT) 
  1058.                  ExAllocatePool(NonPagedPool,
  1059.                                 sizeof(IRP_COMPLETION_CONTEXT));
  1061.     if(!irpContext) {
  1063.         IsoUsb_DbgPrint(1, ("Failed to alloc memory for irpContextn"));
  1064.         ntStatus = STATUS_INSUFFICIENT_RESOURCES;
  1065.     }
  1066.     else {
  1068.         //
  1069.         // increment the count. In the HoldIoRequestWorkerRoutine, the
  1070.         // count is decremented twice (one for the system Irp and the 
  1071.         // other for the device Irp. An increment here compensates for 
  1072.         // the sytem irp..The decrement corresponding to this increment 
  1073.         // is in the completion function
  1074.         //
  1076.         IsoUsb_DbgPrint(3, ("IdleNotificationCallback::"));
  1077.         IsoUsb_IoIncrement(DeviceExtension);
  1079.         powerState.DeviceState = DeviceExtension->PowerDownLevel;
  1081.         KeInitializeEvent(&irpCompletionEvent, NotificationEvent, FALSE);
  1083.         irpContext->DeviceExtension = DeviceExtension;
  1084.         irpContext->Event = &irpCompletionEvent;
  1086.         ntStatus = PoRequestPowerIrp(
  1087.                           DeviceExtension->PhysicalDeviceObject, 
  1088.                           IRP_MN_SET_POWER, 
  1089.                           powerState, 
  1090.                           (PREQUEST_POWER_COMPLETE) PoIrpCompletionFunc,
  1091.                           irpContext, 
  1092.                           NULL);
  1094.         if(STATUS_PENDING == ntStatus) {
  1096.             IsoUsb_DbgPrint(3, ("IdleNotificationCallback::"
  1097.                            "waiting for the power irp to completen"));
  1099.             KeWaitForSingleObject(&irpCompletionEvent,
  1100.                                   Executive,
  1101.                                   KernelMode,
  1102.                                   FALSE,
  1103.                                   NULL);
  1104.         }
  1105.     }
  1106.     
  1107.     if(!NT_SUCCESS(ntStatus)) {
  1109.         if(irpContext) {
  1111.             ExFreePool(irpContext);
  1112.         }
  1113.     }
  1115.     IsoUsb_DbgPrint(3, ("IdleNotificationCallback - endsn"));
  1116. }
  1119. NTSTATUS
  1120. IdleNotificationRequestComplete(
  1121.     IN PDEVICE_OBJECT    DeviceObject,
  1122.     IN PIRP              Irp,
  1123.     IN PDEVICE_EXTENSION DeviceExtension
  1124.     )
  1125. /*++
  1126.  
  1127. Routine Description:
  1129.   Completion routine for idle notification irp
  1131. Arguments:
  1133.     DeviceObject - pointer to device object
  1134.     Irp - I/O request packet
  1135.     DeviceExtension - pointer to device extension
  1137. Return Value:
  1139.     NT status value
  1141. --*/
  1142. {
  1143.     NTSTATUS                ntStatus;
  1144.     POWER_STATE             powerState;
  1145.     KIRQL                   oldIrql;
  1146.     PIRP                    idleIrp;
  1147.     LARGE_INTEGER           dueTime;
  1148.     PUSB_IDLE_CALLBACK_INFO idleCallbackInfo;
  1150.     IsoUsb_DbgPrint(3, ("IdleNotificationRequestCompete - beginsn"));
  1152.     idleIrp = NULL;
  1154.     //
  1155.     // check the Irp status
  1156.     //
  1158.     ntStatus = Irp->IoStatus.Status;
  1160.     if(!NT_SUCCESS(ntStatus) && ntStatus != STATUS_NOT_SUPPORTED) {
  1162.         IsoUsb_DbgPrint(1, ("Idle irp completes with error::"));
  1164.         switch(ntStatus) {
  1165.             
  1166.         case STATUS_INVALID_DEVICE_REQUEST:
  1168.             IsoUsb_DbgPrint(1, ("STATUS_INVALID_DEVICE_REQUESTn"));
  1170.             break;
  1172.         case STATUS_CANCELLED:
  1174.             IsoUsb_DbgPrint(1, ("STATUS_CANCELLEDn"));
  1176.             break;
  1178.         case STATUS_POWER_STATE_INVALID:
  1180.             IsoUsb_DbgPrint(1, ("STATUS_POWER_STATE_INVALIDn"));
  1182.             goto IdleNotificationRequestComplete_Exit;
  1184.         case STATUS_DEVICE_BUSY:
  1186.             IsoUsb_DbgPrint(1, ("STATUS_DEVICE_BUSYn"));
  1188.             break;
  1190.         default:
  1192.             IsoUsb_DbgPrint(1, ("defaultn"));
  1194.             break;
  1195.         }
  1197.         //
  1198.         // if in error, issue a SetD0
  1199.         //
  1201.         IsoUsb_DbgPrint(3, ("IdleNotificationRequestComplete::"));
  1202.         IsoUsb_IoIncrement(DeviceExtension);
  1204.         powerState.DeviceState = PowerDeviceD0;
  1206.         ntStatus = PoRequestPowerIrp(
  1207.                           DeviceExtension->PhysicalDeviceObject, 
  1208.                           IRP_MN_SET_POWER, 
  1209.                           powerState, 
  1210.                           (PREQUEST_POWER_COMPLETE) PoIrpAsyncCompletionFunc, 
  1211.                           DeviceExtension, 
  1212.                           NULL);
  1214.         if(!NT_SUCCESS(ntStatus)) {
  1215.     
  1216.             IsoUsb_DbgPrint(1, ("PoRequestPowerIrp failedn"));
  1217.         }
  1219.     }
  1221. IdleNotificationRequestComplete_Exit:
  1223.     KeAcquireSpinLock(&DeviceExtension->IdleReqStateLock, &oldIrql);
  1225.     idleCallbackInfo = DeviceExtension->IdleCallbackInfo;
  1227.     DeviceExtension->IdleCallbackInfo = NULL;
  1229.     idleIrp = (PIRP) InterlockedExchangePointer(
  1230.                                         &DeviceExtension->PendingIdleIrp,
  1231.                                         NULL);
  1233.     InterlockedExchange(&DeviceExtension->IdleReqPend, 0);
  1235.     KeReleaseSpinLock(&DeviceExtension->IdleReqStateLock, oldIrql);
  1237.     if(idleCallbackInfo) {
  1239.         ExFreePool(idleCallbackInfo);
  1240.     }
  1242.     //
  1243.     // since we allocated the irp, we need to free it.
  1244.     // return STATUS_MORE_PROCESSING_REQUIRED so that 
  1245.     // the kernel does not touch it.
  1246.     //
  1248.     if(idleIrp) {
  1250.         IsoUsb_DbgPrint(3, ("completion routine has a valid irp and frees itn"));
  1252.         IoFreeIrp(Irp);
  1254.         KeSetEvent(&DeviceExtension->NoIdleReqPendEvent,
  1255.                    IO_NO_INCREMENT,
  1256.                    FALSE);
  1257.     }
  1258.     else {
  1260.         //
  1261.         // The CancelSelectiveSuspend routine has grabbed the Irp from the device 
  1262.         // extension. Now the last one to decrement the FreeIdleIrpCount should
  1263.         // free the irp.
  1264.         //
  1265.         if(0 == InterlockedDecrement(&DeviceExtension->FreeIdleIrpCount)) {
  1267.             IsoUsb_DbgPrint(3, ("completion routine frees the irpn"));
  1268.             
  1269.             IoFreeIrp(Irp);
  1271.             KeSetEvent(&DeviceExtension->NoIdleReqPendEvent,
  1272.                        IO_NO_INCREMENT,
  1273.                        FALSE);
  1274.         }
  1275.     }
  1277.     if(DeviceExtension->SSEnable) {
  1279.         IsoUsb_DbgPrint(3, ("Set the timer to fire DPCsn"));
  1281.         dueTime.QuadPart = -10000 * IDLE_INTERVAL;               // 5000 ms
  1283.         KeSetTimerEx(&DeviceExtension->Timer, 
  1284.                      dueTime,
  1285.                      IDLE_INTERVAL,                              // 5000 ms
  1286.                      &DeviceExtension->DeferredProcCall);
  1288.         IsoUsb_DbgPrint(3, ("IdleNotificationRequestCompete - endsn"));
  1289.     }
  1291.     return STATUS_MORE_PROCESSING_REQUIRED;
  1292. }
  1294. VOID
  1295. CancelSelectSuspend(
  1296.     IN PDEVICE_EXTENSION DeviceExtension
  1297.     )
  1298. /*++
  1299.  
  1300. Routine Description:
  1302.     This routine is invoked to cancel selective suspend request.
  1304. Arguments:
  1306.     DeviceExtension - pointer to device extension
  1308. Return Value:
  1310.     None.
  1312. --*/
  1313. {
  1314.     PIRP  irp;
  1315.     KIRQL oldIrql;
  1317.     irp = NULL;
  1319.     IsoUsb_DbgPrint(3, ("CancelSelectSuspend - beginsn"));
  1321.     KeAcquireSpinLock(&DeviceExtension->IdleReqStateLock, &oldIrql);
  1323.     if(!CanDeviceSuspend(DeviceExtension))
  1324.     {
  1325.         IsoUsb_DbgPrint(3, ("Device is not idlen"));
  1326.     
  1327.         irp = (PIRP) InterlockedExchangePointer(
  1328.                             &DeviceExtension->PendingIdleIrp, 
  1329.                             NULL);
  1330.     }
  1332.     KeReleaseSpinLock(&DeviceExtension->IdleReqStateLock, oldIrql);
  1334.     //
  1335.     // since we have a valid Irp ptr,
  1336.     // we can call IoCancelIrp on it,
  1337.     // without the fear of the irp 
  1338.     // being freed underneath us.
  1339.     //
  1340.     if(irp) {
  1342.         //
  1343.         // This routine has the irp pointer.
  1344.         // It is safe to call IoCancelIrp because we know that
  1345.         // the compleiton routine will not free this irp unless...
  1346.         // 
  1347.         
  1348.         if(IoCancelIrp(irp)) {
  1350.             IsoUsb_DbgPrint(3, ("IoCancelIrp returns TRUEn"));
  1351.         }
  1352.         else {
  1353.             IsoUsb_DbgPrint(3, ("IoCancelIrp returns FALSEn"));
  1354.         }
  1356.         //
  1357.         // ....we decrement the FreeIdleIrpCount from 2 to 1.
  1358.         // if completion routine runs ahead of us, then this routine 
  1359.         // decrements the FreeIdleIrpCount from 1 to 0 and hence shall
  1360.         // free the irp.
  1361.         //
  1363.         if(0 == InterlockedDecrement(&DeviceExtension->FreeIdleIrpCount)) {
  1365.             IsoUsb_DbgPrint(3, ("CancelSelectSuspend frees the irpn"));
  1366.             
  1367.             IoFreeIrp(irp);
  1369.             KeSetEvent(&DeviceExtension->NoIdleReqPendEvent,
  1370.                        IO_NO_INCREMENT,
  1371.                        FALSE);
  1372.         }
  1373.     }
  1375.     IsoUsb_DbgPrint(3, ("CancelSelectSuspend - endsn"));
  1377.     return;
  1378. }
  1380. VOID
  1381. PoIrpCompletionFunc(
  1382.     IN PDEVICE_OBJECT DeviceObject,
  1383.     IN UCHAR MinorFunction,
  1384.     IN POWER_STATE PowerState,
  1385.     IN PVOID Context,
  1386.     IN PIO_STATUS_BLOCK IoStatus
  1387.     )
  1388. /*++
  1389.  
  1390. Routine Description:
  1392.     Completion routine for power irp PoRequested in IdleNotification
  1393.     RequestComplete routine.
  1395. Arguments:
  1397.     DeviceObject - pointer to device object
  1398.     MinorFunciton - minor function for the irp.
  1399.     PowerState - irp power state
  1400.     Context - context passed to the completion function
  1401.     IoStatus - status block.
  1403. Return Value:
  1405.     None
  1407. --*/
  1408. {
  1409.     PIRP_COMPLETION_CONTEXT irpContext;
  1410.     
  1411.     //
  1412.     // initialize variables
  1413.     //
  1415.     if(Context) {
  1417.         irpContext = (PIRP_COMPLETION_CONTEXT) Context;
  1418.     }
  1420.     //
  1421.     // all we do is set the event and decrement the count
  1422.     //
  1424.     if(irpContext) {
  1426.         KeSetEvent(irpContext->Event, 0, FALSE);
  1428.         IsoUsb_DbgPrint(3, ("PoIrpCompletionFunc::"));
  1429.         IsoUsb_IoDecrement(irpContext->DeviceExtension);
  1431.         ExFreePool(irpContext);
  1432.     }
  1434.     return;
  1435. }
  1437. VOID
  1438. PoIrpAsyncCompletionFunc(
  1439.     IN PDEVICE_OBJECT DeviceObject,
  1440.     IN UCHAR MinorFunction,
  1441.     IN POWER_STATE PowerState,
  1442.     IN PVOID Context,
  1443.     IN PIO_STATUS_BLOCK IoStatus
  1444.     )
  1445. /*++
  1447. Routine Description:
  1449.   Completion routine for PoRequest wait wake irp
  1451. Arguments:
  1453.     DeviceObject - pointer to device object
  1454.     MinorFunciton - minor function for the irp.
  1455.     PowerState - irp power state
  1456.     Context - context passed to the completion function
  1457.     IoStatus - status block.    
  1459. Return Value:
  1461.     None
  1463. --*/
  1464. {
  1465.     PDEVICE_EXTENSION DeviceExtension;
  1466.     
  1467.     //
  1468.     // initialize variables
  1469.     //
  1470.     DeviceExtension = (PDEVICE_EXTENSION) Context;
  1472.     //
  1473.     // all we do is decrement the count
  1474.     //
  1475.     
  1476.     IsoUsb_DbgPrint(3, ("PoIrpAsyncCompletionFunc::"));
  1477.     IsoUsb_IoDecrement(DeviceExtension);
  1479.     return;
  1480. }
  1482. VOID
  1483. WWIrpCompletionFunc(
  1484.     IN PDEVICE_OBJECT DeviceObject,
  1485.     IN UCHAR MinorFunction,
  1486.     IN POWER_STATE PowerState,
  1487.     IN PVOID Context,
  1488.     IN PIO_STATUS_BLOCK IoStatus
  1489.     )
  1490. /*++
  1491.  
  1492. Routine Description:
  1494.   Completion routine for idle notification irp
  1496. Arguments:
  1498. Return Value:
  1500. --*/
  1501. {
  1502.     PDEVICE_EXTENSION DeviceExtension;
  1503.     
  1504.     //
  1505.     // initialize variables
  1506.     //
  1507.     DeviceExtension = (PDEVICE_EXTENSION) Context;
  1509.     //
  1510.     // all we do is decrement the count
  1511.     //
  1512.     
  1513.     IsoUsb_DbgPrint(3, ("WWIrpCompletionFunc::"));
  1514.     IsoUsb_IoDecrement(DeviceExtension);
  1516.     return;
  1517. }