1 // SPDX-License-Identifier: BSD-3-Clause-Clear 2 /* 3 * Copyright (c) 2019-2021 The Linux Foundation. All rights reserved. 4 * Copyright (c) Qualcomm Technologies, Inc. and/or its subsidiaries. 5 */ 6 7 #include "../core.h" 8 #include "../debug.h" 9 #include "../dp_tx.h" 10 #include "../peer.h" 11 #include "dp_tx.h" 12 #include "hal_desc.h" 13 #include "hal.h" 14 #include "hal_tx.h" 15 16 static void 17 ath12k_wifi7_hal_tx_cmd_ext_desc_setup(struct ath12k_base *ab, 18 struct hal_tx_msdu_ext_desc *tcl_ext_cmd, 19 struct hal_tx_info *ti) 20 { 21 tcl_ext_cmd->info0 = le32_encode_bits(ti->paddr, 22 HAL_TX_MSDU_EXT_INFO0_BUF_PTR_LO); 23 tcl_ext_cmd->info1 = le32_encode_bits(0x0, 24 HAL_TX_MSDU_EXT_INFO1_BUF_PTR_HI) | 25 le32_encode_bits(ti->data_len, 26 HAL_TX_MSDU_EXT_INFO1_BUF_LEN); 27 28 tcl_ext_cmd->info1 |= le32_encode_bits(1, HAL_TX_MSDU_EXT_INFO1_EXTN_OVERRIDE) | 29 le32_encode_bits(ti->encap_type, 30 HAL_TX_MSDU_EXT_INFO1_ENCAP_TYPE) | 31 le32_encode_bits(ti->encrypt_type, 32 HAL_TX_MSDU_EXT_INFO1_ENCRYPT_TYPE); 33 } 34 35 #define HTT_META_DATA_ALIGNMENT 0x8 36 37 /* Preparing HTT Metadata when utilized with ext MSDU */ 38 static int ath12k_wifi7_dp_prepare_htt_metadata(struct sk_buff *skb) 39 { 40 struct hal_tx_msdu_metadata *desc_ext; 41 u8 htt_desc_size; 42 /* Size rounded of multiple of 8 bytes */ 43 u8 htt_desc_size_aligned; 44 45 htt_desc_size = sizeof(struct hal_tx_msdu_metadata); 46 htt_desc_size_aligned = ALIGN(htt_desc_size, HTT_META_DATA_ALIGNMENT); 47 48 desc_ext = ath12k_dp_metadata_align_skb(skb, htt_desc_size_aligned); 49 if (!desc_ext) 50 return -ENOMEM; 51 52 desc_ext->info0 = le32_encode_bits(1, HAL_TX_MSDU_METADATA_INFO0_ENCRYPT_FLAG) | 53 le32_encode_bits(0, HAL_TX_MSDU_METADATA_INFO0_ENCRYPT_TYPE) | 54 le32_encode_bits(1, 55 HAL_TX_MSDU_METADATA_INFO0_HOST_TX_DESC_POOL); 56 57 return 0; 58 } 59 60 /* TODO: Remove the export once this file is built with wifi7 ko */ 61 int ath12k_wifi7_dp_tx(struct ath12k_pdev_dp *dp_pdev, struct ath12k_link_vif *arvif, 62 struct sk_buff *skb, bool gsn_valid, int mcbc_gsn, 63 bool is_mcast) 64 { 65 struct ath12k_dp *dp = dp_pdev->dp; 66 struct ath12k_hal *hal = dp->hal; 67 struct ath12k_base *ab = dp->ab; 68 struct hal_tx_info ti = {}; 69 struct ath12k_tx_desc_info *tx_desc; 70 struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb); 71 struct ath12k_skb_cb *skb_cb = ATH12K_SKB_CB(skb); 72 struct hal_tcl_data_cmd *hal_tcl_desc; 73 struct hal_tx_msdu_ext_desc *msg; 74 struct sk_buff *skb_ext_desc = NULL; 75 struct hal_srng *tcl_ring; 76 struct ieee80211_hdr *hdr = (void *)skb->data; 77 struct ath12k_vif *ahvif = arvif->ahvif; 78 struct ath12k_dp_vif *dp_vif = &ahvif->dp_vif; 79 struct ath12k_dp_link_vif *dp_link_vif; 80 struct dp_tx_ring *tx_ring; 81 u8 pool_id; 82 u8 hal_ring_id; 83 int ret; 84 u8 ring_selector, ring_map = 0; 85 bool tcl_ring_retry; 86 bool msdu_ext_desc = false; 87 bool add_htt_metadata = false; 88 u32 iova_mask = dp->hw_params->iova_mask; 89 bool is_diff_encap = false; 90 bool is_null_frame = false; 91 92 if (test_bit(ATH12K_FLAG_CRASH_FLUSH, &ab->dev_flags)) 93 return -ESHUTDOWN; 94 95 if (!(info->flags & IEEE80211_TX_CTL_HW_80211_ENCAP) && 96 !ieee80211_is_data(hdr->frame_control)) 97 return -EOPNOTSUPP; 98 99 pool_id = skb_get_queue_mapping(skb) & (ATH12K_HW_MAX_QUEUES - 1); 100 101 /* Let the default ring selection be based on current processor 102 * number, where one of the 3 tcl rings are selected based on 103 * the smp_processor_id(). In case that ring 104 * is full/busy, we resort to other available rings. 105 * If all rings are full, we drop the packet. 106 * TODO: Add throttling logic when all rings are full 107 */ 108 ring_selector = dp->hw_params->hw_ops->get_ring_selector(skb); 109 110 tcl_ring_sel: 111 tcl_ring_retry = false; 112 ti.ring_id = ring_selector % dp->hw_params->max_tx_ring; 113 114 ring_map |= BIT(ti.ring_id); 115 ti.rbm_id = hal->tcl_to_wbm_rbm_map[ti.ring_id].rbm_id; 116 117 tx_ring = &dp->tx_ring[ti.ring_id]; 118 119 tx_desc = ath12k_dp_tx_assign_buffer(dp, pool_id); 120 if (!tx_desc) 121 return -ENOMEM; 122 123 dp_link_vif = ath12k_dp_vif_to_dp_link_vif(&ahvif->dp_vif, arvif->link_id); 124 125 ti.bank_id = dp_link_vif->bank_id; 126 ti.meta_data_flags = dp_link_vif->tcl_metadata; 127 128 if (dp_vif->tx_encap_type == HAL_TCL_ENCAP_TYPE_RAW && 129 test_bit(ATH12K_FLAG_HW_CRYPTO_DISABLED, &ab->dev_flags)) { 130 if (skb_cb->flags & ATH12K_SKB_CIPHER_SET) { 131 ti.encrypt_type = 132 ath12k_dp_tx_get_encrypt_type(skb_cb->cipher); 133 134 if (ieee80211_has_protected(hdr->frame_control)) 135 skb_put(skb, IEEE80211_CCMP_MIC_LEN); 136 } else { 137 ti.encrypt_type = HAL_ENCRYPT_TYPE_OPEN; 138 } 139 140 msdu_ext_desc = true; 141 } 142 143 if (gsn_valid) { 144 /* Reset and Initialize meta_data_flags with Global Sequence 145 * Number (GSN) info. 146 */ 147 ti.meta_data_flags = 148 u32_encode_bits(HTT_TCL_META_DATA_TYPE_GLOBAL_SEQ_NUM, 149 HTT_TCL_META_DATA_TYPE) | 150 u32_encode_bits(mcbc_gsn, HTT_TCL_META_DATA_GLOBAL_SEQ_NUM); 151 } 152 153 ti.encap_type = ath12k_dp_tx_get_encap_type(ab, skb); 154 ti.addr_search_flags = dp_link_vif->hal_addr_search_flags; 155 ti.search_type = dp_link_vif->search_type; 156 ti.type = HAL_TCL_DESC_TYPE_BUFFER; 157 ti.pkt_offset = 0; 158 ti.lmac_id = dp_link_vif->lmac_id; 159 160 ti.vdev_id = dp_link_vif->vdev_id; 161 if (gsn_valid) 162 ti.vdev_id += HTT_TX_MLO_MCAST_HOST_REINJECT_BASE_VDEV_ID; 163 164 ti.bss_ast_hash = dp_link_vif->ast_hash; 165 ti.bss_ast_idx = dp_link_vif->ast_idx; 166 ti.dscp_tid_tbl_idx = 0; 167 168 if (skb->ip_summed == CHECKSUM_PARTIAL && 169 ti.encap_type != HAL_TCL_ENCAP_TYPE_RAW) { 170 ti.flags0 |= u32_encode_bits(1, HAL_TCL_DATA_CMD_INFO2_IP4_CKSUM_EN) | 171 u32_encode_bits(1, HAL_TCL_DATA_CMD_INFO2_UDP4_CKSUM_EN) | 172 u32_encode_bits(1, HAL_TCL_DATA_CMD_INFO2_UDP6_CKSUM_EN) | 173 u32_encode_bits(1, HAL_TCL_DATA_CMD_INFO2_TCP4_CKSUM_EN) | 174 u32_encode_bits(1, HAL_TCL_DATA_CMD_INFO2_TCP6_CKSUM_EN); 175 } 176 177 ti.flags1 |= u32_encode_bits(1, HAL_TCL_DATA_CMD_INFO3_TID_OVERWRITE); 178 179 ti.tid = ath12k_dp_tx_get_tid(skb); 180 181 switch (ti.encap_type) { 182 case HAL_TCL_ENCAP_TYPE_NATIVE_WIFI: 183 is_null_frame = ieee80211_is_nullfunc(hdr->frame_control); 184 if (ahvif->vif->offload_flags & IEEE80211_OFFLOAD_ENCAP_ENABLED) { 185 if (skb->protocol == cpu_to_be16(ETH_P_PAE) || is_null_frame) 186 is_diff_encap = true; 187 188 /* Firmware expects msdu ext descriptor for nwifi/raw packets 189 * received in ETH mode. Without this, observed tx fail for 190 * Multicast packets in ETH mode. 191 */ 192 msdu_ext_desc = true; 193 } else { 194 ath12k_dp_tx_encap_nwifi(skb); 195 } 196 break; 197 case HAL_TCL_ENCAP_TYPE_RAW: 198 if (!test_bit(ATH12K_FLAG_RAW_MODE, &ab->dev_flags)) { 199 ret = -EINVAL; 200 goto fail_remove_tx_buf; 201 } 202 break; 203 case HAL_TCL_ENCAP_TYPE_ETHERNET: 204 /* no need to encap */ 205 break; 206 case HAL_TCL_ENCAP_TYPE_802_3: 207 default: 208 /* TODO: Take care of other encap modes as well */ 209 ret = -EINVAL; 210 atomic_inc(&dp->device_stats.tx_err.misc_fail); 211 goto fail_remove_tx_buf; 212 } 213 214 if (iova_mask && 215 (unsigned long)skb->data & iova_mask) { 216 ret = ath12k_dp_tx_align_payload(dp, &skb); 217 if (ret) { 218 ath12k_warn(ab, "failed to align TX buffer %d\n", ret); 219 /* don't bail out, give original buffer 220 * a chance even unaligned. 221 */ 222 goto map; 223 } 224 225 /* hdr is pointing to a wrong place after alignment, 226 * so refresh it for later use. 227 */ 228 hdr = (void *)skb->data; 229 } 230 map: 231 ti.paddr = dma_map_single(dp->dev, skb->data, skb->len, DMA_TO_DEVICE); 232 if (dma_mapping_error(dp->dev, ti.paddr)) { 233 atomic_inc(&dp->device_stats.tx_err.misc_fail); 234 ath12k_warn(ab, "failed to DMA map data Tx buffer\n"); 235 ret = -ENOMEM; 236 goto fail_remove_tx_buf; 237 } 238 239 if ((!test_bit(ATH12K_FLAG_HW_CRYPTO_DISABLED, &ab->dev_flags) && 240 !(skb_cb->flags & ATH12K_SKB_HW_80211_ENCAP) && 241 !(skb_cb->flags & ATH12K_SKB_CIPHER_SET) && 242 ieee80211_has_protected(hdr->frame_control)) || 243 is_diff_encap) { 244 /* Firmware is not expecting meta data for qos null 245 * nwifi packet received in ETH encap mode. 246 */ 247 if (is_null_frame && msdu_ext_desc) 248 goto skip_htt_meta; 249 250 /* Add metadata for sw encrypted vlan group traffic 251 * and EAPOL nwifi packet received in ETH encap mode. 252 */ 253 add_htt_metadata = true; 254 msdu_ext_desc = true; 255 ti.meta_data_flags |= HTT_TCL_META_DATA_VALID_HTT; 256 skip_htt_meta: 257 ti.flags0 |= u32_encode_bits(1, HAL_TCL_DATA_CMD_INFO2_TO_FW); 258 ti.encap_type = HAL_TCL_ENCAP_TYPE_RAW; 259 ti.encrypt_type = HAL_ENCRYPT_TYPE_OPEN; 260 } 261 262 tx_desc->skb = skb; 263 tx_desc->mac_id = dp_link_vif->pdev_idx; 264 ti.desc_id = tx_desc->desc_id; 265 ti.data_len = skb->len; 266 skb_cb->paddr = ti.paddr; 267 268 if (msdu_ext_desc) { 269 skb_ext_desc = dev_alloc_skb(sizeof(struct hal_tx_msdu_ext_desc)); 270 if (!skb_ext_desc) { 271 ret = -ENOMEM; 272 goto fail_unmap_dma; 273 } 274 275 skb_put(skb_ext_desc, sizeof(struct hal_tx_msdu_ext_desc)); 276 memset(skb_ext_desc->data, 0, skb_ext_desc->len); 277 278 msg = (struct hal_tx_msdu_ext_desc *)skb_ext_desc->data; 279 ath12k_wifi7_hal_tx_cmd_ext_desc_setup(ab, msg, &ti); 280 281 if (add_htt_metadata) { 282 ret = ath12k_wifi7_dp_prepare_htt_metadata(skb_ext_desc); 283 if (ret < 0) { 284 ath12k_dbg(ab, ATH12K_DBG_DP_TX, 285 "Failed to add HTT meta data, dropping packet\n"); 286 goto fail_free_ext_skb; 287 } 288 } 289 290 ti.paddr = dma_map_single(dp->dev, skb_ext_desc->data, 291 skb_ext_desc->len, DMA_TO_DEVICE); 292 ret = dma_mapping_error(dp->dev, ti.paddr); 293 if (ret) 294 goto fail_free_ext_skb; 295 296 ti.data_len = skb_ext_desc->len; 297 ti.type = HAL_TCL_DESC_TYPE_EXT_DESC; 298 299 skb_cb->paddr_ext_desc = ti.paddr; 300 tx_desc->skb_ext_desc = skb_ext_desc; 301 } 302 303 hal_ring_id = tx_ring->tcl_data_ring.ring_id; 304 tcl_ring = &hal->srng_list[hal_ring_id]; 305 306 spin_lock_bh(&tcl_ring->lock); 307 308 ath12k_hal_srng_access_begin(ab, tcl_ring); 309 310 hal_tcl_desc = ath12k_hal_srng_src_get_next_entry(ab, tcl_ring); 311 if (!hal_tcl_desc) { 312 /* NOTE: It is highly unlikely we'll be running out of tcl_ring 313 * desc because the desc is directly enqueued onto hw queue. 314 */ 315 ath12k_hal_srng_access_end(ab, tcl_ring); 316 dp->device_stats.tx_err.desc_na[ti.ring_id]++; 317 spin_unlock_bh(&tcl_ring->lock); 318 ret = -ENOMEM; 319 320 /* Checking for available tcl descriptors in another ring in 321 * case of failure due to full tcl ring now, is better than 322 * checking this ring earlier for each pkt tx. 323 * Restart ring selection if some rings are not checked yet. 324 */ 325 if (ring_map != (BIT(dp->hw_params->max_tx_ring) - 1) && 326 dp->hw_params->tcl_ring_retry) { 327 tcl_ring_retry = true; 328 ring_selector++; 329 } 330 331 goto fail_unmap_dma_ext; 332 } 333 334 spin_lock_bh(&arvif->link_stats_lock); 335 arvif->link_stats.tx_encap_type[ti.encap_type]++; 336 arvif->link_stats.tx_encrypt_type[ti.encrypt_type]++; 337 arvif->link_stats.tx_desc_type[ti.type]++; 338 339 if (is_mcast) 340 arvif->link_stats.tx_bcast_mcast++; 341 else 342 arvif->link_stats.tx_enqueued++; 343 spin_unlock_bh(&arvif->link_stats_lock); 344 345 dp->device_stats.tx_enqueued[ti.ring_id]++; 346 347 ath12k_wifi7_hal_tx_cmd_desc_setup(ab, hal_tcl_desc, &ti); 348 349 ath12k_hal_srng_access_end(ab, tcl_ring); 350 351 spin_unlock_bh(&tcl_ring->lock); 352 353 ath12k_dbg_dump(ab, ATH12K_DBG_DP_TX, NULL, "dp tx msdu: ", 354 skb->data, skb->len); 355 356 atomic_inc(&dp_pdev->num_tx_pending); 357 358 return 0; 359 360 fail_unmap_dma_ext: 361 if (skb_cb->paddr_ext_desc) 362 dma_unmap_single(dp->dev, skb_cb->paddr_ext_desc, 363 skb_ext_desc->len, 364 DMA_TO_DEVICE); 365 fail_free_ext_skb: 366 kfree_skb(skb_ext_desc); 367 368 fail_unmap_dma: 369 dma_unmap_single(dp->dev, ti.paddr, ti.data_len, DMA_TO_DEVICE); 370 371 fail_remove_tx_buf: 372 ath12k_dp_tx_release_txbuf(dp, tx_desc, pool_id); 373 374 spin_lock_bh(&arvif->link_stats_lock); 375 arvif->link_stats.tx_dropped++; 376 spin_unlock_bh(&arvif->link_stats_lock); 377 378 if (tcl_ring_retry) 379 goto tcl_ring_sel; 380 381 return ret; 382 } 383 384 static void 385 ath12k_dp_tx_htt_tx_complete_buf(struct ath12k_dp *dp, 386 struct ath12k_tx_desc_params *desc_params, 387 struct dp_tx_ring *tx_ring, 388 struct ath12k_dp_htt_wbm_tx_status *ts, 389 u16 peer_id) 390 { 391 struct ath12k_base *ab = dp->ab; 392 struct ieee80211_tx_info *info; 393 struct ath12k_link_vif *arvif; 394 struct ath12k_skb_cb *skb_cb; 395 struct ieee80211_vif *vif; 396 struct ath12k_vif *ahvif; 397 struct sk_buff *msdu = desc_params->skb; 398 s32 noise_floor; 399 struct ieee80211_tx_status status = {}; 400 struct ath12k_dp_link_peer *peer; 401 struct ath12k_pdev_dp *dp_pdev; 402 u8 pdev_id; 403 404 skb_cb = ATH12K_SKB_CB(msdu); 405 info = IEEE80211_SKB_CB(msdu); 406 407 pdev_id = ath12k_hw_mac_id_to_pdev_id(dp->hw_params, desc_params->mac_id); 408 409 rcu_read_lock(); 410 dp_pdev = ath12k_dp_to_pdev_dp(dp, pdev_id); 411 if (!dp_pdev) { 412 rcu_read_unlock(); 413 return; 414 } 415 416 dp->device_stats.tx_completed[tx_ring->tcl_data_ring_id]++; 417 418 if (atomic_dec_and_test(&dp_pdev->num_tx_pending)) 419 wake_up(&dp_pdev->tx_empty_waitq); 420 421 dma_unmap_single(dp->dev, skb_cb->paddr, msdu->len, DMA_TO_DEVICE); 422 if (skb_cb->paddr_ext_desc) { 423 dma_unmap_single(dp->dev, skb_cb->paddr_ext_desc, 424 desc_params->skb_ext_desc->len, DMA_TO_DEVICE); 425 dev_kfree_skb_any(desc_params->skb_ext_desc); 426 } 427 428 vif = skb_cb->vif; 429 if (vif) { 430 ahvif = ath12k_vif_to_ahvif(vif); 431 arvif = rcu_dereference(ahvif->link[skb_cb->link_id]); 432 if (arvif) { 433 spin_lock_bh(&arvif->link_stats_lock); 434 arvif->link_stats.tx_completed++; 435 spin_unlock_bh(&arvif->link_stats_lock); 436 } 437 } 438 439 memset(&info->status, 0, sizeof(info->status)); 440 441 if (ts->acked) { 442 if (!(info->flags & IEEE80211_TX_CTL_NO_ACK)) { 443 info->flags |= IEEE80211_TX_STAT_ACK; 444 info->status.ack_signal = ts->ack_rssi; 445 446 if (!test_bit(WMI_TLV_SERVICE_HW_DB2DBM_CONVERSION_SUPPORT, 447 ab->wmi_ab.svc_map)) { 448 struct ath12k *ar = ath12k_pdev_dp_to_ar(dp_pdev); 449 450 spin_lock_bh(&ar->data_lock); 451 noise_floor = ath12k_pdev_get_noise_floor(ar); 452 spin_unlock_bh(&ar->data_lock); 453 454 info->status.ack_signal += noise_floor; 455 } 456 457 info->status.flags = IEEE80211_TX_STATUS_ACK_SIGNAL_VALID; 458 } else { 459 info->flags |= IEEE80211_TX_STAT_NOACK_TRANSMITTED; 460 } 461 } 462 463 peer = ath12k_dp_link_peer_find_by_peerid(dp_pdev, peer_id); 464 if (!peer || !peer->sta) { 465 ath12k_dbg(ab, ATH12K_DBG_DATA, 466 "dp_tx: failed to find the peer with peer_id %d\n", peer_id); 467 ieee80211_free_txskb(ath12k_pdev_dp_to_hw(dp_pdev), msdu); 468 goto exit; 469 } else { 470 status.sta = peer->sta; 471 } 472 473 status.info = info; 474 status.skb = msdu; 475 ieee80211_tx_status_ext(ath12k_pdev_dp_to_hw(dp_pdev), &status); 476 exit: 477 rcu_read_unlock(); 478 } 479 480 static void 481 ath12k_dp_tx_process_htt_tx_complete(struct ath12k_dp *dp, void *desc, 482 struct dp_tx_ring *tx_ring, 483 struct ath12k_tx_desc_params *desc_params) 484 { 485 struct htt_tx_wbm_completion *status_desc; 486 struct ath12k_dp_htt_wbm_tx_status ts = {}; 487 enum hal_wbm_htt_tx_comp_status wbm_status; 488 u16 peer_id; 489 490 status_desc = desc; 491 492 wbm_status = le32_get_bits(status_desc->info0, 493 HTT_TX_WBM_COMP_INFO0_STATUS); 494 dp->device_stats.fw_tx_status[wbm_status]++; 495 496 switch (wbm_status) { 497 case HAL_WBM_REL_HTT_TX_COMP_STATUS_OK: 498 ts.acked = (wbm_status == HAL_WBM_REL_HTT_TX_COMP_STATUS_OK); 499 ts.ack_rssi = le32_get_bits(status_desc->info2, 500 HTT_TX_WBM_COMP_INFO2_ACK_RSSI); 501 502 peer_id = le32_get_bits(((struct hal_wbm_completion_ring_tx *)desc)-> 503 info3, HAL_WBM_COMPL_TX_INFO3_PEER_ID); 504 505 ath12k_dp_tx_htt_tx_complete_buf(dp, desc_params, tx_ring, &ts, peer_id); 506 break; 507 case HAL_WBM_REL_HTT_TX_COMP_STATUS_DROP: 508 case HAL_WBM_REL_HTT_TX_COMP_STATUS_TTL: 509 case HAL_WBM_REL_HTT_TX_COMP_STATUS_REINJ: 510 case HAL_WBM_REL_HTT_TX_COMP_STATUS_INSPECT: 511 case HAL_WBM_REL_HTT_TX_COMP_STATUS_VDEVID_MISMATCH: 512 ath12k_dp_tx_free_txbuf(dp, tx_ring, desc_params); 513 break; 514 case HAL_WBM_REL_HTT_TX_COMP_STATUS_MEC_NOTIFY: 515 /* This event is to be handled only when the driver decides to 516 * use WDS offload functionality. 517 */ 518 break; 519 default: 520 ath12k_warn(dp->ab, "Unknown htt wbm tx status %d\n", wbm_status); 521 break; 522 } 523 } 524 525 static void ath12k_wifi7_dp_tx_update_txcompl(struct ath12k_pdev_dp *dp_pdev, 526 struct hal_tx_status *ts) 527 { 528 struct ath12k_dp *dp = dp_pdev->dp; 529 struct ath12k_dp_link_peer *peer; 530 struct ath12k_link_sta *arsta; 531 struct rate_info txrate = {}; 532 struct ieee80211_sta *sta; 533 struct ath12k_sta *ahsta; 534 u16 rate, ru_tones; 535 u8 rate_idx = 0; 536 int ret; 537 538 peer = ath12k_dp_link_peer_find_by_peerid(dp_pdev, ts->peer_id); 539 if (!peer || !peer->sta) { 540 ath12k_dbg(dp->ab, ATH12K_DBG_DP_TX, 541 "failed to find the peer by id %u\n", ts->peer_id); 542 return; 543 } 544 545 spin_lock_bh(&dp->dp_lock); 546 547 sta = peer->sta; 548 ahsta = ath12k_sta_to_ahsta(sta); 549 arsta = &ahsta->deflink; 550 551 spin_unlock_bh(&dp->dp_lock); 552 553 /* This is to prefer choose the real NSS value arsta->last_txrate.nss, 554 * if it is invalid, then choose the NSS value while assoc. 555 */ 556 if (peer->last_txrate.nss) 557 txrate.nss = peer->last_txrate.nss; 558 else 559 txrate.nss = arsta->peer_nss; 560 561 switch (ts->pkt_type) { 562 case HAL_TX_RATE_STATS_PKT_TYPE_11A: 563 case HAL_TX_RATE_STATS_PKT_TYPE_11B: 564 ret = ath12k_mac_hw_ratecode_to_legacy_rate(ts->mcs, 565 ts->pkt_type, 566 &rate_idx, 567 &rate); 568 if (ret < 0) { 569 ath12k_warn(dp->ab, "Invalid tx legacy rate %d\n", ret); 570 return; 571 } 572 573 txrate.legacy = rate; 574 break; 575 case HAL_TX_RATE_STATS_PKT_TYPE_11N: 576 if (ts->mcs > ATH12K_HT_MCS_MAX) { 577 ath12k_warn(dp->ab, "Invalid HT mcs index %d\n", ts->mcs); 578 return; 579 } 580 581 if (txrate.nss != 0) 582 txrate.mcs = ts->mcs + 8 * (txrate.nss - 1); 583 584 txrate.flags = RATE_INFO_FLAGS_MCS; 585 586 if (ts->sgi) 587 txrate.flags |= RATE_INFO_FLAGS_SHORT_GI; 588 break; 589 case HAL_TX_RATE_STATS_PKT_TYPE_11AC: 590 if (ts->mcs > ATH12K_VHT_MCS_MAX) { 591 ath12k_warn(dp->ab, "Invalid VHT mcs index %d\n", ts->mcs); 592 return; 593 } 594 595 txrate.mcs = ts->mcs; 596 txrate.flags = RATE_INFO_FLAGS_VHT_MCS; 597 598 if (ts->sgi) 599 txrate.flags |= RATE_INFO_FLAGS_SHORT_GI; 600 break; 601 case HAL_TX_RATE_STATS_PKT_TYPE_11AX: 602 if (ts->mcs > ATH12K_HE_MCS_MAX) { 603 ath12k_warn(dp->ab, "Invalid HE mcs index %d\n", ts->mcs); 604 return; 605 } 606 607 txrate.mcs = ts->mcs; 608 txrate.flags = RATE_INFO_FLAGS_HE_MCS; 609 txrate.he_gi = ath12k_he_gi_to_nl80211_he_gi(ts->sgi); 610 break; 611 case HAL_TX_RATE_STATS_PKT_TYPE_11BE: 612 if (ts->mcs > ATH12K_EHT_MCS_MAX) { 613 ath12k_warn(dp->ab, "Invalid EHT mcs index %d\n", ts->mcs); 614 return; 615 } 616 617 txrate.mcs = ts->mcs; 618 txrate.flags = RATE_INFO_FLAGS_EHT_MCS; 619 txrate.eht_gi = ath12k_mac_eht_gi_to_nl80211_eht_gi(ts->sgi); 620 break; 621 default: 622 ath12k_warn(dp->ab, "Invalid tx pkt type: %d\n", ts->pkt_type); 623 return; 624 } 625 626 txrate.bw = ath12k_mac_bw_to_mac80211_bw(ts->bw); 627 628 if (ts->ofdma && ts->pkt_type == HAL_TX_RATE_STATS_PKT_TYPE_11AX) { 629 txrate.bw = RATE_INFO_BW_HE_RU; 630 ru_tones = ath12k_mac_he_convert_tones_to_ru_tones(ts->tones); 631 txrate.he_ru_alloc = 632 ath12k_he_ru_tones_to_nl80211_he_ru_alloc(ru_tones); 633 } 634 635 if (ts->ofdma && ts->pkt_type == HAL_TX_RATE_STATS_PKT_TYPE_11BE) { 636 txrate.bw = RATE_INFO_BW_EHT_RU; 637 txrate.eht_ru_alloc = 638 ath12k_mac_eht_ru_tones_to_nl80211_eht_ru_alloc(ts->tones); 639 } 640 641 spin_lock_bh(&dp->dp_lock); 642 peer->txrate = txrate; 643 spin_unlock_bh(&dp->dp_lock); 644 } 645 646 static void ath12k_wifi7_dp_tx_complete_msdu(struct ath12k_pdev_dp *dp_pdev, 647 struct ath12k_tx_desc_params *desc_params, 648 struct hal_tx_status *ts, 649 int ring) 650 { 651 struct ath12k_dp *dp = dp_pdev->dp; 652 struct ath12k_base *ab = dp->ab; 653 struct ieee80211_tx_info *info; 654 struct ath12k_link_vif *arvif; 655 struct ath12k_skb_cb *skb_cb; 656 struct ieee80211_vif *vif; 657 struct ath12k_vif *ahvif; 658 struct sk_buff *msdu = desc_params->skb; 659 s32 noise_floor; 660 struct ieee80211_tx_status status = {}; 661 struct ieee80211_rate_status status_rate = {}; 662 struct ath12k_dp_link_peer *peer; 663 struct rate_info rate; 664 665 if (WARN_ON_ONCE(ts->buf_rel_source != HAL_WBM_REL_SRC_MODULE_TQM)) { 666 /* Must not happen */ 667 return; 668 } 669 670 skb_cb = ATH12K_SKB_CB(msdu); 671 dp->device_stats.tx_completed[ring]++; 672 673 dma_unmap_single(dp->dev, skb_cb->paddr, msdu->len, DMA_TO_DEVICE); 674 if (skb_cb->paddr_ext_desc) { 675 dma_unmap_single(dp->dev, skb_cb->paddr_ext_desc, 676 desc_params->skb_ext_desc->len, DMA_TO_DEVICE); 677 dev_kfree_skb_any(desc_params->skb_ext_desc); 678 } 679 680 rcu_read_lock(); 681 682 if (!rcu_dereference(ab->pdevs_active[dp_pdev->mac_id])) { 683 ieee80211_free_txskb(ath12k_pdev_dp_to_hw(dp_pdev), msdu); 684 goto exit; 685 } 686 687 if (!skb_cb->vif) { 688 ieee80211_free_txskb(ath12k_pdev_dp_to_hw(dp_pdev), msdu); 689 goto exit; 690 } 691 692 vif = skb_cb->vif; 693 if (vif) { 694 ahvif = ath12k_vif_to_ahvif(vif); 695 arvif = rcu_dereference(ahvif->link[skb_cb->link_id]); 696 if (arvif) { 697 spin_lock_bh(&arvif->link_stats_lock); 698 arvif->link_stats.tx_completed++; 699 spin_unlock_bh(&arvif->link_stats_lock); 700 } 701 } 702 703 info = IEEE80211_SKB_CB(msdu); 704 memset(&info->status, 0, sizeof(info->status)); 705 706 /* skip tx rate update from ieee80211_status*/ 707 info->status.rates[0].idx = -1; 708 709 switch (ts->status) { 710 case HAL_WBM_TQM_REL_REASON_FRAME_ACKED: 711 if (!(info->flags & IEEE80211_TX_CTL_NO_ACK)) { 712 info->flags |= IEEE80211_TX_STAT_ACK; 713 info->status.ack_signal = ts->ack_rssi; 714 715 if (!test_bit(WMI_TLV_SERVICE_HW_DB2DBM_CONVERSION_SUPPORT, 716 ab->wmi_ab.svc_map)) { 717 struct ath12k *ar = ath12k_pdev_dp_to_ar(dp_pdev); 718 719 spin_lock_bh(&ar->data_lock); 720 noise_floor = ath12k_pdev_get_noise_floor(ar); 721 spin_unlock_bh(&ar->data_lock); 722 723 info->status.ack_signal += noise_floor; 724 } 725 726 info->status.flags = IEEE80211_TX_STATUS_ACK_SIGNAL_VALID; 727 } 728 break; 729 case HAL_WBM_TQM_REL_REASON_CMD_REMOVE_TX: 730 if (info->flags & IEEE80211_TX_CTL_NO_ACK) { 731 info->flags |= IEEE80211_TX_STAT_NOACK_TRANSMITTED; 732 break; 733 } 734 fallthrough; 735 case HAL_WBM_TQM_REL_REASON_CMD_REMOVE_MPDU: 736 case HAL_WBM_TQM_REL_REASON_DROP_THRESHOLD: 737 case HAL_WBM_TQM_REL_REASON_CMD_REMOVE_AGED_FRAMES: 738 /* The failure status is due to internal firmware tx failure 739 * hence drop the frame; do not update the status of frame to 740 * the upper layer 741 */ 742 ieee80211_free_txskb(ath12k_pdev_dp_to_hw(dp_pdev), msdu); 743 goto exit; 744 default: 745 ath12k_dbg(ab, ATH12K_DBG_DP_TX, "tx frame is not acked status %d\n", 746 ts->status); 747 break; 748 } 749 750 /* NOTE: Tx rate status reporting. Tx completion status does not have 751 * necessary information (for example nss) to build the tx rate. 752 * Might end up reporting it out-of-band from HTT stats. 753 */ 754 755 ath12k_wifi7_dp_tx_update_txcompl(dp_pdev, ts); 756 757 peer = ath12k_dp_link_peer_find_by_peerid(dp_pdev, ts->peer_id); 758 if (!peer || !peer->sta) { 759 ath12k_err(ab, 760 "dp_tx: failed to find the peer with peer_id %d\n", 761 ts->peer_id); 762 ieee80211_free_txskb(ath12k_pdev_dp_to_hw(dp_pdev), msdu); 763 goto exit; 764 } 765 766 status.sta = peer->sta; 767 status.info = info; 768 status.skb = msdu; 769 rate = peer->last_txrate; 770 771 status_rate.rate_idx = rate; 772 status_rate.try_count = 1; 773 774 status.rates = &status_rate; 775 status.n_rates = 1; 776 ieee80211_tx_status_ext(ath12k_pdev_dp_to_hw(dp_pdev), &status); 777 778 exit: 779 rcu_read_unlock(); 780 } 781 782 static void 783 ath12k_wifi7_dp_tx_status_parse(struct ath12k_dp *dp, 784 struct hal_wbm_completion_ring_tx *desc, 785 struct hal_tx_status *ts) 786 { 787 u32 info0 = le32_to_cpu(desc->rate_stats.info0); 788 789 ts->buf_rel_source = 790 le32_get_bits(desc->info0, HAL_WBM_COMPL_TX_INFO0_REL_SRC_MODULE); 791 if (ts->buf_rel_source != HAL_WBM_REL_SRC_MODULE_FW && 792 ts->buf_rel_source != HAL_WBM_REL_SRC_MODULE_TQM) 793 return; 794 795 if (ts->buf_rel_source == HAL_WBM_REL_SRC_MODULE_FW) 796 return; 797 798 ts->status = le32_get_bits(desc->info0, 799 HAL_WBM_COMPL_TX_INFO0_TQM_RELEASE_REASON); 800 801 ts->ppdu_id = le32_get_bits(desc->info1, 802 HAL_WBM_COMPL_TX_INFO1_TQM_STATUS_NUMBER); 803 804 ts->peer_id = le32_get_bits(desc->info3, HAL_WBM_COMPL_TX_INFO3_PEER_ID); 805 806 ts->ack_rssi = le32_get_bits(desc->info2, 807 HAL_WBM_COMPL_TX_INFO2_ACK_FRAME_RSSI); 808 809 if (info0 & HAL_TX_RATE_STATS_INFO0_VALID) { 810 ts->pkt_type = u32_get_bits(info0, HAL_TX_RATE_STATS_INFO0_PKT_TYPE); 811 ts->mcs = u32_get_bits(info0, HAL_TX_RATE_STATS_INFO0_MCS); 812 ts->sgi = u32_get_bits(info0, HAL_TX_RATE_STATS_INFO0_SGI); 813 ts->bw = u32_get_bits(info0, HAL_TX_RATE_STATS_INFO0_BW); 814 ts->tones = u32_get_bits(info0, HAL_TX_RATE_STATS_INFO0_TONES_IN_RU); 815 ts->ofdma = u32_get_bits(info0, HAL_TX_RATE_STATS_INFO0_OFDMA_TX); 816 } 817 } 818 819 void ath12k_wifi7_dp_tx_completion_handler(struct ath12k_dp *dp, int ring_id) 820 { 821 struct ath12k_base *ab = dp->ab; 822 struct ath12k_pdev_dp *dp_pdev; 823 int hal_ring_id = dp->tx_ring[ring_id].tcl_comp_ring.ring_id; 824 struct hal_srng *status_ring = &dp->hal->srng_list[hal_ring_id]; 825 struct ath12k_tx_desc_info *tx_desc = NULL; 826 struct hal_tx_status ts = {}; 827 struct ath12k_tx_desc_params desc_params; 828 struct dp_tx_ring *tx_ring = &dp->tx_ring[ring_id]; 829 struct hal_wbm_release_ring *desc; 830 u8 pdev_idx; 831 u64 desc_va; 832 enum hal_wbm_rel_src_module buf_rel_source; 833 enum hal_wbm_tqm_rel_reason rel_status; 834 835 spin_lock_bh(&status_ring->lock); 836 837 ath12k_hal_srng_access_begin(ab, status_ring); 838 839 while (ATH12K_TX_COMPL_NEXT(ab, tx_ring->tx_status_head) != 840 tx_ring->tx_status_tail) { 841 desc = ath12k_hal_srng_dst_get_next_entry(ab, status_ring); 842 if (!desc) 843 break; 844 845 memcpy(&tx_ring->tx_status[tx_ring->tx_status_head], 846 desc, sizeof(*desc)); 847 tx_ring->tx_status_head = 848 ATH12K_TX_COMPL_NEXT(ab, tx_ring->tx_status_head); 849 } 850 851 if (ath12k_hal_srng_dst_peek(ab, status_ring) && 852 (ATH12K_TX_COMPL_NEXT(ab, tx_ring->tx_status_head) == 853 tx_ring->tx_status_tail)) { 854 /* TODO: Process pending tx_status messages when kfifo_is_full() */ 855 ath12k_warn(ab, "Unable to process some of the tx_status ring desc because status_fifo is full\n"); 856 } 857 858 ath12k_hal_srng_access_end(ab, status_ring); 859 860 spin_unlock_bh(&status_ring->lock); 861 862 while (ATH12K_TX_COMPL_NEXT(ab, tx_ring->tx_status_tail) != 863 tx_ring->tx_status_head) { 864 struct hal_wbm_completion_ring_tx *tx_status; 865 u32 desc_id; 866 867 tx_ring->tx_status_tail = 868 ATH12K_TX_COMPL_NEXT(ab, tx_ring->tx_status_tail); 869 tx_status = &tx_ring->tx_status[tx_ring->tx_status_tail]; 870 ath12k_wifi7_dp_tx_status_parse(dp, tx_status, &ts); 871 872 if (le32_get_bits(tx_status->info0, HAL_WBM_COMPL_TX_INFO0_CC_DONE)) { 873 /* HW done cookie conversion */ 874 desc_va = ((u64)le32_to_cpu(tx_status->buf_va_hi) << 32 | 875 le32_to_cpu(tx_status->buf_va_lo)); 876 tx_desc = (struct ath12k_tx_desc_info *)((unsigned long)desc_va); 877 } else { 878 /* SW does cookie conversion to VA */ 879 desc_id = le32_get_bits(tx_status->buf_va_hi, 880 BUFFER_ADDR_INFO1_SW_COOKIE); 881 882 tx_desc = ath12k_dp_get_tx_desc(dp, desc_id); 883 } 884 if (!tx_desc) { 885 ath12k_warn(ab, "unable to retrieve tx_desc!"); 886 continue; 887 } 888 889 desc_params.mac_id = tx_desc->mac_id; 890 desc_params.skb = tx_desc->skb; 891 desc_params.skb_ext_desc = tx_desc->skb_ext_desc; 892 893 /* Find the HAL_WBM_RELEASE_INFO0_REL_SRC_MODULE value */ 894 buf_rel_source = le32_get_bits(tx_status->info0, 895 HAL_WBM_RELEASE_INFO0_REL_SRC_MODULE); 896 dp->device_stats.tx_wbm_rel_source[buf_rel_source]++; 897 898 rel_status = le32_get_bits(tx_status->info0, 899 HAL_WBM_COMPL_TX_INFO0_TQM_RELEASE_REASON); 900 dp->device_stats.tqm_rel_reason[rel_status]++; 901 902 /* Release descriptor as soon as extracting necessary info 903 * to reduce contention 904 */ 905 ath12k_dp_tx_release_txbuf(dp, tx_desc, tx_desc->pool_id); 906 if (ts.buf_rel_source == HAL_WBM_REL_SRC_MODULE_FW) { 907 ath12k_dp_tx_process_htt_tx_complete(dp, (void *)tx_status, 908 tx_ring, &desc_params); 909 continue; 910 } 911 912 pdev_idx = ath12k_hw_mac_id_to_pdev_id(dp->hw_params, desc_params.mac_id); 913 914 rcu_read_lock(); 915 916 dp_pdev = ath12k_dp_to_pdev_dp(dp, pdev_idx); 917 if (!dp_pdev) { 918 rcu_read_unlock(); 919 continue; 920 } 921 922 if (atomic_dec_and_test(&dp_pdev->num_tx_pending)) 923 wake_up(&dp_pdev->tx_empty_waitq); 924 925 ath12k_wifi7_dp_tx_complete_msdu(dp_pdev, &desc_params, &ts, 926 tx_ring->tcl_data_ring_id); 927 rcu_read_unlock(); 928 } 929 } 930 931 u32 ath12k_wifi7_dp_tx_get_vdev_bank_config(struct ath12k_base *ab, 932 struct ath12k_link_vif *arvif) 933 { 934 u32 bank_config = 0; 935 u8 link_id = arvif->link_id; 936 struct ath12k_vif *ahvif = arvif->ahvif; 937 struct ath12k_dp_vif *dp_vif = &ahvif->dp_vif; 938 struct ath12k_dp_link_vif *dp_link_vif; 939 940 dp_link_vif = ath12k_dp_vif_to_dp_link_vif(dp_vif, link_id); 941 942 /* Only valid for raw frames with HW crypto enabled. 943 * With SW crypto, mac80211 sets key per packet 944 */ 945 if (dp_vif->tx_encap_type == HAL_TCL_ENCAP_TYPE_RAW && 946 test_bit(ATH12K_FLAG_HW_CRYPTO_DISABLED, &ab->dev_flags)) 947 bank_config |= 948 u32_encode_bits(ath12k_dp_tx_get_encrypt_type(dp_vif->key_cipher), 949 HAL_TX_BANK_CONFIG_ENCRYPT_TYPE); 950 951 bank_config |= u32_encode_bits(dp_vif->tx_encap_type, 952 HAL_TX_BANK_CONFIG_ENCAP_TYPE); 953 bank_config |= u32_encode_bits(0, HAL_TX_BANK_CONFIG_SRC_BUFFER_SWAP) | 954 u32_encode_bits(0, HAL_TX_BANK_CONFIG_LINK_META_SWAP) | 955 u32_encode_bits(0, HAL_TX_BANK_CONFIG_EPD); 956 957 /* only valid if idx_lookup_override is not set in tcl_data_cmd */ 958 if (ahvif->vdev_type == WMI_VDEV_TYPE_STA) 959 bank_config |= u32_encode_bits(1, HAL_TX_BANK_CONFIG_INDEX_LOOKUP_EN); 960 else 961 bank_config |= u32_encode_bits(0, HAL_TX_BANK_CONFIG_INDEX_LOOKUP_EN); 962 963 bank_config |= u32_encode_bits(dp_link_vif->hal_addr_search_flags & 964 HAL_TX_ADDRX_EN, 965 HAL_TX_BANK_CONFIG_ADDRX_EN) | 966 u32_encode_bits(!!(dp_link_vif->hal_addr_search_flags & 967 HAL_TX_ADDRY_EN), 968 HAL_TX_BANK_CONFIG_ADDRY_EN); 969 970 bank_config |= u32_encode_bits(ieee80211_vif_is_mesh(ahvif->vif) ? 3 : 0, 971 HAL_TX_BANK_CONFIG_MESH_EN) | 972 u32_encode_bits(dp_link_vif->vdev_id_check_en, 973 HAL_TX_BANK_CONFIG_VDEV_ID_CHECK_EN); 974 975 bank_config |= u32_encode_bits(0, HAL_TX_BANK_CONFIG_DSCP_TIP_MAP_ID); 976 977 return bank_config; 978 } 979