?  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 / cinit.c
blob5f853ce79309888aad498cdf4b85f1649690aeab
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 : init.c */
18 /* */
19 /* Abstract */
20 /* This module contains init functions. */
21 /* */
22 /* NOTES */
23 /* None */
24 /* */
25 /************************************************************************/
26 #include "cprecomp.h"
27 #include "../hal/hpreg.h"
28
29 extern const u8_t zcUpToAc[8];
30
31 u16_t zcIndextoRateBG[16] = {1000, 2000, 5500, 11000, 0, 0, 0, 0, 48000,
32 24000, 12000, 6000, 54000, 36000, 18000, 9000};
33 u32_t zcIndextoRateN20L[16] = {6500, 13000, 19500, 26000, 39000, 52000, 58500,
34 65000, 13000, 26000, 39000, 52000, 78000, 104000,
35 117000, 130000};
36 u32_t zcIndextoRateN20S[16] = {7200, 14400, 21700, 28900, 43300, 57800, 65000,
37 72200, 14400, 28900, 43300, 57800, 86700, 115600,
38 130000, 144400};
39 u32_t zcIndextoRateN40L[16] = {13500, 27000, 40500, 54000, 81000, 108000, 121500,
40 135000, 27000, 54000, 81000, 108000, 162000, 216000,
41 243000, 270000};
42 u32_t zcIndextoRateN40S[16] = {15000, 30000, 45000, 60000, 90000, 120000, 135000,
43 150000, 30000, 60000, 90000, 120000, 180000, 240000,
44 270000, 300000};
45
46 /************************************************************************/
47 /* */
48 /* FUNCTION DESCRIPTION zfTxGenWlanHeader */
49 /* Generate WLAN MAC header and LLC header. */
50 /* */
51 /* INPUTS */
52 /* dev : device pointer */
53 /* buf : buffer pointer */
54 /* id : Index of TxD */
55 /* port : WLAN port */
56 /* */
57 /* OUTPUTS */
58 /* length of removed Ethernet header */
59 /* */
60 /* AUTHOR */
61 /* Stephen ZyDAS Technology Corporation 2005.5 */
62 /* */
63 /************************************************************************/
64 u16_t zfTxGenWlanHeader(zdev_t* dev, zbuf_t* buf, u16_t* header, u16_t seq,
65 u8_t flag, u16_t plusLen, u16_t minusLen, u16_t port,
66 u16_t* da, u16_t* sa, u8_t up, u16_t *micLen,
67 u16_t* snap, u16_t snapLen, struct aggControl *aggControl)
68 {
69
70 u16_t len;
71 u16_t macCtrl;
72 u32_t phyCtrl;
73 u16_t hlen = 16;
74 u16_t icvLen = 0;
75 u16_t wdsPortId;
76 u16_t vap = 0;
77 u16_t mcs = 0;
78 u16_t mt = 0;
79 u8_t qosType;
80 u8_t b1, b2;
81 u16_t wdsPort;
82 u8_t encExemptionActionType;
83 u16_t rateProbingFlag = 0;
84 u8_t tkipFrameOffset = 0;
85
86 #ifdef ZM_ENABLE_IBSS_WPA2PSK
87 u8_t res, peerIdx;
88 u8_t userIdx=0;
89 u16_t *iv16;
90 u32_t *iv32;
91 #endif
92
93 zmw_get_wlan_dev(dev);
94
95 /* Generate WLAN header */
96 /* Frame control */
97 header[4] = 0x0008 | (flag<<8);
98 /* Duration */
99 header[5] = 0x0000;
100
101 if (wd->wlanMode == ZM_MODE_INFRASTRUCTURE)
102 {
103 /* ToDS bit */
104 header[4] |= 0x0100;
105
106 /*Sometimes we wake up to tx/rx but AP still think we are sleeping, so still need to set this bit*/
107 if ( zfPowerSavingMgrIsSleeping(dev) || wd->sta.psMgr.tempWakeUp == 1 )
108 {
109 header[4] |= 0x1000;
110 }
111
112 /* Address 1 = BSSID */
113 header[6] = wd->sta.bssid[0];
114 header[7] = wd->sta.bssid[1];
115 header[8] = wd->sta.bssid[2];
116 /* Address 3 = DA */
117 header[12] = da[0];
118 header[13] = da[1];
119 header[14] = da[2];
120 }
121 else if (wd->wlanMode == ZM_MODE_PSEUDO)
122 {
123 /* Address 1 = DA */
124 header[6] = da[0];
125 header[7] = da[1];
126 header[8] = da[2];
127 /* Address 3 = 00:00:00:00:00:00 */
128 header[12] = 0;
129 header[13] = 0;
130 header[14] = 0;
131
132 /* PSEUDO test : WDS */
133 if (wd->enableWDS)
134 {
135 /* ToDS and FromDS bit */
136 header[4] |= 0x0300;
137
138 /* Address 4 = SA */
139 header[16] = 0;
140 header[17] = 0;
141 header[18] = 0;
142
143 hlen = 19;
144 }
145 }
146 else if (wd->wlanMode == ZM_MODE_IBSS)
147 {
148 /* Address 1 = DA */
149 header[6] = da[0];
150 header[7] = da[1];
151 header[8] = da[2];
152 /* Address 3 = BSSID */
153 header[12] = wd->sta.bssid[0];
154 header[13] = wd->sta.bssid[1];
155 header[14] = wd->sta.bssid[2];
156
157 #ifdef ZM_ENABLE_IBSS_WPA2PSK
158 zmw_enter_critical_section(dev);
159 res = zfStaFindOppositeByMACAddr(dev, da, &peerIdx);
160 if(res == 0) // Find opposite in our OppositeInfo Structure !
161 {
162 userIdx = peerIdx;
163 }
164 zmw_leave_critical_section(dev);
165 #endif
166 }
167 else if (wd->wlanMode == ZM_MODE_AP)
168 {
169 if (port < 0x20)
170 /* AP mode */
171 {
172 /* FromDS bit */
173 header[4] |= 0x0200;
174
175 /* Address 1 = DA */
176 header[6] = da[0];
177 header[7] = da[1];
178 header[8] = da[2];
179 /* Address 3 = SA */
180 header[12] = sa[0];
181 header[13] = sa[1];
182 header[14] = sa[2];
183
184 if (port < ZM_MAX_AP_SUPPORT)
185 {
186 vap = port;
187 header[14] += (vap<<8);
188 }
189 }
190 else
191 /* WDS port */
192 {
193 /* ToDS and FromDS bit */
194 header[4] |= 0x0300;
195
196 wdsPortId = port - 0x20;
197
198 /* Address 1 = RA */
199 header[6] = wd->ap.wds.macAddr[wdsPortId][0];
200 header[7] = wd->ap.wds.macAddr[wdsPortId][1];
201 header[8] = wd->ap.wds.macAddr[wdsPortId][2];
202 /* Address 3 = DA */
203 header[12] = da[0];
204 header[13] = da[1];
205 header[14] = da[2];
206 /* Address 4 = SA */
207 header[16] = sa[0];
208 header[17] = sa[1];
209 header[18] = sa[2];
210
211 hlen = 19;
212 }
213 } /* else if (wd->wlanMode == ZM_MODE_AP) */
214
215 /* Address 2 = TA */
216 header[9] = wd->macAddr[0];
217 header[10] = wd->macAddr[1];
218 #ifdef ZM_VAPMODE_MULTILE_SSID
219 header[11] = wd->macAddr[2]; //Multiple SSID
220 #else
221 header[11] = wd->macAddr[2] + (vap<<8); //VAP
222 #endif
223
224 if ( (wd->wlanMode == ZM_MODE_IBSS) && (wd->XLinkMode) )
225 {
226 header[9] = sa[0];
227 header[10] = sa[1];
228 header[11] = sa[2];
229 }
230
231 /* Sequence Control */
232 header[15] = seq;
233
234
235 if (wd->wlanMode == ZM_MODE_AP)
236 {
237 zfApGetStaTxRateAndQosType(dev, da, &phyCtrl, &qosType, &rateProbingFlag);
238 mt = (u16_t)(phyCtrl & 0x3);
239 mcs = (u16_t)((phyCtrl >> 16) & 0x3f);
240 #if 1
241 //zfApGetStaQosType(dev, da, &qosType);
242
243 /* if DA == WME STA */
244 if (qosType == 1)
245 {
246 /* QoS data */
247 header[4] |= 0x0080;
248
249 /* QoS Control */
250 header[hlen] = up;
251 hlen += 1;
252 }
253 #endif
254 }
255
256 #if 0
257 //AGG Test Code
258 if (header[6] == 0x8000)
259 {
260 /* QoS data */
261 header[4] |= 0x0080;
262
263 /* QoS Control */
264 header[hlen] = 0;
265 hlen += 1;
266 }
267 #endif
268
269 if (wd->wlanMode == ZM_MODE_AP) {
270 /* Todo: rate control here for qos field */
271 }
272 else {
273 /* Rate control */
274 zfStaGetTxRate(dev, da, &phyCtrl, &rateProbingFlag);
275 mt = (u16_t)(phyCtrl & 0x3);
276 mcs = (u16_t)((phyCtrl >> 16) & 0x3f);
277 }
278
279 if (wd->txMCS != 0xff)
280 {
281 /* fixed rate */
282 phyCtrl = ((u32_t)wd->txMCS<<16) + wd->txMT;
283 mcs = wd->txMCS;
284 mt = wd->txMT;
285 }
286
287 if (wd->enableAggregation)
288 {
289 /* force enable aggregation */
290 if (wd->enableAggregation==2 && !(header[6]&0x1))
291 {
292 /* QoS data */
293 header[4] |= 0x0080;
294
295 /* QoS Control */
296 header[hlen] = 0;
297 hlen += 1;
298 }
299 /* if wd->enableAggregation=1 => force disable */
300 /* if wd->enableAggregation=0 => auto */
301 }
302
303 #ifdef ZM_ENABLE_AGGREGATION
304 /*
305 * aggregation control
306 */
307
308 /*
309 * QoS data
310 */
311 if (wd->wlanMode == ZM_MODE_AP) {
312 if (aggControl && mt == 2) {
313 if (wd->enableAggregation==0 && !(header[6]&0x1))
314 {
315 header[4] |= 0x0080;
316
317 /*
318 * QoS Control
319 */
320 header[hlen] = 0;
321 hlen += 1;
322 }
323 }
324 }
325 #endif
326
327 // MSDU Length
328 len = zfwBufGetSize(dev, buf);
329
330 /* Generate control setting */
331 /* Backoff, Non-Burst and hardware duration */
332 macCtrl = 0x208;
333
334 /* ACK */
335 if ((header[6] & 0x1) == 0x1)
336 {
337 /* multicast frame : Set NO-ACK bit */
338 macCtrl |= 0x4;
339 }
340 else
341 {
342 /* unicast frame */
343 #if 0
344 // Enable RTS according to MPDU Lengths ( not MSDU Lengths )
345 if (len >= wd->rtsThreshold)
346 {
347 /* Enable RTS */
348 macCtrl |= 1;
349 }
350 #endif
351 }
352 /* VAP test code */
353 //macCtrl |= 0x4;
354
355 if (wd->wlanMode == ZM_MODE_AP)
356 {
357 u8_t encryType;
358 u16_t iv16;
359 u32_t iv32;
360
361 /* Check whether this is a multicast frame */
362 if ((header[6] & 0x1) == 0x1)
363 {
364 /* multicast frame */
365 if (wd->ap.encryMode[vap] == ZM_TKIP)
366 {
367 wd->ap.iv16[vap]++;
368
369 if(wd->ap.iv16[vap] == 0)
370 {
371 wd->ap.iv32[vap]++;
372 }
373
374 b1 = (u8_t) (wd->ap.iv16[vap] >> 8);
375 b2 = (b1 | 0x20) & 0x7f;
376 header[hlen] = ((u16_t)b2 << 8) + b1;
377 b1 = (u8_t) wd->ap.iv16[vap];
378 b2 = 0x20 | (wd->ap.bcKeyIndex[vap] << 6);
379 header[hlen+1] = ((u16_t)b2 << 8) + b1;
380 header[hlen+2] = (u16_t) wd->ap.iv32[vap];
381 header[hlen+3] = (u16_t) (wd->ap.iv32[vap] >> 16);
382
383 //macCtrl |= 0x80;
384 macCtrl |= 0x40;
385 icvLen = 4;
386
387 /* set hardware MIC */
388 if ( (!(seq & 0xf))&&(!(flag & 0x4)) )
389 {
390 macCtrl |= 0x100;
391 plusLen += 8;
392 *micLen = 8;
393 }
394
395 header[4] |= 0x4000;
396 hlen += 4;
397 }
398 else if (wd->ap.encryMode[vap] == ZM_AES)
399 {
400 wd->ap.iv16[vap]++;
401
402 if(wd->ap.iv16[vap] == 0)
403 {
404 wd->ap.iv32[vap]++;
405 }
406
407 b1 = (u8_t) wd->ap.iv16[vap];
408 b2 = (u8_t) (wd->ap.iv16[vap] >> 8);
409 header[hlen] = ((u16_t)b2 << 8) + b1;
410 header[hlen+1] = 0x2000 | (wd->ap.bcKeyIndex[vap] << 14);
411 header[hlen+2] = (u16_t) (wd->ap.iv32[vap]);
412 header[hlen+3] = (u16_t) (wd->ap.iv32[vap] >> 16);
413
414 macCtrl |= 0xc0;
415 icvLen = 8; /* MIC */
416
417 header[4] |= 0x4000;
418 hlen += 4;
419 }
420 #ifdef ZM_ENABLE_CENC
421 else if (wd->ap.encryMode[vap] == ZM_CENC)
422 {
423 //u32_t txiv[4];
424
425 wd->ap.txiv[vap][0]++;
426
427 if (wd->ap.txiv[vap][0] == 0)
428 {
429 wd->ap.txiv[vap][1]++;
430 }
431
432 if (wd->ap.txiv[vap][1] == 0)
433 {
434 wd->ap.txiv[vap][2]++;
435 }
436
437 if (wd->ap.txiv[vap][2] == 0)
438 {
439 wd->ap.txiv[vap][3]++;
440 }
441
442 if (wd->ap.txiv[vap][3] == 0)
443 {
444 wd->ap.txiv[vap][0] = 0;
445 wd->ap.txiv[vap][1] = 0;
446 wd->ap.txiv[vap][2] = 0;
447 }
448
449 header[hlen] = (wd->ap.bcKeyIndex[vap] & 0x0001); /* For Key Id and reserved field */
450 header[hlen+1] = (u16_t)wd->ap.txiv[vap][0];
451 header[hlen+2] = (u16_t)(wd->ap.txiv[vap][0] >> 16);
452 header[hlen+3] = (u16_t)wd->ap.txiv[vap][1];
453 header[hlen+4] = (u16_t)(wd->ap.txiv[vap][1] >> 16);
454 header[hlen+5] = (u16_t)wd->ap.txiv[vap][2];
455 header[hlen+6] = (u16_t)(wd->ap.txiv[vap][2] >> 16);
456 header[hlen+7] = (u16_t)wd->ap.txiv[vap][3];
457 header[hlen+8] = (u16_t)(wd->ap.txiv[vap][3] >> 16);
458
459 macCtrl |= 0x80;
460 icvLen = 16; /* MIC */
461
462 header[4] |= 0x4000;
463 hlen += 9;
464 }
465 #endif //ZM_ENABLE_CENC
466 }
467 else
468 {
469 /* Get STA's encryption type */
470 zfApGetStaEncryType(dev, da, &encryType);
471
472 if (encryType == ZM_TKIP)
473 {
474 /* Get iv16 and iv32 */
475 zfApGetStaWpaIv(dev, da, &iv16, &iv32);
476
477 iv16++;
478 if (iv16 == 0)
479 {
480 iv32++;
481 }
482
483 b1 = (u8_t) (iv16 >> 8);
484 b2 = (b1 | 0x20) & 0x7f;
485 header[hlen] = ((u16_t)b2 << 8) + b1;
486 b1 = (u8_t) iv16;
487 b2 = 0x20;
488 header[hlen+1] = ((u16_t)b2 << 8) + b1;
489 header[hlen+2] = (u16_t) iv32;
490 header[hlen+3] = (u16_t) (iv32 >> 16);
491
492 //macCtrl |= 0x80;
493 macCtrl |= 0x40;
494 icvLen = 4;
495
496 /* set hardware MIC */
497 if ( (!(seq & 0xf))&&(!(flag & 0x4)) )
498 {
499 macCtrl |= 0x100;
500 plusLen += 8;
501 *micLen = 8;
502 }
503
504 header[4] |= 0x4000;
505 hlen += 4;
506
507 /* Set iv16 and iv32 */
508 zfApSetStaWpaIv(dev, da, iv16, iv32);
509 }
510 else if (encryType == ZM_AES)
511 {
512 /* Get iv16 and iv32 */
513 zfApGetStaWpaIv(dev, da, &iv16, &iv32);
514
515 iv16++;
516 if (iv16 == 0)
517 {
518 iv32++;
519 }
520
521 b1 = (u8_t) iv16;
522 b2 = (u8_t) (iv16 >> 8);
523 header[hlen] = ((u16_t)b2 << 8) + b1;
524 header[hlen+1] = 0x2000;
525 header[hlen+2] = (u16_t) (iv32);
526 header[hlen+3] = (u16_t) (iv32 >> 16);
527
528 macCtrl |= 0xc0;
529 icvLen = 8; /* MIC */
530
531 header[4] |= 0x4000;
532 hlen += 4;
533
534 /* Set iv16 and iv32 */
535 zfApSetStaWpaIv(dev, da, iv16, iv32);
536 }
537 #ifdef ZM_ENABLE_CENC
538 else if (encryType == ZM_CENC)
539 {
540 u32_t txiv[4];
541 u8_t keyIdx;
542
543 /* Get CENC TxIV */
544 zfApGetStaCencIvAndKeyIdx(dev, da, txiv, &keyIdx);
545
546 txiv[0] += 2;
547
548 if (txiv[0] == 0 || txiv[0] == 1)
549 {
550 txiv[1]++;
551 }
552
553 if (txiv[1] == 0)
554 {
555 txiv[2]++;
556 }
557
558 if (txiv[2] == 0)
559 {
560 txiv[3]++;
561 }
562
563 if (txiv[3] == 0)
564 {
565 txiv[0] = 0;
566 txiv[1] = 0;
567 txiv[2] = 0;
568 }
569
570 header[hlen] = (keyIdx & 0x0001); /* For Key Id and reserved field */
571 header[hlen+1] = (u16_t)txiv[0];
572 header[hlen+2] = (u16_t)(txiv[0] >> 16);
573 header[hlen+3] = (u16_t)txiv[1];
574 header[hlen+4] = (u16_t)(txiv[1] >> 16);
575 header[hlen+5] = (u16_t)txiv[2];
576 header[hlen+6] = (u16_t)(txiv[2] >> 16);
577 header[hlen+7] = (u16_t)txiv[3];
578 header[hlen+8] = (u16_t)(txiv[3] >> 16);
579
580 macCtrl |= 0x80;
581 icvLen = 16; /* MIC */
582
583 header[4] |= 0x4000;
584 hlen += 9;
585
586 /* Set CENC IV */
587 zfApSetStaCencIv(dev, da, txiv);
588 }
589 #endif //ZM_ENABLE_CENC
590 }
591
592 /* protection mode */
593 if (wd->ap.protectionMode == 1)
594 {
595 /* Enable Self-CTS */
596 macCtrl &= 0xFFFC;
597 macCtrl |= 2;
598 }
599
600 /* Rate Control */
601 if (port < 0x20)
602 {
603 /* AP */
604 /* IV */
605 if ((wd->ap.encryMode[vap] == ZM_WEP64) ||
606 (wd->ap.encryMode[vap] == ZM_WEP128) ||
607 (wd->ap.encryMode[vap] == ZM_WEP256))
608 {
609 header[4] |= 0x4000;
610 header[hlen] = 0x0; //IV
611 header[hlen+1] = wd->ap.bcKeyIndex[vap] << 14; //IV with Keyid--CWYang(m)
612 hlen += 2;
613 icvLen = 4;
614 macCtrl |= 0x40;
615 }
616 }
617 else
618 {
619 /* WDS */
620
621 /* TODO : Fixed rate to 54M */
622 phyCtrl = 0xc0001; //PHY control L
623
624 /* WDS port checking */
625 if ((wdsPort = (port - 0x20)) >= ZM_MAX_WDS_SUPPORT)
626 {
627 wdsPort = 0;
628 }
629
630 #if 1
631 /* IV */
632 switch (wd->ap.wds.encryMode[wdsPort])
633 {
634 case ZM_WEP64:
635 case ZM_WEP128:
636 case ZM_WEP256:
637 header[4] |= 0x4000;
638 header[hlen] = 0x0; //IV
639 header[hlen+1] = wd->ap.bcKeyIndex[vap] << 14; //IV with Keyid
640 hlen += 2;
641 icvLen = 4;
642 macCtrl |= 0x40;
643 break;
644
645 case ZM_TKIP:
646 wd->sta.iv16++;
647
648 if ( wd->sta.iv16 == 0 )
649 {
650 wd->sta.iv32++;
651 }
652
653 b1 = (u8_t) (wd->sta.iv16 >> 8);
654 b2 = (b1 | 0x20) & 0x7f;
655 header[hlen] = ((u16_t)b2 << 8) + b1;
656 b1 = (u8_t) wd->sta.iv16;
657 b2 = 0x20;
658 header[hlen+1] = ((u16_t)b2 << 8) + b1;
659 header[hlen+2] = (u16_t) wd->sta.iv32;
660 header[hlen+3] = (u16_t) (wd->sta.iv32 >> 16);
661
662 //macCtrl |= 0x80;
663 macCtrl |= 0x40;
664 icvLen = 4;
665
666 /* set hardware MIC */
667 if ( (!(seq & 0xf))&&(!(flag & 0x4)) )
668 {
669 macCtrl |= 0x100;
670 plusLen += 8;
671 *micLen = 8;
672 }
673
674 header[4] |= 0x4000;
675 hlen += 4;
676 break;
677
678 case ZM_AES:
679 wd->sta.iv16++;
680 if ( wd->sta.iv16 == 0 )
681 {
682 wd->sta.iv32++;
683 }
684
685 b1 = (u8_t) wd->sta.iv16;
686 b2 = (u8_t) (wd->sta.iv16 >> 8);
687 header[hlen] = ((u16_t)b2 << 8) + b1;
688 header[hlen+1] = 0x2000;
689 header[hlen+2] = (u16_t) (wd->sta.iv32);
690 header[hlen+3] = (u16_t) (wd->sta.iv32 >> 16);
691
692 macCtrl |= 0xc0; /* Set to AES in control setting */
693 icvLen = 8; /* MIC */
694
695 header[4] |= 0x4000; /* Set WEP bit in wlan header */
696 hlen += 4; /* plus IV length */
697 break;
698 }/* end of switch */
699 #endif
700 }
701 }
702 else /* wd->wlanMode != ZM_MODE_AP */
703 {
704 encExemptionActionType = zfwGetPktEncExemptionActionType(dev, buf);
705
706 if ( wd->wlanMode == ZM_MODE_INFRASTRUCTURE )
707 {
708 #if 1
709 /* if WME AP */
710 if (wd->sta.wmeConnected != 0)
711 {
712 /* QoS data */
713 header[4] |= 0x0080;
714
715 /* QoS Control */
716 header[hlen] = up;
717 hlen += 1;
718 }
719 #endif
720
721 if ( encExemptionActionType == ZM_ENCRYPTION_EXEMPT_NO_EXEMPTION )
722 {
723 if ( wd->sta.authMode < ZM_AUTH_MODE_WPA )
724 { /* non-WPA */
725 if ( wd->sta.wepStatus == ZM_ENCRYPTION_WEP_ENABLED )
726 {
727 if ( (wd->sta.encryMode == ZM_WEP64)||
728 (wd->sta.encryMode == ZM_WEP128)||
729 (wd->sta.encryMode == ZM_WEP256) )
730 {
731 header[4] |= 0x4000;
732 header[hlen] = 0x0; //IV
733 header[hlen+1] = 0x0; //IV
734 header[hlen+1] |= (((u16_t) wd->sta.keyId) << 14);
735 hlen += 2;
736 icvLen = 4;
737
738 /* For Software WEP */
739 if ((wd->sta.SWEncryptEnable & ZM_SW_WEP_ENCRY_EN) != 0)
740 {
741 u8_t keyLen = 5;
742 u8_t iv[3];
743
744 iv[0] = 0x0;
745 iv[1] = 0x0;
746 iv[2] = 0x0;
747
748 if (wd->sta.SWEncryMode[wd->sta.keyId] == ZM_WEP64)
749 {
750 keyLen = 5;
751 }
752 else if (wd->sta.SWEncryMode[wd->sta.keyId] == ZM_WEP128)
753 {
754 keyLen = 13;
755 }
756 else if (wd->sta.SWEncryMode[wd->sta.keyId] == ZM_WEP256)
757 {
758 keyLen = 29;
759 }
760
761 zfWEPEncrypt(dev, buf, (u8_t*) snap, snapLen, minusLen, keyLen,
762 wd->sta.wepKey[wd->sta.keyId], iv);
763 }
764 else
765 {
766 macCtrl |= 0x40;
767 }
768 }
769 }
770 }
771 else
772 { /* WPA */
773 if ( wd->sta.wpaState >= ZM_STA_WPA_STATE_PK_OK )
774 {
775 wd->sta.iv16++;
776 if ( wd->sta.iv16 == 0 )
777 {
778 wd->sta.iv32++;
779 }
780
781 /* set encryption mode */
782 if ( wd->sta.encryMode == ZM_TKIP )
783 {
784 b1 = (u8_t) (wd->sta.iv16 >> 8);
785 b2 = (b1 | 0x20) & 0x7f;
786 header[hlen] = ((u16_t)b2 << 8) + b1;
787 b1 = (u8_t) wd->sta.iv16;
788 b2 = 0x20;
789
790 // header[hlen+1] = (((u16_t) wd->sta.keyId) << 14) | (((u16_t)b2 << 8) + b1);
791 // STA in infrastructure mode should use keyId = 0 to transmit unicast !
792 header[hlen+1] = (((u16_t)b2 << 8) + b1);
793 header[hlen+2] = (u16_t) wd->sta.iv32;
794 header[hlen+3] = (u16_t) (wd->sta.iv32 >> 16);
795
796 /* If software encryption enable */
797 if ((wd->sta.SWEncryptEnable & ZM_SW_TKIP_ENCRY_EN) == 0)
798 {
799 //macCtrl |= 0x80;
800 /* TKIP same to WEP */
801 macCtrl |= 0x40;
802 icvLen = 4;
803
804 /* set hardware MIC */
805 if ( (!(seq & 0xf))&&(!(flag & 0x4)) )
806 {
807 macCtrl |= 0x100;
808 plusLen += 8;
809 *micLen = 8;
810 }
811 }
812 else
813 {
814 u8_t mic[8];
815 u16_t offset;
816 u32_t icv;
817 u8_t RC4Key[16];
818
819 /* TODO: Remove the criticial section here. */
820 zmw_declare_for_critical_section();
821
822 zmw_enter_critical_section(dev);
823 /* Calculate MIC */
824 zfCalTxMic(dev, buf, (u8_t *)snap, snapLen, minusLen, da, sa, up, mic);
825
826 offset = zfwBufGetSize(dev, buf);
827
828 /* Append MIC to the buffer */
829 zfCopyToIntTxBuffer(dev, buf, mic, offset, 8);
830 zfwBufSetSize(dev, buf, offset+8);
831 zmw_leave_critical_section(dev);
832
833 /* TKIP Key Mixing */
834 zfTkipPhase1KeyMix(wd->sta.iv32, &wd->sta.txSeed);
835 zfTkipPhase2KeyMix(wd->sta.iv16, &wd->sta.txSeed);
836 zfTkipGetseeds(wd->sta.iv16, RC4Key, &wd->sta.txSeed);
837
838 /* Encrypt Data */
839 zfTKIPEncrypt(dev, buf, (u8_t *)snap, snapLen, minusLen, 16, RC4Key, &icv);
840
841 icvLen = 4;
842 len += 8;
843 }
844
845 header[4] |= 0x4000;
846 hlen += 4;
847 }
848 else if ( wd->sta.encryMode == ZM_AES )
849 {
850 b1 = (u8_t) wd->sta.iv16;
851 b2 = (u8_t) (wd->sta.iv16 >> 8);
852 header[hlen] = ((u16_t)b2 << 8) + b1;
853 // header[hlen+1] = (((u16_t) wd->sta.keyId) << 14) | (0x2000);
854 // STA in infrastructure mode should use keyId = 0 to transmit unicast !
855 header[hlen+1] = 0x2000;
856 header[hlen+2] = (u16_t) (wd->sta.iv32);
857 header[hlen+3] = (u16_t) (wd->sta.iv32 >> 16);
858
859 macCtrl |= 0xc0;
860 icvLen = 8; /* MIC */
861
862 header[4] |= 0x4000;
863 hlen += 4;
864 }
865 #ifdef ZM_ENABLE_CENC
866 else if ( wd->sta.encryMode == ZM_CENC )
867 {
868 /* Accumlate the PN sequence */
869 wd->sta.txiv[0] += 2;
870
871 if (wd->sta.txiv[0] == 0 || wd->sta.txiv[0] == 1)
872 {
873 wd->sta.txiv[1]++;
874 }
875
876 if (wd->sta.txiv[1] == 0)
877 {
878 wd->sta.txiv[2]++;
879 }
880
881 if (wd->sta.txiv[2] == 0)
882 {
883 wd->sta.txiv[3]++;
884 }
885
886 if (wd->sta.txiv[3] == 0)
887 {
888 wd->sta.txiv[0] = 0;
889 wd->sta.txiv[1] = 0;
890 wd->sta.txiv[2] = 0;
891 }
892
893 header[hlen] = (wd->sta.cencKeyId & 0x0001); /* For Key Id and reserved field */
894 header[hlen+1] = (u16_t) wd->sta.txiv[0];
895 header[hlen+2] = (u16_t) (wd->sta.txiv[0] >> 16);
896 header[hlen+3] = (u16_t) wd->sta.txiv[1];
897 header[hlen+4] = (u16_t) (wd->sta.txiv[1] >> 16);
898 header[hlen+5] = (u16_t) wd->sta.txiv[2];
899 header[hlen+6] = (u16_t) (wd->sta.txiv[2] >> 16);
900 header[hlen+7] = (u16_t) wd->sta.txiv[3];
901 header[hlen+8] = (u16_t) (wd->sta.txiv[3] >> 16);
902
903 macCtrl |= 0x80;
904 icvLen = 16; /* MIC */
905
906 header[4] |= 0x4000;
907 hlen += 9;
908 }
909 #endif //ZM_ENABLE_CENC
910 }
911 }
912 } // if ( encExemptionActionType == ZM_ENCRYPTION_EXEMPT_NO_EXEMPTION )
913 } /* if ( wd->wlanMode != ZM_MODE_INFRASTRUCTURE ) */
914
915 if ( wd->wlanMode == ZM_MODE_IBSS )
916 {
917 if ( encExemptionActionType == ZM_ENCRYPTION_EXEMPT_NO_EXEMPTION )
918 {
919 #ifdef ZM_ENABLE_IBSS_WPA2PSK
920 if( wd->sta.oppositeInfo[userIdx].wpaState >= ZM_STA_WPA_STATE_PK_OK || wd->sta.wpaState >= ZM_STA_WPA_STATE_PK_OK)
921 {
922 int isUnicast = 1 ;
923
924 if((da[0]& 0x1))
925 {
926 isUnicast = 0 ; // Not unicast , is broadcast
927 }
928
929 if( wd->sta.ibssWpa2Psk == 1 )
930 { /* The IV order is not the same between unicast and broadcast ! */
931 if ( isUnicast )
932 {
933 iv16 = &wd->sta.oppositeInfo[userIdx].iv16;
934 iv32 = &wd->sta.oppositeInfo[userIdx].iv32;
935 }
936 else
937 {
938 iv16 = &wd->sta.iv16;
939 iv32 = &wd->sta.iv32;
940 }
941 }
942 else
943 {
944 iv16 = &wd->sta.iv16;
945 iv32 = &wd->sta.iv32;
946 }
947
948 (*iv16)++;
949 if ( *iv16 == 0 )
950 {
951 *iv32++;
952 }
953
954 if ( wd->sta.oppositeInfo[userIdx].encryMode == ZM_AES || wd->sta.encryMode == ZM_AES)
955 {
956 //printk("Station encryption mode is AES-CCMP\n") ;
957 b1 = (u8_t) (*iv16);
958 b2 = (u8_t) ((*iv16) >> 8);
959 header[hlen] = ((u16_t)b2 << 8) + b1;
960
961 if ( isUnicast )
962 {
963 header[hlen+1] = 0x2000;
964 }
965 else
966 {
967 header[hlen+1] = 0x2000 | (((u16_t) wd->sta.keyId) << 14);
968 }
969
970 header[hlen+2] = (u16_t) (*iv32);
971 header[hlen+3] = (u16_t) ((*iv32) >> 16);
972 macCtrl |= 0xc0;
973 icvLen = 8; /* MIC */
974 }
975
976 header[4] |= 0x4000;
977 hlen += 4;
978 }
979 else if ( wd->sta.wepStatus == ZM_ENCRYPTION_WEP_ENABLED)
980 {
981 if ( (wd->sta.encryMode == ZM_WEP64)||
982 (wd->sta.encryMode == ZM_WEP128)||
983 (wd->sta.encryMode == ZM_WEP256) )
984 {
985 header[4] |= 0x4000;
986 header[hlen] = 0x0; //IV
987 header[hlen+1] = 0x0; //IV
988 header[hlen+1] |= (((u16_t) wd->sta.keyId) << 14);
989 hlen += 2;
990 icvLen = 4;
991 macCtrl |= 0x40;
992 }
993 }
994 #else
995 /* ----- 20070405 add by Mxzeng ----- */
996 if( wd->sta.wpaState >= ZM_STA_WPA_STATE_PK_OK )
997 {
998 int isUnicast = 1 ;
999
1000 if((da[0]& 0x1))
1001 {
1002 isUnicast = 0 ; // Not unicast , is broadcast
1003 }
1004
1005 wd->sta.iv16++;
1006 if ( wd->sta.iv16 == 0 )
1007 {
1008 wd->sta.iv32++;
1009 }
1010
1011 if ( wd->sta.encryMode == ZM_AES )
1012 {
1013 //printk("Station encryption mode is AES-CCMP\n") ;
1014 b1 = (u8_t) wd->sta.iv16;
1015 b2 = (u8_t) (wd->sta.iv16 >> 8);
1016 header[hlen] = ((u16_t)b2 << 8) + b1;
1017
1018 if ( isUnicast )
1019 {
1020 header[hlen+1] = 0x2000;
1021 }
1022 else
1023 {
1024 header[hlen+1] = 0x2000 | (((u16_t) wd->sta.keyId) << 14);
1025 }
1026
1027 header[hlen+2] = (u16_t) (wd->sta.iv32);
1028 header[hlen+3] = (u16_t) (wd->sta.iv32 >> 16);
1029 macCtrl |= 0xc0;
1030 icvLen = 8; /* MIC */
1031 }
1032
1033 header[4] |= 0x4000;
1034 hlen += 4;
1035 }
1036 else if ( wd->sta.wepStatus == ZM_ENCRYPTION_WEP_ENABLED)
1037 {
1038 if ( (wd->sta.encryMode == ZM_WEP64)||
1039 (wd->sta.encryMode == ZM_WEP128)||
1040 (wd->sta.encryMode == ZM_WEP256) )
1041 {
1042 header[4] |= 0x4000;
1043 header[hlen] = 0x0; //IV
1044 header[hlen+1] = 0x0; //IV
1045 header[hlen+1] |= (((u16_t) wd->sta.keyId) << 14);
1046 hlen += 2;
1047 icvLen = 4;
1048 macCtrl |= 0x40;
1049 }
1050 }
1051 #endif
1052 } // End if ( encExemptionActionType == ZM_ENCRYPTION_EXEMPT_NO_EXEMPTION )
1053 } // End if ( wd->wlanMode == ZM_MODE_IBSS )
1054 else if ( wd->wlanMode == ZM_MODE_PSEUDO )
1055 {
1056 switch (wd->sta.encryMode)
1057 {
1058 case ZM_WEP64:
1059 case ZM_WEP128:
1060 case ZM_WEP256:
1061 header[4] |= 0x4000;
1062 header[hlen] = 0x0; //IV
1063 header[hlen+1] = 0x0; //IV
1064 hlen += 2;
1065 icvLen = 4;
1066 macCtrl |= 0x40;
1067 break;
1068
1069 case ZM_TKIP:
1070 {
1071 wd->sta.iv16++;
1072 if ( wd->sta.iv16 == 0 )
1073 {
1074 wd->sta.iv32++;
1075 }
1076
1077 b1 = (u8_t) (wd->sta.iv16 >> 8);
1078 b2 = (b1 | 0x20) & 0x7f;
1079 header[hlen] = ((u16_t)b2 << 8) + b1;
1080 b1 = (u8_t) wd->sta.iv16;
1081 b2 = 0x20;
1082 header[hlen+1] = ((u16_t)b2 << 8) + b1;
1083 header[hlen+2] = (u16_t) wd->sta.iv32;
1084 header[hlen+3] = (u16_t) (wd->sta.iv32 >> 16);
1085
1086 //macCtrl |= 0x80;
1087 macCtrl |= 0x40;
1088 icvLen = 4;
1089
1090 /* set hardware MIC */
1091 if ( (!(seq & 0xf))&&(!(flag & 0x4)) )
1092 {
1093 macCtrl |= 0x100;
1094 plusLen += 8;
1095 *micLen = 8;
1096 }
1097
1098 header[4] |= 0x4000;
1099 hlen += 4;
1100 }/* end of PSEUDO TKIP */
1101 break;
1102
1103 case ZM_AES:
1104 {
1105 wd->sta.iv16++;
1106 if ( wd->sta.iv16 == 0 )
1107 {
1108 wd->sta.iv32++;
1109 }
1110
1111 b1 = (u8_t) wd->sta.iv16;
1112 b2 = (u8_t) (wd->sta.iv16 >> 8);
1113 header[hlen] = ((u16_t)b2 << 8) + b1;
1114 header[hlen+1] = 0x2000;
1115 header[hlen+2] = (u16_t) (wd->sta.iv32);
1116 header[hlen+3] = (u16_t) (wd->sta.iv32 >> 16);
1117 macCtrl |= 0xc0;
1118 icvLen = 8; /* MIC */
1119 header[4] |= 0x4000;
1120 hlen += 4;
1121 }/* end of PSEUDO AES */
1122 break;
1123
1124 #ifdef ZM_ENABLE_CENC
1125 case ZM_CENC:
1126 /* Accumlate the PN sequence */
1127 wd->sta.txiv[0] += 2;
1128
1129 if (wd->sta.txiv[0] == 0 || wd->sta.txiv[0] == 1)
1130 {
1131 wd->sta.txiv[1]++;
1132 }
1133
1134 if (wd->sta.txiv[1] == 0)
1135 {
1136 wd->sta.txiv[2]++;
1137 }
1138
1139 if (wd->sta.txiv[2] == 0)
1140 {
1141 wd->sta.txiv[3]++;
1142 }
1143
1144 if (wd->sta.txiv[3] == 0)
1145 {
1146 wd->sta.txiv[0] = 0;
1147 wd->sta.txiv[1] = 0;
1148 wd->sta.txiv[2] = 0;
1149 }
1150
1151 header[hlen] = 0;
1152 header[hlen+1] = (u16_t) wd->sta.txiv[0];
1153 header[hlen+2] = (u16_t) (wd->sta.txiv[0] >> 16);
1154 header[hlen+3] = (u16_t) wd->sta.txiv[1];
1155 header[hlen+4] = (u16_t) (wd->sta.txiv[1] >> 16);
1156 header[hlen+5] = (u16_t) wd->sta.txiv[2];
1157 header[hlen+6] = (u16_t) (wd->sta.txiv[2] >> 16);
1158 header[hlen+7] = (u16_t) wd->sta.txiv[3];
1159 header[hlen+8] = (u16_t) (wd->sta.txiv[3] >> 16);
1160
1161 macCtrl |= 0x80;
1162 icvLen = 16; /* MIC */
1163
1164 header[4] |= 0x4000;
1165 hlen += 9;
1166 break;
1167 #endif //ZM_ENABLE_CENC
1168 }/* end of switch */
1169 }
1170
1171 /* Generate control setting */
1172
1173 /* protection mode */
1174 if (wd->enableProtectionMode)
1175 {
1176 if (wd->enableProtectionMode==2)
1177 {
1178 /* Force enable protection: self cts */
1179 macCtrl &= 0xFFFC;
1180 macCtrl |= 2;
1181 }
1182 /* if wd->enableProtectionMode=1 => force disable */
1183 /* if wd->enableProtectionMode=0 => auto */
1184 }
1185 else
1186 {
1187
1188 /* protection mode */
1189 if (wd->sta.bProtectionMode == TRUE)
1190 {
1191 /* Enable Self-CTS */
1192 macCtrl &= 0xFFFC;
1193 macCtrl |= 2;
1194 }
1195 }
1196
1197 }
1198
1199 if (wd->txMCS != 0xff)
1200 {
1201 /* fixed rate */
1202 phyCtrl = ((u32_t)wd->txMCS<<16) + wd->txMT;
1203 mcs = wd->txMCS;
1204 mt = wd->txMT;
1205 }
1206
1207 if (mt == 2)
1208 {
1209 #if 0
1210 /* HT PT: 0 Mixed mode 1 Green field */
1211 if (wd->sta.preambleTypeHT == ZM_PREAMBLE_TYPE_GREEN_FIELD)
1212 {
1213 phyCtrl |= 0x4; /* Bit 2 */
1214 }
1215 #endif
1216 /* Bandwidth */
1217 if (wd->sta.htCtrlBandwidth == ZM_BANDWIDTH_40MHZ)
1218 {
1219 phyCtrl |= (0x80<<16); /* BIT 23 */
1220 }
1221 #if 0
1222 /* STBC */
1223 if (wd->sta.htCtrlSTBC<=0x3)
1224 {
1225 phyCtrl |= (wd->sta.htCtrlSTBC<<28); /* BIT 23 */
1226 }
1227 #endif
1228 /* Short GI */
1229 if(wd->sta.htCtrlSG)
1230 {
1231 phyCtrl |= (0x8000<<16); /* BIT 31 */
1232 }
1233
1234 /* TA */
1235 if ( ((mcs >=0x8) && (mcs<=0xf)) || (wd->sta.htCtrlSTBC) )
1236 {
1237 phyCtrl |= 0x1800; /* BIT 11 12 */
1238 }
1239 }
1240 else if(mt == 1)
1241 {
1242 #if 0
1243 //bug that cause OFDM rate become duplicate legacy rate
1244 /* Bandwidth */
1245 if (wd->sta.htCtrlBandwidth == ZM_BANDWIDTH_40MHZ)
1246 {
1247 phyCtrl |= (0x80<<16); /* BIT 23 */
1248 mt = 3; /* duplicate legacy */
1249 phyCtrl |= mt;
1250 }
1251 #endif
1252 }
1253 else if(mt == 0)
1254 {
1255 /* CCK PT: Legcy Preamble: 1 long preamble 2 short preamble */
1256 if (wd->preambleTypeInUsed == ZM_PREAMBLE_TYPE_SHORT)
1257 {
1258 //phyCtrl |= 0x4; /* BIT 2 */
1259 }
1260 }
1261
1262 /* TA */
1263 if (wd->sta.defaultTA)
1264 {
1265 phyCtrl |= 0x1000;
1266 }
1267 else
1268 {
1269 phyCtrl |= 0x0800;
1270 }
1271
1272 //Get CurrentTxRate -- CWYang(+)
1273 if ((mt == 0) || (mt == 1)) //B,G Rate
1274 {
1275 if (mcs < 16)
1276 {
1277 wd->CurrentTxRateKbps = zcIndextoRateBG[mcs];
1278 }
1279 }
1280 else if (mt == 2)
1281 {
1282 if (mcs < 16)
1283 {
1284 if (wd->sta.htCtrlBandwidth == ZM_BANDWIDTH_40MHZ)
1285 {
1286 if((phyCtrl & 0x80000000) != 0)
1287 {
1288 /* Short GI 40 MHz MIMO Rate */
1289 wd->CurrentTxRateKbps = zcIndextoRateN40S[mcs];
1290 }
1291 else
1292 {
1293 /* Long GI 40 MHz MIMO Rate */
1294 wd->CurrentTxRateKbps = zcIndextoRateN40L[mcs];
1295 }
1296 }
1297 else
1298 {
1299 if((phyCtrl & 0x80000000) != 0)
1300 {
1301 /* Short GI 20 MHz MIMO Rate */
1302 wd->CurrentTxRateKbps = zcIndextoRateN20S[mcs];
1303 }
1304 else
1305 {
1306 /* Long GI 20 MHz MIMO Rate */
1307 wd->CurrentTxRateKbps = zcIndextoRateN20L[mcs];
1308 }
1309 }
1310 }
1311 }
1312
1313 //802.11 header(include IV) = (hlen<<1)-8
1314 //ethernet frame = len
1315 //snap + mic = plusLen
1316 //ethernet header = minusLen
1317 //icv = icvLen
1318 //crc32 = 4
1319 //length=802.11 header+snap+(ethernet frame-ethernet header)+mic+icv+crc32
1320 header[0] = ((hlen<<1)-8)+plusLen+(len-minusLen)+icvLen+4; //Length
1321
1322 // header[0] : MPDU Lengths
1323 if ((header[6] & 0x1) != 0x1) // Unicast Frame
1324 {
1325 if (header[0] >= wd->rtsThreshold)
1326 {
1327 /* Enable RTS */
1328 macCtrl |= 1;
1329 }
1330 }
1331
1332 if ( wd->sta.encryMode == ZM_TKIP )
1333 tkipFrameOffset = 8;
1334
1335 if( wd->sta.EnableHT != 1 )
1336 { // Aggregation should not be fragmented !
1337 if ( header[0] > ( wd->fragThreshold + tkipFrameOffset ) )
1338 {
1339 return 0; // Need to be fragmented ! !
1340 }
1341 }
1342
1343 //if ( wd->sta.encryMode == ZM_TKIP )
1344 //{
1345 // zm_debug_msg1("ctrl length = ", header[0]);
1346 //}
1347
1348 //MAC control
1349 if (rateProbingFlag != 0)
1350 {
1351 macCtrl |= 0x8000;
1352 }
1353 header[1] = macCtrl;
1354 //PHY control L
1355 header[2] = (u16_t) ((phyCtrl&0xffff) | 0x700 | (zcUpToAc[up&0x7]<<13));
1356 //PHY control H
1357 header[3] = (u16_t) ((phyCtrl>>16) | 0x700);
1358
1359 if (wd->enableAggregation)
1360 {
1361 /* force enable aggregation */
1362 if (wd->enableAggregation==2 && !(header[6]&0x1))
1363 {
1364 if (((header[2] & 0x3) == 2))
1365 {
1366 /* Enable aggregation */
1367 header[1] |= 0x20;
1368 }
1369 }
1370 /* if wd->enableAggregation=1 => force disable */
1371 /* if wd->enableAggregation=0 => auto */
1372 }
1373
1374 #ifdef ZM_ENABLE_AGGREGATION
1375 if (wd->addbaComplete) {
1376 #ifdef ZM_BYPASS_AGGR_SCHEDULING
1377 if (!(header[6]&0x1) && !rateProbingFlag && (wd->enableAggregation != 1))
1378 {
1379 if (((header[2] & 0x3) == 2))
1380 {
1381 /* Unicast frame with HT rate => Enable aggregation */
1382 /* We only support software encryption in single packet mode */
1383 if ((wd->sta.SWEncryptEnable & ZM_SW_TKIP_ENCRY_EN) == 0 &&
1384 (wd->sta.SWEncryptEnable & ZM_SW_WEP_ENCRY_EN) == 0)
1385 {
1386 /* Set aggregation group bits per AC */
1387 header[1] |= (0x20 | (zcUpToAc[up&0x7]<<10));
1388
1389 //if (wd->sta.currentFrequency < 3000)
1390 {
1391 /* issue: -PB42 Enable RTS/CTS to prevent OWL Tx hang up */
1392 /* If this is Owl Ap, enable RTS/CTS protect */
1393 if ( (wd->sta.athOwlAp == 1) || (wd->sta.RTSInAGGMode == TRUE) )
1394 {
1395 header[1] &= 0xfffc;
1396 header[1] |= 0x1;
1397 }
1398
1399 /* Enable RIFS : workaround 854T RTS/CTS */
1400 /* Bit13 : TI enable RIFS */
1401 //header[1] |= 0x2000;
1402 }
1403 }
1404 }
1405 }
1406 #else
1407 /*
1408 * aggregation ampduIndication control
1409 */
1410 if (aggControl && aggControl->aggEnabled) {
1411 if (wd->enableAggregation==0 && !(header[6]&0x1))
1412 {
1413 if (((header[2] & 0x3) == 2))
1414 {
1415 /* Enable aggregation */
1416 header[1] |= 0x20;
1417 if (ZM_AGG_LAST_MPDU == aggControl->ampduIndication)
1418 header[1] |= 0x4000;
1419 }
1420 else {
1421 zm_debug_msg1("no aggr, header[2]&0x3 = ",header[2] & 0x3)
1422 aggControl->aggEnabled = 0;
1423 }
1424 }
1425 else {
1426 zm_debug_msg1("no aggr, wd->enableAggregation = ", wd->enableAggregation);
1427 zm_debug_msg1("no aggr, !header[6]&0x1 = ",!(header[6]&0x1));
1428 aggControl->aggEnabled = 0;
1429 }
1430 }
1431 #endif
1432
1433 #ifdef ZM_AGGR_BIT_ON
1434 if (!(header[6]&0x1) && !rateProbingFlag)
1435 {
1436 if (((header[2] & 0x3) == 2))
1437 {
1438 /* Unicast frame with HT rate => Enable aggregation */
1439 /* Set aggregation group bits per AC */
1440 header[1] |= (0x20 | (zcUpToAc[up&0x7]<<10));
1441
1442 //if (wd->sta.currentFrequency < 3000)
1443 {
1444 /* Enable RTS/CTS to prevent OWL Tx hang up */
1445 header[1] &= 0xfffc;
1446 header[1] |= 0x1;
1447 }
1448 }
1449 }
1450 #endif
1451 }
1452 #endif
1453
1454 return (hlen<<1);
1455 }
1456
1457
1458 u16_t zfTxGenMmHeader(zdev_t* dev, u8_t frameType, u16_t* dst,
1459 u16_t* header, u16_t len, zbuf_t* buf, u16_t vap, u8_t encrypt)
1460 {
1461 //u16_t bodyLen;
1462 u8_t hlen = 32; // MAC ctrl + PHY ctrl + 802.11 MM header
1463
1464 zmw_get_wlan_dev(dev);
1465
1466 zmw_declare_for_critical_section();
1467
1468 /* Generate control setting */
1469 //bodyLen = zfwBufGetSize(dev, buf);
1470 header[0] = 24+len+4; //Length
1471 if ((dst[0] & 0x1) != 0) //Broadcast, multicast frames
1472 {
1473 header[1] = 0xc; //MAC control, backoff + noack
1474 }
1475 else
1476 {
1477 header[1] = 0x8; //MAC control, backoff + (ack)
1478 }
1479 /* Dualband Management frame tx Rate */
1480 if (wd->wlanMode == ZM_MODE_AP)
1481 {
1482 if (wd->frequency < 3000)
1483 {
1484 /* CCK 1M */
1485 header[2] = 0x0f00; //PHY control L
1486 header[3] = 0x0000; //PHY control H
1487 }
1488 else
1489 {
1490 /* CCK 6M */
1491 header[2] = 0x0f01; //PHY control L
1492 header[3] = 0x000B; //PHY control H
1493 }
1494 }
1495 else
1496 {
1497 if (wd->sta.currentFrequency < 3000)
1498 {
1499 /* CCK 2M */
1500 header[2] = 0x0f00; //PHY control L
1501 header[3] = 0x0001; //PHY control H
1502 }
1503 else
1504 {
1505 /* CCK 6M */
1506 header[2] = 0x0f01; //PHY control L
1507 header[3] = 0x000B; //PHY control H
1508 }
1509 }
1510 /* Generate WLAN header */
1511 /* Frame control */
1512 header[4+0] = frameType;
1513 /* Duration */
1514 header[4+1] = 0;
1515
1516 if (wd->wlanMode == ZM_MODE_INFRASTRUCTURE)
1517 {
1518 if ( frameType == ZM_WLAN_FRAME_TYPE_PROBEREQ )
1519 {
1520 header[4+8] = 0xFFFF;
1521 header[4+9] = 0xFFFF;
1522 header[4+10] = 0xFFFF;
1523 }
1524 else if ( frameType == ZM_WLAN_FRAME_TYPE_BA ) {
1525 /* do nothing */
1526 }
1527 else
1528 {
1529 header[4+8] = wd->sta.bssid[0];
1530 header[4+9] = wd->sta.bssid[1];
1531 header[4+10] = wd->sta.bssid[2];
1532 }
1533 }
1534 else if (wd->wlanMode == ZM_MODE_PSEUDO)
1535 {
1536 /* Address 3 = 00:00:00:00:00:00 */
1537 header[4+8] = 0;
1538 header[4+9] = 0;
1539 header[4+10] = 0;
1540 }
1541 else if (wd->wlanMode == ZM_MODE_IBSS)
1542 {
1543 header[4+8] = wd->sta.bssid[0];
1544 header[4+9] = wd->sta.bssid[1];
1545 header[4+10] = wd->sta.bssid[2];
1546
1547 if ( frameType == ZM_WLAN_FRAME_TYPE_ATIM )
1548 {
1549 /* put ATIM to queue 5th */
1550 //header[2] |= (ZM_BIT_13|ZM_BIT_14);
1551 header[2] |= ZM_BIT_15;
1552 }
1553 }
1554 else if (wd->wlanMode == ZM_MODE_AP)
1555 {
1556 /* Address 3 = BSSID */
1557 header[4+8] = wd->macAddr[0];
1558 header[4+9] = wd->macAddr[1];
1559 #ifdef ZM_VAPMODE_MULTILE_SSID
1560 header[4+10] = wd->macAddr[2]; //Multiple SSID
1561 #else
1562 header[4+10] = wd->macAddr[2] + (vap<<8); //VAP
1563 #endif
1564 //if in scan, must set address 3 to broadcast because of some ap would care this
1565 //if ((wd->heartBeatNotification & ZM_BSSID_LIST_SCAN)
1566 // == ZM_BSSID_LIST_SCAN)
1567 //if FrameType is Probe Request, Address3 should be boradcast
1568 if (frameType == ZM_WLAN_FRAME_TYPE_PROBEREQ)
1569 {
1570 header[4+8] = 0xFFFF;
1571 header[4+9] = 0xFFFF;
1572 header[4+10] = 0xFFFF;
1573 }
1574 }
1575
1576 /* Address 1 = DA */
1577 header[4+2] = dst[0];
1578 header[4+3] = dst[1];
1579 header[4+4] = dst[2];
1580
1581 /* Address 2 = SA */
1582 header[4+5] = wd->macAddr[0];
1583 header[4+6] = wd->macAddr[1];
1584 if (wd->wlanMode == ZM_MODE_AP)
1585 {
1586 #ifdef ZM_VAPMODE_MULTILE_SSID
1587 header[4+7] = wd->macAddr[2]; //Multiple SSID
1588 #else
1589 header[4+7] = wd->macAddr[2] + (vap<<8); //VAP
1590 #endif
1591 }
1592 else
1593 {
1594 header[4+7] = wd->macAddr[2];
1595 }
1596
1597 /* Sequence Control */
1598 zmw_enter_critical_section(dev);
1599 header[4+11] = ((wd->mmseq++)<<4);
1600 zmw_leave_critical_section(dev);
1601
1602 if( frameType == ZM_WLAN_FRAME_TYPE_QOS_NULL )
1603 {
1604 /*Qos Control*/
1605 header[4+12] = 0x0;
1606 hlen+=2;
1607 header[0]+=2;
1608 }
1609
1610 if ( encrypt )
1611 {
1612 if ( wd->sta.wepStatus == ZM_ENCRYPTION_WEP_ENABLED )
1613 {
1614 if ( (wd->sta.encryMode == ZM_WEP64)||
1615 (wd->sta.encryMode == ZM_WEP128)||
1616 (wd->sta.encryMode == ZM_WEP256) )
1617 {
1618 header[4] |= 0x4000;
1619 header[16] = 0x0; //IV
1620 header[17] = 0x0; //IV
1621 header[17] |= (((u16_t) wd->sta.keyId) << 14);
1622 hlen += 4;
1623
1624 header[0] += 8; // icvLen = 4;
1625 header[1] |= 0x40; // enable encryption on macCtrl
1626 }
1627 }
1628 }
1629
1630 // Enable HW duration
1631 if ( frameType != ZM_WLAN_FRAME_TYPE_PSPOLL )
1632 {
1633 header[1] |= 0x200;
1634 }
1635
1636 return hlen;
1637 }
1638
1639 void zfInitMacApMode(zdev_t* dev)
1640 {
1641 u16_t i;
1642
1643 zmw_get_wlan_dev(dev);
1644
1645 zfHpEnableBeacon(dev, ZM_MODE_AP, (wd->beaconInterval/wd->ap.vapNumber), 1, 0);
1646
1647 /* AP mode */
1648 zfHpSetApStaMode(dev, ZM_HAL_80211_MODE_AP);
1649
1650 /* VAP test code */
1651 /* AP + VAP mode */
1652 if (wd->ap.vapNumber >= 2)
1653 {
1654 for (i=1; i<ZM_MAX_AP_SUPPORT; i++)
1655 {
1656 if (((wd->ap.apBitmap >> i) & 0x1) != 0)
1657 {
1658 u16_t mac[3];
1659 mac[0] = wd->macAddr[0];
1660 mac[1] = wd->macAddr[1];
1661 #ifdef ZM_VAPMODE_MULTILE_SSID
1662 mac[2] = wd->macAddr[2]; //Multiple SSID
1663 #else
1664 mac[2] = wd->macAddr[2] + (i<<8); //VAP
1665 #endif
1666 zfHpSetMacAddress(dev, mac, i);
1667
1668 }
1669 }
1670 }
1671
1672 /* basic rate setting */
1673 zfHpSetBasicRateSet(dev, wd->bRateBasic, wd->gRateBasic);
1674
1675 /* Set TxQs CWMIN, CWMAX, AIFS and TXO to WME AP default. */
1676 zfUpdateDefaultQosParameter(dev, 1);
1677
1678 return;
1679 }
1680
1681 u16_t zfChGetNextChannel(zdev_t* dev, u16_t frequency, u8_t* pbPassive)
1682 {
1683 u8_t i;
1684 u8_t bPassive;
1685
1686 zmw_get_wlan_dev(dev);
1687
1688 /* Avoid NULL value */
1689 if ( pbPassive == NULL )
1690 {
1691 pbPassive = &bPassive;
1692 }
1693
1694 for( i=0; i<wd->regulationTable.allowChannelCnt; i++ )
1695 {
1696 if ( wd->regulationTable.allowChannel[i].channel == frequency )
1697 {
1698 if ( i == (wd->regulationTable.allowChannelCnt-1) )
1699 {
1700 i = 0;
1701 }
1702 else
1703 {
1704 i++;
1705 }
1706
1707 if ( wd->regulationTable.allowChannel[i].channelFlags
1708 & ZM_REG_FLAG_CHANNEL_PASSIVE )
1709 {
1710 *pbPassive = TRUE;
1711 }
1712 else
1713 {
1714 *pbPassive = FALSE;
1715 }
1716
1717 return wd->regulationTable.allowChannel[i].channel;
1718 }
1719 }
1720
1721 return 0xffff;
1722 }
1723
1724 u16_t zfChGetFirstChannel(zdev_t* dev, u8_t* pbPassive)
1725 {
1726 u8_t bPassive;
1727
1728 zmw_get_wlan_dev(dev);
1729
1730 /* Avoid NULL value */
1731 if ( pbPassive == NULL )
1732 {
1733 pbPassive = &bPassive;
1734 }
1735
1736 if ( wd->regulationTable.allowChannel[0].channelFlags & ZM_REG_FLAG_CHANNEL_PASSIVE )
1737 {
1738 *pbPassive = TRUE;
1739 }
1740 else
1741 {
1742 *pbPassive = FALSE;
1743 }
1744
1745 return wd->regulationTable.allowChannel[0].channel;
1746 }
1747
1748 u16_t zfChGetFirst2GhzChannel(zdev_t* dev)
1749 {
1750 u8_t i;
1751
1752 zmw_get_wlan_dev(dev);
1753
1754 for( i=0; i<wd->regulationTable.allowChannelCnt; i++ )
1755 {
1756 if ( wd->regulationTable.allowChannel[i].channel < 3000 )
1757 {
1758 /* find the first 2Ghz channel */
1759 return wd->regulationTable.allowChannel[i].channel;
1760 }
1761 }
1762
1763 /* Can not find any 2Ghz channel */
1764 return 0;
1765 }
1766
1767 u16_t zfChGetFirst5GhzChannel(zdev_t* dev)
1768 {
1769 u8_t i;
1770
1771 zmw_get_wlan_dev(dev);
1772
1773 for( i=0; i<wd->regulationTable.allowChannelCnt; i++ )
1774 {
1775 if ( wd->regulationTable.allowChannel[i].channel > 3000 )
1776 {
1777 /* find the first 5Ghz channel */
1778 return wd->regulationTable.allowChannel[i].channel;
1779 }
1780 }
1781
1782 /* Can not find any 5Ghz channel */
1783 return 0;
1784 }
1785
1786 u16_t zfChGetLastChannel(zdev_t* dev, u8_t* pbPassive)
1787 {
1788 u8_t bPassive;
1789 u8_t ChannelIndex;
1790
1791 zmw_get_wlan_dev(dev);
1792
1793 ChannelIndex = wd->regulationTable.allowChannelCnt-1;
1794
1795 /* Avoid NULL value */
1796 if ( pbPassive == NULL )
1797 {
1798 pbPassive = &bPassive;
1799 }
1800
1801 if ( wd->regulationTable.allowChannel[ChannelIndex].channelFlags
1802 & ZM_REG_FLAG_CHANNEL_PASSIVE )
1803 {
1804 *pbPassive = TRUE;
1805 }
1806 else
1807 {
1808 *pbPassive = FALSE;
1809 }
1810
1811 return wd->regulationTable.allowChannel[ChannelIndex].channel;
1812 }
1813
1814 u16_t zfChGetLast5GhzChannel(zdev_t* dev)
1815 {
1816 u8_t i;
1817 u16_t last5Ghzfrequency;
1818
1819 zmw_get_wlan_dev(dev);
1820
1821 last5Ghzfrequency = 0;
1822 for( i=0; i<wd->regulationTable.allowChannelCnt; i++ )
1823 {
1824 if ( wd->regulationTable.allowChannel[i].channel > 3000 )
1825 {
1826 last5Ghzfrequency = wd->regulationTable.allowChannel[i].channel;
1827 }
1828 }
1829
1830 return last5Ghzfrequency;
1831 }
1832
1833 /* freqBand = 0 => auto check */
1834 /* = 1 => 2.4 GHz band */
1835 /* = 2 => 5 GHz band */
1836 u16_t zfChNumToFreq(zdev_t* dev, u8_t ch, u8_t freqBand)
1837 {
1838 u16_t freq = 0xffff;
1839
1840 if ( freqBand == 0 )
1841 {
1842 if (ch > 14)
1843 { /* adapter is at 5 GHz band */
1844 freqBand = 2;
1845 }
1846 else
1847 {
1848 freqBand = 1;
1849 }
1850 }
1851
1852 if ( freqBand == 2 )
1853 { /* the channel belongs to 5 GHz band */
1854 if ( (ch >= 184)&&(ch <= 196) )
1855 {
1856 freq = 4000 + ch*5;
1857 }
1858 else
1859 {
1860 freq = 5000 + ch*5;
1861 }
1862 }
1863 else
1864 { /* the channel belongs to 2.4 GHz band */
1865 if ( ch == 14 )
1866 {
1867 freq = ZM_CH_G_14;
1868 }
1869 else
1870 {
1871 freq = ZM_CH_G_1 + (ch-1)*5;
1872 }
1873 }
1874
1875 return freq;
1876 }
1877
1878 u8_t zfChFreqToNum(u16_t freq, u8_t* pbIs5GBand)
1879 {
1880 u8_t ch;
1881 u8_t Is5GBand;
1882
1883 /* to avoid NULL value */
1884 if ( pbIs5GBand == NULL )
1885 {
1886 pbIs5GBand = &Is5GBand;
1887 }
1888
1889 *pbIs5GBand = FALSE;
1890
1891 if ( freq == ZM_CH_G_14 )
1892 {
1893 ch = 14;
1894 }
1895 else if ( freq < 4000 )
1896 {
1897 ch = (freq - ZM_CH_G_1) / 5 + 1;
1898 }
1899 else if ( freq < 5000 )
1900 {
1901 ch = (freq - 4000) / 5;
1902 *pbIs5GBand = TRUE;
1903 }
1904 else
1905 {
1906 ch = (freq - 5000) / 5;
1907 *pbIs5GBand = TRUE;
1908 }
1909
1910 return ch;
1911 }
Nao low-level kernelspace/userspace library that runs on our robots, Nao-Team HTWK