Windows CE SDHC驱动简析(2)-CSDIOControllerBase类(基于WinCE5.0 SMDK2410 BSP的SDHC驱动)

接下来我们来看看CSDIOControllerBase类,该类实现了主控制器驱动的硬件实现,定义了很多成员变量和函数,如有错误,欢迎指正.
CSDIOControllerBase原型如下:

 class CSDIOControllerBase
 {
 public:
     explicit CSDIOControllerBase( PSDCARD_HC_CONTEXT pHCContext );
     virtual ~CSDIOControllerBase();

     PSDCARD_HC_CONTEXT GetHostContext() const;

     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 S3C2410X_SDI_REG    *vm_pSDIReg;                // pointer to the SDI special registers
     volatile S3C2410X_IOPORT_REG *vm_pIOPreg;                // pointer to the GPIO control registers
     volatile S3C2410X_CLKPWR_REG *vm_pCLKPWR;                // pointer to the clock control register
     volatile S3C2410X_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);
 };

其中有几个纯虚函数是由继承类实现的(CSDIOController类,sdiocontroller.cpp)
    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;
下面我们来一一看看每个成员函数:
1.构造函数CSDIOControllerBase
初始化成员变量,大部分初始化为0或NULL,当前状态m_CurrentState设为Idle

 CSDIOControllerBase::CSDIOControllerBase( PSDCARD_HC_CONTEXT pHCContext )
 {
     vm_pSDIReg = NULL;
     vm_pIOPreg = NULL;
     vm_pCLKPWR = NULL;
     vm_pDMAreg = NULL;
     m_pDMABuffer = NULL;
     m_dwDMAChannel = 0;

     m_pHCContext = pHCContext;

     m_hResponseReceivedEvent = NULL;
     m_nCardDetectIstThreadPriority = 0;
     m_hCardInsertInterruptEvent = NULL;
     m_hCardInsertInterruptThread = NULL;

     m_nSDIOIstThreadPriority = 0;
     m_hSDIOInterruptEvent = NULL;
     m_hSDIOInterruptThread = NULL;

     m_nControllerIstThreadPriority = 0;
     m_hControllerInterruptEvent = NULL;
     m_hControllerInterruptThread = NULL;

     m_DMAIstThreadPriority = 0;
     m_hDMAInterruptEvent = NULL;
     m_hDMAInterruptThread = NULL;

     m_bUseDMAForTransfer = FALSE;
     m_bDriverShutdown = FALSE;

     m_bDevicePresent = FALSE;
     m_CurrentState = Idle;
     m_bSendInitClocks = TRUE;
     m_dwLastTypeOfTransfer = SD_READ;

     m_dwNumBytesToTransfer = 0;
     m_dwNumBytesUnaligned = 0;
     m_dwNumBytesExtra = 0;

     m_rgchRegPath[0] = 0;
     m_dwSDIBusWidth = 0;

     m_bReinsertTheCard = FALSE;

     m_fHandleBusyCheckOnCommand38 = FALSE;
     m_dwDMATransferTimeoutFactor = 8;
     m_dwDMATransferTimeoutConstant = 3000;

     m_fCardInTheSlot = FALSE;
 }

 
2.~CSDIOControllerBase
未做任何工作.

3.PreDeinit
这个函数被SDH_PreDeinit调用,m_bDriverShutdown为FALSE时调用Deinitialize进行资源释放.

 void CSDIOControllerBase::PreDeinit()
 {
     if( !m_bDriverShutdown )
     {
         Deinitialize();
     }
 }

 
4.Initialize
该函数被SDHCDInitialize调用.
(1)设置crtical section临界访问,然后映射GPIO寄存器空SDI控制器,时钟能源管理寄存器,DMA控制器IO地址空间. 然后分配内存给DMA传输(64KB大小).
接着初始化寄存器
(2)MMC_Hardware_PowerUp设置CLKCON使能SDI PCLK.
(3)设置GPIO寄存器使能SDI功能
(4)SetClockRate设置SDI时钟(100HZ)
(5)设置SDI寄存器模式,little edian,512 bytes per block,设置timeout,reset fifo
(6)创建SD卡检测事件m_hCardInsertInterruptEvent及线程SD_CardDetectThread
(7)创建接收应答事件m_hResponseReceivedEvent
(8)创建IST线程m_hSDIOInterruptThread处理SDIO数据传输中断事件m_hSDIOInterruptEvent,并初始化中断
(9)设置DMA传输中断事件m_hDMAInterruptEvent和线程m_hDMAInterruptThread
(10)调用继承类InitializeHardware函数.
(11)出错处理,调用Deinitialize

 SD_API_STATUS CSDIOControllerBase::Initialize()
 {
     DEBUGMSG (SDCARD_ZONE_INIT,(TEXT("SDHCDInitialize starts")));
     SD_API_STATUS status = SD_API_STATUS_SUCCESS;   // intermediate status
     DWORD         threadID;                         // thread ID

     InitializeCriticalSection(&m_ControllerCriticalSection);

     //----- 1. Map the GPIO registers needed to enable the SDI controller -----
     vm_pIOPreg = (S3C2410X_IOPORT_REG *)VirtualAlloc(0, sizeof(S3C2410X_IOPORT_REG), MEM_RESERVE, PAGE_NOACCESS);
     if (vm_pIOPreg == NULL)
     {
         DEBUGMSG (1,(TEXT("GPIO registers not allocated")));
         status = SD_API_STATUS_INSUFFICIENT_RESOURCES;
         goto INIT_ERROR;
     }
     if (!VirtualCopy((PVOID)vm_pIOPreg, (PVOID)(S3C2410X_BASE_REG_PA_IOPORT >> 8), sizeof(S3C2410X_IOPORT_REG), PAGE_PHYSICAL | PAGE_READWRITE | PAGE_NOCACHE)) {
         DEBUGMSG (1,(TEXT("GPIO registers not mapped")));
         status = SD_API_STATUS_INSUFFICIENT_RESOURCES;
         goto INIT_ERROR;
     }
     DEBUGMSG (1,(TEXT("GPIO registers mapped to %x"), vm_pIOPreg));

     //----- 2. Map the SDI control registers into the device drivers address space -----
     vm_pSDIReg = (S3C2410X_SDI_REG *)VirtualAlloc(0, sizeof(S3C2410X_SDI_REG), MEM_RESERVE, PAGE_NOACCESS);
     if (vm_pSDIReg == NULL)
     {
         DEBUGMSG (1,(TEXT("SDI control registers not allocated/n/r")));
         status = SD_API_STATUS_INSUFFICIENT_RESOURCES;
         goto INIT_ERROR;
     }
     if (!VirtualCopy((PVOID)vm_pSDIReg, (PVOID)(S3C2410X_BASE_REG_PA_SDI >> 8), sizeof(S3C2410X_SDI_REG), PAGE_PHYSICAL | PAGE_READWRITE | PAGE_NOCACHE)) {
         DEBUGMSG (1,(TEXT("SDI control registers not mapped/n/r")));
         status = SD_API_STATUS_INSUFFICIENT_RESOURCES;
         goto INIT_ERROR;
     }
     DEBUGMSG (1,(TEXT("SDI control registers mapped to %x/n/r"), vm_pSDIReg));

     vm_pCLKPWR = (S3C2410X_CLKPWR_REG *)VirtualAlloc(0, sizeof(S3C2410X_CLKPWR_REG), MEM_RESERVE, PAGE_NOACCESS);
     if (vm_pCLKPWR == NULL)
     {
         DEBUGMSG (1,(TEXT("Clock & Power Management Special Register not allocated/n/r")));
         status = SD_API_STATUS_INSUFFICIENT_RESOURCES;
         goto INIT_ERROR;
     }
     if (!VirtualCopy((PVOID)vm_pCLKPWR, (PVOID)(S3C2410X_BASE_REG_PA_CLOCK_POWER >> 8), sizeof(S3C2410X_CLKPWR_REG), PAGE_PHYSICAL | PAGE_READWRITE | PAGE_NOCACHE)) {
         DEBUGMSG (1,(TEXT("Clock & Power Management Special Register not mapped/n/r")));
         goto INIT_ERROR;
     }
     DEBUGMSG (1,(TEXT("Clock & Power Management Special Register mapped to %x/n/r"), vm_pCLKPWR));

     if( m_dwDMAChannel != 0xffffffff )
     {
         //----- 3. Map the DMA control registers used for SDI data transfers -----
         vm_pDMAreg = (S3C2410X_DMA_REG *)VirtualAlloc(0, sizeof(S3C2410X_DMA_REG), MEM_RESERVE, PAGE_NOACCESS);
         if (vm_pDMAreg == NULL)
         {
             DEBUGMSG (1,(TEXT("DMA Register not allocated/n/r")));
             status = SD_API_STATUS_INSUFFICIENT_RESOURCES;
             goto INIT_ERROR;
         }
         if (!VirtualCopy((PVOID)vm_pDMAreg, (PVOID)(S3C2410X_BASE_REG_PA_DMA >> 8), sizeof(S3C2410X_DMA_REG), PAGE_PHYSICAL | PAGE_READWRITE | PAGE_NOCACHE)) {
             DEBUGMSG (1,(TEXT("DMA Register not mapped/n/r")));
             status = SD_API_STATUS_INSUFFICIENT_RESOURCES;
             goto INIT_ERROR;
         }
         DEBUGMSG (1,(TEXT("DMA Register mapped to %x/n/r"), vm_pDMAreg));

         //----- 4. Allocate a block of memory for DMA transfers -----
         DMA_ADAPTER_OBJECT dmaAdapter;
         dmaAdapter.ObjectSize = sizeof(dmaAdapter);
         dmaAdapter.InterfaceType = Internal;
         dmaAdapter.BusNumber = 0;
         m_pDMABuffer = (PBYTE)HalAllocateCommonBuffer( &dmaAdapter, MAXIMUM_DMA_TRANSFER_SIZE, &m_pDMABufferPhys, FALSE );
         if( m_pDMABuffer == NULL )
         {
             RETAILMSG(1, (TEXT("SHCDriver: - Unable to allocate memory for DMA buffers!/r/n")));
             status = SD_API_STATUS_INSUFFICIENT_RESOURCES;
             goto INIT_ERROR;
         }
     }

     //  Supply the clock to the SDI controller
     MMC_Hardware_PowerUp();

     //----- 6. Configure the GPIO lines for SDI mode and enable the pullup resistor -----
     vm_pIOPreg->GPEUP  &= 0xF83F;
     vm_pIOPreg->GPECON |= 0x2AA800;

     //----- 7. Set the SD/SDI controller to some reasonable default values -----
     SetClockRate(SD_DEFAULT_CARD_ID_CLOCK_RATE);        // 100Khz

     vm_pSDIReg->SDICON     |= LITTLE_ENDIAN_BYTE_ORDER;    // Windows CE is always Little Endian.
     vm_pSDIReg->SDICON     |= RESET_FIFO;                  // Reset the FIFO
     vm_pSDIReg->SDIBSIZE    = BYTES_PER_SECTOR;
     vm_pSDIReg->SDIDTIMER   = MAX_DATABUSY_TIMEOUT;        // Data/busy timeout

     //----- 8. Setup the thread for detecting card insertion/deletion -----
     m_hCardInsertInterruptEvent = CreateEvent(NULL, FALSE, FALSE,NULL);

     if(NULL == m_hCardInsertInterruptEvent)
     {
         status = SD_API_STATUS_INSUFFICIENT_RESOURCES;
         goto INIT_ERROR;
     }

     m_bDevicePresent                    = FALSE;

     m_hCardInsertInterruptThread = CreateThread(NULL, 0,
                                                 (LPTHREAD_START_ROUTINE)SD_CardDetectThread,
                                                 this, 0, &threadID);

     if(NULL == m_hCardInsertInterruptThread)
     {
         status = SD_API_STATUS_INSUFFICIENT_RESOURCES;
         goto INIT_ERROR;
     }


     //----- 9 . Setup an event used for signaling our response thread -----
     m_hResponseReceivedEvent = CreateEvent(NULL, FALSE, FALSE,NULL);

     if(NULL == m_hResponseReceivedEvent)
     {
         status = SD_API_STATUS_INSUFFICIENT_RESOURCES;
         goto INIT_ERROR;
     }


     //----- 10. Setup the IST for handling SDIO data transfer interrupts -----
     m_hSDIOInterruptEvent = CreateEvent(NULL, FALSE, FALSE,NULL);

     if(NULL == m_hSDIOInterruptEvent)
     {
         status = SD_API_STATUS_INSUFFICIENT_RESOURCES;
         goto INIT_ERROR;
     }

     // initialize the card insertion interrupt event
     if(!InterruptInitialize (m_dwSDIOSysIntr, m_hSDIOInterruptEvent,
                              NULL, 0))
     {
         status = SD_API_STATUS_INSUFFICIENT_RESOURCES;
         goto INIT_ERROR;
     }

     m_hSDIOInterruptThread = CreateThread(NULL, 0,
                                           (LPTHREAD_START_ROUTINE)SD_IOInterruptIstThread,
                                           this, 0, &threadID);

     if(NULL == m_hSDIOInterruptThread)
     {
         status = SD_API_STATUS_INSUFFICIENT_RESOURCES;
         goto INIT_ERROR;
     }

     //----- 11. Setup the interrupt event for handling SDIO DMA data transfers -----
     m_hDMAInterruptEvent = CreateEvent(NULL, FALSE, FALSE,NULL);

     if(NULL == m_hDMAInterruptEvent)
     {
         status = SD_API_STATUS_INSUFFICIENT_RESOURCES;
         goto INIT_ERROR;
     }

     // initialize the dma transfer interrupt event
     if(!InterruptInitialize (m_dwDMASysIntr, m_hDMAInterruptEvent,
                              NULL, 0))
     {
         status = SD_API_STATUS_INSUFFICIENT_RESOURCES;
         goto INIT_ERROR;
     }

     m_hDMAInterruptThread = CreateThread(NULL, 0,
                                                 (LPTHREAD_START_ROUTINE)SD_TransferIstThread,
                                                 this, 0, &threadID);

     if(NULL == m_hDMAInterruptThread)
     {
         status = SD_API_STATUS_INSUFFICIENT_RESOURCES;
         goto INIT_ERROR;
     }

     m_dwLastTypeOfTransfer = SD_READ;
     m_bUseDMAForTransfer = FALSE;

     if( !InitializeHardware() )
     {
         DEBUGMSG (1,(TEXT("InitializeHardware failed!/n/r")));
         status = SD_API_STATUS_UNSUCCESSFUL;
         goto INIT_ERROR;
     }

 INIT_ERROR:

     if(!SD_API_SUCCESS(status))
     {
         Deinitialize();
     }

     DEBUGMSG (SDCARD_ZONE_INIT,(TEXT("SDHCDInitialize ends")));
     return status;
 }

5.Deinitialize
Deinitialize用来关闭Initialize创建的事件IST线程,释放DMA buffer,关闭SDI power等

 SD_API_STATUS CSDIOControllerBase::Deinitialize()
 {
     DEBUGMSG (SDCARD_ZONE_INIT,(TEXT("SDHCDDeinitialize starts")));
     //----- 1. Set the controller state to "shutdown" -----
     m_bDriverShutdown = TRUE;

     //----- 2. Disable and cleanup the ISTs/events ------
     InterruptDisable (m_dwSDIOSysIntr);
     SetEvent(m_hResponseReceivedEvent);
     InterruptDisable (m_dwDMASysIntr);

     if(NULL != m_hResponseReceivedEvent)
     {
         CloseHandle(m_hResponseReceivedEvent);
         m_hResponseReceivedEvent = NULL;
     }

     if(NULL != m_hSDIOInterruptThread)
     {
         WaitForSingleObject(m_hSDIOInterruptThread, INFINITE);
         CloseHandle(m_hSDIOInterruptThread);
         m_hSDIOInterruptThread = NULL;
     }

     if(NULL != m_hSDIOInterruptEvent)
     {
         CloseHandle(m_hSDIOInterruptEvent);
         m_hSDIOInterruptEvent = NULL;
     }

     if(NULL != m_hDMAInterruptThread)
     {
         WaitForSingleObject(m_hDMAInterruptThread, INFINITE);
         CloseHandle(m_hDMAInterruptThread);
         m_hDMAInterruptThread = NULL;
     }

     if(NULL != m_hDMAInterruptEvent)
     {
         CloseHandle(m_hDMAInterruptEvent);
         m_hDMAInterruptEvent = NULL;
     }

     if(NULL != m_hCardInsertInterruptThread)
     {
         WaitForSingleObject(m_hCardInsertInterruptThread, INFINITE);
         CloseHandle(m_hCardInsertInterruptThread);
         m_hCardInsertInterruptThread = NULL;
     }

     if(NULL != m_hCardInsertInterruptEvent)
     {
         CloseHandle(m_hCardInsertInterruptEvent);
         m_hCardInsertInterruptEvent = NULL;
     }

     if( m_dwDMAChannel != 0xffffffff )
     {
         //----- 3. Free the DMA memory -----
         HalFreeCommonBuffer( NULL, 0, m_pDMABufferPhys, m_pDMABuffer, FALSE );
     }

     //----- 4. Close the handle to the utility driver (used for fast driver-->driver calling -----
     MMC_Hardware_PowerDown();

     DeleteCriticalSection(&m_ControllerCriticalSection);

     DEBUGMSG (SDCARD_ZONE_INIT,(TEXT("SDHCDDeinitialize ends")));
     return SD_API_STATUS_SUCCESS;
 }

6.CancelIoHandler
CancelIoHandler被SDHCDCancelIoHandler调用.首先调用Stop_SDI_Hardware设置SDIDCON强制停止数据传输.调用SDHCDReleaseHCLock释放lock,最后调用SDHCDIndicateBusRequestComplete使用Cancel状态(SD_API_STATUS_CANCELED)来完成Bus请求.

 BOOLEAN CSDIOControllerBase::CancelIoHandler(DWORD dwSlot, PSD_BUS_REQUEST pRequest)
 {
     DEBUGMSG (SDCARD_ZONE_FUNC,(TEXT("SDHCDCancelIoHandler starts")));

     //--- Stop hardware, cancel the request!
     Stop_SDI_Hardware();

     // release the lock before we complete the request
     SDHCDReleaseHCLock(m_pHCContext);

     // complete the request with a cancelled status
     SDHCDIndicateBusRequestComplete(m_pHCContext, pRequest,SD_API_STATUS_CANCELED);

     DEBUGMSG (SDCARD_ZONE_FUNC,(TEXT("SDHCDCancelIoHandler ends")));
     return TRUE;
 }

7.SlotOptionHandler
CancelIoHandler被SDHCDSlotOptionHandler调用.Slot选项变化时该函数被调用.
(1)SDHCDSetSlotPower:设置slot power,因为系统一直工作在3.3V,不会变化,这里不做任何处理.
(2)SDHCDSetSlotInterface:设置slot接口模式,根据输入数据(pData)设置4bit还是1bit bus模式,调用SetClockRate设置SDI时钟频率.
(3)SDHCDEnableSDIOInterrupts:调用Enable_SDIO_Interrupts使能SDIO中断.
(4)SDHCDDisableSDIOInterrupts:调用Disable_SDIO_Interrupts禁止SDIO中断.
(5)SDHCDAckSDIOInterrupt:调用Ack_SDIO_Interrupts和InterruptDone(m_dwSDIOSysIntr)确认SDIO中断完成.
(6)SDHCDGetWriteProtectStatus:调用IsCardWriteProtected获得写保护状态.
(7)SDHCDQueryBlockCapability:查询Block性能参数.通过输入参数pData来获得ReadBlockSize,WriteBlockSize并根据设定的最大最小值进行修正.
(8)SDHCDGetSlotInfo:获得特定slot的信息.调用SDHCDSetSlotCapabilities等函数设置slot参数,如电压,时钟频率,上电延时等.

 SD_API_STATUS CSDIOControllerBase::SlotOptionHandler(DWORD dwSlot, SD_SLOT_OPTION_CODE Option,
                                      PVOID pData, ULONG OptionSize)
 {
     DEBUGMSG (SDCARD_ZONE_FUNC,(TEXT("SDHCDSlotOptionHandler starts")));

     SD_API_STATUS status = SD_API_STATUS_SUCCESS;   // status
     PSD_HOST_BLOCK_CAPABILITY pBlockCaps;           // block capabilities

     switch(Option)
     {
         case SDHCDSetSlotPower:
             DEBUGMSG (SDCARD_ZONE_INFO,(TEXT("SDHCDSlotOptionHandler option=SDHCDSetSlotPower")));
             // Nothing to do because this system only operates at the reported 3.3V
             break;

         case SDHCDSetSlotInterface:
             DEBUGMSG (SDCARD_ZONE_INFO,(TEXT("SDHCDSlotOptionHandler option=SDHCDSetSlotInterface")));
             // First set the bus width
             if(((PSD_CARD_INTERFACE)pData)->InterfaceMode == SD_INTERFACE_SD_4BIT)
             {
                 Set_SDI_Bus_Width_4Bit();
             }else
             {
                 // Standard (i.e. 1bit) bus width
                 Set_SDI_Bus_Width_1Bit();
             }

             // Next, set the clock rate
             ((PSD_CARD_INTERFACE)pData)->ClockRate = SetClockRate(((PSD_CARD_INTERFACE)pData)->ClockRate);
             break;

         case SDHCDEnableSDIOInterrupts:
             DEBUGMSG (SDCARD_ZONE_INFO,(TEXT("SDHCDSlotOptionHandler option=SDHCDEnableSDIOInterrupts")));
             Enable_SDIO_Interrupts();
             break;

         case SDHCDDisableSDIOInterrupts:
             DEBUGMSG (SDCARD_ZONE_INFO,(TEXT("SDHCDSlotOptionHandler option=SDHCDDisableSDIOInterrupts")));
             Disable_SDIO_Interrupts();
             break;

         case SDHCDAckSDIOInterrupt:

             DEBUGMSG (SDCARD_ZONE_INFO,(TEXT("SDHCDSlotOptionHandler option=SDHCDAckSDIOInterrupt")));
             //----- 2. Clear the SDIO interrupt pending bit -----
             Ack_SDIO_Interrupts();
             InterruptDone(m_dwSDIOSysIntr);
             break;

         case SDHCDGetWriteProtectStatus:
             DEBUGMSG (SDCARD_ZONE_INFO,(TEXT("SDHCDSlotOptionHandler option=SDHCDGetWriteProtectStatus")));
             ((PSD_CARD_INTERFACE)pData)->WriteProtected = IsCardWriteProtected();
             break;

         case SDHCDQueryBlockCapability:

             DEBUGMSG (SDCARD_ZONE_INFO,(TEXT("SDHCDSlotOptionHandler option=SDHCDQueryBlockCapability")));
             pBlockCaps = (PSD_HOST_BLOCK_CAPABILITY)pData;

             DEBUGMSG(SDCARD_ZONE_INFO, (TEXT("SDHCD:SDHCDSlotOptionHandler() - Read Block Length: %d , Read Blocks: %d/n"),
                                                 pBlockCaps->ReadBlockSize, pBlockCaps->ReadBlocks));

             DEBUGMSG(SDCARD_ZONE_INFO, (TEXT("SDHCD:SDHCDSlotOptionHandler() - Write Block Length: %d , Write Blocks: %d/n"),
                                                 pBlockCaps->WriteBlockSize, pBlockCaps->WriteBlocks));

             pBlockCaps = (PSD_HOST_BLOCK_CAPABILITY)pData;

             //----- Validate block transfer properties -----
             if (pBlockCaps->ReadBlockSize < MINIMUM_BLOCK_TRANSFER_SIZE )
             {
                 pBlockCaps->ReadBlockSize = MINIMUM_BLOCK_TRANSFER_SIZE;
             }

             if (pBlockCaps->WriteBlockSize < MINIMUM_BLOCK_TRANSFER_SIZE )
             {
                 pBlockCaps->WriteBlockSize = MINIMUM_BLOCK_TRANSFER_SIZE;
             }

             if (pBlockCaps->ReadBlockSize > MAXIMUM_BLOCK_TRANSFER_SIZE )
             {
                 pBlockCaps->ReadBlockSize = MAXIMUM_BLOCK_TRANSFER_SIZE;
             }

             if (pBlockCaps->WriteBlockSize > MAXIMUM_BLOCK_TRANSFER_SIZE )
             {
                 pBlockCaps->WriteBlockSize = MAXIMUM_BLOCK_TRANSFER_SIZE;
             }
             break;

         case SDHCDGetSlotInfo:
             DEBUGMSG (SDCARD_ZONE_INFO,(TEXT("SDHCDSlotOptionHandler option=SDHCDGetSlotInfo")));
             if( OptionSize != sizeof(SDCARD_HC_SLOT_INFO) || pData == NULL )
             {
                 status = SD_API_STATUS_INVALID_PARAMETER;
             }
             else
             {
                 PSDCARD_HC_SLOT_INFO pSlotInfo = (PSDCARD_HC_SLOT_INFO)pData;

                 // set the slot capabilities
                 SDHCDSetSlotCapabilities(pSlotInfo, SD_SLOT_SD_4BIT_CAPABLE |
                     SD_SLOT_SD_1BIT_CAPABLE |
                     SD_SLOT_SDIO_CAPABLE    |
                     SD_SLOT_SDIO_INT_DETECT_4BIT_MULTI_BLOCK);

                 SDHCDSetVoltageWindowMask(pSlotInfo, (SD_VDD_WINDOW_3_2_TO_3_3 | SD_VDD_WINDOW_3_3_TO_3_4));

                 // Set optimal voltage
                 SDHCDSetDesiredSlotVoltage(pSlotInfo, SD_VDD_WINDOW_3_2_TO_3_3);

                 SDHCDSetMaxClockRate(pSlotInfo, MAX_SDI_BUS_TRANSFER_SPEED);

                 // Set power up delay. We handle this in SetVoltage().
                 SDHCDSetPowerUpDelay(pSlotInfo, 300);
             }
             break;

         default:
             DEBUGMSG (SDCARD_ZONE_WARN,(TEXT("SDHCDSlotOptionHandler option=SD_API_STATUS_INVALID_PARAMETER")));
            status = SD_API_STATUS_INVALID_PARAMETER;

     }
     DEBUGMSG (SDCARD_ZONE_FUNC,(TEXT("SDHCDSlotOptionHandler ends")));
     return status;
 }

8.BusRequestHandler
BusRequestHandler被SDHCDBusRequestHandler调用,用来处理总线请求.
首先复位FIFO和状态寄存器,然后使能SDI CLOCK,计算要传输数据大小,判断是否DMA传输以及是否4字节对齐,4字节整数倍来进行DMA传输(SetupDmaXfer)或者轮询IO传输(SetupPollingXfer).
接着判断传输的是单独命令还是命令和数据,第一次传输命令时需延时80个clock周期.SendCommand最后一个参数表示是传输命令(FALSE)还是命令和数据(TRUE).
最后设置设置事件m_hResponseReceivedEvent来通知传输IST命令应答发生.

 SD_API_STATUS CSDIOControllerBase::BusRequestHandler(DWORD dwSlot, PSD_BUS_REQUEST pRequest)
 {
     DEBUGMSG (SDCARD_ZONE_FUNC,(TEXT("BusRequestHandler starts (CMD:%d)"), pRequest->CommandCode));
     SD_API_STATUS   status;

     // Reset FIFO and status registers
     vm_pSDIReg->SDICON |= RESET_FIFO;
     vm_pSDIReg->SDIDSTA = 0xffff;
     vm_pSDIReg->SDIDCON = 0;
     vm_pSDIReg->SDICSTA = 0xffff;
     vm_pSDIReg->SDICCON = 0;

    Start_SDI_Clock();

     //----- 1. Determine the type of command (data vs. no data) and send the command -----
     m_dwNumBytesToTransfer  = pRequest->BlockSize * pRequest->NumBlocks;

     //----- 2 Can we schedule a DMA operation using the caller's buffer as-is?  -----
     //
     //        There are two situations that we need to account for:
     //
     //             1) A non-DWORD aligned buffer
     //             2) A buffer whose "transfer size" isn't a multiple of sizeof(DWORD)
     //
     //        For the first case, an data-alignment exception will occur if the buffer is
     //        addressed at the non-DWORD aligned address.  For the second case, the SDI
     //        controller will pad zeros into the remaining bytes of the last unfilled DWORD.
     //        Practically, this means that the SD Card will get a corrupted data string.
     //
     //        To handle these two situations, we can simply use our polling I/O routines to
     //        fulfill the I/O request.
     //
     if( ( m_dwDMAChannel == 0xffffffff ) || (!IS_BUFFER_DWORD_ALIGNED(pRequest->pBlockBuffer)) || (!IS_BUFFER_SIZE_A_DWORD_MULTPLE(pRequest->BlockSize)) || m_dwNumBytesToTransfer > MAXIMUM_DMA_TRANSFER_SIZE )
     {
         m_bUseDMAForTransfer = FALSE;
         SetupPollingXfer(pRequest);                     // Use polling I/O routines for data transfer
     }else{
         m_bUseDMAForTransfer = TRUE;
         SetupDmaXfer(pRequest);                         // Use DMA for data transfer
     }

     if(pRequest->TransferClass == SD_COMMAND)
     {
         // Command only
         status = SendCommand(pRequest->CommandCode, pRequest->CommandArgument, pRequest->CommandResponse.ResponseType, FALSE);

         if(!SD_API_SUCCESS(status))
         {
             DEBUGMSG(SDCARD_ZONE_ERROR, (TEXT("SDHCD:SDHCDBusRequestHandler() - Error sending command:0x%02x/r/n"), pRequest->CommandCode));
             goto BUS_REQUEST_COMPLETE;
         }

         //----- 2. Is this the first command sent to the card?  If so, delay the 74 (or 80) clock cycles per the SD spec -----
         if(m_bSendInitClocks)
         {
             m_bSendInitClocks = FALSE;
             Wait_80_SDI_Clock_Cycles();
         }
     }
     else
     {
         // Command with data transfer
         status = SendCommand(pRequest->CommandCode, pRequest->CommandArgument, pRequest->CommandResponse.ResponseType, TRUE);

         if(!SD_API_SUCCESS(status))
         {
             DEBUGMSG(SDCARD_ZONE_ERROR, (TEXT("SDHCD:SDHCDBusRequestHandler() - Error sending command:0x%02x/r/n"), pRequest->CommandCode));
             goto BUS_REQUEST_COMPLETE;
         }
     }

     //----- 3. Signal an IST that processes response information and cache our state -----
     //         NOTE: It is critical that this API NOT complete the bus request directly (which
     //               is why another thread is used).  The bus driver expects bus requests to complete
     //               asynchronously and a stack overflow WILL eventually occur if this rule isn't honored.
     SetEvent(m_hResponseReceivedEvent);
     m_CurrentState = CommandSent;
     status = SD_API_STATUS_PENDING;

 BUS_REQUEST_COMPLETE:
     DEBUGMSG (SDCARD_ZONE_FUNC,(TEXT("SDHCD:BusRequestHandler ends")));
     return status;
 }

9.TransferIstThread
TransferIstThread被SD_TransferIstThread调用,而SD_TransferIstThread在Initialize中被创建,对应于m_hDMAInterruptThread句柄.这个IST线程用来处理SDIO的DMA通道通信.
首先设置该线程的优先级(从注册表中获得,"DMA_IST_Priority"=dword:96),然后等待m_hResponseReceivedEvent事件的发生,该事件发生后继续运行,否则挂起.
m_hResponseReceivedEvent触发后,如果controller down则线程退出.调用SDHCDGetAndLockCurrentRequest(实现在sdhclib)来获取当前slot的请求,并锁住禁止取消.
然后处理一个特殊情况,SD_CMD_STOP_TRANSMISSION命令在SD_CMD_WRITE_MULTIPLE_BLOCK后发送,需要进行BUSY_CHECK.
如果BusyCheck为true,CommandCode为SD_CMD_ERASE或者CommandCode为SD_CMD_STOP_TRANSMISSION,m_dwLastTypeOfTransfer为SD_WRITE时,需要等待IO传输结束.检查SDIDSTA寄存器BusyFin位,如果为0(busy not finish),则进行等待,并判断超时,IsCardPresent,以及一些错误状态,如果任何一种情况发生,就设置BUSY_CHECKS_FINISH,跳转到TRANSFER_DONE通知BusRequest完成.
如果BUSY_CHECKS_FINISH成立,则准备DMA传输.如果ResponseType为NoResponse,跳转到TRANSFER_DONE.否则调用GetCommandResponse获取CommandResponse状态.如果是命令,直接TRANSFER_DONE.数据传输分两种情况是否使用DMA,m_bUseDMAForTransfer为false,启动IO传输,为true,并判断是SD_WRITE写操作时,复制数据到DMA memory,调用Enable_SDIO_DMA_Channel,启动DMA通道,然后等待DMA完成中断事件m_hDMAInterruptEvent,完成后调用InterruptDone和Stop_SDIO_DMA_Channel通知中断完成并停止DMA通道.然后等待读取SDIDSTA等待data transfer结束.如果是SD_READ,读取从DMA memory放到调用缓存区pBlockBuffer中.
最后停止SDI clock,通知总线请求结束(SDHCDIndicateBusRequestComplete).

 DWORD CSDIOControllerBase::TransferIstThread()
 {
     PSD_BUS_REQUEST     pRequest = NULL;       // the request to complete
     SD_API_STATUS       status;

     if( m_DMAIstThreadPriority != 0xffffffff && !CeSetThreadPriority( GetCurrentThread(), m_DMAIstThreadPriority ) )
     {
         DEBUGMSG(SDCARD_ZONE_WARN,(TEXT("SDHCDriver:TransferIstThread(): warning, failed to set CEThreadPriority /n")));
     }

     for(;;)
     {
         //----- 1. Wait for the command response -----
         status = SD_API_STATUS_PENDING;
         if(WaitForSingleObject(m_hResponseReceivedEvent, INFINITE) == WAIT_FAILED)
         {
             DEBUGMSG(SDCARD_ZONE_ERROR, (TEXT("SDHCDriver:TransferIstThread(): Wait Failed!/n")));
             return FALSE;
         }

         if(m_bDriverShutdown)
         {
             DEBUGMSG(SDCARD_ZONE_WARN, (TEXT("SDHCD:TransferIstThread(): Thread Exiting/n")));
             return FALSE;
         }

         //----- 2. Get and lock the current bus request -----
         if(pRequest == NULL)
         {
             if((pRequest = SDHCDGetAndLockCurrentRequest(m_pHCContext, 0)) == NULL)
             {
                 DEBUGMSG(SDCARD_ZONE_ERROR, (TEXT("SDHCD:SDHControllerIstThread() - Unable to get/lock current request!/r/n")));
                 status = SD_API_STATUS_INVALID_DEVICE_REQUEST;
                 goto TRANSFER_DONE;
             }
         }

         //----- 3. SPECIAL CASE: The SD_CMD_STOP_TRANSMISSION that is sent after a SD_CMD_WRITE_MULTIPLE_BLOCK command -----
         //                       requires a BUSY_CHECK
         if( ( m_fHandleBusyCheckOnCommand38 && pRequest->CommandCode == SD_CMD_ERASE ) ||
             ( ( pRequest->CommandCode == SD_CMD_STOP_TRANSMISSION ) && ( m_dwLastTypeOfTransfer == SD_WRITE ) ) )
         {
             DWORD dwWaitCount = 0;
             //----- 4. Wait until the I/O transfer is complete -----
             while(!(vm_pSDIReg->SDIDSTA & BUSY_CHECKS_FINISH))
             {
                 dwWaitCount++;
                 if( dwWaitCount > WAIT_TIME )
                 {
                     DEBUGMSG(SDCARD_ZONE_ERROR, (TEXT("SDHCD:SDHControllerIstThread() - timeout waiting for BUSY_CHECKS to finish!/r/n")));
                     status = SD_API_STATUS_DATA_TIMEOUT;
                     goto TRANSFER_DONE;
                 }

                 if( !IsCardPresent() )
                 {
                     DEBUGMSG(SDCARD_ZONE_ERROR, (TEXT("SDHCD:SDHControllerIstThread() - Card ejected!/r/n")));
                     status = SD_API_STATUS_DEVICE_REMOVED;
                     goto TRANSFER_DONE;
                 }
                 if((vm_pSDIReg->SDIDSTA & FIFO_FAIL_ERROR))
                 {
                     vm_pSDIReg->SDIDSTA = BUSY_CHECKS_FINISH | FIFO_FAIL_ERROR;
                     DEBUGMSG(SDCARD_ZONE_ERROR, (TEXT("SDHCD:SDHControllerIstThread() - FIFO Error waiting for BUSY_CHECKS to finish!/r/n")));
                     status = SD_API_STATUS_DATA_ERROR;
                     goto TRANSFER_DONE;
                 }
                 if((vm_pSDIReg->SDIDSTA & DATA_TRANSMIT_CRC_ERROR))
                 {
                     vm_pSDIReg->SDIDSTA = BUSY_CHECKS_FINISH | DATA_TRANSMIT_CRC_ERROR;
                     DEBUGMSG(SDCARD_ZONE_ERROR, (TEXT("SDHCD:SDHControllerIstThread() - Transmit CRC Error waiting for BUSY_CHECKS to finish!/r/n")));
                     status = SD_API_STATUS_DATA_ERROR;
                     goto TRANSFER_DONE;
                 }
                 if((vm_pSDIReg->SDIDSTA & DATA_RECEIVE_CRC_ERROR))
                 {
                     vm_pSDIReg->SDIDSTA = BUSY_CHECKS_FINISH | DATA_RECEIVE_CRC_ERROR;
                     DEBUGMSG(SDCARD_ZONE_ERROR, (TEXT("SDHCD:SDHControllerIstThread() - Receive CRC Error waiting for BUSY_CHECKS to finish!/r/n")));
                     status = SD_API_STATUS_DATA_ERROR;
                     goto TRANSFER_DONE;
                 }
                 if((vm_pSDIReg->SDIDSTA & DATA_TIME_OUT))
                 {
                     vm_pSDIReg->SDIDSTA = BUSY_CHECKS_FINISH | DATA_TIME_OUT;
                     DEBUGMSG(SDCARD_ZONE_ERROR, (TEXT("SDHCD:SDHControllerIstThread() - Data timeout waiting for BUSY_CHECKS to finish!/r/n")));
                     status = SD_API_STATUS_DATA_TIMEOUT;
                     goto TRANSFER_DONE;
                 }
             }
             vm_pSDIReg->SDIDSTA = BUSY_CHECKS_FINISH;
         }

         //----- 5. Get the response information -----
         if(pRequest->CommandResponse.ResponseType == NoResponse)
         {
             goto TRANSFER_DONE;
         }else{
             status = GetCommandResponse(pRequest);

             if(!SD_API_SUCCESS(status))
             {
                 DEBUGMSG(SDCARD_ZONE_ERROR, (TEXT("SDHCD:SDHCDBusRequestHandler() - Error getting response for command:0x%02x/r/n"), pRequest->CommandCode));
                 goto TRANSFER_DONE;
             }
         }

         //----- 6. If this is a data transfer, start the I/O operation; otherwise, finish the request -----
         if(pRequest->TransferClass == SD_COMMAND)
         {
             goto TRANSFER_DONE;
         }


         //----- 7. If this is a DMA transfer, we enable interrupts and wait for the DMA interrupt.  Otherwise, -----
         //         we use our polling routines to complete the I/O.
         if(m_bUseDMAForTransfer == FALSE)
         {

             //----- 8. Polling I/O, use our special routines to handle this request
             switch(pRequest->TransferClass)
             {
             case SD_READ:
                 if(!PollingReceive(pRequest, m_dwNumBytesToTransfer))
                 {
                     DEBUGMSG(SDCARD_ZONE_ERROR, (TEXT("SDHCD:BusRequestHandler() - PollingReceive() failed/r/n")));
                     goto TRANSFER_DONE;
                 }
                 break;

             case SD_WRITE:
                 if(!PollingTransmit(pRequest, m_dwNumBytesToTransfer))
                 {
                     DEBUGMSG(SDCARD_ZONE_ERROR, (TEXT("SDHCD:BusRequestHandler() - PollingReceive() failed/r/n")));
                     goto TRANSFER_DONE;
                 }
                 break;
             }

             status = SD_API_STATUS_SUCCESS;
         }else
         {


             //----- 9. For WRITE requests, be sure to copy the write data from the caller's buffer into DMA memory-----
             if(pRequest->TransferClass == SD_WRITE)
             {
                 BOOL fNoException;
                 DEBUGCHK(m_dwNumBytesToTransfer <= MAXIMUM_DMA_TRANSFER_SIZE);

                 SD_SET_PROC_PERMISSIONS_FROM_REQUEST( pRequest ) {
                     fNoException = SDPerformSafeCopy( m_pDMABuffer, pRequest->pBlockBuffer, m_dwNumBytesToTransfer );
                 } SD_RESTORE_PROC_PERMISSIONS();

                 if (fNoException == FALSE) {
                     status = SD_API_STATUS_ACCESS_VIOLATION;
                     goto TRANSFER_DONE;
                 }
             }

             //----- 10. DMA I/O, enable the DMA channel -----
             Enable_SDIO_DMA_Channel();

             //----- 11. Wait for a DMA interrupt -----
             // first estimate the maximum DMA transfer time
             DWORD dwDelay = m_dwNumBytesToTransfer * m_dwDMATransferTimeoutFactor / ( m_dwClockRate / 2000 );
             if( Get_SDI_Bus_Width() != WIDE_BUS_ENABLE )
             {
                 dwDelay *= 4;
             }
             dwDelay += m_dwDMATransferTimeoutConstant;

             // now wait for the interrupt
             if(WaitForSingleObject(m_hDMAInterruptEvent, dwDelay) != WAIT_OBJECT_0)
             {
                 DEBUGMSG(SDCARD_ZONE_WARN, (TEXT("TransferIstThread(): Wait Failed!/n")));
                 Stop_SDIO_DMA_Channel();
                 status = SD_API_STATUS_DATA_TIMEOUT;
                 goto TRANSFER_DONE;
             }

             if(m_bDriverShutdown)
             {
                 DEBUGMSG(SDCARD_ZONE_WARN, (TEXT("SDHCD:TransferIstThread(): Thread Exiting/n")));
                 return FALSE;
             }

             //----- 12. ACK the DMA completion interrupt and stop the DMA channel -----
             InterruptDone(m_dwDMASysIntr);
             Stop_SDIO_DMA_Channel();

             DWORD dwWaitCount = 0;
             //----- 13. Wait until the I/O transfer is complete -----
             while(!(vm_pSDIReg->SDIDSTA & DATA_TRANSMIT_FINISHED))
             {
                 dwWaitCount++;
                 if( dwWaitCount > WAIT_TIME )
                 {
                     DEBUGMSG(SDCARD_ZONE_ERROR, (TEXT("SDHCD:SDHControllerIstThread() - timeout waiting for DMA transfer completion!/r/n")));
                     status = SD_API_STATUS_DATA_TIMEOUT;
                     goto TRANSFER_DONE;
                 }

                 if( !IsCardPresent() )
                 {
                     DEBUGMSG(SDCARD_ZONE_ERROR, (TEXT("SDHCD:SDHControllerIstThread() - Card ejected!/r/n")));
                     status = SD_API_STATUS_DEVICE_REMOVED;
                     goto TRANSFER_DONE;
                 }
                 if((vm_pSDIReg->SDIDSTA & FIFO_FAIL_ERROR))
                 {
                     vm_pSDIReg->SDIDSTA = BUSY_CHECKS_FINISH | FIFO_FAIL_ERROR;
                     DEBUGMSG(SDCARD_ZONE_ERROR, (TEXT("SDHCD:SDHControllerIstThread() - FIFO Error waiting for DMA transfer completion!/r/n")));
                     status = SD_API_STATUS_DATA_ERROR;
                     goto TRANSFER_DONE;
                 }
                 if((vm_pSDIReg->SDIDSTA & DATA_TRANSMIT_CRC_ERROR))
                 {
                     vm_pSDIReg->SDIDSTA = BUSY_CHECKS_FINISH | DATA_TRANSMIT_CRC_ERROR;
                     DEBUGMSG(SDCARD_ZONE_ERROR, (TEXT("SDHCD:SDHControllerIstThread() - Transmit CRC Error waiting for DMA transfer completion!/r/n")));
                     status = SD_API_STATUS_DATA_ERROR;
                     goto TRANSFER_DONE;
                 }
                 if((vm_pSDIReg->SDIDSTA & DATA_RECEIVE_CRC_ERROR))
                 {
                     vm_pSDIReg->SDIDSTA = BUSY_CHECKS_FINISH | DATA_RECEIVE_CRC_ERROR;
                     DEBUGMSG(SDCARD_ZONE_ERROR, (TEXT("SDHCD:SDHControllerIstThread() - Receive CRC Error waiting for DMA transfer completion!/r/n")));
                     status = SD_API_STATUS_DATA_ERROR;
                     goto TRANSFER_DONE;
                 }
                 if((vm_pSDIReg->SDIDSTA & DATA_TIME_OUT))
                 {
                     vm_pSDIReg->SDIDSTA = BUSY_CHECKS_FINISH | DATA_TIME_OUT;
                     DEBUGMSG(SDCARD_ZONE_ERROR, (TEXT("SDHCD:SDHControllerIstThread() - Data timeout waiting for DMA transfer completion!/r/n")));
                     status = SD_API_STATUS_DATA_TIMEOUT;
                     goto TRANSFER_DONE;
                 }
             }

             vm_pSDIReg->SDIDSTA = DATA_TRANSMIT_FINISHED;

             //----- 14. For READ requests, be sure to copy the data read from the DMA memory into the caller's buffer -----
             if(pRequest->TransferClass == SD_READ)
             {
                 BOOL fNoException;
                 DEBUGCHK(m_dwNumBytesToTransfer <= MAXIMUM_DMA_TRANSFER_SIZE);

                 SD_SET_PROC_PERMISSIONS_FROM_REQUEST( pRequest ) {
                     fNoException = SDPerformSafeCopy( pRequest->pBlockBuffer, m_pDMABuffer, m_dwNumBytesToTransfer );
                 } SD_RESTORE_PROC_PERMISSIONS();

                 if (fNoException == FALSE) {
                     status = SD_API_STATUS_ACCESS_VIOLATION;
                     goto TRANSFER_DONE;
                 }
             }

             //----- 15. I/O is complete.  Finish the bus request! -----
             status = SD_API_STATUS_SUCCESS;
         }

 TRANSFER_DONE:
         if( !( Is_SDIO_Interrupt_Enabled() && ( Get_SDI_Bus_Width() == WIDE_BUS_ENABLE ) ) )
         {
             Stop_SDI_Clock();
         }
         m_CurrentState = CommandComplete;
         SDHCDIndicateBusRequestComplete(m_pHCContext, pRequest, status);
         pRequest = NULL;
     }

     return TRUE;
 }

10.IOInterruptIstThread
被SD_IOInterruptIstThread调用,对应于句柄m_hSDIOInterruptThread.同样首先设置线程优先级(从注册表中获取"SDIO_IST_Priority"=dword:97),然后等待m_hSDIOInterruptEvent事件发生,如果事件发生同时卡存在的话,调用SDHCDIndicateSlotStateChange通知总线驱动SD卡中断发生.

 DWORD CSDIOControllerBase::IOInterruptIstThread()
 {

     if( m_nSDIOIstThreadPriority != 0xffffffff && !CeSetThreadPriority( GetCurrentThread(), m_nSDIOIstThreadPriority ) )
     {
         DEBUGMSG(SDCARD_ZONE_WARN,(TEXT("SDHCDriver:SDIOInterruptIstThread(): warning, failed to set CEThreadPriority /n")));
     }

     for(;;)
     {
         //----- 1. Wait for a SDIO interrupt -----
         if(WaitForSingleObject(m_hSDIOInterruptEvent, INFINITE) != WAIT_OBJECT_0)
         {
             DEBUGMSG(SDCARD_ZONE_WARN, (TEXT("SDHCD:SDIOInterruptIstThread(): Wait Failed!/n")));
             return FALSE;
         }

         if(m_bDriverShutdown)
         {
             DEBUGMSG(SDCARD_ZONE_WARN, (TEXT("SDHCD:SDIOInterruptIstThread(): Thread Exiting/n")));
             return FALSE;
         }

         if(m_bDevicePresent && IsCardPresent())
         {
             // indicate that the card is interrupting
             SDHCDIndicateSlotStateChange(m_pHCContext, 0, DeviceInterrupting);
         }

         // NOTE: SDHCDIndicateSlotStateChange() is called above to inform the bus driver
         //       that the SDIO card has generated an interrupt.  After this notification, the
         //       bus driver will eventually call back SDHCDSlotOptionHandler() to enable/disable
         //       and ACK the SDIO interrupt as necessary.  Consequently, we DO NOT acknowledge
         //       the interrupt here...

     }
 }

11.CardDetectThread
被SD_CardDetectThread调用.首先设置线程优先级(从注册表中获取"CardDetect_Thread_Priority"=dword:98"),然后等待m_hCardInsertInterruptEvent事件,调用IsCardPresent监测卡是否插入.如果卡拔出,调用SDHCDIndicateSlotStateChange通知DeviceEjected,否则卡插入,进行SDI寄存器初始化,设置clock rate(100KHz),启动SDI clock,调用SDHCDIndicateSlotStateChange通知DeviceInserted.

 DWORD CSDIOControllerBase::CardDetectThread()
 {
     BOOL  bSlotStateChanged = FALSE;
     DWORD dwWaitResult  = WAIT_TIMEOUT;

     if( m_nCardDetectIstThreadPriority != 0xffffffff && !CeSetThreadPriority( GetCurrentThread(), m_nCardDetectIstThreadPriority ) )
     {
         DEBUGMSG(SDCARD_ZONE_WARN, (TEXT("SDHCDriver:CardDetectThread(): warning, failed to set CEThreadPriority /n")));
     }

     for(;;)
     {
         //----- 1. Wait for the next insertion/removal interrupt -----
         dwWaitResult = WaitForSingleObject(m_hCardInsertInterruptEvent, m_dwPollingTimeout);

         if(m_bDriverShutdown)
         {
             DEBUGMSG(SDCARD_ZONE_WARN, (TEXT("SDHCardDetectIstThread: Thread Exiting/n")));
             return FALSE;
         }

         // Test if a card is present
         if( IsCardPresent() == m_bDevicePresent )
         {
             bSlotStateChanged = FALSE;
         }
         else
         {
             bSlotStateChanged = TRUE;
         }

         if( bSlotStateChanged || m_bReinsertTheCard )
         {
             m_bReinsertTheCard = FALSE;

             // If a card is inserted, unload the driver...
             if(m_bDevicePresent == TRUE)
             {
                 m_fCardInTheSlot = FALSE;
                 // indicate the slot change
                 SDHCDIndicateSlotStateChange(m_pHCContext, 0, DeviceEjected);
                 m_bDevicePresent = FALSE;

                 Stop_SDI_Clock();
             }

             if(IsCardPresent())
             {
                 m_fCardInTheSlot = TRUE;
                 m_bDevicePresent = TRUE;

                 //----- 5. Reset the clock to the ID rate -----
                 vm_pSDIReg->SDICON     |= LITTLE_ENDIAN_BYTE_ORDER;    // Windows CE is always Little Endian.
                 vm_pSDIReg->SDICON     |= RESET_FIFO;                  // Reset the FIFO
                 vm_pSDIReg->SDIBSIZE    = BYTES_PER_SECTOR;
                 vm_pSDIReg->SDIDTIMER   = MAX_DATABUSY_TIMEOUT;        // Data/busy timeout
                 SetClockRate(SD_DEFAULT_CARD_ID_CLOCK_RATE);

                 // give the card enough time for initialization
                 Start_SDI_Clock();
                 Wait_80_SDI_Clock_Cycles();

                 //----- 6. Inform the bus handler that this is the first command sent -----
                 m_bSendInitClocks = TRUE;

                 //----- 7. Indicate the slot change -----
                 SDHCDIndicateSlotStateChange(m_pHCContext, 0, DeviceInserted);
             }
         } // if
     } // for

     return TRUE;
 }

12.SendCommand
在BusRequestHandler中被调用,首先清除SDICSTA状态标志位,设置SDICARG命令参数寄存器.判断命令是否带数据设置SDICCON.根据不同的Response类型SDICCON进行不同设置.NoResponse时,写命令到SDICCON并发送命令,并确定发送完成.Short response时,SDICCON设置WAIT_FOR_RESPONSE.ResponseR2时,SDICCON设置LONG_RESPONSE | WAIT_FOR_RESPONSE.

 SD_API_STATUS CSDIOControllerBase::SendCommand(UINT16 Cmd, UINT32 Arg, UINT16 respType, BOOL bDataTransfer)
 {
     unsigned int uiNewCmdRegVal = 0;
     DWORD dwWaitCount = 0;

     DEBUGMSG (SDHC_SEND_ZONE,(TEXT("SendCommand (0x%08x, 0x%04x, 0x%08x, 0x%04x, 0x%x) starts"),
                 this, Cmd, Arg, respType, bDataTransfer));
     //----- 1. Reset any pending status flags -----
     vm_pSDIReg->SDICSTA = (CRC_CHECK_FAILED | COMMAND_SENT | COMMAND_TIMED_OUT | RESPONSE_RECEIVED);

     //----- 2. Specify the command's argument -----
     vm_pSDIReg->SDICARG = Arg;

     //----- 3. Specify the command's data transfer requirements -----
     if(bDataTransfer == TRUE)
     {
         vm_pSDIReg->SDICCON  |= SDIO_COMMAND_WITH_DATA;
     }else
     {
         vm_pSDIReg->SDICCON  &= ~SDIO_COMMAND_WITH_DATA;
     }

     //----- 4. Send the command to the MMC controller -----
     switch(respType)
     {
     case NoResponse:                // Response is not required, but make sure the command was sent
         DEBUGMSG (SDHC_RESPONSE_ZONE,(TEXT("SendCommand no response required")));
         vm_pSDIReg->SDICCON = START_COMMAND | COMMAND_START_BIT | (Cmd & MAX_CMD_VALUE);

         while(!(vm_pSDIReg->SDICSTA & COMMAND_SENT))
         {
             dwWaitCount++;
             if( dwWaitCount > WAIT_TIME )
             {
                 DEBUGMSG(SDCARD_ZONE_ERROR, (TEXT("SDHCD:SendCommand() - timeout waiting for command completion!/r/n")));
                 return SD_API_STATUS_RESPONSE_TIMEOUT;
             }

             if( !IsCardPresent() )
             {
                 DEBUGMSG(SDCARD_ZONE_ERROR, (TEXT("SDHCD:SendCommand() - Card ejected!/r/n")));
                 return SD_API_STATUS_DEVICE_REMOVED;
             }
             if(vm_pSDIReg->SDICSTA & COMMAND_TIMED_OUT)
             {
                 DEBUGMSG(SDCARD_ZONE_ERROR, (TEXT("SDHCD:SendCommand() - Command 0x%04x timed out!/r/n"), Cmd));
                 vm_pSDIReg->SDICSTA = COMMAND_TIMED_OUT;                // Clear the error
                 return SD_API_STATUS_RESPONSE_TIMEOUT;
             }
         }
         vm_pSDIReg->SDICSTA = COMMAND_SENT;                         // Clear the status
         break;

     case ResponseR1:                // Short response required
     case ResponseR1b:
     case ResponseR3:
     case ResponseR4:
     case ResponseR5:
     case ResponseR6:
         DEBUGMSG (SDHC_RESPONSE_ZONE,(TEXT("sendSDICommand short response required")));
 //      vm_pSDIReg->SDICCON = uiNewCmdRegVal | WAIT_FOR_RESPONSE | START_COMMAND | COMMAND_START_BIT | (Cmd & MAX_CMD_VALUE);
         vm_pSDIReg->SDICCON = WAIT_FOR_RESPONSE | START_COMMAND | COMMAND_START_BIT | (Cmd & MAX_CMD_VALUE);
         break;

     case ResponseR2:                // Long response required
         DEBUGMSG (SDHC_RESPONSE_ZONE,(TEXT("sendSDICommand long response required")));
 //      vm_pSDIReg->SDICCON = uiNewCmdRegVal | LONG_RESPONSE | WAIT_FOR_RESPONSE | START_COMMAND | COMMAND_START_BIT | (Cmd & MAX_CMD_VALUE);
         vm_pSDIReg->SDICCON = LONG_RESPONSE | WAIT_FOR_RESPONSE | START_COMMAND | COMMAND_START_BIT | (Cmd & MAX_CMD_VALUE);
         break;

     default:
         DEBUGMSG(SDCARD_ZONE_ERROR, (TEXT("SDHCD:sendSDICommand() - Invalid response type.  Command not sent!/r/n")));
         return SD_API_STATUS_NOT_IMPLEMENTED;
         break;
     }

     return SD_API_STATUS_SUCCESS;
 }

13.GetCommandResponse
该函数用来获取命令应答,在TransferIstThread被调用.读取SDICSTA直到命令应答接收,如果有错误状态就返回错误.然后根据不同的应答类型分别读取SDIRSP0,SDIRSP1,SDIRSP2,SDIRSP3,具体格式参加代码注释.

 SD_API_STATUS CSDIOControllerBase::GetCommandResponse(PSD_BUS_REQUEST pRequest)
 {
     DEBUGMSG (SDHC_RESPONSE_ZONE,(TEXT("GetCommandResponse started")));
     PUCHAR              respBuff;       // response buffer
     DWORD dwWaitCount = 0;

     //----- 1. Wait for the response information to get arrive at the controller -----
     while(!(vm_pSDIReg->SDICSTA & RESPONSE_RECEIVED))
     {
         dwWaitCount++;
         if( dwWaitCount > WAIT_TIME )
         {
             DEBUGMSG(SDCARD_ZONE_ERROR, (TEXT("SDHCD:GetCommandResponse() - timeout waiting for command response!/r/n")));
             return SD_API_STATUS_RESPONSE_TIMEOUT;
         }

         if( !IsCardPresent() )
         {
             DEBUGMSG(SDCARD_ZONE_ERROR, (TEXT("SDHCD:GetCommandResponse() - Card ejected!/r/n")));
             return SD_API_STATUS_DEVICE_REMOVED;
         }
         if(vm_pSDIReg->SDICSTA & COMMAND_TIMED_OUT)
         {
             vm_pSDIReg->SDICSTA = COMMAND_TIMED_OUT;                // Clear the error
             DEBUGMSG (SDCARD_ZONE_ERROR,(TEXT("GetCommandResponse returned SD_API_STATUS_RESPONSE_TIMEOUT (COMMAND_TIMED_OUT)")));
             return SD_API_STATUS_RESPONSE_TIMEOUT;
         }

         if(vm_pSDIReg->SDIDSTA & CRC_CHECK_FAILED)
         {
             vm_pSDIReg->SDIDSTA = CRC_CHECK_FAILED;             // Clear the error
             DEBUGMSG (SDCARD_ZONE_ERROR,(TEXT("GetCommandResponse returned SD_API_STATUS_CRC_ERROR (CRC_CHECK_FAILED)")));
             return SD_API_STATUS_CRC_ERROR;
         }

         if(vm_pSDIReg->SDIDSTA & DATA_TRANSMIT_CRC_ERROR)
         {
             vm_pSDIReg->SDIDSTA = DATA_TRANSMIT_CRC_ERROR;      // Clear the error
             DEBUGMSG (SDCARD_ZONE_ERROR,(TEXT("getSDICommandResponse returned SD_API_STATUS_CRC_ERROR (DATA_TRANSMIT_CRC_ERROR)")));
             return SD_API_STATUS_CRC_ERROR;
         }

         if(vm_pSDIReg->SDIDSTA & DATA_RECEIVE_CRC_ERROR)
         {
             vm_pSDIReg->SDIDSTA = DATA_RECEIVE_CRC_ERROR;           // Clear the error
             DEBUGMSG (SDCARD_ZONE_ERROR,(TEXT("GetCommandResponse returned SD_API_STATUS_CRC_ERROR (DATA_RECEIVE_CRC_ERROR)")));
             return SD_API_STATUS_CRC_ERROR;
         }

         if(vm_pSDIReg->SDIDSTA & DATA_TIME_OUT)
         {
             vm_pSDIReg->SDIDSTA = DATA_TIME_OUT;                    // Clear the error
             DEBUGMSG (SDCARD_ZONE_ERROR,(TEXT("GetCommandResponse returned SD_API_STATUS_DATA_TIMEOUT (DATA_TIME_OUT)")));
             return SD_API_STATUS_DATA_TIMEOUT;
         }
     }
     vm_pSDIReg->SDICSTA = RESPONSE_RECEIVED;                        // Clear the status


     //----- 2. Copy the response information to our "response buffer" -----
     //         NOTE: All START_BIT and TRANSMISSION_BIT bits ='0'. All END_BIT bits ='0'. All RESERVED bits ='1'
     respBuff = pRequest->CommandResponse.ResponseBuffer;
     switch(pRequest->CommandResponse.ResponseType)
     {
         case NoResponse:
             break;

         case ResponseR1:
         case ResponseR1b:
             //--- SHORT RESPONSE (48 bits total)---
             // Format: { START_BIT(1) | TRANSMISSION_BIT(1) | COMMAND_INDEX(6) | CARD_STATUS(32) | CRC7(7) | END_BIT(1) }
             // NOTE: START_BIT and TRANSMISSION_BIT = 0, END_BIT = 1
             //
             *(respBuff    ) = (BYTE)(START_BIT | TRANSMISSION_BIT | pRequest->CommandCode);
             *(respBuff + 1) = (BYTE)(vm_pSDIReg->SDIRSP0      );
             *(respBuff + 2) = (BYTE)(vm_pSDIReg->SDIRSP0 >> 8 );
             *(respBuff + 3) = (BYTE)(vm_pSDIReg->SDIRSP0 >> 16);
             *(respBuff + 4) = (BYTE)(vm_pSDIReg->SDIRSP0 >> 24);
             *(respBuff + 5) = (BYTE)(END_RESERVED | END_BIT);
             break;

         case ResponseR3:
         case ResponseR4:
             //--- SHORT RESPONSE (48 bits total)---
             // Format: { START_BIT(1) | TRANSMISSION_BIT(1) | RESERVED(6) | CARD_STATUS(32) | RESERVED(7) | END_BIT(1) }
             //
             *(respBuff    ) = (BYTE)(START_BIT | TRANSMISSION_BIT | START_RESERVED);
             *(respBuff + 1) = (BYTE)(vm_pSDIReg->SDIRSP0      );
             *(respBuff + 2) = (BYTE)(vm_pSDIReg->SDIRSP0 >> 8 );
             *(respBuff + 3) = (BYTE)(vm_pSDIReg->SDIRSP0 >> 16);
             *(respBuff + 4) = (BYTE)(vm_pSDIReg->SDIRSP0 >> 24);
             *(respBuff + 5) = (BYTE)(END_RESERVED | END_BIT);
             break;

         case ResponseR5:
         case ResponseR6:
             //--- SHORT RESPONSE (48 bits total)---
             // Format: { START_BIT(1) | TRANSMISSION_BIT(1) | COMMAND_INDEX(6) | RCA(16) | CARD_STATUS(16) | CRC7(7) | END_BIT(1) }
             //
             *(respBuff    ) = (BYTE)(START_BIT | TRANSMISSION_BIT | pRequest->CommandCode);
             *(respBuff + 1) = (BYTE)(vm_pSDIReg->SDIRSP0      );
             *(respBuff + 2) = (BYTE)(vm_pSDIReg->SDIRSP0 >> 8 );
             *(respBuff + 3) = (BYTE)(vm_pSDIReg->SDIRSP0 >> 16);
             *(respBuff + 4) = (BYTE)(vm_pSDIReg->SDIRSP0 >> 24);
             *(respBuff + 5) = (BYTE)(vm_pSDIReg->SDIRSP1 >> 24);
             break;

         case ResponseR2:
             //--- LONG RESPONSE (136 bits total)---
             // Format: { START_BIT(1) | TRANSMISSION_BIT(1) | RESERVED(6) | CARD_STATUS(127) | END_BIT(1) }
             //
             // NOTE: In this implementation, the caller doesn't require the upper 8 bits of reserved data.
             //       Consequently, these bits aren't included and the response info is copied directly into
             //       the beginning of the supplied buffer.
             //
             //*(respBuff    )   = (BYTE)(START_BIT | TRANSMISSION_BIT | START_RESERVED);
             //
             *(respBuff + 0) = (BYTE)(vm_pSDIReg->SDIRSP3      );
             *(respBuff + 1) = (BYTE)(vm_pSDIReg->SDIRSP3 >> 8 );
             *(respBuff + 2) = (BYTE)(vm_pSDIReg->SDIRSP3 >> 16);
             *(respBuff + 3) = (BYTE)(vm_pSDIReg->SDIRSP3 >> 24);

             *(respBuff + 4) = (BYTE)(vm_pSDIReg->SDIRSP2      );
             *(respBuff + 5) = (BYTE)(vm_pSDIReg->SDIRSP2 >> 8 );
             *(respBuff + 6) = (BYTE)(vm_pSDIReg->SDIRSP2 >> 16);
             *(respBuff + 7) = (BYTE)(vm_pSDIReg->SDIRSP2 >> 24);

             *(respBuff + 8) = (BYTE)(vm_pSDIReg->SDIRSP1      );
             *(respBuff + 9) = (BYTE)(vm_pSDIReg->SDIRSP1 >> 8 );
             *(respBuff + 10)= (BYTE)(vm_pSDIReg->SDIRSP1 >> 16);
             *(respBuff + 11)= (BYTE)(vm_pSDIReg->SDIRSP1 >> 24);

             *(respBuff + 12)= (BYTE)(vm_pSDIReg->SDIRSP0      );
             *(respBuff + 13)= (BYTE)(vm_pSDIReg->SDIRSP0 >> 8 );
             *(respBuff + 14)= (BYTE)(vm_pSDIReg->SDIRSP0 >> 16);
             *(respBuff + 15)= (BYTE)(vm_pSDIReg->SDIRSP0 >> 24);
             break;

         default:
             DEBUGMSG(SDCARD_ZONE_ERROR, (TEXT("SDHCD:GetCmdResponse(): Unrecognized response type!/r/n")));
             break;
     }

     DEBUGMSG (SDHC_RESPONSE_ZONE,(TEXT("GetCommandResponse returned SD_API_STATUS_SUCCESS")));
     return SD_API_STATUS_SUCCESS;
 }

14.SetupDmaXfer
DMA传输,分两种情况SD_READ和SD_WRITE,首先设置request类型(SD_READ或SD_WRITE),reset fifo,设置BlockSize(SDIBSIZE寄存器),根据m_dwDMAChannel(0-3)设置DMA寄存器,设置源/目的地址,源地址periperal bus, fixed addr,目的地址system bus, increment addr,设置DMA通道传输特性handshake, sync PCLK, interrupt, single RX, single service,, MMC request, no auto-reload, word (32 bits), RX count,SD_READ和SD_WRITE的源和目的地址正好相反.
当SD_CMD_STOP_TRANSMISSION命令时,设置BUSY_AFTER_COMMAND

 BOOL CSDIOControllerBase::SetupDmaXfer(PSD_BUS_REQUEST pRequest)
 {
     //----- 1. Check the parameters -----
     if(!pRequest)
     {
         DEBUGMSG(SDCARD_ZONE_ERROR, (TEXT("SDHCD:SetupDmaXfer() - Invalid parameters!/r/n")));
         return FALSE;
     }

     //----- 2. Setup the SD/MMC controller according to the type of transfer -----
     switch(pRequest->TransferClass)
     {
     case SD_READ:

         //********* 3. READ request *********
         m_dwLastTypeOfTransfer = SD_READ;

         //----- 3a. Reset the FIFO -----
         vm_pSDIReg->SDIDTIMER   = MAX_DATABUSY_TIMEOUT;
         vm_pSDIReg->SDIBSIZE      = pRequest->BlockSize;
         Stop_SDIO_DMA_Channel();

         switch( m_dwDMAChannel )
         {
         case 0:
             //----- 3b. Initialize the DMA channel for input mode -----
             vm_pDMAreg->DISRC0   = (int)MMCFIF_PHYS;
             vm_pDMAreg->DISRCC0 |= (SOURCE_PERIPHERAL_BUS | FIXED_SOURCE_ADDRESS); // Source is periperal bus, fixed addr
             vm_pDMAreg->DIDST0   = (int)m_pDMABufferPhys.LowPart;
             vm_pDMAreg->DIDSTC0 &= ~(DESTINATION_PERIPHERAL_BUS | FIXED_DESTINATION_ADDRESS); // Destination is system bus, increment addr
             //----- 3c. Configure the DMA channel's transfer characteristics: handshake, sync PCLK, interrupt, -----
             //         single RX, single service,, MMC request, no auto-reload, word (32 bits), RX count
             vm_pDMAreg->DCON0  = (  HANDSHAKE_MODE | GENERATE_INTERRUPT | MMC_DMA0 | DMA_TRIGGERED_BY_HARDWARE
                                     | NO_DMA_AUTO_RELOAD | TRANSFER_WORD | ((pRequest->BlockSize / sizeof(DWORD)) * pRequest->NumBlocks));
             break;

         case 1:
             //----- 3b. Initialize the DMA channel for input mode -----
             vm_pDMAreg->DISRC1 = (int)MMCFIF_PHYS;
             vm_pDMAreg->DISRCC1    |= (SOURCE_PERIPHERAL_BUS | FIXED_SOURCE_ADDRESS);              // Source is periperal bus, fixed addr
             vm_pDMAreg->DIDST1 = (int)m_pDMABufferPhys.LowPart;
             vm_pDMAreg->DIDSTC1 &= ~(DESTINATION_PERIPHERAL_BUS | FIXED_DESTINATION_ADDRESS);  // Destination is system bus, increment addr
             //----- 3c. Configure the DMA channel's transfer characteristics: handshake, sync PCLK, interrupt, -----
             //         single RX, single service,, MMC request, no auto-reload, word (32 bits), RX count
             vm_pDMAreg->DCON1  = (  HANDSHAKE_MODE | GENERATE_INTERRUPT | MMC_DMA0 | DMA_TRIGGERED_BY_HARDWARE
                                     | NO_DMA_AUTO_RELOAD | TRANSFER_WORD | ((pRequest->BlockSize / sizeof(DWORD)) * pRequest->NumBlocks));
             break;

         case 2:
             //----- 3b. Initialize the DMA channel for input mode -----
             vm_pDMAreg->DISRC2 = (int)MMCFIF_PHYS;
             vm_pDMAreg->DISRCC2    |= (SOURCE_PERIPHERAL_BUS | FIXED_SOURCE_ADDRESS);              // Source is periperal bus, fixed addr
             vm_pDMAreg->DIDST2 = (int)m_pDMABufferPhys.LowPart;
             vm_pDMAreg->DIDSTC2 &= ~(DESTINATION_PERIPHERAL_BUS | FIXED_DESTINATION_ADDRESS);  // Destination is system bus, increment addr
             //----- 3c. Configure the DMA channel's transfer characteristics: handshake, sync PCLK, interrupt, -----
             //         single RX, single service,, MMC request, no auto-reload, word (32 bits), RX count
             vm_pDMAreg->DCON2  = (  HANDSHAKE_MODE | GENERATE_INTERRUPT | MMC_DMA0 | DMA_TRIGGERED_BY_HARDWARE
                                     | NO_DMA_AUTO_RELOAD | TRANSFER_WORD | ((pRequest->BlockSize / sizeof(DWORD)) * pRequest->NumBlocks));
             break;

         case 3:
             //----- 3b. Initialize the DMA channel for input mode -----
             vm_pDMAreg->DISRC3 = (int)MMCFIF_PHYS;
             vm_pDMAreg->DISRCC3    |= (SOURCE_PERIPHERAL_BUS | FIXED_SOURCE_ADDRESS);              // Source is periperal bus, fixed addr
             vm_pDMAreg->DIDST3 = (int)m_pDMABufferPhys.LowPart;
             vm_pDMAreg->DIDSTC3 &= ~(DESTINATION_PERIPHERAL_BUS | FIXED_DESTINATION_ADDRESS);  // Destination is system bus, increment addr
             //----- 3c. Configure the DMA channel's transfer characteristics: handshake, sync PCLK, interrupt, -----
             //         single RX, single service,, MMC request, no auto-reload, word (32 bits), RX count
             vm_pDMAreg->DCON3  = (  HANDSHAKE_MODE | GENERATE_INTERRUPT | MMC_DMA0 | DMA_TRIGGERED_BY_HARDWARE
                                     | NO_DMA_AUTO_RELOAD | TRANSFER_WORD | ((pRequest->BlockSize / sizeof(DWORD)) * pRequest->NumBlocks));
             break;

         default:
             ASSERT(0); // invalid DMA Channel... we should never get here
         }

         //----- 3d. Setup the controller and DMA channel appropriately -----
         vm_pSDIReg->SDIDCON   = RECEIVE_AFTER_COMMAND | TRANSFER_BLOCK_MODE | Get_SDI_Bus_Width() | DMA_ENABLE | DATA_RECEIVE_START | pRequest->NumBlocks;

         break;

     case SD_WRITE:

         //********* 4. WRITE request *********
         m_dwLastTypeOfTransfer = SD_WRITE;

         //----- 4a. Reset the FIFO -----
         vm_pSDIReg->SDIDTIMER   = MAX_DATABUSY_TIMEOUT;
         vm_pSDIReg->SDIBSIZE      = pRequest->BlockSize;
         Stop_SDIO_DMA_Channel();

         switch( m_dwDMAChannel )
         {
         case 0:
             //----- 4b. Initialize the DMA channel for output mode -----
             vm_pDMAreg->DISRC0 = (int)m_pDMABufferPhys.LowPart;
             vm_pDMAreg->DISRCC0    &= ~(SOURCE_PERIPHERAL_BUS | FIXED_SOURCE_ADDRESS);             // Source is periperal bus, fixed addr

             vm_pDMAreg->DIDST0 = (int)MMCFIF_PHYS;
             vm_pDMAreg->DIDSTC0 |= (DESTINATION_PERIPHERAL_BUS | FIXED_DESTINATION_ADDRESS);       // Destination is system bus, increment addr

             //----- 4c. Configure the DMA channel's transfer characteristics: handshake, sync PCLK, interrupt, -----
             //          single TX, single service, MMC request, no auto-reload, word (32 bits), TX count
             vm_pDMAreg->DCON0  = (  HANDSHAKE_MODE | GENERATE_INTERRUPT | MMC_DMA0 | DMA_TRIGGERED_BY_HARDWARE
                                             | NO_DMA_AUTO_RELOAD | TRANSFER_WORD | ((pRequest->BlockSize / sizeof(DWORD)) * pRequest->NumBlocks));
             break;

         case 1:
             //----- 4b. Initialize the DMA channel for output mode -----
             vm_pDMAreg->DISRC1 = (int)m_pDMABufferPhys.LowPart;
             vm_pDMAreg->DISRCC1    &= ~(SOURCE_PERIPHERAL_BUS | FIXED_SOURCE_ADDRESS);             // Source is periperal bus, fixed addr

             vm_pDMAreg->DIDST1 = (int)MMCFIF_PHYS;
             vm_pDMAreg->DIDSTC1 |= (DESTINATION_PERIPHERAL_BUS | FIXED_DESTINATION_ADDRESS);       // Destination is system bus, increment addr

             //----- 4c. Configure the DMA channel's transfer characteristics: handshake, sync PCLK, interrupt, -----
             //          single TX, single service, MMC request, no auto-reload, word (32 bits), TX count
             vm_pDMAreg->DCON1  = (  HANDSHAKE_MODE | GENERATE_INTERRUPT | MMC_DMA0 | DMA_TRIGGERED_BY_HARDWARE
                                             | NO_DMA_AUTO_RELOAD | TRANSFER_WORD | ((pRequest->BlockSize / sizeof(DWORD)) * pRequest->NumBlocks));
             break;

         case 2:
             //----- 4b. Initialize the DMA channel for output mode -----
             vm_pDMAreg->DISRC2 = (int)m_pDMABufferPhys.LowPart;
             vm_pDMAreg->DISRCC2    &= ~(SOURCE_PERIPHERAL_BUS | FIXED_SOURCE_ADDRESS);             // Source is periperal bus, fixed addr

             vm_pDMAreg->DIDST2 = (int)MMCFIF_PHYS;
             vm_pDMAreg->DIDSTC2 |= (DESTINATION_PERIPHERAL_BUS | FIXED_DESTINATION_ADDRESS);       // Destination is system bus, increment addr

             //----- 4c. Configure the DMA channel's transfer characteristics: handshake, sync PCLK, interrupt, -----
             //          single TX, single service, MMC request, no auto-reload, word (32 bits), TX count
             vm_pDMAreg->DCON2  = (  HANDSHAKE_MODE | GENERATE_INTERRUPT | MMC_DMA0 | DMA_TRIGGERED_BY_HARDWARE
                                             | NO_DMA_AUTO_RELOAD | TRANSFER_WORD | ((pRequest->BlockSize / sizeof(DWORD)) * pRequest->NumBlocks));
             break;

         case 3:
             //----- 4b. Initialize the DMA channel for output mode -----
             vm_pDMAreg->DISRC3 = (int)m_pDMABufferPhys.LowPart;
             vm_pDMAreg->DISRCC3    &= ~(SOURCE_PERIPHERAL_BUS | FIXED_SOURCE_ADDRESS);             // Source is periperal bus, fixed addr

             vm_pDMAreg->DIDST3 = (int)MMCFIF_PHYS;
             vm_pDMAreg->DIDSTC3 |= (DESTINATION_PERIPHERAL_BUS | FIXED_DESTINATION_ADDRESS);       // Destination is system bus, increment addr

             //----- 4c. Configure the DMA channel's transfer characteristics: handshake, sync PCLK, interrupt, -----
             //          single TX, single service, MMC request, no auto-reload, word (32 bits), TX count
             vm_pDMAreg->DCON3  = (  HANDSHAKE_MODE | GENERATE_INTERRUPT | MMC_DMA0 | DMA_TRIGGERED_BY_HARDWARE
                                             | NO_DMA_AUTO_RELOAD | TRANSFER_WORD | ((pRequest->BlockSize / sizeof(DWORD)) * pRequest->NumBlocks));
             break;

         default:
             ASSERT(0); // invalid DMA Channel... we should never get here
         }

         //----- 4d. Setup the controller and DMA channel appropriately -----
         vm_pSDIReg->SDIDCON  = TRANSMIT_AFTER_RESPONSE | TRANSFER_BLOCK_MODE | Get_SDI_Bus_Width() | DMA_ENABLE | DATA_TRANSMIT_START | pRequest->NumBlocks;

         break;


     case SD_COMMAND:

         //----- 5. SPECIAL CASE: The SD_CMD_STOP_TRANSMISSION command requires that BUSY_AFTER_COMMAND be setup. -----
         if( ( m_fHandleBusyCheckOnCommand38 && pRequest->CommandCode == SD_CMD_ERASE ) ||
             ( ( pRequest->CommandCode == SD_CMD_STOP_TRANSMISSION ) && ( m_dwLastTypeOfTransfer == SD_WRITE ) ) )
         {
             vm_pSDIReg->SDIDCON = BUSY_AFTER_COMMAND | TRANSFER_BLOCK_MODE | DATA_BUSY | pRequest->NumBlocks;
         }
         break;

     default:
         DEBUGMSG(SDCARD_ZONE_ERROR, (TEXT("SDHCD:SetupDmaXfer(): Unrecognized transfer mode!/r/n")));
         return FALSE;
     }

     return TRUE;
 }

15.IsCardBusy
检查Card是否处在Busy状态.检查SDICSTA和SDIDSTA状态寄存器,COMMAND_IN_PROGRESS,DATA_TRANSMIT_IN_PROGRESS,DATA_RECIEVE_IN_PROGRESS,READ_WAIT_REQUEST_OCCURE状态发生时,Card处于Busy状态.

 BOOL CSDIOControllerBase::IsCardBusy(UINT16 inData)
 {
     //----- 1. Is there a command currently in progress? -----
     if(vm_pSDIReg->SDICSTA & COMMAND_IN_PROGRESS)
         return TRUE;

     //----- 2. Is there a transfer in progress? -----
     if((vm_pSDIReg->SDIDSTA & DATA_TRANSMIT_IN_PROGRESS) ||
        (vm_pSDIReg->SDIDSTA & DATA_RECIEVE_IN_PROGRESS))
        return TRUE;

     //----- 3. Is there a READ-WAIT request in progress? -----
     if(vm_pSDIReg->SDIDSTA & READ_WAIT_REQUEST_OCCURED)
         return TRUE;

     return FALSE;
 }

16.SetClockRate
设置SDI clock时钟频率.首先检查参数正确性,频率最大为25MHz.如果输入MMC全速频率20MHz,由于2410在20MHz会有问题,所以设置成20MHz,然后计算分频值prescale = ((PCLK / (2*baud_rate)) - 1,然后确保SDI时钟处于停止状态,最后设置SDIPRE寄存器设置分配值,并启动SDI时钟.

 DWORD CSDIOControllerBase::SetClockRate(DWORD dwClockRate)
 {
     if((dwClockRate < 0) || (dwClockRate > SD_FULL_SPEED_RATE))
     {
         DEBUGMSG(ZONE_ENABLE_ERROR, (TEXT("SDHCDriver:SetClockRate() - invalid clock rate %d !/r/n"), dwClockRate));
         goto DONE;
     }

     //----- BUGBUG -----
     // HARDWARE BUG WORKAROUND
     //
     // The newest datasheet for the S3C2410X states that the maximum reliable speed for MMC cards is 10Mhz.
     // Some limited testing has shown 20Mhz to still be reliable, but for extra caution let's use 10Mhz.
     if(dwClockRate == MMC_FULL_SPEED_RATE)
     {
         dwClockRate = 10000000;
     }

     //----- 2. Calculate the clock rate  -----
     //         NOTE: Using the prescale value, the clock's baud rate is
     //               determined as follows: baud_rate = (PCLK / 2 / (prescale + 1))
     //
     //               Hence, the prescale value can be computed as follows:
     //               prescale = ((PCLK / (2*baud_rate)) - 1

     DWORD dwPrescale = dwClockRate ? ( (PCLK / (2*dwClockRate)) - 1 ) : 0xff;
     DWORD dwActualRate = PCLK / 2 / ( dwPrescale + 1 );

     // adjust the rate if too high
     if( dwActualRate > dwClockRate )
     {
         dwPrescale++; // set to next supported lower rate

         // recalculate the actual rate
         dwActualRate = PCLK / 2 / ( dwPrescale + 1 );
     }

     // adjust the rate if too low
     if( dwPrescale > 0xff )
     {
         dwPrescale = 0xff; // set to slowest supported rate

         // recalculate the actual rate
         dwActualRate = PCLK / 2 / ( dwPrescale + 1 );
     }

     BOOL fClockIsRunning = Is_SDI_Clock_Running();

     //----- 2. Make sure the clock is stopped -----
     if( fClockIsRunning )
     {
         Stop_SDI_Clock();
     }

     //----- 3. Set the clock rate  -----
     vm_pSDIReg->SDIPRE = dwPrescale;

     DEBUGMSG(SDHC_CLOCK_ZONE, (TEXT("SDHCD:SetClockRate() - Clock rate set to %d Hz/n"), dwActualRate));

     if( fClockIsRunning )
     {
         Start_SDI_Clock();
     }

     // remember the current clock rate
     m_dwClockRate = dwActualRate;

 DONE:
     return m_dwClockRate;
 }

17.PollingTransmit
用来轮询发送数据.首先判断一些错误状态是否发生,如卡不再插槽,FIFO Fail,CRC error等就返回false.状态正常则读取SDIFSTA看FIFO能否接收更多数据.可以就向SDIDAT写数据.直至FIFO满为止.然后监测数据是否写完,并设置DATA_TRANSMIT_FINISHED.

 BOOL CSDIOControllerBase::PollingTransmit(PSD_BUS_REQUEST pRequest, DWORD dwLen)
 {
     BOOL fRetVal = TRUE;
     PBYTE pBuff = pRequest->pBlockBuffer;

     SD_SET_PROC_PERMISSIONS_FROM_REQUEST( pRequest ) {
         __try {
             //----- 1. Send the data to the FIFO -----
             while(dwLen > 0)
             {
                 if( !m_fCardInTheSlot )
                 {
                     DEBUGMSG(SDCARD_ZONE_ERROR, (TEXT("SDHCD:PollingTransmit() - Card ejected!/r/n")));
                     fRetVal = FALSE;
                     break;
                 }
                 if((vm_pSDIReg->SDIDSTA & FIFO_FAIL_ERROR))
                 {
                     DEBUGMSG(SDCARD_ZONE_ERROR, (TEXT("SDHCD:PollingTransmit() - FIFO Error!/r/n")));
                     fRetVal = FALSE;
                     break;
                 }
                 if((vm_pSDIReg->SDIDSTA & DATA_TRANSMIT_CRC_ERROR))
                 {
                     DEBUGMSG(SDCARD_ZONE_ERROR, (TEXT("SDHCD:PollingTransmit() - Transmit CRC Error!/r/n")));
                     fRetVal = FALSE;
                     break;
                 }
                 if((vm_pSDIReg->SDIDSTA & DATA_TIME_OUT))
                 {
                     DEBUGMSG(SDCARD_ZONE_ERROR, (TEXT("SDHCD:PollingTransmit() - Data timeout!/r/n")));
                     fRetVal = FALSE;
                     break;
                 }
                 //----- 2. Is the FIFO ready to accept more data? -----
                 if((vm_pSDIReg->SDIFSTA & FIFO_AVAIL_FOR_TX))
                 {
                     *(PBYTE)&(vm_pSDIReg->SDIDAT) = *pBuff++;
                     dwLen--;
                 }
             }
         } __except (SDProcessException(GetExceptionInformation())) {
             DEBUGMSG(SDCARD_ZONE_ERROR, (TEXT("--- SDHC Driver: Exception caught in PollingTransmit/n")));
             fRetVal = FALSE;
         }
     } SD_RESTORE_PROC_PERMISSIONS();

     if( fRetVal )
     {
         DWORD dwWaitCount = 0;
         //----- 4. Make sure the transmit completes! -----
         while(!(vm_pSDIReg->SDIDSTA & DATA_TRANSMIT_FINISHED))
         {
             dwWaitCount++;
             if( dwWaitCount > WAIT_TIME )
             {
                 DEBUGMSG(SDCARD_ZONE_ERROR, (TEXT("SDHCD:PollingTransmit() - timeout waiting for DATA_TRANSMIT_FINISHED!/r/n")));
                 return SD_API_STATUS_RESPONSE_TIMEOUT;
             }

             if( !IsCardPresent() )
             {
                 DEBUGMSG(SDCARD_ZONE_ERROR, (TEXT("SDHCD:PollingTransmit() - Card ejected!/r/n")));
                 fRetVal = FALSE;
                 break;
             }
             if((vm_pSDIReg->SDIDSTA & FIFO_FAIL_ERROR))
             {
                 DEBUGMSG(SDCARD_ZONE_ERROR, (TEXT("SDHCD:PollingTransmit() - FIFO Error waiting for DATA_TRANSMIT_FINISHED!/r/n")));
                 fRetVal = FALSE;
                 break;
             }
             if((vm_pSDIReg->SDIDSTA & DATA_TRANSMIT_CRC_ERROR))
             {
                 DEBUGMSG(SDCARD_ZONE_ERROR, (TEXT("SDHCD:PollingTransmit() - Transmit CRC Error waiting for DATA_TRANSMIT_FINISHED!/r/n")));
                 fRetVal = FALSE;
                 break;
             }
             if((vm_pSDIReg->SDIDSTA & DATA_TIME_OUT))
             {
                 DEBUGMSG(SDCARD_ZONE_ERROR, (TEXT("SDHCD:PollingTransmit() - Data timeout waiting for DATA_TRANSMIT_FINISHED!/r/n")));
                 fRetVal = FALSE;
                 break;
             }
         }
         vm_pSDIReg->SDIDSTA = DATA_TRANSMIT_FINISHED;
     }

     return fRetVal;
 }

18.PollingReceive
轮询接收数据.首先判断一些错误状态是否发生,没有的话读SDIFSTA寄存器看是否有数据,有的话读取数据到缓冲区中.