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