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