//
// Copyright (c) Microsoft Corporation.  All rights reserved.
//
//
// Use of this source code is subject to the terms of the Microsoft end-user
// license agreement (EULA) under which you licensed this SOFTWARE PRODUCT.
// If you did not accept the terms of the EULA, you are not authorized to use
// this source code. For a copy of the EULA, please see the LICENSE.RTF on your
// install media.
//
/*++

THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF
ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO
THE IMPLIED WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A
PARTICULAR PURPOSE.

Module Name: 

        BOT.C

Abstract:

        Bulk-Only Transport
        USB Revison 1.0, Sept. 31, 1999

--*/

#include "bot.h"

BOOL
BOT_ResetAllPipes(
    PUSBMSC_DEVICE pUsbDevice
    );

DWORD
BOT_ResetEvent(
    HANDLE hEvent
    )
{
    DWORD dwErr = ERROR_SUCCESS;

    if ( hEvent && !ResetEvent(hEvent) ) {
        ASSERT(0);
        dwErr = GetLastError();
        DEBUGMSG( ZONE_ERR,(TEXT("*** ResetEvent ERROR:%d ***\n"), dwErr));
        return dwErr;
    }

    return TRUE;
}


//
// 3.1 Bulk-Only Mass Storage Reset.
// This class-specific command shall ready the device for the next CBW.
//
BOOL
BOT_MassStorageReset(
    PUSBMSC_DEVICE pUsbDevice
    )
{
    USB_DEVICE_REQUEST ControlHeader;
    DWORD dwBytesTransferred = 0;
    DWORD dwErr = 0, dwUsbErr = 0;
    BOOL bRc = FALSE;
    UCHAR count = 0;
    
    INIT_DT;

    DEBUGMSG( ZONE_TRACE, (TEXT("USBMSC>BOT_MassStorageReset\n")));

    START_DT;

    if ( ACCEPT_IO(pUsbDevice) ) {

        ControlHeader.bmRequestType = USB_REQUEST_HOST_TO_DEVICE | USB_REQUEST_CLASS | USB_REQUEST_FOR_INTERFACE;
        ControlHeader.bRequest = 255;
        ControlHeader.wValue = 0;
        ControlHeader.wIndex = pUsbDevice->pUsbInterface->Descriptor.bInterfaceNumber;
        ControlHeader.wLength = 0;
_retry:
        dwErr = IssueVendorTransfer( pUsbDevice->UsbFuncs,
                                     pUsbDevice->hUsbDevice,
                                     DefaultTransferComplete,
                                     pUsbDevice->hEP0Event,
                                     (USB_OUT_TRANSFER|USB_NO_WAIT|USB_SHORT_TRANSFER_OK),
                                     &ControlHeader,
                                     NULL, 0,
                                     &dwBytesTransferred,
                                     pUsbDevice->Timeouts.Reset,
                                     &dwUsbErr );

        if ( ERROR_SUCCESS == dwErr && USB_NO_ERROR == dwUsbErr ) {
            bRc = TRUE;
        } else if (ERROR_SUCCESS == ResetDefaultEndpoint(pUsbDevice->UsbFuncs, pUsbDevice->hUsbDevice) ) {
            if (++count < MAX_BOT_STALL_COUNT) {
                DEBUGMSG( ZONE_WARN, (TEXT("Retry BOT_MassStorageReset\n")));
                Sleep(ONE_FRAME_PERIOD);
                //TEST_TRAP();
                goto _retry;
            }
        }
    }

    STOP_DT( TEXT("BOT_MassStorageReset"), 10, pUsbDevice->Timeouts.Reset );
    
    DEBUGMSG( ZONE_TRACE, (TEXT("USBMSC<BOT_MassStorageReset:%d\n"), bRc) );

    return bRc;
}


//
// 3.2 Get Max LUN
//
UCHAR
BOT_GetMaxLUN(
    PUSBMSC_DEVICE pUsbDevice
    )
{
    USB_DEVICE_REQUEST ControlHeader;
    DWORD dwBytesTransferred = 0;
    UCHAR bMaxLun = 0xFF;
    DWORD dwErr = 0, dwUsbErr = 0;
    BOOL bRc = FALSE;

    INIT_DT;

    DEBUGMSG( ZONE_TRACE, (TEXT("USBMSC>BOT_GetMaxLUN\n")));

    START_DT;

    if ( ACCEPT_IO(pUsbDevice) ) {

        ControlHeader.bmRequestType = USB_REQUEST_DEVICE_TO_HOST | USB_REQUEST_CLASS | USB_REQUEST_FOR_INTERFACE;
        ControlHeader.bRequest = 254;
        ControlHeader.wValue = 0;
        ControlHeader.wIndex = pUsbDevice->pUsbInterface->Descriptor.bInterfaceNumber;
        ControlHeader.wLength = 1;

        dwErr = IssueVendorTransfer( pUsbDevice->UsbFuncs,
                                     pUsbDevice->hUsbDevice,
                                     DefaultTransferComplete,
                                     pUsbDevice->hEP0Event,
                                     (USB_IN_TRANSFER|USB_NO_WAIT|USB_SHORT_TRANSFER_OK),
                                     &ControlHeader,
                                     &bMaxLun, 0,
                                     &dwBytesTransferred,
                                     pUsbDevice->Timeouts.CommandBlock,
                                     &dwUsbErr );

        if ( ERROR_SUCCESS != dwErr || USB_NO_ERROR != dwUsbErr ) {
            
            ResetDefaultEndpoint(pUsbDevice->UsbFuncs, pUsbDevice->hUsbDevice);
                    
        }

    } 

    STOP_DT( TEXT("BOT_GetMaxLUN"), 10, pUsbDevice->Timeouts.CommandBlock );

    DEBUGMSG( ZONE_TRACE, (TEXT("USBMSC<BOT_GetMaxLUN:%d\n"), bMaxLun ));

    return bMaxLun;
}


//
// 5.3.4 Reset Recovery
//
BOOL
BOT_ResetRecovery(
    PUSBMSC_DEVICE pUsbDevice
    )
{
    BOOL bRc = FALSE;
    DWORD dwErr;

    INIT_DT;

    DEBUGMSG(ZONE_TRACE,(TEXT("USBMSC>BOT_ResetRecovery\n")));

    START_DT;
    
    // 0. reset endpoint 0
    dwErr = ResetDefaultEndpoint(pUsbDevice->UsbFuncs, 
                                 pUsbDevice->hUsbDevice);
    
    if ( ERROR_SUCCESS == dwErr ) 
    {
        // 1. send class command
        BOT_MassStorageReset(pUsbDevice);

        // 2. reset BulkIn endpoint
        dwErr = ResetBulkEndpoint(pUsbDevice->UsbFuncs, 
                                  pUsbDevice->hUsbDevice,
                                  pUsbDevice->BulkIn.hPipe,
                                  DefaultTransferComplete,
                                  pUsbDevice->BulkIn.hEvent,
                                  pUsbDevice->BulkIn.bIndex,
                                  pUsbDevice->Timeouts.Reset);
        
        if ( ERROR_SUCCESS == dwErr) 
        {
            // 3. reset BulkOut endpoint
            dwErr = ResetBulkEndpoint(pUsbDevice->UsbFuncs, 
                                      pUsbDevice->hUsbDevice,
                                      pUsbDevice->BulkOut.hPipe,
                                      DefaultTransferComplete,
                                      pUsbDevice->BulkOut.hEvent,
                                      pUsbDevice->BulkOut.bIndex,
                                      pUsbDevice->Timeouts.Reset );

            if ( ERROR_SUCCESS == dwErr ) {
                bRc = TRUE;
            }  //else TEST_TRAP();

        }  //else TEST_TRAP();
        //}
    } //else TEST_TRAP();

    BOT_ResetEvent(pUsbDevice->hEP0Event);
    BOT_ResetEvent(pUsbDevice->BulkIn.hEvent);
    BOT_ResetEvent(pUsbDevice->BulkOut.hEvent);

    STOP_DT( TEXT("BOT_ResetRecovery"), 10, pUsbDevice->Timeouts.Reset );
    
    DEBUGMSG(ZONE_TRACE,(TEXT("USBMSC<BOT_ResetRecovery:%d\n"), bRc));
   
    return bRc;
}



//
// Reset All Pipes
//
BOOL
BOT_ResetAllPipes(
    PUSBMSC_DEVICE pUsbDevice
    )
{
   BOOL bRc = FALSE;
   DWORD dwErr;

   INIT_DT;

   DEBUGMSG(ZONE_TRACE,(TEXT("USBMSC>BOT_ResetAllPipes\n")));

   START_DT

   // 0. reset endpoint 0
   dwErr = ResetDefaultEndpoint(pUsbDevice->UsbFuncs, 
                                pUsbDevice->hUsbDevice);

   if ( ERROR_SUCCESS == dwErr ) 
   {
        // 1. reset BulkIn endpoint
        if ( ResetPipe(pUsbDevice->UsbFuncs,
                       pUsbDevice->BulkIn.hPipe,
                       USB_NO_WAIT) ) 
        {
            // 2. reset BulkOut endpoint
            if ( ResetPipe(pUsbDevice->UsbFuncs,
                           pUsbDevice->BulkOut.hPipe,
                           USB_NO_WAIT) ) 
            {               
                bRc = TRUE;
            }
        }
    }

    BOT_ResetEvent(pUsbDevice->hEP0Event);
    BOT_ResetEvent(pUsbDevice->BulkIn.hEvent);
    BOT_ResetEvent(pUsbDevice->BulkOut.hEvent);

    STOP_DT( TEXT("BOT_ResetAllPipes"), 10, pUsbDevice->Timeouts.Reset );  

    DEBUGMSG(ZONE_TRACE,(TEXT("USBMSC<BOT_ResetAllPipes:%d\n"), bRc));
   
    return bRc;
}


//
// See 5.3 Data Transfer Conditions
//
DWORD
BOT_DataTransfer(
    PUSBMSC_DEVICE           pUsbDevice,
    PTRANSPORT_COMMAND       pCommand,
    OPTIONAL PTRANSPORT_DATA pData, // OPTIONAL
    BOOL                     Direction // TRUE = Data-In, else Data-Out
    )
{
    // Command Block Wrapper
    CBW Cbw;
    DWORD dwCbwSize = sizeof(CBW);

    // Command Status Wrapper
    CSW Csw;
    DWORD dwCswSize = sizeof(CSW);

    DWORD dwBytesTransferred = 0;   
    DWORD dwErr = ERROR_SUCCESS;
    DWORD dwUsbErr = USB_NO_ERROR;
    DWORD dwResetErr, dwCswErr;

    BOOL  bRc = FALSE;
    UCHAR ucStallCount;

    INIT_DT;

    DEBUGMSG(ZONE_TRACE,(TEXT("USBMSC>BOT_DataTransfer\n")));

    // parameter check
    if ( !pCommand || !pCommand->CommandBlock || pCommand->Length > MAX_CBWCB_SIZE ) {
        dwErr = ERROR_INVALID_PARAMETER;
        DEBUGMSG(ZONE_ERR,(TEXT("BOT_DataTransfer error:%d\n"),dwErr));
        SetLastError(dwErr);
        return dwErr;
    }

    if ( !ACCEPT_IO(pUsbDevice) ) {
        dwErr = ERROR_ACCESS_DENIED;
        DEBUGMSG( ZONE_ERR,(TEXT("BOT_DataTransfer error:%d\n"), dwErr));
        SetLastError(dwErr);
        return dwErr;
    }

    //
    // We require exclusive entry into the transport.
    // we could implement command queuing.
    //
    EnterCriticalSection(&pUsbDevice->Lock);

    if ( !BOT_ResetAllPipes(pUsbDevice) ) {
        DEBUGMSG( ZONE_ERR, (TEXT("BOT_ResetAllPipes failed!\n")));
        dwErr = ERROR_GEN_FAILURE;
        goto BOT_SendCommandDone;
    }

    ucStallCount = 0;

    pUsbDevice->dwCurTag++;

    memset( &Cbw, 0, dwCbwSize );
    memset( &Csw, 0, dwCswSize );

    //
    // build the active CBW
    //        
    Cbw.dCBWSignature = CBW_SIGNATURE;