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