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