virtual BOOL InterpretCapabilities( LPCTSTR pszRegistryPath );
    void OnPowerUp();
    void OnPowerDown();
    void PreDeinit();

protected:
    // override to customize for specific hardware
    virtual BOOL InitializeHardware( BOOL bOnPowerUp = FALSE ) = 0;
    virtual void DeinitializeHardware( BOOL bOnPowerDown = FALSE ) = 0;
    virtual BOOL CustomSetup( LPCTSTR pszRegistryPath ) = 0;
    virtual BOOL IsCardWriteProtected() = 0;
    virtual BOOL IsCardPresent() = 0;

protected:

    volatile S3C2440X_SDI_REG    *vm_pSDIReg;                // pointer to the SDI special registers
    volatile S3C2440X_IOPORT_REG *vm_pIOPreg;                // pointer to the GPIO control registers
    volatile S3C2440X_CLKPWR_REG *vm_pCLKPWR;                // pointer to the clock control register
    volatile S3C2440X_DMA_REG    *vm_pDMAreg;                // pointer to the DMA special registers

    DWORD                   m_dwSDIOIrq;                     // SDIO IRQ
    DWORD                   m_dwSDIOSysIntr;                 // SDIO SysIntr

    PBYTE                   m_pDMABuffer;                    // pointer to buffers used for DMA transfers
    PHYSICAL_ADDRESS        m_pDMABufferPhys;                // physical address of the SMA buffer
    DWORD                   m_dwDMAChannel;                  // DMA channel to use for data transfers
    DWORD                   m_dwDMAIrq;                      // DMA IRQ
    DWORD                   m_dwDMASysIntr;                  // DMA SysIntr

    DWORD                   m_dwPollingTimeout;              // card detect thread polling timeout

    char                    m_chCardDetectGPIO;              // GPIO used for card detection
    DWORD                   m_dwCardDetectMask;
    DWORD                   m_dwCardDetectFlag;
    DWORD                   m_dwCardDetectControlMask;
    DWORD                   m_dwCardDetectControlFlag;
    DWORD                   m_dwCardDetectPullupMask;
    DWORD                   m_dwCardDetectPullupFlag;

    char                    m_chCardReadWriteGPIO;           // GPIO used for card read/write detection
    DWORD                   m_dwCardReadWriteMask;
    DWORD                   m_dwCardReadWriteFlag;
    DWORD                   m_dwCardReadWriteControlMask;
    DWORD                   m_dwCardReadWriteControlFlag;
    DWORD                   m_dwCardReadWritePullupMask;
    DWORD                   m_dwCardReadWritePullupFlag;

    PSDCARD_HC_CONTEXT      m_pHCContext;                    // the host controller context
    HANDLE                  m_hResponseReceivedEvent;		 // Used to post command response info asynchronously

    int                     m_nCardDetectIstThreadPriority;  // controller IST thread priority
    HANDLE                  m_hCardInsertInterruptEvent;     // card insert/remove interrupt event
    HANDLE                  m_hCardInsertInterruptThread;    // card insert/remove interrupt event

    int                     m_nSDIOIstThreadPriority;        // SDIO IST thread priority
    HANDLE                  m_hSDIOInterruptEvent;           // SDIO Interrupt event
    HANDLE                  m_hSDIOInterruptThread;          // SDIO Interrupt Thread Event

    int                     m_nControllerIstThreadPriority;  // controller IST thread priority
    HANDLE                  m_hControllerInterruptEvent;     // controller interrupt event
    HANDLE                  m_hControllerInterruptThread;    // controller interrupt thread

    int                     m_DMAIstThreadPriority;		     // DMA IST thread priority
    HANDLE                  m_hDMAInterruptEvent;			 // DMA interrupt event
    HANDLE                  m_hDMAInterruptThread;		     // DMA interrupt thread   

    BOOL                    m_bReinsertTheCard;              // Indicates if a card insertion should be simulated now
    BOOL                    m_bUseDMAForTransfer;			 // Indicates whether DMA is used for I/O requests
    BOOL                    m_bDriverShutdown;               // controller shutdown
    CRITICAL_SECTION        m_ControllerCriticalSection;     // controller critical section 
    BOOL                    m_bDevicePresent;                // indicates if device is present in the slot											  
    WCHAR                   m_rgchRegPath[256];              // reg path  
    SDHCDSTATE              m_CurrentState;                  // current transfer state
    BOOL                    m_bSendInitClocks;               // indicates if this is the first command sent
    DWORD			        m_dwLastTypeOfTransfer;          // inidcates the last type of data transfer initiated

    DWORD			        m_dwNumBytesToTransfer;          // # of bytes that still need to be transferred
    DWORD			        m_dwNumBytesUnaligned;           // # of bytes from a DWORD-aligned address
    DWORD			        m_dwNumBytesExtra;               // # of extra bytes in buffer that aren't a multiple of sizeof(DWORD)

    DWORD			        m_dwSDIBusWidth;                 // SD data transfer mode (1 bit or 4 bit) flag
    DWORD                   m_dwClockRate;                   // current clock rate

    BOOL                    m_fCardInTheSlot;				 // TRUE - a card is inserted in the slot, FALSE otherwise
    BOOL                    m_fHandleBusyCheckOnCommand38;
    DWORD                   m_dwDMATransferTimeoutFactor;
    DWORD                   m_dwDMATransferTimeoutConstant;

    SD_API_STATUS	SendCommand(UINT16 Cmd, UINT32 Arg, UINT16 respType, BOOL bDataTransfer);
    SD_API_STATUS   GetCommandResponse(PSD_BUS_REQUEST pRequest);
    DWORD           SetClockRate(DWORD dwClockRate);
    BOOL			IsCardBusy(UINT16 inData);

    BOOL			SetupDmaXfer(PSD_BUS_REQUEST pRequest);

    BOOL			SetupPollingXfer(PSD_BUS_REQUEST pRequest);
    BOOL			PollingTransmit(PSD_BUS_REQUEST pRequest, DWORD dwLen);
    BOOL			PollingReceive(PSD_BUS_REQUEST pRequest, DWORD dwLen);

    inline void     MMC_Hardware_PowerUp();
    inline void     MMC_Hardware_PowerDown();
    inline void     Stop_SDI_Hardware();
    inline void     Set_SDI_Bus_Width_1Bit();
    inline void     Set_SDI_Bus_Width_4Bit();
    inline DWORD    Get_SDI_Bus_Width();
    inline void     Wait_80_SDI_Clock_Cycles();
    inline void     Start_SDI_Clock();
    inline void     Stop_SDI_Clock();
    inline BOOL     Is_SDI_Clock_Running();
    inline void     Enable_SDIO_Interrupts();
    inline void     Disable_SDIO_Interrupts();
    inline BOOL     Is_SDIO_Interrupt_Enabled();
    inline void     Ack_SDIO_Interrupts();
    inline void     Enable_SDIO_DMA_Channel();
    inline void     Disable_SDIO_DMA_Channel();
    inline void     Stop_SDIO_DMA_Channel();

    // thread routines
    virtual DWORD   CardDetectThread();
    virtual DWORD   IOInterruptIstThread();
    virtual DWORD   TransferIstThread();

    // implementation of the callbacks for the SD Bus driver
    SD_API_STATUS	Deinitialize();
    SD_API_STATUS	Initialize();
    BOOLEAN			CancelIoHandler(DWORD dwSlot, PSD_BUS_REQUEST pRequest);
    SD_API_STATUS	BusRequestHandler(DWORD dwSlot, PSD_BUS_REQUEST pRequest);
    SD_API_STATUS	SlotOptionHandler(DWORD dwSlot, SD_SLOT_OPTION_CODE Option, PVOID pData, ULONG OptionSize);

    // thread start routines
    static DWORD            SD_CardDetectThread(CSDIOControllerBase *pController);
    static DWORD            SD_IOInterruptIstThread(CSDIOControllerBase *pController);
    static DWORD            SD_TransferIstThread(CSDIOControllerBase *pController);

    // SD Bus driver callback functions
    static SD_API_STATUS	SDHCDDeinitialize(PSDCARD_HC_CONTEXT pHCContext);
    static SD_API_STATUS	SDHCDInitialize(PSDCARD_HC_CONTEXT pHCContext);
    static BOOLEAN			SDHCDCancelIoHandler(PSDCARD_HC_CONTEXT pHCContext, DWORD dwSlot, PSD_BUS_REQUEST pRequest);
    static SD_API_STATUS	SDHCDBusRequestHandler(PSDCARD_HC_CONTEXT pHCContext, DWORD dwSlot, PSD_BUS_REQUEST pRequest);
    static SD_API_STATUS	SDHCDSlotOptionHandler(PSDCARD_HC_CONTEXT pHCContext, DWORD dwSlot, 
									    SD_SLOT_OPTION_CODE Option, PVOID pData, ULONG OptionSize);
};

typedef CSDIOControllerBase *PCSDIOControllerBase;

#define GET_PCONTROLLER_FROM_HCD(pHCDContext) \
    GetExtensionFromHCDContext(PCSDIOControllerBase, pHCDContext)

CSDIOControllerBase *CreateSDIOController( PSDCARD_HC_CONTEXT pHCContext );

#define SDHC_INTERRUPT_ZONE    SDCARD_ZONE_0
#define SDHC_SEND_ZONE         SDCARD_ZONE_1
#define SDHC_RESPONSE_ZONE     SDCARD_ZONE_2
#define SDHC_RECEIVE_ZONE      SDCARD_ZONE_3
#define SDHC_CLOCK_ZONE        SDCARD_ZONE_4
#define SDHC_TRANSMIT_ZONE     SDCARD_ZONE_5

#define SDHC_INTERRUPT_ZONE_ON ZONE_ENABLE_0
#define SDHC_SEND_ZONE_ON      ZONE_ENABLE_1
#define SDHC_RESPONSE_ZONE_ON  ZONE_ENABLE_2
#define SDHC_RECEIVE_ZONE_ON   ZONE_ENABLE_3
#define SDHC_CLOCK_ZONE_ON     ZONE_ENABLE_4
#define SDHC_TRANSMIT_ZONE_ON  ZONE_ENABLE_5

#endif // __SDIOCONTROLLER_H

// DO NOT REMOVE --- END EXTERNALLY DEVELOPED SOURCE CODE ID --- DO NOT REMOVE