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
, struct vnt_tx_buffer
*tx_buffer
,
103 struct vnt_mic_hdr
**mic_hdr
, u32 need_mic
,
104 void *rts_cts
, u32 cbFrameSize
, int bNeedACK
, u32 uDMAIdx
,
105 struct ethhdr
*psEthHeader
, bool need_rts
);
107 static u32
s_uFillDataHead(struct vnt_private
*pDevice
,
108 u8 byPktType
, u16 wCurrentRate
, void *pTxDataHead
, u32 cbFrameLength
,
109 u32 uDMAIdx
, int bNeedAck
, u8 byFBOption
);
111 static void s_vGenerateMACHeader(struct vnt_private
*pDevice
,
112 u8
*pbyBufferAddr
, u16 wDuration
, struct ethhdr
*psEthHeader
,
113 int bNeedEncrypt
, u16 wFragType
, u32 uDMAIdx
, u32 uFragIdx
);
115 static void s_vFillTxKey(struct vnt_private
*pDevice
, u8
*pbyBuf
,
116 u8
*pbyIVHead
, PSKeyItem pTransmitKey
, u8
*pbyHdrBuf
, u16 wPayloadLen
,
117 struct vnt_mic_hdr
*mic_hdr
);
119 static void s_vSWencryption(struct vnt_private
*pDevice
,
120 PSKeyItem pTransmitKey
, u8
*pbyPayloadHead
, u16 wPayloadSize
);
122 static unsigned int s_uGetTxRsvTime(struct vnt_private
*pDevice
, u8 byPktType
,
123 u32 cbFrameLength
, u16 wRate
, int bNeedAck
);
125 static u16
s_uGetRTSCTSRsvTime(struct vnt_private
*pDevice
, u8 byRTSRsvType
,
126 u8 byPktType
, u32 cbFrameLength
, u16 wCurrentRate
);
128 static void s_vFillCTSHead(struct vnt_private
*pDevice
, u32 uDMAIdx
,
129 u8 byPktType
, union vnt_tx_data_head
*head
, u32 cbFrameLength
,
130 int bNeedAck
, u16 wCurrentRate
, u8 byFBOption
);
132 static void s_vFillRTSHead(struct vnt_private
*pDevice
, u8 byPktType
,
133 union vnt_tx_data_head
*head
, u32 cbFrameLength
, int bNeedAck
,
134 struct ethhdr
*psEthHeader
, u16 wCurrentRate
, u8 byFBOption
);
136 static u16
s_uGetDataDuration(struct vnt_private
*pDevice
,
137 u8 byPktType
, int bNeedAck
);
139 static u16
s_uGetRTSCTSDuration(struct vnt_private
*pDevice
,
140 u8 byDurType
, u32 cbFrameLength
, u8 byPktType
, u16 wRate
,
141 int bNeedAck
, u8 byFBOption
);
143 static void *s_vGetFreeContext(struct vnt_private
*pDevice
)
145 struct vnt_usb_send_context
*pContext
= NULL
;
146 struct vnt_usb_send_context
*pReturnContext
= NULL
;
149 DBG_PRT(MSG_LEVEL_DEBUG
, KERN_INFO
"GetFreeContext()\n");
151 for (ii
= 0; ii
< pDevice
->cbTD
; ii
++) {
152 pContext
= pDevice
->apTD
[ii
];
153 if (pContext
->bBoolInUse
== false) {
154 pContext
->bBoolInUse
= true;
155 memset(pContext
->Data
, 0, MAX_TOTAL_SIZE_WITH_ALL_HEADERS
);
156 pReturnContext
= pContext
;
160 if ( ii
== pDevice
->cbTD
) {
161 DBG_PRT(MSG_LEVEL_DEBUG
, KERN_INFO
"No Free Tx Context\n");
163 return (void *) pReturnContext
;
166 static void s_vSaveTxPktInfo(struct vnt_private
*pDevice
, u8 byPktNum
,
167 u8
*pbyDestAddr
, u16 wPktLength
, u16 wFIFOCtl
)
169 PSStatCounter pStatistic
= &pDevice
->scStatistic
;
171 if (is_broadcast_ether_addr(pbyDestAddr
))
172 pStatistic
->abyTxPktInfo
[byPktNum
].byBroadMultiUni
= TX_PKT_BROAD
;
173 else if (is_multicast_ether_addr(pbyDestAddr
))
174 pStatistic
->abyTxPktInfo
[byPktNum
].byBroadMultiUni
= TX_PKT_MULTI
;
176 pStatistic
->abyTxPktInfo
[byPktNum
].byBroadMultiUni
= TX_PKT_UNI
;
178 pStatistic
->abyTxPktInfo
[byPktNum
].wLength
= wPktLength
;
179 pStatistic
->abyTxPktInfo
[byPktNum
].wFIFOCtl
= wFIFOCtl
;
180 memcpy(pStatistic
->abyTxPktInfo
[byPktNum
].abyDestAddr
,
185 static void s_vFillTxKey(struct vnt_private
*pDevice
, u8
*pbyBuf
,
186 u8
*pbyIVHead
, PSKeyItem pTransmitKey
, u8
*pbyHdrBuf
,
187 u16 wPayloadLen
, struct vnt_mic_hdr
*mic_hdr
)
189 u32
*pdwIV
= (u32
*)pbyIVHead
;
190 u32
*pdwExtIV
= (u32
*)((u8
*)pbyIVHead
+ 4);
191 struct ieee80211_hdr
*pMACHeader
= (struct ieee80211_hdr
*)pbyHdrBuf
;
195 if (pTransmitKey
== NULL
)
198 dwRevIVCounter
= cpu_to_le32(pDevice
->dwIVCounter
);
199 *pdwIV
= pDevice
->dwIVCounter
;
200 pDevice
->byKeyIndex
= pTransmitKey
->dwKeyIndex
& 0xf;
202 switch (pTransmitKey
->byCipherSuite
) {
204 if (pTransmitKey
->uKeyLength
== WLAN_WEP232_KEYLEN
) {
205 memcpy(pDevice
->abyPRNG
, (u8
*)&dwRevIVCounter
, 3);
206 memcpy(pDevice
->abyPRNG
+ 3, pTransmitKey
->abyKey
,
207 pTransmitKey
->uKeyLength
);
209 memcpy(pbyBuf
, (u8
*)&dwRevIVCounter
, 3);
210 memcpy(pbyBuf
+ 3, pTransmitKey
->abyKey
,
211 pTransmitKey
->uKeyLength
);
212 if (pTransmitKey
->uKeyLength
== WLAN_WEP40_KEYLEN
) {
213 memcpy(pbyBuf
+8, (u8
*)&dwRevIVCounter
, 3);
214 memcpy(pbyBuf
+11, pTransmitKey
->abyKey
,
215 pTransmitKey
->uKeyLength
);
218 memcpy(pDevice
->abyPRNG
, pbyBuf
, 16);
220 /* Append IV after Mac Header */
221 *pdwIV
&= WEP_IV_MASK
;
222 *pdwIV
|= (u32
)pDevice
->byKeyIndex
<< 30;
223 *pdwIV
= cpu_to_le32(*pdwIV
);
225 pDevice
->dwIVCounter
++;
226 if (pDevice
->dwIVCounter
> WEP_IV_MASK
)
227 pDevice
->dwIVCounter
= 0;
231 pTransmitKey
->wTSC15_0
++;
232 if (pTransmitKey
->wTSC15_0
== 0)
233 pTransmitKey
->dwTSC47_16
++;
235 TKIPvMixKey(pTransmitKey
->abyKey
, pDevice
->abyCurrentNetAddr
,
236 pTransmitKey
->wTSC15_0
, pTransmitKey
->dwTSC47_16
,
238 memcpy(pbyBuf
, pDevice
->abyPRNG
, 16);
241 memcpy(pdwIV
, pDevice
->abyPRNG
, 3);
243 *(pbyIVHead
+3) = (u8
)(((pDevice
->byKeyIndex
<< 6) &
245 /* Append IV&ExtIV after Mac Header */
246 *pdwExtIV
= cpu_to_le32(pTransmitKey
->dwTSC47_16
);
248 DBG_PRT(MSG_LEVEL_DEBUG
, KERN_INFO
249 "vFillTxKey()---- pdwExtIV: %x\n", *pdwExtIV
);
253 pTransmitKey
->wTSC15_0
++;
254 if (pTransmitKey
->wTSC15_0
== 0)
255 pTransmitKey
->dwTSC47_16
++;
257 memcpy(pbyBuf
, pTransmitKey
->abyKey
, 16);
261 *(pbyIVHead
+3) = (u8
)(((pDevice
->byKeyIndex
<< 6) &
264 *pdwIV
|= cpu_to_le16((u16
)(pTransmitKey
->wTSC15_0
));
266 /* Append IV&ExtIV after Mac Header */
267 *pdwExtIV
= cpu_to_le32(pTransmitKey
->dwTSC47_16
);
274 mic_hdr
->payload_len
= cpu_to_be16(wPayloadLen
);
275 memcpy(mic_hdr
->mic_addr2
, pMACHeader
->addr2
, ETH_ALEN
);
277 mic_hdr
->tsc_47_16
= cpu_to_be32(pTransmitKey
->dwTSC47_16
);
278 mic_hdr
->tsc_15_0
= cpu_to_be16(pTransmitKey
->wTSC15_0
);
281 if (pDevice
->bLongHeader
)
282 mic_hdr
->hlen
= cpu_to_be16(28);
284 mic_hdr
->hlen
= cpu_to_be16(22);
286 memcpy(mic_hdr
->addr1
, pMACHeader
->addr1
, ETH_ALEN
);
287 memcpy(mic_hdr
->addr2
, pMACHeader
->addr2
, ETH_ALEN
);
290 memcpy(mic_hdr
->addr3
, pMACHeader
->addr3
, ETH_ALEN
);
291 mic_hdr
->frame_control
= cpu_to_le16(pMACHeader
->frame_control
293 mic_hdr
->seq_ctrl
= cpu_to_le16(pMACHeader
->seq_ctrl
& 0xf);
295 if (pDevice
->bLongHeader
)
296 memcpy(mic_hdr
->addr4
, pMACHeader
->addr4
, ETH_ALEN
);
300 static void s_vSWencryption(struct vnt_private
*pDevice
,
301 PSKeyItem pTransmitKey
, u8
*pbyPayloadHead
, u16 wPayloadSize
)
304 u32 dwICV
= 0xffffffff;
307 if (pTransmitKey
== NULL
)
310 if (pTransmitKey
->byCipherSuite
== KEY_CTL_WEP
) {
311 //=======================================================================
312 // Append ICV after payload
313 dwICV
= CRCdwGetCrc32Ex(pbyPayloadHead
, wPayloadSize
, dwICV
);//ICV(Payload)
314 pdwICV
= (u32
*)(pbyPayloadHead
+ wPayloadSize
);
315 // finally, we must invert dwCRC to get the correct answer
316 *pdwICV
= cpu_to_le32(~dwICV
);
318 rc4_init(&pDevice
->SBox
, pDevice
->abyPRNG
, pTransmitKey
->uKeyLength
+ 3);
319 rc4_encrypt(&pDevice
->SBox
, pbyPayloadHead
, pbyPayloadHead
, wPayloadSize
+cbICVlen
);
320 //=======================================================================
321 } else if (pTransmitKey
->byCipherSuite
== KEY_CTL_TKIP
) {
322 //=======================================================================
323 //Append ICV after payload
324 dwICV
= CRCdwGetCrc32Ex(pbyPayloadHead
, wPayloadSize
, dwICV
);//ICV(Payload)
325 pdwICV
= (u32
*)(pbyPayloadHead
+ wPayloadSize
);
326 // finally, we must invert dwCRC to get the correct answer
327 *pdwICV
= cpu_to_le32(~dwICV
);
329 rc4_init(&pDevice
->SBox
, pDevice
->abyPRNG
, TKIP_KEY_LEN
);
330 rc4_encrypt(&pDevice
->SBox
, pbyPayloadHead
, pbyPayloadHead
, wPayloadSize
+cbICVlen
);
331 //=======================================================================
335 static u16
vnt_time_stamp_off(struct vnt_private
*priv
, u16 rate
)
337 return cpu_to_le16(wTimeStampOff
[priv
->byPreambleType
% 2]
341 /*byPktType : PK_TYPE_11A 0
346 static u32
s_uGetTxRsvTime(struct vnt_private
*pDevice
, u8 byPktType
,
347 u32 cbFrameLength
, u16 wRate
, int bNeedAck
)
349 u32 uDataTime
, uAckTime
;
351 uDataTime
= BBuGetFrameTime(pDevice
->byPreambleType
, byPktType
, cbFrameLength
, wRate
);
352 if (byPktType
== PK_TYPE_11B
) {//llb,CCK mode
353 uAckTime
= BBuGetFrameTime(pDevice
->byPreambleType
, byPktType
, 14, (u16
)pDevice
->byTopCCKBasicRate
);
354 } else {//11g 2.4G OFDM mode & 11a 5G OFDM mode
355 uAckTime
= BBuGetFrameTime(pDevice
->byPreambleType
, byPktType
, 14, (u16
)pDevice
->byTopOFDMBasicRate
);
359 return (uDataTime
+ pDevice
->uSIFS
+ uAckTime
);
366 static u16
vnt_rxtx_rsvtime_le16(struct vnt_private
*priv
, u8 pkt_type
,
367 u32 frame_length
, u16 rate
, int need_ack
)
369 return cpu_to_le16((u16
)s_uGetTxRsvTime(priv
, pkt_type
,
370 frame_length
, rate
, need_ack
));
373 //byFreqType: 0=>5GHZ 1=>2.4GHZ
374 static u16
s_uGetRTSCTSRsvTime(struct vnt_private
*pDevice
,
375 u8 byRTSRsvType
, u8 byPktType
, u32 cbFrameLength
, u16 wCurrentRate
)
377 u32 uRrvTime
, uRTSTime
, uCTSTime
, uAckTime
, uDataTime
;
379 uRrvTime
= uRTSTime
= uCTSTime
= uAckTime
= uDataTime
= 0;
381 uDataTime
= BBuGetFrameTime(pDevice
->byPreambleType
, byPktType
, cbFrameLength
, wCurrentRate
);
382 if (byRTSRsvType
== 0) { //RTSTxRrvTime_bb
383 uRTSTime
= BBuGetFrameTime(pDevice
->byPreambleType
, byPktType
, 20, pDevice
->byTopCCKBasicRate
);
384 uCTSTime
= uAckTime
= BBuGetFrameTime(pDevice
->byPreambleType
, byPktType
, 14, pDevice
->byTopCCKBasicRate
);
386 else if (byRTSRsvType
== 1){ //RTSTxRrvTime_ba, only in 2.4GHZ
387 uRTSTime
= BBuGetFrameTime(pDevice
->byPreambleType
, byPktType
, 20, pDevice
->byTopCCKBasicRate
);
388 uCTSTime
= BBuGetFrameTime(pDevice
->byPreambleType
, byPktType
, 14, pDevice
->byTopCCKBasicRate
);
389 uAckTime
= BBuGetFrameTime(pDevice
->byPreambleType
, byPktType
, 14, pDevice
->byTopOFDMBasicRate
);
391 else if (byRTSRsvType
== 2) { //RTSTxRrvTime_aa
392 uRTSTime
= BBuGetFrameTime(pDevice
->byPreambleType
, byPktType
, 20, pDevice
->byTopOFDMBasicRate
);
393 uCTSTime
= uAckTime
= BBuGetFrameTime(pDevice
->byPreambleType
, byPktType
, 14, pDevice
->byTopOFDMBasicRate
);
395 else if (byRTSRsvType
== 3) { //CTSTxRrvTime_ba, only in 2.4GHZ
396 uCTSTime
= BBuGetFrameTime(pDevice
->byPreambleType
, byPktType
, 14, pDevice
->byTopCCKBasicRate
);
397 uAckTime
= BBuGetFrameTime(pDevice
->byPreambleType
, byPktType
, 14, pDevice
->byTopOFDMBasicRate
);
398 uRrvTime
= uCTSTime
+ uAckTime
+ uDataTime
+ 2*pDevice
->uSIFS
;
403 uRrvTime
= uRTSTime
+ uCTSTime
+ uAckTime
+ uDataTime
+ 3*pDevice
->uSIFS
;
404 return cpu_to_le16((u16
)uRrvTime
);
407 //byFreqType 0: 5GHz, 1:2.4Ghz
408 static u16
s_uGetDataDuration(struct vnt_private
*pDevice
,
409 u8 byPktType
, int bNeedAck
)
414 if (byPktType
== PK_TYPE_11B
)
415 uAckTime
= BBuGetFrameTime(pDevice
->byPreambleType
,
416 byPktType
, 14, pDevice
->byTopCCKBasicRate
);
418 uAckTime
= BBuGetFrameTime(pDevice
->byPreambleType
,
419 byPktType
, 14, pDevice
->byTopOFDMBasicRate
);
420 return cpu_to_le16((u16
)(pDevice
->uSIFS
+ uAckTime
));
426 //byFreqType: 0=>5GHZ 1=>2.4GHZ
427 static u16
s_uGetRTSCTSDuration(struct vnt_private
*pDevice
, u8 byDurType
,
428 u32 cbFrameLength
, u8 byPktType
, u16 wRate
, int bNeedAck
,
431 u32 uCTSTime
= 0, uDurTime
= 0;
435 case RTSDUR_BB
: //RTSDuration_bb
436 uCTSTime
= BBuGetFrameTime(pDevice
->byPreambleType
, byPktType
, 14, pDevice
->byTopCCKBasicRate
);
437 uDurTime
= uCTSTime
+ 2*pDevice
->uSIFS
+ s_uGetTxRsvTime(pDevice
, byPktType
, cbFrameLength
, wRate
, bNeedAck
);
440 case RTSDUR_BA
: //RTSDuration_ba
441 uCTSTime
= BBuGetFrameTime(pDevice
->byPreambleType
, byPktType
, 14, pDevice
->byTopCCKBasicRate
);
442 uDurTime
= uCTSTime
+ 2*pDevice
->uSIFS
+ s_uGetTxRsvTime(pDevice
, byPktType
, cbFrameLength
, wRate
, bNeedAck
);
445 case RTSDUR_AA
: //RTSDuration_aa
446 uCTSTime
= BBuGetFrameTime(pDevice
->byPreambleType
, byPktType
, 14, pDevice
->byTopOFDMBasicRate
);
447 uDurTime
= uCTSTime
+ 2*pDevice
->uSIFS
+ s_uGetTxRsvTime(pDevice
, byPktType
, cbFrameLength
, wRate
, bNeedAck
);
450 case CTSDUR_BA
: //CTSDuration_ba
451 uDurTime
= pDevice
->uSIFS
+ s_uGetTxRsvTime(pDevice
, byPktType
, cbFrameLength
, wRate
, bNeedAck
);
454 case RTSDUR_BA_F0
: //RTSDuration_ba_f0
455 uCTSTime
= BBuGetFrameTime(pDevice
->byPreambleType
, byPktType
, 14, pDevice
->byTopCCKBasicRate
);
456 if ((byFBOption
== AUTO_FB_0
) && (wRate
>= RATE_18M
) && (wRate
<=RATE_54M
)) {
457 uDurTime
= uCTSTime
+ 2*pDevice
->uSIFS
+ s_uGetTxRsvTime(pDevice
, byPktType
, cbFrameLength
, wFB_Opt0
[FB_RATE0
][wRate
-RATE_18M
], bNeedAck
);
458 } else if ((byFBOption
== AUTO_FB_1
) && (wRate
>= RATE_18M
) && (wRate
<=RATE_54M
)) {
459 uDurTime
= uCTSTime
+ 2*pDevice
->uSIFS
+ s_uGetTxRsvTime(pDevice
, byPktType
, cbFrameLength
, wFB_Opt1
[FB_RATE0
][wRate
-RATE_18M
], bNeedAck
);
463 case RTSDUR_AA_F0
: //RTSDuration_aa_f0
464 uCTSTime
= BBuGetFrameTime(pDevice
->byPreambleType
, byPktType
, 14, pDevice
->byTopOFDMBasicRate
);
465 if ((byFBOption
== AUTO_FB_0
) && (wRate
>= RATE_18M
) && (wRate
<=RATE_54M
)) {
466 uDurTime
= uCTSTime
+ 2*pDevice
->uSIFS
+ s_uGetTxRsvTime(pDevice
, byPktType
, cbFrameLength
, wFB_Opt0
[FB_RATE0
][wRate
-RATE_18M
], bNeedAck
);
467 } else if ((byFBOption
== AUTO_FB_1
) && (wRate
>= RATE_18M
) && (wRate
<=RATE_54M
)) {
468 uDurTime
= uCTSTime
+ 2*pDevice
->uSIFS
+ s_uGetTxRsvTime(pDevice
, byPktType
, cbFrameLength
, wFB_Opt1
[FB_RATE0
][wRate
-RATE_18M
], bNeedAck
);
472 case RTSDUR_BA_F1
: //RTSDuration_ba_f1
473 uCTSTime
= BBuGetFrameTime(pDevice
->byPreambleType
, byPktType
, 14, pDevice
->byTopCCKBasicRate
);
474 if ((byFBOption
== AUTO_FB_0
) && (wRate
>= RATE_18M
) && (wRate
<=RATE_54M
)) {
475 uDurTime
= uCTSTime
+ 2*pDevice
->uSIFS
+ s_uGetTxRsvTime(pDevice
, byPktType
, cbFrameLength
, wFB_Opt0
[FB_RATE1
][wRate
-RATE_18M
], bNeedAck
);
476 } else if ((byFBOption
== AUTO_FB_1
) && (wRate
>= RATE_18M
) && (wRate
<=RATE_54M
)) {
477 uDurTime
= uCTSTime
+ 2*pDevice
->uSIFS
+ s_uGetTxRsvTime(pDevice
, byPktType
, cbFrameLength
, wFB_Opt1
[FB_RATE1
][wRate
-RATE_18M
], bNeedAck
);
481 case RTSDUR_AA_F1
: //RTSDuration_aa_f1
482 uCTSTime
= BBuGetFrameTime(pDevice
->byPreambleType
, byPktType
, 14, pDevice
->byTopOFDMBasicRate
);
483 if ((byFBOption
== AUTO_FB_0
) && (wRate
>= RATE_18M
) && (wRate
<=RATE_54M
)) {
484 uDurTime
= uCTSTime
+ 2*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
= uCTSTime
+ 2*pDevice
->uSIFS
+ s_uGetTxRsvTime(pDevice
, byPktType
, cbFrameLength
, wFB_Opt1
[FB_RATE1
][wRate
-RATE_18M
], bNeedAck
);
490 case CTSDUR_BA_F0
: //CTSDuration_ba_f0
491 if ((byFBOption
== AUTO_FB_0
) && (wRate
>= RATE_18M
) && (wRate
<=RATE_54M
)) {
492 uDurTime
= pDevice
->uSIFS
+ s_uGetTxRsvTime(pDevice
, byPktType
, cbFrameLength
, wFB_Opt0
[FB_RATE0
][wRate
-RATE_18M
], bNeedAck
);
493 } else if ((byFBOption
== AUTO_FB_1
) && (wRate
>= RATE_18M
) && (wRate
<=RATE_54M
)) {
494 uDurTime
= pDevice
->uSIFS
+ s_uGetTxRsvTime(pDevice
, byPktType
, cbFrameLength
, wFB_Opt1
[FB_RATE0
][wRate
-RATE_18M
], bNeedAck
);
498 case CTSDUR_BA_F1
: //CTSDuration_ba_f1
499 if ((byFBOption
== AUTO_FB_0
) && (wRate
>= RATE_18M
) && (wRate
<=RATE_54M
)) {
500 uDurTime
= pDevice
->uSIFS
+ s_uGetTxRsvTime(pDevice
, byPktType
, cbFrameLength
, wFB_Opt0
[FB_RATE1
][wRate
-RATE_18M
], bNeedAck
);
501 } else if ((byFBOption
== AUTO_FB_1
) && (wRate
>= RATE_18M
) && (wRate
<=RATE_54M
)) {
502 uDurTime
= pDevice
->uSIFS
+ s_uGetTxRsvTime(pDevice
, byPktType
, cbFrameLength
, wFB_Opt1
[FB_RATE1
][wRate
-RATE_18M
], bNeedAck
);
510 return cpu_to_le16((u16
)uDurTime
);
513 static u32
s_uFillDataHead(struct vnt_private
*pDevice
,
514 u8 byPktType
, u16 wCurrentRate
, void *pTxDataHead
, u32 cbFrameLength
,
515 u32 uDMAIdx
, int bNeedAck
, u8 byFBOption
)
518 if (pTxDataHead
== NULL
) {
522 if (byPktType
== PK_TYPE_11GB
|| byPktType
== PK_TYPE_11GA
) {
523 if (byFBOption
== AUTO_FB_NONE
) {
524 struct vnt_tx_datahead_g
*pBuf
=
525 (struct vnt_tx_datahead_g
*)pTxDataHead
;
526 //Get SignalField,ServiceField,Length
527 BBvCalculateParameter(pDevice
, cbFrameLength
, wCurrentRate
,
528 byPktType
, &pBuf
->a
);
529 BBvCalculateParameter(pDevice
, cbFrameLength
,
530 pDevice
->byTopCCKBasicRate
, PK_TYPE_11B
, &pBuf
->b
);
531 //Get Duration and TimeStamp
532 pBuf
->wDuration_a
= s_uGetDataDuration(pDevice
,
533 byPktType
, bNeedAck
);
534 pBuf
->wDuration_b
= s_uGetDataDuration(pDevice
,
535 PK_TYPE_11B
, bNeedAck
);
537 pBuf
->wTimeStampOff_a
= vnt_time_stamp_off(pDevice
,
539 pBuf
->wTimeStampOff_b
= vnt_time_stamp_off(pDevice
,
540 pDevice
->byTopCCKBasicRate
);
541 return (pBuf
->wDuration_a
);
544 struct vnt_tx_datahead_g_fb
*pBuf
=
545 (struct vnt_tx_datahead_g_fb
*)pTxDataHead
;
546 //Get SignalField,ServiceField,Length
547 BBvCalculateParameter(pDevice
, cbFrameLength
, wCurrentRate
,
548 byPktType
, &pBuf
->a
);
549 BBvCalculateParameter(pDevice
, cbFrameLength
,
550 pDevice
->byTopCCKBasicRate
, PK_TYPE_11B
, &pBuf
->b
);
551 //Get Duration and TimeStamp
552 pBuf
->wDuration_a
= s_uGetDataDuration(pDevice
,
553 byPktType
, bNeedAck
);
554 pBuf
->wDuration_b
= s_uGetDataDuration(pDevice
,
555 PK_TYPE_11B
, bNeedAck
);
556 pBuf
->wDuration_a_f0
= s_uGetDataDuration(pDevice
,
557 byPktType
, bNeedAck
);
558 pBuf
->wDuration_a_f1
= s_uGetDataDuration(pDevice
,
559 byPktType
, bNeedAck
);
560 pBuf
->wTimeStampOff_a
= vnt_time_stamp_off(pDevice
,
562 pBuf
->wTimeStampOff_b
= vnt_time_stamp_off(pDevice
,
563 pDevice
->byTopCCKBasicRate
);
564 return (pBuf
->wDuration_a
);
565 } //if (byFBOption == AUTO_FB_NONE)
567 else if (byPktType
== PK_TYPE_11A
) {
568 if (byFBOption
!= AUTO_FB_NONE
) {
569 struct vnt_tx_datahead_a_fb
*pBuf
=
570 (struct vnt_tx_datahead_a_fb
*)pTxDataHead
;
571 //Get SignalField,ServiceField,Length
572 BBvCalculateParameter(pDevice
, cbFrameLength
, wCurrentRate
,
573 byPktType
, &pBuf
->a
);
574 //Get Duration and TimeStampOff
575 pBuf
->wDuration
= s_uGetDataDuration(pDevice
,
576 byPktType
, bNeedAck
);
577 pBuf
->wDuration_f0
= s_uGetDataDuration(pDevice
,
578 byPktType
, bNeedAck
);
579 pBuf
->wDuration_f1
= s_uGetDataDuration(pDevice
,
580 byPktType
, bNeedAck
);
581 pBuf
->wTimeStampOff
= vnt_time_stamp_off(pDevice
,
583 return (pBuf
->wDuration
);
585 struct vnt_tx_datahead_ab
*pBuf
=
586 (struct vnt_tx_datahead_ab
*)pTxDataHead
;
587 //Get SignalField,ServiceField,Length
588 BBvCalculateParameter(pDevice
, cbFrameLength
, wCurrentRate
,
589 byPktType
, &pBuf
->ab
);
590 //Get Duration and TimeStampOff
591 pBuf
->wDuration
= s_uGetDataDuration(pDevice
,
592 byPktType
, bNeedAck
);
593 pBuf
->wTimeStampOff
= vnt_time_stamp_off(pDevice
,
595 return (pBuf
->wDuration
);
598 else if (byPktType
== PK_TYPE_11B
) {
599 struct vnt_tx_datahead_ab
*pBuf
=
600 (struct vnt_tx_datahead_ab
*)pTxDataHead
;
601 //Get SignalField,ServiceField,Length
602 BBvCalculateParameter(pDevice
, cbFrameLength
, wCurrentRate
,
603 byPktType
, &pBuf
->ab
);
604 //Get Duration and TimeStampOff
605 pBuf
->wDuration
= s_uGetDataDuration(pDevice
,
606 byPktType
, bNeedAck
);
607 pBuf
->wTimeStampOff
= vnt_time_stamp_off(pDevice
,
609 return (pBuf
->wDuration
);
614 static int vnt_fill_ieee80211_rts(struct vnt_private
*priv
,
615 struct ieee80211_rts
*rts
, struct ethhdr
*eth_hdr
,
618 rts
->duration
= duration
;
619 rts
->frame_control
= TYPE_CTL_RTS
;
621 if (priv
->eOPMode
== OP_MODE_ADHOC
|| priv
->eOPMode
== OP_MODE_AP
)
622 memcpy(rts
->ra
, eth_hdr
->h_dest
, ETH_ALEN
);
624 memcpy(rts
->ra
, priv
->abyBSSID
, ETH_ALEN
);
626 if (priv
->eOPMode
== OP_MODE_AP
)
627 memcpy(rts
->ta
, priv
->abyBSSID
, ETH_ALEN
);
629 memcpy(rts
->ta
, eth_hdr
->h_source
, ETH_ALEN
);
634 static int vnt_rxtx_rts_g_head(struct vnt_private
*priv
,
635 struct vnt_rts_g
*buf
, struct ethhdr
*eth_hdr
,
636 u8 pkt_type
, u32 frame_len
, int need_ack
,
637 u16 current_rate
, u8 fb_option
)
639 u16 rts_frame_len
= 20;
641 BBvCalculateParameter(priv
, rts_frame_len
, priv
->byTopCCKBasicRate
,
642 PK_TYPE_11B
, &buf
->b
);
643 BBvCalculateParameter(priv
, rts_frame_len
,
644 priv
->byTopOFDMBasicRate
, pkt_type
, &buf
->a
);
646 buf
->wDuration_bb
= s_uGetRTSCTSDuration(priv
, RTSDUR_BB
, frame_len
,
647 PK_TYPE_11B
, priv
->byTopCCKBasicRate
, need_ack
, fb_option
);
648 buf
->wDuration_aa
= s_uGetRTSCTSDuration(priv
, RTSDUR_AA
, frame_len
,
649 pkt_type
, current_rate
, need_ack
, fb_option
);
650 buf
->wDuration_ba
= s_uGetRTSCTSDuration(priv
, RTSDUR_BA
, frame_len
,
651 pkt_type
, current_rate
, need_ack
, fb_option
);
653 vnt_fill_ieee80211_rts(priv
, &buf
->data
, eth_hdr
, buf
->wDuration_aa
);
658 static int vnt_rxtx_rts_g_fb_head(struct vnt_private
*priv
,
659 struct vnt_rts_g_fb
*buf
, struct ethhdr
*eth_hdr
,
660 u8 pkt_type
, u32 frame_len
, int need_ack
,
661 u16 current_rate
, u8 fb_option
)
663 u16 rts_frame_len
= 20;
665 BBvCalculateParameter(priv
, rts_frame_len
, priv
->byTopCCKBasicRate
,
666 PK_TYPE_11B
, &buf
->b
);
667 BBvCalculateParameter(priv
, rts_frame_len
,
668 priv
->byTopOFDMBasicRate
, pkt_type
, &buf
->a
);
671 buf
->wDuration_bb
= s_uGetRTSCTSDuration(priv
, RTSDUR_BB
, frame_len
,
672 PK_TYPE_11B
, priv
->byTopCCKBasicRate
, need_ack
, fb_option
);
673 buf
->wDuration_aa
= s_uGetRTSCTSDuration(priv
, RTSDUR_AA
, frame_len
,
674 pkt_type
, current_rate
, need_ack
, fb_option
);
675 buf
->wDuration_ba
= s_uGetRTSCTSDuration(priv
, RTSDUR_BA
, frame_len
,
676 pkt_type
, current_rate
, need_ack
, fb_option
);
679 buf
->wRTSDuration_ba_f0
= s_uGetRTSCTSDuration(priv
, RTSDUR_BA_F0
,
680 frame_len
, pkt_type
, current_rate
, need_ack
, fb_option
);
681 buf
->wRTSDuration_aa_f0
= s_uGetRTSCTSDuration(priv
, RTSDUR_AA_F0
,
682 frame_len
, pkt_type
, current_rate
, need_ack
, fb_option
);
683 buf
->wRTSDuration_ba_f1
= s_uGetRTSCTSDuration(priv
, RTSDUR_BA_F1
,
684 frame_len
, pkt_type
, current_rate
, need_ack
, fb_option
);
685 buf
->wRTSDuration_aa_f1
= s_uGetRTSCTSDuration(priv
, RTSDUR_AA_F1
,
686 frame_len
, pkt_type
, current_rate
, need_ack
, fb_option
);
688 vnt_fill_ieee80211_rts(priv
, &buf
->data
, eth_hdr
, buf
->wDuration_aa
);
693 static int vnt_rxtx_rts_ab_head(struct vnt_private
*priv
,
694 struct vnt_rts_ab
*buf
, struct ethhdr
*eth_hdr
,
695 u8 pkt_type
, u32 frame_len
, int need_ack
,
696 u16 current_rate
, u8 fb_option
)
698 u16 rts_frame_len
= 20;
700 BBvCalculateParameter(priv
, rts_frame_len
,
701 priv
->byTopOFDMBasicRate
, pkt_type
, &buf
->ab
);
703 buf
->wDuration
= s_uGetRTSCTSDuration(priv
, RTSDUR_AA
, frame_len
,
704 pkt_type
, current_rate
, need_ack
, fb_option
);
706 vnt_fill_ieee80211_rts(priv
, &buf
->data
, eth_hdr
, buf
->wDuration
);
711 static int vnt_rxtx_rts_a_fb_head(struct vnt_private
*priv
,
712 struct vnt_rts_a_fb
*buf
, struct ethhdr
*eth_hdr
,
713 u8 pkt_type
, u32 frame_len
, int need_ack
,
714 u16 current_rate
, u8 fb_option
)
716 u16 rts_frame_len
= 20;
718 BBvCalculateParameter(priv
, rts_frame_len
,
719 priv
->byTopOFDMBasicRate
, pkt_type
, &buf
->a
);
721 buf
->wDuration
= s_uGetRTSCTSDuration(priv
, RTSDUR_AA
, frame_len
,
722 pkt_type
, current_rate
, need_ack
, fb_option
);
724 buf
->wRTSDuration_f0
= s_uGetRTSCTSDuration(priv
, RTSDUR_AA_F0
,
725 frame_len
, pkt_type
, current_rate
, need_ack
, fb_option
);
727 buf
->wRTSDuration_f1
= s_uGetRTSCTSDuration(priv
, RTSDUR_AA_F1
,
728 frame_len
, pkt_type
, current_rate
, need_ack
, fb_option
);
730 vnt_fill_ieee80211_rts(priv
, &buf
->data
, eth_hdr
, buf
->wDuration
);
735 static void s_vFillRTSHead(struct vnt_private
*pDevice
, u8 byPktType
,
736 union vnt_tx_data_head
*head
, u32 cbFrameLength
, int bNeedAck
,
737 struct ethhdr
*psEthHeader
, u16 wCurrentRate
, u8 byFBOption
)
743 /* Note: So far RTSHead doesn't appear in ATIM
744 * & Beacom DMA, so we don't need to take them
746 * Otherwise, we need to modified codes for them.
751 if (byFBOption
== AUTO_FB_NONE
)
752 vnt_rxtx_rts_g_head(pDevice
, &head
->rts_g
,
753 psEthHeader
, byPktType
, cbFrameLength
,
754 bNeedAck
, wCurrentRate
, byFBOption
);
756 vnt_rxtx_rts_g_fb_head(pDevice
, &head
->rts_g_fb
,
757 psEthHeader
, byPktType
, cbFrameLength
,
758 bNeedAck
, wCurrentRate
, byFBOption
);
762 vnt_rxtx_rts_a_fb_head(pDevice
, &head
->rts_a_fb
,
763 psEthHeader
, byPktType
, cbFrameLength
,
764 bNeedAck
, wCurrentRate
, byFBOption
);
768 vnt_rxtx_rts_ab_head(pDevice
, &head
->rts_ab
,
769 psEthHeader
, byPktType
, cbFrameLength
,
770 bNeedAck
, wCurrentRate
, byFBOption
);
774 static void s_vFillCTSHead(struct vnt_private
*pDevice
, u32 uDMAIdx
,
775 u8 byPktType
, union vnt_tx_data_head
*head
, u32 cbFrameLength
,
776 int bNeedAck
, u16 wCurrentRate
, u8 byFBOption
)
778 u32 uCTSFrameLen
= 14;
783 if (byFBOption
!= AUTO_FB_NONE
) {
785 struct vnt_cts_fb
*pBuf
= &head
->cts_g_fb
;
786 /* Get SignalField,ServiceField,Length */
787 BBvCalculateParameter(pDevice
, uCTSFrameLen
,
788 pDevice
->byTopCCKBasicRate
, PK_TYPE_11B
, &pBuf
->b
);
789 pBuf
->wDuration_ba
= s_uGetRTSCTSDuration(pDevice
, CTSDUR_BA
,
790 cbFrameLength
, byPktType
,
791 wCurrentRate
, bNeedAck
, byFBOption
);
792 /* Get CTSDuration_ba_f0 */
793 pBuf
->wCTSDuration_ba_f0
= s_uGetRTSCTSDuration(pDevice
,
794 CTSDUR_BA_F0
, cbFrameLength
, byPktType
, wCurrentRate
,
795 bNeedAck
, byFBOption
);
796 /* Get CTSDuration_ba_f1 */
797 pBuf
->wCTSDuration_ba_f1
= s_uGetRTSCTSDuration(pDevice
,
798 CTSDUR_BA_F1
, cbFrameLength
, byPktType
, wCurrentRate
,
799 bNeedAck
, byFBOption
);
800 /* Get CTS Frame body */
801 pBuf
->data
.duration
= pBuf
->wDuration_ba
;
802 pBuf
->data
.frame_control
= TYPE_CTL_CTS
;
803 memcpy(pBuf
->data
.ra
, pDevice
->abyCurrentNetAddr
, ETH_ALEN
);
805 struct vnt_cts
*pBuf
= &head
->cts_g
;
806 /* Get SignalField,ServiceField,Length */
807 BBvCalculateParameter(pDevice
, uCTSFrameLen
,
808 pDevice
->byTopCCKBasicRate
, PK_TYPE_11B
, &pBuf
->b
);
809 /* Get CTSDuration_ba */
810 pBuf
->wDuration_ba
= s_uGetRTSCTSDuration(pDevice
,
811 CTSDUR_BA
, cbFrameLength
, byPktType
,
812 wCurrentRate
, bNeedAck
, byFBOption
);
813 /*Get CTS Frame body*/
814 pBuf
->data
.duration
= pBuf
->wDuration_ba
;
815 pBuf
->data
.frame_control
= TYPE_CTL_CTS
;
816 memcpy(pBuf
->data
.ra
, pDevice
->abyCurrentNetAddr
, ETH_ALEN
);
823 * Generate FIFO control for MAC & Baseband controller
827 * pDevice - Pointer to adpater
828 * pTxDataHead - Transmit Data Buffer
829 * pTxBufHead - pTxBufHead
830 * pvRrvTime - pvRrvTime
833 * cbFrameSize - Transmit Data Length (Hdr+Payload+FCS)
834 * bNeedACK - If need ACK
835 * uDMAIdx - DMA Index
843 static void s_vGenerateTxParameter(struct vnt_private
*pDevice
,
844 u8 byPktType
, u16 wCurrentRate
, struct vnt_tx_buffer
*tx_buffer
,
845 struct vnt_mic_hdr
**mic_hdr
, u32 need_mic
,
846 void *rts_cts
, u32 cbFrameSize
, int bNeedACK
, u32 uDMAIdx
,
847 struct ethhdr
*psEthHeader
, bool need_rts
)
849 struct vnt_tx_fifo_head
*pFifoHead
= &tx_buffer
->fifo_head
;
850 union vnt_tx_data_head
*head
= rts_cts
;
851 u32 cbMACHdLen
= WLAN_HDR_ADDR3_LEN
; /* 24 */
853 u8 byFBOption
= AUTO_FB_NONE
;
855 //DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"s_vGenerateTxParameter...\n");
856 pFifoHead
->wReserved
= wCurrentRate
;
857 wFifoCtl
= pFifoHead
->wFIFOCtl
;
859 if (wFifoCtl
& FIFOCTL_AUTO_FB_0
) {
860 byFBOption
= AUTO_FB_0
;
862 else if (wFifoCtl
& FIFOCTL_AUTO_FB_1
) {
863 byFBOption
= AUTO_FB_1
;
869 if (pDevice
->bLongHeader
)
870 cbMACHdLen
= WLAN_HDR_ADDR3_LEN
+ 6;
872 if (byPktType
== PK_TYPE_11GB
|| byPktType
== PK_TYPE_11GA
) {
875 struct vnt_rrv_time_rts
*pBuf
= &tx_buffer
->tx_head
.tx_rts
.rts
;
877 pBuf
->wRTSTxRrvTime_aa
= s_uGetRTSCTSRsvTime(pDevice
, 2,
878 byPktType
, cbFrameSize
, wCurrentRate
);
879 pBuf
->wRTSTxRrvTime_ba
= s_uGetRTSCTSRsvTime(pDevice
, 1,
880 byPktType
, cbFrameSize
, wCurrentRate
);
881 pBuf
->wRTSTxRrvTime_bb
= s_uGetRTSCTSRsvTime(pDevice
, 0,
882 byPktType
, cbFrameSize
, wCurrentRate
);
883 pBuf
->wTxRrvTime_a
= vnt_rxtx_rsvtime_le16(pDevice
,
884 byPktType
, cbFrameSize
, wCurrentRate
, bNeedACK
);
885 pBuf
->wTxRrvTime_b
= vnt_rxtx_rsvtime_le16(pDevice
,
886 PK_TYPE_11B
, cbFrameSize
, pDevice
->byTopCCKBasicRate
,
889 *mic_hdr
= &tx_buffer
->tx_head
.tx_rts
.tx
.mic
.hdr
;
892 s_vFillRTSHead(pDevice
, byPktType
, head
, cbFrameSize
,
893 bNeedACK
, psEthHeader
, wCurrentRate
, byFBOption
);
895 else {//RTS_needless, PCF mode
897 struct vnt_rrv_time_cts
*pBuf
= &tx_buffer
->tx_head
.tx_cts
.cts
;
899 pBuf
->wTxRrvTime_a
= vnt_rxtx_rsvtime_le16(pDevice
, byPktType
,
900 cbFrameSize
, wCurrentRate
, bNeedACK
);
901 pBuf
->wTxRrvTime_b
= vnt_rxtx_rsvtime_le16(pDevice
,
902 PK_TYPE_11B
, cbFrameSize
,
903 pDevice
->byTopCCKBasicRate
, bNeedACK
);
904 pBuf
->wCTSTxRrvTime_ba
= s_uGetRTSCTSRsvTime(pDevice
, 3,
905 byPktType
, cbFrameSize
, wCurrentRate
);
908 *mic_hdr
= &tx_buffer
->tx_head
.tx_cts
.tx
.mic
.hdr
;
911 s_vFillCTSHead(pDevice
, uDMAIdx
, byPktType
, head
,
912 cbFrameSize
, bNeedACK
, wCurrentRate
, byFBOption
);
915 else if (byPktType
== PK_TYPE_11A
) {
918 struct vnt_rrv_time_ab
*pBuf
= &tx_buffer
->tx_head
.tx_ab
.ab
;
920 pBuf
->wRTSTxRrvTime
= s_uGetRTSCTSRsvTime(pDevice
, 2,
921 byPktType
, cbFrameSize
, wCurrentRate
);
922 pBuf
->wTxRrvTime
= vnt_rxtx_rsvtime_le16(pDevice
, byPktType
,
923 cbFrameSize
, wCurrentRate
, bNeedACK
);
925 *mic_hdr
= &tx_buffer
->tx_head
.tx_ab
.tx
.mic
.hdr
;
928 s_vFillRTSHead(pDevice
, byPktType
, head
, cbFrameSize
,
929 bNeedACK
, psEthHeader
, wCurrentRate
, byFBOption
);
932 struct vnt_rrv_time_ab
*pBuf
= &tx_buffer
->tx_head
.tx_ab
.ab
;
935 *mic_hdr
= &tx_buffer
->tx_head
.tx_ab
.tx
.mic
.hdr
;
937 pBuf
->wTxRrvTime
= vnt_rxtx_rsvtime_le16(pDevice
, PK_TYPE_11A
,
938 cbFrameSize
, wCurrentRate
, bNeedACK
);
941 else if (byPktType
== PK_TYPE_11B
) {
944 struct vnt_rrv_time_ab
*pBuf
= &tx_buffer
->tx_head
.tx_ab
.ab
;
946 pBuf
->wRTSTxRrvTime
= s_uGetRTSCTSRsvTime(pDevice
, 0,
947 byPktType
, cbFrameSize
, wCurrentRate
);
948 pBuf
->wTxRrvTime
= vnt_rxtx_rsvtime_le16(pDevice
, PK_TYPE_11B
,
949 cbFrameSize
, wCurrentRate
, bNeedACK
);
952 *mic_hdr
= &tx_buffer
->tx_head
.tx_ab
.tx
.mic
.hdr
;
955 s_vFillRTSHead(pDevice
, byPktType
, head
, cbFrameSize
,
956 bNeedACK
, psEthHeader
, wCurrentRate
, byFBOption
);
958 else { //RTS_needless, non PCF mode
960 struct vnt_rrv_time_ab
*pBuf
= &tx_buffer
->tx_head
.tx_ab
.ab
;
963 *mic_hdr
= &tx_buffer
->tx_head
.tx_ab
.tx
.mic
.hdr
;
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
*tx_buffer
, 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_tx_fifo_head
*pTxBufHead
= &tx_buffer
->fifo_head
;
984 struct vnt_manager
*pMgmt
= &pDevice
->vnt_mgmt
;
985 u32 cbFrameSize
, cbFrameBodySize
;
987 u32 cbIVlen
= 0, cbICVlen
= 0, cbMIClen
= 0, cbMACHdLen
= 0;
988 u32 cbFCSlen
= 4, cbMICHDR
= 0;
991 u8
*pbyType
, *pbyMacHdr
, *pbyIVHead
, *pbyPayloadHead
, *pbyTxBufferAddr
;
992 u8 abySNAP_RFC1042
[ETH_ALEN
] = {0xAA, 0xAA, 0x03, 0x00, 0x00, 0x00};
993 u8 abySNAP_Bridgetunnel
[ETH_ALEN
]
994 = {0xAA, 0xAA, 0x03, 0x00, 0x00, 0xF8};
996 u32 cbHeaderLength
= 0, uPadding
= 0;
997 struct vnt_mic_hdr
*pMICHDR
;
998 void *rts_cts
= NULL
;
1000 u8 byFBOption
= AUTO_FB_NONE
, byFragType
;
1002 u32 dwMICKey0
, dwMICKey1
, dwMIC_Priority
;
1003 u32
*pdwMIC_L
, *pdwMIC_R
;
1004 int bSoftWEP
= false;
1006 pMICHDR
= 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(struct vnt_tx_fifo_head
);
1130 if (byPktType
== PK_TYPE_11GB
|| byPktType
== PK_TYPE_11GA
) {//802.11g packet
1131 if (byFBOption
== AUTO_FB_NONE
) {
1132 if (bRTS
== true) {//RTS_need
1133 rts_cts
= (struct vnt_rts_g
*) (pbyTxBufferAddr
+ wTxBufSize
+
1134 sizeof(struct vnt_rrv_time_rts
) + cbMICHDR
);
1135 pvTxDataHd
= (struct vnt_tx_datahead_g
*) (pbyTxBufferAddr
+
1136 wTxBufSize
+ sizeof(struct vnt_rrv_time_rts
) +
1137 cbMICHDR
+ sizeof(struct vnt_rts_g
));
1138 cbHeaderLength
= wTxBufSize
+ sizeof(struct vnt_rrv_time_rts
) +
1139 cbMICHDR
+ sizeof(struct vnt_rts_g
) +
1140 sizeof(struct vnt_tx_datahead_g
);
1142 else { //RTS_needless
1143 rts_cts
= (struct vnt_cts
*) (pbyTxBufferAddr
+ wTxBufSize
+
1144 sizeof(struct vnt_rrv_time_cts
) + cbMICHDR
);
1145 pvTxDataHd
= (struct vnt_tx_datahead_g
*)(pbyTxBufferAddr
+
1146 wTxBufSize
+ sizeof(struct vnt_rrv_time_cts
) +
1147 cbMICHDR
+ sizeof(struct vnt_cts
));
1148 cbHeaderLength
= wTxBufSize
+ sizeof(struct vnt_rrv_time_cts
) +
1149 cbMICHDR
+ sizeof(struct vnt_cts
) +
1150 sizeof(struct vnt_tx_datahead_g
);
1154 if (bRTS
== true) {//RTS_need
1155 rts_cts
= (struct vnt_rts_g_fb
*)(pbyTxBufferAddr
+ wTxBufSize
+
1156 sizeof(struct vnt_rrv_time_rts
) + cbMICHDR
);
1157 pvTxDataHd
= (struct vnt_tx_datahead_g_fb
*) (pbyTxBufferAddr
+
1158 wTxBufSize
+ sizeof(struct vnt_rrv_time_rts
) +
1159 cbMICHDR
+ sizeof(struct vnt_rts_g_fb
));
1160 cbHeaderLength
= wTxBufSize
+ sizeof(struct vnt_rrv_time_rts
) +
1161 cbMICHDR
+ sizeof(struct vnt_rts_g_fb
) +
1162 sizeof(struct vnt_tx_datahead_g_fb
);
1164 else if (bRTS
== false) { //RTS_needless
1165 rts_cts
= (struct vnt_cts_fb
*) (pbyTxBufferAddr
+ wTxBufSize
+
1166 sizeof(struct vnt_rrv_time_cts
) + cbMICHDR
);
1167 pvTxDataHd
= (struct vnt_tx_datahead_g_fb
*) (pbyTxBufferAddr
+
1168 wTxBufSize
+ sizeof(struct vnt_rrv_time_cts
) +
1169 cbMICHDR
+ sizeof(struct vnt_cts_fb
));
1170 cbHeaderLength
= wTxBufSize
+ sizeof(struct vnt_rrv_time_cts
) +
1171 cbMICHDR
+ sizeof(struct vnt_cts_fb
) +
1172 sizeof(struct vnt_tx_datahead_g_fb
);
1176 else {//802.11a/b packet
1177 if (byFBOption
== AUTO_FB_NONE
) {
1178 if (bRTS
== true) {//RTS_need
1179 rts_cts
= (struct vnt_rts_ab
*) (pbyTxBufferAddr
+ wTxBufSize
+
1180 sizeof(struct vnt_rrv_time_ab
) + cbMICHDR
);
1181 pvTxDataHd
= (struct vnt_tx_datahead_ab
*)(pbyTxBufferAddr
+
1182 wTxBufSize
+ sizeof(struct vnt_rrv_time_ab
) + cbMICHDR
+
1183 sizeof(struct vnt_rts_ab
));
1184 cbHeaderLength
= wTxBufSize
+ sizeof(struct vnt_rrv_time_ab
) +
1185 cbMICHDR
+ sizeof(struct vnt_rts_ab
) +
1186 sizeof(struct vnt_tx_datahead_ab
);
1188 else if (bRTS
== false) { //RTS_needless, no MICHDR
1189 pvTxDataHd
= (struct vnt_tx_datahead_ab
*)(pbyTxBufferAddr
+
1190 wTxBufSize
+ sizeof(struct vnt_rrv_time_ab
) + cbMICHDR
);
1191 cbHeaderLength
= wTxBufSize
+ sizeof(struct vnt_rrv_time_ab
) +
1192 cbMICHDR
+ sizeof(struct vnt_tx_datahead_ab
);
1196 if (bRTS
== true) {//RTS_need
1197 rts_cts
= (struct vnt_rts_a_fb
*)(pbyTxBufferAddr
+ wTxBufSize
+
1198 sizeof(struct vnt_rrv_time_ab
) + cbMICHDR
);
1199 pvTxDataHd
= (struct vnt_tx_datahead_a_fb
*)(pbyTxBufferAddr
+
1200 wTxBufSize
+ sizeof(struct vnt_rrv_time_ab
) + cbMICHDR
+
1201 sizeof(struct vnt_rts_a_fb
));
1202 cbHeaderLength
= wTxBufSize
+ sizeof(struct vnt_rrv_time_ab
) +
1203 cbMICHDR
+ sizeof(struct vnt_rts_a_fb
) +
1204 sizeof(struct vnt_tx_datahead_a_fb
);
1206 else if (bRTS
== false) { //RTS_needless
1207 pvTxDataHd
= (struct vnt_tx_datahead_a_fb
*)(pbyTxBufferAddr
+
1208 wTxBufSize
+ sizeof(struct vnt_rrv_time_ab
) + cbMICHDR
);
1209 cbHeaderLength
= wTxBufSize
+ sizeof(struct vnt_rrv_time_ab
) +
1210 cbMICHDR
+ sizeof(struct vnt_tx_datahead_a_fb
);
1215 pbyMacHdr
= (u8
*)(pbyTxBufferAddr
+ cbHeaderLength
);
1216 pbyIVHead
= (u8
*)(pbyMacHdr
+ cbMACHdLen
+ uPadding
);
1217 pbyPayloadHead
= (u8
*)(pbyMacHdr
+ cbMACHdLen
+ uPadding
+ cbIVlen
);
1219 //=========================
1221 //=========================
1222 DBG_PRT(MSG_LEVEL_DEBUG
, KERN_INFO
"No Fragmentation...\n");
1223 byFragType
= FRAGCTL_NONFRAG
;
1224 //uDMAIdx = TYPE_AC0DMA;
1225 //pTxBufHead = (PSTxBufHead) &(pTxBufHead->adwTxKey[0]);
1227 //Fill FIFO,RrvTime,RTS,and CTS
1228 s_vGenerateTxParameter(pDevice
, byPktType
, wCurrentRate
,
1229 tx_buffer
, &pMICHDR
, cbMICHDR
, rts_cts
,
1230 cbFrameSize
, bNeedACK
, uDMAIdx
, psEthHeader
, bRTS
);
1232 uDuration
= s_uFillDataHead(pDevice
, byPktType
, wCurrentRate
, pvTxDataHd
, cbFrameSize
, uDMAIdx
, bNeedACK
,
1234 // Generate TX MAC Header
1235 s_vGenerateMACHeader(pDevice
, pbyMacHdr
, (u16
)uDuration
, psEthHeader
, bNeedEncryption
,
1236 byFragType
, uDMAIdx
, 0);
1238 if (bNeedEncryption
== true) {
1240 s_vFillTxKey(pDevice
, (u8
*)(pTxBufHead
->adwTxKey
), pbyIVHead
, pTransmitKey
,
1241 pbyMacHdr
, (u16
)cbFrameBodySize
, pMICHDR
);
1243 if (pDevice
->bEnableHostWEP
) {
1244 pMgmt
->sNodeDBTable
[uNodeIndex
].dwTSC47_16
= pTransmitKey
->dwTSC47_16
;
1245 pMgmt
->sNodeDBTable
[uNodeIndex
].wTSC15_0
= pTransmitKey
->wTSC15_0
;
1250 if (ntohs(psEthHeader
->h_proto
) > ETH_DATA_LEN
) {
1251 if (pDevice
->dwDiagRefCount
== 0) {
1252 if ((psEthHeader
->h_proto
== cpu_to_be16(ETH_P_IPX
)) ||
1253 (psEthHeader
->h_proto
== cpu_to_le16(0xF380))) {
1254 memcpy((u8
*) (pbyPayloadHead
),
1255 abySNAP_Bridgetunnel
, 6);
1257 memcpy((u8
*) (pbyPayloadHead
), &abySNAP_RFC1042
[0], 6);
1259 pbyType
= (u8
*) (pbyPayloadHead
+ 6);
1260 memcpy(pbyType
, &(psEthHeader
->h_proto
), sizeof(u16
));
1262 memcpy((u8
*) (pbyPayloadHead
), &(psEthHeader
->h_proto
), sizeof(u16
));
1268 if (pPacket
!= NULL
) {
1269 // Copy the Packet into a tx Buffer
1270 memcpy((pbyPayloadHead
+ cb802_1_H_len
),
1271 (pPacket
+ ETH_HLEN
),
1272 uSkbPacketLen
- ETH_HLEN
1276 // while bRelayPacketSend psEthHeader is point to header+payload
1277 memcpy((pbyPayloadHead
+ cb802_1_H_len
), ((u8
*)psEthHeader
) + ETH_HLEN
, uSkbPacketLen
- ETH_HLEN
);
1280 if ((bNeedEncryption
== true) && (pTransmitKey
!= NULL
) && (pTransmitKey
->byCipherSuite
== KEY_CTL_TKIP
)) {
1282 ///////////////////////////////////////////////////////////////////
1284 if (pDevice
->vnt_mgmt
.eAuthenMode
== WMAC_AUTH_WPANONE
) {
1285 dwMICKey0
= *(u32
*)(&pTransmitKey
->abyKey
[16]);
1286 dwMICKey1
= *(u32
*)(&pTransmitKey
->abyKey
[20]);
1288 else if ((pTransmitKey
->dwKeyIndex
& AUTHENTICATOR_KEY
) != 0) {
1289 dwMICKey0
= *(u32
*)(&pTransmitKey
->abyKey
[16]);
1290 dwMICKey1
= *(u32
*)(&pTransmitKey
->abyKey
[20]);
1293 dwMICKey0
= *(u32
*)(&pTransmitKey
->abyKey
[24]);
1294 dwMICKey1
= *(u32
*)(&pTransmitKey
->abyKey
[28]);
1296 // DO Software Michael
1297 MIC_vInit(dwMICKey0
, dwMICKey1
);
1298 MIC_vAppend((u8
*)&(psEthHeader
->h_dest
[0]), 12);
1300 MIC_vAppend((u8
*)&dwMIC_Priority
, 4);
1301 DBG_PRT(MSG_LEVEL_DEBUG
, KERN_INFO
"MIC KEY: %X, %X\n",
1302 dwMICKey0
, dwMICKey1
);
1304 ///////////////////////////////////////////////////////////////////
1306 //DBG_PRN_GRP12(("Length:%d, %d\n", cbFrameBodySize, uFromHDtoPLDLength));
1307 //for (ii = 0; ii < cbFrameBodySize; ii++) {
1308 // DBG_PRN_GRP12(("%02x ", *((u8 *)((pbyPayloadHead + cb802_1_H_len) + ii))));
1310 //DBG_PRN_GRP12(("\n\n\n"));
1312 MIC_vAppend(pbyPayloadHead
, cbFrameBodySize
);
1314 pdwMIC_L
= (u32
*)(pbyPayloadHead
+ cbFrameBodySize
);
1315 pdwMIC_R
= (u32
*)(pbyPayloadHead
+ cbFrameBodySize
+ 4);
1317 MIC_vGetMIC(pdwMIC_L
, pdwMIC_R
);
1320 if (pDevice
->bTxMICFail
== true) {
1323 pDevice
->bTxMICFail
= false;
1325 //DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"uLength: %d, %d\n", uLength, cbFrameBodySize);
1326 //DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"cbReqCount:%d, %d, %d, %d\n", cbReqCount, cbHeaderLength, uPadding, cbIVlen);
1327 //DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"MIC:%lX, %lX\n", *pdwMIC_L, *pdwMIC_R);
1330 if (bSoftWEP
== true) {
1332 s_vSWencryption(pDevice
, pTransmitKey
, (pbyPayloadHead
), (u16
)(cbFrameBodySize
+ cbMIClen
));
1334 } else if ( ((pDevice
->eEncryptionStatus
== Ndis802_11Encryption1Enabled
) && (bNeedEncryption
== true)) ||
1335 ((pDevice
->eEncryptionStatus
== Ndis802_11Encryption2Enabled
) && (bNeedEncryption
== true)) ||
1336 ((pDevice
->eEncryptionStatus
== Ndis802_11Encryption3Enabled
) && (bNeedEncryption
== true)) ) {
1337 cbFrameSize
-= cbICVlen
;
1340 cbFrameSize
-= cbFCSlen
;
1342 *pcbHeaderLen
= cbHeaderLength
;
1343 *pcbTotalLen
= cbHeaderLength
+ cbFrameSize
;
1345 //Set FragCtl in TxBufferHead
1346 pTxBufHead
->wFragCtl
|= (u16
)byFragType
;
1355 * Translate 802.3 to 802.11 header
1359 * pDevice - Pointer to adapter
1360 * dwTxBufferAddr - Transmit Buffer
1361 * pPacket - Packet from upper layer
1362 * cbPacketSize - Transmit Data Length
1364 * pcbHeadSize - Header size of MAC&Baseband control and 802.11 Header
1365 * pcbAppendPayload - size of append payload for 802.1H translation
1367 * Return Value: none
1371 static void s_vGenerateMACHeader(struct vnt_private
*pDevice
,
1372 u8
*pbyBufferAddr
, u16 wDuration
, struct ethhdr
*psEthHeader
,
1373 int bNeedEncrypt
, u16 wFragType
, u32 uDMAIdx
, u32 uFragIdx
)
1375 struct ieee80211_hdr
*pMACHeader
= (struct ieee80211_hdr
*)pbyBufferAddr
;
1377 pMACHeader
->frame_control
= TYPE_802_11_DATA
;
1379 if (pDevice
->eOPMode
== OP_MODE_AP
) {
1380 memcpy(&(pMACHeader
->addr1
[0]),
1381 &(psEthHeader
->h_dest
[0]),
1383 memcpy(&(pMACHeader
->addr2
[0]), &(pDevice
->abyBSSID
[0]), ETH_ALEN
);
1384 memcpy(&(pMACHeader
->addr3
[0]),
1385 &(psEthHeader
->h_source
[0]),
1387 pMACHeader
->frame_control
|= FC_FROMDS
;
1389 if (pDevice
->eOPMode
== OP_MODE_ADHOC
) {
1390 memcpy(&(pMACHeader
->addr1
[0]),
1391 &(psEthHeader
->h_dest
[0]),
1393 memcpy(&(pMACHeader
->addr2
[0]),
1394 &(psEthHeader
->h_source
[0]),
1396 memcpy(&(pMACHeader
->addr3
[0]),
1397 &(pDevice
->abyBSSID
[0]),
1400 memcpy(&(pMACHeader
->addr3
[0]),
1401 &(psEthHeader
->h_dest
[0]),
1403 memcpy(&(pMACHeader
->addr2
[0]),
1404 &(psEthHeader
->h_source
[0]),
1406 memcpy(&(pMACHeader
->addr1
[0]),
1407 &(pDevice
->abyBSSID
[0]),
1409 pMACHeader
->frame_control
|= FC_TODS
;
1414 pMACHeader
->frame_control
|= cpu_to_le16((u16
)WLAN_SET_FC_ISWEP(1));
1416 pMACHeader
->duration_id
= cpu_to_le16(wDuration
);
1418 if (pDevice
->bLongHeader
) {
1419 PWLAN_80211HDR_A4 pMACA4Header
= (PWLAN_80211HDR_A4
) pbyBufferAddr
;
1420 pMACHeader
->frame_control
|= (FC_TODS
| FC_FROMDS
);
1421 memcpy(pMACA4Header
->abyAddr4
, pDevice
->abyBSSID
, WLAN_ADDR_LEN
);
1423 pMACHeader
->seq_ctrl
= cpu_to_le16(pDevice
->wSeqCounter
<< 4);
1425 //Set FragNumber in Sequence Control
1426 pMACHeader
->seq_ctrl
|= cpu_to_le16((u16
)uFragIdx
);
1428 if ((wFragType
== FRAGCTL_ENDFRAG
) || (wFragType
== FRAGCTL_NONFRAG
)) {
1429 pDevice
->wSeqCounter
++;
1430 if (pDevice
->wSeqCounter
> 0x0fff)
1431 pDevice
->wSeqCounter
= 0;
1434 if ((wFragType
== FRAGCTL_STAFRAG
) || (wFragType
== FRAGCTL_MIDFRAG
)) { //StartFrag or MidFrag
1435 pMACHeader
->frame_control
|= FC_MOREFRAG
;
1442 * Request instructs a MAC to transmit a 802.11 management packet through
1443 * the adapter onto the medium.
1447 * hDeviceContext - Pointer to the adapter
1448 * pPacket - A pointer to a descriptor for the packet to transmit
1452 * Return Value: CMD_STATUS_PENDING if MAC Tx resource available; otherwise false
1456 CMD_STATUS
csMgmt_xmit(struct vnt_private
*pDevice
,
1457 struct vnt_tx_mgmt
*pPacket
)
1459 struct vnt_manager
*pMgmt
= &pDevice
->vnt_mgmt
;
1460 struct vnt_tx_buffer
*pTX_Buffer
;
1461 struct vnt_usb_send_context
*pContext
;
1462 struct vnt_tx_fifo_head
*pTxBufHead
;
1463 struct ieee80211_hdr
*pMACHeader
;
1464 struct ethhdr sEthHeader
;
1465 u8 byPktType
, *pbyTxBufferAddr
;
1466 void *rts_cts
= NULL
;
1468 struct vnt_mic_hdr
*pMICHDR
= NULL
;
1469 u32 uDuration
, cbReqCount
, cbHeaderSize
, cbFrameBodySize
, cbFrameSize
;
1470 int bNeedACK
, bIsPSPOLL
= false;
1471 u32 cbIVlen
= 0, cbICVlen
= 0, cbMIClen
= 0, cbFCSlen
= 4;
1475 u16 wCurrentRate
= RATE_1M
;
1477 pContext
= (struct vnt_usb_send_context
*)s_vGetFreeContext(pDevice
);
1479 if (NULL
== pContext
) {
1480 DBG_PRT(MSG_LEVEL_DEBUG
, KERN_INFO
"ManagementSend TX...NO CONTEXT!\n");
1481 return CMD_STATUS_RESOURCES
;
1484 pTX_Buffer
= (struct vnt_tx_buffer
*)&pContext
->Data
[0];
1485 cbFrameBodySize
= pPacket
->cbPayloadLen
;
1486 pTxBufHead
= &pTX_Buffer
->fifo_head
;
1487 pbyTxBufferAddr
= (u8
*)&pTxBufHead
->adwTxKey
[0];
1488 wTxBufSize
= sizeof(struct vnt_tx_fifo_head
);
1490 if (pDevice
->byBBType
== BB_TYPE_11A
) {
1491 wCurrentRate
= RATE_6M
;
1492 byPktType
= PK_TYPE_11A
;
1494 wCurrentRate
= RATE_1M
;
1495 byPktType
= PK_TYPE_11B
;
1498 // SetPower will cause error power TX state for OFDM Date packet in TX buffer.
1499 // 2004.11.11 Kyle -- Using OFDM power to tx MngPkt will decrease the connection capability.
1500 // And cmd timer will wait data pkt TX finish before scanning so it's OK
1501 // to set power here.
1502 if (pMgmt
->eScanState
!= WMAC_NO_SCANNING
) {
1503 RFbSetPower(pDevice
, wCurrentRate
, pDevice
->byCurrentCh
);
1505 RFbSetPower(pDevice
, wCurrentRate
, pMgmt
->uCurrChannel
);
1507 pDevice
->wCurrentRate
= wCurrentRate
;
1510 if (byPktType
== PK_TYPE_11A
) {//0000 0000 0000 0000
1511 pTxBufHead
->wFIFOCtl
= 0;
1513 else if (byPktType
== PK_TYPE_11B
) {//0000 0001 0000 0000
1514 pTxBufHead
->wFIFOCtl
|= FIFOCTL_11B
;
1516 else if (byPktType
== PK_TYPE_11GB
) {//0000 0010 0000 0000
1517 pTxBufHead
->wFIFOCtl
|= FIFOCTL_11GB
;
1519 else if (byPktType
== PK_TYPE_11GA
) {//0000 0011 0000 0000
1520 pTxBufHead
->wFIFOCtl
|= FIFOCTL_11GA
;
1523 pTxBufHead
->wFIFOCtl
|= FIFOCTL_TMOEN
;
1524 pTxBufHead
->wTimeStamp
= cpu_to_le16(DEFAULT_MGN_LIFETIME_RES_64us
);
1526 if (is_multicast_ether_addr(pPacket
->p80211Header
->sA3
.abyAddr1
)) {
1531 pTxBufHead
->wFIFOCtl
|= FIFOCTL_NEEDACK
;
1534 if ((pMgmt
->eCurrMode
== WMAC_MODE_ESS_AP
) ||
1535 (pMgmt
->eCurrMode
== WMAC_MODE_IBSS_STA
) ) {
1537 pTxBufHead
->wFIFOCtl
|= FIFOCTL_LRETRY
;
1538 //Set Preamble type always long
1539 //pDevice->byPreambleType = PREAMBLE_LONG;
1540 // probe-response don't retry
1541 //if ((pPacket->p80211Header->sA4.wFrameCtl & TYPE_SUBTYPE_MASK) == TYPE_MGMT_PROBE_RSP) {
1542 // bNeedACK = false;
1543 // pTxBufHead->wFIFOCtl &= (~FIFOCTL_NEEDACK);
1547 pTxBufHead
->wFIFOCtl
|= (FIFOCTL_GENINT
| FIFOCTL_ISDMA0
);
1549 if ((pPacket
->p80211Header
->sA4
.wFrameCtl
& TYPE_SUBTYPE_MASK
) == TYPE_CTL_PSPOLL
) {
1551 cbMacHdLen
= WLAN_HDR_ADDR2_LEN
;
1553 cbMacHdLen
= WLAN_HDR_ADDR3_LEN
;
1556 //Set FRAGCTL_MACHDCNT
1557 pTxBufHead
->wFragCtl
|= cpu_to_le16((u16
)(cbMacHdLen
<< 10));
1560 // Although spec says MMPDU can be fragmented; In most case,
1561 // no one will send a MMPDU under fragmentation. With RTS may occur.
1562 pDevice
->bAES
= false; //Set FRAGCTL_WEPTYP
1564 if (WLAN_GET_FC_ISWEP(pPacket
->p80211Header
->sA4
.wFrameCtl
) != 0) {
1565 if (pDevice
->eEncryptionStatus
== Ndis802_11Encryption1Enabled
) {
1568 pTxBufHead
->wFragCtl
|= FRAGCTL_LEGACY
;
1570 else if (pDevice
->eEncryptionStatus
== Ndis802_11Encryption2Enabled
) {
1571 cbIVlen
= 8;//IV+ExtIV
1574 pTxBufHead
->wFragCtl
|= FRAGCTL_TKIP
;
1575 //We need to get seed here for filling TxKey entry.
1576 //TKIPvMixKey(pTransmitKey->abyKey, pDevice->abyCurrentNetAddr,
1577 // pTransmitKey->wTSC15_0, pTransmitKey->dwTSC47_16, pDevice->abyPRNG);
1579 else if (pDevice
->eEncryptionStatus
== Ndis802_11Encryption3Enabled
) {
1580 cbIVlen
= 8;//RSN Header
1582 pTxBufHead
->wFragCtl
|= FRAGCTL_AES
;
1583 pDevice
->bAES
= true;
1585 //MAC Header should be padding 0 to DW alignment.
1586 uPadding
= 4 - (cbMacHdLen
%4);
1590 cbFrameSize
= cbMacHdLen
+ cbFrameBodySize
+ cbIVlen
+ cbMIClen
+ cbICVlen
+ cbFCSlen
;
1592 //Set FIFOCTL_GrpAckPolicy
1593 if (pDevice
->bGrpAckPolicy
== true) {//0000 0100 0000 0000
1594 pTxBufHead
->wFIFOCtl
|= FIFOCTL_GRPACK
;
1596 //the rest of pTxBufHead->wFragCtl:FragTyp will be set later in s_vFillFragParameter()
1598 //Set RrvTime/RTS/CTS Buffer
1599 if (byPktType
== PK_TYPE_11GB
|| byPktType
== PK_TYPE_11GA
) {//802.11g packet
1600 rts_cts
= (struct vnt_cts
*) (pbyTxBufferAddr
+ wTxBufSize
+
1601 sizeof(struct vnt_rrv_time_cts
));
1602 pvTxDataHd
= (struct vnt_tx_datahead_g
*)(pbyTxBufferAddr
+ wTxBufSize
+
1603 sizeof(struct vnt_rrv_time_cts
) + sizeof(struct vnt_cts
));
1604 cbHeaderSize
= wTxBufSize
+ sizeof(struct vnt_rrv_time_cts
) +
1605 sizeof(struct vnt_cts
) + sizeof(struct vnt_tx_datahead_g
);
1607 else { // 802.11a/b packet
1608 pvTxDataHd
= (struct vnt_tx_datahead_ab
*) (pbyTxBufferAddr
+
1609 wTxBufSize
+ sizeof(struct vnt_rrv_time_ab
));
1610 cbHeaderSize
= wTxBufSize
+ sizeof(struct vnt_rrv_time_ab
) +
1611 sizeof(struct vnt_tx_datahead_ab
);
1614 memcpy(&(sEthHeader
.h_dest
[0]),
1615 &(pPacket
->p80211Header
->sA3
.abyAddr1
[0]),
1617 memcpy(&(sEthHeader
.h_source
[0]),
1618 &(pPacket
->p80211Header
->sA3
.abyAddr2
[0]),
1620 //=========================
1622 //=========================
1623 pTxBufHead
->wFragCtl
|= (u16
)FRAGCTL_NONFRAG
;
1625 /* Fill FIFO,RrvTime,RTS,and CTS */
1626 s_vGenerateTxParameter(pDevice
, byPktType
, wCurrentRate
,
1627 pTX_Buffer
, &pMICHDR
, 0, rts_cts
,
1628 cbFrameSize
, bNeedACK
, TYPE_TXDMA0
, &sEthHeader
, false);
1631 uDuration
= s_uFillDataHead(pDevice
, byPktType
, wCurrentRate
, pvTxDataHd
, cbFrameSize
, TYPE_TXDMA0
, bNeedACK
,
1634 pMACHeader
= (struct ieee80211_hdr
*) (pbyTxBufferAddr
+ cbHeaderSize
);
1636 cbReqCount
= cbHeaderSize
+ cbMacHdLen
+ uPadding
+ cbIVlen
+ cbFrameBodySize
;
1638 if (WLAN_GET_FC_ISWEP(pPacket
->p80211Header
->sA4
.wFrameCtl
) != 0) {
1640 u8
* pbyPayloadHead
;
1642 PSKeyItem pTransmitKey
= NULL
;
1644 pbyIVHead
= (u8
*)(pbyTxBufferAddr
+ cbHeaderSize
+ cbMacHdLen
+ uPadding
);
1645 pbyPayloadHead
= (u8
*)(pbyTxBufferAddr
+ cbHeaderSize
+ cbMacHdLen
+ uPadding
+ cbIVlen
);
1647 if ((pDevice
->eOPMode
== OP_MODE_INFRASTRUCTURE
) &&
1648 (pDevice
->bLinkPass
== true)) {
1649 pbyBSSID
= pDevice
->abyBSSID
;
1651 if (KeybGetTransmitKey(&(pDevice
->sKey
), pbyBSSID
, PAIRWISE_KEY
, &pTransmitKey
) == false) {
1653 if(KeybGetTransmitKey(&(pDevice
->sKey
), pbyBSSID
, GROUP_KEY
, &pTransmitKey
) == true) {
1654 DBG_PRT(MSG_LEVEL_DEBUG
, KERN_INFO
"Get GTK.\n");
1658 DBG_PRT(MSG_LEVEL_DEBUG
, KERN_INFO
"Get PTK.\n");
1663 pbyBSSID
= pDevice
->abyBroadcastAddr
;
1664 if(KeybGetTransmitKey(&(pDevice
->sKey
), pbyBSSID
, GROUP_KEY
, &pTransmitKey
) == false) {
1665 pTransmitKey
= NULL
;
1666 DBG_PRT(MSG_LEVEL_DEBUG
, KERN_INFO
"KEY is NULL. OP Mode[%d]\n", pDevice
->eOPMode
);
1668 DBG_PRT(MSG_LEVEL_DEBUG
, KERN_INFO
"Get GTK.\n");
1672 s_vFillTxKey(pDevice
, (u8
*)(pTxBufHead
->adwTxKey
), pbyIVHead
, pTransmitKey
,
1673 (u8
*)pMACHeader
, (u16
)cbFrameBodySize
, NULL
);
1675 memcpy(pMACHeader
, pPacket
->p80211Header
, cbMacHdLen
);
1676 memcpy(pbyPayloadHead
, ((u8
*)(pPacket
->p80211Header
) + cbMacHdLen
),
1680 // Copy the Packet into a tx Buffer
1681 memcpy(pMACHeader
, pPacket
->p80211Header
, pPacket
->cbMPDULen
);
1684 pMACHeader
->seq_ctrl
= cpu_to_le16(pDevice
->wSeqCounter
<< 4);
1685 pDevice
->wSeqCounter
++ ;
1686 if (pDevice
->wSeqCounter
> 0x0fff)
1687 pDevice
->wSeqCounter
= 0;
1690 // The MAC will automatically replace the Duration-field of MAC header by Duration-field
1691 // of FIFO control header.
1692 // This will cause AID-field of PS-POLL packet be incorrect (Because PS-POLL's AID field is
1693 // in the same place of other packet's Duration-field).
1694 // And it will cause Cisco-AP to issue Disassociation-packet
1695 if (byPktType
== PK_TYPE_11GB
|| byPktType
== PK_TYPE_11GA
) {
1696 ((struct vnt_tx_datahead_g
*)pvTxDataHd
)->wDuration_a
=
1697 cpu_to_le16(pPacket
->p80211Header
->sA2
.wDurationID
);
1698 ((struct vnt_tx_datahead_g
*)pvTxDataHd
)->wDuration_b
=
1699 cpu_to_le16(pPacket
->p80211Header
->sA2
.wDurationID
);
1701 ((struct vnt_tx_datahead_ab
*)pvTxDataHd
)->wDuration
=
1702 cpu_to_le16(pPacket
->p80211Header
->sA2
.wDurationID
);
1706 pTX_Buffer
->wTxByteCount
= cpu_to_le16((u16
)(cbReqCount
));
1707 pTX_Buffer
->byPKTNO
= (u8
) (((wCurrentRate
<<4) &0x00F0) | ((pDevice
->wSeqCounter
- 1) & 0x000F));
1708 pTX_Buffer
->byType
= 0x00;
1710 pContext
->pPacket
= NULL
;
1711 pContext
->Type
= CONTEXT_MGMT_PACKET
;
1712 pContext
->uBufLen
= (u16
)cbReqCount
+ 4; //USB header
1714 if (WLAN_GET_FC_TODS(pMACHeader
->frame_control
) == 0) {
1715 s_vSaveTxPktInfo(pDevice
, (u8
)(pTX_Buffer
->byPKTNO
& 0x0F),
1716 &pMACHeader
->addr1
[0], (u16
)cbFrameSize
,
1717 pTxBufHead
->wFIFOCtl
);
1720 s_vSaveTxPktInfo(pDevice
, (u8
)(pTX_Buffer
->byPKTNO
& 0x0F),
1721 &pMACHeader
->addr3
[0], (u16
)cbFrameSize
,
1722 pTxBufHead
->wFIFOCtl
);
1725 PIPEnsSendBulkOut(pDevice
,pContext
);
1726 return CMD_STATUS_PENDING
;
1729 CMD_STATUS
csBeacon_xmit(struct vnt_private
*pDevice
,
1730 struct vnt_tx_mgmt
*pPacket
)
1732 struct vnt_beacon_buffer
*pTX_Buffer
;
1733 u32 cbFrameSize
= pPacket
->cbMPDULen
+ WLAN_FCS_LEN
;
1734 u32 cbHeaderSize
= 0;
1735 u16 wTxBufSize
= sizeof(STxShortBufHead
);
1736 PSTxShortBufHead pTxBufHead
;
1737 struct ieee80211_hdr
*pMACHeader
;
1738 struct vnt_tx_datahead_ab
*pTxDataHead
;
1740 u32 cbFrameBodySize
;
1742 u8
*pbyTxBufferAddr
;
1743 struct vnt_usb_send_context
*pContext
;
1746 pContext
= (struct vnt_usb_send_context
*)s_vGetFreeContext(pDevice
);
1747 if (NULL
== pContext
) {
1748 status
= CMD_STATUS_RESOURCES
;
1749 DBG_PRT(MSG_LEVEL_DEBUG
, KERN_INFO
"ManagementSend TX...NO CONTEXT!\n");
1753 pTX_Buffer
= (struct vnt_beacon_buffer
*)&pContext
->Data
[0];
1754 pbyTxBufferAddr
= (u8
*)&(pTX_Buffer
->wFIFOCtl
);
1756 cbFrameBodySize
= pPacket
->cbPayloadLen
;
1758 pTxBufHead
= (PSTxShortBufHead
) pbyTxBufferAddr
;
1759 wTxBufSize
= sizeof(STxShortBufHead
);
1761 if (pDevice
->byBBType
== BB_TYPE_11A
) {
1762 wCurrentRate
= RATE_6M
;
1763 pTxDataHead
= (struct vnt_tx_datahead_ab
*)
1764 (pbyTxBufferAddr
+ wTxBufSize
);
1765 //Get SignalField,ServiceField,Length
1766 BBvCalculateParameter(pDevice
, cbFrameSize
, wCurrentRate
, PK_TYPE_11A
,
1768 //Get Duration and TimeStampOff
1769 pTxDataHead
->wDuration
= s_uGetDataDuration(pDevice
,
1770 PK_TYPE_11A
, false);
1771 pTxDataHead
->wTimeStampOff
= vnt_time_stamp_off(pDevice
, wCurrentRate
);
1772 cbHeaderSize
= wTxBufSize
+ sizeof(struct vnt_tx_datahead_ab
);
1774 wCurrentRate
= RATE_1M
;
1775 pTxBufHead
->wFIFOCtl
|= FIFOCTL_11B
;
1776 pTxDataHead
= (struct vnt_tx_datahead_ab
*)
1777 (pbyTxBufferAddr
+ wTxBufSize
);
1778 //Get SignalField,ServiceField,Length
1779 BBvCalculateParameter(pDevice
, cbFrameSize
, wCurrentRate
, PK_TYPE_11B
,
1781 //Get Duration and TimeStampOff
1782 pTxDataHead
->wDuration
= s_uGetDataDuration(pDevice
,
1783 PK_TYPE_11B
, false);
1784 pTxDataHead
->wTimeStampOff
= vnt_time_stamp_off(pDevice
, wCurrentRate
);
1785 cbHeaderSize
= wTxBufSize
+ sizeof(struct vnt_tx_datahead_ab
);
1788 //Generate Beacon Header
1789 pMACHeader
= (struct ieee80211_hdr
*)(pbyTxBufferAddr
+ cbHeaderSize
);
1790 memcpy(pMACHeader
, pPacket
->p80211Header
, pPacket
->cbMPDULen
);
1792 pMACHeader
->duration_id
= 0;
1793 pMACHeader
->seq_ctrl
= cpu_to_le16(pDevice
->wSeqCounter
<< 4);
1794 pDevice
->wSeqCounter
++ ;
1795 if (pDevice
->wSeqCounter
> 0x0fff)
1796 pDevice
->wSeqCounter
= 0;
1798 cbReqCount
= cbHeaderSize
+ WLAN_HDR_ADDR3_LEN
+ cbFrameBodySize
;
1800 pTX_Buffer
->wTxByteCount
= (u16
)cbReqCount
;
1801 pTX_Buffer
->byPKTNO
= (u8
) (((wCurrentRate
<<4) &0x00F0) | ((pDevice
->wSeqCounter
- 1) & 0x000F));
1802 pTX_Buffer
->byType
= 0x01;
1804 pContext
->pPacket
= NULL
;
1805 pContext
->Type
= CONTEXT_MGMT_PACKET
;
1806 pContext
->uBufLen
= (u16
)cbReqCount
+ 4; //USB header
1808 PIPEnsSendBulkOut(pDevice
,pContext
);
1809 return CMD_STATUS_PENDING
;
1813 void vDMA0_tx_80211(struct vnt_private
*pDevice
, struct sk_buff
*skb
)
1815 struct vnt_manager
*pMgmt
= &pDevice
->vnt_mgmt
;
1816 struct vnt_tx_buffer
*pTX_Buffer
;
1817 struct vnt_tx_fifo_head
*pTxBufHead
;
1819 u8
*pbyTxBufferAddr
;
1820 void *rts_cts
= NULL
;
1822 u32 uDuration
, cbReqCount
;
1823 struct ieee80211_hdr
*pMACHeader
;
1824 u32 cbHeaderSize
, cbFrameBodySize
;
1825 int bNeedACK
, bIsPSPOLL
= false;
1827 u32 cbIVlen
= 0, cbICVlen
= 0, cbMIClen
= 0, cbFCSlen
= 4;
1829 u32 cbMICHDR
= 0, uLength
= 0;
1830 u32 dwMICKey0
, dwMICKey1
;
1832 u32
*pdwMIC_L
, *pdwMIC_R
;
1835 struct ethhdr sEthHeader
;
1836 struct vnt_mic_hdr
*pMICHDR
;
1837 u32 wCurrentRate
= RATE_1M
;
1838 PUWLAN_80211HDR p80211Header
;
1840 int bNodeExist
= false;
1842 PSKeyItem pTransmitKey
= NULL
;
1843 u8
*pbyIVHead
, *pbyPayloadHead
, *pbyMacHdr
;
1844 u32 cbExtSuppRate
= 0;
1845 struct vnt_usb_send_context
*pContext
;
1847 pMICHDR
= pvTxDataHd
= NULL
;
1849 if(skb
->len
<= WLAN_HDR_ADDR3_LEN
) {
1850 cbFrameBodySize
= 0;
1853 cbFrameBodySize
= skb
->len
- WLAN_HDR_ADDR3_LEN
;
1855 p80211Header
= (PUWLAN_80211HDR
)skb
->data
;
1857 pContext
= (struct vnt_usb_send_context
*)s_vGetFreeContext(pDevice
);
1859 if (NULL
== pContext
) {
1860 DBG_PRT(MSG_LEVEL_DEBUG
, KERN_INFO
"DMA0 TX...NO CONTEXT!\n");
1861 dev_kfree_skb_irq(skb
);
1865 pTX_Buffer
= (struct vnt_tx_buffer
*)&pContext
->Data
[0];
1866 pTxBufHead
= &pTX_Buffer
->fifo_head
;
1867 pbyTxBufferAddr
= (u8
*)&pTxBufHead
->adwTxKey
[0];
1868 wTxBufSize
= sizeof(struct vnt_tx_fifo_head
);
1870 if (pDevice
->byBBType
== BB_TYPE_11A
) {
1871 wCurrentRate
= RATE_6M
;
1872 byPktType
= PK_TYPE_11A
;
1874 wCurrentRate
= RATE_1M
;
1875 byPktType
= PK_TYPE_11B
;
1878 // SetPower will cause error power TX state for OFDM Date packet in TX buffer.
1879 // 2004.11.11 Kyle -- Using OFDM power to tx MngPkt will decrease the connection capability.
1880 // And cmd timer will wait data pkt TX finish before scanning so it's OK
1881 // to set power here.
1882 if (pMgmt
->eScanState
!= WMAC_NO_SCANNING
) {
1883 RFbSetPower(pDevice
, wCurrentRate
, pDevice
->byCurrentCh
);
1885 RFbSetPower(pDevice
, wCurrentRate
, pMgmt
->uCurrChannel
);
1888 DBG_PRT(MSG_LEVEL_DEBUG
, KERN_INFO
"vDMA0_tx_80211: p80211Header->sA3.wFrameCtl = %x \n", p80211Header
->sA3
.wFrameCtl
);
1891 if (byPktType
== PK_TYPE_11A
) {//0000 0000 0000 0000
1892 pTxBufHead
->wFIFOCtl
= 0;
1894 else if (byPktType
== PK_TYPE_11B
) {//0000 0001 0000 0000
1895 pTxBufHead
->wFIFOCtl
|= FIFOCTL_11B
;
1897 else if (byPktType
== PK_TYPE_11GB
) {//0000 0010 0000 0000
1898 pTxBufHead
->wFIFOCtl
|= FIFOCTL_11GB
;
1900 else if (byPktType
== PK_TYPE_11GA
) {//0000 0011 0000 0000
1901 pTxBufHead
->wFIFOCtl
|= FIFOCTL_11GA
;
1904 pTxBufHead
->wFIFOCtl
|= FIFOCTL_TMOEN
;
1905 pTxBufHead
->wTimeStamp
= cpu_to_le16(DEFAULT_MGN_LIFETIME_RES_64us
);
1907 if (is_multicast_ether_addr(p80211Header
->sA3
.abyAddr1
)) {
1909 if (pDevice
->bEnableHostWEP
) {
1915 if (pDevice
->bEnableHostWEP
) {
1916 if (BSSbIsSTAInNodeDB(pDevice
, (u8
*)(p80211Header
->sA3
.abyAddr1
), &uNodeIndex
))
1920 pTxBufHead
->wFIFOCtl
|= FIFOCTL_NEEDACK
;
1923 if ((pMgmt
->eCurrMode
== WMAC_MODE_ESS_AP
) ||
1924 (pMgmt
->eCurrMode
== WMAC_MODE_IBSS_STA
) ) {
1926 pTxBufHead
->wFIFOCtl
|= FIFOCTL_LRETRY
;
1927 //Set Preamble type always long
1928 //pDevice->byPreambleType = PREAMBLE_LONG;
1930 // probe-response don't retry
1931 //if ((p80211Header->sA4.wFrameCtl & TYPE_SUBTYPE_MASK) == TYPE_MGMT_PROBE_RSP) {
1932 // bNeedACK = false;
1933 // pTxBufHead->wFIFOCtl &= (~FIFOCTL_NEEDACK);
1937 pTxBufHead
->wFIFOCtl
|= (FIFOCTL_GENINT
| FIFOCTL_ISDMA0
);
1939 if ((p80211Header
->sA4
.wFrameCtl
& TYPE_SUBTYPE_MASK
) == TYPE_CTL_PSPOLL
) {
1941 cbMacHdLen
= WLAN_HDR_ADDR2_LEN
;
1943 cbMacHdLen
= WLAN_HDR_ADDR3_LEN
;
1946 // hostapd daemon ext support rate patch
1947 if (WLAN_GET_FC_FSTYPE(p80211Header
->sA4
.wFrameCtl
) == WLAN_FSTYPE_ASSOCRESP
) {
1949 if (((PWLAN_IE_SUPP_RATES
)pMgmt
->abyCurrSuppRates
)->len
!= 0) {
1950 cbExtSuppRate
+= ((PWLAN_IE_SUPP_RATES
)pMgmt
->abyCurrSuppRates
)->len
+ WLAN_IEHDR_LEN
;
1953 if (((PWLAN_IE_SUPP_RATES
)pMgmt
->abyCurrExtSuppRates
)->len
!= 0) {
1954 cbExtSuppRate
+= ((PWLAN_IE_SUPP_RATES
)pMgmt
->abyCurrExtSuppRates
)->len
+ WLAN_IEHDR_LEN
;
1957 if (cbExtSuppRate
>0) {
1958 cbFrameBodySize
= WLAN_ASSOCRESP_OFF_SUPP_RATES
;
1962 //Set FRAGCTL_MACHDCNT
1963 pTxBufHead
->wFragCtl
|= cpu_to_le16((u16
)cbMacHdLen
<< 10);
1966 // Although spec says MMPDU can be fragmented; In most case,
1967 // no one will send a MMPDU under fragmentation. With RTS may occur.
1968 pDevice
->bAES
= false; //Set FRAGCTL_WEPTYP
1970 if (WLAN_GET_FC_ISWEP(p80211Header
->sA4
.wFrameCtl
) != 0) {
1971 if (pDevice
->eEncryptionStatus
== Ndis802_11Encryption1Enabled
) {
1974 pTxBufHead
->wFragCtl
|= FRAGCTL_LEGACY
;
1976 else if (pDevice
->eEncryptionStatus
== Ndis802_11Encryption2Enabled
) {
1977 cbIVlen
= 8;//IV+ExtIV
1980 pTxBufHead
->wFragCtl
|= FRAGCTL_TKIP
;
1981 //We need to get seed here for filling TxKey entry.
1982 //TKIPvMixKey(pTransmitKey->abyKey, pDevice->abyCurrentNetAddr,
1983 // pTransmitKey->wTSC15_0, pTransmitKey->dwTSC47_16, pDevice->abyPRNG);
1985 else if (pDevice
->eEncryptionStatus
== Ndis802_11Encryption3Enabled
) {
1986 cbIVlen
= 8;//RSN Header
1988 cbMICHDR
= sizeof(struct vnt_mic_hdr
);
1989 pTxBufHead
->wFragCtl
|= FRAGCTL_AES
;
1990 pDevice
->bAES
= true;
1992 //MAC Header should be padding 0 to DW alignment.
1993 uPadding
= 4 - (cbMacHdLen
%4);
1997 cbFrameSize
= cbMacHdLen
+ cbFrameBodySize
+ cbIVlen
+ cbMIClen
+ cbICVlen
+ cbFCSlen
+ cbExtSuppRate
;
1999 //Set FIFOCTL_GrpAckPolicy
2000 if (pDevice
->bGrpAckPolicy
== true) {//0000 0100 0000 0000
2001 pTxBufHead
->wFIFOCtl
|= FIFOCTL_GRPACK
;
2003 //the rest of pTxBufHead->wFragCtl:FragTyp will be set later in s_vFillFragParameter()
2005 if (byPktType
== PK_TYPE_11GB
|| byPktType
== PK_TYPE_11GA
) {//802.11g packet
2006 rts_cts
= (struct vnt_cts
*) (pbyTxBufferAddr
+ wTxBufSize
+
2007 sizeof(struct vnt_rrv_time_cts
) + cbMICHDR
);
2008 pvTxDataHd
= (struct vnt_tx_datahead_g
*) (pbyTxBufferAddr
+
2009 wTxBufSize
+ sizeof(struct vnt_rrv_time_cts
) + cbMICHDR
+
2010 sizeof(struct vnt_cts
));
2011 cbHeaderSize
= wTxBufSize
+ sizeof(struct vnt_rrv_time_cts
) + cbMICHDR
+
2012 sizeof(struct vnt_cts
) + sizeof(struct vnt_tx_datahead_g
);
2015 else {//802.11a/b packet
2016 pvTxDataHd
= (struct vnt_tx_datahead_ab
*)(pbyTxBufferAddr
+
2017 wTxBufSize
+ sizeof(struct vnt_rrv_time_ab
) + cbMICHDR
);
2018 cbHeaderSize
= wTxBufSize
+ sizeof(struct vnt_rrv_time_ab
) + cbMICHDR
+
2019 sizeof(struct vnt_tx_datahead_ab
);
2021 memcpy(&(sEthHeader
.h_dest
[0]),
2022 &(p80211Header
->sA3
.abyAddr1
[0]),
2024 memcpy(&(sEthHeader
.h_source
[0]),
2025 &(p80211Header
->sA3
.abyAddr2
[0]),
2027 //=========================
2029 //=========================
2030 pTxBufHead
->wFragCtl
|= (u16
)FRAGCTL_NONFRAG
;
2032 /* Fill FIFO,RrvTime,RTS,and CTS */
2033 s_vGenerateTxParameter(pDevice
, byPktType
, wCurrentRate
,
2034 pTX_Buffer
, &pMICHDR
, cbMICHDR
, rts_cts
,
2035 cbFrameSize
, bNeedACK
, TYPE_TXDMA0
, &sEthHeader
, false);
2038 uDuration
= s_uFillDataHead(pDevice
, byPktType
, wCurrentRate
, pvTxDataHd
, cbFrameSize
, TYPE_TXDMA0
, bNeedACK
,
2041 pMACHeader
= (struct ieee80211_hdr
*) (pbyTxBufferAddr
+ cbHeaderSize
);
2043 cbReqCount
= cbHeaderSize
+ cbMacHdLen
+ uPadding
+ cbIVlen
+ (cbFrameBodySize
+ cbMIClen
) + cbExtSuppRate
;
2045 pbyMacHdr
= (u8
*)(pbyTxBufferAddr
+ cbHeaderSize
);
2046 pbyPayloadHead
= (u8
*)(pbyMacHdr
+ cbMacHdLen
+ uPadding
+ cbIVlen
);
2047 pbyIVHead
= (u8
*)(pbyMacHdr
+ cbMacHdLen
+ uPadding
);
2049 // Copy the Packet into a tx Buffer
2050 memcpy(pbyMacHdr
, skb
->data
, cbMacHdLen
);
2052 // version set to 0, patch for hostapd deamon
2053 pMACHeader
->frame_control
&= cpu_to_le16(0xfffc);
2054 memcpy(pbyPayloadHead
, (skb
->data
+ cbMacHdLen
), cbFrameBodySize
);
2056 // replace support rate, patch for hostapd daemon( only support 11M)
2057 if (WLAN_GET_FC_FSTYPE(p80211Header
->sA4
.wFrameCtl
) == WLAN_FSTYPE_ASSOCRESP
) {
2058 if (cbExtSuppRate
!= 0) {
2059 if (((PWLAN_IE_SUPP_RATES
)pMgmt
->abyCurrSuppRates
)->len
!= 0)
2060 memcpy((pbyPayloadHead
+ cbFrameBodySize
),
2061 pMgmt
->abyCurrSuppRates
,
2062 ((PWLAN_IE_SUPP_RATES
)pMgmt
->abyCurrSuppRates
)->len
+ WLAN_IEHDR_LEN
2064 if (((PWLAN_IE_SUPP_RATES
)pMgmt
->abyCurrExtSuppRates
)->len
!= 0)
2065 memcpy((pbyPayloadHead
+ cbFrameBodySize
) + ((PWLAN_IE_SUPP_RATES
)pMgmt
->abyCurrSuppRates
)->len
+ WLAN_IEHDR_LEN
,
2066 pMgmt
->abyCurrExtSuppRates
,
2067 ((PWLAN_IE_SUPP_RATES
)pMgmt
->abyCurrExtSuppRates
)->len
+ WLAN_IEHDR_LEN
2073 if (WLAN_GET_FC_ISWEP(p80211Header
->sA4
.wFrameCtl
) != 0) {
2075 if (pDevice
->bEnableHostWEP
) {
2076 pTransmitKey
= &STempKey
;
2077 pTransmitKey
->byCipherSuite
= pMgmt
->sNodeDBTable
[uNodeIndex
].byCipherSuite
;
2078 pTransmitKey
->dwKeyIndex
= pMgmt
->sNodeDBTable
[uNodeIndex
].dwKeyIndex
;
2079 pTransmitKey
->uKeyLength
= pMgmt
->sNodeDBTable
[uNodeIndex
].uWepKeyLength
;
2080 pTransmitKey
->dwTSC47_16
= pMgmt
->sNodeDBTable
[uNodeIndex
].dwTSC47_16
;
2081 pTransmitKey
->wTSC15_0
= pMgmt
->sNodeDBTable
[uNodeIndex
].wTSC15_0
;
2082 memcpy(pTransmitKey
->abyKey
,
2083 &pMgmt
->sNodeDBTable
[uNodeIndex
].abyWepKey
[0],
2084 pTransmitKey
->uKeyLength
2088 if ((pTransmitKey
!= NULL
) && (pTransmitKey
->byCipherSuite
== KEY_CTL_TKIP
)) {
2090 dwMICKey0
= *(u32
*)(&pTransmitKey
->abyKey
[16]);
2091 dwMICKey1
= *(u32
*)(&pTransmitKey
->abyKey
[20]);
2093 // DO Software Michael
2094 MIC_vInit(dwMICKey0
, dwMICKey1
);
2095 MIC_vAppend((u8
*)&(sEthHeader
.h_dest
[0]), 12);
2097 MIC_vAppend((u8
*)&dwMIC_Priority
, 4);
2098 DBG_PRT(MSG_LEVEL_DEBUG
, KERN_INFO
"DMA0_tx_8021:MIC KEY:"\
2099 " %X, %X\n", dwMICKey0
, dwMICKey1
);
2101 uLength
= cbHeaderSize
+ cbMacHdLen
+ uPadding
+ cbIVlen
;
2103 MIC_vAppend((pbyTxBufferAddr
+ uLength
), cbFrameBodySize
);
2105 pdwMIC_L
= (u32
*)(pbyTxBufferAddr
+ uLength
+ cbFrameBodySize
);
2106 pdwMIC_R
= (u32
*)(pbyTxBufferAddr
+ uLength
+ cbFrameBodySize
+ 4);
2108 MIC_vGetMIC(pdwMIC_L
, pdwMIC_R
);
2111 if (pDevice
->bTxMICFail
== true) {
2114 pDevice
->bTxMICFail
= false;
2117 DBG_PRT(MSG_LEVEL_DEBUG
, KERN_INFO
"uLength: %d, %d\n", uLength
, cbFrameBodySize
);
2118 DBG_PRT(MSG_LEVEL_DEBUG
, KERN_INFO
"cbReqCount:%d, %d, %d, %d\n", cbReqCount
, cbHeaderSize
, uPadding
, cbIVlen
);
2119 DBG_PRT(MSG_LEVEL_DEBUG
, KERN_INFO
"MIC:%x, %x\n",
2120 *pdwMIC_L
, *pdwMIC_R
);
2124 s_vFillTxKey(pDevice
, (u8
*)(pTxBufHead
->adwTxKey
), pbyIVHead
, pTransmitKey
,
2125 pbyMacHdr
, (u16
)cbFrameBodySize
, pMICHDR
);
2127 if (pDevice
->bEnableHostWEP
) {
2128 pMgmt
->sNodeDBTable
[uNodeIndex
].dwTSC47_16
= pTransmitKey
->dwTSC47_16
;
2129 pMgmt
->sNodeDBTable
[uNodeIndex
].wTSC15_0
= pTransmitKey
->wTSC15_0
;
2132 if ((pDevice
->byLocalID
<= REV_ID_VT3253_A1
)) {
2133 s_vSWencryption(pDevice
, pTransmitKey
, pbyPayloadHead
, (u16
)(cbFrameBodySize
+ cbMIClen
));
2137 pMACHeader
->seq_ctrl
= cpu_to_le16(pDevice
->wSeqCounter
<< 4);
2138 pDevice
->wSeqCounter
++ ;
2139 if (pDevice
->wSeqCounter
> 0x0fff)
2140 pDevice
->wSeqCounter
= 0;
2143 // The MAC will automatically replace the Duration-field of MAC header by Duration-field
2144 // of FIFO control header.
2145 // This will cause AID-field of PS-POLL packet be incorrect (Because PS-POLL's AID field is
2146 // in the same place of other packet's Duration-field).
2147 // And it will cause Cisco-AP to issue Disassociation-packet
2148 if (byPktType
== PK_TYPE_11GB
|| byPktType
== PK_TYPE_11GA
) {
2149 ((struct vnt_tx_datahead_g
*)pvTxDataHd
)->wDuration_a
=
2150 cpu_to_le16(p80211Header
->sA2
.wDurationID
);
2151 ((struct vnt_tx_datahead_g
*)pvTxDataHd
)->wDuration_b
=
2152 cpu_to_le16(p80211Header
->sA2
.wDurationID
);
2154 ((struct vnt_tx_datahead_ab
*)pvTxDataHd
)->wDuration
=
2155 cpu_to_le16(p80211Header
->sA2
.wDurationID
);
2159 pTX_Buffer
->wTxByteCount
= cpu_to_le16((u16
)(cbReqCount
));
2160 pTX_Buffer
->byPKTNO
= (u8
) (((wCurrentRate
<<4) &0x00F0) | ((pDevice
->wSeqCounter
- 1) & 0x000F));
2161 pTX_Buffer
->byType
= 0x00;
2163 pContext
->pPacket
= skb
;
2164 pContext
->Type
= CONTEXT_MGMT_PACKET
;
2165 pContext
->uBufLen
= (u16
)cbReqCount
+ 4; //USB header
2167 if (WLAN_GET_FC_TODS(pMACHeader
->frame_control
) == 0) {
2168 s_vSaveTxPktInfo(pDevice
, (u8
)(pTX_Buffer
->byPKTNO
& 0x0F),
2169 &pMACHeader
->addr1
[0], (u16
)cbFrameSize
,
2170 pTxBufHead
->wFIFOCtl
);
2173 s_vSaveTxPktInfo(pDevice
, (u8
)(pTX_Buffer
->byPKTNO
& 0x0F),
2174 &pMACHeader
->addr3
[0], (u16
)cbFrameSize
,
2175 pTxBufHead
->wFIFOCtl
);
2177 PIPEnsSendBulkOut(pDevice
,pContext
);
2182 //TYPE_AC0DMA data tx
2185 * Tx packet via AC0DMA(DMA1)
2189 * pDevice - Pointer to the adapter
2190 * skb - Pointer to tx skb packet
2194 * Return Value: NULL
2197 int nsDMA_tx_packet(struct vnt_private
*pDevice
,
2198 u32 uDMAIdx
, struct sk_buff
*skb
)
2200 struct net_device_stats
*pStats
= &pDevice
->stats
;
2201 struct vnt_manager
*pMgmt
= &pDevice
->vnt_mgmt
;
2202 struct vnt_tx_buffer
*pTX_Buffer
;
2203 u32 BytesToWrite
= 0, uHeaderLen
= 0;
2205 u8 byMask
[8] = {1, 2, 4, 8, 0x10, 0x20, 0x40, 0x80};
2208 int bNeedEncryption
= false;
2209 PSKeyItem pTransmitKey
= NULL
;
2212 int bTKIP_UseGTK
= false;
2213 int bNeedDeAuth
= false;
2215 int bNodeExist
= false;
2216 struct vnt_usb_send_context
*pContext
;
2217 bool fConvertedPacket
;
2219 u16 wKeepRate
= pDevice
->wCurrentRate
;
2220 int bTxeapol_key
= false;
2222 if (pMgmt
->eCurrMode
== WMAC_MODE_ESS_AP
) {
2224 if (pDevice
->uAssocCount
== 0) {
2225 dev_kfree_skb_irq(skb
);
2229 if (is_multicast_ether_addr((u8
*)(skb
->data
))) {
2232 if (pMgmt
->sNodeDBTable
[0].bPSEnable
) {
2234 skb_queue_tail(&(pMgmt
->sNodeDBTable
[0].sTxPSQueue
), skb
);
2235 pMgmt
->sNodeDBTable
[0].wEnQueueCnt
++;
2237 pMgmt
->abyPSTxMap
[0] |= byMask
[0];
2240 // multicast/broadcast data rate
2242 if (pDevice
->byBBType
!= BB_TYPE_11A
)
2243 pDevice
->wCurrentRate
= RATE_2M
;
2245 pDevice
->wCurrentRate
= RATE_24M
;
2246 // long preamble type
2247 pDevice
->byPreambleType
= PREAMBLE_SHORT
;
2251 if (BSSbIsSTAInNodeDB(pDevice
, (u8
*)(skb
->data
), &uNodeIndex
)) {
2253 if (pMgmt
->sNodeDBTable
[uNodeIndex
].bPSEnable
) {
2255 skb_queue_tail(&pMgmt
->sNodeDBTable
[uNodeIndex
].sTxPSQueue
, skb
);
2257 pMgmt
->sNodeDBTable
[uNodeIndex
].wEnQueueCnt
++;
2259 wAID
= pMgmt
->sNodeDBTable
[uNodeIndex
].wAID
;
2260 pMgmt
->abyPSTxMap
[wAID
>> 3] |= byMask
[wAID
& 7];
2261 DBG_PRT(MSG_LEVEL_DEBUG
, KERN_INFO
"Set:pMgmt->abyPSTxMap[%d]= %d\n",
2262 (wAID
>> 3), pMgmt
->abyPSTxMap
[wAID
>> 3]);
2266 // AP rate decided from node
2267 pDevice
->wCurrentRate
= pMgmt
->sNodeDBTable
[uNodeIndex
].wTxDataRate
;
2268 // tx preamble decided from node
2270 if (pMgmt
->sNodeDBTable
[uNodeIndex
].bShortPreamble
) {
2271 pDevice
->byPreambleType
= pDevice
->byShortPreamble
;
2274 pDevice
->byPreambleType
= PREAMBLE_LONG
;
2280 if (bNodeExist
== false) {
2281 DBG_PRT(MSG_LEVEL_DEBUG
, KERN_DEBUG
"Unknown STA not found in node DB \n");
2282 dev_kfree_skb_irq(skb
);
2287 pContext
= (struct vnt_usb_send_context
*)s_vGetFreeContext(pDevice
);
2289 if (pContext
== NULL
) {
2290 DBG_PRT(MSG_LEVEL_DEBUG
, KERN_DEBUG
" pContext == NULL\n");
2291 dev_kfree_skb_irq(skb
);
2292 return STATUS_RESOURCES
;
2295 memcpy(pDevice
->sTxEthHeader
.h_dest
, (u8
*)(skb
->data
), ETH_HLEN
);
2297 //mike add:station mode check eapol-key challenge--->
2299 u8 Protocol_Version
; //802.1x Authentication
2300 u8 Packet_Type
; //802.1x Authentication
2304 Protocol_Version
= skb
->data
[ETH_HLEN
];
2305 Packet_Type
= skb
->data
[ETH_HLEN
+1];
2306 Descriptor_type
= skb
->data
[ETH_HLEN
+1+1+2];
2307 Key_info
= (skb
->data
[ETH_HLEN
+1+1+2+1] << 8)|(skb
->data
[ETH_HLEN
+1+1+2+2]);
2308 if (pDevice
->sTxEthHeader
.h_proto
== cpu_to_be16(ETH_P_PAE
)) {
2309 /* 802.1x OR eapol-key challenge frame transfer */
2310 if (((Protocol_Version
== 1) || (Protocol_Version
== 2)) &&
2311 (Packet_Type
== 3)) {
2312 bTxeapol_key
= true;
2313 if(!(Key_info
& BIT3
) && //WPA or RSN group-key challenge
2314 (Key_info
& BIT8
) && (Key_info
& BIT9
)) { //send 2/2 key
2315 if(Descriptor_type
==254) {
2316 pDevice
->fWPA_Authened
= true;
2320 pDevice
->fWPA_Authened
= true;
2321 PRINT_K("WPA2(re-keying) ");
2323 PRINT_K("Authentication completed!!\n");
2325 else if((Key_info
& BIT3
) && (Descriptor_type
==2) && //RSN pairwise-key challenge
2326 (Key_info
& BIT8
) && (Key_info
& BIT9
)) {
2327 pDevice
->fWPA_Authened
= true;
2328 PRINT_K("WPA2 Authentication completed!!\n");
2333 //mike add:station mode check eapol-key challenge<---
2335 if (pDevice
->bEncryptionEnable
== true) {
2336 bNeedEncryption
= true;
2339 if ((pMgmt
->eCurrMode
== WMAC_MODE_ESS_STA
) &&
2340 (pMgmt
->eCurrState
== WMAC_STATE_ASSOC
)) {
2341 pbyBSSID
= pDevice
->abyBSSID
;
2343 if (KeybGetTransmitKey(&(pDevice
->sKey
), pbyBSSID
, PAIRWISE_KEY
, &pTransmitKey
) == false) {
2345 if(KeybGetTransmitKey(&(pDevice
->sKey
), pbyBSSID
, GROUP_KEY
, &pTransmitKey
) == true) {
2346 bTKIP_UseGTK
= true;
2347 DBG_PRT(MSG_LEVEL_DEBUG
, KERN_DEBUG
"Get GTK.\n");
2351 DBG_PRT(MSG_LEVEL_DEBUG
, KERN_DEBUG
"Get PTK.\n");
2354 }else if (pMgmt
->eCurrMode
== WMAC_MODE_IBSS_STA
) {
2355 /* TO_DS = 0 and FROM_DS = 0 --> 802.11 MAC Address1 */
2356 pbyBSSID
= pDevice
->sTxEthHeader
.h_dest
;
2357 DBG_PRT(MSG_LEVEL_DEBUG
, KERN_DEBUG
"IBSS Serach Key: \n");
2358 for (ii
= 0; ii
< 6; ii
++)
2359 DBG_PRT(MSG_LEVEL_DEBUG
, KERN_DEBUG
"%x \n", *(pbyBSSID
+ii
));
2360 DBG_PRT(MSG_LEVEL_DEBUG
, KERN_DEBUG
"\n");
2363 if(KeybGetTransmitKey(&(pDevice
->sKey
), pbyBSSID
, PAIRWISE_KEY
, &pTransmitKey
) == true)
2367 pbyBSSID
= pDevice
->abyBroadcastAddr
;
2368 if(KeybGetTransmitKey(&(pDevice
->sKey
), pbyBSSID
, GROUP_KEY
, &pTransmitKey
) == false) {
2369 pTransmitKey
= NULL
;
2370 if (pMgmt
->eCurrMode
== WMAC_MODE_IBSS_STA
) {
2371 DBG_PRT(MSG_LEVEL_DEBUG
, KERN_DEBUG
"IBSS and KEY is NULL. [%d]\n", pMgmt
->eCurrMode
);
2374 DBG_PRT(MSG_LEVEL_DEBUG
, KERN_DEBUG
"NOT IBSS and KEY is NULL. [%d]\n", pMgmt
->eCurrMode
);
2376 bTKIP_UseGTK
= true;
2377 DBG_PRT(MSG_LEVEL_DEBUG
, KERN_DEBUG
"Get GTK.\n");
2382 if (pDevice
->bEnableHostWEP
) {
2383 DBG_PRT(MSG_LEVEL_DEBUG
, KERN_DEBUG
"acdma0: STA index %d\n", uNodeIndex
);
2384 if (pDevice
->bEncryptionEnable
== true) {
2385 pTransmitKey
= &STempKey
;
2386 pTransmitKey
->byCipherSuite
= pMgmt
->sNodeDBTable
[uNodeIndex
].byCipherSuite
;
2387 pTransmitKey
->dwKeyIndex
= pMgmt
->sNodeDBTable
[uNodeIndex
].dwKeyIndex
;
2388 pTransmitKey
->uKeyLength
= pMgmt
->sNodeDBTable
[uNodeIndex
].uWepKeyLength
;
2389 pTransmitKey
->dwTSC47_16
= pMgmt
->sNodeDBTable
[uNodeIndex
].dwTSC47_16
;
2390 pTransmitKey
->wTSC15_0
= pMgmt
->sNodeDBTable
[uNodeIndex
].wTSC15_0
;
2391 memcpy(pTransmitKey
->abyKey
,
2392 &pMgmt
->sNodeDBTable
[uNodeIndex
].abyWepKey
[0],
2393 pTransmitKey
->uKeyLength
2398 byPktType
= (u8
)pDevice
->byPacketType
;
2400 if (pDevice
->bFixRate
) {
2401 if (pDevice
->byBBType
== BB_TYPE_11B
) {
2402 if (pDevice
->uConnectionRate
>= RATE_11M
) {
2403 pDevice
->wCurrentRate
= RATE_11M
;
2405 pDevice
->wCurrentRate
= (u16
)pDevice
->uConnectionRate
;
2408 if ((pDevice
->byBBType
== BB_TYPE_11A
) &&
2409 (pDevice
->uConnectionRate
<= RATE_6M
)) {
2410 pDevice
->wCurrentRate
= RATE_6M
;
2412 if (pDevice
->uConnectionRate
>= RATE_54M
)
2413 pDevice
->wCurrentRate
= RATE_54M
;
2415 pDevice
->wCurrentRate
= (u16
)pDevice
->uConnectionRate
;
2420 if (pDevice
->eOPMode
== OP_MODE_ADHOC
) {
2421 // Adhoc Tx rate decided from node DB
2422 if (is_multicast_ether_addr(pDevice
->sTxEthHeader
.h_dest
)) {
2423 // Multicast use highest data rate
2424 pDevice
->wCurrentRate
= pMgmt
->sNodeDBTable
[0].wTxDataRate
;
2426 pDevice
->byPreambleType
= pDevice
->byShortPreamble
;
2429 if (BSSbIsSTAInNodeDB(pDevice
, &(pDevice
->sTxEthHeader
.h_dest
[0]), &uNodeIndex
)) {
2430 pDevice
->wCurrentRate
= pMgmt
->sNodeDBTable
[uNodeIndex
].wTxDataRate
;
2431 if (pMgmt
->sNodeDBTable
[uNodeIndex
].bShortPreamble
) {
2432 pDevice
->byPreambleType
= pDevice
->byShortPreamble
;
2436 pDevice
->byPreambleType
= PREAMBLE_LONG
;
2438 DBG_PRT(MSG_LEVEL_DEBUG
, KERN_INFO
"Found Node Index is [%d] Tx Data Rate:[%d]\n",uNodeIndex
, pDevice
->wCurrentRate
);
2441 if (pDevice
->byBBType
!= BB_TYPE_11A
)
2442 pDevice
->wCurrentRate
= RATE_2M
;
2444 pDevice
->wCurrentRate
= RATE_24M
; // refer to vMgrCreateOwnIBSS()'s
2445 // abyCurrExtSuppRates[]
2446 pDevice
->byPreambleType
= PREAMBLE_SHORT
;
2447 DBG_PRT(MSG_LEVEL_DEBUG
, KERN_INFO
"Not Found Node use highest basic Rate.....\n");
2451 if (pDevice
->eOPMode
== OP_MODE_INFRASTRUCTURE
) {
2452 // Infra STA rate decided from AP Node, index = 0
2453 pDevice
->wCurrentRate
= pMgmt
->sNodeDBTable
[0].wTxDataRate
;
2457 if (pDevice
->sTxEthHeader
.h_proto
== cpu_to_be16(ETH_P_PAE
)) {
2458 if (pDevice
->byBBType
!= BB_TYPE_11A
) {
2459 pDevice
->wCurrentRate
= RATE_1M
;
2460 pDevice
->byACKRate
= RATE_1M
;
2461 pDevice
->byTopCCKBasicRate
= RATE_1M
;
2462 pDevice
->byTopOFDMBasicRate
= RATE_6M
;
2464 pDevice
->wCurrentRate
= RATE_6M
;
2465 pDevice
->byACKRate
= RATE_6M
;
2466 pDevice
->byTopCCKBasicRate
= RATE_1M
;
2467 pDevice
->byTopOFDMBasicRate
= RATE_6M
;
2471 DBG_PRT(MSG_LEVEL_DEBUG
,
2472 KERN_INFO
"dma_tx: pDevice->wCurrentRate = %d\n",
2473 pDevice
->wCurrentRate
);
2475 if (wKeepRate
!= pDevice
->wCurrentRate
) {
2476 bScheduleCommand((void *) pDevice
, WLAN_CMD_SETPOWER
, NULL
);
2479 if (pDevice
->wCurrentRate
<= RATE_11M
) {
2480 byPktType
= PK_TYPE_11B
;
2483 if (bNeedEncryption
== true) {
2484 DBG_PRT(MSG_LEVEL_DEBUG
, KERN_INFO
"ntohs Pkt Type=%04x\n", ntohs(pDevice
->sTxEthHeader
.h_proto
));
2485 if ((pDevice
->sTxEthHeader
.h_proto
) == cpu_to_be16(ETH_P_PAE
)) {
2486 bNeedEncryption
= false;
2487 DBG_PRT(MSG_LEVEL_DEBUG
, KERN_INFO
"Pkt Type=%04x\n", (pDevice
->sTxEthHeader
.h_proto
));
2488 if ((pMgmt
->eCurrMode
== WMAC_MODE_ESS_STA
) && (pMgmt
->eCurrState
== WMAC_STATE_ASSOC
)) {
2489 if (pTransmitKey
== NULL
) {
2490 DBG_PRT(MSG_LEVEL_DEBUG
, KERN_INFO
"Don't Find TX KEY\n");
2493 if (bTKIP_UseGTK
== true) {
2494 DBG_PRT(MSG_LEVEL_DEBUG
, KERN_INFO
"error: KEY is GTK!!~~\n");
2497 DBG_PRT(MSG_LEVEL_DEBUG
, KERN_INFO
"Find PTK [%X]\n",
2498 pTransmitKey
->dwKeyIndex
);
2499 bNeedEncryption
= true;
2504 if (pDevice
->bEnableHostWEP
) {
2505 if ((uNodeIndex
!= 0) &&
2506 (pMgmt
->sNodeDBTable
[uNodeIndex
].dwKeyIndex
& PAIRWISE_KEY
)) {
2507 DBG_PRT(MSG_LEVEL_DEBUG
, KERN_INFO
"Find PTK [%X]\n",
2508 pTransmitKey
->dwKeyIndex
);
2509 bNeedEncryption
= true;
2515 if (pTransmitKey
== NULL
) {
2516 DBG_PRT(MSG_LEVEL_DEBUG
, KERN_INFO
"return no tx key\n");
2517 pContext
->bBoolInUse
= false;
2518 dev_kfree_skb_irq(skb
);
2519 pStats
->tx_dropped
++;
2520 return STATUS_FAILURE
;
2525 pTX_Buffer
= (struct vnt_tx_buffer
*)&pContext
->Data
[0];
2527 fConvertedPacket
= s_bPacketToWirelessUsb(pDevice
, byPktType
,
2528 pTX_Buffer
, bNeedEncryption
,
2529 skb
->len
, uDMAIdx
, &pDevice
->sTxEthHeader
,
2530 (u8
*)skb
->data
, pTransmitKey
, uNodeIndex
,
2531 pDevice
->wCurrentRate
,
2532 &uHeaderLen
, &BytesToWrite
2535 if (fConvertedPacket
== false) {
2536 pContext
->bBoolInUse
= false;
2537 dev_kfree_skb_irq(skb
);
2538 return STATUS_FAILURE
;
2541 if ( pDevice
->bEnablePSMode
== true ) {
2542 if ( !pDevice
->bPSModeTxBurst
) {
2543 bScheduleCommand((void *) pDevice
,
2544 WLAN_CMD_MAC_DISPOWERSAVING
,
2546 pDevice
->bPSModeTxBurst
= true;
2550 pTX_Buffer
->byPKTNO
= (u8
) (((pDevice
->wCurrentRate
<<4) &0x00F0) | ((pDevice
->wSeqCounter
- 1) & 0x000F));
2551 pTX_Buffer
->wTxByteCount
= (u16
)BytesToWrite
;
2553 pContext
->pPacket
= skb
;
2554 pContext
->Type
= CONTEXT_DATA_PACKET
;
2555 pContext
->uBufLen
= (u16
)BytesToWrite
+ 4 ; //USB header
2557 s_vSaveTxPktInfo(pDevice
, (u8
)(pTX_Buffer
->byPKTNO
& 0x0F),
2558 &pContext
->sEthHeader
.h_dest
[0],
2559 (u16
)(BytesToWrite
-uHeaderLen
),
2560 pTX_Buffer
->fifo_head
.wFIFOCtl
);
2562 status
= PIPEnsSendBulkOut(pDevice
,pContext
);
2564 if (bNeedDeAuth
== true) {
2565 u16 wReason
= WLAN_MGMT_REASON_MIC_FAILURE
;
2567 bScheduleCommand((void *) pDevice
, WLAN_CMD_DEAUTH
, (u8
*) &wReason
);
2570 if(status
!=STATUS_PENDING
) {
2571 pContext
->bBoolInUse
= false;
2572 dev_kfree_skb_irq(skb
);
2573 return STATUS_FAILURE
;
2582 * Relay packet send (AC1DMA) from rx dpc.
2586 * pDevice - Pointer to the adapter
2587 * pPacket - Pointer to rx packet
2588 * cbPacketSize - rx ethernet frame size
2592 * Return Value: Return true if packet is copy to dma1; otherwise false
2595 int bRelayPacketSend(struct vnt_private
*pDevice
, u8
*pbySkbData
, u32 uDataLen
,
2598 struct vnt_manager
*pMgmt
= &pDevice
->vnt_mgmt
;
2599 struct vnt_tx_buffer
*pTX_Buffer
;
2600 u32 BytesToWrite
= 0, uHeaderLen
= 0;
2601 u8 byPktType
= PK_TYPE_11B
;
2602 int bNeedEncryption
= false;
2604 PSKeyItem pTransmitKey
= NULL
;
2606 struct vnt_usb_send_context
*pContext
;
2608 int fConvertedPacket
;
2610 u16 wKeepRate
= pDevice
->wCurrentRate
;
2612 pContext
= (struct vnt_usb_send_context
*)s_vGetFreeContext(pDevice
);
2614 if (NULL
== pContext
) {
2618 memcpy(pDevice
->sTxEthHeader
.h_dest
, (u8
*)pbySkbData
, ETH_HLEN
);
2620 if (pDevice
->bEncryptionEnable
== true) {
2621 bNeedEncryption
= true;
2623 pbyBSSID
= pDevice
->abyBroadcastAddr
;
2624 if(KeybGetTransmitKey(&(pDevice
->sKey
), pbyBSSID
, GROUP_KEY
, &pTransmitKey
) == false) {
2625 pTransmitKey
= NULL
;
2626 DBG_PRT(MSG_LEVEL_DEBUG
, KERN_DEBUG
"KEY is NULL. [%d]\n", pMgmt
->eCurrMode
);
2628 DBG_PRT(MSG_LEVEL_DEBUG
, KERN_DEBUG
"Get GTK.\n");
2632 if (pDevice
->bEnableHostWEP
) {
2633 if (uNodeIndex
< MAX_NODE_NUM
+ 1) {
2634 pTransmitKey
= &STempKey
;
2635 pTransmitKey
->byCipherSuite
= pMgmt
->sNodeDBTable
[uNodeIndex
].byCipherSuite
;
2636 pTransmitKey
->dwKeyIndex
= pMgmt
->sNodeDBTable
[uNodeIndex
].dwKeyIndex
;
2637 pTransmitKey
->uKeyLength
= pMgmt
->sNodeDBTable
[uNodeIndex
].uWepKeyLength
;
2638 pTransmitKey
->dwTSC47_16
= pMgmt
->sNodeDBTable
[uNodeIndex
].dwTSC47_16
;
2639 pTransmitKey
->wTSC15_0
= pMgmt
->sNodeDBTable
[uNodeIndex
].wTSC15_0
;
2640 memcpy(pTransmitKey
->abyKey
,
2641 &pMgmt
->sNodeDBTable
[uNodeIndex
].abyWepKey
[0],
2642 pTransmitKey
->uKeyLength
2647 if ( bNeedEncryption
&& (pTransmitKey
== NULL
) ) {
2648 pContext
->bBoolInUse
= false;
2652 byPktTyp
= (u8
)pDevice
->byPacketType
;
2654 if (pDevice
->bFixRate
) {
2655 if (pDevice
->byBBType
== BB_TYPE_11B
) {
2656 if (pDevice
->uConnectionRate
>= RATE_11M
) {
2657 pDevice
->wCurrentRate
= RATE_11M
;
2659 pDevice
->wCurrentRate
= (u16
)pDevice
->uConnectionRate
;
2662 if ((pDevice
->byBBType
== BB_TYPE_11A
) &&
2663 (pDevice
->uConnectionRate
<= RATE_6M
)) {
2664 pDevice
->wCurrentRate
= RATE_6M
;
2666 if (pDevice
->uConnectionRate
>= RATE_54M
)
2667 pDevice
->wCurrentRate
= RATE_54M
;
2669 pDevice
->wCurrentRate
= (u16
)pDevice
->uConnectionRate
;
2674 pDevice
->wCurrentRate
= pMgmt
->sNodeDBTable
[uNodeIndex
].wTxDataRate
;
2677 if (wKeepRate
!= pDevice
->wCurrentRate
) {
2678 bScheduleCommand((void *) pDevice
, WLAN_CMD_SETPOWER
, NULL
);
2681 if (pDevice
->wCurrentRate
<= RATE_11M
)
2682 byPktType
= PK_TYPE_11B
;
2684 BytesToWrite
= uDataLen
+ ETH_FCS_LEN
;
2686 // Convert the packet to an usb frame and copy into our buffer
2687 // and send the irp.
2689 pTX_Buffer
= (struct vnt_tx_buffer
*)&pContext
->Data
[0];
2691 fConvertedPacket
= s_bPacketToWirelessUsb(pDevice
, byPktType
,
2692 pTX_Buffer
, bNeedEncryption
,
2693 uDataLen
, TYPE_AC0DMA
, &pDevice
->sTxEthHeader
,
2694 pbySkbData
, pTransmitKey
, uNodeIndex
,
2695 pDevice
->wCurrentRate
,
2696 &uHeaderLen
, &BytesToWrite
2699 if (fConvertedPacket
== false) {
2700 pContext
->bBoolInUse
= false;
2704 pTX_Buffer
->byPKTNO
= (u8
) (((pDevice
->wCurrentRate
<<4) &0x00F0) | ((pDevice
->wSeqCounter
- 1) & 0x000F));
2705 pTX_Buffer
->wTxByteCount
= (u16
)BytesToWrite
;
2707 pContext
->pPacket
= NULL
;
2708 pContext
->Type
= CONTEXT_DATA_PACKET
;
2709 pContext
->uBufLen
= (u16
)BytesToWrite
+ 4 ; //USB header
2711 s_vSaveTxPktInfo(pDevice
, (u8
)(pTX_Buffer
->byPKTNO
& 0x0F),
2712 &pContext
->sEthHeader
.h_dest
[0],
2713 (u16
)(BytesToWrite
- uHeaderLen
),
2714 pTX_Buffer
->fifo_head
.wFIFOCtl
);
2716 status
= PIPEnsSendBulkOut(pDevice
,pContext
);