1 /* 2 * Copyright (c) 2021, The Linux Foundation. All rights reserved. 3 * Copyright (c) 2021-2022 Qualcomm Innovation Center, Inc. All rights reserved. 4 * 5 * Permission to use, copy, modify, and/or distribute this software for any 6 * purpose with or without fee is hereby granted, provided that the above 7 * copyright notice and this permission notice appear in all copies. 8 * 9 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES 10 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF 11 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR 12 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES 13 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN 14 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF 15 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. 16 */ 17 18 #include <hal_api.h> 19 #include <wlan_cfg.h> 20 #include "dp_types.h" 21 #include "dp_internal.h" 22 #include "dp_htt.h" 23 #include "dp_mon.h" 24 #include "dp_mon_filter.h" 25 26 #include <dp_mon_1.0.h> 27 #include <dp_rx_mon_1.0.h> 28 #include <dp_mon_filter_1.0.h> 29 30 #if defined(QCA_MCOPY_SUPPORT) || defined(ATH_SUPPORT_NAC_RSSI) \ 31 || defined(ATH_SUPPORT_NAC) || defined(WLAN_RX_PKT_CAPTURE_ENH) 32 /** 33 * dp_mon_filter_check_co_exist() - Check the co-existing of the 34 * enabled modes. 35 * @pdev: DP pdev handle 36 * 37 * Return: QDF_STATUS 38 */ 39 static QDF_STATUS dp_mon_filter_check_co_exist(struct dp_pdev *pdev) 40 { 41 struct dp_mon_pdev *mon_pdev = pdev->monitor_pdev; 42 /* 43 * Check if the Rx Enhanced capture mode, monitor mode, 44 * smart_monitor_mode and mcopy mode can co-exist together. 45 */ 46 if ((mon_pdev->rx_enh_capture_mode != CDP_RX_ENH_CAPTURE_DISABLED) && 47 ((mon_pdev->neighbour_peers_added && mon_pdev->mvdev) || 48 mon_pdev->mcopy_mode)) { 49 dp_mon_filter_err("%pK:Rx Capture mode can't exist with modes:\n" 50 "Smart Monitor Mode:%d\n" 51 "M_Copy Mode:%d", pdev->soc, 52 mon_pdev->neighbour_peers_added, 53 mon_pdev->mcopy_mode); 54 return QDF_STATUS_E_FAILURE; 55 } 56 57 /* 58 * Check if the monitor mode cannot co-exist with any other mode. 59 */ 60 if ((mon_pdev->mvdev && mon_pdev->monitor_configured) && 61 (mon_pdev->mcopy_mode || mon_pdev->neighbour_peers_added)) { 62 dp_mon_filter_err("%pK: Monitor mode can't exist with modes\n" 63 "M_Copy Mode:%d\n" 64 "Smart Monitor Mode:%d", 65 pdev->soc, mon_pdev->mcopy_mode, 66 mon_pdev->neighbour_peers_added); 67 return QDF_STATUS_E_FAILURE; 68 } 69 70 /* 71 * Check if the smart monitor mode can co-exist with any other mode 72 */ 73 if (mon_pdev->neighbour_peers_added && 74 ((mon_pdev->mcopy_mode) || mon_pdev->monitor_configured)) { 75 dp_mon_filter_err("%pk: Smart Monitor mode can't exist with modes\n" 76 "M_Copy Mode:%d\n" 77 "Monitor Mode:%d", 78 pdev->soc, mon_pdev->mcopy_mode, 79 mon_pdev->monitor_configured); 80 return QDF_STATUS_E_FAILURE; 81 } 82 83 /* 84 * Check if the m_copy, monitor mode and the smart_monitor_mode 85 * can co-exist togther. 86 */ 87 if (mon_pdev->mcopy_mode && 88 (mon_pdev->mvdev || mon_pdev->neighbour_peers_added)) { 89 dp_mon_filter_err("%pK: mcopy mode can't exist with modes\n" 90 "Monitor Mode:%pK\n" 91 "Smart Monitor Mode:%d", 92 pdev->soc, mon_pdev->mvdev, 93 mon_pdev->neighbour_peers_added); 94 return QDF_STATUS_E_FAILURE; 95 } 96 97 /* 98 * Check if the Rx packet log lite or full can co-exist with 99 * the enable modes. 100 */ 101 if ((mon_pdev->rx_pktlog_mode != DP_RX_PKTLOG_DISABLED) && 102 !mon_pdev->rx_pktlog_cbf && 103 (mon_pdev->mvdev || mon_pdev->monitor_configured)) { 104 dp_mon_filter_err("%pK: Rx pktlog full/lite can't exist with modes\n" 105 "Monitor Mode:%d", pdev->soc, 106 mon_pdev->monitor_configured); 107 return QDF_STATUS_E_FAILURE; 108 } 109 return QDF_STATUS_SUCCESS; 110 } 111 #else 112 static QDF_STATUS dp_mon_filter_check_co_exist(struct dp_pdev *pdev) 113 { 114 struct dp_mon_pdev *mon_pdev = pdev->monitor_pdev; 115 /* 116 * Check if the Rx packet log lite or full can co-exist with 117 * the enable modes. 118 */ 119 if ((mon_pdev->rx_pktlog_mode != DP_RX_PKTLOG_DISABLED) && 120 (mon_pdev->mvdev || mon_pdev->monitor_configured)) { 121 dp_mon_filter_err("%pK: Rx pktlog full/lite can't exist with modes\n" 122 "Monitor Mode:%d", pdev->soc, 123 mon_pdev->monitor_configured); 124 return QDF_STATUS_E_FAILURE; 125 } 126 127 return QDF_STATUS_SUCCESS; 128 } 129 #endif 130 131 #ifdef QCA_ENHANCED_STATS_SUPPORT 132 void dp_mon_filter_setup_enhanced_stats_1_0(struct dp_pdev *pdev) 133 { 134 struct dp_mon_filter filter = {0}; 135 enum dp_mon_filter_mode mode = DP_MON_FILTER_ENHACHED_STATS_MODE; 136 enum dp_mon_filter_srng_type srng_type = 137 DP_MON_FILTER_SRNG_TYPE_RXDMA_MONITOR_STATUS; 138 struct dp_mon_pdev *mon_pdev; 139 140 if (!pdev) { 141 dp_mon_filter_err("pdev Context is null"); 142 return; 143 } 144 145 /* Enabled the filter */ 146 filter.valid = true; 147 148 mon_pdev = pdev->monitor_pdev; 149 dp_mon_filter_set_status_cmn(mon_pdev, &filter); 150 151 filter.tlv_filter.enable_mo = 0; 152 filter.tlv_filter.mo_mgmt_filter = 0; 153 filter.tlv_filter.mo_ctrl_filter = 0; 154 filter.tlv_filter.mo_data_filter = 0; 155 156 dp_mon_filter_show_filter(mon_pdev, mode, &filter); 157 mon_pdev->filter[mode][srng_type] = filter; 158 } 159 160 /** 161 * dp_mon_filter_reset_enhanced_stats() - Reset the enhanced stats filter 162 * @pdev: DP pdev handle 163 */ 164 void dp_mon_filter_reset_enhanced_stats_1_0(struct dp_pdev *pdev) 165 { 166 struct dp_mon_filter filter = {0}; 167 enum dp_mon_filter_mode mode = DP_MON_FILTER_ENHACHED_STATS_MODE; 168 enum dp_mon_filter_srng_type srng_type = 169 DP_MON_FILTER_SRNG_TYPE_RXDMA_MONITOR_STATUS; 170 struct dp_mon_pdev *mon_pdev; 171 172 if (!pdev) { 173 dp_mon_filter_err("pdev Context is null"); 174 return; 175 } 176 177 mon_pdev = pdev->monitor_pdev; 178 mon_pdev->filter[mode][srng_type] = filter; 179 } 180 #endif /* QCA_ENHANCED_STATS_SUPPORT */ 181 182 #ifdef QCA_UNDECODED_METADATA_SUPPORT 183 /** 184 * mon_filter_setup_undecoded_metadata_capture() - Setup undecoded frame 185 * capture phyrx aborted frame filter setup 186 * @pdev: DP pdev handle 187 */ 188 void dp_mon_filter_setup_undecoded_metadata_capture_1_0(struct dp_pdev *pdev) 189 { 190 struct dp_mon_filter filter = {0}; 191 enum dp_mon_filter_mode mode = 192 DP_MON_FILTER_UNDECODED_METADATA_CAPTURE_MODE; 193 enum dp_mon_filter_srng_type srng_type = 194 DP_MON_FILTER_SRNG_TYPE_RXDMA_MONITOR_STATUS; 195 struct dp_mon_pdev *mon_pdev; 196 197 if (!pdev) { 198 dp_mon_filter_err("pdev Context is null"); 199 return; 200 } 201 202 /* Enabled the filter */ 203 mon_pdev = pdev->monitor_pdev; 204 if (mon_pdev->monitor_configured || 205 mon_pdev->scan_spcl_vap_configured) { 206 filter = mon_pdev->filter[DP_MON_FILTER_MONITOR_MODE][srng_type]; 207 } else if (mon_pdev->neighbour_peers_added) { 208 filter = mon_pdev->filter[DP_MON_FILTER_SMART_MONITOR_MODE][srng_type]; 209 } else { 210 dp_mon_filter_set_status_cmn(mon_pdev, &filter); 211 filter.valid = true; 212 } 213 214 /* Setup the filter to subscribe to FP PHY status tlv */ 215 filter.tlv_filter.fp_phy_err = 1; 216 filter.tlv_filter.fp_phy_err_buf_src = SW2RXDMA_BUF_SOURCE_RING; 217 filter.tlv_filter.fp_phy_err_buf_dest = RXDMA2SW_RING; 218 filter.tlv_filter.phy_err_mask = mon_pdev->phyrx_error_mask; 219 filter.tlv_filter.phy_err_mask_cont = mon_pdev->phyrx_error_mask_cont; 220 221 filter.tlv_filter.phy_err_filter_valid = 1; 222 223 dp_mon_filter_show_filter(mon_pdev, mode, &filter); 224 mon_pdev->filter[mode][srng_type] = filter; 225 } 226 227 /** 228 * mon_filter_reset_undecoded_metadata_capture() - Reset undecoded frame 229 * capture phyrx aborted frame filter 230 * @pdev: DP pdev handle 231 */ 232 void dp_mon_filter_reset_undecoded_metadata_capture_1_0(struct dp_pdev *pdev) 233 { 234 struct dp_mon_filter filter = {0}; 235 enum dp_mon_filter_mode mode = 236 DP_MON_FILTER_UNDECODED_METADATA_CAPTURE_MODE; 237 enum dp_mon_filter_srng_type srng_type = 238 DP_MON_FILTER_SRNG_TYPE_RXDMA_MONITOR_STATUS; 239 struct dp_mon_pdev *mon_pdev; 240 241 if (!pdev) { 242 dp_mon_filter_err("pdev Context is null"); 243 return; 244 } 245 mon_pdev = pdev->monitor_pdev; 246 247 filter = mon_pdev->filter[mode][srng_type]; 248 249 /* Reset the phy error and phy error mask */ 250 filter.tlv_filter.fp_phy_err = 0; 251 filter.tlv_filter.fp_phy_err_buf_src = NO_BUFFER_RING; 252 filter.tlv_filter.fp_phy_err_buf_dest = RXDMA_RELEASING_RING; 253 254 filter.tlv_filter.phy_err_mask = 0; 255 filter.tlv_filter.phy_err_mask_cont = 0; 256 mon_pdev->phyrx_error_mask = 0; 257 mon_pdev->phyrx_error_mask_cont = 0; 258 259 filter.tlv_filter.phy_err_filter_valid = 1; 260 261 dp_mon_filter_show_filter(mon_pdev, mode, &filter); 262 mon_pdev->filter[mode][srng_type] = filter; 263 } 264 #endif /* QCA_UNDECODED_METADATA_SUPPORT */ 265 266 #ifdef QCA_MCOPY_SUPPORT 267 #ifdef QCA_MONITOR_PKT_SUPPORT 268 static void dp_mon_filter_set_reset_mcopy_dest(struct dp_pdev *pdev, 269 struct dp_mon_filter *pfilter) 270 { 271 struct dp_soc *soc = pdev->soc; 272 struct dp_mon_pdev *mon_pdev = pdev->monitor_pdev; 273 enum dp_mon_filter_mode mode = DP_MON_FILTER_MCOPY_MODE; 274 enum dp_mon_filter_srng_type srng_type; 275 276 srng_type = ((soc->wlan_cfg_ctx->rxdma1_enable) ? 277 DP_MON_FILTER_SRNG_TYPE_RXDMA_MON_BUF : 278 DP_MON_FILTER_SRNG_TYPE_RXDMA_BUF); 279 280 /* Set the filter */ 281 if (pfilter->valid) { 282 dp_mon_filter_set_mon_cmn(mon_pdev, pfilter); 283 284 pfilter->tlv_filter.fp_data_filter = 0; 285 pfilter->tlv_filter.mo_data_filter = 0; 286 287 dp_mon_filter_show_filter(mon_pdev, mode, pfilter); 288 mon_pdev->filter[mode][srng_type] = *pfilter; 289 } else /* Reset the filter */ 290 mon_pdev->filter[mode][srng_type] = *pfilter; 291 } 292 #else 293 static void dp_mon_filter_set_reset_mcopy_dest(struct dp_pdev *pdev, 294 struct dp_mon_filter *pfilter) 295 { 296 } 297 #endif 298 299 void dp_mon_filter_setup_mcopy_mode_1_0(struct dp_pdev *pdev) 300 { 301 struct dp_mon_filter filter = {0}; 302 struct dp_soc *soc = NULL; 303 enum dp_mon_filter_mode mode = DP_MON_FILTER_MCOPY_MODE; 304 enum dp_mon_filter_srng_type srng_type = 305 DP_MON_FILTER_SRNG_TYPE_RXDMA_MONITOR_STATUS; 306 struct dp_mon_pdev *mon_pdev; 307 308 if (!pdev) { 309 dp_mon_filter_err("pdev Context is null"); 310 return; 311 } 312 313 soc = pdev->soc; 314 if (!soc) { 315 dp_mon_filter_err("Soc Context is null"); 316 return; 317 } 318 319 mon_pdev = pdev->monitor_pdev; 320 if (!mon_pdev) { 321 dp_mon_filter_err("monitor pdev Context is null"); 322 return; 323 } 324 /* Enabled the filter */ 325 filter.valid = true; 326 dp_mon_filter_set_reset_mcopy_dest(pdev, &filter); 327 328 /* Clear the filter as the same filter will be used to set the 329 * monitor status ring 330 */ 331 qdf_mem_zero(&(filter), sizeof(struct dp_mon_filter)); 332 333 /* Enabled the filter */ 334 filter.valid = true; 335 dp_mon_filter_set_status_cmn(mon_pdev, &filter); 336 337 /* Setup the filter */ 338 filter.tlv_filter.enable_mo = 1; 339 filter.tlv_filter.packet_header = 1; 340 filter.tlv_filter.mpdu_end = 1; 341 dp_mon_filter_show_filter(mon_pdev, mode, &filter); 342 343 srng_type = DP_MON_FILTER_SRNG_TYPE_RXDMA_MONITOR_STATUS; 344 mon_pdev->filter[mode][srng_type] = filter; 345 } 346 347 void dp_mon_filter_reset_mcopy_mode_1_0(struct dp_pdev *pdev) 348 { 349 struct dp_mon_filter filter = {0}; 350 struct dp_soc *soc = NULL; 351 enum dp_mon_filter_mode mode = DP_MON_FILTER_MCOPY_MODE; 352 enum dp_mon_filter_srng_type srng_type = 353 DP_MON_FILTER_SRNG_TYPE_RXDMA_MONITOR_STATUS; 354 struct dp_mon_pdev *mon_pdev; 355 356 if (!pdev) { 357 dp_mon_filter_err("pdev Context is null"); 358 return; 359 } 360 361 soc = pdev->soc; 362 if (!soc) { 363 dp_mon_filter_err("Soc Context is null"); 364 return; 365 } 366 367 mon_pdev = pdev->monitor_pdev; 368 dp_mon_filter_set_reset_mcopy_dest(pdev, &filter); 369 370 srng_type = DP_MON_FILTER_SRNG_TYPE_RXDMA_MONITOR_STATUS; 371 mon_pdev->filter[mode][srng_type] = filter; 372 } 373 #endif 374 375 #if defined(ATH_SUPPORT_NAC_RSSI) || defined(ATH_SUPPORT_NAC) 376 /** 377 * dp_mon_filter_setup_smart_monitor() - Setup the smart monitor mode filter 378 * @pdev: DP pdev handle 379 */ 380 void dp_mon_filter_setup_smart_monitor_1_0(struct dp_pdev *pdev) 381 { 382 struct dp_mon_filter filter = {0}; 383 struct dp_soc *soc = NULL; 384 struct dp_mon_soc *mon_soc; 385 386 enum dp_mon_filter_mode mode = DP_MON_FILTER_SMART_MONITOR_MODE; 387 enum dp_mon_filter_srng_type srng_type = 388 DP_MON_FILTER_SRNG_TYPE_RXDMA_MONITOR_STATUS; 389 struct dp_mon_pdev *mon_pdev; 390 391 if (!pdev) { 392 dp_mon_filter_err("pdev Context is null"); 393 return; 394 } 395 396 soc = pdev->soc; 397 if (!soc) { 398 dp_mon_filter_err("Soc Context is null"); 399 return; 400 } 401 402 mon_soc = soc->monitor_soc; 403 mon_pdev = pdev->monitor_pdev; 404 405 /* Enabled the filter */ 406 filter.valid = true; 407 dp_mon_filter_set_status_cmn(mon_pdev, &filter); 408 409 filter.tlv_filter.enable_mo = 0; 410 filter.tlv_filter.mo_mgmt_filter = 0; 411 filter.tlv_filter.mo_ctrl_filter = 0; 412 filter.tlv_filter.mo_data_filter = 0; 413 414 if (mon_soc->hw_nac_monitor_support) { 415 filter.tlv_filter.enable_md = 1; 416 filter.tlv_filter.packet_header = 1; 417 filter.tlv_filter.md_data_filter = FILTER_DATA_ALL; 418 } 419 420 dp_mon_filter_show_filter(mon_pdev, mode, &filter); 421 mon_pdev->filter[mode][srng_type] = filter; 422 } 423 424 void dp_mon_filter_reset_smart_monitor_1_0(struct dp_pdev *pdev) 425 { 426 struct dp_mon_filter filter = {0}; 427 enum dp_mon_filter_mode mode = DP_MON_FILTER_SMART_MONITOR_MODE; 428 enum dp_mon_filter_srng_type srng_type = 429 DP_MON_FILTER_SRNG_TYPE_RXDMA_MONITOR_STATUS; 430 struct dp_mon_pdev *mon_pdev; 431 432 if (!pdev) { 433 dp_mon_filter_err("pdev Context is null"); 434 return; 435 } 436 437 mon_pdev = pdev->monitor_pdev; 438 mon_pdev->filter[mode][srng_type] = filter; 439 } 440 #endif /* ATH_SUPPORT_NAC_RSSI || ATH_SUPPORT_NAC */ 441 442 #ifdef WLAN_RX_PKT_CAPTURE_ENH 443 #ifdef QCA_MONITOR_PKT_SUPPORT 444 static 445 void dp_mon_filter_set_reset_rx_enh_capture_dest(struct dp_pdev *pdev, 446 struct dp_mon_filter *pfilter) 447 { 448 struct dp_soc *soc = pdev->soc; 449 struct dp_mon_pdev *mon_pdev = pdev->monitor_pdev; 450 enum dp_mon_filter_mode mode = DP_MON_FILTER_RX_CAPTURE_MODE; 451 enum dp_mon_filter_srng_type srng_type; 452 453 srng_type = ((soc->wlan_cfg_ctx->rxdma1_enable) ? 454 DP_MON_FILTER_SRNG_TYPE_RXDMA_MON_BUF : 455 DP_MON_FILTER_SRNG_TYPE_RXDMA_BUF); 456 457 /* Set the filter */ 458 if (pfilter->valid) { 459 dp_mon_filter_set_mon_cmn(mon_pdev, pfilter); 460 461 pfilter->tlv_filter.fp_mgmt_filter = 0; 462 pfilter->tlv_filter.fp_ctrl_filter = 0; 463 pfilter->tlv_filter.fp_data_filter = 0; 464 pfilter->tlv_filter.mo_mgmt_filter = 0; 465 pfilter->tlv_filter.mo_ctrl_filter = 0; 466 pfilter->tlv_filter.mo_data_filter = 0; 467 468 dp_mon_filter_show_filter(mon_pdev, mode, pfilter); 469 pdev->monitor_pdev->filter[mode][srng_type] = *pfilter; 470 } else /* Reset the filter */ 471 pdev->monitor_pdev->filter[mode][srng_type] = *pfilter; 472 } 473 #else 474 static 475 void dp_mon_filter_set_reset_rx_enh_capture_dest(struct dp_pdev *pdev, 476 struct dp_mon_filter *pfilter) 477 { 478 } 479 #endif 480 481 void dp_mon_filter_setup_rx_enh_capture_1_0(struct dp_pdev *pdev) 482 { 483 struct dp_mon_filter filter = {0}; 484 struct dp_soc *soc = NULL; 485 enum dp_mon_filter_mode mode = DP_MON_FILTER_RX_CAPTURE_MODE; 486 enum dp_mon_filter_srng_type srng_type = 487 DP_MON_FILTER_SRNG_TYPE_RXDMA_MONITOR_STATUS; 488 struct dp_mon_pdev *mon_pdev; 489 490 if (!pdev) { 491 dp_mon_filter_err("pdev Context is null"); 492 return; 493 } 494 495 soc = pdev->soc; 496 if (!soc) { 497 dp_mon_filter_err("Soc Context is null"); 498 return; 499 } 500 501 mon_pdev = pdev->monitor_pdev; 502 503 /* Enabled the filter */ 504 filter.valid = true; 505 dp_mon_filter_set_reset_rx_enh_capture_dest(pdev, &filter); 506 507 /* Clear the filter as the same filter will be used to set the 508 * monitor status ring 509 */ 510 qdf_mem_zero(&(filter), sizeof(struct dp_mon_filter)); 511 512 /* Enabled the filter */ 513 filter.valid = true; 514 dp_mon_filter_set_status_cmn(mon_pdev, &filter); 515 516 /* Setup the filter */ 517 filter.tlv_filter.mpdu_end = 1; 518 filter.tlv_filter.enable_mo = 1; 519 filter.tlv_filter.packet_header = 1; 520 521 if (mon_pdev->rx_enh_capture_mode == CDP_RX_ENH_CAPTURE_MPDU) { 522 filter.tlv_filter.header_per_msdu = 0; 523 filter.tlv_filter.enable_mo = 0; 524 } else if (mon_pdev->rx_enh_capture_mode == 525 CDP_RX_ENH_CAPTURE_MPDU_MSDU) { 526 bool is_rx_mon_proto_flow_tag_enabled = 527 wlan_cfg_is_rx_mon_protocol_flow_tag_enabled(soc->wlan_cfg_ctx); 528 filter.tlv_filter.header_per_msdu = 1; 529 filter.tlv_filter.enable_mo = 0; 530 if (mon_pdev->is_rx_enh_capture_trailer_enabled || 531 is_rx_mon_proto_flow_tag_enabled) 532 filter.tlv_filter.msdu_end = 1; 533 } 534 535 dp_mon_filter_show_filter(mon_pdev, mode, &filter); 536 537 srng_type = DP_MON_FILTER_SRNG_TYPE_RXDMA_MONITOR_STATUS; 538 mon_pdev->filter[mode][srng_type] = filter; 539 } 540 541 void dp_mon_filter_reset_rx_enh_capture_1_0(struct dp_pdev *pdev) 542 { 543 struct dp_mon_filter filter = {0}; 544 struct dp_soc *soc = NULL; 545 enum dp_mon_filter_mode mode = DP_MON_FILTER_RX_CAPTURE_MODE; 546 enum dp_mon_filter_srng_type srng_type = 547 DP_MON_FILTER_SRNG_TYPE_RXDMA_MONITOR_STATUS; 548 struct dp_mon_pdev *mon_pdev; 549 550 if (!pdev) { 551 dp_mon_filter_err("pdev Context is null"); 552 return; 553 } 554 555 soc = pdev->soc; 556 if (!soc) { 557 dp_mon_filter_err("Soc Context is null"); 558 return; 559 } 560 561 mon_pdev = pdev->monitor_pdev; 562 dp_mon_filter_set_reset_rx_enh_capture_dest(pdev, &filter); 563 564 srng_type = DP_MON_FILTER_SRNG_TYPE_RXDMA_MONITOR_STATUS; 565 mon_pdev->filter[mode][srng_type] = filter; 566 } 567 #endif /* WLAN_RX_PKT_CAPTURE_ENH */ 568 569 #ifdef QCA_MONITOR_PKT_SUPPORT 570 static void dp_mon_filter_set_reset_mon_dest(struct dp_pdev *pdev, 571 struct dp_mon_filter *pfilter) 572 { 573 struct dp_soc *soc = pdev->soc; 574 struct dp_mon_pdev *mon_pdev = pdev->monitor_pdev; 575 enum dp_mon_filter_mode mode = DP_MON_FILTER_MONITOR_MODE; 576 enum dp_mon_filter_srng_type srng_type; 577 578 srng_type = ((soc->wlan_cfg_ctx->rxdma1_enable) ? 579 DP_MON_FILTER_SRNG_TYPE_RXDMA_MON_BUF : 580 DP_MON_FILTER_SRNG_TYPE_RXDMA_BUF); 581 582 /* set the filter */ 583 if (pfilter->valid) { 584 dp_mon_filter_set_mon_cmn(mon_pdev, pfilter); 585 586 dp_mon_filter_show_filter(mon_pdev, mode, pfilter); 587 mon_pdev->filter[mode][srng_type] = *pfilter; 588 } else /* reset the filter */ 589 mon_pdev->filter[mode][srng_type] = *pfilter; 590 } 591 #else 592 static void dp_mon_filter_set_reset_mon_dest(struct dp_pdev *pdev, 593 struct dp_mon_filter *pfilter) 594 { 595 } 596 #endif 597 598 void dp_mon_filter_setup_mon_mode_1_0(struct dp_pdev *pdev) 599 { 600 struct dp_mon_filter filter = {0}; 601 struct dp_soc *soc = NULL; 602 enum dp_mon_filter_mode mode = DP_MON_FILTER_MONITOR_MODE; 603 enum dp_mon_filter_srng_type srng_type = 604 DP_MON_FILTER_SRNG_TYPE_RXDMA_MONITOR_STATUS; 605 struct dp_mon_pdev *mon_pdev; 606 607 if (!pdev) { 608 dp_mon_filter_err("pdev Context is null"); 609 return; 610 } 611 612 soc = pdev->soc; 613 if (!soc) { 614 dp_mon_filter_err("Soc Context is null"); 615 return; 616 } 617 618 mon_pdev = pdev->monitor_pdev; 619 filter.valid = true; 620 dp_mon_filter_set_reset_mon_dest(pdev, &filter); 621 622 /* Clear the filter as the same filter will be used to set the 623 * monitor status ring 624 */ 625 qdf_mem_zero(&(filter), sizeof(struct dp_mon_filter)); 626 627 /* Enabled the filter */ 628 filter.valid = true; 629 dp_mon_filter_set_status_cmn(mon_pdev, &filter); 630 dp_mon_filter_show_filter(mon_pdev, mode, &filter); 631 632 /* Store the above filter */ 633 srng_type = DP_MON_FILTER_SRNG_TYPE_RXDMA_MONITOR_STATUS; 634 mon_pdev->filter[mode][srng_type] = filter; 635 } 636 637 void dp_mon_filter_reset_mon_mode_1_0(struct dp_pdev *pdev) 638 { 639 struct dp_mon_filter filter = {0}; 640 struct dp_soc *soc = NULL; 641 enum dp_mon_filter_mode mode = DP_MON_FILTER_MONITOR_MODE; 642 enum dp_mon_filter_srng_type srng_type = 643 DP_MON_FILTER_SRNG_TYPE_RXDMA_MONITOR_STATUS; 644 struct dp_mon_pdev *mon_pdev; 645 646 if (!pdev) { 647 dp_mon_filter_err("pdev Context is null"); 648 return; 649 } 650 651 soc = pdev->soc; 652 if (!soc) { 653 dp_mon_filter_err("Soc Context is null"); 654 return; 655 } 656 657 mon_pdev = pdev->monitor_pdev; 658 dp_mon_filter_set_reset_mon_dest(pdev, &filter); 659 660 srng_type = DP_MON_FILTER_SRNG_TYPE_RXDMA_MONITOR_STATUS; 661 mon_pdev->filter[mode][srng_type] = filter; 662 } 663 664 #ifdef WDI_EVENT_ENABLE 665 void dp_mon_filter_setup_rx_pkt_log_full_1_0(struct dp_pdev *pdev) 666 { 667 struct dp_mon_filter filter = {0}; 668 enum dp_mon_filter_mode mode = DP_MON_FILTER_PKT_LOG_FULL_MODE; 669 enum dp_mon_filter_srng_type srng_type = 670 DP_MON_FILTER_SRNG_TYPE_RXDMA_MONITOR_STATUS; 671 struct dp_mon_pdev *mon_pdev; 672 673 if (!pdev) { 674 dp_mon_filter_err("pdev Context is null"); 675 return; 676 } 677 678 mon_pdev = pdev->monitor_pdev; 679 /* Enabled the filter */ 680 filter.valid = true; 681 dp_mon_filter_set_status_cmn(mon_pdev, &filter); 682 683 /* Setup the filter */ 684 filter.tlv_filter.packet_header = 1; 685 filter.tlv_filter.msdu_start = 1; 686 filter.tlv_filter.msdu_end = 1; 687 filter.tlv_filter.mpdu_end = 1; 688 filter.tlv_filter.attention = 1; 689 690 dp_mon_filter_show_filter(mon_pdev, mode, &filter); 691 mon_pdev->filter[mode][srng_type] = filter; 692 } 693 694 void dp_mon_filter_reset_rx_pkt_log_full_1_0(struct dp_pdev *pdev) 695 { 696 struct dp_mon_filter filter = {0}; 697 enum dp_mon_filter_mode mode = DP_MON_FILTER_PKT_LOG_FULL_MODE; 698 enum dp_mon_filter_srng_type srng_type = 699 DP_MON_FILTER_SRNG_TYPE_RXDMA_MONITOR_STATUS; 700 struct dp_mon_pdev *mon_pdev; 701 702 if (!pdev) { 703 dp_mon_filter_err("pdev Context is null"); 704 return; 705 } 706 707 mon_pdev = pdev->monitor_pdev; 708 mon_pdev->filter[mode][srng_type] = filter; 709 } 710 711 void dp_mon_filter_setup_rx_pkt_log_lite_1_0(struct dp_pdev *pdev) 712 { 713 struct dp_mon_filter filter = {0}; 714 enum dp_mon_filter_mode mode = DP_MON_FILTER_PKT_LOG_LITE_MODE; 715 enum dp_mon_filter_srng_type srng_type = 716 DP_MON_FILTER_SRNG_TYPE_RXDMA_MONITOR_STATUS; 717 struct dp_mon_pdev *mon_pdev; 718 719 if (!pdev) { 720 dp_mon_filter_err("pdev Context is null"); 721 return; 722 } 723 724 mon_pdev = pdev->monitor_pdev; 725 /* Enabled the filter */ 726 filter.valid = true; 727 dp_mon_filter_set_status_cmn(mon_pdev, &filter); 728 729 dp_mon_filter_show_filter(mon_pdev, mode, &filter); 730 mon_pdev->filter[mode][srng_type] = filter; 731 } 732 733 void dp_mon_filter_reset_rx_pkt_log_lite_1_0(struct dp_pdev *pdev) 734 { 735 struct dp_mon_filter filter = {0}; 736 enum dp_mon_filter_mode mode = DP_MON_FILTER_PKT_LOG_LITE_MODE; 737 enum dp_mon_filter_srng_type srng_type = 738 DP_MON_FILTER_SRNG_TYPE_RXDMA_MONITOR_STATUS; 739 struct dp_mon_pdev *mon_pdev; 740 741 if (!pdev) { 742 dp_mon_filter_err("pdev Context is null"); 743 return; 744 } 745 746 mon_pdev = pdev->monitor_pdev; 747 748 mon_pdev->filter[mode][srng_type] = filter; 749 } 750 751 #ifdef QCA_MONITOR_PKT_SUPPORT 752 static 753 void dp_mon_filter_set_reset_rx_pkt_log_cbf_dest(struct dp_pdev *pdev, 754 struct dp_mon_filter *pfilter) 755 { 756 struct dp_soc *soc = pdev->soc; 757 struct dp_mon_pdev *mon_pdev = pdev->monitor_pdev; 758 enum dp_mon_filter_mode mode = DP_MON_FILTER_PKT_LOG_CBF_MODE; 759 enum dp_mon_filter_srng_type srng_type; 760 761 srng_type = ((soc->wlan_cfg_ctx->rxdma1_enable) ? 762 DP_MON_FILTER_SRNG_TYPE_RXDMA_MON_BUF : 763 DP_MON_FILTER_SRNG_TYPE_RXDMA_BUF); 764 765 /*set the filter */ 766 if (pfilter->valid) { 767 dp_mon_filter_set_cbf_cmn(pdev, pfilter); 768 769 dp_mon_filter_show_filter(mon_pdev, mode, pfilter); 770 mon_pdev->filter[mode][srng_type] = *pfilter; 771 } else /* reset the filter */ 772 mon_pdev->filter[mode][srng_type] = *pfilter; 773 } 774 #else 775 static 776 void dp_mon_filter_set_reset_rx_pkt_log_cbf_dest(struct dp_pdev *pdev, 777 struct dp_mon_filter *pfilter) 778 { 779 } 780 #endif 781 782 void dp_mon_filter_setup_rx_pkt_log_cbf_1_0(struct dp_pdev *pdev) 783 { 784 struct dp_mon_filter filter = {0}; 785 struct dp_soc *soc = NULL; 786 enum dp_mon_filter_mode mode = DP_MON_FILTER_PKT_LOG_CBF_MODE; 787 enum dp_mon_filter_srng_type srng_type = 788 DP_MON_FILTER_SRNG_TYPE_RXDMA_MONITOR_STATUS; 789 struct dp_mon_pdev *mon_pdev = NULL; 790 791 if (!pdev) { 792 dp_mon_filter_err("pdev Context is null"); 793 return; 794 } 795 796 mon_pdev = pdev->monitor_pdev; 797 soc = pdev->soc; 798 if (!soc) { 799 dp_mon_filter_err("Soc Context is null"); 800 return; 801 } 802 803 /* Enabled the filter */ 804 filter.valid = true; 805 dp_mon_filter_set_status_cbf(pdev, &filter); 806 dp_mon_filter_show_filter(mon_pdev, mode, &filter); 807 mon_pdev->filter[mode][srng_type] = filter; 808 809 /* Clear the filter as the same filter will be used to set the 810 * monitor status ring 811 */ 812 qdf_mem_zero(&(filter), sizeof(struct dp_mon_filter)); 813 814 filter.valid = true; 815 dp_mon_filter_set_reset_rx_pkt_log_cbf_dest(pdev, &filter); 816 } 817 818 void dp_mon_filter_reset_rx_pktlog_cbf_1_0(struct dp_pdev *pdev) 819 { 820 struct dp_mon_filter filter = {0}; 821 struct dp_soc *soc = NULL; 822 enum dp_mon_filter_mode mode = DP_MON_FILTER_PKT_LOG_CBF_MODE; 823 enum dp_mon_filter_srng_type srng_type = 824 DP_MON_FILTER_SRNG_TYPE_RXDMA_BUF; 825 struct dp_mon_pdev *mon_pdev = NULL; 826 827 if (!pdev) { 828 QDF_TRACE(QDF_MODULE_ID_MON_FILTER, QDF_TRACE_LEVEL_ERROR, 829 FL("pdev Context is null")); 830 return; 831 } 832 833 mon_pdev = pdev->monitor_pdev; 834 soc = pdev->soc; 835 if (!soc) { 836 QDF_TRACE(QDF_MODULE_ID_MON_FILTER, QDF_TRACE_LEVEL_ERROR, 837 FL("Soc Context is null")); 838 return; 839 } 840 841 dp_mon_filter_set_reset_rx_pkt_log_cbf_dest(pdev, &filter); 842 843 srng_type = DP_MON_FILTER_SRNG_TYPE_RXDMA_MONITOR_STATUS; 844 mon_pdev->filter[mode][srng_type] = filter; 845 } 846 #endif /* WDI_EVENT_ENABLE */ 847 848 #ifdef WLAN_DP_RESET_MON_BUF_RING_FILTER 849 /** 850 * dp_mon_should_reset_buf_ring_filter() - Reset the monitor buf ring filter 851 * @pdev: DP PDEV handle 852 * 853 * WIN has targets which does not support monitor mode, but still do the 854 * monitor mode init/deinit, only the rxdma1_enable flag will be set to 0. 855 * MCL need to do the monitor buffer ring filter reset always, but this is 856 * not needed for WIN targets where rxdma1 is not enabled (the indicator 857 * that monitor mode is not enabled. 858 * This function is used as WAR till WIN cleans up the monitor mode 859 * function for targets where monitor mode is not enabled. 860 * 861 * Returns: true 862 */ 863 static inline bool dp_mon_should_reset_buf_ring_filter(struct dp_pdev *pdev) 864 { 865 return (pdev->monitor_pdev->mvdev) ? true : false; 866 } 867 #else 868 static inline bool dp_mon_should_reset_buf_ring_filter(struct dp_pdev *pdev) 869 { 870 return false; 871 } 872 #endif 873 874 #ifdef QCA_MONITOR_PKT_SUPPORT 875 static QDF_STATUS dp_mon_filter_dest_update(struct dp_pdev *pdev, 876 struct dp_mon_filter *pfilter, 877 bool *pmon_mode_set) 878 { 879 struct dp_soc *soc = pdev->soc; 880 struct dp_mon_pdev *mon_pdev = pdev->monitor_pdev; 881 enum dp_mon_filter_srng_type srng_type; 882 QDF_STATUS status = QDF_STATUS_SUCCESS; 883 884 srng_type = ((soc->wlan_cfg_ctx->rxdma1_enable) ? 885 DP_MON_FILTER_SRNG_TYPE_RXDMA_MON_BUF : 886 DP_MON_FILTER_SRNG_TYPE_RXDMA_BUF); 887 888 dp_mon_filter_h2t_setup(soc, pdev, srng_type, pfilter); 889 890 *pmon_mode_set = pfilter->valid; 891 if (dp_mon_should_reset_buf_ring_filter(pdev) || *pmon_mode_set) { 892 status = dp_mon_ht2_rx_ring_cfg(soc, pdev, 893 srng_type, 894 &pfilter->tlv_filter); 895 } else { 896 /* 897 * For WIN case the monitor buffer ring is used and it does need 898 * reset when monitor mode gets enabled/disabled. 899 */ 900 if (soc->wlan_cfg_ctx->rxdma1_enable) { 901 if (mon_pdev->monitor_configured || *pmon_mode_set) { 902 status = dp_mon_ht2_rx_ring_cfg(soc, pdev, 903 srng_type, 904 &pfilter->tlv_filter); 905 } 906 } 907 } 908 909 return status; 910 } 911 912 static void dp_mon_filter_dest_reset(struct dp_pdev *pdev) 913 { 914 struct dp_soc *soc = pdev->soc; 915 enum dp_mon_filter_srng_type srng_type; 916 917 srng_type = ((soc->wlan_cfg_ctx->rxdma1_enable) ? 918 DP_MON_FILTER_SRNG_TYPE_RXDMA_MON_BUF : 919 DP_MON_FILTER_SRNG_TYPE_RXDMA_BUF); 920 921 dp_mon_filter_reset_mon_srng(soc, pdev, srng_type); 922 } 923 #else 924 static QDF_STATUS dp_mon_filter_dest_update(struct dp_pdev *pdev, 925 struct dp_mon_filter *pfilter, 926 bool *pmon_mode_set) 927 { 928 return QDF_STATUS_SUCCESS; 929 } 930 931 static void dp_mon_filter_dest_reset(struct dp_pdev *pdev) 932 { 933 } 934 #endif 935 936 QDF_STATUS dp_mon_filter_update_1_0(struct dp_pdev *pdev) 937 { 938 struct dp_soc *soc; 939 bool mon_mode_set = false; 940 struct dp_mon_filter filter = {0}; 941 QDF_STATUS status = QDF_STATUS_SUCCESS; 942 struct dp_mon_pdev *mon_pdev; 943 944 if (!pdev) { 945 dp_mon_filter_err("pdev Context is null"); 946 return QDF_STATUS_E_FAILURE; 947 } 948 949 mon_pdev = pdev->monitor_pdev; 950 soc = pdev->soc; 951 if (!soc) { 952 dp_mon_filter_err("Soc Context is null"); 953 return QDF_STATUS_E_FAILURE; 954 } 955 956 status = dp_mon_filter_check_co_exist(pdev); 957 if (status != QDF_STATUS_SUCCESS) 958 return status; 959 960 /* 961 * Setup the filters for the monitor destination ring. 962 */ 963 status = dp_mon_filter_dest_update(pdev, &filter, 964 &mon_mode_set); 965 966 if (status != QDF_STATUS_SUCCESS) { 967 dp_mon_filter_err("%pK: Monitor destination ring filter setting failed", 968 soc); 969 return QDF_STATUS_E_FAILURE; 970 } 971 972 /* 973 * Setup the filters for the status ring. 974 */ 975 qdf_mem_zero(&(filter), sizeof(filter)); 976 dp_mon_filter_h2t_setup(soc, pdev, 977 DP_MON_FILTER_SRNG_TYPE_RXDMA_MONITOR_STATUS, 978 &filter); 979 980 /* 981 * Reset the monitor filters if the all the modes for the status rings 982 * are disabled. This is done to prevent the HW backpressure from the 983 * monitor destination ring in case the status ring filters 984 * are not enabled. 985 */ 986 if (!filter.valid && mon_mode_set) 987 dp_mon_filter_dest_reset(pdev); 988 989 if (dp_mon_ht2_rx_ring_cfg(soc, pdev, 990 DP_MON_FILTER_SRNG_TYPE_RXDMA_MONITOR_STATUS, 991 &filter.tlv_filter) != QDF_STATUS_SUCCESS) { 992 dp_mon_filter_err("%pK: Monitor status ring filter setting failed", 993 soc); 994 dp_mon_filter_dest_reset(pdev); 995 return QDF_STATUS_E_FAILURE; 996 } 997 998 return status; 999 } 1000 1001 #if defined(WLAN_CFR_ENABLE) && defined(WLAN_ENH_CFR_ENABLE) 1002 /* 1003 * dp_cfr_filter_1_0() - Configure HOST RX monitor status ring for CFR 1004 * 1005 * @soc_hdl: Datapath soc handle 1006 * @pdev_id: id of data path pdev handle 1007 * @enable: Enable/Disable CFR 1008 * @filter_val: Flag to select Filter for monitor mode 1009 * 1010 * Return: void 1011 */ 1012 static void dp_cfr_filter_1_0(struct cdp_soc_t *soc_hdl, 1013 uint8_t pdev_id, 1014 bool enable, 1015 struct cdp_monitor_filter *filter_val) 1016 { 1017 struct dp_soc *soc = cdp_soc_t_to_dp_soc(soc_hdl); 1018 struct dp_pdev *pdev = NULL; 1019 struct htt_rx_ring_tlv_filter htt_tlv_filter = {0}; 1020 int max_mac_rings; 1021 uint8_t mac_id = 0; 1022 struct dp_mon_pdev *mon_pdev; 1023 1024 pdev = dp_get_pdev_from_soc_pdev_id_wifi3(soc, pdev_id); 1025 if (!pdev) { 1026 dp_mon_err("pdev is NULL"); 1027 return; 1028 } 1029 1030 mon_pdev = pdev->monitor_pdev; 1031 1032 if (mon_pdev->mvdev) { 1033 dp_mon_info("No action is needed since mon mode is enabled\n"); 1034 return; 1035 } 1036 1037 soc = pdev->soc; 1038 pdev->cfr_rcc_mode = false; 1039 max_mac_rings = wlan_cfg_get_num_mac_rings(pdev->wlan_cfg_ctx); 1040 dp_update_num_mac_rings_for_dbs(soc, &max_mac_rings); 1041 1042 dp_mon_debug("Max_mac_rings %d", max_mac_rings); 1043 dp_mon_info("enable : %d, mode: 0x%x", enable, filter_val->mode); 1044 1045 if (enable) { 1046 pdev->cfr_rcc_mode = true; 1047 1048 htt_tlv_filter.ppdu_start = 1; 1049 htt_tlv_filter.ppdu_end = 1; 1050 htt_tlv_filter.ppdu_end_user_stats = 1; 1051 htt_tlv_filter.ppdu_end_user_stats_ext = 1; 1052 htt_tlv_filter.ppdu_end_status_done = 1; 1053 htt_tlv_filter.mpdu_start = 1; 1054 htt_tlv_filter.offset_valid = false; 1055 1056 htt_tlv_filter.enable_fp = 1057 (filter_val->mode & MON_FILTER_PASS) ? 1 : 0; 1058 htt_tlv_filter.enable_md = 0; 1059 htt_tlv_filter.enable_mo = 1060 (filter_val->mode & MON_FILTER_OTHER) ? 1 : 0; 1061 htt_tlv_filter.fp_mgmt_filter = filter_val->fp_mgmt; 1062 htt_tlv_filter.fp_ctrl_filter = filter_val->fp_ctrl; 1063 htt_tlv_filter.fp_data_filter = filter_val->fp_data; 1064 htt_tlv_filter.mo_mgmt_filter = filter_val->mo_mgmt; 1065 htt_tlv_filter.mo_ctrl_filter = filter_val->mo_ctrl; 1066 htt_tlv_filter.mo_data_filter = filter_val->mo_data; 1067 } 1068 1069 for (mac_id = 0; 1070 mac_id < soc->wlan_cfg_ctx->num_rxdma_status_rings_per_pdev; 1071 mac_id++) { 1072 int mac_for_pdev = 1073 dp_get_mac_id_for_pdev(mac_id, pdev->pdev_id); 1074 1075 htt_h2t_rx_ring_cfg(soc->htt_handle, 1076 mac_for_pdev, 1077 soc->rxdma_mon_status_ring[mac_id].hal_srng, 1078 RXDMA_MONITOR_STATUS, 1079 RX_MON_STATUS_BUF_SIZE, 1080 &htt_tlv_filter); 1081 } 1082 } 1083 1084 void dp_cfr_filter_register_1_0(struct cdp_ops *ops) 1085 { 1086 ops->cfr_ops->txrx_cfr_filter = dp_cfr_filter_1_0; 1087 } 1088 #endif 1089