impl.c

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

//
// Copyright (c) Microsoft Corporation.  All rights reserved.
//
//
// Use of this sample source code is subject to the terms of the Microsoft
// license agreement under which you licensed this sample source code. If
// you did not accept the terms of the license agreement, you are not
// authorized to use this sample source code. For the terms of the license,
// please see the license agreement between you and Microsoft or, if applicable,
// see the LICENSE.RTF on your install media or the root of your tools installation.
// THE SAMPLE SOURCE CODE IS PROVIDED "AS IS", WITH NO WARRANTIES OR INDEMNITIES.
//
//
// Copyright (c) 2002 BSQUARE Corporation.  All rights reserved.
// DO NOT REMOVE --- BEGIN EXTERNALLY DEVELOPED SOURCE CODE ID 40973--- DO NOT REMOVE
//
// Module Name:
//
//    Impl.c   
//
// Abstract:
//
//    Driver entry points for Plato SDIO driver 
//
// Notes:
//
///////////////////////////////////////////////////////////////////////////////

#include <windows.h>
#include <nkintr.h>
#include <ceddk.h>
#include <bulverde.h>
#include <xllp_gpio.h>

#define SDH_CARD_DETECT_PRIORITY 101

XLLP_GPIO_T         *g_pGPIORegisters = NULL;    // GPIO registers
HANDLE               hCardInsertInterruptEvent;     // card insert/remove interrupt event
HANDLE               hCardInsertInterruptThread;    // card insert/remove interrupt event
XLLP_UINT32_T        g_SDCDGpio;       // SD/MMC card detect interrupt GPIO value
DWORD                dwSDCDIrq;        // SD/MMC card detect interrupt IRQ value
DWORD                dwSysintrCD;      // SD/MMC card detect interrupt SYSINTR value
DWORD                dwCardDetectIstThreadPriority;   // Card detect IST thread priority
BOOL                 fSimulateCardInsertion;

void  ProcessCardInsertion(void *pContext);
void  ProcessCardRemoval(void *pContext);
BOOL  DriverShutdown(void *pContext);

DWORD SDCardDetectIstThread(void *pContext);

BOOL InitializeHardware( HANDLE hBusAccessHandle )
{
    PHYSICAL_ADDRESS PA;
    XLLP_UINT32_T pins[3];

    PA.QuadPart = BULVERDE_BASE_REG_PA_GPIO;
    g_pGPIORegisters = (XLLP_GPIO_T *) MmMapIoSpace(PA, sizeof(XLLP_GPIO_T), FALSE);

    if (g_pGPIORegisters == NULL) {
        RETAILMSG(1,
            (_T("InitializeHardware: - MmMapIoSpace Failure\n"))
            );
        goto ExitInit;
    }

    //
    // set up Card Detect interrupt pin
    //set interrupt pin  
    pins[0] = 1; //number of pins in array
    pins[1] = g_SDCDGpio; //pin to modify
    XllpGpioClearAlternateFn(g_pGPIORegisters, pins);
    XllpGpioSetRisingDetectEnable(g_pGPIORegisters, pins);
    XllpGpioSetFallingEdgeDetectEnable(g_pGPIORegisters, pins);
    XllpGpioSetDirectionIn(g_pGPIORegisters, pins);

ExitInit:

    return TRUE;
}

void UnInitializeHardware()
{
    if(g_pGPIORegisters)
    {
        VirtualFree((PVOID)g_pGPIORegisters, 0, MEM_RELEASE);
        g_pGPIORegisters = NULL;
    }
}

BOOL IsCardWriteProtected()
{
    //write protection switch is not connected on Plato
    return FALSE;
}

BOOL IsCardPresent()
{
    if( XllpGpioGetState(g_pGPIORegisters, g_SDCDGpio) ) 
        return TRUE;
    else
        return FALSE;
}

void MMCPowerControl( BOOL fPowerOn )
{
    // Plato has no control over the power on the SD Slot
}

void SimulateCardInsertion()
{
    fSimulateCardInsertion = TRUE;
    SetInterruptEvent( dwSysintrCD );
}

///////////////////////////////////////////////////////////////////////////////
//  SDCardDetectIstThread - IST thread for card detect interrupts
//  Input:  pContext - pointer to the device context
//  Output: 
//  Return: thread exit code
///////////////////////////////////////////////////////////////////////////////
DWORD SDCardDetectIstThread(void *pContext)
{
    DWORD waitStatus;
    DWORD dwTimeout = INFINITE;

    dwTimeout = INFINITE;
    SetEvent( hCardInsertInterruptEvent ); // set it to check for cards already inserted at boot time

    if (!CeSetThreadPriority(GetCurrentThread(), 
                             dwCardDetectIstThreadPriority)) {
        //DbgPrintZo(SDCARD_ZONE_WARN,
        //    (TEXT("SDCardDetectIstThread: warning, failed to set CEThreadPriority \n")));
    }

    while(TRUE)
    {
        waitStatus = WaitForSingleObject( hCardInsertInterruptEvent, dwTimeout );

        if (WAIT_OBJECT_0 != waitStatus) {
            //DbgPrintZo(SDCARD_ZONE_WARN, (TEXT("SDCardDetectIstThread: Wait Failed! 0x%08X \n"), waitStatus));
                // bail out
            return 0;
        }

        if( DriverShutdown(pContext) ) {
            //DbgPrintZo(1, (TEXT("SDCardDetectIstThread: Thread Exiting\n")));
            return 0;
        }
        
        if( fSimulateCardInsertion )
        {
            fSimulateCardInsertion = FALSE;
            ProcessCardRemoval(pContext);
        }

        Sleep( 100 ); // delay to handle bouncing effect on the interrupt line

        if( IsCardPresent() )
        {
            ProcessCardInsertion(pContext);
        }
        else 
        {
            ProcessCardRemoval(pContext);
        }

        InterruptDone( dwSysintrCD );
    } // while
}

BOOL  SetupCardDetectIST( void *pHardwareContext )
{
    DWORD threadID;                         // thread ID
    fSimulateCardInsertion = FALSE;

        // convert the hardware SD/MMC card detect interrupt IRQ into a logical SYSINTR value
    if (!KernelIoControl(IOCTL_HAL_REQUEST_SYSINTR, &dwSDCDIrq, sizeof(DWORD), &(dwSysintrCD), sizeof(DWORD), NULL))
    {
        // invalid SDIO SYSINTR value!
        //DEBUGMSG(SDCARD_ZONE_ERROR, (TEXT("Error obtaining SDIO SYSINTR value!\n")));
        dwSysintrCD = SYSINTR_UNDEFINED;
        return FALSE;
    }

        // allocate the interrupt event for card insertion
    hCardInsertInterruptEvent = CreateEvent(NULL, FALSE, FALSE,NULL);
    
    if (NULL == hCardInsertInterruptEvent) {
        return FALSE;
    }

    // initialize the card insertion interrupt event
    if (!InterruptInitialize (dwSysintrCD,
                            hCardInsertInterruptEvent,
                            NULL,
                            0)) {
        return FALSE;
    }

    InterruptDone(dwSysintrCD);

        // create the interrupt thread to handle card insertion events
    hCardInsertInterruptThread = 
                    CreateThread(NULL,
                                 0,
                                 (LPTHREAD_START_ROUTINE)SDCardDetectIstThread,
                                 pHardwareContext,
                                 0,
                                 &threadID);
    
    if (NULL == hCardInsertInterruptThread) {
        return FALSE;
    }

    return TRUE;
}

void CleanupCardDetectIST()
{
    // wake up the IST
    if( hCardInsertInterruptEvent )
    {
        SetEvent(hCardInsertInterruptEvent);
    }

    // clean up card insertion IST 
    if (NULL != hCardInsertInterruptThread) {
        // wait for the thread to exit
        WaitForSingleObject(hCardInsertInterruptThread, INFINITE); 
        CloseHandle(hCardInsertInterruptThread);
        hCardInsertInterruptThread = NULL;
    }

    // free card insertion interrupt event
    if (NULL != hCardInsertInterruptEvent) {
        CloseHandle(hCardInsertInterruptEvent);
        hCardInsertInterruptEvent = NULL;
    }

    // free card insertion interrupt
    if( dwSysintrCD != SYSINTR_UNDEFINED )
    {
        InterruptDisable( dwSysintrCD );
        KernelIoControl(IOCTL_HAL_RELEASE_SYSINTR, &dwSysintrCD, sizeof(DWORD), NULL, 0, NULL);
        dwSysintrCD = SYSINTR_UNDEFINED;
    }
}

#define CARDDETECT_GPIO_TEXT _T("CardDetectGPIO")
#define CARDDETECT_IRQ_TEXT _T("CardDetectIRQ")
#define CARDDETECT_IST_PRI_TEXT _T("CardDetectISTPriority")
#define DEFAULT_CARD_DETECT_IST_PRIORITY 101
BOOL LoadPlatformRegistrySettings( HKEY hKeyDevice )
{
    DWORD dwRegVal;
    DWORD dwDataSize;
    DWORD dwType;

    dwDataSize = sizeof(DWORD);
    if( ERROR_SUCCESS == RegQueryValueEx( hKeyDevice, CARDDETECT_GPIO_TEXT,
                                          NULL, &dwType, (LPBYTE)&dwRegVal, &dwDataSize ) &&
        REG_DWORD == dwType )
    {
        g_SDCDGpio = (XLLP_UINT32_T) dwRegVal;
    }
    else
    {
        return FALSE;
    }

    dwDataSize = sizeof(DWORD);
    if( ERROR_SUCCESS == RegQueryValueEx( hKeyDevice, CARDDETECT_IRQ_TEXT,
                                          NULL, &dwType, (LPBYTE)&dwRegVal, &dwDataSize ) &&
        REG_DWORD == dwType )
    {
        dwSDCDIrq = dwRegVal;
    }
    else
    {
        return FALSE;
    }

    dwDataSize = sizeof(DWORD);
    if( ERROR_SUCCESS == RegQueryValueEx( hKeyDevice, CARDDETECT_IST_PRI_TEXT,
                                          NULL, &dwType, (LPBYTE)&dwRegVal, &dwDataSize ) &&
        REG_DWORD == dwType )
    {
        dwCardDetectIstThreadPriority = dwRegVal;
    }
    else
    {
        dwCardDetectIstThreadPriority = DEFAULT_CARD_DETECT_IST_PRIORITY;
    }

    return TRUE;
}