windows-xp/Source/XPSP1/NT/drivers/wdm/usb/driver/usbdiag/usbdiag.c

/*++

Copyright (c) 1996  Microsoft Corporation

Module Name:

    usbdiag.c

Abstract:

    USB device driver for Intel/Microsoft USB diagnostic apps 

Environment:

    kernel mode only

Notes:

  THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF ANY
  KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
  IMPLIED WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR
  PURPOSE.

  Copyright (c) 1996 Microsoft Corporation.  All Rights Reserved.


Revision History:

     5-4-96 : created
    7-21-97 : Todd Carpenter adds Chap11 IOCTL's

--*/

#define DRIVER

#include "wdm.h"
#include "stdarg.h"
#include "stdio.h"

#pragma pack (push,1)
#include "usb100.h"
#include "usbdi.h"
#include "usbdlib.h"
#include "usbioctl.h"
#pragma pack (pop) //disable 1-byte alignment
 
#include "opaque.h"

#pragma pack (push,1)
#include "ioctl.h"
#include "chap9drv.h"
#include "USBDIAG.h"
#pragma pack (pop) //disable 1-byte alignment

PDEVICE_OBJECT          USBDIAG_GlobalDeviceObject = NULL;

ULONG USBDIAG_NextDeviceNumber = 0;
ULONG USBDIAG_NumberDevices = 0;
ULONG gulMemoryAllocated = 0;

USBD_VERSION_INFORMATION gVersionInformation;


/* UCHAR *SystemPowerStateString[] = {
   "PowerSystemUnspecified",
   "PowerSystemWorking",
   "PowerSystemSleeping1",
   "PowerSystemSleeping2",
   "PowerSystemSleeping3",
   "PowerSystemHibernate",
   "PowerSystemShutdown",
   "PowerSystemMaximum"
};

UCHAR *DevicePowerStateString[] = {
   "PowerDeviceUnspecified",
   "PowerDeviceD0",
   "PowerDeviceD1",
   "PowerDeviceD2",
   "PowerDeviceD3",
   "PowerDeviceMaximum"
}; */



//
// Global pointer to Driver Object
//

PDRIVER_OBJECT USBDIAG_DriverObject;

#define REMOTE_WAKEUP 0x20

#ifdef PAGE_CODE
#ifdef ALLOC_PRAGMA
#pragma alloc_text(PAGE, USBD_SubmitSynchronousURB)
#pragma alloc_text(PAGE, USBD_CloseEndpoint)
#endif
#endif


NTSTATUS
DriverEntry(
    IN PDRIVER_OBJECT DriverObject,
    IN PUNICODE_STRING RegistryPath
    )
/*++

Routine Description:

    Installable driver initialization entry point.
    This entry point is called directly by the I/O system.

Arguments:

    DriverObject - pointer to the driver object

    RegistryPath - pointer to a unicode string representing the path
                   to driver-specific key in the registry

Return Value:

    STATUS_SUCCESS if successful,
    STATUS_UNSUCCESSFUL otherwise

--*/
{
    NTSTATUS ntStatus = STATUS_SUCCESS;
    //PDEVICE_OBJECT deviceObject = NULL;

    DbgPrint("USBDIAG.SYS: entering (USBDIAG) DriverEntry\n");
    DbgPrint("USBDIAG.SYS: USBDIAG Driver Build Date/Time: %s  %s\n",
              __DATE__, __TIME__);

    USBDIAG_DriverObject = DriverObject;

    //
    // Create dispatch points for device control, create, close.
    //

    DriverObject->MajorFunction[IRP_MJ_PNP]     = USBDIAG_PnP;
    DriverObject->MajorFunction[IRP_MJ_POWER]   = USBDIAG_Power;
                
    DriverObject->MajorFunction[IRP_MJ_CREATE]  =
    DriverObject->MajorFunction[IRP_MJ_CLOSE]   =  USBDIAG_Dispatch;

    DriverObject->MajorFunction[IRP_MJ_DEVICE_CONTROL]  =  USBDIAG_ProcessIOCTL;
    DriverObject->MajorFunction[IRP_MJ_WRITE]   =  NULL;
    DriverObject->MajorFunction[IRP_MJ_READ]    =  NULL;
    DriverObject->DriverUnload                  =  USBDIAG_Unload;
                                            
    DriverObject->DriverExtension->AddDevice    = USBDIAG_PnPAddDevice;

    DbgPrint ("'USBDIAG.SYS: exiting (USBDIAG) DriverEntry (%x)\n", ntStatus);


    // determine the os version and store in a global.
    USBD_GetUSBDIVersion(&gVersionInformation);

    return ntStatus;
}


NTSTATUS
USBDIAG_Dispatch(
    IN PDEVICE_OBJECT DeviceObject,
    IN PIRP           Irp
    )
/*++

Routine Description:

    Process the IRPs sent to this device.

Arguments:

    DeviceObject - pointer to a device object

    Irp          - pointer to an I/O Request Packet

Return Value:


--*/
{
    PIO_STACK_LOCATION irpStack;
    NTSTATUS ntStatus;
    PDEVICE_EXTENSION globalDeviceExtension;
    
    //USBDIAG_KdPrint(("USBDIAG.SYS: enter USBDIAG_Dispatch\n"));

    //
    // Default return status unless overridden later
    //
    Irp->IoStatus.Status = STATUS_SUCCESS;
    Irp->IoStatus.Information = 0;

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

    switch (irpStack->MajorFunction) {
    case IRP_MJ_CREATE:
        //USBDIAG_KdPrint(("USBDIAG.SYS: IRP_MJ_CREATE\n"));
        ASSERT(USBDIAG_GlobalDeviceObject != NULL);
        globalDeviceExtension = USBDIAG_GlobalDeviceObject->DeviceExtension;
        globalDeviceExtension->OpenFRC++;
                break;
                
    case IRP_MJ_CLOSE:
        //USBDIAG_KdPrint(("USBDIAG.SYS: IRP_MJ_CLOSE\n"));
        ASSERT(USBDIAG_GlobalDeviceObject != NULL);
        globalDeviceExtension = USBDIAG_GlobalDeviceObject->DeviceExtension;
        globalDeviceExtension->OpenFRC--;
        break;

    default:
        Irp->IoStatus.Status = STATUS_INVALID_PARAMETER;    
        break;
        
    } /* case MajorFunction */

    ntStatus = Irp->IoStatus.Status;

    IoCompleteRequest (Irp, IO_NO_INCREMENT);

    //USBDIAG_KdPrint(("USBDIAG.SYS: Exit USBDIAG_Dispatch %x\n", ntStatus));
    
    return ntStatus;
}


NTSTATUS
USBDIAG_PnP(
    IN PDEVICE_OBJECT DeviceObject,
    IN PIRP           Irp
    )
/*++

Routine Description:

    Process the PnP IRPs sent to this device.

Arguments:

    DeviceObject - pointer to a device object

    Irp          - pointer to an I/O Request Packet

Return Value:


--*/
{
    NTSTATUS            ntStatus;
    PIO_STACK_LOCATION  irpStack;
    PDEVICE_EXTENSION   deviceExtension;
    PDEVICE_EXTENSION   globalDeviceExtension;
    PDEVICE_LIST_ENTRY  device, foundDevice;
    BOOLEAN             passDownIrp;


    //USBDIAG_KdPrint(("USBDIAG.SYS: enter USBDIAG_PnP\n"));

    //
    // Default to passing down all Irps unless overridden later.
    //
    passDownIrp = TRUE;

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

    //
    // Get a pointer to the device extension
    //
    deviceExtension = DeviceObject->DeviceExtension;

    ASSERT (deviceExtension != NULL);

    //
    // Get a pointer to the global device extension
    //
    globalDeviceExtension = USBDIAG_GlobalDeviceObject->DeviceExtension;
    
    //
    // Switch on the PnP minor function
    //
    switch (irpStack->MinorFunction) {
        case IRP_MN_START_DEVICE:
            //USBDIAG_KdPrint(("USBDIAG.SYS: IRP_MN_START_DEVICE\n"));
            ntStatus = USBDIAG_PassDownIrp(DeviceObject, Irp);
            USBDIAG_KdPrint (("Back from passing down IRP_MN_START_DEVICE; status: %#X\n",
                              ntStatus));

            if (NT_SUCCESS(ntStatus))
            {
                // Now we can begin our configuration actions on the device
                //
                ntStatus = USBDIAG_StartDevice(DeviceObject);
            }
            passDownIrp = FALSE;
            break;
        
        case IRP_MN_QUERY_CAPABILITIES: // 0x09
            USBDIAG_KdPrint (("*********************************\n"));
            USBDIAG_KdPrint (("IRP_MN_QUERY_CAPABILITIES\n"));
            passDownIrp = FALSE;

            IoCopyCurrentIrpStackLocationToNext(Irp);
            IoSetCompletionRoutine(Irp,
                                   USBDIAG_QueryCapabilitiesCompletionRoutine,
                                   DeviceObject,
                                   TRUE,
                                   TRUE,
                                   TRUE);

            ntStatus = IoCallDriver(deviceExtension->StackDeviceObject, Irp);
            break;


        case IRP_MN_STOP_DEVICE:
            //USBDIAG_KdPrint(("USBDIAG.SYS: IRP_MN_STOP_DEVICE\n"));
            ntStatus = USBDIAG_StopDevice(DeviceObject);
            break;

        case IRP_MN_REMOVE_DEVICE:
            {
                int i = 1;
                //USBDIAG_KdPrint(("USBDIAG.SYS: IRP_MN_REMOVE_DEVICE\n"));
                ntStatus = USBDIAG_StopDevice(DeviceObject);

                // remove all downstream devices
                for (i = 1; i <= MAX_DOWNSTREAM_DEVICES; i++)
                {
                    if (deviceExtension->DeviceData[i])
                    {
                        USBDIAG_KdPrint(("IRP_MN_REMOVE_DEVICE: Removing device on downstream port %d\n", i));
                        USBDIAG_RemoveDownstreamDevice(deviceExtension->DeviceData[i],
                                                       deviceExtension->StackDeviceObject);

                    }
                }
                USBDIAG_KdPrint(("Done removing downstream devices\n"));
                //
                // Remove this device object from our list
                //

                device = globalDeviceExtension->DeviceList;

                USBDIAG_KdPrint(("USBDIAG.SYS: IRP_MN_REMOVE_DEVICE devobj = %x dev = %x\n", 
                                  DeviceObject, device));

                ASSERT(device != NULL);

                if (device->DeviceObject == DeviceObject) {
                    //
                    // DeviceObject is the first one on the list.  Delete from the
                    // list by setting the head of the list to point to the next
                    // one on the list.
                    //
                    globalDeviceExtension->DeviceList = device->Next;                

                    USBDIAG_ExFreePool(device);
                
                } else {
                    //
                    // DeviceObject is not the first one on the list.  Walk the
                    // list and find it.
                    //
                    while (device->Next) {
                        if (device->Next->DeviceObject == DeviceObject) {
                            //
                            // DeviceObject is the next one on the list, remember
                            // the next one and delete it by setting the next one
                            // to the next next one.
                            //
                            foundDevice = device->Next;
                            device->Next = foundDevice->Next;

                            USBDIAG_ExFreePool(foundDevice);
                            break;
                                }
                        device = device->Next;
                    }
                }

                //USBDIAG_KdPrint(("USBDIAG.SYS: Detaching stack device object...%X\n",
                                  //deviceExtension->StackDeviceObject));
                IoDetachDevice(deviceExtension->StackDeviceObject);

                //
                // Pass the REMOVE_DEVICE Irp down now after detaching and
                // removing the device instead of later.
                //
                passDownIrp = FALSE;

                IoSkipCurrentIrpStackLocation (Irp);

                ntStatus = IoCallDriver(deviceExtension->StackDeviceObject, Irp);

                //USBDIAG_KdPrint(("USBDIAG.SYS: Deleting device object...%X\n", DeviceObject));
                IoDeleteDevice(DeviceObject);

                USBDIAG_NumberDevices--;

                //
                // Free the GlobalDeviceObject if this was the last real
                // DeviceObject.   XXXXX Take a careful look at what the
                // hell this routine is all about.
                //
                USBDIAG_RemoveGlobalDeviceObject();
            }
            break;
            
        default:
            //USBDIAG_KdPrint(("USBDIAG.SYS: PnP IOCTL not handled: (%#X)\n",
                              //irpStack->MinorFunction));
            break;
    }

    if (passDownIrp)
    {
        //
        // Pass the PnP Irp down the stack
        //
        IoSkipCurrentIrpStackLocation (Irp);
        ntStatus = IoCallDriver(deviceExtension->StackDeviceObject,
                                Irp);
    }

    //USBDIAG_KdPrint(("USBDIAG.SYS: Exit USBDIAG_PnP %x\n", ntStatus));
    
    return ntStatus;
}

NTSTATUS
USBDIAG_PassDownIrp (
    IN PDEVICE_OBJECT   DeviceObject,
    IN PIRP             Irp
    )
{
    PDEVICE_EXTENSION   deviceExtension = DeviceObject->DeviceExtension;
    KEVENT              localevent;
    NTSTATUS            ntStatus;

    PAGED_CODE();

    // Initialize the event we'll wait on
    //
    KeInitializeEvent(&localevent,
                      SynchronizationEvent,
                      FALSE);

    // Copy down Irp params for the next driver
    //
    IoCopyCurrentIrpStackLocationToNext(Irp);

    // Set the completion routine, which will signal the event
    //
    IoSetCompletionRoutine(Irp,
                           USBDIAG_GenericCompletionRoutine,
                           &localevent,
                           TRUE,    // InvokeOnSuccess
                           TRUE,    // InvokeOnError
                           TRUE);   // InvokeOnCancel

    // Pass the Irp down the stack
    //
    ntStatus = IoCallDriver(deviceExtension->StackDeviceObject, Irp);

    // If the request is pending, block until it completes
    //
    if (ntStatus == STATUS_PENDING)
    {
        KeWaitForSingleObject(&localevent,
                              Executive,
                              KernelMode,
                              FALSE,
                              NULL);

        ntStatus = Irp->IoStatus.Status;
    }

    return ntStatus;
}

NTSTATUS
USBDIAG_GenericCompletionRoutine(
    IN PDEVICE_OBJECT   DeviceObject,
    IN PIRP             Irp,
    IN PVOID            Context
    )
{
    PKEVENT kevent;

    kevent = (PKEVENT)Context;
    KeSetEvent(kevent, IO_NO_INCREMENT,FALSE);
    return STATUS_MORE_PROCESSING_REQUIRED;
}


VOID
USBDIAG_Unload(
    IN PDRIVER_OBJECT DriverObject
    )
/*++

Routine Description:

    Free all the allocated resources, etc.

Arguments:

    DriverObject - pointer to a driver object

Return Value:


--*/
{
    DbgPrint ("USBDIAG.SYS: enter USBDIAG_Unload\n");

    //
    // Free any global resources allocated
    // in DriverEntry
    //

    // free the global deviceobject here

        USBDIAG_RemoveGlobalDeviceObject();
    DbgPrint ("USBDIAG.SYS: exit USBDIAG_Unload\n");
}



NTSTATUS
USBDIAG_StartDevice(
    IN  PDEVICE_OBJECT DeviceObject
    )
/*++

Routine Description:

    Initializes a given instance of the device on the USB.

Arguments:

    DeviceObject - pointer to the device object for this instance of a 
                    UTB

Return Value:

    NT status code

--*/
{
    PDEVICE_EXTENSION deviceExtension = DeviceObject->DeviceExtension;
    NTSTATUS ntStatus;
    PUSB_DEVICE_DESCRIPTOR deviceDescriptor = NULL;
    PURB urb;
    ULONG siz;

    //USBDIAG_KdPrint(("USBDIAG.SYS: enter USBDIAG_StartDevice\n"));    

    //
    // Fetch the device descriptor for the device
    // 
    urb = USBDIAG_ExAllocatePool(NonPagedPool, 
                         sizeof(struct _URB_CONTROL_DESCRIPTOR_REQUEST));
                         
    if (urb) 
    {
        siz = sizeof(USB_DEVICE_DESCRIPTOR);

        deviceDescriptor = USBDIAG_ExAllocatePool(NonPagedPool, siz);

        if (deviceDescriptor) 
        {    
            UsbBuildGetDescriptorRequest(urb,
                                         (USHORT) sizeof (struct _URB_CONTROL_DESCRIPTOR_REQUEST),
                                         USB_DEVICE_DESCRIPTOR_TYPE,
                                         0,
                                         0,
                                         deviceDescriptor,
                                         NULL,
                                         siz,
                                         NULL);
                                                                  
            ntStatus = USBDIAG_CallUSBD(DeviceObject, urb);

            if (NT_SUCCESS(ntStatus)) 
            {
                //USBDIAG_KdPrint(("USBDIAG.SYS: Device Descriptor = %x, len %x\n", 
                                //deviceDescriptor, 
                                //urb->UrbControlDescriptorRequest.TransferBufferLength));    

                //USBDIAG_KdPrint(("USBDIAG.SYS: USB Device Descriptor:\n"));
                //USBDIAG_KdPrint(("USBDIAG.SYS: -------------------------\n"));                
                //USBDIAG_KdPrint(("USBDIAG.SYS: bLength %d\n", deviceDescriptor->bLength));
                //USBDIAG_KdPrint(("USBDIAG.SYS: bDescriptorType 0x%x\n", deviceDescriptor->bDescriptorType));
                //USBDIAG_KdPrint(("USBDIAG.SYS: bcdUSB 0x%x\n", deviceDescriptor->bcdUSB));
                //USBDIAG_KdPrint(("USBDIAG.SYS: bDeviceClass 0x%x\n", deviceDescriptor->bDeviceClass));
                //USBDIAG_KdPrint(("USBDIAG.SYS: bDeviceSubClass 0x%x\n", deviceDescriptor->bDeviceSubClass));
                //USBDIAG_KdPrint(("USBDIAG.SYS: bDeviceProtocol 0x%x\n", deviceDescriptor->bDeviceProtocol));
                //USBDIAG_KdPrint(("USBDIAG.SYS: bMaxPacketSize0 0x%x\n", deviceDescriptor->bMaxPacketSize0));
                //USBDIAG_KdPrint(("USBDIAG.SYS: idVendor 0x%x\n", deviceDescriptor->idVendor));
                //USBDIAG_KdPrint(("USBDIAG.SYS: idProduct 0x%x\n", deviceDescriptor->idProduct));
                //USBDIAG_KdPrint(("USBDIAG.SYS: bcdDevice 0x%x\n", deviceDescriptor->bcdDevice));
                //USBDIAG_KdPrint(("USBDIAG.SYS: iManufacturer 0x%x\n", deviceDescriptor->iManufacturer));
                //USBDIAG_KdPrint(("USBDIAG.SYS: iProduct 0x%x\n", deviceDescriptor->iProduct));
                //USBDIAG_KdPrint(("USBDIAG.SYS: iSerialNumber 0x%x\n", deviceDescriptor->iSerialNumber));
                //USBDIAG_KdPrint(("USBDIAG.SYS: bNumConfigurations 0x%x\n", deviceDescriptor->bNumConfigurations));
            }
        } 
        else 
        {
            ntStatus = STATUS_INSUFFICIENT_RESOURCES;
        }            
        
        if (NT_SUCCESS(ntStatus)) 
        {
            deviceExtension->pDeviceDescriptor = deviceDescriptor;
            deviceExtension->Stopped = FALSE;
        } 
        else if (deviceDescriptor) 
        {
             USBDIAG_ExFreePool(deviceDescriptor);
        }

        USBDIAG_ExFreePool(urb);
    } 
    else 
    {
        ntStatus = STATUS_INSUFFICIENT_RESOURCES;        
    }        


    //USBDIAG_KdPrint(("USBDIAG.SYS: exit USBDIAG_StartDevice (%x)\n", ntStatus));

    return ntStatus;
}

NTSTATUS
USBDIAG_QueryCapabilitiesCompletionRoutine(
    IN PDEVICE_OBJECT NullDeviceObject,
    IN PIRP Irp,
    IN PVOID Context
    )
{
    PDEVICE_OBJECT deviceObject       = (PDEVICE_OBJECT) Context;
    PDEVICE_EXTENSION deviceExtension = deviceObject->DeviceExtension;
    NTSTATUS ntStatus = STATUS_SUCCESS;
    PIO_STACK_LOCATION irpStack = IoGetCurrentIrpStackLocation (Irp);
    ULONG ulPowerLevel;

    USBDIAG_KdPrint(("enter USBDIAG_QueryCapabilitiesCompletionRoutine (Irp->IoStatus.Status = 0x%x)\n", Irp->IoStatus.Status));

    //  If the lower driver returned PENDING, mark our stack location as pending also.
    if (Irp->PendingReturned) 
    {
        IoMarkIrpPending(Irp);
    }
    ASSERT(irpStack->MajorFunction == IRP_MJ_PNP);
    ASSERT(irpStack->MinorFunction == IRP_MN_QUERY_CAPABILITIES);

    irpStack = IoGetCurrentIrpStackLocation (Irp);

    USBDIAG_KdPrint(("sizeof(DEVICE_CAPABILITIES) = %d (0x%x)\n",sizeof(DEVICE_CAPABILITIES),sizeof(DEVICE_CAPABILITIES)));

    // this is for Win2k
    irpStack->Parameters.DeviceCapabilities.Capabilities->SurpriseRemovalOK = TRUE;
    irpStack->Parameters.DeviceCapabilities.Capabilities->Removable         = TRUE;

    RtlCopyMemory(&deviceExtension->DeviceCapabilities, 
                  irpStack->Parameters.DeviceCapabilities.Capabilities, 
                  sizeof(DEVICE_CAPABILITIES));


    // print out capabilities info
    USBDIAG_KdPrint(("************ Device Capabilites ************\n"));
    USBDIAG_KdPrint(("SystemWake = 0x%x\n", deviceExtension->DeviceCapabilities.SystemWake));
    USBDIAG_KdPrint(("DeviceWake = 0x%x\n", deviceExtension->DeviceCapabilities.DeviceWake));

//    USBDIAG_KdPrint(("SystemWake = %s\n",
//                    SystemPowerStateString[deviceExtension->DeviceCapabilities.SystemWake]));
//    USBDIAG_KdPrint(("DeviceWake = %s\n",
//                    DevicePowerStateString[deviceExtension->DeviceCapabilities.DeviceWake]));

    USBDIAG_KdPrint(("Device Address: 0x%x\n", deviceExtension->DeviceCapabilities.Address));

    for (ulPowerLevel=PowerSystemUnspecified; ulPowerLevel< PowerSystemMaximum; ulPowerLevel++) 
    {
//        USBDIAG_KdPrint(("Dev State Map: sys st %s = dev st %s\n",
//                        SystemPowerStateString[ulPowerLevel],
//                        DevicePowerStateString[deviceExtension->DeviceCapabilities.DeviceState[ulPowerLevel]] ));
    }
    Irp->IoStatus.Status = STATUS_SUCCESS;

    return ntStatus;
}


NTSTATUS
USBDIAG_StopDevice(
    IN  PDEVICE_OBJECT DeviceObject
    )
/*++

Routine Description:

    Stops a given instance of a UTB device on the 82930.

Arguments:

    DeviceObject - pointer to the device object for this instance of a 82930 

Return Value:

    NT status code

--*/
{
    PDEVICE_EXTENSION deviceExtension = DeviceObject->DeviceExtension;
    NTSTATUS          ntStatus        = STATUS_SUCCESS;

    //USBDIAG_KdPrint(("USBDIAG.SYS: enter USBDIAG_StopDevice\n"));    

    if (deviceExtension->Stopped != TRUE)
    {
        ntStatus = USBDIAG_CancelAllIrps(deviceExtension);
        // 
        // if we are already stopped then just exit
        //

        if (deviceExtension->pDeviceDescriptor)
        {
            USBDIAG_ExFreePool(deviceExtension->pDeviceDescriptor);
            deviceExtension->pDeviceDescriptor = NULL;
        }
        deviceExtension->Stopped = TRUE;
    }

    //USBDIAG_KdPrint(("USBDIAG.SYS: exit USBDIAG_StopDevice (%x)\n", ntStatus));

    return ntStatus;
}



NTSTATUS
USBDIAG_PnPAddDevice(
    IN PDRIVER_OBJECT DriverObject,
    IN OUT PDEVICE_OBJECT PhysicalDeviceObject
    )
/*++

Routine Description:

    This routine is called to create a new instance of the device

Arguments:

    DriverObject - pointer to the driver object for this instance of USBDIAG

    PhysicalDeviceObject - pointer to device object created by the bus

Return Value:

    STATUS_SUCCESS if successful,
    STATUS_UNSUCCESSFUL otherwise

--*/
{
    NTSTATUS                ntStatus = STATUS_SUCCESS;
    PDEVICE_OBJECT          deviceObject = NULL;
    PDEVICE_EXTENSION       deviceExtension, globalDeviceExtension = NULL;
//    PDEVICE_OBJECT          tempdeviceObject = NULL;
    
    USBDIAG_KdPrint(("USBDIAG.SYS: enter USBDIAG_PnPAddDevice\n"));

    //
    // Are we given the physical device object?
    //
    if (PhysicalDeviceObject) {

            if (USBDIAG_GlobalDeviceObject == NULL) {

                //USBDIAG_KdPrint(("USBDIAG.SYS: PnPAddDevice Creating Global Device Object\n"));

                ntStatus = 
                    USBDIAG_CreateDeviceObject(DriverObject, &USBDIAG_GlobalDeviceObject, TRUE);
                    
                if (NT_SUCCESS(ntStatus)) {  
                    globalDeviceExtension = USBDIAG_GlobalDeviceObject->DeviceExtension;
                    
                    USBDIAG_GlobalDeviceObject->Flags &= ~DO_DEVICE_INITIALIZING;
            
                    globalDeviceExtension->DeviceList = NULL;    
                    globalDeviceExtension->OpenFRC = 0;                    
                }                                        
            } 
            else 
            {
                 globalDeviceExtension = USBDIAG_GlobalDeviceObject->DeviceExtension;
            }

            //
            // create our funtional device object (FDO)
            //

            if (NT_SUCCESS(ntStatus)) 
            {            
                //USBDIAG_KdPrint(("USBDIAG.SYS: PnPAddDevice creating new USB device object\n"));

                ntStatus = USBDIAG_CreateDeviceObject(DriverObject, &deviceObject, FALSE);

                if (NT_SUCCESS(ntStatus)) 
                {
                    //USBDIAG_KdPrint(("USBDIAG.SYS: PnPAddDevice DONE creating new USB device object\n"));
                }//if
            }
            if (NT_SUCCESS(ntStatus)) 
            {
                PDEVICE_LIST_ENTRY device;
                
                deviceExtension = deviceObject->DeviceExtension;
                RtlZeroMemory(deviceExtension->DeviceData, MAX_DOWNSTREAM_DEVICES * sizeof(PUSBD_DEVICE_DATA));

                // We support buffered I/O only
                deviceObject->Flags |= DO_BUFFERED_IO;

                // 
                // remember the Physical device Object
                //
                deviceExtension->PhysicalDeviceObject=PhysicalDeviceObject;

                //
                // Attach to the PDO
                //
                //USBDIAG_KdPrint(("USBDIAG.SYS: PnPAddDevice attaching device to Stack.\n"));

                //
                // The stackdeviceobject is what we use to send Urbs down the stack
                //
                deviceExtension->StackDeviceObject =
                    IoAttachDeviceToDeviceStack(deviceObject, PhysicalDeviceObject);

                RtlZeroMemory(deviceExtension->DeviceData, MAX_DOWNSTREAM_DEVICES * sizeof(PUSBD_DEVICE_DATA));

                if ((deviceExtension->StackDeviceObject) != NULL) 
                {

                    //passed the IoAttachDeviceToDeviceStack call
                    //USBDIAG_KdPrint(("USBDIAG.SYS: PnPAddDevice successfully attached device to stack\n"));
                    
                    USBDIAG_KdPrint(("USBDIAG.SYS: PnPAddDevice stackDevObj: %X\n",deviceExtension->StackDeviceObject));
                    
                    USBDIAG_KdPrint(("USBDIAG.SYS: Saving in deviceExtension 0x%x.\n",
                                      deviceExtension));

                    if (gVersionInformation.USBDI_Version >= USBD_WIN98_SE_VERSION) // Win98 SE, Win2K and beyond
                    {
                        device = USBDIAG_ExAllocatePool(NonPagedPool, sizeof(DEVICE_LIST_ENTRY));

                        if (device) 
                        {
                            PDEVICE_OBJECT RootHubPdo = NULL;
                            PDEVICE_OBJECT TopOfHcdStackDeviceObject = NULL;

                            ASSERT(globalDeviceExtension != NULL);
                            device->Next = globalDeviceExtension->DeviceList;
                            globalDeviceExtension->DeviceList = device;
                            device->DeviceNumber = USBDIAG_NextDeviceNumber++;
                            device->PhysicalDeviceObject = PhysicalDeviceObject;
                            device->DeviceObject = deviceObject;

                            KeInitializeEvent(&deviceExtension->WaitWakeEvent, SynchronizationEvent, FALSE);


                            // Get the RootHubPdo & TopOfHcdStackDeviceObject
                            ntStatus = USBDIAG_SyncGetRootHubPdo(deviceExtension->StackDeviceObject,
                                                                                                                         PhysicalDeviceObject,
                                                                 &RootHubPdo,
                                                                 &TopOfHcdStackDeviceObject);

                            if (NT_SUCCESS(ntStatus))
                            {
                                ASSERT(RootHubPdo);
                                deviceExtension->RootHubPdo = RootHubPdo;

                                //ASSERT(TopOfHcdStackDeviceObject);
                                //deviceExtension->TopOfHcdStackDeviceObject = TopOfHcdStackDeviceObject;
                            }
                            else
                            {
                                ASSERT(FALSE);
                                deviceExtension->RootHubPdo = NULL;
                                deviceExtension->TopOfHcdStackDeviceObject = NULL;

                            }
                            ntStatus = STATUS_SUCCESS;
                        } //if device allocate was successful
                    }
                        
                }//if attach device was successful
                else
                {
                    ntStatus = STATUS_NO_SUCH_DEVICE;
                    //USBDIAG_KdPrint(("USBDIAG.SYS: PnPAddDevice FAILED attaching device to stack\n"));
                } //else attach failed     

            }// if successfully created device object                

    } 
    else 
    {
        //
        // Given no physical device object, therefore asked to do detection.
        // This is a dream on as all USB controller are PCI devices.
        //

        ntStatus = STATUS_NO_MORE_ENTRIES;
    }//else no PDO given

    //USBDIAG_KdPrint(("USBDIAG.SYS: exit USBDIAG_PnPAddDevice (%x)\n", ntStatus));

        if(NT_SUCCESS(ntStatus))
                USBDIAG_NumberDevices++;

    return ntStatus;
}


NTSTATUS
USBDIAG_CreateDeviceObject(
    IN PDRIVER_OBJECT DriverObject,
    IN PDEVICE_OBJECT *DeviceObject,
    BOOLEAN Global
    )
/*++

Routine Description:

    Creates a Functional DeviceObject for the diag driver
    
Arguments:

    DriverObject - pointer to the driver object for device

    DeviceObject - pointer to DeviceObject pointer to return
                    created device object.

    Global - create the global device object and symbolic link.

Return Value:

    STATUS_SUCCESS if successful,
    STATUS_UNSUCCESSFUL otherwise

--*/
{
    NTSTATUS ntStatus;
    WCHAR deviceLinkBuffer[]  = L"\\DosDevices\\USBDIAG";
    UNICODE_STRING deviceLinkUnicodeString;
    WCHAR deviceNameBuffer[]  = L"\\Device\\USBDIAG";
    UNICODE_STRING deviceNameUnicodeString;
    PDEVICE_EXTENSION deviceExtension;
    STRING deviceName;

    //USBDIAG_KdPrint(("USBDIAG.SYS: enter USBDIAG_CreateDeviceObject\n"));


    //
    // fix up device names based on Instance
    //

    //USBDIAG_KdPrint(("USBDIAG.SYS: USBDIAG_CreateDeviceObject InitUnicode String\n"));

    RtlInitUnicodeString (&deviceNameUnicodeString,
                          deviceNameBuffer);


    //USBDIAG_KdPrint(("USBDIAG.SYS: USBDIAG_CreateDeviceObject Convert unicode to ansi\n"));

    //Print out the unicode string

    deviceName.Buffer = NULL;

    ntStatus = RtlUnicodeStringToAnsiString (&deviceName,
                                             &deviceNameUnicodeString, 
                                             TRUE);


    if (NT_SUCCESS(ntStatus)) {
        //USBDIAG_KdPrint(("USBDIAG.SYS: Create Device Name (%s)\n", deviceName.Buffer));
        RtlFreeAnsiString (&deviceName);
        if (!NT_SUCCESS(ntStatus)) {
            //USBDIAG_KdPrint(("USBDIAG.SYS: Failed freeing ansi string!\n"));
        }//if not successful ntstatus
    } else {
        //USBDIAG_KdPrint(("USBDIAG.SYS: Unicode to Ansi str failed w/ ntStatus: 0x%x\n",ntStatus));
    }

    
    //USBDIAG_KdPrint(("USBDIAG.SYS: USBDIAG_CreateDeviceObject IOCreateDevice \n"));

    ntStatus = IoCreateDevice (DriverObject,
                                   sizeof (DEVICE_EXTENSION),
                               Global ? &deviceNameUnicodeString : NULL,
                                   FILE_DEVICE_UNKNOWN,
                               0,
                                   FALSE,
                               DeviceObject);

    if (NT_SUCCESS(ntStatus)) {

        //
        // Initialize our device extension
        //
        
        deviceExtension = (PDEVICE_EXTENSION) ((*DeviceObject)->DeviceExtension);

        if (Global)
                {
            RtlInitUnicodeString (&deviceLinkUnicodeString,
                                  deviceLinkBuffer);
                                  
            //USBDIAG_KdPrint(("USBDIAG.SYS: Global: Create DosDevice name (%s)\n", deviceLinkBuffer));        
            
            ntStatus = IoCreateSymbolicLink (&deviceLinkUnicodeString,
                                             &deviceNameUnicodeString);

            RtlCopyMemory(deviceExtension->DeviceLinkNameBuffer, 
                      deviceLinkBuffer,        
                      sizeof(deviceLinkBuffer));
        }//if Global
                else
                {
                deviceExtension->Stopped = TRUE;
            (*DeviceObject)->Flags |= DO_POWER_PAGABLE;
                        (*DeviceObject)->Flags &= ~DO_DEVICE_INITIALIZING;
                }//else


        //Setup the ptr to the device extension for this device & init the Irp field (for now)
        //deviceExtension->IrpHead = NULL;

        InitializeListHead(&deviceExtension->ListHead);
        KeInitializeSpinLock(&deviceExtension->SpinLock);
        KeInitializeEvent(&deviceExtension->CancelEvent, NotificationEvent, FALSE);

        // this event is triggered when self-requested power irps complete
        //KeInitializeEvent(&deviceExtension->SelfRequestedPowerIrpEvent, NotificationEvent, FALSE);
        deviceExtension->SelfRequestedPowerIrpEvent = NULL;

        // initialize original power level as fully on
        deviceExtension->CurrentDeviceState.DeviceState = PowerDeviceD0;
        deviceExtension->CurrentSystemState.SystemState = PowerSystemWorking;

        deviceExtension->WaitWakeIrp  = NULL;
        deviceExtension->InterruptIrp = NULL;
   
    }//if ntsuccess 

    //USBDIAG_KdPrint(("USBDIAG.SYS: exit USBDIAG_CreateDeviceObject (%x)\n", ntStatus));

    return ntStatus;
}


NTSTATUS
USBDIAG_CallUSBD(
    IN PDEVICE_OBJECT DeviceObject,
    IN PURB Urb
    )
/*++

Routine Description:

    Passes a URB to the USBD class driver

Arguments:

    DeviceObject - pointer to the device object for this instance of an 82930  

    Urb - pointer to Urb request block

Return Value:

    STATUS_SUCCESS if successful,
    STATUS_UNSUCCESSFUL otherwise

--*/
{
    NTSTATUS ntStatus, status = STATUS_SUCCESS;
    PDEVICE_EXTENSION deviceExtension;
    PIRP irp;
    KEVENT event;
    IO_STATUS_BLOCK ioStatus;
    PIO_STACK_LOCATION nextStack;

        //USBDIAG_KdPrint(("USBDIAG.SYS: enter USBDIAG_CallUSBD\n"));

    deviceExtension = DeviceObject->DeviceExtension;

    //
    // issue a synchronous request   
    //

    KeInitializeEvent(&event, NotificationEvent, FALSE);

    irp = IoBuildDeviceIoControlRequest(
                IOCTL_INTERNAL_USB_SUBMIT_URB,
                deviceExtension->StackDeviceObject,
                NULL,
                0,
                NULL,
                0,
                TRUE, /* INTERNAL */
                &event,
                &ioStatus);

    //
    // Call the class driver to perform the operation.  If the returned status
    // is PENDING, wait for the request to complete.
    //

    nextStack = IoGetNextIrpStackLocation(irp);
    ASSERT(nextStack != NULL);

    //
    // pass the URB to the USB driver stack
    // 
    nextStack->Parameters.Others.Argument1 = Urb;
    

    //USBDIAG_KdPrint(("USBDIAG.SYS: calling USBD\n"));

    ntStatus = IoCallDriver(deviceExtension->StackDeviceObject, 
                            irp);

    //USBDIAG_KdPrint(("USBDIAG.SYS: return from IoCallDriver USBD %x\n", ntStatus));

        {
                KIRQL irql;
                irql = KeGetCurrentIrql();
                ASSERT(irql <= PASSIVE_LEVEL);
        }

    if (ntStatus == STATUS_PENDING) {
        //USBDIAG_KdPrint(("USBDIAG.SYS: Wait for single object\n"));

        status = KeWaitForSingleObject(
                       &event,
                       Suspended,
                       KernelMode,
                       FALSE,
                       NULL);    

        //USBDIAG_KdPrint(("USBDIAG.SYS: Wait for single object, returned %x\n", status));

    } else {
        ioStatus.Status = ntStatus;        
    }        

    //USBDIAG_KdPrint(("USBDIAG.SYS: URB status = %x status = %x irp status %x\n", 
//        Urb->UrbHeader.Status, status, ioStatus.Status));

    //
    // USBD maps the error code for us
    //
    ntStatus = ioStatus.Status;

        //USBDIAG_KdPrint(("USBDIAG.SYS: exit USBDIAG_CallUSBD (%x)\n", ntStatus));

    return ntStatus;
}


NTSTATUS
USBDIAG_RemoveGlobalDeviceObject(
    )
/*++

Routine Description:

Arguments:

Return Value:

    STATUS_SUCCESS if successful,
    STATUS_UNSUCCESSFUL otherwise

--*/
{
    NTSTATUS ntStatus = STATUS_SUCCESS;
    PDEVICE_EXTENSION globalDeviceExtension;
    UNICODE_STRING deviceLinkUnicodeString;
        KIRQL irql;

    //USBDIAG_KdPrint(("USBDIAG.SYS: enter USBDIAG_RemoveGlobalDeviceObjec\n"));    

        irql = KeGetCurrentIrql();
        ASSERT(irql <= PASSIVE_LEVEL);

    if (USBDIAG_GlobalDeviceObject != NULL) {
    
        globalDeviceExtension = USBDIAG_GlobalDeviceObject->DeviceExtension;

        //USBDIAG_KdPrint(("USBDIAG.SYS: USBDIAG_RemoveGlobalDeviceObject open frc = %x, list = %x\n",
                          //globalDeviceExtension->OpenFRC,
                          //globalDeviceExtension->DeviceList));    

        if ( globalDeviceExtension->DeviceList == NULL && 
             globalDeviceExtension->OpenFRC == 0) {

            //USBDIAG_KdPrint(("USBDIAG.SYS: Deleting global device object\n"));

            // delete our global device object once we have no more devices
        
            RtlInitUnicodeString (&deviceLinkUnicodeString,
                                  globalDeviceExtension->DeviceLinkNameBuffer);

            //USBDIAG_KdPrint(("USBDIAG.SYS: Deleting Symbolic Link (UnicodeStr) at addr %X\n",
                              //&deviceLinkUnicodeString));

            ntStatus = IoDeleteSymbolicLink(&deviceLinkUnicodeString);

            if (NT_SUCCESS(ntStatus)) {

                //USBDIAG_KdPrint(("USBDIAG.SYS: Deleting Global Device Object at addr %X\n",
                                //  USBDIAG_GlobalDeviceObject));

                IoDeleteDevice( USBDIAG_GlobalDeviceObject );
    
                USBDIAG_GlobalDeviceObject = NULL;

                //USBDIAG_KdPrint(("USBDIAG.SYS: Successfully Deleted Global Device Object\n"));
            
            }            
        }
    }

    return ntStatus;
}


#define MEM_SIGNATURE                   ((ULONG) 'CLLA')
#define MEM_FREED_SIGNATURE             ((ULONG) 'EERF')


PVOID
USBDIAG_ExAllocatePool(
    IN POOL_TYPE    PoolType,
    IN ULONG        NumberOfBytes
    )
{
        PULONG  pMem;

        // allocate memory plus a little extra for our own use
        pMem = ExAllocatePool(PoolType, NumberOfBytes + (2 * sizeof(ULONG)));

        // see if we actually allocated any memory
        if(pMem)
        {
                // store number of bytes allocated at start of memory allocated
                *pMem++ = NumberOfBytes;

                // now we are pointing at the memory allocated for caller
                // put signature word at end

                // get new pointer that points to end of buffer - ULONG
                pMem = (PULONG) (((PUCHAR) pMem) + NumberOfBytes);

                // write signature
                *pMem = MEM_SIGNATURE;

                // get back pointer to return to caller
                pMem = (PULONG) (((PUCHAR) pMem) - NumberOfBytes);

        gulMemoryAllocated += NumberOfBytes;
        //USBDIAG_KdPrint(("USBDIAG_ExAllocatePool: bytes allocated: %d\n", gulMemoryAllocated));
        }

        return (PVOID) pMem;    
}

VOID
USBDIAG_ExFreePool(
    IN PVOID    P
    )
{
        PULONG  pTmp = (PULONG) P;
        ULONG   buffSize;
        //PULONG  pSav=pTmp;
        
        // point at size ULONG at start of buffer, and address to free
        pTmp--;

        // get the size of memory allocated by caller
        buffSize = *pTmp;

        // point at signature and make sure it's O.K.
        ((PCHAR) P) += buffSize;

        if(*((PULONG) P) == MEM_SIGNATURE)
        {
                // let's go ahead and get rid of signature in case we get called
                // with this pointer again and memory is still paged in
                *((PULONG) P) = MEM_FREED_SIGNATURE;
                
                // free real pointer
                ExFreePool(pTmp);

        gulMemoryAllocated -= buffSize;

        //USBDIAG_KdPrint(("USBDIAG_ExFreePool: bytes allocated: %d\n", gulMemoryAllocated));
        }
        else {
                TRAP();
    }//else    
}

NTSTATUS
USBDIAG_ResetParentPort(
    IN PDEVICE_OBJECT DeviceObject
    )
/*++

Routine Description:

    Reset the our parent port

Arguments:

Return Value:

    STATUS_SUCCESS if successful,
    STATUS_UNSUCCESSFUL otherwise

--*/
{
    NTSTATUS ntStatus, status = STATUS_SUCCESS;
    PIRP irp;
    KEVENT event;
    IO_STATUS_BLOCK ioStatus;
    PIO_STACK_LOCATION nextStack;
    PDEVICE_EXTENSION deviceExtension = DeviceObject->DeviceExtension;//USBDIAG_GlobalDeviceObject->DeviceExtension;

    USBDIAG_KdPrint(("enter USBDIAG_ResetParentPort\n"));

    ASSERT(deviceExtension);
    ASSERT(deviceExtension->StackDeviceObject);

    if (!deviceExtension->StackDeviceObject)
        return STATUS_UNSUCCESSFUL;
    //
    // issue a synchronous request
    //

    KeInitializeEvent(&event, NotificationEvent, FALSE);


    irp = IoBuildDeviceIoControlRequest(
                IOCTL_INTERNAL_USB_RESET_PORT,
                deviceExtension->StackDeviceObject,
                NULL,
                0,
                NULL,
                0,
                TRUE, /* INTERNAL */
                &event,
                &ioStatus);

    //
    // Call the class driver to perform the operation.  If the returned status
    // is PENDING, wait for the request to complete.
    //

    nextStack = IoGetNextIrpStackLocation(irp);
    ASSERT(nextStack != NULL);

    USBDIAG_KdPrint(("USBDIAG_ResetParentPort() calling USBD enable port api\n"));

    ntStatus = IoCallDriver(deviceExtension->StackDeviceObject,
                            irp);
                            
    USBDIAG_KdPrint(("USBDIAG_ResetParentPort() return from IoCallDriver USBD %x\n", ntStatus));

    if (ntStatus == STATUS_PENDING) 
    {
        USBDIAG_KdPrint(("USBDIAG_ResetParentPort() Wait for single object\n"));

        status = KeWaitForSingleObject(
                       &event,
                       Suspended,
                       KernelMode,
                       FALSE,
                       NULL);

        USBDIAG_KdPrint(("USBDIAG_ResetParentPort() Wait for single object, returned %x\n", status));
    } 
    else 
    {
        ioStatus.Status = ntStatus;
    }

    //
    // USBD maps the error code for us
    //
    ntStatus = ioStatus.Status;

    USBDIAG_KdPrint(("Exit USBDIAG_ResetPort (%x)\n", ntStatus));

    return ntStatus;
}

// *************************************
PWCHAR
GetString(PWCHAR pwc, BOOLEAN MultiSZ);

// **************************************************************************
// **************************************************************************
// downstream manipulation routines

NTSTATUS
USBDIAG_RemoveDownstreamDevice(
    IN PUSBD_DEVICE_DATA DeviceData,
    IN PDEVICE_OBJECT DeviceObject
    )
{
    NTSTATUS ntStatus = STATUS_SUCCESS;
    PUSBD_PIPE defaultPipe = &DeviceData->DefaultPipe;

        //USBDIAG_KdPrint(("- USBDIAG_RemoveDownstreamDevice calling USBD_CloseEndpoint -\n"));
    ntStatus = USBD_CloseEndpoint(DeviceData,
                                  DeviceObject,
                                  defaultPipe,
                                  NULL);

    DeviceData = NULL;

    return ntStatus;

}

NTSTATUS
USBDIAG_Chap11SetConfiguration(
    IN PUSBD_DEVICE_DATA DeviceData,
    IN PDEVICE_OBJECT DeviceObject
    )
{
    NTSTATUS ntStatus = STATUS_SUCCESS;

        ASSERT(DeviceObject);

    USBDIAG_KdPrint(("USBDIAG_Chap11SetConfiguration: DeviceData 0x%x (& 0x%x), DeviceObject 0x%x\n",
                     *DeviceData,
                     DeviceData,
                     DeviceObject));

    ntStatus = USBD_SendCommand(DeviceData,
                                DeviceObject,
                                STANDARD_COMMAND_SET_CONFIGURATION,
                                0x01,   // wValue  = 1
                                0,      // wIndex  = 0
                                0,      // wLength = 0
                                NULL,
                                0,
                                NULL,
                                NULL);

    return ntStatus;
}

NTSTATUS
USBDIAG_Chap11EnableRemoteWakeup(
    IN PUSBD_DEVICE_DATA DeviceData,
    IN PDEVICE_OBJECT DeviceObject
    )
{
    NTSTATUS ntStatus = STATUS_SUCCESS;

    ASSERT(DeviceData);

    USBDIAG_KdPrint(("USBDIAG_Chap11EnableRemoteWakeup: DeviceData 0x%x (& 0x%x), DeviceObject 0x%x\n",
                     *DeviceData,
                     DeviceData,
                     DeviceObject));

    ntStatus = USBD_SendCommand(DeviceData,
                                DeviceObject,
                                STANDARD_COMMAND_SET_DEVICE_FEATURE,
                                0x01,   // wValue  = 2 for rwu
                                0,      // wIndex  = 0
                                0,      // wLength = 0
                                NULL,
                                0,
                                NULL,
                                NULL);

    return ntStatus;
}

NTSTATUS
USBDIAG_Chap11SendPacketDownstream(
    IN PUSBD_DEVICE_DATA DeviceData,
    IN PDEVICE_OBJECT DeviceObject,
        IN PREQ_SEND_PACKET_DOWNSTREAM pSendPacketDownstream
    )
{
    NTSTATUS                     ntStatus               = STATUS_SUCCESS;
        PCHAP11_SETUP_PACKET pSetupPacket       = &pSendPacketDownstream->SetupPacket;
        PUCHAR                           pucTempBuffer  = NULL;

    if (pSetupPacket->wLength)
    {
        pucTempBuffer = ExAllocatePool(NonPagedPool, pSetupPacket->wLength);
            if (!pucTempBuffer)
                    return STATUS_INSUFFICIENT_RESOURCES;
    }


    ASSERT(DeviceData);

    ntStatus = USBD_SendCommand(DeviceData,
                                DeviceObject,
                                pSetupPacket->wRequest,
                                pSetupPacket->wValue,
                                pSetupPacket->wIndex,
                                                                pSetupPacket->wLength,
                                pucTempBuffer,
                                pSetupPacket->wLength,
                                &pSendPacketDownstream->dwBytes,
                                &pSendPacketDownstream->ulUrbStatus);

    if (NT_SUCCESS(ntStatus) && pSetupPacket->wLength && pSendPacketDownstream->pucBuffer)
    {
        RtlCopyMemory(pSendPacketDownstream->pucBuffer, pucTempBuffer, pSendPacketDownstream->dwBytes);
    }

    if (pSetupPacket->wLength && pSendPacketDownstream->pucBuffer && pucTempBuffer)
    {
        ExFreePool(pucTempBuffer);
        pucTempBuffer = NULL;
    }

    return ntStatus;
}

NTSTATUS
USBDIAG_CreateInitDownstreamDevice(
    PREQ_ENUMERATE_DOWNSTREAM_DEVICE pEnumerate,
    PDEVICE_EXTENSION deviceExtension
    )
{
    NTSTATUS    ntStatus            = STATUS_SUCCESS;
    UCHAR       ucPortNumber        = pEnumerate->ucPortNumber;
    PUSBD_DEVICE_DATA DeviceData    = NULL; 
    BOOLEAN     bLowSpeed           = pEnumerate->bLowSpeed;
    ULONG       MaxPacketSize0      = 8;
    ULONG       DeviceHackFlags;

    PUSB_DEVICE_DESCRIPTOR deviceDescriptor = NULL;
    ULONG deviceDescriptorLength = 0;
        PUSB_CONFIGURATION_DESCRIPTOR configDescriptor = NULL;
        ULONG configDescriptorLength = 0;

    if (deviceExtension->DeviceData[ucPortNumber])
        return STATUS_SUCCESS;

        USBDIAG_KdPrint(("***************************************************\n"));
    USBDIAG_KdPrint(("USBDIAG.SYS: REQ_FUNCTION_CHAP11_CREATE_USBD_DEVICE\n"));
    USBDIAG_KdPrint(("- Downstream device:\n"));
    USBDIAG_KdPrint(("- Port:     %d\n",   pEnumerate->ucPortNumber));
    USBDIAG_KdPrint(("- Lowspeed: %d\n",   pEnumerate->bLowSpeed));

        if (!deviceExtension->RootHubPdo)
                return STATUS_INVALID_PARAMETER;

    ntStatus = USBD_CreateDevice(&DeviceData,
                               deviceExtension->RootHubPdo,
                               bLowSpeed, 
                               MaxPacketSize0,
                               &DeviceHackFlags);

    USBDIAG_KdPrint(("* After USBD_CreateDevice, DeviceData = 0x%x\n", DeviceData));

    if (NT_SUCCESS(ntStatus))
    {
        ASSERT(DeviceData);

        //USBDIAG_KdPrint(("deviceExtension->DeviceData[%d] = 0x%x\n", deviceExtension->DeviceData[ucPortNumber]));


        deviceDescriptorLength = sizeof(USB_DEVICE_DESCRIPTOR);
        deviceDescriptor = ExAllocatePool(NonPagedPool, deviceDescriptorLength);

        if (!deviceDescriptor)
        {
            ntStatus = STATUS_INSUFFICIENT_RESOURCES;
        }
                else
                {
                        configDescriptorLength = 0xFF;
                        configDescriptor = ExAllocatePool(NonPagedPool, configDescriptorLength);
                }

                if (!configDescriptor)
                {
                        ntStatus = STATUS_INSUFFICIENT_RESOURCES;
                }

    }

    if (NT_SUCCESS(ntStatus))
    { 
                USBDIAG_KdPrint(("== Chap9Control calling USBD_InitializeDevice ==\n"));
        ntStatus = USBD_InitializeDevice(DeviceData,
                                                                                 deviceExtension->RootHubPdo,
                                         deviceDescriptor,
                                         deviceDescriptorLength,
                                                                                 configDescriptor,
                                                                                 configDescriptorLength); 

        }

    if (NT_SUCCESS(ntStatus))
    {
        deviceExtension->DeviceData[ucPortNumber] = DeviceData;

        USBDIAG_KdPrint(("SAVING...\n"));
        USBDIAG_KdPrint(("PortNumber: %d\n", ucPortNumber));
        USBDIAG_KdPrint(("DeviceData: 0x%x\n", DeviceData));

        if (configDescriptor)
        {
            deviceExtension->DownstreamConfigDescriptor[ucPortNumber] = configDescriptor;
        }
        else
        {
            USBDIAG_KdPrint(("configDescriptor after USBD_InitializeDevice is NULL\n!"));
        }

        //USBDIAG_KdPrint(("deviceExtension->DeviceData[%d]: 0x%x\n", 
                          //ucPortNumber,
                          //deviceExtension->DeviceData[ucPortNumber]));

        //USBDIAG_KdPrint(("deviceExtension: 0x%x\n", deviceExtension));
        //USBDIAG_KdPrint(("deviceExtension->DeviceData: 0x%x\n", 
                           //deviceExtension->DeviceData));
        //USBDIAG_KdPrint(("&deviceExtension->DeviceData[0]: 0x%x\n", 
                          //&deviceExtension->DeviceData[0]));
        //USBDIAG_KdPrint(("&deviceExtension->DeviceData[%d]: 0x%x\n", 
                          //ucPortNumber,
                          //&deviceExtension->DeviceData[ucPortNumber]));

    }

        if (!deviceExtension->DeviceData[ucPortNumber])
    {
        USBDIAG_KdPrint(("Attempt to create/init downstream device FAILED!\n"));
                ntStatus = STATUS_UNSUCCESSFUL;
    }

    return ntStatus;
}

NTSTATUS
USBDIAG_SetCfgEnableRWu(
    PDEVICE_EXTENSION deviceExtension, 
    PREQ_ENUMERATE_DOWNSTREAM_DEVICE pEnumerate
    )
{
    UCHAR ucPortNumber = pEnumerate->ucPortNumber;
    PUSBD_DEVICE_DATA DeviceData = deviceExtension->DeviceData[ucPortNumber];
    NTSTATUS ntStatus = STATUS_INVALID_PARAMETER;
    PUSB_CONFIGURATION_DESCRIPTOR configDescriptor = deviceExtension->DownstreamConfigDescriptor[ucPortNumber];


        USBDIAG_KdPrint(("*************************************************\n"));
    USBDIAG_KdPrint(("USBDIAG.SYS: REQ_FUNCTION_CHAP11_INIT_USBD_DEVICE\n"));
    USBDIAG_KdPrint(("PortNumber: %d\n", ucPortNumber));
    USBDIAG_KdPrint(("DeviceData: 0x%x\n", DeviceData));
    USBDIAG_KdPrint(("deviceExtension->DeviceData[%d]: 0x%x\n", 
                      ucPortNumber,
                      deviceExtension->DeviceData[ucPortNumber]));

        ASSERT(deviceExtension->RootHubPdo);

        ASSERT(DeviceData);

        USBDIAG_KdPrint(("- Chap9Control calling USBDIAG_Chap11SetConfiguration -\n"));
        if (DeviceData)
        {
                ntStatus = USBDIAG_Chap11SetConfiguration(DeviceData,
                                                                                                  deviceExtension->RootHubPdo);

        USBDIAG_KdPrint(("Set Config On Downstream Device On Port %d %s\n",
                         ucPortNumber,
                         NT_SUCCESS(ntStatus) ? "Passed" : "FAILED"));


                if (NT_SUCCESS(ntStatus))
                {
            if (configDescriptor->bmAttributes & REMOTE_WAKEUP)
            {
                            USBDIAG_KdPrint((" Chap9Control calling USBDIAG_Chap11EnableRemoteWakeup -\n"));
                            ntStatus = USBDIAG_Chap11EnableRemoteWakeup(DeviceData,
                                                                                                                    //deviceExtension->StackDeviceObject);
                                                                                                                    deviceExtension->RootHubPdo);
                USBDIAG_KdPrint(("Enable RWu On Downstream Device On Port %d %s\n",
                                 ucPortNumber,
                                 NT_SUCCESS(ntStatus) ? "Passed" : "FAILED"));
            }
                }
    }
    return ntStatus;
}

NTSTATUS
USBD_SendCommand(
    IN PUSBD_DEVICE_DATA DeviceData,
    IN PDEVICE_OBJECT DeviceObject,
    IN USHORT RequestCode,
    IN USHORT WValue,
    IN USHORT WIndex,
    IN USHORT WLength,
    IN PVOID Buffer,
    IN ULONG BufferLength,
    OUT PULONG BytesReturned,
    OUT USBD_STATUS *UsbStatus
    )
/*++

Routine Description:

    Send a standard USB command on the default pipe.

Arguments:

    DeviceData - ptr to USBD device structure the command will be sent to

    DeviceObject -

    RequestCode -

    WValue - wValue for setup packet

    WIndex - wIndex for setup packet

    WLength - wLength for setup packet

    Buffer - Input/Output Buffer for command                                                                                                                                                                                                                  
  BufferLength - Length of Input/Output buffer.

    BytesReturned - pointer to ulong to copy number of bytes
                    returned (optional)

    UsbStatus - USBD status code returned in the URB.

Return Value:

    STATUS_SUCCESS if successful,
    STATUS_UNSUCCESSFUL otherwise

--*/
{
    NTSTATUS ntStatus;
    PHCD_URB urb = NULL;
    PUSBD_PIPE defaultPipe = &(DeviceData->DefaultPipe);
    PUSB_STANDARD_SETUP_PACKET setupPacket;
    PUSBD_EXTENSION deviceExtension;

    PAGED_CODE();
    //USBDIAG_KdPrint(("enter USBD_SendCommand\n"));
    ASSERT_DEVICE(DeviceData);

    deviceExtension = DeviceObject->DeviceExtension;
    

    if (deviceExtension->DeviceHackFlags & 
        USBD_DEVHACK_SLOW_ENUMERATION) {
        
        //
        // if noncomplience switch is on in the
        // registry we'll pause here to give the
        // device a chance to respond.
        //
        
        LARGE_INTEGER deltaTime;
        deltaTime.QuadPart = 100 * -10000;
        (VOID) KeDelayExecutionThread(KernelMode,
                                      FALSE,
                                      &deltaTime);
    }

    urb = ExAllocatePool(NonPagedPool,
                  sizeof(struct _URB_CONTROL_TRANSFER));

    if (!urb) {
        ntStatus = STATUS_INSUFFICIENT_RESOURCES;
    } else {

        urb->UrbHeader.Length = sizeof(struct _URB_CONTROL_TRANSFER);

        urb->UrbHeader.Function = URB_FUNCTION_CONTROL_TRANSFER;

        setupPacket = (PUSB_STANDARD_SETUP_PACKET) 
            urb->HcdUrbCommonTransfer.Extension.u.SetupPacket;
        setupPacket->RequestCode = RequestCode;
        setupPacket->wValue = WValue;
        setupPacket->wIndex = WIndex;
        setupPacket->wLength = WLength;

        urb->HcdUrbCommonTransfer.hca.HcdEndpoint = defaultPipe->HcdEndpoint;
        urb->HcdUrbCommonTransfer.TransferFlags = USBD_SHORT_TRANSFER_OK;

        // USBD is responsible for setting the transfer direction
        //
        // TRANSFER direction is implied in the command

        if (RequestCode & USB_DEVICE_TO_HOST)
            USBD_SET_TRANSFER_DIRECTION_IN(urb->HcdUrbCommonTransfer.TransferFlags);
        else
            USBD_SET_TRANSFER_DIRECTION_OUT(urb->HcdUrbCommonTransfer.TransferFlags);

        urb->HcdUrbCommonTransfer.TransferBufferLength = BufferLength;
        urb->HcdUrbCommonTransfer.TransferBuffer = Buffer;
        urb->HcdUrbCommonTransfer.TransferBufferMDL = NULL;
        urb->HcdUrbCommonTransfer.UrbLink = NULL;

        //USBDIAG_KdPrint(("SendCommand cmd = 0x%x buffer = 0x%x length = 0x%x direction = 0x%x\n",
                         //setupPacket->RequestCode,
                         //urb->HcdUrbCommonTransfer.TransferBuffer,
                         //urb->HcdUrbCommonTransfer.TransferBufferLength,
                         //urb->HcdUrbCommonTransfer.TransferFlags
                         //));

        ntStatus = USBD_SubmitSynchronousURB((PURB)urb, DeviceObject, DeviceData);

        if (BytesReturned) {
            *BytesReturned = urb->HcdUrbCommonTransfer.TransferBufferLength;
        }            

        if (UsbStatus) {
            *UsbStatus = urb->HcdUrbCommonTransfer.Status;
        }            

        // free the transfer URB

        ExFreePool(urb);

    }

    //USBDIAG_KdPrint(("exit USBD_SendCommand 0x%x\n", ntStatus));

    return ntStatus;
}


NTSTATUS
USBD_CloseEndpoint(
    IN PUSBD_DEVICE_DATA DeviceData,
    IN PDEVICE_OBJECT DeviceObject,
    IN PUSBD_PIPE PipeHandle,
    IN OUT USBD_STATUS *UsbStatus
    )
/*++

Routine Description:

    Close an Endpoint

Arguments:

    DeviceData - ptr to USBD device data structure.

    DeviceObject - USBD device object.

    PipeHandle - USBD pipe handle associated with the endpoint.

Return Value:

    STATUS_SUCCESS if successful,
    STATUS_UNSUCCESSFUL otherwise

--*/
{
    NTSTATUS ntStatus;
    PHCD_URB urb;
    PUSBD_EXTENSION deviceExtension;

    PAGED_CODE();
    //USBDIAG_KdPrint(("enter USBD_CloseEndpoint\n"));
    ASSERT_DEVICE(DeviceData);

    deviceExtension = DeviceObject->DeviceExtension;

    urb = ExAllocatePool(NonPagedPool,
                  sizeof(struct _URB_HCD_CLOSE_ENDPOINT));

    if (!urb) {
        ntStatus = STATUS_INSUFFICIENT_RESOURCES;
    } else {

        urb->UrbHeader.Length = sizeof(struct _URB_HCD_CLOSE_ENDPOINT);
        urb->UrbHeader.Function = URB_FUNCTION_HCD_CLOSE_ENDPOINT;


        urb->HcdUrbCloseEndpoint.HcdEndpoint = PipeHandle->HcdEndpoint;

        //
        // Serialize Close Endpoint requests
        //

        ntStatus = USBD_SubmitSynchronousURB((PURB) urb, DeviceObject, 
                DeviceData);

       if (UsbStatus)
            *UsbStatus = urb->UrbHeader.Status;

        ExFreePool(urb);
    }

    //USBDIAG_KdPrint(("exit USBD_CloseEndpoint 0x%x\n", ntStatus));

    return ntStatus;
}




// downstream manipulation routines done
// **************************************************************************
// **************************************************************************

NTSTATUS
USBDIAG_WaitForWakeup(
    PDEVICE_EXTENSION deviceExtension
    )
{
    NTSTATUS ntStatus;
    
    USBDIAG_KdPrint(("'USBDIAG_WaitForWakeup: Waiting for Wait/Wake completion event\n"));

    USBDIAG_KdPrint(("Waiting for WaitWakeEvent...\n"));
    ntStatus = KeWaitForSingleObject(&deviceExtension->WaitWakeEvent,
                                     Suspended,
                                     KernelMode,
                                     FALSE,
                                     NULL);

    USBDIAG_KdPrint(("'WaitWakeEvent Signalled, Clearing ...\n"));
    KeClearEvent(&deviceExtension->WaitWakeEvent);

    return ntStatus;
}







PWCHAR
GetString(PWCHAR pwc, BOOLEAN MultiSZ)
{
    PWCHAR  psz, p;
    SIZE_T  Size;

    PAGED_CODE();
    psz=pwc;
    while (*psz!='\0' || (MultiSZ && *(psz+1)!='\0')) {
        psz++;
    }

    Size=(psz-pwc+1+(MultiSZ ? 1: 0))*sizeof(*pwc);

    // We use pool here because these pointers are passed
    // to the PnP code who is responsible for freeing them
    if ((p=ExAllocatePool(PagedPool, Size))!=NULL) {
        RtlCopyMemory(p, pwc, Size);
    }

    return(p);
}

#if DBG
ULONG USBD_Debug_Trace_Level =
#ifdef MAX_DEBUG
9;
#else
#ifdef NTKERN
1;
#else
0;
#endif /* NTKERN */
#endif /* MAX_DEBUG */
#endif /* DBG */

#ifdef DEBUG_LOG
struct USBD_LOG_ENTRY {
    CHAR    le_name[4];        // Identifying string
    ULONG    le_info1;        // entry specific info
    ULONG    le_info2;        // entry specific info
    ULONG    le_info3;        // entry specific info
}; /* USBD_LOG_ENTRY */


struct USBD_LOG_ENTRY *LStart = 0;    // No log yet
struct USBD_LOG_ENTRY *LPtr;
struct USBD_LOG_ENTRY *LEnd;
#endif /* DEBUG_LOG */






#if DBG
ULONG
_cdecl
USBD_KdPrintX(
    PCH Format,
    ...
    )
{
    va_list list;
    int i;
    int arg[5];

    if (USBD_Debug_Trace_Level == 1) {
        DbgPrint("USBD: ");
    } else {        
        DbgPrint("'USBD: ");
    }        
    va_start(list, Format);
    for (i=0; i<4; i++)
        arg[i] = va_arg(list, int);

    DbgPrint(Format, arg[0], arg[1], arg[2], arg[3]);

    return 0;
}


VOID
USBD_Warning(
    PUSBD_DEVICE_DATA DeviceData,
    PUCHAR Message,
    BOOLEAN DebugBreak
    )
{                                                                                               
    DbgPrint("USBD: Warning ****************************************************************\n");
    if (DeviceData) {
        DbgPrint("Device PID %04.4x, VID %04.4x\n",     
                 DeviceData->DeviceDescriptor.idProduct, 
                 DeviceData->DeviceDescriptor.idVendor); 
    }
    DbgPrint("%s", Message);

    DbgPrint("******************************************************************************\n");

//    if (DebugBreak) {
//        DBGBREAK();
//    }
}
 

VOID
USBD_Assert(
    IN PVOID FailedAssertion,
    IN PVOID FileName,
    IN ULONG LineNumber,
    IN PCHAR Message
    )
/*++

Routine Description:

    Debug Assert function.

Arguments:

    DeviceObject - pointer to a device object

    Irp          - pointer to an I/O Request Packet

Return Value:


--*/
{
#ifdef NTKERN  
    // this makes the compiler generate a ret
    ULONG stop = 1;
    
assert_loop:
#endif
    // just call the NT assert function and stop
    // in the debugger.
    RtlAssert( FailedAssertion, FileName, LineNumber, Message );

    // loop here to prevent users from going past
    // are assert before we can look at it
#ifdef NTKERN    
    DBGBREAK();
    if (stop) {
        goto assert_loop;
    }        
#endif
    return;
}
#endif /* DBG */

#define DEADMAN_TIMER
#define DEADMAN_TIMEOUT     5000     //timeout in ms
                                     //use a 5 second timeout
typedef struct _USBD_DEADMAN_TIMER {
    PIRP Irp;
    KTIMER TimeoutTimer;
    KDPC TimeoutDpc;
} USBD_DEADMAN_TIMER, *PUSBD_DEADMAN_TIMER;


NTSTATUS
USBD_SubmitSynchronousURB(
    IN PURB Urb,
    IN PDEVICE_OBJECT DeviceObject,
    IN PUSBD_DEVICE_DATA DeviceData
    )
/*++

Routine Description:

    Submit a Urb to HCD synchronously

Arguments:

    Urb - Urb to submit

    DeviceObject USBD device object

Return Value:

    STATUS_SUCCESS if successful,
    STATUS_UNSUCCESSFUL otherwise

--*/
{
    NTSTATUS ntStatus = STATUS_SUCCESS, status;
    PIRP irp;
    KEVENT event;
    IO_STATUS_BLOCK ioStatus;
    PIO_STACK_LOCATION nextStack;
//#ifdef DEADMAN_TIMER
#if 0
    BOOLEAN haveTimer = FALSE;
    PUSBD_DEADMAN_TIMER timer;
#endif /* DEADMAN_TIMER */     

    PAGED_CODE();

    //USBDIAG_KdPrint(("enter USBD_SubmitSynchronousURB\n"));
    ASSERT_DEVICE(DeviceData);

    irp = IoBuildDeviceIoControlRequest(
                IOCTL_INTERNAL_USB_SUBMIT_URB,
                HCD_DEVICE_OBJECT(DeviceObject),
                NULL,
                0,
                NULL,
                0,
                TRUE, /* INTERNAL */
                &event,
                &ioStatus);

    //
    // Call the hc driver to perform the operation.  If the returned status
    // is PENDING, wait for the request to complete.
    //

    KeInitializeEvent(&event, NotificationEvent, FALSE);

    nextStack = IoGetNextIrpStackLocation(irp);
    ASSERT(nextStack != NULL);
    nextStack->Parameters.Others.Argument1 = Urb;

    //
    // initialize flags field
    // for internal request
    //
    Urb->UrbHeader.UsbdFlags = 0;

    //
    // Init the Irp field for transfers
    //

    switch(Urb->UrbHeader.Function) {
    case URB_FUNCTION_CONTROL_TRANSFER:
    case URB_FUNCTION_BULK_OR_INTERRUPT_TRANSFER:
        HC_URB(Urb)->HcdUrbCommonTransfer.hca.HcdIrp = irp;

        if (HC_URB(Urb)->HcdUrbCommonTransfer.TransferBufferMDL == NULL &&
            HC_URB(Urb)->HcdUrbCommonTransfer.TransferBufferLength != 0) {

            if ((HC_URB(Urb)->HcdUrbCommonTransfer.TransferBufferMDL =
                IoAllocateMdl(HC_URB(Urb)->HcdUrbCommonTransfer.TransferBuffer,
                              HC_URB(Urb)->HcdUrbCommonTransfer.TransferBufferLength,
                              FALSE,
                              FALSE,
                              NULL)) == NULL)
                ntStatus = STATUS_INSUFFICIENT_RESOURCES;
            else {
                Urb->UrbHeader.UsbdFlags |= USBD_REQUEST_MDL_ALLOCATED;
                MmBuildMdlForNonPagedPool(HC_URB(Urb)->HcdUrbCommonTransfer.TransferBufferMDL);
            }

        }
        break;
    }

    //USBDIAG_KdPrint(("USBD_SubmitSynchronousURB: calling HCD with URB\n"));

    if (NT_SUCCESS(ntStatus)) {
        // set the renter bit on the URB function code
        Urb->UrbHeader.Function |= 0x2000;
        
        ntStatus = IoCallDriver(HCD_DEVICE_OBJECT(DeviceObject),
                                irp);
    }                                

    //USBDIAG_KdPrint(("ntStatus from IoCallDriver = 0x%x\n", ntStatus));

    status = STATUS_SUCCESS;
    if (ntStatus == STATUS_PENDING) {
    
//#ifdef DEADMAN_TIMER
#if 0

        LARGE_INTEGER dueTime;

        timer = ExAllocatePool(NonPagedPool, sizeof(USBD_DEADMAN_TIMER));
        if (timer) {
            timer->Irp = irp;
            KeInitializeTimer(&timer->TimeoutTimer);
            KeInitializeDpc(&timer->TimeoutDpc,
                            USBD_SyncUrbTimeoutDPC,
                            timer);

            dueTime.QuadPart = -10000 * DEADMAN_TIMEOUT;

            KeSetTimer(&timer->TimeoutTimer,
                       dueTime,
                       &timer->TimeoutDpc);        

            haveTimer = TRUE;
        }
        
#endif /* DEADMAN_TIMER */           

        status = KeWaitForSingleObject(
                            &event,
                            Suspended,
                            KernelMode,
                            FALSE,
                            NULL);  
                            
        ntStatus = ioStatus.Status;
    } else {
        ioStatus.Status = ntStatus;
    }   

//#ifdef DEADMAN_TIMER
#if 0
    //
    // remove our timeoutDPC from the queue
    //
    if (haveTimer) {
        KeCancelTimer(&timer->TimeoutTimer);
        ExFreePool(timer);
    }                
#endif /* DEADMAN_TIMER */

// NOTE:
// mapping is handled by completion routine
// called by HCD

    //USBDIAG_KdPrint(("Leave Synch URB urb status = 0x%x ntStatus = 0x%x\n", Urb->UrbHeader.Status, ntStatus));

    return ntStatus;
}



NTSTATUS 
USBDIAG_SyncGetRootHubPdo(
        IN PDEVICE_OBJECT     StackDeviceObject,
    IN PDEVICE_OBJECT     PhysicalDeviceObject,
    IN OUT PDEVICE_OBJECT *RootHubPdo,
    IN OUT PDEVICE_OBJECT *TopOfHcdStackDeviceObject
    )
{
    NTSTATUS ntStatus, status;
    PIRP irp;
    KEVENT event;
    IO_STATUS_BLOCK ioStatus;
    PIO_STACK_LOCATION nextStack;

    PAGED_CODE();
    
    USBDIAG_KdPrint(("enter USBDIAG_SyncGetRootHubPdo\n"));

    //
    // issue a synchronous request to the RootHubBdo
    //
    KeInitializeEvent(&event, NotificationEvent, FALSE);

        //USBDIAG_KdPrint(("USBDIAG_SyncGetRootHubPdo: ioctl code: 0x%x\n", IOCTL_INTERNAL_USB_GET_PARENT_HUB_INFO));

    irp = IoBuildDeviceIoControlRequest(IOCTL_INTERNAL_USB_GET_PARENT_HUB_INFO,
                                     //StackDeviceObject, //PhysicalDeviceObject,
                                     PhysicalDeviceObject,
                                     NULL,
                                     0,
                                     NULL,
                                     0,
                                     TRUE,  // INTERNAL
                                     &event,
                                     &ioStatus);

    if (NULL == irp) {
        USBDIAG_KdPrint(("USBUSBDIAG_SyncGetRootHubPdo build Irp failed\n"));
        return STATUS_INSUFFICIENT_RESOURCES;
    }
    //
    // Call the class driver to perform the operation.  If the returned
    // status
    // is PENDING, wait for the request to complete.
    //
    nextStack = IoGetNextIrpStackLocation(irp);
        //nextStack = IoGetCurrentIrpStackLocation(irp);

    //
    // pass the URB to the USBD 'class driver'
    //
    nextStack->Parameters.Others.Argument1 = NULL;
    nextStack->Parameters.Others.Argument2 = NULL;
    //nextStack->Parameters.Others.Argument3 = NULL;
    nextStack->Parameters.Others.Argument4 = RootHubPdo;

// _asm int 3

    ntStatus = IoCallDriver(PhysicalDeviceObject, irp);

    USBDIAG_KdPrint(("return from IoCallDriver USBD %x\n", ntStatus));

    if (ntStatus == STATUS_PENDING) 
    {
        USBDIAG_KdPrint(("Wait for single object\n"));

        status = KeWaitForSingleObject(&event,
                                       Suspended,
                                       KernelMode,
                                       FALSE,
                                       NULL);

        USBDIAG_KdPrint(("Wait for single object, returned %x\n", status));
    } else {
        ioStatus.Status = ntStatus;
    }

    ntStatus = ioStatus.Status;

    USBDIAG_KdPrint(("exit USBDIAG_SyncGetRootHubPdo with ntStatus: 0x%x)\n", ntStatus));

    return ntStatus;
}


//#ifdef DEADMAN_TIMER
#if 0
VOID
USBD_SyncUrbTimeoutDPC(
    IN PKDPC Dpc,
    IN PVOID DeferredContext,
    IN PVOID SystemArgument1,
    IN PVOID SystemArgument2
    )
/*++

Routine Description:

    This routine runs at DISPATCH_LEVEL IRQL. 

    
    
Arguments:

    Dpc - Pointer to the DPC object.

    DeferredContext - 

    SystemArgument1 - not used.
    
    SystemArgument2 - not used.

Return Value:

    None.

--*/
{
    PUSBD_DEADMAN_TIMER timer;
#if DBG
    BOOLEAN status;
#endif

    timer = DeferredContext;    

    
#if DBG
    status = 
#endif
        IoCancelIrp(timer->Irp);

#if DBG
    USBD_ASSERT(status == TRUE);    
#endif    
}
#endif /* DEADMAN_TIMER */

NTSTATUS
USBD_SetPdoRegistryParameter (
    IN PDEVICE_OBJECT PhysicalDeviceObject,
    IN PWCHAR KeyName,
    IN ULONG KeyNameLength,
    IN PVOID Data,
    IN ULONG DataLength,
    IN ULONG KeyType,
    IN ULONG DevInstKeyType
    )
/*++

Routine Description:

Arguments:

Return Value:

--*/
{
    NTSTATUS ntStatus;
    HANDLE handle;
    UNICODE_STRING keyNameUnicodeString;

    PAGED_CODE();

    RtlInitUnicodeString(&keyNameUnicodeString, KeyName);

    ntStatus=IoOpenDeviceRegistryKey(PhysicalDeviceObject,
                                     DevInstKeyType,
                                     STANDARD_RIGHTS_ALL,
                                     &handle);


    if (NT_SUCCESS(ntStatus)) {

        USBD_SetRegistryKeyValue(handle,
                                 &keyNameUnicodeString,
                                 Data,
                                 DataLength,
                                 KeyType);

        ZwClose(handle);
    }

    //USBDIAG_KdPrint((" RtlQueryRegistryValues status 0x%x\n"));

    return ntStatus;
}


NTSTATUS
USBD_SetRegistryKeyValue (
    IN HANDLE Handle,
    IN PUNICODE_STRING KeyNameUnicodeString,
    IN PVOID Data,
    IN ULONG DataLength,
    IN ULONG KeyType
    )
/*++

Routine Description:

Arguments:

Return Value:

--*/
{
    NTSTATUS ntStatus = STATUS_INSUFFICIENT_RESOURCES;

    PAGED_CODE();

    //
    // Create the key or open it, as appropriate based on the caller's
    // wishes.
    //

    ntStatus = ZwSetValueKey(Handle,
                             KeyNameUnicodeString,
                             0,
                             KeyType,
                             Data,
                             DataLength);

    //USBDIAG_KdPrint((" ZwSetKeyValue = 0x%x\n", ntStatus));

    return ntStatus;
}