pdsocket.cpp

SBC2410 WinCE 5.0 BSP.绝大多数驱动已经调通。

        }
    }

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

    // get the CSC Interrupt delay
    dwSize = sizeof( DWORD );
    if( RegQueryValueEx( CSC_INTERRUPT_DELAY_NAME,
                          &dwType,
                          ( PUCHAR ) & dwData,
                          &dwSize ) )
    {
		m_dwCSCInterruptDelay = dwData;
    }
	else
	{
		m_dwCSCInterruptDelay = 200;
	}

    dwRet = ERROR_SUCCESS;

grc_fail: 
    return dwRet;
}   // GetRegistryConfig

BOOL CPcmciaBusBridge::InitCardBusBridge( void )
{
    DWORD dwRet;

    // Create critical section protecting the PCIC registers
    __try
    {
        InitializeCriticalSection( &m_PCICCritSec );
    }
    __except( EXCEPTION_EXECUTE_HANDLER )
    {
        DEBUGMSG( ZONE_PDD,
                  ( TEXT( "PDCardInitServices InitializeCriticalSection failed %d\r\n" ) ) );
        return FALSE;
    }
    m_fPCICCritSecInitialized = true;

    // Get registry information
    if( ( dwRet = GetRegistryConfig() ) != ERROR_SUCCESS )
    {
        DEBUGMSG( ZONE_PDD,
                  ( TEXT( "PDCardInitServices GetRegistryConfig failed %d\r\n" ),
                    dwRet ) );
        return FALSE;
    }

	// Allocate PCMCIA buffers.
	m_vpIOPRegs = (S3C2410X_IOPORT_REG*)VirtualAlloc(0, sizeof(S3C2410X_IOPORT_REG), MEM_RESERVE, PAGE_NOACCESS);
	if (m_vpIOPRegs == NULL) 
	{
		DEBUGMSG (1,(TEXT("m_vpIOPRegs is not allocated\n\r")));
		goto pcis_fail;
	}
	if (!VirtualCopy((PVOID)m_vpIOPRegs, (PVOID)(S3C2410X_BASE_REG_PA_IOPORT >> 8), sizeof(S3C2410X_IOPORT_REG), PAGE_PHYSICAL|PAGE_READWRITE|PAGE_NOCACHE)) {
		DEBUGMSG (1,(TEXT("m_vpIOPRegs is not mapped\n\r")));
		goto pcis_fail;
	}
	DEBUGMSG (1,(TEXT("m_vpIOPRegs is mapped to %x\n\r"), m_vpIOPRegs));
	
	m_vpMEMRegs = (S3C2410X_MEMCTRL_REG*)VirtualAlloc(0,sizeof(S3C2410X_MEMCTRL_REG), MEM_RESERVE,PAGE_NOACCESS);
	if(m_vpMEMRegs == NULL) 
	{
		DEBUGMSG (1,(TEXT("m_vpMEMRegs is not allocated\n\r")));
		goto pcis_fail;
	}
	if(!VirtualCopy((PVOID)m_vpMEMRegs,(PVOID)(S3C2410X_BASE_REG_PA_MEMCTRL >> 8),sizeof(S3C2410X_MEMCTRL_REG), PAGE_PHYSICAL|PAGE_READWRITE|PAGE_NOCACHE)) {

		DEBUGMSG (1,(TEXT("m_vpMEMRegs is not mapped\n\r")));
		goto pcis_fail;
	}    
	DEBUGMSG (1,(TEXT("m_vpMEMRegs is mapped to %x\n\r"), m_vpMEMRegs));

	m_vpPCMCIAPort = (PUCHAR*)VirtualAlloc(0, 0x0400, MEM_RESERVE,PAGE_NOACCESS);
	if(m_vpPCMCIAPort == NULL) 
	{
		DEBUGMSG (1,(TEXT("m_vpPCMCIAPort is not allocated\n\r")));
		goto pcis_fail;
	}
	if(!VirtualCopy((PVOID)m_vpPCMCIAPort,(PVOID)PD6710_IO_BASE_ADDRESS, 0x0400, PAGE_READWRITE|PAGE_NOCACHE)) {
		DEBUGMSG (1,(TEXT("m_vpPCMCIAPort is not mapped\n\r")));
		goto pcis_fail;
	}    
	DEBUGMSG (1,(TEXT("m_vpPCMCIAPort is mapped to %x\n\r"), m_vpPCMCIAPort));
	
	// Initialize S3C2410 for PD6710           
	// EINT3(GPF3) is enabled.
	m_vpIOPRegs->GPFCON = (m_vpIOPRegs->GPFCON & ~(0x3<<6)) | (0x2<<6); 
	// EINT3 is PULLUP enabled.
	m_vpIOPRegs->GPFUP = (m_vpIOPRegs->GPFUP & ~(0x1<<3));              

	// EINT8(GPG0) is enabled.
	m_vpIOPRegs->GPGCON = (m_vpIOPRegs->GPGCON & ~(0x3<<0)) | (0x2<<0); 
	// EINT8 is *not* PULLUP enabled.
	m_vpIOPRegs->GPGUP = (m_vpIOPRegs->GPGUP | (0x1<<0));

	
	// nGCS2=nUB/nLB(nSBHE),nWAIT,16-bit
	m_vpMEMRegs->BWSCON = (m_vpMEMRegs->BWSCON & ~(0xf<<8)) | (0xd<<8); 

	// BANK2 access timing
	m_vpMEMRegs->BANKCON2 = ((B6710_Tacs<<13)+(B6710_Tcos<<11)+(B6710_Tacc<<8)+(B6710_Tcoh<<6)\
		+(B6710_Tah<<4)+(B6710_Tacp<<2)+(B6710_PMC));

	
	// EINT8=Level-high triggered, IRQ3.
	// EINT3=Falling Edge triggering -> connected INTR(controller)
	m_vpIOPRegs->EXTINT1=(m_vpIOPRegs->EXTINT1 & ~(0xf<<0)) | (0x1<<0); 
	m_vpIOPRegs->EXTINT0=(m_vpIOPRegs->EXTINT0 & ~(0xf<<12)) | (0x2<<12); 
		
	m_PCICIndex = ((PUCHAR)((ULONG)m_vpPCMCIAPort+0x3e0));
	m_PCICData = ((PUCHAR)((ULONG)m_vpPCMCIAPort+0x3e1));

	DEBUGMSG(1, (TEXT("PDCardInitServices m_PCICIndex = 0x%x, m_PCICData = 0x%x\r\n"),
		          m_PCICIndex, m_PCICData));

    if( !IsValidPCICSig() )
    {
        return FALSE;
    }

    DEBUGMSG( ZONE_PDD,
              ( TEXT( "PDCardInitServices m_PCICIndex = 0x%x, m_PCICData = 0x%x\r\n" ),
                m_PCICIndex,
                m_PCICData ) );

    UINT8 tmp = ReadPCICRegister( REG_CHIP_REVISION );
    DEBUGMSG( ZONE_PDD,
              ( TEXT( "PDCardInitServices REG_CHIP_REVISION = 0x%x\r\n" ),
                tmp ) );

    InstallIsr();

    return TRUE;

pcis_fail:
    return FALSE;
}

#define DEFAULT_PRIORITY 101

BOOL CPcmciaBusBridge::Init()
{
    if( !loadPcCardEntry() )
    {
        return FALSE;
    }

    if( !InitCardBusBridge() )
    {
        return FALSE;
    }

    if( !GetSocketNumberFromCS( TRUE ) )
    {
        return FALSE;
    }

    // Set Tread Priority.
    m_uPriority = DEFAULT_PRIORITY;
    DWORD dwRegPriority = 0;
    if( GetRegValue( RegPriority256,
                     ( PBYTE ) & dwRegPriority,
                     sizeof( dwRegPriority ) ) )
    {
        m_uPriority = ( UINT ) dwRegPriority;
    }
    // Get Thread Priority from Registry and Set it.
    CeSetPriority( m_uPriority );
    m_bTerminated = FALSE;

    ThreadStart();
    return TRUE;
}
BOOL CPcmciaBusBridge::GetRegPowerOption( PDWORD pOption )
{
    if( pOption )
    {
        return GetRegValue( RegPowerOption,
                            ( PBYTE ) pOption,
                            sizeof( DWORD ) );
    }
    return TRUE;
}
void CPcmciaBusBridge::PowerMgr( BOOL bPowerDown )
{
    if( bPowerDown )
    {
        if( m_pCardSocket )
        {
            // Disable client interrupts
            WritePCICRegister( REG_INTERRUPT_AND_GENERAL_CONTROL,
                ReadPCICRegister( REG_INTERRUPT_AND_GENERAL_CONTROL ) & 0xf0 );
            // Shut down socket any way.
            WritePCICRegister( REG_POWER_CONTROL, 0 );
        }
    }
    else
    {
        // Initialize S3C2410 for PD6710           
        // EINT3(GPF3) is enabled.
        m_vpIOPRegs->GPFCON = (m_vpIOPRegs->GPFCON & ~(0x3<<6)) | (0x2<<6); 

        // EINT3 is PULLUP enabled.
        m_vpIOPRegs->GPFUP = (m_vpIOPRegs->GPFUP & ~(0x1<<3));              

        // EINT8(GPG0) is enabled.
        m_vpIOPRegs->GPGCON = (m_vpIOPRegs->GPGCON & ~(0x3<<0)) | (0x2<<0); 
        // EINT8 is *not* PULLUP enabled.
        m_vpIOPRegs->GPGUP = (m_vpIOPRegs->GPGUP | (0x1<<0));


        // nGCS2=nUB/nLB(nSBHE),nWAIT,16-bit
        m_vpMEMRegs->BWSCON = (m_vpMEMRegs->BWSCON & ~(0xf<<8)) | (0xd<<8); 

        // BANK2 access timing
        m_vpMEMRegs->BANKCON2 = ((B6710_Tacs<<13)+(B6710_Tcos<<11)+(B6710_Tacc<<8)+(B6710_Tcoh<<6)\
            +(B6710_Tah<<4)+(B6710_Tacp<<2)+(B6710_PMC));


        // EINT8=Level-high triggered, IRQ3.
        // EINT3=Falling Edge triggering -> connected INTR(controller)
        m_vpIOPRegs->EXTINT1=(m_vpIOPRegs->EXTINT1 & ~(0xf<<0)) | (0x1<<0); 
        m_vpIOPRegs->EXTINT0=(m_vpIOPRegs->EXTINT0 & ~(0xf<<12)) | (0x2<<12); 

        if( m_pCardSocket )
        {
            m_fCardInjectEvent = TRUE;
            SetEvent( m_hISTEvent );
        }
    } 
}

BOOL CPcmciaBusBridge::NeedPowerResuming()
{
    m_bResumeFlag = TRUE;
    SetInterruptEvent( m_dwCSCSysIntr );
    return TRUE;
}

void CPcmciaBusBridge::PowerCycleEvent()
{
    Lock();
    m_fPowerCycleEvent = TRUE;
    SetEvent( m_hISTEvent );
    Unlock();
}

void CPcmciaBusBridge::CardInjectEvent()
{
    Lock();
    m_fCardInjectEvent = TRUE;
    SetEvent( m_hISTEvent );
    Unlock();
}

DWORD CPcmciaBusBridge::ThreadRun() // THIS is CardBusBridge IST.
{
    // Test if a PCMCIA card is already inserted in one of the sockets
    UINT8 bCardStatusChange = 0 ;
    if( ( ReadPCICRegister( REG_INTERFACE_STATUS ) 
            & ( STS_CD1 | STS_CD2 ) ) == ( STS_CD1 | STS_CD2 ) )
    {
        bCardStatusChange |= CSC_DETECT_CHANGE;
        SetEvent( m_hISTEvent );
    }

    DEBUGCHK(m_hISTEvent!=NULL);

    // run until signalled to terminate
    while( !m_bTerminated && m_hISTEvent )
    {
        BOOL bInterrupt = (WaitForSingleObject(m_hISTEvent,m_dwPollTimeout)!=WAIT_TIMEOUT);
        if( m_fPollingMode ) // we are polling, fake an interrupt event
        {
            bInterrupt = true;
        }

        if (!bInterrupt) { // we have reached a timeout in non-polling mode or something bad has occured.
            continue;
        }

        Lock();

        UINT8 bSocketState; 
        UINT8 fNotifyEvents;

        while (TRUE) {
            Sleep(20);
            // See what changed and acknowledge any status change interrupts
            fNotifyEvents = 0;
            bCardStatusChange |= ReadPCICRegister( REG_CARD_STATUS_CHANGE );
            // if nothing has changed, continue until next event
            if( !m_fPowerCycleEvent &&
                !m_fCardInjectEvent &&
                bCardStatusChange == 0x0 )
            {
                break;
            }

            // Figure out the socket state
            bSocketState = ReadPCICRegister( REG_INTERFACE_STATUS );

            if( bCardStatusChange & CSC_DETECT_CHANGE )
            {
                fNotifyEvents |= EVENT_MASK_CARD_DETECT;
            }

            if( m_fCardInjectEvent )
            {
                fNotifyEvents |= EVENT_MASK_CARD_DETECT;
                m_fCardInjectEvent = FALSE;
            }

            if( m_fPowerCycleEvent )
            {
                fNotifyEvents |= SPS_POWERCYCLE;
                m_fPowerCycleEvent = FALSE;
            }

            if( fNotifyEvents & EVENT_MASK_CARD_DETECT )
            {
                // we're only processing Card Detection Signal.
                // If this happens, Something has been changed. 
                // Send out Card revmoval before doing any more process.
                RemovePcmciaCardSocket();
                ProcessCDD( bSocketState );
            }
            else
            {
                // Other Event left for type specific socket
                if( m_pCardSocket )
                    m_pCardSocket->SocketEventHandle( bCardStatusChange, fNotifyEvents );
            }
            bCardStatusChange = 0 ; 
        }
        Unlock();
        
        if( !m_fPollingMode )
        {
            DEBUGMSG( ZONE_FUNCTION,
                      ( L"CardBus: PCCardBus Call InterruptDone\r\n" ) );
            InterruptDone( m_dwCSCSysIntr );
        }
    } // while(!m_bTerminated) 
    return 0;
}

void CPcmciaBusBridge::ProcessCDD( DWORD dwStateReg )
{
    switch( dwStateReg & ( STS_CD1 | STS_CD2 ) )
    {
      case 0x0:
        // Complete removal
        if( m_pCardSocket )
        {
            RemovePcmciaCardSocket();
        }
        // Socket Detached.

        break;
      case (STS_CD1|STS_CD2):
        // Complete Insertion.
        if( m_pCardSocket == NULL )
        {
            InsertPcmciaCardSocket( CreatePCMCIASocket( this ) );
        }
        break;
      default:
        break;
    }
}

void CPcmciaBusBridge::CallBackToCardService( HANDLE hSocket, PSS_SOCKET_STATE pSocketState )
{
    if( m_pCallBackToCardService )
    {
        __try
        {
            m_pCallBackToCardService( hSocket,
                                      m_uSocketNum,
                                      pSocketState );
        } __except( EXCEPTION_EXECUTE_HANDLER )
        {
            DEBUGCHK( FALSE );
        }
    }
    else
    {
        DEBUGCHK( FALSE );
    }
}
BOOL CPcmciaBusBridge::GetSocketNumberFromCS( BOOL bGet )
{
    STATUS status = CERR_BAD_ARGS;
    if( m_pRequestSocketNumber && m_pDeleteSocket )
    {
        __try
        {
            status = ( bGet ?
                       m_pRequestSocketNumber( &m_uSocketNum,
                                               sizeof( SMDK2410SocketServiceStatic ),
                                               &SMDK2410SocketServiceStatic,
                                               GetSocketName() ) :
                       m_pDeleteSocket( m_uSocketNum ) );
        } __except( EXCEPTION_EXECUTE_HANDLER )
        {
            DEBUGCHK( FALSE );
            status = CERR_BAD_ARGS;
        }
    }
    DEBUGCHK( status == CERR_SUCCESS );
    return ( status == CERR_SUCCESS );
}