zd1205.c

ZYDAS zd1211b driver for Linux2.4

                        (*pTxGain) --;

                break;

        case AL2230_RF:
        case AL2230S_RF:
        case AL7230B_RF:
                if (*pTxGain > AL2230_MIN_TX_PWR_SET)
                        (*pTxGain) -= 2;
                break;

        default:
                break;
        }

        HW_Write_TxGain2(&dot11Obj, TxPwrType);

}



int
zd1205_AnyActivity(struct zd1205_private *macp)
{
        unsigned long flags;

        // Any frame wait for transmission.
        spin_lock_irqsave(&macp->q_lock, flags);
        if (macp->activeTxQ->count)
        {
                spin_unlock_irqrestore(&macp->q_lock, flags);



                return 1;
        }
        spin_unlock_irqrestore(&macp->q_lock, flags);


        if ((dot11Obj.QueueFlag & MGT_QUEUE_SET) || (dot11Obj.QueueFlag & TX_QUEUE_SET))
                return 1;

        if (macp->bAnyActivity)
                return 1;

        // No any activity.
        return 0;
}


void zd1205_connect_mon(struct zd1205_private *macp)
{
        static u16 IdleLoop_Under_Seq1 = 0;

        zd_ConnectMon();
        //    if (dot11Obj.bDeviceInSleep)
        // 	printk(KERN_ERR "mon\n");
        if ((macp->cardSetting.BssType == INFRASTRUCTURE_BSS) && (macp->bPSMSupported))
        {
                if ((!dot11Obj.bChScanning) && (macp->PwrState) && (!dot11Obj.bDeviceInSleep) && (macp->bAssoc)) {
                        // Solve Sequence number duplication problem after wakeup.
                        if (!zd1205_AnyActivity(macp)) {
                                if ((macp->SequenceNum != 1) || (IdleLoop_Under_Seq1 > 20)) {
                                        //zd1205_sleep_reset(macp);
                                        IdleLoop_Under_Seq1 = 0;
                                        // Avoid accessing Registers to save computation power.
                                } else {
                                        IdleLoop_Under_Seq1++;
                                }
                                //ZD1211DEBUG(2, "IdleLoop_Under_Seq1= %d\n", IdleLoop_Under_Seq1);
                        }
                }
        }


}


void zd1205_mgt_mon_cb(struct net_device *dev)
{
        struct zd1205_private *macp = dev->priv;


#ifdef HOST_IF_USB

        defer_kevent(macp, KEVENT_MGT_MON_TIMEOUT);
        mod_timer(&(macp->tm_mgt_id), jiffies+ (1*HZ)/50); //20ms


#else

        zd1205_connect_mon(macp);
        mod_timer(&(macp->tm_mgt_id), jiffies+ (1*HZ)/50); //20ms
#endif

}


void zd1205_SwAntennaDiv(struct zd1205_private *macp)
{
#if fANT_DIVERSITY
        static u32 loop = 0;
        loop++;

        // Software Antenna Diversity Mechanism
        if (macp->bEnableSwAntennaDiv)
        {
                switch(AccState) {
                case ACC_1:
                        if ((loop % macp->Ant_MonitorDur1) == 0) {
                                if (macp->Acc_Num_OFDM)
                                        Avg1_SQ_OFDM = macp->Acc_SQ_OFDM / macp->Acc_Num_OFDM;
                                else {
                                        Avg1_SQ_OFDM = 0;

                                        if (macp->Acc_Num)
                                                Avg1_SQ = macp->Acc_SQ / macp->Acc_Num;
                                        else
                                                Avg1_SQ = 0;
                                }

                                // Higher SQ is better
                                if (((Avg1_SQ_OFDM < macp->NiceSQThr_OFDM) && (Avg1_SQ_OFDM > 0))
                                                || ((Avg1_SQ_OFDM == 0)
                                                    && ((Avg1_SQ < macp->NiceSQThr) && (Avg1_SQ > 0)))
                                                || (!macp->bAssoc)) { // disconnected
                                        SwitchAntenna(macp);
                                        AccState = ACC_2;
                                }

                                macp->Acc_SQ = 0;


                                macp->Acc_Num = 0;

                                macp->Acc_SQ_OFDM = 0;
                                macp->Acc_Num_OFDM = 0;
                        }
                        break;

                case ACC_2:
                        if ((loop % macp->Ant_MonitorDur2) == 0)
                        {
                                if (macp->Acc_Num_OFDM)
                                        Avg2_SQ_OFDM = macp->Acc_SQ_OFDM / macp->Acc_Num_OFDM;
                                else {
                                        Avg2_SQ_OFDM = 0;
                                        if (macp->Acc_Num)
                                                Avg2_SQ = macp->Acc_SQ / macp->Acc_Num;
                                        else
                                                Avg2_SQ = 0;
                                }

                                // Higher SQ is better
                                if ((Avg2_SQ_OFDM < Avg1_SQ_OFDM)


                                                || (((Avg2_SQ_OFDM == 0) && (Avg1_SQ_OFDM == 0))
                                                    && (Avg2_SQ < Avg1_SQ))
                                                || (!macp->bAssoc)) { // disconnected
                                        SwitchAntenna(macp);


                                }

                                AccState = ACC_1;
                                macp->Acc_SQ = 0;
                                macp->Acc_Num = 0;
                                macp->Acc_SQ_OFDM = 0;
                                macp->Acc_Num_OFDM = 0;
                        }

                        break;

                default:
                        break;
                }
        }
#endif
}


void zd1205_CollectHwTally(struct zd1205_private *macp)
{
        macp->hwTotalRxFrm += zd_readl(TotalRxFrm);
        macp->hwCRC32Cnt += zd_readl(CRC32Cnt);

        macp->hwCRC16Cnt += zd_readl(CRC16Cnt);
        //macp->hwDecrypErr_UNI += zd_readl(DecrypErr_UNI);
        //macp->hwDecrypErr_Mul += zd_readl(DecrypErr_Mul);
        macp->hwRxFIFOOverrun += zd_readl(RxFIFOOverrun);
        macp->hwTotalTxFrm += zd_readl(TotalTxFrm);


        macp->hwUnderrunCnt += zd_readl(UnderrunCnt);
        macp->hwRetryCnt += zd_readl(RetryCnt);
}


#define	TOLERANCE		2

int zd1205_IbssPsCheck(struct zd1205_private *macp)
{
        u32 ul_BcnItvl, ul_atimwnd;
        u64 TSFTimer;
        u32 tmpvalue;


        // Make sure that we have passed (ATIM-Window+TOLERANCE)
        ul_BcnItvl = zd_readl(ZD_BCNInterval);
        ul_BcnItvl &= 0xffff;

        ul_atimwnd = zd_readl(ZD_ATIMWndPeriod);
        tmpvalue = zd_readl(ZD_TSF_LowPart);
        TSFTimer = tmpvalue;

        tmpvalue = zd_readl(ZD_TSF_HighPart);
        TSFTimer += (((u64)tmpvalue) << 32);
        TSFTimer = TSFTimer >> 10; // in unit of TU

        //printk("TSF(TU) %d \n", TSFTimer);
        //printk("BeaconInterval = %d\n", ul_BcnItvl);
        //printk("TSF mod BeaconInterval = %d\n", (TSFTimer % ul_BcnItvl));

        if ((do_div(TSFTimer, ul_BcnItvl)) > (ul_atimwnd + TOLERANCE))
        {
                // Make sure no traffic before (ATIMWnd+TOLERANCE)
                if ((!macp->bFrmRxed1) && (macp->SuggestionMode == PS_PSM)) {
                        // Any frame wait for transmission.
                        if (!macp->activeTxQ->count) {

                                //zd1205_sleep_reset(macp);
                                return 1;
                        }
                }
        }

        return 0;
}



void zd1205_InfraPsCheck(struct zd1205_private *macp)
{
        u32 tmpvalue;

        // Now, we assure that no any power-save related operation performing.
        // That's because all power-save related operations are either
        // Mutexed by Adapter->Lock or Notified by Adapter->Notification.
        if ((macp->SuggestionMode == PS_PSM) && (macp->PwrState == PS_CAM))
        {
                down(&macp->bcn_sem);
                tmpvalue = zd_readl(ZD_BCNInterval);

                tmpvalue |= POWER_MNT;


                zd_writel(tmpvalue, ZD_BCNInterval);
                up(&macp->bcn_sem);

                macp->PwrState = PS_PSM;
                zd_EventNotify(EVENT_PS_CHANGE, (U8)macp->PwrState, 0, 0);
                ZD1211DEBUG(0, "=====CAM --> PSM\n");
        } else if ((macp->SuggestionMode == PS_CAM) && (macp->PwrState == PS_PSM) &&
                        (!dot11Obj.bDeviceInSleep))
        {
                down(&macp->bcn_sem);

                tmpvalue = zd_readl(ZD_BCNInterval);
                tmpvalue &= ~POWER_MNT;
                zd_writel(tmpvalue, ZD_BCNInterval);
                up(&macp->bcn_sem);

                macp->PwrState = PS_CAM;
                zd_EventNotify(EVENT_PS_CHANGE, (U8)macp->PwrState, 0, 0);
                ZD1211DEBUG(0, "=====PSM --> CAM\n");
        }

        return;
}

//Normally, house keeping routine is run every 100ms.
void zd1205_house_keeping(struct zd1205_private *macp)
{

        static u32 loop = 0;
        card_Setting_t *pSetting = &macp->cardSetting;
        u8 BssType = pSetting->BssType;
        u8 bAssoc = macp->bAssoc;

#if 0

        if (dot11Obj.QueueFlag & TX_QUEUE_SET)
        {
                macp->txQueSetCnt++;
                //tasklet_schedule(&macp->zd1205_tx_tasklet);
                zd_CleanupTxQ();
        }
#endif
        loop++;

#ifndef HOST_IF_USB

        while (dot11Obj.bDeviceInSleep)
        {
                // If device is in sleep, do not access device register often to
                // prevent host from slowing down.
                wait_ms(10);
        }
#else
        if (dot11Obj.bDeviceInSleep)
                return;
#endif

        // Software Antenna Diversity Mechanism
        if (macp->bEnableSwAntennaDiv)
        {
                zd1205_SwAntennaDiv(macp);
        }

        // IBSS power-save monitor
        if ((BssType == INDEPENDENT_BSS) && (bAssoc))
        {
                if ((!dot11Obj.bChScanning) && macp->bPSMSupported) {
                        if (zd1205_IbssPsCheck(macp))
                                return;
                }
        }

#if 1
        // Infrasture AP mode beacon generation
        if (BssType == AP_BSS)
        {
                down(&macp->bcn_sem);
                zd_EventNotify(EVENT_TBCN, 0, 0, 0);
                up(&macp->bcn_sem);

                if (macp->dtimCount == 0)
                        macp->dtimCount = macp->cardSetting.DtimPeriod;
                macp->dtimCount--;
        }
#endif


        //++ Recovery mechanism for ZD1202 ASIC Phy-Bus arbitration fault.
        //   We combined tx-power-tracking/Sw Antenna diversity code here to
        //   reduce the frequence of
        //   calling ReleaseCtrOfPhyReg. It's harmful to throughput.

        if ((loop % 1) == 0)
        { //every 100 ms
                //Collect HW Tally
                //zd1205_CollectHwTally(macp);  //This will make us lose CfgNextBcn interrupt

#ifdef HOST_IF_USB

                //tmpvalue = zd_readl(0x6e4);
                //macp->REG_6e4_Add += tmpvalue;
                //printk(KERN_ERR "Detect Strong Signal:%lu\n",jiffies);
                zd1211_StrongSignalDect(macp);
#endif

                // Infrastructure Power-State momitor

                if ((!dot11Obj.bChScanning) && (BssType == INFRASTRUCTURE_BSS) && (bAssoc) &&  (macp->bPSMSupported)) {
                        zd1205_InfraPsCheck(macp);
                }
        }

#ifdef HOST_IF_USB
	#ifndef ZD1211B
        zd1211_TxCalibration(macp);
#endif

        zd1211_CheckWithIPC(macp);
#endif

}

void HKeepingCB(struct net_device *dev)
{
        struct zd1205_private *macp = dev->priv;

#ifdef HOST_IF_USB

        defer_kevent(macp, KEVENT_HOUSE_KEEPING);
        mod_timer(&(macp->tm_hking_id), jiffies+ (1*HZ)/10);
#else

        zd1205_house_keeping(macp);
        mod_timer(&(macp->tm_hking_id), jiffies+ (1*HZ)/10);
#endif

}

void zd1205_CollectBssInfo(struct zd1205_private *macp, plcp_wla_Header_t *pWlanHdr, u8 *pMacBody, u32 bodyLen)
{
        u8 bssidmatched = 0;
        u8 i, j;
        u8 *pBssid;