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

源码开发语言/平台
当前位置：首页 > 源码/资料 > Windows编程 > 通讯编程 > 查看源码
display.c
资源名称：VC++USB.rar　[点击查看]
上传用户：hnzyys
上传日期：2015-09-10
资源大小：423k
文件大小：32k
源码类别：

通讯编程

开发平台：

Visual C++

display.c：源码内容
  1. /*++
  3. Copyright (c) 1997-1998 Microsoft Corporation
  5. Module Name:
  7. DISPLAY.C
  9. Abstract:
  11. This source file contains the routines which update the edit control
  12. to display information about the selected USB device.
  14. Environment:
  16. user mode
  18. Revision History:
  20. 04-25-97 : created
  22. --*/
  24. //*****************************************************************************
  25. // I N C L U D E S
  26. //*****************************************************************************
  28. #include <windows.h>
  29. #include <basetyps.h>
  31. #include "vndrlist.h"
  32. #include "usbview.h"
  33. #include "usb100.h"
  35. //*****************************************************************************
  36. // D E F I N E S
  37. //*****************************************************************************
  39. #define BUFFERALLOCINCREMENT        8192
  40. #define BUFFERMINFREESPACE          1024
  42. //*****************************************************************************
  43. // T Y P E D E F S
  44. //*****************************************************************************
  46. //*****************************************************************************
  47. // G L O B A L S    P R I V A T E    T O    T H I S    F I L E
  48. //*****************************************************************************
  50. // Workspace for text info which is used to update the edit control
  51. //
  52. CHAR *TextBuffer = NULL;
  53. int   TextBufferLen = 0;
  54. int   TextBufferPos = 0;
  56. //*****************************************************************************
  57. // L O C A L    F U N C T I O N    P R O T O T Y P E S
  58. //*****************************************************************************
  60. VOID
  61. DisplayHubInfo (
  62.     PUSB_HUB_INFORMATION HubInfo
  63. );
  65. VOID
  66. DisplayConnectionInfo (
  67.     PUSB_NODE_CONNECTION_INFORMATION    ConnectInfo,
  68.     PSTRING_DESCRIPTOR_NODE             StringDescs
  69. );
  71. VOID
  72. DisplayPipeInfo (
  73.     ULONG           NumPipes,
  74.     USB_PIPE_INFO  *PipeInfo
  75. );
  77. VOID
  78. DisplayConfigDesc (
  79.     PUSB_CONFIGURATION_DESCRIPTOR   ConfigDesc,
  80.     PSTRING_DESCRIPTOR_NODE         StringDescs
  81. );
  83. VOID
  84. DisplayConfigurationDescriptor (
  85.     PUSB_CONFIGURATION_DESCRIPTOR   ConfigDesc,
  86.     PSTRING_DESCRIPTOR_NODE         StringDescs
  87. );
  89. VOID
  90. DisplayInterfaceDescriptor (
  91.     PUSB_INTERFACE_DESCRIPTOR   InterfaceDesc,
  92.     PSTRING_DESCRIPTOR_NODE     StringDescs
  93. );
  95. VOID
  96. DisplayEndpointDescriptor (
  97.     PUSB_ENDPOINT_DESCRIPTOR    EndpointDesc
  98. );
  100. VOID
  101. DisplayHidDescriptor (
  102.     PUSB_HID_DESCRIPTOR         HidDesc
  103. );
  105. VOID
  106. DisplayStringDescriptor (
  107.     UCHAR                       Index,
  108.     PSTRING_DESCRIPTOR_NODE     StringDescs
  109. );
  111. VOID
  112. DisplayUnknownDescriptor (
  113.     PUSB_COMMON_DESCRIPTOR      CommonDesc
  114. );
  116. PCHAR
  117. GetVendorString (
  118.     USHORT     idVendor
  119. );
  121. //*****************************************************************************
  122. // L O C A L    F U N C T I O N S
  123. //*****************************************************************************
  126. //*****************************************************************************
  127. //
  128. // CreateTextBuffer()
  129. //
  130. //*****************************************************************************
  132. BOOL
  133. CreateTextBuffer (
  134. )
  135. {
  136.     // Allocate the buffer
  137.     //
  138.     TextBuffer = ALLOC(BUFFERALLOCINCREMENT);
  140.     if (TextBuffer == NULL)
  141.     {
  142.         OOPS();
  144.         return FALSE;
  145.     }
  147.     TextBufferLen = BUFFERALLOCINCREMENT;
  149.     // Reset the buffer position and terminate the buffer
  150.     //
  151.     *TextBuffer = 0;
  152.     TextBufferPos = 0;
  154.     return TRUE;
  155. }
  158. //*****************************************************************************
  159. //
  160. // DestroyTextBuffer()
  161. //
  162. //*****************************************************************************
  164. VOID
  165. DestroyTextBuffer (
  166. )
  167. {
  168.     if (TextBuffer != NULL)
  169.     {
  170.         FREE(TextBuffer);
  172.         TextBuffer = NULL;
  173.     }
  174. }
  177. //*****************************************************************************
  178. //
  179. // ResetTextBuffer()
  180. //
  181. //*****************************************************************************
  183. BOOL
  184. ResetTextBuffer (
  185. )
  186. {
  187.     // Fail if the text buffer has not been allocated
  188.     //
  189.     if (TextBuffer == NULL)
  190.     {
  191.         OOPS();
  193.         return FALSE;
  194.     }
  196.     // Reset the buffer position and terminate the buffer
  197.     //
  198.     *TextBuffer = 0;
  199.     TextBufferPos = 0;
  201.     return TRUE;
  202. }
  204. //*****************************************************************************
  205. //
  206. // AppendTextBuffer()
  207. //
  208. //*****************************************************************************
  210. VOID __cdecl
  211. AppendTextBuffer (
  212.     LPCTSTR lpFormat,
  213.     ...
  214. )
  215. {
  216.     va_list arglist;
  218.     va_start(arglist, lpFormat);
  220.     // Make sure we have a healthy amount of space free in the buffer,
  221.     // reallocating the buffer if necessary.
  222.     //
  223.     if (TextBufferLen - TextBufferPos < BUFFERMINFREESPACE)
  224.     {
  225.         CHAR *TextBufferTmp;
  227.         TextBufferTmp = REALLOC(TextBuffer, TextBufferLen+BUFFERALLOCINCREMENT);
  229.         if (TextBufferTmp != NULL)
  230.         {
  231.             TextBuffer = TextBufferTmp;
  232.             TextBufferLen += BUFFERALLOCINCREMENT;
  233.         }
  234.         else
  235.         {
  236.             // If GlobalReAlloc fails, the original memory is not freed,
  237.             // and the original handle and pointer are still valid.
  238.             //
  239.             OOPS();
  241.             return;
  242.         }
  243.     }
  245.     // Add the text to the end of the buffer, updating the buffer position.
  246.     //
  247.     TextBufferPos += wvsprintf(TextBuffer + TextBufferPos,
  248.                                lpFormat,
  249.                                arglist);
  250. }
  254. //*****************************************************************************
  255. //
  256. // UpdateEditControl()
  257. //
  258. // hTreeItem - Handle of selected TreeView item for which information should
  259. // be displayed in the edit control.
  260. //
  261. //*****************************************************************************
  263. VOID
  264. UpdateEditControl (
  265.     HWND      hEditWnd,
  266.     HWND      hTreeWnd,
  267.     HTREEITEM hTreeItem
  268. )
  269. {
  270.     TV_ITEM         tvi;
  271.     PUSBDEVICEINFO  info;
  273.     // Start with an empty text buffer.
  274.     //
  275.     if (!ResetTextBuffer())
  276.     {
  277.         return;
  278.     }
  280.     //
  281.     // Get the name of the TreeView item, along with the a pointer to the
  282.     // info we stored about the item in the item's lParam.
  283.     //
  285.     tvi.mask = TVIF_HANDLE | TVIF_TEXT | TVIF_PARAM;
  286.     tvi.hItem = hTreeItem;
  287.     tvi.pszText = (LPSTR)TextBuffer;
  288.     tvi.cchTextMax = TextBufferLen-2;  // leave space for "rn'
  290.     TreeView_GetItem(hTreeWnd,
  291.                      &tvi);
  293.     info = (PUSBDEVICEINFO)tvi.lParam;
  295.     //
  296.     // If we didn't store any info for the item, just display the item's
  297.     // name, else display the info we stored for the item.
  298.     //
  299.     if (info != NULL)
  300.     {
  301.         if (info->ConnectionInfo == NULL)
  302.         {
  303.             // Must be Root HUB, external devices have Connection Info
  304.             //
  305.             AppendTextBuffer("Root Hub: %srn",
  306.                              info->HubName);
  308.             DisplayHubInfo(&info->HubInfo->u.HubInformation);
  309.         }
  310.         else
  311.         {
  312.             if (info->HubInfo != NULL)
  313.             {
  314.                 // Must be external HUB external
  315.                 //
  316.                 AppendTextBuffer("External Hub: %srn",
  317.                                  info->HubName);
  319.                 DisplayHubInfo(&info->HubInfo->u.HubInformation);
  320.             }
  321.             else
  322.             {
  323.                 // Must be external non-HUB device.  Nothing special to
  324.                 // display here that isn't displayed in connection info
  325.                 // below.
  326.             }
  328.             // Display info common to any external device
  329.             //
  330.             DisplayConnectionInfo(info->ConnectionInfo,
  331.                                   info->StringDescs);
  333.             if (info->ConfigDesc)
  334.             {
  335.                 DisplayConfigDesc((PUSB_CONFIGURATION_DESCRIPTOR)(info->ConfigDesc + 1),
  336.                                   info->StringDescs);
  337.             }
  339.         }
  340.     }
  342.     // All done formatting text buffer with info, now update the edit
  343.     // control with the contents of the text buffer
  344.     //
  345.     SetWindowText(hEditWnd, TextBuffer);
  346. }
  349. //*****************************************************************************
  350. //
  351. // DisplayHubInfo()
  352. //
  353. // HubInfo - Info about the hub.
  354. //
  355. //*****************************************************************************
  357. VOID
  358. DisplayHubInfo (
  359.     PUSB_HUB_INFORMATION    HubInfo
  360. )
  361. {
  363.     USHORT wHubChar;
  365.     AppendTextBuffer("Hub Power:               %srn",
  366.                      HubInfo->HubIsBusPowered ?
  367.                      "Bus Power" : "Self Power");
  369.     AppendTextBuffer("Number of Ports:         %drn",
  370.                      HubInfo->HubDescriptor.bNumberOfPorts);
  372.     wHubChar = HubInfo->HubDescriptor.wHubCharacteristics;
  374.     switch (wHubChar & 0x0003)
  375.     {
  376.         case 0x0000:
  377.             AppendTextBuffer("Power switching:         Gangedrn");
  378.             break;
  380.         case 0x0001:
  381.             AppendTextBuffer("Power switching:         Individualrn");
  382.             break;
  384.         case 0x0002:
  385.         case 0x0003:
  386.             AppendTextBuffer("Power switching:         Nonern");
  387.             break;
  388.     }
  390.     switch (wHubChar & 0x0004)
  391.     {
  392.         case 0x0000:
  393.             AppendTextBuffer("Compound device:         Norn");
  394.             break;
  396.         case 0x0004:
  397.             AppendTextBuffer("Compound device:         Yesrn");
  398.             break;
  399.     }
  401.     switch (wHubChar & 0x0018)
  402.     {
  403.         case 0x0000:
  404.             AppendTextBuffer("Over-current Protection: Globalrn");
  405.             break;
  407.         case 0x0008:
  408.             AppendTextBuffer("Over-current Protection: Individualrn");
  409.             break;
  411.         case 0x0010:
  412.         case 0x0018:
  413.             AppendTextBuffer("No Over-current Protection (Bus Power Only)rn");
  414.             break;
  415.     }
  417.     AppendTextBuffer("rn");
  419. }
  421. //*****************************************************************************
  422. //
  423. // DisplayConnectionInfo()
  424. //
  425. // ConnectInfo - Info about the connection.
  426. //
  427. //*****************************************************************************
  429. VOID
  430. DisplayConnectionInfo (
  431.     PUSB_NODE_CONNECTION_INFORMATION    ConnectInfo,
  432.     PSTRING_DESCRIPTOR_NODE             StringDescs
  433. )
  434. {
  436.     if (ConnectInfo->ConnectionStatus == NoDeviceConnected)
  437.     {
  438.         AppendTextBuffer("ConnectionStatus: NoDeviceConnectedrn");
  439.     }
  440.     else
  441.     {
  442.         PCHAR VendorString;
  444.         AppendTextBuffer("Device Descriptor:rn");
  446.         AppendTextBuffer("bcdUSB:             0x%04Xrn",
  447.                          ConnectInfo->DeviceDescriptor.bcdUSB);
  449.         AppendTextBuffer("bDeviceClass:         0x%02Xrn",
  450.                          ConnectInfo->DeviceDescriptor.bDeviceClass);
  452.         AppendTextBuffer("bDeviceSubClass:      0x%02Xrn",
  453.                          ConnectInfo->DeviceDescriptor.bDeviceSubClass);
  455.         AppendTextBuffer("bDeviceProtocol:      0x%02Xrn",
  456.                          ConnectInfo->DeviceDescriptor.bDeviceProtocol);
  458.         AppendTextBuffer("bMaxPacketSize0:      0x%02X (%d)rn",
  459.                          ConnectInfo->DeviceDescriptor.bMaxPacketSize0,
  460.                          ConnectInfo->DeviceDescriptor.bMaxPacketSize0);
  462.         VendorString = GetVendorString(ConnectInfo->DeviceDescriptor.idVendor);
  464.         if (VendorString != NULL)
  465.         {
  466.             AppendTextBuffer("idVendor:           0x%04X (%s)rn",
  467.                              ConnectInfo->DeviceDescriptor.idVendor,
  468.                              VendorString);
  469.         }
  470.         else
  471.         {
  472.             AppendTextBuffer("idVendor:           0x%04Xrn",
  473.                              ConnectInfo->DeviceDescriptor.idVendor);
  474.         }
  476.         AppendTextBuffer("idProduct:          0x%04Xrn",
  477.                          ConnectInfo->DeviceDescriptor.idProduct);
  479.         AppendTextBuffer("bcdDevice:          0x%04Xrn",
  480.                          ConnectInfo->DeviceDescriptor.bcdDevice);
  482.         AppendTextBuffer("iManufacturer:        0x%02Xrn",
  483.                          ConnectInfo->DeviceDescriptor.iManufacturer);
  485.         if (ConnectInfo->DeviceDescriptor.iManufacturer)
  486.         {
  487.             DisplayStringDescriptor(ConnectInfo->DeviceDescriptor.iManufacturer,
  488.                                     StringDescs);
  489.         }
  491.         AppendTextBuffer("iProduct:             0x%02Xrn",
  492.                          ConnectInfo->DeviceDescriptor.iProduct);
  494.         if (ConnectInfo->DeviceDescriptor.iProduct)
  495.         {
  496.             DisplayStringDescriptor(ConnectInfo->DeviceDescriptor.iProduct,
  497.                                     StringDescs);
  498.         }
  500.         AppendTextBuffer("iSerialNumber:        0x%02Xrn",
  501.                          ConnectInfo->DeviceDescriptor.iSerialNumber);
  503.         if (ConnectInfo->DeviceDescriptor.iSerialNumber)
  504.         {
  505.             DisplayStringDescriptor(ConnectInfo->DeviceDescriptor.iSerialNumber,
  506.                                     StringDescs);
  507.         }
  509.         AppendTextBuffer("bNumConfigurations:   0x%02Xrn",
  510.                          ConnectInfo->DeviceDescriptor.bNumConfigurations);
  512.         AppendTextBuffer("rnConnectionStatus: %srn",
  513.                          ConnectionStatuses[ConnectInfo->ConnectionStatus]);
  515.         AppendTextBuffer("Current Config Value: 0x%02Xrn",
  516.                          ConnectInfo->CurrentConfigurationValue);
  518.         if (ConnectInfo->LowSpeed)
  519.         {
  520.             AppendTextBuffer("Device Bus Speed:      Lowrn");
  521.         }
  522.         else
  523.         {
  524.             AppendTextBuffer("Device Bus Speed:     Fullrn");
  525.         }
  527.         AppendTextBuffer("Device Address:       0x%02Xrn",
  528.                          ConnectInfo->DeviceAddress);
  530.         AppendTextBuffer("Open Pipes:             %2drn",
  531.                          ConnectInfo->NumberOfOpenPipes);
  533.         if (ConnectInfo->NumberOfOpenPipes)
  534.         {
  535.             DisplayPipeInfo(ConnectInfo->NumberOfOpenPipes,
  536.                             ConnectInfo->PipeList);
  537.         }
  538.     }
  539. }
  541. //*****************************************************************************
  542. //
  543. // DisplayPipeInfo()
  544. //
  545. // NumPipes - Number of pipe for we info should be displayed.
  546. //
  547. // PipeInfo - Info about the pipes.
  548. //
  549. //*****************************************************************************
  551. VOID
  552. DisplayPipeInfo (
  553.     ULONG           NumPipes,
  554.     USB_PIPE_INFO  *PipeInfo
  555. )
  556. {
  557.     ULONG i;
  559.     for (i=0; i<NumPipes; i++)
  560.     {
  561.         DisplayEndpointDescriptor(&PipeInfo[i].EndpointDescriptor);
  562.     }
  564. }
  567. //*****************************************************************************
  568. //
  569. // DisplayConfigDesc()
  570. //
  571. // ConfigDesc - The Configuration Descriptor, and associated Interface and
  572. // EndpointDescriptors
  573. //
  574. //*****************************************************************************
  576. VOID
  577. DisplayConfigDesc (
  578.     PUSB_CONFIGURATION_DESCRIPTOR   ConfigDesc,
  579.     PSTRING_DESCRIPTOR_NODE         StringDescs
  580. )
  581. {
  582.     PUCHAR                  descEnd;
  583.     PUSB_COMMON_DESCRIPTOR  commonDesc;
  584.     UCHAR                   bInterfaceClass;
  585.     UCHAR                   bInterfaceSubClass;
  586.     BOOL                    displayUnknown;
  588.     bInterfaceClass = 0;
  590.     descEnd = (PUCHAR)ConfigDesc + ConfigDesc->wTotalLength;
  592.     commonDesc = (PUSB_COMMON_DESCRIPTOR)ConfigDesc;
  594.     while ((PUCHAR)commonDesc + sizeof(USB_COMMON_DESCRIPTOR) < descEnd &&
  595.            (PUCHAR)commonDesc + commonDesc->bLength <= descEnd)
  596.     {
  597.         displayUnknown = FALSE;
  599.         switch (commonDesc->bDescriptorType)
  600.         {
  601.             case USB_CONFIGURATION_DESCRIPTOR_TYPE:
  602.                 if (commonDesc->bLength != sizeof(USB_CONFIGURATION_DESCRIPTOR))
  603.                 {
  604.                     OOPS();
  605.                     displayUnknown = TRUE;
  606.                     break;
  607.                 }
  608.                 DisplayConfigurationDescriptor((PUSB_CONFIGURATION_DESCRIPTOR)commonDesc,
  609.                                                StringDescs);
  610.                 break;
  612.             case USB_INTERFACE_DESCRIPTOR_TYPE:
  613.                 if ((commonDesc->bLength != sizeof(USB_INTERFACE_DESCRIPTOR)) &&
  614.                     (commonDesc->bLength != sizeof(USB_INTERFACE_DESCRIPTOR2)))
  615.                 {
  616.                     OOPS();
  617.                     displayUnknown = TRUE;
  618.                     break;
  619.                 }
  620.                 bInterfaceClass = ((PUSB_INTERFACE_DESCRIPTOR)commonDesc)->bInterfaceClass;
  621.                 bInterfaceSubClass = ((PUSB_INTERFACE_DESCRIPTOR)commonDesc)->bInterfaceSubClass;
  623.                 DisplayInterfaceDescriptor((PUSB_INTERFACE_DESCRIPTOR)commonDesc,
  624.                                            StringDescs);
  625.                 break;
  627.             case USB_ENDPOINT_DESCRIPTOR_TYPE:
  628.                 if ((commonDesc->bLength != sizeof(USB_ENDPOINT_DESCRIPTOR)) &&
  629.                     (commonDesc->bLength != sizeof(USB_ENDPOINT_DESCRIPTOR2)))
  630.                 {
  631.                     OOPS();
  632.                     displayUnknown = TRUE;
  633.                     break;
  634.                 }
  635.                 DisplayEndpointDescriptor((PUSB_ENDPOINT_DESCRIPTOR)commonDesc);
  636.                 break;
  638.             case USB_HID_DESCRIPTOR_TYPE:
  639.                 if (commonDesc->bLength < sizeof(USB_HID_DESCRIPTOR))
  640.                 {
  641.                     OOPS();
  642.                     displayUnknown = TRUE;
  643.                     break;
  644.                 }
  645.                 DisplayHidDescriptor((PUSB_HID_DESCRIPTOR)commonDesc);
  646.                 break;
  648.             default:
  649.                 switch (bInterfaceClass)
  650.                 {
  651.                     case USB_DEVICE_CLASS_AUDIO:
  652.                         displayUnknown = !DisplayAudioDescriptor(
  653.                                               (PUSB_AUDIO_COMMON_DESCRIPTOR)commonDesc,
  654.                                               bInterfaceSubClass);
  655.                         break;
  657.                     default:
  658.                         displayUnknown = TRUE;
  659.                         break;
  660.                 }
  661.                 break;
  662.         }
  664.         if (displayUnknown)
  665.         {
  666.             DisplayUnknownDescriptor(commonDesc);
  667.         }
  669.         (PUCHAR)commonDesc += commonDesc->bLength;
  670.     }
  671. }
  674. //*****************************************************************************
  675. //
  676. // DisplayConfigurationDescriptor()
  677. //
  678. //*****************************************************************************
  680. VOID
  681. DisplayConfigurationDescriptor (
  682.     PUSB_CONFIGURATION_DESCRIPTOR   ConfigDesc,
  683.     PSTRING_DESCRIPTOR_NODE         StringDescs
  684. )
  685. {
  687.     AppendTextBuffer("rnConfiguration Descriptor:rn");
  689.     AppendTextBuffer("wTotalLength:       0x%04Xrn",
  690.                      ConfigDesc->wTotalLength);
  692.     AppendTextBuffer("bNumInterfaces:       0x%02Xrn",
  693.                      ConfigDesc->bNumInterfaces);
  695.     AppendTextBuffer("bConfigurationValue:  0x%02Xrn",
  696.                      ConfigDesc->bConfigurationValue);
  698.     AppendTextBuffer("iConfiguration:       0x%02Xrn",
  699.                      ConfigDesc->iConfiguration);
  701.     if (ConfigDesc->iConfiguration)
  702.     {
  703.         DisplayStringDescriptor(ConfigDesc->iConfiguration,
  704.                                 StringDescs);
  705.     }
  707.     AppendTextBuffer("bmAttributes:         0x%02X (",
  708.                      ConfigDesc->bmAttributes);
  710.     if (ConfigDesc->bmAttributes & 0x80)
  711.     {
  712.         AppendTextBuffer("Bus Powered ");
  713.     }
  715.     if (ConfigDesc->bmAttributes & 0x40)
  716.     {
  717.         AppendTextBuffer("Self Powered ");
  718.     }
  720.     if (ConfigDesc->bmAttributes & 0x20)
  721.     {
  722.         AppendTextBuffer("Remote Wakeup");
  723.     }
  725.     AppendTextBuffer(")rn");
  727.     AppendTextBuffer("MaxPower:             0x%02X (%d Ma)rn",
  728.                      ConfigDesc->MaxPower,
  729.                      ConfigDesc->MaxPower * 2);
  731. }
  733. //*****************************************************************************
  734. //
  735. // DisplayInterfaceDescriptor()
  736. //
  737. //*****************************************************************************
  739. VOID
  740. DisplayInterfaceDescriptor (
  741.     PUSB_INTERFACE_DESCRIPTOR   InterfaceDesc,
  742.     PSTRING_DESCRIPTOR_NODE     StringDescs
  743. )
  744. {
  745.     PCHAR pStr;
  747.     AppendTextBuffer("rnInterface Descriptor:rn");
  749.     AppendTextBuffer("bInterfaceNumber:     0x%02Xrn",
  750.                      InterfaceDesc->bInterfaceNumber);
  752.     AppendTextBuffer("bAlternateSetting:    0x%02Xrn",
  753.                      InterfaceDesc->bAlternateSetting);
  755.     AppendTextBuffer("bNumEndpoints:        0x%02Xrn",
  756.                      InterfaceDesc->bNumEndpoints);
  758.     AppendTextBuffer("bInterfaceClass:      0x%02X",
  759.                      InterfaceDesc->bInterfaceClass);
  761.     pStr = "rn";
  763.     switch (InterfaceDesc->bInterfaceClass)
  764.     {
  765.         case USB_DEVICE_CLASS_AUDIO:
  766.             pStr = " (Audio)rn";
  767.             break;
  769.         case USB_DEVICE_CLASS_HUMAN_INTERFACE:
  770.             pStr = " (HID)rn";
  771.             break;
  773.         case USB_DEVICE_CLASS_HUB:
  774.             pStr = " (Hub)rn";
  775.             break;
  777.         default:
  778.             break;
  779.     }
  781.     AppendTextBuffer(pStr);
  783.     AppendTextBuffer("bInterfaceSubClass:   0x%02X",
  784.                      InterfaceDesc->bInterfaceSubClass);
  786.     pStr = "rn";
  788.     switch (InterfaceDesc->bInterfaceClass)
  789.     {
  790.         case USB_DEVICE_CLASS_AUDIO:
  791.             switch (InterfaceDesc->bInterfaceSubClass)
  792.             {
  793.                 case USB_AUDIO_SUBCLASS_AUDIOCONTROL:
  794.                     pStr = " (Audio Control)rn";
  795.                     break;
  797.                 case USB_AUDIO_SUBCLASS_AUDIOSTREAMING:
  798.                     pStr = " (Audio Streaming)rn";
  799.                     break;
  801.                 case USB_AUDIO_SUBCLASS_MIDISTREAMING:
  802.                     pStr = " (MIDI Streaming)rn";
  803.                     break;
  805.                 default:
  806.                     break;
  807.             }
  808.             break;
  810.         default:
  811.             break;
  812.     }
  814.     AppendTextBuffer(pStr);
  816.     AppendTextBuffer("bInterfaceProtocol:   0x%02Xrn",
  817.                      InterfaceDesc->bInterfaceProtocol);
  819.     AppendTextBuffer("iInterface:           0x%02Xrn",
  820.                      InterfaceDesc->iInterface);
  822.     if (InterfaceDesc->iInterface)
  823.     {
  824.         DisplayStringDescriptor(InterfaceDesc->iInterface,
  825.                                 StringDescs);
  826.     }
  828.     if (InterfaceDesc->bLength == sizeof(USB_INTERFACE_DESCRIPTOR2))
  829.     {
  830.         PUSB_INTERFACE_DESCRIPTOR2 interfaceDesc2;
  832.         interfaceDesc2 = (PUSB_INTERFACE_DESCRIPTOR2)InterfaceDesc;
  834.         AppendTextBuffer("wNumClasses:        0x%04Xrn",
  835.                          interfaceDesc2->wNumClasses);
  836.     }
  838. }
  840. //*****************************************************************************
  841. //
  842. // DisplayEndpointDescriptor()
  843. //
  844. //*****************************************************************************
  846. VOID
  847. DisplayEndpointDescriptor (
  848.     PUSB_ENDPOINT_DESCRIPTOR    EndpointDesc
  849. )
  850. {
  852.     AppendTextBuffer("rnEndpoint Descriptor:rn");
  854.     AppendTextBuffer("bEndpointAddress:     0x%02Xrn",
  855.                      EndpointDesc->bEndpointAddress);
  857.     switch (EndpointDesc->bmAttributes & 0x03)
  858.     {
  859.         case 0x00:
  860.             AppendTextBuffer("Transfer Type:     Controlrn");
  861.             break;
  863.         case 0x01:
  864.             AppendTextBuffer("Transfer Type: Isochronousrn");
  865.             break;
  867.         case 0x02:
  868.             AppendTextBuffer("Transfer Type:        Bulkrn");
  869.             break;
  871.         case 0x03:
  872.             AppendTextBuffer("Transfer Type:   Interruptrn");
  873.             break;
  875.     }
  877.     AppendTextBuffer("wMaxPacketSize:     0x%04X (%d)rn",
  878.                      EndpointDesc->wMaxPacketSize,
  879.                      EndpointDesc->wMaxPacketSize);
  881.     if (EndpointDesc->bLength == sizeof(USB_ENDPOINT_DESCRIPTOR))
  882.     {
  883.         AppendTextBuffer("bInterval:            0x%02Xrn",
  884.                          EndpointDesc->bInterval);
  885.     }
  886.     else
  887.     {
  888.         PUSB_ENDPOINT_DESCRIPTOR2 endpointDesc2;
  890.         endpointDesc2 = (PUSB_ENDPOINT_DESCRIPTOR2)EndpointDesc;
  892.         AppendTextBuffer("wInterval:          0x%04Xrn",
  893.                          endpointDesc2->wInterval);
  895.         AppendTextBuffer("bSyncAddress:         0x%02Xrn",
  896.                          endpointDesc2->bSyncAddress);
  897.     }
  899. }
  902. //*****************************************************************************
  903. //
  904. // DisplayHidDescriptor()
  905. //
  906. //*****************************************************************************
  908. VOID
  909. DisplayHidDescriptor (
  910.     PUSB_HID_DESCRIPTOR         HidDesc
  911. )
  912. {
  913.     UCHAR i;
  915.     AppendTextBuffer("rnHID Descriptor:rn");
  917.     AppendTextBuffer("bcdHID:             0x%04Xrn",
  918.     HidDesc->bcdHID);
  920.     AppendTextBuffer("bCountryCode:         0x%02Xrn",
  921.                      HidDesc->bCountryCode);
  923.     AppendTextBuffer("bNumDescriptors:      0x%02Xrn",
  924.                      HidDesc->bNumDescriptors);
  926.     for (i=0; i<HidDesc->bNumDescriptors; i++)
  927.     {
  928.         AppendTextBuffer("bDescriptorType:      0x%02Xrn",
  929.                          HidDesc->OptionalDescriptors[i].bDescriptorType);
  931.         AppendTextBuffer("wDescriptorLength:  0x%04Xrn",
  932.                          HidDesc->OptionalDescriptors[i].wDescriptorLength);
  933.     }
  935. }
  938. #if 0
  939. //*****************************************************************************
  940. //
  941. // DisplayPowerDescriptor()
  942. //
  943. //*****************************************************************************
  945. PCHAR PowerUnits[] =
  946. {
  947.     "0.001 mW",
  948.     "0.01 mW",
  949.     "0.1 mW",
  950.     "1 mW",
  951.     "10 mW",
  952.     "100 mW",
  953.     "1 W"
  954. };
  956. VOID
  957. DisplayPowerDescriptor (
  958.     PUSB_POWER_DESCRIPTOR       PowerDesc
  959. )
  960. {
  961.     UCHAR i;
  963.     AppendTextBuffer("rnPower Descriptor:rn");
  965.     AppendTextBuffer("bCapabilitiesFlags:   0x%02X (",
  966.                      PowerDesc->bCapabilitiesFlags);
  968.     if (PowerDesc->bCapabilitiesFlags & USB_SUPPORT_D2_WAKEUP)
  969.     {
  970.         AppendTextBuffer("WakeD2 ");
  971.     }
  972.     if (PowerDesc->bCapabilitiesFlags & USB_SUPPORT_D1_WAKEUP)
  973.     {
  974.         AppendTextBuffer("WakeD1 ");
  975.     }
  976.     if (PowerDesc->bCapabilitiesFlags & USB_SUPPORT_D3_COMMAND)
  977.     {
  978.         AppendTextBuffer("D3 ");
  979.     }
  980.     if (PowerDesc->bCapabilitiesFlags & USB_SUPPORT_D2_COMMAND)
  981.     {
  982.         AppendTextBuffer("D2 ");
  983.     }
  984.     if (PowerDesc->bCapabilitiesFlags & USB_SUPPORT_D1_COMMAND)
  985.     {
  986.         AppendTextBuffer("D1 ");
  987.     }
  988.     if (PowerDesc->bCapabilitiesFlags & USB_SUPPORT_D0_COMMAND)
  989.     {
  990.         AppendTextBuffer("D0 ");
  991.     }
  992.     AppendTextBuffer(")rn");
  994.     AppendTextBuffer("EventNotification:  0x%04Xrn",
  995.                      PowerDesc->EventNotification);
  997.     AppendTextBuffer("D1LatencyTime:      0x%04Xrn",
  998.                      PowerDesc->D1LatencyTime);
  1000.     AppendTextBuffer("D2LatencyTime:      0x%04Xrn",
  1001.                      PowerDesc->D2LatencyTime);
  1003.     AppendTextBuffer("D3LatencyTime:      0x%04Xrn",
  1004.                      PowerDesc->D3LatencyTime);
  1006.     AppendTextBuffer("PowerUnit:            0x%02X (%s)rn",
  1007.                      PowerDesc->PowerUnit,
  1008.                      PowerDesc->PowerUnit < sizeof(PowerUnits)/sizeof(PowerUnits[0])
  1009.                      ? PowerUnits[PowerDesc->PowerUnit]
  1010.                      : "?");
  1012.     AppendTextBuffer("D0PowerConsumption: 0x%04X (%5d)rn",
  1013.                      PowerDesc->D0PowerConsumption,
  1014.                      PowerDesc->D0PowerConsumption);
  1016.     AppendTextBuffer("D1PowerConsumption: 0x%04X (%5d)rn",
  1017.                      PowerDesc->D1PowerConsumption,
  1018.                      PowerDesc->D1PowerConsumption);
  1020.     AppendTextBuffer("D2PowerConsumption: 0x%04X (%5d)rn",
  1021.                      PowerDesc->D2PowerConsumption,
  1022.                      PowerDesc->D2PowerConsumption);
  1024. }
  1025. #endif
  1027. //*****************************************************************************
  1028. //
  1029. // DisplayStringDescriptor()
  1030. //
  1031. //*****************************************************************************
  1033. #if 1
  1035. VOID
  1036. DisplayStringDescriptor (
  1037.     UCHAR                       Index,
  1038.     PSTRING_DESCRIPTOR_NODE     StringDescs
  1039. )
  1040. {
  1041.     ULONG nBytes;
  1043.     while (StringDescs)
  1044.     {
  1045.         if (StringDescs->DescriptorIndex == Index)
  1046.         {
  1047.             AppendTextBuffer("0x%04X: "",
  1048.                              StringDescs->LanguageID);
  1050.             nBytes = WideCharToMultiByte(
  1051.                          CP_ACP,     // CodePage
  1052.                          0,          // CodePage
  1053.                          StringDescs->StringDescriptor->bString,
  1054.                          (StringDescs->StringDescriptor->bLength - 2) / 2,
  1055.                          TextBuffer + TextBufferPos,
  1056.                          TextBufferLen - TextBufferPos,
  1057.                          NULL,       // lpDefaultChar
  1058.                          NULL);      // pUsedDefaultChar
  1060.             TextBufferPos += nBytes;
  1062.             AppendTextBuffer(""rn");
  1063.         }
  1065.         StringDescs = StringDescs->Next;
  1066.     }
  1068. }
  1070. #else
  1072. VOID
  1073. DisplayStringDescriptor (
  1074.     UCHAR                       Index,
  1075.     PSTRING_DESCRIPTOR_NODE     StringDescs
  1076. )
  1077. {
  1078.     UCHAR i;
  1080.     while (StringDescs)
  1081.     {
  1082.         if (StringDescs->DescriptorIndex == Index)
  1083.         {
  1084.             AppendTextBuffer("String Descriptor:rn");
  1086.             AppendTextBuffer("LanguageID:         0x%04Xrn",
  1087.                              StringDescs->LanguageID);
  1089.             AppendTextBuffer("bLength:              0x%02Xrn",
  1090.                              StringDescs->StringDescriptor->bLength);
  1092.             for (i = 0; i < StringDescs->StringDescriptor->bLength-2; i++)
  1093.             {
  1094.                 AppendTextBuffer("%02X ",
  1095.                                  ((PUCHAR)StringDescs->StringDescriptor->bString)[i]);
  1097.                 if (i % 16 == 15)
  1098.                 {
  1099.                     AppendTextBuffer("rn");
  1100.                 }
  1101.             }
  1103.             if (i % 16 != 0)
  1104.             {
  1105.                 AppendTextBuffer("rn");
  1106.             }
  1107.         }
  1109.         StringDescs = StringDescs->Next;
  1110.     }
  1112. }
  1114. #endif
  1116. //*****************************************************************************
  1117. //
  1118. // DisplayUnknownDescriptor()
  1119. //
  1120. //*****************************************************************************
  1122. VOID
  1123. DisplayUnknownDescriptor (
  1124.     PUSB_COMMON_DESCRIPTOR      CommonDesc
  1125. )
  1126. {
  1127.     UCHAR   i;
  1129.     AppendTextBuffer("rnUnknown Descriptor:rn");
  1131.     AppendTextBuffer("bDescriptorType:      0x%02Xrn",
  1132.                      CommonDesc->bDescriptorType);
  1134.     AppendTextBuffer("bLength:              0x%02Xrn",
  1135.                      CommonDesc->bLength);
  1137.     for (i = 0; i < CommonDesc->bLength; i++)
  1138.     {
  1139.         AppendTextBuffer("%02X ",
  1140.                          ((PUCHAR)CommonDesc)[i]);
  1142.         if (i % 16 == 15)
  1143.         {
  1144.             AppendTextBuffer("rn");
  1145.         }
  1146.     }
  1148.     if (i % 16 != 0)
  1149.     {
  1150.         AppendTextBuffer("rn");
  1151.     }
  1153. }
  1155. //*****************************************************************************
  1156. //
  1157. // GetVendorString()
  1158. //
  1159. // idVendor - USB Vendor ID
  1160. //
  1161. // Return Value - Vendor name string associated with idVendor, or NULL if
  1162. // no vendor name string is found which is associated with idVendor.
  1163. //
  1164. //*****************************************************************************
  1166. PCHAR
  1167. GetVendorString (
  1168.     USHORT     idVendor
  1169. )
  1170. {
  1171.     PUSBVENDORID vendorID;
  1173.     if (idVendor != 0x0000)
  1174.     {
  1175.         vendorID = USBVendorIDs;
  1177.         while (vendorID->usVendorID != 0x0000)
  1178.         {
  1179.             if (vendorID->usVendorID == idVendor)
  1180.             {
  1181.                 return (vendorID->szVendor);
  1182.             }
  1183.             vendorID++;
  1184.         }
  1185.     }
  1187.     return NULL;
  1188. }