cardx500.cpp

WinCE5.0部分核心源码

    if (!cmdEnable(card)) {
        return FALSE;
        }

    GetCmdStatus(card, CMD_X500_EnableAll);

    BOOLEAN Acked       = FALSE;
    BOOLEAN associated  = FALSE;
    for (int i = 0; (i < 3) && (FALSE == CQIsFull(card->fidQ)); i++) {
        FID fid = AllocNextFid(card);

        if (0 == fid) {
            LogError( card, NDIS_ERROR_CODE_HARDWARE_FAILURE, 0x00080000 |HARDWARE_FAILURE);
            return FALSE;
            }
        
        fidCounter++;
        FidArray[ i ] = fid;
        CQStore( card->fidQ, fid );                 
        }
    
#if NDISVER == 3  || NDISVER == 41
    // delay 2 seconds, waiting for a status link 
    for (i = 0; i < 2000; i++) {
        NdisRawReadPortUshort( card->m_IOBase+REG_INT_STAT, &usWord );

        if (usWord & EVNT_STAT_CMD) {
            AckCmdInterrupt(card);
        }

        if (usWord & EVNT_STAT_LINK) {
            break;
        }
    }
#endif

    card->m_IsPolling   = FALSE;
    card->m_CardStarted = TRUE;
    card->m_CardPresent = TRUE;
    card->m_PrevCmdDone = TRUE;

    if (card->m_MaxPSP) {
        cmdSleep(card);
    }

#ifdef MICROSOFT
    //spb026
    if (TRUE == card->flashCard) {
       card->flashCard=FALSE;   
       FlashImage(card);
    }
#endif

    return TRUE;
}


void InitInterrupts( PCARD card )
{
    card->m_IntMask     =  card->m_MaxPSP ?
        (USHORT)(INT_EN_Rx| INT_EN_Tx   | INT_EN_TxExc | INT_EN_CMD | INT_EN_AWAKE | INT_EN_LINK):
        (USHORT)(INT_EN_Rx | INT_EN_Tx  | INT_EN_TxExc | INT_EN_CMD | INT_EN_LINK );
  
    if (card->m_InterruptRegistered ) 
        NdisRawWritePortUshort( card->m_IOBase+REG_INT_EN, card->m_IntMask );
    else
        NdisRawWritePortUshort( card->m_IOBase+REG_INT_EN, 0 );

}


//===========================================================================
    void SetUserConfig (PCARD card, CFG_X500 &cfg)
//===========================================================================
// 
// Description: Overlay "advanced" fields on top of the specified cfg structure.
//    
//      Inputs: card    - pointer to card structure.
//              cfg     - reference to config structure on which we'll overlay
//                        registry info.
//    
//     Returns: nothing
//---------------------------------------------------------------------------
{
    cfg.TxMSDULifetime  = 1500; // 1.5 second;      
    // 
    // Grab the real mac address from the cfg structure.
    // 
    memcpy(card->m_PermanentAddress, cfg.MacId, sizeof(card->m_StationAddress));
    memcpy(card->m_profiles[0].zFlags.cfg.MacId, cfg.MacId, sizeof(card->m_StationAddress));

    // 
    // Use the default zflags if they're valid.
    // 
    if (card->m_profiles[0].isValid) {
        cfg = card->m_profiles[0].zFlags.cfg;
        }
    // 
    // Overide the MAC address if necessary.
    // 
    if (card->m_MacIdOveride) {
        memcpy(cfg.MacId, card->m_StationAddress, sizeof(card->m_StationAddress));
        }
    else {
        memcpy(card->m_StationAddress, cfg.MacId, sizeof(card->m_StationAddress));
        }
    
    memcpy(cfg.NodeName, card->m_AdapterName, 16);

    cfg.OpMode          = card->m_InfrastructureMode;       
    cfg.PowerSaveMode   = card->m_PowerSaveMode;
    card->m_MaxPSP      = (card->m_PowerSaveMode >= 3) && (1 & card->capabilities.u16SoftwareCapabilities);
    
    if (2 < cfg.PowerSaveMode) {
        cfg.PowerSaveMode -= 2;
        }
    // 
    // added INT_EN_AWAKE per Ned.  (jbeaujon 11/01/00) 
    // 
    // removed INT_EN_AWAKE per Ned.  (jbeaujon 11/14/00)
    // 
    if (card->m_MaxPSP) {
        cfg.MaxPowerSave = INT_EN_CMD | INT_EN_Rx | INT_EN_Tx | INT_EN_TxExc | INT_EN_LINK;
/*
        cfg.MaxPowerSave = INT_EN_CMD | INT_EN_Rx | INT_EN_Tx | INT_EN_TxExc | INT_EN_LINK | INT_EN_AWAKE;
*/
        }
    
    if (card->m_TransmitPower) {
        cfg.TransmitPower = card->m_TransmitPower;
        }

    STSUPRATES  *pSel = SUPPORTED_RATES;
    while ((0xFFFF != pSel->SelectedRate) && (pSel->SelectedRate != card->m_SelectedRate)) {
        ++pSel;
        }
    
    if (0xFFFF == pSel->SelectedRate) {
        memcpy( card->m_SupportedRates, cfg.SupRates, sizeof(cfg.SupRates));
        card->m_LinkSpeed = pSel->LinkSpeed;
        }
    else if (pSel->SelectedRate) {
        memcpy(card->m_SupportedRates, pSel->SupRates, sizeof(cfg.SupRates));
        memcpy(cfg.SupRates, pSel->SupRates, sizeof(cfg.SupRates));
        card->m_LinkSpeed = pSel->LinkSpeed;
        }
    else {  // auto mode
        while ((0xFFFF != pSel->SelectedRate) && strcmp(card->m_CardName, pSel->CardName)) {
            ++pSel;
            }

        card->m_LinkSpeed = pSel->LinkSpeed;
        if (0xFFFF != pSel->SelectedRate) {
            memcpy( cfg.SupRates, pSel->SupRates, sizeof(cfg.SupRates));        
            }
        }
    
    switch (0xFFFF & card->m_MagicPacketMode) {
        case 0:             //Broadcast/Multicast/Unicast = ignore nothing
            cfg.MagicMode = MPA_STAUSCHANGE; 
            break;

        case 1:             //Broadcast/Unicast  = ignore multicast
            cfg.MagicMode = MPM_NOMULTICAST | MPA_STAUSCHANGE; 
            break;

        case 2:             //Unicast = ignore broadcast
            cfg.MagicMode = MPM_NOBROADCAST | MPM_NOMULTICAST | MPA_STAUSCHANGE;
            break;

        case 0xFFFF:

        default:
            break;
        }
}

//===========================================================================
    void SetUserSSID (PCARD card, STSSID &ssid)
//===========================================================================
// 
// Description: Overlay "advanced" fields on top of the specified ssid structure.
//    
//      Inputs: card    - pointer to card structure.
//              ssid    - reference to ssid structure on which we'll overlay
//                        registry info.
//    
//     Returns: nothing
//---------------------------------------------------------------------------
{
    if (card->m_profiles[0].isValid) {
        ssid = card->m_profiles[0].zFlags.SSIDList;
        }
    ssid.Len1 = card->m_ESS_IDLen1;
    if (card->m_ESS_IDLen1) {
    	// PREFIX #50063
        memcpy(ssid.ID1, card->m_ESS_ID1, min(sizeof(ssid.ID1), card->m_ESS_IDLen1));
        }
}

//===========================================================================
    void SetUserAPs (PCARD card, STAPLIST &aps)
//===========================================================================
// 
// Description: Overlay "advanced" fields on top of the specified aps structure.
//    
//      Inputs: card    - pointer to card structure.
//              aps     - reference to ap list structure on which we'll overlay
//                        registry info.
//    
//     Returns: nothing
//---------------------------------------------------------------------------
{
    if (card->m_profiles[0].isValid) {
        aps = card->m_profiles[0].zFlags.APList;
        }
}

//===========================================================================
    NDIS_STATUS cbResetCard (OUT PBOOLEAN   AddressingReset, 
                             IN NDIS_HANDLE Context)
//===========================================================================
// 
// Description: 
//    
//      Inputs: 
//    
//     Returns: 
//---------------------------------------------------------------------------
{
    
    PCARD card = (PCARD)Context;

#ifndef UNDER_CE
    USHORT  usWord;
#endif

#if NDISVER == 3

    //*AddressingReset = FALSE;
    //turn  NDIS_STATUS_NOT_RESETTABLE;
    BOOLEAN IsInserted = IsCardInserted(card);

    if (IsInserted && card->m_CardPresent) {    // same ol same ol
        PRINT("RESET");
        CQReset(card->m_Q);
        *AddressingReset = FALSE;
        //

        PNDIS_PACKET    Packet;
        while (Packet = (PNDIS_PACKET)CQGetNext(card->m_Q)) {
            NdisMSendComplete(  card->m_MAHandle, Packet, NDIS_STATUS_SUCCESS );
            }
        //return    NDIS_STATUS_SUCCESS;
        }
    else if (IsInserted && ! card->m_CardPresent) {  // just inserted
        CQReset(card->fidQ);        
        CQReset(card->m_Q);
        InitHW(card );  
        InitInterrupts( card );
        }

    else if (!IsInserted && card->m_CardPresent) {   // just removed
        card->m_CardStarted = FALSE;
        card->m_CardPresent = FALSE;
        }
    else {   // !IsInserted && !card->m_CardPresent 
        }

    return  NDIS_STATUS_SUCCESS;

#elif NDISVER == 5


#ifndef UNDER_CE
    NdisAcquireSpinLock(&card->m_lock);

    while (card->m_TxHead) {
        NdisReleaseSpinLock(&card->m_lock);
        NdisMSendComplete(card->m_MAHandle, card->m_TxHead, NDIS_STATUS_SUCCESS);
        NdisAcquireSpinLock(&card->m_lock);
        DequeuePacket(card->m_TxHead, card->m_TxTail);
        }   
    NdisReleaseSpinLock(&card->m_lock);

#else
{
    NDIS_PACKET     *pNdisPacket;
    
    NdisAcquireSpinLock(&card->m_lock);
    while (pNdisPacket = card->m_TxHead) {
        DequeuePacket(card->m_TxHead, card->m_TxTail);        
        NdisReleaseSpinLock(&card->m_lock);
        NdisMSendComplete(card->m_MAHandle, pNdisPacket, NDIS_STATUS_FAILURE);
        NdisAcquireSpinLock(&card->m_lock);
        }   
    NdisReleaseSpinLock(&card->m_lock);
}    

#endif

    *AddressingReset = FALSE;

    return  NDIS_STATUS_SUCCESS;
#endif
}

//===========================================================================
    BOOLEAN FindCard (PCARD card)
//===========================================================================
// 
// Description: 
//    
//      Inputs: 
//    
//     Returns: 
//---------------------------------------------------------------------------
{
    USHORT  usWord;
    ULONG   port[]      = {REG_CMD_P0};
    USHORT  cmp[]       = {0x0000, 0xAA55, 0x55AA};
    int     portSize    = sizeof(port) / sizeof(port[0]);
    int     cmpSize     = sizeof(cmp) / sizeof(cmp[0]);
    
    //spbMgc Make sure Attribue Memory is registered before we use it.   
    if (card->IsAMCC && card->m_AttribMemRegistered) {
        USHORT  usWord;
        // get the control register;
        NdisReadRegisterUshort((USHORT *)(card->m_ContolRegMemBase+0x38), &usWord);
        //enable the interrupt register.
        usWord |= 0x02000;
        NdisWriteRegisterUshort((USHORT *)(card->m_ContolRegMemBase+0x38), usWord);
        //
        NdisWriteRegisterUshort((USHORT *)(card->m_pAttribMemBase+0x3E0), 0x0045);
        //NdisWriteRegisterUshort( (USHORT *)(card->m_RadioMemBase+0x3E0), 0x0045 );        // only because we don't know which is which
        }
    // 
    // enable FULL Micro ISA Over ISA fulll IO range  
    // 
    NdisRawWritePortUchar(card->m_IOBase+ 6 , 0x2000);    // must be first
    NdisRawWritePortUchar(card->m_IOBase+ 7 , 0x20);      // must be second
    // 
    // enable FULL Micro ISA fulll IO range  
    // 
    if (card->m_PortIOLen8Bit) {
        NdisRawWritePortUchar(card->m_IOBase8Bit+ 7 , 0x20);
        }

    //cmdReset(card);

    for (int j = 0; j < portSize; j++) {
        for (int i = 0; i < cmpSize; i++) {
            NdisRawWritePortUshort(card->m_IOBase+port[j], cmp[i]);
            NdisRawReadPortUshort(card->m_IOBase+port[j], &usWord);
            if (cmp[i] != usWord) {
                return FALSE;
                }
            }
        }
    NdisRawWritePortUshort(card->m_IOBase+REG_AUX_PAGE, 0x0000);
    NdisRawWritePortUshort(card->m_IOBase+REG_AUX_OFF, 0x0000);
    NdisRawReadPortUshort(card->m_IOBase+REG_AUX_DATA, &usWord);

    if (0x0000 != usWord) {
        return FALSE;
        }
    
    NdisRawReadPortUshort(card->m_IOBase+REG_AUX_DATA, &usWord);
    if ((0xFFF0 & cmp[cmpSize-1]) != (0xFFF0 & usWord)) {
        return FALSE;
        }

    NdisRawWritePortUshort(card->m_IOBase+REG_SWS0, 0x0000);
    NdisRawWritePortUshort(card->m_IOBase+REG_SWS1, 0x0000);
    NdisRawWritePortUshort(card->m_IOBase+REG_CMD, 0x0000);

    usWord = 0x8000;
    USHORT usFlashCode;

    for (j = 4000; j && (usWord & 0x8000); j-- ) {
        NdisRawReadPortUshort(card->m_IOBase+REG_CMD, &usWord);
        NdisRawReadPortUshort(card->m_IOBase+REG_SWS1, &usFlashCode);
        if (0x33 == (0xff & usFlashCode)) {
            card->m_CardFirmwareErr = TRUE;
            break;
            }
        DelayMS( 1 );       
        }

    usWord = 0;
    for (j = 4000; !card->m_CardFirmwareErr && j && 0==usWord; j--) {
        NdisRawReadPortUshort(card->m_IOBase+REG_INT_STAT, &usWord);
        usWord &= EVNT_STAT_CMD;
        DelayMS( 1 );       
        }
    
    AckCmdInterrupt(card);

    return (j > 0) || card->m_CardFirmwareErr;  
}

void            
UpdateCounters(PCARD    card)
{
    if( ! card->IsAwake )
        return;

    STSTATISTICS32  st;         
    cmdStatistics32Get(card, &st );

    card->m_FramesXmitGood          = st.HostTxMc+st.HostTxBc+st.HostTxUc;      // Good Frames Transmitted
    card->m_FramesXmitBad           = st.HostTxFail;                            // Bad Frames Transmitted
    card->m_FramesRcvGood           = st.HostRxMc+st.HostRxBc+st.HostRxUc;      // Good Frames Received
    card->m_FramesRcvBad            = st.HostRxDiscard;         // CRC errors counted
    card->m_FramesRcvOverRun        = st.RxOverrunErr;                          // missed packet counted
    card->m_FramesXmitOneCollision  = st.TxSinColl;                             // Frames Transmitted with one collision
    card->m_FramesXmitManyCollisions= st.TxMulColl;                             // Frames Transmitted with > 1 collision
}

BOOLEAN
RxFidSetup(PCARD card)
{
    USHORT  fid;
#ifndef UNDER_CE
    USHORT  usWord;
#endif
    NdisRawReadPortUshort( card->m_IOBase+REG_FID_RX, &fid);        // Get the FID value
    return BapSet(card, REG_BAPrx_SEL, fid, sizeof(RXFID_HDR) ); //off* );
}


BOOLEAN 
IsCardInserted( 
    PCARD card 
    )
{
    USHORT  usWord;
    NdisRawReadPortUshort( card->m_IOBase+REG_INT_EN, &usWord);     
    return 0xFFFF != usWord; 
}