drivers/staging/otus/80211core/ccmd.c

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