void zfCoreSetKeyComplete(zdev_t* dev)
{
zmw_get_wlan_dev(dev);
zmw_declare_for_critical_section();
#if 0
wd->sta.flagKeyChanging = 0;
#else
if(wd->sta.flagKeyChanging)
{
zmw_enter_critical_section(dev);
wd->sta.flagKeyChanging--;
zmw_leave_critical_section(dev);
}
#endif
zm_debug_msg1(" zfCoreSetKeyComplete--- ", wd->sta.flagKeyChanging);
zfPushVtxq(dev);
}
u8_t zfScanMgrScanEventTimeout(zdev_t* dev)
{
u16_t nextScanFrequency = 0;
u8_t temp;
zmw_get_wlan_dev(dev);
zmw_declare_for_critical_section();
zmw_enter_critical_section(dev);
if ( wd->sta.scanFrequency == 0 )
{
zmw_leave_critical_section(dev);
return -1;
}
nextScanFrequency = zfChGetNextChannel(dev, wd->sta.scanFrequency,
&wd->sta.bPassiveScan);
if ( (nextScanFrequency == 0xffff)
|| (wd->sta.scanFrequency == zfChGetLastChannel(dev, &temp)) )
{
u8_t currScanType;
u8_t isExternalScan = 0;
u8_t isInternalScan = 0;
//zm_debug_msg1("end scan = ", KeQueryInterruptTime());
wd->sta.scanFrequency = 0;
zm_debug_msg1("scan 1 type: ", wd->sta.scanMgr.currScanType);
zm_debug_msg1("scan channel count = ", wd->regulationTable.allowChannelCnt);
//zfBssInfoRefresh(dev);
zfTimerCancel(dev, ZM_EVENT_TIMEOUT_SCAN);
if ( wd->sta.bChannelScan == FALSE )
{
zm_debug_msg0("WOW!! scan is cancelled\n");
zmw_leave_critical_section(dev);
goto report_scan_result;
}
currScanType = wd->sta.scanMgr.currScanType;
switch(currScanType)
{
case ZM_SCAN_MGR_SCAN_EXTERNAL:
isExternalScan = 1;
if ( wd->sta.scanMgr.scanReqs[ZM_SCAN_MGR_SCAN_INTERNAL - 1] )
{
wd->sta.scanMgr.scanReqs[ZM_SCAN_MGR_SCAN_INTERNAL - 1] = 0;
isInternalScan = 1;
}
break;
case ZM_SCAN_MGR_SCAN_INTERNAL:
isInternalScan = 1;
if ( wd->sta.scanMgr.scanReqs[ZM_SCAN_MGR_SCAN_EXTERNAL - 1] )
{
// Because the external scan should pre-empts internal scan.
// So this shall not be happened!!
zm_assert(0);
}
break;
default:
zm_assert(0);
break;
}
wd->sta.scanMgr.scanReqs[currScanType - 1] = 0;
wd->sta.scanMgr.scanStartDelay = 100;
wd->sta.scanMgr.currScanType = ZM_SCAN_MGR_SCAN_NONE;
zmw_leave_critical_section(dev);
//Set channel according to AP's configuration
zfCoreSetFrequencyEx(dev, wd->frequency, wd->BandWidth40,
wd->ExtOffset, zfScanMgrEventScanCompleteCb);
wd->sta.bChannelScan = FALSE;
#if 1
if (zfStaIsConnected(dev))
{ // Finish site survey, reset the variable to detect using wrong frequency !
zfHpFinishSiteSurvey(dev, 1);
zmw_enter_critical_section(dev);
wd->sta.ibssSiteSurveyStatus = 2;
wd->tickIbssReceiveBeacon = 0;
wd->sta.ibssReceiveBeaconCount = 0;
zmw_leave_critical_section(dev);
/* #5 Re-enable RIFS function after the site survey ! */
/* This is because switch band will reset the BB register to initial value */
if( wd->sta.rifsState == ZM_RIFS_STATE_DETECTED )
{
zfHpEnableRifs(dev, ((wd->sta.currentFrequency<3000)?1:0), wd->sta.EnableHT, wd->sta.HT2040);
}
}
else
{
zfHpFinishSiteSurvey(dev, 0);
zmw_enter_critical_section(dev);
wd->sta.ibssSiteSurveyStatus = 0;
zmw_leave_critical_section(dev);
}
#endif
report_scan_result:
/* avoid lose receive packet when site survey */
//if ((zfStaIsConnected(dev)) && (!zfPowerSavingMgrIsSleeping(dev)))
//{
// zfSendNullData(dev, 0);
//}
if ( isExternalScan )//Quickly reboot
{
if (wd->zfcbScanNotify != NULL)
{
wd->zfcbScanNotify(dev, NULL);
}
}
if ( isInternalScan )
{
//wd->sta.InternalScanReq = 0;
zfStaReconnect(dev);
}
return 0;
}
else
{
wd->sta.scanFrequency = nextScanFrequency;
//zmw_enter_critical_section(dev);
zfTimerCancel(dev, ZM_EVENT_IN_SCAN);
zmw_leave_critical_section(dev);
zm_debug_msg0("scan 2");
zfCoreSetFrequencyV2(dev, wd->sta.scanFrequency, zfScanMgrEventSetFreqCompleteCb);
return 1;
}
}
/*
* Control Adaptive Noise Immunity Parameters
*/
u8_t zfHpAniControl(zdev_t *dev, ZM_HAL_ANI_CMD cmd, int param)
{
typedef s32_t TABLE[];
struct zsHpPriv *HpPriv;
struct zsAniState *aniState;
zmw_get_wlan_dev(dev);
HpPriv = (struct zsHpPriv *)wd->hpPrivate;
aniState = HpPriv->curani;
switch (cmd)
{
case ZM_HAL_ANI_NOISE_IMMUNITY_LEVEL:
{
u32_t level = param;
if (level >= ARRAY_SIZE(HpPriv->totalSizeDesired)) {
zm_debug_msg1("level out of range, desired level : ", level);
zm_debug_msg1("max level : ", ARRAY_SIZE(HpPriv->totalSizeDesired));
return FALSE;
}
zfDelayWriteInternalReg(dev, AR_PHY_DESIRED_SZ,
(HpPriv->regPHYDesiredSZ & ~AR_PHY_DESIRED_SZ_TOT_DES)
| ((HpPriv->totalSizeDesired[level] << AR_PHY_DESIRED_SZ_TOT_DES_S)
& AR_PHY_DESIRED_SZ_TOT_DES));
zfDelayWriteInternalReg(dev, AR_PHY_AGC_CTL1,
(HpPriv->regPHYAgcCtl1 & ~AR_PHY_AGC_CTL1_COARSE_LOW)
| ((HpPriv->coarseLow[level] << AR_PHY_AGC_CTL1_COARSE_LOW_S)
& AR_PHY_AGC_CTL1_COARSE_LOW));
zfDelayWriteInternalReg(dev, AR_PHY_AGC_CTL1,
(HpPriv->regPHYAgcCtl1 & ~AR_PHY_AGC_CTL1_COARSE_HIGH)
| ((HpPriv->coarseHigh[level] << AR_PHY_AGC_CTL1_COARSE_HIGH_S)
& AR_PHY_AGC_CTL1_COARSE_HIGH));
zfDelayWriteInternalReg(dev, AR_PHY_FIND_SIG,
(HpPriv->regPHYFindSig & ~AR_PHY_FIND_SIG_FIRPWR)
| ((HpPriv->firpwr[level] << AR_PHY_FIND_SIG_FIRPWR_S)
& AR_PHY_FIND_SIG_FIRPWR));
zfFlushDelayWrite(dev);
if (level > aniState->noiseImmunityLevel)
HpPriv->stats.ast_ani_niup++;
else if (level < aniState->noiseImmunityLevel)
HpPriv->stats.ast_ani_nidown++;
aniState->noiseImmunityLevel = (u8_t)level;
break;
}
case ZM_HAL_ANI_OFDM_WEAK_SIGNAL_DETECTION:
{
const TABLE m1ThreshLow = { 127, 50 };
const TABLE m2ThreshLow = { 127, 40 };
const TABLE m1Thresh = { 127, 0x4d };
const TABLE m2Thresh = { 127, 0x40 };
const TABLE m2CountThr = { 31, 16 };
const TABLE m2CountThrLow = { 63, 48 };
u32_t on = param ? 1 : 0;
zfDelayWriteInternalReg(dev, AR_PHY_SFCORR_LOW,
(HpPriv->regPHYSfcorrLow & ~AR_PHY_SFCORR_LOW_M1_THRESH_LOW)
| ((m1ThreshLow[on] << AR_PHY_SFCORR_LOW_M1_THRESH_LOW_S)
& AR_PHY_SFCORR_LOW_M1_THRESH_LOW));
zfDelayWriteInternalReg(dev, AR_PHY_SFCORR_LOW,
(HpPriv->regPHYSfcorrLow & ~AR_PHY_SFCORR_LOW_M2_THRESH_LOW)
| ((m2ThreshLow[on] << AR_PHY_SFCORR_LOW_M2_THRESH_LOW_S)
& AR_PHY_SFCORR_LOW_M2_THRESH_LOW));
zfDelayWriteInternalReg(dev, AR_PHY_SFCORR,
(HpPriv->regPHYSfcorr & ~AR_PHY_SFCORR_M1_THRESH)
| ((m1Thresh[on] << AR_PHY_SFCORR_M1_THRESH_S)
& AR_PHY_SFCORR_M1_THRESH));
zfDelayWriteInternalReg(dev, AR_PHY_SFCORR,
(HpPriv->regPHYSfcorr & ~AR_PHY_SFCORR_M2_THRESH)
| ((m2Thresh[on] << AR_PHY_SFCORR_M2_THRESH_S)
& AR_PHY_SFCORR_M2_THRESH));
zfDelayWriteInternalReg(dev, AR_PHY_SFCORR,
(HpPriv->regPHYSfcorr & ~AR_PHY_SFCORR_M2COUNT_THR)
| ((m2CountThr[on] << AR_PHY_SFCORR_M2COUNT_THR_S)
& AR_PHY_SFCORR_M2COUNT_THR));
zfDelayWriteInternalReg(dev, AR_PHY_SFCORR_LOW,
(HpPriv->regPHYSfcorrLow & ~AR_PHY_SFCORR_LOW_M2COUNT_THR_LOW)
| ((m2CountThrLow[on] << AR_PHY_SFCORR_LOW_M2COUNT_THR_LOW_S)
& AR_PHY_SFCORR_LOW_M2COUNT_THR_LOW));
if (on)
{
zfDelayWriteInternalReg(dev, AR_PHY_SFCORR_LOW,
HpPriv->regPHYSfcorrLow | AR_PHY_SFCORR_LOW_USE_SELF_CORR_LOW);
}
else
{
zfDelayWriteInternalReg(dev, AR_PHY_SFCORR_LOW,
HpPriv->regPHYSfcorrLow & ~AR_PHY_SFCORR_LOW_USE_SELF_CORR_LOW);
}
zfFlushDelayWrite(dev);
if (!on != aniState->ofdmWeakSigDetectOff)
{
if (on)
HpPriv->stats.ast_ani_ofdmon++;
else
HpPriv->stats.ast_ani_ofdmoff++;
aniState->ofdmWeakSigDetectOff = !on;
}
break;
}
case ZM_HAL_ANI_CCK_WEAK_SIGNAL_THR:
{
const TABLE weakSigThrCck = { 8, 6 };
u32_t high = param ? 1 : 0;
zfDelayWriteInternalReg(dev, AR_PHY_CCK_DETECT,
(HpPriv->regPHYCckDetect & ~AR_PHY_CCK_DETECT_WEAK_SIG_THR_CCK)
| ((weakSigThrCck[high] << AR_PHY_CCK_DETECT_WEAK_SIG_THR_CCK_S)
& AR_PHY_CCK_DETECT_WEAK_SIG_THR_CCK));
zfFlushDelayWrite(dev);
if (high != aniState->cckWeakSigThreshold)
{
if (high)
HpPriv->stats.ast_ani_cckhigh++;
else
HpPriv->stats.ast_ani_ccklow++;
aniState->cckWeakSigThreshold = (u8_t)high;
}
break;
}
case ZM_HAL_ANI_FIRSTEP_LEVEL:
{
const TABLE firstep = { 0, 4, 8 };
u32_t level = param;
if (level >= ARRAY_SIZE(firstep))
{
zm_debug_msg1("level out of range, desired level : ", level);
zm_debug_msg1("max level : ", ARRAY_SIZE(firstep));
return FALSE;
}
zfDelayWriteInternalReg(dev, AR_PHY_FIND_SIG,
(HpPriv->regPHYFindSig & ~AR_PHY_FIND_SIG_FIRSTEP)
| ((firstep[level] << AR_PHY_FIND_SIG_FIRSTEP_S)
& AR_PHY_FIND_SIG_FIRSTEP));
zfFlushDelayWrite(dev);
if (level > aniState->firstepLevel)
HpPriv->stats.ast_ani_stepup++;
else if (level < aniState->firstepLevel)
HpPriv->stats.ast_ani_stepdown++;
aniState->firstepLevel = (u8_t)level;
break;
}
case ZM_HAL_ANI_SPUR_IMMUNITY_LEVEL:
{
const TABLE cycpwrThr1 = { 2, 4, 6, 8, 10, 12, 14, 16 };
u32_t level = param;
if (level >= ARRAY_SIZE(cycpwrThr1))
{
zm_debug_msg1("level out of range, desired level : ", level);
zm_debug_msg1("max level : ", ARRAY_SIZE(cycpwrThr1));
return FALSE;
}
zfDelayWriteInternalReg(dev, AR_PHY_TIMING5,
(HpPriv->regPHYTiming5 & ~AR_PHY_TIMING5_CYCPWR_THR1)
| ((cycpwrThr1[level] << AR_PHY_TIMING5_CYCPWR_THR1_S)
& AR_PHY_TIMING5_CYCPWR_THR1));
zfFlushDelayWrite(dev);
if (level > aniState->spurImmunityLevel)
HpPriv->stats.ast_ani_spurup++;
else if (level < aniState->spurImmunityLevel)
HpPriv->stats.ast_ani_spurdown++;
aniState->spurImmunityLevel = (u8_t)level;
break;
}
case ZM_HAL_ANI_PRESENT:
break;
#ifdef AH_PRIVATE_DIAG
case ZM_HAL_ANI_MODE:
if (param == 0)
{
HpPriv->procPhyErr &= ~ZM_HAL_PROCESS_ANI;
/* Turn off HW counters if we have them */
zfHpAniDetach(dev);
//zfHpSetRxFilter(dev, zfHpGetRxFilter(dev) &~ HAL_RX_FILTER_PHYERR);
}
else
{ /* normal/auto mode */
HpPriv->procPhyErr |= ZM_HAL_PROCESS_ANI;
if (HpPriv->hasHwPhyCounters)
{
//zfHpSetRxFilter(dev, zfHpGetRxFilter(dev) &~ HAL_RX_FILTER_PHYERR);
}
else
{
//zfHpSetRxFilter(dev, zfHpGetRxFilter(dev) | HAL_RX_FILTER_PHYERR);
}
}
break;
case ZM_HAL_ANI_PHYERR_RESET:
HpPriv->stats.ast_ani_ofdmerrs = 0;
HpPriv->stats.ast_ani_cckerrs = 0;
break;
#endif /* AH_PRIVATE_DIAG */
default:
zm_debug_msg1("invalid cmd ", cmd);
return FALSE;
}
return TRUE;
}
u8_t zfScanMgrScanStart(zdev_t* dev, u8_t scanType)
{
u8_t i;
zmw_get_wlan_dev(dev);
zm_debug_msg1("scanType = ", scanType);
zmw_declare_for_critical_section();
if ( scanType != ZM_SCAN_MGR_SCAN_INTERNAL &&
scanType != ZM_SCAN_MGR_SCAN_EXTERNAL )
{
zm_debug_msg0("unknown scanType");
return 1;
}
else if (zfStaIsConnecting(dev))
{
zm_debug_msg0("reject scan request due to connecting");
return 1;
}
i = scanType - 1;
zmw_enter_critical_section(dev);
if ( wd->sta.scanMgr.scanReqs[i] == 1 )
{
zm_debug_msg1("scan rescheduled", scanType);
goto scan_done;
}
wd->sta.scanMgr.scanReqs[i] = 1;
zm_debug_msg1("scan scheduled: ", scanType);
// If there's no scan pending, we do the scan right away.
// If there's an internal scan and the new scan request is external one,
// we will restart the scan.
if ( wd->sta.scanMgr.currScanType == ZM_SCAN_MGR_SCAN_NONE )
{
goto schedule_scan;
}
else if ( wd->sta.scanMgr.currScanType == ZM_SCAN_MGR_SCAN_INTERNAL &&
scanType == ZM_SCAN_MGR_SCAN_EXTERNAL )
{
// Stop the internal scan & schedule external scan first
zfTimerCancel(dev, ZM_EVENT_SCAN);
/* Fix for WHQL sendrecv => we do not apply delay time in which the device
stop transmitting packet when we already connect to some AP */
wd->sta.bScheduleScan = FALSE;
zfTimerCancel(dev, ZM_EVENT_TIMEOUT_SCAN);
zfTimerCancel(dev, ZM_EVENT_IN_SCAN);
wd->sta.bChannelScan = FALSE;
goto schedule_scan;
}
else
{
zm_debug_msg0("Scan is busy...waiting later to start\n");
}
zmw_leave_critical_section(dev);
return 0;
scan_done:
zmw_leave_critical_section(dev);
return 1;
schedule_scan:
wd->sta.bScheduleScan = TRUE;
zfTimerSchedule(dev, ZM_EVENT_SCAN, wd->sta.scanMgr.scanStartDelay);
wd->sta.scanMgr.scanStartDelay = 3;
//wd->sta.scanMgr.scanStartDelay = 0;
wd->sta.scanMgr.currScanType = scanType;
zmw_leave_critical_section(dev);
if ((zfStaIsConnected(dev)) && (!zfPowerSavingMgrIsSleeping(dev)))
{
zfSendNullData(dev, 1);
}
return 0;
}
