cbit.c

Windows CE 5.0下的U盘驱动源代码。

//
// 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: 

        CBIT.C

Abstract:

        Control/Bulk/Interrupt Transport
        USB Revison 1.0, Dec. 14, 1998

--*/

#include "cbit.h"
BOOL BulkTransferMgrTransfer(LPVOID lpContent, LPTRANSFER_NOTIFY_ROUTINE NotifyRoutine,PVOID NotifyContext,DWORD Flags,
        LPVOID pBuffer,DWORD BufferLength);
BOOL BulkTransferClose(LPVOID lpContent);
BOOL BulkTransferMgrGetStatus(LPVOID lpContent, LPDWORD lpByteTransferred , LPDWORD lpdErrors);
BOOL BulkTransferWait(LPVOID lpContent,DWORD dwTicks);

DWORD
CBIT_CommandTransport(
    PUSBMSC_DEVICE     pUsbDevice,
    PTRANSPORT_COMMAND pCommand,
    PDWORD             pdwBytesTransferred
    );

BOOL
CBIT_ResetAllPipes(
    PUSBMSC_DEVICE pUsbDevice
    );

DWORD
CBIT_StatusTransport(
    PUSBMSC_DEVICE     pUsbDevice
    );


DWORD
CBIT_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;
}


//
// 2.2 Command Block Reset.
//
// Note: CBIT 1.0 sections
//      2.3.2.4 Indefinite Delay, and
//      2.3.2.6 Persistant Command Block Failure 
// in the spec create a failure recovery problem on WCE devices
// since we can not yet suspend or perform a port reset.
//
DWORD
CBIT_CommandBlockReset(
    PUSBMSC_DEVICE pUsbDevice
    )
{
    TRANSPORT_COMMAND tCommand = {0};
    UCHAR             bCommandBlock[12];
        
    DWORD dwErr = 0, dwBytesTransferred = 0;
    
    DEBUGMSG(ZONE_TRACE,(TEXT("USBMSC>CBIT_CommandBlockReset\n")));

    tCommand.Flags   = DATA_OUT;
    tCommand.Timeout = pUsbDevice->Timeouts.CommandBlock;
    tCommand.Length  = USBMSC_SUBCLASS_SCSI == pUsbDevice->pUsbInterface->Descriptor.bInterfaceSubClass ? 6 : 12;
    tCommand.CommandBlock = bCommandBlock;

    memset( bCommandBlock, 0xFF, sizeof(bCommandBlock));  
    bCommandBlock[0] = 0x1D;
    bCommandBlock[1] = 0x04;

    dwErr = CBIT_CommandTransport( pUsbDevice,
                                   &tCommand,
                                   &dwBytesTransferred );

    if ( ERROR_SUCCESS == dwErr ) {
        dwErr = CBIT_StatusTransport( pUsbDevice );
    
    }

    //
    // The host shall send ClearFeature on both Bulk-In and Bulk-Out pipes,
    // which is done in Reset Recovery
    //

    DEBUGMSG(ZONE_TRACE,(TEXT("USBMSC<CBIT_CommandBlockReset:%d\n"), dwErr));

    return dwErr;
}


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

    INIT_DT;

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

    START_DT;
    
    // 0. reset endpoint 0
    dwErr = ResetDefaultEndpoint(pUsbDevice->UsbFuncs, 
                                 pUsbDevice->hUsbDevice);
    
    if ( ERROR_SUCCESS == dwErr ) 
    {
        // 1. send class command
        // CBI1.0: 2.2 - After a Command Block Reset completes, the Stall condition and endpoint's data toggle
        // are undefined. The host shall send Clear Feature to both bulk in and bulk out.
//        dwErr = CBIT_CommandBlockReset(pUsbDevice);
//        if ( ERROR_SUCCESS != dwErr )
//            TEST_TRAP();

        // 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 && pUsbDevice->Interrupt.hPipe) 
            {
                // 4. reset Interrupt endpoint
                dwErr = ResetBulkEndpoint(pUsbDevice->UsbFuncs,
                                          pUsbDevice->hUsbDevice,
                                          pUsbDevice->Interrupt.hPipe,
                                          DefaultTransferComplete,
                                          pUsbDevice->Interrupt.hEvent,
                                          pUsbDevice->Interrupt.bIndex,
                                          pUsbDevice->Timeouts.Reset );
            }
        }
    }

    if (ERROR_SUCCESS == dwErr) {
        bRc = TRUE;
    }

    CBIT_ResetEvent(pUsbDevice->hEP0Event);
    CBIT_ResetEvent(pUsbDevice->BulkIn.hEvent);
    CBIT_ResetEvent(pUsbDevice->BulkOut.hEvent);
    CBIT_ResetEvent(pUsbDevice->Interrupt.hEvent);

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

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



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

   INIT_DT;

   DEBUGMSG(ZONE_TRACE,(TEXT("USBMSC>CBIT_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) ) 
            {
                // 3. reset Interrupt endpoint
                bRc = pUsbDevice->Interrupt.hPipe ? ResetPipe(pUsbDevice->UsbFuncs,pUsbDevice->Interrupt.hPipe,USB_NO_WAIT) : TRUE;
            }
        }
    }

    CBIT_ResetEvent(pUsbDevice->hEP0Event);
    CBIT_ResetEvent(pUsbDevice->BulkIn.hEvent);
    CBIT_ResetEvent(pUsbDevice->BulkOut.hEvent);
    CBIT_ResetEvent(pUsbDevice->Interrupt.hEvent);

    STOP_DT( TEXT("CBIT_ResetAllPipes"), 100, pUsbDevice->Timeouts.Reset );  

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


//
// 4.1 Accept Device-Specific Command (ADSC)
//
DWORD
CBIT_CommandTransport(
    PUSBMSC_DEVICE     pUsbDevice,
    PTRANSPORT_COMMAND pCommand,
    PDWORD             pdwBytesTransferred
    )
{
    USB_DEVICE_REQUEST ADSC = {0};
    DWORD dwErr = 0, dwUsbErr = 0;
    BOOL bRc = FALSE;
    UCHAR count = 0;
    
    INIT_DT;

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

    if ( !pCommand || !pCommand->CommandBlock || !pdwBytesTransferred ) {
        dwErr = ERROR_INVALID_PARAMETER;
        DEBUGMSG(ZONE_ERR,(TEXT("CBIT_CommandTransport error:%d\n"),dwErr));
        SetLastError(dwErr);
        return dwErr;
    }

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

    START_DT;

    // ADSC packet
    ADSC.bmRequestType = USB_REQUEST_HOST_TO_DEVICE | USB_REQUEST_CLASS | USB_REQUEST_FOR_INTERFACE;
    ADSC.bRequest = 0;
    ADSC.wValue   = 0;
    ADSC.wIndex   = pUsbDevice->pUsbInterface->Descriptor.bInterfaceNumber;
    ADSC.wLength  = (USHORT)pCommand->Length;

_retry:
    dwErr = IssueVendorTransfer( pUsbDevice->UsbFuncs,
                                 pUsbDevice->hUsbDevice,
                                 DefaultTransferComplete,
                                 pUsbDevice->hEP0Event,
                                 (USB_OUT_TRANSFER|USB_NO_WAIT|USB_SHORT_TRANSFER_OK),
                                 &ADSC,
                                 pCommand->CommandBlock, 0,
                                 pdwBytesTransferred,
                                 pUsbDevice->Timeouts.CommandBlock,
                                 &dwUsbErr );

    if ( ERROR_SUCCESS != dwErr || USB_NO_ERROR != dwUsbErr || *pdwBytesTransferred != pCommand->Length ) {

        DEBUGMSG( ZONE_ERR, (TEXT("CBIT_CommandTransport error(%d, 0x%x, %d, %d, %d)\n"), 
            dwErr, dwUsbErr, *pdwBytesTransferred, pCommand->Length, pUsbDevice->Timeouts.CommandBlock));

        if (ERROR_SUCCESS == ResetDefaultEndpoint(pUsbDevice->UsbFuncs, pUsbDevice->hUsbDevice) ) {
            if (++count < MAX_CBIT_STALL_COUNT) {
                DEBUGMSG( ZONE_WARN, (TEXT("Retry CBIT_CommandTransport\n")));
                Sleep(ONE_FRAME_PERIOD);
                goto _retry;
            }
        }

        if ( USB_NO_ERROR != dwUsbErr && ERROR_SUCCESS == dwErr) {