1 /* 2 * Copyright (c) 2020-2021 The Linux Foundation. All rights reserved. 3 * 4 * Permission to use, copy, modify, and/or distribute this software for 5 * any purpose with or without fee is hereby granted, provided that the 6 * above copyright notice and this permission notice appear in all 7 * copies. 8 * 9 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL 10 * WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED 11 * WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE 12 * AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL 13 * DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR 14 * PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER 15 * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR 16 * PERFORMANCE OF THIS SOFTWARE. 17 */ 18 19 #include <hal_api.h> 20 #include <wlan_cfg.h> 21 #include "dp_types.h" 22 #include "dp_internal.h" 23 #include "dp_htt.h" 24 #include "dp_mon.h" 25 #include "dp_mon_filter.h" 26 27 /** 28 * dp_mon_filter_mode_type_to_str 29 * Monitor Filter mode to string 30 */ 31 static int8_t *dp_mon_filter_mode_type_to_str[DP_MON_FILTER_MAX_MODE] = { 32 #ifdef QCA_ENHANCED_STATS_SUPPORT 33 "DP MON FILTER ENHACHED STATS MODE", 34 #endif /* QCA_ENHANCED_STATS_SUPPORT */ 35 #ifdef QCA_MCOPY_SUPPORT 36 "DP MON FILTER MCOPY MODE", 37 #endif /* QCA_MCOPY_SUPPORT */ 38 #if defined(ATH_SUPPORT_NAC_RSSI) || defined(ATH_SUPPORT_NAC) 39 "DP MON FILTER SMART MONITOR MODE", 40 #endif /* ATH_SUPPORT_NAC_RSSI || ATH_SUPPORT_NAC */ 41 "DP_MON FILTER MONITOR MODE", 42 #ifdef WLAN_RX_PKT_CAPTURE_ENH 43 "DP MON FILTER RX CAPTURE MODE", 44 #endif /* WLAN_RX_PKT_CAPTURE_ENH */ 45 #ifdef WDI_EVENT_ENABLE 46 "DP MON FILTER PKT LOG FULL MODE", 47 "DP MON FILTER PKT LOG LITE_MODE", 48 #endif /* WDI_EVENT_ENABLE */ 49 }; 50 51 /** 52 * dp_mon_filter_show_filter() - Show the set filters 53 * @mon_pdev: Monitor pdev handle 54 * @mode: The filter modes 55 * @tlv_filter: tlv filter 56 */ 57 static void dp_mon_filter_show_filter(struct dp_mon_pdev *mon_pdev, 58 enum dp_mon_filter_mode mode, 59 struct dp_mon_filter *filter) 60 { 61 struct htt_rx_ring_tlv_filter *tlv_filter = &filter->tlv_filter; 62 63 DP_MON_FILTER_PRINT("[%s]: Valid: %d", 64 dp_mon_filter_mode_type_to_str[mode], 65 filter->valid); 66 DP_MON_FILTER_PRINT("mpdu_start: %d", tlv_filter->mpdu_start); 67 DP_MON_FILTER_PRINT("msdu_start: %d", tlv_filter->msdu_start); 68 DP_MON_FILTER_PRINT("packet: %d", tlv_filter->packet); 69 DP_MON_FILTER_PRINT("msdu_end: %d", tlv_filter->msdu_end); 70 DP_MON_FILTER_PRINT("mpdu_end: %d", tlv_filter->mpdu_end); 71 DP_MON_FILTER_PRINT("packet_header: %d", 72 tlv_filter->packet_header); 73 DP_MON_FILTER_PRINT("attention: %d", tlv_filter->attention); 74 DP_MON_FILTER_PRINT("ppdu_start: %d", tlv_filter->ppdu_start); 75 DP_MON_FILTER_PRINT("ppdu_end: %d", tlv_filter->ppdu_end); 76 DP_MON_FILTER_PRINT("ppdu_end_user_stats: %d", 77 tlv_filter->ppdu_end_user_stats); 78 DP_MON_FILTER_PRINT("ppdu_end_user_stats_ext: %d", 79 tlv_filter->ppdu_end_user_stats_ext); 80 DP_MON_FILTER_PRINT("ppdu_end_status_done: %d", 81 tlv_filter->ppdu_end_status_done); 82 DP_MON_FILTER_PRINT("header_per_msdu: %d", tlv_filter->header_per_msdu); 83 DP_MON_FILTER_PRINT("enable_fp: %d", tlv_filter->enable_fp); 84 DP_MON_FILTER_PRINT("enable_md: %d", tlv_filter->enable_md); 85 DP_MON_FILTER_PRINT("enable_mo: %d", tlv_filter->enable_mo); 86 DP_MON_FILTER_PRINT("fp_mgmt_filter: 0x%x", tlv_filter->fp_mgmt_filter); 87 DP_MON_FILTER_PRINT("mo_mgmt_filter: 0x%x", tlv_filter->mo_mgmt_filter); 88 DP_MON_FILTER_PRINT("fp_ctrl_filter: 0x%x", tlv_filter->fp_ctrl_filter); 89 DP_MON_FILTER_PRINT("mo_ctrl_filter: 0x%x", tlv_filter->mo_ctrl_filter); 90 DP_MON_FILTER_PRINT("fp_data_filter: 0x%x", tlv_filter->fp_data_filter); 91 DP_MON_FILTER_PRINT("mo_data_filter: 0x%x", tlv_filter->mo_data_filter); 92 DP_MON_FILTER_PRINT("md_data_filter: 0x%x", tlv_filter->md_data_filter); 93 DP_MON_FILTER_PRINT("md_mgmt_filter: 0x%x", tlv_filter->md_mgmt_filter); 94 DP_MON_FILTER_PRINT("md_ctrl_filter: 0x%x", tlv_filter->md_ctrl_filter); 95 } 96 97 /** 98 * dp_mon_ht2_rx_ring_cfg() - Send the tlv config to fw for a srng_type 99 * based on target 100 * @soc: DP soc handle 101 * @pdev: DP pdev handle 102 * @srng_type: The srng type for which filter wll be set 103 * @tlv_filter: tlv filter 104 */ 105 static QDF_STATUS 106 dp_mon_ht2_rx_ring_cfg(struct dp_soc *soc, 107 struct dp_pdev *pdev, 108 enum dp_mon_filter_srng_type srng_type, 109 struct htt_rx_ring_tlv_filter *tlv_filter) 110 { 111 int mac_id; 112 int max_mac_rings = wlan_cfg_get_num_mac_rings(pdev->wlan_cfg_ctx); 113 QDF_STATUS status = QDF_STATUS_SUCCESS; 114 115 /* 116 * Overwrite the max_mac_rings for the status rings. 117 */ 118 if (srng_type == DP_MON_FILTER_SRNG_TYPE_RXDMA_MONITOR_STATUS) 119 dp_is_hw_dbs_enable(soc, &max_mac_rings); 120 121 dp_mon_filter_info("%pK: srng type %d Max_mac_rings %d ", 122 soc, srng_type, max_mac_rings); 123 124 /* 125 * Loop through all MACs per radio and set the filter to the individual 126 * macs. For MCL 127 */ 128 for (mac_id = 0; mac_id < max_mac_rings; mac_id++) { 129 int mac_for_pdev = 130 dp_get_mac_id_for_pdev(mac_id, pdev->pdev_id); 131 int lmac_id = dp_get_lmac_id_for_pdev_id(soc, mac_id, pdev->pdev_id); 132 int hal_ring_type, ring_buf_size; 133 hal_ring_handle_t hal_ring_hdl; 134 135 switch (srng_type) { 136 case DP_MON_FILTER_SRNG_TYPE_RXDMA_BUF: 137 hal_ring_hdl = pdev->rx_mac_buf_ring[lmac_id].hal_srng; 138 hal_ring_type = RXDMA_BUF; 139 ring_buf_size = RX_DATA_BUFFER_SIZE; 140 break; 141 142 case DP_MON_FILTER_SRNG_TYPE_RXDMA_MONITOR_STATUS: 143 /* 144 * If two back to back HTT msg sending happened in 145 * short time, the second HTT msg source SRNG HP 146 * writing has chance to fail, this has been confirmed 147 * by HST HW. 148 * for monitor mode, here is the last HTT msg for sending. 149 * if the 2nd HTT msg for monitor status ring sending failed, 150 * HW won't provide anything into 2nd monitor status ring. 151 * as a WAR, add some delay before 2nd HTT msg start sending, 152 * > 2us is required per HST HW, delay 100 us for safe. 153 */ 154 if (mac_id) 155 qdf_udelay(100); 156 157 hal_ring_hdl = 158 soc->rxdma_mon_status_ring[lmac_id].hal_srng; 159 hal_ring_type = RXDMA_MONITOR_STATUS; 160 ring_buf_size = RX_MON_STATUS_BUF_SIZE; 161 break; 162 163 case DP_MON_FILTER_SRNG_TYPE_RXDMA_MON_BUF: 164 hal_ring_hdl = 165 soc->rxdma_mon_buf_ring[lmac_id].hal_srng; 166 hal_ring_type = RXDMA_MONITOR_BUF; 167 ring_buf_size = RX_DATA_BUFFER_SIZE; 168 break; 169 170 default: 171 return QDF_STATUS_E_FAILURE; 172 } 173 174 status = htt_h2t_rx_ring_cfg(soc->htt_handle, mac_for_pdev, 175 hal_ring_hdl, hal_ring_type, 176 ring_buf_size, 177 tlv_filter); 178 if (status != QDF_STATUS_SUCCESS) 179 return status; 180 } 181 182 return status; 183 } 184 185 /** 186 * dp_mon_filter_ht2_setup() - Setup the filter for the Target setup 187 * @soc: DP soc handle 188 * @pdev: DP pdev handle 189 * @srng_type: The srng type for which filter wll be set 190 * @tlv_filter: tlv filter 191 */ 192 static void dp_mon_filter_ht2_setup(struct dp_soc *soc, struct dp_pdev *pdev, 193 enum dp_mon_filter_srng_type srng_type, 194 struct dp_mon_filter *filter) 195 { 196 int32_t current_mode = 0; 197 struct htt_rx_ring_tlv_filter *tlv_filter = &filter->tlv_filter; 198 struct dp_mon_pdev *mon_pdev = pdev->monitor_pdev; 199 200 /* 201 * Loop through all the modes. 202 */ 203 for (current_mode = 0; current_mode < DP_MON_FILTER_MAX_MODE; 204 current_mode++) { 205 struct dp_mon_filter *mon_filter = 206 &mon_pdev->filter[current_mode][srng_type]; 207 uint32_t src_filter = 0, dst_filter = 0; 208 209 /* 210 * Check if the correct mode is enabled or not. 211 */ 212 if (!mon_filter->valid) 213 continue; 214 215 filter->valid = true; 216 217 /* 218 * Set the super bit fields 219 */ 220 src_filter = 221 DP_MON_FILTER_GET(&mon_filter->tlv_filter, FILTER_TLV); 222 dst_filter = DP_MON_FILTER_GET(tlv_filter, FILTER_TLV); 223 dst_filter |= src_filter; 224 DP_MON_FILTER_SET(tlv_filter, FILTER_TLV, dst_filter); 225 226 /* 227 * Set the filter management filter. 228 */ 229 src_filter = DP_MON_FILTER_GET(&mon_filter->tlv_filter, 230 FILTER_FP_MGMT); 231 dst_filter = DP_MON_FILTER_GET(tlv_filter, FILTER_FP_MGMT); 232 dst_filter |= src_filter; 233 DP_MON_FILTER_SET(tlv_filter, FILTER_FP_MGMT, dst_filter); 234 235 /* 236 * Set the monitor other management filter. 237 */ 238 src_filter = DP_MON_FILTER_GET(&mon_filter->tlv_filter, 239 FILTER_MO_MGMT); 240 dst_filter = DP_MON_FILTER_GET(tlv_filter, FILTER_MO_MGMT); 241 dst_filter |= src_filter; 242 DP_MON_FILTER_SET(tlv_filter, FILTER_MO_MGMT, dst_filter); 243 244 /* 245 * Set the filter pass control filter. 246 */ 247 src_filter = DP_MON_FILTER_GET(&mon_filter->tlv_filter, 248 FILTER_FP_CTRL); 249 dst_filter = DP_MON_FILTER_GET(tlv_filter, FILTER_FP_CTRL); 250 dst_filter |= src_filter; 251 DP_MON_FILTER_SET(tlv_filter, FILTER_FP_CTRL, dst_filter); 252 253 /* 254 * Set the monitor other control filter. 255 */ 256 src_filter = DP_MON_FILTER_GET(&mon_filter->tlv_filter, 257 FILTER_MO_CTRL); 258 dst_filter = DP_MON_FILTER_GET(tlv_filter, FILTER_MO_CTRL); 259 dst_filter |= src_filter; 260 DP_MON_FILTER_SET(tlv_filter, FILTER_MO_CTRL, dst_filter); 261 262 /* 263 * Set the filter pass data filter. 264 */ 265 src_filter = DP_MON_FILTER_GET(&mon_filter->tlv_filter, 266 FILTER_FP_DATA); 267 dst_filter = DP_MON_FILTER_GET(tlv_filter, 268 FILTER_FP_DATA); 269 dst_filter |= src_filter; 270 DP_MON_FILTER_SET(tlv_filter, 271 FILTER_FP_DATA, dst_filter); 272 273 /* 274 * Set the monitor other data filter. 275 */ 276 src_filter = DP_MON_FILTER_GET(&mon_filter->tlv_filter, 277 FILTER_MO_DATA); 278 dst_filter = DP_MON_FILTER_GET(tlv_filter, FILTER_MO_DATA); 279 dst_filter |= src_filter; 280 DP_MON_FILTER_SET(tlv_filter, FILTER_MO_DATA, dst_filter); 281 282 /* 283 * Set the monitor direct data filter. 284 */ 285 src_filter = DP_MON_FILTER_GET(&mon_filter->tlv_filter, 286 FILTER_MD_DATA); 287 dst_filter = DP_MON_FILTER_GET(tlv_filter, 288 FILTER_MD_DATA); 289 dst_filter |= src_filter; 290 DP_MON_FILTER_SET(tlv_filter, 291 FILTER_MD_DATA, dst_filter); 292 293 /* 294 * Set the monitor direct management filter. 295 */ 296 src_filter = DP_MON_FILTER_GET(&mon_filter->tlv_filter, 297 FILTER_MD_MGMT); 298 dst_filter = DP_MON_FILTER_GET(tlv_filter, FILTER_MD_MGMT); 299 dst_filter |= src_filter; 300 DP_MON_FILTER_SET(tlv_filter, FILTER_MD_MGMT, dst_filter); 301 302 /* 303 * Set the monitor direct management filter. 304 */ 305 src_filter = DP_MON_FILTER_GET(&mon_filter->tlv_filter, 306 FILTER_MD_CTRL); 307 dst_filter = DP_MON_FILTER_GET(tlv_filter, FILTER_MD_CTRL); 308 dst_filter |= src_filter; 309 DP_MON_FILTER_SET(tlv_filter, FILTER_MD_CTRL, dst_filter); 310 } 311 312 dp_mon_filter_show_filter(mon_pdev, 0, filter); 313 } 314 315 #ifdef QCA_MONITOR_PKT_SUPPORT 316 /** 317 * dp_mon_filter_reset_mon_srng() 318 * @soc: DP SoC handle 319 * @pdev: DP pdev handle 320 * @mon_srng_type: Monitor srng type 321 */ 322 static void 323 dp_mon_filter_reset_mon_srng(struct dp_soc *soc, struct dp_pdev *pdev, 324 enum dp_mon_filter_srng_type mon_srng_type) 325 { 326 struct htt_rx_ring_tlv_filter tlv_filter = {0}; 327 328 if (dp_mon_ht2_rx_ring_cfg(soc, pdev, mon_srng_type, 329 &tlv_filter) != QDF_STATUS_SUCCESS) { 330 dp_mon_filter_err("%pK: Monitor destinatin ring filter setting failed", 331 soc); 332 } 333 } 334 #endif 335 336 #if defined(QCA_MCOPY_SUPPORT) || defined(ATH_SUPPORT_NAC_RSSI) \ 337 || defined(ATH_SUPPORT_NAC) || defined(WLAN_RX_PKT_CAPTURE_ENH) 338 /** 339 * dp_mon_filter_check_co_exist() - Check the co-existing of the 340 * enabled modes. 341 * @pdev: DP pdev handle 342 * 343 * Return: QDF_STATUS 344 */ 345 static QDF_STATUS dp_mon_filter_check_co_exist(struct dp_pdev *pdev) 346 { 347 struct dp_mon_pdev *mon_pdev = pdev->monitor_pdev; 348 349 /* 350 * Check if the Rx Enhanced capture mode, monitor mode, 351 * smart_monitor_mode and mcopy mode can co-exist together. 352 */ 353 if ((mon_pdev->rx_enh_capture_mode != CDP_RX_ENH_CAPTURE_DISABLED) && 354 ((mon_pdev->neighbour_peers_added && mon_pdev->mvdev) || 355 mon_pdev->mcopy_mode)) { 356 dp_mon_filter_err("%pK:Rx Capture mode can't exist with modes:\n" 357 "Smart Monitor Mode:%d\n" 358 "M_Copy Mode:%d", pdev->soc, 359 mon_pdev->neighbour_peers_added, 360 mon_pdev->mcopy_mode); 361 return QDF_STATUS_E_FAILURE; 362 } 363 364 /* 365 * Check if the monitor mode cannot co-exist with any other mode. 366 */ 367 if ((mon_pdev->mvdev && mon_pdev->monitor_configured) && 368 (mon_pdev->mcopy_mode || mon_pdev->neighbour_peers_added)) { 369 dp_mon_filter_err("%pK: Monitor mode can't exist with modes\n" 370 "M_Copy Mode:%d\n" 371 "Smart Monitor Mode:%d", 372 pdev->soc, mon_pdev->mcopy_mode, 373 mon_pdev->neighbour_peers_added); 374 return QDF_STATUS_E_FAILURE; 375 } 376 377 /* 378 * Check if the smart monitor mode can co-exist with any other mode 379 */ 380 if (mon_pdev->neighbour_peers_added && 381 ((mon_pdev->mcopy_mode) || mon_pdev->monitor_configured)) { 382 dp_mon_filter_err("%pk: Smart Monitor mode can't exist with modes\n" 383 "M_Copy Mode:%d\n" 384 "Monitor Mode:%d", 385 pdev->soc, mon_pdev->mcopy_mode, 386 mon_pdev->monitor_configured); 387 return QDF_STATUS_E_FAILURE; 388 } 389 390 /* 391 * Check if the m_copy, monitor mode and the smart_monitor_mode 392 * can co-exist togther. 393 */ 394 if (mon_pdev->mcopy_mode && 395 (mon_pdev->mvdev || mon_pdev->neighbour_peers_added)) { 396 dp_mon_filter_err("%pK: mcopy mode can't exist with modes\n" 397 "Monitor Mode:%pK\n" 398 "Smart Monitor Mode:%d", 399 pdev->soc, mon_pdev->mvdev, 400 mon_pdev->neighbour_peers_added); 401 return QDF_STATUS_E_FAILURE; 402 } 403 404 /* 405 * Check if the Rx packet log lite or full can co-exist with 406 * the enable modes. 407 */ 408 if ((mon_pdev->rx_pktlog_mode != DP_RX_PKTLOG_DISABLED) && 409 !mon_pdev->rx_pktlog_cbf && 410 (mon_pdev->mvdev || mon_pdev->monitor_configured)) { 411 dp_mon_filter_err("%pK: Rx pktlog full/lite can't exist with modes\n" 412 "Monitor Mode:%d", pdev->soc, 413 mon_pdev->monitor_configured); 414 return QDF_STATUS_E_FAILURE; 415 } 416 return QDF_STATUS_SUCCESS; 417 } 418 #else 419 static QDF_STATUS dp_mon_filter_check_co_exist(struct dp_pdev *pdev) 420 { 421 struct dp_mon_pdev *mon_pdev = pdev->monitor_pdev; 422 423 /* 424 * Check if the Rx packet log lite or full can co-exist with 425 * the enable modes. 426 */ 427 if ((mon_pdev->rx_pktlog_mode != DP_RX_PKTLOG_DISABLED) && 428 (mon_pdev->mvdev || mon_pdev->monitor_configured)) { 429 dp_mon_filter_err("%pK: Rx pktlog full/lite can't exist with modes\n" 430 "Monitor Mode:%d", pdev->soc, 431 mon_pdev->monitor_configured); 432 return QDF_STATUS_E_FAILURE; 433 } 434 435 return QDF_STATUS_SUCCESS; 436 } 437 #endif 438 439 #ifdef QCA_MONITOR_PKT_SUPPORT 440 /** 441 * dp_mon_filter_set_mon_cmn() - Setp the common mon filters 442 * @mon_pdev: Monitor pdev handle 443 * @filter: DP mon filter 444 * 445 * Return: QDF_STATUS 446 */ 447 static void dp_mon_filter_set_mon_cmn(struct dp_mon_pdev *mon_pdev, 448 struct dp_mon_filter *filter) 449 { 450 filter->tlv_filter.mpdu_start = 1; 451 filter->tlv_filter.msdu_start = 1; 452 filter->tlv_filter.packet = 1; 453 filter->tlv_filter.msdu_end = 1; 454 filter->tlv_filter.mpdu_end = 1; 455 filter->tlv_filter.packet_header = 1; 456 filter->tlv_filter.attention = 1; 457 filter->tlv_filter.ppdu_start = 0; 458 filter->tlv_filter.ppdu_end = 0; 459 filter->tlv_filter.ppdu_end_user_stats = 0; 460 filter->tlv_filter.ppdu_end_user_stats_ext = 0; 461 filter->tlv_filter.ppdu_end_status_done = 0; 462 filter->tlv_filter.header_per_msdu = 1; 463 filter->tlv_filter.enable_fp = 464 (mon_pdev->mon_filter_mode & MON_FILTER_PASS) ? 1 : 0; 465 filter->tlv_filter.enable_mo = 466 (mon_pdev->mon_filter_mode & MON_FILTER_OTHER) ? 1 : 0; 467 468 filter->tlv_filter.fp_mgmt_filter = mon_pdev->fp_mgmt_filter; 469 filter->tlv_filter.fp_ctrl_filter = mon_pdev->fp_ctrl_filter; 470 filter->tlv_filter.fp_data_filter = mon_pdev->fp_data_filter; 471 filter->tlv_filter.mo_mgmt_filter = mon_pdev->mo_mgmt_filter; 472 filter->tlv_filter.mo_ctrl_filter = mon_pdev->mo_ctrl_filter; 473 filter->tlv_filter.mo_data_filter = mon_pdev->mo_data_filter; 474 filter->tlv_filter.offset_valid = false; 475 } 476 #endif 477 478 /** 479 * dp_mon_filter_set_status_cmn() - Setp the common status filters 480 * @mon_pdev: Monitor pdev handle 481 * @filter: Dp mon filters 482 * 483 * Return: QDF_STATUS 484 */ 485 static void dp_mon_filter_set_status_cmn(struct dp_mon_pdev *mon_pdev, 486 struct dp_mon_filter *filter) 487 { 488 filter->tlv_filter.mpdu_start = 1; 489 filter->tlv_filter.msdu_start = 0; 490 filter->tlv_filter.packet = 0; 491 filter->tlv_filter.msdu_end = 0; 492 filter->tlv_filter.mpdu_end = 0; 493 filter->tlv_filter.attention = 0; 494 filter->tlv_filter.ppdu_start = 1; 495 filter->tlv_filter.ppdu_end = 1; 496 filter->tlv_filter.ppdu_end_user_stats = 1; 497 filter->tlv_filter.ppdu_end_user_stats_ext = 1; 498 filter->tlv_filter.ppdu_end_status_done = 1; 499 filter->tlv_filter.enable_fp = 1; 500 filter->tlv_filter.enable_md = 0; 501 filter->tlv_filter.fp_mgmt_filter = FILTER_MGMT_ALL; 502 filter->tlv_filter.fp_ctrl_filter = FILTER_CTRL_ALL; 503 filter->tlv_filter.fp_data_filter = FILTER_DATA_ALL; 504 filter->tlv_filter.offset_valid = false; 505 506 if (mon_pdev->mon_filter_mode & MON_FILTER_OTHER) { 507 filter->tlv_filter.enable_mo = 1; 508 filter->tlv_filter.mo_mgmt_filter = FILTER_MGMT_ALL; 509 filter->tlv_filter.mo_ctrl_filter = FILTER_CTRL_ALL; 510 filter->tlv_filter.mo_data_filter = FILTER_DATA_ALL; 511 } else { 512 filter->tlv_filter.enable_mo = 0; 513 } 514 } 515 516 /** 517 * dp_mon_filter_set_status_cbf() - Set the cbf status filters 518 * @pdev: DP pdev handle 519 * @filter: Dp mon filters 520 * 521 * Return: void 522 */ 523 static void dp_mon_filter_set_status_cbf(struct dp_pdev *pdev, 524 struct dp_mon_filter *filter) 525 { 526 filter->tlv_filter.mpdu_start = 1; 527 filter->tlv_filter.msdu_start = 0; 528 filter->tlv_filter.packet = 0; 529 filter->tlv_filter.msdu_end = 0; 530 filter->tlv_filter.mpdu_end = 0; 531 filter->tlv_filter.attention = 0; 532 filter->tlv_filter.ppdu_start = 1; 533 filter->tlv_filter.ppdu_end = 1; 534 filter->tlv_filter.ppdu_end_user_stats = 1; 535 filter->tlv_filter.ppdu_end_user_stats_ext = 1; 536 filter->tlv_filter.ppdu_end_status_done = 1; 537 filter->tlv_filter.enable_fp = 1; 538 filter->tlv_filter.enable_md = 0; 539 filter->tlv_filter.fp_mgmt_filter = FILTER_MGMT_ACT_NO_ACK; 540 filter->tlv_filter.fp_ctrl_filter = 0; 541 filter->tlv_filter.fp_data_filter = 0; 542 filter->tlv_filter.offset_valid = false; 543 filter->tlv_filter.enable_mo = 0; 544 } 545 546 #ifdef QCA_MONITOR_PKT_SUPPORT 547 /** 548 * dp_mon_filter_set_cbf_cmn() - Set the common cbf mode filters 549 * @pdev: DP pdev handle 550 * @filter: Dp mon filters 551 * 552 * Return: void 553 */ 554 static void dp_mon_filter_set_cbf_cmn(struct dp_pdev *pdev, 555 struct dp_mon_filter *filter) 556 { 557 filter->tlv_filter.mpdu_start = 1; 558 filter->tlv_filter.msdu_start = 1; 559 filter->tlv_filter.packet = 1; 560 filter->tlv_filter.msdu_end = 1; 561 filter->tlv_filter.mpdu_end = 1; 562 filter->tlv_filter.attention = 1; 563 filter->tlv_filter.ppdu_start = 0; 564 filter->tlv_filter.ppdu_end = 0; 565 filter->tlv_filter.ppdu_end_user_stats = 0; 566 filter->tlv_filter.ppdu_end_user_stats_ext = 0; 567 filter->tlv_filter.ppdu_end_status_done = 0; 568 filter->tlv_filter.enable_fp = 1; 569 filter->tlv_filter.enable_md = 0; 570 filter->tlv_filter.fp_mgmt_filter = FILTER_MGMT_ACT_NO_ACK; 571 filter->tlv_filter.offset_valid = false; 572 filter->tlv_filter.enable_mo = 0; 573 } 574 #endif 575 576 #ifdef QCA_ENHANCED_STATS_SUPPORT 577 /** 578 * dp_mon_filter_setup_enhanced_stats() - Setup the enhanced stats filter 579 * @mon_pdev: Monitor pdev handle 580 */ 581 void dp_mon_filter_setup_enhanced_stats(struct dp_mon_pdev *mon_pdev) 582 { 583 struct dp_mon_filter filter = {0}; 584 enum dp_mon_filter_mode mode = DP_MON_FILTER_ENHACHED_STATS_MODE; 585 enum dp_mon_filter_srng_type srng_type = 586 DP_MON_FILTER_SRNG_TYPE_RXDMA_MONITOR_STATUS; 587 588 if (!mon_pdev) { 589 dp_mon_filter_err("Monitor pdev Context is null"); 590 return; 591 } 592 593 /* Enabled the filter */ 594 filter.valid = true; 595 596 dp_mon_filter_set_status_cmn(mon_pdev, &filter); 597 dp_mon_filter_show_filter(mon_pdev, mode, &filter); 598 mon_pdev->filter[mode][srng_type] = filter; 599 } 600 601 /** 602 * dp_mon_filter_reset_enhanced_stats() - Reset the enhanced stats filter 603 * @mon_pdev: Monitor pdev handle 604 */ 605 void dp_mon_filter_reset_enhanced_stats(struct dp_mon_pdev *mon_pdev) 606 { 607 struct dp_mon_filter filter = {0}; 608 enum dp_mon_filter_mode mode = DP_MON_FILTER_ENHACHED_STATS_MODE; 609 enum dp_mon_filter_srng_type srng_type = 610 DP_MON_FILTER_SRNG_TYPE_RXDMA_MONITOR_STATUS; 611 612 if (!mon_pdev) { 613 dp_mon_filter_err("pdev Context is null"); 614 return; 615 } 616 617 mon_pdev->filter[mode][srng_type] = filter; 618 } 619 #endif /* QCA_ENHANCED_STATS_SUPPORT */ 620 621 #ifdef QCA_MCOPY_SUPPORT 622 #ifdef QCA_MONITOR_PKT_SUPPORT 623 static void 624 dp_mon_filter_set_reset_mcopy_mon_buf(struct dp_pdev *pdev, 625 struct dp_mon_filter *pfilter) 626 { 627 struct dp_soc *soc = pdev->soc; 628 struct dp_mon_pdev *mon_pdev = pdev->monitor_pdev; 629 enum dp_mon_filter_mode mode = DP_MON_FILTER_MCOPY_MODE; 630 enum dp_mon_filter_srng_type srng_type; 631 632 srng_type = ((soc->wlan_cfg_ctx->rxdma1_enable) ? 633 DP_MON_FILTER_SRNG_TYPE_RXDMA_MON_BUF : 634 DP_MON_FILTER_SRNG_TYPE_RXDMA_BUF); 635 636 /* Set the filter */ 637 if (pfilter->valid) { 638 dp_mon_filter_set_mon_cmn(mon_pdev, pfilter); 639 640 pfilter->tlv_filter.fp_data_filter = 0; 641 pfilter->tlv_filter.mo_data_filter = 0; 642 643 dp_mon_filter_show_filter(mon_pdev, mode, pfilter); 644 mon_pdev->filter[mode][srng_type] = *pfilter; 645 } else /* Reset the filter */ 646 mon_pdev->filter[mode][srng_type] = *pfilter; 647 } 648 #else 649 static void 650 dp_mon_filter_set_reset_mcopy_mon_buf(struct dp_pdev *pdev, 651 struct dp_mon_filter *pfilter) 652 { 653 } 654 #endif 655 656 /** 657 * dp_mon_filter_setup_mcopy_mode() - Setup the m_copy mode filter 658 * @pdev: DP pdev handle 659 */ 660 void dp_mon_filter_setup_mcopy_mode(struct dp_pdev *pdev) 661 { 662 struct dp_mon_filter filter = {0}; 663 struct dp_soc *soc = NULL; 664 enum dp_mon_filter_mode mode = DP_MON_FILTER_MCOPY_MODE; 665 enum dp_mon_filter_srng_type srng_type = 666 DP_MON_FILTER_SRNG_TYPE_RXDMA_MONITOR_STATUS; 667 struct dp_mon_pdev *mon_pdev; 668 669 if (!pdev) { 670 dp_mon_filter_err("pdev Context is null"); 671 return; 672 } 673 674 soc = pdev->soc; 675 if (!soc) { 676 dp_mon_filter_err("Soc Context is null"); 677 return; 678 } 679 680 mon_pdev = pdev->monitor_pdev; 681 if (!mon_pdev) { 682 dp_mon_filter_err("monitor pdev Context is null"); 683 return; 684 } 685 /* Enabled the filter */ 686 filter.valid = true; 687 dp_mon_filter_set_reset_mcopy_mon_buf(pdev, &filter); 688 689 /* Clear the filter as the same filter will be used to set the 690 * monitor status ring 691 */ 692 qdf_mem_zero(&(filter), sizeof(struct dp_mon_filter)); 693 694 /* Enabled the filter */ 695 filter.valid = true; 696 dp_mon_filter_set_status_cmn(mon_pdev, &filter); 697 698 /* Setup the filter */ 699 filter.tlv_filter.enable_mo = 1; 700 filter.tlv_filter.packet_header = 1; 701 filter.tlv_filter.mpdu_end = 1; 702 dp_mon_filter_show_filter(mon_pdev, mode, &filter); 703 704 srng_type = DP_MON_FILTER_SRNG_TYPE_RXDMA_MONITOR_STATUS; 705 mon_pdev->filter[mode][srng_type] = filter; 706 } 707 708 /** 709 * dp_mon_filter_reset_mcopy_mode() - Reset the m_copy mode filter 710 * @pdev: DP pdev handle 711 */ 712 void dp_mon_filter_reset_mcopy_mode(struct dp_pdev *pdev) 713 { 714 struct dp_mon_filter filter = {0}; 715 struct dp_soc *soc = NULL; 716 enum dp_mon_filter_mode mode = DP_MON_FILTER_MCOPY_MODE; 717 enum dp_mon_filter_srng_type srng_type = 718 DP_MON_FILTER_SRNG_TYPE_RXDMA_MONITOR_STATUS; 719 struct dp_mon_pdev *mon_pdev; 720 721 if (!pdev) { 722 dp_mon_filter_err("pdev Context is null"); 723 return; 724 } 725 726 soc = pdev->soc; 727 if (!soc) { 728 dp_mon_filter_err("Soc Context is null"); 729 return; 730 } 731 732 mon_pdev = pdev->monitor_pdev; 733 dp_mon_filter_set_reset_mcopy_mon_buf(pdev, &filter); 734 735 srng_type = DP_MON_FILTER_SRNG_TYPE_RXDMA_MONITOR_STATUS; 736 mon_pdev->filter[mode][srng_type] = filter; 737 } 738 #endif /* QCA_MCOPY_SUPPORT */ 739 740 #if defined(ATH_SUPPORT_NAC_RSSI) || defined(ATH_SUPPORT_NAC) 741 /** 742 * dp_mon_filter_setup_smart_monitor() - Setup the smart monitor mode filter 743 * @pdev: DP pdev handle 744 */ 745 void dp_mon_filter_setup_smart_monitor(struct dp_pdev *pdev) 746 { 747 struct dp_mon_filter filter = {0}; 748 struct dp_soc *soc = NULL; 749 struct dp_mon_soc *mon_soc; 750 751 enum dp_mon_filter_mode mode = DP_MON_FILTER_SMART_MONITOR_MODE; 752 enum dp_mon_filter_srng_type srng_type = 753 DP_MON_FILTER_SRNG_TYPE_RXDMA_MONITOR_STATUS; 754 struct dp_mon_pdev *mon_pdev; 755 756 if (!pdev) { 757 dp_mon_filter_err("pdev Context is null"); 758 return; 759 } 760 761 soc = pdev->soc; 762 if (!soc) { 763 dp_mon_filter_err("Soc Context is null"); 764 return; 765 } 766 767 mon_soc = soc->monitor_soc; 768 mon_pdev = pdev->monitor_pdev; 769 770 /* Enabled the filter */ 771 filter.valid = true; 772 dp_mon_filter_set_status_cmn(mon_pdev, &filter); 773 774 if (mon_soc->hw_nac_monitor_support) { 775 filter.tlv_filter.enable_md = 1; 776 filter.tlv_filter.packet_header = 1; 777 filter.tlv_filter.md_data_filter = FILTER_DATA_ALL; 778 } 779 780 dp_mon_filter_show_filter(mon_pdev, mode, &filter); 781 mon_pdev->filter[mode][srng_type] = filter; 782 } 783 784 /** 785 * dp_mon_filter_reset_smart_monitor() - Reset the smart monitor mode filter 786 * @pdev: DP pdev handle 787 */ 788 void dp_mon_filter_reset_smart_monitor(struct dp_pdev *pdev) 789 { 790 struct dp_mon_filter filter = {0}; 791 enum dp_mon_filter_mode mode = DP_MON_FILTER_SMART_MONITOR_MODE; 792 enum dp_mon_filter_srng_type srng_type = 793 DP_MON_FILTER_SRNG_TYPE_RXDMA_MONITOR_STATUS; 794 struct dp_mon_pdev *mon_pdev; 795 796 if (!pdev) { 797 dp_mon_filter_err("monitor pdev Context is null"); 798 return; 799 } 800 mon_pdev = pdev->monitor_pdev; 801 mon_pdev->filter[mode][srng_type] = filter; 802 } 803 #endif /* ATH_SUPPORT_NAC_RSSI || ATH_SUPPORT_NAC */ 804 805 #ifdef WLAN_RX_PKT_CAPTURE_ENH 806 #ifdef QCA_MONITOR_PKT_SUPPORT 807 static void 808 dp_mon_filter_set_reset_rx_enh_capture_mon_buf(struct dp_pdev *pdev, 809 struct dp_mon_filter *pfilter) 810 { 811 struct dp_soc *soc = pdev->soc; 812 struct dp_mon_pdev *mon_pdev = pdev->monitor_pdev; 813 enum dp_mon_filter_mode mode = DP_MON_FILTER_RX_CAPTURE_MODE; 814 enum dp_mon_filter_srng_type srng_type; 815 816 srng_type = ((soc->wlan_cfg_ctx->rxdma1_enable) ? 817 DP_MON_FILTER_SRNG_TYPE_RXDMA_MON_BUF : 818 DP_MON_FILTER_SRNG_TYPE_RXDMA_BUF); 819 820 /* Set the filter */ 821 if (pfilter->valid) { 822 dp_mon_filter_set_mon_cmn(mon_pdev, pfilter); 823 824 pfilter->tlv_filter.fp_mgmt_filter = 0; 825 pfilter->tlv_filter.fp_ctrl_filter = 0; 826 pfilter->tlv_filter.fp_data_filter = 0; 827 pfilter->tlv_filter.mo_mgmt_filter = 0; 828 pfilter->tlv_filter.mo_ctrl_filter = 0; 829 pfilter->tlv_filter.mo_data_filter = 0; 830 831 dp_mon_filter_show_filter(mon_pdev, mode, pfilter); 832 pdev->monitor_pdev->filter[mode][srng_type] = *pfilter; 833 } else /* Reset the filter */ 834 pdev->monitor_pdev->filter[mode][srng_type] = *pfilter; 835 } 836 #else 837 static void 838 dp_mon_filter_set_reset_rx_enh_capture_mon_buf(struct dp_pdev *pdev, 839 struct dp_mon_filter *pfilter) 840 { 841 } 842 #endif 843 844 /** 845 * dp_mon_filter_setup_rx_enh_capture() - Setup the Rx capture mode filters 846 * @pdev: DP pdev handle 847 */ 848 void dp_mon_filter_setup_rx_enh_capture(struct dp_pdev *pdev) 849 { 850 struct dp_mon_filter filter = {0}; 851 struct dp_soc *soc = NULL; 852 enum dp_mon_filter_mode mode = DP_MON_FILTER_RX_CAPTURE_MODE; 853 enum dp_mon_filter_srng_type srng_type = 854 DP_MON_FILTER_SRNG_TYPE_RXDMA_MONITOR_STATUS; 855 struct dp_mon_pdev *mon_pdev; 856 857 if (!pdev) { 858 dp_mon_filter_err("pdev Context is null"); 859 return; 860 } 861 862 soc = pdev->soc; 863 if (!soc) { 864 dp_mon_filter_err("Soc Context is null"); 865 return; 866 } 867 868 mon_pdev = pdev->monitor_pdev; 869 870 /* Enabled the filter */ 871 filter.valid = true; 872 dp_mon_filter_set_reset_rx_enh_capture_mon_buf(pdev, &filter); 873 874 /* Clear the filter as the same filter will be used to set the 875 * monitor status ring 876 */ 877 qdf_mem_zero(&(filter), sizeof(struct dp_mon_filter)); 878 879 /* Enabled the filter */ 880 filter.valid = true; 881 dp_mon_filter_set_status_cmn(mon_pdev, &filter); 882 883 /* Setup the filter */ 884 filter.tlv_filter.mpdu_end = 1; 885 filter.tlv_filter.enable_mo = 1; 886 filter.tlv_filter.packet_header = 1; 887 888 if (mon_pdev->rx_enh_capture_mode == CDP_RX_ENH_CAPTURE_MPDU) { 889 filter.tlv_filter.header_per_msdu = 0; 890 filter.tlv_filter.enable_mo = 0; 891 } else if (mon_pdev->rx_enh_capture_mode == 892 CDP_RX_ENH_CAPTURE_MPDU_MSDU) { 893 bool is_rx_mon_proto_flow_tag_enabled = 894 wlan_cfg_is_rx_mon_protocol_flow_tag_enabled(soc->wlan_cfg_ctx); 895 filter.tlv_filter.header_per_msdu = 1; 896 filter.tlv_filter.enable_mo = 0; 897 if (mon_pdev->is_rx_enh_capture_trailer_enabled || 898 is_rx_mon_proto_flow_tag_enabled) 899 filter.tlv_filter.msdu_end = 1; 900 } 901 902 dp_mon_filter_show_filter(mon_pdev, mode, &filter); 903 904 srng_type = DP_MON_FILTER_SRNG_TYPE_RXDMA_MONITOR_STATUS; 905 mon_pdev->filter[mode][srng_type] = filter; 906 } 907 908 /** 909 * dp_mon_filter_reset_rx_enh_capture() - Reset the Rx capture mode filters 910 * @pdev: DP pdev handle 911 */ 912 void dp_mon_filter_reset_rx_enh_capture(struct dp_pdev *pdev) 913 { 914 struct dp_mon_filter filter = {0}; 915 struct dp_soc *soc = NULL; 916 enum dp_mon_filter_mode mode = DP_MON_FILTER_RX_CAPTURE_MODE; 917 enum dp_mon_filter_srng_type srng_type = 918 DP_MON_FILTER_SRNG_TYPE_RXDMA_MONITOR_STATUS; 919 struct dp_mon_pdev *mon_pdev; 920 921 if (!pdev) { 922 dp_mon_filter_err("pdev Context is null"); 923 return; 924 } 925 926 soc = pdev->soc; 927 if (!soc) { 928 dp_mon_filter_err("Soc Context is null"); 929 return; 930 } 931 932 mon_pdev = pdev->monitor_pdev; 933 dp_mon_filter_set_reset_rx_enh_capture_mon_buf(pdev, &filter); 934 935 srng_type = DP_MON_FILTER_SRNG_TYPE_RXDMA_MONITOR_STATUS; 936 mon_pdev->filter[mode][srng_type] = filter; 937 } 938 #endif /* WLAN_RX_PKT_CAPTURE_ENH */ 939 940 #ifdef QCA_MONITOR_PKT_SUPPORT 941 static void dp_mon_filter_set_reset_mon_buf(struct dp_pdev *pdev, 942 struct dp_mon_filter *pfilter) 943 { 944 struct dp_soc *soc = pdev->soc; 945 struct dp_mon_pdev *mon_pdev = pdev->monitor_pdev; 946 enum dp_mon_filter_mode mode = DP_MON_FILTER_MONITOR_MODE; 947 enum dp_mon_filter_srng_type srng_type; 948 949 srng_type = ((soc->wlan_cfg_ctx->rxdma1_enable) ? 950 DP_MON_FILTER_SRNG_TYPE_RXDMA_MON_BUF : 951 DP_MON_FILTER_SRNG_TYPE_RXDMA_BUF); 952 953 /* set the filter */ 954 if (pfilter->valid) { 955 dp_mon_filter_set_mon_cmn(mon_pdev, pfilter); 956 957 dp_mon_filter_show_filter(mon_pdev, mode, pfilter); 958 mon_pdev->filter[mode][srng_type] = *pfilter; 959 } else /* reset the filter */ 960 mon_pdev->filter[mode][srng_type] = *pfilter; 961 } 962 #else 963 static void dp_mon_filter_set_reset_mon_buf(struct dp_pdev *pdev, 964 struct dp_mon_filter *pfilter) 965 { 966 } 967 #endif 968 969 /** 970 * dp_mon_filter_setup_mon_mode() - Setup the Rx monitor mode filter 971 * @pdev: DP pdev handle 972 */ 973 void dp_mon_filter_setup_mon_mode(struct dp_pdev *pdev) 974 { 975 struct dp_mon_filter filter = {0}; 976 struct dp_soc *soc = NULL; 977 enum dp_mon_filter_mode mode = DP_MON_FILTER_MONITOR_MODE; 978 enum dp_mon_filter_srng_type srng_type = 979 DP_MON_FILTER_SRNG_TYPE_RXDMA_MONITOR_STATUS; 980 struct dp_mon_pdev *mon_pdev; 981 982 if (!pdev) { 983 dp_mon_filter_err("pdev Context is null"); 984 return; 985 } 986 987 soc = pdev->soc; 988 if (!soc) { 989 dp_mon_filter_err("Soc Context is null"); 990 return; 991 } 992 993 mon_pdev = pdev->monitor_pdev; 994 filter.valid = true; 995 dp_mon_filter_set_reset_mon_buf(pdev, &filter); 996 997 /* Clear the filter as the same filter will be used to set the 998 * monitor status ring 999 */ 1000 qdf_mem_zero(&(filter), sizeof(struct dp_mon_filter)); 1001 1002 /* Enabled the filter */ 1003 filter.valid = true; 1004 dp_mon_filter_set_status_cmn(mon_pdev, &filter); 1005 dp_mon_filter_show_filter(mon_pdev, mode, &filter); 1006 1007 /* Store the above filter */ 1008 srng_type = DP_MON_FILTER_SRNG_TYPE_RXDMA_MONITOR_STATUS; 1009 mon_pdev->filter[mode][srng_type] = filter; 1010 } 1011 1012 /** 1013 * dp_mon_filter_reset_mon_mode() - Reset the Rx monitor mode filter 1014 * @pdev: DP pdev handle 1015 */ 1016 void dp_mon_filter_reset_mon_mode(struct dp_pdev *pdev) 1017 { 1018 struct dp_mon_filter filter = {0}; 1019 struct dp_soc *soc = NULL; 1020 enum dp_mon_filter_mode mode = DP_MON_FILTER_MONITOR_MODE; 1021 enum dp_mon_filter_srng_type srng_type = 1022 DP_MON_FILTER_SRNG_TYPE_RXDMA_MONITOR_STATUS; 1023 struct dp_mon_pdev *mon_pdev; 1024 1025 if (!pdev) { 1026 dp_mon_filter_err("pdev Context is null"); 1027 return; 1028 } 1029 1030 soc = pdev->soc; 1031 if (!soc) { 1032 dp_mon_filter_err("Soc Context is null"); 1033 return; 1034 } 1035 1036 mon_pdev = pdev->monitor_pdev; 1037 dp_mon_filter_set_reset_mon_buf(pdev, &filter); 1038 1039 srng_type = DP_MON_FILTER_SRNG_TYPE_RXDMA_MONITOR_STATUS; 1040 mon_pdev->filter[mode][srng_type] = filter; 1041 } 1042 1043 #ifdef WDI_EVENT_ENABLE 1044 /** 1045 * dp_mon_filter_setup_rx_pkt_log_full() - Setup the Rx pktlog full mode filter 1046 * @pdev: DP pdev handle 1047 */ 1048 void dp_mon_filter_setup_rx_pkt_log_full(struct dp_pdev *pdev) 1049 { 1050 struct dp_mon_filter filter = {0}; 1051 enum dp_mon_filter_mode mode = DP_MON_FILTER_PKT_LOG_FULL_MODE; 1052 enum dp_mon_filter_srng_type srng_type = 1053 DP_MON_FILTER_SRNG_TYPE_RXDMA_MONITOR_STATUS; 1054 struct dp_mon_pdev *mon_pdev; 1055 1056 if (!pdev) { 1057 dp_mon_filter_err("pdev Context is null"); 1058 return; 1059 } 1060 1061 mon_pdev = pdev->monitor_pdev; 1062 /* Enabled the filter */ 1063 filter.valid = true; 1064 dp_mon_filter_set_status_cmn(mon_pdev, &filter); 1065 1066 /* Setup the filter */ 1067 filter.tlv_filter.packet_header = 1; 1068 filter.tlv_filter.msdu_start = 1; 1069 filter.tlv_filter.msdu_end = 1; 1070 filter.tlv_filter.mpdu_end = 1; 1071 filter.tlv_filter.attention = 1; 1072 1073 dp_mon_filter_show_filter(mon_pdev, mode, &filter); 1074 mon_pdev->filter[mode][srng_type] = filter; 1075 } 1076 1077 /** 1078 * dp_mon_filter_reset_rx_pkt_log_full() - Reset the Rx pktlog full mode filter 1079 * @pdev: DP pdev handle 1080 */ 1081 void dp_mon_filter_reset_rx_pkt_log_full(struct dp_pdev *pdev) 1082 { 1083 struct dp_mon_filter filter = {0}; 1084 enum dp_mon_filter_mode mode = DP_MON_FILTER_PKT_LOG_FULL_MODE; 1085 enum dp_mon_filter_srng_type srng_type = 1086 DP_MON_FILTER_SRNG_TYPE_RXDMA_MONITOR_STATUS; 1087 struct dp_mon_pdev *mon_pdev; 1088 1089 if (!pdev) { 1090 dp_mon_filter_err("pdev Context is null"); 1091 return; 1092 } 1093 1094 mon_pdev = pdev->monitor_pdev; 1095 mon_pdev->filter[mode][srng_type] = filter; 1096 } 1097 1098 /** 1099 * dp_mon_filter_setup_rx_pkt_log_lite() - Setup the Rx pktlog lite mode filter 1100 * @pdev: DP pdev handle 1101 */ 1102 void dp_mon_filter_setup_rx_pkt_log_lite(struct dp_pdev *pdev) 1103 { 1104 struct dp_mon_filter filter = {0}; 1105 enum dp_mon_filter_mode mode = DP_MON_FILTER_PKT_LOG_LITE_MODE; 1106 enum dp_mon_filter_srng_type srng_type = 1107 DP_MON_FILTER_SRNG_TYPE_RXDMA_MONITOR_STATUS; 1108 struct dp_mon_pdev *mon_pdev; 1109 1110 if (!pdev) { 1111 dp_mon_filter_err("pdev Context is null"); 1112 return; 1113 } 1114 1115 mon_pdev = pdev->monitor_pdev; 1116 /* Enabled the filter */ 1117 filter.valid = true; 1118 dp_mon_filter_set_status_cmn(mon_pdev, &filter); 1119 1120 dp_mon_filter_show_filter(mon_pdev, mode, &filter); 1121 mon_pdev->filter[mode][srng_type] = filter; 1122 } 1123 1124 /** 1125 * dp_mon_filter_reset_rx_pkt_log_lite() - Reset the Rx pktlog lite mode filter 1126 * @pdev: DP pdev handle 1127 */ 1128 void dp_mon_filter_reset_rx_pkt_log_lite(struct dp_pdev *pdev) 1129 { 1130 struct dp_mon_filter filter = {0}; 1131 enum dp_mon_filter_mode mode = DP_MON_FILTER_PKT_LOG_LITE_MODE; 1132 enum dp_mon_filter_srng_type srng_type = 1133 DP_MON_FILTER_SRNG_TYPE_RXDMA_MONITOR_STATUS; 1134 struct dp_mon_pdev *mon_pdev; 1135 1136 if (!pdev) { 1137 dp_mon_filter_err("dp pdev Context is null"); 1138 return; 1139 } 1140 1141 mon_pdev = pdev->monitor_pdev; 1142 mon_pdev->filter[mode][srng_type] = filter; 1143 } 1144 1145 #ifdef QCA_MONITOR_PKT_SUPPORT 1146 static void 1147 dp_mon_filter_set_reset_rx_pkt_log_cbf_mon_buf(struct dp_pdev *pdev, 1148 struct dp_mon_filter *pfilter) 1149 { 1150 struct dp_soc *soc = pdev->soc; 1151 struct dp_mon_pdev *mon_pdev = pdev->monitor_pdev; 1152 enum dp_mon_filter_mode mode = DP_MON_FILTER_PKT_LOG_CBF_MODE; 1153 enum dp_mon_filter_srng_type srng_type; 1154 1155 srng_type = ((soc->wlan_cfg_ctx->rxdma1_enable) ? 1156 DP_MON_FILTER_SRNG_TYPE_RXDMA_MON_BUF : 1157 DP_MON_FILTER_SRNG_TYPE_RXDMA_BUF); 1158 1159 /*set the filter */ 1160 if (pfilter->valid) { 1161 dp_mon_filter_set_cbf_cmn(pdev, pfilter); 1162 1163 dp_mon_filter_show_filter(mon_pdev, mode, pfilter); 1164 mon_pdev->filter[mode][srng_type] = *pfilter; 1165 } else /* reset the filter */ 1166 mon_pdev->filter[mode][srng_type] = *pfilter; 1167 } 1168 #else 1169 static void 1170 dp_mon_filter_set_reset_rx_pkt_log_cbf_mon_buf(struct dp_pdev *pdev, 1171 struct dp_mon_filter *pfilter) 1172 { 1173 } 1174 #endif 1175 1176 /** 1177 * dp_mon_filter_setup_rx_pkt_log_cbf() - Setup the Rx pktlog CBF mode filter 1178 * @pdev: DP pdev handle 1179 */ 1180 void dp_mon_filter_setup_rx_pkt_log_cbf(struct dp_pdev *pdev) 1181 { 1182 struct dp_mon_filter filter = {0}; 1183 struct dp_soc *soc = NULL; 1184 enum dp_mon_filter_mode mode = DP_MON_FILTER_PKT_LOG_CBF_MODE; 1185 enum dp_mon_filter_srng_type srng_type = 1186 DP_MON_FILTER_SRNG_TYPE_RXDMA_MONITOR_STATUS; 1187 struct dp_mon_pdev *mon_pdev; 1188 1189 if (!pdev) { 1190 dp_mon_filter_err("pdev Context is null"); 1191 return; 1192 } 1193 1194 mon_pdev = pdev->monitor_pdev; 1195 soc = pdev->soc; 1196 if (!soc) { 1197 dp_mon_filter_err("Soc Context is null"); 1198 return; 1199 } 1200 1201 /* Enabled the filter */ 1202 filter.valid = true; 1203 dp_mon_filter_set_status_cbf(pdev, &filter); 1204 dp_mon_filter_show_filter(mon_pdev, mode, &filter); 1205 mon_pdev->filter[mode][srng_type] = filter; 1206 1207 /* Clear the filter as the same filter will be used to set the 1208 * monitor status ring 1209 */ 1210 qdf_mem_zero(&(filter), sizeof(struct dp_mon_filter)); 1211 1212 filter.valid = true; 1213 dp_mon_filter_set_reset_rx_pkt_log_cbf_mon_buf(pdev, &filter); 1214 } 1215 1216 /** 1217 * dp_mon_filter_reset_rx_pktlog_cbf() - Reset the Rx pktlog CBF mode filter 1218 * @pdev: DP pdev handle 1219 */ 1220 void dp_mon_filter_reset_rx_pktlog_cbf(struct dp_pdev *pdev) 1221 { 1222 struct dp_mon_filter filter = {0}; 1223 struct dp_soc *soc = NULL; 1224 enum dp_mon_filter_mode mode = DP_MON_FILTER_PKT_LOG_CBF_MODE; 1225 enum dp_mon_filter_srng_type srng_type = 1226 DP_MON_FILTER_SRNG_TYPE_RXDMA_BUF; 1227 struct dp_mon_pdev *mon_pdev; 1228 1229 if (!pdev) { 1230 QDF_TRACE(QDF_MODULE_ID_MON_FILTER, QDF_TRACE_LEVEL_ERROR, 1231 FL("pdev Context is null")); 1232 return; 1233 } 1234 1235 mon_pdev = pdev->monitor_pdev; 1236 soc = pdev->soc; 1237 if (!soc) { 1238 QDF_TRACE(QDF_MODULE_ID_MON_FILTER, QDF_TRACE_LEVEL_ERROR, 1239 FL("Soc Context is null")); 1240 return; 1241 } 1242 1243 dp_mon_filter_set_reset_rx_pkt_log_cbf_mon_buf(pdev, &filter); 1244 1245 srng_type = DP_MON_FILTER_SRNG_TYPE_RXDMA_MONITOR_STATUS; 1246 mon_pdev->filter[mode][srng_type] = filter; 1247 } 1248 #endif /* WDI_EVENT_ENABLE */ 1249 1250 #ifdef WLAN_DP_RESET_MON_BUF_RING_FILTER 1251 /** 1252 * dp_mon_should_reset_buf_ring_filter() - Reset the monitor buf ring filter 1253 * @pdev: DP PDEV handle 1254 * 1255 * WIN has targets which does not support monitor mode, but still do the 1256 * monitor mode init/deinit, only the rxdma1_enable flag will be set to 0. 1257 * MCL need to do the monitor buffer ring filter reset always, but this is 1258 * not needed for WIN targets where rxdma1 is not enabled (the indicator 1259 * that monitor mode is not enabled. 1260 * This function is used as WAR till WIN cleans up the monitor mode 1261 * function for targets where monitor mode is not enabled. 1262 * 1263 * Returns: true 1264 */ 1265 static inline bool dp_mon_should_reset_buf_ring_filter(struct dp_pdev *pdev) 1266 { 1267 return (pdev->monitor_pdev->mvdev) ? true : false; 1268 } 1269 #else 1270 static inline bool dp_mon_should_reset_buf_ring_filter(struct dp_pdev *pdev) 1271 { 1272 return false; 1273 } 1274 #endif 1275 1276 #ifdef QCA_MONITOR_PKT_SUPPORT 1277 static QDF_STATUS dp_mon_filter_mon_buf_update(struct dp_pdev *pdev, 1278 struct dp_mon_filter *pfilter, 1279 bool *pmon_mode_set) 1280 { 1281 struct dp_soc *soc = pdev->soc; 1282 struct dp_mon_pdev *mon_pdev = pdev->monitor_pdev; 1283 enum dp_mon_filter_srng_type srng_type; 1284 QDF_STATUS status = QDF_STATUS_SUCCESS; 1285 1286 srng_type = ((soc->wlan_cfg_ctx->rxdma1_enable) ? 1287 DP_MON_FILTER_SRNG_TYPE_RXDMA_MON_BUF : 1288 DP_MON_FILTER_SRNG_TYPE_RXDMA_BUF); 1289 1290 dp_mon_filter_ht2_setup(soc, pdev, srng_type, pfilter); 1291 1292 *pmon_mode_set = pfilter->valid; 1293 if (dp_mon_should_reset_buf_ring_filter(pdev) || *pmon_mode_set) { 1294 status = dp_mon_ht2_rx_ring_cfg(soc, pdev, 1295 srng_type, 1296 &pfilter->tlv_filter); 1297 } else { 1298 /* 1299 * For WIN case the monitor buffer ring is used and it does need 1300 * reset when monitor mode gets enabled/disabled. 1301 */ 1302 if (soc->wlan_cfg_ctx->rxdma1_enable) { 1303 if (mon_pdev->monitor_configured || *pmon_mode_set) { 1304 status = dp_mon_ht2_rx_ring_cfg(soc, pdev, 1305 srng_type, 1306 &pfilter->tlv_filter); 1307 } 1308 } 1309 } 1310 1311 return status; 1312 } 1313 1314 static void dp_mon_filter_mon_buf_reset(struct dp_pdev *pdev) 1315 { 1316 struct dp_soc *soc = pdev->soc; 1317 enum dp_mon_filter_srng_type srng_type; 1318 1319 srng_type = ((soc->wlan_cfg_ctx->rxdma1_enable) ? 1320 DP_MON_FILTER_SRNG_TYPE_RXDMA_MON_BUF : 1321 DP_MON_FILTER_SRNG_TYPE_RXDMA_BUF); 1322 1323 dp_mon_filter_reset_mon_srng(soc, pdev, srng_type); 1324 } 1325 #else 1326 static QDF_STATUS dp_mon_filter_mon_buf_update(struct dp_pdev *pdev, 1327 struct dp_mon_filter *pfilter, 1328 bool *pmon_mode_set) 1329 { 1330 return QDF_STATUS_SUCCESS; 1331 } 1332 1333 static void dp_mon_filter_mon_buf_reset(struct dp_pdev *pdev) 1334 { 1335 } 1336 #endif 1337 1338 /** 1339 * dp_mon_filter_update() - Setup the monitor filter setting for a srng 1340 * type 1341 * @pdev: DP pdev handle 1342 * 1343 * Return: QDF_STATUS 1344 */ 1345 QDF_STATUS dp_mon_filter_update(struct dp_pdev *pdev) 1346 { 1347 struct dp_soc *soc; 1348 bool mon_mode_set = false; 1349 struct dp_mon_filter filter = {0}; 1350 QDF_STATUS status = QDF_STATUS_SUCCESS; 1351 struct dp_mon_pdev *mon_pdev; 1352 1353 if (!pdev) { 1354 dp_mon_filter_err("pdev Context is null"); 1355 return QDF_STATUS_E_FAILURE; 1356 } 1357 1358 mon_pdev = pdev->monitor_pdev; 1359 soc = pdev->soc; 1360 if (!soc) { 1361 dp_mon_filter_err("Soc Context is null"); 1362 return QDF_STATUS_E_FAILURE; 1363 } 1364 1365 status = dp_mon_filter_check_co_exist(pdev); 1366 if (status != QDF_STATUS_SUCCESS) 1367 return status; 1368 1369 if (soc->monitor_soc->monitor_mode_v2) { 1370 dp_mon_filter_err(" Mon ring not supported for this arch"); 1371 return QDF_STATUS_E_FAILURE; 1372 } 1373 1374 /* 1375 * Setup the filters for the monitor destination ring. 1376 */ 1377 status = dp_mon_filter_mon_buf_update(pdev, &filter, 1378 &mon_mode_set); 1379 1380 if (status != QDF_STATUS_SUCCESS) { 1381 dp_mon_filter_err("%pK: Monitor destination ring filter setting failed", 1382 soc); 1383 return QDF_STATUS_E_FAILURE; 1384 } 1385 1386 /* 1387 * Setup the filters for the status ring. 1388 */ 1389 qdf_mem_zero(&(filter), sizeof(filter)); 1390 dp_mon_filter_ht2_setup(soc, pdev, 1391 DP_MON_FILTER_SRNG_TYPE_RXDMA_MONITOR_STATUS, 1392 &filter); 1393 1394 /* 1395 * Reset the monitor filters if the all the modes for the status rings 1396 * are disabled. This is done to prevent the HW backpressure from the 1397 * monitor destination ring in case the status ring filters 1398 * are not enabled. 1399 */ 1400 if (!filter.valid && mon_mode_set) 1401 dp_mon_filter_mon_buf_reset(pdev); 1402 1403 if (dp_mon_ht2_rx_ring_cfg(soc, pdev, 1404 DP_MON_FILTER_SRNG_TYPE_RXDMA_MONITOR_STATUS, 1405 &filter.tlv_filter) != QDF_STATUS_SUCCESS) { 1406 dp_mon_filter_err("%pK: Monitor status ring filter setting failed", 1407 soc); 1408 dp_mon_filter_mon_buf_reset(pdev); 1409 return QDF_STATUS_E_FAILURE; 1410 } 1411 1412 return status; 1413 } 1414 1415 /** 1416 * dp_mon_filter_dealloc() - Deallocate the filter objects to be stored in 1417 * the radio object. 1418 * @pdev: DP pdev handle 1419 */ 1420 void dp_mon_filter_dealloc(struct dp_mon_pdev *mon_pdev) 1421 { 1422 enum dp_mon_filter_mode mode; 1423 struct dp_mon_filter **mon_filter = NULL; 1424 1425 if (!mon_pdev) { 1426 dp_mon_filter_err("Monitor pdev Context is null"); 1427 return; 1428 } 1429 1430 mon_filter = mon_pdev->filter; 1431 1432 /* 1433 * Check if the monitor filters are already allocated to the mon_pdev. 1434 */ 1435 if (!mon_filter) { 1436 dp_mon_filter_err("Found NULL memmory for the Monitor filter"); 1437 return; 1438 } 1439 1440 /* 1441 * Iterate through the every mode and free the filter object. 1442 */ 1443 for (mode = 0; mode < DP_MON_FILTER_MAX_MODE; mode++) { 1444 if (!mon_filter[mode]) { 1445 continue; 1446 } 1447 1448 qdf_mem_free(mon_filter[mode]); 1449 mon_filter[mode] = NULL; 1450 } 1451 1452 qdf_mem_free(mon_filter); 1453 mon_pdev->filter = NULL; 1454 } 1455 1456 /** 1457 * dp_mon_filter_alloc() - Allocate the filter objects to be stored in 1458 * the radio object. 1459 * @mon_pdev: Monitor pdev handle 1460 */ 1461 struct dp_mon_filter **dp_mon_filter_alloc(struct dp_mon_pdev *mon_pdev) 1462 { 1463 struct dp_mon_filter **mon_filter = NULL; 1464 enum dp_mon_filter_mode mode; 1465 1466 if (!mon_pdev) { 1467 dp_mon_filter_err("pdev Context is null"); 1468 return NULL; 1469 } 1470 1471 mon_filter = (struct dp_mon_filter **)qdf_mem_malloc( 1472 (sizeof(struct dp_mon_filter *) * 1473 DP_MON_FILTER_MAX_MODE)); 1474 if (!mon_filter) { 1475 dp_mon_filter_err("Monitor filter mem allocation failed"); 1476 return NULL; 1477 } 1478 1479 qdf_mem_zero(mon_filter, 1480 sizeof(struct dp_mon_filter *) * DP_MON_FILTER_MAX_MODE); 1481 1482 /* 1483 * Allocate the memory for filters for different srngs for each modes. 1484 */ 1485 for (mode = 0; mode < DP_MON_FILTER_MAX_MODE; mode++) { 1486 mon_filter[mode] = qdf_mem_malloc(sizeof(struct dp_mon_filter) * 1487 DP_MON_FILTER_SRNG_TYPE_MAX); 1488 /* Assign the mon_filter to the pdev->filter such 1489 * that the dp_mon_filter_dealloc() can free up the filters. */ 1490 if (!mon_filter[mode]) { 1491 mon_pdev->filter = mon_filter; 1492 goto fail; 1493 } 1494 } 1495 1496 return mon_filter; 1497 fail: 1498 dp_mon_filter_dealloc(mon_pdev); 1499 return NULL; 1500 } 1501