?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
GUI: Fix Tomato RAF theme for all builds. Compilation typo.
[tomato.git] / release / src-rt-6.x.4708 / linux / linux-2.6.36 / drivers / staging / otus / 80211core / coid.c
blobbd9c7bec3f7ebb95197dcf21d6ac315d21fe721b
1 /*
2 * Copyright (c) 2007-2008 Atheros Communications Inc.
3 *
4 * Permission to use, copy, modify, and/or distribute this software for any
5 * purpose with or without fee is hereby granted, provided that the above
6 * copyright notice and this permission notice appear in all copies.
7 *
8 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
9 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
10 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
11 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
12 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
13 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
14 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
15 */
16 /* */
17 /* Module Name : iod.c */
18 /* */
19 /* Abstract */
20 /* This module contains OID functions. */
21 /* */
22 /* NOTES */
23 /* None */
24 /* */
25 /************************************************************************/
26 #include "cprecomp.h"
27 #include "../hal/hpreg.h"
28
29 /************************************************************************/
30 /* */
31 /* FUNCTION DESCRIPTION zfiWlanQueryMacAddress */
32 /* Query OWN MAC address. */
33 /* */
34 /* INPUTS */
35 /* addr : for return MAC address */
36 /* */
37 /* OUTPUTS */
38 /* None */
39 /* */
40 /* AUTHOR */
41 /* Stephen Chen ZyDAS Technology Corporation 2005.10 */
42 /* */
43 /************************************************************************/
44 void zfiWlanQueryMacAddress(zdev_t* dev, u8_t* addr)
45 {
46 u16_t vapId = 0;
47 zmw_get_wlan_dev(dev);
48
49 vapId = zfwGetVapId(dev);
50
51 addr[0] = (u8_t)(wd->macAddr[0] & 0xff);
52 addr[1] = (u8_t)(wd->macAddr[0] >> 8);
53 addr[2] = (u8_t)(wd->macAddr[1] & 0xff);
54 addr[3] = (u8_t)(wd->macAddr[1] >> 8);
55 addr[4] = (u8_t)(wd->macAddr[2] & 0xff);
56 if (vapId == 0xffff)
57 addr[5] = (u8_t)(wd->macAddr[2] >> 8);
58 else
59 {
60 #ifdef ZM_VAPMODE_MULTILE_SSID
61 addr[5] = (u8_t)(wd->macAddr[2] >> 8); // Multiple SSID
62 #else
63 addr[5] = vapId + 1 + (u8_t)(wd->macAddr[2] >> 8); //VAP
64 #endif
65 }
66
67 return;
68 }
69
70 void zfiWlanQueryBssList(zdev_t* dev, struct zsBssList* pBssList)
71 {
72 struct zsBssInfo* pBssInfo;
73 struct zsBssInfo* pDstBssInfo;
74 u8_t i;
75 u8_t* pMemList;
76 u8_t* pMemInfo;
77
78 zmw_get_wlan_dev(dev);
79
80 zmw_declare_for_critical_section();
81
82 pMemList = (u8_t*) pBssList;
83 pMemInfo = pMemList + sizeof(struct zsBssList);
84 pBssList->head = (struct zsBssInfo*) pMemInfo;
85
86 zmw_enter_critical_section(dev);
87
88 pBssInfo = wd->sta.bssList.head;
89 pDstBssInfo = (struct zsBssInfo*) pMemInfo;
90 pBssList->bssCount = wd->sta.bssList.bssCount;
91
92 for( i=0; i<wd->sta.bssList.bssCount; i++ )
93 {
94 zfMemoryCopy((u8_t*)pDstBssInfo, (u8_t*)pBssInfo,
95 sizeof(struct zsBssInfo));
96
97 if ( pBssInfo->next != NULL )
98 {
99 pBssInfo = pBssInfo->next;
100 pDstBssInfo->next = pDstBssInfo + 1;
101 pDstBssInfo++;
102 }
103 else
104 {
105 zm_assert(i==(wd->sta.bssList.bssCount-1));
106 }
107 }
108
109 zmw_leave_critical_section(dev);
110
111 zfScanMgrScanAck(dev);
112 }
113
114 void zfiWlanQueryBssListV1(zdev_t* dev, struct zsBssListV1* bssListV1)
115 {
116 struct zsBssInfo* pBssInfo;
117 //struct zsBssInfo* pDstBssInfo;
118 u8_t i, j, bdrop = 0, k = 0, Same_Count = 0;
119 u8_t bssid[6];
120 //u8_t* pMemList;
121 //u8_t* pMemInfo;
122 zmw_get_wlan_dev(dev);
123 zmw_declare_for_critical_section();
124
125 zmw_enter_critical_section(dev);
126
127 bssListV1->bssCount = wd->sta.bssList.bssCount;
128
129 pBssInfo = wd->sta.bssList.head;
130 ZM_MAC_WORD_TO_BYTE(wd->sta.bssid, bssid);
131
132 for( i=0; i<wd->sta.bssList.bssCount; i++ )
133 {
134 bdrop = 0;
135 if ( zfStaIsConnected(dev)
136 && (wd->wlanMode == ZM_MODE_INFRASTRUCTURE ) )
137 {
138 for (j = 0; j < 6; j++)
139 {
140 if ( pBssInfo->bssid[j] != bssid[j] )
141 {
142 break;
143 }
144 }
145
146 if ( (j == 6)
147 &&((pBssInfo->ssid[1] == wd->sta.ssidLen) || (pBssInfo->ssid[1] == 0) )&& (pBssInfo->frequency == wd->frequency) )
148 {
149 if(pBssInfo->ssid[1] == 0)
150 pBssInfo->ssid[1] = wd->sta.ssidLen;
151
152 if(Same_Count == 0)
153 {//First meet
154 Same_Count++;
155 }
156 else
157 {//same one
158 bdrop = 1;
159 bssListV1->bssCount--;
160 }
161
162 }
163 }
164
165 if (bdrop == 0)
166 {
167 zfMemoryCopy((u8_t*)(&bssListV1->bssInfo[k]), (u8_t*)pBssInfo,
168 sizeof(struct zsBssInfo));
169
170 if(Same_Count == 1)
171 {
172 zfMemoryCopy(&(bssListV1->bssInfo[k].ssid[2]), wd->sta.ssid, wd->sta.ssidLen);
173 Same_Count++;
174 }
175
176 k++;
177 }
178
179 if ( pBssInfo->next != NULL )
180 {
181 pBssInfo = pBssInfo->next;
182 }
183 else
184 {
185 zm_assert(i==(wd->sta.bssList.bssCount-1));
186 }
187 }
188
189 zmw_leave_critical_section(dev);
190
191 zfScanMgrScanAck(dev);
192 }
193
194 void zfiWlanQueryAdHocCreatedBssDesc(zdev_t* dev, struct zsBssInfo *pBssInfo)
195 {
196 zmw_get_wlan_dev(dev);
197
198 zfMemoryCopy((u8_t *)pBssInfo, (u8_t *)&wd->sta.ibssBssDesc, sizeof(struct zsBssInfo));
199 }
200
201 u8_t zfiWlanQueryAdHocIsCreator(zdev_t* dev)
202 {
203 zmw_get_wlan_dev(dev);
204
205 return wd->sta.ibssBssIsCreator;
206 }
207
208 u32_t zfiWlanQuerySupportMode(zdev_t* dev)
209 {
210 zmw_get_wlan_dev(dev);
211
212 return wd->supportMode;
213 }
214
215 u32_t zfiWlanQueryTransmitPower(zdev_t* dev)
216 {
217 u32_t ret = 0;
218
219 zmw_get_wlan_dev(dev);
220
221 if (zfStaIsConnected(dev)) {
222 ret = wd->sta.connPowerInHalfDbm;
223 } else {
224 ret = zfHpGetTransmitPower(dev);
225 }
226
227 return ret;
228 }
229
230 /************************************************************************/
231 /* */
232 /* FUNCTION DESCRIPTION zfiWlanFlushBssList */
233 /* Flush BSSID List. */
234 /* */
235 /* INPUTS */
236 /* dev : device pointer */
237 /* */
238 /* OUTPUTS */
239 /* none */
240 /* */
241 /* AUTHOR */
242 /* Stephen Chen Atheros Communications, INC. 2006.12 */
243 /* */
244 /************************************************************************/
245 void zfiWlanFlushBssList(zdev_t* dev)
246 {
247 zmw_declare_for_critical_section();
248
249 zmw_enter_critical_section(dev);
250 /* Call zfBssInfoRefresh() twice to remove all entry */
251 zfBssInfoRefresh(dev, 1);
252 zmw_leave_critical_section(dev);
253 }
254
255 void zfiWlanSetWlanMode(zdev_t* dev, u8_t wlanMode)
256 {
257 zmw_get_wlan_dev(dev);
258
259 zmw_declare_for_critical_section();
260
261 zmw_enter_critical_section(dev);
262 wd->ws.wlanMode = wlanMode;
263 zmw_leave_critical_section(dev);
264 }
265
266 void zfiWlanSetAuthenticationMode(zdev_t* dev, u8_t authMode)
267 {
268 zmw_get_wlan_dev(dev);
269
270 zmw_declare_for_critical_section();
271
272 zmw_enter_critical_section(dev);
273 wd->ws.authMode = authMode;
274 zmw_leave_critical_section(dev);
275 }
276
277 void zfiWlanSetWepStatus(zdev_t* dev, u8_t wepStatus)
278 {
279 zmw_get_wlan_dev(dev);
280
281 zmw_declare_for_critical_section();
282
283 zmw_enter_critical_section(dev);
284 wd->ws.wepStatus = wepStatus;
285 zmw_leave_critical_section(dev);
286
287 }
288
289 void zfiWlanSetSSID(zdev_t* dev, u8_t* ssid, u8_t ssidLength)
290 {
291 u16_t i;
292 zmw_get_wlan_dev(dev);
293
294 zmw_declare_for_critical_section();
295
296 if ( ssidLength <= 32 )
297 {
298 zmw_enter_critical_section(dev);
299
300 wd->ws.ssidLen = ssidLength;
301 zfMemoryCopy(wd->ws.ssid, ssid, ssidLength);
302
303 if ( ssidLength < 32 )
304 {
305 wd->ws.ssid[ssidLength] = 0;
306 }
307
308 wd->ws.probingSsidList[0].ssidLen = ssidLength;
309 zfMemoryCopy(wd->ws.probingSsidList[0].ssid, ssid, ssidLength);
310 for (i=1; i<ZM_MAX_PROBE_HIDDEN_SSID_SIZE; i++)
311 {
312 wd->ws.probingSsidList[i].ssidLen = 0;
313 }
314
315 zmw_leave_critical_section(dev);
316 }
317 }
318
319 void zfiWlanSetFragThreshold(zdev_t* dev, u16_t fragThreshold)
320 {
321 zmw_get_wlan_dev(dev);
322
323 zmw_declare_for_critical_section();
324
325 zmw_enter_critical_section(dev);
326
327 if (fragThreshold == 0)
328 { /* fragmentation is disabled */
329 wd->fragThreshold = 32767;
330 }
331 else if (fragThreshold < 256)
332 {
333 /* Minimum fragment threshold */
334 wd->fragThreshold = 256;
335 }
336 else if (fragThreshold > 2346)
337 {
338 wd->fragThreshold = 2346;
339 }
340 else
341 {
342 wd->fragThreshold = fragThreshold & 0xfffe;
343 }
344
345 zmw_leave_critical_section(dev);
346 }
347
348 void zfiWlanSetRtsThreshold(zdev_t* dev, u16_t rtsThreshold)
349 {
350 zmw_get_wlan_dev(dev);
351
352 zmw_declare_for_critical_section();
353
354 zmw_enter_critical_section(dev);
355 wd->rtsThreshold = rtsThreshold;
356 zmw_leave_critical_section(dev);
357 }
358
359 void zfiWlanSetFrequency(zdev_t* dev, u32_t frequency, u8_t bImmediate)
360 {
361 zmw_get_wlan_dev(dev);
362
363 zmw_declare_for_critical_section();
364
365 if ( bImmediate )
366 {
367 zmw_enter_critical_section(dev);
368 wd->frequency = (u16_t) (frequency/1000);
369 zmw_leave_critical_section(dev);
370 zfCoreSetFrequency(dev, wd->frequency);
371 }
372 else
373 {
374 zmw_enter_critical_section(dev);
375 if( frequency == 0 )
376 { // Auto select clean channel depend on wireless environment !
377 wd->ws.autoSetFrequency = 0;
378 }
379 wd->ws.frequency = (u16_t) (frequency/1000);
380 zmw_leave_critical_section(dev);
381 }
382 }
383
384 void zfiWlanSetBssid(zdev_t* dev, u8_t* bssid)
385 {
386 u16_t i;
387 zmw_get_wlan_dev(dev);
388
389 zmw_declare_for_critical_section();
390
391 zmw_enter_critical_section(dev);
392 for (i=0; i<6; i++)
393 {
394 wd->ws.desiredBssid[i] = bssid[i];
395 }
396 wd->ws.bDesiredBssid = TRUE;
397 zmw_leave_critical_section(dev);
398
399 }
400
401 void zfiWlanSetBeaconInterval(zdev_t* dev,
402 u16_t beaconInterval,
403 u8_t bImmediate)
404 {
405 zmw_get_wlan_dev(dev);
406
407 zmw_declare_for_critical_section();
408
409 if ( bImmediate )
410 {
411 zmw_enter_critical_section(dev);
412 wd->beaconInterval = beaconInterval;
413 zmw_leave_critical_section(dev);
414
415 /* update beacon interval here */
416 }
417 else
418 {
419 zmw_enter_critical_section(dev);
420 wd->ws.beaconInterval = beaconInterval;
421 zmw_leave_critical_section(dev);
422 }
423 }
424
425
426 void zfiWlanSetDtimCount(zdev_t* dev, u8_t dtim)
427 {
428 zmw_get_wlan_dev(dev);
429
430 zmw_declare_for_critical_section();
431
432 zmw_enter_critical_section(dev);
433 if (dtim > 0)
434 {
435 wd->ws.dtim = dtim;
436 }
437 zmw_leave_critical_section(dev);
438 }
439
440
441 void zfiWlanSetAtimWindow(zdev_t* dev, u16_t atimWindow, u8_t bImmediate)
442 {
443 zmw_get_wlan_dev(dev);
444
445 zmw_declare_for_critical_section();
446
447 if ( bImmediate )
448 {
449 zmw_enter_critical_section(dev);
450 wd->sta.atimWindow = atimWindow;
451 zmw_leave_critical_section(dev);
452
453 /* atim window here */
454 }
455 else
456 {
457 zmw_enter_critical_section(dev);
458 wd->ws.atimWindow = atimWindow;
459 zmw_leave_critical_section(dev);
460 }
461 }
462
463
464 void zfiWlanSetEncryMode(zdev_t* dev, u8_t encryMode)
465 {
466 zmw_get_wlan_dev(dev);
467
468 zmw_declare_for_critical_section();
469
470 zmw_enter_critical_section(dev);
471 if (wd->wlanMode == ZM_MODE_AP)
472 {
473 /* Hostapd Issue */
474 if ((wd->ws.encryMode != ZM_AES) && (wd->ws.encryMode != ZM_TKIP))
475 wd->ws.encryMode = encryMode;
476 }
477 else
478 wd->ws.encryMode = encryMode;
479 zmw_leave_critical_section(dev);
480 }
481
482 void zfiWlanSetDefaultKeyId(zdev_t* dev, u8_t keyId)
483 {
484 zmw_get_wlan_dev(dev);
485
486 wd->sta.keyId = keyId;
487 }
488
489 u8_t zfiWlanQueryIsPKInstalled(zdev_t *dev, u8_t *staMacAddr)
490 {
491 u8_t isInstalled = 0;
492
493 //#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
512 u8_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 */
1144 u8_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
1218 void zfiWlanSetPowerSaveMode(zdev_t* dev, u8_t mode)
1219 {
1220
1221 zfPowerSavingMgrSetMode(dev, mode);
1222 }
1223
1224 void 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
1235 u8_t zfiWlanQueryWlanMode(zdev_t* dev)
1236 {
1237 zmw_get_wlan_dev(dev);
1238
1239 return wd->wlanMode;
1240 }
1241
1242 u8_t zfiWlanQueryAdapterState(zdev_t* dev)
1243 {
1244 zmw_get_wlan_dev(dev);
1245
1246 return wd->state;
1247 }
1248
1249 u8_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
1268 u8_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
1286 void 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
1313 u16_t zfiWlanQueryFragThreshold(zdev_t* dev)
1314 {
1315 zmw_get_wlan_dev(dev);
1316
1317 return wd->fragThreshold;
1318 }
1319
1320 u16_t zfiWlanQueryRtsThreshold(zdev_t* dev)
1321 {
1322 zmw_get_wlan_dev(dev);
1323
1324 return wd->rtsThreshold;
1325 }
1326
1327 u32_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 ***********************************************************/
1345 u32_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
1397 u32_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 */
1418 void 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
1426 u8_t zfiWlanQueryCWMode(zdev_t* dev)
1427 {
1428 zmw_get_wlan_dev(dev);
1429
1430 return wd->cwm.cw_mode;
1431 }
1432
1433 u32_t zfiWlanQueryCWEnable(zdev_t* dev)
1434 {
1435 zmw_get_wlan_dev(dev);
1436
1437 return wd->cwm.cw_enable;
1438 }
1439
1440 void 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
1450 u16_t zfiWlanQueryBeaconInterval(zdev_t* dev)
1451 {
1452 zmw_get_wlan_dev(dev);
1453
1454 return wd->beaconInterval;
1455 }
1456
1457 u32_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
1465 u16_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
1476 u8_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
1486 u16_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
1499 u16_t zfiWlanQueryAid(zdev_t* dev)
1500 {
1501 zmw_get_wlan_dev(dev);
1502
1503 return wd->sta.aid;
1504 }
1505
1506 void 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
1525 void 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
1544 void 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
1555 void 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
1567 u8_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
1602 u8_t zfiWlanQueryHTMode(zdev_t* dev)
1603 {
1604 zmw_get_wlan_dev(dev);
1605 // 0:Legancy, 1:N
1606 return wd->sta.EnableHT;
1607 }
1608
1609 u8_t zfiWlanQueryBandWidth40(zdev_t* dev)
1610 {
1611 zmw_get_wlan_dev(dev);
1612 // 0:20M, 1:40M
1613 return wd->BandWidth40;
1614 }
1615
1616 u16_t zfiWlanQueryRegionCode(zdev_t* dev)
1617 {
1618 zmw_get_wlan_dev(dev);
1619
1620 return wd->regulationTable.regionCode;
1621 }
1622 void 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
1661 void 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
1684 void 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
1701 void 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
1711 void zfiWlanSetBGMode(zdev_t* dev, u8_t mode)
1712 {
1713 zmw_get_wlan_dev(dev);
1714
1715 wd->ws.bgMode = mode;
1716 }
1717
1718 void zfiWlanSetpreambleType(zdev_t* dev, u8_t type)
1719 {
1720 zmw_get_wlan_dev(dev);
1721
1722 wd->ws.preambleType = type;
1723 }
1724
1725 u8_t zfiWlanQuerypreambleType(zdev_t* dev)
1726 {
1727 zmw_get_wlan_dev(dev);
1728
1729 return wd->ws.preambleType;
1730 }
1731
1732 u8_t zfiWlanQueryPowerSaveMode(zdev_t* dev)
1733 {
1734 zmw_get_wlan_dev(dev);
1735
1736 return wd->sta.powerSaveMode;
1737 }
1738
1739 u8_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
1776 u32_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
1796 void 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
1818 void 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
1849 void 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 */
1858 void 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
1867 void 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
1875 void 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
1890 void zfiWlanSetApWme(zdev_t* dev, u8_t enable)
1891 {
1892 zmw_get_wlan_dev(dev);
1893
1894 wd->ws.apWmeEnabled = enable;
1895 }
1896
1897 u8_t zfiWlanQuerywmeEnable(zdev_t* dev)
1898 {
1899 zmw_get_wlan_dev(dev);
1900
1901 return wd->ws.staWmeEnabled;
1902 }
1903
1904 void 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
1922 void 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
1931 void zfiWlanSetDropUnencryptedPackets(zdev_t* dev, u8_t enable)
1932 {
1933 zmw_get_wlan_dev(dev);
1934
1935 wd->ws.dropUnencryptedPkts = enable;
1936 }
1937
1938 void zfiWlanSetStaRxSecurityCheckCb(zdev_t* dev, zfpStaRxSecurityCheckCb pStaRxSecurityCheckCb)
1939 {
1940 zmw_get_wlan_dev(dev);
1941
1942 wd->sta.pStaRxSecurityCheckCb = pStaRxSecurityCheckCb;
1943 }
1944
1945 void 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 /************************************************************************/
1972 u16_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 */
2010 void 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(+)
2026 void 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 */
2037 u16_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
2054 u32_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
2141 u8_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
2179 u8_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
2229 u8_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
2251 u8_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
2279 u8_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
2306 u8_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
2318 void 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
2361 void 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
2373 void 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
2381 void 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
2392 void 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
2403 void zfiWlanSetAdhocMode(zdev_t* dev, u32_t mode)
2404 {
2405 zmw_get_wlan_dev(dev);
2406
2407 wd->ws.adhocMode = mode;
2408 }
2409
2410 u32_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
2429 u8_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
2455 const char* zfiWlanQueryCountryIsoName(zdev_t* dev)
2456 {
2457 zmw_get_wlan_dev(dev);
2458
2459 return wd->ws.countryIsoName;
2460 }
2461
2462
2463
2464 void 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
2490 const char* zfiHpGetisoNamefromregionCode(zdev_t* dev, u16_t regionCode)
2491 {
2492 return zfHpGetisoNamefromregionCode(dev, regionCode);
2493 }
2494
2495 u16_t zfiWlanChannelToFrequency(zdev_t* dev, u8_t channel)
2496 {
2497 return zfChNumToFreq(dev, channel, 0);
2498 }
2499
2500 u8_t zfiWlanFrequencyToChannel(zdev_t* dev, u16_t freq)
2501 {
2502 u8_t is5GBand = 0;
2503
2504 return zfChFreqToNum(freq, &is5GBand);
2505 }
2506
2507 void zfiWlanDisableDfsChannel(zdev_t* dev, u8_t disableFlag)
2508 {
2509 zfHpDisableDfsChannel(dev, disableFlag);
2510 return;
2511 }
2512
2513 void 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
2525 void zfiWlanEnableLeapConfig(zdev_t* dev, u8_t leapEnabled)
2526 {
2527 zmw_get_wlan_dev(dev);
2528
2529 wd->sta.leapEnabled = leapEnabled;
2530 }
2531
2532 u32_t zfiWlanQueryHwCapability(zdev_t* dev)
2533 {
2534 return zfHpCapability(dev);
2535 }
2536
2537 u32_t zfiWlanQueryReceivedPacket(zdev_t* dev)
2538 {
2539 zmw_get_wlan_dev(dev);
2540
2541 return wd->sta.ReceivedPktRatePerSecond;
2542 }
2543
2544 void 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
2554 u16_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
2567 void 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
2576 u16_t zfiWlanGetMulticastAddressCount(zdev_t* dev)
2577 {
2578 zmw_get_wlan_dev(dev);
2579
2580 return wd->sta.multicastList.size;
2581 }
2582
2583 void 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
2596 void 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
2617 u8_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
2636 void 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
2648 void 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 }
Tomato firmware and modifications.