diskmain.h

EP9315开发板的Wince6.0的BSP包文件

        if (m_hDevKey) 
            RegCloseKey( m_hDevKey);
        DeleteCriticalSection( &m_csDisk);            
    }
    virtual BOOL Init(HKEY hActiveKey);
    // Set m_fUseLBA48 if appropriate
    void ConfigLBA48(void);

    void SetActiveKey(TCHAR *szActiveKey)
    {
        wcscpy( m_szActiveKey, szActiveKey);
    }
    void SetDeviceKey(TCHAR *szDeviceKey)
    {
        wcscpy( m_szDeviceKey, szDeviceKey);
    }
    BOOL PostInit(PPOST_INIT_BUF pPostInitBuf);
    BOOL PerformIoctl(PIOREQ pIOReq);
    BOOL ResetController(BOOL bSoftReset=FALSE);
    BOOL Identify();
    BYTE WaitOnBusy(BOOL fBase);
    void AnalyzeDeviceCapabilities ();
    BOOL SetTransferMode(BYTE bMode);
    virtual void SetBestTransferMode() = 0;
    virtual DWORD ForceTransferMode(BOOL fUDMAActive, ULONG ulDmaMode) = 0;

public: // Actual DISK functions
    DWORD GetDiskInfo(PIOREQ pIOReq);       
    DWORD SetDiskInfo(PIOREQ pIOReq);       
    virtual DWORD GetDeviceInfo(PIOREQ pIOReq);
    DWORD GetDiskName( PIOREQ pIOReq);
    DWORD ReadWriteDisk( PIOREQ pIOReq, BOOL fRead = TRUE);
    DWORD ReadWriteDiskDMA(PIOREQ pIOReq, BOOL fRead = TRUE);
    DWORD GetStorageId(PIOREQ pIOReq);
    void  PowerUp() { m_dwDeviceFlags &= ~DFLAGS_DEVICE_PWRDN;}
    void  PowerDown() { m_dwDeviceFlags |= DFLAGS_DEVICE_PWRDN;}
public: // ATAPI

    DWORD ScsiPassThrough( const SCSI_PASS_THROUGH &PassThrough,
                                      SGX_BUF* pSgxBuf,
                                      PSENSE_DATA pSenseData,
                                      DWORD* pdwBytesReturned,
                                      BOOL fAllowNoData );

    DWORD AtapiIoctl(PIOREQ pIOReq);
    DWORD ReadCdRom(CDROM_READ *pReadInfo, PDWORD pBytesReturned);
    DWORD SetupCdRomRead(BOOL bRawMode, DWORD dwLBAAddr, DWORD dwTransferLength, PATAPI_COMMAND_PACKET pCmdPkt);

    DWORD CDisk::ReadCdRomDMA
    (
        BOOL    bRawMode,
        DWORD   dwLBAAddr, 
        DWORD   dwTransferLength, 
        DWORD   dwSgCount, 
        SGX_BUF *pSgBuf,
        DWORD   *pBytesRead
    );

    DWORD CDisk::ReadCdRomPIO
    (
        BOOL    bRawMode,
        DWORD   dwLBAAddr, 
        DWORD   dwTransferLength, 
        DWORD   dwSgCount, 
        SGX_BUF *pSgBuf,
        DWORD   *pBytesRead
    );

    BOOL  AtapiSendCommand(PATAPI_COMMAND_PACKET pCmdPkt, WORD wCount = 0, BOOL fDMA = FALSE);
    BOOL  AtapiReceiveData(PSGX_BUF pSgBuf, DWORD dwSgCount,LPDWORD pdwBytesRead);
    BOOL  AtapiSendData(PSGX_BUF pSgBuf, DWORD dwSgCount,LPDWORD pdwBytesWritten);
    BOOL  AtapiIsUnitReady(PIOREQ pIOReq = NULL);
    BOOL  AtapiIsUnitReadyEx();
    BOOL  AtapiGetSenseInfo(SENSE_DATA *pSenseData);
    BOOL  AtapiIssueInquiry(INQUIRY_DATA *pInqData);
    BOOL  AtapiGetToc(CDROM_TOC *pTOC);
    DWORD AtapiGetDiscInfo(PIOREQ pIOReq);
    DWORD AtapiReadQChannel(PIOREQ pIOReq);
    DWORD AtapiLoadMedia(BOOL bEject=FALSE);
    DWORD AtapiStartDisc();
    BOOL  AtapiDetectDVD();
    void  AtapiDumpSenseData();
public: // CDAUDIO Functions
    DWORD ControlAudio(PIOREQ pIOReq);

public: //DVD Functions
    DWORD DVDReadKey(PIOREQ pIOReq);
    DWORD DVDGetRegion(PIOREQ pIOReq);
    DWORD DVDSendKey(PIOREQ pIOReq);
    DWORD DVDSetRegion(PIOREQ pIOReq);
    BOOL  DVDGetCopySystem(LPBYTE pbCopySystem);



    
public: // IO Functions    
    BOOL SendIOCommand(DWORD dwStartSector, DWORD dwNumberOfSectors, BYTE bCmd);
    virtual BOOL WaitForInterrupt(DWORD dwTimeOut) = 0; 
    virtual ULONG WaitForDmaInterrupt(DWORD dwTimeOut) = 0; 
    WORD CheckIntrState();
    virtual void EnableInterrupt() = 0;
    void  ReadBuffer(PBYTE pBuffer,DWORD dwCount);
    void  WriteBuffer(PBYTE pBuffer,DWORD dwCount);
    BOOL WaitForDRQ();
    BOOL WaitForDisc(BYTE bStatusType, DWORD dwTimeOut, DWORD dwPeriod = 0); 
 public:
    virtual BOOL SetupDMA( PSG_BUF pSgBuf, DWORD dwSgCount, BOOL fRead) = 0;
    virtual BOOL BeginDMA(BOOL fRead) = 0;
    //virtual BOOL ContinueDMA() = 0;
    virtual BOOL EndDMA() = 0;
    virtual BOOL AbortDMA() = 0;
    virtual BOOL CompleteDMA(PSG_BUF pSgBuf, DWORD dwSgCount, BOOL fRead) = 0;

public: // Generic functions
    inline void StallExecution(DWORD dwUS) 
    {
        if ((dwUS >= 1000) && (m_dwDeviceFlags & DFLAGS_DEVICE_CDROM)) 
            Sleep (dwUS / 100);
        else 
            ::StallExecution(dwUS);         
    }    
    virtual void TakeCS() 
    { 
        EnterCriticalSection( &m_csDisk); 
    }
    virtual void ReleaseCS() 
    { 
        LeaveCriticalSection( &m_csDisk); 
    }
    inline void Open() { InterlockedIncrement( (LONG *)&m_dwOpenCount); }
    void Close() { InterlockedDecrement( (LONG *)&m_dwOpenCount); }
    
public: // inline IO Functions
    // This status function does does NOT ack the interrupt
    virtual BYTE GetAltStatus()                                    = 0;
    // This status function ack's the interrupt
    virtual BYTE GetBaseStatus()                                   = 0;
    virtual BYTE GetError()                                        = 0;
    virtual BYTE GetReason()                                       = 0;
    virtual void SelectDevice()                                    = 0;
    virtual void WriteDriveController(BYTE bData)                  = 0;
    virtual void WriteAltDriveController(BYTE bData)               = 0;
    virtual void SetDriveHead(BYTE bDriveHead)                     = 0;  
    virtual void WriteCommand(BYTE bCommand)                       = 0;
    virtual void WriteFeature(BYTE bFeature)                       = 0;
    virtual void WriteSectorCount(BYTE bValue)                     = 0;
    virtual void WriteDriveHeadReg(BYTE bValue)                    = 0;
    virtual void WriteSectorNumber(BYTE bValue)                    = 0;
    virtual void WriteLowCount(BYTE bValue)                        = 0;
    virtual void WriteHighCount(BYTE bValue)                       = 0;
    virtual BYTE GetLowCount()                                     = 0;
    virtual BYTE GetHighCount()                                    = 0;
    virtual void ReadWordBuffer( PWORD pBuffer, DWORD dwCount)     = 0;
    virtual void WriteWordBuffer( PWORD pBuffer, DWORD dwCount)    = 0;
    virtual void ReadByteBuffer( PBYTE pBuffer, DWORD dwCount)     = 0;
    virtual void WriteByteBuffer( PBYTE pBuffer, DWORD dwCount)    = 0;
    virtual void WriteWord(WORD wData)                             = 0;
    virtual WORD ReadWord()                                        = 0;
    virtual void WriteByte(BYTE bData)                             = 0;
    virtual WORD ReadByte()                                        = 0;
    virtual BOOL IsReadDMASupported()                              = 0;
    virtual BOOL IsWriteDMASupported()                             = 0;
    virtual BOOL WaitOnDMARQ(ULONG ulTime)                         = 0;
    virtual BOOL WaitOnDMARQForCD(ULONG ulTime)                    = 0;
    inline WORD GetCount() 
    {
        return GetLowCount() + ((WORD)GetHighCount() <<8);
    }    
    virtual DWORD GetUserDriveStatistics(UserDriveStatistics *pStats) = 0;

    DWORD GetDriveIdentifyData(IDENTIFY_DATA *pId);


    
public:    // Helper functions
    inline BOOL IsAtapiDevice() 
    {
//        return (m_Id.GeneralConfiguration & IDE_IDDATA_ATAPI_DEVICE);
        return m_fAtapiDevice;
    }    

        
    inline void AtapiSoftReset()
    {
        WriteCommand( ATAPI_CMD_SOFT_RESET);
        ::StallExecution(400);
        WaitForDisc(WAIT_TYPE_NOT_BUSY,4000, 100);
        WaitForDisc(WAIT_TYPE_READY,5000, 100);
    }

    inline BOOL IsCDRomDevice() 
    {
        return (((m_Id.GeneralConfiguration >> 8) & 0x1f) == ATA_IDDEVICE_CDROM);
    }    

    inline BOOL IsDVDROMDevice()
    {
         return TRUE;
    }

    inline BOOL IsDiskDevice() 
    {
        return (((m_Id.GeneralConfiguration >> 8) & 0x1f) == ATA_IDDEVICE_DISK);
    }    

    inline BOOL IsRemoveableDevice() 
    {
        return (m_Id.GeneralConfiguration & IDE_IDDATA_REMOVABLE);
    }    

    inline BOOL IsDRQTypeIRQ()
    {
        return ((m_Id.GeneralConfiguration >> 5) & 0x0003) == ATA_DRQTYPE_INTRQ;
    }    
    inline WORD GetPacketSize()
    {
        return m_Id.GeneralConfiguration & 0x0003 ? 16 : 12;
    }
private:
    BOOL ValidateSg(PCDROM_READ pCdrom , DWORD InBufLen);
    BOOL ValidateSg(PSG_REQ pSgReq, DWORD InBufLen, DWORD dwArgType, OUT PUCHAR * saveoldptrs);
    // Unmap pointers mapped by ValidateSg, Essentially an array version of CeCloseCallerBuffer
    HRESULT static UnmapSg(
        IN const SG_BUF * sr_sglist,
        IN const PUCHAR * saveoldptrs,
        IN DWORD sr_sglistlen,
        IN DWORD dwArgType) ;

    //
    // Debug routine.
    //
    DWORD TestDisk(void);

    
};



#endif // _DISKMAIN_H_