main.c

Windows CE 6.0 BSP for VOIP sample phone. Intel PXA270 platform.

///////////////////////////////////////////////////////////////////////////////
//  SDH_PowerDown - the power down entry point
//  Input:  hDeviceContext - the device context from SDH_Init
//  Output: 
//  Notes:  preforms no actions
///////////////////////////////////////////////////////////////////////////////
void SDH_PowerDown(DWORD    hDeviceContext)
{
    PSDCARD_HC_CONTEXT pHostContext;
    PSDH_HARDWARE_CONTEXT pController;

    DbgPrintZo(SDCARD_ZONE_FUNC, (TEXT("SDH: +SDH_PowerDown\n")));

    pHostContext = (PSDCARD_HC_CONTEXT)hDeviceContext;
    ASSERT( pHostContext );
    if( pHostContext )
    {
        pController = pHostContext->pHCSpecificContext;
        SDControllerPowerDown( pController );
    }
}

///////////////////////////////////////////////////////////////////////////////
//  SDH_PowerUp - the power up entry point 
//  Input:  hDeviceContext - the device context from SDH_Init
//  Output: 
//  Notes:  preforms no actions
///////////////////////////////////////////////////////////////////////////////
void SDH_PowerUp(DWORD  hDeviceContext)
{
    PSDCARD_HC_CONTEXT pHostContext;
    PSDH_HARDWARE_CONTEXT pController;

    DbgPrintZo(SDCARD_ZONE_FUNC, (TEXT("SDH: +SDH_PowerDown\n")));

    pHostContext = (PSDCARD_HC_CONTEXT)hDeviceContext;
    ASSERT( pHostContext );
    if( pHostContext )
    {
        pController = pHostContext->pHCSpecificContext;
        SDControllerPowerUp( pController );
    }
}

///////////////////////////////////////////////////////////////////////////////
//  SDH_Read - the read entry point for the CE file system wrapper
//  Input:  hOpenContext - the context from SDH_Open
//          pBuffer - the user's buffer
//          Count - the size of the transfer
//  Output: 
//  Return: zero
//  Notes:  not used
///////////////////////////////////////////////////////////////////////////////
DWORD SDH_Read(DWORD    hOpenContext,
               LPVOID   pBuffer,
               DWORD    Count)
{
    DbgPrintZo(SDCARD_ZONE_FUNC, (TEXT("SDH: +-SDH_Read\n")));
    return 0;
}

///////////////////////////////////////////////////////////////////////////////
//  SDH_Seek - the seek entry point for the CE file system wrapper
//  Input:  hOpenContext - the context from SDH_Open
//          Amount - the amount to seek
//          Type - the type of seek
//  Output: 
//  Return: zero
//  Notes:  not used
///////////////////////////////////////////////////////////////////////////////
DWORD SDH_Seek(DWORD    hOpenContext,
               long     Amount,
               DWORD    Type)
{
    DbgPrintZo(SDCARD_ZONE_FUNC, (TEXT("SDH: +-SDH_Seek\n")));
    return 0;
}

///////////////////////////////////////////////////////////////////////////////
//  SDH_Write - the write entry point for the CE file system wrapper
//  Input:  hOpenContext - the context from SDH_Open
//          pBuffer - the user's buffer
//          Count - the size of the transfer
//  Output: 
//  Return: zero
//  Notes:  Not used
///////////////////////////////////////////////////////////////////////////////
DWORD SDH_Write(DWORD   hOpenContext,
                LPCVOID pBuffer,
                DWORD   Count)
{
    DbgPrintZo(SDCARD_ZONE_FUNC, (TEXT("SDH: +-SDH_Write\n")));
    return 0;
}

#define CONTROLLER_IRQ_TEXT _T("ControllerIRQ")
#define CONTROLLER_IST_PRI_TEXT _T("ControllerISTPriority")
#define CLOCK_ALWAYS_ON_TEXT _T("ClockAlwaysOn")
#define CLOCK_ON_IF_INTERRUPTS_ENABLED_TEXT _T("ClockOnIfInterruptsEnabled")
#define MAXIMUM_CLOCK_FREQUENCY_TEXT _T("MaximumClockFrequency")
#define CONTROLLER_DMA_ISR_DLL_TEXT _T("DMAIsrDll")
#define CONTROLLER_DMA_ISR_HANDLER_TEXT _T("DMAIsrHandler")
#define CONTROLLER_DMA_IRQ_TEXT _T("DMAIRQ")
#define CONTROLLER_DMA_SYSINT_TEXT _T("DMASysIntr")
#define CONTROLLER_DMA_CHANNEL_TEXT _T("DMAChannel")
#define CONTROLLER_DMA_IST_PRI_TEXT _T("DMAISTPriority")
#define CONTROLLER_DMA_BUFFER_SIZE_TEXT  _T("DMABufferSize")
#define CONTROLLER_POLLING_MODE_TEXT _T("PollingModeSize")

BOOL LoadRegistrySettings( HKEY hKeyDevice, PSDH_HARDWARE_CONTEXT pController )
{
    DWORD dwRegVal;
    DWORD dwDataSize;
    DWORD dwType;

    dwDataSize = sizeof(DWORD);
    if( ERROR_SUCCESS == RegQueryValueEx( hKeyDevice, CONTROLLER_IRQ_TEXT,
                                          NULL, &dwType, (LPBYTE)&dwRegVal, &dwDataSize ) &&
        REG_DWORD == dwType )
    {
        pController->dwSDMMCIrq = dwRegVal;
    }
    else
    {
        return FALSE;
    }

    // get the DMA channel
    dwDataSize = sizeof(DWORD);
    if( ERROR_SUCCESS == RegQueryValueEx( hKeyDevice, CONTROLLER_DMA_CHANNEL_TEXT,
                                          NULL, &dwType, (LPBYTE)&dwRegVal, &dwDataSize ) &&
        REG_DWORD == dwType )
    {
        if( dwRegVal > 31 )
        {
            pController->dwDmaChannel = 0xffffffff;
            return FALSE;
        }
        pController->dwDmaChannel = dwRegVal;

        // get the DMA IRQ
        dwDataSize = sizeof(DWORD);
        if( ERROR_SUCCESS == RegQueryValueEx( hKeyDevice, CONTROLLER_DMA_IRQ_TEXT,
                                              NULL, &dwType, (LPBYTE)&dwRegVal, &dwDataSize ) &&
            REG_DWORD == dwType )
        {
            pController->dwDmaIRQ = dwRegVal;
        }
        else
        {
            pController->dwDmaIRQ = IRQ_DMAC;
        }

        // get the DMA buffer size
        dwDataSize = sizeof(DWORD);
        if( ERROR_SUCCESS == RegQueryValueEx( hKeyDevice, CONTROLLER_DMA_BUFFER_SIZE_TEXT,
                                              NULL, &dwType, (LPBYTE)&dwRegVal, &dwDataSize ) &&
            REG_DWORD == dwType )
        {
            pController->dwDmaBufferSize = dwRegVal;
        }
        else
        {
            pController->dwDmaBufferSize = 0;
        }

        // get the DMA SysInt
        dwDataSize = sizeof(DWORD);
        if( ERROR_SUCCESS == RegQueryValueEx( hKeyDevice, CONTROLLER_DMA_SYSINT_TEXT,
                                              NULL, &dwType, (LPBYTE)&dwRegVal, &dwDataSize ) &&
            REG_DWORD == dwType )
        {
            pController->dwDmaSysIntr = dwRegVal;
        }
        else
        {
            pController->dwDmaSysIntr = SYSINTR_UNDEFINED;
        }

        dwDataSize = sizeof(pController->wszDmaIsrDll);
        if( ERROR_SUCCESS == RegQueryValueEx( hKeyDevice, CONTROLLER_DMA_ISR_DLL_TEXT,
                                              NULL, &dwType, (LPBYTE)pController->wszDmaIsrDll, &dwDataSize ) &&
            REG_SZ == dwType )
        {
        }
        else
        {
            pController->wszDmaIsrDll[0] = 0;
        }

        dwDataSize = sizeof(pController->wszDmaIsrHandler);
        if( ERROR_SUCCESS == RegQueryValueEx( hKeyDevice, CONTROLLER_DMA_ISR_HANDLER_TEXT,
                                              NULL, &dwType, (LPBYTE)pController->wszDmaIsrHandler, &dwDataSize ) &&
            REG_SZ == dwType )
        {
        }
        else
        {
            pController->wszDmaIsrHandler[0] = 0;
        }

        dwDataSize = sizeof(DWORD);
        if( ERROR_SUCCESS == RegQueryValueEx( hKeyDevice, CONTROLLER_DMA_IST_PRI_TEXT,
                                              NULL, &dwType, (LPBYTE)&dwRegVal, &dwDataSize ) &&
            REG_DWORD == dwType )
        {
            pController->DmaIstThreadPriority = dwRegVal;
        }
        else
        {
            pController->DmaIstThreadPriority = SDH_DMA_CONTROLLER_PRIORITY;
        }
    }
    else
    {
        pController->dwDmaChannel = 0xffffffff;
        pController->wszDmaIsrDll[0] = 0;
        pController->wszDmaIsrHandler[0] = 0;
    }

    dwDataSize = sizeof(DWORD);
    if( ERROR_SUCCESS == RegQueryValueEx( hKeyDevice, CLOCK_ALWAYS_ON_TEXT,
                                          NULL, &dwType, (LPBYTE)&dwRegVal, &dwDataSize ) &&
        REG_DWORD == dwType )
    {
        pController->fClockAlwaysOn = dwRegVal ? TRUE : FALSE;
    }
    else
    {
        pController->fClockAlwaysOn = FALSE;
    }

    dwDataSize = sizeof(DWORD);
    if( ERROR_SUCCESS == RegQueryValueEx( hKeyDevice, CLOCK_ON_IF_INTERRUPTS_ENABLED_TEXT,
                                          NULL, &dwType, (LPBYTE)&dwRegVal, &dwDataSize ) &&
        REG_DWORD == dwType )
    {
        pController->fClockOnIfInterruptsEnabled = dwRegVal ? TRUE : FALSE;
    }
    else
    {
        pController->fClockOnIfInterruptsEnabled = FALSE;
    }

    dwDataSize = sizeof(DWORD);
    if( ERROR_SUCCESS == RegQueryValueEx( hKeyDevice, CONTROLLER_IST_PRI_TEXT,
                                          NULL, &dwType, (LPBYTE)&dwRegVal, &dwDataSize ) &&
        REG_DWORD == dwType )
    {
        pController->ControllerIstThreadPriority = dwRegVal;
    }
    else
    {
        pController->ControllerIstThreadPriority = SDH_CARD_CONTROLLER_PRIORITY;
    }

    dwDataSize = sizeof(DWORD);
    if( ERROR_SUCCESS == RegQueryValueEx( hKeyDevice, MAXIMUM_CLOCK_FREQUENCY_TEXT,
                                          NULL, &dwType, (LPBYTE)&dwRegVal, &dwDataSize ) &&
        REG_DWORD == dwType )
    {
        pController->dwMaximumSDClockFrequency = dwRegVal;
    }
    else
    {
        pController->dwMaximumSDClockFrequency = MAXIMUM_SDCLOCK_FREQUENCY;
    }

    dwDataSize = sizeof(DWORD);
    if( ERROR_SUCCESS == RegQueryValueEx( hKeyDevice, CONTROLLER_POLLING_MODE_TEXT,
                                          NULL, &dwType, (LPBYTE)&dwRegVal, &dwDataSize ) &&
        REG_DWORD == dwType )
    {
        pController->dwPollingModeSize = dwRegVal;
    }
    else
    {
        pController->dwPollingModeSize = NUM_BYTE_FOR_POLLING_MODE;
    }
    return LoadPlatformRegistrySettings(hKeyDevice);
}

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