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 if (pxmitpriv
->pallocated_frame_buf
)
251 vfree(pxmitpriv
->pallocated_frame_buf
);
253 if (pxmitpriv
->pallocated_xmitbuf
)
254 vfree(pxmitpriv
->pallocated_xmitbuf
);
256 /* free xmit extension buff */
257 pxmitbuf
= (struct xmit_buf
*)pxmitpriv
->pxmit_extbuf
;
258 for (i
= 0; i
< num_xmit_extbuf
; i
++) {
259 rtw_os_xmit_resource_free(padapter
, pxmitbuf
, (max_xmit_extbuf_size
+ XMITBUF_ALIGN_SZ
));
263 if (pxmitpriv
->pallocated_xmit_extbuf
) {
264 vfree(pxmitpriv
->pallocated_xmit_extbuf
);
267 rtw_free_hwxmits(padapter
);
269 mutex_destroy(&pxmitpriv
->ack_tx_mutex
);
272 static void update_attrib_vcs_info(struct adapter
*padapter
, struct xmit_frame
*pxmitframe
)
275 struct pkt_attrib
*pattrib
= &pxmitframe
->attrib
;
276 struct sta_info
*psta
= pattrib
->psta
;
277 struct mlme_ext_priv
*pmlmeext
= &(padapter
->mlmeextpriv
);
278 struct mlme_ext_info
*pmlmeinfo
= &(pmlmeext
->mlmext_info
);
280 if (pattrib
->nr_frags
!= 1)
281 sz
= padapter
->xmitpriv
.frag_len
;
283 sz
= pattrib
->last_txcmdsz
;
285 /* (1) RTS_Threshold is compared to the MPDU, not MSDU. */
286 /* (2) If there are more than one frag in this MSDU, only the first frag uses protection frame. */
287 /* Other fragments are protected by previous fragment. */
288 /* So we only need to check the length of first fragment. */
289 if (pmlmeext
->cur_wireless_mode
< WIRELESS_11_24N
|| padapter
->registrypriv
.wifi_spec
) {
290 if (sz
> padapter
->registrypriv
.rts_thresh
) {
291 pattrib
->vcs_mode
= RTS_CTS
;
294 pattrib
->vcs_mode
= RTS_CTS
;
295 else if (psta
->cts2self
)
296 pattrib
->vcs_mode
= CTS_TO_SELF
;
298 pattrib
->vcs_mode
= NONE_VCS
;
303 if ((pmlmeinfo
->assoc_AP_vendor
== HT_IOT_PEER_ATHEROS
) && pattrib
->ampdu_en
&&
304 (padapter
->securitypriv
.dot11PrivacyAlgrthm
== _AES_
)) {
305 pattrib
->vcs_mode
= CTS_TO_SELF
;
309 /* check ERP protection */
310 if (psta
->rtsen
|| psta
->cts2self
) {
312 pattrib
->vcs_mode
= RTS_CTS
;
313 else if (psta
->cts2self
)
314 pattrib
->vcs_mode
= CTS_TO_SELF
;
319 /* check HT op mode */
320 if (pattrib
->ht_en
) {
321 u8 htopmode
= pmlmeinfo
->HT_protection
;
322 if ((pmlmeext
->cur_bwmode
&& (htopmode
== 2 || htopmode
== 3)) ||
323 (!pmlmeext
->cur_bwmode
&& htopmode
== 3)) {
324 pattrib
->vcs_mode
= RTS_CTS
;
330 if (sz
> padapter
->registrypriv
.rts_thresh
) {
331 pattrib
->vcs_mode
= RTS_CTS
;
335 /* to do list: check MIMO power save condition. */
337 /* check AMPDU aggregation for TXOP */
338 if (pattrib
->ampdu_en
) {
339 pattrib
->vcs_mode
= RTS_CTS
;
343 pattrib
->vcs_mode
= NONE_VCS
;
349 static void update_attrib_phy_info(struct pkt_attrib
*pattrib
, struct sta_info
*psta
)
352 pattrib->vcs_mode = RTS_CTS;
353 else if (psta->cts2self)
354 pattrib->vcs_mode = CTS_TO_SELF;
356 pattrib->vcs_mode = NONE_VCS;*/
360 pattrib
->triggered
= 0;
362 /* qos_en, ht_en, init rate, , bw, ch_offset, sgi */
363 pattrib
->qos_en
= psta
->qos_option
;
365 pattrib
->raid
= psta
->raid
;
366 pattrib
->ht_en
= psta
->htpriv
.ht_option
;
367 pattrib
->bwmode
= psta
->htpriv
.bwmode
;
368 pattrib
->ch_offset
= psta
->htpriv
.ch_offset
;
369 pattrib
->sgi
= psta
->htpriv
.sgi
;
370 pattrib
->ampdu_en
= false;
371 pattrib
->retry_ctrl
= false;
374 u8
qos_acm(u8 acm_mask
, u8 priority
)
376 u8 change_priority
= priority
;
381 if (acm_mask
& BIT(1))
389 if (acm_mask
& BIT(2))
394 if (acm_mask
& BIT(3))
398 DBG_88E("qos_acm(): invalid pattrib->priority: %d!!!\n", priority
);
402 return change_priority
;
405 static void set_qos(struct pkt_file
*ppktfile
, struct pkt_attrib
*pattrib
)
407 struct ethhdr etherhdr
;
411 _rtw_open_pktfile(ppktfile
->pkt
, ppktfile
);
412 _rtw_pktfile_read(ppktfile
, (unsigned char *)ðerhdr
, ETH_HLEN
);
414 /* get user_prio from IP hdr */
415 if (pattrib
->ether_type
== 0x0800) {
416 _rtw_pktfile_read(ppktfile
, (u8
*)&ip_hdr
, sizeof(ip_hdr
));
417 /* user_prio = (ntohs(ip_hdr.tos) >> 5) & 0x3; */
418 user_prio
= ip_hdr
.tos
>> 5;
419 } else if (pattrib
->ether_type
== 0x888e) {
420 /* "When priority processing of data frames is supported, */
421 /* a STA's SME should send EAPOL-Key frames at the highest priority." */
425 pattrib
->priority
= user_prio
;
426 pattrib
->hdrlen
= WLAN_HDR_A3_QOS_LEN
;
427 pattrib
->subtype
= WIFI_QOS_DATA_TYPE
;
430 static s32
update_attrib(struct adapter
*padapter
, struct sk_buff
*pkt
, struct pkt_attrib
*pattrib
)
432 struct pkt_file pktfile
;
433 struct sta_info
*psta
= NULL
;
434 struct ethhdr etherhdr
;
437 struct sta_priv
*pstapriv
= &padapter
->stapriv
;
438 struct security_priv
*psecuritypriv
= &padapter
->securitypriv
;
439 struct mlme_priv
*pmlmepriv
= &padapter
->mlmepriv
;
440 struct qos_priv
*pqospriv
= &pmlmepriv
->qospriv
;
444 _rtw_open_pktfile(pkt
, &pktfile
);
445 _rtw_pktfile_read(&pktfile
, (u8
*)ðerhdr
, ETH_HLEN
);
447 pattrib
->ether_type
= ntohs(etherhdr
.h_proto
);
449 memcpy(pattrib
->dst
, ðerhdr
.h_dest
, ETH_ALEN
);
450 memcpy(pattrib
->src
, ðerhdr
.h_source
, ETH_ALEN
);
454 if (check_fwstate(pmlmepriv
, WIFI_ADHOC_STATE
) ||
455 check_fwstate(pmlmepriv
, WIFI_ADHOC_MASTER_STATE
)) {
456 memcpy(pattrib
->ra
, pattrib
->dst
, ETH_ALEN
);
457 memcpy(pattrib
->ta
, pattrib
->src
, ETH_ALEN
);
458 } else if (check_fwstate(pmlmepriv
, WIFI_STATION_STATE
)) {
459 memcpy(pattrib
->ra
, get_bssid(pmlmepriv
), ETH_ALEN
);
460 memcpy(pattrib
->ta
, pattrib
->src
, ETH_ALEN
);
461 } else if (check_fwstate(pmlmepriv
, WIFI_AP_STATE
)) {
462 memcpy(pattrib
->ra
, pattrib
->dst
, ETH_ALEN
);
463 memcpy(pattrib
->ta
, get_bssid(pmlmepriv
), ETH_ALEN
);
466 pattrib
->pktlen
= pktfile
.pkt_len
;
468 if (ETH_P_IP
== pattrib
->ether_type
) {
469 /* The following is for DHCP and ARP packet, we use cck1M to tx these packets and let LPS awake some time */
470 /* to prevent DHCP protocol fail */
472 _rtw_pktfile_read(&pktfile
, &tmp
[0], 24);
473 pattrib
->dhcp_pkt
= 0;
474 if (pktfile
.pkt_len
> 282) {/* MINIMUM_DHCP_PACKET_SIZE) { */
475 if (ETH_P_IP
== pattrib
->ether_type
) {/* IP header */
476 if (((tmp
[21] == 68) && (tmp
[23] == 67)) ||
477 ((tmp
[21] == 67) && (tmp
[23] == 68))) {
478 /* 68 : UDP BOOTP client */
479 /* 67 : UDP BOOTP server */
480 RT_TRACE(_module_rtl871x_xmit_c_
, _drv_err_
, ("====================== update_attrib: get DHCP Packet\n"));
481 /* Use low rate to send DHCP packet. */
482 pattrib
->dhcp_pkt
= 1;
486 } else if (0x888e == pattrib
->ether_type
) {
487 DBG_88E_LEVEL(_drv_info_
, "send eapol packet\n");
490 if ((pattrib
->ether_type
== 0x888e) || (pattrib
->dhcp_pkt
== 1))
491 rtw_set_scan_deny(padapter
, 3000);
493 /* If EAPOL , ARP , OR DHCP packet, driver must be in active mode. */
494 if ((pattrib
->ether_type
== 0x0806) || (pattrib
->ether_type
== 0x888e) || (pattrib
->dhcp_pkt
== 1))
495 rtw_lps_ctrl_wk_cmd(padapter
, LPS_CTRL_SPECIAL_PACKET
, 1);
497 bmcast
= IS_MCAST(pattrib
->ra
);
501 psta
= rtw_get_bcmc_stainfo(padapter
);
503 psta
= rtw_get_stainfo(pstapriv
, pattrib
->ra
);
504 if (psta
== NULL
) { /* if we cannot get psta => drrp the pkt */
505 RT_TRACE(_module_rtl871x_xmit_c_
, _drv_alert_
, ("\nupdate_attrib => get sta_info fail, ra: %pM\n", (pattrib
->ra
)));
508 } else if ((check_fwstate(pmlmepriv
, WIFI_AP_STATE
) == true) && (!(psta
->state
& _FW_LINKED
))) {
515 pattrib
->mac_id
= psta
->mac_id
;
516 /* DBG_88E("%s ==> mac_id(%d)\n", __func__, pattrib->mac_id); */
517 pattrib
->psta
= psta
;
519 /* if we cannot get psta => drop the pkt */
520 RT_TRACE(_module_rtl871x_xmit_c_
, _drv_alert_
, ("\nupdate_attrib => get sta_info fail, ra:%pM\n", (pattrib
->ra
)));
525 pattrib
->ack_policy
= 0;
526 /* get ether_hdr_len */
527 pattrib
->pkt_hdrlen
= ETH_HLEN
;/* pattrib->ether_type == 0x8100) ? (14 + 4): 14; vlan tag */
529 pattrib
->hdrlen
= WLAN_HDR_A3_LEN
;
530 pattrib
->subtype
= WIFI_DATA_TYPE
;
531 pattrib
->priority
= 0;
533 if (check_fwstate(pmlmepriv
, WIFI_AP_STATE
|WIFI_ADHOC_STATE
|WIFI_ADHOC_MASTER_STATE
)) {
534 if (psta
->qos_option
)
535 set_qos(&pktfile
, pattrib
);
537 if (pqospriv
->qos_option
) {
538 set_qos(&pktfile
, pattrib
);
540 if (pmlmepriv
->acm_mask
!= 0)
541 pattrib
->priority
= qos_acm(pmlmepriv
->acm_mask
, pattrib
->priority
);
545 if (psta
->ieee8021x_blocked
) {
546 RT_TRACE(_module_rtl871x_xmit_c_
, _drv_err_
, ("\n psta->ieee8021x_blocked == true\n"));
548 pattrib
->encrypt
= 0;
550 if ((pattrib
->ether_type
!= 0x888e) && !check_fwstate(pmlmepriv
, WIFI_MP_STATE
)) {
551 RT_TRACE(_module_rtl871x_xmit_c_
, _drv_err_
, ("\npsta->ieee8021x_blocked == true, pattrib->ether_type(%.4x) != 0x888e\n", pattrib
->ether_type
));
556 GET_ENCRY_ALGO(psecuritypriv
, psta
, pattrib
->encrypt
, bmcast
);
558 switch (psecuritypriv
->dot11AuthAlgrthm
) {
559 case dot11AuthAlgrthm_Open
:
560 case dot11AuthAlgrthm_Shared
:
561 case dot11AuthAlgrthm_Auto
:
562 pattrib
->key_idx
= (u8
)psecuritypriv
->dot11PrivacyKeyIndex
;
564 case dot11AuthAlgrthm_8021X
:
566 pattrib
->key_idx
= (u8
)psecuritypriv
->dot118021XGrpKeyid
;
568 pattrib
->key_idx
= 0;
571 pattrib
->key_idx
= 0;
576 switch (pattrib
->encrypt
) {
580 pattrib
->icv_len
= 4;
584 pattrib
->icv_len
= 4;
586 if (padapter
->securitypriv
.busetkipkey
== _FAIL
) {
587 RT_TRACE(_module_rtl871x_xmit_c_
, _drv_err_
,
588 ("\npadapter->securitypriv.busetkipkey(%d) == _FAIL drop packet\n",
589 padapter
->securitypriv
.busetkipkey
));
595 RT_TRACE(_module_rtl871x_xmit_c_
, _drv_info_
, ("pattrib->encrypt=%d (_AES_)\n", pattrib
->encrypt
));
597 pattrib
->icv_len
= 8;
601 pattrib
->icv_len
= 0;
605 RT_TRACE(_module_rtl871x_xmit_c_
, _drv_info_
,
606 ("update_attrib: encrypt=%d securitypriv.sw_encrypt=%d\n",
607 pattrib
->encrypt
, padapter
->securitypriv
.sw_encrypt
));
609 if (pattrib
->encrypt
&&
610 (padapter
->securitypriv
.sw_encrypt
|| !psecuritypriv
->hw_decrypted
)) {
611 pattrib
->bswenc
= true;
612 RT_TRACE(_module_rtl871x_xmit_c_
, _drv_err_
,
613 ("update_attrib: encrypt=%d securitypriv.hw_decrypted=%d bswenc = true\n",
614 pattrib
->encrypt
, padapter
->securitypriv
.sw_encrypt
));
616 pattrib
->bswenc
= false;
617 RT_TRACE(_module_rtl871x_xmit_c_
, _drv_info_
, ("update_attrib: bswenc = false\n"));
620 update_attrib_phy_info(pattrib
, psta
);
628 static s32
xmitframe_addmic(struct adapter
*padapter
, struct xmit_frame
*pxmitframe
)
630 int curfragnum
, length
;
631 u8
*pframe
, *payload
, mic
[8];
632 struct mic_data micdata
;
633 struct sta_info
*stainfo
;
634 struct pkt_attrib
*pattrib
= &pxmitframe
->attrib
;
635 struct security_priv
*psecuritypriv
= &padapter
->securitypriv
;
636 struct xmit_priv
*pxmitpriv
= &padapter
->xmitpriv
;
637 u8 priority
[4] = {0x0, 0x0, 0x0, 0x0};
638 u8 hw_hdr_offset
= 0;
639 int bmcst
= IS_MCAST(pattrib
->ra
);
642 stainfo
= pattrib
->psta
;
644 stainfo
= rtw_get_stainfo(&padapter
->stapriv
, &pattrib
->ra
[0]);
647 hw_hdr_offset
= TXDESC_SIZE
+ (pxmitframe
->pkt_offset
* PACKET_OFFSET_SZ
);
649 if (pattrib
->encrypt
== _TKIP_
) {/* if (psecuritypriv->dot11PrivacyAlgrthm == _TKIP_PRIVACY_) */
650 /* encode mic code */
651 if (stainfo
!= NULL
) {
652 u8 null_key
[16] = {0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
653 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
656 pframe
= pxmitframe
->buf_addr
+ hw_hdr_offset
;
659 if (!memcmp(psecuritypriv
->dot118021XGrptxmickey
[psecuritypriv
->dot118021XGrpKeyid
].skey
, null_key
, 16))
661 /* start to calculate the mic code */
662 rtw_secmicsetkey(&micdata
, psecuritypriv
->dot118021XGrptxmickey
[psecuritypriv
->dot118021XGrpKeyid
].skey
);
664 if (!memcmp(&stainfo
->dot11tkiptxmickey
.skey
[0], null_key
, 16)) {
665 /* DbgPrint("\nxmitframe_addmic:stainfo->dot11tkiptxmickey == 0\n"); */
669 /* start to calculate the mic code */
670 rtw_secmicsetkey(&micdata
, &stainfo
->dot11tkiptxmickey
.skey
[0]);
673 if (pframe
[1]&1) { /* ToDS == 1 */
674 rtw_secmicappend(&micdata
, &pframe
[16], 6); /* DA */
675 if (pframe
[1]&2) /* From Ds == 1 */
676 rtw_secmicappend(&micdata
, &pframe
[24], 6);
678 rtw_secmicappend(&micdata
, &pframe
[10], 6);
679 } else { /* ToDS == 0 */
680 rtw_secmicappend(&micdata
, &pframe
[4], 6); /* DA */
681 if (pframe
[1]&2) /* From Ds == 1 */
682 rtw_secmicappend(&micdata
, &pframe
[16], 6);
684 rtw_secmicappend(&micdata
, &pframe
[10], 6);
688 priority
[0] = (u8
)pxmitframe
->attrib
.priority
;
690 rtw_secmicappend(&micdata
, &priority
[0], 4);
694 for (curfragnum
= 0; curfragnum
< pattrib
->nr_frags
; curfragnum
++) {
695 payload
= (u8
*)round_up((size_t)(payload
), 4);
696 RT_TRACE(_module_rtl871x_xmit_c_
, _drv_err_
,
697 ("=== curfragnum=%d, pframe = 0x%.2x, 0x%.2x, 0x%.2x, 0x%.2x, 0x%.2x, 0x%.2x, 0x%.2x, 0x%.2x,!!!\n",
698 curfragnum
, *payload
, *(payload
+1),
699 *(payload
+2), *(payload
+3),
700 *(payload
+4), *(payload
+5),
701 *(payload
+6), *(payload
+7)));
703 payload
= payload
+pattrib
->hdrlen
+pattrib
->iv_len
;
704 RT_TRACE(_module_rtl871x_xmit_c_
, _drv_err_
,
705 ("curfragnum=%d pattrib->hdrlen=%d pattrib->iv_len=%d",
706 curfragnum
, pattrib
->hdrlen
, pattrib
->iv_len
));
707 if ((curfragnum
+1) == pattrib
->nr_frags
) {
708 length
= pattrib
->last_txcmdsz
-pattrib
->hdrlen
-pattrib
->iv_len
-((pattrib
->bswenc
) ? pattrib
->icv_len
: 0);
709 rtw_secmicappend(&micdata
, payload
, length
);
710 payload
= payload
+length
;
712 length
= pxmitpriv
->frag_len
-pattrib
->hdrlen
-pattrib
->iv_len
-((pattrib
->bswenc
) ? pattrib
->icv_len
: 0);
713 rtw_secmicappend(&micdata
, payload
, length
);
714 payload
= payload
+length
+pattrib
->icv_len
;
715 RT_TRACE(_module_rtl871x_xmit_c_
, _drv_err_
, ("curfragnum=%d length=%d pattrib->icv_len=%d", curfragnum
, length
, pattrib
->icv_len
));
718 rtw_secgetmic(&micdata
, &(mic
[0]));
719 RT_TRACE(_module_rtl871x_xmit_c_
, _drv_err_
, ("xmitframe_addmic: before add mic code!!!\n"));
720 RT_TRACE(_module_rtl871x_xmit_c_
, _drv_err_
, ("xmitframe_addmic: pattrib->last_txcmdsz=%d!!!\n", pattrib
->last_txcmdsz
));
721 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\
722 mic[4]= 0x%.2x , mic[5]= 0x%.2x , mic[6]= 0x%.2x , mic[7]= 0x%.2x !!!!\n",
723 mic
[0], mic
[1], mic
[2], mic
[3], mic
[4], mic
[5], mic
[6], mic
[7]));
724 /* add mic code and add the mic code length in last_txcmdsz */
726 memcpy(payload
, &(mic
[0]), 8);
727 pattrib
->last_txcmdsz
+= 8;
729 RT_TRACE(_module_rtl871x_xmit_c_
, _drv_info_
, ("\n ======== last pkt ========\n"));
730 payload
= payload
-pattrib
->last_txcmdsz
+8;
731 for (curfragnum
= 0; curfragnum
< pattrib
->last_txcmdsz
; curfragnum
= curfragnum
+8)
732 RT_TRACE(_module_rtl871x_xmit_c_
, _drv_info_
,
733 (" %.2x, %.2x, %.2x, %.2x, %.2x, %.2x, %.2x, %.2x ",
734 *(payload
+curfragnum
), *(payload
+curfragnum
+1),
735 *(payload
+curfragnum
+2), *(payload
+curfragnum
+3),
736 *(payload
+curfragnum
+4), *(payload
+curfragnum
+5),
737 *(payload
+curfragnum
+6), *(payload
+curfragnum
+7)));
739 RT_TRACE(_module_rtl871x_xmit_c_
, _drv_err_
, ("xmitframe_addmic: rtw_get_stainfo==NULL!!!\n"));
747 static s32
xmitframe_swencrypt(struct adapter
*padapter
, struct xmit_frame
*pxmitframe
)
749 struct pkt_attrib
*pattrib
= &pxmitframe
->attrib
;
752 if (pattrib
->bswenc
) {
753 RT_TRACE(_module_rtl871x_xmit_c_
, _drv_alert_
, ("### xmitframe_swencrypt\n"));
754 switch (pattrib
->encrypt
) {
757 rtw_wep_encrypt(padapter
, (u8
*)pxmitframe
);
760 rtw_tkip_encrypt(padapter
, (u8
*)pxmitframe
);
763 rtw_aes_encrypt(padapter
, (u8
*)pxmitframe
);
769 RT_TRACE(_module_rtl871x_xmit_c_
, _drv_notice_
, ("### xmitframe_hwencrypt\n"));
776 s32
rtw_make_wlanhdr(struct adapter
*padapter
, u8
*hdr
, struct pkt_attrib
*pattrib
)
780 struct rtw_ieee80211_hdr
*pwlanhdr
= (struct rtw_ieee80211_hdr
*)hdr
;
781 struct mlme_priv
*pmlmepriv
= &padapter
->mlmepriv
;
782 struct qos_priv
*pqospriv
= &pmlmepriv
->qospriv
;
783 u8 qos_option
= false;
786 __le16
*fctrl
= &pwlanhdr
->frame_ctl
;
788 struct sta_info
*psta
;
790 int bmcst
= IS_MCAST(pattrib
->ra
);
794 psta
= pattrib
->psta
;
797 psta
= rtw_get_bcmc_stainfo(padapter
);
799 psta
= rtw_get_stainfo(&padapter
->stapriv
, pattrib
->ra
);
803 memset(hdr
, 0, WLANHDR_OFFSET
);
805 SetFrameSubType(fctrl
, pattrib
->subtype
);
807 if (pattrib
->subtype
& WIFI_DATA_TYPE
) {
808 if ((check_fwstate(pmlmepriv
, WIFI_STATION_STATE
) == true)) {
809 /* to_ds = 1, fr_ds = 0; */
810 /* Data transfer to AP */
812 memcpy(pwlanhdr
->addr1
, get_bssid(pmlmepriv
), ETH_ALEN
);
813 memcpy(pwlanhdr
->addr2
, pattrib
->src
, ETH_ALEN
);
814 memcpy(pwlanhdr
->addr3
, pattrib
->dst
, ETH_ALEN
);
816 if (pqospriv
->qos_option
)
818 } else if (check_fwstate(pmlmepriv
, WIFI_AP_STATE
)) {
819 /* to_ds = 0, fr_ds = 1; */
821 memcpy(pwlanhdr
->addr1
, pattrib
->dst
, ETH_ALEN
);
822 memcpy(pwlanhdr
->addr2
, get_bssid(pmlmepriv
), ETH_ALEN
);
823 memcpy(pwlanhdr
->addr3
, pattrib
->src
, ETH_ALEN
);
825 if (psta
->qos_option
)
827 } else if (check_fwstate(pmlmepriv
, WIFI_ADHOC_STATE
) ||
828 check_fwstate(pmlmepriv
, WIFI_ADHOC_MASTER_STATE
)) {
829 memcpy(pwlanhdr
->addr1
, pattrib
->dst
, ETH_ALEN
);
830 memcpy(pwlanhdr
->addr2
, pattrib
->src
, ETH_ALEN
);
831 memcpy(pwlanhdr
->addr3
, get_bssid(pmlmepriv
), ETH_ALEN
);
833 if (psta
->qos_option
)
836 RT_TRACE(_module_rtl871x_xmit_c_
, _drv_err_
, ("fw_state:%x is not allowed to xmit frame\n", get_fwstate(pmlmepriv
)));
844 if (pattrib
->encrypt
)
848 qc
= (unsigned short *)(hdr
+ pattrib
->hdrlen
- 2);
850 if (pattrib
->priority
)
851 SetPriority(qc
, pattrib
->priority
);
853 SetEOSP(qc
, pattrib
->eosp
);
855 SetAckpolicy(qc
, pattrib
->ack_policy
);
858 /* TODO: fill HT Control Field */
860 /* Update Seq Num will be handled by f/w */
862 psta
->sta_xmitpriv
.txseq_tid
[pattrib
->priority
]++;
863 psta
->sta_xmitpriv
.txseq_tid
[pattrib
->priority
] &= 0xFFF;
865 pattrib
->seqnum
= psta
->sta_xmitpriv
.txseq_tid
[pattrib
->priority
];
867 SetSeqNum(hdr
, pattrib
->seqnum
);
869 /* check if enable ampdu */
870 if (pattrib
->ht_en
&& psta
->htpriv
.ampdu_enable
) {
871 if (psta
->htpriv
.agg_enable_bitmap
& BIT(pattrib
->priority
))
872 pattrib
->ampdu_en
= true;
875 /* re-check if enable ampdu by BA_starting_seqctrl */
876 if (pattrib
->ampdu_en
) {
879 tx_seq
= psta
->BA_starting_seqctrl
[pattrib
->priority
& 0x0f];
881 /* check BA_starting_seqctrl */
882 if (SN_LESS(pattrib
->seqnum
, tx_seq
)) {
883 pattrib
->ampdu_en
= false;/* AGG BK */
884 } else if (SN_EQUAL(pattrib
->seqnum
, tx_seq
)) {
885 psta
->BA_starting_seqctrl
[pattrib
->priority
& 0x0f] = (tx_seq
+1)&0xfff;
887 pattrib
->ampdu_en
= true;/* AGG EN */
889 psta
->BA_starting_seqctrl
[pattrib
->priority
& 0x0f] = (pattrib
->seqnum
+1)&0xfff;
890 pattrib
->ampdu_en
= true;/* AGG EN */
900 s32
rtw_txframes_pending(struct adapter
*padapter
)
902 struct xmit_priv
*pxmitpriv
= &padapter
->xmitpriv
;
904 return (!list_empty(&pxmitpriv
->be_pending
.queue
) ||
905 !list_empty(&pxmitpriv
->bk_pending
.queue
) ||
906 !list_empty(&pxmitpriv
->vi_pending
.queue
) ||
907 !list_empty(&pxmitpriv
->vo_pending
.queue
));
910 s32
rtw_txframes_sta_ac_pending(struct adapter
*padapter
, struct pkt_attrib
*pattrib
)
912 struct sta_info
*psta
;
913 struct tx_servq
*ptxservq
;
914 int priority
= pattrib
->priority
;
916 psta
= pattrib
->psta
;
921 ptxservq
= &(psta
->sta_xmitpriv
.bk_q
);
925 ptxservq
= &(psta
->sta_xmitpriv
.vi_q
);
929 ptxservq
= &(psta
->sta_xmitpriv
.vo_q
);
934 ptxservq
= &(psta
->sta_xmitpriv
.be_q
);
938 return ptxservq
->qcnt
;
942 * Calculate wlan 802.11 packet MAX size from pkt_attrib
943 * This function doesn't consider fragment case
945 u32
rtw_calculate_wlan_pkt_size_by_attribue(struct pkt_attrib
*pattrib
)
949 len
= pattrib
->hdrlen
+ pattrib
->iv_len
; /* WLAN Header and IV */
950 len
+= SNAP_SIZE
+ sizeof(u16
); /* LLC */
951 len
+= pattrib
->pktlen
;
952 if (pattrib
->encrypt
== _TKIP_
)
954 len
+= ((pattrib
->bswenc
) ? pattrib
->icv_len
: 0); /* ICV */
961 This sub-routine will perform all the following:
963 1. remove 802.3 header.
964 2. create wlan_header, based on the info in pxmitframe
965 3. append sta's iv/ext-iv
967 5. move frag chunk from pframe to pxmitframe->mem
968 6. apply sw-encrypt, if necessary.
971 s32
rtw_xmitframe_coalesce(struct adapter
*padapter
, struct sk_buff
*pkt
, struct xmit_frame
*pxmitframe
)
973 struct pkt_file pktfile
;
974 s32 frg_inx
, frg_len
, mpdu_len
, llc_sz
, mem_sz
;
976 u8
*pframe
, *mem_start
;
978 struct sta_info
*psta
;
979 struct xmit_priv
*pxmitpriv
= &padapter
->xmitpriv
;
980 struct pkt_attrib
*pattrib
= &pxmitframe
->attrib
;
982 s32 bmcst
= IS_MCAST(pattrib
->ra
);
986 psta
= rtw_get_stainfo(&padapter
->stapriv
, pattrib
->ra
);
991 if (pxmitframe
->buf_addr
== NULL
) {
992 DBG_88E("==> %s buf_addr == NULL\n", __func__
);
996 pbuf_start
= pxmitframe
->buf_addr
;
998 hw_hdr_offset
= TXDESC_SIZE
+ (pxmitframe
->pkt_offset
* PACKET_OFFSET_SZ
);
1000 mem_start
= pbuf_start
+ hw_hdr_offset
;
1002 if (rtw_make_wlanhdr(padapter
, mem_start
, pattrib
) == _FAIL
) {
1003 RT_TRACE(_module_rtl871x_xmit_c_
, _drv_err_
, ("rtw_xmitframe_coalesce: rtw_make_wlanhdr fail; drop pkt\n"));
1004 DBG_88E("rtw_xmitframe_coalesce: rtw_make_wlanhdr fail; drop pkt\n");
1009 _rtw_open_pktfile(pkt
, &pktfile
);
1010 _rtw_pktfile_read(&pktfile
, NULL
, pattrib
->pkt_hdrlen
);
1013 frg_len
= pxmitpriv
->frag_len
- 4;/* 2346-4 = 2342 */
1022 SetMFrag(mem_start
);
1024 pframe
+= pattrib
->hdrlen
;
1025 mpdu_len
-= pattrib
->hdrlen
;
1027 /* adding icv, if necessary... */
1028 if (pattrib
->iv_len
) {
1029 switch (pattrib
->encrypt
) {
1032 WEP_IV(pattrib
->iv
, psta
->dot11txpn
, pattrib
->key_idx
);
1036 TKIP_IV(pattrib
->iv
, psta
->dot11txpn
, pattrib
->key_idx
);
1038 TKIP_IV(pattrib
->iv
, psta
->dot11txpn
, 0);
1042 AES_IV(pattrib
->iv
, psta
->dot11txpn
, pattrib
->key_idx
);
1044 AES_IV(pattrib
->iv
, psta
->dot11txpn
, 0);
1048 memcpy(pframe
, pattrib
->iv
, pattrib
->iv_len
);
1050 RT_TRACE(_module_rtl871x_xmit_c_
, _drv_notice_
,
1051 ("rtw_xmitframe_coalesce: keyid=%d pattrib->iv[3]=%.2x pframe=%.2x %.2x %.2x %.2x\n",
1052 padapter
->securitypriv
.dot11PrivacyKeyIndex
, pattrib
->iv
[3], *pframe
, *(pframe
+1), *(pframe
+2), *(pframe
+3)));
1054 pframe
+= pattrib
->iv_len
;
1056 mpdu_len
-= pattrib
->iv_len
;
1060 llc_sz
= rtw_put_snap(pframe
, pattrib
->ether_type
);
1065 if ((pattrib
->icv_len
> 0) && (pattrib
->bswenc
)) {
1066 mpdu_len
-= pattrib
->icv_len
;
1070 /* don't do fragment to broadcat/multicast packets */
1071 mem_sz
= _rtw_pktfile_read(&pktfile
, pframe
, pattrib
->pktlen
);
1073 mem_sz
= _rtw_pktfile_read(&pktfile
, pframe
, mpdu_len
);
1078 if ((pattrib
->icv_len
> 0) && (pattrib
->bswenc
)) {
1079 memcpy(pframe
, pattrib
->icv
, pattrib
->icv_len
);
1080 pframe
+= pattrib
->icv_len
;
1085 if (bmcst
|| rtw_endofpktfile(&pktfile
)) {
1086 pattrib
->nr_frags
= frg_inx
;
1088 pattrib
->last_txcmdsz
= pattrib
->hdrlen
+ pattrib
->iv_len
+ ((pattrib
->nr_frags
== 1) ? llc_sz
: 0) +
1089 ((pattrib
->bswenc
) ? pattrib
->icv_len
: 0) + mem_sz
;
1091 ClearMFrag(mem_start
);
1095 RT_TRACE(_module_rtl871x_xmit_c_
, _drv_err_
, ("%s: There're still something in packet!\n", __func__
));
1098 addr
= (size_t)(pframe
);
1100 mem_start
= (unsigned char *)round_up(addr
, 4) + hw_hdr_offset
;
1101 memcpy(mem_start
, pbuf_start
+ hw_hdr_offset
, pattrib
->hdrlen
);
1104 /* Frame is about to be encrypted. Forward it to the monitor first. */
1105 rtl88eu_mon_xmit_hook(padapter
->pmondev
, pxmitframe
, frg_len
);
1107 if (xmitframe_addmic(padapter
, pxmitframe
) == _FAIL
) {
1108 RT_TRACE(_module_rtl871x_xmit_c_
, _drv_err_
, ("xmitframe_addmic(padapter, pxmitframe) == _FAIL\n"));
1109 DBG_88E("xmitframe_addmic(padapter, pxmitframe) == _FAIL\n");
1114 xmitframe_swencrypt(padapter
, pxmitframe
);
1117 update_attrib_vcs_info(padapter
, pxmitframe
);
1119 pattrib
->vcs_mode
= NONE_VCS
;
1127 /* Logical Link Control(LLC) SubNetwork Attachment Point(SNAP) header
1128 * IEEE LLC/SNAP header contains 8 octets
1129 * First 3 octets comprise the LLC portion
1130 * SNAP portion, 5 octets, is divided into two fields:
1131 * Organizationally Unique Identifier(OUI), 3 octets,
1132 * type, defined by that organization, 2 octets.
1134 s32
rtw_put_snap(u8
*data
, u16 h_proto
)
1136 struct ieee80211_snap_hdr
*snap
;
1140 snap
= (struct ieee80211_snap_hdr
*)data
;
1145 if (h_proto
== 0x8137 || h_proto
== 0x80f3)
1150 snap
->oui
[0] = oui
[0];
1151 snap
->oui
[1] = oui
[1];
1152 snap
->oui
[2] = oui
[2];
1154 *(__be16
*)(data
+ SNAP_SIZE
) = htons(h_proto
);
1157 return SNAP_SIZE
+ sizeof(u16
);
1160 void rtw_update_protection(struct adapter
*padapter
, u8
*ie
, uint ie_len
)
1165 struct xmit_priv
*pxmitpriv
= &padapter
->xmitpriv
;
1166 struct registry_priv
*pregistrypriv
= &padapter
->registrypriv
;
1169 switch (pxmitpriv
->vcs_setting
) {
1171 pxmitpriv
->vcs
= NONE_VCS
;
1177 perp
= rtw_get_ie(ie
, _ERPINFO_IE_
, &erp_len
, ie_len
);
1179 pxmitpriv
->vcs
= NONE_VCS
;
1181 protection
= (*(perp
+ 2)) & BIT(1);
1183 if (pregistrypriv
->vcs_type
== RTS_CTS
)
1184 pxmitpriv
->vcs
= RTS_CTS
;
1186 pxmitpriv
->vcs
= CTS_TO_SELF
;
1188 pxmitpriv
->vcs
= NONE_VCS
;
1196 void rtw_count_tx_stats(struct adapter
*padapter
, struct xmit_frame
*pxmitframe
, int sz
)
1198 struct sta_info
*psta
= NULL
;
1199 struct stainfo_stats
*pstats
= NULL
;
1200 struct xmit_priv
*pxmitpriv
= &padapter
->xmitpriv
;
1201 struct mlme_priv
*pmlmepriv
= &padapter
->mlmepriv
;
1203 if ((pxmitframe
->frame_tag
&0x0f) == DATA_FRAMETAG
) {
1204 pxmitpriv
->tx_bytes
+= sz
;
1205 pmlmepriv
->LinkDetectInfo
.NumTxOkInPeriod
+= pxmitframe
->agg_num
;
1207 psta
= pxmitframe
->attrib
.psta
;
1209 pstats
= &psta
->sta_stats
;
1210 pstats
->tx_pkts
+= pxmitframe
->agg_num
;
1211 pstats
->tx_bytes
+= sz
;
1216 struct xmit_buf
*rtw_alloc_xmitbuf_ext(struct xmit_priv
*pxmitpriv
)
1219 struct xmit_buf
*pxmitbuf
;
1220 struct __queue
*pfree_queue
= &pxmitpriv
->free_xmit_extbuf_queue
;
1222 spin_lock_irqsave(&pfree_queue
->lock
, irql
);
1223 pxmitbuf
= list_first_entry_or_null(&pfree_queue
->queue
,
1224 struct xmit_buf
, list
);
1226 list_del_init(&pxmitbuf
->list
);
1227 pxmitpriv
->free_xmit_extbuf_cnt
--;
1228 pxmitbuf
->priv_data
= NULL
;
1229 /* pxmitbuf->ext_tag = true; */
1230 if (pxmitbuf
->sctx
) {
1231 DBG_88E("%s pxmitbuf->sctx is not NULL\n", __func__
);
1232 rtw_sctx_done_err(&pxmitbuf
->sctx
, RTW_SCTX_DONE_BUF_ALLOC
);
1235 spin_unlock_irqrestore(&pfree_queue
->lock
, irql
);
1240 s32
rtw_free_xmitbuf_ext(struct xmit_priv
*pxmitpriv
, struct xmit_buf
*pxmitbuf
)
1243 struct __queue
*pfree_queue
= &pxmitpriv
->free_xmit_extbuf_queue
;
1246 if (pxmitbuf
== NULL
)
1249 spin_lock_irqsave(&pfree_queue
->lock
, irql
);
1251 list_del_init(&pxmitbuf
->list
);
1253 list_add_tail(&(pxmitbuf
->list
), get_list_head(pfree_queue
));
1254 pxmitpriv
->free_xmit_extbuf_cnt
++;
1256 spin_unlock_irqrestore(&pfree_queue
->lock
, irql
);
1262 struct xmit_buf
*rtw_alloc_xmitbuf(struct xmit_priv
*pxmitpriv
)
1265 struct xmit_buf
*pxmitbuf
;
1266 struct __queue
*pfree_xmitbuf_queue
= &pxmitpriv
->free_xmitbuf_queue
;
1268 /* DBG_88E("+rtw_alloc_xmitbuf\n"); */
1270 spin_lock_irqsave(&pfree_xmitbuf_queue
->lock
, irql
);
1271 pxmitbuf
= list_first_entry_or_null(&pfree_xmitbuf_queue
->queue
,
1272 struct xmit_buf
, list
);
1274 list_del_init(&pxmitbuf
->list
);
1275 pxmitpriv
->free_xmitbuf_cnt
--;
1276 pxmitbuf
->priv_data
= NULL
;
1277 if (pxmitbuf
->sctx
) {
1278 DBG_88E("%s pxmitbuf->sctx is not NULL\n", __func__
);
1279 rtw_sctx_done_err(&pxmitbuf
->sctx
, RTW_SCTX_DONE_BUF_ALLOC
);
1282 spin_unlock_irqrestore(&pfree_xmitbuf_queue
->lock
, irql
);
1287 s32
rtw_free_xmitbuf(struct xmit_priv
*pxmitpriv
, struct xmit_buf
*pxmitbuf
)
1290 struct __queue
*pfree_xmitbuf_queue
= &pxmitpriv
->free_xmitbuf_queue
;
1292 if (pxmitbuf
== NULL
)
1295 if (pxmitbuf
->sctx
) {
1296 DBG_88E("%s pxmitbuf->sctx is not NULL\n", __func__
);
1297 rtw_sctx_done_err(&pxmitbuf
->sctx
, RTW_SCTX_DONE_BUF_FREE
);
1300 if (pxmitbuf
->ext_tag
) {
1301 rtw_free_xmitbuf_ext(pxmitpriv
, pxmitbuf
);
1303 spin_lock_irqsave(&pfree_xmitbuf_queue
->lock
, irql
);
1305 list_del_init(&pxmitbuf
->list
);
1307 list_add_tail(&(pxmitbuf
->list
), get_list_head(pfree_xmitbuf_queue
));
1309 pxmitpriv
->free_xmitbuf_cnt
++;
1310 spin_unlock_irqrestore(&pfree_xmitbuf_queue
->lock
, irql
);
1320 2. RXENTRY (rx_thread or RX_ISR/RX_CallBack)
1322 If we turn on USE_RXTHREAD, then, no need for critical section.
1323 Otherwise, we must use _enter/_exit critical to protect free_xmit_queue...
1325 Must be very very cautious...
1329 struct xmit_frame
*rtw_alloc_xmitframe(struct xmit_priv
*pxmitpriv
)
1330 /* _queue *pfree_xmit_queue) */
1333 Please remember to use all the osdep_service api,
1334 and lock/unlock or _enter/_exit critical to protect
1337 struct xmit_frame
*pxframe
;
1338 struct __queue
*pfree_xmit_queue
= &pxmitpriv
->free_xmit_queue
;
1340 spin_lock_bh(&pfree_xmit_queue
->lock
);
1341 pxframe
= list_first_entry_or_null(&pfree_xmit_queue
->queue
,
1342 struct xmit_frame
, list
);
1344 RT_TRACE(_module_rtl871x_xmit_c_
, _drv_info_
,
1345 ("rtw_alloc_xmitframe:%d\n",
1346 pxmitpriv
->free_xmitframe_cnt
));
1348 list_del_init(&pxframe
->list
);
1350 /* default value setting */
1351 pxmitpriv
->free_xmitframe_cnt
--;
1353 RT_TRACE(_module_rtl871x_xmit_c_
, _drv_info_
,
1354 ("rtw_alloc_xmitframe():free_xmitframe_cnt=%d\n",
1355 pxmitpriv
->free_xmitframe_cnt
));
1357 pxframe
->buf_addr
= NULL
;
1358 pxframe
->pxmitbuf
= NULL
;
1360 memset(&pxframe
->attrib
, 0, sizeof(struct pkt_attrib
));
1361 /* pxframe->attrib.psta = NULL; */
1363 pxframe
->frame_tag
= DATA_FRAMETAG
;
1365 pxframe
->pkt
= NULL
;
1366 pxframe
->pkt_offset
= 1;/* default use pkt_offset to fill tx desc */
1368 pxframe
->agg_num
= 1;
1369 pxframe
->ack_report
= 0;
1371 spin_unlock_bh(&pfree_xmit_queue
->lock
);
1376 s32
rtw_free_xmitframe(struct xmit_priv
*pxmitpriv
, struct xmit_frame
*pxmitframe
)
1378 struct __queue
*pfree_xmit_queue
= &pxmitpriv
->free_xmit_queue
;
1379 struct adapter
*padapter
= pxmitpriv
->adapter
;
1380 struct sk_buff
*pndis_pkt
= NULL
;
1383 if (pxmitframe
== NULL
) {
1384 RT_TRACE(_module_rtl871x_xmit_c_
, _drv_err_
, ("====== rtw_free_xmitframe():pxmitframe == NULL!!!!!!!!!!\n"));
1388 spin_lock_bh(&pfree_xmit_queue
->lock
);
1390 list_del_init(&pxmitframe
->list
);
1392 if (pxmitframe
->pkt
) {
1393 pndis_pkt
= pxmitframe
->pkt
;
1394 pxmitframe
->pkt
= NULL
;
1397 list_add_tail(&pxmitframe
->list
, get_list_head(pfree_xmit_queue
));
1399 pxmitpriv
->free_xmitframe_cnt
++;
1400 RT_TRACE(_module_rtl871x_xmit_c_
, _drv_debug_
, ("rtw_free_xmitframe():free_xmitframe_cnt=%d\n", pxmitpriv
->free_xmitframe_cnt
));
1402 spin_unlock_bh(&pfree_xmit_queue
->lock
);
1405 rtw_os_pkt_complete(padapter
, pndis_pkt
);
1413 void rtw_free_xmitframe_queue(struct xmit_priv
*pxmitpriv
, struct __queue
*pframequeue
)
1415 struct list_head
*plist
, *phead
;
1416 struct xmit_frame
*pxmitframe
;
1419 spin_lock_bh(&(pframequeue
->lock
));
1421 phead
= get_list_head(pframequeue
);
1422 plist
= phead
->next
;
1424 while (phead
!= plist
) {
1425 pxmitframe
= container_of(plist
, struct xmit_frame
, list
);
1427 plist
= plist
->next
;
1429 rtw_free_xmitframe(pxmitpriv
, pxmitframe
);
1431 spin_unlock_bh(&(pframequeue
->lock
));
1435 s32
rtw_xmitframe_enqueue(struct adapter
*padapter
, struct xmit_frame
*pxmitframe
)
1437 if (rtw_xmit_classifier(padapter
, pxmitframe
) == _FAIL
) {
1438 RT_TRACE(_module_rtl871x_xmit_c_
, _drv_err_
,
1439 ("rtw_xmitframe_enqueue: drop xmit pkt for classifier fail\n"));
1440 /* pxmitframe->pkt = NULL; */
1447 static struct xmit_frame
*dequeue_one_xmitframe(struct xmit_priv
*pxmitpriv
, struct hw_xmit
*phwxmit
, struct tx_servq
*ptxservq
, struct __queue
*pframe_queue
)
1449 struct list_head
*xmitframe_plist
, *xmitframe_phead
;
1450 struct xmit_frame
*pxmitframe
= NULL
;
1452 xmitframe_phead
= get_list_head(pframe_queue
);
1453 xmitframe_plist
= xmitframe_phead
->next
;
1455 if (xmitframe_phead
!= xmitframe_plist
) {
1456 pxmitframe
= container_of(xmitframe_plist
, struct xmit_frame
, list
);
1458 xmitframe_plist
= xmitframe_plist
->next
;
1460 list_del_init(&pxmitframe
->list
);
1467 struct xmit_frame
*rtw_dequeue_xframe(struct xmit_priv
*pxmitpriv
, struct hw_xmit
*phwxmit_i
, int entry
)
1469 struct list_head
*sta_plist
, *sta_phead
;
1470 struct hw_xmit
*phwxmit
;
1471 struct tx_servq
*ptxservq
= NULL
;
1472 struct __queue
*pframe_queue
= NULL
;
1473 struct xmit_frame
*pxmitframe
= NULL
;
1474 struct adapter
*padapter
= pxmitpriv
->adapter
;
1475 struct registry_priv
*pregpriv
= &padapter
->registrypriv
;
1479 inx
[0] = 0; inx
[1] = 1; inx
[2] = 2; inx
[3] = 3;
1481 if (pregpriv
->wifi_spec
== 1) {
1484 for (j
= 0; j
< 4; j
++)
1485 inx
[j
] = pxmitpriv
->wmm_para_seq
[j
];
1488 spin_lock_bh(&pxmitpriv
->lock
);
1490 for (i
= 0; i
< entry
; i
++) {
1491 phwxmit
= phwxmit_i
+ inx
[i
];
1493 sta_phead
= get_list_head(phwxmit
->sta_queue
);
1494 sta_plist
= sta_phead
->next
;
1496 while (sta_phead
!= sta_plist
) {
1497 ptxservq
= container_of(sta_plist
, struct tx_servq
, tx_pending
);
1499 pframe_queue
= &ptxservq
->sta_pending
;
1501 pxmitframe
= dequeue_one_xmitframe(pxmitpriv
, phwxmit
, ptxservq
, pframe_queue
);
1506 /* Remove sta node when there are no pending packets. */
1507 if (list_empty(&pframe_queue
->queue
)) /* must be done after get_next and before break */
1508 list_del_init(&ptxservq
->tx_pending
);
1512 sta_plist
= sta_plist
->next
;
1516 spin_unlock_bh(&pxmitpriv
->lock
);
1520 struct tx_servq
*rtw_get_sta_pending(struct adapter
*padapter
, struct sta_info
*psta
, int up
, u8
*ac
)
1522 struct tx_servq
*ptxservq
;
1527 ptxservq
= &(psta
->sta_xmitpriv
.bk_q
);
1529 RT_TRACE(_module_rtl871x_xmit_c_
, _drv_info_
, ("rtw_get_sta_pending : BK\n"));
1533 ptxservq
= &(psta
->sta_xmitpriv
.vi_q
);
1535 RT_TRACE(_module_rtl871x_xmit_c_
, _drv_info_
, ("rtw_get_sta_pending : VI\n"));
1539 ptxservq
= &(psta
->sta_xmitpriv
.vo_q
);
1541 RT_TRACE(_module_rtl871x_xmit_c_
, _drv_info_
, ("rtw_get_sta_pending : VO\n"));
1546 ptxservq
= &(psta
->sta_xmitpriv
.be_q
);
1548 RT_TRACE(_module_rtl871x_xmit_c_
, _drv_info_
, ("rtw_get_sta_pending : BE\n"));
1557 * Will enqueue pxmitframe to the proper queue,
1558 * and indicate it to xx_pending list.....
1560 s32
rtw_xmit_classifier(struct adapter
*padapter
, struct xmit_frame
*pxmitframe
)
1563 struct sta_info
*psta
;
1564 struct tx_servq
*ptxservq
;
1565 struct pkt_attrib
*pattrib
= &pxmitframe
->attrib
;
1566 struct sta_priv
*pstapriv
= &padapter
->stapriv
;
1567 struct hw_xmit
*phwxmits
= padapter
->xmitpriv
.hwxmits
;
1571 if (pattrib
->psta
) {
1572 psta
= pattrib
->psta
;
1574 psta
= rtw_get_stainfo(pstapriv
, pattrib
->ra
);
1579 DBG_88E("rtw_xmit_classifier: psta == NULL\n");
1580 RT_TRACE(_module_rtl871x_xmit_c_
, _drv_err_
, ("rtw_xmit_classifier: psta == NULL\n"));
1584 ptxservq
= rtw_get_sta_pending(padapter
, psta
, pattrib
->priority
, (u8
*)(&ac_index
));
1586 if (list_empty(&ptxservq
->tx_pending
))
1587 list_add_tail(&ptxservq
->tx_pending
, get_list_head(phwxmits
[ac_index
].sta_queue
));
1589 list_add_tail(&pxmitframe
->list
, get_list_head(&ptxservq
->sta_pending
));
1591 phwxmits
[ac_index
].accnt
++;
1598 void rtw_alloc_hwxmits(struct adapter
*padapter
)
1600 struct hw_xmit
*hwxmits
;
1601 struct xmit_priv
*pxmitpriv
= &padapter
->xmitpriv
;
1603 pxmitpriv
->hwxmit_entry
= HWXMIT_ENTRY
;
1605 pxmitpriv
->hwxmits
= kcalloc(pxmitpriv
->hwxmit_entry
,
1606 sizeof(struct hw_xmit
), GFP_KERNEL
);
1608 hwxmits
= pxmitpriv
->hwxmits
;
1610 hwxmits
[0] .sta_queue
= &pxmitpriv
->vo_pending
;
1611 hwxmits
[1] .sta_queue
= &pxmitpriv
->vi_pending
;
1612 hwxmits
[2] .sta_queue
= &pxmitpriv
->be_pending
;
1613 hwxmits
[3] .sta_queue
= &pxmitpriv
->bk_pending
;
1616 void rtw_free_hwxmits(struct adapter
*padapter
)
1618 struct hw_xmit
*hwxmits
;
1619 struct xmit_priv
*pxmitpriv
= &padapter
->xmitpriv
;
1621 hwxmits
= pxmitpriv
->hwxmits
;
1625 void rtw_init_hwxmits(struct hw_xmit
*phwxmit
, int entry
)
1628 for (i
= 0; i
< entry
; i
++, phwxmit
++)
1632 u32
rtw_get_ff_hwaddr(struct xmit_frame
*pxmitframe
)
1635 struct pkt_attrib
*pattrib
= &pxmitframe
->attrib
;
1637 switch (pattrib
->qsel
) {
1640 addr
= BE_QUEUE_INX
;
1644 addr
= BK_QUEUE_INX
;
1648 addr
= VI_QUEUE_INX
;
1652 addr
= VO_QUEUE_INX
;
1655 addr
= BCN_QUEUE_INX
;
1657 case 0x11:/* BC/MC in PS (HIQ) */
1658 addr
= HIGH_QUEUE_INX
;
1662 addr
= MGT_QUEUE_INX
;
1669 static void do_queue_select(struct adapter
*padapter
, struct pkt_attrib
*pattrib
)
1673 qsel
= pattrib
->priority
;
1674 RT_TRACE(_module_rtl871x_xmit_c_
, _drv_info_
, ("### do_queue_select priority=%d , qsel = %d\n", pattrib
->priority
, qsel
));
1676 pattrib
->qsel
= qsel
;
1680 * The main transmit(tx) entry
1684 * 0 success, hardware will handle this xmit frame(packet)
1687 s32
rtw_xmit(struct adapter
*padapter
, struct sk_buff
**ppkt
)
1689 struct xmit_priv
*pxmitpriv
= &padapter
->xmitpriv
;
1690 struct xmit_frame
*pxmitframe
= NULL
;
1693 pxmitframe
= rtw_alloc_xmitframe(pxmitpriv
);
1694 if (pxmitframe
== NULL
) {
1695 RT_TRACE(_module_xmit_osdep_c_
, _drv_err_
, ("rtw_xmit: no more pxmitframe\n"));
1696 DBG_88E("DBG_TX_DROP_FRAME %s no more pxmitframe\n", __func__
);
1700 res
= update_attrib(padapter
, *ppkt
, &pxmitframe
->attrib
);
1703 RT_TRACE(_module_xmit_osdep_c_
, _drv_err_
, ("rtw_xmit: update attrib fail\n"));
1704 rtw_free_xmitframe(pxmitpriv
, pxmitframe
);
1707 pxmitframe
->pkt
= *ppkt
;
1709 rtw_led_control(padapter
, LED_CTL_TX
);
1711 do_queue_select(padapter
, &pxmitframe
->attrib
);
1713 #ifdef CONFIG_88EU_AP_MODE
1714 spin_lock_bh(&pxmitpriv
->lock
);
1715 if (xmitframe_enqueue_for_sleeping_sta(padapter
, pxmitframe
)) {
1716 spin_unlock_bh(&pxmitpriv
->lock
);
1719 spin_unlock_bh(&pxmitpriv
->lock
);
1722 if (rtw_hal_xmit(padapter
, pxmitframe
) == false)
1728 #if defined(CONFIG_88EU_AP_MODE)
1730 int xmitframe_enqueue_for_sleeping_sta(struct adapter
*padapter
, struct xmit_frame
*pxmitframe
)
1733 struct sta_info
*psta
= NULL
;
1734 struct sta_priv
*pstapriv
= &padapter
->stapriv
;
1735 struct pkt_attrib
*pattrib
= &pxmitframe
->attrib
;
1736 struct mlme_priv
*pmlmepriv
= &padapter
->mlmepriv
;
1737 int bmcst
= IS_MCAST(pattrib
->ra
);
1739 if (check_fwstate(pmlmepriv
, WIFI_AP_STATE
) == false)
1743 psta
= pattrib
->psta
;
1745 psta
= rtw_get_stainfo(pstapriv
, pattrib
->ra
);
1750 if (pattrib
->triggered
== 1) {
1752 pattrib
->qsel
= 0x11;/* HIQ */
1757 spin_lock_bh(&psta
->sleep_q
.lock
);
1759 if (pstapriv
->sta_dz_bitmap
) {/* if any one sta is in ps mode */
1760 list_del_init(&pxmitframe
->list
);
1762 list_add_tail(&pxmitframe
->list
, get_list_head(&psta
->sleep_q
));
1766 pstapriv
->tim_bitmap
|= BIT(0);/* */
1767 pstapriv
->sta_dz_bitmap
|= BIT(0);
1769 update_beacon(padapter
, _TIM_IE_
, NULL
, false);/* tx bc/mc packets after update bcn */
1774 spin_unlock_bh(&psta
->sleep_q
.lock
);
1779 spin_lock_bh(&psta
->sleep_q
.lock
);
1781 if (psta
->state
&WIFI_SLEEP_STATE
) {
1784 if (pstapriv
->sta_dz_bitmap
&BIT(psta
->aid
)) {
1785 list_del_init(&pxmitframe
->list
);
1787 list_add_tail(&pxmitframe
->list
, get_list_head(&psta
->sleep_q
));
1791 switch (pattrib
->priority
) {
1794 wmmps_ac
= psta
->uapsd_bk
&BIT(0);
1798 wmmps_ac
= psta
->uapsd_vi
&BIT(0);
1802 wmmps_ac
= psta
->uapsd_vo
&BIT(0);
1807 wmmps_ac
= psta
->uapsd_be
&BIT(0);
1812 psta
->sleepq_ac_len
++;
1814 if (((psta
->has_legacy_ac
) && (!wmmps_ac
)) ||
1815 ((!psta
->has_legacy_ac
) && (wmmps_ac
))) {
1816 pstapriv
->tim_bitmap
|= BIT(psta
->aid
);
1818 if (psta
->sleepq_len
== 1) {
1819 /* update BCN for TIM IE */
1820 update_beacon(padapter
, _TIM_IE_
, NULL
, false);
1827 spin_unlock_bh(&psta
->sleep_q
.lock
);
1832 static void dequeue_xmitframes_to_sleeping_queue(struct adapter
*padapter
, struct sta_info
*psta
, struct __queue
*pframequeue
)
1834 struct list_head
*plist
, *phead
;
1836 struct tx_servq
*ptxservq
;
1837 struct pkt_attrib
*pattrib
;
1838 struct xmit_frame
*pxmitframe
;
1839 struct hw_xmit
*phwxmits
= padapter
->xmitpriv
.hwxmits
;
1841 phead
= get_list_head(pframequeue
);
1842 plist
= phead
->next
;
1844 while (phead
!= plist
) {
1845 pxmitframe
= container_of(plist
, struct xmit_frame
, list
);
1847 plist
= plist
->next
;
1849 xmitframe_enqueue_for_sleeping_sta(padapter
, pxmitframe
);
1851 pattrib
= &pxmitframe
->attrib
;
1853 ptxservq
= rtw_get_sta_pending(padapter
, psta
, pattrib
->priority
, (u8
*)(&ac_index
));
1856 phwxmits
[ac_index
].accnt
--;
1860 void stop_sta_xmit(struct adapter
*padapter
, struct sta_info
*psta
)
1862 struct sta_info
*psta_bmc
;
1863 struct sta_xmit_priv
*pstaxmitpriv
;
1864 struct sta_priv
*pstapriv
= &padapter
->stapriv
;
1865 struct xmit_priv
*pxmitpriv
= &padapter
->xmitpriv
;
1867 pstaxmitpriv
= &psta
->sta_xmitpriv
;
1869 /* for BC/MC Frames */
1870 psta_bmc
= rtw_get_bcmc_stainfo(padapter
);
1872 spin_lock_bh(&pxmitpriv
->lock
);
1874 psta
->state
|= WIFI_SLEEP_STATE
;
1876 pstapriv
->sta_dz_bitmap
|= BIT(psta
->aid
);
1878 dequeue_xmitframes_to_sleeping_queue(padapter
, psta
, &pstaxmitpriv
->vo_q
.sta_pending
);
1879 list_del_init(&(pstaxmitpriv
->vo_q
.tx_pending
));
1881 dequeue_xmitframes_to_sleeping_queue(padapter
, psta
, &pstaxmitpriv
->vi_q
.sta_pending
);
1882 list_del_init(&(pstaxmitpriv
->vi_q
.tx_pending
));
1884 dequeue_xmitframes_to_sleeping_queue(padapter
, psta
, &pstaxmitpriv
->be_q
.sta_pending
);
1885 list_del_init(&(pstaxmitpriv
->be_q
.tx_pending
));
1887 dequeue_xmitframes_to_sleeping_queue(padapter
, psta
, &pstaxmitpriv
->bk_q
.sta_pending
);
1888 list_del_init(&(pstaxmitpriv
->bk_q
.tx_pending
));
1890 /* for BC/MC Frames */
1891 pstaxmitpriv
= &psta_bmc
->sta_xmitpriv
;
1892 dequeue_xmitframes_to_sleeping_queue(padapter
, psta_bmc
, &pstaxmitpriv
->be_q
.sta_pending
);
1893 list_del_init(&(pstaxmitpriv
->be_q
.tx_pending
));
1895 spin_unlock_bh(&pxmitpriv
->lock
);
1898 void wakeup_sta_to_xmit(struct adapter
*padapter
, struct sta_info
*psta
)
1900 u8 update_mask
= 0, wmmps_ac
= 0;
1901 struct sta_info
*psta_bmc
;
1902 struct list_head
*xmitframe_plist
, *xmitframe_phead
;
1903 struct xmit_frame
*pxmitframe
= NULL
;
1904 struct sta_priv
*pstapriv
= &padapter
->stapriv
;
1906 spin_lock_bh(&psta
->sleep_q
.lock
);
1908 xmitframe_phead
= get_list_head(&psta
->sleep_q
);
1909 xmitframe_plist
= xmitframe_phead
->next
;
1911 while (xmitframe_phead
!= xmitframe_plist
) {
1912 pxmitframe
= container_of(xmitframe_plist
, struct xmit_frame
, list
);
1914 xmitframe_plist
= xmitframe_plist
->next
;
1916 list_del_init(&pxmitframe
->list
);
1918 switch (pxmitframe
->attrib
.priority
) {
1921 wmmps_ac
= psta
->uapsd_bk
&BIT(1);
1925 wmmps_ac
= psta
->uapsd_vi
&BIT(1);
1929 wmmps_ac
= psta
->uapsd_vo
&BIT(1);
1934 wmmps_ac
= psta
->uapsd_be
&BIT(1);
1939 if (psta
->sleepq_len
> 0)
1940 pxmitframe
->attrib
.mdata
= 1;
1942 pxmitframe
->attrib
.mdata
= 0;
1945 psta
->sleepq_ac_len
--;
1946 if (psta
->sleepq_ac_len
> 0) {
1947 pxmitframe
->attrib
.mdata
= 1;
1948 pxmitframe
->attrib
.eosp
= 0;
1950 pxmitframe
->attrib
.mdata
= 0;
1951 pxmitframe
->attrib
.eosp
= 1;
1955 pxmitframe
->attrib
.triggered
= 1;
1957 spin_unlock_bh(&psta
->sleep_q
.lock
);
1958 if (rtw_hal_xmit(padapter
, pxmitframe
))
1959 rtw_os_xmit_complete(padapter
, pxmitframe
);
1960 spin_lock_bh(&psta
->sleep_q
.lock
);
1963 if (psta
->sleepq_len
== 0) {
1964 pstapriv
->tim_bitmap
&= ~BIT(psta
->aid
);
1966 update_mask
= BIT(0);
1968 if (psta
->state
&WIFI_SLEEP_STATE
)
1969 psta
->state
^= WIFI_SLEEP_STATE
;
1971 if (psta
->state
& WIFI_STA_ALIVE_CHK_STATE
) {
1972 psta
->expire_to
= pstapriv
->expire_to
;
1973 psta
->state
^= WIFI_STA_ALIVE_CHK_STATE
;
1976 pstapriv
->sta_dz_bitmap
&= ~BIT(psta
->aid
);
1979 spin_unlock_bh(&psta
->sleep_q
.lock
);
1981 /* for BC/MC Frames */
1982 psta_bmc
= rtw_get_bcmc_stainfo(padapter
);
1986 if ((pstapriv
->sta_dz_bitmap
&0xfffe) == 0x0) { /* no any sta in ps mode */
1987 spin_lock_bh(&psta_bmc
->sleep_q
.lock
);
1989 xmitframe_phead
= get_list_head(&psta_bmc
->sleep_q
);
1990 xmitframe_plist
= xmitframe_phead
->next
;
1992 while (xmitframe_phead
!= xmitframe_plist
) {
1993 pxmitframe
= container_of(xmitframe_plist
, struct xmit_frame
, list
);
1995 xmitframe_plist
= xmitframe_plist
->next
;
1997 list_del_init(&pxmitframe
->list
);
1999 psta_bmc
->sleepq_len
--;
2000 if (psta_bmc
->sleepq_len
> 0)
2001 pxmitframe
->attrib
.mdata
= 1;
2003 pxmitframe
->attrib
.mdata
= 0;
2005 pxmitframe
->attrib
.triggered
= 1;
2007 spin_unlock_bh(&psta_bmc
->sleep_q
.lock
);
2008 if (rtw_hal_xmit(padapter
, pxmitframe
))
2009 rtw_os_xmit_complete(padapter
, pxmitframe
);
2010 spin_lock_bh(&psta_bmc
->sleep_q
.lock
);
2013 if (psta_bmc
->sleepq_len
== 0) {
2014 pstapriv
->tim_bitmap
&= ~BIT(0);
2015 pstapriv
->sta_dz_bitmap
&= ~BIT(0);
2017 update_mask
|= BIT(1);
2020 spin_unlock_bh(&psta_bmc
->sleep_q
.lock
);
2024 update_beacon(padapter
, _TIM_IE_
, NULL
, false);
2027 void xmit_delivery_enabled_frames(struct adapter
*padapter
, struct sta_info
*psta
)
2030 struct list_head
*xmitframe_plist
, *xmitframe_phead
;
2031 struct xmit_frame
*pxmitframe
= NULL
;
2032 struct sta_priv
*pstapriv
= &padapter
->stapriv
;
2034 spin_lock_bh(&psta
->sleep_q
.lock
);
2036 xmitframe_phead
= get_list_head(&psta
->sleep_q
);
2037 xmitframe_plist
= xmitframe_phead
->next
;
2039 while (xmitframe_phead
!= xmitframe_plist
) {
2040 pxmitframe
= container_of(xmitframe_plist
, struct xmit_frame
, list
);
2042 xmitframe_plist
= xmitframe_plist
->next
;
2044 switch (pxmitframe
->attrib
.priority
) {
2047 wmmps_ac
= psta
->uapsd_bk
&BIT(1);
2051 wmmps_ac
= psta
->uapsd_vi
&BIT(1);
2055 wmmps_ac
= psta
->uapsd_vo
&BIT(1);
2060 wmmps_ac
= psta
->uapsd_be
&BIT(1);
2067 list_del_init(&pxmitframe
->list
);
2070 psta
->sleepq_ac_len
--;
2072 if (psta
->sleepq_ac_len
> 0) {
2073 pxmitframe
->attrib
.mdata
= 1;
2074 pxmitframe
->attrib
.eosp
= 0;
2076 pxmitframe
->attrib
.mdata
= 0;
2077 pxmitframe
->attrib
.eosp
= 1;
2080 pxmitframe
->attrib
.triggered
= 1;
2082 if (rtw_hal_xmit(padapter
, pxmitframe
) == true)
2083 rtw_os_xmit_complete(padapter
, pxmitframe
);
2085 if ((psta
->sleepq_ac_len
== 0) && (!psta
->has_legacy_ac
) && (wmmps_ac
)) {
2086 pstapriv
->tim_bitmap
&= ~BIT(psta
->aid
);
2088 /* update BCN for TIM IE */
2089 update_beacon(padapter
, _TIM_IE_
, NULL
, false);
2093 spin_unlock_bh(&psta
->sleep_q
.lock
);
2098 void rtw_sctx_init(struct submit_ctx
*sctx
, int timeout_ms
)
2100 sctx
->timeout_ms
= timeout_ms
;
2101 sctx
->submit_time
= jiffies
;
2102 init_completion(&sctx
->done
);
2103 sctx
->status
= RTW_SCTX_SUBMITTED
;
2106 int rtw_sctx_wait(struct submit_ctx
*sctx
)
2109 unsigned long expire
;
2112 expire
= sctx
->timeout_ms
? msecs_to_jiffies(sctx
->timeout_ms
) : MAX_SCHEDULE_TIMEOUT
;
2113 if (!wait_for_completion_timeout(&sctx
->done
, expire
)) {
2114 /* timeout, do something?? */
2115 status
= RTW_SCTX_DONE_TIMEOUT
;
2116 DBG_88E("%s timeout\n", __func__
);
2118 status
= sctx
->status
;
2121 if (status
== RTW_SCTX_DONE_SUCCESS
)
2127 static bool rtw_sctx_chk_waring_status(int status
)
2130 case RTW_SCTX_DONE_UNKNOWN
:
2131 case RTW_SCTX_DONE_BUF_ALLOC
:
2132 case RTW_SCTX_DONE_BUF_FREE
:
2134 case RTW_SCTX_DONE_DRV_STOP
:
2135 case RTW_SCTX_DONE_DEV_REMOVE
:
2142 void rtw_sctx_done_err(struct submit_ctx
**sctx
, int status
)
2145 if (rtw_sctx_chk_waring_status(status
))
2146 DBG_88E("%s status:%d\n", __func__
, status
);
2147 (*sctx
)->status
= status
;
2148 complete(&((*sctx
)->done
));
2153 int rtw_ack_tx_wait(struct xmit_priv
*pxmitpriv
, u32 timeout_ms
)
2155 struct submit_ctx
*pack_tx_ops
= &pxmitpriv
->ack_tx_ops
;
2157 pack_tx_ops
->submit_time
= jiffies
;
2158 pack_tx_ops
->timeout_ms
= timeout_ms
;
2159 pack_tx_ops
->status
= RTW_SCTX_SUBMITTED
;
2161 return rtw_sctx_wait(pack_tx_ops
);
2164 void rtw_ack_tx_done(struct xmit_priv
*pxmitpriv
, int status
)
2166 struct submit_ctx
*pack_tx_ops
= &pxmitpriv
->ack_tx_ops
;
2168 if (pxmitpriv
->ack_tx
)
2169 rtw_sctx_done_err(&pack_tx_ops
, status
);
2171 DBG_88E("%s ack_tx not set\n", __func__
);