} else if ( NULL == pUsbDevice->Interrupt.hPipe &&
                (pEndpoint->Descriptor.bmAttributes & USB_ENDPOINT_TYPE_MASK) == USB_ENDPOINT_TYPE_INTERRUPT) 
            {
                //
                // create the Interrupt pipe
                //
                pUsbDevice->Interrupt.hPipe = pUsbDevice->UsbFuncs->lpOpenPipe( pUsbDevice->hUsbDevice,
                                                                                &pEndpoint->Descriptor );
               if ( !pUsbDevice->Interrupt.hPipe ) {
                    DEBUGMSG( ZONE_ERR, (TEXT("OpenPipe error: %d\n"), GetLastError() ));
                    bRc = FALSE;
                    TEST_TRAP();
                    break;
               }

               //
               // setup any endpoint specific timers, buffers, context, etc.
               //
               pUsbDevice->Interrupt.hEvent = CreateEvent( NULL, MANUAL_RESET_EVENT, FALSE, NULL);
               if ( !pUsbDevice->Interrupt.hEvent ) {
                    DEBUGMSG( ZONE_ERR, (TEXT("CreateEvent error:%d\n"), GetLastError() ));
                    bRc = FALSE;
                    TEST_TRAP();
                    break;
               }

               pUsbDevice->Interrupt.bIndex         = pEndpoint->Descriptor.bEndpointAddress;
               pUsbDevice->Interrupt.wMaxPacketSize = pEndpoint->Descriptor.wMaxPacketSize;
            }
      
        } else {
         DEBUGMSG( ZONE_WARN, (TEXT("Unsupported Endpoint:0x%x\n"), pEndpoint->Descriptor.bEndpointAddress));
         TEST_TRAP();
        }
    }

    //
    // did we find our endpoints?
    //
    bRc = (pUsbDevice->BulkOut.hPipe && pUsbDevice->BulkIn.hPipe) ? TRUE : FALSE;
    switch (pUsbDevice->pUsbInterface->Descriptor.bInterfaceProtocol) {
        case USBMSC_INTERFACE_PROTOCOL_CBIT:
            //
            // CBI Transport 3.4.3: *shall* support the interrupt endpoint
            //
            bRc &= (pUsbDevice->Interrupt.hPipe) ? TRUE : FALSE;
            ASSERTMSG((TEXT("CBI device missing Interrupt endpoint; fix your device!!\n")), bRc );
            break;

         case USBMSC_INTERFACE_PROTOCOL_CBT:
            break;

        case USBMSC_INTERFACE_PROTOCOL_BOT:
            break;

        default:
            bRc = FALSE;
            DEBUGMSG( ZONE_ERR, (TEXT("Unsupported device\n")));
            TEST_TRAP();
            break;
    }

    //
    // close the transfer handle.
    //
    if (hTransfer) {
       bRc = CloseTransferHandle( pUsbDevice->UsbFuncs, hTransfer );
       ASSERT(bRc);
    }

    //
    // if we failed to find all of our endpoints then cleanup will occur later
    //

    DEBUGMSG( ZONE_USB_INIT, (TEXT("USBMSC<SetUsbInterface:%d\n"), bRc));

    return (bRc);
}


VOID
ClosePipe(
    PUSBMSC_DEVICE pUsbDevice,
    PPIPE pPipe
    )
{
    if ( !pUsbDevice || !pUsbDevice->UsbFuncs || !pPipe) {
        DEBUGMSG(ZONE_ERR,(TEXT("Invalid Parameter!\n")));
        return;
    }

    if (pPipe->hPipe) {
        pUsbDevice->UsbFuncs->lpClosePipe(pPipe->hPipe);
    }

    if (pPipe->hEvent) {
        CloseHandle(pPipe->hEvent);
    }

    return;
}


VOID
RemoveDeviceContext(
   PUSBMSC_DEVICE pUsbDevice
   )
{
   DEBUGMSG(ZONE_INIT,(TEXT("USBMSC>RemoveDeviceContext(%p)\n"), pUsbDevice));

   if ( VALID_CONTEXT( pUsbDevice ) ) {

    if ( pUsbDevice->Flags.AcceptIo ) {
        DEBUGMSG(ZONE_ERR,(TEXT("RemoveDeviceContext on open device!!!\n")));
        //TEST_TRAP();
        return;
    }

    ClosePipe( pUsbDevice, &pUsbDevice->BulkOut );
    ClosePipe( pUsbDevice, &pUsbDevice->BulkIn );
    ClosePipe( pUsbDevice, &pUsbDevice->Interrupt );
    DeleteBulkTransferMgr(pUsbDevice->BulkOut.pAsyncContent);
    DeleteBulkTransferMgr(pUsbDevice->BulkIn.pAsyncContent);

    if (pUsbDevice->hEP0Event) {
        CloseHandle(pUsbDevice->hEP0Event);
    }
      
    if (&pUsbDevice->Lock) {
        DeleteCriticalSection( &pUsbDevice->Lock );
    }

    if (pUsbDevice->hDiskDriver) {
        FreeLibrary(pUsbDevice->hDiskDriver);
    }
      
    LocalFree(pUsbDevice);
   
   } else {
      DEBUGMSG(ZONE_ERR,(TEXT("Invalid Parameter\n")));
   }

   DEBUGMSG(ZONE_INIT,(TEXT("USBMSC<RemoveDeviceContext\n")));
   
   return;
}


//*****************************************************************************
//
//  U S B M S C      I N T E R F A C E
//
//*****************************************************************************


/*++

UsbsDataTransfer:
   Called by the USB Disk driver to place the block command on the USB.
   Used for reads, writes, commands, etc.

 hTransport:
   The Transport handle passed to DiskAttach.

 pCommand:
    Pointer to Command Block for this transaction.

 pData:
    Pointer to Data Block for this transaction. May be NULL.

 Returns:
   Win32 error code.

--*/
DWORD
UsbsDataTransfer(
    HANDLE             hTransport,
    PTRANSPORT_COMMAND pCommand,
    OPTIONAL PTRANSPORT_DATA pData
    )
{
    PUSBMSC_DEVICE pUsbDevice = (PUSBMSC_DEVICE)hTransport;
    DWORD dwErr = ERROR_SUCCESS;

    DEBUGMSG(ZONE_INIT,(TEXT("USBMSC>UsbsDataTransfer\n")));    

    if ( hTransport && pCommand )
    {
        if ( ACCEPT_IO(pUsbDevice) ) 
        {
            if (pData) {
                // preset the number of bytes transferred
                pData->TransferLength = 0; 
            }

            //
            // MUX the Transport Protocol
            //
            switch ( pUsbDevice->pUsbInterface->Descriptor.bInterfaceProtocol ) {

                case USBMSC_INTERFACE_PROTOCOL_CBIT:
                    DEBUGMSG(ZONE_INIT,(TEXT("USBMSC_INTERFACE_PROTOCOL_CBIT\n")));
                    dwErr = CBIT_DataTransfer( pUsbDevice, pCommand, pData, (pCommand->Flags & DATA_IN));
                    break;

                case USBMSC_INTERFACE_PROTOCOL_CBT:
                    DEBUGMSG(ZONE_INIT,(TEXT("USBMSC_INTERFACE_PROTOCOL_CBT\n")));
                    // TEST_TRAP(); // !! this is currently untested - need a device !!
                    dwErr = CBIT_DataTransfer( pUsbDevice, pCommand, pData, (pCommand->Flags & DATA_IN));
                    break;
        
                case USBMSC_INTERFACE_PROTOCOL_BOT:
                    DEBUGMSG(ZONE_INIT,(TEXT("USBMSC_INTERFACE_PROTOCOL_BOT\n")));
                    dwErr = BOT_DataTransfer( pUsbDevice, pCommand, pData, (pCommand->Flags & DATA_IN));
                    break;

                default:
                    DEBUGMSG(ZONE_ERR,(TEXT("ERROR_INVALID_DRIVE\n")));
                    dwErr = ERROR_INVALID_DRIVE;
                    SetLastError(dwErr);
                    break;
            }

        } else {
            dwErr = ERROR_ACCESS_DENIED;
            SetLastError( dwErr );
            DEBUGMSG(ZONE_ERR,(TEXT("UsbsDataTransfer error: %d\n"), dwErr));
        }

    } else {
        dwErr = ERROR_INVALID_PARAMETER;
        SetLastError( dwErr );
    }

    DEBUGMSG(ZONE_INIT,(TEXT("USBMSC<UsbsDataTransfer:%d\n"), dwErr));
    return dwErr;
}

DWORD GetMaxLUN(HANDLE hTransport, PUCHAR pLun)
{
    PUSBMSC_DEVICE pUsbDevice = (PUSBMSC_DEVICE)hTransport;
    DWORD dwErr = ERROR_INVALID_PARAMETER;

    DEBUGMSG(ZONE_INIT,(TEXT("USBMSC>GetMaxLUN\n")));    

    if ( hTransport  && pLun ) {
        if ( ACCEPT_IO(pUsbDevice) ) 
            switch ( pUsbDevice->pUsbInterface->Descriptor.bInterfaceProtocol ) {
                case USBMSC_INTERFACE_PROTOCOL_BOT:
                    DEBUGMSG(ZONE_INIT,(TEXT("USBMSC_INTERFACE_PROTOCOL_BOT\n")));
                    dwErr = BOT_GetMaxLUN( pUsbDevice,pLun );
                    break;
                default:
                    DEBUGMSG(ZONE_INIT,(TEXT("Default\n")));
                    *pLun = 1;
                    break;
            }
        DEBUGMSG(ZONE_INIT,(TEXT("USBMSC>GetMaxLUN return dwErr=%d,*pLun=%d\n"),dwErr,*pLun));    
    }
    return dwErr;
}
//*****************************************************************************
//
//      E X P O R T E D     U T I L S
//
//*****************************************************************************


//
// Returns the context pointer stored by Device Manager in the driver's Active path.
// The caller should check the pointer's validity.
//
PVOID
UsbsGetContextFromReg(
   LPTSTR  ActivePath
   )
{
    BOOL bRc;
    PVOID pClientInfo = NULL;
    DWORD dwValue = 0;
    REG_VALUE_DESCR rdValDesc[] = {
        TEXT("ClientInfo"), REG_DWORD, sizeof(DWORD), (PUCHAR)(&dwValue),
        NULL, 0, 0, NULL
    };

    if ( ActivePath ) {

        bRc = GetSetKeyValues( ActivePath,
                                   rdValDesc,
                                   GET, 
                                   FALSE );

        // return the val
        if ( bRc ) {
            pClientInfo = (PVOID)dwValue;
        }

    } else {
        DEBUGMSG(ZONE_ERR, (TEXT("Invalid Parameter\n")));
    }

    return pClientInfo;
}


BOOL
UsbDeviceTest(
   PUSBMSC_DEVICE  pUsbDevice
   )
{
#if 1
    UNREFERENCED_PARAMETER(pUsbDevice);
#else
    DWORD dwErr;

    //
   // set stall on EP0
   //
   dwErr = ClearOrSetFeature( pUsbDevice->UsbFuncs,
                              pUsbDevice->hUsbDevice,
                              DefaultTransferComplete,
                              pUsbDevice->hEP0Event,
                              USB_SEND_TO_ENDPOINT,
                              USB_FEATURE_ENDPOINT_STALL,
                              0, // bIndex
                              1000,
                              TRUE );

   if ( ERROR_SUCCESS != dwErr ) {
      DEBUGMSG( ZONE_ERR, (TEXT("SetFeature error:%d\n"), dwErr ));
      TEST_TRAP();
   }

   //
   // clear EP0
   //
   ResetDefaultEndpoint(pUsbDevice->UsbFuncs, pUsbDevice->hUsbDevice);

   //
   // set stall on the BulkOut endpoint
   //
   dwErr = ClearOrSetFeature( pUsbDevice->UsbFuncs,
                              pUsbDevice->hUsbDevice,
                              DefaultTransferComplete,
                              pUsbDevice->hEP0Event,
                              USB_SEND_TO_ENDPOINT,
                              USB_FEATURE_ENDPOINT_STALL,
                              pUsbDevice->BulkOut.bIndex,
                              1000,
                              TRUE );
   
   if ( ERROR_SUCCESS != dwErr ) {
      DEBUGMSG( ZONE_ERR, (TEXT("SetFeature error:%d\n"), dwErr));
      TEST_TRAP();
   }
   
   //
   // clear it
   //
   dwErr = ClearOrSetFeature( pUsbDevice->UsbFuncs,
                              pUsbDevice->hUsbDevice,
                              DefaultTransferComplete,
                              pUsbDevice->hEP0Event,
                              USB_SEND_TO_ENDPOINT,
                              USB_FEATURE_ENDPOINT_STALL,
                              pUsbDevice->BulkOut.bIndex,
                              1000,
                              FALSE );
   
   if ( ERROR_SUCCESS != dwErr ) {
      DEBUGMSG( ZONE_ERR, (TEXT("ClearFeature error:%d\n"), dwErr));
      TEST_TRAP();
   }


   //
   // set stall on the BulkIn endpoint
   //
   dwErr = ClearOrSetFeature( pUsbDevice->UsbFuncs,
                              pUsbDevice->hUsbDevice,
                              DefaultTransferComplete,
                              pUsbDevice->hEP0Event,
                              USB_SEND_TO_ENDPOINT,
                              USB_FEATURE_ENDPOINT_STALL,
                              pUsbDevice->BulkIn.bIndex,
                              1000,
                              TRUE );

   if ( ERROR_SUCCESS != dwErr ) {
      DEBUGMSG( ZONE_ERR, (TEXT("SetFeature error:%d\n"), dwErr));
      TEST_TRAP();
   }

   //
   // clear it
   //
   dwErr = ClearOrSetFeature( pUsbDevice->UsbFuncs,
                              pUsbDevice->hUsbDevice,
                              DefaultTransferComplete,
                              pUsbDevice->hEP0Event,
                              USB_SEND_TO_ENDPOINT,
                              USB_FEATURE_ENDPOINT_STALL,
                              pUsbDevice->BulkIn.bIndex,
                              1000,
                              FALSE );

   if ( ERROR_SUCCESS != dwErr ) {
      DEBUGMSG( ZONE_ERR, (TEXT("ClearFeature error:%d\n"), dwErr ));
      TEST_TRAP();
   }

#endif // 0

   return TRUE;
}

// EOF