case USB_RESERVED_DESCRIPTOR_TYPE:
		return "USB_RESERVED_DESCRIPTOR_TYPE";

	case USB_CONFIG_POWER_DESCRIPTOR_TYPE:
		return "USB_CONFIG_POWER_DESCRIPTOR_TYPE";

	case USB_INTERFACE_POWER_DESCRIPTOR_TYPE:
		return "USB_INTERFACE_POWER_DESCRIPTOR_TYPE";
#endif // for current nt5ddk version of USB100.h
		
	default:
		return "??? UNKNOWN!!";	
	}
}


char
*usbEndPointTypeString(UCHAR bmAttributes)
/*++
Routine Description:

    Called to get ascii string of endpt descriptor type

Arguments:

	PUSB_ENDPOINT_DESCRIPTOR->bmAttributes

Return Value:

    ptr to string

--*/
{
	UINT typ = bmAttributes & USB_ENDPOINT_TYPE_MASK;


	switch( typ) {
	case USB_ENDPOINT_TYPE_INTERRUPT:
		return "USB_ENDPOINT_TYPE_INTERRUPT";

	case USB_ENDPOINT_TYPE_BULK:
		return "USB_ENDPOINT_TYPE_BULK";	

	case USB_ENDPOINT_TYPE_ISOCHRONOUS:
		return "USB_ENDPOINT_TYPE_ISOCHRONOUS";	
		
	case USB_ENDPOINT_TYPE_CONTROL:
		return "USB_ENDPOINT_TYPE_CONTROL";	
		
	default:
		return "??? UNKNOWN!!";	
	}
}


char
*usbConfigAttributesString(UCHAR bmAttributes)
/*++
Routine Description:

    Called to get ascii string of USB_CONFIGURATION_DESCRIPTOR attributes

Arguments:

	PUSB_CONFIGURATION_DESCRIPTOR->bmAttributes

Return Value:

    ptr to string

--*/
{
	UINT typ = bmAttributes & USB_CONFIG_POWERED_MASK;


	switch( typ) {

	case USB_CONFIG_BUS_POWERED:
		return "USB_CONFIG_BUS_POWERED";

	case USB_CONFIG_SELF_POWERED:
		return "USB_CONFIG_SELF_POWERED";
		
	case USB_CONFIG_REMOTE_WAKEUP:
		return "USB_CONFIG_REMOTE_WAKEUP";

		
	default:
		return "??? UNKNOWN!!";	
	}
}


void
print_USB_CONFIGURATION_DESCRIPTOR(PUSB_CONFIGURATION_DESCRIPTOR cd)
/*++
Routine Description:

    Called to do formatted ascii dump to console of a USB config descriptor

Arguments:

    ptr to USB configuration descriptor

Return Value:

    none

--*/
{
    printf("\n===================\nUSB_CONFIGURATION_DESCRIPTOR\n");

    printf(
    "bLength = 0x%x, decimal %d\n", cd->bLength, cd->bLength
    );

    printf(
    "bDescriptorType = 0x%x ( %s )\n", cd->bDescriptorType, usbDescriptorTypeString( cd->bDescriptorType )
    );

    printf(
    "wTotalLength = 0x%x, decimal %d\n", cd->wTotalLength, cd->wTotalLength
    );

    printf(
    "bNumInterfaces = 0x%x, decimal %d\n", cd->bNumInterfaces, cd->bNumInterfaces
    );

    printf(
    "bConfigurationValue = 0x%x, decimal %d\n", cd->bConfigurationValue, cd->bConfigurationValue
    );

    printf(
    "iConfiguration = 0x%x, decimal %d\n", cd->iConfiguration, cd->iConfiguration
    );

    printf(
    "bmAttributes = 0x%x ( %s )\n", cd->bmAttributes, usbConfigAttributesString( cd->bmAttributes )
    );

    printf(
    "MaxPower = 0x%x, decimal %d\n", cd->MaxPower, cd->MaxPower
    );
}


void
print_USB_INTERFACE_DESCRIPTOR(PUSB_INTERFACE_DESCRIPTOR id, UINT ix)
/*++
Routine Description:

    Called to do formatted ascii dump to console of a USB interface descriptor

Arguments:

    ptr to USB interface descriptor

Return Value:

    none

--*/
{
    printf("\n-----------------------------\nUSB_INTERFACE_DESCRIPTOR #%d\n", ix);


    printf(
    "bLength = 0x%x\n", id->bLength
    );


    printf(
    "bDescriptorType = 0x%x ( %s )\n", id->bDescriptorType, usbDescriptorTypeString( id->bDescriptorType )
    );


    printf(
    "bInterfaceNumber = 0x%x\n", id->bInterfaceNumber
    );
    printf(
    "bAlternateSetting = 0x%x\n", id->bAlternateSetting
    );
    printf(
    "bNumEndpoints = 0x%x\n", id->bNumEndpoints
    );
    printf(
    "bInterfaceClass = 0x%x\n", id->bInterfaceClass
    );
    printf(
    "bInterfaceSubClass = 0x%x\n", id->bInterfaceSubClass
    );
    printf(
    "bInterfaceProtocol = 0x%x\n", id->bInterfaceProtocol
    );
    printf(
    "bInterface = 0x%x\n", id->iInterface
    );
}


void
print_USB_ENDPOINT_DESCRIPTOR(PUSB_ENDPOINT_DESCRIPTOR ed, int i)
/*++
Routine Description:

    Called to do formatted ascii dump to console of a USB endpoint descriptor

Arguments:

    ptr to USB endpoint descriptor,
	index of this endpt in interface desc

Return Value:

    none

--*/
{
    printf(
	"------------------------------\nUSB_ENDPOINT_DESCRIPTOR for Pipe%02d\n", i
	);

    printf(
    "bLength = 0x%x\n", ed->bLength
    );

    printf(
    "bDescriptorType = 0x%x ( %s )\n", ed->bDescriptorType, usbDescriptorTypeString( ed->bDescriptorType )
    );


	if ( USB_ENDPOINT_DIRECTION_IN( ed->bEndpointAddress ) ) {
		printf(
		"bEndpointAddress= 0x%x ( INPUT )\n", ed->bEndpointAddress
		);
	} else {
		printf(
		"bEndpointAddress= 0x%x ( OUTPUT )\n", ed->bEndpointAddress
		);
	}

    printf(
    "bmAttributes= 0x%x ( %s )\n", ed->bmAttributes, usbEndPointTypeString ( ed->bmAttributes )
    );


    printf(
    "wMaxPacketSize= 0x%x, decimal %d\n", ed->wMaxPacketSize, ed->wMaxPacketSize
    );
    printf(
    "bInterval = 0x%x, decimal %d\n", ed->bInterval, ed->bInterval
    );
}

void
rw_dev( HANDLE hDEV )
/*++
Routine Description:

    Called to do formatted ascii dump to console of  USB
    configuration, interface, and endpoint descriptors
    (Cmdline "rwiso -u" )

Arguments:

    handle to device

Return Value:

    none

--*/
{
	ULONG success;
	int siz, nBytes;
	char buf[256];
    PUSB_CONFIGURATION_DESCRIPTOR cd;
    PUSB_INTERFACE_DESCRIPTOR id;
    PUSB_ENDPOINT_DESCRIPTOR ed;

	siz = sizeof(buf);

	if (hDEV == INVALID_HANDLE_VALUE) {
		NOISY(("DEV not open"));
		return;
	}
	
	success = DeviceIoControl(hDEV,
			IOCTL_ISOUSB_GET_CONFIG_DESCRIPTOR,
			buf,
			siz,
			buf,
			siz,
			&nBytes,
			NULL);

	NOISY(("request complete, success = %d nBytes = %d\n", success, nBytes));
	
	if (success) {
        ULONG i;
		UINT  j, n;
        char *pch;

        pch = buf;
		n = 0;

        cd = (PUSB_CONFIGURATION_DESCRIPTOR) pch;

        print_USB_CONFIGURATION_DESCRIPTOR( cd );

        pch += cd->bLength;

        do {

            id = (PUSB_INTERFACE_DESCRIPTOR) pch;

            print_USB_INTERFACE_DESCRIPTOR(id, n++);

            pch += id->bLength;
            for (j=0; j<id->bNumEndpoints; j++) {

                ed = (PUSB_ENDPOINT_DESCRIPTOR) pch;

                print_USB_ENDPOINT_DESCRIPTOR(ed,j);

                pch += ed->bLength;
            }
            i = (ULONG)(pch - buf);
        } while (i<cd->wTotalLength);

	}
	
	return;

}


int  dumpUsbConfig()
/*++
Routine Description:

    Called to do formatted ascii dump to console of  USB
    configuration, interface, and endpoint descriptors
    (Cmdline "rwiso -u" )

Arguments:

    none

Return Value:

    none

--*/
{

	HANDLE hDEV = open_dev();

	if ( hDEV )
	{
		rw_dev( hDEV );
		CloseHandle(hDEV);
	}

	return 0;
}
//  End, routines for USB configuration and pipe info dump  (Cmdline "rwiso -u" )

// Begin, routines for Iso Streaming



void
IsoStream( HANDLE hDEV, BOOL fStop )
/*++
Routine Description:

    Called to start or stop an iso stream
    (Cmdline "RwIso -g" )

Arguments:

    handle to device

Return Value:

    none

--*/
{
	ULONG success;
	int nBytes;
	DWORD ioctl;
	char i;

	if ( fStop )
	{
		ioctl = IOCTL_ISOUSB_STOP_ISO_STREAM;
		
		for ( i = 0; i < sizeof( gbuf ); i ++ )
			gbuf[ i ] = 0; // init outbuf to 0's to make sure read was good

		success = DeviceIoControl(hDEV,
				ioctl,
				&gpStreamObj, //pointer to stream object initted when stream was started
				sizeof( PVOID),
				gbuf, // output buffer gets back from kernel mode
				sizeof(gbuf),
				&nBytes,
				NULL);

		NOISY(("DeviceIoControl STOP_ISO_STREAM complete, success = %d\n", success));
	}
	else
	{
		ioctl = IOCTL_ISOUSB_START_ISO_STREAM;
		//input is our 256-byte buffer, binary char 0-255
		for ( i = 0; i < sizeof( gbuf ); i ++ )
			gbuf[ i ] = i;

		success = DeviceIoControl(hDEV,
				ioctl,
				gbuf,
				sizeof(gbuf),
				&gpStreamObj, // will receive pointer to stream object
				sizeof( PVOID),
				&nBytes,
				NULL);

		NOISY(("DeviceIoControl START_ISO_STREAM complete, success = %d\n", success));
	}



	if (hDEV == INVALID_HANDLE_VALUE) {
		NOISY(("DEV not open"));
		return;
	}
	

	

}

void StartIsoStream( void )
{
	if ( !ghStreamDev ) {

		ghStreamDev = open_dev();

		if ( ghStreamDev != INVALID_HANDLE_VALUE ) {
			IsoStream(  ghStreamDev , FALSE );

			Sleep( gMS );

			StopIsoStream();
		}
	}
}

void StopIsoStream( void )
{
	if ( ghStreamDev ) {
		IsoStream(  ghStreamDev , TRUE );
		ghStreamDev = NULL;
	}
}

// End, routines for Iso Streaming

int _cdecl main(
    int argc,
	char *argv[])
/*++
Routine Description:

    Entry point to RwIso.exe
    Parses cmdline, performs user-requested tests

Arguments:

    argc, argv  standard console  'c' app arguments

Return Value:

    Zero

--*/

{
    char *pinBuf = NULL, *poutBuf = NULL;
    ULONG nBytesRead, nBytesWrite, nBytes;
	ULONG i, j;
    int ok;
    ULONG success;
    HANDLE hRead = INVALID_HANDLE_VALUE, hWrite = INVALID_HANDLE_VALUE;
	char buf[1024];
	clock_t	start, finish;
	ULONG totalBytes = 0L;
	double seconds;
	ULONG fail = 0L;

    parse(argc, argv );

	// dump USB configuation and pipe info
	if( fDumpUsbConfig ) {
		dumpUsbConfig();
	}


	// doing a read, write, or both test
	if ((fRead) || (fWrite)) {

	    if (fRead) {
            //
            // open the output file
            //
			if ( fDumpReadData ) { // round size to sizeof ULONG for readable dumping
				while( ReadLen % sizeof( ULONG ) )
						ReadLen++;
			}

            hRead = open_file( inPipe);
	
	        pinBuf = malloc(ReadLen);

	    }

	    if (fWrite) {

			if ( fDumpReadData ) { // round size to sizeof ULONG for readable dumping
				while( WriteLen % sizeof( ULONG ) )
						WriteLen++;
			}

	        hWrite = open_file( outPipe);
	        poutBuf = malloc(WriteLen);
	    }


        for (i=0; i<IterationCount; i++) {

    	    if (fWrite && poutBuf && hWrite != INVALID_HANDLE_VALUE) {

				PULONG pOut = (PULONG) poutBuf;
				ULONG  numLongs = WriteLen / sizeof( ULONG );
                //
                // put some data in the output buffer
                //

    	        for (j=0; j<numLongs; j++) {
    	            *(pOut+j) = j;
    	        }

                //
                // send the write
                //

	            WriteFile(hWrite,
	                      poutBuf,
	                      WriteLen,
	                      &nBytesWrite,
	                      NULL);

	            printf("<%s> W (%04.4d) : request %06.6d bytes -- %06.6d bytes written\n",
	                    outPipe, i, WriteLen, nBytesWrite);
                assert(nBytesWrite == WriteLen);
	        }

	        if (fRead && pinBuf) {

	            success = ReadFile(hRead,
	                          pinBuf,
                              ReadLen,
	                          &nBytesRead,
	                          NULL);

	            printf("<%s> R (%04.4d) : request %06.6d bytes -- %06.6d bytes read\n",
	                inPipe, i, ReadLen, nBytesRead);

                if (fWrite) {

                    //
                    // validate the input buffer against what
                    // we sent to the 82930 (loopback test)
                    //

                    ok = compare_buffs(pinBuf, poutBuf,  nBytesRead);

					if( fDumpReadData ) {
						printf("Dumping read buffer\n");
						dump( pinBuf, nBytesRead );	
						printf("Dumping write buffer\n");
						dump( poutBuf, nBytesRead );

					}

                    assert(ok);

					if(ok != 1)
						fail++;

                    assert(ReadLen == WriteLen);
                    assert(nBytesRead == ReadLen);
                    assert(nBytesWrite == WriteLen);
                }
	        }
	
        }


        if (pinBuf) {
            free(pinBuf);
        }

        if (poutBuf) {
            free(poutBuf);
        }


		// close devices if needed
		if(hRead != INVALID_HANDLE_VALUE)
			CloseHandle(hRead);
		if(hWrite != INVALID_HANDLE_VALUE)
			CloseHandle(hWrite);

    }
	
	StopIsoStream(); // stop iso stream if we started one

	return 0;
}