1 // SPDX-License-Identifier: GPL-2.0
2 /******************************************************************************
3 *
4 * Copyright(c) 2007 - 2012 Realtek Corporation. All rights reserved.
5 *
6 ******************************************************************************/
7 #include <drv_types.h>
8
9 static u8 P802_1H_OUI[P80211_OUI_LEN] = { 0x00, 0x00, 0xf8 };
10 static u8 RFC1042_OUI[P80211_OUI_LEN] = { 0x00, 0x00, 0x00 };
11
_init_txservq(struct tx_servq * ptxservq)12 static void _init_txservq(struct tx_servq *ptxservq)
13 {
14 INIT_LIST_HEAD(&ptxservq->tx_pending);
15 INIT_LIST_HEAD(&ptxservq->sta_pending.queue);
16 spin_lock_init(&ptxservq->sta_pending.lock);
17 ptxservq->qcnt = 0;
18 }
19
_rtw_init_sta_xmit_priv(struct sta_xmit_priv * psta_xmitpriv)20 void _rtw_init_sta_xmit_priv(struct sta_xmit_priv *psta_xmitpriv)
21 {
22 memset((unsigned char *)psta_xmitpriv, 0, sizeof(struct sta_xmit_priv));
23
24 spin_lock_init(&psta_xmitpriv->lock);
25
26 _init_txservq(&psta_xmitpriv->be_q);
27 _init_txservq(&psta_xmitpriv->bk_q);
28 _init_txservq(&psta_xmitpriv->vi_q);
29 _init_txservq(&psta_xmitpriv->vo_q);
30 INIT_LIST_HEAD(&psta_xmitpriv->legacy_dz);
31 INIT_LIST_HEAD(&psta_xmitpriv->apsd);
32 }
33
_rtw_init_xmit_priv(struct xmit_priv * pxmitpriv,struct adapter * padapter)34 s32 _rtw_init_xmit_priv(struct xmit_priv *pxmitpriv, struct adapter *padapter)
35 {
36 int i;
37 struct xmit_buf *pxmitbuf;
38 struct xmit_frame *pxframe;
39 signed int res = _SUCCESS;
40
41 spin_lock_init(&pxmitpriv->lock);
42 spin_lock_init(&pxmitpriv->lock_sctx);
43 init_completion(&pxmitpriv->xmit_comp);
44 init_completion(&pxmitpriv->terminate_xmitthread_comp);
45
46 /*
47 * Please insert all the queue initialization using _rtw_init_queue below
48 */
49
50 pxmitpriv->adapter = padapter;
51
52 INIT_LIST_HEAD(&pxmitpriv->be_pending.queue);
53 spin_lock_init(&pxmitpriv->be_pending.lock);
54 INIT_LIST_HEAD(&pxmitpriv->bk_pending.queue);
55 spin_lock_init(&pxmitpriv->bk_pending.lock);
56 INIT_LIST_HEAD(&pxmitpriv->vi_pending.queue);
57 spin_lock_init(&pxmitpriv->vi_pending.lock);
58 INIT_LIST_HEAD(&pxmitpriv->vo_pending.queue);
59 spin_lock_init(&pxmitpriv->vo_pending.lock);
60 INIT_LIST_HEAD(&pxmitpriv->bm_pending.queue);
61 spin_lock_init(&pxmitpriv->bm_pending.lock);
62
63 INIT_LIST_HEAD(&pxmitpriv->free_xmit_queue.queue);
64 spin_lock_init(&pxmitpriv->free_xmit_queue.lock);
65
66 /*
67 * Please allocate memory with the sz = (struct xmit_frame) * NR_XMITFRAME,
68 * and initialize free_xmit_frame below.
69 * Please also apply free_txobj to link_up all the xmit_frames...
70 */
71
72 pxmitpriv->pallocated_frame_buf = vzalloc(NR_XMITFRAME * sizeof(struct xmit_frame) + 4);
73
74 if (!pxmitpriv->pallocated_frame_buf) {
75 pxmitpriv->pxmit_frame_buf = NULL;
76 res = _FAIL;
77 goto exit;
78 }
79 pxmitpriv->pxmit_frame_buf = (u8 *)N_BYTE_ALIGMENT((SIZE_PTR)(pxmitpriv->pallocated_frame_buf), 4);
80
81 pxframe = (struct xmit_frame *)pxmitpriv->pxmit_frame_buf;
82
83 for (i = 0; i < NR_XMITFRAME; i++) {
84 INIT_LIST_HEAD(&pxframe->list);
85
86 pxframe->padapter = padapter;
87 pxframe->frame_tag = NULL_FRAMETAG;
88
89 pxframe->pkt = NULL;
90
91 pxframe->buf_addr = NULL;
92 pxframe->pxmitbuf = NULL;
93
94 list_add_tail(&pxframe->list,
95 &pxmitpriv->free_xmit_queue.queue);
96
97 pxframe++;
98 }
99
100 pxmitpriv->free_xmitframe_cnt = NR_XMITFRAME;
101
102 pxmitpriv->frag_len = MAX_FRAG_THRESHOLD;
103
104 /* init xmit_buf */
105 INIT_LIST_HEAD(&pxmitpriv->free_xmitbuf_queue.queue);
106 spin_lock_init(&pxmitpriv->free_xmitbuf_queue.lock);
107 INIT_LIST_HEAD(&pxmitpriv->pending_xmitbuf_queue.queue);
108 spin_lock_init(&pxmitpriv->pending_xmitbuf_queue.lock);
109
110 pxmitpriv->pallocated_xmitbuf = vzalloc(NR_XMITBUFF * sizeof(struct xmit_buf) + 4);
111
112 if (!pxmitpriv->pallocated_xmitbuf) {
113 res = _FAIL;
114 goto exit;
115 }
116
117 pxmitpriv->pxmitbuf = (u8 *)N_BYTE_ALIGMENT((SIZE_PTR)(pxmitpriv->pallocated_xmitbuf), 4);
118
119 pxmitbuf = (struct xmit_buf *)pxmitpriv->pxmitbuf;
120
121 for (i = 0; i < NR_XMITBUFF; i++) {
122 INIT_LIST_HEAD(&pxmitbuf->list);
123
124 pxmitbuf->priv_data = NULL;
125 pxmitbuf->padapter = padapter;
126 pxmitbuf->buf_tag = XMITBUF_DATA;
127
128 /* Tx buf allocation may fail sometimes, so sleep and retry. */
129 res = rtw_os_xmit_resource_alloc(padapter, pxmitbuf, (MAX_XMITBUF_SZ + XMITBUF_ALIGN_SZ), true);
130 if (res == _FAIL) {
131 msleep(10);
132 res = rtw_os_xmit_resource_alloc(padapter, pxmitbuf, (MAX_XMITBUF_SZ + XMITBUF_ALIGN_SZ), true);
133 if (res == _FAIL)
134 goto exit;
135 }
136
137 pxmitbuf->phead = pxmitbuf->pbuf;
138 pxmitbuf->pend = pxmitbuf->pbuf + MAX_XMITBUF_SZ;
139 pxmitbuf->len = 0;
140 pxmitbuf->pdata = pxmitbuf->ptail = pxmitbuf->phead;
141
142 pxmitbuf->flags = XMIT_VO_QUEUE;
143
144 list_add_tail(&pxmitbuf->list,
145 &pxmitpriv->free_xmitbuf_queue.queue);
146 #ifdef DBG_XMIT_BUF
147 pxmitbuf->no = i;
148 #endif
149
150 pxmitbuf++;
151 }
152
153 pxmitpriv->free_xmitbuf_cnt = NR_XMITBUFF;
154
155 /* init xframe_ext queue, the same count as extbuf */
156 INIT_LIST_HEAD(&pxmitpriv->free_xframe_ext_queue.queue);
157 spin_lock_init(&pxmitpriv->free_xframe_ext_queue.lock);
158
159 pxmitpriv->xframe_ext_alloc_addr = vzalloc(NR_XMIT_EXTBUFF * sizeof(struct xmit_frame) + 4);
160
161 if (!pxmitpriv->xframe_ext_alloc_addr) {
162 pxmitpriv->xframe_ext = NULL;
163 res = _FAIL;
164 goto exit;
165 }
166 pxmitpriv->xframe_ext = (u8 *)N_BYTE_ALIGMENT((SIZE_PTR)(pxmitpriv->xframe_ext_alloc_addr), 4);
167 pxframe = (struct xmit_frame *)pxmitpriv->xframe_ext;
168
169 for (i = 0; i < NR_XMIT_EXTBUFF; i++) {
170 INIT_LIST_HEAD(&pxframe->list);
171
172 pxframe->padapter = padapter;
173 pxframe->frame_tag = NULL_FRAMETAG;
174
175 pxframe->pkt = NULL;
176
177 pxframe->buf_addr = NULL;
178 pxframe->pxmitbuf = NULL;
179
180 pxframe->ext_tag = 1;
181
182 list_add_tail(&pxframe->list,
183 &pxmitpriv->free_xframe_ext_queue.queue);
184
185 pxframe++;
186 }
187 pxmitpriv->free_xframe_ext_cnt = NR_XMIT_EXTBUFF;
188
189 /* Init xmit extension buff */
190 INIT_LIST_HEAD(&pxmitpriv->free_xmit_extbuf_queue.queue);
191 spin_lock_init(&pxmitpriv->free_xmit_extbuf_queue.lock);
192
193 pxmitpriv->pallocated_xmit_extbuf = vzalloc(NR_XMIT_EXTBUFF * sizeof(struct xmit_buf) + 4);
194
195 if (!pxmitpriv->pallocated_xmit_extbuf) {
196 res = _FAIL;
197 goto exit;
198 }
199
200 pxmitpriv->pxmit_extbuf = (u8 *)N_BYTE_ALIGMENT((SIZE_PTR)(pxmitpriv->pallocated_xmit_extbuf), 4);
201
202 pxmitbuf = (struct xmit_buf *)pxmitpriv->pxmit_extbuf;
203
204 for (i = 0; i < NR_XMIT_EXTBUFF; i++) {
205 INIT_LIST_HEAD(&pxmitbuf->list);
206
207 pxmitbuf->priv_data = NULL;
208 pxmitbuf->padapter = padapter;
209 pxmitbuf->buf_tag = XMITBUF_MGNT;
210
211 res = rtw_os_xmit_resource_alloc(padapter, pxmitbuf, MAX_XMIT_EXTBUF_SZ + XMITBUF_ALIGN_SZ, true);
212 if (res == _FAIL) {
213 res = _FAIL;
214 goto exit;
215 }
216
217 pxmitbuf->phead = pxmitbuf->pbuf;
218 pxmitbuf->pend = pxmitbuf->pbuf + MAX_XMIT_EXTBUF_SZ;
219 pxmitbuf->len = 0;
220 pxmitbuf->pdata = pxmitbuf->ptail = pxmitbuf->phead;
221
222 list_add_tail(&pxmitbuf->list,
223 &pxmitpriv->free_xmit_extbuf_queue.queue);
224 #ifdef DBG_XMIT_BUF_EXT
225 pxmitbuf->no = i;
226 #endif
227 pxmitbuf++;
228 }
229
230 pxmitpriv->free_xmit_extbuf_cnt = NR_XMIT_EXTBUFF;
231
232 for (i = 0; i < CMDBUF_MAX; i++) {
233 pxmitbuf = &pxmitpriv->pcmd_xmitbuf[i];
234 if (pxmitbuf) {
235 INIT_LIST_HEAD(&pxmitbuf->list);
236
237 pxmitbuf->priv_data = NULL;
238 pxmitbuf->padapter = padapter;
239 pxmitbuf->buf_tag = XMITBUF_CMD;
240
241 res = rtw_os_xmit_resource_alloc(padapter, pxmitbuf,
242 MAX_CMDBUF_SZ + XMITBUF_ALIGN_SZ,
243 true);
244 if (res == _FAIL) {
245 res = _FAIL;
246 goto exit;
247 }
248
249 pxmitbuf->phead = pxmitbuf->pbuf;
250 pxmitbuf->pend = pxmitbuf->pbuf + MAX_CMDBUF_SZ;
251 pxmitbuf->len = 0;
252 pxmitbuf->pdata = pxmitbuf->ptail = pxmitbuf->phead;
253 pxmitbuf->alloc_sz = MAX_CMDBUF_SZ + XMITBUF_ALIGN_SZ;
254 }
255 }
256
257 res = rtw_alloc_hwxmits(padapter);
258 if (res == _FAIL)
259 goto exit;
260 rtw_init_hwxmits(pxmitpriv->hwxmits, pxmitpriv->hwxmit_entry);
261
262 for (i = 0; i < 4; i++)
263 pxmitpriv->wmm_para_seq[i] = i;
264
265 pxmitpriv->ack_tx = false;
266 mutex_init(&pxmitpriv->ack_tx_mutex);
267 rtw_sctx_init(&pxmitpriv->ack_tx_ops, 0);
268
269 rtw_hal_init_xmit_priv(padapter);
270
271 exit:
272 return res;
273 }
274
_rtw_free_xmit_priv(struct xmit_priv * pxmitpriv)275 void _rtw_free_xmit_priv(struct xmit_priv *pxmitpriv)
276 {
277 int i;
278 struct adapter *padapter = pxmitpriv->adapter;
279 struct xmit_frame *pxmitframe = (struct xmit_frame *)pxmitpriv->pxmit_frame_buf;
280 struct xmit_buf *pxmitbuf = (struct xmit_buf *)pxmitpriv->pxmitbuf;
281
282 rtw_hal_free_xmit_priv(padapter);
283
284 if (!pxmitpriv->pxmit_frame_buf)
285 return;
286
287 for (i = 0; i < NR_XMITFRAME; i++) {
288 rtw_os_xmit_complete(padapter, pxmitframe);
289
290 pxmitframe++;
291 }
292
293 for (i = 0; i < NR_XMITBUFF; i++) {
294 rtw_os_xmit_resource_free(padapter, pxmitbuf, (MAX_XMITBUF_SZ + XMITBUF_ALIGN_SZ), true);
295
296 pxmitbuf++;
297 }
298
299 vfree(pxmitpriv->pallocated_frame_buf);
300 vfree(pxmitpriv->pallocated_xmitbuf);
301
302 /* free xframe_ext queue, the same count as extbuf */
303 pxmitframe = (struct xmit_frame *)pxmitpriv->xframe_ext;
304 if (pxmitframe) {
305 for (i = 0; i < NR_XMIT_EXTBUFF; i++) {
306 rtw_os_xmit_complete(padapter, pxmitframe);
307 pxmitframe++;
308 }
309 }
310
311 vfree(pxmitpriv->xframe_ext_alloc_addr);
312
313 /* free xmit extension buff */
314 pxmitbuf = (struct xmit_buf *)pxmitpriv->pxmit_extbuf;
315 for (i = 0; i < NR_XMIT_EXTBUFF; i++) {
316 rtw_os_xmit_resource_free(padapter, pxmitbuf, (MAX_XMIT_EXTBUF_SZ + XMITBUF_ALIGN_SZ), true);
317
318 pxmitbuf++;
319 }
320
321 vfree(pxmitpriv->pallocated_xmit_extbuf);
322
323 for (i = 0; i < CMDBUF_MAX; i++) {
324 pxmitbuf = &pxmitpriv->pcmd_xmitbuf[i];
325 if (pxmitbuf)
326 rtw_os_xmit_resource_free(padapter, pxmitbuf,
327 MAX_CMDBUF_SZ + XMITBUF_ALIGN_SZ,
328 true);
329 }
330
331 rtw_free_hwxmits(padapter);
332
333 mutex_destroy(&pxmitpriv->ack_tx_mutex);
334 }
335
query_ra_short_GI(struct sta_info * psta)336 u8 query_ra_short_GI(struct sta_info *psta)
337 {
338 u8 sgi = false, sgi_20m = false, sgi_40m = false;
339
340 sgi_20m = psta->htpriv.sgi_20m;
341 sgi_40m = psta->htpriv.sgi_40m;
342
343 switch (psta->bw_mode) {
344 case CHANNEL_WIDTH_40:
345 sgi = sgi_40m;
346 break;
347 case CHANNEL_WIDTH_20:
348 default:
349 sgi = sgi_20m;
350 break;
351 }
352
353 return sgi;
354 }
355
update_attrib_vcs_info(struct adapter * padapter,struct xmit_frame * pxmitframe)356 static void update_attrib_vcs_info(struct adapter *padapter, struct xmit_frame *pxmitframe)
357 {
358 u32 sz;
359 struct pkt_attrib *pattrib = &pxmitframe->attrib;
360 /* struct sta_info *psta = pattrib->psta; */
361 struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
362 struct mlme_ext_info *pmlmeinfo = &pmlmeext->mlmext_info;
363
364 if (pattrib->nr_frags != 1)
365 sz = padapter->xmitpriv.frag_len;
366 else /* no frag */
367 sz = pattrib->last_txcmdsz;
368
369 /* (1) RTS_Threshold is compared to the MPDU, not MSDU. */
370 /* (2) If there are more than one frag in this MSDU, only the first frag uses protection frame. */
371 /* Other fragments are protected by previous fragment. */
372 /* So we only need to check the length of first fragment. */
373 if (pmlmeext->cur_wireless_mode < WIRELESS_11_24N || padapter->registrypriv.wifi_spec) {
374 if (sz > padapter->registrypriv.rts_thresh) {
375 pattrib->vcs_mode = RTS_CTS;
376 } else {
377 if (pattrib->rtsen)
378 pattrib->vcs_mode = RTS_CTS;
379 else if (pattrib->cts2self)
380 pattrib->vcs_mode = CTS_TO_SELF;
381 else
382 pattrib->vcs_mode = NONE_VCS;
383 }
384 } else {
385 while (true) {
386 /* IOT action */
387 if ((pmlmeinfo->assoc_AP_vendor == HT_IOT_PEER_ATHEROS) && (pattrib->ampdu_en == true) &&
388 (padapter->securitypriv.dot11PrivacyAlgrthm == _AES_)) {
389 pattrib->vcs_mode = CTS_TO_SELF;
390 break;
391 }
392
393 /* check ERP protection */
394 if (pattrib->rtsen || pattrib->cts2self) {
395 if (pattrib->rtsen)
396 pattrib->vcs_mode = RTS_CTS;
397 else if (pattrib->cts2self)
398 pattrib->vcs_mode = CTS_TO_SELF;
399
400 break;
401 }
402
403 /* check HT op mode */
404 if (pattrib->ht_en) {
405 u8 HTOpMode = pmlmeinfo->HT_protection;
406
407 if ((pmlmeext->cur_bwmode && (HTOpMode == 2 || HTOpMode == 3)) ||
408 (!pmlmeext->cur_bwmode && HTOpMode == 3)) {
409 pattrib->vcs_mode = RTS_CTS;
410 break;
411 }
412 }
413
414 /* check rts */
415 if (sz > padapter->registrypriv.rts_thresh) {
416 pattrib->vcs_mode = RTS_CTS;
417 break;
418 }
419
420 /* to do list: check MIMO power save condition. */
421
422 /* check AMPDU aggregation for TXOP */
423 if (pattrib->ampdu_en == true) {
424 pattrib->vcs_mode = RTS_CTS;
425 break;
426 }
427
428 pattrib->vcs_mode = NONE_VCS;
429 break;
430 }
431 }
432
433 /* for debug : force driver control vrtl_carrier_sense. */
434 if (padapter->driver_vcs_en == 1)
435 pattrib->vcs_mode = padapter->driver_vcs_type;
436 }
437
update_attrib_phy_info(struct adapter * padapter,struct pkt_attrib * pattrib,struct sta_info * psta)438 static void update_attrib_phy_info(struct adapter *padapter, struct pkt_attrib *pattrib, struct sta_info *psta)
439 {
440 struct mlme_ext_priv *mlmeext = &padapter->mlmeextpriv;
441
442 pattrib->rtsen = psta->rtsen;
443 pattrib->cts2self = psta->cts2self;
444
445 pattrib->mdata = 0;
446 pattrib->eosp = 0;
447 pattrib->triggered = 0;
448 pattrib->ampdu_spacing = 0;
449
450 /* qos_en, ht_en, init rate, , bw, ch_offset, sgi */
451 pattrib->qos_en = psta->qos_option;
452
453 pattrib->raid = psta->raid;
454
455 pattrib->bwmode = min(mlmeext->cur_bwmode, psta->bw_mode);
456
457 pattrib->sgi = query_ra_short_GI(psta);
458
459 pattrib->ldpc = psta->ldpc;
460 pattrib->stbc = psta->stbc;
461
462 pattrib->ht_en = psta->htpriv.ht_option;
463 pattrib->ch_offset = psta->htpriv.ch_offset;
464 pattrib->ampdu_en = false;
465
466 if (padapter->driver_ampdu_spacing != 0xFF) /* driver control AMPDU Density for peer sta's rx */
467 pattrib->ampdu_spacing = padapter->driver_ampdu_spacing;
468 else
469 pattrib->ampdu_spacing = psta->htpriv.rx_ampdu_min_spacing;
470
471 pattrib->retry_ctrl = false;
472 }
473
update_attrib_sec_info(struct adapter * padapter,struct pkt_attrib * pattrib,struct sta_info * psta)474 static s32 update_attrib_sec_info(struct adapter *padapter, struct pkt_attrib *pattrib, struct sta_info *psta)
475 {
476 signed int res = _SUCCESS;
477 struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
478 struct security_priv *psecuritypriv = &padapter->securitypriv;
479 signed int bmcast = is_multicast_ether_addr(pattrib->ra);
480
481 memset(pattrib->dot118021x_UncstKey.skey, 0, 16);
482 memset(pattrib->dot11tkiptxmickey.skey, 0, 16);
483 pattrib->mac_id = psta->mac_id;
484
485 if (psta->ieee8021x_blocked == true) {
486 pattrib->encrypt = 0;
487
488 if ((pattrib->ether_type != 0x888e) && (check_fwstate(pmlmepriv, WIFI_MP_STATE) == false)) {
489 res = _FAIL;
490 goto exit;
491 }
492 } else {
493 GET_ENCRY_ALGO(psecuritypriv, psta, pattrib->encrypt, bmcast);
494
495 switch (psecuritypriv->dot11AuthAlgrthm) {
496 case dot11AuthAlgrthm_Open:
497 case dot11AuthAlgrthm_Shared:
498 case dot11AuthAlgrthm_Auto:
499 pattrib->key_idx = (u8)psecuritypriv->dot11PrivacyKeyIndex;
500 break;
501 case dot11AuthAlgrthm_8021X:
502 if (bmcast)
503 pattrib->key_idx = (u8)psecuritypriv->dot118021XGrpKeyid;
504 else
505 pattrib->key_idx = 0;
506 break;
507 default:
508 pattrib->key_idx = 0;
509 break;
510 }
511
512 /* For WPS 1.0 WEP, driver should not encrypt EAPOL Packet for WPS handshake. */
513 if (((pattrib->encrypt == _WEP40_) || (pattrib->encrypt == _WEP104_)) && (pattrib->ether_type == 0x888e))
514 pattrib->encrypt = _NO_PRIVACY_;
515 }
516
517 switch (pattrib->encrypt) {
518 case _WEP40_:
519 case _WEP104_:
520 pattrib->iv_len = 4;
521 pattrib->icv_len = 4;
522 WEP_IV(pattrib->iv, psta->dot11txpn, pattrib->key_idx);
523 break;
524
525 case _TKIP_:
526 pattrib->iv_len = 8;
527 pattrib->icv_len = 4;
528
529 if (psecuritypriv->busetkipkey == _FAIL) {
530 res = _FAIL;
531 goto exit;
532 }
533
534 if (bmcast)
535 TKIP_IV(pattrib->iv, psta->dot11txpn, pattrib->key_idx);
536 else
537 TKIP_IV(pattrib->iv, psta->dot11txpn, 0);
538
539 memcpy(pattrib->dot11tkiptxmickey.skey, psta->dot11tkiptxmickey.skey, 16);
540
541 break;
542
543 case _AES_:
544
545 pattrib->iv_len = 8;
546 pattrib->icv_len = 8;
547
548 if (bmcast)
549 AES_IV(pattrib->iv, psta->dot11txpn, pattrib->key_idx);
550 else
551 AES_IV(pattrib->iv, psta->dot11txpn, 0);
552
553 break;
554
555 default:
556 pattrib->iv_len = 0;
557 pattrib->icv_len = 0;
558 break;
559 }
560
561 if (pattrib->encrypt > 0)
562 memcpy(pattrib->dot118021x_UncstKey.skey, psta->dot118021x_UncstKey.skey, 16);
563
564 if (pattrib->encrypt &&
565 ((padapter->securitypriv.sw_encrypt) || (!psecuritypriv->hw_decrypted)))
566 pattrib->bswenc = true;
567 else
568 pattrib->bswenc = false;
569
570 exit:
571
572 return res;
573 }
574
qos_acm(u8 acm_mask,u8 priority)575 u8 qos_acm(u8 acm_mask, u8 priority)
576 {
577 switch (priority) {
578 case 0:
579 case 3:
580 if (acm_mask & BIT(1))
581 priority = 1;
582 break;
583 case 1:
584 case 2:
585 break;
586 case 4:
587 case 5:
588 if (acm_mask & BIT(2))
589 priority = 0;
590 break;
591 case 6:
592 case 7:
593 if (acm_mask & BIT(3))
594 priority = 5;
595 break;
596 default:
597 break;
598 }
599
600 return priority;
601 }
602
set_qos(struct pkt_file * ppktfile,struct pkt_attrib * pattrib)603 static int set_qos(struct pkt_file *ppktfile, struct pkt_attrib *pattrib)
604 {
605 struct ethhdr etherhdr;
606 struct iphdr ip_hdr;
607 s32 UserPriority = 0;
608 int ret;
609
610 _rtw_open_pktfile(ppktfile->pkt, ppktfile);
611 ret = _rtw_pktfile_read(ppktfile, (unsigned char *)ðerhdr, ETH_HLEN);
612 if (ret < 0)
613 return ret;
614
615 /* get UserPriority from IP hdr */
616 if (pattrib->ether_type == 0x0800) {
617 ret = _rtw_pktfile_read(ppktfile, (u8 *)&ip_hdr, sizeof(ip_hdr));
618 if (ret < 0)
619 return ret;
620
621 UserPriority = ip_hdr.tos >> 5;
622 }
623 pattrib->priority = UserPriority;
624 pattrib->hdrlen = WLAN_HDR_A3_QOS_LEN;
625 pattrib->subtype = WIFI_QOS_DATA_TYPE;
626
627 return 0;
628 }
629
update_attrib(struct adapter * padapter,struct sk_buff * pkt,struct pkt_attrib * pattrib)630 static s32 update_attrib(struct adapter *padapter, struct sk_buff *pkt, struct pkt_attrib *pattrib)
631 {
632 struct pkt_file pktfile;
633 struct sta_info *psta = NULL;
634 struct ethhdr etherhdr;
635
636 signed int bmcast;
637 struct sta_priv *pstapriv = &padapter->stapriv;
638 struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
639 struct qos_priv *pqospriv = &pmlmepriv->qospriv;
640 signed int res = _SUCCESS;
641 int ret;
642
643 _rtw_open_pktfile(pkt, &pktfile);
644 ret = _rtw_pktfile_read(&pktfile, (u8 *)ðerhdr, ETH_HLEN);
645 if (ret < 0)
646 return ret;
647
648 pattrib->ether_type = ntohs(etherhdr.h_proto);
649
650 memcpy(pattrib->dst, ðerhdr.h_dest, ETH_ALEN);
651 memcpy(pattrib->src, ðerhdr.h_source, ETH_ALEN);
652
653 if ((check_fwstate(pmlmepriv, WIFI_ADHOC_STATE) == true) ||
654 (check_fwstate(pmlmepriv, WIFI_ADHOC_MASTER_STATE) == true)) {
655 memcpy(pattrib->ra, pattrib->dst, ETH_ALEN);
656 memcpy(pattrib->ta, pattrib->src, ETH_ALEN);
657 } else if (check_fwstate(pmlmepriv, WIFI_STATION_STATE)) {
658 memcpy(pattrib->ra, get_bssid(pmlmepriv), ETH_ALEN);
659 memcpy(pattrib->ta, pattrib->src, ETH_ALEN);
660 } else if (check_fwstate(pmlmepriv, WIFI_AP_STATE)) {
661 memcpy(pattrib->ra, pattrib->dst, ETH_ALEN);
662 memcpy(pattrib->ta, get_bssid(pmlmepriv), ETH_ALEN);
663 }
664
665 pattrib->pktlen = pktfile.pkt_len;
666
667 if (pattrib->ether_type == ETH_P_IP) {
668 /* The following is for DHCP and ARP packet, we use cck1M to tx these packets and let LPS awake some time */
669 /* to prevent DHCP protocol fail */
670
671 u8 tmp[24];
672
673 ret = _rtw_pktfile_read(&pktfile, &tmp[0], 24);
674 if (ret < 0)
675 return ret;
676
677 pattrib->dhcp_pkt = 0;
678 if (pktfile.pkt_len > 282) {/* MINIMUM_DHCP_PACKET_SIZE) { */
679 if (pattrib->ether_type == ETH_P_IP) {/* IP header */
680 if (((tmp[21] == 68) && (tmp[23] == 67)) ||
681 ((tmp[21] == 67) && (tmp[23] == 68))) {
682 /* 68 : UDP BOOTP client */
683 /* 67 : UDP BOOTP server */
684 pattrib->dhcp_pkt = 1;
685 }
686 }
687 }
688
689 /* for parsing ICMP pakcets */
690 {
691 struct iphdr *piphdr = (struct iphdr *)tmp;
692
693 pattrib->icmp_pkt = 0;
694 if (piphdr->protocol == 0x1) /* protocol type in ip header 0x1 is ICMP */
695 pattrib->icmp_pkt = 1;
696 }
697 } else if (pattrib->ether_type == 0x888e) {
698 netdev_dbg(padapter->pnetdev, "send eapol packet\n");
699 }
700
701 if ((pattrib->ether_type == 0x888e) || (pattrib->dhcp_pkt == 1))
702 rtw_set_scan_deny(padapter, 3000);
703
704 /* If EAPOL , ARP , OR DHCP packet, driver must be in active mode. */
705 if (pattrib->icmp_pkt == 1)
706 rtw_lps_ctrl_wk_cmd(padapter, LPS_CTRL_LEAVE, 1);
707 else if (pattrib->dhcp_pkt == 1)
708 rtw_lps_ctrl_wk_cmd(padapter, LPS_CTRL_SPECIAL_PACKET, 1);
709
710 bmcast = is_multicast_ether_addr(pattrib->ra);
711
712 /* get sta_info */
713 if (bmcast) {
714 psta = rtw_get_bcmc_stainfo(padapter);
715 } else {
716 psta = rtw_get_stainfo(pstapriv, pattrib->ra);
717 if (!psta) { /* if we cannot get psta => drop the pkt */
718 res = _FAIL;
719 goto exit;
720 } else if ((check_fwstate(pmlmepriv, WIFI_AP_STATE) == true) && (!(psta->state & _FW_LINKED))) {
721 res = _FAIL;
722 goto exit;
723 }
724 }
725
726 if (!psta) {
727 /* if we cannot get psta => drop the pkt */
728 res = _FAIL;
729 goto exit;
730 }
731
732 if (!(psta->state & _FW_LINKED))
733 return _FAIL;
734
735 spin_lock_bh(&psta->lock);
736 if (update_attrib_sec_info(padapter, pattrib, psta) == _FAIL) {
737 spin_unlock_bh(&psta->lock);
738 res = _FAIL;
739 goto exit;
740 }
741
742 update_attrib_phy_info(padapter, pattrib, psta);
743
744 pattrib->psta = psta;
745 spin_unlock_bh(&psta->lock);
746
747 pattrib->pctrl = 0;
748
749 pattrib->ack_policy = 0;
750 /* get ether_hdr_len */
751 pattrib->pkt_hdrlen = ETH_HLEN;/* pattrib->ether_type == 0x8100) ? (14 + 4): 14; vlan tag */
752
753 pattrib->hdrlen = WLAN_HDR_A3_LEN;
754 pattrib->subtype = WIFI_DATA_TYPE;
755 pattrib->priority = 0;
756
757 if (check_fwstate(pmlmepriv, WIFI_AP_STATE | WIFI_ADHOC_STATE | WIFI_ADHOC_MASTER_STATE)) {
758 if (pattrib->qos_en) {
759 ret = set_qos(&pktfile, pattrib);
760 if (ret < 0)
761 return ret;
762 }
763 } else {
764 if (pqospriv->qos_option) {
765 ret = set_qos(&pktfile, pattrib);
766 if (ret < 0)
767 return ret;
768
769 if (pmlmepriv->acm_mask != 0)
770 pattrib->priority = qos_acm(pmlmepriv->acm_mask, pattrib->priority);
771 }
772 }
773
774 /* pattrib->priority = 5; force to used VI queue, for testing */
775
776 exit:
777 return res;
778 }
779
xmitframe_addmic(struct adapter * padapter,struct xmit_frame * pxmitframe)780 static s32 xmitframe_addmic(struct adapter *padapter, struct xmit_frame *pxmitframe)
781 {
782 signed int curfragnum, length;
783 u8 *pframe, *payload, mic[8];
784 struct mic_data micdata;
785 struct pkt_attrib *pattrib = &pxmitframe->attrib;
786 struct security_priv *psecuritypriv = &padapter->securitypriv;
787 struct xmit_priv *pxmitpriv = &padapter->xmitpriv;
788 u8 priority[4] = {0x0, 0x0, 0x0, 0x0};
789 u8 hw_hdr_offset = 0;
790 signed int bmcst = is_multicast_ether_addr(pattrib->ra);
791
792 hw_hdr_offset = TXDESC_OFFSET;
793
794 if (pattrib->encrypt == _TKIP_) {
795 /* encode mic code */
796 {
797 u8 null_key[16] = {0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0};
798
799 pframe = pxmitframe->buf_addr + hw_hdr_offset;
800
801 if (bmcst) {
802 if (!memcmp(psecuritypriv->dot118021XGrptxmickey[psecuritypriv->dot118021XGrpKeyid].skey, null_key, 16))
803 return _FAIL;
804 /* start to calculate the mic code */
805 rtw_secmicsetkey(&micdata, psecuritypriv->dot118021XGrptxmickey[psecuritypriv->dot118021XGrpKeyid].skey);
806 } else {
807 if (!memcmp(&pattrib->dot11tkiptxmickey.skey[0], null_key, 16))
808 return _FAIL;
809 /* start to calculate the mic code */
810 rtw_secmicsetkey(&micdata, &pattrib->dot11tkiptxmickey.skey[0]);
811 }
812
813 if (pframe[1] & 1) { /* ToDS == 1 */
814 rtw_secmicappend(&micdata, &pframe[16], 6); /* DA */
815 if (pframe[1] & 2) /* From Ds == 1 */
816 rtw_secmicappend(&micdata, &pframe[24], 6);
817 else
818 rtw_secmicappend(&micdata, &pframe[10], 6);
819 } else { /* ToDS == 0 */
820 rtw_secmicappend(&micdata, &pframe[4], 6); /* DA */
821 if (pframe[1] & 2) /* From Ds == 1 */
822 rtw_secmicappend(&micdata, &pframe[16], 6);
823 else
824 rtw_secmicappend(&micdata, &pframe[10], 6);
825 }
826
827 if (pattrib->qos_en)
828 priority[0] = (u8)pxmitframe->attrib.priority;
829
830 rtw_secmicappend(&micdata, &priority[0], 4);
831
832 payload = pframe;
833
834 for (curfragnum = 0; curfragnum < pattrib->nr_frags; curfragnum++) {
835 payload = (u8 *)round_up((SIZE_PTR)(payload), 4);
836 payload = payload + pattrib->hdrlen + pattrib->iv_len;
837
838 if ((curfragnum + 1) == pattrib->nr_frags) {
839 length = pattrib->last_txcmdsz - pattrib->hdrlen -
840 pattrib->iv_len -
841 ((pattrib->bswenc) ? pattrib->icv_len : 0);
842 rtw_secmicappend(&micdata, payload, length);
843 payload = payload + length;
844 } else {
845 length = pxmitpriv->frag_len - pattrib->hdrlen -
846 pattrib->iv_len -
847 ((pattrib->bswenc) ? pattrib->icv_len : 0);
848 rtw_secmicappend(&micdata, payload, length);
849 payload = payload + length + pattrib->icv_len;
850 }
851 }
852 rtw_secgetmic(&micdata, &mic[0]);
853 /* add mic code and add the mic code length in last_txcmdsz */
854
855 memcpy(payload, &mic[0], 8);
856 pattrib->last_txcmdsz += 8;
857 }
858 }
859 return _SUCCESS;
860 }
861
xmitframe_swencrypt(struct adapter * padapter,struct xmit_frame * pxmitframe)862 static s32 xmitframe_swencrypt(struct adapter *padapter, struct xmit_frame *pxmitframe)
863 {
864 struct pkt_attrib *pattrib = &pxmitframe->attrib;
865
866 if (pattrib->bswenc) {
867 switch (pattrib->encrypt) {
868 case _WEP40_:
869 case _WEP104_:
870 rtw_wep_encrypt(padapter, (u8 *)pxmitframe);
871 break;
872 case _TKIP_:
873 rtw_tkip_encrypt(padapter, (u8 *)pxmitframe);
874 break;
875 case _AES_:
876 rtw_aes_encrypt(padapter, (u8 *)pxmitframe);
877 break;
878 default:
879 break;
880 }
881 }
882
883 return _SUCCESS;
884 }
885
rtw_make_wlanhdr(struct adapter * padapter,u8 * hdr,struct pkt_attrib * pattrib)886 s32 rtw_make_wlanhdr(struct adapter *padapter, u8 *hdr, struct pkt_attrib *pattrib)
887 {
888 u16 *qc;
889
890 struct ieee80211_hdr *pwlanhdr = (struct ieee80211_hdr *)hdr;
891 struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
892 struct qos_priv *pqospriv = &pmlmepriv->qospriv;
893 u8 qos_option = false;
894 signed int res = _SUCCESS;
895 __le16 *fctrl = &pwlanhdr->frame_control;
896
897 memset(hdr, 0, WLANHDR_OFFSET);
898
899 SetFrameSubType(fctrl, pattrib->subtype);
900
901 if (pattrib->subtype & WIFI_DATA_TYPE) {
902 if (check_fwstate(pmlmepriv, WIFI_STATION_STATE) == true) {
903 /* to_ds = 1, fr_ds = 0; */
904
905 {
906 /* 1.Data transfer to AP */
907 /* 2.Arp pkt will relayed by AP */
908 SetToDs(fctrl);
909 memcpy(pwlanhdr->addr1, get_bssid(pmlmepriv), ETH_ALEN);
910 memcpy(pwlanhdr->addr2, pattrib->src, ETH_ALEN);
911 memcpy(pwlanhdr->addr3, pattrib->dst, ETH_ALEN);
912 }
913
914 if (pqospriv->qos_option)
915 qos_option = true;
916 } else if (check_fwstate(pmlmepriv, WIFI_AP_STATE) == true) {
917 /* to_ds = 0, fr_ds = 1; */
918 SetFrDs(fctrl);
919 memcpy(pwlanhdr->addr1, pattrib->dst, ETH_ALEN);
920 memcpy(pwlanhdr->addr2, get_bssid(pmlmepriv), ETH_ALEN);
921 memcpy(pwlanhdr->addr3, pattrib->src, ETH_ALEN);
922
923 if (pattrib->qos_en)
924 qos_option = true;
925 } else if ((check_fwstate(pmlmepriv, WIFI_ADHOC_STATE) == true) ||
926 (check_fwstate(pmlmepriv, WIFI_ADHOC_MASTER_STATE) == true)) {
927 memcpy(pwlanhdr->addr1, pattrib->dst, ETH_ALEN);
928 memcpy(pwlanhdr->addr2, pattrib->src, ETH_ALEN);
929 memcpy(pwlanhdr->addr3, get_bssid(pmlmepriv), ETH_ALEN);
930
931 if (pattrib->qos_en)
932 qos_option = true;
933 } else {
934 res = _FAIL;
935 goto exit;
936 }
937
938 if (pattrib->mdata)
939 SetMData(fctrl);
940
941 if (pattrib->encrypt)
942 SetPrivacy(fctrl);
943
944 if (qos_option) {
945 qc = (unsigned short *)(hdr + pattrib->hdrlen - 2);
946
947 if (pattrib->priority)
948 SetPriority(qc, pattrib->priority);
949
950 SetEOSP(qc, pattrib->eosp);
951
952 SetAckpolicy(qc, pattrib->ack_policy);
953 }
954
955 /* TODO: fill HT Control Field */
956
957 /* Update Seq Num will be handled by f/w */
958 {
959 struct sta_info *psta;
960
961 psta = rtw_get_stainfo(&padapter->stapriv, pattrib->ra);
962 if (pattrib->psta != psta)
963 return _FAIL;
964
965 if (!psta)
966 return _FAIL;
967
968 if (!(psta->state & _FW_LINKED))
969 return _FAIL;
970
971 if (psta) {
972 psta->sta_xmitpriv.txseq_tid[pattrib->priority]++;
973 psta->sta_xmitpriv.txseq_tid[pattrib->priority] %= 4096u;
974 pattrib->seqnum = psta->sta_xmitpriv.txseq_tid[pattrib->priority];
975
976 SetSeqNum(hdr, pattrib->seqnum);
977
978 /* check if enable ampdu */
979 if (pattrib->ht_en && psta->htpriv.ampdu_enable)
980 if (psta->htpriv.agg_enable_bitmap & BIT(pattrib->priority))
981 pattrib->ampdu_en = true;
982
983 /* re-check if enable ampdu by BA_starting_seqctrl */
984 if (pattrib->ampdu_en == true) {
985 u16 tx_seq;
986
987 tx_seq = psta->BA_starting_seqctrl[pattrib->priority & 0x0f];
988
989 /* check BA_starting_seqctrl */
990 if (SN_LESS(pattrib->seqnum, tx_seq)) {
991 pattrib->ampdu_en = false;/* AGG BK */
992 } else if (SN_EQUAL(pattrib->seqnum, tx_seq)) {
993 psta->BA_starting_seqctrl[pattrib->priority & 0x0f] =
994 (tx_seq + 1) % 4096u;
995
996 pattrib->ampdu_en = true;/* AGG EN */
997 } else {
998 psta->BA_starting_seqctrl[pattrib->priority & 0x0f] =
999 (pattrib->seqnum + 1) % 4096u;
1000
1001 pattrib->ampdu_en = true;/* AGG EN */
1002 }
1003 }
1004 }
1005 }
1006 } else {
1007 }
1008
1009 exit:
1010 return res;
1011 }
1012
rtw_txframes_pending(struct adapter * padapter)1013 s32 rtw_txframes_pending(struct adapter *padapter)
1014 {
1015 struct xmit_priv *pxmitpriv = &padapter->xmitpriv;
1016
1017 return ((!list_empty(&pxmitpriv->be_pending.queue)) ||
1018 (!list_empty(&pxmitpriv->bk_pending.queue)) ||
1019 (!list_empty(&pxmitpriv->vi_pending.queue)) ||
1020 (!list_empty(&pxmitpriv->vo_pending.queue)));
1021 }
1022
1023 /*
1024 * Calculate wlan 802.11 packet MAX size from pkt_attrib
1025 * This function doesn't consider fragment case
1026 */
rtw_calculate_wlan_pkt_size_by_attribue(struct pkt_attrib * pattrib)1027 u32 rtw_calculate_wlan_pkt_size_by_attribue(struct pkt_attrib *pattrib)
1028 {
1029 u32 len = 0;
1030
1031 len = pattrib->hdrlen + pattrib->iv_len; /* WLAN Header and IV */
1032 len += SNAP_SIZE + sizeof(u16); /* LLC */
1033 len += pattrib->pktlen;
1034 if (pattrib->encrypt == _TKIP_)
1035 len += 8; /* MIC */
1036 len += ((pattrib->bswenc) ? pattrib->icv_len : 0); /* ICV */
1037
1038 return len;
1039 }
1040
1041 /*
1042 * This sub-routine will perform all the following:
1043 * 1. remove 802.3 header.
1044 * 2. create wlan_header, based on the info in pxmitframe
1045 * 3. append sta's iv/ext-iv
1046 * 4. append LLC
1047 * 5. move frag chunk from pframe to pxmitframe->mem
1048 * 6. apply sw-encrypt, if necessary.
1049 */
rtw_xmitframe_coalesce(struct adapter * padapter,struct sk_buff * pkt,struct xmit_frame * pxmitframe)1050 s32 rtw_xmitframe_coalesce(struct adapter *padapter, struct sk_buff *pkt, struct xmit_frame *pxmitframe)
1051 {
1052 struct pkt_file pktfile;
1053
1054 s32 frg_inx, frg_len, mpdu_len, llc_sz, mem_sz;
1055
1056 SIZE_PTR addr;
1057
1058 u8 *pframe, *mem_start;
1059 u8 hw_hdr_offset;
1060
1061 struct xmit_priv *pxmitpriv = &padapter->xmitpriv;
1062
1063 struct pkt_attrib *pattrib = &pxmitframe->attrib;
1064
1065 u8 *pbuf_start;
1066
1067 s32 bmcst = is_multicast_ether_addr(pattrib->ra);
1068 s32 res = _SUCCESS;
1069 int ret;
1070
1071 if (!pxmitframe->buf_addr)
1072 return _FAIL;
1073
1074 pbuf_start = pxmitframe->buf_addr;
1075
1076 hw_hdr_offset = TXDESC_OFFSET;
1077 mem_start = pbuf_start + hw_hdr_offset;
1078
1079 if (rtw_make_wlanhdr(padapter, mem_start, pattrib) == _FAIL) {
1080 res = _FAIL;
1081 goto exit;
1082 }
1083
1084 _rtw_open_pktfile(pkt, &pktfile);
1085 ret = _rtw_pktfile_read(&pktfile, NULL, pattrib->pkt_hdrlen);
1086 if (ret < 0)
1087 return ret;
1088
1089 frg_inx = 0;
1090 frg_len = pxmitpriv->frag_len - 4;/* 2346-4 = 2342 */
1091
1092 while (1) {
1093 llc_sz = 0;
1094
1095 mpdu_len = frg_len;
1096
1097 pframe = mem_start;
1098
1099 SetMFrag(mem_start);
1100
1101 pframe += pattrib->hdrlen;
1102 mpdu_len -= pattrib->hdrlen;
1103
1104 /* adding icv, if necessary... */
1105 if (pattrib->iv_len) {
1106 memcpy(pframe, pattrib->iv, pattrib->iv_len);
1107
1108 pframe += pattrib->iv_len;
1109
1110 mpdu_len -= pattrib->iv_len;
1111 }
1112
1113 if (frg_inx == 0) {
1114 llc_sz = rtw_put_snap(pframe, pattrib->ether_type);
1115 pframe += llc_sz;
1116 mpdu_len -= llc_sz;
1117 }
1118
1119 if ((pattrib->icv_len > 0) && (pattrib->bswenc))
1120 mpdu_len -= pattrib->icv_len;
1121
1122 if (bmcst) {
1123 /* don't do fragment to broadcast/multicast packets */
1124 mem_sz = _rtw_pktfile_read(&pktfile, pframe, pattrib->pktlen);
1125 } else {
1126 mem_sz = _rtw_pktfile_read(&pktfile, pframe, mpdu_len);
1127 }
1128
1129 if (mem_sz < 0)
1130 return mem_sz;
1131
1132 pframe += mem_sz;
1133
1134 if ((pattrib->icv_len > 0) && (pattrib->bswenc)) {
1135 memcpy(pframe, pattrib->icv, pattrib->icv_len);
1136 pframe += pattrib->icv_len;
1137 }
1138
1139 frg_inx++;
1140
1141 if (bmcst || (rtw_endofpktfile(&pktfile) == true)) {
1142 pattrib->nr_frags = frg_inx;
1143
1144 pattrib->last_txcmdsz = pattrib->hdrlen + pattrib->iv_len +
1145 ((pattrib->nr_frags == 1) ? llc_sz : 0) +
1146 ((pattrib->bswenc) ? pattrib->icv_len : 0) +
1147 mem_sz;
1148
1149 ClearMFrag(mem_start);
1150
1151 break;
1152 }
1153
1154 addr = (SIZE_PTR)(pframe);
1155
1156 mem_start = (unsigned char *)round_up(addr, 4) + hw_hdr_offset;
1157 memcpy(mem_start, pbuf_start + hw_hdr_offset, pattrib->hdrlen);
1158 }
1159
1160 if (xmitframe_addmic(padapter, pxmitframe) == _FAIL) {
1161 res = _FAIL;
1162 goto exit;
1163 }
1164
1165 xmitframe_swencrypt(padapter, pxmitframe);
1166
1167 if (bmcst == false)
1168 update_attrib_vcs_info(padapter, pxmitframe);
1169 else
1170 pattrib->vcs_mode = NONE_VCS;
1171
1172 exit:
1173 return res;
1174 }
1175
1176 /* broadcast or multicast management pkt use BIP, unicast management pkt use CCMP encryption */
rtw_mgmt_xmitframe_coalesce(struct adapter * padapter,struct sk_buff * pkt,struct xmit_frame * pxmitframe)1177 s32 rtw_mgmt_xmitframe_coalesce(struct adapter *padapter, struct sk_buff *pkt, struct xmit_frame *pxmitframe)
1178 {
1179 u8 *pframe, *mem_start = NULL, *tmp_buf = NULL;
1180 u8 subtype;
1181 struct sta_info *psta = NULL;
1182 struct pkt_attrib *pattrib = &pxmitframe->attrib;
1183 s32 bmcst = is_multicast_ether_addr(pattrib->ra);
1184 u8 *BIP_AAD = NULL;
1185 u8 *MGMT_body = NULL;
1186
1187 struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
1188 struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
1189 struct ieee80211_hdr *pwlanhdr;
1190 u8 MME[_MME_IE_LENGTH_];
1191 u32 ori_len;
1192
1193 mem_start = pframe = (u8 *)(pxmitframe->buf_addr) + TXDESC_OFFSET;
1194 pwlanhdr = (struct ieee80211_hdr *)pframe;
1195
1196 ori_len = BIP_AAD_SIZE + pattrib->pktlen;
1197 tmp_buf = BIP_AAD = kzalloc(ori_len, GFP_ATOMIC);
1198 subtype = GetFrameSubType(pframe); /* bit(7)~bit(2) */
1199
1200 if (!BIP_AAD)
1201 return _FAIL;
1202
1203 spin_lock_bh(&padapter->security_key_mutex);
1204
1205 /* only support station mode */
1206 if (!check_fwstate(pmlmepriv, WIFI_STATION_STATE) || !check_fwstate(pmlmepriv, _FW_LINKED))
1207 goto xmitframe_coalesce_success;
1208
1209 /* IGTK key is not install, it may not support 802.11w */
1210 if (!padapter->securitypriv.binstallBIPkey)
1211 goto xmitframe_coalesce_success;
1212
1213 /* station mode doesn't need TX BIP, just ready the code */
1214 if (bmcst) {
1215 int frame_body_len;
1216 u8 mic[16];
1217
1218 memset(MME, 0, 18);
1219
1220 /* other types doesn't need the BIP */
1221 if (GetFrameSubType(pframe) != WIFI_DEAUTH && GetFrameSubType(pframe) != WIFI_DISASSOC)
1222 goto xmitframe_coalesce_fail;
1223
1224 MGMT_body = pframe + sizeof(struct ieee80211_hdr_3addr);
1225 pframe += pattrib->pktlen;
1226
1227 /* octent 0 and 1 is key index , BIP keyid is 4 or 5, LSB only need octent 0 */
1228 MME[0] = padapter->securitypriv.dot11wBIPKeyid;
1229 /* copy packet number */
1230 memcpy(&MME[2], &pmlmeext->mgnt_80211w_IPN, 6);
1231 /* increase the packet number */
1232 pmlmeext->mgnt_80211w_IPN++;
1233
1234 /* add MME IE with MIC all zero, MME string doesn't include element id and length */
1235 pframe = rtw_set_ie(pframe, WLAN_EID_MMIE, 16,
1236 MME, &pattrib->pktlen);
1237 pattrib->last_txcmdsz = pattrib->pktlen;
1238 /* total frame length - header length */
1239 frame_body_len = pattrib->pktlen - sizeof(struct ieee80211_hdr_3addr);
1240
1241 /* conscruct AAD, copy frame control field */
1242 memcpy(BIP_AAD, &pwlanhdr->frame_control, 2);
1243 ClearRetry(BIP_AAD);
1244 ClearPwrMgt(BIP_AAD);
1245 ClearMData(BIP_AAD);
1246 /* conscruct AAD, copy address 1 to address 3 */
1247 memcpy(BIP_AAD + 2, &pwlanhdr->addrs, sizeof(pwlanhdr->addrs));
1248 /* copy management fram body */
1249 memcpy(BIP_AAD + BIP_AAD_SIZE, MGMT_body, frame_body_len);
1250 /* calculate mic */
1251 if (omac1_aes_128(padapter->securitypriv.dot11wBIPKey[padapter->securitypriv.dot11wBIPKeyid].skey
1252 , BIP_AAD, BIP_AAD_SIZE + frame_body_len, mic))
1253 goto xmitframe_coalesce_fail;
1254
1255 /* copy right BIP mic value, total is 128bits, we use the 0~63 bits */
1256 memcpy(pframe - 8, mic, 8);
1257 } else { /* unicast mgmt frame TX */
1258 /* start to encrypt mgmt frame */
1259 if (subtype == WIFI_DEAUTH || subtype == WIFI_DISASSOC ||
1260 subtype == WIFI_REASSOCREQ || subtype == WIFI_ACTION) {
1261 if (pattrib->psta)
1262 psta = pattrib->psta;
1263 else
1264 psta = rtw_get_stainfo(&padapter->stapriv, pattrib->ra);
1265
1266 if (!psta)
1267 goto xmitframe_coalesce_fail;
1268
1269 if (!(psta->state & _FW_LINKED) || !pxmitframe->buf_addr)
1270 goto xmitframe_coalesce_fail;
1271
1272 /* according 802.11-2012 standard, these five types are not robust types */
1273 if (subtype == WIFI_ACTION &&
1274 (pframe[WLAN_HDR_A3_LEN] == RTW_WLAN_CATEGORY_PUBLIC ||
1275 pframe[WLAN_HDR_A3_LEN] == RTW_WLAN_CATEGORY_HT ||
1276 pframe[WLAN_HDR_A3_LEN] == RTW_WLAN_CATEGORY_UNPROTECTED_WNM ||
1277 pframe[WLAN_HDR_A3_LEN] == RTW_WLAN_CATEGORY_SELF_PROTECTED ||
1278 pframe[WLAN_HDR_A3_LEN] == RTW_WLAN_CATEGORY_P2P))
1279 goto xmitframe_coalesce_fail;
1280 /* before encrypt dump the management packet content */
1281 if (pattrib->encrypt > 0)
1282 memcpy(pattrib->dot118021x_UncstKey.skey, psta->dot118021x_UncstKey.skey, 16);
1283 /* bakeup original management packet */
1284 memcpy(tmp_buf, pframe, pattrib->pktlen);
1285 /* move to data portion */
1286 pframe += pattrib->hdrlen;
1287
1288 /* 802.11w unicast management packet must be _AES_ */
1289 pattrib->iv_len = 8;
1290 /* it's MIC of AES */
1291 pattrib->icv_len = 8;
1292
1293 switch (pattrib->encrypt) {
1294 case _AES_:
1295 /* set AES IV header */
1296 AES_IV(pattrib->iv, psta->dot11wtxpn, 0);
1297 break;
1298 default:
1299 goto xmitframe_coalesce_fail;
1300 }
1301 /* insert iv header into management frame */
1302 memcpy(pframe, pattrib->iv, pattrib->iv_len);
1303 pframe += pattrib->iv_len;
1304 /* copy mgmt data portion after CCMP header */
1305 memcpy(pframe, tmp_buf + pattrib->hdrlen,
1306 pattrib->pktlen - pattrib->hdrlen);
1307 /* move pframe to end of mgmt pkt */
1308 pframe += pattrib->pktlen - pattrib->hdrlen;
1309 /* add 8 bytes CCMP IV header to length */
1310 pattrib->pktlen += pattrib->iv_len;
1311 if ((pattrib->icv_len > 0) && (pattrib->bswenc)) {
1312 memcpy(pframe, pattrib->icv, pattrib->icv_len);
1313 pframe += pattrib->icv_len;
1314 }
1315 /* add 8 bytes MIC */
1316 pattrib->pktlen += pattrib->icv_len;
1317 /* set final tx command size */
1318 pattrib->last_txcmdsz = pattrib->pktlen;
1319
1320 /* set protected bit must be beofre SW encrypt */
1321 SetPrivacy(mem_start);
1322 /* software encrypt */
1323 xmitframe_swencrypt(padapter, pxmitframe);
1324 }
1325 }
1326
1327 xmitframe_coalesce_success:
1328 spin_unlock_bh(&padapter->security_key_mutex);
1329 kfree(BIP_AAD);
1330 return _SUCCESS;
1331
1332 xmitframe_coalesce_fail:
1333 spin_unlock_bh(&padapter->security_key_mutex);
1334 kfree(BIP_AAD);
1335 return _FAIL;
1336 }
1337
1338 /* Logical Link Control(LLC) SubNetwork Attachment Point(SNAP) header
1339 * IEEE LLC/SNAP header contains 8 octets
1340 * First 3 octets comprise the LLC portion
1341 * SNAP portion, 5 octets, is divided into two fields:
1342 *Organizationally Unique Identifier(OUI), 3 octets,
1343 *type, defined by that organization, 2 octets.
1344 */
rtw_put_snap(u8 * data,u16 h_proto)1345 s32 rtw_put_snap(u8 *data, u16 h_proto)
1346 {
1347 struct ieee80211_snap_hdr *snap;
1348 u8 *oui;
1349
1350 snap = (struct ieee80211_snap_hdr *)data;
1351 snap->dsap = 0xaa;
1352 snap->ssap = 0xaa;
1353 snap->ctrl = 0x03;
1354
1355 if (h_proto == 0x8137 || h_proto == 0x80f3)
1356 oui = P802_1H_OUI;
1357 else
1358 oui = RFC1042_OUI;
1359
1360 snap->oui[0] = oui[0];
1361 snap->oui[1] = oui[1];
1362 snap->oui[2] = oui[2];
1363
1364 *(__be16 *)(data + SNAP_SIZE) = htons(h_proto);
1365
1366 return SNAP_SIZE + sizeof(u16);
1367 }
1368
rtw_update_protection(struct adapter * padapter,u8 * ie,uint ie_len)1369 void rtw_update_protection(struct adapter *padapter, u8 *ie, uint ie_len)
1370 {
1371 uint protection;
1372 u8 *perp;
1373 signed int erp_len;
1374 struct xmit_priv *pxmitpriv = &padapter->xmitpriv;
1375 struct registry_priv *pregistrypriv = &padapter->registrypriv;
1376
1377 switch (pxmitpriv->vcs_setting) {
1378 case DISABLE_VCS:
1379 pxmitpriv->vcs = NONE_VCS;
1380 break;
1381
1382 case ENABLE_VCS:
1383 break;
1384
1385 case AUTO_VCS:
1386 default:
1387 perp = rtw_get_ie(ie, WLAN_EID_ERP_INFO, &erp_len, ie_len);
1388 if (!perp) {
1389 pxmitpriv->vcs = NONE_VCS;
1390 } else {
1391 protection = (*(perp + 2)) & BIT(1);
1392 if (protection) {
1393 if (pregistrypriv->vcs_type == RTS_CTS)
1394 pxmitpriv->vcs = RTS_CTS;
1395 else
1396 pxmitpriv->vcs = CTS_TO_SELF;
1397 } else {
1398 pxmitpriv->vcs = NONE_VCS;
1399 }
1400 }
1401
1402 break;
1403 }
1404 }
1405
rtw_count_tx_stats(struct adapter * padapter,struct xmit_frame * pxmitframe,int sz)1406 void rtw_count_tx_stats(struct adapter *padapter, struct xmit_frame *pxmitframe, int sz)
1407 {
1408 struct sta_info *psta = NULL;
1409 struct stainfo_stats *pstats = NULL;
1410 struct xmit_priv *pxmitpriv = &padapter->xmitpriv;
1411 struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
1412 u8 pkt_num = 1;
1413
1414 if ((pxmitframe->frame_tag & 0x0f) == DATA_FRAMETAG) {
1415 pkt_num = pxmitframe->agg_num;
1416
1417 pmlmepriv->LinkDetectInfo.NumTxOkInPeriod += pkt_num;
1418
1419 pxmitpriv->tx_pkts += pkt_num;
1420
1421 pxmitpriv->tx_bytes += sz;
1422
1423 psta = pxmitframe->attrib.psta;
1424 if (psta) {
1425 pstats = &psta->sta_stats;
1426
1427 pstats->tx_pkts += pkt_num;
1428
1429 pstats->tx_bytes += sz;
1430 }
1431 }
1432 }
1433
__rtw_alloc_cmd_xmitbuf(struct xmit_priv * pxmitpriv,enum cmdbuf_type buf_type)1434 static struct xmit_buf *__rtw_alloc_cmd_xmitbuf(struct xmit_priv *pxmitpriv,
1435 enum cmdbuf_type buf_type)
1436 {
1437 struct xmit_buf *pxmitbuf = NULL;
1438
1439 pxmitbuf = &pxmitpriv->pcmd_xmitbuf[buf_type];
1440 if (pxmitbuf) {
1441 pxmitbuf->priv_data = NULL;
1442
1443 pxmitbuf->len = 0;
1444 pxmitbuf->pdata = pxmitbuf->ptail = pxmitbuf->phead;
1445 pxmitbuf->agg_num = 0;
1446 pxmitbuf->pg_num = 0;
1447
1448 if (pxmitbuf->sctx)
1449 rtw_sctx_done_err(&pxmitbuf->sctx, RTW_SCTX_DONE_BUF_ALLOC);
1450 }
1451
1452 return pxmitbuf;
1453 }
1454
__rtw_alloc_cmdxmitframe(struct xmit_priv * pxmitpriv,enum cmdbuf_type buf_type)1455 struct xmit_frame *__rtw_alloc_cmdxmitframe(struct xmit_priv *pxmitpriv,
1456 enum cmdbuf_type buf_type)
1457 {
1458 struct xmit_frame *pcmdframe;
1459 struct xmit_buf *pxmitbuf;
1460
1461 pcmdframe = rtw_alloc_xmitframe(pxmitpriv);
1462 if (!pcmdframe)
1463 return NULL;
1464
1465 pxmitbuf = __rtw_alloc_cmd_xmitbuf(pxmitpriv, buf_type);
1466 if (!pxmitbuf) {
1467 rtw_free_xmitframe(pxmitpriv, pcmdframe);
1468 return NULL;
1469 }
1470
1471 pcmdframe->frame_tag = MGNT_FRAMETAG;
1472
1473 pcmdframe->pxmitbuf = pxmitbuf;
1474
1475 pcmdframe->buf_addr = pxmitbuf->pbuf;
1476
1477 pxmitbuf->priv_data = pcmdframe;
1478
1479 return pcmdframe;
1480 }
1481
rtw_alloc_xmitbuf_ext(struct xmit_priv * pxmitpriv)1482 struct xmit_buf *rtw_alloc_xmitbuf_ext(struct xmit_priv *pxmitpriv)
1483 {
1484 unsigned long irqL;
1485 struct xmit_buf *pxmitbuf = NULL;
1486 struct list_head *plist, *phead;
1487 struct __queue *pfree_queue = &pxmitpriv->free_xmit_extbuf_queue;
1488
1489 spin_lock_irqsave(&pfree_queue->lock, irqL);
1490
1491 if (list_empty(&pfree_queue->queue)) {
1492 pxmitbuf = NULL;
1493 } else {
1494 phead = get_list_head(pfree_queue);
1495
1496 plist = get_next(phead);
1497
1498 pxmitbuf = container_of(plist, struct xmit_buf, list);
1499
1500 list_del_init(&pxmitbuf->list);
1501 }
1502
1503 if (pxmitbuf) {
1504 pxmitpriv->free_xmit_extbuf_cnt--;
1505
1506 pxmitbuf->priv_data = NULL;
1507
1508 pxmitbuf->len = 0;
1509 pxmitbuf->pdata = pxmitbuf->phead;
1510 pxmitbuf->ptail = pxmitbuf->phead;
1511 pxmitbuf->agg_num = 1;
1512
1513 if (pxmitbuf->sctx)
1514 rtw_sctx_done_err(&pxmitbuf->sctx, RTW_SCTX_DONE_BUF_ALLOC);
1515 }
1516
1517 spin_unlock_irqrestore(&pfree_queue->lock, irqL);
1518
1519 return pxmitbuf;
1520 }
1521
rtw_free_xmitbuf_ext(struct xmit_priv * pxmitpriv,struct xmit_buf * pxmitbuf)1522 s32 rtw_free_xmitbuf_ext(struct xmit_priv *pxmitpriv, struct xmit_buf *pxmitbuf)
1523 {
1524 unsigned long irqL;
1525 struct __queue *pfree_queue = &pxmitpriv->free_xmit_extbuf_queue;
1526
1527 if (!pxmitbuf)
1528 return _FAIL;
1529
1530 spin_lock_irqsave(&pfree_queue->lock, irqL);
1531
1532 list_del_init(&pxmitbuf->list);
1533
1534 list_add_tail(&pxmitbuf->list, get_list_head(pfree_queue));
1535 pxmitpriv->free_xmit_extbuf_cnt++;
1536
1537 spin_unlock_irqrestore(&pfree_queue->lock, irqL);
1538
1539 return _SUCCESS;
1540 }
1541
rtw_alloc_xmitbuf(struct xmit_priv * pxmitpriv)1542 struct xmit_buf *rtw_alloc_xmitbuf(struct xmit_priv *pxmitpriv)
1543 {
1544 unsigned long irqL;
1545 struct xmit_buf *pxmitbuf = NULL;
1546 struct list_head *plist, *phead;
1547 struct __queue *pfree_xmitbuf_queue = &pxmitpriv->free_xmitbuf_queue;
1548
1549 spin_lock_irqsave(&pfree_xmitbuf_queue->lock, irqL);
1550
1551 if (list_empty(&pfree_xmitbuf_queue->queue)) {
1552 pxmitbuf = NULL;
1553 } else {
1554 phead = get_list_head(pfree_xmitbuf_queue);
1555
1556 plist = get_next(phead);
1557
1558 pxmitbuf = container_of(plist, struct xmit_buf, list);
1559
1560 list_del_init(&pxmitbuf->list);
1561 }
1562
1563 if (pxmitbuf) {
1564 pxmitpriv->free_xmitbuf_cnt--;
1565
1566 pxmitbuf->priv_data = NULL;
1567
1568 pxmitbuf->len = 0;
1569 pxmitbuf->pdata = pxmitbuf->phead;
1570 pxmitbuf->ptail = pxmitbuf->phead;
1571 pxmitbuf->agg_num = 0;
1572 pxmitbuf->pg_num = 0;
1573
1574 if (pxmitbuf->sctx)
1575 rtw_sctx_done_err(&pxmitbuf->sctx, RTW_SCTX_DONE_BUF_ALLOC);
1576 }
1577
1578 spin_unlock_irqrestore(&pfree_xmitbuf_queue->lock, irqL);
1579
1580 return pxmitbuf;
1581 }
1582
rtw_free_xmitbuf(struct xmit_priv * pxmitpriv,struct xmit_buf * pxmitbuf)1583 s32 rtw_free_xmitbuf(struct xmit_priv *pxmitpriv, struct xmit_buf *pxmitbuf)
1584 {
1585 unsigned long irqL;
1586 struct __queue *pfree_xmitbuf_queue = &pxmitpriv->free_xmitbuf_queue;
1587
1588 if (!pxmitbuf)
1589 return _FAIL;
1590
1591 if (pxmitbuf->sctx)
1592 rtw_sctx_done_err(&pxmitbuf->sctx, RTW_SCTX_DONE_BUF_FREE);
1593
1594 if (pxmitbuf->buf_tag == XMITBUF_CMD) {
1595 } else if (pxmitbuf->buf_tag == XMITBUF_MGNT) {
1596 rtw_free_xmitbuf_ext(pxmitpriv, pxmitbuf);
1597 } else {
1598 spin_lock_irqsave(&pfree_xmitbuf_queue->lock, irqL);
1599
1600 list_del_init(&pxmitbuf->list);
1601
1602 list_add_tail(&pxmitbuf->list,
1603 get_list_head(pfree_xmitbuf_queue));
1604
1605 pxmitpriv->free_xmitbuf_cnt++;
1606 spin_unlock_irqrestore(&pfree_xmitbuf_queue->lock, irqL);
1607 }
1608 return _SUCCESS;
1609 }
1610
rtw_init_xmitframe(struct xmit_frame * pxframe)1611 static void rtw_init_xmitframe(struct xmit_frame *pxframe)
1612 {
1613 if (pxframe) { /* default value setting */
1614 pxframe->buf_addr = NULL;
1615 pxframe->pxmitbuf = NULL;
1616
1617 memset(&pxframe->attrib, 0, sizeof(struct pkt_attrib));
1618
1619 pxframe->frame_tag = DATA_FRAMETAG;
1620
1621 pxframe->pg_num = 1;
1622 pxframe->agg_num = 1;
1623 pxframe->ack_report = 0;
1624 }
1625 }
1626
1627 /*
1628 * Calling context:
1629 * 1. OS_TXENTRY
1630 * 2. RXENTRY (rx_thread or RX_ISR/RX_CallBack)
1631 *
1632 * If we turn on USE_RXTHREAD, then, no need for critical section.
1633 * Otherwise, we must use _enter/_exit critical to protect free_xmit_queue...
1634 *
1635 * Must be very, very cautious...
1636 */
rtw_alloc_xmitframe(struct xmit_priv * pxmitpriv)1637 struct xmit_frame *rtw_alloc_xmitframe(struct xmit_priv *pxmitpriv)/* _queue *pfree_xmit_queue) */
1638 {
1639 /*
1640 * Please remember to use all the osdep_service api,
1641 * and lock/unlock or _enter/_exit critical to protect
1642 * pfree_xmit_queue
1643 */
1644
1645 struct xmit_frame *pxframe = NULL;
1646 struct list_head *plist, *phead;
1647 struct __queue *pfree_xmit_queue = &pxmitpriv->free_xmit_queue;
1648
1649 spin_lock_bh(&pfree_xmit_queue->lock);
1650
1651 if (list_empty(&pfree_xmit_queue->queue)) {
1652 pxframe = NULL;
1653 } else {
1654 phead = get_list_head(pfree_xmit_queue);
1655
1656 plist = get_next(phead);
1657
1658 pxframe = container_of(plist, struct xmit_frame, list);
1659
1660 list_del_init(&pxframe->list);
1661 pxmitpriv->free_xmitframe_cnt--;
1662 }
1663
1664 spin_unlock_bh(&pfree_xmit_queue->lock);
1665
1666 rtw_init_xmitframe(pxframe);
1667 return pxframe;
1668 }
1669
rtw_alloc_xmitframe_ext(struct xmit_priv * pxmitpriv)1670 struct xmit_frame *rtw_alloc_xmitframe_ext(struct xmit_priv *pxmitpriv)
1671 {
1672 struct xmit_frame *pxframe = NULL;
1673 struct list_head *plist, *phead;
1674 struct __queue *queue = &pxmitpriv->free_xframe_ext_queue;
1675
1676 spin_lock_bh(&queue->lock);
1677
1678 if (list_empty(&queue->queue)) {
1679 pxframe = NULL;
1680 } else {
1681 phead = get_list_head(queue);
1682 plist = get_next(phead);
1683 pxframe = container_of(plist, struct xmit_frame, list);
1684
1685 list_del_init(&pxframe->list);
1686 pxmitpriv->free_xframe_ext_cnt--;
1687 }
1688
1689 spin_unlock_bh(&queue->lock);
1690
1691 rtw_init_xmitframe(pxframe);
1692
1693 return pxframe;
1694 }
1695
rtw_alloc_xmitframe_once(struct xmit_priv * pxmitpriv)1696 struct xmit_frame *rtw_alloc_xmitframe_once(struct xmit_priv *pxmitpriv)
1697 {
1698 struct xmit_frame *pxframe = NULL;
1699 u8 *alloc_addr;
1700
1701 alloc_addr = kzalloc(sizeof(*pxframe) + 4, GFP_ATOMIC);
1702 if (!alloc_addr)
1703 goto exit;
1704
1705 pxframe = (struct xmit_frame *)N_BYTE_ALIGMENT((SIZE_PTR)(alloc_addr), 4);
1706 pxframe->alloc_addr = alloc_addr;
1707
1708 pxframe->padapter = pxmitpriv->adapter;
1709 pxframe->frame_tag = NULL_FRAMETAG;
1710
1711 pxframe->pkt = NULL;
1712
1713 pxframe->buf_addr = NULL;
1714 pxframe->pxmitbuf = NULL;
1715
1716 rtw_init_xmitframe(pxframe);
1717
1718 exit:
1719 return pxframe;
1720 }
1721
rtw_free_xmitframe(struct xmit_priv * pxmitpriv,struct xmit_frame * pxmitframe)1722 s32 rtw_free_xmitframe(struct xmit_priv *pxmitpriv, struct xmit_frame *pxmitframe)
1723 {
1724 struct __queue *queue = NULL;
1725 struct adapter *padapter = pxmitpriv->adapter;
1726 struct sk_buff *pndis_pkt = NULL;
1727
1728 if (!pxmitframe)
1729 goto exit;
1730
1731 if (pxmitframe->pkt) {
1732 pndis_pkt = pxmitframe->pkt;
1733 pxmitframe->pkt = NULL;
1734 }
1735
1736 if (pxmitframe->alloc_addr) {
1737 kfree(pxmitframe->alloc_addr);
1738 goto check_pkt_complete;
1739 }
1740
1741 if (pxmitframe->ext_tag == 0)
1742 queue = &pxmitpriv->free_xmit_queue;
1743 else if (pxmitframe->ext_tag == 1)
1744 queue = &pxmitpriv->free_xframe_ext_queue;
1745
1746 spin_lock_bh(&queue->lock);
1747
1748 list_del_init(&pxmitframe->list);
1749 list_add_tail(&pxmitframe->list, get_list_head(queue));
1750 if (pxmitframe->ext_tag == 0)
1751 pxmitpriv->free_xmitframe_cnt++;
1752 else if (pxmitframe->ext_tag == 1)
1753 pxmitpriv->free_xframe_ext_cnt++;
1754
1755 spin_unlock_bh(&queue->lock);
1756
1757 check_pkt_complete:
1758
1759 if (pndis_pkt)
1760 rtw_os_pkt_complete(padapter, pndis_pkt);
1761
1762 exit:
1763 return _SUCCESS;
1764 }
1765
rtw_free_xmitframe_queue(struct xmit_priv * pxmitpriv,struct __queue * pframequeue)1766 void rtw_free_xmitframe_queue(struct xmit_priv *pxmitpriv, struct __queue *pframequeue)
1767 {
1768 struct list_head *plist, *phead, *tmp;
1769 struct xmit_frame *pxmitframe;
1770
1771 spin_lock_bh(&pframequeue->lock);
1772
1773 phead = get_list_head(pframequeue);
1774 list_for_each_safe(plist, tmp, phead) {
1775 pxmitframe = list_entry(plist, struct xmit_frame, list);
1776
1777 rtw_free_xmitframe(pxmitpriv, pxmitframe);
1778 }
1779 spin_unlock_bh(&pframequeue->lock);
1780 }
1781
rtw_xmitframe_enqueue(struct adapter * padapter,struct xmit_frame * pxmitframe)1782 s32 rtw_xmitframe_enqueue(struct adapter *padapter, struct xmit_frame *pxmitframe)
1783 {
1784 if (rtw_xmit_classifier(padapter, pxmitframe) == _FAIL)
1785 return _FAIL;
1786
1787 return _SUCCESS;
1788 }
1789
rtw_get_sta_pending(struct adapter * padapter,struct sta_info * psta,signed int up,u8 * ac)1790 struct tx_servq *rtw_get_sta_pending(struct adapter *padapter, struct sta_info *psta, signed int up, u8 *ac)
1791 {
1792 struct tx_servq *ptxservq = NULL;
1793
1794 switch (up) {
1795 case 1:
1796 case 2:
1797 ptxservq = &psta->sta_xmitpriv.bk_q;
1798 *(ac) = 3;
1799 break;
1800
1801 case 4:
1802 case 5:
1803 ptxservq = &psta->sta_xmitpriv.vi_q;
1804 *(ac) = 1;
1805 break;
1806
1807 case 6:
1808 case 7:
1809 ptxservq = &psta->sta_xmitpriv.vo_q;
1810 *(ac) = 0;
1811 break;
1812
1813 case 0:
1814 case 3:
1815 default:
1816 ptxservq = &psta->sta_xmitpriv.be_q;
1817 *(ac) = 2;
1818 break;
1819 }
1820
1821 return ptxservq;
1822 }
1823
1824 /*
1825 * Will enqueue pxmitframe to the proper queue,
1826 * and indicate it to xx_pending list.....
1827 */
rtw_xmit_classifier(struct adapter * padapter,struct xmit_frame * pxmitframe)1828 s32 rtw_xmit_classifier(struct adapter *padapter, struct xmit_frame *pxmitframe)
1829 {
1830 u8 ac_index;
1831 struct sta_info *psta;
1832 struct tx_servq *ptxservq;
1833 struct pkt_attrib *pattrib = &pxmitframe->attrib;
1834 struct hw_xmit *phwxmits = padapter->xmitpriv.hwxmits;
1835 signed int res = _SUCCESS;
1836
1837 psta = rtw_get_stainfo(&padapter->stapriv, pattrib->ra);
1838 if (pattrib->psta != psta)
1839 return _FAIL;
1840
1841 if (!psta) {
1842 res = _FAIL;
1843 goto exit;
1844 }
1845
1846 if (!(psta->state & _FW_LINKED))
1847 return _FAIL;
1848
1849 ptxservq = rtw_get_sta_pending(padapter, psta, pattrib->priority, (u8 *)(&ac_index));
1850
1851 if (list_empty(&ptxservq->tx_pending))
1852 list_add_tail(&ptxservq->tx_pending, get_list_head(phwxmits[ac_index].sta_queue));
1853
1854 list_add_tail(&pxmitframe->list, get_list_head(&ptxservq->sta_pending));
1855 ptxservq->qcnt++;
1856 phwxmits[ac_index].accnt++;
1857
1858 exit:
1859
1860 return res;
1861 }
1862
rtw_alloc_hwxmits(struct adapter * padapter)1863 s32 rtw_alloc_hwxmits(struct adapter *padapter)
1864 {
1865 struct hw_xmit *hwxmits;
1866 struct xmit_priv *pxmitpriv = &padapter->xmitpriv;
1867
1868 pxmitpriv->hwxmit_entry = HWXMIT_ENTRY;
1869
1870 pxmitpriv->hwxmits = NULL;
1871
1872 pxmitpriv->hwxmits = kzalloc_objs(*hwxmits, pxmitpriv->hwxmit_entry,
1873 GFP_ATOMIC);
1874 if (!pxmitpriv->hwxmits)
1875 return _FAIL;
1876
1877 hwxmits = pxmitpriv->hwxmits;
1878
1879 if (pxmitpriv->hwxmit_entry == 5) {
1880 hwxmits[0] .sta_queue = &pxmitpriv->bm_pending;
1881
1882 hwxmits[1] .sta_queue = &pxmitpriv->vo_pending;
1883
1884 hwxmits[2] .sta_queue = &pxmitpriv->vi_pending;
1885
1886 hwxmits[3] .sta_queue = &pxmitpriv->bk_pending;
1887
1888 hwxmits[4] .sta_queue = &pxmitpriv->be_pending;
1889 } else if (pxmitpriv->hwxmit_entry == 4) {
1890 hwxmits[0] .sta_queue = &pxmitpriv->vo_pending;
1891
1892 hwxmits[1] .sta_queue = &pxmitpriv->vi_pending;
1893
1894 hwxmits[2] .sta_queue = &pxmitpriv->be_pending;
1895
1896 hwxmits[3] .sta_queue = &pxmitpriv->bk_pending;
1897 } else {
1898 }
1899
1900 return _SUCCESS;
1901 }
1902
rtw_free_hwxmits(struct adapter * padapter)1903 void rtw_free_hwxmits(struct adapter *padapter)
1904 {
1905 struct xmit_priv *pxmitpriv = &padapter->xmitpriv;
1906
1907 kfree(pxmitpriv->hwxmits);
1908 }
1909
rtw_init_hwxmits(struct hw_xmit * phwxmit,signed int entry)1910 void rtw_init_hwxmits(struct hw_xmit *phwxmit, signed int entry)
1911 {
1912 signed int i;
1913
1914 for (i = 0; i < entry; i++, phwxmit++)
1915 phwxmit->accnt = 0;
1916 }
1917
rtw_get_ff_hwaddr(struct xmit_frame * pxmitframe)1918 u32 rtw_get_ff_hwaddr(struct xmit_frame *pxmitframe)
1919 {
1920 u32 addr;
1921 struct pkt_attrib *pattrib = &pxmitframe->attrib;
1922
1923 switch (pattrib->qsel) {
1924 case 0:
1925 case 3:
1926 addr = BE_QUEUE_INX;
1927 break;
1928 case 1:
1929 case 2:
1930 addr = BK_QUEUE_INX;
1931 break;
1932 case 4:
1933 case 5:
1934 addr = VI_QUEUE_INX;
1935 break;
1936 case 6:
1937 case 7:
1938 addr = VO_QUEUE_INX;
1939 break;
1940 case 0x10:
1941 addr = BCN_QUEUE_INX;
1942 break;
1943 case 0x11:/* BC/MC in PS (HIQ) */
1944 addr = HIGH_QUEUE_INX;
1945 break;
1946 case 0x12:
1947 default:
1948 addr = MGT_QUEUE_INX;
1949 break;
1950 }
1951
1952 return addr;
1953 }
1954
do_queue_select(struct adapter * padapter,struct pkt_attrib * pattrib)1955 static void do_queue_select(struct adapter *padapter, struct pkt_attrib *pattrib)
1956 {
1957 u8 qsel;
1958
1959 qsel = pattrib->priority;
1960
1961 pattrib->qsel = qsel;
1962 }
1963
1964 /*
1965 * The main transmit(tx) entry
1966 *
1967 * Return
1968 *1 enqueue
1969 *0 success, hardware will handle this xmit frame(packet)
1970 *<0 fail
1971 */
rtw_xmit(struct adapter * padapter,struct sk_buff ** ppkt)1972 s32 rtw_xmit(struct adapter *padapter, struct sk_buff **ppkt)
1973 {
1974 static unsigned long start;
1975
1976 struct xmit_priv *pxmitpriv = &padapter->xmitpriv;
1977 struct xmit_frame *pxmitframe = NULL;
1978
1979 s32 res;
1980
1981 if (start == 0)
1982 start = jiffies;
1983
1984 pxmitframe = rtw_alloc_xmitframe(pxmitpriv);
1985
1986 if (jiffies_to_msecs(jiffies - start) > 2000)
1987 start = jiffies;
1988
1989 if (!pxmitframe)
1990 return -1;
1991
1992 res = update_attrib(padapter, *ppkt, &pxmitframe->attrib);
1993
1994 if (res != _SUCCESS) {
1995 rtw_free_xmitframe(pxmitpriv, pxmitframe);
1996 return -1;
1997 }
1998 pxmitframe->pkt = *ppkt;
1999
2000 do_queue_select(padapter, &pxmitframe->attrib);
2001
2002 spin_lock_bh(&pxmitpriv->lock);
2003 if (xmitframe_enqueue_for_sleeping_sta(padapter, pxmitframe) == true) {
2004 spin_unlock_bh(&pxmitpriv->lock);
2005 return 1;
2006 }
2007 spin_unlock_bh(&pxmitpriv->lock);
2008
2009 /* pre_xmitframe */
2010 if (rtw_hal_xmit(padapter, pxmitframe) == false)
2011 return 1;
2012
2013 return 0;
2014 }
2015
2016 #define RTW_HIQ_FILTER_ALLOW_ALL 0
2017 #define RTW_HIQ_FILTER_ALLOW_SPECIAL 1
2018 #define RTW_HIQ_FILTER_DENY_ALL 2
2019
xmitframe_hiq_filter(struct xmit_frame * xmitframe)2020 inline bool xmitframe_hiq_filter(struct xmit_frame *xmitframe)
2021 {
2022 bool allow = false;
2023 struct adapter *adapter = xmitframe->padapter;
2024 struct registry_priv *registry = &adapter->registrypriv;
2025
2026 if (registry->hiq_filter == RTW_HIQ_FILTER_ALLOW_SPECIAL) {
2027 struct pkt_attrib *attrib = &xmitframe->attrib;
2028
2029 if (attrib->ether_type == 0x0806 ||
2030 attrib->ether_type == 0x888e ||
2031 attrib->dhcp_pkt
2032 )
2033 allow = true;
2034
2035 } else if (registry->hiq_filter == RTW_HIQ_FILTER_ALLOW_ALL)
2036 allow = true;
2037 else if (registry->hiq_filter == RTW_HIQ_FILTER_DENY_ALL) {
2038 } else
2039 rtw_warn_on(1);
2040
2041 return allow;
2042 }
2043
xmitframe_enqueue_for_sleeping_sta(struct adapter * padapter,struct xmit_frame * pxmitframe)2044 signed int xmitframe_enqueue_for_sleeping_sta(struct adapter *padapter, struct xmit_frame *pxmitframe)
2045 {
2046 signed int ret = false;
2047 struct sta_info *psta = NULL;
2048 struct sta_priv *pstapriv = &padapter->stapriv;
2049 struct pkt_attrib *pattrib = &pxmitframe->attrib;
2050 struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
2051 signed int bmcst = is_multicast_ether_addr(pattrib->ra);
2052 bool update_tim = false;
2053
2054 if (check_fwstate(pmlmepriv, WIFI_AP_STATE) == false)
2055 return ret;
2056 psta = rtw_get_stainfo(&padapter->stapriv, pattrib->ra);
2057 if (pattrib->psta != psta)
2058 return false;
2059
2060 if (!psta)
2061 return false;
2062
2063 if (!(psta->state & _FW_LINKED))
2064 return false;
2065
2066 if (pattrib->triggered == 1) {
2067 if (bmcst && xmitframe_hiq_filter(pxmitframe))
2068 pattrib->qsel = 0x11;/* HIQ */
2069
2070 return ret;
2071 }
2072
2073 if (bmcst) {
2074 spin_lock_bh(&psta->sleep_q.lock);
2075
2076 if (pstapriv->sta_dz_bitmap) { /* if anyone sta is in ps mode */
2077 /* pattrib->qsel = 0x11;HIQ */
2078
2079 list_del_init(&pxmitframe->list);
2080
2081 list_add_tail(&pxmitframe->list, get_list_head(&psta->sleep_q));
2082
2083 psta->sleepq_len++;
2084
2085 if (!(pstapriv->tim_bitmap & BIT(0)))
2086 update_tim = true;
2087
2088 pstapriv->tim_bitmap |= BIT(0);
2089 pstapriv->sta_dz_bitmap |= BIT(0);
2090
2091 if (update_tim)
2092 update_beacon(padapter, WLAN_EID_TIM, NULL, true);
2093 else
2094 chk_bmc_sleepq_cmd(padapter);
2095
2096 ret = true;
2097 }
2098
2099 spin_unlock_bh(&psta->sleep_q.lock);
2100
2101 return ret;
2102 }
2103
2104 spin_lock_bh(&psta->sleep_q.lock);
2105
2106 if (psta->state & WIFI_SLEEP_STATE) {
2107 u8 wmmps_ac = 0;
2108
2109 if (pstapriv->sta_dz_bitmap & BIT(psta->aid)) {
2110 list_del_init(&pxmitframe->list);
2111
2112 list_add_tail(&pxmitframe->list, get_list_head(&psta->sleep_q));
2113
2114 psta->sleepq_len++;
2115
2116 switch (pattrib->priority) {
2117 case 1:
2118 case 2:
2119 wmmps_ac = psta->uapsd_bk & BIT(0);
2120 break;
2121 case 4:
2122 case 5:
2123 wmmps_ac = psta->uapsd_vi & BIT(0);
2124 break;
2125 case 6:
2126 case 7:
2127 wmmps_ac = psta->uapsd_vo & BIT(0);
2128 break;
2129 case 0:
2130 case 3:
2131 default:
2132 wmmps_ac = psta->uapsd_be & BIT(0);
2133 break;
2134 }
2135
2136 if (wmmps_ac)
2137 psta->sleepq_ac_len++;
2138
2139 if (((psta->has_legacy_ac) && (!wmmps_ac)) || ((!psta->has_legacy_ac) && (wmmps_ac))) {
2140 if (!(pstapriv->tim_bitmap & BIT(psta->aid)))
2141 update_tim = true;
2142
2143 pstapriv->tim_bitmap |= BIT(psta->aid);
2144
2145 if (update_tim)
2146 /* update BCN for TIM IE */
2147 update_beacon(padapter, WLAN_EID_TIM, NULL, true);
2148 }
2149
2150 ret = true;
2151 }
2152 }
2153
2154 spin_unlock_bh(&psta->sleep_q.lock);
2155
2156 return ret;
2157 }
2158
dequeue_xmitframes_to_sleeping_queue(struct adapter * padapter,struct sta_info * psta,struct __queue * pframequeue)2159 static void dequeue_xmitframes_to_sleeping_queue(struct adapter *padapter, struct sta_info *psta, struct __queue *pframequeue)
2160 {
2161 signed int ret;
2162 struct list_head *plist, *phead, *tmp;
2163 u8 ac_index;
2164 struct tx_servq *ptxservq;
2165 struct pkt_attrib *pattrib;
2166 struct xmit_frame *pxmitframe;
2167 struct hw_xmit *phwxmits = padapter->xmitpriv.hwxmits;
2168
2169 phead = get_list_head(pframequeue);
2170 list_for_each_safe(plist, tmp, phead) {
2171 pxmitframe = list_entry(plist, struct xmit_frame, list);
2172
2173 pattrib = &pxmitframe->attrib;
2174
2175 pattrib->triggered = 0;
2176
2177 ret = xmitframe_enqueue_for_sleeping_sta(padapter, pxmitframe);
2178
2179 if (true == ret) {
2180 ptxservq = rtw_get_sta_pending(padapter, psta, pattrib->priority, (u8 *)(&ac_index));
2181
2182 ptxservq->qcnt--;
2183 phwxmits[ac_index].accnt--;
2184 } else {
2185 }
2186 }
2187 }
2188
stop_sta_xmit(struct adapter * padapter,struct sta_info * psta)2189 void stop_sta_xmit(struct adapter *padapter, struct sta_info *psta)
2190 {
2191 struct sta_info *psta_bmc;
2192 struct sta_xmit_priv *pstaxmitpriv;
2193 struct sta_priv *pstapriv = &padapter->stapriv;
2194 struct xmit_priv *pxmitpriv = &padapter->xmitpriv;
2195
2196 pstaxmitpriv = &psta->sta_xmitpriv;
2197
2198 /* for BC/MC Frames */
2199 psta_bmc = rtw_get_bcmc_stainfo(padapter);
2200
2201 spin_lock_bh(&pxmitpriv->lock);
2202
2203 psta->state |= WIFI_SLEEP_STATE;
2204
2205 pstapriv->sta_dz_bitmap |= BIT(psta->aid);
2206
2207 dequeue_xmitframes_to_sleeping_queue(padapter, psta, &pstaxmitpriv->vo_q.sta_pending);
2208 list_del_init(&pstaxmitpriv->vo_q.tx_pending);
2209
2210 dequeue_xmitframes_to_sleeping_queue(padapter, psta, &pstaxmitpriv->vi_q.sta_pending);
2211 list_del_init(&pstaxmitpriv->vi_q.tx_pending);
2212
2213 dequeue_xmitframes_to_sleeping_queue(padapter, psta, &pstaxmitpriv->be_q.sta_pending);
2214 list_del_init(&pstaxmitpriv->be_q.tx_pending);
2215
2216 dequeue_xmitframes_to_sleeping_queue(padapter, psta, &pstaxmitpriv->bk_q.sta_pending);
2217 list_del_init(&pstaxmitpriv->bk_q.tx_pending);
2218
2219 /* for BC/MC Frames */
2220 pstaxmitpriv = &psta_bmc->sta_xmitpriv;
2221 dequeue_xmitframes_to_sleeping_queue(padapter, psta_bmc, &pstaxmitpriv->be_q.sta_pending);
2222 list_del_init(&pstaxmitpriv->be_q.tx_pending);
2223
2224 spin_unlock_bh(&pxmitpriv->lock);
2225 }
2226
wakeup_sta_to_xmit(struct adapter * padapter,struct sta_info * psta)2227 void wakeup_sta_to_xmit(struct adapter *padapter, struct sta_info *psta)
2228 {
2229 u8 update_mask = 0, wmmps_ac = 0;
2230 struct sta_info *psta_bmc;
2231 struct list_head *xmitframe_plist, *xmitframe_phead, *tmp;
2232 struct xmit_frame *pxmitframe = NULL;
2233 struct sta_priv *pstapriv = &padapter->stapriv;
2234 struct xmit_priv *pxmitpriv = &padapter->xmitpriv;
2235
2236 psta_bmc = rtw_get_bcmc_stainfo(padapter);
2237
2238 spin_lock_bh(&pxmitpriv->lock);
2239
2240 xmitframe_phead = get_list_head(&psta->sleep_q);
2241 list_for_each_safe(xmitframe_plist, tmp, xmitframe_phead) {
2242 pxmitframe = list_entry(xmitframe_plist, struct xmit_frame,
2243 list);
2244
2245 list_del_init(&pxmitframe->list);
2246
2247 switch (pxmitframe->attrib.priority) {
2248 case 1:
2249 case 2:
2250 wmmps_ac = psta->uapsd_bk & BIT(1);
2251 break;
2252 case 4:
2253 case 5:
2254 wmmps_ac = psta->uapsd_vi & BIT(1);
2255 break;
2256 case 6:
2257 case 7:
2258 wmmps_ac = psta->uapsd_vo & BIT(1);
2259 break;
2260 case 0:
2261 case 3:
2262 default:
2263 wmmps_ac = psta->uapsd_be & BIT(1);
2264 break;
2265 }
2266
2267 psta->sleepq_len--;
2268 if (psta->sleepq_len > 0)
2269 pxmitframe->attrib.mdata = 1;
2270 else
2271 pxmitframe->attrib.mdata = 0;
2272
2273 if (wmmps_ac) {
2274 psta->sleepq_ac_len--;
2275 if (psta->sleepq_ac_len > 0) {
2276 pxmitframe->attrib.mdata = 1;
2277 pxmitframe->attrib.eosp = 0;
2278 } else {
2279 pxmitframe->attrib.mdata = 0;
2280 pxmitframe->attrib.eosp = 1;
2281 }
2282 }
2283
2284 pxmitframe->attrib.triggered = 1;
2285
2286 rtw_hal_xmitframe_enqueue(padapter, pxmitframe);
2287 }
2288
2289 if (psta->sleepq_len == 0) {
2290 if (pstapriv->tim_bitmap & BIT(psta->aid))
2291 update_mask = BIT(0);
2292
2293 pstapriv->tim_bitmap &= ~BIT(psta->aid);
2294
2295 if (psta->state & WIFI_SLEEP_STATE)
2296 psta->state ^= WIFI_SLEEP_STATE;
2297
2298 if (psta->state & WIFI_STA_ALIVE_CHK_STATE) {
2299 psta->expire_to = pstapriv->expire_to;
2300 psta->state ^= WIFI_STA_ALIVE_CHK_STATE;
2301 }
2302
2303 pstapriv->sta_dz_bitmap &= ~BIT(psta->aid);
2304 }
2305
2306 /* for BC/MC Frames */
2307 if (!psta_bmc)
2308 goto _exit;
2309
2310 if ((pstapriv->sta_dz_bitmap & 0xfffe) == 0x0) { /* no any sta in ps mode */
2311 xmitframe_phead = get_list_head(&psta_bmc->sleep_q);
2312 list_for_each_safe(xmitframe_plist, tmp, xmitframe_phead) {
2313 pxmitframe = list_entry(xmitframe_plist,
2314 struct xmit_frame, list);
2315
2316 list_del_init(&pxmitframe->list);
2317
2318 psta_bmc->sleepq_len--;
2319 if (psta_bmc->sleepq_len > 0)
2320 pxmitframe->attrib.mdata = 1;
2321 else
2322 pxmitframe->attrib.mdata = 0;
2323
2324 pxmitframe->attrib.triggered = 1;
2325 rtw_hal_xmitframe_enqueue(padapter, pxmitframe);
2326 }
2327
2328 if (psta_bmc->sleepq_len == 0) {
2329 if (pstapriv->tim_bitmap & BIT(0))
2330 update_mask |= BIT(1);
2331
2332 pstapriv->tim_bitmap &= ~BIT(0);
2333 pstapriv->sta_dz_bitmap &= ~BIT(0);
2334 }
2335 }
2336
2337 _exit:
2338
2339 spin_unlock_bh(&pxmitpriv->lock);
2340
2341 if (update_mask)
2342 update_beacon(padapter, WLAN_EID_TIM, NULL, true);
2343 }
2344
xmit_delivery_enabled_frames(struct adapter * padapter,struct sta_info * psta)2345 void xmit_delivery_enabled_frames(struct adapter *padapter, struct sta_info *psta)
2346 {
2347 u8 wmmps_ac = 0;
2348 struct list_head *xmitframe_plist, *xmitframe_phead, *tmp;
2349 struct xmit_frame *pxmitframe = NULL;
2350 struct sta_priv *pstapriv = &padapter->stapriv;
2351 struct xmit_priv *pxmitpriv = &padapter->xmitpriv;
2352
2353 spin_lock_bh(&pxmitpriv->lock);
2354
2355 xmitframe_phead = get_list_head(&psta->sleep_q);
2356 list_for_each_safe(xmitframe_plist, tmp, xmitframe_phead) {
2357 pxmitframe = list_entry(xmitframe_plist, struct xmit_frame,
2358 list);
2359
2360 switch (pxmitframe->attrib.priority) {
2361 case 1:
2362 case 2:
2363 wmmps_ac = psta->uapsd_bk & BIT(1);
2364 break;
2365 case 4:
2366 case 5:
2367 wmmps_ac = psta->uapsd_vi & BIT(1);
2368 break;
2369 case 6:
2370 case 7:
2371 wmmps_ac = psta->uapsd_vo & BIT(1);
2372 break;
2373 case 0:
2374 case 3:
2375 default:
2376 wmmps_ac = psta->uapsd_be & BIT(1);
2377 break;
2378 }
2379
2380 if (!wmmps_ac)
2381 continue;
2382
2383 list_del_init(&pxmitframe->list);
2384
2385 psta->sleepq_len--;
2386 psta->sleepq_ac_len--;
2387
2388 if (psta->sleepq_ac_len > 0) {
2389 pxmitframe->attrib.mdata = 1;
2390 pxmitframe->attrib.eosp = 0;
2391 } else {
2392 pxmitframe->attrib.mdata = 0;
2393 pxmitframe->attrib.eosp = 1;
2394 }
2395
2396 pxmitframe->attrib.triggered = 1;
2397 rtw_hal_xmitframe_enqueue(padapter, pxmitframe);
2398
2399 if ((psta->sleepq_ac_len == 0) && (!psta->has_legacy_ac) && (wmmps_ac)) {
2400 pstapriv->tim_bitmap &= ~BIT(psta->aid);
2401
2402 update_beacon(padapter, WLAN_EID_TIM, NULL, true);
2403 }
2404 }
2405
2406 spin_unlock_bh(&pxmitpriv->lock);
2407 }
2408
enqueue_pending_xmitbuf(struct xmit_priv * pxmitpriv,struct xmit_buf * pxmitbuf)2409 void enqueue_pending_xmitbuf(struct xmit_priv *pxmitpriv, struct xmit_buf *pxmitbuf)
2410 {
2411 struct __queue *pqueue;
2412 struct adapter *pri_adapter = pxmitpriv->adapter;
2413
2414 pqueue = &pxmitpriv->pending_xmitbuf_queue;
2415
2416 spin_lock_bh(&pqueue->lock);
2417 list_del_init(&pxmitbuf->list);
2418 list_add_tail(&pxmitbuf->list, get_list_head(pqueue));
2419 spin_unlock_bh(&pqueue->lock);
2420
2421 complete(&pri_adapter->xmitpriv.xmit_comp);
2422 }
2423
enqueue_pending_xmitbuf_to_head(struct xmit_priv * pxmitpriv,struct xmit_buf * pxmitbuf)2424 void enqueue_pending_xmitbuf_to_head(struct xmit_priv *pxmitpriv, struct xmit_buf *pxmitbuf)
2425 {
2426 struct __queue *pqueue;
2427
2428 pqueue = &pxmitpriv->pending_xmitbuf_queue;
2429
2430 spin_lock_bh(&pqueue->lock);
2431 list_del_init(&pxmitbuf->list);
2432 list_add(&pxmitbuf->list, get_list_head(pqueue));
2433 spin_unlock_bh(&pqueue->lock);
2434 }
2435
dequeue_pending_xmitbuf(struct xmit_priv * pxmitpriv)2436 struct xmit_buf *dequeue_pending_xmitbuf(struct xmit_priv *pxmitpriv)
2437 {
2438 struct xmit_buf *pxmitbuf;
2439 struct __queue *pqueue;
2440
2441 pxmitbuf = NULL;
2442 pqueue = &pxmitpriv->pending_xmitbuf_queue;
2443
2444 spin_lock_bh(&pqueue->lock);
2445
2446 if (!list_empty(&pqueue->queue)) {
2447 struct list_head *plist, *phead;
2448
2449 phead = get_list_head(pqueue);
2450 plist = get_next(phead);
2451 pxmitbuf = container_of(plist, struct xmit_buf, list);
2452 list_del_init(&pxmitbuf->list);
2453 }
2454
2455 spin_unlock_bh(&pqueue->lock);
2456
2457 return pxmitbuf;
2458 }
2459
dequeue_pending_xmitbuf_under_survey(struct xmit_priv * pxmitpriv)2460 struct xmit_buf *dequeue_pending_xmitbuf_under_survey(struct xmit_priv *pxmitpriv)
2461 {
2462 struct xmit_buf *pxmitbuf;
2463 struct __queue *pqueue;
2464
2465 pxmitbuf = NULL;
2466 pqueue = &pxmitpriv->pending_xmitbuf_queue;
2467
2468 spin_lock_bh(&pqueue->lock);
2469
2470 if (!list_empty(&pqueue->queue)) {
2471 struct list_head *plist, *phead;
2472 u8 type;
2473
2474 phead = get_list_head(pqueue);
2475 plist = phead;
2476 do {
2477 plist = get_next(plist);
2478 if (plist == phead)
2479 break;
2480
2481 pxmitbuf = container_of(plist, struct xmit_buf, list);
2482
2483 type = GetFrameSubType(pxmitbuf->pbuf + TXDESC_OFFSET);
2484
2485 if ((type == WIFI_PROBEREQ) ||
2486 (type == WIFI_DATA_NULL) ||
2487 (type == WIFI_QOS_DATA_NULL)) {
2488 list_del_init(&pxmitbuf->list);
2489 break;
2490 }
2491 pxmitbuf = NULL;
2492 } while (1);
2493 }
2494
2495 spin_unlock_bh(&pqueue->lock);
2496
2497 return pxmitbuf;
2498 }
2499
check_pending_xmitbuf(struct xmit_priv * pxmitpriv)2500 signed int check_pending_xmitbuf(struct xmit_priv *pxmitpriv)
2501 {
2502 struct __queue *pqueue;
2503 signed int ret = false;
2504
2505 pqueue = &pxmitpriv->pending_xmitbuf_queue;
2506
2507 spin_lock_bh(&pqueue->lock);
2508
2509 if (!list_empty(&pqueue->queue))
2510 ret = true;
2511
2512 spin_unlock_bh(&pqueue->lock);
2513
2514 return ret;
2515 }
2516
rtw_xmit_thread(void * context)2517 int rtw_xmit_thread(void *context)
2518 {
2519 s32 err;
2520 struct adapter *padapter;
2521
2522 err = _SUCCESS;
2523 padapter = context;
2524
2525 allow_signal(SIGTERM);
2526
2527 do {
2528 err = rtw_hal_xmit_thread_handler(padapter);
2529 flush_signals_thread();
2530 } while (err == _SUCCESS);
2531
2532 complete(&padapter->xmitpriv.terminate_xmitthread_comp);
2533
2534 return 0;
2535 }
2536
rtw_sctx_init(struct submit_ctx * sctx,int timeout_ms)2537 void rtw_sctx_init(struct submit_ctx *sctx, int timeout_ms)
2538 {
2539 sctx->timeout_ms = timeout_ms;
2540 sctx->submit_time = jiffies;
2541 init_completion(&sctx->done);
2542 sctx->status = RTW_SCTX_SUBMITTED;
2543 }
2544
rtw_sctx_wait(struct submit_ctx * sctx)2545 int rtw_sctx_wait(struct submit_ctx *sctx)
2546 {
2547 int ret = _FAIL;
2548 unsigned long expire;
2549 int status = 0;
2550
2551 expire = sctx->timeout_ms ? msecs_to_jiffies(sctx->timeout_ms) : MAX_SCHEDULE_TIMEOUT;
2552 if (!wait_for_completion_timeout(&sctx->done, expire))
2553 /* timeout, do something?? */
2554 status = RTW_SCTX_DONE_TIMEOUT;
2555 else
2556 status = sctx->status;
2557
2558 if (status == RTW_SCTX_DONE_SUCCESS)
2559 ret = _SUCCESS;
2560
2561 return ret;
2562 }
2563
rtw_sctx_done_err(struct submit_ctx ** sctx,int status)2564 void rtw_sctx_done_err(struct submit_ctx **sctx, int status)
2565 {
2566 if (*sctx) {
2567 (*sctx)->status = status;
2568 complete(&((*sctx)->done));
2569 *sctx = NULL;
2570 }
2571 }
2572
rtw_sctx_done(struct submit_ctx ** sctx)2573 void rtw_sctx_done(struct submit_ctx **sctx)
2574 {
2575 rtw_sctx_done_err(sctx, RTW_SCTX_DONE_SUCCESS);
2576 }
2577
rtw_ack_tx_wait(struct xmit_priv * pxmitpriv,u32 timeout_ms)2578 int rtw_ack_tx_wait(struct xmit_priv *pxmitpriv, u32 timeout_ms)
2579 {
2580 struct submit_ctx *pack_tx_ops = &pxmitpriv->ack_tx_ops;
2581
2582 pack_tx_ops->submit_time = jiffies;
2583 pack_tx_ops->timeout_ms = timeout_ms;
2584 pack_tx_ops->status = RTW_SCTX_SUBMITTED;
2585
2586 return rtw_sctx_wait(pack_tx_ops);
2587 }
2588
rtw_ack_tx_done(struct xmit_priv * pxmitpriv,int status)2589 void rtw_ack_tx_done(struct xmit_priv *pxmitpriv, int status)
2590 {
2591 struct submit_ctx *pack_tx_ops = &pxmitpriv->ack_tx_ops;
2592
2593 if (pxmitpriv->ack_tx)
2594 rtw_sctx_done_err(&pack_tx_ops, status);
2595 }
2596