]> git.proxmox.com Git - mirror_ubuntu-artful-kernel.git/blob - drivers/staging/vt6656/rxtx.c
projects / mirror_ubuntu-artful-kernel.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
staging: vt6656: s_vGenerateTxParameter parse out vnt_rrv_time_ab
[mirror_ubuntu-artful-kernel.git] / drivers / staging / vt6656 / rxtx.c
1 /*
2 * Copyright (c) 1996, 2003 VIA Networking Technologies, Inc.
3 * All rights reserved.
4 *
5 * This program is free software; you can redistribute it and/or modify
6 * it under the terms of the GNU General Public License as published by
7 * the Free Software Foundation; either version 2 of the License, or
8 * (at your option) any later version.
9 *
10 * This program is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 * GNU General Public License for more details.
14 *
15 * You should have received a copy of the GNU General Public License along
16 * with this program; if not, write to the Free Software Foundation, Inc.,
17 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
18 *
19 * File: rxtx.c
20 *
21 * Purpose: handle WMAC/802.3/802.11 rx & tx functions
22 *
23 * Author: Lyndon Chen
24 *
25 * Date: May 20, 2003
26 *
27 * Functions:
28 * s_vGenerateTxParameter - Generate tx dma required parameter.
29 * csBeacon_xmit - beacon tx function
30 * csMgmt_xmit - management tx function
31 * s_uGetDataDuration - get tx data required duration
32 * s_uFillDataHead- fulfill tx data duration header
33 * s_uGetRTSCTSDuration- get rtx/cts required duration
34 * s_uGetRTSCTSRsvTime- get rts/cts reserved time
35 * s_uGetTxRsvTime- get frame reserved time
36 * s_vFillCTSHead- fulfill CTS ctl header
37 * s_vFillFragParameter- Set fragment ctl parameter.
38 * s_vFillRTSHead- fulfill RTS ctl header
39 * vDMA0_tx_80211- tx 802.11 frame via dma0
40 * vGenerateFIFOHeader- Generate tx FIFO ctl header
41 *
42 * Revision History:
43 *
44 */
45
46 #include "device.h"
47 #include "rxtx.h"
48 #include "card.h"
49 #include "mac.h"
50 #include "rf.h"
51 #include "usbpipe.h"
52
53 static int msglevel = MSG_LEVEL_INFO;
54
55 static const u16 wTimeStampOff[2][MAX_RATE] = {
56 {384, 288, 226, 209, 54, 43, 37, 31, 28, 25, 24, 23}, // Long Preamble
57 {384, 192, 130, 113, 54, 43, 37, 31, 28, 25, 24, 23}, // Short Preamble
58 };
59
60 static const u16 wFB_Opt0[2][5] = {
61 {RATE_12M, RATE_18M, RATE_24M, RATE_36M, RATE_48M}, // fallback_rate0
62 {RATE_12M, RATE_12M, RATE_18M, RATE_24M, RATE_36M}, // fallback_rate1
63 };
64 static const u16 wFB_Opt1[2][5] = {
65 {RATE_12M, RATE_18M, RATE_24M, RATE_24M, RATE_36M}, // fallback_rate0
66 {RATE_6M , RATE_6M, RATE_12M, RATE_12M, RATE_18M}, // fallback_rate1
67 };
68
69 #define RTSDUR_BB 0
70 #define RTSDUR_BA 1
71 #define RTSDUR_AA 2
72 #define CTSDUR_BA 3
73 #define RTSDUR_BA_F0 4
74 #define RTSDUR_AA_F0 5
75 #define RTSDUR_BA_F1 6
76 #define RTSDUR_AA_F1 7
77 #define CTSDUR_BA_F0 8
78 #define CTSDUR_BA_F1 9
79 #define DATADUR_B 10
80 #define DATADUR_A 11
81 #define DATADUR_A_F0 12
82 #define DATADUR_A_F1 13
83
84 static struct vnt_usb_send_context *s_vGetFreeContext(struct vnt_private *);
85
86 static u16 s_vGenerateTxParameter(struct vnt_usb_send_context *tx_context,
87 u8 byPktType, u16 wCurrentRate, struct vnt_tx_buffer *tx_buffer,
88 struct vnt_mic_hdr **mic_hdr, u32 need_mic, u32 cbFrameSize,
89 int bNeedACK, bool need_rts);
90
91 static unsigned int s_uGetTxRsvTime(struct vnt_private *pDevice, u8 byPktType,
92 u32 cbFrameLength, u16 wRate, int bNeedAck);
93
94 static __le16 s_uGetRTSCTSRsvTime(struct vnt_private *priv,
95 u8 rsv_type, u8 pkt_type, u32 frame_length, u16 current_rate);
96
97 static u16 s_vFillCTSHead(struct vnt_usb_send_context *tx_context,
98 u8 byPktType, union vnt_tx_data_head *head, u32 cbFrameLength,
99 int bNeedAck, u16 wCurrentRate);
100
101 static u16 s_vFillRTSHead(struct vnt_usb_send_context *tx_context, u8 byPktType,
102 union vnt_tx_data_head *head, u32 cbFrameLength, int bNeedAck,
103 u16 wCurrentRate);
104
105 static __le16 s_uGetDataDuration(struct vnt_private *pDevice,
106 u8 byPktType, int bNeedAck);
107
108 static __le16 s_uGetRTSCTSDuration(struct vnt_private *pDevice,
109 u8 byDurType, u32 cbFrameLength, u8 byPktType, u16 wRate,
110 int bNeedAck);
111
112 static struct vnt_usb_send_context
113 *s_vGetFreeContext(struct vnt_private *priv)
114 {
115 struct vnt_usb_send_context *context = NULL;
116 int ii;
117
118 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"GetFreeContext()\n");
119
120 for (ii = 0; ii < priv->cbTD; ii++) {
121 if (!priv->apTD[ii])
122 return NULL;
123
124 context = priv->apTD[ii];
125 if (context->in_use == false) {
126 context->in_use = true;
127 memset(context->data, 0,
128 MAX_TOTAL_SIZE_WITH_ALL_HEADERS);
129
130 context->hdr = NULL;
131
132 return context;
133 }
134 }
135
136 if (ii == priv->cbTD)
137 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"No Free Tx Context\n");
138
139 return NULL;
140 }
141
142 static __le16 vnt_time_stamp_off(struct vnt_private *priv, u16 rate)
143 {
144 return cpu_to_le16(wTimeStampOff[priv->byPreambleType % 2]
145 [rate % MAX_RATE]);
146 }
147
148 /*byPktType : PK_TYPE_11A 0
149 PK_TYPE_11B 1
150 PK_TYPE_11GB 2
151 PK_TYPE_11GA 3
152 */
153 static u32 s_uGetTxRsvTime(struct vnt_private *priv, u8 pkt_type,
154 u32 frame_length, u16 rate, int need_ack)
155 {
156 u32 data_time, ack_time;
157
158 data_time = vnt_get_frame_time(priv->byPreambleType, pkt_type,
159 frame_length, rate);
160
161 if (pkt_type == PK_TYPE_11B)
162 ack_time = vnt_get_frame_time(priv->byPreambleType, pkt_type,
163 14, (u16)priv->byTopCCKBasicRate);
164 else
165 ack_time = vnt_get_frame_time(priv->byPreambleType, pkt_type,
166 14, (u16)priv->byTopOFDMBasicRate);
167
168 if (need_ack)
169 return data_time + priv->uSIFS + ack_time;
170
171 return data_time;
172 }
173
174 static __le16 vnt_rxtx_rsvtime_le16(struct vnt_private *priv, u8 pkt_type,
175 u32 frame_length, u16 rate, int need_ack)
176 {
177 return cpu_to_le16((u16)s_uGetTxRsvTime(priv, pkt_type,
178 frame_length, rate, need_ack));
179 }
180
181 //byFreqType: 0=>5GHZ 1=>2.4GHZ
182 static __le16 s_uGetRTSCTSRsvTime(struct vnt_private *priv,
183 u8 rsv_type, u8 pkt_type, u32 frame_length, u16 current_rate)
184 {
185 u32 rrv_time, rts_time, cts_time, ack_time, data_time;
186
187 rrv_time = rts_time = cts_time = ack_time = data_time = 0;
188
189 data_time = vnt_get_frame_time(priv->byPreambleType, pkt_type,
190 frame_length, current_rate);
191
192 if (rsv_type == 0) {
193 rts_time = vnt_get_frame_time(priv->byPreambleType,
194 pkt_type, 20, priv->byTopCCKBasicRate);
195 cts_time = ack_time = vnt_get_frame_time(priv->byPreambleType,
196 pkt_type, 14, priv->byTopCCKBasicRate);
197 } else if (rsv_type == 1) {
198 rts_time = vnt_get_frame_time(priv->byPreambleType,
199 pkt_type, 20, priv->byTopCCKBasicRate);
200 cts_time = vnt_get_frame_time(priv->byPreambleType, pkt_type,
201 14, priv->byTopCCKBasicRate);
202 ack_time = vnt_get_frame_time(priv->byPreambleType, pkt_type,
203 14, priv->byTopOFDMBasicRate);
204 } else if (rsv_type == 2) {
205 rts_time = vnt_get_frame_time(priv->byPreambleType, pkt_type,
206 20, priv->byTopOFDMBasicRate);
207 cts_time = ack_time = vnt_get_frame_time(priv->byPreambleType,
208 pkt_type, 14, priv->byTopOFDMBasicRate);
209 } else if (rsv_type == 3) {
210 cts_time = vnt_get_frame_time(priv->byPreambleType, pkt_type,
211 14, priv->byTopCCKBasicRate);
212 ack_time = vnt_get_frame_time(priv->byPreambleType, pkt_type,
213 14, priv->byTopOFDMBasicRate);
214
215 rrv_time = cts_time + ack_time + data_time + 2 * priv->uSIFS;
216
217 return cpu_to_le16((u16)rrv_time);
218 }
219
220 rrv_time = rts_time + cts_time + ack_time + data_time + 3 * priv->uSIFS;
221
222 return cpu_to_le16((u16)rrv_time);
223 }
224
225 //byFreqType 0: 5GHz, 1:2.4Ghz
226 static __le16 s_uGetDataDuration(struct vnt_private *pDevice,
227 u8 byPktType, int bNeedAck)
228 {
229 u32 uAckTime = 0;
230
231 if (bNeedAck) {
232 if (byPktType == PK_TYPE_11B)
233 uAckTime = vnt_get_frame_time(pDevice->byPreambleType,
234 byPktType, 14, pDevice->byTopCCKBasicRate);
235 else
236 uAckTime = vnt_get_frame_time(pDevice->byPreambleType,
237 byPktType, 14, pDevice->byTopOFDMBasicRate);
238 return cpu_to_le16((u16)(pDevice->uSIFS + uAckTime));
239 }
240
241 return 0;
242 }
243
244 //byFreqType: 0=>5GHZ 1=>2.4GHZ
245 static __le16 s_uGetRTSCTSDuration(struct vnt_private *pDevice, u8 byDurType,
246 u32 cbFrameLength, u8 byPktType, u16 wRate, int bNeedAck)
247 {
248 u32 uCTSTime = 0, uDurTime = 0;
249
250 switch (byDurType) {
251 case RTSDUR_BB:
252 case RTSDUR_BA:
253 case RTSDUR_BA_F0:
254 case RTSDUR_BA_F1:
255 uCTSTime = vnt_get_frame_time(pDevice->byPreambleType,
256 byPktType, 14, pDevice->byTopCCKBasicRate);
257 uDurTime = uCTSTime + 2 * pDevice->uSIFS +
258 s_uGetTxRsvTime(pDevice, byPktType,
259 cbFrameLength, wRate, bNeedAck);
260 break;
261
262 case RTSDUR_AA:
263 case RTSDUR_AA_F0:
264 case RTSDUR_AA_F1:
265 uCTSTime = vnt_get_frame_time(pDevice->byPreambleType,
266 byPktType, 14, pDevice->byTopOFDMBasicRate);
267 uDurTime = uCTSTime + 2 * pDevice->uSIFS +
268 s_uGetTxRsvTime(pDevice, byPktType,
269 cbFrameLength, wRate, bNeedAck);
270 break;
271
272 case CTSDUR_BA:
273 case CTSDUR_BA_F0:
274 case CTSDUR_BA_F1:
275 uDurTime = pDevice->uSIFS + s_uGetTxRsvTime(pDevice,
276 byPktType, cbFrameLength, wRate, bNeedAck);
277 break;
278
279 default:
280 break;
281 }
282
283 return cpu_to_le16((u16)uDurTime);
284 }
285
286 static u16 vnt_mac_hdr_pos(struct vnt_usb_send_context *tx_context,
287 struct ieee80211_hdr *hdr)
288 {
289 u8 *head = tx_context->data + offsetof(struct vnt_tx_buffer, fifo_head);
290 u8 *hdr_pos = (u8 *)hdr;
291
292 tx_context->hdr = hdr;
293 if (!tx_context->hdr)
294 return 0;
295
296 return (u16)(hdr_pos - head);
297 }
298
299 static u16 vnt_rxtx_datahead_g(struct vnt_usb_send_context *tx_context,
300 u8 pkt_type, u16 rate, struct vnt_tx_datahead_g *buf,
301 u32 frame_len, int need_ack)
302 {
303
304 struct vnt_private *priv = tx_context->priv;
305 struct ieee80211_hdr *hdr =
306 (struct ieee80211_hdr *)tx_context->skb->data;
307
308 /* Get SignalField,ServiceField,Length */
309 vnt_get_phy_field(priv, frame_len, rate, pkt_type, &buf->a);
310 vnt_get_phy_field(priv, frame_len, priv->byTopCCKBasicRate,
311 PK_TYPE_11B, &buf->b);
312
313 /* Get Duration and TimeStamp */
314 if (ieee80211_is_pspoll(hdr->frame_control)) {
315 __le16 dur = cpu_to_le16(priv->current_aid | BIT(14) | BIT(15));
316
317 buf->duration_a = dur;
318 buf->duration_b = dur;
319 } else {
320 buf->duration_a = s_uGetDataDuration(priv, pkt_type, need_ack);
321 buf->duration_b = s_uGetDataDuration(priv,
322 PK_TYPE_11B, need_ack);
323 }
324
325 buf->time_stamp_off_a = vnt_time_stamp_off(priv, rate);
326 buf->time_stamp_off_b = vnt_time_stamp_off(priv,
327 priv->byTopCCKBasicRate);
328
329 tx_context->tx_hdr_size = vnt_mac_hdr_pos(tx_context, &buf->hdr);
330
331 return le16_to_cpu(buf->duration_a);
332 }
333
334 static u16 vnt_rxtx_datahead_g_fb(struct vnt_usb_send_context *tx_context,
335 u8 pkt_type, u16 rate, struct vnt_tx_datahead_g_fb *buf,
336 u32 frame_len, int need_ack)
337 {
338 struct vnt_private *priv = tx_context->priv;
339
340 /* Get SignalField,ServiceField,Length */
341 vnt_get_phy_field(priv, frame_len, rate, pkt_type, &buf->a);
342
343 vnt_get_phy_field(priv, frame_len, priv->byTopCCKBasicRate,
344 PK_TYPE_11B, &buf->b);
345
346 /* Get Duration and TimeStamp */
347 buf->duration_a = s_uGetDataDuration(priv, pkt_type, need_ack);
348 buf->duration_b = s_uGetDataDuration(priv, PK_TYPE_11B, need_ack);
349
350 buf->duration_a_f0 = s_uGetDataDuration(priv, pkt_type, need_ack);
351 buf->duration_a_f1 = s_uGetDataDuration(priv, pkt_type, need_ack);
352
353 buf->time_stamp_off_a = vnt_time_stamp_off(priv, rate);
354 buf->time_stamp_off_b = vnt_time_stamp_off(priv,
355 priv->byTopCCKBasicRate);
356
357 tx_context->tx_hdr_size = vnt_mac_hdr_pos(tx_context, &buf->hdr);
358
359 return le16_to_cpu(buf->duration_a);
360 }
361
362 static u16 vnt_rxtx_datahead_a_fb(struct vnt_usb_send_context *tx_context,
363 u8 pkt_type, u16 rate, struct vnt_tx_datahead_a_fb *buf,
364 u32 frame_len, int need_ack)
365 {
366 struct vnt_private *priv = tx_context->priv;
367
368 /* Get SignalField,ServiceField,Length */
369 vnt_get_phy_field(priv, frame_len, rate, pkt_type, &buf->a);
370 /* Get Duration and TimeStampOff */
371 buf->duration = s_uGetDataDuration(priv, pkt_type, need_ack);
372
373 buf->duration_f0 = s_uGetDataDuration(priv, pkt_type, need_ack);
374 buf->duration_f1 = s_uGetDataDuration(priv, pkt_type, need_ack);
375
376 buf->time_stamp_off = vnt_time_stamp_off(priv, rate);
377
378 tx_context->tx_hdr_size = vnt_mac_hdr_pos(tx_context, &buf->hdr);
379
380 return le16_to_cpu(buf->duration);
381 }
382
383 static u16 vnt_rxtx_datahead_ab(struct vnt_usb_send_context *tx_context,
384 u8 pkt_type, u16 rate, struct vnt_tx_datahead_ab *buf,
385 u32 frame_len, int need_ack)
386 {
387 struct vnt_private *priv = tx_context->priv;
388 struct ieee80211_hdr *hdr =
389 (struct ieee80211_hdr *)tx_context->skb->data;
390
391 /* Get SignalField,ServiceField,Length */
392 vnt_get_phy_field(priv, frame_len, rate, pkt_type, &buf->ab);
393
394 /* Get Duration and TimeStampOff */
395 if (ieee80211_is_pspoll(hdr->frame_control)) {
396 __le16 dur = cpu_to_le16(priv->current_aid | BIT(14) | BIT(15));
397
398 buf->duration = dur;
399 } else {
400 buf->duration = s_uGetDataDuration(priv, pkt_type, need_ack);
401 }
402
403 buf->time_stamp_off = vnt_time_stamp_off(priv, rate);
404
405 tx_context->tx_hdr_size = vnt_mac_hdr_pos(tx_context, &buf->hdr);
406
407 return le16_to_cpu(buf->duration);
408 }
409
410 static int vnt_fill_ieee80211_rts(struct vnt_usb_send_context *tx_context,
411 struct ieee80211_rts *rts, __le16 duration)
412 {
413 struct ieee80211_hdr *hdr =
414 (struct ieee80211_hdr *)tx_context->skb->data;
415
416 rts->duration = duration;
417 rts->frame_control =
418 cpu_to_le16(IEEE80211_FTYPE_CTL | IEEE80211_STYPE_RTS);
419
420 memcpy(rts->ra, hdr->addr1, ETH_ALEN);
421 memcpy(rts->ta, hdr->addr2, ETH_ALEN);
422
423 return 0;
424 }
425
426 static u16 vnt_rxtx_rts_g_head(struct vnt_usb_send_context *tx_context,
427 struct vnt_rts_g *buf, u8 pkt_type, u32 frame_len, int need_ack,
428 u16 current_rate)
429 {
430 struct vnt_private *priv = tx_context->priv;
431 u16 rts_frame_len = 20;
432
433 vnt_get_phy_field(priv, rts_frame_len, priv->byTopCCKBasicRate,
434 PK_TYPE_11B, &buf->b);
435 vnt_get_phy_field(priv, rts_frame_len,
436 priv->byTopOFDMBasicRate, pkt_type, &buf->a);
437
438 buf->duration_bb = s_uGetRTSCTSDuration(priv, RTSDUR_BB, frame_len,
439 PK_TYPE_11B, priv->byTopCCKBasicRate, need_ack);
440 buf->duration_aa = s_uGetRTSCTSDuration(priv, RTSDUR_AA, frame_len,
441 pkt_type, current_rate, need_ack);
442 buf->duration_ba = s_uGetRTSCTSDuration(priv, RTSDUR_BA, frame_len,
443 pkt_type, current_rate, need_ack);
444
445 vnt_fill_ieee80211_rts(tx_context, &buf->data, buf->duration_aa);
446
447 return vnt_rxtx_datahead_g(tx_context, pkt_type, current_rate,
448 &buf->data_head, frame_len, need_ack);
449 }
450
451 static u16 vnt_rxtx_rts_g_fb_head(struct vnt_usb_send_context *tx_context,
452 struct vnt_rts_g_fb *buf, u8 pkt_type, u32 frame_len, int need_ack,
453 u16 current_rate)
454 {
455 struct vnt_private *priv = tx_context->priv;
456 u16 rts_frame_len = 20;
457
458 vnt_get_phy_field(priv, rts_frame_len, priv->byTopCCKBasicRate,
459 PK_TYPE_11B, &buf->b);
460 vnt_get_phy_field(priv, rts_frame_len,
461 priv->byTopOFDMBasicRate, pkt_type, &buf->a);
462
463
464 buf->duration_bb = s_uGetRTSCTSDuration(priv, RTSDUR_BB, frame_len,
465 PK_TYPE_11B, priv->byTopCCKBasicRate, need_ack);
466 buf->duration_aa = s_uGetRTSCTSDuration(priv, RTSDUR_AA, frame_len,
467 pkt_type, current_rate, need_ack);
468 buf->duration_ba = s_uGetRTSCTSDuration(priv, RTSDUR_BA, frame_len,
469 pkt_type, current_rate, need_ack);
470
471
472 buf->rts_duration_ba_f0 = s_uGetRTSCTSDuration(priv, RTSDUR_BA_F0,
473 frame_len, pkt_type, priv->tx_rate_fb0, need_ack);
474 buf->rts_duration_aa_f0 = s_uGetRTSCTSDuration(priv, RTSDUR_AA_F0,
475 frame_len, pkt_type, priv->tx_rate_fb0, need_ack);
476 buf->rts_duration_ba_f1 = s_uGetRTSCTSDuration(priv, RTSDUR_BA_F1,
477 frame_len, pkt_type, priv->tx_rate_fb1, need_ack);
478 buf->rts_duration_aa_f1 = s_uGetRTSCTSDuration(priv, RTSDUR_AA_F1,
479 frame_len, pkt_type, priv->tx_rate_fb1, need_ack);
480
481 vnt_fill_ieee80211_rts(tx_context, &buf->data, buf->duration_aa);
482
483 return vnt_rxtx_datahead_g_fb(tx_context, pkt_type, current_rate,
484 &buf->data_head, frame_len, need_ack);
485 }
486
487 static u16 vnt_rxtx_rts_ab_head(struct vnt_usb_send_context *tx_context,
488 struct vnt_rts_ab *buf, u8 pkt_type, u32 frame_len, int need_ack,
489 u16 current_rate)
490 {
491 struct vnt_private *priv = tx_context->priv;
492 u16 rts_frame_len = 20;
493
494 vnt_get_phy_field(priv, rts_frame_len,
495 priv->byTopOFDMBasicRate, pkt_type, &buf->ab);
496
497 buf->duration = s_uGetRTSCTSDuration(priv, RTSDUR_AA, frame_len,
498 pkt_type, current_rate, need_ack);
499
500 vnt_fill_ieee80211_rts(tx_context, &buf->data, buf->duration);
501
502 return vnt_rxtx_datahead_ab(tx_context, pkt_type, current_rate,
503 &buf->data_head, frame_len, need_ack);
504 }
505
506 static u16 vnt_rxtx_rts_a_fb_head(struct vnt_usb_send_context *tx_context,
507 struct vnt_rts_a_fb *buf, u8 pkt_type, u32 frame_len, int need_ack,
508 u16 current_rate)
509 {
510 struct vnt_private *priv = tx_context->priv;
511 u16 rts_frame_len = 20;
512
513 vnt_get_phy_field(priv, rts_frame_len,
514 priv->byTopOFDMBasicRate, pkt_type, &buf->a);
515
516 buf->duration = s_uGetRTSCTSDuration(priv, RTSDUR_AA, frame_len,
517 pkt_type, current_rate, need_ack);
518
519 buf->rts_duration_f0 = s_uGetRTSCTSDuration(priv, RTSDUR_AA_F0,
520 frame_len, pkt_type, priv->tx_rate_fb0, need_ack);
521
522 buf->rts_duration_f1 = s_uGetRTSCTSDuration(priv, RTSDUR_AA_F1,
523 frame_len, pkt_type, priv->tx_rate_fb1, need_ack);
524
525 vnt_fill_ieee80211_rts(tx_context, &buf->data, buf->duration);
526
527 return vnt_rxtx_datahead_a_fb(tx_context, pkt_type, current_rate,
528 &buf->data_head, frame_len, need_ack);
529 }
530
531 static u16 s_vFillRTSHead(struct vnt_usb_send_context *tx_context, u8 byPktType,
532 union vnt_tx_data_head *head, u32 cbFrameLength, int bNeedAck,
533 u16 wCurrentRate)
534 {
535
536 if (!head)
537 return 0;
538
539 /* Note: So far RTSHead doesn't appear in ATIM
540 * & Beacom DMA, so we don't need to take them
541 * into account.
542 * Otherwise, we need to modified codes for them.
543 */
544 switch (byPktType) {
545 case PK_TYPE_11GB:
546 case PK_TYPE_11GA:
547 if (!tx_context->fb_option)
548 return vnt_rxtx_rts_g_head(tx_context, &head->rts_g,
549 byPktType, cbFrameLength,
550 bNeedAck, wCurrentRate);
551 else
552 return vnt_rxtx_rts_g_fb_head(tx_context,
553 &head->rts_g_fb, byPktType,
554 cbFrameLength, bNeedAck, wCurrentRate);
555 break;
556 case PK_TYPE_11A:
557 if (tx_context->fb_option) {
558 return vnt_rxtx_rts_a_fb_head(tx_context,
559 &head->rts_a_fb, byPktType,
560 cbFrameLength, bNeedAck, wCurrentRate);
561 break;
562 }
563 case PK_TYPE_11B:
564 return vnt_rxtx_rts_ab_head(tx_context, &head->rts_ab,
565 byPktType, cbFrameLength, bNeedAck,
566 wCurrentRate);
567 }
568
569 return 0;
570 }
571
572 static u16 s_vFillCTSHead(struct vnt_usb_send_context *tx_context,
573 u8 byPktType, union vnt_tx_data_head *head, u32 cbFrameLength,
574 int bNeedAck, u16 wCurrentRate)
575 {
576 struct vnt_private *pDevice = tx_context->priv;
577 u32 uCTSFrameLen = 14;
578
579 if (!head)
580 return 0;
581
582 if (tx_context->fb_option) {
583 /* Auto Fall back */
584 struct vnt_cts_fb *pBuf = &head->cts_g_fb;
585 /* Get SignalField,ServiceField,Length */
586 vnt_get_phy_field(pDevice, uCTSFrameLen,
587 pDevice->byTopCCKBasicRate, PK_TYPE_11B, &pBuf->b);
588 pBuf->duration_ba = s_uGetRTSCTSDuration(pDevice, CTSDUR_BA,
589 cbFrameLength, byPktType,
590 wCurrentRate, bNeedAck);
591 /* Get CTSDuration_ba_f0 */
592 pBuf->cts_duration_ba_f0 = s_uGetRTSCTSDuration(pDevice,
593 CTSDUR_BA_F0, cbFrameLength, byPktType,
594 pDevice->tx_rate_fb0, bNeedAck);
595 /* Get CTSDuration_ba_f1 */
596 pBuf->cts_duration_ba_f1 = s_uGetRTSCTSDuration(pDevice,
597 CTSDUR_BA_F1, cbFrameLength, byPktType,
598 pDevice->tx_rate_fb1, bNeedAck);
599 /* Get CTS Frame body */
600 pBuf->data.duration = pBuf->duration_ba;
601 pBuf->data.frame_control =
602 cpu_to_le16(IEEE80211_FTYPE_CTL | IEEE80211_STYPE_CTS);
603
604 memcpy(pBuf->data.ra, pDevice->abyCurrentNetAddr, ETH_ALEN);
605
606 return vnt_rxtx_datahead_g_fb(tx_context, byPktType,
607 wCurrentRate, &pBuf->data_head, cbFrameLength,
608 bNeedAck);
609 } else {
610 struct vnt_cts *pBuf = &head->cts_g;
611 /* Get SignalField,ServiceField,Length */
612 vnt_get_phy_field(pDevice, uCTSFrameLen,
613 pDevice->byTopCCKBasicRate, PK_TYPE_11B, &pBuf->b);
614 /* Get CTSDuration_ba */
615 pBuf->duration_ba = s_uGetRTSCTSDuration(pDevice,
616 CTSDUR_BA, cbFrameLength, byPktType,
617 wCurrentRate, bNeedAck);
618 /*Get CTS Frame body*/
619 pBuf->data.duration = pBuf->duration_ba;
620 pBuf->data.frame_control =
621 cpu_to_le16(IEEE80211_FTYPE_CTL | IEEE80211_STYPE_CTS);
622
623 memcpy(pBuf->data.ra, pDevice->abyCurrentNetAddr, ETH_ALEN);
624
625 return vnt_rxtx_datahead_g(tx_context, byPktType, wCurrentRate,
626 &pBuf->data_head, cbFrameLength, bNeedAck);
627 }
628
629 return 0;
630 }
631
632 static u16 vnt_rxtx_rts(struct vnt_usb_send_context *tx_context,
633 union vnt_tx_head *tx_head, u8 pkt_type, u32 frame_size,
634 int need_ack, u16 current_rate)
635 {
636 struct vnt_private *priv = tx_context->priv;
637 struct vnt_rrv_time_rts *buf = &tx_head->tx_rts.rts;
638
639 buf->rts_rrv_time_aa = s_uGetRTSCTSRsvTime(priv, 2,
640 pkt_type, frame_size, current_rate);
641 buf->rts_rrv_time_ba = s_uGetRTSCTSRsvTime(priv, 1,
642 pkt_type, frame_size, current_rate);
643 buf->rts_rrv_time_bb = s_uGetRTSCTSRsvTime(priv, 0,
644 pkt_type, frame_size, current_rate);
645
646 buf->rrv_time_a = vnt_rxtx_rsvtime_le16(priv, pkt_type, frame_size,
647 current_rate, need_ack);
648 buf->rrv_time_b = vnt_rxtx_rsvtime_le16(priv, PK_TYPE_11B, frame_size,
649 priv->byTopCCKBasicRate, need_ack);
650
651 return 0;
652 }
653
654 static u16 vnt_rxtx_cts(struct vnt_usb_send_context *tx_context,
655 union vnt_tx_head *tx_head, u8 pkt_type, u32 frame_size,
656 int need_ack, u16 current_rate)
657 {
658 struct vnt_private *priv = tx_context->priv;
659 struct vnt_rrv_time_cts *buf = &tx_head->tx_cts.cts;
660
661 buf->rrv_time_a = vnt_rxtx_rsvtime_le16(priv, pkt_type,
662 frame_size, current_rate, need_ack);
663 buf->rrv_time_b = vnt_rxtx_rsvtime_le16(priv, PK_TYPE_11B,
664 frame_size, priv->byTopCCKBasicRate, need_ack);
665
666 buf->cts_rrv_time_ba = s_uGetRTSCTSRsvTime(priv, 3,
667 pkt_type, frame_size, current_rate);
668
669 return 0;
670 }
671
672 static u16 vnt_rxtx_ab(struct vnt_usb_send_context *tx_context,
673 union vnt_tx_head *tx_head, u8 pkt_type, u32 frame_size,
674 int need_ack, u16 current_rate, bool need_rts)
675 {
676 struct vnt_private *priv = tx_context->priv;
677 struct vnt_rrv_time_ab *buf = &tx_head->tx_ab.ab;
678
679 buf->rrv_time = vnt_rxtx_rsvtime_le16(priv, pkt_type,
680 frame_size, current_rate, need_ack);
681
682 if (need_rts) {
683 if (pkt_type == PK_TYPE_11B)
684 buf->rts_rrv_time = s_uGetRTSCTSRsvTime(priv, 0,
685 pkt_type, frame_size, current_rate);
686 else /* PK_TYPE_11A */
687 buf->rts_rrv_time = s_uGetRTSCTSRsvTime(priv, 2,
688 pkt_type, frame_size, current_rate);
689 }
690
691 return 0;
692 }
693
694 /*+
695 *
696 * Description:
697 * Generate FIFO control for MAC & Baseband controller
698 *
699 * Parameters:
700 * In:
701 * pDevice - Pointer to adpater
702 * pTxDataHead - Transmit Data Buffer
703 * pTxBufHead - pTxBufHead
704 * pvRrvTime - pvRrvTime
705 * pvRTS - RTS Buffer
706 * pCTS - CTS Buffer
707 * cbFrameSize - Transmit Data Length (Hdr+Payload+FCS)
708 * bNeedACK - If need ACK
709 * Out:
710 * none
711 *
712 * Return Value: none
713 *
714 -*/
715
716 static u16 s_vGenerateTxParameter(struct vnt_usb_send_context *tx_context,
717 u8 byPktType, u16 wCurrentRate, struct vnt_tx_buffer *tx_buffer,
718 struct vnt_mic_hdr **mic_hdr, u32 need_mic, u32 cbFrameSize,
719 int bNeedACK, bool need_rts)
720 {
721 union vnt_tx_data_head *head = NULL;
722
723 if (byPktType == PK_TYPE_11GB || byPktType == PK_TYPE_11GA) {
724 if (need_rts) {
725 vnt_rxtx_rts(tx_context, &tx_buffer->tx_head,
726 byPktType, cbFrameSize, bNeedACK, wCurrentRate);
727
728 if (need_mic) {
729 *mic_hdr = &tx_buffer->
730 tx_head.tx_rts.tx.mic.hdr;
731 head = &tx_buffer->tx_head.tx_rts.tx.mic.head;
732 } else {
733 head = &tx_buffer->tx_head.tx_rts.tx.head;
734 }
735
736 /* Fill RTS */
737 return s_vFillRTSHead(tx_context, byPktType, head,
738 cbFrameSize, bNeedACK,
739 wCurrentRate);
740
741 } else {
742 vnt_rxtx_cts(tx_context, &tx_buffer->tx_head,
743 byPktType, cbFrameSize, bNeedACK, wCurrentRate);
744
745 if (need_mic) {
746 *mic_hdr = &tx_buffer->
747 tx_head.tx_cts.tx.mic.hdr;
748 head = &tx_buffer->tx_head.tx_cts.tx.mic.head;
749 } else {
750 head = &tx_buffer->tx_head.tx_cts.tx.head;
751 }
752
753 /* Fill CTS */
754 return s_vFillCTSHead(tx_context, byPktType,
755 head, cbFrameSize, bNeedACK, wCurrentRate);
756 }
757 } else if (byPktType == PK_TYPE_11A) {
758 if (need_mic) {
759 *mic_hdr = &tx_buffer->tx_head.tx_ab.tx.mic.hdr;
760 head = &tx_buffer->tx_head.tx_ab.tx.mic.head;
761 } else {
762 head = &tx_buffer->tx_head.tx_ab.tx.head;
763 }
764
765 if (need_rts) {
766 vnt_rxtx_ab(tx_context, &tx_buffer->tx_head, byPktType,
767 cbFrameSize, bNeedACK, wCurrentRate, need_rts);
768
769
770 /* Fill RTS */
771 return s_vFillRTSHead(tx_context, byPktType, head,
772 cbFrameSize, bNeedACK,
773 wCurrentRate);
774 } else {
775 vnt_rxtx_ab(tx_context, &tx_buffer->tx_head, byPktType,
776 cbFrameSize, bNeedACK, wCurrentRate, need_rts);
777
778 return vnt_rxtx_datahead_a_fb(tx_context, byPktType,
779 wCurrentRate, &head->data_head_a_fb,
780 cbFrameSize, bNeedACK);
781 }
782 } else if (byPktType == PK_TYPE_11B) {
783 if (need_mic) {
784 *mic_hdr = &tx_buffer->tx_head.tx_ab.tx.mic.hdr;
785 head = &tx_buffer->tx_head.tx_ab.tx.mic.head;
786 } else {
787 head = &tx_buffer->tx_head.tx_ab.tx.head;
788 }
789
790 if (need_rts) {
791 vnt_rxtx_ab(tx_context, &tx_buffer->tx_head, byPktType,
792 cbFrameSize, bNeedACK, wCurrentRate, need_rts);
793
794 /* Fill RTS */
795 return s_vFillRTSHead(tx_context, byPktType, head,
796 cbFrameSize, bNeedACK,
797 wCurrentRate);
798 } else {
799 vnt_rxtx_ab(tx_context, &tx_buffer->tx_head, byPktType,
800 cbFrameSize, bNeedACK, wCurrentRate, need_rts);
801
802 return vnt_rxtx_datahead_ab(tx_context, byPktType,
803 wCurrentRate, &head->data_head_ab,
804 cbFrameSize, bNeedACK);
805 }
806 }
807
808 return 0;
809 }
810
811 static void vnt_fill_txkey(struct vnt_usb_send_context *tx_context,
812 u8 *key_buffer, struct ieee80211_key_conf *tx_key, struct sk_buff *skb,
813 u16 payload_len, struct vnt_mic_hdr *mic_hdr)
814 {
815 struct ieee80211_hdr *hdr = tx_context->hdr;
816 struct ieee80211_key_seq seq;
817 u8 *iv = ((u8 *)hdr + ieee80211_get_hdrlen_from_skb(skb));
818
819 /* strip header and icv len from payload */
820 payload_len -= ieee80211_get_hdrlen_from_skb(skb);
821 payload_len -= tx_key->icv_len;
822
823 switch (tx_key->cipher) {
824 case WLAN_CIPHER_SUITE_WEP40:
825 case WLAN_CIPHER_SUITE_WEP104:
826 memcpy(key_buffer, iv, 3);
827 memcpy(key_buffer + 3, tx_key->key, tx_key->keylen);
828
829 if (tx_key->keylen == WLAN_KEY_LEN_WEP40) {
830 memcpy(key_buffer + 8, iv, 3);
831 memcpy(key_buffer + 11,
832 tx_key->key, WLAN_KEY_LEN_WEP40);
833 }
834
835 break;
836 case WLAN_CIPHER_SUITE_TKIP:
837 ieee80211_get_tkip_p2k(tx_key, skb, key_buffer);
838
839 break;
840 case WLAN_CIPHER_SUITE_CCMP:
841
842 if (!mic_hdr)
843 return;
844
845 mic_hdr->id = 0x59;
846 mic_hdr->payload_len = cpu_to_be16(payload_len);
847 memcpy(mic_hdr->mic_addr2, hdr->addr2, ETH_ALEN);
848
849 ieee80211_get_key_tx_seq(tx_key, &seq);
850
851 memcpy(mic_hdr->ccmp_pn, seq.ccmp.pn, IEEE80211_CCMP_PN_LEN);
852
853 if (ieee80211_has_a4(hdr->frame_control))
854 mic_hdr->hlen = cpu_to_be16(28);
855 else
856 mic_hdr->hlen = cpu_to_be16(22);
857
858 memcpy(mic_hdr->addr1, hdr->addr1, ETH_ALEN);
859 memcpy(mic_hdr->addr2, hdr->addr2, ETH_ALEN);
860 memcpy(mic_hdr->addr3, hdr->addr3, ETH_ALEN);
861
862 mic_hdr->frame_control = cpu_to_le16(
863 le16_to_cpu(hdr->frame_control) & 0xc78f);
864 mic_hdr->seq_ctrl = cpu_to_le16(
865 le16_to_cpu(hdr->seq_ctrl) & 0xf);
866
867 if (ieee80211_has_a4(hdr->frame_control))
868 memcpy(mic_hdr->addr4, hdr->addr4, ETH_ALEN);
869
870
871 memcpy(key_buffer, tx_key->key, WLAN_KEY_LEN_CCMP);
872
873 break;
874 default:
875 break;
876 }
877
878 }
879
880 int vnt_tx_packet(struct vnt_private *priv, struct sk_buff *skb)
881 {
882 struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
883 struct ieee80211_tx_rate *tx_rate = &info->control.rates[0];
884 struct ieee80211_rate *rate;
885 struct ieee80211_key_conf *tx_key;
886 struct ieee80211_hdr *hdr;
887 struct vnt_mic_hdr *mic_hdr = NULL;
888 struct vnt_tx_buffer *tx_buffer;
889 struct vnt_tx_fifo_head *tx_buffer_head;
890 struct vnt_usb_send_context *tx_context;
891 unsigned long flags;
892 u32 frame_size = 0;
893 u16 tx_bytes, tx_header_size, tx_body_size, current_rate, duration_id;
894 u8 pkt_type, fb_option = AUTO_FB_NONE;
895 bool need_rts = false, need_ack = false, is_pspoll = false;
896 bool need_mic = false;
897
898 hdr = (struct ieee80211_hdr *)(skb->data);
899
900 rate = ieee80211_get_tx_rate(priv->hw, info);
901
902 current_rate = rate->hw_value;
903 if (priv->wCurrentRate != current_rate &&
904 !(priv->hw->conf.flags & IEEE80211_CONF_OFFCHANNEL)) {
905 priv->wCurrentRate = current_rate;
906 bScheduleCommand(priv, WLAN_CMD_SETPOWER, NULL);
907 }
908
909 if (current_rate > RATE_11M)
910 pkt_type = priv->byPacketType;
911 else
912 pkt_type = PK_TYPE_11B;
913
914 spin_lock_irqsave(&priv->lock, flags);
915
916 tx_context = s_vGetFreeContext(priv);
917 if (!tx_context) {
918 dev_dbg(&priv->usb->dev, "%s No free context\n", __func__);
919 spin_unlock_irqrestore(&priv->lock, flags);
920 return -ENOMEM;
921 }
922
923 tx_context->skb = skb;
924
925 spin_unlock_irqrestore(&priv->lock, flags);
926
927 tx_buffer = (struct vnt_tx_buffer *)tx_context->data;
928 tx_buffer_head = &tx_buffer->fifo_head;
929 tx_body_size = skb->len;
930
931 frame_size = tx_body_size + 4;
932
933 /*Set fifo controls */
934 if (pkt_type == PK_TYPE_11A)
935 tx_buffer_head->wFIFOCtl = 0;
936 else if (pkt_type == PK_TYPE_11B)
937 tx_buffer_head->wFIFOCtl = FIFOCTL_11B;
938 else if (pkt_type == PK_TYPE_11GB)
939 tx_buffer_head->wFIFOCtl = FIFOCTL_11GB;
940 else if (pkt_type == PK_TYPE_11GA)
941 tx_buffer_head->wFIFOCtl = FIFOCTL_11GA;
942
943 if (!ieee80211_is_data(hdr->frame_control)) {
944 tx_buffer_head->wFIFOCtl |= (FIFOCTL_GENINT |
945 FIFOCTL_ISDMA0);
946 tx_buffer_head->wFIFOCtl |= FIFOCTL_TMOEN;
947
948 tx_buffer_head->time_stamp =
949 cpu_to_le16(DEFAULT_MGN_LIFETIME_RES_64us);
950 } else {
951 tx_buffer_head->time_stamp =
952 cpu_to_le16(DEFAULT_MSDU_LIFETIME_RES_64us);
953 }
954
955 if (!(info->flags & IEEE80211_TX_CTL_NO_ACK)) {
956 tx_buffer_head->wFIFOCtl |= FIFOCTL_NEEDACK;
957 need_ack = true;
958 }
959
960 if (ieee80211_has_retry(hdr->frame_control))
961 tx_buffer_head->wFIFOCtl |= FIFOCTL_LRETRY;
962
963 if (tx_rate->flags & IEEE80211_TX_RC_USE_SHORT_PREAMBLE)
964 priv->byPreambleType = PREAMBLE_SHORT;
965 else
966 priv->byPreambleType = PREAMBLE_LONG;
967
968 if (tx_rate->flags & IEEE80211_TX_RC_USE_RTS_CTS) {
969 need_rts = true;
970 tx_buffer_head->wFIFOCtl |= FIFOCTL_RTS;
971 }
972
973 if (ieee80211_has_a4(hdr->frame_control))
974 tx_buffer_head->wFIFOCtl |= FIFOCTL_LHEAD;
975
976 if (info->flags & IEEE80211_TX_CTL_NO_PS_BUFFER)
977 is_pspoll = true;
978
979 tx_buffer_head->frag_ctl =
980 cpu_to_le16(ieee80211_get_hdrlen_from_skb(skb) << 10);
981
982 if (info->control.hw_key) {
983 tx_key = info->control.hw_key;
984 switch (info->control.hw_key->cipher) {
985 case WLAN_CIPHER_SUITE_WEP40:
986 case WLAN_CIPHER_SUITE_WEP104:
987 tx_buffer_head->frag_ctl |= cpu_to_le16(FRAGCTL_LEGACY);
988 break;
989 case WLAN_CIPHER_SUITE_TKIP:
990 tx_buffer_head->frag_ctl |= cpu_to_le16(FRAGCTL_TKIP);
991 break;
992 case WLAN_CIPHER_SUITE_CCMP:
993 tx_buffer_head->frag_ctl |= cpu_to_le16(FRAGCTL_AES);
994 need_mic = true;
995 default:
996 break;
997 }
998 frame_size += tx_key->icv_len;
999 }
1000
1001 tx_buffer_head->current_rate = cpu_to_le16(current_rate);
1002
1003 /* legacy rates TODO use ieee80211_tx_rate */
1004 if (current_rate >= RATE_18M && ieee80211_is_data(hdr->frame_control)) {
1005 if (priv->byAutoFBCtrl == AUTO_FB_0) {
1006 tx_buffer_head->wFIFOCtl |= FIFOCTL_AUTO_FB_0;
1007
1008 priv->tx_rate_fb0 =
1009 wFB_Opt0[FB_RATE0][current_rate - RATE_18M];
1010 priv->tx_rate_fb1 =
1011 wFB_Opt0[FB_RATE1][current_rate - RATE_18M];
1012
1013 fb_option = AUTO_FB_0;
1014 } else if (priv->byAutoFBCtrl == AUTO_FB_1) {
1015 tx_buffer_head->wFIFOCtl |= FIFOCTL_AUTO_FB_1;
1016
1017 priv->tx_rate_fb0 =
1018 wFB_Opt1[FB_RATE0][current_rate - RATE_18M];
1019 priv->tx_rate_fb1 =
1020 wFB_Opt1[FB_RATE1][current_rate - RATE_18M];
1021
1022 fb_option = AUTO_FB_1;
1023 }
1024 }
1025
1026 tx_context->fb_option = fb_option;
1027
1028 duration_id = s_vGenerateTxParameter(tx_context, pkt_type, current_rate,
1029 tx_buffer, &mic_hdr, need_mic, frame_size,
1030 need_ack, need_rts);
1031
1032 tx_header_size = tx_context->tx_hdr_size;
1033 if (!tx_header_size) {
1034 tx_context->in_use = false;
1035 return -ENOMEM;
1036 }
1037
1038 tx_buffer_head->frag_ctl |= cpu_to_le16(FRAGCTL_NONFRAG);
1039
1040 tx_bytes = tx_header_size + tx_body_size;
1041
1042 memcpy(tx_context->hdr, skb->data, tx_body_size);
1043
1044 hdr->duration_id = cpu_to_le16(duration_id);
1045
1046 if (info->control.hw_key) {
1047 tx_key = info->control.hw_key;
1048 if (tx_key->keylen > 0)
1049 vnt_fill_txkey(tx_context, tx_buffer_head->tx_key,
1050 tx_key, skb, tx_body_size, mic_hdr);
1051 }
1052
1053 priv->wSeqCounter = (le16_to_cpu(hdr->seq_ctrl) &
1054 IEEE80211_SCTL_SEQ) >> 4;
1055
1056 tx_buffer->tx_byte_count = cpu_to_le16(tx_bytes);
1057 tx_buffer->byPKTNO = tx_context->pkt_no;
1058 tx_buffer->byType = 0x00;
1059
1060 tx_bytes += 4;
1061
1062 tx_context->type = CONTEXT_DATA_PACKET;
1063 tx_context->buf_len = tx_bytes;
1064
1065 spin_lock_irqsave(&priv->lock, flags);
1066
1067 if (PIPEnsSendBulkOut(priv, tx_context) != STATUS_PENDING) {
1068 spin_unlock_irqrestore(&priv->lock, flags);
1069 return -EIO;
1070 }
1071
1072 spin_unlock_irqrestore(&priv->lock, flags);
1073
1074 return 0;
1075 }
1076
1077 static int vnt_beacon_xmit(struct vnt_private *priv,
1078 struct sk_buff *skb)
1079 {
1080 struct vnt_beacon_buffer *beacon_buffer;
1081 struct vnt_tx_short_buf_head *short_head;
1082 struct ieee80211_tx_info *info;
1083 struct vnt_usb_send_context *context;
1084 struct ieee80211_mgmt *mgmt_hdr;
1085 unsigned long flags;
1086 u32 frame_size = skb->len + 4;
1087 u16 current_rate, count;
1088
1089 spin_lock_irqsave(&priv->lock, flags);
1090
1091 context = s_vGetFreeContext(priv);
1092 if (!context) {
1093 dev_dbg(&priv->usb->dev, "%s No free context!\n", __func__);
1094 spin_unlock_irqrestore(&priv->lock, flags);
1095 return -ENOMEM;
1096 }
1097
1098 context->skb = skb;
1099
1100 spin_unlock_irqrestore(&priv->lock, flags);
1101
1102 beacon_buffer = (struct vnt_beacon_buffer *)&context->data[0];
1103 short_head = &beacon_buffer->short_head;
1104
1105 if (priv->byBBType == BB_TYPE_11A) {
1106 current_rate = RATE_6M;
1107
1108 /* Get SignalField,ServiceField,Length */
1109 vnt_get_phy_field(priv, frame_size, current_rate,
1110 PK_TYPE_11A, &short_head->ab);
1111
1112 /* Get Duration and TimeStampOff */
1113 short_head->duration = s_uGetDataDuration(priv,
1114 PK_TYPE_11A, false);
1115 short_head->time_stamp_off =
1116 vnt_time_stamp_off(priv, current_rate);
1117 } else {
1118 current_rate = RATE_1M;
1119 short_head->fifo_ctl |= FIFOCTL_11B;
1120
1121 /* Get SignalField,ServiceField,Length */
1122 vnt_get_phy_field(priv, frame_size, current_rate,
1123 PK_TYPE_11B, &short_head->ab);
1124
1125 /* Get Duration and TimeStampOff */
1126 short_head->duration = s_uGetDataDuration(priv,
1127 PK_TYPE_11B, false);
1128 short_head->time_stamp_off =
1129 vnt_time_stamp_off(priv, current_rate);
1130 }
1131
1132 /* Generate Beacon Header */
1133 mgmt_hdr = &beacon_buffer->mgmt_hdr;
1134 memcpy(mgmt_hdr, skb->data, skb->len);
1135
1136 /* time stamp always 0 */
1137 mgmt_hdr->u.beacon.timestamp = 0;
1138
1139 info = IEEE80211_SKB_CB(skb);
1140 if (info->flags & IEEE80211_TX_CTL_ASSIGN_SEQ) {
1141 struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)mgmt_hdr;
1142 hdr->duration_id = 0;
1143 hdr->seq_ctrl = cpu_to_le16(priv->wSeqCounter << 4);
1144 }
1145
1146 priv->wSeqCounter++;
1147 if (priv->wSeqCounter > 0x0fff)
1148 priv->wSeqCounter = 0;
1149
1150 count = sizeof(struct vnt_tx_short_buf_head) + skb->len;
1151
1152 beacon_buffer->tx_byte_count = cpu_to_le16(count);
1153 beacon_buffer->byPKTNO = context->pkt_no;
1154 beacon_buffer->byType = 0x01;
1155
1156 context->type = CONTEXT_BEACON_PACKET;
1157 context->buf_len = count + 4; /* USB header */
1158
1159 spin_lock_irqsave(&priv->lock, flags);
1160
1161 if (PIPEnsSendBulkOut(priv, context) != STATUS_PENDING)
1162 ieee80211_free_txskb(priv->hw, context->skb);
1163
1164 spin_unlock_irqrestore(&priv->lock, flags);
1165
1166 return 0;
1167 }
1168
1169 int vnt_beacon_make(struct vnt_private *priv, struct ieee80211_vif *vif)
1170 {
1171 struct sk_buff *beacon;
1172
1173 beacon = ieee80211_beacon_get(priv->hw, vif);
1174 if (!beacon)
1175 return -ENOMEM;
1176
1177 if (vnt_beacon_xmit(priv, beacon)) {
1178 ieee80211_free_txskb(priv->hw, beacon);
1179 return -ENODEV;
1180 }
1181
1182 return 0;
1183 }
1184
1185 int vnt_beacon_enable(struct vnt_private *priv, struct ieee80211_vif *vif,
1186 struct ieee80211_bss_conf *conf)
1187 {
1188 int ret;
1189
1190 vnt_mac_reg_bits_off(priv, MAC_REG_TCR, TCR_AUTOBCNTX);
1191
1192 vnt_mac_reg_bits_off(priv, MAC_REG_TFTCTL, TFTCTL_TSFCNTREN);
1193
1194 vnt_mac_set_beacon_interval(priv, conf->beacon_int);
1195
1196 vnt_clear_current_tsf(priv);
1197
1198 vnt_mac_reg_bits_on(priv, MAC_REG_TFTCTL, TFTCTL_TSFCNTREN);
1199
1200 vnt_reset_next_tbtt(priv, conf->beacon_int);
1201
1202 ret = vnt_beacon_make(priv, vif);
1203
1204 return ret;
1205 }
Ubuntu Artful kernel mirror