| /* |
| * Copyright (c) 2007-2008 Atheros Communications Inc. |
| * |
| * Permission to use, copy, modify, and/or distribute this software for any |
| * purpose with or without fee is hereby granted, provided that the above |
| * copyright notice and this permission notice appear in all copies. |
| * |
| * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES |
| * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF |
| * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR |
| * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES |
| * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN |
| * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF |
| * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. |
| */ |
| |
| #include "cprecomp.h" |
| #include "ratectrl.h" |
| |
| |
| void zfUpdateBssid(zdev_t* dev, u8_t* bssid) |
| { |
| |
| zmw_get_wlan_dev(dev); |
| |
| //zmw_declare_for_critical_section(); |
| |
| //zmw_enter_critical_section(dev); |
| wd->sta.bssid[0] = bssid[0] + (((u16_t) bssid[1]) << 8); |
| wd->sta.bssid[1] = bssid[2] + (((u16_t) bssid[3]) << 8); |
| wd->sta.bssid[2] = bssid[4] + (((u16_t) bssid[5]) << 8); |
| //zmw_leave_critical_section(dev); |
| |
| zfHpSetBssid(dev, bssid); |
| |
| } |
| |
| /************************************************************************************/ |
| /* */ |
| /* FUNCTION DESCRIPTION zfResetSupportRate */ |
| /* Reset support rate to default value. */ |
| /* */ |
| /* INPUTS */ |
| /* dev : device pointer */ |
| /* type: ZM_DEFAULT_SUPPORT_RATE_ZERO => reset to zero */ |
| /* ZM_DEFAULT_SUPPORT_RATE_DISCONNECT => reset to disconnect status */ |
| /* ZM_DEFAULT_SUPPORT_RATE_IBSS_B => reset to IBSS creator(b mode) */ |
| /* ZM_DEFAULT_SUPPORT_RATE_IBSS_AG => reset to IBSS creator(a/g mode) */ |
| /* */ |
| /************************************************************************************/ |
| void zfResetSupportRate(zdev_t* dev, u8_t type) |
| { |
| zmw_get_wlan_dev(dev); |
| |
| switch(type) |
| { |
| case ZM_DEFAULT_SUPPORT_RATE_ZERO: |
| wd->bRate = 0; |
| wd->bRateBasic = 0; |
| wd->gRate = 0; |
| wd->gRateBasic = 0; |
| break; |
| case ZM_DEFAULT_SUPPORT_RATE_DISCONNECT: |
| wd->bRate = 0xf; |
| wd->bRateBasic = 0xf; |
| wd->gRate = 0xff; |
| wd->gRateBasic = 0x15; |
| break; |
| case ZM_DEFAULT_SUPPORT_RATE_IBSS_B: |
| wd->bRate = 0xf; |
| wd->bRateBasic = 0xf; |
| wd->gRate = 0; |
| wd->gRateBasic = 0; |
| break; |
| case ZM_DEFAULT_SUPPORT_RATE_IBSS_AG: |
| wd->bRate = 0xf; |
| wd->bRateBasic = 0xf; |
| wd->gRate = 0xff; |
| wd->gRateBasic = 0; |
| break; |
| } |
| } |
| |
| void zfUpdateSupportRate(zdev_t* dev, u8_t* rateArray) |
| { |
| u8_t bRate=0, bRateBasic=0, gRate=0, gRateBasic=0; |
| u8_t length = rateArray[1]; |
| u8_t i, j; |
| |
| zmw_get_wlan_dev(dev); |
| |
| for(i=2; i<length+2; i++) |
| { |
| for(j=0; j<4; j++) |
| { |
| if ( (rateArray[i] & 0x7f) == zg11bRateTbl[j] ) |
| { |
| bRate |= (1 << j); |
| if ( rateArray[i] & 0x80 ) |
| { |
| bRateBasic |= (1 << j); |
| } |
| } |
| } |
| |
| if ( j == 4 ) |
| { |
| for(j=0; j<8; j++) |
| { |
| if ( (rateArray[i] & 0x7f) == zg11gRateTbl[j] ) |
| { |
| gRate |= (1 << j); |
| if ( rateArray[i] & 0x80 ) |
| { |
| gRateBasic |= (1 << j); |
| } |
| } |
| } |
| } |
| } |
| |
| |
| wd->bRate |= bRate; |
| wd->bRateBasic |= bRateBasic; |
| wd->gRate |= gRate; |
| wd->gRateBasic |= gRateBasic; |
| } |
| |
| u8_t zfIsGOnlyMode(zdev_t* dev, u16_t frequency, u8_t* rateArray) |
| { |
| u8_t length = rateArray[1]; |
| u8_t i, j; |
| |
| if (frequency < 3000) { |
| for (i = 2; i < length+2; i++) { |
| for (j = 0; j < 8; j++) { |
| if ( ((rateArray[i] & 0x7f) == zg11gRateTbl[j]) |
| && (rateArray[i] & 0x80) ) { |
| return 1; |
| } |
| } |
| } |
| } |
| |
| return 0; |
| } |
| |
| void zfGatherBMode(zdev_t* dev, u8_t* rateArray, u8_t* extrateArray) |
| { |
| u8_t gatherBMode[ZM_MAX_SUPP_RATES_IE_SIZE + 2]; |
| u8_t i, j, k = 0; |
| u8_t length; |
| |
| gatherBMode[0] = ZM_WLAN_EID_SUPPORT_RATE; |
| gatherBMode[1] = 0; |
| |
| length = rateArray[1]; |
| for (i = 2; i < length+2; i++) { |
| for (j = 0; j < 4; j++) { |
| if ( (rateArray[i] & 0x7f) == zg11bRateTbl[j] ) { |
| gatherBMode[2+k] = rateArray[i]; |
| |
| gatherBMode[1]++; |
| k++; |
| } |
| } |
| } |
| |
| length = extrateArray[1]; |
| for (i = 2; i < length+2; i++) { |
| for (j = 0; j < 4; j++) { |
| if ( (extrateArray[i] & 0x7f) == zg11bRateTbl[j] ) { |
| gatherBMode[2+k] = extrateArray[i]; |
| |
| gatherBMode[1]++; |
| k++; |
| } |
| } |
| } |
| |
| extrateArray[0] = extrateArray[1] = 0; |
| zfMemoryCopy(rateArray, gatherBMode, gatherBMode[1]+2); |
| } |
| |
| u16_t zfGetRandomNumber(zdev_t* dev, u16_t initValue) |
| { |
| #if 0 |
| /* Compiler/Linker error on Linux */ |
| if ( initValue ) |
| { |
| srand(initValue); |
| } |
| |
| return ((u16_t)rand()); |
| #endif |
| return 0; |
| } |
| |
| u8_t zfPSDeviceSleep(zdev_t* dev) |
| { |
| //zmw_get_wlan_dev(dev); |
| |
| /* enter PS mode */ |
| |
| return 0; |
| } |
| |
| u8_t zcOfdmPhyCrtlToRate[] = |
| { |
| /* 0x8=48M, 0x9=24M, 0xa=12M, 0xb=6M, 0xc=54M, 0xd=36M, 0xe=18M, 0xf=9M */ |
| 10, 8, 6, 4, 11, 9, 7, 5 |
| }; |
| |
| u8_t zfPhyCtrlToRate(u32_t phyCtrl) |
| { |
| u32_t mt, mcs, sg; |
| u8_t rate = 0; |
| |
| mt = phyCtrl & 0x3; |
| mcs = (phyCtrl>>18) & 0x3f; |
| sg = (phyCtrl>>31) & 0x1; |
| |
| if ((mt == 0) && (mcs <=3)) |
| { |
| rate = (u8_t)mcs; |
| } |
| else if ((mt == 1) && (mcs >= 0x8) && (mcs <= 0xf)) |
| { |
| rate = zcOfdmPhyCrtlToRate[mcs-8]; |
| } |
| else if ((mt == 2) && (mcs <= 15)) |
| { |
| rate = (u8_t)mcs + 12; |
| if(sg) { |
| if (mcs != 7) |
| { |
| rate = (u8_t)mcs + 12 + 2; |
| } |
| else //MCS7-SG |
| { |
| rate = (u8_t)30; |
| } |
| } |
| } |
| |
| return rate; |
| } |
| |
| |
| void zfCoreEvent(zdev_t* dev, u16_t event, u8_t* rsp) |
| { |
| u16_t i; |
| zbuf_t* psBuf; |
| u8_t moreData; |
| u8_t vap = 0; |
| u8_t peerIdx; |
| s8_t res; |
| zmw_get_wlan_dev(dev); |
| zmw_declare_for_critical_section(); |
| |
| |
| if (event == 0) //Beacon Event |
| { |
| if ( wd->wlanMode == ZM_MODE_AP ) |
| { |
| zfApSendBeacon(dev); |
| |
| if (wd->CurrentDtimCount == 0) |
| { |
| /* TODO : Send queued broadcast frames at BC/MC event */ |
| do |
| { |
| psBuf = NULL; |
| moreData = 0; |
| zmw_enter_critical_section(dev); |
| if (wd->ap.bcmcTail[vap] != wd->ap.bcmcHead[vap]) |
| { |
| //zm_msg0_mm(ZM_LV_0, "Send BCMC frames"); |
| psBuf = wd->ap.bcmcArray[vap][wd->ap.bcmcHead[vap]]; |
| wd->ap.bcmcHead[vap] = (wd->ap.bcmcHead[vap] + 1) |
| & (ZM_BCMC_ARRAY_SIZE - 1); |
| if (wd->ap.bcmcTail[vap] != wd->ap.bcmcHead[vap]) |
| { |
| moreData = 0x20; |
| } |
| } |
| zmw_leave_critical_section(dev); |
| if (psBuf != NULL) |
| { |
| /* TODO : config moreData bit */ |
| zfTxSendEth(dev, psBuf, 0, ZM_EXTERNAL_ALLOC_BUF, |
| moreData); |
| } |
| } while(psBuf != NULL); |
| |
| } |
| } |
| else |
| { |
| /* STA mode */ |
| if ( wd->sta.powerSaveMode > ZM_STA_PS_NONE ) |
| { |
| /* send queued packets */ |
| for(i=0; i<wd->sta.staPSDataCount; i++) |
| { |
| zfTxSendEth(dev, wd->sta.staPSDataQueue[i], 0, |
| ZM_EXTERNAL_ALLOC_BUF, 0); |
| } |
| |
| wd->sta.staPSDataCount = 0; |
| } |
| |
| if ( wd->wlanMode == ZM_MODE_IBSS ) |
| { |
| zfStaSendBeacon(dev); |
| wd->sta.ibssAtimTimer = ZM_BIT_15 | wd->sta.atimWindow; |
| } |
| |
| zfPowerSavingMgrPreTBTTInterrupt(dev); |
| } |
| } //if (event == 0) //Beacon Event |
| else if (event == 1) //Retry completed event |
| { |
| u32_t retryRate; |
| |
| retryRate = (u32_t)(rsp[6]) + (((u32_t)(rsp[7]))<<8) |
| + (((u32_t)(rsp[8]))<<16) + (((u32_t)(rsp[9]))<<24); |
| /* Degrade Tx Rate */ |
| if (wd->wlanMode == ZM_MODE_AP) |
| { |
| zmw_enter_critical_section(dev); |
| if ((i=zfApFindSta(dev, (u16_t*)rsp)) != 0xffff) |
| { |
| zfRateCtrlTxFailEvent(dev, &wd->ap.staTable[i].rcCell, 0,(u32_t)zfPhyCtrlToRate(retryRate)); |
| } |
| zmw_leave_critical_section(dev); |
| } |
| else |
| { |
| zmw_enter_critical_section(dev); |
| res = zfStaFindOppositeByMACAddr(dev, (u16_t*)rsp, &peerIdx); |
| if ( res == 0 ) |
| { |
| zfRateCtrlTxFailEvent(dev, &wd->sta.oppositeInfo[peerIdx].rcCell, 0,(u32_t)zfPhyCtrlToRate(retryRate)); |
| } |
| zmw_leave_critical_section(dev); |
| } |
| } //else if (event == 1) //Retry completed event |
| else if (event == 2) //Tx Fail event |
| { |
| u32_t retryRate; |
| |
| retryRate = (u32_t)(rsp[6]) + (((u32_t)(rsp[7]))<<8) |
| + (((u32_t)(rsp[8]))<<16) + (((u32_t)(rsp[9]))<<24); |
| |
| /* Degrade Tx Rate */ |
| if (wd->wlanMode == ZM_MODE_AP) |
| { |
| zmw_enter_critical_section(dev); |
| if ((i=zfApFindSta(dev, (u16_t*)rsp)) != 0xffff) |
| { |
| zfRateCtrlTxFailEvent(dev, &wd->ap.staTable[i].rcCell, 0,(u32_t)zfPhyCtrlToRate(retryRate)); |
| } |
| zmw_leave_critical_section(dev); |
| |
| zfApSendFailure(dev, rsp); |
| } |
| else |
| { |
| zmw_enter_critical_section(dev); |
| res = zfStaFindOppositeByMACAddr(dev, (u16_t*)rsp, &peerIdx); |
| if ( res == 0 ) |
| { |
| zfRateCtrlTxFailEvent(dev, &wd->sta.oppositeInfo[peerIdx].rcCell, 0,(u32_t)zfPhyCtrlToRate(retryRate)); |
| } |
| zmw_leave_critical_section(dev); |
| } |
| } //else if (event == 2) //Tx Fail event |
| else if (event == 3) //Tx Comp event |
| { |
| u32_t retryRate; |
| |
| retryRate = (u32_t)(rsp[6]) + (((u32_t)(rsp[7]))<<8) |
| + (((u32_t)(rsp[8]))<<16) + (((u32_t)(rsp[9]))<<24); |
| |
| /* TODO : Tx completed, used for rate control probing */ |
| if (wd->wlanMode == ZM_MODE_AP) |
| { |
| zmw_enter_critical_section(dev); |
| if ((i=zfApFindSta(dev, (u16_t*)rsp)) != 0xffff) |
| { |
| zfRateCtrlTxSuccessEvent(dev, &wd->ap.staTable[i].rcCell, zfPhyCtrlToRate(retryRate)); |
| } |
| zmw_leave_critical_section(dev); |
| } |
| else |
| { |
| zmw_enter_critical_section(dev); |
| res = zfStaFindOppositeByMACAddr(dev, (u16_t*)rsp, &peerIdx); |
| if ( res == 0 ) |
| { |
| zfRateCtrlTxSuccessEvent(dev, &wd->sta.oppositeInfo[peerIdx].rcCell, zfPhyCtrlToRate(retryRate)); |
| } |
| zmw_leave_critical_section(dev); |
| } |
| } //else if (event == 3) //Tx Comp event |
| else if (event == 4) //BA failed count |
| { |
| u32_t fail; |
| u32_t rate; |
| peerIdx = 0; |
| |
| fail=((u32_t*)rsp)[0] & 0xFFFF; |
| rate=((u32_t*)rsp)[0] >> 16; |
| |
| if (rate > 15) { |
| rate = (rate & 0xF) + 12 + 2; |
| } |
| else { |
| rate = rate + 12; |
| } |
| |
| zmw_enter_critical_section(dev); |
| zfRateCtrlTxFailEvent(dev, &wd->sta.oppositeInfo[peerIdx].rcCell, (u8_t)rate, fail); |
| zmw_leave_critical_section(dev); |
| } |
| } |
| |
| void zfBeaconCfgInterrupt(zdev_t* dev, u8_t* rsp) |
| { |
| u32_t txBeaconCounter; |
| |
| zmw_get_wlan_dev(dev); |
| |
| zmw_declare_for_critical_section(); |
| |
| if ( wd->wlanMode == ZM_MODE_IBSS ) |
| { |
| txBeaconCounter = *((u32_t *)rsp); |
| if ( wd->sta.beaconTxCnt != txBeaconCounter ) |
| { |
| wd->sta.txBeaconInd = 1; |
| |
| zmw_enter_critical_section(dev); |
| wd->tickIbssSendBeacon = 0; |
| zmw_leave_critical_section(dev); |
| } |
| else |
| { |
| wd->sta.txBeaconInd = 0; |
| } |
| |
| #ifdef ZM_ENABLE_IBSS_DELAYED_JOIN_INDICATION |
| if ( wd->sta.txBeaconInd && wd->sta.ibssDelayedInd ) |
| { |
| if (wd->zfcbIbssPartnerNotify != NULL) |
| { |
| wd->zfcbIbssPartnerNotify(dev, 1, &wd->sta.ibssDelayedIndEvent); |
| } |
| |
| wd->sta.ibssDelayedInd = 0; |
| } |
| #endif |
| |
| wd->sta.beaconTxCnt = txBeaconCounter; |
| |
| // Need to check if the time is expired after ATIM window?? |
| |
| // Check if we have buffered any data for those stations that are sleeping |
| // If it's true, then transmitting ATIM pkt to notify them |
| |
| #ifdef ZM_ENABLE_IBSS_PS |
| // TODO: Need to check if the station receive our ATIM pkt??? |
| zfStaIbssPSSend(dev); |
| |
| if ( wd->sta.atimWindow == 0 ) |
| { |
| // We won't receive the end of ATIM isr so we fake it |
| zfPowerSavingMgrAtimWinExpired(dev); |
| } |
| #endif |
| } |
| } |
| |
| void zfEndOfAtimWindowInterrupt(zdev_t* dev) |
| { |
| #ifdef ZM_ENABLE_IBSS_PS |
| zmw_get_wlan_dev(dev); |
| |
| if ( wd->wlanMode == ZM_MODE_IBSS ) |
| { |
| // Transmit any queued pkt for the stations!! |
| zfPowerSavingMgrAtimWinExpired(dev); |
| } |
| #endif |
| } |
