impl.c

Windows CE 6.0 BSP for VOIPAC Board (PXA270) Version 2b.

//
// 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.
//
//
// 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 Mainstone SDIO driver 
//
// Notes:
//
///////////////////////////////////////////////////////////////////////////////

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

#define SDH_CARD_DETECT_PRIORITY 101

volatile BULVERDE_GPIO_REG  *g_pGPIORegs = NULL;     // Mainstone board level registers
HANDLE               hCardInsertInterruptEvent;     // card insert/remove interrupt event
HANDLE               hCardInsertInterruptThread;    // card insert/remove interrupt event
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 )
{
    ULONG fInIOSpace = FALSE;
    PHYSICAL_ADDRESS Bulverde_GPIO_Base = {BULVERDE_BASE_REG_PA_GPIO};
    ASSERT( g_pGPIORegs == NULL );
    if( !BusTransBusAddrToVirtual( hBusAccessHandle, Internal, 0, Bulverde_GPIO_Base,
					sizeof(BULVERDE_GPIO_REG), &fInIOSpace, (PPVOID)&g_pGPIORegs ) )
	{
        return FALSE;
	}

    // Set SD/Memory stick Mux control to route the signals to SD/MMC Socket
//    g_pMainstoneRegs->misc_wr &= 0xFBFB; // clear bit 10 of Miscellaneous Write Register 1

    return TRUE;
}

void UnInitializeHardware()
{
    if ( g_pGPIORegs ) {
        MmUnmapIoSpace((PVOID)g_pGPIORegs, sizeof(BULVERDE_GPIO_REG));
        g_pGPIORegs = NULL;
    }
}

BOOL IsCardWriteProtected()
{
    if( g_pGPIORegs->GPLR1 & XLLP_BIT_20 ) // GPIO52
        return TRUE;
    else
        return FALSE;
}

BOOL IsCardPresent()
{
    if( g_pGPIORegs->GPLR1 & XLLP_BIT_21 ) // GPIO53
        return FALSE;
    else
        return TRUE;
}

void MMCPowerControl( BOOL fPowerOn )
{
/*    UINT32 uTmp = g_pMainstoneRegs->misc_wr & 0xF7FB;
    uTmp |= fPowerOn ? 0x0800 : 0;
    g_pMainstoneRegs->misc_wr = uTmp;*/
}

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_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_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;
}