This source file includes following definitions.
- vnt_time_stamp_off
- s_uGetTxRsvTime
- vnt_rxtx_rsvtime_le16
- s_uGetRTSCTSRsvTime
- s_uGetDataDuration
- s_uGetRTSCTSDuration
- s_uFillDataHead
- s_vFillRTSHead
- s_vFillCTSHead
- s_vGenerateTxParameter
- s_cbFillTxBufHead
- vnt_fill_txkey
- vnt_generate_fifo_header
- vnt_beacon_xmit
- vnt_beacon_make
- vnt_beacon_enable
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
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
46
47
48
49
50
51
52
53
54
55
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},
61 {384, 192, 130, 113, 54, 43, 37, 31, 28, 25, 24, 23},
62 };
63
64 static const unsigned short wFB_Opt0[2][5] = {
65 {RATE_12M, RATE_18M, RATE_24M, RATE_36M, RATE_48M},
66 {RATE_12M, RATE_12M, RATE_18M, RATE_24M, RATE_36M},
67 };
68
69 static const unsigned short wFB_Opt1[2][5] = {
70 {RATE_12M, RATE_18M, RATE_24M, RATE_24M, RATE_36M},
71 {RATE_6M, RATE_6M, RATE_12M, RATE_12M, RATE_18M},
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
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
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
152
153
154
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 = BBuGetFrameTime(pDevice->byPreambleType, byPktType, cbFrameLength, wRate);
169 if (byPktType == PK_TYPE_11B)
170 uAckTime = BBuGetFrameTime(pDevice->byPreambleType, byPktType, 14, (unsigned short)pDevice->byTopCCKBasicRate);
171 else
172 uAckTime = BBuGetFrameTime(pDevice->byPreambleType, byPktType, 14, (unsigned short)pDevice->byTopOFDMBasicRate);
173
174 if (bNeedAck)
175 return uDataTime + pDevice->uSIFS + uAckTime;
176 else
177 return uDataTime;
178 }
179
180 static __le16 vnt_rxtx_rsvtime_le16(struct vnt_private *priv, u8 pkt_type,
181 u32 frame_length, u16 rate, bool need_ack)
182 {
183 return cpu_to_le16((u16)s_uGetTxRsvTime(priv, pkt_type,
184 frame_length, rate, need_ack));
185 }
186
187
188 static
189 __le16
190 s_uGetRTSCTSRsvTime(
191 struct vnt_private *pDevice,
192 unsigned char byRTSRsvType,
193 unsigned char byPktType,
194 unsigned int cbFrameLength,
195 unsigned short wCurrentRate
196 )
197 {
198 unsigned int uRrvTime, uRTSTime, uCTSTime, uAckTime, uDataTime;
199
200 uRrvTime = uRTSTime = uCTSTime = uAckTime = uDataTime = 0;
201
202 uDataTime = BBuGetFrameTime(pDevice->byPreambleType, byPktType, cbFrameLength, wCurrentRate);
203 if (byRTSRsvType == 0) {
204 uRTSTime = BBuGetFrameTime(pDevice->byPreambleType, byPktType, 20, pDevice->byTopCCKBasicRate);
205 uCTSTime = uAckTime = BBuGetFrameTime(pDevice->byPreambleType, byPktType, 14, pDevice->byTopCCKBasicRate);
206 } else if (byRTSRsvType == 1) {
207 uRTSTime = BBuGetFrameTime(pDevice->byPreambleType, byPktType, 20, pDevice->byTopCCKBasicRate);
208 uCTSTime = BBuGetFrameTime(pDevice->byPreambleType, byPktType, 14, pDevice->byTopCCKBasicRate);
209 uAckTime = BBuGetFrameTime(pDevice->byPreambleType, byPktType, 14, pDevice->byTopOFDMBasicRate);
210 } else if (byRTSRsvType == 2) {
211 uRTSTime = BBuGetFrameTime(pDevice->byPreambleType, byPktType, 20, pDevice->byTopOFDMBasicRate);
212 uCTSTime = uAckTime = BBuGetFrameTime(pDevice->byPreambleType, byPktType, 14, pDevice->byTopOFDMBasicRate);
213 } else if (byRTSRsvType == 3) {
214 uCTSTime = BBuGetFrameTime(pDevice->byPreambleType, byPktType, 14, pDevice->byTopCCKBasicRate);
215 uAckTime = BBuGetFrameTime(pDevice->byPreambleType, byPktType, 14, pDevice->byTopOFDMBasicRate);
216 uRrvTime = uCTSTime + uAckTime + uDataTime + 2 * pDevice->uSIFS;
217 return cpu_to_le16((u16)uRrvTime);
218 }
219
220
221 uRrvTime = uRTSTime + uCTSTime + uAckTime + uDataTime + 3 * pDevice->uSIFS;
222 return cpu_to_le16((u16)uRrvTime);
223 }
224
225
226 static
227 unsigned int
228 s_uGetDataDuration(
229 struct vnt_private *pDevice,
230 unsigned char byDurType,
231 unsigned int cbFrameLength,
232 unsigned char byPktType,
233 unsigned short wRate,
234 bool bNeedAck,
235 unsigned int uFragIdx,
236 unsigned int cbLastFragmentSize,
237 unsigned int uMACfragNum,
238 unsigned char byFBOption
239 )
240 {
241 bool bLastFrag = false;
242 unsigned int uAckTime = 0, uNextPktTime = 0;
243
244 if (uFragIdx == (uMACfragNum - 1))
245 bLastFrag = true;
246
247 switch (byDurType) {
248 case DATADUR_B:
249 if (((uMACfragNum == 1)) || bLastFrag) {
250 if (bNeedAck) {
251 uAckTime = BBuGetFrameTime(pDevice->byPreambleType, byPktType, 14, pDevice->byTopCCKBasicRate);
252 return pDevice->uSIFS + uAckTime;
253 } else {
254 return 0;
255 }
256 } else {
257 if (uFragIdx == (uMACfragNum - 2))
258 uNextPktTime = s_uGetTxRsvTime(pDevice, byPktType, cbLastFragmentSize, wRate, bNeedAck);
259 else
260 uNextPktTime = s_uGetTxRsvTime(pDevice, byPktType, cbFrameLength, wRate, bNeedAck);
261
262 if (bNeedAck) {
263 uAckTime = BBuGetFrameTime(pDevice->byPreambleType, byPktType, 14, pDevice->byTopCCKBasicRate);
264 return pDevice->uSIFS + uAckTime + uNextPktTime;
265 } else {
266 return pDevice->uSIFS + uNextPktTime;
267 }
268 }
269 break;
270
271 case DATADUR_A:
272 if (((uMACfragNum == 1)) || bLastFrag) {
273 if (bNeedAck) {
274 uAckTime = BBuGetFrameTime(pDevice->byPreambleType, byPktType, 14, pDevice->byTopOFDMBasicRate);
275 return pDevice->uSIFS + uAckTime;
276 } else {
277 return 0;
278 }
279 } else {
280 if (uFragIdx == (uMACfragNum - 2))
281 uNextPktTime = s_uGetTxRsvTime(pDevice, byPktType, cbLastFragmentSize, wRate, bNeedAck);
282 else
283 uNextPktTime = s_uGetTxRsvTime(pDevice, byPktType, cbFrameLength, wRate, bNeedAck);
284
285 if (bNeedAck) {
286 uAckTime = BBuGetFrameTime(pDevice->byPreambleType, byPktType, 14, pDevice->byTopOFDMBasicRate);
287 return pDevice->uSIFS + uAckTime + uNextPktTime;
288 } else {
289 return pDevice->uSIFS + uNextPktTime;
290 }
291 }
292 break;
293
294 case DATADUR_A_F0:
295 if (((uMACfragNum == 1)) || bLastFrag) {
296 if (bNeedAck) {
297 uAckTime = BBuGetFrameTime(pDevice->byPreambleType, byPktType, 14, pDevice->byTopOFDMBasicRate);
298 return pDevice->uSIFS + uAckTime;
299 } else {
300 return 0;
301 }
302 } else {
303 if (byFBOption == AUTO_FB_0) {
304 if (wRate < RATE_18M)
305 wRate = RATE_18M;
306 else if (wRate > RATE_54M)
307 wRate = RATE_54M;
308
309 if (uFragIdx == (uMACfragNum - 2))
310 uNextPktTime = s_uGetTxRsvTime(pDevice, byPktType, cbLastFragmentSize, wFB_Opt0[FB_RATE0][wRate-RATE_18M], bNeedAck);
311 else
312 uNextPktTime = s_uGetTxRsvTime(pDevice, byPktType, cbFrameLength, wFB_Opt0[FB_RATE0][wRate-RATE_18M], bNeedAck);
313
314 } else {
315 if (wRate < RATE_18M)
316 wRate = RATE_18M;
317 else if (wRate > RATE_54M)
318 wRate = RATE_54M;
319
320 if (uFragIdx == (uMACfragNum - 2))
321 uNextPktTime = s_uGetTxRsvTime(pDevice, byPktType, cbLastFragmentSize, wFB_Opt1[FB_RATE0][wRate-RATE_18M], bNeedAck);
322 else
323 uNextPktTime = s_uGetTxRsvTime(pDevice, byPktType, cbFrameLength, wFB_Opt1[FB_RATE0][wRate-RATE_18M], bNeedAck);
324 }
325
326 if (bNeedAck) {
327 uAckTime = BBuGetFrameTime(pDevice->byPreambleType, byPktType, 14, pDevice->byTopOFDMBasicRate);
328 return pDevice->uSIFS + uAckTime + uNextPktTime;
329 } else {
330 return pDevice->uSIFS + uNextPktTime;
331 }
332 }
333 break;
334
335 case DATADUR_A_F1:
336 if (((uMACfragNum == 1)) || bLastFrag) {
337 if (bNeedAck) {
338 uAckTime = BBuGetFrameTime(pDevice->byPreambleType, byPktType, 14, pDevice->byTopOFDMBasicRate);
339 return pDevice->uSIFS + uAckTime;
340 } else {
341 return 0;
342 }
343 } else {
344 if (byFBOption == AUTO_FB_0) {
345 if (wRate < RATE_18M)
346 wRate = RATE_18M;
347 else if (wRate > RATE_54M)
348 wRate = RATE_54M;
349
350 if (uFragIdx == (uMACfragNum - 2))
351 uNextPktTime = s_uGetTxRsvTime(pDevice, byPktType, cbLastFragmentSize, wFB_Opt0[FB_RATE1][wRate-RATE_18M], bNeedAck);
352 else
353 uNextPktTime = s_uGetTxRsvTime(pDevice, byPktType, cbFrameLength, wFB_Opt0[FB_RATE1][wRate-RATE_18M], bNeedAck);
354
355 } else {
356 if (wRate < RATE_18M)
357 wRate = RATE_18M;
358 else if (wRate > RATE_54M)
359 wRate = RATE_54M;
360
361 if (uFragIdx == (uMACfragNum - 2))
362 uNextPktTime = s_uGetTxRsvTime(pDevice, byPktType, cbLastFragmentSize, wFB_Opt1[FB_RATE1][wRate-RATE_18M], bNeedAck);
363 else
364 uNextPktTime = s_uGetTxRsvTime(pDevice, byPktType, cbFrameLength, wFB_Opt1[FB_RATE1][wRate-RATE_18M], bNeedAck);
365 }
366 if (bNeedAck) {
367 uAckTime = BBuGetFrameTime(pDevice->byPreambleType, byPktType, 14, pDevice->byTopOFDMBasicRate);
368 return pDevice->uSIFS + uAckTime + uNextPktTime;
369 } else {
370 return pDevice->uSIFS + uNextPktTime;
371 }
372 }
373 break;
374
375 default:
376 break;
377 }
378
379 return 0;
380 }
381
382
383 static
384 __le16
385 s_uGetRTSCTSDuration(
386 struct vnt_private *pDevice,
387 unsigned char byDurType,
388 unsigned int cbFrameLength,
389 unsigned char byPktType,
390 unsigned short wRate,
391 bool bNeedAck,
392 unsigned char byFBOption
393 )
394 {
395 unsigned int uCTSTime = 0, uDurTime = 0;
396
397 switch (byDurType) {
398 case RTSDUR_BB:
399 uCTSTime = BBuGetFrameTime(pDevice->byPreambleType, byPktType, 14, pDevice->byTopCCKBasicRate);
400 uDurTime = uCTSTime + 2 * pDevice->uSIFS + s_uGetTxRsvTime(pDevice, byPktType, cbFrameLength, wRate, bNeedAck);
401 break;
402
403 case RTSDUR_BA:
404 uCTSTime = BBuGetFrameTime(pDevice->byPreambleType, byPktType, 14, pDevice->byTopCCKBasicRate);
405 uDurTime = uCTSTime + 2 * pDevice->uSIFS + s_uGetTxRsvTime(pDevice, byPktType, cbFrameLength, wRate, bNeedAck);
406 break;
407
408 case RTSDUR_AA:
409 uCTSTime = BBuGetFrameTime(pDevice->byPreambleType, byPktType, 14, pDevice->byTopOFDMBasicRate);
410 uDurTime = uCTSTime + 2 * pDevice->uSIFS + s_uGetTxRsvTime(pDevice, byPktType, cbFrameLength, wRate, bNeedAck);
411 break;
412
413 case CTSDUR_BA:
414 uDurTime = pDevice->uSIFS + s_uGetTxRsvTime(pDevice, byPktType, cbFrameLength, wRate, bNeedAck);
415 break;
416
417 case RTSDUR_BA_F0:
418 uCTSTime = BBuGetFrameTime(pDevice->byPreambleType, byPktType, 14, pDevice->byTopCCKBasicRate);
419 if ((byFBOption == AUTO_FB_0) && (wRate >= RATE_18M) && (wRate <= RATE_54M))
420 uDurTime = uCTSTime + 2 * pDevice->uSIFS + s_uGetTxRsvTime(pDevice, byPktType, cbFrameLength, wFB_Opt0[FB_RATE0][wRate-RATE_18M], bNeedAck);
421 else if ((byFBOption == AUTO_FB_1) && (wRate >= RATE_18M) && (wRate <= RATE_54M))
422 uDurTime = uCTSTime + 2 * pDevice->uSIFS + s_uGetTxRsvTime(pDevice, byPktType, cbFrameLength, wFB_Opt1[FB_RATE0][wRate-RATE_18M], bNeedAck);
423
424 break;
425
426 case RTSDUR_AA_F0:
427 uCTSTime = BBuGetFrameTime(pDevice->byPreambleType, byPktType, 14, pDevice->byTopOFDMBasicRate);
428 if ((byFBOption == AUTO_FB_0) && (wRate >= RATE_18M) && (wRate <= RATE_54M))
429 uDurTime = uCTSTime + 2 * pDevice->uSIFS + s_uGetTxRsvTime(pDevice, byPktType, cbFrameLength, wFB_Opt0[FB_RATE0][wRate-RATE_18M], bNeedAck);
430 else if ((byFBOption == AUTO_FB_1) && (wRate >= RATE_18M) && (wRate <= RATE_54M))
431 uDurTime = uCTSTime + 2 * pDevice->uSIFS + s_uGetTxRsvTime(pDevice, byPktType, cbFrameLength, wFB_Opt1[FB_RATE0][wRate-RATE_18M], bNeedAck);
432
433 break;
434
435 case RTSDUR_BA_F1:
436 uCTSTime = BBuGetFrameTime(pDevice->byPreambleType, byPktType, 14, pDevice->byTopCCKBasicRate);
437 if ((byFBOption == AUTO_FB_0) && (wRate >= RATE_18M) && (wRate <= RATE_54M))
438 uDurTime = uCTSTime + 2*pDevice->uSIFS + s_uGetTxRsvTime(pDevice, byPktType, cbFrameLength, wFB_Opt0[FB_RATE1][wRate-RATE_18M], bNeedAck);
439 else if ((byFBOption == AUTO_FB_1) && (wRate >= RATE_18M) && (wRate <= RATE_54M))
440 uDurTime = uCTSTime + 2 * pDevice->uSIFS + s_uGetTxRsvTime(pDevice, byPktType, cbFrameLength, wFB_Opt1[FB_RATE1][wRate-RATE_18M], bNeedAck);
441
442 break;
443
444 case RTSDUR_AA_F1:
445 uCTSTime = BBuGetFrameTime(pDevice->byPreambleType, byPktType, 14, pDevice->byTopOFDMBasicRate);
446 if ((byFBOption == AUTO_FB_0) && (wRate >= RATE_18M) && (wRate <= RATE_54M))
447 uDurTime = uCTSTime + 2 * pDevice->uSIFS + s_uGetTxRsvTime(pDevice, byPktType, cbFrameLength, wFB_Opt0[FB_RATE1][wRate-RATE_18M], bNeedAck);
448 else if ((byFBOption == AUTO_FB_1) && (wRate >= RATE_18M) && (wRate <= RATE_54M))
449 uDurTime = uCTSTime + 2 * pDevice->uSIFS + s_uGetTxRsvTime(pDevice, byPktType, cbFrameLength, wFB_Opt1[FB_RATE1][wRate-RATE_18M], bNeedAck);
450
451 break;
452
453 case CTSDUR_BA_F0:
454 if ((byFBOption == AUTO_FB_0) && (wRate >= RATE_18M) && (wRate <= RATE_54M))
455 uDurTime = pDevice->uSIFS + s_uGetTxRsvTime(pDevice, byPktType, cbFrameLength, wFB_Opt0[FB_RATE0][wRate-RATE_18M], bNeedAck);
456 else if ((byFBOption == AUTO_FB_1) && (wRate >= RATE_18M) && (wRate <= RATE_54M))
457 uDurTime = pDevice->uSIFS + s_uGetTxRsvTime(pDevice, byPktType, cbFrameLength, wFB_Opt1[FB_RATE0][wRate-RATE_18M], bNeedAck);
458
459 break;
460
461 case CTSDUR_BA_F1:
462 if ((byFBOption == AUTO_FB_0) && (wRate >= RATE_18M) && (wRate <= RATE_54M))
463 uDurTime = pDevice->uSIFS + s_uGetTxRsvTime(pDevice, byPktType, cbFrameLength, wFB_Opt0[FB_RATE1][wRate-RATE_18M], bNeedAck);
464 else if ((byFBOption == AUTO_FB_1) && (wRate >= RATE_18M) && (wRate <= RATE_54M))
465 uDurTime = pDevice->uSIFS + s_uGetTxRsvTime(pDevice, byPktType, cbFrameLength, wFB_Opt1[FB_RATE1][wRate-RATE_18M], bNeedAck);
466
467 break;
468
469 default:
470 break;
471 }
472
473 return cpu_to_le16((u16)uDurTime);
474 }
475
476 static
477 __le16
478 s_uFillDataHead(
479 struct vnt_private *pDevice,
480 unsigned char byPktType,
481 void *pTxDataHead,
482 unsigned int cbFrameLength,
483 unsigned int uDMAIdx,
484 bool bNeedAck,
485 unsigned int uFragIdx,
486 unsigned int cbLastFragmentSize,
487 unsigned int uMACfragNum,
488 unsigned char byFBOption,
489 unsigned short wCurrentRate,
490 bool is_pspoll
491 )
492 {
493 if (!pTxDataHead)
494 return 0;
495
496 if (byPktType == PK_TYPE_11GB || byPktType == PK_TYPE_11GA) {
497 if (byFBOption == AUTO_FB_NONE) {
498 struct vnt_tx_datahead_g *buf = pTxDataHead;
499
500 vnt_get_phy_field(pDevice, cbFrameLength, wCurrentRate,
501 byPktType, &buf->a);
502
503 vnt_get_phy_field(pDevice, cbFrameLength,
504 pDevice->byTopCCKBasicRate,
505 PK_TYPE_11B, &buf->b);
506
507 if (is_pspoll) {
508 __le16 dur = cpu_to_le16(pDevice->current_aid | BIT(14) | BIT(15));
509
510 buf->duration_a = dur;
511 buf->duration_b = dur;
512 } else {
513
514 buf->duration_a =
515 cpu_to_le16((u16)s_uGetDataDuration(pDevice, DATADUR_A, cbFrameLength,
516 byPktType, wCurrentRate, bNeedAck, uFragIdx,
517 cbLastFragmentSize, uMACfragNum,
518 byFBOption));
519 buf->duration_b =
520 cpu_to_le16((u16)s_uGetDataDuration(pDevice, DATADUR_B, cbFrameLength,
521 PK_TYPE_11B, pDevice->byTopCCKBasicRate,
522 bNeedAck, uFragIdx, cbLastFragmentSize,
523 uMACfragNum, byFBOption));
524 }
525
526 buf->time_stamp_off_a = vnt_time_stamp_off(pDevice, wCurrentRate);
527 buf->time_stamp_off_b = vnt_time_stamp_off(pDevice, pDevice->byTopCCKBasicRate);
528
529 return buf->duration_a;
530 } else {
531
532 struct vnt_tx_datahead_g_fb *buf = pTxDataHead;
533
534 vnt_get_phy_field(pDevice, cbFrameLength, wCurrentRate,
535 byPktType, &buf->a);
536
537 vnt_get_phy_field(pDevice, cbFrameLength,
538 pDevice->byTopCCKBasicRate,
539 PK_TYPE_11B, &buf->b);
540
541 buf->duration_a = cpu_to_le16((u16)s_uGetDataDuration(pDevice, DATADUR_A, cbFrameLength, byPktType,
542 wCurrentRate, bNeedAck, uFragIdx, cbLastFragmentSize, uMACfragNum, byFBOption));
543 buf->duration_b = cpu_to_le16((u16)s_uGetDataDuration(pDevice, DATADUR_B, cbFrameLength, PK_TYPE_11B,
544 pDevice->byTopCCKBasicRate, bNeedAck, uFragIdx, cbLastFragmentSize, uMACfragNum, byFBOption));
545 buf->duration_a_f0 = cpu_to_le16((u16)s_uGetDataDuration(pDevice, DATADUR_A_F0, cbFrameLength, byPktType,
546 wCurrentRate, bNeedAck, uFragIdx, cbLastFragmentSize, uMACfragNum, byFBOption));
547 buf->duration_a_f1 = cpu_to_le16((u16)s_uGetDataDuration(pDevice, DATADUR_A_F1, cbFrameLength, byPktType,
548 wCurrentRate, bNeedAck, uFragIdx, cbLastFragmentSize, uMACfragNum, byFBOption));
549
550 buf->time_stamp_off_a = vnt_time_stamp_off(pDevice, wCurrentRate);
551 buf->time_stamp_off_b = vnt_time_stamp_off(pDevice, pDevice->byTopCCKBasicRate);
552
553 return buf->duration_a;
554 }
555 } else if (byPktType == PK_TYPE_11A) {
556 if (byFBOption != AUTO_FB_NONE) {
557
558 struct vnt_tx_datahead_a_fb *buf = pTxDataHead;
559
560 vnt_get_phy_field(pDevice, cbFrameLength, wCurrentRate,
561 byPktType, &buf->a);
562
563
564 buf->duration = cpu_to_le16((u16)s_uGetDataDuration(pDevice, DATADUR_A, cbFrameLength, byPktType,
565 wCurrentRate, bNeedAck, uFragIdx, cbLastFragmentSize, uMACfragNum, byFBOption));
566 buf->duration_f0 = cpu_to_le16((u16)s_uGetDataDuration(pDevice, DATADUR_A_F0, cbFrameLength, byPktType,
567 wCurrentRate, bNeedAck, uFragIdx, cbLastFragmentSize, uMACfragNum, byFBOption));
568 buf->duration_f1 = cpu_to_le16((u16)s_uGetDataDuration(pDevice, DATADUR_A_F1, cbFrameLength, byPktType,
569 wCurrentRate, bNeedAck, uFragIdx, cbLastFragmentSize, uMACfragNum, byFBOption));
570 buf->time_stamp_off = vnt_time_stamp_off(pDevice, wCurrentRate);
571 return buf->duration;
572 } else {
573 struct vnt_tx_datahead_ab *buf = pTxDataHead;
574
575 vnt_get_phy_field(pDevice, cbFrameLength, wCurrentRate,
576 byPktType, &buf->ab);
577
578 if (is_pspoll) {
579 __le16 dur = cpu_to_le16(pDevice->current_aid | BIT(14) | BIT(15));
580
581 buf->duration = dur;
582 } else {
583
584 buf->duration =
585 cpu_to_le16((u16)s_uGetDataDuration(pDevice, DATADUR_A, cbFrameLength, byPktType,
586 wCurrentRate, bNeedAck, uFragIdx,
587 cbLastFragmentSize, uMACfragNum,
588 byFBOption));
589 }
590
591 buf->time_stamp_off = vnt_time_stamp_off(pDevice, wCurrentRate);
592 return buf->duration;
593 }
594 } else {
595 struct vnt_tx_datahead_ab *buf = pTxDataHead;
596
597 vnt_get_phy_field(pDevice, cbFrameLength, wCurrentRate,
598 byPktType, &buf->ab);
599
600 if (is_pspoll) {
601 __le16 dur = cpu_to_le16(pDevice->current_aid | BIT(14) | BIT(15));
602
603 buf->duration = dur;
604 } else {
605
606 buf->duration =
607 cpu_to_le16((u16)s_uGetDataDuration(pDevice, DATADUR_B, cbFrameLength, byPktType,
608 wCurrentRate, bNeedAck, uFragIdx,
609 cbLastFragmentSize, uMACfragNum,
610 byFBOption));
611 }
612
613 buf->time_stamp_off = vnt_time_stamp_off(pDevice, wCurrentRate);
614 return buf->duration;
615 }
616 return 0;
617 }
618
619 static
620 void
621 s_vFillRTSHead(
622 struct vnt_private *pDevice,
623 unsigned char byPktType,
624 void *pvRTS,
625 unsigned int cbFrameLength,
626 bool bNeedAck,
627 bool bDisCRC,
628 struct ieee80211_hdr *hdr,
629 unsigned short wCurrentRate,
630 unsigned char byFBOption
631 )
632 {
633 unsigned int uRTSFrameLen = 20;
634
635 if (!pvRTS)
636 return;
637
638 if (bDisCRC) {
639
640
641
642 uRTSFrameLen -= 4;
643 }
644
645
646
647
648
649 if (byPktType == PK_TYPE_11GB || byPktType == PK_TYPE_11GA) {
650 if (byFBOption == AUTO_FB_NONE) {
651 struct vnt_rts_g *buf = pvRTS;
652
653 vnt_get_phy_field(pDevice, uRTSFrameLen,
654 pDevice->byTopCCKBasicRate,
655 PK_TYPE_11B, &buf->b);
656
657 vnt_get_phy_field(pDevice, uRTSFrameLen,
658 pDevice->byTopOFDMBasicRate,
659 byPktType, &buf->a);
660
661 buf->duration_bb =
662 s_uGetRTSCTSDuration(pDevice, RTSDUR_BB,
663 cbFrameLength, PK_TYPE_11B,
664 pDevice->byTopCCKBasicRate,
665 bNeedAck, byFBOption);
666 buf->duration_aa =
667 s_uGetRTSCTSDuration(pDevice, RTSDUR_AA,
668 cbFrameLength, byPktType,
669 wCurrentRate, bNeedAck,
670 byFBOption);
671 buf->duration_ba =
672 s_uGetRTSCTSDuration(pDevice, RTSDUR_BA,
673 cbFrameLength, byPktType,
674 wCurrentRate, bNeedAck,
675 byFBOption);
676
677 buf->data.duration = buf->duration_aa;
678
679 buf->data.frame_control =
680 cpu_to_le16(IEEE80211_FTYPE_CTL |
681 IEEE80211_STYPE_RTS);
682
683 ether_addr_copy(buf->data.ra, hdr->addr1);
684 ether_addr_copy(buf->data.ta, hdr->addr2);
685 } else {
686 struct vnt_rts_g_fb *buf = pvRTS;
687
688 vnt_get_phy_field(pDevice, uRTSFrameLen,
689 pDevice->byTopCCKBasicRate,
690 PK_TYPE_11B, &buf->b);
691
692 vnt_get_phy_field(pDevice, uRTSFrameLen,
693 pDevice->byTopOFDMBasicRate,
694 byPktType, &buf->a);
695
696 buf->duration_bb =
697 s_uGetRTSCTSDuration(pDevice, RTSDUR_BB,
698 cbFrameLength, PK_TYPE_11B,
699 pDevice->byTopCCKBasicRate,
700 bNeedAck, byFBOption);
701 buf->duration_aa =
702 s_uGetRTSCTSDuration(pDevice, RTSDUR_AA,
703 cbFrameLength, byPktType,
704 wCurrentRate, bNeedAck,
705 byFBOption);
706 buf->duration_ba =
707 s_uGetRTSCTSDuration(pDevice, RTSDUR_BA,
708 cbFrameLength, byPktType,
709 wCurrentRate, bNeedAck,
710 byFBOption);
711 buf->rts_duration_ba_f0 =
712 s_uGetRTSCTSDuration(pDevice, RTSDUR_BA_F0,
713 cbFrameLength, byPktType,
714 wCurrentRate, bNeedAck,
715 byFBOption);
716 buf->rts_duration_aa_f0 =
717 s_uGetRTSCTSDuration(pDevice, RTSDUR_AA_F0,
718 cbFrameLength, byPktType,
719 wCurrentRate, bNeedAck,
720 byFBOption);
721 buf->rts_duration_ba_f1 =
722 s_uGetRTSCTSDuration(pDevice, RTSDUR_BA_F1,
723 cbFrameLength, byPktType,
724 wCurrentRate, bNeedAck,
725 byFBOption);
726 buf->rts_duration_aa_f1 =
727 s_uGetRTSCTSDuration(pDevice, RTSDUR_AA_F1,
728 cbFrameLength, byPktType,
729 wCurrentRate, bNeedAck,
730 byFBOption);
731 buf->data.duration = buf->duration_aa;
732
733 buf->data.frame_control =
734 cpu_to_le16(IEEE80211_FTYPE_CTL |
735 IEEE80211_STYPE_RTS);
736
737 ether_addr_copy(buf->data.ra, hdr->addr1);
738 ether_addr_copy(buf->data.ta, hdr->addr2);
739 }
740 } else if (byPktType == PK_TYPE_11A) {
741 if (byFBOption == AUTO_FB_NONE) {
742 struct vnt_rts_ab *buf = pvRTS;
743
744 vnt_get_phy_field(pDevice, uRTSFrameLen,
745 pDevice->byTopOFDMBasicRate,
746 byPktType, &buf->ab);
747
748 buf->duration =
749 s_uGetRTSCTSDuration(pDevice, RTSDUR_AA,
750 cbFrameLength, byPktType,
751 wCurrentRate, bNeedAck,
752 byFBOption);
753 buf->data.duration = buf->duration;
754
755 buf->data.frame_control =
756 cpu_to_le16(IEEE80211_FTYPE_CTL |
757 IEEE80211_STYPE_RTS);
758
759 ether_addr_copy(buf->data.ra, hdr->addr1);
760 ether_addr_copy(buf->data.ta, hdr->addr2);
761 } else {
762 struct vnt_rts_a_fb *buf = pvRTS;
763
764 vnt_get_phy_field(pDevice, uRTSFrameLen,
765 pDevice->byTopOFDMBasicRate,
766 byPktType, &buf->a);
767
768 buf->duration =
769 s_uGetRTSCTSDuration(pDevice, RTSDUR_AA,
770 cbFrameLength, byPktType,
771 wCurrentRate, bNeedAck,
772 byFBOption);
773 buf->rts_duration_f0 =
774 s_uGetRTSCTSDuration(pDevice, RTSDUR_AA_F0,
775 cbFrameLength, byPktType,
776 wCurrentRate, bNeedAck,
777 byFBOption);
778 buf->rts_duration_f1 =
779 s_uGetRTSCTSDuration(pDevice, RTSDUR_AA_F1,
780 cbFrameLength, byPktType,
781 wCurrentRate, bNeedAck,
782 byFBOption);
783 buf->data.duration = buf->duration;
784
785 buf->data.frame_control =
786 cpu_to_le16(IEEE80211_FTYPE_CTL |
787 IEEE80211_STYPE_RTS);
788
789 ether_addr_copy(buf->data.ra, hdr->addr1);
790 ether_addr_copy(buf->data.ta, hdr->addr2);
791 }
792 } else if (byPktType == PK_TYPE_11B) {
793 struct vnt_rts_ab *buf = pvRTS;
794
795 vnt_get_phy_field(pDevice, uRTSFrameLen,
796 pDevice->byTopCCKBasicRate,
797 PK_TYPE_11B, &buf->ab);
798
799 buf->duration =
800 s_uGetRTSCTSDuration(pDevice, RTSDUR_BB, cbFrameLength,
801 byPktType, wCurrentRate, bNeedAck,
802 byFBOption);
803
804 buf->data.duration = buf->duration;
805
806 buf->data.frame_control =
807 cpu_to_le16(IEEE80211_FTYPE_CTL | IEEE80211_STYPE_RTS);
808
809 ether_addr_copy(buf->data.ra, hdr->addr1);
810 ether_addr_copy(buf->data.ta, hdr->addr2);
811 }
812 }
813
814 static
815 void
816 s_vFillCTSHead(
817 struct vnt_private *pDevice,
818 unsigned int uDMAIdx,
819 unsigned char byPktType,
820 void *pvCTS,
821 unsigned int cbFrameLength,
822 bool bNeedAck,
823 bool bDisCRC,
824 unsigned short wCurrentRate,
825 unsigned char byFBOption
826 )
827 {
828 unsigned int uCTSFrameLen = 14;
829
830 if (!pvCTS)
831 return;
832
833 if (bDisCRC) {
834
835
836
837 uCTSFrameLen -= 4;
838 }
839
840 if (byPktType == PK_TYPE_11GB || byPktType == PK_TYPE_11GA) {
841 if (byFBOption != AUTO_FB_NONE && uDMAIdx != TYPE_ATIMDMA && uDMAIdx != TYPE_BEACONDMA) {
842
843 struct vnt_cts_fb *buf = pvCTS;
844
845 vnt_get_phy_field(pDevice, uCTSFrameLen,
846 pDevice->byTopCCKBasicRate,
847 PK_TYPE_11B, &buf->b);
848
849 buf->duration_ba =
850 s_uGetRTSCTSDuration(pDevice, CTSDUR_BA,
851 cbFrameLength, byPktType,
852 wCurrentRate, bNeedAck,
853 byFBOption);
854
855
856 buf->cts_duration_ba_f0 =
857 s_uGetRTSCTSDuration(pDevice, CTSDUR_BA_F0,
858 cbFrameLength, byPktType,
859 wCurrentRate, bNeedAck,
860 byFBOption);
861
862
863 buf->cts_duration_ba_f1 =
864 s_uGetRTSCTSDuration(pDevice, CTSDUR_BA_F1,
865 cbFrameLength, byPktType,
866 wCurrentRate, bNeedAck,
867 byFBOption);
868
869
870 buf->data.duration = buf->duration_ba;
871
872 buf->data.frame_control =
873 cpu_to_le16(IEEE80211_FTYPE_CTL |
874 IEEE80211_STYPE_CTS);
875
876 buf->reserved2 = 0x0;
877
878 ether_addr_copy(buf->data.ra,
879 pDevice->abyCurrentNetAddr);
880 } else {
881 struct vnt_cts *buf = pvCTS;
882
883 vnt_get_phy_field(pDevice, uCTSFrameLen,
884 pDevice->byTopCCKBasicRate,
885 PK_TYPE_11B, &buf->b);
886
887
888 buf->duration_ba =
889 s_uGetRTSCTSDuration(pDevice, CTSDUR_BA,
890 cbFrameLength, byPktType,
891 wCurrentRate, bNeedAck,
892 byFBOption);
893
894
895 buf->data.duration = buf->duration_ba;
896
897 buf->data.frame_control =
898 cpu_to_le16(IEEE80211_FTYPE_CTL |
899 IEEE80211_STYPE_CTS);
900
901 buf->reserved2 = 0x0;
902 ether_addr_copy(buf->data.ra,
903 pDevice->abyCurrentNetAddr);
904 }
905 }
906 }
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932 static
933 void
934 s_vGenerateTxParameter(
935 struct vnt_private *pDevice,
936 unsigned char byPktType,
937 struct vnt_tx_fifo_head *tx_buffer_head,
938 void *pvRrvTime,
939 void *pvRTS,
940 void *pvCTS,
941 unsigned int cbFrameSize,
942 bool bNeedACK,
943 unsigned int uDMAIdx,
944 void *psEthHeader,
945 unsigned short wCurrentRate
946 )
947 {
948 u16 fifo_ctl = le16_to_cpu(tx_buffer_head->fifo_ctl);
949 bool bDisCRC = false;
950 unsigned char byFBOption = AUTO_FB_NONE;
951
952 tx_buffer_head->current_rate = cpu_to_le16(wCurrentRate);
953
954 if (fifo_ctl & FIFOCTL_CRCDIS)
955 bDisCRC = true;
956
957 if (fifo_ctl & FIFOCTL_AUTO_FB_0)
958 byFBOption = AUTO_FB_0;
959 else if (fifo_ctl & FIFOCTL_AUTO_FB_1)
960 byFBOption = AUTO_FB_1;
961
962 if (!pvRrvTime)
963 return;
964
965 if (byPktType == PK_TYPE_11GB || byPktType == PK_TYPE_11GA) {
966 if (pvRTS) {
967
968 struct vnt_rrv_time_rts *buf = pvRrvTime;
969
970 buf->rts_rrv_time_aa = s_uGetRTSCTSRsvTime(pDevice, 2, byPktType, cbFrameSize, wCurrentRate);
971 buf->rts_rrv_time_ba = s_uGetRTSCTSRsvTime(pDevice, 1, byPktType, cbFrameSize, wCurrentRate);
972 buf->rts_rrv_time_bb = s_uGetRTSCTSRsvTime(pDevice, 0, byPktType, cbFrameSize, wCurrentRate);
973 buf->rrv_time_a = vnt_rxtx_rsvtime_le16(pDevice, byPktType, cbFrameSize, wCurrentRate, bNeedACK);
974 buf->rrv_time_b = vnt_rxtx_rsvtime_le16(pDevice, PK_TYPE_11B, cbFrameSize, pDevice->byTopCCKBasicRate, bNeedACK);
975
976 s_vFillRTSHead(pDevice, byPktType, pvRTS, cbFrameSize, bNeedACK, bDisCRC, psEthHeader, wCurrentRate, byFBOption);
977 } else {
978 struct vnt_rrv_time_cts *buf = pvRrvTime;
979
980 buf->rrv_time_a = vnt_rxtx_rsvtime_le16(pDevice, byPktType, cbFrameSize, wCurrentRate, bNeedACK);
981 buf->rrv_time_b = vnt_rxtx_rsvtime_le16(pDevice, PK_TYPE_11B, cbFrameSize, pDevice->byTopCCKBasicRate, bNeedACK);
982 buf->cts_rrv_time_ba = s_uGetRTSCTSRsvTime(pDevice, 3, byPktType, cbFrameSize, wCurrentRate);
983
984
985 s_vFillCTSHead(pDevice, uDMAIdx, byPktType, pvCTS, cbFrameSize, bNeedACK, bDisCRC, wCurrentRate, byFBOption);
986 }
987 } else if (byPktType == PK_TYPE_11A) {
988 if (pvRTS) {
989 struct vnt_rrv_time_ab *buf = pvRrvTime;
990
991 buf->rts_rrv_time = s_uGetRTSCTSRsvTime(pDevice, 2, byPktType, cbFrameSize, wCurrentRate);
992 buf->rrv_time = vnt_rxtx_rsvtime_le16(pDevice, byPktType, cbFrameSize, wCurrentRate, bNeedACK);
993
994
995 s_vFillRTSHead(pDevice, byPktType, pvRTS, cbFrameSize, bNeedACK, bDisCRC, psEthHeader, wCurrentRate, byFBOption);
996 } else if (!pvRTS) {
997 struct vnt_rrv_time_ab *buf = pvRrvTime;
998
999 buf->rrv_time = vnt_rxtx_rsvtime_le16(pDevice, PK_TYPE_11A, cbFrameSize, wCurrentRate, bNeedACK);
1000 }
1001 } else if (byPktType == PK_TYPE_11B) {
1002 if (pvRTS) {
1003 struct vnt_rrv_time_ab *buf = pvRrvTime;
1004
1005 buf->rts_rrv_time = s_uGetRTSCTSRsvTime(pDevice, 0, byPktType, cbFrameSize, wCurrentRate);
1006 buf->rrv_time = vnt_rxtx_rsvtime_le16(pDevice, PK_TYPE_11B, cbFrameSize, wCurrentRate, bNeedACK);
1007
1008
1009 s_vFillRTSHead(pDevice, byPktType, pvRTS, cbFrameSize, bNeedACK, bDisCRC, psEthHeader, wCurrentRate, byFBOption);
1010 } else {
1011 struct vnt_rrv_time_ab *buf = pvRrvTime;
1012
1013 buf->rrv_time = vnt_rxtx_rsvtime_le16(pDevice, PK_TYPE_11B, cbFrameSize, wCurrentRate, bNeedACK);
1014 }
1015 }
1016 }
1017
1018 static unsigned int
1019 s_cbFillTxBufHead(struct vnt_private *pDevice, unsigned char byPktType,
1020 unsigned char *pbyTxBufferAddr,
1021 unsigned int uDMAIdx, struct vnt_tx_desc *pHeadTD,
1022 unsigned int is_pspoll)
1023 {
1024 struct vnt_td_info *td_info = pHeadTD->td_info;
1025 struct sk_buff *skb = td_info->skb;
1026 struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
1027 struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)skb->data;
1028 struct vnt_tx_fifo_head *tx_buffer_head =
1029 (struct vnt_tx_fifo_head *)td_info->buf;
1030 u16 fifo_ctl = le16_to_cpu(tx_buffer_head->fifo_ctl);
1031 unsigned int cbFrameSize;
1032 __le16 uDuration;
1033 unsigned char *pbyBuffer;
1034 unsigned int uLength = 0;
1035 unsigned int cbMICHDR = 0;
1036 unsigned int uMACfragNum = 1;
1037 unsigned int uPadding = 0;
1038 unsigned int cbReqCount = 0;
1039 bool bNeedACK = (bool)(fifo_ctl & FIFOCTL_NEEDACK);
1040 bool bRTS = (bool)(fifo_ctl & FIFOCTL_RTS);
1041 struct vnt_tx_desc *ptdCurr;
1042 unsigned int cbHeaderLength = 0;
1043 void *pvRrvTime;
1044 struct vnt_mic_hdr *pMICHDR;
1045 void *pvRTS;
1046 void *pvCTS;
1047 void *pvTxDataHd;
1048 unsigned short wTxBufSize;
1049 unsigned char byFBOption = AUTO_FB_NONE;
1050
1051 pvRrvTime = pMICHDR = pvRTS = pvCTS = pvTxDataHd = NULL;
1052
1053 cbFrameSize = skb->len + 4;
1054
1055 if (info->control.hw_key) {
1056 switch (info->control.hw_key->cipher) {
1057 case WLAN_CIPHER_SUITE_CCMP:
1058 cbMICHDR = sizeof(struct vnt_mic_hdr);
1059 default:
1060 break;
1061 }
1062
1063 cbFrameSize += info->control.hw_key->icv_len;
1064
1065 if (pDevice->byLocalID > REV_ID_VT3253_A1) {
1066
1067 uPadding = 4 - (ieee80211_get_hdrlen_from_skb(skb) % 4);
1068 uPadding %= 4;
1069 }
1070 }
1071
1072
1073
1074
1075 if (fifo_ctl & FIFOCTL_AUTO_FB_0)
1076 byFBOption = AUTO_FB_0;
1077 else if (fifo_ctl & FIFOCTL_AUTO_FB_1)
1078 byFBOption = AUTO_FB_1;
1079
1080
1081 wTxBufSize = sizeof(struct vnt_tx_fifo_head);
1082 if (byPktType == PK_TYPE_11GB || byPktType == PK_TYPE_11GA) {
1083
1084 if (byFBOption == AUTO_FB_NONE) {
1085 if (bRTS) {
1086 pvRrvTime = (void *)(pbyTxBufferAddr + wTxBufSize);
1087 pMICHDR = (struct vnt_mic_hdr *)(pbyTxBufferAddr + wTxBufSize + sizeof(struct vnt_rrv_time_rts));
1088 pvRTS = (void *)(pbyTxBufferAddr + wTxBufSize + sizeof(struct vnt_rrv_time_rts) + cbMICHDR);
1089 pvCTS = NULL;
1090 pvTxDataHd = (void *)(pbyTxBufferAddr + wTxBufSize + sizeof(struct vnt_rrv_time_rts) +
1091 cbMICHDR + sizeof(struct vnt_rts_g));
1092 cbHeaderLength = wTxBufSize + sizeof(struct vnt_rrv_time_rts) +
1093 cbMICHDR + sizeof(struct vnt_rts_g) +
1094 sizeof(struct vnt_tx_datahead_g);
1095 } else {
1096 pvRrvTime = (void *)(pbyTxBufferAddr + wTxBufSize);
1097 pMICHDR = (struct vnt_mic_hdr *)(pbyTxBufferAddr + wTxBufSize + sizeof(struct vnt_rrv_time_cts));
1098 pvRTS = NULL;
1099 pvCTS = (void *) (pbyTxBufferAddr + wTxBufSize + sizeof(struct vnt_rrv_time_cts) + cbMICHDR);
1100 pvTxDataHd = (void *)(pbyTxBufferAddr + wTxBufSize +
1101 sizeof(struct vnt_rrv_time_cts) + cbMICHDR + sizeof(struct vnt_cts));
1102 cbHeaderLength = wTxBufSize + sizeof(struct vnt_rrv_time_cts) +
1103 cbMICHDR + sizeof(struct vnt_cts) + sizeof(struct vnt_tx_datahead_g);
1104 }
1105 } else {
1106
1107 if (bRTS) {
1108 pvRrvTime = (void *)(pbyTxBufferAddr + wTxBufSize);
1109 pMICHDR = (struct vnt_mic_hdr *)(pbyTxBufferAddr + wTxBufSize + sizeof(struct vnt_rrv_time_rts));
1110 pvRTS = (void *) (pbyTxBufferAddr + wTxBufSize + sizeof(struct vnt_rrv_time_rts) + cbMICHDR);
1111 pvCTS = NULL;
1112 pvTxDataHd = (void *)(pbyTxBufferAddr + wTxBufSize + sizeof(struct vnt_rrv_time_rts) +
1113 cbMICHDR + sizeof(struct vnt_rts_g_fb));
1114 cbHeaderLength = wTxBufSize + sizeof(struct vnt_rrv_time_rts) +
1115 cbMICHDR + sizeof(struct vnt_rts_g_fb) + sizeof(struct vnt_tx_datahead_g_fb);
1116 } else {
1117 pvRrvTime = (void *)(pbyTxBufferAddr + wTxBufSize);
1118 pMICHDR = (struct vnt_mic_hdr *)(pbyTxBufferAddr + wTxBufSize + sizeof(struct vnt_rrv_time_cts));
1119 pvRTS = NULL;
1120 pvCTS = (void *)(pbyTxBufferAddr + wTxBufSize + sizeof(struct vnt_rrv_time_cts) + cbMICHDR);
1121 pvTxDataHd = (void *)(pbyTxBufferAddr + wTxBufSize + sizeof(struct vnt_rrv_time_cts) +
1122 cbMICHDR + sizeof(struct vnt_cts_fb));
1123 cbHeaderLength = wTxBufSize + sizeof(struct vnt_rrv_time_cts) +
1124 cbMICHDR + sizeof(struct vnt_cts_fb) + sizeof(struct vnt_tx_datahead_g_fb);
1125 }
1126 }
1127 } else {
1128
1129 if (byFBOption == AUTO_FB_NONE) {
1130 if (bRTS) {
1131 pvRrvTime = (void *)(pbyTxBufferAddr + wTxBufSize);
1132 pMICHDR = (struct vnt_mic_hdr *)(pbyTxBufferAddr + wTxBufSize + sizeof(struct vnt_rrv_time_ab));
1133 pvRTS = (void *)(pbyTxBufferAddr + wTxBufSize + sizeof(struct vnt_rrv_time_ab) + cbMICHDR);
1134 pvCTS = NULL;
1135 pvTxDataHd = (void *)(pbyTxBufferAddr + wTxBufSize +
1136 sizeof(struct vnt_rrv_time_ab) + cbMICHDR + sizeof(struct vnt_rts_ab));
1137 cbHeaderLength = wTxBufSize + sizeof(struct vnt_rrv_time_ab) +
1138 cbMICHDR + sizeof(struct vnt_rts_ab) + sizeof(struct vnt_tx_datahead_ab);
1139 } else {
1140 pvRrvTime = (void *)(pbyTxBufferAddr + wTxBufSize);
1141 pMICHDR = (struct vnt_mic_hdr *)(pbyTxBufferAddr + wTxBufSize + sizeof(struct vnt_rrv_time_ab));
1142 pvRTS = NULL;
1143 pvCTS = NULL;
1144 pvTxDataHd = (void *)(pbyTxBufferAddr + wTxBufSize + sizeof(struct vnt_rrv_time_ab) + cbMICHDR);
1145 cbHeaderLength = wTxBufSize + sizeof(struct vnt_rrv_time_ab) +
1146 cbMICHDR + sizeof(struct vnt_tx_datahead_ab);
1147 }
1148 } else {
1149
1150 if (bRTS) {
1151 pvRrvTime = (void *)(pbyTxBufferAddr + wTxBufSize);
1152 pMICHDR = (struct vnt_mic_hdr *)(pbyTxBufferAddr + wTxBufSize + sizeof(struct vnt_rrv_time_ab));
1153 pvRTS = (void *)(pbyTxBufferAddr + wTxBufSize + sizeof(struct vnt_rrv_time_ab) + cbMICHDR);
1154 pvCTS = NULL;
1155 pvTxDataHd = (void *)(pbyTxBufferAddr + wTxBufSize +
1156 sizeof(struct vnt_rrv_time_ab) + cbMICHDR + sizeof(struct vnt_rts_a_fb));
1157 cbHeaderLength = wTxBufSize + sizeof(struct vnt_rrv_time_ab) +
1158 cbMICHDR + sizeof(struct vnt_rts_a_fb) + sizeof(struct vnt_tx_datahead_a_fb);
1159 } else {
1160 pvRrvTime = (void *)(pbyTxBufferAddr + wTxBufSize);
1161 pMICHDR = (struct vnt_mic_hdr *)(pbyTxBufferAddr + wTxBufSize + sizeof(struct vnt_rrv_time_ab));
1162 pvRTS = NULL;
1163 pvCTS = NULL;
1164 pvTxDataHd = (void *)(pbyTxBufferAddr + wTxBufSize + sizeof(struct vnt_rrv_time_ab) + cbMICHDR);
1165 cbHeaderLength = wTxBufSize + sizeof(struct vnt_rrv_time_ab) +
1166 cbMICHDR + sizeof(struct vnt_tx_datahead_a_fb);
1167 }
1168 }
1169 }
1170
1171 td_info->mic_hdr = pMICHDR;
1172
1173 memset((void *)(pbyTxBufferAddr + wTxBufSize), 0, (cbHeaderLength - wTxBufSize));
1174
1175
1176 s_vGenerateTxParameter(pDevice, byPktType, tx_buffer_head, pvRrvTime, pvRTS, pvCTS,
1177 cbFrameSize, bNeedACK, uDMAIdx, hdr, pDevice->wCurrentRate);
1178
1179 uDuration = s_uFillDataHead(pDevice, byPktType, pvTxDataHd, cbFrameSize, uDMAIdx, bNeedACK,
1180 0, 0, uMACfragNum, byFBOption, pDevice->wCurrentRate, is_pspoll);
1181
1182 hdr->duration_id = uDuration;
1183
1184 cbReqCount = cbHeaderLength + uPadding + skb->len;
1185 pbyBuffer = (unsigned char *)pHeadTD->td_info->buf;
1186 uLength = cbHeaderLength + uPadding;
1187
1188
1189 memcpy((pbyBuffer + uLength), skb->data, skb->len);
1190
1191 ptdCurr = pHeadTD;
1192
1193 ptdCurr->td_info->req_count = (u16)cbReqCount;
1194
1195 return cbHeaderLength;
1196 }
1197
1198 static void vnt_fill_txkey(struct ieee80211_hdr *hdr, u8 *key_buffer,
1199 struct ieee80211_key_conf *tx_key,
1200 struct sk_buff *skb, u16 payload_len,
1201 struct vnt_mic_hdr *mic_hdr)
1202 {
1203 u64 pn64;
1204 u8 *iv = ((u8 *)hdr + ieee80211_get_hdrlen_from_skb(skb));
1205
1206
1207 payload_len -= ieee80211_get_hdrlen_from_skb(skb);
1208 payload_len -= tx_key->icv_len;
1209
1210 switch (tx_key->cipher) {
1211 case WLAN_CIPHER_SUITE_WEP40:
1212 case WLAN_CIPHER_SUITE_WEP104:
1213 memcpy(key_buffer, iv, 3);
1214 memcpy(key_buffer + 3, tx_key->key, tx_key->keylen);
1215
1216 if (tx_key->keylen == WLAN_KEY_LEN_WEP40) {
1217 memcpy(key_buffer + 8, iv, 3);
1218 memcpy(key_buffer + 11,
1219 tx_key->key, WLAN_KEY_LEN_WEP40);
1220 }
1221
1222 break;
1223 case WLAN_CIPHER_SUITE_TKIP:
1224 ieee80211_get_tkip_p2k(tx_key, skb, key_buffer);
1225
1226 break;
1227 case WLAN_CIPHER_SUITE_CCMP:
1228
1229 if (!mic_hdr)
1230 return;
1231
1232 mic_hdr->id = 0x59;
1233 mic_hdr->payload_len = cpu_to_be16(payload_len);
1234 ether_addr_copy(mic_hdr->mic_addr2, hdr->addr2);
1235
1236 pn64 = atomic64_read(&tx_key->tx_pn);
1237 mic_hdr->ccmp_pn[5] = pn64;
1238 mic_hdr->ccmp_pn[4] = pn64 >> 8;
1239 mic_hdr->ccmp_pn[3] = pn64 >> 16;
1240 mic_hdr->ccmp_pn[2] = pn64 >> 24;
1241 mic_hdr->ccmp_pn[1] = pn64 >> 32;
1242 mic_hdr->ccmp_pn[0] = pn64 >> 40;
1243
1244 if (ieee80211_has_a4(hdr->frame_control))
1245 mic_hdr->hlen = cpu_to_be16(28);
1246 else
1247 mic_hdr->hlen = cpu_to_be16(22);
1248
1249 ether_addr_copy(mic_hdr->addr1, hdr->addr1);
1250 ether_addr_copy(mic_hdr->addr2, hdr->addr2);
1251 ether_addr_copy(mic_hdr->addr3, hdr->addr3);
1252
1253 mic_hdr->frame_control = cpu_to_le16(
1254 le16_to_cpu(hdr->frame_control) & 0xc78f);
1255 mic_hdr->seq_ctrl = cpu_to_le16(
1256 le16_to_cpu(hdr->seq_ctrl) & 0xf);
1257
1258 if (ieee80211_has_a4(hdr->frame_control))
1259 ether_addr_copy(mic_hdr->addr4, hdr->addr4);
1260
1261 memcpy(key_buffer, tx_key->key, WLAN_KEY_LEN_CCMP);
1262
1263 break;
1264 default:
1265 break;
1266 }
1267 }
1268
1269 int vnt_generate_fifo_header(struct vnt_private *priv, u32 dma_idx,
1270 struct vnt_tx_desc *head_td, struct sk_buff *skb)
1271 {
1272 struct vnt_td_info *td_info = head_td->td_info;
1273 struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
1274 struct ieee80211_tx_rate *tx_rate = &info->control.rates[0];
1275 struct ieee80211_rate *rate;
1276 struct ieee80211_key_conf *tx_key;
1277 struct ieee80211_hdr *hdr;
1278 struct vnt_tx_fifo_head *tx_buffer_head =
1279 (struct vnt_tx_fifo_head *)td_info->buf;
1280 u16 tx_body_size = skb->len, current_rate;
1281 u8 pkt_type;
1282 bool is_pspoll = false;
1283
1284 memset(tx_buffer_head, 0, sizeof(*tx_buffer_head));
1285
1286 hdr = (struct ieee80211_hdr *)(skb->data);
1287
1288 rate = ieee80211_get_tx_rate(priv->hw, info);
1289
1290 current_rate = rate->hw_value;
1291 if (priv->wCurrentRate != current_rate &&
1292 !(priv->hw->conf.flags & IEEE80211_CONF_OFFCHANNEL)) {
1293 priv->wCurrentRate = current_rate;
1294
1295 RFbSetPower(priv, priv->wCurrentRate,
1296 priv->hw->conf.chandef.chan->hw_value);
1297 }
1298
1299 if (current_rate > RATE_11M) {
1300 if (info->band == NL80211_BAND_5GHZ) {
1301 pkt_type = PK_TYPE_11A;
1302 } else {
1303 if (tx_rate->flags & IEEE80211_TX_RC_USE_CTS_PROTECT)
1304 pkt_type = PK_TYPE_11GB;
1305 else
1306 pkt_type = PK_TYPE_11GA;
1307 }
1308 } else {
1309 pkt_type = PK_TYPE_11B;
1310 }
1311
1312
1313 if (pkt_type == PK_TYPE_11A)
1314 tx_buffer_head->fifo_ctl = 0;
1315 else if (pkt_type == PK_TYPE_11B)
1316 tx_buffer_head->fifo_ctl = cpu_to_le16(FIFOCTL_11B);
1317 else if (pkt_type == PK_TYPE_11GB)
1318 tx_buffer_head->fifo_ctl = cpu_to_le16(FIFOCTL_11GB);
1319 else if (pkt_type == PK_TYPE_11GA)
1320 tx_buffer_head->fifo_ctl = cpu_to_le16(FIFOCTL_11GA);
1321
1322
1323 tx_buffer_head->fifo_ctl |= cpu_to_le16(FIFOCTL_GENINT);
1324
1325 if (!ieee80211_is_data(hdr->frame_control)) {
1326 tx_buffer_head->fifo_ctl |= cpu_to_le16(FIFOCTL_TMOEN);
1327 tx_buffer_head->fifo_ctl |= cpu_to_le16(FIFOCTL_ISDMA0);
1328 tx_buffer_head->time_stamp =
1329 cpu_to_le16(DEFAULT_MGN_LIFETIME_RES_64us);
1330 } else {
1331 tx_buffer_head->time_stamp =
1332 cpu_to_le16(DEFAULT_MSDU_LIFETIME_RES_64us);
1333 }
1334
1335 if (!(info->flags & IEEE80211_TX_CTL_NO_ACK))
1336 tx_buffer_head->fifo_ctl |= cpu_to_le16(FIFOCTL_NEEDACK);
1337
1338 if (ieee80211_has_retry(hdr->frame_control))
1339 tx_buffer_head->fifo_ctl |= cpu_to_le16(FIFOCTL_LRETRY);
1340
1341 if (tx_rate->flags & IEEE80211_TX_RC_USE_SHORT_PREAMBLE)
1342 priv->byPreambleType = PREAMBLE_SHORT;
1343 else
1344 priv->byPreambleType = PREAMBLE_LONG;
1345
1346 if (tx_rate->flags & IEEE80211_TX_RC_USE_RTS_CTS)
1347 tx_buffer_head->fifo_ctl |= cpu_to_le16(FIFOCTL_RTS);
1348
1349 if (ieee80211_has_a4(hdr->frame_control)) {
1350 tx_buffer_head->fifo_ctl |= cpu_to_le16(FIFOCTL_LHEAD);
1351 priv->bLongHeader = true;
1352 }
1353
1354 if (info->flags & IEEE80211_TX_CTL_NO_PS_BUFFER)
1355 is_pspoll = true;
1356
1357 tx_buffer_head->frag_ctl =
1358 cpu_to_le16(ieee80211_get_hdrlen_from_skb(skb) << 10);
1359
1360 if (info->control.hw_key) {
1361 tx_key = info->control.hw_key;
1362
1363 switch (info->control.hw_key->cipher) {
1364 case WLAN_CIPHER_SUITE_WEP40:
1365 case WLAN_CIPHER_SUITE_WEP104:
1366 tx_buffer_head->frag_ctl |= cpu_to_le16(FRAGCTL_LEGACY);
1367 break;
1368 case WLAN_CIPHER_SUITE_TKIP:
1369 tx_buffer_head->frag_ctl |= cpu_to_le16(FRAGCTL_TKIP);
1370 break;
1371 case WLAN_CIPHER_SUITE_CCMP:
1372 tx_buffer_head->frag_ctl |= cpu_to_le16(FRAGCTL_AES);
1373 default:
1374 break;
1375 }
1376 }
1377
1378 tx_buffer_head->current_rate = cpu_to_le16(current_rate);
1379
1380
1381 if (current_rate >= RATE_18M && ieee80211_is_data(hdr->frame_control)) {
1382 if (priv->byAutoFBCtrl == AUTO_FB_0)
1383 tx_buffer_head->fifo_ctl |=
1384 cpu_to_le16(FIFOCTL_AUTO_FB_0);
1385 else if (priv->byAutoFBCtrl == AUTO_FB_1)
1386 tx_buffer_head->fifo_ctl |=
1387 cpu_to_le16(FIFOCTL_AUTO_FB_1);
1388 }
1389
1390 tx_buffer_head->frag_ctl |= cpu_to_le16(FRAGCTL_NONFRAG);
1391
1392 s_cbFillTxBufHead(priv, pkt_type, (u8 *)tx_buffer_head,
1393 dma_idx, head_td, is_pspoll);
1394
1395 if (info->control.hw_key) {
1396 tx_key = info->control.hw_key;
1397 if (tx_key->keylen > 0)
1398 vnt_fill_txkey(hdr, tx_buffer_head->tx_key,
1399 tx_key, skb, tx_body_size, td_info->mic_hdr);
1400 }
1401
1402 return 0;
1403 }
1404
1405 static int vnt_beacon_xmit(struct vnt_private *priv,
1406 struct sk_buff *skb)
1407 {
1408 struct vnt_tx_short_buf_head *short_head =
1409 (struct vnt_tx_short_buf_head *)priv->tx_beacon_bufs;
1410 struct ieee80211_mgmt *mgmt_hdr = (struct ieee80211_mgmt *)
1411 (priv->tx_beacon_bufs + sizeof(*short_head));
1412 struct ieee80211_tx_info *info;
1413 u32 frame_size = skb->len + 4;
1414 u16 current_rate;
1415
1416 memset(priv->tx_beacon_bufs, 0, sizeof(*short_head));
1417
1418 if (priv->byBBType == BB_TYPE_11A) {
1419 current_rate = RATE_6M;
1420
1421
1422 vnt_get_phy_field(priv, frame_size, current_rate,
1423 PK_TYPE_11A, &short_head->ab);
1424
1425
1426 short_head->duration =
1427 cpu_to_le16((u16)s_uGetDataDuration(priv, DATADUR_B,
1428 frame_size, PK_TYPE_11A, current_rate,
1429 false, 0, 0, 1, AUTO_FB_NONE));
1430
1431 short_head->time_stamp_off =
1432 vnt_time_stamp_off(priv, current_rate);
1433 } else {
1434 current_rate = RATE_1M;
1435 short_head->fifo_ctl |= cpu_to_le16(FIFOCTL_11B);
1436
1437
1438 vnt_get_phy_field(priv, frame_size, current_rate,
1439 PK_TYPE_11B, &short_head->ab);
1440
1441
1442 short_head->duration =
1443 cpu_to_le16((u16)s_uGetDataDuration(priv, DATADUR_B,
1444 frame_size, PK_TYPE_11B, current_rate,
1445 false, 0, 0, 1, AUTO_FB_NONE));
1446
1447 short_head->time_stamp_off =
1448 vnt_time_stamp_off(priv, current_rate);
1449 }
1450
1451 short_head->fifo_ctl |= cpu_to_le16(FIFOCTL_GENINT);
1452
1453
1454 memcpy(mgmt_hdr, skb->data, skb->len);
1455
1456
1457 mgmt_hdr->u.beacon.timestamp = 0;
1458
1459 info = IEEE80211_SKB_CB(skb);
1460 if (info->flags & IEEE80211_TX_CTL_ASSIGN_SEQ) {
1461 struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)mgmt_hdr;
1462
1463 hdr->duration_id = 0;
1464 hdr->seq_ctrl = cpu_to_le16(priv->wSeqCounter << 4);
1465 }
1466
1467 priv->wSeqCounter++;
1468 if (priv->wSeqCounter > 0x0fff)
1469 priv->wSeqCounter = 0;
1470
1471 priv->wBCNBufLen = sizeof(*short_head) + skb->len;
1472
1473 MACvSetCurrBCNTxDescAddr(priv->PortOffset, priv->tx_beacon_dma);
1474
1475 MACvSetCurrBCNLength(priv->PortOffset, priv->wBCNBufLen);
1476
1477 MACvRegBitsOn(priv->PortOffset, MAC_REG_TCR, TCR_AUTOBCNTX);
1478
1479 MACvTransmitBCN(priv->PortOffset);
1480
1481 return 0;
1482 }
1483
1484 int vnt_beacon_make(struct vnt_private *priv, struct ieee80211_vif *vif)
1485 {
1486 struct sk_buff *beacon;
1487
1488 beacon = ieee80211_beacon_get(priv->hw, vif);
1489 if (!beacon)
1490 return -ENOMEM;
1491
1492 if (vnt_beacon_xmit(priv, beacon)) {
1493 ieee80211_free_txskb(priv->hw, beacon);
1494 return -ENODEV;
1495 }
1496
1497 return 0;
1498 }
1499
1500 int vnt_beacon_enable(struct vnt_private *priv, struct ieee80211_vif *vif,
1501 struct ieee80211_bss_conf *conf)
1502 {
1503 VNSvOutPortB(priv->PortOffset + MAC_REG_TFTCTL, TFTCTL_TSFCNTRST);
1504
1505 VNSvOutPortB(priv->PortOffset + MAC_REG_TFTCTL, TFTCTL_TSFCNTREN);
1506
1507 CARDvSetFirstNextTBTT(priv, conf->beacon_int);
1508
1509 CARDbSetBeaconPeriod(priv, conf->beacon_int);
1510
1511 return vnt_beacon_make(priv, vif);
1512 }