1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26#include "cprecomp.h"
27#include "../hal/hpreg.h"
28
29
30
31
32
33
34
35
36
37
38
39
40
41
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);
62#else
63 addr[5] = vapId + 1 + (u8_t)(wd->macAddr[2] >> 8);
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
118 u8_t i, j, bdrop = 0, k = 0, Same_Count = 0;
119 u8_t bssid[6];
120
121
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 {
154 Same_Count++;
155 }
156 else
157 {
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
233
234
235
236
237
238
239
240
241
242
243
244
245void zfiWlanFlushBssList(zdev_t* dev)
246{
247 zmw_declare_for_critical_section();
248
249 zmw_enter_critical_section(dev);
250
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 {
329 wd->fragThreshold = 32767;
330 }
331 else if (fragThreshold < 256)
332 {
333
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 {
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
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
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
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#if 1
494
495 u8_t res, peerIdx;
496
497 zmw_get_wlan_dev(dev);
498
499 zmw_declare_for_critical_section();
500
501 zmw_enter_critical_section(dev);
502 res = zfStaFindOppositeByMACAddr(dev, (u16_t *)staMacAddr, &peerIdx);
503 if( res == 0 )
504 {
505 isInstalled = wd->sta.oppositeInfo[peerIdx].pkInstalled;
506 }
507 zmw_leave_critical_section(dev);
508
509#endif
510
511 return isInstalled;
512}
513
514u8_t zfiWlanSetKey(zdev_t* dev, struct zsKeyInfo keyInfo)
515{
516 u16_t broadcast[3] = {0xffff, 0xffff, 0xffff};
517 u32_t* key;
518 u8_t encryMode = ZM_NO_WEP;
519#ifdef ZM_ENABLE_IBSS_WPA2PSK
520 u8_t encryType = ZM_NO_WEP;
521#endif
522 u8_t micKey[16];
523 u16_t id = 0;
524 u8_t vapId, i, addr[6];
525 u8_t userIdx=0;
526
527#ifdef ZM_ENABLE_IBSS_WPA2PSK
528
529 u8_t res, peerIdx;
530
531
532 zmw_get_wlan_dev(dev);
533
534 if ( wd->sta.ibssWpa2Psk == 1 )
535 {
536 zmw_enter_critical_section(dev);
537 res = zfStaFindOppositeByMACAddr(dev, (u16_t*)keyInfo.macAddr, &peerIdx);
538 if( res == 0 )
539 {
540 userIdx = peerIdx;
541 if ( wd->sta.oppositeInfo[userIdx].camIdx == 0xff )
542 wd->sta.oppositeInfo[userIdx].camIdx = userIdx;
543 }
544 zmw_leave_critical_section(dev);
545 }
546#else
547 zmw_get_wlan_dev(dev);
548#endif
549
550 if ( keyInfo.flag & ZM_KEY_FLAG_AUTHENTICATOR )
551 {
552
553 if (keyInfo.flag & ZM_KEY_FLAG_PK)
554 {
555
556 if ((id = zfApFindSta(dev, keyInfo.macAddr)) == 0xffff)
557 {
558
559 return ZM_STATUS_FAILURE;
560 }
561
562 wd->ap.staTable[id].iv16 = 0;
563 wd->ap.staTable[id].iv32 = 0;
564
565 if (keyInfo.keyLength == 32)
566 {
567
568
569
570
571
572
573
574#ifdef ZM_ENABLE_CENC
575 if (keyInfo.flag & ZM_KEY_FLAG_CENC)
576 {
577 zm_debug_msg0("Set CENC pairwise Key");
578
579 wd->ap.staTable[id].encryMode = ZM_CENC;
580
581
582 wd->ap.staTable[id].txiv[0] = 0x5c365c37;
583 wd->ap.staTable[id].txiv[1] = 0x5c365c36;
584 wd->ap.staTable[id].txiv[2] = 0x5c365c36;
585 wd->ap.staTable[id].txiv[3] = 0x5c365c36;
586
587 wd->ap.staTable[id].rxiv[0] = 0x5c365c36;
588 wd->ap.staTable[id].rxiv[1] = 0x5c365c36;
589 wd->ap.staTable[id].rxiv[2] = 0x5c365c36;
590 wd->ap.staTable[id].rxiv[3] = 0x5c365c36;
591
592
593 wd->ap.staTable[id].cencKeyIdx = keyInfo.keyIndex;
594
595
596
597 }
598 else
599#endif
600 {
601 wd->ap.staTable[id].encryMode = ZM_TKIP;
602
603 zfMemoryCopy(micKey, &keyInfo.key[16], 8);
604 zfMemoryCopy(&micKey[8], &keyInfo.key[24], 8);
605
606
607
608
609
610 zfMemoryCopy((u8_t *)&(wd->ap.staTable[id].txMicKey), &(keyInfo.key[16]), 8);
611 zfMemoryCopy((u8_t *)&(wd->ap.staTable[id].rxMicKey), &(keyInfo.key[24]), 8);
612
613 }
614 }
615 else if (keyInfo.keyLength == 16)
616 {
617 wd->ap.staTable[id].encryMode = ZM_AES;
618 }
619 else if (keyInfo.keyLength == 0)
620 {
621
622 zfApClearStaKey(dev, (u16_t *)keyInfo.macAddr);
623
624 return ZM_STATUS_SUCCESS;
625 }
626 else
627 {
628 return ZM_STATUS_FAILURE;
629 }
630
631
632
633 zfHpSetApPairwiseKey(dev, (u16_t *)keyInfo.macAddr,
634 wd->ap.staTable[id].encryMode, (u32_t*) keyInfo.key,
635 (u32_t*) &keyInfo.key[16], id+1);
636 wd->ap.staTable[id].keyIdx = id + 1 + 4;
637 }
638 else if (keyInfo.flag & ZM_KEY_FLAG_GK)
639 {
640 vapId = keyInfo.vapId;
641
642 wd->ap.iv16[vapId] = 0;
643 wd->ap.iv32[vapId] = 0;
644
645 if (keyInfo.keyLength == 32)
646 {
647
648
649
650
651#ifdef ZM_ENABLE_CENC
652 if (keyInfo.flag & ZM_KEY_FLAG_CENC)
653 {
654 encryMode = ZM_CENC;
655 zm_debug_msg0("Set CENC group Key");
656
657
658 wd->ap.txiv[vapId][0] = 0x5c365c36;
659 wd->ap.txiv[vapId][1] = 0x5c365c36;
660 wd->ap.txiv[vapId][2] = 0x5c365c36;
661 wd->ap.txiv[vapId][3] = 0x5c365c36;
662
663
664
665 key = (u32_t*) keyInfo.key;
666 }
667 else
668#endif
669 {
670 encryMode = ZM_TKIP;
671 key = (u32_t *)keyInfo.key;
672
673
674
675
676
677
678
679 zfMicSetKey(&(keyInfo.key[16]), &(wd->ap.bcMicKey[0]));
680 key = (u32_t*) keyInfo.key;
681 }
682 }
683 else if (keyInfo.keyLength == 16)
684 {
685 encryMode = ZM_AES;
686 key = (u32_t *)keyInfo.key;
687 zm_debug_msg0("CWY - Set AES Group Key");
688 }
689 else if (keyInfo.keyLength == 0)
690 {
691
692 zfApClearStaKey(dev, broadcast);
693
694
695 wd->ap.capab[vapId] &= 0xffef;
696
697 return ZM_STATUS_SUCCESS;
698 }
699 else
700 {
701 if (keyInfo.keyLength == 5)
702 {
703 encryMode = ZM_WEP64;
704 }
705 else if (keyInfo.keyLength == 13)
706 {
707 encryMode = ZM_WEP128;
708 }
709 else if (keyInfo.keyLength == 29)
710 {
711 encryMode = ZM_WEP256;
712 }
713
714 key = (u32_t*) keyInfo.key;
715 }
716
717
718
719
720
721 zfHpSetApGroupKey(dev, wd->macAddr, encryMode,
722 key, (u32_t*) &keyInfo.key[16], vapId);
723
724
725 wd->ws.encryMode = encryMode;
726
727
728 wd->ap.encryMode[vapId] = encryMode;
729
730
731 wd->ap.bcKeyIndex[vapId] = keyInfo.keyIndex;
732 wd->ap.bcHalKeyIdx[vapId] = vapId + 60;
733
734
735 wd->ap.capab[vapId] |= 0x10;
736 }
737 }
738 else
739 {
740
741 if ( keyInfo.flag & ZM_KEY_FLAG_PK )
742 {
743
744
745
746
747
748
749#ifdef ZM_ENABLE_IBSS_WPA2PSK
750 if ( wd->sta.ibssWpa2Psk == 1 )
751 {
752
753 wd->sta.oppositeInfo[userIdx].iv16 = 0;
754 wd->sta.oppositeInfo[userIdx].iv32 = 0;
755 }
756 else
757 {
758 wd->sta.iv16 = 0;
759 wd->sta.iv32 = 0;
760 }
761
762 wd->sta.oppositeInfo[userIdx].pkInstalled = 1;
763#else
764 wd->sta.iv16 = 0;
765 wd->sta.iv32 = 0;
766
767 wd->sta.oppositeInfo[userIdx].pkInstalled = 1;
768#endif
769
770 if ( keyInfo.keyLength == 32 )
771 {
772 zfTkipInit(keyInfo.key, (u8_t*) wd->macAddr,
773 &wd->sta.txSeed, keyInfo.initIv);
774 zfTkipInit(keyInfo.key, (u8_t*) wd->sta.bssid,
775 &wd->sta.rxSeed[keyInfo.keyIndex], keyInfo.initIv);
776
777#ifdef ZM_ENABLE_CENC
778 if (keyInfo.flag & ZM_KEY_FLAG_CENC)
779 {
780 zm_debug_msg0("Set CENC pairwise Key");
781
782 wd->sta.encryMode = ZM_CENC;
783
784
785 wd->sta.txiv[0] = 0x5c365c36;
786 wd->sta.txiv[1] = 0x5c365c36;
787 wd->sta.txiv[2] = 0x5c365c36;
788 wd->sta.txiv[3] = 0x5c365c36;
789
790 wd->sta.rxiv[0] = 0x5c365c37;
791 wd->sta.rxiv[1] = 0x5c365c36;
792 wd->sta.rxiv[2] = 0x5c365c36;
793 wd->sta.rxiv[3] = 0x5c365c36;
794
795
796 wd->sta.cencKeyId = keyInfo.keyIndex;
797
798
799
800 }
801 else
802#endif
803 {
804 wd->sta.encryMode = ZM_TKIP;
805
806
807
808
809 zfMicSetKey(&keyInfo.key[16], &wd->sta.txMicKey);
810 zfMicSetKey(&keyInfo.key[24],
811 &wd->sta.rxMicKey[keyInfo.keyIndex]);
812 }
813 }
814 else if ( keyInfo.keyLength == 16 )
815 {
816#ifdef ZM_ENABLE_IBSS_WPA2PSK
817 if ( wd->sta.ibssWpa2Psk == 1 )
818 {
819 wd->sta.oppositeInfo[userIdx].encryMode = ZM_AES;
820 encryType = wd->sta.oppositeInfo[userIdx].encryMode;
821 }
822 else
823 {
824 wd->sta.encryMode = ZM_AES;
825 encryType = wd->sta.encryMode;
826 }
827#else
828 wd->sta.encryMode = ZM_AES;
829#endif
830 }
831 else
832 {
833 return ZM_STATUS_FAILURE;
834 }
835
836
837
838
839
840
841
842#ifdef ZM_ENABLE_IBSS_WPA2PSK
843 if ( (keyInfo.keyLength==16) && (wd->sta.ibssWpa2Psk==1) )
844 {
845 zfHpSetPerUserKey(dev,
846 userIdx,
847 keyInfo.keyIndex,
848 (u8_t*)keyInfo.macAddr,
849 encryType,
850
851 (u32_t*) keyInfo.key, (u32_t*) &keyInfo.key[16]);
852
853 wd->sta.oppositeInfo[userIdx].wpaState = ZM_STA_WPA_STATE_PK_OK ;
854 }
855 else
856 {
857 for (i = 0; i < 3; i++)
858 {
859 addr[2 * i] = wd->sta.bssid[i] & 0xff;
860 addr[2 * i + 1] = wd->sta.bssid[i] >> 8;
861 }
862 zfHpSetPerUserKey(dev,
863 ZM_USER_KEY_PK,
864 0,
865 addr,
866 wd->sta.encryMode,
867 (u32_t*) keyInfo.key, (u32_t*) &keyInfo.key[16]);
868
869 wd->sta.keyId = 4;
870 }
871#else
872
873 for (i = 0; i < 3; i++)
874 {
875 addr[2 * i] = wd->sta.bssid[i] & 0xff;
876 addr[2 * i + 1] = wd->sta.bssid[i] >> 8;
877 }
878 zfHpSetPerUserKey(dev,
879 ZM_USER_KEY_PK,
880 0,
881 addr,
882 wd->sta.encryMode,
883 (u32_t*) keyInfo.key, (u32_t*) &keyInfo.key[16]);
884
885 wd->sta.keyId = 4;
886#endif
887
888 wd->sta.wpaState = ZM_STA_WPA_STATE_PK_OK;
889 }
890 else if ( keyInfo.flag & ZM_KEY_FLAG_GK )
891 {
892
893 zfTkipInit(keyInfo.key, (u8_t*) wd->sta.bssid,
894 &wd->sta.rxSeed[keyInfo.keyIndex], keyInfo.initIv);
895
896 if ( keyInfo.keyLength == 32 )
897 {
898#ifdef ZM_ENABLE_CENC
899 if (keyInfo.flag & ZM_KEY_FLAG_CENC)
900 {
901 encryMode = ZM_CENC;
902 zm_debug_msg0("Set CENC group Key");
903
904
905 wd->sta.rxivGK[0] = 0x5c365c36;
906 wd->sta.rxivGK[1] = 0x5c365c36;
907 wd->sta.rxivGK[2] = 0x5c365c36;
908 wd->sta.rxivGK[3] = 0x5c365c36;
909
910
911
912 key = (u32_t*) keyInfo.key;
913 }
914 else
915#endif
916 {
917 encryMode = ZM_TKIP;
918 key = (u32_t*) wd->sta.rxSeed[keyInfo.keyIndex].tk;
919
920 if ( !(keyInfo.flag & ZM_KEY_FLAG_INIT_IV) )
921 {
922 wd->sta.rxSeed[keyInfo.keyIndex].iv16 = 0;
923 wd->sta.rxSeed[keyInfo.keyIndex].iv32 = 0;
924 }
925
926
927
928
929
930 zfMicSetKey(&keyInfo.key[24],
931 &wd->sta.rxMicKey[keyInfo.keyIndex]);
932 }
933 }
934 else if ( keyInfo.keyLength == 16 )
935 {
936 encryMode = ZM_AES;
937
938 }
939 else
940 {
941 if ( keyInfo.keyLength == 5 )
942 {
943 encryMode = ZM_WEP64;
944 }
945 else if ( keyInfo.keyLength == 13 )
946 {
947 encryMode = ZM_WEP128;
948 }
949 else if ( keyInfo.keyLength == 29 )
950 {
951 encryMode = ZM_WEP256;
952 }
953
954 key = (u32_t*) keyInfo.key;
955 }
956
957
958
959
960
961
962#ifdef ZM_ENABLE_IBSS_WPA2PSK
963 if ( (keyInfo.keyLength==16) && (wd->sta.ibssWpa2Psk==1) )
964 {
965 zfHpSetPerUserKey(dev,
966 userIdx,
967 keyInfo.keyIndex,
968
969 (u8_t*)keyInfo.macAddr,
970 encryMode,
971 (u32_t*) keyInfo.key, (u32_t*) &keyInfo.key[16]);
972 }
973 else
974 {
975 zfHpSetPerUserKey(dev,
976 ZM_USER_KEY_GK,
977 0,
978 (u8_t *)broadcast,
979 encryMode,
980 (u32_t*) keyInfo.key, (u32_t*) &keyInfo.key[16]);
981
982 wd->sta.wpaState = ZM_STA_WPA_STATE_GK_OK;
983 }
984#else
985 zfHpSetPerUserKey(dev,
986 ZM_USER_KEY_GK,
987 0,
988 (u8_t *)broadcast,
989 encryMode,
990 (u32_t*) keyInfo.key, (u32_t*) &keyInfo.key[16]);
991
992 wd->sta.wpaState = ZM_STA_WPA_STATE_GK_OK;
993#endif
994 }
995 else
996 {
997 zm_debug_msg0("legacy WEP");
998
999 if ( keyInfo.keyIndex >= 4 )
1000 {
1001 return ZM_STATUS_FAILURE;
1002 }
1003
1004 if ( keyInfo.keyLength == 5 )
1005 {
1006 zm_debug_msg0("WEP 64");
1007
1008 encryMode = ZM_WEP64;
1009 }
1010 else if ( keyInfo.keyLength == 13 )
1011 {
1012 zm_debug_msg0("WEP 128");
1013
1014 encryMode = ZM_WEP128;
1015 }
1016 else if ( keyInfo.keyLength == 32 )
1017 {
1018
1019 #if 0
1020
1021 if ( wd->sta.wpaState != ZM_STA_WPA_STATE_PK_OK )
1022 {
1023 wd->sta.iv16 = 0;
1024 wd->sta.iv32 = 0;
1025 }
1026 #endif
1027
1028 encryMode = ZM_TKIP;
1029
1030 zfTkipInit(keyInfo.key, (u8_t*) wd->sta.bssid,
1031 &wd->sta.rxSeed[keyInfo.keyIndex], keyInfo.initIv);
1032 zfMicSetKey(&keyInfo.key[24],
1033 &wd->sta.rxMicKey[keyInfo.keyIndex]);
1034 }
1035 else if ( keyInfo.keyLength == 16 )
1036 {
1037
1038 #if 0
1039
1040 if ( wd->sta.wpaState != ZM_STA_WPA_STATE_PK_OK )
1041 {
1042
1043
1044 wd->sta.iv16 = 0;
1045 wd->sta.iv32 = 0;
1046 }
1047 #endif
1048
1049 encryMode = ZM_AES;
1050 }
1051 else if ( keyInfo.keyLength == 29 )
1052 {
1053 zm_debug_msg0("WEP 256");
1054
1055 encryMode = ZM_WEP256;
1056
1057
1058 }
1059 else
1060 {
1061 return ZM_STATUS_FAILURE;
1062 }
1063
1064 {
1065 u8_t i;
1066
1067 zm_debug_msg0("key = ");
1068 for(i = 0; i < keyInfo.keyLength; i++)
1069 {
1070 zm_debug_msg2("", keyInfo.key[i]);
1071 }
1072 }
1073
1074 if ( keyInfo.flag & ZM_KEY_FLAG_DEFAULT_KEY )
1075 {
1076
1077 vapId = 0;
1078 wd->ap.bcHalKeyIdx[vapId] = keyInfo.keyIndex;
1079 wd->ap.bcKeyIndex[vapId] = keyInfo.keyIndex;
1080 wd->sta.keyId = keyInfo.keyIndex;
1081 }
1082
1083 if(encryMode == ZM_TKIP)
1084 {
1085 if(wd->TKIP_Group_KeyChanging == 0x1)
1086 {
1087 zm_debug_msg0("Countermeasure : Cancel Old Timer ");
1088 zfTimerCancel(dev, ZM_EVENT_SKIP_COUNTERMEASURE);
1089 }
1090 else
1091 {
1092 zm_debug_msg0("Countermeasure : Create New Timer ");
1093 }
1094
1095 wd->TKIP_Group_KeyChanging = 0x1;
1096 zfTimerSchedule(dev, ZM_EVENT_SKIP_COUNTERMEASURE, 150);
1097 }
1098
1099
1100
1101
1102
1103
1104
1105
1106
1107 if ( encryMode == ZM_TKIP ||
1108 encryMode == ZM_AES )
1109 {
1110 zfHpSetDefaultKey(dev, keyInfo.keyIndex, encryMode,
1111 (u32_t*) keyInfo.key, (u32_t*) &keyInfo.key[16]);
1112
1113#ifdef ZM_ENABLE_IBSS_WPA2PSK
1114 if ( (keyInfo.keyLength==16) && (wd->sta.ibssWpa2Psk==1) )
1115 {
1116 wd->sta.wpaState = ZM_STA_WPA_STATE_PK_OK;
1117 }
1118 else
1119 {
1120 if (wd->sta.wpaState == ZM_STA_WPA_STATE_PK_OK)
1121 wd->sta.wpaState = ZM_STA_WPA_STATE_GK_OK;
1122 else
1123 {
1124 wd->sta.wpaState = ZM_STA_WPA_STATE_PK_OK;
1125 wd->sta.encryMode = encryMode;
1126 wd->ws.encryMode = encryMode;
1127 }
1128 }
1129#else
1130 if (wd->sta.wpaState == ZM_STA_WPA_STATE_PK_OK)
1131 wd->sta.wpaState = ZM_STA_WPA_STATE_GK_OK;
1132 else if ( wd->sta.wpaState == ZM_STA_WPA_STATE_INIT )
1133 {
1134 wd->sta.wpaState = ZM_STA_WPA_STATE_PK_OK;
1135 wd->sta.encryMode = encryMode;
1136 wd->ws.encryMode = encryMode;
1137 }
1138#endif
1139 }
1140 else
1141 {
1142 zfHpSetDefaultKey(dev, keyInfo.keyIndex, encryMode,
1143 (u32_t*) keyInfo.key, NULL);
1144
1145
1146 zfMemoryCopy(wd->sta.wepKey[keyInfo.keyIndex], keyInfo.key,
1147 keyInfo.keyLength);
1148
1149
1150 wd->sta.SWEncryMode[keyInfo.keyIndex] = encryMode;
1151
1152 wd->sta.encryMode = encryMode;
1153 wd->ws.encryMode = encryMode;
1154 }
1155 }
1156 }
1157
1158
1159 return ZM_STATUS_SUCCESS;
1160}
1161
1162
1163u8_t zfiWlanPSEUDOSetKey(zdev_t* dev, struct zsKeyInfo keyInfo)
1164{
1165
1166
1167 u8_t micKey[16];
1168
1169 zmw_get_wlan_dev(dev);
1170
1171 switch (keyInfo.keyLength)
1172 {
1173 case 5:
1174 wd->sta.encryMode = ZM_WEP64;
1175
1176 zfCoreSetKey(dev, 64, 0, ZM_WEP64, (u16_t *)keyInfo.macAddr, (u32_t*) keyInfo.key);
1177 break;
1178
1179 case 13:
1180 wd->sta.encryMode = ZM_WEP128;
1181
1182 zfCoreSetKey(dev, 64, 0, ZM_WEP128, (u16_t *)keyInfo.macAddr, (u32_t*) keyInfo.key);
1183 break;
1184
1185 case 29:
1186 wd->sta.encryMode = ZM_WEP256;
1187
1188 zfCoreSetKey(dev, 64, 1, ZM_WEP256, (u16_t *)keyInfo.macAddr, (u32_t*) (&keyInfo.key[16]));
1189 zfCoreSetKey(dev, 64, 0, ZM_WEP256, (u16_t *)keyInfo.macAddr, (u32_t*) keyInfo.key);
1190 break;
1191
1192 case 16:
1193 wd->sta.encryMode = ZM_AES;
1194
1195 zfCoreSetKey(dev, 64, 0, ZM_AES, (u16_t *)keyInfo.macAddr, (u32_t*) keyInfo.key);
1196 break;
1197
1198 case 32:
1199#ifdef ZM_ENABLE_CENC
1200 if (keyInfo.flag & ZM_KEY_FLAG_CENC)
1201 {
1202 u16_t boardcastAddr[3] = {0xffff, 0xffff, 0xffff};
1203 u16_t Addr_a[] = { 0x0000, 0x0080, 0x0901};
1204 u16_t Addr_b[] = { 0x0000, 0x0080, 0x0902};
1205
1206 wd->sta.encryMode = ZM_CENC;
1207 zfCoreSetKey(dev, 0, 1, ZM_CENC, (u16_t *)Addr_a, (u32_t*) (&keyInfo.key[16]));
1208 zfCoreSetKey(dev, 0, 0, ZM_CENC, (u16_t *)Addr_a, (u32_t*) keyInfo.key);
1209
1210 zfCoreSetKey(dev, 1, 1, ZM_CENC, (u16_t *)Addr_b, (u32_t*) (&keyInfo.key[16]));
1211 zfCoreSetKey(dev, 1, 0, ZM_CENC, (u16_t *)Addr_b, (u32_t*) keyInfo.key);
1212
1213 zfCoreSetKey(dev, 2, 1, ZM_CENC, (u16_t *)boardcastAddr, (u32_t*) (&keyInfo.key[16]));
1214 zfCoreSetKey(dev, 2, 0, ZM_CENC, (u16_t *)boardcastAddr, (u32_t*) keyInfo.key);
1215
1216
1217 wd->sta.txiv[0] = 0x5c365c36;
1218 wd->sta.txiv[1] = 0x5c365c36;
1219 wd->sta.txiv[2] = 0x5c365c36;
1220 wd->sta.txiv[3] = 0x5c365c36;
1221 }
1222 else
1223#endif
1224 {
1225 wd->sta.encryMode = ZM_TKIP;
1226 zfCoreSetKey(dev, 64, 1, ZM_TKIP, (u16_t *)keyInfo.macAddr, (u32_t*) micKey);
1227 zfCoreSetKey(dev, 64, 0, ZM_TKIP, (u16_t *)keyInfo.macAddr, (u32_t*) keyInfo.key);
1228 }
1229 break;
1230 default:
1231 wd->sta.encryMode = ZM_NO_WEP;
1232 }
1233
1234 return ZM_STATUS_SUCCESS;
1235}
1236
1237void zfiWlanSetPowerSaveMode(zdev_t* dev, u8_t mode)
1238{
1239#if 0
1240 zmw_get_wlan_dev(dev);
1241
1242 wd->sta.powerSaveMode = mode;
1243
1244
1245 if ( mode > ZM_STA_PS_NONE )
1246 {
1247 if ( wd->wlanMode == ZM_MODE_INFRASTRUCTURE )
1248 {
1249 zfSendNullData(dev, 1);
1250 }
1251
1252
1253 zfPSDeviceSleep(dev);
1254 }
1255#endif
1256
1257 zfPowerSavingMgrSetMode(dev, mode);
1258}
1259
1260void zfiWlanSetMacAddress(zdev_t* dev, u16_t* mac)
1261{
1262 zmw_get_wlan_dev(dev);
1263
1264 wd->macAddr[0] = mac[0];
1265 wd->macAddr[1] = mac[1];
1266 wd->macAddr[2] = mac[2];
1267
1268 zfHpSetMacAddress(dev, mac, 0);
1269}
1270
1271u8_t zfiWlanQueryWlanMode(zdev_t* dev)
1272{
1273 zmw_get_wlan_dev(dev);
1274
1275 return wd->wlanMode;
1276}
1277
1278u8_t zfiWlanQueryAdapterState(zdev_t* dev)
1279{
1280 zmw_get_wlan_dev(dev);
1281
1282 return wd->state;
1283}
1284
1285u8_t zfiWlanQueryAuthenticationMode(zdev_t* dev, u8_t bWrapper)
1286{
1287 u8_t authMode;
1288
1289 zmw_get_wlan_dev(dev);
1290
1291 if ( bWrapper )
1292 {
1293 authMode = wd->ws.authMode;
1294 }
1295 else
1296 {
1297
1298 authMode = wd->sta.currentAuthMode;
1299 }
1300
1301 return authMode;
1302}
1303
1304u8_t zfiWlanQueryWepStatus(zdev_t* dev, u8_t bWrapper)
1305{
1306 u8_t wepStatus;
1307
1308 zmw_get_wlan_dev(dev);
1309
1310 if ( bWrapper )
1311 {
1312 wepStatus = wd->ws.wepStatus;
1313 }
1314 else
1315 {
1316 wepStatus = wd->sta.wepStatus;
1317 }
1318
1319 return wepStatus;
1320}
1321
1322void zfiWlanQuerySSID(zdev_t* dev, u8_t* ssid, u8_t* pSsidLength)
1323{
1324 u16_t vapId = 0;
1325 zmw_get_wlan_dev(dev);
1326
1327 if (wd->wlanMode == ZM_MODE_AP)
1328 {
1329 vapId = zfwGetVapId(dev);
1330
1331 if (vapId == 0xffff)
1332 {
1333 *pSsidLength = wd->ap.ssidLen[0];
1334 zfMemoryCopy(ssid, wd->ap.ssid[0], wd->ap.ssidLen[0]);
1335 }
1336 else
1337 {
1338 *pSsidLength = wd->ap.ssidLen[vapId + 1];
1339 zfMemoryCopy(ssid, wd->ap.ssid[vapId + 1], wd->ap.ssidLen[vapId + 1]);
1340 }
1341 }
1342 else
1343 {
1344 *pSsidLength = wd->sta.ssidLen;
1345 zfMemoryCopy(ssid, wd->sta.ssid, wd->sta.ssidLen);
1346 }
1347}
1348
1349u16_t zfiWlanQueryFragThreshold(zdev_t* dev)
1350{
1351 zmw_get_wlan_dev(dev);
1352
1353 return wd->fragThreshold;
1354}
1355
1356u16_t zfiWlanQueryRtsThreshold(zdev_t* dev)
1357{
1358 zmw_get_wlan_dev(dev);
1359
1360 return wd->rtsThreshold;
1361}
1362
1363u32_t zfiWlanQueryFrequency(zdev_t* dev)
1364{
1365 zmw_get_wlan_dev(dev);
1366
1367 return (wd->frequency*1000);
1368}
1369
1370
1371
1372
1373
1374
1375
1376
1377
1378
1379
1380
1381u32_t zfiWlanQueryCurrentFrequency(zdev_t* dev, u8_t qmode)
1382{
1383 u32_t frequency;
1384
1385 zmw_get_wlan_dev(dev);
1386
1387 switch (qmode)
1388 {
1389 case 0:
1390 if (wd->sta.currentFrequency > 3000)
1391 {
1392 if (wd->supportMode & ZM_WIRELESS_MODE_5)
1393 {
1394 frequency = wd->sta.currentFrequency;
1395 }
1396 else if (wd->supportMode & ZM_WIRELESS_MODE_24)
1397 {
1398 frequency = zfChGetFirst2GhzChannel(dev);
1399 }
1400 else
1401 {
1402 frequency = 0;
1403 }
1404 }
1405 else
1406 {
1407 if (wd->supportMode & ZM_WIRELESS_MODE_24)
1408 {
1409 frequency = wd->sta.currentFrequency;
1410 }
1411 else if (wd->supportMode & ZM_WIRELESS_MODE_5)
1412 {
1413 frequency = zfChGetLast5GhzChannel(dev);
1414 }
1415 else
1416 {
1417 frequency = 0;
1418 }
1419 }
1420 break;
1421
1422 case 1:
1423 frequency = wd->sta.currentFrequency;
1424 break;
1425
1426 default:
1427 frequency = 0;
1428 }
1429
1430 return (frequency*1000);
1431}
1432
1433u32_t zfiWlanQueryFrequencyAttribute(zdev_t* dev, u32_t freq)
1434{
1435 u8_t i;
1436 u16_t frequency = (u16_t) (freq/1000);
1437 u32_t ret = 0;
1438
1439 zmw_get_wlan_dev(dev);
1440
1441 for (i = 0; i < wd->regulationTable.allowChannelCnt; i++)
1442 {
1443 if ( wd->regulationTable.allowChannel[i].channel == frequency )
1444 {
1445 ret = wd->regulationTable.allowChannel[i].channelFlags;
1446 }
1447 }
1448
1449 return ret;
1450}
1451
1452
1453
1454void zfiWlanQueryFrequencyHT(zdev_t* dev, u32_t *bandWidth, u32_t *extOffset)
1455{
1456 zmw_get_wlan_dev(dev);
1457
1458 *bandWidth = wd->BandWidth40;
1459 *extOffset = wd->ExtOffset;
1460}
1461
1462u8_t zfiWlanQueryCWMode(zdev_t* dev)
1463{
1464 zmw_get_wlan_dev(dev);
1465
1466 return wd->cwm.cw_mode;
1467}
1468
1469u32_t zfiWlanQueryCWEnable(zdev_t* dev)
1470{
1471 zmw_get_wlan_dev(dev);
1472
1473 return wd->cwm.cw_enable;
1474}
1475
1476void zfiWlanQueryBssid(zdev_t* dev, u8_t* bssid)
1477{
1478 u8_t addr[6];
1479
1480 zmw_get_wlan_dev(dev);
1481
1482 ZM_MAC_WORD_TO_BYTE(wd->sta.bssid, addr);
1483 zfMemoryCopy(bssid, addr, 6);
1484}
1485
1486u16_t zfiWlanQueryBeaconInterval(zdev_t* dev)
1487{
1488 zmw_get_wlan_dev(dev);
1489
1490 return wd->beaconInterval;
1491}
1492
1493u32_t zfiWlanQueryRxBeaconTotal(zdev_t* dev)
1494{
1495 zmw_get_wlan_dev(dev);
1496 wd->sta.rxBeaconTotal += wd->sta.rxBeaconCount;
1497
1498 return wd->sta.rxBeaconTotal;
1499}
1500
1501u16_t zfiWlanQueryAtimWindow(zdev_t* dev)
1502{
1503 u16_t atimWindow;
1504
1505 zmw_get_wlan_dev(dev);
1506
1507 atimWindow = wd->sta.atimWindow;
1508
1509 return atimWindow;
1510}
1511
1512u8_t zfiWlanQueryEncryMode(zdev_t* dev)
1513{
1514 zmw_get_wlan_dev(dev);
1515
1516 if (wd->wlanMode == ZM_MODE_AP)
1517 return wd->ap.encryMode[0];
1518 else
1519 return wd->sta.encryMode;
1520}
1521
1522u16_t zfiWlanQueryCapability(zdev_t* dev)
1523{
1524 u16_t capability;
1525
1526 zmw_get_wlan_dev(dev);
1527
1528 capability = wd->sta.capability[0] +
1529 (((u16_t) wd->sta.capability[1]) << 8);
1530
1531 return capability;
1532
1533}
1534
1535u16_t zfiWlanQueryAid(zdev_t* dev)
1536{
1537 zmw_get_wlan_dev(dev);
1538
1539 return wd->sta.aid;
1540}
1541
1542void zfiWlanQuerySupportRate(zdev_t* dev, u8_t* rateArray, u8_t* pLength)
1543{
1544 u8_t i, j=0;
1545
1546 zmw_get_wlan_dev(dev);
1547
1548 for( i=0; i<4; i++ )
1549 {
1550 if ( wd->bRate & (0x1 << i) )
1551 {
1552 rateArray[j] = zg11bRateTbl[i] +
1553 ((wd->bRateBasic & (0x1<<i))<<(7-i));
1554 j++;
1555 }
1556 }
1557
1558 *pLength = j;
1559}
1560
1561void zfiWlanQueryExtSupportRate(zdev_t* dev, u8_t* rateArray, u8_t* pLength)
1562{
1563 u8_t i, j=0;
1564
1565 zmw_get_wlan_dev(dev);
1566
1567 for( i=0; i<8; i++ )
1568 {
1569 if ( wd->gRate & (0x1 << i) )
1570 {
1571 rateArray[j] = zg11gRateTbl[i] +
1572 ((wd->gRateBasic & (0x1<<i))<<(7-i));
1573 j++;
1574 }
1575 }
1576
1577 *pLength = j;
1578}
1579
1580void zfiWlanQueryRsnIe(zdev_t* dev, u8_t* ie, u8_t* pLength)
1581{
1582 u8_t len;
1583
1584 zmw_get_wlan_dev(dev);
1585
1586 len = wd->sta.rsnIe[1] + 2;
1587 zfMemoryCopy(ie, wd->sta.rsnIe, len);
1588 *pLength = len;
1589}
1590
1591void zfiWlanQueryWpaIe(zdev_t* dev, u8_t* ie, u8_t* pLength)
1592{
1593 u8_t len;
1594
1595 zmw_get_wlan_dev(dev);
1596
1597 len = wd->sta.wpaIe[1] + 2;
1598 zfMemoryCopy(ie, wd->sta.wpaIe, len);
1599 *pLength = len;
1600
1601}
1602
1603u8_t zfiWlanQueryMulticastCipherAlgo(zdev_t *dev)
1604{
1605 zmw_get_wlan_dev(dev);
1606
1607 switch( wd->sta.currentAuthMode )
1608 {
1609 case ZM_AUTH_MODE_WPA2PSK:
1610 case ZM_AUTH_MODE_WPA2:
1611 if ( wd->sta.rsnIe[7] == 2 )
1612 {
1613 return ZM_TKIP;
1614 }
1615 else
1616 {
1617 return ZM_AES;
1618 }
1619 break;
1620
1621 case ZM_AUTH_MODE_WPAPSK:
1622 case ZM_AUTH_MODE_WPA:
1623 if ( wd->sta.rsnIe[11] == 2 )
1624 {
1625 return ZM_TKIP;
1626 }
1627 else
1628 {
1629 return ZM_AES;
1630 }
1631 break;
1632
1633 default:
1634 return wd->sta.encryMode;
1635 }
1636}
1637
1638u8_t zfiWlanQueryHTMode(zdev_t* dev)
1639{
1640 zmw_get_wlan_dev(dev);
1641
1642 return wd->sta.EnableHT;
1643}
1644
1645u8_t zfiWlanQueryBandWidth40(zdev_t* dev)
1646{
1647 zmw_get_wlan_dev(dev);
1648
1649 return wd->BandWidth40;
1650}
1651
1652u16_t zfiWlanQueryRegionCode(zdev_t* dev)
1653{
1654 zmw_get_wlan_dev(dev);
1655
1656 return wd->regulationTable.regionCode;
1657}
1658void zfiWlanSetWpaIe(zdev_t* dev, u8_t* ie, u8_t Length)
1659{
1660 u16_t vapId = 0;
1661 zmw_get_wlan_dev(dev);
1662
1663 if (wd->wlanMode == ZM_MODE_AP)
1664 {
1665 vapId = zfwGetVapId(dev);
1666
1667 if (vapId == 0xffff)
1668 vapId = 0;
1669 else
1670 vapId++;
1671
1672 zm_assert(Length < ZM_MAX_WPAIE_SIZE);
1673 if (Length < ZM_MAX_WPAIE_SIZE)
1674 {
1675 wd->ap.wpaLen[vapId] = Length;
1676 zfMemoryCopy(wd->ap.wpaIe[vapId], ie, wd->ap.wpaLen[vapId]);
1677 }
1678
1679 }
1680 else
1681 {
1682 wd->sta.wpaLen = Length;
1683 zfMemoryCopy(wd->sta.wpaIe, ie, wd->sta.wpaLen);
1684 }
1685
1686 if (wd->wlanMode == ZM_MODE_AP)
1687 {
1688 wd->ap.wpaSupport[vapId] = 1;
1689 }
1690 else
1691 {
1692 wd->sta.wpaSupport = 1;
1693 }
1694
1695}
1696
1697void zfiWlanSetWpaSupport(zdev_t* dev, u8_t WpaSupport)
1698{
1699 u16_t vapId = 0;
1700 zmw_get_wlan_dev(dev);
1701
1702 if (wd->wlanMode == ZM_MODE_AP)
1703 {
1704 vapId = zfwGetVapId(dev);
1705
1706 if (vapId == 0xffff)
1707 vapId = 0;
1708 else
1709 vapId++;
1710
1711 wd->ap.wpaSupport[vapId] = WpaSupport;
1712 }
1713 else
1714 {
1715 wd->sta.wpaSupport = WpaSupport;
1716 }
1717
1718}
1719
1720void zfiWlanSetProtectionMode(zdev_t* dev, u8_t mode)
1721{
1722 zmw_get_wlan_dev(dev);
1723
1724 wd->sta.bProtectionMode = mode;
1725 if (wd->sta.bProtectionMode == TRUE)
1726 {
1727 zfHpSetSlotTime(dev, 0);
1728 }
1729 else
1730 {
1731 zfHpSetSlotTime(dev, 1);
1732 }
1733
1734 zm_msg1_mm(ZM_LV_1, "wd->protectionMode=", wd->sta.bProtectionMode);
1735}
1736
1737void zfiWlanSetBasicRate(zdev_t* dev, u8_t bRateSet, u8_t gRateSet,
1738 u32_t nRateSet)
1739{
1740 zmw_get_wlan_dev(dev);
1741
1742 wd->ws.bRateBasic = bRateSet;
1743 wd->ws.gRateBasic = gRateSet;
1744 wd->ws.nRateBasic = nRateSet;
1745}
1746
1747void zfiWlanSetBGMode(zdev_t* dev, u8_t mode)
1748{
1749 zmw_get_wlan_dev(dev);
1750
1751 wd->ws.bgMode = mode;
1752}
1753
1754void zfiWlanSetpreambleType(zdev_t* dev, u8_t type)
1755{
1756 zmw_get_wlan_dev(dev);
1757
1758 wd->ws.preambleType = type;
1759}
1760
1761u8_t zfiWlanQuerypreambleType(zdev_t* dev)
1762{
1763 zmw_get_wlan_dev(dev);
1764
1765 return wd->ws.preambleType;
1766}
1767
1768u8_t zfiWlanQueryPowerSaveMode(zdev_t* dev)
1769{
1770 zmw_get_wlan_dev(dev);
1771
1772 return wd->sta.powerSaveMode;
1773}
1774
1775u8_t zfiWlanSetPmkidInfo(zdev_t* dev, u16_t* bssid, u8_t* pmkid)
1776{
1777 u32_t i;
1778
1779 zmw_get_wlan_dev(dev);
1780
1781 for(i=0; i<wd->sta.pmkidInfo.bssidCount; i++)
1782 {
1783 if ( zfMemoryIsEqual((u8_t*) wd->sta.pmkidInfo.bssidInfo[i].bssid,
1784 (u8_t*) bssid, 6) )
1785 {
1786
1787 break;
1788 }
1789 }
1790
1791 if ( i < wd->sta.pmkidInfo.bssidCount )
1792 {
1793
1794 zfMemoryCopy(wd->sta.pmkidInfo.bssidInfo[i].pmkid, pmkid, 16);
1795 }
1796 else
1797 {
1798 if ( i < ZM_PMKID_MAX_BSS_CNT )
1799 {
1800 wd->sta.pmkidInfo.bssidInfo[i].bssid[0] = bssid[0];
1801 wd->sta.pmkidInfo.bssidInfo[i].bssid[1] = bssid[1];
1802 wd->sta.pmkidInfo.bssidInfo[i].bssid[2] = bssid[2];
1803
1804 zfMemoryCopy(wd->sta.pmkidInfo.bssidInfo[i].pmkid, pmkid, 16);
1805 wd->sta.pmkidInfo.bssidCount++;
1806 }
1807 }
1808
1809 return 0;
1810}
1811
1812u32_t zfiWlanQueryPmkidInfo(zdev_t* dev, u8_t* buf, u32_t len)
1813{
1814
1815 u32_t size;
1816
1817 zmw_get_wlan_dev(dev);
1818
1819 size = sizeof(u32_t) +
1820 wd->sta.pmkidInfo.bssidCount * sizeof(struct zsPmkidBssidInfo);
1821
1822 if ( len < size )
1823 {
1824 return wd->sta.pmkidInfo.bssidCount;
1825 }
1826
1827 zfMemoryCopy(buf, (u8_t*) &wd->sta.pmkidInfo, (u16_t) size);
1828
1829 return 0;
1830}
1831
1832void zfiWlanSetMulticastList(zdev_t* dev, u8_t size, u8_t* pList)
1833{
1834 struct zsMulticastAddr* pMacList = (struct zsMulticastAddr*) pList;
1835 u8_t i;
1836 u8_t bAllMulticast = 0;
1837
1838
1839 zmw_get_wlan_dev(dev);
1840
1841 wd->sta.multicastList.size = size;
1842 for(i=0; i<size; i++)
1843 {
1844 zfMemoryCopy(wd->sta.multicastList.macAddr[i].addr,
1845 pMacList[i].addr, 6);
1846 }
1847
1848 if ( wd->sta.osRxFilter & ZM_PACKET_TYPE_ALL_MULTICAST )
1849 bAllMulticast = 1;
1850 zfHpSetMulticastList(dev, size, pList, bAllMulticast);
1851
1852}
1853
1854void zfiWlanRemoveKey(zdev_t* dev, u8_t keyType, u8_t keyId)
1855{
1856 u16_t fakeMacAddr[3] = {0, 0, 0};
1857 u32_t fakeKey[4] = {0, 0, 0, 0};
1858
1859 zmw_get_wlan_dev(dev);
1860
1861 if ( keyType == 0 )
1862 {
1863
1864 zm_debug_msg0("remove WEP key");
1865 zfCoreSetKey(dev, ZM_USER_KEY_DEFAULT+keyId, 0,
1866 ZM_NO_WEP, fakeMacAddr, fakeKey);
1867 wd->sta.encryMode = ZM_NO_WEP;
1868 }
1869 else if ( keyType == 1 )
1870 {
1871
1872 zm_debug_msg0("remove pairwise key");
1873 zfHpRemoveKey(dev, ZM_USER_KEY_PK);
1874 wd->sta.encryMode = ZM_NO_WEP;
1875 }
1876 else
1877 {
1878
1879 zm_debug_msg0("remove group key");
1880 zfHpRemoveKey(dev, ZM_USER_KEY_GK);
1881 }
1882}
1883
1884
1885void zfiWlanQueryRegulationTable(zdev_t* dev, struct zsRegulationTable* pEntry)
1886{
1887 zmw_get_wlan_dev(dev);
1888
1889 zfMemoryCopy((u8_t*) pEntry, (u8_t*) &wd->regulationTable,
1890 sizeof(struct zsRegulationTable));
1891}
1892
1893
1894void zfiWlanSetScanTimerPerChannel(zdev_t* dev, u16_t time)
1895{
1896 zmw_get_wlan_dev(dev);
1897
1898 zm_debug_msg1("scan time (ms) = ", time);
1899
1900 wd->sta.activescanTickPerChannel = time / ZM_MS_PER_TICK;
1901}
1902
1903void zfiWlanSetAutoReconnect(zdev_t* dev, u8_t enable)
1904{
1905 zmw_get_wlan_dev(dev);
1906
1907 wd->sta.bAutoReconnect = enable;
1908
1909}
1910
1911void zfiWlanSetStaWme(zdev_t* dev, u8_t enable, u8_t uapsdInfo)
1912{
1913 zmw_get_wlan_dev(dev);
1914
1915 wd->ws.staWmeEnabled = enable & 0x3;
1916 if ((enable & 0x2) != 0)
1917 {
1918 wd->ws.staWmeQosInfo = uapsdInfo & 0x6f;
1919 }
1920 else
1921 {
1922 wd->ws.staWmeQosInfo = 0;
1923 }
1924}
1925
1926void zfiWlanSetApWme(zdev_t* dev, u8_t enable)
1927{
1928 zmw_get_wlan_dev(dev);
1929
1930 wd->ws.apWmeEnabled = enable;
1931}
1932
1933u8_t zfiWlanQuerywmeEnable(zdev_t* dev)
1934{
1935 zmw_get_wlan_dev(dev);
1936
1937 return wd->ws.staWmeEnabled;
1938}
1939
1940void zfiWlanSetProbingHiddenSsid(zdev_t* dev, u8_t* ssid, u8_t ssidLen,
1941 u16_t entry)
1942{
1943 zmw_get_wlan_dev(dev);
1944 zmw_declare_for_critical_section();
1945
1946
1947 if ((ssidLen <= 32) && (entry < ZM_MAX_PROBE_HIDDEN_SSID_SIZE))
1948 {
1949 zmw_enter_critical_section(dev);
1950 wd->ws.probingSsidList[entry].ssidLen = ssidLen;
1951 zfMemoryCopy(wd->ws.probingSsidList[entry].ssid, ssid, ssidLen);
1952 zmw_leave_critical_section(dev);
1953 }
1954
1955 return;
1956}
1957
1958void zfiWlanSetDisableProbingWithSsid(zdev_t* dev, u8_t mode)
1959{
1960 zmw_get_wlan_dev(dev);
1961
1962 wd->sta.disableProbingWithSsid = mode;
1963
1964 return;
1965}
1966
1967void zfiWlanSetDropUnencryptedPackets(zdev_t* dev, u8_t enable)
1968{
1969 zmw_get_wlan_dev(dev);
1970
1971 wd->ws.dropUnencryptedPkts = enable;
1972}
1973
1974void zfiWlanSetStaRxSecurityCheckCb(zdev_t* dev, zfpStaRxSecurityCheckCb pStaRxSecurityCheckCb)
1975{
1976 zmw_get_wlan_dev(dev);
1977
1978 wd->sta.pStaRxSecurityCheckCb = pStaRxSecurityCheckCb;
1979}
1980
1981void zfiWlanSetIBSSJoinOnly(zdev_t* dev, u8_t joinOnly)
1982{
1983 zmw_get_wlan_dev(dev);
1984
1985 wd->ws.ibssJoinOnly = joinOnly;
1986}
1987
1988
1989
1990
1991
1992
1993
1994
1995
1996
1997
1998
1999
2000
2001
2002
2003
2004
2005
2006
2007
2008u16_t zfiConfigWdsPort(zdev_t* dev, u8_t wdsPortId, u16_t flag, u16_t* wdsAddr,
2009 u16_t encType, u32_t* wdsKey)
2010{
2011 u16_t addr[3];
2012 u32_t key[4];
2013
2014 zmw_get_wlan_dev(dev);
2015
2016 if (wdsPortId >= ZM_MAX_WDS_SUPPORT)
2017 {
2018 return ZM_ERR_WDS_PORT_ID;
2019 }
2020
2021 if (flag == 1)
2022 {
2023
2024 wd->ap.wds.macAddr[wdsPortId][0] = wdsAddr[0];
2025 wd->ap.wds.macAddr[wdsPortId][1] = wdsAddr[1];
2026 wd->ap.wds.macAddr[wdsPortId][2] = wdsAddr[2];
2027
2028 wd->ap.wds.wdsBitmap |= (1 << wdsPortId);
2029 wd->ap.wds.encryMode[wdsPortId] = (u8_t) encType;
2030
2031 zfCoreSetKey(dev, 10+ZM_MAX_WDS_SUPPORT, 0, (u8_t) encType, wdsAddr, wdsKey);
2032 }
2033 else
2034 {
2035
2036 addr[0] = addr[1] = addr[2] = 0;
2037 key[0] = key[1] = key[2] = key[3] = 0;
2038 wd->ap.wds.wdsBitmap &= (~(1 << wdsPortId));
2039 zfCoreSetKey(dev, 10+ZM_MAX_WDS_SUPPORT, 0, ZM_NO_WEP, addr, key);
2040 }
2041
2042 return ZM_SUCCESS;
2043}
2044#ifdef ZM_ENABLE_CENC
2045
2046void zfiWlanQueryGSN(zdev_t* dev, u8_t *gsn, u16_t vapId)
2047{
2048
2049 u32_t txiv[4];
2050 zmw_get_wlan_dev(dev);
2051
2052
2053 txiv[3] = wd->ap.txiv[vapId][0];
2054 txiv[2] = wd->ap.txiv[vapId][1];
2055 txiv[1] = wd->ap.txiv[vapId][2];
2056 txiv[0] = wd->ap.txiv[vapId][3];
2057
2058 zfMemoryCopy(gsn, (u8_t*)txiv, 16);
2059}
2060#endif
2061
2062void zfiWlanQuerySignalInfo(zdev_t* dev, u8_t *buffer)
2063{
2064 zmw_get_wlan_dev(dev);
2065
2066
2067
2068 buffer[0] = wd->SignalStrength;
2069 buffer[1] = wd->SignalQuality;
2070}
2071
2072
2073u16_t zfiStaAddIeWpaRsn(zdev_t* dev, zbuf_t* buf, u16_t offset, u8_t frameType)
2074{
2075 return zfStaAddIeWpaRsn(dev, buf, offset, frameType);
2076}
2077
2078
2079
2080
2081
2082
2083
2084
2085
2086
2087
2088
2089
2090u32_t zfiDebugCmd(zdev_t* dev, u32_t cmd, u32_t value)
2091{
2092 u16_t event;
2093 u32_t tick;
2094 zmw_get_wlan_dev(dev);
2095
2096 zmw_declare_for_critical_section();
2097
2098
2099 zmw_enter_critical_section(dev);
2100
2101 if ( cmd == 0 )
2102 {
2103 event = (u16_t) ((value >> 16) & 0xffff);
2104 tick = value & 0xffff;
2105 zfTimerSchedule(dev, event, tick);
2106 }
2107 else if ( cmd == 1 )
2108 {
2109 event = (u16_t) (value & 0xffff);
2110 zfTimerCancel(dev, event);
2111 }
2112 else if ( cmd == 2 )
2113 {
2114 zfTimerClear(dev);
2115 }
2116 else if ( cmd == 3 )
2117 {
2118 zfTimerSchedule(dev, 1, 500);
2119 zfTimerSchedule(dev, 2, 1000);
2120 zfTimerSchedule(dev, 3, 1000);
2121 zfTimerSchedule(dev, 4, 1000);
2122 zfTimerSchedule(dev, 5, 1500);
2123 zfTimerSchedule(dev, 6, 2000);
2124 zfTimerSchedule(dev, 7, 2200);
2125 zfTimerSchedule(dev, 6, 2500);
2126 zfTimerSchedule(dev, 8, 2800);
2127 }
2128 else if ( cmd == 4)
2129 {
2130 zfTimerSchedule(dev, 1, 500);
2131 zfTimerSchedule(dev, 2, 1000);
2132 zfTimerSchedule(dev, 3, 1000);
2133 zfTimerSchedule(dev, 4, 1000);
2134 zfTimerSchedule(dev, 5, 1500);
2135 zfTimerSchedule(dev, 6, 2000);
2136 zfTimerSchedule(dev, 7, 2200);
2137 zfTimerSchedule(dev, 6, 2500);
2138 zfTimerSchedule(dev, 8, 2800);
2139 zfTimerCancel(dev, 1);
2140 zfTimerCancel(dev, 3);
2141 zfTimerCancel(dev, 6);
2142 }
2143 else if ( cmd == 5 )
2144 {
2145 wd->sta.keyId = (u8_t) value;
2146 }
2147 else if ( cmd == 6 )
2148 {
2149
2150 wd->checksumTest = value;
2151 }
2152 else if ( cmd == 7 )
2153 {
2154 wd->enableProtectionMode = value;
2155 zm_msg1_mm(ZM_LV_1, "wd->enableProtectionMode=", wd->enableProtectionMode);
2156 }
2157 else if ( cmd == 8 )
2158 {
2159
2160 if (value)
2161 {
2162 wd->rxPacketDump = 1;
2163 }
2164 else
2165 {
2166 wd->rxPacketDump = 0;
2167 }
2168 }
2169
2170
2171 zmw_leave_critical_section(dev);
2172
2173 return 0;
2174}
2175
2176#ifdef ZM_ENABLE_CENC
2177u8_t zfiWlanSetCencPairwiseKey(zdev_t* dev, u8_t keyid, u32_t *txiv, u32_t *rxiv,
2178 u8_t *key, u8_t *mic)
2179{
2180 struct zsKeyInfo keyInfo;
2181 u8_t cencKey[32];
2182 u8_t i;
2183 u16_t macAddr[3];
2184
2185 zmw_get_wlan_dev(dev);
2186
2187 for (i = 0; i < 16; i++)
2188 cencKey[i] = key[i];
2189 for (i = 0; i < 16; i++)
2190 cencKey[i + 16] = mic[i];
2191 keyInfo.key = cencKey;
2192 keyInfo.keyLength = 32;
2193 keyInfo.keyIndex = keyid;
2194 keyInfo.flag = ZM_KEY_FLAG_CENC | ZM_KEY_FLAG_PK;
2195 for (i = 0; i < 3; i++)
2196 macAddr[i] = wd->sta.bssid[i];
2197 keyInfo.macAddr = macAddr;
2198
2199 zfiWlanSetKey(dev, keyInfo);
2200
2201
2202
2203
2204
2205
2206
2207
2208
2209
2210
2211
2212 return 0;
2213}
2214
2215u8_t zfiWlanSetCencGroupKey(zdev_t* dev, u8_t keyid, u32_t *rxiv,
2216 u8_t *key, u8_t *mic)
2217{
2218 struct zsKeyInfo keyInfo;
2219 u8_t cencKey[32];
2220 u8_t i;
2221 u16_t macAddr[6] = {0xffff, 0xffff, 0xffff};
2222
2223 zmw_get_wlan_dev(dev);
2224
2225 for (i = 0; i < 16; i++)
2226 cencKey[i] = key[i];
2227 for (i = 0; i < 16; i++)
2228 cencKey[i + 16] = mic[i];
2229 keyInfo.key = cencKey;
2230 keyInfo.keyLength = 32;
2231 keyInfo.keyIndex = keyid;
2232 keyInfo.flag = ZM_KEY_FLAG_CENC | ZM_KEY_FLAG_GK;
2233 keyInfo.vapId = 0;
2234 for (i = 0; i < 3; i++)
2235 keyInfo.vapAddr[i] = wd->macAddr[i];
2236 keyInfo.macAddr = macAddr;
2237
2238 zfiWlanSetKey(dev, keyInfo);
2239
2240
2241 wd->sta.rxivGK[0] = ((rxiv[3] >> 24) & 0xFF)
2242 + (((rxiv[3] >> 16) & 0xFF) << 8)
2243 + (((rxiv[3] >> 8) & 0xFF) << 16)
2244 + ((rxiv[3] & 0xFF) << 24);
2245 wd->sta.rxivGK[1] = ((rxiv[2] >> 24) & 0xFF)
2246 + (((rxiv[2] >> 16) & 0xFF) << 8)
2247 + (((rxiv[2] >> 8) & 0xFF) << 16)
2248 + ((rxiv[2] & 0xFF) << 24);
2249 wd->sta.rxivGK[2] = ((rxiv[1] >> 24) & 0xFF)
2250 + (((rxiv[1] >> 16) & 0xFF) << 8)
2251 + (((rxiv[1] >> 8) & 0xFF) << 16)
2252 + ((rxiv[1] & 0xFF) << 24);
2253 wd->sta.rxivGK[3] = ((rxiv[0] >> 24) & 0xFF)
2254 + (((rxiv[0] >> 16) & 0xFF) << 8)
2255 + (((rxiv[0] >> 8) & 0xFF) << 16)
2256 + ((rxiv[0] & 0xFF) << 24);
2257
2258 wd->sta.authMode = ZM_AUTH_MODE_CENC;
2259 wd->sta.currentAuthMode = ZM_AUTH_MODE_CENC;
2260
2261 return 0;
2262}
2263#endif
2264
2265u8_t zfiWlanSetDot11DMode(zdev_t* dev, u8_t mode)
2266{
2267 u8_t i;
2268
2269 zmw_get_wlan_dev(dev);
2270
2271 wd->sta.b802_11D = mode;
2272 if (mode)
2273 {
2274 wd->regulationTable.regionCode = NO_ENUMRD;
2275 for (i = 0; i < wd->regulationTable.allowChannelCnt; i++)
2276 wd->regulationTable.allowChannel[i].channelFlags |= ZM_REG_FLAG_CHANNEL_PASSIVE;
2277 }
2278 else
2279 {
2280 for (i = 0; i < wd->regulationTable.allowChannelCnt; i++)
2281 wd->regulationTable.allowChannel[i].channelFlags &= ~ZM_REG_FLAG_CHANNEL_PASSIVE;
2282 }
2283
2284 return 0;
2285}
2286
2287u8_t zfiWlanSetDot11HDFSMode(zdev_t* dev, u8_t mode)
2288{
2289 zmw_get_wlan_dev(dev);
2290
2291
2292
2293
2294
2295
2296
2297
2298
2299
2300
2301
2302
2303
2304
2305
2306 wd->sta.DFSEnable = mode;
2307 if (mode)
2308 wd->sta.capability[1] |= ZM_BIT_0;
2309 else
2310 wd->sta.capability[1] &= (~ZM_BIT_0);
2311
2312 return 0;
2313}
2314
2315u8_t zfiWlanSetDot11HTPCMode(zdev_t* dev, u8_t mode)
2316{
2317 zmw_get_wlan_dev(dev);
2318
2319
2320
2321
2322
2323
2324
2325
2326
2327
2328
2329
2330
2331
2332
2333 wd->sta.TPCEnable = mode;
2334 if (mode)
2335 wd->sta.capability[1] |= ZM_BIT_0;
2336 else
2337 wd->sta.capability[1] &= (~ZM_BIT_0);
2338
2339 return 0;
2340}
2341
2342u8_t zfiWlanSetAniMode(zdev_t* dev, u8_t mode)
2343{
2344 zmw_get_wlan_dev(dev);
2345
2346 wd->aniEnable = mode;
2347 if (mode)
2348 zfHpAniAttach(dev);
2349
2350 return 0;
2351}
2352
2353#ifdef ZM_OS_LINUX_FUNC
2354void zfiWlanShowTally(zdev_t* dev)
2355{
2356 zmw_get_wlan_dev(dev);
2357
2358 zm_msg1_mm(ZM_LV_0, "Hw_UnderrunCnt = ", wd->commTally.Hw_UnderrunCnt);
2359 zm_msg1_mm(ZM_LV_0, "Hw_TotalRxFrm = ", wd->commTally.Hw_TotalRxFrm);
2360 zm_msg1_mm(ZM_LV_0, "Hw_CRC32Cnt = ", wd->commTally.Hw_CRC32Cnt);
2361 zm_msg1_mm(ZM_LV_0, "Hw_CRC16Cnt = ", wd->commTally.Hw_CRC16Cnt);
2362 zm_msg1_mm(ZM_LV_1, "Hw_DecrypErr_UNI = ", wd->commTally.Hw_DecrypErr_UNI);
2363 zm_msg1_mm(ZM_LV_0, "Hw_RxFIFOOverrun = ", wd->commTally.Hw_RxFIFOOverrun);
2364 zm_msg1_mm(ZM_LV_1, "Hw_DecrypErr_Mul = ", wd->commTally.Hw_DecrypErr_Mul);
2365 zm_msg1_mm(ZM_LV_1, "Hw_RetryCnt = ", wd->commTally.Hw_RetryCnt);
2366 zm_msg1_mm(ZM_LV_0, "Hw_TotalTxFrm = ", wd->commTally.Hw_TotalTxFrm);
2367 zm_msg1_mm(ZM_LV_0, "Hw_RxTimeOut = ", wd->commTally.Hw_RxTimeOut);
2368 zm_msg1_mm(ZM_LV_0, "Tx_MPDU = ", wd->commTally.Tx_MPDU);
2369 zm_msg1_mm(ZM_LV_0, "BA_Fail = ", wd->commTally.BA_Fail);
2370 zm_msg1_mm(ZM_LV_0, "Hw_Tx_AMPDU = ", wd->commTally.Hw_Tx_AMPDU);
2371 zm_msg1_mm(ZM_LV_0, "Hw_Tx_MPDU = ", wd->commTally.Hw_Tx_MPDU);
2372
2373 zm_msg1_mm(ZM_LV_1, "Hw_RxMPDU = ", wd->commTally.Hw_RxMPDU);
2374 zm_msg1_mm(ZM_LV_1, "Hw_RxDropMPDU = ", wd->commTally.Hw_RxDropMPDU);
2375 zm_msg1_mm(ZM_LV_1, "Hw_RxDelMPDU = ", wd->commTally.Hw_RxDelMPDU);
2376 zm_msg1_mm(ZM_LV_1, "Hw_RxPhyMiscError = ", wd->commTally.Hw_RxPhyMiscError);
2377 zm_msg1_mm(ZM_LV_1, "Hw_RxPhyXRError = ", wd->commTally.Hw_RxPhyXRError);
2378 zm_msg1_mm(ZM_LV_1, "Hw_RxPhyOFDMError = ", wd->commTally.Hw_RxPhyOFDMError);
2379 zm_msg1_mm(ZM_LV_1, "Hw_RxPhyCCKError = ", wd->commTally.Hw_RxPhyCCKError);
2380 zm_msg1_mm(ZM_LV_1, "Hw_RxPhyHTError = ", wd->commTally.Hw_RxPhyHTError);
2381 zm_msg1_mm(ZM_LV_1, "Hw_RxPhyTotalCount = ", wd->commTally.Hw_RxPhyTotalCount);
2382
2383 if (!((wd->commTally.Tx_MPDU == 0) && (wd->commTally.BA_Fail == 0)))
2384 {
2385 zm_debug_msg_p("BA Fail Ratio(%) = ", wd->commTally.BA_Fail * 100,
2386 (wd->commTally.BA_Fail + wd->commTally.Tx_MPDU));
2387 }
2388
2389 if (!((wd->commTally.Hw_Tx_MPDU == 0) && (wd->commTally.Hw_Tx_AMPDU == 0)))
2390 {
2391 zm_debug_msg_p("Avg Agg Number = ",
2392 wd->commTally.Hw_Tx_MPDU, wd->commTally.Hw_Tx_AMPDU);
2393 }
2394}
2395#endif
2396
2397void zfiWlanSetMaxTxPower(zdev_t* dev, u8_t power2, u8_t power5)
2398{
2399 zmw_get_wlan_dev(dev);
2400
2401 zmw_declare_for_critical_section();
2402
2403 zmw_enter_critical_section(dev);
2404 wd->maxTxPower2 = power2;
2405 wd->maxTxPower5 = power5;
2406 zmw_leave_critical_section(dev);
2407}
2408
2409void zfiWlanQueryMaxTxPower(zdev_t* dev, u8_t *power2, u8_t *power5)
2410{
2411 zmw_get_wlan_dev(dev);
2412
2413 *power2 = wd->maxTxPower2;
2414 *power5 = wd->maxTxPower5;
2415}
2416
2417void zfiWlanSetConnectMode(zdev_t* dev, u8_t mode)
2418{
2419 zmw_get_wlan_dev(dev);
2420
2421 zmw_declare_for_critical_section();
2422
2423 zmw_enter_critical_section(dev);
2424 wd->connectMode = mode;
2425 zmw_leave_critical_section(dev);
2426}
2427
2428void zfiWlanSetSupportMode(zdev_t* dev, u32_t mode)
2429{
2430 zmw_get_wlan_dev(dev);
2431
2432 zmw_declare_for_critical_section();
2433
2434 zmw_enter_critical_section(dev);
2435 wd->supportMode = mode;
2436 zmw_leave_critical_section(dev);
2437}
2438
2439void zfiWlanSetAdhocMode(zdev_t* dev, u32_t mode)
2440{
2441 zmw_get_wlan_dev(dev);
2442
2443 wd->ws.adhocMode = mode;
2444}
2445
2446u32_t zfiWlanQueryAdhocMode(zdev_t* dev, u8_t bWrapper)
2447{
2448 u32_t adhocMode;
2449
2450 zmw_get_wlan_dev(dev);
2451
2452 if ( bWrapper )
2453 {
2454 adhocMode = wd->ws.adhocMode;
2455 }
2456 else
2457 {
2458 adhocMode = wd->wfc.bIbssGMode;
2459 }
2460
2461 return adhocMode;
2462}
2463
2464
2465u8_t zfiWlanSetCountryIsoName(zdev_t* dev, u8_t *countryIsoName, u8_t length)
2466{
2467 u8_t buf[5];
2468 zmw_get_wlan_dev(dev);
2469
2470 if (length == 4)
2471 {
2472 buf[2] = wd->ws.countryIsoName[0] = countryIsoName[2];
2473 buf[3] = wd->ws.countryIsoName[1] = countryIsoName[1];
2474 buf[4] = wd->ws.countryIsoName[2] = countryIsoName[0];
2475 }
2476 else if (length == 3)
2477 {
2478 buf[2] = wd->ws.countryIsoName[0] = countryIsoName[1];
2479 buf[3] = wd->ws.countryIsoName[1] = countryIsoName[0];
2480 buf[4] = wd->ws.countryIsoName[2] = '\0';
2481 }
2482 else
2483 {
2484 return 1;
2485 }
2486
2487 return zfHpGetRegulationTablefromISO(dev, buf, length);
2488}
2489
2490
2491const char* zfiWlanQueryCountryIsoName(zdev_t* dev)
2492{
2493 zmw_get_wlan_dev(dev);
2494
2495 return wd->ws.countryIsoName;
2496}
2497
2498
2499
2500void zfiWlanSetRegulatory(zdev_t* dev, u8_t CCS, u16_t Code, u8_t bfirstChannel)
2501{
2502 zmw_get_wlan_dev(dev);
2503
2504 zmw_declare_for_critical_section();
2505
2506 if (CCS)
2507 {
2508
2509 zfHpGetRegulationTablefromCountry(dev, Code);
2510 }
2511 else
2512 {
2513
2514 zfHpGetRegulationTablefromRegionCode(dev, Code);
2515 }
2516
2517 if (bfirstChannel) {
2518 zmw_enter_critical_section(dev);
2519 wd->frequency = zfChGetFirstChannel(dev, NULL);
2520 zmw_leave_critical_section(dev);
2521 zfCoreSetFrequency(dev, wd->frequency);
2522 }
2523}
2524
2525
2526const char* zfiHpGetisoNamefromregionCode(zdev_t* dev, u16_t regionCode)
2527{
2528 return zfHpGetisoNamefromregionCode(dev, regionCode);
2529}
2530
2531u16_t zfiWlanChannelToFrequency(zdev_t* dev, u8_t channel)
2532{
2533 return zfChNumToFreq(dev, channel, 0);
2534}
2535
2536u8_t zfiWlanFrequencyToChannel(zdev_t* dev, u16_t freq)
2537{
2538 u8_t is5GBand = 0;
2539
2540 return zfChFreqToNum(freq, &is5GBand);
2541}
2542
2543void zfiWlanDisableDfsChannel(zdev_t* dev, u8_t disableFlag)
2544{
2545 zfHpDisableDfsChannel(dev, disableFlag);
2546 return;
2547}
2548
2549void zfiWlanSetLEDCtrlParam(zdev_t* dev, u8_t type, u8_t flag)
2550{
2551 zmw_get_wlan_dev(dev);
2552
2553 zmw_declare_for_critical_section();
2554
2555 zmw_enter_critical_section(dev);
2556 wd->ledStruct.LEDCtrlType = type;
2557 wd->ledStruct.LEDCtrlFlagFromReg = flag;
2558 zmw_leave_critical_section(dev);
2559}
2560
2561void zfiWlanEnableLeapConfig(zdev_t* dev, u8_t leapEnabled)
2562{
2563 zmw_get_wlan_dev(dev);
2564
2565 wd->sta.leapEnabled = leapEnabled;
2566}
2567
2568u32_t zfiWlanQueryHwCapability(zdev_t* dev)
2569{
2570 return zfHpCapability(dev);
2571}
2572
2573u32_t zfiWlanQueryReceivedPacket(zdev_t* dev)
2574{
2575 zmw_get_wlan_dev(dev);
2576
2577 return wd->sta.ReceivedPktRatePerSecond;
2578}
2579
2580void zfiWlanCheckSWEncryption(zdev_t* dev)
2581{
2582 zmw_get_wlan_dev(dev);
2583
2584 if (wd->sta.SWEncryptEnable != 0)
2585 {
2586 zfHpSWDecrypt(dev, 1);
2587 }
2588}
2589
2590u16_t zfiWlanQueryAllowChannels(zdev_t* dev, u16_t *channels)
2591{
2592 u16_t ii;
2593 zmw_get_wlan_dev(dev);
2594
2595 for (ii = 0; ii < wd->regulationTable.allowChannelCnt; ii++)
2596 {
2597 channels[ii] = wd->regulationTable.allowChannel[ii].channel;
2598 }
2599
2600 return wd->regulationTable.allowChannelCnt;
2601}
2602
2603void zfiWlanSetDynamicSIFSParam(zdev_t* dev, u8_t val)
2604{
2605 zmw_get_wlan_dev(dev);
2606
2607 wd->dynamicSIFSEnable = val;
2608
2609 zm_debug_msg1("wd->dynamicSIFSEnable = ", wd->dynamicSIFSEnable)
2610}
2611
2612u16_t zfiWlanGetMulticastAddressCount(zdev_t* dev)
2613{
2614 zmw_get_wlan_dev(dev);
2615
2616 return wd->sta.multicastList.size;
2617}
2618
2619void zfiWlanGetMulticastList(zdev_t* dev, u8_t* pMCList)
2620{
2621 struct zsMulticastAddr* pMacList = (struct zsMulticastAddr*) pMCList;
2622 u8_t i;
2623
2624 zmw_get_wlan_dev(dev);
2625
2626 for ( i=0; i<wd->sta.multicastList.size; i++ )
2627 {
2628 zfMemoryCopy(pMacList[i].addr, wd->sta.multicastList.macAddr[i].addr, 6);
2629 }
2630}
2631
2632void zfiWlanSetPacketFilter(zdev_t* dev, u32_t PacketFilter)
2633{
2634 u8_t bAllMulticast = 0;
2635 u32_t oldFilter;
2636
2637 zmw_get_wlan_dev(dev);
2638
2639 oldFilter = wd->sta.osRxFilter;
2640
2641 wd->sta.osRxFilter = PacketFilter;
2642
2643 if ((oldFilter & ZM_PACKET_TYPE_ALL_MULTICAST) !=
2644 (wd->sta.osRxFilter & ZM_PACKET_TYPE_ALL_MULTICAST))
2645 {
2646 if ( wd->sta.osRxFilter & ZM_PACKET_TYPE_ALL_MULTICAST )
2647 bAllMulticast = 1;
2648 zfHpSetMulticastList(dev, wd->sta.multicastList.size,
2649 (u8_t*)wd->sta.multicastList.macAddr, bAllMulticast);
2650 }
2651}
2652
2653u8_t zfiCompareWithMulticastListAddress(zdev_t* dev, u16_t* dstMacAddr)
2654{
2655 u8_t i;
2656 u8_t bIsInMCListAddr = 0;
2657
2658 zmw_get_wlan_dev(dev);
2659
2660 for ( i=0; i<wd->sta.multicastList.size; i++ )
2661 {
2662 if ( zfwMemoryIsEqual((u8_t*)dstMacAddr, (u8_t*)wd->sta.multicastList.macAddr[i].addr, 6) )
2663 {
2664 bIsInMCListAddr = 1;
2665 break;
2666 }
2667 }
2668
2669 return bIsInMCListAddr;
2670}
2671
2672void zfiWlanSetSafeModeEnabled(zdev_t* dev, u8_t safeMode)
2673{
2674 zmw_get_wlan_dev(dev);
2675
2676 wd->sta.bSafeMode = safeMode;
2677
2678 if ( safeMode )
2679 zfStaEnableSWEncryption(dev, 1);
2680 else
2681 zfStaDisableSWEncryption(dev);
2682}
2683
2684void zfiWlanSetIBSSAdditionalIELength(zdev_t* dev, u32_t ibssAdditionalIESize, u8_t* ibssAdditionalIE)
2685{
2686 zmw_get_wlan_dev(dev);
2687
2688 if ( ibssAdditionalIESize )
2689 {
2690 wd->sta.ibssAdditionalIESize = ibssAdditionalIESize;
2691 zfMemoryCopy(wd->sta.ibssAdditionalIE, ibssAdditionalIE, (u16_t)ibssAdditionalIESize);
2692 }
2693 else
2694 wd->sta.ibssAdditionalIESize = 0;
2695}
2696
