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