void zfSendCmdEx(zdev_t* dev) { u32_t ncmd[ZM_MAX_CMD_SIZE/4]; u16_t ncmdLen = 0; u16_t cmdFlag = 0; u16_t i; struct zsHpPriv* hpPriv; zmw_get_wlan_dev(dev); hpPriv=wd->hpPrivate; zmw_declare_for_critical_section(); zmw_enter_critical_section(dev); if (hpPriv->cmdPending == 0) { if (hpPriv->cmdTail != hpPriv->cmdSend) { cmdFlag = 1; /* Get queueing command */ ncmdLen= hpPriv->cmdQ[hpPriv->cmdSend].cmdLen; for (i=0; i<(ncmdLen>>2); i++) { ncmd[i] = hpPriv->cmdQ[hpPriv->cmdSend].cmd[i]; } hpPriv->cmdSend = (hpPriv->cmdSend+1) & (ZM_CMD_QUEUE_SIZE-1); hpPriv->cmdPending = 1; } }
void zfBssInfoCreate(zdev_t* dev) { u8_t i; zmw_get_wlan_dev(dev); zmw_declare_for_critical_section(); zmw_enter_critical_section(dev); wd->sta.bssList.bssCount = 0; wd->sta.bssList.head = NULL; wd->sta.bssList.tail = NULL; wd->sta.bssInfoArrayHead = 0; wd->sta.bssInfoArrayTail = 0; wd->sta.bssInfoFreeCount = ZM_MAX_BSS; for( i=0; i< ZM_MAX_BSS; i++ ) { //wd->sta.bssInfoArray[i] = &(wd->sta.bssInfoPool[i]); wd->sta.bssInfoArray[i] = (struct zsBssInfo*)zfwMemAllocate(dev, sizeof(struct zsBssInfo)); } zmw_leave_critical_section(dev); }
void zfCoreHalInitComplete(zdev_t* dev) { zmw_get_wlan_dev(dev); zmw_declare_for_critical_section(); zmw_enter_critical_section(dev); wd->halState = ZM_HAL_STATE_RUNNING; zmw_leave_critical_section(dev); zfPushVtxq(dev); }
u16_t zfTimerCheckAndHandle(zdev_t* dev) { struct zsTimerEntry *pEntry; struct zsTimerEntry *pTheLastEntry = NULL; u16_t event[ZM_MAX_TIMER_COUNT]; u8_t i, j=0, count; zmw_get_wlan_dev(dev); zmw_declare_for_critical_section(); if ( !wd->bTimerReady ) { return 0; } zmw_enter_critical_section(dev); pEntry = wd->timerList.head; count = ZM_MAX_TIMER_COUNT - wd->timerList.freeCount; for( i=0; i<count; i++ ) { // prevent from the case of tick overflow if ( ( pEntry->timer > wd->tick )&& ((pEntry->timer - wd->tick) < 1000000000) ) { break; } event[j++] = pEntry->event; pTheLastEntry = pEntry; pEntry = pEntry->next; } if ( j > 0 ) { wd->timerList.tail->next = wd->timerList.head; wd->timerList.head->pre = wd->timerList.tail; wd->timerList.head = pEntry; wd->timerList.tail = pTheLastEntry; wd->timerList.freeCount += j; //zm_debug_msg1("free timer count = ", wd->timerList.freeCount); } zmw_leave_critical_section(dev); zfProcessEvent(dev, event, j); return 0; }
void zfScanMgrScanAck(zdev_t* dev) { zmw_get_wlan_dev(dev); zmw_declare_for_critical_section(); zmw_enter_critical_section(dev); wd->sta.scanMgr.scanStartDelay = 3; //wd->sta.scanMgr.scanStartDelay = 0; zmw_leave_critical_section(dev); return; }
u32_t zfCoreSetKey(zdev_t* dev, u8_t user, u8_t keyId, u8_t type, u16_t* mac, u32_t* key) { u32_t ret; zmw_get_wlan_dev(dev); zmw_declare_for_critical_section(); zmw_enter_critical_section(dev); wd->sta.flagKeyChanging++; zm_debug_msg1(" zfCoreSetKey++++ ", wd->sta.flagKeyChanging); zmw_leave_critical_section(dev); ret = zfHpSetKey(dev, user, keyId, type, mac, key); return ret; }
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); }
void zfInitCmdQueue(zdev_t* dev) { struct zsHpPriv* hpPriv; zmw_get_wlan_dev(dev); hpPriv = (struct zsHpPriv*)(wd->hpPrivate); zmw_declare_for_critical_section(); zmw_enter_critical_section(dev); #ifdef ZM_XP_USB_MULTCMD hpPriv->cmdTail = hpPriv->cmdHead = hpPriv->cmdSend = 0; #else hpPriv->cmdTail = hpPriv->cmdHead = 0; #endif hpPriv->cmdPending = 0; hpPriv->cmd.delayWcmdCount = 0; zmw_leave_critical_section(dev); }
static void zfScanMgrEventSetFreqCompleteCb(zdev_t* dev) { zmw_get_wlan_dev(dev); zmw_declare_for_critical_section(); //printk("zfScanMgrEventSetFreqCompleteCb #1\n"); zmw_enter_critical_section(dev); zfTimerSchedule(dev, ZM_EVENT_IN_SCAN, ZM_TICK_IN_SCAN); if (wd->sta.bPassiveScan) { zfTimerSchedule(dev, ZM_EVENT_TIMEOUT_SCAN, wd->sta.passiveScanTickPerChannel); } else { zfTimerSchedule(dev, ZM_EVENT_TIMEOUT_SCAN, wd->sta.activescanTickPerChannel); } zmw_leave_critical_section(dev); zfScanSendProbeRequest(dev); }
void zfProcessEvent(zdev_t* dev, u16_t* eventArray, u8_t eventCount) { u8_t i, j, bypass = FALSE; u16_t eventBypass[32]; u8_t eventBypassCount = 0; zmw_get_wlan_dev(dev); zmw_declare_for_critical_section(); zfZeroMemory((u8_t*) eventBypass, 64); for( i=0; i<eventCount; i++ ) { for( j=0; j<eventBypassCount; j++ ) { if ( eventBypass[j] == eventArray[i] ) { bypass = TRUE; break; } } if ( bypass ) { continue; } switch( eventArray[i] ) { case ZM_EVENT_SCAN: { zfScanMgrScanEventStart(dev); eventBypass[eventBypassCount++] = ZM_EVENT_IN_SCAN; eventBypass[eventBypassCount++] = ZM_EVENT_TIMEOUT_SCAN; } break; case ZM_EVENT_TIMEOUT_SCAN: { u8_t res; res = zfScanMgrScanEventTimeout(dev); if ( res == 0 ) { eventBypass[eventBypassCount++] = ZM_EVENT_TIMEOUT_SCAN; } else if ( res == 1 ) { eventBypass[eventBypassCount++] = ZM_EVENT_IN_SCAN; } } break; case ZM_EVENT_IBSS_MONITOR: { zfStaIbssMonitoring(dev, 0); } break; case ZM_EVENT_IN_SCAN: { zfScanMgrScanEventRetry(dev); } break; case ZM_EVENT_CM_TIMER: { zm_msg0_mm(ZM_LV_0, "ZM_EVENT_CM_TIMER"); wd->sta.cmMicFailureCount = 0; } break; case ZM_EVENT_CM_DISCONNECT: { zm_msg0_mm(ZM_LV_0, "ZM_EVENT_CM_DISCONNECT"); zfChangeAdapterState(dev, ZM_STA_STATE_DISCONNECT); zmw_enter_critical_section(dev); //zfTimerSchedule(dev, ZM_EVENT_CM_BLOCK_TIMER, // ZM_TICK_CM_BLOCK_TIMEOUT); /* Timer Resolution on WinXP is 15/16 ms */ /* Decrease Time offset for <XP> Counter Measure */ zfTimerSchedule(dev, ZM_EVENT_CM_BLOCK_TIMER, ZM_TICK_CM_BLOCK_TIMEOUT - ZM_TICK_CM_BLOCK_TIMEOUT_OFFSET); zmw_leave_critical_section(dev); if (wd->sta.cmMicFailureCount == 2) //accumlate 2 MIC error in 60sec. send deauth to AP { zfSendMmFrame(dev, ZM_WLAN_FRAME_TYPE_DEAUTH, wd->sta.bssid, 1, 0, 0); } wd->sta.cmMicFailureCount = 0; //zfiWlanDisable(dev); zfHpResetKeyCache(dev); if (wd->zfcbConnectNotify != NULL) { wd->zfcbConnectNotify(dev, ZM_STATUS_MEDIA_DISCONNECT_MIC_FAIL, wd->sta.bssid); } } break; case ZM_EVENT_CM_BLOCK_TIMER: { zm_msg0_mm(ZM_LV_0, "ZM_EVENT_CM_BLOCK_TIMER"); //zmw_enter_critical_section(dev); wd->sta.cmDisallowSsidLength = 0; if ( wd->sta.bAutoReconnect ) { zm_msg0_mm(ZM_LV_0, "ZM_EVENT_CM_BLOCK_TIMER:bAutoReconnect!=0"); zfScanMgrScanStop(dev, ZM_SCAN_MGR_SCAN_INTERNAL); zfScanMgrScanStart(dev, ZM_SCAN_MGR_SCAN_INTERNAL); } //zmw_leave_critical_section(dev); } break; case ZM_EVENT_TIMEOUT_ADDBA: { if (!wd->addbaComplete && (wd->addbaCount < 5)) { zfAggSendAddbaRequest(dev, wd->sta.bssid, 0, 0); wd->addbaCount++; zfTimerSchedule(dev, ZM_EVENT_TIMEOUT_ADDBA, 100); } else { zfTimerCancel(dev, ZM_EVENT_TIMEOUT_ADDBA); } } break; #ifdef ZM_ENABLE_PERFORMANCE_EVALUATION case ZM_EVENT_TIMEOUT_PERFORMANCE: { zfiPerformanceRefresh(dev); } break; #endif case ZM_EVENT_SKIP_COUNTERMEASURE: //enable the Countermeasure { zm_debug_msg0("Countermeasure : Enable MIC Check "); wd->TKIP_Group_KeyChanging = 0x0; } break; default: break; } } }
void zfCollectHWTally(zdev_t*dev, u32_t* rsp, u8_t id) { zmw_get_wlan_dev(dev); zmw_declare_for_critical_section(); zmw_enter_critical_section(dev); if (id == 0) { wd->commTally.Hw_UnderrunCnt += (0xFFFF & rsp[1]); wd->commTally.Hw_TotalRxFrm += rsp[2]; wd->commTally.Hw_CRC32Cnt += rsp[3]; wd->commTally.Hw_CRC16Cnt += rsp[4]; #ifdef ZM_ENABLE_NATIVE_WIFI /* These code are here to satisfy Vista DTM */ wd->commTally.Hw_DecrypErr_UNI += ((rsp[5]>50) && (rsp[5]<60))?50:rsp[5]; #else wd->commTally.Hw_DecrypErr_UNI += rsp[5]; #endif wd->commTally.Hw_RxFIFOOverrun += rsp[6]; wd->commTally.Hw_DecrypErr_Mul += rsp[7]; wd->commTally.Hw_RetryCnt += rsp[8]; wd->commTally.Hw_TotalTxFrm += rsp[9]; wd->commTally.Hw_RxTimeOut +=rsp[10]; wd->commTally.Tx_MPDU += rsp[11]; wd->commTally.BA_Fail += rsp[12]; wd->commTally.Hw_Tx_AMPDU += rsp[13]; wd->commTally.Hw_Tx_MPDU += rsp[14]; wd->commTally.RateCtrlTxMPDU += rsp[11]; wd->commTally.RateCtrlBAFail += rsp[12]; } else { wd->commTally.Hw_RxMPDU += rsp[1]; wd->commTally.Hw_RxDropMPDU += rsp[2]; wd->commTally.Hw_RxDelMPDU += rsp[3]; wd->commTally.Hw_RxPhyMiscError += rsp[4]; wd->commTally.Hw_RxPhyXRError += rsp[5]; wd->commTally.Hw_RxPhyOFDMError += rsp[6]; wd->commTally.Hw_RxPhyCCKError += rsp[7]; wd->commTally.Hw_RxPhyHTError += rsp[8]; wd->commTally.Hw_RxPhyTotalCount += rsp[9]; } zmw_leave_critical_section(dev); if (id == 0) { zm_msg1_mm(ZM_LV_1, "rsplen =", rsp[0]); zm_msg1_mm(ZM_LV_1, "Hw_UnderrunCnt = ", (0xFFFF & rsp[1])); zm_msg1_mm(ZM_LV_1, "Hw_TotalRxFrm = ", rsp[2]); zm_msg1_mm(ZM_LV_1, "Hw_CRC32Cnt = ", rsp[3]); zm_msg1_mm(ZM_LV_1, "Hw_CRC16Cnt = ", rsp[4]); zm_msg1_mm(ZM_LV_1, "Hw_DecrypErr_UNI = ", rsp[5]); zm_msg1_mm(ZM_LV_1, "Hw_RxFIFOOverrun = ", rsp[6]); zm_msg1_mm(ZM_LV_1, "Hw_DecrypErr_Mul = ", rsp[7]); zm_msg1_mm(ZM_LV_1, "Hw_RetryCnt = ", rsp[8]); zm_msg1_mm(ZM_LV_1, "Hw_TotalTxFrm = ", rsp[9]); zm_msg1_mm(ZM_LV_1, "Hw_RxTimeOut = ", rsp[10]); zm_msg1_mm(ZM_LV_1, "Tx_MPDU = ", rsp[11]); zm_msg1_mm(ZM_LV_1, "BA_Fail = ", rsp[12]); zm_msg1_mm(ZM_LV_1, "Hw_Tx_AMPDU = ", rsp[13]); zm_msg1_mm(ZM_LV_1, "Hw_Tx_MPDU = ", rsp[14]); } else { zm_msg1_mm(ZM_LV_1, "rsplen = ", rsp[0]); zm_msg1_mm(ZM_LV_1, "Hw_RxMPDU = ", (0xFFFF & rsp[1])); zm_msg1_mm(ZM_LV_1, "Hw_RxDropMPDU = ", rsp[2]); zm_msg1_mm(ZM_LV_1, "Hw_RxDelMPDU = ", rsp[3]); zm_msg1_mm(ZM_LV_1, "Hw_RxPhyMiscError = ", rsp[4]); zm_msg1_mm(ZM_LV_1, "Hw_RxPhyXRError = ", rsp[5]); zm_msg1_mm(ZM_LV_1, "Hw_RxPhyOFDMError = ", rsp[6]); zm_msg1_mm(ZM_LV_1, "Hw_RxPhyCCKError = ", rsp[7]); zm_msg1_mm(ZM_LV_1, "Hw_RxPhyHTError = ", rsp[8]); zm_msg1_mm(ZM_LV_1, "Hw_RxPhyTotalCount = ", rsp[9]); } }
void zfScanMgrScanStop(zdev_t* dev, u8_t scanType) { u8_t scanNotifyRequired = 0; u8_t theOtherScan = ZM_SCAN_MGR_SCAN_NONE; zmw_get_wlan_dev(dev); zmw_declare_for_critical_section(); zmw_enter_critical_section(dev); if ( wd->sta.scanMgr.currScanType == ZM_SCAN_MGR_SCAN_NONE ) { zm_assert(wd->sta.scanMgr.scanReqs[0] == 0); zm_assert(wd->sta.scanMgr.scanReqs[1] == 0); goto done; } switch(scanType) { case ZM_SCAN_MGR_SCAN_EXTERNAL: scanNotifyRequired = 1; theOtherScan = ZM_SCAN_MGR_SCAN_INTERNAL; break; case ZM_SCAN_MGR_SCAN_INTERNAL: theOtherScan = ZM_SCAN_MGR_SCAN_EXTERNAL; break; default: goto done; } if ( wd->sta.scanMgr.currScanType != scanType ) { goto stop_done; } 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; wd->sta.scanFrequency = 0; if ( wd->sta.scanMgr.scanReqs[theOtherScan - 1] ) { wd->sta.scanMgr.currScanType = theOtherScan; // Schedule the other scan after 1 second later zfTimerSchedule(dev, ZM_EVENT_SCAN, 100); } else { wd->sta.scanMgr.currScanType = ZM_SCAN_MGR_SCAN_NONE; } stop_done: wd->sta.scanMgr.scanReqs[scanType - 1] = 0; zmw_leave_critical_section(dev); /* avoid lose receive packet when site survey */ if ((zfStaIsConnected(dev)) && (!zfPowerSavingMgrIsSleeping(dev))) { zfSendNullData(dev, 0); } if ( scanNotifyRequired ) { zm_debug_msg0("Scan notify after reset"); if (wd->zfcbScanNotify != NULL) { wd->zfcbScanNotify(dev, NULL); } } return; done: zmw_leave_critical_section(dev); return; }
void zfScanMgrScanEventStart(zdev_t* dev) { zmw_get_wlan_dev(dev); zmw_declare_for_critical_section(); if ( wd->sta.bChannelScan ) { return; } zfPowerSavingMgrWakeup(dev); zmw_enter_critical_section(dev); if ( wd->sta.scanMgr.currScanType == ZM_SCAN_MGR_SCAN_NONE ) { goto no_scan; } //zfBssInfoRefresh(dev); zfBssInfoRefresh(dev, 0); wd->sta.bChannelScan = TRUE; wd->sta.bScheduleScan = FALSE; zfTimerCancel(dev, ZM_EVENT_IN_SCAN); zfTimerCancel(dev, ZM_EVENT_TIMEOUT_SCAN); //zm_debug_msg1("start scan = ", KeQueryInterruptTime()); wd->sta.scanFrequency = zfChGetFirstChannel(dev, &wd->sta.bPassiveScan); zmw_leave_critical_section(dev); /* avoid lose receive packet when site survey */ //if ((zfStaIsConnected(dev)) && (!zfPowerSavingMgrIsSleeping(dev))) //{ // zfSendNullData(dev, 1); //} // zm_debug_msg0("scan 0"); // zfCoreSetFrequencyV2(dev, wd->sta.scanFrequency, zfScanMgrEventSetFreqCompleteCb); #if 1 if (zfStaIsConnected(dev)) {// If doing site survey ! zfHpBeginSiteSurvey(dev, 1); zmw_enter_critical_section(dev); wd->sta.ibssSiteSurveyStatus = 1; zmw_leave_critical_section(dev); } else { zfHpBeginSiteSurvey(dev, 0); zmw_enter_critical_section(dev); wd->sta.ibssSiteSurveyStatus = 0; zmw_leave_critical_section(dev); } #endif zm_debug_msg0("scan 0"); zfCoreSetFrequencyV2(dev, wd->sta.scanFrequency, zfScanMgrEventSetFreqCompleteCb); return; no_scan: zmw_leave_critical_section(dev); return; }
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; } }
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; }
u16_t zfFindCleanFrequency(zdev_t* dev, u32_t adhocMode) { u8_t i, j; u16_t returnChannel; u16_t count_24G = 0, min24GIndex = 0; u16_t count_5G = 0, min5GIndex = 0; u16_t CombinationBssNumberIn24G[15] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0}; u16_t BssNumberIn24G[17] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0}; u16_t Array_24G[15] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0}; u16_t BssNumberIn5G[31] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0}; u16_t Array_5G[31] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0}; struct zsBssInfo* pBssInfo; zmw_get_wlan_dev(dev); if ((pBssInfo = wd->sta.bssList.head) == NULL) { if( adhocMode == ZM_ADHOCBAND_B || adhocMode == ZM_ADHOCBAND_G || adhocMode == ZM_ADHOCBAND_BG || adhocMode == ZM_ADHOCBAND_ABG ) { returnChannel = zfChGetFirst2GhzChannel(dev); } else { returnChannel = zfChGetFirst5GhzChannel(dev); } return returnChannel; } /* #1 Get Allowed Channel following Country Code ! */ zmw_declare_for_critical_section(); zmw_enter_critical_section(dev); for (i = 0; i < wd->regulationTable.allowChannelCnt; i++) { if (wd->regulationTable.allowChannel[i].channel < 3000) { // 2.4GHz Array_24G[count_24G] = wd->regulationTable.allowChannel[i].channel; count_24G++; } else { // 5GHz count_5G++; Array_5G[i] = wd->regulationTable.allowChannel[i].channel; } } zmw_leave_critical_section(dev); while( pBssInfo != NULL ) { /* #2_1 Count BSS number in some specificed frequency in 2.4GHz band ! */ if( adhocMode == ZM_ADHOCBAND_B || adhocMode == ZM_ADHOCBAND_G || adhocMode == ZM_ADHOCBAND_BG || adhocMode == ZM_ADHOCBAND_ABG ) { for( i=0; i<=(count_24G+3); i++ ) { if( pBssInfo->frequency == Array_24G[i] ) { // Array_24G[0] correspond to BssNumberIn24G[2] BssNumberIn24G[pBssInfo->channel+1]++; } } } /* #2_2 Count BSS number in some specificed frequency in 5GHz band ! */ if( adhocMode == ZM_ADHOCBAND_A || adhocMode == ZM_ADHOCBAND_ABG ) { for( i=0; i<count_5G; i++ ) { // 5GHz channel is not equal to array index if( pBssInfo->frequency == Array_5G[i] ) { // Array_5G[0] correspond to BssNumberIn5G[0] BssNumberIn5G[i]++; } } } pBssInfo = pBssInfo->next; } #if 0 for(i=0; i<=(count_24G+3); i++) { printk("2.4GHz Before combin, %d BSS network : %d", i, BssNumberIn24G[i]); } for(i=0; i<count_5G; i++) { printk("5GHz Before combin, %d BSS network : %d", i, BssNumberIn5G[i]); } #endif if( adhocMode == ZM_ADHOCBAND_B || adhocMode == ZM_ADHOCBAND_G || adhocMode == ZM_ADHOCBAND_BG || adhocMode == ZM_ADHOCBAND_ABG ) { /* #3_1 Count BSS number that influence the specificed frequency in 2.4GHz ! */ for( j=0; j<count_24G; j++ ) { CombinationBssNumberIn24G[j] = BssNumberIn24G[j] + BssNumberIn24G[j+1] + BssNumberIn24G[j+2] + BssNumberIn24G[j+3] + BssNumberIn24G[j+4]; //printk("After combine, the number of BSS network channel %d is %d", // j , CombinationBssNumberIn24G[j]); } /* #4_1 Find the less utilized frequency in 2.4GHz band ! */ min24GIndex = zfFindMinimumUtilizationChannelIndex(dev, CombinationBssNumberIn24G, count_24G); } /* #4_2 Find the less utilized frequency in 5GHz band ! */ if( adhocMode == ZM_ADHOCBAND_A || adhocMode == ZM_ADHOCBAND_ABG ) { min5GIndex = zfFindMinimumUtilizationChannelIndex(dev, BssNumberIn5G, count_5G); } if( adhocMode == ZM_ADHOCBAND_B || adhocMode == ZM_ADHOCBAND_G || adhocMode == ZM_ADHOCBAND_BG ) { return Array_24G[min24GIndex]; } else if( adhocMode == ZM_ADHOCBAND_A ) { return Array_5G[min5GIndex]; } else if( adhocMode == ZM_ADHOCBAND_ABG ) { if ( CombinationBssNumberIn24G[min24GIndex] <= BssNumberIn5G[min5GIndex] ) return Array_24G[min24GIndex]; else return Array_5G[min5GIndex]; } else return 2412; }
void zfBssInfoReorderList(zdev_t* dev) { struct zsBssInfo* pBssInfo = NULL; struct zsBssInfo* pInsBssInfo = NULL; struct zsBssInfo* pNextBssInfo = NULL; struct zsBssInfo* pPreBssInfo = NULL; u8_t i = 0; zmw_get_wlan_dev(dev); zmw_declare_for_critical_section(); zmw_enter_critical_section(dev); if (wd->sta.bssList.bssCount > 1) { pInsBssInfo = wd->sta.bssList.head; wd->sta.bssList.tail = pInsBssInfo; pBssInfo = pInsBssInfo->next; pInsBssInfo->next = NULL; while (pBssInfo != NULL) { i = 0; while (1) { // if (pBssInfo->signalStrength >= pInsBssInfo->signalStrength) if( pBssInfo->sortValue >= pInsBssInfo->sortValue) { if (i==0) { //Insert BssInfo to head wd->sta.bssList.head = pBssInfo; pNextBssInfo = pBssInfo->next; pBssInfo->next = pInsBssInfo; break; } else { //Insert BssInfo to neither head nor tail pPreBssInfo->next = pBssInfo; pNextBssInfo = pBssInfo->next; pBssInfo->next = pInsBssInfo; break; } } else { if (pInsBssInfo->next != NULL) { //Signal strength smaller than current BssInfo, check next pPreBssInfo = pInsBssInfo; pInsBssInfo = pInsBssInfo->next; } else { //Insert BssInfo to tail pInsBssInfo->next = pBssInfo; pNextBssInfo = pBssInfo->next; wd->sta.bssList.tail = pBssInfo; pBssInfo->next = NULL; break; } } i++; } pBssInfo = pNextBssInfo; pInsBssInfo = wd->sta.bssList.head; } } //if (wd->sta.bssList.bssCount > 1) zmw_leave_critical_section(dev); }
void zfGetWrapperSetting(zdev_t *dev) { u8_t bPassive; u16_t vapId = 0; zmw_get_wlan_dev(dev); zmw_declare_for_critical_section(); #if 0 if ((wd->ws.countryIsoName[0] != 0) || (wd->ws.countryIsoName[1] != 0) || (wd->ws.countryIsoName[2] != '\0')) { zfHpGetRegulationTablefromRegionCode(dev, zfHpGetRegionCodeFromIsoName(dev, wd->ws.countryIsoName)); } #endif zmw_enter_critical_section(dev); wd->wlanMode = wd->ws.wlanMode; /* set channel */ if (wd->ws.frequency) { wd->frequency = wd->ws.frequency; wd->ws.frequency = 0; } else { wd->frequency = zfChGetFirstChannel(dev, &bPassive); if (wd->wlanMode == ZM_MODE_IBSS) { if (wd->ws.adhocMode == ZM_ADHOCBAND_A) wd->frequency = ZM_CH_A_36; else wd->frequency = ZM_CH_G_6; } } #ifdef ZM_AP_DEBUG /* honda add for debug, 2437 channel 6, 2452 channel 9 */ wd->frequency = 2437; /* end of add by honda */ #endif /* set preamble type */ switch (wd->ws.preambleType) { case ZM_PREAMBLE_TYPE_AUTO: case ZM_PREAMBLE_TYPE_SHORT: case ZM_PREAMBLE_TYPE_LONG: wd->preambleType = wd->ws.preambleType; break; default: wd->preambleType = ZM_PREAMBLE_TYPE_SHORT; break; } wd->ws.preambleType = 0; if (wd->wlanMode == ZM_MODE_AP) { vapId = zfwGetVapId(dev); if (vapId == 0xffff) { wd->ap.authAlgo[0] = wd->ws.authMode; wd->ap.encryMode[0] = wd->ws.encryMode; } else { wd->ap.authAlgo[vapId + 1] = wd->ws.authMode; wd->ap.encryMode[vapId + 1] = wd->ws.encryMode; } wd->ws.authMode = 0; wd->ws.encryMode = ZM_NO_WEP; /* Get beaconInterval from WrapperSetting */ if ((wd->ws.beaconInterval >= 20) && (wd->ws.beaconInterval <= 1000)) wd->beaconInterval = wd->ws.beaconInterval; else wd->beaconInterval = 100; /* 100ms */ if (wd->ws.dtim > 0) wd->dtim = wd->ws.dtim; else wd->dtim = 1; wd->ap.qosMode = wd->ws.apWmeEnabled & 0x1; wd->ap.uapsdEnabled = (wd->ws.apWmeEnabled & 0x2) >> 1; } else {