disk.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:

    disk.c

Abstract:

    DSK_Xxx Streams Interface for USB Disk Class:
        bInterfaceSubClass = 0x02 : SFF8020i (ATAPI) CD-ROM
        bInterfaceSubClass = 0x04 : USB Floppy Interface (UFI)
        bInterfaceSubClass = 0x06 : SCSI Passthrough

Notes:

--*/

#include <ntcompat.h>
#include <pkfuncs.h>
#include <devload.h>
#include <storemgr.h>

#include "usbmsc.h"
#include "scsi2.h"
BOOL
WaitForUnitReady(
    IN PSCSI_DEVICE pDevice
    );


UCHAR
DiscoverLuns(
    IN PSCSI_DEVICE pDevice
    );

DWORD
GetDiskInfo(
    IN PSCSI_DEVICE     pDevice,
    IN OUT PDISK_INFO   pDiskInfo,
    IN UCHAR            Lun
    );

DWORD
GetMediumInfo(
    IN PSCSI_DEVICE pDevice,
    IN UCHAR        Lun
    );

VOID
RemoveDeviceContext(
   PSCSI_DEVICE pDevice
   );

DWORD WINAPI 
MediaChangeThread(
    LPVOID Context
    );

DWORD
MountUpperDriver(
    IN PSCSI_DEVICE pDevice,
    IN PPOST_INIT_BUF pInBuf
    );

DWORD
DismountUpperDriver(
    IN PSCSI_DEVICE pDevice
    );

DWORD
GetDeviceInfo(
    IN PSCSI_DEVICE pDevice,
    IN OUT STORAGEDEVICEINFO *psdi
    );

#ifdef DEBUG
DBGPARAM dpCurSettings = {
    TEXT("USBDISK6"), {
    TEXT("Errors"),    TEXT("Warnings"),    TEXT("Init"),       TEXT("Trace"),
    TEXT("SCSI"),      TEXT("CDROM"),       TEXT("CDDA"),       TEXT("IOCTL"), 
    TEXT("Read"),      TEXT("Write"),       TEXT("Thread"),     TEXT("Event"),
    TEXT("Undefined"), TEXT("Undefined"),   TEXT("Undefined"),  TEXT("Undefined"),
    },
    0x0003 //0x0123 // 0x0003 // ZONE_WRN|ZONE_ERR
};

#endif  // DEBUG

BOOL 
DllEntry(
   HANDLE hDllHandle, 
   DWORD  dwReason, 
   LPVOID lpreserved
   ) 
{
    BOOL bRc = TRUE;
    
    UNREFERENCED_PARAMETER(hDllHandle);
    UNREFERENCED_PARAMETER(lpreserved);
    
    switch (dwReason) {
        case DLL_PROCESS_ATTACH:
            DEBUGREGISTER((HINSTANCE)hDllHandle);
	    DisableThreadLibraryCalls((HMODULE) hDllHandle);
            break;

        case DLL_PROCESS_DETACH:
            break;

        default:
            break;
    }
   
    return bRc;
}

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

/*++

DSK_Init:
    Called by Device Manager to initialize our streams interface in response to our call to
    ActivateDevice. We passed ActivateDevice a pointer to our device context, but must read 
    it out of the registry as "ClientInfo".

Returns:
    Context pointer used in Xxx_Open, Xxx_PowerDown, Xxx_PowerUp, and Xxx_Deinit

--*/
PSCSI_DEVICE
DSK_Init(
   PVOID Context
   )
{
    LPTSTR ActivePath = (LPTSTR)Context;
    PSCSI_DEVICE pDevice = NULL;
    BOOL  bRc = TRUE;

    DEBUGMSG(ZONE_INIT, (TEXT("USBDISK6>DSK_Init(%p)\n"), Context));

    //
    // Get and verify our Context from the Registry
    //
    pDevice = UsbsGetContextFromReg( ActivePath );

    if ( VALID_CONTEXT( pDevice ) ) {
        //
        // Acquire the remove lock. We release it in DSK_Deinit
        //
        if (ERROR_SUCCESS == AcquireRemoveLock(&pDevice->RemoveLock,NULL)) {
            //
            // Initialize state
            //
            EnterCriticalSection(&pDevice->Lock);

            pDevice->DeviceType = SCSI_DEVICE_UNKNOWN;
            pDevice->MediumType = SCSI_MEDIUM_UNKNOWN;

            pDevice->Flags.MediumPresent = FALSE;
            pDevice->Flags.Open          = FALSE;
            pDevice->Flags.MediumChanged = TRUE;

            pDevice->hProc = GetCallerProcess();

            LeaveCriticalSection(&pDevice->Lock);

            //
            // Try to get Medium information
            //
            GetMediumInfo(pDevice, pDevice->Lun);

        } else {
            bRc = FALSE;
            TEST_TRAP();
        }

    } else {
        bRc = FALSE;
        TEST_TRAP();
    }

    DEBUGMSG(ZONE_INIT, (TEXT("USBDISK6<DSK_Init:0x%x\n"), pDevice ));

    return (bRc ? pDevice : NULL);
}


//
// Called by Device Manager when we Deregister our DSK interface.
//
BOOL
DSK_Deinit(
   PSCSI_DEVICE pDevice
   )
{
    BOOL  bRc = FALSE;

    DEBUGMSG(ZONE_INIT, (TEXT("USBDISK6>DSK_Deinit\n")));

    if ( VALID_CONTEXT( pDevice ) ) {
      
        //EnterCriticalSection( &pDevice->Lock );
        // ...
        //LeaveCriticalSection(&pDevice->Lock);

        //
        // Release the remove lock acquired in DSK_Init
        //
        ReleaseRemoveLock(&pDevice->RemoveLock,NULL);
    }

    DEBUGMSG(ZONE_INIT, (TEXT("USBDISK6<DSK_Deinit:%d\n"), bRc));

    return bRc;
}

















PSCSI_DEVICE
DSK_Open(
   PSCSI_DEVICE Context,      // context returned by DSK_Init.
   DWORD        AccessCode,   // @parm access code
   DWORD        ShareMode     // @parm share mode
   )
{
    PSCSI_DEVICE pDevice = Context;
    BOOL bRc = TRUE;

    UNREFERENCED_PARAMETER(AccessCode);
    UNREFERENCED_PARAMETER(ShareMode);

    DEBUGMSG(ZONE_INIT,(TEXT("USBDISK6>DSK_Open(0x%x, 0x%x, 0x%x)\n"),pDevice, AccessCode, ShareMode));

    //
    // acquire the remove lock; release it in DSK_Close
    //
    if ( VALID_CONTEXT( pDevice ) ) {

        EnterCriticalSection(&pDevice->Lock);

        if ( !pDevice->Flags.DeviceRemoved && !pDevice->Flags.PoweredDown) {

            pDevice->OpenCount++;

            pDevice->Flags.Open = TRUE;

        } else {
            DEBUGMSG( ZONE_ERR,(TEXT("DSK_Open: ERROR_ACCESS_DENIED\n")));
            SetLastError(ERROR_ACCESS_DENIED);
            bRc = FALSE;
        }

        LeaveCriticalSection(&pDevice->Lock);
   
    } else {
        DEBUGMSG( ZONE_ERR,(TEXT("DSK_Open: ERROR_FILE_NOT_FOUND\n")));
        SetLastError(ERROR_FILE_NOT_FOUND);
        bRc = FALSE;
    }

    DEBUGMSG(ZONE_INIT,(TEXT("USBDISK6<DSK_Open:%d\n"), bRc ));

    return (bRc ? pDevice : NULL);
}


BOOL
DSK_Close(
   PSCSI_DEVICE Context
   )
{
    PSCSI_DEVICE pDevice = Context;
    BOOL bRc = TRUE;

    DEBUGMSG(ZONE_INIT,(TEXT("USBDISK6>DSK_Close(0x%x)\n"),pDevice));

    if ( VALID_CONTEXT( pDevice ) ) {

        EnterCriticalSection(&pDevice->Lock);

        if ( 0 == --pDevice->OpenCount ) {

            pDevice->Flags.Open = FALSE;

        }

        ASSERT( pDevice->OpenCount >= 0);

        LeaveCriticalSection(&pDevice->Lock);

    } else {
        DEBUGMSG( ZONE_ERR,(TEXT("DSK_Close: ERROR_INVALID_HANDLE\n")));
        SetLastError(ERROR_INVALID_HANDLE);
        bRc = FALSE;
    }
    
    DEBUGMSG( ZONE_INIT,(TEXT("USBDISK6<DSK_Close:%d\n"), bRc));
    return bRc;
}


ULONG
DSK_Read(
   PSCSI_DEVICE pDevice,
   PUCHAR pBuffer,
   ULONG  BufferLength
   )
{
    UNREFERENCED_PARAMETER(pDevice);
    UNREFERENCED_PARAMETER(pBuffer);
    UNREFERENCED_PARAMETER(BufferLength);
    
    DEBUGMSG(ZONE_ERR,(TEXT("DSK_Read\n")));
    SetLastError(ERROR_INVALID_FUNCTION);
    return  0;
}


ULONG
DSK_Write(
   PSCSI_DEVICE pDevice,
   PUCHAR pBuffer,
   ULONG  BufferLength
   )
{
    UNREFERENCED_PARAMETER(pDevice);
    UNREFERENCED_PARAMETER(pBuffer);
    UNREFERENCED_PARAMETER(BufferLength);

    DEBUGMSG(ZONE_ERR,(TEXT("DSK_Write\n")));
    SetLastError(ERROR_INVALID_FUNCTION);
    return  0;
}


ULONG
DSK_Seek(
   PVOID Context,
   LONG Position,
   DWORD Type
   )
{
    UNREFERENCED_PARAMETER(Context);
    UNREFERENCED_PARAMETER(Position);
    UNREFERENCED_PARAMETER(Type);
    return FAILURE;
}


BOOL
DSK_PowerDown(
   PVOID Context
   )
{
    UNREFERENCED_PARAMETER(Context);
    DEBUGMSG(ZONE_INIT,(TEXT("USBDISK6>DSK_PowerDown\r\n")));
    DEBUGMSG(ZONE_INIT,(TEXT("USBDISK6<DSK_PowerDown\r\n")));
    return TRUE;
}

BOOL
DSK_PowerUp(
   PVOID Context
   )
{
    UNREFERENCED_PARAMETER(Context);
    DEBUGMSG(ZONE_INIT,(TEXT("USBDISK6>DSK_PowerUp\r\n")));
    DEBUGMSG(ZONE_INIT,(TEXT("USBDISK6<DSK_PowerUp\r\n")));
    return TRUE;
}

BOOL
DSK_IOControl(
    PSCSI_DEVICE pDevice,
    DWORD  Ioctl,
    PUCHAR pInBuf,
    DWORD  InBufLen, 
    PUCHAR pOutBuf,
    DWORD  OutBufLen,
    PDWORD pdwBytesTransferred
   )
{
    BOOL   bRead = TRUE, bRc = FALSE;
    DWORD  dwErr  = ERROR_SUCCESS;
    PUCHAR pBuf = NULL;
    DWORD  dwBufLen = 0;

    DEBUGMSG(ZONE_DSK_IOCTL,(TEXT("USBDISK6>DSK_IOControl(IOCTL:0x%x, InBuf:0x%x, InBufLen:%d, OutBuf:0x%x, OutBufLen:0x%x)\n"),
                                    Ioctl, pInBuf, InBufLen, pOutBuf, OutBufLen ));

    if ( ACCEPT_IO(pDevice) ) 
    {
        EnterCriticalSection(&pDevice->Lock);

        switch (Ioctl) 
        {       		
            case IOCTL_DISK_GETINFO: // new ioctls
                pBuf = pOutBuf;
                dwBufLen = OutBufLen;
                break;
            
            case DISK_IOCTL_GETINFO: // old ioctls