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