1 /* 2 * Copyright (c) 2016-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 #include "htt.h" 19 #include "dp_peer.h" 20 #include "hal_rx.h" 21 #include "hal_api.h" 22 #include "qdf_nbuf.h" 23 #include "dp_types.h" 24 #include "dp_internal.h" 25 #include "dp_tx.h" 26 #include "enet.h" 27 #ifdef WIFI_MONITOR_SUPPORT 28 #include "dp_mon.h" 29 #endif 30 #include "dp_txrx_wds.h" 31 32 /* Generic AST entry aging timer value */ 33 #define DP_AST_AGING_TIMER_DEFAULT_MS 5000 34 #define DP_VLAN_UNTAGGED 0 35 #define DP_VLAN_TAGGED_MULTICAST 1 36 #define DP_VLAN_TAGGED_UNICAST 2 37 #define DP_MAX_VLAN_IDS 4096 38 #define DP_INVALID_AST_IDX 0xffff 39 #define DP_INVALID_FLOW_PRIORITY 0xff 40 #define DP_PEER_AST0_FLOW_MASK 0x4 41 #define DP_PEER_AST1_FLOW_MASK 0x8 42 #define DP_PEER_AST2_FLOW_MASK 0x1 43 #define DP_PEER_AST3_FLOW_MASK 0x2 44 #define DP_MAX_AST_INDEX_PER_PEER 4 45 46 static void 47 dp_peer_age_ast_entries(struct dp_soc *soc, struct dp_peer *peer, void *arg) 48 { 49 struct dp_ast_entry *ase, *temp_ase; 50 struct ast_del_ctxt *del_ctxt = (struct ast_del_ctxt *)arg; 51 52 if ((del_ctxt->del_count >= soc->max_ast_ageout_count) && 53 !del_ctxt->age) { 54 return; 55 } 56 57 DP_PEER_ITERATE_ASE_LIST(peer, ase, temp_ase) { 58 /* 59 * Do not expire static ast entries and HM WDS entries 60 */ 61 if (ase->type != CDP_TXRX_AST_TYPE_WDS && 62 ase->type != CDP_TXRX_AST_TYPE_DA) 63 continue; 64 65 if (ase->is_active) { 66 if (del_ctxt->age) 67 ase->is_active = FALSE; 68 69 continue; 70 } 71 72 if (del_ctxt->del_count < soc->max_ast_ageout_count) { 73 DP_STATS_INC(soc, ast.aged_out, 1); 74 dp_peer_del_ast(soc, ase); 75 del_ctxt->del_count++; 76 } else { 77 soc->pending_ageout = true; 78 if (!del_ctxt->age) 79 break; 80 } 81 } 82 } 83 84 static void 85 dp_peer_age_mec_entries(struct dp_soc *soc) 86 { 87 uint32_t index; 88 struct dp_mec_entry *mecentry, *mecentry_next; 89 90 TAILQ_HEAD(, dp_mec_entry) free_list; 91 TAILQ_INIT(&free_list); 92 93 for (index = 0; index <= soc->mec_hash.mask; index++) { 94 qdf_spin_lock_bh(&soc->mec_lock); 95 /* 96 * Expire MEC entry every n sec. 97 */ 98 if (!TAILQ_EMPTY(&soc->mec_hash.bins[index])) { 99 TAILQ_FOREACH_SAFE(mecentry, &soc->mec_hash.bins[index], 100 hash_list_elem, mecentry_next) { 101 if (mecentry->is_active) { 102 mecentry->is_active = FALSE; 103 continue; 104 } 105 dp_peer_mec_detach_entry(soc, mecentry, 106 &free_list); 107 } 108 } 109 qdf_spin_unlock_bh(&soc->mec_lock); 110 } 111 112 dp_peer_mec_free_list(soc, &free_list); 113 } 114 115 static void dp_ast_aging_timer_fn(void *soc_hdl) 116 { 117 struct dp_soc *soc = (struct dp_soc *)soc_hdl; 118 struct ast_del_ctxt del_ctxt = {0}; 119 120 121 if (soc->wds_ast_aging_timer_cnt++ >= DP_WDS_AST_AGING_TIMER_CNT) { 122 del_ctxt.age = true; 123 soc->wds_ast_aging_timer_cnt = 0; 124 } 125 126 if (soc->pending_ageout || del_ctxt.age) { 127 soc->pending_ageout = false; 128 129 /* AST list access lock */ 130 qdf_spin_lock_bh(&soc->ast_lock); 131 132 dp_soc_iterate_peer(soc, dp_peer_age_ast_entries, &del_ctxt, 133 DP_MOD_ID_AST); 134 qdf_spin_unlock_bh(&soc->ast_lock); 135 } 136 137 /* 138 * If NSS offload is enabled, the MEC timeout 139 * will be managed by NSS. 140 */ 141 if (qdf_atomic_read(&soc->mec_cnt) && 142 !wlan_cfg_get_dp_soc_nss_cfg(soc->wlan_cfg_ctx)) 143 dp_peer_age_mec_entries(soc); 144 145 if (qdf_atomic_read(&soc->cmn_init_done)) 146 qdf_timer_mod(&soc->ast_aging_timer, 147 DP_AST_AGING_TIMER_DEFAULT_MS); 148 } 149 150 /* 151 * dp_soc_wds_attach() - Setup WDS timer and AST table 152 * @soc: Datapath SOC handle 153 * 154 * Return: None 155 */ 156 void dp_soc_wds_attach(struct dp_soc *soc) 157 { 158 soc->wds_ast_aging_timer_cnt = 0; 159 soc->pending_ageout = false; 160 qdf_timer_init(soc->osdev, &soc->ast_aging_timer, 161 dp_ast_aging_timer_fn, (void *)soc, 162 QDF_TIMER_TYPE_WAKE_APPS); 163 164 qdf_timer_mod(&soc->ast_aging_timer, DP_AST_AGING_TIMER_DEFAULT_MS); 165 } 166 167 /* 168 * dp_soc_wds_detach() - Detach WDS data structures and timers 169 * @txrx_soc: DP SOC handle 170 * 171 * Return: None 172 */ 173 void dp_soc_wds_detach(struct dp_soc *soc) 174 { 175 qdf_timer_stop(&soc->ast_aging_timer); 176 qdf_timer_free(&soc->ast_aging_timer); 177 } 178 179 /** 180 * dp_tx_mec_handler() - Tx MEC Notify Handler 181 * @vdev: pointer to dp dev handler 182 * @status : Tx completion status from HTT descriptor 183 * 184 * Handles MEC notify event sent from fw to Host 185 * 186 * Return: none 187 */ 188 void dp_tx_mec_handler(struct dp_vdev *vdev, uint8_t *status) 189 { 190 struct dp_soc *soc; 191 QDF_STATUS add_mec_status; 192 uint8_t mac_addr[QDF_MAC_ADDR_SIZE], i; 193 194 if (!vdev->mec_enabled) 195 return; 196 197 /* MEC required only in STA mode */ 198 if (vdev->opmode != wlan_op_mode_sta) 199 return; 200 201 soc = vdev->pdev->soc; 202 203 for (i = 0; i < QDF_MAC_ADDR_SIZE; i++) 204 mac_addr[(QDF_MAC_ADDR_SIZE - 1) - i] = 205 status[(QDF_MAC_ADDR_SIZE - 2) + i]; 206 207 dp_peer_debug("%pK: MEC add for mac_addr "QDF_MAC_ADDR_FMT, 208 soc, QDF_MAC_ADDR_REF(mac_addr)); 209 210 if (qdf_mem_cmp(mac_addr, vdev->mac_addr.raw, QDF_MAC_ADDR_SIZE)) { 211 add_mec_status = dp_peer_mec_add_entry(soc, vdev, mac_addr); 212 dp_peer_debug("%pK: MEC add status %d", vdev, add_mec_status); 213 } 214 } 215 216 #ifndef QCA_HOST_MODE_WIFI_DISABLED 217 218 /** 219 * dp_rx_da_learn() - Add AST entry based on DA lookup 220 * This is a WAR for HK 1.0 and will 221 * be removed in HK 2.0 222 * 223 * @soc: core txrx main context 224 * @rx_tlv_hdr : start address of rx tlvs 225 * @ta_peer : Transmitter peer entry 226 * @nbuf : nbuf to retrieve destination mac for which AST will be added 227 * 228 */ 229 void 230 dp_rx_da_learn(struct dp_soc *soc, 231 uint8_t *rx_tlv_hdr, 232 struct dp_peer *ta_peer, 233 qdf_nbuf_t nbuf) 234 { 235 /* For HKv2 DA port learing is not needed */ 236 if (qdf_likely(soc->ast_override_support)) 237 return; 238 239 if (qdf_unlikely(!ta_peer)) 240 return; 241 242 if (qdf_unlikely(ta_peer->vdev->opmode != wlan_op_mode_ap)) 243 return; 244 245 if (!soc->da_war_enabled) 246 return; 247 248 if (qdf_unlikely(!qdf_nbuf_is_da_valid(nbuf) && 249 !qdf_nbuf_is_da_mcbc(nbuf))) { 250 dp_peer_add_ast(soc, 251 ta_peer, 252 qdf_nbuf_data(nbuf), 253 CDP_TXRX_AST_TYPE_DA, 254 DP_AST_FLAGS_HM); 255 } 256 } 257 258 /** 259 * dp_txrx_set_wds_rx_policy() - API to store datapath 260 * config parameters 261 * @soc - datapath soc handle 262 * @vdev_id - id of datapath vdev handle 263 * @cfg: ini parameter handle 264 * 265 * Return: status 266 */ 267 #ifdef WDS_VENDOR_EXTENSION 268 QDF_STATUS 269 dp_txrx_set_wds_rx_policy(struct cdp_soc_t *soc_hdl, uint8_t vdev_id, 270 u_int32_t val) 271 { 272 struct dp_soc *soc = cdp_soc_t_to_dp_soc(soc_hdl); 273 struct dp_peer *peer; 274 struct dp_vdev *vdev = dp_vdev_get_ref_by_id(soc, vdev_id, 275 DP_MOD_ID_MISC); 276 if (!vdev) { 277 QDF_TRACE(QDF_MODULE_ID_DP, QDF_TRACE_LEVEL_ERROR, 278 FL("vdev is NULL for vdev_id %d"), vdev_id); 279 return QDF_STATUS_E_INVAL; 280 } 281 282 peer = dp_vdev_bss_peer_ref_n_get(vdev, DP_MOD_ID_AST); 283 284 if (peer) { 285 peer->wds_ecm.wds_rx_filter = 1; 286 peer->wds_ecm.wds_rx_ucast_4addr = 287 (val & WDS_POLICY_RX_UCAST_4ADDR) ? 1 : 0; 288 peer->wds_ecm.wds_rx_mcast_4addr = 289 (val & WDS_POLICY_RX_MCAST_4ADDR) ? 1 : 0; 290 dp_peer_unref_delete(peer, DP_MOD_ID_AST); 291 } 292 293 dp_vdev_unref_delete(soc, vdev, DP_MOD_ID_MISC); 294 return QDF_STATUS_SUCCESS; 295 } 296 297 /** 298 * dp_txrx_peer_wds_tx_policy_update() - API to set tx wds policy 299 * 300 * @cdp_soc: DP soc handle 301 * @vdev_id: id of vdev handle 302 * @peer_mac: peer mac address 303 * @wds_tx_ucast: policy for unicast transmission 304 * @wds_tx_mcast: policy for multicast transmission 305 * 306 * Return: void 307 */ 308 QDF_STATUS 309 dp_txrx_peer_wds_tx_policy_update(struct cdp_soc_t *soc, uint8_t vdev_id, 310 uint8_t *peer_mac, int wds_tx_ucast, 311 int wds_tx_mcast) 312 { 313 struct dp_peer *peer = dp_peer_find_hash_find((struct dp_soc *)soc, 314 peer_mac, 0, 315 vdev_id, 316 DP_MOD_ID_AST); 317 if (!peer) { 318 QDF_TRACE(QDF_MODULE_ID_DP, QDF_TRACE_LEVEL_ERROR, 319 FL("peer is NULL for mac %pM vdev_id %d"), 320 peer_mac, vdev_id); 321 return QDF_STATUS_E_INVAL; 322 } 323 324 if (wds_tx_ucast || wds_tx_mcast) { 325 peer->wds_enabled = 1; 326 peer->wds_ecm.wds_tx_ucast_4addr = wds_tx_ucast; 327 peer->wds_ecm.wds_tx_mcast_4addr = wds_tx_mcast; 328 } else { 329 peer->wds_enabled = 0; 330 peer->wds_ecm.wds_tx_ucast_4addr = 0; 331 peer->wds_ecm.wds_tx_mcast_4addr = 0; 332 } 333 334 QDF_TRACE(QDF_MODULE_ID_DP, QDF_TRACE_LEVEL_INFO, 335 "Policy Update set to :\n"); 336 QDF_TRACE(QDF_MODULE_ID_DP, QDF_TRACE_LEVEL_INFO, 337 "peer->wds_enabled %d\n", peer->wds_enabled); 338 QDF_TRACE(QDF_MODULE_ID_DP, QDF_TRACE_LEVEL_INFO, 339 "peer->wds_ecm.wds_tx_ucast_4addr %d\n", 340 peer->wds_ecm.wds_tx_ucast_4addr); 341 QDF_TRACE(QDF_MODULE_ID_DP, QDF_TRACE_LEVEL_INFO, 342 "peer->wds_ecm.wds_tx_mcast_4addr %d\n", 343 peer->wds_ecm.wds_tx_mcast_4addr); 344 345 dp_peer_unref_delete(peer, DP_MOD_ID_AST); 346 return QDF_STATUS_SUCCESS; 347 } 348 349 int dp_wds_rx_policy_check(uint8_t *rx_tlv_hdr, 350 struct dp_vdev *vdev, 351 struct dp_peer *peer) 352 { 353 struct dp_peer *bss_peer; 354 int fr_ds, to_ds, rx_3addr, rx_4addr; 355 int rx_policy_ucast, rx_policy_mcast; 356 hal_soc_handle_t hal_soc = vdev->pdev->soc->hal_soc; 357 int rx_mcast = hal_rx_msdu_end_da_is_mcbc_get(hal_soc, rx_tlv_hdr); 358 359 if (vdev->opmode == wlan_op_mode_ap) { 360 bss_peer = dp_vdev_bss_peer_ref_n_get(vdev, DP_MOD_ID_AST); 361 /* if wds policy check is not enabled on this vdev, accept all frames */ 362 if (bss_peer && !bss_peer->wds_ecm.wds_rx_filter) { 363 dp_peer_unref_delete(bss_peer, DP_MOD_ID_AST); 364 return 1; 365 } 366 rx_policy_ucast = bss_peer->wds_ecm.wds_rx_ucast_4addr; 367 rx_policy_mcast = bss_peer->wds_ecm.wds_rx_mcast_4addr; 368 dp_peer_unref_delete(bss_peer, DP_MOD_ID_AST); 369 } else { /* sta mode */ 370 if (!peer->wds_ecm.wds_rx_filter) { 371 return 1; 372 } 373 rx_policy_ucast = peer->wds_ecm.wds_rx_ucast_4addr; 374 rx_policy_mcast = peer->wds_ecm.wds_rx_mcast_4addr; 375 } 376 377 /* ------------------------------------------------ 378 * self 379 * peer- rx rx- 380 * wds ucast mcast dir policy accept note 381 * ------------------------------------------------ 382 * 1 1 0 11 x1 1 AP configured to accept ds-to-ds Rx ucast from wds peers, constraint met; so, accept 383 * 1 1 0 01 x1 0 AP configured to accept ds-to-ds Rx ucast from wds peers, constraint not met; so, drop 384 * 1 1 0 10 x1 0 AP configured to accept ds-to-ds Rx ucast from wds peers, constraint not met; so, drop 385 * 1 1 0 00 x1 0 bad frame, won't see it 386 * 1 0 1 11 1x 1 AP configured to accept ds-to-ds Rx mcast from wds peers, constraint met; so, accept 387 * 1 0 1 01 1x 0 AP configured to accept ds-to-ds Rx mcast from wds peers, constraint not met; so, drop 388 * 1 0 1 10 1x 0 AP configured to accept ds-to-ds Rx mcast from wds peers, constraint not met; so, drop 389 * 1 0 1 00 1x 0 bad frame, won't see it 390 * 1 1 0 11 x0 0 AP configured to accept from-ds Rx ucast from wds peers, constraint not met; so, drop 391 * 1 1 0 01 x0 0 AP configured to accept from-ds Rx ucast from wds peers, constraint not met; so, drop 392 * 1 1 0 10 x0 1 AP configured to accept from-ds Rx ucast from wds peers, constraint met; so, accept 393 * 1 1 0 00 x0 0 bad frame, won't see it 394 * 1 0 1 11 0x 0 AP configured to accept from-ds Rx mcast from wds peers, constraint not met; so, drop 395 * 1 0 1 01 0x 0 AP configured to accept from-ds Rx mcast from wds peers, constraint not met; so, drop 396 * 1 0 1 10 0x 1 AP configured to accept from-ds Rx mcast from wds peers, constraint met; so, accept 397 * 1 0 1 00 0x 0 bad frame, won't see it 398 * 399 * 0 x x 11 xx 0 we only accept td-ds Rx frames from non-wds peers in mode. 400 * 0 x x 01 xx 1 401 * 0 x x 10 xx 0 402 * 0 x x 00 xx 0 bad frame, won't see it 403 * ------------------------------------------------ 404 */ 405 406 fr_ds = hal_rx_mpdu_get_fr_ds(hal_soc, rx_tlv_hdr); 407 to_ds = hal_rx_mpdu_get_to_ds(hal_soc, rx_tlv_hdr); 408 rx_3addr = fr_ds ^ to_ds; 409 rx_4addr = fr_ds & to_ds; 410 411 if (vdev->opmode == wlan_op_mode_ap) { 412 if ((!peer->wds_enabled && rx_3addr && to_ds) || 413 (peer->wds_enabled && !rx_mcast && (rx_4addr == rx_policy_ucast)) || 414 (peer->wds_enabled && rx_mcast && (rx_4addr == rx_policy_mcast))) { 415 return 1; 416 } 417 } else { /* sta mode */ 418 if ((!rx_mcast && (rx_4addr == rx_policy_ucast)) || 419 (rx_mcast && (rx_4addr == rx_policy_mcast))) { 420 return 1; 421 } 422 } 423 return 0; 424 } 425 #endif 426 427 /** 428 * dp_tx_add_groupkey_metadata - Add group key in metadata 429 * @vdev: DP vdev handle 430 * @msdu_info: MSDU info to be setup in MSDU descriptor 431 * @group_key: Group key index programmed in metadata 432 * 433 * Return: void 434 */ 435 #ifdef QCA_MULTIPASS_SUPPORT 436 static 437 void dp_tx_add_groupkey_metadata(struct dp_vdev *vdev, 438 struct dp_tx_msdu_info_s *msdu_info, uint16_t group_key) 439 { 440 struct htt_tx_msdu_desc_ext2_t *meta_data = 441 (struct htt_tx_msdu_desc_ext2_t *)&msdu_info->meta_data[0]; 442 443 qdf_mem_zero(meta_data, sizeof(struct htt_tx_msdu_desc_ext2_t)); 444 445 /* 446 * When attempting to send a multicast packet with multi-passphrase, 447 * host shall add HTT EXT meta data "struct htt_tx_msdu_desc_ext2_t" 448 * ref htt.h indicating the group_id field in "key_flags" also having 449 * "valid_key_flags" as 1. Assign “key_flags = group_key_ix”. 450 */ 451 HTT_TX_MSDU_EXT2_DESC_FLAG_VALID_KEY_FLAGS_SET(msdu_info->meta_data[0], 1); 452 HTT_TX_MSDU_EXT2_DESC_KEY_FLAGS_SET(msdu_info->meta_data[2], group_key); 453 } 454 455 /** 456 * dp_tx_remove_vlan_tag - Remove 4 bytes of vlan tag 457 * @vdev: DP vdev handle 458 * @tx_desc: Tx Descriptor Handle 459 * 460 * Return: void 461 */ 462 static 463 void dp_tx_remove_vlan_tag(struct dp_vdev *vdev, qdf_nbuf_t nbuf) 464 { 465 struct vlan_ethhdr veth_hdr; 466 struct vlan_ethhdr *veh = (struct vlan_ethhdr *)nbuf->data; 467 468 /* 469 * Extract VLAN header of 4 bytes: 470 * Frame Format : {dst_addr[6], src_addr[6], 802.1Q header[4], EtherType[2], Payload} 471 * Before Removal : xx xx xx xx xx xx xx xx xx xx xx xx 81 00 00 02 08 00 45 00 00... 472 * After Removal : xx xx xx xx xx xx xx xx xx xx xx xx 08 00 45 00 00... 473 */ 474 qdf_mem_copy(&veth_hdr, veh, sizeof(veth_hdr)); 475 qdf_nbuf_pull_head(nbuf, ETHERTYPE_VLAN_LEN); 476 veh = (struct vlan_ethhdr *)nbuf->data; 477 qdf_mem_copy(veh, &veth_hdr, 2 * QDF_MAC_ADDR_SIZE); 478 return; 479 } 480 481 /** 482 * dp_tx_need_multipass_process - If frame needs multipass phrase processing 483 * @vdev: DP vdev handle 484 * @tx_desc: Tx Descriptor Handle 485 * @vlan_id: vlan id of frame 486 * 487 * Return: whether peer is special or classic 488 */ 489 static 490 uint8_t dp_tx_need_multipass_process(struct dp_soc *soc, struct dp_vdev *vdev, 491 qdf_nbuf_t buf, uint16_t *vlan_id) 492 { 493 struct dp_peer *peer = NULL; 494 qdf_ether_header_t *eh = (qdf_ether_header_t *)qdf_nbuf_data(buf); 495 struct vlan_ethhdr *veh = NULL; 496 bool not_vlan = ((vdev->tx_encap_type == htt_cmn_pkt_type_raw) || 497 (htons(eh->ether_type) != ETH_P_8021Q)); 498 499 if (qdf_unlikely(not_vlan)) 500 return DP_VLAN_UNTAGGED; 501 502 veh = (struct vlan_ethhdr *)eh; 503 *vlan_id = (ntohs(veh->h_vlan_TCI) & VLAN_VID_MASK); 504 505 if (qdf_unlikely(DP_FRAME_IS_MULTICAST((eh)->ether_dhost))) { 506 qdf_spin_lock_bh(&vdev->mpass_peer_mutex); 507 TAILQ_FOREACH(peer, &vdev->mpass_peer_list, 508 mpass_peer_list_elem) { 509 if (*vlan_id == peer->vlan_id) { 510 qdf_spin_unlock_bh(&vdev->mpass_peer_mutex); 511 return DP_VLAN_TAGGED_MULTICAST; 512 } 513 } 514 qdf_spin_unlock_bh(&vdev->mpass_peer_mutex); 515 return DP_VLAN_UNTAGGED; 516 } 517 518 peer = dp_peer_find_hash_find(soc, eh->ether_dhost, 0, DP_VDEV_ALL, 519 DP_MOD_ID_TX_MULTIPASS); 520 521 if (qdf_unlikely(peer == NULL)) 522 return DP_VLAN_UNTAGGED; 523 524 /* 525 * Do not drop the frame when vlan_id doesn't match. 526 * Send the frame as it is. 527 */ 528 if (*vlan_id == peer->vlan_id) { 529 dp_peer_unref_delete(peer, DP_MOD_ID_TX_MULTIPASS); 530 return DP_VLAN_TAGGED_UNICAST; 531 } 532 533 dp_peer_unref_delete(peer, DP_MOD_ID_TX_MULTIPASS); 534 return DP_VLAN_UNTAGGED; 535 } 536 537 /** 538 * dp_tx_multipass_process - Process vlan frames in tx path 539 * @soc: dp soc handle 540 * @vdev: DP vdev handle 541 * @nbuf: skb 542 * @msdu_info: msdu descriptor 543 * 544 * Return: status whether frame needs to be dropped or transmitted 545 */ 546 bool dp_tx_multipass_process(struct dp_soc *soc, struct dp_vdev *vdev, 547 qdf_nbuf_t nbuf, 548 struct dp_tx_msdu_info_s *msdu_info) 549 { 550 uint16_t vlan_id = 0; 551 uint16_t group_key = 0; 552 uint8_t is_spcl_peer = DP_VLAN_UNTAGGED; 553 qdf_nbuf_t nbuf_copy = NULL; 554 555 if (HTT_TX_MSDU_EXT2_DESC_FLAG_VALID_KEY_FLAGS_GET(msdu_info->meta_data[0])) { 556 return true; 557 } 558 559 is_spcl_peer = dp_tx_need_multipass_process(soc, vdev, nbuf, &vlan_id); 560 561 if ((is_spcl_peer != DP_VLAN_TAGGED_MULTICAST) && 562 (is_spcl_peer != DP_VLAN_TAGGED_UNICAST)) 563 return true; 564 565 if (is_spcl_peer == DP_VLAN_TAGGED_UNICAST) { 566 dp_tx_remove_vlan_tag(vdev, nbuf); 567 return true; 568 } 569 570 /* AP can have classic clients, special clients & 571 * classic repeaters. 572 * 1. Classic clients & special client: 573 * Remove vlan header, find corresponding group key 574 * index, fill in metaheader and enqueue multicast 575 * frame to TCL. 576 * 2. Classic repeater: 577 * Pass through to classic repeater with vlan tag 578 * intact without any group key index. Hardware 579 * will know which key to use to send frame to 580 * repeater. 581 */ 582 nbuf_copy = qdf_nbuf_copy(nbuf); 583 584 /* 585 * Send multicast frame to special peers even 586 * if pass through to classic repeater fails. 587 */ 588 if (nbuf_copy) { 589 struct dp_tx_msdu_info_s msdu_info_copy; 590 qdf_mem_zero(&msdu_info_copy, sizeof(msdu_info_copy)); 591 msdu_info_copy.tid = HTT_TX_EXT_TID_INVALID; 592 HTT_TX_MSDU_EXT2_DESC_FLAG_VALID_KEY_FLAGS_SET(msdu_info_copy.meta_data[0], 1); 593 nbuf_copy = dp_tx_send_msdu_single(vdev, nbuf_copy, &msdu_info_copy, HTT_INVALID_PEER, NULL); 594 if (nbuf_copy) { 595 qdf_nbuf_free(nbuf_copy); 596 qdf_err("nbuf_copy send failed"); 597 } 598 } 599 600 group_key = vdev->iv_vlan_map[vlan_id]; 601 602 /* 603 * If group key is not installed, drop the frame. 604 */ 605 if (!group_key) 606 return false; 607 608 dp_tx_remove_vlan_tag(vdev, nbuf); 609 dp_tx_add_groupkey_metadata(vdev, msdu_info, group_key); 610 msdu_info->exception_fw = 1; 611 return true; 612 } 613 614 /** 615 * dp_rx_multipass_process - insert vlan tag on frames for traffic separation 616 * @vdev: DP vdev handle 617 * @nbuf: skb 618 * @tid: traffic priority 619 * 620 * Return: bool: true in case of success else false 621 * Success is considered if: 622 * i. If frame has vlan header 623 * ii. If the frame comes from different peer and dont need multipass processing 624 * Failure is considered if: 625 * i. Frame comes from multipass peer but doesn't contain vlan header. 626 * In failure case, drop such frames. 627 */ 628 bool dp_rx_multipass_process(struct dp_peer *peer, qdf_nbuf_t nbuf, uint8_t tid) 629 { 630 struct vlan_ethhdr *vethhdrp; 631 632 if (qdf_unlikely(!peer->vlan_id)) 633 return true; 634 635 vethhdrp = (struct vlan_ethhdr *)qdf_nbuf_data(nbuf); 636 /* 637 * h_vlan_proto & h_vlan_TCI should be 0x8100 & zero respectively 638 * as it is expected to be padded by 0 639 * return false if frame doesn't have above tag so that caller will 640 * drop the frame. 641 */ 642 if (qdf_unlikely(vethhdrp->h_vlan_proto != htons(QDF_ETH_TYPE_8021Q)) || 643 qdf_unlikely(vethhdrp->h_vlan_TCI != 0)) 644 return false; 645 646 vethhdrp->h_vlan_TCI = htons(((tid & 0x7) << VLAN_PRIO_SHIFT) | 647 (peer->vlan_id & VLAN_VID_MASK)); 648 return true; 649 } 650 651 #endif /* QCA_MULTIPASS_SUPPORT */ 652 653 #endif /* QCA_HOST_MODE_WIFI_DISABLED */ 654 655 #ifdef QCA_MULTIPASS_SUPPORT 656 657 /** 658 * dp_peer_multipass_list_remove: remove peer from list 659 * @peer: pointer to peer 660 * 661 * return: void 662 */ 663 void dp_peer_multipass_list_remove(struct dp_peer *peer) 664 { 665 struct dp_vdev *vdev = peer->vdev; 666 struct dp_peer *tpeer = NULL; 667 bool found = 0; 668 669 qdf_spin_lock_bh(&vdev->mpass_peer_mutex); 670 TAILQ_FOREACH(tpeer, &vdev->mpass_peer_list, mpass_peer_list_elem) { 671 if (tpeer == peer) { 672 found = 1; 673 TAILQ_REMOVE(&vdev->mpass_peer_list, peer, mpass_peer_list_elem); 674 break; 675 } 676 } 677 678 qdf_spin_unlock_bh(&vdev->mpass_peer_mutex); 679 680 if (found) 681 dp_peer_unref_delete(peer, DP_MOD_ID_TX_MULTIPASS); 682 } 683 684 /** 685 * dp_peer_multipass_list_add: add to new multipass list 686 * @dp_soc: soc handle 687 * @peer_mac: mac address 688 * @vdev_id: vdev id for peer 689 * @vlan_id: vlan_id 690 * 691 * return: void 692 */ 693 static void dp_peer_multipass_list_add(struct dp_soc *soc, uint8_t *peer_mac, 694 uint8_t vdev_id, uint16_t vlan_id) 695 { 696 struct dp_peer *peer = 697 dp_peer_find_hash_find(soc, peer_mac, 0, vdev_id, 698 DP_MOD_ID_TX_MULTIPASS); 699 700 if (qdf_unlikely(!peer)) { 701 qdf_err("NULL peer"); 702 return; 703 } 704 705 /* If peer already exists in vdev multipass list, do not add it. 706 * This may happen if key install comes twice or re-key 707 * happens for a peer. 708 */ 709 if (peer->vlan_id) { 710 dp_debug("peer already added to vdev multipass list" 711 "MAC: "QDF_MAC_ADDR_FMT" vlan: %d ", 712 QDF_MAC_ADDR_REF(peer->mac_addr.raw), peer->vlan_id); 713 dp_peer_unref_delete(peer, DP_MOD_ID_TX_MULTIPASS); 714 return; 715 } 716 717 /* 718 * Ref_cnt is incremented inside dp_peer_find_hash_find(). 719 * Decrement it when element is deleted from the list. 720 */ 721 peer->vlan_id = vlan_id; 722 qdf_spin_lock_bh(&peer->vdev->mpass_peer_mutex); 723 TAILQ_INSERT_HEAD(&peer->vdev->mpass_peer_list, peer, 724 mpass_peer_list_elem); 725 qdf_spin_unlock_bh(&peer->vdev->mpass_peer_mutex); 726 } 727 728 /** 729 * dp_peer_set_vlan_id: set vlan_id for this peer 730 * @cdp_soc: soc handle 731 * @vdev_id: vdev id for peer 732 * @peer_mac: mac address 733 * @vlan_id: vlan id for peer 734 * 735 * return: void 736 */ 737 void dp_peer_set_vlan_id(struct cdp_soc_t *cdp_soc, 738 uint8_t vdev_id, uint8_t *peer_mac, 739 uint16_t vlan_id) 740 { 741 struct dp_soc *soc = (struct dp_soc *)cdp_soc; 742 struct dp_vdev *vdev = 743 dp_vdev_get_ref_by_id((struct dp_soc *)soc, vdev_id, 744 DP_MOD_ID_TX_MULTIPASS); 745 746 if (vdev && vdev->multipass_en) { 747 dp_peer_multipass_list_add(soc, peer_mac, vdev_id, vlan_id); 748 dp_vdev_unref_delete(soc, vdev, DP_MOD_ID_TX_MULTIPASS); 749 } 750 } 751 752 /** 753 * dp_set_vlan_groupkey: set vlan map for vdev 754 * @soc: pointer to soc 755 * @vdev_id : id of vdev 756 * @vlan_id: vlan_id 757 * @group_key: group key for vlan 758 * 759 * return: set success/failure 760 */ 761 QDF_STATUS dp_set_vlan_groupkey(struct cdp_soc_t *soc_hdl, uint8_t vdev_id, 762 uint16_t vlan_id, uint16_t group_key) 763 { 764 struct dp_soc *soc = cdp_soc_t_to_dp_soc(soc_hdl); 765 struct dp_vdev *vdev = dp_vdev_get_ref_by_id(soc, vdev_id, 766 DP_MOD_ID_TX_MULTIPASS); 767 QDF_STATUS status; 768 769 if (!vdev || !vdev->multipass_en) { 770 status = QDF_STATUS_E_INVAL; 771 goto fail; 772 } 773 774 if (!vdev->iv_vlan_map) { 775 uint16_t vlan_map_size = (sizeof(uint16_t))*DP_MAX_VLAN_IDS; 776 vdev->iv_vlan_map = (uint16_t *)qdf_mem_malloc(vlan_map_size); 777 778 if (!vdev->iv_vlan_map) { 779 QDF_TRACE_ERROR(QDF_MODULE_ID_DP, "iv_vlan_map"); 780 status = QDF_STATUS_E_NOMEM; 781 goto fail; 782 } 783 784 /* 785 * 0 is invalid group key. 786 * Initilalize array with invalid group keys. 787 */ 788 qdf_mem_zero(vdev->iv_vlan_map, vlan_map_size); 789 } 790 791 if (vlan_id >= DP_MAX_VLAN_IDS) { 792 status = QDF_STATUS_E_INVAL; 793 goto fail; 794 } 795 796 vdev->iv_vlan_map[vlan_id] = group_key; 797 status = QDF_STATUS_SUCCESS; 798 fail: 799 if (vdev) 800 dp_vdev_unref_delete(soc, vdev, DP_MOD_ID_TX_MULTIPASS); 801 return status; 802 } 803 804 /** 805 * dp_tx_vdev_multipass_deinit: set vlan map for vdev 806 * @vdev_handle: pointer to vdev 807 * 808 * return: void 809 */ 810 void dp_tx_vdev_multipass_deinit(struct dp_vdev *vdev) 811 { 812 struct dp_peer *peer = NULL; 813 qdf_spin_lock_bh(&vdev->mpass_peer_mutex); 814 TAILQ_FOREACH(peer, &vdev->mpass_peer_list, mpass_peer_list_elem) 815 qdf_err("Peers present in mpass list :" QDF_MAC_ADDR_FMT, 816 QDF_MAC_ADDR_REF(peer->mac_addr.raw)); 817 qdf_spin_unlock_bh(&vdev->mpass_peer_mutex); 818 819 if (vdev->iv_vlan_map) { 820 qdf_mem_free(vdev->iv_vlan_map); 821 vdev->iv_vlan_map = NULL; 822 } 823 824 qdf_spinlock_destroy(&vdev->mpass_peer_mutex); 825 } 826 827 /** 828 * dp_peer_multipass_list_init: initialize peer mulitpass list 829 * @vdev_handle: pointer to vdev 830 * 831 * return: set success/failure 832 */ 833 void dp_peer_multipass_list_init(struct dp_vdev *vdev) 834 { 835 /* 836 * vdev->iv_vlan_map is allocated when the first configuration command 837 * is issued to avoid unnecessary allocation for regular mode VAP. 838 */ 839 TAILQ_INIT(&vdev->mpass_peer_list); 840 qdf_spinlock_create(&vdev->mpass_peer_mutex); 841 } 842 #endif /* QCA_MULTIPASS_SUPPORT */ 843 844 #ifdef QCA_PEER_MULTIQ_SUPPORT 845 846 /** 847 * dp_peer_reset_flowq_map() - reset peer flowq map table 848 * @peer - dp peer handle 849 * 850 * Return: none 851 */ 852 void dp_peer_reset_flowq_map(struct dp_peer *peer) 853 { 854 int i = 0; 855 856 if (!peer) 857 return; 858 859 for (i = 0; i < DP_PEER_AST_FLOWQ_MAX; i++) { 860 peer->peer_ast_flowq_idx[i].is_valid = false; 861 peer->peer_ast_flowq_idx[i].valid_tid_mask = false; 862 peer->peer_ast_flowq_idx[i].ast_idx = DP_INVALID_AST_IDX; 863 peer->peer_ast_flowq_idx[i].flowQ = DP_INVALID_FLOW_PRIORITY; 864 } 865 } 866 867 /** 868 * dp_peer_get_flowid_from_flowmask() - get flow id from flow mask 869 * @peer - dp peer handle 870 * @mask - flow mask 871 * 872 * Return: flow id 873 */ 874 static int dp_peer_get_flowid_from_flowmask(struct dp_peer *peer, 875 uint8_t mask) 876 { 877 if (!peer) { 878 QDF_TRACE(QDF_MODULE_ID_TXRX, QDF_TRACE_LEVEL_ERROR, 879 "%s: Invalid peer\n", __func__); 880 return -1; 881 } 882 883 if (mask & DP_PEER_AST0_FLOW_MASK) 884 return DP_PEER_AST_FLOWQ_UDP; 885 else if (mask & DP_PEER_AST1_FLOW_MASK) 886 return DP_PEER_AST_FLOWQ_NON_UDP; 887 else if (mask & DP_PEER_AST2_FLOW_MASK) 888 return DP_PEER_AST_FLOWQ_HI_PRIO; 889 else if (mask & DP_PEER_AST3_FLOW_MASK) 890 return DP_PEER_AST_FLOWQ_LOW_PRIO; 891 892 return DP_PEER_AST_FLOWQ_MAX; 893 } 894 895 /** 896 * dp_peer_get_ast_valid() - get ast index valid from mask 897 * @mask - mask for ast valid bits 898 * @index - index for an ast 899 * 900 * Return - 1 if ast index is valid from mask else 0 901 */ 902 static inline bool dp_peer_get_ast_valid(uint8_t mask, uint16_t index) 903 { 904 if (index == 0) 905 return 1; 906 return ((mask) & (1 << ((index) - 1))); 907 } 908 909 /** 910 * dp_peer_ast_index_flow_queue_map_create() - create ast index flow queue map 911 * @soc - genereic soc handle 912 * @is_wds - flag to indicate if peer is wds 913 * @peer_id - peer_id from htt peer map message 914 * @peer_mac_addr - mac address of the peer 915 * @ast_info - ast flow override information from peer map 916 * 917 * Return: none 918 */ 919 void dp_peer_ast_index_flow_queue_map_create(void *soc_hdl, 920 bool is_wds, uint16_t peer_id, uint8_t *peer_mac_addr, 921 struct dp_ast_flow_override_info *ast_info) 922 { 923 struct dp_soc *soc = (struct dp_soc *)soc_hdl; 924 struct dp_peer *peer = NULL; 925 uint8_t i; 926 927 /* 928 * Ast flow override feature is supported 929 * only for connected client 930 */ 931 if (is_wds) 932 return; 933 934 peer = dp_peer_get_ref_by_id(soc, peer_id, DP_MOD_ID_AST); 935 if (!peer) { 936 QDF_TRACE(QDF_MODULE_ID_TXRX, QDF_TRACE_LEVEL_ERROR, 937 "%s: Invalid peer\n", __func__); 938 return; 939 } 940 941 /* Valid only in AP mode */ 942 if (peer->vdev->opmode != wlan_op_mode_ap) { 943 QDF_TRACE(QDF_MODULE_ID_DP, QDF_TRACE_LEVEL_ERROR, 944 "%s: Peer ast flow map not in STA mode\n", __func__); 945 goto end; 946 } 947 948 /* Making sure the peer is for this mac address */ 949 if (!qdf_is_macaddr_equal((struct qdf_mac_addr *)peer_mac_addr, 950 (struct qdf_mac_addr *)peer->mac_addr.raw)) { 951 QDF_TRACE(QDF_MODULE_ID_TXRX, QDF_TRACE_LEVEL_ERROR, 952 "%s: Peer mac address mismatch\n", __func__); 953 goto end; 954 } 955 956 /* Ast entry flow mapping not valid for self peer map */ 957 if (qdf_is_macaddr_equal((struct qdf_mac_addr *)peer_mac_addr, 958 (struct qdf_mac_addr *)peer->vdev->mac_addr.raw)) { 959 QDF_TRACE(QDF_MODULE_ID_TXRX, QDF_TRACE_LEVEL_ERROR, 960 "%s: Ast flow mapping not valid for self peer \n", __func__); 961 goto end; 962 } 963 964 /* Fill up ast index <---> flow id mapping table for this peer */ 965 for (i = 0; i < DP_MAX_AST_INDEX_PER_PEER; i++) { 966 967 /* Check if this ast index is valid */ 968 peer->peer_ast_flowq_idx[i].is_valid = 969 dp_peer_get_ast_valid(ast_info->ast_valid_mask, i); 970 if (!peer->peer_ast_flowq_idx[i].is_valid) 971 continue; 972 973 /* Get the flow queue id which is mapped to this ast index */ 974 peer->peer_ast_flowq_idx[i].flowQ = 975 dp_peer_get_flowid_from_flowmask(peer, 976 ast_info->ast_flow_mask[i]); 977 /* 978 * Update tid valid mask only if flow id HIGH or 979 * Low priority 980 */ 981 if (peer->peer_ast_flowq_idx[i].flowQ == 982 DP_PEER_AST_FLOWQ_HI_PRIO) { 983 peer->peer_ast_flowq_idx[i].valid_tid_mask = 984 ast_info->tid_valid_hi_pri_mask; 985 } else if (peer->peer_ast_flowq_idx[i].flowQ == 986 DP_PEER_AST_FLOWQ_LOW_PRIO) { 987 peer->peer_ast_flowq_idx[i].valid_tid_mask = 988 ast_info->tid_valid_low_pri_mask; 989 } 990 991 /* Save the ast index for this entry */ 992 peer->peer_ast_flowq_idx[i].ast_idx = ast_info->ast_idx[i]; 993 } 994 995 if (soc->cdp_soc.ol_ops->peer_ast_flowid_map) { 996 soc->cdp_soc.ol_ops->peer_ast_flowid_map( 997 soc->ctrl_psoc, peer->peer_id, 998 peer->vdev->vdev_id, peer_mac_addr); 999 } 1000 1001 end: 1002 /* Release peer reference */ 1003 dp_peer_unref_delete(peer, DP_MOD_ID_AST); 1004 } 1005 1006 /** 1007 * dp_peer_find_ast_index_by_flowq_id() - API to get ast idx for a given flowid 1008 * @soc - soc handle 1009 * @peer_mac_addr - mac address of the peer 1010 * @flow_id - flow id to find ast index 1011 * 1012 * Return: ast index for a given flow id, -1 for fail cases 1013 */ 1014 int dp_peer_find_ast_index_by_flowq_id(struct cdp_soc_t *soc, 1015 uint16_t vdev_id, uint8_t *peer_mac_addr, 1016 uint8_t flow_id, uint8_t tid) 1017 { 1018 struct dp_peer *peer = NULL; 1019 uint8_t i; 1020 uint16_t ast_index; 1021 1022 if (flow_id >= DP_PEER_AST_FLOWQ_MAX) { 1023 QDF_TRACE(QDF_MODULE_ID_DP, QDF_TRACE_LEVEL_ERROR, 1024 "Invalid Flow ID %d\n", flow_id); 1025 return -1; 1026 } 1027 1028 peer = dp_peer_find_hash_find((struct dp_soc *)soc, 1029 peer_mac_addr, 0, vdev_id, 1030 DP_MOD_ID_AST); 1031 if (!peer) { 1032 QDF_TRACE(QDF_MODULE_ID_DP, QDF_TRACE_LEVEL_ERROR, 1033 "%s: Invalid peer\n", __func__); 1034 return -1; 1035 } 1036 1037 /* 1038 * Loop over the ast entry <----> flow-id mapping to find 1039 * which ast index entry has this flow queue id enabled. 1040 */ 1041 for (i = 0; i < DP_PEER_AST_FLOWQ_MAX; i++) { 1042 if (peer->peer_ast_flowq_idx[i].flowQ == flow_id) 1043 /* 1044 * Found the matching index for this flow id 1045 */ 1046 break; 1047 } 1048 1049 /* 1050 * No match found for this flow id 1051 */ 1052 if (i == DP_PEER_AST_FLOWQ_MAX) { 1053 QDF_TRACE(QDF_MODULE_ID_DP, QDF_TRACE_LEVEL_ERROR, 1054 "%s: ast index not found for flow %d\n", __func__, flow_id); 1055 dp_peer_unref_delete(peer, DP_MOD_ID_AST); 1056 return -1; 1057 } 1058 1059 /* Check whether this ast entry is valid */ 1060 if (!peer->peer_ast_flowq_idx[i].is_valid) { 1061 QDF_TRACE(QDF_MODULE_ID_DP, QDF_TRACE_LEVEL_ERROR, 1062 "%s: ast index is invalid for flow %d\n", __func__, flow_id); 1063 dp_peer_unref_delete(peer, DP_MOD_ID_AST); 1064 return -1; 1065 } 1066 1067 if (flow_id == DP_PEER_AST_FLOWQ_HI_PRIO || 1068 flow_id == DP_PEER_AST_FLOWQ_LOW_PRIO) { 1069 /* 1070 * check if this tid is valid for Hi 1071 * and Low priority flow id 1072 */ 1073 if ((peer->peer_ast_flowq_idx[i].valid_tid_mask 1074 & (1 << tid))) { 1075 /* Release peer reference */ 1076 ast_index = peer->peer_ast_flowq_idx[i].ast_idx; 1077 dp_peer_unref_delete(peer, DP_MOD_ID_AST); 1078 return ast_index; 1079 } else { 1080 QDF_TRACE(QDF_MODULE_ID_DP, QDF_TRACE_LEVEL_ERROR, 1081 "%s: TID %d is not valid for flow %d\n", 1082 __func__, tid, flow_id); 1083 /* 1084 * TID is not valid for this flow 1085 * Return -1 1086 */ 1087 dp_peer_unref_delete(peer, DP_MOD_ID_AST); 1088 return -1; 1089 } 1090 } 1091 1092 /* 1093 * TID valid check not required for 1094 * UDP/NON UDP flow id 1095 */ 1096 ast_index = peer->peer_ast_flowq_idx[i].ast_idx; 1097 dp_peer_unref_delete(peer, DP_MOD_ID_AST); 1098 return ast_index; 1099 } 1100 #endif 1101 1102 void dp_hmwds_ast_add_notify(struct dp_peer *peer, 1103 uint8_t *mac_addr, 1104 enum cdp_txrx_ast_entry_type type, 1105 QDF_STATUS err, 1106 bool is_peer_map) 1107 { 1108 struct dp_vdev *dp_vdev = peer->vdev; 1109 struct dp_pdev *dp_pdev = dp_vdev->pdev; 1110 struct cdp_peer_hmwds_ast_add_status add_status; 1111 1112 /* Ignore ast types other than HM */ 1113 if ((type != CDP_TXRX_AST_TYPE_WDS_HM) && 1114 (type != CDP_TXRX_AST_TYPE_WDS_HM_SEC)) 1115 return; 1116 1117 /* existing ast delete in progress, will be attempted 1118 * to add again after delete is complete. Send status then. 1119 */ 1120 if (err == QDF_STATUS_E_AGAIN) 1121 return; 1122 1123 /* peer map pending, notify actual status 1124 * when peer map is received. 1125 */ 1126 if (!is_peer_map && (err == QDF_STATUS_SUCCESS)) 1127 return; 1128 1129 qdf_mem_zero(&add_status, sizeof(add_status)); 1130 add_status.vdev_id = dp_vdev->vdev_id; 1131 /* For type CDP_TXRX_AST_TYPE_WDS_HM_SEC dp_peer_add_ast() 1132 * returns QDF_STATUS_E_FAILURE as it is host only entry. 1133 * In such cases set err as success. Also err code set to 1134 * QDF_STATUS_E_ALREADY indicates entry already exist in 1135 * such cases set err as success too. Any other error code 1136 * is actual error. 1137 */ 1138 if (((type == CDP_TXRX_AST_TYPE_WDS_HM_SEC) && 1139 (err == QDF_STATUS_E_FAILURE)) || 1140 (err == QDF_STATUS_E_ALREADY)) { 1141 err = QDF_STATUS_SUCCESS; 1142 } 1143 add_status.status = err; 1144 qdf_mem_copy(add_status.peer_mac, peer->mac_addr.raw, 1145 QDF_MAC_ADDR_SIZE); 1146 qdf_mem_copy(add_status.ast_mac, mac_addr, 1147 QDF_MAC_ADDR_SIZE); 1148 #ifdef WDI_EVENT_ENABLE 1149 dp_wdi_event_handler(WDI_EVENT_HMWDS_AST_ADD_STATUS, dp_pdev->soc, 1150 (void *)&add_status, 0, 1151 WDI_NO_VAL, dp_pdev->pdev_id); 1152 #endif 1153 } 1154 1155 #ifdef FEATURE_PERPKT_INFO 1156 /** 1157 * dp_get_completion_indication_for_stack() - send completion to stack 1158 * @soc : dp_soc handle 1159 * @pdev: dp_pdev handle 1160 * @peer: dp peer handle 1161 * @ts: transmit completion status structure 1162 * @netbuf: Buffer pointer for free 1163 * 1164 * This function is used for indication whether buffer needs to be 1165 * sent to stack for freeing or not 1166 */ 1167 QDF_STATUS 1168 dp_get_completion_indication_for_stack(struct dp_soc *soc, 1169 struct dp_pdev *pdev, 1170 struct dp_peer *peer, 1171 struct hal_tx_completion_status *ts, 1172 qdf_nbuf_t netbuf, 1173 uint64_t time_latency) 1174 { 1175 struct tx_capture_hdr *ppdu_hdr; 1176 uint16_t peer_id = ts->peer_id; 1177 uint32_t ppdu_id = ts->ppdu_id; 1178 uint8_t first_msdu = ts->first_msdu; 1179 uint8_t last_msdu = ts->last_msdu; 1180 uint32_t txcap_hdr_size = sizeof(struct tx_capture_hdr); 1181 1182 if (qdf_unlikely(!dp_monitor_is_enable_tx_sniffer(pdev) && 1183 !dp_monitor_is_enable_mcopy_mode(pdev) && 1184 !pdev->latency_capture_enable)) 1185 return QDF_STATUS_E_NOSUPPORT; 1186 1187 if (!peer) { 1188 QDF_TRACE(QDF_MODULE_ID_DP, QDF_TRACE_LEVEL_ERROR, 1189 FL("Peer Invalid")); 1190 return QDF_STATUS_E_INVAL; 1191 } 1192 1193 /* If mcopy is enabled and mcopy_mode is M_COPY deliver 1st MSDU 1194 * per PPDU. If mcopy_mode is M_COPY_EXTENDED deliver 1st MSDU 1195 * for each MPDU 1196 */ 1197 if (dp_monitor_mcopy_check_deliver(pdev, 1198 peer_id, 1199 ppdu_id, 1200 first_msdu) != QDF_STATUS_SUCCESS) 1201 return QDF_STATUS_E_INVAL; 1202 1203 if (qdf_unlikely(qdf_nbuf_headroom(netbuf) < txcap_hdr_size)) { 1204 netbuf = qdf_nbuf_realloc_headroom(netbuf, txcap_hdr_size); 1205 if (!netbuf) { 1206 QDF_TRACE(QDF_MODULE_ID_DP, QDF_TRACE_LEVEL_ERROR, 1207 FL("No headroom")); 1208 return QDF_STATUS_E_NOMEM; 1209 } 1210 } 1211 1212 if (!qdf_nbuf_push_head(netbuf, txcap_hdr_size)) { 1213 QDF_TRACE(QDF_MODULE_ID_DP, QDF_TRACE_LEVEL_ERROR, 1214 FL("No headroom")); 1215 return QDF_STATUS_E_NOMEM; 1216 } 1217 1218 ppdu_hdr = (struct tx_capture_hdr *)qdf_nbuf_data(netbuf); 1219 qdf_mem_copy(ppdu_hdr->ta, peer->vdev->mac_addr.raw, 1220 QDF_MAC_ADDR_SIZE); 1221 qdf_mem_copy(ppdu_hdr->ra, peer->mac_addr.raw, 1222 QDF_MAC_ADDR_SIZE); 1223 ppdu_hdr->ppdu_id = ppdu_id; 1224 ppdu_hdr->peer_id = peer_id; 1225 ppdu_hdr->first_msdu = first_msdu; 1226 ppdu_hdr->last_msdu = last_msdu; 1227 if (qdf_unlikely(pdev->latency_capture_enable)) { 1228 ppdu_hdr->tsf = ts->tsf; 1229 ppdu_hdr->time_latency = (uint32_t)time_latency; 1230 } 1231 1232 return QDF_STATUS_SUCCESS; 1233 } 1234 1235 /** 1236 * dp_send_completion_to_stack() - send completion to stack 1237 * @soc : dp_soc handle 1238 * @pdev: dp_pdev handle 1239 * @peer_id: peer_id of the peer for which completion came 1240 * @ppdu_id: ppdu_id 1241 * @netbuf: Buffer pointer for free 1242 * 1243 * This function is used to send completion to stack 1244 * to free buffer 1245 */ 1246 void dp_send_completion_to_stack(struct dp_soc *soc, struct dp_pdev *pdev, 1247 uint16_t peer_id, uint32_t ppdu_id, 1248 qdf_nbuf_t netbuf) 1249 { 1250 dp_wdi_event_handler(WDI_EVENT_TX_DATA, soc, 1251 netbuf, peer_id, 1252 WDI_NO_VAL, pdev->pdev_id); 1253 } 1254 #endif 1255