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;
1210 ptdCurr->buff_addr = cpu_to_le32(ptdCurr->pTDInfo->skb_dma);
1212 return cbHeaderLength;
1215 static void vnt_fill_txkey(struct ieee80211_hdr *hdr, u8 *key_buffer,
1216 struct ieee80211_key_conf *tx_key,
1217 struct sk_buff *skb, u16 payload_len,
1218 struct vnt_mic_hdr *mic_hdr)
1220 struct ieee80211_key_seq seq;
1221 u8 *iv = ((u8 *)hdr + ieee80211_get_hdrlen_from_skb(skb));
1223 /* strip header and icv len from payload */
1224 payload_len -= ieee80211_get_hdrlen_from_skb(skb);
1225 payload_len -= tx_key->icv_len;
1227 switch (tx_key->cipher) {
1228 case WLAN_CIPHER_SUITE_WEP40:
1229 case WLAN_CIPHER_SUITE_WEP104:
1230 memcpy(key_buffer, iv, 3);
1231 memcpy(key_buffer + 3, tx_key->key, tx_key->keylen);
1233 if (tx_key->keylen == WLAN_KEY_LEN_WEP40) {
1234 memcpy(key_buffer + 8, iv, 3);
1235 memcpy(key_buffer + 11,
1236 tx_key->key, WLAN_KEY_LEN_WEP40);
1240 case WLAN_CIPHER_SUITE_TKIP:
1241 ieee80211_get_tkip_p2k(tx_key, skb, key_buffer);
1244 case WLAN_CIPHER_SUITE_CCMP:
1250 mic_hdr->payload_len = cpu_to_be16(payload_len);
1251 ether_addr_copy(mic_hdr->mic_addr2, hdr->addr2);
1253 ieee80211_get_key_tx_seq(tx_key, &seq);
1255 memcpy(mic_hdr->ccmp_pn, seq.ccmp.pn, IEEE80211_CCMP_PN_LEN);
1257 if (ieee80211_has_a4(hdr->frame_control))
1258 mic_hdr->hlen = cpu_to_be16(28);
1260 mic_hdr->hlen = cpu_to_be16(22);
1262 ether_addr_copy(mic_hdr->addr1, hdr->addr1);
1263 ether_addr_copy(mic_hdr->addr2, hdr->addr2);
1264 ether_addr_copy(mic_hdr->addr3, hdr->addr3);
1266 mic_hdr->frame_control = cpu_to_le16(
1267 le16_to_cpu(hdr->frame_control) & 0xc78f);
1268 mic_hdr->seq_ctrl = cpu_to_le16(
1269 le16_to_cpu(hdr->seq_ctrl) & 0xf);
1271 if (ieee80211_has_a4(hdr->frame_control))
1272 ether_addr_copy(mic_hdr->addr4, hdr->addr4);
1274 memcpy(key_buffer, tx_key->key, WLAN_KEY_LEN_CCMP);
1282 int vnt_generate_fifo_header(struct vnt_private *priv, u32 dma_idx,
1283 PSTxDesc head_td, struct sk_buff *skb)
1285 PDEVICE_TD_INFO td_info = head_td->pTDInfo;
1286 struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
1287 struct ieee80211_tx_rate *tx_rate = &info->control.rates[0];
1288 struct ieee80211_rate *rate;
1289 struct ieee80211_key_conf *tx_key;
1290 struct ieee80211_hdr *hdr;
1291 struct vnt_tx_fifo_head *tx_buffer_head =
1292 (struct vnt_tx_fifo_head *)td_info->buf;
1293 u16 tx_body_size = skb->len, current_rate;
1295 bool is_pspoll = false;
1297 memset(tx_buffer_head, 0, sizeof(*tx_buffer_head));
1299 hdr = (struct ieee80211_hdr *)(skb->data);
1301 rate = ieee80211_get_tx_rate(priv->hw, info);
1303 current_rate = rate->hw_value;
1304 if (priv->wCurrentRate != current_rate &&
1305 !(priv->hw->conf.flags & IEEE80211_CONF_OFFCHANNEL)) {
1306 priv->wCurrentRate = current_rate;
1308 RFbSetPower(priv, priv->wCurrentRate,
1309 priv->hw->conf.chandef.chan->hw_value);
1312 if (current_rate > RATE_11M)
1313 pkt_type = (u8)priv->byPacketType;
1315 pkt_type = PK_TYPE_11B;
1317 /*Set fifo controls */
1318 if (pkt_type == PK_TYPE_11A)
1319 tx_buffer_head->fifo_ctl = 0;
1320 else if (pkt_type == PK_TYPE_11B)
1321 tx_buffer_head->fifo_ctl = cpu_to_le16(FIFOCTL_11B);
1322 else if (pkt_type == PK_TYPE_11GB)
1323 tx_buffer_head->fifo_ctl = cpu_to_le16(FIFOCTL_11GB);
1324 else if (pkt_type == PK_TYPE_11GA)
1325 tx_buffer_head->fifo_ctl = cpu_to_le16(FIFOCTL_11GA);
1327 /* generate interrupt */
1328 tx_buffer_head->fifo_ctl |= cpu_to_le16(FIFOCTL_GENINT);
1330 if (!ieee80211_is_data(hdr->frame_control)) {
1331 tx_buffer_head->fifo_ctl |= cpu_to_le16(FIFOCTL_TMOEN);
1332 tx_buffer_head->fifo_ctl |= cpu_to_le16(FIFOCTL_ISDMA0);
1333 tx_buffer_head->time_stamp =
1334 cpu_to_le16(DEFAULT_MGN_LIFETIME_RES_64us);
1336 tx_buffer_head->time_stamp =
1337 cpu_to_le16(DEFAULT_MSDU_LIFETIME_RES_64us);
1340 if (!(info->flags & IEEE80211_TX_CTL_NO_ACK))
1341 tx_buffer_head->fifo_ctl |= cpu_to_le16(FIFOCTL_NEEDACK);
1343 if (ieee80211_has_retry(hdr->frame_control))
1344 tx_buffer_head->fifo_ctl |= cpu_to_le16(FIFOCTL_LRETRY);
1346 if (tx_rate->flags & IEEE80211_TX_RC_USE_SHORT_PREAMBLE)
1347 priv->byPreambleType = PREAMBLE_SHORT;
1349 priv->byPreambleType = PREAMBLE_LONG;
1351 if (tx_rate->flags & IEEE80211_TX_RC_USE_RTS_CTS)
1352 tx_buffer_head->fifo_ctl |= cpu_to_le16(FIFOCTL_RTS);
1354 if (ieee80211_has_a4(hdr->frame_control)) {
1355 tx_buffer_head->fifo_ctl |= cpu_to_le16(FIFOCTL_LHEAD);
1356 priv->bLongHeader = true;
1359 if (info->flags & IEEE80211_TX_CTL_NO_PS_BUFFER)
1362 tx_buffer_head->frag_ctl =
1363 cpu_to_le16(ieee80211_get_hdrlen_from_skb(skb) << 10);
1365 if (info->control.hw_key) {
1366 tx_key = info->control.hw_key;
1368 switch (info->control.hw_key->cipher) {
1369 case WLAN_CIPHER_SUITE_WEP40:
1370 case WLAN_CIPHER_SUITE_WEP104:
1371 tx_buffer_head->frag_ctl |= cpu_to_le16(FRAGCTL_LEGACY);
1373 case WLAN_CIPHER_SUITE_TKIP:
1374 tx_buffer_head->frag_ctl |= cpu_to_le16(FRAGCTL_TKIP);
1376 case WLAN_CIPHER_SUITE_CCMP:
1377 tx_buffer_head->frag_ctl |= cpu_to_le16(FRAGCTL_AES);
1383 tx_buffer_head->current_rate = cpu_to_le16(current_rate);
1385 /* legacy rates TODO use ieee80211_tx_rate */
1386 if (current_rate >= RATE_18M && ieee80211_is_data(hdr->frame_control)) {
1387 if (priv->byAutoFBCtrl == AUTO_FB_0)
1388 tx_buffer_head->fifo_ctl |=
1389 cpu_to_le16(FIFOCTL_AUTO_FB_0);
1390 else if (priv->byAutoFBCtrl == AUTO_FB_1)
1391 tx_buffer_head->fifo_ctl |=
1392 cpu_to_le16(FIFOCTL_AUTO_FB_1);
1396 tx_buffer_head->frag_ctl |= cpu_to_le16(FRAGCTL_NONFRAG);
1398 s_cbFillTxBufHead(priv, pkt_type, (u8 *)tx_buffer_head,
1399 dma_idx, head_td, is_pspoll);
1401 if (info->control.hw_key) {
1402 tx_key = info->control.hw_key;
1403 if (tx_key->keylen > 0)
1404 vnt_fill_txkey(hdr, tx_buffer_head->tx_key,
1405 tx_key, skb, tx_body_size, td_info->mic_hdr);
1411 static int vnt_beacon_xmit(struct vnt_private *priv,
1412 struct sk_buff *skb)
1414 struct vnt_tx_short_buf_head *short_head =
1415 (struct vnt_tx_short_buf_head *)priv->tx_beacon_bufs;
1416 struct ieee80211_mgmt *mgmt_hdr = (struct ieee80211_mgmt *)
1417 (priv->tx_beacon_bufs + sizeof(*short_head));
1418 struct ieee80211_tx_info *info;
1419 u32 frame_size = skb->len + 4;
1422 memset(priv->tx_beacon_bufs, 0, sizeof(*short_head));
1424 if (priv->byBBType == BB_TYPE_11A) {
1425 current_rate = RATE_6M;
1427 /* Get SignalField,ServiceField,Length */
1428 vnt_get_phy_field(priv, frame_size, current_rate,
1429 PK_TYPE_11A, &short_head->ab);
1431 /* Get Duration and TimeStampOff */
1432 short_head->duration =
1433 cpu_to_le16((u16)s_uGetDataDuration(priv, DATADUR_B,
1434 frame_size, PK_TYPE_11A, current_rate,
1435 false, 0, 0, 1, AUTO_FB_NONE));
1437 short_head->time_stamp_off =
1438 vnt_time_stamp_off(priv, current_rate);
1440 current_rate = RATE_1M;
1441 short_head->fifo_ctl |= cpu_to_le16(FIFOCTL_11B);
1443 /* Get SignalField,ServiceField,Length */
1444 vnt_get_phy_field(priv, frame_size, current_rate,
1445 PK_TYPE_11B, &short_head->ab);
1447 /* Get Duration and TimeStampOff */
1448 short_head->duration =
1449 cpu_to_le16((u16)s_uGetDataDuration(priv, DATADUR_B,
1450 frame_size, PK_TYPE_11B, current_rate,
1451 false, 0, 0, 1, AUTO_FB_NONE));
1453 short_head->time_stamp_off =
1454 vnt_time_stamp_off(priv, current_rate);
1457 short_head->fifo_ctl |= cpu_to_le16(FIFOCTL_GENINT);
1460 memcpy(mgmt_hdr, skb->data, skb->len);
1462 /* time stamp always 0 */
1463 mgmt_hdr->u.beacon.timestamp = 0;
1465 info = IEEE80211_SKB_CB(skb);
1466 if (info->flags & IEEE80211_TX_CTL_ASSIGN_SEQ) {
1467 struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)mgmt_hdr;
1469 hdr->duration_id = 0;
1470 hdr->seq_ctrl = cpu_to_le16(priv->wSeqCounter << 4);
1473 priv->wSeqCounter++;
1474 if (priv->wSeqCounter > 0x0fff)
1475 priv->wSeqCounter = 0;
1477 priv->wBCNBufLen = sizeof(*short_head) + skb->len;
1479 MACvSetCurrBCNTxDescAddr(priv->PortOffset, priv->tx_beacon_dma);
1481 MACvSetCurrBCNLength(priv->PortOffset, priv->wBCNBufLen);
1482 /* Set auto Transmit on */
1483 MACvRegBitsOn(priv->PortOffset, MAC_REG_TCR, TCR_AUTOBCNTX);
1484 /* Poll Transmit the adapter */
1485 MACvTransmitBCN(priv->PortOffset);
1490 int vnt_beacon_make(struct vnt_private *priv, struct ieee80211_vif *vif)
1492 struct sk_buff *beacon;
1494 beacon = ieee80211_beacon_get(priv->hw, vif);
1498 if (vnt_beacon_xmit(priv, beacon)) {
1499 ieee80211_free_txskb(priv->hw, beacon);
1506 int vnt_beacon_enable(struct vnt_private *priv, struct ieee80211_vif *vif,
1507 struct ieee80211_bss_conf *conf)
1511 VNSvOutPortB(priv->PortOffset + MAC_REG_TFTCTL, TFTCTL_TSFCNTRST);
1513 VNSvOutPortB(priv->PortOffset + MAC_REG_TFTCTL, TFTCTL_TSFCNTREN);
1515 CARDvSetFirstNextTBTT(priv, conf->beacon_int);
1517 CARDbSetBeaconPeriod(priv, conf->beacon_int);
1519 ret = vnt_beacon_make(priv, vif);