{
#ifdef DEBUG
    const DWORD dwTimeout = 2000;
#else
    const DWORD dwTimeout = INFINITE;
#endif
    SETFNAME(_T("IST"));

    DEBUGMSG(SDCARD_ZONE_INIT, (TEXT("%s Thread Starting\n"), pszFname));

    if (!CeSetThreadPriority(GetCurrentThread(), m_dwPriority)) {
        DEBUGMSG(SDCARD_ZONE_WARN, (TEXT("%s Failed to set CEThreadPriority\n"),
            pszFname));
    }

    while (TRUE) {
        DEBUGCHK(m_hevInterrupt);
        DWORD dwWaitStatus = WaitForSingleObject(m_hevInterrupt, dwTimeout);
        Validate();
        if (m_fDriverShutdown) {
            break;
        }
        if (WAIT_OBJECT_0 != dwWaitStatus) {
            PCSDHCSlotBase pSlotZero = GetSlot(0);
            DEBUGMSG(SDCARD_ZONE_INFO, (TEXT("%s Wait timeout Slot Interrupt Reg x%08X ! Wait status 0x%08X\n"),pszFname,pSlotZero->ReadControllerInterrupts(), dwWaitStatus));
        } else {
            HandleInterrupt();
            InterruptDone(m_dwSysIntr);
        }
    }

    DEBUGMSG(SDCARD_ZONE_INIT, (TEXT("%s Thread Exiting\n"), pszFname));
    return 0;
}


VOID 
CSDHCBase::HandleInterrupt(
                           ) 
{
    Lock();

    // Use slot zero to get the shared global interrupt register
    PCSDHCSlotBase pSlotZero = GetSlot(0);
    DWORD dwIntStatus = pSlotZero->ReadControllerInterrupts();

    do {
         for (DWORD dwSlot = 0; dwSlot < m_cSlots; ++dwSlot) {
            PCSDHCSlotBase pSlot = GetSlot(dwSlot);

            // It is not needed to use slot number because we use NORMAL_INT_STATUS instead of SLOT_INT_STATUS
            if ( (dwIntStatus) || pSlot->NeedsServicing() ) {
                pSlot->HandleInterrupt();
            }
        }

        dwIntStatus = pSlotZero->ReadControllerInterrupts();
        // In order to prevent infinite CARD INT occuring, below code is needed because of the architecture of HSMMC on s3c6410.
         if(dwIntStatus && pSlotZero->IsOnlySDIOInterrupt()) break;
    } while (dwIntStatus);
    Unlock();
}


DWORD
CSDHCBase::DetermineSlotCount(
                              )
{
    SETFNAME(_T("DetermineSlotCount"));

    DWORD cSlots = 0;

    // Read window information
    DDKWINDOWINFO wini = { sizeof(wini) };
    DWORD dwStatus = DDKReg_GetWindowInfo(m_regDevice, &wini);
    if (dwStatus != ERROR_SUCCESS) {
        DEBUGMSG(SDCARD_ZONE_ERROR, (_T("%s Error getting window information\r\n"),
            pszFname));
        goto EXIT;
    }

    cSlots = wini.dwNumMemWindows;

    if (cSlots == 0) {
        DEBUGMSG(SDCARD_ZONE_ERROR, (_T("%s There were not any reported slots.\r\n"),
            pszFname));
        goto EXIT;
    }

EXIT:
    return cSlots;
}




DWORD 
CSDHCBase::DetermineFirstSlotWindow(
                                    PDDKWINDOWINFO pwini
                                    )
{
    PREFAST_DEBUGCHK(pwini);
    DEBUGCHK(pwini->dwNumMemWindows >= m_cSlots);
    DEBUGCHK(pwini->dwNumMemWindows > 0);

    DWORD dwSlotZeroWindow = 0;

    return dwSlotZeroWindow;
}


CEDEVICE_POWER_STATE
CSDHCBase::DetermineRequiredControllerPowerState(
    )
{
    CEDEVICE_POWER_STATE cps = D4;

    for (DWORD dwSlot = 0; dwSlot < m_cSlots; ++dwSlot) {
        PCSDHCSlotBase pSlot = GetSlot(dwSlot);
        cps = min(cps, pSlot->GetPowerState());
    }

    return cps;
}


SD_API_STATUS
CSDHCBase::SetControllerPowerState(
                                   CEDEVICE_POWER_STATE cpsNew
                                   )
{
    if (cpsNew != m_cpsCurrent) {
        switch (cpsNew) {
        case D0:
        case D4:
            KernelIoControl(IOCTL_HAL_DISABLE_WAKE, &m_dwSysIntr, 
                sizeof(m_dwSysIntr), NULL, 0, NULL);
            break;

        case D3:
            KernelIoControl(IOCTL_HAL_ENABLE_WAKE, &m_dwSysIntr, 
                sizeof(m_dwSysIntr), NULL, 0, NULL);
            break;
        }

        SetDevicePowerState(m_hBusAccess, cpsNew, NULL);
        m_cpsCurrent = cpsNew;
    }

    return SD_API_STATUS_SUCCESS;
}


#ifdef DEBUG
VOID 
CSDHCBase::Validate(
                    )
{
    DEBUGCHK(m_regDevice.IsOK());
    DEBUGCHK(m_hBusAccess);
    ValidateSlotCount();
    DEBUGCHK(m_pSlots);
    DEBUGCHK(m_pSlotInfos);
    DEBUGCHK(m_pHCDContext);
    DEBUGCHK(m_dwBusNumber != INVALID_BUS_NUMBER);
    DEBUGCHK(m_interfaceType != InterfaceTypeUndefined);
    DEBUGCHK(m_dwSysIntr != SYSINTR_UNDEFINED);
    DEBUGCHK(VALID_DX(m_cpsCurrent));

    if (m_fRegisteredWithBusDriver && !m_fDriverShutdown) {
        DEBUGCHK(m_htIST);
        DEBUGCHK(m_fHardwareInitialized);
        DEBUGCHK(m_fInterruptInitialized);
    }
}
#endif


// Get the creation proc address and call it
PCSDHCBase
CSDHCBase::CreateSDHCControllerObject(
    LPCTSTR pszActiveKey
    )
{
    PCSDHCBase pSDHC = NULL;
    HKEY hkDevice = OpenDeviceKey(pszActiveKey);

    if (hkDevice) {
        CReg regDevice(hkDevice, _T(""));
        DEBUGCHK(regDevice.IsOK());
        TCHAR szDll[MAX_PATH];

        if (regDevice.ValueSZ(DEVLOAD_DLLNAME_VALNAME, szDll, dim(szDll))) {
            szDll[dim(szDll) - 1] = 0; // Null-terminate
            
            TCHAR szProc[MAX_PATH];

            if (regDevice.ValueSZ(SDHC_CREATION_PROC_KEY, szProc, dim(szProc))) {
                szProc[dim(szProc) - 1] = 0; // Null-terminate
                
                HMODULE hMod = LoadLibrary(szDll);
                if (hMod) {
                    LPSDHC_CREATION_PROC pfnCreate = (LPSDHC_CREATION_PROC)
                        GetProcAddress(hMod, szProc);
                    if (pfnCreate) {
                        pSDHC = (*pfnCreate)();
                    }
                    
                    FreeLibrary(hMod);
                }
            }
        }

        RegCloseKey(hkDevice);
    }

    return pSDHC;
}


///////////////////////////////////////////////////////////////////////////////
//  SDHCInitialize - Initialize the the controller
//  Input:  pHCContext -  host controller context
//          
//  Output: 
//  Return: SD_API_STATUS
//  Notes:  
//          
///////////////////////////////////////////////////////////////////////////////
SD_API_STATUS CSDHCBase::SDHCInitialize(PSDCARD_HC_CONTEXT pHCContext)
{
    DEBUGMSG(SDCARD_ZONE_INIT,(TEXT("SDHCInitialize++\n")));

    PREFAST_DEBUGCHK(pHCContext);
    PCSDHCBase pController = GET_PCONTROLLER_FROM_HCD(pHCContext);
    PREFAST_DEBUGCHK(pController);
    SD_API_STATUS status = pController->Start();

    DEBUGMSG(SDCARD_ZONE_INIT,(TEXT("SDHCInitialize--\n")));

    return status;
}


///////////////////////////////////////////////////////////////////////////////
//  SDHCDeinitialize - Deinitialize the SDHC Controller
//  Input:  pHCContext - HC context
//          
//  Output: 
//  Return: SD_API_STATUS
//  Notes:  
//          
//
///////////////////////////////////////////////////////////////////////////////
SD_API_STATUS CSDHCBase::SDHCDeinitialize(PSDCARD_HC_CONTEXT pHCContext)
{
    DEBUGMSG(SDCARD_ZONE_INIT,(TEXT("SDHCDeinitialize++\n")));

    PREFAST_DEBUGCHK(pHCContext);
    PCSDHCBase pController = GET_PCONTROLLER_FROM_HCD(pHCContext);
    PREFAST_DEBUGCHK(pController);
    SD_API_STATUS status = pController->Stop();

    DEBUGMSG(SDCARD_ZONE_INIT,(TEXT("SDHCDeinitialize--\n")));

    return status;
}


///////////////////////////////////////////////////////////////////////////////
//  SDHCSDCancelIoHandler - io cancel handler 
//  Input:  pHostContext - host controller context
//          dwSlot - slot the request is going on
//          pRequest - the request to be cancelled
//          
//  Output: 
//  Return: TRUE if I/O was cancelled
//  Notes:  
//          the HC lock is taken before entering this cancel handler
//
///////////////////////////////////////////////////////////////////////////////
BOOLEAN 
CSDHCBase::SDHCCancelIoHandler(
                    PSDCARD_HC_CONTEXT  pHCContext,
                    DWORD               dwSlot,
                    PSD_BUS_REQUEST     pRequest
                    )
{
    PREFAST_DEBUGCHK(pHCContext);
    PCSDHCBase pController = GET_PCONTROLLER_FROM_HCD(pHCContext);
    PREFAST_DEBUGCHK(pController);
    return pController->CancelIoHandler(dwSlot, pRequest);
}


///////////////////////////////////////////////////////////////////////////////
//  SDHCBusRequestHandler - bus request handler 
//  Input:  pHostContext - host controller context
//          dwSlot - slot the request is going to
//          pRequest - the request
//          
//  Output: 
//  Return: SD_API_STATUS
//  Notes:  The request passed in is marked as uncancelable, this function
//          has the option of making the outstanding request cancelable    
//          returns status pending
///////////////////////////////////////////////////////////////////////////////
SD_API_STATUS 
CSDHCBase::SDHCBusRequestHandler(
                      PSDCARD_HC_CONTEXT pHCContext, 
                      DWORD              dwSlot, 
                      PSD_BUS_REQUEST    pRequest
                      ) 
{
    PREFAST_DEBUGCHK(pHCContext);
    PCSDHCBase pController = GET_PCONTROLLER_FROM_HCD(pHCContext);
    PREFAST_DEBUGCHK(pController);
    return pController->BusRequestHandler(dwSlot, pRequest);
}

///////////////////////////////////////////////////////////////////////////////
//  SDHCSlotOptionHandler - handler for slot option changes
//  Input:  pHostContext - host controller context
//          dwSlot       - the slot the change is being applied to
//          Option       - the option code
//          pData        - data associaSHC with the option
//  Output: 
//  Return: SD_API_STATUS
//  Notes:  
///////////////////////////////////////////////////////////////////////////////
SD_API_STATUS 
CSDHCBase::SDHCSlotOptionHandler(
                      PSDCARD_HC_CONTEXT    pHCContext,
                      DWORD                 dwSlot, 
                      SD_SLOT_OPTION_CODE   sdOption, 
                      PVOID                 pData,
                      ULONG                 ulOptionSize
                      )
{
    PCSDHCBase pController = GET_PCONTROLLER_FROM_HCD(pHCContext);
    PREFAST_DEBUGCHK(pController);
    return pController->SlotOptionHandler(dwSlot, sdOption, pData, ulOptionSize);
}


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