pcmsock.cpp

Windows CE 6.0 BSP for VOIPAC Board (PXA270) Version 2b.

    }

    Unlock();
    return CERR_SUCCESS;
}


void CPcmciaCardSocket::PowerMgrCallback( BOOL bPowerOff )
{
    SS_SOCKET_STATE sSocketState = m_SockState;
    sSocketState.dwEventChanged  = SOCK_EVENT_SUSPEND_RESUME;
    sSocketState.dwEventStatus   = (bPowerOff ?
                                   SOCK_EVENT_CD :
                                   (SOCK_EVENT_CD |
                                   SOCK_EVENT_SUSPEND_RESUME ) );
    m_pBridge->CallBackToCardService(m_pBridge->GetSocketNumber(),
                                     GetSocketHandle(),
                                     &sSocketState );
}


void CPcmciaCardSocket::PowerMgr( BOOL bPowerDown )
{
}


BOOL CPcmciaCardSocket::Resuming() // This routine can not call sleep because it could endup yeild to other thread.
{
    return(FALSE);
}

//
// PDCardSetSocket
//
// @func    STATUS | PDCardSetSocket | Set the socket state of the specified socket.
// @rdesc   Returns one of the CERR_* return codes in cardserv.h.
//
// @comm    This function sets the specified socket's state and adjusts the socket
//          controller appropriately.
//          PDCardGetSocketState will usually be called first and adjustments will
//          be made to the PDCARD_SOCKET_STATE structure before PDCardSetSocketState
//          is called.  This avoids duplicated socket state on different layers and
//          it avoids unintentionally setting socket parameters.
//
// @xref <f PDCardGetSocketState>
//
STATUS CPcmciaCardSocket::CardSetSocket(PSS_SOCKET_STATE pState)
{
    STATUS retValue = CERR_SUCCESS;

    if(m_pBridge && pState)
    {
        Lock();

        // Indicate to the memory controller that a card is present in the socket.
        //
        m_pMemCtrlRegs->mecr = 0x00000003;

        m_SockState.dwEventMask     = pState->dwEventMask;
        m_SockState.dwEventChanged &= ~pState->dwEventChanged;

        //
        // Check the power settings for the socket.
        //
        if( ( pState->dwEventStatus & SOCK_EVENT_EJECT ) != 0 ||
            ( pState->dwEventStatus & SOCK_EVENT_INSERT ) != 0 )
        {
            // Ask for ejection of the card.
            DEBUGMSG( ZONE_PDD,
                      ( TEXT( "PDCardSetSocket  PCMSocket. Gernerate Artificial Eject\r\n" ) ) );
            // We have to force 
            m_pBridge->ForceEjectEvent(m_pBridge->GetSlotNumber());
        }
        else
        if ((pState->fVcc  != m_SockState.fVcc) ||
            (pState->uVpp1 != m_SockState.uVpp1)||
            (pState->uVpp2 != m_SockState.uVpp2))
        {
            // We don't support changing Vpp.
            if (pState->uVpp1 != pState->uVpp2 ||
                m_SockState.uVpp1 != pState->uVpp1 ||
                m_SockState.uVpp2 != pState->uVpp2)
            {
                Unlock();
                return(CERR_BAD_VPP);
            }
    
            if ((pState->fVcc & SOCK_VCC_LEVEL_MASK ) >= NUM_POWER_ENTRIES ||
               !(m_rgPowerEntries[pState->fVcc & SOCK_VCC_LEVEL_MASK].fSupply & PWR_SUPPLY_VCC))
            {
                Unlock();
                return (CERR_BAD_VCC);
            }
            else
            {
                retValue = CardPowerHandler(m_rgPowerEntries[pState->fVcc & SOCK_VCC_LEVEL_MASK].uPowerLevel);

                if (retValue == CERR_SUCCESS)
                {
                    m_SockState.fVcc  = pState->fVcc;
                    m_SockState.uVpp1 = pState->uVpp1;
                    m_SockState.uVpp2 = pState->uVpp2;
                }
            }
        }

	       Unlock();
    }

    return (STATUS)retValue;
}


STATUS CPcmciaCardSocket::CardPowerHandler(UINT8 nVcc)
{
    XLLP_STATUS_T retValue = XLLP_STATUS_FAILURE;

    switch(nVcc)
    {
    case 0:  // Off
        if(m_pBridge->GetSlotNumber() == 0) 
        {
            RETAILMSG(TRUE, (TEXT("INFO: Setting PCCARD slot 0 voltage to 0v (off).\r\n")));
            retValue = XllpPCCardPowerOff(m_pstrPCCardSocketHandle, XLLP_PCCARD_SOCKET0);
        }
        else
        {
            RETAILMSG(TRUE, (TEXT("INFO: Setting PCCARD slot 1 voltage to 0v (off).\r\n")));
            retValue = XllpPCCardPowerOff(m_pstrPCCardSocketHandle, XLLP_PCCARD_SOCKET1);
        }
        break;

    case 33:  // 3.3v
        if (m_pBridge->GetSlotNumber() == 0) 
        { 
            RETAILMSG(TRUE, (TEXT("INFO: Setting PCCARD slot 0 voltage to 3.3v).\r\n")));
            retValue = XllpPCCardPowerOn(m_pstrPCCardSocketHandle, XLLP_PCCARD_SOCKET0, XLLP_PCCARD_3_30VOLTS);
        } 
        else 
        {
            RETAILMSG(TRUE, (TEXT("INFO: Setting PCCARD slot 1 voltage to 3.3v).\r\n")));
            retValue = XllpPCCardPowerOn(m_pstrPCCardSocketHandle, XLLP_PCCARD_SOCKET1, XLLP_PCCARD_3_30VOLTS);
        }
        break;

    case 50:  // 5.0v
        if (m_pBridge->GetSlotNumber() == 0) 
        { 
            RETAILMSG(TRUE, (TEXT("INFO: Setting PCCARD slot 0 voltage to 5.0v).\r\n")));
            retValue = XllpPCCardPowerOn(m_pstrPCCardSocketHandle, XLLP_PCCARD_SOCKET0, XLLP_PCCARD_5_00VOLTS);
        } 
        else 
        {
            RETAILMSG(TRUE, (TEXT("INFO: Setting PCCARD slot 1 voltage to 5.0v).\r\n")));
            retValue = XllpPCCardPowerOn(m_pstrPCCardSocketHandle, XLLP_PCCARD_SOCKET1, XLLP_PCCARD_5_00VOLTS);
        }
        break;

    default:
        break;
    }

    return((retValue == XLLP_STATUS_SUCCESS) ? CERR_SUCCESS : CERR_BAD_VCC);

}


void CPcmciaCardSocket::PowerCycleEvent()
{
    m_pBridge->PowerCycleEvent(m_pBridge->GetSlotNumber());
}


//
// ResetSocket - do a PCMCIA reset
// return CERR_SUCCESS on success, CERR_UNSUPPORTED_SERVICE if size is anomolous
//
STATUS CPcmciaCardSocket::CardResetSocket()
{
	STATUS        retValue          = CERR_SUCCESS;
	BOOL          bCardDetectStatus = FALSE;
    XLLP_UINT32_T uiCardVoltage     = 0;
    UINT16        nSlotNumber       = 0;
	UINT16 statusReg = 0;

    Lock();

    if( m_pBridge )
    {

        nSlotNumber = m_pBridge->GetSlotNumber();
 		statusReg = XllpPCCardSocketState( m_pstrPCCardSocketHandle, nSlotNumber);

       switch(nSlotNumber)
        {
        case 1:
			bCardDetectStatus = !((statusReg & PCMCIA_S1_nCD_MASK) >> 5);
            break;
        case 0:
			bCardDetectStatus = !((statusReg & PCMCIA_S0_nCD_MASK) >> 5);
            break;
        default:
            retValue = CERR_BAD_SOCKET;
            break;
        }

        if ((retValue == CERR_SUCCESS) && (bCardDetectStatus == TRUE))
        {
            if (XllpPCCardGetVoltageSetting(m_pstrPCCardSocketHandle, nSlotNumber, &uiCardVoltage) != XLLP_STATUS_SUCCESS)
            {
                retValue = CERR_BAD_VCC;
                goto Done;
            }
            if (XllpPCCardPowerOff(m_pstrPCCardSocketHandle, nSlotNumber) != XLLP_STATUS_SUCCESS)
            {
                retValue = CERR_BAD_VCC;
                goto Done;
            }
            Sleep(310);
            if (XllpPCCardPowerOn(m_pstrPCCardSocketHandle, nSlotNumber, uiCardVoltage) != XLLP_STATUS_SUCCESS)
            {
                retValue = CERR_BAD_VCC;
                goto Done;
            }
            Sleep(100);
            if (XllpPCCardResetSocket(m_pstrPCCardSocketHandle, nSlotNumber) != XLLP_STATUS_SUCCESS)
            {
                retValue = CERR_GENERAL_FAILURE;
                goto Done;
            }
            m_SockState.fVcc = (uiCardVoltage ==  XLLP_PCCARD_3_30VOLTS?1:2);
            m_SockState.uVpp1 = 0;
            m_SockState.uVpp2 = 0;

            // Notify the MDD of a power-on status change.
            SocketEventHandle(SOCK_EVENT_PWRCYCLE, SOCK_EVENT_PWRCYCLE);
        }

	}

Done:
    Unlock();
    return (retValue);

}


CPcmciaCardSocket* CreatePCMCIASocket(CPcmciaBusBridge* pBridge,
                                      UINT16 m_SlotNumber )
{
    CPcmciaCardSocket* pNewSocket = new CPcmciaCardSocket(pBridge, m_SlotNumber);
    if( pNewSocket != NULL )
    {
        if( pNewSocket->CardInitWindow( pNewSocket ) )
        {
            return pNewSocket;
        }
        else
        {
            delete pNewSocket;
        }
    }
    return NULL;
}