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

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

驱动编程

开发平台：

Visual C++

rwiso.c：源码内容
  1. /*++
  3. Copyright (c) 1997-1998  Microsoft Corporation
  5. Module Name:
  7.     RwIso.c
  9. Abstract:
  11.     Console test app for IsoUsb.sys driver
  13. Environment:
  15.     user mode only
  17. Notes:
  19.   THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF ANY
  20.   KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
  21.   IMPLIED WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR
  22.   PURPOSE.
  24.   Copyright (c) 1997-1998 Microsoft Corporation.  All Rights Reserved.
  27. Revision History:
  29.         11/17/97: created
  31. --*/
  33. #include <windows.h>
  35. #include <conio.h>
  36. #include <stdio.h>
  37. #include <stdlib.h>
  38. #include <assert.h>
  39. #include <time.h>
  41. #include "devioctl.h"
  43. #include <setupapi.h>
  44. #include <basetyps.h>
  46. #include "IsoUsr.h"
  48. #include "usbdi.h"
  50. #define NOISY(_x_) printf _x_ ;
  52. char inPipe[32] = "PIPE04";     // pipe name for iso input pipe on our test board
  53. char outPipe[32] = "PIPE05";    // pipe name for iso output pipe on our test board
  54. char completeDeviceName[256] = "";  //generated from the GUID registered by the driver itself
  56. BOOL fDumpUsbConfig = FALSE;    // flags set in response to console command line switches
  57. BOOL fDumpReadData = FALSE;
  58. BOOL fRead = FALSE;
  59. BOOL fWrite = FALSE;
  61. PVOID gpStreamObj;
  62. char gbuf[256];
  65. BOOL fIsoStreamStarted = FALSE;
  66. HANDLE ghStreamDev = NULL;
  67. int gMS = 10000; // default to 10 secs stream test
  69. int gDebugLevel = 1;      // higher == more verbose, default is 1, 0 turns off all
  71. ULONG IterationCount = 1; // count of iterations of the test we are to perform
  72. int WriteLen = 0;         // #bytes to write
  73. int ReadLen = 0;          // #bytes to read
  75. void StartIsoStream( void );
  77. void StopIsoStream( void );
  79. // functions
  82. HANDLE
  83. OpenOneDevice (
  84.     IN       HDEVINFO                    HardwareDeviceInfo,
  85.     IN       PSP_DEVICE_INTERFACE_DATA   DeviceInfoData,
  86.         IN               char *devName
  87.     )
  88. /*++
  89. Routine Description:
  91.     Given the HardwareDeviceInfo, representing a handle to the plug and
  92.     play information, and deviceInfoData, representing a specific usb device,
  93.     open that device and fill in all the relevant information in the given
  94.     USB_DEVICE_DESCRIPTOR structure.
  96. Arguments:
  98.     HardwareDeviceInfo:  handle to info obtained from Pnp mgr via SetupDiGetClassDevs()
  99.     DeviceInfoData:      ptr to info obtained via SetupDiEnumDeviceInterfaces()
  101. Return Value:
  103.     return HANDLE if the open and initialization was successfull,
  104.         else INVLAID_HANDLE_VALUE.
  106. --*/
  107. {
  108.     PSP_DEVICE_INTERFACE_DETAIL_DATA     functionClassDeviceData = NULL;
  109.     ULONG                                predictedLength = 0;
  110.     ULONG                                requiredLength = 0;
  111.         HANDLE                                                           hOut = INVALID_HANDLE_VALUE;
  113.     //
  114.     // allocate a function class device data structure to receive the
  115.     // goods about this particular device.
  116.     //
  117.     SetupDiGetDeviceInterfaceDetail (
  118.             HardwareDeviceInfo,
  119.             DeviceInfoData,
  120.             NULL, // probing so no output buffer yet
  121.             0, // probing so output buffer length of zero
  122.             &requiredLength,
  123.             NULL); // not interested in the specific dev-node
  126.     predictedLength = requiredLength;
  127.     // sizeof (SP_FNCLASS_DEVICE_DATA) + 512;
  129.     functionClassDeviceData = malloc (predictedLength);
  130.     functionClassDeviceData->cbSize = sizeof (SP_DEVICE_INTERFACE_DETAIL_DATA);
  132.     //
  133.     // Retrieve the information from Plug and Play.
  134.     //
  135.     if (! SetupDiGetDeviceInterfaceDetail (
  136.                HardwareDeviceInfo,
  137.                DeviceInfoData,
  138.                functionClassDeviceData,
  139.                predictedLength,
  140.                &requiredLength,
  141.                NULL)) {
  142.                 free( functionClassDeviceData );
  143.         return INVALID_HANDLE_VALUE;
  144.     }
  146.         strcpy( devName,functionClassDeviceData->DevicePath) ;
  147.         printf( "Attempting to open %sn", devName );
  149.     hOut = CreateFile (
  150.                   functionClassDeviceData->DevicePath,
  151.                   GENERIC_READ | GENERIC_WRITE,
  152.                   FILE_SHARE_READ | FILE_SHARE_WRITE,
  153.                   NULL, // no SECURITY_ATTRIBUTES structure
  154.                   OPEN_EXISTING, // No special create flags
  155.                   0, // No special attributes
  156.                   NULL); // No template file
  158.     if (INVALID_HANDLE_VALUE == hOut) {
  159.                 printf( "FAILED to open %sn", devName );
  160.     }
  161.         free( functionClassDeviceData );
  162.         return hOut;
  163. }
  166. HANDLE
  167. OpenUsbDevice( LPGUID  pGuid, char *outNameBuf)
  168. /*++
  169. Routine Description:
  171.    Do the required PnP things in order to find
  172.    the next available proper device in the system at this time.
  174. Arguments:
  176.     pGuid:      ptr to GUID registered by the driver itself
  177.     outNameBuf: the generated name for this device
  179. Return Value:
  181.     return HANDLE if the open and initialization was successful,
  182.         else INVLAID_HANDLE_VALUE.
  183. --*/
  184. {
  185.    ULONG NumberDevices;
  186.    HANDLE hOut = INVALID_HANDLE_VALUE;
  187.    HDEVINFO                 hardwareDeviceInfo;
  188.    SP_DEVICE_INTERFACE_DATA deviceInfoData;
  189.    ULONG                    i;
  190.    BOOLEAN                  done;
  191.    PUSB_DEVICE_DESCRIPTOR   usbDeviceInst;
  192.    PUSB_DEVICE_DESCRIPTOR       *UsbDevices = &usbDeviceInst;
  194.    *UsbDevices = NULL;
  195.    NumberDevices = 0;
  197.    //
  198.    // Open a handle to the plug and play dev node.
  199.    // SetupDiGetClassDevs() returns a device information set that contains info on all
  200.    // installed devices of a specified class.
  201.    //
  202.    hardwareDeviceInfo = SetupDiGetClassDevs (
  203.                            pGuid,
  204.                            NULL, // Define no enumerator (global)
  205.                            NULL, // Define no
  206.                            (DIGCF_PRESENT | // Only Devices present
  207.                             DIGCF_DEVICEINTERFACE)); // Function class devices.
  209.    //
  210.    // Take a wild guess at the number of devices we have;
  211.    // Be prepared to realloc and retry if there are more than we guessed
  212.    //
  213.    NumberDevices = 4;
  214.    done = FALSE;
  215.    deviceInfoData.cbSize = sizeof (SP_DEVICE_INTERFACE_DATA);
  217.    i=0;
  218.    while (!done) {
  219.       NumberDevices *= 2;
  221.       if (*UsbDevices) {
  222.          *UsbDevices =
  223.                realloc (*UsbDevices, (NumberDevices * sizeof (USB_DEVICE_DESCRIPTOR)));
  224.       } else {
  225.          *UsbDevices = calloc (NumberDevices, sizeof (USB_DEVICE_DESCRIPTOR));
  226.       }
  228.       if (NULL == *UsbDevices) {
  230.          // SetupDiDestroyDeviceInfoList destroys a device information set
  231.          // and frees all associated memory.
  233.          SetupDiDestroyDeviceInfoList (hardwareDeviceInfo);
  234.          return INVALID_HANDLE_VALUE;
  235.       }
  237.       usbDeviceInst = *UsbDevices + i;
  239.       for (; i < NumberDevices; i++) {
  241.          // SetupDiEnumDeviceInterfaces() returns information about device interfaces
  242.          // exposed by one or more devices. Each call returns information about one interface;
  243.          // the routine can be called repeatedly to get information about several interfaces
  244.          // exposed by one or more devices.
  246.          if (SetupDiEnumDeviceInterfaces (hardwareDeviceInfo,
  247.                                          0, // We don't care about specific PDOs
  248.                                                                                  pGuid,
  249.                                          i,
  250.                                          &deviceInfoData)) {
  252.             hOut = OpenOneDevice (hardwareDeviceInfo, &deviceInfoData, outNameBuf);
  253.                         if ( hOut != INVALID_HANDLE_VALUE ) {
  254.                done = TRUE;
  255.                break;
  256.                         }
  257.          } else {
  258.             if (ERROR_NO_MORE_ITEMS == GetLastError()) {
  259.                done = TRUE;
  260.                break;
  261.             }
  262.          }
  263.       }
  264.    }
  266.    NumberDevices = i;
  268.    // SetupDiDestroyDeviceInfoList() destroys a device information set
  269.    // and frees all associated memory.
  271.    SetupDiDestroyDeviceInfoList (hardwareDeviceInfo);
  272.    free ( *UsbDevices );
  273.    return hOut;
  274. }
  279. BOOL
  280. GetUsbDeviceFileName( LPGUID  pGuid, char *outNameBuf)
  281. /*++
  282. Routine Description:
  284.     Given a ptr to a driver-registered GUID, give us a string with the device name
  285.     that can be used in a CreateFile() call.
  286.     Actually briefly opens and closes the device and sets outBuf if successfull;
  287.     returns FALSE if not
  289. Arguments:
  291.     pGuid:      ptr to GUID registered by the driver itself
  292.     outNameBuf: the generated zero-terminated name for this device
  294. Return Value:
  296.     TRUE on success else FALSE
  298. --*/
  299. {
  300.         HANDLE hDev = OpenUsbDevice( pGuid, outNameBuf );
  301.         if ( hDev != INVALID_HANDLE_VALUE )
  302.         {
  303.                 CloseHandle( hDev );
  304.                 return TRUE;
  305.         }
  306.         return FALSE;
  308. }
  310. HANDLE
  311. open_dev()
  312. /*++
  313. Routine Description:
  315.     Called by dumpUsbConfig() to open an instance of our device
  317. Arguments:
  319.     None
  321. Return Value:
  323.     Device handle on success else NULL
  325. --*/
  326. {
  328.         HANDLE hDEV = OpenUsbDevice( (LPGUID)&GUID_CLASS_I82930_ISO, completeDeviceName);
  331.         if (hDEV == INVALID_HANDLE_VALUE) {
  332.                 printf("Failed to open (%s) = %d", completeDeviceName, GetLastError());
  333.         } else {
  334.                 printf("DeviceName = (%s)n", completeDeviceName);
  335.     }           
  337.         return hDEV;
  338. }
  341. HANDLE
  342. open_file( char *filename)
  343. /*++
  344. Routine Description:
  346.     Called by main() to open an instance of our device after obtaining its name
  348. Arguments:
  350.     None
  352. Return Value:
  354.     Device handle on success else NULL
  356. --*/
  357. {
  359.         int success = 1;
  360.         HANDLE h;
  362.         if ( !GetUsbDeviceFileName(
  363.                 (LPGUID) &GUID_CLASS_I82930_ISO,
  364.                 completeDeviceName) )
  365.         {
  366.                 NOISY(("Failed to GetUsbDeviceFileNamen", GetLastError()));
  367.                 return  INVALID_HANDLE_VALUE;
  368.         }
  370.     strcat (completeDeviceName,
  371.                         "\"
  372.                         );                      
  374.     strcat (completeDeviceName,
  375.                         filename
  376.                         );                                      
  378.         printf("completeDeviceName = (%s)n", completeDeviceName);
  380.         h = CreateFile(completeDeviceName,
  381.                 GENERIC_WRITE | GENERIC_READ,
  382.                 FILE_SHARE_WRITE | FILE_SHARE_READ,
  383.                 NULL,
  384.                 OPEN_EXISTING,
  385.                 0,
  386.                 NULL);
  388.         if (h == INVALID_HANDLE_VALUE) {
  389.                 NOISY(("Failed to open (%s) = %d", completeDeviceName, GetLastError()));
  390.                 success = 0;
  391.         } else {
  392.                         NOISY(("Opened successfully.n"));
  393.     }           
  395.         return h;
  396. }
  398. void
  399. usage()
  400. /*++
  401. Routine Description:
  403.     Called by main() to dump usage info to the console when
  404.     the app is called with no parms or with an invalid parm
  406. Arguments:
  408.     None
  410. Return Value:
  412.     None
  414. --*/
  415. {
  416.     printf("Usage for Read/Write test:n");
  417.     printf("-r [n] where n is number of bytes to readn");
  418.     printf("-w [n] where n is number of bytes to writen");
  419.     printf("-c [n] where n is number of iterations (default = 1)n");
  420.     printf("-i [s] where s is the input pipen");
  421.     printf("-o [s] where s is the output pipen");
  422.     printf("-v verbose -- dumps read datan");
  424.     printf("nUsage for USB and Endpoint info:n");
  425.     printf("-u to dump USB configuration and pipe info n");
  426.     printf("-g [s] Run Isochronous test stream for 's' seconds n");
  428. }
  431. void
  432. parse(
  433.     int argc,
  434.     char *argv[] )
  435. /*++
  436. Routine Description:
  438.     Called by main() to parse command line parms
  440. Arguments:
  442.     argc and argv that was passed to main()
  444. Return Value:
  446.     Sets global flags as per user function request
  448. --*/
  449. {
  450.     int i;
  452.         if ( argc < 2 ) // give usage if invoked with no parms
  453.                 usage();
  455.     for (i=0; i<argc; i++) {
  456.         if (argv[i][0] == '-' ||
  457.             argv[i][0] == '/') {
  458.             switch(argv[i][1]) {
  459.             case 'r':
  460.             case 'R':
  461.                 ReadLen = atoi(&argv[i+1][0]);
  462.                                 fRead = TRUE;
  463.                 i++;
  464.                 break;
  465.             case 'w':
  466.             case 'W':
  467.                 WriteLen = atoi(&argv[i+1][0]);
  468.                                 fWrite = TRUE;
  469.                 i++;
  470.                 break;
  471.             case 'c':
  472.             case 'C':
  473.                 IterationCount = atoi(&argv[i+1][0]);
  474.                 i++;
  475.                 break;
  476.             case 'i':
  477.             case 'I':
  478.                 strcpy(inPipe, &argv[i+1][0]);
  479.                 i++;
  480.                 break;
  481.             case 'u':
  482.             case 'U':
  483.                 fDumpUsbConfig = TRUE;
  484.                                 i++;
  485.                 break;
  486.             case 'v':
  487.             case 'V':
  488.                 fDumpReadData = TRUE;
  489.                                 i++;
  490.                 break;
  491.                          case 'o':
  492.              case 'O':
  493.                 strcpy(outPipe, &argv[i+1][0]);
  494.                 i++;
  495.                 break;
  496.                          case 'g':
  497.              case 'G':
  498.                  gMS = 1000 * atoi(&argv[i+1][0]);
  499.                                  StartIsoStream();
  500.                 break;
  501.                          case 'x':
  502.              case 'X':
  503.                                  StopIsoStream();
  504.                 break;
  505.             default:
  506.                 usage();
  507.             }
  508.         }
  509.     }
  510. }
  512. BOOL
  513. compare_buffs(char *buff1, char *buff2, int length)
  514. /*++
  515. Routine Description:
  517.     Called to verify read and write buffers match for loopback test
  519. Arguments:
  521.     buffers to compare and length
  523. Return Value:
  525.     TRUE if buffers match, else FALSE
  527. --*/
  528. {
  529.     int ok = 1;
  531.         if (memcmp(buff1, buff2, length )) {
  533.                 // Edi, and Esi point to the mismatching char and ecx indicates the
  534.                 // remaining length.
  535.                 ok = 0;
  536.         }
  539.     return ok;
  540. }
  542. #define NPERLN 8
  544. void
  545. dump(
  546.    UCHAR *b,
  547.    int len
  548. )
  549. /*++
  550. Routine Description:
  552.     Called to do formatted ascii dump to console of the io buffer
  554. Arguments:
  556.     buffer and length
  558. Return Value:
  560.     none
  562. --*/
  563. {
  564.     ULONG i;
  565.         ULONG longLen = (ULONG)len / sizeof( ULONG );
  566.         PULONG pBuf = (PULONG) b;
  568.         // dump an ordinal ULONG for each sizeof(ULONG)'th byte
  569.     printf("n****** BEGIN DUMP LEN decimal %d, 0x%xn", len,len);
  570.     for (i=0; i<longLen; i++) {
  571.         printf("%04X ", *pBuf++);
  572.         if (i % NPERLN == (NPERLN - 1)) {
  573.             printf("n");
  574.         }
  575.     }
  576.     if (i % NPERLN != 0) {
  577.         printf("n");
  578.     }
  579.     printf("n****** END DUMP LEN decimal %d, 0x%xn", len,len);
  580. }
  582. // Begin, routines for USB configuration dump (Cmdline "rwiso -u" )
  585. char
  586. *usbDescriptorTypeString(UCHAR bDescriptorType )
  587. /*++
  588. Routine Description:
  590.     Called to get ascii string of USB descriptor
  592. Arguments:
  594.         PUSB_ENDPOINT_DESCRIPTOR->bDescriptorType or
  595.         PUSB_DEVICE_DESCRIPTOR->bDescriptorType or
  596.         PUSB_INTERFACE_DESCRIPTOR->bDescriptorType or
  597.         PUSB_STRING_DESCRIPTOR->bDescriptorType or
  598.         PUSB_POWER_DESCRIPTOR->bDescriptorType or
  599.         PUSB_CONFIGURATION_DESCRIPTOR->bDescriptorType
  601. Return Value:
  603.     ptr to string
  605. --*/{
  607.         switch(bDescriptorType) {
  609.         case USB_DEVICE_DESCRIPTOR_TYPE:
  610.                 return "USB_DEVICE_DESCRIPTOR_TYPE";
  612.         case USB_CONFIGURATION_DESCRIPTOR_TYPE:
  613.                 return "USB_CONFIGURATION_DESCRIPTOR_TYPE";
  614.                 
  616.         case USB_STRING_DESCRIPTOR_TYPE:
  617.                 return "USB_STRING_DESCRIPTOR_TYPE";
  618.                 
  620.         case USB_INTERFACE_DESCRIPTOR_TYPE:
  621.                 return "USB_INTERFACE_DESCRIPTOR_TYPE";
  622.                 
  624.         case USB_ENDPOINT_DESCRIPTOR_TYPE:
  625.                 return "USB_ENDPOINT_DESCRIPTOR_TYPE";
  626.                 
  628. #ifdef USB_POWER_DESCRIPTOR_TYPE // this is the older definintion which is actually obsolete
  629.     // workaround for temporary bug in 98ddk, older USB100.h file
  630.         case USB_POWER_DESCRIPTOR_TYPE:
  631.                 return "USB_POWER_DESCRIPTOR_TYPE";
  632. #endif
  633.                 
  634. #ifdef USB_RESERVED_DESCRIPTOR_TYPE  // this is the current version of USB100.h as in NT5DDK
  636.         case USB_RESERVED_DESCRIPTOR_TYPE:
  637.                 return "USB_RESERVED_DESCRIPTOR_TYPE";
  639.         case USB_CONFIG_POWER_DESCRIPTOR_TYPE:
  640.                 return "USB_CONFIG_POWER_DESCRIPTOR_TYPE";
  642.         case USB_INTERFACE_POWER_DESCRIPTOR_TYPE:
  643.                 return "USB_INTERFACE_POWER_DESCRIPTOR_TYPE";
  644. #endif // for current nt5ddk version of USB100.h
  645.                 
  646.         default:
  647.                 return "??? UNKNOWN!!"; 
  648.         }
  649. }
  652. char
  653. *usbEndPointTypeString(UCHAR bmAttributes)
  654. /*++
  655. Routine Description:
  657.     Called to get ascii string of endpt descriptor type
  659. Arguments:
  661.         PUSB_ENDPOINT_DESCRIPTOR->bmAttributes
  663. Return Value:
  665.     ptr to string
  667. --*/
  668. {
  669.         UINT typ = bmAttributes & USB_ENDPOINT_TYPE_MASK;
  672.         switch( typ) {
  673.         case USB_ENDPOINT_TYPE_INTERRUPT:
  674.                 return "USB_ENDPOINT_TYPE_INTERRUPT";
  676.         case USB_ENDPOINT_TYPE_BULK:
  677.                 return "USB_ENDPOINT_TYPE_BULK";        
  679.         case USB_ENDPOINT_TYPE_ISOCHRONOUS:
  680.                 return "USB_ENDPOINT_TYPE_ISOCHRONOUS"; 
  681.                 
  682.         case USB_ENDPOINT_TYPE_CONTROL:
  683.                 return "USB_ENDPOINT_TYPE_CONTROL";     
  684.                 
  685.         default:
  686.                 return "??? UNKNOWN!!"; 
  687.         }
  688. }
  691. char
  692. *usbConfigAttributesString(UCHAR bmAttributes)
  693. /*++
  694. Routine Description:
  696.     Called to get ascii string of USB_CONFIGURATION_DESCRIPTOR attributes
  698. Arguments:
  700.         PUSB_CONFIGURATION_DESCRIPTOR->bmAttributes
  702. Return Value:
  704.     ptr to string
  706. --*/
  707. {
  708.         UINT typ = bmAttributes & USB_CONFIG_POWERED_MASK;
  711.         switch( typ) {
  713.         case USB_CONFIG_BUS_POWERED:
  714.                 return "USB_CONFIG_BUS_POWERED";
  716.         case USB_CONFIG_SELF_POWERED:
  717.                 return "USB_CONFIG_SELF_POWERED";
  718.                 
  719.         case USB_CONFIG_REMOTE_WAKEUP:
  720.                 return "USB_CONFIG_REMOTE_WAKEUP";
  722.                 
  723.         default:
  724.                 return "??? UNKNOWN!!"; 
  725.         }
  726. }
  729. void
  730. print_USB_CONFIGURATION_DESCRIPTOR(PUSB_CONFIGURATION_DESCRIPTOR cd)
  731. /*++
  732. Routine Description:
  734.     Called to do formatted ascii dump to console of a USB config descriptor
  736. Arguments:
  738.     ptr to USB configuration descriptor
  740. Return Value:
  742.     none
  744. --*/
  745. {
  746.     printf("n===================nUSB_CONFIGURATION_DESCRIPTORn");
  748.     printf(
  749.     "bLength = 0x%x, decimal %dn", cd->bLength, cd->bLength
  750.     );
  752.     printf(
  753.     "bDescriptorType = 0x%x ( %s )n", cd->bDescriptorType, usbDescriptorTypeString( cd->bDescriptorType )
  754.     );
  756.     printf(
  757.     "wTotalLength = 0x%x, decimal %dn", cd->wTotalLength, cd->wTotalLength
  758.     );
  760.     printf(
  761.     "bNumInterfaces = 0x%x, decimal %dn", cd->bNumInterfaces, cd->bNumInterfaces
  762.     );
  764.     printf(
  765.     "bConfigurationValue = 0x%x, decimal %dn", cd->bConfigurationValue, cd->bConfigurationValue
  766.     );
  768.     printf(
  769.     "iConfiguration = 0x%x, decimal %dn", cd->iConfiguration, cd->iConfiguration
  770.     );
  772.     printf(
  773.     "bmAttributes = 0x%x ( %s )n", cd->bmAttributes, usbConfigAttributesString( cd->bmAttributes )
  774.     );
  776.     printf(
  777.     "MaxPower = 0x%x, decimal %dn", cd->MaxPower, cd->MaxPower
  778.     );
  779. }
  782. void
  783. print_USB_INTERFACE_DESCRIPTOR(PUSB_INTERFACE_DESCRIPTOR id, UINT ix)
  784. /*++
  785. Routine Description:
  787.     Called to do formatted ascii dump to console of a USB interface descriptor
  789. Arguments:
  791.     ptr to USB interface descriptor
  793. Return Value:
  795.     none
  797. --*/
  798. {
  799.     printf("n-----------------------------nUSB_INTERFACE_DESCRIPTOR #%dn", ix);
  802.     printf(
  803.     "bLength = 0x%xn", id->bLength
  804.     );
  807.     printf(
  808.     "bDescriptorType = 0x%x ( %s )n", id->bDescriptorType, usbDescriptorTypeString( id->bDescriptorType )
  809.     );
  812.     printf(
  813.     "bInterfaceNumber = 0x%xn", id->bInterfaceNumber
  814.     );
  815.     printf(
  816.     "bAlternateSetting = 0x%xn", id->bAlternateSetting
  817.     );
  818.     printf(
  819.     "bNumEndpoints = 0x%xn", id->bNumEndpoints
  820.     );
  821.     printf(
  822.     "bInterfaceClass = 0x%xn", id->bInterfaceClass
  823.     );
  824.     printf(
  825.     "bInterfaceSubClass = 0x%xn", id->bInterfaceSubClass
  826.     );
  827.     printf(
  828.     "bInterfaceProtocol = 0x%xn", id->bInterfaceProtocol
  829.     );
  830.     printf(
  831.     "bInterface = 0x%xn", id->iInterface
  832.     );
  833. }
  836. void
  837. print_USB_ENDPOINT_DESCRIPTOR(PUSB_ENDPOINT_DESCRIPTOR ed, int i)
  838. /*++
  839. Routine Description:
  841.     Called to do formatted ascii dump to console of a USB endpoint descriptor
  843. Arguments:
  845.     ptr to USB endpoint descriptor,
  846.         index of this endpt in interface desc
  848. Return Value:
  850.     none
  852. --*/
  853. {
  854.     printf(
  855.         "------------------------------nUSB_ENDPOINT_DESCRIPTOR for Pipe%02dn", i
  856.         );
  858.     printf(
  859.     "bLength = 0x%xn", ed->bLength
  860.     );
  862.     printf(
  863.     "bDescriptorType = 0x%x ( %s )n", ed->bDescriptorType, usbDescriptorTypeString( ed->bDescriptorType )
  864.     );
  867.         if ( USB_ENDPOINT_DIRECTION_IN( ed->bEndpointAddress ) ) {
  868.                 printf(
  869.                 "bEndpointAddress= 0x%x ( INPUT )n", ed->bEndpointAddress
  870.                 );
  871.         } else {
  872.                 printf(
  873.                 "bEndpointAddress= 0x%x ( OUTPUT )n", ed->bEndpointAddress
  874.                 );
  875.         }
  877.     printf(
  878.     "bmAttributes= 0x%x ( %s )n", ed->bmAttributes, usbEndPointTypeString ( ed->bmAttributes )
  879.     );
  882.     printf(
  883.     "wMaxPacketSize= 0x%x, decimal %dn", ed->wMaxPacketSize, ed->wMaxPacketSize
  884.     );
  885.     printf(
  886.     "bInterval = 0x%x, decimal %dn", ed->bInterval, ed->bInterval
  887.     );
  888. }
  890. void
  891. rw_dev( HANDLE hDEV )
  892. /*++
  893. Routine Description:
  895.     Called to do formatted ascii dump to console of  USB
  896.     configuration, interface, and endpoint descriptors
  897.     (Cmdline "rwiso -u" )
  899. Arguments:
  901.     handle to device
  903. Return Value:
  905.     none
  907. --*/
  908. {
  909.         ULONG success;
  910.         int siz, nBytes;
  911.         char buf[256];
  912.     PUSB_CONFIGURATION_DESCRIPTOR cd;
  913.     PUSB_INTERFACE_DESCRIPTOR id;
  914.     PUSB_ENDPOINT_DESCRIPTOR ed;
  916.         siz = sizeof(buf);
  918.         if (hDEV == INVALID_HANDLE_VALUE) {
  919.                 NOISY(("DEV not open"));
  920.                 return;
  921.         }
  922.         
  923.         success = DeviceIoControl(hDEV,
  924.                         IOCTL_ISOUSB_GET_CONFIG_DESCRIPTOR,
  925.                         buf,
  926.                         siz,
  927.                         buf,
  928.                         siz,
  929.                         &nBytes,
  930.                         NULL);
  932.         NOISY(("request complete, success = %d nBytes = %dn", success, nBytes));
  933.         
  934.         if (success) {
  935.         ULONG i;
  936.                 UINT  j, n;
  937.         char *pch;
  939.         pch = buf;
  940.                 n = 0;
  942.         cd = (PUSB_CONFIGURATION_DESCRIPTOR) pch;
  944.         print_USB_CONFIGURATION_DESCRIPTOR( cd );
  946.         pch += cd->bLength;
  948.         do {
  950.             id = (PUSB_INTERFACE_DESCRIPTOR) pch;
  952.             print_USB_INTERFACE_DESCRIPTOR(id, n++);
  954.             pch += id->bLength;
  955.             for (j=0; j<id->bNumEndpoints; j++) {
  957.                 ed = (PUSB_ENDPOINT_DESCRIPTOR) pch;
  959.                 print_USB_ENDPOINT_DESCRIPTOR(ed,j);
  961.                 pch += ed->bLength;
  962.             }
  963.             i = (ULONG)(pch - buf);
  964.         } while (i<cd->wTotalLength);
  966.         }
  967.         
  968.         return;
  970. }
  973. int  dumpUsbConfig()
  974. /*++
  975. Routine Description:
  977.     Called to do formatted ascii dump to console of  USB
  978.     configuration, interface, and endpoint descriptors
  979.     (Cmdline "rwiso -u" )
  981. Arguments:
  983.     none
  985. Return Value:
  987.     none
  989. --*/
  990. {
  992.         HANDLE hDEV = open_dev();
  994.         if ( hDEV )
  995.         {
  996.                 rw_dev( hDEV );
  997.                 CloseHandle(hDEV);
  998.         }
  1000.         return 0;
  1001. }
  1002. //  End, routines for USB configuration and pipe info dump  (Cmdline "rwiso -u" )
  1004. // Begin, routines for Iso Streaming
  1008. void
  1009. IsoStream( HANDLE hDEV, BOOL fStop )
  1010. /*++
  1011. Routine Description:
  1013.     Called to start or stop an iso stream
  1014.     (Cmdline "RwIso -g" )
  1016. Arguments:
  1018.     handle to device
  1020. Return Value:
  1022.     none
  1024. --*/
  1025. {
  1026.         ULONG success;
  1027.         int nBytes;
  1028.         DWORD ioctl;
  1029.         char i;
  1031.         if ( fStop )
  1032.         {
  1033.                 ioctl = IOCTL_ISOUSB_STOP_ISO_STREAM;
  1034.                 
  1035.                 for ( i = 0; i < sizeof( gbuf ); i ++ )
  1036.                         gbuf[ i ] = 0; // init outbuf to 0's to make sure read was good
  1038.                 success = DeviceIoControl(hDEV,
  1039.                                 ioctl,
  1040.                                 &gpStreamObj, //pointer to stream object initted when stream was started
  1041.                                 sizeof( PVOID),
  1042.                                 gbuf, // output buffer gets back from kernel mode
  1043.                                 sizeof(gbuf),
  1044.                                 &nBytes,
  1045.                                 NULL);
  1047.                 NOISY(("DeviceIoControl STOP_ISO_STREAM complete, success = %dn", success));
  1048.         }
  1049.         else
  1050.         {
  1051.                 ioctl = IOCTL_ISOUSB_START_ISO_STREAM;
  1052.                 //input is our 256-byte buffer, binary char 0-255
  1053.                 for ( i = 0; i < sizeof( gbuf ); i ++ )
  1054.                         gbuf[ i ] = i;
  1056.                 success = DeviceIoControl(hDEV,
  1057.                                 ioctl,
  1058.                                 gbuf,
  1059.                                 sizeof(gbuf),
  1060.                                 &gpStreamObj, // will receive pointer to stream object
  1061.                                 sizeof( PVOID),
  1062.                                 &nBytes,
  1063.                                 NULL);
  1065.                 NOISY(("DeviceIoControl START_ISO_STREAM complete, success = %dn", success));
  1066.         }
  1070.         if (hDEV == INVALID_HANDLE_VALUE) {
  1071.                 NOISY(("DEV not open"));
  1072.                 return;
  1073.         }
  1074.         
  1076.         
  1078. }
  1080. void StartIsoStream( void )
  1081. {
  1082.         if ( !ghStreamDev ) {
  1084.                 ghStreamDev = open_dev();
  1086.                 if ( ghStreamDev != INVALID_HANDLE_VALUE ) {
  1087.                         IsoStream(  ghStreamDev , FALSE );
  1089.                         Sleep( gMS );
  1091.                         StopIsoStream();
  1092.                 }
  1093.         }
  1094. }
  1096. void StopIsoStream( void )
  1097. {
  1098.         if ( ghStreamDev ) {
  1099.                 IsoStream(  ghStreamDev , TRUE );
  1100.                 ghStreamDev = NULL;
  1101.         }
  1102. }
  1104. // End, routines for Iso Streaming
  1106. int _cdecl main(
  1107.     int argc,
  1108.         char *argv[])
  1109. /*++
  1110. Routine Description:
  1112.     Entry point to RwIso.exe
  1113.     Parses cmdline, performs user-requested tests
  1115. Arguments:
  1117.     argc, argv  standard console  'c' app arguments
  1119. Return Value:
  1121.     Zero
  1123. --*/
  1125. {
  1126.     char *pinBuf = NULL, *poutBuf = NULL;
  1127.     ULONG nBytesRead, nBytesWrite, nBytes;
  1128.         ULONG i, j;
  1129.     int ok;
  1130.     ULONG success;
  1131.     HANDLE hRead = INVALID_HANDLE_VALUE, hWrite = INVALID_HANDLE_VALUE;
  1132.         char buf[1024];
  1133.         clock_t start, finish;
  1134.         ULONG totalBytes = 0L;
  1135.         double seconds;
  1136.         ULONG fail = 0L;
  1138.     parse(argc, argv );
  1140.         // dump USB configuation and pipe info
  1141.         if( fDumpUsbConfig ) {
  1142.                 dumpUsbConfig();
  1143.         }
  1146.         // doing a read, write, or both test
  1147.         if ((fRead) || (fWrite)) {
  1149.             if (fRead) {
  1150.             //
  1151.             // open the output file
  1152.             //
  1153.                         if ( fDumpReadData ) { // round size to sizeof ULONG for readable dumping
  1154.                                 while( ReadLen % sizeof( ULONG ) )
  1155.                                                 ReadLen++;
  1156.                         }
  1158.             hRead = open_file( inPipe);
  1159.         
  1160.                 pinBuf = malloc(ReadLen);
  1162.             }
  1164.             if (fWrite) {
  1166.                         if ( fDumpReadData ) { // round size to sizeof ULONG for readable dumping
  1167.                                 while( WriteLen % sizeof( ULONG ) )
  1168.                                                 WriteLen++;
  1169.                         }
  1171.                 hWrite = open_file( outPipe);
  1172.                 poutBuf = malloc(WriteLen);
  1173.             }
  1176.         for (i=0; i<IterationCount; i++) {
  1178.             if (fWrite && poutBuf && hWrite != INVALID_HANDLE_VALUE) {
  1180.                                 PULONG pOut = (PULONG) poutBuf;
  1181.                                 ULONG  numLongs = WriteLen / sizeof( ULONG );
  1182.                 //
  1183.                 // put some data in the output buffer
  1184.                 //
  1186.                 for (j=0; j<numLongs; j++) {
  1187.                     *(pOut+j) = j;
  1188.                 }
  1190.                 //
  1191.                 // send the write
  1192.                 //
  1194.                     WriteFile(hWrite,
  1195.                               poutBuf,
  1196.                               WriteLen,
  1197.                               &nBytesWrite,
  1198.                               NULL);
  1200.                     printf("<%s> W (%04.4d) : request %06.6d bytes -- %06.6d bytes writtenn",
  1201.                             outPipe, i, WriteLen, nBytesWrite);
  1202.                 assert(nBytesWrite == WriteLen);
  1203.                 }
  1205.                 if (fRead && pinBuf) {
  1207.                     success = ReadFile(hRead,
  1208.                                   pinBuf,
  1209.                               ReadLen,
  1210.                                   &nBytesRead,
  1211.                                   NULL);
  1213.                     printf("<%s> R (%04.4d) : request %06.6d bytes -- %06.6d bytes readn",
  1214.                         inPipe, i, ReadLen, nBytesRead);
  1216.                 if (fWrite) {
  1218.                     //
  1219.                     // validate the input buffer against what
  1220.                     // we sent to the 82930 (loopback test)
  1221.                     //
  1223.                     ok = compare_buffs(pinBuf, poutBuf,  nBytesRead);
  1225.                                         if( fDumpReadData ) {
  1226.                                                 printf("Dumping read buffern");
  1227.                                                 dump( pinBuf, nBytesRead );     
  1228.                                                 printf("Dumping write buffern");
  1229.                                                 dump( poutBuf, nBytesRead );
  1231.                                         }
  1233.                     assert(ok);
  1235.                                         if(ok != 1)
  1236.                                                 fail++;
  1238.                     assert(ReadLen == WriteLen);
  1239.                     assert(nBytesRead == ReadLen);
  1240.                     assert(nBytesWrite == WriteLen);
  1241.                 }
  1242.                 }
  1243.         
  1244.         }
  1247.         if (pinBuf) {
  1248.             free(pinBuf);
  1249.         }
  1251.         if (poutBuf) {
  1252.             free(poutBuf);
  1253.         }
  1256.                 // close devices if needed
  1257.                 if(hRead != INVALID_HANDLE_VALUE)
  1258.                         CloseHandle(hRead);
  1259.                 if(hWrite != INVALID_HANDLE_VALUE)
  1260.                         CloseHandle(hWrite);
  1262.     }
  1263.         
  1264.         StopIsoStream(); // stop iso stream if we started one
  1266.         return 0;
  1267. }