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