sdbusdriver.h

2443 wince5.0 bsp, source code

    }

    return SD_API_STATUS_SUCCESS;
}
// slot event packet
typedef struct SDCARD_HC_SLOT_EVENT {
    PSDBUS_HC_SLOT_CONTEXT   pSlotContext;      // the slot context
    SD_SLOT_EVENT            SlotEvent;
} *PSDCARD_HC_SLOT_EVENT;

// bus driver tag
#define SD_BUS_DRIVER_TAG  'SDBS'

// bus driver zones
#define SDBUS_ZONE_HCD                  SDCARD_ZONE_0
#define ENABLE_SDBUS_ZONE_HCD           ZONE_ENABLE_0
#define SDBUS_ZONE_DISPATCHER           SDCARD_ZONE_1
#define ENABLE_SDBUS_ZONE_DISPATCHER    ZONE_ENABLE_1
#define SDCARD_ZONE_SHUTDOWN            SDCARD_ZONE_2
#define ENABLE_SDBUS_ZONE_SHUTDOWN      ZONE_ENABLE_2
#define SDBUS_ZONE_POWER                SDCARD_ZONE_3
#define ENABLE_SDBUS_ZONE_POWER         ZONE_ENABLE_3
#define SDBUS_ZONE_DEVICE               SDCARD_ZONE_4
#define ENABLE_SDBUS_ZONE_DEVICE        ZONE_ENABLE_4
#define SDBUS_ZONE_REQUEST              SDCARD_ZONE_5
#define ENABLE_SDBUS_ZONE_REQUEST       ZONE_ENABLE_5
#define SDBUS_ZONE_BUFFER               SDCARD_ZONE_6
#define ENABLE_SDBUS_ZONE_BUFFER        ZONE_ENABLE_6

// macro to get the system context
#define GetSDBusDriver(pHc) ((CSDBusDriver *)((pHc)->pSystemContext))

// default powerup wait while polling for NOT busy
#define DEFAULT_POWER_UP_TOTAL_WAIT_TIME  2000
// as per spec , 50 MS interval 
#define DEFAULT_POWER_UP_SD_POLL_INTERVAL 50
// MMC cards don't really specify this, so we'll just borrow the SD one.
#define DEFAULT_POWER_UP_MMC_POLL_INTERVAL DEFAULT_POWER_UP_SD_POLL_INTERVAL

// SDIO doesn't specify this either, but in case some one
// needs clocks during CMD5 polling (which is a spec violation)
// we provide a clock train 
#define DEFAULT_POWER_UP_SDIO_POLL_INTERVAL 2 // SDIO WiFi cards need this to be 2

#define POWER_UP_POLL_TIME_KEY          TEXT("PowerUpPollingTime")
#define POWER_UP_POLL_TIME_INTERVAL_KEY TEXT("PowerUpPollingInterval")

#define SDDCGetBusDriver(pDevice) (CSDBusDriver *)(pDevice)->pSystemContext

// get the system context
PVOID SDGetSystemContext();

// fast-path callback
VOID NotifyClient(PSDCARD_DEVICE_CONTEXT pDevice, SD_SLOT_EVENT_TYPE Event);

// deregister a host controller
SD_API_STATUS DoDeregisterHostController(PSDBUS_HC_CONTEXT pHCContext, 
                                         BOOL fExternalCall);


// the main class for the bus driver
class CSDBusDriver
{
public:
    // constructor
    CSDBusDriver(LPCTSTR pszActiveKey);

    // destructor
    ~CSDBusDriver();

    // initialize
    SD_API_STATUS Initialize();

    // registration of the host controller
    SD_API_STATUS RegisterHostController(PSDBUS_HC_CONTEXT pHCContext);

    // de registration of the host controller
    SD_API_STATUS DeregisterHostController(PSDBUS_HC_CONTEXT pHCContext);

    // acquire global system lock
    inline VOID AcquireLock() {
        EnterCriticalSection(&m_BusDriverCriticalSection);
    }

    // release global system lock
    inline VOID ReleaseLock() {
        LeaveCriticalSection(&m_BusDriverCriticalSection);
    }

    BOOLEAN IsReady() {
        return m_Initialized;
    }

    // bus request dispatcher
    static VOID BusRequestCompleteDispatch(CSDWorkItem *pWorkItem, CSDBusDriver *pBusDriver);
    // slot status change dispatcher
    static VOID SlotStatusChange(CSDWorkItem *pWorkItem, CSDBusDriver *pBusDriver);


    VOID HandleBusRequestComplete();

    VOID DeleteClientDevice(PSDCARD_DEVICE_CONTEXT pDevice);

    SD_API_STATUS RegisterClientDevice(PSDCARD_DEVICE_CONTEXT           pDevice,
        PVOID                            pContext,
        PSDCARD_CLIENT_REGISTRATION_INFO pInfo);

    PSDCARD_DEVICE_CONTEXT AllocateDeviceContext();

    VOID HandleAddDevice(PSDBUS_HC_SLOT_CONTEXT pSlot);

    VOID HandleRemoveDevice(PSDBUS_HC_SLOT_CONTEXT pSlot);

    VOID HandleDeviceInterrupting(PSDBUS_HC_SLOT_CONTEXT pSlot);

    static VOID CommandCompleteCallback(SD_DEVICE_HANDLE hDevice,
        PSDBUS_BUS_REQUEST  pRequest,
        PVOID            pContext,
        DWORD            BusRequestParam);

    SD_API_STATUS SDLoadDevice(PSDCARD_DEVICE_CONTEXT pDevice);

    VOID SDUnloadDevice(PSDCARD_DEVICE_CONTEXT pDevice);

    // get SD/MMC/SDIO card custom reg path
    static SD_API_STATUS GetCustomRegPath(PSDCARD_DEVICE_CONTEXT pDevice,
        LPTSTR                 pPath,
        DWORD                  cchPath,
        BOOL                   BasePath);

    SD_API_STATUS SubmitToHC(PSDBUS_HC_CONTEXT pHost, 
        DWORD Slot, 
        PSDBUS_BUS_REQUEST pRequest);

    // allocate a bus request
    _inline PSDBUS_BUS_REQUEST AllocateBusRequest() {
        PSDBUS_BUS_REQUEST pRequest = 
            (PSDBUS_BUS_REQUEST)SDAllocateFromMemList(m_BusRequestList);

        if (pRequest) {
            DEBUGMSG(SDBUS_ZONE_REQUEST, (_T("SDBus: Allocated request 0x%08x\n"), 
                pRequest));
            pRequest->dwSig = VALID_BUS_REQUEST_SIG;
        }

        return pRequest;
    }

    _inline VOID FreeBusRequest(PSDBUS_BUS_REQUEST pRequest) {
        DEBUGCHK(pRequest->dwSig == VALID_BUS_REQUEST_SIG);
        SDFreeToMemList(m_BusRequestList, pRequest);
        DEBUGMSG(SDBUS_ZONE_REQUEST, (_T("SDBus: Freed request 0x%08x\n"), 
            pRequest));
    }

    // submit a request
    SD_API_STATUS SubmitBusRequest(PSDBUS_BUS_REQUEST pRequest);

    PSD_SYNCH_REQUEST_INFO AllocateSyncInfo();

    VOID FreeSyncInfo(PSD_SYNCH_REQUEST_INFO pInfo);

    _inline DWORD GetDispatchPriority() {
        return m_DispatchPriority;
    }

    // queue a completed request 
    _inline VOID QueueCompletedRequest(PSDBUS_BUS_REQUEST pRequest) {
        AcquireLock();

        // queue the request
        SDQueueBusRequest(&m_CompletedRequestQueue, pRequest);

        ReleaseLock();
    }

    // legacy power up/down
    VOID PowerUp(PSDBUS_HC_SLOT_CONTEXT pSlot);

    VOID PowerDown(PSDBUS_HC_SLOT_CONTEXT pSlot, BOOL KeepPower);

    VOID PostSlotEvent(SD_SLOT_EVENT            Event,
        PSDBUS_HC_SLOT_CONTEXT   pSlotContext,
        CSDWorkItem              *pWorkItem);

    DWORD GetSlotInfo(PUCHAR pBuffer, DWORD Length);

    VOID WakeUpBusRequestCompleteDispatcher() {
        // wake up the bus request complete dispatcher
        m_pBusRequestCompleteDispatcher->WakeUpWorkItem();    
    }

    ULONG GetRetryCount()  { return m_BusRequestRetryCount;}

    DWORD GetNewHCNumber();

    BOOL BusIOControl(DWORD dwCode, PBYTE pBufIn, DWORD dwLenIn, PBYTE pBufOut, 
        DWORD dwLenOut, PDWORD pdwActualOut) {
            return m_sdBusEnum.IOControl(dwCode, pBufIn, dwLenIn, pBufOut, 
                dwLenOut, pdwActualOut);
        }

protected:

    CRITICAL_SECTION    m_BusDriverCriticalSection;     // bus driver critical section
    BOOLEAN             m_Initialized;                  // fully initialized
    LIST_ENTRY          m_HostControllerListHead;       // host controller link list
    SD_MEMORY_LIST_HANDLE  m_BusRequestList;            // list for bus requests
    SD_MEMORY_LIST_HANDLE  m_SynchList;                  // synchronous request info list
    DWORD               m_DispatchPriority;             // dispatch priority
    SD_REQUEST_QUEUE    m_CompletedRequestQueue;        // completed request queue
    CSDWorkItem         *m_pBusRequestCompleteDispatcher;  // the bus request complete dispatcher
    ULONG               m_BusRequestRetryCount;            // retry count
    CSdBusEnum          m_sdBusEnum;
    CReg                m_regDevice;
};


// Internal implementations of functions exported to host controller drivers
// through function pointers.
SD_API_STATUS SDHCDAllocateContext__X(DWORD NumberOfSlots,
                                      PSDCARD_HC_CONTEXT *ppExternalHCContext);

VOID SDHCDDeleteContext__X(PSDCARD_HC_CONTEXT pExternalHCContext);

SD_API_STATUS SDHCDRegisterHostController__X(PSDCARD_HC_CONTEXT pExternalHCContext);

SD_API_STATUS SDHCDDeregisterHostController__X(PSDCARD_HC_CONTEXT pExternalHCContext);

VOID SDHCDIndicateSlotStateChange__X(PSDCARD_HC_CONTEXT pExternalHCContext, 
                                     DWORD              SlotNumber,
                                     SD_SLOT_EVENT      Event);

VOID SDHCDIndicateBusRequestComplete__X(PSDCARD_HC_CONTEXT pExternalHCContext,
                                        HBUS_REQUEST       hRequest,
                                        SD_API_STATUS      Status);

VOID SDHCDUnlockRequest__X(PSDCARD_HC_CONTEXT  pExternalHCContext,
                           HBUS_REQUEST        hRequest);

HBUS_REQUEST SDHCDGetAndLockCurrentRequest__X(PSDCARD_HC_CONTEXT pExternalHCContext, 
                                              DWORD              SlotIndex);

VOID SDHCDPowerUpDown__X(PSDCARD_HC_CONTEXT  pExternalHCContext, 
                         BOOL                PowerUp, 
                         BOOL                SlotKeepPower,
                         DWORD               SlotIndex);


// Signature of SDCARD_HC_CONTEXT structure
#define VALID_HC_CONTEXT_SIG        'cHdS' // SdHc
#define DEREGISTERED_HC_CONTEXT_SIG 0xdededede

#endif

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