projects / deliverable / linux.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Merge branch 'fixes' of git://git.kernel.org/pub/scm/linux/kernel/git/evalenti/linux...
[deliverable/linux.git] / drivers / staging / vt6655 / rxtx.c
1 /*
2 * Copyright (c) 1996, 2003 VIA Networking Technologies, Inc.
3 * All rights reserved.
4 *
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.
9 *
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.
14 *
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.
18 *
19 * File: rxtx.c
20 *
21 * Purpose: handle WMAC/802.3/802.11 rx & tx functions
22 *
23 * Author: Lyndon Chen
24 *
25 * Date: May 20, 2003
26 *
27 * 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
46 *
47 * Revision History:
48 *
49 */
50
51 #include "device.h"
52 #include "rxtx.h"
53 #include "card.h"
54 #include "mac.h"
55 #include "baseband.h"
56 #include "rf.h"
57
58 /*--------------------- Static Definitions -------------------------*/
59
60 /*--------------------- Static Classes ----------------------------*/
61
62 /*--------------------- Static Variables --------------------------*/
63
64 /*--------------------- Static Functions --------------------------*/
65
66 /*--------------------- Static Definitions -------------------------*/
67 #define CRITICAL_PACKET_LEN 256 // if packet size < 256 -> in-direct send
68 // packet size >= 256 -> direct send
69
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
73 };
74
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
78 };
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
82 };
83
84 #define RTSDUR_BB 0
85 #define RTSDUR_BA 1
86 #define RTSDUR_AA 2
87 #define CTSDUR_BA 3
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
94 #define DATADUR_B 10
95 #define DATADUR_A 11
96 #define DATADUR_A_F0 12
97 #define DATADUR_A_F1 13
98
99 /*--------------------- Static Functions --------------------------*/
100 static
101 void
102 s_vFillRTSHead(
103 struct vnt_private *pDevice,
104 unsigned char byPktType,
105 void *pvRTS,
106 unsigned int cbFrameLength,
107 bool bNeedAck,
108 bool bDisCRC,
109 struct ieee80211_hdr *hdr,
110 unsigned short wCurrentRate,
111 unsigned char byFBOption
112 );
113
114 static
115 void
116 s_vGenerateTxParameter(
117 struct vnt_private *pDevice,
118 unsigned char byPktType,
119 void *pTxBufHead,
120 void *pvRrvTime,
121 void *pvRTS,
122 void *pvCTS,
123 unsigned int cbFrameSize,
124 bool bNeedACK,
125 unsigned int uDMAIdx,
126 void *psEthHeader,
127 unsigned short wCurrentRate
128 );
129
130 static unsigned int
131 s_cbFillTxBufHead(struct vnt_private *pDevice, unsigned char byPktType,
132 unsigned char *pbyTxBufferAddr,
133 unsigned int uDMAIdx, PSTxDesc pHeadTD,
134 unsigned int uNodeIndex);
135
136 static
137 __le16
138 s_uFillDataHead(
139 struct vnt_private *pDevice,
140 unsigned char byPktType,
141 void *pTxDataHead,
142 unsigned int cbFrameLength,
143 unsigned int uDMAIdx,
144 bool bNeedAck,
145 unsigned int uFragIdx,
146 unsigned int cbLastFragmentSize,
147 unsigned int uMACfragNum,
148 unsigned char byFBOption,
149 unsigned short wCurrentRate,
150 bool is_pspoll
151 );
152
153 /*--------------------- Export Variables --------------------------*/
154
155 static __le16 vnt_time_stamp_off(struct vnt_private *priv, u16 rate)
156 {
157 return cpu_to_le16(wTimeStampOff[priv->byPreambleType % 2]
158 [rate % MAX_RATE]);
159 }
160
161 /*byPktType : PK_TYPE_11A 0
162 PK_TYPE_11B 1
163 PK_TYPE_11GB 2
164 PK_TYPE_11GA 3
165 */
166 static
167 unsigned int
168 s_uGetTxRsvTime(
169 struct vnt_private *pDevice,
170 unsigned char byPktType,
171 unsigned int cbFrameLength,
172 unsigned short wRate,
173 bool bNeedAck
174 )
175 {
176 unsigned int uDataTime, uAckTime;
177
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);
183
184 if (bNeedAck)
185 return uDataTime + pDevice->uSIFS + uAckTime;
186 else
187 return uDataTime;
188 }
189
190 static __le16 vnt_rxtx_rsvtime_le16(struct vnt_private *priv, u8 pkt_type,
191 u32 frame_length, u16 rate, bool need_ack)
192 {
193 return cpu_to_le16((u16)s_uGetTxRsvTime(priv, pkt_type,
194 frame_length, rate, need_ack));
195 }
196
197 //byFreqType: 0=>5GHZ 1=>2.4GHZ
198 static
199 __le16
200 s_uGetRTSCTSRsvTime(
201 struct vnt_private *pDevice,
202 unsigned char byRTSRsvType,
203 unsigned char byPktType,
204 unsigned int cbFrameLength,
205 unsigned short wCurrentRate
206 )
207 {
208 unsigned int uRrvTime, uRTSTime, uCTSTime, uAckTime, uDataTime;
209
210 uRrvTime = uRTSTime = uCTSTime = uAckTime = uDataTime = 0;
211
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);
228 }
229
230 //RTSRrvTime
231 uRrvTime = uRTSTime + uCTSTime + uAckTime + uDataTime + 3*pDevice->uSIFS;
232 return cpu_to_le16((u16)uRrvTime);
233 }
234
235 //byFreqType 0: 5GHz, 1:2.4Ghz
236 static
237 unsigned int
238 s_uGetDataDuration(
239 struct vnt_private *pDevice,
240 unsigned char byDurType,
241 unsigned int cbFrameLength,
242 unsigned char byPktType,
243 unsigned short wRate,
244 bool bNeedAck,
245 unsigned int uFragIdx,
246 unsigned int cbLastFragmentSize,
247 unsigned int uMACfragNum,
248 unsigned char byFBOption
249 )
250 {
251 bool bLastFrag = 0;
252 unsigned int uAckTime = 0, uNextPktTime = 0;
253
254 if (uFragIdx == (uMACfragNum-1))
255 bLastFrag = 1;
256
257 switch (byDurType) {
258 case DATADUR_B: //DATADUR_B
259 if (((uMACfragNum == 1)) || bLastFrag) {//Non Frag or Last Frag
260 if (bNeedAck) {
261 uAckTime = BBuGetFrameTime(pDevice->byPreambleType, byPktType, 14, pDevice->byTopCCKBasicRate);
262 return pDevice->uSIFS + uAckTime;
263 } else {
264 return 0;
265 }
266 } else {//First Frag or Mid Frag
267 if (uFragIdx == (uMACfragNum-2))
268 uNextPktTime = s_uGetTxRsvTime(pDevice, byPktType, cbLastFragmentSize, wRate, bNeedAck);
269 else
270 uNextPktTime = s_uGetTxRsvTime(pDevice, byPktType, cbFrameLength, wRate, bNeedAck);
271
272 if (bNeedAck) {
273 uAckTime = BBuGetFrameTime(pDevice->byPreambleType, byPktType, 14, pDevice->byTopCCKBasicRate);
274 return pDevice->uSIFS + uAckTime + uNextPktTime;
275 } else {
276 return pDevice->uSIFS + uNextPktTime;
277 }
278 }
279 break;
280
281 case DATADUR_A: //DATADUR_A
282 if (((uMACfragNum == 1)) || bLastFrag) {//Non Frag or Last Frag
283 if (bNeedAck) {
284 uAckTime = BBuGetFrameTime(pDevice->byPreambleType, byPktType, 14, pDevice->byTopOFDMBasicRate);
285 return pDevice->uSIFS + uAckTime;
286 } else {
287 return 0;
288 }
289 } else {//First Frag or Mid Frag
290 if (uFragIdx == (uMACfragNum-2))
291 uNextPktTime = s_uGetTxRsvTime(pDevice, byPktType, cbLastFragmentSize, wRate, bNeedAck);
292 else
293 uNextPktTime = s_uGetTxRsvTime(pDevice, byPktType, cbFrameLength, wRate, bNeedAck);
294
295 if (bNeedAck) {
296 uAckTime = BBuGetFrameTime(pDevice->byPreambleType, byPktType, 14, pDevice->byTopOFDMBasicRate);
297 return pDevice->uSIFS + uAckTime + uNextPktTime;
298 } else {
299 return pDevice->uSIFS + uNextPktTime;
300 }
301 }
302 break;
303
304 case DATADUR_A_F0: //DATADUR_A_F0
305 if (((uMACfragNum == 1)) || bLastFrag) {//Non Frag or Last Frag
306 if (bNeedAck) {
307 uAckTime = BBuGetFrameTime(pDevice->byPreambleType, byPktType, 14, pDevice->byTopOFDMBasicRate);
308 return pDevice->uSIFS + uAckTime;
309 } else {
310 return 0;
311 }
312 } else { //First Frag or Mid Frag
313 if (byFBOption == AUTO_FB_0) {
314 if (wRate < RATE_18M)
315 wRate = RATE_18M;
316 else if (wRate > RATE_54M)
317 wRate = RATE_54M;
318
319 if (uFragIdx == (uMACfragNum-2))
320 uNextPktTime = s_uGetTxRsvTime(pDevice, byPktType, cbLastFragmentSize, wFB_Opt0[FB_RATE0][wRate-RATE_18M], bNeedAck);
321 else
322 uNextPktTime = s_uGetTxRsvTime(pDevice, byPktType, cbFrameLength, wFB_Opt0[FB_RATE0][wRate-RATE_18M], bNeedAck);
323
324 } else { // (byFBOption == AUTO_FB_1)
325 if (wRate < RATE_18M)
326 wRate = RATE_18M;
327 else if (wRate > RATE_54M)
328 wRate = RATE_54M;
329
330 if (uFragIdx == (uMACfragNum-2))
331 uNextPktTime = s_uGetTxRsvTime(pDevice, byPktType, cbLastFragmentSize, wFB_Opt1[FB_RATE0][wRate-RATE_18M], bNeedAck);
332 else
333 uNextPktTime = s_uGetTxRsvTime(pDevice, byPktType, cbFrameLength, wFB_Opt1[FB_RATE0][wRate-RATE_18M], bNeedAck);
334
335 }
336
337 if (bNeedAck) {
338 uAckTime = BBuGetFrameTime(pDevice->byPreambleType, byPktType, 14, pDevice->byTopOFDMBasicRate);
339 return pDevice->uSIFS + uAckTime + uNextPktTime;
340 } else {
341 return pDevice->uSIFS + uNextPktTime;
342 }
343 }
344 break;
345
346 case DATADUR_A_F1: //DATADUR_A_F1
347 if (((uMACfragNum == 1)) || bLastFrag) {//Non Frag or Last Frag
348 if (bNeedAck) {
349 uAckTime = BBuGetFrameTime(pDevice->byPreambleType, byPktType, 14, pDevice->byTopOFDMBasicRate);
350 return pDevice->uSIFS + uAckTime;
351 } else {
352 return 0;
353 }
354 } else { //First Frag or Mid Frag
355 if (byFBOption == AUTO_FB_0) {
356 if (wRate < RATE_18M)
357 wRate = RATE_18M;
358 else if (wRate > RATE_54M)
359 wRate = RATE_54M;
360
361 if (uFragIdx == (uMACfragNum-2))
362 uNextPktTime = s_uGetTxRsvTime(pDevice, byPktType, cbLastFragmentSize, wFB_Opt0[FB_RATE1][wRate-RATE_18M], bNeedAck);
363 else
364 uNextPktTime = s_uGetTxRsvTime(pDevice, byPktType, cbFrameLength, wFB_Opt0[FB_RATE1][wRate-RATE_18M], bNeedAck);
365
366 } else { // (byFBOption == AUTO_FB_1)
367 if (wRate < RATE_18M)
368 wRate = RATE_18M;
369 else if (wRate > RATE_54M)
370 wRate = RATE_54M;
371
372 if (uFragIdx == (uMACfragNum-2))
373 uNextPktTime = s_uGetTxRsvTime(pDevice, byPktType, cbLastFragmentSize, wFB_Opt1[FB_RATE1][wRate-RATE_18M], bNeedAck);
374 else
375 uNextPktTime = s_uGetTxRsvTime(pDevice, byPktType, cbFrameLength, wFB_Opt1[FB_RATE1][wRate-RATE_18M], bNeedAck);
376 }
377 if (bNeedAck) {
378 uAckTime = BBuGetFrameTime(pDevice->byPreambleType, byPktType, 14, pDevice->byTopOFDMBasicRate);
379 return pDevice->uSIFS + uAckTime + uNextPktTime;
380 } else {
381 return pDevice->uSIFS + uNextPktTime;
382 }
383 }
384 break;
385
386 default:
387 break;
388 }
389
390 ASSERT(false);
391 return 0;
392 }
393
394 //byFreqType: 0=>5GHZ 1=>2.4GHZ
395 static
396 __le16
397 s_uGetRTSCTSDuration(
398 struct vnt_private *pDevice,
399 unsigned char byDurType,
400 unsigned int cbFrameLength,
401 unsigned char byPktType,
402 unsigned short wRate,
403 bool bNeedAck,
404 unsigned char byFBOption
405 )
406 {
407 unsigned int uCTSTime = 0, uDurTime = 0;
408
409 switch (byDurType) {
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);
413 break;
414
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);
418 break;
419
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);
423 break;
424
425 case CTSDUR_BA: //CTSDuration_ba
426 uDurTime = pDevice->uSIFS + s_uGetTxRsvTime(pDevice, byPktType, cbFrameLength, wRate, bNeedAck);
427 break;
428
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);
435
436 break;
437
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);
444
445 break;
446
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);
453
454 break;
455
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);
462
463 break;
464
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);
470
471 break;
472
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);
478
479 break;
480
481 default:
482 break;
483 }
484
485 return cpu_to_le16((u16)uDurTime);
486 }
487
488 static
489 __le16
490 s_uFillDataHead(
491 struct vnt_private *pDevice,
492 unsigned char byPktType,
493 void *pTxDataHead,
494 unsigned int cbFrameLength,
495 unsigned int uDMAIdx,
496 bool bNeedAck,
497 unsigned int uFragIdx,
498 unsigned int cbLastFragmentSize,
499 unsigned int uMACfragNum,
500 unsigned char byFBOption,
501 unsigned short wCurrentRate,
502 bool is_pspoll
503 )
504 {
505
506 if (pTxDataHead == NULL)
507 return 0;
508
509
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,
515 byPktType, &buf->a);
516
517 vnt_get_phy_field(pDevice, cbFrameLength,
518 pDevice->byTopCCKBasicRate,
519 PK_TYPE_11B, &buf->b);
520
521 if (is_pspoll) {
522 __le16 dur = cpu_to_le16(pDevice->current_aid | BIT(14) | BIT(15));
523
524 buf->duration_a = dur;
525 buf->duration_b = dur;
526 } else {
527 /* Get Duration and TimeStamp */
528 buf->duration_a =
529 cpu_to_le16((u16)s_uGetDataDuration(pDevice, DATADUR_A, cbFrameLength,
530 byPktType, wCurrentRate, bNeedAck, uFragIdx,
531 cbLastFragmentSize, uMACfragNum,
532 byFBOption));
533 buf->duration_b =
534 cpu_to_le16((u16)s_uGetDataDuration(pDevice, DATADUR_B, cbFrameLength,
535 PK_TYPE_11B, pDevice->byTopCCKBasicRate,
536 bNeedAck, uFragIdx, cbLastFragmentSize,
537 uMACfragNum, byFBOption));
538 }
539
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);
542
543 return buf->duration_a;
544 } else {
545 /* Auto Fallback */
546 struct vnt_tx_datahead_g_fb *buf = pTxDataHead;
547 /* Get SignalField, ServiceField & Length */
548 vnt_get_phy_field(pDevice, cbFrameLength, wCurrentRate,
549 byPktType, &buf->a);
550
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));
563
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);
566
567 return buf->duration_a;
568 } //if (byFBOption == AUTO_FB_NONE)
569 } else if (byPktType == PK_TYPE_11A) {
570 if ((byFBOption != AUTO_FB_NONE)) {
571 /* Auto Fallback */
572 struct vnt_tx_datahead_a_fb *buf = pTxDataHead;
573 /* Get SignalField, ServiceField & Length */
574 vnt_get_phy_field(pDevice, cbFrameLength, wCurrentRate,
575 byPktType, &buf->a);
576
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;
586 } else {
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);
591
592 if (is_pspoll) {
593 __le16 dur = cpu_to_le16(pDevice->current_aid | BIT(14) | BIT(15));
594
595 buf->duration = dur;
596 } else {
597 /* Get Duration and TimeStampOff */
598 buf->duration =
599 cpu_to_le16((u16)s_uGetDataDuration(pDevice, DATADUR_A, cbFrameLength, byPktType,
600 wCurrentRate, bNeedAck, uFragIdx,
601 cbLastFragmentSize, uMACfragNum,
602 byFBOption));
603 }
604
605 buf->time_stamp_off = vnt_time_stamp_off(pDevice, wCurrentRate);
606 return buf->duration;
607 }
608 } else {
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);
613
614 if (is_pspoll) {
615 __le16 dur = cpu_to_le16(pDevice->current_aid | BIT(14) | BIT(15));
616
617 buf->duration = dur;
618 } else {
619 /* Get Duration and TimeStampOff */
620 buf->duration =
621 cpu_to_le16((u16)s_uGetDataDuration(pDevice, DATADUR_B, cbFrameLength, byPktType,
622 wCurrentRate, bNeedAck, uFragIdx,
623 cbLastFragmentSize, uMACfragNum,
624 byFBOption));
625 }
626
627 buf->time_stamp_off = vnt_time_stamp_off(pDevice, wCurrentRate);
628 return buf->duration;
629 }
630 return 0;
631 }
632
633
634 static
635 void
636 s_vFillRTSHead(
637 struct vnt_private *pDevice,
638 unsigned char byPktType,
639 void *pvRTS,
640 unsigned int cbFrameLength,
641 bool bNeedAck,
642 bool bDisCRC,
643 struct ieee80211_hdr *hdr,
644 unsigned short wCurrentRate,
645 unsigned char byFBOption
646 )
647 {
648 unsigned int uRTSFrameLen = 20;
649
650 if (pvRTS == NULL)
651 return;
652
653 if (bDisCRC) {
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.
656 uRTSFrameLen -= 4;
657 }
658
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);
668
669 vnt_get_phy_field(pDevice, uRTSFrameLen,
670 pDevice->byTopOFDMBasicRate,
671 byPktType, &buf->a);
672 /* Get Duration */
673 buf->duration_bb =
674 s_uGetRTSCTSDuration(pDevice, RTSDUR_BB,
675 cbFrameLength, PK_TYPE_11B,
676 pDevice->byTopCCKBasicRate,
677 bNeedAck, byFBOption);
678 buf->duration_aa =
679 s_uGetRTSCTSDuration(pDevice, RTSDUR_AA,
680 cbFrameLength, byPktType,
681 wCurrentRate, bNeedAck,
682 byFBOption);
683 buf->duration_ba =
684 s_uGetRTSCTSDuration(pDevice, RTSDUR_BA,
685 cbFrameLength, byPktType,
686 wCurrentRate, bNeedAck,
687 byFBOption);
688
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);
694
695 ether_addr_copy(buf->data.ra, hdr->addr1);
696 ether_addr_copy(buf->data.ta, hdr->addr2);
697 } else {
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);
703
704 vnt_get_phy_field(pDevice, uRTSFrameLen,
705 pDevice->byTopOFDMBasicRate,
706 byPktType, &buf->a);
707 /* Get Duration */
708 buf->duration_bb =
709 s_uGetRTSCTSDuration(pDevice, RTSDUR_BB,
710 cbFrameLength, PK_TYPE_11B,
711 pDevice->byTopCCKBasicRate,
712 bNeedAck, byFBOption);
713 buf->duration_aa =
714 s_uGetRTSCTSDuration(pDevice, RTSDUR_AA,
715 cbFrameLength, byPktType,
716 wCurrentRate, bNeedAck,
717 byFBOption);
718 buf->duration_ba =
719 s_uGetRTSCTSDuration(pDevice, RTSDUR_BA,
720 cbFrameLength, byPktType,
721 wCurrentRate, bNeedAck,
722 byFBOption);
723 buf->rts_duration_ba_f0 =
724 s_uGetRTSCTSDuration(pDevice, RTSDUR_BA_F0,
725 cbFrameLength, byPktType,
726 wCurrentRate, bNeedAck,
727 byFBOption);
728 buf->rts_duration_aa_f0 =
729 s_uGetRTSCTSDuration(pDevice, RTSDUR_AA_F0,
730 cbFrameLength, byPktType,
731 wCurrentRate, bNeedAck,
732 byFBOption);
733 buf->rts_duration_ba_f1 =
734 s_uGetRTSCTSDuration(pDevice, RTSDUR_BA_F1,
735 cbFrameLength, byPktType,
736 wCurrentRate, bNeedAck,
737 byFBOption);
738 buf->rts_duration_aa_f1 =
739 s_uGetRTSCTSDuration(pDevice, RTSDUR_AA_F1,
740 cbFrameLength, byPktType,
741 wCurrentRate, bNeedAck,
742 byFBOption);
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);
748
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);
759 /* Get Duration */
760 buf->duration =
761 s_uGetRTSCTSDuration(pDevice, RTSDUR_AA,
762 cbFrameLength, byPktType,
763 wCurrentRate, bNeedAck,
764 byFBOption);
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);
770
771 ether_addr_copy(buf->data.ra, hdr->addr1);
772 ether_addr_copy(buf->data.ta, hdr->addr2);
773 } else {
774 struct vnt_rts_a_fb *buf = pvRTS;
775 /* Get SignalField, ServiceField & Length */
776 vnt_get_phy_field(pDevice, uRTSFrameLen,
777 pDevice->byTopOFDMBasicRate,
778 byPktType, &buf->a);
779 /* Get Duration */
780 buf->duration =
781 s_uGetRTSCTSDuration(pDevice, RTSDUR_AA,
782 cbFrameLength, byPktType,
783 wCurrentRate, bNeedAck,
784 byFBOption);
785 buf->rts_duration_f0 =
786 s_uGetRTSCTSDuration(pDevice, RTSDUR_AA_F0,
787 cbFrameLength, byPktType,
788 wCurrentRate, bNeedAck,
789 byFBOption);
790 buf->rts_duration_f1 =
791 s_uGetRTSCTSDuration(pDevice, RTSDUR_AA_F1,
792 cbFrameLength, byPktType,
793 wCurrentRate, bNeedAck,
794 byFBOption);
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);
800
801 ether_addr_copy(buf->data.ra, hdr->addr1);
802 ether_addr_copy(buf->data.ta, hdr->addr2);
803 }
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);
810 /* Get Duration */
811 buf->duration =
812 s_uGetRTSCTSDuration(pDevice, RTSDUR_BB, cbFrameLength,
813 byPktType, wCurrentRate, bNeedAck,
814 byFBOption);
815
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);
820
821 ether_addr_copy(buf->data.ra, hdr->addr1);
822 ether_addr_copy(buf->data.ta, hdr->addr2);
823 }
824 }
825
826 static
827 void
828 s_vFillCTSHead(
829 struct vnt_private *pDevice,
830 unsigned int uDMAIdx,
831 unsigned char byPktType,
832 void *pvCTS,
833 unsigned int cbFrameLength,
834 bool bNeedAck,
835 bool bDisCRC,
836 unsigned short wCurrentRate,
837 unsigned char byFBOption
838 )
839 {
840 unsigned int uCTSFrameLen = 14;
841
842 if (pvCTS == NULL)
843 return;
844
845 if (bDisCRC) {
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.
848 uCTSFrameLen -= 4;
849 }
850
851 if (byPktType == PK_TYPE_11GB || byPktType == PK_TYPE_11GA) {
852 if (byFBOption != AUTO_FB_NONE && uDMAIdx != TYPE_ATIMDMA && uDMAIdx != TYPE_BEACONDMA) {
853 // Auto Fall back
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);
859
860 buf->duration_ba =
861 s_uGetRTSCTSDuration(pDevice, CTSDUR_BA,
862 cbFrameLength, byPktType,
863 wCurrentRate, bNeedAck,
864 byFBOption);
865
866 /* Get CTSDuration_ba_f0 */
867 buf->cts_duration_ba_f0 =
868 s_uGetRTSCTSDuration(pDevice, CTSDUR_BA_F0,
869 cbFrameLength, byPktType,
870 wCurrentRate, bNeedAck,
871 byFBOption);
872
873 /* Get CTSDuration_ba_f1 */
874 buf->cts_duration_ba_f1 =
875 s_uGetRTSCTSDuration(pDevice, CTSDUR_BA_F1,
876 cbFrameLength, byPktType,
877 wCurrentRate, bNeedAck,
878 byFBOption);
879
880 /* Get CTS Frame body */
881 buf->data.duration = buf->duration_ba;
882
883 buf->data.frame_control =
884 cpu_to_le16(IEEE80211_FTYPE_CTL |
885 IEEE80211_STYPE_CTS);
886
887 buf->reserved2 = 0x0;
888
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);
897
898 /* Get CTSDuration_ba */
899 buf->duration_ba =
900 s_uGetRTSCTSDuration(pDevice, CTSDUR_BA,
901 cbFrameLength, byPktType,
902 wCurrentRate, bNeedAck,
903 byFBOption);
904
905 /* Get CTS Frame body */
906 buf->data.duration = buf->duration_ba;
907
908 buf->data.frame_control =
909 cpu_to_le16(IEEE80211_FTYPE_CTL |
910 IEEE80211_STYPE_CTS);
911
912 buf->reserved2 = 0x0;
913 ether_addr_copy(buf->data.ra,
914 pDevice->abyCurrentNetAddr);
915 }
916 }
917 }
918
919 /*+
920 *
921 * Description:
922 * Generate FIFO control for MAC & Baseband controller
923 *
924 * Parameters:
925 * In:
926 * pDevice - Pointer to adapter
927 * pTxDataHead - Transmit Data Buffer
928 * pTxBufHead - pTxBufHead
929 * pvRrvTime - pvRrvTime
930 * pvRTS - RTS Buffer
931 * pCTS - CTS Buffer
932 * cbFrameSize - Transmit Data Length (Hdr+Payload+FCS)
933 * bNeedACK - If need ACK
934 * uDescIdx - Desc Index
935 * Out:
936 * none
937 *
938 * Return Value: none
939 *
940 -*/
941 // unsigned int cbFrameSize,//Hdr+Payload+FCS
942 static
943 void
944 s_vGenerateTxParameter(
945 struct vnt_private *pDevice,
946 unsigned char byPktType,
947 void *pTxBufHead,
948 void *pvRrvTime,
949 void *pvRTS,
950 void *pvCTS,
951 unsigned int cbFrameSize,
952 bool bNeedACK,
953 unsigned int uDMAIdx,
954 void *psEthHeader,
955 unsigned short wCurrentRate
956 )
957 {
958 unsigned short wFifoCtl;
959 bool bDisCRC = false;
960 unsigned char byFBOption = AUTO_FB_NONE;
961
962 PSTxBufHead pFifoHead = (PSTxBufHead)pTxBufHead;
963
964 pFifoHead->wReserved = wCurrentRate;
965 wFifoCtl = pFifoHead->wFIFOCtl;
966
967 if (wFifoCtl & FIFOCTL_CRCDIS)
968 bDisCRC = true;
969
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;
974
975 if (!pvRrvTime)
976 return;
977
978 if (byPktType == PK_TYPE_11GB || byPktType == PK_TYPE_11GA) {
979 if (pvRTS != NULL) { //RTS_need
980 /* Fill RsvTime */
981 struct vnt_rrv_time_rts *buf = pvRrvTime;
982
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);
988
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;
992
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);
996
997 //Fill CTS
998 s_vFillCTSHead(pDevice, uDMAIdx, byPktType, pvCTS, cbFrameSize, bNeedACK, bDisCRC, wCurrentRate, byFBOption);
999 }
1000 } else if (byPktType == PK_TYPE_11A) {
1001 if (pvRTS != NULL) {//RTS_need, non PCF mode
1002 struct vnt_rrv_time_ab *buf = pvRrvTime;
1003
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);
1006
1007 //Fill RTS
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;
1011
1012 buf->rrv_time = vnt_rxtx_rsvtime_le16(pDevice, PK_TYPE_11A, cbFrameSize, wCurrentRate, bNeedACK);
1013 }
1014 } else if (byPktType == PK_TYPE_11B) {
1015 if ((pvRTS != NULL)) {//RTS_need, non PCF mode
1016 struct vnt_rrv_time_ab *buf = pvRrvTime;
1017
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);
1020
1021 //Fill RTS
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;
1025
1026 buf->rrv_time = vnt_rxtx_rsvtime_le16(pDevice, PK_TYPE_11B, cbFrameSize, wCurrentRate, bNeedACK);
1027 }
1028 }
1029 }
1030
1031 static unsigned int
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)
1036 {
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;
1045 __le16 uDuration;
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);
1054 PSTxDesc ptdCurr;
1055 unsigned int cbHeaderLength = 0;
1056 void *pvRrvTime;
1057 struct vnt_mic_hdr *pMICHDR;
1058 void *pvRTS;
1059 void *pvCTS;
1060 void *pvTxDataHd;
1061 unsigned short wTxBufSize; // FFinfo size
1062 unsigned char byFBOption = AUTO_FB_NONE;
1063
1064 pvRrvTime = pMICHDR = pvRTS = pvCTS = pvTxDataHd = NULL;
1065
1066 cbFrameSize = skb->len + 4;
1067
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);
1072 default:
1073 break;
1074 }
1075
1076 cbFrameSize += info->control.hw_key->icv_len;
1077
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);
1081 uPadding %= 4;
1082 }
1083 }
1084
1085 //
1086 // Use for AUTO FALL BACK
1087 //
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;
1092
1093 //////////////////////////////////////////////////////
1094 //Set RrvTime/RTS/CTS Buffer
1095 wTxBufSize = sizeof(STxBufHead);
1096 if (byPktType == PK_TYPE_11GB || byPktType == PK_TYPE_11GA) {//802.11g packet
1097
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);
1103 pvCTS = NULL;
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));
1112 pvRTS = NULL;
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);
1118 }
1119 } else {
1120 // Auto Fall Back
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);
1125 pvCTS = NULL;
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));
1133 pvRTS = NULL;
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);
1139 }
1140 } // Auto Fall Back
1141 } else {//802.11a/b packet
1142
1143 if (byFBOption == AUTO_FB_NONE) {
1144 if (bRTS == true) {
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);
1148 pvCTS = NULL;
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));
1156 pvRTS = NULL;
1157 pvCTS = NULL;
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);
1161 }
1162 } else {
1163 // Auto Fall Back
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);
1168 pvCTS = NULL;
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));
1176 pvRTS = NULL;
1177 pvCTS = NULL;
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);
1181 }
1182 } // Auto Fall Back
1183 }
1184
1185 td_info->mic_hdr = pMICHDR;
1186
1187 memset((void *)(pbyTxBufferAddr + wTxBufSize), 0, (cbHeaderLength - wTxBufSize));
1188
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);
1192 /* Fill DataHead */
1193 uDuration = s_uFillDataHead(pDevice, byPktType, pvTxDataHd, cbFrameSize, uDMAIdx, bNeedACK,
1194 0, 0, uMACfragNum, byFBOption, pDevice->wCurrentRate, is_pspoll);
1195
1196 hdr->duration_id = uDuration;
1197
1198 cbReqCount = cbHeaderLength + uPadding + skb->len;
1199 pbyBuffer = (unsigned char *)pHeadTD->pTDInfo->buf;
1200 uLength = cbHeaderLength + uPadding;
1201
1202 /* Copy the Packet into a tx Buffer */
1203 memcpy((pbyBuffer + uLength), skb->data, skb->len);
1204
1205 ptdCurr = (PSTxDesc)pHeadTD;
1206
1207 ptdCurr->pTDInfo->dwReqCount = cbReqCount;
1208 ptdCurr->pTDInfo->dwHeaderLength = cbHeaderLength;
1209 ptdCurr->pTDInfo->skb_dma = ptdCurr->pTDInfo->buf_dma;
1210
1211 return cbHeaderLength;
1212 }
1213
1214 static void vnt_fill_txkey(struct ieee80211_hdr *hdr, u8 *key_buffer,
1215 struct ieee80211_key_conf *tx_key,
1216 struct sk_buff *skb, u16 payload_len,
1217 struct vnt_mic_hdr *mic_hdr)
1218 {
1219 struct ieee80211_key_seq seq;
1220 u8 *iv = ((u8 *)hdr + ieee80211_get_hdrlen_from_skb(skb));
1221
1222 /* strip header and icv len from payload */
1223 payload_len -= ieee80211_get_hdrlen_from_skb(skb);
1224 payload_len -= tx_key->icv_len;
1225
1226 switch (tx_key->cipher) {
1227 case WLAN_CIPHER_SUITE_WEP40:
1228 case WLAN_CIPHER_SUITE_WEP104:
1229 memcpy(key_buffer, iv, 3);
1230 memcpy(key_buffer + 3, tx_key->key, tx_key->keylen);
1231
1232 if (tx_key->keylen == WLAN_KEY_LEN_WEP40) {
1233 memcpy(key_buffer + 8, iv, 3);
1234 memcpy(key_buffer + 11,
1235 tx_key->key, WLAN_KEY_LEN_WEP40);
1236 }
1237
1238 break;
1239 case WLAN_CIPHER_SUITE_TKIP:
1240 ieee80211_get_tkip_p2k(tx_key, skb, key_buffer);
1241
1242 break;
1243 case WLAN_CIPHER_SUITE_CCMP:
1244
1245 if (!mic_hdr)
1246 return;
1247
1248 mic_hdr->id = 0x59;
1249 mic_hdr->payload_len = cpu_to_be16(payload_len);
1250 ether_addr_copy(mic_hdr->mic_addr2, hdr->addr2);
1251
1252 ieee80211_get_key_tx_seq(tx_key, &seq);
1253
1254 memcpy(mic_hdr->ccmp_pn, seq.ccmp.pn, IEEE80211_CCMP_PN_LEN);
1255
1256 if (ieee80211_has_a4(hdr->frame_control))
1257 mic_hdr->hlen = cpu_to_be16(28);
1258 else
1259 mic_hdr->hlen = cpu_to_be16(22);
1260
1261 ether_addr_copy(mic_hdr->addr1, hdr->addr1);
1262 ether_addr_copy(mic_hdr->addr2, hdr->addr2);
1263 ether_addr_copy(mic_hdr->addr3, hdr->addr3);
1264
1265 mic_hdr->frame_control = cpu_to_le16(
1266 le16_to_cpu(hdr->frame_control) & 0xc78f);
1267 mic_hdr->seq_ctrl = cpu_to_le16(
1268 le16_to_cpu(hdr->seq_ctrl) & 0xf);
1269
1270 if (ieee80211_has_a4(hdr->frame_control))
1271 ether_addr_copy(mic_hdr->addr4, hdr->addr4);
1272
1273 memcpy(key_buffer, tx_key->key, WLAN_KEY_LEN_CCMP);
1274
1275 break;
1276 default:
1277 break;
1278 }
1279 }
1280
1281 int vnt_generate_fifo_header(struct vnt_private *priv, u32 dma_idx,
1282 PSTxDesc head_td, struct sk_buff *skb)
1283 {
1284 PDEVICE_TD_INFO td_info = head_td->pTDInfo;
1285 struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
1286 struct ieee80211_tx_rate *tx_rate = &info->control.rates[0];
1287 struct ieee80211_rate *rate;
1288 struct ieee80211_key_conf *tx_key;
1289 struct ieee80211_hdr *hdr;
1290 struct vnt_tx_fifo_head *tx_buffer_head =
1291 (struct vnt_tx_fifo_head *)td_info->buf;
1292 u16 tx_body_size = skb->len, current_rate;
1293 u8 pkt_type;
1294 bool is_pspoll = false;
1295
1296 memset(tx_buffer_head, 0, sizeof(*tx_buffer_head));
1297
1298 hdr = (struct ieee80211_hdr *)(skb->data);
1299
1300 rate = ieee80211_get_tx_rate(priv->hw, info);
1301
1302 current_rate = rate->hw_value;
1303 if (priv->wCurrentRate != current_rate &&
1304 !(priv->hw->conf.flags & IEEE80211_CONF_OFFCHANNEL)) {
1305 priv->wCurrentRate = current_rate;
1306
1307 RFbSetPower(priv, priv->wCurrentRate,
1308 priv->hw->conf.chandef.chan->hw_value);
1309 }
1310
1311 if (current_rate > RATE_11M)
1312 pkt_type = (u8)priv->byPacketType;
1313 else
1314 pkt_type = PK_TYPE_11B;
1315
1316 /*Set fifo controls */
1317 if (pkt_type == PK_TYPE_11A)
1318 tx_buffer_head->fifo_ctl = 0;
1319 else if (pkt_type == PK_TYPE_11B)
1320 tx_buffer_head->fifo_ctl = cpu_to_le16(FIFOCTL_11B);
1321 else if (pkt_type == PK_TYPE_11GB)
1322 tx_buffer_head->fifo_ctl = cpu_to_le16(FIFOCTL_11GB);
1323 else if (pkt_type == PK_TYPE_11GA)
1324 tx_buffer_head->fifo_ctl = cpu_to_le16(FIFOCTL_11GA);
1325
1326 /* generate interrupt */
1327 tx_buffer_head->fifo_ctl |= cpu_to_le16(FIFOCTL_GENINT);
1328
1329 if (!ieee80211_is_data(hdr->frame_control)) {
1330 tx_buffer_head->fifo_ctl |= cpu_to_le16(FIFOCTL_TMOEN);
1331 tx_buffer_head->fifo_ctl |= cpu_to_le16(FIFOCTL_ISDMA0);
1332 tx_buffer_head->time_stamp =
1333 cpu_to_le16(DEFAULT_MGN_LIFETIME_RES_64us);
1334 } else {
1335 tx_buffer_head->time_stamp =
1336 cpu_to_le16(DEFAULT_MSDU_LIFETIME_RES_64us);
1337 }
1338
1339 if (!(info->flags & IEEE80211_TX_CTL_NO_ACK))
1340 tx_buffer_head->fifo_ctl |= cpu_to_le16(FIFOCTL_NEEDACK);
1341
1342 if (ieee80211_has_retry(hdr->frame_control))
1343 tx_buffer_head->fifo_ctl |= cpu_to_le16(FIFOCTL_LRETRY);
1344
1345 if (tx_rate->flags & IEEE80211_TX_RC_USE_SHORT_PREAMBLE)
1346 priv->byPreambleType = PREAMBLE_SHORT;
1347 else
1348 priv->byPreambleType = PREAMBLE_LONG;
1349
1350 if (tx_rate->flags & IEEE80211_TX_RC_USE_RTS_CTS)
1351 tx_buffer_head->fifo_ctl |= cpu_to_le16(FIFOCTL_RTS);
1352
1353 if (ieee80211_has_a4(hdr->frame_control)) {
1354 tx_buffer_head->fifo_ctl |= cpu_to_le16(FIFOCTL_LHEAD);
1355 priv->bLongHeader = true;
1356 }
1357
1358 if (info->flags & IEEE80211_TX_CTL_NO_PS_BUFFER)
1359 is_pspoll = true;
1360
1361 tx_buffer_head->frag_ctl =
1362 cpu_to_le16(ieee80211_get_hdrlen_from_skb(skb) << 10);
1363
1364 if (info->control.hw_key) {
1365 tx_key = info->control.hw_key;
1366
1367 switch (info->control.hw_key->cipher) {
1368 case WLAN_CIPHER_SUITE_WEP40:
1369 case WLAN_CIPHER_SUITE_WEP104:
1370 tx_buffer_head->frag_ctl |= cpu_to_le16(FRAGCTL_LEGACY);
1371 break;
1372 case WLAN_CIPHER_SUITE_TKIP:
1373 tx_buffer_head->frag_ctl |= cpu_to_le16(FRAGCTL_TKIP);
1374 break;
1375 case WLAN_CIPHER_SUITE_CCMP:
1376 tx_buffer_head->frag_ctl |= cpu_to_le16(FRAGCTL_AES);
1377 default:
1378 break;
1379 }
1380 }
1381
1382 tx_buffer_head->current_rate = cpu_to_le16(current_rate);
1383
1384 /* legacy rates TODO use ieee80211_tx_rate */
1385 if (current_rate >= RATE_18M && ieee80211_is_data(hdr->frame_control)) {
1386 if (priv->byAutoFBCtrl == AUTO_FB_0)
1387 tx_buffer_head->fifo_ctl |=
1388 cpu_to_le16(FIFOCTL_AUTO_FB_0);
1389 else if (priv->byAutoFBCtrl == AUTO_FB_1)
1390 tx_buffer_head->fifo_ctl |=
1391 cpu_to_le16(FIFOCTL_AUTO_FB_1);
1392
1393 }
1394
1395 tx_buffer_head->frag_ctl |= cpu_to_le16(FRAGCTL_NONFRAG);
1396
1397 s_cbFillTxBufHead(priv, pkt_type, (u8 *)tx_buffer_head,
1398 dma_idx, head_td, is_pspoll);
1399
1400 if (info->control.hw_key) {
1401 tx_key = info->control.hw_key;
1402 if (tx_key->keylen > 0)
1403 vnt_fill_txkey(hdr, tx_buffer_head->tx_key,
1404 tx_key, skb, tx_body_size, td_info->mic_hdr);
1405 }
1406
1407 return 0;
1408 }
1409
1410 static int vnt_beacon_xmit(struct vnt_private *priv,
1411 struct sk_buff *skb)
1412 {
1413 struct vnt_tx_short_buf_head *short_head =
1414 (struct vnt_tx_short_buf_head *)priv->tx_beacon_bufs;
1415 struct ieee80211_mgmt *mgmt_hdr = (struct ieee80211_mgmt *)
1416 (priv->tx_beacon_bufs + sizeof(*short_head));
1417 struct ieee80211_tx_info *info;
1418 u32 frame_size = skb->len + 4;
1419 u16 current_rate;
1420
1421 memset(priv->tx_beacon_bufs, 0, sizeof(*short_head));
1422
1423 if (priv->byBBType == BB_TYPE_11A) {
1424 current_rate = RATE_6M;
1425
1426 /* Get SignalField,ServiceField,Length */
1427 vnt_get_phy_field(priv, frame_size, current_rate,
1428 PK_TYPE_11A, &short_head->ab);
1429
1430 /* Get Duration and TimeStampOff */
1431 short_head->duration =
1432 cpu_to_le16((u16)s_uGetDataDuration(priv, DATADUR_B,
1433 frame_size, PK_TYPE_11A, current_rate,
1434 false, 0, 0, 1, AUTO_FB_NONE));
1435
1436 short_head->time_stamp_off =
1437 vnt_time_stamp_off(priv, current_rate);
1438 } else {
1439 current_rate = RATE_1M;
1440 short_head->fifo_ctl |= cpu_to_le16(FIFOCTL_11B);
1441
1442 /* Get SignalField,ServiceField,Length */
1443 vnt_get_phy_field(priv, frame_size, current_rate,
1444 PK_TYPE_11B, &short_head->ab);
1445
1446 /* Get Duration and TimeStampOff */
1447 short_head->duration =
1448 cpu_to_le16((u16)s_uGetDataDuration(priv, DATADUR_B,
1449 frame_size, PK_TYPE_11B, current_rate,
1450 false, 0, 0, 1, AUTO_FB_NONE));
1451
1452 short_head->time_stamp_off =
1453 vnt_time_stamp_off(priv, current_rate);
1454 }
1455
1456 short_head->fifo_ctl |= cpu_to_le16(FIFOCTL_GENINT);
1457
1458 /* Copy Beacon */
1459 memcpy(mgmt_hdr, skb->data, skb->len);
1460
1461 /* time stamp always 0 */
1462 mgmt_hdr->u.beacon.timestamp = 0;
1463
1464 info = IEEE80211_SKB_CB(skb);
1465 if (info->flags & IEEE80211_TX_CTL_ASSIGN_SEQ) {
1466 struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)mgmt_hdr;
1467
1468 hdr->duration_id = 0;
1469 hdr->seq_ctrl = cpu_to_le16(priv->wSeqCounter << 4);
1470 }
1471
1472 priv->wSeqCounter++;
1473 if (priv->wSeqCounter > 0x0fff)
1474 priv->wSeqCounter = 0;
1475
1476 priv->wBCNBufLen = sizeof(*short_head) + skb->len;
1477
1478 MACvSetCurrBCNTxDescAddr(priv->PortOffset, priv->tx_beacon_dma);
1479
1480 MACvSetCurrBCNLength(priv->PortOffset, priv->wBCNBufLen);
1481 /* Set auto Transmit on */
1482 MACvRegBitsOn(priv->PortOffset, MAC_REG_TCR, TCR_AUTOBCNTX);
1483 /* Poll Transmit the adapter */
1484 MACvTransmitBCN(priv->PortOffset);
1485
1486 return 0;
1487 }
1488
1489 int vnt_beacon_make(struct vnt_private *priv, struct ieee80211_vif *vif)
1490 {
1491 struct sk_buff *beacon;
1492
1493 beacon = ieee80211_beacon_get(priv->hw, vif);
1494 if (!beacon)
1495 return -ENOMEM;
1496
1497 if (vnt_beacon_xmit(priv, beacon)) {
1498 ieee80211_free_txskb(priv->hw, beacon);
1499 return -ENODEV;
1500 }
1501
1502 return 0;
1503 }
1504
1505 int vnt_beacon_enable(struct vnt_private *priv, struct ieee80211_vif *vif,
1506 struct ieee80211_bss_conf *conf)
1507 {
1508 int ret;
1509
1510 VNSvOutPortB(priv->PortOffset + MAC_REG_TFTCTL, TFTCTL_TSFCNTRST);
1511
1512 VNSvOutPortB(priv->PortOffset + MAC_REG_TFTCTL, TFTCTL_TSFCNTREN);
1513
1514 CARDvSetFirstNextTBTT(priv, conf->beacon_int);
1515
1516 CARDbSetBeaconPeriod(priv, conf->beacon_int);
1517
1518 ret = vnt_beacon_make(priv, vif);
1519
1520 return ret;
1521 }
Linux kernel - Deliverables
This page took 0.06289 seconds and 6 git commands to generate.