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