pdsocket.cpp

Windows CE 6.0 针对PXA270的开发板的BSP参考代码

//
// 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.
//
/*++
THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF
ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO
THE IMPLIED WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A
PARTICULAR PURPOSE.

Module Name:  

Abstract:

    Platform dependent PCMCIA initialization functions

Notes: 
--*/
#include <windows.h>
#include <types.h>
#include <socksv2.h>
#include <memory.h>
#include <ceddk.h>
#include <nkintr.h>
#include "pdsocket.h"


//////////////////////////////////////////////////////////////////////////

// special registry values for this driver
#define IRQ_VALUE_NAME           TEXT("Irq")
#define SYSINTR_VALUE_NAME       TEXT("SysIntr")
#define POLLEDDEVICES_VALUE_NAME TEXT("PolledDevices")
#define CLIENT_IRQ_VALUE_NAME    TEXT("ClientIrq")
#define POLL_TIMEOUT_NAME        TEXT("PollTimeout")
#define POLLING_MODE_NAME        TEXT("PollingMode")
#define SLOT_NUMBER_NAME         TEXT("SlotNumber")
#define DISABLE_SOCKET_NAME      TEXT("DisableSocket")
#define CSC_THREAD_PRIORITY_NAME TEXT("CSCThreadPriority")
#define POWER_OPTION_NAME        TEXT("RegPowerOption")

#define DEFAULT_PRIORITY         101

const SS_POWER_ENTRY CPcmciaCardSocket::m_rgPowerEntries[NUM_POWER_ENTRIES] =
{
    { 0,    PWR_SUPPLY_VCC  | PWR_SUPPLY_VPP1 | PWR_SUPPLY_VPP2 },
    { 33,   PWR_SUPPLY_VCC  | PWR_SUPPLY_VPP1 | PWR_SUPPLY_VPP2 },
    { 50,   PWR_SUPPLY_VCC  | PWR_SUPPLY_VPP1 | PWR_SUPPLY_VPP2 }
};

DWORD CPcmciaCardSocket::m_dwSocketLastIndex = 1;


STATUS CPcmciaCardSocket::GetPowerEntry( PDWORD pdwNumOfEntry,
                                         PSS_POWER_ENTRY pPowerEntry )
{
    STATUS status = CERR_BAD_ARGS;
    if( pdwNumOfEntry != NULL && pPowerEntry != NULL )
    {
        DWORD dwNumOfCopied = min( *pdwNumOfEntry, NUM_POWER_ENTRIES );
        if( dwNumOfCopied != 0 )
        {
            memcpy( pPowerEntry,
                    m_rgPowerEntries,
                    dwNumOfCopied * sizeof( SS_POWER_ENTRY ) );
            *pdwNumOfEntry = dwNumOfCopied;
            status = CERR_SUCCESS;
        }
    }
    return status;
}


CPcmciaBusBridge::CPcmciaBusBridge( LPCTSTR RegPath ) : CPCCardBusBridgeBase( RegPath ),
                                                        CMiniThread( 0,
                                                                     TRUE )
{

    //m_fPCICCritSecInitialized = false;
    m_hISTEvent = NULL;
    m_prgCardSocket = NULL;
    m_rgfPowerCycleEvent = FALSE;
    m_rgForceEject = FALSE;
    m_fPollingMode = TRUE;
};


CPcmciaBusBridge::~CPcmciaBusBridge()
{
    GetSocketNumberFromCS( FALSE );

    // Terminate IST
    m_bTerminated = TRUE;
    if( m_hISTEvent )
    {
        SetEvent( m_hISTEvent );
        ThreadTerminated( 1000 );
        if( !m_fPollingMode )
        {
            InterruptDisable( m_dwCSCSysIntr );
        }
        CloseHandle( m_hISTEvent );
    };

    RemovePcmciaCardSocket();

    //if( m_fPCICCritSecInitialized )
    //{
        //DeleteCriticalSection( &m_PddSocketCrit );
        //DeleteCriticalSection( &m_PddWindowCrit );
    //}

    UnMapDeviceRegisters();

}


BOOL CPcmciaBusBridge::InstallIsr()
{

    // CreateIST Event.
    m_hISTEvent = CreateEvent( 0, FALSE, FALSE, NULL );

    if( !m_fPollingMode )
    {
        InterruptInitialize( m_dwCSCSysIntr, m_hISTEvent, 0, 0 );
        //InterruptInitialize( m_dwCSCSysIntr, m_hISTEvent, 0, 0 );
    }

    return(TRUE);
}


BOOL CPcmciaBusBridge::InitializeBridgeHW( void )
{
    // TODO - handle initializing only the current slot...

    // Configure the MECR register to inform the memory controller about the
    // total number of sockets on Mainstone (0x1 => 2 sockets).
    //
    m_pMemCtrlRegs->mecr   = 0x00000001;

    m_strPCCardSocketHandle.pstrGpioRegsHandle    = (XLLP_GPIO_T *) m_pGPIORegs;
    m_strPCCardSocketHandle.pstrBcrHandle         = (XLLP_BCR_T *)  m_pBLRegs;
    m_strPCCardSocketHandle.pstrOstRegsHandle     = (XLLP_OST_T *)  m_pOSTRegs;
    m_strPCCardSocketHandle.pstrMemCtrlRegsHandle = (XLLP_MEMORY_CONTROL_REGISTER_T *) m_pMemCtrlRegs;

    m_strPCCardSocketHandle.pstrPCCardSocketState = &m_strPCCardSocketState;
    m_strPCCardSocketHandle.pstrCardTimingHandle  = (XLLP_CARDTIMING_T *)&m_strPCCardExpMemTiming;

    m_pstrPCCardSocketHandle = &m_strPCCardSocketHandle;       

    // Set up memory controller timings for both sockets.
    //
    XllpPCCardSetExpMemTiming(m_pstrPCCardSocketHandle);

    // Configure the GPIO signals for both sockets.
    //
    XllpPCCardConfigureGPIOs(m_pstrPCCardSocketHandle);	

    m_pBLRegs->pcmcia0_srcr  = 0;
    m_pBLRegs->pcmcia1_srcr  = 0;

    m_pBLRegs->pcmcia0_srcr |= (XLLP_BIT_3);
    m_pBLRegs->pcmcia1_srcr |= (XLLP_BIT_3);

    return(TRUE);
}


BOOL CPcmciaBusBridge::UnMapDeviceRegisters( void )
{

	if(m_pBLRegs)
	{
		VirtualFree((PVOID)m_pBLRegs, 0, MEM_RELEASE);
		m_pBLRegs = NULL;
	}
	if(m_pGPIORegs)
	{
		VirtualFree((PVOID)m_pGPIORegs, 0, MEM_RELEASE);
		m_pGPIORegs = NULL;
	}
	if(m_pMemCtrlRegs)
	{
		VirtualFree((PVOID)m_pMemCtrlRegs, 0, MEM_RELEASE);
		m_pMemCtrlRegs = NULL;
	}
	if(m_pOSTRegs)
	{
		VirtualFree((PVOID)m_pOSTRegs, 0, MEM_RELEASE);
		m_pOSTRegs = NULL;
	}

    return(TRUE);
}


BOOL CPcmciaBusBridge::MapDeviceRegisters( void )
{
    PHYSICAL_ADDRESS PA;

    PA.QuadPart = MAINSTONEII_BASE_REG_PA_FPGA;
    m_pBLRegs = (volatile MAINSTONEII_BLR_REGS *) MmMapIoSpace(PA, sizeof(MAINSTONEII_BLR_REGS), FALSE);

    PA.QuadPart = BULVERDE_BASE_REG_PA_GPIO;
    m_pGPIORegs = (volatile BULVERDE_GPIO_REG *) MmMapIoSpace(PA, sizeof(BULVERDE_GPIO_REG), FALSE);

    PA.QuadPart = BULVERDE_BASE_REG_PA_MEMC;
    m_pMemCtrlRegs = (volatile BULVERDE_MEMCTRL_REG *) MmMapIoSpace(PA, sizeof(BULVERDE_MEMCTRL_REG), FALSE);

    PA.QuadPart = BULVERDE_BASE_REG_PA_OST;
    m_pOSTRegs = (volatile BULVERDE_OST_REG *) MmMapIoSpace(PA, sizeof(BULVERDE_OST_REG), FALSE);

    if (!m_pBLRegs || !m_pGPIORegs || !m_pMemCtrlRegs || !m_pOSTRegs)
    {
        return(FALSE);
    }

    return(TRUE);

}   // MapDeviceRegisters.


//
// Function to get the initial settings from the registry
//
// NOTE: lpRegPath is assumed to be under HKEY_LOCAL_MACHINE
//
// Returns ERROR_SUCCESS on success or a Win32 error code on failure
//
DWORD CPcmciaBusBridge::GetRegistryConfig( void )
{
    DWORD dwRet = 1;
    DWORD dwSize, dwType, dwData;

    // Get the PCMCIA window configurations
    if( !LoadWindowsSettings() )
    {
        dwRet = ERROR_INVALID_DATA;
        goto grc_fail;
    }

    // Read the registry to determine the physical slot number we're dealing with.
    dwSize = sizeof( DWORD );
    if( !RegQueryValueEx( SLOT_NUMBER_NAME,
                          &dwType,
                          ( PUCHAR ) & dwData,
                          &dwSize ) )
    {
        DEBUGMSG( ZONE_PDD,
                  ( TEXT( "PCMCIA:GetRegistyConfig RegQueryValueEx(%s) failed\r\n" ),
                    SLOT_NUMBER_NAME ) );
        goto grc_fail;
    }
    m_SlotNumber = (UINT8)dwData;

    // Get the polling mode value.
    dwSize = sizeof( DWORD );
    if( !RegQueryValueEx( POLLING_MODE_NAME,
                          &dwType,
                          ( PUCHAR ) & dwData,
                          &dwSize ) )
    {
        m_fPollingMode = TRUE; // RegQueryValueEx failed, default to TRUE
    }
    else
    {
        m_fPollingMode = dwData ? TRUE : FALSE;
    }

    // Get client (function) IRQ.
    dwSize = sizeof( DWORD );
    if( !RegQueryValueEx( CLIENT_IRQ_VALUE_NAME,
                          &dwType,
                          ( PUCHAR ) & dwData,
                          &dwSize ) )
    {
        DEBUGMSG( ZONE_PDD,
                  ( TEXT( "PCMCIA:GetRegistyConfig RegQueryValueEx(%s) failed\r\n" ),
                    CLIENT_IRQ_VALUE_NAME ) );
        goto grc_fail;
    }
    m_dwClientIrq = dwData;

// TODO - get CD IRQ and SYSINTR - no polling.

    // Get card status change (CSC) IRQ and SYSINTR values.
    // NOTE: the CSC and CD IRQ values are part of the same IRQ multi-string in the registry.
    dwSize = sizeof( DWORD );
    if( !RegQueryValueEx( IRQ_VALUE_NAME,
                          &dwType,
                          ( PUCHAR ) & dwData,
                          &dwSize ) )
    {
        m_dwCSCIrq = 0;
        m_fPollingMode = FALSE;
    }
    else
    {
        m_dwCSCIrq = dwData;
    }
    dwSize = sizeof( DWORD );
    if( !RegQueryValueEx( SYSINTR_VALUE_NAME,
                          &dwType,
                          ( PUCHAR ) & dwData,
                          &dwSize ) )
    {
        m_dwCSCSysIntr = 0;
        m_dwCSCIrq = 0;
        m_fPollingMode = FALSE;
    }
    else
    {
        m_dwCSCSysIntr = dwData;
    }

    // Get the polling timeout value.
    dwSize = sizeof( DWORD );
    if( !RegQueryValueEx( POLL_TIMEOUT_NAME,
                          &dwType,
                          ( PUCHAR ) & dwData,
                          &dwSize ) )
    {
        // RegQueryValueEx failed; if pooling, set the timeout to 0.5 sec, otherwise set to INFINITE
        m_dwPollTimeout = m_fPollingMode ? 500 : INFINITE;
    }
    else
    {
        m_dwPollTimeout = dwData;
    }

    // Get thread priority from registry and set it.
    m_uPriority = DEFAULT_PRIORITY;
    dwSize = sizeof( DWORD );
    if( RegQueryValueEx( CSC_THREAD_PRIORITY_NAME,
                         &dwType,
                         ( PUCHAR ) & dwData,