| 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 |
|
| 11 |
static |
| 12 |
void 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 |
|
| 35 |
void 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 |
} |
| 94 |
EXPORT_SYMBOL(rtw_tx_fill_tx_desc); |
| 95 |
|
| 96 |
static 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 |
|
| 107 |
static u8 get_tx_ampdu_density(struct ieee80211_sta *sta) |
| 108 |
{ |
| 109 |
return sta->deflink.ht_cap.ampdu_density; |
| 110 |
} |
| 111 |
|
| 112 |
static 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 |
|
| 125 |
static 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 |
|
| 166 |
static 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 |
|
| 179 |
void 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 |
|
| 196 |
void 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 |
} |
| 212 |
EXPORT_SYMBOL(rtw_tx_report_enqueue); |
| 213 |
|
| 214 |
static 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 |
|
| 229 |
void 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 |
|
| 260 |
static 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 |
|
| 273 |
static 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 |
|
| 292 |
static 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 |
|
| 319 |
static 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 |
|
| 331 |
static 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 |
|
| 383 |
out: |
| 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 |
|
| 402 |
void 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 |
|
| 446 |
void 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 |
|
| 497 |
struct sk_buff * |
| 498 |
rtw_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 |
} |
| 521 |
EXPORT_SYMBOL(rtw_tx_write_data_rsvd_page_get); |
| 522 |
|
| 523 |
struct sk_buff * |
| 524 |
rtw_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 |
} |
| 547 |
EXPORT_SYMBOL(rtw_tx_write_data_h2c_get); |
| 548 |
|
| 549 |
void 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 |
|
| 567 |
out: |
| 568 |
ieee80211_free_txskb(rtwdev->hw, skb); |
| 569 |
} |
| 570 |
|
| 571 |
static 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 |
|
| 603 |
static 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 |
|
| 622 |
static 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 |
|
| 635 |
static 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 |
|
| 660 |
void __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 |
|
| 681 |
void 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 |
|
| 688 |
void 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 |
|
| 699 |
void 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 |
|
| 713 |
static 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 |
|
| 720 |
static_assert(ARRAY_SIZE(ac_to_hwq) == IEEE80211_NUM_ACS); |
| 721 |
|
| 722 |
enum 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 |
} |
| 729 |
EXPORT_SYMBOL(rtw_tx_ac_to_hwq); |
| 730 |
|
| 731 |
enum 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 |
} |
| 752 |
EXPORT_SYMBOL(rtw_tx_queue_mapping); |