1 // SPDX-License-Identifier: GPL-2.0+
2 /*
3 * Copyright (c) 1996, 2003 VIA Networking Technologies, Inc.
4 * All rights reserved.
5 *
6 * Purpose: handle WMAC/802.3/802.11 rx & tx functions
7 *
8 * Author: Lyndon Chen
9 *
10 * Date: May 20, 2003
11 *
12 * Functions:
13 * s_vGenerateTxParameter - Generate tx dma required parameter.
14 * vGenerateMACHeader - Translate 802.3 to 802.11 header
15 * cbGetFragCount - Calculate fragment number count
16 * csBeacon_xmit - beacon tx function
17 * csMgmt_xmit - management tx function
18 * s_cbFillTxBufHead - fulfill tx dma buffer header
19 * s_uGetDataDuration - get tx data required duration
20 * s_uFillDataHead- fulfill tx data duration header
21 * s_uGetRTSCTSDuration- get rtx/cts required duration
22 * get_rtscts_time- get rts/cts reserved time
23 * s_uGetTxRsvTime- get frame reserved time
24 * s_vFillCTSHead- fulfill CTS ctl header
25 * s_vFillFragParameter- Set fragment ctl parameter.
26 * s_vFillRTSHead- fulfill RTS ctl header
27 * s_vFillTxKey- fulfill tx encrypt key
28 * s_vSWencryption- Software encrypt header
29 * vDMA0_tx_80211- tx 802.11 frame via dma0
30 * vGenerateFIFOHeader- Generate tx FIFO ctl header
31 *
32 * Revision History:
33 *
34 */
35
36 #include "device.h"
37 #include "rxtx.h"
38 #include "card.h"
39 #include "mac.h"
40 #include "baseband.h"
41 #include "rf.h"
42
43 /*--------------------- Static Definitions -------------------------*/
44
45 /*--------------------- Static Classes ----------------------------*/
46
47 /*--------------------- Static Variables --------------------------*/
48
49 /*--------------------- Static Functions --------------------------*/
50
51 /*--------------------- Static Definitions -------------------------*/
52 /* if packet size < 256 -> in-direct send
53 * vpacket size >= 256 -> direct send
54 */
55 #define CRITICAL_PACKET_LEN 256
56
57 static const unsigned short time_stamp_off[2][MAX_RATE] = {
58 {384, 288, 226, 209, 54, 43, 37, 31, 28, 25, 24, 23}, /* Long Preamble */
59 {384, 192, 130, 113, 54, 43, 37, 31, 28, 25, 24, 23}, /* Short Preamble */
60 };
61
62 static const unsigned short fb_opt0[2][5] = {
63 {RATE_12M, RATE_18M, RATE_24M, RATE_36M, RATE_48M}, /* fallback_rate0 */
64 {RATE_12M, RATE_12M, RATE_18M, RATE_24M, RATE_36M}, /* fallback_rate1 */
65 };
66
67 static const unsigned short fb_opt1[2][5] = {
68 {RATE_12M, RATE_18M, RATE_24M, RATE_24M, RATE_36M}, /* fallback_rate0 */
69 {RATE_6M, RATE_6M, RATE_12M, RATE_12M, RATE_18M}, /* fallback_rate1 */
70 };
71
72 #define RTSDUR_BB 0
73 #define RTSDUR_BA 1
74 #define RTSDUR_AA 2
75 #define CTSDUR_BA 3
76 #define RTSDUR_BA_F0 4
77 #define RTSDUR_AA_F0 5
78 #define RTSDUR_BA_F1 6
79 #define RTSDUR_AA_F1 7
80 #define CTSDUR_BA_F0 8
81 #define CTSDUR_BA_F1 9
82 #define DATADUR_B 10
83 #define DATADUR_A 11
84 #define DATADUR_A_F0 12
85 #define DATADUR_A_F1 13
86
87 /*--------------------- Static Functions --------------------------*/
88 static
89 void
90 s_vFillRTSHead(
91 struct vnt_private *pDevice,
92 unsigned char byPktType,
93 void *pvRTS,
94 unsigned int cbFrameLength,
95 bool bNeedAck,
96 bool bDisCRC,
97 struct ieee80211_hdr *hdr,
98 unsigned short wCurrentRate,
99 unsigned char byFBOption
100 );
101
102 static
103 void
104 s_vGenerateTxParameter(
105 struct vnt_private *pDevice,
106 unsigned char byPktType,
107 struct vnt_tx_fifo_head *,
108 void *pvRrvTime,
109 void *pvRTS,
110 void *pvCTS,
111 unsigned int cbFrameSize,
112 bool bNeedACK,
113 unsigned int uDMAIdx,
114 void *psEthHeader,
115 unsigned short wCurrentRate
116 );
117
118 static unsigned int
119 s_cbFillTxBufHead(struct vnt_private *pDevice, unsigned char byPktType,
120 unsigned char *pbyTxBufferAddr,
121 unsigned int uDMAIdx, struct vnt_tx_desc *pHeadTD,
122 unsigned int uNodeIndex);
123
124 static
125 __le16
126 s_uFillDataHead(
127 struct vnt_private *pDevice,
128 unsigned char byPktType,
129 void *pTxDataHead,
130 unsigned int cbFrameLength,
131 unsigned int uDMAIdx,
132 bool bNeedAck,
133 unsigned int uFragIdx,
134 unsigned int cbLastFragmentSize,
135 unsigned int uMACfragNum,
136 unsigned char byFBOption,
137 unsigned short wCurrentRate,
138 bool is_pspoll
139 );
140
141 /*--------------------- Export Variables --------------------------*/
142
vnt_time_stamp_off(struct vnt_private * priv,u16 rate)143 static __le16 vnt_time_stamp_off(struct vnt_private *priv, u16 rate)
144 {
145 return cpu_to_le16(time_stamp_off[priv->preamble_type % 2]
146 [rate % MAX_RATE]);
147 }
148
149 /* byPktType : PK_TYPE_11A 0
150 * PK_TYPE_11B 1
151 * PK_TYPE_11GB 2
152 * PK_TYPE_11GA 3
153 */
154 static
155 unsigned int
s_uGetTxRsvTime(struct vnt_private * pDevice,unsigned char byPktType,unsigned int cbFrameLength,unsigned short wRate,bool bNeedAck)156 s_uGetTxRsvTime(
157 struct vnt_private *pDevice,
158 unsigned char byPktType,
159 unsigned int cbFrameLength,
160 unsigned short wRate,
161 bool bNeedAck
162 )
163 {
164 unsigned int uDataTime, uAckTime;
165
166 uDataTime = bb_get_frame_time(pDevice->preamble_type, byPktType, cbFrameLength, wRate);
167
168 if (!bNeedAck)
169 return uDataTime;
170
171 /*
172 * CCK mode - 11b
173 * OFDM mode - 11g 2.4G & 11a 5G
174 */
175 uAckTime = bb_get_frame_time(pDevice->preamble_type, byPktType, 14,
176 byPktType == PK_TYPE_11B ?
177 pDevice->byTopCCKBasicRate :
178 pDevice->byTopOFDMBasicRate);
179
180 return uDataTime + pDevice->uSIFS + uAckTime;
181 }
182
vnt_rxtx_rsvtime_le16(struct vnt_private * priv,u8 pkt_type,u32 frame_length,u16 rate,bool need_ack)183 static __le16 vnt_rxtx_rsvtime_le16(struct vnt_private *priv, u8 pkt_type,
184 u32 frame_length, u16 rate, bool need_ack)
185 {
186 return cpu_to_le16((u16)s_uGetTxRsvTime(priv, pkt_type,
187 frame_length, rate, need_ack));
188 }
189
190 /* byFreqType: 0=>5GHZ 1=>2.4GHZ */
get_rtscts_time(struct vnt_private * priv,unsigned char rts_rsvtype,unsigned char pkt_type,unsigned int frame_length,unsigned short current_rate)191 static __le16 get_rtscts_time(struct vnt_private *priv,
192 unsigned char rts_rsvtype,
193 unsigned char pkt_type,
194 unsigned int frame_length,
195 unsigned short current_rate)
196 {
197 unsigned int rrv_time = 0;
198 unsigned int rts_time = 0;
199 unsigned int cts_time = 0;
200 unsigned int ack_time = 0;
201 unsigned int data_time = 0;
202
203 data_time = bb_get_frame_time(priv->preamble_type, pkt_type, frame_length, current_rate);
204 if (rts_rsvtype == 0) { /* RTSTxRrvTime_bb */
205 rts_time = bb_get_frame_time(priv->preamble_type, pkt_type, 20, priv->byTopCCKBasicRate);
206 ack_time = bb_get_frame_time(priv->preamble_type, pkt_type, 14, priv->byTopCCKBasicRate);
207 cts_time = ack_time;
208 } else if (rts_rsvtype == 1) { /* RTSTxRrvTime_ba, only in 2.4GHZ */
209 rts_time = bb_get_frame_time(priv->preamble_type, pkt_type, 20, priv->byTopCCKBasicRate);
210 cts_time = bb_get_frame_time(priv->preamble_type, pkt_type, 14, priv->byTopCCKBasicRate);
211 ack_time = bb_get_frame_time(priv->preamble_type, pkt_type, 14, priv->byTopOFDMBasicRate);
212 } else if (rts_rsvtype == 2) { /* RTSTxRrvTime_aa */
213 rts_time = bb_get_frame_time(priv->preamble_type, pkt_type, 20, priv->byTopOFDMBasicRate);
214 ack_time = bb_get_frame_time(priv->preamble_type, pkt_type, 14, priv->byTopOFDMBasicRate);
215 cts_time = ack_time;
216 } else if (rts_rsvtype == 3) { /* CTSTxRrvTime_ba, only in 2.4GHZ */
217 cts_time = bb_get_frame_time(priv->preamble_type, pkt_type, 14, priv->byTopCCKBasicRate);
218 ack_time = bb_get_frame_time(priv->preamble_type, pkt_type, 14, priv->byTopOFDMBasicRate);
219 rrv_time = cts_time + ack_time + data_time + 2 * priv->uSIFS;
220 return cpu_to_le16((u16)rrv_time);
221 }
222
223 /* RTSRrvTime */
224 rrv_time = rts_time + cts_time + ack_time + data_time + 3 * priv->uSIFS;
225 return cpu_to_le16((u16)rrv_time);
226 }
227
228 /* byFreqType 0: 5GHz, 1:2.4Ghz */
229 static
230 unsigned int
s_uGetDataDuration(struct vnt_private * pDevice,unsigned char byDurType,unsigned int cbFrameLength,unsigned char byPktType,unsigned short wRate,bool bNeedAck,unsigned int uFragIdx,unsigned int cbLastFragmentSize,unsigned int uMACfragNum,unsigned char byFBOption)231 s_uGetDataDuration(
232 struct vnt_private *pDevice,
233 unsigned char byDurType,
234 unsigned int cbFrameLength,
235 unsigned char byPktType,
236 unsigned short wRate,
237 bool bNeedAck,
238 unsigned int uFragIdx,
239 unsigned int cbLastFragmentSize,
240 unsigned int uMACfragNum,
241 unsigned char byFBOption
242 )
243 {
244 bool bLastFrag = false;
245 unsigned int uAckTime = 0, uNextPktTime = 0, len;
246
247 if (uFragIdx == (uMACfragNum - 1))
248 bLastFrag = true;
249
250 if (uFragIdx == (uMACfragNum - 2))
251 len = cbLastFragmentSize;
252 else
253 len = cbFrameLength;
254
255 switch (byDurType) {
256 case DATADUR_B: /* DATADUR_B */
257 if (bNeedAck) {
258 uAckTime = bb_get_frame_time(pDevice->preamble_type,
259 byPktType, 14,
260 pDevice->byTopCCKBasicRate);
261 }
262 /* Non Frag or Last Frag */
263 if ((uMACfragNum == 1) || bLastFrag) {
264 if (!bNeedAck)
265 return 0;
266 } else {
267 /* First Frag or Mid Frag */
268 uNextPktTime = s_uGetTxRsvTime(pDevice, byPktType,
269 len, wRate, bNeedAck);
270 }
271
272 return pDevice->uSIFS + uAckTime + uNextPktTime;
273
274 case DATADUR_A: /* DATADUR_A */
275 if (bNeedAck) {
276 uAckTime = bb_get_frame_time(pDevice->preamble_type,
277 byPktType, 14,
278 pDevice->byTopOFDMBasicRate);
279 }
280 /* Non Frag or Last Frag */
281 if ((uMACfragNum == 1) || bLastFrag) {
282 if (!bNeedAck)
283 return 0;
284 } else {
285 /* First Frag or Mid Frag */
286 uNextPktTime = s_uGetTxRsvTime(pDevice, byPktType,
287 len, wRate, bNeedAck);
288 }
289
290 return pDevice->uSIFS + uAckTime + uNextPktTime;
291
292 case DATADUR_A_F0: /* DATADUR_A_F0 */
293 case DATADUR_A_F1: /* DATADUR_A_F1 */
294 if (bNeedAck) {
295 uAckTime = bb_get_frame_time(pDevice->preamble_type,
296 byPktType, 14,
297 pDevice->byTopOFDMBasicRate);
298 }
299 /* Non Frag or Last Frag */
300 if ((uMACfragNum == 1) || bLastFrag) {
301 if (!bNeedAck)
302 return 0;
303 } else {
304 /* First Frag or Mid Frag */
305 if (wRate < RATE_18M)
306 wRate = RATE_18M;
307 else if (wRate > RATE_54M)
308 wRate = RATE_54M;
309
310 wRate -= RATE_18M;
311
312 if (byFBOption == AUTO_FB_0)
313 wRate = fb_opt0[FB_RATE0][wRate];
314 else
315 wRate = fb_opt1[FB_RATE0][wRate];
316
317 uNextPktTime = s_uGetTxRsvTime(pDevice, byPktType,
318 len, wRate, bNeedAck);
319 }
320
321 return pDevice->uSIFS + uAckTime + uNextPktTime;
322
323 default:
324 break;
325 }
326
327 return 0;
328 }
329
330 /* byFreqType: 0=>5GHZ 1=>2.4GHZ */
331 static
332 __le16
s_uGetRTSCTSDuration(struct vnt_private * pDevice,unsigned char byDurType,unsigned int cbFrameLength,unsigned char byPktType,unsigned short wRate,bool bNeedAck,unsigned char byFBOption)333 s_uGetRTSCTSDuration(
334 struct vnt_private *pDevice,
335 unsigned char byDurType,
336 unsigned int cbFrameLength,
337 unsigned char byPktType,
338 unsigned short wRate,
339 bool bNeedAck,
340 unsigned char byFBOption
341 )
342 {
343 unsigned int uCTSTime = 0, uDurTime = 0;
344
345 switch (byDurType) {
346 case RTSDUR_BB: /* RTSDuration_bb */
347 uCTSTime = bb_get_frame_time(pDevice->preamble_type, byPktType, 14, pDevice->byTopCCKBasicRate);
348 uDurTime = uCTSTime + 2 * pDevice->uSIFS + s_uGetTxRsvTime(pDevice, byPktType, cbFrameLength, wRate, bNeedAck);
349 break;
350
351 case RTSDUR_BA: /* RTSDuration_ba */
352 uCTSTime = bb_get_frame_time(pDevice->preamble_type, byPktType, 14, pDevice->byTopCCKBasicRate);
353 uDurTime = uCTSTime + 2 * pDevice->uSIFS + s_uGetTxRsvTime(pDevice, byPktType, cbFrameLength, wRate, bNeedAck);
354 break;
355
356 case RTSDUR_AA: /* RTSDuration_aa */
357 uCTSTime = bb_get_frame_time(pDevice->preamble_type, byPktType, 14, pDevice->byTopOFDMBasicRate);
358 uDurTime = uCTSTime + 2 * pDevice->uSIFS + s_uGetTxRsvTime(pDevice, byPktType, cbFrameLength, wRate, bNeedAck);
359 break;
360
361 case CTSDUR_BA: /* CTSDuration_ba */
362 uDurTime = pDevice->uSIFS + s_uGetTxRsvTime(pDevice, byPktType, cbFrameLength, wRate, bNeedAck);
363 break;
364
365 case RTSDUR_BA_F0: /* RTSDuration_ba_f0 */
366 uCTSTime = bb_get_frame_time(pDevice->preamble_type, byPktType, 14, pDevice->byTopCCKBasicRate);
367 if ((byFBOption == AUTO_FB_0) && (wRate >= RATE_18M) && (wRate <= RATE_54M))
368 uDurTime = uCTSTime + 2 * pDevice->uSIFS + s_uGetTxRsvTime(pDevice, byPktType, cbFrameLength, fb_opt0[FB_RATE0][wRate - RATE_18M], bNeedAck);
369 else if ((byFBOption == AUTO_FB_1) && (wRate >= RATE_18M) && (wRate <= RATE_54M))
370 uDurTime = uCTSTime + 2 * pDevice->uSIFS + s_uGetTxRsvTime(pDevice, byPktType, cbFrameLength, fb_opt1[FB_RATE0][wRate - RATE_18M], bNeedAck);
371
372 break;
373
374 case RTSDUR_AA_F0: /* RTSDuration_aa_f0 */
375 uCTSTime = bb_get_frame_time(pDevice->preamble_type, byPktType, 14, pDevice->byTopOFDMBasicRate);
376 if ((byFBOption == AUTO_FB_0) && (wRate >= RATE_18M) && (wRate <= RATE_54M))
377 uDurTime = uCTSTime + 2 * pDevice->uSIFS + s_uGetTxRsvTime(pDevice, byPktType, cbFrameLength, fb_opt0[FB_RATE0][wRate - RATE_18M], bNeedAck);
378 else if ((byFBOption == AUTO_FB_1) && (wRate >= RATE_18M) && (wRate <= RATE_54M))
379 uDurTime = uCTSTime + 2 * pDevice->uSIFS + s_uGetTxRsvTime(pDevice, byPktType, cbFrameLength, fb_opt1[FB_RATE0][wRate - RATE_18M], bNeedAck);
380
381 break;
382
383 case RTSDUR_BA_F1: /* RTSDuration_ba_f1 */
384 uCTSTime = bb_get_frame_time(pDevice->preamble_type, byPktType, 14, pDevice->byTopCCKBasicRate);
385 if ((byFBOption == AUTO_FB_0) && (wRate >= RATE_18M) && (wRate <= RATE_54M))
386 uDurTime = uCTSTime + 2 * pDevice->uSIFS + s_uGetTxRsvTime(pDevice, byPktType, cbFrameLength, fb_opt0[FB_RATE1][wRate - RATE_18M], bNeedAck);
387 else if ((byFBOption == AUTO_FB_1) && (wRate >= RATE_18M) && (wRate <= RATE_54M))
388 uDurTime = uCTSTime + 2 * pDevice->uSIFS + s_uGetTxRsvTime(pDevice, byPktType, cbFrameLength, fb_opt1[FB_RATE1][wRate - RATE_18M], bNeedAck);
389
390 break;
391
392 case RTSDUR_AA_F1: /* RTSDuration_aa_f1 */
393 uCTSTime = bb_get_frame_time(pDevice->preamble_type, byPktType, 14, pDevice->byTopOFDMBasicRate);
394 if ((byFBOption == AUTO_FB_0) && (wRate >= RATE_18M) && (wRate <= RATE_54M))
395 uDurTime = uCTSTime + 2 * pDevice->uSIFS + s_uGetTxRsvTime(pDevice, byPktType, cbFrameLength, fb_opt0[FB_RATE1][wRate - RATE_18M], bNeedAck);
396 else if ((byFBOption == AUTO_FB_1) && (wRate >= RATE_18M) && (wRate <= RATE_54M))
397 uDurTime = uCTSTime + 2 * pDevice->uSIFS + s_uGetTxRsvTime(pDevice, byPktType, cbFrameLength, fb_opt1[FB_RATE1][wRate - RATE_18M], bNeedAck);
398
399 break;
400
401 case CTSDUR_BA_F0: /* CTSDuration_ba_f0 */
402 if ((byFBOption == AUTO_FB_0) && (wRate >= RATE_18M) && (wRate <= RATE_54M))
403 uDurTime = pDevice->uSIFS + s_uGetTxRsvTime(pDevice, byPktType, cbFrameLength, fb_opt0[FB_RATE0][wRate - RATE_18M], bNeedAck);
404 else if ((byFBOption == AUTO_FB_1) && (wRate >= RATE_18M) && (wRate <= RATE_54M))
405 uDurTime = pDevice->uSIFS + s_uGetTxRsvTime(pDevice, byPktType, cbFrameLength, fb_opt1[FB_RATE0][wRate - RATE_18M], bNeedAck);
406
407 break;
408
409 case CTSDUR_BA_F1: /* CTSDuration_ba_f1 */
410 if ((byFBOption == AUTO_FB_0) && (wRate >= RATE_18M) && (wRate <= RATE_54M))
411 uDurTime = pDevice->uSIFS + s_uGetTxRsvTime(pDevice, byPktType, cbFrameLength, fb_opt0[FB_RATE1][wRate - RATE_18M], bNeedAck);
412 else if ((byFBOption == AUTO_FB_1) && (wRate >= RATE_18M) && (wRate <= RATE_54M))
413 uDurTime = pDevice->uSIFS + s_uGetTxRsvTime(pDevice, byPktType, cbFrameLength, fb_opt1[FB_RATE1][wRate - RATE_18M], bNeedAck);
414
415 break;
416
417 default:
418 break;
419 }
420
421 return cpu_to_le16((u16)uDurTime);
422 }
423
424 static
425 __le16
s_uFillDataHead(struct vnt_private * pDevice,unsigned char byPktType,void * pTxDataHead,unsigned int cbFrameLength,unsigned int uDMAIdx,bool bNeedAck,unsigned int uFragIdx,unsigned int cbLastFragmentSize,unsigned int uMACfragNum,unsigned char byFBOption,unsigned short wCurrentRate,bool is_pspoll)426 s_uFillDataHead(
427 struct vnt_private *pDevice,
428 unsigned char byPktType,
429 void *pTxDataHead,
430 unsigned int cbFrameLength,
431 unsigned int uDMAIdx,
432 bool bNeedAck,
433 unsigned int uFragIdx,
434 unsigned int cbLastFragmentSize,
435 unsigned int uMACfragNum,
436 unsigned char byFBOption,
437 unsigned short wCurrentRate,
438 bool is_pspoll
439 )
440 {
441 struct vnt_tx_datahead_ab *buf = pTxDataHead;
442
443 if (!pTxDataHead)
444 return 0;
445
446 if (byPktType == PK_TYPE_11GB || byPktType == PK_TYPE_11GA) {
447 /* Auto Fallback */
448 struct vnt_tx_datahead_g_fb *buf = pTxDataHead;
449
450 if (byFBOption == AUTO_FB_NONE) {
451 struct vnt_tx_datahead_g *buf = pTxDataHead;
452 /* Get SignalField, ServiceField & Length */
453 vnt_get_phy_field(pDevice, cbFrameLength, wCurrentRate,
454 byPktType, &buf->a);
455
456 vnt_get_phy_field(pDevice, cbFrameLength,
457 pDevice->byTopCCKBasicRate,
458 PK_TYPE_11B, &buf->b);
459
460 if (is_pspoll) {
461 __le16 dur = cpu_to_le16(pDevice->current_aid | BIT(14) | BIT(15));
462
463 buf->duration_a = dur;
464 buf->duration_b = dur;
465 } else {
466 /* Get Duration and TimeStamp */
467 buf->duration_a =
468 cpu_to_le16((u16)s_uGetDataDuration(pDevice, DATADUR_A, cbFrameLength,
469 byPktType, wCurrentRate, bNeedAck, uFragIdx,
470 cbLastFragmentSize, uMACfragNum,
471 byFBOption));
472 buf->duration_b =
473 cpu_to_le16((u16)s_uGetDataDuration(pDevice, DATADUR_B, cbFrameLength,
474 PK_TYPE_11B, pDevice->byTopCCKBasicRate,
475 bNeedAck, uFragIdx, cbLastFragmentSize,
476 uMACfragNum, byFBOption));
477 }
478
479 buf->time_stamp_off_a = vnt_time_stamp_off(pDevice, wCurrentRate);
480 buf->time_stamp_off_b = vnt_time_stamp_off(pDevice, pDevice->byTopCCKBasicRate);
481
482 return buf->duration_a;
483 }
484
485 /* Get SignalField, ServiceField & Length */
486 vnt_get_phy_field(pDevice, cbFrameLength, wCurrentRate,
487 byPktType, &buf->a);
488
489 vnt_get_phy_field(pDevice, cbFrameLength,
490 pDevice->byTopCCKBasicRate,
491 PK_TYPE_11B, &buf->b);
492 /* Get Duration and TimeStamp */
493 buf->duration_a = cpu_to_le16((u16)s_uGetDataDuration(pDevice, DATADUR_A, cbFrameLength, byPktType,
494 wCurrentRate, bNeedAck, uFragIdx, cbLastFragmentSize, uMACfragNum, byFBOption));
495 buf->duration_b = cpu_to_le16((u16)s_uGetDataDuration(pDevice, DATADUR_B, cbFrameLength, PK_TYPE_11B,
496 pDevice->byTopCCKBasicRate, bNeedAck, uFragIdx, cbLastFragmentSize, uMACfragNum, byFBOption));
497 buf->duration_a_f0 = cpu_to_le16((u16)s_uGetDataDuration(pDevice, DATADUR_A_F0, cbFrameLength, byPktType,
498 wCurrentRate, bNeedAck, uFragIdx, cbLastFragmentSize, uMACfragNum, byFBOption));
499 buf->duration_a_f1 = cpu_to_le16((u16)s_uGetDataDuration(pDevice, DATADUR_A_F1, cbFrameLength, byPktType,
500 wCurrentRate, bNeedAck, uFragIdx, cbLastFragmentSize, uMACfragNum, byFBOption));
501
502 buf->time_stamp_off_a = vnt_time_stamp_off(pDevice, wCurrentRate);
503 buf->time_stamp_off_b = vnt_time_stamp_off(pDevice, pDevice->byTopCCKBasicRate);
504
505 return buf->duration_a;
506 /* if (byFBOption == AUTO_FB_NONE) */
507 } else if (byPktType == PK_TYPE_11A) {
508 struct vnt_tx_datahead_ab *buf = pTxDataHead;
509
510 if (byFBOption != AUTO_FB_NONE) {
511 /* Auto Fallback */
512 struct vnt_tx_datahead_a_fb *buf = pTxDataHead;
513 /* Get SignalField, ServiceField & Length */
514 vnt_get_phy_field(pDevice, cbFrameLength, wCurrentRate,
515 byPktType, &buf->a);
516
517 /* Get Duration and TimeStampOff */
518 buf->duration = cpu_to_le16((u16)s_uGetDataDuration(pDevice, DATADUR_A, cbFrameLength, byPktType,
519 wCurrentRate, bNeedAck, uFragIdx, cbLastFragmentSize, uMACfragNum, byFBOption));
520 buf->duration_f0 = cpu_to_le16((u16)s_uGetDataDuration(pDevice, DATADUR_A_F0, cbFrameLength, byPktType,
521 wCurrentRate, bNeedAck, uFragIdx, cbLastFragmentSize, uMACfragNum, byFBOption));
522 buf->duration_f1 = cpu_to_le16((u16)s_uGetDataDuration(pDevice, DATADUR_A_F1, cbFrameLength, byPktType,
523 wCurrentRate, bNeedAck, uFragIdx, cbLastFragmentSize, uMACfragNum, byFBOption));
524 buf->time_stamp_off = vnt_time_stamp_off(pDevice, wCurrentRate);
525 return buf->duration;
526 }
527
528 /* Get SignalField, ServiceField & Length */
529 vnt_get_phy_field(pDevice, cbFrameLength, wCurrentRate,
530 byPktType, &buf->ab);
531
532 if (is_pspoll) {
533 __le16 dur = cpu_to_le16(pDevice->current_aid | BIT(14) | BIT(15));
534
535 buf->duration = dur;
536 } else {
537 /* Get Duration and TimeStampOff */
538 buf->duration =
539 cpu_to_le16((u16)s_uGetDataDuration(pDevice, DATADUR_A, cbFrameLength, byPktType,
540 wCurrentRate, bNeedAck, uFragIdx,
541 cbLastFragmentSize, uMACfragNum,
542 byFBOption));
543 }
544
545 buf->time_stamp_off = vnt_time_stamp_off(pDevice, wCurrentRate);
546 return buf->duration;
547 }
548
549 /* Get SignalField, ServiceField & Length */
550 vnt_get_phy_field(pDevice, cbFrameLength, wCurrentRate,
551 byPktType, &buf->ab);
552
553 if (is_pspoll) {
554 __le16 dur = cpu_to_le16(pDevice->current_aid | BIT(14) | BIT(15));
555
556 buf->duration = dur;
557 } else {
558 /* Get Duration and TimeStampOff */
559 buf->duration =
560 cpu_to_le16((u16)s_uGetDataDuration(pDevice, DATADUR_B, cbFrameLength, byPktType,
561 wCurrentRate, bNeedAck, uFragIdx,
562 cbLastFragmentSize, uMACfragNum,
563 byFBOption));
564 }
565
566 buf->time_stamp_off = vnt_time_stamp_off(pDevice, wCurrentRate);
567 return buf->duration;
568 }
569
570 static
571 void
s_vFillRTSHead(struct vnt_private * pDevice,unsigned char byPktType,void * pvRTS,unsigned int cbFrameLength,bool bNeedAck,bool bDisCRC,struct ieee80211_hdr * hdr,unsigned short wCurrentRate,unsigned char byFBOption)572 s_vFillRTSHead(
573 struct vnt_private *pDevice,
574 unsigned char byPktType,
575 void *pvRTS,
576 unsigned int cbFrameLength,
577 bool bNeedAck,
578 bool bDisCRC,
579 struct ieee80211_hdr *hdr,
580 unsigned short wCurrentRate,
581 unsigned char byFBOption
582 )
583 {
584 unsigned int uRTSFrameLen = 20;
585
586 if (!pvRTS)
587 return;
588
589 if (bDisCRC) {
590 /* When CRCDIS bit is on, H/W forgot to generate FCS for
591 * RTS frame, in this case we need to decrease its length by 4.
592 */
593 uRTSFrameLen -= 4;
594 }
595
596 /* Note: So far RTSHead doesn't appear in ATIM & Beacom DMA,
597 * so we don't need to take them into account.
598 * Otherwise, we need to modify codes for them.
599 */
600 if (byPktType == PK_TYPE_11GB || byPktType == PK_TYPE_11GA) {
601 if (byFBOption == AUTO_FB_NONE) {
602 struct vnt_rts_g *buf = pvRTS;
603 /* Get SignalField, ServiceField & Length */
604 vnt_get_phy_field(pDevice, uRTSFrameLen,
605 pDevice->byTopCCKBasicRate,
606 PK_TYPE_11B, &buf->b);
607
608 vnt_get_phy_field(pDevice, uRTSFrameLen,
609 pDevice->byTopOFDMBasicRate,
610 byPktType, &buf->a);
611 /* Get Duration */
612 buf->duration_bb =
613 s_uGetRTSCTSDuration(pDevice, RTSDUR_BB,
614 cbFrameLength, PK_TYPE_11B,
615 pDevice->byTopCCKBasicRate,
616 bNeedAck, byFBOption);
617 buf->duration_aa =
618 s_uGetRTSCTSDuration(pDevice, RTSDUR_AA,
619 cbFrameLength, byPktType,
620 wCurrentRate, bNeedAck,
621 byFBOption);
622 buf->duration_ba =
623 s_uGetRTSCTSDuration(pDevice, RTSDUR_BA,
624 cbFrameLength, byPktType,
625 wCurrentRate, bNeedAck,
626 byFBOption);
627
628 buf->data.duration = buf->duration_aa;
629 /* Get RTS Frame body */
630 buf->data.frame_control =
631 cpu_to_le16(IEEE80211_FTYPE_CTL |
632 IEEE80211_STYPE_RTS);
633
634 ether_addr_copy(buf->data.ra, hdr->addr1);
635 ether_addr_copy(buf->data.ta, hdr->addr2);
636 } else {
637 struct vnt_rts_g_fb *buf = pvRTS;
638 /* Get SignalField, ServiceField & Length */
639 vnt_get_phy_field(pDevice, uRTSFrameLen,
640 pDevice->byTopCCKBasicRate,
641 PK_TYPE_11B, &buf->b);
642
643 vnt_get_phy_field(pDevice, uRTSFrameLen,
644 pDevice->byTopOFDMBasicRate,
645 byPktType, &buf->a);
646 /* Get Duration */
647 buf->duration_bb =
648 s_uGetRTSCTSDuration(pDevice, RTSDUR_BB,
649 cbFrameLength, PK_TYPE_11B,
650 pDevice->byTopCCKBasicRate,
651 bNeedAck, byFBOption);
652 buf->duration_aa =
653 s_uGetRTSCTSDuration(pDevice, RTSDUR_AA,
654 cbFrameLength, byPktType,
655 wCurrentRate, bNeedAck,
656 byFBOption);
657 buf->duration_ba =
658 s_uGetRTSCTSDuration(pDevice, RTSDUR_BA,
659 cbFrameLength, byPktType,
660 wCurrentRate, bNeedAck,
661 byFBOption);
662 buf->rts_duration_ba_f0 =
663 s_uGetRTSCTSDuration(pDevice, RTSDUR_BA_F0,
664 cbFrameLength, byPktType,
665 wCurrentRate, bNeedAck,
666 byFBOption);
667 buf->rts_duration_aa_f0 =
668 s_uGetRTSCTSDuration(pDevice, RTSDUR_AA_F0,
669 cbFrameLength, byPktType,
670 wCurrentRate, bNeedAck,
671 byFBOption);
672 buf->rts_duration_ba_f1 =
673 s_uGetRTSCTSDuration(pDevice, RTSDUR_BA_F1,
674 cbFrameLength, byPktType,
675 wCurrentRate, bNeedAck,
676 byFBOption);
677 buf->rts_duration_aa_f1 =
678 s_uGetRTSCTSDuration(pDevice, RTSDUR_AA_F1,
679 cbFrameLength, byPktType,
680 wCurrentRate, bNeedAck,
681 byFBOption);
682 buf->data.duration = buf->duration_aa;
683 /* Get RTS Frame body */
684 buf->data.frame_control =
685 cpu_to_le16(IEEE80211_FTYPE_CTL |
686 IEEE80211_STYPE_RTS);
687
688 ether_addr_copy(buf->data.ra, hdr->addr1);
689 ether_addr_copy(buf->data.ta, hdr->addr2);
690 } /* if (byFBOption == AUTO_FB_NONE) */
691 } else if (byPktType == PK_TYPE_11A) {
692 if (byFBOption == AUTO_FB_NONE) {
693 struct vnt_rts_ab *buf = pvRTS;
694 /* Get SignalField, ServiceField & Length */
695 vnt_get_phy_field(pDevice, uRTSFrameLen,
696 pDevice->byTopOFDMBasicRate,
697 byPktType, &buf->ab);
698 /* Get Duration */
699 buf->duration =
700 s_uGetRTSCTSDuration(pDevice, RTSDUR_AA,
701 cbFrameLength, byPktType,
702 wCurrentRate, bNeedAck,
703 byFBOption);
704 buf->data.duration = buf->duration;
705 /* Get RTS Frame body */
706 buf->data.frame_control =
707 cpu_to_le16(IEEE80211_FTYPE_CTL |
708 IEEE80211_STYPE_RTS);
709
710 ether_addr_copy(buf->data.ra, hdr->addr1);
711 ether_addr_copy(buf->data.ta, hdr->addr2);
712 } else {
713 struct vnt_rts_a_fb *buf = pvRTS;
714 /* Get SignalField, ServiceField & Length */
715 vnt_get_phy_field(pDevice, uRTSFrameLen,
716 pDevice->byTopOFDMBasicRate,
717 byPktType, &buf->a);
718 /* Get Duration */
719 buf->duration =
720 s_uGetRTSCTSDuration(pDevice, RTSDUR_AA,
721 cbFrameLength, byPktType,
722 wCurrentRate, bNeedAck,
723 byFBOption);
724 buf->rts_duration_f0 =
725 s_uGetRTSCTSDuration(pDevice, RTSDUR_AA_F0,
726 cbFrameLength, byPktType,
727 wCurrentRate, bNeedAck,
728 byFBOption);
729 buf->rts_duration_f1 =
730 s_uGetRTSCTSDuration(pDevice, RTSDUR_AA_F1,
731 cbFrameLength, byPktType,
732 wCurrentRate, bNeedAck,
733 byFBOption);
734 buf->data.duration = buf->duration;
735 /* Get RTS Frame body */
736 buf->data.frame_control =
737 cpu_to_le16(IEEE80211_FTYPE_CTL |
738 IEEE80211_STYPE_RTS);
739
740 ether_addr_copy(buf->data.ra, hdr->addr1);
741 ether_addr_copy(buf->data.ta, hdr->addr2);
742 }
743 } else if (byPktType == PK_TYPE_11B) {
744 struct vnt_rts_ab *buf = pvRTS;
745 /* Get SignalField, ServiceField & Length */
746 vnt_get_phy_field(pDevice, uRTSFrameLen,
747 pDevice->byTopCCKBasicRate,
748 PK_TYPE_11B, &buf->ab);
749 /* Get Duration */
750 buf->duration =
751 s_uGetRTSCTSDuration(pDevice, RTSDUR_BB, cbFrameLength,
752 byPktType, wCurrentRate, bNeedAck,
753 byFBOption);
754
755 buf->data.duration = buf->duration;
756 /* Get RTS Frame body */
757 buf->data.frame_control =
758 cpu_to_le16(IEEE80211_FTYPE_CTL | IEEE80211_STYPE_RTS);
759
760 ether_addr_copy(buf->data.ra, hdr->addr1);
761 ether_addr_copy(buf->data.ta, hdr->addr2);
762 }
763 }
764
765 static
766 void
s_vFillCTSHead(struct vnt_private * pDevice,unsigned int uDMAIdx,unsigned char byPktType,void * pvCTS,unsigned int cbFrameLength,bool bNeedAck,bool bDisCRC,unsigned short wCurrentRate,unsigned char byFBOption)767 s_vFillCTSHead(
768 struct vnt_private *pDevice,
769 unsigned int uDMAIdx,
770 unsigned char byPktType,
771 void *pvCTS,
772 unsigned int cbFrameLength,
773 bool bNeedAck,
774 bool bDisCRC,
775 unsigned short wCurrentRate,
776 unsigned char byFBOption
777 )
778 {
779 unsigned int uCTSFrameLen = 14;
780
781 if (!pvCTS)
782 return;
783
784 if (bDisCRC) {
785 /* When CRCDIS bit is on, H/W forgot to generate FCS for
786 * CTS frame, in this case we need to decrease its length by 4.
787 */
788 uCTSFrameLen -= 4;
789 }
790
791 if (byPktType == PK_TYPE_11GB || byPktType == PK_TYPE_11GA) {
792 if (byFBOption != AUTO_FB_NONE && uDMAIdx != TYPE_ATIMDMA && uDMAIdx != TYPE_BEACONDMA) {
793 /* Auto Fall back */
794 struct vnt_cts_fb *buf = pvCTS;
795 /* Get SignalField, ServiceField & Length */
796 vnt_get_phy_field(pDevice, uCTSFrameLen,
797 pDevice->byTopCCKBasicRate,
798 PK_TYPE_11B, &buf->b);
799
800 buf->duration_ba =
801 s_uGetRTSCTSDuration(pDevice, CTSDUR_BA,
802 cbFrameLength, byPktType,
803 wCurrentRate, bNeedAck,
804 byFBOption);
805
806 /* Get CTSDuration_ba_f0 */
807 buf->cts_duration_ba_f0 =
808 s_uGetRTSCTSDuration(pDevice, CTSDUR_BA_F0,
809 cbFrameLength, byPktType,
810 wCurrentRate, bNeedAck,
811 byFBOption);
812
813 /* Get CTSDuration_ba_f1 */
814 buf->cts_duration_ba_f1 =
815 s_uGetRTSCTSDuration(pDevice, CTSDUR_BA_F1,
816 cbFrameLength, byPktType,
817 wCurrentRate, bNeedAck,
818 byFBOption);
819
820 /* Get CTS Frame body */
821 buf->data.duration = buf->duration_ba;
822
823 buf->data.frame_control =
824 cpu_to_le16(IEEE80211_FTYPE_CTL |
825 IEEE80211_STYPE_CTS);
826
827 buf->reserved2 = 0x0;
828
829 ether_addr_copy(buf->data.ra,
830 pDevice->abyCurrentNetAddr);
831 } else { /* if (byFBOption != AUTO_FB_NONE && uDMAIdx != TYPE_ATIMDMA && uDMAIdx != TYPE_BEACONDMA) */
832 struct vnt_cts *buf = pvCTS;
833 /* Get SignalField, ServiceField & Length */
834 vnt_get_phy_field(pDevice, uCTSFrameLen,
835 pDevice->byTopCCKBasicRate,
836 PK_TYPE_11B, &buf->b);
837
838 /* Get CTSDuration_ba */
839 buf->duration_ba =
840 s_uGetRTSCTSDuration(pDevice, CTSDUR_BA,
841 cbFrameLength, byPktType,
842 wCurrentRate, bNeedAck,
843 byFBOption);
844
845 /* Get CTS Frame body */
846 buf->data.duration = buf->duration_ba;
847
848 buf->data.frame_control =
849 cpu_to_le16(IEEE80211_FTYPE_CTL |
850 IEEE80211_STYPE_CTS);
851
852 buf->reserved2 = 0x0;
853 ether_addr_copy(buf->data.ra,
854 pDevice->abyCurrentNetAddr);
855 }
856 }
857 }
858
859 /*
860 *
861 * Description:
862 * Generate FIFO control for MAC & Baseband controller
863 *
864 * Parameters:
865 * In:
866 * pDevice - Pointer to adapter
867 * pTxDataHead - Transmit Data Buffer
868 * pTxBufHead - pTxBufHead
869 * pvRrvTime - pvRrvTime
870 * pvRTS - RTS Buffer
871 * pCTS - CTS Buffer
872 * cbFrameSize - Transmit Data Length (Hdr+Payload+FCS)
873 * bNeedACK - If need ACK
874 * uDescIdx - Desc Index
875 * Out:
876 * none
877 *
878 * Return Value: none
879 *
880 -
881 * unsigned int cbFrameSize, Hdr+Payload+FCS
882 */
883 static
884 void
s_vGenerateTxParameter(struct vnt_private * pDevice,unsigned char byPktType,struct vnt_tx_fifo_head * tx_buffer_head,void * pvRrvTime,void * pvRTS,void * pvCTS,unsigned int cbFrameSize,bool bNeedACK,unsigned int uDMAIdx,void * psEthHeader,unsigned short wCurrentRate)885 s_vGenerateTxParameter(
886 struct vnt_private *pDevice,
887 unsigned char byPktType,
888 struct vnt_tx_fifo_head *tx_buffer_head,
889 void *pvRrvTime,
890 void *pvRTS,
891 void *pvCTS,
892 unsigned int cbFrameSize,
893 bool bNeedACK,
894 unsigned int uDMAIdx,
895 void *psEthHeader,
896 unsigned short wCurrentRate
897 )
898 {
899 u16 fifo_ctl = le16_to_cpu(tx_buffer_head->fifo_ctl);
900 bool bDisCRC = false;
901 unsigned char byFBOption = AUTO_FB_NONE;
902
903 tx_buffer_head->current_rate = cpu_to_le16(wCurrentRate);
904
905 if (fifo_ctl & FIFOCTL_CRCDIS)
906 bDisCRC = true;
907
908 if (fifo_ctl & FIFOCTL_AUTO_FB_0)
909 byFBOption = AUTO_FB_0;
910 else if (fifo_ctl & FIFOCTL_AUTO_FB_1)
911 byFBOption = AUTO_FB_1;
912
913 if (!pvRrvTime)
914 return;
915
916 if (byPktType == PK_TYPE_11GB || byPktType == PK_TYPE_11GA) {
917 if (pvRTS) { /* RTS_need */
918 /* Fill RsvTime */
919 struct vnt_rrv_time_rts *buf = pvRrvTime;
920
921 buf->rts_rrv_time_aa = get_rtscts_time(pDevice, 2, byPktType, cbFrameSize, wCurrentRate);
922 buf->rts_rrv_time_ba = get_rtscts_time(pDevice, 1, byPktType, cbFrameSize, wCurrentRate);
923 buf->rts_rrv_time_bb = get_rtscts_time(pDevice, 0, byPktType, cbFrameSize, wCurrentRate);
924 buf->rrv_time_a = vnt_rxtx_rsvtime_le16(pDevice, byPktType, cbFrameSize, wCurrentRate, bNeedACK);
925 buf->rrv_time_b = vnt_rxtx_rsvtime_le16(pDevice, PK_TYPE_11B, cbFrameSize, pDevice->byTopCCKBasicRate, bNeedACK);
926
927 s_vFillRTSHead(pDevice, byPktType, pvRTS, cbFrameSize, bNeedACK, bDisCRC, psEthHeader, wCurrentRate, byFBOption);
928 } else {/* RTS_needless, PCF mode */
929 struct vnt_rrv_time_cts *buf = pvRrvTime;
930
931 buf->rrv_time_a = vnt_rxtx_rsvtime_le16(pDevice, byPktType, cbFrameSize, wCurrentRate, bNeedACK);
932 buf->rrv_time_b = vnt_rxtx_rsvtime_le16(pDevice, PK_TYPE_11B, cbFrameSize, pDevice->byTopCCKBasicRate, bNeedACK);
933 buf->cts_rrv_time_ba = get_rtscts_time(pDevice, 3, byPktType, cbFrameSize, wCurrentRate);
934
935 /* Fill CTS */
936 s_vFillCTSHead(pDevice, uDMAIdx, byPktType, pvCTS, cbFrameSize, bNeedACK, bDisCRC, wCurrentRate, byFBOption);
937 }
938 } else if (byPktType == PK_TYPE_11A) {
939 if (pvRTS) {/* RTS_need, non PCF mode */
940 struct vnt_rrv_time_ab *buf = pvRrvTime;
941
942 buf->rts_rrv_time = get_rtscts_time(pDevice, 2, byPktType, cbFrameSize, wCurrentRate);
943 buf->rrv_time = vnt_rxtx_rsvtime_le16(pDevice, byPktType, cbFrameSize, wCurrentRate, bNeedACK);
944
945 /* Fill RTS */
946 s_vFillRTSHead(pDevice, byPktType, pvRTS, cbFrameSize, bNeedACK, bDisCRC, psEthHeader, wCurrentRate, byFBOption);
947 } else if (!pvRTS) {/* RTS_needless, non PCF mode */
948 struct vnt_rrv_time_ab *buf = pvRrvTime;
949
950 buf->rrv_time = vnt_rxtx_rsvtime_le16(pDevice, PK_TYPE_11A, cbFrameSize, wCurrentRate, bNeedACK);
951 }
952 } else if (byPktType == PK_TYPE_11B) {
953 if (pvRTS) {/* RTS_need, non PCF mode */
954 struct vnt_rrv_time_ab *buf = pvRrvTime;
955
956 buf->rts_rrv_time = get_rtscts_time(pDevice, 0, byPktType, cbFrameSize, wCurrentRate);
957 buf->rrv_time = vnt_rxtx_rsvtime_le16(pDevice, PK_TYPE_11B, cbFrameSize, wCurrentRate, bNeedACK);
958
959 /* Fill RTS */
960 s_vFillRTSHead(pDevice, byPktType, pvRTS, cbFrameSize, bNeedACK, bDisCRC, psEthHeader, wCurrentRate, byFBOption);
961 } else { /* RTS_needless, non PCF mode */
962 struct vnt_rrv_time_ab *buf = pvRrvTime;
963
964 buf->rrv_time = vnt_rxtx_rsvtime_le16(pDevice, PK_TYPE_11B, cbFrameSize, wCurrentRate, bNeedACK);
965 }
966 }
967 }
968
969 static unsigned int
s_cbFillTxBufHead(struct vnt_private * pDevice,unsigned char byPktType,unsigned char * pbyTxBufferAddr,unsigned int uDMAIdx,struct vnt_tx_desc * pHeadTD,unsigned int is_pspoll)970 s_cbFillTxBufHead(struct vnt_private *pDevice, unsigned char byPktType,
971 unsigned char *pbyTxBufferAddr,
972 unsigned int uDMAIdx, struct vnt_tx_desc *pHeadTD,
973 unsigned int is_pspoll)
974 {
975 struct vnt_td_info *td_info = pHeadTD->td_info;
976 struct sk_buff *skb = td_info->skb;
977 struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
978 struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)skb->data;
979 struct vnt_tx_fifo_head *tx_buffer_head =
980 (struct vnt_tx_fifo_head *)td_info->buf;
981 u16 fifo_ctl = le16_to_cpu(tx_buffer_head->fifo_ctl);
982 unsigned int cbFrameSize;
983 __le16 uDuration;
984 unsigned char *pbyBuffer;
985 unsigned int uLength = 0;
986 unsigned int cbMICHDR = 0;
987 unsigned int uMACfragNum = 1;
988 unsigned int uPadding = 0;
989 unsigned int cbReqCount = 0;
990 bool bNeedACK = (bool)(fifo_ctl & FIFOCTL_NEEDACK);
991 bool bRTS = (bool)(fifo_ctl & FIFOCTL_RTS);
992 struct vnt_tx_desc *ptdCurr;
993 unsigned int cbHeaderLength = 0;
994 void *pvRrvTime = NULL;
995 struct vnt_mic_hdr *pMICHDR = NULL;
996 void *pvRTS = NULL;
997 void *pvCTS = NULL;
998 void *pvTxDataHd = NULL;
999 unsigned short wTxBufSize; /* FFinfo size */
1000 unsigned char byFBOption = AUTO_FB_NONE;
1001
1002 cbFrameSize = skb->len + 4;
1003
1004 if (info->control.hw_key) {
1005 switch (info->control.hw_key->cipher) {
1006 case WLAN_CIPHER_SUITE_CCMP:
1007 cbMICHDR = sizeof(struct vnt_mic_hdr);
1008 break;
1009 default:
1010 break;
1011 }
1012
1013 cbFrameSize += info->control.hw_key->icv_len;
1014
1015 if (pDevice->local_id > REV_ID_VT3253_A1) {
1016 /* MAC Header should be padding 0 to DW alignment. */
1017 uPadding = 4 - (ieee80211_get_hdrlen_from_skb(skb) % 4);
1018 uPadding %= 4;
1019 }
1020 }
1021
1022 /*
1023 * Use for AUTO FALL BACK
1024 */
1025 if (fifo_ctl & FIFOCTL_AUTO_FB_0)
1026 byFBOption = AUTO_FB_0;
1027 else if (fifo_ctl & FIFOCTL_AUTO_FB_1)
1028 byFBOption = AUTO_FB_1;
1029
1030 /* Set RrvTime/RTS/CTS Buffer */
1031 wTxBufSize = sizeof(struct vnt_tx_fifo_head);
1032 if (byPktType == PK_TYPE_11GB || byPktType == PK_TYPE_11GA) {/* 802.11g packet */
1033
1034 if (byFBOption == AUTO_FB_NONE) {
1035 if (bRTS) {/* RTS_need */
1036 pvRrvTime = (void *)(pbyTxBufferAddr + wTxBufSize);
1037 pMICHDR = (struct vnt_mic_hdr *)(pbyTxBufferAddr + wTxBufSize + sizeof(struct vnt_rrv_time_rts));
1038 pvRTS = (void *)(pbyTxBufferAddr + wTxBufSize + sizeof(struct vnt_rrv_time_rts) + cbMICHDR);
1039 pvCTS = NULL;
1040 pvTxDataHd = (void *)(pbyTxBufferAddr + wTxBufSize + sizeof(struct vnt_rrv_time_rts) +
1041 cbMICHDR + sizeof(struct vnt_rts_g));
1042 cbHeaderLength = wTxBufSize + sizeof(struct vnt_rrv_time_rts) +
1043 cbMICHDR + sizeof(struct vnt_rts_g) +
1044 sizeof(struct vnt_tx_datahead_g);
1045 } else { /* RTS_needless */
1046 pvRrvTime = (void *)(pbyTxBufferAddr + wTxBufSize);
1047 pMICHDR = (struct vnt_mic_hdr *)(pbyTxBufferAddr + wTxBufSize + sizeof(struct vnt_rrv_time_cts));
1048 pvRTS = NULL;
1049 pvCTS = (void *) (pbyTxBufferAddr + wTxBufSize + sizeof(struct vnt_rrv_time_cts) + cbMICHDR);
1050 pvTxDataHd = (void *)(pbyTxBufferAddr + wTxBufSize +
1051 sizeof(struct vnt_rrv_time_cts) + cbMICHDR + sizeof(struct vnt_cts));
1052 cbHeaderLength = wTxBufSize + sizeof(struct vnt_rrv_time_cts) +
1053 cbMICHDR + sizeof(struct vnt_cts) + sizeof(struct vnt_tx_datahead_g);
1054 }
1055 } else {
1056 /* Auto Fall Back */
1057 if (bRTS) {/* RTS_need */
1058 pvRrvTime = (void *)(pbyTxBufferAddr + wTxBufSize);
1059 pMICHDR = (struct vnt_mic_hdr *)(pbyTxBufferAddr + wTxBufSize + sizeof(struct vnt_rrv_time_rts));
1060 pvRTS = (void *) (pbyTxBufferAddr + wTxBufSize + sizeof(struct vnt_rrv_time_rts) + cbMICHDR);
1061 pvCTS = NULL;
1062 pvTxDataHd = (void *)(pbyTxBufferAddr + wTxBufSize + sizeof(struct vnt_rrv_time_rts) +
1063 cbMICHDR + sizeof(struct vnt_rts_g_fb));
1064 cbHeaderLength = wTxBufSize + sizeof(struct vnt_rrv_time_rts) +
1065 cbMICHDR + sizeof(struct vnt_rts_g_fb) + sizeof(struct vnt_tx_datahead_g_fb);
1066 } else { /* RTS_needless */
1067 pvRrvTime = (void *)(pbyTxBufferAddr + wTxBufSize);
1068 pMICHDR = (struct vnt_mic_hdr *)(pbyTxBufferAddr + wTxBufSize + sizeof(struct vnt_rrv_time_cts));
1069 pvRTS = NULL;
1070 pvCTS = (void *)(pbyTxBufferAddr + wTxBufSize + sizeof(struct vnt_rrv_time_cts) + cbMICHDR);
1071 pvTxDataHd = (void *)(pbyTxBufferAddr + wTxBufSize + sizeof(struct vnt_rrv_time_cts) +
1072 cbMICHDR + sizeof(struct vnt_cts_fb));
1073 cbHeaderLength = wTxBufSize + sizeof(struct vnt_rrv_time_cts) +
1074 cbMICHDR + sizeof(struct vnt_cts_fb) + sizeof(struct vnt_tx_datahead_g_fb);
1075 }
1076 } /* Auto Fall Back */
1077 } else {/* 802.11a/b packet */
1078
1079 if (byFBOption == AUTO_FB_NONE) {
1080 if (bRTS) {
1081 pvRrvTime = (void *)(pbyTxBufferAddr + wTxBufSize);
1082 pMICHDR = (struct vnt_mic_hdr *)(pbyTxBufferAddr + wTxBufSize + sizeof(struct vnt_rrv_time_ab));
1083 pvRTS = (void *)(pbyTxBufferAddr + wTxBufSize + sizeof(struct vnt_rrv_time_ab) + cbMICHDR);
1084 pvCTS = NULL;
1085 pvTxDataHd = (void *)(pbyTxBufferAddr + wTxBufSize +
1086 sizeof(struct vnt_rrv_time_ab) + cbMICHDR + sizeof(struct vnt_rts_ab));
1087 cbHeaderLength = wTxBufSize + sizeof(struct vnt_rrv_time_ab) +
1088 cbMICHDR + sizeof(struct vnt_rts_ab) + sizeof(struct vnt_tx_datahead_ab);
1089 } else { /* RTS_needless, need MICHDR */
1090 pvRrvTime = (void *)(pbyTxBufferAddr + wTxBufSize);
1091 pMICHDR = (struct vnt_mic_hdr *)(pbyTxBufferAddr + wTxBufSize + sizeof(struct vnt_rrv_time_ab));
1092 pvRTS = NULL;
1093 pvCTS = NULL;
1094 pvTxDataHd = (void *)(pbyTxBufferAddr + wTxBufSize + sizeof(struct vnt_rrv_time_ab) + cbMICHDR);
1095 cbHeaderLength = wTxBufSize + sizeof(struct vnt_rrv_time_ab) +
1096 cbMICHDR + sizeof(struct vnt_tx_datahead_ab);
1097 }
1098 } else {
1099 /* Auto Fall Back */
1100 if (bRTS) { /* RTS_need */
1101 pvRrvTime = (void *)(pbyTxBufferAddr + wTxBufSize);
1102 pMICHDR = (struct vnt_mic_hdr *)(pbyTxBufferAddr + wTxBufSize + sizeof(struct vnt_rrv_time_ab));
1103 pvRTS = (void *)(pbyTxBufferAddr + wTxBufSize + sizeof(struct vnt_rrv_time_ab) + cbMICHDR);
1104 pvCTS = NULL;
1105 pvTxDataHd = (void *)(pbyTxBufferAddr + wTxBufSize +
1106 sizeof(struct vnt_rrv_time_ab) + cbMICHDR + sizeof(struct vnt_rts_a_fb));
1107 cbHeaderLength = wTxBufSize + sizeof(struct vnt_rrv_time_ab) +
1108 cbMICHDR + sizeof(struct vnt_rts_a_fb) + sizeof(struct vnt_tx_datahead_a_fb);
1109 } else { /* RTS_needless */
1110 pvRrvTime = (void *)(pbyTxBufferAddr + wTxBufSize);
1111 pMICHDR = (struct vnt_mic_hdr *)(pbyTxBufferAddr + wTxBufSize + sizeof(struct vnt_rrv_time_ab));
1112 pvRTS = NULL;
1113 pvCTS = NULL;
1114 pvTxDataHd = (void *)(pbyTxBufferAddr + wTxBufSize + sizeof(struct vnt_rrv_time_ab) + cbMICHDR);
1115 cbHeaderLength = wTxBufSize + sizeof(struct vnt_rrv_time_ab) +
1116 cbMICHDR + sizeof(struct vnt_tx_datahead_a_fb);
1117 }
1118 } /* Auto Fall Back */
1119 }
1120
1121 td_info->mic_hdr = pMICHDR;
1122
1123 memset((void *)(pbyTxBufferAddr + wTxBufSize), 0, (cbHeaderLength - wTxBufSize));
1124
1125 /* Fill FIFO,RrvTime,RTS,and CTS */
1126 s_vGenerateTxParameter(pDevice, byPktType, tx_buffer_head, pvRrvTime, pvRTS, pvCTS,
1127 cbFrameSize, bNeedACK, uDMAIdx, hdr, pDevice->wCurrentRate);
1128 /* Fill DataHead */
1129 uDuration = s_uFillDataHead(pDevice, byPktType, pvTxDataHd, cbFrameSize, uDMAIdx, bNeedACK,
1130 0, 0, uMACfragNum, byFBOption, pDevice->wCurrentRate, is_pspoll);
1131
1132 hdr->duration_id = uDuration;
1133
1134 cbReqCount = cbHeaderLength + uPadding + skb->len;
1135 pbyBuffer = (unsigned char *)pHeadTD->td_info->buf;
1136 uLength = cbHeaderLength + uPadding;
1137
1138 /* Copy the Packet into a tx Buffer */
1139 memcpy((pbyBuffer + uLength), skb->data, skb->len);
1140
1141 ptdCurr = pHeadTD;
1142
1143 ptdCurr->td_info->req_count = (u16)cbReqCount;
1144
1145 return cbHeaderLength;
1146 }
1147
vnt_fill_txkey(struct ieee80211_hdr * hdr,u8 * key_buffer,struct ieee80211_key_conf * tx_key,struct sk_buff * skb,u16 payload_len,struct vnt_mic_hdr * mic_hdr)1148 static void vnt_fill_txkey(struct ieee80211_hdr *hdr, u8 *key_buffer,
1149 struct ieee80211_key_conf *tx_key,
1150 struct sk_buff *skb, u16 payload_len,
1151 struct vnt_mic_hdr *mic_hdr)
1152 {
1153 u64 pn64;
1154 u8 *iv = ((u8 *)hdr + ieee80211_get_hdrlen_from_skb(skb));
1155
1156 /* strip header and icv len from payload */
1157 payload_len -= ieee80211_get_hdrlen_from_skb(skb);
1158 payload_len -= tx_key->icv_len;
1159
1160 switch (tx_key->cipher) {
1161 case WLAN_CIPHER_SUITE_WEP40:
1162 case WLAN_CIPHER_SUITE_WEP104:
1163 memcpy(key_buffer, iv, 3);
1164 memcpy(key_buffer + 3, tx_key->key, tx_key->keylen);
1165
1166 if (tx_key->keylen == WLAN_KEY_LEN_WEP40) {
1167 memcpy(key_buffer + 8, iv, 3);
1168 memcpy(key_buffer + 11,
1169 tx_key->key, WLAN_KEY_LEN_WEP40);
1170 }
1171
1172 break;
1173 case WLAN_CIPHER_SUITE_TKIP:
1174 ieee80211_get_tkip_p2k(tx_key, skb, key_buffer);
1175
1176 break;
1177 case WLAN_CIPHER_SUITE_CCMP:
1178
1179 if (!mic_hdr)
1180 return;
1181
1182 mic_hdr->id = 0x59;
1183 mic_hdr->payload_len = cpu_to_be16(payload_len);
1184 ether_addr_copy(mic_hdr->mic_addr2, hdr->addr2);
1185
1186 pn64 = atomic64_read(&tx_key->tx_pn);
1187 mic_hdr->ccmp_pn[5] = pn64;
1188 mic_hdr->ccmp_pn[4] = pn64 >> 8;
1189 mic_hdr->ccmp_pn[3] = pn64 >> 16;
1190 mic_hdr->ccmp_pn[2] = pn64 >> 24;
1191 mic_hdr->ccmp_pn[1] = pn64 >> 32;
1192 mic_hdr->ccmp_pn[0] = pn64 >> 40;
1193
1194 if (ieee80211_has_a4(hdr->frame_control))
1195 mic_hdr->hlen = cpu_to_be16(28);
1196 else
1197 mic_hdr->hlen = cpu_to_be16(22);
1198
1199 ether_addr_copy(mic_hdr->addr1, hdr->addr1);
1200 ether_addr_copy(mic_hdr->addr2, hdr->addr2);
1201 ether_addr_copy(mic_hdr->addr3, hdr->addr3);
1202
1203 mic_hdr->frame_control = cpu_to_le16(
1204 le16_to_cpu(hdr->frame_control) & 0xc78f);
1205 mic_hdr->seq_ctrl = cpu_to_le16(
1206 le16_to_cpu(hdr->seq_ctrl) & 0xf);
1207
1208 if (ieee80211_has_a4(hdr->frame_control))
1209 ether_addr_copy(mic_hdr->addr4, hdr->addr4);
1210
1211 memcpy(key_buffer, tx_key->key, WLAN_KEY_LEN_CCMP);
1212
1213 break;
1214 default:
1215 break;
1216 }
1217 }
1218
vnt_generate_fifo_header(struct vnt_private * priv,u32 dma_idx,struct vnt_tx_desc * head_td,struct sk_buff * skb)1219 int vnt_generate_fifo_header(struct vnt_private *priv, u32 dma_idx,
1220 struct vnt_tx_desc *head_td, struct sk_buff *skb)
1221 {
1222 struct vnt_td_info *td_info = head_td->td_info;
1223 struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
1224 struct ieee80211_tx_rate *tx_rate = &info->control.rates[0];
1225 struct ieee80211_rate *rate;
1226 struct ieee80211_key_conf *tx_key;
1227 struct ieee80211_hdr *hdr;
1228 struct vnt_tx_fifo_head *tx_buffer_head =
1229 (struct vnt_tx_fifo_head *)td_info->buf;
1230 u16 tx_body_size = skb->len, current_rate;
1231 u8 pkt_type;
1232 bool is_pspoll = false;
1233
1234 memset(tx_buffer_head, 0, sizeof(*tx_buffer_head));
1235
1236 hdr = (struct ieee80211_hdr *)(skb->data);
1237
1238 rate = ieee80211_get_tx_rate(priv->hw, info);
1239
1240 current_rate = rate->hw_value;
1241 if (priv->wCurrentRate != current_rate &&
1242 !(priv->hw->conf.flags & IEEE80211_CONF_OFFCHANNEL)) {
1243 priv->wCurrentRate = current_rate;
1244
1245 RFbSetPower(priv, priv->wCurrentRate,
1246 priv->hw->conf.chandef.chan->hw_value);
1247 }
1248
1249 if (current_rate > RATE_11M) {
1250 if (info->band == NL80211_BAND_5GHZ) {
1251 pkt_type = PK_TYPE_11A;
1252 } else {
1253 if (tx_rate->flags & IEEE80211_TX_RC_USE_CTS_PROTECT)
1254 pkt_type = PK_TYPE_11GB;
1255 else
1256 pkt_type = PK_TYPE_11GA;
1257 }
1258 } else {
1259 pkt_type = PK_TYPE_11B;
1260 }
1261
1262 /*Set fifo controls */
1263 if (pkt_type == PK_TYPE_11A)
1264 tx_buffer_head->fifo_ctl = 0;
1265 else if (pkt_type == PK_TYPE_11B)
1266 tx_buffer_head->fifo_ctl = cpu_to_le16(FIFOCTL_11B);
1267 else if (pkt_type == PK_TYPE_11GB)
1268 tx_buffer_head->fifo_ctl = cpu_to_le16(FIFOCTL_11GB);
1269 else if (pkt_type == PK_TYPE_11GA)
1270 tx_buffer_head->fifo_ctl = cpu_to_le16(FIFOCTL_11GA);
1271
1272 /* generate interrupt */
1273 tx_buffer_head->fifo_ctl |= cpu_to_le16(FIFOCTL_GENINT);
1274
1275 if (!ieee80211_is_data(hdr->frame_control)) {
1276 tx_buffer_head->fifo_ctl |= cpu_to_le16(FIFOCTL_TMOEN);
1277 tx_buffer_head->fifo_ctl |= cpu_to_le16(FIFOCTL_ISDMA0);
1278 tx_buffer_head->time_stamp =
1279 cpu_to_le16(DEFAULT_MGN_LIFETIME_RES_64us);
1280 } else {
1281 tx_buffer_head->time_stamp =
1282 cpu_to_le16(DEFAULT_MSDU_LIFETIME_RES_64us);
1283 }
1284
1285 if (!(info->flags & IEEE80211_TX_CTL_NO_ACK))
1286 tx_buffer_head->fifo_ctl |= cpu_to_le16(FIFOCTL_NEEDACK);
1287
1288 if (ieee80211_has_retry(hdr->frame_control))
1289 tx_buffer_head->fifo_ctl |= cpu_to_le16(FIFOCTL_LRETRY);
1290
1291 if (tx_rate->flags & IEEE80211_TX_RC_USE_SHORT_PREAMBLE)
1292 priv->preamble_type = PREAMBLE_SHORT;
1293 else
1294 priv->preamble_type = PREAMBLE_LONG;
1295
1296 if (tx_rate->flags & IEEE80211_TX_RC_USE_RTS_CTS)
1297 tx_buffer_head->fifo_ctl |= cpu_to_le16(FIFOCTL_RTS);
1298
1299 if (ieee80211_has_a4(hdr->frame_control)) {
1300 tx_buffer_head->fifo_ctl |= cpu_to_le16(FIFOCTL_LHEAD);
1301 priv->bLongHeader = true;
1302 }
1303
1304 if (info->flags & IEEE80211_TX_CTL_NO_PS_BUFFER)
1305 is_pspoll = true;
1306
1307 tx_buffer_head->frag_ctl =
1308 cpu_to_le16(ieee80211_get_hdrlen_from_skb(skb) << 10);
1309
1310 if (info->control.hw_key) {
1311 switch (info->control.hw_key->cipher) {
1312 case WLAN_CIPHER_SUITE_WEP40:
1313 case WLAN_CIPHER_SUITE_WEP104:
1314 tx_buffer_head->frag_ctl |= cpu_to_le16(FRAGCTL_LEGACY);
1315 break;
1316 case WLAN_CIPHER_SUITE_TKIP:
1317 tx_buffer_head->frag_ctl |= cpu_to_le16(FRAGCTL_TKIP);
1318 break;
1319 case WLAN_CIPHER_SUITE_CCMP:
1320 tx_buffer_head->frag_ctl |= cpu_to_le16(FRAGCTL_AES);
1321 break;
1322 default:
1323 break;
1324 }
1325 }
1326
1327 tx_buffer_head->current_rate = cpu_to_le16(current_rate);
1328
1329 /* legacy rates TODO use ieee80211_tx_rate */
1330 if (current_rate >= RATE_18M && ieee80211_is_data(hdr->frame_control)) {
1331 if (priv->byAutoFBCtrl == AUTO_FB_0)
1332 tx_buffer_head->fifo_ctl |=
1333 cpu_to_le16(FIFOCTL_AUTO_FB_0);
1334 else if (priv->byAutoFBCtrl == AUTO_FB_1)
1335 tx_buffer_head->fifo_ctl |=
1336 cpu_to_le16(FIFOCTL_AUTO_FB_1);
1337 }
1338
1339 tx_buffer_head->frag_ctl |= cpu_to_le16(FRAGCTL_NONFRAG);
1340
1341 s_cbFillTxBufHead(priv, pkt_type, (u8 *)tx_buffer_head,
1342 dma_idx, head_td, is_pspoll);
1343
1344 if (info->control.hw_key) {
1345 tx_key = info->control.hw_key;
1346 if (tx_key->keylen > 0)
1347 vnt_fill_txkey(hdr, tx_buffer_head->tx_key,
1348 tx_key, skb, tx_body_size,
1349 td_info->mic_hdr);
1350 }
1351
1352 return 0;
1353 }
1354
vnt_beacon_xmit(struct vnt_private * priv,struct sk_buff * skb)1355 static int vnt_beacon_xmit(struct vnt_private *priv,
1356 struct sk_buff *skb)
1357 {
1358 struct vnt_tx_short_buf_head *short_head =
1359 (struct vnt_tx_short_buf_head *)priv->tx_beacon_bufs;
1360 struct ieee80211_mgmt *mgmt_hdr = (struct ieee80211_mgmt *)
1361 (priv->tx_beacon_bufs + sizeof(*short_head));
1362 struct ieee80211_tx_info *info;
1363 u32 frame_size = skb->len + 4;
1364 u16 current_rate;
1365
1366 memset(priv->tx_beacon_bufs, 0, sizeof(*short_head));
1367
1368 if (priv->byBBType == BB_TYPE_11A) {
1369 current_rate = RATE_6M;
1370
1371 /* Get SignalField,ServiceField,Length */
1372 vnt_get_phy_field(priv, frame_size, current_rate,
1373 PK_TYPE_11A, &short_head->ab);
1374
1375 /* Get Duration and TimeStampOff */
1376 short_head->duration =
1377 cpu_to_le16((u16)s_uGetDataDuration(priv, DATADUR_B,
1378 frame_size, PK_TYPE_11A, current_rate,
1379 false, 0, 0, 1, AUTO_FB_NONE));
1380
1381 short_head->time_stamp_off =
1382 vnt_time_stamp_off(priv, current_rate);
1383 } else {
1384 current_rate = RATE_1M;
1385 short_head->fifo_ctl |= cpu_to_le16(FIFOCTL_11B);
1386
1387 /* Get SignalField,ServiceField,Length */
1388 vnt_get_phy_field(priv, frame_size, current_rate,
1389 PK_TYPE_11B, &short_head->ab);
1390
1391 /* Get Duration and TimeStampOff */
1392 short_head->duration =
1393 cpu_to_le16((u16)s_uGetDataDuration(priv, DATADUR_B,
1394 frame_size, PK_TYPE_11B, current_rate,
1395 false, 0, 0, 1, AUTO_FB_NONE));
1396
1397 short_head->time_stamp_off =
1398 vnt_time_stamp_off(priv, current_rate);
1399 }
1400
1401 short_head->fifo_ctl |= cpu_to_le16(FIFOCTL_GENINT);
1402
1403 /* Copy Beacon */
1404 memcpy(mgmt_hdr, skb->data, skb->len);
1405
1406 /* time stamp always 0 */
1407 mgmt_hdr->u.beacon.timestamp = 0;
1408
1409 info = IEEE80211_SKB_CB(skb);
1410 if (info->flags & IEEE80211_TX_CTL_ASSIGN_SEQ) {
1411 struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)mgmt_hdr;
1412
1413 hdr->duration_id = 0;
1414 hdr->seq_ctrl = cpu_to_le16(priv->wSeqCounter << 4);
1415 }
1416
1417 priv->wSeqCounter++;
1418 if (priv->wSeqCounter > 0x0fff)
1419 priv->wSeqCounter = 0;
1420
1421 priv->wBCNBufLen = sizeof(*short_head) + skb->len;
1422
1423 iowrite32((u32)priv->tx_beacon_dma, priv->port_offset + MAC_REG_BCNDMAPTR);
1424
1425 iowrite16(priv->wBCNBufLen, priv->port_offset + MAC_REG_BCNDMACTL + 2);
1426 /* Set auto Transmit on */
1427 vt6655_mac_reg_bits_on(priv->port_offset, MAC_REG_TCR, TCR_AUTOBCNTX);
1428 /* Poll Transmit the adapter */
1429 iowrite8(BEACON_READY, priv->port_offset + MAC_REG_BCNDMACTL);
1430
1431 return 0;
1432 }
1433
vnt_beacon_make(struct vnt_private * priv,struct ieee80211_vif * vif)1434 int vnt_beacon_make(struct vnt_private *priv, struct ieee80211_vif *vif)
1435 {
1436 struct sk_buff *beacon;
1437
1438 beacon = ieee80211_beacon_get(priv->hw, vif, 0);
1439 if (!beacon)
1440 return -ENOMEM;
1441
1442 if (vnt_beacon_xmit(priv, beacon)) {
1443 ieee80211_free_txskb(priv->hw, beacon);
1444 return -ENODEV;
1445 }
1446
1447 return 0;
1448 }
1449
vnt_beacon_enable(struct vnt_private * priv,struct ieee80211_vif * vif,struct ieee80211_bss_conf * conf)1450 int vnt_beacon_enable(struct vnt_private *priv, struct ieee80211_vif *vif,
1451 struct ieee80211_bss_conf *conf)
1452 {
1453 iowrite8(TFTCTL_TSFCNTRST, priv->port_offset + MAC_REG_TFTCTL);
1454
1455 iowrite8(TFTCTL_TSFCNTREN, priv->port_offset + MAC_REG_TFTCTL);
1456
1457 CARDvSetFirstNextTBTT(priv, conf->beacon_int);
1458
1459 CARDbSetBeaconPeriod(priv, conf->beacon_int);
1460
1461 return vnt_beacon_make(priv, vif);
1462 }
1463