sdmemmain.cpp

6410BSP3

          (PUCHAR)&pDevice->IdleTimeout,
          &dataLength) == ERROR_SUCCESS
       ) {
      // key is present
      DEBUGMSG(SDCARD_ZONE_INIT, (TEXT("SDMemory: Initialize: Using idle timeout of %u milliseconds\r\n"),
            pDevice->IdleTimeout));
    }

    // read "IdlePowerState"
    // default power state for idle
    // if the power state is greater than D2, we do idle checking
    pDevice->PowerStateForIdle = D2;
    dataLength = sizeof(DWORD);
    data = 0;
    if (RegQueryValueEx(
          hSubKey,
          IDLE_POWER_STATE,
          NULL,
          NULL,
          (PUCHAR)&data,
          &dataLength) == ERROR_SUCCESS
       ) {
      if (data <= (ULONG)D4) {
        pDevice->PowerStateForIdle = (CEDEVICE_POWER_STATE)data;
      }
    }

    DEBUGMSG(SDCARD_ZONE_INIT, (TEXT("SDMemory: Idle Timeout: %d Idle Power State: %d\r\n"),
          pDevice->IdleTimeout,
          pDevice->PowerStateForIdle));

    RegCloseKey(hSubKey);
  }

  // allocate our buffer list; we need 2 buffers: 1 for read and 1 for write data
  BufferSize = (ULONG)(pDevice->BlockTransferSize * SD_BLOCK_SIZE);

  // create the data buffer memory list
  pDevice->hBufferList = SDCreateMemoryList(SD_MEMORY_TAG, 2, BufferSize);
  if (pDevice->hBufferList == NULL) {
    DEBUGMSG(SDCARD_ZONE_ERROR, (TEXT("SDMemory: Initialize: Failed to allocate buffer list\r\n")));
    CleanUpDevice(pDevice);
    return 0;
  }

  pDevice->fPreDeinitCalled = FALSE;

  InitializePowerManagement(pDevice);

  DEBUGMSG(SDCARD_ZONE_INIT, (TEXT("SDMemory: -SMC_Init\r\n")));

  return (DWORD)pDevice;
}

///////////////////////////////////////////////////////////////////////////////
//  SMC_IOControl - the I/O control entry point for the memory driver
//  Input:  Handle - the context returned from SMC_Open
//          IoctlCode - the ioctl code
//          pInBuf - the input buffer from the user
//          InBufSize - the length of the input buffer
//          pOutBuf - the output buffer from the user
//          InBufSize - the length of the output buffer
//          pBytesReturned - the size of the transfer
//  Output:
//  Return:  TRUE if ioctl was handled
//  Notes:
///////////////////////////////////////////////////////////////////////////////
extern "C" BOOL WINAPI SMC_IOControl(
    DWORD   Handle,
    DWORD   IoctlCode,
    PBYTE   pInBuf,
    DWORD   InBufSize,
    PBYTE   pOutBuf,
    DWORD   OutBufSize,
    PDWORD  pBytesReturned
    )
{
    DWORD            Status = ERROR_SUCCESS;             // win32 status
    PSD_MEMCARD_INFO pHandle = (PSD_MEMCARD_INFO)Handle; // memcard info
    PSG_REQ          pSG;                                // scatter gather buffer
    SD_API_STATUS    sdStatus;                           // SD API status
    DWORD            SafeBytesReturned = 0;              // safe copy of pBytesReturned
    DWORD             dwStartTicks = 0;

    DEBUGMSG(SDCARD_ZONE_FUNC, (TEXT("SDMemory: +SMC_IOControl\r\n")));

    // any of these IOCTLs can access the device instance or card handle so we
    // must protect it from being freed from XXX_Deinit; Windows CE does not
    // synchronize the  callback from Deinit
    AcquireRemovalLock(pHandle);

    if (pHandle->fPreDeinitCalled) {
        Status = ERROR_INVALID_HANDLE;
        goto ErrorStatusReturn;
    }

    sdStatus = RequestPrologue(pHandle, IoctlCode);

    if (!SD_API_SUCCESS(sdStatus)) {
        ReleaseRemovalLock(pHandle);
        SetLastError(SDAPIStatusToErrorCode(sdStatus));
        return FALSE;
    }

    DEBUGMSG(SDCARD_ZONE_INFO, (TEXT("SMC_IOControl: Recevied IOCTL %d ="), IoctlCode));
    switch(IoctlCode) {
        case IOCTL_DISK_READ:
            DEBUGMSG(SDCARD_ZONE_INFO, (TEXT("IOCTL_DISK_READ\r\n")));
            break;
        case DISK_IOCTL_READ:
            DEBUGMSG(SDCARD_ZONE_INFO, (TEXT("DISK_IOCTL_READ\r\n")));
            break;
        case IOCTL_DISK_WRITE:
            DEBUGMSG(SDCARD_ZONE_INFO, (TEXT("IOCTL_DISK_WRITE\r\n")));
            break;
        case DISK_IOCTL_WRITE:
            DEBUGMSG(SDCARD_ZONE_INFO, (TEXT("DISK_IOCTL_WRITE\r\n")));
            break;
        case IOCTL_DISK_GETINFO:
            DEBUGMSG(SDCARD_ZONE_INFO, (TEXT("IOCTL_DISK_GETINFO\r\n")));
            break;
        case DISK_IOCTL_GETINFO:
            DEBUGMSG(SDCARD_ZONE_INFO, (TEXT("DISK_IOCTL_GETINFO\r\n")));
            break;
        case IOCTL_DISK_SETINFO:
            DEBUGMSG(SDCARD_ZONE_INFO, (TEXT("IOCTL_DISK_SETINFO\r\n")));
            break;
        case DISK_IOCTL_INITIALIZED:
            DEBUGMSG(SDCARD_ZONE_INFO, (TEXT("DISK_IOCTL_INITIALIZED\r\n")));
            break;
        case IOCTL_DISK_INITIALIZED:
            DEBUGMSG(SDCARD_ZONE_INFO, (TEXT("IOCTL_DISK_INITIALIZED\r\n")));
            break;
        case IOCTL_DISK_GETNAME:
            DEBUGMSG(SDCARD_ZONE_INFO, (TEXT("IOCTL_DISK_GETNAME\r\n")));
            break;
        case DISK_IOCTL_GETNAME:
            DEBUGMSG(SDCARD_ZONE_INFO, (TEXT("DISK_IOCTL_GETNAME\r\n")));
            break;
        case IOCTL_DISK_GET_STORAGEID:
            DEBUGMSG(SDCARD_ZONE_INFO, (TEXT("IOCTL_DISK_GET_STORAGEID\r\n")));
            break;
        case IOCTL_DISK_FORMAT_MEDIA:
        case DISK_IOCTL_FORMAT_MEDIA:
            DEBUGMSG(SDCARD_ZONE_INFO, (TEXT("IOCTL_DISK_FORMAT_MEDIA\r\n")));
            break;
        case IOCTL_DISK_DEVICE_INFO:
            DEBUGMSG(SDCARD_ZONE_INFO, (TEXT("IOCTL_DISK_DEVICE_INFO\r\n")));
            break;
        case IOCTL_DISK_DELETE_SECTORS:
            DEBUGMSG(SDCARD_ZONE_INFO, (TEXT("IOCTL_DISK_DELETE_SECTORS\r\n")));
            break;
        default:
            DEBUGMSG(SDCARD_ZONE_INFO, (TEXT("**UNKNOWN**\r\n")));
            break;
    }

    // validate parameters
    switch(IoctlCode) {

        case IOCTL_DISK_READ:
        case DISK_IOCTL_READ:
        case IOCTL_DISK_WRITE:
        case DISK_IOCTL_WRITE:
            if (pInBuf == NULL || InBufSize < sizeof(SG_REQ) || InBufSize > (sizeof(SG_REQ) + ((MAX_SG_BUF - 1) * sizeof(SG_BUF)))) {
                Status = ERROR_INVALID_PARAMETER;
            }
            break;

        case DISK_IOCTL_GETINFO:
        case IOCTL_DISK_SETINFO:
            if (NULL == pInBuf || InBufSize != sizeof(DISK_INFO)) {
                Status = ERROR_INVALID_PARAMETER;
            }
            break;

        case IOCTL_DISK_DELETE_SECTORS:
            if (pInBuf == NULL || InBufSize != sizeof(DELETE_SECTOR_INFO)) {
                Status = ERROR_INVALID_PARAMETER;
            }
            break;

        case IOCTL_DISK_GETINFO:
            if (pOutBuf == NULL || OutBufSize != sizeof(DISK_INFO)) {
                Status = ERROR_INVALID_PARAMETER;
            }
            break;

        case IOCTL_DISK_GET_STORAGEID:
            // the identification data is stored after the struct, so the out
            // buffer must be at least the size of the struct.
            if (pOutBuf == NULL || OutBufSize < sizeof(STORAGE_IDENTIFICATION)) {
                Status = ERROR_INVALID_PARAMETER;
            }
            break;

        case IOCTL_DISK_FORMAT_MEDIA:
        case DISK_IOCTL_FORMAT_MEDIA:
            break;

        case IOCTL_DISK_DEVICE_INFO:
            if (NULL == pInBuf || (InBufSize != sizeof(STORAGEDEVICEINFO))) {
                Status = ERROR_INVALID_PARAMETER;
            }
            break;

        case IOCTL_POWER_CAPABILITIES:
            if (!pOutBuf || OutBufSize < sizeof(POWER_CAPABILITIES) || !pBytesReturned) {
                Status = ERROR_INVALID_PARAMETER;
            }
            break;

        case IOCTL_POWER_SET:
            if (!pOutBuf || OutBufSize < sizeof(CEDEVICE_POWER_STATE) || !pBytesReturned) {
                Status = ERROR_INVALID_PARAMETER;
            }
            break;

        default:
            Status = ERROR_INVALID_PARAMETER;
    }

    if (Status != ERROR_SUCCESS) {
        goto ErrorStatusReturn;
    }

    // execute the IOCTL
    switch(IoctlCode) {

        case IOCTL_DISK_READ:
        case DISK_IOCTL_READ:
            pSG = (PSG_REQ)pInBuf;
            if (0 == CeSafeCopyMemory((LPVOID)pHandle->pSterileIoRequest, (LPVOID)pSG, InBufSize)) {
                Status = ERROR_INVALID_PARAMETER;
                break;
            }
            Status = SDMemRead(pHandle, pHandle->pSterileIoRequest);
            __try {
                pSG->sr_status = Status;
                if (pBytesReturned && (ERROR_SUCCESS == Status)) {
                    *pBytesReturned = (pHandle->pSterileIoRequest->sr_num_sec * SD_BLOCK_SIZE);
                }
            }
            __except(EXCEPTION_EXECUTE_HANDLER) {
                Status = ERROR_INVALID_PARAMETER;
            }
            break;

        case IOCTL_DISK_WRITE:
        case DISK_IOCTL_WRITE:
            pSG = (PSG_REQ)pInBuf;
            if (0 == CeSafeCopyMemory((LPVOID)pHandle->pSterileIoRequest, (LPVOID)pSG, InBufSize)) {
                Status = ERROR_INVALID_PARAMETER;
                break;
            }
            Status = SDMemWrite(pHandle, pHandle->pSterileIoRequest);
            __try {
                pSG->sr_status = Status;
                if (pBytesReturned && (ERROR_SUCCESS == Status)) {
                    *pBytesReturned = (pHandle->pSterileIoRequest->sr_num_sec * SD_BLOCK_SIZE);
                }
            }
            __except(EXCEPTION_EXECUTE_HANDLER) {
                Status = ERROR_INVALID_PARAMETER;
            }
            break;

        case IOCTL_DISK_GETINFO:
        {
            DISK_INFO SafeDiskInfo = {0};
            SafeBytesReturned = sizeof(DISK_INFO);
            Status = GetDiskInfo(pHandle, &SafeDiskInfo);
            if (0 == CeSafeCopyMemory((LPVOID)pOutBuf, (LPVOID)&SafeDiskInfo, sizeof(DISK_INFO))) {
                Status = ERROR_INVALID_PARAMETER;
                break;
            }
            if (pBytesReturned) {
                if (0 == CeSafeCopyMemory((LPVOID)pBytesReturned, (LPVOID)&SafeBytesReturned, sizeof(DWORD))) {
                    Status = ERROR_INVALID_PARAMETER;
                    break;
                }
            }
        }
            break;

        case DISK_IOCTL_GETINFO:
        {
            DISK_INFO SafeDiskInfo = {0};
            SafeBytesReturned = sizeof(DISK_INFO);
            Status = GetDiskInfo(pHandle, &SafeDiskInfo);
            if (0 == CeSafeCopyMemory((LPVOID)pInBuf, (LPVOID)&SafeDiskInfo, sizeof(DISK_INFO))) {
                Status = ERROR_INVALID_PARAMETER;
                break;
            }
            if (pBytesReturned) {
                if (0 == CeSafeCopyMemory((LPVOID)pBytesReturned, (LPVOID)&SafeBytesReturned, sizeof(DWORD))) {
                    Status = ERROR_INVALID_PARAMETER;
                    break;
                }
            }
        }
            break;

        case IOCTL_DISK_SETINFO:
        {
            DISK_INFO SafeDiskInfo = {0};
            if (0 == CeSafeCopyMemory((LPVOID)&SafeDiskInfo, (LPVOID)pInBuf, sizeof(DISK_INFO))) {
                Status = ERROR_INVALID_PARAMETER;
                break;
            }
            Status = SetDiskInfo(pHandle, &SafeDiskInfo);
        }
            break;

        case IOCTL_DISK_FORMAT_MEDIA:
        case DISK_IOCTL_FORMAT_MEDIA:
            Status = ERROR_SUCCESS;
            break;

        case IOCTL_DISK_GET_STORAGEID:
        {
            __try {
                Status = GetStorageID(
                    pHandle,
                    (PSTORAGE_IDENTIFICATION)pOutBuf,
                    OutBufSize,
                    pBytesReturned);
            }
            __except(EXCEPTION_EXECUTE_HANDLER) {
                Status = ERROR_INVALID_PARAMETER;
            }
        }
            break;

        case IOCTL_DISK_DEVICE_INFO:
        {
            STORAGEDEVICEINFO SafeStorageDeviceInfo = {0};
            SafeBytesReturned = sizeof(STORAGEDEVICEINFO);
            if (!GetDeviceInfo(pHandle, &SafeStorageDeviceInfo)) {
                Status = ERROR_GEN_FAILURE;
                break;
            }
            if (0 == CeSafeCopyMemory((LPVOID)pInBuf, (LPVOID)&SafeStorageDeviceInfo, sizeof(STORAGEDEVICEINFO))) {
                Status = ERROR_INVALID_PARAMETER;
                break;
            }
            Status = ERROR_SUCCESS;
            if (pBytesReturned) {
                if (0 == CeSafeCopyMemory((LPVOID)pBytesReturned, (LPVOID)&SafeBytesReturned, sizeof(DWORD))) {
                    Status = ERROR_INVALID_PARAMETER;
                }
            }
        }
            break;