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