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
,
119 struct vnt_tx_fifo_head
*,
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
251 bool bLastFrag
= false;
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
,
947 struct vnt_tx_fifo_head
*tx_buffer_head
,
951 unsigned int cbFrameSize
,
953 unsigned int uDMAIdx
,
955 unsigned short wCurrentRate
958 u16 fifo_ctl
= le16_to_cpu(tx_buffer_head
->fifo_ctl
);
959 bool bDisCRC
= false;
960 unsigned char byFBOption
= AUTO_FB_NONE
;
962 tx_buffer_head
->current_rate
= cpu_to_le16(wCurrentRate
);
964 if (fifo_ctl
& FIFOCTL_CRCDIS
)
967 if (fifo_ctl
& FIFOCTL_AUTO_FB_0
)
968 byFBOption
= AUTO_FB_0
;
969 else if (fifo_ctl
& FIFOCTL_AUTO_FB_1
)
970 byFBOption
= AUTO_FB_1
;
975 if (byPktType
== PK_TYPE_11GB
|| byPktType
== PK_TYPE_11GA
) {
976 if (pvRTS
!= NULL
) { /* RTS_need
978 struct vnt_rrv_time_rts
*buf
= pvRrvTime
;
980 buf
->rts_rrv_time_aa
= s_uGetRTSCTSRsvTime(pDevice
, 2, byPktType
, cbFrameSize
, wCurrentRate
);
981 buf
->rts_rrv_time_ba
= s_uGetRTSCTSRsvTime(pDevice
, 1, byPktType
, cbFrameSize
, wCurrentRate
);
982 buf
->rts_rrv_time_bb
= s_uGetRTSCTSRsvTime(pDevice
, 0, byPktType
, cbFrameSize
, wCurrentRate
);
983 buf
->rrv_time_a
= vnt_rxtx_rsvtime_le16(pDevice
, byPktType
, cbFrameSize
, wCurrentRate
, bNeedACK
);
984 buf
->rrv_time_b
= vnt_rxtx_rsvtime_le16(pDevice
, PK_TYPE_11B
, cbFrameSize
, pDevice
->byTopCCKBasicRate
, bNeedACK
);
986 s_vFillRTSHead(pDevice
, byPktType
, pvRTS
, cbFrameSize
, bNeedACK
, bDisCRC
, psEthHeader
, wCurrentRate
, byFBOption
);
987 } else {/* RTS_needless, PCF mode */
988 struct vnt_rrv_time_cts
*buf
= pvRrvTime
;
990 buf
->rrv_time_a
= vnt_rxtx_rsvtime_le16(pDevice
, byPktType
, cbFrameSize
, wCurrentRate
, bNeedACK
);
991 buf
->rrv_time_b
= vnt_rxtx_rsvtime_le16(pDevice
, PK_TYPE_11B
, cbFrameSize
, pDevice
->byTopCCKBasicRate
, bNeedACK
);
992 buf
->cts_rrv_time_ba
= s_uGetRTSCTSRsvTime(pDevice
, 3, byPktType
, cbFrameSize
, wCurrentRate
);
995 s_vFillCTSHead(pDevice
, uDMAIdx
, byPktType
, pvCTS
, cbFrameSize
, bNeedACK
, bDisCRC
, wCurrentRate
, byFBOption
);
997 } else if (byPktType
== PK_TYPE_11A
) {
998 if (pvRTS
!= NULL
) {/* RTS_need, non PCF mode */
999 struct vnt_rrv_time_ab
*buf
= pvRrvTime
;
1001 buf
->rts_rrv_time
= s_uGetRTSCTSRsvTime(pDevice
, 2, byPktType
, cbFrameSize
, wCurrentRate
);
1002 buf
->rrv_time
= vnt_rxtx_rsvtime_le16(pDevice
, byPktType
, cbFrameSize
, wCurrentRate
, bNeedACK
);
1005 s_vFillRTSHead(pDevice
, byPktType
, pvRTS
, cbFrameSize
, bNeedACK
, bDisCRC
, psEthHeader
, wCurrentRate
, byFBOption
);
1006 } else if (pvRTS
== NULL
) {/* RTS_needless, non PCF mode */
1007 struct vnt_rrv_time_ab
*buf
= pvRrvTime
;
1009 buf
->rrv_time
= vnt_rxtx_rsvtime_le16(pDevice
, PK_TYPE_11A
, cbFrameSize
, wCurrentRate
, bNeedACK
);
1011 } else if (byPktType
== PK_TYPE_11B
) {
1012 if ((pvRTS
!= NULL
)) {/* RTS_need, non PCF mode */
1013 struct vnt_rrv_time_ab
*buf
= pvRrvTime
;
1015 buf
->rts_rrv_time
= s_uGetRTSCTSRsvTime(pDevice
, 0, byPktType
, cbFrameSize
, wCurrentRate
);
1016 buf
->rrv_time
= vnt_rxtx_rsvtime_le16(pDevice
, PK_TYPE_11B
, cbFrameSize
, wCurrentRate
, bNeedACK
);
1019 s_vFillRTSHead(pDevice
, byPktType
, pvRTS
, cbFrameSize
, bNeedACK
, bDisCRC
, psEthHeader
, wCurrentRate
, byFBOption
);
1020 } else { /* RTS_needless, non PCF mode */
1021 struct vnt_rrv_time_ab
*buf
= pvRrvTime
;
1023 buf
->rrv_time
= vnt_rxtx_rsvtime_le16(pDevice
, PK_TYPE_11B
, cbFrameSize
, wCurrentRate
, bNeedACK
);
1029 s_cbFillTxBufHead(struct vnt_private
*pDevice
, unsigned char byPktType
,
1030 unsigned char *pbyTxBufferAddr
,
1031 unsigned int uDMAIdx
, PSTxDesc pHeadTD
,
1032 unsigned int is_pspoll
)
1034 PDEVICE_TD_INFO td_info
= pHeadTD
->pTDInfo
;
1035 struct sk_buff
*skb
= td_info
->skb
;
1036 struct ieee80211_tx_info
*info
= IEEE80211_SKB_CB(skb
);
1037 struct ieee80211_hdr
*hdr
= (struct ieee80211_hdr
*)skb
->data
;
1038 struct vnt_tx_fifo_head
*tx_buffer_head
=
1039 (struct vnt_tx_fifo_head
*)td_info
->buf
;
1040 u16 fifo_ctl
= le16_to_cpu(tx_buffer_head
->fifo_ctl
);
1041 unsigned int cbFrameSize
;
1043 unsigned char *pbyBuffer
;
1044 unsigned int uLength
= 0;
1045 unsigned int cbMICHDR
= 0;
1046 unsigned int uMACfragNum
= 1;
1047 unsigned int uPadding
= 0;
1048 unsigned int cbReqCount
= 0;
1049 bool bNeedACK
= (bool)(fifo_ctl
& FIFOCTL_NEEDACK
);
1050 bool bRTS
= (bool)(fifo_ctl
& FIFOCTL_RTS
);
1052 unsigned int cbHeaderLength
= 0;
1054 struct vnt_mic_hdr
*pMICHDR
;
1058 unsigned short wTxBufSize
; /* FFinfo size */
1059 unsigned char byFBOption
= AUTO_FB_NONE
;
1061 pvRrvTime
= pMICHDR
= pvRTS
= pvCTS
= pvTxDataHd
= NULL
;
1063 cbFrameSize
= skb
->len
+ 4;
1065 if (info
->control
.hw_key
) {
1066 switch (info
->control
.hw_key
->cipher
) {
1067 case WLAN_CIPHER_SUITE_CCMP
:
1068 cbMICHDR
= sizeof(struct vnt_mic_hdr
);
1073 cbFrameSize
+= info
->control
.hw_key
->icv_len
;
1075 if (pDevice
->byLocalID
> REV_ID_VT3253_A1
) {
1076 /* MAC Header should be padding 0 to DW alignment. */
1077 uPadding
= 4 - (ieee80211_get_hdrlen_from_skb(skb
) % 4);
1083 * Use for AUTO FALL BACK
1085 if (fifo_ctl
& FIFOCTL_AUTO_FB_0
)
1086 byFBOption
= AUTO_FB_0
;
1087 else if (fifo_ctl
& FIFOCTL_AUTO_FB_1
)
1088 byFBOption
= AUTO_FB_1
;
1091 /* Set RrvTime/RTS/CTS Buffer */
1092 wTxBufSize
= sizeof(STxBufHead
);
1093 if (byPktType
== PK_TYPE_11GB
|| byPktType
== PK_TYPE_11GA
) {/* 802.11g packet */
1095 if (byFBOption
== AUTO_FB_NONE
) {
1096 if (bRTS
== true) {/* RTS_need */
1097 pvRrvTime
= (void *)(pbyTxBufferAddr
+ wTxBufSize
);
1098 pMICHDR
= (struct vnt_mic_hdr
*)(pbyTxBufferAddr
+ wTxBufSize
+ sizeof(struct vnt_rrv_time_rts
));
1099 pvRTS
= (void *)(pbyTxBufferAddr
+ wTxBufSize
+ sizeof(struct vnt_rrv_time_rts
) + cbMICHDR
);
1101 pvTxDataHd
= (void *)(pbyTxBufferAddr
+ wTxBufSize
+ sizeof(struct vnt_rrv_time_rts
) +
1102 cbMICHDR
+ sizeof(struct vnt_rts_g
));
1103 cbHeaderLength
= wTxBufSize
+ sizeof(struct vnt_rrv_time_rts
) +
1104 cbMICHDR
+ sizeof(struct vnt_rts_g
) +
1105 sizeof(struct vnt_tx_datahead_g
);
1106 } else { /* RTS_needless */
1107 pvRrvTime
= (void *)(pbyTxBufferAddr
+ wTxBufSize
);
1108 pMICHDR
= (struct vnt_mic_hdr
*) (pbyTxBufferAddr
+ wTxBufSize
+ sizeof(struct vnt_rrv_time_cts
));
1110 pvCTS
= (void *) (pbyTxBufferAddr
+ wTxBufSize
+ sizeof(struct vnt_rrv_time_cts
) + cbMICHDR
);
1111 pvTxDataHd
= (void *)(pbyTxBufferAddr
+ wTxBufSize
+
1112 sizeof(struct vnt_rrv_time_cts
) + cbMICHDR
+ sizeof(struct vnt_cts
));
1113 cbHeaderLength
= wTxBufSize
+ sizeof(struct vnt_rrv_time_cts
) +
1114 cbMICHDR
+ sizeof(struct vnt_cts
) + sizeof(struct vnt_tx_datahead_g
);
1117 /* Auto Fall Back */
1118 if (bRTS
== true) {/* RTS_need */
1119 pvRrvTime
= (void *)(pbyTxBufferAddr
+ wTxBufSize
);
1120 pMICHDR
= (struct vnt_mic_hdr
*) (pbyTxBufferAddr
+ wTxBufSize
+ sizeof(struct vnt_rrv_time_rts
));
1121 pvRTS
= (void *) (pbyTxBufferAddr
+ wTxBufSize
+ sizeof(struct vnt_rrv_time_rts
) + cbMICHDR
);
1123 pvTxDataHd
= (void *)(pbyTxBufferAddr
+ wTxBufSize
+ sizeof(struct vnt_rrv_time_rts
) +
1124 cbMICHDR
+ sizeof(struct vnt_rts_g_fb
));
1125 cbHeaderLength
= wTxBufSize
+ sizeof(struct vnt_rrv_time_rts
) +
1126 cbMICHDR
+ sizeof(struct vnt_rts_g_fb
) + sizeof(struct vnt_tx_datahead_g_fb
);
1127 } else { /* RTS_needless */
1128 pvRrvTime
= (void *)(pbyTxBufferAddr
+ wTxBufSize
);
1129 pMICHDR
= (struct vnt_mic_hdr
*) (pbyTxBufferAddr
+ wTxBufSize
+ sizeof(struct vnt_rrv_time_cts
));
1131 pvCTS
= (void *)(pbyTxBufferAddr
+ wTxBufSize
+ sizeof(struct vnt_rrv_time_cts
) + cbMICHDR
);
1132 pvTxDataHd
= (void *)(pbyTxBufferAddr
+ wTxBufSize
+ sizeof(struct vnt_rrv_time_cts
) +
1133 cbMICHDR
+ sizeof(struct vnt_cts_fb
));
1134 cbHeaderLength
= wTxBufSize
+ sizeof(struct vnt_rrv_time_cts
) +
1135 cbMICHDR
+ sizeof(struct vnt_cts_fb
) + sizeof(struct vnt_tx_datahead_g_fb
);
1137 } /* Auto Fall Back */
1138 } else {/* 802.11a/b packet */
1140 if (byFBOption
== AUTO_FB_NONE
) {
1142 pvRrvTime
= (void *)(pbyTxBufferAddr
+ wTxBufSize
);
1143 pMICHDR
= (struct vnt_mic_hdr
*) (pbyTxBufferAddr
+ wTxBufSize
+ sizeof(struct vnt_rrv_time_ab
));
1144 pvRTS
= (void *)(pbyTxBufferAddr
+ wTxBufSize
+ sizeof(struct vnt_rrv_time_ab
) + cbMICHDR
);
1146 pvTxDataHd
= (void *)(pbyTxBufferAddr
+ wTxBufSize
+
1147 sizeof(struct vnt_rrv_time_ab
) + cbMICHDR
+ sizeof(struct vnt_rts_ab
));
1148 cbHeaderLength
= wTxBufSize
+ sizeof(struct vnt_rrv_time_ab
) +
1149 cbMICHDR
+ sizeof(struct vnt_rts_ab
) + sizeof(struct vnt_tx_datahead_ab
);
1150 } else { /* RTS_needless, need MICHDR */
1151 pvRrvTime
= (void *)(pbyTxBufferAddr
+ wTxBufSize
);
1152 pMICHDR
= (struct vnt_mic_hdr
*) (pbyTxBufferAddr
+ wTxBufSize
+ sizeof(struct vnt_rrv_time_ab
));
1155 pvTxDataHd
= (void *)(pbyTxBufferAddr
+ wTxBufSize
+ sizeof(struct vnt_rrv_time_ab
) + cbMICHDR
);
1156 cbHeaderLength
= wTxBufSize
+ sizeof(struct vnt_rrv_time_ab
) +
1157 cbMICHDR
+ sizeof(struct vnt_tx_datahead_ab
);
1160 /* Auto Fall Back */
1161 if (bRTS
== true) { /* RTS_need */
1162 pvRrvTime
= (void *)(pbyTxBufferAddr
+ wTxBufSize
);
1163 pMICHDR
= (struct vnt_mic_hdr
*) (pbyTxBufferAddr
+ wTxBufSize
+ sizeof(struct vnt_rrv_time_ab
));
1164 pvRTS
= (void *)(pbyTxBufferAddr
+ wTxBufSize
+ sizeof(struct vnt_rrv_time_ab
) + cbMICHDR
);
1166 pvTxDataHd
= (void *)(pbyTxBufferAddr
+ wTxBufSize
+
1167 sizeof(struct vnt_rrv_time_ab
) + cbMICHDR
+ sizeof(struct vnt_rts_a_fb
));
1168 cbHeaderLength
= wTxBufSize
+ sizeof(struct vnt_rrv_time_ab
) +
1169 cbMICHDR
+ sizeof(struct vnt_rts_a_fb
) + sizeof(struct vnt_tx_datahead_a_fb
);
1170 } else { /* RTS_needless */
1171 pvRrvTime
= (void *)(pbyTxBufferAddr
+ wTxBufSize
);
1172 pMICHDR
= (struct vnt_mic_hdr
*)(pbyTxBufferAddr
+ wTxBufSize
+ sizeof(struct vnt_rrv_time_ab
));
1175 pvTxDataHd
= (void *)(pbyTxBufferAddr
+ wTxBufSize
+ sizeof(struct vnt_rrv_time_ab
) + cbMICHDR
);
1176 cbHeaderLength
= wTxBufSize
+ sizeof(struct vnt_rrv_time_ab
) +
1177 cbMICHDR
+ sizeof(struct vnt_tx_datahead_a_fb
);
1179 } /* Auto Fall Back */
1182 td_info
->mic_hdr
= pMICHDR
;
1184 memset((void *)(pbyTxBufferAddr
+ wTxBufSize
), 0, (cbHeaderLength
- wTxBufSize
));
1186 /* Fill FIFO,RrvTime,RTS,and CTS */
1187 s_vGenerateTxParameter(pDevice
, byPktType
, tx_buffer_head
, pvRrvTime
, pvRTS
, pvCTS
,
1188 cbFrameSize
, bNeedACK
, uDMAIdx
, hdr
, pDevice
->wCurrentRate
);
1190 uDuration
= s_uFillDataHead(pDevice
, byPktType
, pvTxDataHd
, cbFrameSize
, uDMAIdx
, bNeedACK
,
1191 0, 0, uMACfragNum
, byFBOption
, pDevice
->wCurrentRate
, is_pspoll
);
1193 hdr
->duration_id
= uDuration
;
1195 cbReqCount
= cbHeaderLength
+ uPadding
+ skb
->len
;
1196 pbyBuffer
= (unsigned char *)pHeadTD
->pTDInfo
->buf
;
1197 uLength
= cbHeaderLength
+ uPadding
;
1199 /* Copy the Packet into a tx Buffer */
1200 memcpy((pbyBuffer
+ uLength
), skb
->data
, skb
->len
);
1202 ptdCurr
= (PSTxDesc
)pHeadTD
;
1204 ptdCurr
->pTDInfo
->dwReqCount
= cbReqCount
;
1205 ptdCurr
->pTDInfo
->dwHeaderLength
= cbHeaderLength
;
1206 ptdCurr
->pTDInfo
->skb_dma
= ptdCurr
->pTDInfo
->buf_dma
;
1208 return cbHeaderLength
;
1211 static void vnt_fill_txkey(struct ieee80211_hdr
*hdr
, u8
*key_buffer
,
1212 struct ieee80211_key_conf
*tx_key
,
1213 struct sk_buff
*skb
, u16 payload_len
,
1214 struct vnt_mic_hdr
*mic_hdr
)
1216 struct ieee80211_key_seq seq
;
1217 u8
*iv
= ((u8
*)hdr
+ ieee80211_get_hdrlen_from_skb(skb
));
1219 /* strip header and icv len from payload */
1220 payload_len
-= ieee80211_get_hdrlen_from_skb(skb
);
1221 payload_len
-= tx_key
->icv_len
;
1223 switch (tx_key
->cipher
) {
1224 case WLAN_CIPHER_SUITE_WEP40
:
1225 case WLAN_CIPHER_SUITE_WEP104
:
1226 memcpy(key_buffer
, iv
, 3);
1227 memcpy(key_buffer
+ 3, tx_key
->key
, tx_key
->keylen
);
1229 if (tx_key
->keylen
== WLAN_KEY_LEN_WEP40
) {
1230 memcpy(key_buffer
+ 8, iv
, 3);
1231 memcpy(key_buffer
+ 11,
1232 tx_key
->key
, WLAN_KEY_LEN_WEP40
);
1236 case WLAN_CIPHER_SUITE_TKIP
:
1237 ieee80211_get_tkip_p2k(tx_key
, skb
, key_buffer
);
1240 case WLAN_CIPHER_SUITE_CCMP
:
1246 mic_hdr
->payload_len
= cpu_to_be16(payload_len
);
1247 ether_addr_copy(mic_hdr
->mic_addr2
, hdr
->addr2
);
1249 ieee80211_get_key_tx_seq(tx_key
, &seq
);
1251 memcpy(mic_hdr
->ccmp_pn
, seq
.ccmp
.pn
, IEEE80211_CCMP_PN_LEN
);
1253 if (ieee80211_has_a4(hdr
->frame_control
))
1254 mic_hdr
->hlen
= cpu_to_be16(28);
1256 mic_hdr
->hlen
= cpu_to_be16(22);
1258 ether_addr_copy(mic_hdr
->addr1
, hdr
->addr1
);
1259 ether_addr_copy(mic_hdr
->addr2
, hdr
->addr2
);
1260 ether_addr_copy(mic_hdr
->addr3
, hdr
->addr3
);
1262 mic_hdr
->frame_control
= cpu_to_le16(
1263 le16_to_cpu(hdr
->frame_control
) & 0xc78f);
1264 mic_hdr
->seq_ctrl
= cpu_to_le16(
1265 le16_to_cpu(hdr
->seq_ctrl
) & 0xf);
1267 if (ieee80211_has_a4(hdr
->frame_control
))
1268 ether_addr_copy(mic_hdr
->addr4
, hdr
->addr4
);
1270 memcpy(key_buffer
, tx_key
->key
, WLAN_KEY_LEN_CCMP
);
1278 int vnt_generate_fifo_header(struct vnt_private
*priv
, u32 dma_idx
,
1279 PSTxDesc head_td
, struct sk_buff
*skb
)
1281 PDEVICE_TD_INFO td_info
= head_td
->pTDInfo
;
1282 struct ieee80211_tx_info
*info
= IEEE80211_SKB_CB(skb
);
1283 struct ieee80211_tx_rate
*tx_rate
= &info
->control
.rates
[0];
1284 struct ieee80211_rate
*rate
;
1285 struct ieee80211_key_conf
*tx_key
;
1286 struct ieee80211_hdr
*hdr
;
1287 struct vnt_tx_fifo_head
*tx_buffer_head
=
1288 (struct vnt_tx_fifo_head
*)td_info
->buf
;
1289 u16 tx_body_size
= skb
->len
, current_rate
;
1291 bool is_pspoll
= false;
1293 memset(tx_buffer_head
, 0, sizeof(*tx_buffer_head
));
1295 hdr
= (struct ieee80211_hdr
*)(skb
->data
);
1297 rate
= ieee80211_get_tx_rate(priv
->hw
, info
);
1299 current_rate
= rate
->hw_value
;
1300 if (priv
->wCurrentRate
!= current_rate
&&
1301 !(priv
->hw
->conf
.flags
& IEEE80211_CONF_OFFCHANNEL
)) {
1302 priv
->wCurrentRate
= current_rate
;
1304 RFbSetPower(priv
, priv
->wCurrentRate
,
1305 priv
->hw
->conf
.chandef
.chan
->hw_value
);
1308 if (current_rate
> RATE_11M
) {
1309 if (info
->band
== IEEE80211_BAND_5GHZ
) {
1310 pkt_type
= PK_TYPE_11A
;
1312 if (tx_rate
->flags
& IEEE80211_TX_RC_USE_CTS_PROTECT
)
1313 pkt_type
= PK_TYPE_11GB
;
1315 pkt_type
= PK_TYPE_11GA
;
1318 pkt_type
= PK_TYPE_11B
;
1321 /*Set fifo controls */
1322 if (pkt_type
== PK_TYPE_11A
)
1323 tx_buffer_head
->fifo_ctl
= 0;
1324 else if (pkt_type
== PK_TYPE_11B
)
1325 tx_buffer_head
->fifo_ctl
= cpu_to_le16(FIFOCTL_11B
);
1326 else if (pkt_type
== PK_TYPE_11GB
)
1327 tx_buffer_head
->fifo_ctl
= cpu_to_le16(FIFOCTL_11GB
);
1328 else if (pkt_type
== PK_TYPE_11GA
)
1329 tx_buffer_head
->fifo_ctl
= cpu_to_le16(FIFOCTL_11GA
);
1331 /* generate interrupt */
1332 tx_buffer_head
->fifo_ctl
|= cpu_to_le16(FIFOCTL_GENINT
);
1334 if (!ieee80211_is_data(hdr
->frame_control
)) {
1335 tx_buffer_head
->fifo_ctl
|= cpu_to_le16(FIFOCTL_TMOEN
);
1336 tx_buffer_head
->fifo_ctl
|= cpu_to_le16(FIFOCTL_ISDMA0
);
1337 tx_buffer_head
->time_stamp
=
1338 cpu_to_le16(DEFAULT_MGN_LIFETIME_RES_64us
);
1340 tx_buffer_head
->time_stamp
=
1341 cpu_to_le16(DEFAULT_MSDU_LIFETIME_RES_64us
);
1344 if (!(info
->flags
& IEEE80211_TX_CTL_NO_ACK
))
1345 tx_buffer_head
->fifo_ctl
|= cpu_to_le16(FIFOCTL_NEEDACK
);
1347 if (ieee80211_has_retry(hdr
->frame_control
))
1348 tx_buffer_head
->fifo_ctl
|= cpu_to_le16(FIFOCTL_LRETRY
);
1350 if (tx_rate
->flags
& IEEE80211_TX_RC_USE_SHORT_PREAMBLE
)
1351 priv
->byPreambleType
= PREAMBLE_SHORT
;
1353 priv
->byPreambleType
= PREAMBLE_LONG
;
1355 if (tx_rate
->flags
& IEEE80211_TX_RC_USE_RTS_CTS
)
1356 tx_buffer_head
->fifo_ctl
|= cpu_to_le16(FIFOCTL_RTS
);
1358 if (ieee80211_has_a4(hdr
->frame_control
)) {
1359 tx_buffer_head
->fifo_ctl
|= cpu_to_le16(FIFOCTL_LHEAD
);
1360 priv
->bLongHeader
= true;
1363 if (info
->flags
& IEEE80211_TX_CTL_NO_PS_BUFFER
)
1366 tx_buffer_head
->frag_ctl
=
1367 cpu_to_le16(ieee80211_get_hdrlen_from_skb(skb
) << 10);
1369 if (info
->control
.hw_key
) {
1370 tx_key
= info
->control
.hw_key
;
1372 switch (info
->control
.hw_key
->cipher
) {
1373 case WLAN_CIPHER_SUITE_WEP40
:
1374 case WLAN_CIPHER_SUITE_WEP104
:
1375 tx_buffer_head
->frag_ctl
|= cpu_to_le16(FRAGCTL_LEGACY
);
1377 case WLAN_CIPHER_SUITE_TKIP
:
1378 tx_buffer_head
->frag_ctl
|= cpu_to_le16(FRAGCTL_TKIP
);
1380 case WLAN_CIPHER_SUITE_CCMP
:
1381 tx_buffer_head
->frag_ctl
|= cpu_to_le16(FRAGCTL_AES
);
1387 tx_buffer_head
->current_rate
= cpu_to_le16(current_rate
);
1389 /* legacy rates TODO use ieee80211_tx_rate */
1390 if (current_rate
>= RATE_18M
&& ieee80211_is_data(hdr
->frame_control
)) {
1391 if (priv
->byAutoFBCtrl
== AUTO_FB_0
)
1392 tx_buffer_head
->fifo_ctl
|=
1393 cpu_to_le16(FIFOCTL_AUTO_FB_0
);
1394 else if (priv
->byAutoFBCtrl
== AUTO_FB_1
)
1395 tx_buffer_head
->fifo_ctl
|=
1396 cpu_to_le16(FIFOCTL_AUTO_FB_1
);
1400 tx_buffer_head
->frag_ctl
|= cpu_to_le16(FRAGCTL_NONFRAG
);
1402 s_cbFillTxBufHead(priv
, pkt_type
, (u8
*)tx_buffer_head
,
1403 dma_idx
, head_td
, is_pspoll
);
1405 if (info
->control
.hw_key
) {
1406 tx_key
= info
->control
.hw_key
;
1407 if (tx_key
->keylen
> 0)
1408 vnt_fill_txkey(hdr
, tx_buffer_head
->tx_key
,
1409 tx_key
, skb
, tx_body_size
, td_info
->mic_hdr
);
1415 static int vnt_beacon_xmit(struct vnt_private
*priv
,
1416 struct sk_buff
*skb
)
1418 struct vnt_tx_short_buf_head
*short_head
=
1419 (struct vnt_tx_short_buf_head
*)priv
->tx_beacon_bufs
;
1420 struct ieee80211_mgmt
*mgmt_hdr
= (struct ieee80211_mgmt
*)
1421 (priv
->tx_beacon_bufs
+ sizeof(*short_head
));
1422 struct ieee80211_tx_info
*info
;
1423 u32 frame_size
= skb
->len
+ 4;
1426 memset(priv
->tx_beacon_bufs
, 0, sizeof(*short_head
));
1428 if (priv
->byBBType
== BB_TYPE_11A
) {
1429 current_rate
= RATE_6M
;
1431 /* Get SignalField,ServiceField,Length */
1432 vnt_get_phy_field(priv
, frame_size
, current_rate
,
1433 PK_TYPE_11A
, &short_head
->ab
);
1435 /* Get Duration and TimeStampOff */
1436 short_head
->duration
=
1437 cpu_to_le16((u16
)s_uGetDataDuration(priv
, DATADUR_B
,
1438 frame_size
, PK_TYPE_11A
, current_rate
,
1439 false, 0, 0, 1, AUTO_FB_NONE
));
1441 short_head
->time_stamp_off
=
1442 vnt_time_stamp_off(priv
, current_rate
);
1444 current_rate
= RATE_1M
;
1445 short_head
->fifo_ctl
|= cpu_to_le16(FIFOCTL_11B
);
1447 /* Get SignalField,ServiceField,Length */
1448 vnt_get_phy_field(priv
, frame_size
, current_rate
,
1449 PK_TYPE_11B
, &short_head
->ab
);
1451 /* Get Duration and TimeStampOff */
1452 short_head
->duration
=
1453 cpu_to_le16((u16
)s_uGetDataDuration(priv
, DATADUR_B
,
1454 frame_size
, PK_TYPE_11B
, current_rate
,
1455 false, 0, 0, 1, AUTO_FB_NONE
));
1457 short_head
->time_stamp_off
=
1458 vnt_time_stamp_off(priv
, current_rate
);
1461 short_head
->fifo_ctl
|= cpu_to_le16(FIFOCTL_GENINT
);
1464 memcpy(mgmt_hdr
, skb
->data
, skb
->len
);
1466 /* time stamp always 0 */
1467 mgmt_hdr
->u
.beacon
.timestamp
= 0;
1469 info
= IEEE80211_SKB_CB(skb
);
1470 if (info
->flags
& IEEE80211_TX_CTL_ASSIGN_SEQ
) {
1471 struct ieee80211_hdr
*hdr
= (struct ieee80211_hdr
*)mgmt_hdr
;
1473 hdr
->duration_id
= 0;
1474 hdr
->seq_ctrl
= cpu_to_le16(priv
->wSeqCounter
<< 4);
1477 priv
->wSeqCounter
++;
1478 if (priv
->wSeqCounter
> 0x0fff)
1479 priv
->wSeqCounter
= 0;
1481 priv
->wBCNBufLen
= sizeof(*short_head
) + skb
->len
;
1483 MACvSetCurrBCNTxDescAddr(priv
->PortOffset
, priv
->tx_beacon_dma
);
1485 MACvSetCurrBCNLength(priv
->PortOffset
, priv
->wBCNBufLen
);
1486 /* Set auto Transmit on */
1487 MACvRegBitsOn(priv
->PortOffset
, MAC_REG_TCR
, TCR_AUTOBCNTX
);
1488 /* Poll Transmit the adapter */
1489 MACvTransmitBCN(priv
->PortOffset
);
1494 int vnt_beacon_make(struct vnt_private
*priv
, struct ieee80211_vif
*vif
)
1496 struct sk_buff
*beacon
;
1498 beacon
= ieee80211_beacon_get(priv
->hw
, vif
);
1502 if (vnt_beacon_xmit(priv
, beacon
)) {
1503 ieee80211_free_txskb(priv
->hw
, beacon
);
1510 int vnt_beacon_enable(struct vnt_private
*priv
, struct ieee80211_vif
*vif
,
1511 struct ieee80211_bss_conf
*conf
)
1513 VNSvOutPortB(priv
->PortOffset
+ MAC_REG_TFTCTL
, TFTCTL_TSFCNTRST
);
1515 VNSvOutPortB(priv
->PortOffset
+ MAC_REG_TFTCTL
, TFTCTL_TSFCNTREN
);
1517 CARDvSetFirstNextTBTT(priv
, conf
->beacon_int
);
1519 CARDbSetBeaconPeriod(priv
, conf
->beacon_int
);
1521 return vnt_beacon_make(priv
, vif
);