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