?  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 / ccmd.c
blob47997797367108df7eb1f65f8478cdcdab1bc37f
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 : cmd.c */
18 /* */
19 /* Abstract */
20 /* This module contains command interface functions. */
21 /* */
22 /* NOTES */
23 /* None */
24 /* */
25 /************************************************************************/
26 #include "cprecomp.h"
27 #include "../hal/hpreg.h"
28
29
30 u16_t zfWlanReset(zdev_t* dev);
31 u32_t zfUpdateRxRate(zdev_t* dev);
32
33
34 extern void zfiUsbRecv(zdev_t *dev, zbuf_t *buf);
35 extern void zfiUsbRegIn(zdev_t* dev, u32_t* rsp, u16_t rspLen);
36 extern void zfiUsbOutComplete(zdev_t* dev, zbuf_t *buf, u8_t status, u8_t *hdr);
37 extern void zfiUsbRegOutComplete(zdev_t* dev);
38 extern u16_t zfHpReinit(zdev_t* dev, u32_t frequency);
39
40 /* Get size (byte) of driver core global data structure. */
41 /* This size will be used by driver wrapper to allocate */
42 /* a memory space for driver core to store global variables */
43 u16_t zfiGlobalDataSize(zdev_t* dev)
44 {
45 u32_t ret;
46 ret = (sizeof(struct zsWlanDev));
47 zm_assert((ret>>16) == 0);
48 return (u16_t)ret;
49 }
50
51
52 /* Initialize WLAN hardware and software, resource will be allocated */
53 /* for WLAN operation, must be called first before other function. */
54 extern u16_t zfiWlanOpen(zdev_t* dev, struct zsCbFuncTbl* cbFuncTbl)
55 {
56 //u16_t ret;
57 //u32_t i;
58 //u8_t* ch;
59 //u8_t bPassive;
60 u32_t devSize;
61 struct zfCbUsbFuncTbl cbUsbFuncTbl;
62 zmw_get_wlan_dev(dev);
63
64 zm_debug_msg0("start");
65
66 devSize = sizeof(struct zsWlanDev);
67 /* Zeroize zsWlanDev struct */
68 zfZeroMemory((u8_t*)wd, (u16_t)devSize);
69
70 #ifdef ZM_ENABLE_AGGREGATION
71 zfAggInit(dev);
72 #endif
73
74 zfCwmInit(dev);
75
76 wd->commTally.RateCtrlTxMPDU = 0;
77 wd->commTally.RateCtrlBAFail = 0;
78 wd->preambleTypeInUsed = ZM_PREAMBLE_TYPE_SHORT;
79
80 if (cbFuncTbl == NULL)
81 {
82 /* zfcbRecvEth() is mandatory */
83 zm_assert(0);
84 }
85 else
86 {
87 if (cbFuncTbl->zfcbRecvEth == NULL)
88 {
89 /* zfcbRecvEth() is mandatory */
90 zm_assert(0);
91 }
92 wd->zfcbAuthNotify = cbFuncTbl->zfcbAuthNotify;
93 wd->zfcbAuthNotify = cbFuncTbl->zfcbAuthNotify;
94 wd->zfcbAsocNotify = cbFuncTbl->zfcbAsocNotify;
95 wd->zfcbDisAsocNotify = cbFuncTbl->zfcbDisAsocNotify;
96 wd->zfcbApConnectNotify = cbFuncTbl->zfcbApConnectNotify;
97 wd->zfcbConnectNotify = cbFuncTbl->zfcbConnectNotify;
98 wd->zfcbScanNotify = cbFuncTbl->zfcbScanNotify;
99 wd->zfcbMicFailureNotify = cbFuncTbl->zfcbMicFailureNotify;
100 wd->zfcbApMicFailureNotify = cbFuncTbl->zfcbApMicFailureNotify;
101 wd->zfcbIbssPartnerNotify = cbFuncTbl->zfcbIbssPartnerNotify;
102 wd->zfcbMacAddressNotify = cbFuncTbl->zfcbMacAddressNotify;
103 wd->zfcbSendCompleteIndication = cbFuncTbl->zfcbSendCompleteIndication;
104 wd->zfcbRecvEth = cbFuncTbl->zfcbRecvEth;
105 wd->zfcbRestoreBufData = cbFuncTbl->zfcbRestoreBufData;
106 wd->zfcbRecv80211 = cbFuncTbl->zfcbRecv80211;
107 #ifdef ZM_ENABLE_CENC
108 wd->zfcbCencAsocNotify = cbFuncTbl->zfcbCencAsocNotify;
109 #endif //ZM_ENABLE_CENC
110 wd->zfcbClassifyTxPacket = cbFuncTbl->zfcbClassifyTxPacket;
111 wd->zfcbHwWatchDogNotify = cbFuncTbl->zfcbHwWatchDogNotify;
112 }
113
114 //add by honda 0330
115 cbUsbFuncTbl.zfcbUsbRecv = zfiUsbRecv;
116 cbUsbFuncTbl.zfcbUsbRegIn = zfiUsbRegIn;
117 cbUsbFuncTbl.zfcbUsbOutComplete = zfiUsbOutComplete;
118 cbUsbFuncTbl.zfcbUsbRegOutComplete = zfiUsbRegOutComplete;
119 zfwUsbRegisterCallBack(dev, &cbUsbFuncTbl);
120 /* Init OWN MAC address */
121 wd->macAddr[0] = 0x8000;
122 wd->macAddr[1] = 0x0000;
123 wd->macAddr[2] = 0x0000;
124
125 wd->regulationTable.regionCode = 0xffff;
126
127 zfHpInit(dev, wd->frequency);
128
129 /* init region code */
130 //wd->regulationTable.regionCode = NULL1_WORLD; //Only 2.4g RegCode
131 //zfHpGetRegulationTablefromRegionCode(dev, NULL1_WORLD);
132 //zfiWlanSetDot11DMode(dev , 1); // Enable 802.11d
133 /* Get the first channel */
134 //wd->frequency = zfChGetFirstChannel(dev, &bPassive);
135 #ifdef ZM_AP_DEBUG
136 //wd->frequency = 2437;
137 #endif
138
139 //STA mode
140 wd->sta.mTxRate = 0x0;
141 wd->sta.uTxRate = 0x3;
142 wd->sta.mmTxRate = 0x0;
143 wd->sta.adapterState = ZM_STA_STATE_DISCONNECT;
144 wd->sta.capability[0] = 0x01;
145 wd->sta.capability[1] = 0x00;
146
147 wd->sta.preambleTypeHT = 0;
148 wd->sta.htCtrlBandwidth = 0;
149 wd->sta.htCtrlSTBC = 0;
150 wd->sta.htCtrlSG = 0;
151 wd->sta.defaultTA = 0;
152 //wd->sta.activescanTickPerChannel = ZM_TIME_ACTIVE_SCAN/ZM_MS_PER_TICK;
153 {
154 u8_t Dur = ZM_TIME_ACTIVE_SCAN;
155 zfwGetActiveScanDur(dev, &Dur);
156 wd->sta.activescanTickPerChannel = Dur/ZM_MS_PER_TICK;
157
158 }
159 wd->sta.passiveScanTickPerChannel = ZM_TIME_PASSIVE_SCAN/ZM_MS_PER_TICK;
160 wd->sta.bAutoReconnect = TRUE;
161 wd->sta.dropUnencryptedPkts = FALSE;
162
163 /* set default to bypass all multicast packet for linux, window XP would set 0 by wrapper initialization */
164 wd->sta.bAllMulticast = 1;
165
166 /* Initial the RIFS Status / RIFS-like frame count / RIFS count */
167 wd->sta.rifsState = ZM_RIFS_STATE_DETECTING;
168 wd->sta.rifsLikeFrameCnt = 0;
169 wd->sta.rifsCount = 0;
170
171 wd->sta.osRxFilter = 0;
172 wd->sta.bSafeMode = 0;
173
174 //Common
175 zfResetSupportRate(dev, ZM_DEFAULT_SUPPORT_RATE_DISCONNECT);
176 wd->beaconInterval = 100;
177 wd->rtsThreshold = 2346;
178 wd->fragThreshold = 32767;
179 wd->wlanMode = ZM_MODE_INFRASTRUCTURE;
180 wd->txMCS = 0xff; //AUTO
181 wd->dtim = 1;
182 //wd->txMT = 1; //OFDM
183 wd->tick = 1;
184 wd->maxTxPower2 = 0xff;
185 wd->maxTxPower5 = 0xff;
186 wd->supportMode = 0xffffffff;
187 wd->ws.adhocMode = ZM_ADHOCBAND_G;
188 wd->ws.autoSetFrequency = 0xff;
189
190 //AP mode
191 //wd->bgMode = wd->ws.bgMode;
192 wd->ap.ssidLen[0] = 6;
193 wd->ap.ssid[0][0] = 'Z';
194 wd->ap.ssid[0][1] = 'D';
195 wd->ap.ssid[0][2] = '1';
196 wd->ap.ssid[0][3] = '2';
197 wd->ap.ssid[0][4] = '2';
198 wd->ap.ssid[0][5] = '1';
199
200 // Init the country iso name as NA
201 wd->ws.countryIsoName[0] = 0;
202 wd->ws.countryIsoName[1] = 0;
203 wd->ws.countryIsoName[2] = '\0';
204
205 /* init fragmentation is disabled */
206 //zfiWlanSetFragThreshold(dev, 0);
207
208 /* airopeek : swSniffer 1=>on 0=>off */
209 wd->swSniffer = 0;
210 wd->XLinkMode = 0;
211
212 // jhlee HT 0
213 #if 1
214 /* AP Mode*/
215 /* Init HT Capability Info */
216 wd->ap.HTCap.Data.ElementID = ZM_WLAN_EID_HT_CAPABILITY;
217 wd->ap.HTCap.Data.Length = 26;
218 //wd->ap.HTCap.Data.SupChannelWidthSet = 0;
219 //wd->ap.HTCap.Data.MIMOPowerSave = 3;
220 //wd->ap.HTCap.Data.ShortGIfor40MHz = 0;
221 //wd->ap.HTCap.Data.ShortGIfor20MHz = 0;
222 //wd->ap.HTCap.Data.DSSSandCCKin40MHz = 0;
223 wd->ap.HTCap.Data.AMPDUParam |= HTCAP_MaxRxAMPDU3;
224 wd->ap.HTCap.Data.MCSSet[0] = 0xFF; // MCS 0 ~ 7
225 wd->ap.HTCap.Data.MCSSet[1] = 0xFF; // MCS 8 ~ 15
226
227 /* Init Extended HT Capability Info */
228 wd->ap.ExtHTCap.Data.ElementID = ZM_WLAN_EID_EXTENDED_HT_CAPABILITY;
229 wd->ap.ExtHTCap.Data.Length = 22;
230 wd->ap.ExtHTCap.Data.ControlChannel = 6;
231 //wd->ap.ExtHTCap.Data.ExtChannelOffset = 3;
232 wd->ap.ExtHTCap.Data.ChannelInfo |= ExtHtCap_RecomTxWidthSet;
233 //wd->ap.ExtHTCap.Data.RIFSMode = 1;
234 wd->ap.ExtHTCap.Data.OperatingInfo |= 1;
235
236 /* STA Mode*/
237 /* Init HT Capability Info */
238 wd->sta.HTCap.Data.ElementID = ZM_WLAN_EID_HT_CAPABILITY;
239 wd->sta.HTCap.Data.Length = 26;
240
241 /* Test with 5G-AP : 7603 */
242 //wd->sta.HTCap.Data.SupChannelWidthSet = 1;
243 wd->sta.HTCap.Data.HtCapInfo |= HTCAP_SMEnabled;
244 wd->sta.HTCap.Data.HtCapInfo |= HTCAP_SupChannelWidthSet;
245 wd->sta.HTCap.Data.HtCapInfo |= HTCAP_ShortGIfor40MHz;
246 wd->sta.HTCap.Data.HtCapInfo |= HTCAP_DSSSandCCKin40MHz;
247 #ifndef ZM_DISABLE_AMSDU8K_SUPPORT
248 wd->sta.HTCap.Data.HtCapInfo |= HTCAP_MaxAMSDULength;
249 #endif
250 //wd->sta.HTCap.Data.MIMOPowerSave = 0;
251 //wd->sta.HTCap.Data.ShortGIfor40MHz = 0;
252 //wd->sta.HTCap.Data.ShortGIfor20MHz = 0;
253 //wd->sta.HTCap.Data.DSSSandCCKin40MHz = 0;
254 wd->sta.HTCap.Data.AMPDUParam |= HTCAP_MaxRxAMPDU3;
255 wd->sta.HTCap.Data.MCSSet[0] = 0xFF; // MCS 0 ~ 7
256 wd->sta.HTCap.Data.MCSSet[1] = 0xFF; // MCS 8 ~ 15
257 wd->sta.HTCap.Data.PCO |= HTCAP_TransmissionTime3;
258 //wd->sta.HTCap.Data.TransmissionTime = 0;
259 /* Init Extended HT Capability Info */
260 wd->sta.ExtHTCap.Data.ElementID = ZM_WLAN_EID_EXTENDED_HT_CAPABILITY;
261 wd->sta.ExtHTCap.Data.Length = 22;
262 wd->sta.ExtHTCap.Data.ControlChannel = 6;
263
264 //wd->sta.ExtHTCap.Data.ExtChannelOffset |= 3;
265 wd->sta.ExtHTCap.Data.ChannelInfo |= ExtHtCap_ExtChannelOffsetBelow;
266
267 //wd->sta.ExtHTCap.Data.RecomTxWidthSet = 1;
268 //wd->sta.ExtHTCap.Data.RIFSMode = 1;
269 wd->sta.ExtHTCap.Data.OperatingInfo |= 1;
270 #endif
271
272 #if 0
273 /* WME test code */
274 wd->ap.qosMode[0] = 1;
275 #endif
276
277 wd->ledStruct.ledMode[0] = 0x2221;
278 wd->ledStruct.ledMode[1] = 0x2221;
279
280 zfTimerInit(dev);
281
282 ZM_PERFORMANCE_INIT(dev);
283
284 zfBssInfoCreate(dev);
285 zfScanMgrInit(dev);
286 zfPowerSavingMgrInit(dev);
287
288 #if 0
289 /* Test code */
290 {
291 u32_t key[4] = {0xffffffff, 0xff, 0, 0};
292 u16_t addr[3] = {0x8000, 0x01ab, 0x0000};
293 //zfSetKey(dev, 0, 0, ZM_WEP64, addr, key);
294 //zfSetKey(dev, 0, 0, ZM_AES, addr, key);
295 //zfSetKey(dev, 64, 0, 1, wd->macAddr, key);
296 }
297 #endif
298
299 // WME settings
300 wd->ws.staWmeEnabled = 1; // Enable WME by default
301 #define ZM_UAPSD_Q_SIZE 32 //2^N
302 wd->ap.uapsdQ = zfQueueCreate(dev, ZM_UAPSD_Q_SIZE);
303 zm_assert(wd->ap.uapsdQ != NULL);
304 wd->sta.uapsdQ = zfQueueCreate(dev, ZM_UAPSD_Q_SIZE);
305 zm_assert(wd->sta.uapsdQ != NULL);
306
307 //zfHpInit(dev, wd->frequency);
308
309 /* MAC address */
310 //zfHpSetMacAddress(dev, wd->macAddr, 0);
311 zfHpGetMacAddress(dev);
312
313 zfCoreSetFrequency(dev, wd->frequency);
314
315 #if ZM_PCI_LOOP_BACK == 1
316 zfwWriteReg(dev, ZM_REG_PCI_CONTROL, 6);
317 #endif /* #if ZM_PCI_LOOP_BACK == 1 */
318
319 //zfiWlanSetDot11DMode(dev , 1); // Enable 802.11d
320 //zfiWlanSetDot11HDFSMode(dev , 1); // Enable 802.11h DFS
321 wd->sta.DFSEnable = 1;
322 wd->sta.capability[1] |= ZM_BIT_0;
323
324 //zfiWlanSetFrequency(dev, 5260000, TRUE);
325 //zfiWlanSetAniMode(dev , 1); // Enable ANI
326
327 /* Trgger Rx DMA */
328 zfHpStartRecv(dev);
329
330 zm_debug_msg0("end");
331
332 return 0;
333 }
334
335 /* WLAN hardware will be shutdown and all resource will be release */
336 u16_t zfiWlanClose(zdev_t* dev)
337 {
338 zmw_get_wlan_dev(dev);
339
340 zm_msg0_init(ZM_LV_0, "enter");
341
342 wd->state = ZM_WLAN_STATE_CLOSEDED;
343
344 //zfiWlanDisable(dev, 1);
345 zfWlanReset(dev);
346
347 zfHpStopRecv(dev);
348
349 /* Disable MAC */
350 /* Disable PHY */
351 /* Disable RF */
352
353 zfHpRelease(dev);
354
355 zfQueueDestroy(dev, wd->ap.uapsdQ);
356 zfQueueDestroy(dev, wd->sta.uapsdQ);
357
358 zfBssInfoDestroy(dev);
359
360 #ifdef ZM_ENABLE_AGGREGATION
361 /* add by honda */
362 zfAggRxFreeBuf(dev, 1); //1 for release structure memory
363 /* end of add by honda */
364 #endif
365
366 zm_msg0_init(ZM_LV_0, "exit");
367
368 return 0;
369 }
370
371 void zfGetWrapperSetting(zdev_t* dev)
372 {
373 u8_t bPassive;
374 u16_t vapId = 0;
375
376 zmw_get_wlan_dev(dev);
377
378 zmw_declare_for_critical_section();
379 #if 0
380 if ( (wd->ws.countryIsoName[0] != 0)
381 || (wd->ws.countryIsoName[1] != 0)
382 || (wd->ws.countryIsoName[2] != '\0') )
383 {
384 zfHpGetRegulationTablefromRegionCode(
385 dev,
386 zfHpGetRegionCodeFromIsoName(dev, wd->ws.countryIsoName) );
387 }
388 #endif
389 zmw_enter_critical_section(dev);
390
391 wd->wlanMode = wd->ws.wlanMode;
392
393 /* set channel */
394 if ( wd->ws.frequency )
395 {
396 wd->frequency = wd->ws.frequency;
397 wd->ws.frequency = 0;
398 }
399 else
400 {
401 wd->frequency = zfChGetFirstChannel(dev, &bPassive);
402
403 if ( wd->wlanMode == ZM_MODE_IBSS )
404 {
405 if (wd->ws.adhocMode == ZM_ADHOCBAND_A)
406 {
407 wd->frequency = ZM_CH_A_36;
408 }
409 else
410 {
411 wd->frequency = ZM_CH_G_6;
412 }
413 }
414 }
415 #ifdef ZM_AP_DEBUG
416 /* honda add for debug, 2437 channel 6, 2452 channel 9 */
417 wd->frequency = 2437;
418 /* end of add by honda */
419 #endif
420
421 /* set preamble type */
422 switch (wd->ws.preambleType)
423 {
424 case ZM_PREAMBLE_TYPE_AUTO:
425 case ZM_PREAMBLE_TYPE_SHORT:
426 case ZM_PREAMBLE_TYPE_LONG:
427 wd->preambleType = wd->ws.preambleType;
428 break;
429 default:
430 wd->preambleType = ZM_PREAMBLE_TYPE_SHORT;
431 break;
432 }
433 wd->ws.preambleType = 0;
434
435 if ( wd->wlanMode == ZM_MODE_AP )
436 {
437 vapId = zfwGetVapId(dev);
438
439 if (vapId == 0xffff)
440 {
441 wd->ap.authAlgo[0] = wd->ws.authMode;
442 wd->ap.encryMode[0] = wd->ws.encryMode;
443 }
444 else
445 {
446 wd->ap.authAlgo[vapId + 1] = wd->ws.authMode;
447 wd->ap.encryMode[vapId + 1] = wd->ws.encryMode;
448 }
449 wd->ws.authMode = 0;
450 wd->ws.encryMode = ZM_NO_WEP;
451
452 /* Get beaconInterval from WrapperSetting */
453 if ((wd->ws.beaconInterval >= 20) && (wd->ws.beaconInterval <= 1000))
454 {
455 wd->beaconInterval = wd->ws.beaconInterval;
456 }
457 else
458 {
459 wd->beaconInterval = 100; //100ms
460 }
461
462 if (wd->ws.dtim > 0)
463 {
464 wd->dtim = wd->ws.dtim;
465 }
466 else
467 {
468 wd->dtim = 1;
469 }
470
471 wd->ap.qosMode = wd->ws.apWmeEnabled & 0x1;
472 wd->ap.uapsdEnabled = (wd->ws.apWmeEnabled & 0x2) >> 1;
473 }
474 else
475 {
476 wd->sta.authMode = wd->ws.authMode;
477 wd->sta.currentAuthMode = wd->ws.authMode;
478 wd->sta.wepStatus = wd->ws.wepStatus;
479
480 if ( wd->ws.beaconInterval )
481 {
482 wd->beaconInterval = wd->ws.beaconInterval;
483 }
484 else
485 {
486 wd->beaconInterval = 0x64;
487 }
488
489 if ( wd->wlanMode == ZM_MODE_IBSS )
490 {
491 /* 1. Set default channel 6 (2437MHz) */
492 // wd->frequency = 2437;
493
494 /* 2. Otus support 802.11g Mode */
495 if ((wd->ws.adhocMode == ZM_ADHOCBAND_G) ||
496 (wd->ws.adhocMode == ZM_ADHOCBAND_BG) ||
497 (wd->ws.adhocMode == ZM_ADHOCBAND_ABG) ) {
498 wd->wfc.bIbssGMode = 1;
499 } else {
500 wd->wfc.bIbssGMode = 0;
501 }
502
503 /* 3. set short preamble */
504 //wd->sta.preambleType = ZM_PREAMBLE_TYPE_SHORT ;
505 }
506
507 /* set ATIM window */
508 if ( wd->ws.atimWindow )
509 {
510 wd->sta.atimWindow = wd->ws.atimWindow;
511 }
512 else
513 {
514 //wd->sta.atimWindow = 0x0a;
515 wd->sta.atimWindow = 0;
516 }
517
518 //wd->sta.connectingHiddenAP = 1;//wd->ws.connectingHiddenAP;
519 wd->sta.dropUnencryptedPkts = wd->ws.dropUnencryptedPkts;
520 wd->sta.ibssJoinOnly = wd->ws.ibssJoinOnly;
521
522 if ( wd->ws.bDesiredBssid )
523 {
524 zfMemoryCopy(wd->sta.desiredBssid, wd->ws.desiredBssid, 6);
525 wd->sta.bDesiredBssid = TRUE;
526 wd->ws.bDesiredBssid = FALSE;
527 }
528 else
529 {
530 wd->sta.bDesiredBssid = FALSE;
531 }
532
533 /* check ssid */
534 if ( wd->ws.ssidLen != 0 )
535 {
536 if ( (!zfMemoryIsEqual(wd->ws.ssid, wd->sta.ssid,
537 wd->sta.ssidLen))||
538 (wd->ws.ssidLen != wd->sta.ssidLen)||
539 (wd->sta.authMode == ZM_AUTH_MODE_WPA)||
540 (wd->sta.authMode == ZM_AUTH_MODE_WPAPSK) ||
541 (wd->ws.staWmeQosInfo!= 0) )
542 {
543 /*if u-APSD test(set QosInfo), clear connectByReasso to do association (not reassociation)*/
544 wd->sta.connectByReasso = FALSE;
545 wd->sta.failCntOfReasso = 0;
546 wd->sta.pmkidInfo.bssidCount = 0;
547
548 wd->sta.ssidLen = wd->ws.ssidLen;
549 zfMemoryCopy(wd->sta.ssid, wd->ws.ssid, wd->sta.ssidLen);
550
551 if ( wd->sta.ssidLen < 32 )
552 {
553 wd->sta.ssid[wd->sta.ssidLen] = 0;
554 }
555 }
556 }
557 else
558 { /* ANY BSS */
559 wd->sta.ssid[0] = 0;
560 wd->sta.ssidLen = 0;
561 }
562
563 wd->sta.wmeEnabled = wd->ws.staWmeEnabled;
564 wd->sta.wmeQosInfo = wd->ws.staWmeQosInfo;
565
566 }
567
568 zmw_leave_critical_section(dev);
569 }
570
571 u16_t zfWlanEnable(zdev_t* dev)
572 {
573 u8_t bssid[6] = {0x0, 0x0, 0x0, 0x0, 0x0, 0x0};
574 u16_t i;
575
576 zmw_get_wlan_dev(dev);
577
578 zmw_declare_for_critical_section();
579
580 if ( wd->wlanMode == ZM_MODE_UNKNOWN )
581 {
582 zm_debug_msg0("Unknown Mode...Skip...");
583 return 0;
584 }
585
586 if (wd->wlanMode == ZM_MODE_AP)
587 {
588 u16_t vapId;
589
590 vapId = zfwGetVapId(dev);
591
592 if (vapId == 0xffff)
593 {
594 /* AP mode */
595 zfApInitStaTbl(dev);
596
597 /* AP default parameters */
598 wd->bRate = 0xf;
599 wd->gRate = 0xff;
600 wd->bRateBasic = 0xf;
601 wd->gRateBasic = 0x0;
602 //wd->beaconInterval = 100;
603 wd->ap.apBitmap = 1;
604 wd->ap.beaconCounter = 0;
605 //wd->ap.vapNumber = 1; //mark by ygwei for Vap
606
607 wd->ap.hideSsid[0] = 0;
608 wd->ap.staAgingTimeSec = 10*60;
609 wd->ap.staProbingTimeSec = 60;
610
611 for (i=0; i<ZM_MAX_AP_SUPPORT; i++)
612 {
613 wd->ap.bcmcHead[i] = wd->ap.bcmcTail[i] = 0;
614 }
615
616 //wd->ap.uniHead = wd->ap.uniTail = 0;
617
618 /* load AP parameters */
619 wd->bRateBasic = wd->ws.bRateBasic;
620 wd->gRateBasic = wd->ws.gRateBasic;
621 wd->bgMode = wd->ws.bgMode;
622 if ((wd->ws.ssidLen <= 32) && (wd->ws.ssidLen != 0))
623 {
624 wd->ap.ssidLen[0] = wd->ws.ssidLen;
625 for(i=0; i<wd->ws.ssidLen; i++)
626 {
627 wd->ap.ssid[0][i] = wd->ws.ssid[i];
628 }
629 wd->ws.ssidLen = 0; // Reset Wrapper Variable
630 }
631
632 if (wd->ap.encryMode[0] == 0)
633 {
634 wd->ap.capab[0] = 0x001;
635 }
636 else
637 {
638 wd->ap.capab[0] = 0x011;
639 }
640 /* set Short Slot Time bit if not 11b */
641 if (wd->ap.wlanType[0] != ZM_WLAN_TYPE_PURE_B)
642 {
643 wd->ap.capab[0] |= 0x400;
644 }
645
646 // wd->ap.vapNumber = 1; // mark by ygwei for Vap Test
647 }
648 else
649 {
650 #if 0
651 /* VAP Test Code */
652 wd->ap.apBitmap = 0x3;
653 wd->ap.capab[1] = 0x401;
654 wd->ap.ssidLen[1] = 4;
655 wd->ap.ssid[1][0] = 'v';
656 wd->ap.ssid[1][1] = 'a';
657 wd->ap.ssid[1][2] = 'p';
658 wd->ap.ssid[1][3] = '1';
659 wd->ap.authAlgo[1] = wd->ws.authMode;
660 wd->ap.encryMode[1] = wd->ws.encryMode;
661 wd->ap.vapNumber = 2;
662 #else
663 /* VAP Test Code */
664 wd->ap.apBitmap = 0x1 | (0x01 << (vapId+1));
665
666 if ((wd->ws.ssidLen <= 32) && (wd->ws.ssidLen != 0))
667 {
668 wd->ap.ssidLen[vapId+1] = wd->ws.ssidLen;
669 for(i=0; i<wd->ws.ssidLen; i++)
670 {
671 wd->ap.ssid[vapId+1][i] = wd->ws.ssid[i];
672 }
673 wd->ws.ssidLen = 0; // Reset Wrapper Variable
674 }
675
676 if (wd->ap.encryMode[vapId+1] == 0)
677 {
678 wd->ap.capab[vapId+1] = 0x401;
679 }
680 else
681 {
682 wd->ap.capab[vapId+1] = 0x411;
683 }
684
685 wd->ap.authAlgo[vapId+1] = wd->ws.authMode;
686 wd->ap.encryMode[vapId+1] = wd->ws.encryMode;
687
688 /* Need to be modified when VAP is used */
689 //wd->ap.vapNumber = 2;
690 #endif
691 }
692
693 wd->ap.vapNumber++;
694
695 zfCoreSetFrequency(dev, wd->frequency);
696
697 zfInitMacApMode(dev);
698
699 /* Disable protection mode */
700 zfApSetProtectionMode(dev, 0);
701
702 zfApSendBeacon(dev);
703 } /*if (wd->wlanMode == ZM_MODE_AP) */
704 else
705 {
706 zfScanMgrScanStop(dev, ZM_SCAN_MGR_SCAN_INTERNAL);
707 zfScanMgrScanStop(dev, ZM_SCAN_MGR_SCAN_EXTERNAL);
708
709 zmw_enter_critical_section(dev);
710 wd->sta.oppositeCount = 0; /* reset opposite count */
711 //wd->sta.bAutoReconnect = wd->sta.bAutoReconnectEnabled;
712 //wd->sta.scanWithSSID = 0;
713 zfStaInitOppositeInfo(dev);
714 zmw_leave_critical_section(dev);
715
716 zfStaResetStatus(dev, 0);
717
718 if ( (wd->sta.cmDisallowSsidLength != 0)&&
719 (wd->sta.ssidLen == wd->sta.cmDisallowSsidLength)&&
720 (zfMemoryIsEqual(wd->sta.ssid, wd->sta.cmDisallowSsid,
721 wd->sta.ssidLen)) &&
722 (wd->sta.wepStatus == ZM_ENCRYPTION_TKIP))
723 { /* countermeasures */
724 zm_debug_msg0("countermeasures disallow association");
725
726 }
727 else
728 {
729 switch( wd->wlanMode )
730 {
731 case ZM_MODE_IBSS:
732 /* some registers may be set here */
733 if ( wd->sta.authMode == ZM_AUTH_MODE_WPA2PSK )
734 {
735 zfHpSetApStaMode(dev, ZM_HAL_80211_MODE_IBSS_WPA2PSK);
736 }
737 else
738 {
739 zfHpSetApStaMode(dev, ZM_HAL_80211_MODE_IBSS_GENERAL);
740 }
741
742 zm_msg0_mm(ZM_LV_0, "ZM_MODE_IBSS");
743 zfIbssConnectNetwork(dev);
744 break;
745
746 case ZM_MODE_INFRASTRUCTURE:
747 /* some registers may be set here */
748 zfHpSetApStaMode(dev, ZM_HAL_80211_MODE_STA);
749
750 zfInfraConnectNetwork(dev);
751 break;
752
753 case ZM_MODE_PSEUDO:
754 /* some registers may be set here */
755 zfHpSetApStaMode(dev, ZM_HAL_80211_MODE_STA);
756
757 zfUpdateBssid(dev, bssid);
758 zfCoreSetFrequency(dev, wd->frequency);
759 break;
760
761 default:
762 break;
763 }
764 }
765
766 }
767
768
769 //if ( (wd->wlanMode != ZM_MODE_INFRASTRUCTURE)&&
770 // (wd->wlanMode != ZM_MODE_AP) )
771 if ( wd->wlanMode == ZM_MODE_PSEUDO )
772 {
773 /* Reset Wlan status */
774 zfWlanReset(dev);
775
776 if (wd->zfcbConnectNotify != NULL)
777 {
778 wd->zfcbConnectNotify(dev, ZM_STATUS_MEDIA_CONNECT, wd->sta.bssid);
779 }
780 zfChangeAdapterState(dev, ZM_STA_STATE_CONNECTED);
781 }
782
783
784 if(wd->wlanMode == ZM_MODE_AP)
785 {
786 if (wd->zfcbConnectNotify != NULL)
787 {
788 wd->zfcbConnectNotify(dev, ZM_STATUS_MEDIA_CONNECT, wd->sta.bssid);
789 }
790 //zfChangeAdapterState(dev, ZM_STA_STATE_CONNECTED);
791 }
792
793 // Assign default Tx Rate
794 if ( wd->sta.EnableHT )
795 {
796 u32_t oneTxStreamCap;
797 oneTxStreamCap = (zfHpCapability(dev) & ZM_HP_CAP_11N_ONE_TX_STREAM);
798 if(oneTxStreamCap)
799 wd->CurrentTxRateKbps = 135000;
800 else
801 wd->CurrentTxRateKbps = 270000;
802 wd->CurrentRxRateKbps = 270000;
803 }
804 else
805 {
806 wd->CurrentTxRateKbps = 54000;
807 wd->CurrentRxRateKbps = 54000;
808 }
809
810 wd->state = ZM_WLAN_STATE_ENABLED;
811
812 return 0;
813 }
814
815 /* Enable/disable Wlan operation */
816 u16_t zfiWlanEnable(zdev_t* dev)
817 {
818 u16_t ret;
819
820 zmw_get_wlan_dev(dev);
821
822 zm_msg0_mm(ZM_LV_1, "Enable Wlan");
823
824 zfGetWrapperSetting(dev);
825
826 zfZeroMemory((u8_t*) &wd->trafTally, sizeof(struct zsTrafTally));
827
828 // Reset cmMicFailureCount to 0 for new association request
829 if ( wd->sta.cmMicFailureCount == 1 )
830 {
831 zfTimerCancel(dev, ZM_EVENT_CM_TIMER);
832 wd->sta.cmMicFailureCount = 0;
833 }
834
835 zfFlushVtxq(dev);
836 if ((wd->queueFlushed & 0x10) != 0)
837 {
838 zfHpUsbReset(dev);
839 }
840 ret = zfWlanEnable(dev);
841
842 return ret;
843 }
844 /* Add a flag named ResetKeyCache to show if KeyCache should be cleared.
845 for hostapd in AP mode, if driver receives iwconfig ioctl
846 after setting group key, it shouldn't clear KeyCache. */
847 u16_t zfiWlanDisable(zdev_t* dev, u8_t ResetKeyCache)
848 {
849 u16_t i;
850 u8_t isConnected;
851
852 zmw_get_wlan_dev(dev);
853
854 #ifdef ZM_ENABLE_IBSS_WPA2PSK
855 zmw_declare_for_critical_section();
856 #endif
857 wd->state = ZM_WLAN_STATE_DISABLED;
858
859 zm_msg0_mm(ZM_LV_1, "Disable Wlan");
860
861 if ( wd->wlanMode != ZM_MODE_AP )
862 {
863 isConnected = zfStaIsConnected(dev);
864
865 if ( (wd->wlanMode == ZM_MODE_INFRASTRUCTURE)&&
866 (wd->sta.currentAuthMode != ZM_AUTH_MODE_WPA2) )
867 {
868 /* send deauthentication frame */
869 if (isConnected)
870 {
871 //zfiWlanDeauth(dev, NULL, 0);
872 zfSendMmFrame(dev, ZM_WLAN_FRAME_TYPE_DEAUTH, wd->sta.bssid, 3, 0, 0);
873 //zmw_debug_msg0("send a Deauth frame!");
874 }
875 }
876
877 // Remove all the connected peer stations
878 if ( wd->wlanMode == ZM_MODE_IBSS )
879 {
880 wd->sta.ibssBssIsCreator = 0;
881 zfTimerCancel(dev, ZM_EVENT_IBSS_MONITOR);
882 zfStaIbssMonitoring(dev, 1);
883 }
884
885 #ifdef ZM_ENABLE_IBSS_WPA2PSK
886 zmw_enter_critical_section(dev);
887 wd->sta.ibssWpa2Psk = 0;
888 zmw_leave_critical_section(dev);
889 #endif
890
891 wd->sta.wpaState = ZM_STA_WPA_STATE_INIT;
892
893 /* reset connect timeout counter */
894 wd->sta.connectTimeoutCount = 0;
895
896 /* reset connectState to None */
897 wd->sta.connectState = ZM_STA_CONN_STATE_NONE;
898
899 /* reset leap enable variable */
900 wd->sta.leapEnabled = 0;
901
902 /* Disable the RIFS Status / RIFS-like frame count / RIFS count */
903 if( wd->sta.rifsState == ZM_RIFS_STATE_DETECTED )
904 zfHpDisableRifs(dev);
905 wd->sta.rifsState = ZM_RIFS_STATE_DETECTING;
906 wd->sta.rifsLikeFrameCnt = 0;
907 wd->sta.rifsCount = 0;
908
909 wd->sta.osRxFilter = 0;
910 wd->sta.bSafeMode = 0;
911
912 zfChangeAdapterState(dev, ZM_STA_STATE_DISCONNECT);
913 if (ResetKeyCache)
914 zfHpResetKeyCache(dev);
915
916 if (isConnected)
917 {
918 if (wd->zfcbConnectNotify != NULL)
919 {
920 wd->zfcbConnectNotify(dev, ZM_STATUS_MEDIA_CONNECTION_DISABLED, wd->sta.bssid);
921 }
922 }
923 else
924 {
925 if (wd->zfcbConnectNotify != NULL)
926 {
927 wd->zfcbConnectNotify(dev, ZM_STATUS_MEDIA_DISABLED, wd->sta.bssid);
928 }
929 }
930 }
931 else //if (wd->wlanMode == ZM_MODE_AP)
932 {
933 for (i=0; i<ZM_MAX_STA_SUPPORT; i++)
934 {
935 /* send deauthentication frame */
936 if (wd->ap.staTable[i].valid == 1)
937 {
938 /* Reason : Sending station is leaving */
939 zfSendMmFrame(dev, ZM_WLAN_FRAME_TYPE_DEAUTH,
940 wd->ap.staTable[i].addr, 3, 0, 0);
941 }
942 }
943
944 if (ResetKeyCache)
945 zfHpResetKeyCache(dev);
946
947 wd->ap.vapNumber--;
948 }
949
950 /* stop beacon */
951 zfHpDisableBeacon(dev);
952
953 /* Flush VTxQ and MmQ */
954 zfFlushVtxq(dev);
955 /* Flush AP PS queues */
956 zfApFlushBufferedPsFrame(dev);
957 /* Free buffer in defragment list*/
958 zfAgingDefragList(dev, 1);
959
960 #ifdef ZM_ENABLE_AGGREGATION
961 /* add by honda */
962 zfAggRxFreeBuf(dev, 0); //1 for release structure memory
963 /* end of add by honda */
964 #endif
965
966 // Clear the information for the peer stations of IBSS or AP of Station mode
967 zfZeroMemory((u8_t*)wd->sta.oppositeInfo, sizeof(struct zsOppositeInfo) * ZM_MAX_OPPOSITE_COUNT);
968
969 /* Turn off Software WEP/TKIP */
970 if (wd->sta.SWEncryptEnable != 0)
971 {
972 zm_debug_msg0("Disable software encryption");
973 zfStaDisableSWEncryption(dev);
974 }
975
976 /* Improve WEP/TKIP performace with HT AP, detail information please look bug#32495 */
977 //zfHpSetTTSIFSTime(dev, 0x8);
978
979 return 0;
980 }
981
982 u16_t zfiWlanSuspend(zdev_t* dev)
983 {
984 zmw_get_wlan_dev(dev);
985 zmw_declare_for_critical_section();
986
987 // Change the HAL state to init so that any packet can't be transmitted between
988 // resume & HAL reinit. This would cause the chip hang issue in OTUS.
989 zmw_enter_critical_section(dev);
990 wd->halState = ZM_HAL_STATE_INIT;
991 zmw_leave_critical_section(dev);
992
993 return 0;
994 }
995
996 u16_t zfiWlanResume(zdev_t* dev, u8_t doReconn)
997 {
998 u16_t ret;
999 zmw_get_wlan_dev(dev);
1000 zmw_declare_for_critical_section();
1001
1002 /* Redownload firmware, Reinit MAC,PHY,RF */
1003 zfHpReinit(dev, wd->frequency);
1004
1005 //Set channel according to AP's configuration
1006 zfCoreSetFrequencyExV2(dev, wd->frequency, wd->BandWidth40,
1007 wd->ExtOffset, NULL, 1);
1008
1009 zfHpSetMacAddress(dev, wd->macAddr, 0);
1010
1011 /* Start Rx */
1012 zfHpStartRecv(dev);
1013
1014 zfFlushVtxq(dev);
1015
1016 if ( wd->wlanMode != ZM_MODE_INFRASTRUCTURE &&
1017 wd->wlanMode != ZM_MODE_IBSS )
1018 {
1019 return 1;
1020 }
1021
1022 zm_msg0_mm(ZM_LV_1, "Resume Wlan");
1023 if ( (zfStaIsConnected(dev)) || (zfStaIsConnecting(dev)) )
1024 {
1025 if (doReconn == 1)
1026 {
1027 zm_msg0_mm(ZM_LV_1, "Re-connect...");
1028 zmw_enter_critical_section(dev);
1029 wd->sta.connectByReasso = FALSE;
1030 zmw_leave_critical_section(dev);
1031
1032 zfWlanEnable(dev);
1033 }
1034 else if (doReconn == 0)
1035 {
1036 zfHpSetRollCallTable(dev);
1037 }
1038 }
1039
1040 ret = 0;
1041
1042 return ret;
1043 }
1044
1045 /************************************************************************/
1046 /* */
1047 /* FUNCTION DESCRIPTION zfiWlanFlushAllQueuedBuffers */
1048 /* Flush Virtual TxQ, MmQ, PS frames and defragment list */
1049 /* */
1050 /* INPUTS */
1051 /* dev : device pointer */
1052 /* */
1053 /* OUTPUTS */
1054 /* None */
1055 /* */
1056 /* AUTHOR */
1057 /* Stephen Chen Atheros Communications, INC. 2007.1 */
1058 /* */
1059 /************************************************************************/
1060 void zfiWlanFlushAllQueuedBuffers(zdev_t* dev)
1061 {
1062 /* Flush VTxQ and MmQ */
1063 zfFlushVtxq(dev);
1064 /* Flush AP PS queues */
1065 zfApFlushBufferedPsFrame(dev);
1066 /* Free buffer in defragment list*/
1067 zfAgingDefragList(dev, 1);
1068 }
1069
1070 /* Do WLAN site survey */
1071 u16_t zfiWlanScan(zdev_t* dev)
1072 {
1073 u16_t ret = 1;
1074 zmw_get_wlan_dev(dev);
1075
1076 zm_debug_msg0("");
1077
1078 zmw_declare_for_critical_section();
1079
1080 zmw_enter_critical_section(dev);
1081
1082 if (wd->wlanMode == ZM_MODE_AP)
1083 {
1084 wd->heartBeatNotification |= ZM_BSSID_LIST_SCAN;
1085 wd->sta.scanFrequency = 0;
1086 //wd->sta.pUpdateBssList->bssCount = 0;
1087 ret = 0;
1088 }
1089 else
1090 {
1091 #if 0
1092 if ( !zfStaBlockWlanScan(dev) )
1093 {
1094 zm_debug_msg0("scan request");
1095 //zfTimerSchedule(dev, ZM_EVENT_SCAN, ZM_TICK_ZERO);
1096 ret = 0;
1097 goto start_scan;
1098 }
1099 #else
1100 goto start_scan;
1101 #endif
1102 }
1103
1104 zmw_leave_critical_section(dev);
1105
1106 return ret;
1107
1108 start_scan:
1109 zmw_leave_critical_section(dev);
1110
1111 if(wd->ledStruct.LEDCtrlFlagFromReg & ZM_LED_CTRL_FLAG_ALPHA) // flag for Alpha
1112 wd->ledStruct.LEDCtrlFlag |= ZM_LED_CTRL_FLAG_ALPHA;
1113
1114 ret = zfScanMgrScanStart(dev, ZM_SCAN_MGR_SCAN_EXTERNAL);
1115
1116 zm_debug_msg1("ret = ", ret);
1117
1118 return ret;
1119 }
1120
1121
1122 /* rate */
1123 /* 0 : AUTO */
1124 /* 1 : CCK 1M */
1125 /* 2 : CCK 2M */
1126 /* 3 : CCK 5.5M */
1127 /* 4 : CCK 11M */
1128 /* 5 : OFDM 6M */
1129 /* 6 : OFDM 9M */
1130 /* 7 : OFDM 12M */
1131 /* 8 : OFDM 18M */
1132 /* 9 : OFDM 24M */
1133 /* 10 : OFDM 36M */
1134 /* 11 : OFDM 48M */
1135 /* 12 : OFDM 54M */
1136 /* 13 : MCS 0 */
1137 /* 28 : MCS 15 */
1138 u16_t zcRateToMCS[] =
1139 {0xff, 0, 1, 2, 3, 0xb, 0xf, 0xa, 0xe, 0x9, 0xd, 0x8, 0xc};
1140 u16_t zcRateToMT[] = {0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1};
1141
1142 u16_t zfiWlanSetTxRate(zdev_t* dev, u16_t rate)
1143 { // jhlee HT 0
1144 zmw_get_wlan_dev(dev);
1145
1146 if (rate <=12)
1147 {
1148 wd->txMCS = zcRateToMCS[rate];
1149 wd->txMT = zcRateToMT[rate];
1150 return ZM_SUCCESS;
1151 }
1152 else if ((rate<=28)||(rate==13+32))
1153 {
1154 wd->txMCS = rate - 12 - 1;
1155 wd->txMT = 2;
1156 return ZM_SUCCESS;
1157 }
1158
1159 return ZM_ERR_INVALID_TX_RATE;
1160 }
1161
1162 const u32_t zcRateIdToKbps40M[] =
1163 {
1164 1000, 2000, 5500, 11000, /* 1M, 2M, 5M, 11M , 0 1 2 3*/
1165 6000, 9000, 12000, 18000, /* 6M 9M 12M 18M , 4 5 6 7*/
1166 24000, 36000, 48000, 54000, /* 24M 36M 48M 54M , 8 9 10 11*/
1167 13500, 27000, 40500, 54000, /* MCS0 MCS1 MCS2 MCS3 , 12 13 14 15*/
1168 81000, 108000, 121500, 135000, /* MCS4 MCS5 MCS6 MCS7 , 16 17 18 19*/
1169 27000, 54000, 81000, 108000, /* MCS8 MCS9 MCS10 MCS11 , 20 21 22 23*/
1170 162000, 216000, 243000, 270000, /* MCS12 MCS13 MCS14 MCS15 , 24 25 26 27*/
1171 270000, 300000, 150000 /* MCS14SG, MCS15SG, MCS7SG , 28 29 30*/
1172 };
1173
1174 const u32_t zcRateIdToKbps20M[] =
1175 {
1176 1000, 2000, 5500, 11000, /* 1M, 2M, 5M, 11M , 0 1 2 3*/
1177 6000, 9000, 12000, 18000, /* 6M 9M 12M 18M , 4 5 6 7*/
1178 24000, 36000, 48000, 54000, /* 24M 36M 48M 54M , 8 9 10 11*/
1179 6500, 13000, 19500, 26000, /* MCS0 MCS1 MCS2 MCS3 , 12 13 14 15*/
1180 39000, 52000, 58500, 65000, /* MCS4 MCS5 MCS6 MCS7 , 16 17 18 19*/
1181 13000, 26000, 39000, 52000, /* MCS8 MCS9 MCS10 MCS11 , 20 21 22 23*/
1182 78000, 104000, 117000, 130000, /* MCS12 MCS13 MCS14 MCS15 , 24 25 26 27*/
1183 130000, 144400, 72200 /* MCS14SG, MCS15SG, MSG7SG , 28 29 30*/
1184 };
1185
1186 u32_t zfiWlanQueryTxRate(zdev_t* dev)
1187 {
1188 u8_t rateId = 0xff;
1189 zmw_get_wlan_dev(dev);
1190 zmw_declare_for_critical_section();
1191
1192 /* If Tx rate had not been trained, return maximum Tx rate instead */
1193 if ((wd->wlanMode == ZM_MODE_INFRASTRUCTURE) && (zfStaIsConnected(dev)))
1194 {
1195 zmw_enter_critical_section(dev);
1196 //Not in fixed rate mode
1197 if (wd->txMCS == 0xff)
1198 {
1199 if ((wd->sta.oppositeInfo[0].rcCell.flag & ZM_RC_TRAINED_BIT) == 0)
1200 {
1201 rateId = wd->sta.oppositeInfo[0].rcCell.operationRateSet[wd->sta.oppositeInfo[0].rcCell.operationRateCount-1];
1202 }
1203 else
1204 {
1205 rateId = wd->sta.oppositeInfo[0].rcCell.operationRateSet[wd->sta.oppositeInfo[0].rcCell.currentRateIndex];
1206 }
1207 }
1208 zmw_leave_critical_section(dev);
1209 }
1210 if (rateId != 0xff)
1211 {
1212 if (wd->sta.htCtrlBandwidth)
1213 {
1214 return zcRateIdToKbps40M[rateId];
1215 }
1216 else
1217 {
1218 return zcRateIdToKbps20M[rateId];
1219 }
1220 }
1221 else
1222 {
1223 return wd->CurrentTxRateKbps;
1224 }
1225 }
1226
1227 void zfWlanUpdateRxRate(zdev_t* dev, struct zsAdditionInfo* addInfo)
1228 {
1229 u32_t rxRateKbps;
1230 zmw_get_wlan_dev(dev);
1231 //zm_msg1_mm(ZM_LV_0, "addInfo->Tail.Data.RxMacStatus =", addInfo->Tail.Data.RxMacStatus & 0x03);
1232
1233 /* b5~b4: MPDU indication. */
1234 /* 00: Single MPDU. */
1235 /* 10: First MPDU of A-MPDU. */
1236 /* 11: Middle MPDU of A-MPDU. */
1237 /* 01: Last MPDU of A-MPDU. */
1238 /* Only First MPDU and Single MPDU have PLCP header */
1239 /* First MPDU : (mpduInd & 0x30) == 0x00 */
1240 /* Single MPDU : (mpduInd & 0x30) == 0x20 */
1241 if ((addInfo->Tail.Data.RxMacStatus & 0x10) == 0)
1242 {
1243 /* Modulation type */
1244 wd->modulationType = addInfo->Tail.Data.RxMacStatus & 0x03;
1245 switch(wd->modulationType)
1246 {
1247 case 0x0: wd->rateField = addInfo->PlcpHeader[0] & 0xff; //CCK mode
1248 wd->rxInfo = 0;
1249 break;
1250 case 0x1: wd->rateField = addInfo->PlcpHeader[0] & 0x0f; //Legacy-OFDM mode
1251 wd->rxInfo = 0;
1252 break;
1253 case 0x2: wd->rateField = addInfo->PlcpHeader[3]; //HT-OFDM mode
1254 wd->rxInfo = addInfo->PlcpHeader[6];
1255 break;
1256 default: break;
1257 }
1258
1259 rxRateKbps = zfUpdateRxRate(dev);
1260 if (wd->CurrentRxRateUpdated == 1)
1261 {
1262 if (rxRateKbps > wd->CurrentRxRateKbps)
1263 {
1264 wd->CurrentRxRateKbps = rxRateKbps;
1265 }
1266 }
1267 else
1268 {
1269 wd->CurrentRxRateKbps = rxRateKbps;
1270 wd->CurrentRxRateUpdated = 1;
1271 }
1272 }
1273 }
1274 #if 0
1275 u16_t zcIndextoRateBG[16] = {1000, 2000, 5500, 11000, 0, 0, 0, 0, 48000,
1276 24000, 12000, 6000, 54000, 36000, 18000, 9000};
1277 u32_t zcIndextoRateN20L[16] = {6500, 13000, 19500, 26000, 39000, 52000, 58500,
1278 65000, 13000, 26000, 39000, 52000, 78000, 104000,
1279 117000, 130000};
1280 u32_t zcIndextoRateN20S[16] = {7200, 14400, 21700, 28900, 43300, 57800, 65000,
1281 72200, 14400, 28900, 43300, 57800, 86700, 115600,
1282 130000, 144400};
1283 u32_t zcIndextoRateN40L[16] = {13500, 27000, 40500, 54000, 81000, 108000, 121500,
1284 135000, 27000, 54000, 81000, 108000, 162000, 216000,
1285 243000, 270000};
1286 u32_t zcIndextoRateN40S[16] = {15000, 30000, 45000, 60000, 90000, 120000, 135000,
1287 150000, 30000, 60000, 90000, 120000, 180000, 240000,
1288 270000, 300000};
1289 #endif
1290
1291 extern u16_t zcIndextoRateBG[16];
1292 extern u32_t zcIndextoRateN20L[16];
1293 extern u32_t zcIndextoRateN20S[16];
1294 extern u32_t zcIndextoRateN40L[16];
1295 extern u32_t zcIndextoRateN40S[16];
1296
1297 u32_t zfiWlanQueryRxRate(zdev_t* dev)
1298 {
1299 zmw_get_wlan_dev(dev);
1300
1301 wd->CurrentRxRateUpdated = 0;
1302 return wd->CurrentRxRateKbps;
1303 }
1304
1305 u32_t zfUpdateRxRate(zdev_t* dev)
1306 {
1307 u8_t mcs, bandwidth;
1308 u32_t rxRateKbps = 130000;
1309 zmw_get_wlan_dev(dev);
1310
1311 switch (wd->modulationType)
1312 {
1313 case 0x0: //CCK mode
1314 switch (wd->rateField)
1315 {
1316 case 0x0a: rxRateKbps = 1000;
1317 break;
1318 case 0x14: rxRateKbps = 2000;
1319
1320 case 0x37: rxRateKbps = 5500;
1321 break;
1322 case 0x6e: rxRateKbps = 11000;
1323 break;
1324 default:
1325 break;
1326 }
1327 break;
1328 case 0x1: //Legacy-OFDM mode
1329 if (wd->rateField <= 15)
1330 {
1331 rxRateKbps = zcIndextoRateBG[wd->rateField];
1332 }
1333 break;
1334 case 0x2: //HT-OFDM mode
1335 mcs = wd->rateField & 0x7F;
1336 bandwidth = wd->rateField & 0x80;
1337 if (mcs <= 15)
1338 {
1339 if (bandwidth != 0)
1340 {
1341 if((wd->rxInfo & 0x80) != 0)
1342 {
1343 /* Short GI 40 MHz MIMO Rate */
1344 rxRateKbps = zcIndextoRateN40S[mcs];
1345 }
1346 else
1347 {
1348 /* Long GI 40 MHz MIMO Rate */
1349 rxRateKbps = zcIndextoRateN40L[mcs];
1350 }
1351 }
1352 else
1353 {
1354 if((wd->rxInfo & 0x80) != 0)
1355 {
1356 /* Short GI 20 MHz MIMO Rate */
1357 rxRateKbps = zcIndextoRateN20S[mcs];
1358 }
1359 else
1360 {
1361 /* Long GI 20 MHz MIMO Rate */
1362 rxRateKbps = zcIndextoRateN20L[mcs];
1363 }
1364 }
1365 }
1366 break;
1367 default:
1368 break;
1369 }
1370 //zm_msg1_mm(ZM_LV_0, "wd->CurrentRxRateKbps=", wd->CurrentRxRateKbps);
1371
1372 // ToDo: use bandwith field to define 40MB
1373 return rxRateKbps;
1374 }
1375
1376 /* Get WLAN stastics */
1377 u16_t zfiWlanGetStatistics(zdev_t* dev)
1378 {
1379 /* Return link statistics */
1380 return 0;
1381 }
1382
1383 u16_t zfiWlanReset(zdev_t* dev)
1384 {
1385 zmw_get_wlan_dev(dev);
1386
1387 wd->state = ZM_WLAN_STATE_DISABLED;
1388
1389 return zfWlanReset(dev);
1390 }
1391
1392 /* Reset WLAN */
1393 u16_t zfWlanReset(zdev_t* dev)
1394 {
1395 u8_t isConnected;
1396 zmw_get_wlan_dev(dev);
1397
1398 zmw_declare_for_critical_section();
1399
1400 zm_debug_msg0("zfWlanReset");
1401
1402 isConnected = zfStaIsConnected(dev);
1403
1404 //if ( wd->wlanMode != ZM_MODE_AP )
1405 {
1406 if ( (wd->wlanMode == ZM_MODE_INFRASTRUCTURE)&&
1407 (wd->sta.currentAuthMode != ZM_AUTH_MODE_WPA2) )
1408 {
1409 /* send deauthentication frame */
1410 if (isConnected)
1411 {
1412 //zfiWlanDeauth(dev, NULL, 0);
1413 zfSendMmFrame(dev, ZM_WLAN_FRAME_TYPE_DEAUTH, wd->sta.bssid, 3, 0, 0);
1414 //zmw_debug_msg0("send a Deauth frame!");
1415 }
1416 }
1417 }
1418
1419 zfChangeAdapterState(dev, ZM_STA_STATE_DISCONNECT);
1420 zfHpResetKeyCache(dev);
1421
1422 if (isConnected)
1423 {
1424 //zfiWlanDisable(dev);
1425 if (wd->zfcbConnectNotify != NULL)
1426 {
1427 wd->zfcbConnectNotify(dev, ZM_STATUS_MEDIA_CONNECTION_RESET, wd->sta.bssid);
1428 }
1429 }
1430 else
1431 {
1432 if (wd->zfcbConnectNotify != NULL)
1433 {
1434 wd->zfcbConnectNotify(dev, ZM_STATUS_MEDIA_RESET, wd->sta.bssid);
1435 }
1436 }
1437
1438 /* stop beacon */
1439 zfHpDisableBeacon(dev);
1440
1441 /* Free buffer in defragment list*/
1442 zfAgingDefragList(dev, 1);
1443
1444 /* Flush VTxQ and MmQ */
1445 zfFlushVtxq(dev);
1446
1447 #ifdef ZM_ENABLE_AGGREGATION
1448 /* add by honda */
1449 zfAggRxFreeBuf(dev, 0); //1 for release structure memory
1450 /* end of add by honda */
1451 #endif
1452
1453 zfStaRefreshBlockList(dev, 1);
1454
1455 zmw_enter_critical_section(dev);
1456
1457 zfTimerCancel(dev, ZM_EVENT_IBSS_MONITOR);
1458 zfTimerCancel(dev, ZM_EVENT_CM_BLOCK_TIMER);
1459 zfTimerCancel(dev, ZM_EVENT_CM_DISCONNECT);
1460
1461 wd->sta.connectState = ZM_STA_CONN_STATE_NONE;
1462 wd->sta.connectByReasso = FALSE;
1463 wd->sta.cmDisallowSsidLength = 0;
1464 wd->sta.bAutoReconnect = 0;
1465 wd->sta.InternalScanReq = 0;
1466 wd->sta.encryMode = ZM_NO_WEP;
1467 wd->sta.wepStatus = ZM_ENCRYPTION_WEP_DISABLED;
1468 wd->sta.wpaState = ZM_STA_WPA_STATE_INIT;
1469 wd->sta.cmMicFailureCount = 0;
1470 wd->sta.ibssBssIsCreator = 0;
1471 #ifdef ZM_ENABLE_IBSS_WPA2PSK
1472 wd->sta.ibssWpa2Psk = 0;
1473 #endif
1474 /* reset connect timeout counter */
1475 wd->sta.connectTimeoutCount = 0;
1476
1477 /* reset leap enable variable */
1478 wd->sta.leapEnabled = 0;
1479
1480 /* Reset the RIFS Status / RIFS-like frame count / RIFS count */
1481 if( wd->sta.rifsState == ZM_RIFS_STATE_DETECTED )
1482 zfHpDisableRifs(dev);
1483 wd->sta.rifsState = ZM_RIFS_STATE_DETECTING;
1484 wd->sta.rifsLikeFrameCnt = 0;
1485 wd->sta.rifsCount = 0;
1486
1487 wd->sta.osRxFilter = 0;
1488 wd->sta.bSafeMode = 0;
1489
1490 // Clear the information for the peer stations of IBSS or AP of Station mode
1491 zfZeroMemory((u8_t*)wd->sta.oppositeInfo, sizeof(struct zsOppositeInfo) * ZM_MAX_OPPOSITE_COUNT);
1492
1493 zmw_leave_critical_section(dev);
1494
1495 zfScanMgrScanStop(dev, ZM_SCAN_MGR_SCAN_INTERNAL);
1496 zfScanMgrScanStop(dev, ZM_SCAN_MGR_SCAN_EXTERNAL);
1497
1498 /* Turn off Software WEP/TKIP */
1499 if (wd->sta.SWEncryptEnable != 0)
1500 {
1501 zm_debug_msg0("Disable software encryption");
1502 zfStaDisableSWEncryption(dev);
1503 }
1504
1505 /* Improve WEP/TKIP performace with HT AP, detail information please look bug#32495 */
1506 //zfHpSetTTSIFSTime(dev, 0x8);
1507
1508 /* Keep Pseudo mode */
1509 if ( wd->wlanMode != ZM_MODE_PSEUDO )
1510 {
1511 wd->wlanMode = ZM_MODE_INFRASTRUCTURE;
1512 }
1513 return 0;
1514 }
1515
1516 /* Deauthenticate a STA */
1517 u16_t zfiWlanDeauth(zdev_t* dev, u16_t* macAddr, u16_t reason)
1518 {
1519 zmw_get_wlan_dev(dev);
1520
1521 if ( wd->wlanMode == ZM_MODE_AP )
1522 {
1523 //u16_t id;
1524
1525 /*
1526 * we will reset all key in zfHpResetKeyCache() when call
1527 * zfiWlanDisable(), if we want to reset PairwiseKey for each sta,
1528 * need to use a nullAddr to let keyindex not match.
1529 * otherwise hardware will still find PairwiseKey when AP change
1530 * encryption mode from WPA to WEP
1531 */
1532
1533 /*
1534 if ((id = zfApFindSta(dev, macAddr)) != 0xffff)
1535 {
1536 u32_t key[8];
1537 u16_t nullAddr[3] = { 0x0, 0x0, 0x0 };
1538
1539 if (wd->ap.staTable[i].encryMode != ZM_NO_WEP)
1540 {
1541 zfHpSetApPairwiseKey(dev, nullAddr,
1542 ZM_NO_WEP, &key[0], &key[4], i+1);
1543 }
1544 //zfHpSetApPairwiseKey(dev, (u16_t *)macAddr,
1545 // ZM_NO_WEP, &key[0], &key[4], id+1);
1546 wd->ap.staTable[id].encryMode = ZM_NO_WEP;
1547 wd->ap.staTable[id].keyIdx = 0xff;
1548 }
1549 */
1550
1551 zfSendMmFrame(dev, ZM_WLAN_FRAME_TYPE_DEAUTH, macAddr, reason, 0, 0);
1552 }
1553 else
1554 {
1555 zfSendMmFrame(dev, ZM_WLAN_FRAME_TYPE_DEAUTH, wd->sta.bssid, 3, 0, 0);
1556 }
1557
1558 /* Issue DEAUTH command to FW */
1559 return 0;
1560 }
1561
1562
1563 /* XP packet filter feature : */
1564 /* 1=>enable: All multicast address packets, not just the ones enumerated in the multicast address list. */
1565 /* 0=>disable */
1566 void zfiWlanSetAllMulticast(zdev_t* dev, u32_t setting)
1567 {
1568 zmw_get_wlan_dev(dev);
1569 zm_msg1_mm(ZM_LV_0, "sta.bAllMulticast = ", setting);
1570 wd->sta.bAllMulticast = (u8_t)setting;
1571 }
1572
1573
1574 /* HT configure API */
1575 void zfiWlanSetHTCtrl(zdev_t* dev, u32_t *setting, u32_t forceTxTPC)
1576 {
1577 zmw_get_wlan_dev(dev);
1578
1579 wd->preambleType = (u8_t)setting[0];
1580 wd->sta.preambleTypeHT = (u8_t)setting[1];
1581 wd->sta.htCtrlBandwidth = (u8_t)setting[2];
1582 wd->sta.htCtrlSTBC = (u8_t)setting[3];
1583 wd->sta.htCtrlSG = (u8_t)setting[4];
1584 wd->sta.defaultTA = (u8_t)setting[5];
1585 wd->enableAggregation = (u8_t)setting[6];
1586 wd->enableWDS = (u8_t)setting[7];
1587
1588 wd->forceTxTPC = forceTxTPC;
1589 }
1590
1591 /* FB50 in OS XP, RD private test code */
1592 void zfiWlanQueryHTCtrl(zdev_t* dev, u32_t *setting, u32_t *forceTxTPC)
1593 {
1594 zmw_get_wlan_dev(dev);
1595
1596 setting[0] = wd->preambleType;
1597 setting[1] = wd->sta.preambleTypeHT;
1598 setting[2] = wd->sta.htCtrlBandwidth;
1599 setting[3] = wd->sta.htCtrlSTBC;
1600 setting[4] = wd->sta.htCtrlSG;
1601 setting[5] = wd->sta.defaultTA;
1602 setting[6] = wd->enableAggregation;
1603 setting[7] = wd->enableWDS;
1604
1605 *forceTxTPC = wd->forceTxTPC;
1606 }
1607
1608 void zfiWlanDbg(zdev_t* dev, u8_t setting)
1609 {
1610 zmw_get_wlan_dev(dev);
1611
1612 wd->enableHALDbgInfo = setting;
1613 }
1614
1615 /* FB50 in OS XP, RD private test code */
1616 void zfiWlanSetRxPacketDump(zdev_t* dev, u32_t setting)
1617 {
1618 zmw_get_wlan_dev(dev);
1619 if (setting)
1620 {
1621 wd->rxPacketDump = 1; /* enable */
1622 }
1623 else
1624 {
1625 wd->rxPacketDump = 0; /* disable */
1626 }
1627 }
1628
1629
1630 /* FB50 in OS XP, RD private test code */
1631 /* Tally */
1632 void zfiWlanResetTally(zdev_t* dev)
1633 {
1634 zmw_get_wlan_dev(dev);
1635
1636 zmw_declare_for_critical_section();
1637
1638 zmw_enter_critical_section(dev);
1639
1640 wd->commTally.txUnicastFrm = 0; //txUnicastFrames
1641 wd->commTally.txMulticastFrm = 0; //txMulticastFrames
1642 wd->commTally.txUnicastOctets = 0; //txUniOctets byte size
1643 wd->commTally.txMulticastOctets = 0; //txMultiOctets byte size
1644 wd->commTally.txFrmUpperNDIS = 0;
1645 wd->commTally.txFrmDrvMgt = 0;
1646 wd->commTally.RetryFailCnt = 0;
1647 wd->commTally.Hw_TotalTxFrm = 0; //Hardware total Tx Frame
1648 wd->commTally.Hw_RetryCnt = 0; //txMultipleRetriesFrames
1649 wd->commTally.Hw_UnderrunCnt = 0;//
1650 wd->commTally.DriverRxFrmCnt = 0;//
1651 wd->commTally.rxUnicastFrm = 0; //rxUnicastFrames
1652 wd->commTally.rxMulticastFrm = 0; //rxMulticastFrames
1653 wd->commTally.NotifyNDISRxFrmCnt = 0;//
1654 wd->commTally.rxUnicastOctets = 0; //rxUniOctets byte size
1655 wd->commTally.rxMulticastOctets = 0; //rxMultiOctets byte size
1656 wd->commTally.DriverDiscardedFrm = 0;// Discard by ValidateFrame
1657 wd->commTally.LessThanDataMinLen = 0;//
1658 wd->commTally.GreaterThanMaxLen = 0;//
1659 wd->commTally.DriverDiscardedFrmCauseByMulticastList = 0;
1660 wd->commTally.DriverDiscardedFrmCauseByFrmCtrl = 0;
1661 wd->commTally.rxNeedFrgFrm = 0; // need more frg frm
1662 wd->commTally.DriverRxMgtFrmCnt = 0;
1663 wd->commTally.rxBroadcastFrm = 0; //Receive broadcast frame count
1664 wd->commTally.rxBroadcastOctets = 0; //Receive broadcast frame byte size
1665 wd->commTally.Hw_TotalRxFrm = 0;//
1666 wd->commTally.Hw_CRC16Cnt = 0; //rxPLCPCRCErrCnt
1667 wd->commTally.Hw_CRC32Cnt = 0; //rxCRC32ErrCnt
1668 wd->commTally.Hw_DecrypErr_UNI = 0;//
1669 wd->commTally.Hw_DecrypErr_Mul = 0;//
1670 wd->commTally.Hw_RxFIFOOverrun = 0;//
1671 wd->commTally.Hw_RxTimeOut = 0;
1672 wd->commTally.LossAP = 0;//
1673
1674 wd->commTally.Tx_MPDU = 0;
1675 wd->commTally.BA_Fail = 0;
1676 wd->commTally.Hw_Tx_AMPDU = 0;
1677 wd->commTally.Hw_Tx_MPDU = 0;
1678
1679 wd->commTally.txQosDropCount[0] = 0;
1680 wd->commTally.txQosDropCount[1] = 0;
1681 wd->commTally.txQosDropCount[2] = 0;
1682 wd->commTally.txQosDropCount[3] = 0;
1683 wd->commTally.txQosDropCount[4] = 0;
1684
1685 wd->commTally.Hw_RxMPDU = 0;
1686 wd->commTally.Hw_RxDropMPDU = 0;
1687 wd->commTally.Hw_RxDelMPDU = 0;
1688
1689 wd->commTally.Hw_RxPhyMiscError = 0;
1690 wd->commTally.Hw_RxPhyXRError = 0;
1691 wd->commTally.Hw_RxPhyOFDMError = 0;
1692 wd->commTally.Hw_RxPhyCCKError = 0;
1693 wd->commTally.Hw_RxPhyHTError = 0;
1694 wd->commTally.Hw_RxPhyTotalCount = 0;
1695
1696 #if (defined(GCCK) && defined(OFDM))
1697 wd->commTally.rx11bDataFrame = 0;
1698 wd->commTally.rxOFDMDataFrame = 0;
1699 #endif
1700
1701 zmw_leave_critical_section(dev);
1702 }
1703
1704 /* FB50 in OS XP, RD private test code */
1705 void zfiWlanQueryTally(zdev_t* dev, struct zsCommTally *tally)
1706 {
1707 zmw_get_wlan_dev(dev);
1708
1709 zmw_declare_for_critical_section();
1710
1711 zmw_enter_critical_section(dev);
1712 zfMemoryCopy((u8_t*)tally, (u8_t*)&wd->commTally, sizeof(struct zsCommTally));
1713 zmw_leave_critical_section(dev);
1714 }
1715 void zfiWlanQueryTrafTally(zdev_t* dev, struct zsTrafTally *tally)
1716 {
1717 zmw_get_wlan_dev(dev);
1718
1719 zmw_declare_for_critical_section();
1720
1721 zmw_enter_critical_section(dev);
1722 zfMemoryCopy((u8_t*)tally, (u8_t*)&wd->trafTally, sizeof(struct zsTrafTally));
1723 zmw_leave_critical_section(dev);
1724 }
1725
1726 void zfiWlanQueryMonHalRxInfo(zdev_t* dev, struct zsMonHalRxInfo *monHalRxInfo)
1727 {
1728 zfHpQueryMonHalRxInfo(dev, (u8_t *)monHalRxInfo);
1729 }
1730
1731 /* parse the modeMDKEnable to DrvCore */
1732 void zfiDKEnable(zdev_t* dev, u32_t enable)
1733 {
1734 zmw_get_wlan_dev(dev);
1735
1736 wd->modeMDKEnable = enable;
1737 zm_debug_msg1("modeMDKEnable = ", wd->modeMDKEnable);
1738 }
1739
1740 /* airoPeek */
1741 u32_t zfiWlanQueryPacketTypePromiscuous(zdev_t* dev)
1742 {
1743 zmw_get_wlan_dev(dev);
1744
1745 return wd->swSniffer;
1746 }
1747
1748 /* airoPeek */
1749 void zfiWlanSetPacketTypePromiscuous(zdev_t* dev, u32_t setValue)
1750 {
1751 zmw_get_wlan_dev(dev);
1752
1753 wd->swSniffer = setValue;
1754 zm_msg1_mm(ZM_LV_0, "wd->swSniffer ", wd->swSniffer);
1755 if (setValue)
1756 {
1757 /* write register for sniffer mode */
1758 zfHpSetSnifferMode(dev, 1);
1759 zm_msg0_mm(ZM_LV_1, "enalbe sniffer mode");
1760 }
1761 else
1762 {
1763 zfHpSetSnifferMode(dev, 0);
1764 zm_msg0_mm(ZM_LV_0, "disalbe sniffer mode");
1765 }
1766 }
1767
1768 void zfiWlanSetXLinkMode(zdev_t* dev, u32_t setValue)
1769 {
1770 zmw_get_wlan_dev(dev);
1771
1772 wd->XLinkMode = setValue;
1773 if (setValue)
1774 {
1775 /* write register for sniffer mode */
1776 zfHpSetSnifferMode(dev, 1);
1777 }
1778 else
1779 {
1780 zfHpSetSnifferMode(dev, 0);
1781 }
1782 }
1783
1784 extern void zfStaChannelManagement(zdev_t* dev, u8_t scan);
1785 void zfiSetChannelManagement(zdev_t* dev, u32_t setting)
1786 {
1787 zmw_get_wlan_dev(dev);
1788
1789 switch (setting)
1790 {
1791 case 1:
1792 wd->sta.EnableHT = 1;
1793 wd->BandWidth40 = 1;
1794 wd->ExtOffset = 1;
1795 break;
1796 case 3:
1797 wd->sta.EnableHT = 1;
1798 wd->BandWidth40 = 1;
1799 wd->ExtOffset = 3;
1800 break;
1801 case 0:
1802 wd->sta.EnableHT = 1;
1803 wd->BandWidth40 = 0;
1804 wd->ExtOffset = 0;
1805 break;
1806 default:
1807 wd->BandWidth40 = 0;
1808 wd->ExtOffset = 0;
1809 break;
1810
1811 }
1812 zfCoreSetFrequencyEx(dev, wd->frequency, wd->BandWidth40,
1813 wd->ExtOffset, NULL);
1814 }
1815
1816 void zfiSetRifs(zdev_t* dev, u16_t setting)
1817 {
1818 zmw_get_wlan_dev(dev);
1819
1820 wd->sta.ie.HtInfo.ChannelInfo |= ExtHtCap_RIFSMode;
1821 wd->sta.EnableHT = 1;
1822 switch (setting)
1823 {
1824 case 0:
1825 wd->sta.HT2040 = 0;
1826 // zfHpSetRifs(dev, 1, 0, (wd->sta.currentFrequency < 3000)? 1:0);
1827 break;
1828 case 1:
1829 wd->sta.HT2040 = 1;
1830 // zfHpSetRifs(dev, 1, 1, (wd->sta.currentFrequency < 3000)? 1:0);
1831 break;
1832 default:
1833 wd->sta.HT2040 = 0;
1834 // zfHpSetRifs(dev, 1, 0, (wd->sta.currentFrequency < 3000)? 1:0);
1835 break;
1836 }
1837 }
1838
1839 void zfiCheckRifs(zdev_t* dev)
1840 {
1841 zmw_get_wlan_dev(dev);
1842
1843 if(wd->sta.ie.HtInfo.ChannelInfo & ExtHtCap_RIFSMode)
1844 {
1845 // zfHpSetRifs(dev, wd->sta.EnableHT, wd->sta.HT2040, (wd->sta.currentFrequency < 3000)? 1:0);
1846 }
1847 }
1848
1849 void zfiSetReorder(zdev_t* dev, u16_t value)
1850 {
1851 zmw_get_wlan_dev(dev);
1852
1853 wd->reorder = value;
1854 }
1855
1856 void zfiSetSeqDebug(zdev_t* dev, u16_t value)
1857 {
1858 zmw_get_wlan_dev(dev);
1859
1860 wd->seq_debug = value;
1861 }
Nao low-level kernelspace/userspace library that runs on our robots, Nao-Team HTWK