1 // SPDX-License-Identifier: BSD-3-Clause-Clear 2 /* 3 * Copyright (c) 2018-2021 The Linux Foundation. All rights reserved. 4 * Copyright (c) Qualcomm Technologies, Inc. and/or its subsidiaries. 5 */ 6 7 #include "core.h" 8 #include "peer.h" 9 #include "debug.h" 10 #include "debugfs.h" 11 12 static void ath12k_peer_delete_wait_register(struct ath12k *ar, 13 struct ath12k_peer_delete_wait *wait, 14 u32 vdev_id, const u8 *addr) 15 { 16 wait->vdev_id = vdev_id; 17 ether_addr_copy(wait->addr, addr); 18 init_completion(&wait->done); 19 20 spin_lock_bh(&ar->data_lock); 21 list_add(&wait->list, &ar->peer_delete_waits); 22 spin_unlock_bh(&ar->data_lock); 23 } 24 25 static void ath12k_peer_delete_wait_unregister(struct ath12k *ar, 26 struct ath12k_peer_delete_wait *wait) 27 { 28 spin_lock_bh(&ar->data_lock); 29 list_del(&wait->list); 30 spin_unlock_bh(&ar->data_lock); 31 } 32 33 void ath12k_peer_delete_resp_signal(struct ath12k *ar, u32 vdev_id, const u8 *addr) 34 { 35 struct ath12k_peer_delete_wait *wait; 36 37 guard(spinlock_bh)(&ar->data_lock); 38 39 list_for_each_entry(wait, &ar->peer_delete_waits, list) { 40 if (wait->vdev_id == vdev_id && 41 ether_addr_equal(wait->addr, addr)) { 42 complete(&wait->done); 43 return; 44 } 45 } 46 47 ath12k_warn(ar->ab, "failed to find link peer with vdev id %u addr %pM\n", 48 vdev_id, addr); 49 } 50 51 void ath12k_peer_delete_wait_flush(struct ath12k *ar) 52 { 53 struct ath12k_peer_delete_wait *wait; 54 55 spin_lock_bh(&ar->data_lock); 56 list_for_each_entry(wait, &ar->peer_delete_waits, list) 57 complete(&wait->done); 58 spin_unlock_bh(&ar->data_lock); 59 } 60 61 static int ath12k_wait_for_dp_link_peer_common(struct ath12k_base *ab, int vdev_id, 62 const u8 *addr, bool expect_mapped) 63 { 64 int ret; 65 struct ath12k_dp *dp = ath12k_ab_to_dp(ab); 66 67 ret = wait_event_timeout(ab->peer_mapping_wq, ({ 68 bool mapped; 69 70 spin_lock_bh(&dp->dp_lock); 71 mapped = !!ath12k_dp_link_peer_find_by_vdev_and_addr(dp, 72 vdev_id, 73 addr); 74 spin_unlock_bh(&dp->dp_lock); 75 76 (mapped == expect_mapped || 77 test_bit(ATH12K_FLAG_CRASH_FLUSH, &ab->dev_flags)); 78 }), 3 * HZ); 79 80 if (ret <= 0) 81 return -ETIMEDOUT; 82 83 return 0; 84 } 85 86 void ath12k_peer_cleanup(struct ath12k *ar, u32 vdev_id) 87 { 88 struct ath12k_dp_link_peer *peer, *tmp; 89 struct ath12k_base *ab = ar->ab; 90 struct ath12k_dp *dp = ath12k_ab_to_dp(ab); 91 92 lockdep_assert_wiphy(ath12k_ar_to_hw(ar)->wiphy); 93 94 spin_lock_bh(&dp->dp_lock); 95 list_for_each_entry_safe(peer, tmp, &dp->peers, list) { 96 if (peer->vdev_id != vdev_id) 97 continue; 98 99 ath12k_warn(ab, "removing stale peer %pM from vdev_id %d\n", 100 peer->addr, vdev_id); 101 102 ath12k_dp_link_peer_free(peer); 103 ar->num_peers--; 104 } 105 106 spin_unlock_bh(&dp->dp_lock); 107 } 108 109 static int ath12k_wait_for_peer_deleted(struct ath12k *ar, int vdev_id, const u8 *addr) 110 { 111 return ath12k_wait_for_dp_link_peer_common(ar->ab, vdev_id, addr, false); 112 } 113 114 int ath12k_wait_for_peer_delete_done(struct ath12k *ar, 115 struct ath12k_peer_delete_wait *wait) 116 { 117 unsigned long time_left; 118 int ret; 119 120 ret = ath12k_wait_for_peer_deleted(ar, wait->vdev_id, wait->addr); 121 if (ret) { 122 ath12k_warn(ar->ab, "failed wait for peer deleted\n"); 123 return ret; 124 } 125 126 time_left = wait_for_completion_timeout(&wait->done, 3 * HZ); 127 if (time_left == 0) { 128 ath12k_warn(ar->ab, "Timeout in receiving peer delete response\n"); 129 return -ETIMEDOUT; 130 } 131 132 return 0; 133 } 134 135 static int ath12k_peer_delete_send(struct ath12k *ar, u32 vdev_id, const u8 *addr) 136 { 137 struct ath12k_base *ab = ar->ab; 138 int ret; 139 140 lockdep_assert_wiphy(ath12k_ar_to_hw(ar)->wiphy); 141 142 ret = ath12k_wmi_send_peer_delete_cmd(ar, addr, vdev_id); 143 if (ret) { 144 ath12k_warn(ab, 145 "failed to delete peer vdev_id %d addr %pM ret %d\n", 146 vdev_id, addr, ret); 147 return ret; 148 } 149 150 return 0; 151 } 152 153 int ath12k_peer_delete(struct ath12k *ar, u32 vdev_id, u8 *addr) 154 { 155 struct ath12k_peer_delete_wait wait; 156 int ret; 157 158 lockdep_assert_wiphy(ath12k_ar_to_hw(ar)->wiphy); 159 160 ath12k_dp_link_peer_unassign(ath12k_ab_to_dp(ar->ab), 161 &(ath12k_ar_to_ah(ar)->dp_hw), vdev_id, 162 addr, ar->hw_link_id); 163 164 /* 165 * Register the stack waiter before sending so the resp_event for 166 * this peer cannot arrive while no waiter is queued. 167 */ 168 ath12k_peer_delete_wait_register(ar, &wait, vdev_id, addr); 169 170 ret = ath12k_peer_delete_send(ar, vdev_id, addr); 171 if (ret) 172 goto out; 173 174 ret = ath12k_wait_for_peer_delete_done(ar, &wait); 175 if (ret) 176 goto out; 177 178 ar->num_peers--; 179 180 out: 181 ath12k_peer_delete_wait_unregister(ar, &wait); 182 return ret; 183 } 184 185 static int ath12k_wait_for_peer_created(struct ath12k *ar, int vdev_id, const u8 *addr) 186 { 187 return ath12k_wait_for_dp_link_peer_common(ar->ab, vdev_id, addr, true); 188 } 189 190 int ath12k_peer_create(struct ath12k *ar, struct ath12k_link_vif *arvif, 191 struct ieee80211_sta *sta, 192 struct ath12k_wmi_peer_create_arg *arg) 193 { 194 struct ieee80211_vif *vif = ath12k_ahvif_to_vif(arvif->ahvif); 195 struct ath12k_vif *ahvif = arvif->ahvif; 196 struct ath12k_dp_link_vif *dp_link_vif; 197 struct ath12k_link_sta *arsta; 198 u8 link_id = arvif->link_id; 199 struct ath12k_dp_link_peer *peer; 200 struct ath12k_sta *ahsta; 201 u16 ml_peer_id; 202 int ret; 203 struct ath12k_dp *dp = ath12k_ab_to_dp(ar->ab); 204 205 lockdep_assert_wiphy(ath12k_ar_to_hw(ar)->wiphy); 206 207 dp_link_vif = ath12k_dp_vif_to_dp_link_vif(&ahvif->dp_vif, link_id); 208 209 if (ar->num_peers > (ar->max_num_peers - 1)) { 210 ath12k_warn(ar->ab, 211 "failed to create peer due to insufficient peer entry resource in firmware\n"); 212 return -ENOBUFS; 213 } 214 215 spin_lock_bh(&dp->dp_lock); 216 peer = ath12k_dp_link_peer_find_by_pdev_and_addr(dp, ar->pdev_idx, 217 arg->peer_addr); 218 if (peer) { 219 spin_unlock_bh(&dp->dp_lock); 220 return -EINVAL; 221 } 222 spin_unlock_bh(&dp->dp_lock); 223 224 ret = ath12k_wmi_send_peer_create_cmd(ar, arg); 225 if (ret) { 226 ath12k_warn(ar->ab, 227 "failed to send peer create vdev_id %d ret %d\n", 228 arg->vdev_id, ret); 229 return ret; 230 } 231 232 ret = ath12k_wait_for_peer_created(ar, arg->vdev_id, 233 arg->peer_addr); 234 if (ret) 235 return ret; 236 237 spin_lock_bh(&dp->dp_lock); 238 239 peer = ath12k_dp_link_peer_find_by_vdev_and_addr(dp, arg->vdev_id, 240 arg->peer_addr); 241 if (!peer) { 242 struct ath12k_peer_delete_wait wait; 243 244 spin_unlock_bh(&dp->dp_lock); 245 ath12k_warn(ar->ab, "failed to find peer %pM on vdev %i after creation\n", 246 arg->peer_addr, arg->vdev_id); 247 248 ath12k_peer_delete_wait_register(ar, &wait, arg->vdev_id, 249 arg->peer_addr); 250 251 ret = ath12k_wmi_send_peer_delete_cmd(ar, arg->peer_addr, 252 arg->vdev_id); 253 if (ret) { 254 ath12k_warn(ar->ab, "failed to delete peer vdev_id %d addr %pM\n", 255 arg->vdev_id, arg->peer_addr); 256 ath12k_peer_delete_wait_unregister(ar, &wait); 257 return ret; 258 } 259 260 ret = ath12k_wait_for_peer_delete_done(ar, &wait); 261 ath12k_peer_delete_wait_unregister(ar, &wait); 262 if (ret) 263 return ret; 264 265 return -ENOENT; 266 } 267 268 peer->pdev_idx = ar->pdev_idx; 269 peer->sta = sta; 270 271 if (vif->type == NL80211_IFTYPE_STATION) { 272 dp_link_vif->ast_hash = peer->ast_hash; 273 dp_link_vif->ast_idx = peer->hw_peer_id; 274 } 275 276 if (sta) { 277 ahsta = ath12k_sta_to_ahsta(sta); 278 arsta = wiphy_dereference(ath12k_ar_to_hw(ar)->wiphy, 279 ahsta->link[link_id]); 280 /* TODO: Split DP related field usage to DP peer structure */ 281 arsta->tcl_metadata = u16_encode_bits(0, HTT_TCL_META_DATA_TYPE) | 282 u16_encode_bits(peer->peer_id, 283 HTT_TCL_META_DATA_PEER_ID) | 284 u16_encode_bits(0, HTT_TCL_META_DATA_VALID_HTT); 285 arsta->ast_hash = peer->ast_hash; 286 arsta->ast_idx = peer->hw_peer_id; 287 peer->link_id = arsta->link_id; 288 289 /* Fill ML info into created peer */ 290 if (sta->mlo) { 291 ml_peer_id = ahsta->ml_peer_id; 292 /* 293 * For chips where firmware allocates the ML peer ID, 294 * ml_peer_id is ATH12K_MLO_PEER_ID_PENDING here. The 295 * MLO_RX_PEER_MAP HTT event handler fixes up 296 * peer->ml_id once the ID is known. 297 */ 298 if (ml_peer_id == ATH12K_MLO_PEER_ID_PENDING) 299 peer->ml_id = ATH12K_MLO_PEER_ID_INVALID; 300 else 301 peer->ml_id = ml_peer_id; 302 ether_addr_copy(peer->ml_addr, sta->addr); 303 304 /* the assoc link is considered primary for now */ 305 peer->primary_link = arsta->is_assoc_link; 306 peer->mlo = true; 307 } else { 308 peer->ml_id = ATH12K_MLO_PEER_ID_INVALID; 309 peer->primary_link = true; 310 peer->mlo = false; 311 } 312 } 313 314 ar->num_peers++; 315 316 spin_unlock_bh(&dp->dp_lock); 317 318 if (arvif->link_id < IEEE80211_MLD_MAX_NUM_LINKS) { 319 ret = ath12k_dp_link_peer_assign(ath12k_ab_to_dp(ar->ab), 320 &(ath12k_ar_to_ah(ar)->dp_hw), 321 arvif->vdev_id, sta, 322 (u8 *)arg->peer_addr, link_id, 323 ar->hw_link_id); 324 } 325 326 if (vif->type == NL80211_IFTYPE_AP && peer->dp_peer) 327 peer->dp_peer->ucast_ra_only = true; 328 329 return ret; 330 } 331 332 u16 ath12k_peer_ml_alloc(struct ath12k_hw *ah) 333 { 334 u16 ml_peer_id; 335 336 lockdep_assert_wiphy(ah->hw->wiphy); 337 338 for (ml_peer_id = 0; ml_peer_id < ATH12K_MAX_MLO_PEERS; ml_peer_id++) { 339 if (test_bit(ml_peer_id, ah->free_ml_peer_id_map)) 340 continue; 341 342 set_bit(ml_peer_id, ah->free_ml_peer_id_map); 343 break; 344 } 345 346 if (ml_peer_id == ATH12K_MAX_MLO_PEERS) 347 return ATH12K_MLO_PEER_ID_INVALID; 348 349 return ml_peer_id | ATH12K_PEER_ML_ID_VALID; 350 } 351 352 void ath12k_peer_ml_free(struct ath12k_hw *ah, struct ath12k_sta *ahsta) 353 { 354 lockdep_assert_wiphy(ah->hw->wiphy); 355 356 /* 357 * Only devices that allocate the ID on the host own a slot in 358 * free_ml_peer_id_map. 359 */ 360 if (ah->host_alloc_ml_id && 361 (ahsta->ml_peer_id < 362 (ATH12K_MAX_MLO_PEERS | ATH12K_PEER_ML_ID_VALID))) 363 clear_bit(ahsta->ml_peer_id & ~ATH12K_PEER_ML_ID_VALID, 364 ah->free_ml_peer_id_map); 365 ahsta->ml_peer_id = ATH12K_MLO_PEER_ID_INVALID; 366 } 367 368 int ath12k_peer_mlo_link_peers_delete(struct ath12k_vif *ahvif, struct ath12k_sta *ahsta) 369 { 370 DECLARE_BITMAP(registered, IEEE80211_MLD_MAX_NUM_LINKS); 371 struct ieee80211_sta *sta = ath12k_ahsta_to_sta(ahsta); 372 struct ath12k_hw *ah = ahvif->ah; 373 struct ath12k_link_vif *arvif; 374 struct ath12k_link_sta *arsta; 375 int ret, err_ret = 0; 376 unsigned long links; 377 struct ath12k *ar; 378 u8 link_id; 379 380 lockdep_assert_wiphy(ah->hw->wiphy); 381 382 if (!sta->mlo) 383 return -EINVAL; 384 385 struct ath12k_peer_delete_wait *waits __free(kfree) = 386 kzalloc_objs(*waits, IEEE80211_MLD_MAX_NUM_LINKS); 387 if (!waits) 388 return -ENOMEM; 389 390 bitmap_zero(registered, IEEE80211_MLD_MAX_NUM_LINKS); 391 392 /* 393 * Firmware expects delete of all link peers at once before waiting 394 * for reception of peer unmap or delete responses. Phase 1 registers 395 * a per-link stack waiter and sends WMI peer delete for every 396 * link; the resp_event handler matches each response to its 397 * (vdev_id, addr) waiter on ar->peer_delete_waits. 398 */ 399 links = ahsta->links_map; 400 for_each_set_bit(link_id, &links, IEEE80211_MLD_MAX_NUM_LINKS) { 401 arvif = wiphy_dereference(ah->hw->wiphy, ahvif->link[link_id]); 402 arsta = wiphy_dereference(ah->hw->wiphy, ahsta->link[link_id]); 403 if (!arvif || !arsta) 404 continue; 405 406 ar = arvif->ar; 407 if (!ar) 408 continue; 409 410 ath12k_dp_peer_cleanup(ar, arvif->vdev_id, arsta->addr); 411 412 ath12k_dp_link_peer_unassign(ath12k_ab_to_dp(ar->ab), 413 &(ath12k_ar_to_ah(ar)->dp_hw), 414 arvif->vdev_id, arsta->addr, 415 ar->hw_link_id); 416 417 ath12k_peer_delete_wait_register(ar, &waits[link_id], 418 arvif->vdev_id, arsta->addr); 419 420 ret = ath12k_peer_delete_send(ar, arvif->vdev_id, arsta->addr); 421 if (ret) { 422 ath12k_warn(ar->ab, 423 "failed to delete peer vdev_id %d addr %pM ret %d\n", 424 arvif->vdev_id, arsta->addr, ret); 425 err_ret = ret; 426 ath12k_peer_delete_wait_unregister(ar, &waits[link_id]); 427 continue; 428 } 429 430 set_bit(link_id, registered); 431 } 432 433 /* 434 * Phase 2: wait for unmap + delete_resp on each registered link 435 * and tear down the waiter. 436 */ 437 links = ahsta->links_map; 438 for_each_set_bit(link_id, &links, IEEE80211_MLD_MAX_NUM_LINKS) { 439 if (!test_bit(link_id, registered)) 440 continue; 441 442 arvif = wiphy_dereference(ah->hw->wiphy, ahvif->link[link_id]); 443 ar = arvif->ar; 444 445 ret = ath12k_wait_for_peer_delete_done(ar, &waits[link_id]); 446 ath12k_peer_delete_wait_unregister(ar, &waits[link_id]); 447 if (ret) { 448 err_ret = ret; 449 continue; 450 } 451 ar->num_peers--; 452 } 453 454 return err_ret; 455 } 456 457 static int ath12k_link_sta_rhash_insert(struct ath12k_base *ab, 458 struct ath12k_link_sta *arsta) 459 { 460 struct ath12k_link_sta *tmp; 461 462 lockdep_assert_held(&ab->base_lock); 463 464 tmp = rhashtable_lookup_get_insert_fast(ab->rhead_sta_addr, &arsta->rhash_addr, 465 ab->rhash_sta_addr_param); 466 if (!tmp) 467 return 0; 468 else if (IS_ERR(tmp)) 469 return PTR_ERR(tmp); 470 else 471 return -EEXIST; 472 } 473 474 static int ath12k_link_sta_rhash_remove(struct ath12k_base *ab, 475 struct ath12k_link_sta *arsta) 476 { 477 int ret; 478 479 lockdep_assert_held(&ab->base_lock); 480 481 ret = rhashtable_remove_fast(ab->rhead_sta_addr, &arsta->rhash_addr, 482 ab->rhash_sta_addr_param); 483 if (ret && ret != -ENOENT) 484 return ret; 485 486 return 0; 487 } 488 489 int ath12k_link_sta_rhash_add(struct ath12k_base *ab, 490 struct ath12k_link_sta *arsta) 491 { 492 int ret; 493 494 lockdep_assert_held(&ab->base_lock); 495 496 ret = ath12k_link_sta_rhash_insert(ab, arsta); 497 if (ret) 498 ath12k_warn(ab, "failed to add arsta %pM in rhash_addr ret %d\n", 499 arsta->addr, ret); 500 501 return ret; 502 } 503 504 void ath12k_link_sta_rhash_delete(struct ath12k_base *ab, 505 struct ath12k_link_sta *arsta) 506 { 507 /* 508 * Return type of this function is void since there is nothing to be 509 * done in failure case 510 */ 511 int ret; 512 513 lockdep_assert_held(&ab->base_lock); 514 515 ret = ath12k_link_sta_rhash_remove(ab, arsta); 516 if (ret) 517 ath12k_warn(ab, 518 "failed to remove arsta %pM in rhash_addr ret %d\n", 519 arsta->addr, ret); 520 } 521 522 int ath12k_link_sta_rhash_tbl_init(struct ath12k_base *ab) 523 { 524 struct rhashtable_params *param; 525 struct rhashtable *rhash_addr_tbl; 526 int ret; 527 528 rhash_addr_tbl = kzalloc_obj(*ab->rhead_sta_addr); 529 if (!rhash_addr_tbl) 530 return -ENOMEM; 531 532 param = &ab->rhash_sta_addr_param; 533 534 param->key_offset = offsetof(struct ath12k_link_sta, addr); 535 param->head_offset = offsetof(struct ath12k_link_sta, rhash_addr); 536 param->key_len = sizeof_field(struct ath12k_link_sta, addr); 537 param->automatic_shrinking = true; 538 param->nelem_hint = ab->num_radios * ath12k_core_get_max_peers_per_radio(ab); 539 540 ret = rhashtable_init(rhash_addr_tbl, param); 541 if (ret) { 542 ath12k_warn(ab, "failed to init peer addr rhash table %d\n", 543 ret); 544 goto err_free; 545 } 546 547 ab->rhead_sta_addr = rhash_addr_tbl; 548 549 return 0; 550 551 err_free: 552 kfree(rhash_addr_tbl); 553 554 return ret; 555 } 556 557 void ath12k_link_sta_rhash_tbl_destroy(struct ath12k_base *ab) 558 { 559 if (!ab->rhead_sta_addr) 560 return; 561 562 rhashtable_destroy(ab->rhead_sta_addr); 563 kfree(ab->rhead_sta_addr); 564 ab->rhead_sta_addr = NULL; 565 } 566 567 struct ath12k_link_sta *ath12k_link_sta_find_by_addr(struct ath12k_base *ab, 568 const u8 *addr) 569 { 570 lockdep_assert_held(&ab->base_lock); 571 572 return rhashtable_lookup_fast(ab->rhead_sta_addr, addr, 573 ab->rhash_sta_addr_param); 574 } 575