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 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 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 zfScanMgrScanEventRetry(zdev_t* dev)
{
zmw_get_wlan_dev(dev);
if ( !wd->sta.bChannelScan )
{
return;
}
if ( !wd->sta.bPassiveScan )
{
zfScanSendProbeRequest(dev);
#if 0
zmw_enter_critical_section(dev);
zfTimerSchedule(dev, ZM_EVENT_IN_SCAN, ZM_TICK_IN_SCAN);
zmw_leave_critical_section(dev);
#endif
}
}
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);
}
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);
}
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;
}
}
}
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;
}
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;
}
}
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;
}
u16_t zfTxGenWlanHeader(zdev_t* dev, zbuf_t* buf, u16_t* header, u16_t seq,
u8_t flag, u16_t plusLen, u16_t minusLen, u16_t port,
u16_t* da, u16_t* sa, u8_t up, u16_t *micLen,
u16_t* snap, u16_t snapLen, struct aggControl *aggControl)
{
u16_t len;
u16_t macCtrl;
u32_t phyCtrl;
u16_t hlen = 16;
u16_t icvLen = 0;
u16_t wdsPortId;
u16_t vap = 0;
u16_t mcs = 0;
u16_t mt = 0;
u8_t qosType;
u8_t b1, b2;
u16_t wdsPort;
u8_t encExemptionActionType;
u16_t rateProbingFlag = 0;
u8_t tkipFrameOffset = 0;
#ifdef ZM_ENABLE_IBSS_WPA2PSK
u8_t res, peerIdx;
u8_t userIdx=0;
u16_t *iv16;
u32_t *iv32;
#endif
zmw_get_wlan_dev(dev);
header[4] = 0x0008 | (flag<<8);
header[5] = 0x0000;
if (wd->wlanMode == ZM_MODE_INFRASTRUCTURE)
{
header[4] |= 0x0100;
if ( zfPowerSavingMgrIsSleeping(dev) || wd->sta.psMgr.tempWakeUp == 1 )
{
header[4] |= 0x1000;
}
header[6] = wd->sta.bssid[0];
header[7] = wd->sta.bssid[1];
header[8] = wd->sta.bssid[2];
header[12] = da[0];
header[13] = da[1];
header[14] = da[2];
}
else if (wd->wlanMode == ZM_MODE_PSEUDO)
{
header[6] = da[0];
header[7] = da[1];
header[8] = da[2];
header[12] = 0;
header[13] = 0;
header[14] = 0;
if (wd->enableWDS)
{
header[4] |= 0x0300;
header[16] = 0;
header[17] = 0;
header[18] = 0;
hlen = 19;
}
}
else if (wd->wlanMode == ZM_MODE_IBSS)
{
header[6] = da[0];
header[7] = da[1];
header[8] = da[2];
header[12] = wd->sta.bssid[0];
header[13] = wd->sta.bssid[1];
header[14] = wd->sta.bssid[2];
#ifdef ZM_ENABLE_IBSS_WPA2PSK
zmw_enter_critical_section(dev);
res = zfStaFindOppositeByMACAddr(dev, da, &peerIdx);
if(res == 0)
{
userIdx = peerIdx;
}
zmw_leave_critical_section(dev);
#endif
}
else if (wd->wlanMode == ZM_MODE_AP)
{
if (port < 0x20)
{
header[4] |= 0x0200;
header[6] = da[0];
header[7] = da[1];
header[8] = da[2];
header[12] = sa[0];
header[13] = sa[1];
header[14] = sa[2];
if (port < ZM_MAX_AP_SUPPORT)
{
vap = port;
header[14] += (vap<<8);
}
}
else
{
header[4] |= 0x0300;
wdsPortId = port - 0x20;
header[6] = wd->ap.wds.macAddr[wdsPortId][0];
header[7] = wd->ap.wds.macAddr[wdsPortId][1];
header[8] = wd->ap.wds.macAddr[wdsPortId][2];
header[12] = da[0];
header[13] = da[1];
header[14] = da[2];
header[16] = sa[0];
header[17] = sa[1];
header[18] = sa[2];
hlen = 19;
}
}
header[9] = wd->macAddr[0];
header[10] = wd->macAddr[1];
#ifdef ZM_VAPMODE_MULTILE_SSID
header[11] = wd->macAddr[2];
#else
header[11] = wd->macAddr[2] + (vap<<8);
#endif
if ( (wd->wlanMode == ZM_MODE_IBSS) && (wd->XLinkMode) )
{
header[9] = sa[0];
header[10] = sa[1];
header[11] = sa[2];
}
header[15] = seq;
if (wd->wlanMode == ZM_MODE_AP)
{
zfApGetStaTxRateAndQosType(dev, da, &phyCtrl, &qosType, &rateProbingFlag);
mt = (u16_t)(phyCtrl & 0x3);
mcs = (u16_t)((phyCtrl >> 16) & 0x3f);
#if 1
if (qosType == 1)
{
header[4] |= 0x0080;
header[hlen] = up;
hlen += 1;
}
#endif
}
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;
}
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);
}
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;
}
u16_t zfTxGenWlanHeader(zdev_t* dev, zbuf_t* buf, u16_t* header, u16_t seq,
u8_t flag, u16_t plusLen, u16_t minusLen, u16_t port,
u16_t* da, u16_t* sa, u8_t up, u16_t *micLen,
u16_t* snap, u16_t snapLen, struct aggControl *aggControl)
{
u16_t len;
u16_t macCtrl;
u32_t phyCtrl;
u16_t hlen = 16;
u16_t icvLen = 0;
u16_t wdsPortId;
u16_t vap = 0;
u16_t mcs = 0;
u16_t mt = 0;
u8_t qosType;
u8_t b1, b2;
u16_t wdsPort;
u8_t encExemptionActionType;
u16_t rateProbingFlag = 0;
u8_t tkipFrameOffset = 0;
#ifdef ZM_ENABLE_IBSS_WPA2PSK
u8_t res, peerIdx;
u8_t userIdx=0;
u16_t *iv16;
u32_t *iv32;
#endif
zmw_get_wlan_dev(dev);
/* Generate WLAN header */
/* Frame control */
header[4] = 0x0008 | (flag<<8);
/* Duration */
header[5] = 0x0000;
if (wd->wlanMode == ZM_MODE_INFRASTRUCTURE)
{
/* ToDS bit */
header[4] |= 0x0100;
/*Sometimes we wake up to tx/rx but AP still think we are sleeping, so still need to set this bit*/
if ( zfPowerSavingMgrIsSleeping(dev) || wd->sta.psMgr.tempWakeUp == 1 )
{
header[4] |= 0x1000;
}
/* Address 1 = BSSID */
header[6] = wd->sta.bssid[0];
header[7] = wd->sta.bssid[1];
header[8] = wd->sta.bssid[2];
/* Address 3 = DA */
header[12] = da[0];
header[13] = da[1];
header[14] = da[2];
}
else if (wd->wlanMode == ZM_MODE_PSEUDO)
{
/* Address 1 = DA */
header[6] = da[0];
header[7] = da[1];
header[8] = da[2];
/* Address 3 = 00:00:00:00:00:00 */
header[12] = 0;
header[13] = 0;
header[14] = 0;
/* PSEUDO test : WDS */
if (wd->enableWDS)
{
/* ToDS and FromDS bit */
header[4] |= 0x0300;
/* Address 4 = SA */
header[16] = 0;
header[17] = 0;
header[18] = 0;
hlen = 19;
}
}
else if (wd->wlanMode == ZM_MODE_IBSS)
{
/* Address 1 = DA */
header[6] = da[0];
header[7] = da[1];
header[8] = da[2];
/* Address 3 = BSSID */
header[12] = wd->sta.bssid[0];
header[13] = wd->sta.bssid[1];
header[14] = wd->sta.bssid[2];
#ifdef ZM_ENABLE_IBSS_WPA2PSK
zmw_enter_critical_section(dev);
res = zfStaFindOppositeByMACAddr(dev, da, &peerIdx);
if(res == 0) // Find opposite in our OppositeInfo Structure !
{
userIdx = peerIdx;
}
zmw_leave_critical_section(dev);
#endif
}
else if (wd->wlanMode == ZM_MODE_AP)
{
if (port < 0x20)
/* AP mode */
{
/* FromDS bit */
header[4] |= 0x0200;
/* Address 1 = DA */
header[6] = da[0];
header[7] = da[1];
header[8] = da[2];
/* Address 3 = SA */
header[12] = sa[0];
header[13] = sa[1];
header[14] = sa[2];
if (port < ZM_MAX_AP_SUPPORT)
{
vap = port;
header[14] += (vap<<8);
}
}
else
/* WDS port */
{
/* ToDS and FromDS bit */
header[4] |= 0x0300;
wdsPortId = port - 0x20;
/* Address 1 = RA */
header[6] = wd->ap.wds.macAddr[wdsPortId][0];
header[7] = wd->ap.wds.macAddr[wdsPortId][1];
header[8] = wd->ap.wds.macAddr[wdsPortId][2];
/* Address 3 = DA */
header[12] = da[0];
header[13] = da[1];
header[14] = da[2];
/* Address 4 = SA */
header[16] = sa[0];
header[17] = sa[1];
header[18] = sa[2];
hlen = 19;
}
} /* else if (wd->wlanMode == ZM_MODE_AP) */
/* Address 2 = TA */
header[9] = wd->macAddr[0];
header[10] = wd->macAddr[1];
#ifdef ZM_VAPMODE_MULTILE_SSID
header[11] = wd->macAddr[2]; //Multiple SSID
#else
header[11] = wd->macAddr[2] + (vap<<8); //VAP
#endif
if ( (wd->wlanMode == ZM_MODE_IBSS) && (wd->XLinkMode) )
{
header[9] = sa[0];
header[10] = sa[1];
header[11] = sa[2];
}
/* Sequence Control */
header[15] = seq;
if (wd->wlanMode == ZM_MODE_AP)
{
zfApGetStaTxRateAndQosType(dev, da, &phyCtrl, &qosType, &rateProbingFlag);
mt = (u16_t)(phyCtrl & 0x3);
mcs = (u16_t)((phyCtrl >> 16) & 0x3f);
#if 1
//zfApGetStaQosType(dev, da, &qosType);
/* if DA == WME STA */
if (qosType == 1)
{
/* QoS data */
header[4] |= 0x0080;
/* QoS Control */
header[hlen] = up;
hlen += 1;
}
#endif
}
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 {
