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 __le32 *txdesc = (__le32 *)skb->data; 38 39 SET_TX_DESC_TXPKTSIZE(txdesc, pkt_info->tx_pkt_size); 40 SET_TX_DESC_OFFSET(txdesc, pkt_info->offset); 41 SET_TX_DESC_PKT_OFFSET(txdesc, pkt_info->pkt_offset); 42 SET_TX_DESC_QSEL(txdesc, pkt_info->qsel); 43 SET_TX_DESC_BMC(txdesc, pkt_info->bmc); 44 SET_TX_DESC_RATE_ID(txdesc, pkt_info->rate_id); 45 SET_TX_DESC_DATARATE(txdesc, pkt_info->rate); 46 SET_TX_DESC_DISDATAFB(txdesc, pkt_info->dis_rate_fallback); 47 SET_TX_DESC_USE_RATE(txdesc, pkt_info->use_rate); 48 SET_TX_DESC_SEC_TYPE(txdesc, pkt_info->sec_type); 49 SET_TX_DESC_DATA_BW(txdesc, pkt_info->bw); 50 SET_TX_DESC_SW_SEQ(txdesc, pkt_info->seq); 51 SET_TX_DESC_MAX_AGG_NUM(txdesc, pkt_info->ampdu_factor); 52 SET_TX_DESC_AMPDU_DENSITY(txdesc, pkt_info->ampdu_density); 53 SET_TX_DESC_DATA_STBC(txdesc, pkt_info->stbc); 54 SET_TX_DESC_DATA_LDPC(txdesc, pkt_info->ldpc); 55 SET_TX_DESC_AGG_EN(txdesc, pkt_info->ampdu_en); 56 SET_TX_DESC_LS(txdesc, pkt_info->ls); 57 SET_TX_DESC_DATA_SHORT(txdesc, pkt_info->short_gi); 58 SET_TX_DESC_SPE_RPT(txdesc, pkt_info->report); 59 SET_TX_DESC_SW_DEFINE(txdesc, pkt_info->sn); 60 SET_TX_DESC_USE_RTS(txdesc, pkt_info->rts); 61 } 62 EXPORT_SYMBOL(rtw_tx_fill_tx_desc); 63 64 static u8 get_tx_ampdu_factor(struct ieee80211_sta *sta) 65 { 66 u8 exp = sta->ht_cap.ampdu_factor; 67 68 /* the least ampdu factor is 8K, and the value in the tx desc is the 69 * max aggregation num, which represents val * 2 packets can be 70 * aggregated in an AMPDU, so here we should use 8/2=4 as the base 71 */ 72 return (BIT(2) << exp) - 1; 73 } 74 75 static u8 get_tx_ampdu_density(struct ieee80211_sta *sta) 76 { 77 return sta->ht_cap.ampdu_density; 78 } 79 80 static u8 get_highest_ht_tx_rate(struct rtw_dev *rtwdev, 81 struct ieee80211_sta *sta) 82 { 83 u8 rate; 84 85 if (rtwdev->hal.rf_type == RF_2T2R && sta->ht_cap.mcs.rx_mask[1] != 0) 86 rate = DESC_RATEMCS15; 87 else 88 rate = DESC_RATEMCS7; 89 90 return rate; 91 } 92 93 static u8 get_highest_vht_tx_rate(struct rtw_dev *rtwdev, 94 struct ieee80211_sta *sta) 95 { 96 struct rtw_efuse *efuse = &rtwdev->efuse; 97 u8 rate; 98 u16 tx_mcs_map; 99 100 tx_mcs_map = le16_to_cpu(sta->vht_cap.vht_mcs.tx_mcs_map); 101 if (efuse->hw_cap.nss == 1) { 102 switch (tx_mcs_map & 0x3) { 103 case IEEE80211_VHT_MCS_SUPPORT_0_7: 104 rate = DESC_RATEVHT1SS_MCS7; 105 break; 106 case IEEE80211_VHT_MCS_SUPPORT_0_8: 107 rate = DESC_RATEVHT1SS_MCS8; 108 break; 109 default: 110 case IEEE80211_VHT_MCS_SUPPORT_0_9: 111 rate = DESC_RATEVHT1SS_MCS9; 112 break; 113 } 114 } else if (efuse->hw_cap.nss >= 2) { 115 switch ((tx_mcs_map & 0xc) >> 2) { 116 case IEEE80211_VHT_MCS_SUPPORT_0_7: 117 rate = DESC_RATEVHT2SS_MCS7; 118 break; 119 case IEEE80211_VHT_MCS_SUPPORT_0_8: 120 rate = DESC_RATEVHT2SS_MCS8; 121 break; 122 default: 123 case IEEE80211_VHT_MCS_SUPPORT_0_9: 124 rate = DESC_RATEVHT2SS_MCS9; 125 break; 126 } 127 } else { 128 rate = DESC_RATEVHT1SS_MCS9; 129 } 130 131 return rate; 132 } 133 134 static void rtw_tx_report_enable(struct rtw_dev *rtwdev, 135 struct rtw_tx_pkt_info *pkt_info) 136 { 137 struct rtw_tx_report *tx_report = &rtwdev->tx_report; 138 139 /* [11:8], reserved, fills with zero 140 * [7:2], tx report sequence number 141 * [1:0], firmware use, fills with zero 142 */ 143 pkt_info->sn = (atomic_inc_return(&tx_report->sn) << 2) & 0xfc; 144 pkt_info->report = true; 145 } 146 147 void rtw_tx_report_purge_timer(struct timer_list *t) 148 { 149 struct rtw_dev *rtwdev = from_timer(rtwdev, t, tx_report.purge_timer); 150 struct rtw_tx_report *tx_report = &rtwdev->tx_report; 151 unsigned long flags; 152 153 if (skb_queue_len(&tx_report->queue) == 0) 154 return; 155 156 WARN(1, "purge skb(s) not reported by firmware\n"); 157 158 spin_lock_irqsave(&tx_report->q_lock, flags); 159 skb_queue_purge(&tx_report->queue); 160 spin_unlock_irqrestore(&tx_report->q_lock, flags); 161 } 162 163 void rtw_tx_report_enqueue(struct rtw_dev *rtwdev, struct sk_buff *skb, u8 sn) 164 { 165 struct rtw_tx_report *tx_report = &rtwdev->tx_report; 166 unsigned long flags; 167 u8 *drv_data; 168 169 /* pass sn to tx report handler through driver data */ 170 drv_data = (u8 *)IEEE80211_SKB_CB(skb)->status.status_driver_data; 171 *drv_data = sn; 172 173 spin_lock_irqsave(&tx_report->q_lock, flags); 174 __skb_queue_tail(&tx_report->queue, skb); 175 spin_unlock_irqrestore(&tx_report->q_lock, flags); 176 177 mod_timer(&tx_report->purge_timer, jiffies + RTW_TX_PROBE_TIMEOUT); 178 } 179 EXPORT_SYMBOL(rtw_tx_report_enqueue); 180 181 static void rtw_tx_report_tx_status(struct rtw_dev *rtwdev, 182 struct sk_buff *skb, bool acked) 183 { 184 struct ieee80211_tx_info *info; 185 186 info = IEEE80211_SKB_CB(skb); 187 ieee80211_tx_info_clear_status(info); 188 if (acked) 189 info->flags |= IEEE80211_TX_STAT_ACK; 190 else 191 info->flags &= ~IEEE80211_TX_STAT_ACK; 192 193 ieee80211_tx_status_irqsafe(rtwdev->hw, skb); 194 } 195 196 void rtw_tx_report_handle(struct rtw_dev *rtwdev, struct sk_buff *skb) 197 { 198 struct rtw_tx_report *tx_report = &rtwdev->tx_report; 199 struct rtw_c2h_cmd *c2h; 200 struct sk_buff *cur, *tmp; 201 unsigned long flags; 202 u8 sn, st; 203 u8 *n; 204 205 c2h = get_c2h_from_skb(skb); 206 207 sn = GET_CCX_REPORT_SEQNUM(c2h->payload); 208 st = GET_CCX_REPORT_STATUS(c2h->payload); 209 210 spin_lock_irqsave(&tx_report->q_lock, flags); 211 skb_queue_walk_safe(&tx_report->queue, cur, tmp) { 212 n = (u8 *)IEEE80211_SKB_CB(cur)->status.status_driver_data; 213 if (*n == sn) { 214 __skb_unlink(cur, &tx_report->queue); 215 rtw_tx_report_tx_status(rtwdev, cur, st == 0); 216 break; 217 } 218 } 219 spin_unlock_irqrestore(&tx_report->q_lock, flags); 220 } 221 222 static void rtw_tx_mgmt_pkt_info_update(struct rtw_dev *rtwdev, 223 struct rtw_tx_pkt_info *pkt_info, 224 struct ieee80211_sta *sta, 225 struct sk_buff *skb) 226 { 227 pkt_info->use_rate = true; 228 pkt_info->rate_id = 6; 229 pkt_info->dis_rate_fallback = true; 230 } 231 232 static void rtw_tx_data_pkt_info_update(struct rtw_dev *rtwdev, 233 struct rtw_tx_pkt_info *pkt_info, 234 struct ieee80211_sta *sta, 235 struct sk_buff *skb) 236 { 237 struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)skb->data; 238 struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb); 239 struct rtw_sta_info *si; 240 u16 seq; 241 u8 ampdu_factor = 0; 242 u8 ampdu_density = 0; 243 bool ampdu_en = false; 244 u8 rate = DESC_RATE6M; 245 u8 rate_id = 6; 246 u8 bw = RTW_CHANNEL_WIDTH_20; 247 bool stbc = false; 248 bool ldpc = false; 249 250 seq = (le16_to_cpu(hdr->seq_ctrl) & IEEE80211_SCTL_SEQ) >> 4; 251 252 /* for broadcast/multicast, use default values */ 253 if (!sta) 254 goto out; 255 256 if (info->flags & IEEE80211_TX_CTL_AMPDU) { 257 ampdu_en = true; 258 ampdu_factor = get_tx_ampdu_factor(sta); 259 ampdu_density = get_tx_ampdu_density(sta); 260 } 261 262 if (info->control.use_rts) 263 pkt_info->rts = true; 264 265 if (sta->vht_cap.vht_supported) 266 rate = get_highest_vht_tx_rate(rtwdev, sta); 267 else if (sta->ht_cap.ht_supported) 268 rate = get_highest_ht_tx_rate(rtwdev, sta); 269 else if (sta->supp_rates[0] <= 0xf) 270 rate = DESC_RATE11M; 271 else 272 rate = DESC_RATE54M; 273 274 si = (struct rtw_sta_info *)sta->drv_priv; 275 276 bw = si->bw_mode; 277 rate_id = si->rate_id; 278 stbc = si->stbc_en; 279 ldpc = si->ldpc_en; 280 281 out: 282 pkt_info->seq = seq; 283 pkt_info->ampdu_factor = ampdu_factor; 284 pkt_info->ampdu_density = ampdu_density; 285 pkt_info->ampdu_en = ampdu_en; 286 pkt_info->rate = rate; 287 pkt_info->rate_id = rate_id; 288 pkt_info->bw = bw; 289 pkt_info->stbc = stbc; 290 pkt_info->ldpc = ldpc; 291 } 292 293 void rtw_tx_pkt_info_update(struct rtw_dev *rtwdev, 294 struct rtw_tx_pkt_info *pkt_info, 295 struct ieee80211_sta *sta, 296 struct sk_buff *skb) 297 { 298 struct rtw_chip_info *chip = rtwdev->chip; 299 struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb); 300 struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)skb->data; 301 struct rtw_sta_info *si; 302 struct ieee80211_vif *vif = NULL; 303 __le16 fc = hdr->frame_control; 304 u8 sec_type = 0; 305 bool bmc; 306 307 if (sta) { 308 si = (struct rtw_sta_info *)sta->drv_priv; 309 vif = si->vif; 310 } 311 312 if (ieee80211_is_mgmt(fc) || ieee80211_is_nullfunc(fc)) 313 rtw_tx_mgmt_pkt_info_update(rtwdev, pkt_info, sta, skb); 314 else if (ieee80211_is_data(fc)) 315 rtw_tx_data_pkt_info_update(rtwdev, pkt_info, sta, skb); 316 317 if (info->control.hw_key) { 318 struct ieee80211_key_conf *key = info->control.hw_key; 319 320 switch (key->cipher) { 321 case WLAN_CIPHER_SUITE_WEP40: 322 case WLAN_CIPHER_SUITE_WEP104: 323 case WLAN_CIPHER_SUITE_TKIP: 324 sec_type = 0x01; 325 break; 326 case WLAN_CIPHER_SUITE_CCMP: 327 sec_type = 0x03; 328 break; 329 default: 330 break; 331 } 332 } 333 334 bmc = is_broadcast_ether_addr(hdr->addr1) || 335 is_multicast_ether_addr(hdr->addr1); 336 337 if (info->flags & IEEE80211_TX_CTL_REQ_TX_STATUS) 338 rtw_tx_report_enable(rtwdev, pkt_info); 339 340 pkt_info->bmc = bmc; 341 pkt_info->sec_type = sec_type; 342 pkt_info->tx_pkt_size = skb->len; 343 pkt_info->offset = chip->tx_pkt_desc_sz; 344 pkt_info->qsel = skb->priority; 345 pkt_info->ls = true; 346 347 /* maybe merge with tx status ? */ 348 rtw_tx_stats(rtwdev, vif, skb); 349 } 350 351 void rtw_rsvd_page_pkt_info_update(struct rtw_dev *rtwdev, 352 struct rtw_tx_pkt_info *pkt_info, 353 struct sk_buff *skb) 354 { 355 struct rtw_chip_info *chip = rtwdev->chip; 356 struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)skb->data; 357 bool bmc; 358 359 bmc = is_broadcast_ether_addr(hdr->addr1) || 360 is_multicast_ether_addr(hdr->addr1); 361 pkt_info->use_rate = true; 362 pkt_info->rate_id = 6; 363 pkt_info->dis_rate_fallback = true; 364 pkt_info->bmc = bmc; 365 pkt_info->tx_pkt_size = skb->len; 366 pkt_info->offset = chip->tx_pkt_desc_sz; 367 pkt_info->qsel = TX_DESC_QSEL_MGMT; 368 pkt_info->ls = true; 369 } 370 371 struct sk_buff * 372 rtw_tx_write_data_rsvd_page_get(struct rtw_dev *rtwdev, 373 struct rtw_tx_pkt_info *pkt_info, 374 u8 *buf, u32 size) 375 { 376 struct rtw_chip_info *chip = rtwdev->chip; 377 struct sk_buff *skb; 378 u32 tx_pkt_desc_sz; 379 u32 length; 380 381 tx_pkt_desc_sz = chip->tx_pkt_desc_sz; 382 length = size + tx_pkt_desc_sz; 383 skb = dev_alloc_skb(length); 384 if (!skb) { 385 rtw_err(rtwdev, "failed to alloc write data rsvd page skb\n"); 386 return NULL; 387 } 388 389 skb_reserve(skb, tx_pkt_desc_sz); 390 skb_put_data(skb, buf, size); 391 pkt_info->tx_pkt_size = size; 392 pkt_info->offset = tx_pkt_desc_sz; 393 394 return skb; 395 } 396 EXPORT_SYMBOL(rtw_tx_write_data_rsvd_page_get); 397 398 struct sk_buff * 399 rtw_tx_write_data_h2c_get(struct rtw_dev *rtwdev, 400 struct rtw_tx_pkt_info *pkt_info, 401 u8 *buf, u32 size) 402 { 403 struct rtw_chip_info *chip = rtwdev->chip; 404 struct sk_buff *skb; 405 u32 tx_pkt_desc_sz; 406 u32 length; 407 408 tx_pkt_desc_sz = chip->tx_pkt_desc_sz; 409 length = size + tx_pkt_desc_sz; 410 skb = dev_alloc_skb(length); 411 if (!skb) { 412 rtw_err(rtwdev, "failed to alloc write data h2c skb\n"); 413 return NULL; 414 } 415 416 skb_reserve(skb, tx_pkt_desc_sz); 417 skb_put_data(skb, buf, size); 418 pkt_info->tx_pkt_size = size; 419 420 return skb; 421 } 422 EXPORT_SYMBOL(rtw_tx_write_data_h2c_get); 423 424 void rtw_tx(struct rtw_dev *rtwdev, 425 struct ieee80211_tx_control *control, 426 struct sk_buff *skb) 427 { 428 struct rtw_tx_pkt_info pkt_info = {0}; 429 int ret; 430 431 rtw_tx_pkt_info_update(rtwdev, &pkt_info, control->sta, skb); 432 ret = rtw_hci_tx_write(rtwdev, &pkt_info, skb); 433 if (ret) { 434 rtw_err(rtwdev, "failed to write TX skb to HCI\n"); 435 goto out; 436 } 437 438 rtw_hci_tx_kick_off(rtwdev); 439 440 return; 441 442 out: 443 ieee80211_free_txskb(rtwdev->hw, skb); 444 } 445 446 static void rtw_txq_check_agg(struct rtw_dev *rtwdev, 447 struct rtw_txq *rtwtxq, 448 struct sk_buff *skb) 449 { 450 struct ieee80211_txq *txq = rtwtxq_to_txq(rtwtxq); 451 struct ieee80211_tx_info *info; 452 struct rtw_sta_info *si; 453 454 if (test_bit(RTW_TXQ_AMPDU, &rtwtxq->flags)) { 455 info = IEEE80211_SKB_CB(skb); 456 info->flags |= IEEE80211_TX_CTL_AMPDU; 457 return; 458 } 459 460 if (skb_get_queue_mapping(skb) == IEEE80211_AC_VO) 461 return; 462 463 if (test_bit(RTW_TXQ_BLOCK_BA, &rtwtxq->flags)) 464 return; 465 466 if (unlikely(skb->protocol == cpu_to_be16(ETH_P_PAE))) 467 return; 468 469 if (!txq->sta) 470 return; 471 472 si = (struct rtw_sta_info *)txq->sta->drv_priv; 473 set_bit(txq->tid, si->tid_ba); 474 475 ieee80211_queue_work(rtwdev->hw, &rtwdev->ba_work); 476 } 477 478 static int rtw_txq_push_skb(struct rtw_dev *rtwdev, 479 struct rtw_txq *rtwtxq, 480 struct sk_buff *skb) 481 { 482 struct ieee80211_txq *txq = rtwtxq_to_txq(rtwtxq); 483 struct rtw_tx_pkt_info pkt_info = {0}; 484 int ret; 485 486 rtw_txq_check_agg(rtwdev, rtwtxq, skb); 487 488 rtw_tx_pkt_info_update(rtwdev, &pkt_info, txq->sta, skb); 489 ret = rtw_hci_tx_write(rtwdev, &pkt_info, skb); 490 if (ret) { 491 rtw_err(rtwdev, "failed to write TX skb to HCI\n"); 492 return ret; 493 } 494 rtwtxq->last_push = jiffies; 495 496 return 0; 497 } 498 499 static struct sk_buff *rtw_txq_dequeue(struct rtw_dev *rtwdev, 500 struct rtw_txq *rtwtxq) 501 { 502 struct ieee80211_txq *txq = rtwtxq_to_txq(rtwtxq); 503 struct sk_buff *skb; 504 505 skb = ieee80211_tx_dequeue(rtwdev->hw, txq); 506 if (!skb) 507 return NULL; 508 509 return skb; 510 } 511 512 static void rtw_txq_push(struct rtw_dev *rtwdev, 513 struct rtw_txq *rtwtxq, 514 unsigned long frames) 515 { 516 struct sk_buff *skb; 517 int ret; 518 int i; 519 520 rcu_read_lock(); 521 522 for (i = 0; i < frames; i++) { 523 skb = rtw_txq_dequeue(rtwdev, rtwtxq); 524 if (!skb) 525 break; 526 527 ret = rtw_txq_push_skb(rtwdev, rtwtxq, skb); 528 if (ret) { 529 rtw_err(rtwdev, "failed to pusk skb, ret %d\n", ret); 530 break; 531 } 532 } 533 534 rcu_read_unlock(); 535 } 536 537 void rtw_tx_tasklet(unsigned long data) 538 { 539 struct rtw_dev *rtwdev = (void *)data; 540 struct rtw_txq *rtwtxq, *tmp; 541 542 spin_lock_bh(&rtwdev->txq_lock); 543 544 list_for_each_entry_safe(rtwtxq, tmp, &rtwdev->txqs, list) { 545 struct ieee80211_txq *txq = rtwtxq_to_txq(rtwtxq); 546 unsigned long frame_cnt; 547 unsigned long byte_cnt; 548 549 ieee80211_txq_get_depth(txq, &frame_cnt, &byte_cnt); 550 rtw_txq_push(rtwdev, rtwtxq, frame_cnt); 551 552 list_del_init(&rtwtxq->list); 553 } 554 555 rtw_hci_tx_kick_off(rtwdev); 556 557 spin_unlock_bh(&rtwdev->txq_lock); 558 } 559 560 void rtw_txq_init(struct rtw_dev *rtwdev, struct ieee80211_txq *txq) 561 { 562 struct rtw_txq *rtwtxq; 563 564 if (!txq) 565 return; 566 567 rtwtxq = (struct rtw_txq *)txq->drv_priv; 568 INIT_LIST_HEAD(&rtwtxq->list); 569 } 570 571 void rtw_txq_cleanup(struct rtw_dev *rtwdev, struct ieee80211_txq *txq) 572 { 573 struct rtw_txq *rtwtxq; 574 575 if (!txq) 576 return; 577 578 rtwtxq = (struct rtw_txq *)txq->drv_priv; 579 spin_lock_bh(&rtwdev->txq_lock); 580 if (!list_empty(&rtwtxq->list)) 581 list_del_init(&rtwtxq->list); 582 spin_unlock_bh(&rtwdev->txq_lock); 583 } 584