?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
added 2.6.29.6 aldebaran kernel
[nao-ulib.git] / kernel / 2.6.29.6-aldebaran-rt / drivers / staging / otus / 80211core / coid.c
blob6007f3131f8fcc0ad632ee75a7cc371dec44fce2
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 zmw_get_wlan_dev(dev);
218
219 u32_t ret = 0;
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 #if 1
494 //#ifdef ZM_ENABLE_IBSS_WPA2PSK
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 //#endif
509 #endif
510
511 return isInstalled;
512 }
513
514 u8_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 /* Determine opposite exist or not */
529 u8_t res, peerIdx;
530 // u8_t userIdx=0;
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 { /* set key by authenticator */
552 /* set pairwise key */
553 if (keyInfo.flag & ZM_KEY_FLAG_PK)
554 {
555 /* Find STA's information */
556 if ((id = zfApFindSta(dev, keyInfo.macAddr)) == 0xffff)
557 {
558 /* Can't STA in the staTable */
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 { /* TKIP */
567 //u8_t KeyRsc[6] = {0, 0, 0, 0, 0, 0};
568
569 /* In the current AP mode, we set KeyRsc to zero */
570 //zfTkipInit(keyInfo.key, (u8_t*) wd->macAddr,
571 // &(wd->ap.staTable[id].txSeed), KeyRsc);
572 //zfTkipInit(keyInfo.key, (u8_t*) keyInfo.macAddr,
573 // &(wd->ap.staTable[id].rxSeed), KeyRsc);
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 /* Reset txiv and rxiv */
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 /* Set Key Index */
593 wd->ap.staTable[id].cencKeyIdx = keyInfo.keyIndex;
594
595 //zfCoreSetKey(dev, id+1, 1, ZM_CENC, (u16_t *)keyInfo.macAddr,
596 // (u32_t*) &keyInfo.key[16]);
597 }
598 else
599 #endif //ZM_ENABLE_CENC
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 //zfCoreSetKey(dev, id+1, 1, ZM_TKIP, (u16_t *)keyInfo.macAddr,
607 // (u32_t*) micKey);
608
609 /* For fragmentation, we use software MIC */
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 { /* AES */
617 wd->ap.staTable[id].encryMode = ZM_AES;
618 }
619 else if (keyInfo.keyLength == 0)
620 {
621 /* Clear Key Info */
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 //zfCoreSetKey(dev, id+1, 0, wd->ap.staTable[id].encryMode,
632 // (u16_t *)keyInfo.macAddr, (u32_t*) keyInfo.key);
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 { /* TKIP */
647 //u8_t KeyRsc[6] = {0, 0, 0, 0, 0, 0};
648
649 //zfTkipInit(keyInfo.key, (u8_t*) wd->macAddr,
650 // &(wd->ap.bcSeed), KeyRsc);
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 /* Reset txiv and rxiv */
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 //zfCoreSetKey(dev, 0, 1, ZM_CENC, keyInfo.vapAddr,
664 // (u32_t*) &keyInfo.key[16]);
665 key = (u32_t*) keyInfo.key;
666 }
667 else
668 #endif //ZM_ENABLE_CENC
669 {
670 encryMode = ZM_TKIP;
671 key = (u32_t *)keyInfo.key;
672
673 /* set MIC key to HMAC */
674 //zfCoreSetKey(dev, 0, 1, ZM_TKIP, broadcast,
675 // (u32_t*) (&keyInfo.key[16]));
676 //zfCoreSetKey(dev, 0, 1, ZM_TKIP, keyInfo.vapAddr,
677 // (u32_t*) (&keyInfo.key[16]));
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 { /* AES */
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 /* Clear Key Info */
692 zfApClearStaKey(dev, broadcast);
693
694 /* Turn off WEP bit in the capability field */
695 wd->ap.capab[vapId] &= 0xffef;
696
697 return ZM_STATUS_SUCCESS;
698 }
699 else
700 { /* WEP */
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 // Modification for CAM not support VAP search
718 //zfCoreSetKey(dev, 0, 0, encryMode, broadcast, key);
719 //zfCoreSetKey(dev, 0, 0, encryMode, wd->macAddr, key);
720 //zfCoreSetKey(dev, 0, 0, encryMode, keyInfo.vapAddr, key);
721 zfHpSetApGroupKey(dev, wd->macAddr, encryMode,
722 key, (u32_t*) &keyInfo.key[16], vapId);
723
724 //zfiWlanSetEncryMode(dev, encryMode);
725 wd->ws.encryMode = encryMode;
726
727 /* set the multicast address encryption type */
728 wd->ap.encryMode[vapId] = encryMode;
729
730 /* set the multicast key index */
731 wd->ap.bcKeyIndex[vapId] = keyInfo.keyIndex;
732 wd->ap.bcHalKeyIdx[vapId] = vapId + 60;
733
734 /* Turn on WEP bit in the capability field */
735 wd->ap.capab[vapId] |= 0x10;
736 }
737 }
738 else
739 { /* set by supplicant */
740
741 if ( keyInfo.flag & ZM_KEY_FLAG_PK )
742 { /* set pairwise key */
743
744 //zfTkipInit(keyInfo.key, (u8_t*) wd->macAddr,
745 // &wd->sta.txSeed, keyInfo.initIv);
746 //zfTkipInit(keyInfo.key, (u8_t*) wd->sta.bssid,
747 // &wd->sta.rxSeed[keyInfo.keyIndex], keyInfo.initIv);
748
749 #ifdef ZM_ENABLE_IBSS_WPA2PSK
750 if ( wd->sta.ibssWpa2Psk == 1 )
751 {
752 /* unicast -- > pairwise key */
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 { /* TKIP */
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 /* Reset txiv and rxiv */
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 /* Set Key Index */
796 wd->sta.cencKeyId = keyInfo.keyIndex;
797
798 //zfCoreSetKey(dev, id+1, 1, ZM_CENC, (u16_t *)keyInfo.macAddr,
799 // (u32_t*) &keyInfo.key[16]);
800 }
801 else
802 #endif //ZM_ENABLE_CENC
803 {
804 wd->sta.encryMode = ZM_TKIP;
805
806 //zfCoreSetKey(dev, 0, 1, ZM_TKIP, wd->sta.bssid,
807 // (u32_t*) &keyInfo.key[16]);
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 { /* AES */
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 /* user 0 */
837 //zfCoreSetKey(dev, 0, 0, wd->sta.encryMode,
838 // wd->sta.bssid, (u32_t*) keyInfo.key);
839 //zfHpSetStaPairwiseKey(dev, wd->sta.bssid, wd->sta.encryMode,
840 // (u32_t*) keyInfo.key, (u32_t*) &keyInfo.key[16]);
841
842 #ifdef ZM_ENABLE_IBSS_WPA2PSK
843 if ( (keyInfo.keyLength==16) && (wd->sta.ibssWpa2Psk==1) )
844 { /* If not AES-CCMP and ibss network , use traditional */
845 zfHpSetPerUserKey(dev,
846 userIdx,
847 keyInfo.keyIndex, // key id == 0 ( Pairwise key = 0 )
848 (u8_t*)keyInfo.macAddr, // RX need Source Address ( Address 2 )
849 encryType,
850 // wd->sta.encryMode,
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 {/* Big Endian and Little Endian Compatibility */
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, // user id
864 0, // key id
865 addr,//(u8_t *)wd->sta.bssid,
866 wd->sta.encryMode,
867 (u32_t*) keyInfo.key, (u32_t*) &keyInfo.key[16]);
868
869 wd->sta.keyId = 4;
870 }
871 #else
872 /* Big Endian and Little Endian Compatibility */
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, // user id
880 0, // key id
881 addr,//(u8_t *)wd->sta.bssid,
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 { /* set group key */
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 { /* TKIP */
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 /* Reset txiv and rxiv */
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 //zfCoreSetKey(dev, 0, 1, ZM_CENC, keyInfo.vapAddr,
911 // (u32_t*) &keyInfo.key[16]);
912 key = (u32_t*) keyInfo.key;
913 }
914 else
915 #endif //ZM_ENABLE_CENC
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 /* set MIC key to HMAC */
927 //zfCoreSetKey(dev, 8, 1, ZM_TKIP, broadcast,
928 // (u32_t*) (&keyInfo.key[16]));
929
930 zfMicSetKey(&keyInfo.key[24],
931 &wd->sta.rxMicKey[keyInfo.keyIndex]);
932 }
933 }
934 else if ( keyInfo.keyLength == 16 )
935 { /* AES */
936 encryMode = ZM_AES;
937 //key = (u32_t*) wd->sta.rxSeed[keyInfo.keyIndex].tk;
938 }
939 else
940 { /* WEP */
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 /* user 8 */
958 //zfCoreSetKey(dev, 8, 0, encryMode, broadcast, key);
959 //zfHpSetStaGroupKey(dev, broadcast, encryMode,
960 // (u32_t*) keyInfo.key, (u32_t*) (&keyInfo.key[16]));
961
962 #ifdef ZM_ENABLE_IBSS_WPA2PSK
963 if ( (keyInfo.keyLength==16) && (wd->sta.ibssWpa2Psk==1) )
964 {/* If not AES-CCMP and ibss network , use traditional */
965 zfHpSetPerUserKey(dev,
966 userIdx,
967 keyInfo.keyIndex, // key id
968 // (u8_t *)broadcast, // for only 2 stations IBSS netwrl ( A2 )
969 (u8_t*)keyInfo.macAddr, // for multiple ( > 2 ) stations IBSS network ( A2 )
970 encryMode,
971 (u32_t*) keyInfo.key, (u32_t*) &keyInfo.key[16]);
972 }
973 else
974 {
975 zfHpSetPerUserKey(dev,
976 ZM_USER_KEY_GK, // user id
977 0, // key id
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, // user id
987 0, // key id
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 { /* legacy WEP */
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 /* TKIP */
1019 #if 0
1020 // Don't reset the IV since some AP would fail in IV check and drop our connection
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 /* AES */
1038 #if 0
1039 // Don't reset the IV since some AP would fail in IV check and drop our connection
1040 if ( wd->sta.wpaState != ZM_STA_WPA_STATE_PK_OK )
1041 {
1042 /* broadcast -- > group key */
1043 /* Only initialize when set our default key ! */
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 //zfCoreSetKey(dev, 64, 1, wd->sta.encryMode,
1057 // wd->sta.bssid, (u32_t*) (&keyInfo.key[16]));
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 //for WEP default key 1~3 and ATOM platform--CWYang(+)
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 /* use default key */
1104 //zfCoreSetKey(dev, ZM_USER_KEY_DEFAULT+keyInfo.keyIndex, 0,
1105 // wd->sta.encryMode, wd->sta.bssid, (u32_t*) keyInfo.key);
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 {/* If not AES-CCMP and ibss network , use traditional */
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 /* Save key for software WEP */
1146 zfMemoryCopy(wd->sta.wepKey[keyInfo.keyIndex], keyInfo.key,
1147 keyInfo.keyLength);
1148
1149 /* TODO: Check whether we need to save the SWEncryMode */
1150 wd->sta.SWEncryMode[keyInfo.keyIndex] = encryMode;
1151
1152 wd->sta.encryMode = encryMode;
1153 wd->ws.encryMode = encryMode;
1154 }
1155 }
1156 }
1157
1158 // wd->sta.flagKeyChanging = 1;
1159 return ZM_STATUS_SUCCESS;
1160 }
1161
1162 /* PSEUDO test */
1163 u8_t zfiWlanPSEUDOSetKey(zdev_t* dev, struct zsKeyInfo keyInfo)
1164 {
1165 //u16_t broadcast[3] = {0xffff, 0xffff, 0xffff};
1166 //u32_t* key;
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 /* use default key */
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 /* use default key */
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 /* use default key */
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 //zfCoreSetKey(dev, 0, 0, ZM_AES, (u16_t *)keyInfo.macAddr, (u32_t*) keyInfo.key);
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 /* CENC test: user0,1 and user2 for boardcast */
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 /* Initialize PN sequence */
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 //ZM_ENABLE_CENC
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
1237 void 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 /* send null data with PwrBit to inform AP */
1245 if ( mode > ZM_STA_PS_NONE )
1246 {
1247 if ( wd->wlanMode == ZM_MODE_INFRASTRUCTURE )
1248 {
1249 zfSendNullData(dev, 1);
1250 }
1251
1252 /* device into PS mode */
1253 zfPSDeviceSleep(dev);
1254 }
1255 #endif
1256
1257 zfPowerSavingMgrSetMode(dev, mode);
1258 }
1259
1260 void 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
1271 u8_t zfiWlanQueryWlanMode(zdev_t* dev)
1272 {
1273 zmw_get_wlan_dev(dev);
1274
1275 return wd->wlanMode;
1276 }
1277
1278 u8_t zfiWlanQueryAdapterState(zdev_t* dev)
1279 {
1280 zmw_get_wlan_dev(dev);
1281
1282 return wd->state;
1283 }
1284
1285 u8_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 //authMode = wd->sta.authMode;
1298 authMode = wd->sta.currentAuthMode;
1299 }
1300
1301 return authMode;
1302 }
1303
1304 u8_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
1322 void 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
1349 u16_t zfiWlanQueryFragThreshold(zdev_t* dev)
1350 {
1351 zmw_get_wlan_dev(dev);
1352
1353 return wd->fragThreshold;
1354 }
1355
1356 u16_t zfiWlanQueryRtsThreshold(zdev_t* dev)
1357 {
1358 zmw_get_wlan_dev(dev);
1359
1360 return wd->rtsThreshold;
1361 }
1362
1363 u32_t zfiWlanQueryFrequency(zdev_t* dev)
1364 {
1365 zmw_get_wlan_dev(dev);
1366
1367 return (wd->frequency*1000);
1368 }
1369
1370 /***********************************************************
1371 * Function: zfiWlanQueryCurrentFrequency
1372 * Return value:
1373 * - 0 : no validate current frequency
1374 * - (>0): current frequency depend on "qmode"
1375 * Input:
1376 * - qmode:
1377 * 0: return value depend on the support mode, this
1378 qmode is use to solve the bug #31223
1379 * 1: return the actually current frequency
1380 ***********************************************************/
1381 u32_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
1433 u32_t zfiWlanQueryFrequencyAttribute(zdev_t* dev, u32_t freq)
1434 {
1435 zmw_get_wlan_dev(dev);
1436
1437 u8_t i;
1438 u16_t frequency = (u16_t) (freq/1000);
1439 u32_t ret = 0;
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 /* BandWidth 0=>20 1=>40 */
1453 /* ExtOffset 0=>20 1=>high control 40 3=>low control 40 */
1454 void 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
1462 u8_t zfiWlanQueryCWMode(zdev_t* dev)
1463 {
1464 zmw_get_wlan_dev(dev);
1465
1466 return wd->cwm.cw_mode;
1467 }
1468
1469 u32_t zfiWlanQueryCWEnable(zdev_t* dev)
1470 {
1471 zmw_get_wlan_dev(dev);
1472
1473 return wd->cwm.cw_enable;
1474 }
1475
1476 void 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
1486 u16_t zfiWlanQueryBeaconInterval(zdev_t* dev)
1487 {
1488 zmw_get_wlan_dev(dev);
1489
1490 return wd->beaconInterval;
1491 }
1492
1493 u32_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
1501 u16_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
1512 u8_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
1522 u16_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
1535 u16_t zfiWlanQueryAid(zdev_t* dev)
1536 {
1537 zmw_get_wlan_dev(dev);
1538
1539 return wd->sta.aid;
1540 }
1541
1542 void 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
1561 void 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
1580 void 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
1591 void 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
1603 u8_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
1638 u8_t zfiWlanQueryHTMode(zdev_t* dev)
1639 {
1640 zmw_get_wlan_dev(dev);
1641 // 0:Legancy, 1:N
1642 return wd->sta.EnableHT;
1643 }
1644
1645 u8_t zfiWlanQueryBandWidth40(zdev_t* dev)
1646 {
1647 zmw_get_wlan_dev(dev);
1648 // 0:20M, 1:40M
1649 return wd->BandWidth40;
1650 }
1651
1652 u16_t zfiWlanQueryRegionCode(zdev_t* dev)
1653 {
1654 zmw_get_wlan_dev(dev);
1655
1656 return wd->regulationTable.regionCode;
1657 }
1658 void 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) // AP Mode
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 //zfiWlanSetWpaSupport(dev, 1);
1686 if (wd->wlanMode == ZM_MODE_AP) // AP Mode
1687 {
1688 wd->ap.wpaSupport[vapId] = 1;
1689 }
1690 else
1691 {
1692 wd->sta.wpaSupport = 1;
1693 }
1694
1695 }
1696
1697 void 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) // AP Mode
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
1720 void 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
1737 void 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
1747 void zfiWlanSetBGMode(zdev_t* dev, u8_t mode)
1748 {
1749 zmw_get_wlan_dev(dev);
1750
1751 wd->ws.bgMode = mode;
1752 }
1753
1754 void zfiWlanSetpreambleType(zdev_t* dev, u8_t type)
1755 {
1756 zmw_get_wlan_dev(dev);
1757
1758 wd->ws.preambleType = type;
1759 }
1760
1761 u8_t zfiWlanQuerypreambleType(zdev_t* dev)
1762 {
1763 zmw_get_wlan_dev(dev);
1764
1765 return wd->ws.preambleType;
1766 }
1767
1768 u8_t zfiWlanQueryPowerSaveMode(zdev_t* dev)
1769 {
1770 zmw_get_wlan_dev(dev);
1771
1772 return wd->sta.powerSaveMode;
1773 }
1774
1775 u8_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 /* matched */
1787 break;
1788 }
1789 }
1790
1791 if ( i < wd->sta.pmkidInfo.bssidCount )
1792 {
1793 /* overwrite the original one */
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
1812 u32_t zfiWlanQueryPmkidInfo(zdev_t* dev, u8_t* buf, u32_t len)
1813 {
1814 //struct zsPmkidInfo* pPmkidInfo = ( struct zsPmkidInfo* ) buf;
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
1832 void 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 //u32_t value;
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
1854 void 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 /* remove WEP key */
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 /* remove pairwise key */
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 /* remove group key */
1879 zm_debug_msg0("remove group key");
1880 zfHpRemoveKey(dev, ZM_USER_KEY_GK);
1881 }
1882 }
1883
1884
1885 void 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 /* parameter "time" is specified in ms */
1894 void 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
1903 void zfiWlanSetAutoReconnect(zdev_t* dev, u8_t enable)
1904 {
1905 zmw_get_wlan_dev(dev);
1906
1907 wd->sta.bAutoReconnect = enable;
1908 //wd->sta.bAutoReconnectEnabled = enable;
1909 }
1910
1911 void 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
1926 void zfiWlanSetApWme(zdev_t* dev, u8_t enable)
1927 {
1928 zmw_get_wlan_dev(dev);
1929
1930 wd->ws.apWmeEnabled = enable;
1931 }
1932
1933 u8_t zfiWlanQuerywmeEnable(zdev_t* dev)
1934 {
1935 zmw_get_wlan_dev(dev);
1936
1937 return wd->ws.staWmeEnabled;
1938 }
1939
1940 void 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
1958 void 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
1967 void zfiWlanSetDropUnencryptedPackets(zdev_t* dev, u8_t enable)
1968 {
1969 zmw_get_wlan_dev(dev);
1970
1971 wd->ws.dropUnencryptedPkts = enable;
1972 }
1973
1974 void zfiWlanSetStaRxSecurityCheckCb(zdev_t* dev, zfpStaRxSecurityCheckCb pStaRxSecurityCheckCb)
1975 {
1976 zmw_get_wlan_dev(dev);
1977
1978 wd->sta.pStaRxSecurityCheckCb = pStaRxSecurityCheckCb;
1979 }
1980
1981 void 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 /* FUNCTION DESCRIPTION zfiConfigWdsPort */
1991 /* Configure WDS port. */
1992 /* */
1993 /* INPUTS */
1994 /* dev : device pointer */
1995 /* wdsPortId : WDS port ID, start from 0 */
1996 /* flag : 0=>disable WDS port, 1=>enable WDS port */
1997 /* wdsAddr : WDS neighbor MAC address */
1998 /* encType : encryption type for WDS port */
1999 /* wdsKey : encryption key for WDS port */
2000 /* */
2001 /* OUTPUTS */
2002 /* Error code */
2003 /* */
2004 /* AUTHOR */
2005 /* Stephen Chen ZyDAS Technology Corporation 2006.6 */
2006 /* */
2007 /************************************************************************/
2008 u16_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 /* Enable WDS port */
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 /* Disable WDS port */
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 /* CENC */
2046 void zfiWlanQueryGSN(zdev_t* dev, u8_t *gsn, u16_t vapId)
2047 {
2048 //struct zsWlanDev* wd = (struct zsWlanDev*) zmw_wlan_dev(dev);
2049 u32_t txiv[4];
2050 zmw_get_wlan_dev(dev);
2051
2052 /* convert little endian to big endian for 32 bits */
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 //ZM_ENABLE_CENC
2061 //CWYang(+)
2062 void zfiWlanQuerySignalInfo(zdev_t* dev, u8_t *buffer)
2063 {
2064 zmw_get_wlan_dev(dev);
2065
2066 /*Change Signal Strength/Quality Value to Human Sense Here*/
2067
2068 buffer[0] = wd->SignalStrength;
2069 buffer[1] = wd->SignalQuality;
2070 }
2071
2072 /* OS-XP */
2073 u16_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 /* zfiDebugCmd */
2079 /* cmd value-description */
2080 /* 0 schedule timer */
2081 /* 1 cancel timer */
2082 /* 2 clear timer */
2083 /* 3 test timer */
2084 /* 4 */
2085 /* 5 */
2086 /* 6 checksum test 0/1 */
2087 /* 7 enableProtectionMode */
2088 /* 8 rx packet content dump 0/1 */
2089
2090 u32_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 { /* schedule timer */
2103 event = (u16_t) ((value >> 16) & 0xffff);
2104 tick = value & 0xffff;
2105 zfTimerSchedule(dev, event, tick);
2106 }
2107 else if ( cmd == 1 )
2108 { /* cancel timer */
2109 event = (u16_t) (value & 0xffff);
2110 zfTimerCancel(dev, event);
2111 }
2112 else if ( cmd == 2 )
2113 { /* clear timer */
2114 zfTimerClear(dev);
2115 }
2116 else if ( cmd == 3 )
2117 { /* test timer */
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 /* 0: normal 1: always set TCP/UDP checksum zero */
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 /* rx packet content dump */
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
2177 u8_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 /* Reset txiv and rxiv */
2202 //wd->sta.txiv[0] = txiv[0];
2203 //wd->sta.txiv[1] = txiv[1];
2204 //wd->sta.txiv[2] = txiv[2];
2205 //wd->sta.txiv[3] = txiv[3];
2206 //
2207 //wd->sta.rxiv[0] = rxiv[0];
2208 //wd->sta.rxiv[1] = rxiv[1];
2209 //wd->sta.rxiv[2] = rxiv[2];
2210 //wd->sta.rxiv[3] = rxiv[3];
2211
2212 return 0;
2213 }
2214
2215 u8_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 /* Reset txiv and rxiv */
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 //ZM_ENABLE_CENC
2264
2265 u8_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) //Enable 802.11d
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 //Disable
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
2287 u8_t zfiWlanSetDot11HDFSMode(zdev_t* dev, u8_t mode)
2288 {
2289 zmw_get_wlan_dev(dev);
2290
2291 //zm_debug_msg0("CWY - Enable 802.11h DFS");
2292
2293 // TODO : DFS Enable in 5250 to 5350 MHz and 5470 to 5725 MHz .
2294 //if ( Adapter->ZD80211HSupport &&
2295 // Adapter->CardSetting.NetworkTypeInUse == Ndis802_11OFDM5 &&
2296 // ((ChannelNo >=52 && ChannelNo <= 64) || //5250~5350 MHZ
2297 // (ChannelNo >=100 && ChannelNo <= 140))) //5470~5725 MHZ
2298 //{
2299 // Adapter->ZD80211HSetting.DFSEnable=TRUE;
2300 //}
2301 //else
2302 //{
2303 // Adapter->ZD80211HSetting.DFSEnable=FALSE;
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
2315 u8_t zfiWlanSetDot11HTPCMode(zdev_t* dev, u8_t mode)
2316 {
2317 zmw_get_wlan_dev(dev);
2318
2319 // TODO : TPC Enable in 5150~5350 MHz and 5470~5725MHz.
2320 //if ( Adapter->ZD80211HSupport &&
2321 // Adapter->CardSetting.NetworkTypeInUse == Ndis802_11OFDM5 &&
2322 // ((ChannelNo == 36 || ChannelNo == 40 || ChannelNo == 44 || ChannelNo == 48) || //5150~5250 MHZ , Not Japan
2323 // (ChannelNo >=52 && ChannelNo <= 64) || //5250~5350 MHZ
2324 // (ChannelNo >=100 && ChannelNo <= 140))) //5470~5725 MHZ
2325 //{
2326 // Adapter->ZD80211HSetting.TPCEnable=TRUE;
2327 //}
2328 //else
2329 //{
2330 // Adapter->ZD80211HSetting.TPCEnable=FALSE;
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
2342 u8_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
2354 void 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
2397 void 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
2409 void 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
2417 void 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
2428 void 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
2439 void zfiWlanSetAdhocMode(zdev_t* dev, u32_t mode)
2440 {
2441 zmw_get_wlan_dev(dev);
2442
2443 wd->ws.adhocMode = mode;
2444 }
2445
2446 u32_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
2465 u8_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
2491 const char* zfiWlanQueryCountryIsoName(zdev_t* dev)
2492 {
2493 zmw_get_wlan_dev(dev);
2494
2495 return wd->ws.countryIsoName;
2496 }
2497
2498
2499
2500 void 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 /* Reset Regulation Table by Country Code */
2509 zfHpGetRegulationTablefromCountry(dev, Code);
2510 }
2511 else
2512 {
2513 /* Reset Regulation Table by Region Code */
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
2526 const char* zfiHpGetisoNamefromregionCode(zdev_t* dev, u16_t regionCode)
2527 {
2528 return zfHpGetisoNamefromregionCode(dev, regionCode);
2529 }
2530
2531 u16_t zfiWlanChannelToFrequency(zdev_t* dev, u8_t channel)
2532 {
2533 return zfChNumToFreq(dev, channel, 0);
2534 }
2535
2536 u8_t zfiWlanFrequencyToChannel(zdev_t* dev, u16_t freq)
2537 {
2538 u8_t is5GBand = 0;
2539
2540 return zfChFreqToNum(freq, &is5GBand);
2541 }
2542
2543 void zfiWlanDisableDfsChannel(zdev_t* dev, u8_t disableFlag)
2544 {
2545 zfHpDisableDfsChannel(dev, disableFlag);
2546 return;
2547 }
2548
2549 void 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
2561 void zfiWlanEnableLeapConfig(zdev_t* dev, u8_t leapEnabled)
2562 {
2563 zmw_get_wlan_dev(dev);
2564
2565 wd->sta.leapEnabled = leapEnabled;
2566 }
2567
2568 u32_t zfiWlanQueryHwCapability(zdev_t* dev)
2569 {
2570 return zfHpCapability(dev);
2571 }
2572
2573 u32_t zfiWlanQueryReceivedPacket(zdev_t* dev)
2574 {
2575 zmw_get_wlan_dev(dev);
2576
2577 return wd->sta.ReceivedPktRatePerSecond;
2578 }
2579
2580 void 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
2590 u16_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
2603 void 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
2612 u16_t zfiWlanGetMulticastAddressCount(zdev_t* dev)
2613 {
2614 zmw_get_wlan_dev(dev);
2615
2616 return wd->sta.multicastList.size;
2617 }
2618
2619 void 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
2632 void 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
2653 u8_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
2672 void 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
2684 void 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 }
Nao low-level kernelspace/userspace library that runs on our robots, Nao-Team HTWK