diskmain.cpp

EP931X系列的WinCE显卡驱动源代码

                if (m_Id.UltraDMASupport & (1 << 2)) {
                    dwCycleTime = UDMA_MODE2_CYCLE_TIME;
                    dwXferMode |= UDMA_MODE2;
                    dwBestXferMode = 2;
                }
                if (m_Id.UltraDMASupport & (1 << 3)) {
                    dwCycleTime = UDMA_MODE3_CYCLE_TIME;
                    dwXferMode |= UDMA_MODE3;
                    dwBestXferMode = 3;
                }
                if (m_Id.UltraDMASupport & (1 << 4)) {
                    dwCycleTime = UDMA_MODE4_CYCLE_TIME;
                    dwXferMode |= UDMA_MODE4;
                    dwBestXferMode = 4;
                }
            }

            if (m_Id.UltraDMAActive) {
                if (m_Id.UltraDMAActive & IDD_UDMA_MODE4_ACTIVE) {
                    dwCurrentMode = UDMA_MODE4;
                } else if (m_Id.UltraDMAActive & IDD_UDMA_MODE3_ACTIVE) {
                    dwCurrentMode = UDMA_MODE3;
                } else if (m_Id.UltraDMAActive & IDD_UDMA_MODE2_ACTIVE) {
                    dwCurrentMode = UDMA_MODE2;
                } else if (m_Id.UltraDMAActive & IDD_UDMA_MODE1_ACTIVE) {
                    dwCurrentMode = UDMA_MODE1;
                }  else if (m_Id.UltraDMAActive & IDD_UDMA_MODE0_ACTIVE) {
                    dwCurrentMode = UDMA_MODE0;
                }
            }
        }

        //
        // Doesn't really know the ultra dma cycle time
        //
        m_dwBestUDmaCycleTime = dwCycleTime;
        m_dwBestUDmaMode      = dwBestXferMode;

        m_dwTransferModeSupported = dwXferMode;
        m_dwTransferModeCurrent  |= dwCurrentMode;


        DEBUGMSG( ZONE_INIT, (TEXT("ATAPI:AnalyzeDeviceCapabilities target %d transfer timing:\r\n"),m_dwDevice));

        DEBUGMSG( ZONE_INIT, (TEXT("ATAPI:AnalyzeDeviceCapabilities PIO mode supported   = %4x and best cycle time = %5d ns\r\n"),
                        m_dwTransferModeSupported & PIO_SUPPORT,
                        m_dwBestPioCycleTime));
        DEBUGMSG( ZONE_INIT, (TEXT("ATAPI:AnalyzeDeviceCapabilities SWDMA mode supported = %4x and best cycle time = %5d ns\r\n"),
                        m_dwTransferModeSupported & SWDMA_SUPPORT,
                        m_dwBestSwDmaCycleTime));
        DEBUGMSG( ZONE_INIT, (TEXT("ATAPI:AnalyzeDeviceCapabilities MWDMA mode supported = %4x and best cycle time = %5d ns\r\n"),
                        m_dwTransferModeSupported & MWDMA_SUPPORT,
                        m_dwBestSwDmaCycleTime));
        DEBUGMSG( ZONE_INIT, (TEXT("ATAPI:AnalyzeDeviceCapabilities UDMA mode supported  = %4x and best cycle time = %5d ns\r\n"),
                        m_dwTransferModeSupported & UDMA_SUPPORT,
                        m_dwBestUDmaCycleTime));
        //DEBUGMSG( ZONE_INIT, (TEXT("ATAPI:AnalyzeDeviceCapabilities Current mode bitmap  = %4x\r\n"),
        //                m_dwTransferModeCurrent));
            
    }
} // AnalyzeDeviceCapabilities
// Validate the buffer pointer.
BOOL CDisk::ValidateSg(PSG_REQ pSgReq ,DWORD InBufLen)
{
    if (PSLGetCallerTrust()!= OEM_CERTIFY_TRUST) {
        if  (pSgReq && InBufLen >= (sizeof(SG_REQ) + sizeof(SG_BUF) * (pSgReq->sr_num_sg - 1))) {
            DWORD dwIndex;
            for (dwIndex=0; dwIndex < pSgReq -> sr_num_sg; dwIndex++) {
                pSgReq->sr_sglist[dwIndex].sb_buf = 
                    (PUCHAR)MapCallerPtr((LPVOID)pSgReq->sr_sglist[dwIndex].sb_buf,pSgReq->sr_sglist[dwIndex].sb_len);
            }
        }
        else // Parameter Wrong.
            return FALSE;
    }
    return TRUE;
}
BOOL CDisk::ValidateSg(PCDROM_READ pCdrom ,DWORD InBufLen)
{
    if (PSLGetCallerTrust()!= OEM_CERTIFY_TRUST) {
        if  (pCdrom && InBufLen >= (sizeof(CDROM_READ) + sizeof(SGX_BUF) * (pCdrom->sgcount - 1))) {
            DWORD dwIndex;
            for (dwIndex=0; dwIndex < pCdrom-> sgcount; dwIndex++) {
                pCdrom->sglist[dwIndex].sb_buf = 
                    (PUCHAR)MapCallerPtr((LPVOID)pCdrom->sglist[dwIndex].sb_buf,pCdrom->sglist[dwIndex].sb_len);
            }
        }
        else // Parameter Wrong.
            return FALSE;
    }
    return TRUE;
}
/*------------------------------------------------------------------------------------------*/
BOOL CDisk::PerformIoctl(PIOREQ pIOReq)
{
    DWORD dwError = ERROR_SUCCESS;
    DEBUGMSG( ZONE_IOCTL, (TEXT("ATAPI:PerformIoctl: %x DeviceId: %x \r\n"),pIOReq->dwCode, m_dwDeviceId));

    if (m_dwDeviceFlags & DFLAGS_DEVICE_PWRDN) {
        SetLastError(ERROR_DEVICE_NOT_AVAILABLE);
        return FALSE;
    }   

    if (pIOReq->pBytesReturned)
            *(pIOReq->pBytesReturned)=0;

     TakeCS();
    __try {
        switch( pIOReq->dwCode) {
            case IOCTL_DISK_GETINFO:
            case DISK_IOCTL_GETINFO:
                if (IsCDRomDevice())
                {
                    dwError = ERROR_BAD_COMMAND;
                } else {
                    dwError = GetDiskInfo(pIOReq);
                }   
                break;
            case IOCTL_DISK_DEVICE_INFO:
                dwError = GetDeviceInfo(pIOReq);
                break;
            case DISK_IOCTL_GETNAME  :
            case IOCTL_DISK_GETNAME  :
                dwError=GetDiskName(pIOReq);
                break;
            case DISK_IOCTL_SETINFO :
            case IOCTL_DISK_SETINFO :
                dwError = SetDiskInfo(pIOReq);
                break;
            case DISK_IOCTL_READ    :
            case IOCTL_DISK_READ    :
                if (!ValidateSg((PSG_REQ)pIOReq->pInBuf,pIOReq->dwInBufSize))
                    dwError=ERROR_INVALID_PARAMETER;
                else
                if (IsDMASupported()) {
                    dwError = ReadWriteDiskDMA(pIOReq, TRUE);
                } else {
                    dwError = ReadWriteDisk(pIOReq, TRUE);                      
                }    
                break;
            case DISK_IOCTL_WRITE:
            case IOCTL_DISK_WRITE:
                if (!ValidateSg((PSG_REQ)pIOReq->pInBuf,pIOReq->dwInBufSize))
                    dwError=ERROR_INVALID_PARAMETER;
                else
                 if (IsDMASupported()) {
                    dwError = ReadWriteDiskDMA(pIOReq, FALSE);
                } else {
                    dwError = ReadWriteDisk(pIOReq, FALSE);                     
                }    
                break;
            case IOCTL_DISK_GET_STORAGEID:  // this is a new op, so use new codes //
                dwError = GetStorageId(pIOReq);
                break;

            case DISK_IOCTL_FORMAT_MEDIA:
            case IOCTL_DISK_FORMAT_MEDIA:
                dwError = ERROR_SUCCESS;
                break;;
///////////////////// ATAPI  /////////////////////////////////////                
            case IOCTL_CDROM_READ_SG:
            case IOCTL_CDROM_TEST_UNIT_READY:
            case IOCTL_CDROM_DISC_INFO:
            case IOCTL_CDROM_EJECT_MEDIA:
            case IOCTL_CDROM_LOAD_MEDIA:    
///////////////////// DVD ///////////////////////////////////////                
            case IOCTL_DVD_START_SESSION:
            case IOCTL_DVD_READ_KEY:
            case IOCTL_DVD_END_SESSION:
            case IOCTL_DVD_SEND_KEY:
            case IOCTL_DVD_GET_REGION:
///////////////////// CDAUDIO ///////////////////////////////////                
             case IOCTL_CDROM_READ_TOC:
             case IOCTL_CDROM_GET_CONTROL:
             case IOCTL_CDROM_PLAY_AUDIO_MSF:
             case IOCTL_CDROM_SEEK_AUDIO_MSF:
             case IOCTL_CDROM_STOP_AUDIO:
             case IOCTL_CDROM_PAUSE_AUDIO:
             case IOCTL_CDROM_RESUME_AUDIO:
             case IOCTL_CDROM_GET_VOLUME:
             case IOCTL_CDROM_SET_VOLUME:
             case IOCTL_CDROM_READ_Q_CHANNEL:
             case IOCTL_CDROM_GET_LAST_SESSION:
             case IOCTL_CDROM_RAW_READ:
             case IOCTL_CDROM_DISK_TYPE:
             case IOCTL_CDROM_SCAN_AUDIO:
             case IOCTL_CDROM_ISSUE_INQUIRY:
                 if (IsAtapiDevice())
                    dwError = AtapiIoctl(pIOReq);
                else 
                    dwError = ERROR_INVALID_OPERATION;
                break;
            default:
                dwError = ERROR_NOT_SUPPORTED;
                break;
        }
    } __except(EXCEPTION_EXECUTE_HANDLER) {
        dwError = ERROR_GEN_FAILURE;
    }
    ReleaseCS();
    if (dwError != ERROR_SUCCESS) 
        SetLastError( dwError);
    return ERROR_SUCCESS == dwError;
}
/*------------------------------------------------------------------------------------------*/
BOOL CDisk::PostInit(PPOST_INIT_BUF pPostInitBuf)
{
    DWORD dwError=ERROR_SUCCESS;

    DEBUGMSG( ZONEID_INIT, (TEXT("ATAPI: PostInit ( Device :0x%x) \r\n"),m_dwDeviceId));
    m_hDevice = pPostInitBuf->p_hDevice;
    return dwError == ERROR_SUCCESS;
}    

/*------------------------------------------------------------------------------------------*/
DWORD CDisk::GetDiskInfo(PIOREQ pIOReq)
{
    DWORD dwError = ERROR_SUCCESS;
    DISK_INFO *pInfo = NULL;

// The Call can come in three flavors (BC).  Just inbuf is specified, outbuf is specified or both.  If both then outbuf is used
    if (pIOReq->pInBuf) {
        if (pIOReq->dwInBufSize != sizeof(DISK_INFO)) 
            return ERROR_INVALID_PARAMETER;
        pInfo = (DISK_INFO *)pIOReq->pInBuf;
    }

    if (pIOReq->pOutBuf) {
        if (pIOReq->dwOutBufSize!= sizeof(DISK_INFO)) 
            return ERROR_INVALID_PARAMETER;
        pInfo = (DISK_INFO *)pIOReq->pOutBuf;
    }
    
    if (!pInfo) {
        DEBUGMSG( ZONE_ERROR | ZONE_IOCTL, (TEXT("ATAPI:GetDiskInfo No valid input buffer or output buffer !!!\r\n")));
        return ERROR_INVALID_PARAMETER;
    }    
    if (IsRemoveableDevice()) {
     }
    if (IsAtapiDevice()) {
        // TODO:
//        AtapiGetDiskInfo();
    }    
    if (ERROR_SUCCESS == dwError) {    
        __try {
            memcpy( pInfo, &m_DiskInfo, sizeof(DISK_INFO));
            pInfo->di_flags |= DISK_INFO_FLAG_PAGEABLE;
            pInfo->di_flags &= ~DISK_INFO_FLAG_UNFORMATTED;
            if (pIOReq->pBytesReturned)
                *(pIOReq->pBytesReturned) = sizeof(DISK_INFO);
        } __except(EXCEPTION_EXECUTE_HANDLER) {
            dwError = ERROR_INVALID_PARAMETER;
        }    
    }    
    return dwError;
}
/*------------------------------------------------------------------------------------------*/

DWORD CDisk::SetDiskInfo(PIOREQ pIOReq)
{
   DWORD dwError = ERROR_SUCCESS;
   DISK_INFO *pInfo = (DISK_INFO *)pIOReq->pInBuf;
    if  ((pIOReq->pInBuf == NULL) ||
        (pIOReq->dwInBufSize != sizeof(DISK_INFO))) {
        return ERROR_INVALID_PARAMETER; 
    }
    memcpy( &m_DiskInfo, pInfo, sizeof(DISK_INFO));
    return dwError;
}

/*------------------------------------------------------------------------------------------*/
DWORD CDisk::GetDeviceInfo(PIOREQ pIOReq)
{
    PSTORAGEDEVICEINFO psdi = (PSTORAGEDEVICEINFO)pIOReq->pInBuf;
    HKEY hKey;
    if ((pIOReq->dwInBufSize== 0) ||
         (pIOReq->pInBuf== NULL))
    {
        return ERROR_INVALID_PARAMETER; 
    }
    
    if (pIOReq->pBytesReturned)
        *(pIOReq->pBytesReturned) = sizeof(STORAGEDEVICEINFO);

    psdi->dwDeviceClass = 0;
    psdi->dwDeviceType = 0;
    psdi->dwDeviceFlags = 0;
    wcscpy( psdi->szProfile, L"Default");
    if (ERROR_SUCCESS != RegOpenKeyEx( HKEY_LOCAL_MACHINE, m_szDeviceKey, 0, 0, &hKey)) {
        hKey = NULL;
    }   
    if (IsAtapiDevice() && IsCDRomDevice()) {
        psdi->dwDeviceClass = STORAGE_DEVICE_CLASS_MULTIMEDIA;
        psdi->dwDeviceType |= STORAGE_DEVICE_TYPE_REMOVABLE_MEDIA;
        psdi->dwDeviceType |= STORAGE_DEVICE_TYPE_ATAPI;
        psdi->dwDeviceType |= STORAGE_DEVICE_TYPE_PCIIDE;
        psdi->dwDeviceFlags |= STORAGE_DEVICE_FLAG_MEDIASENSE;
        psdi->dwDeviceFlags |= STORAGE_DEVICE_FLAG_READONLY;
        if (!hKey || !AtaGetRegistryString( hKey, REG_VALUE_CDPROFILE, (PTSTR *)&psdi->szProfile, sizeof(psdi->szProfile))) {
            wcscpy( psdi->szProfile, REG_VALUE_CDPROFILE);
        }
    } else {
        psdi->dwDeviceClass = STORAGE_DEVICE_CLASS_BLOCK;
        psdi->dwDeviceType |= STORAGE_DEVICE_TYPE_PCIIDE;
        psdi->dwDeviceType |= STORAGE_DEVICE_TYPE_ATA;
        psdi->dwDeviceFlags |= STORAGE_DEVICE_FLAG_READWRITE;
        if (!hKey || !AtaGetRegistryString( hKey, REG_VALUE_HDPROFILE, (PTSTR *)&psdi->szProfile, sizeof(psdi->szProfile))) {
            wcscpy( psdi->szProfile, REG_VALUE_HDPROFILE);
        }
    }
    return ERROR_SUCCESS;
}
/*------------------------------------------------------------------------------------------*/


 DWORD  CDisk::GetDiskName(PIOREQ pIOReq)
{
    static PTCHAR szDefaultDiscDrive = TEXT("External Volume");
    PTCHAR szDiskName = NULL;
    DWORD dwSize;
    DEBUGMSG( ZONE_IOCTL, (TEXT("ATAPI:GeDisktName\r\n")));
    if  ((pIOReq->pBytesReturned == NULL) ||
         (pIOReq->dwOutBufSize == 0) ||
         (pIOReq->pOutBuf == NULL) )