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 *rts_cts
, u32 cbFrameSize
, int bNeedACK
, u32 uDMAIdx
,
104 struct ethhdr
*psEthHeader
, bool need_rts
);
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
, union vnt_tx_data_head
*head
, u32 cbFrameLength
,
129 int bNeedAck
, u16 wCurrentRate
, u8 byFBOption
);
131 static void s_vFillRTSHead(struct vnt_private
*pDevice
, u8 byPktType
,
132 union vnt_tx_data_head
*head
, 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 struct vnt_usb_send_context
*pContext
= NULL
;
145 struct vnt_usb_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 switch (pTransmitKey
->byCipherSuite
) {
203 if (pTransmitKey
->uKeyLength
== WLAN_WEP232_KEYLEN
) {
204 memcpy(pDevice
->abyPRNG
, (u8
*)&dwRevIVCounter
, 3);
205 memcpy(pDevice
->abyPRNG
+ 3, pTransmitKey
->abyKey
,
206 pTransmitKey
->uKeyLength
);
208 memcpy(pbyBuf
, (u8
*)&dwRevIVCounter
, 3);
209 memcpy(pbyBuf
+ 3, pTransmitKey
->abyKey
,
210 pTransmitKey
->uKeyLength
);
211 if (pTransmitKey
->uKeyLength
== WLAN_WEP40_KEYLEN
) {
212 memcpy(pbyBuf
+8, (u8
*)&dwRevIVCounter
, 3);
213 memcpy(pbyBuf
+11, pTransmitKey
->abyKey
,
214 pTransmitKey
->uKeyLength
);
217 memcpy(pDevice
->abyPRNG
, pbyBuf
, 16);
219 /* Append IV after Mac Header */
220 *pdwIV
&= WEP_IV_MASK
;
221 *pdwIV
|= (u32
)pDevice
->byKeyIndex
<< 30;
222 *pdwIV
= cpu_to_le32(*pdwIV
);
224 pDevice
->dwIVCounter
++;
225 if (pDevice
->dwIVCounter
> WEP_IV_MASK
)
226 pDevice
->dwIVCounter
= 0;
230 pTransmitKey
->wTSC15_0
++;
231 if (pTransmitKey
->wTSC15_0
== 0)
232 pTransmitKey
->dwTSC47_16
++;
234 TKIPvMixKey(pTransmitKey
->abyKey
, pDevice
->abyCurrentNetAddr
,
235 pTransmitKey
->wTSC15_0
, pTransmitKey
->dwTSC47_16
,
237 memcpy(pbyBuf
, pDevice
->abyPRNG
, 16);
240 memcpy(pdwIV
, pDevice
->abyPRNG
, 3);
242 *(pbyIVHead
+3) = (u8
)(((pDevice
->byKeyIndex
<< 6) &
244 /* Append IV&ExtIV after Mac Header */
245 *pdwExtIV
= cpu_to_le32(pTransmitKey
->dwTSC47_16
);
247 DBG_PRT(MSG_LEVEL_DEBUG
, KERN_INFO
248 "vFillTxKey()---- pdwExtIV: %x\n", *pdwExtIV
);
252 pTransmitKey
->wTSC15_0
++;
253 if (pTransmitKey
->wTSC15_0
== 0)
254 pTransmitKey
->dwTSC47_16
++;
256 memcpy(pbyBuf
, pTransmitKey
->abyKey
, 16);
260 *(pbyIVHead
+3) = (u8
)(((pDevice
->byKeyIndex
<< 6) &
263 *pdwIV
|= cpu_to_le16((u16
)(pTransmitKey
->wTSC15_0
));
265 /* Append IV&ExtIV after Mac Header */
266 *pdwExtIV
= cpu_to_le32(pTransmitKey
->dwTSC47_16
);
273 mic_hdr
->payload_len
= cpu_to_be16(wPayloadLen
);
274 memcpy(mic_hdr
->mic_addr2
, pMACHeader
->addr2
, ETH_ALEN
);
276 mic_hdr
->tsc_47_16
= cpu_to_be32(pTransmitKey
->dwTSC47_16
);
277 mic_hdr
->tsc_15_0
= cpu_to_be16(pTransmitKey
->wTSC15_0
);
280 if (pDevice
->bLongHeader
)
281 mic_hdr
->hlen
= cpu_to_be16(28);
283 mic_hdr
->hlen
= cpu_to_be16(22);
285 memcpy(mic_hdr
->addr1
, pMACHeader
->addr1
, ETH_ALEN
);
286 memcpy(mic_hdr
->addr2
, pMACHeader
->addr2
, ETH_ALEN
);
289 memcpy(mic_hdr
->addr3
, pMACHeader
->addr3
, ETH_ALEN
);
290 mic_hdr
->frame_control
= cpu_to_le16(pMACHeader
->frame_control
292 mic_hdr
->seq_ctrl
= cpu_to_le16(pMACHeader
->seq_ctrl
& 0xf);
294 if (pDevice
->bLongHeader
)
295 memcpy(mic_hdr
->addr4
, pMACHeader
->addr4
, ETH_ALEN
);
299 static void s_vSWencryption(struct vnt_private
*pDevice
,
300 PSKeyItem pTransmitKey
, u8
*pbyPayloadHead
, u16 wPayloadSize
)
303 u32 dwICV
= 0xffffffff;
306 if (pTransmitKey
== NULL
)
309 if (pTransmitKey
->byCipherSuite
== KEY_CTL_WEP
) {
310 //=======================================================================
311 // Append ICV after payload
312 dwICV
= CRCdwGetCrc32Ex(pbyPayloadHead
, wPayloadSize
, dwICV
);//ICV(Payload)
313 pdwICV
= (u32
*)(pbyPayloadHead
+ wPayloadSize
);
314 // finally, we must invert dwCRC to get the correct answer
315 *pdwICV
= cpu_to_le32(~dwICV
);
317 rc4_init(&pDevice
->SBox
, pDevice
->abyPRNG
, pTransmitKey
->uKeyLength
+ 3);
318 rc4_encrypt(&pDevice
->SBox
, pbyPayloadHead
, pbyPayloadHead
, wPayloadSize
+cbICVlen
);
319 //=======================================================================
320 } else if (pTransmitKey
->byCipherSuite
== KEY_CTL_TKIP
) {
321 //=======================================================================
322 //Append ICV after payload
323 dwICV
= CRCdwGetCrc32Ex(pbyPayloadHead
, wPayloadSize
, dwICV
);//ICV(Payload)
324 pdwICV
= (u32
*)(pbyPayloadHead
+ wPayloadSize
);
325 // finally, we must invert dwCRC to get the correct answer
326 *pdwICV
= cpu_to_le32(~dwICV
);
328 rc4_init(&pDevice
->SBox
, pDevice
->abyPRNG
, TKIP_KEY_LEN
);
329 rc4_encrypt(&pDevice
->SBox
, pbyPayloadHead
, pbyPayloadHead
, wPayloadSize
+cbICVlen
);
330 //=======================================================================
334 static u16
vnt_time_stamp_off(struct vnt_private
*priv
, u16 rate
)
336 return cpu_to_le16(wTimeStampOff
[priv
->byPreambleType
% 2]
340 /*byPktType : PK_TYPE_11A 0
345 static u32
s_uGetTxRsvTime(struct vnt_private
*pDevice
, u8 byPktType
,
346 u32 cbFrameLength
, u16 wRate
, int bNeedAck
)
348 u32 uDataTime
, uAckTime
;
350 uDataTime
= BBuGetFrameTime(pDevice
->byPreambleType
, byPktType
, cbFrameLength
, wRate
);
351 if (byPktType
== PK_TYPE_11B
) {//llb,CCK mode
352 uAckTime
= BBuGetFrameTime(pDevice
->byPreambleType
, byPktType
, 14, (u16
)pDevice
->byTopCCKBasicRate
);
353 } else {//11g 2.4G OFDM mode & 11a 5G OFDM mode
354 uAckTime
= BBuGetFrameTime(pDevice
->byPreambleType
, byPktType
, 14, (u16
)pDevice
->byTopOFDMBasicRate
);
358 return (uDataTime
+ pDevice
->uSIFS
+ uAckTime
);
365 static u16
vnt_rxtx_rsvtime_le16(struct vnt_private
*priv
, u8 pkt_type
,
366 u32 frame_length
, u16 rate
, int need_ack
)
368 return cpu_to_le16((u16
)s_uGetTxRsvTime(priv
, pkt_type
,
369 frame_length
, rate
, need_ack
));
372 //byFreqType: 0=>5GHZ 1=>2.4GHZ
373 static u16
s_uGetRTSCTSRsvTime(struct vnt_private
*pDevice
,
374 u8 byRTSRsvType
, u8 byPktType
, u32 cbFrameLength
, u16 wCurrentRate
)
376 u32 uRrvTime
, uRTSTime
, uCTSTime
, uAckTime
, uDataTime
;
378 uRrvTime
= uRTSTime
= uCTSTime
= uAckTime
= uDataTime
= 0;
380 uDataTime
= BBuGetFrameTime(pDevice
->byPreambleType
, byPktType
, cbFrameLength
, wCurrentRate
);
381 if (byRTSRsvType
== 0) { //RTSTxRrvTime_bb
382 uRTSTime
= BBuGetFrameTime(pDevice
->byPreambleType
, byPktType
, 20, pDevice
->byTopCCKBasicRate
);
383 uCTSTime
= uAckTime
= BBuGetFrameTime(pDevice
->byPreambleType
, byPktType
, 14, pDevice
->byTopCCKBasicRate
);
385 else if (byRTSRsvType
== 1){ //RTSTxRrvTime_ba, only in 2.4GHZ
386 uRTSTime
= BBuGetFrameTime(pDevice
->byPreambleType
, byPktType
, 20, pDevice
->byTopCCKBasicRate
);
387 uCTSTime
= BBuGetFrameTime(pDevice
->byPreambleType
, byPktType
, 14, pDevice
->byTopCCKBasicRate
);
388 uAckTime
= BBuGetFrameTime(pDevice
->byPreambleType
, byPktType
, 14, pDevice
->byTopOFDMBasicRate
);
390 else if (byRTSRsvType
== 2) { //RTSTxRrvTime_aa
391 uRTSTime
= BBuGetFrameTime(pDevice
->byPreambleType
, byPktType
, 20, pDevice
->byTopOFDMBasicRate
);
392 uCTSTime
= uAckTime
= BBuGetFrameTime(pDevice
->byPreambleType
, byPktType
, 14, pDevice
->byTopOFDMBasicRate
);
394 else if (byRTSRsvType
== 3) { //CTSTxRrvTime_ba, only in 2.4GHZ
395 uCTSTime
= BBuGetFrameTime(pDevice
->byPreambleType
, byPktType
, 14, pDevice
->byTopCCKBasicRate
);
396 uAckTime
= BBuGetFrameTime(pDevice
->byPreambleType
, byPktType
, 14, pDevice
->byTopOFDMBasicRate
);
397 uRrvTime
= uCTSTime
+ uAckTime
+ uDataTime
+ 2*pDevice
->uSIFS
;
402 uRrvTime
= uRTSTime
+ uCTSTime
+ uAckTime
+ uDataTime
+ 3*pDevice
->uSIFS
;
403 return cpu_to_le16((u16
)uRrvTime
);
406 //byFreqType 0: 5GHz, 1:2.4Ghz
407 static u16
s_uGetDataDuration(struct vnt_private
*pDevice
,
408 u8 byPktType
, int bNeedAck
)
413 if (byPktType
== PK_TYPE_11B
)
414 uAckTime
= BBuGetFrameTime(pDevice
->byPreambleType
,
415 byPktType
, 14, pDevice
->byTopCCKBasicRate
);
417 uAckTime
= BBuGetFrameTime(pDevice
->byPreambleType
,
418 byPktType
, 14, pDevice
->byTopOFDMBasicRate
);
419 return cpu_to_le16((u16
)(pDevice
->uSIFS
+ uAckTime
));
425 //byFreqType: 0=>5GHZ 1=>2.4GHZ
426 static u16
s_uGetRTSCTSDuration(struct vnt_private
*pDevice
, u8 byDurType
,
427 u32 cbFrameLength
, u8 byPktType
, u16 wRate
, int bNeedAck
,
430 u32 uCTSTime
= 0, uDurTime
= 0;
434 case RTSDUR_BB
: //RTSDuration_bb
435 uCTSTime
= BBuGetFrameTime(pDevice
->byPreambleType
, byPktType
, 14, pDevice
->byTopCCKBasicRate
);
436 uDurTime
= uCTSTime
+ 2*pDevice
->uSIFS
+ s_uGetTxRsvTime(pDevice
, byPktType
, cbFrameLength
, wRate
, bNeedAck
);
439 case RTSDUR_BA
: //RTSDuration_ba
440 uCTSTime
= BBuGetFrameTime(pDevice
->byPreambleType
, byPktType
, 14, pDevice
->byTopCCKBasicRate
);
441 uDurTime
= uCTSTime
+ 2*pDevice
->uSIFS
+ s_uGetTxRsvTime(pDevice
, byPktType
, cbFrameLength
, wRate
, bNeedAck
);
444 case RTSDUR_AA
: //RTSDuration_aa
445 uCTSTime
= BBuGetFrameTime(pDevice
->byPreambleType
, byPktType
, 14, pDevice
->byTopOFDMBasicRate
);
446 uDurTime
= uCTSTime
+ 2*pDevice
->uSIFS
+ s_uGetTxRsvTime(pDevice
, byPktType
, cbFrameLength
, wRate
, bNeedAck
);
449 case CTSDUR_BA
: //CTSDuration_ba
450 uDurTime
= pDevice
->uSIFS
+ s_uGetTxRsvTime(pDevice
, byPktType
, cbFrameLength
, wRate
, bNeedAck
);
453 case RTSDUR_BA_F0
: //RTSDuration_ba_f0
454 uCTSTime
= BBuGetFrameTime(pDevice
->byPreambleType
, byPktType
, 14, pDevice
->byTopCCKBasicRate
);
455 if ((byFBOption
== AUTO_FB_0
) && (wRate
>= RATE_18M
) && (wRate
<=RATE_54M
)) {
456 uDurTime
= uCTSTime
+ 2*pDevice
->uSIFS
+ s_uGetTxRsvTime(pDevice
, byPktType
, cbFrameLength
, wFB_Opt0
[FB_RATE0
][wRate
-RATE_18M
], bNeedAck
);
457 } else if ((byFBOption
== AUTO_FB_1
) && (wRate
>= RATE_18M
) && (wRate
<=RATE_54M
)) {
458 uDurTime
= uCTSTime
+ 2*pDevice
->uSIFS
+ s_uGetTxRsvTime(pDevice
, byPktType
, cbFrameLength
, wFB_Opt1
[FB_RATE0
][wRate
-RATE_18M
], bNeedAck
);
462 case RTSDUR_AA_F0
: //RTSDuration_aa_f0
463 uCTSTime
= BBuGetFrameTime(pDevice
->byPreambleType
, byPktType
, 14, pDevice
->byTopOFDMBasicRate
);
464 if ((byFBOption
== AUTO_FB_0
) && (wRate
>= RATE_18M
) && (wRate
<=RATE_54M
)) {
465 uDurTime
= uCTSTime
+ 2*pDevice
->uSIFS
+ s_uGetTxRsvTime(pDevice
, byPktType
, cbFrameLength
, wFB_Opt0
[FB_RATE0
][wRate
-RATE_18M
], bNeedAck
);
466 } else if ((byFBOption
== AUTO_FB_1
) && (wRate
>= RATE_18M
) && (wRate
<=RATE_54M
)) {
467 uDurTime
= uCTSTime
+ 2*pDevice
->uSIFS
+ s_uGetTxRsvTime(pDevice
, byPktType
, cbFrameLength
, wFB_Opt1
[FB_RATE0
][wRate
-RATE_18M
], bNeedAck
);
471 case RTSDUR_BA_F1
: //RTSDuration_ba_f1
472 uCTSTime
= BBuGetFrameTime(pDevice
->byPreambleType
, byPktType
, 14, pDevice
->byTopCCKBasicRate
);
473 if ((byFBOption
== AUTO_FB_0
) && (wRate
>= RATE_18M
) && (wRate
<=RATE_54M
)) {
474 uDurTime
= uCTSTime
+ 2*pDevice
->uSIFS
+ s_uGetTxRsvTime(pDevice
, byPktType
, cbFrameLength
, wFB_Opt0
[FB_RATE1
][wRate
-RATE_18M
], bNeedAck
);
475 } else if ((byFBOption
== AUTO_FB_1
) && (wRate
>= RATE_18M
) && (wRate
<=RATE_54M
)) {
476 uDurTime
= uCTSTime
+ 2*pDevice
->uSIFS
+ s_uGetTxRsvTime(pDevice
, byPktType
, cbFrameLength
, wFB_Opt1
[FB_RATE1
][wRate
-RATE_18M
], bNeedAck
);
480 case RTSDUR_AA_F1
: //RTSDuration_aa_f1
481 uCTSTime
= BBuGetFrameTime(pDevice
->byPreambleType
, byPktType
, 14, pDevice
->byTopOFDMBasicRate
);
482 if ((byFBOption
== AUTO_FB_0
) && (wRate
>= RATE_18M
) && (wRate
<=RATE_54M
)) {
483 uDurTime
= uCTSTime
+ 2*pDevice
->uSIFS
+ s_uGetTxRsvTime(pDevice
, byPktType
, cbFrameLength
, wFB_Opt0
[FB_RATE1
][wRate
-RATE_18M
], bNeedAck
);
484 } else if ((byFBOption
== AUTO_FB_1
) && (wRate
>= RATE_18M
) && (wRate
<=RATE_54M
)) {
485 uDurTime
= uCTSTime
+ 2*pDevice
->uSIFS
+ s_uGetTxRsvTime(pDevice
, byPktType
, cbFrameLength
, wFB_Opt1
[FB_RATE1
][wRate
-RATE_18M
], bNeedAck
);
489 case CTSDUR_BA_F0
: //CTSDuration_ba_f0
490 if ((byFBOption
== AUTO_FB_0
) && (wRate
>= RATE_18M
) && (wRate
<=RATE_54M
)) {
491 uDurTime
= pDevice
->uSIFS
+ s_uGetTxRsvTime(pDevice
, byPktType
, cbFrameLength
, wFB_Opt0
[FB_RATE0
][wRate
-RATE_18M
], bNeedAck
);
492 } else if ((byFBOption
== AUTO_FB_1
) && (wRate
>= RATE_18M
) && (wRate
<=RATE_54M
)) {
493 uDurTime
= pDevice
->uSIFS
+ s_uGetTxRsvTime(pDevice
, byPktType
, cbFrameLength
, wFB_Opt1
[FB_RATE0
][wRate
-RATE_18M
], bNeedAck
);
497 case CTSDUR_BA_F1
: //CTSDuration_ba_f1
498 if ((byFBOption
== AUTO_FB_0
) && (wRate
>= RATE_18M
) && (wRate
<=RATE_54M
)) {
499 uDurTime
= pDevice
->uSIFS
+ s_uGetTxRsvTime(pDevice
, byPktType
, cbFrameLength
, wFB_Opt0
[FB_RATE1
][wRate
-RATE_18M
], bNeedAck
);
500 } else if ((byFBOption
== AUTO_FB_1
) && (wRate
>= RATE_18M
) && (wRate
<=RATE_54M
)) {
501 uDurTime
= pDevice
->uSIFS
+ s_uGetTxRsvTime(pDevice
, byPktType
, cbFrameLength
, wFB_Opt1
[FB_RATE1
][wRate
-RATE_18M
], bNeedAck
);
509 return cpu_to_le16((u16
)uDurTime
);
512 static u32
s_uFillDataHead(struct vnt_private
*pDevice
,
513 u8 byPktType
, u16 wCurrentRate
, void *pTxDataHead
, u32 cbFrameLength
,
514 u32 uDMAIdx
, int bNeedAck
, u8 byFBOption
)
517 if (pTxDataHead
== NULL
) {
521 if (byPktType
== PK_TYPE_11GB
|| byPktType
== PK_TYPE_11GA
) {
522 if (byFBOption
== AUTO_FB_NONE
) {
523 struct vnt_tx_datahead_g
*pBuf
=
524 (struct vnt_tx_datahead_g
*)pTxDataHead
;
525 //Get SignalField,ServiceField,Length
526 BBvCalculateParameter(pDevice
, cbFrameLength
, wCurrentRate
,
527 byPktType
, &pBuf
->a
);
528 BBvCalculateParameter(pDevice
, cbFrameLength
,
529 pDevice
->byTopCCKBasicRate
, PK_TYPE_11B
, &pBuf
->b
);
530 //Get Duration and TimeStamp
531 pBuf
->wDuration_a
= s_uGetDataDuration(pDevice
,
532 byPktType
, bNeedAck
);
533 pBuf
->wDuration_b
= s_uGetDataDuration(pDevice
,
534 PK_TYPE_11B
, bNeedAck
);
536 pBuf
->wTimeStampOff_a
= vnt_time_stamp_off(pDevice
,
538 pBuf
->wTimeStampOff_b
= vnt_time_stamp_off(pDevice
,
539 pDevice
->byTopCCKBasicRate
);
540 return (pBuf
->wDuration_a
);
543 struct vnt_tx_datahead_g_fb
*pBuf
=
544 (struct vnt_tx_datahead_g_fb
*)pTxDataHead
;
545 //Get SignalField,ServiceField,Length
546 BBvCalculateParameter(pDevice
, cbFrameLength
, wCurrentRate
,
547 byPktType
, &pBuf
->a
);
548 BBvCalculateParameter(pDevice
, cbFrameLength
,
549 pDevice
->byTopCCKBasicRate
, PK_TYPE_11B
, &pBuf
->b
);
550 //Get Duration and TimeStamp
551 pBuf
->wDuration_a
= s_uGetDataDuration(pDevice
,
552 byPktType
, bNeedAck
);
553 pBuf
->wDuration_b
= s_uGetDataDuration(pDevice
,
554 PK_TYPE_11B
, bNeedAck
);
555 pBuf
->wDuration_a_f0
= s_uGetDataDuration(pDevice
,
556 byPktType
, bNeedAck
);
557 pBuf
->wDuration_a_f1
= s_uGetDataDuration(pDevice
,
558 byPktType
, bNeedAck
);
559 pBuf
->wTimeStampOff_a
= vnt_time_stamp_off(pDevice
,
561 pBuf
->wTimeStampOff_b
= vnt_time_stamp_off(pDevice
,
562 pDevice
->byTopCCKBasicRate
);
563 return (pBuf
->wDuration_a
);
564 } //if (byFBOption == AUTO_FB_NONE)
566 else if (byPktType
== PK_TYPE_11A
) {
567 if (byFBOption
!= AUTO_FB_NONE
) {
568 struct vnt_tx_datahead_a_fb
*pBuf
=
569 (struct vnt_tx_datahead_a_fb
*)pTxDataHead
;
570 //Get SignalField,ServiceField,Length
571 BBvCalculateParameter(pDevice
, cbFrameLength
, wCurrentRate
,
572 byPktType
, &pBuf
->a
);
573 //Get Duration and TimeStampOff
574 pBuf
->wDuration
= s_uGetDataDuration(pDevice
,
575 byPktType
, bNeedAck
);
576 pBuf
->wDuration_f0
= s_uGetDataDuration(pDevice
,
577 byPktType
, bNeedAck
);
578 pBuf
->wDuration_f1
= s_uGetDataDuration(pDevice
,
579 byPktType
, bNeedAck
);
580 pBuf
->wTimeStampOff
= vnt_time_stamp_off(pDevice
,
582 return (pBuf
->wDuration
);
584 struct vnt_tx_datahead_ab
*pBuf
=
585 (struct vnt_tx_datahead_ab
*)pTxDataHead
;
586 //Get SignalField,ServiceField,Length
587 BBvCalculateParameter(pDevice
, cbFrameLength
, wCurrentRate
,
588 byPktType
, &pBuf
->ab
);
589 //Get Duration and TimeStampOff
590 pBuf
->wDuration
= s_uGetDataDuration(pDevice
,
591 byPktType
, bNeedAck
);
592 pBuf
->wTimeStampOff
= vnt_time_stamp_off(pDevice
,
594 return (pBuf
->wDuration
);
597 else if (byPktType
== PK_TYPE_11B
) {
598 struct vnt_tx_datahead_ab
*pBuf
=
599 (struct vnt_tx_datahead_ab
*)pTxDataHead
;
600 //Get SignalField,ServiceField,Length
601 BBvCalculateParameter(pDevice
, cbFrameLength
, wCurrentRate
,
602 byPktType
, &pBuf
->ab
);
603 //Get Duration and TimeStampOff
604 pBuf
->wDuration
= s_uGetDataDuration(pDevice
,
605 byPktType
, bNeedAck
);
606 pBuf
->wTimeStampOff
= vnt_time_stamp_off(pDevice
,
608 return (pBuf
->wDuration
);
613 static int vnt_fill_ieee80211_rts(struct vnt_private
*priv
,
614 struct ieee80211_rts
*rts
, struct ethhdr
*eth_hdr
,
617 rts
->duration
= duration
;
618 rts
->frame_control
= TYPE_CTL_RTS
;
620 if (priv
->eOPMode
== OP_MODE_ADHOC
|| priv
->eOPMode
== OP_MODE_AP
)
621 memcpy(rts
->ra
, eth_hdr
->h_dest
, ETH_ALEN
);
623 memcpy(rts
->ra
, priv
->abyBSSID
, ETH_ALEN
);
625 if (priv
->eOPMode
== OP_MODE_AP
)
626 memcpy(rts
->ta
, priv
->abyBSSID
, ETH_ALEN
);
628 memcpy(rts
->ta
, eth_hdr
->h_source
, ETH_ALEN
);
633 static int vnt_rxtx_rts_g_head(struct vnt_private
*priv
,
634 struct vnt_rts_g
*buf
, struct ethhdr
*eth_hdr
,
635 u8 pkt_type
, u32 frame_len
, int need_ack
,
636 u16 current_rate
, u8 fb_option
)
638 u16 rts_frame_len
= 20;
640 BBvCalculateParameter(priv
, rts_frame_len
, priv
->byTopCCKBasicRate
,
641 PK_TYPE_11B
, &buf
->b
);
642 BBvCalculateParameter(priv
, rts_frame_len
,
643 priv
->byTopOFDMBasicRate
, pkt_type
, &buf
->a
);
645 buf
->wDuration_bb
= s_uGetRTSCTSDuration(priv
, RTSDUR_BB
, frame_len
,
646 PK_TYPE_11B
, priv
->byTopCCKBasicRate
, need_ack
, fb_option
);
647 buf
->wDuration_aa
= s_uGetRTSCTSDuration(priv
, RTSDUR_AA
, frame_len
,
648 pkt_type
, current_rate
, need_ack
, fb_option
);
649 buf
->wDuration_ba
= s_uGetRTSCTSDuration(priv
, RTSDUR_BA
, frame_len
,
650 pkt_type
, current_rate
, need_ack
, fb_option
);
652 vnt_fill_ieee80211_rts(priv
, &buf
->data
, eth_hdr
, buf
->wDuration_aa
);
657 static int vnt_rxtx_rts_g_fb_head(struct vnt_private
*priv
,
658 struct vnt_rts_g_fb
*buf
, struct ethhdr
*eth_hdr
,
659 u8 pkt_type
, u32 frame_len
, int need_ack
,
660 u16 current_rate
, u8 fb_option
)
662 u16 rts_frame_len
= 20;
664 BBvCalculateParameter(priv
, rts_frame_len
, priv
->byTopCCKBasicRate
,
665 PK_TYPE_11B
, &buf
->b
);
666 BBvCalculateParameter(priv
, rts_frame_len
,
667 priv
->byTopOFDMBasicRate
, pkt_type
, &buf
->a
);
670 buf
->wDuration_bb
= s_uGetRTSCTSDuration(priv
, RTSDUR_BB
, frame_len
,
671 PK_TYPE_11B
, priv
->byTopCCKBasicRate
, need_ack
, fb_option
);
672 buf
->wDuration_aa
= s_uGetRTSCTSDuration(priv
, RTSDUR_AA
, frame_len
,
673 pkt_type
, current_rate
, need_ack
, fb_option
);
674 buf
->wDuration_ba
= s_uGetRTSCTSDuration(priv
, RTSDUR_BA
, frame_len
,
675 pkt_type
, current_rate
, need_ack
, fb_option
);
678 buf
->wRTSDuration_ba_f0
= s_uGetRTSCTSDuration(priv
, RTSDUR_BA_F0
,
679 frame_len
, pkt_type
, current_rate
, need_ack
, fb_option
);
680 buf
->wRTSDuration_aa_f0
= s_uGetRTSCTSDuration(priv
, RTSDUR_AA_F0
,
681 frame_len
, pkt_type
, current_rate
, need_ack
, fb_option
);
682 buf
->wRTSDuration_ba_f1
= s_uGetRTSCTSDuration(priv
, RTSDUR_BA_F1
,
683 frame_len
, pkt_type
, current_rate
, need_ack
, fb_option
);
684 buf
->wRTSDuration_aa_f1
= s_uGetRTSCTSDuration(priv
, RTSDUR_AA_F1
,
685 frame_len
, pkt_type
, current_rate
, need_ack
, fb_option
);
687 vnt_fill_ieee80211_rts(priv
, &buf
->data
, eth_hdr
, buf
->wDuration_aa
);
692 static int vnt_rxtx_rts_ab_head(struct vnt_private
*priv
,
693 struct vnt_rts_ab
*buf
, struct ethhdr
*eth_hdr
,
694 u8 pkt_type
, u32 frame_len
, int need_ack
,
695 u16 current_rate
, u8 fb_option
)
697 u16 rts_frame_len
= 20;
699 BBvCalculateParameter(priv
, rts_frame_len
,
700 priv
->byTopOFDMBasicRate
, pkt_type
, &buf
->ab
);
702 buf
->wDuration
= s_uGetRTSCTSDuration(priv
, RTSDUR_AA
, frame_len
,
703 pkt_type
, current_rate
, need_ack
, fb_option
);
705 vnt_fill_ieee80211_rts(priv
, &buf
->data
, eth_hdr
, buf
->wDuration
);
710 static int vnt_rxtx_rts_a_fb_head(struct vnt_private
*priv
,
711 struct vnt_rts_a_fb
*buf
, struct ethhdr
*eth_hdr
,
712 u8 pkt_type
, u32 frame_len
, int need_ack
,
713 u16 current_rate
, u8 fb_option
)
715 u16 rts_frame_len
= 20;
717 BBvCalculateParameter(priv
, rts_frame_len
,
718 priv
->byTopOFDMBasicRate
, pkt_type
, &buf
->a
);
720 buf
->wDuration
= s_uGetRTSCTSDuration(priv
, RTSDUR_AA
, frame_len
,
721 pkt_type
, current_rate
, need_ack
, fb_option
);
723 buf
->wRTSDuration_f0
= s_uGetRTSCTSDuration(priv
, RTSDUR_AA_F0
,
724 frame_len
, pkt_type
, current_rate
, need_ack
, fb_option
);
726 buf
->wRTSDuration_f1
= s_uGetRTSCTSDuration(priv
, RTSDUR_AA_F1
,
727 frame_len
, pkt_type
, current_rate
, need_ack
, fb_option
);
729 vnt_fill_ieee80211_rts(priv
, &buf
->data
, eth_hdr
, buf
->wDuration
);
734 static void s_vFillRTSHead(struct vnt_private
*pDevice
, u8 byPktType
,
735 union vnt_tx_data_head
*head
, u32 cbFrameLength
, int bNeedAck
,
736 struct ethhdr
*psEthHeader
, u16 wCurrentRate
, u8 byFBOption
)
742 /* Note: So far RTSHead doesn't appear in ATIM
743 * & Beacom DMA, so we don't need to take them
745 * Otherwise, we need to modified codes for them.
750 if (byFBOption
== AUTO_FB_NONE
)
751 vnt_rxtx_rts_g_head(pDevice
, &head
->rts_g
,
752 psEthHeader
, byPktType
, cbFrameLength
,
753 bNeedAck
, wCurrentRate
, byFBOption
);
755 vnt_rxtx_rts_g_fb_head(pDevice
, &head
->rts_g_fb
,
756 psEthHeader
, byPktType
, cbFrameLength
,
757 bNeedAck
, wCurrentRate
, byFBOption
);
761 vnt_rxtx_rts_a_fb_head(pDevice
, &head
->rts_a_fb
,
762 psEthHeader
, byPktType
, cbFrameLength
,
763 bNeedAck
, wCurrentRate
, byFBOption
);
767 vnt_rxtx_rts_ab_head(pDevice
, &head
->rts_ab
,
768 psEthHeader
, byPktType
, cbFrameLength
,
769 bNeedAck
, wCurrentRate
, byFBOption
);
773 static void s_vFillCTSHead(struct vnt_private
*pDevice
, u32 uDMAIdx
,
774 u8 byPktType
, union vnt_tx_data_head
*head
, u32 cbFrameLength
,
775 int bNeedAck
, u16 wCurrentRate
, u8 byFBOption
)
777 u32 uCTSFrameLen
= 14;
782 if (byFBOption
!= AUTO_FB_NONE
) {
784 struct vnt_cts_fb
*pBuf
= &head
->cts_g_fb
;
785 /* Get SignalField,ServiceField,Length */
786 BBvCalculateParameter(pDevice
, uCTSFrameLen
,
787 pDevice
->byTopCCKBasicRate
, PK_TYPE_11B
, &pBuf
->b
);
788 pBuf
->wDuration_ba
= s_uGetRTSCTSDuration(pDevice
, CTSDUR_BA
,
789 cbFrameLength
, byPktType
,
790 wCurrentRate
, bNeedAck
, byFBOption
);
791 /* Get CTSDuration_ba_f0 */
792 pBuf
->wCTSDuration_ba_f0
= s_uGetRTSCTSDuration(pDevice
,
793 CTSDUR_BA_F0
, cbFrameLength
, byPktType
, wCurrentRate
,
794 bNeedAck
, byFBOption
);
795 /* Get CTSDuration_ba_f1 */
796 pBuf
->wCTSDuration_ba_f1
= s_uGetRTSCTSDuration(pDevice
,
797 CTSDUR_BA_F1
, cbFrameLength
, byPktType
, wCurrentRate
,
798 bNeedAck
, byFBOption
);
799 /* Get CTS Frame body */
800 pBuf
->data
.duration
= pBuf
->wDuration_ba
;
801 pBuf
->data
.frame_control
= TYPE_CTL_CTS
;
802 memcpy(pBuf
->data
.ra
, pDevice
->abyCurrentNetAddr
, ETH_ALEN
);
804 struct vnt_cts
*pBuf
= &head
->cts_g
;
805 /* Get SignalField,ServiceField,Length */
806 BBvCalculateParameter(pDevice
, uCTSFrameLen
,
807 pDevice
->byTopCCKBasicRate
, PK_TYPE_11B
, &pBuf
->b
);
808 /* Get CTSDuration_ba */
809 pBuf
->wDuration_ba
= s_uGetRTSCTSDuration(pDevice
,
810 CTSDUR_BA
, cbFrameLength
, byPktType
,
811 wCurrentRate
, bNeedAck
, byFBOption
);
812 /*Get CTS Frame body*/
813 pBuf
->data
.duration
= pBuf
->wDuration_ba
;
814 pBuf
->data
.frame_control
= TYPE_CTL_CTS
;
815 memcpy(pBuf
->data
.ra
, pDevice
->abyCurrentNetAddr
, ETH_ALEN
);
822 * Generate FIFO control for MAC & Baseband controller
826 * pDevice - Pointer to adpater
827 * pTxDataHead - Transmit Data Buffer
828 * pTxBufHead - pTxBufHead
829 * pvRrvTime - pvRrvTime
832 * cbFrameSize - Transmit Data Length (Hdr+Payload+FCS)
833 * bNeedACK - If need ACK
834 * uDMAIdx - DMA Index
842 static void s_vGenerateTxParameter(struct vnt_private
*pDevice
,
843 u8 byPktType
, u16 wCurrentRate
, void *pTxBufHead
, void *pvRrvTime
,
844 void *rts_cts
, u32 cbFrameSize
, int bNeedACK
, u32 uDMAIdx
,
845 struct ethhdr
*psEthHeader
, bool need_rts
)
847 struct vnt_tx_fifo_head
*pFifoHead
=
848 (struct vnt_tx_fifo_head
*)pTxBufHead
;
849 union vnt_tx_data_head
*head
= rts_cts
;
850 u32 cbMACHdLen
= WLAN_HDR_ADDR3_LEN
; /* 24 */
852 u8 byFBOption
= AUTO_FB_NONE
;
854 //DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"s_vGenerateTxParameter...\n");
855 pFifoHead
->wReserved
= wCurrentRate
;
856 wFifoCtl
= pFifoHead
->wFIFOCtl
;
858 if (wFifoCtl
& FIFOCTL_AUTO_FB_0
) {
859 byFBOption
= AUTO_FB_0
;
861 else if (wFifoCtl
& FIFOCTL_AUTO_FB_1
) {
862 byFBOption
= AUTO_FB_1
;
868 if (pDevice
->bLongHeader
)
869 cbMACHdLen
= WLAN_HDR_ADDR3_LEN
+ 6;
871 if (byPktType
== PK_TYPE_11GB
|| byPktType
== PK_TYPE_11GA
) {
874 struct vnt_rrv_time_rts
*pBuf
=
875 (struct vnt_rrv_time_rts
*)pvRrvTime
;
876 pBuf
->wRTSTxRrvTime_aa
= s_uGetRTSCTSRsvTime(pDevice
, 2,
877 byPktType
, cbFrameSize
, wCurrentRate
);
878 pBuf
->wRTSTxRrvTime_ba
= s_uGetRTSCTSRsvTime(pDevice
, 1,
879 byPktType
, cbFrameSize
, wCurrentRate
);
880 pBuf
->wRTSTxRrvTime_bb
= s_uGetRTSCTSRsvTime(pDevice
, 0,
881 byPktType
, cbFrameSize
, wCurrentRate
);
882 pBuf
->wTxRrvTime_a
= vnt_rxtx_rsvtime_le16(pDevice
,
883 byPktType
, cbFrameSize
, wCurrentRate
, bNeedACK
);
884 pBuf
->wTxRrvTime_b
= vnt_rxtx_rsvtime_le16(pDevice
,
885 PK_TYPE_11B
, cbFrameSize
, pDevice
->byTopCCKBasicRate
,
888 s_vFillRTSHead(pDevice
, byPktType
, head
, cbFrameSize
,
889 bNeedACK
, psEthHeader
, wCurrentRate
, byFBOption
);
891 else {//RTS_needless, PCF mode
893 struct vnt_rrv_time_cts
*pBuf
=
894 (struct vnt_rrv_time_cts
*)pvRrvTime
;
895 pBuf
->wTxRrvTime_a
= vnt_rxtx_rsvtime_le16(pDevice
, byPktType
,
896 cbFrameSize
, wCurrentRate
, bNeedACK
);
897 pBuf
->wTxRrvTime_b
= vnt_rxtx_rsvtime_le16(pDevice
,
898 PK_TYPE_11B
, cbFrameSize
,
899 pDevice
->byTopCCKBasicRate
, bNeedACK
);
900 pBuf
->wCTSTxRrvTime_ba
= s_uGetRTSCTSRsvTime(pDevice
, 3,
901 byPktType
, cbFrameSize
, wCurrentRate
);
903 s_vFillCTSHead(pDevice
, uDMAIdx
, byPktType
, head
,
904 cbFrameSize
, bNeedACK
, wCurrentRate
, byFBOption
);
907 else if (byPktType
== PK_TYPE_11A
) {
910 struct vnt_rrv_time_ab
*pBuf
=
911 (struct vnt_rrv_time_ab
*)pvRrvTime
;
912 pBuf
->wRTSTxRrvTime
= s_uGetRTSCTSRsvTime(pDevice
, 2,
913 byPktType
, cbFrameSize
, wCurrentRate
);
914 pBuf
->wTxRrvTime
= vnt_rxtx_rsvtime_le16(pDevice
, byPktType
,
915 cbFrameSize
, wCurrentRate
, bNeedACK
);
917 s_vFillRTSHead(pDevice
, byPktType
, head
, cbFrameSize
,
918 bNeedACK
, psEthHeader
, wCurrentRate
, byFBOption
);
921 struct vnt_rrv_time_ab
*pBuf
=
922 (struct vnt_rrv_time_ab
*)pvRrvTime
;
923 pBuf
->wTxRrvTime
= vnt_rxtx_rsvtime_le16(pDevice
, PK_TYPE_11A
,
924 cbFrameSize
, wCurrentRate
, bNeedACK
);
927 else if (byPktType
== PK_TYPE_11B
) {
930 struct vnt_rrv_time_ab
*pBuf
=
931 (struct vnt_rrv_time_ab
*)pvRrvTime
;
932 pBuf
->wRTSTxRrvTime
= s_uGetRTSCTSRsvTime(pDevice
, 0,
933 byPktType
, cbFrameSize
, wCurrentRate
);
934 pBuf
->wTxRrvTime
= vnt_rxtx_rsvtime_le16(pDevice
, PK_TYPE_11B
,
935 cbFrameSize
, wCurrentRate
, bNeedACK
);
937 s_vFillRTSHead(pDevice
, byPktType
, head
, cbFrameSize
,
938 bNeedACK
, psEthHeader
, wCurrentRate
, byFBOption
);
940 else { //RTS_needless, non PCF mode
942 struct vnt_rrv_time_ab
*pBuf
=
943 (struct vnt_rrv_time_ab
*)pvRrvTime
;
944 pBuf
->wTxRrvTime
= vnt_rxtx_rsvtime_le16(pDevice
, PK_TYPE_11B
,
945 cbFrameSize
, wCurrentRate
, bNeedACK
);
948 //DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"s_vGenerateTxParameter END.\n");
951 u8 * pbyBuffer,//point to pTxBufHead
952 u16 wFragType,//00:Non-Frag, 01:Start, 02:Mid, 03:Last
953 unsigned int cbFragmentSize,//Hdr+payoad+FCS
956 static int s_bPacketToWirelessUsb(struct vnt_private
*pDevice
, u8 byPktType
,
957 struct vnt_tx_buffer
*tx_buffer
, int bNeedEncryption
,
958 u32 uSkbPacketLen
, u32 uDMAIdx
, struct ethhdr
*psEthHeader
,
959 u8
*pPacket
, PSKeyItem pTransmitKey
, u32 uNodeIndex
, u16 wCurrentRate
,
960 u32
*pcbHeaderLen
, u32
*pcbTotalLen
)
962 struct vnt_tx_fifo_head
*pTxBufHead
= &tx_buffer
->fifo_head
;
963 struct vnt_manager
*pMgmt
= &pDevice
->vnt_mgmt
;
964 u32 cbFrameSize
, cbFrameBodySize
;
966 u32 cbIVlen
= 0, cbICVlen
= 0, cbMIClen
= 0, cbMACHdLen
= 0;
967 u32 cbFCSlen
= 4, cbMICHDR
= 0;
970 u8
*pbyType
, *pbyMacHdr
, *pbyIVHead
, *pbyPayloadHead
, *pbyTxBufferAddr
;
971 u8 abySNAP_RFC1042
[ETH_ALEN
] = {0xAA, 0xAA, 0x03, 0x00, 0x00, 0x00};
972 u8 abySNAP_Bridgetunnel
[ETH_ALEN
]
973 = {0xAA, 0xAA, 0x03, 0x00, 0x00, 0xF8};
975 u32 cbHeaderLength
= 0, uPadding
= 0;
977 struct vnt_mic_hdr
*pMICHDR
;
978 void *rts_cts
= NULL
;
980 u8 byFBOption
= AUTO_FB_NONE
, byFragType
;
982 u32 dwMICKey0
, dwMICKey1
, dwMIC_Priority
;
983 u32
*pdwMIC_L
, *pdwMIC_R
;
984 int bSoftWEP
= false;
985 pvRrvTime
= pMICHDR
= pvTxDataHd
= NULL
;
987 if (bNeedEncryption
&& pTransmitKey
->pvKeyTable
) {
988 if (((PSKeyTable
)pTransmitKey
->pvKeyTable
)->bSoftWEP
== true)
989 bSoftWEP
= true; /* WEP 256 */
993 if (ntohs(psEthHeader
->h_proto
) > ETH_DATA_LEN
) {
994 if (pDevice
->dwDiagRefCount
== 0) {
1003 cbFrameBodySize
= uSkbPacketLen
- ETH_HLEN
+ cb802_1_H_len
;
1006 pTxBufHead
->wFIFOCtl
|= (u16
)(byPktType
<<8);
1008 if (pDevice
->dwDiagRefCount
!= 0) {
1010 pTxBufHead
->wFIFOCtl
= pTxBufHead
->wFIFOCtl
& (~FIFOCTL_NEEDACK
);
1011 } else { //if (pDevice->dwDiagRefCount != 0) {
1012 if ((pDevice
->eOPMode
== OP_MODE_ADHOC
) ||
1013 (pDevice
->eOPMode
== OP_MODE_AP
)) {
1014 if (is_multicast_ether_addr(psEthHeader
->h_dest
)) {
1016 pTxBufHead
->wFIFOCtl
=
1017 pTxBufHead
->wFIFOCtl
& (~FIFOCTL_NEEDACK
);
1020 pTxBufHead
->wFIFOCtl
|= FIFOCTL_NEEDACK
;
1024 // MSDUs in Infra mode always need ACK
1026 pTxBufHead
->wFIFOCtl
|= FIFOCTL_NEEDACK
;
1028 } //if (pDevice->dwDiagRefCount != 0) {
1030 pTxBufHead
->wTimeStamp
= DEFAULT_MSDU_LIFETIME_RES_64us
;
1033 if (pDevice
->bLongHeader
)
1034 pTxBufHead
->wFIFOCtl
|= FIFOCTL_LHEAD
;
1036 //Set FRAGCTL_MACHDCNT
1037 if (pDevice
->bLongHeader
) {
1038 cbMACHdLen
= WLAN_HDR_ADDR3_LEN
+ 6;
1040 cbMACHdLen
= WLAN_HDR_ADDR3_LEN
;
1042 pTxBufHead
->wFragCtl
|= (u16
)(cbMACHdLen
<< 10);
1044 //Set FIFOCTL_GrpAckPolicy
1045 if (pDevice
->bGrpAckPolicy
== true) {//0000 0100 0000 0000
1046 pTxBufHead
->wFIFOCtl
|= FIFOCTL_GRPACK
;
1049 //Set Auto Fallback Ctl
1050 if (wCurrentRate
>= RATE_18M
) {
1051 if (pDevice
->byAutoFBCtrl
== AUTO_FB_0
) {
1052 pTxBufHead
->wFIFOCtl
|= FIFOCTL_AUTO_FB_0
;
1053 byFBOption
= AUTO_FB_0
;
1054 } else if (pDevice
->byAutoFBCtrl
== AUTO_FB_1
) {
1055 pTxBufHead
->wFIFOCtl
|= FIFOCTL_AUTO_FB_1
;
1056 byFBOption
= AUTO_FB_1
;
1060 if (bSoftWEP
!= true) {
1061 if ((bNeedEncryption
) && (pTransmitKey
!= NULL
)) { //WEP enabled
1062 if (pTransmitKey
->byCipherSuite
== KEY_CTL_WEP
) { //WEP40 or WEP104
1063 pTxBufHead
->wFragCtl
|= FRAGCTL_LEGACY
;
1065 if (pTransmitKey
->byCipherSuite
== KEY_CTL_TKIP
) {
1066 DBG_PRT(MSG_LEVEL_DEBUG
, KERN_INFO
"Tx Set wFragCtl == FRAGCTL_TKIP\n");
1067 pTxBufHead
->wFragCtl
|= FRAGCTL_TKIP
;
1069 else if (pTransmitKey
->byCipherSuite
== KEY_CTL_CCMP
) { //CCMP
1070 pTxBufHead
->wFragCtl
|= FRAGCTL_AES
;
1075 if ((bNeedEncryption
) && (pTransmitKey
!= NULL
)) {
1076 if (pTransmitKey
->byCipherSuite
== KEY_CTL_WEP
) {
1080 else if (pTransmitKey
->byCipherSuite
== KEY_CTL_TKIP
) {
1081 cbIVlen
= 8;//IV+ExtIV
1085 if (pTransmitKey
->byCipherSuite
== KEY_CTL_CCMP
) {
1086 cbIVlen
= 8;//RSN Header
1088 cbMICHDR
= sizeof(struct vnt_mic_hdr
);
1090 if (bSoftWEP
== false) {
1091 //MAC Header should be padding 0 to DW alignment.
1092 uPadding
= 4 - (cbMACHdLen
%4);
1097 cbFrameSize
= cbMACHdLen
+ cbIVlen
+ (cbFrameBodySize
+ cbMIClen
) + cbICVlen
+ cbFCSlen
;
1099 if ( (bNeedACK
== false) ||(cbFrameSize
< pDevice
->wRTSThreshold
) ) {
1103 pTxBufHead
->wFIFOCtl
|= (FIFOCTL_RTS
| FIFOCTL_LRETRY
);
1106 pbyTxBufferAddr
= (u8
*) &(pTxBufHead
->adwTxKey
[0]);
1107 wTxBufSize
= sizeof(struct vnt_tx_fifo_head
);
1109 if (byPktType
== PK_TYPE_11GB
|| byPktType
== PK_TYPE_11GA
) {//802.11g packet
1110 if (byFBOption
== AUTO_FB_NONE
) {
1111 if (bRTS
== true) {//RTS_need
1112 pvRrvTime
= (struct vnt_rrv_time_rts
*)
1113 (pbyTxBufferAddr
+ wTxBufSize
);
1114 pMICHDR
= (struct vnt_mic_hdr
*)(pbyTxBufferAddr
+ wTxBufSize
+
1115 sizeof(struct vnt_rrv_time_rts
));
1116 rts_cts
= (struct vnt_rts_g
*) (pbyTxBufferAddr
+ wTxBufSize
+
1117 sizeof(struct vnt_rrv_time_rts
) + cbMICHDR
);
1118 pvTxDataHd
= (struct vnt_tx_datahead_g
*) (pbyTxBufferAddr
+
1119 wTxBufSize
+ sizeof(struct vnt_rrv_time_rts
) +
1120 cbMICHDR
+ sizeof(struct vnt_rts_g
));
1121 cbHeaderLength
= wTxBufSize
+ sizeof(struct vnt_rrv_time_rts
) +
1122 cbMICHDR
+ sizeof(struct vnt_rts_g
) +
1123 sizeof(struct vnt_tx_datahead_g
);
1125 else { //RTS_needless
1126 pvRrvTime
= (struct vnt_rrv_time_cts
*)
1127 (pbyTxBufferAddr
+ wTxBufSize
);
1128 pMICHDR
= (struct vnt_mic_hdr
*) (pbyTxBufferAddr
+ wTxBufSize
+
1129 sizeof(struct vnt_rrv_time_cts
));
1130 rts_cts
= (struct vnt_cts
*) (pbyTxBufferAddr
+ wTxBufSize
+
1131 sizeof(struct vnt_rrv_time_cts
) + cbMICHDR
);
1132 pvTxDataHd
= (struct vnt_tx_datahead_g
*)(pbyTxBufferAddr
+
1133 wTxBufSize
+ sizeof(struct vnt_rrv_time_cts
) +
1134 cbMICHDR
+ sizeof(struct vnt_cts
));
1135 cbHeaderLength
= wTxBufSize
+ sizeof(struct vnt_rrv_time_cts
) +
1136 cbMICHDR
+ sizeof(struct vnt_cts
) +
1137 sizeof(struct vnt_tx_datahead_g
);
1141 if (bRTS
== true) {//RTS_need
1142 pvRrvTime
= (struct vnt_rrv_time_rts
*)(pbyTxBufferAddr
+
1144 pMICHDR
= (struct vnt_mic_hdr
*) (pbyTxBufferAddr
+ wTxBufSize
+
1145 sizeof(struct vnt_rrv_time_rts
));
1146 rts_cts
= (struct vnt_rts_g_fb
*)(pbyTxBufferAddr
+ wTxBufSize
+
1147 sizeof(struct vnt_rrv_time_rts
) + cbMICHDR
);
1148 pvTxDataHd
= (struct vnt_tx_datahead_g_fb
*) (pbyTxBufferAddr
+
1149 wTxBufSize
+ sizeof(struct vnt_rrv_time_rts
) +
1150 cbMICHDR
+ sizeof(struct vnt_rts_g_fb
));
1151 cbHeaderLength
= wTxBufSize
+ sizeof(struct vnt_rrv_time_rts
) +
1152 cbMICHDR
+ sizeof(struct vnt_rts_g_fb
) +
1153 sizeof(struct vnt_tx_datahead_g_fb
);
1155 else if (bRTS
== false) { //RTS_needless
1156 pvRrvTime
= (struct vnt_rrv_time_cts
*)
1157 (pbyTxBufferAddr
+ wTxBufSize
);
1158 pMICHDR
= (struct vnt_mic_hdr
*) (pbyTxBufferAddr
+ wTxBufSize
+
1159 sizeof(struct vnt_rrv_time_cts
));
1160 rts_cts
= (struct vnt_cts_fb
*) (pbyTxBufferAddr
+ wTxBufSize
+
1161 sizeof(struct vnt_rrv_time_cts
) + cbMICHDR
);
1162 pvTxDataHd
= (struct vnt_tx_datahead_g_fb
*) (pbyTxBufferAddr
+
1163 wTxBufSize
+ sizeof(struct vnt_rrv_time_cts
) +
1164 cbMICHDR
+ sizeof(struct vnt_cts_fb
));
1165 cbHeaderLength
= wTxBufSize
+ sizeof(struct vnt_rrv_time_cts
) +
1166 cbMICHDR
+ sizeof(struct vnt_cts_fb
) +
1167 sizeof(struct vnt_tx_datahead_g_fb
);
1171 else {//802.11a/b packet
1172 if (byFBOption
== AUTO_FB_NONE
) {
1173 if (bRTS
== true) {//RTS_need
1174 pvRrvTime
= (struct vnt_rrv_time_ab
*) (pbyTxBufferAddr
+
1176 pMICHDR
= (struct vnt_mic_hdr
*)(pbyTxBufferAddr
+ wTxBufSize
+
1177 sizeof(struct vnt_rrv_time_ab
));
1178 rts_cts
= (struct vnt_rts_ab
*) (pbyTxBufferAddr
+ wTxBufSize
+
1179 sizeof(struct vnt_rrv_time_ab
) + cbMICHDR
);
1180 pvTxDataHd
= (struct vnt_tx_datahead_ab
*)(pbyTxBufferAddr
+
1181 wTxBufSize
+ sizeof(struct vnt_rrv_time_ab
) + cbMICHDR
+
1182 sizeof(struct vnt_rts_ab
));
1183 cbHeaderLength
= wTxBufSize
+ sizeof(struct vnt_rrv_time_ab
) +
1184 cbMICHDR
+ sizeof(struct vnt_rts_ab
) +
1185 sizeof(struct vnt_tx_datahead_ab
);
1187 else if (bRTS
== false) { //RTS_needless, no MICHDR
1188 pvRrvTime
= (struct vnt_rrv_time_ab
*)(pbyTxBufferAddr
+
1190 pMICHDR
= (struct vnt_mic_hdr
*) (pbyTxBufferAddr
+ wTxBufSize
+
1191 sizeof(struct vnt_rrv_time_ab
));
1192 pvTxDataHd
= (struct vnt_tx_datahead_ab
*)(pbyTxBufferAddr
+
1193 wTxBufSize
+ sizeof(struct vnt_rrv_time_ab
) + cbMICHDR
);
1194 cbHeaderLength
= wTxBufSize
+ sizeof(struct vnt_rrv_time_ab
) +
1195 cbMICHDR
+ sizeof(struct vnt_tx_datahead_ab
);
1199 if (bRTS
== true) {//RTS_need
1200 pvRrvTime
= (struct vnt_rrv_time_ab
*)(pbyTxBufferAddr
+
1202 pMICHDR
= (struct vnt_mic_hdr
*) (pbyTxBufferAddr
+ wTxBufSize
+
1203 sizeof(struct vnt_rrv_time_ab
));
1204 rts_cts
= (struct vnt_rts_a_fb
*)(pbyTxBufferAddr
+ wTxBufSize
+
1205 sizeof(struct vnt_rrv_time_ab
) + cbMICHDR
);
1206 pvTxDataHd
= (struct vnt_tx_datahead_a_fb
*)(pbyTxBufferAddr
+
1207 wTxBufSize
+ sizeof(struct vnt_rrv_time_ab
) + cbMICHDR
+
1208 sizeof(struct vnt_rts_a_fb
));
1209 cbHeaderLength
= wTxBufSize
+ sizeof(struct vnt_rrv_time_ab
) +
1210 cbMICHDR
+ sizeof(struct vnt_rts_a_fb
) +
1211 sizeof(struct vnt_tx_datahead_a_fb
);
1213 else if (bRTS
== false) { //RTS_needless
1214 pvRrvTime
= (struct vnt_rrv_time_ab
*)(pbyTxBufferAddr
+
1216 pMICHDR
= (struct vnt_mic_hdr
*)(pbyTxBufferAddr
+ wTxBufSize
+
1217 sizeof(struct vnt_rrv_time_ab
));
1218 pvTxDataHd
= (struct vnt_tx_datahead_a_fb
*)(pbyTxBufferAddr
+
1219 wTxBufSize
+ sizeof(struct vnt_rrv_time_ab
) + cbMICHDR
);
1220 cbHeaderLength
= wTxBufSize
+ sizeof(struct vnt_rrv_time_ab
) +
1221 cbMICHDR
+ sizeof(struct vnt_tx_datahead_a_fb
);
1226 pbyMacHdr
= (u8
*)(pbyTxBufferAddr
+ cbHeaderLength
);
1227 pbyIVHead
= (u8
*)(pbyMacHdr
+ cbMACHdLen
+ uPadding
);
1228 pbyPayloadHead
= (u8
*)(pbyMacHdr
+ cbMACHdLen
+ uPadding
+ cbIVlen
);
1230 //=========================
1232 //=========================
1233 DBG_PRT(MSG_LEVEL_DEBUG
, KERN_INFO
"No Fragmentation...\n");
1234 byFragType
= FRAGCTL_NONFRAG
;
1235 //uDMAIdx = TYPE_AC0DMA;
1236 //pTxBufHead = (PSTxBufHead) &(pTxBufHead->adwTxKey[0]);
1238 //Fill FIFO,RrvTime,RTS,and CTS
1239 s_vGenerateTxParameter(pDevice
, byPktType
, wCurrentRate
,
1240 (void *)pbyTxBufferAddr
, pvRrvTime
, rts_cts
,
1241 cbFrameSize
, bNeedACK
, uDMAIdx
, psEthHeader
, bRTS
);
1243 uDuration
= s_uFillDataHead(pDevice
, byPktType
, wCurrentRate
, pvTxDataHd
, cbFrameSize
, uDMAIdx
, bNeedACK
,
1245 // Generate TX MAC Header
1246 s_vGenerateMACHeader(pDevice
, pbyMacHdr
, (u16
)uDuration
, psEthHeader
, bNeedEncryption
,
1247 byFragType
, uDMAIdx
, 0);
1249 if (bNeedEncryption
== true) {
1251 s_vFillTxKey(pDevice
, (u8
*)(pTxBufHead
->adwTxKey
), pbyIVHead
, pTransmitKey
,
1252 pbyMacHdr
, (u16
)cbFrameBodySize
, pMICHDR
);
1254 if (pDevice
->bEnableHostWEP
) {
1255 pMgmt
->sNodeDBTable
[uNodeIndex
].dwTSC47_16
= pTransmitKey
->dwTSC47_16
;
1256 pMgmt
->sNodeDBTable
[uNodeIndex
].wTSC15_0
= pTransmitKey
->wTSC15_0
;
1261 if (ntohs(psEthHeader
->h_proto
) > ETH_DATA_LEN
) {
1262 if (pDevice
->dwDiagRefCount
== 0) {
1263 if ((psEthHeader
->h_proto
== cpu_to_be16(ETH_P_IPX
)) ||
1264 (psEthHeader
->h_proto
== cpu_to_le16(0xF380))) {
1265 memcpy((u8
*) (pbyPayloadHead
),
1266 abySNAP_Bridgetunnel
, 6);
1268 memcpy((u8
*) (pbyPayloadHead
), &abySNAP_RFC1042
[0], 6);
1270 pbyType
= (u8
*) (pbyPayloadHead
+ 6);
1271 memcpy(pbyType
, &(psEthHeader
->h_proto
), sizeof(u16
));
1273 memcpy((u8
*) (pbyPayloadHead
), &(psEthHeader
->h_proto
), sizeof(u16
));
1279 if (pPacket
!= NULL
) {
1280 // Copy the Packet into a tx Buffer
1281 memcpy((pbyPayloadHead
+ cb802_1_H_len
),
1282 (pPacket
+ ETH_HLEN
),
1283 uSkbPacketLen
- ETH_HLEN
1287 // while bRelayPacketSend psEthHeader is point to header+payload
1288 memcpy((pbyPayloadHead
+ cb802_1_H_len
), ((u8
*)psEthHeader
) + ETH_HLEN
, uSkbPacketLen
- ETH_HLEN
);
1291 if ((bNeedEncryption
== true) && (pTransmitKey
!= NULL
) && (pTransmitKey
->byCipherSuite
== KEY_CTL_TKIP
)) {
1293 ///////////////////////////////////////////////////////////////////
1295 if (pDevice
->vnt_mgmt
.eAuthenMode
== WMAC_AUTH_WPANONE
) {
1296 dwMICKey0
= *(u32
*)(&pTransmitKey
->abyKey
[16]);
1297 dwMICKey1
= *(u32
*)(&pTransmitKey
->abyKey
[20]);
1299 else if ((pTransmitKey
->dwKeyIndex
& AUTHENTICATOR_KEY
) != 0) {
1300 dwMICKey0
= *(u32
*)(&pTransmitKey
->abyKey
[16]);
1301 dwMICKey1
= *(u32
*)(&pTransmitKey
->abyKey
[20]);
1304 dwMICKey0
= *(u32
*)(&pTransmitKey
->abyKey
[24]);
1305 dwMICKey1
= *(u32
*)(&pTransmitKey
->abyKey
[28]);
1307 // DO Software Michael
1308 MIC_vInit(dwMICKey0
, dwMICKey1
);
1309 MIC_vAppend((u8
*)&(psEthHeader
->h_dest
[0]), 12);
1311 MIC_vAppend((u8
*)&dwMIC_Priority
, 4);
1312 DBG_PRT(MSG_LEVEL_DEBUG
, KERN_INFO
"MIC KEY: %X, %X\n",
1313 dwMICKey0
, dwMICKey1
);
1315 ///////////////////////////////////////////////////////////////////
1317 //DBG_PRN_GRP12(("Length:%d, %d\n", cbFrameBodySize, uFromHDtoPLDLength));
1318 //for (ii = 0; ii < cbFrameBodySize; ii++) {
1319 // DBG_PRN_GRP12(("%02x ", *((u8 *)((pbyPayloadHead + cb802_1_H_len) + ii))));
1321 //DBG_PRN_GRP12(("\n\n\n"));
1323 MIC_vAppend(pbyPayloadHead
, cbFrameBodySize
);
1325 pdwMIC_L
= (u32
*)(pbyPayloadHead
+ cbFrameBodySize
);
1326 pdwMIC_R
= (u32
*)(pbyPayloadHead
+ cbFrameBodySize
+ 4);
1328 MIC_vGetMIC(pdwMIC_L
, pdwMIC_R
);
1331 if (pDevice
->bTxMICFail
== true) {
1334 pDevice
->bTxMICFail
= false;
1336 //DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"uLength: %d, %d\n", uLength, cbFrameBodySize);
1337 //DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"cbReqCount:%d, %d, %d, %d\n", cbReqCount, cbHeaderLength, uPadding, cbIVlen);
1338 //DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"MIC:%lX, %lX\n", *pdwMIC_L, *pdwMIC_R);
1341 if (bSoftWEP
== true) {
1343 s_vSWencryption(pDevice
, pTransmitKey
, (pbyPayloadHead
), (u16
)(cbFrameBodySize
+ cbMIClen
));
1345 } else if ( ((pDevice
->eEncryptionStatus
== Ndis802_11Encryption1Enabled
) && (bNeedEncryption
== true)) ||
1346 ((pDevice
->eEncryptionStatus
== Ndis802_11Encryption2Enabled
) && (bNeedEncryption
== true)) ||
1347 ((pDevice
->eEncryptionStatus
== Ndis802_11Encryption3Enabled
) && (bNeedEncryption
== true)) ) {
1348 cbFrameSize
-= cbICVlen
;
1351 cbFrameSize
-= cbFCSlen
;
1353 *pcbHeaderLen
= cbHeaderLength
;
1354 *pcbTotalLen
= cbHeaderLength
+ cbFrameSize
;
1356 //Set FragCtl in TxBufferHead
1357 pTxBufHead
->wFragCtl
|= (u16
)byFragType
;
1366 * Translate 802.3 to 802.11 header
1370 * pDevice - Pointer to adapter
1371 * dwTxBufferAddr - Transmit Buffer
1372 * pPacket - Packet from upper layer
1373 * cbPacketSize - Transmit Data Length
1375 * pcbHeadSize - Header size of MAC&Baseband control and 802.11 Header
1376 * pcbAppendPayload - size of append payload for 802.1H translation
1378 * Return Value: none
1382 static void s_vGenerateMACHeader(struct vnt_private
*pDevice
,
1383 u8
*pbyBufferAddr
, u16 wDuration
, struct ethhdr
*psEthHeader
,
1384 int bNeedEncrypt
, u16 wFragType
, u32 uDMAIdx
, u32 uFragIdx
)
1386 struct ieee80211_hdr
*pMACHeader
= (struct ieee80211_hdr
*)pbyBufferAddr
;
1388 pMACHeader
->frame_control
= TYPE_802_11_DATA
;
1390 if (pDevice
->eOPMode
== OP_MODE_AP
) {
1391 memcpy(&(pMACHeader
->addr1
[0]),
1392 &(psEthHeader
->h_dest
[0]),
1394 memcpy(&(pMACHeader
->addr2
[0]), &(pDevice
->abyBSSID
[0]), ETH_ALEN
);
1395 memcpy(&(pMACHeader
->addr3
[0]),
1396 &(psEthHeader
->h_source
[0]),
1398 pMACHeader
->frame_control
|= FC_FROMDS
;
1400 if (pDevice
->eOPMode
== OP_MODE_ADHOC
) {
1401 memcpy(&(pMACHeader
->addr1
[0]),
1402 &(psEthHeader
->h_dest
[0]),
1404 memcpy(&(pMACHeader
->addr2
[0]),
1405 &(psEthHeader
->h_source
[0]),
1407 memcpy(&(pMACHeader
->addr3
[0]),
1408 &(pDevice
->abyBSSID
[0]),
1411 memcpy(&(pMACHeader
->addr3
[0]),
1412 &(psEthHeader
->h_dest
[0]),
1414 memcpy(&(pMACHeader
->addr2
[0]),
1415 &(psEthHeader
->h_source
[0]),
1417 memcpy(&(pMACHeader
->addr1
[0]),
1418 &(pDevice
->abyBSSID
[0]),
1420 pMACHeader
->frame_control
|= FC_TODS
;
1425 pMACHeader
->frame_control
|= cpu_to_le16((u16
)WLAN_SET_FC_ISWEP(1));
1427 pMACHeader
->duration_id
= cpu_to_le16(wDuration
);
1429 if (pDevice
->bLongHeader
) {
1430 PWLAN_80211HDR_A4 pMACA4Header
= (PWLAN_80211HDR_A4
) pbyBufferAddr
;
1431 pMACHeader
->frame_control
|= (FC_TODS
| FC_FROMDS
);
1432 memcpy(pMACA4Header
->abyAddr4
, pDevice
->abyBSSID
, WLAN_ADDR_LEN
);
1434 pMACHeader
->seq_ctrl
= cpu_to_le16(pDevice
->wSeqCounter
<< 4);
1436 //Set FragNumber in Sequence Control
1437 pMACHeader
->seq_ctrl
|= cpu_to_le16((u16
)uFragIdx
);
1439 if ((wFragType
== FRAGCTL_ENDFRAG
) || (wFragType
== FRAGCTL_NONFRAG
)) {
1440 pDevice
->wSeqCounter
++;
1441 if (pDevice
->wSeqCounter
> 0x0fff)
1442 pDevice
->wSeqCounter
= 0;
1445 if ((wFragType
== FRAGCTL_STAFRAG
) || (wFragType
== FRAGCTL_MIDFRAG
)) { //StartFrag or MidFrag
1446 pMACHeader
->frame_control
|= FC_MOREFRAG
;
1453 * Request instructs a MAC to transmit a 802.11 management packet through
1454 * the adapter onto the medium.
1458 * hDeviceContext - Pointer to the adapter
1459 * pPacket - A pointer to a descriptor for the packet to transmit
1463 * Return Value: CMD_STATUS_PENDING if MAC Tx resource available; otherwise false
1467 CMD_STATUS
csMgmt_xmit(struct vnt_private
*pDevice
,
1468 struct vnt_tx_mgmt
*pPacket
)
1470 struct vnt_manager
*pMgmt
= &pDevice
->vnt_mgmt
;
1471 struct vnt_tx_buffer
*pTX_Buffer
;
1472 struct vnt_usb_send_context
*pContext
;
1473 struct vnt_tx_fifo_head
*pTxBufHead
;
1474 struct ieee80211_hdr
*pMACHeader
;
1475 struct ethhdr sEthHeader
;
1476 u8 byPktType
, *pbyTxBufferAddr
;
1477 void *rts_cts
= NULL
;
1478 void *pvTxDataHd
, *pvRrvTime
, *pMICHDR
;
1479 u32 uDuration
, cbReqCount
, cbHeaderSize
, cbFrameBodySize
, cbFrameSize
;
1480 int bNeedACK
, bIsPSPOLL
= false;
1481 u32 cbIVlen
= 0, cbICVlen
= 0, cbMIClen
= 0, cbFCSlen
= 4;
1485 u16 wCurrentRate
= RATE_1M
;
1487 pContext
= (struct vnt_usb_send_context
*)s_vGetFreeContext(pDevice
);
1489 if (NULL
== pContext
) {
1490 DBG_PRT(MSG_LEVEL_DEBUG
, KERN_INFO
"ManagementSend TX...NO CONTEXT!\n");
1491 return CMD_STATUS_RESOURCES
;
1494 pTX_Buffer
= (struct vnt_tx_buffer
*)&pContext
->Data
[0];
1495 cbFrameBodySize
= pPacket
->cbPayloadLen
;
1496 pTxBufHead
= &pTX_Buffer
->fifo_head
;
1497 pbyTxBufferAddr
= (u8
*)&pTxBufHead
->adwTxKey
[0];
1498 wTxBufSize
= sizeof(struct vnt_tx_fifo_head
);
1500 if (pDevice
->byBBType
== BB_TYPE_11A
) {
1501 wCurrentRate
= RATE_6M
;
1502 byPktType
= PK_TYPE_11A
;
1504 wCurrentRate
= RATE_1M
;
1505 byPktType
= PK_TYPE_11B
;
1508 // SetPower will cause error power TX state for OFDM Date packet in TX buffer.
1509 // 2004.11.11 Kyle -- Using OFDM power to tx MngPkt will decrease the connection capability.
1510 // And cmd timer will wait data pkt TX finish before scanning so it's OK
1511 // to set power here.
1512 if (pMgmt
->eScanState
!= WMAC_NO_SCANNING
) {
1513 RFbSetPower(pDevice
, wCurrentRate
, pDevice
->byCurrentCh
);
1515 RFbSetPower(pDevice
, wCurrentRate
, pMgmt
->uCurrChannel
);
1517 pDevice
->wCurrentRate
= wCurrentRate
;
1520 if (byPktType
== PK_TYPE_11A
) {//0000 0000 0000 0000
1521 pTxBufHead
->wFIFOCtl
= 0;
1523 else if (byPktType
== PK_TYPE_11B
) {//0000 0001 0000 0000
1524 pTxBufHead
->wFIFOCtl
|= FIFOCTL_11B
;
1526 else if (byPktType
== PK_TYPE_11GB
) {//0000 0010 0000 0000
1527 pTxBufHead
->wFIFOCtl
|= FIFOCTL_11GB
;
1529 else if (byPktType
== PK_TYPE_11GA
) {//0000 0011 0000 0000
1530 pTxBufHead
->wFIFOCtl
|= FIFOCTL_11GA
;
1533 pTxBufHead
->wFIFOCtl
|= FIFOCTL_TMOEN
;
1534 pTxBufHead
->wTimeStamp
= cpu_to_le16(DEFAULT_MGN_LIFETIME_RES_64us
);
1536 if (is_multicast_ether_addr(pPacket
->p80211Header
->sA3
.abyAddr1
)) {
1541 pTxBufHead
->wFIFOCtl
|= FIFOCTL_NEEDACK
;
1544 if ((pMgmt
->eCurrMode
== WMAC_MODE_ESS_AP
) ||
1545 (pMgmt
->eCurrMode
== WMAC_MODE_IBSS_STA
) ) {
1547 pTxBufHead
->wFIFOCtl
|= FIFOCTL_LRETRY
;
1548 //Set Preamble type always long
1549 //pDevice->byPreambleType = PREAMBLE_LONG;
1550 // probe-response don't retry
1551 //if ((pPacket->p80211Header->sA4.wFrameCtl & TYPE_SUBTYPE_MASK) == TYPE_MGMT_PROBE_RSP) {
1552 // bNeedACK = false;
1553 // pTxBufHead->wFIFOCtl &= (~FIFOCTL_NEEDACK);
1557 pTxBufHead
->wFIFOCtl
|= (FIFOCTL_GENINT
| FIFOCTL_ISDMA0
);
1559 if ((pPacket
->p80211Header
->sA4
.wFrameCtl
& TYPE_SUBTYPE_MASK
) == TYPE_CTL_PSPOLL
) {
1561 cbMacHdLen
= WLAN_HDR_ADDR2_LEN
;
1563 cbMacHdLen
= WLAN_HDR_ADDR3_LEN
;
1566 //Set FRAGCTL_MACHDCNT
1567 pTxBufHead
->wFragCtl
|= cpu_to_le16((u16
)(cbMacHdLen
<< 10));
1570 // Although spec says MMPDU can be fragmented; In most case,
1571 // no one will send a MMPDU under fragmentation. With RTS may occur.
1572 pDevice
->bAES
= false; //Set FRAGCTL_WEPTYP
1574 if (WLAN_GET_FC_ISWEP(pPacket
->p80211Header
->sA4
.wFrameCtl
) != 0) {
1575 if (pDevice
->eEncryptionStatus
== Ndis802_11Encryption1Enabled
) {
1578 pTxBufHead
->wFragCtl
|= FRAGCTL_LEGACY
;
1580 else if (pDevice
->eEncryptionStatus
== Ndis802_11Encryption2Enabled
) {
1581 cbIVlen
= 8;//IV+ExtIV
1584 pTxBufHead
->wFragCtl
|= FRAGCTL_TKIP
;
1585 //We need to get seed here for filling TxKey entry.
1586 //TKIPvMixKey(pTransmitKey->abyKey, pDevice->abyCurrentNetAddr,
1587 // pTransmitKey->wTSC15_0, pTransmitKey->dwTSC47_16, pDevice->abyPRNG);
1589 else if (pDevice
->eEncryptionStatus
== Ndis802_11Encryption3Enabled
) {
1590 cbIVlen
= 8;//RSN Header
1592 pTxBufHead
->wFragCtl
|= FRAGCTL_AES
;
1593 pDevice
->bAES
= true;
1595 //MAC Header should be padding 0 to DW alignment.
1596 uPadding
= 4 - (cbMacHdLen
%4);
1600 cbFrameSize
= cbMacHdLen
+ cbFrameBodySize
+ cbIVlen
+ cbMIClen
+ cbICVlen
+ cbFCSlen
;
1602 //Set FIFOCTL_GrpAckPolicy
1603 if (pDevice
->bGrpAckPolicy
== true) {//0000 0100 0000 0000
1604 pTxBufHead
->wFIFOCtl
|= FIFOCTL_GRPACK
;
1606 //the rest of pTxBufHead->wFragCtl:FragTyp will be set later in s_vFillFragParameter()
1608 //Set RrvTime/RTS/CTS Buffer
1609 if (byPktType
== PK_TYPE_11GB
|| byPktType
== PK_TYPE_11GA
) {//802.11g packet
1611 pvRrvTime
= (struct vnt_rrv_time_cts
*) (pbyTxBufferAddr
+ wTxBufSize
);
1613 rts_cts
= (struct vnt_cts
*) (pbyTxBufferAddr
+ wTxBufSize
+
1614 sizeof(struct vnt_rrv_time_cts
));
1615 pvTxDataHd
= (struct vnt_tx_datahead_g
*)(pbyTxBufferAddr
+ wTxBufSize
+
1616 sizeof(struct vnt_rrv_time_cts
) + sizeof(struct vnt_cts
));
1617 cbHeaderSize
= wTxBufSize
+ sizeof(struct vnt_rrv_time_cts
) +
1618 sizeof(struct vnt_cts
) + sizeof(struct vnt_tx_datahead_g
);
1620 else { // 802.11a/b packet
1621 pvRrvTime
= (struct vnt_rrv_time_ab
*) (pbyTxBufferAddr
+ wTxBufSize
);
1623 pvTxDataHd
= (struct vnt_tx_datahead_ab
*) (pbyTxBufferAddr
+
1624 wTxBufSize
+ sizeof(struct vnt_rrv_time_ab
));
1625 cbHeaderSize
= wTxBufSize
+ sizeof(struct vnt_rrv_time_ab
) +
1626 sizeof(struct vnt_tx_datahead_ab
);
1629 memcpy(&(sEthHeader
.h_dest
[0]),
1630 &(pPacket
->p80211Header
->sA3
.abyAddr1
[0]),
1632 memcpy(&(sEthHeader
.h_source
[0]),
1633 &(pPacket
->p80211Header
->sA3
.abyAddr2
[0]),
1635 //=========================
1637 //=========================
1638 pTxBufHead
->wFragCtl
|= (u16
)FRAGCTL_NONFRAG
;
1640 /* Fill FIFO,RrvTime,RTS,and CTS */
1641 s_vGenerateTxParameter(pDevice
, byPktType
, wCurrentRate
,
1642 pbyTxBufferAddr
, pvRrvTime
, rts_cts
,
1643 cbFrameSize
, bNeedACK
, TYPE_TXDMA0
, &sEthHeader
, false);
1646 uDuration
= s_uFillDataHead(pDevice
, byPktType
, wCurrentRate
, pvTxDataHd
, cbFrameSize
, TYPE_TXDMA0
, bNeedACK
,
1649 pMACHeader
= (struct ieee80211_hdr
*) (pbyTxBufferAddr
+ cbHeaderSize
);
1651 cbReqCount
= cbHeaderSize
+ cbMacHdLen
+ uPadding
+ cbIVlen
+ cbFrameBodySize
;
1653 if (WLAN_GET_FC_ISWEP(pPacket
->p80211Header
->sA4
.wFrameCtl
) != 0) {
1655 u8
* pbyPayloadHead
;
1657 PSKeyItem pTransmitKey
= NULL
;
1659 pbyIVHead
= (u8
*)(pbyTxBufferAddr
+ cbHeaderSize
+ cbMacHdLen
+ uPadding
);
1660 pbyPayloadHead
= (u8
*)(pbyTxBufferAddr
+ cbHeaderSize
+ cbMacHdLen
+ uPadding
+ cbIVlen
);
1662 if ((pDevice
->eOPMode
== OP_MODE_INFRASTRUCTURE
) &&
1663 (pDevice
->bLinkPass
== true)) {
1664 pbyBSSID
= pDevice
->abyBSSID
;
1666 if (KeybGetTransmitKey(&(pDevice
->sKey
), pbyBSSID
, PAIRWISE_KEY
, &pTransmitKey
) == false) {
1668 if(KeybGetTransmitKey(&(pDevice
->sKey
), pbyBSSID
, GROUP_KEY
, &pTransmitKey
) == true) {
1669 DBG_PRT(MSG_LEVEL_DEBUG
, KERN_INFO
"Get GTK.\n");
1673 DBG_PRT(MSG_LEVEL_DEBUG
, KERN_INFO
"Get PTK.\n");
1678 pbyBSSID
= pDevice
->abyBroadcastAddr
;
1679 if(KeybGetTransmitKey(&(pDevice
->sKey
), pbyBSSID
, GROUP_KEY
, &pTransmitKey
) == false) {
1680 pTransmitKey
= NULL
;
1681 DBG_PRT(MSG_LEVEL_DEBUG
, KERN_INFO
"KEY is NULL. OP Mode[%d]\n", pDevice
->eOPMode
);
1683 DBG_PRT(MSG_LEVEL_DEBUG
, KERN_INFO
"Get GTK.\n");
1687 s_vFillTxKey(pDevice
, (u8
*)(pTxBufHead
->adwTxKey
), pbyIVHead
, pTransmitKey
,
1688 (u8
*)pMACHeader
, (u16
)cbFrameBodySize
, NULL
);
1690 memcpy(pMACHeader
, pPacket
->p80211Header
, cbMacHdLen
);
1691 memcpy(pbyPayloadHead
, ((u8
*)(pPacket
->p80211Header
) + cbMacHdLen
),
1695 // Copy the Packet into a tx Buffer
1696 memcpy(pMACHeader
, pPacket
->p80211Header
, pPacket
->cbMPDULen
);
1699 pMACHeader
->seq_ctrl
= cpu_to_le16(pDevice
->wSeqCounter
<< 4);
1700 pDevice
->wSeqCounter
++ ;
1701 if (pDevice
->wSeqCounter
> 0x0fff)
1702 pDevice
->wSeqCounter
= 0;
1705 // The MAC will automatically replace the Duration-field of MAC header by Duration-field
1706 // of FIFO control header.
1707 // This will cause AID-field of PS-POLL packet be incorrect (Because PS-POLL's AID field is
1708 // in the same place of other packet's Duration-field).
1709 // And it will cause Cisco-AP to issue Disassociation-packet
1710 if (byPktType
== PK_TYPE_11GB
|| byPktType
== PK_TYPE_11GA
) {
1711 ((struct vnt_tx_datahead_g
*)pvTxDataHd
)->wDuration_a
=
1712 cpu_to_le16(pPacket
->p80211Header
->sA2
.wDurationID
);
1713 ((struct vnt_tx_datahead_g
*)pvTxDataHd
)->wDuration_b
=
1714 cpu_to_le16(pPacket
->p80211Header
->sA2
.wDurationID
);
1716 ((struct vnt_tx_datahead_ab
*)pvTxDataHd
)->wDuration
=
1717 cpu_to_le16(pPacket
->p80211Header
->sA2
.wDurationID
);
1721 pTX_Buffer
->wTxByteCount
= cpu_to_le16((u16
)(cbReqCount
));
1722 pTX_Buffer
->byPKTNO
= (u8
) (((wCurrentRate
<<4) &0x00F0) | ((pDevice
->wSeqCounter
- 1) & 0x000F));
1723 pTX_Buffer
->byType
= 0x00;
1725 pContext
->pPacket
= NULL
;
1726 pContext
->Type
= CONTEXT_MGMT_PACKET
;
1727 pContext
->uBufLen
= (u16
)cbReqCount
+ 4; //USB header
1729 if (WLAN_GET_FC_TODS(pMACHeader
->frame_control
) == 0) {
1730 s_vSaveTxPktInfo(pDevice
, (u8
)(pTX_Buffer
->byPKTNO
& 0x0F),
1731 &pMACHeader
->addr1
[0], (u16
)cbFrameSize
,
1732 pTxBufHead
->wFIFOCtl
);
1735 s_vSaveTxPktInfo(pDevice
, (u8
)(pTX_Buffer
->byPKTNO
& 0x0F),
1736 &pMACHeader
->addr3
[0], (u16
)cbFrameSize
,
1737 pTxBufHead
->wFIFOCtl
);
1740 PIPEnsSendBulkOut(pDevice
,pContext
);
1741 return CMD_STATUS_PENDING
;
1744 CMD_STATUS
csBeacon_xmit(struct vnt_private
*pDevice
,
1745 struct vnt_tx_mgmt
*pPacket
)
1747 struct vnt_beacon_buffer
*pTX_Buffer
;
1748 u32 cbFrameSize
= pPacket
->cbMPDULen
+ WLAN_FCS_LEN
;
1749 u32 cbHeaderSize
= 0;
1750 u16 wTxBufSize
= sizeof(STxShortBufHead
);
1751 PSTxShortBufHead pTxBufHead
;
1752 struct ieee80211_hdr
*pMACHeader
;
1753 struct vnt_tx_datahead_ab
*pTxDataHead
;
1755 u32 cbFrameBodySize
;
1757 u8
*pbyTxBufferAddr
;
1758 struct vnt_usb_send_context
*pContext
;
1761 pContext
= (struct vnt_usb_send_context
*)s_vGetFreeContext(pDevice
);
1762 if (NULL
== pContext
) {
1763 status
= CMD_STATUS_RESOURCES
;
1764 DBG_PRT(MSG_LEVEL_DEBUG
, KERN_INFO
"ManagementSend TX...NO CONTEXT!\n");
1768 pTX_Buffer
= (struct vnt_beacon_buffer
*)&pContext
->Data
[0];
1769 pbyTxBufferAddr
= (u8
*)&(pTX_Buffer
->wFIFOCtl
);
1771 cbFrameBodySize
= pPacket
->cbPayloadLen
;
1773 pTxBufHead
= (PSTxShortBufHead
) pbyTxBufferAddr
;
1774 wTxBufSize
= sizeof(STxShortBufHead
);
1776 if (pDevice
->byBBType
== BB_TYPE_11A
) {
1777 wCurrentRate
= RATE_6M
;
1778 pTxDataHead
= (struct vnt_tx_datahead_ab
*)
1779 (pbyTxBufferAddr
+ wTxBufSize
);
1780 //Get SignalField,ServiceField,Length
1781 BBvCalculateParameter(pDevice
, cbFrameSize
, wCurrentRate
, PK_TYPE_11A
,
1783 //Get Duration and TimeStampOff
1784 pTxDataHead
->wDuration
= s_uGetDataDuration(pDevice
,
1785 PK_TYPE_11A
, false);
1786 pTxDataHead
->wTimeStampOff
= vnt_time_stamp_off(pDevice
, wCurrentRate
);
1787 cbHeaderSize
= wTxBufSize
+ sizeof(struct vnt_tx_datahead_ab
);
1789 wCurrentRate
= RATE_1M
;
1790 pTxBufHead
->wFIFOCtl
|= FIFOCTL_11B
;
1791 pTxDataHead
= (struct vnt_tx_datahead_ab
*)
1792 (pbyTxBufferAddr
+ wTxBufSize
);
1793 //Get SignalField,ServiceField,Length
1794 BBvCalculateParameter(pDevice
, cbFrameSize
, wCurrentRate
, PK_TYPE_11B
,
1796 //Get Duration and TimeStampOff
1797 pTxDataHead
->wDuration
= s_uGetDataDuration(pDevice
,
1798 PK_TYPE_11B
, false);
1799 pTxDataHead
->wTimeStampOff
= vnt_time_stamp_off(pDevice
, wCurrentRate
);
1800 cbHeaderSize
= wTxBufSize
+ sizeof(struct vnt_tx_datahead_ab
);
1803 //Generate Beacon Header
1804 pMACHeader
= (struct ieee80211_hdr
*)(pbyTxBufferAddr
+ cbHeaderSize
);
1805 memcpy(pMACHeader
, pPacket
->p80211Header
, pPacket
->cbMPDULen
);
1807 pMACHeader
->duration_id
= 0;
1808 pMACHeader
->seq_ctrl
= cpu_to_le16(pDevice
->wSeqCounter
<< 4);
1809 pDevice
->wSeqCounter
++ ;
1810 if (pDevice
->wSeqCounter
> 0x0fff)
1811 pDevice
->wSeqCounter
= 0;
1813 cbReqCount
= cbHeaderSize
+ WLAN_HDR_ADDR3_LEN
+ cbFrameBodySize
;
1815 pTX_Buffer
->wTxByteCount
= (u16
)cbReqCount
;
1816 pTX_Buffer
->byPKTNO
= (u8
) (((wCurrentRate
<<4) &0x00F0) | ((pDevice
->wSeqCounter
- 1) & 0x000F));
1817 pTX_Buffer
->byType
= 0x01;
1819 pContext
->pPacket
= NULL
;
1820 pContext
->Type
= CONTEXT_MGMT_PACKET
;
1821 pContext
->uBufLen
= (u16
)cbReqCount
+ 4; //USB header
1823 PIPEnsSendBulkOut(pDevice
,pContext
);
1824 return CMD_STATUS_PENDING
;
1828 void vDMA0_tx_80211(struct vnt_private
*pDevice
, struct sk_buff
*skb
)
1830 struct vnt_manager
*pMgmt
= &pDevice
->vnt_mgmt
;
1831 struct vnt_tx_buffer
*pTX_Buffer
;
1832 struct vnt_tx_fifo_head
*pTxBufHead
;
1834 u8
*pbyTxBufferAddr
;
1835 void *rts_cts
= NULL
;
1837 u32 uDuration
, cbReqCount
;
1838 struct ieee80211_hdr
*pMACHeader
;
1839 u32 cbHeaderSize
, cbFrameBodySize
;
1840 int bNeedACK
, bIsPSPOLL
= false;
1842 u32 cbIVlen
= 0, cbICVlen
= 0, cbMIClen
= 0, cbFCSlen
= 4;
1844 u32 cbMICHDR
= 0, uLength
= 0;
1845 u32 dwMICKey0
, dwMICKey1
;
1847 u32
*pdwMIC_L
, *pdwMIC_R
;
1850 struct ethhdr sEthHeader
;
1851 void *pvRrvTime
, *pMICHDR
;
1852 u32 wCurrentRate
= RATE_1M
;
1853 PUWLAN_80211HDR p80211Header
;
1855 int bNodeExist
= false;
1857 PSKeyItem pTransmitKey
= NULL
;
1858 u8
*pbyIVHead
, *pbyPayloadHead
, *pbyMacHdr
;
1859 u32 cbExtSuppRate
= 0;
1860 struct vnt_usb_send_context
*pContext
;
1862 pvRrvTime
= pMICHDR
= pvTxDataHd
= NULL
;
1864 if(skb
->len
<= WLAN_HDR_ADDR3_LEN
) {
1865 cbFrameBodySize
= 0;
1868 cbFrameBodySize
= skb
->len
- WLAN_HDR_ADDR3_LEN
;
1870 p80211Header
= (PUWLAN_80211HDR
)skb
->data
;
1872 pContext
= (struct vnt_usb_send_context
*)s_vGetFreeContext(pDevice
);
1874 if (NULL
== pContext
) {
1875 DBG_PRT(MSG_LEVEL_DEBUG
, KERN_INFO
"DMA0 TX...NO CONTEXT!\n");
1876 dev_kfree_skb_irq(skb
);
1880 pTX_Buffer
= (struct vnt_tx_buffer
*)&pContext
->Data
[0];
1881 pTxBufHead
= &pTX_Buffer
->fifo_head
;
1882 pbyTxBufferAddr
= (u8
*)&pTxBufHead
->adwTxKey
[0];
1883 wTxBufSize
= sizeof(struct vnt_tx_fifo_head
);
1885 if (pDevice
->byBBType
== BB_TYPE_11A
) {
1886 wCurrentRate
= RATE_6M
;
1887 byPktType
= PK_TYPE_11A
;
1889 wCurrentRate
= RATE_1M
;
1890 byPktType
= PK_TYPE_11B
;
1893 // SetPower will cause error power TX state for OFDM Date packet in TX buffer.
1894 // 2004.11.11 Kyle -- Using OFDM power to tx MngPkt will decrease the connection capability.
1895 // And cmd timer will wait data pkt TX finish before scanning so it's OK
1896 // to set power here.
1897 if (pMgmt
->eScanState
!= WMAC_NO_SCANNING
) {
1898 RFbSetPower(pDevice
, wCurrentRate
, pDevice
->byCurrentCh
);
1900 RFbSetPower(pDevice
, wCurrentRate
, pMgmt
->uCurrChannel
);
1903 DBG_PRT(MSG_LEVEL_DEBUG
, KERN_INFO
"vDMA0_tx_80211: p80211Header->sA3.wFrameCtl = %x \n", p80211Header
->sA3
.wFrameCtl
);
1906 if (byPktType
== PK_TYPE_11A
) {//0000 0000 0000 0000
1907 pTxBufHead
->wFIFOCtl
= 0;
1909 else if (byPktType
== PK_TYPE_11B
) {//0000 0001 0000 0000
1910 pTxBufHead
->wFIFOCtl
|= FIFOCTL_11B
;
1912 else if (byPktType
== PK_TYPE_11GB
) {//0000 0010 0000 0000
1913 pTxBufHead
->wFIFOCtl
|= FIFOCTL_11GB
;
1915 else if (byPktType
== PK_TYPE_11GA
) {//0000 0011 0000 0000
1916 pTxBufHead
->wFIFOCtl
|= FIFOCTL_11GA
;
1919 pTxBufHead
->wFIFOCtl
|= FIFOCTL_TMOEN
;
1920 pTxBufHead
->wTimeStamp
= cpu_to_le16(DEFAULT_MGN_LIFETIME_RES_64us
);
1922 if (is_multicast_ether_addr(p80211Header
->sA3
.abyAddr1
)) {
1924 if (pDevice
->bEnableHostWEP
) {
1930 if (pDevice
->bEnableHostWEP
) {
1931 if (BSSbIsSTAInNodeDB(pDevice
, (u8
*)(p80211Header
->sA3
.abyAddr1
), &uNodeIndex
))
1935 pTxBufHead
->wFIFOCtl
|= FIFOCTL_NEEDACK
;
1938 if ((pMgmt
->eCurrMode
== WMAC_MODE_ESS_AP
) ||
1939 (pMgmt
->eCurrMode
== WMAC_MODE_IBSS_STA
) ) {
1941 pTxBufHead
->wFIFOCtl
|= FIFOCTL_LRETRY
;
1942 //Set Preamble type always long
1943 //pDevice->byPreambleType = PREAMBLE_LONG;
1945 // probe-response don't retry
1946 //if ((p80211Header->sA4.wFrameCtl & TYPE_SUBTYPE_MASK) == TYPE_MGMT_PROBE_RSP) {
1947 // bNeedACK = false;
1948 // pTxBufHead->wFIFOCtl &= (~FIFOCTL_NEEDACK);
1952 pTxBufHead
->wFIFOCtl
|= (FIFOCTL_GENINT
| FIFOCTL_ISDMA0
);
1954 if ((p80211Header
->sA4
.wFrameCtl
& TYPE_SUBTYPE_MASK
) == TYPE_CTL_PSPOLL
) {
1956 cbMacHdLen
= WLAN_HDR_ADDR2_LEN
;
1958 cbMacHdLen
= WLAN_HDR_ADDR3_LEN
;
1961 // hostapd daemon ext support rate patch
1962 if (WLAN_GET_FC_FSTYPE(p80211Header
->sA4
.wFrameCtl
) == WLAN_FSTYPE_ASSOCRESP
) {
1964 if (((PWLAN_IE_SUPP_RATES
)pMgmt
->abyCurrSuppRates
)->len
!= 0) {
1965 cbExtSuppRate
+= ((PWLAN_IE_SUPP_RATES
)pMgmt
->abyCurrSuppRates
)->len
+ WLAN_IEHDR_LEN
;
1968 if (((PWLAN_IE_SUPP_RATES
)pMgmt
->abyCurrExtSuppRates
)->len
!= 0) {
1969 cbExtSuppRate
+= ((PWLAN_IE_SUPP_RATES
)pMgmt
->abyCurrExtSuppRates
)->len
+ WLAN_IEHDR_LEN
;
1972 if (cbExtSuppRate
>0) {
1973 cbFrameBodySize
= WLAN_ASSOCRESP_OFF_SUPP_RATES
;
1977 //Set FRAGCTL_MACHDCNT
1978 pTxBufHead
->wFragCtl
|= cpu_to_le16((u16
)cbMacHdLen
<< 10);
1981 // Although spec says MMPDU can be fragmented; In most case,
1982 // no one will send a MMPDU under fragmentation. With RTS may occur.
1983 pDevice
->bAES
= false; //Set FRAGCTL_WEPTYP
1985 if (WLAN_GET_FC_ISWEP(p80211Header
->sA4
.wFrameCtl
) != 0) {
1986 if (pDevice
->eEncryptionStatus
== Ndis802_11Encryption1Enabled
) {
1989 pTxBufHead
->wFragCtl
|= FRAGCTL_LEGACY
;
1991 else if (pDevice
->eEncryptionStatus
== Ndis802_11Encryption2Enabled
) {
1992 cbIVlen
= 8;//IV+ExtIV
1995 pTxBufHead
->wFragCtl
|= FRAGCTL_TKIP
;
1996 //We need to get seed here for filling TxKey entry.
1997 //TKIPvMixKey(pTransmitKey->abyKey, pDevice->abyCurrentNetAddr,
1998 // pTransmitKey->wTSC15_0, pTransmitKey->dwTSC47_16, pDevice->abyPRNG);
2000 else if (pDevice
->eEncryptionStatus
== Ndis802_11Encryption3Enabled
) {
2001 cbIVlen
= 8;//RSN Header
2003 cbMICHDR
= sizeof(struct vnt_mic_hdr
);
2004 pTxBufHead
->wFragCtl
|= FRAGCTL_AES
;
2005 pDevice
->bAES
= true;
2007 //MAC Header should be padding 0 to DW alignment.
2008 uPadding
= 4 - (cbMacHdLen
%4);
2012 cbFrameSize
= cbMacHdLen
+ cbFrameBodySize
+ cbIVlen
+ cbMIClen
+ cbICVlen
+ cbFCSlen
+ cbExtSuppRate
;
2014 //Set FIFOCTL_GrpAckPolicy
2015 if (pDevice
->bGrpAckPolicy
== true) {//0000 0100 0000 0000
2016 pTxBufHead
->wFIFOCtl
|= FIFOCTL_GRPACK
;
2018 //the rest of pTxBufHead->wFragCtl:FragTyp will be set later in s_vFillFragParameter()
2020 if (byPktType
== PK_TYPE_11GB
|| byPktType
== PK_TYPE_11GA
) {//802.11g packet
2021 pvRrvTime
= (struct vnt_rrv_time_cts
*) (pbyTxBufferAddr
+ wTxBufSize
);
2022 pMICHDR
= (struct vnt_mic_hdr
*) (pbyTxBufferAddr
+ wTxBufSize
+
2023 sizeof(struct vnt_rrv_time_cts
));
2024 rts_cts
= (struct vnt_cts
*) (pbyTxBufferAddr
+ wTxBufSize
+
2025 sizeof(struct vnt_rrv_time_cts
) + cbMICHDR
);
2026 pvTxDataHd
= (struct vnt_tx_datahead_g
*) (pbyTxBufferAddr
+
2027 wTxBufSize
+ sizeof(struct vnt_rrv_time_cts
) + cbMICHDR
+
2028 sizeof(struct vnt_cts
));
2029 cbHeaderSize
= wTxBufSize
+ sizeof(struct vnt_rrv_time_cts
) + cbMICHDR
+
2030 sizeof(struct vnt_cts
) + sizeof(struct vnt_tx_datahead_g
);
2033 else {//802.11a/b packet
2035 pvRrvTime
= (struct vnt_rrv_time_ab
*) (pbyTxBufferAddr
+ wTxBufSize
);
2036 pMICHDR
= (struct vnt_mic_hdr
*) (pbyTxBufferAddr
+ wTxBufSize
+
2037 sizeof(struct vnt_rrv_time_ab
));
2038 pvTxDataHd
= (struct vnt_tx_datahead_ab
*)(pbyTxBufferAddr
+
2039 wTxBufSize
+ sizeof(struct vnt_rrv_time_ab
) + cbMICHDR
);
2040 cbHeaderSize
= wTxBufSize
+ sizeof(struct vnt_rrv_time_ab
) + cbMICHDR
+
2041 sizeof(struct vnt_tx_datahead_ab
);
2043 memcpy(&(sEthHeader
.h_dest
[0]),
2044 &(p80211Header
->sA3
.abyAddr1
[0]),
2046 memcpy(&(sEthHeader
.h_source
[0]),
2047 &(p80211Header
->sA3
.abyAddr2
[0]),
2049 //=========================
2051 //=========================
2052 pTxBufHead
->wFragCtl
|= (u16
)FRAGCTL_NONFRAG
;
2054 /* Fill FIFO,RrvTime,RTS,and CTS */
2055 s_vGenerateTxParameter(pDevice
, byPktType
, wCurrentRate
,
2056 pbyTxBufferAddr
, pvRrvTime
, rts_cts
,
2057 cbFrameSize
, bNeedACK
, TYPE_TXDMA0
, &sEthHeader
, false);
2060 uDuration
= s_uFillDataHead(pDevice
, byPktType
, wCurrentRate
, pvTxDataHd
, cbFrameSize
, TYPE_TXDMA0
, bNeedACK
,
2063 pMACHeader
= (struct ieee80211_hdr
*) (pbyTxBufferAddr
+ cbHeaderSize
);
2065 cbReqCount
= cbHeaderSize
+ cbMacHdLen
+ uPadding
+ cbIVlen
+ (cbFrameBodySize
+ cbMIClen
) + cbExtSuppRate
;
2067 pbyMacHdr
= (u8
*)(pbyTxBufferAddr
+ cbHeaderSize
);
2068 pbyPayloadHead
= (u8
*)(pbyMacHdr
+ cbMacHdLen
+ uPadding
+ cbIVlen
);
2069 pbyIVHead
= (u8
*)(pbyMacHdr
+ cbMacHdLen
+ uPadding
);
2071 // Copy the Packet into a tx Buffer
2072 memcpy(pbyMacHdr
, skb
->data
, cbMacHdLen
);
2074 // version set to 0, patch for hostapd deamon
2075 pMACHeader
->frame_control
&= cpu_to_le16(0xfffc);
2076 memcpy(pbyPayloadHead
, (skb
->data
+ cbMacHdLen
), cbFrameBodySize
);
2078 // replace support rate, patch for hostapd daemon( only support 11M)
2079 if (WLAN_GET_FC_FSTYPE(p80211Header
->sA4
.wFrameCtl
) == WLAN_FSTYPE_ASSOCRESP
) {
2080 if (cbExtSuppRate
!= 0) {
2081 if (((PWLAN_IE_SUPP_RATES
)pMgmt
->abyCurrSuppRates
)->len
!= 0)
2082 memcpy((pbyPayloadHead
+ cbFrameBodySize
),
2083 pMgmt
->abyCurrSuppRates
,
2084 ((PWLAN_IE_SUPP_RATES
)pMgmt
->abyCurrSuppRates
)->len
+ WLAN_IEHDR_LEN
2086 if (((PWLAN_IE_SUPP_RATES
)pMgmt
->abyCurrExtSuppRates
)->len
!= 0)
2087 memcpy((pbyPayloadHead
+ cbFrameBodySize
) + ((PWLAN_IE_SUPP_RATES
)pMgmt
->abyCurrSuppRates
)->len
+ WLAN_IEHDR_LEN
,
2088 pMgmt
->abyCurrExtSuppRates
,
2089 ((PWLAN_IE_SUPP_RATES
)pMgmt
->abyCurrExtSuppRates
)->len
+ WLAN_IEHDR_LEN
2095 if (WLAN_GET_FC_ISWEP(p80211Header
->sA4
.wFrameCtl
) != 0) {
2097 if (pDevice
->bEnableHostWEP
) {
2098 pTransmitKey
= &STempKey
;
2099 pTransmitKey
->byCipherSuite
= pMgmt
->sNodeDBTable
[uNodeIndex
].byCipherSuite
;
2100 pTransmitKey
->dwKeyIndex
= pMgmt
->sNodeDBTable
[uNodeIndex
].dwKeyIndex
;
2101 pTransmitKey
->uKeyLength
= pMgmt
->sNodeDBTable
[uNodeIndex
].uWepKeyLength
;
2102 pTransmitKey
->dwTSC47_16
= pMgmt
->sNodeDBTable
[uNodeIndex
].dwTSC47_16
;
2103 pTransmitKey
->wTSC15_0
= pMgmt
->sNodeDBTable
[uNodeIndex
].wTSC15_0
;
2104 memcpy(pTransmitKey
->abyKey
,
2105 &pMgmt
->sNodeDBTable
[uNodeIndex
].abyWepKey
[0],
2106 pTransmitKey
->uKeyLength
2110 if ((pTransmitKey
!= NULL
) && (pTransmitKey
->byCipherSuite
== KEY_CTL_TKIP
)) {
2112 dwMICKey0
= *(u32
*)(&pTransmitKey
->abyKey
[16]);
2113 dwMICKey1
= *(u32
*)(&pTransmitKey
->abyKey
[20]);
2115 // DO Software Michael
2116 MIC_vInit(dwMICKey0
, dwMICKey1
);
2117 MIC_vAppend((u8
*)&(sEthHeader
.h_dest
[0]), 12);
2119 MIC_vAppend((u8
*)&dwMIC_Priority
, 4);
2120 DBG_PRT(MSG_LEVEL_DEBUG
, KERN_INFO
"DMA0_tx_8021:MIC KEY:"\
2121 " %X, %X\n", dwMICKey0
, dwMICKey1
);
2123 uLength
= cbHeaderSize
+ cbMacHdLen
+ uPadding
+ cbIVlen
;
2125 MIC_vAppend((pbyTxBufferAddr
+ uLength
), cbFrameBodySize
);
2127 pdwMIC_L
= (u32
*)(pbyTxBufferAddr
+ uLength
+ cbFrameBodySize
);
2128 pdwMIC_R
= (u32
*)(pbyTxBufferAddr
+ uLength
+ cbFrameBodySize
+ 4);
2130 MIC_vGetMIC(pdwMIC_L
, pdwMIC_R
);
2133 if (pDevice
->bTxMICFail
== true) {
2136 pDevice
->bTxMICFail
= false;
2139 DBG_PRT(MSG_LEVEL_DEBUG
, KERN_INFO
"uLength: %d, %d\n", uLength
, cbFrameBodySize
);
2140 DBG_PRT(MSG_LEVEL_DEBUG
, KERN_INFO
"cbReqCount:%d, %d, %d, %d\n", cbReqCount
, cbHeaderSize
, uPadding
, cbIVlen
);
2141 DBG_PRT(MSG_LEVEL_DEBUG
, KERN_INFO
"MIC:%x, %x\n",
2142 *pdwMIC_L
, *pdwMIC_R
);
2146 s_vFillTxKey(pDevice
, (u8
*)(pTxBufHead
->adwTxKey
), pbyIVHead
, pTransmitKey
,
2147 pbyMacHdr
, (u16
)cbFrameBodySize
, pMICHDR
);
2149 if (pDevice
->bEnableHostWEP
) {
2150 pMgmt
->sNodeDBTable
[uNodeIndex
].dwTSC47_16
= pTransmitKey
->dwTSC47_16
;
2151 pMgmt
->sNodeDBTable
[uNodeIndex
].wTSC15_0
= pTransmitKey
->wTSC15_0
;
2154 if ((pDevice
->byLocalID
<= REV_ID_VT3253_A1
)) {
2155 s_vSWencryption(pDevice
, pTransmitKey
, pbyPayloadHead
, (u16
)(cbFrameBodySize
+ cbMIClen
));
2159 pMACHeader
->seq_ctrl
= cpu_to_le16(pDevice
->wSeqCounter
<< 4);
2160 pDevice
->wSeqCounter
++ ;
2161 if (pDevice
->wSeqCounter
> 0x0fff)
2162 pDevice
->wSeqCounter
= 0;
2165 // The MAC will automatically replace the Duration-field of MAC header by Duration-field
2166 // of FIFO control header.
2167 // This will cause AID-field of PS-POLL packet be incorrect (Because PS-POLL's AID field is
2168 // in the same place of other packet's Duration-field).
2169 // And it will cause Cisco-AP to issue Disassociation-packet
2170 if (byPktType
== PK_TYPE_11GB
|| byPktType
== PK_TYPE_11GA
) {
2171 ((struct vnt_tx_datahead_g
*)pvTxDataHd
)->wDuration_a
=
2172 cpu_to_le16(p80211Header
->sA2
.wDurationID
);
2173 ((struct vnt_tx_datahead_g
*)pvTxDataHd
)->wDuration_b
=
2174 cpu_to_le16(p80211Header
->sA2
.wDurationID
);
2176 ((struct vnt_tx_datahead_ab
*)pvTxDataHd
)->wDuration
=
2177 cpu_to_le16(p80211Header
->sA2
.wDurationID
);
2181 pTX_Buffer
->wTxByteCount
= cpu_to_le16((u16
)(cbReqCount
));
2182 pTX_Buffer
->byPKTNO
= (u8
) (((wCurrentRate
<<4) &0x00F0) | ((pDevice
->wSeqCounter
- 1) & 0x000F));
2183 pTX_Buffer
->byType
= 0x00;
2185 pContext
->pPacket
= skb
;
2186 pContext
->Type
= CONTEXT_MGMT_PACKET
;
2187 pContext
->uBufLen
= (u16
)cbReqCount
+ 4; //USB header
2189 if (WLAN_GET_FC_TODS(pMACHeader
->frame_control
) == 0) {
2190 s_vSaveTxPktInfo(pDevice
, (u8
)(pTX_Buffer
->byPKTNO
& 0x0F),
2191 &pMACHeader
->addr1
[0], (u16
)cbFrameSize
,
2192 pTxBufHead
->wFIFOCtl
);
2195 s_vSaveTxPktInfo(pDevice
, (u8
)(pTX_Buffer
->byPKTNO
& 0x0F),
2196 &pMACHeader
->addr3
[0], (u16
)cbFrameSize
,
2197 pTxBufHead
->wFIFOCtl
);
2199 PIPEnsSendBulkOut(pDevice
,pContext
);
2204 //TYPE_AC0DMA data tx
2207 * Tx packet via AC0DMA(DMA1)
2211 * pDevice - Pointer to the adapter
2212 * skb - Pointer to tx skb packet
2216 * Return Value: NULL
2219 int nsDMA_tx_packet(struct vnt_private
*pDevice
,
2220 u32 uDMAIdx
, struct sk_buff
*skb
)
2222 struct net_device_stats
*pStats
= &pDevice
->stats
;
2223 struct vnt_manager
*pMgmt
= &pDevice
->vnt_mgmt
;
2224 struct vnt_tx_buffer
*pTX_Buffer
;
2225 u32 BytesToWrite
= 0, uHeaderLen
= 0;
2227 u8 byMask
[8] = {1, 2, 4, 8, 0x10, 0x20, 0x40, 0x80};
2230 int bNeedEncryption
= false;
2231 PSKeyItem pTransmitKey
= NULL
;
2234 int bTKIP_UseGTK
= false;
2235 int bNeedDeAuth
= false;
2237 int bNodeExist
= false;
2238 struct vnt_usb_send_context
*pContext
;
2239 bool fConvertedPacket
;
2241 u16 wKeepRate
= pDevice
->wCurrentRate
;
2242 int bTxeapol_key
= false;
2244 if (pMgmt
->eCurrMode
== WMAC_MODE_ESS_AP
) {
2246 if (pDevice
->uAssocCount
== 0) {
2247 dev_kfree_skb_irq(skb
);
2251 if (is_multicast_ether_addr((u8
*)(skb
->data
))) {
2254 if (pMgmt
->sNodeDBTable
[0].bPSEnable
) {
2256 skb_queue_tail(&(pMgmt
->sNodeDBTable
[0].sTxPSQueue
), skb
);
2257 pMgmt
->sNodeDBTable
[0].wEnQueueCnt
++;
2259 pMgmt
->abyPSTxMap
[0] |= byMask
[0];
2262 // multicast/broadcast data rate
2264 if (pDevice
->byBBType
!= BB_TYPE_11A
)
2265 pDevice
->wCurrentRate
= RATE_2M
;
2267 pDevice
->wCurrentRate
= RATE_24M
;
2268 // long preamble type
2269 pDevice
->byPreambleType
= PREAMBLE_SHORT
;
2273 if (BSSbIsSTAInNodeDB(pDevice
, (u8
*)(skb
->data
), &uNodeIndex
)) {
2275 if (pMgmt
->sNodeDBTable
[uNodeIndex
].bPSEnable
) {
2277 skb_queue_tail(&pMgmt
->sNodeDBTable
[uNodeIndex
].sTxPSQueue
, skb
);
2279 pMgmt
->sNodeDBTable
[uNodeIndex
].wEnQueueCnt
++;
2281 wAID
= pMgmt
->sNodeDBTable
[uNodeIndex
].wAID
;
2282 pMgmt
->abyPSTxMap
[wAID
>> 3] |= byMask
[wAID
& 7];
2283 DBG_PRT(MSG_LEVEL_DEBUG
, KERN_INFO
"Set:pMgmt->abyPSTxMap[%d]= %d\n",
2284 (wAID
>> 3), pMgmt
->abyPSTxMap
[wAID
>> 3]);
2288 // AP rate decided from node
2289 pDevice
->wCurrentRate
= pMgmt
->sNodeDBTable
[uNodeIndex
].wTxDataRate
;
2290 // tx preamble decided from node
2292 if (pMgmt
->sNodeDBTable
[uNodeIndex
].bShortPreamble
) {
2293 pDevice
->byPreambleType
= pDevice
->byShortPreamble
;
2296 pDevice
->byPreambleType
= PREAMBLE_LONG
;
2302 if (bNodeExist
== false) {
2303 DBG_PRT(MSG_LEVEL_DEBUG
, KERN_DEBUG
"Unknown STA not found in node DB \n");
2304 dev_kfree_skb_irq(skb
);
2309 pContext
= (struct vnt_usb_send_context
*)s_vGetFreeContext(pDevice
);
2311 if (pContext
== NULL
) {
2312 DBG_PRT(MSG_LEVEL_DEBUG
, KERN_DEBUG
" pContext == NULL\n");
2313 dev_kfree_skb_irq(skb
);
2314 return STATUS_RESOURCES
;
2317 memcpy(pDevice
->sTxEthHeader
.h_dest
, (u8
*)(skb
->data
), ETH_HLEN
);
2319 //mike add:station mode check eapol-key challenge--->
2321 u8 Protocol_Version
; //802.1x Authentication
2322 u8 Packet_Type
; //802.1x Authentication
2326 Protocol_Version
= skb
->data
[ETH_HLEN
];
2327 Packet_Type
= skb
->data
[ETH_HLEN
+1];
2328 Descriptor_type
= skb
->data
[ETH_HLEN
+1+1+2];
2329 Key_info
= (skb
->data
[ETH_HLEN
+1+1+2+1] << 8)|(skb
->data
[ETH_HLEN
+1+1+2+2]);
2330 if (pDevice
->sTxEthHeader
.h_proto
== cpu_to_be16(ETH_P_PAE
)) {
2331 /* 802.1x OR eapol-key challenge frame transfer */
2332 if (((Protocol_Version
== 1) || (Protocol_Version
== 2)) &&
2333 (Packet_Type
== 3)) {
2334 bTxeapol_key
= true;
2335 if(!(Key_info
& BIT3
) && //WPA or RSN group-key challenge
2336 (Key_info
& BIT8
) && (Key_info
& BIT9
)) { //send 2/2 key
2337 if(Descriptor_type
==254) {
2338 pDevice
->fWPA_Authened
= true;
2342 pDevice
->fWPA_Authened
= true;
2343 PRINT_K("WPA2(re-keying) ");
2345 PRINT_K("Authentication completed!!\n");
2347 else if((Key_info
& BIT3
) && (Descriptor_type
==2) && //RSN pairwise-key challenge
2348 (Key_info
& BIT8
) && (Key_info
& BIT9
)) {
2349 pDevice
->fWPA_Authened
= true;
2350 PRINT_K("WPA2 Authentication completed!!\n");
2355 //mike add:station mode check eapol-key challenge<---
2357 if (pDevice
->bEncryptionEnable
== true) {
2358 bNeedEncryption
= true;
2361 if ((pMgmt
->eCurrMode
== WMAC_MODE_ESS_STA
) &&
2362 (pMgmt
->eCurrState
== WMAC_STATE_ASSOC
)) {
2363 pbyBSSID
= pDevice
->abyBSSID
;
2365 if (KeybGetTransmitKey(&(pDevice
->sKey
), pbyBSSID
, PAIRWISE_KEY
, &pTransmitKey
) == false) {
2367 if(KeybGetTransmitKey(&(pDevice
->sKey
), pbyBSSID
, GROUP_KEY
, &pTransmitKey
) == true) {
2368 bTKIP_UseGTK
= true;
2369 DBG_PRT(MSG_LEVEL_DEBUG
, KERN_DEBUG
"Get GTK.\n");
2373 DBG_PRT(MSG_LEVEL_DEBUG
, KERN_DEBUG
"Get PTK.\n");
2376 }else if (pMgmt
->eCurrMode
== WMAC_MODE_IBSS_STA
) {
2377 /* TO_DS = 0 and FROM_DS = 0 --> 802.11 MAC Address1 */
2378 pbyBSSID
= pDevice
->sTxEthHeader
.h_dest
;
2379 DBG_PRT(MSG_LEVEL_DEBUG
, KERN_DEBUG
"IBSS Serach Key: \n");
2380 for (ii
= 0; ii
< 6; ii
++)
2381 DBG_PRT(MSG_LEVEL_DEBUG
, KERN_DEBUG
"%x \n", *(pbyBSSID
+ii
));
2382 DBG_PRT(MSG_LEVEL_DEBUG
, KERN_DEBUG
"\n");
2385 if(KeybGetTransmitKey(&(pDevice
->sKey
), pbyBSSID
, PAIRWISE_KEY
, &pTransmitKey
) == true)
2389 pbyBSSID
= pDevice
->abyBroadcastAddr
;
2390 if(KeybGetTransmitKey(&(pDevice
->sKey
), pbyBSSID
, GROUP_KEY
, &pTransmitKey
) == false) {
2391 pTransmitKey
= NULL
;
2392 if (pMgmt
->eCurrMode
== WMAC_MODE_IBSS_STA
) {
2393 DBG_PRT(MSG_LEVEL_DEBUG
, KERN_DEBUG
"IBSS and KEY is NULL. [%d]\n", pMgmt
->eCurrMode
);
2396 DBG_PRT(MSG_LEVEL_DEBUG
, KERN_DEBUG
"NOT IBSS and KEY is NULL. [%d]\n", pMgmt
->eCurrMode
);
2398 bTKIP_UseGTK
= true;
2399 DBG_PRT(MSG_LEVEL_DEBUG
, KERN_DEBUG
"Get GTK.\n");
2404 if (pDevice
->bEnableHostWEP
) {
2405 DBG_PRT(MSG_LEVEL_DEBUG
, KERN_DEBUG
"acdma0: STA index %d\n", uNodeIndex
);
2406 if (pDevice
->bEncryptionEnable
== true) {
2407 pTransmitKey
= &STempKey
;
2408 pTransmitKey
->byCipherSuite
= pMgmt
->sNodeDBTable
[uNodeIndex
].byCipherSuite
;
2409 pTransmitKey
->dwKeyIndex
= pMgmt
->sNodeDBTable
[uNodeIndex
].dwKeyIndex
;
2410 pTransmitKey
->uKeyLength
= pMgmt
->sNodeDBTable
[uNodeIndex
].uWepKeyLength
;
2411 pTransmitKey
->dwTSC47_16
= pMgmt
->sNodeDBTable
[uNodeIndex
].dwTSC47_16
;
2412 pTransmitKey
->wTSC15_0
= pMgmt
->sNodeDBTable
[uNodeIndex
].wTSC15_0
;
2413 memcpy(pTransmitKey
->abyKey
,
2414 &pMgmt
->sNodeDBTable
[uNodeIndex
].abyWepKey
[0],
2415 pTransmitKey
->uKeyLength
2420 byPktType
= (u8
)pDevice
->byPacketType
;
2422 if (pDevice
->bFixRate
) {
2423 if (pDevice
->byBBType
== BB_TYPE_11B
) {
2424 if (pDevice
->uConnectionRate
>= RATE_11M
) {
2425 pDevice
->wCurrentRate
= RATE_11M
;
2427 pDevice
->wCurrentRate
= (u16
)pDevice
->uConnectionRate
;
2430 if ((pDevice
->byBBType
== BB_TYPE_11A
) &&
2431 (pDevice
->uConnectionRate
<= RATE_6M
)) {
2432 pDevice
->wCurrentRate
= RATE_6M
;
2434 if (pDevice
->uConnectionRate
>= RATE_54M
)
2435 pDevice
->wCurrentRate
= RATE_54M
;
2437 pDevice
->wCurrentRate
= (u16
)pDevice
->uConnectionRate
;
2442 if (pDevice
->eOPMode
== OP_MODE_ADHOC
) {
2443 // Adhoc Tx rate decided from node DB
2444 if (is_multicast_ether_addr(pDevice
->sTxEthHeader
.h_dest
)) {
2445 // Multicast use highest data rate
2446 pDevice
->wCurrentRate
= pMgmt
->sNodeDBTable
[0].wTxDataRate
;
2448 pDevice
->byPreambleType
= pDevice
->byShortPreamble
;
2451 if (BSSbIsSTAInNodeDB(pDevice
, &(pDevice
->sTxEthHeader
.h_dest
[0]), &uNodeIndex
)) {
2452 pDevice
->wCurrentRate
= pMgmt
->sNodeDBTable
[uNodeIndex
].wTxDataRate
;
2453 if (pMgmt
->sNodeDBTable
[uNodeIndex
].bShortPreamble
) {
2454 pDevice
->byPreambleType
= pDevice
->byShortPreamble
;
2458 pDevice
->byPreambleType
= PREAMBLE_LONG
;
2460 DBG_PRT(MSG_LEVEL_DEBUG
, KERN_INFO
"Found Node Index is [%d] Tx Data Rate:[%d]\n",uNodeIndex
, pDevice
->wCurrentRate
);
2463 if (pDevice
->byBBType
!= BB_TYPE_11A
)
2464 pDevice
->wCurrentRate
= RATE_2M
;
2466 pDevice
->wCurrentRate
= RATE_24M
; // refer to vMgrCreateOwnIBSS()'s
2467 // abyCurrExtSuppRates[]
2468 pDevice
->byPreambleType
= PREAMBLE_SHORT
;
2469 DBG_PRT(MSG_LEVEL_DEBUG
, KERN_INFO
"Not Found Node use highest basic Rate.....\n");
2473 if (pDevice
->eOPMode
== OP_MODE_INFRASTRUCTURE
) {
2474 // Infra STA rate decided from AP Node, index = 0
2475 pDevice
->wCurrentRate
= pMgmt
->sNodeDBTable
[0].wTxDataRate
;
2479 if (pDevice
->sTxEthHeader
.h_proto
== cpu_to_be16(ETH_P_PAE
)) {
2480 if (pDevice
->byBBType
!= BB_TYPE_11A
) {
2481 pDevice
->wCurrentRate
= RATE_1M
;
2482 pDevice
->byACKRate
= RATE_1M
;
2483 pDevice
->byTopCCKBasicRate
= RATE_1M
;
2484 pDevice
->byTopOFDMBasicRate
= RATE_6M
;
2486 pDevice
->wCurrentRate
= RATE_6M
;
2487 pDevice
->byACKRate
= RATE_6M
;
2488 pDevice
->byTopCCKBasicRate
= RATE_1M
;
2489 pDevice
->byTopOFDMBasicRate
= RATE_6M
;
2493 DBG_PRT(MSG_LEVEL_DEBUG
,
2494 KERN_INFO
"dma_tx: pDevice->wCurrentRate = %d\n",
2495 pDevice
->wCurrentRate
);
2497 if (wKeepRate
!= pDevice
->wCurrentRate
) {
2498 bScheduleCommand((void *) pDevice
, WLAN_CMD_SETPOWER
, NULL
);
2501 if (pDevice
->wCurrentRate
<= RATE_11M
) {
2502 byPktType
= PK_TYPE_11B
;
2505 if (bNeedEncryption
== true) {
2506 DBG_PRT(MSG_LEVEL_DEBUG
, KERN_INFO
"ntohs Pkt Type=%04x\n", ntohs(pDevice
->sTxEthHeader
.h_proto
));
2507 if ((pDevice
->sTxEthHeader
.h_proto
) == cpu_to_be16(ETH_P_PAE
)) {
2508 bNeedEncryption
= false;
2509 DBG_PRT(MSG_LEVEL_DEBUG
, KERN_INFO
"Pkt Type=%04x\n", (pDevice
->sTxEthHeader
.h_proto
));
2510 if ((pMgmt
->eCurrMode
== WMAC_MODE_ESS_STA
) && (pMgmt
->eCurrState
== WMAC_STATE_ASSOC
)) {
2511 if (pTransmitKey
== NULL
) {
2512 DBG_PRT(MSG_LEVEL_DEBUG
, KERN_INFO
"Don't Find TX KEY\n");
2515 if (bTKIP_UseGTK
== true) {
2516 DBG_PRT(MSG_LEVEL_DEBUG
, KERN_INFO
"error: KEY is GTK!!~~\n");
2519 DBG_PRT(MSG_LEVEL_DEBUG
, KERN_INFO
"Find PTK [%X]\n",
2520 pTransmitKey
->dwKeyIndex
);
2521 bNeedEncryption
= true;
2526 if (pDevice
->bEnableHostWEP
) {
2527 if ((uNodeIndex
!= 0) &&
2528 (pMgmt
->sNodeDBTable
[uNodeIndex
].dwKeyIndex
& PAIRWISE_KEY
)) {
2529 DBG_PRT(MSG_LEVEL_DEBUG
, KERN_INFO
"Find PTK [%X]\n",
2530 pTransmitKey
->dwKeyIndex
);
2531 bNeedEncryption
= true;
2537 if (pTransmitKey
== NULL
) {
2538 DBG_PRT(MSG_LEVEL_DEBUG
, KERN_INFO
"return no tx key\n");
2539 pContext
->bBoolInUse
= false;
2540 dev_kfree_skb_irq(skb
);
2541 pStats
->tx_dropped
++;
2542 return STATUS_FAILURE
;
2547 pTX_Buffer
= (struct vnt_tx_buffer
*)&pContext
->Data
[0];
2549 fConvertedPacket
= s_bPacketToWirelessUsb(pDevice
, byPktType
,
2550 pTX_Buffer
, bNeedEncryption
,
2551 skb
->len
, uDMAIdx
, &pDevice
->sTxEthHeader
,
2552 (u8
*)skb
->data
, pTransmitKey
, uNodeIndex
,
2553 pDevice
->wCurrentRate
,
2554 &uHeaderLen
, &BytesToWrite
2557 if (fConvertedPacket
== false) {
2558 pContext
->bBoolInUse
= false;
2559 dev_kfree_skb_irq(skb
);
2560 return STATUS_FAILURE
;
2563 if ( pDevice
->bEnablePSMode
== true ) {
2564 if ( !pDevice
->bPSModeTxBurst
) {
2565 bScheduleCommand((void *) pDevice
,
2566 WLAN_CMD_MAC_DISPOWERSAVING
,
2568 pDevice
->bPSModeTxBurst
= true;
2572 pTX_Buffer
->byPKTNO
= (u8
) (((pDevice
->wCurrentRate
<<4) &0x00F0) | ((pDevice
->wSeqCounter
- 1) & 0x000F));
2573 pTX_Buffer
->wTxByteCount
= (u16
)BytesToWrite
;
2575 pContext
->pPacket
= skb
;
2576 pContext
->Type
= CONTEXT_DATA_PACKET
;
2577 pContext
->uBufLen
= (u16
)BytesToWrite
+ 4 ; //USB header
2579 s_vSaveTxPktInfo(pDevice
, (u8
)(pTX_Buffer
->byPKTNO
& 0x0F),
2580 &pContext
->sEthHeader
.h_dest
[0],
2581 (u16
)(BytesToWrite
-uHeaderLen
),
2582 pTX_Buffer
->fifo_head
.wFIFOCtl
);
2584 status
= PIPEnsSendBulkOut(pDevice
,pContext
);
2586 if (bNeedDeAuth
== true) {
2587 u16 wReason
= WLAN_MGMT_REASON_MIC_FAILURE
;
2589 bScheduleCommand((void *) pDevice
, WLAN_CMD_DEAUTH
, (u8
*) &wReason
);
2592 if(status
!=STATUS_PENDING
) {
2593 pContext
->bBoolInUse
= false;
2594 dev_kfree_skb_irq(skb
);
2595 return STATUS_FAILURE
;
2604 * Relay packet send (AC1DMA) from rx dpc.
2608 * pDevice - Pointer to the adapter
2609 * pPacket - Pointer to rx packet
2610 * cbPacketSize - rx ethernet frame size
2614 * Return Value: Return true if packet is copy to dma1; otherwise false
2617 int bRelayPacketSend(struct vnt_private
*pDevice
, u8
*pbySkbData
, u32 uDataLen
,
2620 struct vnt_manager
*pMgmt
= &pDevice
->vnt_mgmt
;
2621 struct vnt_tx_buffer
*pTX_Buffer
;
2622 u32 BytesToWrite
= 0, uHeaderLen
= 0;
2623 u8 byPktType
= PK_TYPE_11B
;
2624 int bNeedEncryption
= false;
2626 PSKeyItem pTransmitKey
= NULL
;
2628 struct vnt_usb_send_context
*pContext
;
2630 int fConvertedPacket
;
2632 u16 wKeepRate
= pDevice
->wCurrentRate
;
2634 pContext
= (struct vnt_usb_send_context
*)s_vGetFreeContext(pDevice
);
2636 if (NULL
== pContext
) {
2640 memcpy(pDevice
->sTxEthHeader
.h_dest
, (u8
*)pbySkbData
, ETH_HLEN
);
2642 if (pDevice
->bEncryptionEnable
== true) {
2643 bNeedEncryption
= true;
2645 pbyBSSID
= pDevice
->abyBroadcastAddr
;
2646 if(KeybGetTransmitKey(&(pDevice
->sKey
), pbyBSSID
, GROUP_KEY
, &pTransmitKey
) == false) {
2647 pTransmitKey
= NULL
;
2648 DBG_PRT(MSG_LEVEL_DEBUG
, KERN_DEBUG
"KEY is NULL. [%d]\n", pMgmt
->eCurrMode
);
2650 DBG_PRT(MSG_LEVEL_DEBUG
, KERN_DEBUG
"Get GTK.\n");
2654 if (pDevice
->bEnableHostWEP
) {
2655 if (uNodeIndex
< MAX_NODE_NUM
+ 1) {
2656 pTransmitKey
= &STempKey
;
2657 pTransmitKey
->byCipherSuite
= pMgmt
->sNodeDBTable
[uNodeIndex
].byCipherSuite
;
2658 pTransmitKey
->dwKeyIndex
= pMgmt
->sNodeDBTable
[uNodeIndex
].dwKeyIndex
;
2659 pTransmitKey
->uKeyLength
= pMgmt
->sNodeDBTable
[uNodeIndex
].uWepKeyLength
;
2660 pTransmitKey
->dwTSC47_16
= pMgmt
->sNodeDBTable
[uNodeIndex
].dwTSC47_16
;
2661 pTransmitKey
->wTSC15_0
= pMgmt
->sNodeDBTable
[uNodeIndex
].wTSC15_0
;
2662 memcpy(pTransmitKey
->abyKey
,
2663 &pMgmt
->sNodeDBTable
[uNodeIndex
].abyWepKey
[0],
2664 pTransmitKey
->uKeyLength
2669 if ( bNeedEncryption
&& (pTransmitKey
== NULL
) ) {
2670 pContext
->bBoolInUse
= false;
2674 byPktTyp
= (u8
)pDevice
->byPacketType
;
2676 if (pDevice
->bFixRate
) {
2677 if (pDevice
->byBBType
== BB_TYPE_11B
) {
2678 if (pDevice
->uConnectionRate
>= RATE_11M
) {
2679 pDevice
->wCurrentRate
= RATE_11M
;
2681 pDevice
->wCurrentRate
= (u16
)pDevice
->uConnectionRate
;
2684 if ((pDevice
->byBBType
== BB_TYPE_11A
) &&
2685 (pDevice
->uConnectionRate
<= RATE_6M
)) {
2686 pDevice
->wCurrentRate
= RATE_6M
;
2688 if (pDevice
->uConnectionRate
>= RATE_54M
)
2689 pDevice
->wCurrentRate
= RATE_54M
;
2691 pDevice
->wCurrentRate
= (u16
)pDevice
->uConnectionRate
;
2696 pDevice
->wCurrentRate
= pMgmt
->sNodeDBTable
[uNodeIndex
].wTxDataRate
;
2699 if (wKeepRate
!= pDevice
->wCurrentRate
) {
2700 bScheduleCommand((void *) pDevice
, WLAN_CMD_SETPOWER
, NULL
);
2703 if (pDevice
->wCurrentRate
<= RATE_11M
)
2704 byPktType
= PK_TYPE_11B
;
2706 BytesToWrite
= uDataLen
+ ETH_FCS_LEN
;
2708 // Convert the packet to an usb frame and copy into our buffer
2709 // and send the irp.
2711 pTX_Buffer
= (struct vnt_tx_buffer
*)&pContext
->Data
[0];
2713 fConvertedPacket
= s_bPacketToWirelessUsb(pDevice
, byPktType
,
2714 pTX_Buffer
, bNeedEncryption
,
2715 uDataLen
, TYPE_AC0DMA
, &pDevice
->sTxEthHeader
,
2716 pbySkbData
, pTransmitKey
, uNodeIndex
,
2717 pDevice
->wCurrentRate
,
2718 &uHeaderLen
, &BytesToWrite
2721 if (fConvertedPacket
== false) {
2722 pContext
->bBoolInUse
= false;
2726 pTX_Buffer
->byPKTNO
= (u8
) (((pDevice
->wCurrentRate
<<4) &0x00F0) | ((pDevice
->wSeqCounter
- 1) & 0x000F));
2727 pTX_Buffer
->wTxByteCount
= (u16
)BytesToWrite
;
2729 pContext
->pPacket
= NULL
;
2730 pContext
->Type
= CONTEXT_DATA_PACKET
;
2731 pContext
->uBufLen
= (u16
)BytesToWrite
+ 4 ; //USB header
2733 s_vSaveTxPktInfo(pDevice
, (u8
)(pTX_Buffer
->byPKTNO
& 0x0F),
2734 &pContext
->sEthHeader
.h_dest
[0],
2735 (u16
)(BytesToWrite
- uHeaderLen
),
2736 pTX_Buffer
->fifo_head
.wFIFOCtl
);
2738 status
= PIPEnsSendBulkOut(pDevice
,pContext
);