disk.c

WIN CE 下storage 存储外设的驱动程序

{
    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;
    BOOL   bRc = FALSE;
    DWORD  dwErr = ERROR_SUCCESS;
    PUCHAR pBuf = NULL;
    DWORD  dwBufLen = 0;
    DWORD  SafeBytesReturned = 0;

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

    if (!ACCEPT_IO(pDevice)) {
        DEBUGMSG(ZONE_ERR, (TEXT("USBDISK6>DSK_IOControl: The device is not available\r\n")));
        SetLastError(ERROR_DEVICE_NOT_AVAILABLE);
        return FALSE;
    }

    EnterCriticalSection(&pDevice->Lock);

    switch (Ioctl)
    {
        case IOCTL_DISK_GETINFO:
            pBuf = pOutBuf;
            dwBufLen = OutBufLen;
            break;

        case DISK_IOCTL_GETINFO:
            pBuf = pInBuf;
            dwBufLen = InBufLen;
            break;

        case IOCTL_DISK_READ:
        case IOCTL_DISK_WRITE:
            bRead = IOCTL_DISK_READ == Ioctl ? TRUE : FALSE;
            break;

        case DISK_IOCTL_READ:
        case DISK_IOCTL_WRITE:
            bRead = DISK_IOCTL_READ == Ioctl ? TRUE : FALSE;
            break;

        default:
            break;
    }

    switch (Ioctl)
    {
        // This IOCTL is deprecated.
        case IOCTL_DISK_INITIALIZED:
        case DISK_IOCTL_INITIALIZED:
            DEBUGMSG(ZONE_DSK_IOCTL,(TEXT("USBDISK6>DSK_IOControl>IOCTL_DISK_INITIALIZED\r\n")));
            if (
                !IsStorageManagerRunning() &&
                pInBuf &&
                InBufLen >= sizeof(PPOST_INIT_BUF)
            ) {
                MountUpperDriver(pDevice, (PPOST_INIT_BUF)pInBuf);
                break;
            }
            DEBUGMSG(ZONE_TRACE, (L"USBDISK>DSK_IOControl> Not loading FSD; Storage Manager running\r\n"));
            break;

        case IOCTL_DISK_DEVICE_INFO:
        {
            STORAGEDEVICEINFO SafeStorageDeviceInfo = {0};
            SafeBytesReturned = sizeof(STORAGEDEVICEINFO);
            DEBUGMSG(ZONE_DSK_IOCTL, (TEXT("USBDISK6>DSK_IOControl>IOCTL_DISK_DEVICE_INFO\r\n")));
            if ((pInBuf == NULL) || InBufLen != sizeof(STORAGEDEVICEINFO))
            {
                dwErr = ERROR_INVALID_PARAMETER;
                break;
            }
            dwErr = GetDeviceInfo(pDevice, &SafeStorageDeviceInfo);
            if (ERROR_SUCCESS != dwErr) {
                break;
            }
            if (0 == CeSafeCopyMemory((LPVOID)pInBuf, (LPVOID)&SafeStorageDeviceInfo, sizeof(STORAGEDEVICEINFO))) {
                dwErr = ERROR_INVALID_PARAMETER;
                break;
            }
            if (pdwBytesTransferred) {
                if (0 == CeSafeCopyMemory((LPVOID)pdwBytesTransferred, (LPVOID)&SafeBytesReturned, sizeof(DWORD))) {
                    dwErr = ERROR_INVALID_PARAMETER;
                    break;
                }
            }
            break;
        }

        case IOCTL_DISK_GETINFO:
        case DISK_IOCTL_GETINFO:
        {
            DISK_INFO SafeDiskInfo = {0};
            SafeBytesReturned = 0;
            DEBUGMSG(ZONE_DSK_IOCTL, (TEXT("USBDISK6>DSK_IOControl>IOCTL_DISK_GETINFO\r\n")));
            if (NULL == pBuf || dwBufLen != sizeof(DISK_INFO)) {
                dwErr = ERROR_INVALID_PARAMETER;
                break;
            }
            // If a device is attached and a medium is present, then we may
            // have already fetched its disk info.
            if (
                pDevice ->Flags.MediumPresent &&
                0 != pDevice->DiskInfo.di_total_sectors &&
                0 != pDevice->DiskInfo.di_bytes_per_sect
            ) {
                // Fetch cached copy of the device's disk info.
                memcpy((LPVOID)&SafeDiskInfo, (LPVOID)&pDevice->DiskInfo, sizeof(DISK_INFO));
                bRc = TRUE;
            }
            else {
                // Query the device blindly.
                if (0 == GetDiskInfo(pDevice, &SafeDiskInfo, pDevice->Lun)) {
                    // We failed to fetch the medium's device info.  A device
                    // may not be attached or may not contain media.
                    DEBUGMSG(ZONE_ERR, (TEXT("USBDISK6>DSK_IOControl> A device is not attached or does not contain media\r\n")));
                    // Reset our cached copy of the device's disk info.
                    memset((PVOID)&pDevice->DiskInfo, sizeof(DISK_INFO), 0);
                }
                else {
                    // The device returned disk info.
                    pDevice->Flags.FSDMounted = TRUE;
                    pDevice->Flags.MediumChanged = FALSE;
                    bRc = TRUE;
                }
            }
            if (bRc) {
                if (0 == CeSafeCopyMemory((LPVOID)pBuf, (LPVOID)&SafeDiskInfo, sizeof(DISK_INFO))) {
                    dwErr = ERROR_INVALID_PARAMETER;
                    break;
                }
                if (pdwBytesTransferred) {
                    if (0 == CeSafeCopyMemory((LPVOID)pdwBytesTransferred, (LPVOID)&SafeBytesReturned, sizeof(DWORD))) {
                        dwErr = ERROR_INVALID_PARAMETER;
                        break;
                    }
                }
            }
            break;
        }

        case IOCTL_DISK_SETINFO:
        case DISK_IOCTL_SETINFO:
        {
            DISK_INFO SafeDiskInfo = {0};
            SafeBytesReturned = sizeof(DISK_INFO);
            DEBUGMSG(ZONE_DSK_IOCTL, (TEXT("USBDISK6>DSK_IOControl>IOCTL_DISK_SETINFO\r\n")));
            if (NULL == pInBuf || InBufLen != sizeof(DISK_INFO)) {
                dwErr = ERROR_INVALID_PARAMETER;
                break;
            }
            if (0 == CeSafeCopyMemory((LPVOID)&SafeDiskInfo, (LPVOID)pInBuf, sizeof(DISK_INFO))) {
                dwErr = ERROR_INVALID_PARAMETER;
                break;
            }
            memcpy((LPVOID)&pDevice->DiskInfo, (LPVOID)&SafeDiskInfo, sizeof(DISK_INFO));
            if (pdwBytesTransferred) {
                if (0 == CeSafeCopyMemory((LPVOID)pdwBytesTransferred, (LPVOID)&SafeBytesReturned, sizeof(DWORD))) {
                    dwErr = ERROR_INVALID_PARAMETER;
                    break;
                }
            }
            break;
        }

        case IOCTL_DISK_READ:
        case IOCTL_DISK_WRITE:
        case DISK_IOCTL_READ:
        case DISK_IOCTL_WRITE:
        {
            DEBUGMSG(ZONE_DSK_IOCTL, (TEXT("USBDISK6>DSK_IOControl>%s\r\n"),
                (bRead ? TEXT("IOCTL_DISK_READ"):TEXT("IOCTL_DISK_WRITE"))));
            // Sterilize the caller's SG_REQ.
            if (!SterilizeIoRequest(
                pDevice->pSterileIoRequest,
                (PSG_REQ)pInBuf,
                InBufLen)
            ) {
                dwErr = ERROR_INVALID_PARAMETER;
                break;
            }
            // If write, ensure that the device is not write-protected.
            if (!bRead && pDevice->Flags.WriteProtect) {
                dwErr = ERROR_WRITE_PROTECT;
                break;
            }
            pDevice->Flags.MediumChanged = FALSE;
            // Initiate I/O.  Note that, to determine if ScsiRWSG succeeded,
            // we are required to inspect the sr_status.  It's safe to do so,
            // because pSterileIoRequest is our safe copy of the caller's
            // SG_REQ.
            SafeBytesReturned = ScsiRWSG(
                pDevice,
                pDevice->pSterileIoRequest,
                pDevice->Lun,
                bRead
                );
            if (pdwBytesTransferred) {
                if (0 == CeSafeCopyMemory((LPVOID)pdwBytesTransferred, (LPVOID)&SafeBytesReturned, sizeof(DWORD))) {
                    dwErr = ERROR_INVALID_PARAMETER;
                    break;
                }
            }
            
            dwErr = pDevice->pSterileIoRequest->sr_status;
            if (ERROR_SUCCESS != dwErr) {
                break;
            }
            break;
        }

        case IOCTL_DISK_FORMAT_MEDIA:
        case DISK_IOCTL_FORMAT_MEDIA:
            DEBUGMSG(ZONE_DSK_IOCTL, (TEXT("USBDISK6>DSK_IOControl>IOCTL_DISK_FORMAT_MEDIA\r\n")));
            break;

        case IOCTL_DISK_GETNAME:
        case DISK_IOCTL_GETNAME:
        {
            WCHAR SafeFolderName[] = DEFAULT_FOLDER_SZ;
            SafeBytesReturned = sizeof(DEFAULT_FOLDER_SZ);
            DEBUGMSG(ZONE_DSK_IOCTL, (TEXT("USBDISK6>DSK_IOControl>IOCTL_DISK_GETNAME\r\n")));
            if (pOutBuf == NULL) {
                dwErr = ERROR_INVALID_PARAMETER;
                break;
            }
            if (OutBufLen < sizeof(DEFAULT_FOLDER_SZ)) {
                dwErr = ERROR_INSUFFICIENT_BUFFER;
                break;
            }
            if (0 == CeSafeCopyMemory((LPVOID)pOutBuf, (LPVOID)SafeFolderName, sizeof(DEFAULT_FOLDER_SZ))) {
                dwErr = ERROR_INVALID_PARAMETER;
                break;
            }
            if (pdwBytesTransferred) {
                if (0 == CeSafeCopyMemory((LPVOID)pdwBytesTransferred, (LPVOID)&SafeBytesReturned, sizeof(DWORD))) {
                    dwErr = ERROR_INVALID_PARAMETER;
                    break;
                }
            }
            break;
        }

        case IOCTL_SCSI_PASSTHROUGH:
        {
            TRANSPORT_COMMAND SafeTransportCommand = {0};
            TRANSPORT_DATA    SafeTransportData = {0};
            LPVOID            pCommandBlockOrig = NULL;
            LPVOID            pDataBlockOrig = NULL;
            
            SafeBytesReturned = 0;
            DEBUGMSG(ZONE_DSK_IOCTL, (TEXT("USBDISK6>DSK_IOControl>IOCTL_SCSI_PASSTHROUGH\r\n")));
            if (
                NULL == pInBuf ||
                InBufLen != sizeof(TRANSPORT_COMMAND) ||
                NULL == pOutBuf ||
                OutBufLen != sizeof(TRANSPORT_DATA))
            {
                dwErr = ERROR_INVALID_PARAMETER;
                break;
            }
            // Sterilize the caller's command wrapper.
            if (0 == CeSafeCopyMemory((LPVOID)&SafeTransportCommand, (LPVOID)pInBuf, sizeof(TRANSPORT_COMMAND))) {
                dwErr = ERROR_INVALID_PARAMETER;
                break;
            }
            // Map the caller's command block.
            pCommandBlockOrig = SafeTransportCommand.CommandBlock;
            if (FAILED(CeOpenCallerBuffer(
                        &SafeTransportCommand.CommandBlock,
                        pCommandBlockOrig,
                        SafeTransportCommand.Length,
                        ARG_I_PTR,
                        FALSE))) {                        
                dwErr = ERROR_INVALID_PARAMETER;
                break;
            }
            
            if (NULL == SafeTransportCommand.CommandBlock) {
                dwErr = ERROR_INVALID_PARAMETER;
                break;
            }
            // Sterilize the caller's data wrapper.
            if (0 == CeSafeCopyMemory((LPVOID)&SafeTransportData, (LPVOID)pOutBuf, sizeof(TRANSPORT_DATA))) {
                dwErr = ERROR_INVALID_PARAMETER;
                goto CleanUp_Passthrough;
            }
            // The data block may be NULL.  Map the caller's data block as
            // appropriate.
            if (NULL != SafeTransportData.DataBlock) {
                pDataBlockOrig = SafeTransportData.DataBlock;
                if (FAILED(CeOpenCallerBuffer(
                            &SafeTransportData.DataBlock,
                            pDataBlockOrig,
                            SafeTransportData.RequestLength,
                            ARG_IO_PTR,
                            FALSE))) {
                    dwErr = ERROR_INVALID_PARAMETER;
                    goto CleanUp_Passthrough;
                }
            }
            
            // Issue command.
            dwErr = ScsiPassthrough(pDevice, &SafeTransportCommand, &SafeTransportData);

            CleanUp_Passthrough:
            // Cleanup mapped ptrs.
            if (FAILED(CeCloseCallerBuffer(
                        SafeTransportCommand.CommandBlock,
                        pCommandBlockOrig,
                        SafeTransportCommand.Length,
                        ARG_I_PTR))) {
                ASSERT(!"Unexpected failure in CeCloseCallerBuffer");
                dwErr = ERROR_GEN_FAILURE;
                break;
            }

            if (pDataBlockOrig) {
                if (FAILED(CeCloseCallerBuffer(
                            SafeTransportData.DataBlock,
                            pDataBlockOrig,
                            SafeTransportData.RequestLength,
                            ARG_IO_PTR))) {
                    ASSERT(!"Unexpected failure in CeCloseCallerBuffer");
                    dwErr = ERROR_GEN_FAILURE;
                    break;
                }
            }

            if (ERROR_SUCCESS != dwErr) {
                break;
            }
            if (pdwBytesTransferred) {
                if (0 == CeSafeCopyMemory((LPVOID)pdwBytesTransferred, (LPVOID)&SafeTransportData.TransferLength, sizeof(DWORD)) ||
                    0 == CeSafeCopyMemory(pOutBuf, &SafeTransportData, OutBufLen)) {