1/* 2 * Copyright (c) 2007-2008 Atheros Communications Inc. 3 * 4 * Permission to use, copy, modify, and/or distribute this software for any 5 * purpose with or without fee is hereby granted, provided that the above 6 * copyright notice and this permission notice appear in all copies. 7 * 8 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES 9 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF 10 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR 11 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES 12 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN 13 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF 14 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. 15 */ 16/* */ 17/* Module Name : cmd.c */ 18/* */ 19/* Abstract */ 20/* This module contains command interface functions. */ 21/* */ 22/* NOTES */ 23/* None */ 24/* */ 25/************************************************************************/ 26#include "cprecomp.h" 27#include "../hal/hpreg.h" 28 29 30u16_t zfWlanReset(zdev_t *dev); 31u32_t zfUpdateRxRate(zdev_t *dev); 32 33 34extern void zfiUsbRecv(zdev_t *dev, zbuf_t *buf); 35extern void zfiUsbRegIn(zdev_t *dev, u32_t *rsp, u16_t rspLen); 36extern void zfiUsbOutComplete(zdev_t *dev, zbuf_t *buf, u8_t status, u8_t *hdr); 37extern void zfiUsbRegOutComplete(zdev_t *dev); 38extern u16_t zfHpReinit(zdev_t *dev, u32_t frequency); 39 40/* Get size (byte) of driver core global data structure. */ 41/* This size will be used by driver wrapper to allocate */ 42/* a memory space for driver core to store global variables */ 43u16_t zfiGlobalDataSize(zdev_t *dev) 44{ 45 u32_t ret; 46 ret = (sizeof(struct zsWlanDev)); 47 zm_assert((ret>>16) == 0); 48 return (u16_t)ret; 49} 50 51 52/* Initialize WLAN hardware and software, resource will be allocated */ 53/* for WLAN operation, must be called first before other function. */ 54extern u16_t zfiWlanOpen(zdev_t *dev, struct zsCbFuncTbl *cbFuncTbl) 55{ 56 /* u16_t ret; 57 u32_t i; 58 u8_t* ch; 59 u8_t bPassive; 60 */ 61 u32_t devSize; 62 struct zfCbUsbFuncTbl cbUsbFuncTbl; 63 zmw_get_wlan_dev(dev); 64 65 zm_debug_msg0("start"); 66 67 devSize = sizeof(struct zsWlanDev); 68 /* Zeroize zsWlanDev struct */ 69 zfZeroMemory((u8_t *)wd, (u16_t)devSize); 70 71#ifdef ZM_ENABLE_AGGREGATION 72 zfAggInit(dev); 73#endif 74 75 zfCwmInit(dev); 76 77 wd->commTally.RateCtrlTxMPDU = 0; 78 wd->commTally.RateCtrlBAFail = 0; 79 wd->preambleTypeInUsed = ZM_PREAMBLE_TYPE_SHORT; 80 81 if (cbFuncTbl == NULL) { 82 /* zfcbRecvEth() is mandatory */ 83 zm_assert(0); 84 } else { 85 if (cbFuncTbl->zfcbRecvEth == NULL) { 86 /* zfcbRecvEth() is mandatory */ 87 zm_assert(0); 88 } 89 wd->zfcbAuthNotify = cbFuncTbl->zfcbAuthNotify; 90 wd->zfcbAuthNotify = cbFuncTbl->zfcbAuthNotify; 91 wd->zfcbAsocNotify = cbFuncTbl->zfcbAsocNotify; 92 wd->zfcbDisAsocNotify = cbFuncTbl->zfcbDisAsocNotify; 93 wd->zfcbApConnectNotify = cbFuncTbl->zfcbApConnectNotify; 94 wd->zfcbConnectNotify = cbFuncTbl->zfcbConnectNotify; 95 wd->zfcbScanNotify = cbFuncTbl->zfcbScanNotify; 96 wd->zfcbMicFailureNotify = cbFuncTbl->zfcbMicFailureNotify; 97 wd->zfcbApMicFailureNotify = cbFuncTbl->zfcbApMicFailureNotify; 98 wd->zfcbIbssPartnerNotify = cbFuncTbl->zfcbIbssPartnerNotify; 99 wd->zfcbMacAddressNotify = cbFuncTbl->zfcbMacAddressNotify; 100 wd->zfcbSendCompleteIndication = 101 cbFuncTbl->zfcbSendCompleteIndication; 102 wd->zfcbRecvEth = cbFuncTbl->zfcbRecvEth; 103 wd->zfcbRestoreBufData = cbFuncTbl->zfcbRestoreBufData; 104 wd->zfcbRecv80211 = cbFuncTbl->zfcbRecv80211; 105#ifdef ZM_ENABLE_CENC 106 wd->zfcbCencAsocNotify = cbFuncTbl->zfcbCencAsocNotify; 107#endif /* ZM_ENABLE_CENC */ 108 wd->zfcbClassifyTxPacket = cbFuncTbl->zfcbClassifyTxPacket; 109 wd->zfcbHwWatchDogNotify = cbFuncTbl->zfcbHwWatchDogNotify; 110 } 111 112 /* add by honda 0330 */ 113 cbUsbFuncTbl.zfcbUsbRecv = zfiUsbRecv; 114 cbUsbFuncTbl.zfcbUsbRegIn = zfiUsbRegIn; 115 cbUsbFuncTbl.zfcbUsbOutComplete = zfiUsbOutComplete; 116 cbUsbFuncTbl.zfcbUsbRegOutComplete = zfiUsbRegOutComplete; 117 zfwUsbRegisterCallBack(dev, &cbUsbFuncTbl); 118 /* Init OWN MAC address */ 119 wd->macAddr[0] = 0x8000; 120 wd->macAddr[1] = 0x0000; 121 wd->macAddr[2] = 0x0000; 122 123 wd->regulationTable.regionCode = 0xffff; 124 125 zfHpInit(dev, wd->frequency); 126 127 /* init region code */ 128 /* wd->regulationTable.regionCode = NULL1_WORLD; //Only 2.4g RegCode */ 129 /* zfHpGetRegulationTablefromRegionCode(dev, NULL1_WORLD); */ 130 /* zfiWlanSetDot11DMode(dev , 1); //Enable 802.11d */ 131 /* Get the first channel */ 132 /* wd->frequency = zfChGetFirstChannel(dev, &bPassive); */ 133#ifdef ZM_AP_DEBUG 134 /* wd->frequency = 2437; */ 135#endif 136 137 /* STA mode */ 138 wd->sta.mTxRate = 0x0; 139 wd->sta.uTxRate = 0x3; 140 wd->sta.mmTxRate = 0x0; 141 wd->sta.adapterState = ZM_STA_STATE_DISCONNECT; 142 wd->sta.capability[0] = 0x01; 143 wd->sta.capability[1] = 0x00; 144 145 wd->sta.preambleTypeHT = 0; 146 wd->sta.htCtrlBandwidth = 0; 147 wd->sta.htCtrlSTBC = 0; 148 wd->sta.htCtrlSG = 0; 149 wd->sta.defaultTA = 0; 150 /*wd->sta.activescanTickPerChannel = 151 *ZM_TIME_ACTIVE_SCAN/ZM_MS_PER_TICK; 152 */ 153 { 154 u8_t Dur = ZM_TIME_ACTIVE_SCAN; 155 zfwGetActiveScanDur(dev, &Dur); 156 wd->sta.activescanTickPerChannel = Dur / ZM_MS_PER_TICK; 157 158 } 159 wd->sta.passiveScanTickPerChannel = ZM_TIME_PASSIVE_SCAN/ZM_MS_PER_TICK; 160 wd->sta.bAutoReconnect = TRUE; 161 wd->sta.dropUnencryptedPkts = FALSE; 162 163 /* set default to bypass all multicast packet for linux, 164 * window XP would set 0 by wrapper initialization 165 */ 166 wd->sta.bAllMulticast = 1; 167 168 /* Initial the RIFS Status / RIFS-like frame count / RIFS count */ 169 wd->sta.rifsState = ZM_RIFS_STATE_DETECTING; 170 wd->sta.rifsLikeFrameCnt = 0; 171 wd->sta.rifsCount = 0; 172 173 wd->sta.osRxFilter = 0; 174 wd->sta.bSafeMode = 0; 175 176 /* Common */ 177 zfResetSupportRate(dev, ZM_DEFAULT_SUPPORT_RATE_DISCONNECT); 178 wd->beaconInterval = 100; 179 wd->rtsThreshold = 2346; 180 wd->fragThreshold = 32767; 181 wd->wlanMode = ZM_MODE_INFRASTRUCTURE; 182 wd->txMCS = 0xff; /* AUTO */ 183 wd->dtim = 1; 184 /* wd->txMT = 1; *//*OFDM */ 185 wd->tick = 1; 186 wd->maxTxPower2 = 0xff; 187 wd->maxTxPower5 = 0xff; 188 wd->supportMode = 0xffffffff; 189 wd->ws.adhocMode = ZM_ADHOCBAND_G; 190 wd->ws.autoSetFrequency = 0xff; 191 192 /* AP mode */ 193 /* wd->bgMode = wd->ws.bgMode; */ 194 wd->ap.ssidLen[0] = 6; 195 wd->ap.ssid[0][0] = 'Z'; 196 wd->ap.ssid[0][1] = 'D'; 197 wd->ap.ssid[0][2] = '1'; 198 wd->ap.ssid[0][3] = '2'; 199 wd->ap.ssid[0][4] = '2'; 200 wd->ap.ssid[0][5] = '1'; 201 202 /* Init the country iso name as NA */ 203 wd->ws.countryIsoName[0] = 0; 204 wd->ws.countryIsoName[1] = 0; 205 wd->ws.countryIsoName[2] = '\0'; 206 207 /* init fragmentation is disabled */ 208 /* zfiWlanSetFragThreshold(dev, 0); */ 209 210 /* airopeek : swSniffer 1=>on 0=>off */ 211 wd->swSniffer = 0; 212 wd->XLinkMode = 0; 213 214 /* jhlee HT 0 */ 215 /* AP Mode*/ 216 /* Init HT Capability Info */ 217 wd->ap.HTCap.Data.ElementID = ZM_WLAN_EID_HT_CAPABILITY; 218 wd->ap.HTCap.Data.Length = 26; 219 /*wd->ap.HTCap.Data.SupChannelWidthSet = 0; 220 wd->ap.HTCap.Data.MIMOPowerSave = 3; 221 wd->ap.HTCap.Data.ShortGIfor40MHz = 0; 222 wd->ap.HTCap.Data.ShortGIfor20MHz = 0; 223 wd->ap.HTCap.Data.DSSSandCCKin40MHz = 0; 224 */ 225 wd->ap.HTCap.Data.AMPDUParam |= HTCAP_MaxRxAMPDU3; 226 wd->ap.HTCap.Data.MCSSet[0] = 0xFF; /* MCS 0 ~ 7 */ 227 wd->ap.HTCap.Data.MCSSet[1] = 0xFF; /* MCS 8 ~ 15 */ 228 229 /* Init Extended HT Capability Info */ 230 wd->ap.ExtHTCap.Data.ElementID = ZM_WLAN_EID_EXTENDED_HT_CAPABILITY; 231 wd->ap.ExtHTCap.Data.Length = 22; 232 wd->ap.ExtHTCap.Data.ControlChannel = 6; 233 /* wd->ap.ExtHTCap.Data.ExtChannelOffset = 3; */ 234 wd->ap.ExtHTCap.Data.ChannelInfo |= ExtHtCap_RecomTxWidthSet; 235 /* wd->ap.ExtHTCap.Data.RIFSMode = 1; */ 236 wd->ap.ExtHTCap.Data.OperatingInfo |= 1; 237 238 /* STA Mode*/ 239 /* Init HT Capability Info */ 240 wd->sta.HTCap.Data.ElementID = ZM_WLAN_EID_HT_CAPABILITY; 241 wd->sta.HTCap.Data.Length = 26; 242 243 /* Test with 5G-AP : 7603 */ 244 /* wd->sta.HTCap.Data.SupChannelWidthSet = 1; */ 245 wd->sta.HTCap.Data.HtCapInfo |= HTCAP_SMEnabled; 246 wd->sta.HTCap.Data.HtCapInfo |= HTCAP_SupChannelWidthSet; 247 wd->sta.HTCap.Data.HtCapInfo |= HTCAP_ShortGIfor40MHz; 248 wd->sta.HTCap.Data.HtCapInfo |= HTCAP_DSSSandCCKin40MHz; 249#ifndef ZM_DISABLE_AMSDU8K_SUPPORT 250 wd->sta.HTCap.Data.HtCapInfo |= HTCAP_MaxAMSDULength; 251#endif 252 /*wd->sta.HTCap.Data.MIMOPowerSave = 0; 253 wd->sta.HTCap.Data.ShortGIfor40MHz = 0; 254 wd->sta.HTCap.Data.ShortGIfor20MHz = 0; 255 wd->sta.HTCap.Data.DSSSandCCKin40MHz = 0; 256 */ 257 wd->sta.HTCap.Data.AMPDUParam |= HTCAP_MaxRxAMPDU3; 258 wd->sta.HTCap.Data.MCSSet[0] = 0xFF; /* MCS 0 ~ 7 */ 259 wd->sta.HTCap.Data.MCSSet[1] = 0xFF; /* MCS 8 ~ 15 */ 260 wd->sta.HTCap.Data.PCO |= HTCAP_TransmissionTime3; 261 /* wd->sta.HTCap.Data.TransmissionTime = 0; */ 262 /* Init Extended HT Capability Info */ 263 wd->sta.ExtHTCap.Data.ElementID = ZM_WLAN_EID_EXTENDED_HT_CAPABILITY; 264 wd->sta.ExtHTCap.Data.Length = 22; 265 wd->sta.ExtHTCap.Data.ControlChannel = 6; 266 267 /* wd->sta.ExtHTCap.Data.ExtChannelOffset |= 3; */ 268 wd->sta.ExtHTCap.Data.ChannelInfo |= ExtHtCap_ExtChannelOffsetBelow; 269 270 /* wd->sta.ExtHTCap.Data.RecomTxWidthSet = 1; */ 271 /* wd->sta.ExtHTCap.Data.RIFSMode = 1; */ 272 wd->sta.ExtHTCap.Data.OperatingInfo |= 1; 273 274 275 wd->ledStruct.ledMode[0] = 0x2221; 276 wd->ledStruct.ledMode[1] = 0x2221; 277 278 zfTimerInit(dev); 279 280 ZM_PERFORMANCE_INIT(dev); 281 282 zfBssInfoCreate(dev); 283 zfScanMgrInit(dev); 284 zfPowerSavingMgrInit(dev); 285 286 287 /* WME settings */ 288 wd->ws.staWmeEnabled = 1; /* Enable WME by default */ 289#define ZM_UAPSD_Q_SIZE 32 /* 2^N */ 290 wd->ap.uapsdQ = zfQueueCreate(dev, ZM_UAPSD_Q_SIZE); 291 zm_assert(wd->ap.uapsdQ != NULL); 292 wd->sta.uapsdQ = zfQueueCreate(dev, ZM_UAPSD_Q_SIZE); 293 zm_assert(wd->sta.uapsdQ != NULL); 294 295 /* zfHpInit(dev, wd->frequency); */ 296 297 /* MAC address */ 298 /* zfHpSetMacAddress(dev, wd->macAddr, 0); */ 299 zfHpGetMacAddress(dev); 300 301 zfCoreSetFrequency(dev, wd->frequency); 302 303#if ZM_PCI_LOOP_BACK == 1 304 zfwWriteReg(dev, ZM_REG_PCI_CONTROL, 6); 305#endif /* #if ZM_PCI_LOOP_BACK == 1 */ 306 307 /* zfiWlanSetDot11DMode(dev , 1); // Enable 802.11d */ 308 /* zfiWlanSetDot11HDFSMode(dev , 1); // Enable 802.11h DFS */ 309 wd->sta.DFSEnable = 1; 310 wd->sta.capability[1] |= ZM_BIT_0; 311 312 /* zfiWlanSetFrequency(dev, 5260000, TRUE); */ 313 /* zfiWlanSetAniMode(dev , 1); // Enable ANI */ 314 315 /* Trgger Rx DMA */ 316 zfHpStartRecv(dev); 317 318 zm_debug_msg0("end"); 319 320 return 0; 321} 322 323/* WLAN hardware will be shutdown and all resource will be release */ 324u16_t zfiWlanClose(zdev_t *dev) 325{ 326 zmw_get_wlan_dev(dev); 327 328 zm_msg0_init(ZM_LV_0, "enter"); 329 330 wd->state = ZM_WLAN_STATE_CLOSEDED; 331 332 /* zfiWlanDisable(dev, 1); */ 333 zfWlanReset(dev); 334 335 zfHpStopRecv(dev); 336 337 /* Disable MAC */ 338 /* Disable PHY */ 339 /* Disable RF */ 340 341 zfHpRelease(dev); 342 343 zfQueueDestroy(dev, wd->ap.uapsdQ); 344 zfQueueDestroy(dev, wd->sta.uapsdQ); 345 346 zfBssInfoDestroy(dev); 347 348#ifdef ZM_ENABLE_AGGREGATION 349 /* add by honda */ 350 zfAggRxFreeBuf(dev, 1); /* 1 for release structure memory */ 351 /* end of add by honda */ 352#endif 353 354 zm_msg0_init(ZM_LV_0, "exit"); 355 356 return 0; 357} 358 359void zfGetWrapperSetting(zdev_t *dev) 360{ 361 u8_t bPassive; 362 u16_t vapId = 0; 363 364 zmw_get_wlan_dev(dev); 365 366 zmw_declare_for_critical_section(); 367 zmw_enter_critical_section(dev); 368 369 wd->wlanMode = wd->ws.wlanMode; 370 371 /* set channel */ 372 if (wd->ws.frequency) { 373 wd->frequency = wd->ws.frequency; 374 wd->ws.frequency = 0; 375 } else { 376 wd->frequency = zfChGetFirstChannel(dev, &bPassive); 377 378 if (wd->wlanMode == ZM_MODE_IBSS) { 379 if (wd->ws.adhocMode == ZM_ADHOCBAND_A) 380 wd->frequency = ZM_CH_A_36; 381 else 382 wd->frequency = ZM_CH_G_6; 383 } 384 } 385#ifdef ZM_AP_DEBUG 386 /* honda add for debug, 2437 channel 6, 2452 channel 9 */ 387 wd->frequency = 2437; 388 /* end of add by honda */ 389#endif 390 391 /* set preamble type */ 392 switch (wd->ws.preambleType) { 393 case ZM_PREAMBLE_TYPE_AUTO: 394 case ZM_PREAMBLE_TYPE_SHORT: 395 case ZM_PREAMBLE_TYPE_LONG: 396 wd->preambleType = wd->ws.preambleType; 397 break; 398 default: 399 wd->preambleType = ZM_PREAMBLE_TYPE_SHORT; 400 break; 401 } 402 wd->ws.preambleType = 0; 403 404 if (wd->wlanMode == ZM_MODE_AP) { 405 vapId = zfwGetVapId(dev); 406 407 if (vapId == 0xffff) { 408 wd->ap.authAlgo[0] = wd->ws.authMode; 409 wd->ap.encryMode[0] = wd->ws.encryMode; 410 } else { 411 wd->ap.authAlgo[vapId + 1] = wd->ws.authMode; 412 wd->ap.encryMode[vapId + 1] = wd->ws.encryMode; 413 } 414 wd->ws.authMode = 0; 415 wd->ws.encryMode = ZM_NO_WEP; 416 417 /* Get beaconInterval from WrapperSetting */ 418 if ((wd->ws.beaconInterval >= 20) && 419 (wd->ws.beaconInterval <= 1000)) 420 wd->beaconInterval = wd->ws.beaconInterval; 421 else 422 wd->beaconInterval = 100; /* 100ms */ 423 424 if (wd->ws.dtim > 0) 425 wd->dtim = wd->ws.dtim; 426 else 427 wd->dtim = 1; 428 429 430 wd->ap.qosMode = wd->ws.apWmeEnabled & 0x1; 431 wd->ap.uapsdEnabled = (wd->ws.apWmeEnabled & 0x2) >> 1; 432 } else { 433 wd->sta.authMode = wd->ws.authMode; 434 wd->sta.currentAuthMode = wd->ws.authMode; 435 wd->sta.wepStatus = wd->ws.wepStatus; 436 437 if (wd->ws.beaconInterval) 438 wd->beaconInterval = wd->ws.beaconInterval; 439 else 440 wd->beaconInterval = 0x64; 441 442 if (wd->wlanMode == ZM_MODE_IBSS) { 443 /* 1. Set default channel 6 (2437MHz) */ 444 /* wd->frequency = 2437; */ 445 446 /* 2. Otus support 802.11g Mode */ 447 if ((wd->ws.adhocMode == ZM_ADHOCBAND_G) || 448 (wd->ws.adhocMode == ZM_ADHOCBAND_BG) || 449 (wd->ws.adhocMode == ZM_ADHOCBAND_ABG)) 450 wd->wfc.bIbssGMode = 1; 451 else 452 wd->wfc.bIbssGMode = 0; 453 454 /* 3. set short preamble */ 455 /* wd->sta.preambleType = ZM_PREAMBLE_TYPE_SHORT; */ 456 } 457 458 /* set ATIM window */ 459 if (wd->ws.atimWindow) 460 wd->sta.atimWindow = wd->ws.atimWindow; 461 else { 462 /* wd->sta.atimWindow = 0x0a; */ 463 wd->sta.atimWindow = 0; 464 } 465 466 /* wd->sta.connectingHiddenAP = 1; 467 wd->ws.connectingHiddenAP; 468 */ 469 wd->sta.dropUnencryptedPkts = wd->ws.dropUnencryptedPkts; 470 wd->sta.ibssJoinOnly = wd->ws.ibssJoinOnly; 471 472 if (wd->ws.bDesiredBssid) { 473 zfMemoryCopy(wd->sta.desiredBssid, 474 wd->ws.desiredBssid, 6); 475 wd->sta.bDesiredBssid = TRUE; 476 wd->ws.bDesiredBssid = FALSE; 477 } else 478 wd->sta.bDesiredBssid = FALSE; 479 480 /* check ssid */ 481 if (wd->ws.ssidLen != 0) { 482 if ((!zfMemoryIsEqual(wd->ws.ssid, wd->sta.ssid, 483 wd->sta.ssidLen)) || 484 (wd->ws.ssidLen != wd->sta.ssidLen) || 485 (wd->sta.authMode == ZM_AUTH_MODE_WPA) || 486 (wd->sta.authMode == ZM_AUTH_MODE_WPAPSK) || 487 (wd->ws.staWmeQosInfo != 0)) { 488 /* if u-APSD test(set QosInfo), clear 489 connectByReasso to do association 490 (not reassociation) 491 */ 492 wd->sta.connectByReasso = FALSE; 493 wd->sta.failCntOfReasso = 0; 494 wd->sta.pmkidInfo.bssidCount = 0; 495 496 wd->sta.ssidLen = wd->ws.ssidLen; 497 zfMemoryCopy(wd->sta.ssid, wd->ws.ssid, 498 wd->sta.ssidLen); 499 500 if (wd->sta.ssidLen < 32) 501 wd->sta.ssid[wd->sta.ssidLen] = 0; 502 } 503 } else { 504 /* ANY BSS */ 505 wd->sta.ssid[0] = 0; 506 wd->sta.ssidLen = 0; 507 } 508 509 wd->sta.wmeEnabled = wd->ws.staWmeEnabled; 510 wd->sta.wmeQosInfo = wd->ws.staWmeQosInfo; 511 512 } 513 514 zmw_leave_critical_section(dev); 515} 516 517u16_t zfWlanEnable(zdev_t *dev) 518{ 519 u8_t bssid[6] = {0x0, 0x0, 0x0, 0x0, 0x0, 0x0}; 520 u16_t i; 521 522 zmw_get_wlan_dev(dev); 523 524 zmw_declare_for_critical_section(); 525 526 if (wd->wlanMode == ZM_MODE_UNKNOWN) { 527 zm_debug_msg0("Unknown Mode...Skip..."); 528 return 0; 529 } 530 531 if (wd->wlanMode == ZM_MODE_AP) { 532 u16_t vapId; 533 534 vapId = zfwGetVapId(dev); 535 536 if (vapId == 0xffff) { 537 /* AP mode */ 538 zfApInitStaTbl(dev); 539 540 /* AP default parameters */ 541 wd->bRate = 0xf; 542 wd->gRate = 0xff; 543 wd->bRateBasic = 0xf; 544 wd->gRateBasic = 0x0; 545 /* wd->beaconInterval = 100; */ 546 wd->ap.apBitmap = 1; 547 wd->ap.beaconCounter = 0; 548 /* wd->ap.vapNumber = 1; //mark by ygwei for Vap */ 549 550 wd->ap.hideSsid[0] = 0; 551 wd->ap.staAgingTimeSec = 10*60; 552 wd->ap.staProbingTimeSec = 60; 553 554 for (i = 0; i < ZM_MAX_AP_SUPPORT; i++) 555 wd->ap.bcmcHead[i] = wd->ap.bcmcTail[i] = 0; 556 557 /* wd->ap.uniHead = wd->ap.uniTail = 0; */ 558 559 /* load AP parameters */ 560 wd->bRateBasic = wd->ws.bRateBasic; 561 wd->gRateBasic = wd->ws.gRateBasic; 562 wd->bgMode = wd->ws.bgMode; 563 if ((wd->ws.ssidLen <= 32) && (wd->ws.ssidLen != 0)) { 564 wd->ap.ssidLen[0] = wd->ws.ssidLen; 565 for (i = 0; i < wd->ws.ssidLen; i++) 566 wd->ap.ssid[0][i] = wd->ws.ssid[i]; 567 wd->ws.ssidLen = 0; /* Reset Wrapper Variable */ 568 } 569 570 if (wd->ap.encryMode[0] == 0) 571 wd->ap.capab[0] = 0x001; 572 else 573 wd->ap.capab[0] = 0x011; 574 /* set Short Slot Time bit if not 11b */ 575 if (wd->ap.wlanType[0] != ZM_WLAN_TYPE_PURE_B) 576 wd->ap.capab[0] |= 0x400; 577 578 /* wd->ap.vapNumber = 1; //mark by ygwei for Vap Test */ 579 } else { 580 /* VAP Test Code */ 581 wd->ap.apBitmap = 0x1 | (0x01 << (vapId+1)); 582 583 if ((wd->ws.ssidLen <= 32) && (wd->ws.ssidLen != 0)) { 584 wd->ap.ssidLen[vapId+1] = wd->ws.ssidLen; 585 for (i = 0; i < wd->ws.ssidLen; i++) 586 wd->ap.ssid[vapId+1][i] = 587 wd->ws.ssid[i]; 588 wd->ws.ssidLen = 0; /* Reset Wrapper Variable */ 589 } 590 591 if (wd->ap.encryMode[vapId+1] == 0) 592 wd->ap.capab[vapId+1] = 0x401; 593 else 594 wd->ap.capab[vapId+1] = 0x411; 595 596 wd->ap.authAlgo[vapId+1] = wd->ws.authMode; 597 wd->ap.encryMode[vapId+1] = wd->ws.encryMode; 598 599 /* Need to be modified when VAP is used */ 600 /* wd->ap.vapNumber = 2; */ 601 } 602 603 wd->ap.vapNumber++; 604 605 zfCoreSetFrequency(dev, wd->frequency); 606 607 zfInitMacApMode(dev); 608 609 /* Disable protection mode */ 610 zfApSetProtectionMode(dev, 0); 611 612 zfApSendBeacon(dev); 613 } else { /*if (wd->wlanMode == ZM_MODE_AP) */ 614 615 zfScanMgrScanStop(dev, ZM_SCAN_MGR_SCAN_INTERNAL); 616 zfScanMgrScanStop(dev, ZM_SCAN_MGR_SCAN_EXTERNAL); 617 618 zmw_enter_critical_section(dev); 619 wd->sta.oppositeCount = 0; /* reset opposite count */ 620 /* wd->sta.bAutoReconnect = wd->sta.bAutoReconnectEnabled; */ 621 /* wd->sta.scanWithSSID = 0; */ 622 zfStaInitOppositeInfo(dev); 623 zmw_leave_critical_section(dev); 624 625 zfStaResetStatus(dev, 0); 626 627 if ((wd->sta.cmDisallowSsidLength != 0) && 628 (wd->sta.ssidLen == wd->sta.cmDisallowSsidLength) && 629 (zfMemoryIsEqual(wd->sta.ssid, wd->sta.cmDisallowSsid, 630 wd->sta.ssidLen)) && 631 (wd->sta.wepStatus == ZM_ENCRYPTION_TKIP)) {/*countermeasures*/ 632 zm_debug_msg0("countermeasures disallow association"); 633 } else { 634 switch (wd->wlanMode) { 635 case ZM_MODE_IBSS: 636 /* some registers may be set here */ 637 if (wd->sta.authMode == ZM_AUTH_MODE_WPA2PSK) 638 zfHpSetApStaMode(dev, 639 ZM_HAL_80211_MODE_IBSS_WPA2PSK); 640 else 641 zfHpSetApStaMode(dev, 642 ZM_HAL_80211_MODE_IBSS_GENERAL); 643 644 zm_msg0_mm(ZM_LV_0, "ZM_MODE_IBSS"); 645 zfIbssConnectNetwork(dev); 646 break; 647 648 case ZM_MODE_INFRASTRUCTURE: 649 /* some registers may be set here */ 650 zfHpSetApStaMode(dev, ZM_HAL_80211_MODE_STA); 651 652 zfInfraConnectNetwork(dev); 653 break; 654 655 case ZM_MODE_PSEUDO: 656 /* some registers may be set here */ 657 zfHpSetApStaMode(dev, ZM_HAL_80211_MODE_STA); 658 659 zfUpdateBssid(dev, bssid); 660 zfCoreSetFrequency(dev, wd->frequency); 661 break; 662 663 default: 664 break; 665 } 666 } 667 668 } 669 670 671 /* if ((wd->wlanMode != ZM_MODE_INFRASTRUCTURE) && 672 (wd->wlanMode != ZM_MODE_AP)) 673 */ 674 if (wd->wlanMode == ZM_MODE_PSEUDO) { 675 /* Reset Wlan status */ 676 zfWlanReset(dev); 677 678 if (wd->zfcbConnectNotify != NULL) 679 wd->zfcbConnectNotify(dev, ZM_STATUS_MEDIA_CONNECT, 680 wd->sta.bssid); 681 zfChangeAdapterState(dev, ZM_STA_STATE_CONNECTED); 682 } 683 684 685 if (wd->wlanMode == ZM_MODE_AP) { 686 if (wd->zfcbConnectNotify != NULL) 687 wd->zfcbConnectNotify(dev, ZM_STATUS_MEDIA_CONNECT, 688 wd->sta.bssid); 689 /* zfChangeAdapterState(dev, ZM_STA_STATE_CONNECTED); */ 690 } 691 692 /* Assign default Tx Rate */ 693 if (wd->sta.EnableHT) { 694 u32_t oneTxStreamCap; 695 oneTxStreamCap = (zfHpCapability(dev) & 696 ZM_HP_CAP_11N_ONE_TX_STREAM); 697 if (oneTxStreamCap) 698 wd->CurrentTxRateKbps = 135000; 699 else 700 wd->CurrentTxRateKbps = 270000; 701 wd->CurrentRxRateKbps = 270000; 702 } else { 703 wd->CurrentTxRateKbps = 54000; 704 wd->CurrentRxRateKbps = 54000; 705 } 706 707 wd->state = ZM_WLAN_STATE_ENABLED; 708 709 return 0; 710} 711 712/* Enable/disable Wlan operation */ 713u16_t zfiWlanEnable(zdev_t *dev) 714{ 715 u16_t ret; 716 717 zmw_get_wlan_dev(dev); 718 719 zm_msg0_mm(ZM_LV_1, "Enable Wlan"); 720 721 zfGetWrapperSetting(dev); 722 723 zfZeroMemory((u8_t *) &wd->trafTally, sizeof(struct zsTrafTally)); 724 725 /* Reset cmMicFailureCount to 0 for new association request */ 726 if (wd->sta.cmMicFailureCount == 1) { 727 zfTimerCancel(dev, ZM_EVENT_CM_TIMER); 728 wd->sta.cmMicFailureCount = 0; 729 } 730 731 zfFlushVtxq(dev); 732 if ((wd->queueFlushed & 0x10) != 0) 733 zfHpUsbReset(dev); 734 735 ret = zfWlanEnable(dev); 736 737 return ret; 738} 739/* Add a flag named ResetKeyCache to show if KeyCache should be cleared. 740 for hostapd in AP mode, if driver receives iwconfig ioctl 741 after setting group key, it shouldn't clear KeyCache. 742*/ 743u16_t zfiWlanDisable(zdev_t *dev, u8_t ResetKeyCache) 744{ 745 u16_t i; 746 u8_t isConnected; 747 748 zmw_get_wlan_dev(dev); 749 750#ifdef ZM_ENABLE_IBSS_WPA2PSK 751 zmw_declare_for_critical_section(); 752#endif 753 wd->state = ZM_WLAN_STATE_DISABLED; 754 755 zm_msg0_mm(ZM_LV_1, "Disable Wlan"); 756 757 if (wd->wlanMode != ZM_MODE_AP) { 758 isConnected = zfStaIsConnected(dev); 759 760 if ((wd->wlanMode == ZM_MODE_INFRASTRUCTURE) && 761 (wd->sta.currentAuthMode != ZM_AUTH_MODE_WPA2)) { 762 /* send deauthentication frame */ 763 if (isConnected) { 764 /* zfiWlanDeauth(dev, NULL, 0); */ 765 zfSendMmFrame(dev, ZM_WLAN_FRAME_TYPE_DEAUTH, 766 wd->sta.bssid, 3, 0, 0); 767 /* zmw_debug_msg0("send a Deauth frame!"); */ 768 } 769 } 770 771 /* Remove all the connected peer stations */ 772 if (wd->wlanMode == ZM_MODE_IBSS) { 773 wd->sta.ibssBssIsCreator = 0; 774 zfTimerCancel(dev, ZM_EVENT_IBSS_MONITOR); 775 zfStaIbssMonitoring(dev, 1); 776 } 777 778#ifdef ZM_ENABLE_IBSS_WPA2PSK 779 zmw_enter_critical_section(dev); 780 wd->sta.ibssWpa2Psk = 0; 781 zmw_leave_critical_section(dev); 782#endif 783 784 wd->sta.wpaState = ZM_STA_WPA_STATE_INIT; 785 786 /* reset connect timeout counter */ 787 wd->sta.connectTimeoutCount = 0; 788 789 /* reset connectState to None */ 790 wd->sta.connectState = ZM_STA_CONN_STATE_NONE; 791 792 /* reset leap enable variable */ 793 wd->sta.leapEnabled = 0; 794 795 /* Disable the RIFS Status/RIFS-like frame count/RIFS count */ 796 if (wd->sta.rifsState == ZM_RIFS_STATE_DETECTED) 797 zfHpDisableRifs(dev); 798 wd->sta.rifsState = ZM_RIFS_STATE_DETECTING; 799 wd->sta.rifsLikeFrameCnt = 0; 800 wd->sta.rifsCount = 0; 801 802 wd->sta.osRxFilter = 0; 803 wd->sta.bSafeMode = 0; 804 805 zfChangeAdapterState(dev, ZM_STA_STATE_DISCONNECT); 806 if (ResetKeyCache) 807 zfHpResetKeyCache(dev); 808 809 if (isConnected) { 810 if (wd->zfcbConnectNotify != NULL) 811 wd->zfcbConnectNotify(dev, 812 ZM_STATUS_MEDIA_CONNECTION_DISABLED, 813 wd->sta.bssid); 814 } else { 815 if (wd->zfcbConnectNotify != NULL) 816 wd->zfcbConnectNotify(dev, 817 ZM_STATUS_MEDIA_DISABLED, wd->sta.bssid); 818 } 819 } else { /* if (wd->wlanMode == ZM_MODE_AP) */ 820 for (i = 0; i < ZM_MAX_STA_SUPPORT; i++) { 821 /* send deauthentication frame */ 822 if (wd->ap.staTable[i].valid == 1) { 823 /* Reason : Sending station is leaving */ 824 zfSendMmFrame(dev, ZM_WLAN_FRAME_TYPE_DEAUTH, 825 wd->ap.staTable[i].addr, 3, 0, 0); 826 } 827 } 828 829 if (ResetKeyCache) 830 zfHpResetKeyCache(dev); 831 832 wd->ap.vapNumber--; 833 } 834 835 /* stop beacon */ 836 zfHpDisableBeacon(dev); 837 838 /* Flush VTxQ and MmQ */ 839 zfFlushVtxq(dev); 840 /* Flush AP PS queues */ 841 zfApFlushBufferedPsFrame(dev); 842 /* Free buffer in defragment list*/ 843 zfAgingDefragList(dev, 1); 844 845#ifdef ZM_ENABLE_AGGREGATION 846 /* add by honda */ 847 zfAggRxFreeBuf(dev, 0); /* 1 for release structure memory */ 848 /* end of add by honda */ 849#endif 850 851 /* Clear the information for the peer stations 852 of IBSS or AP of Station mode 853 */ 854 zfZeroMemory((u8_t *)wd->sta.oppositeInfo, 855 sizeof(struct zsOppositeInfo) * ZM_MAX_OPPOSITE_COUNT); 856 857 /* Turn off Software WEP/TKIP */ 858 if (wd->sta.SWEncryptEnable != 0) { 859 zm_debug_msg0("Disable software encryption"); 860 zfStaDisableSWEncryption(dev); 861 } 862 863 /* Improve WEP/TKIP performance with HT AP, 864 detail information please look bug#32495 */ 865 /* zfHpSetTTSIFSTime(dev, 0x8); */ 866 867 return 0; 868} 869 870u16_t zfiWlanSuspend(zdev_t *dev) 871{ 872 zmw_get_wlan_dev(dev); 873 zmw_declare_for_critical_section(); 874 875 /* Change the HAL state to init so that any packet 876 can't be transmitted between resume & HAL reinit. 877 This would cause the chip hang issue in OTUS. 878 */ 879 zmw_enter_critical_section(dev); 880 wd->halState = ZM_HAL_STATE_INIT; 881 zmw_leave_critical_section(dev); 882 883 return 0; 884} 885 886u16_t zfiWlanResume(zdev_t *dev, u8_t doReconn) 887{ 888 u16_t ret; 889 zmw_get_wlan_dev(dev); 890 zmw_declare_for_critical_section(); 891 892 /* Redownload firmware, Reinit MAC,PHY,RF */ 893 zfHpReinit(dev, wd->frequency); 894 895 /* Set channel according to AP's configuration */ 896 zfCoreSetFrequencyExV2(dev, wd->frequency, wd->BandWidth40, 897 wd->ExtOffset, NULL, 1); 898 899 zfHpSetMacAddress(dev, wd->macAddr, 0); 900 901 /* Start Rx */ 902 zfHpStartRecv(dev); 903 904 zfFlushVtxq(dev); 905 906 if (wd->wlanMode != ZM_MODE_INFRASTRUCTURE && 907 wd->wlanMode != ZM_MODE_IBSS) 908 return 1; 909 910 zm_msg0_mm(ZM_LV_1, "Resume Wlan"); 911 if ((zfStaIsConnected(dev)) || (zfStaIsConnecting(dev))) { 912 if (doReconn == 1) { 913 zm_msg0_mm(ZM_LV_1, "Re-connect..."); 914 zmw_enter_critical_section(dev); 915 wd->sta.connectByReasso = FALSE; 916 zmw_leave_critical_section(dev); 917 918 zfWlanEnable(dev); 919 } else if (doReconn == 0) 920 zfHpSetRollCallTable(dev); 921 } 922 923 ret = 0; 924 925 return ret; 926} 927 928/************************************************************************/ 929/* */ 930/* FUNCTION DESCRIPTION zfiWlanFlushAllQueuedBuffers */ 931/* Flush Virtual TxQ, MmQ, PS frames and defragment list */ 932/* */ 933/* INPUTS */ 934/* dev : device pointer */ 935/* */ 936/* OUTPUTS */ 937/* None */ 938/* */ 939/* AUTHOR */ 940/* Stephen Chen Atheros Communications, INC. 2007.1 */ 941/* */ 942/************************************************************************/ 943void zfiWlanFlushAllQueuedBuffers(zdev_t *dev) 944{ 945 /* Flush VTxQ and MmQ */ 946 zfFlushVtxq(dev); 947 /* Flush AP PS queues */ 948 zfApFlushBufferedPsFrame(dev); 949 /* Free buffer in defragment list*/ 950 zfAgingDefragList(dev, 1); 951} 952 953/* Do WLAN site survey */ 954u16_t zfiWlanScan(zdev_t *dev) 955{ 956 u16_t ret = 1; 957 zmw_get_wlan_dev(dev); 958 959 zm_debug_msg0(""); 960 961 zmw_declare_for_critical_section(); 962 963 zmw_enter_critical_section(dev); 964 965 if (wd->wlanMode == ZM_MODE_AP) { 966 wd->heartBeatNotification |= ZM_BSSID_LIST_SCAN; 967 wd->sta.scanFrequency = 0; 968 /* wd->sta.pUpdateBssList->bssCount = 0; */ 969 ret = 0; 970 } else { 971 goto start_scan; 972 } 973 974 zmw_leave_critical_section(dev); 975 976 return ret; 977 978start_scan: 979 zmw_leave_critical_section(dev); 980 981 if (wd->ledStruct.LEDCtrlFlagFromReg & ZM_LED_CTRL_FLAG_ALPHA) { 982 /* flag for Alpha */ 983 wd->ledStruct.LEDCtrlFlag |= ZM_LED_CTRL_FLAG_ALPHA; 984 } 985 986 ret = zfScanMgrScanStart(dev, ZM_SCAN_MGR_SCAN_EXTERNAL); 987 988 zm_debug_msg1("ret = ", ret); 989 990 return ret; 991} 992 993 994/* rate */ 995/* 0 : AUTO */ 996/* 1 : CCK 1M */ 997/* 2 : CCK 2M */ 998/* 3 : CCK 5.5M */ 999/* 4 : CCK 11M */ 1000/* 5 : OFDM 6M */ 1001/* 6 : OFDM 9M */ 1002/* 7 : OFDM 12M */ 1003/* 8 : OFDM 18M */ 1004/* 9 : OFDM 24M */ 1005/* 10 : OFDM 36M */ 1006/* 11 : OFDM 48M */ 1007/* 12 : OFDM 54M */ 1008/* 13 : MCS 0 */ 1009/* 28 : MCS 15 */ 1010u16_t zcRateToMCS[] = 1011 {0xff, 0, 1, 2, 3, 0xb, 0xf, 0xa, 0xe, 0x9, 0xd, 0x8, 0xc}; 1012u16_t zcRateToMT[] = {0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1}; 1013 1014u16_t zfiWlanSetTxRate(zdev_t *dev, u16_t rate) 1015{ 1016 /* jhlee HT 0 */ 1017 zmw_get_wlan_dev(dev); 1018 1019 if (rate <= 12) { 1020 wd->txMCS = zcRateToMCS[rate]; 1021 wd->txMT = zcRateToMT[rate]; 1022 return ZM_SUCCESS; 1023 } else if ((rate <= 28) || (rate == 13 + 32)) { 1024 wd->txMCS = rate - 12 - 1; 1025 wd->txMT = 2; 1026 return ZM_SUCCESS; 1027 } 1028 1029 return ZM_ERR_INVALID_TX_RATE; 1030} 1031 1032const u32_t zcRateIdToKbps40M[] = 1033{ 1034 1000, 2000, 5500, 11000, /* 1M, 2M, 5M, 11M , 0 1 2 3 */ 1035 6000, 9000, 12000, 18000, /* 6M 9M 12M 18M , 4 5 6 7 */ 1036 24000, 36000, 48000, 54000, /* 24M 36M 48M 54M , 8 9 10 11 */ 1037 13500, 27000, 40500, 54000, /* MCS0 MCS1 MCS2 MCS3 , 12 13 14 15 */ 1038 81000, 108000, 121500, 135000, /* MCS4 MCS5 MCS6 MCS7 , 16 17 18 19 */ 1039 27000, 54000, 81000, 108000, /* MCS8 MCS9 MCS10 MCS11 , 20 21 22 23 */ 1040 162000, 216000, 243000, 270000, /*MCS12 MCS13 MCS14 MCS15, 24 25 26 27*/ 1041 270000, 300000, 150000 /* MCS14SG, MCS15SG, MCS7SG , 28 29 30 */ 1042}; 1043 1044const u32_t zcRateIdToKbps20M[] = 1045{ 1046 1000, 2000, 5500, 11000, /* 1M, 2M, 5M, 11M , 0 1 2 3 */ 1047 6000, 9000, 12000, 18000, /* 6M 9M 12M 18M , 4 5 6 7 */ 1048 24000, 36000, 48000, 54000, /* 24M 36M 48M 54M , 8 9 10 11 */ 1049 6500, 13000, 19500, 26000, /* MCS0 MCS1 MCS2 MCS3 , 12 13 14 15 */ 1050 39000, 52000, 58500, 65000, /* MCS4 MCS5 MCS6 MCS7 , 16 17 18 19 */ 1051 13000, 26000, 39000, 52000, /* MCS8 MCS9 MCS10 MCS11 , 20 21 22 23 */ 1052 78000, 104000, 117000, 130000, /* MCS12 MCS13 MCS14 MCS15, 24 25 26 27*/ 1053 130000, 144400, 72200 /* MCS14SG, MCS15SG, MSG7SG , 28 29 30 */ 1054}; 1055 1056u32_t zfiWlanQueryTxRate(zdev_t *dev) 1057{ 1058 u8_t rateId = 0xff; 1059 zmw_get_wlan_dev(dev); 1060 zmw_declare_for_critical_section(); 1061 1062 /* If Tx rate had not been trained, return maximum Tx rate instead */ 1063 if ((wd->wlanMode == ZM_MODE_INFRASTRUCTURE) && 1064 (zfStaIsConnected(dev))) { 1065 zmw_enter_critical_section(dev); 1066 /* Not in fixed rate mode */ 1067 if (wd->txMCS == 0xff) { 1068 if ((wd->sta.oppositeInfo[0].rcCell.flag & 1069 ZM_RC_TRAINED_BIT) == 0) 1070 rateId = wd->sta.oppositeInfo[0].rcCell. \ 1071 operationRateSet[wd->sta.oppositeInfo[0]. \ 1072 rcCell.operationRateCount-1]; 1073 else 1074 rateId = wd->sta.oppositeInfo[0].rcCell. \ 1075 operationRateSet[wd->sta.oppositeInfo[0]. \ 1076 rcCell.currentRateIndex]; 1077 } 1078 zmw_leave_critical_section(dev); 1079 } 1080 1081 if (rateId != 0xff) { 1082 if (wd->sta.htCtrlBandwidth) 1083 return zcRateIdToKbps40M[rateId]; 1084 else 1085 return zcRateIdToKbps20M[rateId]; 1086 } else 1087 return wd->CurrentTxRateKbps; 1088} 1089 1090void zfWlanUpdateRxRate(zdev_t *dev, struct zsAdditionInfo *addInfo) 1091{ 1092 u32_t rxRateKbps; 1093 zmw_get_wlan_dev(dev); 1094 /* zm_msg1_mm(ZM_LV_0, "addInfo->Tail.Data.RxMacStatus =", 1095 * addInfo->Tail.Data.RxMacStatus & 0x03); 1096 */ 1097 1098 /* b5~b4: MPDU indication. */ 1099 /* 00: Single MPDU. */ 1100 /* 10: First MPDU of A-MPDU. */ 1101 /* 11: Middle MPDU of A-MPDU. */ 1102 /* 01: Last MPDU of A-MPDU. */ 1103 /* Only First MPDU and Single MPDU have PLCP header */ 1104 /* First MPDU : (mpduInd & 0x30) == 0x00 */ 1105 /* Single MPDU : (mpduInd & 0x30) == 0x20 */ 1106 if ((addInfo->Tail.Data.RxMacStatus & 0x10) == 0) { 1107 /* Modulation type */ 1108 wd->modulationType = addInfo->Tail.Data.RxMacStatus & 0x03; 1109 switch (wd->modulationType) { 1110 /* CCK mode */ 1111 case 0x0: 1112 wd->rateField = addInfo->PlcpHeader[0] & 0xff; 1113 wd->rxInfo = 0; 1114 break; 1115 /* Legacy-OFDM mode */ 1116 case 0x1: 1117 wd->rateField = addInfo->PlcpHeader[0] & 0x0f; 1118 wd->rxInfo = 0; 1119 break; 1120 /* HT-OFDM mode */ 1121 case 0x2: 1122 wd->rateField = addInfo->PlcpHeader[3]; 1123 wd->rxInfo = addInfo->PlcpHeader[6]; 1124 break; 1125 default: 1126 break; 1127 } 1128 1129 rxRateKbps = zfUpdateRxRate(dev); 1130 if (wd->CurrentRxRateUpdated == 1) { 1131 if (rxRateKbps > wd->CurrentRxRateKbps) 1132 wd->CurrentRxRateKbps = rxRateKbps; 1133 } else { 1134 wd->CurrentRxRateKbps = rxRateKbps; 1135 wd->CurrentRxRateUpdated = 1; 1136 } 1137 } 1138} 1139 1140 1141extern u16_t zcIndextoRateBG[16]; 1142extern u32_t zcIndextoRateN20L[16]; 1143extern u32_t zcIndextoRateN20S[16]; 1144extern u32_t zcIndextoRateN40L[16]; 1145extern u32_t zcIndextoRateN40S[16]; 1146 1147u32_t zfiWlanQueryRxRate(zdev_t *dev) 1148{ 1149 zmw_get_wlan_dev(dev); 1150 1151 wd->CurrentRxRateUpdated = 0; 1152 return wd->CurrentRxRateKbps; 1153} 1154 1155u32_t zfUpdateRxRate(zdev_t *dev) 1156{ 1157 u8_t mcs, bandwidth; 1158 u32_t rxRateKbps = 130000; 1159 zmw_get_wlan_dev(dev); 1160 1161 switch (wd->modulationType) { 1162 /* CCK mode */ 1163 case 0x0: 1164 switch (wd->rateField) { 1165 case 0x0a: 1166 rxRateKbps = 1000; 1167 break; 1168 case 0x14: 1169 rxRateKbps = 2000; 1170 1171 case 0x37: 1172 rxRateKbps = 5500; 1173 break; 1174 case 0x6e: 1175 rxRateKbps = 11000; 1176 break; 1177 default: 1178 break; 1179 } 1180 break; 1181 /* Legacy-OFDM mode */ 1182 case 0x1: 1183 if (wd->rateField <= 15) 1184 rxRateKbps = zcIndextoRateBG[wd->rateField]; 1185 break; 1186 /* HT-OFDM mode */ 1187 case 0x2: 1188 mcs = wd->rateField & 0x7F; 1189 bandwidth = wd->rateField & 0x80; 1190 if (mcs <= 15) { 1191 if (bandwidth != 0) { 1192 if ((wd->rxInfo & 0x80) != 0) { 1193 /* Short GI 40 MHz MIMO Rate */ 1194 rxRateKbps = zcIndextoRateN40S[mcs]; 1195 } else { 1196 /* Long GI 40 MHz MIMO Rate */ 1197 rxRateKbps = zcIndextoRateN40L[mcs]; 1198 } 1199 } else { 1200 if ((wd->rxInfo & 0x80) != 0) { 1201 /* Short GI 20 MHz MIMO Rate */ 1202 rxRateKbps = zcIndextoRateN20S[mcs]; 1203 } else { 1204 /* Long GI 20 MHz MIMO Rate */ 1205 rxRateKbps = zcIndextoRateN20L[mcs]; 1206 } 1207 } 1208 } 1209 break; 1210 default: 1211 break; 1212 } 1213 /* zm_msg1_mm(ZM_LV_0, "wd->CurrentRxRateKbps=", 1214 wd->CurrentRxRateKbps); 1215 */ 1216 1217 /* ToDo: use bandwith field to define 40MB */ 1218 return rxRateKbps; 1219} 1220 1221/* Get WLAN stastics */ 1222u16_t zfiWlanGetStatistics(zdev_t *dev) 1223{ 1224 /* Return link statistics */ 1225 return 0; 1226} 1227 1228u16_t zfiWlanReset(zdev_t *dev) 1229{ 1230 zmw_get_wlan_dev(dev); 1231 1232 wd->state = ZM_WLAN_STATE_DISABLED; 1233 1234 return zfWlanReset(dev); 1235} 1236 1237/* Reset WLAN */ 1238u16_t zfWlanReset(zdev_t *dev) 1239{ 1240 u8_t isConnected; 1241 zmw_get_wlan_dev(dev); 1242 1243 zmw_declare_for_critical_section(); 1244 1245 zm_debug_msg0("zfWlanReset"); 1246 1247 isConnected = zfStaIsConnected(dev); 1248 1249 /* if ( wd->wlanMode != ZM_MODE_AP ) */ 1250 { 1251 if ((wd->wlanMode == ZM_MODE_INFRASTRUCTURE) && 1252 (wd->sta.currentAuthMode != ZM_AUTH_MODE_WPA2)) { 1253 /* send deauthentication frame */ 1254 if (isConnected) { 1255 /* zfiWlanDeauth(dev, NULL, 0); */ 1256 zfSendMmFrame(dev, ZM_WLAN_FRAME_TYPE_DEAUTH, 1257 wd->sta.bssid, 3, 0, 0); 1258 /* zmw_debug_msg0("send a Deauth frame!"); */ 1259 } 1260 } 1261 } 1262 1263 zfChangeAdapterState(dev, ZM_STA_STATE_DISCONNECT); 1264 zfHpResetKeyCache(dev); 1265 1266 if (isConnected) { 1267 /* zfiWlanDisable(dev); */ 1268 if (wd->zfcbConnectNotify != NULL) 1269 wd->zfcbConnectNotify(dev, 1270 ZM_STATUS_MEDIA_CONNECTION_RESET, wd->sta.bssid); 1271 } else { 1272 if (wd->zfcbConnectNotify != NULL) 1273 wd->zfcbConnectNotify(dev, ZM_STATUS_MEDIA_RESET, 1274 wd->sta.bssid); 1275 } 1276 1277 /* stop beacon */ 1278 zfHpDisableBeacon(dev); 1279 1280 /* Free buffer in defragment list*/ 1281 zfAgingDefragList(dev, 1); 1282 1283 /* Flush VTxQ and MmQ */ 1284 zfFlushVtxq(dev); 1285 1286#ifdef ZM_ENABLE_AGGREGATION 1287 /* add by honda */ 1288 zfAggRxFreeBuf(dev, 0); /* 1 for release structure memory */ 1289 /* end of add by honda */ 1290#endif 1291 1292 zfStaRefreshBlockList(dev, 1); 1293 1294 zmw_enter_critical_section(dev); 1295 1296 zfTimerCancel(dev, ZM_EVENT_IBSS_MONITOR); 1297 zfTimerCancel(dev, ZM_EVENT_CM_BLOCK_TIMER); 1298 zfTimerCancel(dev, ZM_EVENT_CM_DISCONNECT); 1299 1300 wd->sta.connectState = ZM_STA_CONN_STATE_NONE; 1301 wd->sta.connectByReasso = FALSE; 1302 wd->sta.cmDisallowSsidLength = 0; 1303 wd->sta.bAutoReconnect = 0; 1304 wd->sta.InternalScanReq = 0; 1305 wd->sta.encryMode = ZM_NO_WEP; 1306 wd->sta.wepStatus = ZM_ENCRYPTION_WEP_DISABLED; 1307 wd->sta.wpaState = ZM_STA_WPA_STATE_INIT; 1308 wd->sta.cmMicFailureCount = 0; 1309 wd->sta.ibssBssIsCreator = 0; 1310#ifdef ZM_ENABLE_IBSS_WPA2PSK 1311 wd->sta.ibssWpa2Psk = 0; 1312#endif 1313 /* reset connect timeout counter */ 1314 wd->sta.connectTimeoutCount = 0; 1315 1316 /* reset leap enable variable */ 1317 wd->sta.leapEnabled = 0; 1318 1319 /* Reset the RIFS Status / RIFS-like frame count / RIFS count */ 1320 if (wd->sta.rifsState == ZM_RIFS_STATE_DETECTED) 1321 zfHpDisableRifs(dev); 1322 wd->sta.rifsState = ZM_RIFS_STATE_DETECTING; 1323 wd->sta.rifsLikeFrameCnt = 0; 1324 wd->sta.rifsCount = 0; 1325 1326 wd->sta.osRxFilter = 0; 1327 wd->sta.bSafeMode = 0; 1328 1329 /* Clear the information for the peer 1330 stations of IBSS or AP of Station mode 1331 */ 1332 zfZeroMemory((u8_t *)wd->sta.oppositeInfo, 1333 sizeof(struct zsOppositeInfo) * ZM_MAX_OPPOSITE_COUNT); 1334 1335 zmw_leave_critical_section(dev); 1336 1337 zfScanMgrScanStop(dev, ZM_SCAN_MGR_SCAN_INTERNAL); 1338 zfScanMgrScanStop(dev, ZM_SCAN_MGR_SCAN_EXTERNAL); 1339 1340 /* Turn off Software WEP/TKIP */ 1341 if (wd->sta.SWEncryptEnable != 0) { 1342 zm_debug_msg0("Disable software encryption"); 1343 zfStaDisableSWEncryption(dev); 1344 } 1345 1346 /* Improve WEP/TKIP performance with HT AP, 1347 detail information please look bug#32495 1348 */ 1349 /* zfHpSetTTSIFSTime(dev, 0x8); */ 1350 1351 /* Keep Pseudo mode */ 1352 if (wd->wlanMode != ZM_MODE_PSEUDO) 1353 wd->wlanMode = ZM_MODE_INFRASTRUCTURE; 1354 1355 return 0; 1356} 1357 1358/* Deauthenticate a STA */ 1359u16_t zfiWlanDeauth(zdev_t *dev, u16_t *macAddr, u16_t reason) 1360{ 1361 zmw_get_wlan_dev(dev); 1362 1363 if (wd->wlanMode == ZM_MODE_AP) { 1364 /* u16_t id; */ 1365 1366 /* 1367 * we will reset all key in zfHpResetKeyCache() when call 1368 * zfiWlanDisable(), if we want to reset PairwiseKey for each 1369 * sta, need to use a nullAddr to let keyindex not match. 1370 * otherwise hardware will still find PairwiseKey when AP change 1371 * encryption mode from WPA to WEP 1372 */ 1373 1374 /* 1375 id = zfApFindSta(dev, macAddr); 1376 if (id != 0xffff) 1377 { 1378 u32_t key[8]; 1379 u16_t nullAddr[3] = { 0x0, 0x0, 0x0 }; 1380 1381 if (wd->ap.staTable[i].encryMode != ZM_NO_WEP) 1382 { 1383 zfHpSetApPairwiseKey(dev, nullAddr, 1384 ZM_NO_WEP, &key[0], &key[4], i+1); 1385 } 1386 //zfHpSetApPairwiseKey(dev, (u16_t *)macAddr, 1387 // ZM_NO_WEP, &key[0], &key[4], id+1); 1388 wd->ap.staTable[id].encryMode = ZM_NO_WEP; 1389 wd->ap.staTable[id].keyIdx = 0xff; 1390 } 1391 */ 1392 1393 zfSendMmFrame(dev, ZM_WLAN_FRAME_TYPE_DEAUTH, macAddr, 1394 reason, 0, 0); 1395 } else 1396 zfSendMmFrame(dev, ZM_WLAN_FRAME_TYPE_DEAUTH, 1397 wd->sta.bssid, 3, 0, 0); 1398 1399 /* Issue DEAUTH command to FW */ 1400 return 0; 1401} 1402 1403 1404/* XP packet filter feature : */ 1405/* 1=>enable: All multicast address packets, not just the ones */ 1406/* enumerated in the multicast address list. */ 1407/* 0=>disable */ 1408void zfiWlanSetAllMulticast(zdev_t *dev, u32_t setting) 1409{ 1410 zmw_get_wlan_dev(dev); 1411 zm_msg1_mm(ZM_LV_0, "sta.bAllMulticast = ", setting); 1412 wd->sta.bAllMulticast = (u8_t)setting; 1413} 1414 1415 1416/* HT configure API */ 1417void zfiWlanSetHTCtrl(zdev_t *dev, u32_t *setting, u32_t forceTxTPC) 1418{ 1419 zmw_get_wlan_dev(dev); 1420 1421 wd->preambleType = (u8_t)setting[0]; 1422 wd->sta.preambleTypeHT = (u8_t)setting[1]; 1423 wd->sta.htCtrlBandwidth = (u8_t)setting[2]; 1424 wd->sta.htCtrlSTBC = (u8_t)setting[3]; 1425 wd->sta.htCtrlSG = (u8_t)setting[4]; 1426 wd->sta.defaultTA = (u8_t)setting[5]; 1427 wd->enableAggregation = (u8_t)setting[6]; 1428 wd->enableWDS = (u8_t)setting[7]; 1429 1430 wd->forceTxTPC = forceTxTPC; 1431} 1432 1433/* FB50 in OS XP, RD private test code */ 1434void zfiWlanQueryHTCtrl(zdev_t *dev, u32_t *setting, u32_t *forceTxTPC) 1435{ 1436 zmw_get_wlan_dev(dev); 1437 1438 setting[0] = wd->preambleType; 1439 setting[1] = wd->sta.preambleTypeHT; 1440 setting[2] = wd->sta.htCtrlBandwidth; 1441 setting[3] = wd->sta.htCtrlSTBC; 1442 setting[4] = wd->sta.htCtrlSG; 1443 setting[5] = wd->sta.defaultTA; 1444 setting[6] = wd->enableAggregation; 1445 setting[7] = wd->enableWDS; 1446 1447 *forceTxTPC = wd->forceTxTPC; 1448} 1449 1450void zfiWlanDbg(zdev_t *dev, u8_t setting) 1451{ 1452 zmw_get_wlan_dev(dev); 1453 1454 wd->enableHALDbgInfo = setting; 1455} 1456 1457/* FB50 in OS XP, RD private test code */ 1458void zfiWlanSetRxPacketDump(zdev_t *dev, u32_t setting) 1459{ 1460 zmw_get_wlan_dev(dev); 1461 if (setting) 1462 wd->rxPacketDump = 1; /* enable */ 1463 else 1464 wd->rxPacketDump = 0; /* disable */ 1465} 1466 1467 1468/* FB50 in OS XP, RD private test code */ 1469/* Tally */ 1470void zfiWlanResetTally(zdev_t *dev) 1471{ 1472 zmw_get_wlan_dev(dev); 1473 1474 zmw_declare_for_critical_section(); 1475 1476 zmw_enter_critical_section(dev); 1477 1478 wd->commTally.txUnicastFrm = 0; /* txUnicastFrames */ 1479 wd->commTally.txMulticastFrm = 0; /* txMulticastFrames */ 1480 wd->commTally.txUnicastOctets = 0; /* txUniOctets byte size */ 1481 wd->commTally.txMulticastOctets = 0; /* txMultiOctets byte size */ 1482 wd->commTally.txFrmUpperNDIS = 0; 1483 wd->commTally.txFrmDrvMgt = 0; 1484 wd->commTally.RetryFailCnt = 0; 1485 wd->commTally.Hw_TotalTxFrm = 0; /* Hardware total Tx Frame */ 1486 wd->commTally.Hw_RetryCnt = 0; /* txMultipleRetriesFrames */ 1487 wd->commTally.Hw_UnderrunCnt = 0; 1488 wd->commTally.DriverRxFrmCnt = 0; 1489 wd->commTally.rxUnicastFrm = 0; /* rxUnicastFrames */ 1490 wd->commTally.rxMulticastFrm = 0; /* rxMulticastFrames */ 1491 wd->commTally.NotifyNDISRxFrmCnt = 0; 1492 wd->commTally.rxUnicastOctets = 0; /* rxUniOctets byte size */ 1493 wd->commTally.rxMulticastOctets = 0; /* rxMultiOctets byte size */ 1494 wd->commTally.DriverDiscardedFrm = 0; /* Discard by ValidateFrame */ 1495 wd->commTally.LessThanDataMinLen = 0; 1496 wd->commTally.GreaterThanMaxLen = 0; 1497 wd->commTally.DriverDiscardedFrmCauseByMulticastList = 0; 1498 wd->commTally.DriverDiscardedFrmCauseByFrmCtrl = 0; 1499 wd->commTally.rxNeedFrgFrm = 0; /* need more frg frm */ 1500 wd->commTally.DriverRxMgtFrmCnt = 0; 1501 wd->commTally.rxBroadcastFrm = 0;/* Receive broadcast frame count */ 1502 wd->commTally.rxBroadcastOctets = 0;/*Receive broadcast framebyte size*/ 1503 wd->commTally.Hw_TotalRxFrm = 0; 1504 wd->commTally.Hw_CRC16Cnt = 0; /* rxPLCPCRCErrCnt */ 1505 wd->commTally.Hw_CRC32Cnt = 0; /* rxCRC32ErrCnt */ 1506 wd->commTally.Hw_DecrypErr_UNI = 0; 1507 wd->commTally.Hw_DecrypErr_Mul = 0; 1508 wd->commTally.Hw_RxFIFOOverrun = 0; 1509 wd->commTally.Hw_RxTimeOut = 0; 1510 wd->commTally.LossAP = 0; 1511 1512 wd->commTally.Tx_MPDU = 0; 1513 wd->commTally.BA_Fail = 0; 1514 wd->commTally.Hw_Tx_AMPDU = 0; 1515 wd->commTally.Hw_Tx_MPDU = 0; 1516 1517 wd->commTally.txQosDropCount[0] = 0; 1518 wd->commTally.txQosDropCount[1] = 0; 1519 wd->commTally.txQosDropCount[2] = 0; 1520 wd->commTally.txQosDropCount[3] = 0; 1521 wd->commTally.txQosDropCount[4] = 0; 1522 1523 wd->commTally.Hw_RxMPDU = 0; 1524 wd->commTally.Hw_RxDropMPDU = 0; 1525 wd->commTally.Hw_RxDelMPDU = 0; 1526 1527 wd->commTally.Hw_RxPhyMiscError = 0; 1528 wd->commTally.Hw_RxPhyXRError = 0; 1529 wd->commTally.Hw_RxPhyOFDMError = 0; 1530 wd->commTally.Hw_RxPhyCCKError = 0; 1531 wd->commTally.Hw_RxPhyHTError = 0; 1532 wd->commTally.Hw_RxPhyTotalCount = 0; 1533 1534#if (defined(GCCK) && defined(OFDM)) 1535 wd->commTally.rx11bDataFrame = 0; 1536 wd->commTally.rxOFDMDataFrame = 0; 1537#endif 1538 1539 zmw_leave_critical_section(dev); 1540} 1541 1542/* FB50 in OS XP, RD private test code */ 1543void zfiWlanQueryTally(zdev_t *dev, struct zsCommTally *tally) 1544{ 1545 zmw_get_wlan_dev(dev); 1546 1547 zmw_declare_for_critical_section(); 1548 1549 zmw_enter_critical_section(dev); 1550 zfMemoryCopy((u8_t *)tally, (u8_t *)&wd->commTally, 1551 sizeof(struct zsCommTally)); 1552 zmw_leave_critical_section(dev); 1553} 1554 1555void zfiWlanQueryTrafTally(zdev_t *dev, struct zsTrafTally *tally) 1556{ 1557 zmw_get_wlan_dev(dev); 1558 1559 zmw_declare_for_critical_section(); 1560 1561 zmw_enter_critical_section(dev); 1562 zfMemoryCopy((u8_t *)tally, (u8_t *)&wd->trafTally, 1563 sizeof(struct zsTrafTally)); 1564 zmw_leave_critical_section(dev); 1565} 1566 1567void zfiWlanQueryMonHalRxInfo(zdev_t *dev, struct zsMonHalRxInfo *monHalRxInfo) 1568{ 1569 zfHpQueryMonHalRxInfo(dev, (u8_t *)monHalRxInfo); 1570} 1571 1572/* parse the modeMDKEnable to DrvCore */ 1573void zfiDKEnable(zdev_t *dev, u32_t enable) 1574{ 1575 zmw_get_wlan_dev(dev); 1576 1577 wd->modeMDKEnable = enable; 1578 zm_debug_msg1("modeMDKEnable = ", wd->modeMDKEnable); 1579} 1580 1581/* airoPeek */ 1582u32_t zfiWlanQueryPacketTypePromiscuous(zdev_t *dev) 1583{ 1584 zmw_get_wlan_dev(dev); 1585 1586 return wd->swSniffer; 1587} 1588 1589/* airoPeek */ 1590void zfiWlanSetPacketTypePromiscuous(zdev_t *dev, u32_t setValue) 1591{ 1592 zmw_get_wlan_dev(dev); 1593 1594 wd->swSniffer = setValue; 1595 zm_msg1_mm(ZM_LV_0, "wd->swSniffer ", wd->swSniffer); 1596 if (setValue) { 1597 /* write register for sniffer mode */ 1598 zfHpSetSnifferMode(dev, 1); 1599 zm_msg0_mm(ZM_LV_1, "enable sniffer mode"); 1600 } else { 1601 zfHpSetSnifferMode(dev, 0); 1602 zm_msg0_mm(ZM_LV_0, "disalbe sniffer mode"); 1603 } 1604} 1605 1606void zfiWlanSetXLinkMode(zdev_t *dev, u32_t setValue) 1607{ 1608 zmw_get_wlan_dev(dev); 1609 1610 wd->XLinkMode = setValue; 1611 if (setValue) { 1612 /* write register for sniffer mode */ 1613 zfHpSetSnifferMode(dev, 1); 1614 } else 1615 zfHpSetSnifferMode(dev, 0); 1616} 1617 1618extern void zfStaChannelManagement(zdev_t *dev, u8_t scan); 1619 1620void zfiSetChannelManagement(zdev_t *dev, u32_t setting) 1621{ 1622 zmw_get_wlan_dev(dev); 1623 1624 switch (setting) { 1625 case 1: 1626 wd->sta.EnableHT = 1; 1627 wd->BandWidth40 = 1; 1628 wd->ExtOffset = 1; 1629 break; 1630 case 3: 1631 wd->sta.EnableHT = 1; 1632 wd->BandWidth40 = 1; 1633 wd->ExtOffset = 3; 1634 break; 1635 case 0: 1636 wd->sta.EnableHT = 1; 1637 wd->BandWidth40 = 0; 1638 wd->ExtOffset = 0; 1639 break; 1640 default: 1641 wd->BandWidth40 = 0; 1642 wd->ExtOffset = 0; 1643 break; 1644 } 1645 1646 zfCoreSetFrequencyEx(dev, wd->frequency, wd->BandWidth40, 1647 wd->ExtOffset, NULL); 1648} 1649 1650void zfiSetRifs(zdev_t *dev, u16_t setting) 1651{ 1652 zmw_get_wlan_dev(dev); 1653 1654 wd->sta.ie.HtInfo.ChannelInfo |= ExtHtCap_RIFSMode; 1655 wd->sta.EnableHT = 1; 1656 1657 switch (setting) { 1658 case 0: 1659 wd->sta.HT2040 = 0; 1660 /* zfHpSetRifs(dev, 1, 0, 1661 * (wd->sta.currentFrequency < 3000)? 1:0); 1662 */ 1663 break; 1664 case 1: 1665 wd->sta.HT2040 = 1; 1666 /* zfHpSetRifs(dev, 1, 1, 1667 * (wd->sta.currentFrequency < 3000)? 1:0); 1668 */ 1669 break; 1670 default: 1671 wd->sta.HT2040 = 0; 1672 /* zfHpSetRifs(dev, 1, 0, 1673 * (wd->sta.currentFrequency < 3000)? 1:0); 1674 */ 1675 break; 1676 } 1677} 1678 1679void zfiCheckRifs(zdev_t *dev) 1680{ 1681 zmw_get_wlan_dev(dev); 1682 1683 if (wd->sta.ie.HtInfo.ChannelInfo & ExtHtCap_RIFSMode) 1684 ; 1685 /* zfHpSetRifs(dev, wd->sta.EnableHT, wd->sta.HT2040, 1686 * (wd->sta.currentFrequency < 3000)? 1:0); 1687 */ 1688} 1689 1690void zfiSetReorder(zdev_t *dev, u16_t value) 1691{ 1692 zmw_get_wlan_dev(dev); 1693 1694 wd->reorder = value; 1695} 1696 1697void zfiSetSeqDebug(zdev_t *dev, u16_t value) 1698{ 1699 zmw_get_wlan_dev(dev); 1700 1701 wd->seq_debug = value; 1702} 1703