drivers/staging/otus/80211core/coid.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 : iod.c                                                 */
  18 /*                                                                      */
  19 /*  Abstract                                                            */
  20 /*      This module contains OID functions.                             */
  21 /*                                                                      */
  22 /*  NOTES                                                               */
  23 /*      None                                                            */
  24 /*                                                                      */
  25 /************************************************************************/
  26 #include "cprecomp.h"
  27 #include "../hal/hpreg.h"
  28
  29 /************************************************************************/
  30 /*                                                                      */
  31 /*    FUNCTION DESCRIPTION                  zfiWlanQueryMacAddress      */
  32 /*      Query OWN MAC address.                                          */
  33 /*                                                                      */
  34 /*    INPUTS                                                            */
  35 /*      addr : for return MAC address                                   */
  36 /*                                                                      */
  37 /*    OUTPUTS                                                           */
  38 /*      None                                                            */
  39 /*                                                                      */
  40 /*    AUTHOR                                                            */
  41 /*      Stephen Chen        ZyDAS Technology Corporation    2005.10     */
  42 /*                                                                      */
  43 /************************************************************************/
  44 void zfiWlanQueryMacAddress(zdev_t* dev, u8_t* addr)
  45 {
  46     u16_t vapId = 0;
  47     zmw_get_wlan_dev(dev);
  48
  49     vapId = zfwGetVapId(dev);
  50
  51     addr[0] = (u8_t)(wd->macAddr[0] & 0xff);
  52     addr[1] = (u8_t)(wd->macAddr[0] >> 8);
  53     addr[2] = (u8_t)(wd->macAddr[1] & 0xff);
  54     addr[3] = (u8_t)(wd->macAddr[1] >> 8);
  55     addr[4] = (u8_t)(wd->macAddr[2] & 0xff);
  56     if (vapId == 0xffff)
  57         addr[5] = (u8_t)(wd->macAddr[2] >> 8);
  58     else
  59     {
  60 #ifdef ZM_VAPMODE_MULTILE_SSID
  61         addr[5] = (u8_t)(wd->macAddr[2] >> 8); // Multiple SSID
  62 #else
  63         addr[5] = vapId + 1 + (u8_t)(wd->macAddr[2] >> 8); //VAP
  64 #endif
  65     }
  66
  67     return;
  68 }
  69
  70 void zfiWlanQueryBssList(zdev_t* dev, struct zsBssList* pBssList)
  71 {
  72     struct zsBssInfo*   pBssInfo;
  73     struct zsBssInfo*   pDstBssInfo;
  74     u8_t   i;
  75     u8_t*  pMemList;
  76     u8_t*  pMemInfo;
  77
  78     zmw_get_wlan_dev(dev);
  79
  80     zmw_declare_for_critical_section();
  81
  82     pMemList = (u8_t*) pBssList;
  83     pMemInfo = pMemList + sizeof(struct zsBssList);
  84     pBssList->head = (struct zsBssInfo*) pMemInfo;
  85
  86     zmw_enter_critical_section(dev);
  87
  88     pBssInfo = wd->sta.bssList.head;
  89     pDstBssInfo = (struct zsBssInfo*) pMemInfo;
  90     pBssList->bssCount = wd->sta.bssList.bssCount;
  91
  92     for( i=0; i<wd->sta.bssList.bssCount; i++ )
  93     {
  94         zfMemoryCopy((u8_t*)pDstBssInfo, (u8_t*)pBssInfo,
  95                 sizeof(struct zsBssInfo));
  96
  97         if ( pBssInfo->next != NULL )
  98         {
  99             pBssInfo = pBssInfo->next;
 100             pDstBssInfo->next = pDstBssInfo + 1;
 101             pDstBssInfo++;
 102         }
 103         else
 104         {
 105             zm_assert(i==(wd->sta.bssList.bssCount-1));
 106         }
 107     }
 108
 109     zmw_leave_critical_section(dev);
 110
 111     zfScanMgrScanAck(dev);
 112 }
 113
 114 void zfiWlanQueryBssListV1(zdev_t* dev, struct zsBssListV1* bssListV1)
 115 {
 116     struct zsBssInfo*   pBssInfo;
 117     //struct zsBssInfo*   pDstBssInfo;
 118     u8_t   i, j, bdrop = 0, k = 0, Same_Count = 0;
 119     u8_t   bssid[6];
 120     //u8_t*  pMemList;
 121     //u8_t*  pMemInfo;
 122     zmw_get_wlan_dev(dev);
 123     zmw_declare_for_critical_section();
 124
 125     zmw_enter_critical_section(dev);
 126
 127     bssListV1->bssCount = wd->sta.bssList.bssCount;
 128
 129     pBssInfo = wd->sta.bssList.head;
 130     ZM_MAC_WORD_TO_BYTE(wd->sta.bssid, bssid);
 131
 132     for( i=0; i<wd->sta.bssList.bssCount; i++ )
 133     {
 134         bdrop = 0;
 135         if ( zfStaIsConnected(dev)
 136              && (wd->wlanMode == ZM_MODE_INFRASTRUCTURE ) )
 137         {
 138                         for (j = 0; j < 6; j++)
 139             {
 140                 if ( pBssInfo->bssid[j] != bssid[j] )
 141                 {
 142                     break;
 143                 }
 144             }
 145
 146             if  ( (j == 6)
 147                   &&((pBssInfo->ssid[1] == wd->sta.ssidLen) || (pBssInfo->ssid[1] == 0) )&& (pBssInfo->frequency == wd->frequency) )
 148             {
 149                                 if(pBssInfo->ssid[1] == 0)
 150                                         pBssInfo->ssid[1] = wd->sta.ssidLen;
 151
 152                                 if(Same_Count == 0)
 153                                 {//First meet
 154                                         Same_Count++;
 155                                 }
 156                                 else
 157                                 {//same one
 158                                         bdrop = 1;
 159                                         bssListV1->bssCount--;
 160                                 }
 161
 162             }
 163         }
 164
 165         if (bdrop == 0)
 166         {
 167             zfMemoryCopy((u8_t*)(&bssListV1->bssInfo[k]), (u8_t*)pBssInfo,
 168                 sizeof(struct zsBssInfo));
 169
 170                         if(Same_Count == 1)
 171                         {
 172                                 zfMemoryCopy(&(bssListV1->bssInfo[k].ssid[2]), wd->sta.ssid, wd->sta.ssidLen);
 173                                 Same_Count++;
 174                         }
 175
 176                         k++;
 177         }
 178
 179         if ( pBssInfo->next != NULL )
 180         {
 181             pBssInfo = pBssInfo->next;
 182         }
 183         else
 184         {
 185             zm_assert(i==(wd->sta.bssList.bssCount-1));
 186         }
 187     }
 188
 189     zmw_leave_critical_section(dev);
 190
 191     zfScanMgrScanAck(dev);
 192 }
 193
 194 void zfiWlanQueryAdHocCreatedBssDesc(zdev_t* dev, struct zsBssInfo *pBssInfo)
 195 {
 196     zmw_get_wlan_dev(dev);
 197
 198     zfMemoryCopy((u8_t *)pBssInfo, (u8_t *)&wd->sta.ibssBssDesc, sizeof(struct zsBssInfo));
 199 }
 200
 201 u8_t zfiWlanQueryAdHocIsCreator(zdev_t* dev)
 202 {
 203     zmw_get_wlan_dev(dev);
 204
 205     return wd->sta.ibssBssIsCreator;
 206 }
 207
 208 u32_t zfiWlanQuerySupportMode(zdev_t* dev)
 209 {
 210     zmw_get_wlan_dev(dev);
 211
 212     return wd->supportMode;
 213 }
 214
 215 u32_t zfiWlanQueryTransmitPower(zdev_t* dev)
 216 {
 217     u32_t ret = 0;
 218
 219     zmw_get_wlan_dev(dev);
 220
 221     if (zfStaIsConnected(dev)) {
 222         ret = wd->sta.connPowerInHalfDbm;
 223     } else {
 224         ret = zfHpGetTransmitPower(dev);
 225     }
 226
 227     return ret;
 228 }
 229
 230 /************************************************************************/
 231 /*                                                                      */
 232 /*    FUNCTION DESCRIPTION                  zfiWlanFlushBssList         */
 233 /*      Flush BSSID List.                                               */
 234 /*                                                                      */
 235 /*    INPUTS                                                            */
 236 /*      dev : device pointer                                            */
 237 /*                                                                      */
 238 /*    OUTPUTS                                                           */
 239 /*      none                                                            */
 240 /*                                                                      */
 241 /*    AUTHOR                                                            */
 242 /*      Stephen Chen        Atheros Communications, INC.    2006.12     */
 243 /*                                                                      */
 244 /************************************************************************/
 245 void zfiWlanFlushBssList(zdev_t* dev)
 246 {
 247     zmw_declare_for_critical_section();
 248
 249     zmw_enter_critical_section(dev);
 250     /* Call zfBssInfoRefresh() twice to remove all entry */
 251     zfBssInfoRefresh(dev, 1);
 252     zmw_leave_critical_section(dev);
 253 }
 254
 255 void zfiWlanSetWlanMode(zdev_t* dev, u8_t wlanMode)
 256 {
 257     zmw_get_wlan_dev(dev);
 258
 259     zmw_declare_for_critical_section();
 260
 261     zmw_enter_critical_section(dev);
 262     wd->ws.wlanMode = wlanMode;
 263     zmw_leave_critical_section(dev);
 264 }
 265
 266 void zfiWlanSetAuthenticationMode(zdev_t* dev, u8_t authMode)
 267 {
 268     zmw_get_wlan_dev(dev);
 269
 270     zmw_declare_for_critical_section();
 271
 272     zmw_enter_critical_section(dev);
 273     wd->ws.authMode = authMode;
 274     zmw_leave_critical_section(dev);
 275 }
 276
 277 void zfiWlanSetWepStatus(zdev_t* dev, u8_t wepStatus)
 278 {
 279     zmw_get_wlan_dev(dev);
 280
 281     zmw_declare_for_critical_section();
 282
 283     zmw_enter_critical_section(dev);
 284     wd->ws.wepStatus = wepStatus;
 285     zmw_leave_critical_section(dev);
 286
 287 }
 288
 289 void zfiWlanSetSSID(zdev_t* dev, u8_t* ssid, u8_t ssidLength)
 290 {
 291     u16_t i;
 292     zmw_get_wlan_dev(dev);
 293
 294     zmw_declare_for_critical_section();
 295
 296     if ( ssidLength <= 32 )
 297     {
 298         zmw_enter_critical_section(dev);
 299
 300         wd->ws.ssidLen = ssidLength;
 301         zfMemoryCopy(wd->ws.ssid, ssid, ssidLength);
 302
 303         if ( ssidLength < 32 )
 304         {
 305             wd->ws.ssid[ssidLength] = 0;
 306         }
 307
 308         wd->ws.probingSsidList[0].ssidLen = ssidLength;
 309         zfMemoryCopy(wd->ws.probingSsidList[0].ssid, ssid, ssidLength);
 310         for (i=1; i<ZM_MAX_PROBE_HIDDEN_SSID_SIZE; i++)
 311         {
 312             wd->ws.probingSsidList[i].ssidLen = 0;
 313         }
 314
 315         zmw_leave_critical_section(dev);
 316     }
 317 }
 318
 319 void zfiWlanSetFragThreshold(zdev_t* dev, u16_t fragThreshold)
 320 {
 321     zmw_get_wlan_dev(dev);
 322
 323     zmw_declare_for_critical_section();
 324
 325     zmw_enter_critical_section(dev);
 326
 327     if (fragThreshold == 0)
 328     {   /* fragmentation is disabled */
 329         wd->fragThreshold = 32767;
 330     }
 331     else if (fragThreshold < 256)
 332     {
 333         /* Minimum fragment threshold */
 334         wd->fragThreshold = 256;
 335     }
 336     else if (fragThreshold > 2346)
 337     {
 338         wd->fragThreshold = 2346;
 339     }
 340     else
 341     {
 342         wd->fragThreshold = fragThreshold & 0xfffe;
 343     }
 344
 345     zmw_leave_critical_section(dev);
 346 }
 347
 348 void zfiWlanSetRtsThreshold(zdev_t* dev, u16_t rtsThreshold)
 349 {
 350     zmw_get_wlan_dev(dev);
 351
 352     zmw_declare_for_critical_section();
 353
 354     zmw_enter_critical_section(dev);
 355     wd->rtsThreshold = rtsThreshold;
 356     zmw_leave_critical_section(dev);
 357 }
 358
 359 void zfiWlanSetFrequency(zdev_t* dev, u32_t frequency, u8_t bImmediate)
 360 {
 361     zmw_get_wlan_dev(dev);
 362
 363     zmw_declare_for_critical_section();
 364
 365     if ( bImmediate )
 366     {
 367         zmw_enter_critical_section(dev);
 368         wd->frequency = (u16_t) (frequency/1000);
 369         zmw_leave_critical_section(dev);
 370         zfCoreSetFrequency(dev, wd->frequency);
 371     }
 372     else
 373     {
 374         zmw_enter_critical_section(dev);
 375         if( frequency == 0 )
 376         { // Auto select clean channel depend on wireless environment !
 377             wd->ws.autoSetFrequency = 0;
 378         }
 379         wd->ws.frequency = (u16_t) (frequency/1000);
 380         zmw_leave_critical_section(dev);
 381     }
 382 }
 383
 384 void zfiWlanSetBssid(zdev_t* dev, u8_t* bssid)
 385 {
 386     u16_t i;
 387     zmw_get_wlan_dev(dev);
 388
 389     zmw_declare_for_critical_section();
 390
 391     zmw_enter_critical_section(dev);
 392     for (i=0; i<6; i++)
 393     {
 394         wd->ws.desiredBssid[i] = bssid[i];
 395     }
 396     wd->ws.bDesiredBssid = TRUE;
 397     zmw_leave_critical_section(dev);
 398
 399 }
 400
 401 void zfiWlanSetBeaconInterval(zdev_t* dev,
 402                               u16_t  beaconInterval,
 403                               u8_t   bImmediate)
 404 {
 405     zmw_get_wlan_dev(dev);
 406
 407     zmw_declare_for_critical_section();
 408
 409     if ( bImmediate )
 410     {
 411         zmw_enter_critical_section(dev);
 412         wd->beaconInterval = beaconInterval;
 413         zmw_leave_critical_section(dev);
 414
 415         /* update beacon interval here */
 416     }
 417     else
 418     {
 419         zmw_enter_critical_section(dev);
 420         wd->ws.beaconInterval = beaconInterval;
 421         zmw_leave_critical_section(dev);
 422     }
 423 }
 424
 425
 426 void zfiWlanSetDtimCount(zdev_t* dev, u8_t  dtim)
 427 {
 428     zmw_get_wlan_dev(dev);
 429
 430     zmw_declare_for_critical_section();
 431
 432     zmw_enter_critical_section(dev);
 433     if (dtim > 0)
 434     {
 435         wd->ws.dtim = dtim;
 436     }
 437     zmw_leave_critical_section(dev);
 438 }
 439
 440
 441 void zfiWlanSetAtimWindow(zdev_t* dev, u16_t atimWindow, u8_t bImmediate)
 442 {
 443     zmw_get_wlan_dev(dev);
 444
 445     zmw_declare_for_critical_section();
 446
 447     if ( bImmediate )
 448     {
 449         zmw_enter_critical_section(dev);
 450         wd->sta.atimWindow = atimWindow;
 451         zmw_leave_critical_section(dev);
 452
 453         /* atim window here */
 454     }
 455     else
 456     {
 457         zmw_enter_critical_section(dev);
 458         wd->ws.atimWindow = atimWindow;
 459         zmw_leave_critical_section(dev);
 460     }
 461 }
 462
 463
 464 void zfiWlanSetEncryMode(zdev_t* dev, u8_t encryMode)
 465 {
 466     zmw_get_wlan_dev(dev);
 467
 468     zmw_declare_for_critical_section();
 469
 470     zmw_enter_critical_section(dev);
 471     if (wd->wlanMode == ZM_MODE_AP)
 472     {
 473         /* Hostapd Issue */
 474         if ((wd->ws.encryMode != ZM_AES) && (wd->ws.encryMode != ZM_TKIP))
 475             wd->ws.encryMode = encryMode;
 476     }
 477     else
 478         wd->ws.encryMode = encryMode;
 479     zmw_leave_critical_section(dev);
 480 }
 481
 482 void zfiWlanSetDefaultKeyId(zdev_t* dev, u8_t keyId)
 483 {
 484     zmw_get_wlan_dev(dev);
 485
 486     wd->sta.keyId = keyId;
 487 }
 488
 489 u8_t zfiWlanQueryIsPKInstalled(zdev_t *dev, u8_t *staMacAddr)
 490 {
 491     u8_t isInstalled = 0;
 492
 493 #if 1
 494 //#ifdef ZM_ENABLE_IBSS_WPA2PSK
 495     u8_t   res, peerIdx;
 496
 497     zmw_get_wlan_dev(dev);
 498
 499     zmw_declare_for_critical_section();
 500
 501     zmw_enter_critical_section(dev);
 502     res = zfStaFindOppositeByMACAddr(dev, (u16_t *)staMacAddr, &peerIdx);
 503     if( res == 0 )
 504     {
 505         isInstalled = wd->sta.oppositeInfo[peerIdx].pkInstalled;
 506     }
 507     zmw_leave_critical_section(dev);
 508 //#endif
 509 #endif
 510
 511     return isInstalled;
 512 }
 513
 514 u8_t zfiWlanSetKey(zdev_t* dev, struct zsKeyInfo keyInfo)
 515 {
 516     u16_t  broadcast[3] = {0xffff, 0xffff, 0xffff};
 517     u32_t* key;
 518     u8_t   encryMode = ZM_NO_WEP;
 519 #ifdef ZM_ENABLE_IBSS_WPA2PSK
 520     u8_t   encryType = ZM_NO_WEP;
 521 #endif
 522     u8_t   micKey[16];
 523     u16_t  id = 0;
 524     u8_t   vapId, i, addr[6];
 525     u8_t   userIdx=0;
 526
 527 #ifdef ZM_ENABLE_IBSS_WPA2PSK
 528     /* Determine opposite exist or not */
 529     u8_t   res, peerIdx;
 530 //    u8_t   userIdx=0;
 531
 532     zmw_get_wlan_dev(dev);
 533
 534     if ( wd->sta.ibssWpa2Psk == 1 )
 535     {
 536         zmw_enter_critical_section(dev);
 537         res = zfStaFindOppositeByMACAddr(dev, (u16_t*)keyInfo.macAddr, &peerIdx);
 538         if( res == 0 )
 539         {
 540             userIdx = peerIdx;
 541             if ( wd->sta.oppositeInfo[userIdx].camIdx == 0xff )
 542                 wd->sta.oppositeInfo[userIdx].camIdx = userIdx;
 543         }
 544         zmw_leave_critical_section(dev);
 545     }
 546 #else
 547     zmw_get_wlan_dev(dev);
 548 #endif
 549
 550     if ( keyInfo.flag & ZM_KEY_FLAG_AUTHENTICATOR )
 551     {   /* set key by authenticator */
 552         /* set pairwise key */
 553         if (keyInfo.flag & ZM_KEY_FLAG_PK)
 554         {
 555             /* Find STA's information */
 556             if ((id = zfApFindSta(dev, keyInfo.macAddr)) == 0xffff)
 557             {
 558                 /* Can't STA in the staTable */
 559                 return ZM_STATUS_FAILURE;
 560             }
 561
 562             wd->ap.staTable[id].iv16 = 0;
 563             wd->ap.staTable[id].iv32 = 0;
 564
 565             if (keyInfo.keyLength == 32)
 566             {   /* TKIP */
 567                 //u8_t KeyRsc[6] = {0, 0, 0, 0, 0, 0};
 568
 569                 /* In the current AP mode, we set KeyRsc to zero */
 570                 //zfTkipInit(keyInfo.key, (u8_t*) wd->macAddr,
 571                 //           &(wd->ap.staTable[id].txSeed), KeyRsc);
 572                 //zfTkipInit(keyInfo.key, (u8_t*) keyInfo.macAddr,
 573                 //           &(wd->ap.staTable[id].rxSeed), KeyRsc);
 574 #ifdef ZM_ENABLE_CENC
 575                 if (keyInfo.flag & ZM_KEY_FLAG_CENC)
 576                 {
 577                     zm_debug_msg0("Set CENC pairwise Key");
 578
 579                     wd->ap.staTable[id].encryMode = ZM_CENC;
 580
 581                     /* Reset txiv and rxiv */
 582                     wd->ap.staTable[id].txiv[0] = 0x5c365c37;
 583                     wd->ap.staTable[id].txiv[1] = 0x5c365c36;
 584                     wd->ap.staTable[id].txiv[2] = 0x5c365c36;
 585                     wd->ap.staTable[id].txiv[3] = 0x5c365c36;
 586
 587                     wd->ap.staTable[id].rxiv[0] = 0x5c365c36;
 588                     wd->ap.staTable[id].rxiv[1] = 0x5c365c36;
 589                     wd->ap.staTable[id].rxiv[2] = 0x5c365c36;
 590                     wd->ap.staTable[id].rxiv[3] = 0x5c365c36;
 591
 592                     /* Set Key Index */
 593                     wd->ap.staTable[id].cencKeyIdx = keyInfo.keyIndex;
 594
 595                     //zfCoreSetKey(dev, id+1, 1, ZM_CENC, (u16_t *)keyInfo.macAddr,
 596                     //          (u32_t*) &keyInfo.key[16]);
 597                 }
 598                 else
 599 #endif //ZM_ENABLE_CENC
 600                 {
 601                     wd->ap.staTable[id].encryMode = ZM_TKIP;
 602
 603                     zfMemoryCopy(micKey, &keyInfo.key[16], 8);
 604                     zfMemoryCopy(&micKey[8], &keyInfo.key[24], 8);
 605
 606                     //zfCoreSetKey(dev, id+1, 1, ZM_TKIP, (u16_t *)keyInfo.macAddr,
 607                     //           (u32_t*) micKey);
 608
 609                     /* For fragmentation, we use software MIC */
 610                     zfMemoryCopy((u8_t *)&(wd->ap.staTable[id].txMicKey), &(keyInfo.key[16]), 8);
 611                     zfMemoryCopy((u8_t *)&(wd->ap.staTable[id].rxMicKey), &(keyInfo.key[24]), 8);
 612
 613                 }
 614             }
 615             else if (keyInfo.keyLength == 16)
 616             {   /* AES */
 617                 wd->ap.staTable[id].encryMode = ZM_AES;
 618             }
 619             else if (keyInfo.keyLength == 0)
 620             {
 621                 /* Clear Key Info */
 622                 zfApClearStaKey(dev, (u16_t *)keyInfo.macAddr);
 623
 624                 return ZM_STATUS_SUCCESS;
 625             }
 626             else
 627             {
 628                 return ZM_STATUS_FAILURE;
 629             }
 630
 631             //zfCoreSetKey(dev, id+1, 0, wd->ap.staTable[id].encryMode,
 632             //      (u16_t *)keyInfo.macAddr, (u32_t*) keyInfo.key);
 633             zfHpSetApPairwiseKey(dev, (u16_t *)keyInfo.macAddr,
 634                     wd->ap.staTable[id].encryMode, (u32_t*) keyInfo.key,
 635                     (u32_t*) &keyInfo.key[16], id+1);
 636             wd->ap.staTable[id].keyIdx = id + 1 + 4;
 637         }
 638         else if (keyInfo.flag & ZM_KEY_FLAG_GK)
 639         {
 640             vapId = keyInfo.vapId;
 641
 642             wd->ap.iv16[vapId] = 0;
 643             wd->ap.iv32[vapId] = 0;
 644
 645             if (keyInfo.keyLength == 32)
 646             {   /* TKIP */
 647                 //u8_t KeyRsc[6] = {0, 0, 0, 0, 0, 0};
 648
 649                 //zfTkipInit(keyInfo.key, (u8_t*) wd->macAddr,
 650                 //           &(wd->ap.bcSeed), KeyRsc);
 651 #ifdef ZM_ENABLE_CENC
 652                 if (keyInfo.flag & ZM_KEY_FLAG_CENC)
 653                 {
 654                     encryMode = ZM_CENC;
 655                     zm_debug_msg0("Set CENC group Key");
 656
 657                     /* Reset txiv and rxiv */
 658                     wd->ap.txiv[vapId][0] = 0x5c365c36;
 659                     wd->ap.txiv[vapId][1] = 0x5c365c36;
 660                     wd->ap.txiv[vapId][2] = 0x5c365c36;
 661                     wd->ap.txiv[vapId][3] = 0x5c365c36;
 662
 663                     //zfCoreSetKey(dev, 0, 1, ZM_CENC, keyInfo.vapAddr,
 664                     //          (u32_t*) &keyInfo.key[16]);
 665                     key = (u32_t*) keyInfo.key;
 666                 }
 667                 else
 668 #endif //ZM_ENABLE_CENC
 669                 {
 670                     encryMode = ZM_TKIP;
 671                     key = (u32_t *)keyInfo.key;
 672
 673                     /* set MIC key to HMAC */
 674                     //zfCoreSetKey(dev, 0, 1, ZM_TKIP, broadcast,
 675                     //         (u32_t*) (&keyInfo.key[16]));
 676                     //zfCoreSetKey(dev, 0, 1, ZM_TKIP, keyInfo.vapAddr,
 677                     //           (u32_t*) (&keyInfo.key[16]));
 678
 679                     zfMicSetKey(&(keyInfo.key[16]), &(wd->ap.bcMicKey[0]));
 680                     key = (u32_t*) keyInfo.key;
 681                 }
 682             }
 683             else if (keyInfo.keyLength == 16)
 684             {   /* AES */
 685                 encryMode = ZM_AES;
 686                 key = (u32_t *)keyInfo.key;
 687                 zm_debug_msg0("CWY - Set AES Group Key");
 688             }
 689             else if (keyInfo.keyLength == 0)
 690             {
 691                 /* Clear Key Info */
 692                 zfApClearStaKey(dev, broadcast);
 693
 694                 /* Turn off WEP bit in the capability field */
 695                 wd->ap.capab[vapId] &= 0xffef;
 696
 697                 return ZM_STATUS_SUCCESS;
 698             }
 699             else
 700             {   /* WEP */
 701                 if (keyInfo.keyLength == 5)
 702                 {
 703                     encryMode = ZM_WEP64;
 704                 }
 705                 else if (keyInfo.keyLength == 13)
 706                 {
 707                     encryMode = ZM_WEP128;
 708                 }
 709                 else if (keyInfo.keyLength == 29)
 710                 {
 711                     encryMode = ZM_WEP256;
 712                 }
 713
 714                 key = (u32_t*) keyInfo.key;
 715             }
 716
 717             // Modification for CAM not support VAP search
 718             //zfCoreSetKey(dev, 0, 0, encryMode, broadcast, key);
 719             //zfCoreSetKey(dev, 0, 0, encryMode, wd->macAddr, key);
 720             //zfCoreSetKey(dev, 0, 0, encryMode, keyInfo.vapAddr, key);
 721             zfHpSetApGroupKey(dev, wd->macAddr, encryMode,
 722                     key, (u32_t*) &keyInfo.key[16], vapId);
 723
 724             //zfiWlanSetEncryMode(dev, encryMode);
 725             wd->ws.encryMode = encryMode;
 726
 727             /* set the multicast address encryption type */
 728             wd->ap.encryMode[vapId] = encryMode;
 729
 730             /* set the multicast key index */
 731             wd->ap.bcKeyIndex[vapId] = keyInfo.keyIndex;
 732             wd->ap.bcHalKeyIdx[vapId] = vapId + 60;
 733
 734             /* Turn on WEP bit in the capability field */
 735             wd->ap.capab[vapId] |= 0x10;
 736         }
 737     }
 738     else
 739     {   /* set by supplicant */
 740
 741         if ( keyInfo.flag & ZM_KEY_FLAG_PK )
 742         {   /* set pairwise key */
 743
 744             //zfTkipInit(keyInfo.key, (u8_t*) wd->macAddr,
 745             //           &wd->sta.txSeed, keyInfo.initIv);
 746             //zfTkipInit(keyInfo.key, (u8_t*) wd->sta.bssid,
 747             //           &wd->sta.rxSeed[keyInfo.keyIndex], keyInfo.initIv);
 748
 749 #ifdef ZM_ENABLE_IBSS_WPA2PSK
 750             if ( wd->sta.ibssWpa2Psk == 1 )
 751             {
 752                 /* unicast -- > pairwise key */
 753                 wd->sta.oppositeInfo[userIdx].iv16 = 0;
 754                 wd->sta.oppositeInfo[userIdx].iv32 = 0;
 755             }
 756             else
 757             {
 758                 wd->sta.iv16 = 0;
 759                 wd->sta.iv32 = 0;
 760             }
 761
 762             wd->sta.oppositeInfo[userIdx].pkInstalled = 1;
 763 #else
 764             wd->sta.iv16 = 0;
 765             wd->sta.iv32 = 0;
 766
 767             wd->sta.oppositeInfo[userIdx].pkInstalled = 1;
 768 #endif
 769
 770             if ( keyInfo.keyLength == 32 )
 771             {   /* TKIP */
 772                 zfTkipInit(keyInfo.key, (u8_t*) wd->macAddr,
 773                         &wd->sta.txSeed, keyInfo.initIv);
 774                 zfTkipInit(keyInfo.key, (u8_t*) wd->sta.bssid,
 775                         &wd->sta.rxSeed[keyInfo.keyIndex], keyInfo.initIv);
 776
 777 #ifdef ZM_ENABLE_CENC
 778                 if (keyInfo.flag & ZM_KEY_FLAG_CENC)
 779                 {
 780                     zm_debug_msg0("Set CENC pairwise Key");
 781
 782                     wd->sta.encryMode = ZM_CENC;
 783
 784                     /* Reset txiv and rxiv */
 785                     wd->sta.txiv[0] = 0x5c365c36;
 786                     wd->sta.txiv[1] = 0x5c365c36;
 787                     wd->sta.txiv[2] = 0x5c365c36;
 788                     wd->sta.txiv[3] = 0x5c365c36;
 789
 790                     wd->sta.rxiv[0] = 0x5c365c37;
 791                     wd->sta.rxiv[1] = 0x5c365c36;
 792                     wd->sta.rxiv[2] = 0x5c365c36;
 793                     wd->sta.rxiv[3] = 0x5c365c36;
 794
 795                     /* Set Key Index */
 796                     wd->sta.cencKeyId = keyInfo.keyIndex;
 797
 798                     //zfCoreSetKey(dev, id+1, 1, ZM_CENC, (u16_t *)keyInfo.macAddr,
 799                     //         (u32_t*) &keyInfo.key[16]);
 800                 }
 801                 else
 802 #endif //ZM_ENABLE_CENC
 803                 {
 804                     wd->sta.encryMode = ZM_TKIP;
 805
 806                     //zfCoreSetKey(dev, 0, 1, ZM_TKIP, wd->sta.bssid,
 807                     //         (u32_t*) &keyInfo.key[16]);
 808
 809                     zfMicSetKey(&keyInfo.key[16], &wd->sta.txMicKey);
 810                     zfMicSetKey(&keyInfo.key[24],
 811                                 &wd->sta.rxMicKey[keyInfo.keyIndex]);
 812                 }
 813             }
 814             else if ( keyInfo.keyLength == 16 )
 815             {   /* AES */
 816 #ifdef ZM_ENABLE_IBSS_WPA2PSK
 817                 if ( wd->sta.ibssWpa2Psk == 1 )
 818                 {
 819                     wd->sta.oppositeInfo[userIdx].encryMode = ZM_AES;
 820                     encryType = wd->sta.oppositeInfo[userIdx].encryMode;
 821                 }
 822                 else
 823                 {
 824                     wd->sta.encryMode = ZM_AES;
 825                     encryType = wd->sta.encryMode;
 826                 }
 827 #else
 828                 wd->sta.encryMode = ZM_AES;
 829 #endif
 830             }
 831             else
 832             {
 833                 return ZM_STATUS_FAILURE;
 834             }
 835
 836             /* user 0 */
 837             //zfCoreSetKey(dev, 0, 0, wd->sta.encryMode,
 838             //         wd->sta.bssid, (u32_t*) keyInfo.key);
 839             //zfHpSetStaPairwiseKey(dev, wd->sta.bssid, wd->sta.encryMode,
 840             //    (u32_t*) keyInfo.key, (u32_t*) &keyInfo.key[16]);
 841
 842 #ifdef ZM_ENABLE_IBSS_WPA2PSK
 843             if ( (keyInfo.keyLength==16) && (wd->sta.ibssWpa2Psk==1) )
 844             { /* If not AES-CCMP and ibss network , use traditional */
 845                 zfHpSetPerUserKey(dev,
 846                                 userIdx,
 847                                 keyInfo.keyIndex,  // key id == 0 ( Pairwise key = 0 )
 848                                 (u8_t*)keyInfo.macAddr,   // RX need Source Address ( Address 2 )
 849                                 encryType,
 850 //                              wd->sta.encryMode,
 851                                 (u32_t*) keyInfo.key, (u32_t*) &keyInfo.key[16]);
 852
 853                 wd->sta.oppositeInfo[userIdx].wpaState = ZM_STA_WPA_STATE_PK_OK ;
 854             }
 855             else
 856             {/* Big Endian and Little Endian Compatibility */
 857                 for (i = 0; i < 3; i++)
 858                 {
 859                     addr[2 * i] = wd->sta.bssid[i] & 0xff;
 860                     addr[2 * i + 1] = wd->sta.bssid[i] >> 8;
 861                 }
 862                 zfHpSetPerUserKey(dev,
 863                                     ZM_USER_KEY_PK,   // user id
 864                                     0,                // key id
 865                                     addr,//(u8_t *)wd->sta.bssid,
 866                               wd->sta.encryMode,
 867                               (u32_t*) keyInfo.key, (u32_t*) &keyInfo.key[16]);
 868
 869                 wd->sta.keyId = 4;
 870             }
 871 #else
 872             /* Big Endian and Little Endian Compatibility */
 873             for (i = 0; i < 3; i++)
 874             {
 875                 addr[2 * i] = wd->sta.bssid[i] & 0xff;
 876                 addr[2 * i + 1] = wd->sta.bssid[i] >> 8;
 877             }
 878             zfHpSetPerUserKey(dev,
 879                               ZM_USER_KEY_PK,   // user id
 880                               0,                // key id
 881                               addr,//(u8_t *)wd->sta.bssid,
 882                               wd->sta.encryMode,
 883                               (u32_t*) keyInfo.key, (u32_t*) &keyInfo.key[16]);
 884
 885             wd->sta.keyId = 4;
 886 #endif
 887
 888             wd->sta.wpaState = ZM_STA_WPA_STATE_PK_OK;
 889         }
 890         else if ( keyInfo.flag & ZM_KEY_FLAG_GK )
 891         {   /* set group key */
 892
 893             zfTkipInit(keyInfo.key, (u8_t*) wd->sta.bssid,
 894                        &wd->sta.rxSeed[keyInfo.keyIndex], keyInfo.initIv);
 895
 896             if ( keyInfo.keyLength == 32 )
 897             {   /* TKIP */
 898 #ifdef ZM_ENABLE_CENC
 899                 if (keyInfo.flag & ZM_KEY_FLAG_CENC)
 900                 {
 901                     encryMode = ZM_CENC;
 902                     zm_debug_msg0("Set CENC group Key");
 903
 904                     /* Reset txiv and rxiv */
 905                     wd->sta.rxivGK[0] = 0x5c365c36;
 906                     wd->sta.rxivGK[1] = 0x5c365c36;
 907                     wd->sta.rxivGK[2] = 0x5c365c36;
 908                     wd->sta.rxivGK[3] = 0x5c365c36;
 909
 910                     //zfCoreSetKey(dev, 0, 1, ZM_CENC, keyInfo.vapAddr,
 911                     //         (u32_t*) &keyInfo.key[16]);
 912                     key = (u32_t*) keyInfo.key;
 913                 }
 914                 else
 915 #endif //ZM_ENABLE_CENC
 916                 {
 917                     encryMode = ZM_TKIP;
 918                     key = (u32_t*) wd->sta.rxSeed[keyInfo.keyIndex].tk;
 919
 920                     if ( !(keyInfo.flag & ZM_KEY_FLAG_INIT_IV) )
 921                     {
 922                         wd->sta.rxSeed[keyInfo.keyIndex].iv16 = 0;
 923                         wd->sta.rxSeed[keyInfo.keyIndex].iv32 = 0;
 924                     }
 925
 926                     /* set MIC key to HMAC */
 927                     //zfCoreSetKey(dev, 8, 1, ZM_TKIP, broadcast,
 928                     //         (u32_t*) (&keyInfo.key[16]));
 929
 930                     zfMicSetKey(&keyInfo.key[24],
 931                                 &wd->sta.rxMicKey[keyInfo.keyIndex]);
 932                 }
 933             }
 934             else if ( keyInfo.keyLength == 16 )
 935             {   /* AES */
 936                 encryMode = ZM_AES;
 937                 //key = (u32_t*) wd->sta.rxSeed[keyInfo.keyIndex].tk;
 938             }
 939             else
 940             {   /* WEP */
 941                 if ( keyInfo.keyLength == 5 )
 942                 {
 943                     encryMode = ZM_WEP64;
 944                 }
 945                 else if ( keyInfo.keyLength == 13 )
 946                 {
 947                     encryMode = ZM_WEP128;
 948                 }
 949                 else if ( keyInfo.keyLength == 29 )
 950                 {
 951                     encryMode = ZM_WEP256;
 952                 }
 953
 954                 key = (u32_t*) keyInfo.key;
 955             }
 956
 957             /* user 8 */
 958             //zfCoreSetKey(dev, 8, 0, encryMode, broadcast, key);
 959             //zfHpSetStaGroupKey(dev, broadcast, encryMode,
 960             //        (u32_t*) keyInfo.key, (u32_t*) (&keyInfo.key[16]));
 961
 962 #ifdef ZM_ENABLE_IBSS_WPA2PSK
 963             if ( (keyInfo.keyLength==16) && (wd->sta.ibssWpa2Psk==1) )
 964             {/* If not AES-CCMP and ibss network , use traditional */
 965                 zfHpSetPerUserKey(dev,
 966                               userIdx,
 967                               keyInfo.keyIndex,                // key id
 968                               // (u8_t *)broadcast,                  // for only 2 stations IBSS netwrl ( A2 )
 969                               (u8_t*)keyInfo.macAddr,   // for multiple ( > 2 ) stations IBSS network ( A2 )
 970                               encryMode,
 971                               (u32_t*) keyInfo.key, (u32_t*) &keyInfo.key[16]);
 972             }
 973             else
 974             {
 975                 zfHpSetPerUserKey(dev,
 976                                 ZM_USER_KEY_GK,   // user id
 977                                 0,                // key id
 978                                 (u8_t *)broadcast,
 979                                 encryMode,
 980                                 (u32_t*) keyInfo.key, (u32_t*) &keyInfo.key[16]);
 981
 982                 wd->sta.wpaState = ZM_STA_WPA_STATE_GK_OK;
 983             }
 984 #else
 985             zfHpSetPerUserKey(dev,
 986                               ZM_USER_KEY_GK,   // user id
 987                               0,                // key id
 988                               (u8_t *)broadcast,
 989                               encryMode,
 990                               (u32_t*) keyInfo.key, (u32_t*) &keyInfo.key[16]);
 991
 992             wd->sta.wpaState = ZM_STA_WPA_STATE_GK_OK;
 993 #endif
 994         }
 995         else
 996         {   /* legacy WEP */
 997             zm_debug_msg0("legacy WEP");
 998
 999             if ( keyInfo.keyIndex >= 4 )
1000             {
1001                 return ZM_STATUS_FAILURE;
1002             }
1003
1004             if ( keyInfo.keyLength == 5 )
1005             {
1006                 zm_debug_msg0("WEP 64");
1007
1008                 encryMode = ZM_WEP64;
1009             }
1010             else if ( keyInfo.keyLength == 13 )
1011             {
1012                 zm_debug_msg0("WEP 128");
1013
1014                 encryMode = ZM_WEP128;
1015             }
1016             else if ( keyInfo.keyLength == 32 )
1017             {
1018                 /* TKIP */
1019                 #if 0
1020                 // Don't reset the IV since some AP would fail in IV check and drop our connection
1021                 if ( wd->sta.wpaState != ZM_STA_WPA_STATE_PK_OK )
1022                 {
1023                     wd->sta.iv16 = 0;
1024                     wd->sta.iv32 = 0;
1025                 }
1026                 #endif
1027
1028                 encryMode = ZM_TKIP;
1029
1030                 zfTkipInit(keyInfo.key, (u8_t*) wd->sta.bssid,
1031                            &wd->sta.rxSeed[keyInfo.keyIndex], keyInfo.initIv);
1032                 zfMicSetKey(&keyInfo.key[24],
1033                            &wd->sta.rxMicKey[keyInfo.keyIndex]);
1034             }
1035             else if ( keyInfo.keyLength == 16 )
1036             {
1037                 /* AES */
1038                 #if 0
1039                 // Don't reset the IV since some AP would fail in IV check and drop our connection
1040                 if ( wd->sta.wpaState != ZM_STA_WPA_STATE_PK_OK )
1041                 {
1042                     /* broadcast -- > group key */
1043                     /* Only initialize when set our default key ! */
1044                     wd->sta.iv16 = 0;
1045                     wd->sta.iv32 = 0;
1046                 }
1047                 #endif
1048
1049                 encryMode = ZM_AES;
1050             }
1051             else if ( keyInfo.keyLength == 29 )
1052             {
1053                 zm_debug_msg0("WEP 256");
1054
1055                 encryMode = ZM_WEP256;
1056                 //zfCoreSetKey(dev, 64, 1, wd->sta.encryMode,
1057                 //         wd->sta.bssid, (u32_t*) (&keyInfo.key[16]));
1058             }
1059             else
1060             {
1061                 return ZM_STATUS_FAILURE;
1062             }
1063
1064             {
1065                 u8_t i;
1066
1067                 zm_debug_msg0("key = ");
1068                 for(i = 0; i < keyInfo.keyLength; i++)
1069                 {
1070                     zm_debug_msg2("", keyInfo.key[i]);
1071                 }
1072             }
1073
1074             if ( keyInfo.flag & ZM_KEY_FLAG_DEFAULT_KEY )
1075             {
1076                 //for WEP default key 1~3 and ATOM platform--CWYang(+)
1077                 vapId = 0;
1078                 wd->ap.bcHalKeyIdx[vapId] = keyInfo.keyIndex;
1079                 wd->ap.bcKeyIndex[vapId] = keyInfo.keyIndex;
1080                 wd->sta.keyId = keyInfo.keyIndex;
1081             }
1082
1083                         if(encryMode == ZM_TKIP)
1084                         {
1085                                 if(wd->TKIP_Group_KeyChanging == 0x1)
1086                                 {
1087                                         zm_debug_msg0("Countermeasure : Cancel Old Timer ");
1088                                         zfTimerCancel(dev,      ZM_EVENT_SKIP_COUNTERMEASURE);
1089                                 }
1090                                 else
1091                                 {
1092                                         zm_debug_msg0("Countermeasure : Create New Timer ");
1093                                 }
1094
1095                                 wd->TKIP_Group_KeyChanging = 0x1;
1096                                 zfTimerSchedule(dev, ZM_EVENT_SKIP_COUNTERMEASURE, 150);
1097                         }
1098
1099
1100
1101                         //------------------------------------------------------------------------
1102
1103             /* use default key */
1104             //zfCoreSetKey(dev, ZM_USER_KEY_DEFAULT+keyInfo.keyIndex, 0,
1105             //         wd->sta.encryMode, wd->sta.bssid, (u32_t*) keyInfo.key);
1106
1107             if ( encryMode == ZM_TKIP ||
1108                  encryMode == ZM_AES )
1109             {
1110                 zfHpSetDefaultKey(dev, keyInfo.keyIndex, encryMode,
1111                                  (u32_t*) keyInfo.key, (u32_t*) &keyInfo.key[16]);
1112
1113 #ifdef ZM_ENABLE_IBSS_WPA2PSK
1114             if ( (keyInfo.keyLength==16) && (wd->sta.ibssWpa2Psk==1) )
1115             {/* If not AES-CCMP and ibss network , use traditional */
1116                 wd->sta.wpaState = ZM_STA_WPA_STATE_PK_OK;
1117             }
1118             else
1119             {
1120                 if (wd->sta.wpaState == ZM_STA_WPA_STATE_PK_OK)
1121                     wd->sta.wpaState = ZM_STA_WPA_STATE_GK_OK;
1122                 else
1123                 {
1124                     wd->sta.wpaState = ZM_STA_WPA_STATE_PK_OK;
1125                     wd->sta.encryMode = encryMode;
1126                     wd->ws.encryMode = encryMode;
1127                 }
1128             }
1129 #else
1130                 if (wd->sta.wpaState == ZM_STA_WPA_STATE_PK_OK)
1131                     wd->sta.wpaState = ZM_STA_WPA_STATE_GK_OK;
1132                 else if ( wd->sta.wpaState == ZM_STA_WPA_STATE_INIT )
1133                 {
1134                     wd->sta.wpaState = ZM_STA_WPA_STATE_PK_OK;
1135                     wd->sta.encryMode = encryMode;
1136                     wd->ws.encryMode = encryMode;
1137                 }
1138 #endif
1139             }
1140             else
1141             {
1142                 zfHpSetDefaultKey(dev, keyInfo.keyIndex, encryMode,
1143                                (u32_t*) keyInfo.key, NULL);
1144
1145                 /* Save key for software WEP */
1146                 zfMemoryCopy(wd->sta.wepKey[keyInfo.keyIndex], keyInfo.key,
1147                         keyInfo.keyLength);
1148
1149                 /* TODO: Check whether we need to save the SWEncryMode */
1150                 wd->sta.SWEncryMode[keyInfo.keyIndex] = encryMode;
1151
1152                 wd->sta.encryMode = encryMode;
1153                 wd->ws.encryMode = encryMode;
1154             }
1155         }
1156     }
1157
1158 //    wd->sta.flagKeyChanging = 1;
1159     return ZM_STATUS_SUCCESS;
1160 }
1161
1162 /* PSEUDO test */
1163 u8_t zfiWlanPSEUDOSetKey(zdev_t* dev, struct zsKeyInfo keyInfo)
1164 {
1165     //u16_t  broadcast[3] = {0xffff, 0xffff, 0xffff};
1166     //u32_t* key;
1167     u8_t   micKey[16];
1168
1169     zmw_get_wlan_dev(dev);
1170
1171     switch (keyInfo.keyLength)
1172     {
1173         case 5:
1174             wd->sta.encryMode = ZM_WEP64;
1175             /* use default key */
1176             zfCoreSetKey(dev, 64, 0, ZM_WEP64, (u16_t *)keyInfo.macAddr, (u32_t*) keyInfo.key);
1177                           break;
1178
1179         case 13:
1180             wd->sta.encryMode = ZM_WEP128;
1181             /* use default key */
1182             zfCoreSetKey(dev, 64, 0, ZM_WEP128, (u16_t *)keyInfo.macAddr, (u32_t*) keyInfo.key);
1183                         break;
1184
1185         case 29:
1186             wd->sta.encryMode = ZM_WEP256;
1187             /* use default key */
1188             zfCoreSetKey(dev, 64, 1, ZM_WEP256,  (u16_t *)keyInfo.macAddr, (u32_t*) (&keyInfo.key[16]));
1189             zfCoreSetKey(dev, 64, 0, ZM_WEP256, (u16_t *)keyInfo.macAddr, (u32_t*) keyInfo.key);
1190                           break;
1191
1192         case 16:
1193             wd->sta.encryMode = ZM_AES;
1194             //zfCoreSetKey(dev, 0, 0, ZM_AES, (u16_t *)keyInfo.macAddr, (u32_t*) keyInfo.key);
1195             zfCoreSetKey(dev, 64, 0, ZM_AES, (u16_t *)keyInfo.macAddr, (u32_t*) keyInfo.key);
1196             break;
1197
1198         case 32:
1199 #ifdef ZM_ENABLE_CENC
1200             if (keyInfo.flag & ZM_KEY_FLAG_CENC)
1201             {
1202                 u16_t boardcastAddr[3] = {0xffff, 0xffff, 0xffff};
1203                 u16_t Addr_a[] = { 0x0000, 0x0080, 0x0901};
1204                 u16_t Addr_b[] = { 0x0000, 0x0080, 0x0902};
1205                 /* CENC test: user0,1 and user2 for boardcast */
1206                 wd->sta.encryMode = ZM_CENC;
1207                 zfCoreSetKey(dev, 0, 1, ZM_CENC, (u16_t *)Addr_a, (u32_t*) (&keyInfo.key[16]));
1208                 zfCoreSetKey(dev, 0, 0, ZM_CENC, (u16_t *)Addr_a, (u32_t*) keyInfo.key);
1209
1210                 zfCoreSetKey(dev, 1, 1, ZM_CENC, (u16_t *)Addr_b, (u32_t*) (&keyInfo.key[16]));
1211                 zfCoreSetKey(dev, 1, 0, ZM_CENC, (u16_t *)Addr_b, (u32_t*) keyInfo.key);
1212
1213                 zfCoreSetKey(dev, 2, 1, ZM_CENC, (u16_t *)boardcastAddr, (u32_t*) (&keyInfo.key[16]));
1214                 zfCoreSetKey(dev, 2, 0, ZM_CENC, (u16_t *)boardcastAddr, (u32_t*) keyInfo.key);
1215
1216                 /* Initialize PN sequence */
1217                 wd->sta.txiv[0] = 0x5c365c36;
1218                 wd->sta.txiv[1] = 0x5c365c36;
1219                 wd->sta.txiv[2] = 0x5c365c36;
1220                 wd->sta.txiv[3] = 0x5c365c36;
1221             }
1222             else
1223 #endif //ZM_ENABLE_CENC
1224             {
1225                 wd->sta.encryMode = ZM_TKIP;
1226                 zfCoreSetKey(dev, 64, 1, ZM_TKIP, (u16_t *)keyInfo.macAddr, (u32_t*) micKey);
1227                 zfCoreSetKey(dev, 64, 0, ZM_TKIP, (u16_t *)keyInfo.macAddr, (u32_t*) keyInfo.key);
1228             }
1229             break;
1230         default:
1231             wd->sta.encryMode = ZM_NO_WEP;
1232     }
1233
1234     return ZM_STATUS_SUCCESS;
1235 }
1236
1237 void zfiWlanSetPowerSaveMode(zdev_t* dev, u8_t mode)
1238 {
1239 #if 0
1240     zmw_get_wlan_dev(dev);
1241
1242     wd->sta.powerSaveMode = mode;
1243
1244     /* send null data with PwrBit to inform AP */
1245     if ( mode > ZM_STA_PS_NONE )
1246     {
1247         if ( wd->wlanMode == ZM_MODE_INFRASTRUCTURE )
1248         {
1249             zfSendNullData(dev, 1);
1250         }
1251
1252         /* device into PS mode */
1253         zfPSDeviceSleep(dev);
1254     }
1255 #endif
1256
1257     zfPowerSavingMgrSetMode(dev, mode);
1258 }
1259
1260 void zfiWlanSetMacAddress(zdev_t* dev, u16_t* mac)
1261 {
1262     zmw_get_wlan_dev(dev);
1263
1264     wd->macAddr[0] = mac[0];
1265     wd->macAddr[1] = mac[1];
1266     wd->macAddr[2] = mac[2];
1267
1268     zfHpSetMacAddress(dev, mac, 0);
1269 }
1270
1271 u8_t zfiWlanQueryWlanMode(zdev_t* dev)
1272 {
1273     zmw_get_wlan_dev(dev);
1274
1275     return wd->wlanMode;
1276 }
1277
1278 u8_t zfiWlanQueryAdapterState(zdev_t* dev)
1279 {
1280     zmw_get_wlan_dev(dev);
1281
1282     return wd->state;
1283 }
1284
1285 u8_t zfiWlanQueryAuthenticationMode(zdev_t* dev, u8_t bWrapper)
1286 {
1287     u8_t   authMode;
1288
1289     zmw_get_wlan_dev(dev);
1290
1291     if ( bWrapper )
1292     {
1293         authMode = wd->ws.authMode;
1294     }
1295     else
1296     {
1297         //authMode = wd->sta.authMode;
1298         authMode = wd->sta.currentAuthMode;
1299     }
1300
1301     return authMode;
1302 }
1303
1304 u8_t zfiWlanQueryWepStatus(zdev_t* dev, u8_t bWrapper)
1305 {
1306     u8_t wepStatus;
1307
1308     zmw_get_wlan_dev(dev);
1309
1310     if ( bWrapper )
1311     {
1312         wepStatus = wd->ws.wepStatus;
1313     }
1314     else
1315     {
1316         wepStatus = wd->sta.wepStatus;
1317     }
1318
1319     return wepStatus;
1320 }
1321
1322 void zfiWlanQuerySSID(zdev_t* dev, u8_t* ssid, u8_t* pSsidLength)
1323 {
1324     u16_t vapId = 0;
1325     zmw_get_wlan_dev(dev);
1326
1327     if (wd->wlanMode == ZM_MODE_AP)
1328     {
1329         vapId = zfwGetVapId(dev);
1330
1331         if (vapId == 0xffff)
1332         {
1333             *pSsidLength = wd->ap.ssidLen[0];
1334             zfMemoryCopy(ssid, wd->ap.ssid[0], wd->ap.ssidLen[0]);
1335         }
1336         else
1337         {
1338             *pSsidLength = wd->ap.ssidLen[vapId + 1];
1339             zfMemoryCopy(ssid, wd->ap.ssid[vapId + 1], wd->ap.ssidLen[vapId + 1]);
1340         }
1341     }
1342     else
1343     {
1344         *pSsidLength = wd->sta.ssidLen;
1345         zfMemoryCopy(ssid, wd->sta.ssid, wd->sta.ssidLen);
1346     }
1347 }
1348
1349 u16_t zfiWlanQueryFragThreshold(zdev_t* dev)
1350 {
1351     zmw_get_wlan_dev(dev);
1352
1353     return wd->fragThreshold;
1354 }
1355
1356 u16_t zfiWlanQueryRtsThreshold(zdev_t* dev)
1357 {
1358     zmw_get_wlan_dev(dev);
1359
1360     return wd->rtsThreshold;
1361 }
1362
1363 u32_t zfiWlanQueryFrequency(zdev_t* dev)
1364 {
1365     zmw_get_wlan_dev(dev);
1366
1367     return (wd->frequency*1000);
1368 }
1369
1370 /***********************************************************
1371  * Function: zfiWlanQueryCurrentFrequency
1372  * Return value:
1373  *   -   0 : no validate current frequency
1374  *   - (>0): current frequency depend on "qmode"
1375  * Input:
1376  *   - qmode:
1377  *      0: return value depend on the support mode, this
1378            qmode is use to solve the bug #31223
1379  *      1: return the actually current frequency
1380  ***********************************************************/
1381 u32_t zfiWlanQueryCurrentFrequency(zdev_t* dev, u8_t qmode)
1382 {
1383     u32_t frequency;
1384
1385     zmw_get_wlan_dev(dev);
1386
1387     switch (qmode)
1388     {
1389     case 0:
1390         if (wd->sta.currentFrequency > 3000)
1391         {
1392             if (wd->supportMode & ZM_WIRELESS_MODE_5)
1393             {
1394                 frequency = wd->sta.currentFrequency;
1395             }
1396             else if (wd->supportMode & ZM_WIRELESS_MODE_24)
1397             {
1398                 frequency = zfChGetFirst2GhzChannel(dev);
1399             }
1400             else
1401             {
1402                 frequency = 0;
1403             }
1404         }
1405         else
1406         {
1407             if (wd->supportMode & ZM_WIRELESS_MODE_24)
1408             {
1409                 frequency = wd->sta.currentFrequency;
1410             }
1411             else if (wd->supportMode & ZM_WIRELESS_MODE_5)
1412             {
1413                 frequency = zfChGetLast5GhzChannel(dev);
1414             }
1415             else
1416             {
1417                 frequency = 0;
1418             }
1419         }
1420         break;
1421
1422     case 1:
1423         frequency = wd->sta.currentFrequency;
1424         break;
1425
1426     default:
1427         frequency = 0;
1428     }
1429
1430     return (frequency*1000);
1431 }
1432
1433 u32_t zfiWlanQueryFrequencyAttribute(zdev_t* dev, u32_t freq)
1434 {
1435     u8_t  i;
1436     u16_t frequency = (u16_t) (freq/1000);
1437     u32_t ret = 0;
1438
1439     zmw_get_wlan_dev(dev);
1440
1441     for (i = 0; i < wd->regulationTable.allowChannelCnt; i++)
1442     {
1443         if ( wd->regulationTable.allowChannel[i].channel == frequency )
1444         {
1445             ret = wd->regulationTable.allowChannel[i].channelFlags;
1446         }
1447     }
1448
1449     return ret;
1450 }
1451
1452 /* BandWidth  0=>20  1=>40 */
1453 /* ExtOffset  0=>20  1=>high control 40   3=>low control 40 */
1454 void zfiWlanQueryFrequencyHT(zdev_t* dev, u32_t *bandWidth, u32_t *extOffset)
1455 {
1456     zmw_get_wlan_dev(dev);
1457
1458     *bandWidth = wd->BandWidth40;
1459     *extOffset = wd->ExtOffset;
1460 }
1461
1462 u8_t zfiWlanQueryCWMode(zdev_t* dev)
1463 {
1464     zmw_get_wlan_dev(dev);
1465
1466     return wd->cwm.cw_mode;
1467 }
1468
1469 u32_t zfiWlanQueryCWEnable(zdev_t* dev)
1470 {
1471     zmw_get_wlan_dev(dev);
1472
1473     return wd->cwm.cw_enable;
1474 }
1475
1476 void zfiWlanQueryBssid(zdev_t* dev, u8_t* bssid)
1477 {
1478     u8_t   addr[6];
1479
1480     zmw_get_wlan_dev(dev);
1481
1482     ZM_MAC_WORD_TO_BYTE(wd->sta.bssid, addr);
1483     zfMemoryCopy(bssid, addr, 6);
1484 }
1485
1486 u16_t zfiWlanQueryBeaconInterval(zdev_t* dev)
1487 {
1488     zmw_get_wlan_dev(dev);
1489
1490     return wd->beaconInterval;
1491 }
1492
1493 u32_t zfiWlanQueryRxBeaconTotal(zdev_t* dev)
1494 {
1495     zmw_get_wlan_dev(dev);
1496     wd->sta.rxBeaconTotal += wd->sta.rxBeaconCount;
1497
1498     return wd->sta.rxBeaconTotal;
1499 }
1500
1501 u16_t zfiWlanQueryAtimWindow(zdev_t* dev)
1502 {
1503     u16_t atimWindow;
1504
1505     zmw_get_wlan_dev(dev);
1506
1507     atimWindow = wd->sta.atimWindow;
1508
1509     return atimWindow;
1510 }
1511
1512 u8_t zfiWlanQueryEncryMode(zdev_t* dev)
1513 {
1514     zmw_get_wlan_dev(dev);
1515
1516     if (wd->wlanMode == ZM_MODE_AP)
1517         return wd->ap.encryMode[0];
1518     else
1519         return wd->sta.encryMode;
1520 }
1521
1522 u16_t zfiWlanQueryCapability(zdev_t* dev)
1523 {
1524     u16_t capability;
1525
1526     zmw_get_wlan_dev(dev);
1527
1528     capability = wd->sta.capability[0] +
1529                  (((u16_t) wd->sta.capability[1]) << 8);
1530
1531     return capability;
1532
1533 }
1534
1535 u16_t zfiWlanQueryAid(zdev_t* dev)
1536 {
1537     zmw_get_wlan_dev(dev);
1538
1539     return wd->sta.aid;
1540 }
1541
1542 void zfiWlanQuerySupportRate(zdev_t* dev, u8_t* rateArray, u8_t* pLength)
1543 {
1544     u8_t   i, j=0;
1545
1546     zmw_get_wlan_dev(dev);
1547
1548     for( i=0; i<4; i++ )
1549     {
1550         if ( wd->bRate & (0x1 << i) )
1551         {
1552             rateArray[j] = zg11bRateTbl[i] +
1553                            ((wd->bRateBasic & (0x1<<i))<<(7-i));
1554             j++;
1555         }
1556     }
1557
1558     *pLength = j;
1559 }
1560
1561 void zfiWlanQueryExtSupportRate(zdev_t* dev, u8_t* rateArray, u8_t* pLength)
1562 {
1563     u8_t   i, j=0;
1564
1565     zmw_get_wlan_dev(dev);
1566
1567     for( i=0; i<8; i++ )
1568     {
1569         if ( wd->gRate & (0x1 << i) )
1570         {
1571             rateArray[j] = zg11gRateTbl[i] +
1572                            ((wd->gRateBasic & (0x1<<i))<<(7-i));
1573             j++;
1574         }
1575     }
1576
1577     *pLength = j;
1578 }
1579
1580 void zfiWlanQueryRsnIe(zdev_t* dev, u8_t* ie, u8_t* pLength)
1581 {
1582     u8_t len;
1583
1584     zmw_get_wlan_dev(dev);
1585
1586     len = wd->sta.rsnIe[1] + 2;
1587     zfMemoryCopy(ie, wd->sta.rsnIe, len);
1588     *pLength = len;
1589 }
1590
1591 void zfiWlanQueryWpaIe(zdev_t* dev, u8_t* ie, u8_t* pLength)
1592 {
1593     u8_t len;
1594
1595     zmw_get_wlan_dev(dev);
1596
1597     len = wd->sta.wpaIe[1] + 2;
1598     zfMemoryCopy(ie, wd->sta.wpaIe, len);
1599     *pLength = len;
1600
1601 }
1602
1603 u8_t zfiWlanQueryMulticastCipherAlgo(zdev_t *dev)
1604 {
1605     zmw_get_wlan_dev(dev);
1606
1607     switch( wd->sta.currentAuthMode )
1608     {
1609         case ZM_AUTH_MODE_WPA2PSK:
1610         case ZM_AUTH_MODE_WPA2:
1611             if ( wd->sta.rsnIe[7] == 2 )
1612             {
1613                 return ZM_TKIP;
1614             }
1615             else
1616             {
1617                 return ZM_AES;
1618             }
1619             break;
1620
1621         case ZM_AUTH_MODE_WPAPSK:
1622         case ZM_AUTH_MODE_WPA:
1623             if ( wd->sta.rsnIe[11] == 2 )
1624             {
1625                 return ZM_TKIP;
1626             }
1627             else
1628             {
1629                 return ZM_AES;
1630             }
1631             break;
1632
1633         default:
1634             return wd->sta.encryMode;
1635     }
1636 }
1637
1638 u8_t zfiWlanQueryHTMode(zdev_t* dev)
1639 {
1640     zmw_get_wlan_dev(dev);
1641     // 0:Legancy, 1:N
1642     return wd->sta.EnableHT;
1643 }
1644
1645 u8_t zfiWlanQueryBandWidth40(zdev_t* dev)
1646 {
1647     zmw_get_wlan_dev(dev);
1648     // 0:20M, 1:40M
1649     return wd->BandWidth40;
1650 }
1651
1652 u16_t zfiWlanQueryRegionCode(zdev_t* dev)
1653 {
1654     zmw_get_wlan_dev(dev);
1655
1656     return wd->regulationTable.regionCode;
1657 }
1658 void zfiWlanSetWpaIe(zdev_t* dev, u8_t* ie, u8_t Length)
1659 {
1660     u16_t vapId = 0;
1661     zmw_get_wlan_dev(dev);
1662
1663     if (wd->wlanMode == ZM_MODE_AP) // AP Mode
1664     {
1665         vapId = zfwGetVapId(dev);
1666
1667         if (vapId == 0xffff)
1668             vapId = 0;
1669         else
1670             vapId++;
1671
1672         zm_assert(Length < ZM_MAX_WPAIE_SIZE);
1673         if (Length < ZM_MAX_WPAIE_SIZE)
1674         {
1675             wd->ap.wpaLen[vapId] = Length;
1676             zfMemoryCopy(wd->ap.wpaIe[vapId], ie, wd->ap.wpaLen[vapId]);
1677         }
1678
1679     }
1680     else
1681     {
1682         wd->sta.wpaLen = Length;
1683         zfMemoryCopy(wd->sta.wpaIe, ie, wd->sta.wpaLen);
1684     }
1685     //zfiWlanSetWpaSupport(dev, 1);
1686     if (wd->wlanMode == ZM_MODE_AP) // AP Mode
1687     {
1688         wd->ap.wpaSupport[vapId] = 1;
1689     }
1690     else
1691     {
1692         wd->sta.wpaSupport = 1;
1693     }
1694
1695 }
1696
1697 void zfiWlanSetWpaSupport(zdev_t* dev, u8_t WpaSupport)
1698 {
1699     u16_t vapId = 0;
1700     zmw_get_wlan_dev(dev);
1701
1702     if (wd->wlanMode == ZM_MODE_AP) // AP Mode
1703     {
1704         vapId = zfwGetVapId(dev);
1705
1706         if (vapId == 0xffff)
1707             vapId = 0;
1708         else
1709             vapId++;
1710
1711         wd->ap.wpaSupport[vapId] = WpaSupport;
1712     }
1713     else
1714     {
1715         wd->sta.wpaSupport = WpaSupport;
1716     }
1717
1718 }
1719
1720 void zfiWlanSetProtectionMode(zdev_t* dev, u8_t mode)
1721 {
1722     zmw_get_wlan_dev(dev);
1723
1724     wd->sta.bProtectionMode = mode;
1725     if (wd->sta.bProtectionMode == TRUE)
1726     {
1727         zfHpSetSlotTime(dev, 0);
1728     }
1729     else
1730     {
1731         zfHpSetSlotTime(dev, 1);
1732     }
1733
1734     zm_msg1_mm(ZM_LV_1, "wd->protectionMode=", wd->sta.bProtectionMode);
1735 }
1736
1737 void zfiWlanSetBasicRate(zdev_t* dev, u8_t bRateSet, u8_t gRateSet,
1738                          u32_t nRateSet)
1739 {
1740     zmw_get_wlan_dev(dev);
1741
1742     wd->ws.bRateBasic = bRateSet;
1743     wd->ws.gRateBasic = gRateSet;
1744     wd->ws.nRateBasic = nRateSet;
1745 }
1746
1747 void zfiWlanSetBGMode(zdev_t* dev, u8_t mode)
1748 {
1749     zmw_get_wlan_dev(dev);
1750
1751     wd->ws.bgMode = mode;
1752 }
1753
1754 void zfiWlanSetpreambleType(zdev_t* dev, u8_t type)
1755 {
1756     zmw_get_wlan_dev(dev);
1757
1758     wd->ws.preambleType = type;
1759 }
1760
1761 u8_t zfiWlanQuerypreambleType(zdev_t* dev)
1762 {
1763     zmw_get_wlan_dev(dev);
1764
1765     return wd->ws.preambleType;
1766 }
1767
1768 u8_t zfiWlanQueryPowerSaveMode(zdev_t* dev)
1769 {
1770     zmw_get_wlan_dev(dev);
1771
1772     return wd->sta.powerSaveMode;
1773 }
1774
1775 u8_t zfiWlanSetPmkidInfo(zdev_t* dev, u16_t* bssid, u8_t* pmkid)
1776 {
1777     u32_t  i;
1778
1779     zmw_get_wlan_dev(dev);
1780
1781     for(i=0; i<wd->sta.pmkidInfo.bssidCount; i++)
1782     {
1783         if ( zfMemoryIsEqual((u8_t*) wd->sta.pmkidInfo.bssidInfo[i].bssid,
1784                              (u8_t*) bssid, 6) )
1785         {
1786             /* matched */
1787             break;
1788         }
1789     }
1790
1791     if ( i < wd->sta.pmkidInfo.bssidCount )
1792     {
1793         /* overwrite the original one */
1794         zfMemoryCopy(wd->sta.pmkidInfo.bssidInfo[i].pmkid, pmkid, 16);
1795     }
1796     else
1797     {
1798         if ( i < ZM_PMKID_MAX_BSS_CNT )
1799         {
1800             wd->sta.pmkidInfo.bssidInfo[i].bssid[0] = bssid[0];
1801             wd->sta.pmkidInfo.bssidInfo[i].bssid[1] = bssid[1];
1802             wd->sta.pmkidInfo.bssidInfo[i].bssid[2] = bssid[2];
1803
1804             zfMemoryCopy(wd->sta.pmkidInfo.bssidInfo[i].pmkid, pmkid, 16);
1805             wd->sta.pmkidInfo.bssidCount++;
1806         }
1807     }
1808
1809     return 0;
1810 }
1811
1812 u32_t zfiWlanQueryPmkidInfo(zdev_t* dev, u8_t* buf, u32_t len)
1813 {
1814     //struct zsPmkidInfo* pPmkidInfo = ( struct zsPmkidInfo* ) buf;
1815     u32_t  size;
1816
1817     zmw_get_wlan_dev(dev);
1818
1819     size = sizeof(u32_t) +
1820            wd->sta.pmkidInfo.bssidCount * sizeof(struct zsPmkidBssidInfo);
1821
1822     if ( len < size )
1823     {
1824         return wd->sta.pmkidInfo.bssidCount;
1825     }
1826
1827     zfMemoryCopy(buf, (u8_t*) &wd->sta.pmkidInfo, (u16_t) size);
1828
1829     return 0;
1830 }
1831
1832 void zfiWlanSetMulticastList(zdev_t* dev, u8_t size, u8_t* pList)
1833 {
1834     struct zsMulticastAddr* pMacList = (struct zsMulticastAddr*) pList;
1835     u8_t   i;
1836     u8_t   bAllMulticast = 0;
1837     //u32_t  value;
1838
1839     zmw_get_wlan_dev(dev);
1840
1841     wd->sta.multicastList.size = size;
1842     for(i=0; i<size; i++)
1843     {
1844         zfMemoryCopy(wd->sta.multicastList.macAddr[i].addr,
1845                      pMacList[i].addr, 6);
1846     }
1847
1848     if ( wd->sta.osRxFilter & ZM_PACKET_TYPE_ALL_MULTICAST )
1849         bAllMulticast = 1;
1850     zfHpSetMulticastList(dev, size, pList, bAllMulticast);
1851
1852 }
1853
1854 void zfiWlanRemoveKey(zdev_t* dev, u8_t keyType, u8_t keyId)
1855 {
1856     u16_t  fakeMacAddr[3] = {0, 0, 0};
1857     u32_t  fakeKey[4] = {0, 0, 0, 0};
1858
1859     zmw_get_wlan_dev(dev);
1860
1861     if ( keyType == 0 )
1862     {
1863         /* remove WEP key */
1864         zm_debug_msg0("remove WEP key");
1865         zfCoreSetKey(dev, ZM_USER_KEY_DEFAULT+keyId, 0,
1866                  ZM_NO_WEP, fakeMacAddr, fakeKey);
1867         wd->sta.encryMode = ZM_NO_WEP;
1868     }
1869     else if ( keyType == 1 )
1870     {
1871         /* remove pairwise key */
1872         zm_debug_msg0("remove pairwise key");
1873         zfHpRemoveKey(dev, ZM_USER_KEY_PK);
1874         wd->sta.encryMode = ZM_NO_WEP;
1875     }
1876     else
1877     {
1878         /* remove group key */
1879         zm_debug_msg0("remove group key");
1880         zfHpRemoveKey(dev, ZM_USER_KEY_GK);
1881     }
1882 }
1883
1884
1885 void zfiWlanQueryRegulationTable(zdev_t* dev, struct zsRegulationTable* pEntry)
1886 {
1887     zmw_get_wlan_dev(dev);
1888
1889     zfMemoryCopy((u8_t*) pEntry, (u8_t*) &wd->regulationTable,
1890                  sizeof(struct zsRegulationTable));
1891 }
1892
1893 /* parameter "time" is specified in ms */
1894 void zfiWlanSetScanTimerPerChannel(zdev_t* dev, u16_t time)
1895 {
1896     zmw_get_wlan_dev(dev);
1897
1898     zm_debug_msg1("scan time (ms) = ", time);
1899
1900     wd->sta.activescanTickPerChannel = time / ZM_MS_PER_TICK;
1901 }
1902
1903 void zfiWlanSetAutoReconnect(zdev_t* dev, u8_t enable)
1904 {
1905     zmw_get_wlan_dev(dev);
1906
1907     wd->sta.bAutoReconnect = enable;
1908     //wd->sta.bAutoReconnectEnabled = enable;
1909 }
1910
1911 void zfiWlanSetStaWme(zdev_t* dev, u8_t enable, u8_t uapsdInfo)
1912 {
1913     zmw_get_wlan_dev(dev);
1914
1915     wd->ws.staWmeEnabled = enable & 0x3;
1916     if ((enable & 0x2) != 0)
1917     {
1918         wd->ws.staWmeQosInfo = uapsdInfo & 0x6f;
1919     }
1920     else
1921     {
1922         wd->ws.staWmeQosInfo = 0;
1923     }
1924 }
1925
1926 void zfiWlanSetApWme(zdev_t* dev, u8_t enable)
1927 {
1928     zmw_get_wlan_dev(dev);
1929
1930     wd->ws.apWmeEnabled = enable;
1931 }
1932
1933 u8_t zfiWlanQuerywmeEnable(zdev_t* dev)
1934 {
1935     zmw_get_wlan_dev(dev);
1936
1937     return wd->ws.staWmeEnabled;
1938 }
1939
1940 void zfiWlanSetProbingHiddenSsid(zdev_t* dev, u8_t* ssid, u8_t ssidLen,
1941     u16_t entry)
1942 {
1943     zmw_get_wlan_dev(dev);
1944     zmw_declare_for_critical_section();
1945
1946
1947     if ((ssidLen <= 32) && (entry < ZM_MAX_PROBE_HIDDEN_SSID_SIZE))
1948     {
1949         zmw_enter_critical_section(dev);
1950         wd->ws.probingSsidList[entry].ssidLen = ssidLen;
1951         zfMemoryCopy(wd->ws.probingSsidList[entry].ssid, ssid, ssidLen);
1952         zmw_leave_critical_section(dev);
1953     }
1954
1955     return;
1956 }
1957
1958 void zfiWlanSetDisableProbingWithSsid(zdev_t* dev, u8_t mode)
1959 {
1960     zmw_get_wlan_dev(dev);
1961
1962     wd->sta.disableProbingWithSsid = mode;
1963
1964     return;
1965 }
1966
1967 void zfiWlanSetDropUnencryptedPackets(zdev_t* dev, u8_t enable)
1968 {
1969     zmw_get_wlan_dev(dev);
1970
1971     wd->ws.dropUnencryptedPkts = enable;
1972 }
1973
1974 void zfiWlanSetStaRxSecurityCheckCb(zdev_t* dev, zfpStaRxSecurityCheckCb pStaRxSecurityCheckCb)
1975 {
1976     zmw_get_wlan_dev(dev);
1977
1978     wd->sta.pStaRxSecurityCheckCb = pStaRxSecurityCheckCb;
1979 }
1980
1981 void zfiWlanSetIBSSJoinOnly(zdev_t* dev, u8_t joinOnly)
1982 {
1983     zmw_get_wlan_dev(dev);
1984
1985     wd->ws.ibssJoinOnly = joinOnly;
1986 }
1987
1988 /************************************************************************/
1989 /*                                                                      */
1990 /*    FUNCTION DESCRIPTION                  zfiConfigWdsPort            */
1991 /*      Configure WDS port.                                             */
1992 /*                                                                      */
1993 /*    INPUTS                                                            */
1994 /*      dev : device pointer                                            */
1995 /*      wdsPortId : WDS port ID, start from 0                           */
1996 /*      flag : 0=>disable WDS port, 1=>enable WDS port                  */
1997 /*      wdsAddr : WDS neighbor MAC address                              */
1998 /*      encType : encryption type for WDS port                          */
1999 /*      wdsKey : encryption key for WDS port                            */
2000 /*                                                                      */
2001 /*    OUTPUTS                                                           */
2002 /*      Error code                                                      */
2003 /*                                                                      */
2004 /*    AUTHOR                                                            */
2005 /*      Stephen Chen        ZyDAS Technology Corporation    2006.6      */
2006 /*                                                                      */
2007 /************************************************************************/
2008 u16_t zfiConfigWdsPort(zdev_t* dev, u8_t wdsPortId, u16_t flag, u16_t* wdsAddr,
2009         u16_t encType, u32_t* wdsKey)
2010 {
2011     u16_t addr[3];
2012     u32_t key[4];
2013
2014     zmw_get_wlan_dev(dev);
2015
2016     if (wdsPortId >= ZM_MAX_WDS_SUPPORT)
2017     {
2018         return ZM_ERR_WDS_PORT_ID;
2019     }
2020
2021     if (flag == 1)
2022     {
2023         /* Enable WDS port */
2024         wd->ap.wds.macAddr[wdsPortId][0] = wdsAddr[0];
2025         wd->ap.wds.macAddr[wdsPortId][1] = wdsAddr[1];
2026         wd->ap.wds.macAddr[wdsPortId][2] = wdsAddr[2];
2027
2028         wd->ap.wds.wdsBitmap |= (1 << wdsPortId);
2029         wd->ap.wds.encryMode[wdsPortId] = (u8_t) encType;
2030
2031         zfCoreSetKey(dev, 10+ZM_MAX_WDS_SUPPORT, 0, (u8_t) encType, wdsAddr, wdsKey);
2032     }
2033     else
2034     {
2035         /* Disable WDS port */
2036         addr[0] = addr[1] = addr[2] = 0;
2037         key[0] = key[1] = key[2] = key[3] = 0;
2038         wd->ap.wds.wdsBitmap &= (~(1 << wdsPortId));
2039         zfCoreSetKey(dev, 10+ZM_MAX_WDS_SUPPORT, 0, ZM_NO_WEP, addr, key);
2040     }
2041
2042     return ZM_SUCCESS;
2043 }
2044 #ifdef ZM_ENABLE_CENC
2045 /* CENC */
2046 void zfiWlanQueryGSN(zdev_t* dev, u8_t *gsn, u16_t vapId)
2047 {
2048     //struct zsWlanDev* wd = (struct zsWlanDev*) zmw_wlan_dev(dev);
2049     u32_t txiv[4];
2050     zmw_get_wlan_dev(dev);
2051
2052     /* convert little endian to big endian for 32 bits */
2053     txiv[3] = wd->ap.txiv[vapId][0];
2054     txiv[2] = wd->ap.txiv[vapId][1];
2055     txiv[1] = wd->ap.txiv[vapId][2];
2056     txiv[0] = wd->ap.txiv[vapId][3];
2057
2058     zfMemoryCopy(gsn, (u8_t*)txiv, 16);
2059 }
2060 #endif //ZM_ENABLE_CENC
2061 //CWYang(+)
2062 void zfiWlanQuerySignalInfo(zdev_t* dev, u8_t *buffer)
2063 {
2064     zmw_get_wlan_dev(dev);
2065
2066     /*Change Signal Strength/Quality Value to Human Sense Here*/
2067
2068     buffer[0] = wd->SignalStrength;
2069     buffer[1] = wd->SignalQuality;
2070 }
2071
2072 /* OS-XP */
2073 u16_t zfiStaAddIeWpaRsn(zdev_t* dev, zbuf_t* buf, u16_t offset, u8_t frameType)
2074 {
2075     return  zfStaAddIeWpaRsn(dev, buf, offset, frameType);
2076 }
2077
2078 /* zfiDebugCmd                                                                        */
2079 /*     cmd       value-description                                                  */
2080 /*         0       schedule timer                                                     */
2081 /*         1       cancel timer                                                         */
2082 /*         2       clear timer                                                           */
2083 /*         3       test timer                                                            */
2084 /*         4                                                                                 */
2085 /*         5                                                                                 */
2086 /*         6       checksum test     0/1                                           */
2087 /*         7       enableProtectionMode                                          */
2088 /*         8       rx packet content dump    0/1                               */
2089
2090 u32_t zfiDebugCmd(zdev_t* dev, u32_t cmd, u32_t value)
2091 {
2092     u16_t event;
2093     u32_t tick;
2094     zmw_get_wlan_dev(dev);
2095
2096     zmw_declare_for_critical_section();
2097
2098
2099     zmw_enter_critical_section(dev);
2100
2101     if ( cmd == 0 )
2102     {   /* schedule timer */
2103         event = (u16_t) ((value >> 16) & 0xffff);
2104         tick = value & 0xffff;
2105         zfTimerSchedule(dev, event, tick);
2106     }
2107     else if ( cmd == 1 )
2108     {   /* cancel timer */
2109         event = (u16_t) (value & 0xffff);
2110         zfTimerCancel(dev, event);
2111     }
2112     else if ( cmd == 2 )
2113     {   /* clear timer */
2114         zfTimerClear(dev);
2115     }
2116     else if ( cmd == 3 )
2117     {   /* test timer */
2118         zfTimerSchedule(dev, 1,  500);
2119         zfTimerSchedule(dev, 2, 1000);
2120         zfTimerSchedule(dev, 3, 1000);
2121         zfTimerSchedule(dev, 4, 1000);
2122         zfTimerSchedule(dev, 5, 1500);
2123         zfTimerSchedule(dev, 6, 2000);
2124         zfTimerSchedule(dev, 7, 2200);
2125         zfTimerSchedule(dev, 6, 2500);
2126         zfTimerSchedule(dev, 8, 2800);
2127     }
2128     else if ( cmd == 4)
2129     {
2130         zfTimerSchedule(dev, 1,  500);
2131         zfTimerSchedule(dev, 2, 1000);
2132         zfTimerSchedule(dev, 3, 1000);
2133         zfTimerSchedule(dev, 4, 1000);
2134         zfTimerSchedule(dev, 5, 1500);
2135         zfTimerSchedule(dev, 6, 2000);
2136         zfTimerSchedule(dev, 7, 2200);
2137         zfTimerSchedule(dev, 6, 2500);
2138         zfTimerSchedule(dev, 8, 2800);
2139         zfTimerCancel(dev, 1);
2140         zfTimerCancel(dev, 3);
2141         zfTimerCancel(dev, 6);
2142     }
2143     else if ( cmd == 5 )
2144     {
2145         wd->sta.keyId = (u8_t) value;
2146     }
2147         else if ( cmd == 6 )
2148         {
2149             /* 0: normal    1: always set TCP/UDP checksum zero */
2150         wd->checksumTest = value;
2151         }
2152         else if ( cmd == 7 )
2153         {
2154         wd->enableProtectionMode = value;
2155             zm_msg1_mm(ZM_LV_1, "wd->enableProtectionMode=", wd->enableProtectionMode);
2156         }
2157         else if ( cmd == 8 )
2158         {
2159         /* rx packet content dump */
2160         if (value)
2161         {
2162             wd->rxPacketDump = 1;
2163         }
2164         else
2165         {
2166             wd->rxPacketDump = 0;
2167         }
2168         }
2169
2170
2171     zmw_leave_critical_section(dev);
2172
2173     return 0;
2174 }
2175
2176 #ifdef ZM_ENABLE_CENC
2177 u8_t zfiWlanSetCencPairwiseKey(zdev_t* dev, u8_t keyid, u32_t *txiv, u32_t *rxiv,
2178         u8_t *key, u8_t *mic)
2179 {
2180     struct zsKeyInfo keyInfo;
2181     u8_t cencKey[32];
2182     u8_t i;
2183     u16_t macAddr[3];
2184
2185     zmw_get_wlan_dev(dev);
2186
2187     for (i = 0; i < 16; i++)
2188         cencKey[i] = key[i];
2189     for (i = 0; i < 16; i++)
2190         cencKey[i + 16] = mic[i];
2191     keyInfo.key = cencKey;
2192     keyInfo.keyLength = 32;
2193     keyInfo.keyIndex = keyid;
2194     keyInfo.flag = ZM_KEY_FLAG_CENC | ZM_KEY_FLAG_PK;
2195     for (i = 0; i < 3; i++)
2196         macAddr[i] = wd->sta.bssid[i];
2197     keyInfo.macAddr = macAddr;
2198
2199     zfiWlanSetKey(dev, keyInfo);
2200
2201     /* Reset txiv and rxiv */
2202     //wd->sta.txiv[0] = txiv[0];
2203     //wd->sta.txiv[1] = txiv[1];
2204     //wd->sta.txiv[2] = txiv[2];
2205     //wd->sta.txiv[3] = txiv[3];
2206     //
2207     //wd->sta.rxiv[0] = rxiv[0];
2208     //wd->sta.rxiv[1] = rxiv[1];
2209     //wd->sta.rxiv[2] = rxiv[2];
2210     //wd->sta.rxiv[3] = rxiv[3];
2211
2212     return 0;
2213 }
2214
2215 u8_t zfiWlanSetCencGroupKey(zdev_t* dev, u8_t keyid, u32_t *rxiv,
2216         u8_t *key, u8_t *mic)
2217 {
2218     struct zsKeyInfo keyInfo;
2219     u8_t cencKey[32];
2220     u8_t i;
2221     u16_t macAddr[6] = {0xffff, 0xffff, 0xffff};
2222
2223     zmw_get_wlan_dev(dev);
2224
2225     for (i = 0; i < 16; i++)
2226         cencKey[i] = key[i];
2227     for (i = 0; i < 16; i++)
2228         cencKey[i + 16] = mic[i];
2229     keyInfo.key = cencKey;
2230     keyInfo.keyLength = 32;
2231     keyInfo.keyIndex = keyid;
2232     keyInfo.flag = ZM_KEY_FLAG_CENC | ZM_KEY_FLAG_GK;
2233     keyInfo.vapId = 0;
2234     for (i = 0; i < 3; i++)
2235         keyInfo.vapAddr[i] = wd->macAddr[i];
2236     keyInfo.macAddr = macAddr;
2237
2238     zfiWlanSetKey(dev, keyInfo);
2239
2240     /* Reset txiv and rxiv */
2241     wd->sta.rxivGK[0] = ((rxiv[3] >> 24) & 0xFF)
2242                       + (((rxiv[3] >> 16) & 0xFF) << 8)
2243                       + (((rxiv[3] >> 8) & 0xFF) << 16)
2244                       + ((rxiv[3] & 0xFF) << 24);
2245     wd->sta.rxivGK[1] = ((rxiv[2] >> 24) & 0xFF)
2246                       + (((rxiv[2] >> 16) & 0xFF) << 8)
2247                       + (((rxiv[2] >> 8) & 0xFF) << 16)
2248                       + ((rxiv[2] & 0xFF) << 24);
2249     wd->sta.rxivGK[2] = ((rxiv[1] >> 24) & 0xFF)
2250                       + (((rxiv[1] >> 16) & 0xFF) << 8)
2251                       + (((rxiv[1] >> 8) & 0xFF) << 16)
2252                       + ((rxiv[1] & 0xFF) << 24);
2253     wd->sta.rxivGK[3] = ((rxiv[0] >> 24) & 0xFF)
2254                       + (((rxiv[0] >> 16) & 0xFF) << 8)
2255                       + (((rxiv[0] >> 8) & 0xFF) << 16)
2256                       + ((rxiv[0] & 0xFF) << 24);
2257
2258     wd->sta.authMode = ZM_AUTH_MODE_CENC;
2259     wd->sta.currentAuthMode = ZM_AUTH_MODE_CENC;
2260
2261     return 0;
2262 }
2263 #endif //ZM_ENABLE_CENC
2264
2265 u8_t zfiWlanSetDot11DMode(zdev_t* dev, u8_t mode)
2266 {
2267     u8_t i;
2268
2269     zmw_get_wlan_dev(dev);
2270
2271     wd->sta.b802_11D = mode;
2272     if (mode) //Enable 802.11d
2273     {
2274         wd->regulationTable.regionCode = NO_ENUMRD;
2275         for (i = 0; i < wd->regulationTable.allowChannelCnt; i++)
2276             wd->regulationTable.allowChannel[i].channelFlags |= ZM_REG_FLAG_CHANNEL_PASSIVE;
2277     }
2278     else //Disable
2279     {
2280         for (i = 0; i < wd->regulationTable.allowChannelCnt; i++)
2281             wd->regulationTable.allowChannel[i].channelFlags &= ~ZM_REG_FLAG_CHANNEL_PASSIVE;
2282     }
2283
2284     return 0;
2285 }
2286
2287 u8_t zfiWlanSetDot11HDFSMode(zdev_t* dev, u8_t mode)
2288 {
2289     zmw_get_wlan_dev(dev);
2290
2291     //zm_debug_msg0("CWY - Enable 802.11h DFS");
2292
2293     // TODO : DFS Enable in 5250 to 5350 MHz and 5470 to 5725 MHz .
2294     //if ( Adapter->ZD80211HSupport &&
2295     //   Adapter->CardSetting.NetworkTypeInUse == Ndis802_11OFDM5 &&
2296     //   ((ChannelNo >=52 && ChannelNo <= 64)   ||                              //5250~5350 MHZ
2297     //    (ChannelNo >=100 && ChannelNo <= 140)))                       //5470~5725 MHZ
2298     //{
2299     //   Adapter->ZD80211HSetting.DFSEnable=TRUE;
2300     //}
2301     //else
2302     //{
2303     //   Adapter->ZD80211HSetting.DFSEnable=FALSE;
2304     //}
2305
2306     wd->sta.DFSEnable = mode;
2307     if (mode)
2308         wd->sta.capability[1] |= ZM_BIT_0;
2309     else
2310         wd->sta.capability[1] &= (~ZM_BIT_0);
2311
2312     return 0;
2313 }
2314
2315 u8_t zfiWlanSetDot11HTPCMode(zdev_t* dev, u8_t mode)
2316 {
2317     zmw_get_wlan_dev(dev);
2318
2319     // TODO : TPC Enable in 5150~5350 MHz and 5470~5725MHz.
2320     //if ( Adapter->ZD80211HSupport &&
2321     //   Adapter->CardSetting.NetworkTypeInUse == Ndis802_11OFDM5 &&
2322     //   ((ChannelNo == 36 || ChannelNo == 40 || ChannelNo == 44 || ChannelNo == 48) || //5150~5250 MHZ , Not Japan
2323     //    (ChannelNo >=52 && ChannelNo <= 64) ||                                //5250~5350 MHZ
2324     //    (ChannelNo >=100 && ChannelNo <= 140)))                       //5470~5725 MHZ
2325     //{
2326     //   Adapter->ZD80211HSetting.TPCEnable=TRUE;
2327     //}
2328     //else
2329     //{
2330     //   Adapter->ZD80211HSetting.TPCEnable=FALSE;
2331     //}
2332
2333     wd->sta.TPCEnable = mode;
2334     if (mode)
2335         wd->sta.capability[1] |= ZM_BIT_0;
2336     else
2337         wd->sta.capability[1] &= (~ZM_BIT_0);
2338
2339     return 0;
2340 }
2341
2342 u8_t zfiWlanSetAniMode(zdev_t* dev, u8_t mode)
2343 {
2344     zmw_get_wlan_dev(dev);
2345
2346     wd->aniEnable = mode;
2347     if (mode)
2348         zfHpAniAttach(dev);
2349
2350     return 0;
2351 }
2352
2353 #ifdef ZM_OS_LINUX_FUNC
2354 void zfiWlanShowTally(zdev_t* dev)
2355 {
2356     zmw_get_wlan_dev(dev);
2357
2358     zm_msg1_mm(ZM_LV_0, "Hw_UnderrunCnt    = ", wd->commTally.Hw_UnderrunCnt);
2359     zm_msg1_mm(ZM_LV_0, "Hw_TotalRxFrm     = ", wd->commTally.Hw_TotalRxFrm);
2360     zm_msg1_mm(ZM_LV_0, "Hw_CRC32Cnt       = ", wd->commTally.Hw_CRC32Cnt);
2361     zm_msg1_mm(ZM_LV_0, "Hw_CRC16Cnt       = ", wd->commTally.Hw_CRC16Cnt);
2362     zm_msg1_mm(ZM_LV_1, "Hw_DecrypErr_UNI  = ", wd->commTally.Hw_DecrypErr_UNI);
2363     zm_msg1_mm(ZM_LV_0, "Hw_RxFIFOOverrun  = ", wd->commTally.Hw_RxFIFOOverrun);
2364     zm_msg1_mm(ZM_LV_1, "Hw_DecrypErr_Mul  = ", wd->commTally.Hw_DecrypErr_Mul);
2365     zm_msg1_mm(ZM_LV_1, "Hw_RetryCnt       = ", wd->commTally.Hw_RetryCnt);
2366     zm_msg1_mm(ZM_LV_0, "Hw_TotalTxFrm     = ", wd->commTally.Hw_TotalTxFrm);
2367     zm_msg1_mm(ZM_LV_0, "Hw_RxTimeOut      = ", wd->commTally.Hw_RxTimeOut);
2368     zm_msg1_mm(ZM_LV_0, "Tx_MPDU           = ", wd->commTally.Tx_MPDU);
2369     zm_msg1_mm(ZM_LV_0, "BA_Fail           = ", wd->commTally.BA_Fail);
2370     zm_msg1_mm(ZM_LV_0, "Hw_Tx_AMPDU       = ", wd->commTally.Hw_Tx_AMPDU);
2371     zm_msg1_mm(ZM_LV_0, "Hw_Tx_MPDU        = ", wd->commTally.Hw_Tx_MPDU);
2372
2373     zm_msg1_mm(ZM_LV_1, "Hw_RxMPDU          = ", wd->commTally.Hw_RxMPDU);
2374     zm_msg1_mm(ZM_LV_1, "Hw_RxDropMPDU      = ", wd->commTally.Hw_RxDropMPDU);
2375     zm_msg1_mm(ZM_LV_1, "Hw_RxDelMPDU       = ", wd->commTally.Hw_RxDelMPDU);
2376     zm_msg1_mm(ZM_LV_1, "Hw_RxPhyMiscError  = ", wd->commTally.Hw_RxPhyMiscError);
2377     zm_msg1_mm(ZM_LV_1, "Hw_RxPhyXRError    = ", wd->commTally.Hw_RxPhyXRError);
2378     zm_msg1_mm(ZM_LV_1, "Hw_RxPhyOFDMError  = ", wd->commTally.Hw_RxPhyOFDMError);
2379     zm_msg1_mm(ZM_LV_1, "Hw_RxPhyCCKError   = ", wd->commTally.Hw_RxPhyCCKError);
2380     zm_msg1_mm(ZM_LV_1, "Hw_RxPhyHTError    = ", wd->commTally.Hw_RxPhyHTError);
2381     zm_msg1_mm(ZM_LV_1, "Hw_RxPhyTotalCount = ", wd->commTally.Hw_RxPhyTotalCount);
2382
2383     if (!((wd->commTally.Tx_MPDU == 0) && (wd->commTally.BA_Fail == 0)))
2384     {
2385         zm_debug_msg_p("BA Fail Ratio(%)  = ", wd->commTally.BA_Fail * 100,
2386                 (wd->commTally.BA_Fail + wd->commTally.Tx_MPDU));
2387     }
2388
2389     if (!((wd->commTally.Hw_Tx_MPDU == 0) && (wd->commTally.Hw_Tx_AMPDU == 0)))
2390     {
2391         zm_debug_msg_p("Avg Agg Number    = ",
2392                 wd->commTally.Hw_Tx_MPDU, wd->commTally.Hw_Tx_AMPDU);
2393     }
2394 }
2395 #endif
2396
2397 void zfiWlanSetMaxTxPower(zdev_t* dev, u8_t power2, u8_t power5)
2398 {
2399     zmw_get_wlan_dev(dev);
2400
2401     zmw_declare_for_critical_section();
2402
2403     zmw_enter_critical_section(dev);
2404     wd->maxTxPower2 = power2;
2405     wd->maxTxPower5 = power5;
2406     zmw_leave_critical_section(dev);
2407 }
2408
2409 void zfiWlanQueryMaxTxPower(zdev_t* dev, u8_t *power2, u8_t *power5)
2410 {
2411     zmw_get_wlan_dev(dev);
2412
2413     *power2 = wd->maxTxPower2;
2414     *power5 = wd->maxTxPower5;
2415 }
2416
2417 void zfiWlanSetConnectMode(zdev_t* dev, u8_t mode)
2418 {
2419     zmw_get_wlan_dev(dev);
2420
2421     zmw_declare_for_critical_section();
2422
2423     zmw_enter_critical_section(dev);
2424     wd->connectMode = mode;
2425     zmw_leave_critical_section(dev);
2426 }
2427
2428 void zfiWlanSetSupportMode(zdev_t* dev, u32_t mode)
2429 {
2430     zmw_get_wlan_dev(dev);
2431
2432     zmw_declare_for_critical_section();
2433
2434     zmw_enter_critical_section(dev);
2435     wd->supportMode = mode;
2436     zmw_leave_critical_section(dev);
2437 }
2438
2439 void zfiWlanSetAdhocMode(zdev_t* dev, u32_t mode)
2440 {
2441     zmw_get_wlan_dev(dev);
2442
2443     wd->ws.adhocMode = mode;
2444 }
2445
2446 u32_t zfiWlanQueryAdhocMode(zdev_t* dev, u8_t bWrapper)
2447 {
2448     u32_t adhocMode;
2449
2450     zmw_get_wlan_dev(dev);
2451
2452     if ( bWrapper )
2453     {
2454         adhocMode = wd->ws.adhocMode;
2455     }
2456     else
2457     {
2458         adhocMode = wd->wfc.bIbssGMode;
2459     }
2460
2461     return adhocMode;
2462 }
2463
2464
2465 u8_t zfiWlanSetCountryIsoName(zdev_t* dev, u8_t *countryIsoName, u8_t length)
2466 {
2467     u8_t buf[5];
2468     zmw_get_wlan_dev(dev);
2469
2470     if (length == 4)
2471     {
2472         buf[2] = wd->ws.countryIsoName[0] = countryIsoName[2];
2473         buf[3] = wd->ws.countryIsoName[1] = countryIsoName[1];
2474         buf[4] = wd->ws.countryIsoName[2] = countryIsoName[0];
2475     }
2476     else if (length == 3)
2477     {
2478         buf[2] = wd->ws.countryIsoName[0] = countryIsoName[1];
2479         buf[3] = wd->ws.countryIsoName[1] = countryIsoName[0];
2480         buf[4] = wd->ws.countryIsoName[2] = '\0';
2481     }
2482     else
2483     {
2484         return 1;
2485     }
2486
2487     return zfHpGetRegulationTablefromISO(dev, buf, length);
2488 }
2489
2490
2491 const char* zfiWlanQueryCountryIsoName(zdev_t* dev)
2492 {
2493     zmw_get_wlan_dev(dev);
2494
2495     return wd->ws.countryIsoName;
2496 }
2497
2498
2499
2500 void zfiWlanSetRegulatory(zdev_t* dev, u8_t CCS, u16_t Code, u8_t bfirstChannel)
2501 {
2502     zmw_get_wlan_dev(dev);
2503
2504     zmw_declare_for_critical_section();
2505
2506     if (CCS)
2507     {
2508         /* Reset Regulation Table by Country Code */
2509         zfHpGetRegulationTablefromCountry(dev, Code);
2510     }
2511     else
2512     {
2513         /* Reset Regulation Table by Region Code */
2514         zfHpGetRegulationTablefromRegionCode(dev, Code);
2515     }
2516
2517     if (bfirstChannel) {
2518         zmw_enter_critical_section(dev);
2519         wd->frequency = zfChGetFirstChannel(dev, NULL);
2520         zmw_leave_critical_section(dev);
2521         zfCoreSetFrequency(dev, wd->frequency);
2522     }
2523 }
2524
2525
2526 const char* zfiHpGetisoNamefromregionCode(zdev_t* dev, u16_t regionCode)
2527 {
2528     return zfHpGetisoNamefromregionCode(dev, regionCode);
2529 }
2530
2531 u16_t zfiWlanChannelToFrequency(zdev_t* dev, u8_t channel)
2532 {
2533     return zfChNumToFreq(dev, channel, 0);
2534 }
2535
2536 u8_t zfiWlanFrequencyToChannel(zdev_t* dev, u16_t freq)
2537 {
2538     u8_t is5GBand = 0;
2539
2540     return zfChFreqToNum(freq, &is5GBand);
2541 }
2542
2543 void zfiWlanDisableDfsChannel(zdev_t* dev, u8_t disableFlag)
2544 {
2545     zfHpDisableDfsChannel(dev, disableFlag);
2546     return;
2547 }
2548
2549 void zfiWlanSetLEDCtrlParam(zdev_t* dev, u8_t type, u8_t flag)
2550 {
2551     zmw_get_wlan_dev(dev);
2552
2553     zmw_declare_for_critical_section();
2554
2555     zmw_enter_critical_section(dev);
2556     wd->ledStruct.LEDCtrlType = type;
2557     wd->ledStruct.LEDCtrlFlagFromReg  = flag;
2558     zmw_leave_critical_section(dev);
2559 }
2560
2561 void zfiWlanEnableLeapConfig(zdev_t* dev, u8_t leapEnabled)
2562 {
2563     zmw_get_wlan_dev(dev);
2564
2565     wd->sta.leapEnabled = leapEnabled;
2566 }
2567
2568 u32_t zfiWlanQueryHwCapability(zdev_t* dev)
2569 {
2570     return zfHpCapability(dev);
2571 }
2572
2573 u32_t zfiWlanQueryReceivedPacket(zdev_t* dev)
2574 {
2575     zmw_get_wlan_dev(dev);
2576
2577     return wd->sta.ReceivedPktRatePerSecond;
2578 }
2579
2580 void zfiWlanCheckSWEncryption(zdev_t* dev)
2581 {
2582     zmw_get_wlan_dev(dev);
2583
2584     if (wd->sta.SWEncryptEnable != 0)
2585     {
2586         zfHpSWDecrypt(dev, 1);
2587     }
2588 }
2589
2590 u16_t zfiWlanQueryAllowChannels(zdev_t* dev, u16_t *channels)
2591 {
2592     u16_t ii;
2593     zmw_get_wlan_dev(dev);
2594
2595     for (ii = 0; ii < wd->regulationTable.allowChannelCnt; ii++)
2596     {
2597         channels[ii] = wd->regulationTable.allowChannel[ii].channel;
2598     }
2599
2600     return wd->regulationTable.allowChannelCnt;
2601 }
2602
2603 void zfiWlanSetDynamicSIFSParam(zdev_t* dev, u8_t val)
2604 {
2605     zmw_get_wlan_dev(dev);
2606
2607     wd->dynamicSIFSEnable = val;
2608
2609     zm_debug_msg1("wd->dynamicSIFSEnable = ", wd->dynamicSIFSEnable)
2610 }
2611
2612 u16_t zfiWlanGetMulticastAddressCount(zdev_t* dev)
2613 {
2614     zmw_get_wlan_dev(dev);
2615
2616     return wd->sta.multicastList.size;
2617 }
2618
2619 void zfiWlanGetMulticastList(zdev_t* dev, u8_t* pMCList)
2620 {
2621     struct zsMulticastAddr* pMacList = (struct zsMulticastAddr*) pMCList;
2622     u8_t i;
2623
2624     zmw_get_wlan_dev(dev);
2625
2626     for ( i=0; i<wd->sta.multicastList.size; i++ )
2627     {
2628         zfMemoryCopy(pMacList[i].addr, wd->sta.multicastList.macAddr[i].addr, 6);
2629     }
2630 }
2631
2632 void zfiWlanSetPacketFilter(zdev_t* dev, u32_t PacketFilter)
2633 {
2634     u8_t  bAllMulticast = 0;
2635     u32_t oldFilter;
2636
2637     zmw_get_wlan_dev(dev);
2638
2639     oldFilter = wd->sta.osRxFilter;
2640
2641     wd->sta.osRxFilter = PacketFilter;
2642
2643     if ((oldFilter & ZM_PACKET_TYPE_ALL_MULTICAST) !=
2644         (wd->sta.osRxFilter & ZM_PACKET_TYPE_ALL_MULTICAST))
2645     {
2646         if ( wd->sta.osRxFilter & ZM_PACKET_TYPE_ALL_MULTICAST )
2647             bAllMulticast = 1;
2648         zfHpSetMulticastList(dev, wd->sta.multicastList.size,
2649                              (u8_t*)wd->sta.multicastList.macAddr, bAllMulticast);
2650     }
2651 }
2652
2653 u8_t zfiCompareWithMulticastListAddress(zdev_t* dev, u16_t* dstMacAddr)
2654 {
2655     u8_t i;
2656     u8_t bIsInMCListAddr = 0;
2657
2658     zmw_get_wlan_dev(dev);
2659
2660     for ( i=0; i<wd->sta.multicastList.size; i++ )
2661     {
2662         if ( zfwMemoryIsEqual((u8_t*)dstMacAddr, (u8_t*)wd->sta.multicastList.macAddr[i].addr, 6) )
2663         {
2664             bIsInMCListAddr = 1;
2665             break;
2666         }
2667     }
2668
2669     return bIsInMCListAddr;
2670 }
2671
2672 void zfiWlanSetSafeModeEnabled(zdev_t* dev, u8_t safeMode)
2673 {
2674     zmw_get_wlan_dev(dev);
2675
2676     wd->sta.bSafeMode = safeMode;
2677
2678     if ( safeMode )
2679         zfStaEnableSWEncryption(dev, 1);
2680     else
2681         zfStaDisableSWEncryption(dev);
2682 }
2683
2684 void zfiWlanSetIBSSAdditionalIELength(zdev_t* dev, u32_t ibssAdditionalIESize, u8_t* ibssAdditionalIE)
2685 {
2686         zmw_get_wlan_dev(dev);
2687
2688         if ( ibssAdditionalIESize )
2689     {
2690             wd->sta.ibssAdditionalIESize = ibssAdditionalIESize;
2691         zfMemoryCopy(wd->sta.ibssAdditionalIE, ibssAdditionalIE, (u16_t)ibssAdditionalIESize);
2692     }
2693     else
2694         wd->sta.ibssAdditionalIESize = 0;
2695 }