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 defined(__linux__) 187 if (skb_queue_len(&tx_report->queue) == 0) 188 return; 189 190 rtw_warn(rtwdev, "failed to get tx report from firmware\n"); 191 192 spin_lock_irqsave(&tx_report->q_lock, flags); 193 skb_queue_purge(&tx_report->queue); 194 spin_unlock_irqrestore(&tx_report->q_lock, flags); 195 #elif defined(__FreeBSD__) 196 uint32_t qlen; 197 198 spin_lock_irqsave(&tx_report->q_lock, flags); 199 qlen = skb_queue_len(&tx_report->queue); 200 if (qlen > 0) 201 skb_queue_purge(&tx_report->queue); 202 spin_unlock_irqrestore(&tx_report->q_lock, flags); 203 204 /* 205 * XXX while there could be a new enqueue in the queue 206 * simply not yet processed given the timer is updated without 207 * locks after enqueue in rtw_tx_report_enqueue(), the numbers 208 * seen can be in the 100s. We revert to rtw_dbg from 209 * Linux git 584dce175f0461d5d9d63952a1e7955678c91086 . 210 */ 211 rtw_dbg(rtwdev, RTW_DBG_TX, "failed to get tx report from firmware: " 212 "txreport qlen %u\n", qlen); 213 #endif 214 } 215 216 void rtw_tx_report_enqueue(struct rtw_dev *rtwdev, struct sk_buff *skb, u8 sn) 217 { 218 struct rtw_tx_report *tx_report = &rtwdev->tx_report; 219 unsigned long flags; 220 u8 *drv_data; 221 222 /* pass sn to tx report handler through driver data */ 223 drv_data = (u8 *)IEEE80211_SKB_CB(skb)->status.status_driver_data; 224 *drv_data = sn; 225 226 spin_lock_irqsave(&tx_report->q_lock, flags); 227 __skb_queue_tail(&tx_report->queue, skb); 228 spin_unlock_irqrestore(&tx_report->q_lock, flags); 229 230 mod_timer(&tx_report->purge_timer, jiffies + RTW_TX_PROBE_TIMEOUT); 231 } 232 EXPORT_SYMBOL(rtw_tx_report_enqueue); 233 234 static void rtw_tx_report_tx_status(struct rtw_dev *rtwdev, 235 struct sk_buff *skb, bool acked) 236 { 237 struct ieee80211_tx_info *info; 238 239 info = IEEE80211_SKB_CB(skb); 240 ieee80211_tx_info_clear_status(info); 241 if (acked) 242 info->flags |= IEEE80211_TX_STAT_ACK; 243 else 244 info->flags &= ~IEEE80211_TX_STAT_ACK; 245 246 ieee80211_tx_status_irqsafe(rtwdev->hw, skb); 247 } 248 249 void rtw_tx_report_handle(struct rtw_dev *rtwdev, struct sk_buff *skb, int src) 250 { 251 struct rtw_tx_report *tx_report = &rtwdev->tx_report; 252 struct rtw_c2h_cmd *c2h; 253 struct sk_buff *cur, *tmp; 254 unsigned long flags; 255 u8 sn, st; 256 u8 *n; 257 258 c2h = get_c2h_from_skb(skb); 259 260 if (src == C2H_CCX_TX_RPT) { 261 sn = GET_CCX_REPORT_SEQNUM_V0(c2h->payload); 262 st = GET_CCX_REPORT_STATUS_V0(c2h->payload); 263 } else { 264 sn = GET_CCX_REPORT_SEQNUM_V1(c2h->payload); 265 st = GET_CCX_REPORT_STATUS_V1(c2h->payload); 266 } 267 268 spin_lock_irqsave(&tx_report->q_lock, flags); 269 skb_queue_walk_safe(&tx_report->queue, cur, tmp) { 270 n = (u8 *)IEEE80211_SKB_CB(cur)->status.status_driver_data; 271 if (*n == sn) { 272 __skb_unlink(cur, &tx_report->queue); 273 rtw_tx_report_tx_status(rtwdev, cur, st == 0); 274 break; 275 } 276 } 277 spin_unlock_irqrestore(&tx_report->q_lock, flags); 278 } 279 280 static u8 rtw_get_mgmt_rate(struct rtw_dev *rtwdev, struct sk_buff *skb, 281 u8 lowest_rate, bool ignore_rate) 282 { 283 struct ieee80211_tx_info *tx_info = IEEE80211_SKB_CB(skb); 284 struct ieee80211_vif *vif = tx_info->control.vif; 285 bool force_lowest = test_bit(RTW_FLAG_FORCE_LOWEST_RATE, rtwdev->flags); 286 287 if (!vif || !vif->bss_conf.basic_rates || ignore_rate || force_lowest) 288 return lowest_rate; 289 290 return __ffs(vif->bss_conf.basic_rates) + lowest_rate; 291 } 292 293 static void rtw_tx_pkt_info_update_rate(struct rtw_dev *rtwdev, 294 struct rtw_tx_pkt_info *pkt_info, 295 struct sk_buff *skb, 296 bool ignore_rate) 297 { 298 if (rtwdev->hal.current_band_type == RTW_BAND_2G) { 299 pkt_info->rate_id = RTW_RATEID_B_20M; 300 pkt_info->rate = rtw_get_mgmt_rate(rtwdev, skb, DESC_RATE1M, 301 ignore_rate); 302 } else { 303 pkt_info->rate_id = RTW_RATEID_G; 304 pkt_info->rate = rtw_get_mgmt_rate(rtwdev, skb, DESC_RATE6M, 305 ignore_rate); 306 } 307 308 pkt_info->use_rate = true; 309 pkt_info->dis_rate_fallback = true; 310 } 311 312 static void rtw_tx_pkt_info_update_sec(struct rtw_dev *rtwdev, 313 struct rtw_tx_pkt_info *pkt_info, 314 struct sk_buff *skb) 315 { 316 struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb); 317 u8 sec_type = 0; 318 319 if (info && info->control.hw_key) { 320 struct ieee80211_key_conf *key = info->control.hw_key; 321 322 switch (key->cipher) { 323 case WLAN_CIPHER_SUITE_WEP40: 324 case WLAN_CIPHER_SUITE_WEP104: 325 case WLAN_CIPHER_SUITE_TKIP: 326 sec_type = 0x01; 327 break; 328 case WLAN_CIPHER_SUITE_CCMP: 329 sec_type = 0x03; 330 break; 331 default: 332 break; 333 } 334 } 335 336 pkt_info->sec_type = sec_type; 337 } 338 339 static void rtw_tx_mgmt_pkt_info_update(struct rtw_dev *rtwdev, 340 struct rtw_tx_pkt_info *pkt_info, 341 struct ieee80211_sta *sta, 342 struct sk_buff *skb) 343 { 344 rtw_tx_pkt_info_update_rate(rtwdev, pkt_info, skb, false); 345 pkt_info->dis_qselseq = true; 346 pkt_info->en_hwseq = true; 347 pkt_info->hw_ssn_sel = 0; 348 /* TODO: need to change hw port and hw ssn sel for multiple vifs */ 349 } 350 351 static void rtw_tx_data_pkt_info_update(struct rtw_dev *rtwdev, 352 struct rtw_tx_pkt_info *pkt_info, 353 struct ieee80211_sta *sta, 354 struct sk_buff *skb) 355 { 356 struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)skb->data; 357 struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb); 358 struct ieee80211_hw *hw = rtwdev->hw; 359 struct rtw_dm_info *dm_info = &rtwdev->dm_info; 360 struct rtw_sta_info *si; 361 u8 fix_rate; 362 u16 seq; 363 u8 ampdu_factor = 0; 364 u8 ampdu_density = 0; 365 bool ampdu_en = false; 366 u8 rate = DESC_RATE6M; 367 u8 rate_id = 6; 368 u8 bw = RTW_CHANNEL_WIDTH_20; 369 bool stbc = false; 370 bool ldpc = false; 371 372 seq = (le16_to_cpu(hdr->seq_ctrl) & IEEE80211_SCTL_SEQ) >> 4; 373 374 /* for broadcast/multicast, use default values */ 375 if (!sta) 376 goto out; 377 378 if (info->flags & IEEE80211_TX_CTL_AMPDU) { 379 ampdu_en = true; 380 ampdu_factor = get_tx_ampdu_factor(sta); 381 ampdu_density = get_tx_ampdu_density(sta); 382 } 383 384 if (info->control.use_rts || skb->len > hw->wiphy->rts_threshold) 385 pkt_info->rts = true; 386 387 if (sta->deflink.vht_cap.vht_supported) 388 rate = get_highest_vht_tx_rate(rtwdev, sta); 389 else if (sta->deflink.ht_cap.ht_supported) 390 rate = get_highest_ht_tx_rate(rtwdev, sta); 391 else if (sta->deflink.supp_rates[0] <= 0xf) 392 rate = DESC_RATE11M; 393 else 394 rate = DESC_RATE54M; 395 396 si = (struct rtw_sta_info *)sta->drv_priv; 397 398 bw = si->bw_mode; 399 rate_id = si->rate_id; 400 stbc = rtwdev->hal.txrx_1ss ? false : si->stbc_en; 401 ldpc = si->ldpc_en; 402 403 out: 404 pkt_info->seq = seq; 405 pkt_info->ampdu_factor = ampdu_factor; 406 pkt_info->ampdu_density = ampdu_density; 407 pkt_info->ampdu_en = ampdu_en; 408 pkt_info->rate = rate; 409 pkt_info->rate_id = rate_id; 410 pkt_info->bw = bw; 411 pkt_info->stbc = stbc; 412 pkt_info->ldpc = ldpc; 413 414 fix_rate = dm_info->fix_rate; 415 if (fix_rate < DESC_RATE_MAX) { 416 pkt_info->rate = fix_rate; 417 pkt_info->dis_rate_fallback = true; 418 pkt_info->use_rate = true; 419 } 420 } 421 422 void rtw_tx_pkt_info_update(struct rtw_dev *rtwdev, 423 struct rtw_tx_pkt_info *pkt_info, 424 struct ieee80211_sta *sta, 425 struct sk_buff *skb) 426 { 427 const struct rtw_chip_info *chip = rtwdev->chip; 428 struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb); 429 struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)skb->data; 430 struct ieee80211_vif *vif = info->control.vif; 431 struct rtw_sta_info *si; 432 struct rtw_vif *rtwvif; 433 __le16 fc = hdr->frame_control; 434 bool bmc; 435 436 if (sta) { 437 si = (struct rtw_sta_info *)sta->drv_priv; 438 pkt_info->mac_id = si->mac_id; 439 } else if (vif) { 440 rtwvif = (struct rtw_vif *)vif->drv_priv; 441 pkt_info->mac_id = rtwvif->mac_id; 442 } 443 444 if (ieee80211_is_mgmt(fc) || ieee80211_is_nullfunc(fc)) 445 rtw_tx_mgmt_pkt_info_update(rtwdev, pkt_info, sta, skb); 446 else if (ieee80211_is_data(fc)) 447 rtw_tx_data_pkt_info_update(rtwdev, pkt_info, sta, skb); 448 449 bmc = is_broadcast_ether_addr(hdr->addr1) || 450 is_multicast_ether_addr(hdr->addr1); 451 452 if (info->flags & IEEE80211_TX_CTL_REQ_TX_STATUS) 453 rtw_tx_report_enable(rtwdev, pkt_info); 454 455 pkt_info->bmc = bmc; 456 rtw_tx_pkt_info_update_sec(rtwdev, pkt_info, skb); 457 pkt_info->tx_pkt_size = skb->len; 458 pkt_info->offset = chip->tx_pkt_desc_sz; 459 pkt_info->qsel = skb->priority; 460 pkt_info->ls = true; 461 462 /* maybe merge with tx status ? */ 463 rtw_tx_stats(rtwdev, vif, skb); 464 } 465 466 void rtw_tx_rsvd_page_pkt_info_update(struct rtw_dev *rtwdev, 467 struct rtw_tx_pkt_info *pkt_info, 468 struct sk_buff *skb, 469 enum rtw_rsvd_packet_type type) 470 { 471 const struct rtw_chip_info *chip = rtwdev->chip; 472 struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)skb->data; 473 bool bmc; 474 475 /* A beacon or dummy reserved page packet indicates that it is the first 476 * reserved page, and the qsel of it will be set in each hci. 477 */ 478 if (type != RSVD_BEACON && type != RSVD_DUMMY) 479 pkt_info->qsel = TX_DESC_QSEL_MGMT; 480 481 rtw_tx_pkt_info_update_rate(rtwdev, pkt_info, skb, true); 482 483 bmc = is_broadcast_ether_addr(hdr->addr1) || 484 is_multicast_ether_addr(hdr->addr1); 485 pkt_info->bmc = bmc; 486 pkt_info->tx_pkt_size = skb->len; 487 pkt_info->offset = chip->tx_pkt_desc_sz; 488 pkt_info->ls = true; 489 if (type == RSVD_PS_POLL) { 490 pkt_info->nav_use_hdr = true; 491 } else { 492 pkt_info->dis_qselseq = true; 493 pkt_info->en_hwseq = true; 494 pkt_info->hw_ssn_sel = 0; 495 } 496 if (type == RSVD_QOS_NULL) 497 pkt_info->bt_null = true; 498 499 if (type == RSVD_BEACON) { 500 struct rtw_rsvd_page *rsvd_pkt; 501 int hdr_len; 502 503 rsvd_pkt = list_first_entry_or_null(&rtwdev->rsvd_page_list, 504 struct rtw_rsvd_page, 505 build_list); 506 if (rsvd_pkt && rsvd_pkt->tim_offset != 0) { 507 hdr_len = sizeof(struct ieee80211_hdr_3addr); 508 pkt_info->tim_offset = rsvd_pkt->tim_offset - hdr_len; 509 } 510 } 511 512 rtw_tx_pkt_info_update_sec(rtwdev, pkt_info, skb); 513 514 /* TODO: need to change hw port and hw ssn sel for multiple vifs */ 515 } 516 517 struct sk_buff * 518 rtw_tx_write_data_rsvd_page_get(struct rtw_dev *rtwdev, 519 struct rtw_tx_pkt_info *pkt_info, 520 u8 *buf, u32 size) 521 { 522 const struct rtw_chip_info *chip = rtwdev->chip; 523 struct sk_buff *skb; 524 u32 tx_pkt_desc_sz; 525 u32 length; 526 527 tx_pkt_desc_sz = chip->tx_pkt_desc_sz; 528 length = size + tx_pkt_desc_sz; 529 skb = dev_alloc_skb(length); 530 if (!skb) { 531 rtw_err(rtwdev, "failed to alloc write data rsvd page skb\n"); 532 return NULL; 533 } 534 535 skb_reserve(skb, tx_pkt_desc_sz); 536 skb_put_data(skb, buf, size); 537 rtw_tx_rsvd_page_pkt_info_update(rtwdev, pkt_info, skb, RSVD_BEACON); 538 539 return skb; 540 } 541 EXPORT_SYMBOL(rtw_tx_write_data_rsvd_page_get); 542 543 struct sk_buff * 544 rtw_tx_write_data_h2c_get(struct rtw_dev *rtwdev, 545 struct rtw_tx_pkt_info *pkt_info, 546 u8 *buf, u32 size) 547 { 548 const struct rtw_chip_info *chip = rtwdev->chip; 549 struct sk_buff *skb; 550 u32 tx_pkt_desc_sz; 551 u32 length; 552 553 tx_pkt_desc_sz = chip->tx_pkt_desc_sz; 554 length = size + tx_pkt_desc_sz; 555 skb = dev_alloc_skb(length); 556 if (!skb) { 557 rtw_err(rtwdev, "failed to alloc write data h2c skb\n"); 558 return NULL; 559 } 560 561 skb_reserve(skb, tx_pkt_desc_sz); 562 skb_put_data(skb, buf, size); 563 pkt_info->tx_pkt_size = size; 564 565 return skb; 566 } 567 EXPORT_SYMBOL(rtw_tx_write_data_h2c_get); 568 569 void rtw_tx(struct rtw_dev *rtwdev, 570 struct ieee80211_tx_control *control, 571 struct sk_buff *skb) 572 { 573 struct rtw_tx_pkt_info pkt_info = {0}; 574 int ret; 575 576 rtw_tx_pkt_info_update(rtwdev, &pkt_info, control->sta, skb); 577 ret = rtw_hci_tx_write(rtwdev, &pkt_info, skb); 578 if (ret) { 579 #if defined(__linux__) 580 rtw_err(rtwdev, "failed to write TX skb to HCI\n"); 581 #elif defined(__FreeBSD__) 582 rtw_err(rtwdev, "%s: failed to write TX skb to HCI: %d\n", __func__, ret); 583 #endif 584 goto out; 585 } 586 587 rtw_hci_tx_kick_off(rtwdev); 588 589 return; 590 591 out: 592 ieee80211_free_txskb(rtwdev->hw, skb); 593 } 594 595 static void rtw_txq_check_agg(struct rtw_dev *rtwdev, 596 struct rtw_txq *rtwtxq, 597 struct sk_buff *skb) 598 { 599 struct ieee80211_txq *txq = rtwtxq_to_txq(rtwtxq); 600 struct ieee80211_tx_info *info; 601 struct rtw_sta_info *si; 602 603 if (test_bit(RTW_TXQ_AMPDU, &rtwtxq->flags)) { 604 info = IEEE80211_SKB_CB(skb); 605 info->flags |= IEEE80211_TX_CTL_AMPDU; 606 return; 607 } 608 609 if (skb_get_queue_mapping(skb) == IEEE80211_AC_VO) 610 return; 611 612 if (test_bit(RTW_TXQ_BLOCK_BA, &rtwtxq->flags)) 613 return; 614 615 if (unlikely(skb->protocol == cpu_to_be16(ETH_P_PAE))) 616 return; 617 618 if (!txq->sta) 619 return; 620 621 si = (struct rtw_sta_info *)txq->sta->drv_priv; 622 set_bit(txq->tid, si->tid_ba); 623 624 ieee80211_queue_work(rtwdev->hw, &rtwdev->ba_work); 625 } 626 627 static int rtw_txq_push_skb(struct rtw_dev *rtwdev, 628 struct rtw_txq *rtwtxq, 629 struct sk_buff *skb) 630 { 631 struct ieee80211_txq *txq = rtwtxq_to_txq(rtwtxq); 632 struct rtw_tx_pkt_info pkt_info = {0}; 633 int ret; 634 635 rtw_txq_check_agg(rtwdev, rtwtxq, skb); 636 637 rtw_tx_pkt_info_update(rtwdev, &pkt_info, txq->sta, skb); 638 ret = rtw_hci_tx_write(rtwdev, &pkt_info, skb); 639 if (ret) { 640 #if defined(__linux__) 641 rtw_err(rtwdev, "failed to write TX skb to HCI\n"); 642 #elif defined(__FreeBSD__) 643 rtw_err(rtwdev, "%s: failed to write TX skb to HCI: %d\n", __func__, ret); 644 #endif 645 return ret; 646 } 647 return 0; 648 } 649 650 static struct sk_buff *rtw_txq_dequeue(struct rtw_dev *rtwdev, 651 struct rtw_txq *rtwtxq) 652 { 653 struct ieee80211_txq *txq = rtwtxq_to_txq(rtwtxq); 654 struct sk_buff *skb; 655 656 skb = ieee80211_tx_dequeue(rtwdev->hw, txq); 657 if (!skb) 658 return NULL; 659 660 return skb; 661 } 662 663 static void rtw_txq_push(struct rtw_dev *rtwdev, 664 struct rtw_txq *rtwtxq, 665 unsigned long frames) 666 { 667 struct sk_buff *skb; 668 int ret; 669 int i; 670 671 rcu_read_lock(); 672 673 for (i = 0; i < frames; i++) { 674 skb = rtw_txq_dequeue(rtwdev, rtwtxq); 675 if (!skb) 676 break; 677 678 ret = rtw_txq_push_skb(rtwdev, rtwtxq, skb); 679 if (ret) { 680 #if defined(__FreeBSD__) 681 dev_kfree_skb_any(skb); 682 rtw_err(rtwdev, "failed to push skb, ret %d\n", ret); 683 #else 684 rtw_err(rtwdev, "failed to pusk skb, ret %d\n", ret); 685 #endif 686 break; 687 } 688 } 689 690 rcu_read_unlock(); 691 } 692 693 void __rtw_tx_work(struct rtw_dev *rtwdev) 694 { 695 struct rtw_txq *rtwtxq, *tmp; 696 697 spin_lock_bh(&rtwdev->txq_lock); 698 699 list_for_each_entry_safe(rtwtxq, tmp, &rtwdev->txqs, list) { 700 struct ieee80211_txq *txq = rtwtxq_to_txq(rtwtxq); 701 unsigned long frame_cnt; 702 703 ieee80211_txq_get_depth(txq, &frame_cnt, NULL); 704 rtw_txq_push(rtwdev, rtwtxq, frame_cnt); 705 706 list_del_init(&rtwtxq->list); 707 } 708 709 rtw_hci_tx_kick_off(rtwdev); 710 711 spin_unlock_bh(&rtwdev->txq_lock); 712 } 713 714 void rtw_tx_work(struct work_struct *w) 715 { 716 struct rtw_dev *rtwdev = container_of(w, struct rtw_dev, tx_work); 717 718 __rtw_tx_work(rtwdev); 719 } 720 721 void rtw_txq_init(struct rtw_dev *rtwdev, struct ieee80211_txq *txq) 722 { 723 struct rtw_txq *rtwtxq; 724 725 if (!txq) 726 return; 727 728 rtwtxq = (struct rtw_txq *)txq->drv_priv; 729 INIT_LIST_HEAD(&rtwtxq->list); 730 } 731 732 void rtw_txq_cleanup(struct rtw_dev *rtwdev, struct ieee80211_txq *txq) 733 { 734 struct rtw_txq *rtwtxq; 735 736 if (!txq) 737 return; 738 739 rtwtxq = (struct rtw_txq *)txq->drv_priv; 740 spin_lock_bh(&rtwdev->txq_lock); 741 if (!list_empty(&rtwtxq->list)) 742 list_del_init(&rtwtxq->list); 743 spin_unlock_bh(&rtwdev->txq_lock); 744 } 745 746 static const enum rtw_tx_queue_type ac_to_hwq[] = { 747 [IEEE80211_AC_VO] = RTW_TX_QUEUE_VO, 748 [IEEE80211_AC_VI] = RTW_TX_QUEUE_VI, 749 [IEEE80211_AC_BE] = RTW_TX_QUEUE_BE, 750 [IEEE80211_AC_BK] = RTW_TX_QUEUE_BK, 751 }; 752 753 #if defined(__linux__) 754 static_assert(ARRAY_SIZE(ac_to_hwq) == IEEE80211_NUM_ACS); 755 #elif defined(__FreeBSD__) 756 rtw88_static_assert(ARRAY_SIZE(ac_to_hwq) == IEEE80211_NUM_ACS); 757 #endif 758 759 enum rtw_tx_queue_type rtw_tx_ac_to_hwq(enum ieee80211_ac_numbers ac) 760 { 761 if (WARN_ON(unlikely(ac >= IEEE80211_NUM_ACS))) 762 return RTW_TX_QUEUE_BE; 763 764 return ac_to_hwq[ac]; 765 } 766 EXPORT_SYMBOL(rtw_tx_ac_to_hwq); 767 768 enum rtw_tx_queue_type rtw_tx_queue_mapping(struct sk_buff *skb) 769 { 770 struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)skb->data; 771 __le16 fc = hdr->frame_control; 772 u8 q_mapping = skb_get_queue_mapping(skb); 773 enum rtw_tx_queue_type queue; 774 775 if (unlikely(ieee80211_is_beacon(fc))) 776 queue = RTW_TX_QUEUE_BCN; 777 else if (unlikely(ieee80211_is_mgmt(fc) || ieee80211_is_ctl(fc))) 778 queue = RTW_TX_QUEUE_MGMT; 779 else if (is_broadcast_ether_addr(hdr->addr1) || 780 is_multicast_ether_addr(hdr->addr1)) 781 queue = RTW_TX_QUEUE_HI0; 782 else if (WARN_ON_ONCE(q_mapping >= ARRAY_SIZE(ac_to_hwq))) 783 queue = ac_to_hwq[IEEE80211_AC_BE]; 784 else 785 queue = ac_to_hwq[q_mapping]; 786 787 return queue; 788 } 789 EXPORT_SYMBOL(rtw_tx_queue_mapping); 790