1 // SPDX-License-Identifier: BSD-3-Clause-Clear 2 /* 3 * Copyright (c) 2018-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 "peer.h" 9 #include "dp_peer.h" 10 #include "htc.h" 11 #include "dp_htt.h" 12 #include "debugfs_htt_stats.h" 13 #include "debugfs.h" 14 15 static void ath12k_dp_htt_htc_tx_complete(struct ath12k_base *ab, 16 struct sk_buff *skb) 17 { 18 dev_kfree_skb_any(skb); 19 } 20 21 int ath12k_dp_htt_connect(struct ath12k_dp *dp) 22 { 23 struct ath12k_htc_svc_conn_req conn_req = {}; 24 struct ath12k_htc_svc_conn_resp conn_resp = {}; 25 int status; 26 27 conn_req.ep_ops.ep_tx_complete = ath12k_dp_htt_htc_tx_complete; 28 conn_req.ep_ops.ep_rx_complete = ath12k_dp_htt_htc_t2h_msg_handler; 29 30 /* connect to control service */ 31 conn_req.service_id = ATH12K_HTC_SVC_ID_HTT_DATA_MSG; 32 33 status = ath12k_htc_connect_service(&dp->ab->htc, &conn_req, 34 &conn_resp); 35 36 if (status) 37 return status; 38 39 dp->eid = conn_resp.eid; 40 41 return 0; 42 } 43 44 static int ath12k_get_ppdu_user_index(struct htt_ppdu_stats *ppdu_stats, 45 u16 peer_id) 46 { 47 int i; 48 49 for (i = 0; i < HTT_PPDU_STATS_MAX_USERS - 1; i++) { 50 if (ppdu_stats->user_stats[i].is_valid_peer_id) { 51 if (peer_id == ppdu_stats->user_stats[i].peer_id) 52 return i; 53 } else { 54 return i; 55 } 56 } 57 58 return -EINVAL; 59 } 60 61 static int ath12k_htt_tlv_ppdu_stats_parse(struct ath12k_base *ab, 62 u16 tag, u16 len, const void *ptr, 63 void *data) 64 { 65 const struct htt_ppdu_stats_usr_cmpltn_ack_ba_status *ba_status; 66 const struct htt_ppdu_stats_usr_cmpltn_cmn *cmplt_cmn; 67 const struct htt_ppdu_stats_user_rate *user_rate; 68 struct htt_ppdu_stats_info *ppdu_info; 69 struct htt_ppdu_user_stats *user_stats; 70 int cur_user; 71 u16 peer_id; 72 73 ppdu_info = data; 74 75 switch (tag) { 76 case HTT_PPDU_STATS_TAG_COMMON: 77 if (len < sizeof(struct htt_ppdu_stats_common)) { 78 ath12k_warn(ab, "Invalid len %d for the tag 0x%x\n", 79 len, tag); 80 return -EINVAL; 81 } 82 memcpy(&ppdu_info->ppdu_stats.common, ptr, 83 sizeof(struct htt_ppdu_stats_common)); 84 break; 85 case HTT_PPDU_STATS_TAG_USR_RATE: 86 if (len < sizeof(struct htt_ppdu_stats_user_rate)) { 87 ath12k_warn(ab, "Invalid len %d for the tag 0x%x\n", 88 len, tag); 89 return -EINVAL; 90 } 91 user_rate = ptr; 92 peer_id = le16_to_cpu(user_rate->sw_peer_id); 93 cur_user = ath12k_get_ppdu_user_index(&ppdu_info->ppdu_stats, 94 peer_id); 95 if (cur_user < 0) 96 return -EINVAL; 97 user_stats = &ppdu_info->ppdu_stats.user_stats[cur_user]; 98 user_stats->peer_id = peer_id; 99 user_stats->is_valid_peer_id = true; 100 memcpy(&user_stats->rate, ptr, 101 sizeof(struct htt_ppdu_stats_user_rate)); 102 user_stats->tlv_flags |= BIT(tag); 103 break; 104 case HTT_PPDU_STATS_TAG_USR_COMPLTN_COMMON: 105 if (len < sizeof(struct htt_ppdu_stats_usr_cmpltn_cmn)) { 106 ath12k_warn(ab, "Invalid len %d for the tag 0x%x\n", 107 len, tag); 108 return -EINVAL; 109 } 110 111 cmplt_cmn = ptr; 112 peer_id = le16_to_cpu(cmplt_cmn->sw_peer_id); 113 cur_user = ath12k_get_ppdu_user_index(&ppdu_info->ppdu_stats, 114 peer_id); 115 if (cur_user < 0) 116 return -EINVAL; 117 user_stats = &ppdu_info->ppdu_stats.user_stats[cur_user]; 118 user_stats->peer_id = peer_id; 119 user_stats->is_valid_peer_id = true; 120 memcpy(&user_stats->cmpltn_cmn, ptr, 121 sizeof(struct htt_ppdu_stats_usr_cmpltn_cmn)); 122 user_stats->tlv_flags |= BIT(tag); 123 break; 124 case HTT_PPDU_STATS_TAG_USR_COMPLTN_ACK_BA_STATUS: 125 if (len < 126 sizeof(struct htt_ppdu_stats_usr_cmpltn_ack_ba_status)) { 127 ath12k_warn(ab, "Invalid len %d for the tag 0x%x\n", 128 len, tag); 129 return -EINVAL; 130 } 131 132 ba_status = ptr; 133 peer_id = le16_to_cpu(ba_status->sw_peer_id); 134 cur_user = ath12k_get_ppdu_user_index(&ppdu_info->ppdu_stats, 135 peer_id); 136 if (cur_user < 0) 137 return -EINVAL; 138 user_stats = &ppdu_info->ppdu_stats.user_stats[cur_user]; 139 user_stats->peer_id = peer_id; 140 user_stats->is_valid_peer_id = true; 141 memcpy(&user_stats->ack_ba, ptr, 142 sizeof(struct htt_ppdu_stats_usr_cmpltn_ack_ba_status)); 143 user_stats->tlv_flags |= BIT(tag); 144 break; 145 } 146 return 0; 147 } 148 149 int ath12k_dp_htt_tlv_iter(struct ath12k_base *ab, const void *ptr, size_t len, 150 int (*iter)(struct ath12k_base *ab, u16 tag, u16 len, 151 const void *ptr, void *data), 152 void *data) 153 { 154 const struct htt_tlv *tlv; 155 const void *begin = ptr; 156 u16 tlv_tag, tlv_len; 157 int ret = -EINVAL; 158 159 while (len > 0) { 160 if (len < sizeof(*tlv)) { 161 ath12k_err(ab, "htt tlv parse failure at byte %zd (%zu bytes left, %zu expected)\n", 162 ptr - begin, len, sizeof(*tlv)); 163 return -EINVAL; 164 } 165 tlv = (struct htt_tlv *)ptr; 166 tlv_tag = le32_get_bits(tlv->header, HTT_TLV_TAG); 167 tlv_len = le32_get_bits(tlv->header, HTT_TLV_LEN); 168 ptr += sizeof(*tlv); 169 len -= sizeof(*tlv); 170 171 if (tlv_len > len) { 172 ath12k_err(ab, "htt tlv parse failure of tag %u at byte %zd (%zu bytes left, %u expected)\n", 173 tlv_tag, ptr - begin, len, tlv_len); 174 return -EINVAL; 175 } 176 ret = iter(ab, tlv_tag, tlv_len, ptr, data); 177 if (ret == -ENOMEM) 178 return ret; 179 180 ptr += tlv_len; 181 len -= tlv_len; 182 } 183 return 0; 184 } 185 186 static void 187 ath12k_update_per_peer_tx_stats(struct ath12k_pdev_dp *dp_pdev, 188 struct htt_ppdu_stats *ppdu_stats, u8 user) 189 { 190 struct ath12k_dp *dp = dp_pdev->dp; 191 struct ath12k_base *ab = dp->ab; 192 struct ath12k_dp_link_peer *peer; 193 struct htt_ppdu_stats_user_rate *user_rate; 194 struct ath12k_per_peer_tx_stats *peer_stats = &dp_pdev->peer_tx_stats; 195 struct htt_ppdu_user_stats *usr_stats = &ppdu_stats->user_stats[user]; 196 struct htt_ppdu_stats_common *common = &ppdu_stats->common; 197 int ret; 198 u8 flags, mcs, nss, bw, sgi, dcm, ppdu_type, rate_idx = 0; 199 u32 v, succ_bytes = 0; 200 u16 tones, rate = 0, succ_pkts = 0; 201 u32 tx_duration = 0; 202 u8 tid = HTT_PPDU_STATS_NON_QOS_TID; 203 u16 tx_retry_failed = 0, tx_retry_count = 0; 204 bool is_ampdu = false, is_ofdma; 205 206 if (!(usr_stats->tlv_flags & BIT(HTT_PPDU_STATS_TAG_USR_RATE))) 207 return; 208 209 if (usr_stats->tlv_flags & BIT(HTT_PPDU_STATS_TAG_USR_COMPLTN_COMMON)) 210 is_ampdu = 211 HTT_USR_CMPLTN_IS_AMPDU(usr_stats->cmpltn_cmn.flags); 212 213 if (usr_stats->tlv_flags & 214 BIT(HTT_PPDU_STATS_TAG_USR_COMPLTN_ACK_BA_STATUS)) { 215 succ_bytes = le32_to_cpu(usr_stats->ack_ba.success_bytes); 216 succ_pkts = le32_get_bits(usr_stats->ack_ba.info, 217 HTT_PPDU_STATS_ACK_BA_INFO_NUM_MSDU_M); 218 tid = le32_get_bits(usr_stats->ack_ba.info, 219 HTT_PPDU_STATS_ACK_BA_INFO_TID_NUM); 220 221 if (usr_stats->tlv_flags & BIT(HTT_PPDU_STATS_TAG_USR_COMPLTN_COMMON)) { 222 tx_retry_failed = 223 __le16_to_cpu(usr_stats->cmpltn_cmn.mpdu_tried) - 224 __le16_to_cpu(usr_stats->cmpltn_cmn.mpdu_success); 225 tx_retry_count = 226 HTT_USR_CMPLTN_LONG_RETRY(usr_stats->cmpltn_cmn.flags) + 227 HTT_USR_CMPLTN_SHORT_RETRY(usr_stats->cmpltn_cmn.flags); 228 } 229 230 if (common->fes_duration_us) 231 tx_duration = le32_to_cpu(common->fes_duration_us); 232 } 233 234 user_rate = &usr_stats->rate; 235 flags = HTT_USR_RATE_PREAMBLE(user_rate->rate_flags); 236 bw = HTT_USR_RATE_BW(user_rate->rate_flags) - 2; 237 nss = HTT_USR_RATE_NSS(user_rate->rate_flags) + 1; 238 mcs = HTT_USR_RATE_MCS(user_rate->rate_flags); 239 sgi = HTT_USR_RATE_GI(user_rate->rate_flags); 240 dcm = HTT_USR_RATE_DCM(user_rate->rate_flags); 241 242 ppdu_type = HTT_USR_RATE_PPDU_TYPE(user_rate->info1); 243 is_ofdma = (ppdu_type == HTT_PPDU_STATS_PPDU_TYPE_MU_OFDMA) || 244 (ppdu_type == HTT_PPDU_STATS_PPDU_TYPE_MU_MIMO_OFDMA); 245 246 /* Note: If host configured fixed rates and in some other special 247 * cases, the broadcast/management frames are sent in different rates. 248 * Firmware rate's control to be skipped for this? 249 */ 250 251 if (flags == WMI_RATE_PREAMBLE_HE && mcs > ATH12K_HE_MCS_MAX) { 252 ath12k_warn(ab, "Invalid HE mcs %d peer stats", mcs); 253 return; 254 } 255 256 if (flags == WMI_RATE_PREAMBLE_VHT && mcs > ATH12K_VHT_MCS_MAX) { 257 ath12k_warn(ab, "Invalid VHT mcs %d peer stats", mcs); 258 return; 259 } 260 261 if (flags == WMI_RATE_PREAMBLE_HT && (mcs > ATH12K_HT_MCS_MAX || nss < 1)) { 262 ath12k_warn(ab, "Invalid HT mcs %d nss %d peer stats", 263 mcs, nss); 264 return; 265 } 266 267 if (flags == WMI_RATE_PREAMBLE_CCK || flags == WMI_RATE_PREAMBLE_OFDM) { 268 ret = ath12k_mac_hw_ratecode_to_legacy_rate(mcs, 269 flags, 270 &rate_idx, 271 &rate); 272 if (ret < 0) 273 return; 274 } 275 276 rcu_read_lock(); 277 peer = ath12k_dp_link_peer_find_by_peerid(dp_pdev, usr_stats->peer_id); 278 279 if (!peer || !peer->sta) { 280 rcu_read_unlock(); 281 return; 282 } 283 284 spin_lock_bh(&dp->dp_lock); 285 286 memset(&peer->txrate, 0, sizeof(peer->txrate)); 287 288 peer->txrate.bw = ath12k_mac_bw_to_mac80211_bw(bw); 289 290 switch (flags) { 291 case WMI_RATE_PREAMBLE_OFDM: 292 peer->txrate.legacy = rate; 293 break; 294 case WMI_RATE_PREAMBLE_CCK: 295 peer->txrate.legacy = rate; 296 break; 297 case WMI_RATE_PREAMBLE_HT: 298 peer->txrate.mcs = mcs + 8 * (nss - 1); 299 peer->txrate.flags = RATE_INFO_FLAGS_MCS; 300 if (sgi) 301 peer->txrate.flags |= RATE_INFO_FLAGS_SHORT_GI; 302 break; 303 case WMI_RATE_PREAMBLE_VHT: 304 peer->txrate.mcs = mcs; 305 peer->txrate.flags = RATE_INFO_FLAGS_VHT_MCS; 306 if (sgi) 307 peer->txrate.flags |= RATE_INFO_FLAGS_SHORT_GI; 308 break; 309 case WMI_RATE_PREAMBLE_HE: 310 peer->txrate.mcs = mcs; 311 peer->txrate.flags = RATE_INFO_FLAGS_HE_MCS; 312 peer->txrate.he_dcm = dcm; 313 peer->txrate.he_gi = ath12k_he_gi_to_nl80211_he_gi(sgi); 314 tones = le16_to_cpu(user_rate->ru_end) - 315 le16_to_cpu(user_rate->ru_start) + 1; 316 v = ath12k_he_ru_tones_to_nl80211_he_ru_alloc(tones); 317 peer->txrate.he_ru_alloc = v; 318 if (is_ofdma) 319 peer->txrate.bw = RATE_INFO_BW_HE_RU; 320 break; 321 case WMI_RATE_PREAMBLE_EHT: 322 peer->txrate.mcs = mcs; 323 peer->txrate.flags = RATE_INFO_FLAGS_EHT_MCS; 324 peer->txrate.he_dcm = dcm; 325 peer->txrate.eht_gi = ath12k_mac_eht_gi_to_nl80211_eht_gi(sgi); 326 tones = le16_to_cpu(user_rate->ru_end) - 327 le16_to_cpu(user_rate->ru_start) + 1; 328 v = ath12k_mac_eht_ru_tones_to_nl80211_eht_ru_alloc(tones); 329 peer->txrate.eht_ru_alloc = v; 330 if (is_ofdma) 331 peer->txrate.bw = RATE_INFO_BW_EHT_RU; 332 break; 333 } 334 335 peer->tx_retry_failed += tx_retry_failed; 336 peer->tx_retry_count += tx_retry_count; 337 peer->txrate.nss = nss; 338 peer->tx_duration += tx_duration; 339 memcpy(&peer->last_txrate, &peer->txrate, sizeof(struct rate_info)); 340 341 spin_unlock_bh(&dp->dp_lock); 342 343 /* PPDU stats reported for mgmt packet doesn't have valid tx bytes. 344 * So skip peer stats update for mgmt packets. 345 */ 346 if (tid < HTT_PPDU_STATS_NON_QOS_TID) { 347 memset(peer_stats, 0, sizeof(*peer_stats)); 348 peer_stats->succ_pkts = succ_pkts; 349 peer_stats->succ_bytes = succ_bytes; 350 peer_stats->is_ampdu = is_ampdu; 351 peer_stats->duration = tx_duration; 352 peer_stats->ba_fails = 353 HTT_USR_CMPLTN_LONG_RETRY(usr_stats->cmpltn_cmn.flags) + 354 HTT_USR_CMPLTN_SHORT_RETRY(usr_stats->cmpltn_cmn.flags); 355 } 356 357 rcu_read_unlock(); 358 } 359 360 static void ath12k_htt_update_ppdu_stats(struct ath12k_pdev_dp *dp_pdev, 361 struct htt_ppdu_stats *ppdu_stats) 362 { 363 u8 user; 364 365 for (user = 0; user < HTT_PPDU_STATS_MAX_USERS - 1; user++) 366 ath12k_update_per_peer_tx_stats(dp_pdev, ppdu_stats, user); 367 } 368 369 static 370 struct htt_ppdu_stats_info *ath12k_dp_htt_get_ppdu_desc(struct ath12k_pdev_dp *dp_pdev, 371 u32 ppdu_id) 372 { 373 struct htt_ppdu_stats_info *ppdu_info; 374 375 lockdep_assert_held(&dp_pdev->ppdu_list_lock); 376 if (!list_empty(&dp_pdev->ppdu_stats_info)) { 377 list_for_each_entry(ppdu_info, &dp_pdev->ppdu_stats_info, list) { 378 if (ppdu_info->ppdu_id == ppdu_id) 379 return ppdu_info; 380 } 381 382 if (dp_pdev->ppdu_stat_list_depth > HTT_PPDU_DESC_MAX_DEPTH) { 383 ppdu_info = list_first_entry(&dp_pdev->ppdu_stats_info, 384 typeof(*ppdu_info), list); 385 list_del(&ppdu_info->list); 386 dp_pdev->ppdu_stat_list_depth--; 387 ath12k_htt_update_ppdu_stats(dp_pdev, &ppdu_info->ppdu_stats); 388 kfree(ppdu_info); 389 } 390 } 391 392 ppdu_info = kzalloc_obj(*ppdu_info, GFP_ATOMIC); 393 if (!ppdu_info) 394 return NULL; 395 396 list_add_tail(&ppdu_info->list, &dp_pdev->ppdu_stats_info); 397 dp_pdev->ppdu_stat_list_depth++; 398 399 return ppdu_info; 400 } 401 402 static void ath12k_copy_to_delay_stats(struct ath12k_dp_link_peer *peer, 403 struct htt_ppdu_user_stats *usr_stats) 404 { 405 peer->ppdu_stats_delayba.sw_peer_id = le16_to_cpu(usr_stats->rate.sw_peer_id); 406 peer->ppdu_stats_delayba.info0 = le32_to_cpu(usr_stats->rate.info0); 407 peer->ppdu_stats_delayba.ru_end = le16_to_cpu(usr_stats->rate.ru_end); 408 peer->ppdu_stats_delayba.ru_start = le16_to_cpu(usr_stats->rate.ru_start); 409 peer->ppdu_stats_delayba.info1 = le32_to_cpu(usr_stats->rate.info1); 410 peer->ppdu_stats_delayba.rate_flags = le32_to_cpu(usr_stats->rate.rate_flags); 411 peer->ppdu_stats_delayba.resp_rate_flags = 412 le32_to_cpu(usr_stats->rate.resp_rate_flags); 413 414 peer->delayba_flag = true; 415 } 416 417 static void ath12k_copy_to_bar(struct ath12k_dp_link_peer *peer, 418 struct htt_ppdu_user_stats *usr_stats) 419 { 420 usr_stats->rate.sw_peer_id = cpu_to_le16(peer->ppdu_stats_delayba.sw_peer_id); 421 usr_stats->rate.info0 = cpu_to_le32(peer->ppdu_stats_delayba.info0); 422 usr_stats->rate.ru_end = cpu_to_le16(peer->ppdu_stats_delayba.ru_end); 423 usr_stats->rate.ru_start = cpu_to_le16(peer->ppdu_stats_delayba.ru_start); 424 usr_stats->rate.info1 = cpu_to_le32(peer->ppdu_stats_delayba.info1); 425 usr_stats->rate.rate_flags = cpu_to_le32(peer->ppdu_stats_delayba.rate_flags); 426 usr_stats->rate.resp_rate_flags = 427 cpu_to_le32(peer->ppdu_stats_delayba.resp_rate_flags); 428 429 peer->delayba_flag = false; 430 } 431 432 static int ath12k_htt_pull_ppdu_stats(struct ath12k_base *ab, 433 struct sk_buff *skb) 434 { 435 struct ath12k_dp *dp = ath12k_ab_to_dp(ab); 436 struct ath12k_htt_ppdu_stats_msg *msg; 437 struct htt_ppdu_stats_info *ppdu_info; 438 struct ath12k_dp_link_peer *peer = NULL; 439 struct htt_ppdu_user_stats *usr_stats = NULL; 440 u32 peer_id = 0; 441 struct ath12k_pdev_dp *dp_pdev; 442 int ret, i; 443 u8 pdev_id, pdev_idx; 444 u32 ppdu_id, len; 445 446 msg = (struct ath12k_htt_ppdu_stats_msg *)skb->data; 447 len = le32_get_bits(msg->info, HTT_T2H_PPDU_STATS_INFO_PAYLOAD_SIZE); 448 if (len > (skb->len - struct_size(msg, data, 0))) { 449 ath12k_warn(ab, 450 "HTT PPDU STATS event has unexpected payload size %u, should be smaller than %u\n", 451 len, skb->len); 452 return -EINVAL; 453 } 454 455 pdev_id = le32_get_bits(msg->info, HTT_T2H_PPDU_STATS_INFO_PDEV_ID); 456 ppdu_id = le32_to_cpu(msg->ppdu_id); 457 458 pdev_idx = DP_HW2SW_MACID(pdev_id); 459 if (pdev_idx >= MAX_RADIOS) { 460 ath12k_warn(ab, "HTT PPDU STATS invalid pdev id %u", pdev_id); 461 return -EINVAL; 462 } 463 464 rcu_read_lock(); 465 466 dp_pdev = ath12k_dp_to_pdev_dp(dp, pdev_idx); 467 if (!dp_pdev) { 468 ret = -EINVAL; 469 goto exit; 470 } 471 472 spin_lock_bh(&dp_pdev->ppdu_list_lock); 473 ppdu_info = ath12k_dp_htt_get_ppdu_desc(dp_pdev, ppdu_id); 474 if (!ppdu_info) { 475 spin_unlock_bh(&dp_pdev->ppdu_list_lock); 476 ret = -EINVAL; 477 goto exit; 478 } 479 480 ppdu_info->ppdu_id = ppdu_id; 481 ret = ath12k_dp_htt_tlv_iter(ab, msg->data, len, 482 ath12k_htt_tlv_ppdu_stats_parse, 483 (void *)ppdu_info); 484 if (ret) { 485 spin_unlock_bh(&dp_pdev->ppdu_list_lock); 486 ath12k_warn(ab, "Failed to parse tlv %d\n", ret); 487 goto exit; 488 } 489 490 if (ppdu_info->ppdu_stats.common.num_users >= HTT_PPDU_STATS_MAX_USERS) { 491 spin_unlock_bh(&dp_pdev->ppdu_list_lock); 492 ath12k_warn(ab, 493 "HTT PPDU STATS event has unexpected num_users %u, should be smaller than %u\n", 494 ppdu_info->ppdu_stats.common.num_users, 495 HTT_PPDU_STATS_MAX_USERS); 496 ret = -EINVAL; 497 goto exit; 498 } 499 500 /* back up data rate tlv for all peers */ 501 if (ppdu_info->frame_type == HTT_STATS_PPDU_FTYPE_DATA && 502 (ppdu_info->tlv_bitmap & (1 << HTT_PPDU_STATS_TAG_USR_COMMON)) && 503 ppdu_info->delay_ba) { 504 for (i = 0; i < ppdu_info->ppdu_stats.common.num_users; i++) { 505 peer_id = ppdu_info->ppdu_stats.user_stats[i].peer_id; 506 peer = ath12k_dp_link_peer_find_by_peerid(dp_pdev, peer_id); 507 if (!peer) 508 continue; 509 510 usr_stats = &ppdu_info->ppdu_stats.user_stats[i]; 511 if (usr_stats->delay_ba) 512 ath12k_copy_to_delay_stats(peer, usr_stats); 513 } 514 } 515 516 /* restore all peers' data rate tlv to mu-bar tlv */ 517 if (ppdu_info->frame_type == HTT_STATS_PPDU_FTYPE_BAR && 518 (ppdu_info->tlv_bitmap & (1 << HTT_PPDU_STATS_TAG_USR_COMMON))) { 519 for (i = 0; i < ppdu_info->bar_num_users; i++) { 520 peer_id = ppdu_info->ppdu_stats.user_stats[i].peer_id; 521 peer = ath12k_dp_link_peer_find_by_peerid(dp_pdev, peer_id); 522 if (!peer) 523 continue; 524 525 usr_stats = &ppdu_info->ppdu_stats.user_stats[i]; 526 if (peer->delayba_flag) 527 ath12k_copy_to_bar(peer, usr_stats); 528 } 529 } 530 531 spin_unlock_bh(&dp_pdev->ppdu_list_lock); 532 533 exit: 534 rcu_read_unlock(); 535 536 return ret; 537 } 538 539 static void ath12k_htt_mlo_offset_event_handler(struct ath12k_base *ab, 540 struct sk_buff *skb) 541 { 542 struct ath12k_htt_mlo_offset_msg *msg; 543 struct ath12k_pdev *pdev; 544 struct ath12k *ar; 545 u8 pdev_id; 546 547 msg = (struct ath12k_htt_mlo_offset_msg *)skb->data; 548 pdev_id = u32_get_bits(__le32_to_cpu(msg->info), 549 HTT_T2H_MLO_OFFSET_INFO_PDEV_ID); 550 551 rcu_read_lock(); 552 ar = ath12k_mac_get_ar_by_pdev_id(ab, pdev_id); 553 if (!ar) { 554 /* It is possible that the ar is not yet active (started). 555 * The above function will only look for the active pdev 556 * and hence %NULL return is possible. Just silently 557 * discard this message 558 */ 559 goto exit; 560 } 561 562 spin_lock_bh(&ar->data_lock); 563 pdev = ar->pdev; 564 565 pdev->timestamp.info = __le32_to_cpu(msg->info); 566 pdev->timestamp.sync_timestamp_lo_us = __le32_to_cpu(msg->sync_timestamp_lo_us); 567 pdev->timestamp.sync_timestamp_hi_us = __le32_to_cpu(msg->sync_timestamp_hi_us); 568 pdev->timestamp.mlo_offset_lo = __le32_to_cpu(msg->mlo_offset_lo); 569 pdev->timestamp.mlo_offset_hi = __le32_to_cpu(msg->mlo_offset_hi); 570 pdev->timestamp.mlo_offset_clks = __le32_to_cpu(msg->mlo_offset_clks); 571 pdev->timestamp.mlo_comp_clks = __le32_to_cpu(msg->mlo_comp_clks); 572 pdev->timestamp.mlo_comp_timer = __le32_to_cpu(msg->mlo_comp_timer); 573 574 spin_unlock_bh(&ar->data_lock); 575 exit: 576 rcu_read_unlock(); 577 } 578 579 static void ath12k_dp_htt_mlo_peer_map_handler(struct ath12k_base *ab, 580 struct sk_buff *skb) 581 { 582 struct htt_resp_msg *resp = (struct htt_resp_msg *)skb->data; 583 struct htt_t2h_mlo_peer_map_event *ev = &resp->mlo_peer_map_ev; 584 u16 raw_peer_id, peer_id, addr_h16; 585 u8 peer_addr[ETH_ALEN]; 586 int ret; 587 588 if (skb->len < sizeof(*ev)) { 589 ath12k_warn(ab, "unexpected htt mlo peer map event len %u\n", 590 skb->len); 591 return; 592 } 593 594 raw_peer_id = le32_get_bits(ev->info0, 595 HTT_T2H_MLO_PEER_MAP_INFO0_MLO_PEER_ID); 596 peer_id = raw_peer_id | ATH12K_PEER_ML_ID_VALID; 597 598 addr_h16 = le32_get_bits(ev->info1, 599 HTT_T2H_MLO_PEER_MAP_INFO1_MAC_ADDR_H16); 600 ath12k_dp_get_mac_addr(le32_to_cpu(ev->mac_addr_l32), addr_h16, 601 peer_addr); 602 603 ath12k_dbg(ab, ATH12K_DBG_DP_HTT, "htt mlo peer map peer %pM id %u\n", 604 peer_addr, peer_id); 605 606 /* 607 * Fix up the dp_peer entry created with ATH12K_MLO_PEER_ID_PENDING 608 * earlier; on chips with host_alloc_ml_id == false this is the only 609 * point at which the host learns the firmware-assigned ID. Chips 610 * that allocate the ID on the host also receive this event but the 611 * firmware-reported ID matches the host-allocated one, so there is 612 * nothing to fix up. 613 */ 614 if (!ab->hw_params->host_alloc_ml_id) { 615 ret = ath12k_dp_peer_fixup_peer_id(ab, peer_addr, 616 peer_id); 617 if (ret) 618 ath12k_warn(ab, 619 "failed to fix up peer id %u for dp peer %pM: %d\n", 620 peer_id, peer_addr, ret); 621 } 622 } 623 624 void ath12k_dp_htt_htc_t2h_msg_handler(struct ath12k_base *ab, 625 struct sk_buff *skb) 626 { 627 struct ath12k_dp *dp = ath12k_ab_to_dp(ab); 628 struct htt_resp_msg *resp = (struct htt_resp_msg *)skb->data; 629 enum htt_t2h_msg_type type; 630 u16 peer_id; 631 u8 vdev_id; 632 u8 mac_addr[ETH_ALEN]; 633 u16 peer_mac_h16; 634 u16 ast_hash = 0; 635 u16 hw_peer_id; 636 637 type = le32_get_bits(resp->version_msg.version, HTT_T2H_MSG_TYPE); 638 639 ath12k_dbg(ab, ATH12K_DBG_DP_HTT, "dp_htt rx msg type :0x%0x\n", type); 640 641 switch (type) { 642 case HTT_T2H_MSG_TYPE_VERSION_CONF: 643 dp->htt_tgt_ver_major = le32_get_bits(resp->version_msg.version, 644 HTT_T2H_VERSION_CONF_MAJOR); 645 dp->htt_tgt_ver_minor = le32_get_bits(resp->version_msg.version, 646 HTT_T2H_VERSION_CONF_MINOR); 647 complete(&dp->htt_tgt_version_received); 648 break; 649 /* TODO: remove unused peer map versions after testing */ 650 case HTT_T2H_MSG_TYPE_PEER_MAP: 651 vdev_id = le32_get_bits(resp->peer_map_ev.info, 652 HTT_T2H_PEER_MAP_INFO_VDEV_ID); 653 peer_id = le32_get_bits(resp->peer_map_ev.info, 654 HTT_T2H_PEER_MAP_INFO_PEER_ID); 655 peer_mac_h16 = le32_get_bits(resp->peer_map_ev.info1, 656 HTT_T2H_PEER_MAP_INFO1_MAC_ADDR_H16); 657 ath12k_dp_get_mac_addr(le32_to_cpu(resp->peer_map_ev.mac_addr_l32), 658 peer_mac_h16, mac_addr); 659 ath12k_dp_link_peer_map_event(ab, vdev_id, peer_id, mac_addr, 0, 0); 660 break; 661 case HTT_T2H_MSG_TYPE_PEER_MAP2: 662 vdev_id = le32_get_bits(resp->peer_map_ev.info, 663 HTT_T2H_PEER_MAP_INFO_VDEV_ID); 664 peer_id = le32_get_bits(resp->peer_map_ev.info, 665 HTT_T2H_PEER_MAP_INFO_PEER_ID); 666 peer_mac_h16 = le32_get_bits(resp->peer_map_ev.info1, 667 HTT_T2H_PEER_MAP_INFO1_MAC_ADDR_H16); 668 ath12k_dp_get_mac_addr(le32_to_cpu(resp->peer_map_ev.mac_addr_l32), 669 peer_mac_h16, mac_addr); 670 ast_hash = le32_get_bits(resp->peer_map_ev.info2, 671 HTT_T2H_PEER_MAP_INFO2_AST_HASH_VAL); 672 hw_peer_id = le32_get_bits(resp->peer_map_ev.info1, 673 HTT_T2H_PEER_MAP_INFO1_HW_PEER_ID); 674 ath12k_dp_link_peer_map_event(ab, vdev_id, peer_id, mac_addr, ast_hash, 675 hw_peer_id); 676 break; 677 case HTT_T2H_MSG_TYPE_PEER_MAP3: 678 vdev_id = le32_get_bits(resp->peer_map_ev.info, 679 HTT_T2H_PEER_MAP_INFO_VDEV_ID); 680 peer_id = le32_get_bits(resp->peer_map_ev.info, 681 HTT_T2H_PEER_MAP_INFO_PEER_ID); 682 peer_mac_h16 = le32_get_bits(resp->peer_map_ev.info1, 683 HTT_T2H_PEER_MAP_INFO1_MAC_ADDR_H16); 684 ath12k_dp_get_mac_addr(le32_to_cpu(resp->peer_map_ev.mac_addr_l32), 685 peer_mac_h16, mac_addr); 686 ast_hash = le32_get_bits(resp->peer_map_ev.info2, 687 HTT_T2H_PEER_MAP3_INFO2_AST_HASH_VAL); 688 hw_peer_id = le32_get_bits(resp->peer_map_ev.info2, 689 HTT_T2H_PEER_MAP3_INFO2_HW_PEER_ID); 690 ath12k_dp_link_peer_map_event(ab, vdev_id, peer_id, mac_addr, ast_hash, 691 hw_peer_id); 692 break; 693 case HTT_T2H_MSG_TYPE_PEER_UNMAP: 694 case HTT_T2H_MSG_TYPE_PEER_UNMAP2: 695 peer_id = le32_get_bits(resp->peer_unmap_ev.info, 696 HTT_T2H_PEER_UNMAP_INFO_PEER_ID); 697 ath12k_dp_link_peer_unmap_event(ab, peer_id); 698 break; 699 case HTT_T2H_MSG_TYPE_PPDU_STATS_IND: 700 ath12k_htt_pull_ppdu_stats(ab, skb); 701 break; 702 case HTT_T2H_MSG_TYPE_EXT_STATS_CONF: 703 ath12k_debugfs_htt_ext_stats_handler(ab, skb); 704 break; 705 case HTT_T2H_MSG_TYPE_MLO_TIMESTAMP_OFFSET_IND: 706 ath12k_htt_mlo_offset_event_handler(ab, skb); 707 break; 708 case HTT_T2H_MSG_TYPE_MLO_RX_PEER_MAP: 709 ath12k_dp_htt_mlo_peer_map_handler(ab, skb); 710 break; 711 default: 712 ath12k_dbg(ab, ATH12K_DBG_DP_HTT, "dp_htt event %d not handled\n", 713 type); 714 break; 715 } 716 717 dev_kfree_skb_any(skb); 718 } 719 EXPORT_SYMBOL(ath12k_dp_htt_htc_t2h_msg_handler); 720 721 static int 722 ath12k_dp_tx_get_ring_id_type(struct ath12k_base *ab, 723 int mac_id, u32 ring_id, 724 enum hal_ring_type ring_type, 725 enum htt_srng_ring_type *htt_ring_type, 726 enum htt_srng_ring_id *htt_ring_id) 727 { 728 int ret = 0; 729 730 switch (ring_type) { 731 case HAL_RXDMA_BUF: 732 /* for some targets, host fills rx buffer to fw and fw fills to 733 * rxbuf ring for each rxdma 734 */ 735 if (!ab->hw_params->rx_mac_buf_ring) { 736 if (!(ring_id == HAL_SRNG_SW2RXDMA_BUF0 || 737 ring_id == HAL_SRNG_SW2RXDMA_BUF1)) { 738 ret = -EINVAL; 739 } 740 *htt_ring_id = HTT_RXDMA_HOST_BUF_RING; 741 *htt_ring_type = HTT_SW_TO_HW_RING; 742 } else { 743 if (ring_id == HAL_SRNG_SW2RXDMA_BUF0) { 744 *htt_ring_id = HTT_HOST1_TO_FW_RXBUF_RING; 745 *htt_ring_type = HTT_SW_TO_SW_RING; 746 } else { 747 *htt_ring_id = HTT_RXDMA_HOST_BUF_RING; 748 *htt_ring_type = HTT_SW_TO_HW_RING; 749 } 750 } 751 break; 752 case HAL_RXDMA_DST: 753 *htt_ring_id = HTT_RXDMA_NON_MONITOR_DEST_RING; 754 *htt_ring_type = HTT_HW_TO_SW_RING; 755 break; 756 case HAL_RXDMA_MONITOR_BUF: 757 *htt_ring_id = HTT_RX_MON_HOST2MON_BUF_RING; 758 *htt_ring_type = HTT_SW_TO_HW_RING; 759 break; 760 case HAL_RXDMA_MONITOR_STATUS: 761 *htt_ring_id = HTT_RXDMA_MONITOR_STATUS_RING; 762 *htt_ring_type = HTT_SW_TO_HW_RING; 763 break; 764 case HAL_RXDMA_MONITOR_DST: 765 *htt_ring_id = HTT_RX_MON_MON2HOST_DEST_RING; 766 *htt_ring_type = HTT_HW_TO_SW_RING; 767 break; 768 case HAL_RXDMA_MONITOR_DESC: 769 *htt_ring_id = HTT_RXDMA_MONITOR_DESC_RING; 770 *htt_ring_type = HTT_SW_TO_HW_RING; 771 break; 772 default: 773 ath12k_warn(ab, "Unsupported ring type in DP :%d\n", ring_type); 774 ret = -EINVAL; 775 } 776 return ret; 777 } 778 779 int ath12k_dp_tx_htt_srng_setup(struct ath12k_base *ab, u32 ring_id, 780 int mac_id, enum hal_ring_type ring_type) 781 { 782 struct ath12k_dp *dp = ath12k_ab_to_dp(ab); 783 struct htt_srng_setup_cmd *cmd; 784 struct hal_srng *srng = &ab->hal.srng_list[ring_id]; 785 struct hal_srng_params params; 786 struct sk_buff *skb; 787 u32 ring_entry_sz; 788 int len = sizeof(*cmd); 789 dma_addr_t hp_addr, tp_addr; 790 enum htt_srng_ring_type htt_ring_type; 791 enum htt_srng_ring_id htt_ring_id; 792 int ret; 793 794 skb = ath12k_htc_alloc_skb(ab, len); 795 if (!skb) 796 return -ENOMEM; 797 798 memset(¶ms, 0, sizeof(params)); 799 ath12k_hal_srng_get_params(ab, srng, ¶ms); 800 801 hp_addr = ath12k_hal_srng_get_hp_addr(ab, srng); 802 tp_addr = ath12k_hal_srng_get_tp_addr(ab, srng); 803 804 ret = ath12k_dp_tx_get_ring_id_type(ab, mac_id, ring_id, 805 ring_type, &htt_ring_type, 806 &htt_ring_id); 807 if (ret) 808 goto err_free; 809 810 skb_put(skb, len); 811 cmd = (struct htt_srng_setup_cmd *)skb->data; 812 cmd->info0 = le32_encode_bits(HTT_H2T_MSG_TYPE_SRING_SETUP, 813 HTT_SRNG_SETUP_CMD_INFO0_MSG_TYPE); 814 if (htt_ring_type == HTT_SW_TO_HW_RING || 815 htt_ring_type == HTT_HW_TO_SW_RING) 816 cmd->info0 |= le32_encode_bits(DP_SW2HW_MACID(mac_id), 817 HTT_SRNG_SETUP_CMD_INFO0_PDEV_ID); 818 else 819 cmd->info0 |= le32_encode_bits(mac_id, 820 HTT_SRNG_SETUP_CMD_INFO0_PDEV_ID); 821 cmd->info0 |= le32_encode_bits(htt_ring_type, 822 HTT_SRNG_SETUP_CMD_INFO0_RING_TYPE); 823 cmd->info0 |= le32_encode_bits(htt_ring_id, 824 HTT_SRNG_SETUP_CMD_INFO0_RING_ID); 825 826 cmd->ring_base_addr_lo = cpu_to_le32(params.ring_base_paddr & 827 HAL_ADDR_LSB_REG_MASK); 828 829 cmd->ring_base_addr_hi = cpu_to_le32((u64)params.ring_base_paddr >> 830 HAL_ADDR_MSB_REG_SHIFT); 831 832 ret = ath12k_hal_srng_get_entrysize(ab, ring_type); 833 if (ret < 0) 834 goto err_free; 835 836 ring_entry_sz = ret; 837 838 ring_entry_sz >>= 2; 839 cmd->info1 = le32_encode_bits(ring_entry_sz, 840 HTT_SRNG_SETUP_CMD_INFO1_RING_ENTRY_SIZE); 841 cmd->info1 |= le32_encode_bits(params.num_entries * ring_entry_sz, 842 HTT_SRNG_SETUP_CMD_INFO1_RING_SIZE); 843 cmd->info1 |= le32_encode_bits(!!(params.flags & HAL_SRNG_FLAGS_MSI_SWAP), 844 HTT_SRNG_SETUP_CMD_INFO1_RING_FLAGS_MSI_SWAP); 845 cmd->info1 |= le32_encode_bits(!!(params.flags & HAL_SRNG_FLAGS_DATA_TLV_SWAP), 846 HTT_SRNG_SETUP_CMD_INFO1_RING_FLAGS_TLV_SWAP); 847 cmd->info1 |= le32_encode_bits(!!(params.flags & HAL_SRNG_FLAGS_RING_PTR_SWAP), 848 HTT_SRNG_SETUP_CMD_INFO1_RING_FLAGS_HOST_FW_SWAP); 849 if (htt_ring_type == HTT_SW_TO_HW_RING) 850 cmd->info1 |= cpu_to_le32(HTT_SRNG_SETUP_CMD_INFO1_RING_LOOP_CNT_DIS); 851 852 cmd->ring_head_off32_remote_addr_lo = cpu_to_le32(lower_32_bits(hp_addr)); 853 cmd->ring_head_off32_remote_addr_hi = cpu_to_le32(upper_32_bits(hp_addr)); 854 855 cmd->ring_tail_off32_remote_addr_lo = cpu_to_le32(lower_32_bits(tp_addr)); 856 cmd->ring_tail_off32_remote_addr_hi = cpu_to_le32(upper_32_bits(tp_addr)); 857 858 cmd->ring_msi_addr_lo = cpu_to_le32(lower_32_bits(params.msi_addr)); 859 cmd->ring_msi_addr_hi = cpu_to_le32(upper_32_bits(params.msi_addr)); 860 cmd->msi_data = cpu_to_le32(params.msi_data); 861 862 cmd->intr_info = 863 le32_encode_bits(params.intr_batch_cntr_thres_entries * ring_entry_sz, 864 HTT_SRNG_SETUP_CMD_INTR_INFO_BATCH_COUNTER_THRESH); 865 cmd->intr_info |= 866 le32_encode_bits(params.intr_timer_thres_us >> 3, 867 HTT_SRNG_SETUP_CMD_INTR_INFO_INTR_TIMER_THRESH); 868 869 cmd->info2 = 0; 870 if (params.flags & HAL_SRNG_FLAGS_LOW_THRESH_INTR_EN) { 871 cmd->info2 = le32_encode_bits(params.low_threshold, 872 HTT_SRNG_SETUP_CMD_INFO2_INTR_LOW_THRESH); 873 } 874 875 ath12k_dbg(ab, ATH12K_DBG_HAL, 876 "%s msi_addr_lo:0x%x, msi_addr_hi:0x%x, msi_data:0x%x\n", 877 __func__, cmd->ring_msi_addr_lo, cmd->ring_msi_addr_hi, 878 cmd->msi_data); 879 880 ath12k_dbg(ab, ATH12K_DBG_HAL, 881 "ring_id:%d, ring_type:%d, intr_info:0x%x, flags:0x%x\n", 882 ring_id, ring_type, cmd->intr_info, cmd->info2); 883 884 ret = ath12k_htc_send(&ab->htc, dp->eid, skb); 885 if (ret) 886 goto err_free; 887 888 return 0; 889 890 err_free: 891 dev_kfree_skb_any(skb); 892 893 return ret; 894 } 895 896 int ath12k_dp_tx_htt_h2t_ver_req_msg(struct ath12k_base *ab) 897 { 898 struct ath12k_dp *dp = ath12k_ab_to_dp(ab); 899 struct sk_buff *skb; 900 struct htt_ver_req_cmd *cmd; 901 int len = sizeof(*cmd); 902 u32 metadata_version; 903 int ret; 904 905 init_completion(&dp->htt_tgt_version_received); 906 907 skb = ath12k_htc_alloc_skb(ab, len); 908 if (!skb) 909 return -ENOMEM; 910 911 skb_put(skb, len); 912 cmd = (struct htt_ver_req_cmd *)skb->data; 913 cmd->ver_reg_info = le32_encode_bits(HTT_H2T_MSG_TYPE_VERSION_REQ, 914 HTT_OPTION_TAG); 915 metadata_version = ath12k_ftm_mode ? HTT_OPTION_TCL_METADATA_VER_V1 : 916 HTT_OPTION_TCL_METADATA_VER_V2; 917 918 cmd->tcl_metadata_version = le32_encode_bits(HTT_TAG_TCL_METADATA_VERSION, 919 HTT_OPTION_TAG) | 920 le32_encode_bits(HTT_TCL_METADATA_VER_SZ, 921 HTT_OPTION_LEN) | 922 le32_encode_bits(metadata_version, 923 HTT_OPTION_VALUE); 924 925 ret = ath12k_htc_send(&ab->htc, dp->eid, skb); 926 if (ret) { 927 dev_kfree_skb_any(skb); 928 return ret; 929 } 930 931 ret = wait_for_completion_timeout(&dp->htt_tgt_version_received, 932 HTT_TARGET_VERSION_TIMEOUT_HZ); 933 if (ret == 0) { 934 ath12k_warn(ab, "htt target version request timed out\n"); 935 return -ETIMEDOUT; 936 } 937 938 if (dp->htt_tgt_ver_major != HTT_TARGET_VERSION_MAJOR) { 939 ath12k_err(ab, "unsupported htt major version %d supported version is %d\n", 940 dp->htt_tgt_ver_major, HTT_TARGET_VERSION_MAJOR); 941 return -EOPNOTSUPP; 942 } 943 944 return 0; 945 } 946 947 int ath12k_dp_tx_htt_h2t_ppdu_stats_req(struct ath12k *ar, u32 mask) 948 { 949 struct ath12k_base *ab = ar->ab; 950 struct ath12k_dp *dp = ath12k_ab_to_dp(ab); 951 struct sk_buff *skb; 952 struct htt_ppdu_stats_cfg_cmd *cmd; 953 int len = sizeof(*cmd); 954 u8 pdev_mask; 955 int ret; 956 int i; 957 958 for (i = 0; i < ab->hw_params->num_rxdma_per_pdev; i++) { 959 skb = ath12k_htc_alloc_skb(ab, len); 960 if (!skb) 961 return -ENOMEM; 962 963 skb_put(skb, len); 964 cmd = (struct htt_ppdu_stats_cfg_cmd *)skb->data; 965 cmd->msg = le32_encode_bits(HTT_H2T_MSG_TYPE_PPDU_STATS_CFG, 966 HTT_PPDU_STATS_CFG_MSG_TYPE); 967 968 pdev_mask = 1 << (i + ar->pdev_idx); 969 cmd->msg |= le32_encode_bits(pdev_mask, HTT_PPDU_STATS_CFG_PDEV_ID); 970 cmd->msg |= le32_encode_bits(mask, HTT_PPDU_STATS_CFG_TLV_TYPE_BITMASK); 971 972 ret = ath12k_htc_send(&ab->htc, dp->eid, skb); 973 if (ret) { 974 dev_kfree_skb_any(skb); 975 return ret; 976 } 977 } 978 979 return 0; 980 } 981 982 int ath12k_dp_tx_htt_rx_filter_setup(struct ath12k_base *ab, u32 ring_id, 983 int mac_id, enum hal_ring_type ring_type, 984 int rx_buf_size, 985 struct htt_rx_ring_tlv_filter *tlv_filter) 986 { 987 struct ath12k_dp *dp = ath12k_ab_to_dp(ab); 988 struct htt_rx_ring_selection_cfg_cmd *cmd; 989 struct hal_srng *srng = &ab->hal.srng_list[ring_id]; 990 struct hal_srng_params params; 991 struct sk_buff *skb; 992 int len = sizeof(*cmd); 993 enum htt_srng_ring_type htt_ring_type; 994 enum htt_srng_ring_id htt_ring_id; 995 int ret; 996 997 skb = ath12k_htc_alloc_skb(ab, len); 998 if (!skb) 999 return -ENOMEM; 1000 1001 memset(¶ms, 0, sizeof(params)); 1002 ath12k_hal_srng_get_params(ab, srng, ¶ms); 1003 1004 ret = ath12k_dp_tx_get_ring_id_type(ab, mac_id, ring_id, 1005 ring_type, &htt_ring_type, 1006 &htt_ring_id); 1007 if (ret) 1008 goto err_free; 1009 1010 skb_put(skb, len); 1011 cmd = (struct htt_rx_ring_selection_cfg_cmd *)skb->data; 1012 cmd->info0 = le32_encode_bits(HTT_H2T_MSG_TYPE_RX_RING_SELECTION_CFG, 1013 HTT_RX_RING_SELECTION_CFG_CMD_INFO0_MSG_TYPE); 1014 if (htt_ring_type == HTT_SW_TO_HW_RING || 1015 htt_ring_type == HTT_HW_TO_SW_RING) 1016 cmd->info0 |= 1017 le32_encode_bits(DP_SW2HW_MACID(mac_id), 1018 HTT_RX_RING_SELECTION_CFG_CMD_INFO0_PDEV_ID); 1019 else 1020 cmd->info0 |= 1021 le32_encode_bits(mac_id, 1022 HTT_RX_RING_SELECTION_CFG_CMD_INFO0_PDEV_ID); 1023 cmd->info0 |= le32_encode_bits(htt_ring_id, 1024 HTT_RX_RING_SELECTION_CFG_CMD_INFO0_RING_ID); 1025 cmd->info0 |= le32_encode_bits(!!(params.flags & HAL_SRNG_FLAGS_MSI_SWAP), 1026 HTT_RX_RING_SELECTION_CFG_CMD_INFO0_SS); 1027 cmd->info0 |= le32_encode_bits(!!(params.flags & HAL_SRNG_FLAGS_DATA_TLV_SWAP), 1028 HTT_RX_RING_SELECTION_CFG_CMD_INFO0_PS); 1029 cmd->info0 |= le32_encode_bits(tlv_filter->offset_valid, 1030 HTT_RX_RING_SELECTION_CFG_CMD_INFO0_OFFSET_VALID); 1031 cmd->info0 |= 1032 le32_encode_bits(tlv_filter->drop_threshold_valid, 1033 HTT_RX_RING_SELECTION_CFG_CMD_INFO0_DROP_THRES_VAL); 1034 cmd->info0 |= le32_encode_bits(!tlv_filter->rxmon_disable, 1035 HTT_RX_RING_SELECTION_CFG_CMD_INFO0_EN_RXMON); 1036 1037 cmd->info1 = le32_encode_bits(rx_buf_size, 1038 HTT_RX_RING_SELECTION_CFG_CMD_INFO1_BUF_SIZE); 1039 cmd->info1 |= le32_encode_bits(tlv_filter->conf_len_mgmt, 1040 HTT_RX_RING_SELECTION_CFG_CMD_INFO1_CONF_LEN_MGMT); 1041 cmd->info1 |= le32_encode_bits(tlv_filter->conf_len_ctrl, 1042 HTT_RX_RING_SELECTION_CFG_CMD_INFO1_CONF_LEN_CTRL); 1043 cmd->info1 |= le32_encode_bits(tlv_filter->conf_len_data, 1044 HTT_RX_RING_SELECTION_CFG_CMD_INFO1_CONF_LEN_DATA); 1045 cmd->pkt_type_en_flags0 = cpu_to_le32(tlv_filter->pkt_filter_flags0); 1046 cmd->pkt_type_en_flags1 = cpu_to_le32(tlv_filter->pkt_filter_flags1); 1047 cmd->pkt_type_en_flags2 = cpu_to_le32(tlv_filter->pkt_filter_flags2); 1048 cmd->pkt_type_en_flags3 = cpu_to_le32(tlv_filter->pkt_filter_flags3); 1049 cmd->rx_filter_tlv = cpu_to_le32(tlv_filter->rx_filter); 1050 1051 cmd->info2 = le32_encode_bits(tlv_filter->rx_drop_threshold, 1052 HTT_RX_RING_SELECTION_CFG_CMD_INFO2_DROP_THRESHOLD); 1053 cmd->info2 |= 1054 le32_encode_bits(tlv_filter->enable_log_mgmt_type, 1055 HTT_RX_RING_SELECTION_CFG_CMD_INFO2_EN_LOG_MGMT_TYPE); 1056 cmd->info2 |= 1057 le32_encode_bits(tlv_filter->enable_log_ctrl_type, 1058 HTT_RX_RING_SELECTION_CFG_CMD_INFO2_EN_CTRL_TYPE); 1059 cmd->info2 |= 1060 le32_encode_bits(tlv_filter->enable_log_data_type, 1061 HTT_RX_RING_SELECTION_CFG_CMD_INFO2_EN_LOG_DATA_TYPE); 1062 1063 cmd->info3 = 1064 le32_encode_bits(tlv_filter->enable_rx_tlv_offset, 1065 HTT_RX_RING_SELECTION_CFG_CMD_INFO3_EN_TLV_PKT_OFFSET); 1066 cmd->info3 |= 1067 le32_encode_bits(tlv_filter->rx_tlv_offset, 1068 HTT_RX_RING_SELECTION_CFG_CMD_INFO3_PKT_TLV_OFFSET); 1069 1070 if (tlv_filter->offset_valid) { 1071 cmd->rx_packet_offset = 1072 le32_encode_bits(tlv_filter->rx_packet_offset, 1073 HTT_RX_RING_SELECTION_CFG_RX_PACKET_OFFSET); 1074 1075 cmd->rx_packet_offset |= 1076 le32_encode_bits(tlv_filter->rx_header_offset, 1077 HTT_RX_RING_SELECTION_CFG_RX_HEADER_OFFSET); 1078 1079 cmd->rx_mpdu_offset = 1080 le32_encode_bits(tlv_filter->rx_mpdu_end_offset, 1081 HTT_RX_RING_SELECTION_CFG_RX_MPDU_END_OFFSET); 1082 1083 cmd->rx_mpdu_offset |= 1084 le32_encode_bits(tlv_filter->rx_mpdu_start_offset, 1085 HTT_RX_RING_SELECTION_CFG_RX_MPDU_START_OFFSET); 1086 1087 cmd->rx_msdu_offset = 1088 le32_encode_bits(tlv_filter->rx_msdu_end_offset, 1089 HTT_RX_RING_SELECTION_CFG_RX_MSDU_END_OFFSET); 1090 1091 cmd->rx_msdu_offset |= 1092 le32_encode_bits(tlv_filter->rx_msdu_start_offset, 1093 HTT_RX_RING_SELECTION_CFG_RX_MSDU_START_OFFSET); 1094 1095 cmd->rx_attn_offset = 1096 le32_encode_bits(tlv_filter->rx_attn_offset, 1097 HTT_RX_RING_SELECTION_CFG_RX_ATTENTION_OFFSET); 1098 } 1099 1100 if (tlv_filter->rx_mpdu_start_wmask > 0 && 1101 tlv_filter->rx_msdu_end_wmask > 0) { 1102 cmd->info2 |= 1103 le32_encode_bits(true, 1104 HTT_RX_RING_SELECTION_CFG_WORD_MASK_COMPACT_SET); 1105 cmd->rx_mpdu_start_end_mask = 1106 le32_encode_bits(tlv_filter->rx_mpdu_start_wmask, 1107 HTT_RX_RING_SELECTION_CFG_RX_MPDU_START_MASK); 1108 /* mpdu_end is not used for any hardwares so far 1109 * please assign it in future if any chip is 1110 * using through hal ops 1111 */ 1112 cmd->rx_mpdu_start_end_mask |= 1113 le32_encode_bits(tlv_filter->rx_mpdu_end_wmask, 1114 HTT_RX_RING_SELECTION_CFG_RX_MPDU_END_MASK); 1115 cmd->rx_msdu_end_word_mask = 1116 le32_encode_bits(tlv_filter->rx_msdu_end_wmask, 1117 HTT_RX_RING_SELECTION_CFG_RX_MSDU_END_MASK); 1118 } 1119 1120 ret = ath12k_htc_send(&ab->htc, dp->eid, skb); 1121 if (ret) 1122 goto err_free; 1123 1124 return 0; 1125 1126 err_free: 1127 dev_kfree_skb_any(skb); 1128 1129 return ret; 1130 } 1131 EXPORT_SYMBOL(ath12k_dp_tx_htt_rx_filter_setup); 1132 1133 int 1134 ath12k_dp_tx_htt_h2t_ext_stats_req(struct ath12k *ar, u8 type, 1135 struct htt_ext_stats_cfg_params *cfg_params, 1136 u64 cookie) 1137 { 1138 struct ath12k_base *ab = ar->ab; 1139 struct ath12k_dp *dp = ath12k_ab_to_dp(ab); 1140 struct sk_buff *skb; 1141 struct htt_ext_stats_cfg_cmd *cmd; 1142 int len = sizeof(*cmd); 1143 int ret; 1144 u32 pdev_id; 1145 1146 skb = ath12k_htc_alloc_skb(ab, len); 1147 if (!skb) 1148 return -ENOMEM; 1149 1150 skb_put(skb, len); 1151 1152 cmd = (struct htt_ext_stats_cfg_cmd *)skb->data; 1153 memset(cmd, 0, sizeof(*cmd)); 1154 cmd->hdr.msg_type = HTT_H2T_MSG_TYPE_EXT_STATS_CFG; 1155 1156 pdev_id = ath12k_mac_get_target_pdev_id(ar); 1157 cmd->hdr.pdev_mask = 1 << pdev_id; 1158 1159 cmd->hdr.stats_type = type; 1160 cmd->cfg_param0 = cpu_to_le32(cfg_params->cfg0); 1161 cmd->cfg_param1 = cpu_to_le32(cfg_params->cfg1); 1162 cmd->cfg_param2 = cpu_to_le32(cfg_params->cfg2); 1163 cmd->cfg_param3 = cpu_to_le32(cfg_params->cfg3); 1164 cmd->cookie_lsb = cpu_to_le32(lower_32_bits(cookie)); 1165 cmd->cookie_msb = cpu_to_le32(upper_32_bits(cookie)); 1166 1167 ret = ath12k_htc_send(&ab->htc, dp->eid, skb); 1168 if (ret) { 1169 ath12k_warn(ab, "failed to send htt type stats request: %d", 1170 ret); 1171 dev_kfree_skb_any(skb); 1172 return ret; 1173 } 1174 1175 return 0; 1176 } 1177 1178 int ath12k_dp_tx_htt_monitor_mode_ring_config(struct ath12k *ar, bool reset) 1179 { 1180 struct ath12k_base *ab = ar->ab; 1181 int ret; 1182 1183 ret = ath12k_dp_tx_htt_rx_monitor_mode_ring_config(ar, reset); 1184 if (ret) { 1185 ath12k_err(ab, "failed to setup rx monitor filter %d\n", ret); 1186 return ret; 1187 } 1188 1189 return 0; 1190 } 1191 1192 int ath12k_dp_tx_htt_rx_monitor_mode_ring_config(struct ath12k *ar, bool reset) 1193 { 1194 struct ath12k_base *ab = ar->ab; 1195 struct ath12k_dp *dp = ath12k_ab_to_dp(ab); 1196 struct htt_rx_ring_tlv_filter tlv_filter = {}; 1197 int ret, ring_id, i; 1198 1199 tlv_filter.offset_valid = false; 1200 1201 if (!reset) { 1202 tlv_filter.rx_filter = HTT_RX_MON_FILTER_TLV_FLAGS_MON_DEST_RING; 1203 1204 tlv_filter.drop_threshold_valid = true; 1205 tlv_filter.rx_drop_threshold = HTT_RX_RING_TLV_DROP_THRESHOLD_VALUE; 1206 1207 tlv_filter.enable_log_mgmt_type = true; 1208 tlv_filter.enable_log_ctrl_type = true; 1209 tlv_filter.enable_log_data_type = true; 1210 1211 tlv_filter.conf_len_ctrl = HTT_RX_RING_DEFAULT_DMA_LENGTH; 1212 tlv_filter.conf_len_mgmt = HTT_RX_RING_DEFAULT_DMA_LENGTH; 1213 tlv_filter.conf_len_data = HTT_RX_RING_DEFAULT_DMA_LENGTH; 1214 1215 tlv_filter.enable_rx_tlv_offset = true; 1216 tlv_filter.rx_tlv_offset = HTT_RX_RING_PKT_TLV_OFFSET; 1217 1218 tlv_filter.pkt_filter_flags0 = 1219 HTT_RX_MON_FP_MGMT_FILTER_FLAGS0 | 1220 HTT_RX_MON_MO_MGMT_FILTER_FLAGS0; 1221 tlv_filter.pkt_filter_flags1 = 1222 HTT_RX_MON_FP_MGMT_FILTER_FLAGS1 | 1223 HTT_RX_MON_MO_MGMT_FILTER_FLAGS1; 1224 tlv_filter.pkt_filter_flags2 = 1225 HTT_RX_MON_FP_CTRL_FILTER_FLASG2 | 1226 HTT_RX_MON_MO_CTRL_FILTER_FLASG2; 1227 tlv_filter.pkt_filter_flags3 = 1228 HTT_RX_MON_FP_CTRL_FILTER_FLASG3 | 1229 HTT_RX_MON_MO_CTRL_FILTER_FLASG3 | 1230 HTT_RX_MON_FP_DATA_FILTER_FLASG3 | 1231 HTT_RX_MON_MO_DATA_FILTER_FLASG3; 1232 } else { 1233 tlv_filter = ath12k_mac_mon_status_filter_default; 1234 1235 if (ath12k_debugfs_is_extd_rx_stats_enabled(ar)) 1236 tlv_filter.rx_filter = ath12k_debugfs_rx_filter(ar); 1237 } 1238 1239 if (ab->hw_params->rxdma1_enable) { 1240 for (i = 0; i < ab->hw_params->num_rxdma_per_pdev; i++) { 1241 ring_id = ar->dp.rxdma_mon_dst_ring[i].ring_id; 1242 ret = ath12k_dp_tx_htt_rx_filter_setup(ar->ab, ring_id, 1243 ar->dp.mac_id + i, 1244 HAL_RXDMA_MONITOR_DST, 1245 DP_RXDMA_REFILL_RING_SIZE, 1246 &tlv_filter); 1247 if (ret) { 1248 ath12k_err(ab, 1249 "failed to setup filter for monitor buf %d\n", 1250 ret); 1251 return ret; 1252 } 1253 } 1254 return 0; 1255 } 1256 1257 if (!reset) { 1258 for (i = 0; i < ab->hw_params->num_rxdma_per_pdev; i++) { 1259 ring_id = dp->rx_mac_buf_ring[i].ring_id; 1260 ret = ath12k_dp_tx_htt_rx_filter_setup(ar->ab, ring_id, 1261 i, 1262 HAL_RXDMA_BUF, 1263 DP_RXDMA_REFILL_RING_SIZE, 1264 &tlv_filter); 1265 if (ret) { 1266 ath12k_err(ab, 1267 "failed to setup filter for mon rx buf %d\n", 1268 ret); 1269 return ret; 1270 } 1271 } 1272 } 1273 1274 for (i = 0; i < ab->hw_params->num_rxdma_per_pdev; i++) { 1275 ring_id = dp->rx_mon_status_refill_ring[i].refill_buf_ring.ring_id; 1276 if (!reset) { 1277 tlv_filter.rx_filter = 1278 HTT_RX_MON_FILTER_TLV_FLAGS_MON_STATUS_RING; 1279 } 1280 1281 ret = ath12k_dp_tx_htt_rx_filter_setup(ab, ring_id, 1282 i, 1283 HAL_RXDMA_MONITOR_STATUS, 1284 RX_MON_STATUS_BUF_SIZE, 1285 &tlv_filter); 1286 if (ret) { 1287 ath12k_err(ab, 1288 "failed to setup filter for mon status buf %d\n", 1289 ret); 1290 return ret; 1291 } 1292 } 1293 1294 return 0; 1295 } 1296 1297 int ath12k_dp_tx_htt_tx_filter_setup(struct ath12k_base *ab, u32 ring_id, 1298 int mac_id, enum hal_ring_type ring_type, 1299 int tx_buf_size, 1300 struct htt_tx_ring_tlv_filter *htt_tlv_filter) 1301 { 1302 struct ath12k_dp *dp = ath12k_ab_to_dp(ab); 1303 struct htt_tx_ring_selection_cfg_cmd *cmd; 1304 struct hal_srng *srng = &ab->hal.srng_list[ring_id]; 1305 struct hal_srng_params params; 1306 struct sk_buff *skb; 1307 int len = sizeof(*cmd); 1308 enum htt_srng_ring_type htt_ring_type; 1309 enum htt_srng_ring_id htt_ring_id; 1310 int ret; 1311 1312 skb = ath12k_htc_alloc_skb(ab, len); 1313 if (!skb) 1314 return -ENOMEM; 1315 1316 memset(¶ms, 0, sizeof(params)); 1317 ath12k_hal_srng_get_params(ab, srng, ¶ms); 1318 1319 ret = ath12k_dp_tx_get_ring_id_type(ab, mac_id, ring_id, 1320 ring_type, &htt_ring_type, 1321 &htt_ring_id); 1322 1323 if (ret) 1324 goto err_free; 1325 1326 skb_put(skb, len); 1327 cmd = (struct htt_tx_ring_selection_cfg_cmd *)skb->data; 1328 cmd->info0 = le32_encode_bits(HTT_H2T_MSG_TYPE_TX_MONITOR_CFG, 1329 HTT_TX_RING_SELECTION_CFG_CMD_INFO0_MSG_TYPE); 1330 if (htt_ring_type == HTT_SW_TO_HW_RING || 1331 htt_ring_type == HTT_HW_TO_SW_RING) 1332 cmd->info0 |= 1333 le32_encode_bits(DP_SW2HW_MACID(mac_id), 1334 HTT_TX_RING_SELECTION_CFG_CMD_INFO0_PDEV_ID); 1335 else 1336 cmd->info0 |= 1337 le32_encode_bits(mac_id, 1338 HTT_TX_RING_SELECTION_CFG_CMD_INFO0_PDEV_ID); 1339 cmd->info0 |= le32_encode_bits(htt_ring_id, 1340 HTT_TX_RING_SELECTION_CFG_CMD_INFO0_RING_ID); 1341 cmd->info0 |= le32_encode_bits(!!(params.flags & HAL_SRNG_FLAGS_MSI_SWAP), 1342 HTT_TX_RING_SELECTION_CFG_CMD_INFO0_SS); 1343 cmd->info0 |= le32_encode_bits(!!(params.flags & HAL_SRNG_FLAGS_DATA_TLV_SWAP), 1344 HTT_TX_RING_SELECTION_CFG_CMD_INFO0_PS); 1345 1346 cmd->info1 |= 1347 le32_encode_bits(tx_buf_size, 1348 HTT_TX_RING_SELECTION_CFG_CMD_INFO1_RING_BUFF_SIZE); 1349 1350 if (htt_tlv_filter->tx_mon_mgmt_filter) { 1351 cmd->info1 |= 1352 le32_encode_bits(HTT_STATS_FRAME_CTRL_TYPE_MGMT, 1353 HTT_TX_RING_SELECTION_CFG_CMD_INFO1_PKT_TYPE); 1354 cmd->info1 |= 1355 le32_encode_bits(htt_tlv_filter->tx_mon_pkt_dma_len, 1356 HTT_TX_RING_SELECTION_CFG_CMD_INFO1_CONF_LEN_MGMT); 1357 cmd->info2 |= 1358 le32_encode_bits(HTT_STATS_FRAME_CTRL_TYPE_MGMT, 1359 HTT_TX_RING_SELECTION_CFG_CMD_INFO2_PKT_TYPE_EN_FLAG); 1360 } 1361 1362 if (htt_tlv_filter->tx_mon_data_filter) { 1363 cmd->info1 |= 1364 le32_encode_bits(HTT_STATS_FRAME_CTRL_TYPE_CTRL, 1365 HTT_TX_RING_SELECTION_CFG_CMD_INFO1_PKT_TYPE); 1366 cmd->info1 |= 1367 le32_encode_bits(htt_tlv_filter->tx_mon_pkt_dma_len, 1368 HTT_TX_RING_SELECTION_CFG_CMD_INFO1_CONF_LEN_CTRL); 1369 cmd->info2 |= 1370 le32_encode_bits(HTT_STATS_FRAME_CTRL_TYPE_CTRL, 1371 HTT_TX_RING_SELECTION_CFG_CMD_INFO2_PKT_TYPE_EN_FLAG); 1372 } 1373 1374 if (htt_tlv_filter->tx_mon_ctrl_filter) { 1375 cmd->info1 |= 1376 le32_encode_bits(HTT_STATS_FRAME_CTRL_TYPE_DATA, 1377 HTT_TX_RING_SELECTION_CFG_CMD_INFO1_PKT_TYPE); 1378 cmd->info1 |= 1379 le32_encode_bits(htt_tlv_filter->tx_mon_pkt_dma_len, 1380 HTT_TX_RING_SELECTION_CFG_CMD_INFO1_CONF_LEN_DATA); 1381 cmd->info2 |= 1382 le32_encode_bits(HTT_STATS_FRAME_CTRL_TYPE_DATA, 1383 HTT_TX_RING_SELECTION_CFG_CMD_INFO2_PKT_TYPE_EN_FLAG); 1384 } 1385 1386 cmd->tlv_filter_mask_in0 = 1387 cpu_to_le32(htt_tlv_filter->tx_mon_downstream_tlv_flags); 1388 cmd->tlv_filter_mask_in1 = 1389 cpu_to_le32(htt_tlv_filter->tx_mon_upstream_tlv_flags0); 1390 cmd->tlv_filter_mask_in2 = 1391 cpu_to_le32(htt_tlv_filter->tx_mon_upstream_tlv_flags1); 1392 cmd->tlv_filter_mask_in3 = 1393 cpu_to_le32(htt_tlv_filter->tx_mon_upstream_tlv_flags2); 1394 1395 ret = ath12k_htc_send(&ab->htc, dp->eid, skb); 1396 if (ret) 1397 goto err_free; 1398 1399 return 0; 1400 1401 err_free: 1402 dev_kfree_skb_any(skb); 1403 return ret; 1404 } 1405