tx.c

  1// SPDX-License-Identifier: GPL-2.0 OR BSD-3-Clause
  2/* Copyright(c) 2018-2019  Realtek Corporation
  3 */
  4
  5#include "main.h"
  6#include "tx.h"
  7#include "fw.h"
  8#include "ps.h"
  9#include "debug.h"
 10
 11static
 12void rtw_tx_stats(struct rtw_dev *rtwdev, struct ieee80211_vif *vif,
 13		  struct sk_buff *skb)
 14{
 15	struct ieee80211_hdr *hdr;
 16	struct rtw_vif *rtwvif;
 17
 18	hdr = (struct ieee80211_hdr *)skb->data;
 19
 20	if (!ieee80211_is_data(hdr->frame_control))
 21		return;
 22
 23	if (!is_broadcast_ether_addr(hdr->addr1) &&
 24	    !is_multicast_ether_addr(hdr->addr1)) {
 25		rtwdev->stats.tx_unicast += skb->len;
 26		rtwdev->stats.tx_cnt++;
 27		if (vif) {
 28			rtwvif = (struct rtw_vif *)vif->drv_priv;
 29			rtwvif->stats.tx_unicast += skb->len;
 30			rtwvif->stats.tx_cnt++;
 31		}
 32	}
 33}
 34
 35void rtw_tx_fill_tx_desc(struct rtw_dev *rtwdev,
 36			 struct rtw_tx_pkt_info *pkt_info, struct sk_buff *skb)
 37{
 38	struct rtw_tx_desc *tx_desc = (struct rtw_tx_desc *)skb->data;
 39	bool more_data = false;
 40
 41	if (pkt_info->qsel == TX_DESC_QSEL_HIGH)
 42		more_data = true;
 43
 44	tx_desc->w0 = le32_encode_bits(pkt_info->tx_pkt_size, RTW_TX_DESC_W0_TXPKTSIZE) |
 45		      le32_encode_bits(pkt_info->offset, RTW_TX_DESC_W0_OFFSET) |
 46		      le32_encode_bits(pkt_info->bmc, RTW_TX_DESC_W0_BMC) |
 47		      le32_encode_bits(pkt_info->ls, RTW_TX_DESC_W0_LS) |
 48		      le32_encode_bits(pkt_info->dis_qselseq, RTW_TX_DESC_W0_DISQSELSEQ);
 49
 50	tx_desc->w1 = le32_encode_bits(pkt_info->mac_id, RTW_TX_DESC_W1_MACID) |
 51		      le32_encode_bits(pkt_info->qsel, RTW_TX_DESC_W1_QSEL) |
 52		      le32_encode_bits(pkt_info->rate_id, RTW_TX_DESC_W1_RATE_ID) |
 53		      le32_encode_bits(pkt_info->sec_type, RTW_TX_DESC_W1_SEC_TYPE) |
 54		      le32_encode_bits(pkt_info->pkt_offset, RTW_TX_DESC_W1_PKT_OFFSET) |
 55		      le32_encode_bits(more_data, RTW_TX_DESC_W1_MORE_DATA);
 56
 57	tx_desc->w2 = le32_encode_bits(pkt_info->ampdu_en, RTW_TX_DESC_W2_AGG_EN) |
 58		      le32_encode_bits(pkt_info->report, RTW_TX_DESC_W2_SPE_RPT) |
 59		      le32_encode_bits(pkt_info->ampdu_density, RTW_TX_DESC_W2_AMPDU_DEN) |
 60		      le32_encode_bits(pkt_info->bt_null, RTW_TX_DESC_W2_BT_NULL);
 61
 62	tx_desc->w3 = le32_encode_bits(pkt_info->hw_ssn_sel, RTW_TX_DESC_W3_HW_SSN_SEL) |
 63		      le32_encode_bits(pkt_info->use_rate, RTW_TX_DESC_W3_USE_RATE) |
 64		      le32_encode_bits(pkt_info->dis_rate_fallback, RTW_TX_DESC_W3_DISDATAFB) |
 65		      le32_encode_bits(pkt_info->rts, RTW_TX_DESC_W3_USE_RTS) |
 66		      le32_encode_bits(pkt_info->nav_use_hdr, RTW_TX_DESC_W3_NAVUSEHDR) |
 67		      le32_encode_bits(pkt_info->ampdu_factor, RTW_TX_DESC_W3_MAX_AGG_NUM);
 68
 69	tx_desc->w4 = le32_encode_bits(pkt_info->rate, RTW_TX_DESC_W4_DATARATE);
 70
 71	if (rtwdev->chip->old_datarate_fb_limit)
 72		tx_desc->w4 |= le32_encode_bits(0x1f, RTW_TX_DESC_W4_DATARATE_FB_LIMIT);
 73
 74	tx_desc->w5 = le32_encode_bits(pkt_info->short_gi, RTW_TX_DESC_W5_DATA_SHORT) |
 75		      le32_encode_bits(pkt_info->bw, RTW_TX_DESC_W5_DATA_BW) |
 76		      le32_encode_bits(pkt_info->ldpc, RTW_TX_DESC_W5_DATA_LDPC) |
 77		      le32_encode_bits(pkt_info->stbc, RTW_TX_DESC_W5_DATA_STBC);
 78
 79	tx_desc->w6 = le32_encode_bits(pkt_info->sn, RTW_TX_DESC_W6_SW_DEFINE);
 80
 81	tx_desc->w8 = le32_encode_bits(pkt_info->en_hwseq, RTW_TX_DESC_W8_EN_HWSEQ);
 82
 83	tx_desc->w9 = le32_encode_bits(pkt_info->seq, RTW_TX_DESC_W9_SW_SEQ);
 84
 85	if (pkt_info->rts) {
 86		tx_desc->w4 |= le32_encode_bits(DESC_RATE24M, RTW_TX_DESC_W4_RTSRATE);
 87		tx_desc->w5 |= le32_encode_bits(1, RTW_TX_DESC_W5_DATA_RTS_SHORT);
 88	}
 89
 90	if (pkt_info->tim_offset)
 91		tx_desc->w9 |= le32_encode_bits(1, RTW_TX_DESC_W9_TIM_EN) |
 92			       le32_encode_bits(pkt_info->tim_offset, RTW_TX_DESC_W9_TIM_OFFSET);
 93}
 94EXPORT_SYMBOL(rtw_tx_fill_tx_desc);
 95
 96static u8 get_tx_ampdu_factor(struct ieee80211_sta *sta)
 97{
 98	u8 exp = sta->deflink.ht_cap.ampdu_factor;
 99
100	/* the least ampdu factor is 8K, and the value in the tx desc is the
101	 * max aggregation num, which represents val * 2 packets can be
102	 * aggregated in an AMPDU, so here we should use 8/2=4 as the base
103	 */
104	return (BIT(2) << exp) - 1;
105}
106
107static u8 get_tx_ampdu_density(struct ieee80211_sta *sta)
108{
109	return sta->deflink.ht_cap.ampdu_density;
110}
111
112static u8 get_highest_ht_tx_rate(struct rtw_dev *rtwdev,
113				 struct ieee80211_sta *sta)
114{
115	u8 rate;
116
117	if (rtwdev->hal.rf_type == RF_2T2R && sta->deflink.ht_cap.mcs.rx_mask[1] != 0)
118		rate = DESC_RATEMCS15;
119	else
120		rate = DESC_RATEMCS7;
121
122	return rate;
123}
124
125static u8 get_highest_vht_tx_rate(struct rtw_dev *rtwdev,
126				  struct ieee80211_sta *sta)
127{
128	struct rtw_efuse *efuse = &rtwdev->efuse;
129	u8 rate;
130	u16 tx_mcs_map;
131
132	tx_mcs_map = le16_to_cpu(sta->deflink.vht_cap.vht_mcs.tx_mcs_map);
133	if (efuse->hw_cap.nss == 1) {
134		switch (tx_mcs_map & 0x3) {
135		case IEEE80211_VHT_MCS_SUPPORT_0_7:
136			rate = DESC_RATEVHT1SS_MCS7;
137			break;
138		case IEEE80211_VHT_MCS_SUPPORT_0_8:
139			rate = DESC_RATEVHT1SS_MCS8;
140			break;
141		default:
142		case IEEE80211_VHT_MCS_SUPPORT_0_9:
143			rate = DESC_RATEVHT1SS_MCS9;
144			break;
145		}
146	} else if (efuse->hw_cap.nss >= 2) {
147		switch ((tx_mcs_map & 0xc) >> 2) {
148		case IEEE80211_VHT_MCS_SUPPORT_0_7:
149			rate = DESC_RATEVHT2SS_MCS7;
150			break;
151		case IEEE80211_VHT_MCS_SUPPORT_0_8:
152			rate = DESC_RATEVHT2SS_MCS8;
153			break;
154		default:
155		case IEEE80211_VHT_MCS_SUPPORT_0_9:
156			rate = DESC_RATEVHT2SS_MCS9;
157			break;
158		}
159	} else {
160		rate = DESC_RATEVHT1SS_MCS9;
161	}
162
163	return rate;
164}
165
166static void rtw_tx_report_enable(struct rtw_dev *rtwdev,
167				 struct rtw_tx_pkt_info *pkt_info)
168{
169	struct rtw_tx_report *tx_report = &rtwdev->tx_report;
170
171	/* [11:8], reserved, fills with zero
172	 * [7:2],  tx report sequence number
173	 * [1:0],  firmware use, fills with zero
174	 */
175	pkt_info->sn = (atomic_inc_return(&tx_report->sn) << 2) & 0xfc;
176	pkt_info->report = true;
177}
178
179void rtw_tx_report_purge_timer(struct timer_list *t)
180{
181	struct rtw_dev *rtwdev = timer_container_of(rtwdev, t,
182						    tx_report.purge_timer);
183	struct rtw_tx_report *tx_report = &rtwdev->tx_report;
184	unsigned long flags;
185
186	if (skb_queue_len(&tx_report->queue) == 0)
187		return;
188
189	rtw_warn(rtwdev, "failed to get tx report from firmware\n");
190
191	spin_lock_irqsave(&tx_report->q_lock, flags);
192	skb_queue_purge(&tx_report->queue);
193	spin_unlock_irqrestore(&tx_report->q_lock, flags);
194}
195
196void rtw_tx_report_enqueue(struct rtw_dev *rtwdev, struct sk_buff *skb, u8 sn)
197{
198	struct rtw_tx_report *tx_report = &rtwdev->tx_report;
199	unsigned long flags;
200	u8 *drv_data;
201
202	/* pass sn to tx report handler through driver data */
203	drv_data = (u8 *)IEEE80211_SKB_CB(skb)->status.status_driver_data;
204	*drv_data = sn;
205
206	spin_lock_irqsave(&tx_report->q_lock, flags);
207	__skb_queue_tail(&tx_report->queue, skb);
208	spin_unlock_irqrestore(&tx_report->q_lock, flags);
209
210	mod_timer(&tx_report->purge_timer, jiffies + RTW_TX_PROBE_TIMEOUT);
211}
212EXPORT_SYMBOL(rtw_tx_report_enqueue);
213
214static void rtw_tx_report_tx_status(struct rtw_dev *rtwdev,
215				    struct sk_buff *skb, bool acked)
216{
217	struct ieee80211_tx_info *info;
218
219	info = IEEE80211_SKB_CB(skb);
220	ieee80211_tx_info_clear_status(info);
221	if (acked)
222		info->flags |= IEEE80211_TX_STAT_ACK;
223	else
224		info->flags &= ~IEEE80211_TX_STAT_ACK;
225
226	ieee80211_tx_status_irqsafe(rtwdev->hw, skb);
227}
228
229void rtw_tx_report_handle(struct rtw_dev *rtwdev, struct sk_buff *skb, int src)
230{
231	struct rtw_tx_report *tx_report = &rtwdev->tx_report;
232	struct rtw_c2h_cmd *c2h;
233	struct sk_buff *cur, *tmp;
234	unsigned long flags;
235	u8 sn, st;
236	u8 *n;
237
238	c2h = get_c2h_from_skb(skb);
239
240	if (src == C2H_CCX_TX_RPT) {
241		sn = GET_CCX_REPORT_SEQNUM_V0(c2h->payload);
242		st = GET_CCX_REPORT_STATUS_V0(c2h->payload);
243	} else {
244		sn = GET_CCX_REPORT_SEQNUM_V1(c2h->payload);
245		st = GET_CCX_REPORT_STATUS_V1(c2h->payload);
246	}
247
248	spin_lock_irqsave(&tx_report->q_lock, flags);
249	skb_queue_walk_safe(&tx_report->queue, cur, tmp) {
250		n = (u8 *)IEEE80211_SKB_CB(cur)->status.status_driver_data;
251		if (*n == sn) {
252			__skb_unlink(cur, &tx_report->queue);
253			rtw_tx_report_tx_status(rtwdev, cur, st == 0);
254			break;
255		}
256	}
257	spin_unlock_irqrestore(&tx_report->q_lock, flags);
258}
259
260static u8 rtw_get_mgmt_rate(struct rtw_dev *rtwdev, struct sk_buff *skb,
261			    u8 lowest_rate, bool ignore_rate)
262{
263	struct ieee80211_tx_info *tx_info = IEEE80211_SKB_CB(skb);
264	struct ieee80211_vif *vif = tx_info->control.vif;
265	bool force_lowest = test_bit(RTW_FLAG_FORCE_LOWEST_RATE, rtwdev->flags);
266
267	if (!vif || !vif->bss_conf.basic_rates || ignore_rate || force_lowest)
268		return lowest_rate;
269
270	return __ffs(vif->bss_conf.basic_rates) + lowest_rate;
271}
272
273static void rtw_tx_pkt_info_update_rate(struct rtw_dev *rtwdev,
274					struct rtw_tx_pkt_info *pkt_info,
275					struct sk_buff *skb,
276					bool ignore_rate)
277{
278	if (rtwdev->hal.current_band_type == RTW_BAND_2G) {
279		pkt_info->rate_id = RTW_RATEID_B_20M;
280		pkt_info->rate = rtw_get_mgmt_rate(rtwdev, skb, DESC_RATE1M,
281						   ignore_rate);
282	} else {
283		pkt_info->rate_id = RTW_RATEID_G;
284		pkt_info->rate = rtw_get_mgmt_rate(rtwdev, skb, DESC_RATE6M,
285						   ignore_rate);
286	}
287
288	pkt_info->use_rate = true;
289	pkt_info->dis_rate_fallback = true;
290}
291
292static void rtw_tx_pkt_info_update_sec(struct rtw_dev *rtwdev,
293				       struct rtw_tx_pkt_info *pkt_info,
294				       struct sk_buff *skb)
295{
296	struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
297	u8 sec_type = 0;
298
299	if (info && info->control.hw_key) {
300		struct ieee80211_key_conf *key = info->control.hw_key;
301
302		switch (key->cipher) {
303		case WLAN_CIPHER_SUITE_WEP40:
304		case WLAN_CIPHER_SUITE_WEP104:
305		case WLAN_CIPHER_SUITE_TKIP:
306			sec_type = 0x01;
307			break;
308		case WLAN_CIPHER_SUITE_CCMP:
309			sec_type = 0x03;
310			break;
311		default:
312			break;
313		}
314	}
315
316	pkt_info->sec_type = sec_type;
317}
318
319static void rtw_tx_mgmt_pkt_info_update(struct rtw_dev *rtwdev,
320					struct rtw_tx_pkt_info *pkt_info,
321					struct ieee80211_sta *sta,
322					struct sk_buff *skb)
323{
324	rtw_tx_pkt_info_update_rate(rtwdev, pkt_info, skb, false);
325	pkt_info->dis_qselseq = true;
326	pkt_info->en_hwseq = true;
327	pkt_info->hw_ssn_sel = 0;
328	/* TODO: need to change hw port and hw ssn sel for multiple vifs */
329}
330
331static void rtw_tx_data_pkt_info_update(struct rtw_dev *rtwdev,
332					struct rtw_tx_pkt_info *pkt_info,
333					struct ieee80211_sta *sta,
334					struct sk_buff *skb)
335{
336	struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)skb->data;
337	struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
338	struct ieee80211_hw *hw = rtwdev->hw;
339	struct rtw_dm_info *dm_info = &rtwdev->dm_info;
340	struct rtw_sta_info *si;
341	u8 fix_rate;
342	u16 seq;
343	u8 ampdu_factor = 0;
344	u8 ampdu_density = 0;
345	bool ampdu_en = false;
346	u8 rate = DESC_RATE6M;
347	u8 rate_id = 6;
348	u8 bw = RTW_CHANNEL_WIDTH_20;
349	bool stbc = false;
350	bool ldpc = false;
351
352	seq = (le16_to_cpu(hdr->seq_ctrl) & IEEE80211_SCTL_SEQ) >> 4;
353
354	/* for broadcast/multicast, use default values */
355	if (!sta)
356		goto out;
357
358	if (info->flags & IEEE80211_TX_CTL_AMPDU) {
359		ampdu_en = true;
360		ampdu_factor = get_tx_ampdu_factor(sta);
361		ampdu_density = get_tx_ampdu_density(sta);
362	}
363
364	if (info->control.use_rts || skb->len > hw->wiphy->rts_threshold)
365		pkt_info->rts = true;
366
367	if (sta->deflink.vht_cap.vht_supported)
368		rate = get_highest_vht_tx_rate(rtwdev, sta);
369	else if (sta->deflink.ht_cap.ht_supported)
370		rate = get_highest_ht_tx_rate(rtwdev, sta);
371	else if (sta->deflink.supp_rates[0] <= 0xf)
372		rate = DESC_RATE11M;
373	else
374		rate = DESC_RATE54M;
375
376	si = (struct rtw_sta_info *)sta->drv_priv;
377
378	bw = si->bw_mode;
379	rate_id = si->rate_id;
380	stbc = rtwdev->hal.txrx_1ss ? false : si->stbc_en;
381	ldpc = si->ldpc_en;
382
383out:
384	pkt_info->seq = seq;
385	pkt_info->ampdu_factor = ampdu_factor;
386	pkt_info->ampdu_density = ampdu_density;
387	pkt_info->ampdu_en = ampdu_en;
388	pkt_info->rate = rate;
389	pkt_info->rate_id = rate_id;
390	pkt_info->bw = bw;
391	pkt_info->stbc = stbc;
392	pkt_info->ldpc = ldpc;
393
394	fix_rate = dm_info->fix_rate;
395	if (fix_rate < DESC_RATE_MAX) {
396		pkt_info->rate = fix_rate;
397		pkt_info->dis_rate_fallback = true;
398		pkt_info->use_rate = true;
399	}
400}
401
402void rtw_tx_pkt_info_update(struct rtw_dev *rtwdev,
403			    struct rtw_tx_pkt_info *pkt_info,
404			    struct ieee80211_sta *sta,
405			    struct sk_buff *skb)
406{
407	const struct rtw_chip_info *chip = rtwdev->chip;
408	struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
409	struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)skb->data;
410	struct ieee80211_vif *vif = info->control.vif;
411	struct rtw_sta_info *si;
412	struct rtw_vif *rtwvif;
413	__le16 fc = hdr->frame_control;
414	bool bmc;
415
416	if (sta) {
417		si = (struct rtw_sta_info *)sta->drv_priv;
418		pkt_info->mac_id = si->mac_id;
419	} else if (vif) {
420		rtwvif = (struct rtw_vif *)vif->drv_priv;
421		pkt_info->mac_id = rtwvif->mac_id;
422	}
423
424	if (ieee80211_is_mgmt(fc) || ieee80211_is_nullfunc(fc))
425		rtw_tx_mgmt_pkt_info_update(rtwdev, pkt_info, sta, skb);
426	else if (ieee80211_is_data(fc))
427		rtw_tx_data_pkt_info_update(rtwdev, pkt_info, sta, skb);
428
429	bmc = is_broadcast_ether_addr(hdr->addr1) ||
430	      is_multicast_ether_addr(hdr->addr1);
431
432	if (info->flags & IEEE80211_TX_CTL_REQ_TX_STATUS)
433		rtw_tx_report_enable(rtwdev, pkt_info);
434
435	pkt_info->bmc = bmc;
436	rtw_tx_pkt_info_update_sec(rtwdev, pkt_info, skb);
437	pkt_info->tx_pkt_size = skb->len;
438	pkt_info->offset = chip->tx_pkt_desc_sz;
439	pkt_info->qsel = skb->priority;
440	pkt_info->ls = true;
441
442	/* maybe merge with tx status ? */
443	rtw_tx_stats(rtwdev, vif, skb);
444}
445
446void rtw_tx_rsvd_page_pkt_info_update(struct rtw_dev *rtwdev,
447				      struct rtw_tx_pkt_info *pkt_info,
448				      struct sk_buff *skb,
449				      enum rtw_rsvd_packet_type type)
450{
451	const struct rtw_chip_info *chip = rtwdev->chip;
452	struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)skb->data;
453	bool bmc;
454
455	/* A beacon or dummy reserved page packet indicates that it is the first
456	 * reserved page, and the qsel of it will be set in each hci.
457	 */
458	if (type != RSVD_BEACON && type != RSVD_DUMMY)
459		pkt_info->qsel = TX_DESC_QSEL_MGMT;
460
461	rtw_tx_pkt_info_update_rate(rtwdev, pkt_info, skb, true);
462
463	bmc = is_broadcast_ether_addr(hdr->addr1) ||
464	      is_multicast_ether_addr(hdr->addr1);
465	pkt_info->bmc = bmc;
466	pkt_info->tx_pkt_size = skb->len;
467	pkt_info->offset = chip->tx_pkt_desc_sz;
468	pkt_info->ls = true;
469	if (type == RSVD_PS_POLL) {
470		pkt_info->nav_use_hdr = true;
471	} else {
472		pkt_info->dis_qselseq = true;
473		pkt_info->en_hwseq = true;
474		pkt_info->hw_ssn_sel = 0;
475	}
476	if (type == RSVD_QOS_NULL)
477		pkt_info->bt_null = true;
478
479	if (type == RSVD_BEACON) {
480		struct rtw_rsvd_page *rsvd_pkt;
481		int hdr_len;
482
483		rsvd_pkt = list_first_entry_or_null(&rtwdev->rsvd_page_list,
484						    struct rtw_rsvd_page,
485						    build_list);
486		if (rsvd_pkt && rsvd_pkt->tim_offset != 0) {
487			hdr_len = sizeof(struct ieee80211_hdr_3addr);
488			pkt_info->tim_offset = rsvd_pkt->tim_offset - hdr_len;
489		}
490	}
491
492	rtw_tx_pkt_info_update_sec(rtwdev, pkt_info, skb);
493
494	/* TODO: need to change hw port and hw ssn sel for multiple vifs */
495}
496
497struct sk_buff *
498rtw_tx_write_data_rsvd_page_get(struct rtw_dev *rtwdev,
499				struct rtw_tx_pkt_info *pkt_info,
500				u8 *buf, u32 size)
501{
502	const struct rtw_chip_info *chip = rtwdev->chip;
503	struct sk_buff *skb;
504	u32 tx_pkt_desc_sz;
505	u32 length;
506
507	tx_pkt_desc_sz = chip->tx_pkt_desc_sz;
508	length = size + tx_pkt_desc_sz;
509	skb = dev_alloc_skb(length);
510	if (!skb) {
511		rtw_err(rtwdev, "failed to alloc write data rsvd page skb\n");
512		return NULL;
513	}
514
515	skb_reserve(skb, tx_pkt_desc_sz);
516	skb_put_data(skb, buf, size);
517	rtw_tx_rsvd_page_pkt_info_update(rtwdev, pkt_info, skb, RSVD_BEACON);
518
519	return skb;
520}
521EXPORT_SYMBOL(rtw_tx_write_data_rsvd_page_get);
522
523struct sk_buff *
524rtw_tx_write_data_h2c_get(struct rtw_dev *rtwdev,
525			  struct rtw_tx_pkt_info *pkt_info,
526			  u8 *buf, u32 size)
527{
528	const struct rtw_chip_info *chip = rtwdev->chip;
529	struct sk_buff *skb;
530	u32 tx_pkt_desc_sz;
531	u32 length;
532
533	tx_pkt_desc_sz = chip->tx_pkt_desc_sz;
534	length = size + tx_pkt_desc_sz;
535	skb = dev_alloc_skb(length);
536	if (!skb) {
537		rtw_err(rtwdev, "failed to alloc write data h2c skb\n");
538		return NULL;
539	}
540
541	skb_reserve(skb, tx_pkt_desc_sz);
542	skb_put_data(skb, buf, size);
543	pkt_info->tx_pkt_size = size;
544
545	return skb;
546}
547EXPORT_SYMBOL(rtw_tx_write_data_h2c_get);
548
549void rtw_tx(struct rtw_dev *rtwdev,
550	    struct ieee80211_tx_control *control,
551	    struct sk_buff *skb)
552{
553	struct rtw_tx_pkt_info pkt_info = {0};
554	int ret;
555
556	rtw_tx_pkt_info_update(rtwdev, &pkt_info, control->sta, skb);
557	ret = rtw_hci_tx_write(rtwdev, &pkt_info, skb);
558	if (ret) {
559		rtw_err(rtwdev, "failed to write TX skb to HCI\n");
560		goto out;
561	}
562
563	rtw_hci_tx_kick_off(rtwdev);
564
565	return;
566
567out:
568	ieee80211_free_txskb(rtwdev->hw, skb);
569}
570
571static void rtw_txq_check_agg(struct rtw_dev *rtwdev,
572			      struct rtw_txq *rtwtxq,
573			      struct sk_buff *skb)
574{
575	struct ieee80211_txq *txq = rtwtxq_to_txq(rtwtxq);
576	struct ieee80211_tx_info *info;
577	struct rtw_sta_info *si;
578
579	if (test_bit(RTW_TXQ_AMPDU, &rtwtxq->flags)) {
580		info = IEEE80211_SKB_CB(skb);
581		info->flags |= IEEE80211_TX_CTL_AMPDU;
582		return;
583	}
584
585	if (skb_get_queue_mapping(skb) == IEEE80211_AC_VO)
586		return;
587
588	if (test_bit(RTW_TXQ_BLOCK_BA, &rtwtxq->flags))
589		return;
590
591	if (unlikely(skb->protocol == cpu_to_be16(ETH_P_PAE)))
592		return;
593
594	if (!txq->sta)
595		return;
596
597	si = (struct rtw_sta_info *)txq->sta->drv_priv;
598	set_bit(txq->tid, si->tid_ba);
599
600	ieee80211_queue_work(rtwdev->hw, &rtwdev->ba_work);
601}
602
603static int rtw_txq_push_skb(struct rtw_dev *rtwdev,
604			    struct rtw_txq *rtwtxq,
605			    struct sk_buff *skb)
606{
607	struct ieee80211_txq *txq = rtwtxq_to_txq(rtwtxq);
608	struct rtw_tx_pkt_info pkt_info = {0};
609	int ret;
610
611	rtw_txq_check_agg(rtwdev, rtwtxq, skb);
612
613	rtw_tx_pkt_info_update(rtwdev, &pkt_info, txq->sta, skb);
614	ret = rtw_hci_tx_write(rtwdev, &pkt_info, skb);
615	if (ret) {
616		rtw_err(rtwdev, "failed to write TX skb to HCI\n");
617		return ret;
618	}
619	return 0;
620}
621
622static struct sk_buff *rtw_txq_dequeue(struct rtw_dev *rtwdev,
623				       struct rtw_txq *rtwtxq)
624{
625	struct ieee80211_txq *txq = rtwtxq_to_txq(rtwtxq);
626	struct sk_buff *skb;
627
628	skb = ieee80211_tx_dequeue(rtwdev->hw, txq);
629	if (!skb)
630		return NULL;
631
632	return skb;
633}
634
635static void rtw_txq_push(struct rtw_dev *rtwdev,
636			 struct rtw_txq *rtwtxq,
637			 unsigned long frames)
638{
639	struct sk_buff *skb;
640	int ret;
641	int i;
642
643	rcu_read_lock();
644
645	for (i = 0; i < frames; i++) {
646		skb = rtw_txq_dequeue(rtwdev, rtwtxq);
647		if (!skb)
648			break;
649
650		ret = rtw_txq_push_skb(rtwdev, rtwtxq, skb);
651		if (ret) {
652			rtw_err(rtwdev, "failed to pusk skb, ret %d\n", ret);
653			break;
654		}
655	}
656
657	rcu_read_unlock();
658}
659
660void __rtw_tx_work(struct rtw_dev *rtwdev)
661{
662	struct rtw_txq *rtwtxq, *tmp;
663
664	spin_lock_bh(&rtwdev->txq_lock);
665
666	list_for_each_entry_safe(rtwtxq, tmp, &rtwdev->txqs, list) {
667		struct ieee80211_txq *txq = rtwtxq_to_txq(rtwtxq);
668		unsigned long frame_cnt;
669
670		ieee80211_txq_get_depth(txq, &frame_cnt, NULL);
671		rtw_txq_push(rtwdev, rtwtxq, frame_cnt);
672
673		list_del_init(&rtwtxq->list);
674	}
675
676	rtw_hci_tx_kick_off(rtwdev);
677
678	spin_unlock_bh(&rtwdev->txq_lock);
679}
680
681void rtw_tx_work(struct work_struct *w)
682{
683	struct rtw_dev *rtwdev = container_of(w, struct rtw_dev, tx_work);
684
685	__rtw_tx_work(rtwdev);
686}
687
688void rtw_txq_init(struct rtw_dev *rtwdev, struct ieee80211_txq *txq)
689{
690	struct rtw_txq *rtwtxq;
691
692	if (!txq)
693		return;
694
695	rtwtxq = (struct rtw_txq *)txq->drv_priv;
696	INIT_LIST_HEAD(&rtwtxq->list);
697}
698
699void rtw_txq_cleanup(struct rtw_dev *rtwdev, struct ieee80211_txq *txq)
700{
701	struct rtw_txq *rtwtxq;
702
703	if (!txq)
704		return;
705
706	rtwtxq = (struct rtw_txq *)txq->drv_priv;
707	spin_lock_bh(&rtwdev->txq_lock);
708	if (!list_empty(&rtwtxq->list))
709		list_del_init(&rtwtxq->list);
710	spin_unlock_bh(&rtwdev->txq_lock);
711}
712
713static const enum rtw_tx_queue_type ac_to_hwq[] = {
714	[IEEE80211_AC_VO] = RTW_TX_QUEUE_VO,
715	[IEEE80211_AC_VI] = RTW_TX_QUEUE_VI,
716	[IEEE80211_AC_BE] = RTW_TX_QUEUE_BE,
717	[IEEE80211_AC_BK] = RTW_TX_QUEUE_BK,
718};
719
720static_assert(ARRAY_SIZE(ac_to_hwq) == IEEE80211_NUM_ACS);
721
722enum rtw_tx_queue_type rtw_tx_ac_to_hwq(enum ieee80211_ac_numbers ac)
723{
724	if (WARN_ON(unlikely(ac >= IEEE80211_NUM_ACS)))
725		return RTW_TX_QUEUE_BE;
726
727	return ac_to_hwq[ac];
728}
729EXPORT_SYMBOL(rtw_tx_ac_to_hwq);
730
731enum rtw_tx_queue_type rtw_tx_queue_mapping(struct sk_buff *skb)
732{
733	struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)skb->data;
734	__le16 fc = hdr->frame_control;
735	u8 q_mapping = skb_get_queue_mapping(skb);
736	enum rtw_tx_queue_type queue;
737
738	if (unlikely(ieee80211_is_beacon(fc)))
739		queue = RTW_TX_QUEUE_BCN;
740	else if (unlikely(ieee80211_is_mgmt(fc) || ieee80211_is_ctl(fc)))
741		queue = RTW_TX_QUEUE_MGMT;
742	else if (is_broadcast_ether_addr(hdr->addr1) ||
743		 is_multicast_ether_addr(hdr->addr1))
744		queue = RTW_TX_QUEUE_HI0;
745	else if (WARN_ON_ONCE(q_mapping >= ARRAY_SIZE(ac_to_hwq)))
746		queue = ac_to_hwq[IEEE80211_AC_BE];
747	else
748		queue = ac_to_hwq[q_mapping];
749
750	return queue;
751}
752EXPORT_SYMBOL(rtw_tx_queue_mapping);