pcmciabridge.cpp

freescale i.mx31 BSP CE5.0全部源码

	    if( ( pObject = m_rgObjectArray[dwIndex] ) != NULL )
	    {
	        if( pObject->GetSocketHandle() == hSocket )
	        {
	            pObject->AddRef();
	            break;
	        }
	    }
	    pObject = NULL;
	}
	Unlock();
	return pObject;
}

//------------------------------------------------------------------------------
//
// Function: InsertPcmciaCardSocket
//
// This function informs the card service layer about card insertion event and the socket state
//
// Parameters:
//      pSocket
//          [in]   CPcmcia class object pertaining to a particular PCMCIA slot
//
// Returns:
//    None
//
//------------------------------------------------------------------------------
void CPcmciaBusBridge::InsertPcmciaCardSocket( CPcmciaSocket* pSocket )
{
	DEBUGMSG( ZONE_PDD, (TEXT("PCCARD: +CPcmciaBusBridge::InsertPcmciaCardSocket\n")));

    if( pSocket )
    {
        //Lock();
        if( m_pCardSocket != pSocket )
            RemovePcmciaCardSocket(  );
        if( m_pCardSocket == NULL  )
        {
            CPcmciaSocket* pReturn = InsertObjectAtEmpty( NULL, pSocket );
            if( pReturn )
            {
                SS_SOCKET_STATE sSockState;
                                              
                m_pCardSocket = pSocket;
                m_pCardSocket->CardGetSocket( &sSockState );
                sSockState.dwEventChanged |= SOCK_EVENT_CD;
                sSockState.dwEventStatus |= SOCK_EVENT_CD;
                
                CallBackToCardService( m_pCardSocket->GetSocketHandle(),
                                       &sSockState );                
            }
            else
            {
                // This should never happens.But we do our best to recover.
                DEBUGCHK( FALSE );
                delete pSocket;
            }
        }
        else
            DEBUGCHK( FALSE );
        //Unlock();
    }
    else
    {
        DEBUGCHK( FALSE );
    }

	DEBUGMSG( ZONE_PDD, (TEXT("PCCARD: -CPcmciaBusBridge::InsertPcmciaCardSocket\n")));
}

//------------------------------------------------------------------------------
//
// Function: RemovePcmciaCardSocket
//
// This function informs the card service layer about card removal event and the socket state
//
// Parameters:
//          None
//
// Returns:
//        None
// 
//------------------------------------------------------------------------------
void CPcmciaBusBridge::RemovePcmciaCardSocket( )
{
	DEBUGMSG( ZONE_PDD, (TEXT("PCCARD: +CPcmciaBusBridge::RemovePcmciaCardSocket\n")));
        Lock();
	
    if( m_pCardSocket )
    {
        SS_SOCKET_STATE sSockState;
        m_pCardSocket->CardGetSocket( &sSockState );
        sSockState.dwEventChanged |= SOCK_EVENT_CD;
        sSockState.dwEventStatus &= ~SOCK_EVENT_CD;
        CallBackToCardService( m_pCardSocket->GetSocketHandle(),
                               &sSockState );

		CPcmciaSocket* pSocket = RemoveObjectBy( m_pCardSocket );
		DEBUGCHK( pSocket != NULL );

        m_pCardSocket = NULL;
    }
    Unlock();
   	
	
	DEBUGMSG( ZONE_PDD, (TEXT("PCCARD: -CPcmciaBusBridge::RemovePcmciaCardSocket\n")));
}

//------------------------------------------------------------------------------
//
// Function: PowerManager
//
// This function brings the controller to normal/low power mode
//
// Parameters:
//      bPowerDown
//          [in]   TRUE for low power mode/FALSE for power up
//
// Returns:
//       None
//
//------------------------------------------------------------------------------
void CPcmciaBusBridge::PowerManager( BOOL bPowerDown )
{
    if( bPowerDown )
    {
		g_vPcmciaReg->PER = 0;	// Disable all the interrupts
	
		SetPccPower(0, TRUE);	// Set GPIO pins to 0 volt	

		g_vPcmciaReg->PGCR = PCMCIA_PGCR_LOWPWRMODE;	// Set to Lower Power mode

		//DeinitGpio();
    }
    else
    {
		//InitGpio();

		// Do software reset - then clear bit after it's done 
		PCMCIA_RESET_SOCKET();
		UINT32 i=100;
		while(i-- <1);
		//Sleep(1000);
		PCMCIA_SET_SOCKET();

		g_vPcmciaReg->PER = 0;	// Disable all the interrupts
		
		// Invalidate all the windows
		for(int num_win= 0; num_win < PCMCIA_NUM_WINDOWS; num_win++) 
		{
			g_vPcmciaReg->PBR[num_win]  = 0;
			g_vPcmciaReg->POR[num_win]  = 0;
			g_vPcmciaReg->POFR[num_win] = 0;
		}

		SetPccPower(0, TRUE);	// Set GPIO pins to 0 volt	
	
		g_vPcmciaReg->PGCR = PCMCIA_PGCR_LOWPWRMODE;	// Set to Lower Power mode
		
       	if( m_pCardSocket )
		{
			m_fCardInjectEvent = TRUE;
			SetEvent( m_hISTEvent );
		}
	}
}

//------------------------------------------------------------------------------
//
// Function: PowerCycleEvent
//
// This function sets a power cycle event for the Cardbusbridge IST (Socket service IST)
//
// Parameters:
//      None
//
// Returns:
//       None
//
//------------------------------------------------------------------------------
void CPcmciaBusBridge::PowerCycleEvent(  )
{
    Lock();
    m_fPowerCycleEvent = TRUE;
    SetEvent( m_hISTEvent );
    Unlock();
}

//------------------------------------------------------------------------------
//
// Function: CardInjectEvent
//
// This function sets a fake card insert event for the Cardbusbridge IST (Socket service IST)
//
// Parameters:
//      None
//
// Returns:
//       None
//
//------------------------------------------------------------------------------
void CPcmciaBusBridge::CardInjectEvent( )
{
    Lock();
    m_fCardInjectEvent = TRUE;
    SetEvent( m_hISTEvent );
    Unlock();
}

//------------------------------------------------------------------------------
//
// Function: ThreadRun
//
// This is the Cardbusbridge IST which is the Socket service layer IST
//
// Parameters:
//      None
//
// Returns:
//      Always returns success (0)
//
//------------------------------------------------------------------------------
DWORD CPcmciaBusBridge::ThreadRun() // THIS is CardBusBridge IST.
{
	UINT32 	dwStatus, dwStatusChange;

	dwStatus = GET_CARD_STATUS();
	
	if (IS_CARD_INSERTED(dwStatus)) {		
		DEBUGMSG( ZONE_PDD, ( L"PCCARD: ThreadRun()  Card is already inserted trigger the IST event\r\n" ) );
		m_fCardInjectEvent = TRUE;
        	SetEvent( m_hISTEvent );
	}

 
	// run until signalled to terminate
	while( !m_bTerminated )
	{
    		DEBUGCHK(m_hISTEvent!=NULL);

		BOOL bInterrupt;

		bInterrupt = (WaitForSingleObject(m_hISTEvent, m_dwPollTimeout)!=WAIT_TIMEOUT);
		
		if( m_fPollingMode ) // we are pooling, fake an interrupt event
			bInterrupt = TRUE;

		//DEBUGMSG( ZONE_PDD, ( L"PCCARD: ThreadRun()  m_fPollingMode=%d\r\n" , m_fPollingMode) );

		if (!bInterrupt) { // we have reached a timeout in non-pooling mode or something bad has occured.
			//DEBUGMSG( ZONE_PDD, ( L"PCCARD: ThreadRun() Timeout Continue\r\n" ) );
			continue;
        	}
        	
        	
        	Lock();
	
		UINT32 fNotifyEvents = 0;

        	while (TRUE) {
            		Sleep(20);

			// See what changed and acknowledge any status change interrupts
            		fNotifyEvents = 0;
            		dwStatusChange = GET_CARD_STATUS_CHANGE();
			dwStatus = GET_CARD_STATUS();		

			//DEBUGMSG( ZONE_PDD, ( L"PCCARD: ThreadRun() dwStatusChange=0x%X dwStatus=0x%X\r\n" , dwStatusChange, dwStatus ));

			// if nothing has changed, continue until next event
            		if( !m_fPowerCycleEvent &&
                	    !m_fCardInjectEvent &&
                            (dwStatusChange&0x7F) == 0x0 )
            		{
                		break;
            		}

			if( IS_CARDDETEC_CHANGE(dwStatusChange) )
            		{
				DEBUGMSG( ZONE_PDD,( L"PCCARD: ThreadRun() CardStatusChange\r\n" ) );
                		fNotifyEvents |= EVENT_MASK_CARD_DETECT;
            		}

            		if( m_fCardInjectEvent )
            		{
				DEBUGMSG( ZONE_PDD,( L"PCCARD: ThreadRun() CardInjectEvent\r\n" ) );
                		fNotifyEvents |= EVENT_MASK_CARD_DETECT;
                		m_fCardInjectEvent = FALSE;
            		}

            		if( m_fPowerCycleEvent )
            		{
				DEBUGMSG( ZONE_PDD,( L"PCCARD: ThreadRun() PowerCycleEvent\r\n" ) );
                		fNotifyEvents |= EVENT_MASK_POWER_CYCLE;
                		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( dwStatus );
            		}
            		else
            		{
                		// Other Event left for type specific socket
				DEBUGMSG( ZONE_PDD, ( L"PCCARD: ThreadRun() OtherEvents\r\n" ) );
                		if( m_pCardSocket )
                    		m_pCardSocket->SocketEventHandle( dwStatusChange, fNotifyEvents );
            		}
			
			dwStatusChange = 0;
        	}
        	
        	Unlock();

        if( !m_fPollingMode )
        {
            DEBUGMSG( ZONE_FUNCTION,
                      ( L"CardBus: PCCardBus Call InterruptDone\r\n" ) );
            InterruptDone( m_dwCSCSysIntr );

        }				
    } // while(!m_bTerminated) 
    return 0;      
}

//------------------------------------------------------------------------------
//
// Function: ProcessCDD
//
// This function brings the controller to normal/low power mode
//
// Parameters:
//      dwPStateReg
//          [in]   status whether card is inserted or not
//
// Returns:
//       None
//
//------------------------------------------------------------------------------
void CPcmciaBusBridge::ProcessCDD( DWORD dwPStateReg )
{
    if( IS_CARD_INSERTED(dwPStateReg) )
    {
	if(!m_pCardSocket)
            InsertPcmciaCardSocket( CreatePCMCIASocket( ) );
    }
    else
    {
    // Complete removal
        if( m_pCardSocket )
        RemovePcmciaCardSocket(  );
    }
}

//------------------------------------------------------------------------------
//
// Function: CallBackToCardService
//
// This function brings the controller to normal/low power mode
//
// Parameters:
//      hSocket
//          [in]   handle to reference the socket slot
//      pSocketState
//          [in]   state of the particular socket slot
//
// Returns:
//       None
//
//------------------------------------------------------------------------------
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 );
    }
}

//------------------------------------------------------------------------------
//
// Function: GetSocketNumberFromCardService
//
// This function brings the controller to normal/low power mode
//
// Parameters:
//      bGet
//          [in]   TRUE to get the socket interface number/FLASE to delete the socket number
//
// Returns:
//       None
//
//------------------------------------------------------------------------------
BOOL CPcmciaBusBridge::GetSocketNumberFromCardService( BOOL bGet )
{
    STATUS status = CERR_BAD_ARGS;
    if( m_pRequestSocketNumber && m_pDeleteSocket )
    {
        __try
        {
            status = ( bGet ?
                       m_pRequestSocketNumber( &m_uSocketNum,
                                               sizeof( MX31SocketServiceStatic ),
                                               &MX31SocketServiceStatic,
                                               GetSocketName() ) :
                       m_pDeleteSocket( m_uSocketNum ) );
        } __except( EXCEPTION_EXECUTE_HANDLER )
        {
            DEBUGCHK( FALSE );
            status = CERR_BAD_ARGS;
        }
    }
    DEBUGCHK( status == CERR_SUCCESS );
    return ( status == CERR_SUCCESS );
}

//
// Print Pcmcia Register value
//
void PcPrintPcmciaReg(void)
{
	UINT8 i = 0;
		
	DEBUGMSG(ZONE_PDD,(TEXT("PCMCIA Register:g_vPcmciaReg:0x%X\n"),g_vPcmciaReg));
	DEBUGMSG(ZONE_PDD,(TEXT("\tPIPR [0x%X] :0x%X\n"),&(g_vPcmciaReg->PIPR),g_vPcmciaReg->PIPR));	
	DEBUGMSG(ZONE_PDD,(TEXT("\tPSCR [0x%X] :0x%X\n"),&(g_vPcmciaReg->PSCR),g_vPcmciaReg->PSCR));
	DEBUGMSG(ZONE_PDD,(TEXT("\tPER [0x%X] :0x%X\n"),&(g_vPcmciaReg->PER),g_vPcmciaReg->PER));
	DEBUGMSG(ZONE_PDD,(TEXT("\tPGSR [0x%X] :0x%X\n"),&(g_vPcmciaReg->PGSR),g_vPcmciaReg->PGSR));
	DEBUGMSG(ZONE_PDD,(TEXT("\tPGCR [0x%X] :0x%X\n"),&(g_vPcmciaReg->PGCR),g_vPcmciaReg->PGCR));
	for(i=0;i<PCMCIA_NUM_WINDOWS;i++) {
		DEBUGMSG(ZONE_PDD,(TEXT("\tPBR[%d] :0x%X = 0x%X\n"),i,&(g_vPcmciaReg->PBR[i]),g_vPcmciaReg->PBR[i]));
		DEBUGMSG(ZONE_PDD,(TEXT("\tPOR[%d] :0x%X= 0x%X\n"),i,&(g_vPcmciaReg->POR[i]),g_vPcmciaReg->POR[i]));
		DEBUGMSG(ZONE_PDD,(TEXT("\tPOFR[%d] :0x%X= 0x%X\n"),i,&(g_vPcmciaReg->POFR[i]),g_vPcmciaReg->POFR[i]));
	}	
}