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 "dp_peer.h"
10 #include "htc.h"
11 #include "dp_htt.h"
12 #include "debugfs_htt_stats.h"
13 #include "debugfs.h"
14
ath12k_dp_htt_htc_tx_complete(struct ath12k_base * ab,struct sk_buff * skb)15 static void ath12k_dp_htt_htc_tx_complete(struct ath12k_base *ab,
16 struct sk_buff *skb)
17 {
18 dev_kfree_skb_any(skb);
19 }
20
ath12k_dp_htt_connect(struct ath12k_dp * dp)21 int ath12k_dp_htt_connect(struct ath12k_dp *dp)
22 {
23 struct ath12k_htc_svc_conn_req conn_req = {};
24 struct ath12k_htc_svc_conn_resp conn_resp = {};
25 int status;
26
27 conn_req.ep_ops.ep_tx_complete = ath12k_dp_htt_htc_tx_complete;
28 conn_req.ep_ops.ep_rx_complete = ath12k_dp_htt_htc_t2h_msg_handler;
29
30 /* connect to control service */
31 conn_req.service_id = ATH12K_HTC_SVC_ID_HTT_DATA_MSG;
32
33 status = ath12k_htc_connect_service(&dp->ab->htc, &conn_req,
34 &conn_resp);
35
36 if (status)
37 return status;
38
39 dp->eid = conn_resp.eid;
40
41 return 0;
42 }
43
ath12k_get_ppdu_user_index(struct htt_ppdu_stats * ppdu_stats,u16 peer_id)44 static int ath12k_get_ppdu_user_index(struct htt_ppdu_stats *ppdu_stats,
45 u16 peer_id)
46 {
47 int i;
48
49 for (i = 0; i < HTT_PPDU_STATS_MAX_USERS - 1; i++) {
50 if (ppdu_stats->user_stats[i].is_valid_peer_id) {
51 if (peer_id == ppdu_stats->user_stats[i].peer_id)
52 return i;
53 } else {
54 return i;
55 }
56 }
57
58 return -EINVAL;
59 }
60
ath12k_htt_tlv_ppdu_stats_parse(struct ath12k_base * ab,u16 tag,u16 len,const void * ptr,void * data)61 static int ath12k_htt_tlv_ppdu_stats_parse(struct ath12k_base *ab,
62 u16 tag, u16 len, const void *ptr,
63 void *data)
64 {
65 const struct htt_ppdu_stats_usr_cmpltn_ack_ba_status *ba_status;
66 const struct htt_ppdu_stats_usr_cmpltn_cmn *cmplt_cmn;
67 const struct htt_ppdu_stats_user_rate *user_rate;
68 struct htt_ppdu_stats_info *ppdu_info;
69 struct htt_ppdu_user_stats *user_stats;
70 int cur_user;
71 u16 peer_id;
72
73 ppdu_info = data;
74
75 switch (tag) {
76 case HTT_PPDU_STATS_TAG_COMMON:
77 if (len < sizeof(struct htt_ppdu_stats_common)) {
78 ath12k_warn(ab, "Invalid len %d for the tag 0x%x\n",
79 len, tag);
80 return -EINVAL;
81 }
82 memcpy(&ppdu_info->ppdu_stats.common, ptr,
83 sizeof(struct htt_ppdu_stats_common));
84 break;
85 case HTT_PPDU_STATS_TAG_USR_RATE:
86 if (len < sizeof(struct htt_ppdu_stats_user_rate)) {
87 ath12k_warn(ab, "Invalid len %d for the tag 0x%x\n",
88 len, tag);
89 return -EINVAL;
90 }
91 user_rate = ptr;
92 peer_id = le16_to_cpu(user_rate->sw_peer_id);
93 cur_user = ath12k_get_ppdu_user_index(&ppdu_info->ppdu_stats,
94 peer_id);
95 if (cur_user < 0)
96 return -EINVAL;
97 user_stats = &ppdu_info->ppdu_stats.user_stats[cur_user];
98 user_stats->peer_id = peer_id;
99 user_stats->is_valid_peer_id = true;
100 memcpy(&user_stats->rate, ptr,
101 sizeof(struct htt_ppdu_stats_user_rate));
102 user_stats->tlv_flags |= BIT(tag);
103 break;
104 case HTT_PPDU_STATS_TAG_USR_COMPLTN_COMMON:
105 if (len < sizeof(struct htt_ppdu_stats_usr_cmpltn_cmn)) {
106 ath12k_warn(ab, "Invalid len %d for the tag 0x%x\n",
107 len, tag);
108 return -EINVAL;
109 }
110
111 cmplt_cmn = ptr;
112 peer_id = le16_to_cpu(cmplt_cmn->sw_peer_id);
113 cur_user = ath12k_get_ppdu_user_index(&ppdu_info->ppdu_stats,
114 peer_id);
115 if (cur_user < 0)
116 return -EINVAL;
117 user_stats = &ppdu_info->ppdu_stats.user_stats[cur_user];
118 user_stats->peer_id = peer_id;
119 user_stats->is_valid_peer_id = true;
120 memcpy(&user_stats->cmpltn_cmn, ptr,
121 sizeof(struct htt_ppdu_stats_usr_cmpltn_cmn));
122 user_stats->tlv_flags |= BIT(tag);
123 break;
124 case HTT_PPDU_STATS_TAG_USR_COMPLTN_ACK_BA_STATUS:
125 if (len <
126 sizeof(struct htt_ppdu_stats_usr_cmpltn_ack_ba_status)) {
127 ath12k_warn(ab, "Invalid len %d for the tag 0x%x\n",
128 len, tag);
129 return -EINVAL;
130 }
131
132 ba_status = ptr;
133 peer_id = le16_to_cpu(ba_status->sw_peer_id);
134 cur_user = ath12k_get_ppdu_user_index(&ppdu_info->ppdu_stats,
135 peer_id);
136 if (cur_user < 0)
137 return -EINVAL;
138 user_stats = &ppdu_info->ppdu_stats.user_stats[cur_user];
139 user_stats->peer_id = peer_id;
140 user_stats->is_valid_peer_id = true;
141 memcpy(&user_stats->ack_ba, ptr,
142 sizeof(struct htt_ppdu_stats_usr_cmpltn_ack_ba_status));
143 user_stats->tlv_flags |= BIT(tag);
144 break;
145 }
146 return 0;
147 }
148
ath12k_dp_htt_tlv_iter(struct ath12k_base * ab,const void * ptr,size_t len,int (* iter)(struct ath12k_base * ab,u16 tag,u16 len,const void * ptr,void * data),void * data)149 int ath12k_dp_htt_tlv_iter(struct ath12k_base *ab, const void *ptr, size_t len,
150 int (*iter)(struct ath12k_base *ab, u16 tag, u16 len,
151 const void *ptr, void *data),
152 void *data)
153 {
154 const struct htt_tlv *tlv;
155 const void *begin = ptr;
156 u16 tlv_tag, tlv_len;
157 int ret = -EINVAL;
158
159 while (len > 0) {
160 if (len < sizeof(*tlv)) {
161 ath12k_err(ab, "htt tlv parse failure at byte %zd (%zu bytes left, %zu expected)\n",
162 ptr - begin, len, sizeof(*tlv));
163 return -EINVAL;
164 }
165 tlv = (struct htt_tlv *)ptr;
166 tlv_tag = le32_get_bits(tlv->header, HTT_TLV_TAG);
167 tlv_len = le32_get_bits(tlv->header, HTT_TLV_LEN);
168 ptr += sizeof(*tlv);
169 len -= sizeof(*tlv);
170
171 if (tlv_len > len) {
172 ath12k_err(ab, "htt tlv parse failure of tag %u at byte %zd (%zu bytes left, %u expected)\n",
173 tlv_tag, ptr - begin, len, tlv_len);
174 return -EINVAL;
175 }
176 ret = iter(ab, tlv_tag, tlv_len, ptr, data);
177 if (ret == -ENOMEM)
178 return ret;
179
180 ptr += tlv_len;
181 len -= tlv_len;
182 }
183 return 0;
184 }
185
186 static void
ath12k_update_per_peer_tx_stats(struct ath12k_pdev_dp * dp_pdev,struct htt_ppdu_stats * ppdu_stats,u8 user)187 ath12k_update_per_peer_tx_stats(struct ath12k_pdev_dp *dp_pdev,
188 struct htt_ppdu_stats *ppdu_stats, u8 user)
189 {
190 struct ath12k_dp *dp = dp_pdev->dp;
191 struct ath12k_base *ab = dp->ab;
192 struct ath12k_dp_link_peer *peer;
193 struct htt_ppdu_stats_user_rate *user_rate;
194 struct ath12k_per_peer_tx_stats *peer_stats = &dp_pdev->peer_tx_stats;
195 struct htt_ppdu_user_stats *usr_stats = &ppdu_stats->user_stats[user];
196 struct htt_ppdu_stats_common *common = &ppdu_stats->common;
197 int ret;
198 u8 flags, mcs, nss, bw, sgi, dcm, ppdu_type, rate_idx = 0;
199 u32 v, succ_bytes = 0;
200 u16 tones, rate = 0, succ_pkts = 0;
201 u32 tx_duration = 0;
202 u8 tid = HTT_PPDU_STATS_NON_QOS_TID;
203 u16 tx_retry_failed = 0, tx_retry_count = 0;
204 bool is_ampdu = false, is_ofdma;
205
206 if (!(usr_stats->tlv_flags & BIT(HTT_PPDU_STATS_TAG_USR_RATE)))
207 return;
208
209 if (usr_stats->tlv_flags & BIT(HTT_PPDU_STATS_TAG_USR_COMPLTN_COMMON))
210 is_ampdu =
211 HTT_USR_CMPLTN_IS_AMPDU(usr_stats->cmpltn_cmn.flags);
212
213 if (usr_stats->tlv_flags &
214 BIT(HTT_PPDU_STATS_TAG_USR_COMPLTN_ACK_BA_STATUS)) {
215 succ_bytes = le32_to_cpu(usr_stats->ack_ba.success_bytes);
216 succ_pkts = le32_get_bits(usr_stats->ack_ba.info,
217 HTT_PPDU_STATS_ACK_BA_INFO_NUM_MSDU_M);
218 tid = le32_get_bits(usr_stats->ack_ba.info,
219 HTT_PPDU_STATS_ACK_BA_INFO_TID_NUM);
220
221 if (usr_stats->tlv_flags & BIT(HTT_PPDU_STATS_TAG_USR_COMPLTN_COMMON)) {
222 tx_retry_failed =
223 __le16_to_cpu(usr_stats->cmpltn_cmn.mpdu_tried) -
224 __le16_to_cpu(usr_stats->cmpltn_cmn.mpdu_success);
225 tx_retry_count =
226 HTT_USR_CMPLTN_LONG_RETRY(usr_stats->cmpltn_cmn.flags) +
227 HTT_USR_CMPLTN_SHORT_RETRY(usr_stats->cmpltn_cmn.flags);
228 }
229
230 if (common->fes_duration_us)
231 tx_duration = le32_to_cpu(common->fes_duration_us);
232 }
233
234 user_rate = &usr_stats->rate;
235 flags = HTT_USR_RATE_PREAMBLE(user_rate->rate_flags);
236 bw = HTT_USR_RATE_BW(user_rate->rate_flags) - 2;
237 nss = HTT_USR_RATE_NSS(user_rate->rate_flags) + 1;
238 mcs = HTT_USR_RATE_MCS(user_rate->rate_flags);
239 sgi = HTT_USR_RATE_GI(user_rate->rate_flags);
240 dcm = HTT_USR_RATE_DCM(user_rate->rate_flags);
241
242 ppdu_type = HTT_USR_RATE_PPDU_TYPE(user_rate->info1);
243 is_ofdma = (ppdu_type == HTT_PPDU_STATS_PPDU_TYPE_MU_OFDMA) ||
244 (ppdu_type == HTT_PPDU_STATS_PPDU_TYPE_MU_MIMO_OFDMA);
245
246 /* Note: If host configured fixed rates and in some other special
247 * cases, the broadcast/management frames are sent in different rates.
248 * Firmware rate's control to be skipped for this?
249 */
250
251 if (flags == WMI_RATE_PREAMBLE_HE && mcs > ATH12K_HE_MCS_MAX) {
252 ath12k_warn(ab, "Invalid HE mcs %d peer stats", mcs);
253 return;
254 }
255
256 if (flags == WMI_RATE_PREAMBLE_VHT && mcs > ATH12K_VHT_MCS_MAX) {
257 ath12k_warn(ab, "Invalid VHT mcs %d peer stats", mcs);
258 return;
259 }
260
261 if (flags == WMI_RATE_PREAMBLE_HT && (mcs > ATH12K_HT_MCS_MAX || nss < 1)) {
262 ath12k_warn(ab, "Invalid HT mcs %d nss %d peer stats",
263 mcs, nss);
264 return;
265 }
266
267 if (flags == WMI_RATE_PREAMBLE_CCK || flags == WMI_RATE_PREAMBLE_OFDM) {
268 ret = ath12k_mac_hw_ratecode_to_legacy_rate(mcs,
269 flags,
270 &rate_idx,
271 &rate);
272 if (ret < 0)
273 return;
274 }
275
276 rcu_read_lock();
277 peer = ath12k_dp_link_peer_find_by_peerid(dp_pdev, usr_stats->peer_id);
278
279 if (!peer || !peer->sta) {
280 rcu_read_unlock();
281 return;
282 }
283
284 spin_lock_bh(&dp->dp_lock);
285
286 memset(&peer->txrate, 0, sizeof(peer->txrate));
287
288 peer->txrate.bw = ath12k_mac_bw_to_mac80211_bw(bw);
289
290 switch (flags) {
291 case WMI_RATE_PREAMBLE_OFDM:
292 peer->txrate.legacy = rate;
293 break;
294 case WMI_RATE_PREAMBLE_CCK:
295 peer->txrate.legacy = rate;
296 break;
297 case WMI_RATE_PREAMBLE_HT:
298 peer->txrate.mcs = mcs + 8 * (nss - 1);
299 peer->txrate.flags = RATE_INFO_FLAGS_MCS;
300 if (sgi)
301 peer->txrate.flags |= RATE_INFO_FLAGS_SHORT_GI;
302 break;
303 case WMI_RATE_PREAMBLE_VHT:
304 peer->txrate.mcs = mcs;
305 peer->txrate.flags = RATE_INFO_FLAGS_VHT_MCS;
306 if (sgi)
307 peer->txrate.flags |= RATE_INFO_FLAGS_SHORT_GI;
308 break;
309 case WMI_RATE_PREAMBLE_HE:
310 peer->txrate.mcs = mcs;
311 peer->txrate.flags = RATE_INFO_FLAGS_HE_MCS;
312 peer->txrate.he_dcm = dcm;
313 peer->txrate.he_gi = ath12k_he_gi_to_nl80211_he_gi(sgi);
314 tones = le16_to_cpu(user_rate->ru_end) -
315 le16_to_cpu(user_rate->ru_start) + 1;
316 v = ath12k_he_ru_tones_to_nl80211_he_ru_alloc(tones);
317 peer->txrate.he_ru_alloc = v;
318 if (is_ofdma)
319 peer->txrate.bw = RATE_INFO_BW_HE_RU;
320 break;
321 case WMI_RATE_PREAMBLE_EHT:
322 peer->txrate.mcs = mcs;
323 peer->txrate.flags = RATE_INFO_FLAGS_EHT_MCS;
324 peer->txrate.he_dcm = dcm;
325 peer->txrate.eht_gi = ath12k_mac_eht_gi_to_nl80211_eht_gi(sgi);
326 tones = le16_to_cpu(user_rate->ru_end) -
327 le16_to_cpu(user_rate->ru_start) + 1;
328 v = ath12k_mac_eht_ru_tones_to_nl80211_eht_ru_alloc(tones);
329 peer->txrate.eht_ru_alloc = v;
330 if (is_ofdma)
331 peer->txrate.bw = RATE_INFO_BW_EHT_RU;
332 break;
333 }
334
335 peer->tx_retry_failed += tx_retry_failed;
336 peer->tx_retry_count += tx_retry_count;
337 peer->txrate.nss = nss;
338 peer->tx_duration += tx_duration;
339 memcpy(&peer->last_txrate, &peer->txrate, sizeof(struct rate_info));
340
341 spin_unlock_bh(&dp->dp_lock);
342
343 /* PPDU stats reported for mgmt packet doesn't have valid tx bytes.
344 * So skip peer stats update for mgmt packets.
345 */
346 if (tid < HTT_PPDU_STATS_NON_QOS_TID) {
347 memset(peer_stats, 0, sizeof(*peer_stats));
348 peer_stats->succ_pkts = succ_pkts;
349 peer_stats->succ_bytes = succ_bytes;
350 peer_stats->is_ampdu = is_ampdu;
351 peer_stats->duration = tx_duration;
352 peer_stats->ba_fails =
353 HTT_USR_CMPLTN_LONG_RETRY(usr_stats->cmpltn_cmn.flags) +
354 HTT_USR_CMPLTN_SHORT_RETRY(usr_stats->cmpltn_cmn.flags);
355 }
356
357 rcu_read_unlock();
358 }
359
ath12k_htt_update_ppdu_stats(struct ath12k_pdev_dp * dp_pdev,struct htt_ppdu_stats * ppdu_stats)360 static void ath12k_htt_update_ppdu_stats(struct ath12k_pdev_dp *dp_pdev,
361 struct htt_ppdu_stats *ppdu_stats)
362 {
363 u8 user;
364
365 for (user = 0; user < HTT_PPDU_STATS_MAX_USERS - 1; user++)
366 ath12k_update_per_peer_tx_stats(dp_pdev, ppdu_stats, user);
367 }
368
369 static
ath12k_dp_htt_get_ppdu_desc(struct ath12k_pdev_dp * dp_pdev,u32 ppdu_id)370 struct htt_ppdu_stats_info *ath12k_dp_htt_get_ppdu_desc(struct ath12k_pdev_dp *dp_pdev,
371 u32 ppdu_id)
372 {
373 struct htt_ppdu_stats_info *ppdu_info;
374
375 lockdep_assert_held(&dp_pdev->ppdu_list_lock);
376 if (!list_empty(&dp_pdev->ppdu_stats_info)) {
377 list_for_each_entry(ppdu_info, &dp_pdev->ppdu_stats_info, list) {
378 if (ppdu_info->ppdu_id == ppdu_id)
379 return ppdu_info;
380 }
381
382 if (dp_pdev->ppdu_stat_list_depth > HTT_PPDU_DESC_MAX_DEPTH) {
383 ppdu_info = list_first_entry(&dp_pdev->ppdu_stats_info,
384 typeof(*ppdu_info), list);
385 list_del(&ppdu_info->list);
386 dp_pdev->ppdu_stat_list_depth--;
387 ath12k_htt_update_ppdu_stats(dp_pdev, &ppdu_info->ppdu_stats);
388 kfree(ppdu_info);
389 }
390 }
391
392 ppdu_info = kzalloc_obj(*ppdu_info, GFP_ATOMIC);
393 if (!ppdu_info)
394 return NULL;
395
396 list_add_tail(&ppdu_info->list, &dp_pdev->ppdu_stats_info);
397 dp_pdev->ppdu_stat_list_depth++;
398
399 return ppdu_info;
400 }
401
ath12k_copy_to_delay_stats(struct ath12k_dp_link_peer * peer,struct htt_ppdu_user_stats * usr_stats)402 static void ath12k_copy_to_delay_stats(struct ath12k_dp_link_peer *peer,
403 struct htt_ppdu_user_stats *usr_stats)
404 {
405 peer->ppdu_stats_delayba.sw_peer_id = le16_to_cpu(usr_stats->rate.sw_peer_id);
406 peer->ppdu_stats_delayba.info0 = le32_to_cpu(usr_stats->rate.info0);
407 peer->ppdu_stats_delayba.ru_end = le16_to_cpu(usr_stats->rate.ru_end);
408 peer->ppdu_stats_delayba.ru_start = le16_to_cpu(usr_stats->rate.ru_start);
409 peer->ppdu_stats_delayba.info1 = le32_to_cpu(usr_stats->rate.info1);
410 peer->ppdu_stats_delayba.rate_flags = le32_to_cpu(usr_stats->rate.rate_flags);
411 peer->ppdu_stats_delayba.resp_rate_flags =
412 le32_to_cpu(usr_stats->rate.resp_rate_flags);
413
414 peer->delayba_flag = true;
415 }
416
ath12k_copy_to_bar(struct ath12k_dp_link_peer * peer,struct htt_ppdu_user_stats * usr_stats)417 static void ath12k_copy_to_bar(struct ath12k_dp_link_peer *peer,
418 struct htt_ppdu_user_stats *usr_stats)
419 {
420 usr_stats->rate.sw_peer_id = cpu_to_le16(peer->ppdu_stats_delayba.sw_peer_id);
421 usr_stats->rate.info0 = cpu_to_le32(peer->ppdu_stats_delayba.info0);
422 usr_stats->rate.ru_end = cpu_to_le16(peer->ppdu_stats_delayba.ru_end);
423 usr_stats->rate.ru_start = cpu_to_le16(peer->ppdu_stats_delayba.ru_start);
424 usr_stats->rate.info1 = cpu_to_le32(peer->ppdu_stats_delayba.info1);
425 usr_stats->rate.rate_flags = cpu_to_le32(peer->ppdu_stats_delayba.rate_flags);
426 usr_stats->rate.resp_rate_flags =
427 cpu_to_le32(peer->ppdu_stats_delayba.resp_rate_flags);
428
429 peer->delayba_flag = false;
430 }
431
ath12k_htt_pull_ppdu_stats(struct ath12k_base * ab,struct sk_buff * skb)432 static int ath12k_htt_pull_ppdu_stats(struct ath12k_base *ab,
433 struct sk_buff *skb)
434 {
435 struct ath12k_dp *dp = ath12k_ab_to_dp(ab);
436 struct ath12k_htt_ppdu_stats_msg *msg;
437 struct htt_ppdu_stats_info *ppdu_info;
438 struct ath12k_dp_link_peer *peer = NULL;
439 struct htt_ppdu_user_stats *usr_stats = NULL;
440 u32 peer_id = 0;
441 struct ath12k_pdev_dp *dp_pdev;
442 int ret, i;
443 u8 pdev_id, pdev_idx;
444 u32 ppdu_id, len;
445
446 msg = (struct ath12k_htt_ppdu_stats_msg *)skb->data;
447 len = le32_get_bits(msg->info, HTT_T2H_PPDU_STATS_INFO_PAYLOAD_SIZE);
448 if (len > (skb->len - struct_size(msg, data, 0))) {
449 ath12k_warn(ab,
450 "HTT PPDU STATS event has unexpected payload size %u, should be smaller than %u\n",
451 len, skb->len);
452 return -EINVAL;
453 }
454
455 pdev_id = le32_get_bits(msg->info, HTT_T2H_PPDU_STATS_INFO_PDEV_ID);
456 ppdu_id = le32_to_cpu(msg->ppdu_id);
457
458 pdev_idx = DP_HW2SW_MACID(pdev_id);
459 if (pdev_idx >= MAX_RADIOS) {
460 ath12k_warn(ab, "HTT PPDU STATS invalid pdev id %u", pdev_id);
461 return -EINVAL;
462 }
463
464 rcu_read_lock();
465
466 dp_pdev = ath12k_dp_to_pdev_dp(dp, pdev_idx);
467 if (!dp_pdev) {
468 ret = -EINVAL;
469 goto exit;
470 }
471
472 spin_lock_bh(&dp_pdev->ppdu_list_lock);
473 ppdu_info = ath12k_dp_htt_get_ppdu_desc(dp_pdev, ppdu_id);
474 if (!ppdu_info) {
475 spin_unlock_bh(&dp_pdev->ppdu_list_lock);
476 ret = -EINVAL;
477 goto exit;
478 }
479
480 ppdu_info->ppdu_id = ppdu_id;
481 ret = ath12k_dp_htt_tlv_iter(ab, msg->data, len,
482 ath12k_htt_tlv_ppdu_stats_parse,
483 (void *)ppdu_info);
484 if (ret) {
485 spin_unlock_bh(&dp_pdev->ppdu_list_lock);
486 ath12k_warn(ab, "Failed to parse tlv %d\n", ret);
487 goto exit;
488 }
489
490 if (ppdu_info->ppdu_stats.common.num_users >= HTT_PPDU_STATS_MAX_USERS) {
491 spin_unlock_bh(&dp_pdev->ppdu_list_lock);
492 ath12k_warn(ab,
493 "HTT PPDU STATS event has unexpected num_users %u, should be smaller than %u\n",
494 ppdu_info->ppdu_stats.common.num_users,
495 HTT_PPDU_STATS_MAX_USERS);
496 ret = -EINVAL;
497 goto exit;
498 }
499
500 /* back up data rate tlv for all peers */
501 if (ppdu_info->frame_type == HTT_STATS_PPDU_FTYPE_DATA &&
502 (ppdu_info->tlv_bitmap & (1 << HTT_PPDU_STATS_TAG_USR_COMMON)) &&
503 ppdu_info->delay_ba) {
504 for (i = 0; i < ppdu_info->ppdu_stats.common.num_users; i++) {
505 peer_id = ppdu_info->ppdu_stats.user_stats[i].peer_id;
506 peer = ath12k_dp_link_peer_find_by_peerid(dp_pdev, peer_id);
507 if (!peer)
508 continue;
509
510 usr_stats = &ppdu_info->ppdu_stats.user_stats[i];
511 if (usr_stats->delay_ba)
512 ath12k_copy_to_delay_stats(peer, usr_stats);
513 }
514 }
515
516 /* restore all peers' data rate tlv to mu-bar tlv */
517 if (ppdu_info->frame_type == HTT_STATS_PPDU_FTYPE_BAR &&
518 (ppdu_info->tlv_bitmap & (1 << HTT_PPDU_STATS_TAG_USR_COMMON))) {
519 for (i = 0; i < ppdu_info->bar_num_users; i++) {
520 peer_id = ppdu_info->ppdu_stats.user_stats[i].peer_id;
521 peer = ath12k_dp_link_peer_find_by_peerid(dp_pdev, peer_id);
522 if (!peer)
523 continue;
524
525 usr_stats = &ppdu_info->ppdu_stats.user_stats[i];
526 if (peer->delayba_flag)
527 ath12k_copy_to_bar(peer, usr_stats);
528 }
529 }
530
531 spin_unlock_bh(&dp_pdev->ppdu_list_lock);
532
533 exit:
534 rcu_read_unlock();
535
536 return ret;
537 }
538
ath12k_htt_mlo_offset_event_handler(struct ath12k_base * ab,struct sk_buff * skb)539 static void ath12k_htt_mlo_offset_event_handler(struct ath12k_base *ab,
540 struct sk_buff *skb)
541 {
542 struct ath12k_htt_mlo_offset_msg *msg;
543 struct ath12k_pdev *pdev;
544 struct ath12k *ar;
545 u8 pdev_id;
546
547 msg = (struct ath12k_htt_mlo_offset_msg *)skb->data;
548 pdev_id = u32_get_bits(__le32_to_cpu(msg->info),
549 HTT_T2H_MLO_OFFSET_INFO_PDEV_ID);
550
551 rcu_read_lock();
552 ar = ath12k_mac_get_ar_by_pdev_id(ab, pdev_id);
553 if (!ar) {
554 /* It is possible that the ar is not yet active (started).
555 * The above function will only look for the active pdev
556 * and hence %NULL return is possible. Just silently
557 * discard this message
558 */
559 goto exit;
560 }
561
562 spin_lock_bh(&ar->data_lock);
563 pdev = ar->pdev;
564
565 pdev->timestamp.info = __le32_to_cpu(msg->info);
566 pdev->timestamp.sync_timestamp_lo_us = __le32_to_cpu(msg->sync_timestamp_lo_us);
567 pdev->timestamp.sync_timestamp_hi_us = __le32_to_cpu(msg->sync_timestamp_hi_us);
568 pdev->timestamp.mlo_offset_lo = __le32_to_cpu(msg->mlo_offset_lo);
569 pdev->timestamp.mlo_offset_hi = __le32_to_cpu(msg->mlo_offset_hi);
570 pdev->timestamp.mlo_offset_clks = __le32_to_cpu(msg->mlo_offset_clks);
571 pdev->timestamp.mlo_comp_clks = __le32_to_cpu(msg->mlo_comp_clks);
572 pdev->timestamp.mlo_comp_timer = __le32_to_cpu(msg->mlo_comp_timer);
573
574 spin_unlock_bh(&ar->data_lock);
575 exit:
576 rcu_read_unlock();
577 }
578
ath12k_dp_htt_mlo_peer_map_handler(struct ath12k_base * ab,struct sk_buff * skb)579 static void ath12k_dp_htt_mlo_peer_map_handler(struct ath12k_base *ab,
580 struct sk_buff *skb)
581 {
582 struct htt_resp_msg *resp = (struct htt_resp_msg *)skb->data;
583 struct htt_t2h_mlo_peer_map_event *ev = &resp->mlo_peer_map_ev;
584 u16 raw_peer_id, peer_id, addr_h16;
585 u8 peer_addr[ETH_ALEN];
586 int ret;
587
588 if (skb->len < sizeof(*ev)) {
589 ath12k_warn(ab, "unexpected htt mlo peer map event len %u\n",
590 skb->len);
591 return;
592 }
593
594 raw_peer_id = le32_get_bits(ev->info0,
595 HTT_T2H_MLO_PEER_MAP_INFO0_MLO_PEER_ID);
596 peer_id = raw_peer_id | ATH12K_PEER_ML_ID_VALID;
597
598 addr_h16 = le32_get_bits(ev->info1,
599 HTT_T2H_MLO_PEER_MAP_INFO1_MAC_ADDR_H16);
600 ath12k_dp_get_mac_addr(le32_to_cpu(ev->mac_addr_l32), addr_h16,
601 peer_addr);
602
603 ath12k_dbg(ab, ATH12K_DBG_DP_HTT, "htt mlo peer map peer %pM id %u\n",
604 peer_addr, peer_id);
605
606 /*
607 * Fix up the dp_peer entry created with ATH12K_MLO_PEER_ID_PENDING
608 * earlier; on chips with host_alloc_ml_id == false this is the only
609 * point at which the host learns the firmware-assigned ID. Chips
610 * that allocate the ID on the host also receive this event but the
611 * firmware-reported ID matches the host-allocated one, so there is
612 * nothing to fix up.
613 */
614 if (!ab->hw_params->host_alloc_ml_id) {
615 ret = ath12k_dp_peer_fixup_peer_id(ab, peer_addr,
616 peer_id);
617 if (ret)
618 ath12k_warn(ab,
619 "failed to fix up peer id %u for dp peer %pM: %d\n",
620 peer_id, peer_addr, ret);
621 }
622 }
623
ath12k_dp_htt_htc_t2h_msg_handler(struct ath12k_base * ab,struct sk_buff * skb)624 void ath12k_dp_htt_htc_t2h_msg_handler(struct ath12k_base *ab,
625 struct sk_buff *skb)
626 {
627 struct ath12k_dp *dp = ath12k_ab_to_dp(ab);
628 struct htt_resp_msg *resp = (struct htt_resp_msg *)skb->data;
629 enum htt_t2h_msg_type type;
630 u16 peer_id;
631 u8 vdev_id;
632 u8 mac_addr[ETH_ALEN];
633 u16 peer_mac_h16;
634 u16 ast_hash = 0;
635 u16 hw_peer_id;
636
637 type = le32_get_bits(resp->version_msg.version, HTT_T2H_MSG_TYPE);
638
639 ath12k_dbg(ab, ATH12K_DBG_DP_HTT, "dp_htt rx msg type :0x%0x\n", type);
640
641 switch (type) {
642 case HTT_T2H_MSG_TYPE_VERSION_CONF:
643 dp->htt_tgt_ver_major = le32_get_bits(resp->version_msg.version,
644 HTT_T2H_VERSION_CONF_MAJOR);
645 dp->htt_tgt_ver_minor = le32_get_bits(resp->version_msg.version,
646 HTT_T2H_VERSION_CONF_MINOR);
647 complete(&dp->htt_tgt_version_received);
648 break;
649 /* TODO: remove unused peer map versions after testing */
650 case HTT_T2H_MSG_TYPE_PEER_MAP:
651 vdev_id = le32_get_bits(resp->peer_map_ev.info,
652 HTT_T2H_PEER_MAP_INFO_VDEV_ID);
653 peer_id = le32_get_bits(resp->peer_map_ev.info,
654 HTT_T2H_PEER_MAP_INFO_PEER_ID);
655 peer_mac_h16 = le32_get_bits(resp->peer_map_ev.info1,
656 HTT_T2H_PEER_MAP_INFO1_MAC_ADDR_H16);
657 ath12k_dp_get_mac_addr(le32_to_cpu(resp->peer_map_ev.mac_addr_l32),
658 peer_mac_h16, mac_addr);
659 ath12k_dp_link_peer_map_event(ab, vdev_id, peer_id, mac_addr, 0, 0);
660 break;
661 case HTT_T2H_MSG_TYPE_PEER_MAP2:
662 vdev_id = le32_get_bits(resp->peer_map_ev.info,
663 HTT_T2H_PEER_MAP_INFO_VDEV_ID);
664 peer_id = le32_get_bits(resp->peer_map_ev.info,
665 HTT_T2H_PEER_MAP_INFO_PEER_ID);
666 peer_mac_h16 = le32_get_bits(resp->peer_map_ev.info1,
667 HTT_T2H_PEER_MAP_INFO1_MAC_ADDR_H16);
668 ath12k_dp_get_mac_addr(le32_to_cpu(resp->peer_map_ev.mac_addr_l32),
669 peer_mac_h16, mac_addr);
670 ast_hash = le32_get_bits(resp->peer_map_ev.info2,
671 HTT_T2H_PEER_MAP_INFO2_AST_HASH_VAL);
672 hw_peer_id = le32_get_bits(resp->peer_map_ev.info1,
673 HTT_T2H_PEER_MAP_INFO1_HW_PEER_ID);
674 ath12k_dp_link_peer_map_event(ab, vdev_id, peer_id, mac_addr, ast_hash,
675 hw_peer_id);
676 break;
677 case HTT_T2H_MSG_TYPE_PEER_MAP3:
678 vdev_id = le32_get_bits(resp->peer_map_ev.info,
679 HTT_T2H_PEER_MAP_INFO_VDEV_ID);
680 peer_id = le32_get_bits(resp->peer_map_ev.info,
681 HTT_T2H_PEER_MAP_INFO_PEER_ID);
682 peer_mac_h16 = le32_get_bits(resp->peer_map_ev.info1,
683 HTT_T2H_PEER_MAP_INFO1_MAC_ADDR_H16);
684 ath12k_dp_get_mac_addr(le32_to_cpu(resp->peer_map_ev.mac_addr_l32),
685 peer_mac_h16, mac_addr);
686 ast_hash = le32_get_bits(resp->peer_map_ev.info2,
687 HTT_T2H_PEER_MAP3_INFO2_AST_HASH_VAL);
688 hw_peer_id = le32_get_bits(resp->peer_map_ev.info2,
689 HTT_T2H_PEER_MAP3_INFO2_HW_PEER_ID);
690 ath12k_dp_link_peer_map_event(ab, vdev_id, peer_id, mac_addr, ast_hash,
691 hw_peer_id);
692 break;
693 case HTT_T2H_MSG_TYPE_PEER_UNMAP:
694 case HTT_T2H_MSG_TYPE_PEER_UNMAP2:
695 peer_id = le32_get_bits(resp->peer_unmap_ev.info,
696 HTT_T2H_PEER_UNMAP_INFO_PEER_ID);
697 ath12k_dp_link_peer_unmap_event(ab, peer_id);
698 break;
699 case HTT_T2H_MSG_TYPE_PPDU_STATS_IND:
700 ath12k_htt_pull_ppdu_stats(ab, skb);
701 break;
702 case HTT_T2H_MSG_TYPE_EXT_STATS_CONF:
703 ath12k_debugfs_htt_ext_stats_handler(ab, skb);
704 break;
705 case HTT_T2H_MSG_TYPE_MLO_TIMESTAMP_OFFSET_IND:
706 ath12k_htt_mlo_offset_event_handler(ab, skb);
707 break;
708 case HTT_T2H_MSG_TYPE_MLO_RX_PEER_MAP:
709 ath12k_dp_htt_mlo_peer_map_handler(ab, skb);
710 break;
711 default:
712 ath12k_dbg(ab, ATH12K_DBG_DP_HTT, "dp_htt event %d not handled\n",
713 type);
714 break;
715 }
716
717 dev_kfree_skb_any(skb);
718 }
719 EXPORT_SYMBOL(ath12k_dp_htt_htc_t2h_msg_handler);
720
721 static int
ath12k_dp_tx_get_ring_id_type(struct ath12k_base * ab,int mac_id,u32 ring_id,enum hal_ring_type ring_type,enum htt_srng_ring_type * htt_ring_type,enum htt_srng_ring_id * htt_ring_id)722 ath12k_dp_tx_get_ring_id_type(struct ath12k_base *ab,
723 int mac_id, u32 ring_id,
724 enum hal_ring_type ring_type,
725 enum htt_srng_ring_type *htt_ring_type,
726 enum htt_srng_ring_id *htt_ring_id)
727 {
728 int ret = 0;
729
730 switch (ring_type) {
731 case HAL_RXDMA_BUF:
732 /* for some targets, host fills rx buffer to fw and fw fills to
733 * rxbuf ring for each rxdma
734 */
735 if (!ab->hw_params->rx_mac_buf_ring) {
736 if (!(ring_id == HAL_SRNG_SW2RXDMA_BUF0 ||
737 ring_id == HAL_SRNG_SW2RXDMA_BUF1)) {
738 ret = -EINVAL;
739 }
740 *htt_ring_id = HTT_RXDMA_HOST_BUF_RING;
741 *htt_ring_type = HTT_SW_TO_HW_RING;
742 } else {
743 if (ring_id == HAL_SRNG_SW2RXDMA_BUF0) {
744 *htt_ring_id = HTT_HOST1_TO_FW_RXBUF_RING;
745 *htt_ring_type = HTT_SW_TO_SW_RING;
746 } else {
747 *htt_ring_id = HTT_RXDMA_HOST_BUF_RING;
748 *htt_ring_type = HTT_SW_TO_HW_RING;
749 }
750 }
751 break;
752 case HAL_RXDMA_DST:
753 *htt_ring_id = HTT_RXDMA_NON_MONITOR_DEST_RING;
754 *htt_ring_type = HTT_HW_TO_SW_RING;
755 break;
756 case HAL_RXDMA_MONITOR_BUF:
757 *htt_ring_id = HTT_RX_MON_HOST2MON_BUF_RING;
758 *htt_ring_type = HTT_SW_TO_HW_RING;
759 break;
760 case HAL_RXDMA_MONITOR_STATUS:
761 *htt_ring_id = HTT_RXDMA_MONITOR_STATUS_RING;
762 *htt_ring_type = HTT_SW_TO_HW_RING;
763 break;
764 case HAL_RXDMA_MONITOR_DST:
765 *htt_ring_id = HTT_RX_MON_MON2HOST_DEST_RING;
766 *htt_ring_type = HTT_HW_TO_SW_RING;
767 break;
768 case HAL_RXDMA_MONITOR_DESC:
769 *htt_ring_id = HTT_RXDMA_MONITOR_DESC_RING;
770 *htt_ring_type = HTT_SW_TO_HW_RING;
771 break;
772 default:
773 ath12k_warn(ab, "Unsupported ring type in DP :%d\n", ring_type);
774 ret = -EINVAL;
775 }
776 return ret;
777 }
778
ath12k_dp_tx_htt_srng_setup(struct ath12k_base * ab,u32 ring_id,int mac_id,enum hal_ring_type ring_type)779 int ath12k_dp_tx_htt_srng_setup(struct ath12k_base *ab, u32 ring_id,
780 int mac_id, enum hal_ring_type ring_type)
781 {
782 struct ath12k_dp *dp = ath12k_ab_to_dp(ab);
783 struct htt_srng_setup_cmd *cmd;
784 struct hal_srng *srng = &ab->hal.srng_list[ring_id];
785 struct hal_srng_params params;
786 struct sk_buff *skb;
787 u32 ring_entry_sz;
788 int len = sizeof(*cmd);
789 dma_addr_t hp_addr, tp_addr;
790 enum htt_srng_ring_type htt_ring_type;
791 enum htt_srng_ring_id htt_ring_id;
792 int ret;
793
794 skb = ath12k_htc_alloc_skb(ab, len);
795 if (!skb)
796 return -ENOMEM;
797
798 memset(¶ms, 0, sizeof(params));
799 ath12k_hal_srng_get_params(ab, srng, ¶ms);
800
801 hp_addr = ath12k_hal_srng_get_hp_addr(ab, srng);
802 tp_addr = ath12k_hal_srng_get_tp_addr(ab, srng);
803
804 ret = ath12k_dp_tx_get_ring_id_type(ab, mac_id, ring_id,
805 ring_type, &htt_ring_type,
806 &htt_ring_id);
807 if (ret)
808 goto err_free;
809
810 skb_put(skb, len);
811 cmd = (struct htt_srng_setup_cmd *)skb->data;
812 cmd->info0 = le32_encode_bits(HTT_H2T_MSG_TYPE_SRING_SETUP,
813 HTT_SRNG_SETUP_CMD_INFO0_MSG_TYPE);
814 if (htt_ring_type == HTT_SW_TO_HW_RING ||
815 htt_ring_type == HTT_HW_TO_SW_RING)
816 cmd->info0 |= le32_encode_bits(DP_SW2HW_MACID(mac_id),
817 HTT_SRNG_SETUP_CMD_INFO0_PDEV_ID);
818 else
819 cmd->info0 |= le32_encode_bits(mac_id,
820 HTT_SRNG_SETUP_CMD_INFO0_PDEV_ID);
821 cmd->info0 |= le32_encode_bits(htt_ring_type,
822 HTT_SRNG_SETUP_CMD_INFO0_RING_TYPE);
823 cmd->info0 |= le32_encode_bits(htt_ring_id,
824 HTT_SRNG_SETUP_CMD_INFO0_RING_ID);
825
826 cmd->ring_base_addr_lo = cpu_to_le32(params.ring_base_paddr &
827 HAL_ADDR_LSB_REG_MASK);
828
829 cmd->ring_base_addr_hi = cpu_to_le32((u64)params.ring_base_paddr >>
830 HAL_ADDR_MSB_REG_SHIFT);
831
832 ret = ath12k_hal_srng_get_entrysize(ab, ring_type);
833 if (ret < 0)
834 goto err_free;
835
836 ring_entry_sz = ret;
837
838 ring_entry_sz >>= 2;
839 cmd->info1 = le32_encode_bits(ring_entry_sz,
840 HTT_SRNG_SETUP_CMD_INFO1_RING_ENTRY_SIZE);
841 cmd->info1 |= le32_encode_bits(params.num_entries * ring_entry_sz,
842 HTT_SRNG_SETUP_CMD_INFO1_RING_SIZE);
843 cmd->info1 |= le32_encode_bits(!!(params.flags & HAL_SRNG_FLAGS_MSI_SWAP),
844 HTT_SRNG_SETUP_CMD_INFO1_RING_FLAGS_MSI_SWAP);
845 cmd->info1 |= le32_encode_bits(!!(params.flags & HAL_SRNG_FLAGS_DATA_TLV_SWAP),
846 HTT_SRNG_SETUP_CMD_INFO1_RING_FLAGS_TLV_SWAP);
847 cmd->info1 |= le32_encode_bits(!!(params.flags & HAL_SRNG_FLAGS_RING_PTR_SWAP),
848 HTT_SRNG_SETUP_CMD_INFO1_RING_FLAGS_HOST_FW_SWAP);
849 if (htt_ring_type == HTT_SW_TO_HW_RING)
850 cmd->info1 |= cpu_to_le32(HTT_SRNG_SETUP_CMD_INFO1_RING_LOOP_CNT_DIS);
851
852 cmd->ring_head_off32_remote_addr_lo = cpu_to_le32(lower_32_bits(hp_addr));
853 cmd->ring_head_off32_remote_addr_hi = cpu_to_le32(upper_32_bits(hp_addr));
854
855 cmd->ring_tail_off32_remote_addr_lo = cpu_to_le32(lower_32_bits(tp_addr));
856 cmd->ring_tail_off32_remote_addr_hi = cpu_to_le32(upper_32_bits(tp_addr));
857
858 cmd->ring_msi_addr_lo = cpu_to_le32(lower_32_bits(params.msi_addr));
859 cmd->ring_msi_addr_hi = cpu_to_le32(upper_32_bits(params.msi_addr));
860 cmd->msi_data = cpu_to_le32(params.msi_data);
861
862 cmd->intr_info =
863 le32_encode_bits(params.intr_batch_cntr_thres_entries * ring_entry_sz,
864 HTT_SRNG_SETUP_CMD_INTR_INFO_BATCH_COUNTER_THRESH);
865 cmd->intr_info |=
866 le32_encode_bits(params.intr_timer_thres_us >> 3,
867 HTT_SRNG_SETUP_CMD_INTR_INFO_INTR_TIMER_THRESH);
868
869 cmd->info2 = 0;
870 if (params.flags & HAL_SRNG_FLAGS_LOW_THRESH_INTR_EN) {
871 cmd->info2 = le32_encode_bits(params.low_threshold,
872 HTT_SRNG_SETUP_CMD_INFO2_INTR_LOW_THRESH);
873 }
874
875 ath12k_dbg(ab, ATH12K_DBG_HAL,
876 "%s msi_addr_lo:0x%x, msi_addr_hi:0x%x, msi_data:0x%x\n",
877 __func__, cmd->ring_msi_addr_lo, cmd->ring_msi_addr_hi,
878 cmd->msi_data);
879
880 ath12k_dbg(ab, ATH12K_DBG_HAL,
881 "ring_id:%d, ring_type:%d, intr_info:0x%x, flags:0x%x\n",
882 ring_id, ring_type, cmd->intr_info, cmd->info2);
883
884 ret = ath12k_htc_send(&ab->htc, dp->eid, skb);
885 if (ret)
886 goto err_free;
887
888 return 0;
889
890 err_free:
891 dev_kfree_skb_any(skb);
892
893 return ret;
894 }
895
ath12k_dp_tx_htt_h2t_ver_req_msg(struct ath12k_base * ab)896 int ath12k_dp_tx_htt_h2t_ver_req_msg(struct ath12k_base *ab)
897 {
898 struct ath12k_dp *dp = ath12k_ab_to_dp(ab);
899 struct sk_buff *skb;
900 struct htt_ver_req_cmd *cmd;
901 int len = sizeof(*cmd);
902 u32 metadata_version;
903 int ret;
904
905 init_completion(&dp->htt_tgt_version_received);
906
907 skb = ath12k_htc_alloc_skb(ab, len);
908 if (!skb)
909 return -ENOMEM;
910
911 skb_put(skb, len);
912 cmd = (struct htt_ver_req_cmd *)skb->data;
913 cmd->ver_reg_info = le32_encode_bits(HTT_H2T_MSG_TYPE_VERSION_REQ,
914 HTT_OPTION_TAG);
915 metadata_version = ath12k_ftm_mode ? HTT_OPTION_TCL_METADATA_VER_V1 :
916 HTT_OPTION_TCL_METADATA_VER_V2;
917
918 cmd->tcl_metadata_version = le32_encode_bits(HTT_TAG_TCL_METADATA_VERSION,
919 HTT_OPTION_TAG) |
920 le32_encode_bits(HTT_TCL_METADATA_VER_SZ,
921 HTT_OPTION_LEN) |
922 le32_encode_bits(metadata_version,
923 HTT_OPTION_VALUE);
924
925 ret = ath12k_htc_send(&ab->htc, dp->eid, skb);
926 if (ret) {
927 dev_kfree_skb_any(skb);
928 return ret;
929 }
930
931 ret = wait_for_completion_timeout(&dp->htt_tgt_version_received,
932 HTT_TARGET_VERSION_TIMEOUT_HZ);
933 if (ret == 0) {
934 ath12k_warn(ab, "htt target version request timed out\n");
935 return -ETIMEDOUT;
936 }
937
938 if (dp->htt_tgt_ver_major != HTT_TARGET_VERSION_MAJOR) {
939 ath12k_err(ab, "unsupported htt major version %d supported version is %d\n",
940 dp->htt_tgt_ver_major, HTT_TARGET_VERSION_MAJOR);
941 return -EOPNOTSUPP;
942 }
943
944 return 0;
945 }
946
ath12k_dp_tx_htt_h2t_ppdu_stats_req(struct ath12k * ar,u32 mask)947 int ath12k_dp_tx_htt_h2t_ppdu_stats_req(struct ath12k *ar, u32 mask)
948 {
949 struct ath12k_base *ab = ar->ab;
950 struct ath12k_dp *dp = ath12k_ab_to_dp(ab);
951 struct sk_buff *skb;
952 struct htt_ppdu_stats_cfg_cmd *cmd;
953 int len = sizeof(*cmd);
954 u8 pdev_mask;
955 int ret;
956 int i;
957
958 for (i = 0; i < ab->hw_params->num_rxdma_per_pdev; i++) {
959 skb = ath12k_htc_alloc_skb(ab, len);
960 if (!skb)
961 return -ENOMEM;
962
963 skb_put(skb, len);
964 cmd = (struct htt_ppdu_stats_cfg_cmd *)skb->data;
965 cmd->msg = le32_encode_bits(HTT_H2T_MSG_TYPE_PPDU_STATS_CFG,
966 HTT_PPDU_STATS_CFG_MSG_TYPE);
967
968 pdev_mask = 1 << (i + ar->pdev_idx);
969 cmd->msg |= le32_encode_bits(pdev_mask, HTT_PPDU_STATS_CFG_PDEV_ID);
970 cmd->msg |= le32_encode_bits(mask, HTT_PPDU_STATS_CFG_TLV_TYPE_BITMASK);
971
972 ret = ath12k_htc_send(&ab->htc, dp->eid, skb);
973 if (ret) {
974 dev_kfree_skb_any(skb);
975 return ret;
976 }
977 }
978
979 return 0;
980 }
981
ath12k_dp_tx_htt_rx_filter_setup(struct ath12k_base * ab,u32 ring_id,int mac_id,enum hal_ring_type ring_type,int rx_buf_size,struct htt_rx_ring_tlv_filter * tlv_filter)982 int ath12k_dp_tx_htt_rx_filter_setup(struct ath12k_base *ab, u32 ring_id,
983 int mac_id, enum hal_ring_type ring_type,
984 int rx_buf_size,
985 struct htt_rx_ring_tlv_filter *tlv_filter)
986 {
987 struct ath12k_dp *dp = ath12k_ab_to_dp(ab);
988 struct htt_rx_ring_selection_cfg_cmd *cmd;
989 struct hal_srng *srng = &ab->hal.srng_list[ring_id];
990 struct hal_srng_params params;
991 struct sk_buff *skb;
992 int len = sizeof(*cmd);
993 enum htt_srng_ring_type htt_ring_type;
994 enum htt_srng_ring_id htt_ring_id;
995 int ret;
996
997 skb = ath12k_htc_alloc_skb(ab, len);
998 if (!skb)
999 return -ENOMEM;
1000
1001 memset(¶ms, 0, sizeof(params));
1002 ath12k_hal_srng_get_params(ab, srng, ¶ms);
1003
1004 ret = ath12k_dp_tx_get_ring_id_type(ab, mac_id, ring_id,
1005 ring_type, &htt_ring_type,
1006 &htt_ring_id);
1007 if (ret)
1008 goto err_free;
1009
1010 skb_put(skb, len);
1011 cmd = (struct htt_rx_ring_selection_cfg_cmd *)skb->data;
1012 cmd->info0 = le32_encode_bits(HTT_H2T_MSG_TYPE_RX_RING_SELECTION_CFG,
1013 HTT_RX_RING_SELECTION_CFG_CMD_INFO0_MSG_TYPE);
1014 if (htt_ring_type == HTT_SW_TO_HW_RING ||
1015 htt_ring_type == HTT_HW_TO_SW_RING)
1016 cmd->info0 |=
1017 le32_encode_bits(DP_SW2HW_MACID(mac_id),
1018 HTT_RX_RING_SELECTION_CFG_CMD_INFO0_PDEV_ID);
1019 else
1020 cmd->info0 |=
1021 le32_encode_bits(mac_id,
1022 HTT_RX_RING_SELECTION_CFG_CMD_INFO0_PDEV_ID);
1023 cmd->info0 |= le32_encode_bits(htt_ring_id,
1024 HTT_RX_RING_SELECTION_CFG_CMD_INFO0_RING_ID);
1025 cmd->info0 |= le32_encode_bits(!!(params.flags & HAL_SRNG_FLAGS_MSI_SWAP),
1026 HTT_RX_RING_SELECTION_CFG_CMD_INFO0_SS);
1027 cmd->info0 |= le32_encode_bits(!!(params.flags & HAL_SRNG_FLAGS_DATA_TLV_SWAP),
1028 HTT_RX_RING_SELECTION_CFG_CMD_INFO0_PS);
1029 cmd->info0 |= le32_encode_bits(tlv_filter->offset_valid,
1030 HTT_RX_RING_SELECTION_CFG_CMD_INFO0_OFFSET_VALID);
1031 cmd->info0 |=
1032 le32_encode_bits(tlv_filter->drop_threshold_valid,
1033 HTT_RX_RING_SELECTION_CFG_CMD_INFO0_DROP_THRES_VAL);
1034 cmd->info0 |= le32_encode_bits(!tlv_filter->rxmon_disable,
1035 HTT_RX_RING_SELECTION_CFG_CMD_INFO0_EN_RXMON);
1036
1037 cmd->info1 = le32_encode_bits(rx_buf_size,
1038 HTT_RX_RING_SELECTION_CFG_CMD_INFO1_BUF_SIZE);
1039 cmd->info1 |= le32_encode_bits(tlv_filter->conf_len_mgmt,
1040 HTT_RX_RING_SELECTION_CFG_CMD_INFO1_CONF_LEN_MGMT);
1041 cmd->info1 |= le32_encode_bits(tlv_filter->conf_len_ctrl,
1042 HTT_RX_RING_SELECTION_CFG_CMD_INFO1_CONF_LEN_CTRL);
1043 cmd->info1 |= le32_encode_bits(tlv_filter->conf_len_data,
1044 HTT_RX_RING_SELECTION_CFG_CMD_INFO1_CONF_LEN_DATA);
1045 cmd->pkt_type_en_flags0 = cpu_to_le32(tlv_filter->pkt_filter_flags0);
1046 cmd->pkt_type_en_flags1 = cpu_to_le32(tlv_filter->pkt_filter_flags1);
1047 cmd->pkt_type_en_flags2 = cpu_to_le32(tlv_filter->pkt_filter_flags2);
1048 cmd->pkt_type_en_flags3 = cpu_to_le32(tlv_filter->pkt_filter_flags3);
1049 cmd->rx_filter_tlv = cpu_to_le32(tlv_filter->rx_filter);
1050
1051 cmd->info2 = le32_encode_bits(tlv_filter->rx_drop_threshold,
1052 HTT_RX_RING_SELECTION_CFG_CMD_INFO2_DROP_THRESHOLD);
1053 cmd->info2 |=
1054 le32_encode_bits(tlv_filter->enable_log_mgmt_type,
1055 HTT_RX_RING_SELECTION_CFG_CMD_INFO2_EN_LOG_MGMT_TYPE);
1056 cmd->info2 |=
1057 le32_encode_bits(tlv_filter->enable_log_ctrl_type,
1058 HTT_RX_RING_SELECTION_CFG_CMD_INFO2_EN_CTRL_TYPE);
1059 cmd->info2 |=
1060 le32_encode_bits(tlv_filter->enable_log_data_type,
1061 HTT_RX_RING_SELECTION_CFG_CMD_INFO2_EN_LOG_DATA_TYPE);
1062
1063 cmd->info3 =
1064 le32_encode_bits(tlv_filter->enable_rx_tlv_offset,
1065 HTT_RX_RING_SELECTION_CFG_CMD_INFO3_EN_TLV_PKT_OFFSET);
1066 cmd->info3 |=
1067 le32_encode_bits(tlv_filter->rx_tlv_offset,
1068 HTT_RX_RING_SELECTION_CFG_CMD_INFO3_PKT_TLV_OFFSET);
1069
1070 if (tlv_filter->offset_valid) {
1071 cmd->rx_packet_offset =
1072 le32_encode_bits(tlv_filter->rx_packet_offset,
1073 HTT_RX_RING_SELECTION_CFG_RX_PACKET_OFFSET);
1074
1075 cmd->rx_packet_offset |=
1076 le32_encode_bits(tlv_filter->rx_header_offset,
1077 HTT_RX_RING_SELECTION_CFG_RX_HEADER_OFFSET);
1078
1079 cmd->rx_mpdu_offset =
1080 le32_encode_bits(tlv_filter->rx_mpdu_end_offset,
1081 HTT_RX_RING_SELECTION_CFG_RX_MPDU_END_OFFSET);
1082
1083 cmd->rx_mpdu_offset |=
1084 le32_encode_bits(tlv_filter->rx_mpdu_start_offset,
1085 HTT_RX_RING_SELECTION_CFG_RX_MPDU_START_OFFSET);
1086
1087 cmd->rx_msdu_offset =
1088 le32_encode_bits(tlv_filter->rx_msdu_end_offset,
1089 HTT_RX_RING_SELECTION_CFG_RX_MSDU_END_OFFSET);
1090
1091 cmd->rx_msdu_offset |=
1092 le32_encode_bits(tlv_filter->rx_msdu_start_offset,
1093 HTT_RX_RING_SELECTION_CFG_RX_MSDU_START_OFFSET);
1094
1095 cmd->rx_attn_offset =
1096 le32_encode_bits(tlv_filter->rx_attn_offset,
1097 HTT_RX_RING_SELECTION_CFG_RX_ATTENTION_OFFSET);
1098 }
1099
1100 if (tlv_filter->rx_mpdu_start_wmask > 0 &&
1101 tlv_filter->rx_msdu_end_wmask > 0) {
1102 cmd->info2 |=
1103 le32_encode_bits(true,
1104 HTT_RX_RING_SELECTION_CFG_WORD_MASK_COMPACT_SET);
1105 cmd->rx_mpdu_start_end_mask =
1106 le32_encode_bits(tlv_filter->rx_mpdu_start_wmask,
1107 HTT_RX_RING_SELECTION_CFG_RX_MPDU_START_MASK);
1108 /* mpdu_end is not used for any hardwares so far
1109 * please assign it in future if any chip is
1110 * using through hal ops
1111 */
1112 cmd->rx_mpdu_start_end_mask |=
1113 le32_encode_bits(tlv_filter->rx_mpdu_end_wmask,
1114 HTT_RX_RING_SELECTION_CFG_RX_MPDU_END_MASK);
1115 cmd->rx_msdu_end_word_mask =
1116 le32_encode_bits(tlv_filter->rx_msdu_end_wmask,
1117 HTT_RX_RING_SELECTION_CFG_RX_MSDU_END_MASK);
1118 }
1119
1120 ret = ath12k_htc_send(&ab->htc, dp->eid, skb);
1121 if (ret)
1122 goto err_free;
1123
1124 return 0;
1125
1126 err_free:
1127 dev_kfree_skb_any(skb);
1128
1129 return ret;
1130 }
1131 EXPORT_SYMBOL(ath12k_dp_tx_htt_rx_filter_setup);
1132
1133 int
ath12k_dp_tx_htt_h2t_ext_stats_req(struct ath12k * ar,u8 type,struct htt_ext_stats_cfg_params * cfg_params,u64 cookie)1134 ath12k_dp_tx_htt_h2t_ext_stats_req(struct ath12k *ar, u8 type,
1135 struct htt_ext_stats_cfg_params *cfg_params,
1136 u64 cookie)
1137 {
1138 struct ath12k_base *ab = ar->ab;
1139 struct ath12k_dp *dp = ath12k_ab_to_dp(ab);
1140 struct sk_buff *skb;
1141 struct htt_ext_stats_cfg_cmd *cmd;
1142 int len = sizeof(*cmd);
1143 int ret;
1144 u32 pdev_id;
1145
1146 skb = ath12k_htc_alloc_skb(ab, len);
1147 if (!skb)
1148 return -ENOMEM;
1149
1150 skb_put(skb, len);
1151
1152 cmd = (struct htt_ext_stats_cfg_cmd *)skb->data;
1153 memset(cmd, 0, sizeof(*cmd));
1154 cmd->hdr.msg_type = HTT_H2T_MSG_TYPE_EXT_STATS_CFG;
1155
1156 pdev_id = ath12k_mac_get_target_pdev_id(ar);
1157 cmd->hdr.pdev_mask = 1 << pdev_id;
1158
1159 cmd->hdr.stats_type = type;
1160 cmd->cfg_param0 = cpu_to_le32(cfg_params->cfg0);
1161 cmd->cfg_param1 = cpu_to_le32(cfg_params->cfg1);
1162 cmd->cfg_param2 = cpu_to_le32(cfg_params->cfg2);
1163 cmd->cfg_param3 = cpu_to_le32(cfg_params->cfg3);
1164 cmd->cookie_lsb = cpu_to_le32(lower_32_bits(cookie));
1165 cmd->cookie_msb = cpu_to_le32(upper_32_bits(cookie));
1166
1167 ret = ath12k_htc_send(&ab->htc, dp->eid, skb);
1168 if (ret) {
1169 ath12k_warn(ab, "failed to send htt type stats request: %d",
1170 ret);
1171 dev_kfree_skb_any(skb);
1172 return ret;
1173 }
1174
1175 return 0;
1176 }
1177
ath12k_dp_tx_htt_monitor_mode_ring_config(struct ath12k * ar,bool reset)1178 int ath12k_dp_tx_htt_monitor_mode_ring_config(struct ath12k *ar, bool reset)
1179 {
1180 struct ath12k_base *ab = ar->ab;
1181 int ret;
1182
1183 ret = ath12k_dp_tx_htt_rx_monitor_mode_ring_config(ar, reset);
1184 if (ret) {
1185 ath12k_err(ab, "failed to setup rx monitor filter %d\n", ret);
1186 return ret;
1187 }
1188
1189 return 0;
1190 }
1191
ath12k_dp_tx_htt_rx_monitor_mode_ring_config(struct ath12k * ar,bool reset)1192 int ath12k_dp_tx_htt_rx_monitor_mode_ring_config(struct ath12k *ar, bool reset)
1193 {
1194 struct ath12k_base *ab = ar->ab;
1195 struct ath12k_dp *dp = ath12k_ab_to_dp(ab);
1196 struct htt_rx_ring_tlv_filter tlv_filter = {};
1197 int ret, ring_id, i;
1198
1199 tlv_filter.offset_valid = false;
1200
1201 if (!reset) {
1202 tlv_filter.rx_filter = HTT_RX_MON_FILTER_TLV_FLAGS_MON_DEST_RING;
1203
1204 tlv_filter.drop_threshold_valid = true;
1205 tlv_filter.rx_drop_threshold = HTT_RX_RING_TLV_DROP_THRESHOLD_VALUE;
1206
1207 tlv_filter.enable_log_mgmt_type = true;
1208 tlv_filter.enable_log_ctrl_type = true;
1209 tlv_filter.enable_log_data_type = true;
1210
1211 tlv_filter.conf_len_ctrl = HTT_RX_RING_DEFAULT_DMA_LENGTH;
1212 tlv_filter.conf_len_mgmt = HTT_RX_RING_DEFAULT_DMA_LENGTH;
1213 tlv_filter.conf_len_data = HTT_RX_RING_DEFAULT_DMA_LENGTH;
1214
1215 tlv_filter.enable_rx_tlv_offset = true;
1216 tlv_filter.rx_tlv_offset = HTT_RX_RING_PKT_TLV_OFFSET;
1217
1218 tlv_filter.pkt_filter_flags0 =
1219 HTT_RX_MON_FP_MGMT_FILTER_FLAGS0 |
1220 HTT_RX_MON_MO_MGMT_FILTER_FLAGS0;
1221 tlv_filter.pkt_filter_flags1 =
1222 HTT_RX_MON_FP_MGMT_FILTER_FLAGS1 |
1223 HTT_RX_MON_MO_MGMT_FILTER_FLAGS1;
1224 tlv_filter.pkt_filter_flags2 =
1225 HTT_RX_MON_FP_CTRL_FILTER_FLASG2 |
1226 HTT_RX_MON_MO_CTRL_FILTER_FLASG2;
1227 tlv_filter.pkt_filter_flags3 =
1228 HTT_RX_MON_FP_CTRL_FILTER_FLASG3 |
1229 HTT_RX_MON_MO_CTRL_FILTER_FLASG3 |
1230 HTT_RX_MON_FP_DATA_FILTER_FLASG3 |
1231 HTT_RX_MON_MO_DATA_FILTER_FLASG3;
1232 } else {
1233 tlv_filter = ath12k_mac_mon_status_filter_default;
1234
1235 if (ath12k_debugfs_is_extd_rx_stats_enabled(ar))
1236 tlv_filter.rx_filter = ath12k_debugfs_rx_filter(ar);
1237 }
1238
1239 if (ab->hw_params->rxdma1_enable) {
1240 for (i = 0; i < ab->hw_params->num_rxdma_per_pdev; i++) {
1241 ring_id = ar->dp.rxdma_mon_dst_ring[i].ring_id;
1242 ret = ath12k_dp_tx_htt_rx_filter_setup(ar->ab, ring_id,
1243 ar->dp.mac_id + i,
1244 HAL_RXDMA_MONITOR_DST,
1245 DP_RXDMA_REFILL_RING_SIZE,
1246 &tlv_filter);
1247 if (ret) {
1248 ath12k_err(ab,
1249 "failed to setup filter for monitor buf %d\n",
1250 ret);
1251 return ret;
1252 }
1253 }
1254 return 0;
1255 }
1256
1257 if (!reset) {
1258 for (i = 0; i < ab->hw_params->num_rxdma_per_pdev; i++) {
1259 ring_id = dp->rx_mac_buf_ring[i].ring_id;
1260 ret = ath12k_dp_tx_htt_rx_filter_setup(ar->ab, ring_id,
1261 i,
1262 HAL_RXDMA_BUF,
1263 DP_RXDMA_REFILL_RING_SIZE,
1264 &tlv_filter);
1265 if (ret) {
1266 ath12k_err(ab,
1267 "failed to setup filter for mon rx buf %d\n",
1268 ret);
1269 return ret;
1270 }
1271 }
1272 }
1273
1274 for (i = 0; i < ab->hw_params->num_rxdma_per_pdev; i++) {
1275 ring_id = dp->rx_mon_status_refill_ring[i].refill_buf_ring.ring_id;
1276 if (!reset) {
1277 tlv_filter.rx_filter =
1278 HTT_RX_MON_FILTER_TLV_FLAGS_MON_STATUS_RING;
1279 }
1280
1281 ret = ath12k_dp_tx_htt_rx_filter_setup(ab, ring_id,
1282 i,
1283 HAL_RXDMA_MONITOR_STATUS,
1284 RX_MON_STATUS_BUF_SIZE,
1285 &tlv_filter);
1286 if (ret) {
1287 ath12k_err(ab,
1288 "failed to setup filter for mon status buf %d\n",
1289 ret);
1290 return ret;
1291 }
1292 }
1293
1294 return 0;
1295 }
1296
ath12k_dp_tx_htt_tx_filter_setup(struct ath12k_base * ab,u32 ring_id,int mac_id,enum hal_ring_type ring_type,int tx_buf_size,struct htt_tx_ring_tlv_filter * htt_tlv_filter)1297 int ath12k_dp_tx_htt_tx_filter_setup(struct ath12k_base *ab, u32 ring_id,
1298 int mac_id, enum hal_ring_type ring_type,
1299 int tx_buf_size,
1300 struct htt_tx_ring_tlv_filter *htt_tlv_filter)
1301 {
1302 struct ath12k_dp *dp = ath12k_ab_to_dp(ab);
1303 struct htt_tx_ring_selection_cfg_cmd *cmd;
1304 struct hal_srng *srng = &ab->hal.srng_list[ring_id];
1305 struct hal_srng_params params;
1306 struct sk_buff *skb;
1307 int len = sizeof(*cmd);
1308 enum htt_srng_ring_type htt_ring_type;
1309 enum htt_srng_ring_id htt_ring_id;
1310 int ret;
1311
1312 skb = ath12k_htc_alloc_skb(ab, len);
1313 if (!skb)
1314 return -ENOMEM;
1315
1316 memset(¶ms, 0, sizeof(params));
1317 ath12k_hal_srng_get_params(ab, srng, ¶ms);
1318
1319 ret = ath12k_dp_tx_get_ring_id_type(ab, mac_id, ring_id,
1320 ring_type, &htt_ring_type,
1321 &htt_ring_id);
1322
1323 if (ret)
1324 goto err_free;
1325
1326 skb_put(skb, len);
1327 cmd = (struct htt_tx_ring_selection_cfg_cmd *)skb->data;
1328 cmd->info0 = le32_encode_bits(HTT_H2T_MSG_TYPE_TX_MONITOR_CFG,
1329 HTT_TX_RING_SELECTION_CFG_CMD_INFO0_MSG_TYPE);
1330 if (htt_ring_type == HTT_SW_TO_HW_RING ||
1331 htt_ring_type == HTT_HW_TO_SW_RING)
1332 cmd->info0 |=
1333 le32_encode_bits(DP_SW2HW_MACID(mac_id),
1334 HTT_TX_RING_SELECTION_CFG_CMD_INFO0_PDEV_ID);
1335 else
1336 cmd->info0 |=
1337 le32_encode_bits(mac_id,
1338 HTT_TX_RING_SELECTION_CFG_CMD_INFO0_PDEV_ID);
1339 cmd->info0 |= le32_encode_bits(htt_ring_id,
1340 HTT_TX_RING_SELECTION_CFG_CMD_INFO0_RING_ID);
1341 cmd->info0 |= le32_encode_bits(!!(params.flags & HAL_SRNG_FLAGS_MSI_SWAP),
1342 HTT_TX_RING_SELECTION_CFG_CMD_INFO0_SS);
1343 cmd->info0 |= le32_encode_bits(!!(params.flags & HAL_SRNG_FLAGS_DATA_TLV_SWAP),
1344 HTT_TX_RING_SELECTION_CFG_CMD_INFO0_PS);
1345
1346 cmd->info1 |=
1347 le32_encode_bits(tx_buf_size,
1348 HTT_TX_RING_SELECTION_CFG_CMD_INFO1_RING_BUFF_SIZE);
1349
1350 if (htt_tlv_filter->tx_mon_mgmt_filter) {
1351 cmd->info1 |=
1352 le32_encode_bits(HTT_STATS_FRAME_CTRL_TYPE_MGMT,
1353 HTT_TX_RING_SELECTION_CFG_CMD_INFO1_PKT_TYPE);
1354 cmd->info1 |=
1355 le32_encode_bits(htt_tlv_filter->tx_mon_pkt_dma_len,
1356 HTT_TX_RING_SELECTION_CFG_CMD_INFO1_CONF_LEN_MGMT);
1357 cmd->info2 |=
1358 le32_encode_bits(HTT_STATS_FRAME_CTRL_TYPE_MGMT,
1359 HTT_TX_RING_SELECTION_CFG_CMD_INFO2_PKT_TYPE_EN_FLAG);
1360 }
1361
1362 if (htt_tlv_filter->tx_mon_data_filter) {
1363 cmd->info1 |=
1364 le32_encode_bits(HTT_STATS_FRAME_CTRL_TYPE_CTRL,
1365 HTT_TX_RING_SELECTION_CFG_CMD_INFO1_PKT_TYPE);
1366 cmd->info1 |=
1367 le32_encode_bits(htt_tlv_filter->tx_mon_pkt_dma_len,
1368 HTT_TX_RING_SELECTION_CFG_CMD_INFO1_CONF_LEN_CTRL);
1369 cmd->info2 |=
1370 le32_encode_bits(HTT_STATS_FRAME_CTRL_TYPE_CTRL,
1371 HTT_TX_RING_SELECTION_CFG_CMD_INFO2_PKT_TYPE_EN_FLAG);
1372 }
1373
1374 if (htt_tlv_filter->tx_mon_ctrl_filter) {
1375 cmd->info1 |=
1376 le32_encode_bits(HTT_STATS_FRAME_CTRL_TYPE_DATA,
1377 HTT_TX_RING_SELECTION_CFG_CMD_INFO1_PKT_TYPE);
1378 cmd->info1 |=
1379 le32_encode_bits(htt_tlv_filter->tx_mon_pkt_dma_len,
1380 HTT_TX_RING_SELECTION_CFG_CMD_INFO1_CONF_LEN_DATA);
1381 cmd->info2 |=
1382 le32_encode_bits(HTT_STATS_FRAME_CTRL_TYPE_DATA,
1383 HTT_TX_RING_SELECTION_CFG_CMD_INFO2_PKT_TYPE_EN_FLAG);
1384 }
1385
1386 cmd->tlv_filter_mask_in0 =
1387 cpu_to_le32(htt_tlv_filter->tx_mon_downstream_tlv_flags);
1388 cmd->tlv_filter_mask_in1 =
1389 cpu_to_le32(htt_tlv_filter->tx_mon_upstream_tlv_flags0);
1390 cmd->tlv_filter_mask_in2 =
1391 cpu_to_le32(htt_tlv_filter->tx_mon_upstream_tlv_flags1);
1392 cmd->tlv_filter_mask_in3 =
1393 cpu_to_le32(htt_tlv_filter->tx_mon_upstream_tlv_flags2);
1394
1395 ret = ath12k_htc_send(&ab->htc, dp->eid, skb);
1396 if (ret)
1397 goto err_free;
1398
1399 return 0;
1400
1401 err_free:
1402 dev_kfree_skb_any(skb);
1403 return ret;
1404 }
1405