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 "dp_mon.h" 8 #include "debug.h" 9 #include "dp_tx.h" 10 #include "peer.h" 11 12 static void 13 ath12k_dp_mon_fill_rx_stats_info(struct hal_rx_mon_ppdu_info *ppdu_info, 14 struct ieee80211_rx_status *rx_status) 15 { 16 u32 center_freq = ppdu_info->freq; 17 18 rx_status->freq = center_freq; 19 rx_status->bw = ath12k_mac_bw_to_mac80211_bw(ppdu_info->bw); 20 rx_status->nss = ppdu_info->nss; 21 rx_status->rate_idx = 0; 22 rx_status->encoding = RX_ENC_LEGACY; 23 rx_status->flag |= RX_FLAG_NO_SIGNAL_VAL; 24 25 if (center_freq >= ATH12K_MIN_6GHZ_FREQ && 26 center_freq <= ATH12K_MAX_6GHZ_FREQ) { 27 rx_status->band = NL80211_BAND_6GHZ; 28 } else if (center_freq >= ATH12K_MIN_2GHZ_FREQ && 29 center_freq <= ATH12K_MAX_2GHZ_FREQ) { 30 rx_status->band = NL80211_BAND_2GHZ; 31 } else if (center_freq >= ATH12K_MIN_5GHZ_FREQ && 32 center_freq <= ATH12K_MAX_5GHZ_FREQ) { 33 rx_status->band = NL80211_BAND_5GHZ; 34 } else { 35 rx_status->band = NUM_NL80211_BANDS; 36 } 37 } 38 39 struct sk_buff 40 *ath12k_dp_rx_alloc_mon_status_buf(struct ath12k_base *ab, 41 struct dp_rxdma_mon_ring *rx_ring, 42 int *buf_id) 43 { 44 struct sk_buff *skb; 45 dma_addr_t paddr; 46 47 skb = dev_alloc_skb(RX_MON_STATUS_BUF_SIZE); 48 49 if (!skb) 50 goto fail_alloc_skb; 51 52 if (!IS_ALIGNED((unsigned long)skb->data, 53 RX_MON_STATUS_BUF_ALIGN)) { 54 skb_pull(skb, PTR_ALIGN(skb->data, RX_MON_STATUS_BUF_ALIGN) - 55 skb->data); 56 } 57 58 paddr = dma_map_single(ab->dev, skb->data, 59 skb->len + skb_tailroom(skb), 60 DMA_FROM_DEVICE); 61 if (unlikely(dma_mapping_error(ab->dev, paddr))) 62 goto fail_free_skb; 63 64 spin_lock_bh(&rx_ring->idr_lock); 65 *buf_id = idr_alloc(&rx_ring->bufs_idr, skb, 0, 66 rx_ring->bufs_max, GFP_ATOMIC); 67 spin_unlock_bh(&rx_ring->idr_lock); 68 if (*buf_id < 0) 69 goto fail_dma_unmap; 70 71 ATH12K_SKB_RXCB(skb)->paddr = paddr; 72 return skb; 73 74 fail_dma_unmap: 75 dma_unmap_single(ab->dev, paddr, skb->len + skb_tailroom(skb), 76 DMA_FROM_DEVICE); 77 fail_free_skb: 78 dev_kfree_skb_any(skb); 79 fail_alloc_skb: 80 return NULL; 81 } 82 EXPORT_SYMBOL(ath12k_dp_rx_alloc_mon_status_buf); 83 84 u32 ath12k_dp_mon_comp_ppduid(u32 msdu_ppdu_id, u32 *ppdu_id) 85 { 86 u32 ret = 0; 87 88 if ((*ppdu_id < msdu_ppdu_id) && 89 ((msdu_ppdu_id - *ppdu_id) < DP_NOT_PPDU_ID_WRAP_AROUND)) { 90 /* Hold on mon dest ring, and reap mon status ring. */ 91 *ppdu_id = msdu_ppdu_id; 92 ret = msdu_ppdu_id; 93 } else if ((*ppdu_id > msdu_ppdu_id) && 94 ((*ppdu_id - msdu_ppdu_id) > DP_NOT_PPDU_ID_WRAP_AROUND)) { 95 /* PPDU ID has exceeded the maximum value and will 96 * restart from 0. 97 */ 98 *ppdu_id = msdu_ppdu_id; 99 ret = msdu_ppdu_id; 100 } 101 return ret; 102 } 103 EXPORT_SYMBOL(ath12k_dp_mon_comp_ppduid); 104 105 static void 106 ath12k_dp_mon_fill_rx_rate(struct ath12k_pdev_dp *dp_pdev, 107 struct hal_rx_mon_ppdu_info *ppdu_info, 108 struct ieee80211_rx_status *rx_status) 109 { 110 struct ath12k_dp *dp = dp_pdev->dp; 111 struct ath12k_base *ab = dp->ab; 112 struct ieee80211_supported_band *sband; 113 enum rx_msdu_start_pkt_type pkt_type; 114 u8 rate_mcs, nss, sgi; 115 bool is_cck; 116 117 pkt_type = ppdu_info->preamble_type; 118 rate_mcs = ppdu_info->mcs; 119 nss = ppdu_info->nss; 120 sgi = ppdu_info->gi; 121 122 switch (pkt_type) { 123 case RX_MSDU_START_PKT_TYPE_11A: 124 case RX_MSDU_START_PKT_TYPE_11B: 125 rate_mcs = ppdu_info->rate; 126 is_cck = (pkt_type == RX_MSDU_START_PKT_TYPE_11B); 127 if (rx_status->band < NUM_NL80211_BANDS) { 128 struct ath12k *ar = ath12k_pdev_dp_to_ar(dp_pdev); 129 130 sband = &ar->mac.sbands[rx_status->band]; 131 rx_status->rate_idx = ath12k_mac_hw_rate_to_idx(sband, rate_mcs, 132 is_cck); 133 } 134 break; 135 case RX_MSDU_START_PKT_TYPE_11N: 136 rx_status->encoding = RX_ENC_HT; 137 if (rate_mcs > ATH12K_HT_MCS_MAX) { 138 ath12k_warn(ab, 139 "Received with invalid mcs in HT mode %d\n", 140 rate_mcs); 141 break; 142 } 143 rx_status->rate_idx = rate_mcs + (8 * (nss - 1)); 144 if (sgi) 145 rx_status->enc_flags |= RX_ENC_FLAG_SHORT_GI; 146 break; 147 case RX_MSDU_START_PKT_TYPE_11AC: 148 rx_status->encoding = RX_ENC_VHT; 149 rx_status->rate_idx = rate_mcs; 150 if (rate_mcs > ATH12K_VHT_MCS_MAX) { 151 ath12k_warn(ab, 152 "Received with invalid mcs in VHT mode %d\n", 153 rate_mcs); 154 break; 155 } 156 if (sgi) 157 rx_status->enc_flags |= RX_ENC_FLAG_SHORT_GI; 158 break; 159 case RX_MSDU_START_PKT_TYPE_11AX: 160 rx_status->rate_idx = rate_mcs; 161 if (rate_mcs > ATH12K_HE_MCS_MAX) { 162 ath12k_warn(ab, 163 "Received with invalid mcs in HE mode %d\n", 164 rate_mcs); 165 break; 166 } 167 rx_status->encoding = RX_ENC_HE; 168 rx_status->he_gi = ath12k_he_gi_to_nl80211_he_gi(sgi); 169 break; 170 case RX_MSDU_START_PKT_TYPE_11BE: 171 rx_status->rate_idx = rate_mcs; 172 if (rate_mcs > ATH12K_EHT_MCS_MAX) { 173 ath12k_warn(ab, 174 "Received with invalid mcs in EHT mode %d\n", 175 rate_mcs); 176 break; 177 } 178 rx_status->encoding = RX_ENC_EHT; 179 rx_status->he_gi = ath12k_he_gi_to_nl80211_he_gi(sgi); 180 break; 181 default: 182 ath12k_dbg(ab, ATH12K_DBG_DATA, 183 "monitor receives invalid preamble type %d", 184 pkt_type); 185 break; 186 } 187 } 188 189 static void ath12k_dp_mon_rx_msdus_set_payload(struct ath12k_base *ab, 190 struct sk_buff *head_msdu, 191 struct sk_buff *tail_msdu) 192 { 193 u32 rx_pkt_offset, l2_hdr_offset, total_offset; 194 195 rx_pkt_offset = ab->hal.hal_desc_sz; 196 l2_hdr_offset = 197 ath12k_dp_rx_h_l3pad(ab, (struct hal_rx_desc *)tail_msdu->data); 198 199 if (ab->hw_params->rxdma1_enable) 200 total_offset = ATH12K_MON_RX_PKT_OFFSET; 201 else 202 total_offset = rx_pkt_offset + l2_hdr_offset; 203 204 skb_pull(head_msdu, total_offset); 205 } 206 207 struct sk_buff * 208 ath12k_dp_mon_rx_merg_msdus(struct ath12k_pdev_dp *dp_pdev, 209 struct dp_mon_mpdu *mon_mpdu, 210 struct hal_rx_mon_ppdu_info *ppdu_info, 211 struct ieee80211_rx_status *rxs) 212 { 213 struct ath12k_dp *dp = dp_pdev->dp; 214 struct ath12k_base *ab = dp->ab; 215 struct sk_buff *msdu, *mpdu_buf, *prev_buf, *head_frag_list; 216 struct sk_buff *head_msdu, *tail_msdu; 217 struct hal_rx_desc *rx_desc; 218 u8 *hdr_desc, *dest, decap_format = mon_mpdu->decap_format; 219 struct ieee80211_hdr_3addr *wh; 220 struct ieee80211_channel *channel; 221 u32 frag_list_sum_len = 0; 222 u8 channel_num = ppdu_info->chan_num; 223 224 mpdu_buf = NULL; 225 head_msdu = mon_mpdu->head; 226 tail_msdu = mon_mpdu->tail; 227 228 if (!head_msdu || !tail_msdu) 229 goto err_merge_fail; 230 231 ath12k_dp_mon_fill_rx_stats_info(ppdu_info, rxs); 232 233 if (unlikely(rxs->band == NUM_NL80211_BANDS || 234 !ath12k_pdev_dp_to_hw(dp_pdev)->wiphy->bands[rxs->band])) { 235 struct ath12k *ar = ath12k_pdev_dp_to_ar(dp_pdev); 236 237 ath12k_dbg(ab, ATH12K_DBG_DATA, 238 "sband is NULL for status band %d channel_num %d center_freq %d pdev_id %d\n", 239 rxs->band, channel_num, ppdu_info->freq, ar->pdev_idx); 240 241 spin_lock_bh(&ar->data_lock); 242 channel = ar->rx_channel; 243 if (channel) { 244 rxs->band = channel->band; 245 channel_num = 246 ieee80211_frequency_to_channel(channel->center_freq); 247 } 248 spin_unlock_bh(&ar->data_lock); 249 } 250 251 if (rxs->band < NUM_NL80211_BANDS) 252 rxs->freq = ieee80211_channel_to_frequency(channel_num, 253 rxs->band); 254 255 ath12k_dp_mon_fill_rx_rate(dp_pdev, ppdu_info, rxs); 256 257 if (decap_format == DP_RX_DECAP_TYPE_RAW) { 258 ath12k_dp_mon_rx_msdus_set_payload(ab, head_msdu, tail_msdu); 259 260 prev_buf = head_msdu; 261 msdu = head_msdu->next; 262 head_frag_list = NULL; 263 264 while (msdu) { 265 ath12k_dp_mon_rx_msdus_set_payload(ab, head_msdu, tail_msdu); 266 267 if (!head_frag_list) 268 head_frag_list = msdu; 269 270 frag_list_sum_len += msdu->len; 271 prev_buf = msdu; 272 msdu = msdu->next; 273 } 274 275 prev_buf->next = NULL; 276 277 skb_trim(prev_buf, prev_buf->len); 278 if (head_frag_list) { 279 skb_shinfo(head_msdu)->frag_list = head_frag_list; 280 head_msdu->data_len = frag_list_sum_len; 281 head_msdu->len += head_msdu->data_len; 282 head_msdu->next = NULL; 283 } 284 } else if (decap_format == DP_RX_DECAP_TYPE_NATIVE_WIFI) { 285 u8 qos_pkt = 0; 286 287 rx_desc = (struct hal_rx_desc *)head_msdu->data; 288 hdr_desc = 289 ab->hal.ops->rx_desc_get_msdu_payload(rx_desc); 290 291 /* Base size */ 292 wh = (struct ieee80211_hdr_3addr *)hdr_desc; 293 294 if (ieee80211_is_data_qos(wh->frame_control)) 295 qos_pkt = 1; 296 297 msdu = head_msdu; 298 299 while (msdu) { 300 ath12k_dp_mon_rx_msdus_set_payload(ab, head_msdu, tail_msdu); 301 if (qos_pkt) { 302 dest = skb_push(msdu, sizeof(__le16)); 303 if (!dest) 304 goto err_merge_fail; 305 memcpy(dest, hdr_desc, sizeof(struct ieee80211_qos_hdr)); 306 } 307 prev_buf = msdu; 308 msdu = msdu->next; 309 } 310 dest = skb_put(prev_buf, HAL_RX_FCS_LEN); 311 if (!dest) 312 goto err_merge_fail; 313 314 ath12k_dbg(ab, ATH12K_DBG_DATA, 315 "mpdu_buf %p mpdu_buf->len %u", 316 prev_buf, prev_buf->len); 317 } else { 318 ath12k_dbg(ab, ATH12K_DBG_DATA, 319 "decap format %d is not supported!\n", 320 decap_format); 321 goto err_merge_fail; 322 } 323 324 return head_msdu; 325 326 err_merge_fail: 327 if (mpdu_buf && decap_format != DP_RX_DECAP_TYPE_RAW) { 328 ath12k_dbg(ab, ATH12K_DBG_DATA, 329 "err_merge_fail mpdu_buf %p", mpdu_buf); 330 /* Free the head buffer */ 331 dev_kfree_skb_any(mpdu_buf); 332 } 333 return NULL; 334 } 335 EXPORT_SYMBOL(ath12k_dp_mon_rx_merg_msdus); 336 337 static void 338 ath12k_dp_mon_rx_update_radiotap_he(struct hal_rx_mon_ppdu_info *rx_status, 339 u8 *rtap_buf) 340 { 341 u32 rtap_len = 0; 342 343 put_unaligned_le16(rx_status->he_data1, &rtap_buf[rtap_len]); 344 rtap_len += 2; 345 346 put_unaligned_le16(rx_status->he_data2, &rtap_buf[rtap_len]); 347 rtap_len += 2; 348 349 put_unaligned_le16(rx_status->he_data3, &rtap_buf[rtap_len]); 350 rtap_len += 2; 351 352 put_unaligned_le16(rx_status->he_data4, &rtap_buf[rtap_len]); 353 rtap_len += 2; 354 355 put_unaligned_le16(rx_status->he_data5, &rtap_buf[rtap_len]); 356 rtap_len += 2; 357 358 put_unaligned_le16(rx_status->he_data6, &rtap_buf[rtap_len]); 359 } 360 361 static void 362 ath12k_dp_mon_rx_update_radiotap_he_mu(struct hal_rx_mon_ppdu_info *rx_status, 363 u8 *rtap_buf) 364 { 365 u32 rtap_len = 0; 366 367 put_unaligned_le16(rx_status->he_flags1, &rtap_buf[rtap_len]); 368 rtap_len += 2; 369 370 put_unaligned_le16(rx_status->he_flags2, &rtap_buf[rtap_len]); 371 rtap_len += 2; 372 373 rtap_buf[rtap_len] = rx_status->he_RU[0]; 374 rtap_len += 1; 375 376 rtap_buf[rtap_len] = rx_status->he_RU[1]; 377 rtap_len += 1; 378 379 rtap_buf[rtap_len] = rx_status->he_RU[2]; 380 rtap_len += 1; 381 382 rtap_buf[rtap_len] = rx_status->he_RU[3]; 383 } 384 385 void ath12k_dp_mon_update_radiotap(struct ath12k_pdev_dp *dp_pdev, 386 struct hal_rx_mon_ppdu_info *ppduinfo, 387 struct sk_buff *mon_skb, 388 struct ieee80211_rx_status *rxs) 389 { 390 struct ath12k *ar = ath12k_pdev_dp_to_ar(dp_pdev); 391 struct ieee80211_supported_band *sband; 392 s32 noise_floor; 393 u8 *ptr = NULL; 394 395 spin_lock_bh(&ar->data_lock); 396 noise_floor = ath12k_pdev_get_noise_floor(ar); 397 spin_unlock_bh(&ar->data_lock); 398 399 rxs->flag |= RX_FLAG_MACTIME_START; 400 rxs->nss = ppduinfo->nss; 401 if (test_bit(WMI_TLV_SERVICE_HW_DB2DBM_CONVERSION_SUPPORT, 402 ar->ab->wmi_ab.svc_map)) 403 rxs->signal = ppduinfo->rssi_comb; 404 else 405 rxs->signal = ppduinfo->rssi_comb + noise_floor; 406 407 if (ppduinfo->userstats[ppduinfo->userid].ampdu_present) { 408 rxs->flag |= RX_FLAG_AMPDU_DETAILS; 409 rxs->ampdu_reference = ppduinfo->userstats[ppduinfo->userid].ampdu_id; 410 } 411 412 if (ppduinfo->is_eht || ppduinfo->eht_usig) { 413 struct ieee80211_radiotap_tlv *tlv; 414 struct ieee80211_radiotap_eht *eht; 415 struct ieee80211_radiotap_eht_usig *usig; 416 u16 len = 0, i, eht_len, usig_len; 417 u8 user; 418 419 if (ppduinfo->is_eht) { 420 eht_len = struct_size(eht, 421 user_info, 422 ppduinfo->eht_info.num_user_info); 423 len += sizeof(*tlv) + eht_len; 424 } 425 426 if (ppduinfo->eht_usig) { 427 usig_len = sizeof(*usig); 428 len += sizeof(*tlv) + usig_len; 429 } 430 431 rxs->flag |= RX_FLAG_RADIOTAP_TLV_AT_END; 432 rxs->encoding = RX_ENC_EHT; 433 434 skb_reset_mac_header(mon_skb); 435 436 tlv = skb_push(mon_skb, len); 437 438 if (ppduinfo->is_eht) { 439 tlv->type = cpu_to_le16(IEEE80211_RADIOTAP_EHT); 440 tlv->len = cpu_to_le16(eht_len); 441 442 eht = (struct ieee80211_radiotap_eht *)tlv->data; 443 eht->known = ppduinfo->eht_info.eht.known; 444 445 for (i = 0; 446 i < ARRAY_SIZE(eht->data) && 447 i < ARRAY_SIZE(ppduinfo->eht_info.eht.data); 448 i++) 449 eht->data[i] = ppduinfo->eht_info.eht.data[i]; 450 451 for (user = 0; user < ppduinfo->eht_info.num_user_info; user++) 452 put_unaligned_le32(ppduinfo->eht_info.user_info[user], 453 &eht->user_info[user]); 454 455 tlv = (struct ieee80211_radiotap_tlv *)&tlv->data[eht_len]; 456 } 457 458 if (ppduinfo->eht_usig) { 459 tlv->type = cpu_to_le16(IEEE80211_RADIOTAP_EHT_USIG); 460 tlv->len = cpu_to_le16(usig_len); 461 462 usig = (struct ieee80211_radiotap_eht_usig *)tlv->data; 463 *usig = ppduinfo->u_sig_info.usig; 464 } 465 } else if (ppduinfo->he_mu_flags) { 466 rxs->flag |= RX_FLAG_RADIOTAP_HE_MU; 467 rxs->encoding = RX_ENC_HE; 468 ptr = skb_push(mon_skb, sizeof(struct ieee80211_radiotap_he_mu)); 469 ath12k_dp_mon_rx_update_radiotap_he_mu(ppduinfo, ptr); 470 } else if (ppduinfo->he_flags) { 471 rxs->flag |= RX_FLAG_RADIOTAP_HE; 472 rxs->encoding = RX_ENC_HE; 473 ptr = skb_push(mon_skb, sizeof(struct ieee80211_radiotap_he)); 474 ath12k_dp_mon_rx_update_radiotap_he(ppduinfo, ptr); 475 } else if (ppduinfo->vht_flags) { 476 rxs->encoding = RX_ENC_VHT; 477 } else if (ppduinfo->ht_flags) { 478 rxs->encoding = RX_ENC_HT; 479 } else { 480 struct ath12k *ar; 481 482 ar = ath12k_pdev_dp_to_ar(dp_pdev); 483 rxs->encoding = RX_ENC_LEGACY; 484 sband = &ar->mac.sbands[rxs->band]; 485 rxs->rate_idx = ath12k_mac_hw_rate_to_idx(sband, ppduinfo->rate, 486 ppduinfo->cck_flag); 487 } 488 489 rxs->mactime = ppduinfo->tsft; 490 } 491 EXPORT_SYMBOL(ath12k_dp_mon_update_radiotap); 492 493 void ath12k_dp_mon_rx_deliver_msdu(struct ath12k_pdev_dp *dp_pdev, 494 struct napi_struct *napi, 495 struct sk_buff *msdu, 496 struct ieee80211_rx_status *status) 497 { 498 static const struct ieee80211_radiotap_he known = { 499 .data1 = cpu_to_le16(IEEE80211_RADIOTAP_HE_DATA1_DATA_MCS_KNOWN | 500 IEEE80211_RADIOTAP_HE_DATA1_BW_RU_ALLOC_KNOWN), 501 .data2 = cpu_to_le16(IEEE80211_RADIOTAP_HE_DATA2_GI_KNOWN), 502 }; 503 struct ieee80211_rx_status *rx_status; 504 struct ieee80211_radiotap_he *he = NULL; 505 506 status->link_valid = 0; 507 508 if ((status->encoding == RX_ENC_HE) && !(status->flag & RX_FLAG_RADIOTAP_HE) && 509 !(status->flag & RX_FLAG_SKIP_MONITOR)) { 510 he = skb_push(msdu, sizeof(known)); 511 memcpy(he, &known, sizeof(known)); 512 status->flag |= RX_FLAG_RADIOTAP_HE; 513 } 514 515 rx_status = IEEE80211_SKB_RXCB(msdu); 516 *rx_status = *status; 517 518 ieee80211_rx_napi(ath12k_pdev_dp_to_hw(dp_pdev), NULL, msdu, napi); 519 } 520 EXPORT_SYMBOL(ath12k_dp_mon_rx_deliver_msdu); 521 522 int ath12k_dp_pkt_set_pktlen(struct sk_buff *skb, u32 len) 523 { 524 if (skb->len > len) { 525 skb_trim(skb, len); 526 } else { 527 if (skb_tailroom(skb) < len - skb->len) { 528 if ((pskb_expand_head(skb, 0, 529 len - skb->len - skb_tailroom(skb), 530 GFP_ATOMIC))) { 531 return -ENOMEM; 532 } 533 } 534 skb_put(skb, (len - skb->len)); 535 } 536 537 return 0; 538 } 539 EXPORT_SYMBOL(ath12k_dp_pkt_set_pktlen); 540 541 int 542 ath12k_dp_mon_parse_status_buf(struct ath12k_pdev_dp *dp_pdev, 543 struct ath12k_mon_data *pmon, 544 const struct dp_mon_packet_info *packet_info) 545 { 546 struct ath12k_dp *dp = dp_pdev->dp; 547 struct ath12k_base *ab = dp->ab; 548 struct dp_rxdma_mon_ring *buf_ring = &dp->rxdma_mon_buf_ring; 549 struct sk_buff *msdu; 550 int buf_id; 551 u32 offset; 552 553 buf_id = u32_get_bits(packet_info->cookie, DP_RXDMA_BUF_COOKIE_BUF_ID); 554 555 spin_lock_bh(&buf_ring->idr_lock); 556 msdu = idr_remove(&buf_ring->bufs_idr, buf_id); 557 spin_unlock_bh(&buf_ring->idr_lock); 558 559 if (unlikely(!msdu)) { 560 ath12k_warn(ab, "mon dest desc with inval buf_id %d\n", buf_id); 561 return 0; 562 } 563 564 dma_unmap_single(ab->dev, ATH12K_SKB_RXCB(msdu)->paddr, 565 msdu->len + skb_tailroom(msdu), 566 DMA_FROM_DEVICE); 567 568 offset = packet_info->dma_length + ATH12K_MON_RX_DOT11_OFFSET; 569 if (ath12k_dp_pkt_set_pktlen(msdu, offset)) { 570 dev_kfree_skb_any(msdu); 571 goto dest_replenish; 572 } 573 574 if (!pmon->mon_mpdu->head) 575 pmon->mon_mpdu->head = msdu; 576 else 577 pmon->mon_mpdu->tail->next = msdu; 578 579 pmon->mon_mpdu->tail = msdu; 580 581 dest_replenish: 582 ath12k_dp_mon_buf_replenish(ab, buf_ring, 1); 583 584 return 0; 585 } 586 EXPORT_SYMBOL(ath12k_dp_mon_parse_status_buf); 587 588 int ath12k_dp_mon_buf_replenish(struct ath12k_base *ab, 589 struct dp_rxdma_mon_ring *buf_ring, 590 int req_entries) 591 { 592 struct hal_mon_buf_ring *mon_buf; 593 struct sk_buff *skb; 594 struct hal_srng *srng; 595 dma_addr_t paddr; 596 u32 cookie; 597 int buf_id; 598 599 srng = &ab->hal.srng_list[buf_ring->refill_buf_ring.ring_id]; 600 spin_lock_bh(&srng->lock); 601 ath12k_hal_srng_access_begin(ab, srng); 602 603 while (req_entries > 0) { 604 skb = dev_alloc_skb(DP_RX_BUFFER_SIZE + DP_RX_BUFFER_ALIGN_SIZE); 605 if (unlikely(!skb)) 606 goto fail_alloc_skb; 607 608 if (!IS_ALIGNED((unsigned long)skb->data, DP_RX_BUFFER_ALIGN_SIZE)) { 609 skb_pull(skb, 610 PTR_ALIGN(skb->data, DP_RX_BUFFER_ALIGN_SIZE) - 611 skb->data); 612 } 613 614 paddr = dma_map_single(ab->dev, skb->data, 615 skb->len + skb_tailroom(skb), 616 DMA_FROM_DEVICE); 617 618 if (unlikely(dma_mapping_error(ab->dev, paddr))) 619 goto fail_free_skb; 620 621 spin_lock_bh(&buf_ring->idr_lock); 622 buf_id = idr_alloc(&buf_ring->bufs_idr, skb, 0, 623 buf_ring->bufs_max * 3, GFP_ATOMIC); 624 spin_unlock_bh(&buf_ring->idr_lock); 625 626 if (unlikely(buf_id < 0)) 627 goto fail_dma_unmap; 628 629 mon_buf = ath12k_hal_srng_src_get_next_entry(ab, srng); 630 if (unlikely(!mon_buf)) 631 goto fail_idr_remove; 632 633 ATH12K_SKB_RXCB(skb)->paddr = paddr; 634 635 cookie = u32_encode_bits(buf_id, DP_RXDMA_BUF_COOKIE_BUF_ID); 636 637 mon_buf->paddr_lo = cpu_to_le32(lower_32_bits(paddr)); 638 mon_buf->paddr_hi = cpu_to_le32(upper_32_bits(paddr)); 639 mon_buf->cookie = cpu_to_le64(cookie); 640 641 req_entries--; 642 } 643 644 ath12k_hal_srng_access_end(ab, srng); 645 spin_unlock_bh(&srng->lock); 646 return 0; 647 648 fail_idr_remove: 649 spin_lock_bh(&buf_ring->idr_lock); 650 idr_remove(&buf_ring->bufs_idr, buf_id); 651 spin_unlock_bh(&buf_ring->idr_lock); 652 fail_dma_unmap: 653 dma_unmap_single(ab->dev, paddr, skb->len + skb_tailroom(skb), 654 DMA_FROM_DEVICE); 655 fail_free_skb: 656 dev_kfree_skb_any(skb); 657 fail_alloc_skb: 658 ath12k_hal_srng_access_end(ab, srng); 659 spin_unlock_bh(&srng->lock); 660 return -ENOMEM; 661 } 662 EXPORT_SYMBOL(ath12k_dp_mon_buf_replenish); 663 664 int ath12k_dp_mon_status_bufs_replenish(struct ath12k_base *ab, 665 struct dp_rxdma_mon_ring *rx_ring, 666 int req_entries) 667 { 668 enum hal_rx_buf_return_buf_manager mgr = 669 ab->hal.hal_params->rx_buf_rbm; 670 int num_free, num_remain, buf_id; 671 struct ath12k_buffer_addr *desc; 672 struct hal_srng *srng; 673 struct sk_buff *skb; 674 dma_addr_t paddr; 675 u32 cookie; 676 677 req_entries = min(req_entries, rx_ring->bufs_max); 678 679 srng = &ab->hal.srng_list[rx_ring->refill_buf_ring.ring_id]; 680 681 spin_lock_bh(&srng->lock); 682 683 ath12k_hal_srng_access_begin(ab, srng); 684 685 num_free = ath12k_hal_srng_src_num_free(ab, srng, true); 686 if (!req_entries && (num_free > (rx_ring->bufs_max * 3) / 4)) 687 req_entries = num_free; 688 689 req_entries = min(num_free, req_entries); 690 num_remain = req_entries; 691 692 while (num_remain > 0) { 693 skb = dev_alloc_skb(RX_MON_STATUS_BUF_SIZE); 694 if (!skb) 695 break; 696 697 if (!IS_ALIGNED((unsigned long)skb->data, 698 RX_MON_STATUS_BUF_ALIGN)) { 699 skb_pull(skb, 700 PTR_ALIGN(skb->data, RX_MON_STATUS_BUF_ALIGN) - 701 skb->data); 702 } 703 704 paddr = dma_map_single(ab->dev, skb->data, 705 skb->len + skb_tailroom(skb), 706 DMA_FROM_DEVICE); 707 if (dma_mapping_error(ab->dev, paddr)) 708 goto fail_free_skb; 709 710 spin_lock_bh(&rx_ring->idr_lock); 711 buf_id = idr_alloc(&rx_ring->bufs_idr, skb, 0, 712 rx_ring->bufs_max * 3, GFP_ATOMIC); 713 spin_unlock_bh(&rx_ring->idr_lock); 714 if (buf_id < 0) 715 goto fail_dma_unmap; 716 cookie = u32_encode_bits(buf_id, DP_RXDMA_BUF_COOKIE_BUF_ID); 717 718 desc = ath12k_hal_srng_src_get_next_entry(ab, srng); 719 if (!desc) 720 goto fail_buf_unassign; 721 722 ATH12K_SKB_RXCB(skb)->paddr = paddr; 723 724 num_remain--; 725 726 ath12k_hal_rx_buf_addr_info_set(&ab->hal, desc, paddr, cookie, mgr); 727 } 728 729 ath12k_hal_srng_access_end(ab, srng); 730 731 spin_unlock_bh(&srng->lock); 732 733 return req_entries - num_remain; 734 735 fail_buf_unassign: 736 spin_lock_bh(&rx_ring->idr_lock); 737 idr_remove(&rx_ring->bufs_idr, buf_id); 738 spin_unlock_bh(&rx_ring->idr_lock); 739 fail_dma_unmap: 740 dma_unmap_single(ab->dev, paddr, skb->len + skb_tailroom(skb), 741 DMA_FROM_DEVICE); 742 fail_free_skb: 743 dev_kfree_skb_any(skb); 744 745 ath12k_hal_srng_access_end(ab, srng); 746 747 spin_unlock_bh(&srng->lock); 748 749 return req_entries - num_remain; 750 } 751 752 static void 753 ath12k_dp_mon_rx_update_peer_rate_table_stats(struct ath12k_rx_peer_stats *rx_stats, 754 struct hal_rx_mon_ppdu_info *ppdu_info, 755 struct hal_rx_user_status *user_stats, 756 u32 num_msdu) 757 { 758 struct ath12k_rx_peer_rate_stats *stats; 759 u32 mcs_idx = (user_stats) ? user_stats->mcs : ppdu_info->mcs; 760 u32 nss_idx = (user_stats) ? user_stats->nss - 1 : ppdu_info->nss - 1; 761 u32 bw_idx = ppdu_info->bw; 762 u32 gi_idx = ppdu_info->gi; 763 u32 len; 764 765 if (!rx_stats) 766 return; 767 768 if (mcs_idx > HAL_RX_MAX_MCS_HT || nss_idx >= HAL_RX_MAX_NSS || 769 bw_idx >= HAL_RX_BW_MAX || gi_idx >= HAL_RX_GI_MAX) { 770 return; 771 } 772 773 if (ppdu_info->preamble_type == HAL_RX_PREAMBLE_11AX || 774 ppdu_info->preamble_type == HAL_RX_PREAMBLE_11BE) 775 gi_idx = ath12k_he_gi_to_nl80211_he_gi(ppdu_info->gi); 776 777 rx_stats->pkt_stats.rx_rate[bw_idx][gi_idx][nss_idx][mcs_idx] += num_msdu; 778 stats = &rx_stats->byte_stats; 779 780 if (user_stats) 781 len = user_stats->mpdu_ok_byte_count; 782 else 783 len = ppdu_info->mpdu_len; 784 785 stats->rx_rate[bw_idx][gi_idx][nss_idx][mcs_idx] += len; 786 } 787 788 void ath12k_dp_mon_rx_update_peer_su_stats(struct ath12k_dp_link_peer *peer, 789 struct hal_rx_mon_ppdu_info *ppdu_info) 790 { 791 struct ath12k_rx_peer_stats *rx_stats = peer->peer_stats.rx_stats; 792 u32 num_msdu; 793 794 peer->rssi_comb = ppdu_info->rssi_comb; 795 ewma_avg_rssi_add(&peer->avg_rssi, ppdu_info->rssi_comb); 796 if (!rx_stats) 797 return; 798 799 num_msdu = ppdu_info->tcp_msdu_count + ppdu_info->tcp_ack_msdu_count + 800 ppdu_info->udp_msdu_count + ppdu_info->other_msdu_count; 801 802 rx_stats->num_msdu += num_msdu; 803 rx_stats->tcp_msdu_count += ppdu_info->tcp_msdu_count + 804 ppdu_info->tcp_ack_msdu_count; 805 rx_stats->udp_msdu_count += ppdu_info->udp_msdu_count; 806 rx_stats->other_msdu_count += ppdu_info->other_msdu_count; 807 808 if (ppdu_info->preamble_type == HAL_RX_PREAMBLE_11A || 809 ppdu_info->preamble_type == HAL_RX_PREAMBLE_11B) { 810 ppdu_info->nss = 1; 811 ppdu_info->mcs = HAL_RX_MAX_MCS; 812 ppdu_info->tid = IEEE80211_NUM_TIDS; 813 } 814 815 if (ppdu_info->ldpc < HAL_RX_SU_MU_CODING_MAX) 816 rx_stats->coding_count[ppdu_info->ldpc] += num_msdu; 817 818 if (ppdu_info->tid <= IEEE80211_NUM_TIDS) 819 rx_stats->tid_count[ppdu_info->tid] += num_msdu; 820 821 if (ppdu_info->preamble_type < HAL_RX_PREAMBLE_MAX) 822 rx_stats->pream_cnt[ppdu_info->preamble_type] += num_msdu; 823 824 if (ppdu_info->reception_type < HAL_RX_RECEPTION_TYPE_MAX) 825 rx_stats->reception_type[ppdu_info->reception_type] += num_msdu; 826 827 if (ppdu_info->is_stbc) 828 rx_stats->stbc_count += num_msdu; 829 830 if (ppdu_info->beamformed) 831 rx_stats->beamformed_count += num_msdu; 832 833 if (ppdu_info->num_mpdu_fcs_ok > 1) 834 rx_stats->ampdu_msdu_count += num_msdu; 835 else 836 rx_stats->non_ampdu_msdu_count += num_msdu; 837 838 rx_stats->num_mpdu_fcs_ok += ppdu_info->num_mpdu_fcs_ok; 839 rx_stats->num_mpdu_fcs_err += ppdu_info->num_mpdu_fcs_err; 840 rx_stats->dcm_count += ppdu_info->dcm; 841 842 rx_stats->rx_duration += ppdu_info->rx_duration; 843 peer->rx_duration = rx_stats->rx_duration; 844 845 if (ppdu_info->nss > 0 && ppdu_info->nss <= HAL_RX_MAX_NSS) { 846 rx_stats->pkt_stats.nss_count[ppdu_info->nss - 1] += num_msdu; 847 rx_stats->byte_stats.nss_count[ppdu_info->nss - 1] += ppdu_info->mpdu_len; 848 } 849 850 if (ppdu_info->preamble_type == HAL_RX_PREAMBLE_11N && 851 ppdu_info->mcs <= HAL_RX_MAX_MCS_HT) { 852 rx_stats->pkt_stats.ht_mcs_count[ppdu_info->mcs] += num_msdu; 853 rx_stats->byte_stats.ht_mcs_count[ppdu_info->mcs] += ppdu_info->mpdu_len; 854 /* To fit into rate table for HT packets */ 855 ppdu_info->mcs = ppdu_info->mcs % 8; 856 } 857 858 if (ppdu_info->preamble_type == HAL_RX_PREAMBLE_11AC && 859 ppdu_info->mcs <= HAL_RX_MAX_MCS_VHT) { 860 rx_stats->pkt_stats.vht_mcs_count[ppdu_info->mcs] += num_msdu; 861 rx_stats->byte_stats.vht_mcs_count[ppdu_info->mcs] += ppdu_info->mpdu_len; 862 } 863 864 if (ppdu_info->preamble_type == HAL_RX_PREAMBLE_11AX && 865 ppdu_info->mcs <= HAL_RX_MAX_MCS_HE) { 866 rx_stats->pkt_stats.he_mcs_count[ppdu_info->mcs] += num_msdu; 867 rx_stats->byte_stats.he_mcs_count[ppdu_info->mcs] += ppdu_info->mpdu_len; 868 } 869 870 if (ppdu_info->preamble_type == HAL_RX_PREAMBLE_11BE && 871 ppdu_info->mcs <= HAL_RX_MAX_MCS_BE) { 872 rx_stats->pkt_stats.be_mcs_count[ppdu_info->mcs] += num_msdu; 873 rx_stats->byte_stats.be_mcs_count[ppdu_info->mcs] += ppdu_info->mpdu_len; 874 } 875 876 if ((ppdu_info->preamble_type == HAL_RX_PREAMBLE_11A || 877 ppdu_info->preamble_type == HAL_RX_PREAMBLE_11B) && 878 ppdu_info->rate < HAL_RX_LEGACY_RATE_INVALID) { 879 rx_stats->pkt_stats.legacy_count[ppdu_info->rate] += num_msdu; 880 rx_stats->byte_stats.legacy_count[ppdu_info->rate] += ppdu_info->mpdu_len; 881 } 882 883 if (ppdu_info->gi < HAL_RX_GI_MAX) { 884 rx_stats->pkt_stats.gi_count[ppdu_info->gi] += num_msdu; 885 rx_stats->byte_stats.gi_count[ppdu_info->gi] += ppdu_info->mpdu_len; 886 } 887 888 if (ppdu_info->bw < HAL_RX_BW_MAX) { 889 rx_stats->pkt_stats.bw_count[ppdu_info->bw] += num_msdu; 890 rx_stats->byte_stats.bw_count[ppdu_info->bw] += ppdu_info->mpdu_len; 891 } 892 893 ath12k_dp_mon_rx_update_peer_rate_table_stats(rx_stats, ppdu_info, 894 NULL, num_msdu); 895 } 896 EXPORT_SYMBOL(ath12k_dp_mon_rx_update_peer_su_stats); 897 898 void ath12k_dp_mon_rx_process_ulofdma(struct hal_rx_mon_ppdu_info *ppdu_info) 899 { 900 struct hal_rx_user_status *rx_user_status; 901 u32 num_users, i, mu_ul_user_v0_word0, mu_ul_user_v0_word1, ru_size; 902 903 if (!(ppdu_info->reception_type == HAL_RX_RECEPTION_TYPE_MU_MIMO || 904 ppdu_info->reception_type == HAL_RX_RECEPTION_TYPE_MU_OFDMA || 905 ppdu_info->reception_type == HAL_RX_RECEPTION_TYPE_MU_OFDMA_MIMO)) 906 return; 907 908 num_users = ppdu_info->num_users; 909 if (num_users > HAL_MAX_UL_MU_USERS) 910 num_users = HAL_MAX_UL_MU_USERS; 911 912 for (i = 0; i < num_users; i++) { 913 rx_user_status = &ppdu_info->userstats[i]; 914 mu_ul_user_v0_word0 = 915 rx_user_status->ul_ofdma_user_v0_word0; 916 mu_ul_user_v0_word1 = 917 rx_user_status->ul_ofdma_user_v0_word1; 918 919 if (u32_get_bits(mu_ul_user_v0_word0, 920 HAL_RX_UL_OFDMA_USER_INFO_V0_W0_VALID) && 921 !u32_get_bits(mu_ul_user_v0_word0, 922 HAL_RX_UL_OFDMA_USER_INFO_V0_W0_VER)) { 923 rx_user_status->mcs = 924 u32_get_bits(mu_ul_user_v0_word1, 925 HAL_RX_UL_OFDMA_USER_INFO_V0_W1_MCS); 926 rx_user_status->nss = 927 u32_get_bits(mu_ul_user_v0_word1, 928 HAL_RX_UL_OFDMA_USER_INFO_V0_W1_NSS) + 1; 929 930 rx_user_status->ofdma_info_valid = 1; 931 rx_user_status->ul_ofdma_ru_start_index = 932 u32_get_bits(mu_ul_user_v0_word1, 933 HAL_RX_UL_OFDMA_USER_INFO_V0_W1_RU_START); 934 935 ru_size = u32_get_bits(mu_ul_user_v0_word1, 936 HAL_RX_UL_OFDMA_USER_INFO_V0_W1_RU_SIZE); 937 rx_user_status->ul_ofdma_ru_width = ru_size; 938 rx_user_status->ul_ofdma_ru_size = ru_size; 939 } 940 rx_user_status->ldpc = u32_get_bits(mu_ul_user_v0_word1, 941 HAL_RX_UL_OFDMA_USER_INFO_V0_W1_LDPC); 942 } 943 ppdu_info->ldpc = 1; 944 } 945 EXPORT_SYMBOL(ath12k_dp_mon_rx_process_ulofdma); 946 947 static void 948 ath12k_dp_mon_rx_update_user_stats(struct ath12k_base *ab, 949 struct hal_rx_mon_ppdu_info *ppdu_info, 950 u32 uid) 951 { 952 struct ath12k_rx_peer_stats *rx_stats = NULL; 953 struct hal_rx_user_status *user_stats = &ppdu_info->userstats[uid]; 954 struct ath12k_dp_link_peer *peer; 955 u32 num_msdu; 956 struct ath12k_dp *dp = ath12k_ab_to_dp(ab); 957 958 if (user_stats->ast_index == 0 || user_stats->ast_index == 0xFFFF) 959 return; 960 961 peer = ath12k_dp_link_peer_find_by_ast(dp, user_stats->ast_index); 962 963 if (!peer) { 964 ath12k_warn(ab, "peer ast idx %d can't be found\n", 965 user_stats->ast_index); 966 return; 967 } 968 969 peer->rssi_comb = ppdu_info->rssi_comb; 970 ewma_avg_rssi_add(&peer->avg_rssi, ppdu_info->rssi_comb); 971 rx_stats = peer->peer_stats.rx_stats; 972 if (!rx_stats) 973 return; 974 975 num_msdu = user_stats->tcp_msdu_count + user_stats->tcp_ack_msdu_count + 976 user_stats->udp_msdu_count + user_stats->other_msdu_count; 977 978 rx_stats->num_msdu += num_msdu; 979 rx_stats->tcp_msdu_count += user_stats->tcp_msdu_count + 980 user_stats->tcp_ack_msdu_count; 981 rx_stats->udp_msdu_count += user_stats->udp_msdu_count; 982 rx_stats->other_msdu_count += user_stats->other_msdu_count; 983 984 if (ppdu_info->ldpc < HAL_RX_SU_MU_CODING_MAX) 985 rx_stats->coding_count[ppdu_info->ldpc] += num_msdu; 986 987 if (user_stats->tid <= IEEE80211_NUM_TIDS) 988 rx_stats->tid_count[user_stats->tid] += num_msdu; 989 990 if (user_stats->preamble_type < HAL_RX_PREAMBLE_MAX) 991 rx_stats->pream_cnt[user_stats->preamble_type] += num_msdu; 992 993 if (ppdu_info->reception_type < HAL_RX_RECEPTION_TYPE_MAX) 994 rx_stats->reception_type[ppdu_info->reception_type] += num_msdu; 995 996 if (ppdu_info->is_stbc) 997 rx_stats->stbc_count += num_msdu; 998 999 if (ppdu_info->beamformed) 1000 rx_stats->beamformed_count += num_msdu; 1001 1002 if (user_stats->mpdu_cnt_fcs_ok > 1) 1003 rx_stats->ampdu_msdu_count += num_msdu; 1004 else 1005 rx_stats->non_ampdu_msdu_count += num_msdu; 1006 1007 rx_stats->num_mpdu_fcs_ok += user_stats->mpdu_cnt_fcs_ok; 1008 rx_stats->num_mpdu_fcs_err += user_stats->mpdu_cnt_fcs_err; 1009 rx_stats->dcm_count += ppdu_info->dcm; 1010 if (ppdu_info->reception_type == HAL_RX_RECEPTION_TYPE_MU_OFDMA || 1011 ppdu_info->reception_type == HAL_RX_RECEPTION_TYPE_MU_OFDMA_MIMO) 1012 rx_stats->ru_alloc_cnt[user_stats->ul_ofdma_ru_size] += num_msdu; 1013 1014 rx_stats->rx_duration += ppdu_info->rx_duration; 1015 peer->rx_duration = rx_stats->rx_duration; 1016 1017 if (user_stats->nss > 0 && user_stats->nss <= HAL_RX_MAX_NSS) { 1018 rx_stats->pkt_stats.nss_count[user_stats->nss - 1] += num_msdu; 1019 rx_stats->byte_stats.nss_count[user_stats->nss - 1] += 1020 user_stats->mpdu_ok_byte_count; 1021 } 1022 1023 if (user_stats->preamble_type == HAL_RX_PREAMBLE_11AX && 1024 user_stats->mcs <= HAL_RX_MAX_MCS_HE) { 1025 rx_stats->pkt_stats.he_mcs_count[user_stats->mcs] += num_msdu; 1026 rx_stats->byte_stats.he_mcs_count[user_stats->mcs] += 1027 user_stats->mpdu_ok_byte_count; 1028 } 1029 1030 if (ppdu_info->gi < HAL_RX_GI_MAX) { 1031 rx_stats->pkt_stats.gi_count[ppdu_info->gi] += num_msdu; 1032 rx_stats->byte_stats.gi_count[ppdu_info->gi] += 1033 user_stats->mpdu_ok_byte_count; 1034 } 1035 1036 if (ppdu_info->bw < HAL_RX_BW_MAX) { 1037 rx_stats->pkt_stats.bw_count[ppdu_info->bw] += num_msdu; 1038 rx_stats->byte_stats.bw_count[ppdu_info->bw] += 1039 user_stats->mpdu_ok_byte_count; 1040 } 1041 1042 ath12k_dp_mon_rx_update_peer_rate_table_stats(rx_stats, ppdu_info, 1043 user_stats, num_msdu); 1044 } 1045 1046 void 1047 ath12k_dp_mon_rx_update_peer_mu_stats(struct ath12k_base *ab, 1048 struct hal_rx_mon_ppdu_info *ppdu_info) 1049 { 1050 u32 num_users, i; 1051 1052 num_users = ppdu_info->num_users; 1053 if (num_users > HAL_MAX_UL_MU_USERS) 1054 num_users = HAL_MAX_UL_MU_USERS; 1055 1056 for (i = 0; i < num_users; i++) 1057 ath12k_dp_mon_rx_update_user_stats(ab, ppdu_info, i); 1058 } 1059 EXPORT_SYMBOL(ath12k_dp_mon_rx_update_peer_mu_stats); 1060