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 * vGenerateMACHeader - Translate 802.3 to 802.11 header
30 * cbGetFragCount - Calculate fragment number count
31 * csBeacon_xmit - beacon tx function
32 * csMgmt_xmit - management tx function
33 * s_cbFillTxBufHead - fulfill tx dma buffer header
34 * s_uGetDataDuration - get tx data required duration
35 * s_uFillDataHead- fulfill tx data duration header
36 * s_uGetRTSCTSDuration- get rtx/cts required duration
37 * s_uGetRTSCTSRsvTime- get rts/cts reserved time
38 * s_uGetTxRsvTime- get frame reserved time
39 * s_vFillCTSHead- fulfill CTS ctl header
40 * s_vFillFragParameter- Set fragment ctl parameter.
41 * s_vFillRTSHead- fulfill RTS ctl header
42 * s_vFillTxKey- fulfill tx encrypt key
43 * s_vSWencryption- Software encrypt header
44 * vDMA0_tx_80211- tx 802.11 frame via dma0
45 * vGenerateFIFOHeader- Generate tx FIFO ctl header
58 /*--------------------- Static Definitions -------------------------*/
60 /*--------------------- Static Classes ----------------------------*/
62 /*--------------------- Static Variables --------------------------*/
64 /*--------------------- Static Functions --------------------------*/
66 /*--------------------- Static Definitions -------------------------*/
67 #define CRITICAL_PACKET_LEN 256 // if packet size < 256 -> in-direct send
68 // packet size >= 256 -> direct send
70 static const unsigned short wTimeStampOff
[2][MAX_RATE
] = {
71 {384, 288, 226, 209, 54, 43, 37, 31, 28, 25, 24, 23}, // Long Preamble
72 {384, 192, 130, 113, 54, 43, 37, 31, 28, 25, 24, 23}, // Short Preamble
75 static const unsigned short wFB_Opt0
[2][5] = {
76 {RATE_12M
, RATE_18M
, RATE_24M
, RATE_36M
, RATE_48M
}, // fallback_rate0
77 {RATE_12M
, RATE_12M
, RATE_18M
, RATE_24M
, RATE_36M
}, // fallback_rate1
79 static const unsigned short wFB_Opt1
[2][5] = {
80 {RATE_12M
, RATE_18M
, RATE_24M
, RATE_24M
, RATE_36M
}, // fallback_rate0
81 {RATE_6M
, RATE_6M
, RATE_12M
, RATE_12M
, RATE_18M
}, // fallback_rate1
88 #define RTSDUR_BA_F0 4
89 #define RTSDUR_AA_F0 5
90 #define RTSDUR_BA_F1 6
91 #define RTSDUR_AA_F1 7
92 #define CTSDUR_BA_F0 8
93 #define CTSDUR_BA_F1 9
96 #define DATADUR_A_F0 12
97 #define DATADUR_A_F1 13
99 /*--------------------- Static Functions --------------------------*/
103 struct vnt_private
*pDevice
,
104 unsigned char byPktType
,
106 unsigned int cbFrameLength
,
109 struct ieee80211_hdr
*hdr
,
110 unsigned short wCurrentRate
,
111 unsigned char byFBOption
116 s_vGenerateTxParameter(
117 struct vnt_private
*pDevice
,
118 unsigned char byPktType
,
123 unsigned int cbFrameSize
,
125 unsigned int uDMAIdx
,
127 unsigned short wCurrentRate
131 s_cbFillTxBufHead(struct vnt_private
*pDevice
, unsigned char byPktType
,
132 unsigned char *pbyTxBufferAddr
,
133 unsigned int uDMAIdx
, PSTxDesc pHeadTD
,
134 unsigned int uNodeIndex
);
139 struct vnt_private
*pDevice
,
140 unsigned char byPktType
,
142 unsigned int cbFrameLength
,
143 unsigned int uDMAIdx
,
145 unsigned int uFragIdx
,
146 unsigned int cbLastFragmentSize
,
147 unsigned int uMACfragNum
,
148 unsigned char byFBOption
,
149 unsigned short wCurrentRate
,
153 /*--------------------- Export Variables --------------------------*/
155 static __le16
vnt_time_stamp_off(struct vnt_private
*priv
, u16 rate
)
157 return cpu_to_le16(wTimeStampOff
[priv
->byPreambleType
% 2]
161 /*byPktType : PK_TYPE_11A 0
169 struct vnt_private
*pDevice
,
170 unsigned char byPktType
,
171 unsigned int cbFrameLength
,
172 unsigned short wRate
,
176 unsigned int uDataTime
, uAckTime
;
178 uDataTime
= BBuGetFrameTime(pDevice
->byPreambleType
, byPktType
, cbFrameLength
, wRate
);
179 if (byPktType
== PK_TYPE_11B
) //llb,CCK mode
180 uAckTime
= BBuGetFrameTime(pDevice
->byPreambleType
, byPktType
, 14, (unsigned short)pDevice
->byTopCCKBasicRate
);
181 else //11g 2.4G OFDM mode & 11a 5G OFDM mode
182 uAckTime
= BBuGetFrameTime(pDevice
->byPreambleType
, byPktType
, 14, (unsigned short)pDevice
->byTopOFDMBasicRate
);
185 return uDataTime
+ pDevice
->uSIFS
+ uAckTime
;
190 static __le16
vnt_rxtx_rsvtime_le16(struct vnt_private
*priv
, u8 pkt_type
,
191 u32 frame_length
, u16 rate
, bool need_ack
)
193 return cpu_to_le16((u16
)s_uGetTxRsvTime(priv
, pkt_type
,
194 frame_length
, rate
, need_ack
));
197 //byFreqType: 0=>5GHZ 1=>2.4GHZ
201 struct vnt_private
*pDevice
,
202 unsigned char byRTSRsvType
,
203 unsigned char byPktType
,
204 unsigned int cbFrameLength
,
205 unsigned short wCurrentRate
208 unsigned int uRrvTime
, uRTSTime
, uCTSTime
, uAckTime
, uDataTime
;
210 uRrvTime
= uRTSTime
= uCTSTime
= uAckTime
= uDataTime
= 0;
212 uDataTime
= BBuGetFrameTime(pDevice
->byPreambleType
, byPktType
, cbFrameLength
, wCurrentRate
);
213 if (byRTSRsvType
== 0) { //RTSTxRrvTime_bb
214 uRTSTime
= BBuGetFrameTime(pDevice
->byPreambleType
, byPktType
, 20, pDevice
->byTopCCKBasicRate
);
215 uCTSTime
= uAckTime
= BBuGetFrameTime(pDevice
->byPreambleType
, byPktType
, 14, pDevice
->byTopCCKBasicRate
);
216 } else if (byRTSRsvType
== 1) { //RTSTxRrvTime_ba, only in 2.4GHZ
217 uRTSTime
= BBuGetFrameTime(pDevice
->byPreambleType
, byPktType
, 20, pDevice
->byTopCCKBasicRate
);
218 uCTSTime
= BBuGetFrameTime(pDevice
->byPreambleType
, byPktType
, 14, pDevice
->byTopCCKBasicRate
);
219 uAckTime
= BBuGetFrameTime(pDevice
->byPreambleType
, byPktType
, 14, pDevice
->byTopOFDMBasicRate
);
220 } else if (byRTSRsvType
== 2) { //RTSTxRrvTime_aa
221 uRTSTime
= BBuGetFrameTime(pDevice
->byPreambleType
, byPktType
, 20, pDevice
->byTopOFDMBasicRate
);
222 uCTSTime
= uAckTime
= BBuGetFrameTime(pDevice
->byPreambleType
, byPktType
, 14, pDevice
->byTopOFDMBasicRate
);
223 } else if (byRTSRsvType
== 3) { //CTSTxRrvTime_ba, only in 2.4GHZ
224 uCTSTime
= BBuGetFrameTime(pDevice
->byPreambleType
, byPktType
, 14, pDevice
->byTopCCKBasicRate
);
225 uAckTime
= BBuGetFrameTime(pDevice
->byPreambleType
, byPktType
, 14, pDevice
->byTopOFDMBasicRate
);
226 uRrvTime
= uCTSTime
+ uAckTime
+ uDataTime
+ 2*pDevice
->uSIFS
;
227 return cpu_to_le16((u16
)uRrvTime
);
231 uRrvTime
= uRTSTime
+ uCTSTime
+ uAckTime
+ uDataTime
+ 3*pDevice
->uSIFS
;
232 return cpu_to_le16((u16
)uRrvTime
);
235 //byFreqType 0: 5GHz, 1:2.4Ghz
239 struct vnt_private
*pDevice
,
240 unsigned char byDurType
,
241 unsigned int cbFrameLength
,
242 unsigned char byPktType
,
243 unsigned short wRate
,
245 unsigned int uFragIdx
,
246 unsigned int cbLastFragmentSize
,
247 unsigned int uMACfragNum
,
248 unsigned char byFBOption
252 unsigned int uAckTime
= 0, uNextPktTime
= 0;
254 if (uFragIdx
== (uMACfragNum
-1))
258 case DATADUR_B
: //DATADUR_B
259 if (((uMACfragNum
== 1)) || bLastFrag
) {//Non Frag or Last Frag
261 uAckTime
= BBuGetFrameTime(pDevice
->byPreambleType
, byPktType
, 14, pDevice
->byTopCCKBasicRate
);
262 return pDevice
->uSIFS
+ uAckTime
;
266 } else {//First Frag or Mid Frag
267 if (uFragIdx
== (uMACfragNum
-2))
268 uNextPktTime
= s_uGetTxRsvTime(pDevice
, byPktType
, cbLastFragmentSize
, wRate
, bNeedAck
);
270 uNextPktTime
= s_uGetTxRsvTime(pDevice
, byPktType
, cbFrameLength
, wRate
, bNeedAck
);
273 uAckTime
= BBuGetFrameTime(pDevice
->byPreambleType
, byPktType
, 14, pDevice
->byTopCCKBasicRate
);
274 return pDevice
->uSIFS
+ uAckTime
+ uNextPktTime
;
276 return pDevice
->uSIFS
+ uNextPktTime
;
281 case DATADUR_A
: //DATADUR_A
282 if (((uMACfragNum
== 1)) || bLastFrag
) {//Non Frag or Last Frag
284 uAckTime
= BBuGetFrameTime(pDevice
->byPreambleType
, byPktType
, 14, pDevice
->byTopOFDMBasicRate
);
285 return pDevice
->uSIFS
+ uAckTime
;
289 } else {//First Frag or Mid Frag
290 if (uFragIdx
== (uMACfragNum
-2))
291 uNextPktTime
= s_uGetTxRsvTime(pDevice
, byPktType
, cbLastFragmentSize
, wRate
, bNeedAck
);
293 uNextPktTime
= s_uGetTxRsvTime(pDevice
, byPktType
, cbFrameLength
, wRate
, bNeedAck
);
296 uAckTime
= BBuGetFrameTime(pDevice
->byPreambleType
, byPktType
, 14, pDevice
->byTopOFDMBasicRate
);
297 return pDevice
->uSIFS
+ uAckTime
+ uNextPktTime
;
299 return pDevice
->uSIFS
+ uNextPktTime
;
304 case DATADUR_A_F0
: //DATADUR_A_F0
305 if (((uMACfragNum
== 1)) || bLastFrag
) {//Non Frag or Last Frag
307 uAckTime
= BBuGetFrameTime(pDevice
->byPreambleType
, byPktType
, 14, pDevice
->byTopOFDMBasicRate
);
308 return pDevice
->uSIFS
+ uAckTime
;
312 } else { //First Frag or Mid Frag
313 if (byFBOption
== AUTO_FB_0
) {
314 if (wRate
< RATE_18M
)
316 else if (wRate
> RATE_54M
)
319 if (uFragIdx
== (uMACfragNum
-2))
320 uNextPktTime
= s_uGetTxRsvTime(pDevice
, byPktType
, cbLastFragmentSize
, wFB_Opt0
[FB_RATE0
][wRate
-RATE_18M
], bNeedAck
);
322 uNextPktTime
= s_uGetTxRsvTime(pDevice
, byPktType
, cbFrameLength
, wFB_Opt0
[FB_RATE0
][wRate
-RATE_18M
], bNeedAck
);
324 } else { // (byFBOption == AUTO_FB_1)
325 if (wRate
< RATE_18M
)
327 else if (wRate
> RATE_54M
)
330 if (uFragIdx
== (uMACfragNum
-2))
331 uNextPktTime
= s_uGetTxRsvTime(pDevice
, byPktType
, cbLastFragmentSize
, wFB_Opt1
[FB_RATE0
][wRate
-RATE_18M
], bNeedAck
);
333 uNextPktTime
= s_uGetTxRsvTime(pDevice
, byPktType
, cbFrameLength
, wFB_Opt1
[FB_RATE0
][wRate
-RATE_18M
], bNeedAck
);
338 uAckTime
= BBuGetFrameTime(pDevice
->byPreambleType
, byPktType
, 14, pDevice
->byTopOFDMBasicRate
);
339 return pDevice
->uSIFS
+ uAckTime
+ uNextPktTime
;
341 return pDevice
->uSIFS
+ uNextPktTime
;
346 case DATADUR_A_F1
: //DATADUR_A_F1
347 if (((uMACfragNum
== 1)) || bLastFrag
) {//Non Frag or Last Frag
349 uAckTime
= BBuGetFrameTime(pDevice
->byPreambleType
, byPktType
, 14, pDevice
->byTopOFDMBasicRate
);
350 return pDevice
->uSIFS
+ uAckTime
;
354 } else { //First Frag or Mid Frag
355 if (byFBOption
== AUTO_FB_0
) {
356 if (wRate
< RATE_18M
)
358 else if (wRate
> RATE_54M
)
361 if (uFragIdx
== (uMACfragNum
-2))
362 uNextPktTime
= s_uGetTxRsvTime(pDevice
, byPktType
, cbLastFragmentSize
, wFB_Opt0
[FB_RATE1
][wRate
-RATE_18M
], bNeedAck
);
364 uNextPktTime
= s_uGetTxRsvTime(pDevice
, byPktType
, cbFrameLength
, wFB_Opt0
[FB_RATE1
][wRate
-RATE_18M
], bNeedAck
);
366 } else { // (byFBOption == AUTO_FB_1)
367 if (wRate
< RATE_18M
)
369 else if (wRate
> RATE_54M
)
372 if (uFragIdx
== (uMACfragNum
-2))
373 uNextPktTime
= s_uGetTxRsvTime(pDevice
, byPktType
, cbLastFragmentSize
, wFB_Opt1
[FB_RATE1
][wRate
-RATE_18M
], bNeedAck
);
375 uNextPktTime
= s_uGetTxRsvTime(pDevice
, byPktType
, cbFrameLength
, wFB_Opt1
[FB_RATE1
][wRate
-RATE_18M
], bNeedAck
);
378 uAckTime
= BBuGetFrameTime(pDevice
->byPreambleType
, byPktType
, 14, pDevice
->byTopOFDMBasicRate
);
379 return pDevice
->uSIFS
+ uAckTime
+ uNextPktTime
;
381 return pDevice
->uSIFS
+ uNextPktTime
;
394 //byFreqType: 0=>5GHZ 1=>2.4GHZ
397 s_uGetRTSCTSDuration(
398 struct vnt_private
*pDevice
,
399 unsigned char byDurType
,
400 unsigned int cbFrameLength
,
401 unsigned char byPktType
,
402 unsigned short wRate
,
404 unsigned char byFBOption
407 unsigned int uCTSTime
= 0, uDurTime
= 0;
410 case RTSDUR_BB
: //RTSDuration_bb
411 uCTSTime
= BBuGetFrameTime(pDevice
->byPreambleType
, byPktType
, 14, pDevice
->byTopCCKBasicRate
);
412 uDurTime
= uCTSTime
+ 2*pDevice
->uSIFS
+ s_uGetTxRsvTime(pDevice
, byPktType
, cbFrameLength
, wRate
, bNeedAck
);
415 case RTSDUR_BA
: //RTSDuration_ba
416 uCTSTime
= BBuGetFrameTime(pDevice
->byPreambleType
, byPktType
, 14, pDevice
->byTopCCKBasicRate
);
417 uDurTime
= uCTSTime
+ 2*pDevice
->uSIFS
+ s_uGetTxRsvTime(pDevice
, byPktType
, cbFrameLength
, wRate
, bNeedAck
);
420 case RTSDUR_AA
: //RTSDuration_aa
421 uCTSTime
= BBuGetFrameTime(pDevice
->byPreambleType
, byPktType
, 14, pDevice
->byTopOFDMBasicRate
);
422 uDurTime
= uCTSTime
+ 2*pDevice
->uSIFS
+ s_uGetTxRsvTime(pDevice
, byPktType
, cbFrameLength
, wRate
, bNeedAck
);
425 case CTSDUR_BA
: //CTSDuration_ba
426 uDurTime
= pDevice
->uSIFS
+ s_uGetTxRsvTime(pDevice
, byPktType
, cbFrameLength
, wRate
, bNeedAck
);
429 case RTSDUR_BA_F0
: //RTSDuration_ba_f0
430 uCTSTime
= BBuGetFrameTime(pDevice
->byPreambleType
, byPktType
, 14, pDevice
->byTopCCKBasicRate
);
431 if ((byFBOption
== AUTO_FB_0
) && (wRate
>= RATE_18M
) && (wRate
<= RATE_54M
))
432 uDurTime
= uCTSTime
+ 2 * pDevice
->uSIFS
+ s_uGetTxRsvTime(pDevice
, byPktType
, cbFrameLength
, wFB_Opt0
[FB_RATE0
][wRate
-RATE_18M
], bNeedAck
);
433 else if ((byFBOption
== AUTO_FB_1
) && (wRate
>= RATE_18M
) && (wRate
<= RATE_54M
))
434 uDurTime
= uCTSTime
+ 2 * pDevice
->uSIFS
+ s_uGetTxRsvTime(pDevice
, byPktType
, cbFrameLength
, wFB_Opt1
[FB_RATE0
][wRate
-RATE_18M
], bNeedAck
);
438 case RTSDUR_AA_F0
: //RTSDuration_aa_f0
439 uCTSTime
= BBuGetFrameTime(pDevice
->byPreambleType
, byPktType
, 14, pDevice
->byTopOFDMBasicRate
);
440 if ((byFBOption
== AUTO_FB_0
) && (wRate
>= RATE_18M
) && (wRate
<= RATE_54M
))
441 uDurTime
= uCTSTime
+ 2*pDevice
->uSIFS
+ s_uGetTxRsvTime(pDevice
, byPktType
, cbFrameLength
, wFB_Opt0
[FB_RATE0
][wRate
-RATE_18M
], bNeedAck
);
442 else if ((byFBOption
== AUTO_FB_1
) && (wRate
>= RATE_18M
) && (wRate
<= RATE_54M
))
443 uDurTime
= uCTSTime
+ 2*pDevice
->uSIFS
+ s_uGetTxRsvTime(pDevice
, byPktType
, cbFrameLength
, wFB_Opt1
[FB_RATE0
][wRate
-RATE_18M
], bNeedAck
);
447 case RTSDUR_BA_F1
: //RTSDuration_ba_f1
448 uCTSTime
= BBuGetFrameTime(pDevice
->byPreambleType
, byPktType
, 14, pDevice
->byTopCCKBasicRate
);
449 if ((byFBOption
== AUTO_FB_0
) && (wRate
>= RATE_18M
) && (wRate
<= RATE_54M
))
450 uDurTime
= uCTSTime
+ 2*pDevice
->uSIFS
+ s_uGetTxRsvTime(pDevice
, byPktType
, cbFrameLength
, wFB_Opt0
[FB_RATE1
][wRate
-RATE_18M
], bNeedAck
);
451 else if ((byFBOption
== AUTO_FB_1
) && (wRate
>= RATE_18M
) && (wRate
<= RATE_54M
))
452 uDurTime
= uCTSTime
+ 2*pDevice
->uSIFS
+ s_uGetTxRsvTime(pDevice
, byPktType
, cbFrameLength
, wFB_Opt1
[FB_RATE1
][wRate
-RATE_18M
], bNeedAck
);
456 case RTSDUR_AA_F1
: //RTSDuration_aa_f1
457 uCTSTime
= BBuGetFrameTime(pDevice
->byPreambleType
, byPktType
, 14, pDevice
->byTopOFDMBasicRate
);
458 if ((byFBOption
== AUTO_FB_0
) && (wRate
>= RATE_18M
) && (wRate
<= RATE_54M
))
459 uDurTime
= uCTSTime
+ 2*pDevice
->uSIFS
+ s_uGetTxRsvTime(pDevice
, byPktType
, cbFrameLength
, wFB_Opt0
[FB_RATE1
][wRate
-RATE_18M
], bNeedAck
);
460 else if ((byFBOption
== AUTO_FB_1
) && (wRate
>= RATE_18M
) && (wRate
<= RATE_54M
))
461 uDurTime
= uCTSTime
+ 2*pDevice
->uSIFS
+ s_uGetTxRsvTime(pDevice
, byPktType
, cbFrameLength
, wFB_Opt1
[FB_RATE1
][wRate
-RATE_18M
], bNeedAck
);
465 case CTSDUR_BA_F0
: //CTSDuration_ba_f0
466 if ((byFBOption
== AUTO_FB_0
) && (wRate
>= RATE_18M
) && (wRate
<= RATE_54M
))
467 uDurTime
= pDevice
->uSIFS
+ s_uGetTxRsvTime(pDevice
, byPktType
, cbFrameLength
, wFB_Opt0
[FB_RATE0
][wRate
-RATE_18M
], bNeedAck
);
468 else if ((byFBOption
== AUTO_FB_1
) && (wRate
>= RATE_18M
) && (wRate
<= RATE_54M
))
469 uDurTime
= pDevice
->uSIFS
+ s_uGetTxRsvTime(pDevice
, byPktType
, cbFrameLength
, wFB_Opt1
[FB_RATE0
][wRate
-RATE_18M
], bNeedAck
);
473 case CTSDUR_BA_F1
: //CTSDuration_ba_f1
474 if ((byFBOption
== AUTO_FB_0
) && (wRate
>= RATE_18M
) && (wRate
<= RATE_54M
))
475 uDurTime
= 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
= pDevice
->uSIFS
+ s_uGetTxRsvTime(pDevice
, byPktType
, cbFrameLength
, wFB_Opt1
[FB_RATE1
][wRate
-RATE_18M
], bNeedAck
);
485 return cpu_to_le16((u16
)uDurTime
);
491 struct vnt_private
*pDevice
,
492 unsigned char byPktType
,
494 unsigned int cbFrameLength
,
495 unsigned int uDMAIdx
,
497 unsigned int uFragIdx
,
498 unsigned int cbLastFragmentSize
,
499 unsigned int uMACfragNum
,
500 unsigned char byFBOption
,
501 unsigned short wCurrentRate
,
506 if (pTxDataHead
== NULL
)
510 if (byPktType
== PK_TYPE_11GB
|| byPktType
== PK_TYPE_11GA
) {
511 if (byFBOption
== AUTO_FB_NONE
) {
512 struct vnt_tx_datahead_g
*buf
= pTxDataHead
;
513 /* Get SignalField, ServiceField & Length */
514 vnt_get_phy_field(pDevice
, cbFrameLength
, wCurrentRate
,
517 vnt_get_phy_field(pDevice
, cbFrameLength
,
518 pDevice
->byTopCCKBasicRate
,
519 PK_TYPE_11B
, &buf
->b
);
522 __le16 dur
= cpu_to_le16(pDevice
->current_aid
| BIT(14) | BIT(15));
524 buf
->duration_a
= dur
;
525 buf
->duration_b
= dur
;
527 /* Get Duration and TimeStamp */
529 cpu_to_le16((u16
)s_uGetDataDuration(pDevice
, DATADUR_A
, cbFrameLength
,
530 byPktType
, wCurrentRate
, bNeedAck
, uFragIdx
,
531 cbLastFragmentSize
, uMACfragNum
,
534 cpu_to_le16((u16
)s_uGetDataDuration(pDevice
, DATADUR_B
, cbFrameLength
,
535 PK_TYPE_11B
, pDevice
->byTopCCKBasicRate
,
536 bNeedAck
, uFragIdx
, cbLastFragmentSize
,
537 uMACfragNum
, byFBOption
));
540 buf
->time_stamp_off_a
= vnt_time_stamp_off(pDevice
, wCurrentRate
);
541 buf
->time_stamp_off_b
= vnt_time_stamp_off(pDevice
, pDevice
->byTopCCKBasicRate
);
543 return buf
->duration_a
;
546 struct vnt_tx_datahead_g_fb
*buf
= pTxDataHead
;
547 /* Get SignalField, ServiceField & Length */
548 vnt_get_phy_field(pDevice
, cbFrameLength
, wCurrentRate
,
551 vnt_get_phy_field(pDevice
, cbFrameLength
,
552 pDevice
->byTopCCKBasicRate
,
553 PK_TYPE_11B
, &buf
->b
);
554 /* Get Duration and TimeStamp */
555 buf
->duration_a
= cpu_to_le16((u16
)s_uGetDataDuration(pDevice
, DATADUR_A
, cbFrameLength
, byPktType
,
556 wCurrentRate
, bNeedAck
, uFragIdx
, cbLastFragmentSize
, uMACfragNum
, byFBOption
));
557 buf
->duration_b
= cpu_to_le16((u16
)s_uGetDataDuration(pDevice
, DATADUR_B
, cbFrameLength
, PK_TYPE_11B
,
558 pDevice
->byTopCCKBasicRate
, bNeedAck
, uFragIdx
, cbLastFragmentSize
, uMACfragNum
, byFBOption
));
559 buf
->duration_a_f0
= cpu_to_le16((u16
)s_uGetDataDuration(pDevice
, DATADUR_A_F0
, cbFrameLength
, byPktType
,
560 wCurrentRate
, bNeedAck
, uFragIdx
, cbLastFragmentSize
, uMACfragNum
, byFBOption
));
561 buf
->duration_a_f1
= cpu_to_le16((u16
)s_uGetDataDuration(pDevice
, DATADUR_A_F1
, cbFrameLength
, byPktType
,
562 wCurrentRate
, bNeedAck
, uFragIdx
, cbLastFragmentSize
, uMACfragNum
, byFBOption
));
564 buf
->time_stamp_off_a
= vnt_time_stamp_off(pDevice
, wCurrentRate
);
565 buf
->time_stamp_off_b
= vnt_time_stamp_off(pDevice
, pDevice
->byTopCCKBasicRate
);
567 return buf
->duration_a
;
568 } //if (byFBOption == AUTO_FB_NONE)
569 } else if (byPktType
== PK_TYPE_11A
) {
570 if ((byFBOption
!= AUTO_FB_NONE
)) {
572 struct vnt_tx_datahead_a_fb
*buf
= pTxDataHead
;
573 /* Get SignalField, ServiceField & Length */
574 vnt_get_phy_field(pDevice
, cbFrameLength
, wCurrentRate
,
577 /* Get Duration and TimeStampOff */
578 buf
->duration
= cpu_to_le16((u16
)s_uGetDataDuration(pDevice
, DATADUR_A
, cbFrameLength
, byPktType
,
579 wCurrentRate
, bNeedAck
, uFragIdx
, cbLastFragmentSize
, uMACfragNum
, byFBOption
));
580 buf
->duration_f0
= cpu_to_le16((u16
)s_uGetDataDuration(pDevice
, DATADUR_A_F0
, cbFrameLength
, byPktType
,
581 wCurrentRate
, bNeedAck
, uFragIdx
, cbLastFragmentSize
, uMACfragNum
, byFBOption
));
582 buf
->duration_f1
= cpu_to_le16((u16
)s_uGetDataDuration(pDevice
, DATADUR_A_F1
, cbFrameLength
, byPktType
,
583 wCurrentRate
, bNeedAck
, uFragIdx
, cbLastFragmentSize
, uMACfragNum
, byFBOption
));
584 buf
->time_stamp_off
= vnt_time_stamp_off(pDevice
, wCurrentRate
);
585 return buf
->duration
;
587 struct vnt_tx_datahead_ab
*buf
= pTxDataHead
;
588 /* Get SignalField, ServiceField & Length */
589 vnt_get_phy_field(pDevice
, cbFrameLength
, wCurrentRate
,
590 byPktType
, &buf
->ab
);
593 __le16 dur
= cpu_to_le16(pDevice
->current_aid
| BIT(14) | BIT(15));
597 /* Get Duration and TimeStampOff */
599 cpu_to_le16((u16
)s_uGetDataDuration(pDevice
, DATADUR_A
, cbFrameLength
, byPktType
,
600 wCurrentRate
, bNeedAck
, uFragIdx
,
601 cbLastFragmentSize
, uMACfragNum
,
605 buf
->time_stamp_off
= vnt_time_stamp_off(pDevice
, wCurrentRate
);
606 return buf
->duration
;
609 struct vnt_tx_datahead_ab
*buf
= pTxDataHead
;
610 /* Get SignalField, ServiceField & Length */
611 vnt_get_phy_field(pDevice
, cbFrameLength
, wCurrentRate
,
612 byPktType
, &buf
->ab
);
615 __le16 dur
= cpu_to_le16(pDevice
->current_aid
| BIT(14) | BIT(15));
619 /* Get Duration and TimeStampOff */
621 cpu_to_le16((u16
)s_uGetDataDuration(pDevice
, DATADUR_B
, cbFrameLength
, byPktType
,
622 wCurrentRate
, bNeedAck
, uFragIdx
,
623 cbLastFragmentSize
, uMACfragNum
,
627 buf
->time_stamp_off
= vnt_time_stamp_off(pDevice
, wCurrentRate
);
628 return buf
->duration
;
637 struct vnt_private
*pDevice
,
638 unsigned char byPktType
,
640 unsigned int cbFrameLength
,
643 struct ieee80211_hdr
*hdr
,
644 unsigned short wCurrentRate
,
645 unsigned char byFBOption
648 unsigned int uRTSFrameLen
= 20;
654 // When CRCDIS bit is on, H/W forgot to generate FCS for RTS frame,
655 // in this case we need to decrease its length by 4.
659 // Note: So far RTSHead dosen't appear in ATIM & Beacom DMA, so we don't need to take them into account.
660 // Otherwise, we need to modify codes for them.
661 if (byPktType
== PK_TYPE_11GB
|| byPktType
== PK_TYPE_11GA
) {
662 if (byFBOption
== AUTO_FB_NONE
) {
663 struct vnt_rts_g
*buf
= pvRTS
;
664 /* Get SignalField, ServiceField & Length */
665 vnt_get_phy_field(pDevice
, uRTSFrameLen
,
666 pDevice
->byTopCCKBasicRate
,
667 PK_TYPE_11B
, &buf
->b
);
669 vnt_get_phy_field(pDevice
, uRTSFrameLen
,
670 pDevice
->byTopOFDMBasicRate
,
674 s_uGetRTSCTSDuration(pDevice
, RTSDUR_BB
,
675 cbFrameLength
, PK_TYPE_11B
,
676 pDevice
->byTopCCKBasicRate
,
677 bNeedAck
, byFBOption
);
679 s_uGetRTSCTSDuration(pDevice
, RTSDUR_AA
,
680 cbFrameLength
, byPktType
,
681 wCurrentRate
, bNeedAck
,
684 s_uGetRTSCTSDuration(pDevice
, RTSDUR_BA
,
685 cbFrameLength
, byPktType
,
686 wCurrentRate
, bNeedAck
,
689 buf
->data
.duration
= buf
->duration_aa
;
690 /* Get RTS Frame body */
691 buf
->data
.frame_control
=
692 cpu_to_le16(IEEE80211_FTYPE_CTL
|
693 IEEE80211_STYPE_RTS
);
695 ether_addr_copy(buf
->data
.ra
, hdr
->addr1
);
696 ether_addr_copy(buf
->data
.ta
, hdr
->addr2
);
698 struct vnt_rts_g_fb
*buf
= pvRTS
;
699 /* Get SignalField, ServiceField & Length */
700 vnt_get_phy_field(pDevice
, uRTSFrameLen
,
701 pDevice
->byTopCCKBasicRate
,
702 PK_TYPE_11B
, &buf
->b
);
704 vnt_get_phy_field(pDevice
, uRTSFrameLen
,
705 pDevice
->byTopOFDMBasicRate
,
709 s_uGetRTSCTSDuration(pDevice
, RTSDUR_BB
,
710 cbFrameLength
, PK_TYPE_11B
,
711 pDevice
->byTopCCKBasicRate
,
712 bNeedAck
, byFBOption
);
714 s_uGetRTSCTSDuration(pDevice
, RTSDUR_AA
,
715 cbFrameLength
, byPktType
,
716 wCurrentRate
, bNeedAck
,
719 s_uGetRTSCTSDuration(pDevice
, RTSDUR_BA
,
720 cbFrameLength
, byPktType
,
721 wCurrentRate
, bNeedAck
,
723 buf
->rts_duration_ba_f0
=
724 s_uGetRTSCTSDuration(pDevice
, RTSDUR_BA_F0
,
725 cbFrameLength
, byPktType
,
726 wCurrentRate
, bNeedAck
,
728 buf
->rts_duration_aa_f0
=
729 s_uGetRTSCTSDuration(pDevice
, RTSDUR_AA_F0
,
730 cbFrameLength
, byPktType
,
731 wCurrentRate
, bNeedAck
,
733 buf
->rts_duration_ba_f1
=
734 s_uGetRTSCTSDuration(pDevice
, RTSDUR_BA_F1
,
735 cbFrameLength
, byPktType
,
736 wCurrentRate
, bNeedAck
,
738 buf
->rts_duration_aa_f1
=
739 s_uGetRTSCTSDuration(pDevice
, RTSDUR_AA_F1
,
740 cbFrameLength
, byPktType
,
741 wCurrentRate
, bNeedAck
,
743 buf
->data
.duration
= buf
->duration_aa
;
744 /* Get RTS Frame body */
745 buf
->data
.frame_control
=
746 cpu_to_le16(IEEE80211_FTYPE_CTL
|
747 IEEE80211_STYPE_RTS
);
749 ether_addr_copy(buf
->data
.ra
, hdr
->addr1
);
750 ether_addr_copy(buf
->data
.ta
, hdr
->addr2
);
751 } // if (byFBOption == AUTO_FB_NONE)
752 } else if (byPktType
== PK_TYPE_11A
) {
753 if (byFBOption
== AUTO_FB_NONE
) {
754 struct vnt_rts_ab
*buf
= pvRTS
;
755 /* Get SignalField, ServiceField & Length */
756 vnt_get_phy_field(pDevice
, uRTSFrameLen
,
757 pDevice
->byTopOFDMBasicRate
,
758 byPktType
, &buf
->ab
);
761 s_uGetRTSCTSDuration(pDevice
, RTSDUR_AA
,
762 cbFrameLength
, byPktType
,
763 wCurrentRate
, bNeedAck
,
765 buf
->data
.duration
= buf
->duration
;
766 /* Get RTS Frame body */
767 buf
->data
.frame_control
=
768 cpu_to_le16(IEEE80211_FTYPE_CTL
|
769 IEEE80211_STYPE_RTS
);
771 ether_addr_copy(buf
->data
.ra
, hdr
->addr1
);
772 ether_addr_copy(buf
->data
.ta
, hdr
->addr2
);
774 struct vnt_rts_a_fb
*buf
= pvRTS
;
775 /* Get SignalField, ServiceField & Length */
776 vnt_get_phy_field(pDevice
, uRTSFrameLen
,
777 pDevice
->byTopOFDMBasicRate
,
781 s_uGetRTSCTSDuration(pDevice
, RTSDUR_AA
,
782 cbFrameLength
, byPktType
,
783 wCurrentRate
, bNeedAck
,
785 buf
->rts_duration_f0
=
786 s_uGetRTSCTSDuration(pDevice
, RTSDUR_AA_F0
,
787 cbFrameLength
, byPktType
,
788 wCurrentRate
, bNeedAck
,
790 buf
->rts_duration_f1
=
791 s_uGetRTSCTSDuration(pDevice
, RTSDUR_AA_F1
,
792 cbFrameLength
, byPktType
,
793 wCurrentRate
, bNeedAck
,
795 buf
->data
.duration
= buf
->duration
;
796 /* Get RTS Frame body */
797 buf
->data
.frame_control
=
798 cpu_to_le16(IEEE80211_FTYPE_CTL
|
799 IEEE80211_STYPE_RTS
);
801 ether_addr_copy(buf
->data
.ra
, hdr
->addr1
);
802 ether_addr_copy(buf
->data
.ta
, hdr
->addr2
);
804 } else if (byPktType
== PK_TYPE_11B
) {
805 struct vnt_rts_ab
*buf
= pvRTS
;
806 /* Get SignalField, ServiceField & Length */
807 vnt_get_phy_field(pDevice
, uRTSFrameLen
,
808 pDevice
->byTopCCKBasicRate
,
809 PK_TYPE_11B
, &buf
->ab
);
812 s_uGetRTSCTSDuration(pDevice
, RTSDUR_BB
, cbFrameLength
,
813 byPktType
, wCurrentRate
, bNeedAck
,
816 buf
->data
.duration
= buf
->duration
;
817 /* Get RTS Frame body */
818 buf
->data
.frame_control
=
819 cpu_to_le16(IEEE80211_FTYPE_CTL
| IEEE80211_STYPE_RTS
);
821 ether_addr_copy(buf
->data
.ra
, hdr
->addr1
);
822 ether_addr_copy(buf
->data
.ta
, hdr
->addr2
);
829 struct vnt_private
*pDevice
,
830 unsigned int uDMAIdx
,
831 unsigned char byPktType
,
833 unsigned int cbFrameLength
,
836 unsigned short wCurrentRate
,
837 unsigned char byFBOption
840 unsigned int uCTSFrameLen
= 14;
846 // When CRCDIS bit is on, H/W forgot to generate FCS for CTS frame,
847 // in this case we need to decrease its length by 4.
851 if (byPktType
== PK_TYPE_11GB
|| byPktType
== PK_TYPE_11GA
) {
852 if (byFBOption
!= AUTO_FB_NONE
&& uDMAIdx
!= TYPE_ATIMDMA
&& uDMAIdx
!= TYPE_BEACONDMA
) {
854 struct vnt_cts_fb
*buf
= pvCTS
;
855 /* Get SignalField, ServiceField & Length */
856 vnt_get_phy_field(pDevice
, uCTSFrameLen
,
857 pDevice
->byTopCCKBasicRate
,
858 PK_TYPE_11B
, &buf
->b
);
861 s_uGetRTSCTSDuration(pDevice
, CTSDUR_BA
,
862 cbFrameLength
, byPktType
,
863 wCurrentRate
, bNeedAck
,
866 /* Get CTSDuration_ba_f0 */
867 buf
->cts_duration_ba_f0
=
868 s_uGetRTSCTSDuration(pDevice
, CTSDUR_BA_F0
,
869 cbFrameLength
, byPktType
,
870 wCurrentRate
, bNeedAck
,
873 /* Get CTSDuration_ba_f1 */
874 buf
->cts_duration_ba_f1
=
875 s_uGetRTSCTSDuration(pDevice
, CTSDUR_BA_F1
,
876 cbFrameLength
, byPktType
,
877 wCurrentRate
, bNeedAck
,
880 /* Get CTS Frame body */
881 buf
->data
.duration
= buf
->duration_ba
;
883 buf
->data
.frame_control
=
884 cpu_to_le16(IEEE80211_FTYPE_CTL
|
885 IEEE80211_STYPE_CTS
);
887 buf
->reserved2
= 0x0;
889 ether_addr_copy(buf
->data
.ra
,
890 pDevice
->abyCurrentNetAddr
);
891 } else { //if (byFBOption != AUTO_FB_NONE && uDMAIdx != TYPE_ATIMDMA && uDMAIdx != TYPE_BEACONDMA)
892 struct vnt_cts
*buf
= pvCTS
;
893 /* Get SignalField, ServiceField & Length */
894 vnt_get_phy_field(pDevice
, uCTSFrameLen
,
895 pDevice
->byTopCCKBasicRate
,
896 PK_TYPE_11B
, &buf
->b
);
898 /* Get CTSDuration_ba */
900 s_uGetRTSCTSDuration(pDevice
, CTSDUR_BA
,
901 cbFrameLength
, byPktType
,
902 wCurrentRate
, bNeedAck
,
905 /* Get CTS Frame body */
906 buf
->data
.duration
= buf
->duration_ba
;
908 buf
->data
.frame_control
=
909 cpu_to_le16(IEEE80211_FTYPE_CTL
|
910 IEEE80211_STYPE_CTS
);
912 buf
->reserved2
= 0x0;
913 ether_addr_copy(buf
->data
.ra
,
914 pDevice
->abyCurrentNetAddr
);
922 * Generate FIFO control for MAC & Baseband controller
926 * pDevice - Pointer to adapter
927 * pTxDataHead - Transmit Data Buffer
928 * pTxBufHead - pTxBufHead
929 * pvRrvTime - pvRrvTime
932 * cbFrameSize - Transmit Data Length (Hdr+Payload+FCS)
933 * bNeedACK - If need ACK
934 * uDescIdx - Desc Index
941 // unsigned int cbFrameSize,//Hdr+Payload+FCS
944 s_vGenerateTxParameter(
945 struct vnt_private
*pDevice
,
946 unsigned char byPktType
,
951 unsigned int cbFrameSize
,
953 unsigned int uDMAIdx
,
955 unsigned short wCurrentRate
958 unsigned short wFifoCtl
;
959 bool bDisCRC
= false;
960 unsigned char byFBOption
= AUTO_FB_NONE
;
962 PSTxBufHead pFifoHead
= (PSTxBufHead
)pTxBufHead
;
964 pFifoHead
->wReserved
= wCurrentRate
;
965 wFifoCtl
= pFifoHead
->wFIFOCtl
;
967 if (wFifoCtl
& FIFOCTL_CRCDIS
)
970 if (wFifoCtl
& FIFOCTL_AUTO_FB_0
)
971 byFBOption
= AUTO_FB_0
;
972 else if (wFifoCtl
& FIFOCTL_AUTO_FB_1
)
973 byFBOption
= AUTO_FB_1
;
978 if (byPktType
== PK_TYPE_11GB
|| byPktType
== PK_TYPE_11GA
) {
979 if (pvRTS
!= NULL
) { //RTS_need
981 struct vnt_rrv_time_rts
*buf
= pvRrvTime
;
983 buf
->rts_rrv_time_aa
= s_uGetRTSCTSRsvTime(pDevice
, 2, byPktType
, cbFrameSize
, wCurrentRate
);
984 buf
->rts_rrv_time_ba
= s_uGetRTSCTSRsvTime(pDevice
, 1, byPktType
, cbFrameSize
, wCurrentRate
);
985 buf
->rts_rrv_time_bb
= s_uGetRTSCTSRsvTime(pDevice
, 0, byPktType
, cbFrameSize
, wCurrentRate
);
986 buf
->rrv_time_a
= vnt_rxtx_rsvtime_le16(pDevice
, byPktType
, cbFrameSize
, wCurrentRate
, bNeedACK
);
987 buf
->rrv_time_b
= vnt_rxtx_rsvtime_le16(pDevice
, PK_TYPE_11B
, cbFrameSize
, pDevice
->byTopCCKBasicRate
, bNeedACK
);
989 s_vFillRTSHead(pDevice
, byPktType
, pvRTS
, cbFrameSize
, bNeedACK
, bDisCRC
, psEthHeader
, wCurrentRate
, byFBOption
);
990 } else {//RTS_needless, PCF mode
991 struct vnt_rrv_time_cts
*buf
= pvRrvTime
;
993 buf
->rrv_time_a
= vnt_rxtx_rsvtime_le16(pDevice
, byPktType
, cbFrameSize
, wCurrentRate
, bNeedACK
);
994 buf
->rrv_time_b
= vnt_rxtx_rsvtime_le16(pDevice
, PK_TYPE_11B
, cbFrameSize
, pDevice
->byTopCCKBasicRate
, bNeedACK
);
995 buf
->cts_rrv_time_ba
= s_uGetRTSCTSRsvTime(pDevice
, 3, byPktType
, cbFrameSize
, wCurrentRate
);
998 s_vFillCTSHead(pDevice
, uDMAIdx
, byPktType
, pvCTS
, cbFrameSize
, bNeedACK
, bDisCRC
, wCurrentRate
, byFBOption
);
1000 } else if (byPktType
== PK_TYPE_11A
) {
1001 if (pvRTS
!= NULL
) {//RTS_need, non PCF mode
1002 struct vnt_rrv_time_ab
*buf
= pvRrvTime
;
1004 buf
->rts_rrv_time
= s_uGetRTSCTSRsvTime(pDevice
, 2, byPktType
, cbFrameSize
, wCurrentRate
);
1005 buf
->rrv_time
= vnt_rxtx_rsvtime_le16(pDevice
, byPktType
, cbFrameSize
, wCurrentRate
, bNeedACK
);
1008 s_vFillRTSHead(pDevice
, byPktType
, pvRTS
, cbFrameSize
, bNeedACK
, bDisCRC
, psEthHeader
, wCurrentRate
, byFBOption
);
1009 } else if (pvRTS
== NULL
) {//RTS_needless, non PCF mode
1010 struct vnt_rrv_time_ab
*buf
= pvRrvTime
;
1012 buf
->rrv_time
= vnt_rxtx_rsvtime_le16(pDevice
, PK_TYPE_11A
, cbFrameSize
, wCurrentRate
, bNeedACK
);
1014 } else if (byPktType
== PK_TYPE_11B
) {
1015 if ((pvRTS
!= NULL
)) {//RTS_need, non PCF mode
1016 struct vnt_rrv_time_ab
*buf
= pvRrvTime
;
1018 buf
->rts_rrv_time
= s_uGetRTSCTSRsvTime(pDevice
, 0, byPktType
, cbFrameSize
, wCurrentRate
);
1019 buf
->rrv_time
= vnt_rxtx_rsvtime_le16(pDevice
, PK_TYPE_11B
, cbFrameSize
, wCurrentRate
, bNeedACK
);
1022 s_vFillRTSHead(pDevice
, byPktType
, pvRTS
, cbFrameSize
, bNeedACK
, bDisCRC
, psEthHeader
, wCurrentRate
, byFBOption
);
1023 } else { //RTS_needless, non PCF mode
1024 struct vnt_rrv_time_ab
*buf
= pvRrvTime
;
1026 buf
->rrv_time
= vnt_rxtx_rsvtime_le16(pDevice
, PK_TYPE_11B
, cbFrameSize
, wCurrentRate
, bNeedACK
);
1032 s_cbFillTxBufHead(struct vnt_private
*pDevice
, unsigned char byPktType
,
1033 unsigned char *pbyTxBufferAddr
,
1034 unsigned int uDMAIdx
, PSTxDesc pHeadTD
,
1035 unsigned int is_pspoll
)
1037 PDEVICE_TD_INFO td_info
= pHeadTD
->pTDInfo
;
1038 struct sk_buff
*skb
= td_info
->skb
;
1039 struct ieee80211_tx_info
*info
= IEEE80211_SKB_CB(skb
);
1040 struct ieee80211_hdr
*hdr
= (struct ieee80211_hdr
*)skb
->data
;
1041 struct vnt_tx_fifo_head
*tx_buffer_head
=
1042 (struct vnt_tx_fifo_head
*)td_info
->buf
;
1043 u16 fifo_ctl
= le16_to_cpu(tx_buffer_head
->fifo_ctl
);
1044 unsigned int cbFrameSize
;
1046 unsigned char *pbyBuffer
;
1047 unsigned int uLength
= 0;
1048 unsigned int cbMICHDR
= 0;
1049 unsigned int uMACfragNum
= 1;
1050 unsigned int uPadding
= 0;
1051 unsigned int cbReqCount
= 0;
1052 bool bNeedACK
= (bool)(fifo_ctl
& FIFOCTL_NEEDACK
);
1053 bool bRTS
= (bool)(fifo_ctl
& FIFOCTL_RTS
);
1055 unsigned int cbHeaderLength
= 0;
1057 struct vnt_mic_hdr
*pMICHDR
;
1061 unsigned short wTxBufSize
; // FFinfo size
1062 unsigned char byFBOption
= AUTO_FB_NONE
;
1064 pvRrvTime
= pMICHDR
= pvRTS
= pvCTS
= pvTxDataHd
= NULL
;
1066 cbFrameSize
= skb
->len
+ 4;
1068 if (info
->control
.hw_key
) {
1069 switch (info
->control
.hw_key
->cipher
) {
1070 case WLAN_CIPHER_SUITE_CCMP
:
1071 cbMICHDR
= sizeof(struct vnt_mic_hdr
);
1076 cbFrameSize
+= info
->control
.hw_key
->icv_len
;
1078 if (pDevice
->byLocalID
> REV_ID_VT3253_A1
) {
1079 //MAC Header should be padding 0 to DW alignment.
1080 uPadding
= 4 - (ieee80211_get_hdrlen_from_skb(skb
) % 4);
1086 // Use for AUTO FALL BACK
1088 if (fifo_ctl
& FIFOCTL_AUTO_FB_0
)
1089 byFBOption
= AUTO_FB_0
;
1090 else if (fifo_ctl
& FIFOCTL_AUTO_FB_1
)
1091 byFBOption
= AUTO_FB_1
;
1093 //////////////////////////////////////////////////////
1094 //Set RrvTime/RTS/CTS Buffer
1095 wTxBufSize
= sizeof(STxBufHead
);
1096 if (byPktType
== PK_TYPE_11GB
|| byPktType
== PK_TYPE_11GA
) {//802.11g packet
1098 if (byFBOption
== AUTO_FB_NONE
) {
1099 if (bRTS
== true) {//RTS_need
1100 pvRrvTime
= (void *)(pbyTxBufferAddr
+ wTxBufSize
);
1101 pMICHDR
= (struct vnt_mic_hdr
*)(pbyTxBufferAddr
+ wTxBufSize
+ sizeof(struct vnt_rrv_time_rts
));
1102 pvRTS
= (void *)(pbyTxBufferAddr
+ wTxBufSize
+ sizeof(struct vnt_rrv_time_rts
) + cbMICHDR
);
1104 pvTxDataHd
= (void *)(pbyTxBufferAddr
+ wTxBufSize
+ sizeof(struct vnt_rrv_time_rts
) +
1105 cbMICHDR
+ sizeof(struct vnt_rts_g
));
1106 cbHeaderLength
= wTxBufSize
+ sizeof(struct vnt_rrv_time_rts
) +
1107 cbMICHDR
+ sizeof(struct vnt_rts_g
) +
1108 sizeof(struct vnt_tx_datahead_g
);
1109 } else { //RTS_needless
1110 pvRrvTime
= (void *)(pbyTxBufferAddr
+ wTxBufSize
);
1111 pMICHDR
= (struct vnt_mic_hdr
*) (pbyTxBufferAddr
+ wTxBufSize
+ sizeof(struct vnt_rrv_time_cts
));
1113 pvCTS
= (void *) (pbyTxBufferAddr
+ wTxBufSize
+ sizeof(struct vnt_rrv_time_cts
) + cbMICHDR
);
1114 pvTxDataHd
= (void *)(pbyTxBufferAddr
+ wTxBufSize
+
1115 sizeof(struct vnt_rrv_time_cts
) + cbMICHDR
+ sizeof(struct vnt_cts
));
1116 cbHeaderLength
= wTxBufSize
+ sizeof(struct vnt_rrv_time_cts
) +
1117 cbMICHDR
+ sizeof(struct vnt_cts
) + sizeof(struct vnt_tx_datahead_g
);
1121 if (bRTS
== true) {//RTS_need
1122 pvRrvTime
= (void *)(pbyTxBufferAddr
+ wTxBufSize
);
1123 pMICHDR
= (struct vnt_mic_hdr
*) (pbyTxBufferAddr
+ wTxBufSize
+ sizeof(struct vnt_rrv_time_rts
));
1124 pvRTS
= (void *) (pbyTxBufferAddr
+ wTxBufSize
+ sizeof(struct vnt_rrv_time_rts
) + cbMICHDR
);
1126 pvTxDataHd
= (void *)(pbyTxBufferAddr
+ wTxBufSize
+ sizeof(struct vnt_rrv_time_rts
) +
1127 cbMICHDR
+ sizeof(struct vnt_rts_g_fb
));
1128 cbHeaderLength
= wTxBufSize
+ sizeof(struct vnt_rrv_time_rts
) +
1129 cbMICHDR
+ sizeof(struct vnt_rts_g_fb
) + sizeof(struct vnt_tx_datahead_g_fb
);
1130 } else { //RTS_needless
1131 pvRrvTime
= (void *)(pbyTxBufferAddr
+ wTxBufSize
);
1132 pMICHDR
= (struct vnt_mic_hdr
*) (pbyTxBufferAddr
+ wTxBufSize
+ sizeof(struct vnt_rrv_time_cts
));
1134 pvCTS
= (void *)(pbyTxBufferAddr
+ wTxBufSize
+ sizeof(struct vnt_rrv_time_cts
) + cbMICHDR
);
1135 pvTxDataHd
= (void *)(pbyTxBufferAddr
+ wTxBufSize
+ sizeof(struct vnt_rrv_time_cts
) +
1136 cbMICHDR
+ sizeof(struct vnt_cts_fb
));
1137 cbHeaderLength
= wTxBufSize
+ sizeof(struct vnt_rrv_time_cts
) +
1138 cbMICHDR
+ sizeof(struct vnt_cts_fb
) + sizeof(struct vnt_tx_datahead_g_fb
);
1141 } else {//802.11a/b packet
1143 if (byFBOption
== AUTO_FB_NONE
) {
1145 pvRrvTime
= (void *)(pbyTxBufferAddr
+ wTxBufSize
);
1146 pMICHDR
= (struct vnt_mic_hdr
*) (pbyTxBufferAddr
+ wTxBufSize
+ sizeof(struct vnt_rrv_time_ab
));
1147 pvRTS
= (void *)(pbyTxBufferAddr
+ wTxBufSize
+ sizeof(struct vnt_rrv_time_ab
) + cbMICHDR
);
1149 pvTxDataHd
= (void *)(pbyTxBufferAddr
+ wTxBufSize
+
1150 sizeof(struct vnt_rrv_time_ab
) + cbMICHDR
+ sizeof(struct vnt_rts_ab
));
1151 cbHeaderLength
= wTxBufSize
+ sizeof(struct vnt_rrv_time_ab
) +
1152 cbMICHDR
+ sizeof(struct vnt_rts_ab
) + sizeof(struct vnt_tx_datahead_ab
);
1153 } else { //RTS_needless, need MICHDR
1154 pvRrvTime
= (void *)(pbyTxBufferAddr
+ wTxBufSize
);
1155 pMICHDR
= (struct vnt_mic_hdr
*) (pbyTxBufferAddr
+ wTxBufSize
+ sizeof(struct vnt_rrv_time_ab
));
1158 pvTxDataHd
= (void *)(pbyTxBufferAddr
+ wTxBufSize
+ sizeof(struct vnt_rrv_time_ab
) + cbMICHDR
);
1159 cbHeaderLength
= wTxBufSize
+ sizeof(struct vnt_rrv_time_ab
) +
1160 cbMICHDR
+ sizeof(struct vnt_tx_datahead_ab
);
1164 if (bRTS
== true) {//RTS_need
1165 pvRrvTime
= (void *)(pbyTxBufferAddr
+ wTxBufSize
);
1166 pMICHDR
= (struct vnt_mic_hdr
*) (pbyTxBufferAddr
+ wTxBufSize
+ sizeof(struct vnt_rrv_time_ab
));
1167 pvRTS
= (void *)(pbyTxBufferAddr
+ wTxBufSize
+ sizeof(struct vnt_rrv_time_ab
) + cbMICHDR
);
1169 pvTxDataHd
= (void *)(pbyTxBufferAddr
+ wTxBufSize
+
1170 sizeof(struct vnt_rrv_time_ab
) + cbMICHDR
+ sizeof(struct vnt_rts_a_fb
));
1171 cbHeaderLength
= wTxBufSize
+ sizeof(struct vnt_rrv_time_ab
) +
1172 cbMICHDR
+ sizeof(struct vnt_rts_a_fb
) + sizeof(struct vnt_tx_datahead_a_fb
);
1173 } else { //RTS_needless
1174 pvRrvTime
= (void *)(pbyTxBufferAddr
+ wTxBufSize
);
1175 pMICHDR
= (struct vnt_mic_hdr
*)(pbyTxBufferAddr
+ wTxBufSize
+ sizeof(struct vnt_rrv_time_ab
));
1178 pvTxDataHd
= (void *)(pbyTxBufferAddr
+ wTxBufSize
+ sizeof(struct vnt_rrv_time_ab
) + cbMICHDR
);
1179 cbHeaderLength
= wTxBufSize
+ sizeof(struct vnt_rrv_time_ab
) +
1180 cbMICHDR
+ sizeof(struct vnt_tx_datahead_a_fb
);
1185 td_info
->mic_hdr
= pMICHDR
;
1187 memset((void *)(pbyTxBufferAddr
+ wTxBufSize
), 0, (cbHeaderLength
- wTxBufSize
));
1189 /* Fill FIFO,RrvTime,RTS,and CTS */
1190 s_vGenerateTxParameter(pDevice
, byPktType
, tx_buffer_head
, pvRrvTime
, pvRTS
, pvCTS
,
1191 cbFrameSize
, bNeedACK
, uDMAIdx
, hdr
, pDevice
->wCurrentRate
);
1193 uDuration
= s_uFillDataHead(pDevice
, byPktType
, pvTxDataHd
, cbFrameSize
, uDMAIdx
, bNeedACK
,
1194 0, 0, uMACfragNum
, byFBOption
, pDevice
->wCurrentRate
, is_pspoll
);
1196 hdr
->duration_id
= uDuration
;
1198 cbReqCount
= cbHeaderLength
+ uPadding
+ skb
->len
;
1199 pbyBuffer
= (unsigned char *)pHeadTD
->pTDInfo
->buf
;
1200 uLength
= cbHeaderLength
+ uPadding
;
1202 /* Copy the Packet into a tx Buffer */
1203 memcpy((pbyBuffer
+ uLength
), skb
->data
, skb
->len
);
1205 ptdCurr
= (PSTxDesc
)pHeadTD
;
1207 ptdCurr
->pTDInfo
->dwReqCount
= cbReqCount
;
1208 ptdCurr
->pTDInfo
->dwHeaderLength
= cbHeaderLength
;
1209 ptdCurr
->pTDInfo
->skb_dma
= ptdCurr
->pTDInfo
->buf_dma
;
1211 return cbHeaderLength
;
1214 static void vnt_fill_txkey(struct ieee80211_hdr
*hdr
, u8
*key_buffer
,
1215 struct ieee80211_key_conf
*tx_key
,
1216 struct sk_buff
*skb
, u16 payload_len
,
1217 struct vnt_mic_hdr
*mic_hdr
)
1219 struct ieee80211_key_seq seq
;
1220 u8
*iv
= ((u8
*)hdr
+ ieee80211_get_hdrlen_from_skb(skb
));
1222 /* strip header and icv len from payload */
1223 payload_len
-= ieee80211_get_hdrlen_from_skb(skb
);
1224 payload_len
-= tx_key
->icv_len
;
1226 switch (tx_key
->cipher
) {
1227 case WLAN_CIPHER_SUITE_WEP40
:
1228 case WLAN_CIPHER_SUITE_WEP104
:
1229 memcpy(key_buffer
, iv
, 3);
1230 memcpy(key_buffer
+ 3, tx_key
->key
, tx_key
->keylen
);
1232 if (tx_key
->keylen
== WLAN_KEY_LEN_WEP40
) {
1233 memcpy(key_buffer
+ 8, iv
, 3);
1234 memcpy(key_buffer
+ 11,
1235 tx_key
->key
, WLAN_KEY_LEN_WEP40
);
1239 case WLAN_CIPHER_SUITE_TKIP
:
1240 ieee80211_get_tkip_p2k(tx_key
, skb
, key_buffer
);
1243 case WLAN_CIPHER_SUITE_CCMP
:
1249 mic_hdr
->payload_len
= cpu_to_be16(payload_len
);
1250 ether_addr_copy(mic_hdr
->mic_addr2
, hdr
->addr2
);
1252 ieee80211_get_key_tx_seq(tx_key
, &seq
);
1254 memcpy(mic_hdr
->ccmp_pn
, seq
.ccmp
.pn
, IEEE80211_CCMP_PN_LEN
);
1256 if (ieee80211_has_a4(hdr
->frame_control
))
1257 mic_hdr
->hlen
= cpu_to_be16(28);
1259 mic_hdr
->hlen
= cpu_to_be16(22);
1261 ether_addr_copy(mic_hdr
->addr1
, hdr
->addr1
);
1262 ether_addr_copy(mic_hdr
->addr2
, hdr
->addr2
);
1263 ether_addr_copy(mic_hdr
->addr3
, hdr
->addr3
);
1265 mic_hdr
->frame_control
= cpu_to_le16(
1266 le16_to_cpu(hdr
->frame_control
) & 0xc78f);
1267 mic_hdr
->seq_ctrl
= cpu_to_le16(
1268 le16_to_cpu(hdr
->seq_ctrl
) & 0xf);
1270 if (ieee80211_has_a4(hdr
->frame_control
))
1271 ether_addr_copy(mic_hdr
->addr4
, hdr
->addr4
);
1273 memcpy(key_buffer
, tx_key
->key
, WLAN_KEY_LEN_CCMP
);
1281 int vnt_generate_fifo_header(struct vnt_private
*priv
, u32 dma_idx
,
1282 PSTxDesc head_td
, struct sk_buff
*skb
)
1284 PDEVICE_TD_INFO td_info
= head_td
->pTDInfo
;
1285 struct ieee80211_tx_info
*info
= IEEE80211_SKB_CB(skb
);
1286 struct ieee80211_tx_rate
*tx_rate
= &info
->control
.rates
[0];
1287 struct ieee80211_rate
*rate
;
1288 struct ieee80211_key_conf
*tx_key
;
1289 struct ieee80211_hdr
*hdr
;
1290 struct vnt_tx_fifo_head
*tx_buffer_head
=
1291 (struct vnt_tx_fifo_head
*)td_info
->buf
;
1292 u16 tx_body_size
= skb
->len
, current_rate
;
1294 bool is_pspoll
= false;
1296 memset(tx_buffer_head
, 0, sizeof(*tx_buffer_head
));
1298 hdr
= (struct ieee80211_hdr
*)(skb
->data
);
1300 rate
= ieee80211_get_tx_rate(priv
->hw
, info
);
1302 current_rate
= rate
->hw_value
;
1303 if (priv
->wCurrentRate
!= current_rate
&&
1304 !(priv
->hw
->conf
.flags
& IEEE80211_CONF_OFFCHANNEL
)) {
1305 priv
->wCurrentRate
= current_rate
;
1307 RFbSetPower(priv
, priv
->wCurrentRate
,
1308 priv
->hw
->conf
.chandef
.chan
->hw_value
);
1311 if (current_rate
> RATE_11M
)
1312 pkt_type
= (u8
)priv
->byPacketType
;
1314 pkt_type
= PK_TYPE_11B
;
1316 /*Set fifo controls */
1317 if (pkt_type
== PK_TYPE_11A
)
1318 tx_buffer_head
->fifo_ctl
= 0;
1319 else if (pkt_type
== PK_TYPE_11B
)
1320 tx_buffer_head
->fifo_ctl
= cpu_to_le16(FIFOCTL_11B
);
1321 else if (pkt_type
== PK_TYPE_11GB
)
1322 tx_buffer_head
->fifo_ctl
= cpu_to_le16(FIFOCTL_11GB
);
1323 else if (pkt_type
== PK_TYPE_11GA
)
1324 tx_buffer_head
->fifo_ctl
= cpu_to_le16(FIFOCTL_11GA
);
1326 /* generate interrupt */
1327 tx_buffer_head
->fifo_ctl
|= cpu_to_le16(FIFOCTL_GENINT
);
1329 if (!ieee80211_is_data(hdr
->frame_control
)) {
1330 tx_buffer_head
->fifo_ctl
|= cpu_to_le16(FIFOCTL_TMOEN
);
1331 tx_buffer_head
->fifo_ctl
|= cpu_to_le16(FIFOCTL_ISDMA0
);
1332 tx_buffer_head
->time_stamp
=
1333 cpu_to_le16(DEFAULT_MGN_LIFETIME_RES_64us
);
1335 tx_buffer_head
->time_stamp
=
1336 cpu_to_le16(DEFAULT_MSDU_LIFETIME_RES_64us
);
1339 if (!(info
->flags
& IEEE80211_TX_CTL_NO_ACK
))
1340 tx_buffer_head
->fifo_ctl
|= cpu_to_le16(FIFOCTL_NEEDACK
);
1342 if (ieee80211_has_retry(hdr
->frame_control
))
1343 tx_buffer_head
->fifo_ctl
|= cpu_to_le16(FIFOCTL_LRETRY
);
1345 if (tx_rate
->flags
& IEEE80211_TX_RC_USE_SHORT_PREAMBLE
)
1346 priv
->byPreambleType
= PREAMBLE_SHORT
;
1348 priv
->byPreambleType
= PREAMBLE_LONG
;
1350 if (tx_rate
->flags
& IEEE80211_TX_RC_USE_RTS_CTS
)
1351 tx_buffer_head
->fifo_ctl
|= cpu_to_le16(FIFOCTL_RTS
);
1353 if (ieee80211_has_a4(hdr
->frame_control
)) {
1354 tx_buffer_head
->fifo_ctl
|= cpu_to_le16(FIFOCTL_LHEAD
);
1355 priv
->bLongHeader
= true;
1358 if (info
->flags
& IEEE80211_TX_CTL_NO_PS_BUFFER
)
1361 tx_buffer_head
->frag_ctl
=
1362 cpu_to_le16(ieee80211_get_hdrlen_from_skb(skb
) << 10);
1364 if (info
->control
.hw_key
) {
1365 tx_key
= info
->control
.hw_key
;
1367 switch (info
->control
.hw_key
->cipher
) {
1368 case WLAN_CIPHER_SUITE_WEP40
:
1369 case WLAN_CIPHER_SUITE_WEP104
:
1370 tx_buffer_head
->frag_ctl
|= cpu_to_le16(FRAGCTL_LEGACY
);
1372 case WLAN_CIPHER_SUITE_TKIP
:
1373 tx_buffer_head
->frag_ctl
|= cpu_to_le16(FRAGCTL_TKIP
);
1375 case WLAN_CIPHER_SUITE_CCMP
:
1376 tx_buffer_head
->frag_ctl
|= cpu_to_le16(FRAGCTL_AES
);
1382 tx_buffer_head
->current_rate
= cpu_to_le16(current_rate
);
1384 /* legacy rates TODO use ieee80211_tx_rate */
1385 if (current_rate
>= RATE_18M
&& ieee80211_is_data(hdr
->frame_control
)) {
1386 if (priv
->byAutoFBCtrl
== AUTO_FB_0
)
1387 tx_buffer_head
->fifo_ctl
|=
1388 cpu_to_le16(FIFOCTL_AUTO_FB_0
);
1389 else if (priv
->byAutoFBCtrl
== AUTO_FB_1
)
1390 tx_buffer_head
->fifo_ctl
|=
1391 cpu_to_le16(FIFOCTL_AUTO_FB_1
);
1395 tx_buffer_head
->frag_ctl
|= cpu_to_le16(FRAGCTL_NONFRAG
);
1397 s_cbFillTxBufHead(priv
, pkt_type
, (u8
*)tx_buffer_head
,
1398 dma_idx
, head_td
, is_pspoll
);
1400 if (info
->control
.hw_key
) {
1401 tx_key
= info
->control
.hw_key
;
1402 if (tx_key
->keylen
> 0)
1403 vnt_fill_txkey(hdr
, tx_buffer_head
->tx_key
,
1404 tx_key
, skb
, tx_body_size
, td_info
->mic_hdr
);
1410 static int vnt_beacon_xmit(struct vnt_private
*priv
,
1411 struct sk_buff
*skb
)
1413 struct vnt_tx_short_buf_head
*short_head
=
1414 (struct vnt_tx_short_buf_head
*)priv
->tx_beacon_bufs
;
1415 struct ieee80211_mgmt
*mgmt_hdr
= (struct ieee80211_mgmt
*)
1416 (priv
->tx_beacon_bufs
+ sizeof(*short_head
));
1417 struct ieee80211_tx_info
*info
;
1418 u32 frame_size
= skb
->len
+ 4;
1421 memset(priv
->tx_beacon_bufs
, 0, sizeof(*short_head
));
1423 if (priv
->byBBType
== BB_TYPE_11A
) {
1424 current_rate
= RATE_6M
;
1426 /* Get SignalField,ServiceField,Length */
1427 vnt_get_phy_field(priv
, frame_size
, current_rate
,
1428 PK_TYPE_11A
, &short_head
->ab
);
1430 /* Get Duration and TimeStampOff */
1431 short_head
->duration
=
1432 cpu_to_le16((u16
)s_uGetDataDuration(priv
, DATADUR_B
,
1433 frame_size
, PK_TYPE_11A
, current_rate
,
1434 false, 0, 0, 1, AUTO_FB_NONE
));
1436 short_head
->time_stamp_off
=
1437 vnt_time_stamp_off(priv
, current_rate
);
1439 current_rate
= RATE_1M
;
1440 short_head
->fifo_ctl
|= cpu_to_le16(FIFOCTL_11B
);
1442 /* Get SignalField,ServiceField,Length */
1443 vnt_get_phy_field(priv
, frame_size
, current_rate
,
1444 PK_TYPE_11B
, &short_head
->ab
);
1446 /* Get Duration and TimeStampOff */
1447 short_head
->duration
=
1448 cpu_to_le16((u16
)s_uGetDataDuration(priv
, DATADUR_B
,
1449 frame_size
, PK_TYPE_11B
, current_rate
,
1450 false, 0, 0, 1, AUTO_FB_NONE
));
1452 short_head
->time_stamp_off
=
1453 vnt_time_stamp_off(priv
, current_rate
);
1456 short_head
->fifo_ctl
|= cpu_to_le16(FIFOCTL_GENINT
);
1459 memcpy(mgmt_hdr
, skb
->data
, skb
->len
);
1461 /* time stamp always 0 */
1462 mgmt_hdr
->u
.beacon
.timestamp
= 0;
1464 info
= IEEE80211_SKB_CB(skb
);
1465 if (info
->flags
& IEEE80211_TX_CTL_ASSIGN_SEQ
) {
1466 struct ieee80211_hdr
*hdr
= (struct ieee80211_hdr
*)mgmt_hdr
;
1468 hdr
->duration_id
= 0;
1469 hdr
->seq_ctrl
= cpu_to_le16(priv
->wSeqCounter
<< 4);
1472 priv
->wSeqCounter
++;
1473 if (priv
->wSeqCounter
> 0x0fff)
1474 priv
->wSeqCounter
= 0;
1476 priv
->wBCNBufLen
= sizeof(*short_head
) + skb
->len
;
1478 MACvSetCurrBCNTxDescAddr(priv
->PortOffset
, priv
->tx_beacon_dma
);
1480 MACvSetCurrBCNLength(priv
->PortOffset
, priv
->wBCNBufLen
);
1481 /* Set auto Transmit on */
1482 MACvRegBitsOn(priv
->PortOffset
, MAC_REG_TCR
, TCR_AUTOBCNTX
);
1483 /* Poll Transmit the adapter */
1484 MACvTransmitBCN(priv
->PortOffset
);
1489 int vnt_beacon_make(struct vnt_private
*priv
, struct ieee80211_vif
*vif
)
1491 struct sk_buff
*beacon
;
1493 beacon
= ieee80211_beacon_get(priv
->hw
, vif
);
1497 if (vnt_beacon_xmit(priv
, beacon
)) {
1498 ieee80211_free_txskb(priv
->hw
, beacon
);
1505 int vnt_beacon_enable(struct vnt_private
*priv
, struct ieee80211_vif
*vif
,
1506 struct ieee80211_bss_conf
*conf
)
1510 VNSvOutPortB(priv
->PortOffset
+ MAC_REG_TFTCTL
, TFTCTL_TSFCNTRST
);
1512 VNSvOutPortB(priv
->PortOffset
+ MAC_REG_TFTCTL
, TFTCTL_TSFCNTREN
);
1514 CARDvSetFirstNextTBTT(priv
, conf
->beacon_int
);
1516 CARDbSetBeaconPeriod(priv
, conf
->beacon_int
);
1518 ret
= vnt_beacon_make(priv
, vif
);