2 * Copyright (c) 1996, 2003 VIA Networking Technologies, Inc.
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.
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.
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.
21 * Purpose: handle WMAC/802.3/802.11 rx & tx functions
28 * s_vGenerateTxParameter - Generate tx dma required parameter.
29 * s_vGenerateMACHeader - Translate 802.3 to 802.11 header
30 * csBeacon_xmit - beacon tx function
31 * csMgmt_xmit - management tx function
32 * s_uGetDataDuration - get tx data required duration
33 * s_uFillDataHead- fulfill tx data duration header
34 * s_uGetRTSCTSDuration- get rtx/cts required duration
35 * s_uGetRTSCTSRsvTime- get rts/cts reserved time
36 * s_uGetTxRsvTime- get frame reserved time
37 * s_vFillCTSHead- fulfill CTS ctl header
38 * s_vFillFragParameter- Set fragment ctl parameter.
39 * s_vFillRTSHead- fulfill RTS ctl header
40 * s_vFillTxKey- fulfill tx encrypt key
41 * s_vSWencryption- Software encrypt header
42 * vDMA0_tx_80211- tx 802.11 frame via dma0
43 * vGenerateFIFOHeader- Generate tx FIFO ctl header
65 static int msglevel
= MSG_LEVEL_INFO
;
67 const u16 wTimeStampOff
[2][MAX_RATE
] = {
68 {384, 288, 226, 209, 54, 43, 37, 31, 28, 25, 24, 23}, // Long Preamble
69 {384, 192, 130, 113, 54, 43, 37, 31, 28, 25, 24, 23}, // Short Preamble
72 const u16 wFB_Opt0
[2][5] = {
73 {RATE_12M
, RATE_18M
, RATE_24M
, RATE_36M
, RATE_48M
}, // fallback_rate0
74 {RATE_12M
, RATE_12M
, RATE_18M
, RATE_24M
, RATE_36M
}, // fallback_rate1
76 const u16 wFB_Opt1
[2][5] = {
77 {RATE_12M
, RATE_18M
, RATE_24M
, RATE_24M
, RATE_36M
}, // fallback_rate0
78 {RATE_6M
, RATE_6M
, RATE_12M
, RATE_12M
, RATE_18M
}, // fallback_rate1
85 #define RTSDUR_BA_F0 4
86 #define RTSDUR_AA_F0 5
87 #define RTSDUR_BA_F1 6
88 #define RTSDUR_AA_F1 7
89 #define CTSDUR_BA_F0 8
90 #define CTSDUR_BA_F1 9
93 #define DATADUR_A_F0 12
94 #define DATADUR_A_F1 13
96 static void s_vSaveTxPktInfo(struct vnt_private
*pDevice
, u8 byPktNum
,
97 u8
*pbyDestAddr
, u16 wPktLength
, u16 wFIFOCtl
);
99 static void *s_vGetFreeContext(struct vnt_private
*pDevice
);
101 static void s_vGenerateTxParameter(struct vnt_private
*pDevice
,
102 u8 byPktType
, u16 wCurrentRate
, void *pTxBufHead
, void *pvRrvTime
,
103 void *pvRTS
, void *pvCTS
, u32 cbFrameSize
, int bNeedACK
, u32 uDMAIdx
,
104 struct ethhdr
*psEthHeader
);
106 static u32
s_uFillDataHead(struct vnt_private
*pDevice
,
107 u8 byPktType
, u16 wCurrentRate
, void *pTxDataHead
, u32 cbFrameLength
,
108 u32 uDMAIdx
, int bNeedAck
, u8 byFBOption
);
110 static void s_vGenerateMACHeader(struct vnt_private
*pDevice
,
111 u8
*pbyBufferAddr
, u16 wDuration
, struct ethhdr
*psEthHeader
,
112 int bNeedEncrypt
, u16 wFragType
, u32 uDMAIdx
, u32 uFragIdx
);
114 static void s_vFillTxKey(struct vnt_private
*pDevice
, u8
*pbyBuf
,
115 u8
*pbyIVHead
, PSKeyItem pTransmitKey
, u8
*pbyHdrBuf
, u16 wPayloadLen
,
116 struct vnt_mic_hdr
*mic_hdr
);
118 static void s_vSWencryption(struct vnt_private
*pDevice
,
119 PSKeyItem pTransmitKey
, u8
*pbyPayloadHead
, u16 wPayloadSize
);
121 static unsigned int s_uGetTxRsvTime(struct vnt_private
*pDevice
, u8 byPktType
,
122 u32 cbFrameLength
, u16 wRate
, int bNeedAck
);
124 static u16
s_uGetRTSCTSRsvTime(struct vnt_private
*pDevice
, u8 byRTSRsvType
,
125 u8 byPktType
, u32 cbFrameLength
, u16 wCurrentRate
);
127 static void s_vFillCTSHead(struct vnt_private
*pDevice
, u32 uDMAIdx
,
128 u8 byPktType
, void *pvCTS
, u32 cbFrameLength
, int bNeedAck
,
129 u16 wCurrentRate
, u8 byFBOption
);
131 static void s_vFillRTSHead(struct vnt_private
*pDevice
, u8 byPktType
,
132 void *pvRTS
, u32 cbFrameLength
, int bNeedAck
,
133 struct ethhdr
*psEthHeader
, u16 wCurrentRate
, u8 byFBOption
);
135 static u16
s_uGetDataDuration(struct vnt_private
*pDevice
,
136 u8 byPktType
, int bNeedAck
);
138 static u16
s_uGetRTSCTSDuration(struct vnt_private
*pDevice
,
139 u8 byDurType
, u32 cbFrameLength
, u8 byPktType
, u16 wRate
,
140 int bNeedAck
, u8 byFBOption
);
142 static void *s_vGetFreeContext(struct vnt_private
*pDevice
)
144 PUSB_SEND_CONTEXT pContext
= NULL
;
145 PUSB_SEND_CONTEXT pReturnContext
= NULL
;
148 DBG_PRT(MSG_LEVEL_DEBUG
, KERN_INFO
"GetFreeContext()\n");
150 for (ii
= 0; ii
< pDevice
->cbTD
; ii
++) {
151 pContext
= pDevice
->apTD
[ii
];
152 if (pContext
->bBoolInUse
== false) {
153 pContext
->bBoolInUse
= true;
154 memset(pContext
->Data
, 0, MAX_TOTAL_SIZE_WITH_ALL_HEADERS
);
155 pReturnContext
= pContext
;
159 if ( ii
== pDevice
->cbTD
) {
160 DBG_PRT(MSG_LEVEL_DEBUG
, KERN_INFO
"No Free Tx Context\n");
162 return (void *) pReturnContext
;
165 static void s_vSaveTxPktInfo(struct vnt_private
*pDevice
, u8 byPktNum
,
166 u8
*pbyDestAddr
, u16 wPktLength
, u16 wFIFOCtl
)
168 PSStatCounter pStatistic
= &pDevice
->scStatistic
;
170 if (is_broadcast_ether_addr(pbyDestAddr
))
171 pStatistic
->abyTxPktInfo
[byPktNum
].byBroadMultiUni
= TX_PKT_BROAD
;
172 else if (is_multicast_ether_addr(pbyDestAddr
))
173 pStatistic
->abyTxPktInfo
[byPktNum
].byBroadMultiUni
= TX_PKT_MULTI
;
175 pStatistic
->abyTxPktInfo
[byPktNum
].byBroadMultiUni
= TX_PKT_UNI
;
177 pStatistic
->abyTxPktInfo
[byPktNum
].wLength
= wPktLength
;
178 pStatistic
->abyTxPktInfo
[byPktNum
].wFIFOCtl
= wFIFOCtl
;
179 memcpy(pStatistic
->abyTxPktInfo
[byPktNum
].abyDestAddr
,
184 static void s_vFillTxKey(struct vnt_private
*pDevice
, u8
*pbyBuf
,
185 u8
*pbyIVHead
, PSKeyItem pTransmitKey
, u8
*pbyHdrBuf
,
186 u16 wPayloadLen
, struct vnt_mic_hdr
*mic_hdr
)
188 u32
*pdwIV
= (u32
*)pbyIVHead
;
189 u32
*pdwExtIV
= (u32
*)((u8
*)pbyIVHead
+ 4);
190 struct ieee80211_hdr
*pMACHeader
= (struct ieee80211_hdr
*)pbyHdrBuf
;
194 if (pTransmitKey
== NULL
)
197 dwRevIVCounter
= cpu_to_le32(pDevice
->dwIVCounter
);
198 *pdwIV
= pDevice
->dwIVCounter
;
199 pDevice
->byKeyIndex
= pTransmitKey
->dwKeyIndex
& 0xf;
201 if (pTransmitKey
->byCipherSuite
== KEY_CTL_WEP
) {
202 if (pTransmitKey
->uKeyLength
== WLAN_WEP232_KEYLEN
){
203 memcpy(pDevice
->abyPRNG
, (u8
*)&(dwRevIVCounter
), 3);
204 memcpy(pDevice
->abyPRNG
+3, pTransmitKey
->abyKey
, pTransmitKey
->uKeyLength
);
206 memcpy(pbyBuf
, (u8
*)&(dwRevIVCounter
), 3);
207 memcpy(pbyBuf
+3, pTransmitKey
->abyKey
, pTransmitKey
->uKeyLength
);
208 if(pTransmitKey
->uKeyLength
== WLAN_WEP40_KEYLEN
) {
209 memcpy(pbyBuf
+8, (u8
*)&(dwRevIVCounter
), 3);
210 memcpy(pbyBuf
+11, pTransmitKey
->abyKey
, pTransmitKey
->uKeyLength
);
212 memcpy(pDevice
->abyPRNG
, pbyBuf
, 16);
214 // Append IV after Mac Header
215 *pdwIV
&= WEP_IV_MASK
;//00000000 11111111 11111111 11111111
216 *pdwIV
|= (u32
)pDevice
->byKeyIndex
<< 30;
217 *pdwIV
= cpu_to_le32(*pdwIV
);
218 pDevice
->dwIVCounter
++;
219 if (pDevice
->dwIVCounter
> WEP_IV_MASK
) {
220 pDevice
->dwIVCounter
= 0;
222 } else if (pTransmitKey
->byCipherSuite
== KEY_CTL_TKIP
) {
223 pTransmitKey
->wTSC15_0
++;
224 if (pTransmitKey
->wTSC15_0
== 0) {
225 pTransmitKey
->dwTSC47_16
++;
227 TKIPvMixKey(pTransmitKey
->abyKey
, pDevice
->abyCurrentNetAddr
,
228 pTransmitKey
->wTSC15_0
, pTransmitKey
->dwTSC47_16
, pDevice
->abyPRNG
);
229 memcpy(pbyBuf
, pDevice
->abyPRNG
, 16);
231 memcpy(pdwIV
, pDevice
->abyPRNG
, 3);
233 *(pbyIVHead
+3) = (u8
)(((pDevice
->byKeyIndex
<< 6) & 0xc0) | 0x20); // 0x20 is ExtIV
234 // Append IV&ExtIV after Mac Header
235 *pdwExtIV
= cpu_to_le32(pTransmitKey
->dwTSC47_16
);
236 DBG_PRT(MSG_LEVEL_DEBUG
, KERN_INFO
"vFillTxKey()---- pdwExtIV: %x\n",
239 } else if (pTransmitKey
->byCipherSuite
== KEY_CTL_CCMP
) {
240 pTransmitKey
->wTSC15_0
++;
241 if (pTransmitKey
->wTSC15_0
== 0) {
242 pTransmitKey
->dwTSC47_16
++;
244 memcpy(pbyBuf
, pTransmitKey
->abyKey
, 16);
248 *(pbyIVHead
+3) = (u8
)(((pDevice
->byKeyIndex
<< 6) & 0xc0) | 0x20); // 0x20 is ExtIV
249 *pdwIV
|= cpu_to_le16((u16
)(pTransmitKey
->wTSC15_0
));
250 //Append IV&ExtIV after Mac Header
251 *pdwExtIV
= cpu_to_le32(pTransmitKey
->dwTSC47_16
);
258 mic_hdr
->payload_len
= cpu_to_be16(wPayloadLen
);
259 memcpy(mic_hdr
->mic_addr2
, pMACHeader
->addr2
, ETH_ALEN
);
261 mic_hdr
->tsc_47_16
= cpu_to_be32(pTransmitKey
->dwTSC47_16
);
262 mic_hdr
->tsc_15_0
= cpu_to_be16(pTransmitKey
->wTSC15_0
);
265 if (pDevice
->bLongHeader
)
266 mic_hdr
->hlen
= cpu_to_be16(28);
268 mic_hdr
->hlen
= cpu_to_be16(22);
270 memcpy(mic_hdr
->addr1
, pMACHeader
->addr1
, ETH_ALEN
);
271 memcpy(mic_hdr
->addr2
, pMACHeader
->addr2
, ETH_ALEN
);
274 memcpy(mic_hdr
->addr3
, pMACHeader
->addr3
, ETH_ALEN
);
275 mic_hdr
->frame_control
= cpu_to_le16(pMACHeader
->frame_control
277 mic_hdr
->seq_ctrl
= cpu_to_le16(pMACHeader
->seq_ctrl
& 0xf);
279 if (pDevice
->bLongHeader
)
280 memcpy(mic_hdr
->addr4
, pMACHeader
->addr4
, ETH_ALEN
);
284 static void s_vSWencryption(struct vnt_private
*pDevice
,
285 PSKeyItem pTransmitKey
, u8
*pbyPayloadHead
, u16 wPayloadSize
)
288 u32 dwICV
= 0xffffffff;
291 if (pTransmitKey
== NULL
)
294 if (pTransmitKey
->byCipherSuite
== KEY_CTL_WEP
) {
295 //=======================================================================
296 // Append ICV after payload
297 dwICV
= CRCdwGetCrc32Ex(pbyPayloadHead
, wPayloadSize
, dwICV
);//ICV(Payload)
298 pdwICV
= (u32
*)(pbyPayloadHead
+ wPayloadSize
);
299 // finally, we must invert dwCRC to get the correct answer
300 *pdwICV
= cpu_to_le32(~dwICV
);
302 rc4_init(&pDevice
->SBox
, pDevice
->abyPRNG
, pTransmitKey
->uKeyLength
+ 3);
303 rc4_encrypt(&pDevice
->SBox
, pbyPayloadHead
, pbyPayloadHead
, wPayloadSize
+cbICVlen
);
304 //=======================================================================
305 } else if (pTransmitKey
->byCipherSuite
== KEY_CTL_TKIP
) {
306 //=======================================================================
307 //Append ICV after payload
308 dwICV
= CRCdwGetCrc32Ex(pbyPayloadHead
, wPayloadSize
, dwICV
);//ICV(Payload)
309 pdwICV
= (u32
*)(pbyPayloadHead
+ wPayloadSize
);
310 // finally, we must invert dwCRC to get the correct answer
311 *pdwICV
= cpu_to_le32(~dwICV
);
313 rc4_init(&pDevice
->SBox
, pDevice
->abyPRNG
, TKIP_KEY_LEN
);
314 rc4_encrypt(&pDevice
->SBox
, pbyPayloadHead
, pbyPayloadHead
, wPayloadSize
+cbICVlen
);
315 //=======================================================================
319 static u16
vnt_time_stamp_off(struct vnt_private
*priv
, u16 rate
)
321 return cpu_to_le16(wTimeStampOff
[priv
->byPreambleType
% 2]
325 /*byPktType : PK_TYPE_11A 0
330 static u32
s_uGetTxRsvTime(struct vnt_private
*pDevice
, u8 byPktType
,
331 u32 cbFrameLength
, u16 wRate
, int bNeedAck
)
333 u32 uDataTime
, uAckTime
;
335 uDataTime
= BBuGetFrameTime(pDevice
->byPreambleType
, byPktType
, cbFrameLength
, wRate
);
336 if (byPktType
== PK_TYPE_11B
) {//llb,CCK mode
337 uAckTime
= BBuGetFrameTime(pDevice
->byPreambleType
, byPktType
, 14, (u16
)pDevice
->byTopCCKBasicRate
);
338 } else {//11g 2.4G OFDM mode & 11a 5G OFDM mode
339 uAckTime
= BBuGetFrameTime(pDevice
->byPreambleType
, byPktType
, 14, (u16
)pDevice
->byTopOFDMBasicRate
);
343 return (uDataTime
+ pDevice
->uSIFS
+ uAckTime
);
350 static u16
vnt_rxtx_rsvtime_le16(struct vnt_private
*priv
, u8 pkt_type
,
351 u32 frame_length
, u16 rate
, int need_ack
)
353 return cpu_to_le16((u16
)s_uGetTxRsvTime(priv
, pkt_type
,
354 frame_length
, rate
, need_ack
));
357 //byFreqType: 0=>5GHZ 1=>2.4GHZ
358 static u16
s_uGetRTSCTSRsvTime(struct vnt_private
*pDevice
,
359 u8 byRTSRsvType
, u8 byPktType
, u32 cbFrameLength
, u16 wCurrentRate
)
361 u32 uRrvTime
, uRTSTime
, uCTSTime
, uAckTime
, uDataTime
;
363 uRrvTime
= uRTSTime
= uCTSTime
= uAckTime
= uDataTime
= 0;
365 uDataTime
= BBuGetFrameTime(pDevice
->byPreambleType
, byPktType
, cbFrameLength
, wCurrentRate
);
366 if (byRTSRsvType
== 0) { //RTSTxRrvTime_bb
367 uRTSTime
= BBuGetFrameTime(pDevice
->byPreambleType
, byPktType
, 20, pDevice
->byTopCCKBasicRate
);
368 uCTSTime
= uAckTime
= BBuGetFrameTime(pDevice
->byPreambleType
, byPktType
, 14, pDevice
->byTopCCKBasicRate
);
370 else if (byRTSRsvType
== 1){ //RTSTxRrvTime_ba, only in 2.4GHZ
371 uRTSTime
= BBuGetFrameTime(pDevice
->byPreambleType
, byPktType
, 20, pDevice
->byTopCCKBasicRate
);
372 uCTSTime
= BBuGetFrameTime(pDevice
->byPreambleType
, byPktType
, 14, pDevice
->byTopCCKBasicRate
);
373 uAckTime
= BBuGetFrameTime(pDevice
->byPreambleType
, byPktType
, 14, pDevice
->byTopOFDMBasicRate
);
375 else if (byRTSRsvType
== 2) { //RTSTxRrvTime_aa
376 uRTSTime
= BBuGetFrameTime(pDevice
->byPreambleType
, byPktType
, 20, pDevice
->byTopOFDMBasicRate
);
377 uCTSTime
= uAckTime
= BBuGetFrameTime(pDevice
->byPreambleType
, byPktType
, 14, pDevice
->byTopOFDMBasicRate
);
379 else if (byRTSRsvType
== 3) { //CTSTxRrvTime_ba, only in 2.4GHZ
380 uCTSTime
= BBuGetFrameTime(pDevice
->byPreambleType
, byPktType
, 14, pDevice
->byTopCCKBasicRate
);
381 uAckTime
= BBuGetFrameTime(pDevice
->byPreambleType
, byPktType
, 14, pDevice
->byTopOFDMBasicRate
);
382 uRrvTime
= uCTSTime
+ uAckTime
+ uDataTime
+ 2*pDevice
->uSIFS
;
387 uRrvTime
= uRTSTime
+ uCTSTime
+ uAckTime
+ uDataTime
+ 3*pDevice
->uSIFS
;
388 return cpu_to_le16((u16
)uRrvTime
);
391 //byFreqType 0: 5GHz, 1:2.4Ghz
392 static u16
s_uGetDataDuration(struct vnt_private
*pDevice
,
393 u8 byPktType
, int bNeedAck
)
398 if (byPktType
== PK_TYPE_11B
)
399 uAckTime
= BBuGetFrameTime(pDevice
->byPreambleType
,
400 byPktType
, 14, pDevice
->byTopCCKBasicRate
);
402 uAckTime
= BBuGetFrameTime(pDevice
->byPreambleType
,
403 byPktType
, 14, pDevice
->byTopOFDMBasicRate
);
404 return cpu_to_le16((u16
)(pDevice
->uSIFS
+ uAckTime
));
410 //byFreqType: 0=>5GHZ 1=>2.4GHZ
411 static u16
s_uGetRTSCTSDuration(struct vnt_private
*pDevice
, u8 byDurType
,
412 u32 cbFrameLength
, u8 byPktType
, u16 wRate
, int bNeedAck
,
415 u32 uCTSTime
= 0, uDurTime
= 0;
419 case RTSDUR_BB
: //RTSDuration_bb
420 uCTSTime
= BBuGetFrameTime(pDevice
->byPreambleType
, byPktType
, 14, pDevice
->byTopCCKBasicRate
);
421 uDurTime
= uCTSTime
+ 2*pDevice
->uSIFS
+ s_uGetTxRsvTime(pDevice
, byPktType
, cbFrameLength
, wRate
, bNeedAck
);
424 case RTSDUR_BA
: //RTSDuration_ba
425 uCTSTime
= BBuGetFrameTime(pDevice
->byPreambleType
, byPktType
, 14, pDevice
->byTopCCKBasicRate
);
426 uDurTime
= uCTSTime
+ 2*pDevice
->uSIFS
+ s_uGetTxRsvTime(pDevice
, byPktType
, cbFrameLength
, wRate
, bNeedAck
);
429 case RTSDUR_AA
: //RTSDuration_aa
430 uCTSTime
= BBuGetFrameTime(pDevice
->byPreambleType
, byPktType
, 14, pDevice
->byTopOFDMBasicRate
);
431 uDurTime
= uCTSTime
+ 2*pDevice
->uSIFS
+ s_uGetTxRsvTime(pDevice
, byPktType
, cbFrameLength
, wRate
, bNeedAck
);
434 case CTSDUR_BA
: //CTSDuration_ba
435 uDurTime
= pDevice
->uSIFS
+ s_uGetTxRsvTime(pDevice
, byPktType
, cbFrameLength
, wRate
, bNeedAck
);
438 case RTSDUR_BA_F0
: //RTSDuration_ba_f0
439 uCTSTime
= BBuGetFrameTime(pDevice
->byPreambleType
, byPktType
, 14, pDevice
->byTopCCKBasicRate
);
440 if ((byFBOption
== AUTO_FB_0
) && (wRate
>= RATE_18M
) && (wRate
<=RATE_54M
)) {
441 uDurTime
= uCTSTime
+ 2*pDevice
->uSIFS
+ s_uGetTxRsvTime(pDevice
, byPktType
, cbFrameLength
, wFB_Opt0
[FB_RATE0
][wRate
-RATE_18M
], bNeedAck
);
442 } else if ((byFBOption
== AUTO_FB_1
) && (wRate
>= RATE_18M
) && (wRate
<=RATE_54M
)) {
443 uDurTime
= uCTSTime
+ 2*pDevice
->uSIFS
+ s_uGetTxRsvTime(pDevice
, byPktType
, cbFrameLength
, wFB_Opt1
[FB_RATE0
][wRate
-RATE_18M
], bNeedAck
);
447 case RTSDUR_AA_F0
: //RTSDuration_aa_f0
448 uCTSTime
= BBuGetFrameTime(pDevice
->byPreambleType
, byPktType
, 14, pDevice
->byTopOFDMBasicRate
);
449 if ((byFBOption
== AUTO_FB_0
) && (wRate
>= RATE_18M
) && (wRate
<=RATE_54M
)) {
450 uDurTime
= uCTSTime
+ 2*pDevice
->uSIFS
+ s_uGetTxRsvTime(pDevice
, byPktType
, cbFrameLength
, wFB_Opt0
[FB_RATE0
][wRate
-RATE_18M
], bNeedAck
);
451 } else if ((byFBOption
== AUTO_FB_1
) && (wRate
>= RATE_18M
) && (wRate
<=RATE_54M
)) {
452 uDurTime
= uCTSTime
+ 2*pDevice
->uSIFS
+ s_uGetTxRsvTime(pDevice
, byPktType
, cbFrameLength
, wFB_Opt1
[FB_RATE0
][wRate
-RATE_18M
], bNeedAck
);
456 case RTSDUR_BA_F1
: //RTSDuration_ba_f1
457 uCTSTime
= BBuGetFrameTime(pDevice
->byPreambleType
, byPktType
, 14, pDevice
->byTopCCKBasicRate
);
458 if ((byFBOption
== AUTO_FB_0
) && (wRate
>= RATE_18M
) && (wRate
<=RATE_54M
)) {
459 uDurTime
= uCTSTime
+ 2*pDevice
->uSIFS
+ s_uGetTxRsvTime(pDevice
, byPktType
, cbFrameLength
, wFB_Opt0
[FB_RATE1
][wRate
-RATE_18M
], bNeedAck
);
460 } else if ((byFBOption
== AUTO_FB_1
) && (wRate
>= RATE_18M
) && (wRate
<=RATE_54M
)) {
461 uDurTime
= uCTSTime
+ 2*pDevice
->uSIFS
+ s_uGetTxRsvTime(pDevice
, byPktType
, cbFrameLength
, wFB_Opt1
[FB_RATE1
][wRate
-RATE_18M
], bNeedAck
);
465 case RTSDUR_AA_F1
: //RTSDuration_aa_f1
466 uCTSTime
= BBuGetFrameTime(pDevice
->byPreambleType
, byPktType
, 14, pDevice
->byTopOFDMBasicRate
);
467 if ((byFBOption
== AUTO_FB_0
) && (wRate
>= RATE_18M
) && (wRate
<=RATE_54M
)) {
468 uDurTime
= uCTSTime
+ 2*pDevice
->uSIFS
+ s_uGetTxRsvTime(pDevice
, byPktType
, cbFrameLength
, wFB_Opt0
[FB_RATE1
][wRate
-RATE_18M
], bNeedAck
);
469 } else if ((byFBOption
== AUTO_FB_1
) && (wRate
>= RATE_18M
) && (wRate
<=RATE_54M
)) {
470 uDurTime
= uCTSTime
+ 2*pDevice
->uSIFS
+ s_uGetTxRsvTime(pDevice
, byPktType
, cbFrameLength
, wFB_Opt1
[FB_RATE1
][wRate
-RATE_18M
], bNeedAck
);
474 case CTSDUR_BA_F0
: //CTSDuration_ba_f0
475 if ((byFBOption
== AUTO_FB_0
) && (wRate
>= RATE_18M
) && (wRate
<=RATE_54M
)) {
476 uDurTime
= pDevice
->uSIFS
+ s_uGetTxRsvTime(pDevice
, byPktType
, cbFrameLength
, wFB_Opt0
[FB_RATE0
][wRate
-RATE_18M
], bNeedAck
);
477 } else if ((byFBOption
== AUTO_FB_1
) && (wRate
>= RATE_18M
) && (wRate
<=RATE_54M
)) {
478 uDurTime
= pDevice
->uSIFS
+ s_uGetTxRsvTime(pDevice
, byPktType
, cbFrameLength
, wFB_Opt1
[FB_RATE0
][wRate
-RATE_18M
], bNeedAck
);
482 case CTSDUR_BA_F1
: //CTSDuration_ba_f1
483 if ((byFBOption
== AUTO_FB_0
) && (wRate
>= RATE_18M
) && (wRate
<=RATE_54M
)) {
484 uDurTime
= pDevice
->uSIFS
+ s_uGetTxRsvTime(pDevice
, byPktType
, cbFrameLength
, wFB_Opt0
[FB_RATE1
][wRate
-RATE_18M
], bNeedAck
);
485 } else if ((byFBOption
== AUTO_FB_1
) && (wRate
>= RATE_18M
) && (wRate
<=RATE_54M
)) {
486 uDurTime
= pDevice
->uSIFS
+ s_uGetTxRsvTime(pDevice
, byPktType
, cbFrameLength
, wFB_Opt1
[FB_RATE1
][wRate
-RATE_18M
], bNeedAck
);
494 return cpu_to_le16((u16
)uDurTime
);
497 static u32
s_uFillDataHead(struct vnt_private
*pDevice
,
498 u8 byPktType
, u16 wCurrentRate
, void *pTxDataHead
, u32 cbFrameLength
,
499 u32 uDMAIdx
, int bNeedAck
, u8 byFBOption
)
502 if (pTxDataHead
== NULL
) {
506 if (byPktType
== PK_TYPE_11GB
|| byPktType
== PK_TYPE_11GA
) {
507 if (byFBOption
== AUTO_FB_NONE
) {
508 struct vnt_tx_datahead_g
*pBuf
=
509 (struct vnt_tx_datahead_g
*)pTxDataHead
;
510 //Get SignalField,ServiceField,Length
511 BBvCalculateParameter(pDevice
, cbFrameLength
, wCurrentRate
,
512 byPktType
, &pBuf
->a
);
513 BBvCalculateParameter(pDevice
, cbFrameLength
,
514 pDevice
->byTopCCKBasicRate
, PK_TYPE_11B
, &pBuf
->b
);
515 //Get Duration and TimeStamp
516 pBuf
->wDuration_a
= s_uGetDataDuration(pDevice
,
517 byPktType
, bNeedAck
);
518 pBuf
->wDuration_b
= s_uGetDataDuration(pDevice
,
519 PK_TYPE_11B
, bNeedAck
);
521 pBuf
->wTimeStampOff_a
= vnt_time_stamp_off(pDevice
,
523 pBuf
->wTimeStampOff_b
= vnt_time_stamp_off(pDevice
,
524 pDevice
->byTopCCKBasicRate
);
525 return (pBuf
->wDuration_a
);
528 struct vnt_tx_datahead_g_fb
*pBuf
=
529 (struct vnt_tx_datahead_g_fb
*)pTxDataHead
;
530 //Get SignalField,ServiceField,Length
531 BBvCalculateParameter(pDevice
, cbFrameLength
, wCurrentRate
,
532 byPktType
, &pBuf
->a
);
533 BBvCalculateParameter(pDevice
, cbFrameLength
,
534 pDevice
->byTopCCKBasicRate
, PK_TYPE_11B
, &pBuf
->b
);
535 //Get Duration and TimeStamp
536 pBuf
->wDuration_a
= s_uGetDataDuration(pDevice
,
537 byPktType
, bNeedAck
);
538 pBuf
->wDuration_b
= s_uGetDataDuration(pDevice
,
539 PK_TYPE_11B
, bNeedAck
);
540 pBuf
->wDuration_a_f0
= s_uGetDataDuration(pDevice
,
541 byPktType
, bNeedAck
);
542 pBuf
->wDuration_a_f1
= s_uGetDataDuration(pDevice
,
543 byPktType
, bNeedAck
);
544 pBuf
->wTimeStampOff_a
= vnt_time_stamp_off(pDevice
,
546 pBuf
->wTimeStampOff_b
= vnt_time_stamp_off(pDevice
,
547 pDevice
->byTopCCKBasicRate
);
548 return (pBuf
->wDuration_a
);
549 } //if (byFBOption == AUTO_FB_NONE)
551 else if (byPktType
== PK_TYPE_11A
) {
552 if (byFBOption
!= AUTO_FB_NONE
) {
553 struct vnt_tx_datahead_a_fb
*pBuf
=
554 (struct vnt_tx_datahead_a_fb
*)pTxDataHead
;
555 //Get SignalField,ServiceField,Length
556 BBvCalculateParameter(pDevice
, cbFrameLength
, wCurrentRate
,
557 byPktType
, &pBuf
->a
);
558 //Get Duration and TimeStampOff
559 pBuf
->wDuration
= s_uGetDataDuration(pDevice
,
560 byPktType
, bNeedAck
);
561 pBuf
->wDuration_f0
= s_uGetDataDuration(pDevice
,
562 byPktType
, bNeedAck
);
563 pBuf
->wDuration_f1
= s_uGetDataDuration(pDevice
,
564 byPktType
, bNeedAck
);
565 pBuf
->wTimeStampOff
= vnt_time_stamp_off(pDevice
,
567 return (pBuf
->wDuration
);
569 struct vnt_tx_datahead_ab
*pBuf
=
570 (struct vnt_tx_datahead_ab
*)pTxDataHead
;
571 //Get SignalField,ServiceField,Length
572 BBvCalculateParameter(pDevice
, cbFrameLength
, wCurrentRate
,
573 byPktType
, &pBuf
->ab
);
574 //Get Duration and TimeStampOff
575 pBuf
->wDuration
= s_uGetDataDuration(pDevice
,
576 byPktType
, bNeedAck
);
577 pBuf
->wTimeStampOff
= vnt_time_stamp_off(pDevice
,
579 return (pBuf
->wDuration
);
582 else if (byPktType
== PK_TYPE_11B
) {
583 struct vnt_tx_datahead_ab
*pBuf
=
584 (struct vnt_tx_datahead_ab
*)pTxDataHead
;
585 //Get SignalField,ServiceField,Length
586 BBvCalculateParameter(pDevice
, cbFrameLength
, wCurrentRate
,
587 byPktType
, &pBuf
->ab
);
588 //Get Duration and TimeStampOff
589 pBuf
->wDuration
= s_uGetDataDuration(pDevice
,
590 byPktType
, bNeedAck
);
591 pBuf
->wTimeStampOff
= vnt_time_stamp_off(pDevice
,
593 return (pBuf
->wDuration
);
598 static int vnt_fill_ieee80211_rts(struct vnt_private
*priv
,
599 struct ieee80211_rts
*rts
, struct ethhdr
*eth_hdr
,
602 rts
->duration
= duration
;
603 rts
->frame_control
= TYPE_CTL_RTS
;
605 if (priv
->eOPMode
== OP_MODE_ADHOC
|| priv
->eOPMode
== OP_MODE_AP
)
606 memcpy(rts
->ra
, eth_hdr
->h_dest
, ETH_ALEN
);
608 memcpy(rts
->ra
, priv
->abyBSSID
, ETH_ALEN
);
610 if (priv
->eOPMode
== OP_MODE_AP
)
611 memcpy(rts
->ta
, priv
->abyBSSID
, ETH_ALEN
);
613 memcpy(rts
->ta
, eth_hdr
->h_source
, ETH_ALEN
);
618 static int vnt_rxtx_rts_g_head(struct vnt_private
*priv
,
619 struct vnt_rts_g
*buf
, struct ethhdr
*eth_hdr
,
620 u8 pkt_type
, u32 frame_len
, int need_ack
,
621 u16 current_rate
, u8 fb_option
)
623 u16 rts_frame_len
= 20;
625 BBvCalculateParameter(priv
, rts_frame_len
, priv
->byTopCCKBasicRate
,
626 PK_TYPE_11B
, &buf
->b
);
627 BBvCalculateParameter(priv
, rts_frame_len
,
628 priv
->byTopOFDMBasicRate
, pkt_type
, &buf
->a
);
630 buf
->wDuration_bb
= s_uGetRTSCTSDuration(priv
, RTSDUR_BB
, frame_len
,
631 PK_TYPE_11B
, priv
->byTopCCKBasicRate
, need_ack
, fb_option
);
632 buf
->wDuration_aa
= s_uGetRTSCTSDuration(priv
, RTSDUR_AA
, frame_len
,
633 pkt_type
, current_rate
, need_ack
, fb_option
);
634 buf
->wDuration_ba
= s_uGetRTSCTSDuration(priv
, RTSDUR_BA
, frame_len
,
635 pkt_type
, current_rate
, need_ack
, fb_option
);
637 vnt_fill_ieee80211_rts(priv
, &buf
->data
, eth_hdr
, buf
->wDuration_aa
);
642 static void s_vFillRTSHead(struct vnt_private
*pDevice
, u8 byPktType
,
643 void *pvRTS
, u32 cbFrameLength
, int bNeedAck
,
644 struct ethhdr
*psEthHeader
, u16 wCurrentRate
, u8 byFBOption
)
646 u32 uRTSFrameLen
= 20;
651 // Note: So far RTSHead doesn't appear in ATIM & Beacom DMA, so we don't need to take them into account.
652 // Otherwise, we need to modified codes for them.
653 if (byPktType
== PK_TYPE_11GB
|| byPktType
== PK_TYPE_11GA
) {
654 if (byFBOption
== AUTO_FB_NONE
) {
655 struct vnt_rts_g
*pBuf
= (struct vnt_rts_g
*)pvRTS
;
657 vnt_rxtx_rts_g_head(pDevice
, pBuf
,
658 psEthHeader
, byPktType
, cbFrameLength
,
659 bNeedAck
, wCurrentRate
, byFBOption
);
662 struct vnt_rts_g_fb
*pBuf
= (struct vnt_rts_g_fb
*)pvRTS
;
663 //Get SignalField,ServiceField,Length
664 BBvCalculateParameter(pDevice
, uRTSFrameLen
,
665 pDevice
->byTopCCKBasicRate
, PK_TYPE_11B
, &pBuf
->b
);
666 BBvCalculateParameter(pDevice
, uRTSFrameLen
,
667 pDevice
->byTopOFDMBasicRate
, byPktType
, &pBuf
->a
);
669 pBuf
->wDuration_bb
= s_uGetRTSCTSDuration(pDevice
, RTSDUR_BB
,
670 cbFrameLength
, PK_TYPE_11B
,
671 pDevice
->byTopCCKBasicRate
, bNeedAck
, byFBOption
);
672 pBuf
->wDuration_aa
= s_uGetRTSCTSDuration(pDevice
, RTSDUR_AA
,
673 cbFrameLength
, byPktType
,
674 wCurrentRate
, bNeedAck
, byFBOption
);
675 pBuf
->wDuration_ba
= s_uGetRTSCTSDuration(pDevice
, RTSDUR_BA
,
676 cbFrameLength
, byPktType
,
677 wCurrentRate
, bNeedAck
, byFBOption
);
678 pBuf
->wRTSDuration_ba_f0
= s_uGetRTSCTSDuration(pDevice
,
679 RTSDUR_BA_F0
, cbFrameLength
, byPktType
, wCurrentRate
,
680 bNeedAck
, byFBOption
);
681 pBuf
->wRTSDuration_aa_f0
= s_uGetRTSCTSDuration(pDevice
,
682 RTSDUR_AA_F0
, cbFrameLength
, byPktType
,
683 wCurrentRate
, bNeedAck
, byFBOption
);
684 pBuf
->wRTSDuration_ba_f1
= s_uGetRTSCTSDuration(pDevice
,
685 RTSDUR_BA_F1
, cbFrameLength
, byPktType
, wCurrentRate
,
686 bNeedAck
, byFBOption
);
687 pBuf
->wRTSDuration_aa_f1
= s_uGetRTSCTSDuration(pDevice
,
688 RTSDUR_AA_F1
, cbFrameLength
, byPktType
, wCurrentRate
,
689 bNeedAck
, byFBOption
);
690 pBuf
->data
.duration
= pBuf
->wDuration_aa
;
691 /*Get RTS Frame body*/
692 pBuf
->data
.frame_control
= TYPE_CTL_RTS
;
694 if (pDevice
->eOPMode
== OP_MODE_ADHOC
||
695 pDevice
->eOPMode
== OP_MODE_AP
)
696 memcpy(pBuf
->data
.ra
, psEthHeader
->h_dest
, ETH_ALEN
);
698 memcpy(pBuf
->data
.ra
, pDevice
->abyBSSID
, ETH_ALEN
);
700 if (pDevice
->eOPMode
== OP_MODE_AP
)
701 memcpy(pBuf
->data
.ta
, pDevice
->abyBSSID
, ETH_ALEN
);
703 memcpy(pBuf
->data
.ta
, psEthHeader
->h_source
, ETH_ALEN
);
704 } // if (byFBOption == AUTO_FB_NONE)
706 else if (byPktType
== PK_TYPE_11A
) {
707 if (byFBOption
== AUTO_FB_NONE
) {
708 struct vnt_rts_ab
*pBuf
= (struct vnt_rts_ab
*)pvRTS
;
709 //Get SignalField,ServiceField,Length
710 BBvCalculateParameter(pDevice
, uRTSFrameLen
,
711 pDevice
->byTopOFDMBasicRate
, byPktType
, &pBuf
->ab
);
713 pBuf
->wDuration
= s_uGetRTSCTSDuration(pDevice
, RTSDUR_AA
,
714 cbFrameLength
, byPktType
, wCurrentRate
,
715 bNeedAck
, byFBOption
);
716 pBuf
->data
.duration
= pBuf
->wDuration
;
717 /* Get RTS Frame body */
718 pBuf
->data
.frame_control
= TYPE_CTL_RTS
;
720 if (pDevice
->eOPMode
== OP_MODE_ADHOC
||
721 pDevice
->eOPMode
== OP_MODE_AP
)
722 memcpy(pBuf
->data
.ra
, psEthHeader
->h_dest
, ETH_ALEN
);
724 memcpy(pBuf
->data
.ra
, pDevice
->abyBSSID
, ETH_ALEN
);
726 if (pDevice
->eOPMode
== OP_MODE_AP
)
727 memcpy(pBuf
->data
.ta
, pDevice
->abyBSSID
, ETH_ALEN
);
729 memcpy(pBuf
->data
.ta
, psEthHeader
->h_source
, ETH_ALEN
);
732 struct vnt_rts_a_fb
*pBuf
= (struct vnt_rts_a_fb
*)pvRTS
;
733 //Get SignalField,ServiceField,Length
734 BBvCalculateParameter(pDevice
, uRTSFrameLen
,
735 pDevice
->byTopOFDMBasicRate
, byPktType
, &pBuf
->a
);
737 pBuf
->wDuration
= s_uGetRTSCTSDuration(pDevice
, RTSDUR_AA
,
738 cbFrameLength
, byPktType
, wCurrentRate
,
739 bNeedAck
, byFBOption
);
740 pBuf
->wRTSDuration_f0
= s_uGetRTSCTSDuration(pDevice
,
741 RTSDUR_AA_F0
, cbFrameLength
, byPktType
,
742 wCurrentRate
, bNeedAck
, byFBOption
);
743 pBuf
->wRTSDuration_f1
= s_uGetRTSCTSDuration(pDevice
,
744 RTSDUR_AA_F1
, cbFrameLength
, byPktType
,
745 wCurrentRate
, bNeedAck
, byFBOption
);
746 pBuf
->data
.duration
= pBuf
->wDuration
;
747 /* Get RTS Frame body */
748 pBuf
->data
.frame_control
= TYPE_CTL_RTS
;
750 if (pDevice
->eOPMode
== OP_MODE_ADHOC
||
751 pDevice
->eOPMode
== OP_MODE_AP
)
752 memcpy(pBuf
->data
.ra
, psEthHeader
->h_dest
, ETH_ALEN
);
754 memcpy(pBuf
->data
.ra
, pDevice
->abyBSSID
, ETH_ALEN
);
756 if (pDevice
->eOPMode
== OP_MODE_AP
)
757 memcpy(pBuf
->data
.ta
, pDevice
->abyBSSID
, ETH_ALEN
);
759 memcpy(pBuf
->data
.ta
, psEthHeader
->h_source
, ETH_ALEN
);
762 else if (byPktType
== PK_TYPE_11B
) {
763 struct vnt_rts_ab
*pBuf
= (struct vnt_rts_ab
*)pvRTS
;
764 //Get SignalField,ServiceField,Length
765 BBvCalculateParameter(pDevice
, uRTSFrameLen
, pDevice
->byTopCCKBasicRate
,
766 PK_TYPE_11B
, &pBuf
->ab
);
768 pBuf
->wDuration
= s_uGetRTSCTSDuration(pDevice
, RTSDUR_BB
,
769 cbFrameLength
, byPktType
, wCurrentRate
,
770 bNeedAck
, byFBOption
);
772 pBuf
->data
.duration
= pBuf
->wDuration
;
773 /* Get RTS Frame body */
774 pBuf
->data
.frame_control
= TYPE_CTL_RTS
;
776 if (pDevice
->eOPMode
== OP_MODE_ADHOC
||
777 pDevice
->eOPMode
== OP_MODE_AP
)
778 memcpy(pBuf
->data
.ra
, psEthHeader
->h_dest
, ETH_ALEN
);
780 memcpy(pBuf
->data
.ra
, pDevice
->abyBSSID
, ETH_ALEN
);
782 if (pDevice
->eOPMode
== OP_MODE_AP
)
783 memcpy(pBuf
->data
.ta
, pDevice
->abyBSSID
, ETH_ALEN
);
785 memcpy(pBuf
->data
.ta
, psEthHeader
->h_source
, ETH_ALEN
);
789 static void s_vFillCTSHead(struct vnt_private
*pDevice
, u32 uDMAIdx
,
790 u8 byPktType
, void *pvCTS
, u32 cbFrameLength
, int bNeedAck
,
791 u16 wCurrentRate
, u8 byFBOption
)
793 u32 uCTSFrameLen
= 14;
799 if (byPktType
== PK_TYPE_11GB
|| byPktType
== PK_TYPE_11GA
) {
800 if (byFBOption
!= AUTO_FB_NONE
) {
802 struct vnt_cts_fb
*pBuf
= (struct vnt_cts_fb
*)pvCTS
;
803 /* Get SignalField,ServiceField,Length */
804 BBvCalculateParameter(pDevice
, uCTSFrameLen
,
805 pDevice
->byTopCCKBasicRate
, PK_TYPE_11B
, &pBuf
->b
);
806 pBuf
->wDuration_ba
= s_uGetRTSCTSDuration(pDevice
, CTSDUR_BA
,
807 cbFrameLength
, byPktType
,
808 wCurrentRate
, bNeedAck
, byFBOption
);
809 /* Get CTSDuration_ba_f0 */
810 pBuf
->wCTSDuration_ba_f0
= s_uGetRTSCTSDuration(pDevice
,
811 CTSDUR_BA_F0
, cbFrameLength
, byPktType
, wCurrentRate
,
812 bNeedAck
, byFBOption
);
813 /* Get CTSDuration_ba_f1 */
814 pBuf
->wCTSDuration_ba_f1
= s_uGetRTSCTSDuration(pDevice
,
815 CTSDUR_BA_F1
, cbFrameLength
, byPktType
, wCurrentRate
,
816 bNeedAck
, byFBOption
);
817 /* Get CTS Frame body */
818 pBuf
->data
.duration
= pBuf
->wDuration_ba
;
819 pBuf
->data
.frame_control
= TYPE_CTL_CTS
;
820 memcpy(pBuf
->data
.ra
, pDevice
->abyCurrentNetAddr
, ETH_ALEN
);
822 struct vnt_cts
*pBuf
= (struct vnt_cts
*)pvCTS
;
823 /* Get SignalField,ServiceField,Length */
824 BBvCalculateParameter(pDevice
, uCTSFrameLen
,
825 pDevice
->byTopCCKBasicRate
, PK_TYPE_11B
, &pBuf
->b
);
826 /* Get CTSDuration_ba */
827 pBuf
->wDuration_ba
= s_uGetRTSCTSDuration(pDevice
,
828 CTSDUR_BA
, cbFrameLength
, byPktType
,
829 wCurrentRate
, bNeedAck
, byFBOption
);
830 /*Get CTS Frame body*/
831 pBuf
->data
.duration
= pBuf
->wDuration_ba
;
832 pBuf
->data
.frame_control
= TYPE_CTL_CTS
;
833 memcpy(pBuf
->data
.ra
, pDevice
->abyCurrentNetAddr
, ETH_ALEN
);
841 * Generate FIFO control for MAC & Baseband controller
845 * pDevice - Pointer to adpater
846 * pTxDataHead - Transmit Data Buffer
847 * pTxBufHead - pTxBufHead
848 * pvRrvTime - pvRrvTime
851 * cbFrameSize - Transmit Data Length (Hdr+Payload+FCS)
852 * bNeedACK - If need ACK
853 * uDMAIdx - DMA Index
861 static void s_vGenerateTxParameter(struct vnt_private
*pDevice
,
862 u8 byPktType
, u16 wCurrentRate
, void *pTxBufHead
, void *pvRrvTime
,
863 void *pvRTS
, void *pvCTS
, u32 cbFrameSize
, int bNeedACK
, u32 uDMAIdx
,
864 struct ethhdr
*psEthHeader
)
866 u32 cbMACHdLen
= WLAN_HDR_ADDR3_LEN
; /* 24 */
868 u8 byFBOption
= AUTO_FB_NONE
;
870 //DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"s_vGenerateTxParameter...\n");
871 PSTxBufHead pFifoHead
= (PSTxBufHead
)pTxBufHead
;
872 pFifoHead
->wReserved
= wCurrentRate
;
873 wFifoCtl
= pFifoHead
->wFIFOCtl
;
875 if (wFifoCtl
& FIFOCTL_AUTO_FB_0
) {
876 byFBOption
= AUTO_FB_0
;
878 else if (wFifoCtl
& FIFOCTL_AUTO_FB_1
) {
879 byFBOption
= AUTO_FB_1
;
885 if (pDevice
->bLongHeader
)
886 cbMACHdLen
= WLAN_HDR_ADDR3_LEN
+ 6;
888 if (byPktType
== PK_TYPE_11GB
|| byPktType
== PK_TYPE_11GA
) {
890 if (pvRTS
!= NULL
) { //RTS_need
892 struct vnt_rrv_time_rts
*pBuf
=
893 (struct vnt_rrv_time_rts
*)pvRrvTime
;
894 pBuf
->wRTSTxRrvTime_aa
= s_uGetRTSCTSRsvTime(pDevice
, 2,
895 byPktType
, cbFrameSize
, wCurrentRate
);
896 pBuf
->wRTSTxRrvTime_ba
= s_uGetRTSCTSRsvTime(pDevice
, 1,
897 byPktType
, cbFrameSize
, wCurrentRate
);
898 pBuf
->wRTSTxRrvTime_bb
= s_uGetRTSCTSRsvTime(pDevice
, 0,
899 byPktType
, cbFrameSize
, wCurrentRate
);
900 pBuf
->wTxRrvTime_a
= vnt_rxtx_rsvtime_le16(pDevice
,
901 byPktType
, cbFrameSize
, wCurrentRate
, bNeedACK
);
902 pBuf
->wTxRrvTime_b
= vnt_rxtx_rsvtime_le16(pDevice
,
903 PK_TYPE_11B
, cbFrameSize
, pDevice
->byTopCCKBasicRate
,
906 s_vFillRTSHead(pDevice
, byPktType
, pvRTS
, cbFrameSize
, bNeedACK
,
907 psEthHeader
, wCurrentRate
, byFBOption
);
909 else {//RTS_needless, PCF mode
911 struct vnt_rrv_time_cts
*pBuf
=
912 (struct vnt_rrv_time_cts
*)pvRrvTime
;
913 pBuf
->wTxRrvTime_a
= vnt_rxtx_rsvtime_le16(pDevice
, byPktType
,
914 cbFrameSize
, wCurrentRate
, bNeedACK
);
915 pBuf
->wTxRrvTime_b
= vnt_rxtx_rsvtime_le16(pDevice
,
916 PK_TYPE_11B
, cbFrameSize
,
917 pDevice
->byTopCCKBasicRate
, bNeedACK
);
918 pBuf
->wCTSTxRrvTime_ba
= s_uGetRTSCTSRsvTime(pDevice
, 3,
919 byPktType
, cbFrameSize
, wCurrentRate
);
921 s_vFillCTSHead(pDevice
, uDMAIdx
, byPktType
, pvCTS
, cbFrameSize
,
922 bNeedACK
, wCurrentRate
, byFBOption
);
925 else if (byPktType
== PK_TYPE_11A
) {
927 if (pvRTS
!= NULL
) {//RTS_need, non PCF mode
929 struct vnt_rrv_time_ab
*pBuf
=
930 (struct vnt_rrv_time_ab
*)pvRrvTime
;
931 pBuf
->wRTSTxRrvTime
= s_uGetRTSCTSRsvTime(pDevice
, 2,
932 byPktType
, cbFrameSize
, wCurrentRate
);
933 pBuf
->wTxRrvTime
= vnt_rxtx_rsvtime_le16(pDevice
, byPktType
,
934 cbFrameSize
, wCurrentRate
, bNeedACK
);
936 s_vFillRTSHead(pDevice
, byPktType
, pvRTS
, cbFrameSize
, bNeedACK
,
937 psEthHeader
, wCurrentRate
, byFBOption
);
939 else if (pvRTS
== NULL
) {//RTS_needless, non PCF mode
941 struct vnt_rrv_time_ab
*pBuf
=
942 (struct vnt_rrv_time_ab
*)pvRrvTime
;
943 pBuf
->wTxRrvTime
= vnt_rxtx_rsvtime_le16(pDevice
, PK_TYPE_11A
,
944 cbFrameSize
, wCurrentRate
, bNeedACK
);
947 else if (byPktType
== PK_TYPE_11B
) {
949 if ((pvRTS
!= NULL
)) {//RTS_need, non PCF mode
951 struct vnt_rrv_time_ab
*pBuf
=
952 (struct vnt_rrv_time_ab
*)pvRrvTime
;
953 pBuf
->wRTSTxRrvTime
= s_uGetRTSCTSRsvTime(pDevice
, 0,
954 byPktType
, cbFrameSize
, wCurrentRate
);
955 pBuf
->wTxRrvTime
= vnt_rxtx_rsvtime_le16(pDevice
, PK_TYPE_11B
,
956 cbFrameSize
, wCurrentRate
, bNeedACK
);
958 s_vFillRTSHead(pDevice
, byPktType
, pvRTS
, cbFrameSize
, bNeedACK
,
959 psEthHeader
, wCurrentRate
, byFBOption
);
961 else { //RTS_needless, non PCF mode
963 struct vnt_rrv_time_ab
*pBuf
=
964 (struct vnt_rrv_time_ab
*)pvRrvTime
;
965 pBuf
->wTxRrvTime
= vnt_rxtx_rsvtime_le16(pDevice
, PK_TYPE_11B
,
966 cbFrameSize
, wCurrentRate
, bNeedACK
);
969 //DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"s_vGenerateTxParameter END.\n");
972 u8 * pbyBuffer,//point to pTxBufHead
973 u16 wFragType,//00:Non-Frag, 01:Start, 02:Mid, 03:Last
974 unsigned int cbFragmentSize,//Hdr+payoad+FCS
977 static int s_bPacketToWirelessUsb(struct vnt_private
*pDevice
, u8 byPktType
,
978 struct vnt_tx_buffer
*pTxBufHead
, int bNeedEncryption
,
979 u32 uSkbPacketLen
, u32 uDMAIdx
, struct ethhdr
*psEthHeader
,
980 u8
*pPacket
, PSKeyItem pTransmitKey
, u32 uNodeIndex
, u16 wCurrentRate
,
981 u32
*pcbHeaderLen
, u32
*pcbTotalLen
)
983 struct vnt_manager
*pMgmt
= &pDevice
->vnt_mgmt
;
984 u32 cbFrameSize
, cbFrameBodySize
;
986 u32 cbIVlen
= 0, cbICVlen
= 0, cbMIClen
= 0, cbMACHdLen
= 0;
987 u32 cbFCSlen
= 4, cbMICHDR
= 0;
989 u8
*pbyType
, *pbyMacHdr
, *pbyIVHead
, *pbyPayloadHead
, *pbyTxBufferAddr
;
990 u8 abySNAP_RFC1042
[ETH_ALEN
] = {0xAA, 0xAA, 0x03, 0x00, 0x00, 0x00};
991 u8 abySNAP_Bridgetunnel
[ETH_ALEN
]
992 = {0xAA, 0xAA, 0x03, 0x00, 0x00, 0xF8};
994 u32 cbHeaderLength
= 0, uPadding
= 0;
996 struct vnt_mic_hdr
*pMICHDR
;
1000 u8 byFBOption
= AUTO_FB_NONE
, byFragType
;
1002 u32 dwMICKey0
, dwMICKey1
, dwMIC_Priority
;
1003 u32
*pdwMIC_L
, *pdwMIC_R
;
1004 int bSoftWEP
= false;
1006 pvRrvTime
= pMICHDR
= pvRTS
= pvCTS
= pvTxDataHd
= NULL
;
1008 if (bNeedEncryption
&& pTransmitKey
->pvKeyTable
) {
1009 if (((PSKeyTable
)pTransmitKey
->pvKeyTable
)->bSoftWEP
== true)
1010 bSoftWEP
= true; /* WEP 256 */
1014 if (ntohs(psEthHeader
->h_proto
) > ETH_DATA_LEN
) {
1015 if (pDevice
->dwDiagRefCount
== 0) {
1024 cbFrameBodySize
= uSkbPacketLen
- ETH_HLEN
+ cb802_1_H_len
;
1027 pTxBufHead
->wFIFOCtl
|= (u16
)(byPktType
<<8);
1029 if (pDevice
->dwDiagRefCount
!= 0) {
1031 pTxBufHead
->wFIFOCtl
= pTxBufHead
->wFIFOCtl
& (~FIFOCTL_NEEDACK
);
1032 } else { //if (pDevice->dwDiagRefCount != 0) {
1033 if ((pDevice
->eOPMode
== OP_MODE_ADHOC
) ||
1034 (pDevice
->eOPMode
== OP_MODE_AP
)) {
1035 if (is_multicast_ether_addr(psEthHeader
->h_dest
)) {
1037 pTxBufHead
->wFIFOCtl
=
1038 pTxBufHead
->wFIFOCtl
& (~FIFOCTL_NEEDACK
);
1041 pTxBufHead
->wFIFOCtl
|= FIFOCTL_NEEDACK
;
1045 // MSDUs in Infra mode always need ACK
1047 pTxBufHead
->wFIFOCtl
|= FIFOCTL_NEEDACK
;
1049 } //if (pDevice->dwDiagRefCount != 0) {
1051 pTxBufHead
->wTimeStamp
= DEFAULT_MSDU_LIFETIME_RES_64us
;
1054 if (pDevice
->bLongHeader
)
1055 pTxBufHead
->wFIFOCtl
|= FIFOCTL_LHEAD
;
1057 //Set FRAGCTL_MACHDCNT
1058 if (pDevice
->bLongHeader
) {
1059 cbMACHdLen
= WLAN_HDR_ADDR3_LEN
+ 6;
1061 cbMACHdLen
= WLAN_HDR_ADDR3_LEN
;
1063 pTxBufHead
->wFragCtl
|= (u16
)(cbMACHdLen
<< 10);
1065 //Set FIFOCTL_GrpAckPolicy
1066 if (pDevice
->bGrpAckPolicy
== true) {//0000 0100 0000 0000
1067 pTxBufHead
->wFIFOCtl
|= FIFOCTL_GRPACK
;
1070 //Set Auto Fallback Ctl
1071 if (wCurrentRate
>= RATE_18M
) {
1072 if (pDevice
->byAutoFBCtrl
== AUTO_FB_0
) {
1073 pTxBufHead
->wFIFOCtl
|= FIFOCTL_AUTO_FB_0
;
1074 byFBOption
= AUTO_FB_0
;
1075 } else if (pDevice
->byAutoFBCtrl
== AUTO_FB_1
) {
1076 pTxBufHead
->wFIFOCtl
|= FIFOCTL_AUTO_FB_1
;
1077 byFBOption
= AUTO_FB_1
;
1081 if (bSoftWEP
!= true) {
1082 if ((bNeedEncryption
) && (pTransmitKey
!= NULL
)) { //WEP enabled
1083 if (pTransmitKey
->byCipherSuite
== KEY_CTL_WEP
) { //WEP40 or WEP104
1084 pTxBufHead
->wFragCtl
|= FRAGCTL_LEGACY
;
1086 if (pTransmitKey
->byCipherSuite
== KEY_CTL_TKIP
) {
1087 DBG_PRT(MSG_LEVEL_DEBUG
, KERN_INFO
"Tx Set wFragCtl == FRAGCTL_TKIP\n");
1088 pTxBufHead
->wFragCtl
|= FRAGCTL_TKIP
;
1090 else if (pTransmitKey
->byCipherSuite
== KEY_CTL_CCMP
) { //CCMP
1091 pTxBufHead
->wFragCtl
|= FRAGCTL_AES
;
1096 if ((bNeedEncryption
) && (pTransmitKey
!= NULL
)) {
1097 if (pTransmitKey
->byCipherSuite
== KEY_CTL_WEP
) {
1101 else if (pTransmitKey
->byCipherSuite
== KEY_CTL_TKIP
) {
1102 cbIVlen
= 8;//IV+ExtIV
1106 if (pTransmitKey
->byCipherSuite
== KEY_CTL_CCMP
) {
1107 cbIVlen
= 8;//RSN Header
1109 cbMICHDR
= sizeof(struct vnt_mic_hdr
);
1111 if (bSoftWEP
== false) {
1112 //MAC Header should be padding 0 to DW alignment.
1113 uPadding
= 4 - (cbMACHdLen
%4);
1118 cbFrameSize
= cbMACHdLen
+ cbIVlen
+ (cbFrameBodySize
+ cbMIClen
) + cbICVlen
+ cbFCSlen
;
1120 if ( (bNeedACK
== false) ||(cbFrameSize
< pDevice
->wRTSThreshold
) ) {
1124 pTxBufHead
->wFIFOCtl
|= (FIFOCTL_RTS
| FIFOCTL_LRETRY
);
1127 pbyTxBufferAddr
= (u8
*) &(pTxBufHead
->adwTxKey
[0]);
1128 wTxBufSize
= sizeof(STxBufHead
);
1129 if (byPktType
== PK_TYPE_11GB
|| byPktType
== PK_TYPE_11GA
) {//802.11g packet
1130 if (byFBOption
== AUTO_FB_NONE
) {
1131 if (bRTS
== true) {//RTS_need
1132 pvRrvTime
= (struct vnt_rrv_time_rts
*)
1133 (pbyTxBufferAddr
+ wTxBufSize
);
1134 pMICHDR
= (struct vnt_mic_hdr
*)(pbyTxBufferAddr
+ wTxBufSize
+
1135 sizeof(struct vnt_rrv_time_rts
));
1136 pvRTS
= (struct vnt_rts_g
*) (pbyTxBufferAddr
+ wTxBufSize
+
1137 sizeof(struct vnt_rrv_time_rts
) + cbMICHDR
);
1139 pvTxDataHd
= (struct vnt_tx_datahead_g
*) (pbyTxBufferAddr
+
1140 wTxBufSize
+ sizeof(struct vnt_rrv_time_rts
) +
1141 cbMICHDR
+ sizeof(struct vnt_rts_g
));
1142 cbHeaderLength
= wTxBufSize
+ sizeof(struct vnt_rrv_time_rts
) +
1143 cbMICHDR
+ sizeof(struct vnt_rts_g
) +
1144 sizeof(struct vnt_tx_datahead_g
);
1146 else { //RTS_needless
1147 pvRrvTime
= (struct vnt_rrv_time_cts
*)
1148 (pbyTxBufferAddr
+ wTxBufSize
);
1149 pMICHDR
= (struct vnt_mic_hdr
*) (pbyTxBufferAddr
+ wTxBufSize
+
1150 sizeof(struct vnt_rrv_time_cts
));
1152 pvCTS
= (struct vnt_cts
*) (pbyTxBufferAddr
+ wTxBufSize
+
1153 sizeof(struct vnt_rrv_time_cts
) + cbMICHDR
);
1154 pvTxDataHd
= (struct vnt_tx_datahead_g
*)(pbyTxBufferAddr
+
1155 wTxBufSize
+ sizeof(struct vnt_rrv_time_cts
) +
1156 cbMICHDR
+ sizeof(struct vnt_cts
));
1157 cbHeaderLength
= wTxBufSize
+ sizeof(struct vnt_rrv_time_cts
) +
1158 cbMICHDR
+ sizeof(struct vnt_cts
) +
1159 sizeof(struct vnt_tx_datahead_g
);
1163 if (bRTS
== true) {//RTS_need
1164 pvRrvTime
= (struct vnt_rrv_time_rts
*)(pbyTxBufferAddr
+
1166 pMICHDR
= (struct vnt_mic_hdr
*) (pbyTxBufferAddr
+ wTxBufSize
+
1167 sizeof(struct vnt_rrv_time_rts
));
1168 pvRTS
= (struct vnt_rts_g_fb
*) (pbyTxBufferAddr
+ wTxBufSize
+
1169 sizeof(struct vnt_rrv_time_rts
) + cbMICHDR
);
1171 pvTxDataHd
= (struct vnt_tx_datahead_g_fb
*) (pbyTxBufferAddr
+
1172 wTxBufSize
+ sizeof(struct vnt_rrv_time_rts
) +
1173 cbMICHDR
+ sizeof(struct vnt_rts_g_fb
));
1174 cbHeaderLength
= wTxBufSize
+ sizeof(struct vnt_rrv_time_rts
) +
1175 cbMICHDR
+ sizeof(struct vnt_rts_g_fb
) +
1176 sizeof(struct vnt_tx_datahead_g_fb
);
1178 else if (bRTS
== false) { //RTS_needless
1179 pvRrvTime
= (struct vnt_rrv_time_cts
*)
1180 (pbyTxBufferAddr
+ wTxBufSize
);
1181 pMICHDR
= (struct vnt_mic_hdr
*) (pbyTxBufferAddr
+ wTxBufSize
+
1182 sizeof(struct vnt_rrv_time_cts
));
1184 pvCTS
= (struct vnt_cts_fb
*) (pbyTxBufferAddr
+ wTxBufSize
+
1185 sizeof(struct vnt_rrv_time_cts
) + cbMICHDR
);
1186 pvTxDataHd
= (struct vnt_tx_datahead_g_fb
*) (pbyTxBufferAddr
+
1187 wTxBufSize
+ sizeof(struct vnt_rrv_time_cts
) +
1188 cbMICHDR
+ sizeof(struct vnt_cts_fb
));
1189 cbHeaderLength
= wTxBufSize
+ sizeof(struct vnt_rrv_time_cts
) +
1190 cbMICHDR
+ sizeof(struct vnt_cts_fb
) +
1191 sizeof(struct vnt_tx_datahead_g_fb
);
1195 else {//802.11a/b packet
1196 if (byFBOption
== AUTO_FB_NONE
) {
1197 if (bRTS
== true) {//RTS_need
1198 pvRrvTime
= (struct vnt_rrv_time_ab
*) (pbyTxBufferAddr
+
1200 pMICHDR
= (struct vnt_mic_hdr
*)(pbyTxBufferAddr
+ wTxBufSize
+
1201 sizeof(struct vnt_rrv_time_ab
));
1202 pvRTS
= (struct vnt_rts_ab
*) (pbyTxBufferAddr
+ wTxBufSize
+
1203 sizeof(struct vnt_rrv_time_ab
) + cbMICHDR
);
1205 pvTxDataHd
= (struct vnt_tx_datahead_ab
*)(pbyTxBufferAddr
+
1206 wTxBufSize
+ sizeof(struct vnt_rrv_time_ab
) + cbMICHDR
+
1207 sizeof(struct vnt_rts_ab
));
1208 cbHeaderLength
= wTxBufSize
+ sizeof(struct vnt_rrv_time_ab
) +
1209 cbMICHDR
+ sizeof(struct vnt_rts_ab
) +
1210 sizeof(struct vnt_tx_datahead_ab
);
1212 else if (bRTS
== false) { //RTS_needless, no MICHDR
1213 pvRrvTime
= (struct vnt_rrv_time_ab
*)(pbyTxBufferAddr
+
1215 pMICHDR
= (struct vnt_mic_hdr
*) (pbyTxBufferAddr
+ wTxBufSize
+
1216 sizeof(struct vnt_rrv_time_ab
));
1219 pvTxDataHd
= (struct vnt_tx_datahead_ab
*)(pbyTxBufferAddr
+
1220 wTxBufSize
+ sizeof(struct vnt_rrv_time_ab
) + cbMICHDR
);
1221 cbHeaderLength
= wTxBufSize
+ sizeof(struct vnt_rrv_time_ab
) +
1222 cbMICHDR
+ sizeof(struct vnt_tx_datahead_ab
);
1226 if (bRTS
== true) {//RTS_need
1227 pvRrvTime
= (struct vnt_rrv_time_ab
*)(pbyTxBufferAddr
+
1229 pMICHDR
= (struct vnt_mic_hdr
*) (pbyTxBufferAddr
+ wTxBufSize
+
1230 sizeof(struct vnt_rrv_time_ab
));
1231 pvRTS
= (struct vnt_rts_a_fb
*) (pbyTxBufferAddr
+ wTxBufSize
+
1232 sizeof(struct vnt_rrv_time_ab
) + cbMICHDR
);
1234 pvTxDataHd
= (struct vnt_tx_datahead_a_fb
*)(pbyTxBufferAddr
+
1235 wTxBufSize
+ sizeof(struct vnt_rrv_time_ab
) + cbMICHDR
+
1236 sizeof(struct vnt_rts_a_fb
));
1237 cbHeaderLength
= wTxBufSize
+ sizeof(struct vnt_rrv_time_ab
) +
1238 cbMICHDR
+ sizeof(struct vnt_rts_a_fb
) +
1239 sizeof(struct vnt_tx_datahead_a_fb
);
1241 else if (bRTS
== false) { //RTS_needless
1242 pvRrvTime
= (struct vnt_rrv_time_ab
*)(pbyTxBufferAddr
+
1244 pMICHDR
= (struct vnt_mic_hdr
*)(pbyTxBufferAddr
+ wTxBufSize
+
1245 sizeof(struct vnt_rrv_time_ab
));
1248 pvTxDataHd
= (struct vnt_tx_datahead_a_fb
*)(pbyTxBufferAddr
+
1249 wTxBufSize
+ sizeof(struct vnt_rrv_time_ab
) + cbMICHDR
);
1250 cbHeaderLength
= wTxBufSize
+ sizeof(struct vnt_rrv_time_ab
) +
1251 cbMICHDR
+ sizeof(struct vnt_tx_datahead_a_fb
);
1256 pbyMacHdr
= (u8
*)(pbyTxBufferAddr
+ cbHeaderLength
);
1257 pbyIVHead
= (u8
*)(pbyMacHdr
+ cbMACHdLen
+ uPadding
);
1258 pbyPayloadHead
= (u8
*)(pbyMacHdr
+ cbMACHdLen
+ uPadding
+ cbIVlen
);
1260 //=========================
1262 //=========================
1263 DBG_PRT(MSG_LEVEL_DEBUG
, KERN_INFO
"No Fragmentation...\n");
1264 byFragType
= FRAGCTL_NONFRAG
;
1265 //uDMAIdx = TYPE_AC0DMA;
1266 //pTxBufHead = (PSTxBufHead) &(pTxBufHead->adwTxKey[0]);
1268 //Fill FIFO,RrvTime,RTS,and CTS
1269 s_vGenerateTxParameter(pDevice
, byPktType
, wCurrentRate
,
1270 (void *)pbyTxBufferAddr
, pvRrvTime
, pvRTS
, pvCTS
,
1271 cbFrameSize
, bNeedACK
, uDMAIdx
, psEthHeader
);
1273 uDuration
= s_uFillDataHead(pDevice
, byPktType
, wCurrentRate
, pvTxDataHd
, cbFrameSize
, uDMAIdx
, bNeedACK
,
1275 // Generate TX MAC Header
1276 s_vGenerateMACHeader(pDevice
, pbyMacHdr
, (u16
)uDuration
, psEthHeader
, bNeedEncryption
,
1277 byFragType
, uDMAIdx
, 0);
1279 if (bNeedEncryption
== true) {
1281 s_vFillTxKey(pDevice
, (u8
*)(pTxBufHead
->adwTxKey
), pbyIVHead
, pTransmitKey
,
1282 pbyMacHdr
, (u16
)cbFrameBodySize
, pMICHDR
);
1284 if (pDevice
->bEnableHostWEP
) {
1285 pMgmt
->sNodeDBTable
[uNodeIndex
].dwTSC47_16
= pTransmitKey
->dwTSC47_16
;
1286 pMgmt
->sNodeDBTable
[uNodeIndex
].wTSC15_0
= pTransmitKey
->wTSC15_0
;
1291 if (ntohs(psEthHeader
->h_proto
) > ETH_DATA_LEN
) {
1292 if (pDevice
->dwDiagRefCount
== 0) {
1293 if ((psEthHeader
->h_proto
== cpu_to_be16(ETH_P_IPX
)) ||
1294 (psEthHeader
->h_proto
== cpu_to_le16(0xF380))) {
1295 memcpy((u8
*) (pbyPayloadHead
),
1296 abySNAP_Bridgetunnel
, 6);
1298 memcpy((u8
*) (pbyPayloadHead
), &abySNAP_RFC1042
[0], 6);
1300 pbyType
= (u8
*) (pbyPayloadHead
+ 6);
1301 memcpy(pbyType
, &(psEthHeader
->h_proto
), sizeof(u16
));
1303 memcpy((u8
*) (pbyPayloadHead
), &(psEthHeader
->h_proto
), sizeof(u16
));
1309 if (pPacket
!= NULL
) {
1310 // Copy the Packet into a tx Buffer
1311 memcpy((pbyPayloadHead
+ cb802_1_H_len
),
1312 (pPacket
+ ETH_HLEN
),
1313 uSkbPacketLen
- ETH_HLEN
1317 // while bRelayPacketSend psEthHeader is point to header+payload
1318 memcpy((pbyPayloadHead
+ cb802_1_H_len
), ((u8
*)psEthHeader
) + ETH_HLEN
, uSkbPacketLen
- ETH_HLEN
);
1321 if ((bNeedEncryption
== true) && (pTransmitKey
!= NULL
) && (pTransmitKey
->byCipherSuite
== KEY_CTL_TKIP
)) {
1323 ///////////////////////////////////////////////////////////////////
1325 if (pDevice
->vnt_mgmt
.eAuthenMode
== WMAC_AUTH_WPANONE
) {
1326 dwMICKey0
= *(u32
*)(&pTransmitKey
->abyKey
[16]);
1327 dwMICKey1
= *(u32
*)(&pTransmitKey
->abyKey
[20]);
1329 else if ((pTransmitKey
->dwKeyIndex
& AUTHENTICATOR_KEY
) != 0) {
1330 dwMICKey0
= *(u32
*)(&pTransmitKey
->abyKey
[16]);
1331 dwMICKey1
= *(u32
*)(&pTransmitKey
->abyKey
[20]);
1334 dwMICKey0
= *(u32
*)(&pTransmitKey
->abyKey
[24]);
1335 dwMICKey1
= *(u32
*)(&pTransmitKey
->abyKey
[28]);
1337 // DO Software Michael
1338 MIC_vInit(dwMICKey0
, dwMICKey1
);
1339 MIC_vAppend((u8
*)&(psEthHeader
->h_dest
[0]), 12);
1341 MIC_vAppend((u8
*)&dwMIC_Priority
, 4);
1342 DBG_PRT(MSG_LEVEL_DEBUG
, KERN_INFO
"MIC KEY: %X, %X\n",
1343 dwMICKey0
, dwMICKey1
);
1345 ///////////////////////////////////////////////////////////////////
1347 //DBG_PRN_GRP12(("Length:%d, %d\n", cbFrameBodySize, uFromHDtoPLDLength));
1348 //for (ii = 0; ii < cbFrameBodySize; ii++) {
1349 // DBG_PRN_GRP12(("%02x ", *((u8 *)((pbyPayloadHead + cb802_1_H_len) + ii))));
1351 //DBG_PRN_GRP12(("\n\n\n"));
1353 MIC_vAppend(pbyPayloadHead
, cbFrameBodySize
);
1355 pdwMIC_L
= (u32
*)(pbyPayloadHead
+ cbFrameBodySize
);
1356 pdwMIC_R
= (u32
*)(pbyPayloadHead
+ cbFrameBodySize
+ 4);
1358 MIC_vGetMIC(pdwMIC_L
, pdwMIC_R
);
1361 if (pDevice
->bTxMICFail
== true) {
1364 pDevice
->bTxMICFail
= false;
1366 //DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"uLength: %d, %d\n", uLength, cbFrameBodySize);
1367 //DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"cbReqCount:%d, %d, %d, %d\n", cbReqCount, cbHeaderLength, uPadding, cbIVlen);
1368 //DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"MIC:%lX, %lX\n", *pdwMIC_L, *pdwMIC_R);
1371 if (bSoftWEP
== true) {
1373 s_vSWencryption(pDevice
, pTransmitKey
, (pbyPayloadHead
), (u16
)(cbFrameBodySize
+ cbMIClen
));
1375 } else if ( ((pDevice
->eEncryptionStatus
== Ndis802_11Encryption1Enabled
) && (bNeedEncryption
== true)) ||
1376 ((pDevice
->eEncryptionStatus
== Ndis802_11Encryption2Enabled
) && (bNeedEncryption
== true)) ||
1377 ((pDevice
->eEncryptionStatus
== Ndis802_11Encryption3Enabled
) && (bNeedEncryption
== true)) ) {
1378 cbFrameSize
-= cbICVlen
;
1381 cbFrameSize
-= cbFCSlen
;
1383 *pcbHeaderLen
= cbHeaderLength
;
1384 *pcbTotalLen
= cbHeaderLength
+ cbFrameSize
;
1386 //Set FragCtl in TxBufferHead
1387 pTxBufHead
->wFragCtl
|= (u16
)byFragType
;
1396 * Translate 802.3 to 802.11 header
1400 * pDevice - Pointer to adapter
1401 * dwTxBufferAddr - Transmit Buffer
1402 * pPacket - Packet from upper layer
1403 * cbPacketSize - Transmit Data Length
1405 * pcbHeadSize - Header size of MAC&Baseband control and 802.11 Header
1406 * pcbAppendPayload - size of append payload for 802.1H translation
1408 * Return Value: none
1412 static void s_vGenerateMACHeader(struct vnt_private
*pDevice
,
1413 u8
*pbyBufferAddr
, u16 wDuration
, struct ethhdr
*psEthHeader
,
1414 int bNeedEncrypt
, u16 wFragType
, u32 uDMAIdx
, u32 uFragIdx
)
1416 struct ieee80211_hdr
*pMACHeader
= (struct ieee80211_hdr
*)pbyBufferAddr
;
1418 pMACHeader
->frame_control
= TYPE_802_11_DATA
;
1420 if (pDevice
->eOPMode
== OP_MODE_AP
) {
1421 memcpy(&(pMACHeader
->addr1
[0]),
1422 &(psEthHeader
->h_dest
[0]),
1424 memcpy(&(pMACHeader
->addr2
[0]), &(pDevice
->abyBSSID
[0]), ETH_ALEN
);
1425 memcpy(&(pMACHeader
->addr3
[0]),
1426 &(psEthHeader
->h_source
[0]),
1428 pMACHeader
->frame_control
|= FC_FROMDS
;
1430 if (pDevice
->eOPMode
== OP_MODE_ADHOC
) {
1431 memcpy(&(pMACHeader
->addr1
[0]),
1432 &(psEthHeader
->h_dest
[0]),
1434 memcpy(&(pMACHeader
->addr2
[0]),
1435 &(psEthHeader
->h_source
[0]),
1437 memcpy(&(pMACHeader
->addr3
[0]),
1438 &(pDevice
->abyBSSID
[0]),
1441 memcpy(&(pMACHeader
->addr3
[0]),
1442 &(psEthHeader
->h_dest
[0]),
1444 memcpy(&(pMACHeader
->addr2
[0]),
1445 &(psEthHeader
->h_source
[0]),
1447 memcpy(&(pMACHeader
->addr1
[0]),
1448 &(pDevice
->abyBSSID
[0]),
1450 pMACHeader
->frame_control
|= FC_TODS
;
1455 pMACHeader
->frame_control
|= cpu_to_le16((u16
)WLAN_SET_FC_ISWEP(1));
1457 pMACHeader
->duration_id
= cpu_to_le16(wDuration
);
1459 if (pDevice
->bLongHeader
) {
1460 PWLAN_80211HDR_A4 pMACA4Header
= (PWLAN_80211HDR_A4
) pbyBufferAddr
;
1461 pMACHeader
->frame_control
|= (FC_TODS
| FC_FROMDS
);
1462 memcpy(pMACA4Header
->abyAddr4
, pDevice
->abyBSSID
, WLAN_ADDR_LEN
);
1464 pMACHeader
->seq_ctrl
= cpu_to_le16(pDevice
->wSeqCounter
<< 4);
1466 //Set FragNumber in Sequence Control
1467 pMACHeader
->seq_ctrl
|= cpu_to_le16((u16
)uFragIdx
);
1469 if ((wFragType
== FRAGCTL_ENDFRAG
) || (wFragType
== FRAGCTL_NONFRAG
)) {
1470 pDevice
->wSeqCounter
++;
1471 if (pDevice
->wSeqCounter
> 0x0fff)
1472 pDevice
->wSeqCounter
= 0;
1475 if ((wFragType
== FRAGCTL_STAFRAG
) || (wFragType
== FRAGCTL_MIDFRAG
)) { //StartFrag or MidFrag
1476 pMACHeader
->frame_control
|= FC_MOREFRAG
;
1483 * Request instructs a MAC to transmit a 802.11 management packet through
1484 * the adapter onto the medium.
1488 * hDeviceContext - Pointer to the adapter
1489 * pPacket - A pointer to a descriptor for the packet to transmit
1493 * Return Value: CMD_STATUS_PENDING if MAC Tx resource available; otherwise false
1497 CMD_STATUS
csMgmt_xmit(struct vnt_private
*pDevice
,
1498 struct vnt_tx_mgmt
*pPacket
)
1500 struct vnt_manager
*pMgmt
= &pDevice
->vnt_mgmt
;
1501 struct vnt_tx_buffer
*pTX_Buffer
;
1502 PSTxBufHead pTxBufHead
;
1503 PUSB_SEND_CONTEXT pContext
;
1504 struct ieee80211_hdr
*pMACHeader
;
1505 struct vnt_cts
*pCTS
;
1506 struct ethhdr sEthHeader
;
1507 u8 byPktType
, *pbyTxBufferAddr
;
1508 void *pvRTS
, *pvTxDataHd
, *pvRrvTime
, *pMICHDR
;
1509 u32 uDuration
, cbReqCount
, cbHeaderSize
, cbFrameBodySize
, cbFrameSize
;
1510 int bNeedACK
, bIsPSPOLL
= false;
1511 u32 cbIVlen
= 0, cbICVlen
= 0, cbMIClen
= 0, cbFCSlen
= 4;
1515 u16 wCurrentRate
= RATE_1M
;
1517 pContext
= (PUSB_SEND_CONTEXT
)s_vGetFreeContext(pDevice
);
1519 if (NULL
== pContext
) {
1520 DBG_PRT(MSG_LEVEL_DEBUG
, KERN_INFO
"ManagementSend TX...NO CONTEXT!\n");
1521 return CMD_STATUS_RESOURCES
;
1524 pTX_Buffer
= (struct vnt_tx_buffer
*)&pContext
->Data
[0];
1525 pbyTxBufferAddr
= (u8
*)&(pTX_Buffer
->adwTxKey
[0]);
1526 cbFrameBodySize
= pPacket
->cbPayloadLen
;
1527 pTxBufHead
= (PSTxBufHead
) pbyTxBufferAddr
;
1528 wTxBufSize
= sizeof(STxBufHead
);
1530 if (pDevice
->byBBType
== BB_TYPE_11A
) {
1531 wCurrentRate
= RATE_6M
;
1532 byPktType
= PK_TYPE_11A
;
1534 wCurrentRate
= RATE_1M
;
1535 byPktType
= PK_TYPE_11B
;
1538 // SetPower will cause error power TX state for OFDM Date packet in TX buffer.
1539 // 2004.11.11 Kyle -- Using OFDM power to tx MngPkt will decrease the connection capability.
1540 // And cmd timer will wait data pkt TX finish before scanning so it's OK
1541 // to set power here.
1542 if (pMgmt
->eScanState
!= WMAC_NO_SCANNING
) {
1543 RFbSetPower(pDevice
, wCurrentRate
, pDevice
->byCurrentCh
);
1545 RFbSetPower(pDevice
, wCurrentRate
, pMgmt
->uCurrChannel
);
1547 pDevice
->wCurrentRate
= wCurrentRate
;
1550 if (byPktType
== PK_TYPE_11A
) {//0000 0000 0000 0000
1551 pTxBufHead
->wFIFOCtl
= 0;
1553 else if (byPktType
== PK_TYPE_11B
) {//0000 0001 0000 0000
1554 pTxBufHead
->wFIFOCtl
|= FIFOCTL_11B
;
1556 else if (byPktType
== PK_TYPE_11GB
) {//0000 0010 0000 0000
1557 pTxBufHead
->wFIFOCtl
|= FIFOCTL_11GB
;
1559 else if (byPktType
== PK_TYPE_11GA
) {//0000 0011 0000 0000
1560 pTxBufHead
->wFIFOCtl
|= FIFOCTL_11GA
;
1563 pTxBufHead
->wFIFOCtl
|= FIFOCTL_TMOEN
;
1564 pTxBufHead
->wTimeStamp
= cpu_to_le16(DEFAULT_MGN_LIFETIME_RES_64us
);
1566 if (is_multicast_ether_addr(pPacket
->p80211Header
->sA3
.abyAddr1
)) {
1571 pTxBufHead
->wFIFOCtl
|= FIFOCTL_NEEDACK
;
1574 if ((pMgmt
->eCurrMode
== WMAC_MODE_ESS_AP
) ||
1575 (pMgmt
->eCurrMode
== WMAC_MODE_IBSS_STA
) ) {
1577 pTxBufHead
->wFIFOCtl
|= FIFOCTL_LRETRY
;
1578 //Set Preamble type always long
1579 //pDevice->byPreambleType = PREAMBLE_LONG;
1580 // probe-response don't retry
1581 //if ((pPacket->p80211Header->sA4.wFrameCtl & TYPE_SUBTYPE_MASK) == TYPE_MGMT_PROBE_RSP) {
1582 // bNeedACK = false;
1583 // pTxBufHead->wFIFOCtl &= (~FIFOCTL_NEEDACK);
1587 pTxBufHead
->wFIFOCtl
|= (FIFOCTL_GENINT
| FIFOCTL_ISDMA0
);
1589 if ((pPacket
->p80211Header
->sA4
.wFrameCtl
& TYPE_SUBTYPE_MASK
) == TYPE_CTL_PSPOLL
) {
1591 cbMacHdLen
= WLAN_HDR_ADDR2_LEN
;
1593 cbMacHdLen
= WLAN_HDR_ADDR3_LEN
;
1596 //Set FRAGCTL_MACHDCNT
1597 pTxBufHead
->wFragCtl
|= cpu_to_le16((u16
)(cbMacHdLen
<< 10));
1600 // Although spec says MMPDU can be fragmented; In most case,
1601 // no one will send a MMPDU under fragmentation. With RTS may occur.
1602 pDevice
->bAES
= false; //Set FRAGCTL_WEPTYP
1604 if (WLAN_GET_FC_ISWEP(pPacket
->p80211Header
->sA4
.wFrameCtl
) != 0) {
1605 if (pDevice
->eEncryptionStatus
== Ndis802_11Encryption1Enabled
) {
1608 pTxBufHead
->wFragCtl
|= FRAGCTL_LEGACY
;
1610 else if (pDevice
->eEncryptionStatus
== Ndis802_11Encryption2Enabled
) {
1611 cbIVlen
= 8;//IV+ExtIV
1614 pTxBufHead
->wFragCtl
|= FRAGCTL_TKIP
;
1615 //We need to get seed here for filling TxKey entry.
1616 //TKIPvMixKey(pTransmitKey->abyKey, pDevice->abyCurrentNetAddr,
1617 // pTransmitKey->wTSC15_0, pTransmitKey->dwTSC47_16, pDevice->abyPRNG);
1619 else if (pDevice
->eEncryptionStatus
== Ndis802_11Encryption3Enabled
) {
1620 cbIVlen
= 8;//RSN Header
1622 pTxBufHead
->wFragCtl
|= FRAGCTL_AES
;
1623 pDevice
->bAES
= true;
1625 //MAC Header should be padding 0 to DW alignment.
1626 uPadding
= 4 - (cbMacHdLen
%4);
1630 cbFrameSize
= cbMacHdLen
+ cbFrameBodySize
+ cbIVlen
+ cbMIClen
+ cbICVlen
+ cbFCSlen
;
1632 //Set FIFOCTL_GrpAckPolicy
1633 if (pDevice
->bGrpAckPolicy
== true) {//0000 0100 0000 0000
1634 pTxBufHead
->wFIFOCtl
|= FIFOCTL_GRPACK
;
1636 //the rest of pTxBufHead->wFragCtl:FragTyp will be set later in s_vFillFragParameter()
1638 //Set RrvTime/RTS/CTS Buffer
1639 if (byPktType
== PK_TYPE_11GB
|| byPktType
== PK_TYPE_11GA
) {//802.11g packet
1641 pvRrvTime
= (struct vnt_rrv_time_cts
*) (pbyTxBufferAddr
+ wTxBufSize
);
1644 pCTS
= (struct vnt_cts
*) (pbyTxBufferAddr
+ wTxBufSize
+
1645 sizeof(struct vnt_rrv_time_cts
));
1646 pvTxDataHd
= (struct vnt_tx_datahead_g
*)(pbyTxBufferAddr
+ wTxBufSize
+
1647 sizeof(struct vnt_rrv_time_cts
) + sizeof(struct vnt_cts
));
1648 cbHeaderSize
= wTxBufSize
+ sizeof(struct vnt_rrv_time_cts
) +
1649 sizeof(struct vnt_cts
) + sizeof(struct vnt_tx_datahead_g
);
1651 else { // 802.11a/b packet
1652 pvRrvTime
= (struct vnt_rrv_time_ab
*) (pbyTxBufferAddr
+ wTxBufSize
);
1656 pvTxDataHd
= (struct vnt_tx_datahead_ab
*) (pbyTxBufferAddr
+
1657 wTxBufSize
+ sizeof(struct vnt_rrv_time_ab
));
1658 cbHeaderSize
= wTxBufSize
+ sizeof(struct vnt_rrv_time_ab
) +
1659 sizeof(struct vnt_tx_datahead_ab
);
1662 memcpy(&(sEthHeader
.h_dest
[0]),
1663 &(pPacket
->p80211Header
->sA3
.abyAddr1
[0]),
1665 memcpy(&(sEthHeader
.h_source
[0]),
1666 &(pPacket
->p80211Header
->sA3
.abyAddr2
[0]),
1668 //=========================
1670 //=========================
1671 pTxBufHead
->wFragCtl
|= (u16
)FRAGCTL_NONFRAG
;
1673 //Fill FIFO,RrvTime,RTS,and CTS
1674 s_vGenerateTxParameter(pDevice
, byPktType
, wCurrentRate
, pbyTxBufferAddr
, pvRrvTime
, pvRTS
, pCTS
,
1675 cbFrameSize
, bNeedACK
, TYPE_TXDMA0
, &sEthHeader
);
1678 uDuration
= s_uFillDataHead(pDevice
, byPktType
, wCurrentRate
, pvTxDataHd
, cbFrameSize
, TYPE_TXDMA0
, bNeedACK
,
1681 pMACHeader
= (struct ieee80211_hdr
*) (pbyTxBufferAddr
+ cbHeaderSize
);
1683 cbReqCount
= cbHeaderSize
+ cbMacHdLen
+ uPadding
+ cbIVlen
+ cbFrameBodySize
;
1685 if (WLAN_GET_FC_ISWEP(pPacket
->p80211Header
->sA4
.wFrameCtl
) != 0) {
1687 u8
* pbyPayloadHead
;
1689 PSKeyItem pTransmitKey
= NULL
;
1691 pbyIVHead
= (u8
*)(pbyTxBufferAddr
+ cbHeaderSize
+ cbMacHdLen
+ uPadding
);
1692 pbyPayloadHead
= (u8
*)(pbyTxBufferAddr
+ cbHeaderSize
+ cbMacHdLen
+ uPadding
+ cbIVlen
);
1694 if ((pDevice
->eOPMode
== OP_MODE_INFRASTRUCTURE
) &&
1695 (pDevice
->bLinkPass
== true)) {
1696 pbyBSSID
= pDevice
->abyBSSID
;
1698 if (KeybGetTransmitKey(&(pDevice
->sKey
), pbyBSSID
, PAIRWISE_KEY
, &pTransmitKey
) == false) {
1700 if(KeybGetTransmitKey(&(pDevice
->sKey
), pbyBSSID
, GROUP_KEY
, &pTransmitKey
) == true) {
1701 DBG_PRT(MSG_LEVEL_DEBUG
, KERN_INFO
"Get GTK.\n");
1705 DBG_PRT(MSG_LEVEL_DEBUG
, KERN_INFO
"Get PTK.\n");
1710 pbyBSSID
= pDevice
->abyBroadcastAddr
;
1711 if(KeybGetTransmitKey(&(pDevice
->sKey
), pbyBSSID
, GROUP_KEY
, &pTransmitKey
) == false) {
1712 pTransmitKey
= NULL
;
1713 DBG_PRT(MSG_LEVEL_DEBUG
, KERN_INFO
"KEY is NULL. OP Mode[%d]\n", pDevice
->eOPMode
);
1715 DBG_PRT(MSG_LEVEL_DEBUG
, KERN_INFO
"Get GTK.\n");
1719 s_vFillTxKey(pDevice
, (u8
*)(pTxBufHead
->adwTxKey
), pbyIVHead
, pTransmitKey
,
1720 (u8
*)pMACHeader
, (u16
)cbFrameBodySize
, NULL
);
1722 memcpy(pMACHeader
, pPacket
->p80211Header
, cbMacHdLen
);
1723 memcpy(pbyPayloadHead
, ((u8
*)(pPacket
->p80211Header
) + cbMacHdLen
),
1727 // Copy the Packet into a tx Buffer
1728 memcpy(pMACHeader
, pPacket
->p80211Header
, pPacket
->cbMPDULen
);
1731 pMACHeader
->seq_ctrl
= cpu_to_le16(pDevice
->wSeqCounter
<< 4);
1732 pDevice
->wSeqCounter
++ ;
1733 if (pDevice
->wSeqCounter
> 0x0fff)
1734 pDevice
->wSeqCounter
= 0;
1737 // The MAC will automatically replace the Duration-field of MAC header by Duration-field
1738 // of FIFO control header.
1739 // This will cause AID-field of PS-POLL packet be incorrect (Because PS-POLL's AID field is
1740 // in the same place of other packet's Duration-field).
1741 // And it will cause Cisco-AP to issue Disassociation-packet
1742 if (byPktType
== PK_TYPE_11GB
|| byPktType
== PK_TYPE_11GA
) {
1743 ((struct vnt_tx_datahead_g
*)pvTxDataHd
)->wDuration_a
=
1744 cpu_to_le16(pPacket
->p80211Header
->sA2
.wDurationID
);
1745 ((struct vnt_tx_datahead_g
*)pvTxDataHd
)->wDuration_b
=
1746 cpu_to_le16(pPacket
->p80211Header
->sA2
.wDurationID
);
1748 ((struct vnt_tx_datahead_ab
*)pvTxDataHd
)->wDuration
=
1749 cpu_to_le16(pPacket
->p80211Header
->sA2
.wDurationID
);
1753 pTX_Buffer
->wTxByteCount
= cpu_to_le16((u16
)(cbReqCount
));
1754 pTX_Buffer
->byPKTNO
= (u8
) (((wCurrentRate
<<4) &0x00F0) | ((pDevice
->wSeqCounter
- 1) & 0x000F));
1755 pTX_Buffer
->byType
= 0x00;
1757 pContext
->pPacket
= NULL
;
1758 pContext
->Type
= CONTEXT_MGMT_PACKET
;
1759 pContext
->uBufLen
= (u16
)cbReqCount
+ 4; //USB header
1761 if (WLAN_GET_FC_TODS(pMACHeader
->frame_control
) == 0) {
1762 s_vSaveTxPktInfo(pDevice
, (u8
) (pTX_Buffer
->byPKTNO
& 0x0F), &(pMACHeader
->addr1
[0]), (u16
)cbFrameSize
, pTX_Buffer
->wFIFOCtl
);
1765 s_vSaveTxPktInfo(pDevice
, (u8
) (pTX_Buffer
->byPKTNO
& 0x0F), &(pMACHeader
->addr3
[0]), (u16
)cbFrameSize
, pTX_Buffer
->wFIFOCtl
);
1768 PIPEnsSendBulkOut(pDevice
,pContext
);
1769 return CMD_STATUS_PENDING
;
1772 CMD_STATUS
csBeacon_xmit(struct vnt_private
*pDevice
,
1773 struct vnt_tx_mgmt
*pPacket
)
1775 struct vnt_beacon_buffer
*pTX_Buffer
;
1776 u32 cbFrameSize
= pPacket
->cbMPDULen
+ WLAN_FCS_LEN
;
1777 u32 cbHeaderSize
= 0;
1778 u16 wTxBufSize
= sizeof(STxShortBufHead
);
1779 PSTxShortBufHead pTxBufHead
;
1780 struct ieee80211_hdr
*pMACHeader
;
1781 struct vnt_tx_datahead_ab
*pTxDataHead
;
1783 u32 cbFrameBodySize
;
1785 u8
*pbyTxBufferAddr
;
1786 PUSB_SEND_CONTEXT pContext
;
1789 pContext
= (PUSB_SEND_CONTEXT
)s_vGetFreeContext(pDevice
);
1790 if (NULL
== pContext
) {
1791 status
= CMD_STATUS_RESOURCES
;
1792 DBG_PRT(MSG_LEVEL_DEBUG
, KERN_INFO
"ManagementSend TX...NO CONTEXT!\n");
1796 pTX_Buffer
= (struct vnt_beacon_buffer
*)&pContext
->Data
[0];
1797 pbyTxBufferAddr
= (u8
*)&(pTX_Buffer
->wFIFOCtl
);
1799 cbFrameBodySize
= pPacket
->cbPayloadLen
;
1801 pTxBufHead
= (PSTxShortBufHead
) pbyTxBufferAddr
;
1802 wTxBufSize
= sizeof(STxShortBufHead
);
1804 if (pDevice
->byBBType
== BB_TYPE_11A
) {
1805 wCurrentRate
= RATE_6M
;
1806 pTxDataHead
= (struct vnt_tx_datahead_ab
*)
1807 (pbyTxBufferAddr
+ wTxBufSize
);
1808 //Get SignalField,ServiceField,Length
1809 BBvCalculateParameter(pDevice
, cbFrameSize
, wCurrentRate
, PK_TYPE_11A
,
1811 //Get Duration and TimeStampOff
1812 pTxDataHead
->wDuration
= s_uGetDataDuration(pDevice
,
1813 PK_TYPE_11A
, false);
1814 pTxDataHead
->wTimeStampOff
= vnt_time_stamp_off(pDevice
, wCurrentRate
);
1815 cbHeaderSize
= wTxBufSize
+ sizeof(struct vnt_tx_datahead_ab
);
1817 wCurrentRate
= RATE_1M
;
1818 pTxBufHead
->wFIFOCtl
|= FIFOCTL_11B
;
1819 pTxDataHead
= (struct vnt_tx_datahead_ab
*)
1820 (pbyTxBufferAddr
+ wTxBufSize
);
1821 //Get SignalField,ServiceField,Length
1822 BBvCalculateParameter(pDevice
, cbFrameSize
, wCurrentRate
, PK_TYPE_11B
,
1824 //Get Duration and TimeStampOff
1825 pTxDataHead
->wDuration
= s_uGetDataDuration(pDevice
,
1826 PK_TYPE_11B
, false);
1827 pTxDataHead
->wTimeStampOff
= vnt_time_stamp_off(pDevice
, wCurrentRate
);
1828 cbHeaderSize
= wTxBufSize
+ sizeof(struct vnt_tx_datahead_ab
);
1831 //Generate Beacon Header
1832 pMACHeader
= (struct ieee80211_hdr
*)(pbyTxBufferAddr
+ cbHeaderSize
);
1833 memcpy(pMACHeader
, pPacket
->p80211Header
, pPacket
->cbMPDULen
);
1835 pMACHeader
->duration_id
= 0;
1836 pMACHeader
->seq_ctrl
= cpu_to_le16(pDevice
->wSeqCounter
<< 4);
1837 pDevice
->wSeqCounter
++ ;
1838 if (pDevice
->wSeqCounter
> 0x0fff)
1839 pDevice
->wSeqCounter
= 0;
1841 cbReqCount
= cbHeaderSize
+ WLAN_HDR_ADDR3_LEN
+ cbFrameBodySize
;
1843 pTX_Buffer
->wTxByteCount
= (u16
)cbReqCount
;
1844 pTX_Buffer
->byPKTNO
= (u8
) (((wCurrentRate
<<4) &0x00F0) | ((pDevice
->wSeqCounter
- 1) & 0x000F));
1845 pTX_Buffer
->byType
= 0x01;
1847 pContext
->pPacket
= NULL
;
1848 pContext
->Type
= CONTEXT_MGMT_PACKET
;
1849 pContext
->uBufLen
= (u16
)cbReqCount
+ 4; //USB header
1851 PIPEnsSendBulkOut(pDevice
,pContext
);
1852 return CMD_STATUS_PENDING
;
1856 void vDMA0_tx_80211(struct vnt_private
*pDevice
, struct sk_buff
*skb
)
1858 struct vnt_manager
*pMgmt
= &pDevice
->vnt_mgmt
;
1859 struct vnt_tx_buffer
*pTX_Buffer
;
1861 u8
*pbyTxBufferAddr
;
1862 void *pvRTS
, *pvCTS
, *pvTxDataHd
;
1863 u32 uDuration
, cbReqCount
;
1864 struct ieee80211_hdr
*pMACHeader
;
1865 u32 cbHeaderSize
, cbFrameBodySize
;
1866 int bNeedACK
, bIsPSPOLL
= false;
1867 PSTxBufHead pTxBufHead
;
1869 u32 cbIVlen
= 0, cbICVlen
= 0, cbMIClen
= 0, cbFCSlen
= 4;
1871 u32 cbMICHDR
= 0, uLength
= 0;
1872 u32 dwMICKey0
, dwMICKey1
;
1874 u32
*pdwMIC_L
, *pdwMIC_R
;
1877 struct ethhdr sEthHeader
;
1878 void *pvRrvTime
, *pMICHDR
;
1879 u32 wCurrentRate
= RATE_1M
;
1880 PUWLAN_80211HDR p80211Header
;
1882 int bNodeExist
= false;
1884 PSKeyItem pTransmitKey
= NULL
;
1885 u8
*pbyIVHead
, *pbyPayloadHead
, *pbyMacHdr
;
1886 u32 cbExtSuppRate
= 0;
1887 PUSB_SEND_CONTEXT pContext
;
1889 pvRrvTime
= pMICHDR
= pvRTS
= pvCTS
= pvTxDataHd
= NULL
;
1891 if(skb
->len
<= WLAN_HDR_ADDR3_LEN
) {
1892 cbFrameBodySize
= 0;
1895 cbFrameBodySize
= skb
->len
- WLAN_HDR_ADDR3_LEN
;
1897 p80211Header
= (PUWLAN_80211HDR
)skb
->data
;
1899 pContext
= (PUSB_SEND_CONTEXT
)s_vGetFreeContext(pDevice
);
1901 if (NULL
== pContext
) {
1902 DBG_PRT(MSG_LEVEL_DEBUG
, KERN_INFO
"DMA0 TX...NO CONTEXT!\n");
1903 dev_kfree_skb_irq(skb
);
1907 pTX_Buffer
= (struct vnt_tx_buffer
*)&pContext
->Data
[0];
1908 pbyTxBufferAddr
= (u8
*)(&pTX_Buffer
->adwTxKey
[0]);
1909 pTxBufHead
= (PSTxBufHead
) pbyTxBufferAddr
;
1910 wTxBufSize
= sizeof(STxBufHead
);
1912 if (pDevice
->byBBType
== BB_TYPE_11A
) {
1913 wCurrentRate
= RATE_6M
;
1914 byPktType
= PK_TYPE_11A
;
1916 wCurrentRate
= RATE_1M
;
1917 byPktType
= PK_TYPE_11B
;
1920 // SetPower will cause error power TX state for OFDM Date packet in TX buffer.
1921 // 2004.11.11 Kyle -- Using OFDM power to tx MngPkt will decrease the connection capability.
1922 // And cmd timer will wait data pkt TX finish before scanning so it's OK
1923 // to set power here.
1924 if (pMgmt
->eScanState
!= WMAC_NO_SCANNING
) {
1925 RFbSetPower(pDevice
, wCurrentRate
, pDevice
->byCurrentCh
);
1927 RFbSetPower(pDevice
, wCurrentRate
, pMgmt
->uCurrChannel
);
1930 DBG_PRT(MSG_LEVEL_DEBUG
, KERN_INFO
"vDMA0_tx_80211: p80211Header->sA3.wFrameCtl = %x \n", p80211Header
->sA3
.wFrameCtl
);
1933 if (byPktType
== PK_TYPE_11A
) {//0000 0000 0000 0000
1934 pTxBufHead
->wFIFOCtl
= 0;
1936 else if (byPktType
== PK_TYPE_11B
) {//0000 0001 0000 0000
1937 pTxBufHead
->wFIFOCtl
|= FIFOCTL_11B
;
1939 else if (byPktType
== PK_TYPE_11GB
) {//0000 0010 0000 0000
1940 pTxBufHead
->wFIFOCtl
|= FIFOCTL_11GB
;
1942 else if (byPktType
== PK_TYPE_11GA
) {//0000 0011 0000 0000
1943 pTxBufHead
->wFIFOCtl
|= FIFOCTL_11GA
;
1946 pTxBufHead
->wFIFOCtl
|= FIFOCTL_TMOEN
;
1947 pTxBufHead
->wTimeStamp
= cpu_to_le16(DEFAULT_MGN_LIFETIME_RES_64us
);
1949 if (is_multicast_ether_addr(p80211Header
->sA3
.abyAddr1
)) {
1951 if (pDevice
->bEnableHostWEP
) {
1957 if (pDevice
->bEnableHostWEP
) {
1958 if (BSSbIsSTAInNodeDB(pDevice
, (u8
*)(p80211Header
->sA3
.abyAddr1
), &uNodeIndex
))
1962 pTxBufHead
->wFIFOCtl
|= FIFOCTL_NEEDACK
;
1965 if ((pMgmt
->eCurrMode
== WMAC_MODE_ESS_AP
) ||
1966 (pMgmt
->eCurrMode
== WMAC_MODE_IBSS_STA
) ) {
1968 pTxBufHead
->wFIFOCtl
|= FIFOCTL_LRETRY
;
1969 //Set Preamble type always long
1970 //pDevice->byPreambleType = PREAMBLE_LONG;
1972 // probe-response don't retry
1973 //if ((p80211Header->sA4.wFrameCtl & TYPE_SUBTYPE_MASK) == TYPE_MGMT_PROBE_RSP) {
1974 // bNeedACK = false;
1975 // pTxBufHead->wFIFOCtl &= (~FIFOCTL_NEEDACK);
1979 pTxBufHead
->wFIFOCtl
|= (FIFOCTL_GENINT
| FIFOCTL_ISDMA0
);
1981 if ((p80211Header
->sA4
.wFrameCtl
& TYPE_SUBTYPE_MASK
) == TYPE_CTL_PSPOLL
) {
1983 cbMacHdLen
= WLAN_HDR_ADDR2_LEN
;
1985 cbMacHdLen
= WLAN_HDR_ADDR3_LEN
;
1988 // hostapd daemon ext support rate patch
1989 if (WLAN_GET_FC_FSTYPE(p80211Header
->sA4
.wFrameCtl
) == WLAN_FSTYPE_ASSOCRESP
) {
1991 if (((PWLAN_IE_SUPP_RATES
)pMgmt
->abyCurrSuppRates
)->len
!= 0) {
1992 cbExtSuppRate
+= ((PWLAN_IE_SUPP_RATES
)pMgmt
->abyCurrSuppRates
)->len
+ WLAN_IEHDR_LEN
;
1995 if (((PWLAN_IE_SUPP_RATES
)pMgmt
->abyCurrExtSuppRates
)->len
!= 0) {
1996 cbExtSuppRate
+= ((PWLAN_IE_SUPP_RATES
)pMgmt
->abyCurrExtSuppRates
)->len
+ WLAN_IEHDR_LEN
;
1999 if (cbExtSuppRate
>0) {
2000 cbFrameBodySize
= WLAN_ASSOCRESP_OFF_SUPP_RATES
;
2004 //Set FRAGCTL_MACHDCNT
2005 pTxBufHead
->wFragCtl
|= cpu_to_le16((u16
)cbMacHdLen
<< 10);
2008 // Although spec says MMPDU can be fragmented; In most case,
2009 // no one will send a MMPDU under fragmentation. With RTS may occur.
2010 pDevice
->bAES
= false; //Set FRAGCTL_WEPTYP
2012 if (WLAN_GET_FC_ISWEP(p80211Header
->sA4
.wFrameCtl
) != 0) {
2013 if (pDevice
->eEncryptionStatus
== Ndis802_11Encryption1Enabled
) {
2016 pTxBufHead
->wFragCtl
|= FRAGCTL_LEGACY
;
2018 else if (pDevice
->eEncryptionStatus
== Ndis802_11Encryption2Enabled
) {
2019 cbIVlen
= 8;//IV+ExtIV
2022 pTxBufHead
->wFragCtl
|= FRAGCTL_TKIP
;
2023 //We need to get seed here for filling TxKey entry.
2024 //TKIPvMixKey(pTransmitKey->abyKey, pDevice->abyCurrentNetAddr,
2025 // pTransmitKey->wTSC15_0, pTransmitKey->dwTSC47_16, pDevice->abyPRNG);
2027 else if (pDevice
->eEncryptionStatus
== Ndis802_11Encryption3Enabled
) {
2028 cbIVlen
= 8;//RSN Header
2030 cbMICHDR
= sizeof(struct vnt_mic_hdr
);
2031 pTxBufHead
->wFragCtl
|= FRAGCTL_AES
;
2032 pDevice
->bAES
= true;
2034 //MAC Header should be padding 0 to DW alignment.
2035 uPadding
= 4 - (cbMacHdLen
%4);
2039 cbFrameSize
= cbMacHdLen
+ cbFrameBodySize
+ cbIVlen
+ cbMIClen
+ cbICVlen
+ cbFCSlen
+ cbExtSuppRate
;
2041 //Set FIFOCTL_GrpAckPolicy
2042 if (pDevice
->bGrpAckPolicy
== true) {//0000 0100 0000 0000
2043 pTxBufHead
->wFIFOCtl
|= FIFOCTL_GRPACK
;
2045 //the rest of pTxBufHead->wFragCtl:FragTyp will be set later in s_vFillFragParameter()
2047 if (byPktType
== PK_TYPE_11GB
|| byPktType
== PK_TYPE_11GA
) {//802.11g packet
2048 pvRrvTime
= (struct vnt_rrv_time_cts
*) (pbyTxBufferAddr
+ wTxBufSize
);
2049 pMICHDR
= (struct vnt_mic_hdr
*) (pbyTxBufferAddr
+ wTxBufSize
+
2050 sizeof(struct vnt_rrv_time_cts
));
2052 pvCTS
= (struct vnt_cts
*) (pbyTxBufferAddr
+ wTxBufSize
+
2053 sizeof(struct vnt_rrv_time_cts
) + cbMICHDR
);
2054 pvTxDataHd
= (struct vnt_tx_datahead_g
*) (pbyTxBufferAddr
+
2055 wTxBufSize
+ sizeof(struct vnt_rrv_time_cts
) + cbMICHDR
+
2056 sizeof(struct vnt_cts
));
2057 cbHeaderSize
= wTxBufSize
+ sizeof(struct vnt_rrv_time_cts
) + cbMICHDR
+
2058 sizeof(struct vnt_cts
) + sizeof(struct vnt_tx_datahead_g
);
2061 else {//802.11a/b packet
2063 pvRrvTime
= (struct vnt_rrv_time_ab
*) (pbyTxBufferAddr
+ wTxBufSize
);
2064 pMICHDR
= (struct vnt_mic_hdr
*) (pbyTxBufferAddr
+ wTxBufSize
+
2065 sizeof(struct vnt_rrv_time_ab
));
2068 pvTxDataHd
= (struct vnt_tx_datahead_ab
*)(pbyTxBufferAddr
+
2069 wTxBufSize
+ sizeof(struct vnt_rrv_time_ab
) + cbMICHDR
);
2070 cbHeaderSize
= wTxBufSize
+ sizeof(struct vnt_rrv_time_ab
) + cbMICHDR
+
2071 sizeof(struct vnt_tx_datahead_ab
);
2073 memcpy(&(sEthHeader
.h_dest
[0]),
2074 &(p80211Header
->sA3
.abyAddr1
[0]),
2076 memcpy(&(sEthHeader
.h_source
[0]),
2077 &(p80211Header
->sA3
.abyAddr2
[0]),
2079 //=========================
2081 //=========================
2082 pTxBufHead
->wFragCtl
|= (u16
)FRAGCTL_NONFRAG
;
2084 //Fill FIFO,RrvTime,RTS,and CTS
2085 s_vGenerateTxParameter(pDevice
, byPktType
, wCurrentRate
, pbyTxBufferAddr
, pvRrvTime
, pvRTS
, pvCTS
,
2086 cbFrameSize
, bNeedACK
, TYPE_TXDMA0
, &sEthHeader
);
2089 uDuration
= s_uFillDataHead(pDevice
, byPktType
, wCurrentRate
, pvTxDataHd
, cbFrameSize
, TYPE_TXDMA0
, bNeedACK
,
2092 pMACHeader
= (struct ieee80211_hdr
*) (pbyTxBufferAddr
+ cbHeaderSize
);
2094 cbReqCount
= cbHeaderSize
+ cbMacHdLen
+ uPadding
+ cbIVlen
+ (cbFrameBodySize
+ cbMIClen
) + cbExtSuppRate
;
2096 pbyMacHdr
= (u8
*)(pbyTxBufferAddr
+ cbHeaderSize
);
2097 pbyPayloadHead
= (u8
*)(pbyMacHdr
+ cbMacHdLen
+ uPadding
+ cbIVlen
);
2098 pbyIVHead
= (u8
*)(pbyMacHdr
+ cbMacHdLen
+ uPadding
);
2100 // Copy the Packet into a tx Buffer
2101 memcpy(pbyMacHdr
, skb
->data
, cbMacHdLen
);
2103 // version set to 0, patch for hostapd deamon
2104 pMACHeader
->frame_control
&= cpu_to_le16(0xfffc);
2105 memcpy(pbyPayloadHead
, (skb
->data
+ cbMacHdLen
), cbFrameBodySize
);
2107 // replace support rate, patch for hostapd daemon( only support 11M)
2108 if (WLAN_GET_FC_FSTYPE(p80211Header
->sA4
.wFrameCtl
) == WLAN_FSTYPE_ASSOCRESP
) {
2109 if (cbExtSuppRate
!= 0) {
2110 if (((PWLAN_IE_SUPP_RATES
)pMgmt
->abyCurrSuppRates
)->len
!= 0)
2111 memcpy((pbyPayloadHead
+ cbFrameBodySize
),
2112 pMgmt
->abyCurrSuppRates
,
2113 ((PWLAN_IE_SUPP_RATES
)pMgmt
->abyCurrSuppRates
)->len
+ WLAN_IEHDR_LEN
2115 if (((PWLAN_IE_SUPP_RATES
)pMgmt
->abyCurrExtSuppRates
)->len
!= 0)
2116 memcpy((pbyPayloadHead
+ cbFrameBodySize
) + ((PWLAN_IE_SUPP_RATES
)pMgmt
->abyCurrSuppRates
)->len
+ WLAN_IEHDR_LEN
,
2117 pMgmt
->abyCurrExtSuppRates
,
2118 ((PWLAN_IE_SUPP_RATES
)pMgmt
->abyCurrExtSuppRates
)->len
+ WLAN_IEHDR_LEN
2124 if (WLAN_GET_FC_ISWEP(p80211Header
->sA4
.wFrameCtl
) != 0) {
2126 if (pDevice
->bEnableHostWEP
) {
2127 pTransmitKey
= &STempKey
;
2128 pTransmitKey
->byCipherSuite
= pMgmt
->sNodeDBTable
[uNodeIndex
].byCipherSuite
;
2129 pTransmitKey
->dwKeyIndex
= pMgmt
->sNodeDBTable
[uNodeIndex
].dwKeyIndex
;
2130 pTransmitKey
->uKeyLength
= pMgmt
->sNodeDBTable
[uNodeIndex
].uWepKeyLength
;
2131 pTransmitKey
->dwTSC47_16
= pMgmt
->sNodeDBTable
[uNodeIndex
].dwTSC47_16
;
2132 pTransmitKey
->wTSC15_0
= pMgmt
->sNodeDBTable
[uNodeIndex
].wTSC15_0
;
2133 memcpy(pTransmitKey
->abyKey
,
2134 &pMgmt
->sNodeDBTable
[uNodeIndex
].abyWepKey
[0],
2135 pTransmitKey
->uKeyLength
2139 if ((pTransmitKey
!= NULL
) && (pTransmitKey
->byCipherSuite
== KEY_CTL_TKIP
)) {
2141 dwMICKey0
= *(u32
*)(&pTransmitKey
->abyKey
[16]);
2142 dwMICKey1
= *(u32
*)(&pTransmitKey
->abyKey
[20]);
2144 // DO Software Michael
2145 MIC_vInit(dwMICKey0
, dwMICKey1
);
2146 MIC_vAppend((u8
*)&(sEthHeader
.h_dest
[0]), 12);
2148 MIC_vAppend((u8
*)&dwMIC_Priority
, 4);
2149 DBG_PRT(MSG_LEVEL_DEBUG
, KERN_INFO
"DMA0_tx_8021:MIC KEY:"\
2150 " %X, %X\n", dwMICKey0
, dwMICKey1
);
2152 uLength
= cbHeaderSize
+ cbMacHdLen
+ uPadding
+ cbIVlen
;
2154 MIC_vAppend((pbyTxBufferAddr
+ uLength
), cbFrameBodySize
);
2156 pdwMIC_L
= (u32
*)(pbyTxBufferAddr
+ uLength
+ cbFrameBodySize
);
2157 pdwMIC_R
= (u32
*)(pbyTxBufferAddr
+ uLength
+ cbFrameBodySize
+ 4);
2159 MIC_vGetMIC(pdwMIC_L
, pdwMIC_R
);
2162 if (pDevice
->bTxMICFail
== true) {
2165 pDevice
->bTxMICFail
= false;
2168 DBG_PRT(MSG_LEVEL_DEBUG
, KERN_INFO
"uLength: %d, %d\n", uLength
, cbFrameBodySize
);
2169 DBG_PRT(MSG_LEVEL_DEBUG
, KERN_INFO
"cbReqCount:%d, %d, %d, %d\n", cbReqCount
, cbHeaderSize
, uPadding
, cbIVlen
);
2170 DBG_PRT(MSG_LEVEL_DEBUG
, KERN_INFO
"MIC:%x, %x\n",
2171 *pdwMIC_L
, *pdwMIC_R
);
2175 s_vFillTxKey(pDevice
, (u8
*)(pTxBufHead
->adwTxKey
), pbyIVHead
, pTransmitKey
,
2176 pbyMacHdr
, (u16
)cbFrameBodySize
, pMICHDR
);
2178 if (pDevice
->bEnableHostWEP
) {
2179 pMgmt
->sNodeDBTable
[uNodeIndex
].dwTSC47_16
= pTransmitKey
->dwTSC47_16
;
2180 pMgmt
->sNodeDBTable
[uNodeIndex
].wTSC15_0
= pTransmitKey
->wTSC15_0
;
2183 if ((pDevice
->byLocalID
<= REV_ID_VT3253_A1
)) {
2184 s_vSWencryption(pDevice
, pTransmitKey
, pbyPayloadHead
, (u16
)(cbFrameBodySize
+ cbMIClen
));
2188 pMACHeader
->seq_ctrl
= cpu_to_le16(pDevice
->wSeqCounter
<< 4);
2189 pDevice
->wSeqCounter
++ ;
2190 if (pDevice
->wSeqCounter
> 0x0fff)
2191 pDevice
->wSeqCounter
= 0;
2194 // The MAC will automatically replace the Duration-field of MAC header by Duration-field
2195 // of FIFO control header.
2196 // This will cause AID-field of PS-POLL packet be incorrect (Because PS-POLL's AID field is
2197 // in the same place of other packet's Duration-field).
2198 // And it will cause Cisco-AP to issue Disassociation-packet
2199 if (byPktType
== PK_TYPE_11GB
|| byPktType
== PK_TYPE_11GA
) {
2200 ((struct vnt_tx_datahead_g
*)pvTxDataHd
)->wDuration_a
=
2201 cpu_to_le16(p80211Header
->sA2
.wDurationID
);
2202 ((struct vnt_tx_datahead_g
*)pvTxDataHd
)->wDuration_b
=
2203 cpu_to_le16(p80211Header
->sA2
.wDurationID
);
2205 ((struct vnt_tx_datahead_ab
*)pvTxDataHd
)->wDuration
=
2206 cpu_to_le16(p80211Header
->sA2
.wDurationID
);
2210 pTX_Buffer
->wTxByteCount
= cpu_to_le16((u16
)(cbReqCount
));
2211 pTX_Buffer
->byPKTNO
= (u8
) (((wCurrentRate
<<4) &0x00F0) | ((pDevice
->wSeqCounter
- 1) & 0x000F));
2212 pTX_Buffer
->byType
= 0x00;
2214 pContext
->pPacket
= skb
;
2215 pContext
->Type
= CONTEXT_MGMT_PACKET
;
2216 pContext
->uBufLen
= (u16
)cbReqCount
+ 4; //USB header
2218 if (WLAN_GET_FC_TODS(pMACHeader
->frame_control
) == 0) {
2219 s_vSaveTxPktInfo(pDevice
, (u8
) (pTX_Buffer
->byPKTNO
& 0x0F), &(pMACHeader
->addr1
[0]), (u16
)cbFrameSize
, pTX_Buffer
->wFIFOCtl
);
2222 s_vSaveTxPktInfo(pDevice
, (u8
) (pTX_Buffer
->byPKTNO
& 0x0F), &(pMACHeader
->addr3
[0]), (u16
)cbFrameSize
, pTX_Buffer
->wFIFOCtl
);
2224 PIPEnsSendBulkOut(pDevice
,pContext
);
2229 //TYPE_AC0DMA data tx
2232 * Tx packet via AC0DMA(DMA1)
2236 * pDevice - Pointer to the adapter
2237 * skb - Pointer to tx skb packet
2241 * Return Value: NULL
2244 int nsDMA_tx_packet(struct vnt_private
*pDevice
,
2245 u32 uDMAIdx
, struct sk_buff
*skb
)
2247 struct net_device_stats
*pStats
= &pDevice
->stats
;
2248 struct vnt_manager
*pMgmt
= &pDevice
->vnt_mgmt
;
2249 struct vnt_tx_buffer
*pTX_Buffer
;
2250 u32 BytesToWrite
= 0, uHeaderLen
= 0;
2252 u8 byMask
[8] = {1, 2, 4, 8, 0x10, 0x20, 0x40, 0x80};
2255 int bNeedEncryption
= false;
2256 PSKeyItem pTransmitKey
= NULL
;
2259 int bTKIP_UseGTK
= false;
2260 int bNeedDeAuth
= false;
2262 int bNodeExist
= false;
2263 PUSB_SEND_CONTEXT pContext
;
2264 bool fConvertedPacket
;
2266 u16 wKeepRate
= pDevice
->wCurrentRate
;
2267 int bTxeapol_key
= false;
2269 if (pMgmt
->eCurrMode
== WMAC_MODE_ESS_AP
) {
2271 if (pDevice
->uAssocCount
== 0) {
2272 dev_kfree_skb_irq(skb
);
2276 if (is_multicast_ether_addr((u8
*)(skb
->data
))) {
2279 if (pMgmt
->sNodeDBTable
[0].bPSEnable
) {
2281 skb_queue_tail(&(pMgmt
->sNodeDBTable
[0].sTxPSQueue
), skb
);
2282 pMgmt
->sNodeDBTable
[0].wEnQueueCnt
++;
2284 pMgmt
->abyPSTxMap
[0] |= byMask
[0];
2287 // multicast/broadcast data rate
2289 if (pDevice
->byBBType
!= BB_TYPE_11A
)
2290 pDevice
->wCurrentRate
= RATE_2M
;
2292 pDevice
->wCurrentRate
= RATE_24M
;
2293 // long preamble type
2294 pDevice
->byPreambleType
= PREAMBLE_SHORT
;
2298 if (BSSbIsSTAInNodeDB(pDevice
, (u8
*)(skb
->data
), &uNodeIndex
)) {
2300 if (pMgmt
->sNodeDBTable
[uNodeIndex
].bPSEnable
) {
2302 skb_queue_tail(&pMgmt
->sNodeDBTable
[uNodeIndex
].sTxPSQueue
, skb
);
2304 pMgmt
->sNodeDBTable
[uNodeIndex
].wEnQueueCnt
++;
2306 wAID
= pMgmt
->sNodeDBTable
[uNodeIndex
].wAID
;
2307 pMgmt
->abyPSTxMap
[wAID
>> 3] |= byMask
[wAID
& 7];
2308 DBG_PRT(MSG_LEVEL_DEBUG
, KERN_INFO
"Set:pMgmt->abyPSTxMap[%d]= %d\n",
2309 (wAID
>> 3), pMgmt
->abyPSTxMap
[wAID
>> 3]);
2313 // AP rate decided from node
2314 pDevice
->wCurrentRate
= pMgmt
->sNodeDBTable
[uNodeIndex
].wTxDataRate
;
2315 // tx preamble decided from node
2317 if (pMgmt
->sNodeDBTable
[uNodeIndex
].bShortPreamble
) {
2318 pDevice
->byPreambleType
= pDevice
->byShortPreamble
;
2321 pDevice
->byPreambleType
= PREAMBLE_LONG
;
2327 if (bNodeExist
== false) {
2328 DBG_PRT(MSG_LEVEL_DEBUG
, KERN_DEBUG
"Unknown STA not found in node DB \n");
2329 dev_kfree_skb_irq(skb
);
2334 pContext
= (PUSB_SEND_CONTEXT
)s_vGetFreeContext(pDevice
);
2336 if (pContext
== NULL
) {
2337 DBG_PRT(MSG_LEVEL_DEBUG
, KERN_DEBUG
" pContext == NULL\n");
2338 dev_kfree_skb_irq(skb
);
2339 return STATUS_RESOURCES
;
2342 memcpy(pDevice
->sTxEthHeader
.h_dest
, (u8
*)(skb
->data
), ETH_HLEN
);
2344 //mike add:station mode check eapol-key challenge--->
2346 u8 Protocol_Version
; //802.1x Authentication
2347 u8 Packet_Type
; //802.1x Authentication
2351 Protocol_Version
= skb
->data
[ETH_HLEN
];
2352 Packet_Type
= skb
->data
[ETH_HLEN
+1];
2353 Descriptor_type
= skb
->data
[ETH_HLEN
+1+1+2];
2354 Key_info
= (skb
->data
[ETH_HLEN
+1+1+2+1] << 8)|(skb
->data
[ETH_HLEN
+1+1+2+2]);
2355 if (pDevice
->sTxEthHeader
.h_proto
== cpu_to_be16(ETH_P_PAE
)) {
2356 /* 802.1x OR eapol-key challenge frame transfer */
2357 if (((Protocol_Version
== 1) || (Protocol_Version
== 2)) &&
2358 (Packet_Type
== 3)) {
2359 bTxeapol_key
= true;
2360 if(!(Key_info
& BIT3
) && //WPA or RSN group-key challenge
2361 (Key_info
& BIT8
) && (Key_info
& BIT9
)) { //send 2/2 key
2362 if(Descriptor_type
==254) {
2363 pDevice
->fWPA_Authened
= true;
2367 pDevice
->fWPA_Authened
= true;
2368 PRINT_K("WPA2(re-keying) ");
2370 PRINT_K("Authentication completed!!\n");
2372 else if((Key_info
& BIT3
) && (Descriptor_type
==2) && //RSN pairwise-key challenge
2373 (Key_info
& BIT8
) && (Key_info
& BIT9
)) {
2374 pDevice
->fWPA_Authened
= true;
2375 PRINT_K("WPA2 Authentication completed!!\n");
2380 //mike add:station mode check eapol-key challenge<---
2382 if (pDevice
->bEncryptionEnable
== true) {
2383 bNeedEncryption
= true;
2386 if ((pMgmt
->eCurrMode
== WMAC_MODE_ESS_STA
) &&
2387 (pMgmt
->eCurrState
== WMAC_STATE_ASSOC
)) {
2388 pbyBSSID
= pDevice
->abyBSSID
;
2390 if (KeybGetTransmitKey(&(pDevice
->sKey
), pbyBSSID
, PAIRWISE_KEY
, &pTransmitKey
) == false) {
2392 if(KeybGetTransmitKey(&(pDevice
->sKey
), pbyBSSID
, GROUP_KEY
, &pTransmitKey
) == true) {
2393 bTKIP_UseGTK
= true;
2394 DBG_PRT(MSG_LEVEL_DEBUG
, KERN_DEBUG
"Get GTK.\n");
2398 DBG_PRT(MSG_LEVEL_DEBUG
, KERN_DEBUG
"Get PTK.\n");
2401 }else if (pMgmt
->eCurrMode
== WMAC_MODE_IBSS_STA
) {
2402 /* TO_DS = 0 and FROM_DS = 0 --> 802.11 MAC Address1 */
2403 pbyBSSID
= pDevice
->sTxEthHeader
.h_dest
;
2404 DBG_PRT(MSG_LEVEL_DEBUG
, KERN_DEBUG
"IBSS Serach Key: \n");
2405 for (ii
= 0; ii
< 6; ii
++)
2406 DBG_PRT(MSG_LEVEL_DEBUG
, KERN_DEBUG
"%x \n", *(pbyBSSID
+ii
));
2407 DBG_PRT(MSG_LEVEL_DEBUG
, KERN_DEBUG
"\n");
2410 if(KeybGetTransmitKey(&(pDevice
->sKey
), pbyBSSID
, PAIRWISE_KEY
, &pTransmitKey
) == true)
2414 pbyBSSID
= pDevice
->abyBroadcastAddr
;
2415 if(KeybGetTransmitKey(&(pDevice
->sKey
), pbyBSSID
, GROUP_KEY
, &pTransmitKey
) == false) {
2416 pTransmitKey
= NULL
;
2417 if (pMgmt
->eCurrMode
== WMAC_MODE_IBSS_STA
) {
2418 DBG_PRT(MSG_LEVEL_DEBUG
, KERN_DEBUG
"IBSS and KEY is NULL. [%d]\n", pMgmt
->eCurrMode
);
2421 DBG_PRT(MSG_LEVEL_DEBUG
, KERN_DEBUG
"NOT IBSS and KEY is NULL. [%d]\n", pMgmt
->eCurrMode
);
2423 bTKIP_UseGTK
= true;
2424 DBG_PRT(MSG_LEVEL_DEBUG
, KERN_DEBUG
"Get GTK.\n");
2429 if (pDevice
->bEnableHostWEP
) {
2430 DBG_PRT(MSG_LEVEL_DEBUG
, KERN_DEBUG
"acdma0: STA index %d\n", uNodeIndex
);
2431 if (pDevice
->bEncryptionEnable
== true) {
2432 pTransmitKey
= &STempKey
;
2433 pTransmitKey
->byCipherSuite
= pMgmt
->sNodeDBTable
[uNodeIndex
].byCipherSuite
;
2434 pTransmitKey
->dwKeyIndex
= pMgmt
->sNodeDBTable
[uNodeIndex
].dwKeyIndex
;
2435 pTransmitKey
->uKeyLength
= pMgmt
->sNodeDBTable
[uNodeIndex
].uWepKeyLength
;
2436 pTransmitKey
->dwTSC47_16
= pMgmt
->sNodeDBTable
[uNodeIndex
].dwTSC47_16
;
2437 pTransmitKey
->wTSC15_0
= pMgmt
->sNodeDBTable
[uNodeIndex
].wTSC15_0
;
2438 memcpy(pTransmitKey
->abyKey
,
2439 &pMgmt
->sNodeDBTable
[uNodeIndex
].abyWepKey
[0],
2440 pTransmitKey
->uKeyLength
2445 byPktType
= (u8
)pDevice
->byPacketType
;
2447 if (pDevice
->bFixRate
) {
2448 if (pDevice
->byBBType
== BB_TYPE_11B
) {
2449 if (pDevice
->uConnectionRate
>= RATE_11M
) {
2450 pDevice
->wCurrentRate
= RATE_11M
;
2452 pDevice
->wCurrentRate
= (u16
)pDevice
->uConnectionRate
;
2455 if ((pDevice
->byBBType
== BB_TYPE_11A
) &&
2456 (pDevice
->uConnectionRate
<= RATE_6M
)) {
2457 pDevice
->wCurrentRate
= RATE_6M
;
2459 if (pDevice
->uConnectionRate
>= RATE_54M
)
2460 pDevice
->wCurrentRate
= RATE_54M
;
2462 pDevice
->wCurrentRate
= (u16
)pDevice
->uConnectionRate
;
2467 if (pDevice
->eOPMode
== OP_MODE_ADHOC
) {
2468 // Adhoc Tx rate decided from node DB
2469 if (is_multicast_ether_addr(pDevice
->sTxEthHeader
.h_dest
)) {
2470 // Multicast use highest data rate
2471 pDevice
->wCurrentRate
= pMgmt
->sNodeDBTable
[0].wTxDataRate
;
2473 pDevice
->byPreambleType
= pDevice
->byShortPreamble
;
2476 if (BSSbIsSTAInNodeDB(pDevice
, &(pDevice
->sTxEthHeader
.h_dest
[0]), &uNodeIndex
)) {
2477 pDevice
->wCurrentRate
= pMgmt
->sNodeDBTable
[uNodeIndex
].wTxDataRate
;
2478 if (pMgmt
->sNodeDBTable
[uNodeIndex
].bShortPreamble
) {
2479 pDevice
->byPreambleType
= pDevice
->byShortPreamble
;
2483 pDevice
->byPreambleType
= PREAMBLE_LONG
;
2485 DBG_PRT(MSG_LEVEL_DEBUG
, KERN_INFO
"Found Node Index is [%d] Tx Data Rate:[%d]\n",uNodeIndex
, pDevice
->wCurrentRate
);
2488 if (pDevice
->byBBType
!= BB_TYPE_11A
)
2489 pDevice
->wCurrentRate
= RATE_2M
;
2491 pDevice
->wCurrentRate
= RATE_24M
; // refer to vMgrCreateOwnIBSS()'s
2492 // abyCurrExtSuppRates[]
2493 pDevice
->byPreambleType
= PREAMBLE_SHORT
;
2494 DBG_PRT(MSG_LEVEL_DEBUG
, KERN_INFO
"Not Found Node use highest basic Rate.....\n");
2498 if (pDevice
->eOPMode
== OP_MODE_INFRASTRUCTURE
) {
2499 // Infra STA rate decided from AP Node, index = 0
2500 pDevice
->wCurrentRate
= pMgmt
->sNodeDBTable
[0].wTxDataRate
;
2504 if (pDevice
->sTxEthHeader
.h_proto
== cpu_to_be16(ETH_P_PAE
)) {
2505 if (pDevice
->byBBType
!= BB_TYPE_11A
) {
2506 pDevice
->wCurrentRate
= RATE_1M
;
2507 pDevice
->byACKRate
= RATE_1M
;
2508 pDevice
->byTopCCKBasicRate
= RATE_1M
;
2509 pDevice
->byTopOFDMBasicRate
= RATE_6M
;
2511 pDevice
->wCurrentRate
= RATE_6M
;
2512 pDevice
->byACKRate
= RATE_6M
;
2513 pDevice
->byTopCCKBasicRate
= RATE_1M
;
2514 pDevice
->byTopOFDMBasicRate
= RATE_6M
;
2518 DBG_PRT(MSG_LEVEL_DEBUG
,
2519 KERN_INFO
"dma_tx: pDevice->wCurrentRate = %d\n",
2520 pDevice
->wCurrentRate
);
2522 if (wKeepRate
!= pDevice
->wCurrentRate
) {
2523 bScheduleCommand((void *) pDevice
, WLAN_CMD_SETPOWER
, NULL
);
2526 if (pDevice
->wCurrentRate
<= RATE_11M
) {
2527 byPktType
= PK_TYPE_11B
;
2530 if (bNeedEncryption
== true) {
2531 DBG_PRT(MSG_LEVEL_DEBUG
, KERN_INFO
"ntohs Pkt Type=%04x\n", ntohs(pDevice
->sTxEthHeader
.h_proto
));
2532 if ((pDevice
->sTxEthHeader
.h_proto
) == cpu_to_be16(ETH_P_PAE
)) {
2533 bNeedEncryption
= false;
2534 DBG_PRT(MSG_LEVEL_DEBUG
, KERN_INFO
"Pkt Type=%04x\n", (pDevice
->sTxEthHeader
.h_proto
));
2535 if ((pMgmt
->eCurrMode
== WMAC_MODE_ESS_STA
) && (pMgmt
->eCurrState
== WMAC_STATE_ASSOC
)) {
2536 if (pTransmitKey
== NULL
) {
2537 DBG_PRT(MSG_LEVEL_DEBUG
, KERN_INFO
"Don't Find TX KEY\n");
2540 if (bTKIP_UseGTK
== true) {
2541 DBG_PRT(MSG_LEVEL_DEBUG
, KERN_INFO
"error: KEY is GTK!!~~\n");
2544 DBG_PRT(MSG_LEVEL_DEBUG
, KERN_INFO
"Find PTK [%X]\n",
2545 pTransmitKey
->dwKeyIndex
);
2546 bNeedEncryption
= true;
2551 if (pDevice
->bEnableHostWEP
) {
2552 if ((uNodeIndex
!= 0) &&
2553 (pMgmt
->sNodeDBTable
[uNodeIndex
].dwKeyIndex
& PAIRWISE_KEY
)) {
2554 DBG_PRT(MSG_LEVEL_DEBUG
, KERN_INFO
"Find PTK [%X]\n",
2555 pTransmitKey
->dwKeyIndex
);
2556 bNeedEncryption
= true;
2562 if (pTransmitKey
== NULL
) {
2563 DBG_PRT(MSG_LEVEL_DEBUG
, KERN_INFO
"return no tx key\n");
2564 pContext
->bBoolInUse
= false;
2565 dev_kfree_skb_irq(skb
);
2566 pStats
->tx_dropped
++;
2567 return STATUS_FAILURE
;
2572 pTX_Buffer
= (struct vnt_tx_buffer
*)&pContext
->Data
[0];
2574 fConvertedPacket
= s_bPacketToWirelessUsb(pDevice
, byPktType
,
2575 pTX_Buffer
, bNeedEncryption
,
2576 skb
->len
, uDMAIdx
, &pDevice
->sTxEthHeader
,
2577 (u8
*)skb
->data
, pTransmitKey
, uNodeIndex
,
2578 pDevice
->wCurrentRate
,
2579 &uHeaderLen
, &BytesToWrite
2582 if (fConvertedPacket
== false) {
2583 pContext
->bBoolInUse
= false;
2584 dev_kfree_skb_irq(skb
);
2585 return STATUS_FAILURE
;
2588 if ( pDevice
->bEnablePSMode
== true ) {
2589 if ( !pDevice
->bPSModeTxBurst
) {
2590 bScheduleCommand((void *) pDevice
,
2591 WLAN_CMD_MAC_DISPOWERSAVING
,
2593 pDevice
->bPSModeTxBurst
= true;
2597 pTX_Buffer
->byPKTNO
= (u8
) (((pDevice
->wCurrentRate
<<4) &0x00F0) | ((pDevice
->wSeqCounter
- 1) & 0x000F));
2598 pTX_Buffer
->wTxByteCount
= (u16
)BytesToWrite
;
2600 pContext
->pPacket
= skb
;
2601 pContext
->Type
= CONTEXT_DATA_PACKET
;
2602 pContext
->uBufLen
= (u16
)BytesToWrite
+ 4 ; //USB header
2604 s_vSaveTxPktInfo(pDevice
, (u8
) (pTX_Buffer
->byPKTNO
& 0x0F), &(pContext
->sEthHeader
.h_dest
[0]), (u16
) (BytesToWrite
-uHeaderLen
), pTX_Buffer
->wFIFOCtl
);
2606 status
= PIPEnsSendBulkOut(pDevice
,pContext
);
2608 if (bNeedDeAuth
== true) {
2609 u16 wReason
= WLAN_MGMT_REASON_MIC_FAILURE
;
2611 bScheduleCommand((void *) pDevice
, WLAN_CMD_DEAUTH
, (u8
*) &wReason
);
2614 if(status
!=STATUS_PENDING
) {
2615 pContext
->bBoolInUse
= false;
2616 dev_kfree_skb_irq(skb
);
2617 return STATUS_FAILURE
;
2626 * Relay packet send (AC1DMA) from rx dpc.
2630 * pDevice - Pointer to the adapter
2631 * pPacket - Pointer to rx packet
2632 * cbPacketSize - rx ethernet frame size
2636 * Return Value: Return true if packet is copy to dma1; otherwise false
2639 int bRelayPacketSend(struct vnt_private
*pDevice
, u8
*pbySkbData
, u32 uDataLen
,
2642 struct vnt_manager
*pMgmt
= &pDevice
->vnt_mgmt
;
2643 struct vnt_tx_buffer
*pTX_Buffer
;
2644 u32 BytesToWrite
= 0, uHeaderLen
= 0;
2645 u8 byPktType
= PK_TYPE_11B
;
2646 int bNeedEncryption
= false;
2648 PSKeyItem pTransmitKey
= NULL
;
2650 PUSB_SEND_CONTEXT pContext
;
2652 int fConvertedPacket
;
2654 u16 wKeepRate
= pDevice
->wCurrentRate
;
2656 pContext
= (PUSB_SEND_CONTEXT
)s_vGetFreeContext(pDevice
);
2658 if (NULL
== pContext
) {
2662 memcpy(pDevice
->sTxEthHeader
.h_dest
, (u8
*)pbySkbData
, ETH_HLEN
);
2664 if (pDevice
->bEncryptionEnable
== true) {
2665 bNeedEncryption
= true;
2667 pbyBSSID
= pDevice
->abyBroadcastAddr
;
2668 if(KeybGetTransmitKey(&(pDevice
->sKey
), pbyBSSID
, GROUP_KEY
, &pTransmitKey
) == false) {
2669 pTransmitKey
= NULL
;
2670 DBG_PRT(MSG_LEVEL_DEBUG
, KERN_DEBUG
"KEY is NULL. [%d]\n", pMgmt
->eCurrMode
);
2672 DBG_PRT(MSG_LEVEL_DEBUG
, KERN_DEBUG
"Get GTK.\n");
2676 if (pDevice
->bEnableHostWEP
) {
2677 if (uNodeIndex
< MAX_NODE_NUM
+ 1) {
2678 pTransmitKey
= &STempKey
;
2679 pTransmitKey
->byCipherSuite
= pMgmt
->sNodeDBTable
[uNodeIndex
].byCipherSuite
;
2680 pTransmitKey
->dwKeyIndex
= pMgmt
->sNodeDBTable
[uNodeIndex
].dwKeyIndex
;
2681 pTransmitKey
->uKeyLength
= pMgmt
->sNodeDBTable
[uNodeIndex
].uWepKeyLength
;
2682 pTransmitKey
->dwTSC47_16
= pMgmt
->sNodeDBTable
[uNodeIndex
].dwTSC47_16
;
2683 pTransmitKey
->wTSC15_0
= pMgmt
->sNodeDBTable
[uNodeIndex
].wTSC15_0
;
2684 memcpy(pTransmitKey
->abyKey
,
2685 &pMgmt
->sNodeDBTable
[uNodeIndex
].abyWepKey
[0],
2686 pTransmitKey
->uKeyLength
2691 if ( bNeedEncryption
&& (pTransmitKey
== NULL
) ) {
2692 pContext
->bBoolInUse
= false;
2696 byPktTyp
= (u8
)pDevice
->byPacketType
;
2698 if (pDevice
->bFixRate
) {
2699 if (pDevice
->byBBType
== BB_TYPE_11B
) {
2700 if (pDevice
->uConnectionRate
>= RATE_11M
) {
2701 pDevice
->wCurrentRate
= RATE_11M
;
2703 pDevice
->wCurrentRate
= (u16
)pDevice
->uConnectionRate
;
2706 if ((pDevice
->byBBType
== BB_TYPE_11A
) &&
2707 (pDevice
->uConnectionRate
<= RATE_6M
)) {
2708 pDevice
->wCurrentRate
= RATE_6M
;
2710 if (pDevice
->uConnectionRate
>= RATE_54M
)
2711 pDevice
->wCurrentRate
= RATE_54M
;
2713 pDevice
->wCurrentRate
= (u16
)pDevice
->uConnectionRate
;
2718 pDevice
->wCurrentRate
= pMgmt
->sNodeDBTable
[uNodeIndex
].wTxDataRate
;
2721 if (wKeepRate
!= pDevice
->wCurrentRate
) {
2722 bScheduleCommand((void *) pDevice
, WLAN_CMD_SETPOWER
, NULL
);
2725 if (pDevice
->wCurrentRate
<= RATE_11M
)
2726 byPktType
= PK_TYPE_11B
;
2728 BytesToWrite
= uDataLen
+ ETH_FCS_LEN
;
2730 // Convert the packet to an usb frame and copy into our buffer
2731 // and send the irp.
2733 pTX_Buffer
= (struct vnt_tx_buffer
*)&pContext
->Data
[0];
2735 fConvertedPacket
= s_bPacketToWirelessUsb(pDevice
, byPktType
,
2736 pTX_Buffer
, bNeedEncryption
,
2737 uDataLen
, TYPE_AC0DMA
, &pDevice
->sTxEthHeader
,
2738 pbySkbData
, pTransmitKey
, uNodeIndex
,
2739 pDevice
->wCurrentRate
,
2740 &uHeaderLen
, &BytesToWrite
2743 if (fConvertedPacket
== false) {
2744 pContext
->bBoolInUse
= false;
2748 pTX_Buffer
->byPKTNO
= (u8
) (((pDevice
->wCurrentRate
<<4) &0x00F0) | ((pDevice
->wSeqCounter
- 1) & 0x000F));
2749 pTX_Buffer
->wTxByteCount
= (u16
)BytesToWrite
;
2751 pContext
->pPacket
= NULL
;
2752 pContext
->Type
= CONTEXT_DATA_PACKET
;
2753 pContext
->uBufLen
= (u16
)BytesToWrite
+ 4 ; //USB header
2755 s_vSaveTxPktInfo(pDevice
, (u8
) (pTX_Buffer
->byPKTNO
& 0x0F), &(pContext
->sEthHeader
.h_dest
[0]), (u16
) (BytesToWrite
-uHeaderLen
), pTX_Buffer
->wFIFOCtl
);
2757 status
= PIPEnsSendBulkOut(pDevice
,pContext
);