display.c

微软DDK关于USB驱动编程的重要工具USBVIEW的源代码,通过该工具可以查看系统设备管理器中所有USB设备的信息,对于利用DDK编写USB驱动程序非常有帮助.

            break;
    }

    switch (wHubChar & 0x0018)
    {
        case 0x0000:
            AppendTextBuffer("Over-current Protection: Global\r\n");
            break;

        case 0x0008:
            AppendTextBuffer("Over-current Protection: Individual\r\n");
            break;

        case 0x0010:
        case 0x0018:
            AppendTextBuffer("No Over-current Protection (Bus Power Only)\r\n");
            break;
    }

    AppendTextBuffer("\r\n");

}

//*****************************************************************************
//
// DisplayConnectionInfo()
//
// ConnectInfo - Info about the connection.
//
//*****************************************************************************

VOID
DisplayConnectionInfo (
    PUSB_NODE_CONNECTION_INFORMATION    ConnectInfo,
    PSTRING_DESCRIPTOR_NODE             StringDescs
)
{

    if (ConnectInfo->ConnectionStatus == NoDeviceConnected)
    {
        AppendTextBuffer("ConnectionStatus: NoDeviceConnected\r\n");
    }
    else
    {
        PCHAR VendorString;

        AppendTextBuffer("Device Descriptor:\r\n");

        AppendTextBuffer("bcdUSB:             0x%04X\r\n",
                         ConnectInfo->DeviceDescriptor.bcdUSB);

        AppendTextBuffer("bDeviceClass:         0x%02X\r\n",
                         ConnectInfo->DeviceDescriptor.bDeviceClass);

        AppendTextBuffer("bDeviceSubClass:      0x%02X\r\n",
                         ConnectInfo->DeviceDescriptor.bDeviceSubClass);

        AppendTextBuffer("bDeviceProtocol:      0x%02X\r\n",
                         ConnectInfo->DeviceDescriptor.bDeviceProtocol);

        AppendTextBuffer("bMaxPacketSize0:      0x%02X (%d)\r\n",
                         ConnectInfo->DeviceDescriptor.bMaxPacketSize0,
                         ConnectInfo->DeviceDescriptor.bMaxPacketSize0);

        VendorString = GetVendorString(ConnectInfo->DeviceDescriptor.idVendor);

        if (VendorString != NULL)
        {
            AppendTextBuffer("idVendor:           0x%04X (%s)\r\n",
                             ConnectInfo->DeviceDescriptor.idVendor,
                             VendorString);
        }
        else
        {
            AppendTextBuffer("idVendor:           0x%04X\r\n",
                             ConnectInfo->DeviceDescriptor.idVendor);
        }

        AppendTextBuffer("idProduct:          0x%04X\r\n",
                         ConnectInfo->DeviceDescriptor.idProduct);

        AppendTextBuffer("bcdDevice:          0x%04X\r\n",
                         ConnectInfo->DeviceDescriptor.bcdDevice);

        AppendTextBuffer("iManufacturer:        0x%02X\r\n",
                         ConnectInfo->DeviceDescriptor.iManufacturer);

        if (ConnectInfo->DeviceDescriptor.iManufacturer)
        {
            DisplayStringDescriptor(ConnectInfo->DeviceDescriptor.iManufacturer,
                                    StringDescs);
        }

        AppendTextBuffer("iProduct:             0x%02X\r\n",
                         ConnectInfo->DeviceDescriptor.iProduct);

        if (ConnectInfo->DeviceDescriptor.iProduct)
        {
            DisplayStringDescriptor(ConnectInfo->DeviceDescriptor.iProduct,
                                    StringDescs);
        }

        AppendTextBuffer("iSerialNumber:        0x%02X\r\n",
                         ConnectInfo->DeviceDescriptor.iSerialNumber);

        if (ConnectInfo->DeviceDescriptor.iSerialNumber)
        {
            DisplayStringDescriptor(ConnectInfo->DeviceDescriptor.iSerialNumber,
                                    StringDescs);
        }

        AppendTextBuffer("bNumConfigurations:   0x%02X\r\n",
                         ConnectInfo->DeviceDescriptor.bNumConfigurations);

        AppendTextBuffer("\r\nConnectionStatus: %s\r\n",
                         ConnectionStatuses[ConnectInfo->ConnectionStatus]);

        AppendTextBuffer("Current Config Value: 0x%02X\r\n",
                         ConnectInfo->CurrentConfigurationValue);

        if (ConnectInfo->LowSpeed)
        {
            AppendTextBuffer("Device Bus Speed:      Low\r\n");
        }
        else
        {
            AppendTextBuffer("Device Bus Speed:     Full\r\n");
        }

        AppendTextBuffer("Device Address:       0x%02X\r\n",
                         ConnectInfo->DeviceAddress);

        AppendTextBuffer("Open Pipes:             %2d\r\n",
                         ConnectInfo->NumberOfOpenPipes);

        if (ConnectInfo->NumberOfOpenPipes)
        {
            DisplayPipeInfo(ConnectInfo->NumberOfOpenPipes,
                            ConnectInfo->PipeList);
        }
    }
}

//*****************************************************************************
//
// DisplayPipeInfo()
//
// NumPipes - Number of pipe for we info should be displayed.
//
// PipeInfo - Info about the pipes.
//
//*****************************************************************************

VOID
DisplayPipeInfo (
    ULONG           NumPipes,
    USB_PIPE_INFO  *PipeInfo
)
{
    ULONG i;

    for (i=0; i<NumPipes; i++)
    {
        DisplayEndpointDescriptor(&PipeInfo[i].EndpointDescriptor);
    }

}


//*****************************************************************************
//
// DisplayConfigDesc()
//
// ConfigDesc - The Configuration Descriptor, and associated Interface and
// EndpointDescriptors
//
//*****************************************************************************

VOID
DisplayConfigDesc (
    PUSB_CONFIGURATION_DESCRIPTOR   ConfigDesc,
    PSTRING_DESCRIPTOR_NODE         StringDescs
)
{
    PUCHAR                  descEnd;
    PUSB_COMMON_DESCRIPTOR  commonDesc;
    UCHAR                   bInterfaceClass;
    UCHAR                   bInterfaceSubClass;
    BOOL                    displayUnknown;

    bInterfaceClass = 0;

    descEnd = (PUCHAR)ConfigDesc + ConfigDesc->wTotalLength;

    commonDesc = (PUSB_COMMON_DESCRIPTOR)ConfigDesc;

    while ((PUCHAR)commonDesc + sizeof(USB_COMMON_DESCRIPTOR) < descEnd &&
           (PUCHAR)commonDesc + commonDesc->bLength <= descEnd)
    {
        displayUnknown = FALSE;

        switch (commonDesc->bDescriptorType)
        {
            case USB_CONFIGURATION_DESCRIPTOR_TYPE:
                if (commonDesc->bLength != sizeof(USB_CONFIGURATION_DESCRIPTOR))
                {
                    OOPS();
                    displayUnknown = TRUE;
                    break;
                }
                DisplayConfigurationDescriptor((PUSB_CONFIGURATION_DESCRIPTOR)commonDesc,
                                               StringDescs);
                break;

            case USB_INTERFACE_DESCRIPTOR_TYPE:
                if ((commonDesc->bLength != sizeof(USB_INTERFACE_DESCRIPTOR)) &&
                    (commonDesc->bLength != sizeof(USB_INTERFACE_DESCRIPTOR2)))
                {
                    OOPS();
                    displayUnknown = TRUE;
                    break;
                }
                bInterfaceClass = ((PUSB_INTERFACE_DESCRIPTOR)commonDesc)->bInterfaceClass;
                bInterfaceSubClass = ((PUSB_INTERFACE_DESCRIPTOR)commonDesc)->bInterfaceSubClass;

                DisplayInterfaceDescriptor((PUSB_INTERFACE_DESCRIPTOR)commonDesc,
                                           StringDescs);
                break;

            case USB_ENDPOINT_DESCRIPTOR_TYPE:
                if ((commonDesc->bLength != sizeof(USB_ENDPOINT_DESCRIPTOR)) &&
                    (commonDesc->bLength != sizeof(USB_ENDPOINT_DESCRIPTOR2)))
                {
                    OOPS();
                    displayUnknown = TRUE;
                    break;
                }
                DisplayEndpointDescriptor((PUSB_ENDPOINT_DESCRIPTOR)commonDesc);
                break;

            case USB_HID_DESCRIPTOR_TYPE:
                if (commonDesc->bLength < sizeof(USB_HID_DESCRIPTOR))
                {
                    OOPS();
                    displayUnknown = TRUE;
                    break;
                }
                DisplayHidDescriptor((PUSB_HID_DESCRIPTOR)commonDesc);
                break;

            default:
                switch (bInterfaceClass)
                {
                    case USB_DEVICE_CLASS_AUDIO:
                        displayUnknown = !DisplayAudioDescriptor(
                                              (PUSB_AUDIO_COMMON_DESCRIPTOR)commonDesc,
                                              bInterfaceSubClass);
                        break;

                    default:
                        displayUnknown = TRUE;
                        break;
                }
                break;
        }

        if (displayUnknown)
        {
            DisplayUnknownDescriptor(commonDesc);
        }

        (PUCHAR)commonDesc += commonDesc->bLength;
    }
}


//*****************************************************************************
//
// DisplayConfigurationDescriptor()
//
//*****************************************************************************

VOID
DisplayConfigurationDescriptor (
    PUSB_CONFIGURATION_DESCRIPTOR   ConfigDesc,
    PSTRING_DESCRIPTOR_NODE         StringDescs
)
{

    AppendTextBuffer("\r\nConfiguration Descriptor:\r\n");

    AppendTextBuffer("wTotalLength:       0x%04X\r\n",
                     ConfigDesc->wTotalLength);

    AppendTextBuffer("bNumInterfaces:       0x%02X\r\n",
                     ConfigDesc->bNumInterfaces);

    AppendTextBuffer("bConfigurationValue:  0x%02X\r\n",
                     ConfigDesc->bConfigurationValue);

    AppendTextBuffer("iConfiguration:       0x%02X\r\n",
                     ConfigDesc->iConfiguration);

    if (ConfigDesc->iConfiguration)
    {
        DisplayStringDescriptor(ConfigDesc->iConfiguration,
                                StringDescs);
    }

    AppendTextBuffer("bmAttributes:         0x%02X (",
                     ConfigDesc->bmAttributes);

    if (ConfigDesc->bmAttributes & 0x80)
    {
        AppendTextBuffer("Bus Powered ");
    }

    if (ConfigDesc->bmAttributes & 0x40)
    {
        AppendTextBuffer("Self Powered ");
    }

    if (ConfigDesc->bmAttributes & 0x20)
    {
        AppendTextBuffer("Remote Wakeup");
    }

    AppendTextBuffer(")\r\n");

    AppendTextBuffer("MaxPower:             0x%02X (%d Ma)\r\n",
                     ConfigDesc->MaxPower,
                     ConfigDesc->MaxPower * 2);

}

//*****************************************************************************
//
// DisplayInterfaceDescriptor()
//
//*****************************************************************************

VOID
DisplayInterfaceDescriptor (
    PUSB_INTERFACE_DESCRIPTOR   InterfaceDesc,
    PSTRING_DESCRIPTOR_NODE     StringDescs
)
{
    PCHAR pStr;

    AppendTextBuffer("\r\nInterface Descriptor:\r\n");

    AppendTextBuffer("bInterfaceNumber:     0x%02X\r\n",
                     InterfaceDesc->bInterfaceNumber);

    AppendTextBuffer("bAlternateSetting:    0x%02X\r\n",
                     InterfaceDesc->bAlternateSetting);

    AppendTextBuffer("bNumEndpoints:        0x%02X\r\n",
                     InterfaceDesc->bNumEndpoints);

    AppendTextBuffer("bInterfaceClass:      0x%02X",
                     InterfaceDesc->bInterfaceClass);

    pStr = "\r\n";

    switch (InterfaceDesc->bInterfaceClass)
    {
        case USB_DEVICE_CLASS_AUDIO:
            pStr = " (Audio)\r\n";
            break;

        case USB_DEVICE_CLASS_HUMAN_INTERFACE:
            pStr = " (HID)\r\n";
            break;

        case USB_DEVICE_CLASS_HUB:
            pStr = " (Hub)\r\n";
            break;

        default:
            break;
    }

    AppendTextBuffer(pStr);

    AppendTextBuffer("bInterfaceSubClass:   0x%02X",
                     InterfaceDesc->bInterfaceSubClass);

    pStr = "\r\n";

    switch (InterfaceDesc->bInterfaceClass)
    {
        case USB_DEVICE_CLASS_AUDIO:
            switch (InterfaceDesc->bInterfaceSubClass)
            {
                case USB_AUDIO_SUBCLASS_AUDIOCONTROL:
                    pStr = " (Audio Control)\r\n";