diskmain.h

这是运行在windows ce 4.2 版本下的关于硬盘加载的驱动程序

    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; 
    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 EndDMA() = 0;
    virtual BOOL AbortDMA() = 0;
    virtual BOOL CompleteDMA(PSG_BUF pSgBuf, DWORD dwSgCount, BOOL fRead) = 0;

public: // Generic functions
    inline void StallExecution(DWORD dwTime) 
    {
        if ((dwTime >= 100) && (m_dwDeviceFlags & DFLAGS_DEVICE_CDROM)) 
            Sleep (dwTime / 100);
        else 
            ::StallExecution(dwTime*10);         
    }    
    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    
	inline BYTE GetAltStatus() 
    {
        return (BYTE) ATA_READ_BYTE(m_pATARegAlt + ATA_REG_ALT_STATUS );
    }
    // This status function ack's the interrupt
    inline BYTE GetBaseStatus() 
    {
        return (BYTE) ATA_READ_BYTE(m_pATAReg + ATA_REG_STATUS);
    }
    inline BYTE GetError() 
    {
        return (BYTE) ATA_READ_BYTE(m_pATAReg + ATA_REG_ERROR);
    }   
    inline BYTE GetReason()
    {
        return (BYTE) ATA_READ_BYTE(m_pATAReg + ATA_REG_REASON);
    }   
    inline void SelectDevice() 
    {
        ATA_WRITE_BYTE(m_pATAReg+ATA_REG_DRV_HEAD, (m_dwDevice == 0 ) ? ATA_HEAD_DRIVE_1 : ATA_HEAD_DRIVE_2);
    } 
    inline void WriteDriveController(BYTE bData)
    {
        ATA_WRITE_BYTE(m_pATAReg+ATA_REG_DRV_CTRL, bData);
    }
    inline void WriteAltDriveController(BYTE bData)
    {
        ATA_WRITE_BYTE(m_pATARegAlt+ATA_REG_DRV_CTRL, bData);
    }
    inline void SetDriveHead(BYTE bDriveHead)
    {
        ATA_WRITE_BYTE(m_pATAReg+ATA_REG_DRV_HEAD, bDriveHead);
    }
    inline void WriteCommand(BYTE bCommand)
    {
        ATA_WRITE_BYTE(m_pATAReg + ATA_REG_COMMAND, bCommand);
    }
    inline void WriteFeature(BYTE bFeature)
    {
        ATA_WRITE_BYTE( m_pATAReg + ATA_REG_FEATURE, bFeature);
    }
    
    inline void WriteSectorCount(BYTE bValue) 
    {
        ATA_WRITE_BYTE(m_pATAReg + ATA_REG_SECT_CNT, bValue);
    }    

    inline void WriteDriveHeadReg(BYTE bValue) 
    {
        ATA_WRITE_BYTE(m_pATAReg + ATA_REG_DRV_HEAD, bValue);
    }    

    inline void WriteSectorNumber(BYTE bValue) 
    {
        ATA_WRITE_BYTE(m_pATAReg + ATA_REG_SECT_NUM, bValue);
    }    

    inline void WriteLowCount(BYTE bValue) 
    {
        ATA_WRITE_BYTE(m_pATAReg + ATA_REG_BYTECOUNTLOW, bValue);
    }    

    inline void WriteHighCount(BYTE bValue) 
    {
        ATA_WRITE_BYTE(m_pATAReg + ATA_REG_BYTECOUNTHIGH, bValue);
    }    
    
    inline BYTE GetLowCount() 
    {
        return ATA_READ_BYTE(m_pATAReg+ ATA_REG_BYTECOUNTLOW);
    }
    
    inline BYTE GetHighCount() 
    {
        return ATA_READ_BYTE(m_pATAReg+ ATA_REG_BYTECOUNTHIGH);
    }    
    
    inline WORD GetCount() 
    {
        return GetLowCount() + ((WORD)GetHighCount() <<8);
    }    
    
    inline void ReadWordBuffer( PWORD pBuffer, DWORD dwCount)
    {
        READ_PORT_BUFFER_USHORT( (PWORD)(m_pATAReg+ATA_REG_DATA), pBuffer, dwCount);
    }
    inline void WriteWordBuffer( PWORD pBuffer, DWORD dwCount)
    {
        WRITE_PORT_BUFFER_USHORT((PWORD)(m_pATAReg+ATA_REG_DATA), pBuffer, dwCount);
    } 
    inline void ReadByteBuffer( PBYTE pBuffer, DWORD dwCount)
    {
        READ_PORT_BUFFER_UCHAR(m_pATAReg+ATA_REG_DATA, pBuffer, dwCount);
    }
    inline void WriteByteBuffer( PBYTE pBuffer, DWORD dwCount)
    {
        WRITE_PORT_BUFFER_UCHAR(m_pATAReg+ATA_REG_DATA, pBuffer, dwCount);
    } 
    inline void WriteWord(WORD wData) 
    {
        ATA_WRITE_WORD((PWORD)(m_pATAReg + ATA_REG_DATA), wData);
    }    
    inline WORD ReadWord()
    {
        return ATA_READ_WORD((PWORD)(m_pATAReg+ATA_REG_DATA));
    }    
    inline void WriteByte(BYTE bData) 
    {
        ATA_WRITE_BYTE(m_pATAReg + ATA_REG_DATA, bData);
    }    
    inline WORD ReadByte()
    {
        return ATA_READ_BYTE(m_pATAReg+ATA_REG_DATA);
    }    
    
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);
        WaitForDisc(WAIT_TYPE_NOT_BUSY,400);
        WaitForDisc(WAIT_TYPE_READY,500);
    }

    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 IsDMASupported()
    {
        return ((m_Id.Capabilities & IDENTIFY_CAPABILITIES_DMA_SUPPORTED) && m_fDMAActive);
    }    
    inline BOOL IsDRQTypeIRQ()
    {
        return ((m_Id.GeneralConfiguration >> 5) & 0x0003) == ATA_DRQTYPE_INTRQ;
    }    
    inline WORD GetPacketSize()
    {
        return m_Id.GeneralConfiguration & 0x0003 ? 16 : 12;
    }
private:
    BOOL static ValidateSg(PSG_REQ pSgReq ,DWORD InBufLen);
    BOOL static ValidateSg(PCDROM_READ pCdrom,DWORD InBufLen);
};


#endif // _DISKMAIN_H_