1 // SPDX-License-Identifier: GPL-2.0
2 /******************************************************************************
4 * Copyright(c) 2007 - 2012 Realtek Corporation. All rights reserved.
6 ******************************************************************************/
10 static u8 P802_1H_OUI[P80211_OUI_LEN] = { 0x00, 0x00, 0xf8 };
11 static u8 RFC1042_OUI[P80211_OUI_LEN] = { 0x00, 0x00, 0x00 };
13 static void _init_txservq(struct tx_servq *ptxservq)
15 INIT_LIST_HEAD(&ptxservq->tx_pending);
16 INIT_LIST_HEAD(&ptxservq->sta_pending.queue);
17 spin_lock_init(&ptxservq->sta_pending.lock);
21 void _rtw_init_sta_xmit_priv(struct sta_xmit_priv *psta_xmitpriv)
23 memset((unsigned char *)psta_xmitpriv, 0, sizeof(struct sta_xmit_priv));
25 spin_lock_init(&psta_xmitpriv->lock);
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);
35 s32 _rtw_init_xmit_priv(struct xmit_priv *pxmitpriv, struct adapter *padapter)
38 struct xmit_buf *pxmitbuf;
39 struct xmit_frame *pxframe;
40 signed int res = _SUCCESS;
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);
48 * Please insert all the queue initializaiton using _rtw_init_queue below
51 pxmitpriv->adapter = padapter;
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);
64 INIT_LIST_HEAD(&pxmitpriv->free_xmit_queue.queue);
65 spin_lock_init(&pxmitpriv->free_xmit_queue.lock);
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...
73 pxmitpriv->pallocated_frame_buf = vzalloc(NR_XMITFRAME * sizeof(struct xmit_frame) + 4);
75 if (!pxmitpriv->pallocated_frame_buf) {
76 pxmitpriv->pxmit_frame_buf = NULL;
80 pxmitpriv->pxmit_frame_buf = (u8 *)N_BYTE_ALIGMENT((SIZE_PTR)(pxmitpriv->pallocated_frame_buf), 4);
82 pxframe = (struct xmit_frame *) pxmitpriv->pxmit_frame_buf;
84 for (i = 0; i < NR_XMITFRAME; i++) {
85 INIT_LIST_HEAD(&pxframe->list);
87 pxframe->padapter = padapter;
88 pxframe->frame_tag = NULL_FRAMETAG;
92 pxframe->buf_addr = NULL;
93 pxframe->pxmitbuf = NULL;
95 list_add_tail(&pxframe->list,
96 &pxmitpriv->free_xmit_queue.queue);
101 pxmitpriv->free_xmitframe_cnt = NR_XMITFRAME;
103 pxmitpriv->frag_len = MAX_FRAG_THRESHOLD;
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);
111 pxmitpriv->pallocated_xmitbuf = vzalloc(NR_XMITBUFF * sizeof(struct xmit_buf) + 4);
113 if (!pxmitpriv->pallocated_xmitbuf) {
118 pxmitpriv->pxmitbuf = (u8 *)N_BYTE_ALIGMENT((SIZE_PTR)(pxmitpriv->pallocated_xmitbuf), 4);
120 pxmitbuf = (struct xmit_buf *)pxmitpriv->pxmitbuf;
122 for (i = 0; i < NR_XMITBUFF; i++) {
123 INIT_LIST_HEAD(&pxmitbuf->list);
125 pxmitbuf->priv_data = NULL;
126 pxmitbuf->padapter = padapter;
127 pxmitbuf->buf_tag = XMITBUF_DATA;
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);
133 res = rtw_os_xmit_resource_alloc(padapter, pxmitbuf, (MAX_XMITBUF_SZ + XMITBUF_ALIGN_SZ), true);
138 pxmitbuf->phead = pxmitbuf->pbuf;
139 pxmitbuf->pend = pxmitbuf->pbuf + MAX_XMITBUF_SZ;
141 pxmitbuf->pdata = pxmitbuf->ptail = pxmitbuf->phead;
143 pxmitbuf->flags = XMIT_VO_QUEUE;
145 list_add_tail(&pxmitbuf->list,
146 &pxmitpriv->free_xmitbuf_queue.queue);
154 pxmitpriv->free_xmitbuf_cnt = NR_XMITBUFF;
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);
160 pxmitpriv->xframe_ext_alloc_addr = vzalloc(NR_XMIT_EXTBUFF * sizeof(struct xmit_frame) + 4);
162 if (!pxmitpriv->xframe_ext_alloc_addr) {
163 pxmitpriv->xframe_ext = NULL;
167 pxmitpriv->xframe_ext = (u8 *)N_BYTE_ALIGMENT((SIZE_PTR)(pxmitpriv->xframe_ext_alloc_addr), 4);
168 pxframe = (struct xmit_frame *)pxmitpriv->xframe_ext;
170 for (i = 0; i < NR_XMIT_EXTBUFF; i++) {
171 INIT_LIST_HEAD(&pxframe->list);
173 pxframe->padapter = padapter;
174 pxframe->frame_tag = NULL_FRAMETAG;
178 pxframe->buf_addr = NULL;
179 pxframe->pxmitbuf = NULL;
181 pxframe->ext_tag = 1;
183 list_add_tail(&pxframe->list,
184 &pxmitpriv->free_xframe_ext_queue.queue);
188 pxmitpriv->free_xframe_ext_cnt = NR_XMIT_EXTBUFF;
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);
194 pxmitpriv->pallocated_xmit_extbuf = vzalloc(NR_XMIT_EXTBUFF * sizeof(struct xmit_buf) + 4);
196 if (!pxmitpriv->pallocated_xmit_extbuf) {
201 pxmitpriv->pxmit_extbuf = (u8 *)N_BYTE_ALIGMENT((SIZE_PTR)(pxmitpriv->pallocated_xmit_extbuf), 4);
203 pxmitbuf = (struct xmit_buf *)pxmitpriv->pxmit_extbuf;
205 for (i = 0; i < NR_XMIT_EXTBUFF; i++) {
206 INIT_LIST_HEAD(&pxmitbuf->list);
208 pxmitbuf->priv_data = NULL;
209 pxmitbuf->padapter = padapter;
210 pxmitbuf->buf_tag = XMITBUF_MGNT;
212 res = rtw_os_xmit_resource_alloc(padapter, pxmitbuf, MAX_XMIT_EXTBUF_SZ + XMITBUF_ALIGN_SZ, true);
218 pxmitbuf->phead = pxmitbuf->pbuf;
219 pxmitbuf->pend = pxmitbuf->pbuf + MAX_XMIT_EXTBUF_SZ;
221 pxmitbuf->pdata = pxmitbuf->ptail = pxmitbuf->phead;
223 list_add_tail(&pxmitbuf->list,
224 &pxmitpriv->free_xmit_extbuf_queue.queue);
225 #ifdef DBG_XMIT_BUF_EXT
231 pxmitpriv->free_xmit_extbuf_cnt = NR_XMIT_EXTBUFF;
233 for (i = 0; i < CMDBUF_MAX; i++) {
234 pxmitbuf = &pxmitpriv->pcmd_xmitbuf[i];
236 INIT_LIST_HEAD(&pxmitbuf->list);
238 pxmitbuf->priv_data = NULL;
239 pxmitbuf->padapter = padapter;
240 pxmitbuf->buf_tag = XMITBUF_CMD;
242 res = rtw_os_xmit_resource_alloc(padapter, pxmitbuf, MAX_CMDBUF_SZ+XMITBUF_ALIGN_SZ, true);
248 pxmitbuf->phead = pxmitbuf->pbuf;
249 pxmitbuf->pend = pxmitbuf->pbuf + MAX_CMDBUF_SZ;
251 pxmitbuf->pdata = pxmitbuf->ptail = pxmitbuf->phead;
252 pxmitbuf->alloc_sz = MAX_CMDBUF_SZ+XMITBUF_ALIGN_SZ;
256 res = rtw_alloc_hwxmits(padapter);
259 rtw_init_hwxmits(pxmitpriv->hwxmits, pxmitpriv->hwxmit_entry);
261 for (i = 0; i < 4; i++)
262 pxmitpriv->wmm_para_seq[i] = i;
264 pxmitpriv->ack_tx = false;
265 mutex_init(&pxmitpriv->ack_tx_mutex);
266 rtw_sctx_init(&pxmitpriv->ack_tx_ops, 0);
268 rtw_hal_init_xmit_priv(padapter);
274 void _rtw_free_xmit_priv(struct xmit_priv *pxmitpriv)
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;
281 rtw_hal_free_xmit_priv(padapter);
283 if (!pxmitpriv->pxmit_frame_buf)
286 for (i = 0; i < NR_XMITFRAME; i++) {
287 rtw_os_xmit_complete(padapter, pxmitframe);
292 for (i = 0; i < NR_XMITBUFF; i++) {
293 rtw_os_xmit_resource_free(padapter, pxmitbuf, (MAX_XMITBUF_SZ + XMITBUF_ALIGN_SZ), true);
298 vfree(pxmitpriv->pallocated_frame_buf);
299 vfree(pxmitpriv->pallocated_xmitbuf);
301 /* free xframe_ext queue, the same count as extbuf */
302 pxmitframe = (struct xmit_frame *)pxmitpriv->xframe_ext;
304 for (i = 0; i < NR_XMIT_EXTBUFF; i++) {
305 rtw_os_xmit_complete(padapter, pxmitframe);
310 vfree(pxmitpriv->xframe_ext_alloc_addr);
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);
320 vfree(pxmitpriv->pallocated_xmit_extbuf);
322 for (i = 0; i < CMDBUF_MAX; i++) {
323 pxmitbuf = &pxmitpriv->pcmd_xmitbuf[i];
325 rtw_os_xmit_resource_free(padapter, pxmitbuf, MAX_CMDBUF_SZ+XMITBUF_ALIGN_SZ, true);
328 rtw_free_hwxmits(padapter);
330 mutex_destroy(&pxmitpriv->ack_tx_mutex);
333 u8 query_ra_short_GI(struct sta_info *psta)
335 u8 sgi = false, sgi_20m = false, sgi_40m = false;
337 sgi_20m = psta->htpriv.sgi_20m;
338 sgi_40m = psta->htpriv.sgi_40m;
340 switch (psta->bw_mode) {
341 case CHANNEL_WIDTH_40:
344 case CHANNEL_WIDTH_20:
353 static void update_attrib_vcs_info(struct adapter *padapter, struct xmit_frame *pxmitframe)
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;
361 if (pattrib->nr_frags != 1)
362 sz = padapter->xmitpriv.frag_len;
364 sz = pattrib->last_txcmdsz;
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;
375 pattrib->vcs_mode = RTS_CTS;
376 else if (pattrib->cts2self)
377 pattrib->vcs_mode = CTS_TO_SELF;
379 pattrib->vcs_mode = NONE_VCS;
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;
390 /* check ERP protection */
391 if (pattrib->rtsen || pattrib->cts2self) {
393 pattrib->vcs_mode = RTS_CTS;
394 else if (pattrib->cts2self)
395 pattrib->vcs_mode = CTS_TO_SELF;
400 /* check HT op mode */
401 if (pattrib->ht_en) {
402 u8 HTOpMode = pmlmeinfo->HT_protection;
404 if ((pmlmeext->cur_bwmode && (HTOpMode == 2 || HTOpMode == 3)) ||
405 (!pmlmeext->cur_bwmode && HTOpMode == 3)) {
406 pattrib->vcs_mode = RTS_CTS;
412 if (sz > padapter->registrypriv.rts_thresh) {
413 pattrib->vcs_mode = RTS_CTS;
417 /* to do list: check MIMO power save condition. */
419 /* check AMPDU aggregation for TXOP */
420 if (pattrib->ampdu_en == true) {
421 pattrib->vcs_mode = RTS_CTS;
425 pattrib->vcs_mode = NONE_VCS;
430 /* for debug : force driver control vrtl_carrier_sense. */
431 if (padapter->driver_vcs_en == 1)
432 pattrib->vcs_mode = padapter->driver_vcs_type;
435 static void update_attrib_phy_info(struct adapter *padapter, struct pkt_attrib *pattrib, struct sta_info *psta)
437 struct mlme_ext_priv *mlmeext = &padapter->mlmeextpriv;
439 pattrib->rtsen = psta->rtsen;
440 pattrib->cts2self = psta->cts2self;
444 pattrib->triggered = 0;
445 pattrib->ampdu_spacing = 0;
447 /* qos_en, ht_en, init rate, , bw, ch_offset, sgi */
448 pattrib->qos_en = psta->qos_option;
450 pattrib->raid = psta->raid;
452 pattrib->bwmode = min(mlmeext->cur_bwmode, psta->bw_mode);
454 pattrib->sgi = query_ra_short_GI(psta);
456 pattrib->ldpc = psta->ldpc;
457 pattrib->stbc = psta->stbc;
459 pattrib->ht_en = psta->htpriv.ht_option;
460 pattrib->ch_offset = psta->htpriv.ch_offset;
461 pattrib->ampdu_en = false;
463 if (padapter->driver_ampdu_spacing != 0xFF) /* driver control AMPDU Density for peer sta's rx */
464 pattrib->ampdu_spacing = padapter->driver_ampdu_spacing;
466 pattrib->ampdu_spacing = psta->htpriv.rx_ampdu_min_spacing;
468 pattrib->retry_ctrl = false;
471 static s32 update_attrib_sec_info(struct adapter *padapter, struct pkt_attrib *pattrib, struct sta_info *psta)
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);
478 memset(pattrib->dot118021x_UncstKey.skey, 0, 16);
479 memset(pattrib->dot11tkiptxmickey.skey, 0, 16);
480 pattrib->mac_id = psta->mac_id;
482 if (psta->ieee8021x_blocked == true) {
483 pattrib->encrypt = 0;
485 if ((pattrib->ether_type != 0x888e) && (check_fwstate(pmlmepriv, WIFI_MP_STATE) == false)) {
490 GET_ENCRY_ALGO(psecuritypriv, psta, pattrib->encrypt, bmcast);
492 switch (psecuritypriv->dot11AuthAlgrthm) {
493 case dot11AuthAlgrthm_Open:
494 case dot11AuthAlgrthm_Shared:
495 case dot11AuthAlgrthm_Auto:
496 pattrib->key_idx = (u8)psecuritypriv->dot11PrivacyKeyIndex;
498 case dot11AuthAlgrthm_8021X:
500 pattrib->key_idx = (u8)psecuritypriv->dot118021XGrpKeyid;
502 pattrib->key_idx = 0;
505 pattrib->key_idx = 0;
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_;
514 switch (pattrib->encrypt) {
518 pattrib->icv_len = 4;
519 WEP_IV(pattrib->iv, psta->dot11txpn, pattrib->key_idx);
524 pattrib->icv_len = 4;
526 if (psecuritypriv->busetkipkey == _FAIL) {
532 TKIP_IV(pattrib->iv, psta->dot11txpn, pattrib->key_idx);
534 TKIP_IV(pattrib->iv, psta->dot11txpn, 0);
536 memcpy(pattrib->dot11tkiptxmickey.skey, psta->dot11tkiptxmickey.skey, 16);
543 pattrib->icv_len = 8;
546 AES_IV(pattrib->iv, psta->dot11txpn, pattrib->key_idx);
548 AES_IV(pattrib->iv, psta->dot11txpn, 0);
554 pattrib->icv_len = 0;
558 if (pattrib->encrypt > 0)
559 memcpy(pattrib->dot118021x_UncstKey.skey, psta->dot118021x_UncstKey.skey, 16);
561 if (pattrib->encrypt &&
562 ((padapter->securitypriv.sw_encrypt) || (!psecuritypriv->hw_decrypted)))
563 pattrib->bswenc = true;
565 pattrib->bswenc = false;
572 u8 qos_acm(u8 acm_mask, u8 priority)
577 if (acm_mask & BIT(1))
585 if (acm_mask & BIT(2))
590 if (acm_mask & BIT(3))
600 static void set_qos(struct pkt_file *ppktfile, struct pkt_attrib *pattrib)
602 struct ethhdr etherhdr;
604 s32 UserPriority = 0;
606 _rtw_open_pktfile(ppktfile->pkt, ppktfile);
607 _rtw_pktfile_read(ppktfile, (unsigned char *)ðerhdr, ETH_HLEN);
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;
614 pattrib->priority = UserPriority;
615 pattrib->hdrlen = WLAN_HDR_A3_QOS_LEN;
616 pattrib->subtype = WIFI_QOS_DATA_TYPE;
619 static s32 update_attrib(struct adapter *padapter, struct sk_buff *pkt, struct pkt_attrib *pattrib)
621 struct pkt_file pktfile;
622 struct sta_info *psta = NULL;
623 struct ethhdr etherhdr;
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;
631 _rtw_open_pktfile(pkt, &pktfile);
632 _rtw_pktfile_read(&pktfile, (u8 *)ðerhdr, ETH_HLEN);
634 pattrib->ether_type = ntohs(etherhdr.h_proto);
636 memcpy(pattrib->dst, ðerhdr.h_dest, ETH_ALEN);
637 memcpy(pattrib->src, ðerhdr.h_source, ETH_ALEN);
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);
651 pattrib->pktlen = pktfile.pkt_len;
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 */
659 _rtw_pktfile_read(&pktfile, &tmp[0], 24);
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;
673 /* for parsing ICMP pakcets */
675 struct iphdr *piphdr = (struct iphdr *)tmp;
677 pattrib->icmp_pkt = 0;
678 if (piphdr->protocol == 0x1) /* protocol type in ip header 0x1 is ICMP */
679 pattrib->icmp_pkt = 1;
681 } else if (pattrib->ether_type == 0x888e) {
682 netdev_dbg(padapter->pnetdev, "send eapol packet\n");
685 if ((pattrib->ether_type == 0x888e) || (pattrib->dhcp_pkt == 1))
686 rtw_set_scan_deny(padapter, 3000);
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);
694 bmcast = is_multicast_ether_addr(pattrib->ra);
698 psta = rtw_get_bcmc_stainfo(padapter);
700 psta = rtw_get_stainfo(pstapriv, pattrib->ra);
701 if (!psta) { /* if we cannot get psta => drop the pkt */
704 } else if ((check_fwstate(pmlmepriv, WIFI_AP_STATE) == true) && (!(psta->state & _FW_LINKED))) {
711 /* if we cannot get psta => drop the pkt */
716 if (!(psta->state & _FW_LINKED))
720 if (update_attrib_sec_info(padapter, pattrib, psta) == _FAIL) {
725 update_attrib_phy_info(padapter, pattrib, psta);
727 pattrib->psta = psta;
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 */
736 pattrib->hdrlen = WLAN_HDR_A3_LEN;
737 pattrib->subtype = WIFI_DATA_TYPE;
738 pattrib->priority = 0;
740 if (check_fwstate(pmlmepriv, WIFI_AP_STATE|WIFI_ADHOC_STATE|WIFI_ADHOC_MASTER_STATE)) {
742 set_qos(&pktfile, pattrib);
744 if (pqospriv->qos_option) {
745 set_qos(&pktfile, pattrib);
747 if (pmlmepriv->acm_mask != 0)
748 pattrib->priority = qos_acm(pmlmepriv->acm_mask, pattrib->priority);
752 /* pattrib->priority = 5; force to used VI queue, for testing */
758 static s32 xmitframe_addmic(struct adapter *padapter, struct xmit_frame *pxmitframe)
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);
770 hw_hdr_offset = TXDESC_OFFSET;
772 if (pattrib->encrypt == _TKIP_) {
773 /* encode mic code */
775 u8 null_key[16] = {0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0};
777 pframe = pxmitframe->buf_addr + hw_hdr_offset;
780 if (!memcmp(psecuritypriv->dot118021XGrptxmickey[psecuritypriv->dot118021XGrpKeyid].skey, null_key, 16))
782 /* start to calculate the mic code */
783 rtw_secmicsetkey(&micdata, psecuritypriv->dot118021XGrptxmickey[psecuritypriv->dot118021XGrpKeyid].skey);
785 if (!memcmp(&pattrib->dot11tkiptxmickey.skey[0], null_key, 16))
787 /* start to calculate the mic code */
788 rtw_secmicsetkey(&micdata, &pattrib->dot11tkiptxmickey.skey[0]);
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);
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);
802 rtw_secmicappend(&micdata, &pframe[10], 6);
806 priority[0] = (u8)pxmitframe->attrib.priority;
808 rtw_secmicappend(&micdata, &priority[0], 4);
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;
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;
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;
826 rtw_secgetmic(&micdata, &mic[0]);
827 /* add mic code and add the mic code length in last_txcmdsz */
829 memcpy(payload, &mic[0], 8);
830 pattrib->last_txcmdsz += 8;
836 static s32 xmitframe_swencrypt(struct adapter *padapter, struct xmit_frame *pxmitframe)
838 struct pkt_attrib *pattrib = &pxmitframe->attrib;
840 if (pattrib->bswenc) {
841 switch (pattrib->encrypt) {
844 rtw_wep_encrypt(padapter, (u8 *)pxmitframe);
847 rtw_tkip_encrypt(padapter, (u8 *)pxmitframe);
850 rtw_aes_encrypt(padapter, (u8 *)pxmitframe);
860 s32 rtw_make_wlanhdr(struct adapter *padapter, u8 *hdr, struct pkt_attrib *pattrib)
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;
871 memset(hdr, 0, WLANHDR_OFFSET);
873 SetFrameSubType(fctrl, pattrib->subtype);
875 if (pattrib->subtype & WIFI_DATA_TYPE) {
876 if (check_fwstate(pmlmepriv, WIFI_STATION_STATE) == true) {
877 /* to_ds = 1, fr_ds = 0; */
880 /* 1.Data transfer to AP */
881 /* 2.Arp pkt will relayed by AP */
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);
888 if (pqospriv->qos_option)
890 } else if (check_fwstate(pmlmepriv, WIFI_AP_STATE) == true) {
891 /* to_ds = 0, fr_ds = 1; */
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);
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);
915 if (pattrib->encrypt)
919 qc = (unsigned short *)(hdr + pattrib->hdrlen - 2);
921 if (pattrib->priority)
922 SetPriority(qc, pattrib->priority);
924 SetEOSP(qc, pattrib->eosp);
926 SetAckpolicy(qc, pattrib->ack_policy);
929 /* TODO: fill HT Control Field */
931 /* Update Seq Num will be handled by f/w */
933 struct sta_info *psta;
935 psta = rtw_get_stainfo(&padapter->stapriv, pattrib->ra);
936 if (pattrib->psta != psta)
942 if (!(psta->state & _FW_LINKED))
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];
950 SetSeqNum(hdr, pattrib->seqnum);
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;
957 /* re-check if enable ampdu by BA_starting_seqctrl */
958 if (pattrib->ampdu_en == true) {
961 tx_seq = psta->BA_starting_seqctrl[pattrib->priority & 0x0f];
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;
969 pattrib->ampdu_en = true;/* AGG EN */
971 psta->BA_starting_seqctrl[pattrib->priority & 0x0f] = (pattrib->seqnum+1)&0xfff;
972 pattrib->ampdu_en = true;/* AGG EN */
984 s32 rtw_txframes_pending(struct adapter *padapter)
986 struct xmit_priv *pxmitpriv = &padapter->xmitpriv;
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)));
995 * Calculate wlan 802.11 packet MAX size from pkt_attrib
996 * This function doesn't consider fragment case
998 u32 rtw_calculate_wlan_pkt_size_by_attribue(struct pkt_attrib *pattrib)
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_)
1007 len += ((pattrib->bswenc) ? pattrib->icv_len : 0); /* ICV */
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
1018 * 5. move frag chunk from pframe to pxmitframe->mem
1019 * 6. apply sw-encrypt, if necessary.
1021 s32 rtw_xmitframe_coalesce(struct adapter *padapter, struct sk_buff *pkt, struct xmit_frame *pxmitframe)
1023 struct pkt_file pktfile;
1025 s32 frg_inx, frg_len, mpdu_len, llc_sz, mem_sz;
1029 u8 *pframe, *mem_start;
1032 struct xmit_priv *pxmitpriv = &padapter->xmitpriv;
1034 struct pkt_attrib *pattrib = &pxmitframe->attrib;
1038 s32 bmcst = is_multicast_ether_addr(pattrib->ra);
1041 if (!pxmitframe->buf_addr)
1044 pbuf_start = pxmitframe->buf_addr;
1046 hw_hdr_offset = TXDESC_OFFSET;
1047 mem_start = pbuf_start + hw_hdr_offset;
1049 if (rtw_make_wlanhdr(padapter, mem_start, pattrib) == _FAIL) {
1054 _rtw_open_pktfile(pkt, &pktfile);
1055 _rtw_pktfile_read(&pktfile, NULL, pattrib->pkt_hdrlen);
1058 frg_len = pxmitpriv->frag_len - 4;/* 2346-4 = 2342 */
1067 SetMFrag(mem_start);
1069 pframe += pattrib->hdrlen;
1070 mpdu_len -= pattrib->hdrlen;
1072 /* adding icv, if necessary... */
1073 if (pattrib->iv_len) {
1074 memcpy(pframe, pattrib->iv, pattrib->iv_len);
1076 pframe += pattrib->iv_len;
1078 mpdu_len -= pattrib->iv_len;
1082 llc_sz = rtw_put_snap(pframe, pattrib->ether_type);
1087 if ((pattrib->icv_len > 0) && (pattrib->bswenc))
1088 mpdu_len -= pattrib->icv_len;
1091 /* don't do fragment to broadcast/multicast packets */
1092 mem_sz = _rtw_pktfile_read(&pktfile, pframe, pattrib->pktlen);
1094 mem_sz = _rtw_pktfile_read(&pktfile, pframe, mpdu_len);
1099 if ((pattrib->icv_len > 0) && (pattrib->bswenc)) {
1100 memcpy(pframe, pattrib->icv, pattrib->icv_len);
1101 pframe += pattrib->icv_len;
1106 if (bmcst || (rtw_endofpktfile(&pktfile) == true)) {
1107 pattrib->nr_frags = frg_inx;
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;
1112 ClearMFrag(mem_start);
1117 addr = (SIZE_PTR)(pframe);
1119 mem_start = (unsigned char *)round_up(addr, 4) + hw_hdr_offset;
1120 memcpy(mem_start, pbuf_start + hw_hdr_offset, pattrib->hdrlen);
1123 if (xmitframe_addmic(padapter, pxmitframe) == _FAIL) {
1128 xmitframe_swencrypt(padapter, pxmitframe);
1131 update_attrib_vcs_info(padapter, pxmitframe);
1133 pattrib->vcs_mode = NONE_VCS;
1139 /* broadcast or multicast management pkt use BIP, unicast management pkt use CCMP encryption */
1140 s32 rtw_mgmt_xmitframe_coalesce(struct adapter *padapter, struct sk_buff *pkt, struct xmit_frame *pxmitframe)
1142 u8 *pframe, *mem_start = NULL, *tmp_buf = NULL;
1144 struct sta_info *psta = NULL;
1145 struct pkt_attrib *pattrib = &pxmitframe->attrib;
1146 s32 bmcst = is_multicast_ether_addr(pattrib->ra);
1148 u8 *MGMT_body = NULL;
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_];
1156 mem_start = pframe = (u8 *)(pxmitframe->buf_addr) + TXDESC_OFFSET;
1157 pwlanhdr = (struct ieee80211_hdr *)pframe;
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) */
1166 spin_lock_bh(&padapter->security_key_mutex);
1168 /* only support station mode */
1169 if (!check_fwstate(pmlmepriv, WIFI_STATION_STATE) || !check_fwstate(pmlmepriv, _FW_LINKED))
1170 goto xmitframe_coalesce_success;
1172 /* IGTK key is not install, it may not support 802.11w */
1173 if (!padapter->securitypriv.binstallBIPkey)
1174 goto xmitframe_coalesce_success;
1176 /* station mode doesn't need TX BIP, just ready the code */
1183 /* other types doesn't need the BIP */
1184 if (GetFrameSubType(pframe) != WIFI_DEAUTH && GetFrameSubType(pframe) != WIFI_DISASSOC)
1185 goto xmitframe_coalesce_fail;
1187 MGMT_body = pframe + sizeof(struct ieee80211_hdr_3addr);
1188 pframe += pattrib->pktlen;
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++;
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);
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);
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;
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) {
1225 psta = pattrib->psta;
1227 psta = rtw_get_stainfo(&padapter->stapriv, pattrib->ra);
1230 goto xmitframe_coalesce_fail;
1232 if (!(psta->state & _FW_LINKED) || !pxmitframe->buf_addr)
1233 goto xmitframe_coalesce_fail;
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;
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;
1256 switch (pattrib->encrypt) {
1258 /* set AES IV header */
1259 AES_IV(pattrib->iv, psta->dot11wtxpn, 0);
1262 goto xmitframe_coalesce_fail;
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;
1277 /* add 8 bytes MIC */
1278 pattrib->pktlen += pattrib->icv_len;
1279 /* set final tx command size */
1280 pattrib->last_txcmdsz = pattrib->pktlen;
1282 /* set protected bit must be beofre SW encrypt */
1283 SetPrivacy(mem_start);
1284 /* software encrypt */
1285 xmitframe_swencrypt(padapter, pxmitframe);
1289 xmitframe_coalesce_success:
1290 spin_unlock_bh(&padapter->security_key_mutex);
1294 xmitframe_coalesce_fail:
1295 spin_unlock_bh(&padapter->security_key_mutex);
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.
1307 s32 rtw_put_snap(u8 *data, u16 h_proto)
1309 struct ieee80211_snap_hdr *snap;
1312 snap = (struct ieee80211_snap_hdr *)data;
1317 if (h_proto == 0x8137 || h_proto == 0x80f3)
1322 snap->oui[0] = oui[0];
1323 snap->oui[1] = oui[1];
1324 snap->oui[2] = oui[2];
1326 *(__be16 *)(data + SNAP_SIZE) = htons(h_proto);
1328 return SNAP_SIZE + sizeof(u16);
1331 void rtw_update_protection(struct adapter *padapter, u8 *ie, uint ie_len)
1336 struct xmit_priv *pxmitpriv = &padapter->xmitpriv;
1337 struct registry_priv *pregistrypriv = &padapter->registrypriv;
1339 switch (pxmitpriv->vcs_setting) {
1341 pxmitpriv->vcs = NONE_VCS;
1349 perp = rtw_get_ie(ie, WLAN_EID_ERP_INFO, &erp_len, ie_len);
1351 pxmitpriv->vcs = NONE_VCS;
1353 protection = (*(perp + 2)) & BIT(1);
1355 if (pregistrypriv->vcs_type == RTS_CTS)
1356 pxmitpriv->vcs = RTS_CTS;
1358 pxmitpriv->vcs = CTS_TO_SELF;
1360 pxmitpriv->vcs = NONE_VCS;
1368 void rtw_count_tx_stats(struct adapter *padapter, struct xmit_frame *pxmitframe, int sz)
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;
1376 if ((pxmitframe->frame_tag&0x0f) == DATA_FRAMETAG) {
1377 pkt_num = pxmitframe->agg_num;
1379 pmlmepriv->LinkDetectInfo.NumTxOkInPeriod += pkt_num;
1381 pxmitpriv->tx_pkts += pkt_num;
1383 pxmitpriv->tx_bytes += sz;
1385 psta = pxmitframe->attrib.psta;
1387 pstats = &psta->sta_stats;
1389 pstats->tx_pkts += pkt_num;
1391 pstats->tx_bytes += sz;
1396 static struct xmit_buf *__rtw_alloc_cmd_xmitbuf(struct xmit_priv *pxmitpriv,
1397 enum cmdbuf_type buf_type)
1399 struct xmit_buf *pxmitbuf = NULL;
1401 pxmitbuf = &pxmitpriv->pcmd_xmitbuf[buf_type];
1403 pxmitbuf->priv_data = NULL;
1406 pxmitbuf->pdata = pxmitbuf->ptail = pxmitbuf->phead;
1407 pxmitbuf->agg_num = 0;
1408 pxmitbuf->pg_num = 0;
1411 rtw_sctx_done_err(&pxmitbuf->sctx, RTW_SCTX_DONE_BUF_ALLOC);
1417 struct xmit_frame *__rtw_alloc_cmdxmitframe(struct xmit_priv *pxmitpriv,
1418 enum cmdbuf_type buf_type)
1420 struct xmit_frame *pcmdframe;
1421 struct xmit_buf *pxmitbuf;
1423 pcmdframe = rtw_alloc_xmitframe(pxmitpriv);
1427 pxmitbuf = __rtw_alloc_cmd_xmitbuf(pxmitpriv, buf_type);
1429 rtw_free_xmitframe(pxmitpriv, pcmdframe);
1433 pcmdframe->frame_tag = MGNT_FRAMETAG;
1435 pcmdframe->pxmitbuf = pxmitbuf;
1437 pcmdframe->buf_addr = pxmitbuf->pbuf;
1439 pxmitbuf->priv_data = pcmdframe;
1444 struct xmit_buf *rtw_alloc_xmitbuf_ext(struct xmit_priv *pxmitpriv)
1447 struct xmit_buf *pxmitbuf = NULL;
1448 struct list_head *plist, *phead;
1449 struct __queue *pfree_queue = &pxmitpriv->free_xmit_extbuf_queue;
1451 spin_lock_irqsave(&pfree_queue->lock, irqL);
1453 if (list_empty(&pfree_queue->queue)) {
1456 phead = get_list_head(pfree_queue);
1458 plist = get_next(phead);
1460 pxmitbuf = container_of(plist, struct xmit_buf, list);
1462 list_del_init(&pxmitbuf->list);
1466 pxmitpriv->free_xmit_extbuf_cnt--;
1468 pxmitbuf->priv_data = NULL;
1471 pxmitbuf->pdata = pxmitbuf->ptail = pxmitbuf->phead;
1472 pxmitbuf->agg_num = 1;
1475 rtw_sctx_done_err(&pxmitbuf->sctx, RTW_SCTX_DONE_BUF_ALLOC);
1478 spin_unlock_irqrestore(&pfree_queue->lock, irqL);
1483 s32 rtw_free_xmitbuf_ext(struct xmit_priv *pxmitpriv, struct xmit_buf *pxmitbuf)
1486 struct __queue *pfree_queue = &pxmitpriv->free_xmit_extbuf_queue;
1491 spin_lock_irqsave(&pfree_queue->lock, irqL);
1493 list_del_init(&pxmitbuf->list);
1495 list_add_tail(&pxmitbuf->list, get_list_head(pfree_queue));
1496 pxmitpriv->free_xmit_extbuf_cnt++;
1498 spin_unlock_irqrestore(&pfree_queue->lock, irqL);
1503 struct xmit_buf *rtw_alloc_xmitbuf(struct xmit_priv *pxmitpriv)
1506 struct xmit_buf *pxmitbuf = NULL;
1507 struct list_head *plist, *phead;
1508 struct __queue *pfree_xmitbuf_queue = &pxmitpriv->free_xmitbuf_queue;
1510 spin_lock_irqsave(&pfree_xmitbuf_queue->lock, irqL);
1512 if (list_empty(&pfree_xmitbuf_queue->queue)) {
1515 phead = get_list_head(pfree_xmitbuf_queue);
1517 plist = get_next(phead);
1519 pxmitbuf = container_of(plist, struct xmit_buf, list);
1521 list_del_init(&pxmitbuf->list);
1525 pxmitpriv->free_xmitbuf_cnt--;
1527 pxmitbuf->priv_data = NULL;
1530 pxmitbuf->pdata = pxmitbuf->ptail = pxmitbuf->phead;
1531 pxmitbuf->agg_num = 0;
1532 pxmitbuf->pg_num = 0;
1535 rtw_sctx_done_err(&pxmitbuf->sctx, RTW_SCTX_DONE_BUF_ALLOC);
1538 spin_unlock_irqrestore(&pfree_xmitbuf_queue->lock, irqL);
1543 s32 rtw_free_xmitbuf(struct xmit_priv *pxmitpriv, struct xmit_buf *pxmitbuf)
1546 struct __queue *pfree_xmitbuf_queue = &pxmitpriv->free_xmitbuf_queue;
1552 rtw_sctx_done_err(&pxmitbuf->sctx, RTW_SCTX_DONE_BUF_FREE);
1554 if (pxmitbuf->buf_tag == XMITBUF_CMD) {
1555 } else if (pxmitbuf->buf_tag == XMITBUF_MGNT) {
1556 rtw_free_xmitbuf_ext(pxmitpriv, pxmitbuf);
1558 spin_lock_irqsave(&pfree_xmitbuf_queue->lock, irqL);
1560 list_del_init(&pxmitbuf->list);
1562 list_add_tail(&pxmitbuf->list,
1563 get_list_head(pfree_xmitbuf_queue));
1565 pxmitpriv->free_xmitbuf_cnt++;
1566 spin_unlock_irqrestore(&pfree_xmitbuf_queue->lock, irqL);
1571 static void rtw_init_xmitframe(struct xmit_frame *pxframe)
1573 if (pxframe) { /* default value setting */
1574 pxframe->buf_addr = NULL;
1575 pxframe->pxmitbuf = NULL;
1577 memset(&pxframe->attrib, 0, sizeof(struct pkt_attrib));
1579 pxframe->frame_tag = DATA_FRAMETAG;
1581 pxframe->pg_num = 1;
1582 pxframe->agg_num = 1;
1583 pxframe->ack_report = 0;
1590 * 2. RXENTRY (rx_thread or RX_ISR/RX_CallBack)
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...
1595 * Must be very, very cautious...
1597 struct xmit_frame *rtw_alloc_xmitframe(struct xmit_priv *pxmitpriv)/* _queue *pfree_xmit_queue) */
1600 * Please remember to use all the osdep_service api,
1601 * and lock/unlock or _enter/_exit critical to protect
1605 struct xmit_frame *pxframe = NULL;
1606 struct list_head *plist, *phead;
1607 struct __queue *pfree_xmit_queue = &pxmitpriv->free_xmit_queue;
1609 spin_lock_bh(&pfree_xmit_queue->lock);
1611 if (list_empty(&pfree_xmit_queue->queue)) {
1614 phead = get_list_head(pfree_xmit_queue);
1616 plist = get_next(phead);
1618 pxframe = container_of(plist, struct xmit_frame, list);
1620 list_del_init(&pxframe->list);
1621 pxmitpriv->free_xmitframe_cnt--;
1624 spin_unlock_bh(&pfree_xmit_queue->lock);
1626 rtw_init_xmitframe(pxframe);
1630 struct xmit_frame *rtw_alloc_xmitframe_ext(struct xmit_priv *pxmitpriv)
1632 struct xmit_frame *pxframe = NULL;
1633 struct list_head *plist, *phead;
1634 struct __queue *queue = &pxmitpriv->free_xframe_ext_queue;
1636 spin_lock_bh(&queue->lock);
1638 if (list_empty(&queue->queue)) {
1641 phead = get_list_head(queue);
1642 plist = get_next(phead);
1643 pxframe = container_of(plist, struct xmit_frame, list);
1645 list_del_init(&pxframe->list);
1646 pxmitpriv->free_xframe_ext_cnt--;
1649 spin_unlock_bh(&queue->lock);
1651 rtw_init_xmitframe(pxframe);
1656 struct xmit_frame *rtw_alloc_xmitframe_once(struct xmit_priv *pxmitpriv)
1658 struct xmit_frame *pxframe = NULL;
1661 alloc_addr = rtw_zmalloc(sizeof(struct xmit_frame) + 4);
1666 pxframe = (struct xmit_frame *)N_BYTE_ALIGMENT((SIZE_PTR)(alloc_addr), 4);
1667 pxframe->alloc_addr = alloc_addr;
1669 pxframe->padapter = pxmitpriv->adapter;
1670 pxframe->frame_tag = NULL_FRAMETAG;
1672 pxframe->pkt = NULL;
1674 pxframe->buf_addr = NULL;
1675 pxframe->pxmitbuf = NULL;
1677 rtw_init_xmitframe(pxframe);
1683 s32 rtw_free_xmitframe(struct xmit_priv *pxmitpriv, struct xmit_frame *pxmitframe)
1685 struct __queue *queue = NULL;
1686 struct adapter *padapter = pxmitpriv->adapter;
1687 struct sk_buff *pndis_pkt = NULL;
1692 if (pxmitframe->pkt) {
1693 pndis_pkt = pxmitframe->pkt;
1694 pxmitframe->pkt = NULL;
1697 if (pxmitframe->alloc_addr) {
1698 kfree(pxmitframe->alloc_addr);
1699 goto check_pkt_complete;
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;
1709 spin_lock_bh(&queue->lock);
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++;
1718 spin_unlock_bh(&queue->lock);
1723 rtw_os_pkt_complete(padapter, pndis_pkt);
1729 void rtw_free_xmitframe_queue(struct xmit_priv *pxmitpriv, struct __queue *pframequeue)
1731 struct list_head *plist, *phead, *tmp;
1732 struct xmit_frame *pxmitframe;
1734 spin_lock_bh(&pframequeue->lock);
1736 phead = get_list_head(pframequeue);
1737 list_for_each_safe(plist, tmp, phead) {
1738 pxmitframe = list_entry(plist, struct xmit_frame, list);
1740 rtw_free_xmitframe(pxmitpriv, pxmitframe);
1742 spin_unlock_bh(&pframequeue->lock);
1745 s32 rtw_xmitframe_enqueue(struct adapter *padapter, struct xmit_frame *pxmitframe)
1747 if (rtw_xmit_classifier(padapter, pxmitframe) == _FAIL)
1753 struct tx_servq *rtw_get_sta_pending(struct adapter *padapter, struct sta_info *psta, signed int up, u8 *ac)
1755 struct tx_servq *ptxservq = NULL;
1760 ptxservq = &psta->sta_xmitpriv.bk_q;
1766 ptxservq = &psta->sta_xmitpriv.vi_q;
1772 ptxservq = &psta->sta_xmitpriv.vo_q;
1779 ptxservq = &psta->sta_xmitpriv.be_q;
1788 * Will enqueue pxmitframe to the proper queue,
1789 * and indicate it to xx_pending list.....
1791 s32 rtw_xmit_classifier(struct adapter *padapter, struct xmit_frame *pxmitframe)
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;
1800 psta = rtw_get_stainfo(&padapter->stapriv, pattrib->ra);
1801 if (pattrib->psta != psta)
1809 if (!(psta->state & _FW_LINKED))
1812 ptxservq = rtw_get_sta_pending(padapter, psta, pattrib->priority, (u8 *)(&ac_index));
1814 if (list_empty(&ptxservq->tx_pending))
1815 list_add_tail(&ptxservq->tx_pending, get_list_head(phwxmits[ac_index].sta_queue));
1817 list_add_tail(&pxmitframe->list, get_list_head(&ptxservq->sta_pending));
1819 phwxmits[ac_index].accnt++;
1826 s32 rtw_alloc_hwxmits(struct adapter *padapter)
1828 struct hw_xmit *hwxmits;
1829 struct xmit_priv *pxmitpriv = &padapter->xmitpriv;
1831 pxmitpriv->hwxmit_entry = HWXMIT_ENTRY;
1833 pxmitpriv->hwxmits = NULL;
1835 pxmitpriv->hwxmits = rtw_zmalloc(sizeof(struct hw_xmit) * pxmitpriv->hwxmit_entry);
1837 if (!pxmitpriv->hwxmits)
1840 hwxmits = pxmitpriv->hwxmits;
1842 if (pxmitpriv->hwxmit_entry == 5) {
1843 hwxmits[0] .sta_queue = &pxmitpriv->bm_pending;
1845 hwxmits[1] .sta_queue = &pxmitpriv->vo_pending;
1847 hwxmits[2] .sta_queue = &pxmitpriv->vi_pending;
1849 hwxmits[3] .sta_queue = &pxmitpriv->bk_pending;
1851 hwxmits[4] .sta_queue = &pxmitpriv->be_pending;
1852 } else if (pxmitpriv->hwxmit_entry == 4) {
1853 hwxmits[0] .sta_queue = &pxmitpriv->vo_pending;
1855 hwxmits[1] .sta_queue = &pxmitpriv->vi_pending;
1857 hwxmits[2] .sta_queue = &pxmitpriv->be_pending;
1859 hwxmits[3] .sta_queue = &pxmitpriv->bk_pending;
1866 void rtw_free_hwxmits(struct adapter *padapter)
1868 struct xmit_priv *pxmitpriv = &padapter->xmitpriv;
1870 kfree(pxmitpriv->hwxmits);
1873 void rtw_init_hwxmits(struct hw_xmit *phwxmit, signed int entry)
1877 for (i = 0; i < entry; i++, phwxmit++)
1881 u32 rtw_get_ff_hwaddr(struct xmit_frame *pxmitframe)
1884 struct pkt_attrib *pattrib = &pxmitframe->attrib;
1886 switch (pattrib->qsel) {
1889 addr = BE_QUEUE_INX;
1893 addr = BK_QUEUE_INX;
1897 addr = VI_QUEUE_INX;
1901 addr = VO_QUEUE_INX;
1904 addr = BCN_QUEUE_INX;
1906 case 0x11:/* BC/MC in PS (HIQ) */
1907 addr = HIGH_QUEUE_INX;
1911 addr = MGT_QUEUE_INX;
1918 static void do_queue_select(struct adapter *padapter, struct pkt_attrib *pattrib)
1922 qsel = pattrib->priority;
1924 pattrib->qsel = qsel;
1928 * The main transmit(tx) entry
1932 *0 success, hardware will handle this xmit frame(packet)
1935 s32 rtw_xmit(struct adapter *padapter, struct sk_buff **ppkt)
1937 static unsigned long start;
1938 static u32 drop_cnt;
1940 struct xmit_priv *pxmitpriv = &padapter->xmitpriv;
1941 struct xmit_frame *pxmitframe = NULL;
1948 pxmitframe = rtw_alloc_xmitframe(pxmitpriv);
1950 if (jiffies_to_msecs(jiffies - start) > 2000) {
1960 res = update_attrib(padapter, *ppkt, &pxmitframe->attrib);
1963 rtw_free_xmitframe(pxmitpriv, pxmitframe);
1966 pxmitframe->pkt = *ppkt;
1968 do_queue_select(padapter, &pxmitframe->attrib);
1970 spin_lock_bh(&pxmitpriv->lock);
1971 if (xmitframe_enqueue_for_sleeping_sta(padapter, pxmitframe) == true) {
1972 spin_unlock_bh(&pxmitpriv->lock);
1975 spin_unlock_bh(&pxmitpriv->lock);
1978 if (rtw_hal_xmit(padapter, pxmitframe) == false)
1984 #define RTW_HIQ_FILTER_ALLOW_ALL 0
1985 #define RTW_HIQ_FILTER_ALLOW_SPECIAL 1
1986 #define RTW_HIQ_FILTER_DENY_ALL 2
1988 inline bool xmitframe_hiq_filter(struct xmit_frame *xmitframe)
1991 struct adapter *adapter = xmitframe->padapter;
1992 struct registry_priv *registry = &adapter->registrypriv;
1994 if (registry->hiq_filter == RTW_HIQ_FILTER_ALLOW_SPECIAL) {
1995 struct pkt_attrib *attrib = &xmitframe->attrib;
1997 if (attrib->ether_type == 0x0806 ||
1998 attrib->ether_type == 0x888e ||
2003 } else if (registry->hiq_filter == RTW_HIQ_FILTER_ALLOW_ALL)
2005 else if (registry->hiq_filter == RTW_HIQ_FILTER_DENY_ALL) {
2012 signed int xmitframe_enqueue_for_sleeping_sta(struct adapter *padapter, struct xmit_frame *pxmitframe)
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;
2022 if (check_fwstate(pmlmepriv, WIFI_AP_STATE) == false)
2024 psta = rtw_get_stainfo(&padapter->stapriv, pattrib->ra);
2025 if (pattrib->psta != psta)
2031 if (!(psta->state & _FW_LINKED))
2034 if (pattrib->triggered == 1) {
2035 if (bmcst && xmitframe_hiq_filter(pxmitframe))
2036 pattrib->qsel = 0x11;/* HIQ */
2042 spin_lock_bh(&psta->sleep_q.lock);
2044 if (pstapriv->sta_dz_bitmap) { /* if anyone sta is in ps mode */
2045 /* pattrib->qsel = 0x11;HIQ */
2047 list_del_init(&pxmitframe->list);
2049 list_add_tail(&pxmitframe->list, get_list_head(&psta->sleep_q));
2053 if (!(pstapriv->tim_bitmap & BIT(0)))
2056 pstapriv->tim_bitmap |= BIT(0);
2057 pstapriv->sta_dz_bitmap |= BIT(0);
2060 update_beacon(padapter, WLAN_EID_TIM, NULL, true);
2062 chk_bmc_sleepq_cmd(padapter);
2067 spin_unlock_bh(&psta->sleep_q.lock);
2072 spin_lock_bh(&psta->sleep_q.lock);
2074 if (psta->state&WIFI_SLEEP_STATE) {
2077 if (pstapriv->sta_dz_bitmap & BIT(psta->aid)) {
2078 list_del_init(&pxmitframe->list);
2080 list_add_tail(&pxmitframe->list, get_list_head(&psta->sleep_q));
2084 switch (pattrib->priority) {
2087 wmmps_ac = psta->uapsd_bk&BIT(0);
2091 wmmps_ac = psta->uapsd_vi&BIT(0);
2095 wmmps_ac = psta->uapsd_vo&BIT(0);
2100 wmmps_ac = psta->uapsd_be&BIT(0);
2105 psta->sleepq_ac_len++;
2107 if (((psta->has_legacy_ac) && (!wmmps_ac)) || ((!psta->has_legacy_ac) && (wmmps_ac))) {
2108 if (!(pstapriv->tim_bitmap & BIT(psta->aid)))
2111 pstapriv->tim_bitmap |= BIT(psta->aid);
2114 /* update BCN for TIM IE */
2115 update_beacon(padapter, WLAN_EID_TIM, NULL, true);
2122 spin_unlock_bh(&psta->sleep_q.lock);
2127 static void dequeue_xmitframes_to_sleeping_queue(struct adapter *padapter, struct sta_info *psta, struct __queue *pframequeue)
2130 struct list_head *plist, *phead, *tmp;
2132 struct tx_servq *ptxservq;
2133 struct pkt_attrib *pattrib;
2134 struct xmit_frame *pxmitframe;
2135 struct hw_xmit *phwxmits = padapter->xmitpriv.hwxmits;
2137 phead = get_list_head(pframequeue);
2138 list_for_each_safe(plist, tmp, phead) {
2139 pxmitframe = list_entry(plist, struct xmit_frame, list);
2141 pattrib = &pxmitframe->attrib;
2143 pattrib->triggered = 0;
2145 ret = xmitframe_enqueue_for_sleeping_sta(padapter, pxmitframe);
2148 ptxservq = rtw_get_sta_pending(padapter, psta, pattrib->priority, (u8 *)(&ac_index));
2151 phwxmits[ac_index].accnt--;
2157 void stop_sta_xmit(struct adapter *padapter, struct sta_info *psta)
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;
2164 pstaxmitpriv = &psta->sta_xmitpriv;
2166 /* for BC/MC Frames */
2167 psta_bmc = rtw_get_bcmc_stainfo(padapter);
2169 spin_lock_bh(&pxmitpriv->lock);
2171 psta->state |= WIFI_SLEEP_STATE;
2173 pstapriv->sta_dz_bitmap |= BIT(psta->aid);
2175 dequeue_xmitframes_to_sleeping_queue(padapter, psta, &pstaxmitpriv->vo_q.sta_pending);
2176 list_del_init(&pstaxmitpriv->vo_q.tx_pending);
2178 dequeue_xmitframes_to_sleeping_queue(padapter, psta, &pstaxmitpriv->vi_q.sta_pending);
2179 list_del_init(&pstaxmitpriv->vi_q.tx_pending);
2181 dequeue_xmitframes_to_sleeping_queue(padapter, psta, &pstaxmitpriv->be_q.sta_pending);
2182 list_del_init(&pstaxmitpriv->be_q.tx_pending);
2184 dequeue_xmitframes_to_sleeping_queue(padapter, psta, &pstaxmitpriv->bk_q.sta_pending);
2185 list_del_init(&pstaxmitpriv->bk_q.tx_pending);
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);
2192 spin_unlock_bh(&pxmitpriv->lock);
2195 void wakeup_sta_to_xmit(struct adapter *padapter, struct sta_info *psta)
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;
2204 psta_bmc = rtw_get_bcmc_stainfo(padapter);
2206 spin_lock_bh(&pxmitpriv->lock);
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,
2213 list_del_init(&pxmitframe->list);
2215 switch (pxmitframe->attrib.priority) {
2218 wmmps_ac = psta->uapsd_bk&BIT(1);
2222 wmmps_ac = psta->uapsd_vi&BIT(1);
2226 wmmps_ac = psta->uapsd_vo&BIT(1);
2231 wmmps_ac = psta->uapsd_be&BIT(1);
2236 if (psta->sleepq_len > 0)
2237 pxmitframe->attrib.mdata = 1;
2239 pxmitframe->attrib.mdata = 0;
2242 psta->sleepq_ac_len--;
2243 if (psta->sleepq_ac_len > 0) {
2244 pxmitframe->attrib.mdata = 1;
2245 pxmitframe->attrib.eosp = 0;
2247 pxmitframe->attrib.mdata = 0;
2248 pxmitframe->attrib.eosp = 1;
2252 pxmitframe->attrib.triggered = 1;
2254 rtw_hal_xmitframe_enqueue(padapter, pxmitframe);
2257 if (psta->sleepq_len == 0) {
2258 if (pstapriv->tim_bitmap & BIT(psta->aid))
2259 update_mask = BIT(0);
2261 pstapriv->tim_bitmap &= ~BIT(psta->aid);
2263 if (psta->state&WIFI_SLEEP_STATE)
2264 psta->state ^= WIFI_SLEEP_STATE;
2266 if (psta->state & WIFI_STA_ALIVE_CHK_STATE) {
2267 psta->expire_to = pstapriv->expire_to;
2268 psta->state ^= WIFI_STA_ALIVE_CHK_STATE;
2271 pstapriv->sta_dz_bitmap &= ~BIT(psta->aid);
2274 /* for BC/MC Frames */
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);
2284 list_del_init(&pxmitframe->list);
2286 psta_bmc->sleepq_len--;
2287 if (psta_bmc->sleepq_len > 0)
2288 pxmitframe->attrib.mdata = 1;
2290 pxmitframe->attrib.mdata = 0;
2292 pxmitframe->attrib.triggered = 1;
2293 rtw_hal_xmitframe_enqueue(padapter, pxmitframe);
2296 if (psta_bmc->sleepq_len == 0) {
2297 if (pstapriv->tim_bitmap & BIT(0))
2298 update_mask |= BIT(1);
2300 pstapriv->tim_bitmap &= ~BIT(0);
2301 pstapriv->sta_dz_bitmap &= ~BIT(0);
2307 spin_unlock_bh(&pxmitpriv->lock);
2310 update_beacon(padapter, WLAN_EID_TIM, NULL, true);
2313 void xmit_delivery_enabled_frames(struct adapter *padapter, struct sta_info *psta)
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;
2321 spin_lock_bh(&pxmitpriv->lock);
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,
2328 switch (pxmitframe->attrib.priority) {
2331 wmmps_ac = psta->uapsd_bk&BIT(1);
2335 wmmps_ac = psta->uapsd_vi&BIT(1);
2339 wmmps_ac = psta->uapsd_vo&BIT(1);
2344 wmmps_ac = psta->uapsd_be&BIT(1);
2351 list_del_init(&pxmitframe->list);
2354 psta->sleepq_ac_len--;
2356 if (psta->sleepq_ac_len > 0) {
2357 pxmitframe->attrib.mdata = 1;
2358 pxmitframe->attrib.eosp = 0;
2360 pxmitframe->attrib.mdata = 0;
2361 pxmitframe->attrib.eosp = 1;
2364 pxmitframe->attrib.triggered = 1;
2365 rtw_hal_xmitframe_enqueue(padapter, pxmitframe);
2367 if ((psta->sleepq_ac_len == 0) && (!psta->has_legacy_ac) && (wmmps_ac)) {
2368 pstapriv->tim_bitmap &= ~BIT(psta->aid);
2370 update_beacon(padapter, WLAN_EID_TIM, NULL, true);
2374 spin_unlock_bh(&pxmitpriv->lock);
2377 void enqueue_pending_xmitbuf(struct xmit_priv *pxmitpriv, struct xmit_buf *pxmitbuf)
2379 struct __queue *pqueue;
2380 struct adapter *pri_adapter = pxmitpriv->adapter;
2382 pqueue = &pxmitpriv->pending_xmitbuf_queue;
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);
2389 complete(&pri_adapter->xmitpriv.xmit_comp);
2392 void enqueue_pending_xmitbuf_to_head(struct xmit_priv *pxmitpriv, struct xmit_buf *pxmitbuf)
2394 struct __queue *pqueue;
2396 pqueue = &pxmitpriv->pending_xmitbuf_queue;
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);
2404 struct xmit_buf *dequeue_pending_xmitbuf(struct xmit_priv *pxmitpriv)
2406 struct xmit_buf *pxmitbuf;
2407 struct __queue *pqueue;
2410 pqueue = &pxmitpriv->pending_xmitbuf_queue;
2412 spin_lock_bh(&pqueue->lock);
2414 if (!list_empty(&pqueue->queue)) {
2415 struct list_head *plist, *phead;
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);
2423 spin_unlock_bh(&pqueue->lock);
2428 struct xmit_buf *dequeue_pending_xmitbuf_under_survey(struct xmit_priv *pxmitpriv)
2430 struct xmit_buf *pxmitbuf;
2431 struct __queue *pqueue;
2434 pqueue = &pxmitpriv->pending_xmitbuf_queue;
2436 spin_lock_bh(&pqueue->lock);
2438 if (!list_empty(&pqueue->queue)) {
2439 struct list_head *plist, *phead;
2442 phead = get_list_head(pqueue);
2445 plist = get_next(plist);
2449 pxmitbuf = container_of(plist, struct xmit_buf, list);
2451 type = GetFrameSubType(pxmitbuf->pbuf + TXDESC_OFFSET);
2453 if ((type == WIFI_PROBEREQ) ||
2454 (type == WIFI_DATA_NULL) ||
2455 (type == WIFI_QOS_DATA_NULL)) {
2456 list_del_init(&pxmitbuf->list);
2463 spin_unlock_bh(&pqueue->lock);
2468 signed int check_pending_xmitbuf(struct xmit_priv *pxmitpriv)
2470 struct __queue *pqueue;
2471 signed int ret = false;
2473 pqueue = &pxmitpriv->pending_xmitbuf_queue;
2475 spin_lock_bh(&pqueue->lock);
2477 if (!list_empty(&pqueue->queue))
2480 spin_unlock_bh(&pqueue->lock);
2485 int rtw_xmit_thread(void *context)
2488 struct adapter *padapter;
2493 thread_enter("RTW_XMIT_THREAD");
2496 err = rtw_hal_xmit_thread_handler(padapter);
2497 flush_signals_thread();
2498 } while (err == _SUCCESS);
2500 complete(&padapter->xmitpriv.terminate_xmitthread_comp);
2505 void rtw_sctx_init(struct submit_ctx *sctx, int timeout_ms)
2507 sctx->timeout_ms = timeout_ms;
2508 sctx->submit_time = jiffies;
2509 init_completion(&sctx->done);
2510 sctx->status = RTW_SCTX_SUBMITTED;
2513 int rtw_sctx_wait(struct submit_ctx *sctx)
2516 unsigned long expire;
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;
2524 status = sctx->status;
2526 if (status == RTW_SCTX_DONE_SUCCESS)
2532 void rtw_sctx_done_err(struct submit_ctx **sctx, int status)
2535 (*sctx)->status = status;
2536 complete(&((*sctx)->done));
2541 void rtw_sctx_done(struct submit_ctx **sctx)
2543 rtw_sctx_done_err(sctx, RTW_SCTX_DONE_SUCCESS);
2546 int rtw_ack_tx_wait(struct xmit_priv *pxmitpriv, u32 timeout_ms)
2548 struct submit_ctx *pack_tx_ops = &pxmitpriv->ack_tx_ops;
2550 pack_tx_ops->submit_time = jiffies;
2551 pack_tx_ops->timeout_ms = timeout_ms;
2552 pack_tx_ops->status = RTW_SCTX_SUBMITTED;
2554 return rtw_sctx_wait(pack_tx_ops);
2557 void rtw_ack_tx_done(struct xmit_priv *pxmitpriv, int status)
2559 struct submit_ctx *pack_tx_ops = &pxmitpriv->ack_tx_ops;
2561 if (pxmitpriv->ack_tx)
2562 rtw_sctx_done_err(&pack_tx_ops, status);