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