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
ath12k_peer_delete_wait_register(struct ath12k * ar,struct ath12k_peer_delete_wait * wait,u32 vdev_id,const u8 * addr)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
ath12k_peer_delete_wait_unregister(struct ath12k * ar,struct ath12k_peer_delete_wait * wait)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
ath12k_peer_delete_resp_signal(struct ath12k * ar,u32 vdev_id,const u8 * addr)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
ath12k_peer_delete_wait_flush(struct ath12k * ar)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
ath12k_wait_for_dp_link_peer_common(struct ath12k_base * ab,int vdev_id,const u8 * addr,bool expect_mapped)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
ath12k_peer_cleanup(struct ath12k * ar,u32 vdev_id)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
ath12k_wait_for_peer_deleted(struct ath12k * ar,int vdev_id,const u8 * addr)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
ath12k_wait_for_peer_delete_done(struct ath12k * ar,struct ath12k_peer_delete_wait * wait)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
ath12k_peer_delete_send(struct ath12k * ar,u32 vdev_id,const u8 * addr)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
ath12k_peer_delete(struct ath12k * ar,u32 vdev_id,u8 * addr)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
ath12k_wait_for_peer_created(struct ath12k * ar,int vdev_id,const u8 * addr)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
ath12k_peer_create(struct ath12k * ar,struct ath12k_link_vif * arvif,struct ieee80211_sta * sta,struct ath12k_wmi_peer_create_arg * arg)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
ath12k_peer_ml_alloc(struct ath12k_hw * ah)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
ath12k_peer_ml_free(struct ath12k_hw * ah,struct ath12k_sta * ahsta)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
ath12k_peer_mlo_link_peers_delete(struct ath12k_vif * ahvif,struct ath12k_sta * ahsta)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
ath12k_link_sta_rhash_insert(struct ath12k_base * ab,struct ath12k_link_sta * arsta)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
ath12k_link_sta_rhash_remove(struct ath12k_base * ab,struct ath12k_link_sta * arsta)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
ath12k_link_sta_rhash_add(struct ath12k_base * ab,struct ath12k_link_sta * arsta)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
ath12k_link_sta_rhash_delete(struct ath12k_base * ab,struct ath12k_link_sta * arsta)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
ath12k_link_sta_rhash_tbl_init(struct ath12k_base * ab)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
ath12k_link_sta_rhash_tbl_destroy(struct ath12k_base * ab)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
ath12k_link_sta_find_by_addr(struct ath12k_base * ab,const u8 * addr)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