]>
git.proxmox.com Git - mirror_ubuntu-kernels.git/blob - drivers/staging/rtl8188eu/core/rtw_xmit.c
1 // SPDX-License-Identifier: GPL-2.0
2 /******************************************************************************
4 * Copyright(c) 2007 - 2012 Realtek Corporation. All rights reserved.
6 ******************************************************************************/
9 #include <osdep_service.h>
10 #include <drv_types.h>
13 #include <osdep_intf.h>
14 #include <linux/vmalloc.h>
16 static u8 P802_1H_OUI
[P80211_OUI_LEN
] = { 0x00, 0x00, 0xf8 };
17 static u8 RFC1042_OUI
[P80211_OUI_LEN
] = { 0x00, 0x00, 0x00 };
19 static void _init_txservq(struct tx_servq
*ptxservq
)
21 INIT_LIST_HEAD(&ptxservq
->tx_pending
);
22 _rtw_init_queue(&ptxservq
->sta_pending
);
26 void _rtw_init_sta_xmit_priv(struct sta_xmit_priv
*psta_xmitpriv
)
28 memset((unsigned char *)psta_xmitpriv
, 0, sizeof(struct sta_xmit_priv
));
29 spin_lock_init(&psta_xmitpriv
->lock
);
30 _init_txservq(&psta_xmitpriv
->be_q
);
31 _init_txservq(&psta_xmitpriv
->bk_q
);
32 _init_txservq(&psta_xmitpriv
->vi_q
);
33 _init_txservq(&psta_xmitpriv
->vo_q
);
34 INIT_LIST_HEAD(&psta_xmitpriv
->legacy_dz
);
35 INIT_LIST_HEAD(&psta_xmitpriv
->apsd
);
38 s32
_rtw_init_xmit_priv(struct xmit_priv
*pxmitpriv
, struct adapter
*padapter
)
41 struct xmit_buf
*pxmitbuf
;
42 struct xmit_frame
*pxframe
;
44 u32 max_xmit_extbuf_size
= MAX_XMIT_EXTBUF_SZ
;
45 u32 num_xmit_extbuf
= NR_XMIT_EXTBUFF
;
47 /* We don't need to memset padapter->XXX to zero, because adapter is allocated by vzalloc(). */
49 spin_lock_init(&pxmitpriv
->lock
);
52 Please insert all the queue initializaiton using _rtw_init_queue below
55 pxmitpriv
->adapter
= padapter
;
57 _rtw_init_queue(&pxmitpriv
->be_pending
);
58 _rtw_init_queue(&pxmitpriv
->bk_pending
);
59 _rtw_init_queue(&pxmitpriv
->vi_pending
);
60 _rtw_init_queue(&pxmitpriv
->vo_pending
);
61 _rtw_init_queue(&pxmitpriv
->bm_pending
);
63 _rtw_init_queue(&pxmitpriv
->free_xmit_queue
);
66 Please allocate memory with the sz = (struct xmit_frame) * NR_XMITFRAME,
67 and initialize free_xmit_frame below.
68 Please also apply free_txobj to link_up all the xmit_frames...
71 pxmitpriv
->pallocated_frame_buf
= vzalloc(NR_XMITFRAME
* sizeof(struct xmit_frame
) + 4);
73 if (!pxmitpriv
->pallocated_frame_buf
) {
74 pxmitpriv
->pxmit_frame_buf
= NULL
;
75 RT_TRACE(_module_rtl871x_xmit_c_
, _drv_err_
, ("alloc xmit_frame fail!\n"));
79 pxmitpriv
->pxmit_frame_buf
= PTR_ALIGN(pxmitpriv
->pallocated_frame_buf
, 4);
81 pxframe
= (struct xmit_frame
*)pxmitpriv
->pxmit_frame_buf
;
83 for (i
= 0; i
< NR_XMITFRAME
; i
++) {
84 INIT_LIST_HEAD(&pxframe
->list
);
86 pxframe
->padapter
= padapter
;
87 pxframe
->frame_tag
= NULL_FRAMETAG
;
91 pxframe
->buf_addr
= NULL
;
92 pxframe
->pxmitbuf
= NULL
;
94 list_add_tail(&pxframe
->list
, &pxmitpriv
->free_xmit_queue
.queue
);
99 pxmitpriv
->free_xmitframe_cnt
= NR_XMITFRAME
;
101 pxmitpriv
->frag_len
= MAX_FRAG_THRESHOLD
;
104 _rtw_init_queue(&pxmitpriv
->free_xmitbuf_queue
);
105 _rtw_init_queue(&pxmitpriv
->pending_xmitbuf_queue
);
107 pxmitpriv
->pallocated_xmitbuf
= vzalloc(NR_XMITBUFF
* sizeof(struct xmit_buf
) + 4);
109 if (!pxmitpriv
->pallocated_xmitbuf
) {
110 RT_TRACE(_module_rtl871x_xmit_c_
, _drv_err_
, ("alloc xmit_buf fail!\n"));
115 pxmitpriv
->pxmitbuf
= PTR_ALIGN(pxmitpriv
->pallocated_xmitbuf
, 4);
117 pxmitbuf
= (struct xmit_buf
*)pxmitpriv
->pxmitbuf
;
119 for (i
= 0; i
< NR_XMITBUFF
; i
++) {
120 INIT_LIST_HEAD(&pxmitbuf
->list
);
122 pxmitbuf
->priv_data
= NULL
;
123 pxmitbuf
->padapter
= padapter
;
124 pxmitbuf
->ext_tag
= false;
126 /* Tx buf allocation may fail sometimes, so sleep and retry. */
127 res
= rtw_os_xmit_resource_alloc(padapter
, pxmitbuf
, (MAX_XMITBUF_SZ
+ XMITBUF_ALIGN_SZ
));
130 res
= rtw_os_xmit_resource_alloc(padapter
, pxmitbuf
, (MAX_XMITBUF_SZ
+ XMITBUF_ALIGN_SZ
));
135 pxmitbuf
->flags
= XMIT_VO_QUEUE
;
137 list_add_tail(&pxmitbuf
->list
, &pxmitpriv
->free_xmitbuf_queue
.queue
);
141 pxmitpriv
->free_xmitbuf_cnt
= NR_XMITBUFF
;
143 /* Init xmit extension buff */
144 _rtw_init_queue(&pxmitpriv
->free_xmit_extbuf_queue
);
146 pxmitpriv
->pallocated_xmit_extbuf
= vzalloc(num_xmit_extbuf
* sizeof(struct xmit_buf
) + 4);
148 if (!pxmitpriv
->pallocated_xmit_extbuf
) {
149 RT_TRACE(_module_rtl871x_xmit_c_
, _drv_err_
, ("alloc xmit_extbuf fail!\n"));
154 pxmitpriv
->pxmit_extbuf
= PTR_ALIGN(pxmitpriv
->pallocated_xmit_extbuf
, 4);
156 pxmitbuf
= (struct xmit_buf
*)pxmitpriv
->pxmit_extbuf
;
158 for (i
= 0; i
< num_xmit_extbuf
; i
++) {
159 INIT_LIST_HEAD(&pxmitbuf
->list
);
161 pxmitbuf
->priv_data
= NULL
;
162 pxmitbuf
->padapter
= padapter
;
163 pxmitbuf
->ext_tag
= true;
165 res
= rtw_os_xmit_resource_alloc(padapter
, pxmitbuf
, max_xmit_extbuf_size
+ XMITBUF_ALIGN_SZ
);
171 list_add_tail(&pxmitbuf
->list
, &pxmitpriv
->free_xmit_extbuf_queue
.queue
);
175 pxmitpriv
->free_xmit_extbuf_cnt
= num_xmit_extbuf
;
177 rtw_alloc_hwxmits(padapter
);
178 rtw_init_hwxmits(pxmitpriv
->hwxmits
, pxmitpriv
->hwxmit_entry
);
180 for (i
= 0; i
< 4; i
++)
181 pxmitpriv
->wmm_para_seq
[i
] = i
;
183 pxmitpriv
->txirp_cnt
= 1;
185 /* per AC pending irp */
186 pxmitpriv
->beq_cnt
= 0;
187 pxmitpriv
->bkq_cnt
= 0;
188 pxmitpriv
->viq_cnt
= 0;
189 pxmitpriv
->voq_cnt
= 0;
191 pxmitpriv
->ack_tx
= false;
192 mutex_init(&pxmitpriv
->ack_tx_mutex
);
193 rtw_sctx_init(&pxmitpriv
->ack_tx_ops
, 0);
195 rtw_hal_init_xmit_priv(padapter
);
201 void _rtw_free_xmit_priv(struct xmit_priv
*pxmitpriv
)
204 struct adapter
*padapter
= pxmitpriv
->adapter
;
205 struct xmit_frame
*pxmitframe
= (struct xmit_frame
*)pxmitpriv
->pxmit_frame_buf
;
206 struct xmit_buf
*pxmitbuf
= (struct xmit_buf
*)pxmitpriv
->pxmitbuf
;
207 u32 num_xmit_extbuf
= NR_XMIT_EXTBUFF
;
209 if (!pxmitpriv
->pxmit_frame_buf
)
212 for (i
= 0; i
< NR_XMITFRAME
; i
++) {
213 rtw_os_xmit_complete(padapter
, pxmitframe
);
218 for (i
= 0; i
< NR_XMITBUFF
; i
++) {
219 rtw_os_xmit_resource_free(pxmitbuf
);
223 vfree(pxmitpriv
->pallocated_frame_buf
);
224 vfree(pxmitpriv
->pallocated_xmitbuf
);
226 /* free xmit extension buff */
227 pxmitbuf
= (struct xmit_buf
*)pxmitpriv
->pxmit_extbuf
;
228 for (i
= 0; i
< num_xmit_extbuf
; i
++) {
229 rtw_os_xmit_resource_free(pxmitbuf
);
233 vfree(pxmitpriv
->pallocated_xmit_extbuf
);
235 rtw_free_hwxmits(padapter
);
237 mutex_destroy(&pxmitpriv
->ack_tx_mutex
);
240 static void update_attrib_vcs_info(struct adapter
*padapter
, struct xmit_frame
*pxmitframe
)
243 struct pkt_attrib
*pattrib
= &pxmitframe
->attrib
;
244 struct sta_info
*psta
= pattrib
->psta
;
245 struct mlme_ext_priv
*pmlmeext
= &padapter
->mlmeextpriv
;
246 struct mlme_ext_info
*pmlmeinfo
= &pmlmeext
->mlmext_info
;
248 if (pattrib
->nr_frags
!= 1)
249 sz
= padapter
->xmitpriv
.frag_len
;
251 sz
= pattrib
->last_txcmdsz
;
253 /* (1) RTS_Threshold is compared to the MPDU, not MSDU.
254 * (2) If there are more than one frag in this MSDU,
255 * only the first frag uses protection frame.
256 * Other fragments are protected by previous fragment.
257 * So we only need to check the length of first fragment.
259 if (pmlmeext
->cur_wireless_mode
< WIRELESS_11_24N
|| padapter
->registrypriv
.wifi_spec
) {
260 if (sz
> padapter
->registrypriv
.rts_thresh
) {
261 pattrib
->vcs_mode
= RTS_CTS
;
264 pattrib
->vcs_mode
= RTS_CTS
;
265 else if (psta
->cts2self
)
266 pattrib
->vcs_mode
= CTS_TO_SELF
;
268 pattrib
->vcs_mode
= NONE_VCS
;
273 if ((pmlmeinfo
->assoc_AP_vendor
== HT_IOT_PEER_ATHEROS
) && pattrib
->ampdu_en
&&
274 (padapter
->securitypriv
.dot11PrivacyAlgrthm
== _AES_
)) {
275 pattrib
->vcs_mode
= CTS_TO_SELF
;
279 /* check ERP protection */
280 if (psta
->rtsen
|| psta
->cts2self
) {
282 pattrib
->vcs_mode
= RTS_CTS
;
283 else if (psta
->cts2self
)
284 pattrib
->vcs_mode
= CTS_TO_SELF
;
289 /* check HT op mode */
290 if (pattrib
->ht_en
) {
291 u8 htopmode
= pmlmeinfo
->HT_protection
;
293 if ((pmlmeext
->cur_bwmode
&& (htopmode
== 2 || htopmode
== 3)) ||
294 (!pmlmeext
->cur_bwmode
&& htopmode
== 3)) {
295 pattrib
->vcs_mode
= RTS_CTS
;
301 if (sz
> padapter
->registrypriv
.rts_thresh
) {
302 pattrib
->vcs_mode
= RTS_CTS
;
306 /* to do list: check MIMO power save condition. */
308 /* check AMPDU aggregation for TXOP */
309 if (pattrib
->ampdu_en
) {
310 pattrib
->vcs_mode
= RTS_CTS
;
314 pattrib
->vcs_mode
= NONE_VCS
;
320 static void update_attrib_phy_info(struct pkt_attrib
*pattrib
, struct sta_info
*psta
)
324 pattrib
->triggered
= 0;
326 /* qos_en, ht_en, init rate, , bw, ch_offset, sgi */
327 pattrib
->qos_en
= psta
->qos_option
;
329 pattrib
->raid
= psta
->raid
;
330 pattrib
->ht_en
= psta
->htpriv
.ht_option
;
331 pattrib
->bwmode
= psta
->htpriv
.bwmode
;
332 pattrib
->ch_offset
= psta
->htpriv
.ch_offset
;
333 pattrib
->sgi
= psta
->htpriv
.sgi
;
334 pattrib
->ampdu_en
= false;
335 pattrib
->retry_ctrl
= false;
338 u8
qos_acm(u8 acm_mask
, u8 priority
)
340 u8 change_priority
= priority
;
345 if (acm_mask
& BIT(1))
353 if (acm_mask
& BIT(2))
358 if (acm_mask
& BIT(3))
362 DBG_88E("%s(): invalid pattrib->priority: %d!!!\n",
367 return change_priority
;
370 static void set_qos(struct sk_buff
*skb
, struct pkt_attrib
*pattrib
)
372 if (pattrib
->ether_type
== 0x0800) {
375 skb_copy_bits(skb
, ETH_HLEN
, &ip_hdr
, sizeof(ip_hdr
));
376 pattrib
->priority
= ip_hdr
.tos
>> 5;
377 } else if (pattrib
->ether_type
== ETH_P_PAE
) {
378 /* When priority processing of data frames is supported,
379 * a STA's SME should send EAPOL-Key frames at the highest
382 pattrib
->priority
= 7;
384 pattrib
->priority
= 0;
387 pattrib
->hdrlen
= WLAN_HDR_A3_QOS_LEN
;
388 pattrib
->subtype
= WIFI_QOS_DATA_TYPE
;
391 static s32
update_attrib(struct adapter
*padapter
, struct sk_buff
*pkt
, struct pkt_attrib
*pattrib
)
393 struct sta_info
*psta
= NULL
;
394 struct ethhdr etherhdr
;
397 struct sta_priv
*pstapriv
= &padapter
->stapriv
;
398 struct security_priv
*psecuritypriv
= &padapter
->securitypriv
;
399 struct mlme_priv
*pmlmepriv
= &padapter
->mlmepriv
;
400 struct qos_priv
*pqospriv
= &pmlmepriv
->qospriv
;
403 skb_copy_bits(pkt
, 0, ðerhdr
, ETH_HLEN
);
405 pattrib
->ether_type
= ntohs(etherhdr
.h_proto
);
407 memcpy(pattrib
->dst
, ðerhdr
.h_dest
, ETH_ALEN
);
408 memcpy(pattrib
->src
, ðerhdr
.h_source
, ETH_ALEN
);
412 if (check_fwstate(pmlmepriv
, WIFI_ADHOC_STATE
) ||
413 check_fwstate(pmlmepriv
, WIFI_ADHOC_MASTER_STATE
)) {
414 memcpy(pattrib
->ra
, pattrib
->dst
, ETH_ALEN
);
415 memcpy(pattrib
->ta
, pattrib
->src
, ETH_ALEN
);
416 } else if (check_fwstate(pmlmepriv
, WIFI_STATION_STATE
)) {
417 memcpy(pattrib
->ra
, get_bssid(pmlmepriv
), ETH_ALEN
);
418 memcpy(pattrib
->ta
, pattrib
->src
, ETH_ALEN
);
419 } else if (check_fwstate(pmlmepriv
, WIFI_AP_STATE
)) {
420 memcpy(pattrib
->ra
, pattrib
->dst
, ETH_ALEN
);
421 memcpy(pattrib
->ta
, get_bssid(pmlmepriv
), ETH_ALEN
);
424 pattrib
->pktlen
= pkt
->len
- ETH_HLEN
;
426 if (pattrib
->ether_type
== ETH_P_IP
) {
427 /* The following is for DHCP and ARP packet, we use
428 * cck1M to tx these packets and let LPS awake some
429 * time to prevent DHCP protocol fail.
433 skb_copy_bits(pkt
, ETH_HLEN
, tmp
, 24);
435 pattrib
->dhcp_pkt
= 0;
436 if (pkt
->len
> ETH_HLEN
+ 24 + 282) {/* MINIMUM_DHCP_PACKET_SIZE) { */
437 if (pattrib
->ether_type
== ETH_P_IP
) {/* IP header */
438 if (((tmp
[21] == 68) && (tmp
[23] == 67)) ||
439 ((tmp
[21] == 67) && (tmp
[23] == 68))) {
440 /* 68 : UDP BOOTP client */
441 /* 67 : UDP BOOTP server */
442 RT_TRACE(_module_rtl871x_xmit_c_
, _drv_err_
, ("====================== %s: get DHCP Packet\n", __func__
));
443 /* Use low rate to send DHCP packet. */
444 pattrib
->dhcp_pkt
= 1;
448 } else if (pattrib
->ether_type
== ETH_P_PAE
) {
449 DBG_88E_LEVEL(_drv_info_
, "send eapol packet\n");
452 if ((pattrib
->ether_type
== ETH_P_PAE
) || (pattrib
->dhcp_pkt
== 1))
453 rtw_set_scan_deny(padapter
, 3000);
455 /* If EAPOL , ARP , OR DHCP packet, driver must be in active mode. */
456 if ((pattrib
->ether_type
== ETH_P_ARP
) || (pattrib
->ether_type
== ETH_P_PAE
) || (pattrib
->dhcp_pkt
== 1))
457 rtw_lps_ctrl_wk_cmd(padapter
, LPS_CTRL_SPECIAL_PACKET
, 1);
459 mcast
= is_multicast_ether_addr(pattrib
->ra
);
463 psta
= rtw_get_bcmc_stainfo(padapter
);
465 psta
= rtw_get_stainfo(pstapriv
, pattrib
->ra
);
466 if (!psta
) { /* if we cannot get psta => drrp the pkt */
467 RT_TRACE(_module_rtl871x_xmit_c_
, _drv_alert_
, ("\nupdate_attrib => get sta_info fail, ra: %pM\n", (pattrib
->ra
)));
470 } else if (check_fwstate(pmlmepriv
, WIFI_AP_STATE
) &&
471 !(psta
->state
& _FW_LINKED
)) {
478 pattrib
->mac_id
= psta
->mac_id
;
479 /* DBG_88E("%s ==> mac_id(%d)\n", __func__, pattrib->mac_id); */
480 pattrib
->psta
= psta
;
482 /* if we cannot get psta => drop the pkt */
483 RT_TRACE(_module_rtl871x_xmit_c_
, _drv_alert_
, ("\nupdate_attrib => get sta_info fail, ra:%pM\n", (pattrib
->ra
)));
488 pattrib
->ack_policy
= 0;
490 pattrib
->hdrlen
= WLAN_HDR_A3_LEN
;
491 pattrib
->subtype
= WIFI_DATA_TYPE
;
492 pattrib
->priority
= 0;
494 if (check_fwstate(pmlmepriv
, WIFI_AP_STATE
|
495 WIFI_ADHOC_STATE
| WIFI_ADHOC_MASTER_STATE
)) {
496 if (psta
->qos_option
)
497 set_qos(pkt
, pattrib
);
499 if (pqospriv
->qos_option
) {
500 set_qos(pkt
, pattrib
);
502 if (pmlmepriv
->acm_mask
!= 0)
503 pattrib
->priority
= qos_acm(pmlmepriv
->acm_mask
, pattrib
->priority
);
507 if (psta
->ieee8021x_blocked
) {
508 RT_TRACE(_module_rtl871x_xmit_c_
, _drv_err_
, ("\n psta->ieee8021x_blocked == true\n"));
510 pattrib
->encrypt
= 0;
512 if (pattrib
->ether_type
!= ETH_P_PAE
) {
513 RT_TRACE(_module_rtl871x_xmit_c_
, _drv_err_
, ("\npsta->ieee8021x_blocked == true, pattrib->ether_type(%.4x) != ETH_P_PAE\n", pattrib
->ether_type
));
518 GET_ENCRY_ALGO(psecuritypriv
, psta
, pattrib
->encrypt
, mcast
);
520 switch (psecuritypriv
->dot11AuthAlgrthm
) {
521 case dot11AuthAlgrthm_Open
:
522 case dot11AuthAlgrthm_Shared
:
523 case dot11AuthAlgrthm_Auto
:
524 pattrib
->key_idx
= (u8
)psecuritypriv
->dot11PrivacyKeyIndex
;
526 case dot11AuthAlgrthm_8021X
:
528 pattrib
->key_idx
= (u8
)psecuritypriv
->dot118021XGrpKeyid
;
530 pattrib
->key_idx
= 0;
533 pattrib
->key_idx
= 0;
538 switch (pattrib
->encrypt
) {
542 pattrib
->icv_len
= 4;
546 pattrib
->icv_len
= 4;
548 if (padapter
->securitypriv
.busetkipkey
== _FAIL
) {
549 RT_TRACE(_module_rtl871x_xmit_c_
, _drv_err_
,
550 ("\npadapter->securitypriv.busetkipkey(%d) == _FAIL drop packet\n",
551 padapter
->securitypriv
.busetkipkey
));
557 RT_TRACE(_module_rtl871x_xmit_c_
, _drv_info_
, ("pattrib->encrypt=%d (_AES_)\n", pattrib
->encrypt
));
559 pattrib
->icv_len
= 8;
563 pattrib
->icv_len
= 0;
567 RT_TRACE(_module_rtl871x_xmit_c_
, _drv_info_
,
568 ("%s: encrypt=%d\n", __func__
, pattrib
->encrypt
));
570 if (pattrib
->encrypt
&& !psecuritypriv
->hw_decrypted
) {
571 pattrib
->bswenc
= true;
572 RT_TRACE(_module_rtl871x_xmit_c_
, _drv_err_
,
573 ("%s: encrypt=%d bswenc = true\n", __func__
,
576 pattrib
->bswenc
= false;
577 RT_TRACE(_module_rtl871x_xmit_c_
, _drv_info_
, ("%s: bswenc = false\n", __func__
));
580 update_attrib_phy_info(pattrib
, psta
);
586 static s32
xmitframe_addmic(struct adapter
*padapter
, struct xmit_frame
*pxmitframe
)
588 int curfragnum
, length
;
589 u8
*pframe
, *payload
, mic
[8];
590 struct mic_data micdata
;
591 struct sta_info
*stainfo
;
592 struct pkt_attrib
*pattrib
= &pxmitframe
->attrib
;
593 struct security_priv
*psecuritypriv
= &padapter
->securitypriv
;
594 struct xmit_priv
*pxmitpriv
= &padapter
->xmitpriv
;
596 u8 hw_hdr_offset
= 0;
599 stainfo
= pattrib
->psta
;
601 stainfo
= rtw_get_stainfo(&padapter
->stapriv
, &pattrib
->ra
[0]);
603 hw_hdr_offset
= TXDESC_SIZE
+ (pxmitframe
->pkt_offset
* PACKET_OFFSET_SZ
);
605 if (pattrib
->encrypt
== _TKIP_
) {
606 /* encode mic code */
608 u8 null_key
[16] = {};
610 pframe
= pxmitframe
->buf_addr
+ hw_hdr_offset
;
612 if (is_multicast_ether_addr(pattrib
->ra
)) {
613 if (!memcmp(psecuritypriv
->dot118021XGrptxmickey
[psecuritypriv
->dot118021XGrpKeyid
].skey
, null_key
, 16))
615 /* start to calculate the mic code */
616 rtw_secmicsetkey(&micdata
, psecuritypriv
->dot118021XGrptxmickey
[psecuritypriv
->dot118021XGrpKeyid
].skey
);
618 if (!memcmp(&stainfo
->dot11tkiptxmickey
.skey
[0], null_key
, 16))
620 /* start to calculate the mic code */
621 rtw_secmicsetkey(&micdata
, &stainfo
->dot11tkiptxmickey
.skey
[0]);
624 if (pframe
[1] & 1) { /* ToDS == 1 */
625 rtw_secmicappend(&micdata
, &pframe
[16], 6); /* DA */
626 if (pframe
[1] & 2) /* From Ds == 1 */
627 rtw_secmicappend(&micdata
, &pframe
[24], 6);
629 rtw_secmicappend(&micdata
, &pframe
[10], 6);
630 } else { /* ToDS == 0 */
631 rtw_secmicappend(&micdata
, &pframe
[4], 6); /* DA */
632 if (pframe
[1] & 2) /* From Ds == 1 */
633 rtw_secmicappend(&micdata
, &pframe
[16], 6);
635 rtw_secmicappend(&micdata
, &pframe
[10], 6);
639 priority
[0] = (u8
)pxmitframe
->attrib
.priority
;
641 rtw_secmicappend(&micdata
, &priority
[0], 4);
645 for (curfragnum
= 0; curfragnum
< pattrib
->nr_frags
; curfragnum
++) {
646 payload
= (u8
*)round_up((size_t)(payload
), 4);
647 RT_TRACE(_module_rtl871x_xmit_c_
, _drv_err_
,
648 ("=== curfragnum=%d, pframe = 0x%.2x, 0x%.2x, 0x%.2x, 0x%.2x, 0x%.2x, 0x%.2x, 0x%.2x, 0x%.2x,!!!\n",
649 curfragnum
, *payload
, *(payload
+ 1),
650 *(payload
+ 2), *(payload
+ 3),
651 *(payload
+ 4), *(payload
+ 5),
652 *(payload
+ 6), *(payload
+ 7)));
654 payload
+= pattrib
->hdrlen
+ pattrib
->iv_len
;
655 RT_TRACE(_module_rtl871x_xmit_c_
, _drv_err_
,
656 ("curfragnum=%d pattrib->hdrlen=%d pattrib->iv_len=%d",
657 curfragnum
, pattrib
->hdrlen
, pattrib
->iv_len
));
658 if (curfragnum
+ 1 == pattrib
->nr_frags
) {
659 length
= pattrib
->last_txcmdsz
-
663 pattrib
->icv_len
: 0);
664 rtw_secmicappend(&micdata
, payload
, length
);
667 length
= pxmitpriv
->frag_len
-
671 pattrib
->icv_len
: 0);
672 rtw_secmicappend(&micdata
, payload
, length
);
673 payload
+= length
+ pattrib
->icv_len
;
674 RT_TRACE(_module_rtl871x_xmit_c_
, _drv_err_
, ("curfragnum=%d length=%d pattrib->icv_len=%d", curfragnum
, length
, pattrib
->icv_len
));
677 rtw_secgetmic(&micdata
, &mic
[0]);
678 RT_TRACE(_module_rtl871x_xmit_c_
, _drv_err_
, ("%s: before add mic code!!!\n", __func__
));
679 RT_TRACE(_module_rtl871x_xmit_c_
, _drv_err_
, ("%s: pattrib->last_txcmdsz=%d!!!\n", __func__
, pattrib
->last_txcmdsz
));
680 RT_TRACE(_module_rtl871x_xmit_c_
, _drv_err_
, ("%s: mic[0]=0x%.2x , mic[1]=0x%.2x , mic[2]= 0x%.2x, mic[3]=0x%.2x\n\
681 mic[4]= 0x%.2x , mic[5]= 0x%.2x , mic[6]= 0x%.2x , mic[7]= 0x%.2x !!!!\n",
682 __func__
, mic
[0], mic
[1], mic
[2], mic
[3], mic
[4], mic
[5], mic
[6], mic
[7]));
683 /* add mic code and add the mic code length in last_txcmdsz */
685 memcpy(payload
, &mic
[0], 8);
686 pattrib
->last_txcmdsz
+= 8;
688 RT_TRACE(_module_rtl871x_xmit_c_
, _drv_info_
, ("\n ======== last pkt ========\n"));
689 payload
-= pattrib
->last_txcmdsz
+ 8;
690 for (curfragnum
= 0; curfragnum
< pattrib
->last_txcmdsz
; curfragnum
+= 8)
691 RT_TRACE(_module_rtl871x_xmit_c_
, _drv_info_
,
692 (" %.2x, %.2x, %.2x, %.2x, %.2x, %.2x, %.2x, %.2x ",
693 *(payload
+ curfragnum
), *(payload
+ curfragnum
+ 1),
694 *(payload
+ curfragnum
+ 2), *(payload
+ curfragnum
+ 3),
695 *(payload
+ curfragnum
+ 4), *(payload
+ curfragnum
+ 5),
696 *(payload
+ curfragnum
+ 6), *(payload
+ curfragnum
+ 7)));
698 RT_TRACE(_module_rtl871x_xmit_c_
, _drv_err_
, ("%s: rtw_get_stainfo==NULL!!!\n", __func__
));
705 static s32
xmitframe_swencrypt(struct adapter
*padapter
, struct xmit_frame
*pxmitframe
)
707 struct pkt_attrib
*pattrib
= &pxmitframe
->attrib
;
709 if (pattrib
->bswenc
) {
710 RT_TRACE(_module_rtl871x_xmit_c_
, _drv_alert_
, ("### %s\n", __func__
));
711 switch (pattrib
->encrypt
) {
714 rtw_wep_encrypt(padapter
, (u8
*)pxmitframe
);
717 rtw_tkip_encrypt(padapter
, (u8
*)pxmitframe
);
720 rtw_aes_encrypt(padapter
, (u8
*)pxmitframe
);
726 RT_TRACE(_module_rtl871x_xmit_c_
, _drv_notice_
, ("### xmitframe_hwencrypt\n"));
732 s32
rtw_make_wlanhdr(struct adapter
*padapter
, u8
*hdr
, struct pkt_attrib
*pattrib
)
736 struct ieee80211_hdr
*pwlanhdr
= (struct ieee80211_hdr
*)hdr
;
737 struct mlme_priv
*pmlmepriv
= &padapter
->mlmepriv
;
738 struct qos_priv
*pqospriv
= &pmlmepriv
->qospriv
;
739 u8 qos_option
= false;
742 __le16
*fctrl
= &pwlanhdr
->frame_control
;
744 struct sta_info
*psta
;
747 psta
= pattrib
->psta
;
749 if (is_multicast_ether_addr(pattrib
->ra
))
750 psta
= rtw_get_bcmc_stainfo(padapter
);
752 psta
= rtw_get_stainfo(&padapter
->stapriv
, pattrib
->ra
);
755 memset(hdr
, 0, WLANHDR_OFFSET
);
757 SetFrameSubType(fctrl
, pattrib
->subtype
);
759 if (pattrib
->subtype
& WIFI_DATA_TYPE
) {
760 if (check_fwstate(pmlmepriv
, WIFI_STATION_STATE
)) {
761 /* to_ds = 1, fr_ds = 0; */
762 /* Data transfer to AP */
764 memcpy(pwlanhdr
->addr1
, get_bssid(pmlmepriv
), ETH_ALEN
);
765 memcpy(pwlanhdr
->addr2
, pattrib
->src
, ETH_ALEN
);
766 memcpy(pwlanhdr
->addr3
, pattrib
->dst
, ETH_ALEN
);
768 if (pqospriv
->qos_option
)
770 } else if (check_fwstate(pmlmepriv
, WIFI_AP_STATE
)) {
771 /* to_ds = 0, fr_ds = 1; */
773 memcpy(pwlanhdr
->addr1
, pattrib
->dst
, ETH_ALEN
);
774 memcpy(pwlanhdr
->addr2
, get_bssid(pmlmepriv
), ETH_ALEN
);
775 memcpy(pwlanhdr
->addr3
, pattrib
->src
, ETH_ALEN
);
777 if (psta
->qos_option
)
779 } else if (check_fwstate(pmlmepriv
, WIFI_ADHOC_STATE
) ||
780 check_fwstate(pmlmepriv
, WIFI_ADHOC_MASTER_STATE
)) {
781 memcpy(pwlanhdr
->addr1
, pattrib
->dst
, ETH_ALEN
);
782 memcpy(pwlanhdr
->addr2
, pattrib
->src
, ETH_ALEN
);
783 memcpy(pwlanhdr
->addr3
, get_bssid(pmlmepriv
), ETH_ALEN
);
785 if (psta
->qos_option
)
788 RT_TRACE(_module_rtl871x_xmit_c_
, _drv_err_
, ("fw_state:%x is not allowed to xmit frame\n", get_fwstate(pmlmepriv
)));
796 if (pattrib
->encrypt
)
800 qc
= (unsigned short *)(hdr
+ pattrib
->hdrlen
- 2);
802 if (pattrib
->priority
)
803 SetPriority(qc
, pattrib
->priority
);
805 SetEOSP(qc
, pattrib
->eosp
);
807 SetAckpolicy(qc
, pattrib
->ack_policy
);
810 /* TODO: fill HT Control Field */
812 /* Update Seq Num will be handled by f/w */
814 psta
->sta_xmitpriv
.txseq_tid
[pattrib
->priority
]++;
815 psta
->sta_xmitpriv
.txseq_tid
[pattrib
->priority
] &= 0xFFF;
817 pattrib
->seqnum
= psta
->sta_xmitpriv
.txseq_tid
[pattrib
->priority
];
819 SetSeqNum(hdr
, pattrib
->seqnum
);
821 /* check if enable ampdu */
822 if (pattrib
->ht_en
&& psta
->htpriv
.ampdu_enable
) {
823 if (psta
->htpriv
.agg_enable_bitmap
& BIT(pattrib
->priority
))
824 pattrib
->ampdu_en
= true;
827 /* re-check if enable ampdu by BA_starting_seqctrl */
828 if (pattrib
->ampdu_en
) {
831 tx_seq
= psta
->BA_starting_seqctrl
[pattrib
->priority
& 0x0f];
833 /* check BA_starting_seqctrl */
834 if (SN_LESS(pattrib
->seqnum
, tx_seq
)) {
835 pattrib
->ampdu_en
= false;/* AGG BK */
836 } else if (SN_EQUAL(pattrib
->seqnum
, tx_seq
)) {
837 psta
->BA_starting_seqctrl
[pattrib
->priority
& 0x0f] = (tx_seq
+ 1) & 0xfff;
839 pattrib
->ampdu_en
= true;/* AGG EN */
841 psta
->BA_starting_seqctrl
[pattrib
->priority
& 0x0f] = (pattrib
->seqnum
+ 1) & 0xfff;
842 pattrib
->ampdu_en
= true;/* AGG EN */
852 s32
rtw_txframes_pending(struct adapter
*padapter
)
854 struct xmit_priv
*pxmitpriv
= &padapter
->xmitpriv
;
856 return (!list_empty(&pxmitpriv
->be_pending
.queue
) ||
857 !list_empty(&pxmitpriv
->bk_pending
.queue
) ||
858 !list_empty(&pxmitpriv
->vi_pending
.queue
) ||
859 !list_empty(&pxmitpriv
->vo_pending
.queue
));
862 s32
rtw_txframes_sta_ac_pending(struct adapter
*padapter
, struct pkt_attrib
*pattrib
)
864 struct sta_info
*psta
;
865 struct tx_servq
*ptxservq
;
866 int priority
= pattrib
->priority
;
868 psta
= pattrib
->psta
;
873 ptxservq
= &psta
->sta_xmitpriv
.bk_q
;
877 ptxservq
= &psta
->sta_xmitpriv
.vi_q
;
881 ptxservq
= &psta
->sta_xmitpriv
.vo_q
;
886 ptxservq
= &psta
->sta_xmitpriv
.be_q
;
890 return ptxservq
->qcnt
;
895 This sub-routine will perform all the following:
897 1. remove 802.3 header.
898 2. create wlan_header, based on the info in pxmitframe
899 3. append sta's iv/ext-iv
901 5. move frag chunk from pframe to pxmitframe->mem
902 6. apply sw-encrypt, if necessary.
905 s32
rtw_xmitframe_coalesce(struct adapter
*padapter
, struct sk_buff
*pkt
, struct xmit_frame
*pxmitframe
)
907 s32 frg_inx
, frg_len
, mpdu_len
, llc_sz
, mem_sz
;
909 u8
*pframe
, *mem_start
;
911 struct sta_info
*psta
;
912 struct xmit_priv
*pxmitpriv
= &padapter
->xmitpriv
;
913 struct pkt_attrib
*pattrib
= &pxmitframe
->attrib
;
915 bool mcast
= is_multicast_ether_addr(pattrib
->ra
);
917 size_t remainder
= pkt
->len
- ETH_HLEN
;
919 psta
= rtw_get_stainfo(&padapter
->stapriv
, pattrib
->ra
);
924 if (!pxmitframe
->buf_addr
) {
925 DBG_88E("==> %s buf_addr == NULL\n", __func__
);
929 pbuf_start
= pxmitframe
->buf_addr
;
931 hw_hdr_offset
= TXDESC_SIZE
+ (pxmitframe
->pkt_offset
* PACKET_OFFSET_SZ
);
933 mem_start
= pbuf_start
+ hw_hdr_offset
;
935 if (rtw_make_wlanhdr(padapter
, mem_start
, pattrib
) == _FAIL
) {
936 RT_TRACE(_module_rtl871x_xmit_c_
, _drv_err_
, ("%s: rtw_make_wlanhdr fail; drop pkt\n", __func__
));
937 DBG_88E("%s: rtw_make_wlanhdr fail; drop pkt\n", __func__
);
943 frg_len
= pxmitpriv
->frag_len
- 4;/* 2346-4 = 2342 */
954 pframe
+= pattrib
->hdrlen
;
955 mpdu_len
-= pattrib
->hdrlen
;
957 /* adding icv, if necessary... */
958 if (pattrib
->iv_len
) {
959 switch (pattrib
->encrypt
) {
962 WEP_IV(pattrib
->iv
, psta
->dot11txpn
, pattrib
->key_idx
);
966 TKIP_IV(pattrib
->iv
, psta
->dot11txpn
, pattrib
->key_idx
);
968 TKIP_IV(pattrib
->iv
, psta
->dot11txpn
, 0);
972 AES_IV(pattrib
->iv
, psta
->dot11txpn
, pattrib
->key_idx
);
974 AES_IV(pattrib
->iv
, psta
->dot11txpn
, 0);
978 memcpy(pframe
, pattrib
->iv
, pattrib
->iv_len
);
980 RT_TRACE(_module_rtl871x_xmit_c_
, _drv_notice_
,
981 ("%s: keyid=%d pattrib->iv[3]=%.2x pframe=%.2x %.2x %.2x %.2x\n",
983 padapter
->securitypriv
.dot11PrivacyKeyIndex
,
984 pattrib
->iv
[3], *pframe
, *(pframe
+ 1),
985 *(pframe
+ 2), *(pframe
+ 3)));
987 pframe
+= pattrib
->iv_len
;
989 mpdu_len
-= pattrib
->iv_len
;
993 llc_sz
= rtw_put_snap(pframe
, pattrib
->ether_type
);
998 if ((pattrib
->icv_len
> 0) && (pattrib
->bswenc
))
999 mpdu_len
-= pattrib
->icv_len
;
1001 mem_sz
= min_t(size_t, mcast
? pattrib
->pktlen
: mpdu_len
, remainder
);
1002 skb_copy_bits(pkt
, pkt
->len
- remainder
, pframe
, mem_sz
);
1003 remainder
-= mem_sz
;
1007 if ((pattrib
->icv_len
> 0) && (pattrib
->bswenc
)) {
1008 memcpy(pframe
, pattrib
->icv
, pattrib
->icv_len
);
1009 pframe
+= pattrib
->icv_len
;
1014 if (mcast
|| remainder
== 0) {
1015 pattrib
->nr_frags
= frg_inx
;
1017 pattrib
->last_txcmdsz
= pattrib
->hdrlen
+ pattrib
->iv_len
+ ((pattrib
->nr_frags
== 1) ? llc_sz
: 0) +
1018 ((pattrib
->bswenc
) ? pattrib
->icv_len
: 0) + mem_sz
;
1020 ClearMFrag(mem_start
);
1024 RT_TRACE(_module_rtl871x_xmit_c_
, _drv_err_
, ("%s: There're still something in packet!\n", __func__
));
1027 addr
= (size_t)(pframe
);
1029 mem_start
= (unsigned char *)round_up(addr
, 4) + hw_hdr_offset
;
1030 memcpy(mem_start
, pbuf_start
+ hw_hdr_offset
, pattrib
->hdrlen
);
1033 /* Frame is about to be encrypted. Forward it to the monitor first. */
1034 rtl88eu_mon_xmit_hook(padapter
->pmondev
, pxmitframe
, frg_len
);
1036 if (xmitframe_addmic(padapter
, pxmitframe
) == _FAIL
) {
1037 RT_TRACE(_module_rtl871x_xmit_c_
, _drv_err_
, ("xmitframe_addmic(padapter, pxmitframe) == _FAIL\n"));
1038 DBG_88E("xmitframe_addmic(padapter, pxmitframe) == _FAIL\n");
1043 xmitframe_swencrypt(padapter
, pxmitframe
);
1046 update_attrib_vcs_info(padapter
, pxmitframe
);
1048 pattrib
->vcs_mode
= NONE_VCS
;
1054 /* Logical Link Control(LLC) SubNetwork Attachment Point(SNAP) header
1055 * IEEE LLC/SNAP header contains 8 octets
1056 * First 3 octets comprise the LLC portion
1057 * SNAP portion, 5 octets, is divided into two fields:
1058 * Organizationally Unique Identifier(OUI), 3 octets,
1059 * type, defined by that organization, 2 octets.
1061 s32
rtw_put_snap(u8
*data
, u16 h_proto
)
1063 struct ieee80211_snap_hdr
*snap
;
1066 snap
= (struct ieee80211_snap_hdr
*)data
;
1071 if (h_proto
== 0x8137 || h_proto
== 0x80f3)
1076 snap
->oui
[0] = oui
[0];
1077 snap
->oui
[1] = oui
[1];
1078 snap
->oui
[2] = oui
[2];
1080 *(__be16
*)(data
+ SNAP_SIZE
) = htons(h_proto
);
1082 return SNAP_SIZE
+ sizeof(u16
);
1085 void rtw_update_protection(struct adapter
*padapter
, u8
*ie
, uint ie_len
)
1087 uint protection
, erp_len
;
1089 struct xmit_priv
*pxmitpriv
= &padapter
->xmitpriv
;
1090 struct registry_priv
*pregistrypriv
= &padapter
->registrypriv
;
1092 switch (pxmitpriv
->vcs_setting
) {
1094 pxmitpriv
->vcs
= NONE_VCS
;
1100 perp
= rtw_get_ie(ie
, _ERPINFO_IE_
, &erp_len
, ie_len
);
1102 pxmitpriv
->vcs
= NONE_VCS
;
1104 protection
= (*(perp
+ 2)) & BIT(1);
1106 if (pregistrypriv
->vcs_type
== RTS_CTS
)
1107 pxmitpriv
->vcs
= RTS_CTS
;
1109 pxmitpriv
->vcs
= CTS_TO_SELF
;
1111 pxmitpriv
->vcs
= NONE_VCS
;
1118 void rtw_count_tx_stats(struct adapter
*padapter
, struct xmit_frame
*pxmitframe
, int sz
)
1120 struct sta_info
*psta
= NULL
;
1121 struct stainfo_stats
*pstats
= NULL
;
1122 struct xmit_priv
*pxmitpriv
= &padapter
->xmitpriv
;
1123 struct mlme_priv
*pmlmepriv
= &padapter
->mlmepriv
;
1125 if ((pxmitframe
->frame_tag
& 0x0f) == DATA_FRAMETAG
) {
1126 pxmitpriv
->tx_bytes
+= sz
;
1127 pmlmepriv
->LinkDetectInfo
.NumTxOkInPeriod
+= pxmitframe
->agg_num
;
1129 psta
= pxmitframe
->attrib
.psta
;
1131 pstats
= &psta
->sta_stats
;
1132 pstats
->tx_pkts
+= pxmitframe
->agg_num
;
1133 pstats
->tx_bytes
+= sz
;
1138 struct xmit_buf
*rtw_alloc_xmitbuf_ext(struct xmit_priv
*pxmitpriv
)
1141 struct xmit_buf
*pxmitbuf
;
1142 struct __queue
*pfree_queue
= &pxmitpriv
->free_xmit_extbuf_queue
;
1144 spin_lock_irqsave(&pfree_queue
->lock
, irql
);
1145 pxmitbuf
= list_first_entry_or_null(&pfree_queue
->queue
,
1146 struct xmit_buf
, list
);
1148 list_del_init(&pxmitbuf
->list
);
1149 pxmitpriv
->free_xmit_extbuf_cnt
--;
1150 pxmitbuf
->priv_data
= NULL
;
1151 if (pxmitbuf
->sctx
) {
1152 DBG_88E("%s pxmitbuf->sctx is not NULL\n", __func__
);
1153 rtw_sctx_done_err(&pxmitbuf
->sctx
, RTW_SCTX_DONE_BUF_ALLOC
);
1156 spin_unlock_irqrestore(&pfree_queue
->lock
, irql
);
1161 s32
rtw_free_xmitbuf_ext(struct xmit_priv
*pxmitpriv
, struct xmit_buf
*pxmitbuf
)
1164 struct __queue
*pfree_queue
= &pxmitpriv
->free_xmit_extbuf_queue
;
1169 spin_lock_irqsave(&pfree_queue
->lock
, irql
);
1171 list_del_init(&pxmitbuf
->list
);
1173 list_add_tail(&pxmitbuf
->list
, get_list_head(pfree_queue
));
1174 pxmitpriv
->free_xmit_extbuf_cnt
++;
1176 spin_unlock_irqrestore(&pfree_queue
->lock
, irql
);
1181 struct xmit_buf
*rtw_alloc_xmitbuf(struct xmit_priv
*pxmitpriv
)
1184 struct xmit_buf
*pxmitbuf
;
1185 struct __queue
*pfree_xmitbuf_queue
= &pxmitpriv
->free_xmitbuf_queue
;
1187 spin_lock_irqsave(&pfree_xmitbuf_queue
->lock
, irql
);
1188 pxmitbuf
= list_first_entry_or_null(&pfree_xmitbuf_queue
->queue
,
1189 struct xmit_buf
, list
);
1191 list_del_init(&pxmitbuf
->list
);
1192 pxmitpriv
->free_xmitbuf_cnt
--;
1193 pxmitbuf
->priv_data
= NULL
;
1194 if (pxmitbuf
->sctx
) {
1195 DBG_88E("%s pxmitbuf->sctx is not NULL\n", __func__
);
1196 rtw_sctx_done_err(&pxmitbuf
->sctx
, RTW_SCTX_DONE_BUF_ALLOC
);
1199 spin_unlock_irqrestore(&pfree_xmitbuf_queue
->lock
, irql
);
1204 s32
rtw_free_xmitbuf(struct xmit_priv
*pxmitpriv
, struct xmit_buf
*pxmitbuf
)
1207 struct __queue
*pfree_xmitbuf_queue
= &pxmitpriv
->free_xmitbuf_queue
;
1212 if (pxmitbuf
->sctx
) {
1213 DBG_88E("%s pxmitbuf->sctx is not NULL\n", __func__
);
1214 rtw_sctx_done_err(&pxmitbuf
->sctx
, RTW_SCTX_DONE_BUF_FREE
);
1217 if (pxmitbuf
->ext_tag
) {
1218 rtw_free_xmitbuf_ext(pxmitpriv
, pxmitbuf
);
1220 spin_lock_irqsave(&pfree_xmitbuf_queue
->lock
, irql
);
1222 list_del_init(&pxmitbuf
->list
);
1224 list_add_tail(&pxmitbuf
->list
, get_list_head(pfree_xmitbuf_queue
));
1226 pxmitpriv
->free_xmitbuf_cnt
++;
1227 spin_unlock_irqrestore(&pfree_xmitbuf_queue
->lock
, irql
);
1236 2. RXENTRY (rx_thread or RX_ISR/RX_CallBack)
1238 If we turn on USE_RXTHREAD, then, no need for critical section.
1239 Otherwise, we must use _enter/_exit critical to protect free_xmit_queue...
1241 Must be very very cautious...
1245 struct xmit_frame
*rtw_alloc_xmitframe(struct xmit_priv
*pxmitpriv
)
1246 /* _queue *pfree_xmit_queue) */
1249 Please remember to use all the osdep_service api,
1250 and lock/unlock or _enter/_exit critical to protect
1253 struct xmit_frame
*pxframe
;
1254 struct __queue
*pfree_xmit_queue
= &pxmitpriv
->free_xmit_queue
;
1256 spin_lock_bh(&pfree_xmit_queue
->lock
);
1257 pxframe
= list_first_entry_or_null(&pfree_xmit_queue
->queue
,
1258 struct xmit_frame
, list
);
1260 RT_TRACE(_module_rtl871x_xmit_c_
, _drv_info_
,
1261 ("rtw_alloc_xmitframe:%d\n",
1262 pxmitpriv
->free_xmitframe_cnt
));
1264 list_del_init(&pxframe
->list
);
1266 /* default value setting */
1267 pxmitpriv
->free_xmitframe_cnt
--;
1269 RT_TRACE(_module_rtl871x_xmit_c_
, _drv_info_
,
1270 ("rtw_alloc_xmitframe():free_xmitframe_cnt=%d\n",
1271 pxmitpriv
->free_xmitframe_cnt
));
1273 pxframe
->buf_addr
= NULL
;
1274 pxframe
->pxmitbuf
= NULL
;
1276 memset(&pxframe
->attrib
, 0, sizeof(struct pkt_attrib
));
1278 pxframe
->frame_tag
= DATA_FRAMETAG
;
1280 pxframe
->pkt
= NULL
;
1281 pxframe
->pkt_offset
= 1;/* default use pkt_offset to fill tx desc */
1283 pxframe
->agg_num
= 1;
1284 pxframe
->ack_report
= 0;
1286 spin_unlock_bh(&pfree_xmit_queue
->lock
);
1291 s32
rtw_free_xmitframe(struct xmit_priv
*pxmitpriv
, struct xmit_frame
*pxmitframe
)
1293 struct __queue
*pfree_xmit_queue
= &pxmitpriv
->free_xmit_queue
;
1294 struct adapter
*padapter
= pxmitpriv
->adapter
;
1295 struct sk_buff
*pndis_pkt
= NULL
;
1298 RT_TRACE(_module_rtl871x_xmit_c_
, _drv_err_
, ("====== %s:pxmitframe == NULL!!!!!!!!!!\n", __func__
));
1302 spin_lock_bh(&pfree_xmit_queue
->lock
);
1304 list_del_init(&pxmitframe
->list
);
1306 if (pxmitframe
->pkt
) {
1307 pndis_pkt
= pxmitframe
->pkt
;
1308 pxmitframe
->pkt
= NULL
;
1311 list_add_tail(&pxmitframe
->list
, get_list_head(pfree_xmit_queue
));
1313 pxmitpriv
->free_xmitframe_cnt
++;
1314 RT_TRACE(_module_rtl871x_xmit_c_
, _drv_debug_
, ("%s:free_xmitframe_cnt=%d\n", __func__
, pxmitpriv
->free_xmitframe_cnt
));
1316 spin_unlock_bh(&pfree_xmit_queue
->lock
);
1319 rtw_os_pkt_complete(padapter
, pndis_pkt
);
1325 void rtw_free_xmitframe_queue(struct xmit_priv
*pxmitpriv
, struct __queue
*pframequeue
)
1327 struct list_head
*plist
, *phead
;
1328 struct xmit_frame
*pxmitframe
;
1330 spin_lock_bh(&pframequeue
->lock
);
1332 phead
= get_list_head(pframequeue
);
1333 plist
= phead
->next
;
1335 while (phead
!= plist
) {
1336 pxmitframe
= container_of(plist
, struct xmit_frame
, list
);
1338 plist
= plist
->next
;
1340 rtw_free_xmitframe(pxmitpriv
, pxmitframe
);
1342 spin_unlock_bh(&pframequeue
->lock
);
1345 s32
rtw_xmitframe_enqueue(struct adapter
*padapter
, struct xmit_frame
*pxmitframe
)
1347 if (rtw_xmit_classifier(padapter
, pxmitframe
) == _FAIL
) {
1348 RT_TRACE(_module_rtl871x_xmit_c_
, _drv_err_
,
1349 ("%s: drop xmit pkt for classifier fail\n", __func__
));
1356 static struct xmit_frame
*dequeue_one_xmitframe(struct xmit_priv
*pxmitpriv
, struct hw_xmit
*phwxmit
, struct tx_servq
*ptxservq
, struct __queue
*pframe_queue
)
1358 struct list_head
*xmitframe_plist
, *xmitframe_phead
;
1359 struct xmit_frame
*pxmitframe
= NULL
;
1361 xmitframe_phead
= get_list_head(pframe_queue
);
1362 xmitframe_plist
= xmitframe_phead
->next
;
1364 if (xmitframe_phead
!= xmitframe_plist
) {
1365 pxmitframe
= container_of(xmitframe_plist
, struct xmit_frame
, list
);
1367 xmitframe_plist
= xmitframe_plist
->next
;
1369 list_del_init(&pxmitframe
->list
);
1376 struct xmit_frame
*rtw_dequeue_xframe(struct xmit_priv
*pxmitpriv
, struct hw_xmit
*phwxmit_i
, int entry
)
1378 struct list_head
*sta_plist
, *sta_phead
;
1379 struct hw_xmit
*phwxmit
;
1380 struct tx_servq
*ptxservq
= NULL
;
1381 struct __queue
*pframe_queue
= NULL
;
1382 struct xmit_frame
*pxmitframe
= NULL
;
1383 struct adapter
*padapter
= pxmitpriv
->adapter
;
1384 struct registry_priv
*pregpriv
= &padapter
->registrypriv
;
1387 inx
[0] = 0; inx
[1] = 1; inx
[2] = 2; inx
[3] = 3;
1389 if (pregpriv
->wifi_spec
== 1) {
1392 for (j
= 0; j
< 4; j
++)
1393 inx
[j
] = pxmitpriv
->wmm_para_seq
[j
];
1396 spin_lock_bh(&pxmitpriv
->lock
);
1398 for (i
= 0; i
< entry
; i
++) {
1399 phwxmit
= phwxmit_i
+ inx
[i
];
1401 sta_phead
= get_list_head(phwxmit
->sta_queue
);
1402 sta_plist
= sta_phead
->next
;
1404 while (sta_phead
!= sta_plist
) {
1405 ptxservq
= container_of(sta_plist
, struct tx_servq
, tx_pending
);
1407 pframe_queue
= &ptxservq
->sta_pending
;
1409 pxmitframe
= dequeue_one_xmitframe(pxmitpriv
, phwxmit
, ptxservq
, pframe_queue
);
1414 /* Remove sta node when there are no pending packets. */
1415 if (list_empty(&pframe_queue
->queue
)) /* must be done after get_next and before break */
1416 list_del_init(&ptxservq
->tx_pending
);
1420 sta_plist
= sta_plist
->next
;
1424 spin_unlock_bh(&pxmitpriv
->lock
);
1428 struct tx_servq
*rtw_get_sta_pending(struct adapter
*padapter
,
1429 struct sta_info
*psta
, int up
, u8
*ac
)
1431 struct tx_servq
*ptxservq
;
1436 ptxservq
= &psta
->sta_xmitpriv
.bk_q
;
1438 RT_TRACE(_module_rtl871x_xmit_c_
, _drv_info_
,
1439 ("%s : BK\n", __func__
));
1443 ptxservq
= &psta
->sta_xmitpriv
.vi_q
;
1445 RT_TRACE(_module_rtl871x_xmit_c_
, _drv_info_
,
1446 ("%s : VI\n", __func__
));
1450 ptxservq
= &psta
->sta_xmitpriv
.vo_q
;
1452 RT_TRACE(_module_rtl871x_xmit_c_
, _drv_info_
,
1453 ("%s : VO\n", __func__
));
1458 ptxservq
= &psta
->sta_xmitpriv
.be_q
;
1460 RT_TRACE(_module_rtl871x_xmit_c_
, _drv_info_
,
1461 ("%s : BE\n", __func__
));
1469 * Will enqueue pxmitframe to the proper queue,
1470 * and indicate it to xx_pending list.....
1472 s32
rtw_xmit_classifier(struct adapter
*padapter
, struct xmit_frame
*pxmitframe
)
1475 struct sta_info
*psta
;
1476 struct tx_servq
*ptxservq
;
1477 struct pkt_attrib
*pattrib
= &pxmitframe
->attrib
;
1478 struct sta_priv
*pstapriv
= &padapter
->stapriv
;
1479 struct hw_xmit
*phwxmits
= padapter
->xmitpriv
.hwxmits
;
1483 psta
= pattrib
->psta
;
1485 psta
= rtw_get_stainfo(pstapriv
, pattrib
->ra
);
1489 DBG_88E("%s: psta == NULL\n", __func__
);
1490 RT_TRACE(_module_rtl871x_xmit_c_
, _drv_err_
, ("%s: psta == NULL\n", __func__
));
1494 ptxservq
= rtw_get_sta_pending(padapter
, psta
, pattrib
->priority
, (u8
*)(&ac_index
));
1496 if (list_empty(&ptxservq
->tx_pending
))
1497 list_add_tail(&ptxservq
->tx_pending
, get_list_head(phwxmits
[ac_index
].sta_queue
));
1499 list_add_tail(&pxmitframe
->list
, get_list_head(&ptxservq
->sta_pending
));
1501 phwxmits
[ac_index
].accnt
++;
1506 void rtw_alloc_hwxmits(struct adapter
*padapter
)
1508 struct hw_xmit
*hwxmits
;
1509 struct xmit_priv
*pxmitpriv
= &padapter
->xmitpriv
;
1511 pxmitpriv
->hwxmit_entry
= HWXMIT_ENTRY
;
1513 pxmitpriv
->hwxmits
= kcalloc(pxmitpriv
->hwxmit_entry
,
1514 sizeof(struct hw_xmit
), GFP_KERNEL
);
1516 hwxmits
= pxmitpriv
->hwxmits
;
1518 hwxmits
[0] .sta_queue
= &pxmitpriv
->vo_pending
;
1519 hwxmits
[1] .sta_queue
= &pxmitpriv
->vi_pending
;
1520 hwxmits
[2] .sta_queue
= &pxmitpriv
->be_pending
;
1521 hwxmits
[3] .sta_queue
= &pxmitpriv
->bk_pending
;
1524 void rtw_free_hwxmits(struct adapter
*padapter
)
1526 struct hw_xmit
*hwxmits
;
1527 struct xmit_priv
*pxmitpriv
= &padapter
->xmitpriv
;
1529 hwxmits
= pxmitpriv
->hwxmits
;
1533 void rtw_init_hwxmits(struct hw_xmit
*phwxmit
, int entry
)
1537 for (i
= 0; i
< entry
; i
++, phwxmit
++)
1541 u32
rtw_get_ff_hwaddr(struct xmit_frame
*pxmitframe
)
1544 struct pkt_attrib
*pattrib
= &pxmitframe
->attrib
;
1546 switch (pattrib
->qsel
) {
1549 addr
= BE_QUEUE_INX
;
1553 addr
= BK_QUEUE_INX
;
1557 addr
= VI_QUEUE_INX
;
1561 addr
= VO_QUEUE_INX
;
1564 addr
= BCN_QUEUE_INX
;
1566 case 0x11:/* BC/MC in PS (HIQ) */
1567 addr
= HIGH_QUEUE_INX
;
1571 addr
= MGT_QUEUE_INX
;
1579 * The main transmit(tx) entry
1583 * 0 success, hardware will handle this xmit frame(packet)
1586 s32
rtw_xmit(struct adapter
*padapter
, struct sk_buff
**ppkt
)
1588 struct xmit_priv
*pxmitpriv
= &padapter
->xmitpriv
;
1589 struct xmit_frame
*pxmitframe
= NULL
;
1592 pxmitframe
= rtw_alloc_xmitframe(pxmitpriv
);
1594 RT_TRACE(_module_xmit_osdep_c_
, _drv_err_
, ("%s: no more pxmitframe\n", __func__
));
1595 DBG_88E("DBG_TX_DROP_FRAME %s no more pxmitframe\n", __func__
);
1599 res
= update_attrib(padapter
, *ppkt
, &pxmitframe
->attrib
);
1602 RT_TRACE(_module_xmit_osdep_c_
, _drv_err_
, ("%s: update attrib fail\n", __func__
));
1603 rtw_free_xmitframe(pxmitpriv
, pxmitframe
);
1606 pxmitframe
->pkt
= *ppkt
;
1608 led_control_8188eu(padapter
, LED_CTL_TX
);
1610 pxmitframe
->attrib
.qsel
= pxmitframe
->attrib
.priority
;
1612 #ifdef CONFIG_88EU_AP_MODE
1613 spin_lock_bh(&pxmitpriv
->lock
);
1614 if (xmitframe_enqueue_for_sleeping_sta(padapter
, pxmitframe
)) {
1615 spin_unlock_bh(&pxmitpriv
->lock
);
1618 spin_unlock_bh(&pxmitpriv
->lock
);
1621 if (!rtw_hal_xmit(padapter
, pxmitframe
))
1627 #if defined(CONFIG_88EU_AP_MODE)
1629 int xmitframe_enqueue_for_sleeping_sta(struct adapter
*padapter
, struct xmit_frame
*pxmitframe
)
1632 struct sta_info
*psta
= NULL
;
1633 struct sta_priv
*pstapriv
= &padapter
->stapriv
;
1634 struct pkt_attrib
*pattrib
= &pxmitframe
->attrib
;
1635 struct mlme_priv
*pmlmepriv
= &padapter
->mlmepriv
;
1636 bool mcast
= is_multicast_ether_addr(pattrib
->ra
);
1638 if (!check_fwstate(pmlmepriv
, WIFI_AP_STATE
))
1642 psta
= pattrib
->psta
;
1644 psta
= rtw_get_stainfo(pstapriv
, pattrib
->ra
);
1649 if (pattrib
->triggered
== 1) {
1651 pattrib
->qsel
= 0x11;/* HIQ */
1656 spin_lock_bh(&psta
->sleep_q
.lock
);
1658 if (pstapriv
->sta_dz_bitmap
) {/* if any one sta is in ps mode */
1659 list_del_init(&pxmitframe
->list
);
1661 list_add_tail(&pxmitframe
->list
, get_list_head(&psta
->sleep_q
));
1665 pstapriv
->tim_bitmap
|= BIT(0);/* */
1666 pstapriv
->sta_dz_bitmap
|= BIT(0);
1668 update_beacon(padapter
, _TIM_IE_
, NULL
, false);/* tx bc/mc packets after update bcn */
1673 spin_unlock_bh(&psta
->sleep_q
.lock
);
1678 spin_lock_bh(&psta
->sleep_q
.lock
);
1680 if (psta
->state
& WIFI_SLEEP_STATE
) {
1683 if (pstapriv
->sta_dz_bitmap
& BIT(psta
->aid
)) {
1684 list_del_init(&pxmitframe
->list
);
1686 list_add_tail(&pxmitframe
->list
, get_list_head(&psta
->sleep_q
));
1690 switch (pattrib
->priority
) {
1693 wmmps_ac
= psta
->uapsd_bk
& BIT(0);
1697 wmmps_ac
= psta
->uapsd_vi
& BIT(0);
1701 wmmps_ac
= psta
->uapsd_vo
& BIT(0);
1706 wmmps_ac
= psta
->uapsd_be
& BIT(0);
1711 psta
->sleepq_ac_len
++;
1713 if (((psta
->has_legacy_ac
) && (!wmmps_ac
)) ||
1714 ((!psta
->has_legacy_ac
) && (wmmps_ac
))) {
1715 pstapriv
->tim_bitmap
|= BIT(psta
->aid
);
1717 if (psta
->sleepq_len
== 1) {
1718 /* update BCN for TIM IE */
1719 update_beacon(padapter
, _TIM_IE_
, NULL
, false);
1726 spin_unlock_bh(&psta
->sleep_q
.lock
);
1731 static void dequeue_xmitframes_to_sleeping_queue(struct adapter
*padapter
, struct sta_info
*psta
, struct __queue
*pframequeue
)
1733 struct list_head
*plist
, *phead
;
1735 struct tx_servq
*ptxservq
;
1736 struct pkt_attrib
*pattrib
;
1737 struct xmit_frame
*pxmitframe
;
1738 struct hw_xmit
*phwxmits
= padapter
->xmitpriv
.hwxmits
;
1740 phead
= get_list_head(pframequeue
);
1741 plist
= phead
->next
;
1743 while (phead
!= plist
) {
1744 pxmitframe
= container_of(plist
, struct xmit_frame
, list
);
1746 plist
= plist
->next
;
1748 xmitframe_enqueue_for_sleeping_sta(padapter
, pxmitframe
);
1750 pattrib
= &pxmitframe
->attrib
;
1752 ptxservq
= rtw_get_sta_pending(padapter
, psta
, pattrib
->priority
, (u8
*)(&ac_index
));
1755 phwxmits
[ac_index
].accnt
--;
1759 void stop_sta_xmit(struct adapter
*padapter
, struct sta_info
*psta
)
1761 struct sta_info
*psta_bmc
;
1762 struct sta_xmit_priv
*pstaxmitpriv
;
1763 struct sta_priv
*pstapriv
= &padapter
->stapriv
;
1764 struct xmit_priv
*pxmitpriv
= &padapter
->xmitpriv
;
1766 pstaxmitpriv
= &psta
->sta_xmitpriv
;
1768 /* for BC/MC Frames */
1769 psta_bmc
= rtw_get_bcmc_stainfo(padapter
);
1771 spin_lock_bh(&pxmitpriv
->lock
);
1773 psta
->state
|= WIFI_SLEEP_STATE
;
1775 pstapriv
->sta_dz_bitmap
|= BIT(psta
->aid
);
1777 dequeue_xmitframes_to_sleeping_queue(padapter
, psta
,
1778 &pstaxmitpriv
->vo_q
.sta_pending
);
1779 list_del_init(&pstaxmitpriv
->vo_q
.tx_pending
);
1781 dequeue_xmitframes_to_sleeping_queue(padapter
, psta
,
1782 &pstaxmitpriv
->vi_q
.sta_pending
);
1783 list_del_init(&pstaxmitpriv
->vi_q
.tx_pending
);
1785 dequeue_xmitframes_to_sleeping_queue(padapter
, psta
,
1786 &pstaxmitpriv
->be_q
.sta_pending
);
1787 list_del_init(&pstaxmitpriv
->be_q
.tx_pending
);
1789 dequeue_xmitframes_to_sleeping_queue(padapter
, psta
,
1790 &pstaxmitpriv
->bk_q
.sta_pending
);
1791 list_del_init(&pstaxmitpriv
->bk_q
.tx_pending
);
1793 /* for BC/MC Frames */
1794 pstaxmitpriv
= &psta_bmc
->sta_xmitpriv
;
1795 dequeue_xmitframes_to_sleeping_queue(padapter
, psta_bmc
,
1796 &pstaxmitpriv
->be_q
.sta_pending
);
1797 list_del_init(&pstaxmitpriv
->be_q
.tx_pending
);
1799 spin_unlock_bh(&pxmitpriv
->lock
);
1802 void wakeup_sta_to_xmit(struct adapter
*padapter
, struct sta_info
*psta
)
1804 u8 update_mask
= 0, wmmps_ac
= 0;
1805 struct sta_info
*psta_bmc
;
1806 struct list_head
*xmitframe_plist
, *xmitframe_phead
;
1807 struct xmit_frame
*pxmitframe
= NULL
;
1808 struct sta_priv
*pstapriv
= &padapter
->stapriv
;
1810 spin_lock_bh(&psta
->sleep_q
.lock
);
1812 xmitframe_phead
= get_list_head(&psta
->sleep_q
);
1813 xmitframe_plist
= xmitframe_phead
->next
;
1815 while (xmitframe_phead
!= xmitframe_plist
) {
1816 pxmitframe
= container_of(xmitframe_plist
, struct xmit_frame
, list
);
1818 xmitframe_plist
= xmitframe_plist
->next
;
1820 list_del_init(&pxmitframe
->list
);
1822 switch (pxmitframe
->attrib
.priority
) {
1825 wmmps_ac
= psta
->uapsd_bk
& BIT(1);
1829 wmmps_ac
= psta
->uapsd_vi
& BIT(1);
1833 wmmps_ac
= psta
->uapsd_vo
& BIT(1);
1838 wmmps_ac
= psta
->uapsd_be
& BIT(1);
1843 if (psta
->sleepq_len
> 0)
1844 pxmitframe
->attrib
.mdata
= 1;
1846 pxmitframe
->attrib
.mdata
= 0;
1849 psta
->sleepq_ac_len
--;
1850 if (psta
->sleepq_ac_len
> 0) {
1851 pxmitframe
->attrib
.mdata
= 1;
1852 pxmitframe
->attrib
.eosp
= 0;
1854 pxmitframe
->attrib
.mdata
= 0;
1855 pxmitframe
->attrib
.eosp
= 1;
1859 pxmitframe
->attrib
.triggered
= 1;
1861 spin_unlock_bh(&psta
->sleep_q
.lock
);
1862 if (rtw_hal_xmit(padapter
, pxmitframe
))
1863 rtw_os_xmit_complete(padapter
, pxmitframe
);
1864 spin_lock_bh(&psta
->sleep_q
.lock
);
1867 if (psta
->sleepq_len
== 0) {
1868 pstapriv
->tim_bitmap
&= ~BIT(psta
->aid
);
1870 update_mask
= BIT(0);
1872 if (psta
->state
& WIFI_SLEEP_STATE
)
1873 psta
->state
^= WIFI_SLEEP_STATE
;
1875 if (psta
->state
& WIFI_STA_ALIVE_CHK_STATE
) {
1876 psta
->expire_to
= pstapriv
->expire_to
;
1877 psta
->state
^= WIFI_STA_ALIVE_CHK_STATE
;
1880 pstapriv
->sta_dz_bitmap
&= ~BIT(psta
->aid
);
1883 spin_unlock_bh(&psta
->sleep_q
.lock
);
1885 /* for BC/MC Frames */
1886 psta_bmc
= rtw_get_bcmc_stainfo(padapter
);
1890 if ((pstapriv
->sta_dz_bitmap
& 0xfffe) == 0x0) { /* no any sta in ps mode */
1891 spin_lock_bh(&psta_bmc
->sleep_q
.lock
);
1893 xmitframe_phead
= get_list_head(&psta_bmc
->sleep_q
);
1894 xmitframe_plist
= xmitframe_phead
->next
;
1896 while (xmitframe_phead
!= xmitframe_plist
) {
1897 pxmitframe
= container_of(xmitframe_plist
, struct xmit_frame
, list
);
1899 xmitframe_plist
= xmitframe_plist
->next
;
1901 list_del_init(&pxmitframe
->list
);
1903 psta_bmc
->sleepq_len
--;
1904 if (psta_bmc
->sleepq_len
> 0)
1905 pxmitframe
->attrib
.mdata
= 1;
1907 pxmitframe
->attrib
.mdata
= 0;
1909 pxmitframe
->attrib
.triggered
= 1;
1911 spin_unlock_bh(&psta_bmc
->sleep_q
.lock
);
1912 if (rtw_hal_xmit(padapter
, pxmitframe
))
1913 rtw_os_xmit_complete(padapter
, pxmitframe
);
1914 spin_lock_bh(&psta_bmc
->sleep_q
.lock
);
1917 if (psta_bmc
->sleepq_len
== 0) {
1918 pstapriv
->tim_bitmap
&= ~BIT(0);
1919 pstapriv
->sta_dz_bitmap
&= ~BIT(0);
1921 update_mask
|= BIT(1);
1924 spin_unlock_bh(&psta_bmc
->sleep_q
.lock
);
1928 update_beacon(padapter
, _TIM_IE_
, NULL
, false);
1931 void xmit_delivery_enabled_frames(struct adapter
*padapter
, struct sta_info
*psta
)
1934 struct list_head
*xmitframe_plist
, *xmitframe_phead
;
1935 struct xmit_frame
*pxmitframe
= NULL
;
1936 struct sta_priv
*pstapriv
= &padapter
->stapriv
;
1938 spin_lock_bh(&psta
->sleep_q
.lock
);
1940 xmitframe_phead
= get_list_head(&psta
->sleep_q
);
1941 xmitframe_plist
= xmitframe_phead
->next
;
1943 while (xmitframe_phead
!= xmitframe_plist
) {
1944 pxmitframe
= container_of(xmitframe_plist
, struct xmit_frame
, list
);
1946 xmitframe_plist
= xmitframe_plist
->next
;
1948 switch (pxmitframe
->attrib
.priority
) {
1951 wmmps_ac
= psta
->uapsd_bk
& BIT(1);
1955 wmmps_ac
= psta
->uapsd_vi
& BIT(1);
1959 wmmps_ac
= psta
->uapsd_vo
& BIT(1);
1964 wmmps_ac
= psta
->uapsd_be
& BIT(1);
1971 list_del_init(&pxmitframe
->list
);
1974 psta
->sleepq_ac_len
--;
1976 if (psta
->sleepq_ac_len
> 0) {
1977 pxmitframe
->attrib
.mdata
= 1;
1978 pxmitframe
->attrib
.eosp
= 0;
1980 pxmitframe
->attrib
.mdata
= 0;
1981 pxmitframe
->attrib
.eosp
= 1;
1984 pxmitframe
->attrib
.triggered
= 1;
1986 if (rtw_hal_xmit(padapter
, pxmitframe
))
1987 rtw_os_xmit_complete(padapter
, pxmitframe
);
1989 if ((psta
->sleepq_ac_len
== 0) && (!psta
->has_legacy_ac
) && (wmmps_ac
)) {
1990 pstapriv
->tim_bitmap
&= ~BIT(psta
->aid
);
1992 /* update BCN for TIM IE */
1993 update_beacon(padapter
, _TIM_IE_
, NULL
, false);
1997 spin_unlock_bh(&psta
->sleep_q
.lock
);
2002 void rtw_sctx_init(struct submit_ctx
*sctx
, int timeout_ms
)
2004 sctx
->timeout_ms
= timeout_ms
;
2005 sctx
->submit_time
= jiffies
;
2006 init_completion(&sctx
->done
);
2007 sctx
->status
= RTW_SCTX_SUBMITTED
;
2010 int rtw_sctx_wait(struct submit_ctx
*sctx
)
2013 unsigned long expire
;
2016 expire
= sctx
->timeout_ms
? msecs_to_jiffies(sctx
->timeout_ms
) : MAX_SCHEDULE_TIMEOUT
;
2017 if (!wait_for_completion_timeout(&sctx
->done
, expire
)) {
2018 /* timeout, do something?? */
2019 status
= RTW_SCTX_DONE_TIMEOUT
;
2020 DBG_88E("%s timeout\n", __func__
);
2022 status
= sctx
->status
;
2025 if (status
== RTW_SCTX_DONE_SUCCESS
)
2031 static bool rtw_sctx_chk_warning_status(int status
)
2034 case RTW_SCTX_DONE_UNKNOWN
:
2035 case RTW_SCTX_DONE_BUF_ALLOC
:
2036 case RTW_SCTX_DONE_BUF_FREE
:
2038 case RTW_SCTX_DONE_DRV_STOP
:
2039 case RTW_SCTX_DONE_DEV_REMOVE
:
2046 void rtw_sctx_done_err(struct submit_ctx
**sctx
, int status
)
2049 if (rtw_sctx_chk_warning_status(status
))
2050 DBG_88E("%s status:%d\n", __func__
, status
);
2051 (*sctx
)->status
= status
;
2052 complete(&((*sctx
)->done
));
2057 int rtw_ack_tx_wait(struct xmit_priv
*pxmitpriv
, u32 timeout_ms
)
2059 struct submit_ctx
*pack_tx_ops
= &pxmitpriv
->ack_tx_ops
;
2061 pack_tx_ops
->submit_time
= jiffies
;
2062 pack_tx_ops
->timeout_ms
= timeout_ms
;
2063 pack_tx_ops
->status
= RTW_SCTX_SUBMITTED
;
2065 return rtw_sctx_wait(pack_tx_ops
);
2068 void rtw_ack_tx_done(struct xmit_priv
*pxmitpriv
, int status
)
2070 struct submit_ctx
*pack_tx_ops
= &pxmitpriv
->ack_tx_ops
;
2072 if (pxmitpriv
->ack_tx
)
2073 rtw_sctx_done_err(&pack_tx_ops
, status
);
2075 DBG_88E("%s ack_tx not set\n", __func__
);