release/src-rt-6.x.4708/linux/linux-2.6.36/drivers/staging/otus/80211core/cfunc.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
  19 u8_t zfQueryOppositeRate(zdev_t* dev, u8_t dst_mac[6], u8_t frameType)
  20 {
  21     zmw_get_wlan_dev(dev);
  22
  23     /* For AP's rate adaption */
  24     if ( wd->wlanMode == ZM_MODE_AP )
  25     {
  26         return 0;
  27     }
  28
  29     /* For STA's rate adaption */
  30     if ( (frameType & 0x0c) == ZM_WLAN_DATA_FRAME )
  31     {
  32         if ( ZM_IS_MULTICAST(dst_mac) )
  33         {
  34             return wd->sta.mTxRate;
  35         }
  36         else
  37         {
  38             return wd->sta.uTxRate;
  39         }
  40     }
  41
  42     return wd->sta.mmTxRate;
  43 }
  44
  45 void zfCopyToIntTxBuffer(zdev_t* dev, zbuf_t* buf, u8_t* src,
  46                          u16_t offset, u16_t length)
  47 {
  48     u16_t i;
  49
  50     for(i=0; i<length;i++)
  51     {
  52         zmw_tx_buf_writeb(dev, buf, offset+i, src[i]);
  53     }
  54 }
  55
  56 void zfCopyToRxBuffer(zdev_t* dev, zbuf_t* buf, u8_t* src,
  57                       u16_t offset, u16_t length)
  58 {
  59     u16_t i;
  60
  61     for(i=0; i<length;i++)
  62     {
  63         zmw_rx_buf_writeb(dev, buf, offset+i, src[i]);
  64     }
  65 }
  66
  67 void zfCopyFromIntTxBuffer(zdev_t* dev, zbuf_t* buf, u8_t* dst,
  68                            u16_t offset, u16_t length)
  69 {
  70     u16_t i;
  71
  72     for(i=0; i<length; i++)
  73     {
  74         dst[i] = zmw_tx_buf_readb(dev, buf, offset+i);
  75     }
  76 }
  77
  78 void zfCopyFromRxBuffer(zdev_t* dev, zbuf_t* buf, u8_t* dst,
  79                         u16_t offset, u16_t length)
  80 {
  81     u16_t i;
  82
  83     for(i=0; i<length; i++)
  84     {
  85         dst[i] = zmw_rx_buf_readb(dev, buf, offset+i);
  86     }
  87 }
  88
  89 void zfMemoryCopy(u8_t* dst, u8_t* src, u16_t length)
  90 {
  91     zfwMemoryCopy(dst, src, length);
  92 }
  93
  94 void zfMemoryMove(u8_t* dst, u8_t* src, u16_t length)
  95 {
  96     zfwMemoryMove(dst, src, length);
  97 }
  98
  99 void zfZeroMemory(u8_t* va, u16_t length)
 100 {
 101     zfwZeroMemory(va, length);
 102 }
 103
 104 u8_t zfMemoryIsEqual(u8_t* m1, u8_t* m2, u16_t length)
 105 {
 106     return zfwMemoryIsEqual(m1, m2, length);
 107 }
 108
 109 u8_t zfRxBufferEqualToStr(zdev_t* dev, zbuf_t* buf,
 110                           const u8_t* str, u16_t offset, u16_t length)
 111 {
 112     u16_t i;
 113     u8_t ch;
 114
 115     for(i=0; i<length; i++)
 116     {
 117         ch = zmw_rx_buf_readb(dev, buf, offset+i);
 118         if ( ch != str[i] )
 119         {
 120             return FALSE;
 121         }
 122     }
 123
 124     return TRUE;
 125 }
 126
 127 void zfTxBufferCopy(zdev_t*dev, zbuf_t* dst, zbuf_t* src,
 128                     u16_t dstOffset, u16_t srcOffset, u16_t length)
 129 {
 130     u16_t i;
 131
 132     for(i=0; i<length; i++)
 133     {
 134         zmw_tx_buf_writeb(dev, dst, dstOffset+i,
 135                           zmw_tx_buf_readb(dev, src, srcOffset+i));
 136     }
 137 }
 138
 139 void zfRxBufferCopy(zdev_t*dev, zbuf_t* dst, zbuf_t* src,
 140                     u16_t dstOffset, u16_t srcOffset, u16_t length)
 141 {
 142     u16_t i;
 143
 144     for(i=0; i<length; i++)
 145     {
 146         zmw_rx_buf_writeb(dev, dst, dstOffset+i,
 147                              zmw_rx_buf_readb(dev, src, srcOffset+i));
 148     }
 149 }
 150
 151
 152 void zfCollectHWTally(zdev_t*dev, u32_t* rsp, u8_t id)
 153 {
 154     zmw_get_wlan_dev(dev);
 155
 156     zmw_declare_for_critical_section();
 157
 158     zmw_enter_critical_section(dev);
 159
 160     if (id == 0)
 161     {
 162         wd->commTally.Hw_UnderrunCnt += (0xFFFF & rsp[1]);
 163         wd->commTally.Hw_TotalRxFrm += rsp[2];
 164         wd->commTally.Hw_CRC32Cnt += rsp[3];
 165         wd->commTally.Hw_CRC16Cnt += rsp[4];
 166         #ifdef ZM_ENABLE_NATIVE_WIFI
 167         /* These code are here to satisfy Vista DTM */
 168         wd->commTally.Hw_DecrypErr_UNI += ((rsp[5]>50) && (rsp[5]<60))?50:rsp[5];
 169         #else
 170         wd->commTally.Hw_DecrypErr_UNI += rsp[5];
 171         #endif
 172         wd->commTally.Hw_RxFIFOOverrun += rsp[6];
 173         wd->commTally.Hw_DecrypErr_Mul += rsp[7];
 174         wd->commTally.Hw_RetryCnt += rsp[8];
 175         wd->commTally.Hw_TotalTxFrm += rsp[9];
 176         wd->commTally.Hw_RxTimeOut +=rsp[10];
 177
 178         wd->commTally.Tx_MPDU += rsp[11];
 179         wd->commTally.BA_Fail += rsp[12];
 180         wd->commTally.Hw_Tx_AMPDU += rsp[13];
 181         wd->commTally.Hw_Tx_MPDU += rsp[14];
 182         wd->commTally.RateCtrlTxMPDU += rsp[11];
 183         wd->commTally.RateCtrlBAFail += rsp[12];
 184     }
 185     else
 186     {
 187         wd->commTally.Hw_RxMPDU += rsp[1];
 188         wd->commTally.Hw_RxDropMPDU += rsp[2];
 189         wd->commTally.Hw_RxDelMPDU += rsp[3];
 190
 191         wd->commTally.Hw_RxPhyMiscError += rsp[4];
 192         wd->commTally.Hw_RxPhyXRError += rsp[5];
 193         wd->commTally.Hw_RxPhyOFDMError += rsp[6];
 194         wd->commTally.Hw_RxPhyCCKError += rsp[7];
 195         wd->commTally.Hw_RxPhyHTError += rsp[8];
 196         wd->commTally.Hw_RxPhyTotalCount += rsp[9];
 197     }
 198
 199     zmw_leave_critical_section(dev);
 200
 201     if (id == 0)
 202     {
 203         zm_msg1_mm(ZM_LV_1, "rsplen =", rsp[0]);
 204         zm_msg1_mm(ZM_LV_1, "Hw_UnderrunCnt    = ", (0xFFFF & rsp[1]));
 205         zm_msg1_mm(ZM_LV_1, "Hw_TotalRxFrm     = ", rsp[2]);
 206         zm_msg1_mm(ZM_LV_1, "Hw_CRC32Cnt       = ", rsp[3]);
 207         zm_msg1_mm(ZM_LV_1, "Hw_CRC16Cnt       = ", rsp[4]);
 208         zm_msg1_mm(ZM_LV_1, "Hw_DecrypErr_UNI  = ", rsp[5]);
 209         zm_msg1_mm(ZM_LV_1, "Hw_RxFIFOOverrun  = ", rsp[6]);
 210         zm_msg1_mm(ZM_LV_1, "Hw_DecrypErr_Mul  = ", rsp[7]);
 211         zm_msg1_mm(ZM_LV_1, "Hw_RetryCnt       = ", rsp[8]);
 212         zm_msg1_mm(ZM_LV_1, "Hw_TotalTxFrm     = ", rsp[9]);
 213         zm_msg1_mm(ZM_LV_1, "Hw_RxTimeOut      = ", rsp[10]);
 214         zm_msg1_mm(ZM_LV_1, "Tx_MPDU           = ", rsp[11]);
 215         zm_msg1_mm(ZM_LV_1, "BA_Fail           = ", rsp[12]);
 216         zm_msg1_mm(ZM_LV_1, "Hw_Tx_AMPDU       = ", rsp[13]);
 217         zm_msg1_mm(ZM_LV_1, "Hw_Tx_MPDU        = ", rsp[14]);
 218     }
 219     else
 220     {
 221         zm_msg1_mm(ZM_LV_1, "rsplen             = ", rsp[0]);
 222         zm_msg1_mm(ZM_LV_1, "Hw_RxMPDU          = ", (0xFFFF & rsp[1]));
 223         zm_msg1_mm(ZM_LV_1, "Hw_RxDropMPDU      = ", rsp[2]);
 224         zm_msg1_mm(ZM_LV_1, "Hw_RxDelMPDU       = ", rsp[3]);
 225         zm_msg1_mm(ZM_LV_1, "Hw_RxPhyMiscError  = ", rsp[4]);
 226         zm_msg1_mm(ZM_LV_1, "Hw_RxPhyXRError    = ", rsp[5]);
 227         zm_msg1_mm(ZM_LV_1, "Hw_RxPhyOFDMError  = ", rsp[6]);
 228         zm_msg1_mm(ZM_LV_1, "Hw_RxPhyCCKError   = ", rsp[7]);
 229         zm_msg1_mm(ZM_LV_1, "Hw_RxPhyHTError    = ", rsp[8]);
 230         zm_msg1_mm(ZM_LV_1, "Hw_RxPhyTotalCount = ", rsp[9]);
 231     }
 232
 233 }
 234
 235 /* Timer related functions */
 236 void zfTimerInit(zdev_t* dev)
 237 {
 238     u8_t   i;
 239
 240     zmw_get_wlan_dev(dev);
 241
 242     zm_debug_msg0("");
 243
 244     wd->timerList.freeCount = ZM_MAX_TIMER_COUNT;
 245     wd->timerList.head = &(wd->timerList.list[0]);
 246     wd->timerList.tail = &(wd->timerList.list[ZM_MAX_TIMER_COUNT-1]);
 247     wd->timerList.head->pre = NULL;
 248     wd->timerList.head->next = &(wd->timerList.list[1]);
 249     wd->timerList.tail->pre = &(wd->timerList.list[ZM_MAX_TIMER_COUNT-2]);
 250     wd->timerList.tail->next = NULL;
 251
 252     for( i=1; i<(ZM_MAX_TIMER_COUNT-1); i++ )
 253     {
 254         wd->timerList.list[i].pre = &(wd->timerList.list[i-1]);
 255         wd->timerList.list[i].next = &(wd->timerList.list[i+1]);
 256     }
 257
 258     wd->bTimerReady = TRUE;
 259 }
 260
 261
 262 u16_t zfTimerSchedule(zdev_t* dev, u16_t event, u32_t tick)
 263 {
 264     struct zsTimerEntry *pFreeEntry;
 265     struct zsTimerEntry *pEntry;
 266     u8_t   i, count;
 267
 268     zmw_get_wlan_dev(dev);
 269
 270     if ( wd->timerList.freeCount == 0 )
 271     {
 272         zm_debug_msg0("no more timer");
 273         return 1;
 274     }
 275
 276     //zm_debug_msg2("event = ", event);
 277     //zm_debug_msg1("target tick = ", wd->tick + tick);
 278
 279     count = ZM_MAX_TIMER_COUNT - wd->timerList.freeCount;
 280
 281     if ( count == 0 )
 282     {
 283         wd->timerList.freeCount--;
 284         wd->timerList.head->event = event;
 285         wd->timerList.head->timer = wd->tick + tick;
 286         //zm_debug_msg1("free timer count = ", wd->timerList.freeCount);
 287
 288         return 0;
 289     }
 290
 291     pFreeEntry = wd->timerList.tail;
 292     pFreeEntry->timer = wd->tick + tick;
 293     pFreeEntry->event = event;
 294     wd->timerList.tail = pFreeEntry->pre;
 295     pEntry = wd->timerList.head;
 296
 297     for( i=0; i<count; i++ )
 298     {
 299         // prevent from the case of tick overflow
 300         if ( ( pEntry->timer > pFreeEntry->timer )&&
 301              ((pEntry->timer - pFreeEntry->timer) < 1000000000) )
 302         {
 303             if ( i != 0 )
 304             {
 305                 pFreeEntry->pre = pEntry->pre;
 306                 pFreeEntry->pre->next = pFreeEntry;
 307             }
 308             else
 309             {
 310                 pFreeEntry->pre = NULL;
 311             }
 312
 313             pEntry->pre = pFreeEntry;
 314             pFreeEntry->next = pEntry;
 315             break;
 316         }
 317
 318         pEntry = pEntry->next;
 319     }
 320
 321     if ( i == 0 )
 322     {
 323         wd->timerList.head = pFreeEntry;
 324     }
 325
 326     if ( i == count )
 327     {
 328         pFreeEntry->pre = pEntry->pre;
 329         pFreeEntry->pre->next = pFreeEntry;
 330         pEntry->pre = pFreeEntry;
 331         pFreeEntry->next = pEntry;
 332     }
 333
 334     wd->timerList.freeCount--;
 335     //zm_debug_msg1("free timer count = ", wd->timerList.freeCount);
 336
 337     return 0;
 338 }
 339
 340 u16_t zfTimerCancel(zdev_t* dev, u16_t event)
 341 {
 342     struct zsTimerEntry *pEntry;
 343     u8_t   i, count;
 344
 345     zmw_get_wlan_dev(dev);
 346
 347     //zm_debug_msg2("event = ", event);
 348     //zm_debug_msg1("free timer count(b) = ", wd->timerList.freeCount);
 349
 350     pEntry = wd->timerList.head;
 351     count = ZM_MAX_TIMER_COUNT - wd->timerList.freeCount;
 352
 353     for( i=0; i<count; i++ )
 354     {
 355         if ( pEntry->event == event )
 356         {
 357             if ( pEntry == wd->timerList.head )
 358             {   /* remove head entry */
 359                 wd->timerList.head = pEntry->next;
 360                 wd->timerList.tail->next = pEntry;
 361                 pEntry->pre = wd->timerList.tail;
 362                 wd->timerList.tail = pEntry;
 363                 pEntry = wd->timerList.head;
 364             }
 365             else
 366             {   /* remove non-head entry */
 367                 pEntry->pre->next = pEntry->next;
 368                 pEntry->next->pre = pEntry->pre;
 369                 wd->timerList.tail->next = pEntry;
 370                 pEntry->pre = wd->timerList.tail;
 371                 wd->timerList.tail = pEntry;
 372                 pEntry = pEntry->next;
 373             }
 374
 375             wd->timerList.freeCount++;
 376         }
 377         else
 378         {
 379             pEntry = pEntry->next;
 380         }
 381     }
 382
 383     //zm_debug_msg1("free timer count(a) = ", wd->timerList.freeCount);
 384
 385     return 0;
 386 }
 387
 388 void zfTimerClear(zdev_t* dev)
 389 {
 390     zmw_get_wlan_dev(dev);
 391
 392     wd->timerList.freeCount = ZM_MAX_TIMER_COUNT;
 393 }
 394
 395 u16_t zfTimerCheckAndHandle(zdev_t* dev)
 396 {
 397     struct zsTimerEntry *pEntry;
 398     struct zsTimerEntry *pTheLastEntry = NULL;
 399     u16_t  event[ZM_MAX_TIMER_COUNT];
 400     u8_t   i, j=0, count;
 401
 402     zmw_get_wlan_dev(dev);
 403
 404     zmw_declare_for_critical_section();
 405
 406     if ( !wd->bTimerReady )
 407     {
 408         return 0;
 409     }
 410
 411     zmw_enter_critical_section(dev);
 412
 413     pEntry = wd->timerList.head;
 414     count = ZM_MAX_TIMER_COUNT - wd->timerList.freeCount;
 415
 416     for( i=0; i<count; i++ )
 417     {
 418         // prevent from the case of tick overflow
 419         if ( ( pEntry->timer > wd->tick )&&
 420              ((pEntry->timer - wd->tick) < 1000000000) )
 421         {
 422             break;
 423         }
 424
 425         event[j++] = pEntry->event;
 426         pTheLastEntry = pEntry;
 427         pEntry = pEntry->next;
 428     }
 429
 430     if ( j > 0 )
 431     {
 432         wd->timerList.tail->next = wd->timerList.head;
 433         wd->timerList.head->pre = wd->timerList.tail;
 434         wd->timerList.head = pEntry;
 435         wd->timerList.tail = pTheLastEntry;
 436         wd->timerList.freeCount += j;
 437         //zm_debug_msg1("free timer count = ", wd->timerList.freeCount);
 438     }
 439
 440     zmw_leave_critical_section(dev);
 441
 442     zfProcessEvent(dev, event, j);
 443
 444     return 0;
 445 }
 446
 447 u32_t zfCoreSetKey(zdev_t* dev, u8_t user, u8_t keyId, u8_t type,
 448         u16_t* mac, u32_t* key)
 449 {
 450     u32_t ret;
 451
 452     zmw_get_wlan_dev(dev);
 453     zmw_declare_for_critical_section();
 454
 455     zmw_enter_critical_section(dev);
 456     wd->sta.flagKeyChanging++;
 457     zm_debug_msg1("   zfCoreSetKey++++ ", wd->sta.flagKeyChanging);
 458     zmw_leave_critical_section(dev);
 459
 460     ret = zfHpSetKey(dev, user, keyId, type, mac, key);
 461     return ret;
 462 }
 463
 464 void zfCoreSetKeyComplete(zdev_t* dev)
 465 {
 466     zmw_get_wlan_dev(dev);
 467     zmw_declare_for_critical_section();
 468
 469     if(wd->sta.flagKeyChanging)
 470     {
 471         zmw_enter_critical_section(dev);
 472         wd->sta.flagKeyChanging--;
 473         zmw_leave_critical_section(dev);
 474     }
 475     zm_debug_msg1("  zfCoreSetKeyComplete--- ", wd->sta.flagKeyChanging);
 476
 477     zfPushVtxq(dev);
 478 }
 479
 480 void zfCoreHalInitComplete(zdev_t* dev)
 481 {
 482     zmw_get_wlan_dev(dev);
 483     zmw_declare_for_critical_section();
 484
 485     zmw_enter_critical_section(dev);
 486     wd->halState = ZM_HAL_STATE_RUNNING;
 487     zmw_leave_critical_section(dev);
 488
 489     zfPushVtxq(dev);
 490 }
 491
 492 void zfCoreMacAddressNotify(zdev_t* dev, u8_t* addr)
 493 {
 494     zmw_get_wlan_dev(dev);
 495
 496     wd->macAddr[0] = addr[0] | ((u16_t)addr[1]<<8);
 497     wd->macAddr[1] = addr[2] | ((u16_t)addr[3]<<8);
 498     wd->macAddr[2] = addr[4] | ((u16_t)addr[5]<<8);
 499
 500
 501     //zfHpSetMacAddress(dev, wd->macAddr, 0);
 502     if (wd->zfcbMacAddressNotify != NULL)
 503     {
 504         wd->zfcbMacAddressNotify(dev, addr);
 505     }
 506 }
 507
 508 void zfCoreSetIsoName(zdev_t* dev, u8_t* isoName)
 509 {
 510     zmw_get_wlan_dev(dev);
 511
 512     wd->ws.countryIsoName[0] = isoName[0];
 513     wd->ws.countryIsoName[1] = isoName[1];
 514     wd->ws.countryIsoName[2] = '\0';
 515  }
 516
 517
 518 extern void zfScanMgrScanEventStart(zdev_t* dev);
 519 extern u8_t zfScanMgrScanEventTimeout(zdev_t* dev);
 520 extern void zfScanMgrScanEventRetry(zdev_t* dev);
 521
 522 void zfProcessEvent(zdev_t* dev, u16_t* eventArray, u8_t eventCount)
 523 {
 524     u8_t i, j, bypass = FALSE;
 525     u16_t eventBypass[32];
 526     u8_t eventBypassCount = 0;
 527
 528     zmw_get_wlan_dev(dev);
 529
 530     zmw_declare_for_critical_section();
 531
 532     zfZeroMemory((u8_t*) eventBypass, 64);
 533
 534     for( i=0; i<eventCount; i++ )
 535     {
 536         for( j=0; j<eventBypassCount; j++ )
 537         {
 538             if ( eventBypass[j] == eventArray[i] )
 539             {
 540                 bypass = TRUE;
 541                 break;
 542             }
 543         }
 544
 545         if ( bypass )
 546         {
 547             continue;
 548         }
 549
 550         switch( eventArray[i] )
 551         {
 552             case ZM_EVENT_SCAN:
 553                 {
 554                     zfScanMgrScanEventStart(dev);
 555                     eventBypass[eventBypassCount++] = ZM_EVENT_IN_SCAN;
 556                     eventBypass[eventBypassCount++] = ZM_EVENT_TIMEOUT_SCAN;
 557                 }
 558                 break;
 559
 560             case ZM_EVENT_TIMEOUT_SCAN:
 561                 {
 562                     u8_t res;
 563
 564                     res = zfScanMgrScanEventTimeout(dev);
 565                     if ( res == 0 )
 566                     {
 567                         eventBypass[eventBypassCount++] = ZM_EVENT_TIMEOUT_SCAN;
 568                     }
 569                     else if ( res == 1 )
 570                     {
 571                         eventBypass[eventBypassCount++] = ZM_EVENT_IN_SCAN;
 572                     }
 573                 }
 574                 break;
 575
 576             case ZM_EVENT_IBSS_MONITOR:
 577                 {
 578                     zfStaIbssMonitoring(dev, 0);
 579                 }
 580                 break;
 581
 582             case ZM_EVENT_IN_SCAN:
 583                 {
 584                     zfScanMgrScanEventRetry(dev);
 585                 }
 586                 break;
 587
 588             case ZM_EVENT_CM_TIMER:
 589                 {
 590                     zm_msg0_mm(ZM_LV_0, "ZM_EVENT_CM_TIMER");
 591
 592                     wd->sta.cmMicFailureCount = 0;
 593                 }
 594                 break;
 595
 596             case ZM_EVENT_CM_DISCONNECT:
 597                 {
 598                     zm_msg0_mm(ZM_LV_0, "ZM_EVENT_CM_DISCONNECT");
 599
 600                     zfChangeAdapterState(dev, ZM_STA_STATE_DISCONNECT);
 601
 602                     zmw_enter_critical_section(dev);
 603                     //zfTimerSchedule(dev, ZM_EVENT_CM_BLOCK_TIMER,
 604                     //                ZM_TICK_CM_BLOCK_TIMEOUT);
 605
 606                     /* Timer Resolution on WinXP is 15/16 ms  */
 607                     /* Decrease Time offset for <XP> Counter Measure */
 608                     zfTimerSchedule(dev, ZM_EVENT_CM_BLOCK_TIMER,
 609                                          ZM_TICK_CM_BLOCK_TIMEOUT - ZM_TICK_CM_BLOCK_TIMEOUT_OFFSET);
 610
 611                     zmw_leave_critical_section(dev);
 612                     wd->sta.cmMicFailureCount = 0;
 613                     //zfiWlanDisable(dev);
 614                     zfHpResetKeyCache(dev);
 615                     if (wd->zfcbConnectNotify != NULL)
 616                     {
 617                         wd->zfcbConnectNotify(dev, ZM_STATUS_MEDIA_DISCONNECT_MIC_FAIL,
 618                              wd->sta.bssid);
 619                     }
 620                 }
 621                 break;
 622
 623             case ZM_EVENT_CM_BLOCK_TIMER:
 624                 {
 625                     zm_msg0_mm(ZM_LV_0, "ZM_EVENT_CM_BLOCK_TIMER");
 626
 627                     //zmw_enter_critical_section(dev);
 628                     wd->sta.cmDisallowSsidLength = 0;
 629                     if ( wd->sta.bAutoReconnect )
 630                     {
 631                         zm_msg0_mm(ZM_LV_0, "ZM_EVENT_CM_BLOCK_TIMER:bAutoReconnect!=0");
 632                         zfScanMgrScanStop(dev, ZM_SCAN_MGR_SCAN_INTERNAL);
 633                         zfScanMgrScanStart(dev, ZM_SCAN_MGR_SCAN_INTERNAL);
 634                     }
 635                     //zmw_leave_critical_section(dev);
 636                 }
 637                 break;
 638
 639             case ZM_EVENT_TIMEOUT_ADDBA:
 640                 {
 641                     if (!wd->addbaComplete && (wd->addbaCount < 5))
 642                     {
 643                         zfAggSendAddbaRequest(dev, wd->sta.bssid, 0, 0);
 644                         wd->addbaCount++;
 645                         zfTimerSchedule(dev, ZM_EVENT_TIMEOUT_ADDBA, 100);
 646                     }
 647                     else
 648                     {
 649                         zfTimerCancel(dev, ZM_EVENT_TIMEOUT_ADDBA);
 650                     }
 651                 }
 652                 break;
 653
 654             #ifdef ZM_ENABLE_PERFORMANCE_EVALUATION
 655             case ZM_EVENT_TIMEOUT_PERFORMANCE:
 656                 {
 657                     zfiPerformanceRefresh(dev);
 658                 }
 659                 break;
 660             #endif
 661             case ZM_EVENT_SKIP_COUNTERMEASURE:
 662                                 //enable the Countermeasure
 663                                 {
 664                                         zm_debug_msg0("Countermeasure : Enable MIC Check ");
 665                                         wd->TKIP_Group_KeyChanging = 0x0;
 666                                 }
 667                                 break;
 668
 669             default:
 670                 break;
 671         }
 672     }
 673 }
 674
 675 void zfBssInfoCreate(zdev_t* dev)
 676 {
 677     u8_t   i;
 678
 679     zmw_get_wlan_dev(dev);
 680
 681     zmw_declare_for_critical_section();
 682
 683     zmw_enter_critical_section(dev);
 684
 685     wd->sta.bssList.bssCount = 0;
 686     wd->sta.bssList.head = NULL;
 687     wd->sta.bssList.tail = NULL;
 688     wd->sta.bssInfoArrayHead = 0;
 689     wd->sta.bssInfoArrayTail = 0;
 690     wd->sta.bssInfoFreeCount = ZM_MAX_BSS;
 691
 692     for( i=0; i< ZM_MAX_BSS; i++ )
 693     {
 694         //wd->sta.bssInfoArray[i] = &(wd->sta.bssInfoPool[i]);
 695         wd->sta.bssInfoArray[i] = zfwMemAllocate(dev, sizeof(struct zsBssInfo));
 696
 697     }
 698
 699     zmw_leave_critical_section(dev);
 700 }
 701
 702 void zfBssInfoDestroy(zdev_t* dev)
 703 {
 704     u8_t   i;
 705     zmw_get_wlan_dev(dev);
 706
 707     zfBssInfoRefresh(dev, 1);
 708
 709     for( i=0; i< ZM_MAX_BSS; i++ )
 710     {
 711         if (wd->sta.bssInfoArray[i] != NULL)
 712         {
 713             zfwMemFree(dev, wd->sta.bssInfoArray[i], sizeof(struct zsBssInfo));
 714         }
 715         else
 716         {
 717             zm_assert(0);
 718         }
 719     }
 720     return;
 721 }
 722
 723 struct zsBssInfo* zfBssInfoAllocate(zdev_t* dev)
 724 {
 725     struct zsBssInfo* pBssInfo;
 726
 727     zmw_get_wlan_dev(dev);
 728
 729     if (wd->sta.bssInfoFreeCount == 0)
 730         return NULL;
 731
 732     pBssInfo = wd->sta.bssInfoArray[wd->sta.bssInfoArrayHead];
 733     wd->sta.bssInfoArray[wd->sta.bssInfoArrayHead] = NULL;
 734     wd->sta.bssInfoArrayHead = (wd->sta.bssInfoArrayHead + 1) & (ZM_MAX_BSS - 1);
 735     wd->sta.bssInfoFreeCount--;
 736
 737     zfZeroMemory((u8_t*)pBssInfo, sizeof(struct zsBssInfo));
 738
 739     return pBssInfo;
 740 }
 741
 742 void zfBssInfoFree(zdev_t* dev, struct zsBssInfo* pBssInfo)
 743 {
 744     zmw_get_wlan_dev(dev);
 745
 746     zm_assert(wd->sta.bssInfoArray[wd->sta.bssInfoArrayTail] == NULL);
 747
 748     pBssInfo->signalStrength = pBssInfo->signalQuality = 0;
 749     pBssInfo->sortValue = 0;
 750
 751     wd->sta.bssInfoArray[wd->sta.bssInfoArrayTail] = pBssInfo;
 752     wd->sta.bssInfoArrayTail = (wd->sta.bssInfoArrayTail + 1) & (ZM_MAX_BSS - 1);
 753     wd->sta.bssInfoFreeCount++;
 754 }
 755
 756 void zfBssInfoReorderList(zdev_t* dev)
 757 {
 758     struct zsBssInfo* pBssInfo = NULL;
 759     struct zsBssInfo* pInsBssInfo = NULL;
 760     struct zsBssInfo* pNextBssInfo = NULL;
 761     struct zsBssInfo* pPreBssInfo = NULL;
 762     u8_t i = 0;
 763
 764     zmw_get_wlan_dev(dev);
 765
 766     zmw_declare_for_critical_section();
 767
 768     zmw_enter_critical_section(dev);
 769
 770     if (wd->sta.bssList.bssCount > 1)
 771     {
 772         pInsBssInfo = wd->sta.bssList.head;
 773         wd->sta.bssList.tail = pInsBssInfo;
 774         pBssInfo = pInsBssInfo->next;
 775         pInsBssInfo->next = NULL;
 776         while (pBssInfo != NULL)
 777         {
 778             i = 0;
 779             while (1)
 780             {
 781 //                if (pBssInfo->signalStrength >= pInsBssInfo->signalStrength)
 782                 if( pBssInfo->sortValue >= pInsBssInfo->sortValue)
 783                 {
 784                     if (i==0)
 785                     {
 786                         //Insert BssInfo to head
 787                         wd->sta.bssList.head = pBssInfo;
 788                         pNextBssInfo = pBssInfo->next;
 789                         pBssInfo->next = pInsBssInfo;
 790                         break;
 791                     }
 792                     else
 793                     {
 794                         //Insert BssInfo to neither head nor tail
 795                         pPreBssInfo->next = pBssInfo;
 796                         pNextBssInfo = pBssInfo->next;
 797                         pBssInfo->next = pInsBssInfo;
 798                         break;
 799                     }
 800                 }
 801                 else
 802                 {
 803                     if (pInsBssInfo->next != NULL)
 804                     {
 805                         //Signal strength smaller than current BssInfo, check next
 806                         pPreBssInfo = pInsBssInfo;
 807                         pInsBssInfo = pInsBssInfo->next;
 808                     }
 809                     else
 810                     {
 811                         //Insert BssInfo to tail
 812                         pInsBssInfo->next = pBssInfo;
 813                         pNextBssInfo = pBssInfo->next;
 814                         wd->sta.bssList.tail = pBssInfo;
 815                         pBssInfo->next = NULL;
 816                         break;
 817                     }
 818                 }
 819                 i++;
 820             }
 821             pBssInfo = pNextBssInfo;
 822             pInsBssInfo = wd->sta.bssList.head;
 823         }
 824     } //if (wd->sta.bssList.bssCount > 1)
 825
 826     zmw_leave_critical_section(dev);
 827 }
 828
 829 void zfBssInfoInsertToList(zdev_t* dev, struct zsBssInfo* pBssInfo)
 830 {
 831     zmw_get_wlan_dev(dev);
 832
 833     zm_assert(pBssInfo);
 834
 835     //zm_debug_msg2("pBssInfo = ", pBssInfo);
 836
 837     if ( wd->sta.bssList.bssCount == 0 )
 838     {
 839         wd->sta.bssList.head = pBssInfo;
 840         wd->sta.bssList.tail = pBssInfo;
 841     }
 842     else
 843     {
 844         wd->sta.bssList.tail->next = pBssInfo;
 845         wd->sta.bssList.tail = pBssInfo;
 846     }
 847
 848     pBssInfo->next = NULL;
 849     wd->sta.bssList.bssCount++;
 850
 851     //zm_debug_msg2("bss count = ", wd->sta.bssList.bssCount);
 852 }
 853
 854 void zfBssInfoRemoveFromList(zdev_t* dev, struct zsBssInfo* pBssInfo)
 855 {
 856     struct zsBssInfo* pNowBssInfo;
 857     struct zsBssInfo* pPreBssInfo = NULL;
 858     u8_t   i;
 859
 860     zmw_get_wlan_dev(dev);
 861
 862     zm_assert(pBssInfo);
 863     zm_assert(wd->sta.bssList.bssCount);
 864
 865     //zm_debug_msg2("pBssInfo = ", pBssInfo);
 866
 867     pNowBssInfo = wd->sta.bssList.head;
 868
 869     for( i=0; i<wd->sta.bssList.bssCount; i++ )
 870     {
 871         if ( pNowBssInfo == pBssInfo )
 872         {
 873             if ( i == 0 )
 874             {   /* remove head */
 875                 wd->sta.bssList.head = pBssInfo->next;
 876             }
 877             else
 878             {
 879                 pPreBssInfo->next = pBssInfo->next;
 880             }
 881
 882             if ( i == (wd->sta.bssList.bssCount - 1) )
 883             {   /* remove tail */
 884                 wd->sta.bssList.tail = pPreBssInfo;
 885             }
 886
 887             break;
 888         }
 889
 890         pPreBssInfo = pNowBssInfo;
 891         pNowBssInfo = pNowBssInfo->next;
 892     }
 893
 894     zm_assert(i != wd->sta.bssList.bssCount);
 895     wd->sta.bssList.bssCount--;
 896
 897     //zm_debug_msg2("bss count = ", wd->sta.bssList.bssCount);
 898 }
 899
 900 void zfBssInfoRefresh(zdev_t* dev, u16_t mode)
 901 {
 902     struct zsBssInfo*   pBssInfo;
 903     struct zsBssInfo*   pNextBssInfo;
 904     u8_t   i, bssCount;
 905
 906     zmw_get_wlan_dev(dev);
 907
 908     pBssInfo = wd->sta.bssList.head;
 909     bssCount = wd->sta.bssList.bssCount;
 910
 911     for( i=0; i<bssCount; i++ )
 912     {
 913         if (mode == 1)
 914         {
 915             pNextBssInfo = pBssInfo->next;
 916             zfBssInfoRemoveFromList(dev, pBssInfo);
 917             zfBssInfoFree(dev, pBssInfo);
 918             pBssInfo = pNextBssInfo;
 919         }
 920         else
 921         {
 922             if ( pBssInfo->flag & ZM_BSS_INFO_VALID_BIT )
 923             {   /* this one must be kept */
 924                 pBssInfo->flag &= ~ZM_BSS_INFO_VALID_BIT;
 925                 pBssInfo = pBssInfo->next;
 926             }
 927             else
 928             {
 929                 #define ZM_BSS_CACHE_TIME_IN_MS   20000
 930                 if ((wd->tick - pBssInfo->tick) > (ZM_BSS_CACHE_TIME_IN_MS/ZM_MS_PER_TICK))
 931                 {
 932                     pNextBssInfo = pBssInfo->next;
 933                     zfBssInfoRemoveFromList(dev, pBssInfo);
 934                     zfBssInfoFree(dev, pBssInfo);
 935                     pBssInfo = pNextBssInfo;
 936                 }
 937                 else
 938                 {
 939                     pBssInfo = pBssInfo->next;
 940                 }
 941             }
 942         }
 943     } //for( i=0; i<bssCount; i++ )
 944     return;
 945 }
 946
 947 void zfDumpSSID(u8_t length, u8_t *value)
 948 {
 949     u8_t buf[50];
 950     u8_t tmpLength = length;
 951
 952     if ( tmpLength > 49 )
 953     {
 954         tmpLength = 49;
 955     }
 956
 957     zfMemoryCopy(buf, value, tmpLength);
 958     buf[tmpLength] = '\0';
 959     //printk("SSID: %s\n", buf);
 960     //zm_debug_msg_s("ssid = ", value);
 961 }
 962
 963 void zfCoreReinit(zdev_t* dev)
 964 {
 965     zmw_get_wlan_dev(dev);
 966
 967     wd->sta.flagKeyChanging = 0;
 968     wd->sta.flagFreqChanging = 0;
 969 }
 970
 971 void zfGenerateRandomBSSID(zdev_t* dev, u8_t *MACAddr, u8_t *BSSID)
 972 {
 973     //ULONGLONG   time;
 974     u32_t time;
 975
 976     zmw_get_wlan_dev(dev);
 977
 978     time = wd->tick;
 979
 980     //
 981     // Initialize the random BSSID to be the same as MAC address.
 982     //
 983
 984     // RtlCopyMemory(BSSID, MACAddr, sizeof(DOT11_MAC_ADDRESS));
 985     zfMemoryCopy(BSSID, MACAddr, 6);
 986
 987     //
 988     // Get the system time in 10 millisecond.
 989     //
 990
 991     // NdisGetCurrentSystemTime((PLARGE_INTEGER)&time);
 992     // time /= 100000;
 993
 994     //
 995     // Randomize the first 4 bytes of BSSID.
 996     //
 997
 998     BSSID[0] ^= (u8_t)(time & 0xff);
 999     BSSID[0] &= ~0x01;              // Turn off multicast bit
1000     BSSID[0] |= 0x02;               // Turn on local bit
1001
1002     time >>= 8;
1003     BSSID[1] ^= (u8_t)(time & 0xff);
1004
1005     time >>= 8;
1006     BSSID[2] ^= (u8_t)(time & 0xff);
1007
1008     time >>= 8;
1009     BSSID[3] ^= (u8_t)(time & 0xff);
1010 }
1011
1012 u8_t zfiWlanGetDestAddrFromBuf(zdev_t *dev, zbuf_t *buf, u16_t *macAddr)
1013 {
1014 #ifdef ZM_ENABLE_NATIVE_WIFI
1015     zmw_get_wlan_dev(dev);
1016
1017     if ( wd->wlanMode == ZM_MODE_INFRASTRUCTURE )
1018     {
1019         /* DA */
1020         macAddr[0] = zmw_tx_buf_readh(dev, buf, 16);
1021         macAddr[1] = zmw_tx_buf_readh(dev, buf, 18);
1022         macAddr[2] = zmw_tx_buf_readh(dev, buf, 20);
1023     }
1024     else if ( wd->wlanMode == ZM_MODE_IBSS )
1025     {
1026         /* DA */
1027         macAddr[0] = zmw_tx_buf_readh(dev, buf, 4);
1028         macAddr[1] = zmw_tx_buf_readh(dev, buf, 6);
1029         macAddr[2] = zmw_tx_buf_readh(dev, buf, 8);
1030     }
1031     else if ( wd->wlanMode == ZM_MODE_AP )
1032     {
1033         /* DA */
1034         macAddr[0] = zmw_tx_buf_readh(dev, buf, 4);
1035         macAddr[1] = zmw_tx_buf_readh(dev, buf, 6);
1036         macAddr[2] = zmw_tx_buf_readh(dev, buf, 8);
1037     }
1038     else
1039     {
1040         return 1;
1041     }
1042 #else
1043     /* DA */
1044     macAddr[0] = zmw_tx_buf_readh(dev, buf, 0);
1045     macAddr[1] = zmw_tx_buf_readh(dev, buf, 2);
1046     macAddr[2] = zmw_tx_buf_readh(dev, buf, 4);
1047 #endif
1048
1049     return 0;
1050 }
1051
1052 /* Leave an empty line below to remove warning message on some compiler */
1053
1054 u16_t zfFindCleanFrequency(zdev_t* dev, u32_t adhocMode)
1055 {
1056     u8_t   i, j;
1057     u16_t  returnChannel;
1058     u16_t  count_24G = 0, min24GIndex = 0;
1059     u16_t  count_5G = 0,  min5GIndex = 0;
1060     u16_t  CombinationBssNumberIn24G[15] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
1061     u16_t  BssNumberIn24G[17]  = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
1062     u16_t  Array_24G[15]       = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
1063     u16_t  BssNumberIn5G[31]   = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
1064     u16_t  Array_5G[31]        = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
1065     struct zsBssInfo* pBssInfo;
1066
1067     zmw_get_wlan_dev(dev);
1068
1069     pBssInfo = wd->sta.bssList.head;
1070     if (pBssInfo == NULL)
1071     {
1072         if( adhocMode == ZM_ADHOCBAND_B || adhocMode == ZM_ADHOCBAND_G ||
1073             adhocMode == ZM_ADHOCBAND_BG || adhocMode == ZM_ADHOCBAND_ABG )
1074         {
1075             returnChannel = zfChGetFirst2GhzChannel(dev);
1076         }
1077         else
1078         {
1079             returnChannel = zfChGetFirst5GhzChannel(dev);
1080         }
1081
1082         return returnChannel;
1083     }
1084
1085     /* #1 Get Allowed Channel following Country Code ! */
1086     zmw_declare_for_critical_section();
1087     zmw_enter_critical_section(dev);
1088     for (i = 0; i < wd->regulationTable.allowChannelCnt; i++)
1089     {
1090         if (wd->regulationTable.allowChannel[i].channel < 3000)
1091         { // 2.4GHz
1092             Array_24G[count_24G] = wd->regulationTable.allowChannel[i].channel;
1093             count_24G++;
1094         }
1095         else
1096         { // 5GHz
1097             count_5G++;
1098             Array_5G[i] = wd->regulationTable.allowChannel[i].channel;
1099         }
1100     }
1101     zmw_leave_critical_section(dev);
1102
1103     while( pBssInfo != NULL )
1104     {
1105         /* #2_1 Count BSS number in some specificed frequency in 2.4GHz band ! */
1106         if( adhocMode == ZM_ADHOCBAND_B || adhocMode == ZM_ADHOCBAND_G ||
1107             adhocMode == ZM_ADHOCBAND_BG || adhocMode == ZM_ADHOCBAND_ABG )
1108         {
1109             for( i=0; i<=(count_24G+3); i++ )
1110             {
1111                 if( pBssInfo->frequency == Array_24G[i] )
1112                 { // Array_24G[0] correspond to BssNumberIn24G[2]
1113                     BssNumberIn24G[pBssInfo->channel+1]++;
1114                 }
1115             }
1116         }
1117
1118         /* #2_2 Count BSS number in some specificed frequency in 5GHz band ! */
1119         if( adhocMode == ZM_ADHOCBAND_A || adhocMode == ZM_ADHOCBAND_ABG )
1120         {
1121             for( i=0; i<count_5G; i++ )
1122             { // 5GHz channel is not equal to array index
1123                 if( pBssInfo->frequency == Array_5G[i] )
1124                 { // Array_5G[0] correspond to BssNumberIn5G[0]
1125                     BssNumberIn5G[i]++;
1126                 }
1127             }
1128         }
1129
1130         pBssInfo = pBssInfo->next;
1131     }
1132
1133
1134     if( adhocMode == ZM_ADHOCBAND_B || adhocMode == ZM_ADHOCBAND_G ||
1135         adhocMode == ZM_ADHOCBAND_BG || adhocMode == ZM_ADHOCBAND_ABG )
1136     {
1137         /* #3_1 Count BSS number that influence the specificed frequency in 2.4GHz ! */
1138         for( j=0; j<count_24G; j++ )
1139         {
1140             CombinationBssNumberIn24G[j] = BssNumberIn24G[j]   + BssNumberIn24G[j+1] +
1141                                            BssNumberIn24G[j+2] + BssNumberIn24G[j+3] +
1142                                            BssNumberIn24G[j+4];
1143             //printk("After combine, the number of BSS network channel %d is %d",
1144             //                                   j , CombinationBssNumberIn24G[j]);
1145         }
1146
1147         /* #4_1 Find the less utilized frequency in 2.4GHz band ! */
1148         min24GIndex = zfFindMinimumUtilizationChannelIndex(dev, CombinationBssNumberIn24G, count_24G);
1149     }
1150
1151     /* #4_2 Find the less utilized frequency in 5GHz band ! */
1152     if( adhocMode == ZM_ADHOCBAND_A || adhocMode == ZM_ADHOCBAND_ABG )
1153     {
1154         min5GIndex = zfFindMinimumUtilizationChannelIndex(dev, BssNumberIn5G, count_5G);
1155     }
1156
1157     if( adhocMode == ZM_ADHOCBAND_B || adhocMode == ZM_ADHOCBAND_G || adhocMode == ZM_ADHOCBAND_BG )
1158     {
1159         return Array_24G[min24GIndex];
1160     }
1161     else if( adhocMode == ZM_ADHOCBAND_A )
1162     {
1163         return Array_5G[min5GIndex];
1164     }
1165     else if( adhocMode == ZM_ADHOCBAND_ABG )
1166     {
1167         if ( CombinationBssNumberIn24G[min24GIndex] <= BssNumberIn5G[min5GIndex] )
1168             return Array_24G[min24GIndex];
1169         else
1170             return Array_5G[min5GIndex];
1171     }
1172     else
1173         return 2412;
1174 }
1175
1176 u16_t zfFindMinimumUtilizationChannelIndex(zdev_t* dev, u16_t* array, u16_t count)
1177 {
1178     u8_t   i;
1179     u16_t  tempMinIndex, tempMinValue;
1180
1181     i = 1;
1182     tempMinIndex = 0;
1183     tempMinValue = array[tempMinIndex];
1184     while( i< count )
1185     {
1186         if( array[i] < tempMinValue )
1187         {
1188             tempMinValue = array[i];
1189             tempMinIndex = i;
1190         }
1191         i++;
1192     }
1193
1194     return tempMinIndex;
1195 }
1196
1197 u8_t zfCompareWithBssid(zdev_t* dev, u16_t* bssid)
1198 {
1199     zmw_get_wlan_dev(dev);
1200
1201     if ( zfMemoryIsEqual((u8_t*)bssid, (u8_t*)wd->sta.bssid, 6) )
1202     {
1203         return 1;
1204     }
1205     else
1206     {
1207         return 0;
1208     }
1209 }