SAFE public projects git trees. - safe/jmp/linux-2.6/blob - drivers/staging/otus/80211core/cmmsta.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 #include "cprecomp.h"
  18 #include "ratectrl.h"
  19 #include "../hal/hpreg.h"
  20
  21 /* TODO : change global variable to constant */
  22 u8_t   zgWpaRadiusOui[] = { 0x00, 0x50, 0xf2, 0x01 };
  23 u8_t   zgWpaAesOui[] = { 0x00, 0x50, 0xf2, 0x04 };
  24 u8_t   zgWpa2RadiusOui[] = { 0x00, 0x0f, 0xac, 0x01 };
  25 u8_t   zgWpa2AesOui[] = { 0x00, 0x0f, 0xac, 0x04 };
  26
  27 const u16_t zcCwTlb[16] = {   0,    1,    3,    7,   15,   31,   63,  127,
  28                             255,  511, 1023, 2047, 4095, 4095, 4095, 4095};
  29
  30 void zfStaStartConnectCb(zdev_t* dev);
  31
  32 /************************************************************************/
  33 /*                                                                      */
  34 /*    FUNCTION DESCRIPTION                  zfStaPutApIntoBlockingList  */
  35 /*      Put AP into blocking AP list.                                   */
  36 /*                                                                      */
  37 /*    INPUTS                                                            */
  38 /*      dev : device pointer                                            */
  39 /*      bssid : AP's BSSID                                              */
  40 /*      weight : weight of AP                                           */
  41 /*                                                                      */
  42 /*    OUTPUTS                                                           */
  43 /*      none                                                            */
  44 /*                                                                      */
  45 /*    AUTHOR                                                            */
  46 /*      Stephen Chen        Atheros Communications, INC.    2006.12     */
  47 /*                                                                      */
  48 /************************************************************************/
  49 void zfStaPutApIntoBlockingList(zdev_t* dev, u8_t* bssid, u8_t weight)
  50 {
  51     u16_t i, j;
  52     zmw_get_wlan_dev(dev);
  53     zmw_declare_for_critical_section();
  54
  55     if (weight > 0)
  56     {
  57         zmw_enter_critical_section(dev);
  58         /*Find same bssid entry first*/
  59         for (i=0; i<ZM_MAX_BLOCKING_AP_LIST_SIZE; i++)
  60         {
  61             for (j=0; j<6; j++)
  62             {
  63                 if(wd->sta.blockingApList[i].addr[j]!= bssid[j])
  64                 {
  65                     break;
  66                 }
  67             }
  68
  69             if(j==6)
  70             {
  71                 break;
  72             }
  73         }
  74         /*This bssid doesn't have old record.Find an empty entry*/
  75         if (i == ZM_MAX_BLOCKING_AP_LIST_SIZE)
  76         {
  77             for (i=0; i<ZM_MAX_BLOCKING_AP_LIST_SIZE; i++)
  78             {
  79                 if (wd->sta.blockingApList[i].weight == 0)
  80                 {
  81                     break;
  82                 }
  83             }
  84         }
  85
  86         /* If the list is full, pick one entry for replacement */
  87         if (i == ZM_MAX_BLOCKING_AP_LIST_SIZE)
  88         {
  89             i = bssid[5] & (ZM_MAX_BLOCKING_AP_LIST_SIZE-1);
  90         }
  91
  92         /* Update AP address and weight */
  93         for (j=0; j<6; j++)
  94         {
  95             wd->sta.blockingApList[i].addr[j] = bssid[j];
  96         }
  97
  98         wd->sta.blockingApList[i].weight = weight;
  99         zmw_leave_critical_section(dev);
 100     }
 101
 102     return;
 103 }
 104
 105
 106 /************************************************************************/
 107 /*                                                                      */
 108 /*    FUNCTION DESCRIPTION                  zfStaIsApInBlockingList     */
 109 /*      Is AP in blocking list.                                         */
 110 /*                                                                      */
 111 /*    INPUTS                                                            */
 112 /*      dev : device pointer                                            */
 113 /*      bssid : AP's BSSID                                              */
 114 /*                                                                      */
 115 /*    OUTPUTS                                                           */
 116 /*      TRUE : AP in blocking list                                      */
 117 /*      FALSE : AP not in blocking list                                 */
 118 /*                                                                      */
 119 /*    AUTHOR                                                            */
 120 /*      Stephen Chen        Atheros Communications, INC.    2006.12     */
 121 /*                                                                      */
 122 /************************************************************************/
 123 u16_t zfStaIsApInBlockingList(zdev_t* dev, u8_t* bssid)
 124 {
 125     u16_t i, j;
 126     zmw_get_wlan_dev(dev);
 127     //zmw_declare_for_critical_section();
 128
 129     //zmw_enter_critical_section(dev);
 130     for (i=0; i<ZM_MAX_BLOCKING_AP_LIST_SIZE; i++)
 131     {
 132         if (wd->sta.blockingApList[i].weight != 0)
 133         {
 134             for (j=0; j<6; j++)
 135             {
 136                 if (wd->sta.blockingApList[i].addr[j] != bssid[j])
 137                 {
 138                     break;
 139                 }
 140             }
 141             if (j == 6)
 142             {
 143                 //zmw_leave_critical_section(dev);
 144                 return TRUE;
 145             }
 146         }
 147     }
 148     //zmw_leave_critical_section(dev);
 149     return FALSE;
 150 }
 151
 152
 153 /************************************************************************/
 154 /*                                                                      */
 155 /*    FUNCTION DESCRIPTION                  zfStaRefreshBlockList       */
 156 /*      Is AP in blocking list.                                         */
 157 /*                                                                      */
 158 /*    INPUTS                                                            */
 159 /*      dev : device pointer                                            */
 160 /*      flushFlag : flush whole blocking list                           */
 161 /*                                                                      */
 162 /*    OUTPUTS                                                           */
 163 /*      none                                                            */
 164 /*                                                                      */
 165 /*    AUTHOR                                                            */
 166 /*      Stephen Chen        Atheros Communications, INC.    2006.12     */
 167 /*                                                                      */
 168 /************************************************************************/
 169 void zfStaRefreshBlockList(zdev_t* dev, u16_t flushFlag)
 170 {
 171     u16_t i;
 172     zmw_get_wlan_dev(dev);
 173     zmw_declare_for_critical_section();
 174
 175     zmw_enter_critical_section(dev);
 176     for (i=0; i<ZM_MAX_BLOCKING_AP_LIST_SIZE; i++)
 177     {
 178         if (wd->sta.blockingApList[i].weight != 0)
 179         {
 180             if (flushFlag != 0)
 181             {
 182                 wd->sta.blockingApList[i].weight = 0;
 183             }
 184             else
 185             {
 186                 wd->sta.blockingApList[i].weight--;
 187             }
 188         }
 189     }
 190     zmw_leave_critical_section(dev);
 191     return;
 192 }
 193
 194
 195 /************************************************************************/
 196 /*                                                                      */
 197 /*    FUNCTION DESCRIPTION                  zfStaConnectFail            */
 198 /*      Handle Connect failure.                                         */
 199 /*                                                                      */
 200 /*    INPUTS                                                            */
 201 /*      dev : device pointer                                            */
 202 /*      bssid : BSSID                                                   */
 203 /*      reason : reason of failure                                      */
 204 /*                                                                      */
 205 /*    OUTPUTS                                                           */
 206 /*      none                                                            */
 207 /*                                                                      */
 208 /*    AUTHOR                                                            */
 209 /*      Stephen Chen        Atheros Communications, INC.    2006.12     */
 210 /*                                                                      */
 211 /************************************************************************/
 212 void zfStaConnectFail(zdev_t* dev, u16_t reason, u16_t* bssid, u8_t weight)
 213 {
 214     zmw_get_wlan_dev(dev);
 215
 216     /* Change internal state */
 217     zfChangeAdapterState(dev, ZM_STA_STATE_DISCONNECT);
 218
 219     /* Improve WEP/TKIP performance with HT AP, detail information please look bug#32495 */
 220     //zfHpSetTTSIFSTime(dev, 0x8);
 221
 222     /* Notify wrapper of connection status changes */
 223     if (wd->zfcbConnectNotify != NULL)
 224     {
 225         wd->zfcbConnectNotify(dev, reason, bssid);
 226     }
 227
 228     /* Put AP into internal blocking list */
 229     zfStaPutApIntoBlockingList(dev, (u8_t *)bssid, weight);
 230
 231     /* Issue another SCAN */
 232     if ( wd->sta.bAutoReconnect )
 233     {
 234         zm_debug_msg0("Start internal scan...");
 235         zfScanMgrScanStop(dev, ZM_SCAN_MGR_SCAN_INTERNAL);
 236         zfScanMgrScanStart(dev, ZM_SCAN_MGR_SCAN_INTERNAL);
 237     }
 238 }
 239
 240 u8_t zfiWlanIBSSGetPeerStationsCount(zdev_t* dev)
 241 {
 242     zmw_get_wlan_dev(dev);
 243
 244     return wd->sta.oppositeCount;
 245 }
 246
 247 u8_t zfiWlanIBSSIteratePeerStations(zdev_t* dev, u8_t numToIterate, zfpIBSSIteratePeerStationCb callback, void *ctx)
 248 {
 249     u8_t oppositeCount;
 250     u8_t i;
 251     u8_t index = 0;
 252
 253     zmw_get_wlan_dev(dev);
 254
 255     zmw_declare_for_critical_section();
 256
 257     zmw_enter_critical_section(dev);
 258
 259     oppositeCount = wd->sta.oppositeCount;
 260     if ( oppositeCount > numToIterate )
 261     {
 262         oppositeCount = numToIterate;
 263     }
 264
 265     for(i=0; i < ZM_MAX_OPPOSITE_COUNT; i++)
 266     {
 267         if ( oppositeCount == 0 )
 268         {
 269             break;
 270         }
 271
 272         if ( wd->sta.oppositeInfo[i].valid == 0 )
 273         {
 274             continue;
 275         }
 276
 277         callback(dev, &wd->sta.oppositeInfo[i], ctx, index++);
 278         oppositeCount--;
 279
 280     }
 281
 282     zmw_leave_critical_section(dev);
 283
 284     return index;
 285 }
 286
 287
 288 s8_t zfStaFindFreeOpposite(zdev_t* dev, u16_t *sa, int *pFoundIdx)
 289 {
 290     int oppositeCount;
 291     int i;
 292
 293     zmw_get_wlan_dev(dev);
 294
 295     oppositeCount = wd->sta.oppositeCount;
 296
 297     for(i=0; i < ZM_MAX_OPPOSITE_COUNT; i++)
 298     {
 299         if ( oppositeCount == 0 )
 300         {
 301             break;
 302         }
 303
 304         if ( wd->sta.oppositeInfo[i].valid == 0 )
 305         {
 306             continue;
 307         }
 308
 309         oppositeCount--;
 310         if ( zfMemoryIsEqual((u8_t*) sa, wd->sta.oppositeInfo[i].macAddr, 6) )
 311         {
 312             //wd->sta.oppositeInfo[i].aliveCounter++;
 313             wd->sta.oppositeInfo[i].aliveCounter = ZM_IBSS_PEER_ALIVE_COUNTER;
 314
 315             /* it is already stored */
 316             return 1;
 317         }
 318     }
 319
 320     // Check if there's still space for new comer
 321     if ( wd->sta.oppositeCount == ZM_MAX_OPPOSITE_COUNT )
 322     {
 323         return -1;
 324     }
 325
 326     // Find an unused slot for new peer station
 327     for(i=0; i < ZM_MAX_OPPOSITE_COUNT; i++)
 328     {
 329         if ( wd->sta.oppositeInfo[i].valid == 0 )
 330         {
 331             break;
 332         }
 333     }
 334
 335     *pFoundIdx = i;
 336     return 0;
 337 }
 338
 339 s8_t zfStaFindOppositeByMACAddr(zdev_t* dev, u16_t *sa, u8_t *pFoundIdx)
 340 {
 341     u32_t oppositeCount;
 342     u32_t i;
 343
 344     zmw_get_wlan_dev(dev);
 345
 346     oppositeCount = wd->sta.oppositeCount;
 347
 348     for(i=0; i < ZM_MAX_OPPOSITE_COUNT; i++)
 349     {
 350         if ( oppositeCount == 0 )
 351         {
 352             break;
 353         }
 354
 355         if ( wd->sta.oppositeInfo[i].valid == 0 )
 356         {
 357             continue;
 358         }
 359
 360         oppositeCount--;
 361         if ( zfMemoryIsEqual((u8_t*) sa, wd->sta.oppositeInfo[i].macAddr, 6) )
 362         {
 363             *pFoundIdx = (u8_t)i;
 364
 365             return 0;
 366         }
 367     }
 368
 369     *pFoundIdx = 0;
 370     return 1;
 371 }
 372
 373 static void zfStaInitCommonOppositeInfo(zdev_t* dev, int i)
 374 {
 375     zmw_get_wlan_dev(dev);
 376
 377     /* set the default rate to the highest rate */
 378     wd->sta.oppositeInfo[i].valid = 1;
 379     wd->sta.oppositeInfo[i].aliveCounter = ZM_IBSS_PEER_ALIVE_COUNTER;
 380     wd->sta.oppositeCount++;
 381
 382 #ifdef ZM_ENABLE_IBSS_WPA2PSK
 383     /* Set parameters for new opposite peer station !!! */
 384     wd->sta.oppositeInfo[i].camIdx = 0xff;  // Not set key in this location
 385     wd->sta.oppositeInfo[i].pkInstalled = 0;
 386     wd->sta.oppositeInfo[i].wpaState = ZM_STA_WPA_STATE_INIT ;  // No encryption
 387 #endif
 388 }
 389
 390 int zfStaSetOppositeInfoFromBSSInfo(zdev_t* dev, struct zsBssInfo* pBssInfo)
 391 {
 392     int i;
 393     u8_t*  dst;
 394     u16_t  sa[3];
 395     int res;
 396     u32_t oneTxStreamCap;
 397
 398     zmw_get_wlan_dev(dev);
 399
 400     zfMemoryCopy((u8_t*) sa, pBssInfo->macaddr, 6);
 401
 402     res = zfStaFindFreeOpposite(dev, sa, &i);
 403     if ( res != 0 )
 404     {
 405         goto zlReturn;
 406     }
 407
 408     dst = wd->sta.oppositeInfo[i].macAddr;
 409     zfMemoryCopy(dst, (u8_t *)sa, 6);
 410
 411     oneTxStreamCap = (zfHpCapability(dev) & ZM_HP_CAP_11N_ONE_TX_STREAM);
 412
 413     if (pBssInfo->extSupportedRates[1] != 0)
 414     {
 415         /* TODO : Handle 11n */
 416         if (pBssInfo->frequency < 3000)
 417         {
 418             /* 2.4GHz */
 419             if (pBssInfo->EnableHT == 1)
 420                 zfRateCtrlInitCell(dev, &wd->sta.oppositeInfo[i].rcCell, (oneTxStreamCap!=0)?3:2, 1, pBssInfo->SG40);
 421             else
 422                 zfRateCtrlInitCell(dev, &wd->sta.oppositeInfo[i].rcCell, 1, 1, pBssInfo->SG40);
 423         }
 424         else
 425         {
 426             /* 5GHz */
 427             if (pBssInfo->EnableHT == 1)
 428                 zfRateCtrlInitCell(dev, &wd->sta.oppositeInfo[i].rcCell, (oneTxStreamCap!=0)?3:2, 0, pBssInfo->SG40);
 429             else
 430                 zfRateCtrlInitCell(dev, &wd->sta.oppositeInfo[i].rcCell, 1, 0, pBssInfo->SG40);
 431         }
 432     }
 433     else
 434     {
 435         /* TODO : Handle 11n */
 436         if (pBssInfo->frequency < 3000)
 437         {
 438             /* 2.4GHz */
 439             if (pBssInfo->EnableHT == 1)
 440                 zfRateCtrlInitCell(dev, &wd->sta.oppositeInfo[i].rcCell, (oneTxStreamCap!=0)?3:2, 1, pBssInfo->SG40);
 441             else
 442                 zfRateCtrlInitCell(dev, &wd->sta.oppositeInfo[i].rcCell, 0, 1, pBssInfo->SG40);
 443         }
 444         else
 445         {
 446             /* 5GHz */
 447             if (pBssInfo->EnableHT == 1)
 448                 zfRateCtrlInitCell(dev, &wd->sta.oppositeInfo[i].rcCell, (oneTxStreamCap!=0)?3:2, 0, pBssInfo->SG40);
 449             else
 450                 zfRateCtrlInitCell(dev, &wd->sta.oppositeInfo[i].rcCell, 1, 0, pBssInfo->SG40);
 451         }
 452     }
 453
 454
 455     zfStaInitCommonOppositeInfo(dev, i);
 456 zlReturn:
 457     return 0;
 458 }
 459
 460 int zfStaSetOppositeInfoFromRxBuf(zdev_t* dev, zbuf_t* buf)
 461 {
 462     int   i;
 463     u8_t*  dst;
 464     u16_t  sa[3];
 465     int res = 0;
 466     u16_t  offset;
 467     u8_t   bSupportExtRate;
 468     u32_t rtsctsRate = 0xffffffff; /* CTS:OFDM 6M, RTS:OFDM 6M */
 469     u32_t oneTxStreamCap;
 470
 471     zmw_get_wlan_dev(dev);
 472     zmw_declare_for_critical_section();
 473
 474     sa[0] = zmw_rx_buf_readh(dev, buf, ZM_WLAN_HEADER_A2_OFFSET);
 475     sa[1] = zmw_rx_buf_readh(dev, buf, ZM_WLAN_HEADER_A2_OFFSET+2);
 476     sa[2] = zmw_rx_buf_readh(dev, buf, ZM_WLAN_HEADER_A2_OFFSET+4);
 477
 478     zmw_enter_critical_section(dev);
 479
 480     res = zfStaFindFreeOpposite(dev, sa, &i);
 481     if ( res != 0 )
 482     {
 483         goto zlReturn;
 484     }
 485
 486     dst = wd->sta.oppositeInfo[i].macAddr;
 487     zfCopyFromRxBuffer(dev, buf, dst, ZM_WLAN_HEADER_A2_OFFSET, 6);
 488
 489     if ( (wd->sta.currentFrequency < 3000) && !(wd->supportMode & (ZM_WIRELESS_MODE_24_54|ZM_WIRELESS_MODE_24_N)) )
 490     {
 491         bSupportExtRate = 0;
 492     } else {
 493         bSupportExtRate = 1;
 494     }
 495
 496     if ( (bSupportExtRate == 1)
 497          && (wd->sta.currentFrequency < 3000)
 498          && (wd->wlanMode == ZM_MODE_IBSS)
 499          && (wd->wfc.bIbssGMode == 0) )
 500     {
 501         bSupportExtRate = 0;
 502     }
 503
 504     wd->sta.connection_11b = 0;
 505     oneTxStreamCap = (zfHpCapability(dev) & ZM_HP_CAP_11N_ONE_TX_STREAM);
 506
 507     if ( ((offset = zfFindElement(dev, buf, ZM_WLAN_EID_EXTENDED_RATE)) != 0xffff)
 508          && (bSupportExtRate == 1) )
 509     {
 510         /* TODO : Handle 11n */
 511         if (wd->sta.currentFrequency < 3000)
 512         {
 513             /* 2.4GHz */
 514             if (wd->sta.EnableHT == 1)
 515             {
 516                 //11ng
 517                 zfRateCtrlInitCell(dev, &wd->sta.oppositeInfo[i].rcCell, (oneTxStreamCap!=0)?3:2, 1, wd->sta.SG40);
 518             }
 519             else
 520             {
 521                 //11g
 522                 zfRateCtrlInitCell(dev, &wd->sta.oppositeInfo[i].rcCell, 1, 1, wd->sta.SG40);
 523             }
 524             rtsctsRate = 0x00001bb; /* CTS:CCK 1M, RTS:OFDM 6M */
 525         }
 526         else
 527         {
 528             /* 5GHz */
 529             if (wd->sta.EnableHT == 1)
 530             {
 531                 //11na
 532                 zfRateCtrlInitCell(dev, &wd->sta.oppositeInfo[i].rcCell, (oneTxStreamCap!=0)?3:2, 0, wd->sta.SG40);
 533             }
 534             else
 535             {
 536                 //11a
 537                 zfRateCtrlInitCell(dev, &wd->sta.oppositeInfo[i].rcCell, 1, 0, wd->sta.SG40);
 538             }
 539             rtsctsRate = 0x10b01bb; /* CTS:OFDM 6M, RTS:OFDM 6M */
 540         }
 541     }
 542     else
 543     {
 544         /* TODO : Handle 11n */
 545         if (wd->sta.currentFrequency < 3000)
 546         {
 547             /* 2.4GHz */
 548             if (wd->sta.EnableHT == 1)
 549             {
 550                 //11ng
 551                 zfRateCtrlInitCell(dev, &wd->sta.oppositeInfo[i].rcCell, (oneTxStreamCap!=0)?3:2, 1, wd->sta.SG40);
 552                 rtsctsRate = 0x00001bb; /* CTS:CCK 1M, RTS:OFDM 6M */
 553             }
 554             else
 555             {
 556                 //11b
 557                 zfRateCtrlInitCell(dev, &wd->sta.oppositeInfo[i].rcCell, 0, 1, wd->sta.SG40);
 558                 rtsctsRate = 0x0; /* CTS:CCK 1M, RTS:CCK 1M */
 559                 wd->sta.connection_11b = 1;
 560             }
 561         }
 562         else
 563         {
 564             /* 5GHz */
 565             if (wd->sta.EnableHT == 1)
 566             {
 567                 //11na
 568                 zfRateCtrlInitCell(dev, &wd->sta.oppositeInfo[i].rcCell, (oneTxStreamCap!=0)?3:2, 0, wd->sta.SG40);
 569             }
 570             else
 571             {
 572                 //11a
 573                 zfRateCtrlInitCell(dev, &wd->sta.oppositeInfo[i].rcCell, 1, 0, wd->sta.SG40);
 574             }
 575             rtsctsRate = 0x10b01bb; /* CTS:OFDM 6M, RTS:OFDM 6M */
 576         }
 577     }
 578
 579     zfStaInitCommonOppositeInfo(dev, i);
 580
 581 zlReturn:
 582     zmw_leave_critical_section(dev);
 583
 584     if (rtsctsRate != 0xffffffff)
 585     {
 586         zfHpSetRTSCTSRate(dev, rtsctsRate);
 587     }
 588     return res;
 589 }
 590
 591 void zfStaProtErpMonitor(zdev_t* dev, zbuf_t* buf)
 592 {
 593     u16_t   offset;
 594     u8_t    erp;
 595     u8_t    bssid[6];
 596
 597     zmw_get_wlan_dev(dev);
 598
 599     if ( (wd->wlanMode == ZM_MODE_INFRASTRUCTURE)&&(zfStaIsConnected(dev)) )
 600     {
 601         ZM_MAC_WORD_TO_BYTE(wd->sta.bssid, bssid);
 602
 603         if (zfRxBufferEqualToStr(dev, buf, bssid, ZM_WLAN_HEADER_A2_OFFSET, 6))
 604         {
 605             if ( (offset=zfFindElement(dev, buf, ZM_WLAN_EID_ERP)) != 0xffff )
 606             {
 607                 erp = zmw_rx_buf_readb(dev, buf, offset+2);
 608
 609                 if ( erp & ZM_BIT_1 )
 610                 {
 611                     //zm_debug_msg0("protection mode on");
 612                     if (wd->sta.bProtectionMode == FALSE)
 613                     {
 614                         wd->sta.bProtectionMode = TRUE;
 615                         zfHpSetSlotTime(dev, 0);
 616                     }
 617                 }
 618                 else
 619                 {
 620                     //zm_debug_msg0("protection mode off");
 621                     if (wd->sta.bProtectionMode == TRUE)
 622                     {
 623                         wd->sta.bProtectionMode = FALSE;
 624                         zfHpSetSlotTime(dev, 1);
 625                     }
 626                 }
 627             }
 628         }
 629                 //Check the existence of Non-N AP
 630                 //Follow the check the "pBssInfo->EnableHT"
 631                         if ((offset = zfFindElement(dev, buf, ZM_WLAN_EID_HT_CAPABILITY)) != 0xffff)
 632                         {}
 633                         else if ((offset = zfFindElement(dev, buf, ZM_WLAN_PREN2_EID_HTCAPABILITY)) != 0xffff)
 634                         {}
 635                         else
 636                         {wd->sta.NonNAPcount++;}
 637     }
 638 }
 639
 640 void zfStaUpdateWmeParameter(zdev_t* dev, zbuf_t* buf)
 641 {
 642     u16_t   tmp;
 643     u16_t   aifs[5];
 644     u16_t   cwmin[5];
 645     u16_t   cwmax[5];
 646     u16_t   txop[5];
 647     u8_t    acm;
 648     u8_t    ac;
 649     u16_t   len;
 650     u16_t   i;
 651         u16_t   offset;
 652     u8_t    rxWmeParameterSetCount;
 653
 654     zmw_get_wlan_dev(dev);
 655
 656     /* Update if WME parameter set count is changed */
 657     /* If connect to WME AP */
 658     if (wd->sta.wmeConnected != 0)
 659     {
 660         /* Find WME parameter element */
 661         if ((offset = zfFindWifiElement(dev, buf, 2, 1)) != 0xffff)
 662         {
 663             if ((len = zmw_rx_buf_readb(dev, buf, offset+1)) >= 7)
 664             {
 665                 rxWmeParameterSetCount=zmw_rx_buf_readb(dev, buf, offset+8);
 666                 if (rxWmeParameterSetCount != wd->sta.wmeParameterSetCount)
 667                 {
 668                     zm_msg0_mm(ZM_LV_0, "wmeParameterSetCount changed!");
 669                     wd->sta.wmeParameterSetCount = rxWmeParameterSetCount;
 670                     /* retrieve WME parameter and update TxQ parameters */
 671                     acm = 0xf;
 672                     for (i=0; i<4; i++)
 673                     {
 674                         if (len >= (8+(i*4)+4))
 675                         {
 676                             tmp=zmw_rx_buf_readb(dev, buf, offset+10+i*4);
 677                             ac = (tmp >> 5) & 0x3;
 678                             if ((tmp & 0x10) == 0)
 679                             {
 680                                 acm &= (~(1<<ac));
 681                             }
 682                             aifs[ac] = ((tmp & 0xf) * 9) + 10;
 683                             tmp=zmw_rx_buf_readb(dev, buf, offset+11+i*4);
 684                             /* Convert to 2^n */
 685                             cwmin[ac] = zcCwTlb[(tmp & 0xf)];
 686                             cwmax[ac] = zcCwTlb[(tmp >> 4)];
 687                             txop[ac]=zmw_rx_buf_readh(dev, buf,
 688                                     offset+12+i*4);
 689                         }
 690                     }
 691
 692                     if ((acm & 0x4) != 0)
 693                     {
 694                         cwmin[2] = cwmin[0];
 695                         cwmax[2] = cwmax[0];
 696                         aifs[2] = aifs[0];
 697                         txop[2] = txop[0];
 698                     }
 699                     if ((acm & 0x8) != 0)
 700                     {
 701                         cwmin[3] = cwmin[2];
 702                         cwmax[3] = cwmax[2];
 703                         aifs[3] = aifs[2];
 704                         txop[3] = txop[2];
 705                     }
 706                     cwmin[4] = 3;
 707                     cwmax[4] = 7;
 708                     aifs[4] = 28;
 709
 710                     if ((cwmin[2]+aifs[2]) > ((cwmin[0]+aifs[0])+1))
 711                     {
 712                         wd->sta.ac0PriorityHigherThanAc2 = 1;
 713                     }
 714                     else
 715                     {
 716                         wd->sta.ac0PriorityHigherThanAc2 = 0;
 717                     }
 718                     zfHpUpdateQosParameter(dev, cwmin, cwmax, aifs, txop);
 719                 }
 720             }
 721         }
 722     } //if (wd->sta.wmeConnected != 0)
 723 }
 724 /* process 802.11h Dynamic Frequency Selection */
 725 void zfStaUpdateDot11HDFS(zdev_t* dev, zbuf_t* buf)
 726 {
 727     //u8_t    length, channel, is5G;
 728     u16_t   offset;
 729
 730     zmw_get_wlan_dev(dev);
 731
 732     /*
 733     Channel Switch Announcement Element Format
 734     +------+----------+------+-------------------+------------------+--------------------+
 735     |Format|Element ID|Length|Channel Switch Mode|New Channel Number|Channel Switch Count|
 736     +------+----------+------+-------------------+------------------+--------------------+
 737     |Bytes |   1      |  1   |       1           |       1          |          1         |
 738     +------+----------+------+-------------------+------------------+--------------------+
 739     |Value |   37     |  3   |       0 or 1      |unsigned integer  |unsigned integer    |
 740     +------+----------+------+-------------------+------------------+--------------------+
 741     */
 742
 743     /* get EID(Channel Switch Announcement) */
 744     if ( (offset = zfFindElement(dev, buf, ZM_WLAN_EID_CHANNEL_SWITCH_ANNOUNCE)) == 0xffff )
 745     {
 746         //zm_debug_msg0("EID(Channel Switch Announcement) not found");
 747         return;
 748     }
 749     else if ( zmw_rx_buf_readb(dev, buf, offset+1) == 0x3 )
 750     {
 751         zm_debug_msg0("EID(Channel Switch Announcement) found");
 752
 753         //length = zmw_rx_buf_readb(dev, buf, offset+1);
 754         //zfCopyFromRxBuffer(dev, buf, pBssInfo->supportedRates, offset, length+2);
 755
 756         //Chanell Switch Mode set to 1, driver should disable transmit immediate
 757         //we do this by poll CCA high
 758         if (zmw_rx_buf_readb(dev, buf, offset+2) == 0x1 )
 759         {
 760                 //use ZM_OID_INTERNAL_WRITE,ZM_CMD_RESET to notice firmware flush quene and stop dma,
 761                 //then restart rx dma but not tx dma
 762                 if (wd->sta.DFSDisableTx != TRUE)
 763                 {
 764                 /* TODO : zfHpResetTxRx would cause Rx hang */
 765                 //zfHpResetTxRx(dev);
 766                 wd->sta.DFSDisableTx = TRUE;
 767                 /* Trgger Rx DMA */
 768                 zfHpStartRecv(dev);
 769             }
 770                 //Adapter->ZD80211HSetting.DisableTxBy80211H=TRUE;
 771                 //AcquireCtrOfPhyReg(Adapter);
 772                 //ZD1205_WRITE_REGISTER(Adapter,CR24, 0x0);
 773                 //ReleaseDoNotSleep(Adapter);
 774         }
 775
 776         if (zmw_rx_buf_readb(dev, buf, offset+4) <= 0x2 )
 777         {
 778                 //Channel Switch
 779                 //if Channel Switch Count = 0 , STA should change channel immediately.
 780                 //if Channel Switch Count > 0 , STA should change channel after TBTT*count
 781                 //But it won't be accurate to let driver calculate TBTT*count, and the value of
 782                 //Channel Switch Count will decrease by one each when continue receving beacon
 783                 //So we change channel here when we receive count <=2.
 784
 785             zfHpDeleteAllowChannel(dev, wd->sta.currentFrequency);
 786                 wd->frequency = zfChNumToFreq(dev, zmw_rx_buf_readb(dev, buf, offset+3), 0);
 787                 //zfHpAddAllowChannel(dev, wd->frequency);
 788                 zm_debug_msg1("CWY - jump to frequency = ", wd->frequency);
 789                 zfCoreSetFrequency(dev, wd->frequency);
 790                 wd->sta.DFSDisableTx = FALSE;
 791             /* Increase rxBeaconCount to prevent beacon lost */
 792             if (zfStaIsConnected(dev))
 793             {
 794                 wd->sta.rxBeaconCount = 1 << 6; // 2 times of check would pass
 795             }
 796                 //start tx dma to transmit packet
 797
 798                 //if (zmw_rx_buf_readb(dev, buf, offset+3) != wd->frequency)
 799                 //{
 800                 //      //ZDDbgPrint(("Radar Detect by AP\n"));
 801                 //      zfCoreSetFrequency();
 802                 //      ProcessRadarDetectEvent(Adapter);
 803                 //      Set_RF_Channel(Adapter, SwRfd->Rfd->RxBuffer[index+3], (UCHAR)Adapter->RF_Mode, 1);
 804                 //      Adapter->CardSetting.Channel = SwRfd->Rfd->RxBuffer[index+3];
 805                 //      Adapter->SaveChannel = Adapter->CardSetting.Channel;
 806                 //      Adapter->UtilityChannel = Adapter->CardSetting.Channel;
 807                 //}
 808         }
 809     }
 810
 811 }
 812 /* TODO : process 802.11h Transmission Power Control */
 813 void zfStaUpdateDot11HTPC(zdev_t* dev, zbuf_t* buf)
 814 {
 815 }
 816
 817 /* IBSS power-saving mode */
 818 void zfStaIbssPSCheckState(zdev_t* dev, zbuf_t* buf)
 819 {
 820     u8_t   i, frameCtrl;
 821
 822     zmw_get_wlan_dev(dev);
 823
 824     if ( !zfStaIsConnected(dev) )
 825     {
 826         return;
 827     }
 828
 829     if ( wd->wlanMode != ZM_MODE_IBSS )
 830     {
 831         return ;
 832     }
 833
 834     /* check BSSID */
 835     if ( !zfRxBufferEqualToStr(dev, buf, (u8_t*) wd->sta.bssid,
 836                                ZM_WLAN_HEADER_A3_OFFSET, 6) )
 837     {
 838         return;
 839     }
 840
 841     frameCtrl = zmw_rx_buf_readb(dev, buf, 1);
 842
 843     /* check power management bit */
 844     if ( frameCtrl & ZM_BIT_4 )
 845     {
 846         for(i=1; i<ZM_MAX_PS_STA; i++)
 847         {
 848             if ( !wd->sta.staPSList.entity[i].bUsed )
 849             {
 850                 continue;
 851             }
 852
 853             /* check source address */
 854             if ( zfRxBufferEqualToStr(dev, buf,
 855                                       wd->sta.staPSList.entity[i].macAddr,
 856                                       ZM_WLAN_HEADER_A2_OFFSET, 6) )
 857             {
 858                 return;
 859             }
 860         }
 861
 862         for(i=1; i<ZM_MAX_PS_STA; i++)
 863         {
 864             if ( !wd->sta.staPSList.entity[i].bUsed )
 865             {
 866                 wd->sta.staPSList.entity[i].bUsed = TRUE;
 867                 wd->sta.staPSList.entity[i].bDataQueued = FALSE;
 868                 break;
 869             }
 870         }
 871
 872         if ( i == ZM_MAX_PS_STA )
 873         {
 874             /* STA list is full */
 875             return;
 876         }
 877
 878         zfCopyFromRxBuffer(dev, buf, wd->sta.staPSList.entity[i].macAddr,
 879                            ZM_WLAN_HEADER_A2_OFFSET, 6);
 880
 881         if ( wd->sta.staPSList.count == 0 )
 882         {
 883             // enable ATIM window
 884             //zfEnableAtimWindow(dev);
 885         }
 886
 887         wd->sta.staPSList.count++;
 888     }
 889     else if ( wd->sta.staPSList.count )
 890     {
 891         for(i=1; i<ZM_MAX_PS_STA; i++)
 892         {
 893             if ( wd->sta.staPSList.entity[i].bUsed )
 894             {
 895                 if ( zfRxBufferEqualToStr(dev, buf,
 896                                           wd->sta.staPSList.entity[i].macAddr,
 897                                           ZM_WLAN_HEADER_A2_OFFSET, 6) )
 898                 {
 899                     wd->sta.staPSList.entity[i].bUsed = FALSE;
 900                     wd->sta.staPSList.count--;
 901
 902                     if ( wd->sta.staPSList.entity[i].bDataQueued )
 903                     {
 904                         /* send queued data */
 905                     }
 906                 }
 907             }
 908         }
 909
 910         if ( wd->sta.staPSList.count == 0 )
 911         {
 912             /* disable ATIM window */
 913             //zfDisableAtimWindow(dev);
 914         }
 915
 916     }
 917 }
 918
 919 /* IBSS power-saving mode */
 920 u8_t zfStaIbssPSQueueData(zdev_t* dev, zbuf_t* buf)
 921 {
 922     u8_t   i;
 923     u16_t  da[3];
 924
 925     zmw_get_wlan_dev(dev);
 926
 927     if ( !zfStaIsConnected(dev) )
 928     {
 929         return 0;
 930     }
 931
 932     if ( wd->wlanMode != ZM_MODE_IBSS )
 933     {
 934         return 0;
 935     }
 936
 937     if ( wd->sta.staPSList.count == 0 && wd->sta.powerSaveMode <= ZM_STA_PS_NONE )
 938     {
 939         return 0;
 940     }
 941
 942     /* DA */
 943 #ifdef ZM_ENABLE_NATIVE_WIFI
 944     da[0] = zmw_tx_buf_readh(dev, buf, ZM_WLAN_HEADER_A1_OFFSET);
 945     da[1] = zmw_tx_buf_readh(dev, buf, ZM_WLAN_HEADER_A1_OFFSET + 2);
 946     da[2] = zmw_tx_buf_readh(dev, buf, ZM_WLAN_HEADER_A1_OFFSET + 4);
 947 #else
 948     da[0] = zmw_tx_buf_readh(dev, buf, 0);
 949     da[1] = zmw_tx_buf_readh(dev, buf, 2);
 950     da[2] = zmw_tx_buf_readh(dev, buf, 4);
 951 #endif
 952
 953     if ( ZM_IS_MULTICAST_OR_BROADCAST(da) )
 954     {
 955         wd->sta.staPSList.entity[0].bDataQueued = TRUE;
 956         wd->sta.ibssPSDataQueue[wd->sta.ibssPSDataCount++] = buf;
 957         return 1;
 958     }
 959
 960     // Unicast packet...
 961
 962     for(i=1; i<ZM_MAX_PS_STA; i++)
 963     {
 964         if ( zfMemoryIsEqual(wd->sta.staPSList.entity[i].macAddr,
 965                              (u8_t*) da, 6) )
 966         {
 967             wd->sta.staPSList.entity[i].bDataQueued = TRUE;
 968             wd->sta.ibssPSDataQueue[wd->sta.ibssPSDataCount++] = buf;
 969
 970             return 1;
 971         }
 972     }
 973
 974 #if 0
 975     if ( wd->sta.powerSaveMode > ZM_STA_PS_NONE )
 976     {
 977         wd->sta.staPSDataQueue[wd->sta.staPSDataCount++] = buf;
 978
 979         return 1;
 980     }
 981 #endif
 982
 983     return 0;
 984 }
 985
 986 /* IBSS power-saving mode */
 987 void zfStaIbssPSSend(zdev_t* dev)
 988 {
 989     u8_t   i;
 990     u16_t  bcastAddr[3] = {0xffff, 0xffff, 0xffff};
 991
 992     zmw_get_wlan_dev(dev);
 993
 994     if ( !zfStaIsConnected(dev) )
 995     {
 996         return ;
 997     }
 998
 999     if ( wd->wlanMode != ZM_MODE_IBSS )
1000     {
1001         return ;
1002     }
1003
1004     for(i=0; i<ZM_MAX_PS_STA; i++)
1005     {
1006         if ( wd->sta.staPSList.entity[i].bDataQueued )
1007         {
1008             if ( i == 0 )
1009             {
1010                 zfSendMmFrame(dev, ZM_WLAN_FRAME_TYPE_ATIM,
1011                               bcastAddr,
1012                               0, 0, 0);
1013             }
1014             else if ( wd->sta.staPSList.entity[i].bUsed )
1015             {
1016                 // Send ATIM to prevent the peer to go to sleep
1017                 zfSendMmFrame(dev, ZM_WLAN_FRAME_TYPE_ATIM,
1018                               (u16_t*) wd->sta.staPSList.entity[i].macAddr,
1019                               0, 0, 0);
1020             }
1021
1022             wd->sta.staPSList.entity[i].bDataQueued = FALSE;
1023         }
1024     }
1025
1026     for(i=0; i<wd->sta.ibssPSDataCount; i++)
1027     {
1028         zfTxSendEth(dev, wd->sta.ibssPSDataQueue[i], 0,
1029                     ZM_EXTERNAL_ALLOC_BUF, 0);
1030     }
1031
1032     wd->sta.ibssPrevPSDataCount = wd->sta.ibssPSDataCount;
1033     wd->sta.ibssPSDataCount = 0;
1034 }
1035
1036
1037 void zfStaReconnect(zdev_t* dev)
1038 {
1039     zmw_get_wlan_dev(dev);
1040     zmw_declare_for_critical_section();
1041
1042     if ( wd->wlanMode != ZM_MODE_INFRASTRUCTURE &&
1043          wd->wlanMode != ZM_MODE_IBSS )
1044     {
1045         return;
1046     }
1047
1048     if ( (zfStaIsConnected(dev))||(zfStaIsConnecting(dev)) )
1049     {
1050         return;
1051     }
1052
1053     if ( wd->sta.bChannelScan )
1054     {
1055         return;
1056     }
1057
1058     /* Recover zero SSID length  */
1059     if ( (wd->wlanMode == ZM_MODE_INFRASTRUCTURE) && (wd->ws.ssidLen == 0))
1060     {
1061         zm_debug_msg0("zfStaReconnect: NOT Support!! Set SSID to any BSS");
1062         /* ANY BSS */
1063         zmw_enter_critical_section(dev);
1064         wd->sta.ssid[0] = 0;
1065         wd->sta.ssidLen = 0;
1066         zmw_leave_critical_section(dev);
1067     }
1068
1069     // RAY: To ensure no TX pending before re-connecting
1070     zfFlushVtxq(dev);
1071     zfWlanEnable(dev);
1072     zfScanMgrScanAck(dev);
1073 }
1074
1075 void zfStaTimer100ms(zdev_t* dev)
1076 {
1077     zmw_get_wlan_dev(dev);
1078
1079     if ( (wd->tick % 10) == 0 )
1080     {
1081         zfPushVtxq(dev);
1082 //        zfPowerSavingMgrMain(dev);
1083     }
1084 }
1085
1086
1087 void zfStaCheckRxBeacon(zdev_t* dev)
1088 {
1089     zmw_get_wlan_dev(dev);
1090
1091     if (( wd->wlanMode == ZM_MODE_INFRASTRUCTURE ) && (zfStaIsConnected(dev)))
1092     {
1093         if (wd->beaconInterval == 0)
1094         {
1095             wd->beaconInterval = 100;
1096         }
1097         if ( (wd->tick % ((wd->beaconInterval * 10) / ZM_MS_PER_TICK)) == 0 )
1098         {
1099             /* Check rxBeaconCount */
1100             if (wd->sta.rxBeaconCount == 0)
1101             {
1102                 if (wd->sta.beaconMissState == 1)
1103                 {
1104                 /*notify AP that we left*/
1105                 zfSendMmFrame(dev, ZM_WLAN_FRAME_TYPE_DEAUTH, wd->sta.bssid, 3, 0, 0);
1106                 /* Beacon Lost */
1107                 zfStaConnectFail(dev, ZM_STATUS_MEDIA_DISCONNECT_BEACON_MISS,
1108                         wd->sta.bssid, 0);
1109                 }
1110                 else
1111                 {
1112                     wd->sta.beaconMissState = 1;
1113                     /* Reset channel */
1114                     zfCoreSetFrequencyExV2(dev, wd->frequency, wd->BandWidth40,
1115                             wd->ExtOffset, NULL, 1);
1116                 }
1117             }
1118             else
1119             {
1120                 wd->sta.beaconMissState = 0;
1121             }
1122             wd->sta.rxBeaconCount = 0;
1123         }
1124     }
1125 }
1126
1127
1128
1129 void zfStaCheckConnectTimeout(zdev_t* dev)
1130 {
1131     zmw_get_wlan_dev(dev);
1132     zmw_declare_for_critical_section();
1133
1134     if ( wd->wlanMode != ZM_MODE_INFRASTRUCTURE )
1135     {
1136         return;
1137     }
1138
1139     if ( !zfStaIsConnecting(dev) )
1140     {
1141         return;
1142     }
1143
1144     zmw_enter_critical_section(dev);
1145     if ( (wd->sta.connectState == ZM_STA_CONN_STATE_AUTH_OPEN)||
1146          (wd->sta.connectState == ZM_STA_CONN_STATE_AUTH_SHARE_1)||
1147          (wd->sta.connectState == ZM_STA_CONN_STATE_AUTH_SHARE_2)||
1148          (wd->sta.connectState == ZM_STA_CONN_STATE_ASSOCIATE) )
1149     {
1150         if ( (wd->tick - wd->sta.connectTimer) > ZM_INTERVAL_CONNECT_TIMEOUT )
1151         {
1152             if ( wd->sta.connectByReasso )
1153             {
1154                 wd->sta.failCntOfReasso++;
1155                 if ( wd->sta.failCntOfReasso > 2 )
1156                 {
1157                     wd->sta.connectByReasso = FALSE;
1158                 }
1159             }
1160
1161             wd->sta.connectState = ZM_STA_CONN_STATE_NONE;
1162             zm_debug_msg1("connect timeout, state = ", wd->sta.connectState);
1163             //zfiWlanDisable(dev);
1164             goto failed;
1165         }
1166     }
1167
1168     zmw_leave_critical_section(dev);
1169     return;
1170
1171 failed:
1172     zmw_leave_critical_section(dev);
1173     if(wd->sta.authMode == ZM_AUTH_MODE_AUTO)
1174         { // Fix some AP not send authentication failed message to sta and lead to connect timeout !
1175             wd->sta.connectTimeoutCount++;
1176         }
1177     zfStaConnectFail(dev, ZM_STATUS_MEDIA_DISCONNECT_TIMEOUT, wd->sta.bssid, 2);
1178     return;
1179 }
1180
1181 void zfMmStaTimeTick(zdev_t* dev)
1182 {
1183     zmw_get_wlan_dev(dev);
1184
1185     /* airopeek */
1186     if (wd->wlanMode != ZM_MODE_AP && !wd->swSniffer)
1187     {
1188         if ( wd->tick & 1 )
1189         {
1190             zfTimerCheckAndHandle(dev);
1191         }
1192
1193         zfStaCheckRxBeacon(dev);
1194         zfStaTimer100ms(dev);
1195         zfStaCheckConnectTimeout(dev);
1196         zfPowerSavingMgrMain(dev);
1197     }
1198
1199 #ifdef ZM_ENABLE_AGGREGATION
1200     /*
1201      * add by honda
1202      */
1203     zfAggScanAndClear(dev, wd->tick);
1204 #endif
1205 }
1206
1207 void zfStaSendBeacon(zdev_t* dev)
1208 {
1209     zbuf_t* buf;
1210     u16_t offset, seq;
1211
1212     zmw_get_wlan_dev(dev);
1213
1214     zmw_declare_for_critical_section();
1215
1216     //zm_debug_msg0("\n");
1217
1218     /* TBD : Maximum size of beacon */
1219     if ((buf = zfwBufAllocate(dev, 1024)) == NULL)
1220     {
1221         zm_debug_msg0("Allocate beacon buffer failed");
1222         return;
1223     }
1224
1225     offset = 0;
1226     /* wlan header */
1227     /* Frame control */
1228     zmw_tx_buf_writeh(dev, buf, offset, 0x0080);
1229     offset+=2;
1230     /* Duration */
1231     zmw_tx_buf_writeh(dev, buf, offset, 0x0000);
1232     offset+=2;
1233     /* Address 1 */
1234     zmw_tx_buf_writeh(dev, buf, offset, 0xffff);
1235     offset+=2;
1236     zmw_tx_buf_writeh(dev, buf, offset, 0xffff);
1237     offset+=2;
1238     zmw_tx_buf_writeh(dev, buf, offset, 0xffff);
1239     offset+=2;
1240     /* Address 2 */
1241     zmw_tx_buf_writeh(dev, buf, offset, wd->macAddr[0]);
1242     offset+=2;
1243     zmw_tx_buf_writeh(dev, buf, offset, wd->macAddr[1]);
1244     offset+=2;
1245     zmw_tx_buf_writeh(dev, buf, offset, wd->macAddr[2]);
1246     offset+=2;
1247     /* Address 3 */
1248     zmw_tx_buf_writeh(dev, buf, offset, wd->sta.bssid[0]);
1249     offset+=2;
1250     zmw_tx_buf_writeh(dev, buf, offset, wd->sta.bssid[1]);
1251     offset+=2;
1252     zmw_tx_buf_writeh(dev, buf, offset, wd->sta.bssid[2]);
1253     offset+=2;
1254
1255     /* Sequence number */
1256     zmw_enter_critical_section(dev);
1257     seq = ((wd->mmseq++)<<4);
1258     zmw_leave_critical_section(dev);
1259     zmw_tx_buf_writeh(dev, buf, offset, seq);
1260     offset+=2;
1261
1262     /* 24-31 Time Stamp : hardware will fill this field */
1263     offset+=8;
1264
1265     /* Beacon Interval */
1266     zmw_tx_buf_writeh(dev, buf, offset, wd->beaconInterval);
1267     offset+=2;
1268
1269     /* Capability */
1270     zmw_tx_buf_writeb(dev, buf, offset++, wd->sta.capability[0]);
1271     zmw_tx_buf_writeb(dev, buf, offset++, wd->sta.capability[1]);
1272
1273     /* SSID */
1274     offset = zfStaAddIeSsid(dev, buf, offset);
1275
1276     if(wd->frequency <= ZM_CH_G_14)  // 2.4 GHz  b+g
1277     {
1278
1279         /* Support Rate */
1280         offset = zfMmAddIeSupportRate(dev, buf, offset,
1281                                                 ZM_WLAN_EID_SUPPORT_RATE, ZM_RATE_SET_CCK);
1282
1283         /* DS parameter set */
1284         offset = zfMmAddIeDs(dev, buf, offset);
1285
1286         offset = zfStaAddIeIbss(dev, buf, offset);
1287
1288         if( wd->wfc.bIbssGMode
1289             && (wd->supportMode & (ZM_WIRELESS_MODE_24_54|ZM_WIRELESS_MODE_24_N)) )    // Only accompany with enabling a mode .
1290         {
1291             /* ERP Information */
1292             wd->erpElement = 0;
1293             offset = zfMmAddIeErp(dev, buf, offset);
1294         }
1295
1296         /* TODO : country information */
1297         /* RSN */
1298         if ( wd->sta.authMode == ZM_AUTH_MODE_WPA2PSK )
1299         {
1300             offset = zfwStaAddIeWpaRsn(dev, buf, offset, ZM_WLAN_FRAME_TYPE_AUTH);
1301         }
1302
1303         if( wd->wfc.bIbssGMode
1304             && (wd->supportMode & (ZM_WIRELESS_MODE_24_54|ZM_WIRELESS_MODE_24_N)) )    // Only accompany with enabling a mode .
1305         {
1306             /* Enable G Mode */
1307             /* Extended Supported Rates */
1308             offset = zfMmAddIeSupportRate(dev, buf, offset,
1309                                                     ZM_WLAN_EID_EXTENDED_RATE, ZM_RATE_SET_OFDM);
1310             }
1311     }
1312     else    // 5GHz a
1313     {
1314         /* Support Rate a Mode */
1315         offset = zfMmAddIeSupportRate(dev, buf, offset,
1316                                             ZM_WLAN_EID_SUPPORT_RATE, ZM_RATE_SET_OFDM);
1317
1318         /* DS parameter set */
1319         offset = zfMmAddIeDs(dev, buf, offset);
1320
1321         offset = zfStaAddIeIbss(dev, buf, offset);
1322
1323         /* TODO : country information */
1324         /* RSN */
1325         if ( wd->sta.authMode == ZM_AUTH_MODE_WPA2PSK )
1326         {
1327             offset = zfwStaAddIeWpaRsn(dev, buf, offset, ZM_WLAN_FRAME_TYPE_AUTH);
1328         }
1329     }
1330
1331     if ( wd->wlanMode != ZM_MODE_IBSS )
1332     {
1333         /* TODO : Need to check if it is ok */
1334         /* HT Capabilities Info */
1335         offset = zfMmAddHTCapability(dev, buf, offset);
1336
1337         /* Extended HT Capabilities Info */
1338         offset = zfMmAddExtendedHTCapability(dev, buf, offset);
1339     }
1340
1341     if ( wd->sta.ibssAdditionalIESize )
1342         offset = zfStaAddIbssAdditionalIE(dev, buf, offset);
1343
1344     /* 1212 : write to beacon fifo */
1345     /* 1221 : write to share memory */
1346     zfHpSendBeacon(dev, buf, offset);
1347
1348     /* Free beacon buffer */
1349     //zfwBufFree(dev, buf, 0);
1350 }
1351
1352 void zfStaSignalStatistic(zdev_t* dev, u8_t SignalStrength, u8_t SignalQuality) //CWYang(+)
1353 {
1354     zmw_get_wlan_dev(dev);
1355
1356     /* Add Your Code to Do Works Like Moving Average Here */
1357     wd->SignalStrength = (wd->SignalStrength * 7 + SignalStrength * 3)/10;
1358     wd->SignalQuality = (wd->SignalQuality * 7 + SignalQuality * 3)/10;
1359
1360 }
1361
1362 struct zsBssInfo* zfStaFindBssInfo(zdev_t* dev, zbuf_t* buf, struct zsWlanProbeRspFrameHeader *pProbeRspHeader)
1363 {
1364     u8_t    i;
1365     u8_t    j;
1366     u8_t    k;
1367     u8_t    isMatched, length, channel;
1368     u16_t   offset, frequency;
1369     struct zsBssInfo* pBssInfo;
1370
1371     zmw_get_wlan_dev(dev);
1372
1373     if ((pBssInfo = wd->sta.bssList.head) == NULL)
1374     {
1375         return NULL;
1376     }
1377
1378     for( i=0; i<wd->sta.bssList.bssCount; i++ )
1379     {
1380         //zm_debug_msg2("check pBssInfo = ", pBssInfo);
1381
1382         /* Check BSSID */
1383         for( j=0; j<6; j++ )
1384         {
1385             if ( pBssInfo->bssid[j] != pProbeRspHeader->bssid[j] )
1386             {
1387                 break;
1388             }
1389         }
1390
1391                 /* Check SSID */
1392         if (j == 6)
1393         {
1394             if (pProbeRspHeader->ssid[1] <= 32)
1395             {
1396                 /* compare length and ssid */
1397                 isMatched = 1;
1398                                 if((pProbeRspHeader->ssid[1] != 0) && (pBssInfo->ssid[1] != 0))
1399                                 {
1400                 for( k=1; k<pProbeRspHeader->ssid[1] + 1; k++ )
1401                 {
1402                     if ( pBssInfo->ssid[k] != pProbeRspHeader->ssid[k] )
1403                     {
1404                         isMatched = 0;
1405                         break;
1406                     }
1407                 }
1408             }
1409             }
1410             else
1411             {
1412                 isMatched = 0;
1413             }
1414         }
1415         else
1416         {
1417             isMatched = 0;
1418         }
1419
1420         /* Check channel */
1421         /* Add check channel to solve the bug #31222 */
1422         if (isMatched) {
1423             if ((offset = zfFindElement(dev, buf, ZM_WLAN_EID_DS)) != 0xffff) {
1424                 if ((length = zmw_rx_buf_readb(dev, buf, offset+1)) == 1) {
1425                     channel = zmw_rx_buf_readb(dev, buf, offset+2);
1426                     if (zfHpIsAllowedChannel(dev, zfChNumToFreq(dev, channel, 0)) == 0) {
1427                         frequency = 0;
1428                     } else {
1429                         frequency = zfChNumToFreq(dev, channel, 0);;
1430                     }
1431                 } else {
1432                     frequency = 0;
1433                 }
1434             } else {
1435                 frequency = wd->sta.currentFrequency;
1436             }
1437
1438             if (frequency != 0) {
1439                 if ( ((frequency > 3000) && (pBssInfo->frequency > 3000))
1440                      || ((frequency < 3000) && (pBssInfo->frequency < 3000)) ) {
1441                     /* redundant */
1442                     break;
1443                 }
1444             }
1445         }
1446
1447         pBssInfo = pBssInfo->next;
1448     }
1449
1450     if ( i == wd->sta.bssList.bssCount )
1451     {
1452         pBssInfo = NULL;
1453     }
1454
1455     return pBssInfo;
1456 }
1457
1458 u8_t zfStaInitBssInfo(zdev_t* dev, zbuf_t* buf,
1459         struct zsWlanProbeRspFrameHeader *pProbeRspHeader,
1460         struct zsBssInfo* pBssInfo, struct zsAdditionInfo* AddInfo, u8_t type)
1461 {
1462     u8_t    length, channel, is5G;
1463     u16_t   i, offset;
1464     u8_t    apQosInfo;
1465     u16_t    eachIElength = 0;
1466     u16_t   accumulateLen = 0;
1467
1468     zmw_get_wlan_dev(dev);
1469
1470     if ((type == 1) && ((pBssInfo->flag & ZM_BSS_INFO_VALID_BIT) != 0))
1471     {
1472         goto zlUpdateRssi;
1473     }
1474
1475     /* get SSID */
1476     if ( (offset = zfFindElement(dev, buf, ZM_WLAN_EID_SSID)) == 0xffff )
1477     {
1478         zm_debug_msg0("EID(SSID) not found");
1479         goto zlError;
1480     }
1481
1482     length = zmw_rx_buf_readb(dev, buf, offset+1);
1483
1484         {
1485                 u8_t Show_Flag = 0;
1486                 zfwGetShowZeroLengthSSID(dev, &Show_Flag);
1487
1488                 if(Show_Flag)
1489                 {
1490                         if (length > ZM_MAX_SSID_LENGTH )
1491                         {
1492                                 zm_debug_msg0("EID(SSID) is invalid");
1493                                 goto zlError;
1494                         }
1495                 }
1496                 else
1497                 {
1498     if ( length == 0 || length > ZM_MAX_SSID_LENGTH )
1499     {
1500         zm_debug_msg0("EID(SSID) is invalid");
1501         goto zlError;
1502     }
1503
1504                 }
1505         }
1506     zfCopyFromRxBuffer(dev, buf, pBssInfo->ssid, offset, length+2);
1507
1508     /* get DS parameter */
1509     if ( (offset = zfFindElement(dev, buf, ZM_WLAN_EID_DS)) != 0xffff )
1510     {
1511         length = zmw_rx_buf_readb(dev, buf, offset+1);
1512         if ( length != 1 )
1513         {
1514             zm_msg0_mm(ZM_LV_0, "Abnormal DS Param Set IE");
1515             goto zlError;
1516         }
1517         channel = zmw_rx_buf_readb(dev, buf, offset+2);
1518
1519         if (zfHpIsAllowedChannel(dev, zfChNumToFreq(dev, channel, 0)) == 0)
1520         {
1521             goto zlError2;
1522         }
1523
1524         pBssInfo->frequency = zfChNumToFreq(dev, channel, 0); // auto check
1525         pBssInfo->channel = channel;
1526
1527
1528     }
1529     else
1530     {
1531         /* DS parameter not found */
1532         pBssInfo->frequency = wd->sta.currentFrequency;
1533         pBssInfo->channel = zfChFreqToNum(wd->sta.currentFrequency, &is5G);
1534     }
1535
1536     /* initialize security type */
1537     pBssInfo->securityType = ZM_SECURITY_TYPE_NONE;
1538
1539     /* get macaddr */
1540     for( i=0; i<6; i++ )
1541     {
1542         pBssInfo->macaddr[i] = pProbeRspHeader->sa[i];
1543     }
1544
1545     /* get bssid */
1546     for( i=0; i<6; i++ )
1547     {
1548         pBssInfo->bssid[i] = pProbeRspHeader->bssid[i];
1549     }
1550
1551     /* get timestamp */
1552     for( i=0; i<8; i++ )
1553     {
1554         pBssInfo->timeStamp[i] = pProbeRspHeader->timeStamp[i];
1555     }
1556
1557     /* get beacon interval */
1558     pBssInfo->beaconInterval[0] = pProbeRspHeader->beaconInterval[0];
1559     pBssInfo->beaconInterval[1] = pProbeRspHeader->beaconInterval[1];
1560
1561     /* get capability */
1562     pBssInfo->capability[0] = pProbeRspHeader->capability[0];
1563     pBssInfo->capability[1] = pProbeRspHeader->capability[1];
1564
1565     /* Copy frame body */
1566     offset = 36;            // Copy from the start of variable IE
1567     pBssInfo->frameBodysize = zfwBufGetSize(dev, buf)-offset;
1568     if (pBssInfo->frameBodysize > (ZM_MAX_PROBE_FRAME_BODY_SIZE-1))
1569     {
1570         pBssInfo->frameBodysize = ZM_MAX_PROBE_FRAME_BODY_SIZE-1;
1571     }
1572     accumulateLen = 0;
1573     do
1574     {
1575         eachIElength = zmw_rx_buf_readb(dev, buf, offset + accumulateLen+1) + 2;  //Len+(EID+Data)
1576
1577         if ( (eachIElength >= 2)
1578              && ((accumulateLen + eachIElength) <= pBssInfo->frameBodysize) )
1579         {
1580             zfCopyFromRxBuffer(dev, buf, pBssInfo->frameBody+accumulateLen, offset+accumulateLen, eachIElength);
1581             accumulateLen+=(u16_t)eachIElength;
1582         }
1583         else
1584         {
1585             zm_msg0_mm(ZM_LV_1, "probersp frameBodysize abnormal");
1586             break;
1587         }
1588     }
1589     while(accumulateLen < pBssInfo->frameBodysize);
1590     pBssInfo->frameBodysize = accumulateLen;
1591
1592     /* get supported rates */
1593     if ( (offset = zfFindElement(dev, buf, ZM_WLAN_EID_SUPPORT_RATE)) == 0xffff )
1594     {
1595         zm_debug_msg0("EID(supported rates) not found");
1596         goto zlError;
1597     }
1598
1599     length = zmw_rx_buf_readb(dev, buf, offset+1);
1600     if ( length == 0 || length > ZM_MAX_SUPP_RATES_IE_SIZE)
1601     {
1602         zm_msg0_mm(ZM_LV_0, "Supported rates IE length abnormal");
1603         goto zlError;
1604     }
1605     zfCopyFromRxBuffer(dev, buf, pBssInfo->supportedRates, offset, length+2);
1606
1607
1608
1609     /* get Country information */
1610     if ( (offset = zfFindElement(dev, buf, ZM_WLAN_EID_COUNTRY)) != 0xffff )
1611     {
1612         length = zmw_rx_buf_readb(dev, buf, offset+1);
1613         if (length > ZM_MAX_COUNTRY_INFO_SIZE)
1614         {
1615             length = ZM_MAX_COUNTRY_INFO_SIZE;
1616         }
1617         zfCopyFromRxBuffer(dev, buf, pBssInfo->countryInfo, offset, length+2);
1618         /* check 802.11d support data */
1619         if (wd->sta.b802_11D)
1620         {
1621             zfHpGetRegulationTablefromISO(dev, (u8_t *)&pBssInfo->countryInfo, 3);
1622             /* only set regulatory one time */
1623             wd->sta.b802_11D = 0;
1624         }
1625     }
1626
1627     /* get ERP information */
1628     if ( (offset = zfFindElement(dev, buf, ZM_WLAN_EID_ERP)) != 0xffff )
1629     {
1630         pBssInfo->erp = zmw_rx_buf_readb(dev, buf, offset+2);
1631     }
1632
1633     /* get extended supported rates */
1634     if ( (offset = zfFindElement(dev, buf, ZM_WLAN_EID_EXTENDED_RATE)) != 0xffff )
1635     {
1636         length = zmw_rx_buf_readb(dev, buf, offset+1);
1637         if (length > ZM_MAX_SUPP_RATES_IE_SIZE)
1638         {
1639             zm_msg0_mm(ZM_LV_0, "Extended rates IE length abnormal");
1640             goto zlError;
1641         }
1642         zfCopyFromRxBuffer(dev, buf, pBssInfo->extSupportedRates, offset, length+2);
1643     }
1644     else
1645     {
1646         pBssInfo->extSupportedRates[0] = 0;
1647         pBssInfo->extSupportedRates[1] = 0;
1648     }
1649
1650     /* get WPA IE */
1651     if ( (offset = zfFindElement(dev, buf, ZM_WLAN_EID_WPA_IE)) != 0xffff )
1652     {
1653         length = zmw_rx_buf_readb(dev, buf, offset+1);
1654         if (length > ZM_MAX_IE_SIZE)
1655         {
1656             length = ZM_MAX_IE_SIZE;
1657         }
1658         zfCopyFromRxBuffer(dev, buf, pBssInfo->wpaIe, offset, length+2);
1659         pBssInfo->securityType = ZM_SECURITY_TYPE_WPA;
1660     }
1661     else
1662     {
1663         pBssInfo->wpaIe[1] = 0;
1664     }
1665
1666     /* get WPS IE */
1667     if ((offset = zfFindWifiElement(dev, buf, 4, 0xff)) != 0xffff)
1668     {
1669         length = zmw_rx_buf_readb(dev, buf, offset+1);
1670         if (length > ZM_MAX_WPS_IE_SIZE )
1671         {
1672             length = ZM_MAX_WPS_IE_SIZE;
1673         }
1674         zfCopyFromRxBuffer(dev, buf, pBssInfo->wscIe, offset, length+2);
1675     }
1676     else
1677     {
1678         pBssInfo->wscIe[1] = 0;
1679     }
1680
1681     /* get SuperG IE */
1682     if ((offset = zfFindSuperGElement(dev, buf, ZM_WLAN_EID_VENDOR_PRIVATE)) != 0xffff)
1683     {
1684         pBssInfo->apCap |= ZM_SuperG_AP;
1685     }
1686
1687     /* get XR IE */
1688     if ((offset = zfFindXRElement(dev, buf, ZM_WLAN_EID_VENDOR_PRIVATE)) != 0xffff)
1689     {
1690         pBssInfo->apCap |= ZM_XR_AP;
1691     }
1692
1693     /* get RSN IE */
1694     if ( (offset = zfFindElement(dev, buf, ZM_WLAN_EID_RSN_IE)) != 0xffff )
1695     {
1696         length = zmw_rx_buf_readb(dev, buf, offset+1);
1697         if (length > ZM_MAX_IE_SIZE)
1698         {
1699             length = ZM_MAX_IE_SIZE;
1700         }
1701         zfCopyFromRxBuffer(dev, buf, pBssInfo->rsnIe, offset, length+2);
1702         pBssInfo->securityType = ZM_SECURITY_TYPE_WPA;
1703     }
1704     else
1705     {
1706         pBssInfo->rsnIe[1] = 0;
1707     }
1708 #ifdef ZM_ENABLE_CENC
1709     /* get CENC IE */
1710     if ( (offset = zfFindElement(dev, buf, ZM_WLAN_EID_CENC_IE)) != 0xffff )
1711     {
1712         length = zmw_rx_buf_readb(dev, buf, offset+1);
1713         if (length > ZM_MAX_IE_SIZE )
1714         {
1715             length = ZM_MAX_IE_SIZE;
1716         }
1717         zfCopyFromRxBuffer(dev, buf, pBssInfo->cencIe, offset, length+2);
1718         pBssInfo->securityType = ZM_SECURITY_TYPE_CENC;
1719         pBssInfo->capability[0] &= 0xffef;
1720     }
1721     else
1722     {
1723         pBssInfo->cencIe[1] = 0;
1724     }
1725 #endif //ZM_ENABLE_CENC
1726     /* get WME Parameter IE, probe rsp may contain WME parameter element */
1727     //if ( wd->bQoSEnable )
1728     {
1729         if ((offset = zfFindWifiElement(dev, buf, 2, 1)) != 0xffff)
1730         {
1731             apQosInfo = zmw_rx_buf_readb(dev, buf, offset+8) & 0x80;
1732             pBssInfo->wmeSupport = 1 | apQosInfo;
1733         }
1734         else if ((offset = zfFindWifiElement(dev, buf, 2, 0)) != 0xffff)
1735         {
1736             apQosInfo = zmw_rx_buf_readb(dev, buf, offset+8) & 0x80;
1737             pBssInfo->wmeSupport = 1  | apQosInfo;
1738         }
1739         else
1740         {
1741             pBssInfo->wmeSupport = 0;
1742         }
1743     }
1744     //CWYang(+)
1745     if ((offset = zfFindElement(dev, buf, ZM_WLAN_EID_HT_CAPABILITY)) != 0xffff)
1746     {
1747         /* 11n AP */
1748         pBssInfo->EnableHT = 1;
1749         if (zmw_rx_buf_readb(dev, buf, offset+1) & 0x02)
1750         {
1751             pBssInfo->enableHT40 = 1;
1752         }
1753         else
1754         {
1755             pBssInfo->enableHT40 = 0;
1756         }
1757
1758         if (zmw_rx_buf_readb(dev, buf, offset+1) & 0x40)
1759         {
1760             pBssInfo->SG40 = 1;
1761         }
1762         else
1763         {
1764             pBssInfo->SG40 = 0;
1765         }
1766     }
1767     else if ((offset = zfFindElement(dev, buf, ZM_WLAN_PREN2_EID_HTCAPABILITY)) != 0xffff)
1768     {
1769         /* 11n AP */
1770         pBssInfo->EnableHT = 1;
1771         pBssInfo->apCap |= ZM_All11N_AP;
1772         if (zmw_rx_buf_readb(dev, buf, offset+2) & 0x02)
1773         {
1774             pBssInfo->enableHT40 = 1;
1775         }
1776         else
1777         {
1778             pBssInfo->enableHT40 = 0;
1779         }
1780
1781         if (zmw_rx_buf_readb(dev, buf, offset+2) & 0x40)
1782         {
1783             pBssInfo->SG40 = 1;
1784         }
1785         else
1786         {
1787             pBssInfo->SG40 = 0;
1788         }
1789     }
1790     else
1791     {
1792         pBssInfo->EnableHT = 0;
1793     }
1794     /* HT information */
1795     if ((offset = zfFindElement(dev, buf, ZM_WLAN_EID_EXTENDED_HT_CAPABILITY)) != 0xffff)
1796     {
1797         /* atheros pre n */
1798         pBssInfo->extChOffset = zmw_rx_buf_readb(dev, buf, offset+2) & 0x03;
1799     }
1800     else if ((offset = zfFindElement(dev, buf, ZM_WLAN_PREN2_EID_HTINFORMATION)) != 0xffff)
1801     {
1802         /* pre n 2.0 standard */
1803         pBssInfo->extChOffset = zmw_rx_buf_readb(dev, buf, offset+3) & 0x03;
1804     }
1805     else
1806     {
1807         pBssInfo->extChOffset = 0;
1808     }
1809
1810     if ( (pBssInfo->enableHT40 == 1)
1811          && ((pBssInfo->extChOffset != 1) && (pBssInfo->extChOffset != 3)) )
1812     {
1813         pBssInfo->enableHT40 = 0;
1814     }
1815
1816     if (pBssInfo->enableHT40 == 1)
1817     {
1818         if (zfHpIsAllowedChannel(dev, pBssInfo->frequency+((pBssInfo->extChOffset==1)?20:-20)) == 0)
1819         {
1820             /* if extension channel is not an allowed channel, treat AP as non-HT mode */
1821             pBssInfo->EnableHT = 0;
1822             pBssInfo->enableHT40 = 0;
1823             pBssInfo->extChOffset = 0;
1824         }
1825     }
1826
1827     /* get ATH Extended Capability */
1828     if ( ((offset = zfFindElement(dev, buf, ZM_WLAN_EID_EXTENDED_HT_CAPABILITY)) != 0xffff)&&
1829         ((offset = zfFindBrdcmMrvlRlnkExtCap(dev, buf)) == 0xffff))
1830
1831     {
1832         pBssInfo->athOwlAp = 1;
1833     }
1834     else
1835     {
1836         pBssInfo->athOwlAp = 0;
1837     }
1838
1839     /* get Broadcom Extended Capability */
1840     if ( (pBssInfo->EnableHT == 1) //((offset = zfFindElement(dev, buf, ZM_WLAN_EID_EXTENDED_HT_CAPABILITY)) != 0xffff)
1841          && ((offset = zfFindBroadcomExtCap(dev, buf)) != 0xffff) )
1842     {
1843         pBssInfo->broadcomHTAp = 1;
1844     }
1845     else
1846     {
1847         pBssInfo->broadcomHTAp = 0;
1848     }
1849
1850     /* get Marvel Extended Capability */
1851     if ((offset = zfFindMarvelExtCap(dev, buf)) != 0xffff)
1852     {
1853         pBssInfo->marvelAp = 1;
1854     }
1855     else
1856     {
1857         pBssInfo->marvelAp = 0;
1858     }
1859
1860     /* get ATIM window */
1861     if ( (offset = zfFindElement(dev, buf, ZM_WLAN_EID_IBSS)) != 0xffff )
1862     {
1863         pBssInfo->atimWindow = zmw_rx_buf_readh(dev, buf,offset+2);
1864     }
1865
1866     /* Fit for support mode */
1867     if (pBssInfo->frequency > 3000) {
1868         if (wd->supportMode & ZM_WIRELESS_MODE_5_N) {
1869 #if 0
1870             if (wd->supportMode & ZM_WIRELESS_MODE_5_54) {
1871                 /* support mode: a, n */
1872                 /* do nothing */
1873             } else {
1874                 /* support mode: n */
1875                 /* reject non-n bss info */
1876                 if (!pBssInfo->EnableHT) {
1877                     goto zlError2;
1878                 }
1879             }
1880 #endif
1881         } else {
1882             if (wd->supportMode & ZM_WIRELESS_MODE_5_54) {
1883                 /* support mode: a */
1884                 /* delete n mode information */
1885                 pBssInfo->EnableHT = 0;
1886                 pBssInfo->enableHT40 = 0;
1887                 pBssInfo->apCap &= (~ZM_All11N_AP);
1888                 pBssInfo->extChOffset = 0;
1889                 pBssInfo->frameBodysize = zfRemoveElement(dev, pBssInfo->frameBody,
1890                             pBssInfo->frameBodysize, ZM_WLAN_EID_HT_CAPABILITY);
1891                 pBssInfo->frameBodysize = zfRemoveElement(dev, pBssInfo->frameBody,
1892                             pBssInfo->frameBodysize, ZM_WLAN_PREN2_EID_HTCAPABILITY);
1893                 pBssInfo->frameBodysize = zfRemoveElement(dev, pBssInfo->frameBody,
1894                             pBssInfo->frameBodysize, ZM_WLAN_EID_EXTENDED_HT_CAPABILITY);
1895                 pBssInfo->frameBodysize = zfRemoveElement(dev, pBssInfo->frameBody,
1896                             pBssInfo->frameBodysize, ZM_WLAN_PREN2_EID_HTINFORMATION);
1897             } else {
1898                 /* support mode: none */
1899                 goto zlError2;
1900             }
1901         }
1902     } else {
1903         if (wd->supportMode & ZM_WIRELESS_MODE_24_N) {
1904 #if 0
1905             if (wd->supportMode & ZM_WIRELESS_MODE_24_54) {
1906                 if (wd->supportMode & ZM_WIRELESS_MODE_24_11) {
1907                     /* support mode: b, g, n */
1908                     /* do nothing */
1909                 } else {
1910                     /* support mode: g, n */
1911                     /* reject b-only bss info */
1912                     if ( (!pBssInfo->EnableHT)
1913                          && (pBssInfo->extSupportedRates[1] == 0) ) {
1914                          goto zlError2;
1915                     }
1916                 }
1917             } else {
1918                 if (wd->supportMode & ZM_WIRELESS_MODE_24_11) {
1919                     /* support mode: b, n */
1920                     /* 1. reject g-only bss info
1921                      * 2. if non g-only, delete g mode information
1922                      */
1923                     if ( !pBssInfo->EnableHT ) {
1924                         if ( zfIsGOnlyMode(dev, pBssInfo->frequency, pBssInfo->supportedRates)
1925                              || zfIsGOnlyMode(dev, pBssInfo->frequency, pBssInfo->extSupportedRates) ) {
1926                             goto zlError2;
1927                         } else {
1928                             zfGatherBMode(dev, pBssInfo->supportedRates,
1929                                           pBssInfo->extSupportedRates);
1930                             pBssInfo->erp = 0;
1931
1932                             pBssInfo->frameBodysize = zfRemoveElement(dev,
1933                                 pBssInfo->frameBody, pBssInfo->frameBodysize,
1934                                 ZM_WLAN_EID_ERP);
1935                             pBssInfo->frameBodysize = zfRemoveElement(dev,
1936                                 pBssInfo->frameBody, pBssInfo->frameBodysize,
1937                                 ZM_WLAN_EID_EXTENDED_RATE);
1938
1939                             pBssInfo->frameBodysize = zfUpdateElement(dev,
1940                                 pBssInfo->frameBody, pBssInfo->frameBodysize,
1941                                 pBssInfo->supportedRates);
1942                         }
1943                     }
1944                 } else {
1945                     /* support mode: n */
1946                     /* reject non-n bss info */
1947                     if (!pBssInfo->EnableHT) {
1948                         goto zlError2;
1949                     }
1950                 }
1951             }
1952 #endif
1953         } else {
1954             /* delete n mode information */
1955             pBssInfo->EnableHT = 0;
1956             pBssInfo->enableHT40 = 0;
1957             pBssInfo->apCap &= (~ZM_All11N_AP);
1958             pBssInfo->extChOffset = 0;
1959             pBssInfo->frameBodysize = zfRemoveElement(dev, pBssInfo->frameBody,
1960                         pBssInfo->frameBodysize, ZM_WLAN_EID_HT_CAPABILITY);
1961             pBssInfo->frameBodysize = zfRemoveElement(dev, pBssInfo->frameBody,
1962                         pBssInfo->frameBodysize, ZM_WLAN_PREN2_EID_HTCAPABILITY);
1963             pBssInfo->frameBodysize = zfRemoveElement(dev, pBssInfo->frameBody,
1964                         pBssInfo->frameBodysize, ZM_WLAN_EID_EXTENDED_HT_CAPABILITY);
1965             pBssInfo->frameBodysize = zfRemoveElement(dev, pBssInfo->frameBody,
1966                         pBssInfo->frameBodysize, ZM_WLAN_PREN2_EID_HTINFORMATION);
1967
1968             if (wd->supportMode & ZM_WIRELESS_MODE_24_54) {
1969 #if 0
1970                 if (wd->supportMode & ZM_WIRELESS_MODE_24_11) {
1971                     /* support mode: b, g */
1972                     /* delete n mode information */
1973                 } else {
1974                     /* support mode: g */
1975                     /* delete n mode information */
1976                     /* reject b-only bss info */
1977                     if (pBssInfo->extSupportedRates[1] == 0) {
1978                          goto zlError2;
1979                     }
1980                 }
1981 #endif
1982             } else {
1983                 if (wd->supportMode & ZM_WIRELESS_MODE_24_11) {
1984                     /* support mode: b */
1985                     /* delete n mode information */
1986                     if ( zfIsGOnlyMode(dev, pBssInfo->frequency, pBssInfo->supportedRates)
1987                          || zfIsGOnlyMode(dev, pBssInfo->frequency, pBssInfo->extSupportedRates) ) {
1988                         goto zlError2;
1989                     } else {
1990                         zfGatherBMode(dev, pBssInfo->supportedRates,
1991                                           pBssInfo->extSupportedRates);
1992                         pBssInfo->erp = 0;
1993
1994                         pBssInfo->frameBodysize = zfRemoveElement(dev,
1995                             pBssInfo->frameBody, pBssInfo->frameBodysize,
1996                             ZM_WLAN_EID_ERP);
1997                         pBssInfo->frameBodysize = zfRemoveElement(dev,
1998                             pBssInfo->frameBody, pBssInfo->frameBodysize,
1999                             ZM_WLAN_EID_EXTENDED_RATE);
2000
2001                         pBssInfo->frameBodysize = zfUpdateElement(dev,
2002                             pBssInfo->frameBody, pBssInfo->frameBodysize,
2003                             pBssInfo->supportedRates);
2004                     }
2005                 } else {
2006                     /* support mode: none */
2007                     goto zlError2;
2008                 }
2009             }
2010         }
2011     }
2012
2013     pBssInfo->flag |= ZM_BSS_INFO_VALID_BIT;
2014
2015 zlUpdateRssi:
2016     /* Update Timer information */
2017     pBssInfo->tick = wd->tick;
2018
2019     /* Update ERP information */
2020     if ( (offset = zfFindElement(dev, buf, ZM_WLAN_EID_ERP)) != 0xffff )
2021     {
2022         pBssInfo->erp = zmw_rx_buf_readb(dev, buf, offset+2);
2023     }
2024
2025     if( (s8_t)pBssInfo->signalStrength < (s8_t)AddInfo->Tail.Data.SignalStrength1 )
2026     {
2027         /* Update signal strength */
2028         pBssInfo->signalStrength = (u8_t)AddInfo->Tail.Data.SignalStrength1;
2029         /* Update signal quality */
2030         pBssInfo->signalQuality = (u8_t)(AddInfo->Tail.Data.SignalStrength1 * 2);
2031
2032         /* Update the sorting value  */
2033         pBssInfo->sortValue = zfComputeBssInfoWeightValue(dev,
2034                                                (pBssInfo->supportedRates[6] + pBssInfo->extSupportedRates[0]),
2035                                                pBssInfo->EnableHT,
2036                                                pBssInfo->enableHT40,
2037                                                pBssInfo->signalStrength);
2038     }
2039
2040     return 0;
2041
2042 zlError:
2043
2044     return 1;
2045
2046 zlError2:
2047
2048     return 2;
2049 }
2050
2051 void zfStaProcessBeacon(zdev_t* dev, zbuf_t* buf, struct zsAdditionInfo* AddInfo) //CWYang(m)
2052 {
2053     /* Parse TIM and send PS-POLL in power saving mode */
2054     struct zsWlanBeaconFrameHeader*  pBeaconHeader;
2055     struct zsBssInfo* pBssInfo;
2056     u8_t   pBuf[sizeof(struct zsWlanBeaconFrameHeader)];
2057     u8_t   bssid[6];
2058     int    res;
2059
2060     zmw_get_wlan_dev(dev);
2061
2062     zmw_declare_for_critical_section();
2063
2064     /* sta routine jobs */
2065     zfStaProtErpMonitor(dev, buf);  /* check protection mode */
2066
2067     if (zfStaIsConnected(dev))
2068     {
2069         ZM_MAC_WORD_TO_BYTE(wd->sta.bssid, bssid);
2070
2071         if ( wd->wlanMode == ZM_MODE_INFRASTRUCTURE )
2072         {
2073             if ( zfRxBufferEqualToStr(dev, buf, bssid, ZM_WLAN_HEADER_A2_OFFSET, 6) )
2074             {
2075                 zfPowerSavingMgrProcessBeacon(dev, buf);
2076                 zfStaUpdateWmeParameter(dev, buf);
2077                 if (wd->sta.DFSEnable)
2078                     zfStaUpdateDot11HDFS(dev, buf);
2079                 if (wd->sta.TPCEnable)
2080                     zfStaUpdateDot11HTPC(dev, buf);
2081                 /* update signal strength and signal quality */
2082                 zfStaSignalStatistic(dev, AddInfo->Tail.Data.SignalStrength1,
2083                         AddInfo->Tail.Data.SignalQuality); //CWYang(+)
2084                 wd->sta.rxBeaconCount++;
2085             }
2086         }
2087         else if ( wd->wlanMode == ZM_MODE_IBSS )
2088         {
2089             if ( zfRxBufferEqualToStr(dev, buf, bssid, ZM_WLAN_HEADER_A3_OFFSET, 6) )
2090             {
2091                 int res;
2092                 struct zsPartnerNotifyEvent event;
2093
2094                 zm_debug_msg0("20070916 Receive opposite Beacon!");
2095                 zmw_enter_critical_section(dev);
2096                 wd->sta.ibssReceiveBeaconCount++;
2097                 zmw_leave_critical_section(dev);
2098
2099                 res = zfStaSetOppositeInfoFromRxBuf(dev, buf);
2100                 if ( res == 0 )
2101                 {
2102                     // New peer station found. Notify the wrapper now
2103                     zfInitPartnerNotifyEvent(dev, buf, &event);
2104                     if (wd->zfcbIbssPartnerNotify != NULL)
2105                     {
2106                         wd->zfcbIbssPartnerNotify(dev, 1, &event);
2107                     }
2108                 }
2109                 /* update signal strength and signal quality */
2110                 zfStaSignalStatistic(dev, AddInfo->Tail.Data.SignalStrength1,
2111                         AddInfo->Tail.Data.SignalQuality); //CWYang(+)
2112             }
2113             //else if ( wd->sta.ibssPartnerStatus == ZM_IBSS_PARTNER_LOST )
2114             // Why does this happen in IBSS?? The impact of Vista since
2115             // we need to tell it the BSSID
2116 #if 0
2117             else if ( wd->sta.oppositeCount == 0 )
2118             {   /* IBSS merge if SSID matched */
2119                 if ( (offset = zfFindElement(dev, buf, ZM_WLAN_EID_SSID)) != 0xffff )
2120                 {
2121                     if ( (wd->sta.ssidLen == zmw_buf_readb(dev, buf, offset+1))&&
2122                          (zfRxBufferEqualToStr(dev, buf, wd->sta.ssid,
2123                                                offset+2, wd->sta.ssidLen)) )
2124                     {
2125                         capabilityInfo = zmw_buf_readh(dev, buf, 34);
2126
2127                         if ( capabilityInfo & ZM_BIT_1 )
2128                         {
2129                             if ( (wd->sta.capability[0] & ZM_BIT_4) ==
2130                                  (capabilityInfo & ZM_BIT_4) )
2131                             {
2132                                 zm_debug_msg0("IBSS merge");
2133                                 zfCopyFromRxBuffer(dev, buf, bssid,
2134                                                    ZM_WLAN_HEADER_A3_OFFSET, 6);
2135                                 zfUpdateBssid(dev, bssid);
2136                             }
2137                         }
2138                     }
2139                 }
2140             }
2141 #endif
2142         }
2143     }
2144
2145     /* return if not channel scan */
2146     if ( !wd->sta.bChannelScan )
2147     {
2148         goto zlReturn;
2149     }
2150
2151     zfCopyFromRxBuffer(dev, buf, pBuf, 0, sizeof(struct zsWlanBeaconFrameHeader));
2152     pBeaconHeader = (struct zsWlanBeaconFrameHeader*) pBuf;
2153
2154     zmw_enter_critical_section(dev);
2155
2156     //zm_debug_msg1("bss count = ", wd->sta.bssList.bssCount);
2157
2158     pBssInfo = zfStaFindBssInfo(dev, buf, pBeaconHeader);
2159
2160     if ( pBssInfo == NULL )
2161     {
2162         /* Allocate a new entry if BSS not in the scan list */
2163         pBssInfo = zfBssInfoAllocate(dev);
2164         if (pBssInfo != NULL)
2165         {
2166             res = zfStaInitBssInfo(dev, buf, pBeaconHeader, pBssInfo, AddInfo, 0);
2167             //zfDumpSSID(pBssInfo->ssid[1], &(pBssInfo->ssid[2]));
2168             if ( res != 0 )
2169             {
2170                 zfBssInfoFree(dev, pBssInfo);
2171             }
2172             else
2173             {
2174                 zfBssInfoInsertToList(dev, pBssInfo);
2175             }
2176         }
2177     }
2178     else
2179     {
2180         res = zfStaInitBssInfo(dev, buf, pBeaconHeader, pBssInfo, AddInfo, 1);
2181         if (res == 2)
2182         {
2183             zfBssInfoRemoveFromList(dev, pBssInfo);
2184             zfBssInfoFree(dev, pBssInfo);
2185         }
2186         else if ( wd->wlanMode == ZM_MODE_IBSS )
2187         {
2188             int idx;
2189
2190             // It would reset the alive counter if the peer station is found!
2191             zfStaFindFreeOpposite(dev, (u16_t *)pBssInfo->macaddr, &idx);
2192         }
2193     }
2194
2195     zmw_leave_critical_section(dev);
2196
2197 zlReturn:
2198
2199     return;
2200 }
2201
2202
2203 void zfAuthFreqCompleteCb(zdev_t* dev)
2204 {
2205     zmw_get_wlan_dev(dev);
2206     zmw_declare_for_critical_section();
2207
2208     zmw_enter_critical_section(dev);
2209
2210     if (wd->sta.connectState == ZM_STA_CONN_STATE_AUTH_COMPLETED)
2211     {
2212         zm_debug_msg0("ZM_STA_CONN_STATE_ASSOCIATE");
2213         wd->sta.connectTimer = wd->tick;
2214         wd->sta.connectState = ZM_STA_CONN_STATE_ASSOCIATE;
2215     }
2216
2217     zmw_leave_critical_section(dev);
2218     return;
2219 }
2220
2221 /************************************************************************/
2222 /*                                                                      */
2223 /*    FUNCTION DESCRIPTION                  zfProcessAuth               */
2224 /*      Process authenticate management frame.                          */
2225 /*                                                                      */
2226 /*    INPUTS                                                            */
2227 /*      dev : device pointer                                            */
2228 /*      buf : auth frame buffer                                         */
2229 /*                                                                      */
2230 /*    OUTPUTS                                                           */
2231 /*      none                                                            */
2232 /*                                                                      */
2233 /*    AUTHOR                                                            */
2234 /*      Stephen Chen        ZyDAS Technology Corporation    2005.10     */
2235 /*                                                                      */
2236 /************************************************************************/
2237 /* Note : AP allows one authenticating STA at a time, does not          */
2238 /*        support multiple authentication process. Make sure            */
2239 /*        authentication state machine will not be blocked due          */
2240 /*        to incompleted authentication handshake.                      */
2241 void zfStaProcessAuth(zdev_t* dev, zbuf_t* buf, u16_t* src, u16_t apId)
2242 {
2243     struct zsWlanAuthFrameHeader* pAuthFrame;
2244     u8_t  pBuf[sizeof(struct zsWlanAuthFrameHeader)];
2245     u32_t p1, p2;
2246
2247     zmw_get_wlan_dev(dev);
2248     zmw_declare_for_critical_section();
2249
2250     if ( !zfStaIsConnecting(dev) )
2251     {
2252         return;
2253     }
2254
2255     pAuthFrame = (struct zsWlanAuthFrameHeader*) pBuf;
2256     zfCopyFromRxBuffer(dev, buf, pBuf, 0, sizeof(struct zsWlanAuthFrameHeader));
2257
2258     if ( wd->sta.connectState == ZM_STA_CONN_STATE_AUTH_OPEN )
2259     {
2260         if ( (zmw_le16_to_cpu(pAuthFrame->seq) == 2)&&
2261              (zmw_le16_to_cpu(pAuthFrame->algo) == 0)&&
2262              (zmw_le16_to_cpu(pAuthFrame->status) == 0) )
2263         {
2264
2265             zmw_enter_critical_section(dev);
2266             wd->sta.connectTimer = wd->tick;
2267             zm_debug_msg0("ZM_STA_CONN_STATE_AUTH_COMPLETED");
2268             wd->sta.connectState = ZM_STA_CONN_STATE_AUTH_COMPLETED;
2269             zmw_leave_critical_section(dev);
2270
2271             //Set channel according to AP's configuration
2272             //Move to here because of Cisco 11n AP feature
2273             zfCoreSetFrequencyEx(dev, wd->frequency, wd->BandWidth40,
2274                     wd->ExtOffset, zfAuthFreqCompleteCb);
2275
2276             /* send association frame */
2277             if ( wd->sta.connectByReasso )
2278             {
2279                 zfSendMmFrame(dev, ZM_WLAN_FRAME_TYPE_REASOCREQ,
2280                               wd->sta.bssid, 0, 0, 0);
2281             }
2282             else
2283             {
2284                 zfSendMmFrame(dev, ZM_WLAN_FRAME_TYPE_ASOCREQ,
2285                               wd->sta.bssid, 0, 0, 0);
2286             }
2287
2288
2289         }
2290         else
2291         {
2292             zm_debug_msg1("authentication failed, status = ",
2293                           pAuthFrame->status);
2294
2295             if (wd->sta.authMode == ZM_AUTH_MODE_AUTO)
2296             {
2297                 wd->sta.bIsSharedKey = 1;
2298                 zfStaStartConnect(dev, wd->sta.bIsSharedKey);
2299             }
2300             else
2301             {
2302                 zm_debug_msg0("ZM_STA_STATE_DISCONNECT");
2303                 zfStaConnectFail(dev, ZM_STATUS_MEDIA_DISCONNECT_AUTH_FAILED, wd->sta.bssid, 3);
2304             }
2305         }
2306     }
2307     else if ( wd->sta.connectState == ZM_STA_CONN_STATE_AUTH_SHARE_1 )
2308     {
2309         if ( (zmw_le16_to_cpu(pAuthFrame->algo) == 1) &&
2310              (zmw_le16_to_cpu(pAuthFrame->seq) == 2) &&
2311              (zmw_le16_to_cpu(pAuthFrame->status) == 0))
2312               //&& (pAuthFrame->challengeText[1] <= 255) )
2313         {
2314             zfMemoryCopy(wd->sta.challengeText, pAuthFrame->challengeText,
2315                          pAuthFrame->challengeText[1]+2);
2316
2317             /* send the 3rd authentication frame */
2318             p1 = 0x30001;
2319             p2 = 0;
2320             zfSendMmFrame(dev, ZM_WLAN_FRAME_TYPE_AUTH,
2321                           wd->sta.bssid, p1, p2, 0);
2322
2323             zmw_enter_critical_section(dev);
2324             wd->sta.connectTimer = wd->tick;
2325
2326             zm_debug_msg0("ZM_STA_SUB_STATE_AUTH_SHARE_2");
2327             wd->sta.connectState = ZM_STA_CONN_STATE_AUTH_SHARE_2;
2328             zmw_leave_critical_section(dev);
2329         }
2330         else
2331         {
2332             zm_debug_msg1("authentication failed, status = ",
2333                           pAuthFrame->status);
2334
2335             zm_debug_msg0("ZM_STA_STATE_DISCONNECT");
2336             zfStaConnectFail(dev, ZM_STATUS_MEDIA_DISCONNECT_AUTH_FAILED, wd->sta.bssid, 3);
2337         }
2338     }
2339     else if ( wd->sta.connectState == ZM_STA_CONN_STATE_AUTH_SHARE_2 )
2340     {
2341         if ( (zmw_le16_to_cpu(pAuthFrame->algo) == 1)&&
2342              (zmw_le16_to_cpu(pAuthFrame->seq) == 4)&&
2343              (zmw_le16_to_cpu(pAuthFrame->status) == 0) )
2344         {
2345             //Set channel according to AP's configuration
2346             //Move to here because of Cisco 11n AP feature
2347             zfCoreSetFrequencyEx(dev, wd->frequency, wd->BandWidth40,
2348                     wd->ExtOffset, NULL);
2349
2350             /* send association frame */
2351             zfSendMmFrame(dev, ZM_WLAN_FRAME_TYPE_ASOCREQ,
2352                           wd->sta.bssid, 0, 0, 0);
2353
2354             zmw_enter_critical_section(dev);
2355             wd->sta.connectTimer = wd->tick;
2356
2357             zm_debug_msg0("ZM_STA_SUB_STATE_ASSOCIATE");
2358             wd->sta.connectState = ZM_STA_CONN_STATE_ASSOCIATE;
2359             zmw_leave_critical_section(dev);
2360         }
2361         else
2362         {
2363             zm_debug_msg1("authentication failed, status = ",
2364                           pAuthFrame->status);
2365
2366             zm_debug_msg0("ZM_STA_STATE_DISCONNECT");
2367             zfStaConnectFail(dev, ZM_STATUS_MEDIA_DISCONNECT_AUTH_FAILED, wd->sta.bssid, 3);
2368         }
2369     }
2370     else
2371     {
2372         zm_debug_msg0("unknown case");
2373     }
2374 }
2375
2376 void zfStaProcessAsocReq(zdev_t* dev, zbuf_t* buf, u16_t* src, u16_t apId)
2377 {
2378
2379     return;
2380 }
2381
2382 void zfStaProcessAsocRsp(zdev_t* dev, zbuf_t* buf)
2383 {
2384     struct zsWlanAssoFrameHeader* pAssoFrame;
2385     u8_t  pBuf[sizeof(struct zsWlanAssoFrameHeader)];
2386     u16_t offset;
2387     u32_t i;
2388     u32_t oneTxStreamCap;
2389
2390     zmw_get_wlan_dev(dev);
2391
2392     if ( !zfStaIsConnecting(dev) )
2393     {
2394         return;
2395     }
2396
2397     pAssoFrame = (struct zsWlanAssoFrameHeader*) pBuf;
2398     zfCopyFromRxBuffer(dev, buf, pBuf, 0, sizeof(struct zsWlanAssoFrameHeader));
2399
2400     if ( wd->sta.connectState == ZM_STA_CONN_STATE_ASSOCIATE )
2401     {
2402         if ( pAssoFrame->status == 0 )
2403         {
2404             zm_debug_msg0("ZM_STA_STATE_CONNECTED");
2405
2406             if (wd->sta.EnableHT == 1)
2407             {
2408                 wd->sta.wmeConnected = 1;
2409             }
2410             if ((wd->sta.wmeEnabled & ZM_STA_WME_ENABLE_BIT) != 0) //WME enabled
2411             {
2412                 /* Asoc rsp may contain WME parameter element */
2413                 if ((offset = zfFindWifiElement(dev, buf, 2, 1)) != 0xffff)
2414                 {
2415                     zm_debug_msg0("WME enable");
2416                     wd->sta.wmeConnected = 1;
2417                     if ((wd->sta.wmeEnabled & ZM_STA_UAPSD_ENABLE_BIT) != 0)
2418                     {
2419                         if ((zmw_rx_buf_readb(dev, buf, offset+8) & 0x80) != 0)
2420                         {
2421                             zm_debug_msg0("UAPSD enable");
2422                             wd->sta.qosInfo = wd->sta.wmeQosInfo;
2423                         }
2424                     }
2425
2426                     zfStaUpdateWmeParameter(dev, buf);
2427                 }
2428             }
2429
2430
2431             //Store asoc response frame body, for VISTA only
2432             wd->sta.asocRspFrameBodySize = zfwBufGetSize(dev, buf)-24;
2433             if (wd->sta.asocRspFrameBodySize > ZM_CACHED_FRAMEBODY_SIZE)
2434             {
2435                 wd->sta.asocRspFrameBodySize = ZM_CACHED_FRAMEBODY_SIZE;
2436             }
2437             for (i=0; i<wd->sta.asocRspFrameBodySize; i++)
2438             {
2439                 wd->sta.asocRspFrameBody[i] = zmw_rx_buf_readb(dev, buf, i+24);
2440             }
2441
2442             zfStaStoreAsocRspIe(dev, buf);
2443             if (wd->sta.EnableHT &&
2444                 ((wd->sta.ie.HtCap.HtCapInfo & HTCAP_SupChannelWidthSet) != 0) &&
2445                 (wd->ExtOffset != 0))
2446             {
2447                 wd->sta.htCtrlBandwidth = 1;
2448             }
2449             else
2450             {
2451                 wd->sta.htCtrlBandwidth = 0;
2452             }
2453
2454             //Set channel according to AP's configuration
2455             //zfCoreSetFrequencyEx(dev, wd->frequency, wd->BandWidth40,
2456             //        wd->ExtOffset, NULL);
2457
2458             if (wd->sta.EnableHT == 1)
2459             {
2460                 wd->addbaComplete = 0;
2461
2462                 if ((wd->sta.SWEncryptEnable & ZM_SW_TKIP_ENCRY_EN) == 0 &&
2463                     (wd->sta.SWEncryptEnable & ZM_SW_WEP_ENCRY_EN) == 0)
2464                 {
2465                     wd->addbaCount = 1;
2466                     zfAggSendAddbaRequest(dev, wd->sta.bssid, 0, 0);
2467                     zfTimerSchedule(dev, ZM_EVENT_TIMEOUT_ADDBA, 100);
2468                 }
2469             }
2470
2471             /* set RIFS support */
2472             if(wd->sta.ie.HtInfo.ChannelInfo & ExtHtCap_RIFSMode)
2473             {
2474                 wd->sta.HT2040 = 1;
2475 //                zfHpSetRifs(dev, wd->sta.EnableHT, 1, (wd->sta.currentFrequency < 3000)? 1:0);
2476             }
2477
2478             wd->sta.aid = pAssoFrame->aid & 0x3fff;
2479             wd->sta.oppositeCount = 0;    /* reset opposite count */
2480             zfStaSetOppositeInfoFromRxBuf(dev, buf);
2481
2482             wd->sta.rxBeaconCount = 16;
2483
2484             zfChangeAdapterState(dev, ZM_STA_STATE_CONNECTED);
2485             wd->sta.connPowerInHalfDbm = zfHpGetTransmitPower(dev);
2486             if (wd->zfcbConnectNotify != NULL)
2487             {
2488                 if (wd->sta.EnableHT != 0) /* 11n */
2489                 {
2490                         oneTxStreamCap = (zfHpCapability(dev) & ZM_HP_CAP_11N_ONE_TX_STREAM);
2491                         if (wd->sta.htCtrlBandwidth == 1) /* HT40*/
2492                         {
2493                                         if(oneTxStreamCap) /* one Tx stream */
2494                                     {
2495                                         if (wd->sta.SG40)
2496                                         {
2497                                             wd->CurrentTxRateKbps = 150000;
2498                                                     wd->CurrentRxRateKbps = 300000;
2499                                         }
2500                                         else
2501                                         {
2502                                             wd->CurrentTxRateKbps = 135000;
2503                                                     wd->CurrentRxRateKbps = 270000;
2504                                         }
2505                                     }
2506                                     else /* Two Tx streams */
2507                                     {
2508                                         if (wd->sta.SG40)
2509                                         {
2510                                             wd->CurrentTxRateKbps = 300000;
2511                                                     wd->CurrentRxRateKbps = 300000;
2512                                         }
2513                                         else
2514                                         {
2515                                             wd->CurrentTxRateKbps = 270000;
2516                                                     wd->CurrentRxRateKbps = 270000;
2517                                         }
2518                                     }
2519                         }
2520                         else /* HT20 */
2521                         {
2522                             if(oneTxStreamCap) /* one Tx stream */
2523                                     {
2524                                         wd->CurrentTxRateKbps = 650000;
2525                                                 wd->CurrentRxRateKbps = 130000;
2526                                     }
2527                                     else /* Two Tx streams */
2528                                     {
2529                                         wd->CurrentTxRateKbps = 130000;
2530                                             wd->CurrentRxRateKbps = 130000;
2531                                     }
2532                         }
2533                 }
2534                 else /* 11abg */
2535                 {
2536                     if (wd->sta.connection_11b != 0)
2537                     {
2538                         wd->CurrentTxRateKbps = 11000;
2539                                 wd->CurrentRxRateKbps = 11000;
2540                     }
2541                     else
2542                     {
2543                         wd->CurrentTxRateKbps = 54000;
2544                                 wd->CurrentRxRateKbps = 54000;
2545                             }
2546                 }
2547
2548
2549                 wd->zfcbConnectNotify(dev, ZM_STATUS_MEDIA_CONNECT, wd->sta.bssid);
2550             }
2551             wd->sta.connectByReasso = TRUE;
2552             wd->sta.failCntOfReasso = 0;
2553
2554             zfPowerSavingMgrConnectNotify(dev);
2555
2556             /* Disable here because fixed rate is only for test, TBD. */
2557             //if (wd->sta.EnableHT)
2558             //{
2559             //    wd->txMCS = 7; //Rate = 65Mbps
2560             //    wd->txMT = 2; // Ht rate
2561             //    wd->enableAggregation = 2; // Enable Aggregation
2562             //}
2563         }
2564         else
2565         {
2566             zm_debug_msg1("association failed, status = ",
2567                           pAssoFrame->status);
2568
2569             zm_debug_msg0("ZM_STA_STATE_DISCONNECT");
2570             wd->sta.connectByReasso = FALSE;
2571             zfStaConnectFail(dev, ZM_STATUS_MEDIA_DISCONNECT_ASOC_FAILED, wd->sta.bssid, 3);
2572         }
2573     }
2574
2575 }
2576
2577 void zfStaStoreAsocRspIe(zdev_t* dev, zbuf_t* buf)
2578 {
2579     u16_t offset;
2580     u32_t i;
2581     u16_t length;
2582     u8_t  *htcap;
2583     u8_t  asocBw40 = 0;
2584     u8_t  asocExtOffset = 0;
2585
2586     zmw_get_wlan_dev(dev);
2587
2588     for (i=0; i<wd->sta.asocRspFrameBodySize; i++)
2589     {
2590         wd->sta.asocRspFrameBody[i] = zmw_rx_buf_readb(dev, buf, i+24);
2591     }
2592
2593     /* HT capabilities: 28 octets */
2594     if (    ((wd->sta.currentFrequency > 3000) && !(wd->supportMode & ZM_WIRELESS_MODE_5_N))
2595          || ((wd->sta.currentFrequency < 3000) && !(wd->supportMode & ZM_WIRELESS_MODE_24_N)) )
2596     {
2597         /* not 11n AP */
2598         htcap = (u8_t *)&wd->sta.ie.HtCap;
2599         for (i=0; i<28; i++)
2600         {
2601             htcap[i] = 0;
2602         }
2603         wd->BandWidth40 = 0;
2604         wd->ExtOffset = 0;
2605         return;
2606     }
2607
2608     if ((offset = zfFindElement(dev, buf, ZM_WLAN_EID_HT_CAPABILITY)) != 0xffff)
2609     {
2610         /* atheros pre n */
2611         zm_debug_msg0("atheros pre n");
2612         htcap = (u8_t *)&wd->sta.ie.HtCap;
2613         htcap[0] = zmw_rx_buf_readb(dev, buf, offset);
2614         htcap[1] = 26;
2615         for (i=1; i<=26; i++)
2616         {
2617             htcap[i+1] = zmw_rx_buf_readb(dev, buf, offset + i);
2618             zm_msg2_mm(ZM_LV_1, "ASOC:  HT Capabilities, htcap=", htcap[i+1]);
2619         }
2620     }
2621     else if ((offset = zfFindElement(dev, buf, ZM_WLAN_PREN2_EID_HTCAPABILITY)) != 0xffff)
2622     {
2623         /* pre n 2.0 standard */
2624         zm_debug_msg0("pre n 2.0 standard");
2625         htcap = (u8_t *)&wd->sta.ie.HtCap;
2626         for (i=0; i<28; i++)
2627         {
2628             htcap[i] = zmw_rx_buf_readb(dev, buf, offset + i);
2629             zm_msg2_mm(ZM_LV_1, "ASOC:  HT Capabilities, htcap=", htcap[i]);
2630         }
2631     }
2632     else
2633     {
2634         /* not 11n AP */
2635         htcap = (u8_t *)&wd->sta.ie.HtCap;
2636         for (i=0; i<28; i++)
2637         {
2638             htcap[i] = 0;
2639         }
2640         wd->BandWidth40 = 0;
2641         wd->ExtOffset = 0;
2642         return;
2643     }
2644
2645     asocBw40 = (u8_t)((wd->sta.ie.HtCap.HtCapInfo & HTCAP_SupChannelWidthSet) >> 1);
2646
2647     /* HT information */
2648     if ((offset = zfFindElement(dev, buf, ZM_WLAN_EID_EXTENDED_HT_CAPABILITY)) != 0xffff)
2649     {
2650         /* atheros pre n */
2651         zm_debug_msg0("atheros pre n HTINFO");
2652         length = 22;
2653         htcap = (u8_t *)&wd->sta.ie.HtInfo;
2654         htcap[0] = zmw_rx_buf_readb(dev, buf, offset);
2655         htcap[1] = 22;
2656         for (i=1; i<=22; i++)
2657         {
2658             htcap[i+1] = zmw_rx_buf_readb(dev, buf, offset + i);
2659             zm_msg2_mm(ZM_LV_1, "ASOC:  HT Info, htinfo=", htcap[i+1]);
2660         }
2661     }
2662     else if ((offset = zfFindElement(dev, buf, ZM_WLAN_PREN2_EID_HTINFORMATION)) != 0xffff)
2663     {
2664         /* pre n 2.0 standard */
2665         zm_debug_msg0("pre n 2.0 standard HTINFO");
2666         length = zmw_rx_buf_readb(dev, buf, offset + 1);
2667         htcap = (u8_t *)&wd->sta.ie.HtInfo;
2668         for (i=0; i<24; i++)
2669         {
2670             htcap[i] = zmw_rx_buf_readb(dev, buf, offset + i);
2671             zm_msg2_mm(ZM_LV_1, "ASOC:  HT Info, htinfo=", htcap[i]);
2672         }
2673     }
2674     else
2675     {
2676         zm_debug_msg0("no HTINFO");
2677         htcap = (u8_t *)&wd->sta.ie.HtInfo;
2678         for (i=0; i<24; i++)
2679         {
2680             htcap[i] = 0;
2681         }
2682     }
2683     asocExtOffset = wd->sta.ie.HtInfo.ChannelInfo & ExtHtCap_ExtChannelOffsetBelow;
2684
2685     if ((wd->sta.EnableHT == 1) && (asocBw40 == 1) && ((asocExtOffset == 1) || (asocExtOffset == 3)))
2686     {
2687         wd->BandWidth40 = asocBw40;
2688         wd->ExtOffset = asocExtOffset;
2689     }
2690     else
2691     {
2692         wd->BandWidth40 = 0;
2693         wd->ExtOffset = 0;
2694     }
2695
2696     return;
2697 }
2698
2699 void zfStaProcessDeauth(zdev_t* dev, zbuf_t* buf)
2700 {
2701     u16_t apMacAddr[3];
2702
2703     zmw_get_wlan_dev(dev);
2704     zmw_declare_for_critical_section();
2705
2706     /* STA : if SA=connected AP then disconnect with AP */
2707     if ( wd->wlanMode == ZM_MODE_INFRASTRUCTURE )
2708     {
2709         apMacAddr[0] = zmw_rx_buf_readh(dev, buf, ZM_WLAN_HEADER_A3_OFFSET);
2710         apMacAddr[1] = zmw_rx_buf_readh(dev, buf, ZM_WLAN_HEADER_A3_OFFSET+2);
2711         apMacAddr[2] = zmw_rx_buf_readh(dev, buf, ZM_WLAN_HEADER_A3_OFFSET+4);
2712         if ((apMacAddr[0] == wd->sta.bssid[0]) && (apMacAddr[1] == wd->sta.bssid[1]) && (apMacAddr[2] == wd->sta.bssid[2]))
2713         {
2714             if (zfwBufGetSize(dev, buf) >= 24+2) //not a malformed frame
2715             {
2716                 if ( zfStaIsConnected(dev) )
2717                 {
2718                     zfStaConnectFail(dev, ZM_STATUS_MEDIA_DISCONNECT_DEAUTH, wd->sta.bssid, 2);
2719                 }
2720                 else if (zfStaIsConnecting(dev))
2721                 {
2722                     zfStaConnectFail(dev, ZM_STATUS_MEDIA_DISCONNECT_AUTH_FAILED, wd->sta.bssid, 3);
2723                 }
2724                 else
2725                 {
2726                 }
2727             }
2728         }
2729     }
2730     else if ( wd->wlanMode == ZM_MODE_IBSS )
2731     {
2732         u16_t peerMacAddr[3];
2733         u8_t  peerIdx;
2734         s8_t  res;
2735
2736         if ( zfStaIsConnected(dev) )
2737         {
2738             peerMacAddr[0] = zmw_rx_buf_readh(dev, buf, ZM_WLAN_HEADER_A2_OFFSET);
2739             peerMacAddr[1] = zmw_rx_buf_readh(dev, buf, ZM_WLAN_HEADER_A2_OFFSET+2);
2740             peerMacAddr[2] = zmw_rx_buf_readh(dev, buf, ZM_WLAN_HEADER_A2_OFFSET+4);
2741
2742             zmw_enter_critical_section(dev);
2743             res = zfStaFindOppositeByMACAddr(dev, peerMacAddr, &peerIdx);
2744             if ( res == 0 )
2745             {
2746                 wd->sta.oppositeInfo[peerIdx].aliveCounter = 0;
2747             }
2748             zmw_leave_critical_section(dev);
2749         }
2750     }
2751 }
2752
2753 void zfStaProcessDisasoc(zdev_t* dev, zbuf_t* buf)
2754 {
2755     u16_t apMacAddr[3];
2756
2757     zmw_get_wlan_dev(dev);
2758
2759     /* STA : if SA=connected AP then disconnect with AP */
2760     if ( wd->wlanMode == ZM_MODE_INFRASTRUCTURE )
2761     {
2762         apMacAddr[0] = zmw_rx_buf_readh(dev, buf, ZM_WLAN_HEADER_A3_OFFSET);
2763         apMacAddr[1] = zmw_rx_buf_readh(dev, buf, ZM_WLAN_HEADER_A3_OFFSET+2);
2764         apMacAddr[2] = zmw_rx_buf_readh(dev, buf, ZM_WLAN_HEADER_A3_OFFSET+4);
2765
2766         if ((apMacAddr[0] == wd->sta.bssid[0]) && (apMacAddr[1] == wd->sta.bssid[1]) && (apMacAddr[2] == wd->sta.bssid[2]))
2767         {
2768             if (zfwBufGetSize(dev, buf) >= 24+2) //not a malformed frame
2769             {
2770                 if ( zfStaIsConnected(dev) )
2771                 {
2772                     zfStaConnectFail(dev, ZM_STATUS_MEDIA_DISCONNECT_DISASOC, wd->sta.bssid, 2);
2773                 }
2774                 else
2775                 {
2776                     zfStaConnectFail(dev, ZM_STATUS_MEDIA_DISCONNECT_ASOC_FAILED, wd->sta.bssid, 3);
2777                 }
2778             }
2779         }
2780     }
2781 }
2782
2783
2784
2785 /************************************************************************/
2786 /*                                                                      */
2787 /*    FUNCTION DESCRIPTION                  zfProcessProbeReq           */
2788 /*      Process probe request management frame.                         */
2789 /*                                                                      */
2790 /*    INPUTS                                                            */
2791 /*      dev : device pointer                                            */
2792 /*      buf : auth frame buffer                                         */
2793 /*                                                                      */
2794 /*    OUTPUTS                                                           */
2795 /*      none                                                            */
2796 /*                                                                      */
2797 /*    AUTHOR                                                            */
2798 /*      Stephen Chen        ZyDAS Technology Corporation    2005.10     */
2799 /*                                                                      */
2800 /************************************************************************/
2801 void zfStaProcessProbeReq(zdev_t* dev, zbuf_t* buf, u16_t* src)
2802 {
2803     u16_t offset;
2804     u8_t len;
2805     u16_t i, j;
2806     u16_t sendFlag;
2807
2808     zmw_get_wlan_dev(dev);
2809
2810     /* check mode : AP/IBSS */
2811     if ((wd->wlanMode != ZM_MODE_AP) || (wd->wlanMode != ZM_MODE_IBSS))
2812     {
2813         zm_msg0_mm(ZM_LV_3, "Ignore probe req");
2814         return;
2815     }
2816
2817     /* check SSID */
2818     if ((offset = zfFindElement(dev, buf, ZM_WLAN_EID_SSID)) == 0xffff)
2819     {
2820         zm_msg0_mm(ZM_LV_3, "probe req SSID not found");
2821         return;
2822     }
2823
2824     len = zmw_rx_buf_readb(dev, buf, offset+1);
2825
2826     for (i=0; i<ZM_MAX_AP_SUPPORT; i++)
2827     {
2828         if ((wd->ap.apBitmap & (i<<i)) != 0)
2829         {
2830             sendFlag = 0;
2831             /* boardcast SSID */
2832             if ((len == 0) && (wd->ap.hideSsid[i] == 0))
2833             {
2834                 sendFlag = 1;
2835             }
2836             /* Not broadcast SSID */
2837             else if (wd->ap.ssidLen[i] == len)
2838             {
2839                 for (j=0; j<len; j++)
2840                 {
2841                     if (zmw_rx_buf_readb(dev, buf, offset+1+j)
2842                             != wd->ap.ssid[i][j])
2843                     {
2844                         break;
2845                     }
2846                 }
2847                 if (j == len)
2848                 {
2849                     sendFlag = 1;
2850                 }
2851             }
2852             if (sendFlag == 1)
2853             {
2854                 /* Send probe response */
2855                 zfSendMmFrame(dev, ZM_WLAN_FRAME_TYPE_PROBERSP, src, i, 0, 0);
2856             }
2857         }
2858     }
2859 }
2860
2861 void zfStaProcessProbeRsp(zdev_t* dev, zbuf_t* buf, struct zsAdditionInfo* AddInfo)
2862 {
2863     /* return if not channel scan */
2864     // Probe response is sent with unicast. Is this required?
2865     // IBSS would send probe request and the code below would prevent
2866     // the probe response from handling.
2867     #if 0
2868     zmw_get_wlan_dev(dev);
2869
2870     if ( !wd->sta.bChannelScan )
2871     {
2872         return;
2873     }
2874     #endif
2875
2876     zfProcessProbeRsp(dev, buf, AddInfo);
2877 }
2878
2879 void zfIBSSSetupBssDesc(zdev_t *dev)
2880 {
2881 #ifdef ZM_ENABLE_IBSS_WPA2PSK
2882     u8_t i;
2883 #endif
2884     struct zsBssInfo *pBssInfo;
2885     u16_t offset = 0;
2886
2887     zmw_get_wlan_dev(dev);
2888
2889     pBssInfo = &wd->sta.ibssBssDesc;
2890     zfZeroMemory((u8_t *)pBssInfo, sizeof(struct zsBssInfo));
2891
2892     pBssInfo->signalStrength = 100;
2893
2894     zfMemoryCopy((u8_t *)pBssInfo->macaddr, (u8_t *)wd->macAddr,6);
2895     zfMemoryCopy((u8_t *)pBssInfo->bssid, (u8_t *)wd->sta.bssid, 6);
2896
2897     pBssInfo->beaconInterval[0] = (u8_t)(wd->beaconInterval) ;
2898     pBssInfo->beaconInterval[1] = (u8_t)((wd->beaconInterval) >> 8) ;
2899
2900     pBssInfo->capability[0] = wd->sta.capability[0];
2901     pBssInfo->capability[1] = wd->sta.capability[1];
2902
2903     pBssInfo->ssid[0] = ZM_WLAN_EID_SSID;
2904     pBssInfo->ssid[1] = wd->sta.ssidLen;
2905     zfMemoryCopy((u8_t *)&pBssInfo->ssid[2], (u8_t *)wd->sta.ssid, wd->sta.ssidLen);
2906     zfMemoryCopy((u8_t *)&pBssInfo->frameBody[offset], (u8_t *)pBssInfo->ssid,
2907                  wd->sta.ssidLen + 2);
2908     offset += wd->sta.ssidLen + 2;
2909
2910     /* support rate */
2911
2912     /* DS parameter set */
2913     pBssInfo->channel = zfChFreqToNum(wd->frequency, NULL);
2914     pBssInfo->frequency = wd->frequency;
2915     pBssInfo->atimWindow = wd->sta.atimWindow;
2916
2917 #ifdef ZM_ENABLE_IBSS_WPA2PSK
2918     if ( wd->sta.authMode == ZM_AUTH_MODE_WPA2PSK )
2919     {
2920         u8_t rsn[64]=
2921         {
2922                     /* Element ID */
2923                     0x30,
2924                     /* Length */
2925                     0x14,
2926                     /* Version */
2927                     0x01, 0x00,
2928                     /* Group Cipher Suite, default=TKIP */
2929                     0x00, 0x0f, 0xac, 0x04,
2930                     /* Pairwise Cipher Suite Count */
2931                     0x01, 0x00,
2932                     /* Pairwise Cipher Suite, default=TKIP */
2933                     0x00, 0x0f, 0xac, 0x02,
2934                     /* Authentication and Key Management Suite Count */
2935                     0x01, 0x00,
2936                     /* Authentication type, default=PSK */
2937                     0x00, 0x0f, 0xac, 0x02,
2938                     /* RSN capability */
2939                     0x00, 0x00
2940         };
2941
2942         /* Overwrite Group Cipher Suite by AP's setting */
2943         zfMemoryCopy(rsn+4, zgWpa2AesOui, 4);
2944
2945         if ( wd->sta.wepStatus == ZM_ENCRYPTION_AES )
2946         {
2947             /* Overwrite Pairwise Cipher Suite by AES */
2948             zfMemoryCopy(rsn+10, zgWpa2AesOui, 4);
2949         }
2950
2951         // RSN element id
2952         pBssInfo->frameBody[offset++] = ZM_WLAN_EID_RSN_IE ;
2953
2954         // RSN length
2955         pBssInfo->frameBody[offset++] = rsn[1] ;
2956
2957         // RSN information
2958         for(i=0; i<rsn[1]; i++)
2959         {
2960             pBssInfo->frameBody[offset++] = rsn[i+2] ;
2961         }
2962
2963         zfMemoryCopy(pBssInfo->rsnIe, rsn, rsn[1]+2);
2964     }
2965 #endif
2966 }
2967
2968 void zfIbssConnectNetwork(zdev_t* dev)
2969 {
2970     struct zsBssInfo* pBssInfo;
2971     struct zsBssInfo tmpBssInfo;
2972     u8_t   macAddr[6], bssid[6], bssNotFound = TRUE;
2973     u16_t  i, j=100;
2974     u16_t  k;
2975     struct zsPartnerNotifyEvent event;
2976     u32_t  channelFlags;
2977     u16_t  oppositeWepStatus;
2978
2979     zmw_get_wlan_dev(dev);
2980
2981     zmw_declare_for_critical_section();
2982
2983     /* change state to CONNECTING and stop the channel scanning */
2984     zfChangeAdapterState(dev, ZM_STA_STATE_CONNECTING);
2985     zfPowerSavingMgrWakeup(dev);
2986
2987     /* Set TxQs CWMIN, CWMAX, AIFS and TXO to WME STA default. */
2988     zfUpdateDefaultQosParameter(dev, 0);
2989
2990     wd->sta.bProtectionMode = FALSE;
2991     zfHpSetSlotTime(dev, 1);
2992
2993     /* ESS bit off */
2994     wd->sta.capability[0] &= ~ZM_BIT_0;
2995     /* IBSS bit on */
2996     wd->sta.capability[0] |= ZM_BIT_1;
2997     /* not not use short slot time */
2998     wd->sta.capability[1] &= ~ZM_BIT_2;
2999
3000     wd->sta.wmeConnected = 0;
3001     wd->sta.psMgr.tempWakeUp = 0;
3002     wd->sta.qosInfo = 0;
3003     wd->sta.EnableHT = 0;
3004     wd->BandWidth40 = 0;
3005     wd->ExtOffset = 0;
3006
3007     if ( wd->sta.bssList.bssCount )
3008     {
3009         //Reorder BssList by RSSI--CWYang(+)
3010         zfBssInfoReorderList(dev);
3011
3012         zmw_enter_critical_section(dev);
3013
3014         pBssInfo = wd->sta.bssList.head;
3015
3016         for(i=0; i<wd->sta.bssList.bssCount; i++)
3017         {
3018             // 20070806 #1 Privacy bit
3019             if ( pBssInfo->capability[0] & ZM_BIT_4 )
3020             { // Privacy Ibss network
3021 //                zm_debug_msg0("Privacy bit on");
3022                 oppositeWepStatus = ZM_ENCRYPTION_WEP_ENABLED;
3023
3024                 if ( pBssInfo->rsnIe[1] != 0 )
3025                 {
3026                     if ( (pBssInfo->rsnIe[7] == 0x01) || (pBssInfo->rsnIe[7] == 0x05) )
3027                     { // WEP-40 & WEP-104
3028 //                        zm_debug_msg0("WEP40 or WEP104");
3029                         oppositeWepStatus = ZM_ENCRYPTION_WEP_ENABLED;
3030                     }
3031                     else if ( pBssInfo->rsnIe[7] == 0x02 )
3032                     { // TKIP
3033 //                        zm_debug_msg0("TKIP");
3034                         oppositeWepStatus = ZM_ENCRYPTION_TKIP;
3035                     }
3036                     else if ( pBssInfo->rsnIe[7] == 0x04 )
3037                     { // AES
3038 //                        zm_debug_msg0("CCMP-AES");
3039                         oppositeWepStatus = ZM_ENCRYPTION_AES;
3040                     }
3041                 }
3042             }
3043             else
3044             {
3045 //                zm_debug_msg0("Privacy bit off");
3046                 oppositeWepStatus = ZM_ENCRYPTION_WEP_DISABLED;
3047             }
3048
3049             if ( (zfMemoryIsEqual(&(pBssInfo->ssid[2]), wd->sta.ssid,
3050                                   wd->sta.ssidLen))&&
3051                  (wd->sta.ssidLen == pBssInfo->ssid[1])&&
3052                  (oppositeWepStatus == wd->sta.wepStatus) )
3053             {
3054                 /* Check support mode */
3055                 if (pBssInfo->frequency > 3000) {
3056                     if (   (pBssInfo->EnableHT == 1)
3057                         || (pBssInfo->apCap & ZM_All11N_AP) ) //11n AP
3058                     {
3059                         channelFlags = CHANNEL_A_HT;
3060                         if (pBssInfo->enableHT40 == 1) {
3061                             channelFlags |= CHANNEL_HT40;
3062                         }
3063                     } else {
3064                         channelFlags = CHANNEL_A;
3065                     }
3066                 } else {
3067                     if (   (pBssInfo->EnableHT == 1)
3068                         || (pBssInfo->apCap & ZM_All11N_AP) ) //11n AP
3069                     {
3070                         channelFlags = CHANNEL_G_HT;
3071                         if(pBssInfo->enableHT40 == 1) {
3072                             channelFlags |= CHANNEL_HT40;
3073                         }
3074                     } else {
3075                         if (pBssInfo->extSupportedRates[1] == 0) {
3076                             channelFlags = CHANNEL_B;
3077                         } else {
3078                             channelFlags = CHANNEL_G;
3079                         }
3080                     }
3081                 }
3082
3083                 if (   ((channelFlags == CHANNEL_B) && (wd->connectMode & ZM_BIT_0))
3084                     || ((channelFlags == CHANNEL_G) && (wd->connectMode & ZM_BIT_1))
3085                     || ((channelFlags == CHANNEL_A) && (wd->connectMode & ZM_BIT_2))
3086                     || ((channelFlags & CHANNEL_HT20) && (wd->connectMode & ZM_BIT_3)) )
3087                 {
3088                     pBssInfo = pBssInfo->next;
3089                     continue;
3090                 }
3091
3092                 /* Bypass DFS channel */
3093                 if (zfHpIsDfsChannelNCS(dev, pBssInfo->frequency))
3094                 {
3095                     zm_debug_msg0("Bypass DFS channel");
3096                     continue;
3097                 }
3098
3099                 /* check IBSS bit */
3100                 if ( pBssInfo->capability[0] & ZM_BIT_1 )
3101                 {
3102                     /* may check timestamp here */
3103                     j = i;
3104                     break;
3105                 }
3106             }
3107
3108             pBssInfo = pBssInfo->next;
3109         }
3110
3111         if ((j < wd->sta.bssList.bssCount) && (pBssInfo != NULL))
3112         {
3113             zfwMemoryCopy((u8_t*)&tmpBssInfo, (u8_t*)(pBssInfo), sizeof(struct zsBssInfo));
3114             pBssInfo = &tmpBssInfo;
3115         }
3116         else
3117         {
3118             pBssInfo = NULL;
3119         }
3120
3121         zmw_leave_critical_section(dev);
3122
3123         //if ( j < wd->sta.bssList.bssCount )
3124         if (pBssInfo != NULL)
3125         {
3126             int res;
3127
3128             zm_debug_msg0("IBSS found");
3129
3130             /* Found IBSS, reset bssNotFoundCount */
3131             zmw_enter_critical_section(dev);
3132             wd->sta.bssNotFoundCount = 0;
3133             zmw_leave_critical_section(dev);
3134
3135             bssNotFound = FALSE;
3136             wd->sta.atimWindow = pBssInfo->atimWindow;
3137             wd->frequency = pBssInfo->frequency;
3138             //wd->sta.flagFreqChanging = 1;
3139             zfCoreSetFrequency(dev, wd->frequency);
3140             zfUpdateBssid(dev, pBssInfo->bssid);
3141             zfResetSupportRate(dev, ZM_DEFAULT_SUPPORT_RATE_ZERO);
3142             zfUpdateSupportRate(dev, pBssInfo->supportedRates);
3143             zfUpdateSupportRate(dev, pBssInfo->extSupportedRates);
3144             wd->beaconInterval = pBssInfo->beaconInterval[0] +
3145                                  (((u16_t) pBssInfo->beaconInterval[1]) << 8);
3146
3147             if (wd->beaconInterval == 0)
3148             {
3149                 wd->beaconInterval = 100;
3150             }
3151
3152             /* rsn information element */
3153             if ( pBssInfo->rsnIe[1] != 0 )
3154             {
3155                 zfMemoryCopy(wd->sta.rsnIe, pBssInfo->rsnIe,
3156                              pBssInfo->rsnIe[1]+2);
3157
3158 #ifdef ZM_ENABLE_IBSS_WPA2PSK
3159                 /* If not use RSNA , run traditional */
3160                 zmw_enter_critical_section(dev);
3161                 wd->sta.ibssWpa2Psk = 1;
3162                 zmw_leave_critical_section(dev);
3163 #endif
3164             }
3165             else
3166             {
3167                 wd->sta.rsnIe[1] = 0;
3168             }
3169
3170             /* privacy bit */
3171             if ( pBssInfo->capability[0] & ZM_BIT_4 )
3172             {
3173                 wd->sta.capability[0] |= ZM_BIT_4;
3174             }
3175             else
3176             {
3177                 wd->sta.capability[0] &= ~ZM_BIT_4;
3178             }
3179
3180             /* preamble type */
3181             wd->preambleTypeInUsed = wd->preambleType;
3182             if ( wd->preambleTypeInUsed == ZM_PREAMBLE_TYPE_AUTO )
3183             {
3184                 if (pBssInfo->capability[0] & ZM_BIT_5)
3185                 {
3186                     wd->preambleTypeInUsed = ZM_PREAMBLE_TYPE_SHORT;
3187                 }
3188                 else
3189                 {
3190                     wd->preambleTypeInUsed = ZM_PREAMBLE_TYPE_LONG;
3191                 }
3192             }
3193
3194             if (wd->preambleTypeInUsed == ZM_PREAMBLE_TYPE_LONG)
3195             {
3196                 wd->sta.capability[0] &= ~ZM_BIT_5;
3197             }
3198             else
3199             {
3200                 wd->sta.capability[0] |= ZM_BIT_5;
3201             }
3202
3203             wd->sta.beaconFrameBodySize = pBssInfo->frameBodysize + 12;
3204
3205             if (wd->sta.beaconFrameBodySize > ZM_CACHED_FRAMEBODY_SIZE)
3206             {
3207                 wd->sta.beaconFrameBodySize = ZM_CACHED_FRAMEBODY_SIZE;
3208             }
3209
3210             for (k=0; k<8; k++)
3211             {
3212                 wd->sta.beaconFrameBody[k] = pBssInfo->timeStamp[k];
3213             }
3214             wd->sta.beaconFrameBody[8] = pBssInfo->beaconInterval[0];
3215             wd->sta.beaconFrameBody[9] = pBssInfo->beaconInterval[1];
3216             wd->sta.beaconFrameBody[10] = pBssInfo->capability[0];
3217             wd->sta.beaconFrameBody[11] = pBssInfo->capability[1];
3218             //for (k=12; k<wd->sta.beaconFrameBodySize; k++)
3219             for (k=0; k<pBssInfo->frameBodysize; k++)
3220             {
3221                 wd->sta.beaconFrameBody[k+12] = pBssInfo->frameBody[k];
3222             }
3223
3224             zmw_enter_critical_section(dev);
3225             res = zfStaSetOppositeInfoFromBSSInfo(dev, pBssInfo);
3226             if ( res == 0 )
3227             {
3228                 zfMemoryCopy(event.bssid, (u8_t *)(pBssInfo->bssid), 6);
3229                 zfMemoryCopy(event.peerMacAddr, (u8_t *)(pBssInfo->macaddr), 6);
3230             }
3231             zmw_leave_critical_section(dev);
3232
3233             //zfwIbssPartnerNotify(dev, 1, &event);
3234             goto connect_done;
3235         }
3236     }
3237
3238     /* IBSS not found */
3239     if ( bssNotFound )
3240     {
3241 #ifdef ZM_ENABLE_IBSS_WPA2PSK
3242         u16_t offset ;
3243 #endif
3244         if ( wd->sta.ibssJoinOnly )
3245         {
3246             zm_debug_msg0("IBSS join only...retry...");
3247             goto retry_ibss;
3248         }
3249
3250         if(wd->sta.bssNotFoundCount<2)
3251         {
3252             zmw_enter_critical_section(dev);
3253             zm_debug_msg1("IBSS not found, do sitesurvey!!  bssNotFoundCount=", wd->sta.bssNotFoundCount);
3254             wd->sta.bssNotFoundCount++;
3255             zmw_leave_critical_section(dev);
3256             goto retry_ibss;
3257         }
3258         else
3259         {
3260             zmw_enter_critical_section(dev);
3261             /* Fail IBSS found, TODO create IBSS */
3262             wd->sta.bssNotFoundCount = 0;
3263             zmw_leave_critical_section(dev);
3264         }
3265
3266
3267         if (zfHpIsDfsChannel(dev, wd->frequency))
3268         {
3269             wd->frequency = zfHpFindFirstNonDfsChannel(dev, wd->frequency > 3000);
3270         }
3271
3272         if( wd->ws.autoSetFrequency == 0 )
3273         { /* Auto set frequency */
3274             zm_debug_msg1("Create Ad Hoc Network Band ", wd->ws.adhocMode);
3275             wd->frequency = zfFindCleanFrequency(dev, wd->ws.adhocMode);
3276             wd->ws.autoSetFrequency = 0xff;
3277         }
3278         zm_debug_msg1("IBSS not found, created one in channel ", wd->frequency);
3279
3280         wd->sta.ibssBssIsCreator = 1;
3281
3282         //wd->sta.flagFreqChanging = 1;
3283         zfCoreSetFrequency(dev, wd->frequency);
3284         if (wd->sta.bDesiredBssid == TRUE)
3285         {
3286             for (k=0; k<6; k++)
3287             {
3288                 bssid[k] = wd->sta.desiredBssid[k];
3289             }
3290         }
3291         else
3292         {
3293             #if 1
3294             macAddr[0] = (wd->macAddr[0] & 0xff);
3295             macAddr[1] = (wd->macAddr[0] >> 8);
3296             macAddr[2] = (wd->macAddr[1] & 0xff);
3297             macAddr[3] = (wd->macAddr[1] >> 8);
3298             macAddr[4] = (wd->macAddr[2] & 0xff);
3299             macAddr[5] = (wd->macAddr[2] >> 8);
3300             zfGenerateRandomBSSID(dev, (u8_t *)wd->macAddr, (u8_t *)bssid);
3301             #else
3302             for (k=0; k<6; k++)
3303             {
3304                 bssid[k] = (u8_t) zfGetRandomNumber(dev, 0);
3305             }
3306             bssid[0] &= ~ZM_BIT_0;
3307             bssid[0] |= ZM_BIT_1;
3308             #endif
3309         }
3310
3311         zfUpdateBssid(dev, bssid);
3312         //wd->sta.atimWindow = 0x0a;
3313
3314         /* rate information */
3315         if(wd->frequency <= ZM_CH_G_14)  // 2.4 GHz  b+g
3316         {
3317             if ( wd->wfc.bIbssGMode
3318                  && (wd->supportMode & (ZM_WIRELESS_MODE_24_54|ZM_WIRELESS_MODE_24_N)) )
3319             {
3320                 zfResetSupportRate(dev, ZM_DEFAULT_SUPPORT_RATE_IBSS_AG);
3321             }
3322             else
3323             {
3324                 zfResetSupportRate(dev, ZM_DEFAULT_SUPPORT_RATE_IBSS_B);
3325             }
3326         } else {
3327             zfResetSupportRate(dev, ZM_DEFAULT_SUPPORT_RATE_IBSS_AG);
3328         }
3329
3330         if ( wd->sta.wepStatus == ZM_ENCRYPTION_WEP_DISABLED )
3331         {
3332             wd->sta.capability[0] &= ~ZM_BIT_4;
3333         }
3334         else
3335         {
3336             wd->sta.capability[0] |= ZM_BIT_4;
3337         }
3338
3339         wd->preambleTypeInUsed = wd->preambleType;
3340         if (wd->preambleTypeInUsed == ZM_PREAMBLE_TYPE_LONG)
3341         {
3342             wd->sta.capability[0] &= ~ZM_BIT_5;
3343         }
3344         else
3345         {
3346             wd->preambleTypeInUsed = ZM_PREAMBLE_TYPE_SHORT;
3347             wd->sta.capability[0] |= ZM_BIT_5;
3348         }
3349
3350         zfIBSSSetupBssDesc(dev);
3351
3352 #ifdef ZM_ENABLE_IBSS_WPA2PSK
3353
3354         // 20070411 Add WPA2PSK information to its IBSS network !!!
3355         offset = 0 ;
3356
3357         /* timestamp */
3358         offset += 8 ;
3359
3360         /* beacon interval */
3361         wd->sta.beaconFrameBody[offset++] = (u8_t)(wd->beaconInterval) ;
3362         wd->sta.beaconFrameBody[offset++] = (u8_t)((wd->beaconInterval) >> 8) ;
3363
3364         /* capability information */
3365         wd->sta.beaconFrameBody[offset++] = wd->sta.capability[0] ;
3366         wd->sta.beaconFrameBody[offset++] = wd->sta.capability[1] ;
3367         #if 0
3368         /* ssid */
3369         // ssid element id
3370         wd->sta.beaconFrameBody[offset++] = ZM_WLAN_EID_SSID ;
3371         // ssid length
3372         wd->sta.beaconFrameBody[offset++] = wd->sta.ssidLen ;
3373         // ssid information
3374         for(i=0; i<wd->sta.ssidLen; i++)
3375         {
3376             wd->sta.beaconFrameBody[offset++] = wd->sta.ssid[i] ;
3377         }
3378
3379         /* support rate */
3380         rateSet = ZM_RATE_SET_CCK ;
3381         if ( (rateSet == ZM_RATE_SET_OFDM)&&((wd->gRate & 0xff) == 0) )
3382         {
3383             offset += 0 ;
3384         }
3385         else
3386         {
3387             // support rate element id
3388             wd->sta.beaconFrameBody[offset++] = ZM_WLAN_EID_SUPPORT_RATE ;
3389
3390             // support rate length
3391             lenOffset = offset++;
3392
3393             // support rate information
3394             for (i=0; i<4; i++)
3395             {
3396                 if ((wd->bRate & (0x1<<i)) == (0x1<<i))
3397                 {
3398                     wd->sta.beaconFrameBody[offset++] =
3399                             zg11bRateTbl[i]+((wd->bRateBasic & (0x1<<i))<<(7-i)) ;
3400                     len++;
3401                 }
3402             }
3403
3404             // support rate length
3405             wd->sta.beaconFrameBody[lenOffset] = len ;
3406         }
3407
3408         /* DS parameter set */
3409         // DS parameter set elemet id
3410         wd->sta.beaconFrameBody[offset++] = ZM_WLAN_EID_DS ;
3411
3412         // DS parameter set length
3413         wd->sta.beaconFrameBody[offset++] = 1 ;
3414
3415         // DS parameter set information
3416         wd->sta.beaconFrameBody[offset++] =
3417                 zfChFreqToNum(wd->frequency, NULL) ;
3418
3419         /* IBSS parameter set */
3420         // IBSS parameter set element id
3421         wd->sta.beaconFrameBody[offset++] = ZM_WLAN_EID_IBSS ;
3422
3423         // IBSS parameter set length
3424         wd->sta.beaconFrameBody[offset++] = 2 ;
3425
3426         // IBSS parameter set information
3427         wd->sta.beaconFrameBody[offset] = wd->sta.atimWindow ;
3428         offset += 2 ;
3429
3430         /* ERP Information and Extended Supported Rates */
3431         if ( wd->wfc.bIbssGMode
3432              && (wd->supportMode & (ZM_WIRELESS_MODE_24_54|ZM_WIRELESS_MODE_24_N)) )
3433         {
3434             /* ERP Information */
3435             wd->erpElement = 0;
3436             // ERP element id
3437             wd->sta.beaconFrameBody[offset++] = ZM_WLAN_EID_ERP ;
3438
3439             // ERP length
3440             wd->sta.beaconFrameBody[offset++] = 1 ;
3441
3442             // ERP information
3443             wd->sta.beaconFrameBody[offset++] = wd->erpElement ;
3444
3445             /* Extended Supported Rates */
3446             if ( (rateSet == ZM_RATE_SET_OFDM)&&((wd->gRate & 0xff) == 0) )
3447             {
3448                 offset += 0 ;
3449             }
3450             else
3451             {
3452                 len = 0 ;
3453
3454                 // Extended Supported Rates element id
3455                 wd->sta.beaconFrameBody[offset++] = ZM_WLAN_EID_EXTENDED_RATE ;
3456
3457                 // Extended Supported Rates length
3458                 lenOffset = offset++ ;
3459
3460                 // Extended Supported Rates information
3461                 for (i=0; i<8; i++)
3462                 {
3463                     if ((wd->gRate & (0x1<<i)) == (0x1<<i))
3464                     {
3465                         wd->sta.beaconFrameBody[offset++] =
3466                                      zg11gRateTbl[i]+((wd->gRateBasic & (0x1<<i))<<(7-i));
3467                         len++;
3468                     }
3469                 }
3470
3471                 // extended support rate length
3472                   wd->sta.beaconFrameBody[lenOffset] = len ;
3473             }
3474         }
3475         #endif
3476
3477         /* RSN : important information influence the result of creating an IBSS network */
3478         if ( wd->sta.authMode == ZM_AUTH_MODE_WPA2PSK )
3479         {
3480             u8_t frameType = ZM_WLAN_FRAME_TYPE_AUTH ;
3481             u8_t    rsn[64]=
3482             {
3483                         /* Element ID */
3484                         0x30,
3485                         /* Length */
3486                         0x14,
3487                         /* Version */
3488                         0x01, 0x00,
3489                         /* Group Cipher Suite, default=TKIP */
3490                         0x00, 0x0f, 0xac, 0x04,
3491                         /* Pairwise Cipher Suite Count */
3492                         0x01, 0x00,
3493                         /* Pairwise Cipher Suite, default=TKIP */
3494                         0x00, 0x0f, 0xac, 0x02,
3495                         /* Authentication and Key Management Suite Count */
3496                         0x01, 0x00,
3497                         /* Authentication type, default=PSK */
3498                         0x00, 0x0f, 0xac, 0x02,
3499                         /* RSN capability */
3500                         0x00, 0x00
3501             };
3502
3503             /* Overwrite Group Cipher Suite by AP's setting */
3504             zfMemoryCopy(rsn+4, zgWpa2AesOui, 4);
3505
3506             if ( wd->sta.wepStatus == ZM_ENCRYPTION_AES )
3507             {
3508                 /* Overwrite Pairwise Cipher Suite by AES */
3509                 zfMemoryCopy(rsn+10, zgWpa2AesOui, 4);
3510             }
3511
3512             // RSN element id
3513             wd->sta.beaconFrameBody[offset++] = ZM_WLAN_EID_RSN_IE ;
3514
3515             // RSN length
3516             wd->sta.beaconFrameBody[offset++] = rsn[1] ;
3517
3518             // RSN information
3519             for(i=0; i<rsn[1]; i++)
3520                 wd->sta.beaconFrameBody[offset++] = rsn[i+2] ;
3521
3522             zfMemoryCopy(wd->sta.rsnIe, rsn, rsn[1]+2);
3523
3524 #ifdef ZM_ENABLE_IBSS_WPA2PSK
3525             /* If not use RSNA , run traditional */
3526             zmw_enter_critical_section(dev);
3527             wd->sta.ibssWpa2Psk = 1;
3528             zmw_leave_critical_section(dev);
3529 #endif
3530         }
3531
3532         #if 0
3533         /* HT Capabilities Info */
3534         {
3535             u8_t OUI[3] = { 0x0 , 0x90 , 0x4C } ;
3536
3537             wd->sta.beaconFrameBody[offset++] = ZM_WLAN_EID_WPA_IE ;
3538
3539             wd->sta.beaconFrameBody[offset++] = wd->sta.HTCap.Data.Length + 4 ;
3540
3541             for (i = 0; i < 3; i++)
3542             {
3543                 wd->sta.beaconFrameBody[offset++] = OUI[i] ;
3544             }
3545
3546             wd->sta.beaconFrameBody[offset++] = wd->sta.HTCap.Data.ElementID ;
3547
3548             for (i = 0; i < 26; i++)
3549             {
3550                 wd->sta.beaconFrameBody[offset++] = wd->sta.HTCap.Byte[i+2] ;
3551             }
3552         }
3553
3554         /* Extended HT Capabilities Info */
3555         {
3556             u8_t OUI[3] = { 0x0 , 0x90 , 0x4C } ;
3557
3558             wd->sta.beaconFrameBody[offset++] = ZM_WLAN_EID_WPA_IE ;
3559
3560             wd->sta.beaconFrameBody[offset++] = wd->sta.ExtHTCap.Data.Length + 4 ;
3561
3562             for (i = 0; i < 3; i++)
3563             {
3564                 wd->sta.beaconFrameBody[offset++] = OUI[i] ;
3565             }
3566
3567             wd->sta.beaconFrameBody[offset++] = wd->sta.ExtHTCap.Data.ElementID ;
3568
3569             for (i = 0; i < 22; i++)
3570             {
3571                 wd->sta.beaconFrameBody[offset++] = wd->sta.ExtHTCap.Byte[i+2] ;
3572             }
3573         }
3574         #endif
3575
3576         wd->sta.beaconFrameBodySize = offset ;
3577
3578         if (wd->sta.beaconFrameBodySize > ZM_CACHED_FRAMEBODY_SIZE)
3579         {
3580             wd->sta.beaconFrameBodySize = ZM_CACHED_FRAMEBODY_SIZE;
3581         }
3582
3583         // 20070416 Let Create IBSS network could enter the zfwIbssPartnerNotify function
3584         // bssNotFound = FALSE ;
3585
3586         printk("The capability info 1 = %02x\n", wd->sta.capability[0]) ;
3587         printk("The capability info 2 = %02x\n", wd->sta.capability[1]) ;
3588         for(k=0; k<wd->sta.beaconFrameBodySize; k++)
3589         {
3590              printk("%02x ", wd->sta.beaconFrameBody[k]) ;
3591         }
3592         #if 0
3593         zmw_enter_critical_section(dev);
3594         zfMemoryCopy(event.bssid, (u8_t *)bssid, 6);
3595         zfMemoryCopy(event.peerMacAddr, (u8_t *)wd->macAddr, 6);
3596         zmw_leave_critical_section(dev);
3597         #endif
3598 #endif
3599
3600         //zmw_enter_critical_section(dev);
3601         //wd->sta.ibssPartnerStatus = ZM_IBSS_PARTNER_LOST;
3602         //zmw_leave_critical_section(dev);
3603     }
3604     else
3605     {
3606         wd->sta.ibssBssIsCreator = 0;
3607     }
3608
3609 connect_done:
3610     zfHpEnableBeacon(dev, ZM_MODE_IBSS, wd->beaconInterval, wd->dtim, (u8_t)wd->sta.atimWindow);
3611     zfStaSendBeacon(dev); // Refresh Beacon content for ZD1211B HalPlus
3612     zfHpSetAtimWindow(dev, wd->sta.atimWindow);
3613
3614     // Start the IBSS timer to monitor for new stations
3615     zmw_enter_critical_section(dev);
3616     zfTimerSchedule(dev, ZM_EVENT_IBSS_MONITOR, ZM_TICK_IBSS_MONITOR);
3617     zmw_leave_critical_section(dev);
3618
3619
3620     if (wd->zfcbConnectNotify != NULL)
3621     {
3622         wd->zfcbConnectNotify(dev, ZM_STATUS_MEDIA_CONNECT, wd->sta.bssid);
3623     }
3624     zfChangeAdapterState(dev, ZM_STA_STATE_CONNECTED);
3625     wd->sta.connPowerInHalfDbm = zfHpGetTransmitPower(dev);
3626
3627 #ifdef ZM_ENABLE_IBSS_DELAYED_JOIN_INDICATION
3628     if ( !bssNotFound )
3629     {
3630         wd->sta.ibssDelayedInd = 1;
3631         zfMemoryCopy((u8_t *)&wd->sta.ibssDelayedIndEvent, (u8_t *)&event, sizeof(struct zsPartnerNotifyEvent));
3632     }
3633 #else
3634     if ( !bssNotFound )
3635     {
3636         if (wd->zfcbIbssPartnerNotify != NULL)
3637         {
3638             wd->zfcbIbssPartnerNotify(dev, 1, &event);
3639         }
3640     }
3641 #endif
3642
3643     return;
3644
3645 retry_ibss:
3646     zfChangeAdapterState(dev, ZM_STA_STATE_CONNECTING);
3647     zfStaConnectFail(dev, ZM_STATUS_MEDIA_DISCONNECT_NOT_FOUND, wd->sta.bssid, 0);
3648     return;
3649 }
3650
3651 void zfStaProcessAtim(zdev_t* dev, zbuf_t* buf)
3652 {
3653     zmw_get_wlan_dev(dev);
3654
3655     zm_debug_msg0("Receiving Atim window notification");
3656
3657     wd->sta.recvAtim = 1;
3658 }
3659
3660 static struct zsBssInfo* zfInfraFindAPToConnect(zdev_t* dev,
3661         struct zsBssInfo* candidateBss)
3662 {
3663     struct zsBssInfo* pBssInfo;
3664     struct zsBssInfo* pNowBssInfo=NULL;
3665     u16_t i;
3666     u16_t ret, apWepStatus;
3667     u32_t k;
3668     u32_t channelFlags;
3669
3670     zmw_get_wlan_dev(dev);
3671     zmw_declare_for_critical_section();
3672
3673     zmw_enter_critical_section(dev);
3674
3675     pBssInfo = wd->sta.bssList.head;
3676
3677     for(i=0; i<wd->sta.bssList.bssCount; i++)
3678     {
3679         if ( pBssInfo->capability[0] & ZM_BIT_4 )
3680         {
3681             apWepStatus = ZM_ENCRYPTION_WEP_ENABLED;
3682         }
3683         else
3684         {
3685             apWepStatus = ZM_ENCRYPTION_WEP_DISABLED;
3686         }
3687
3688         if ( ((zfMemoryIsEqual(&(pBssInfo->ssid[2]), wd->sta.ssid,
3689                                wd->sta.ssidLen))&&
3690               (wd->sta.ssidLen == pBssInfo->ssid[1]))||
3691              ((wd->sta.ssidLen == 0)&&
3692                /* connect to any BSS: AP's ans STA's WEP status must match */
3693               (wd->sta.wepStatus == apWepStatus )&&
3694               (pBssInfo->securityType != ZM_SECURITY_TYPE_WPA) ))
3695         {
3696             if ( wd->sta.ssidLen == 0 )
3697             {
3698                 zm_debug_msg0("ANY BSS found");
3699             }
3700
3701             if ( ((wd->sta.wepStatus == ZM_ENCRYPTION_WEP_DISABLED && apWepStatus == ZM_ENCRYPTION_WEP_ENABLED) ||
3702                  (wd->sta.wepStatus == ZM_ENCRYPTION_WEP_ENABLED &&
3703                  (apWepStatus == ZM_ENCRYPTION_WEP_DISABLED && wd->sta.dropUnencryptedPkts == 1))) &&
3704                  (wd->sta.authMode >= ZM_AUTH_MODE_OPEN && wd->sta.authMode <= ZM_AUTH_MODE_AUTO) )
3705             {
3706                 zm_debug_msg0("Privacy policy is inconsistent");
3707                 pBssInfo = pBssInfo->next;
3708                 continue;
3709             }
3710
3711             /* for WPA negative test */
3712             if ( !zfCheckAuthentication(dev, pBssInfo) )
3713             {
3714                 pBssInfo = pBssInfo->next;
3715                 continue;
3716             }
3717
3718             /* Check bssid */
3719             if (wd->sta.bDesiredBssid == TRUE)
3720             {
3721                 for (k=0; k<6; k++)
3722                 {
3723                     if (wd->sta.desiredBssid[k] != pBssInfo->bssid[k])
3724                     {
3725                         zm_msg0_mm(ZM_LV_1, "desired bssid not matched 1");
3726                         break;
3727                     }
3728                 }
3729
3730                 if (k != 6)
3731                 {
3732                     zm_msg0_mm(ZM_LV_1, "desired bssid not matched 2");
3733                     pBssInfo = pBssInfo->next;
3734                     continue;
3735                 }
3736             }
3737
3738             /* Check support mode */
3739             if (pBssInfo->frequency > 3000) {
3740                 if (   (pBssInfo->EnableHT == 1)
3741                     || (pBssInfo->apCap & ZM_All11N_AP) ) //11n AP
3742                 {
3743                     channelFlags = CHANNEL_A_HT;
3744                     if (pBssInfo->enableHT40 == 1) {
3745                         channelFlags |= CHANNEL_HT40;
3746                     }
3747                 } else {
3748                     channelFlags = CHANNEL_A;
3749                 }
3750             } else {
3751                 if (   (pBssInfo->EnableHT == 1)
3752                     || (pBssInfo->apCap & ZM_All11N_AP) ) //11n AP
3753                 {
3754                     channelFlags = CHANNEL_G_HT;
3755                     if(pBssInfo->enableHT40 == 1) {
3756                         channelFlags |= CHANNEL_HT40;
3757                     }
3758                 } else {
3759                     if (pBssInfo->extSupportedRates[1] == 0) {
3760                         channelFlags = CHANNEL_B;
3761                     } else {
3762                         channelFlags = CHANNEL_G;
3763                     }
3764                 }
3765             }
3766
3767             if (   ((channelFlags == CHANNEL_B) && (wd->connectMode & ZM_BIT_0))
3768                 || ((channelFlags == CHANNEL_G) && (wd->connectMode & ZM_BIT_1))
3769                 || ((channelFlags == CHANNEL_A) && (wd->connectMode & ZM_BIT_2))
3770                 || ((channelFlags & CHANNEL_HT20) && (wd->connectMode & ZM_BIT_3)) )
3771             {
3772                 pBssInfo = pBssInfo->next;
3773                 continue;
3774             }
3775
3776             /* Skip if AP in blocking list */
3777             if ((ret = zfStaIsApInBlockingList(dev, pBssInfo->bssid)) == TRUE)
3778             {
3779                 zm_msg0_mm(ZM_LV_0, "Candidate AP in blocking List, skip if there's stilla choice!");
3780                 pNowBssInfo = pBssInfo;
3781                 pBssInfo = pBssInfo->next;
3782                 continue;
3783             }
3784
3785             if ( pBssInfo->capability[0] & ZM_BIT_0 )  // check if infra-BSS
3786             {
3787                     pNowBssInfo = pBssInfo;
3788                     wd->sta.apWmeCapability = pBssInfo->wmeSupport;
3789
3790
3791                     goto done;
3792             }
3793         }
3794
3795         pBssInfo = pBssInfo->next;
3796     }
3797
3798 done:
3799     if (pNowBssInfo != NULL)
3800     {
3801         zfwMemoryCopy((void*)candidateBss, (void*)pNowBssInfo, sizeof(struct zsBssInfo));
3802         pNowBssInfo = candidateBss;
3803     }
3804
3805     zmw_leave_critical_section(dev);
3806
3807     return pNowBssInfo;
3808 }
3809
3810
3811 void zfInfraConnectNetwork(zdev_t* dev)
3812 {
3813     struct zsBssInfo* pBssInfo;
3814     struct zsBssInfo* pNowBssInfo=NULL;
3815     struct zsBssInfo candidateBss;
3816     //u16_t i, j=100, quality=10000;
3817     //u8_t ret=FALSE, apWepStatus;
3818     u8_t ret=FALSE;
3819     u16_t k;
3820     u8_t density = ZM_MPDU_DENSITY_NONE;
3821
3822     zmw_get_wlan_dev(dev);
3823     zmw_declare_for_critical_section();
3824
3825     /* Reset bssNotFoundCount for Ad-Hoc:IBSS */
3826     /* Need review : IbssConn -> InfraConn -> IbssConn etc, flag/counter reset? */
3827     zmw_enter_critical_section(dev);
3828     wd->sta.bssNotFoundCount = 0;
3829     zmw_leave_critical_section(dev);
3830
3831     /* Set TxQs CWMIN, CWMAX, AIFS and TXO to WME STA default. */
3832     zfUpdateDefaultQosParameter(dev, 0);
3833
3834     zfStaRefreshBlockList(dev, 0);
3835
3836     /* change state to CONNECTING and stop the channel scanning */
3837     zfChangeAdapterState(dev, ZM_STA_STATE_CONNECTING);
3838     zfPowerSavingMgrWakeup(dev);
3839
3840     wd->sta.wmeConnected = 0;
3841     wd->sta.psMgr.tempWakeUp = 0;
3842     wd->sta.qosInfo = 0;
3843     zfQueueFlush(dev, wd->sta.uapsdQ);
3844
3845     wd->sta.connectState = ZM_STA_CONN_STATE_NONE;
3846
3847     //Reorder BssList by RSSI--CWYang(+)
3848     zfBssInfoReorderList(dev);
3849
3850     pNowBssInfo = zfInfraFindAPToConnect(dev, &candidateBss);
3851
3852         if (wd->sta.SWEncryptEnable != 0)
3853         {
3854             if (wd->sta.bSafeMode == 0)
3855             {
3856                     zfStaDisableSWEncryption(dev);//Quickly reboot
3857             }
3858         }
3859     if ( pNowBssInfo != NULL )
3860     {
3861         //zm_assert(pNowBssInfo != NULL);
3862
3863         pBssInfo = pNowBssInfo;
3864         wd->sta.ssidLen = pBssInfo->ssid[1];
3865         zfMemoryCopy(wd->sta.ssid, &(pBssInfo->ssid[2]), pBssInfo->ssid[1]);
3866         wd->frequency = pBssInfo->frequency;
3867         //wd->sta.flagFreqChanging = 1;
3868
3869         //zfCoreSetFrequency(dev, wd->frequency);
3870         zfUpdateBssid(dev, pBssInfo->bssid);
3871         zfResetSupportRate(dev, ZM_DEFAULT_SUPPORT_RATE_ZERO);
3872         zfUpdateSupportRate(dev, pBssInfo->supportedRates);
3873         zfUpdateSupportRate(dev, pBssInfo->extSupportedRates);
3874
3875         wd->beaconInterval = pBssInfo->beaconInterval[0] +
3876                              (((u16_t) pBssInfo->beaconInterval[1]) << 8);
3877         if (wd->beaconInterval == 0)
3878         {
3879             wd->beaconInterval = 100;
3880         }
3881
3882         /* ESS bit on */
3883         wd->sta.capability[0] |= ZM_BIT_0;
3884         /* IBSS bit off */
3885         wd->sta.capability[0] &= ~ZM_BIT_1;
3886
3887         /* 11n AP flag */
3888         wd->sta.EnableHT = pBssInfo->EnableHT;
3889         wd->sta.SG40 = pBssInfo->SG40;
3890 #ifdef ZM_ENABLE_CENC
3891         if ( pBssInfo->securityType == ZM_SECURITY_TYPE_CENC )
3892         {
3893             wd->sta.wmeEnabled = 0; //Disable WMM in CENC
3894             cencInit(dev);
3895             cencSetCENCMode(dev, NdisCENC_PSK);
3896             wd->sta.wpaState = ZM_STA_WPA_STATE_INIT;
3897             /* CENC */
3898             if ( pBssInfo->cencIe[1] != 0 )
3899             {
3900                 //wd->sta.wepStatus = ZM_ENCRYPTION_CENC;
3901                 //wd->sta.encryMode = ZM_CENC;
3902                 zfwCencHandleBeaconProbrespon(dev, (u8_t *)&pBssInfo->cencIe,
3903                         (u8_t *)&pBssInfo->ssid, (u8_t *)&pBssInfo->macaddr);
3904                 zfMemoryCopy(wd->sta.cencIe, pBssInfo->cencIe,
3905                         pBssInfo->cencIe[1]+2);
3906             }
3907             else
3908             {
3909                 wd->sta.cencIe[1] = 0;
3910             }
3911         }
3912 #endif //ZM_ENABLE_CENC
3913         if ( pBssInfo->securityType == ZM_SECURITY_TYPE_WPA )
3914         {
3915             wd->sta.wpaState = ZM_STA_WPA_STATE_INIT;
3916
3917             if ( wd->sta.wepStatus == ZM_ENCRYPTION_TKIP )
3918             {
3919                 wd->sta.encryMode = ZM_TKIP;
3920
3921                 /* Turn on software encryption/decryption for TKIP */
3922                 if (wd->sta.EnableHT == 1)
3923                 {
3924                     zfStaEnableSWEncryption(dev, (ZM_SW_TKIP_ENCRY_EN|ZM_SW_TKIP_DECRY_EN));
3925                 }
3926
3927                 /* Do not support TKIP in 11n mode */
3928                 //wd->sta.EnableHT = 0;
3929                 //pBssInfo->enableHT40 = 0;
3930             }
3931             else if ( wd->sta.wepStatus == ZM_ENCRYPTION_AES )
3932             {
3933                 wd->sta.encryMode = ZM_AES;
3934
3935                 /* If AP supports HT mode */
3936                 if (wd->sta.EnableHT)
3937                 {
3938                     /* Set MPDU density to 8 us*/
3939                     density = ZM_MPDU_DENSITY_8US;
3940                 }
3941             }
3942
3943             if ( pBssInfo->wpaIe[1] != 0 )
3944             {
3945                 zfMemoryCopy(wd->sta.wpaIe, pBssInfo->wpaIe,
3946                              pBssInfo->wpaIe[1]+2);
3947             }
3948             else
3949             {
3950                 wd->sta.wpaIe[1] = 0;
3951             }
3952
3953             if ( pBssInfo->rsnIe[1] != 0 )
3954             {
3955                 zfMemoryCopy(wd->sta.rsnIe, pBssInfo->rsnIe,
3956                              pBssInfo->rsnIe[1]+2);
3957             }
3958             else
3959             {
3960                 wd->sta.rsnIe[1] = 0;
3961             }
3962         }
3963
3964
3965
3966         /* check preamble bit */
3967         wd->preambleTypeInUsed = wd->preambleType;
3968         if ( wd->preambleTypeInUsed == ZM_PREAMBLE_TYPE_AUTO )
3969         {
3970             if (pBssInfo->capability[0] & ZM_BIT_5)
3971             {
3972                 wd->preambleTypeInUsed = ZM_PREAMBLE_TYPE_SHORT;
3973             }
3974             else
3975             {
3976                 wd->preambleTypeInUsed = ZM_PREAMBLE_TYPE_LONG;
3977             }
3978         }
3979
3980         if (wd->preambleTypeInUsed == ZM_PREAMBLE_TYPE_LONG)
3981         {
3982             wd->sta.capability[0] &= ~ZM_BIT_5;
3983         }
3984         else
3985         {
3986             wd->sta.capability[0] |= ZM_BIT_5;
3987         }
3988
3989         /* check 802.11n 40MHz Setting */
3990         if ((pBssInfo->enableHT40 == 1) &&
3991             ((pBssInfo->extChOffset == 1) || (pBssInfo->extChOffset == 3)))
3992         {
3993             wd->BandWidth40 = pBssInfo->enableHT40;
3994             wd->ExtOffset = pBssInfo->extChOffset;
3995         }
3996         else
3997         {
3998             wd->BandWidth40 = 0;
3999             wd->ExtOffset = 0;
4000         }
4001
4002         /* check 802.11H support bit */
4003
4004         /* check Owl Ap */
4005         if ( pBssInfo->athOwlAp & ZM_BIT_0 )
4006         {
4007             /* In this function, FW retry will be enable, ZM_MAC_REG_RETRY_MAX
4008                will be set to 0.
4009              */
4010             zfHpDisableHwRetry(dev);
4011             wd->sta.athOwlAp = 1;
4012             /* Set MPDU density to 8 us*/
4013             density = ZM_MPDU_DENSITY_8US;
4014         }
4015         else
4016         {
4017             /* In this function, FW retry will be disable, ZM_MAC_REG_RETRY_MAX
4018                will be set to 3.
4019              */
4020             zfHpEnableHwRetry(dev);
4021             wd->sta.athOwlAp = 0;
4022         }
4023         wd->reorder = 1;
4024
4025         /* Set MPDU density */
4026         zfHpSetMPDUDensity(dev, density);
4027
4028         /* check short slot time bit */
4029         if ( pBssInfo->capability[1] & ZM_BIT_2 )
4030         {
4031             wd->sta.capability[1] |= ZM_BIT_2;
4032         }
4033
4034         if ( pBssInfo->erp & ZM_BIT_1 )
4035         {
4036             //zm_debug_msg0("protection mode on");
4037             wd->sta.bProtectionMode = TRUE;
4038             zfHpSetSlotTime(dev, 0);
4039         }
4040         else
4041         {
4042             //zm_debug_msg0("protection mode off");
4043             wd->sta.bProtectionMode = FALSE;
4044             zfHpSetSlotTime(dev, 1);
4045         }
4046
4047         if (pBssInfo->marvelAp == 1)
4048         {
4049             wd->sta.enableDrvBA = 0;
4050             /*
4051              * 8701 : NetGear 3500 (MARVELL)
4052              * Downlink issue : set slottime to 20.
4053              */
4054             zfHpSetSlotTimeRegister(dev, 0);
4055         }
4056         else
4057         {
4058             wd->sta.enableDrvBA = 1;
4059
4060             /*
4061              * This is not good for here do reset slot time.
4062              * I think it should reset when leave MARVELL ap
4063              * or enter disconnect state etc.
4064              */
4065             zfHpSetSlotTimeRegister(dev, 1);
4066         }
4067
4068         //Store probe response frame body, for VISTA only
4069         wd->sta.beaconFrameBodySize = pBssInfo->frameBodysize + 12;
4070         if (wd->sta.beaconFrameBodySize > ZM_CACHED_FRAMEBODY_SIZE)
4071         {
4072             wd->sta.beaconFrameBodySize = ZM_CACHED_FRAMEBODY_SIZE;
4073         }
4074         for (k=0; k<8; k++)
4075         {
4076             wd->sta.beaconFrameBody[k] = pBssInfo->timeStamp[k];
4077         }
4078         wd->sta.beaconFrameBody[8] = pBssInfo->beaconInterval[0];
4079         wd->sta.beaconFrameBody[9] = pBssInfo->beaconInterval[1];
4080         wd->sta.beaconFrameBody[10] = pBssInfo->capability[0];
4081         wd->sta.beaconFrameBody[11] = pBssInfo->capability[1];
4082         for (k=0; k<(wd->sta.beaconFrameBodySize - 12); k++)
4083         {
4084             wd->sta.beaconFrameBody[k+12] = pBssInfo->frameBody[k];
4085         }
4086
4087         if ( ( pBssInfo->capability[0] & ZM_BIT_4 )&&
4088              (( wd->sta.authMode == ZM_AUTH_MODE_OPEN )||
4089               ( wd->sta.authMode == ZM_AUTH_MODE_SHARED_KEY)||
4090               (wd->sta.authMode == ZM_AUTH_MODE_AUTO)) )
4091         {   /* privacy enabled */
4092
4093             if ( wd->sta.wepStatus == ZM_ENCRYPTION_WEP_DISABLED )
4094             {
4095                 zm_debug_msg0("Adapter is no WEP, try to connect to WEP AP");
4096                 ret = FALSE;
4097             }
4098
4099             /* Do not support WEP in 11n mode */
4100             if ( wd->sta.wepStatus == ZM_ENCRYPTION_WEP_ENABLED )
4101             {
4102                 /* Turn on software encryption/decryption for WEP */
4103                 if (wd->sta.EnableHT == 1)
4104                 {
4105                     zfStaEnableSWEncryption(dev, (ZM_SW_WEP_ENCRY_EN|ZM_SW_WEP_DECRY_EN));
4106                 }
4107
4108                 //wd->sta.EnableHT = 0;
4109                 //wd->BandWidth40 = 0;
4110                 //wd->ExtOffset = 0;
4111             }
4112
4113             wd->sta.capability[0] |= ZM_BIT_4;
4114
4115             if ( wd->sta.authMode == ZM_AUTH_MODE_AUTO )
4116             { /* Try to use open and shared-key authehtication alternatively */
4117                 if ( (wd->sta.connectTimeoutCount % 2) == 0 )
4118                     wd->sta.bIsSharedKey = 0;
4119                 else
4120                     wd->sta.bIsSharedKey = 1;
4121             }
4122             else if ( wd->sta.authMode != ZM_AUTH_MODE_SHARED_KEY )
4123             {   /* open  or auto */
4124                 //zfStaStartConnect(dev, 0);
4125                 wd->sta.bIsSharedKey = 0;
4126             }
4127             else if ( wd->sta.authMode != ZM_AUTH_MODE_OPEN )
4128             {   /* shared key */
4129                 //zfStaStartConnect(dev, 1) ;
4130                 wd->sta.bIsSharedKey = 1;
4131             }
4132         }
4133         else
4134         {
4135             if ( (pBssInfo->securityType == ZM_SECURITY_TYPE_WPA)||
4136                  (pBssInfo->capability[0] & ZM_BIT_4) )
4137             {
4138                 wd->sta.capability[0] |= ZM_BIT_4;
4139                 /* initialize WPA related parameters */
4140             }
4141             else
4142             {
4143                 wd->sta.capability[0] &= (~ZM_BIT_4);
4144             }
4145
4146             /* authentication with open system */
4147             //zfStaStartConnect(dev, 0);
4148             wd->sta.bIsSharedKey = 0;
4149         }
4150
4151         /* Improve WEP/TKIP performance with HT AP, detail information please look bug#32495 */
4152         /*
4153         if ( (pBssInfo->broadcomHTAp == 1)
4154              && (wd->sta.SWEncryptEnable != 0) )
4155         {
4156             zfHpSetTTSIFSTime(dev, 0xa);
4157         }
4158         else
4159         {
4160             zfHpSetTTSIFSTime(dev, 0x8);
4161         }
4162         */
4163     }
4164     else
4165     {
4166         zm_debug_msg0("Desired SSID not found");
4167         goto zlConnectFailed;
4168     }
4169
4170
4171     zfCoreSetFrequencyV2(dev, wd->frequency, zfStaStartConnectCb);
4172     return;
4173
4174 zlConnectFailed:
4175     zfStaConnectFail(dev, ZM_STATUS_MEDIA_DISCONNECT_NOT_FOUND, wd->sta.bssid, 0);
4176     return;
4177 }
4178
4179 u8_t zfCheckWPAAuth(zdev_t* dev, struct zsBssInfo* pBssInfo)
4180 {
4181     u8_t   ret=TRUE;
4182     u8_t   pmkCount;
4183     u8_t   i;
4184     u16_t   encAlgoType = 0;
4185
4186     zmw_get_wlan_dev(dev);
4187
4188     if ( wd->sta.wepStatus == ZM_ENCRYPTION_TKIP )
4189     {
4190         encAlgoType = ZM_TKIP;
4191     }
4192     else if ( wd->sta.wepStatus == ZM_ENCRYPTION_AES )
4193     {
4194         encAlgoType = ZM_AES;
4195     }
4196
4197     switch(wd->sta.authMode)
4198     {
4199         case ZM_AUTH_MODE_WPA:
4200         case ZM_AUTH_MODE_WPAPSK:
4201             if ( pBssInfo->wpaIe[1] == 0 )
4202             {
4203                 ret = FALSE;
4204                 break;
4205             }
4206
4207             pmkCount = pBssInfo->wpaIe[12];
4208             for(i=0; i < pmkCount; i++)
4209             {
4210                 if ( pBssInfo->wpaIe[17 + 4*i] == encAlgoType )
4211                 {
4212                     ret = TRUE;
4213                     goto done;
4214                 }
4215             }
4216
4217             ret = FALSE;
4218             break;
4219
4220         case ZM_AUTH_MODE_WPA2:
4221         case ZM_AUTH_MODE_WPA2PSK:
4222             if ( pBssInfo->rsnIe[1] == 0 )
4223             {
4224                 ret = FALSE;
4225                 break;
4226             }
4227
4228             pmkCount = pBssInfo->rsnIe[8];
4229             for(i=0; i < pmkCount; i++)
4230             {
4231                 if ( pBssInfo->rsnIe[13 + 4*i] == encAlgoType )
4232                 {
4233                     ret = TRUE;
4234                     goto done;
4235                 }
4236             }
4237
4238             ret = FALSE;
4239             break;
4240     }
4241
4242 done:
4243     return ret;
4244 }
4245
4246 u8_t zfCheckAuthentication(zdev_t* dev, struct zsBssInfo* pBssInfo)
4247 {
4248     u8_t   ret=TRUE;
4249     u16_t  encAlgoType;
4250     u16_t UnicastCipherNum;
4251
4252     zmw_get_wlan_dev(dev);
4253
4254     /* Connecting to ANY has been checked */
4255     if ( wd->sta.ssidLen == 0 )
4256     {
4257         return ret;
4258     }
4259
4260
4261         switch(wd->sta.authMode)
4262         //switch(wd->ws.authMode)//Quickly reboot
4263     {
4264         case ZM_AUTH_MODE_WPA_AUTO:
4265         case ZM_AUTH_MODE_WPAPSK_AUTO:
4266             encAlgoType = 0;
4267             if(pBssInfo->rsnIe[1] != 0)
4268             {
4269                 UnicastCipherNum = (pBssInfo->rsnIe[8]) +
4270                                    (pBssInfo->rsnIe[9] << 8);
4271
4272                 /* If there is only one unicast cipher */
4273                 if (UnicastCipherNum == 1)
4274                 {
4275                     encAlgoType = pBssInfo->rsnIe[13];
4276                     //encAlgoType = pBssInfo->rsnIe[7];
4277                 }
4278                 else
4279                 {
4280                     u16_t ii;
4281                     u16_t desiredCipher = 0;
4282                     u16_t IEOffSet = 13;
4283
4284                     /* Enumerate all the supported unicast cipher */
4285                     for (ii = 0; ii < UnicastCipherNum; ii++)
4286                     {
4287                         if (pBssInfo->rsnIe[IEOffSet+ii*4] > desiredCipher)
4288                         {
4289                             desiredCipher = pBssInfo->rsnIe[IEOffSet+ii*4];
4290                         }
4291                     }
4292
4293                     encAlgoType = desiredCipher;
4294                 }
4295
4296                 if ( encAlgoType == 0x02 )
4297                 {
4298                             wd->sta.wepStatus = ZM_ENCRYPTION_TKIP;
4299
4300                             if ( wd->sta.authMode == ZM_AUTH_MODE_WPA_AUTO )
4301                     {
4302                         wd->sta.currentAuthMode = ZM_AUTH_MODE_WPA2;
4303                     }
4304                     else //ZM_AUTH_MODE_WPAPSK_AUTO
4305                     {
4306                         wd->sta.currentAuthMode = ZM_AUTH_MODE_WPA2PSK;
4307                     }
4308                 }
4309                 else if ( encAlgoType == 0x04 )
4310                 {
4311                     wd->sta.wepStatus = ZM_ENCRYPTION_AES;
4312
4313                     if ( wd->sta.authMode == ZM_AUTH_MODE_WPA_AUTO )
4314                     {
4315                         wd->sta.currentAuthMode = ZM_AUTH_MODE_WPA2;
4316                     }
4317                     else //ZM_AUTH_MODE_WPAPSK_AUTO
4318                     {
4319                         wd->sta.currentAuthMode = ZM_AUTH_MODE_WPA2PSK;
4320                     }
4321                 }
4322                 else
4323                 {
4324                     ret = FALSE;
4325                 }
4326             }
4327             else if(pBssInfo->wpaIe[1] != 0)
4328             {
4329                 UnicastCipherNum = (pBssInfo->wpaIe[12]) +
4330                                    (pBssInfo->wpaIe[13] << 8);
4331
4332                 /* If there is only one unicast cipher */
4333                 if (UnicastCipherNum == 1)
4334                 {
4335                     encAlgoType = pBssInfo->wpaIe[17];
4336                     //encAlgoType = pBssInfo->wpaIe[11];
4337                 }
4338                 else
4339                 {
4340                     u16_t ii;
4341                     u16_t desiredCipher = 0;
4342                     u16_t IEOffSet = 17;
4343
4344                     /* Enumerate all the supported unicast cipher */
4345                     for (ii = 0; ii < UnicastCipherNum; ii++)
4346                     {
4347                         if (pBssInfo->wpaIe[IEOffSet+ii*4] > desiredCipher)
4348                         {
4349                             desiredCipher = pBssInfo->wpaIe[IEOffSet+ii*4];
4350                         }
4351                     }
4352
4353                     encAlgoType = desiredCipher;
4354                 }
4355
4356                 if ( encAlgoType == 0x02 )
4357                 {
4358                             wd->sta.wepStatus = ZM_ENCRYPTION_TKIP;
4359
4360                             if ( wd->sta.authMode == ZM_AUTH_MODE_WPA_AUTO )
4361                     {
4362                         wd->sta.currentAuthMode = ZM_AUTH_MODE_WPA;
4363                     }
4364                     else //ZM_AUTH_MODE_WPAPSK_AUTO
4365                     {
4366                         wd->sta.currentAuthMode = ZM_AUTH_MODE_WPAPSK;
4367                     }
4368                 }
4369                 else if ( encAlgoType == 0x04 )
4370                 {
4371                     wd->sta.wepStatus = ZM_ENCRYPTION_AES;
4372
4373                     if ( wd->sta.authMode == ZM_AUTH_MODE_WPA_AUTO )
4374                     {
4375                         wd->sta.currentAuthMode = ZM_AUTH_MODE_WPA;
4376                     }
4377                     else //ZM_AUTH_MODE_WPAPSK_AUTO
4378                     {
4379                         wd->sta.currentAuthMode = ZM_AUTH_MODE_WPAPSK;
4380                     }
4381                 }
4382                 else
4383                 {
4384                     ret = FALSE;
4385                 }
4386
4387
4388             }
4389             else
4390             {
4391                 ret = FALSE;
4392             }
4393
4394             break;
4395
4396         case ZM_AUTH_MODE_WPA:
4397         case ZM_AUTH_MODE_WPAPSK:
4398         case ZM_AUTH_MODE_WPA_NONE:
4399         case ZM_AUTH_MODE_WPA2:
4400         case ZM_AUTH_MODE_WPA2PSK:
4401             {
4402                 if ( pBssInfo->securityType != ZM_SECURITY_TYPE_WPA )
4403                 {
4404                     ret = FALSE;
4405                 }
4406
4407                 ret = zfCheckWPAAuth(dev, pBssInfo);
4408             }
4409             break;
4410
4411         case ZM_AUTH_MODE_OPEN:
4412         case ZM_AUTH_MODE_SHARED_KEY:
4413         case ZM_AUTH_MODE_AUTO:
4414             {
4415                 if ( pBssInfo->wscIe[1] )
4416                 {
4417                     // If the AP is a Jumpstart AP, it's ok!! Ray
4418                     break;
4419                 }
4420                 else if ( pBssInfo->securityType == ZM_SECURITY_TYPE_WPA )
4421                 {
4422                     ret = FALSE;
4423                 }
4424             }
4425             break;
4426
4427         default:
4428             break;
4429     }
4430
4431     return ret;
4432 }
4433
4434 u8_t zfStaIsConnected(zdev_t* dev)
4435 {
4436     zmw_get_wlan_dev(dev);
4437
4438     if ( wd->sta.adapterState == ZM_STA_STATE_CONNECTED )
4439     {
4440         return TRUE;
4441     }
4442
4443     return FALSE;
4444 }
4445
4446 u8_t zfStaIsConnecting(zdev_t* dev)
4447 {
4448     zmw_get_wlan_dev(dev);
4449
4450     if ( wd->sta.adapterState == ZM_STA_STATE_CONNECTING )
4451     {
4452         return TRUE;
4453     }
4454
4455     return FALSE;
4456 }
4457
4458 u8_t zfStaIsDisconnect(zdev_t* dev)
4459 {
4460     zmw_get_wlan_dev(dev);
4461
4462     if ( wd->sta.adapterState == ZM_STA_STATE_DISCONNECT )
4463     {
4464         return TRUE;
4465     }
4466
4467     return FALSE;
4468 }
4469
4470 u8_t zfChangeAdapterState(zdev_t* dev, u8_t newState)
4471 {
4472     u8_t ret = TRUE;
4473
4474     zmw_get_wlan_dev(dev);
4475
4476     zmw_declare_for_critical_section();
4477
4478     //if ( newState == wd->sta.adapterState )
4479     //{
4480     //    return FALSE;
4481     //}
4482
4483     switch(newState)
4484     {
4485     case ZM_STA_STATE_DISCONNECT:
4486         zfResetSupportRate(dev, ZM_DEFAULT_SUPPORT_RATE_DISCONNECT);
4487
4488         #if 1
4489             zfScanMgrScanStop(dev, ZM_SCAN_MGR_SCAN_INTERNAL);
4490         #else
4491             if ( wd->sta.bChannelScan )
4492             {
4493                 /* stop the action of channel scanning */
4494                 wd->sta.bChannelScan = FALSE;
4495                 ret =  TRUE;
4496                 break;
4497             }
4498         #endif
4499
4500         break;
4501     case ZM_STA_STATE_CONNECTING:
4502         #if 1
4503             zfScanMgrScanStop(dev, ZM_SCAN_MGR_SCAN_INTERNAL);
4504         #else
4505             if ( wd->sta.bChannelScan )
4506             {
4507                 /* stop the action of channel scanning */
4508                 wd->sta.bChannelScan = FALSE;
4509                 ret =  TRUE;
4510                 break;
4511             }
4512         #endif
4513
4514         break;
4515     case ZM_STA_STATE_CONNECTED:
4516         break;
4517     default:
4518         break;
4519     }
4520
4521     //if ( ret )
4522     //{
4523         zmw_enter_critical_section(dev);
4524         wd->sta.adapterState = newState;
4525         zmw_leave_critical_section(dev);
4526
4527         zm_debug_msg1("change adapter state = ", newState);
4528     //}
4529
4530     return ret;
4531 }
4532
4533 /************************************************************************/
4534 /*                                                                      */
4535 /*    FUNCTION DESCRIPTION                  zfStaMmAddIeSsid            */
4536 /*      Add information element SSID to buffer.                         */
4537 /*                                                                      */
4538 /*    INPUTS                                                            */
4539 /*      dev : device pointer                                            */
4540 /*      buf : buffer to add information element                         */
4541 /*      offset : add information element from this offset               */
4542 /*                                                                      */
4543 /*    OUTPUTS                                                           */
4544 /*      buffer offset after adding information element                  */
4545 /*                                                                      */
4546 /*    AUTHOR                                                            */
4547 /*      Ji-Huang Lee        ZyDAS Technology Corporation    2005.11     */
4548 /*                                                                      */
4549 /************************************************************************/
4550 u16_t zfStaAddIeSsid(zdev_t* dev, zbuf_t* buf, u16_t offset)
4551 {
4552     u16_t i;
4553
4554     zmw_get_wlan_dev(dev);
4555
4556     /* Element ID */
4557     zmw_tx_buf_writeb(dev, buf, offset++, ZM_WLAN_EID_SSID);
4558
4559     /* Element Length */
4560     zmw_tx_buf_writeb(dev, buf, offset++, wd->sta.ssidLen);
4561
4562     /* Information : SSID */
4563     for (i=0; i<wd->sta.ssidLen; i++)
4564     {
4565         zmw_tx_buf_writeb(dev, buf, offset++, wd->sta.ssid[i]);
4566     }
4567
4568     return offset;
4569 }
4570
4571 /************************************************************************/
4572 /*                                                                      */
4573 /*    FUNCTION DESCRIPTION                  zfStaMmAddIeWpa             */
4574 /*      Add information element SSID to buffer.                         */
4575 /*                                                                      */
4576 /*    INPUTS                                                            */
4577 /*      dev : device pointer                                            */
4578 /*      buf : buffer to add information element                         */
4579 /*      offset : add information element from this offset               */
4580 /*                                                                      */
4581 /*    OUTPUTS                                                           */
4582 /*      buffer offset after adding information element                  */
4583 /*                                                                      */
4584 /*    AUTHOR                                                            */
4585 /*      Ji-Huang Lee        ZyDAS Technology Corporation    2006.01     */
4586 /*                                                                      */
4587 /************************************************************************/
4588 u16_t zfStaAddIeWpaRsn(zdev_t* dev, zbuf_t* buf, u16_t offset, u8_t frameType)
4589 {
4590     u32_t  i;
4591     u8_t    ssn[64]={
4592                         /* Element ID */
4593                         0xdd,
4594                         /* Length */
4595                         0x18,
4596                         /* OUI type */
4597                         0x00, 0x50, 0xf2, 0x01,
4598                         /* Version */
4599                         0x01, 0x00,
4600                         /* Group Cipher Suite, default=TKIP */
4601                         0x00, 0x50, 0xf2, 0x02,
4602                         /* Pairwise Cipher Suite Count */
4603                         0x01, 0x00,
4604                         /* Pairwise Cipher Suite, default=TKIP */
4605                         0x00, 0x50, 0xf2, 0x02,
4606                         /* Authentication and Key Management Suite Count */
4607                         0x01, 0x00,
4608                         /* Authentication type, default=PSK */
4609                         0x00, 0x50, 0xf2, 0x02,
4610                         /* WPA capability */
4611                         0x00, 0x00
4612                     };
4613
4614     u8_t    rsn[64]={
4615                         /* Element ID */
4616                         0x30,
4617                         /* Length */
4618                         0x14,
4619                         /* Version */
4620                         0x01, 0x00,
4621                         /* Group Cipher Suite, default=TKIP */
4622                         0x00, 0x0f, 0xac, 0x02,
4623                         /* Pairwise Cipher Suite Count */
4624                         0x01, 0x00,
4625                         /* Pairwise Cipher Suite, default=TKIP */
4626                         0x00, 0x0f, 0xac, 0x02,
4627                         /* Authentication and Key Management Suite Count */
4628                         0x01, 0x00,
4629                         /* Authentication type, default=PSK */
4630                         0x00, 0x0f, 0xac, 0x02,
4631                         /* RSN capability */
4632                         0x00, 0x00
4633                     };
4634
4635     zmw_get_wlan_dev(dev);
4636
4637     if ( wd->sta.currentAuthMode == ZM_AUTH_MODE_WPAPSK )
4638     {
4639         /* Overwrite Group Cipher Suite by AP's setting */
4640         zfMemoryCopy(ssn+8, wd->sta.wpaIe+8, 4);
4641
4642         if ( wd->sta.wepStatus == ZM_ENCRYPTION_AES )
4643         {
4644             /* Overwrite Pairwise Cipher Suite by AES */
4645             zfMemoryCopy(ssn+14, zgWpaAesOui, 4);
4646         }
4647
4648         zfCopyToIntTxBuffer(dev, buf, ssn, offset, ssn[1]+2);
4649         zfMemoryCopy(wd->sta.wpaIe, ssn, ssn[1]+2);
4650         offset += (ssn[1]+2);
4651     }
4652     else if ( wd->sta.currentAuthMode == ZM_AUTH_MODE_WPA )
4653     {
4654         /* Overwrite Group Cipher Suite by AP's setting */
4655         zfMemoryCopy(ssn+8, wd->sta.wpaIe+8, 4);
4656         /* Overwrite Key Management Suite by WPA-Radius */
4657         zfMemoryCopy(ssn+20, zgWpaRadiusOui, 4);
4658
4659         if ( wd->sta.wepStatus == ZM_ENCRYPTION_AES )
4660         {
4661             /* Overwrite Pairwise Cipher Suite by AES */
4662             zfMemoryCopy(ssn+14, zgWpaAesOui, 4);
4663         }
4664
4665         zfCopyToIntTxBuffer(dev, buf, ssn, offset, ssn[1]+2);
4666         zfMemoryCopy(wd->sta.wpaIe, ssn, ssn[1]+2);
4667         offset += (ssn[1]+2);
4668     }
4669     else if ( wd->sta.currentAuthMode == ZM_AUTH_MODE_WPA2PSK )
4670     {
4671         /* Overwrite Group Cipher Suite by AP's setting */
4672         zfMemoryCopy(rsn+4, wd->sta.rsnIe+4, 4);
4673
4674         if ( wd->sta.wepStatus == ZM_ENCRYPTION_AES )
4675         {
4676             /* Overwrite Pairwise Cipher Suite by AES */
4677             zfMemoryCopy(rsn+10, zgWpa2AesOui, 4);
4678         }
4679
4680         if ( frameType == ZM_WLAN_FRAME_TYPE_REASOCREQ )
4681         {
4682             for(i=0; i<wd->sta.pmkidInfo.bssidCount; i++)
4683             {
4684                 if ( zfMemoryIsEqual((u8_t*) wd->sta.pmkidInfo.bssidInfo[i].bssid,
4685                                      (u8_t*) wd->sta.bssid, 6) )
4686                 {
4687                     /* matched */
4688                     break;
4689                 }
4690
4691                 if ( i < wd->sta.pmkidInfo.bssidCount )
4692                 {
4693                     // Fill PMKID Count in RSN information element
4694                     rsn[22] = 0x01;
4695                     rsn[23] = 0x00;
4696
4697                     // Fill PMKID in RSN information element
4698                     zfMemoryCopy(rsn+24,
4699                                  wd->sta.pmkidInfo.bssidInfo[i].pmkid, 16);
4700                                          rsn[1] += 18;
4701                 }
4702             }
4703         }
4704
4705         zfCopyToIntTxBuffer(dev, buf, rsn, offset, rsn[1]+2);
4706         zfMemoryCopy(wd->sta.rsnIe, rsn, rsn[1]+2);
4707         offset += (rsn[1]+2);
4708     }
4709     else if ( wd->sta.currentAuthMode == ZM_AUTH_MODE_WPA2 )
4710     {
4711         /* Overwrite Group Cipher Suite by AP's setting */
4712         zfMemoryCopy(rsn+4, wd->sta.rsnIe+4, 4);
4713         /* Overwrite Key Management Suite by WPA2-Radius */
4714         zfMemoryCopy(rsn+16, zgWpa2RadiusOui, 4);
4715
4716         if ( wd->sta.wepStatus == ZM_ENCRYPTION_AES )
4717         {
4718             /* Overwrite Pairwise Cipher Suite by AES */
4719             zfMemoryCopy(rsn+10, zgWpa2AesOui, 4);
4720         }
4721
4722         if (( frameType == ZM_WLAN_FRAME_TYPE_REASOCREQ || ( frameType == ZM_WLAN_FRAME_TYPE_ASOCREQ )))
4723         {
4724
4725             if (wd->sta.pmkidInfo.bssidCount != 0) {
4726                 // Fill PMKID Count in RSN information element
4727                 rsn[22] = 1;
4728                 rsn[23] = 0;
4729                 /*
4730                  *  The caller is respnsible to give us the relevant PMKID.
4731                  *  We'll only accept 1 PMKID for now.
4732                  */
4733                 for(i=0; i<wd->sta.pmkidInfo.bssidCount; i++)
4734                 {
4735                     if ( zfMemoryIsEqual((u8_t*) wd->sta.pmkidInfo.bssidInfo[i].bssid, (u8_t*) wd->sta.bssid, 6) )
4736                     {
4737                         zfMemoryCopy(rsn+24, wd->sta.pmkidInfo.bssidInfo[i].pmkid, 16);
4738                         break;
4739                     }
4740                 }
4741                 rsn[1] += 18;
4742             }
4743
4744         }
4745
4746         zfCopyToIntTxBuffer(dev, buf, rsn, offset, rsn[1]+2);
4747         zfMemoryCopy(wd->sta.rsnIe, rsn, rsn[1]+2);
4748         offset += (rsn[1]+2);
4749     }
4750
4751     return offset;
4752 }
4753
4754 /************************************************************************/
4755 /*                                                                      */
4756 /*    FUNCTION DESCRIPTION                  zfStaAddIeIbss              */
4757 /*      Add information element IBSS parameter to buffer.               */
4758 /*                                                                      */
4759 /*    INPUTS                                                            */
4760 /*      dev : device pointer                                            */
4761 /*      buf : buffer to add information element                         */
4762 /*      offset : add information element from this offset               */
4763 /*                                                                      */
4764 /*    OUTPUTS                                                           */
4765 /*      buffer offset after adding information element                  */
4766 /*                                                                      */
4767 /*    AUTHOR                                                            */
4768 /*      Ji-Huang Lee        ZyDAS Technology Corporation    2005.12     */
4769 /*                                                                      */
4770 /************************************************************************/
4771 u16_t zfStaAddIeIbss(zdev_t* dev, zbuf_t* buf, u16_t offset)
4772 {
4773     zmw_get_wlan_dev(dev);
4774
4775     /* Element ID */
4776     zmw_tx_buf_writeb(dev, buf, offset++, ZM_WLAN_EID_IBSS);
4777
4778     /* Element Length */
4779     zmw_tx_buf_writeb(dev, buf, offset++, 2);
4780
4781     /* ATIM window */
4782     zmw_tx_buf_writeh(dev, buf, offset, wd->sta.atimWindow);
4783     offset += 2;
4784
4785     return offset;
4786 }
4787
4788
4789
4790 /************************************************************************/
4791 /*                                                                      */
4792 /*    FUNCTION DESCRIPTION                  zfStaAddIeWmeInfo           */
4793 /*      Add WME Information Element to buffer.                          */
4794 /*                                                                      */
4795 /*    INPUTS                                                            */
4796 /*      dev : device pointer                                            */
4797 /*      buf : buffer to add information element                         */
4798 /*      offset : add information element from this offset               */
4799 /*                                                                      */
4800 /*    OUTPUTS                                                           */
4801 /*      buffer offset after adding information element                  */
4802 /*                                                                      */
4803 /*    AUTHOR                                                            */
4804 /*      Stephen Chen        ZyDAS Technology Corporation    2006.6      */
4805 /*                                                                      */
4806 /************************************************************************/
4807 u16_t zfStaAddIeWmeInfo(zdev_t* dev, zbuf_t* buf, u16_t offset, u8_t qosInfo)
4808 {
4809     /* Element ID */
4810     zmw_tx_buf_writeb(dev, buf, offset++, ZM_WLAN_EID_WIFI_IE);
4811
4812     /* Element Length */
4813     zmw_tx_buf_writeb(dev, buf, offset++, 7);
4814
4815     /* OUI */
4816     zmw_tx_buf_writeb(dev, buf, offset++, 0x00);
4817     zmw_tx_buf_writeb(dev, buf, offset++, 0x50);
4818     zmw_tx_buf_writeb(dev, buf, offset++, 0xF2);
4819     zmw_tx_buf_writeb(dev, buf, offset++, 0x02);
4820     zmw_tx_buf_writeb(dev, buf, offset++, 0x00);
4821     zmw_tx_buf_writeb(dev, buf, offset++, 0x01);
4822
4823     /* QoS Info */
4824     zmw_tx_buf_writeb(dev, buf, offset++, qosInfo);
4825
4826     return offset;
4827 }
4828
4829 /************************************************************************/
4830 /*                                                                      */
4831 /*    FUNCTION DESCRIPTION                  zfStaAddIePowerCap          */
4832 /*      Add information element Power capability to buffer.             */
4833 /*                                                                      */
4834 /*    INPUTS                                                            */
4835 /*      dev : device pointer                                            */
4836 /*      buf : buffer to add information element                         */
4837 /*      offset : add information element from this offset               */
4838 /*                                                                      */
4839 /*    OUTPUTS                                                           */
4840 /*      buffer offset after adding information element                  */
4841 /*                                                                      */
4842 /*    AUTHOR                                                            */
4843 /*      Sharon                                            2007.12       */
4844 /*                                                                      */
4845 /************************************************************************/
4846 u16_t zfStaAddIePowerCap(zdev_t* dev, zbuf_t* buf, u16_t offset)
4847 {
4848     u8_t MaxTxPower;
4849     u8_t MinTxPower;
4850
4851     zmw_get_wlan_dev(dev);
4852
4853     /* Element ID */
4854     zmw_tx_buf_writeb(dev, buf, offset++, ZM_WLAN_EID_POWER_CAPABILITY);
4855
4856     /* Element Length */
4857     zmw_tx_buf_writeb(dev, buf, offset++, 2);
4858
4859     MinTxPower = (u8_t)(zfHpGetMinTxPower(dev)/2);
4860     MaxTxPower = (u8_t)(zfHpGetMaxTxPower(dev)/2);
4861
4862     /* Min Transmit Power Cap */
4863     zmw_tx_buf_writeh(dev, buf, offset++, MinTxPower);
4864
4865     /* Max Transmit Power Cap */
4866     zmw_tx_buf_writeh(dev, buf, offset++, MaxTxPower);
4867
4868     return offset;
4869 }
4870 /************************************************************************/
4871 /*                                                                      */
4872 /*    FUNCTION DESCRIPTION                  zfStaAddIeSupportCh              */
4873 /*      Add information element supported channels to buffer.               */
4874 /*                                                                      */
4875 /*    INPUTS                                                            */
4876 /*      dev : device pointer                                            */
4877 /*      buf : buffer to add information element                         */
4878 /*      offset : add information element from this offset               */
4879 /*                                                                      */
4880 /*    OUTPUTS                                                           */
4881 /*      buffer offset after adding information element                  */
4882 /*                                                                      */
4883 /*    AUTHOR                                                            */
4884 /*      Sharon            2007.12     */
4885 /*                                                                      */
4886 /************************************************************************/
4887 u16_t zfStaAddIeSupportCh(zdev_t* dev, zbuf_t* buf, u16_t offset)
4888 {
4889
4890     u8_t   i;
4891     u16_t  count_24G = 0;
4892     u16_t  count_5G = 0;
4893     u16_t  channelNum;
4894     u8_t   length;
4895
4896     zmw_get_wlan_dev(dev);
4897
4898     zmw_declare_for_critical_section();
4899     zmw_enter_critical_section(dev);
4900
4901     for (i = 0; i < wd->regulationTable.allowChannelCnt; i++)
4902     {
4903         if (wd->regulationTable.allowChannel[i].channel < 3000)
4904         { // 2.4Hz
4905             count_24G++;
4906         }
4907         else
4908         { // 5GHz
4909             count_5G++;
4910         }
4911     }
4912
4913     length = (u8_t)(count_5G * 2 + 2); //5G fill by pair, 2,4G (continuous channels) fill 2 bytes
4914
4915     /* Element ID */
4916     zmw_tx_buf_writeb(dev, buf, offset++, ZM_WLAN_EID_SUPPORTED_CHANNELS );
4917
4918     /* Element Length */
4919     zmw_tx_buf_writeb(dev, buf, offset++, length);
4920
4921     // 2.4GHz (continuous channels)
4922     /* First channel number */
4923     zmw_tx_buf_writeh(dev, buf, offset++, 1); //Start from channle 1
4924     /* Number of channels */
4925     zmw_tx_buf_writeh(dev, buf, offset++, count_24G);
4926
4927     for (i = 0; i < wd->regulationTable.allowChannelCnt ; i++)
4928     {
4929         if (wd->regulationTable.allowChannel[i].channel > 4000 && wd->regulationTable.allowChannel[i].channel < 5000)
4930         { // 5GHz 4000 -5000Mhz
4931             channelNum = (wd->regulationTable.allowChannel[i].channel-4000)/5;
4932             /* First channel number */
4933             zmw_tx_buf_writeh(dev, buf, offset++, channelNum);
4934             /* Number of channels */
4935             zmw_tx_buf_writeh(dev, buf, offset++, 1);
4936         }
4937         else if (wd->regulationTable.allowChannel[i].channel >= 5000)
4938         { // 5GHz >5000Mhz
4939             channelNum = (wd->regulationTable.allowChannel[i].channel-5000)/5;
4940             /* First channel number */
4941             zmw_tx_buf_writeh(dev, buf, offset++, channelNum);
4942             /* Number of channels */
4943             zmw_tx_buf_writeh(dev, buf, offset++, 1);
4944         }
4945     }
4946    zmw_leave_critical_section(dev);
4947
4948     return offset;
4949 }
4950
4951 void zfStaStartConnectCb(zdev_t* dev)
4952 {
4953     zmw_get_wlan_dev(dev);
4954
4955     zfStaStartConnect(dev, wd->sta.bIsSharedKey);
4956 }
4957
4958 void zfStaStartConnect(zdev_t* dev, u8_t bIsSharedKey)
4959 {
4960     u32_t p1, p2;
4961     u8_t newConnState;
4962
4963     zmw_get_wlan_dev(dev);
4964     zmw_declare_for_critical_section();
4965
4966     /* p1_low = algorithm number, p1_high = transaction sequence number */
4967     if ( bIsSharedKey )
4968     {
4969         //wd->sta.connectState = ZM_STA_CONN_STATE_AUTH_SHARE_1;
4970         newConnState = ZM_STA_CONN_STATE_AUTH_SHARE_1;
4971         zm_debug_msg0("ZM_STA_CONN_STATE_AUTH_SHARE_1");
4972         p1 = ZM_AUTH_ALGO_SHARED_KEY;
4973     }
4974     else
4975     {
4976         //wd->sta.connectState = ZM_STA_CONN_STATE_AUTH_OPEN;
4977         newConnState = ZM_STA_CONN_STATE_AUTH_OPEN;
4978         zm_debug_msg0("ZM_STA_CONN_STATE_AUTH_OPEN");
4979         if( wd->sta.leapEnabled )
4980             p1 = ZM_AUTH_ALGO_LEAP;
4981         else
4982             p1 = ZM_AUTH_ALGO_OPEN_SYSTEM;
4983     }
4984
4985     /* status code */
4986     p2 = 0x0;
4987
4988     zmw_enter_critical_section(dev);
4989     wd->sta.connectTimer = wd->tick;
4990     wd->sta.connectState = newConnState;
4991     zmw_leave_critical_section(dev);
4992
4993     /* send the 1st authentication frame */
4994     zfSendMmFrame(dev, ZM_WLAN_FRAME_TYPE_AUTH, wd->sta.bssid, p1, p2, 0);
4995
4996     return;
4997 }
4998
4999 void zfSendNullData(zdev_t* dev, u8_t type)
5000 {
5001     zbuf_t* buf;
5002     //u16_t addrTblSize;
5003     //struct zsAddrTbl addrTbl;
5004     u16_t err;
5005     u16_t hlen;
5006     u16_t header[(34+8+1)/2];
5007     u16_t bcastAddr[3] = {0xffff,0xffff,0xffff};
5008     u16_t *dstAddr;
5009
5010     zmw_get_wlan_dev(dev);
5011
5012     if ((buf = zfwBufAllocate(dev, 1024)) == NULL)
5013     {
5014         zm_msg0_mm(ZM_LV_0, "Alloc mm buf Fail!");
5015         return;
5016     }
5017
5018     zfwBufSetSize(dev, buf, 0);
5019
5020     //zm_msg2_mm(ZM_LV_2, "buf->len=", buf->len);
5021
5022     if ( wd->wlanMode == ZM_MODE_IBSS)
5023     {
5024         dstAddr = bcastAddr;
5025     }
5026     else
5027     {
5028         dstAddr = wd->sta.bssid;
5029     }
5030
5031     if (wd->sta.wmeConnected != 0)
5032     {
5033         /* If connect to a WMM AP, Send QoS Null data */
5034         hlen = zfTxGenMmHeader(dev, ZM_WLAN_FRAME_TYPE_QOS_NULL, dstAddr, header, 0, buf, 0, 0);
5035     }
5036     else
5037     {
5038         hlen = zfTxGenMmHeader(dev, ZM_WLAN_FRAME_TYPE_NULL, dstAddr, header, 0, buf, 0, 0);
5039     }
5040
5041     if (wd->wlanMode == ZM_MODE_INFRASTRUCTURE)
5042     {
5043         header[4] |= 0x0100; //TODS bit
5044     }
5045
5046     if ( type == 1 )
5047     {
5048         header[4] |= 0x1000;
5049     }
5050
5051     /* Get buffer DMA address */
5052     //if ((addrTblSize = zfwBufMapDma(dev, buf, &addrTbl)) == 0)
5053     //if ((addrTblSize = zfwMapTxDma(dev, buf, &addrTbl)) == 0)
5054     //{
5055     //    goto zlError;
5056     //}
5057
5058     /*increase unicast frame counter*/
5059     wd->commTally.txUnicastFrm++;
5060
5061     if ((err = zfHpSend(dev, header, hlen, NULL, 0, NULL, 0, buf, 0,
5062             ZM_INTERNAL_ALLOC_BUF, 0, 0xff)) != ZM_SUCCESS)
5063     {
5064         goto zlError;
5065     }
5066
5067
5068     return;
5069
5070 zlError:
5071
5072     zfwBufFree(dev, buf, 0);
5073     return;
5074
5075 }
5076
5077 void zfSendPSPoll(zdev_t* dev)
5078 {
5079     zbuf_t* buf;
5080     //u16_t addrTblSize;
5081     //struct zsAddrTbl addrTbl;
5082     u16_t err;
5083     u16_t hlen;
5084     u16_t header[(8+24+1)/2];
5085
5086     zmw_get_wlan_dev(dev);
5087
5088     if ((buf = zfwBufAllocate(dev, 1024)) == NULL)
5089     {
5090         zm_msg0_mm(ZM_LV_0, "Alloc mm buf Fail!");
5091         return;
5092     }
5093
5094     zfwBufSetSize(dev, buf, 0);
5095
5096     //zm_msg2_mm(ZM_LV_2, "buf->len=", buf->len);
5097
5098     zfTxGenMmHeader(dev, ZM_WLAN_FRAME_TYPE_PSPOLL, wd->sta.bssid, header, 0, buf, 0, 0);
5099
5100     header[0] = 20;
5101     header[4] |= 0x1000;
5102     header[5] = wd->sta.aid | 0xc000; //Both bit-14 and bit-15 are 1
5103     hlen = 16 + 8;
5104
5105     /* Get buffer DMA address */
5106     //if ((addrTblSize = zfwBufMapDma(dev, buf, &addrTbl)) == 0)
5107     //if ((addrTblSize = zfwMapTxDma(dev, buf, &addrTbl)) == 0)
5108     //{
5109     //    goto zlError;
5110     //}
5111
5112     if ((err = zfHpSend(dev, header, hlen, NULL, 0, NULL, 0, buf, 0,
5113             ZM_INTERNAL_ALLOC_BUF, 0, 0xff)) != ZM_SUCCESS)
5114     {
5115         goto zlError;
5116     }
5117
5118     return;
5119
5120 zlError:
5121
5122     zfwBufFree(dev, buf, 0);
5123     return;
5124
5125 }
5126
5127 void zfSendBA(zdev_t* dev, u16_t start_seq, u8_t *bitmap)
5128 {
5129     zbuf_t* buf;
5130     //u16_t addrTblSize;
5131     //struct zsAddrTbl addrTbl;
5132     u16_t err;
5133     u16_t hlen;
5134     u16_t header[(8+24+1)/2];
5135     u16_t i, offset = 0;
5136
5137     zmw_get_wlan_dev(dev);
5138
5139     if ((buf = zfwBufAllocate(dev, 1024)) == NULL)
5140     {
5141         zm_msg0_mm(ZM_LV_0, "Alloc mm buf Fail!");
5142         return;
5143     }
5144
5145     zfwBufSetSize(dev, buf, 12); // 28 = FC 2 + DU 2 + RA 6 + TA 6 + BAC 2 + SEQ 2 + BitMap 8
5146                                  // 12 = BAC 2 + SEQ 2 + BitMap 8
5147
5148     //zm_msg2_mm(ZM_LV_2, "buf->len=", buf->len);
5149
5150     zfTxGenMmHeader(dev, ZM_WLAN_FRAME_TYPE_BA, wd->sta.bssid, header, 0, buf, 0, 0);
5151
5152     header[0] = 32; /* MAC header 16 + BA control 2 + BA info 10 + FCS 4*/
5153     header[1] = 0x4;  /* No ACK */
5154
5155     /* send by OFDM 6M */
5156     header[2] = (u16_t)(zcRateToPhyCtrl[4] & 0xffff);
5157     header[3] = (u16_t)(zcRateToPhyCtrl[4]>>16) & 0xffff;
5158
5159     hlen = 16 + 8;  /* MAC header 16 + control 8*/
5160     offset = 0;
5161     zmw_tx_buf_writeh(dev, buf, offset, 0x05); /*compressed bitmap on*/
5162     offset+=2;
5163     zmw_tx_buf_writeh(dev, buf, offset, start_seq);
5164     offset+=2;
5165
5166     for (i=0; i<8; i++) {
5167         zmw_tx_buf_writeb(dev, buf, offset, bitmap[i]);
5168         offset++;
5169     }
5170
5171     if ((err = zfHpSend(dev, header, hlen, NULL, 0, NULL, 0, buf, 0,
5172             ZM_INTERNAL_ALLOC_BUF, 0, 0xff)) != ZM_SUCCESS)
5173     {
5174         goto zlError;
5175     }
5176
5177     return;
5178
5179 zlError:
5180
5181     zfwBufFree(dev, buf, 0);
5182     return;
5183
5184 }
5185
5186 void zfStaGetTxRate(zdev_t* dev, u16_t* macAddr, u32_t* phyCtrl,
5187         u16_t* rcProbingFlag)
5188 {
5189     u8_t   addr[6], i;
5190     u8_t   rate;
5191     zmw_get_wlan_dev(dev);
5192     zmw_declare_for_critical_section();
5193
5194     ZM_MAC_WORD_TO_BYTE(macAddr, addr);
5195     *phyCtrl = 0;
5196
5197     if ( wd->wlanMode == ZM_MODE_INFRASTRUCTURE )
5198     {
5199         zmw_enter_critical_section(dev);
5200         rate = (u8_t)zfRateCtrlGetTxRate(dev, &wd->sta.oppositeInfo[0].rcCell, rcProbingFlag);
5201 //#ifdef ZM_FB50
5202         //rate = 27;
5203 //#endif
5204         *phyCtrl = zcRateToPhyCtrl[rate];
5205         zmw_leave_critical_section(dev);
5206     }
5207     else
5208     {
5209         zmw_enter_critical_section(dev);
5210         for(i=0; i<wd->sta.oppositeCount; i++)
5211         {
5212             if ( addr[0] && 0x01 == 1 ) // The default beacon transmitted rate is CCK and 1 Mbps , but the a mode should use
5213                                         // OFDM modulation and 6Mbps to transmit beacon.
5214             {
5215                 //rate = (u8_t)zfRateCtrlGetTxRate(dev, &wd->sta.oppositeInfo[i].rcCell, rcProbingFlag);
5216                 rate = wd->sta.oppositeInfo[i].rcCell.operationRateSet[0];
5217                 *phyCtrl = zcRateToPhyCtrl[rate];
5218                 break;
5219             }
5220             else if ( zfMemoryIsEqual(addr, wd->sta.oppositeInfo[i].macAddr, 6) )
5221             {
5222                 rate = (u8_t)zfRateCtrlGetTxRate(dev, &wd->sta.oppositeInfo[i].rcCell, rcProbingFlag);
5223                 *phyCtrl = zcRateToPhyCtrl[rate];
5224                 break;
5225             }
5226         }
5227         zmw_leave_critical_section(dev);
5228     }
5229
5230     return;
5231 }
5232
5233 struct zsMicVar* zfStaGetRxMicKey(zdev_t* dev, zbuf_t* buf)
5234 {
5235     u8_t keyIndex;
5236     u8_t da0;
5237
5238     zmw_get_wlan_dev(dev);
5239
5240     /* if need not check MIC, return NULL */
5241     if ( ((wd->sta.encryMode != ZM_TKIP)&&(wd->sta.encryMode != ZM_AES))||
5242          (wd->sta.wpaState < ZM_STA_WPA_STATE_PK_OK) )
5243     {
5244         return NULL;
5245     }
5246
5247     da0 = zmw_rx_buf_readb(dev, buf, ZM_WLAN_HEADER_A1_OFFSET);
5248
5249     if ((zmw_rx_buf_readb(dev, buf, 0) & 0x80) == 0x80)
5250         keyIndex = zmw_rx_buf_readb(dev, buf, ZM_WLAN_HEADER_IV_OFFSET+5); /* Qos Packet*/
5251     else
5252         keyIndex = zmw_rx_buf_readb(dev, buf, ZM_WLAN_HEADER_IV_OFFSET+3); /* normal Packet*/
5253     keyIndex = (keyIndex & 0xc0) >> 6;
5254
5255     return (&wd->sta.rxMicKey[keyIndex]);
5256 }
5257
5258 struct zsMicVar* zfStaGetTxMicKey(zdev_t* dev, zbuf_t* buf)
5259 {
5260     zmw_get_wlan_dev(dev);
5261
5262     /* if need not check MIC, return NULL */
5263     //if ( ((wd->sta.encryMode != ZM_TKIP)&&(wd->sta.encryMode != ZM_AES))||
5264     //     (wd->sta.wpaState < ZM_STA_WPA_STATE_PK_OK) )
5265     if ( (wd->sta.encryMode != ZM_TKIP) || (wd->sta.wpaState < ZM_STA_WPA_STATE_PK_OK) )
5266     {
5267         return NULL;
5268     }
5269
5270     return (&wd->sta.txMicKey);
5271 }
5272
5273 u16_t zfStaRxValidateFrame(zdev_t* dev, zbuf_t* buf)
5274 {
5275     u8_t   frameType, frameCtrl;
5276     u8_t   da0;
5277     //u16_t  sa[3];
5278     u16_t  ret;
5279     u16_t  i;
5280     //u8_t    sa0;
5281
5282     zmw_get_wlan_dev(dev);
5283
5284     frameType = zmw_rx_buf_readb(dev, buf, 0);
5285     da0 = zmw_rx_buf_readb(dev, buf, ZM_WLAN_HEADER_A1_OFFSET);
5286     //sa0 = zmw_rx_buf_readb(dev, buf, ZM_WLAN_HEADER_A2_OFFSET);
5287
5288     if ( (!zfStaIsConnected(dev))&&((frameType & 0xf) == ZM_WLAN_DATA_FRAME) )
5289     {
5290         return ZM_ERR_DATA_BEFORE_CONNECTED;
5291     }
5292
5293
5294     if ( (zfStaIsConnected(dev))&&((frameType & 0xf) == ZM_WLAN_DATA_FRAME) )
5295     {
5296         /* check BSSID */
5297         if ( wd->wlanMode == ZM_MODE_INFRASTRUCTURE )
5298         {
5299             /* Big Endian and Little Endian Compatibility */
5300             u16_t mac[3];
5301             mac[0] = zmw_cpu_to_le16(wd->sta.bssid[0]);
5302             mac[1] = zmw_cpu_to_le16(wd->sta.bssid[1]);
5303             mac[2] = zmw_cpu_to_le16(wd->sta.bssid[2]);
5304             if ( !zfRxBufferEqualToStr(dev, buf, (u8_t *)mac,
5305                                        ZM_WLAN_HEADER_A2_OFFSET, 6) )
5306             {
5307 /*We will get lots of garbage data, especially in AES mode.*/
5308 /*To avoid sending too many deauthentication frames in STA mode, mark it.*/
5309 #if 0
5310                 /* If unicast frame, send deauth to the transmitter */
5311                 if (( da0 & 0x01 ) == 0)
5312                 {
5313                     for (i=0; i<3; i++)
5314                     {
5315                         sa[i] = zmw_rx_buf_readh(dev, buf, ZM_WLAN_HEADER_A2_OFFSET+(i*2));
5316                     }
5317                                         /* If mutilcast address, don't send deauthentication*/
5318                                         if (( sa0 & 0x01 ) == 0)
5319                                 zfSendMmFrame(dev, ZM_WLAN_FRAME_TYPE_DEAUTH, sa, 7, 0, 0);
5320                 }
5321 #endif
5322                 return ZM_ERR_DATA_BSSID_NOT_MATCHED;
5323             }
5324         }
5325         else if ( wd->wlanMode == ZM_MODE_IBSS )
5326         {
5327             /* Big Endian and Little Endian Compatibility */
5328             u16_t mac[3];
5329             mac[0] = zmw_cpu_to_le16(wd->sta.bssid[0]);
5330             mac[1] = zmw_cpu_to_le16(wd->sta.bssid[1]);
5331             mac[2] = zmw_cpu_to_le16(wd->sta.bssid[2]);
5332             if ( !zfRxBufferEqualToStr(dev, buf, (u8_t *)mac,
5333                                        ZM_WLAN_HEADER_A3_OFFSET, 6) )
5334             {
5335                 return ZM_ERR_DATA_BSSID_NOT_MATCHED;
5336             }
5337         }
5338
5339         frameCtrl = zmw_rx_buf_readb(dev, buf, 1);
5340
5341         /* check security bit */
5342         if ( wd->sta.dropUnencryptedPkts &&
5343              (wd->sta.wepStatus != ZM_ENCRYPTION_WEP_DISABLED )&&
5344              ( !(frameCtrl & ZM_BIT_6) ) )
5345         {   /* security on, but got data without encryption */
5346
5347             #if 1
5348             ret = ZM_ERR_DATA_NOT_ENCRYPTED;
5349             if ( wd->sta.pStaRxSecurityCheckCb != NULL )
5350             {
5351                 ret = wd->sta.pStaRxSecurityCheckCb(dev, buf);
5352             }
5353             else
5354             {
5355                 ret = ZM_ERR_DATA_NOT_ENCRYPTED;
5356             }
5357             if (ret == ZM_ERR_DATA_NOT_ENCRYPTED)
5358             {
5359                 wd->commTally.swRxDropUnencryptedCount++;
5360             }
5361             return ret;
5362             #else
5363             if ( (wd->sta.wepStatus != ZM_ENCRYPTION_TKIP)&&
5364                  (wd->sta.wepStatus != ZM_ENCRYPTION_AES) )
5365             {
5366                 return ZM_ERR_DATA_NOT_ENCRYPTED;
5367             }
5368             #endif
5369         }
5370     }
5371
5372     return ZM_SUCCESS;
5373 }
5374
5375 void zfStaMicFailureHandling(zdev_t* dev, zbuf_t* buf)
5376 {
5377     u8_t   da0;
5378     u8_t   micNotify = 1;
5379
5380     zmw_get_wlan_dev(dev);
5381
5382     zmw_declare_for_critical_section();
5383
5384     if ( wd->sta.wpaState <  ZM_STA_WPA_STATE_PK_OK )
5385     {
5386         return;
5387     }
5388
5389     zmw_enter_critical_section(dev);
5390
5391     wd->sta.cmMicFailureCount++;
5392
5393     if ( wd->sta.cmMicFailureCount == 1 )
5394     {
5395         zm_debug_msg0("get the first MIC failure");
5396         //zfTimerSchedule(dev, ZM_EVENT_CM_TIMER, ZM_TICK_CM_TIMEOUT);
5397
5398         /* Timer Resolution on WinXP is 15/16 ms  */
5399         /* Decrease Time offset for <XP> Counter Measure */
5400         zfTimerSchedule(dev, ZM_EVENT_CM_TIMER, ZM_TICK_CM_TIMEOUT - ZM_TICK_CM_TIMEOUT_OFFSET);
5401     }
5402     else if ( wd->sta.cmMicFailureCount == 2 )
5403     {
5404         zm_debug_msg0("get the second MIC failure");
5405         /* reserve 2 second for OS to send MIC failure report to AP */
5406         wd->sta.cmDisallowSsidLength = wd->sta.ssidLen;
5407         zfMemoryCopy(wd->sta.cmDisallowSsid, wd->sta.ssid, wd->sta.ssidLen);
5408         //wd->sta.cmMicFailureCount = 0;
5409         zfTimerCancel(dev, ZM_EVENT_CM_TIMER);
5410         //zfTimerSchedule(dev, ZM_EVENT_CM_DISCONNECT, ZM_TICK_CM_DISCONNECT);
5411
5412         /* Timer Resolution on WinXP is 15/16 ms  */
5413         /* Decrease Time offset for <XP> Counter Measure */
5414         zfTimerSchedule(dev, ZM_EVENT_CM_DISCONNECT, ZM_TICK_CM_DISCONNECT - ZM_TICK_CM_DISCONNECT_OFFSET);
5415     }
5416     else
5417     {
5418         micNotify = 0;
5419     }
5420
5421     zmw_leave_critical_section(dev);
5422
5423     if (micNotify == 1)
5424     {
5425         da0 = zmw_rx_buf_readb(dev, buf, ZM_WLAN_HEADER_A1_OFFSET);
5426         if ( da0 & 0x01 )
5427         {
5428             if (wd->zfcbMicFailureNotify != NULL)
5429             {
5430                 wd->zfcbMicFailureNotify(dev, wd->sta.bssid, ZM_MIC_GROUP_ERROR);
5431             }
5432         }
5433         else
5434         {
5435             if (wd->zfcbMicFailureNotify != NULL)
5436             {
5437                 wd->zfcbMicFailureNotify(dev, wd->sta.bssid, ZM_MIC_PAIRWISE_ERROR);
5438             }
5439         }
5440     }
5441 }
5442
5443
5444 u8_t zfStaBlockWlanScan(zdev_t* dev)
5445 {
5446     u8_t   ret=FALSE;
5447
5448     zmw_get_wlan_dev(dev);
5449
5450     if ( wd->sta.bChannelScan )
5451     {
5452         return TRUE;
5453     }
5454
5455     return ret;
5456 }
5457
5458 void zfStaResetStatus(zdev_t* dev, u8_t bInit)
5459 {
5460     u8_t   i;
5461
5462     zmw_get_wlan_dev(dev);
5463
5464     zfHpDisableBeacon(dev);
5465
5466     wd->dtim = 1;
5467     wd->sta.capability[0] = 0x01;
5468     wd->sta.capability[1] = 0x00;
5469     /* 802.11h */
5470     if (wd->sta.DFSEnable || wd->sta.TPCEnable)
5471         wd->sta.capability[1] |= ZM_BIT_0;
5472
5473     /* release queued packets */
5474     for(i=0; i<wd->sta.ibssPSDataCount; i++)
5475     {
5476         zfwBufFree(dev, wd->sta.ibssPSDataQueue[i], 0);
5477     }
5478
5479     for(i=0; i<wd->sta.staPSDataCount; i++)
5480     {
5481         zfwBufFree(dev, wd->sta.staPSDataQueue[i], 0);
5482     }
5483
5484     wd->sta.ibssPSDataCount = 0;
5485     wd->sta.staPSDataCount = 0;
5486     zfZeroMemory((u8_t*) &wd->sta.staPSList, sizeof(struct zsStaPSList));
5487
5488     wd->sta.wmeConnected = 0;
5489     wd->sta.psMgr.tempWakeUp = 0;
5490     wd->sta.qosInfo = 0;
5491     zfQueueFlush(dev, wd->sta.uapsdQ);
5492
5493     return;
5494
5495 }
5496
5497 void zfStaIbssMonitoring(zdev_t* dev, u8_t reset)
5498 {
5499     u16_t i;
5500     u16_t oppositeCount;
5501     struct zsPartnerNotifyEvent event;
5502
5503     zmw_get_wlan_dev(dev);
5504
5505     zmw_declare_for_critical_section();
5506
5507     //zm_debug_msg1("zfStaIbssMonitoring %d", wd->sta.oppositeCount);
5508
5509     zmw_enter_critical_section(dev);
5510
5511     if ( wd->sta.oppositeCount == 0 )
5512     {
5513         goto done;
5514     }
5515
5516     if ( wd->sta.bChannelScan )
5517     {
5518         goto done;
5519     }
5520
5521     oppositeCount = wd->sta.oppositeCount;
5522
5523     for(i=0; i < ZM_MAX_OPPOSITE_COUNT; i++)
5524     {
5525         if ( oppositeCount == 0 )
5526         {
5527             break;
5528         }
5529
5530         if ( reset )
5531         {
5532             wd->sta.oppositeInfo[i].valid = 0;
5533         }
5534
5535         if ( wd->sta.oppositeInfo[i].valid == 0 )
5536         {
5537             continue;
5538         }
5539
5540         oppositeCount--;
5541
5542         if ( wd->sta.oppositeInfo[i].aliveCounter )
5543         {
5544             zm_debug_msg1("Setting alive to ", wd->sta.oppositeInfo[i].aliveCounter);
5545
5546             zmw_leave_critical_section(dev);
5547
5548             if ( wd->sta.oppositeInfo[i].aliveCounter != ZM_IBSS_PEER_ALIVE_COUNTER )
5549             {
5550                 zfSendMmFrame(dev, ZM_WLAN_FRAME_TYPE_PROBEREQ,
5551                               (u16_t*)wd->sta.oppositeInfo[i].macAddr, 1, 0, 0);
5552             }
5553
5554             zmw_enter_critical_section(dev);
5555             wd->sta.oppositeInfo[i].aliveCounter--;
5556         }
5557         else
5558         {
5559             zm_debug_msg0("zfStaIbssMonitoring remove the peer station");
5560             zfMemoryCopy(event.bssid, (u8_t *)(wd->sta.bssid), 6);
5561             zfMemoryCopy(event.peerMacAddr, wd->sta.oppositeInfo[i].macAddr, 6);
5562
5563             wd->sta.oppositeInfo[i].valid = 0;
5564             wd->sta.oppositeCount--;
5565             if (wd->zfcbIbssPartnerNotify != NULL)
5566             {
5567                 zmw_leave_critical_section(dev);
5568                 wd->zfcbIbssPartnerNotify(dev, 0, &event);
5569                 zmw_enter_critical_section(dev);
5570             }
5571         }
5572     }
5573
5574 done:
5575     if ( reset == 0 )
5576     {
5577         zfTimerSchedule(dev, ZM_EVENT_IBSS_MONITOR, ZM_TICK_IBSS_MONITOR);
5578     }
5579
5580     zmw_leave_critical_section(dev);
5581 }
5582
5583 void zfInitPartnerNotifyEvent(zdev_t* dev, zbuf_t* buf, struct zsPartnerNotifyEvent *event)
5584 {
5585     u16_t  *peerMacAddr;
5586
5587     zmw_get_wlan_dev(dev);
5588
5589     peerMacAddr = (u16_t *)event->peerMacAddr;
5590
5591     zfMemoryCopy(event->bssid, (u8_t *)(wd->sta.bssid), 6);
5592     peerMacAddr[0] = zmw_rx_buf_readh(dev, buf, ZM_WLAN_HEADER_A2_OFFSET);
5593     peerMacAddr[1] = zmw_rx_buf_readh(dev, buf, ZM_WLAN_HEADER_A2_OFFSET + 2);
5594     peerMacAddr[2] = zmw_rx_buf_readh(dev, buf, ZM_WLAN_HEADER_A2_OFFSET + 4);
5595 }
5596
5597 void zfStaInitOppositeInfo(zdev_t* dev)
5598 {
5599     int i;
5600
5601     zmw_get_wlan_dev(dev);
5602
5603     for(i=0; i<ZM_MAX_OPPOSITE_COUNT; i++)
5604     {
5605         wd->sta.oppositeInfo[i].valid = 0;
5606         wd->sta.oppositeInfo[i].aliveCounter = ZM_IBSS_PEER_ALIVE_COUNTER;
5607     }
5608 }
5609 #ifdef ZM_ENABLE_CENC
5610 u16_t zfStaAddIeCenc(zdev_t* dev, zbuf_t* buf, u16_t offset)
5611 {
5612     zmw_get_wlan_dev(dev);
5613
5614     if (wd->sta.cencIe[1] != 0)
5615     {
5616         zfCopyToIntTxBuffer(dev, buf, wd->sta.cencIe, offset, wd->sta.cencIe[1]+2);
5617         offset += (wd->sta.cencIe[1]+2);
5618     }
5619     return offset;
5620 }
5621 #endif //ZM_ENABLE_CENC
5622 u16_t zfStaProcessAction(zdev_t* dev, zbuf_t* buf)
5623 {
5624     u8_t category, actionDetails;
5625     zmw_get_wlan_dev(dev);
5626
5627     category = zmw_rx_buf_readb(dev, buf, 24);
5628     actionDetails = zmw_rx_buf_readb(dev, buf, 25);
5629     switch (category)
5630     {
5631         case 0:         //Spectrum Management
5632                 switch(actionDetails)
5633                 {
5634                         case 0:                 //Measurement Request
5635                                 break;
5636                         case 1:                 //Measurement Report
5637                                 //ProcessActionSpectrumFrame_MeasurementReport(Adapter,pActionBody+3);
5638                                 break;
5639                         case 2:                 //TPC request
5640                     //if (wd->sta.TPCEnable)
5641                     //    zfStaUpdateDot11HTPC(dev, buf);
5642                                 break;
5643                         case 3:                 //TPC report
5644                     //if (wd->sta.TPCEnable)
5645                     //    zfStaUpdateDot11HTPC(dev, buf);
5646                                 break;
5647                         case 4:                 //Channel Switch Announcement
5648                     if (wd->sta.DFSEnable)
5649                         zfStaUpdateDot11HDFS(dev, buf);
5650                                 break;
5651                         default:
5652                                 zm_debug_msg1("Action Frame contain not support action field ", actionDetails);
5653                                 break;
5654                 }
5655                 break;
5656         case ZM_WLAN_BLOCK_ACK_ACTION_FRAME:
5657             zfAggBlockAckActionFrame(dev, buf);
5658             break;
5659         case 17:        //Qos Management
5660                 break;
5661     }
5662
5663     return 0;
5664 }
5665
5666 /* Determine the time not send beacon , if more than some value ,
5667    re-write the beacon start address */
5668 void zfReWriteBeaconStartAddress(zdev_t* dev)
5669 {
5670     zmw_get_wlan_dev(dev);
5671
5672     zmw_declare_for_critical_section();
5673
5674     zmw_enter_critical_section(dev);
5675     wd->tickIbssSendBeacon++;    // Increase 1 per 10ms .
5676     zmw_leave_critical_section(dev);
5677
5678     if ( wd->tickIbssSendBeacon == 40 )
5679     {
5680 //        DbgPrint("20070727");
5681         zfHpEnableBeacon(dev, ZM_MODE_IBSS, wd->beaconInterval, wd->dtim, (u8_t)wd->sta.atimWindow);
5682         zmw_enter_critical_section(dev);
5683         wd->tickIbssSendBeacon = 0;
5684         zmw_leave_critical_section(dev);
5685     }
5686 }
5687
5688 struct zsTkipSeed* zfStaGetRxSeed(zdev_t* dev, zbuf_t* buf)
5689 {
5690     u8_t keyIndex;
5691     u8_t da0;
5692
5693     zmw_get_wlan_dev(dev);
5694
5695     /* if need not check MIC, return NULL */
5696     if ( ((wd->sta.encryMode != ZM_TKIP)&&(wd->sta.encryMode != ZM_AES))||
5697          (wd->sta.wpaState < ZM_STA_WPA_STATE_PK_OK) )
5698     {
5699         return NULL;
5700     }
5701
5702     da0 = zmw_rx_buf_readb(dev, buf, ZM_WLAN_HEADER_A1_OFFSET);
5703
5704     if ((zmw_rx_buf_readb(dev, buf, 0) & 0x80) == 0x80)
5705         keyIndex = zmw_rx_buf_readb(dev, buf, ZM_WLAN_HEADER_IV_OFFSET+5); /* Qos Packet*/
5706     else
5707         keyIndex = zmw_rx_buf_readb(dev, buf, ZM_WLAN_HEADER_IV_OFFSET+3); /* normal Packet*/
5708     keyIndex = (keyIndex & 0xc0) >> 6;
5709
5710     return (&wd->sta.rxSeed[keyIndex]);
5711 }
5712
5713 void zfStaEnableSWEncryption(zdev_t *dev, u8_t value)
5714 {
5715     zmw_get_wlan_dev(dev);
5716
5717     wd->sta.SWEncryptEnable = value;
5718     zfHpSWDecrypt(dev, 1);
5719     zfHpSWEncrypt(dev, 1);
5720 }
5721
5722 void zfStaDisableSWEncryption(zdev_t *dev)
5723 {
5724     zmw_get_wlan_dev(dev);
5725
5726     wd->sta.SWEncryptEnable = 0;
5727     zfHpSWDecrypt(dev, 0);
5728     zfHpSWEncrypt(dev, 0);
5729 }
5730
5731 u16_t zfComputeBssInfoWeightValue(zdev_t *dev, u8_t isBMode, u8_t isHT, u8_t isHT40, u8_t signalStrength)
5732 {
5733         u8_t  weightOfB           = 0;
5734         u8_t  weightOfAGBelowThr  = 0;
5735         u8_t  weightOfAGUpThr     = 15;
5736         u8_t  weightOfN20BelowThr = 15;
5737         u8_t  weightOfN20UpThr    = 30;
5738         u8_t  weightOfN40BelowThr = 16;
5739         u8_t  weightOfN40UpThr    = 32;
5740
5741     zmw_get_wlan_dev(dev);
5742
5743     if( isBMode == 0 )
5744         return (signalStrength + weightOfB);    // pure b mode , do not add the weight value for this AP !
5745     else
5746     {
5747         if( isHT == 0 && isHT40 == 0 )
5748         { // a , g , b/g mode ! add the weight value 15 for this AP if it's signal strength is more than some value !
5749             if( signalStrength < 18 ) // -77 dBm
5750                                 return signalStrength + weightOfAGBelowThr;
5751                         else
5752                                 return (signalStrength + weightOfAGUpThr);
5753         }
5754         else if( isHT == 1 && isHT40 == 0 )
5755         { // 80211n mode use 20MHz
5756             if( signalStrength < 23 ) // -72 dBm
5757                 return (signalStrength + weightOfN20BelowThr);
5758             else
5759                 return (signalStrength + weightOfN20UpThr);
5760         }
5761         else // isHT == 1 && isHT40 == 1
5762         { // 80211n mode use 40MHz
5763             if( signalStrength < 16 ) // -79 dBm
5764                 return (signalStrength + weightOfN40BelowThr);
5765             else
5766                 return (signalStrength + weightOfN40UpThr);
5767         }
5768     }
5769 }
5770
5771 u16_t zfStaAddIbssAdditionalIE(zdev_t* dev, zbuf_t* buf, u16_t offset)
5772 {
5773         u16_t i;
5774
5775     zmw_get_wlan_dev(dev);
5776
5777     for (i=0; i<wd->sta.ibssAdditionalIESize; i++)
5778     {
5779         zmw_tx_buf_writeb(dev, buf, offset++, wd->sta.ibssAdditionalIE[i]);
5780     }
5781
5782     return offset;
5783 }