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; }