?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Staging: vt6656: use ETH_HLEN macro instead of custom one
[linux-2.6/x86.git] / drivers / staging / vt6656 / rxtx.c
blobc41105526a82a4ff6895120fe5a0a3583f992ae0
1 /*
2 * Copyright (c) 1996, 2003 VIA Networking Technologies, Inc.
3 * All rights reserved.
4 *
5 * This program is free software; you can redistribute it and/or modify
6 * it under the terms of the GNU General Public License as published by
7 * the Free Software Foundation; either version 2 of the License, or
8 * (at your option) any later version.
9 *
10 * This program is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 * GNU General Public License for more details.
14 *
15 * You should have received a copy of the GNU General Public License along
16 * with this program; if not, write to the Free Software Foundation, Inc.,
17 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
18 *
19 * File: rxtx.c
20 *
21 * Purpose: handle WMAC/802.3/802.11 rx & tx functions
22 *
23 * Author: Lyndon Chen
24 *
25 * Date: May 20, 2003
26 *
27 * Functions:
28 * s_vGenerateTxParameter - Generate tx dma requried parameter.
29 * s_vGenerateMACHeader - Translate 802.3 to 802.11 header
30 * csBeacon_xmit - beacon tx function
31 * csMgmt_xmit - management tx function
32 * s_uGetDataDuration - get tx data required duration
33 * s_uFillDataHead- fulfill tx data duration header
34 * s_uGetRTSCTSDuration- get rtx/cts requried duration
35 * s_uGetRTSCTSRsvTime- get rts/cts reserved time
36 * s_uGetTxRsvTime- get frame reserved time
37 * s_vFillCTSHead- fulfill CTS ctl header
38 * s_vFillFragParameter- Set fragement ctl parameter.
39 * s_vFillRTSHead- fulfill RTS ctl header
40 * s_vFillTxKey- fulfill tx encrypt key
41 * s_vSWencryption- Software encrypt header
42 * vDMA0_tx_80211- tx 802.11 frame via dma0
43 * vGenerateFIFOHeader- Generate tx FIFO ctl header
44 *
45 * Revision History:
46 *
47 */
48
49 #include "device.h"
50 #include "rxtx.h"
51 #include "tether.h"
52 #include "card.h"
53 #include "bssdb.h"
54 #include "mac.h"
55 #include "baseband.h"
56 #include "michael.h"
57 #include "tkip.h"
58 #include "tcrc.h"
59 #include "wctl.h"
60 #include "hostap.h"
61 #include "rf.h"
62 #include "datarate.h"
63 #include "usbpipe.h"
64
65 #ifdef WPA_SM_Transtatus
66 #include "iocmd.h"
67 #endif
68
69 /*--------------------- Static Definitions -------------------------*/
70
71 /*--------------------- Static Classes ----------------------------*/
72
73 /*--------------------- Static Variables --------------------------*/
74 //static int msglevel =MSG_LEVEL_DEBUG;
75 static int msglevel =MSG_LEVEL_INFO;
76
77 /*--------------------- Static Functions --------------------------*/
78
79 /*--------------------- Static Definitions -------------------------*/
80 #define CRITICAL_PACKET_LEN 256 // if packet size < 256 -> in-direct send
81 // packet size >= 256 -> direct send
82
83 const WORD wTimeStampOff[2][MAX_RATE] = {
84 {384, 288, 226, 209, 54, 43, 37, 31, 28, 25, 24, 23}, // Long Preamble
85 {384, 192, 130, 113, 54, 43, 37, 31, 28, 25, 24, 23}, // Short Preamble
86 };
87
88 const WORD wFB_Opt0[2][5] = {
89 {RATE_12M, RATE_18M, RATE_24M, RATE_36M, RATE_48M}, // fallback_rate0
90 {RATE_12M, RATE_12M, RATE_18M, RATE_24M, RATE_36M}, // fallback_rate1
91 };
92 const WORD wFB_Opt1[2][5] = {
93 {RATE_12M, RATE_18M, RATE_24M, RATE_24M, RATE_36M}, // fallback_rate0
94 {RATE_6M , RATE_6M, RATE_12M, RATE_12M, RATE_18M}, // fallback_rate1
95 };
96
97
98 #define RTSDUR_BB 0
99 #define RTSDUR_BA 1
100 #define RTSDUR_AA 2
101 #define CTSDUR_BA 3
102 #define RTSDUR_BA_F0 4
103 #define RTSDUR_AA_F0 5
104 #define RTSDUR_BA_F1 6
105 #define RTSDUR_AA_F1 7
106 #define CTSDUR_BA_F0 8
107 #define CTSDUR_BA_F1 9
108 #define DATADUR_B 10
109 #define DATADUR_A 11
110 #define DATADUR_A_F0 12
111 #define DATADUR_A_F1 13
112
113 /*--------------------- Static Functions --------------------------*/
114
115 static
116 void
117 s_vSaveTxPktInfo(
118 PSDevice pDevice,
119 BYTE byPktNum,
120 PBYTE pbyDestAddr,
121 WORD wPktLength,
122 WORD wFIFOCtl
123 );
124
125 static
126 void *
127 s_vGetFreeContext(
128 PSDevice pDevice
129 );
130
131
132 static
133 void
134 s_vGenerateTxParameter(
135 PSDevice pDevice,
136 BYTE byPktType,
137 WORD wCurrentRate,
138 void *pTxBufHead,
139 void *pvRrvTime,
140 void *pvRTS,
141 void *pvCTS,
142 unsigned int cbFrameSize,
143 BOOL bNeedACK,
144 unsigned int uDMAIdx,
145 PSEthernetHeader psEthHeader
146 );
147
148
149 static unsigned int s_uFillDataHead(
150 PSDevice pDevice,
151 BYTE byPktType,
152 WORD wCurrentRate,
153 void *pTxDataHead,
154 unsigned int cbFrameLength,
155 unsigned int uDMAIdx,
156 BOOL bNeedAck,
157 unsigned int uFragIdx,
158 unsigned int cbLastFragmentSize,
159 unsigned int uMACfragNum,
160 BYTE byFBOption
161 );
162
163
164
165
166 static
167 void
168 s_vGenerateMACHeader (
169 PSDevice pDevice,
170 PBYTE pbyBufferAddr,
171 WORD wDuration,
172 PSEthernetHeader psEthHeader,
173 BOOL bNeedEncrypt,
174 WORD wFragType,
175 unsigned int uDMAIdx,
176 unsigned int uFragIdx
177 );
178
179 static
180 void
181 s_vFillTxKey(
182 PSDevice pDevice,
183 PBYTE pbyBuf,
184 PBYTE pbyIVHead,
185 PSKeyItem pTransmitKey,
186 PBYTE pbyHdrBuf,
187 WORD wPayloadLen,
188 PBYTE pMICHDR
189 );
190
191 static
192 void
193 s_vSWencryption (
194 PSDevice pDevice,
195 PSKeyItem pTransmitKey,
196 PBYTE pbyPayloadHead,
197 WORD wPayloadSize
198 );
199
200 static unsigned int s_uGetTxRsvTime(
201 PSDevice pDevice,
202 BYTE byPktType,
203 unsigned int cbFrameLength,
204 WORD wRate,
205 BOOL bNeedAck
206 );
207
208
209 static unsigned int s_uGetRTSCTSRsvTime(
210 PSDevice pDevice,
211 BYTE byRTSRsvType,
212 BYTE byPktType,
213 unsigned int cbFrameLength,
214 WORD wCurrentRate
215 );
216
217 static
218 void
219 s_vFillCTSHead (
220 PSDevice pDevice,
221 unsigned int uDMAIdx,
222 BYTE byPktType,
223 void *pvCTS,
224 unsigned int cbFrameLength,
225 BOOL bNeedAck,
226 BOOL bDisCRC,
227 WORD wCurrentRate,
228 BYTE byFBOption
229 );
230
231 static
232 void
233 s_vFillRTSHead(
234 PSDevice pDevice,
235 BYTE byPktType,
236 void *pvRTS,
237 unsigned int cbFrameLength,
238 BOOL bNeedAck,
239 BOOL bDisCRC,
240 PSEthernetHeader psEthHeader,
241 WORD wCurrentRate,
242 BYTE byFBOption
243 );
244
245 static unsigned int s_uGetDataDuration(
246 PSDevice pDevice,
247 BYTE byDurType,
248 unsigned int cbFrameLength,
249 BYTE byPktType,
250 WORD wRate,
251 BOOL bNeedAck,
252 unsigned int uFragIdx,
253 unsigned int cbLastFragmentSize,
254 unsigned int uMACfragNum,
255 BYTE byFBOption
256 );
257
258
259 static
260 unsigned int
261 s_uGetRTSCTSDuration (
262 PSDevice pDevice,
263 BYTE byDurType,
264 unsigned int cbFrameLength,
265 BYTE byPktType,
266 WORD wRate,
267 BOOL bNeedAck,
268 BYTE byFBOption
269 );
270
271
272 /*--------------------- Export Variables --------------------------*/
273
274 static
275 void *
276 s_vGetFreeContext(
277 PSDevice pDevice
278 )
279 {
280 PUSB_SEND_CONTEXT pContext = NULL;
281 PUSB_SEND_CONTEXT pReturnContext = NULL;
282 unsigned int ii;
283
284 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"GetFreeContext()\n");
285
286 for (ii = 0; ii < pDevice->cbTD; ii++) {
287 pContext = pDevice->apTD[ii];
288 if (pContext->bBoolInUse == FALSE) {
289 pContext->bBoolInUse = TRUE;
290 pReturnContext = pContext;
291 break;
292 }
293 }
294 if ( ii == pDevice->cbTD ) {
295 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"No Free Tx Context\n");
296 }
297 return (void *) pReturnContext;
298 }
299
300
301 static
302 void
303 s_vSaveTxPktInfo(PSDevice pDevice, BYTE byPktNum, PBYTE pbyDestAddr, WORD wPktLength, WORD wFIFOCtl)
304 {
305 PSStatCounter pStatistic=&(pDevice->scStatistic);
306
307
308 if (IS_BROADCAST_ADDRESS(pbyDestAddr))
309 pStatistic->abyTxPktInfo[byPktNum].byBroadMultiUni = TX_PKT_BROAD;
310 else if (IS_MULTICAST_ADDRESS(pbyDestAddr))
311 pStatistic->abyTxPktInfo[byPktNum].byBroadMultiUni = TX_PKT_MULTI;
312 else
313 pStatistic->abyTxPktInfo[byPktNum].byBroadMultiUni = TX_PKT_UNI;
314
315 pStatistic->abyTxPktInfo[byPktNum].wLength = wPktLength;
316 pStatistic->abyTxPktInfo[byPktNum].wFIFOCtl = wFIFOCtl;
317 memcpy(pStatistic->abyTxPktInfo[byPktNum].abyDestAddr,
318 pbyDestAddr,
319 ETH_ALEN);
320 }
321
322
323
324
325 static
326 void
327 s_vFillTxKey (
328 PSDevice pDevice,
329 PBYTE pbyBuf,
330 PBYTE pbyIVHead,
331 PSKeyItem pTransmitKey,
332 PBYTE pbyHdrBuf,
333 WORD wPayloadLen,
334 PBYTE pMICHDR
335 )
336 {
337 PDWORD pdwIV = (PDWORD) pbyIVHead;
338 PDWORD pdwExtIV = (PDWORD) ((PBYTE)pbyIVHead+4);
339 WORD wValue;
340 PS802_11Header pMACHeader = (PS802_11Header)pbyHdrBuf;
341 DWORD dwRevIVCounter;
342
343
344
345 //Fill TXKEY
346 if (pTransmitKey == NULL)
347 return;
348
349 dwRevIVCounter = cpu_to_le32(pDevice->dwIVCounter);
350 *pdwIV = pDevice->dwIVCounter;
351 pDevice->byKeyIndex = pTransmitKey->dwKeyIndex & 0xf;
352
353 if (pTransmitKey->byCipherSuite == KEY_CTL_WEP) {
354 if (pTransmitKey->uKeyLength == WLAN_WEP232_KEYLEN ){
355 memcpy(pDevice->abyPRNG, (PBYTE)&(dwRevIVCounter), 3);
356 memcpy(pDevice->abyPRNG+3, pTransmitKey->abyKey, pTransmitKey->uKeyLength);
357 } else {
358 memcpy(pbyBuf, (PBYTE)&(dwRevIVCounter), 3);
359 memcpy(pbyBuf+3, pTransmitKey->abyKey, pTransmitKey->uKeyLength);
360 if(pTransmitKey->uKeyLength == WLAN_WEP40_KEYLEN) {
361 memcpy(pbyBuf+8, (PBYTE)&(dwRevIVCounter), 3);
362 memcpy(pbyBuf+11, pTransmitKey->abyKey, pTransmitKey->uKeyLength);
363 }
364 memcpy(pDevice->abyPRNG, pbyBuf, 16);
365 }
366 // Append IV after Mac Header
367 *pdwIV &= WEP_IV_MASK;//00000000 11111111 11111111 11111111
368 *pdwIV |= (pDevice->byKeyIndex << 30);
369 *pdwIV = cpu_to_le32(*pdwIV);
370 pDevice->dwIVCounter++;
371 if (pDevice->dwIVCounter > WEP_IV_MASK) {
372 pDevice->dwIVCounter = 0;
373 }
374 } else if (pTransmitKey->byCipherSuite == KEY_CTL_TKIP) {
375 pTransmitKey->wTSC15_0++;
376 if (pTransmitKey->wTSC15_0 == 0) {
377 pTransmitKey->dwTSC47_16++;
378 }
379 TKIPvMixKey(pTransmitKey->abyKey, pDevice->abyCurrentNetAddr,
380 pTransmitKey->wTSC15_0, pTransmitKey->dwTSC47_16, pDevice->abyPRNG);
381 memcpy(pbyBuf, pDevice->abyPRNG, 16);
382 // Make IV
383 memcpy(pdwIV, pDevice->abyPRNG, 3);
384
385 *(pbyIVHead+3) = (BYTE)(((pDevice->byKeyIndex << 6) & 0xc0) | 0x20); // 0x20 is ExtIV
386 // Append IV&ExtIV after Mac Header
387 *pdwExtIV = cpu_to_le32(pTransmitKey->dwTSC47_16);
388 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"vFillTxKey()---- pdwExtIV: %lx\n", *pdwExtIV);
389
390 } else if (pTransmitKey->byCipherSuite == KEY_CTL_CCMP) {
391 pTransmitKey->wTSC15_0++;
392 if (pTransmitKey->wTSC15_0 == 0) {
393 pTransmitKey->dwTSC47_16++;
394 }
395 memcpy(pbyBuf, pTransmitKey->abyKey, 16);
396
397 // Make IV
398 *pdwIV = 0;
399 *(pbyIVHead+3) = (BYTE)(((pDevice->byKeyIndex << 6) & 0xc0) | 0x20); // 0x20 is ExtIV
400 *pdwIV |= cpu_to_le16((WORD)(pTransmitKey->wTSC15_0));
401 //Append IV&ExtIV after Mac Header
402 *pdwExtIV = cpu_to_le32(pTransmitKey->dwTSC47_16);
403
404 //Fill MICHDR0
405 *pMICHDR = 0x59;
406 *((PBYTE)(pMICHDR+1)) = 0; // TxPriority
407 memcpy(pMICHDR+2, &(pMACHeader->abyAddr2[0]), 6);
408 *((PBYTE)(pMICHDR+8)) = HIBYTE(HIWORD(pTransmitKey->dwTSC47_16));
409 *((PBYTE)(pMICHDR+9)) = LOBYTE(HIWORD(pTransmitKey->dwTSC47_16));
410 *((PBYTE)(pMICHDR+10)) = HIBYTE(LOWORD(pTransmitKey->dwTSC47_16));
411 *((PBYTE)(pMICHDR+11)) = LOBYTE(LOWORD(pTransmitKey->dwTSC47_16));
412 *((PBYTE)(pMICHDR+12)) = HIBYTE(pTransmitKey->wTSC15_0);
413 *((PBYTE)(pMICHDR+13)) = LOBYTE(pTransmitKey->wTSC15_0);
414 *((PBYTE)(pMICHDR+14)) = HIBYTE(wPayloadLen);
415 *((PBYTE)(pMICHDR+15)) = LOBYTE(wPayloadLen);
416
417 //Fill MICHDR1
418 *((PBYTE)(pMICHDR+16)) = 0; // HLEN[15:8]
419 if (pDevice->bLongHeader) {
420 *((PBYTE)(pMICHDR+17)) = 28; // HLEN[7:0]
421 } else {
422 *((PBYTE)(pMICHDR+17)) = 22; // HLEN[7:0]
423 }
424 wValue = cpu_to_le16(pMACHeader->wFrameCtl & 0xC78F);
425 memcpy(pMICHDR+18, (PBYTE)&wValue, 2); // MSKFRACTL
426 memcpy(pMICHDR+20, &(pMACHeader->abyAddr1[0]), 6);
427 memcpy(pMICHDR+26, &(pMACHeader->abyAddr2[0]), 6);
428
429 //Fill MICHDR2
430 memcpy(pMICHDR+32, &(pMACHeader->abyAddr3[0]), 6);
431 wValue = pMACHeader->wSeqCtl;
432 wValue &= 0x000F;
433 wValue = cpu_to_le16(wValue);
434 memcpy(pMICHDR+38, (PBYTE)&wValue, 2); // MSKSEQCTL
435 if (pDevice->bLongHeader) {
436 memcpy(pMICHDR+40, &(pMACHeader->abyAddr4[0]), 6);
437 }
438 }
439 }
440
441
442 static
443 void
444 s_vSWencryption (
445 PSDevice pDevice,
446 PSKeyItem pTransmitKey,
447 PBYTE pbyPayloadHead,
448 WORD wPayloadSize
449 )
450 {
451 unsigned int cbICVlen = 4;
452 DWORD dwICV = 0xFFFFFFFFL;
453 PDWORD pdwICV;
454
455 if (pTransmitKey == NULL)
456 return;
457
458 if (pTransmitKey->byCipherSuite == KEY_CTL_WEP) {
459 //=======================================================================
460 // Append ICV after payload
461 dwICV = CRCdwGetCrc32Ex(pbyPayloadHead, wPayloadSize, dwICV);//ICV(Payload)
462 pdwICV = (PDWORD)(pbyPayloadHead + wPayloadSize);
463 // finally, we must invert dwCRC to get the correct answer
464 *pdwICV = cpu_to_le32(~dwICV);
465 // RC4 encryption
466 rc4_init(&pDevice->SBox, pDevice->abyPRNG, pTransmitKey->uKeyLength + 3);
467 rc4_encrypt(&pDevice->SBox, pbyPayloadHead, pbyPayloadHead, wPayloadSize+cbICVlen);
468 //=======================================================================
469 } else if (pTransmitKey->byCipherSuite == KEY_CTL_TKIP) {
470 //=======================================================================
471 //Append ICV after payload
472 dwICV = CRCdwGetCrc32Ex(pbyPayloadHead, wPayloadSize, dwICV);//ICV(Payload)
473 pdwICV = (PDWORD)(pbyPayloadHead + wPayloadSize);
474 // finally, we must invert dwCRC to get the correct answer
475 *pdwICV = cpu_to_le32(~dwICV);
476 // RC4 encryption
477 rc4_init(&pDevice->SBox, pDevice->abyPRNG, TKIP_KEY_LEN);
478 rc4_encrypt(&pDevice->SBox, pbyPayloadHead, pbyPayloadHead, wPayloadSize+cbICVlen);
479 //=======================================================================
480 }
481 }
482
483
484
485
486 /*byPktType : PK_TYPE_11A 0
487 PK_TYPE_11B 1
488 PK_TYPE_11GB 2
489 PK_TYPE_11GA 3
490 */
491 static
492 unsigned int
493 s_uGetTxRsvTime (
494 PSDevice pDevice,
495 BYTE byPktType,
496 unsigned int cbFrameLength,
497 WORD wRate,
498 BOOL bNeedAck
499 )
500 {
501 unsigned int uDataTime, uAckTime;
502
503 uDataTime = BBuGetFrameTime(pDevice->byPreambleType, byPktType, cbFrameLength, wRate);
504 if (byPktType == PK_TYPE_11B) {//llb,CCK mode
505 uAckTime = BBuGetFrameTime(pDevice->byPreambleType, byPktType, 14, (WORD)pDevice->byTopCCKBasicRate);
506 } else {//11g 2.4G OFDM mode & 11a 5G OFDM mode
507 uAckTime = BBuGetFrameTime(pDevice->byPreambleType, byPktType, 14, (WORD)pDevice->byTopOFDMBasicRate);
508 }
509
510 if (bNeedAck) {
511 return (uDataTime + pDevice->uSIFS + uAckTime);
512 }
513 else {
514 return uDataTime;
515 }
516 }
517
518 //byFreqType: 0=>5GHZ 1=>2.4GHZ
519 static
520 unsigned int
521 s_uGetRTSCTSRsvTime (
522 PSDevice pDevice,
523 BYTE byRTSRsvType,
524 BYTE byPktType,
525 unsigned int cbFrameLength,
526 WORD wCurrentRate
527 )
528 {
529 unsigned int uRrvTime , uRTSTime, uCTSTime, uAckTime, uDataTime;
530
531 uRrvTime = uRTSTime = uCTSTime = uAckTime = uDataTime = 0;
532
533
534 uDataTime = BBuGetFrameTime(pDevice->byPreambleType, byPktType, cbFrameLength, wCurrentRate);
535 if (byRTSRsvType == 0) { //RTSTxRrvTime_bb
536 uRTSTime = BBuGetFrameTime(pDevice->byPreambleType, byPktType, 20, pDevice->byTopCCKBasicRate);
537 uCTSTime = uAckTime = BBuGetFrameTime(pDevice->byPreambleType, byPktType, 14, pDevice->byTopCCKBasicRate);
538 }
539 else if (byRTSRsvType == 1){ //RTSTxRrvTime_ba, only in 2.4GHZ
540 uRTSTime = BBuGetFrameTime(pDevice->byPreambleType, byPktType, 20, pDevice->byTopCCKBasicRate);
541 uCTSTime = BBuGetFrameTime(pDevice->byPreambleType, byPktType, 14, pDevice->byTopCCKBasicRate);
542 uAckTime = BBuGetFrameTime(pDevice->byPreambleType, byPktType, 14, pDevice->byTopOFDMBasicRate);
543 }
544 else if (byRTSRsvType == 2) { //RTSTxRrvTime_aa
545 uRTSTime = BBuGetFrameTime(pDevice->byPreambleType, byPktType, 20, pDevice->byTopOFDMBasicRate);
546 uCTSTime = uAckTime = BBuGetFrameTime(pDevice->byPreambleType, byPktType, 14, pDevice->byTopOFDMBasicRate);
547 }
548 else if (byRTSRsvType == 3) { //CTSTxRrvTime_ba, only in 2.4GHZ
549 uCTSTime = BBuGetFrameTime(pDevice->byPreambleType, byPktType, 14, pDevice->byTopCCKBasicRate);
550 uAckTime = BBuGetFrameTime(pDevice->byPreambleType, byPktType, 14, pDevice->byTopOFDMBasicRate);
551 uRrvTime = uCTSTime + uAckTime + uDataTime + 2*pDevice->uSIFS;
552 return uRrvTime;
553 }
554
555 //RTSRrvTime
556 uRrvTime = uRTSTime + uCTSTime + uAckTime + uDataTime + 3*pDevice->uSIFS;
557 return uRrvTime;
558 }
559
560 //byFreqType 0: 5GHz, 1:2.4Ghz
561 static
562 unsigned int
563 s_uGetDataDuration (
564 PSDevice pDevice,
565 BYTE byDurType,
566 unsigned int cbFrameLength,
567 BYTE byPktType,
568 WORD wRate,
569 BOOL bNeedAck,
570 unsigned int uFragIdx,
571 unsigned int cbLastFragmentSize,
572 unsigned int uMACfragNum,
573 BYTE byFBOption
574 )
575 {
576 BOOL bLastFrag = 0;
577 unsigned int uAckTime = 0, uNextPktTime = 0;
578
579 if (uFragIdx == (uMACfragNum-1)) {
580 bLastFrag = 1;
581 }
582
583 switch (byDurType) {
584
585 case DATADUR_B: //DATADUR_B
586 if (((uMACfragNum == 1)) || (bLastFrag == 1)) {//Non Frag or Last Frag
587 if (bNeedAck) {
588 uAckTime = BBuGetFrameTime(pDevice->byPreambleType, byPktType, 14, pDevice->byTopCCKBasicRate);
589 return (pDevice->uSIFS + uAckTime);
590 } else {
591 return 0;
592 }
593 }
594 else {//First Frag or Mid Frag
595 if (uFragIdx == (uMACfragNum-2)) {
596 uNextPktTime = s_uGetTxRsvTime(pDevice, byPktType, cbLastFragmentSize, wRate, bNeedAck);
597 } else {
598 uNextPktTime = s_uGetTxRsvTime(pDevice, byPktType, cbFrameLength, wRate, bNeedAck);
599 }
600 if (bNeedAck) {
601 uAckTime = BBuGetFrameTime(pDevice->byPreambleType, byPktType, 14, pDevice->byTopCCKBasicRate);
602 return (pDevice->uSIFS + uAckTime + uNextPktTime);
603 } else {
604 return (pDevice->uSIFS + uNextPktTime);
605 }
606 }
607 break;
608
609
610 case DATADUR_A: //DATADUR_A
611 if (((uMACfragNum==1)) || (bLastFrag==1)) {//Non Frag or Last Frag
612 if(bNeedAck){
613 uAckTime = BBuGetFrameTime(pDevice->byPreambleType, byPktType, 14, pDevice->byTopOFDMBasicRate);
614 return (pDevice->uSIFS + uAckTime);
615 } else {
616 return 0;
617 }
618 }
619 else {//First Frag or Mid Frag
620 if(uFragIdx == (uMACfragNum-2)){
621 uNextPktTime = s_uGetTxRsvTime(pDevice, byPktType, cbLastFragmentSize, wRate, bNeedAck);
622 } else {
623 uNextPktTime = s_uGetTxRsvTime(pDevice, byPktType, cbFrameLength, wRate, bNeedAck);
624 }
625 if(bNeedAck){
626 uAckTime = BBuGetFrameTime(pDevice->byPreambleType, byPktType, 14, pDevice->byTopOFDMBasicRate);
627 return (pDevice->uSIFS + uAckTime + uNextPktTime);
628 } else {
629 return (pDevice->uSIFS + uNextPktTime);
630 }
631 }
632 break;
633
634 case DATADUR_A_F0: //DATADUR_A_F0
635 if (((uMACfragNum==1)) || (bLastFrag==1)) {//Non Frag or Last Frag
636 if(bNeedAck){
637 uAckTime = BBuGetFrameTime(pDevice->byPreambleType, byPktType, 14, pDevice->byTopOFDMBasicRate);
638 return (pDevice->uSIFS + uAckTime);
639 } else {
640 return 0;
641 }
642 }
643 else { //First Frag or Mid Frag
644 if (byFBOption == AUTO_FB_0) {
645 if (wRate < RATE_18M)
646 wRate = RATE_18M;
647 else if (wRate > RATE_54M)
648 wRate = RATE_54M;
649
650 if(uFragIdx == (uMACfragNum-2)){
651 uNextPktTime = s_uGetTxRsvTime(pDevice, byPktType, cbLastFragmentSize, wFB_Opt0[FB_RATE0][wRate-RATE_18M], bNeedAck);
652 } else {
653 uNextPktTime = s_uGetTxRsvTime(pDevice, byPktType, cbFrameLength, wFB_Opt0[FB_RATE0][wRate-RATE_18M], bNeedAck);
654 }
655 } else { // (byFBOption == AUTO_FB_1)
656 if (wRate < RATE_18M)
657 wRate = RATE_18M;
658 else if (wRate > RATE_54M)
659 wRate = RATE_54M;
660
661 if(uFragIdx == (uMACfragNum-2)){
662 uNextPktTime = s_uGetTxRsvTime(pDevice, byPktType, cbLastFragmentSize, wFB_Opt1[FB_RATE0][wRate-RATE_18M], bNeedAck);
663 } else {
664 uNextPktTime = s_uGetTxRsvTime(pDevice, byPktType, cbFrameLength, wFB_Opt1[FB_RATE0][wRate-RATE_18M], bNeedAck);
665 }
666 }
667
668 if(bNeedAck){
669 uAckTime = BBuGetFrameTime(pDevice->byPreambleType, byPktType, 14, pDevice->byTopOFDMBasicRate);
670 return (pDevice->uSIFS + uAckTime + uNextPktTime);
671 } else {
672 return (pDevice->uSIFS + uNextPktTime);
673 }
674 }
675 break;
676
677 case DATADUR_A_F1: //DATADUR_A_F1
678 if (((uMACfragNum==1)) || (bLastFrag==1)) {//Non Frag or Last Frag
679 if(bNeedAck){
680 uAckTime = BBuGetFrameTime(pDevice->byPreambleType, byPktType, 14, pDevice->byTopOFDMBasicRate);
681 return (pDevice->uSIFS + uAckTime);
682 } else {
683 return 0;
684 }
685 }
686 else { //First Frag or Mid Frag
687 if (byFBOption == AUTO_FB_0) {
688 if (wRate < RATE_18M)
689 wRate = RATE_18M;
690 else if (wRate > RATE_54M)
691 wRate = RATE_54M;
692
693 if(uFragIdx == (uMACfragNum-2)){
694 uNextPktTime = s_uGetTxRsvTime(pDevice, byPktType, cbLastFragmentSize, wFB_Opt0[FB_RATE1][wRate-RATE_18M], bNeedAck);
695 } else {
696 uNextPktTime = s_uGetTxRsvTime(pDevice, byPktType, cbFrameLength, wFB_Opt0[FB_RATE1][wRate-RATE_18M], bNeedAck);
697 }
698
699 } else { // (byFBOption == AUTO_FB_1)
700 if (wRate < RATE_18M)
701 wRate = RATE_18M;
702 else if (wRate > RATE_54M)
703 wRate = RATE_54M;
704
705 if(uFragIdx == (uMACfragNum-2)){
706 uNextPktTime = s_uGetTxRsvTime(pDevice, byPktType, cbLastFragmentSize, wFB_Opt1[FB_RATE1][wRate-RATE_18M], bNeedAck);
707 } else {
708 uNextPktTime = s_uGetTxRsvTime(pDevice, byPktType, cbFrameLength, wFB_Opt1[FB_RATE1][wRate-RATE_18M], bNeedAck);
709 }
710 }
711 if(bNeedAck){
712 uAckTime = BBuGetFrameTime(pDevice->byPreambleType, byPktType, 14, pDevice->byTopOFDMBasicRate);
713 return (pDevice->uSIFS + uAckTime + uNextPktTime);
714 } else {
715 return (pDevice->uSIFS + uNextPktTime);
716 }
717 }
718 break;
719
720 default:
721 break;
722 }
723
724 ASSERT(FALSE);
725 return 0;
726 }
727
728
729 //byFreqType: 0=>5GHZ 1=>2.4GHZ
730 static
731 unsigned int
732 s_uGetRTSCTSDuration (
733 PSDevice pDevice,
734 BYTE byDurType,
735 unsigned int cbFrameLength,
736 BYTE byPktType,
737 WORD wRate,
738 BOOL bNeedAck,
739 BYTE byFBOption
740 )
741 {
742 unsigned int uCTSTime = 0, uDurTime = 0;
743
744
745 switch (byDurType) {
746
747 case RTSDUR_BB: //RTSDuration_bb
748 uCTSTime = BBuGetFrameTime(pDevice->byPreambleType, byPktType, 14, pDevice->byTopCCKBasicRate);
749 uDurTime = uCTSTime + 2*pDevice->uSIFS + s_uGetTxRsvTime(pDevice, byPktType, cbFrameLength, wRate, bNeedAck);
750 break;
751
752 case RTSDUR_BA: //RTSDuration_ba
753 uCTSTime = BBuGetFrameTime(pDevice->byPreambleType, byPktType, 14, pDevice->byTopCCKBasicRate);
754 uDurTime = uCTSTime + 2*pDevice->uSIFS + s_uGetTxRsvTime(pDevice, byPktType, cbFrameLength, wRate, bNeedAck);
755 break;
756
757 case RTSDUR_AA: //RTSDuration_aa
758 uCTSTime = BBuGetFrameTime(pDevice->byPreambleType, byPktType, 14, pDevice->byTopOFDMBasicRate);
759 uDurTime = uCTSTime + 2*pDevice->uSIFS + s_uGetTxRsvTime(pDevice, byPktType, cbFrameLength, wRate, bNeedAck);
760 break;
761
762 case CTSDUR_BA: //CTSDuration_ba
763 uDurTime = pDevice->uSIFS + s_uGetTxRsvTime(pDevice, byPktType, cbFrameLength, wRate, bNeedAck);
764 break;
765
766 case RTSDUR_BA_F0: //RTSDuration_ba_f0
767 uCTSTime = BBuGetFrameTime(pDevice->byPreambleType, byPktType, 14, pDevice->byTopCCKBasicRate);
768 if ((byFBOption == AUTO_FB_0) && (wRate >= RATE_18M) && (wRate <=RATE_54M)) {
769 uDurTime = uCTSTime + 2*pDevice->uSIFS + s_uGetTxRsvTime(pDevice, byPktType, cbFrameLength, wFB_Opt0[FB_RATE0][wRate-RATE_18M], bNeedAck);
770 } else if ((byFBOption == AUTO_FB_1) && (wRate >= RATE_18M) && (wRate <=RATE_54M)) {
771 uDurTime = uCTSTime + 2*pDevice->uSIFS + s_uGetTxRsvTime(pDevice, byPktType, cbFrameLength, wFB_Opt1[FB_RATE0][wRate-RATE_18M], bNeedAck);
772 }
773 break;
774
775 case RTSDUR_AA_F0: //RTSDuration_aa_f0
776 uCTSTime = BBuGetFrameTime(pDevice->byPreambleType, byPktType, 14, pDevice->byTopOFDMBasicRate);
777 if ((byFBOption == AUTO_FB_0) && (wRate >= RATE_18M) && (wRate <=RATE_54M)) {
778 uDurTime = uCTSTime + 2*pDevice->uSIFS + s_uGetTxRsvTime(pDevice, byPktType, cbFrameLength, wFB_Opt0[FB_RATE0][wRate-RATE_18M], bNeedAck);
779 } else if ((byFBOption == AUTO_FB_1) && (wRate >= RATE_18M) && (wRate <=RATE_54M)) {
780 uDurTime = uCTSTime + 2*pDevice->uSIFS + s_uGetTxRsvTime(pDevice, byPktType, cbFrameLength, wFB_Opt1[FB_RATE0][wRate-RATE_18M], bNeedAck);
781 }
782 break;
783
784 case RTSDUR_BA_F1: //RTSDuration_ba_f1
785 uCTSTime = BBuGetFrameTime(pDevice->byPreambleType, byPktType, 14, pDevice->byTopCCKBasicRate);
786 if ((byFBOption == AUTO_FB_0) && (wRate >= RATE_18M) && (wRate <=RATE_54M)) {
787 uDurTime = uCTSTime + 2*pDevice->uSIFS + s_uGetTxRsvTime(pDevice, byPktType, cbFrameLength, wFB_Opt0[FB_RATE1][wRate-RATE_18M], bNeedAck);
788 } else if ((byFBOption == AUTO_FB_1) && (wRate >= RATE_18M) && (wRate <=RATE_54M)) {
789 uDurTime = uCTSTime + 2*pDevice->uSIFS + s_uGetTxRsvTime(pDevice, byPktType, cbFrameLength, wFB_Opt1[FB_RATE1][wRate-RATE_18M], bNeedAck);
790 }
791 break;
792
793 case RTSDUR_AA_F1: //RTSDuration_aa_f1
794 uCTSTime = BBuGetFrameTime(pDevice->byPreambleType, byPktType, 14, pDevice->byTopOFDMBasicRate);
795 if ((byFBOption == AUTO_FB_0) && (wRate >= RATE_18M) && (wRate <=RATE_54M)) {
796 uDurTime = uCTSTime + 2*pDevice->uSIFS + s_uGetTxRsvTime(pDevice, byPktType, cbFrameLength, wFB_Opt0[FB_RATE1][wRate-RATE_18M], bNeedAck);
797 } else if ((byFBOption == AUTO_FB_1) && (wRate >= RATE_18M) && (wRate <=RATE_54M)) {
798 uDurTime = uCTSTime + 2*pDevice->uSIFS + s_uGetTxRsvTime(pDevice, byPktType, cbFrameLength, wFB_Opt1[FB_RATE1][wRate-RATE_18M], bNeedAck);
799 }
800 break;
801
802 case CTSDUR_BA_F0: //CTSDuration_ba_f0
803 if ((byFBOption == AUTO_FB_0) && (wRate >= RATE_18M) && (wRate <=RATE_54M)) {
804 uDurTime = pDevice->uSIFS + s_uGetTxRsvTime(pDevice, byPktType, cbFrameLength, wFB_Opt0[FB_RATE0][wRate-RATE_18M], bNeedAck);
805 } else if ((byFBOption == AUTO_FB_1) && (wRate >= RATE_18M) && (wRate <=RATE_54M)) {
806 uDurTime = pDevice->uSIFS + s_uGetTxRsvTime(pDevice, byPktType, cbFrameLength, wFB_Opt1[FB_RATE0][wRate-RATE_18M], bNeedAck);
807 }
808 break;
809
810 case CTSDUR_BA_F1: //CTSDuration_ba_f1
811 if ((byFBOption == AUTO_FB_0) && (wRate >= RATE_18M) && (wRate <=RATE_54M)) {
812 uDurTime = pDevice->uSIFS + s_uGetTxRsvTime(pDevice, byPktType, cbFrameLength, wFB_Opt0[FB_RATE1][wRate-RATE_18M], bNeedAck);
813 } else if ((byFBOption == AUTO_FB_1) && (wRate >= RATE_18M) && (wRate <=RATE_54M)) {
814 uDurTime = pDevice->uSIFS + s_uGetTxRsvTime(pDevice, byPktType, cbFrameLength, wFB_Opt1[FB_RATE1][wRate-RATE_18M], bNeedAck);
815 }
816 break;
817
818 default:
819 break;
820 }
821
822 return uDurTime;
823
824 }
825
826
827
828
829 static
830 unsigned int
831 s_uFillDataHead (
832 PSDevice pDevice,
833 BYTE byPktType,
834 WORD wCurrentRate,
835 void *pTxDataHead,
836 unsigned int cbFrameLength,
837 unsigned int uDMAIdx,
838 BOOL bNeedAck,
839 unsigned int uFragIdx,
840 unsigned int cbLastFragmentSize,
841 unsigned int uMACfragNum,
842 BYTE byFBOption
843 )
844 {
845
846 if (pTxDataHead == NULL) {
847 return 0;
848 }
849
850 if (byPktType == PK_TYPE_11GB || byPktType == PK_TYPE_11GA) {
851 if((uDMAIdx==TYPE_ATIMDMA)||(uDMAIdx==TYPE_BEACONDMA)) {
852 PSTxDataHead_ab pBuf = (PSTxDataHead_ab)pTxDataHead;
853 //Get SignalField,ServiceField,Length
854 BBvCaculateParameter(pDevice, cbFrameLength, wCurrentRate, byPktType,
855 (PWORD)&(pBuf->wTransmitLength), (PBYTE)&(pBuf->byServiceField), (PBYTE)&(pBuf->bySignalField)
856 );
857 //Get Duration and TimeStampOff
858 pBuf->wDuration = (WORD)s_uGetDataDuration(pDevice, DATADUR_A, cbFrameLength, byPktType,
859 wCurrentRate, bNeedAck, uFragIdx,
860 cbLastFragmentSize, uMACfragNum,
861 byFBOption); //1: 2.4GHz
862 if(uDMAIdx!=TYPE_ATIMDMA) {
863 pBuf->wTimeStampOff = wTimeStampOff[pDevice->byPreambleType%2][wCurrentRate%MAX_RATE];
864 }
865 return (pBuf->wDuration);
866 }
867 else { // DATA & MANAGE Frame
868 if (byFBOption == AUTO_FB_NONE) {
869 PSTxDataHead_g pBuf = (PSTxDataHead_g)pTxDataHead;
870 //Get SignalField,ServiceField,Length
871 BBvCaculateParameter(pDevice, cbFrameLength, wCurrentRate, byPktType,
872 (PWORD)&(pBuf->wTransmitLength_a), (PBYTE)&(pBuf->byServiceField_a), (PBYTE)&(pBuf->bySignalField_a)
873 );
874 BBvCaculateParameter(pDevice, cbFrameLength, pDevice->byTopCCKBasicRate, PK_TYPE_11B,
875 (PWORD)&(pBuf->wTransmitLength_b), (PBYTE)&(pBuf->byServiceField_b), (PBYTE)&(pBuf->bySignalField_b)
876 );
877 //Get Duration and TimeStamp
878 pBuf->wDuration_a = (WORD)s_uGetDataDuration(pDevice, DATADUR_A, cbFrameLength,
879 byPktType, wCurrentRate, bNeedAck, uFragIdx,
880 cbLastFragmentSize, uMACfragNum,
881 byFBOption); //1: 2.4GHz
882 pBuf->wDuration_b = (WORD)s_uGetDataDuration(pDevice, DATADUR_B, cbFrameLength,
883 PK_TYPE_11B, pDevice->byTopCCKBasicRate,
884 bNeedAck, uFragIdx, cbLastFragmentSize,
885 uMACfragNum, byFBOption); //1: 2.4GHz
886
887 pBuf->wTimeStampOff_a = wTimeStampOff[pDevice->byPreambleType%2][wCurrentRate%MAX_RATE];
888 pBuf->wTimeStampOff_b = wTimeStampOff[pDevice->byPreambleType%2][pDevice->byTopCCKBasicRate%MAX_RATE];
889 return (pBuf->wDuration_a);
890 } else {
891 // Auto Fallback
892 PSTxDataHead_g_FB pBuf = (PSTxDataHead_g_FB)pTxDataHead;
893 //Get SignalField,ServiceField,Length
894 BBvCaculateParameter(pDevice, cbFrameLength, wCurrentRate, byPktType,
895 (PWORD)&(pBuf->wTransmitLength_a), (PBYTE)&(pBuf->byServiceField_a), (PBYTE)&(pBuf->bySignalField_a)
896 );
897 BBvCaculateParameter(pDevice, cbFrameLength, pDevice->byTopCCKBasicRate, PK_TYPE_11B,
898 (PWORD)&(pBuf->wTransmitLength_b), (PBYTE)&(pBuf->byServiceField_b), (PBYTE)&(pBuf->bySignalField_b)
899 );
900 //Get Duration and TimeStamp
901 pBuf->wDuration_a = (WORD)s_uGetDataDuration(pDevice, DATADUR_A, cbFrameLength, byPktType,
902 wCurrentRate, bNeedAck, uFragIdx, cbLastFragmentSize, uMACfragNum, byFBOption); //1: 2.4GHz
903 pBuf->wDuration_b = (WORD)s_uGetDataDuration(pDevice, DATADUR_B, cbFrameLength, PK_TYPE_11B,
904 pDevice->byTopCCKBasicRate, bNeedAck, uFragIdx, cbLastFragmentSize, uMACfragNum, byFBOption); //1: 2.4GHz
905 pBuf->wDuration_a_f0 = (WORD)s_uGetDataDuration(pDevice, DATADUR_A_F0, cbFrameLength, byPktType,
906 wCurrentRate, bNeedAck, uFragIdx, cbLastFragmentSize, uMACfragNum, byFBOption); //1: 2.4GHz
907 pBuf->wDuration_a_f1 = (WORD)s_uGetDataDuration(pDevice, DATADUR_A_F1, cbFrameLength, byPktType,
908 wCurrentRate, bNeedAck, uFragIdx, cbLastFragmentSize, uMACfragNum, byFBOption); //1: 2.4GHz
909 pBuf->wTimeStampOff_a = wTimeStampOff[pDevice->byPreambleType%2][wCurrentRate%MAX_RATE];
910 pBuf->wTimeStampOff_b = wTimeStampOff[pDevice->byPreambleType%2][pDevice->byTopCCKBasicRate%MAX_RATE];
911 return (pBuf->wDuration_a);
912 } //if (byFBOption == AUTO_FB_NONE)
913 }
914 }
915 else if (byPktType == PK_TYPE_11A) {
916 if ((byFBOption != AUTO_FB_NONE) && (uDMAIdx != TYPE_ATIMDMA) && (uDMAIdx != TYPE_BEACONDMA)) {
917 // Auto Fallback
918 PSTxDataHead_a_FB pBuf = (PSTxDataHead_a_FB)pTxDataHead;
919 //Get SignalField,ServiceField,Length
920 BBvCaculateParameter(pDevice, cbFrameLength, wCurrentRate, byPktType,
921 (PWORD)&(pBuf->wTransmitLength), (PBYTE)&(pBuf->byServiceField), (PBYTE)&(pBuf->bySignalField)
922 );
923 //Get Duration and TimeStampOff
924 pBuf->wDuration = (WORD)s_uGetDataDuration(pDevice, DATADUR_A, cbFrameLength, byPktType,
925 wCurrentRate, bNeedAck, uFragIdx, cbLastFragmentSize, uMACfragNum, byFBOption); //0: 5GHz
926 pBuf->wDuration_f0 = (WORD)s_uGetDataDuration(pDevice, DATADUR_A_F0, cbFrameLength, byPktType,
927 wCurrentRate, bNeedAck, uFragIdx, cbLastFragmentSize, uMACfragNum, byFBOption); //0: 5GHz
928 pBuf->wDuration_f1 = (WORD)s_uGetDataDuration(pDevice, DATADUR_A_F1, cbFrameLength, byPktType,
929 wCurrentRate, bNeedAck, uFragIdx, cbLastFragmentSize, uMACfragNum, byFBOption); //0: 5GHz
930 if(uDMAIdx!=TYPE_ATIMDMA) {
931 pBuf->wTimeStampOff = wTimeStampOff[pDevice->byPreambleType%2][wCurrentRate%MAX_RATE];
932 }
933 return (pBuf->wDuration);
934 } else {
935 PSTxDataHead_ab pBuf = (PSTxDataHead_ab)pTxDataHead;
936 //Get SignalField,ServiceField,Length
937 BBvCaculateParameter(pDevice, cbFrameLength, wCurrentRate, byPktType,
938 (PWORD)&(pBuf->wTransmitLength), (PBYTE)&(pBuf->byServiceField), (PBYTE)&(pBuf->bySignalField)
939 );
940 //Get Duration and TimeStampOff
941 pBuf->wDuration = (WORD)s_uGetDataDuration(pDevice, DATADUR_A, cbFrameLength, byPktType,
942 wCurrentRate, bNeedAck, uFragIdx,
943 cbLastFragmentSize, uMACfragNum,
944 byFBOption);
945
946 if(uDMAIdx!=TYPE_ATIMDMA) {
947 pBuf->wTimeStampOff = wTimeStampOff[pDevice->byPreambleType%2][wCurrentRate%MAX_RATE];
948 }
949 return (pBuf->wDuration);
950 }
951 }
952 else if (byPktType == PK_TYPE_11B) {
953 PSTxDataHead_ab pBuf = (PSTxDataHead_ab)pTxDataHead;
954 //Get SignalField,ServiceField,Length
955 BBvCaculateParameter(pDevice, cbFrameLength, wCurrentRate, byPktType,
956 (PWORD)&(pBuf->wTransmitLength), (PBYTE)&(pBuf->byServiceField), (PBYTE)&(pBuf->bySignalField)
957 );
958 //Get Duration and TimeStampOff
959 pBuf->wDuration = (WORD)s_uGetDataDuration(pDevice, DATADUR_B, cbFrameLength, byPktType,
960 wCurrentRate, bNeedAck, uFragIdx,
961 cbLastFragmentSize, uMACfragNum,
962 byFBOption);
963 if (uDMAIdx != TYPE_ATIMDMA) {
964 pBuf->wTimeStampOff = wTimeStampOff[pDevice->byPreambleType%2][wCurrentRate%MAX_RATE];
965 }
966 return (pBuf->wDuration);
967 }
968 return 0;
969 }
970
971
972
973
974 static
975 void
976 s_vFillRTSHead (
977 PSDevice pDevice,
978 BYTE byPktType,
979 void *pvRTS,
980 unsigned int cbFrameLength,
981 BOOL bNeedAck,
982 BOOL bDisCRC,
983 PSEthernetHeader psEthHeader,
984 WORD wCurrentRate,
985 BYTE byFBOption
986 )
987 {
988 unsigned int uRTSFrameLen = 20;
989 WORD wLen = 0x0000;
990
991 if (pvRTS == NULL)
992 return;
993
994 if (bDisCRC) {
995 // When CRCDIS bit is on, H/W forgot to generate FCS for RTS frame,
996 // in this case we need to decrease its length by 4.
997 uRTSFrameLen -= 4;
998 }
999
1000 // Note: So far RTSHead dosen't appear in ATIM & Beacom DMA, so we don't need to take them into account.
1001 // Otherwise, we need to modified codes for them.
1002 if (byPktType == PK_TYPE_11GB || byPktType == PK_TYPE_11GA) {
1003 if (byFBOption == AUTO_FB_NONE) {
1004 PSRTS_g pBuf = (PSRTS_g)pvRTS;
1005 //Get SignalField,ServiceField,Length
1006 BBvCaculateParameter(pDevice, uRTSFrameLen, pDevice->byTopCCKBasicRate, PK_TYPE_11B,
1007 (PWORD)&(wLen), (PBYTE)&(pBuf->byServiceField_b), (PBYTE)&(pBuf->bySignalField_b)
1008 );
1009 pBuf->wTransmitLength_b = cpu_to_le16(wLen);
1010 BBvCaculateParameter(pDevice, uRTSFrameLen, pDevice->byTopOFDMBasicRate, byPktType,
1011 (PWORD)&(wLen), (PBYTE)&(pBuf->byServiceField_a), (PBYTE)&(pBuf->bySignalField_a)
1012 );
1013 pBuf->wTransmitLength_a = cpu_to_le16(wLen);
1014 //Get Duration
1015 pBuf->wDuration_bb = cpu_to_le16((WORD)s_uGetRTSCTSDuration(pDevice, RTSDUR_BB, cbFrameLength, PK_TYPE_11B, pDevice->byTopCCKBasicRate, bNeedAck, byFBOption)); //0:RTSDuration_bb, 1:2.4G, 1:CCKData
1016 pBuf->wDuration_aa = cpu_to_le16((WORD)s_uGetRTSCTSDuration(pDevice, RTSDUR_AA, cbFrameLength, byPktType, wCurrentRate, bNeedAck, byFBOption)); //2:RTSDuration_aa, 1:2.4G, 2,3: 2.4G OFDMData
1017 pBuf->wDuration_ba = cpu_to_le16((WORD)s_uGetRTSCTSDuration(pDevice, RTSDUR_BA, cbFrameLength, byPktType, wCurrentRate, bNeedAck, byFBOption)); //1:RTSDuration_ba, 1:2.4G, 2,3:2.4G OFDM Data
1018
1019 pBuf->Data.wDurationID = pBuf->wDuration_aa;
1020 //Get RTS Frame body
1021 pBuf->Data.wFrameControl = TYPE_CTL_RTS;//0x00B4
1022
1023 if ((pDevice->eOPMode == OP_MODE_ADHOC) ||
1024 (pDevice->eOPMode == OP_MODE_AP)) {
1025 memcpy(&(pBuf->Data.abyRA[0]),
1026 &(psEthHeader->abyDstAddr[0]),
1027 ETH_ALEN);
1028 }
1029 else {
1030 memcpy(&(pBuf->Data.abyRA[0]),
1031 &(pDevice->abyBSSID[0]),
1032 ETH_ALEN);
1033 }
1034 if (pDevice->eOPMode == OP_MODE_AP) {
1035 memcpy(&(pBuf->Data.abyTA[0]),
1036 &(pDevice->abyBSSID[0]),
1037 ETH_ALEN);
1038 }
1039 else {
1040 memcpy(&(pBuf->Data.abyTA[0]),
1041 &(psEthHeader->abySrcAddr[0]),
1042 ETH_ALEN);
1043 }
1044 }
1045 else {
1046 PSRTS_g_FB pBuf = (PSRTS_g_FB)pvRTS;
1047 //Get SignalField,ServiceField,Length
1048 BBvCaculateParameter(pDevice, uRTSFrameLen, pDevice->byTopCCKBasicRate, PK_TYPE_11B,
1049 (PWORD)&(wLen), (PBYTE)&(pBuf->byServiceField_b), (PBYTE)&(pBuf->bySignalField_b)
1050 );
1051 pBuf->wTransmitLength_b = cpu_to_le16(wLen);
1052 BBvCaculateParameter(pDevice, uRTSFrameLen, pDevice->byTopOFDMBasicRate, byPktType,
1053 (PWORD)&(wLen), (PBYTE)&(pBuf->byServiceField_a), (PBYTE)&(pBuf->bySignalField_a)
1054 );
1055 pBuf->wTransmitLength_a = cpu_to_le16(wLen);
1056 //Get Duration
1057 pBuf->wDuration_bb = cpu_to_le16((WORD)s_uGetRTSCTSDuration(pDevice, RTSDUR_BB, cbFrameLength, PK_TYPE_11B, pDevice->byTopCCKBasicRate, bNeedAck, byFBOption)); //0:RTSDuration_bb, 1:2.4G, 1:CCKData
1058 pBuf->wDuration_aa = cpu_to_le16((WORD)s_uGetRTSCTSDuration(pDevice, RTSDUR_AA, cbFrameLength, byPktType, wCurrentRate, bNeedAck, byFBOption)); //2:RTSDuration_aa, 1:2.4G, 2,3:2.4G OFDMData
1059 pBuf->wDuration_ba = cpu_to_le16((WORD)s_uGetRTSCTSDuration(pDevice, RTSDUR_BA, cbFrameLength, byPktType, wCurrentRate, bNeedAck, byFBOption)); //1:RTSDuration_ba, 1:2.4G, 2,3:2.4G OFDMData
1060 pBuf->wRTSDuration_ba_f0 = cpu_to_le16((WORD)s_uGetRTSCTSDuration(pDevice, RTSDUR_BA_F0, cbFrameLength, byPktType, wCurrentRate, bNeedAck, byFBOption)); //4:wRTSDuration_ba_f0, 1:2.4G, 1:CCKData
1061 pBuf->wRTSDuration_aa_f0 = cpu_to_le16((WORD)s_uGetRTSCTSDuration(pDevice, RTSDUR_AA_F0, cbFrameLength, byPktType, wCurrentRate, bNeedAck, byFBOption)); //5:wRTSDuration_aa_f0, 1:2.4G, 1:CCKData
1062 pBuf->wRTSDuration_ba_f1 = cpu_to_le16((WORD)s_uGetRTSCTSDuration(pDevice, RTSDUR_BA_F1, cbFrameLength, byPktType, wCurrentRate, bNeedAck, byFBOption)); //6:wRTSDuration_ba_f1, 1:2.4G, 1:CCKData
1063 pBuf->wRTSDuration_aa_f1 = cpu_to_le16((WORD)s_uGetRTSCTSDuration(pDevice, RTSDUR_AA_F1, cbFrameLength, byPktType, wCurrentRate, bNeedAck, byFBOption)); //7:wRTSDuration_aa_f1, 1:2.4G, 1:CCKData
1064 pBuf->Data.wDurationID = pBuf->wDuration_aa;
1065 //Get RTS Frame body
1066 pBuf->Data.wFrameControl = TYPE_CTL_RTS;//0x00B4
1067
1068 if ((pDevice->eOPMode == OP_MODE_ADHOC) ||
1069 (pDevice->eOPMode == OP_MODE_AP)) {
1070 memcpy(&(pBuf->Data.abyRA[0]),
1071 &(psEthHeader->abyDstAddr[0]),
1072 ETH_ALEN);
1073 }
1074 else {
1075 memcpy(&(pBuf->Data.abyRA[0]),
1076 &(pDevice->abyBSSID[0]),
1077 ETH_ALEN);
1078 }
1079
1080 if (pDevice->eOPMode == OP_MODE_AP) {
1081 memcpy(&(pBuf->Data.abyTA[0]),
1082 &(pDevice->abyBSSID[0]),
1083 ETH_ALEN);
1084 }
1085 else {
1086 memcpy(&(pBuf->Data.abyTA[0]),
1087 &(psEthHeader->abySrcAddr[0]),
1088 ETH_ALEN);
1089 }
1090
1091 } // if (byFBOption == AUTO_FB_NONE)
1092 }
1093 else if (byPktType == PK_TYPE_11A) {
1094 if (byFBOption == AUTO_FB_NONE) {
1095 PSRTS_ab pBuf = (PSRTS_ab)pvRTS;
1096 //Get SignalField,ServiceField,Length
1097 BBvCaculateParameter(pDevice, uRTSFrameLen, pDevice->byTopOFDMBasicRate, byPktType,
1098 (PWORD)&(wLen), (PBYTE)&(pBuf->byServiceField), (PBYTE)&(pBuf->bySignalField)
1099 );
1100 pBuf->wTransmitLength = cpu_to_le16(wLen);
1101 //Get Duration
1102 pBuf->wDuration = cpu_to_le16((WORD)s_uGetRTSCTSDuration(pDevice, RTSDUR_AA, cbFrameLength, byPktType, wCurrentRate, bNeedAck, byFBOption)); //0:RTSDuration_aa, 0:5G, 0: 5G OFDMData
1103 pBuf->Data.wDurationID = pBuf->wDuration;
1104 //Get RTS Frame body
1105 pBuf->Data.wFrameControl = TYPE_CTL_RTS;//0x00B4
1106
1107 if ((pDevice->eOPMode == OP_MODE_ADHOC) ||
1108 (pDevice->eOPMode == OP_MODE_AP)) {
1109 memcpy(&(pBuf->Data.abyRA[0]),
1110 &(psEthHeader->abyDstAddr[0]),
1111 ETH_ALEN);
1112 } else {
1113 memcpy(&(pBuf->Data.abyRA[0]),
1114 &(pDevice->abyBSSID[0]),
1115 ETH_ALEN);
1116 }
1117
1118 if (pDevice->eOPMode == OP_MODE_AP) {
1119 memcpy(&(pBuf->Data.abyTA[0]),
1120 &(pDevice->abyBSSID[0]),
1121 ETH_ALEN);
1122 } else {
1123 memcpy(&(pBuf->Data.abyTA[0]),
1124 &(psEthHeader->abySrcAddr[0]),
1125 ETH_ALEN);
1126 }
1127
1128 }
1129 else {
1130 PSRTS_a_FB pBuf = (PSRTS_a_FB)pvRTS;
1131 //Get SignalField,ServiceField,Length
1132 BBvCaculateParameter(pDevice, uRTSFrameLen, pDevice->byTopOFDMBasicRate, byPktType,
1133 (PWORD)&(wLen), (PBYTE)&(pBuf->byServiceField), (PBYTE)&(pBuf->bySignalField)
1134 );
1135 pBuf->wTransmitLength = cpu_to_le16(wLen);
1136 //Get Duration
1137 pBuf->wDuration = cpu_to_le16((WORD)s_uGetRTSCTSDuration(pDevice, RTSDUR_AA, cbFrameLength, byPktType, wCurrentRate, bNeedAck, byFBOption)); //0:RTSDuration_aa, 0:5G, 0: 5G OFDMData
1138 pBuf->wRTSDuration_f0 = cpu_to_le16((WORD)s_uGetRTSCTSDuration(pDevice, RTSDUR_AA_F0, cbFrameLength, byPktType, wCurrentRate, bNeedAck, byFBOption)); //5:RTSDuration_aa_f0, 0:5G, 0: 5G OFDMData
1139 pBuf->wRTSDuration_f1 = cpu_to_le16((WORD)s_uGetRTSCTSDuration(pDevice, RTSDUR_AA_F1, cbFrameLength, byPktType, wCurrentRate, bNeedAck, byFBOption)); //7:RTSDuration_aa_f1, 0:5G, 0:
1140 pBuf->Data.wDurationID = pBuf->wDuration;
1141 //Get RTS Frame body
1142 pBuf->Data.wFrameControl = TYPE_CTL_RTS;//0x00B4
1143
1144 if ((pDevice->eOPMode == OP_MODE_ADHOC) ||
1145 (pDevice->eOPMode == OP_MODE_AP)) {
1146 memcpy(&(pBuf->Data.abyRA[0]),
1147 &(psEthHeader->abyDstAddr[0]),
1148 ETH_ALEN);
1149 } else {
1150 memcpy(&(pBuf->Data.abyRA[0]),
1151 &(pDevice->abyBSSID[0]),
1152 ETH_ALEN);
1153 }
1154 if (pDevice->eOPMode == OP_MODE_AP) {
1155 memcpy(&(pBuf->Data.abyTA[0]),
1156 &(pDevice->abyBSSID[0]),
1157 ETH_ALEN);
1158 } else {
1159 memcpy(&(pBuf->Data.abyTA[0]),
1160 &(psEthHeader->abySrcAddr[0]),
1161 ETH_ALEN);
1162 }
1163 }
1164 }
1165 else if (byPktType == PK_TYPE_11B) {
1166 PSRTS_ab pBuf = (PSRTS_ab)pvRTS;
1167 //Get SignalField,ServiceField,Length
1168 BBvCaculateParameter(pDevice, uRTSFrameLen, pDevice->byTopCCKBasicRate, PK_TYPE_11B,
1169 (PWORD)&(wLen), (PBYTE)&(pBuf->byServiceField), (PBYTE)&(pBuf->bySignalField)
1170 );
1171 pBuf->wTransmitLength = cpu_to_le16(wLen);
1172 //Get Duration
1173 pBuf->wDuration = cpu_to_le16((WORD)s_uGetRTSCTSDuration(pDevice, RTSDUR_BB, cbFrameLength, byPktType, wCurrentRate, bNeedAck, byFBOption)); //0:RTSDuration_bb, 1:2.4G, 1:CCKData
1174 pBuf->Data.wDurationID = pBuf->wDuration;
1175 //Get RTS Frame body
1176 pBuf->Data.wFrameControl = TYPE_CTL_RTS;//0x00B4
1177
1178 if ((pDevice->eOPMode == OP_MODE_ADHOC) ||
1179 (pDevice->eOPMode == OP_MODE_AP)) {
1180 memcpy(&(pBuf->Data.abyRA[0]),
1181 &(psEthHeader->abyDstAddr[0]),
1182 ETH_ALEN);
1183 }
1184 else {
1185 memcpy(&(pBuf->Data.abyRA[0]),
1186 &(pDevice->abyBSSID[0]),
1187 ETH_ALEN);
1188 }
1189
1190 if (pDevice->eOPMode == OP_MODE_AP) {
1191 memcpy(&(pBuf->Data.abyTA[0]),
1192 &(pDevice->abyBSSID[0]),
1193 ETH_ALEN);
1194 } else {
1195 memcpy(&(pBuf->Data.abyTA[0]),
1196 &(psEthHeader->abySrcAddr[0]),
1197 ETH_ALEN);
1198 }
1199 }
1200 }
1201
1202 static
1203 void
1204 s_vFillCTSHead (
1205 PSDevice pDevice,
1206 unsigned int uDMAIdx,
1207 BYTE byPktType,
1208 void *pvCTS,
1209 unsigned int cbFrameLength,
1210 BOOL bNeedAck,
1211 BOOL bDisCRC,
1212 WORD wCurrentRate,
1213 BYTE byFBOption
1214 )
1215 {
1216 unsigned int uCTSFrameLen = 14;
1217 WORD wLen = 0x0000;
1218
1219 if (pvCTS == NULL) {
1220 return;
1221 }
1222
1223 if (bDisCRC) {
1224 // When CRCDIS bit is on, H/W forgot to generate FCS for CTS frame,
1225 // in this case we need to decrease its length by 4.
1226 uCTSFrameLen -= 4;
1227 }
1228
1229 if (byPktType == PK_TYPE_11GB || byPktType == PK_TYPE_11GA) {
1230 if (byFBOption != AUTO_FB_NONE && uDMAIdx != TYPE_ATIMDMA && uDMAIdx != TYPE_BEACONDMA) {
1231 // Auto Fall back
1232 PSCTS_FB pBuf = (PSCTS_FB)pvCTS;
1233 //Get SignalField,ServiceField,Length
1234 BBvCaculateParameter(pDevice, uCTSFrameLen, pDevice->byTopCCKBasicRate, PK_TYPE_11B,
1235 (PWORD)&(wLen), (PBYTE)&(pBuf->byServiceField_b), (PBYTE)&(pBuf->bySignalField_b)
1236 );
1237 pBuf->wTransmitLength_b = cpu_to_le16(wLen);
1238 pBuf->wDuration_ba = (WORD)s_uGetRTSCTSDuration(pDevice, CTSDUR_BA, cbFrameLength, byPktType, wCurrentRate, bNeedAck, byFBOption); //3:CTSDuration_ba, 1:2.4G, 2,3:2.4G OFDM Data
1239 pBuf->wDuration_ba += pDevice->wCTSDuration;
1240 pBuf->wDuration_ba = cpu_to_le16(pBuf->wDuration_ba);
1241 //Get CTSDuration_ba_f0
1242 pBuf->wCTSDuration_ba_f0 = (WORD)s_uGetRTSCTSDuration(pDevice, CTSDUR_BA_F0, cbFrameLength, byPktType, wCurrentRate, bNeedAck, byFBOption); //8:CTSDuration_ba_f0, 1:2.4G, 2,3:2.4G OFDM Data
1243 pBuf->wCTSDuration_ba_f0 += pDevice->wCTSDuration;
1244 pBuf->wCTSDuration_ba_f0 = cpu_to_le16(pBuf->wCTSDuration_ba_f0);
1245 //Get CTSDuration_ba_f1
1246 pBuf->wCTSDuration_ba_f1 = (WORD)s_uGetRTSCTSDuration(pDevice, CTSDUR_BA_F1, cbFrameLength, byPktType, wCurrentRate, bNeedAck, byFBOption); //9:CTSDuration_ba_f1, 1:2.4G, 2,3:2.4G OFDM Data
1247 pBuf->wCTSDuration_ba_f1 += pDevice->wCTSDuration;
1248 pBuf->wCTSDuration_ba_f1 = cpu_to_le16(pBuf->wCTSDuration_ba_f1);
1249 //Get CTS Frame body
1250 pBuf->Data.wDurationID = pBuf->wDuration_ba;
1251 pBuf->Data.wFrameControl = TYPE_CTL_CTS;//0x00C4
1252 pBuf->Data.wReserved = 0x0000;
1253 memcpy(&(pBuf->Data.abyRA[0]),
1254 &(pDevice->abyCurrentNetAddr[0]),
1255 ETH_ALEN);
1256 } else { //if (byFBOption != AUTO_FB_NONE && uDMAIdx != TYPE_ATIMDMA && uDMAIdx != TYPE_BEACONDMA)
1257 PSCTS pBuf = (PSCTS)pvCTS;
1258 //Get SignalField,ServiceField,Length
1259 BBvCaculateParameter(pDevice, uCTSFrameLen, pDevice->byTopCCKBasicRate, PK_TYPE_11B,
1260 (PWORD)&(wLen), (PBYTE)&(pBuf->byServiceField_b), (PBYTE)&(pBuf->bySignalField_b)
1261 );
1262 pBuf->wTransmitLength_b = cpu_to_le16(wLen);
1263 //Get CTSDuration_ba
1264 pBuf->wDuration_ba = cpu_to_le16((WORD)s_uGetRTSCTSDuration(pDevice, CTSDUR_BA, cbFrameLength, byPktType, wCurrentRate, bNeedAck, byFBOption)); //3:CTSDuration_ba, 1:2.4G, 2,3:2.4G OFDM Data
1265 pBuf->wDuration_ba += pDevice->wCTSDuration;
1266 pBuf->wDuration_ba = cpu_to_le16(pBuf->wDuration_ba);
1267
1268 //Get CTS Frame body
1269 pBuf->Data.wDurationID = pBuf->wDuration_ba;
1270 pBuf->Data.wFrameControl = TYPE_CTL_CTS;//0x00C4
1271 pBuf->Data.wReserved = 0x0000;
1272 memcpy(&(pBuf->Data.abyRA[0]),
1273 &(pDevice->abyCurrentNetAddr[0]),
1274 ETH_ALEN);
1275 }
1276 }
1277 }
1278
1279 /*+
1280 *
1281 * Description:
1282 * Generate FIFO control for MAC & Baseband controller
1283 *
1284 * Parameters:
1285 * In:
1286 * pDevice - Pointer to adpater
1287 * pTxDataHead - Transmit Data Buffer
1288 * pTxBufHead - pTxBufHead
1289 * pvRrvTime - pvRrvTime
1290 * pvRTS - RTS Buffer
1291 * pCTS - CTS Buffer
1292 * cbFrameSize - Transmit Data Length (Hdr+Payload+FCS)
1293 * bNeedACK - If need ACK
1294 * uDMAIdx - DMA Index
1295 * Out:
1296 * none
1297 *
1298 * Return Value: none
1299 *
1300 -*/
1301
1302 static
1303 void
1304 s_vGenerateTxParameter (
1305 PSDevice pDevice,
1306 BYTE byPktType,
1307 WORD wCurrentRate,
1308 void *pTxBufHead,
1309 void *pvRrvTime,
1310 void *pvRTS,
1311 void *pvCTS,
1312 unsigned int cbFrameSize,
1313 BOOL bNeedACK,
1314 unsigned int uDMAIdx,
1315 PSEthernetHeader psEthHeader
1316 )
1317 {
1318 unsigned int cbMACHdLen = WLAN_HDR_ADDR3_LEN; /* 24 */
1319 WORD wFifoCtl;
1320 BOOL bDisCRC = FALSE;
1321 BYTE byFBOption = AUTO_FB_NONE;
1322 // WORD wCurrentRate = pDevice->wCurrentRate;
1323
1324 //DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"s_vGenerateTxParameter...\n");
1325 PSTxBufHead pFifoHead = (PSTxBufHead)pTxBufHead;
1326 pFifoHead->wReserved = wCurrentRate;
1327 wFifoCtl = pFifoHead->wFIFOCtl;
1328
1329 if (wFifoCtl & FIFOCTL_CRCDIS) {
1330 bDisCRC = TRUE;
1331 }
1332
1333 if (wFifoCtl & FIFOCTL_AUTO_FB_0) {
1334 byFBOption = AUTO_FB_0;
1335 }
1336 else if (wFifoCtl & FIFOCTL_AUTO_FB_1) {
1337 byFBOption = AUTO_FB_1;
1338 }
1339
1340 if (pDevice->bLongHeader)
1341 cbMACHdLen = WLAN_HDR_ADDR3_LEN + 6;
1342
1343 if (byPktType == PK_TYPE_11GB || byPktType == PK_TYPE_11GA) {
1344
1345 if (pvRTS != NULL) { //RTS_need
1346 //Fill RsvTime
1347 if (pvRrvTime) {
1348 PSRrvTime_gRTS pBuf = (PSRrvTime_gRTS)pvRrvTime;
1349 pBuf->wRTSTxRrvTime_aa = cpu_to_le16((WORD)s_uGetRTSCTSRsvTime(pDevice, 2, byPktType, cbFrameSize, wCurrentRate));//2:RTSTxRrvTime_aa, 1:2.4GHz
1350 pBuf->wRTSTxRrvTime_ba = cpu_to_le16((WORD)s_uGetRTSCTSRsvTime(pDevice, 1, byPktType, cbFrameSize, wCurrentRate));//1:RTSTxRrvTime_ba, 1:2.4GHz
1351 pBuf->wRTSTxRrvTime_bb = cpu_to_le16((WORD)s_uGetRTSCTSRsvTime(pDevice, 0, byPktType, cbFrameSize, wCurrentRate));//0:RTSTxRrvTime_bb, 1:2.4GHz
1352 pBuf->wTxRrvTime_a = cpu_to_le16((WORD) s_uGetTxRsvTime(pDevice, byPktType, cbFrameSize, wCurrentRate, bNeedACK));//2.4G OFDM
1353 pBuf->wTxRrvTime_b = cpu_to_le16((WORD) s_uGetTxRsvTime(pDevice, PK_TYPE_11B, cbFrameSize, pDevice->byTopCCKBasicRate, bNeedACK));//1:CCK
1354 }
1355 //Fill RTS
1356 s_vFillRTSHead(pDevice, byPktType, pvRTS, cbFrameSize, bNeedACK, bDisCRC, psEthHeader, wCurrentRate, byFBOption);
1357 }
1358 else {//RTS_needless, PCF mode
1359
1360 //Fill RsvTime
1361 if (pvRrvTime) {
1362 PSRrvTime_gCTS pBuf = (PSRrvTime_gCTS)pvRrvTime;
1363 pBuf->wTxRrvTime_a = cpu_to_le16((WORD)s_uGetTxRsvTime(pDevice, byPktType, cbFrameSize, wCurrentRate, bNeedACK));//2.4G OFDM
1364 pBuf->wTxRrvTime_b = cpu_to_le16((WORD)s_uGetTxRsvTime(pDevice, PK_TYPE_11B, cbFrameSize, pDevice->byTopCCKBasicRate, bNeedACK));//1:CCK
1365 pBuf->wCTSTxRrvTime_ba = cpu_to_le16((WORD)s_uGetRTSCTSRsvTime(pDevice, 3, byPktType, cbFrameSize, wCurrentRate));//3:CTSTxRrvTime_Ba, 1:2.4GHz
1366 }
1367 //Fill CTS
1368 s_vFillCTSHead(pDevice, uDMAIdx, byPktType, pvCTS, cbFrameSize, bNeedACK, bDisCRC, wCurrentRate, byFBOption);
1369 }
1370 }
1371 else if (byPktType == PK_TYPE_11A) {
1372
1373 if (pvRTS != NULL) {//RTS_need, non PCF mode
1374 //Fill RsvTime
1375 if (pvRrvTime) {
1376 PSRrvTime_ab pBuf = (PSRrvTime_ab)pvRrvTime;
1377 pBuf->wRTSTxRrvTime = cpu_to_le16((WORD)s_uGetRTSCTSRsvTime(pDevice, 2, byPktType, cbFrameSize, wCurrentRate));//2:RTSTxRrvTime_aa, 0:5GHz
1378 pBuf->wTxRrvTime = cpu_to_le16((WORD)s_uGetTxRsvTime(pDevice, byPktType, cbFrameSize, wCurrentRate, bNeedACK));//0:OFDM
1379 }
1380 //Fill RTS
1381 s_vFillRTSHead(pDevice, byPktType, pvRTS, cbFrameSize, bNeedACK, bDisCRC, psEthHeader, wCurrentRate, byFBOption);
1382 }
1383 else if (pvRTS == NULL) {//RTS_needless, non PCF mode
1384 //Fill RsvTime
1385 if (pvRrvTime) {
1386 PSRrvTime_ab pBuf = (PSRrvTime_ab)pvRrvTime;
1387 pBuf->wTxRrvTime = cpu_to_le16((WORD)s_uGetTxRsvTime(pDevice, PK_TYPE_11A, cbFrameSize, wCurrentRate, bNeedACK)); //0:OFDM
1388 }
1389 }
1390 }
1391 else if (byPktType == PK_TYPE_11B) {
1392
1393 if ((pvRTS != NULL)) {//RTS_need, non PCF mode
1394 //Fill RsvTime
1395 if (pvRrvTime) {
1396 PSRrvTime_ab pBuf = (PSRrvTime_ab)pvRrvTime;
1397 pBuf->wRTSTxRrvTime = cpu_to_le16((WORD)s_uGetRTSCTSRsvTime(pDevice, 0, byPktType, cbFrameSize, wCurrentRate));//0:RTSTxRrvTime_bb, 1:2.4GHz
1398 pBuf->wTxRrvTime = cpu_to_le16((WORD)s_uGetTxRsvTime(pDevice, PK_TYPE_11B, cbFrameSize, wCurrentRate, bNeedACK));//1:CCK
1399 }
1400 //Fill RTS
1401 s_vFillRTSHead(pDevice, byPktType, pvRTS, cbFrameSize, bNeedACK, bDisCRC, psEthHeader, wCurrentRate, byFBOption);
1402 }
1403 else { //RTS_needless, non PCF mode
1404 //Fill RsvTime
1405 if (pvRrvTime) {
1406 PSRrvTime_ab pBuf = (PSRrvTime_ab)pvRrvTime;
1407 pBuf->wTxRrvTime = cpu_to_le16((WORD)s_uGetTxRsvTime(pDevice, PK_TYPE_11B, cbFrameSize, wCurrentRate, bNeedACK)); //1:CCK
1408 }
1409 }
1410 }
1411 //DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"s_vGenerateTxParameter END.\n");
1412 }
1413 /*
1414 PBYTE pbyBuffer,//point to pTxBufHead
1415 WORD wFragType,//00:Non-Frag, 01:Start, 02:Mid, 03:Last
1416 unsigned int cbFragmentSize,//Hdr+payoad+FCS
1417 */
1418
1419
1420 BOOL
1421 s_bPacketToWirelessUsb(
1422 PSDevice pDevice,
1423 BYTE byPktType,
1424 PBYTE usbPacketBuf,
1425 BOOL bNeedEncryption,
1426 unsigned int uSkbPacketLen,
1427 unsigned int uDMAIdx,
1428 PSEthernetHeader psEthHeader,
1429 PBYTE pPacket,
1430 PSKeyItem pTransmitKey,
1431 unsigned int uNodeIndex,
1432 WORD wCurrentRate,
1433 unsigned int *pcbHeaderLen,
1434 unsigned int *pcbTotalLen
1435 )
1436 {
1437 PSMgmtObject pMgmt = &(pDevice->sMgmtObj);
1438 unsigned int cbFrameSize, cbFrameBodySize;
1439 PTX_BUFFER pTxBufHead;
1440 unsigned int cb802_1_H_len;
1441 unsigned int cbIVlen = 0, cbICVlen = 0, cbMIClen = 0,
1442 cbMACHdLen = 0, cbFCSlen = 4;
1443 unsigned int cbMICHDR = 0;
1444 BOOL bNeedACK,bRTS;
1445 PBYTE pbyType,pbyMacHdr,pbyIVHead,pbyPayloadHead,pbyTxBufferAddr;
1446 BYTE abySNAP_RFC1042[ETH_ALEN] = {0xAA, 0xAA, 0x03, 0x00, 0x00, 0x00};
1447 BYTE abySNAP_Bridgetunnel[ETH_ALEN] = {0xAA, 0xAA, 0x03, 0x00, 0x00, 0xF8};
1448 unsigned int uDuration;
1449 unsigned int cbHeaderLength = 0, uPadding = 0;
1450 void *pvRrvTime;
1451 PSMICHDRHead pMICHDR;
1452 void *pvRTS;
1453 void *pvCTS;
1454 void *pvTxDataHd;
1455 BYTE byFBOption = AUTO_FB_NONE,byFragType;
1456 WORD wTxBufSize;
1457 DWORD dwMICKey0,dwMICKey1,dwMIC_Priority,dwCRC;
1458 PDWORD pdwMIC_L,pdwMIC_R;
1459 BOOL bSoftWEP = FALSE;
1460
1461
1462
1463
1464 pvRrvTime = pMICHDR = pvRTS = pvCTS = pvTxDataHd = NULL;
1465 if ((bNeedEncryption) && (pTransmitKey != NULL)) {
1466 if (((PSKeyTable) (pTransmitKey->pvKeyTable))->bSoftWEP == TRUE) {
1467 // WEP 256
1468 bSoftWEP = TRUE;
1469 }
1470 }
1471
1472 pTxBufHead = (PTX_BUFFER) usbPacketBuf;
1473 memset(pTxBufHead, 0, sizeof(TX_BUFFER));
1474
1475 // Get pkt type
1476 if (ntohs(psEthHeader->wType) > MAX_DATA_LEN) {
1477 if (pDevice->dwDiagRefCount == 0) {
1478 cb802_1_H_len = 8;
1479 } else {
1480 cb802_1_H_len = 2;
1481 }
1482 } else {
1483 cb802_1_H_len = 0;
1484 }
1485
1486 cbFrameBodySize = uSkbPacketLen - ETH_HLEN + cb802_1_H_len;
1487
1488 //Set packet type
1489 pTxBufHead->wFIFOCtl |= (WORD)(byPktType<<8);
1490
1491 if (pDevice->dwDiagRefCount != 0) {
1492 bNeedACK = FALSE;
1493 pTxBufHead->wFIFOCtl = pTxBufHead->wFIFOCtl & (~FIFOCTL_NEEDACK);
1494 } else { //if (pDevice->dwDiagRefCount != 0) {
1495 if ((pDevice->eOPMode == OP_MODE_ADHOC) ||
1496 (pDevice->eOPMode == OP_MODE_AP)) {
1497 if (IS_MULTICAST_ADDRESS(&(psEthHeader->abyDstAddr[0])) ||
1498 IS_BROADCAST_ADDRESS(&(psEthHeader->abyDstAddr[0]))) {
1499 bNeedACK = FALSE;
1500 pTxBufHead->wFIFOCtl = pTxBufHead->wFIFOCtl & (~FIFOCTL_NEEDACK);
1501 }
1502 else {
1503 bNeedACK = TRUE;
1504 pTxBufHead->wFIFOCtl |= FIFOCTL_NEEDACK;
1505 }
1506 }
1507 else {
1508 // MSDUs in Infra mode always need ACK
1509 bNeedACK = TRUE;
1510 pTxBufHead->wFIFOCtl |= FIFOCTL_NEEDACK;
1511 }
1512 } //if (pDevice->dwDiagRefCount != 0) {
1513
1514 pTxBufHead->wTimeStamp = DEFAULT_MSDU_LIFETIME_RES_64us;
1515
1516 //Set FIFOCTL_LHEAD
1517 if (pDevice->bLongHeader)
1518 pTxBufHead->wFIFOCtl |= FIFOCTL_LHEAD;
1519
1520 if (pDevice->bSoftwareGenCrcErr) {
1521 pTxBufHead->wFIFOCtl |= FIFOCTL_CRCDIS; // set tx descriptors to NO hardware CRC
1522 }
1523
1524 //Set FRAGCTL_MACHDCNT
1525 if (pDevice->bLongHeader) {
1526 cbMACHdLen = WLAN_HDR_ADDR3_LEN + 6;
1527 } else {
1528 cbMACHdLen = WLAN_HDR_ADDR3_LEN;
1529 }
1530 pTxBufHead->wFragCtl |= (WORD)(cbMACHdLen << 10);
1531
1532 //Set FIFOCTL_GrpAckPolicy
1533 if (pDevice->bGrpAckPolicy == TRUE) {//0000 0100 0000 0000
1534 pTxBufHead->wFIFOCtl |= FIFOCTL_GRPACK;
1535 }
1536
1537 //Set Auto Fallback Ctl
1538 if (wCurrentRate >= RATE_18M) {
1539 if (pDevice->byAutoFBCtrl == AUTO_FB_0) {
1540 pTxBufHead->wFIFOCtl |= FIFOCTL_AUTO_FB_0;
1541 byFBOption = AUTO_FB_0;
1542 } else if (pDevice->byAutoFBCtrl == AUTO_FB_1) {
1543 pTxBufHead->wFIFOCtl |= FIFOCTL_AUTO_FB_1;
1544 byFBOption = AUTO_FB_1;
1545 }
1546 }
1547
1548 if (bSoftWEP != TRUE) {
1549 if ((bNeedEncryption) && (pTransmitKey != NULL)) { //WEP enabled
1550 if (pTransmitKey->byCipherSuite == KEY_CTL_WEP) { //WEP40 or WEP104
1551 pTxBufHead->wFragCtl |= FRAGCTL_LEGACY;
1552 }
1553 if (pTransmitKey->byCipherSuite == KEY_CTL_TKIP) {
1554 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"Tx Set wFragCtl == FRAGCTL_TKIP\n");
1555 pTxBufHead->wFragCtl |= FRAGCTL_TKIP;
1556 }
1557 else if (pTransmitKey->byCipherSuite == KEY_CTL_CCMP) { //CCMP
1558 pTxBufHead->wFragCtl |= FRAGCTL_AES;
1559 }
1560 }
1561 }
1562
1563
1564 if ((bNeedEncryption) && (pTransmitKey != NULL)) {
1565 if (pTransmitKey->byCipherSuite == KEY_CTL_WEP) {
1566 cbIVlen = 4;
1567 cbICVlen = 4;
1568 }
1569 else if (pTransmitKey->byCipherSuite == KEY_CTL_TKIP) {
1570 cbIVlen = 8;//IV+ExtIV
1571 cbMIClen = 8;
1572 cbICVlen = 4;
1573 }
1574 if (pTransmitKey->byCipherSuite == KEY_CTL_CCMP) {
1575 cbIVlen = 8;//RSN Header
1576 cbICVlen = 8;//MIC
1577 cbMICHDR = sizeof(SMICHDRHead);
1578 }
1579 if (bSoftWEP == FALSE) {
1580 //MAC Header should be padding 0 to DW alignment.
1581 uPadding = 4 - (cbMACHdLen%4);
1582 uPadding %= 4;
1583 }
1584 }
1585
1586 cbFrameSize = cbMACHdLen + cbIVlen + (cbFrameBodySize + cbMIClen) + cbICVlen + cbFCSlen;
1587
1588 if ( (bNeedACK == FALSE) ||(cbFrameSize < pDevice->wRTSThreshold) ) {
1589 bRTS = FALSE;
1590 } else {
1591 bRTS = TRUE;
1592 pTxBufHead->wFIFOCtl |= (FIFOCTL_RTS | FIFOCTL_LRETRY);
1593 }
1594
1595 pbyTxBufferAddr = (PBYTE) &(pTxBufHead->adwTxKey[0]);
1596 wTxBufSize = sizeof(STxBufHead);
1597 if (byPktType == PK_TYPE_11GB || byPktType == PK_TYPE_11GA) {//802.11g packet
1598 if (byFBOption == AUTO_FB_NONE) {
1599 if (bRTS == TRUE) {//RTS_need
1600 pvRrvTime = (PSRrvTime_gRTS) (pbyTxBufferAddr + wTxBufSize);
1601 pMICHDR = (PSMICHDRHead) (pbyTxBufferAddr + wTxBufSize + sizeof(SRrvTime_gRTS));
1602 pvRTS = (PSRTS_g) (pbyTxBufferAddr + wTxBufSize + sizeof(SRrvTime_gRTS) + cbMICHDR);
1603 pvCTS = NULL;
1604 pvTxDataHd = (PSTxDataHead_g) (pbyTxBufferAddr + wTxBufSize + sizeof(SRrvTime_gRTS) + cbMICHDR + sizeof(SRTS_g));
1605 cbHeaderLength = wTxBufSize + sizeof(SRrvTime_gRTS) + cbMICHDR + sizeof(SRTS_g) + sizeof(STxDataHead_g);
1606 }
1607 else { //RTS_needless
1608 pvRrvTime = (PSRrvTime_gCTS) (pbyTxBufferAddr + wTxBufSize);
1609 pMICHDR = (PSMICHDRHead) (pbyTxBufferAddr + wTxBufSize + sizeof(SRrvTime_gCTS));
1610 pvRTS = NULL;
1611 pvCTS = (PSCTS) (pbyTxBufferAddr + wTxBufSize + sizeof(SRrvTime_gCTS) + cbMICHDR);
1612 pvTxDataHd = (PSTxDataHead_g) (pbyTxBufferAddr + wTxBufSize + sizeof(SRrvTime_gCTS) + cbMICHDR + sizeof(SCTS));
1613 cbHeaderLength = wTxBufSize + sizeof(SRrvTime_gCTS) + cbMICHDR + sizeof(SCTS) + sizeof(STxDataHead_g);
1614 }
1615 } else {
1616 // Auto Fall Back
1617 if (bRTS == TRUE) {//RTS_need
1618 pvRrvTime = (PSRrvTime_gRTS) (pbyTxBufferAddr + wTxBufSize);
1619 pMICHDR = (PSMICHDRHead) (pbyTxBufferAddr + wTxBufSize + sizeof(SRrvTime_gRTS));
1620 pvRTS = (PSRTS_g_FB) (pbyTxBufferAddr + wTxBufSize + sizeof(SRrvTime_gRTS) + cbMICHDR);
1621 pvCTS = NULL;
1622 pvTxDataHd = (PSTxDataHead_g_FB) (pbyTxBufferAddr + wTxBufSize + sizeof(SRrvTime_gRTS) + cbMICHDR + sizeof(SRTS_g_FB));
1623 cbHeaderLength = wTxBufSize + sizeof(SRrvTime_gRTS) + cbMICHDR + sizeof(SRTS_g_FB) + sizeof(STxDataHead_g_FB);
1624 }
1625 else if (bRTS == FALSE) { //RTS_needless
1626 pvRrvTime = (PSRrvTime_gCTS) (pbyTxBufferAddr + wTxBufSize);
1627 pMICHDR = (PSMICHDRHead) (pbyTxBufferAddr + wTxBufSize + sizeof(SRrvTime_gCTS));
1628 pvRTS = NULL;
1629 pvCTS = (PSCTS_FB) (pbyTxBufferAddr + wTxBufSize + sizeof(SRrvTime_gCTS) + cbMICHDR);
1630 pvTxDataHd = (PSTxDataHead_g_FB) (pbyTxBufferAddr + wTxBufSize + sizeof(SRrvTime_gCTS) + cbMICHDR + sizeof(SCTS_FB));
1631 cbHeaderLength = wTxBufSize + sizeof(SRrvTime_gCTS) + cbMICHDR + sizeof(SCTS_FB) + sizeof(STxDataHead_g_FB);
1632 }
1633 } // Auto Fall Back
1634 }
1635 else {//802.11a/b packet
1636 if (byFBOption == AUTO_FB_NONE) {
1637 if (bRTS == TRUE) {//RTS_need
1638 pvRrvTime = (PSRrvTime_ab) (pbyTxBufferAddr + wTxBufSize);
1639 pMICHDR = (PSMICHDRHead) (pbyTxBufferAddr + wTxBufSize + sizeof(SRrvTime_ab));
1640 pvRTS = (PSRTS_ab) (pbyTxBufferAddr + wTxBufSize + sizeof(SRrvTime_ab) + cbMICHDR);
1641 pvCTS = NULL;
1642 pvTxDataHd = (PSTxDataHead_ab) (pbyTxBufferAddr + wTxBufSize + sizeof(SRrvTime_ab) + cbMICHDR + sizeof(SRTS_ab));
1643 cbHeaderLength = wTxBufSize + sizeof(PSRrvTime_ab) + cbMICHDR + sizeof(SRTS_ab) + sizeof(STxDataHead_ab);
1644 }
1645 else if (bRTS == FALSE) { //RTS_needless, no MICHDR
1646 pvRrvTime = (PSRrvTime_ab) (pbyTxBufferAddr + wTxBufSize);
1647 pMICHDR = (PSMICHDRHead) (pbyTxBufferAddr + wTxBufSize + sizeof(SRrvTime_ab));
1648 pvRTS = NULL;
1649 pvCTS = NULL;
1650 pvTxDataHd = (PSTxDataHead_ab) (pbyTxBufferAddr + wTxBufSize + sizeof(SRrvTime_ab) + cbMICHDR);
1651 cbHeaderLength = wTxBufSize + sizeof(SRrvTime_ab) + cbMICHDR + sizeof(STxDataHead_ab);
1652 }
1653 } else {
1654 // Auto Fall Back
1655 if (bRTS == TRUE) {//RTS_need
1656 pvRrvTime = (PSRrvTime_ab) (pbyTxBufferAddr + wTxBufSize);
1657 pMICHDR = (PSMICHDRHead) (pbyTxBufferAddr + wTxBufSize + sizeof(SRrvTime_ab));
1658 pvRTS = (PSRTS_a_FB) (pbyTxBufferAddr + wTxBufSize + sizeof(SRrvTime_ab) + cbMICHDR);
1659 pvCTS = NULL;
1660 pvTxDataHd = (PSTxDataHead_a_FB) (pbyTxBufferAddr + wTxBufSize + sizeof(SRrvTime_ab) + cbMICHDR + sizeof(SRTS_a_FB));
1661 cbHeaderLength = wTxBufSize + sizeof(PSRrvTime_ab) + cbMICHDR + sizeof(SRTS_a_FB) + sizeof(STxDataHead_a_FB);
1662 }
1663 else if (bRTS == FALSE) { //RTS_needless
1664 pvRrvTime = (PSRrvTime_ab) (pbyTxBufferAddr + wTxBufSize);
1665 pMICHDR = (PSMICHDRHead) (pbyTxBufferAddr + wTxBufSize + sizeof(SRrvTime_ab));
1666 pvRTS = NULL;
1667 pvCTS = NULL;
1668 pvTxDataHd = (PSTxDataHead_a_FB) (pbyTxBufferAddr + wTxBufSize + sizeof(SRrvTime_ab) + cbMICHDR);
1669 cbHeaderLength = wTxBufSize + sizeof(SRrvTime_ab) + cbMICHDR + sizeof(STxDataHead_a_FB);
1670 }
1671 } // Auto Fall Back
1672 }
1673
1674 pbyMacHdr = (PBYTE)(pbyTxBufferAddr + cbHeaderLength);
1675 pbyIVHead = (PBYTE)(pbyMacHdr + cbMACHdLen + uPadding);
1676 pbyPayloadHead = (PBYTE)(pbyMacHdr + cbMACHdLen + uPadding + cbIVlen);
1677
1678
1679 //=========================
1680 // No Fragmentation
1681 //=========================
1682 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"No Fragmentation...\n");
1683 byFragType = FRAGCTL_NONFRAG;
1684 //uDMAIdx = TYPE_AC0DMA;
1685 //pTxBufHead = (PSTxBufHead) &(pTxBufHead->adwTxKey[0]);
1686
1687
1688 //Fill FIFO,RrvTime,RTS,and CTS
1689 s_vGenerateTxParameter(pDevice, byPktType, wCurrentRate,
1690 (void *)pbyTxBufferAddr, pvRrvTime, pvRTS, pvCTS,
1691 cbFrameSize, bNeedACK, uDMAIdx, psEthHeader);
1692 //Fill DataHead
1693 uDuration = s_uFillDataHead(pDevice, byPktType, wCurrentRate, pvTxDataHd, cbFrameSize, uDMAIdx, bNeedACK,
1694 0, 0, 1/*uMACfragNum*/, byFBOption);
1695 // Generate TX MAC Header
1696 s_vGenerateMACHeader(pDevice, pbyMacHdr, (WORD)uDuration, psEthHeader, bNeedEncryption,
1697 byFragType, uDMAIdx, 0);
1698
1699 if (bNeedEncryption == TRUE) {
1700 //Fill TXKEY
1701 s_vFillTxKey(pDevice, (PBYTE)(pTxBufHead->adwTxKey), pbyIVHead, pTransmitKey,
1702 pbyMacHdr, (WORD)cbFrameBodySize, (PBYTE)pMICHDR);
1703
1704 if (pDevice->bEnableHostWEP) {
1705 pMgmt->sNodeDBTable[uNodeIndex].dwTSC47_16 = pTransmitKey->dwTSC47_16;
1706 pMgmt->sNodeDBTable[uNodeIndex].wTSC15_0 = pTransmitKey->wTSC15_0;
1707 }
1708 }
1709
1710 // 802.1H
1711 if (ntohs(psEthHeader->wType) > MAX_DATA_LEN) {
1712 if (pDevice->dwDiagRefCount == 0) {
1713 if ( (psEthHeader->wType == TYPE_PKT_IPX) ||
1714 (psEthHeader->wType == cpu_to_le16(0xF380))) {
1715 memcpy((PBYTE) (pbyPayloadHead), &abySNAP_Bridgetunnel[0], 6);
1716 } else {
1717 memcpy((PBYTE) (pbyPayloadHead), &abySNAP_RFC1042[0], 6);
1718 }
1719 pbyType = (PBYTE) (pbyPayloadHead + 6);
1720 memcpy(pbyType, &(psEthHeader->wType), sizeof(WORD));
1721 } else {
1722 memcpy((PBYTE) (pbyPayloadHead), &(psEthHeader->wType), sizeof(WORD));
1723
1724 }
1725
1726 }
1727
1728
1729 if (pPacket != NULL) {
1730 // Copy the Packet into a tx Buffer
1731 memcpy((pbyPayloadHead + cb802_1_H_len),
1732 (pPacket + ETH_HLEN),
1733 uSkbPacketLen - ETH_HLEN
1734 );
1735
1736 } else {
1737 // while bRelayPacketSend psEthHeader is point to header+payload
1738 memcpy((pbyPayloadHead + cb802_1_H_len), ((PBYTE)psEthHeader) + ETH_HLEN, uSkbPacketLen - ETH_HLEN);
1739 }
1740
1741 ASSERT(uLength == cbNdisBodySize);
1742
1743 if ((bNeedEncryption == TRUE) && (pTransmitKey != NULL) && (pTransmitKey->byCipherSuite == KEY_CTL_TKIP)) {
1744
1745 ///////////////////////////////////////////////////////////////////
1746
1747 if (pDevice->sMgmtObj.eAuthenMode == WMAC_AUTH_WPANONE) {
1748 dwMICKey0 = *(PDWORD)(&pTransmitKey->abyKey[16]);
1749 dwMICKey1 = *(PDWORD)(&pTransmitKey->abyKey[20]);
1750 }
1751 else if ((pTransmitKey->dwKeyIndex & AUTHENTICATOR_KEY) != 0) {
1752 dwMICKey0 = *(PDWORD)(&pTransmitKey->abyKey[16]);
1753 dwMICKey1 = *(PDWORD)(&pTransmitKey->abyKey[20]);
1754 }
1755 else {
1756 dwMICKey0 = *(PDWORD)(&pTransmitKey->abyKey[24]);
1757 dwMICKey1 = *(PDWORD)(&pTransmitKey->abyKey[28]);
1758 }
1759 // DO Software Michael
1760 MIC_vInit(dwMICKey0, dwMICKey1);
1761 MIC_vAppend((PBYTE)&(psEthHeader->abyDstAddr[0]), 12);
1762 dwMIC_Priority = 0;
1763 MIC_vAppend((PBYTE)&dwMIC_Priority, 4);
1764 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"MIC KEY: %lX, %lX\n", dwMICKey0, dwMICKey1);
1765
1766 ///////////////////////////////////////////////////////////////////
1767
1768 //DBG_PRN_GRP12(("Length:%d, %d\n", cbFrameBodySize, uFromHDtoPLDLength));
1769 //for (ii = 0; ii < cbFrameBodySize; ii++) {
1770 // DBG_PRN_GRP12(("%02x ", *((PBYTE)((pbyPayloadHead + cb802_1_H_len) + ii))));
1771 //}
1772 //DBG_PRN_GRP12(("\n\n\n"));
1773
1774 MIC_vAppend(pbyPayloadHead, cbFrameBodySize);
1775
1776 pdwMIC_L = (PDWORD)(pbyPayloadHead + cbFrameBodySize);
1777 pdwMIC_R = (PDWORD)(pbyPayloadHead + cbFrameBodySize + 4);
1778
1779 MIC_vGetMIC(pdwMIC_L, pdwMIC_R);
1780 MIC_vUnInit();
1781
1782 if (pDevice->bTxMICFail == TRUE) {
1783 *pdwMIC_L = 0;
1784 *pdwMIC_R = 0;
1785 pDevice->bTxMICFail = FALSE;
1786 }
1787 //DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"uLength: %d, %d\n", uLength, cbFrameBodySize);
1788 //DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"cbReqCount:%d, %d, %d, %d\n", cbReqCount, cbHeaderLength, uPadding, cbIVlen);
1789 //DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"MIC:%lX, %lX\n", *pdwMIC_L, *pdwMIC_R);
1790 }
1791
1792
1793 if (bSoftWEP == TRUE) {
1794
1795 s_vSWencryption(pDevice, pTransmitKey, (pbyPayloadHead), (WORD)(cbFrameBodySize + cbMIClen));
1796
1797 } else if ( ((pDevice->eEncryptionStatus == Ndis802_11Encryption1Enabled) && (bNeedEncryption == TRUE)) ||
1798 ((pDevice->eEncryptionStatus == Ndis802_11Encryption2Enabled) && (bNeedEncryption == TRUE)) ||
1799 ((pDevice->eEncryptionStatus == Ndis802_11Encryption3Enabled) && (bNeedEncryption == TRUE)) ) {
1800 cbFrameSize -= cbICVlen;
1801 }
1802
1803 if (pDevice->bSoftwareGenCrcErr == TRUE) {
1804 unsigned int cbLen;
1805 PDWORD pdwCRC;
1806
1807 dwCRC = 0xFFFFFFFFL;
1808 cbLen = cbFrameSize - cbFCSlen;
1809 // calculate CRC, and wrtie CRC value to end of TD
1810 dwCRC = CRCdwGetCrc32Ex(pbyMacHdr, cbLen, dwCRC);
1811 pdwCRC = (PDWORD)(pbyMacHdr + cbLen);
1812 // finally, we must invert dwCRC to get the correct answer
1813 *pdwCRC = ~dwCRC;
1814 // Force Error
1815 *pdwCRC -= 1;
1816 } else {
1817 cbFrameSize -= cbFCSlen;
1818 }
1819
1820 *pcbHeaderLen = cbHeaderLength;
1821 *pcbTotalLen = cbHeaderLength + cbFrameSize ;
1822
1823
1824 //Set FragCtl in TxBufferHead
1825 pTxBufHead->wFragCtl |= (WORD)byFragType;
1826
1827
1828 return TRUE;
1829
1830 }
1831
1832
1833 /*+
1834 *
1835 * Description:
1836 * Translate 802.3 to 802.11 header
1837 *
1838 * Parameters:
1839 * In:
1840 * pDevice - Pointer to adpater
1841 * dwTxBufferAddr - Transmit Buffer
1842 * pPacket - Packet from upper layer
1843 * cbPacketSize - Transmit Data Length
1844 * Out:
1845 * pcbHeadSize - Header size of MAC&Baseband control and 802.11 Header
1846 * pcbAppendPayload - size of append payload for 802.1H translation
1847 *
1848 * Return Value: none
1849 *
1850 -*/
1851
1852 void
1853 s_vGenerateMACHeader (
1854 PSDevice pDevice,
1855 PBYTE pbyBufferAddr,
1856 WORD wDuration,
1857 PSEthernetHeader psEthHeader,
1858 BOOL bNeedEncrypt,
1859 WORD wFragType,
1860 unsigned int uDMAIdx,
1861 unsigned int uFragIdx
1862 )
1863 {
1864 PS802_11Header pMACHeader = (PS802_11Header)pbyBufferAddr;
1865
1866 memset(pMACHeader, 0, (sizeof(S802_11Header))); //- sizeof(pMACHeader->dwIV)));
1867
1868 if (uDMAIdx == TYPE_ATIMDMA) {
1869 pMACHeader->wFrameCtl = TYPE_802_11_ATIM;
1870 } else {
1871 pMACHeader->wFrameCtl = TYPE_802_11_DATA;
1872 }
1873
1874 if (pDevice->eOPMode == OP_MODE_AP) {
1875 memcpy(&(pMACHeader->abyAddr1[0]),
1876 &(psEthHeader->abyDstAddr[0]),
1877 ETH_ALEN);
1878 memcpy(&(pMACHeader->abyAddr2[0]), &(pDevice->abyBSSID[0]), ETH_ALEN);
1879 memcpy(&(pMACHeader->abyAddr3[0]),
1880 &(psEthHeader->abySrcAddr[0]),
1881 ETH_ALEN);
1882 pMACHeader->wFrameCtl |= FC_FROMDS;
1883 } else {
1884 if (pDevice->eOPMode == OP_MODE_ADHOC) {
1885 memcpy(&(pMACHeader->abyAddr1[0]),
1886 &(psEthHeader->abyDstAddr[0]),
1887 ETH_ALEN);
1888 memcpy(&(pMACHeader->abyAddr2[0]),
1889 &(psEthHeader->abySrcAddr[0]),
1890 ETH_ALEN);
1891 memcpy(&(pMACHeader->abyAddr3[0]),
1892 &(pDevice->abyBSSID[0]),
1893 ETH_ALEN);
1894 } else {
1895 memcpy(&(pMACHeader->abyAddr3[0]),
1896 &(psEthHeader->abyDstAddr[0]),
1897 ETH_ALEN);
1898 memcpy(&(pMACHeader->abyAddr2[0]),
1899 &(psEthHeader->abySrcAddr[0]),
1900 ETH_ALEN);
1901 memcpy(&(pMACHeader->abyAddr1[0]),
1902 &(pDevice->abyBSSID[0]),
1903 ETH_ALEN);
1904 pMACHeader->wFrameCtl |= FC_TODS;
1905 }
1906 }
1907
1908 if (bNeedEncrypt)
1909 pMACHeader->wFrameCtl |= cpu_to_le16((WORD)WLAN_SET_FC_ISWEP(1));
1910
1911 pMACHeader->wDurationID = cpu_to_le16(wDuration);
1912
1913 if (pDevice->bLongHeader) {
1914 PWLAN_80211HDR_A4 pMACA4Header = (PWLAN_80211HDR_A4) pbyBufferAddr;
1915 pMACHeader->wFrameCtl |= (FC_TODS | FC_FROMDS);
1916 memcpy(pMACA4Header->abyAddr4, pDevice->abyBSSID, WLAN_ADDR_LEN);
1917 }
1918 pMACHeader->wSeqCtl = cpu_to_le16(pDevice->wSeqCounter << 4);
1919
1920 //Set FragNumber in Sequence Control
1921 pMACHeader->wSeqCtl |= cpu_to_le16((WORD)uFragIdx);
1922
1923 if ((wFragType == FRAGCTL_ENDFRAG) || (wFragType == FRAGCTL_NONFRAG)) {
1924 pDevice->wSeqCounter++;
1925 if (pDevice->wSeqCounter > 0x0fff)
1926 pDevice->wSeqCounter = 0;
1927 }
1928
1929 if ((wFragType == FRAGCTL_STAFRAG) || (wFragType == FRAGCTL_MIDFRAG)) { //StartFrag or MidFrag
1930 pMACHeader->wFrameCtl |= FC_MOREFRAG;
1931 }
1932 }
1933
1934
1935
1936 /*+
1937 *
1938 * Description:
1939 * Request instructs a MAC to transmit a 802.11 management packet through
1940 * the adapter onto the medium.
1941 *
1942 * Parameters:
1943 * In:
1944 * hDeviceContext - Pointer to the adapter
1945 * pPacket - A pointer to a descriptor for the packet to transmit
1946 * Out:
1947 * none
1948 *
1949 * Return Value: CMD_STATUS_PENDING if MAC Tx resource avaliable; otherwise FALSE
1950 *
1951 -*/
1952
1953 CMD_STATUS csMgmt_xmit(
1954 PSDevice pDevice,
1955 PSTxMgmtPacket pPacket
1956 )
1957 {
1958 BYTE byPktType;
1959 PBYTE pbyTxBufferAddr;
1960 void *pvRTS;
1961 PSCTS pCTS;
1962 void *pvTxDataHd;
1963 unsigned int uDuration;
1964 unsigned int cbReqCount;
1965 PS802_11Header pMACHeader;
1966 unsigned int cbHeaderSize;
1967 unsigned int cbFrameBodySize;
1968 BOOL bNeedACK;
1969 BOOL bIsPSPOLL = FALSE;
1970 PSTxBufHead pTxBufHead;
1971 unsigned int cbFrameSize;
1972 unsigned int cbIVlen = 0;
1973 unsigned int cbICVlen = 0;
1974 unsigned int cbMIClen = 0;
1975 unsigned int cbFCSlen = 4;
1976 unsigned int uPadding = 0;
1977 WORD wTxBufSize;
1978 unsigned int cbMacHdLen;
1979 SEthernetHeader sEthHeader;
1980 void *pvRrvTime;
1981 void *pMICHDR;
1982 PSMgmtObject pMgmt = &(pDevice->sMgmtObj);
1983 WORD wCurrentRate = RATE_1M;
1984 PTX_BUFFER pTX_Buffer;
1985 PUSB_SEND_CONTEXT pContext;
1986
1987
1988
1989 pContext = (PUSB_SEND_CONTEXT)s_vGetFreeContext(pDevice);
1990
1991 if (NULL == pContext) {
1992 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"ManagementSend TX...NO CONTEXT!\n");
1993 return CMD_STATUS_RESOURCES;
1994 }
1995
1996 pTX_Buffer = (PTX_BUFFER) (&pContext->Data[0]);
1997 pbyTxBufferAddr = (PBYTE)&(pTX_Buffer->adwTxKey[0]);
1998 cbFrameBodySize = pPacket->cbPayloadLen;
1999 pTxBufHead = (PSTxBufHead) pbyTxBufferAddr;
2000 wTxBufSize = sizeof(STxBufHead);
2001 memset(pTxBufHead, 0, wTxBufSize);
2002
2003 if (pDevice->byBBType == BB_TYPE_11A) {
2004 wCurrentRate = RATE_6M;
2005 byPktType = PK_TYPE_11A;
2006 } else {
2007 wCurrentRate = RATE_1M;
2008 byPktType = PK_TYPE_11B;
2009 }
2010
2011 // SetPower will cause error power TX state for OFDM Date packet in TX buffer.
2012 // 2004.11.11 Kyle -- Using OFDM power to tx MngPkt will decrease the connection capability.
2013 // And cmd timer will wait data pkt TX finish before scanning so it's OK
2014 // to set power here.
2015 if (pMgmt->eScanState != WMAC_NO_SCANNING) {
2016 RFbSetPower(pDevice, wCurrentRate, pDevice->byCurrentCh);
2017 } else {
2018 RFbSetPower(pDevice, wCurrentRate, pMgmt->uCurrChannel);
2019 }
2020 pDevice->wCurrentRate = wCurrentRate;
2021
2022
2023 //Set packet type
2024 if (byPktType == PK_TYPE_11A) {//0000 0000 0000 0000
2025 pTxBufHead->wFIFOCtl = 0;
2026 }
2027 else if (byPktType == PK_TYPE_11B) {//0000 0001 0000 0000
2028 pTxBufHead->wFIFOCtl |= FIFOCTL_11B;
2029 }
2030 else if (byPktType == PK_TYPE_11GB) {//0000 0010 0000 0000
2031 pTxBufHead->wFIFOCtl |= FIFOCTL_11GB;
2032 }
2033 else if (byPktType == PK_TYPE_11GA) {//0000 0011 0000 0000
2034 pTxBufHead->wFIFOCtl |= FIFOCTL_11GA;
2035 }
2036
2037 pTxBufHead->wFIFOCtl |= FIFOCTL_TMOEN;
2038 pTxBufHead->wTimeStamp = cpu_to_le16(DEFAULT_MGN_LIFETIME_RES_64us);
2039
2040
2041 if (IS_MULTICAST_ADDRESS(&(pPacket->p80211Header->sA3.abyAddr1[0])) ||
2042 IS_BROADCAST_ADDRESS(&(pPacket->p80211Header->sA3.abyAddr1[0]))) {
2043 bNeedACK = FALSE;
2044 }
2045 else {
2046 bNeedACK = TRUE;
2047 pTxBufHead->wFIFOCtl |= FIFOCTL_NEEDACK;
2048 };
2049
2050 if ((pMgmt->eCurrMode == WMAC_MODE_ESS_AP) ||
2051 (pMgmt->eCurrMode == WMAC_MODE_IBSS_STA) ) {
2052
2053 pTxBufHead->wFIFOCtl |= FIFOCTL_LRETRY;
2054 //Set Preamble type always long
2055 //pDevice->byPreambleType = PREAMBLE_LONG;
2056 // probe-response don't retry
2057 //if ((pPacket->p80211Header->sA4.wFrameCtl & TYPE_SUBTYPE_MASK) == TYPE_MGMT_PROBE_RSP) {
2058 // bNeedACK = FALSE;
2059 // pTxBufHead->wFIFOCtl &= (~FIFOCTL_NEEDACK);
2060 //}
2061 }
2062
2063 pTxBufHead->wFIFOCtl |= (FIFOCTL_GENINT | FIFOCTL_ISDMA0);
2064
2065 if ((pPacket->p80211Header->sA4.wFrameCtl & TYPE_SUBTYPE_MASK) == TYPE_CTL_PSPOLL) {
2066 bIsPSPOLL = TRUE;
2067 cbMacHdLen = WLAN_HDR_ADDR2_LEN;
2068 } else {
2069 cbMacHdLen = WLAN_HDR_ADDR3_LEN;
2070 }
2071
2072 //Set FRAGCTL_MACHDCNT
2073 pTxBufHead->wFragCtl |= cpu_to_le16((WORD)(cbMacHdLen << 10));
2074
2075 // Notes:
2076 // Although spec says MMPDU can be fragmented; In most case,
2077 // no one will send a MMPDU under fragmentation. With RTS may occur.
2078 pDevice->bAES = FALSE; //Set FRAGCTL_WEPTYP
2079
2080 if (WLAN_GET_FC_ISWEP(pPacket->p80211Header->sA4.wFrameCtl) != 0) {
2081 if (pDevice->eEncryptionStatus == Ndis802_11Encryption1Enabled) {
2082 cbIVlen = 4;
2083 cbICVlen = 4;
2084 pTxBufHead->wFragCtl |= FRAGCTL_LEGACY;
2085 }
2086 else if (pDevice->eEncryptionStatus == Ndis802_11Encryption2Enabled) {
2087 cbIVlen = 8;//IV+ExtIV
2088 cbMIClen = 8;
2089 cbICVlen = 4;
2090 pTxBufHead->wFragCtl |= FRAGCTL_TKIP;
2091 //We need to get seed here for filling TxKey entry.
2092 //TKIPvMixKey(pTransmitKey->abyKey, pDevice->abyCurrentNetAddr,
2093 // pTransmitKey->wTSC15_0, pTransmitKey->dwTSC47_16, pDevice->abyPRNG);
2094 }
2095 else if (pDevice->eEncryptionStatus == Ndis802_11Encryption3Enabled) {
2096 cbIVlen = 8;//RSN Header
2097 cbICVlen = 8;//MIC
2098 pTxBufHead->wFragCtl |= FRAGCTL_AES;
2099 pDevice->bAES = TRUE;
2100 }
2101 //MAC Header should be padding 0 to DW alignment.
2102 uPadding = 4 - (cbMacHdLen%4);
2103 uPadding %= 4;
2104 }
2105
2106 cbFrameSize = cbMacHdLen + cbFrameBodySize + cbIVlen + cbMIClen + cbICVlen + cbFCSlen;
2107
2108 //Set FIFOCTL_GrpAckPolicy
2109 if (pDevice->bGrpAckPolicy == TRUE) {//0000 0100 0000 0000
2110 pTxBufHead->wFIFOCtl |= FIFOCTL_GRPACK;
2111 }
2112 //the rest of pTxBufHead->wFragCtl:FragTyp will be set later in s_vFillFragParameter()
2113
2114 //Set RrvTime/RTS/CTS Buffer
2115 if (byPktType == PK_TYPE_11GB || byPktType == PK_TYPE_11GA) {//802.11g packet
2116
2117 pvRrvTime = (PSRrvTime_gCTS) (pbyTxBufferAddr + wTxBufSize);
2118 pMICHDR = NULL;
2119 pvRTS = NULL;
2120 pCTS = (PSCTS) (pbyTxBufferAddr + wTxBufSize + sizeof(SRrvTime_gCTS));
2121 pvTxDataHd = (PSTxDataHead_g) (pbyTxBufferAddr + wTxBufSize + sizeof(SRrvTime_gCTS) + sizeof(SCTS));
2122 cbHeaderSize = wTxBufSize + sizeof(SRrvTime_gCTS) + sizeof(SCTS) + sizeof(STxDataHead_g);
2123 }
2124 else { // 802.11a/b packet
2125 pvRrvTime = (PSRrvTime_ab) (pbyTxBufferAddr + wTxBufSize);
2126 pMICHDR = NULL;
2127 pvRTS = NULL;
2128 pCTS = NULL;
2129 pvTxDataHd = (PSTxDataHead_ab) (pbyTxBufferAddr + wTxBufSize + sizeof(SRrvTime_ab));
2130 cbHeaderSize = wTxBufSize + sizeof(SRrvTime_ab) + sizeof(STxDataHead_ab);
2131 }
2132
2133 memset((void *)(pbyTxBufferAddr + wTxBufSize), 0,
2134 (cbHeaderSize - wTxBufSize));
2135
2136 memcpy(&(sEthHeader.abyDstAddr[0]),
2137 &(pPacket->p80211Header->sA3.abyAddr1[0]),
2138 ETH_ALEN);
2139 memcpy(&(sEthHeader.abySrcAddr[0]),
2140 &(pPacket->p80211Header->sA3.abyAddr2[0]),
2141 ETH_ALEN);
2142 //=========================
2143 // No Fragmentation
2144 //=========================
2145 pTxBufHead->wFragCtl |= (WORD)FRAGCTL_NONFRAG;
2146
2147
2148 //Fill FIFO,RrvTime,RTS,and CTS
2149 s_vGenerateTxParameter(pDevice, byPktType, wCurrentRate, pbyTxBufferAddr, pvRrvTime, pvRTS, pCTS,
2150 cbFrameSize, bNeedACK, TYPE_TXDMA0, &sEthHeader);
2151
2152 //Fill DataHead
2153 uDuration = s_uFillDataHead(pDevice, byPktType, wCurrentRate, pvTxDataHd, cbFrameSize, TYPE_TXDMA0, bNeedACK,
2154 0, 0, 1, AUTO_FB_NONE);
2155
2156 pMACHeader = (PS802_11Header) (pbyTxBufferAddr + cbHeaderSize);
2157
2158 cbReqCount = cbHeaderSize + cbMacHdLen + uPadding + cbIVlen + cbFrameBodySize;
2159
2160 if (WLAN_GET_FC_ISWEP(pPacket->p80211Header->sA4.wFrameCtl) != 0) {
2161 PBYTE pbyIVHead;
2162 PBYTE pbyPayloadHead;
2163 PBYTE pbyBSSID;
2164 PSKeyItem pTransmitKey = NULL;
2165
2166 pbyIVHead = (PBYTE)(pbyTxBufferAddr + cbHeaderSize + cbMacHdLen + uPadding);
2167 pbyPayloadHead = (PBYTE)(pbyTxBufferAddr + cbHeaderSize + cbMacHdLen + uPadding + cbIVlen);
2168 do {
2169 if ((pDevice->eOPMode == OP_MODE_INFRASTRUCTURE) &&
2170 (pDevice->bLinkPass == TRUE)) {
2171 pbyBSSID = pDevice->abyBSSID;
2172 // get pairwise key
2173 if (KeybGetTransmitKey(&(pDevice->sKey), pbyBSSID, PAIRWISE_KEY, &pTransmitKey) == FALSE) {
2174 // get group key
2175 if(KeybGetTransmitKey(&(pDevice->sKey), pbyBSSID, GROUP_KEY, &pTransmitKey) == TRUE) {
2176 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"Get GTK.\n");
2177 break;
2178 }
2179 } else {
2180 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"Get PTK.\n");
2181 break;
2182 }
2183 }
2184 // get group key
2185 pbyBSSID = pDevice->abyBroadcastAddr;
2186 if(KeybGetTransmitKey(&(pDevice->sKey), pbyBSSID, GROUP_KEY, &pTransmitKey) == FALSE) {
2187 pTransmitKey = NULL;
2188 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"KEY is NULL. OP Mode[%d]\n", pDevice->eOPMode);
2189 } else {
2190 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"Get GTK.\n");
2191 }
2192 } while(FALSE);
2193 //Fill TXKEY
2194 s_vFillTxKey(pDevice, (PBYTE)(pTxBufHead->adwTxKey), pbyIVHead, pTransmitKey,
2195 (PBYTE)pMACHeader, (WORD)cbFrameBodySize, NULL);
2196
2197 memcpy(pMACHeader, pPacket->p80211Header, cbMacHdLen);
2198 memcpy(pbyPayloadHead, ((PBYTE)(pPacket->p80211Header) + cbMacHdLen),
2199 cbFrameBodySize);
2200 }
2201 else {
2202 // Copy the Packet into a tx Buffer
2203 memcpy(pMACHeader, pPacket->p80211Header, pPacket->cbMPDULen);
2204 }
2205
2206 pMACHeader->wSeqCtl = cpu_to_le16(pDevice->wSeqCounter << 4);
2207 pDevice->wSeqCounter++ ;
2208 if (pDevice->wSeqCounter > 0x0fff)
2209 pDevice->wSeqCounter = 0;
2210
2211 if (bIsPSPOLL) {
2212 // The MAC will automatically replace the Duration-field of MAC header by Duration-field
2213 // of FIFO control header.
2214 // This will cause AID-field of PS-POLL packet be incorrect (Because PS-POLL's AID field is
2215 // in the same place of other packet's Duration-field).
2216 // And it will cause Cisco-AP to issue Disassociation-packet
2217 if (byPktType == PK_TYPE_11GB || byPktType == PK_TYPE_11GA) {
2218 ((PSTxDataHead_g)pvTxDataHd)->wDuration_a = cpu_to_le16(pPacket->p80211Header->sA2.wDurationID);
2219 ((PSTxDataHead_g)pvTxDataHd)->wDuration_b = cpu_to_le16(pPacket->p80211Header->sA2.wDurationID);
2220 } else {
2221 ((PSTxDataHead_ab)pvTxDataHd)->wDuration = cpu_to_le16(pPacket->p80211Header->sA2.wDurationID);
2222 }
2223 }
2224
2225
2226 pTX_Buffer->wTxByteCount = cpu_to_le16((WORD)(cbReqCount));
2227 pTX_Buffer->byPKTNO = (BYTE) (((wCurrentRate<<4) &0x00F0) | ((pDevice->wSeqCounter - 1) & 0x000F));
2228 pTX_Buffer->byType = 0x00;
2229
2230 pContext->pPacket = NULL;
2231 pContext->Type = CONTEXT_MGMT_PACKET;
2232 pContext->uBufLen = (WORD)cbReqCount + 4; //USB header
2233
2234 if (WLAN_GET_FC_TODS(pMACHeader->wFrameCtl) == 0) {
2235 s_vSaveTxPktInfo(pDevice, (BYTE) (pTX_Buffer->byPKTNO & 0x0F), &(pMACHeader->abyAddr1[0]),(WORD)cbFrameSize,pTX_Buffer->wFIFOCtl);
2236 }
2237 else {
2238 s_vSaveTxPktInfo(pDevice, (BYTE) (pTX_Buffer->byPKTNO & 0x0F), &(pMACHeader->abyAddr3[0]),(WORD)cbFrameSize,pTX_Buffer->wFIFOCtl);
2239 }
2240
2241 PIPEnsSendBulkOut(pDevice,pContext);
2242 return CMD_STATUS_PENDING;
2243 }
2244
2245
2246 CMD_STATUS
2247 csBeacon_xmit(
2248 PSDevice pDevice,
2249 PSTxMgmtPacket pPacket
2250 )
2251 {
2252
2253 unsigned int cbFrameSize = pPacket->cbMPDULen + WLAN_FCS_LEN;
2254 unsigned int cbHeaderSize = 0;
2255 WORD wTxBufSize = sizeof(STxShortBufHead);
2256 PSTxShortBufHead pTxBufHead;
2257 PS802_11Header pMACHeader;
2258 PSTxDataHead_ab pTxDataHead;
2259 WORD wCurrentRate;
2260 unsigned int cbFrameBodySize;
2261 unsigned int cbReqCount;
2262 PBEACON_BUFFER pTX_Buffer;
2263 PBYTE pbyTxBufferAddr;
2264 PUSB_SEND_CONTEXT pContext;
2265 CMD_STATUS status;
2266
2267
2268 pContext = (PUSB_SEND_CONTEXT)s_vGetFreeContext(pDevice);
2269 if (NULL == pContext) {
2270 status = CMD_STATUS_RESOURCES;
2271 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"ManagementSend TX...NO CONTEXT!\n");
2272 return status ;
2273 }
2274 pTX_Buffer = (PBEACON_BUFFER) (&pContext->Data[0]);
2275 pbyTxBufferAddr = (PBYTE)&(pTX_Buffer->wFIFOCtl);
2276
2277 cbFrameBodySize = pPacket->cbPayloadLen;
2278
2279 pTxBufHead = (PSTxShortBufHead) pbyTxBufferAddr;
2280 wTxBufSize = sizeof(STxShortBufHead);
2281 memset(pTxBufHead, 0, wTxBufSize);
2282
2283 if (pDevice->byBBType == BB_TYPE_11A) {
2284 wCurrentRate = RATE_6M;
2285 pTxDataHead = (PSTxDataHead_ab) (pbyTxBufferAddr + wTxBufSize);
2286 //Get SignalField,ServiceField,Length
2287 BBvCaculateParameter(pDevice, cbFrameSize, wCurrentRate, PK_TYPE_11A,
2288 (PWORD)&(pTxDataHead->wTransmitLength), (PBYTE)&(pTxDataHead->byServiceField), (PBYTE)&(pTxDataHead->bySignalField)
2289 );
2290 //Get Duration and TimeStampOff
2291 pTxDataHead->wDuration = cpu_to_le16((WORD)s_uGetDataDuration(pDevice, DATADUR_A, cbFrameSize, PK_TYPE_11A,
2292 wCurrentRate, FALSE, 0, 0, 1, AUTO_FB_NONE));
2293 pTxDataHead->wTimeStampOff = wTimeStampOff[pDevice->byPreambleType%2][wCurrentRate%MAX_RATE];
2294 cbHeaderSize = wTxBufSize + sizeof(STxDataHead_ab);
2295 } else {
2296 wCurrentRate = RATE_1M;
2297 pTxBufHead->wFIFOCtl |= FIFOCTL_11B;
2298 pTxDataHead = (PSTxDataHead_ab) (pbyTxBufferAddr + wTxBufSize);
2299 //Get SignalField,ServiceField,Length
2300 BBvCaculateParameter(pDevice, cbFrameSize, wCurrentRate, PK_TYPE_11B,
2301 (PWORD)&(pTxDataHead->wTransmitLength), (PBYTE)&(pTxDataHead->byServiceField), (PBYTE)&(pTxDataHead->bySignalField)
2302 );
2303 //Get Duration and TimeStampOff
2304 pTxDataHead->wDuration = cpu_to_le16((WORD)s_uGetDataDuration(pDevice, DATADUR_B, cbFrameSize, PK_TYPE_11B,
2305 wCurrentRate, FALSE, 0, 0, 1, AUTO_FB_NONE));
2306 pTxDataHead->wTimeStampOff = wTimeStampOff[pDevice->byPreambleType%2][wCurrentRate%MAX_RATE];
2307 cbHeaderSize = wTxBufSize + sizeof(STxDataHead_ab);
2308 }
2309
2310 //Generate Beacon Header
2311 pMACHeader = (PS802_11Header)(pbyTxBufferAddr + cbHeaderSize);
2312 memcpy(pMACHeader, pPacket->p80211Header, pPacket->cbMPDULen);
2313
2314 pMACHeader->wDurationID = 0;
2315 pMACHeader->wSeqCtl = cpu_to_le16(pDevice->wSeqCounter << 4);
2316 pDevice->wSeqCounter++ ;
2317 if (pDevice->wSeqCounter > 0x0fff)
2318 pDevice->wSeqCounter = 0;
2319
2320 cbReqCount = cbHeaderSize + WLAN_HDR_ADDR3_LEN + cbFrameBodySize;
2321
2322 pTX_Buffer->wTxByteCount = (WORD)cbReqCount;
2323 pTX_Buffer->byPKTNO = (BYTE) (((wCurrentRate<<4) &0x00F0) | ((pDevice->wSeqCounter - 1) & 0x000F));
2324 pTX_Buffer->byType = 0x01;
2325
2326 pContext->pPacket = NULL;
2327 pContext->Type = CONTEXT_MGMT_PACKET;
2328 pContext->uBufLen = (WORD)cbReqCount + 4; //USB header
2329
2330 PIPEnsSendBulkOut(pDevice,pContext);
2331 return CMD_STATUS_PENDING;
2332
2333 }
2334
2335
2336
2337
2338
2339 void
2340 vDMA0_tx_80211(PSDevice pDevice, struct sk_buff *skb) {
2341
2342 PSMgmtObject pMgmt = &(pDevice->sMgmtObj);
2343 BYTE byPktType;
2344 PBYTE pbyTxBufferAddr;
2345 void *pvRTS;
2346 void *pvCTS;
2347 void *pvTxDataHd;
2348 unsigned int uDuration;
2349 unsigned int cbReqCount;
2350 PS802_11Header pMACHeader;
2351 unsigned int cbHeaderSize;
2352 unsigned int cbFrameBodySize;
2353 BOOL bNeedACK;
2354 BOOL bIsPSPOLL = FALSE;
2355 PSTxBufHead pTxBufHead;
2356 unsigned int cbFrameSize;
2357 unsigned int cbIVlen = 0;
2358 unsigned int cbICVlen = 0;
2359 unsigned int cbMIClen = 0;
2360 unsigned int cbFCSlen = 4;
2361 unsigned int uPadding = 0;
2362 unsigned int cbMICHDR = 0;
2363 unsigned int uLength = 0;
2364 DWORD dwMICKey0, dwMICKey1;
2365 DWORD dwMIC_Priority;
2366 PDWORD pdwMIC_L;
2367 PDWORD pdwMIC_R;
2368 WORD wTxBufSize;
2369 unsigned int cbMacHdLen;
2370 SEthernetHeader sEthHeader;
2371 void *pvRrvTime;
2372 void *pMICHDR;
2373 WORD wCurrentRate = RATE_1M;
2374 PUWLAN_80211HDR p80211Header;
2375 unsigned int uNodeIndex = 0;
2376 BOOL bNodeExist = FALSE;
2377 SKeyItem STempKey;
2378 PSKeyItem pTransmitKey = NULL;
2379 PBYTE pbyIVHead;
2380 PBYTE pbyPayloadHead;
2381 PBYTE pbyMacHdr;
2382 unsigned int cbExtSuppRate = 0;
2383 PTX_BUFFER pTX_Buffer;
2384 PUSB_SEND_CONTEXT pContext;
2385 // PWLAN_IE pItem;
2386
2387
2388 pvRrvTime = pMICHDR = pvRTS = pvCTS = pvTxDataHd = NULL;
2389
2390 if(skb->len <= WLAN_HDR_ADDR3_LEN) {
2391 cbFrameBodySize = 0;
2392 }
2393 else {
2394 cbFrameBodySize = skb->len - WLAN_HDR_ADDR3_LEN;
2395 }
2396 p80211Header = (PUWLAN_80211HDR)skb->data;
2397
2398 pContext = (PUSB_SEND_CONTEXT)s_vGetFreeContext(pDevice);
2399
2400 if (NULL == pContext) {
2401 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"DMA0 TX...NO CONTEXT!\n");
2402 dev_kfree_skb_irq(skb);
2403 return ;
2404 }
2405
2406 pTX_Buffer = (PTX_BUFFER)(&pContext->Data[0]);
2407 pbyTxBufferAddr = (PBYTE)(&pTX_Buffer->adwTxKey[0]);
2408 pTxBufHead = (PSTxBufHead) pbyTxBufferAddr;
2409 wTxBufSize = sizeof(STxBufHead);
2410 memset(pTxBufHead, 0, wTxBufSize);
2411
2412 if (pDevice->byBBType == BB_TYPE_11A) {
2413 wCurrentRate = RATE_6M;
2414 byPktType = PK_TYPE_11A;
2415 } else {
2416 wCurrentRate = RATE_1M;
2417 byPktType = PK_TYPE_11B;
2418 }
2419
2420 // SetPower will cause error power TX state for OFDM Date packet in TX buffer.
2421 // 2004.11.11 Kyle -- Using OFDM power to tx MngPkt will decrease the connection capability.
2422 // And cmd timer will wait data pkt TX finish before scanning so it's OK
2423 // to set power here.
2424 if (pMgmt->eScanState != WMAC_NO_SCANNING) {
2425 RFbSetPower(pDevice, wCurrentRate, pDevice->byCurrentCh);
2426 } else {
2427 RFbSetPower(pDevice, wCurrentRate, pMgmt->uCurrChannel);
2428 }
2429
2430 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"vDMA0_tx_80211: p80211Header->sA3.wFrameCtl = %x \n", p80211Header->sA3.wFrameCtl);
2431
2432 //Set packet type
2433 if (byPktType == PK_TYPE_11A) {//0000 0000 0000 0000
2434 pTxBufHead->wFIFOCtl = 0;
2435 }
2436 else if (byPktType == PK_TYPE_11B) {//0000 0001 0000 0000
2437 pTxBufHead->wFIFOCtl |= FIFOCTL_11B;
2438 }
2439 else if (byPktType == PK_TYPE_11GB) {//0000 0010 0000 0000
2440 pTxBufHead->wFIFOCtl |= FIFOCTL_11GB;
2441 }
2442 else if (byPktType == PK_TYPE_11GA) {//0000 0011 0000 0000
2443 pTxBufHead->wFIFOCtl |= FIFOCTL_11GA;
2444 }
2445
2446 pTxBufHead->wFIFOCtl |= FIFOCTL_TMOEN;
2447 pTxBufHead->wTimeStamp = cpu_to_le16(DEFAULT_MGN_LIFETIME_RES_64us);
2448
2449
2450 if (IS_MULTICAST_ADDRESS(&(p80211Header->sA3.abyAddr1[0])) ||
2451 IS_BROADCAST_ADDRESS(&(p80211Header->sA3.abyAddr1[0]))) {
2452 bNeedACK = FALSE;
2453 if (pDevice->bEnableHostWEP) {
2454 uNodeIndex = 0;
2455 bNodeExist = TRUE;
2456 };
2457 }
2458 else {
2459 if (pDevice->bEnableHostWEP) {
2460 if (BSSbIsSTAInNodeDB(pDevice, (PBYTE)(p80211Header->sA3.abyAddr1), &uNodeIndex))
2461 bNodeExist = TRUE;
2462 };
2463 bNeedACK = TRUE;
2464 pTxBufHead->wFIFOCtl |= FIFOCTL_NEEDACK;
2465 };
2466
2467 if ((pMgmt->eCurrMode == WMAC_MODE_ESS_AP) ||
2468 (pMgmt->eCurrMode == WMAC_MODE_IBSS_STA) ) {
2469
2470 pTxBufHead->wFIFOCtl |= FIFOCTL_LRETRY;
2471 //Set Preamble type always long
2472 //pDevice->byPreambleType = PREAMBLE_LONG;
2473
2474 // probe-response don't retry
2475 //if ((p80211Header->sA4.wFrameCtl & TYPE_SUBTYPE_MASK) == TYPE_MGMT_PROBE_RSP) {
2476 // bNeedACK = FALSE;
2477 // pTxBufHead->wFIFOCtl &= (~FIFOCTL_NEEDACK);
2478 //}
2479 }
2480
2481 pTxBufHead->wFIFOCtl |= (FIFOCTL_GENINT | FIFOCTL_ISDMA0);
2482
2483 if ((p80211Header->sA4.wFrameCtl & TYPE_SUBTYPE_MASK) == TYPE_CTL_PSPOLL) {
2484 bIsPSPOLL = TRUE;
2485 cbMacHdLen = WLAN_HDR_ADDR2_LEN;
2486 } else {
2487 cbMacHdLen = WLAN_HDR_ADDR3_LEN;
2488 }
2489
2490 // hostapd deamon ext support rate patch
2491 if (WLAN_GET_FC_FSTYPE(p80211Header->sA4.wFrameCtl) == WLAN_FSTYPE_ASSOCRESP) {
2492
2493 if (((PWLAN_IE_SUPP_RATES)pMgmt->abyCurrSuppRates)->len != 0) {
2494 cbExtSuppRate += ((PWLAN_IE_SUPP_RATES)pMgmt->abyCurrSuppRates)->len + WLAN_IEHDR_LEN;
2495 }
2496
2497 if (((PWLAN_IE_SUPP_RATES)pMgmt->abyCurrExtSuppRates)->len != 0) {
2498 cbExtSuppRate += ((PWLAN_IE_SUPP_RATES)pMgmt->abyCurrExtSuppRates)->len + WLAN_IEHDR_LEN;
2499 }
2500
2501 if (cbExtSuppRate >0) {
2502 cbFrameBodySize = WLAN_ASSOCRESP_OFF_SUPP_RATES;
2503 }
2504 }
2505
2506
2507 //Set FRAGCTL_MACHDCNT
2508 pTxBufHead->wFragCtl |= cpu_to_le16((WORD)cbMacHdLen << 10);
2509
2510 // Notes:
2511 // Although spec says MMPDU can be fragmented; In most case,
2512 // no one will send a MMPDU under fragmentation. With RTS may occur.
2513 pDevice->bAES = FALSE; //Set FRAGCTL_WEPTYP
2514
2515
2516 if (WLAN_GET_FC_ISWEP(p80211Header->sA4.wFrameCtl) != 0) {
2517 if (pDevice->eEncryptionStatus == Ndis802_11Encryption1Enabled) {
2518 cbIVlen = 4;
2519 cbICVlen = 4;
2520 pTxBufHead->wFragCtl |= FRAGCTL_LEGACY;
2521 }
2522 else if (pDevice->eEncryptionStatus == Ndis802_11Encryption2Enabled) {
2523 cbIVlen = 8;//IV+ExtIV
2524 cbMIClen = 8;
2525 cbICVlen = 4;
2526 pTxBufHead->wFragCtl |= FRAGCTL_TKIP;
2527 //We need to get seed here for filling TxKey entry.
2528 //TKIPvMixKey(pTransmitKey->abyKey, pDevice->abyCurrentNetAddr,
2529 // pTransmitKey->wTSC15_0, pTransmitKey->dwTSC47_16, pDevice->abyPRNG);
2530 }
2531 else if (pDevice->eEncryptionStatus == Ndis802_11Encryption3Enabled) {
2532 cbIVlen = 8;//RSN Header
2533 cbICVlen = 8;//MIC
2534 cbMICHDR = sizeof(SMICHDRHead);
2535 pTxBufHead->wFragCtl |= FRAGCTL_AES;
2536 pDevice->bAES = TRUE;
2537 }
2538 //MAC Header should be padding 0 to DW alignment.
2539 uPadding = 4 - (cbMacHdLen%4);
2540 uPadding %= 4;
2541 }
2542
2543 cbFrameSize = cbMacHdLen + cbFrameBodySize + cbIVlen + cbMIClen + cbICVlen + cbFCSlen + cbExtSuppRate;
2544
2545 //Set FIFOCTL_GrpAckPolicy
2546 if (pDevice->bGrpAckPolicy == TRUE) {//0000 0100 0000 0000
2547 pTxBufHead->wFIFOCtl |= FIFOCTL_GRPACK;
2548 }
2549 //the rest of pTxBufHead->wFragCtl:FragTyp will be set later in s_vFillFragParameter()
2550
2551
2552 if (byPktType == PK_TYPE_11GB || byPktType == PK_TYPE_11GA) {//802.11g packet
2553
2554 pvRrvTime = (PSRrvTime_gCTS) (pbyTxBufferAddr + wTxBufSize);
2555 pMICHDR = (PSMICHDRHead) (pbyTxBufferAddr + wTxBufSize + sizeof(SRrvTime_gCTS));
2556 pvRTS = NULL;
2557 pvCTS = (PSCTS) (pbyTxBufferAddr + wTxBufSize + sizeof(SRrvTime_gCTS) + cbMICHDR);
2558 pvTxDataHd = (PSTxDataHead_g) (pbyTxBufferAddr + wTxBufSize + sizeof(SRrvTime_gCTS) + cbMICHDR + sizeof(SCTS));
2559 cbHeaderSize = wTxBufSize + sizeof(SRrvTime_gCTS) + cbMICHDR + sizeof(SCTS) + sizeof(STxDataHead_g);
2560
2561 }
2562 else {//802.11a/b packet
2563
2564 pvRrvTime = (PSRrvTime_ab) (pbyTxBufferAddr + wTxBufSize);
2565 pMICHDR = (PSMICHDRHead) (pbyTxBufferAddr + wTxBufSize + sizeof(SRrvTime_ab));
2566 pvRTS = NULL;
2567 pvCTS = NULL;
2568 pvTxDataHd = (PSTxDataHead_ab) (pbyTxBufferAddr + wTxBufSize + sizeof(SRrvTime_ab) + cbMICHDR);
2569 cbHeaderSize = wTxBufSize + sizeof(SRrvTime_ab) + cbMICHDR + sizeof(STxDataHead_ab);
2570 }
2571 memset((void *)(pbyTxBufferAddr + wTxBufSize), 0,
2572 (cbHeaderSize - wTxBufSize));
2573 memcpy(&(sEthHeader.abyDstAddr[0]),
2574 &(p80211Header->sA3.abyAddr1[0]),
2575 ETH_ALEN);
2576 memcpy(&(sEthHeader.abySrcAddr[0]),
2577 &(p80211Header->sA3.abyAddr2[0]),
2578 ETH_ALEN);
2579 //=========================
2580 // No Fragmentation
2581 //=========================
2582 pTxBufHead->wFragCtl |= (WORD)FRAGCTL_NONFRAG;
2583
2584
2585 //Fill FIFO,RrvTime,RTS,and CTS
2586 s_vGenerateTxParameter(pDevice, byPktType, wCurrentRate, pbyTxBufferAddr, pvRrvTime, pvRTS, pvCTS,
2587 cbFrameSize, bNeedACK, TYPE_TXDMA0, &sEthHeader);
2588
2589 //Fill DataHead
2590 uDuration = s_uFillDataHead(pDevice, byPktType, wCurrentRate, pvTxDataHd, cbFrameSize, TYPE_TXDMA0, bNeedACK,
2591 0, 0, 1, AUTO_FB_NONE);
2592
2593 pMACHeader = (PS802_11Header) (pbyTxBufferAddr + cbHeaderSize);
2594
2595 cbReqCount = cbHeaderSize + cbMacHdLen + uPadding + cbIVlen + (cbFrameBodySize + cbMIClen) + cbExtSuppRate;
2596
2597 pbyMacHdr = (PBYTE)(pbyTxBufferAddr + cbHeaderSize);
2598 pbyPayloadHead = (PBYTE)(pbyMacHdr + cbMacHdLen + uPadding + cbIVlen);
2599 pbyIVHead = (PBYTE)(pbyMacHdr + cbMacHdLen + uPadding);
2600
2601 // Copy the Packet into a tx Buffer
2602 memcpy(pbyMacHdr, skb->data, cbMacHdLen);
2603
2604 // version set to 0, patch for hostapd deamon
2605 pMACHeader->wFrameCtl &= cpu_to_le16(0xfffc);
2606 memcpy(pbyPayloadHead, (skb->data + cbMacHdLen), cbFrameBodySize);
2607
2608 // replace support rate, patch for hostapd deamon( only support 11M)
2609 if (WLAN_GET_FC_FSTYPE(p80211Header->sA4.wFrameCtl) == WLAN_FSTYPE_ASSOCRESP) {
2610 if (cbExtSuppRate != 0) {
2611 if (((PWLAN_IE_SUPP_RATES)pMgmt->abyCurrSuppRates)->len != 0)
2612 memcpy((pbyPayloadHead + cbFrameBodySize),
2613 pMgmt->abyCurrSuppRates,
2614 ((PWLAN_IE_SUPP_RATES)pMgmt->abyCurrSuppRates)->len + WLAN_IEHDR_LEN
2615 );
2616 if (((PWLAN_IE_SUPP_RATES)pMgmt->abyCurrExtSuppRates)->len != 0)
2617 memcpy((pbyPayloadHead + cbFrameBodySize) + ((PWLAN_IE_SUPP_RATES)pMgmt->abyCurrSuppRates)->len + WLAN_IEHDR_LEN,
2618 pMgmt->abyCurrExtSuppRates,
2619 ((PWLAN_IE_SUPP_RATES)pMgmt->abyCurrExtSuppRates)->len + WLAN_IEHDR_LEN
2620 );
2621 }
2622 }
2623
2624 // Set wep
2625 if (WLAN_GET_FC_ISWEP(p80211Header->sA4.wFrameCtl) != 0) {
2626
2627 if (pDevice->bEnableHostWEP) {
2628 pTransmitKey = &STempKey;
2629 pTransmitKey->byCipherSuite = pMgmt->sNodeDBTable[uNodeIndex].byCipherSuite;
2630 pTransmitKey->dwKeyIndex = pMgmt->sNodeDBTable[uNodeIndex].dwKeyIndex;
2631 pTransmitKey->uKeyLength = pMgmt->sNodeDBTable[uNodeIndex].uWepKeyLength;
2632 pTransmitKey->dwTSC47_16 = pMgmt->sNodeDBTable[uNodeIndex].dwTSC47_16;
2633 pTransmitKey->wTSC15_0 = pMgmt->sNodeDBTable[uNodeIndex].wTSC15_0;
2634 memcpy(pTransmitKey->abyKey,
2635 &pMgmt->sNodeDBTable[uNodeIndex].abyWepKey[0],
2636 pTransmitKey->uKeyLength
2637 );
2638 }
2639
2640 if ((pTransmitKey != NULL) && (pTransmitKey->byCipherSuite == KEY_CTL_TKIP)) {
2641
2642 dwMICKey0 = *(PDWORD)(&pTransmitKey->abyKey[16]);
2643 dwMICKey1 = *(PDWORD)(&pTransmitKey->abyKey[20]);
2644
2645 // DO Software Michael
2646 MIC_vInit(dwMICKey0, dwMICKey1);
2647 MIC_vAppend((PBYTE)&(sEthHeader.abyDstAddr[0]), 12);
2648 dwMIC_Priority = 0;
2649 MIC_vAppend((PBYTE)&dwMIC_Priority, 4);
2650 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"DMA0_tx_8021:MIC KEY: %lX, %lX\n", dwMICKey0, dwMICKey1);
2651
2652 uLength = cbHeaderSize + cbMacHdLen + uPadding + cbIVlen;
2653
2654 MIC_vAppend((pbyTxBufferAddr + uLength), cbFrameBodySize);
2655
2656 pdwMIC_L = (PDWORD)(pbyTxBufferAddr + uLength + cbFrameBodySize);
2657 pdwMIC_R = (PDWORD)(pbyTxBufferAddr + uLength + cbFrameBodySize + 4);
2658
2659 MIC_vGetMIC(pdwMIC_L, pdwMIC_R);
2660 MIC_vUnInit();
2661
2662 if (pDevice->bTxMICFail == TRUE) {
2663 *pdwMIC_L = 0;
2664 *pdwMIC_R = 0;
2665 pDevice->bTxMICFail = FALSE;
2666 }
2667
2668 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"uLength: %d, %d\n", uLength, cbFrameBodySize);
2669 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"cbReqCount:%d, %d, %d, %d\n", cbReqCount, cbHeaderSize, uPadding, cbIVlen);
2670 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"MIC:%lx, %lx\n", *pdwMIC_L, *pdwMIC_R);
2671
2672 }
2673
2674 s_vFillTxKey(pDevice, (PBYTE)(pTxBufHead->adwTxKey), pbyIVHead, pTransmitKey,
2675 pbyMacHdr, (WORD)cbFrameBodySize, (PBYTE)pMICHDR);
2676
2677 if (pDevice->bEnableHostWEP) {
2678 pMgmt->sNodeDBTable[uNodeIndex].dwTSC47_16 = pTransmitKey->dwTSC47_16;
2679 pMgmt->sNodeDBTable[uNodeIndex].wTSC15_0 = pTransmitKey->wTSC15_0;
2680 }
2681
2682 if ((pDevice->byLocalID <= REV_ID_VT3253_A1)) {
2683 s_vSWencryption(pDevice, pTransmitKey, pbyPayloadHead, (WORD)(cbFrameBodySize + cbMIClen));
2684 }
2685 }
2686
2687 pMACHeader->wSeqCtl = cpu_to_le16(pDevice->wSeqCounter << 4);
2688 pDevice->wSeqCounter++ ;
2689 if (pDevice->wSeqCounter > 0x0fff)
2690 pDevice->wSeqCounter = 0;
2691
2692
2693 if (bIsPSPOLL) {
2694 // The MAC will automatically replace the Duration-field of MAC header by Duration-field
2695 // of FIFO control header.
2696 // This will cause AID-field of PS-POLL packet be incorrect (Because PS-POLL's AID field is
2697 // in the same place of other packet's Duration-field).
2698 // And it will cause Cisco-AP to issue Disassociation-packet
2699 if (byPktType == PK_TYPE_11GB || byPktType == PK_TYPE_11GA) {
2700 ((PSTxDataHead_g)pvTxDataHd)->wDuration_a = cpu_to_le16(p80211Header->sA2.wDurationID);
2701 ((PSTxDataHead_g)pvTxDataHd)->wDuration_b = cpu_to_le16(p80211Header->sA2.wDurationID);
2702 } else {
2703 ((PSTxDataHead_ab)pvTxDataHd)->wDuration = cpu_to_le16(p80211Header->sA2.wDurationID);
2704 }
2705 }
2706
2707 pTX_Buffer->wTxByteCount = cpu_to_le16((WORD)(cbReqCount));
2708 pTX_Buffer->byPKTNO = (BYTE) (((wCurrentRate<<4) &0x00F0) | ((pDevice->wSeqCounter - 1) & 0x000F));
2709 pTX_Buffer->byType = 0x00;
2710
2711 pContext->pPacket = skb;
2712 pContext->Type = CONTEXT_MGMT_PACKET;
2713 pContext->uBufLen = (WORD)cbReqCount + 4; //USB header
2714
2715 if (WLAN_GET_FC_TODS(pMACHeader->wFrameCtl) == 0) {
2716 s_vSaveTxPktInfo(pDevice, (BYTE) (pTX_Buffer->byPKTNO & 0x0F), &(pMACHeader->abyAddr1[0]),(WORD)cbFrameSize,pTX_Buffer->wFIFOCtl);
2717 }
2718 else {
2719 s_vSaveTxPktInfo(pDevice, (BYTE) (pTX_Buffer->byPKTNO & 0x0F), &(pMACHeader->abyAddr3[0]),(WORD)cbFrameSize,pTX_Buffer->wFIFOCtl);
2720 }
2721 PIPEnsSendBulkOut(pDevice,pContext);
2722 return ;
2723
2724 }
2725
2726
2727
2728
2729 //TYPE_AC0DMA data tx
2730 /*
2731 * Description:
2732 * Tx packet via AC0DMA(DMA1)
2733 *
2734 * Parameters:
2735 * In:
2736 * pDevice - Pointer to the adapter
2737 * skb - Pointer to tx skb packet
2738 * Out:
2739 * void
2740 *
2741 * Return Value: NULL
2742 */
2743
2744
2745
2746 NTSTATUS
2747 nsDMA_tx_packet(
2748 PSDevice pDevice,
2749 unsigned int uDMAIdx,
2750 struct sk_buff *skb
2751 )
2752 {
2753 PSMgmtObject pMgmt = &(pDevice->sMgmtObj);
2754 unsigned int BytesToWrite = 0, uHeaderLen = 0;
2755 unsigned int uNodeIndex = 0;
2756 BYTE byMask[8] = {1, 2, 4, 8, 0x10, 0x20, 0x40, 0x80};
2757 WORD wAID;
2758 BYTE byPktType;
2759 BOOL bNeedEncryption = FALSE;
2760 PSKeyItem pTransmitKey = NULL;
2761 SKeyItem STempKey;
2762 unsigned int ii;
2763 BOOL bTKIP_UseGTK = FALSE;
2764 BOOL bNeedDeAuth = FALSE;
2765 PBYTE pbyBSSID;
2766 BOOL bNodeExist = FALSE;
2767 PUSB_SEND_CONTEXT pContext;
2768 BOOL fConvertedPacket;
2769 PTX_BUFFER pTX_Buffer;
2770 unsigned int status;
2771 WORD wKeepRate = pDevice->wCurrentRate;
2772 struct net_device_stats* pStats = &pDevice->stats;
2773 //#ifdef WPA_SM_Transtatus
2774 // extern SWPAResult wpa_Result;
2775 //#endif
2776 BOOL bTxeapol_key = FALSE;
2777
2778
2779 if (pMgmt->eCurrMode == WMAC_MODE_ESS_AP) {
2780
2781 if (pDevice->uAssocCount == 0) {
2782 dev_kfree_skb_irq(skb);
2783 return 0;
2784 }
2785
2786 if (IS_MULTICAST_ADDRESS((PBYTE)(skb->data))) {
2787 uNodeIndex = 0;
2788 bNodeExist = TRUE;
2789 if (pMgmt->sNodeDBTable[0].bPSEnable) {
2790
2791 skb_queue_tail(&(pMgmt->sNodeDBTable[0].sTxPSQueue), skb);
2792 pMgmt->sNodeDBTable[0].wEnQueueCnt++;
2793 // set tx map
2794 pMgmt->abyPSTxMap[0] |= byMask[0];
2795 return 0;
2796 }
2797 // muticast/broadcast data rate
2798
2799 if (pDevice->byBBType != BB_TYPE_11A)
2800 pDevice->wCurrentRate = RATE_2M;
2801 else
2802 pDevice->wCurrentRate = RATE_24M;
2803 // long preamble type
2804 pDevice->byPreambleType = PREAMBLE_SHORT;
2805
2806 }else {
2807
2808 if (BSSbIsSTAInNodeDB(pDevice, (PBYTE)(skb->data), &uNodeIndex)) {
2809
2810 if (pMgmt->sNodeDBTable[uNodeIndex].bPSEnable) {
2811
2812 skb_queue_tail(&pMgmt->sNodeDBTable[uNodeIndex].sTxPSQueue, skb);
2813
2814 pMgmt->sNodeDBTable[uNodeIndex].wEnQueueCnt++;
2815 // set tx map
2816 wAID = pMgmt->sNodeDBTable[uNodeIndex].wAID;
2817 pMgmt->abyPSTxMap[wAID >> 3] |= byMask[wAID & 7];
2818 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "Set:pMgmt->abyPSTxMap[%d]= %d\n",
2819 (wAID >> 3), pMgmt->abyPSTxMap[wAID >> 3]);
2820
2821 return 0;
2822 }
2823 // AP rate decided from node
2824 pDevice->wCurrentRate = pMgmt->sNodeDBTable[uNodeIndex].wTxDataRate;
2825 // tx preamble decided from node
2826
2827 if (pMgmt->sNodeDBTable[uNodeIndex].bShortPreamble) {
2828 pDevice->byPreambleType = pDevice->byShortPreamble;
2829
2830 }else {
2831 pDevice->byPreambleType = PREAMBLE_LONG;
2832 }
2833 bNodeExist = TRUE;
2834 }
2835 }
2836
2837 if (bNodeExist == FALSE) {
2838 DBG_PRT(MSG_LEVEL_DEBUG, KERN_DEBUG"Unknown STA not found in node DB \n");
2839 dev_kfree_skb_irq(skb);
2840 return 0;
2841 }
2842 }
2843
2844 pContext = (PUSB_SEND_CONTEXT)s_vGetFreeContext(pDevice);
2845
2846 if (pContext == NULL) {
2847 DBG_PRT(MSG_LEVEL_DEBUG, KERN_DEBUG" pContext == NULL\n");
2848 dev_kfree_skb_irq(skb);
2849 return STATUS_RESOURCES;
2850 }
2851
2852 memcpy(pDevice->sTxEthHeader.abyDstAddr, (PBYTE)(skb->data), ETH_HLEN);
2853
2854 //mike add:station mode check eapol-key challenge--->
2855 {
2856 BYTE Protocol_Version; //802.1x Authentication
2857 BYTE Packet_Type; //802.1x Authentication
2858 BYTE Descriptor_type;
2859 WORD Key_info;
2860
2861 Protocol_Version = skb->data[ETH_HLEN];
2862 Packet_Type = skb->data[ETH_HLEN+1];
2863 Descriptor_type = skb->data[ETH_HLEN+1+1+2];
2864 Key_info = (skb->data[ETH_HLEN+1+1+2+1] << 8)|(skb->data[ETH_HLEN+1+1+2+2]);
2865 if (pDevice->sTxEthHeader.wType == TYPE_PKT_802_1x) {
2866 if(((Protocol_Version==1) ||(Protocol_Version==2)) &&
2867 (Packet_Type==3)) { //802.1x OR eapol-key challenge frame transfer
2868 bTxeapol_key = TRUE;
2869 if(!(Key_info & BIT3) && //WPA or RSN group-key challenge
2870 (Key_info & BIT8) && (Key_info & BIT9)) { //send 2/2 key
2871 if(Descriptor_type==254) {
2872 pDevice->fWPA_Authened = TRUE;
2873 PRINT_K("WPA ");
2874 }
2875 else {
2876 pDevice->fWPA_Authened = TRUE;
2877 PRINT_K("WPA2(re-keying) ");
2878 }
2879 PRINT_K("Authentication completed!!\n");
2880 }
2881 else if((Key_info & BIT3) && (Descriptor_type==2) && //RSN pairse-key challenge
2882 (Key_info & BIT8) && (Key_info & BIT9)) {
2883 pDevice->fWPA_Authened = TRUE;
2884 PRINT_K("WPA2 Authentication completed!!\n");
2885 }
2886 }
2887 }
2888 }
2889 //mike add:station mode check eapol-key challenge<---
2890
2891 if (pDevice->bEncryptionEnable == TRUE) {
2892 bNeedEncryption = TRUE;
2893 // get Transmit key
2894 do {
2895 if ((pMgmt->eCurrMode == WMAC_MODE_ESS_STA) &&
2896 (pMgmt->eCurrState == WMAC_STATE_ASSOC)) {
2897 pbyBSSID = pDevice->abyBSSID;
2898 // get pairwise key
2899 if (KeybGetTransmitKey(&(pDevice->sKey), pbyBSSID, PAIRWISE_KEY, &pTransmitKey) == FALSE) {
2900 // get group key
2901 if(KeybGetTransmitKey(&(pDevice->sKey), pbyBSSID, GROUP_KEY, &pTransmitKey) == TRUE) {
2902 bTKIP_UseGTK = TRUE;
2903 DBG_PRT(MSG_LEVEL_DEBUG, KERN_DEBUG"Get GTK.\n");
2904 break;
2905 }
2906 } else {
2907 DBG_PRT(MSG_LEVEL_DEBUG, KERN_DEBUG"Get PTK.\n");
2908 break;
2909 }
2910 }else if (pMgmt->eCurrMode == WMAC_MODE_IBSS_STA) {
2911
2912 pbyBSSID = pDevice->sTxEthHeader.abyDstAddr; //TO_DS = 0 and FROM_DS = 0 --> 802.11 MAC Address1
2913 DBG_PRT(MSG_LEVEL_DEBUG, KERN_DEBUG"IBSS Serach Key: \n");
2914 for (ii = 0; ii< 6; ii++)
2915 DBG_PRT(MSG_LEVEL_DEBUG, KERN_DEBUG"%x \n", *(pbyBSSID+ii));
2916 DBG_PRT(MSG_LEVEL_DEBUG, KERN_DEBUG"\n");
2917
2918 // get pairwise key
2919 if(KeybGetTransmitKey(&(pDevice->sKey), pbyBSSID, PAIRWISE_KEY, &pTransmitKey) == TRUE)
2920 break;
2921 }
2922 // get group key
2923 pbyBSSID = pDevice->abyBroadcastAddr;
2924 if(KeybGetTransmitKey(&(pDevice->sKey), pbyBSSID, GROUP_KEY, &pTransmitKey) == FALSE) {
2925 pTransmitKey = NULL;
2926 if (pMgmt->eCurrMode == WMAC_MODE_IBSS_STA) {
2927 DBG_PRT(MSG_LEVEL_DEBUG, KERN_DEBUG"IBSS and KEY is NULL. [%d]\n", pMgmt->eCurrMode);
2928 }
2929 else
2930 DBG_PRT(MSG_LEVEL_DEBUG, KERN_DEBUG"NOT IBSS and KEY is NULL. [%d]\n", pMgmt->eCurrMode);
2931 } else {
2932 bTKIP_UseGTK = TRUE;
2933 DBG_PRT(MSG_LEVEL_DEBUG, KERN_DEBUG"Get GTK.\n");
2934 }
2935 } while(FALSE);
2936 }
2937
2938 if (pDevice->bEnableHostWEP) {
2939 DBG_PRT(MSG_LEVEL_DEBUG, KERN_DEBUG"acdma0: STA index %d\n", uNodeIndex);
2940 if (pDevice->bEncryptionEnable == TRUE) {
2941 pTransmitKey = &STempKey;
2942 pTransmitKey->byCipherSuite = pMgmt->sNodeDBTable[uNodeIndex].byCipherSuite;
2943 pTransmitKey->dwKeyIndex = pMgmt->sNodeDBTable[uNodeIndex].dwKeyIndex;
2944 pTransmitKey->uKeyLength = pMgmt->sNodeDBTable[uNodeIndex].uWepKeyLength;
2945 pTransmitKey->dwTSC47_16 = pMgmt->sNodeDBTable[uNodeIndex].dwTSC47_16;
2946 pTransmitKey->wTSC15_0 = pMgmt->sNodeDBTable[uNodeIndex].wTSC15_0;
2947 memcpy(pTransmitKey->abyKey,
2948 &pMgmt->sNodeDBTable[uNodeIndex].abyWepKey[0],
2949 pTransmitKey->uKeyLength
2950 );
2951 }
2952 }
2953
2954 byPktType = (BYTE)pDevice->byPacketType;
2955
2956 if (pDevice->bFixRate) {
2957 if (pDevice->byBBType == BB_TYPE_11B) {
2958 if (pDevice->uConnectionRate >= RATE_11M) {
2959 pDevice->wCurrentRate = RATE_11M;
2960 } else {
2961 pDevice->wCurrentRate = (WORD)pDevice->uConnectionRate;
2962 }
2963 } else {
2964 if ((pDevice->byBBType == BB_TYPE_11A) &&
2965 (pDevice->uConnectionRate <= RATE_6M)) {
2966 pDevice->wCurrentRate = RATE_6M;
2967 } else {
2968 if (pDevice->uConnectionRate >= RATE_54M)
2969 pDevice->wCurrentRate = RATE_54M;
2970 else
2971 pDevice->wCurrentRate = (WORD)pDevice->uConnectionRate;
2972 }
2973 }
2974 }
2975 else {
2976 if (pDevice->eOPMode == OP_MODE_ADHOC) {
2977 // Adhoc Tx rate decided from node DB
2978 if (IS_MULTICAST_ADDRESS(&(pDevice->sTxEthHeader.abyDstAddr[0]))) {
2979 // Multicast use highest data rate
2980 pDevice->wCurrentRate = pMgmt->sNodeDBTable[0].wTxDataRate;
2981 // preamble type
2982 pDevice->byPreambleType = pDevice->byShortPreamble;
2983 }
2984 else {
2985 if(BSSbIsSTAInNodeDB(pDevice, &(pDevice->sTxEthHeader.abyDstAddr[0]), &uNodeIndex)) {
2986 pDevice->wCurrentRate = pMgmt->sNodeDBTable[uNodeIndex].wTxDataRate;
2987 if (pMgmt->sNodeDBTable[uNodeIndex].bShortPreamble) {
2988 pDevice->byPreambleType = pDevice->byShortPreamble;
2989
2990 }
2991 else {
2992 pDevice->byPreambleType = PREAMBLE_LONG;
2993 }
2994 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"Found Node Index is [%d] Tx Data Rate:[%d]\n",uNodeIndex, pDevice->wCurrentRate);
2995 }
2996 else {
2997 if (pDevice->byBBType != BB_TYPE_11A)
2998 pDevice->wCurrentRate = RATE_2M;
2999 else
3000 pDevice->wCurrentRate = RATE_24M; // refer to vMgrCreateOwnIBSS()'s
3001 // abyCurrExtSuppRates[]
3002 pDevice->byPreambleType = PREAMBLE_SHORT;
3003 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"Not Found Node use highest basic Rate.....\n");
3004 }
3005 }
3006 }
3007 if (pDevice->eOPMode == OP_MODE_INFRASTRUCTURE) {
3008 // Infra STA rate decided from AP Node, index = 0
3009 pDevice->wCurrentRate = pMgmt->sNodeDBTable[0].wTxDataRate;
3010 }
3011 }
3012
3013 if (pDevice->sTxEthHeader.wType == TYPE_PKT_802_1x) {
3014 if (pDevice->byBBType != BB_TYPE_11A) {
3015 pDevice->wCurrentRate = RATE_1M;
3016 pDevice->byACKRate = RATE_1M;
3017 pDevice->byTopCCKBasicRate = RATE_1M;
3018 pDevice->byTopOFDMBasicRate = RATE_6M;
3019 } else {
3020 pDevice->wCurrentRate = RATE_6M;
3021 pDevice->byACKRate = RATE_6M;
3022 pDevice->byTopCCKBasicRate = RATE_1M;
3023 pDevice->byTopOFDMBasicRate = RATE_6M;
3024 }
3025 }
3026
3027 DBG_PRT(MSG_LEVEL_DEBUG,
3028 KERN_INFO "dma_tx: pDevice->wCurrentRate = %d\n",
3029 pDevice->wCurrentRate);
3030
3031 if (wKeepRate != pDevice->wCurrentRate) {
3032 bScheduleCommand((void *) pDevice, WLAN_CMD_SETPOWER, NULL);
3033 }
3034
3035 if (pDevice->wCurrentRate <= RATE_11M) {
3036 byPktType = PK_TYPE_11B;
3037 }
3038
3039 if (bNeedEncryption == TRUE) {
3040 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"ntohs Pkt Type=%04x\n", ntohs(pDevice->sTxEthHeader.wType));
3041 if ((pDevice->sTxEthHeader.wType) == TYPE_PKT_802_1x) {
3042 bNeedEncryption = FALSE;
3043 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"Pkt Type=%04x\n", (pDevice->sTxEthHeader.wType));
3044 if ((pMgmt->eCurrMode == WMAC_MODE_ESS_STA) && (pMgmt->eCurrState == WMAC_STATE_ASSOC)) {
3045 if (pTransmitKey == NULL) {
3046 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"Don't Find TX KEY\n");
3047 }
3048 else {
3049 if (bTKIP_UseGTK == TRUE) {
3050 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"error: KEY is GTK!!~~\n");
3051 }
3052 else {
3053 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"Find PTK [%lX]\n", pTransmitKey->dwKeyIndex);
3054 bNeedEncryption = TRUE;
3055 }
3056 }
3057 }
3058
3059 if (pDevice->byCntMeasure == 2) {
3060 bNeedDeAuth = TRUE;
3061 pDevice->s802_11Counter.TKIPCounterMeasuresInvoked++;
3062 }
3063
3064 if (pDevice->bEnableHostWEP) {
3065 if ((uNodeIndex != 0) &&
3066 (pMgmt->sNodeDBTable[uNodeIndex].dwKeyIndex & PAIRWISE_KEY)) {
3067 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"Find PTK [%lX]\n", pTransmitKey->dwKeyIndex);
3068 bNeedEncryption = TRUE;
3069 }
3070 }
3071 }
3072 else {
3073
3074 #if 0
3075 if((pDevice->fWPA_Authened == FALSE) &&
3076 ((pMgmt->eAuthenMode == WMAC_AUTH_WPAPSK)||(pMgmt->eAuthenMode = WMAC_AUTH_WPA2PSK))){
3077 dev_kfree_skb_irq(skb);
3078 pStats->tx_dropped++;
3079 return STATUS_FAILURE;
3080 }
3081 else if (pTransmitKey == NULL) {
3082 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"return no tx key\n");
3083 dev_kfree_skb_irq(skb);
3084 pStats->tx_dropped++;
3085 return STATUS_FAILURE;
3086 }
3087 #else
3088 if (pTransmitKey == NULL) {
3089 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"return no tx key\n");
3090 dev_kfree_skb_irq(skb);
3091 pStats->tx_dropped++;
3092 return STATUS_FAILURE;
3093 }
3094 #endif
3095
3096 }
3097 }
3098
3099 fConvertedPacket = s_bPacketToWirelessUsb(pDevice, byPktType,
3100 (PBYTE)(&pContext->Data[0]), bNeedEncryption,
3101 skb->len, uDMAIdx, &pDevice->sTxEthHeader,
3102 (PBYTE)skb->data, pTransmitKey, uNodeIndex,
3103 pDevice->wCurrentRate,
3104 &uHeaderLen, &BytesToWrite
3105 );
3106
3107 if (fConvertedPacket == FALSE) {
3108 pContext->bBoolInUse = FALSE;
3109 dev_kfree_skb_irq(skb);
3110 return STATUS_FAILURE;
3111 }
3112
3113 if ( pDevice->bEnablePSMode == TRUE ) {
3114 if ( !pDevice->bPSModeTxBurst ) {
3115 bScheduleCommand((void *) pDevice,
3116 WLAN_CMD_MAC_DISPOWERSAVING,
3117 NULL);
3118 pDevice->bPSModeTxBurst = TRUE;
3119 }
3120 }
3121
3122 pTX_Buffer = (PTX_BUFFER)&(pContext->Data[0]);
3123 pTX_Buffer->byPKTNO = (BYTE) (((pDevice->wCurrentRate<<4) &0x00F0) | ((pDevice->wSeqCounter - 1) & 0x000F));
3124 pTX_Buffer->wTxByteCount = (WORD)BytesToWrite;
3125
3126 pContext->pPacket = skb;
3127 pContext->Type = CONTEXT_DATA_PACKET;
3128 pContext->uBufLen = (WORD)BytesToWrite + 4 ; //USB header
3129
3130 s_vSaveTxPktInfo(pDevice, (BYTE) (pTX_Buffer->byPKTNO & 0x0F), &(pContext->sEthHeader.abyDstAddr[0]),(WORD) (BytesToWrite-uHeaderLen),pTX_Buffer->wFIFOCtl);
3131
3132 status = PIPEnsSendBulkOut(pDevice,pContext);
3133
3134 if (bNeedDeAuth == TRUE) {
3135 WORD wReason = WLAN_MGMT_REASON_MIC_FAILURE;
3136
3137 bScheduleCommand((void *) pDevice, WLAN_CMD_DEAUTH, (PBYTE) &wReason);
3138 }
3139
3140 if(status!=STATUS_PENDING) {
3141 pContext->bBoolInUse = FALSE;
3142 dev_kfree_skb_irq(skb);
3143 return STATUS_FAILURE;
3144 }
3145 else
3146 return 0;
3147
3148 }
3149
3150
3151
3152 /*
3153 * Description:
3154 * Relay packet send (AC1DMA) from rx dpc.
3155 *
3156 * Parameters:
3157 * In:
3158 * pDevice - Pointer to the adapter
3159 * pPacket - Pointer to rx packet
3160 * cbPacketSize - rx ethernet frame size
3161 * Out:
3162 * TURE, FALSE
3163 *
3164 * Return Value: Return TRUE if packet is copy to dma1; otherwise FALSE
3165 */
3166
3167
3168 BOOL
3169 bRelayPacketSend (
3170 PSDevice pDevice,
3171 PBYTE pbySkbData,
3172 unsigned int uDataLen,
3173 unsigned int uNodeIndex
3174 )
3175 {
3176 PSMgmtObject pMgmt = &(pDevice->sMgmtObj);
3177 unsigned int BytesToWrite = 0, uHeaderLen = 0;
3178 BYTE byPktType = PK_TYPE_11B;
3179 BOOL bNeedEncryption = FALSE;
3180 SKeyItem STempKey;
3181 PSKeyItem pTransmitKey = NULL;
3182 PBYTE pbyBSSID;
3183 PUSB_SEND_CONTEXT pContext;
3184 BYTE byPktTyp;
3185 BOOL fConvertedPacket;
3186 PTX_BUFFER pTX_Buffer;
3187 unsigned int status;
3188 WORD wKeepRate = pDevice->wCurrentRate;
3189
3190
3191
3192 pContext = (PUSB_SEND_CONTEXT)s_vGetFreeContext(pDevice);
3193
3194 if (NULL == pContext) {
3195 return FALSE;
3196 }
3197
3198 memcpy(pDevice->sTxEthHeader.abyDstAddr, (PBYTE)pbySkbData, ETH_HLEN);
3199
3200 if (pDevice->bEncryptionEnable == TRUE) {
3201 bNeedEncryption = TRUE;
3202 // get group key
3203 pbyBSSID = pDevice->abyBroadcastAddr;
3204 if(KeybGetTransmitKey(&(pDevice->sKey), pbyBSSID, GROUP_KEY, &pTransmitKey) == FALSE) {
3205 pTransmitKey = NULL;
3206 DBG_PRT(MSG_LEVEL_DEBUG, KERN_DEBUG"KEY is NULL. [%d]\n", pMgmt->eCurrMode);
3207 } else {
3208 DBG_PRT(MSG_LEVEL_DEBUG, KERN_DEBUG"Get GTK.\n");
3209 }
3210 }
3211
3212 if (pDevice->bEnableHostWEP) {
3213 if (uNodeIndex < MAX_NODE_NUM + 1) {
3214 pTransmitKey = &STempKey;
3215 pTransmitKey->byCipherSuite = pMgmt->sNodeDBTable[uNodeIndex].byCipherSuite;
3216 pTransmitKey->dwKeyIndex = pMgmt->sNodeDBTable[uNodeIndex].dwKeyIndex;
3217 pTransmitKey->uKeyLength = pMgmt->sNodeDBTable[uNodeIndex].uWepKeyLength;
3218 pTransmitKey->dwTSC47_16 = pMgmt->sNodeDBTable[uNodeIndex].dwTSC47_16;
3219 pTransmitKey->wTSC15_0 = pMgmt->sNodeDBTable[uNodeIndex].wTSC15_0;
3220 memcpy(pTransmitKey->abyKey,
3221 &pMgmt->sNodeDBTable[uNodeIndex].abyWepKey[0],
3222 pTransmitKey->uKeyLength
3223 );
3224 }
3225 }
3226
3227 if ( bNeedEncryption && (pTransmitKey == NULL) ) {
3228 pContext->bBoolInUse = FALSE;
3229 return FALSE;
3230 }
3231
3232 byPktTyp = (BYTE)pDevice->byPacketType;
3233
3234 if (pDevice->bFixRate) {
3235 if (pDevice->byBBType == BB_TYPE_11B) {
3236 if (pDevice->uConnectionRate >= RATE_11M) {
3237 pDevice->wCurrentRate = RATE_11M;
3238 } else {
3239 pDevice->wCurrentRate = (WORD)pDevice->uConnectionRate;
3240 }
3241 } else {
3242 if ((pDevice->byBBType == BB_TYPE_11A) &&
3243 (pDevice->uConnectionRate <= RATE_6M)) {
3244 pDevice->wCurrentRate = RATE_6M;
3245 } else {
3246 if (pDevice->uConnectionRate >= RATE_54M)
3247 pDevice->wCurrentRate = RATE_54M;
3248 else
3249 pDevice->wCurrentRate = (WORD)pDevice->uConnectionRate;
3250 }
3251 }
3252 }
3253 else {
3254 pDevice->wCurrentRate = pMgmt->sNodeDBTable[uNodeIndex].wTxDataRate;
3255 }
3256
3257 if (wKeepRate != pDevice->wCurrentRate) {
3258 bScheduleCommand((void *) pDevice, WLAN_CMD_SETPOWER, NULL);
3259 }
3260
3261 if (pDevice->wCurrentRate <= RATE_11M)
3262 byPktType = PK_TYPE_11B;
3263
3264 BytesToWrite = uDataLen + U_CRC_LEN;
3265 // Convert the packet to an usb frame and copy into our buffer
3266 // and send the irp.
3267
3268 fConvertedPacket = s_bPacketToWirelessUsb(pDevice, byPktType,
3269 (PBYTE)(&pContext->Data[0]), bNeedEncryption,
3270 uDataLen, TYPE_AC0DMA, &pDevice->sTxEthHeader,
3271 pbySkbData, pTransmitKey, uNodeIndex,
3272 pDevice->wCurrentRate,
3273 &uHeaderLen, &BytesToWrite
3274 );
3275
3276 if (fConvertedPacket == FALSE) {
3277 pContext->bBoolInUse = FALSE;
3278 return FALSE;
3279 }
3280
3281 pTX_Buffer = (PTX_BUFFER)&(pContext->Data[0]);
3282 pTX_Buffer->byPKTNO = (BYTE) (((pDevice->wCurrentRate<<4) &0x00F0) | ((pDevice->wSeqCounter - 1) & 0x000F));
3283 pTX_Buffer->wTxByteCount = (WORD)BytesToWrite;
3284
3285 pContext->pPacket = NULL;
3286 pContext->Type = CONTEXT_DATA_PACKET;
3287 pContext->uBufLen = (WORD)BytesToWrite + 4 ; //USB header
3288
3289 s_vSaveTxPktInfo(pDevice, (BYTE) (pTX_Buffer->byPKTNO & 0x0F), &(pContext->sEthHeader.abyDstAddr[0]),(WORD) (BytesToWrite-uHeaderLen),pTX_Buffer->wFIFOCtl);
3290
3291 status = PIPEnsSendBulkOut(pDevice,pContext);
3292
3293 return TRUE;
3294 }
3295
x86 "subsystem" repository