inline void WriteWordBuffer(PWORD pBuffer, DWORD dwCount) {
        volatile USHORT * const Port = (volatile USHORT * const)(m_pATAReg+m_dwDataDrvCtrlOffset);
        if (m_pPort->m_pController->m_bisIOMapped)
            WRITE_PORT_BUFFER_USHORT((PUSHORT)Port, pBuffer, dwCount);
        else {
            while( dwCount-- )
                *Port = *pBuffer++;
        }
    }
*/

    // Read/write Error/Feature register
    inline BYTE GetError() {
        return (BYTE) ATA_READ_BYTE(m_pATAReg + m_dwFeatureErrorOffset);
    }
    inline void WriteFeature(BYTE bFeature) {
        ATA_WRITE_BYTE( m_pATAReg + m_dwFeatureErrorOffset, bFeature);
    }
    // Read/write Sector Count register
    inline BYTE GetReason() {
        return (BYTE) ATA_READ_BYTE(m_pATAReg + m_dwSectCntReasonOffset);
    }
    inline void WriteSectorCount(BYTE bValue) {
        ATA_WRITE_BYTE(m_pATAReg + m_dwSectCntReasonOffset, bValue);
    }
    // Write Sector Number register
    inline void WriteSectorNumber(BYTE bValue) {
        ATA_WRITE_BYTE(m_pATAReg + m_dwSectNumOffset, bValue);
    }
    // Read/write Cylinder Low, Cylinder High register
    inline BYTE GetLowCount() {
        return ATA_READ_BYTE(m_pATAReg+ m_dwByteCountLowOffset);
    }
    inline void WriteLowCount(BYTE bValue) {
        ATA_WRITE_BYTE(m_pATAReg + m_dwByteCountLowOffset, bValue);
    }
    inline BYTE GetHighCount() {
        return ATA_READ_BYTE(m_pATAReg+ m_dwByteCountHighOffset);
    }
    inline void WriteHighCount(BYTE bValue) {
        ATA_WRITE_BYTE(m_pATAReg + m_dwByteCountHighOffset, bValue);
    }
    inline WORD GetCount() {
        return GetLowCount() + ((WORD)GetHighCount() << 8);
    }
    // Set DEV bit in Device/Head register
    inline void SelectDevice() {
        ATA_WRITE_BYTE(m_pATAReg + m_dwDrvHeadOffset, (m_dwDevice == 0 ) ? ATA_HEAD_DRIVE_1 : ATA_HEAD_DRIVE_2);
    }
    // Write Device/Head register
    inline void SetDriveHead(BYTE bDriveHead) {
        ATA_WRITE_BYTE(m_pATAReg + m_dwDrvHeadOffset, bDriveHead);
    }
    inline void WriteDriveHeadReg(BYTE bValue) {
        ATA_WRITE_BYTE(m_pATAReg + m_dwDrvHeadOffset, bValue);
    }
    // Read Status register (does not clear pending interrupt)
    inline BYTE GetBaseStatus() {
        BYTE bStatus = ATA_READ_BYTE(m_pATAReg + m_dwCommandStatusOffset);
        if (ZONE_CELOG) CeLogData(TRUE, CELID_ATAPI_BASESTATUS, &bStatus, sizeof(bStatus), 0, CELZONE_ALWAYSON, 0, FALSE);
        return bStatus;
    }
    // Write Command register
    inline void WriteCommand(BYTE bCommand) {
        ATA_WRITE_BYTE(m_pATAReg + m_dwCommandStatusOffset, bCommand);
    }
    // Read/write Alternate Status register (read clears pending interrupt)
    inline BYTE GetAltStatus() {
        return (BYTE) ATA_READ_BYTE(m_pATARegAlt + m_dwAltStatusOffset);
    }
    inline void WriteAltDriveController(BYTE bData) {
        ATA_WRITE_BYTE(m_pATARegAlt + m_dwAltDrvCtrl, bData);
    }
 
    inline BYTE ReadByteFromRDATA() {
        return (BYTE) (*((PBYTE)(m_pATAReg + ATA_PIO_RDATA)));
    }

    inline WORD ReadWordFromRDATA() {
        return (WORD) (*((PUSHORT)(m_pATAReg + ATA_PIO_RDATA)));
    }

    inline DWORD ReadDWordFromRDATA() {
        return (DWORD) (*((PULONG)(m_pATAReg + ATA_PIO_RDATA)));
    }    
    

    // ------------------------------------------------------------------------
    // ------------------------------------------------------------------------

    // DSK_Init calls this before Init; set up register blocks
    virtual VOID ConfigureRegisterBlock(DWORD dwStride);
    // Called by DSK_Init
    virtual BOOL Init(HKEY hActiveKey);
    // Reset controller, enable interrupts, call Identify
    virtual BOOL InitController(BOOL fForce = FALSE);
    // Set m_fUseLBA48 if appropriate
    void ConfigLBA48(void);
    // Return STORAGEDEVICEINFO structure
    virtual DWORD GetDeviceInfo(PIOREQ pIOReq);
    // Return STORAGEDEVICEINFO structure by reading the registry.
    virtual DWORD GetDeviceInfo(PSTORAGEDEVICEINFO psdi);
    // Handle standard (diskio.h), non-CD, non-DVD IOCTL-s
    virtual DWORD MainIoctl(PIOREQ pIOReq);
    // Wait for Status register DRQ bit to assert
    virtual BOOL WaitForDRQ();
    // Wait for a specified Status register bit to assert/negate
    virtual BOOL WaitForDisc(BYTE bStatusType, DWORD dwTimeOut, DWORD dwPeriod = 0);
    // DMA I/O
    virtual DWORD ReadWriteDiskDMA(PIOREQ pIOReq, BOOL fRead = TRUE);
    // Instantiate a CDiskPower object
    virtual CDiskPower *GetDiskPowerInterface(void);
    // Eventually called in response to an IOCTL_POWER_SET
    virtual BOOL SetDiskPowerState(CEDEVICE_POWER_STATE newDx);
    // Base wake up function
    virtual BOOL WakeUp();
    // Acquire this instance's critical section
    virtual void TakeCS();
    // Release this instance's critical section
    virtual void ReleaseCS();
    // Called by DSK_Init; this information is used by CDiskPower
    void SetActiveKey(TCHAR *szActiveKey);
    // Called by DSK_Init; this information is used by CDiskPower
    void SetDeviceKey(TCHAR *szDeviceKey);

    // ------------------------------------------------------------------------
    // ------------------------------------------------------------------------

    // Wait for interrupt
    virtual BOOL WaitForInterrupt(DWORD dwTimeOut) = 0;
    // Enable device interrupt
    virtual void EnableInterrupt() = 0;
 
    // ------------------------------------------------------------------------
    // ------------------------------------------------------------------------

    // Core device/CDisk initialize function
    BOOL Identify();
    // Determine whether this device is present on the channel
    BOOL IsDevicePresent();

    // Wait for Status register BSY bit to negate
    BYTE WaitOnBusy(BOOL fBase);
    // Sleep for @dwTime milliseconds
    void StallExecution(DWORD dwTime);
    // Return interrupt state?
    WORD CheckIntrState();

    // ------------------------------------------------------------------------
    // ------------------------------------------------------------------------

    // Perform ATA/ATAPI soft-reset
    BOOL ResetController(BOOL bSoftReset = FALSE);
    // This function sets the transfer mode to @dwMode; For more information
    // on transfer mode encodings, see ATA/ATAPI-6 R3B 8.46.11 (Set transfer mode)
    BOOL SetTransferMode(BYTE bMode);
    // Send EXECUTE DEVICE DIAGNOSTIC command; Determine whether this device is
    // an ATA device or an ATAPI device
    BOOL SendExecuteDeviceDiagnostic(PBYTE pbDiagnosticCode, PBOOL pfIsAtapi);
    // Send IDENTIFY DEVICE/IDENTIFY PACKET DEVICE command
    BOOL SendIdentifyDevice(BOOL fIsAtapi);
    // Enable write cache through SET FEATURES
    BOOL SetWriteCacheMode(BOOL fEnable);
    // Enable read look-ahead through SET FEATURES
    BOOL SetLookAhead();
    // Non-DMA I/O
    BOOL DoRead(CSgReq* pSgReqWrapper, DWORD dwStartingSector, DWORD dwNumberOfSectors, PDWORD pdwBytesRead);
    BOOL DoRead(PBYTE pbBuf, DWORD dwStartingSector, DWORD dwNumberOfSectors, PDWORD pdwBytesRead);
    BOOL DoReadDMA(PBYTE pbBuf, DWORD dwStartingSector, DWORD dwNumberOfSectors, PDWORD pdwBytesRead);
    DWORD ReadDisk(PIOREQ pIoReq);
    BOOL DoWrite(CSgReq* pSgReqWrapper, DWORD dwStartingSector, DWORD dwNumberOfSectors, PDWORD pdwBytesWritten);
    BOOL DoWrite(PBYTE pbBuf, DWORD dwStartingSector, DWORD dwNumberOfSectors, PDWORD pdwBytesWritten);
    BOOL DoWriteDMA(PBYTE pbBuf, DWORD dwStartingSector, DWORD dwNumberOfSectors, PDWORD pdwBytesWritten);
    DWORD WriteDisk(PIOREQ pIoReq);
    // Issue FLUSH CACHE
    DWORD FlushCache();
    // Send read/write command
    BOOL SendIOCommand(DWORD dwStartSector, DWORD dwNumberOfSectors, BYTE bCmd);
    // Issue Power Management command and implements the non-data command protocol
    BOOL SendDiskPowerCommand(BYTE bCmd, BYTE bParam = 0);
    // Issue ATAPI soft-reset
    void AtapiSoftReset();

    // ------------------------------------------------------------------------
    // ------------------------------------------------------------------------

    // Increment m_dwOpenCount; references to device
    void Open();
    // Decrement m_dwOpenCount; references to device
    void Close();
    // Return DISK_INFO structure
    DWORD GetDiskInfo(PIOREQ pIOReq);
    // Set ISK_INFO structure
    DWORD SetDiskInfo(PIOREQ pIOReq);
    // Return mount name, e.g., "Hard Disk"
    DWORD GetDiskName(PIOREQ pIOReq);
    // Return STORAGE_IDENTIFICATION
    DWORD GetStorageId(PIOREQ pIOReq);
    // Handle DISK_IOCTL_INITIALIZED
    BOOL PostInit(PPOST_INIT_BUF pPostInitBuf);
    // Intercept IOCTL_POWER_Xxx-s (and instantiates a CDiskPower object during
    // IOCTL_POWER_CAPABILITIES) and forwards all other IOCTL-s to MainIoctl
    BOOL PerformIoctl(PIOREQ pIOReq);
    // Validate pointers embedded in scatter/gather requests
    BOOL static 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) ;

    // ------------------------------------------------------------------------
    // ------------------------------------------------------------------------

    // Determine if Power Management is supported by examining the IDENTIFY
    // DEVICE information
    BOOL IsPMSupported(void);
    // Determines if Power Management is enabled by examining the IDENTIFY
    // DEVICE information
    BOOL IsPMEnabled(void);

    void PowerUp() { m_dwDeviceFlags &= ~DFLAGS_DEVICE_PWRDN; }
    void PowerDown() { m_dwDeviceFlags |= DFLAGS_DEVICE_PWRDN; }

    // ------------------------------------------------------------------------
    // ------------------------------------------------------------------------

    // Return m_fAtapiDevice
    BOOL IsAtapiDevice();
    // Check the IDENTIFY DEVICE data to see if the device is a CD-ROM device
    BOOL IsCDRomDevice();
    // Check the IDENTIDY DEVICE data to see if the device is a disk device
    BOOL IsDiskDevice();
    // Check the IDENTIDY DEVICE data to see if the device is a removable media device
    BOOL IsRemoveableDevice();
    // Check the IDENTIFY DEVICE data to see if the device supports DMA and
    // whether m_fDMAActive is TRUE
    BOOL IsDMASupported();
    // Check the IDENTIFY DEVICE data to see the packet size supported by the device
    WORD GetPacketSize();
    // Check the IDENTIFY DEVICE data to see if a portion of it is valid
    BOOL IsValidCommandSupportInfo();
    // Check the IDENTIFY DEVICE data to see if the device supports the write cache feature
    BOOL IsWriteCacheSupported();
    // Not used
    BOOL IsDRQTypeIRQ();
    // Not used
    BOOL IsDVDROMDevice();

    BYTE ATA_READ_BYTE(PBYTE p);
    WORD ATA_READ_WORD(PUSHORT p);
    ULONG ATA_READ_DWORD(PULONG p);   
    void ATA_WRITE_BYTE(PBYTE p,BYTE v);
    void ATA_WRITE_WORD(PUSHORT p,USHORT v);
    void ATA_WRITE_DWORD(PULONG p,ULONG v);

    void ReadByteBuffer(PBYTE pBuffer, DWORD dwCount);
    void ReadWordBuffer(PWORD pBuffer, DWORD dwCount);
    void WriteByteBuffer(PBYTE pBuffer, DWORD dwCount);
    void WriteWordBuffer(PWORD pBuffer, DWORD dwCount);
  
    

    void WaitForNoBusyStatus(void);

    void SetConfigMode(int mode, int isWriteMode);

    int SetTransferCommand(UINT32 command);

    virtual void SetPioMode(UCHAR pmode) = 0;
    virtual void SetUdmaMode(void) = 0;
 };

#define ATA_CMD_STOP 0
#define ATA_CMD_START 1
#define ATA_CMD_ABORT 2

#define PIO_CPU 0
#define PIO_DMA 1
#define UDMA 2


#define PIO0 0
#define PIO1 1
#define PIO2 2
#define PIO3 3
#define PIO4 4


#define UDMA0 0
#define UDMA1 1
#define UDMA2 2
#define UDMA3 3
#define UDMA4 4

#endif // _DISKMAIN_H_