projects / GitHub / mt8127 / android_kernel_alcatel_ttab.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Merge staging-next tree into Linus's latest version
[GitHub/mt8127/android_kernel_alcatel_ttab.git] / drivers / staging / vt6655 / rxtx.c
CommitLineData
5449c685
FB		 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:
f77f13e2 28 * s_vGenerateTxParameter - Generate tx dma required parameter.
5449c685 29 * vGenerateMACHeader - Translate 802.3 to 802.11 header
f77f13e2 30 * cbGetFragCount - Caculate fragment number count
5449c685
FB		 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
f77f13e2 36 * s_uGetRTSCTSDuration- get rtx/cts required duration
5449c685
FB		 37 * s_uGetRTSCTSRsvTime- get rts/cts reserved time
38 * s_uGetTxRsvTime- get frame reserved time
39 * s_vFillCTSHead- fulfill CTS ctl header
f77f13e2 40 * s_vFillFragParameter- Set fragment ctl parameter.
5449c685
FB		 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
5449c685 51#include "device.h"
5449c685 52#include "rxtx.h"
5449c685 53#include "tether.h"
5449c685 54#include "card.h"
5449c685 55#include "bssdb.h"
5449c685 56#include "mac.h"
5449c685 57#include "baseband.h"
5449c685 58#include "michael.h"
5449c685 59#include "tkip.h"
5449c685 60#include "tcrc.h"
5449c685 61#include "wctl.h"
5449c685 62#include "wroute.h"
5449c685 63#include "hostap.h"
5449c685 64#include "rf.h"
5449c685
FB		 65
66/*--------------------- Static Definitions -------------------------*/
67
68/*--------------------- Static Classes ----------------------------*/
69
70/*--------------------- Static Variables --------------------------*/
71//static int msglevel =MSG_LEVEL_DEBUG;
72static 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
83const 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
88const 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 };
92const 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
117static
6b35b7b3 118void
5449c685 119s_vFillTxKey(
3a215e0f
CC		 120 PSDevice pDevice,
121 PBYTE pbyBuf,
122 PBYTE pbyIVHead,
123 PSKeyItem pTransmitKey,
124 PBYTE pbyHdrBuf,
125 WORD wPayloadLen,
3cdec554 126 PBYTE pMICHDR
5449c685
FB		 127 );
128
129
130
131static
6b35b7b3 132void
5449c685 133s_vFillRTSHead(
3a215e0f
CC		 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
5449c685
FB		 143 );
144
145static
6b35b7b3 146void
5449c685 147s_vGenerateTxParameter(
3a215e0f
CC		 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
5449c685
FB		 159 );
160
161
162
163static void s_vFillFragParameter(
3a215e0f
CC		 164 PSDevice pDevice,
165 PBYTE pbyBuffer,
166 UINT uTxType,
167 void * pvtdCurr,
168 WORD wFragType,
169 UINT cbReqCount
5449c685
FB		 170 );
171
172
173static
174UINT
175s_cbFillTxBufHead (
3a215e0f
CC		 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,
3cdec554 187 PUINT puMACfragNum
5449c685
FB		 188 );
189
190
191static
192UINT
193s_uFillDataHead (
3a215e0f
CC		 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
5449c685
FB		 205 );
206
207
208/*--------------------- Export Variables --------------------------*/
209
210
211
212static
6b35b7b3 213void
5449c685 214s_vFillTxKey (
3a215e0f
CC		 215 PSDevice pDevice,
216 PBYTE pbyBuf,
217 PBYTE pbyIVHead,
218 PSKeyItem pTransmitKey,
219 PBYTE pbyHdrBuf,
220 WORD wPayloadLen,
3cdec554 221 PBYTE pMICHDR
5449c685
FB		 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 ){
51b6d9c2
JL		 243 memcpy(pDevice->abyPRNG, (PBYTE)&(dwRevIVCounter), 3);
244 memcpy(pDevice->abyPRNG+3, pTransmitKey->abyKey, pTransmitKey->uKeyLength);
5449c685 245 } else {
51b6d9c2
JL		 246 memcpy(pbyBuf, (PBYTE)&(dwRevIVCounter), 3);
247 memcpy(pbyBuf+3, pTransmitKey->abyKey, pTransmitKey->uKeyLength);
5449c685 248 if(pTransmitKey->uKeyLength == WLAN_WEP40_KEYLEN) {
51b6d9c2
JL		 249 memcpy(pbyBuf+8, (PBYTE)&(dwRevIVCounter), 3);
250 memcpy(pbyBuf+11, pTransmitKey->abyKey, pTransmitKey->uKeyLength);
5449c685 251 }
51b6d9c2 252 memcpy(pDevice->abyPRNG, pbyBuf, 16);
5449c685
FB		 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);
51b6d9c2 269 memcpy(pbyBuf, pDevice->abyPRNG, 16);
5449c685 270 // Make IV
51b6d9c2 271 memcpy(pdwIV, pDevice->abyPRNG, 3);
5449c685
FB		 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);
7e809a9b 276 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"vFillTxKey()---- pdwExtIV: %lx\n", *pdwExtIV);
5449c685
FB		 277
278 } else if (pTransmitKey->byCipherSuite == KEY_CTL_CCMP) {
279 pTransmitKey->wTSC15_0++;
280 if (pTransmitKey->wTSC15_0 == 0) {
281 pTransmitKey->dwTSC47_16++;
282 }
51b6d9c2 283 memcpy(pbyBuf, pTransmitKey->abyKey, 16);
5449c685
FB		 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
51b6d9c2 295 memcpy(pMICHDR+2, &(pMACHeader->abyAddr2[0]), 6);
5449c685
FB		 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);
51b6d9c2
JL		 313 memcpy(pMICHDR+18, (PBYTE)&wValue, 2); // MSKFRACTL
314 memcpy(pMICHDR+20, &(pMACHeader->abyAddr1[0]), 6);
315 memcpy(pMICHDR+26, &(pMACHeader->abyAddr2[0]), 6);
5449c685
FB		 316
317 //Fill MICHDR2
51b6d9c2 318 memcpy(pMICHDR+32, &(pMACHeader->abyAddr3[0]), 6);
5449c685
FB		 319 wValue = pMACHeader->wSeqCtl;
320 wValue &= 0x000F;
321 wValue = cpu_to_le16(wValue);
51b6d9c2 322 memcpy(pMICHDR+38, (PBYTE)&wValue, 2); // MSKSEQCTL
5449c685 323 if (pDevice->bLongHeader) {
51b6d9c2 324 memcpy(pMICHDR+40, &(pMACHeader->abyAddr4[0]), 6);
5449c685
FB		 325 }
326 }
327}
328
329
330static
6b35b7b3 331void
5449c685 332s_vSWencryption (
3a215e0f
CC		 333 PSDevice pDevice,
334 PSKeyItem pTransmitKey,
335 PBYTE pbyPayloadHead,
336 WORD wPayloadSize
5449c685
FB		 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
7e809a9b 374/*byPktType : PK_TYPE_11A 0
5449c685
FB		 375 PK_TYPE_11B 1
376 PK_TYPE_11GB 2
377 PK_TYPE_11GA 3
378*/
379static
380UINT
381s_uGetTxRsvTime (
3a215e0f
CC		 382 PSDevice pDevice,
383 BYTE byPktType,
384 UINT cbFrameLength,
385 WORD wRate,
386 BOOL bNeedAck
5449c685
FB		 387 )
388{
389 UINT uDataTime, uAckTime;
390
7e809a9b 391 uDataTime = BBuGetFrameTime(pDevice->byPreambleType, byPktType, cbFrameLength, wRate);
5449c685
FB		 392#ifdef PLICE_DEBUG
393 //printk("s_uGetTxRsvTime is %d\n",uDataTime);
394#endif
7e809a9b
JL		 395 if (byPktType == PK_TYPE_11B) {//llb,CCK mode
396 uAckTime = BBuGetFrameTime(pDevice->byPreambleType, byPktType, 14, (WORD)pDevice->byTopCCKBasicRate);
5449c685 397 } else {//11g 2.4G OFDM mode & 11a 5G OFDM mode
7e809a9b 398 uAckTime = BBuGetFrameTime(pDevice->byPreambleType, byPktType, 14, (WORD)pDevice->byTopOFDMBasicRate);
5449c685
FB		 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
410static
411UINT
412s_uGetRTSCTSRsvTime (
3a215e0f
CC		 413 PSDevice pDevice,
414 BYTE byRTSRsvType,
415 BYTE byPktType,
416 UINT cbFrameLength,
417 WORD wCurrentRate
5449c685
FB		 418 )
419{
420 UINT uRrvTime , uRTSTime, uCTSTime, uAckTime, uDataTime;
421
422 uRrvTime = uRTSTime = uCTSTime = uAckTime = uDataTime = 0;
423
424
7e809a9b 425 uDataTime = BBuGetFrameTime(pDevice->byPreambleType, byPktType, cbFrameLength, wCurrentRate);
5449c685 426 if (byRTSRsvType == 0) { //RTSTxRrvTime_bb
7e809a9b
JL		 427 uRTSTime = BBuGetFrameTime(pDevice->byPreambleType, byPktType, 20, pDevice->byTopCCKBasicRate);
428 uCTSTime = uAckTime = BBuGetFrameTime(pDevice->byPreambleType, byPktType, 14, pDevice->byTopCCKBasicRate);
5449c685
FB		 429 }
430 else if (byRTSRsvType == 1){ //RTSTxRrvTime_ba, only in 2.4GHZ
7e809a9b
JL		 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);
5449c685
FB		 434 }
435 else if (byRTSRsvType == 2) { //RTSTxRrvTime_aa
7e809a9b
JL		 436 uRTSTime = BBuGetFrameTime(pDevice->byPreambleType, byPktType, 20, pDevice->byTopOFDMBasicRate);
437 uCTSTime = uAckTime = BBuGetFrameTime(pDevice->byPreambleType, byPktType, 14, pDevice->byTopOFDMBasicRate);
5449c685
FB		 438 }
439 else if (byRTSRsvType == 3) { //CTSTxRrvTime_ba, only in 2.4GHZ
7e809a9b
JL		 440 uCTSTime = BBuGetFrameTime(pDevice->byPreambleType, byPktType, 14, pDevice->byTopCCKBasicRate);
441 uAckTime = BBuGetFrameTime(pDevice->byPreambleType, byPktType, 14, pDevice->byTopOFDMBasicRate);
5449c685
FB		 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
452static
453UINT
454s_uGetDataDuration (
3a215e0f
CC		 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
5449c685
FB		 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
623static
624UINT
625s_uGetRTSCTSDuration (
3a215e0f
CC		 626 PSDevice pDevice,
627 BYTE byDurType,
628 UINT cbFrameLength,
629 BYTE byPktType,
630 WORD wRate,
631 BOOL bNeedAck,
632 BYTE byFBOption
5449c685
FB		 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
721static
722UINT
723s_uFillDataHead (
3a215e0f
CC		 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
5449c685
FB		 735 )
736{
737 WORD wLen = 0x0000;
738
739 if (pTxDataHead == NULL) {
740 return 0;
741 }
742
7e809a9b 743 if (byPktType == PK_TYPE_11GB || byPktType == PK_TYPE_11GA) {
5449c685
FB		 744 if (byFBOption == AUTO_FB_NONE) {
745 PSTxDataHead_g pBuf = (PSTxDataHead_g)pTxDataHead;
746 //Get SignalField,ServiceField,Length
7e809a9b 747 BBvCaculateParameter(pDevice, cbFrameLength, wCurrentRate, byPktType,
5449c685
FB		 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,
7e809a9b 757 byPktType, wCurrentRate, bNeedAck, uFragIdx,
5449c685
FB		 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
7e809a9b 773 BBvCaculateParameter(pDevice, cbFrameLength, wCurrentRate, byPktType,
5449c685
FB		 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
7e809a9b 782 pBuf->wDuration_a = cpu_to_le16((WORD)s_uGetDataDuration(pDevice, DATADUR_A, cbFrameLength, byPktType,
5449c685
FB		 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
7e809a9b 786 pBuf->wDuration_a_f0 = cpu_to_le16((WORD)s_uGetDataDuration(pDevice, DATADUR_A_F0, cbFrameLength, byPktType,
5449c685 787 wCurrentRate, bNeedAck, uFragIdx, cbLastFragmentSize, uMACfragNum, byFBOption)); //1: 2.4GHz
7e809a9b 788 pBuf->wDuration_a_f1 = cpu_to_le16((WORD)s_uGetDataDuration(pDevice, DATADUR_A_F1, cbFrameLength, byPktType,
5449c685
FB		 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 }
7e809a9b 797 else if (byPktType == PK_TYPE_11A) {
5449c685
FB		 798 if ((byFBOption != AUTO_FB_NONE)) {
799 // Auto Fallback
800 PSTxDataHead_a_FB pBuf = (PSTxDataHead_a_FB)pTxDataHead;
801 //Get SignalField,ServiceField,Length
7e809a9b 802 BBvCaculateParameter(pDevice, cbFrameLength, wCurrentRate, byPktType,
5449c685
FB		 803 (PWORD)&(wLen), (PBYTE)&(pBuf->byServiceField), (PBYTE)&(pBuf->bySignalField)
804 );
805 pBuf->wTransmitLength = cpu_to_le16(wLen);
806 //Get Duration and TimeStampOff
807
7e809a9b 808 pBuf->wDuration = cpu_to_le16((WORD)s_uGetDataDuration(pDevice, DATADUR_A, cbFrameLength, byPktType,
5449c685 809 wCurrentRate, bNeedAck, uFragIdx, cbLastFragmentSize, uMACfragNum, byFBOption)); //0: 5GHz
7e809a9b 810 pBuf->wDuration_f0 = cpu_to_le16((WORD)s_uGetDataDuration(pDevice, DATADUR_A_F0, cbFrameLength, byPktType,
5449c685 811 wCurrentRate, bNeedAck, uFragIdx, cbLastFragmentSize, uMACfragNum, byFBOption)); //0: 5GHz
7e809a9b 812 pBuf->wDuration_f1 = cpu_to_le16((WORD)s_uGetDataDuration(pDevice, DATADUR_A_F1, cbFrameLength, byPktType,
5449c685
FB		 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
7e809a9b 819 BBvCaculateParameter(pDevice, cbFrameLength, wCurrentRate, byPktType,
5449c685
FB		 820 (PWORD)&(wLen), (PBYTE)&(pBuf->byServiceField), (PBYTE)&(pBuf->bySignalField)
821 );
822 pBuf->wTransmitLength = cpu_to_le16(wLen);
823 //Get Duration and TimeStampOff
824
7e809a9b 825 pBuf->wDuration = cpu_to_le16((WORD)s_uGetDataDuration(pDevice, DATADUR_A, cbFrameLength, byPktType,
5449c685
FB		 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
7e809a9b 837 BBvCaculateParameter(pDevice, cbFrameLength, wCurrentRate, byPktType,
5449c685
FB		 838 (PWORD)&(wLen), (PBYTE)&(pBuf->byServiceField), (PBYTE)&(pBuf->bySignalField)
839 );
840 pBuf->wTransmitLength = cpu_to_le16(wLen);
841 //Get Duration and TimeStampOff
7e809a9b 842 pBuf->wDuration = cpu_to_le16((WORD)s_uGetDataDuration(pDevice, DATADUR_B, cbFrameLength, byPktType,
5449c685
FB		 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
853static
6b35b7b3 854void
5449c685 855s_vFillRTSHead (
3a215e0f
CC		 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
5449c685
FB		 865 )
866{
867 UINT uRTSFrameLen = 20;
868 WORD wLen = 0x0000;
869
5449c685
FB		 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.
f77f13e2 880 // Otherwise, we need to modify codes for them.
7e809a9b 881 if (byPktType == PK_TYPE_11GB || byPktType == PK_TYPE_11GA) {
5449c685
FB		 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);
7e809a9b 889 BBvCaculateParameter(pDevice, uRTSFrameLen, pDevice->byTopOFDMBasicRate, byPktType,
5449c685
FB		 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
7e809a9b
JL		 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
5449c685
FB		 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)) {
078b078f 903 memcpy(&(pBuf->Data.abyRA[0]), &(psEthHeader->abyDstAddr[0]), ETH_ALEN);
5449c685
FB		 904 }
905 else {
078b078f 906 memcpy(&(pBuf->Data.abyRA[0]), &(pDevice->abyBSSID[0]), ETH_ALEN);
5449c685
FB		 907 }
908 if (pDevice->eOPMode == OP_MODE_AP) {
078b078f 909 memcpy(&(pBuf->Data.abyTA[0]), &(pDevice->abyBSSID[0]), ETH_ALEN);
5449c685
FB		 910 }
911 else {
078b078f 912 memcpy(&(pBuf->Data.abyTA[0]), &(psEthHeader->abySrcAddr[0]), ETH_ALEN);
5449c685
FB		 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);
7e809a9b 922 BBvCaculateParameter(pDevice, uRTSFrameLen, pDevice->byTopOFDMBasicRate, byPktType,
5449c685
FB		 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
7e809a9b
JL		 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
5449c685
FB		 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)) {
078b078f 941 memcpy(&(pBuf->Data.abyRA[0]), &(psEthHeader->abyDstAddr[0]), ETH_ALEN);
5449c685
FB		 942 }
943 else {
078b078f 944 memcpy(&(pBuf->Data.abyRA[0]), &(pDevice->abyBSSID[0]), ETH_ALEN);
5449c685
FB		 945 }
946
947 if (pDevice->eOPMode == OP_MODE_AP) {
078b078f 948 memcpy(&(pBuf->Data.abyTA[0]), &(pDevice->abyBSSID[0]), ETH_ALEN);
5449c685
FB		 949 }
950 else {
078b078f 951 memcpy(&(pBuf->Data.abyTA[0]), &(psEthHeader->abySrcAddr[0]), ETH_ALEN);
5449c685
FB		 952 }
953
954 } // if (byFBOption == AUTO_FB_NONE)
955 }
7e809a9b 956 else if (byPktType == PK_TYPE_11A) {
5449c685
FB		 957 if (byFBOption == AUTO_FB_NONE) {
958 PSRTS_ab pBuf = (PSRTS_ab)pvRTS;
959 //Get SignalField,ServiceField,Length
7e809a9b 960 BBvCaculateParameter(pDevice, uRTSFrameLen, pDevice->byTopOFDMBasicRate, byPktType,
5449c685
FB		 961 (PWORD)&(wLen), (PBYTE)&(pBuf->byServiceField), (PBYTE)&(pBuf->bySignalField)
962 );
963 pBuf->wTransmitLength = cpu_to_le16(wLen);
964 //Get Duration
7e809a9b 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
5449c685
FB		 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)) {
078b078f 972 memcpy(&(pBuf->Data.abyRA[0]), &(psEthHeader->abyDstAddr[0]), ETH_ALEN);
5449c685
FB		 973 }
974 else {
078b078f 975 memcpy(&(pBuf->Data.abyRA[0]), &(pDevice->abyBSSID[0]), ETH_ALEN);
5449c685
FB		 976 }
977
978 if (pDevice->eOPMode == OP_MODE_AP) {
078b078f 979 memcpy(&(pBuf->Data.abyTA[0]), &(pDevice->abyBSSID[0]), ETH_ALEN);
5449c685
FB		 980 }
981 else {
078b078f 982 memcpy(&(pBuf->Data.abyTA[0]), &(psEthHeader->abySrcAddr[0]), ETH_ALEN);
5449c685
FB		 983 }
984
985 }
986 else {
987 PSRTS_a_FB pBuf = (PSRTS_a_FB)pvRTS;
988 //Get SignalField,ServiceField,Length
7e809a9b 989 BBvCaculateParameter(pDevice, uRTSFrameLen, pDevice->byTopOFDMBasicRate, byPktType,
5449c685
FB		 990 (PWORD)&(wLen), (PBYTE)&(pBuf->byServiceField), (PBYTE)&(pBuf->bySignalField)
991 );
992 pBuf->wTransmitLength = cpu_to_le16(wLen);
993 //Get Duration
7e809a9b
JL		 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:
5449c685
FB		 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)) {
078b078f 1003 memcpy(&(pBuf->Data.abyRA[0]), &(psEthHeader->abyDstAddr[0]), ETH_ALEN);
5449c685
FB		 1004 }
1005 else {
078b078f 1006 memcpy(&(pBuf->Data.abyRA[0]), &(pDevice->abyBSSID[0]), ETH_ALEN);
5449c685
FB		 1007 }
1008 if (pDevice->eOPMode == OP_MODE_AP) {
078b078f 1009 memcpy(&(pBuf->Data.abyTA[0]), &(pDevice->abyBSSID[0]), ETH_ALEN);
5449c685
FB		 1010 }
1011 else {
078b078f 1012 memcpy(&(pBuf->Data.abyTA[0]), &(psEthHeader->abySrcAddr[0]), ETH_ALEN);
5449c685
FB		 1013 }
1014 }
1015 }
7e809a9b 1016 else if (byPktType == PK_TYPE_11B) {
5449c685
FB		 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
7e809a9b 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
5449c685
FB		 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)) {
078b078f 1032 memcpy(&(pBuf->Data.abyRA[0]), &(psEthHeader->abyDstAddr[0]), ETH_ALEN);
5449c685
FB		 1033 }
1034 else {
078b078f 1035 memcpy(&(pBuf->Data.abyRA[0]), &(pDevice->abyBSSID[0]), ETH_ALEN);
5449c685
FB		 1036 }
1037
1038 if (pDevice->eOPMode == OP_MODE_AP) {
078b078f 1039 memcpy(&(pBuf->Data.abyTA[0]), &(pDevice->abyBSSID[0]), ETH_ALEN);
5449c685
FB		 1040 }
1041 else {
078b078f 1042 memcpy(&(pBuf->Data.abyTA[0]), &(psEthHeader->abySrcAddr[0]), ETH_ALEN);
5449c685
FB		 1043 }
1044 }
1045}
1046
1047static
6b35b7b3 1048void
5449c685 1049s_vFillCTSHead (
3a215e0f
CC		 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
5449c685
FB		 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
7e809a9b 1074 if (byPktType == PK_TYPE_11GB || byPktType == PK_TYPE_11GA) {
5449c685
FB		 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
7e809a9b 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
5449c685
FB		 1087 pBuf->wDuration_ba += pDevice->wCTSDuration;
1088 pBuf->wDuration_ba = cpu_to_le16(pBuf->wDuration_ba);
1089 //Get CTSDuration_ba_f0
7e809a9b 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
5449c685
FB		 1091 pBuf->wCTSDuration_ba_f0 += pDevice->wCTSDuration;
1092 pBuf->wCTSDuration_ba_f0 = cpu_to_le16(pBuf->wCTSDuration_ba_f0);
1093 //Get CTSDuration_ba_f1
7e809a9b 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
5449c685
FB		 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;
078b078f 1101 memcpy(&(pBuf->Data.abyRA[0]), &(pDevice->abyCurrentNetAddr[0]), ETH_ALEN);
5449c685
FB		 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
7e809a9b 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
5449c685
FB		 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;
078b078f 1119 memcpy(&(pBuf->Data.abyRA[0]), &(pDevice->abyCurrentNetAddr[0]), ETH_ALEN);
5449c685
FB		 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:
f77f13e2 1136 * pDevice - Pointer to adapter
5449c685
FB		 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
1152static
6b35b7b3 1153void
5449c685 1154s_vGenerateTxParameter (
3a215e0f
CC		 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
5449c685
FB		 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
7e809a9b 1174 //DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"s_vGenerateTxParameter...\n");
5449c685
FB		 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
7e809a9b 1193 if (byPktType == PK_TYPE_11GB || byPktType == PK_TYPE_11GA) {
5449c685
FB		 1194
1195 if (pvRTS != NULL) { //RTS_need
1196 //Fill RsvTime
1197 if (pvRrvTime) {
1198 PSRrvTime_gRTS pBuf = (PSRrvTime_gRTS)pvRrvTime;
7e809a9b
JL		 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
5449c685
FB		 1203 pBuf->wTxRrvTime_b = cpu_to_le16((WORD) s_uGetTxRsvTime(pDevice, PK_TYPE_11B, cbFrameSize, pDevice->byTopCCKBasicRate, bNeedACK));//1:CCK
1204 }
1205 //Fill RTS
7e809a9b 1206 s_vFillRTSHead(pDevice, byPktType, pvRTS, cbFrameSize, bNeedACK, bDisCRC, psEthHeader, wCurrentRate, byFBOption);
5449c685
FB		 1207 }
1208 else {//RTS_needless, PCF mode
1209
1210 //Fill RsvTime
1211 if (pvRrvTime) {
1212 PSRrvTime_gCTS pBuf = (PSRrvTime_gCTS)pvRrvTime;
7e809a9b 1213 pBuf->wTxRrvTime_a = cpu_to_le16((WORD)s_uGetTxRsvTime(pDevice, byPktType, cbFrameSize, wCurrentRate, bNeedACK));//2.4G OFDM
5449c685 1214 pBuf->wTxRrvTime_b = cpu_to_le16((WORD)s_uGetTxRsvTime(pDevice, PK_TYPE_11B, cbFrameSize, pDevice->byTopCCKBasicRate, bNeedACK));//1:CCK
7e809a9b 1215 pBuf->wCTSTxRrvTime_ba = cpu_to_le16((WORD)s_uGetRTSCTSRsvTime(pDevice, 3, byPktType, cbFrameSize, wCurrentRate));//3:CTSTxRrvTime_Ba, 1:2.4GHz
5449c685
FB		 1216 }
1217
1218
1219 //Fill CTS
7e809a9b 1220 s_vFillCTSHead(pDevice, uDMAIdx, byPktType, pvCTS, cbFrameSize, bNeedACK, bDisCRC, wCurrentRate, byFBOption);
5449c685
FB		 1221 }
1222 }
7e809a9b 1223 else if (byPktType == PK_TYPE_11A) {
5449c685
FB		 1224
1225 if (pvRTS != NULL) {//RTS_need, non PCF mode
1226 //Fill RsvTime
1227 if (pvRrvTime) {
1228 PSRrvTime_ab pBuf = (PSRrvTime_ab)pvRrvTime;
7e809a9b
JL		 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
5449c685
FB		 1231 }
1232 //Fill RTS
7e809a9b 1233 s_vFillRTSHead(pDevice, byPktType, pvRTS, cbFrameSize, bNeedACK, bDisCRC, psEthHeader, wCurrentRate, byFBOption);
5449c685
FB		 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 }
7e809a9b 1243 else if (byPktType == PK_TYPE_11B) {
5449c685
FB		 1244
1245 if ((pvRTS != NULL)) {//RTS_need, non PCF mode
1246 //Fill RsvTime
1247 if (pvRrvTime) {
1248 PSRrvTime_ab pBuf = (PSRrvTime_ab)pvRrvTime;
7e809a9b 1249 pBuf->wRTSTxRrvTime = cpu_to_le16((WORD)s_uGetRTSCTSRsvTime(pDevice, 0, byPktType, cbFrameSize, wCurrentRate));//0:RTSTxRrvTime_bb, 1:2.4GHz
5449c685
FB		 1250 pBuf->wTxRrvTime = cpu_to_le16((WORD)s_uGetTxRsvTime(pDevice, PK_TYPE_11B, cbFrameSize, wCurrentRate, bNeedACK));//1:CCK
1251 }
1252 //Fill RTS
7e809a9b 1253 s_vFillRTSHead(pDevice, byPktType, pvRTS, cbFrameSize, bNeedACK, bDisCRC, psEthHeader, wCurrentRate, byFBOption);
5449c685
FB		 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 }
7e809a9b 1263 //DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"s_vGenerateTxParameter END.\n");
5449c685
FB		 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*/
1270static
6b35b7b3 1271void
5449c685 1272s_vFillFragParameter(
3a215e0f
CC		 1273 PSDevice pDevice,
1274 PBYTE pbyBuffer,
1275 UINT uTxType,
1276 void * pvtdCurr,
1277 WORD wFragType,
1278 UINT cbReqCount
5449c685
FB		 1279 )
1280{
1281 PSTxBufHead pTxBufHead = (PSTxBufHead) pbyBuffer;
7e809a9b 1282 //DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"s_vFillFragParameter...\n");
5449c685
FB		 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
7e809a9b 1315 //DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"s_vFillFragParameter END\n");
5449c685
FB		 1316}
1317
1318static
1319UINT
1320s_cbFillTxBufHead (
3a215e0f
CC		 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,
3cdec554 1332 PUINT puMACfragNum
5449c685
FB		 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;
830a619c 1379 void * pvRrvTime;
5449c685 1380 PSMICHDRHead pMICHDR;
830a619c
CC		 1381 void * pvRTS;
1382 void * pvCTS;
1383 void * pvTxDataHd;
5449c685
FB		 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
7e809a9b 1393 //DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"s_cbFillTxBufHead...\n");
5449c685
FB		 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);
7e809a9b 1469 if (byPktType == PK_TYPE_11GB || byPktType == PK_TYPE_11GA) {//802.11g packet
5449c685
FB		 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 }
830a619c 1547 memset((void *)(pbyTxBufferAddr + wTxBufSize), 0, (cbHeaderLength - wTxBufSize));
5449c685
FB		 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);
7e809a9b 1568 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"MIC KEY: %lX, %lX\n", dwMICKey0, dwMICKey1);
5449c685
FB		 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 //=========================
7e809a9b 1598 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"Start Fragmentation...\n");
5449c685
FB		 1599 wFragType = FRAGCTL_STAFRAG;
1600
1601
1602 //Fill FIFO,RrvTime,RTS,and CTS
830a619c 1603 s_vGenerateTxParameter(pDevice, byPktType, (void *)psTxBufHd, pvRrvTime, pvRTS, pvCTS,
5449c685
FB		 1604 cbFragmentSize, bNeedACK, uDMAIdx, psEthHeader, pDevice->wCurrentRate);
1605 //Fill DataHead
7e809a9b 1606 uDuration = s_uFillDataHead(pDevice, byPktType, pvTxDataHd, cbFragmentSize, uDMAIdx, bNeedACK,
5449c685
FB		 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
31c21b77 1625 if (ntohs(psEthHeader->wType) > ETH_DATA_LEN) {
5449c685
FB		 1626 if ((psEthHeader->wType == TYPE_PKT_IPX) ||
1627 (psEthHeader->wType == cpu_to_le16(0xF380))) {
51b6d9c2 1628 memcpy((PBYTE) (pbyPayloadHead), &pDevice->abySNAP_Bridgetunnel[0], 6);
5449c685
FB		 1629 }
1630 else {
51b6d9c2 1631 memcpy((PBYTE) (pbyPayloadHead), &pDevice->abySNAP_RFC1042[0], 6);
5449c685
FB		 1632 }
1633 pbyType = (PBYTE) (pbyPayloadHead + 6);
51b6d9c2 1634 memcpy(pbyType, &(psEthHeader->wType), sizeof(WORD));
5449c685
FB		 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 //}
830a619c 1646 //cbReqCount += s_uDoEncryption(pDevice, psEthHeader, (void *)psTxBufHd, byKeySel,
5449c685
FB		 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
830a619c 1656 memcpy(pbyBuffer, (void *)psTxBufHd, uLength);
5449c685
FB		 1657
1658 // Copy the Packet into a tx Buffer
51b6d9c2 1659 memcpy((pbyBuffer + uLength), (pPacket + 14), (cbFragPayloadSize - cb802_1_H_len));
5449c685
FB		 1660
1661
1662 uTotalCopyLength += cbFragPayloadSize - cb802_1_H_len;
1663
1664 if ((bNeedEncrypt == TRUE) && (pTransmitKey != NULL) && (pTransmitKey->byCipherSuite == KEY_CTL_TKIP)) {
7e809a9b 1665 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"Start MIC: %d\n", cbFragPayloadSize);
5449c685
FB		 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 //--------------------
830a619c 1688 s_vFillFragParameter(pDevice, pbyBuffer, uDMAIdx, (void *)ptdCurr, wFragType, cbReqCount);
5449c685
FB		 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 //=========================
7e809a9b 1701 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"Last Fragmentation...\n");
5449c685
FB		 1702 //tmpDescIdx = (uDescIdx + uFragIdx) % pDevice->cbTD[uDMAIdx];
1703
1704 wFragType = FRAGCTL_ENDFRAG;
1705
1706 //Fill FIFO,RrvTime,RTS,and CTS
830a619c 1707 s_vGenerateTxParameter(pDevice, byPktType, (void *)psTxBufHd, pvRrvTime, pvRTS, pvCTS,
5449c685
FB		 1708 cbLastFragmentSize, bNeedACK, uDMAIdx, psEthHeader, pDevice->wCurrentRate);
1709 //Fill DataHead
7e809a9b 1710 uDuration = s_uFillDataHead(pDevice, byPktType, pvTxDataHd, cbLastFragmentSize, uDMAIdx, bNeedACK,
5449c685
FB		 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
830a619c 1743 memcpy(pbyBuffer, (void *)psTxBufHd, uLength);
5449c685
FB		 1744
1745 // Copy the Packet into a tx Buffer
1746 if (bMIC2Frag == FALSE) {
1747
51b6d9c2 1748 memcpy((pbyBuffer + uLength),
5449c685
FB		 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)) {
7e809a9b 1757 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"LAST: uMICFragLen:%d, cbLastFragPayloadSize:%d, uTmpLen:%d\n",
5449c685
FB		 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);
7e809a9b 1766 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"Last MIC:%lX, %lX\n", *pdwMIC_L, *pdwMIC_R);
5449c685
FB		 1767 } else {
1768 if (uMICFragLen >= 4) {
51b6d9c2 1769 memcpy((pbyBuffer + uLength), ((PBYTE)&dwSafeMIC_R + (uMICFragLen - 4)),
5449c685 1770 (cbMIClen - uMICFragLen));
7e809a9b 1771 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"LAST: uMICFragLen >= 4: %X, %d\n",
5449c685
FB		 1772 *(PBYTE)((PBYTE)&dwSafeMIC_R + (uMICFragLen - 4)),
1773 (cbMIClen - uMICFragLen));
1774
1775 } else {
51b6d9c2 1776 memcpy((pbyBuffer + uLength), ((PBYTE)&dwSafeMIC_L + uMICFragLen),
5449c685 1777 (4 - uMICFragLen));
51b6d9c2 1778 memcpy((pbyBuffer + uLength + (4 - uMICFragLen)), &dwSafeMIC_R, 4);
7e809a9b 1779 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"LAST: uMICFragLen < 4: %X, %d\n",
5449c685
FB		 1780 *(PBYTE)((PBYTE)&dwSafeMIC_R + uMICFragLen - 4),
1781 (cbMIClen - uMICFragLen));
1782 }
1783 /*
1784 for (ii = 0; ii < cbLastFragPayloadSize + 8 + 24; ii++) {
7e809a9b 1785 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"%02x ", *((PBYTE)((pbyBuffer + uLength) + ii - 8 - 24)));
5449c685 1786 }
7e809a9b 1787 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"\n\n");
5449c685
FB		 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
830a619c 1817 s_vFillFragParameter(pDevice, pbyBuffer, uDMAIdx, (void *)ptdCurr, wFragType, cbReqCount);
5449c685
FB		 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 //=========================
7e809a9b 1831 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"Middle Fragmentation...\n");
5449c685
FB		 1832 //tmpDescIdx = (uDescIdx + uFragIdx) % pDevice->cbTD[uDMAIdx];
1833
1834 wFragType = FRAGCTL_MIDFRAG;
1835
1836 //Fill FIFO,RrvTime,RTS,and CTS
830a619c 1837 s_vGenerateTxParameter(pDevice, byPktType, (void *)psTxBufHd, pvRrvTime, pvRTS, pvCTS,
5449c685
FB		 1838 cbFragmentSize, bNeedACK, uDMAIdx, psEthHeader, pDevice->wCurrentRate);
1839 //Fill DataHead
7e809a9b 1840 uDuration = s_uFillDataHead(pDevice, byPktType, pvTxDataHd, cbFragmentSize, uDMAIdx, bNeedACK,
5449c685
FB		 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 //}
830a619c 1867 //cbReqCount += s_uDoEncryption(pDevice, psEthHeader, (void *)psTxBufHd, byKeySel,
5449c685
FB		 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
830a619c 1878 memcpy(pbyBuffer, (void *)psTxBufHd, uLength);
5449c685
FB		 1879
1880 // Copy the Packet into a tx Buffer
51b6d9c2 1881 memcpy((pbyBuffer + uLength),
5449c685
FB		 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
7e809a9b 1904 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"MIDDLE: uMICFragLen:%d, cbFragPayloadSize:%d, uTmpLen:%d\n",
5449c685 1905 uMICFragLen, cbFragPayloadSize, uTmpLen);
7e809a9b 1906 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"Fill MIC in Middle frag [%d]\n", uMICFragLen);
5449c685
FB		 1907 /*
1908 for (ii = 0; ii < uMICFragLen; ii++) {
7e809a9b 1909 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"%02x ", *((PBYTE)((pbyBuffer + uLength + uTmpLen) + ii)));
5449c685 1910 }
7e809a9b 1911 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"\n");
5449c685 1912 */
7e809a9b 1913 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"Get MIC:%lX, %lX\n", *pdwMIC_L, *pdwMIC_R);
5449c685 1914 }
7e809a9b 1915 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"Middle frag len: %d\n", uTmpLen);
5449c685
FB		 1916 /*
1917 for (ii = 0; ii < uTmpLen; ii++) {
7e809a9b 1918 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"%02x ", *((PBYTE)((pbyBuffer + uLength) + ii)));
5449c685 1919 }
7e809a9b 1920 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"\n\n");
5449c685
FB		 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
830a619c 1944 s_vFillFragParameter(pDevice, pbyBuffer, uDMAIdx, (void *)ptdCurr, wFragType, cbReqCount);
5449c685
FB		 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 //=========================
7e809a9b
JL		 1959 //DBG_PRTGRP03(("No Fragmentation...\n"));
1960 //DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"No Fragmentation...\n");
5449c685
FB		 1961 wFragType = FRAGCTL_NONFRAG;
1962
1963 //Set FragCtl in TxBufferHead
1964 psTxBufHd->wFragCtl |= (WORD)wFragType;
1965
1966 //Fill FIFO,RrvTime,RTS,and CTS
830a619c 1967 s_vGenerateTxParameter(pDevice, byPktType, (void *)psTxBufHd, pvRrvTime, pvRTS, pvCTS,
5449c685
FB		 1968 cbFrameSize, bNeedACK, uDMAIdx, psEthHeader, pDevice->wCurrentRate);
1969 //Fill DataHead
7e809a9b 1970 uDuration = s_uFillDataHead(pDevice, byPktType, pvTxDataHd, cbFrameSize, uDMAIdx, bNeedACK,
5449c685
FB		 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
31c21b77 1989 if (ntohs(psEthHeader->wType) > ETH_DATA_LEN) {
5449c685
FB		 1990 if ((psEthHeader->wType == TYPE_PKT_IPX) ||
1991 (psEthHeader->wType == cpu_to_le16(0xF380))) {
51b6d9c2 1992 memcpy((PBYTE) (pbyPayloadHead), &pDevice->abySNAP_Bridgetunnel[0], 6);
5449c685
FB		 1993 }
1994 else {
51b6d9c2 1995 memcpy((PBYTE) (pbyPayloadHead), &pDevice->abySNAP_RFC1042[0], 6);
5449c685
FB		 1996 }
1997 pbyType = (PBYTE) (pbyPayloadHead + 6);
51b6d9c2 1998 memcpy(pbyType, &(psEthHeader->wType), sizeof(WORD));
5449c685
FB		 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) {
7e809a9b 2008 // DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"Fill MICHDR...\n");
5449c685
FB		 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
830a619c 2018 memcpy(pbyBuffer, (void *)psTxBufHd, uLength);
5449c685
FB		 2019
2020 // Copy the Packet into a tx Buffer
51b6d9c2 2021 memcpy((pbyBuffer + uLength),
5449c685
FB		 2022 (pPacket + 14),
2023 cbFrameBodySize - cb802_1_H_len
2024 );
2025
2026 if ((bNeedEncrypt == TRUE) && (pTransmitKey != NULL) && (pTransmitKey->byCipherSuite == KEY_CTL_TKIP)){
2027
7e809a9b 2028 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"Length:%d, %d\n", cbFrameBodySize - cb802_1_H_len, uLength);
5449c685
FB		 2029 /*
2030 for (ii = 0; ii < (cbFrameBodySize - cb802_1_H_len); ii++) {
7e809a9b 2031 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"%02x ", *((PBYTE)((pbyBuffer + uLength) + ii)));
5449c685 2032 }
7e809a9b 2033 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"\n");
5449c685
FB		 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
7e809a9b
JL		 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);
5449c685
FB		 2054/*
2055 for (ii = 0; ii < 8; ii++) {
7e809a9b 2056 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"%02x ", *(((PBYTE)(pdwMIC_L) + ii)));
5449c685 2057 }
7e809a9b 2058 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"\n");
5449c685
FB		 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
7e809a9b
JL		 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);
5449c685
FB		 2088
2089 }
2090 *puMACfragNum = uMACfragNum;
7e809a9b 2091 //DBG_PRTGRP03(("s_cbFillTxBufHead END\n"));
5449c685
FB		 2092 return cbHeaderLength;
2093}
2094
2095
6b35b7b3 2096void
5449c685 2097vGenerateFIFOHeader (
3a215e0f
CC		 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,
3cdec554
CC		 2109 PUINT puMACfragNum,
2110 PUINT pcbHeaderSize
5449c685
FB		 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
51b6d9c2 2121 memset(pTxBufHead, 0, wTxBufSize);
5449c685
FB		 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
7e809a9b 2171 if (byPktType == PK_TYPE_11A) {//0000 0000 0000 0000
5449c685
FB		 2172 ;
2173 }
7e809a9b 2174 else if (byPktType == PK_TYPE_11B) {//0000 0001 0000 0000
5449c685
FB		 2175 pTxBufHead->wFIFOCtl |= FIFOCTL_11B;
2176 }
7e809a9b 2177 else if (byPktType == PK_TYPE_11GB) {//0000 0010 0000 0000
5449c685
FB		 2178 pTxBufHead->wFIFOCtl |= FIFOCTL_11GB;
2179 }
7e809a9b 2180 else if (byPktType == PK_TYPE_11GA) {//0000 0011 0000 0000
5449c685
FB		 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*/
7e809a9b 2238 *pcbHeaderSize = s_cbFillTxBufHead(pDevice, byPktType, pbyTxBufferAddr, cbPayloadSize,
5449c685
FB		 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:
f77f13e2 2255 * pDevice - Pointer to adapter
5449c685
FB		 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
6b35b7b3 2267void
5449c685 2268vGenerateMACHeader (
3a215e0f
CC		 2269 PSDevice pDevice,
2270 PBYTE pbyBufferAddr,
2271 WORD wDuration,
2272 PSEthernetHeader psEthHeader,
2273 BOOL bNeedEncrypt,
2274 WORD wFragType,
2275 UINT uDMAIdx,
2276 UINT uFragIdx
5449c685
FB		 2277 )
2278{
2279 PS802_11Header pMACHeader = (PS802_11Header)pbyBufferAddr;
2280
51b6d9c2 2281 memset(pMACHeader, 0, (sizeof(S802_11Header))); //- sizeof(pMACHeader->dwIV)));
5449c685
FB		 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) {
078b078f
CC		 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);
5449c685
FB		 2293 pMACHeader->wFrameCtl |= FC_FROMDS;
2294 }
2295 else {
2296 if (pDevice->eOPMode == OP_MODE_ADHOC) {
078b078f
CC		 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);
5449c685
FB		 2300 }
2301 else {
078b078f
CC		 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);
5449c685
FB		 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);
51b6d9c2 2317 memcpy(pMACA4Header->abyAddr4, pDevice->abyBSSID, WLAN_ADDR_LEN);
5449c685
FB		 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
2340CMD_STATUS csMgmt_xmit(PSDevice pDevice, PSTxMgmtPacket pPacket) {
2341
2342 PSTxDesc pFrstTD;
7e809a9b 2343 BYTE byPktType;
5449c685 2344 PBYTE pbyTxBufferAddr;
830a619c 2345 void * pvRTS;
5449c685 2346 PSCTS pCTS;
830a619c 2347 void * pvTxDataHd;
5449c685
FB		 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;
830a619c
CC		 2365 void * pvRrvTime;
2366 void * pMICHDR;
5449c685
FB		 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;
7e809a9b 2384 byPktType = PK_TYPE_11A;
5449c685
FB		 2385 } else {
2386 wCurrentRate = RATE_1M;
7e809a9b 2387 byPktType = PK_TYPE_11B;
5449c685
FB		 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;
7e809a9b 2405 byPktType = PK_TYPE_11GA;
5449c685
FB		 2406 }
2407 }
2408
2409 //Set packet type
7e809a9b 2410 if (byPktType == PK_TYPE_11A) {//0000 0000 0000 0000
5449c685
FB		 2411 pTxBufHead->wFIFOCtl = 0;
2412 }
7e809a9b 2413 else if (byPktType == PK_TYPE_11B) {//0000 0001 0000 0000
5449c685
FB		 2414 pTxBufHead->wFIFOCtl |= FIFOCTL_11B;
2415 }
7e809a9b 2416 else if (byPktType == PK_TYPE_11GB) {//0000 0010 0000 0000
5449c685
FB		 2417 pTxBufHead->wFIFOCtl |= FIFOCTL_11GB;
2418 }
7e809a9b 2419 else if (byPktType == PK_TYPE_11GA) {//0000 0011 0000 0000
5449c685
FB		 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
7e809a9b 2501 if (byPktType == PK_TYPE_11GB || byPktType == PK_TYPE_11GA) {//802.11g packet
5449c685
FB		 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
830a619c 2519 memset((void *)(pbyTxBufferAddr + wTxBufSize), 0, (cbHeaderSize - wTxBufSize));
5449c685 2520
078b078f
CC		 2521 memcpy(&(sEthHeader.abyDstAddr[0]), &(pPacket->p80211Header->sA3.abyAddr1[0]), ETH_ALEN);
2522 memcpy(&(sEthHeader.abySrcAddr[0]), &(pPacket->p80211Header->sA3.abyAddr2[0]), ETH_ALEN);
5449c685
FB		 2523 //=========================
2524 // No Fragmentation
2525 //=========================
2526 pTxBufHead->wFragCtl |= (WORD)FRAGCTL_NONFRAG;
2527
2528
2529 //Fill FIFO,RrvTime,RTS,and CTS
7e809a9b 2530 s_vGenerateTxParameter(pDevice, byPktType, pbyTxBufferAddr, pvRrvTime, pvRTS, pCTS,
5449c685
FB		 2531 cbFrameSize, bNeedACK, TYPE_TXDMA0, &sEthHeader, wCurrentRate);
2532
2533 //Fill DataHead
7e809a9b 2534 uDuration = s_uFillDataHead(pDevice, byPktType, pvTxDataHd, cbFrameSize, TYPE_TXDMA0, bNeedACK,
5449c685
FB		 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) {
7e809a9b 2571 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"Get GTK.\n");
5449c685
FB		 2572 break;
2573 }
2574 } else {
7e809a9b 2575 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"Get PTK.\n");
5449c685
FB		 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;
7e809a9b 2583 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"KEY is NULL. OP Mode[%d]\n", pDevice->eOPMode);
5449c685 2584 } else {
7e809a9b 2585 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"Get GTK.\n");
5449c685
FB		 2586 }
2587 } while(FALSE);
2588 //Fill TXKEY
2589 s_vFillTxKey(pDevice, (PBYTE)(pTxBufHead->adwTxKey), pbyIVHead, pTransmitKey,
2590 (PBYTE)pMACHeader, (WORD)cbFrameBodySize, NULL);
2591
51b6d9c2
JL		 2592 memcpy(pMACHeader, pPacket->p80211Header, cbMacHdLen);
2593 memcpy(pbyPayloadHead, ((PBYTE)(pPacket->p80211Header) + cbMacHdLen),
5449c685
FB		 2594 cbFrameBodySize);
2595 }
2596 else {
2597 // Copy the Packet into a tx Buffer
51b6d9c2 2598 memcpy(pMACHeader, pPacket->p80211Header, pPacket->cbMPDULen);
5449c685
FB		 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
7e809a9b 2612 if (byPktType == PK_TYPE_11GB || byPktType == PK_TYPE_11GA) {
5449c685
FB		 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) {
7e809a9b 2642 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " available td0 <= 1\n");
5449c685
FB		 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
2662CMD_STATUS csBeacon_xmit(PSDevice pDevice, PSTxMgmtPacket pPacket) {
2663
7e809a9b 2664 BYTE byPktType;
5449c685
FB		 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;
7e809a9b 2680 byPktType = PK_TYPE_11A;
5449c685
FB		 2681 } else {
2682 wCurrentRate = RATE_2M;
7e809a9b 2683 byPktType = PK_TYPE_11B;
5449c685
FB		 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
7e809a9b
JL		 2695 if (byPktType == PK_TYPE_11A) {//0000 0000 0000 0000
2696 pTxDataHead->wDuration = cpu_to_le16((WORD)s_uGetDataDuration(pDevice, DATADUR_A, cbFrameSize, byPktType,
5449c685
FB		 2697 wCurrentRate, FALSE, 0, 0, 1, AUTO_FB_NONE));
2698 }
7e809a9b 2699 else if (byPktType == PK_TYPE_11B) {//0000 0001 0000 0000
5449c685 2700 pTxBufHead->wFIFOCtl |= FIFOCTL_11B;
7e809a9b 2701 pTxDataHead->wDuration = cpu_to_le16((WORD)s_uGetDataDuration(pDevice, DATADUR_B, cbFrameSize, byPktType,
5449c685
FB		 2702 wCurrentRate, FALSE, 0, 0, 1, AUTO_FB_NONE));
2703 }
2704
7e809a9b 2705 BBvCaculateParameter(pDevice, cbFrameSize, wCurrentRate, byPktType,
5449c685
FB		 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);
51b6d9c2 2715 memcpy(pMACHeader, pPacket->p80211Header, pPacket->cbMPDULen);
5449c685
FB		 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
2739UINT
2740cbGetFragCount (
3a215e0f
CC		 2741 PSDevice pDevice,
2742 PSKeyItem pTransmitKey,
2743 UINT cbFrameBodySize,
2744 PSEthernetHeader psEthHeader
5449c685
FB		 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
6b35b7b3 2828void
5449c685
FB		 2829vDMA0_tx_80211(PSDevice pDevice, struct sk_buff *skb, PBYTE pbMPDU, UINT cbMPDULen) {
2830
2831 PSTxDesc pFrstTD;
7e809a9b 2832 BYTE byPktType;
5449c685 2833 PBYTE pbyTxBufferAddr;
830a619c
CC		 2834 void * pvRTS;
2835 void * pvCTS;
2836 void * pvTxDataHd;
5449c685
FB		 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;
830a619c
CC		 2860 void * pvRrvTime;
2861 void * pMICHDR;
5449c685
FB		 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;
7e809a9b 2896 byPktType = PK_TYPE_11A;
5449c685
FB		 2897 } else {
2898 wCurrentRate = RATE_1M;
7e809a9b 2899 byPktType = PK_TYPE_11B;
5449c685
FB		 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;
7e809a9b 2917 byPktType = PK_TYPE_11GA;
5449c685
FB		 2918 }
2919 }
2920
7e809a9b 2921 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"vDMA0_tx_80211: p80211Header->sA3.wFrameCtl = %x \n", p80211Header->sA3.wFrameCtl);
5449c685
FB		 2922
2923 //Set packet type
7e809a9b 2924 if (byPktType == PK_TYPE_11A) {//0000 0000 0000 0000
5449c685
FB		 2925 pTxBufHead->wFIFOCtl = 0;
2926 }
7e809a9b 2927 else if (byPktType == PK_TYPE_11B) {//0000 0001 0000 0000
5449c685
FB		 2928 pTxBufHead->wFIFOCtl |= FIFOCTL_11B;
2929 }
7e809a9b 2930 else if (byPktType == PK_TYPE_11GB) {//0000 0010 0000 0000
5449c685
FB		 2931 pTxBufHead->wFIFOCtl |= FIFOCTL_11GB;
2932 }
7e809a9b 2933 else if (byPktType == PK_TYPE_11GA) {//0000 0011 0000 0000
5449c685
FB		 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
7e809a9b 3043 if (byPktType == PK_TYPE_11GB || byPktType == PK_TYPE_11GA) {//802.11g packet
5449c685
FB		 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
830a619c 3064 memset((void *)(pbyTxBufferAddr + wTxBufSize), 0, (cbHeaderSize - wTxBufSize));
078b078f
CC		 3065 memcpy(&(sEthHeader.abyDstAddr[0]), &(p80211Header->sA3.abyAddr1[0]), ETH_ALEN);
3066 memcpy(&(sEthHeader.abySrcAddr[0]), &(p80211Header->sA3.abyAddr2[0]), ETH_ALEN);
5449c685
FB		 3067 //=========================
3068 // No Fragmentation
3069 //=========================
3070 pTxBufHead->wFragCtl |= (WORD)FRAGCTL_NONFRAG;
3071
3072
3073 //Fill FIFO,RrvTime,RTS,and CTS
7e809a9b 3074 s_vGenerateTxParameter(pDevice, byPktType, pbyTxBufferAddr, pvRrvTime, pvRTS, pvCTS,
5449c685
FB		 3075 cbFrameSize, bNeedACK, TYPE_TXDMA0, &sEthHeader, wCurrentRate);
3076
3077 //Fill DataHead
7e809a9b 3078 uDuration = s_uFillDataHead(pDevice, byPktType, pvTxDataHd, cbFrameSize, TYPE_TXDMA0, bNeedACK,
5449c685
FB		 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);
7e809a9b 3138 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"DMA0_tx_8021:MIC KEY: %lX, %lX\n", dwMICKey0, dwMICKey1);
5449c685
FB		 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
7e809a9b
JL		 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);
5449c685
FB		 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
7e809a9b 3188 if (byPktType == PK_TYPE_11GB || byPktType == PK_TYPE_11GA) {
5449c685
FB		 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) {
7e809a9b 3220 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " available td0 <= 1\n");
5449c685
FB		 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
kernel source for telekom puls (alcatel/mediatek)