1 /******************************************************************************
3 * Copyright(c) 2007 - 2012 Realtek Corporation. All rights reserved.
5 * This program is free software; you can redistribute it and/or modify it
6 * under the terms of version 2 of the GNU General Public License as
7 * published by the Free Software Foundation.
9 * This program is distributed in the hope that it will be useful, but WITHOUT
10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
14 * You should have received a copy of the GNU General Public License along with
15 * this program; if not, write to the Free Software Foundation, Inc.,
16 * 51 Franklin Street, Fifth Floor, Boston, MA 02110, USA
19 ******************************************************************************/
22 #include <osdep_service.h>
23 #include <drv_types.h>
26 #include <osdep_intf.h>
27 #include <linux/vmalloc.h>
29 static u8 P802_1H_OUI
[P80211_OUI_LEN
] = { 0x00, 0x00, 0xf8 };
30 static u8 RFC1042_OUI
[P80211_OUI_LEN
] = { 0x00, 0x00, 0x00 };
32 static void _init_txservq(struct tx_servq
*ptxservq
)
34 INIT_LIST_HEAD(&ptxservq
->tx_pending
);
35 _rtw_init_queue(&ptxservq
->sta_pending
);
39 void _rtw_init_sta_xmit_priv(struct sta_xmit_priv
*psta_xmitpriv
)
41 memset((unsigned char *)psta_xmitpriv
, 0, sizeof(struct sta_xmit_priv
));
42 spin_lock_init(&psta_xmitpriv
->lock
);
43 _init_txservq(&psta_xmitpriv
->be_q
);
44 _init_txservq(&psta_xmitpriv
->bk_q
);
45 _init_txservq(&psta_xmitpriv
->vi_q
);
46 _init_txservq(&psta_xmitpriv
->vo_q
);
47 INIT_LIST_HEAD(&psta_xmitpriv
->legacy_dz
);
48 INIT_LIST_HEAD(&psta_xmitpriv
->apsd
);
52 s32
_rtw_init_xmit_priv(struct xmit_priv
*pxmitpriv
, struct adapter
*padapter
)
55 struct xmit_buf
*pxmitbuf
;
56 struct xmit_frame
*pxframe
;
58 u32 max_xmit_extbuf_size
= MAX_XMIT_EXTBUF_SZ
;
59 u32 num_xmit_extbuf
= NR_XMIT_EXTBUFF
;
62 /* We don't need to memset padapter->XXX to zero, because adapter is allocated by vzalloc(). */
64 spin_lock_init(&pxmitpriv
->lock
);
65 sema_init(&pxmitpriv
->xmit_sema
, 0);
66 sema_init(&pxmitpriv
->terminate_xmitthread_sema
, 0);
69 Please insert all the queue initializaiton using _rtw_init_queue below
72 pxmitpriv
->adapter
= padapter
;
74 _rtw_init_queue(&pxmitpriv
->be_pending
);
75 _rtw_init_queue(&pxmitpriv
->bk_pending
);
76 _rtw_init_queue(&pxmitpriv
->vi_pending
);
77 _rtw_init_queue(&pxmitpriv
->vo_pending
);
78 _rtw_init_queue(&pxmitpriv
->bm_pending
);
80 _rtw_init_queue(&pxmitpriv
->free_xmit_queue
);
83 Please allocate memory with the sz = (struct xmit_frame) * NR_XMITFRAME,
84 and initialize free_xmit_frame below.
85 Please also apply free_txobj to link_up all the xmit_frames...
88 pxmitpriv
->pallocated_frame_buf
= vzalloc(NR_XMITFRAME
* sizeof(struct xmit_frame
) + 4);
90 if (pxmitpriv
->pallocated_frame_buf
== NULL
) {
91 pxmitpriv
->pxmit_frame_buf
= NULL
;
92 RT_TRACE(_module_rtl871x_xmit_c_
, _drv_err_
, ("alloc xmit_frame fail!\n"));
96 pxmitpriv
->pxmit_frame_buf
= (u8
*)N_BYTE_ALIGMENT((size_t)(pxmitpriv
->pallocated_frame_buf
), 4);
97 /* pxmitpriv->pxmit_frame_buf = pxmitpriv->pallocated_frame_buf + 4 - */
98 /* ((size_t) (pxmitpriv->pallocated_frame_buf) &3); */
100 pxframe
= (struct xmit_frame
*)pxmitpriv
->pxmit_frame_buf
;
102 for (i
= 0; i
< NR_XMITFRAME
; i
++) {
103 INIT_LIST_HEAD(&(pxframe
->list
));
105 pxframe
->padapter
= padapter
;
106 pxframe
->frame_tag
= NULL_FRAMETAG
;
110 pxframe
->buf_addr
= NULL
;
111 pxframe
->pxmitbuf
= NULL
;
113 list_add_tail(&(pxframe
->list
), &(pxmitpriv
->free_xmit_queue
.queue
));
118 pxmitpriv
->free_xmitframe_cnt
= NR_XMITFRAME
;
120 pxmitpriv
->frag_len
= MAX_FRAG_THRESHOLD
;
123 _rtw_init_queue(&pxmitpriv
->free_xmitbuf_queue
);
124 _rtw_init_queue(&pxmitpriv
->pending_xmitbuf_queue
);
126 pxmitpriv
->pallocated_xmitbuf
= vzalloc(NR_XMITBUFF
* sizeof(struct xmit_buf
) + 4);
128 if (pxmitpriv
->pallocated_xmitbuf
== NULL
) {
129 RT_TRACE(_module_rtl871x_xmit_c_
, _drv_err_
, ("alloc xmit_buf fail!\n"));
134 pxmitpriv
->pxmitbuf
= (u8
*)N_BYTE_ALIGMENT((size_t)(pxmitpriv
->pallocated_xmitbuf
), 4);
135 /* pxmitpriv->pxmitbuf = pxmitpriv->pallocated_xmitbuf + 4 - */
136 /* ((size_t) (pxmitpriv->pallocated_xmitbuf) &3); */
138 pxmitbuf
= (struct xmit_buf
*)pxmitpriv
->pxmitbuf
;
140 for (i
= 0; i
< NR_XMITBUFF
; i
++) {
141 INIT_LIST_HEAD(&pxmitbuf
->list
);
143 pxmitbuf
->priv_data
= NULL
;
144 pxmitbuf
->padapter
= padapter
;
145 pxmitbuf
->ext_tag
= false;
147 /* Tx buf allocation may fail sometimes, so sleep and retry. */
148 res
= rtw_os_xmit_resource_alloc(padapter
, pxmitbuf
, (MAX_XMITBUF_SZ
+ XMITBUF_ALIGN_SZ
));
151 res
= rtw_os_xmit_resource_alloc(padapter
, pxmitbuf
, (MAX_XMITBUF_SZ
+ XMITBUF_ALIGN_SZ
));
157 pxmitbuf
->flags
= XMIT_VO_QUEUE
;
159 list_add_tail(&pxmitbuf
->list
, &(pxmitpriv
->free_xmitbuf_queue
.queue
));
163 pxmitpriv
->free_xmitbuf_cnt
= NR_XMITBUFF
;
165 /* Init xmit extension buff */
166 _rtw_init_queue(&pxmitpriv
->free_xmit_extbuf_queue
);
168 pxmitpriv
->pallocated_xmit_extbuf
= vzalloc(num_xmit_extbuf
* sizeof(struct xmit_buf
) + 4);
170 if (pxmitpriv
->pallocated_xmit_extbuf
== NULL
) {
171 RT_TRACE(_module_rtl871x_xmit_c_
, _drv_err_
, ("alloc xmit_extbuf fail!\n"));
176 pxmitpriv
->pxmit_extbuf
= (u8
*)N_BYTE_ALIGMENT((size_t)(pxmitpriv
->pallocated_xmit_extbuf
), 4);
178 pxmitbuf
= (struct xmit_buf
*)pxmitpriv
->pxmit_extbuf
;
180 for (i
= 0; i
< num_xmit_extbuf
; i
++) {
181 INIT_LIST_HEAD(&pxmitbuf
->list
);
183 pxmitbuf
->priv_data
= NULL
;
184 pxmitbuf
->padapter
= padapter
;
185 pxmitbuf
->ext_tag
= true;
187 res
= rtw_os_xmit_resource_alloc(padapter
, pxmitbuf
, max_xmit_extbuf_size
+ XMITBUF_ALIGN_SZ
);
193 list_add_tail(&pxmitbuf
->list
, &(pxmitpriv
->free_xmit_extbuf_queue
.queue
));
197 pxmitpriv
->free_xmit_extbuf_cnt
= num_xmit_extbuf
;
199 rtw_alloc_hwxmits(padapter
);
200 rtw_init_hwxmits(pxmitpriv
->hwxmits
, pxmitpriv
->hwxmit_entry
);
202 for (i
= 0; i
< 4; i
++)
203 pxmitpriv
->wmm_para_seq
[i
] = i
;
205 pxmitpriv
->txirp_cnt
= 1;
207 sema_init(&(pxmitpriv
->tx_retevt
), 0);
209 /* per AC pending irp */
210 pxmitpriv
->beq_cnt
= 0;
211 pxmitpriv
->bkq_cnt
= 0;
212 pxmitpriv
->viq_cnt
= 0;
213 pxmitpriv
->voq_cnt
= 0;
215 pxmitpriv
->ack_tx
= false;
216 mutex_init(&pxmitpriv
->ack_tx_mutex
);
217 rtw_sctx_init(&pxmitpriv
->ack_tx_ops
, 0);
219 rtw_hal_init_xmit_priv(padapter
);
227 void _rtw_free_xmit_priv(struct xmit_priv
*pxmitpriv
)
230 struct adapter
*padapter
= pxmitpriv
->adapter
;
231 struct xmit_frame
*pxmitframe
= (struct xmit_frame
*)pxmitpriv
->pxmit_frame_buf
;
232 struct xmit_buf
*pxmitbuf
= (struct xmit_buf
*)pxmitpriv
->pxmitbuf
;
233 u32 max_xmit_extbuf_size
= MAX_XMIT_EXTBUF_SZ
;
234 u32 num_xmit_extbuf
= NR_XMIT_EXTBUFF
;
236 if (pxmitpriv
->pxmit_frame_buf
== NULL
)
239 for (i
= 0; i
< NR_XMITFRAME
; i
++) {
240 rtw_os_xmit_complete(padapter
, pxmitframe
);
245 for (i
= 0; i
< NR_XMITBUFF
; i
++) {
246 rtw_os_xmit_resource_free(padapter
, pxmitbuf
, (MAX_XMITBUF_SZ
+ XMITBUF_ALIGN_SZ
));
250 vfree(pxmitpriv
->pallocated_frame_buf
);
251 vfree(pxmitpriv
->pallocated_xmitbuf
);
253 /* free xmit extension buff */
254 pxmitbuf
= (struct xmit_buf
*)pxmitpriv
->pxmit_extbuf
;
255 for (i
= 0; i
< num_xmit_extbuf
; i
++) {
256 rtw_os_xmit_resource_free(padapter
, pxmitbuf
, (max_xmit_extbuf_size
+ XMITBUF_ALIGN_SZ
));
260 if (pxmitpriv
->pallocated_xmit_extbuf
) {
261 vfree(pxmitpriv
->pallocated_xmit_extbuf
);
264 rtw_free_hwxmits(padapter
);
266 mutex_destroy(&pxmitpriv
->ack_tx_mutex
);
269 static void update_attrib_vcs_info(struct adapter
*padapter
, struct xmit_frame
*pxmitframe
)
272 struct pkt_attrib
*pattrib
= &pxmitframe
->attrib
;
273 struct sta_info
*psta
= pattrib
->psta
;
274 struct mlme_ext_priv
*pmlmeext
= &(padapter
->mlmeextpriv
);
275 struct mlme_ext_info
*pmlmeinfo
= &(pmlmeext
->mlmext_info
);
277 if (pattrib
->nr_frags
!= 1)
278 sz
= padapter
->xmitpriv
.frag_len
;
280 sz
= pattrib
->last_txcmdsz
;
282 /* (1) RTS_Threshold is compared to the MPDU, not MSDU. */
283 /* (2) If there are more than one frag in this MSDU, only the first frag uses protection frame. */
284 /* Other fragments are protected by previous fragment. */
285 /* So we only need to check the length of first fragment. */
286 if (pmlmeext
->cur_wireless_mode
< WIRELESS_11_24N
|| padapter
->registrypriv
.wifi_spec
) {
287 if (sz
> padapter
->registrypriv
.rts_thresh
) {
288 pattrib
->vcs_mode
= RTS_CTS
;
291 pattrib
->vcs_mode
= RTS_CTS
;
292 else if (psta
->cts2self
)
293 pattrib
->vcs_mode
= CTS_TO_SELF
;
295 pattrib
->vcs_mode
= NONE_VCS
;
300 if ((pmlmeinfo
->assoc_AP_vendor
== HT_IOT_PEER_ATHEROS
) && pattrib
->ampdu_en
&&
301 (padapter
->securitypriv
.dot11PrivacyAlgrthm
== _AES_
)) {
302 pattrib
->vcs_mode
= CTS_TO_SELF
;
306 /* check ERP protection */
307 if (psta
->rtsen
|| psta
->cts2self
) {
309 pattrib
->vcs_mode
= RTS_CTS
;
310 else if (psta
->cts2self
)
311 pattrib
->vcs_mode
= CTS_TO_SELF
;
316 /* check HT op mode */
317 if (pattrib
->ht_en
) {
318 u8 htopmode
= pmlmeinfo
->HT_protection
;
319 if ((pmlmeext
->cur_bwmode
&& (htopmode
== 2 || htopmode
== 3)) ||
320 (!pmlmeext
->cur_bwmode
&& htopmode
== 3)) {
321 pattrib
->vcs_mode
= RTS_CTS
;
327 if (sz
> padapter
->registrypriv
.rts_thresh
) {
328 pattrib
->vcs_mode
= RTS_CTS
;
332 /* to do list: check MIMO power save condition. */
334 /* check AMPDU aggregation for TXOP */
335 if (pattrib
->ampdu_en
) {
336 pattrib
->vcs_mode
= RTS_CTS
;
340 pattrib
->vcs_mode
= NONE_VCS
;
346 static void update_attrib_phy_info(struct pkt_attrib
*pattrib
, struct sta_info
*psta
)
349 pattrib->vcs_mode = RTS_CTS;
350 else if (psta->cts2self)
351 pattrib->vcs_mode = CTS_TO_SELF;
353 pattrib->vcs_mode = NONE_VCS;*/
357 pattrib
->triggered
= 0;
359 /* qos_en, ht_en, init rate, , bw, ch_offset, sgi */
360 pattrib
->qos_en
= psta
->qos_option
;
362 pattrib
->raid
= psta
->raid
;
363 pattrib
->ht_en
= psta
->htpriv
.ht_option
;
364 pattrib
->bwmode
= psta
->htpriv
.bwmode
;
365 pattrib
->ch_offset
= psta
->htpriv
.ch_offset
;
366 pattrib
->sgi
= psta
->htpriv
.sgi
;
367 pattrib
->ampdu_en
= false;
368 pattrib
->retry_ctrl
= false;
371 u8
qos_acm(u8 acm_mask
, u8 priority
)
373 u8 change_priority
= priority
;
378 if (acm_mask
& BIT(1))
386 if (acm_mask
& BIT(2))
391 if (acm_mask
& BIT(3))
395 DBG_88E("qos_acm(): invalid pattrib->priority: %d!!!\n", priority
);
399 return change_priority
;
402 static void set_qos(struct pkt_file
*ppktfile
, struct pkt_attrib
*pattrib
)
404 struct ethhdr etherhdr
;
408 _rtw_open_pktfile(ppktfile
->pkt
, ppktfile
);
409 _rtw_pktfile_read(ppktfile
, (unsigned char *)ðerhdr
, ETH_HLEN
);
411 /* get user_prio from IP hdr */
412 if (pattrib
->ether_type
== 0x0800) {
413 _rtw_pktfile_read(ppktfile
, (u8
*)&ip_hdr
, sizeof(ip_hdr
));
414 /* user_prio = (ntohs(ip_hdr.tos) >> 5) & 0x3; */
415 user_prio
= ip_hdr
.tos
>> 5;
416 } else if (pattrib
->ether_type
== 0x888e) {
417 /* "When priority processing of data frames is supported, */
418 /* a STA's SME should send EAPOL-Key frames at the highest priority." */
422 pattrib
->priority
= user_prio
;
423 pattrib
->hdrlen
= WLAN_HDR_A3_QOS_LEN
;
424 pattrib
->subtype
= WIFI_QOS_DATA_TYPE
;
427 static s32
update_attrib(struct adapter
*padapter
, struct sk_buff
*pkt
, struct pkt_attrib
*pattrib
)
429 struct pkt_file pktfile
;
430 struct sta_info
*psta
= NULL
;
431 struct ethhdr etherhdr
;
434 struct sta_priv
*pstapriv
= &padapter
->stapriv
;
435 struct security_priv
*psecuritypriv
= &padapter
->securitypriv
;
436 struct mlme_priv
*pmlmepriv
= &padapter
->mlmepriv
;
437 struct qos_priv
*pqospriv
= &pmlmepriv
->qospriv
;
441 _rtw_open_pktfile(pkt
, &pktfile
);
442 _rtw_pktfile_read(&pktfile
, (u8
*)ðerhdr
, ETH_HLEN
);
444 pattrib
->ether_type
= ntohs(etherhdr
.h_proto
);
446 memcpy(pattrib
->dst
, ðerhdr
.h_dest
, ETH_ALEN
);
447 memcpy(pattrib
->src
, ðerhdr
.h_source
, ETH_ALEN
);
451 if (check_fwstate(pmlmepriv
, WIFI_ADHOC_STATE
) ||
452 check_fwstate(pmlmepriv
, WIFI_ADHOC_MASTER_STATE
)) {
453 memcpy(pattrib
->ra
, pattrib
->dst
, ETH_ALEN
);
454 memcpy(pattrib
->ta
, pattrib
->src
, ETH_ALEN
);
455 } else if (check_fwstate(pmlmepriv
, WIFI_STATION_STATE
)) {
456 memcpy(pattrib
->ra
, get_bssid(pmlmepriv
), ETH_ALEN
);
457 memcpy(pattrib
->ta
, pattrib
->src
, ETH_ALEN
);
458 } else if (check_fwstate(pmlmepriv
, WIFI_AP_STATE
)) {
459 memcpy(pattrib
->ra
, pattrib
->dst
, ETH_ALEN
);
460 memcpy(pattrib
->ta
, get_bssid(pmlmepriv
), ETH_ALEN
);
463 pattrib
->pktlen
= pktfile
.pkt_len
;
465 if (ETH_P_IP
== pattrib
->ether_type
) {
466 /* The following is for DHCP and ARP packet, we use cck1M to tx these packets and let LPS awake some time */
467 /* to prevent DHCP protocol fail */
469 _rtw_pktfile_read(&pktfile
, &tmp
[0], 24);
470 pattrib
->dhcp_pkt
= 0;
471 if (pktfile
.pkt_len
> 282) {/* MINIMUM_DHCP_PACKET_SIZE) { */
472 if (ETH_P_IP
== pattrib
->ether_type
) {/* IP header */
473 if (((tmp
[21] == 68) && (tmp
[23] == 67)) ||
474 ((tmp
[21] == 67) && (tmp
[23] == 68))) {
475 /* 68 : UDP BOOTP client */
476 /* 67 : UDP BOOTP server */
477 RT_TRACE(_module_rtl871x_xmit_c_
, _drv_err_
, ("====================== update_attrib: get DHCP Packet\n"));
478 /* Use low rate to send DHCP packet. */
479 pattrib
->dhcp_pkt
= 1;
483 } else if (0x888e == pattrib
->ether_type
) {
484 DBG_88E_LEVEL(_drv_info_
, "send eapol packet\n");
487 if ((pattrib
->ether_type
== 0x888e) || (pattrib
->dhcp_pkt
== 1))
488 rtw_set_scan_deny(padapter
, 3000);
490 /* If EAPOL , ARP , OR DHCP packet, driver must be in active mode. */
491 if ((pattrib
->ether_type
== 0x0806) || (pattrib
->ether_type
== 0x888e) || (pattrib
->dhcp_pkt
== 1))
492 rtw_lps_ctrl_wk_cmd(padapter
, LPS_CTRL_SPECIAL_PACKET
, 1);
494 bmcast
= IS_MCAST(pattrib
->ra
);
498 psta
= rtw_get_bcmc_stainfo(padapter
);
500 psta
= rtw_get_stainfo(pstapriv
, pattrib
->ra
);
501 if (psta
== NULL
) { /* if we cannot get psta => drrp the pkt */
502 RT_TRACE(_module_rtl871x_xmit_c_
, _drv_alert_
, ("\nupdate_attrib => get sta_info fail, ra: %pM\n", (pattrib
->ra
)));
505 } else if ((check_fwstate(pmlmepriv
, WIFI_AP_STATE
) == true) && (!(psta
->state
& _FW_LINKED
))) {
512 pattrib
->mac_id
= psta
->mac_id
;
513 /* DBG_88E("%s ==> mac_id(%d)\n", __func__, pattrib->mac_id); */
514 pattrib
->psta
= psta
;
516 /* if we cannot get psta => drop the pkt */
517 RT_TRACE(_module_rtl871x_xmit_c_
, _drv_alert_
, ("\nupdate_attrib => get sta_info fail, ra:%pM\n", (pattrib
->ra
)));
522 pattrib
->ack_policy
= 0;
523 /* get ether_hdr_len */
524 pattrib
->pkt_hdrlen
= ETH_HLEN
;/* pattrib->ether_type == 0x8100) ? (14 + 4): 14; vlan tag */
526 pattrib
->hdrlen
= WLAN_HDR_A3_LEN
;
527 pattrib
->subtype
= WIFI_DATA_TYPE
;
528 pattrib
->priority
= 0;
530 if (check_fwstate(pmlmepriv
, WIFI_AP_STATE
|WIFI_ADHOC_STATE
|WIFI_ADHOC_MASTER_STATE
)) {
531 if (psta
->qos_option
)
532 set_qos(&pktfile
, pattrib
);
534 if (pqospriv
->qos_option
) {
535 set_qos(&pktfile
, pattrib
);
537 if (pmlmepriv
->acm_mask
!= 0)
538 pattrib
->priority
= qos_acm(pmlmepriv
->acm_mask
, pattrib
->priority
);
542 if (psta
->ieee8021x_blocked
) {
543 RT_TRACE(_module_rtl871x_xmit_c_
, _drv_err_
, ("\n psta->ieee8021x_blocked == true\n"));
545 pattrib
->encrypt
= 0;
547 if ((pattrib
->ether_type
!= 0x888e) && !check_fwstate(pmlmepriv
, WIFI_MP_STATE
)) {
548 RT_TRACE(_module_rtl871x_xmit_c_
, _drv_err_
, ("\npsta->ieee8021x_blocked == true, pattrib->ether_type(%.4x) != 0x888e\n", pattrib
->ether_type
));
553 GET_ENCRY_ALGO(psecuritypriv
, psta
, pattrib
->encrypt
, bmcast
);
555 switch (psecuritypriv
->dot11AuthAlgrthm
) {
556 case dot11AuthAlgrthm_Open
:
557 case dot11AuthAlgrthm_Shared
:
558 case dot11AuthAlgrthm_Auto
:
559 pattrib
->key_idx
= (u8
)psecuritypriv
->dot11PrivacyKeyIndex
;
561 case dot11AuthAlgrthm_8021X
:
563 pattrib
->key_idx
= (u8
)psecuritypriv
->dot118021XGrpKeyid
;
565 pattrib
->key_idx
= 0;
568 pattrib
->key_idx
= 0;
573 switch (pattrib
->encrypt
) {
577 pattrib
->icv_len
= 4;
581 pattrib
->icv_len
= 4;
583 if (padapter
->securitypriv
.busetkipkey
== _FAIL
) {
584 RT_TRACE(_module_rtl871x_xmit_c_
, _drv_err_
,
585 ("\npadapter->securitypriv.busetkipkey(%d) == _FAIL drop packet\n",
586 padapter
->securitypriv
.busetkipkey
));
592 RT_TRACE(_module_rtl871x_xmit_c_
, _drv_info_
, ("pattrib->encrypt=%d (_AES_)\n", pattrib
->encrypt
));
594 pattrib
->icv_len
= 8;
598 pattrib
->icv_len
= 0;
602 RT_TRACE(_module_rtl871x_xmit_c_
, _drv_info_
,
603 ("update_attrib: encrypt=%d securitypriv.sw_encrypt=%d\n",
604 pattrib
->encrypt
, padapter
->securitypriv
.sw_encrypt
));
606 if (pattrib
->encrypt
&&
607 (padapter
->securitypriv
.sw_encrypt
|| !psecuritypriv
->hw_decrypted
)) {
608 pattrib
->bswenc
= true;
609 RT_TRACE(_module_rtl871x_xmit_c_
, _drv_err_
,
610 ("update_attrib: encrypt=%d securitypriv.hw_decrypted=%d bswenc = true\n",
611 pattrib
->encrypt
, padapter
->securitypriv
.sw_encrypt
));
613 pattrib
->bswenc
= false;
614 RT_TRACE(_module_rtl871x_xmit_c_
, _drv_info_
, ("update_attrib: bswenc = false\n"));
617 update_attrib_phy_info(pattrib
, psta
);
625 static s32
xmitframe_addmic(struct adapter
*padapter
, struct xmit_frame
*pxmitframe
)
627 int curfragnum
, length
;
628 u8
*pframe
, *payload
, mic
[8];
629 struct mic_data micdata
;
630 struct sta_info
*stainfo
;
631 struct pkt_attrib
*pattrib
= &pxmitframe
->attrib
;
632 struct security_priv
*psecuritypriv
= &padapter
->securitypriv
;
633 struct xmit_priv
*pxmitpriv
= &padapter
->xmitpriv
;
634 u8 priority
[4] = {0x0, 0x0, 0x0, 0x0};
635 u8 hw_hdr_offset
= 0;
636 int bmcst
= IS_MCAST(pattrib
->ra
);
639 stainfo
= pattrib
->psta
;
641 stainfo
= rtw_get_stainfo(&padapter
->stapriv
, &pattrib
->ra
[0]);
644 hw_hdr_offset
= TXDESC_SIZE
+ (pxmitframe
->pkt_offset
* PACKET_OFFSET_SZ
);
646 if (pattrib
->encrypt
== _TKIP_
) {/* if (psecuritypriv->dot11PrivacyAlgrthm == _TKIP_PRIVACY_) */
647 /* encode mic code */
648 if (stainfo
!= NULL
) {
649 u8 null_key
[16] = {0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
650 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
653 pframe
= pxmitframe
->buf_addr
+ hw_hdr_offset
;
656 if (!memcmp(psecuritypriv
->dot118021XGrptxmickey
[psecuritypriv
->dot118021XGrpKeyid
].skey
, null_key
, 16))
658 /* start to calculate the mic code */
659 rtw_secmicsetkey(&micdata
, psecuritypriv
->dot118021XGrptxmickey
[psecuritypriv
->dot118021XGrpKeyid
].skey
);
661 if (!memcmp(&stainfo
->dot11tkiptxmickey
.skey
[0], null_key
, 16)) {
662 /* DbgPrint("\nxmitframe_addmic:stainfo->dot11tkiptxmickey == 0\n"); */
666 /* start to calculate the mic code */
667 rtw_secmicsetkey(&micdata
, &stainfo
->dot11tkiptxmickey
.skey
[0]);
670 if (pframe
[1]&1) { /* ToDS == 1 */
671 rtw_secmicappend(&micdata
, &pframe
[16], 6); /* DA */
672 if (pframe
[1]&2) /* From Ds == 1 */
673 rtw_secmicappend(&micdata
, &pframe
[24], 6);
675 rtw_secmicappend(&micdata
, &pframe
[10], 6);
676 } else { /* ToDS == 0 */
677 rtw_secmicappend(&micdata
, &pframe
[4], 6); /* DA */
678 if (pframe
[1]&2) /* From Ds == 1 */
679 rtw_secmicappend(&micdata
, &pframe
[16], 6);
681 rtw_secmicappend(&micdata
, &pframe
[10], 6);
685 priority
[0] = (u8
)pxmitframe
->attrib
.priority
;
687 rtw_secmicappend(&micdata
, &priority
[0], 4);
691 for (curfragnum
= 0; curfragnum
< pattrib
->nr_frags
; curfragnum
++) {
692 payload
= (u8
*)round_up((size_t)(payload
), 4);
693 RT_TRACE(_module_rtl871x_xmit_c_
, _drv_err_
,
694 ("=== curfragnum=%d, pframe = 0x%.2x, 0x%.2x, 0x%.2x, 0x%.2x, 0x%.2x, 0x%.2x, 0x%.2x, 0x%.2x,!!!\n",
695 curfragnum
, *payload
, *(payload
+1),
696 *(payload
+2), *(payload
+3),
697 *(payload
+4), *(payload
+5),
698 *(payload
+6), *(payload
+7)));
700 payload
= payload
+pattrib
->hdrlen
+pattrib
->iv_len
;
701 RT_TRACE(_module_rtl871x_xmit_c_
, _drv_err_
,
702 ("curfragnum=%d pattrib->hdrlen=%d pattrib->iv_len=%d",
703 curfragnum
, pattrib
->hdrlen
, pattrib
->iv_len
));
704 if ((curfragnum
+1) == pattrib
->nr_frags
) {
705 length
= pattrib
->last_txcmdsz
-pattrib
->hdrlen
-pattrib
->iv_len
-((pattrib
->bswenc
) ? pattrib
->icv_len
: 0);
706 rtw_secmicappend(&micdata
, payload
, length
);
707 payload
= payload
+length
;
709 length
= pxmitpriv
->frag_len
-pattrib
->hdrlen
-pattrib
->iv_len
-((pattrib
->bswenc
) ? pattrib
->icv_len
: 0);
710 rtw_secmicappend(&micdata
, payload
, length
);
711 payload
= payload
+length
+pattrib
->icv_len
;
712 RT_TRACE(_module_rtl871x_xmit_c_
, _drv_err_
, ("curfragnum=%d length=%d pattrib->icv_len=%d", curfragnum
, length
, pattrib
->icv_len
));
715 rtw_secgetmic(&micdata
, &(mic
[0]));
716 RT_TRACE(_module_rtl871x_xmit_c_
, _drv_err_
, ("xmitframe_addmic: before add mic code!!!\n"));
717 RT_TRACE(_module_rtl871x_xmit_c_
, _drv_err_
, ("xmitframe_addmic: pattrib->last_txcmdsz=%d!!!\n", pattrib
->last_txcmdsz
));
718 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\
719 mic[4]= 0x%.2x , mic[5]= 0x%.2x , mic[6]= 0x%.2x , mic[7]= 0x%.2x !!!!\n",
720 mic
[0], mic
[1], mic
[2], mic
[3], mic
[4], mic
[5], mic
[6], mic
[7]));
721 /* add mic code and add the mic code length in last_txcmdsz */
723 memcpy(payload
, &(mic
[0]), 8);
724 pattrib
->last_txcmdsz
+= 8;
726 RT_TRACE(_module_rtl871x_xmit_c_
, _drv_info_
, ("\n ======== last pkt ========\n"));
727 payload
= payload
-pattrib
->last_txcmdsz
+8;
728 for (curfragnum
= 0; curfragnum
< pattrib
->last_txcmdsz
; curfragnum
= curfragnum
+8)
729 RT_TRACE(_module_rtl871x_xmit_c_
, _drv_info_
,
730 (" %.2x, %.2x, %.2x, %.2x, %.2x, %.2x, %.2x, %.2x ",
731 *(payload
+curfragnum
), *(payload
+curfragnum
+1),
732 *(payload
+curfragnum
+2), *(payload
+curfragnum
+3),
733 *(payload
+curfragnum
+4), *(payload
+curfragnum
+5),
734 *(payload
+curfragnum
+6), *(payload
+curfragnum
+7)));
736 RT_TRACE(_module_rtl871x_xmit_c_
, _drv_err_
, ("xmitframe_addmic: rtw_get_stainfo==NULL!!!\n"));
744 static s32
xmitframe_swencrypt(struct adapter
*padapter
, struct xmit_frame
*pxmitframe
)
746 struct pkt_attrib
*pattrib
= &pxmitframe
->attrib
;
749 if (pattrib
->bswenc
) {
750 RT_TRACE(_module_rtl871x_xmit_c_
, _drv_alert_
, ("### xmitframe_swencrypt\n"));
751 switch (pattrib
->encrypt
) {
754 rtw_wep_encrypt(padapter
, (u8
*)pxmitframe
);
757 rtw_tkip_encrypt(padapter
, (u8
*)pxmitframe
);
760 rtw_aes_encrypt(padapter
, (u8
*)pxmitframe
);
766 RT_TRACE(_module_rtl871x_xmit_c_
, _drv_notice_
, ("### xmitframe_hwencrypt\n"));
773 s32
rtw_make_wlanhdr(struct adapter
*padapter
, u8
*hdr
, struct pkt_attrib
*pattrib
)
777 struct rtw_ieee80211_hdr
*pwlanhdr
= (struct rtw_ieee80211_hdr
*)hdr
;
778 struct mlme_priv
*pmlmepriv
= &padapter
->mlmepriv
;
779 struct qos_priv
*pqospriv
= &pmlmepriv
->qospriv
;
780 u8 qos_option
= false;
783 __le16
*fctrl
= &pwlanhdr
->frame_ctl
;
785 struct sta_info
*psta
;
787 int bmcst
= IS_MCAST(pattrib
->ra
);
791 psta
= pattrib
->psta
;
794 psta
= rtw_get_bcmc_stainfo(padapter
);
796 psta
= rtw_get_stainfo(&padapter
->stapriv
, pattrib
->ra
);
800 memset(hdr
, 0, WLANHDR_OFFSET
);
802 SetFrameSubType(fctrl
, pattrib
->subtype
);
804 if (pattrib
->subtype
& WIFI_DATA_TYPE
) {
805 if ((check_fwstate(pmlmepriv
, WIFI_STATION_STATE
) == true)) {
806 /* to_ds = 1, fr_ds = 0; */
807 /* Data transfer to AP */
809 memcpy(pwlanhdr
->addr1
, get_bssid(pmlmepriv
), ETH_ALEN
);
810 memcpy(pwlanhdr
->addr2
, pattrib
->src
, ETH_ALEN
);
811 memcpy(pwlanhdr
->addr3
, pattrib
->dst
, ETH_ALEN
);
813 if (pqospriv
->qos_option
)
815 } else if (check_fwstate(pmlmepriv
, WIFI_AP_STATE
)) {
816 /* to_ds = 0, fr_ds = 1; */
818 memcpy(pwlanhdr
->addr1
, pattrib
->dst
, ETH_ALEN
);
819 memcpy(pwlanhdr
->addr2
, get_bssid(pmlmepriv
), ETH_ALEN
);
820 memcpy(pwlanhdr
->addr3
, pattrib
->src
, ETH_ALEN
);
822 if (psta
->qos_option
)
824 } else if (check_fwstate(pmlmepriv
, WIFI_ADHOC_STATE
) ||
825 check_fwstate(pmlmepriv
, WIFI_ADHOC_MASTER_STATE
)) {
826 memcpy(pwlanhdr
->addr1
, pattrib
->dst
, ETH_ALEN
);
827 memcpy(pwlanhdr
->addr2
, pattrib
->src
, ETH_ALEN
);
828 memcpy(pwlanhdr
->addr3
, get_bssid(pmlmepriv
), ETH_ALEN
);
830 if (psta
->qos_option
)
833 RT_TRACE(_module_rtl871x_xmit_c_
, _drv_err_
, ("fw_state:%x is not allowed to xmit frame\n", get_fwstate(pmlmepriv
)));
841 if (pattrib
->encrypt
)
845 qc
= (unsigned short *)(hdr
+ pattrib
->hdrlen
- 2);
847 if (pattrib
->priority
)
848 SetPriority(qc
, pattrib
->priority
);
850 SetEOSP(qc
, pattrib
->eosp
);
852 SetAckpolicy(qc
, pattrib
->ack_policy
);
855 /* TODO: fill HT Control Field */
857 /* Update Seq Num will be handled by f/w */
859 psta
->sta_xmitpriv
.txseq_tid
[pattrib
->priority
]++;
860 psta
->sta_xmitpriv
.txseq_tid
[pattrib
->priority
] &= 0xFFF;
862 pattrib
->seqnum
= psta
->sta_xmitpriv
.txseq_tid
[pattrib
->priority
];
864 SetSeqNum(hdr
, pattrib
->seqnum
);
866 /* check if enable ampdu */
867 if (pattrib
->ht_en
&& psta
->htpriv
.ampdu_enable
) {
868 if (psta
->htpriv
.agg_enable_bitmap
& BIT(pattrib
->priority
))
869 pattrib
->ampdu_en
= true;
872 /* re-check if enable ampdu by BA_starting_seqctrl */
873 if (pattrib
->ampdu_en
) {
876 tx_seq
= psta
->BA_starting_seqctrl
[pattrib
->priority
& 0x0f];
878 /* check BA_starting_seqctrl */
879 if (SN_LESS(pattrib
->seqnum
, tx_seq
)) {
880 pattrib
->ampdu_en
= false;/* AGG BK */
881 } else if (SN_EQUAL(pattrib
->seqnum
, tx_seq
)) {
882 psta
->BA_starting_seqctrl
[pattrib
->priority
& 0x0f] = (tx_seq
+1)&0xfff;
884 pattrib
->ampdu_en
= true;/* AGG EN */
886 psta
->BA_starting_seqctrl
[pattrib
->priority
& 0x0f] = (pattrib
->seqnum
+1)&0xfff;
887 pattrib
->ampdu_en
= true;/* AGG EN */
897 s32
rtw_txframes_pending(struct adapter
*padapter
)
899 struct xmit_priv
*pxmitpriv
= &padapter
->xmitpriv
;
901 return (!list_empty(&pxmitpriv
->be_pending
.queue
) ||
902 !list_empty(&pxmitpriv
->bk_pending
.queue
) ||
903 !list_empty(&pxmitpriv
->vi_pending
.queue
) ||
904 !list_empty(&pxmitpriv
->vo_pending
.queue
));
907 s32
rtw_txframes_sta_ac_pending(struct adapter
*padapter
, struct pkt_attrib
*pattrib
)
909 struct sta_info
*psta
;
910 struct tx_servq
*ptxservq
;
911 int priority
= pattrib
->priority
;
913 psta
= pattrib
->psta
;
918 ptxservq
= &(psta
->sta_xmitpriv
.bk_q
);
922 ptxservq
= &(psta
->sta_xmitpriv
.vi_q
);
926 ptxservq
= &(psta
->sta_xmitpriv
.vo_q
);
931 ptxservq
= &(psta
->sta_xmitpriv
.be_q
);
935 return ptxservq
->qcnt
;
939 * Calculate wlan 802.11 packet MAX size from pkt_attrib
940 * This function doesn't consider fragment case
942 u32
rtw_calculate_wlan_pkt_size_by_attribue(struct pkt_attrib
*pattrib
)
946 len
= pattrib
->hdrlen
+ pattrib
->iv_len
; /* WLAN Header and IV */
947 len
+= SNAP_SIZE
+ sizeof(u16
); /* LLC */
948 len
+= pattrib
->pktlen
;
949 if (pattrib
->encrypt
== _TKIP_
)
951 len
+= ((pattrib
->bswenc
) ? pattrib
->icv_len
: 0); /* ICV */
958 This sub-routine will perform all the following:
960 1. remove 802.3 header.
961 2. create wlan_header, based on the info in pxmitframe
962 3. append sta's iv/ext-iv
964 5. move frag chunk from pframe to pxmitframe->mem
965 6. apply sw-encrypt, if necessary.
968 s32
rtw_xmitframe_coalesce(struct adapter
*padapter
, struct sk_buff
*pkt
, struct xmit_frame
*pxmitframe
)
970 struct pkt_file pktfile
;
971 s32 frg_inx
, frg_len
, mpdu_len
, llc_sz
, mem_sz
;
973 u8
*pframe
, *mem_start
;
975 struct sta_info
*psta
;
976 struct xmit_priv
*pxmitpriv
= &padapter
->xmitpriv
;
977 struct pkt_attrib
*pattrib
= &pxmitframe
->attrib
;
979 s32 bmcst
= IS_MCAST(pattrib
->ra
);
983 psta
= rtw_get_stainfo(&padapter
->stapriv
, pattrib
->ra
);
988 if (pxmitframe
->buf_addr
== NULL
) {
989 DBG_88E("==> %s buf_addr == NULL\n", __func__
);
993 pbuf_start
= pxmitframe
->buf_addr
;
995 hw_hdr_offset
= TXDESC_SIZE
+ (pxmitframe
->pkt_offset
* PACKET_OFFSET_SZ
);
997 mem_start
= pbuf_start
+ hw_hdr_offset
;
999 if (rtw_make_wlanhdr(padapter
, mem_start
, pattrib
) == _FAIL
) {
1000 RT_TRACE(_module_rtl871x_xmit_c_
, _drv_err_
, ("rtw_xmitframe_coalesce: rtw_make_wlanhdr fail; drop pkt\n"));
1001 DBG_88E("rtw_xmitframe_coalesce: rtw_make_wlanhdr fail; drop pkt\n");
1006 _rtw_open_pktfile(pkt
, &pktfile
);
1007 _rtw_pktfile_read(&pktfile
, NULL
, pattrib
->pkt_hdrlen
);
1010 frg_len
= pxmitpriv
->frag_len
- 4;/* 2346-4 = 2342 */
1019 SetMFrag(mem_start
);
1021 pframe
+= pattrib
->hdrlen
;
1022 mpdu_len
-= pattrib
->hdrlen
;
1024 /* adding icv, if necessary... */
1025 if (pattrib
->iv_len
) {
1026 switch (pattrib
->encrypt
) {
1029 WEP_IV(pattrib
->iv
, psta
->dot11txpn
, pattrib
->key_idx
);
1033 TKIP_IV(pattrib
->iv
, psta
->dot11txpn
, pattrib
->key_idx
);
1035 TKIP_IV(pattrib
->iv
, psta
->dot11txpn
, 0);
1039 AES_IV(pattrib
->iv
, psta
->dot11txpn
, pattrib
->key_idx
);
1041 AES_IV(pattrib
->iv
, psta
->dot11txpn
, 0);
1045 memcpy(pframe
, pattrib
->iv
, pattrib
->iv_len
);
1047 RT_TRACE(_module_rtl871x_xmit_c_
, _drv_notice_
,
1048 ("rtw_xmitframe_coalesce: keyid=%d pattrib->iv[3]=%.2x pframe=%.2x %.2x %.2x %.2x\n",
1049 padapter
->securitypriv
.dot11PrivacyKeyIndex
, pattrib
->iv
[3], *pframe
, *(pframe
+1), *(pframe
+2), *(pframe
+3)));
1051 pframe
+= pattrib
->iv_len
;
1053 mpdu_len
-= pattrib
->iv_len
;
1057 llc_sz
= rtw_put_snap(pframe
, pattrib
->ether_type
);
1062 if ((pattrib
->icv_len
> 0) && (pattrib
->bswenc
)) {
1063 mpdu_len
-= pattrib
->icv_len
;
1067 /* don't do fragment to broadcat/multicast packets */
1068 mem_sz
= _rtw_pktfile_read(&pktfile
, pframe
, pattrib
->pktlen
);
1070 mem_sz
= _rtw_pktfile_read(&pktfile
, pframe
, mpdu_len
);
1075 if ((pattrib
->icv_len
> 0) && (pattrib
->bswenc
)) {
1076 memcpy(pframe
, pattrib
->icv
, pattrib
->icv_len
);
1077 pframe
+= pattrib
->icv_len
;
1082 if (bmcst
|| rtw_endofpktfile(&pktfile
)) {
1083 pattrib
->nr_frags
= frg_inx
;
1085 pattrib
->last_txcmdsz
= pattrib
->hdrlen
+ pattrib
->iv_len
+ ((pattrib
->nr_frags
== 1) ? llc_sz
: 0) +
1086 ((pattrib
->bswenc
) ? pattrib
->icv_len
: 0) + mem_sz
;
1088 ClearMFrag(mem_start
);
1092 RT_TRACE(_module_rtl871x_xmit_c_
, _drv_err_
, ("%s: There're still something in packet!\n", __func__
));
1095 addr
= (size_t)(pframe
);
1097 mem_start
= (unsigned char *)round_up(addr
, 4) + hw_hdr_offset
;
1098 memcpy(mem_start
, pbuf_start
+ hw_hdr_offset
, pattrib
->hdrlen
);
1101 /* Frame is about to be encrypted. Forward it to the monitor first. */
1102 rtl88eu_mon_xmit_hook(padapter
->pmondev
, pxmitframe
, frg_len
);
1104 if (xmitframe_addmic(padapter
, pxmitframe
) == _FAIL
) {
1105 RT_TRACE(_module_rtl871x_xmit_c_
, _drv_err_
, ("xmitframe_addmic(padapter, pxmitframe) == _FAIL\n"));
1106 DBG_88E("xmitframe_addmic(padapter, pxmitframe) == _FAIL\n");
1111 xmitframe_swencrypt(padapter
, pxmitframe
);
1114 update_attrib_vcs_info(padapter
, pxmitframe
);
1116 pattrib
->vcs_mode
= NONE_VCS
;
1124 /* Logical Link Control(LLC) SubNetwork Attachment Point(SNAP) header
1125 * IEEE LLC/SNAP header contains 8 octets
1126 * First 3 octets comprise the LLC portion
1127 * SNAP portion, 5 octets, is divided into two fields:
1128 * Organizationally Unique Identifier(OUI), 3 octets,
1129 * type, defined by that organization, 2 octets.
1131 s32
rtw_put_snap(u8
*data
, u16 h_proto
)
1133 struct ieee80211_snap_hdr
*snap
;
1137 snap
= (struct ieee80211_snap_hdr
*)data
;
1142 if (h_proto
== 0x8137 || h_proto
== 0x80f3)
1147 snap
->oui
[0] = oui
[0];
1148 snap
->oui
[1] = oui
[1];
1149 snap
->oui
[2] = oui
[2];
1151 *(__be16
*)(data
+ SNAP_SIZE
) = htons(h_proto
);
1154 return SNAP_SIZE
+ sizeof(u16
);
1157 void rtw_update_protection(struct adapter
*padapter
, u8
*ie
, uint ie_len
)
1162 struct xmit_priv
*pxmitpriv
= &padapter
->xmitpriv
;
1163 struct registry_priv
*pregistrypriv
= &padapter
->registrypriv
;
1166 switch (pxmitpriv
->vcs_setting
) {
1168 pxmitpriv
->vcs
= NONE_VCS
;
1174 perp
= rtw_get_ie(ie
, _ERPINFO_IE_
, &erp_len
, ie_len
);
1176 pxmitpriv
->vcs
= NONE_VCS
;
1178 protection
= (*(perp
+ 2)) & BIT(1);
1180 if (pregistrypriv
->vcs_type
== RTS_CTS
)
1181 pxmitpriv
->vcs
= RTS_CTS
;
1183 pxmitpriv
->vcs
= CTS_TO_SELF
;
1185 pxmitpriv
->vcs
= NONE_VCS
;
1193 void rtw_count_tx_stats(struct adapter
*padapter
, struct xmit_frame
*pxmitframe
, int sz
)
1195 struct sta_info
*psta
= NULL
;
1196 struct stainfo_stats
*pstats
= NULL
;
1197 struct xmit_priv
*pxmitpriv
= &padapter
->xmitpriv
;
1198 struct mlme_priv
*pmlmepriv
= &padapter
->mlmepriv
;
1200 if ((pxmitframe
->frame_tag
&0x0f) == DATA_FRAMETAG
) {
1201 pxmitpriv
->tx_bytes
+= sz
;
1202 pmlmepriv
->LinkDetectInfo
.NumTxOkInPeriod
+= pxmitframe
->agg_num
;
1204 psta
= pxmitframe
->attrib
.psta
;
1206 pstats
= &psta
->sta_stats
;
1207 pstats
->tx_pkts
+= pxmitframe
->agg_num
;
1208 pstats
->tx_bytes
+= sz
;
1213 struct xmit_buf
*rtw_alloc_xmitbuf_ext(struct xmit_priv
*pxmitpriv
)
1216 struct xmit_buf
*pxmitbuf
;
1217 struct __queue
*pfree_queue
= &pxmitpriv
->free_xmit_extbuf_queue
;
1219 spin_lock_irqsave(&pfree_queue
->lock
, irql
);
1220 pxmitbuf
= list_first_entry_or_null(&pfree_queue
->queue
,
1221 struct xmit_buf
, list
);
1223 list_del_init(&pxmitbuf
->list
);
1224 pxmitpriv
->free_xmit_extbuf_cnt
--;
1225 pxmitbuf
->priv_data
= NULL
;
1226 /* pxmitbuf->ext_tag = true; */
1227 if (pxmitbuf
->sctx
) {
1228 DBG_88E("%s pxmitbuf->sctx is not NULL\n", __func__
);
1229 rtw_sctx_done_err(&pxmitbuf
->sctx
, RTW_SCTX_DONE_BUF_ALLOC
);
1232 spin_unlock_irqrestore(&pfree_queue
->lock
, irql
);
1237 s32
rtw_free_xmitbuf_ext(struct xmit_priv
*pxmitpriv
, struct xmit_buf
*pxmitbuf
)
1240 struct __queue
*pfree_queue
= &pxmitpriv
->free_xmit_extbuf_queue
;
1243 if (pxmitbuf
== NULL
)
1246 spin_lock_irqsave(&pfree_queue
->lock
, irql
);
1248 list_del_init(&pxmitbuf
->list
);
1250 list_add_tail(&(pxmitbuf
->list
), get_list_head(pfree_queue
));
1251 pxmitpriv
->free_xmit_extbuf_cnt
++;
1253 spin_unlock_irqrestore(&pfree_queue
->lock
, irql
);
1259 struct xmit_buf
*rtw_alloc_xmitbuf(struct xmit_priv
*pxmitpriv
)
1262 struct xmit_buf
*pxmitbuf
;
1263 struct __queue
*pfree_xmitbuf_queue
= &pxmitpriv
->free_xmitbuf_queue
;
1265 /* DBG_88E("+rtw_alloc_xmitbuf\n"); */
1267 spin_lock_irqsave(&pfree_xmitbuf_queue
->lock
, irql
);
1268 pxmitbuf
= list_first_entry_or_null(&pfree_xmitbuf_queue
->queue
,
1269 struct xmit_buf
, list
);
1271 list_del_init(&pxmitbuf
->list
);
1272 pxmitpriv
->free_xmitbuf_cnt
--;
1273 pxmitbuf
->priv_data
= NULL
;
1274 if (pxmitbuf
->sctx
) {
1275 DBG_88E("%s pxmitbuf->sctx is not NULL\n", __func__
);
1276 rtw_sctx_done_err(&pxmitbuf
->sctx
, RTW_SCTX_DONE_BUF_ALLOC
);
1279 spin_unlock_irqrestore(&pfree_xmitbuf_queue
->lock
, irql
);
1284 s32
rtw_free_xmitbuf(struct xmit_priv
*pxmitpriv
, struct xmit_buf
*pxmitbuf
)
1287 struct __queue
*pfree_xmitbuf_queue
= &pxmitpriv
->free_xmitbuf_queue
;
1289 if (pxmitbuf
== NULL
)
1292 if (pxmitbuf
->sctx
) {
1293 DBG_88E("%s pxmitbuf->sctx is not NULL\n", __func__
);
1294 rtw_sctx_done_err(&pxmitbuf
->sctx
, RTW_SCTX_DONE_BUF_FREE
);
1297 if (pxmitbuf
->ext_tag
) {
1298 rtw_free_xmitbuf_ext(pxmitpriv
, pxmitbuf
);
1300 spin_lock_irqsave(&pfree_xmitbuf_queue
->lock
, irql
);
1302 list_del_init(&pxmitbuf
->list
);
1304 list_add_tail(&(pxmitbuf
->list
), get_list_head(pfree_xmitbuf_queue
));
1306 pxmitpriv
->free_xmitbuf_cnt
++;
1307 spin_unlock_irqrestore(&pfree_xmitbuf_queue
->lock
, irql
);
1317 2. RXENTRY (rx_thread or RX_ISR/RX_CallBack)
1319 If we turn on USE_RXTHREAD, then, no need for critical section.
1320 Otherwise, we must use _enter/_exit critical to protect free_xmit_queue...
1322 Must be very very cautious...
1326 struct xmit_frame
*rtw_alloc_xmitframe(struct xmit_priv
*pxmitpriv
)
1327 /* _queue *pfree_xmit_queue) */
1330 Please remember to use all the osdep_service api,
1331 and lock/unlock or _enter/_exit critical to protect
1334 struct xmit_frame
*pxframe
;
1335 struct __queue
*pfree_xmit_queue
= &pxmitpriv
->free_xmit_queue
;
1337 spin_lock_bh(&pfree_xmit_queue
->lock
);
1338 pxframe
= list_first_entry_or_null(&pfree_xmit_queue
->queue
,
1339 struct xmit_frame
, list
);
1341 RT_TRACE(_module_rtl871x_xmit_c_
, _drv_info_
,
1342 ("rtw_alloc_xmitframe:%d\n",
1343 pxmitpriv
->free_xmitframe_cnt
));
1345 list_del_init(&pxframe
->list
);
1347 /* default value setting */
1348 pxmitpriv
->free_xmitframe_cnt
--;
1350 RT_TRACE(_module_rtl871x_xmit_c_
, _drv_info_
,
1351 ("rtw_alloc_xmitframe():free_xmitframe_cnt=%d\n",
1352 pxmitpriv
->free_xmitframe_cnt
));
1354 pxframe
->buf_addr
= NULL
;
1355 pxframe
->pxmitbuf
= NULL
;
1357 memset(&pxframe
->attrib
, 0, sizeof(struct pkt_attrib
));
1358 /* pxframe->attrib.psta = NULL; */
1360 pxframe
->frame_tag
= DATA_FRAMETAG
;
1362 pxframe
->pkt
= NULL
;
1363 pxframe
->pkt_offset
= 1;/* default use pkt_offset to fill tx desc */
1365 pxframe
->agg_num
= 1;
1366 pxframe
->ack_report
= 0;
1368 spin_unlock_bh(&pfree_xmit_queue
->lock
);
1373 s32
rtw_free_xmitframe(struct xmit_priv
*pxmitpriv
, struct xmit_frame
*pxmitframe
)
1375 struct __queue
*pfree_xmit_queue
= &pxmitpriv
->free_xmit_queue
;
1376 struct adapter
*padapter
= pxmitpriv
->adapter
;
1377 struct sk_buff
*pndis_pkt
= NULL
;
1380 if (pxmitframe
== NULL
) {
1381 RT_TRACE(_module_rtl871x_xmit_c_
, _drv_err_
, ("====== rtw_free_xmitframe():pxmitframe == NULL!!!!!!!!!!\n"));
1385 spin_lock_bh(&pfree_xmit_queue
->lock
);
1387 list_del_init(&pxmitframe
->list
);
1389 if (pxmitframe
->pkt
) {
1390 pndis_pkt
= pxmitframe
->pkt
;
1391 pxmitframe
->pkt
= NULL
;
1394 list_add_tail(&pxmitframe
->list
, get_list_head(pfree_xmit_queue
));
1396 pxmitpriv
->free_xmitframe_cnt
++;
1397 RT_TRACE(_module_rtl871x_xmit_c_
, _drv_debug_
, ("rtw_free_xmitframe():free_xmitframe_cnt=%d\n", pxmitpriv
->free_xmitframe_cnt
));
1399 spin_unlock_bh(&pfree_xmit_queue
->lock
);
1402 rtw_os_pkt_complete(padapter
, pndis_pkt
);
1410 void rtw_free_xmitframe_queue(struct xmit_priv
*pxmitpriv
, struct __queue
*pframequeue
)
1412 struct list_head
*plist
, *phead
;
1413 struct xmit_frame
*pxmitframe
;
1416 spin_lock_bh(&(pframequeue
->lock
));
1418 phead
= get_list_head(pframequeue
);
1419 plist
= phead
->next
;
1421 while (phead
!= plist
) {
1422 pxmitframe
= container_of(plist
, struct xmit_frame
, list
);
1424 plist
= plist
->next
;
1426 rtw_free_xmitframe(pxmitpriv
, pxmitframe
);
1428 spin_unlock_bh(&(pframequeue
->lock
));
1432 s32
rtw_xmitframe_enqueue(struct adapter
*padapter
, struct xmit_frame
*pxmitframe
)
1434 if (rtw_xmit_classifier(padapter
, pxmitframe
) == _FAIL
) {
1435 RT_TRACE(_module_rtl871x_xmit_c_
, _drv_err_
,
1436 ("rtw_xmitframe_enqueue: drop xmit pkt for classifier fail\n"));
1437 /* pxmitframe->pkt = NULL; */
1444 static struct xmit_frame
*dequeue_one_xmitframe(struct xmit_priv
*pxmitpriv
, struct hw_xmit
*phwxmit
, struct tx_servq
*ptxservq
, struct __queue
*pframe_queue
)
1446 struct list_head
*xmitframe_plist
, *xmitframe_phead
;
1447 struct xmit_frame
*pxmitframe
= NULL
;
1449 xmitframe_phead
= get_list_head(pframe_queue
);
1450 xmitframe_plist
= xmitframe_phead
->next
;
1452 if (xmitframe_phead
!= xmitframe_plist
) {
1453 pxmitframe
= container_of(xmitframe_plist
, struct xmit_frame
, list
);
1455 xmitframe_plist
= xmitframe_plist
->next
;
1457 list_del_init(&pxmitframe
->list
);
1464 struct xmit_frame
*rtw_dequeue_xframe(struct xmit_priv
*pxmitpriv
, struct hw_xmit
*phwxmit_i
, int entry
)
1466 struct list_head
*sta_plist
, *sta_phead
;
1467 struct hw_xmit
*phwxmit
;
1468 struct tx_servq
*ptxservq
= NULL
;
1469 struct __queue
*pframe_queue
= NULL
;
1470 struct xmit_frame
*pxmitframe
= NULL
;
1471 struct adapter
*padapter
= pxmitpriv
->adapter
;
1472 struct registry_priv
*pregpriv
= &padapter
->registrypriv
;
1476 inx
[0] = 0; inx
[1] = 1; inx
[2] = 2; inx
[3] = 3;
1478 if (pregpriv
->wifi_spec
== 1) {
1481 for (j
= 0; j
< 4; j
++)
1482 inx
[j
] = pxmitpriv
->wmm_para_seq
[j
];
1485 spin_lock_bh(&pxmitpriv
->lock
);
1487 for (i
= 0; i
< entry
; i
++) {
1488 phwxmit
= phwxmit_i
+ inx
[i
];
1490 sta_phead
= get_list_head(phwxmit
->sta_queue
);
1491 sta_plist
= sta_phead
->next
;
1493 while (sta_phead
!= sta_plist
) {
1494 ptxservq
= container_of(sta_plist
, struct tx_servq
, tx_pending
);
1496 pframe_queue
= &ptxservq
->sta_pending
;
1498 pxmitframe
= dequeue_one_xmitframe(pxmitpriv
, phwxmit
, ptxservq
, pframe_queue
);
1503 /* Remove sta node when there are no pending packets. */
1504 if (list_empty(&pframe_queue
->queue
)) /* must be done after get_next and before break */
1505 list_del_init(&ptxservq
->tx_pending
);
1509 sta_plist
= sta_plist
->next
;
1513 spin_unlock_bh(&pxmitpriv
->lock
);
1517 struct tx_servq
*rtw_get_sta_pending(struct adapter
*padapter
, struct sta_info
*psta
, int up
, u8
*ac
)
1519 struct tx_servq
*ptxservq
;
1524 ptxservq
= &(psta
->sta_xmitpriv
.bk_q
);
1526 RT_TRACE(_module_rtl871x_xmit_c_
, _drv_info_
, ("rtw_get_sta_pending : BK\n"));
1530 ptxservq
= &(psta
->sta_xmitpriv
.vi_q
);
1532 RT_TRACE(_module_rtl871x_xmit_c_
, _drv_info_
, ("rtw_get_sta_pending : VI\n"));
1536 ptxservq
= &(psta
->sta_xmitpriv
.vo_q
);
1538 RT_TRACE(_module_rtl871x_xmit_c_
, _drv_info_
, ("rtw_get_sta_pending : VO\n"));
1543 ptxservq
= &(psta
->sta_xmitpriv
.be_q
);
1545 RT_TRACE(_module_rtl871x_xmit_c_
, _drv_info_
, ("rtw_get_sta_pending : BE\n"));
1554 * Will enqueue pxmitframe to the proper queue,
1555 * and indicate it to xx_pending list.....
1557 s32
rtw_xmit_classifier(struct adapter
*padapter
, struct xmit_frame
*pxmitframe
)
1560 struct sta_info
*psta
;
1561 struct tx_servq
*ptxservq
;
1562 struct pkt_attrib
*pattrib
= &pxmitframe
->attrib
;
1563 struct sta_priv
*pstapriv
= &padapter
->stapriv
;
1564 struct hw_xmit
*phwxmits
= padapter
->xmitpriv
.hwxmits
;
1568 if (pattrib
->psta
) {
1569 psta
= pattrib
->psta
;
1571 psta
= rtw_get_stainfo(pstapriv
, pattrib
->ra
);
1576 DBG_88E("rtw_xmit_classifier: psta == NULL\n");
1577 RT_TRACE(_module_rtl871x_xmit_c_
, _drv_err_
, ("rtw_xmit_classifier: psta == NULL\n"));
1581 ptxservq
= rtw_get_sta_pending(padapter
, psta
, pattrib
->priority
, (u8
*)(&ac_index
));
1583 if (list_empty(&ptxservq
->tx_pending
))
1584 list_add_tail(&ptxservq
->tx_pending
, get_list_head(phwxmits
[ac_index
].sta_queue
));
1586 list_add_tail(&pxmitframe
->list
, get_list_head(&ptxservq
->sta_pending
));
1588 phwxmits
[ac_index
].accnt
++;
1595 void rtw_alloc_hwxmits(struct adapter
*padapter
)
1597 struct hw_xmit
*hwxmits
;
1598 struct xmit_priv
*pxmitpriv
= &padapter
->xmitpriv
;
1600 pxmitpriv
->hwxmit_entry
= HWXMIT_ENTRY
;
1602 pxmitpriv
->hwxmits
= kcalloc(pxmitpriv
->hwxmit_entry
,
1603 sizeof(struct hw_xmit
), GFP_KERNEL
);
1605 hwxmits
= pxmitpriv
->hwxmits
;
1607 hwxmits
[0] .sta_queue
= &pxmitpriv
->vo_pending
;
1608 hwxmits
[1] .sta_queue
= &pxmitpriv
->vi_pending
;
1609 hwxmits
[2] .sta_queue
= &pxmitpriv
->be_pending
;
1610 hwxmits
[3] .sta_queue
= &pxmitpriv
->bk_pending
;
1613 void rtw_free_hwxmits(struct adapter
*padapter
)
1615 struct hw_xmit
*hwxmits
;
1616 struct xmit_priv
*pxmitpriv
= &padapter
->xmitpriv
;
1618 hwxmits
= pxmitpriv
->hwxmits
;
1622 void rtw_init_hwxmits(struct hw_xmit
*phwxmit
, int entry
)
1625 for (i
= 0; i
< entry
; i
++, phwxmit
++)
1629 u32
rtw_get_ff_hwaddr(struct xmit_frame
*pxmitframe
)
1632 struct pkt_attrib
*pattrib
= &pxmitframe
->attrib
;
1634 switch (pattrib
->qsel
) {
1637 addr
= BE_QUEUE_INX
;
1641 addr
= BK_QUEUE_INX
;
1645 addr
= VI_QUEUE_INX
;
1649 addr
= VO_QUEUE_INX
;
1652 addr
= BCN_QUEUE_INX
;
1654 case 0x11:/* BC/MC in PS (HIQ) */
1655 addr
= HIGH_QUEUE_INX
;
1659 addr
= MGT_QUEUE_INX
;
1666 static void do_queue_select(struct adapter
*padapter
, struct pkt_attrib
*pattrib
)
1670 qsel
= pattrib
->priority
;
1671 RT_TRACE(_module_rtl871x_xmit_c_
, _drv_info_
, ("### do_queue_select priority=%d , qsel = %d\n", pattrib
->priority
, qsel
));
1673 pattrib
->qsel
= qsel
;
1677 * The main transmit(tx) entry
1681 * 0 success, hardware will handle this xmit frame(packet)
1684 s32
rtw_xmit(struct adapter
*padapter
, struct sk_buff
**ppkt
)
1686 struct xmit_priv
*pxmitpriv
= &padapter
->xmitpriv
;
1687 struct xmit_frame
*pxmitframe
= NULL
;
1690 pxmitframe
= rtw_alloc_xmitframe(pxmitpriv
);
1691 if (pxmitframe
== NULL
) {
1692 RT_TRACE(_module_xmit_osdep_c_
, _drv_err_
, ("rtw_xmit: no more pxmitframe\n"));
1693 DBG_88E("DBG_TX_DROP_FRAME %s no more pxmitframe\n", __func__
);
1697 res
= update_attrib(padapter
, *ppkt
, &pxmitframe
->attrib
);
1700 RT_TRACE(_module_xmit_osdep_c_
, _drv_err_
, ("rtw_xmit: update attrib fail\n"));
1701 rtw_free_xmitframe(pxmitpriv
, pxmitframe
);
1704 pxmitframe
->pkt
= *ppkt
;
1706 rtw_led_control(padapter
, LED_CTL_TX
);
1708 do_queue_select(padapter
, &pxmitframe
->attrib
);
1710 #ifdef CONFIG_88EU_AP_MODE
1711 spin_lock_bh(&pxmitpriv
->lock
);
1712 if (xmitframe_enqueue_for_sleeping_sta(padapter
, pxmitframe
)) {
1713 spin_unlock_bh(&pxmitpriv
->lock
);
1716 spin_unlock_bh(&pxmitpriv
->lock
);
1719 if (rtw_hal_xmit(padapter
, pxmitframe
) == false)
1725 #if defined(CONFIG_88EU_AP_MODE)
1727 int xmitframe_enqueue_for_sleeping_sta(struct adapter
*padapter
, struct xmit_frame
*pxmitframe
)
1730 struct sta_info
*psta
= NULL
;
1731 struct sta_priv
*pstapriv
= &padapter
->stapriv
;
1732 struct pkt_attrib
*pattrib
= &pxmitframe
->attrib
;
1733 struct mlme_priv
*pmlmepriv
= &padapter
->mlmepriv
;
1734 int bmcst
= IS_MCAST(pattrib
->ra
);
1736 if (check_fwstate(pmlmepriv
, WIFI_AP_STATE
) == false)
1740 psta
= pattrib
->psta
;
1742 psta
= rtw_get_stainfo(pstapriv
, pattrib
->ra
);
1747 if (pattrib
->triggered
== 1) {
1749 pattrib
->qsel
= 0x11;/* HIQ */
1754 spin_lock_bh(&psta
->sleep_q
.lock
);
1756 if (pstapriv
->sta_dz_bitmap
) {/* if any one sta is in ps mode */
1757 list_del_init(&pxmitframe
->list
);
1759 list_add_tail(&pxmitframe
->list
, get_list_head(&psta
->sleep_q
));
1763 pstapriv
->tim_bitmap
|= BIT(0);/* */
1764 pstapriv
->sta_dz_bitmap
|= BIT(0);
1766 update_beacon(padapter
, _TIM_IE_
, NULL
, false);/* tx bc/mc packets after update bcn */
1771 spin_unlock_bh(&psta
->sleep_q
.lock
);
1776 spin_lock_bh(&psta
->sleep_q
.lock
);
1778 if (psta
->state
&WIFI_SLEEP_STATE
) {
1781 if (pstapriv
->sta_dz_bitmap
&BIT(psta
->aid
)) {
1782 list_del_init(&pxmitframe
->list
);
1784 list_add_tail(&pxmitframe
->list
, get_list_head(&psta
->sleep_q
));
1788 switch (pattrib
->priority
) {
1791 wmmps_ac
= psta
->uapsd_bk
&BIT(0);
1795 wmmps_ac
= psta
->uapsd_vi
&BIT(0);
1799 wmmps_ac
= psta
->uapsd_vo
&BIT(0);
1804 wmmps_ac
= psta
->uapsd_be
&BIT(0);
1809 psta
->sleepq_ac_len
++;
1811 if (((psta
->has_legacy_ac
) && (!wmmps_ac
)) ||
1812 ((!psta
->has_legacy_ac
) && (wmmps_ac
))) {
1813 pstapriv
->tim_bitmap
|= BIT(psta
->aid
);
1815 if (psta
->sleepq_len
== 1) {
1816 /* update BCN for TIM IE */
1817 update_beacon(padapter
, _TIM_IE_
, NULL
, false);
1824 spin_unlock_bh(&psta
->sleep_q
.lock
);
1829 static void dequeue_xmitframes_to_sleeping_queue(struct adapter
*padapter
, struct sta_info
*psta
, struct __queue
*pframequeue
)
1831 struct list_head
*plist
, *phead
;
1833 struct tx_servq
*ptxservq
;
1834 struct pkt_attrib
*pattrib
;
1835 struct xmit_frame
*pxmitframe
;
1836 struct hw_xmit
*phwxmits
= padapter
->xmitpriv
.hwxmits
;
1838 phead
= get_list_head(pframequeue
);
1839 plist
= phead
->next
;
1841 while (phead
!= plist
) {
1842 pxmitframe
= container_of(plist
, struct xmit_frame
, list
);
1844 plist
= plist
->next
;
1846 xmitframe_enqueue_for_sleeping_sta(padapter
, pxmitframe
);
1848 pattrib
= &pxmitframe
->attrib
;
1850 ptxservq
= rtw_get_sta_pending(padapter
, psta
, pattrib
->priority
, (u8
*)(&ac_index
));
1853 phwxmits
[ac_index
].accnt
--;
1857 void stop_sta_xmit(struct adapter
*padapter
, struct sta_info
*psta
)
1859 struct sta_info
*psta_bmc
;
1860 struct sta_xmit_priv
*pstaxmitpriv
;
1861 struct sta_priv
*pstapriv
= &padapter
->stapriv
;
1862 struct xmit_priv
*pxmitpriv
= &padapter
->xmitpriv
;
1864 pstaxmitpriv
= &psta
->sta_xmitpriv
;
1866 /* for BC/MC Frames */
1867 psta_bmc
= rtw_get_bcmc_stainfo(padapter
);
1869 spin_lock_bh(&pxmitpriv
->lock
);
1871 psta
->state
|= WIFI_SLEEP_STATE
;
1873 pstapriv
->sta_dz_bitmap
|= BIT(psta
->aid
);
1875 dequeue_xmitframes_to_sleeping_queue(padapter
, psta
, &pstaxmitpriv
->vo_q
.sta_pending
);
1876 list_del_init(&(pstaxmitpriv
->vo_q
.tx_pending
));
1878 dequeue_xmitframes_to_sleeping_queue(padapter
, psta
, &pstaxmitpriv
->vi_q
.sta_pending
);
1879 list_del_init(&(pstaxmitpriv
->vi_q
.tx_pending
));
1881 dequeue_xmitframes_to_sleeping_queue(padapter
, psta
, &pstaxmitpriv
->be_q
.sta_pending
);
1882 list_del_init(&(pstaxmitpriv
->be_q
.tx_pending
));
1884 dequeue_xmitframes_to_sleeping_queue(padapter
, psta
, &pstaxmitpriv
->bk_q
.sta_pending
);
1885 list_del_init(&(pstaxmitpriv
->bk_q
.tx_pending
));
1887 /* for BC/MC Frames */
1888 pstaxmitpriv
= &psta_bmc
->sta_xmitpriv
;
1889 dequeue_xmitframes_to_sleeping_queue(padapter
, psta_bmc
, &pstaxmitpriv
->be_q
.sta_pending
);
1890 list_del_init(&(pstaxmitpriv
->be_q
.tx_pending
));
1892 spin_unlock_bh(&pxmitpriv
->lock
);
1895 void wakeup_sta_to_xmit(struct adapter
*padapter
, struct sta_info
*psta
)
1897 u8 update_mask
= 0, wmmps_ac
= 0;
1898 struct sta_info
*psta_bmc
;
1899 struct list_head
*xmitframe_plist
, *xmitframe_phead
;
1900 struct xmit_frame
*pxmitframe
= NULL
;
1901 struct sta_priv
*pstapriv
= &padapter
->stapriv
;
1903 spin_lock_bh(&psta
->sleep_q
.lock
);
1905 xmitframe_phead
= get_list_head(&psta
->sleep_q
);
1906 xmitframe_plist
= xmitframe_phead
->next
;
1908 while (xmitframe_phead
!= xmitframe_plist
) {
1909 pxmitframe
= container_of(xmitframe_plist
, struct xmit_frame
, list
);
1911 xmitframe_plist
= xmitframe_plist
->next
;
1913 list_del_init(&pxmitframe
->list
);
1915 switch (pxmitframe
->attrib
.priority
) {
1918 wmmps_ac
= psta
->uapsd_bk
&BIT(1);
1922 wmmps_ac
= psta
->uapsd_vi
&BIT(1);
1926 wmmps_ac
= psta
->uapsd_vo
&BIT(1);
1931 wmmps_ac
= psta
->uapsd_be
&BIT(1);
1936 if (psta
->sleepq_len
> 0)
1937 pxmitframe
->attrib
.mdata
= 1;
1939 pxmitframe
->attrib
.mdata
= 0;
1942 psta
->sleepq_ac_len
--;
1943 if (psta
->sleepq_ac_len
> 0) {
1944 pxmitframe
->attrib
.mdata
= 1;
1945 pxmitframe
->attrib
.eosp
= 0;
1947 pxmitframe
->attrib
.mdata
= 0;
1948 pxmitframe
->attrib
.eosp
= 1;
1952 pxmitframe
->attrib
.triggered
= 1;
1954 spin_unlock_bh(&psta
->sleep_q
.lock
);
1955 if (rtw_hal_xmit(padapter
, pxmitframe
))
1956 rtw_os_xmit_complete(padapter
, pxmitframe
);
1957 spin_lock_bh(&psta
->sleep_q
.lock
);
1960 if (psta
->sleepq_len
== 0) {
1961 pstapriv
->tim_bitmap
&= ~BIT(psta
->aid
);
1963 update_mask
= BIT(0);
1965 if (psta
->state
&WIFI_SLEEP_STATE
)
1966 psta
->state
^= WIFI_SLEEP_STATE
;
1968 if (psta
->state
& WIFI_STA_ALIVE_CHK_STATE
) {
1969 psta
->expire_to
= pstapriv
->expire_to
;
1970 psta
->state
^= WIFI_STA_ALIVE_CHK_STATE
;
1973 pstapriv
->sta_dz_bitmap
&= ~BIT(psta
->aid
);
1976 spin_unlock_bh(&psta
->sleep_q
.lock
);
1978 /* for BC/MC Frames */
1979 psta_bmc
= rtw_get_bcmc_stainfo(padapter
);
1983 if ((pstapriv
->sta_dz_bitmap
&0xfffe) == 0x0) { /* no any sta in ps mode */
1984 spin_lock_bh(&psta_bmc
->sleep_q
.lock
);
1986 xmitframe_phead
= get_list_head(&psta_bmc
->sleep_q
);
1987 xmitframe_plist
= xmitframe_phead
->next
;
1989 while (xmitframe_phead
!= xmitframe_plist
) {
1990 pxmitframe
= container_of(xmitframe_plist
, struct xmit_frame
, list
);
1992 xmitframe_plist
= xmitframe_plist
->next
;
1994 list_del_init(&pxmitframe
->list
);
1996 psta_bmc
->sleepq_len
--;
1997 if (psta_bmc
->sleepq_len
> 0)
1998 pxmitframe
->attrib
.mdata
= 1;
2000 pxmitframe
->attrib
.mdata
= 0;
2002 pxmitframe
->attrib
.triggered
= 1;
2004 spin_unlock_bh(&psta_bmc
->sleep_q
.lock
);
2005 if (rtw_hal_xmit(padapter
, pxmitframe
))
2006 rtw_os_xmit_complete(padapter
, pxmitframe
);
2007 spin_lock_bh(&psta_bmc
->sleep_q
.lock
);
2010 if (psta_bmc
->sleepq_len
== 0) {
2011 pstapriv
->tim_bitmap
&= ~BIT(0);
2012 pstapriv
->sta_dz_bitmap
&= ~BIT(0);
2014 update_mask
|= BIT(1);
2017 spin_unlock_bh(&psta_bmc
->sleep_q
.lock
);
2021 update_beacon(padapter
, _TIM_IE_
, NULL
, false);
2024 void xmit_delivery_enabled_frames(struct adapter
*padapter
, struct sta_info
*psta
)
2027 struct list_head
*xmitframe_plist
, *xmitframe_phead
;
2028 struct xmit_frame
*pxmitframe
= NULL
;
2029 struct sta_priv
*pstapriv
= &padapter
->stapriv
;
2031 spin_lock_bh(&psta
->sleep_q
.lock
);
2033 xmitframe_phead
= get_list_head(&psta
->sleep_q
);
2034 xmitframe_plist
= xmitframe_phead
->next
;
2036 while (xmitframe_phead
!= xmitframe_plist
) {
2037 pxmitframe
= container_of(xmitframe_plist
, struct xmit_frame
, list
);
2039 xmitframe_plist
= xmitframe_plist
->next
;
2041 switch (pxmitframe
->attrib
.priority
) {
2044 wmmps_ac
= psta
->uapsd_bk
&BIT(1);
2048 wmmps_ac
= psta
->uapsd_vi
&BIT(1);
2052 wmmps_ac
= psta
->uapsd_vo
&BIT(1);
2057 wmmps_ac
= psta
->uapsd_be
&BIT(1);
2064 list_del_init(&pxmitframe
->list
);
2067 psta
->sleepq_ac_len
--;
2069 if (psta
->sleepq_ac_len
> 0) {
2070 pxmitframe
->attrib
.mdata
= 1;
2071 pxmitframe
->attrib
.eosp
= 0;
2073 pxmitframe
->attrib
.mdata
= 0;
2074 pxmitframe
->attrib
.eosp
= 1;
2077 pxmitframe
->attrib
.triggered
= 1;
2079 if (rtw_hal_xmit(padapter
, pxmitframe
) == true)
2080 rtw_os_xmit_complete(padapter
, pxmitframe
);
2082 if ((psta
->sleepq_ac_len
== 0) && (!psta
->has_legacy_ac
) && (wmmps_ac
)) {
2083 pstapriv
->tim_bitmap
&= ~BIT(psta
->aid
);
2085 /* update BCN for TIM IE */
2086 update_beacon(padapter
, _TIM_IE_
, NULL
, false);
2090 spin_unlock_bh(&psta
->sleep_q
.lock
);
2095 void rtw_sctx_init(struct submit_ctx
*sctx
, int timeout_ms
)
2097 sctx
->timeout_ms
= timeout_ms
;
2098 sctx
->submit_time
= jiffies
;
2099 init_completion(&sctx
->done
);
2100 sctx
->status
= RTW_SCTX_SUBMITTED
;
2103 int rtw_sctx_wait(struct submit_ctx
*sctx
)
2106 unsigned long expire
;
2109 expire
= sctx
->timeout_ms
? msecs_to_jiffies(sctx
->timeout_ms
) : MAX_SCHEDULE_TIMEOUT
;
2110 if (!wait_for_completion_timeout(&sctx
->done
, expire
)) {
2111 /* timeout, do something?? */
2112 status
= RTW_SCTX_DONE_TIMEOUT
;
2113 DBG_88E("%s timeout\n", __func__
);
2115 status
= sctx
->status
;
2118 if (status
== RTW_SCTX_DONE_SUCCESS
)
2124 static bool rtw_sctx_chk_waring_status(int status
)
2127 case RTW_SCTX_DONE_UNKNOWN
:
2128 case RTW_SCTX_DONE_BUF_ALLOC
:
2129 case RTW_SCTX_DONE_BUF_FREE
:
2131 case RTW_SCTX_DONE_DRV_STOP
:
2132 case RTW_SCTX_DONE_DEV_REMOVE
:
2139 void rtw_sctx_done_err(struct submit_ctx
**sctx
, int status
)
2142 if (rtw_sctx_chk_waring_status(status
))
2143 DBG_88E("%s status:%d\n", __func__
, status
);
2144 (*sctx
)->status
= status
;
2145 complete(&((*sctx
)->done
));
2150 int rtw_ack_tx_wait(struct xmit_priv
*pxmitpriv
, u32 timeout_ms
)
2152 struct submit_ctx
*pack_tx_ops
= &pxmitpriv
->ack_tx_ops
;
2154 pack_tx_ops
->submit_time
= jiffies
;
2155 pack_tx_ops
->timeout_ms
= timeout_ms
;
2156 pack_tx_ops
->status
= RTW_SCTX_SUBMITTED
;
2158 return rtw_sctx_wait(pack_tx_ops
);
2161 void rtw_ack_tx_done(struct xmit_priv
*pxmitpriv
, int status
)
2163 struct submit_ctx
*pack_tx_ops
= &pxmitpriv
->ack_tx_ops
;
2165 if (pxmitpriv
->ack_tx
)
2166 rtw_sctx_done_err(&pack_tx_ops
, status
);
2168 DBG_88E("%s ack_tx not set\n", __func__
);