pcmciasock.cpp

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

//------------------------------------------------------------------------------
//
// Function: CardSetSocket
//
// This function sets the specified socket's state and adjusts the socket  controller appropriately
//
// Parameters:
//      pState
//                  [in]      structure to PSS_SOCKET_STATE
//
// Returns:
//     CERR_SUCCESS on success or a Socket service error code on failure
//
//------------------------------------------------------------------------------
STATUS CPcmciaSocket::CardSetSocket( PSS_SOCKET_STATE pState )
{
	Lock();
	STATUS status = CERR_SUCCESS;

	if( m_pBridge && pState )
	{    	
		INT32 tmp;
		
 		DEBUGMSG( ZONE_PDD,
    		( TEXT( "++CPcmciaSocket::CardSetSocket: 	eventchanged=0x%x eventstatus=0x%x,dwEventMask=0x%x 	fIREQRouting=0x%x, fVcc=0x%x, \r\n\t dwInterfaceType=0x%X, dwInteruptStatus=0x%x\r\n" ),
	      	pState->dwEventChanged,
	      	pState->dwEventStatus,
	      	pState->dwEventMask,
	      	pState->fIREQRouting,
	      	pState->fVcc, 
	      	pState->dwInterfaceType ,
	      	pState->dwInteruptStatus ) );

		// update EventMask and clear the EventChanged status
        m_SocketState.dwEventMask = pState->dwEventMask;
        m_SocketState.dwEventChanged &= ~pState->dwEventChanged;

        m_SocketState.dwInterfaceType= pState->dwInterfaceType;

		m_SocketState.dwInteruptStatus = pState->dwInteruptStatus;
		m_SocketState.fIREQRouting = pState->fIREQRouting;

		if( ( pState->dwEventStatus & SOCK_EVENT_EJECT ) != 0 ||
          		( pState->dwEventStatus & SOCK_EVENT_INSERT ) != 0 )
		{
			DEBUGMSG( ZONE_PDD,
                     ( TEXT( "\tGenerate Artificial Eject\r\n" ) ) );
			CardInjectEvent();
			goto pcss_exit;
		}
						
		if ((pState->fVcc & SOCK_VCC_LEVEL_MASK) >= NUM_POWER_ENTRIES ||
			!(m_rgPowerEntries[pState->fVcc & SOCK_VCC_LEVEL_MASK].fSupply & PWR_SUPPLY_VCC))	
		{
			DEBUGMSG( ZONE_PDD,
                     ( TEXT( "\t ERROR CERR_BAD_VCC\r\n" ) ) );
			status = CERR_BAD_VCC;		
			goto pcss_exit;
		}

		
		// If new card has different power setting for VCC (ignore VPP). Otherwise, use previous setting
		if ((pState->fVcc & SOCK_VCC_LEVEL_MASK) != (m_SocketState.fVcc & SOCK_VCC_LEVEL_MASK)) 
		{
			m_SocketState.fVcc = pState->fVcc;
			PowerOnProcedure(m_SocketState.fVcc);
		} 


		tmp = 0;
		
		if(!m_pBridge->IsPollingMode())
		{
			tmp = PCMCIA_PER_ERRORINTR_EN; // Enable Error interrupt
	 
			if (m_SocketState.dwEventMask & SOCK_EVENT_CD) {
				tmp |= PCMCIA_PER_CARDDETECT_EN;
			}	 
			if (m_SocketState.dwEventMask & SOCK_EVENT_BVD1)	{
				tmp |= PCMCIA_PER_BVD1_STSCHG_EN;
			}
			if (m_SocketState.dwEventMask & SOCK_EVENT_BVD2) {
				tmp |= PCMCIA_PER_BVD2_SPKRIN_EN;
			}		
		}

		if (m_SocketState.dwInteruptStatus & SOCK_INT_FUNC_IRQ_ROUTING) {
			tmp |= PCMCIA_PER_RDY_LOWINTR_EN;		
		}	

		if(tmp != g_vPcmciaReg->PER)
		{
			g_vPcmciaReg->PER = tmp; 
			DEBUGMSG(ZONE_PDD,(TEXT("\tSetSocket PER:0x%X\n\r"),g_vPcmciaReg->PER));
		}
		
pcss_exit:
		
		DEBUGMSG(ZONE_PDD,(TEXT("--PCCARD: CPcmciaSocket::CardSetSocket \n\r")));
	
    }
    else
	{
    	status = CERR_BAD_SOCKET;
    }

	Unlock();

	return status;       
}

//------------------------------------------------------------------------------
//
// Function: PowerCycleEvent
//
// This function informs about power cycle event
//
// Parameters:
//             None
//
// Returns:
//     None
//
//------------------------------------------------------------------------------
void CPcmciaSocket::PowerCycleEvent()
{
	DEBUGMSG(ZONE_PDD,(TEXT("\tCPcmciaSocket::PowerCycleEvent fake event\n\r")));
    m_pBridge->PowerCycleEvent( );
}

//------------------------------------------------------------------------------
//
// Function: PowerOnProcedure
//
// This function sets the voltage level of the socket controller and resets it
//
// Parameters:
//      fVcc
//                  [in]      voltage to set the socket controller
//
// Returns:
//     None
//
//------------------------------------------------------------------------------
void CPcmciaSocket::PowerOnProcedure( UINT8 fVcc)
{
	DWORD tmp;
	
	//
	// Set socket power	as requested.
	//
	switch (m_rgPowerEntries[fVcc & SOCK_VCC_LEVEL_MASK].uPowerLevel)
	{
		case 0:
			// Set 0 Volt
			m_SocketState.dwInteruptStatus &= ~SOCK_INT_FUNC_IRQ_ROUTING; 
			m_pBridge->SetPccPower(0, FALSE);
			DEBUGMSG(ZONE_PDD,(TEXT("\tSet VCC 0\n\r")));			
			break;
		
		case 33:			
			// Set for 3.3 Volt
			DEBUGMSG(ZONE_PDD,(TEXT("\tSet VCC 33\n\r")));
			m_pBridge->SetPccPower(33, FALSE);
			break;
		case 50:
			// Set for 5 Volt
			m_pBridge->SetPccPower(50, FALSE);
			DEBUGMSG(ZONE_PDD,(TEXT("\tSet VCC 50\n\r")));
			break;
		
		default:
			DEBUGMSG(ZONE_PDD,(TEXT("\t Unknown Voltage\n\r")));
			break;
	}

	// Reset socket - after changing the power voltage
	//Sleep(100);
	
	PCMCIA_RESET_SOCKET();
	Sleep(100);
	PCMCIA_SET_SOCKET(); // Clear reset bit

	//PcPrintGpioReg();
	//SOCKETDelay(100000);
	//Sleep(1000);

	// Now set Control Register
	tmp = g_vPcmciaReg->PGCR;
	if(m_rgPowerEntries[fVcc & SOCK_VCC_LEVEL_MASK].uPowerLevel != 0) 
	{
		tmp |= (PCMCIA_PGCR_OUTPUTEN);
	}

	tmp &= ~PCMCIA_PGCR_LOWPWRMODE; // set as normal mode
	
	g_vPcmciaReg->PGCR = tmp;

	// if card is inserted and fVcc voltage is there, need to wait until READY
	if(IS_CARD_INSERTED(g_vPcmciaReg->PIPR) && (m_rgPowerEntries[fVcc & SOCK_VCC_LEVEL_MASK].uPowerLevel!=0)){
		while((g_vPcmciaReg->PIPR& CSP_BITFVAL(PCMCIA_PIPR_RDY, PCMCIA_PIPR_RDY_RDY)) == 0){
			DEBUGMSG(ZONE_PDD, (TEXT("g_vPcmciaReg->PIPR=0X%x\r\n"), g_vPcmciaReg->PIPR));
			Sleep(10);	
		}
	}
	
	//PcPrintPcmciaReg();
	//SOCKETDelay(1000);

    PowerCycleEvent();
}

//------------------------------------------------------------------------------
//
// Function: CardInjectEvent
//
// This function sets the specified socket's state and adjusts the socket  controller appropriately
//
// Parameters:
//      None
//
// Returns:
//     None
//
//------------------------------------------------------------------------------
void CPcmciaSocket::CardInjectEvent()
{
    m_pBridge->CardInjectEvent();
}

//------------------------------------------------------------------------------
//
// Function: CardSetSocket
//
// This function resets the socket controller
//
// Parameters:
//      None
//
// Returns:
//     CERR_SUCCESS on success or a Socket service error code on failure
//
//------------------------------------------------------------------------------
STATUS CPcmciaSocket::CardResetSocket()
{
	Lock();
	STATUS status = CERR_SUCCESS;
	DWORD cardstatus = GET_CARD_STATUS();
	
 	if( m_pBridge )
   	{		

		DEBUGMSG( ZONE_PDD,
              	( TEXT( "+CPcmciaSocket::CardResetSocket: eventchanged=0x%x eventstatus=0x%x,dwEventMask=0x%x \r\n \t PSCR=0x%X PIPR=0x%X\r\n" ),
                	m_SocketState.dwEventChanged,
                	m_SocketState.dwEventStatus,
                	m_SocketState.dwEventMask,
                	GET_CARD_STATUS_CHANGE(),
                	GET_CARD_STATUS()) );

		// Check if card still exist	
		if (!IS_CARD_INSERTED(cardstatus)) {
			status = CERR_NO_CARD;
		}
		else
		{
			m_SocketState.fVcc = PCMCIA_VCC_DEFAULT_INDEX;
			m_SocketState.uVpp1 = 0;
			m_SocketState.uVpp2 = 0;
			//CardSetSocket(&SockState);

			PowerOnProcedure(m_SocketState.fVcc );
		}
		
	}
	else{
		status = CERR_BAD_SOCKET;
	}

	Unlock();

	DEBUGMSG( ZONE_PDD,
              	( TEXT( "-CPcmciaSocket::CardResetSocket: eventchanged=0x%x eventstatus=0x%x,dwEventMask=0x%x \r\n \t PSCR=0x%X PIPR=0x%X\r\n" ),
                	m_SocketState.dwEventChanged,
                	m_SocketState.dwEventStatus,
                	m_SocketState.dwEventMask,
                	GET_CARD_STATUS_CHANGE(),
                	GET_CARD_STATUS()) );
		
	return status;	    	
}

//------------------------------------------------------------------------------
//
// Function: SocketEventHandle
//
// This function updates the card service layer about the socket events
//
// Parameters:
//      dwEvent
//                  [in]      socket event
//      dwPresentStateReg
//                  [in]      socket events to notify the card service layer
//
// Returns:
//     None
//
//------------------------------------------------------------------------------
void CPcmciaSocket::SocketEventHandle( DWORD dwEvent, DWORD dwPresentStateReg ) // Event Handle from Interrupt.
{
    SS_SOCKET_STATE sSockState;

    DEBUGMSG( ZONE_PDD, (TEXT("==>SocketEventHandle dwEvent=0x%X dwPresentStateReg=0x%X\r\n"), dwEvent, dwPresentStateReg));
   
    Lock();
    CardGetSocket( &sSockState );
    // Update the state from interrupt. But not card detection. Card detection event
    // generate during object creation.
    sSockState.dwEventChanged &= ~SOCK_EVENT_CD;
    if( ( dwPresentStateReg & EVENT_MASK_POWER_CYCLE ) != 0 )
    {
        sSockState.dwEventStatus |= SOCK_EVENT_PWRCYCLE;
        sSockState.dwEventChanged |= SOCK_EVENT_PWRCYCLE;
    }
    Unlock();

    m_pBridge->CallBackToCardService( GetSocketHandle(),
                                      &sSockState );
                                      
    DEBUGMSG( ZONE_PDD, (TEXT("<==SocketEventHandle\r\n")));
}