impl.c

Lido PXA270平台开发板的最新BSP,包括源代码

//
// Copyright (c) Microsoft Corporation.  All rights reserved.
//
//
// Use of this source code is subject to the terms of the Microsoft end-user
// license agreement (EULA) under which you licensed this SOFTWARE PRODUCT.
// If you did not accept the terms of the EULA, you are not authorized to use
// this source code. For a copy of the EULA, please see the LICENSE.RTF on your
// install media.
//
//
// 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 XSBASE270_G SDIO driver 
//
// Notes:
//
///////////////////////////////////////////////////////////////////////////////

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

#define SDH_CARD_DETECT_PRIORITY 101

volatile XSBASE270_G_CPLD_REGS  *g_pXSBASE270_GRegs = NULL;     // XSBASE270_G 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

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

DWORD SDCardDetectIstThread(void *pContext);

BOOL InitializeHardware()
{
    PHYSICAL_ADDRESS XSBASE270_G_CPLD_Base = {XSBASE270_G_BASE_REG_PA_CPLD};
    ASSERT( g_pXSBASE270_GRegs == NULL );
	g_pXSBASE270_GRegs = (XSBASE270_G_CPLD_REGS*)MmMapIoSpace( XSBASE270_G_CPLD_Base, sizeof(XSBASE270_G_CPLD_REGS), FALSE );
	if ( !g_pXSBASE270_GRegs )
	{
        return FALSE;
	}

    return TRUE;
}

void UnInitializeHardware()
{
    if ( g_pXSBASE270_GRegs ) {
        MmUnmapIoSpace((PVOID)g_pXSBASE270_GRegs, sizeof(XSBASE270_G_CPLD_REGS));
        g_pXSBASE270_GRegs = NULL;
    }
}

BOOL IsCardWriteProtected()
{
    if( g_pXSBASE270_GRegs->STATUS & STS_MMC_WP )
        return FALSE;
    else
        return TRUE;
}

BOOL IsCardPresent()
{
    if( g_pXSBASE270_GRegs->STATUS & STS_MMC_DET )
        return TRUE;
    else
        return FALSE;
}

void MMCPowerControl( BOOL fPowerOn )
{
    if(fPowerOn)
        g_pXSBASE270_GRegs->BCR1 |= BCR_MMC_PWR;
    else
        g_pXSBASE270_GRegs->BCR1 &= ~BCR_MMC_PWR;
}

///////////////////////////////////////////////////////////////////////////////
//  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;
        }
        
        Sleep( 100 ); // delay to handle bouncing effect on the interrupt line

        if( IsCardPresent() )
        {
            RETAILMSG( TRUE, ( TEXT( "SD CARD is Present\r\n" ) ) );
            ProcessCardInsertion(pContext);
        }
        else 
        {
            ProcessCardRemoval(pContext);
        }

        InterruptDone( dwSysintrCD );
    } // while
}

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

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


        // 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()
{
    InterruptDisable (dwSysintrCD);

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

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