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