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 "dp_rx.h"
8 #include "../dp_tx.h"
9 #include "../peer.h"
10 #include "hal_qcn9274.h"
11 #include "hal_wcn7850.h"
12 #include "hal_qcc2072.h"
13
ath12k_wifi7_dp_rx_get_peer_id(struct ath12k_dp * dp,enum ath12k_peer_metadata_version ver,__le32 peer_metadata)14 static u16 ath12k_wifi7_dp_rx_get_peer_id(struct ath12k_dp *dp,
15 enum ath12k_peer_metadata_version ver,
16 __le32 peer_metadata)
17 {
18 switch (ver) {
19 default:
20 ath12k_warn(dp->ab, "Unknown peer metadata version: %d", ver);
21 fallthrough;
22 case ATH12K_PEER_METADATA_V0:
23 return le32_get_bits(peer_metadata,
24 RX_MPDU_DESC_META_DATA_V0_PEER_ID);
25 case ATH12K_PEER_METADATA_V1:
26 return le32_get_bits(peer_metadata,
27 RX_MPDU_DESC_META_DATA_V1_PEER_ID);
28 case ATH12K_PEER_METADATA_V1A:
29 return le32_get_bits(peer_metadata,
30 RX_MPDU_DESC_META_DATA_V1A_PEER_ID);
31 case ATH12K_PEER_METADATA_V1B:
32 return le32_get_bits(peer_metadata,
33 RX_MPDU_DESC_META_DATA_V1B_PEER_ID);
34 }
35 }
36
ath12k_wifi7_peer_rx_tid_qref_setup(struct ath12k_base * ab,u16 peer_id,u16 tid,dma_addr_t paddr)37 void ath12k_wifi7_peer_rx_tid_qref_setup(struct ath12k_base *ab, u16 peer_id, u16 tid,
38 dma_addr_t paddr)
39 {
40 struct ath12k_reo_queue_ref *qref;
41 struct ath12k_dp *dp = ath12k_ab_to_dp(ab);
42 bool ml_peer = false;
43
44 if (!ab->hw_params->reoq_lut_support)
45 return;
46
47 if (peer_id & ATH12K_PEER_ML_ID_VALID) {
48 peer_id &= ~ATH12K_PEER_ML_ID_VALID;
49 ml_peer = true;
50 }
51
52 if (ml_peer)
53 qref = (struct ath12k_reo_queue_ref *)dp->ml_reoq_lut.vaddr +
54 (peer_id * (IEEE80211_NUM_TIDS + 1) + tid);
55 else
56 qref = (struct ath12k_reo_queue_ref *)dp->reoq_lut.vaddr +
57 (peer_id * (IEEE80211_NUM_TIDS + 1) + tid);
58
59 qref->info0 = u32_encode_bits(lower_32_bits(paddr),
60 BUFFER_ADDR_INFO0_ADDR);
61 qref->info1 = u32_encode_bits(upper_32_bits(paddr),
62 BUFFER_ADDR_INFO1_ADDR) |
63 u32_encode_bits(tid, DP_REO_QREF_NUM);
64
65 ath12k_hal_reo_shared_qaddr_cache_clear(ab);
66 }
67
ath12k_wifi7_peer_rx_tid_qref_reset(struct ath12k_base * ab,u16 peer_id,u16 tid)68 void ath12k_wifi7_peer_rx_tid_qref_reset(struct ath12k_base *ab,
69 u16 peer_id, u16 tid)
70 {
71 struct ath12k_reo_queue_ref *qref;
72 struct ath12k_dp *dp = ath12k_ab_to_dp(ab);
73 bool ml_peer = false;
74
75 if (!ab->hw_params->reoq_lut_support)
76 return;
77
78 if (peer_id & ATH12K_PEER_ML_ID_VALID) {
79 peer_id &= ~ATH12K_PEER_ML_ID_VALID;
80 ml_peer = true;
81 }
82
83 if (ml_peer)
84 qref = (struct ath12k_reo_queue_ref *)dp->ml_reoq_lut.vaddr +
85 (peer_id * (IEEE80211_NUM_TIDS + 1) + tid);
86 else
87 qref = (struct ath12k_reo_queue_ref *)dp->reoq_lut.vaddr +
88 (peer_id * (IEEE80211_NUM_TIDS + 1) + tid);
89
90 qref->info0 = u32_encode_bits(0, BUFFER_ADDR_INFO0_ADDR);
91 qref->info1 = u32_encode_bits(0, BUFFER_ADDR_INFO1_ADDR) |
92 u32_encode_bits(tid, DP_REO_QREF_NUM);
93 }
94
ath12k_wifi7_dp_rx_peer_tid_delete(struct ath12k_base * ab,struct ath12k_dp_link_peer * peer,u8 tid)95 void ath12k_wifi7_dp_rx_peer_tid_delete(struct ath12k_base *ab,
96 struct ath12k_dp_link_peer *peer, u8 tid)
97 {
98 struct ath12k_dp *dp = ath12k_ab_to_dp(ab);
99
100 if (!(peer->rx_tid_active_bitmask & (1 << tid)))
101 return;
102
103 ath12k_dp_mark_tid_as_inactive(dp, peer->peer_id, tid);
104 ath12k_dp_rx_process_reo_cmd_update_rx_queue_list(dp);
105 }
106
ath12k_wifi7_dp_rx_link_desc_return(struct ath12k_dp * dp,struct ath12k_buffer_addr * buf_addr_info,enum hal_wbm_rel_bm_act action)107 int ath12k_wifi7_dp_rx_link_desc_return(struct ath12k_dp *dp,
108 struct ath12k_buffer_addr *buf_addr_info,
109 enum hal_wbm_rel_bm_act action)
110 {
111 struct ath12k_base *ab = dp->ab;
112 struct hal_wbm_release_ring *desc;
113 struct hal_srng *srng;
114 int ret = 0;
115
116 srng = &dp->hal->srng_list[dp->wbm_desc_rel_ring.ring_id];
117
118 spin_lock_bh(&srng->lock);
119
120 ath12k_hal_srng_access_begin(ab, srng);
121
122 desc = ath12k_hal_srng_src_get_next_entry(ab, srng);
123 if (!desc) {
124 ret = -ENOBUFS;
125 goto exit;
126 }
127
128 ath12k_wifi7_hal_rx_msdu_link_desc_set(ab, desc, buf_addr_info, action);
129
130 exit:
131 ath12k_hal_srng_access_end(ab, srng);
132
133 spin_unlock_bh(&srng->lock);
134
135 return ret;
136 }
137
ath12k_wifi7_dp_reo_cmd_send(struct ath12k_base * ab,struct ath12k_dp_rx_tid_rxq * rx_tid,enum hal_reo_cmd_type type,struct ath12k_hal_reo_cmd * cmd,void (* cb)(struct ath12k_dp * dp,void * ctx,enum hal_reo_cmd_status status))138 int ath12k_wifi7_dp_reo_cmd_send(struct ath12k_base *ab,
139 struct ath12k_dp_rx_tid_rxq *rx_tid,
140 enum hal_reo_cmd_type type,
141 struct ath12k_hal_reo_cmd *cmd,
142 void (*cb)(struct ath12k_dp *dp, void *ctx,
143 enum hal_reo_cmd_status status))
144 {
145 struct ath12k_dp *dp = ath12k_ab_to_dp(ab);
146 struct ath12k_dp_rx_reo_cmd *dp_cmd;
147 struct hal_srng *cmd_ring;
148 int cmd_num;
149
150 cmd_ring = &ab->hal.srng_list[dp->reo_cmd_ring.ring_id];
151 cmd_num = ath12k_wifi7_hal_reo_cmd_send(ab, cmd_ring, type, cmd);
152
153 /* cmd_num should start from 1, during failure return the error code */
154 if (cmd_num < 0)
155 return cmd_num;
156
157 /* reo cmd ring descriptors has cmd_num starting from 1 */
158 if (cmd_num == 0)
159 return -EINVAL;
160
161 if (!cb)
162 return 0;
163
164 /* Can this be optimized so that we keep the pending command list only
165 * for tid delete command to free up the resource on the command status
166 * indication?
167 */
168 dp_cmd = kzalloc_obj(*dp_cmd, GFP_ATOMIC);
169
170 if (!dp_cmd)
171 return -ENOMEM;
172
173 memcpy(&dp_cmd->data, rx_tid, sizeof(*rx_tid));
174 dp_cmd->cmd_num = cmd_num;
175 dp_cmd->handler = cb;
176
177 spin_lock_bh(&dp->reo_cmd_lock);
178 list_add_tail(&dp_cmd->list, &dp->reo_cmd_list);
179 spin_unlock_bh(&dp->reo_cmd_lock);
180
181 return 0;
182 }
183
ath12k_wifi7_peer_rx_tid_reo_update(struct ath12k_dp * dp,struct ath12k_dp_link_peer * peer,struct ath12k_dp_rx_tid * rx_tid,u32 ba_win_sz,u16 ssn,bool update_ssn)184 int ath12k_wifi7_peer_rx_tid_reo_update(struct ath12k_dp *dp,
185 struct ath12k_dp_link_peer *peer,
186 struct ath12k_dp_rx_tid *rx_tid,
187 u32 ba_win_sz, u16 ssn,
188 bool update_ssn)
189 {
190 struct ath12k_hal_reo_cmd cmd = {};
191 struct ath12k_base *ab = dp->ab;
192 int ret;
193 struct ath12k_dp_rx_tid_rxq rx_tid_rxq;
194
195 ath12k_dp_init_rx_tid_rxq(&rx_tid_rxq, rx_tid,
196 (peer->rx_tid_active_bitmask & (1 << rx_tid->tid)));
197
198 cmd.addr_lo = lower_32_bits(rx_tid_rxq.qbuf.paddr_aligned);
199 cmd.addr_hi = upper_32_bits(rx_tid_rxq.qbuf.paddr_aligned);
200 cmd.flag = HAL_REO_CMD_FLG_NEED_STATUS;
201 cmd.upd0 = HAL_REO_CMD_UPD0_BA_WINDOW_SIZE;
202 cmd.ba_window_size = ba_win_sz;
203
204 if (update_ssn) {
205 cmd.upd0 |= HAL_REO_CMD_UPD0_SSN;
206 cmd.upd2 = u32_encode_bits(ssn, HAL_REO_CMD_UPD2_SSN);
207 }
208
209 ret = ath12k_wifi7_dp_reo_cmd_send(ab, &rx_tid_rxq,
210 HAL_REO_CMD_UPDATE_RX_QUEUE, &cmd,
211 NULL);
212 if (ret) {
213 ath12k_warn(ab, "failed to update rx tid queue, tid %d (%d)\n",
214 rx_tid_rxq.tid, ret);
215 return ret;
216 }
217
218 rx_tid->ba_win_sz = ba_win_sz;
219
220 return 0;
221 }
222
ath12k_wifi7_dp_reo_cache_flush(struct ath12k_base * ab,struct ath12k_dp_rx_tid_rxq * rx_tid)223 int ath12k_wifi7_dp_reo_cache_flush(struct ath12k_base *ab,
224 struct ath12k_dp_rx_tid_rxq *rx_tid)
225 {
226 struct ath12k_hal_reo_cmd cmd = {};
227 int ret;
228
229 cmd.addr_lo = lower_32_bits(rx_tid->qbuf.paddr_aligned);
230 cmd.addr_hi = upper_32_bits(rx_tid->qbuf.paddr_aligned);
231 /* HAL_REO_CMD_FLG_FLUSH_FWD_ALL_MPDUS - all pending MPDUs
232 *in the bitmap will be forwarded/flushed to REO output rings
233 */
234 cmd.flag = HAL_REO_CMD_FLG_NEED_STATUS |
235 HAL_REO_CMD_FLG_FLUSH_FWD_ALL_MPDUS;
236
237 /* For all QoS TIDs (except NON_QOS), the driver allocates a maximum
238 * window size of 1024. In such cases, the driver can issue a single
239 * 1KB descriptor flush command instead of sending multiple 128-byte
240 * flush commands for each QoS TID, improving efficiency.
241 */
242
243 if (rx_tid->tid != HAL_DESC_REO_NON_QOS_TID)
244 cmd.flag |= HAL_REO_CMD_FLG_FLUSH_QUEUE_1K_DESC;
245
246 ret = ath12k_wifi7_dp_reo_cmd_send(ab, rx_tid,
247 HAL_REO_CMD_FLUSH_CACHE,
248 &cmd, ath12k_dp_reo_cmd_free);
249 return ret;
250 }
251
ath12k_wifi7_dp_rx_assign_reoq(struct ath12k_base * ab,struct ath12k_dp_peer * dp_peer,struct ath12k_dp_rx_tid * rx_tid,u16 ssn,enum hal_pn_type pn_type)252 int ath12k_wifi7_dp_rx_assign_reoq(struct ath12k_base *ab, struct ath12k_dp_peer *dp_peer,
253 struct ath12k_dp_rx_tid *rx_tid,
254 u16 ssn, enum hal_pn_type pn_type)
255 {
256 u32 ba_win_sz = rx_tid->ba_win_sz;
257 struct ath12k_reoq_buf *buf;
258 void *vaddr, *vaddr_aligned;
259 dma_addr_t paddr_aligned;
260 u8 tid = rx_tid->tid;
261 u32 hw_desc_sz;
262 int ret;
263
264 buf = &dp_peer->reoq_bufs[tid];
265 if (!buf->vaddr) {
266 /* TODO: Optimize the memory allocation for qos tid based on
267 * the actual BA window size in REO tid update path.
268 */
269 if (tid == HAL_DESC_REO_NON_QOS_TID)
270 hw_desc_sz = ath12k_wifi7_hal_reo_qdesc_size(ba_win_sz, tid);
271 else
272 hw_desc_sz = ath12k_wifi7_hal_reo_qdesc_size(DP_BA_WIN_SZ_MAX,
273 tid);
274
275 vaddr = kzalloc(hw_desc_sz + HAL_LINK_DESC_ALIGN - 1, GFP_ATOMIC);
276 if (!vaddr)
277 return -ENOMEM;
278
279 vaddr_aligned = PTR_ALIGN(vaddr, HAL_LINK_DESC_ALIGN);
280
281 ath12k_wifi7_hal_reo_qdesc_setup(vaddr_aligned, tid, ba_win_sz,
282 ssn, pn_type);
283
284 paddr_aligned = dma_map_single(ab->dev, vaddr_aligned, hw_desc_sz,
285 DMA_BIDIRECTIONAL);
286 ret = dma_mapping_error(ab->dev, paddr_aligned);
287 if (ret) {
288 kfree(vaddr);
289 return ret;
290 }
291
292 buf->vaddr = vaddr;
293 buf->paddr_aligned = paddr_aligned;
294 buf->size = hw_desc_sz;
295 }
296
297 rx_tid->qbuf = *buf;
298
299 return 0;
300 }
301
ath12k_wifi7_dp_rx_tid_delete_handler(struct ath12k_base * ab,struct ath12k_dp_rx_tid_rxq * rx_tid)302 int ath12k_wifi7_dp_rx_tid_delete_handler(struct ath12k_base *ab,
303 struct ath12k_dp_rx_tid_rxq *rx_tid)
304 {
305 struct ath12k_hal_reo_cmd cmd = {};
306
307 cmd.flag = HAL_REO_CMD_FLG_NEED_STATUS;
308 cmd.addr_lo = lower_32_bits(rx_tid->qbuf.paddr_aligned);
309 cmd.addr_hi = upper_32_bits(rx_tid->qbuf.paddr_aligned);
310 cmd.upd0 |= HAL_REO_CMD_UPD0_VLD;
311 /* Observed flush cache failure, to avoid that set vld bit during delete */
312 cmd.upd1 |= HAL_REO_CMD_UPD1_VLD;
313
314 return ath12k_wifi7_dp_reo_cmd_send(ab, rx_tid,
315 HAL_REO_CMD_UPDATE_RX_QUEUE, &cmd,
316 ath12k_dp_rx_tid_del_func);
317 }
318
ath12k_wifi7_dp_rx_h_csum_offload(struct sk_buff * msdu,struct hal_rx_desc_data * rx_info)319 static void ath12k_wifi7_dp_rx_h_csum_offload(struct sk_buff *msdu,
320 struct hal_rx_desc_data *rx_info)
321 {
322 msdu->ip_summed = (rx_info->ip_csum_fail || rx_info->l4_csum_fail) ?
323 CHECKSUM_NONE : CHECKSUM_UNNECESSARY;
324 }
325
ath12k_wifi7_dp_rx_h_mpdu(struct ath12k_pdev_dp * dp_pdev,struct sk_buff * msdu,struct hal_rx_desc * rx_desc,struct hal_rx_desc_data * rx_info)326 static void ath12k_wifi7_dp_rx_h_mpdu(struct ath12k_pdev_dp *dp_pdev,
327 struct sk_buff *msdu,
328 struct hal_rx_desc *rx_desc,
329 struct hal_rx_desc_data *rx_info)
330 {
331 struct ath12k_skb_rxcb *rxcb;
332 enum hal_encrypt_type enctype;
333 bool is_decrypted = false;
334 struct ieee80211_hdr *hdr;
335 struct ath12k_dp_peer *peer;
336 struct ieee80211_rx_status *rx_status = rx_info->rx_status;
337 u32 err_bitmap = rx_info->err_bitmap;
338
339 RCU_LOCKDEP_WARN(!rcu_read_lock_held(),
340 "dp_rx_h_mpdu called without rcu lock");
341
342 /* PN for multicast packets will be checked in mac80211 */
343 rxcb = ATH12K_SKB_RXCB(msdu);
344 rxcb->is_mcbc = rx_info->is_mcbc;
345
346 if (rxcb->is_mcbc)
347 rxcb->peer_id = rx_info->peer_id;
348
349 peer = ath12k_dp_peer_find_by_peerid(dp_pdev, rxcb->peer_id);
350 if (peer) {
351 /* resetting mcbc bit because mcbc packets are unicast
352 * packets only for AP as STA sends unicast packets.
353 */
354 rxcb->is_mcbc = rxcb->is_mcbc && !peer->ucast_ra_only;
355
356 if (rxcb->is_mcbc)
357 enctype = peer->sec_type_grp;
358 else
359 enctype = peer->sec_type;
360 } else {
361 enctype = HAL_ENCRYPT_TYPE_OPEN;
362 }
363
364 if (enctype != HAL_ENCRYPT_TYPE_OPEN && !err_bitmap)
365 is_decrypted = rx_info->is_decrypted;
366
367 /* Clear per-MPDU flags while leaving per-PPDU flags intact */
368 rx_status->flag &= ~(RX_FLAG_FAILED_FCS_CRC |
369 RX_FLAG_MMIC_ERROR |
370 RX_FLAG_DECRYPTED |
371 RX_FLAG_IV_STRIPPED |
372 RX_FLAG_MMIC_STRIPPED);
373
374 if (err_bitmap & HAL_RX_MPDU_ERR_FCS)
375 rx_status->flag |= RX_FLAG_FAILED_FCS_CRC;
376 if (err_bitmap & HAL_RX_MPDU_ERR_TKIP_MIC)
377 rx_status->flag |= RX_FLAG_MMIC_ERROR;
378
379 if (is_decrypted) {
380 rx_status->flag |= RX_FLAG_DECRYPTED | RX_FLAG_MMIC_STRIPPED;
381
382 if (rx_info->is_mcbc)
383 rx_status->flag |= RX_FLAG_MIC_STRIPPED |
384 RX_FLAG_ICV_STRIPPED;
385 else
386 rx_status->flag |= RX_FLAG_IV_STRIPPED |
387 RX_FLAG_PN_VALIDATED;
388 }
389
390 ath12k_wifi7_dp_rx_h_csum_offload(msdu, rx_info);
391 ath12k_dp_rx_h_undecap(dp_pdev, msdu, rx_desc,
392 enctype, is_decrypted, rx_info);
393
394 if (!is_decrypted || rx_info->is_mcbc)
395 return;
396
397 if (rx_info->decap_type != DP_RX_DECAP_TYPE_ETHERNET2_DIX) {
398 hdr = (void *)msdu->data;
399 hdr->frame_control &= ~__cpu_to_le16(IEEE80211_FCTL_PROTECTED);
400 }
401 }
402
ath12k_wifi7_dp_rx_msdu_coalesce(struct ath12k_hal * hal,struct sk_buff_head * msdu_list,struct sk_buff * first,struct sk_buff * last,u8 l3pad_bytes,int msdu_len,struct hal_rx_desc_data * rx_info)403 static int ath12k_wifi7_dp_rx_msdu_coalesce(struct ath12k_hal *hal,
404 struct sk_buff_head *msdu_list,
405 struct sk_buff *first, struct sk_buff *last,
406 u8 l3pad_bytes, int msdu_len,
407 struct hal_rx_desc_data *rx_info)
408 {
409 struct sk_buff *skb;
410 struct ath12k_skb_rxcb *rxcb = ATH12K_SKB_RXCB(first);
411 int buf_first_hdr_len, buf_first_len;
412 struct hal_rx_desc *ldesc;
413 int space_extra, rem_len, buf_len;
414 u32 hal_rx_desc_sz = hal->hal_desc_sz;
415 bool is_continuation;
416
417 /* As the msdu is spread across multiple rx buffers,
418 * find the offset to the start of msdu for computing
419 * the length of the msdu in the first buffer.
420 */
421 buf_first_hdr_len = hal_rx_desc_sz + l3pad_bytes;
422 buf_first_len = DP_RX_BUFFER_SIZE - buf_first_hdr_len;
423
424 if (WARN_ON_ONCE(msdu_len <= buf_first_len)) {
425 skb_put(first, buf_first_hdr_len + msdu_len);
426 skb_pull(first, buf_first_hdr_len);
427 return 0;
428 }
429
430 ldesc = (struct hal_rx_desc *)last->data;
431 rxcb->is_first_msdu = rx_info->is_first_msdu;
432 rxcb->is_last_msdu = rx_info->is_last_msdu;
433
434 /* MSDU spans over multiple buffers because the length of the MSDU
435 * exceeds DP_RX_BUFFER_SIZE - HAL_RX_DESC_SIZE. So assume the data
436 * in the first buf is of length DP_RX_BUFFER_SIZE - HAL_RX_DESC_SIZE.
437 */
438 skb_put(first, DP_RX_BUFFER_SIZE);
439 skb_pull(first, buf_first_hdr_len);
440
441 /* When an MSDU spread over multiple buffers MSDU_END
442 * tlvs are valid only in the last buffer. Copy those tlvs.
443 */
444 ath12k_dp_rx_desc_end_tlv_copy(hal, rxcb->rx_desc, ldesc);
445
446 space_extra = msdu_len - (buf_first_len + skb_tailroom(first));
447 if (space_extra > 0 &&
448 (pskb_expand_head(first, 0, space_extra, GFP_ATOMIC) < 0)) {
449 /* Free up all buffers of the MSDU */
450 while ((skb = __skb_dequeue(msdu_list)) != NULL) {
451 rxcb = ATH12K_SKB_RXCB(skb);
452 if (!rxcb->is_continuation) {
453 dev_kfree_skb_any(skb);
454 break;
455 }
456 dev_kfree_skb_any(skb);
457 }
458 return -ENOMEM;
459 }
460
461 rem_len = msdu_len - buf_first_len;
462 while ((skb = __skb_dequeue(msdu_list)) != NULL && rem_len > 0) {
463 rxcb = ATH12K_SKB_RXCB(skb);
464 is_continuation = rxcb->is_continuation;
465 if (is_continuation)
466 buf_len = DP_RX_BUFFER_SIZE - hal_rx_desc_sz;
467 else
468 buf_len = rem_len;
469
470 if (buf_len > (DP_RX_BUFFER_SIZE - hal_rx_desc_sz)) {
471 WARN_ON_ONCE(1);
472 dev_kfree_skb_any(skb);
473 return -EINVAL;
474 }
475
476 skb_put(skb, buf_len + hal_rx_desc_sz);
477 skb_pull(skb, hal_rx_desc_sz);
478 skb_copy_from_linear_data(skb, skb_put(first, buf_len),
479 buf_len);
480 dev_kfree_skb_any(skb);
481
482 rem_len -= buf_len;
483 if (!is_continuation)
484 break;
485 }
486
487 return 0;
488 }
489
ath12k_wifi7_dp_rx_process_msdu(struct ath12k_pdev_dp * dp_pdev,struct sk_buff * msdu,struct sk_buff_head * msdu_list,struct hal_rx_desc_data * rx_info)490 static int ath12k_wifi7_dp_rx_process_msdu(struct ath12k_pdev_dp *dp_pdev,
491 struct sk_buff *msdu,
492 struct sk_buff_head *msdu_list,
493 struct hal_rx_desc_data *rx_info)
494 {
495 struct ath12k_dp *dp = dp_pdev->dp;
496 struct hal_rx_desc *rx_desc, *lrx_desc;
497 struct ath12k_skb_rxcb *rxcb;
498 struct sk_buff *last_buf;
499 struct ath12k_hal *hal = dp->hal;
500 u8 l3_pad_bytes;
501 u16 msdu_len;
502 int ret;
503 u32 hal_rx_desc_sz = hal->hal_desc_sz;
504
505 last_buf = ath12k_dp_rx_get_msdu_last_buf(msdu_list, msdu);
506 if (!last_buf) {
507 ath12k_warn(dp->ab,
508 "No valid Rx buffer to access MSDU_END tlv\n");
509 ret = -EIO;
510 goto free_out;
511 }
512
513 rx_desc = (struct hal_rx_desc *)msdu->data;
514 lrx_desc = (struct hal_rx_desc *)last_buf->data;
515
516 ath12k_dp_extract_rx_desc_data(hal, rx_info, rx_desc, lrx_desc);
517 if (!rx_info->msdu_done) {
518 ath12k_warn(dp->ab, "msdu_done bit in msdu_end is not set\n");
519 ret = -EIO;
520 goto free_out;
521 }
522
523 rxcb = ATH12K_SKB_RXCB(msdu);
524 rxcb->rx_desc = rx_desc;
525 msdu_len = rx_info->msdu_len;
526 l3_pad_bytes = rx_info->l3_pad_bytes;
527
528 if (rxcb->is_frag) {
529 skb_pull(msdu, hal_rx_desc_sz);
530 } else if (!rxcb->is_continuation) {
531 if ((msdu_len + hal_rx_desc_sz) > DP_RX_BUFFER_SIZE) {
532 ret = -EINVAL;
533 ath12k_warn(dp->ab, "invalid msdu len %u\n", msdu_len);
534 ath12k_dbg_dump(dp->ab, ATH12K_DBG_DATA, NULL, "", rx_desc,
535 sizeof(*rx_desc));
536 goto free_out;
537 }
538 skb_put(msdu, hal_rx_desc_sz + l3_pad_bytes + msdu_len);
539 skb_pull(msdu, hal_rx_desc_sz + l3_pad_bytes);
540 } else {
541 ret = ath12k_wifi7_dp_rx_msdu_coalesce(hal, msdu_list,
542 msdu, last_buf,
543 l3_pad_bytes, msdu_len,
544 rx_info);
545 if (ret) {
546 ath12k_warn(dp->ab,
547 "failed to coalesce msdu rx buffer%d\n", ret);
548 goto free_out;
549 }
550 }
551
552 if (unlikely(!ath12k_dp_rx_check_nwifi_hdr_len_valid(dp, rx_desc, msdu,
553 rx_info))) {
554 ret = -EINVAL;
555 goto free_out;
556 }
557
558 ath12k_dp_rx_h_ppdu(dp_pdev, rx_info);
559 ath12k_wifi7_dp_rx_h_mpdu(dp_pdev, msdu, rx_desc, rx_info);
560
561 rx_info->rx_status->flag |= RX_FLAG_SKIP_MONITOR | RX_FLAG_DUP_VALIDATED;
562
563 return 0;
564
565 free_out:
566 return ret;
567 }
568
569 static void
ath12k_wifi7_dp_rx_process_received_packets(struct ath12k_dp * dp,struct napi_struct * napi,struct sk_buff_head * msdu_list,int ring_id)570 ath12k_wifi7_dp_rx_process_received_packets(struct ath12k_dp *dp,
571 struct napi_struct *napi,
572 struct sk_buff_head *msdu_list,
573 int ring_id)
574 {
575 struct ath12k_hw_group *ag = dp->ag;
576 struct ath12k_dp_hw_group *dp_hw_grp = &ag->dp_hw_grp;
577 struct ieee80211_rx_status rx_status = {};
578 struct ath12k_skb_rxcb *rxcb;
579 struct sk_buff *msdu;
580 struct ath12k *ar;
581 struct ath12k_pdev_dp *dp_pdev;
582 struct ath12k_hw_link *hw_links = ag->hw_links;
583 struct ath12k_base *partner_ab;
584 struct hal_rx_desc_data rx_info;
585 struct ath12k_dp *partner_dp;
586 u8 hw_link_id, pdev_idx;
587 int ret;
588
589 if (skb_queue_empty(msdu_list))
590 return;
591
592 rx_info.addr2_present = false;
593 rx_info.rx_status = &rx_status;
594
595 rcu_read_lock();
596
597 while ((msdu = __skb_dequeue(msdu_list))) {
598 rxcb = ATH12K_SKB_RXCB(msdu);
599 hw_link_id = rxcb->hw_link_id;
600 partner_dp = ath12k_dp_hw_grp_to_dp(dp_hw_grp,
601 hw_links[hw_link_id].device_id);
602 pdev_idx = ath12k_hw_mac_id_to_pdev_id(partner_dp->hw_params,
603 hw_links[hw_link_id].pdev_idx);
604 partner_ab = partner_dp->ab;
605 ar = partner_ab->pdevs[pdev_idx].ar;
606 if (!rcu_dereference(partner_ab->pdevs_active[pdev_idx])) {
607 dev_kfree_skb_any(msdu);
608 continue;
609 }
610
611 if (test_bit(ATH12K_FLAG_CAC_RUNNING, &ar->dev_flags)) {
612 dev_kfree_skb_any(msdu);
613 continue;
614 }
615
616 dp_pdev = ath12k_dp_to_pdev_dp(partner_dp, pdev_idx);
617 if (!dp_pdev) {
618 dev_kfree_skb_any(msdu);
619 continue;
620 }
621
622 ret = ath12k_wifi7_dp_rx_process_msdu(dp_pdev, msdu, msdu_list, &rx_info);
623 if (ret) {
624 ath12k_dbg(dp->ab, ATH12K_DBG_DATA,
625 "Unable to process msdu %d", ret);
626 dev_kfree_skb_any(msdu);
627 continue;
628 }
629
630 ath12k_dp_rx_deliver_msdu(dp_pdev, napi, msdu, &rx_info);
631 }
632
633 rcu_read_unlock();
634 }
635
ath12k_wifi7_dp_rx_process(struct ath12k_dp * dp,int ring_id,struct napi_struct * napi,int budget)636 int ath12k_wifi7_dp_rx_process(struct ath12k_dp *dp, int ring_id,
637 struct napi_struct *napi, int budget)
638 {
639 struct ath12k_hw_group *ag = dp->ag;
640 struct ath12k_base *ab = dp->ab;
641 struct ath12k_hal *hal = dp->hal;
642 struct ath12k_dp_hw_group *dp_hw_grp = &ag->dp_hw_grp;
643 struct list_head rx_desc_used_list[ATH12K_MAX_DEVICES];
644 struct ath12k_hw_link *hw_links = ag->hw_links;
645 int num_buffs_reaped[ATH12K_MAX_DEVICES] = {};
646 struct ath12k_rx_desc_info *desc_info;
647 struct dp_rxdma_ring *rx_ring = &dp->rx_refill_buf_ring;
648 struct hal_reo_dest_ring *desc;
649 struct ath12k_dp *partner_dp;
650 struct sk_buff_head msdu_list;
651 struct ath12k_skb_rxcb *rxcb;
652 int total_msdu_reaped = 0;
653 u8 hw_link_id, device_id;
654 struct hal_srng *srng;
655 struct sk_buff *msdu;
656 bool done = false;
657 u64 desc_va;
658
659 __skb_queue_head_init(&msdu_list);
660
661 for (device_id = 0; device_id < ATH12K_MAX_DEVICES; device_id++)
662 INIT_LIST_HEAD(&rx_desc_used_list[device_id]);
663
664 srng = &hal->srng_list[dp->reo_dst_ring[ring_id].ring_id];
665
666 spin_lock_bh(&srng->lock);
667
668 try_again:
669 ath12k_hal_srng_access_begin(ab, srng);
670
671 while ((desc = ath12k_hal_srng_dst_get_next_entry(ab, srng))) {
672 struct rx_mpdu_desc *mpdu_info;
673 struct rx_msdu_desc *msdu_info;
674 enum hal_reo_dest_ring_push_reason push_reason;
675 u32 cookie;
676
677 cookie = le32_get_bits(desc->buf_addr_info.info1,
678 BUFFER_ADDR_INFO1_SW_COOKIE);
679
680 hw_link_id = le32_get_bits(desc->info0,
681 HAL_REO_DEST_RING_INFO0_SRC_LINK_ID);
682
683 desc_va = ((u64)le32_to_cpu(desc->buf_va_hi) << 32 |
684 le32_to_cpu(desc->buf_va_lo));
685 desc_info = (struct ath12k_rx_desc_info *)((unsigned long)desc_va);
686
687 device_id = hw_links[hw_link_id].device_id;
688 partner_dp = ath12k_dp_hw_grp_to_dp(dp_hw_grp, device_id);
689 if (unlikely(!partner_dp)) {
690 if (desc_info->skb) {
691 dev_kfree_skb_any(desc_info->skb);
692 desc_info->skb = NULL;
693 }
694
695 continue;
696 }
697
698 /* retry manual desc retrieval */
699 if (!desc_info) {
700 desc_info = ath12k_dp_get_rx_desc(partner_dp, cookie);
701 if (!desc_info) {
702 ath12k_warn(partner_dp->ab, "Invalid cookie in manual descriptor retrieval: 0x%x\n",
703 cookie);
704 continue;
705 }
706 }
707
708 if (desc_info->magic != ATH12K_DP_RX_DESC_MAGIC)
709 ath12k_warn(ab, "Check HW CC implementation");
710
711 msdu = desc_info->skb;
712 desc_info->skb = NULL;
713
714 list_add_tail(&desc_info->list, &rx_desc_used_list[device_id]);
715
716 rxcb = ATH12K_SKB_RXCB(msdu);
717 dma_unmap_single(partner_dp->dev, rxcb->paddr,
718 msdu->len + skb_tailroom(msdu),
719 DMA_FROM_DEVICE);
720
721 num_buffs_reaped[device_id]++;
722 dp->device_stats.reo_rx[ring_id][dp->device_id]++;
723
724 push_reason = le32_get_bits(desc->info0,
725 HAL_REO_DEST_RING_INFO0_PUSH_REASON);
726 if (push_reason !=
727 HAL_REO_DEST_RING_PUSH_REASON_ROUTING_INSTRUCTION) {
728 dev_kfree_skb_any(msdu);
729 dp->device_stats.hal_reo_error[ring_id]++;
730 continue;
731 }
732
733 msdu_info = &desc->rx_msdu_info;
734 mpdu_info = &desc->rx_mpdu_info;
735
736 rxcb->is_first_msdu = !!(le32_to_cpu(msdu_info->info0) &
737 RX_MSDU_DESC_INFO0_FIRST_MSDU_IN_MPDU);
738 rxcb->is_last_msdu = !!(le32_to_cpu(msdu_info->info0) &
739 RX_MSDU_DESC_INFO0_LAST_MSDU_IN_MPDU);
740 rxcb->is_continuation = !!(le32_to_cpu(msdu_info->info0) &
741 RX_MSDU_DESC_INFO0_MSDU_CONTINUATION);
742 rxcb->hw_link_id = hw_link_id;
743 rxcb->peer_id = ath12k_wifi7_dp_rx_get_peer_id(dp, dp->peer_metadata_ver,
744 mpdu_info->peer_meta_data);
745 rxcb->tid = le32_get_bits(mpdu_info->info0,
746 RX_MPDU_DESC_INFO0_TID);
747
748 __skb_queue_tail(&msdu_list, msdu);
749
750 if (!rxcb->is_continuation) {
751 total_msdu_reaped++;
752 done = true;
753 } else {
754 done = false;
755 }
756
757 if (total_msdu_reaped >= budget)
758 break;
759 }
760
761 /* Hw might have updated the head pointer after we cached it.
762 * In this case, even though there are entries in the ring we'll
763 * get rx_desc NULL. Give the read another try with updated cached
764 * head pointer so that we can reap complete MPDU in the current
765 * rx processing.
766 */
767 if (!done && ath12k_hal_srng_dst_num_free(ab, srng, true)) {
768 ath12k_hal_srng_access_end(ab, srng);
769 goto try_again;
770 }
771
772 ath12k_hal_srng_access_end(ab, srng);
773
774 spin_unlock_bh(&srng->lock);
775
776 if (!total_msdu_reaped)
777 goto exit;
778
779 for (device_id = 0; device_id < ATH12K_MAX_DEVICES; device_id++) {
780 if (!num_buffs_reaped[device_id])
781 continue;
782
783 partner_dp = ath12k_dp_hw_grp_to_dp(dp_hw_grp, device_id);
784 rx_ring = &partner_dp->rx_refill_buf_ring;
785
786 ath12k_dp_rx_bufs_replenish(partner_dp, rx_ring,
787 &rx_desc_used_list[device_id],
788 num_buffs_reaped[device_id]);
789 }
790
791 ath12k_wifi7_dp_rx_process_received_packets(dp, napi, &msdu_list,
792 ring_id);
793
794 exit:
795 return total_msdu_reaped;
796 }
797
798 static bool
ath12k_wifi7_dp_rx_h_defrag_validate_incr_pn(struct ath12k_pdev_dp * dp_pdev,struct ath12k_dp_rx_tid * rx_tid,enum hal_encrypt_type encrypt_type)799 ath12k_wifi7_dp_rx_h_defrag_validate_incr_pn(struct ath12k_pdev_dp *dp_pdev,
800 struct ath12k_dp_rx_tid *rx_tid,
801 enum hal_encrypt_type encrypt_type)
802 {
803 struct ath12k_dp *dp = dp_pdev->dp;
804 struct sk_buff *first_frag, *skb;
805 u64 last_pn;
806 u64 cur_pn;
807
808 first_frag = skb_peek(&rx_tid->rx_frags);
809
810 if (encrypt_type != HAL_ENCRYPT_TYPE_CCMP_128 &&
811 encrypt_type != HAL_ENCRYPT_TYPE_CCMP_256 &&
812 encrypt_type != HAL_ENCRYPT_TYPE_GCMP_128 &&
813 encrypt_type != HAL_ENCRYPT_TYPE_AES_GCMP_256)
814 return true;
815
816 last_pn = ath12k_dp_rx_h_get_pn(dp, first_frag);
817 skb_queue_walk(&rx_tid->rx_frags, skb) {
818 if (skb == first_frag)
819 continue;
820
821 cur_pn = ath12k_dp_rx_h_get_pn(dp, skb);
822 if (cur_pn != last_pn + 1)
823 return false;
824 last_pn = cur_pn;
825 }
826 return true;
827 }
828
ath12k_wifi7_dp_rx_h_defrag_reo_reinject(struct ath12k_dp * dp,struct ath12k_dp_rx_tid * rx_tid,struct sk_buff * defrag_skb)829 static int ath12k_wifi7_dp_rx_h_defrag_reo_reinject(struct ath12k_dp *dp,
830 struct ath12k_dp_rx_tid *rx_tid,
831 struct sk_buff *defrag_skb)
832 {
833 struct ath12k_base *ab = dp->ab;
834 struct ath12k_hal *hal = dp->hal;
835 struct hal_rx_desc *rx_desc = (struct hal_rx_desc *)defrag_skb->data;
836 struct hal_reo_entrance_ring *reo_ent_ring;
837 struct hal_reo_dest_ring *reo_dest_ring;
838 struct dp_link_desc_bank *link_desc_banks;
839 struct hal_rx_msdu_link *msdu_link;
840 struct hal_rx_msdu_details *msdu0;
841 struct hal_srng *srng;
842 dma_addr_t link_paddr, buf_paddr;
843 u32 desc_bank, msdu_info, msdu_ext_info, mpdu_info;
844 u32 cookie, hal_rx_desc_sz, dest_ring_info0, queue_addr_hi;
845 int ret;
846 struct ath12k_rx_desc_info *desc_info;
847 enum hal_rx_buf_return_buf_manager idle_link_rbm = dp->idle_link_rbm;
848 u8 dst_ind;
849
850 hal_rx_desc_sz = hal->hal_desc_sz;
851 link_desc_banks = dp->link_desc_banks;
852 reo_dest_ring = rx_tid->dst_ring_desc;
853
854 ath12k_wifi7_hal_rx_reo_ent_paddr_get(&reo_dest_ring->buf_addr_info,
855 &link_paddr, &cookie);
856 desc_bank = u32_get_bits(cookie, DP_LINK_DESC_BANK_MASK);
857
858 msdu_link = (struct hal_rx_msdu_link *)(link_desc_banks[desc_bank].vaddr +
859 (link_paddr - link_desc_banks[desc_bank].paddr));
860 msdu0 = &msdu_link->msdu_link[0];
861 msdu_ext_info = le32_to_cpu(msdu0->rx_msdu_ext_info.info0);
862 dst_ind = u32_get_bits(msdu_ext_info, RX_MSDU_EXT_DESC_INFO0_REO_DEST_IND);
863
864 memset(msdu0, 0, sizeof(*msdu0));
865
866 msdu_info = u32_encode_bits(1, RX_MSDU_DESC_INFO0_FIRST_MSDU_IN_MPDU) |
867 u32_encode_bits(1, RX_MSDU_DESC_INFO0_LAST_MSDU_IN_MPDU) |
868 u32_encode_bits(0, RX_MSDU_DESC_INFO0_MSDU_CONTINUATION) |
869 u32_encode_bits(defrag_skb->len - hal_rx_desc_sz,
870 RX_MSDU_DESC_INFO0_MSDU_LENGTH) |
871 u32_encode_bits(1, RX_MSDU_DESC_INFO0_VALID_SA) |
872 u32_encode_bits(1, RX_MSDU_DESC_INFO0_VALID_DA);
873 msdu0->rx_msdu_info.info0 = cpu_to_le32(msdu_info);
874 msdu0->rx_msdu_ext_info.info0 = cpu_to_le32(msdu_ext_info);
875
876 /* change msdu len in hal rx desc */
877 ath12k_dp_rxdesc_set_msdu_len(hal, rx_desc, defrag_skb->len - hal_rx_desc_sz);
878
879 buf_paddr = dma_map_single(dp->dev, defrag_skb->data,
880 defrag_skb->len + skb_tailroom(defrag_skb),
881 DMA_TO_DEVICE);
882 if (dma_mapping_error(dp->dev, buf_paddr))
883 return -ENOMEM;
884
885 spin_lock_bh(&dp->rx_desc_lock);
886 desc_info = list_first_entry_or_null(&dp->rx_desc_free_list,
887 struct ath12k_rx_desc_info,
888 list);
889 if (!desc_info) {
890 spin_unlock_bh(&dp->rx_desc_lock);
891 ath12k_warn(ab, "failed to find rx desc for reinject\n");
892 ret = -ENOMEM;
893 goto err_unmap_dma;
894 }
895
896 desc_info->skb = defrag_skb;
897 desc_info->in_use = true;
898
899 list_del(&desc_info->list);
900 spin_unlock_bh(&dp->rx_desc_lock);
901
902 ATH12K_SKB_RXCB(defrag_skb)->paddr = buf_paddr;
903
904 ath12k_wifi7_hal_rx_buf_addr_info_set(&msdu0->buf_addr_info, buf_paddr,
905 desc_info->cookie,
906 HAL_RX_BUF_RBM_SW3_BM);
907
908 /* Fill mpdu details into reo entrance ring */
909 srng = &hal->srng_list[dp->reo_reinject_ring.ring_id];
910
911 spin_lock_bh(&srng->lock);
912 ath12k_hal_srng_access_begin(ab, srng);
913
914 reo_ent_ring = ath12k_hal_srng_src_get_next_entry(ab, srng);
915 if (!reo_ent_ring) {
916 ath12k_hal_srng_access_end(ab, srng);
917 spin_unlock_bh(&srng->lock);
918 ret = -ENOSPC;
919 goto err_free_desc;
920 }
921 memset(reo_ent_ring, 0, sizeof(*reo_ent_ring));
922
923 ath12k_wifi7_hal_rx_buf_addr_info_set(&reo_ent_ring->buf_addr_info, link_paddr,
924 cookie, idle_link_rbm);
925
926 mpdu_info = u32_encode_bits(1, RX_MPDU_DESC_INFO0_MSDU_COUNT) |
927 u32_encode_bits(0, RX_MPDU_DESC_INFO0_FRAG_FLAG) |
928 u32_encode_bits(1, RX_MPDU_DESC_INFO0_RAW_MPDU) |
929 u32_encode_bits(1, RX_MPDU_DESC_INFO0_VALID_PN) |
930 u32_encode_bits(rx_tid->tid, RX_MPDU_DESC_INFO0_TID);
931
932 reo_ent_ring->rx_mpdu_info.info0 = cpu_to_le32(mpdu_info);
933 reo_ent_ring->rx_mpdu_info.peer_meta_data =
934 reo_dest_ring->rx_mpdu_info.peer_meta_data;
935
936 if (dp->hw_params->reoq_lut_support) {
937 reo_ent_ring->queue_addr_lo = reo_dest_ring->rx_mpdu_info.peer_meta_data;
938 queue_addr_hi = 0;
939 } else {
940 reo_ent_ring->queue_addr_lo =
941 cpu_to_le32(lower_32_bits(rx_tid->qbuf.paddr_aligned));
942 queue_addr_hi = upper_32_bits(rx_tid->qbuf.paddr_aligned);
943 }
944
945 reo_ent_ring->info0 = le32_encode_bits(queue_addr_hi,
946 HAL_REO_ENTR_RING_INFO0_QUEUE_ADDR_HI) |
947 le32_encode_bits(dst_ind,
948 HAL_REO_ENTR_RING_INFO0_DEST_IND);
949
950 reo_ent_ring->info1 = le32_encode_bits(rx_tid->cur_sn,
951 HAL_REO_ENTR_RING_INFO1_MPDU_SEQ_NUM);
952 dest_ring_info0 = le32_get_bits(reo_dest_ring->info0,
953 HAL_REO_DEST_RING_INFO0_SRC_LINK_ID);
954 reo_ent_ring->info2 =
955 cpu_to_le32(u32_get_bits(dest_ring_info0,
956 HAL_REO_ENTR_RING_INFO2_SRC_LINK_ID));
957
958 ath12k_hal_srng_access_end(ab, srng);
959 spin_unlock_bh(&srng->lock);
960
961 return 0;
962
963 err_free_desc:
964 spin_lock_bh(&dp->rx_desc_lock);
965 desc_info->in_use = false;
966 desc_info->skb = NULL;
967 list_add_tail(&desc_info->list, &dp->rx_desc_free_list);
968 spin_unlock_bh(&dp->rx_desc_lock);
969 err_unmap_dma:
970 dma_unmap_single(dp->dev, buf_paddr, defrag_skb->len + skb_tailroom(defrag_skb),
971 DMA_TO_DEVICE);
972 return ret;
973 }
974
ath12k_wifi7_dp_rx_h_verify_tkip_mic(struct ath12k_pdev_dp * dp_pdev,struct ath12k_dp_peer * peer,enum hal_encrypt_type enctype,struct sk_buff * msdu,struct hal_rx_desc_data * rx_info)975 static int ath12k_wifi7_dp_rx_h_verify_tkip_mic(struct ath12k_pdev_dp *dp_pdev,
976 struct ath12k_dp_peer *peer,
977 enum hal_encrypt_type enctype,
978 struct sk_buff *msdu,
979 struct hal_rx_desc_data *rx_info)
980 {
981 struct ath12k_dp *dp = dp_pdev->dp;
982 struct ath12k_hal *hal = dp->hal;
983 struct hal_rx_desc *rx_desc = (struct hal_rx_desc *)msdu->data;
984 struct ieee80211_rx_status *rxs = IEEE80211_SKB_RXCB(msdu);
985 struct ieee80211_key_conf *key_conf;
986 struct ieee80211_hdr *hdr;
987 u8 mic[IEEE80211_CCMP_MIC_LEN];
988 int head_len, tail_len, ret;
989 size_t data_len;
990 u32 hdr_len, hal_rx_desc_sz = hal->hal_desc_sz;
991 u8 *key, *data;
992 u8 key_idx;
993
994 if (enctype != HAL_ENCRYPT_TYPE_TKIP_MIC)
995 return 0;
996
997 rx_info->addr2_present = false;
998 rx_info->rx_status = rxs;
999
1000 hdr = (struct ieee80211_hdr *)(msdu->data + hal_rx_desc_sz);
1001 hdr_len = ieee80211_hdrlen(hdr->frame_control);
1002 head_len = hdr_len + hal_rx_desc_sz + IEEE80211_TKIP_IV_LEN;
1003 tail_len = IEEE80211_CCMP_MIC_LEN + IEEE80211_TKIP_ICV_LEN + FCS_LEN;
1004
1005 if (!is_multicast_ether_addr(hdr->addr1))
1006 key_idx = peer->ucast_keyidx;
1007 else
1008 key_idx = peer->mcast_keyidx;
1009
1010 key_conf = peer->keys[key_idx];
1011
1012 data = msdu->data + head_len;
1013 data_len = msdu->len - head_len - tail_len;
1014 key = &key_conf->key[NL80211_TKIP_DATA_OFFSET_RX_MIC_KEY];
1015
1016 ret = ath12k_dp_rx_h_michael_mic(peer->tfm_mmic, key, hdr, data,
1017 data_len, mic);
1018 if (ret || memcmp(mic, data + data_len, IEEE80211_CCMP_MIC_LEN))
1019 goto mic_fail;
1020
1021 return 0;
1022
1023 mic_fail:
1024 (ATH12K_SKB_RXCB(msdu))->is_first_msdu = true;
1025 (ATH12K_SKB_RXCB(msdu))->is_last_msdu = true;
1026
1027 ath12k_dp_extract_rx_desc_data(hal, rx_info, rx_desc, rx_desc);
1028
1029 rxs->flag |= RX_FLAG_MMIC_ERROR | RX_FLAG_MMIC_STRIPPED |
1030 RX_FLAG_IV_STRIPPED | RX_FLAG_DECRYPTED;
1031 skb_pull(msdu, hal_rx_desc_sz);
1032
1033 if (unlikely(!ath12k_dp_rx_check_nwifi_hdr_len_valid(dp, rx_desc, msdu,
1034 rx_info)))
1035 return -EINVAL;
1036
1037 ath12k_dp_rx_h_ppdu(dp_pdev, rx_info);
1038 ath12k_dp_rx_h_undecap(dp_pdev, msdu, rx_desc,
1039 HAL_ENCRYPT_TYPE_TKIP_MIC, true, rx_info);
1040 ieee80211_rx(ath12k_pdev_dp_to_hw(dp_pdev), msdu);
1041 return -EINVAL;
1042 }
1043
ath12k_wifi7_dp_rx_h_defrag(struct ath12k_pdev_dp * dp_pdev,struct ath12k_dp_peer * peer,struct ath12k_dp_rx_tid * rx_tid,struct sk_buff ** defrag_skb,enum hal_encrypt_type enctype,struct hal_rx_desc_data * rx_info)1044 static int ath12k_wifi7_dp_rx_h_defrag(struct ath12k_pdev_dp *dp_pdev,
1045 struct ath12k_dp_peer *peer,
1046 struct ath12k_dp_rx_tid *rx_tid,
1047 struct sk_buff **defrag_skb,
1048 enum hal_encrypt_type enctype,
1049 struct hal_rx_desc_data *rx_info)
1050 {
1051 struct ath12k_dp *dp = dp_pdev->dp;
1052 struct ath12k_base *ab = dp->ab;
1053 struct sk_buff *skb, *first_frag, *last_frag;
1054 struct ieee80211_hdr *hdr;
1055 bool is_decrypted = false;
1056 int msdu_len = 0;
1057 int extra_space;
1058 u32 flags, hal_rx_desc_sz = ab->hal.hal_desc_sz;
1059
1060 first_frag = skb_peek(&rx_tid->rx_frags);
1061 last_frag = skb_peek_tail(&rx_tid->rx_frags);
1062
1063 skb_queue_walk(&rx_tid->rx_frags, skb) {
1064 flags = 0;
1065 hdr = (struct ieee80211_hdr *)(skb->data + hal_rx_desc_sz);
1066
1067 if (enctype != HAL_ENCRYPT_TYPE_OPEN)
1068 is_decrypted = rx_info->is_decrypted;
1069
1070 if (is_decrypted) {
1071 if (skb != first_frag)
1072 flags |= RX_FLAG_IV_STRIPPED;
1073 if (skb != last_frag)
1074 flags |= RX_FLAG_ICV_STRIPPED |
1075 RX_FLAG_MIC_STRIPPED;
1076 }
1077
1078 /* RX fragments are always raw packets */
1079 if (skb != last_frag)
1080 skb_trim(skb, skb->len - FCS_LEN);
1081 ath12k_dp_rx_h_undecap_frag(dp_pdev, skb, enctype, flags);
1082
1083 if (skb != first_frag)
1084 skb_pull(skb, hal_rx_desc_sz +
1085 ieee80211_hdrlen(hdr->frame_control));
1086 msdu_len += skb->len;
1087 }
1088
1089 extra_space = msdu_len - (DP_RX_BUFFER_SIZE + skb_tailroom(first_frag));
1090 if (extra_space > 0 &&
1091 (pskb_expand_head(first_frag, 0, extra_space, GFP_ATOMIC) < 0))
1092 return -ENOMEM;
1093
1094 __skb_unlink(first_frag, &rx_tid->rx_frags);
1095 while ((skb = __skb_dequeue(&rx_tid->rx_frags))) {
1096 skb_put_data(first_frag, skb->data, skb->len);
1097 dev_kfree_skb_any(skb);
1098 }
1099
1100 hdr = (struct ieee80211_hdr *)(first_frag->data + hal_rx_desc_sz);
1101 hdr->frame_control &= ~__cpu_to_le16(IEEE80211_FCTL_MOREFRAGS);
1102 ATH12K_SKB_RXCB(first_frag)->is_frag = 1;
1103
1104 if (ath12k_wifi7_dp_rx_h_verify_tkip_mic(dp_pdev, peer, enctype, first_frag,
1105 rx_info))
1106 first_frag = NULL;
1107
1108 *defrag_skb = first_frag;
1109 return 0;
1110 }
1111
ath12k_wifi7_dp_rx_frags_cleanup(struct ath12k_dp_rx_tid * rx_tid,bool rel_link_desc)1112 void ath12k_wifi7_dp_rx_frags_cleanup(struct ath12k_dp_rx_tid *rx_tid,
1113 bool rel_link_desc)
1114 {
1115 enum hal_wbm_rel_bm_act act = HAL_WBM_REL_BM_ACT_PUT_IN_IDLE;
1116 struct ath12k_buffer_addr *buf_addr_info;
1117 struct ath12k_dp *dp = rx_tid->dp;
1118
1119 lockdep_assert_held(&dp->dp_lock);
1120
1121 if (rx_tid->dst_ring_desc) {
1122 if (rel_link_desc) {
1123 buf_addr_info = &rx_tid->dst_ring_desc->buf_addr_info;
1124 ath12k_wifi7_dp_rx_link_desc_return(dp, buf_addr_info, act);
1125 }
1126 kfree(rx_tid->dst_ring_desc);
1127 rx_tid->dst_ring_desc = NULL;
1128 }
1129
1130 rx_tid->cur_sn = 0;
1131 rx_tid->last_frag_no = 0;
1132 rx_tid->rx_frag_bitmap = 0;
1133 __skb_queue_purge(&rx_tid->rx_frags);
1134 }
1135
ath12k_wifi7_dp_rx_frag_h_mpdu(struct ath12k_pdev_dp * dp_pdev,struct sk_buff * msdu,struct hal_reo_dest_ring * ring_desc,struct hal_rx_desc_data * rx_info)1136 static int ath12k_wifi7_dp_rx_frag_h_mpdu(struct ath12k_pdev_dp *dp_pdev,
1137 struct sk_buff *msdu,
1138 struct hal_reo_dest_ring *ring_desc,
1139 struct hal_rx_desc_data *rx_info)
1140 {
1141 struct ath12k_dp *dp = dp_pdev->dp;
1142 struct ath12k_hal *hal = dp->hal;
1143 struct ath12k_base *ab = dp->ab;
1144 struct ath12k_dp_peer *peer;
1145 struct ath12k_dp_rx_tid *rx_tid;
1146 struct sk_buff *defrag_skb = NULL;
1147 u32 peer_id = rx_info->peer_id;
1148 u16 seqno, frag_no;
1149 u8 tid = rx_info->tid;
1150 int ret = 0;
1151 bool more_frags;
1152 enum hal_encrypt_type enctype = rx_info->enctype;
1153
1154 frag_no = ath12k_dp_rx_h_frag_no(hal, msdu);
1155 more_frags = ath12k_dp_rx_h_more_frags(hal, msdu);
1156 seqno = rx_info->seq_no;
1157
1158 if (!rx_info->seq_ctl_valid || !rx_info->fc_valid ||
1159 tid > IEEE80211_NUM_TIDS)
1160 return -EINVAL;
1161
1162 /* received unfragmented packet in reo
1163 * exception ring, this shouldn't happen
1164 * as these packets typically come from
1165 * reo2sw srngs.
1166 */
1167 if (WARN_ON_ONCE(!frag_no && !more_frags))
1168 return -EINVAL;
1169
1170 spin_lock_bh(&dp->dp_lock);
1171 peer = ath12k_dp_peer_find_by_peerid(dp_pdev, peer_id);
1172 if (!peer) {
1173 ath12k_warn(ab, "failed to find the peer to de-fragment received fragment peer_id %d\n",
1174 peer_id);
1175 ret = -ENOENT;
1176 goto out_unlock;
1177 }
1178
1179 if (!peer->dp_setup_done) {
1180 ath12k_warn(ab, "The peer %pM [%d] has uninitialized datapath\n",
1181 peer->addr, peer_id);
1182 ret = -ENOENT;
1183 goto out_unlock;
1184 }
1185
1186 rx_tid = &peer->rx_tid[tid];
1187
1188 if ((!skb_queue_empty(&rx_tid->rx_frags) && seqno != rx_tid->cur_sn) ||
1189 skb_queue_empty(&rx_tid->rx_frags)) {
1190 /* Flush stored fragments and start a new sequence */
1191 ath12k_wifi7_dp_rx_frags_cleanup(rx_tid, true);
1192 rx_tid->cur_sn = seqno;
1193 }
1194
1195 if (rx_tid->rx_frag_bitmap & BIT(frag_no)) {
1196 /* Fragment already present */
1197 ret = -EINVAL;
1198 goto out_unlock;
1199 }
1200
1201 if ((!rx_tid->rx_frag_bitmap || frag_no > __fls(rx_tid->rx_frag_bitmap)))
1202 __skb_queue_tail(&rx_tid->rx_frags, msdu);
1203 else
1204 ath12k_dp_rx_h_sort_frags(hal, &rx_tid->rx_frags, msdu);
1205
1206 rx_tid->rx_frag_bitmap |= BIT(frag_no);
1207 if (!more_frags)
1208 rx_tid->last_frag_no = frag_no;
1209
1210 if (frag_no == 0) {
1211 rx_tid->dst_ring_desc = kmemdup(ring_desc,
1212 sizeof(*rx_tid->dst_ring_desc),
1213 GFP_ATOMIC);
1214 if (!rx_tid->dst_ring_desc) {
1215 ret = -ENOMEM;
1216 goto out_unlock;
1217 }
1218 } else {
1219 ath12k_wifi7_dp_rx_link_desc_return(dp, &ring_desc->buf_addr_info,
1220 HAL_WBM_REL_BM_ACT_PUT_IN_IDLE);
1221 }
1222
1223 if (!rx_tid->last_frag_no ||
1224 rx_tid->rx_frag_bitmap != GENMASK(rx_tid->last_frag_no, 0)) {
1225 mod_timer(&rx_tid->frag_timer, jiffies +
1226 ATH12K_DP_RX_FRAGMENT_TIMEOUT_MS);
1227 goto out_unlock;
1228 }
1229
1230 spin_unlock_bh(&dp->dp_lock);
1231 timer_delete_sync(&rx_tid->frag_timer);
1232 spin_lock_bh(&dp->dp_lock);
1233
1234 peer = ath12k_dp_peer_find_by_peerid(dp_pdev, peer_id);
1235 if (!peer)
1236 goto err_frags_cleanup;
1237
1238 if (!ath12k_wifi7_dp_rx_h_defrag_validate_incr_pn(dp_pdev, rx_tid, enctype))
1239 goto err_frags_cleanup;
1240
1241 if (ath12k_wifi7_dp_rx_h_defrag(dp_pdev, peer, rx_tid, &defrag_skb,
1242 enctype, rx_info))
1243 goto err_frags_cleanup;
1244
1245 if (!defrag_skb)
1246 goto err_frags_cleanup;
1247
1248 if (ath12k_wifi7_dp_rx_h_defrag_reo_reinject(dp, rx_tid, defrag_skb))
1249 goto err_frags_cleanup;
1250
1251 ath12k_wifi7_dp_rx_frags_cleanup(rx_tid, false);
1252 goto out_unlock;
1253
1254 err_frags_cleanup:
1255 dev_kfree_skb_any(defrag_skb);
1256 ath12k_wifi7_dp_rx_frags_cleanup(rx_tid, true);
1257 out_unlock:
1258 spin_unlock_bh(&dp->dp_lock);
1259 return ret;
1260 }
1261
1262 static int
ath12k_wifi7_dp_process_rx_err_buf(struct ath12k_pdev_dp * dp_pdev,struct hal_reo_dest_ring * desc,struct list_head * used_list,bool drop,u32 cookie)1263 ath12k_wifi7_dp_process_rx_err_buf(struct ath12k_pdev_dp *dp_pdev,
1264 struct hal_reo_dest_ring *desc,
1265 struct list_head *used_list,
1266 bool drop, u32 cookie)
1267 {
1268 struct ath12k *ar = ath12k_pdev_dp_to_ar(dp_pdev);
1269 struct ath12k_dp *dp = dp_pdev->dp;
1270 struct ath12k_hal *hal = dp->hal;
1271 struct sk_buff *msdu;
1272 struct ath12k_skb_rxcb *rxcb;
1273 struct hal_rx_desc_data rx_info;
1274 struct hal_rx_desc *rx_desc;
1275 u16 msdu_len;
1276 u32 hal_rx_desc_sz = hal->hal_desc_sz;
1277 struct ath12k_rx_desc_info *desc_info;
1278 u64 desc_va;
1279
1280 desc_va = ((u64)le32_to_cpu(desc->buf_va_hi) << 32 |
1281 le32_to_cpu(desc->buf_va_lo));
1282 desc_info = (struct ath12k_rx_desc_info *)((unsigned long)desc_va);
1283
1284 /* retry manual desc retrieval */
1285 if (!desc_info) {
1286 desc_info = ath12k_dp_get_rx_desc(dp, cookie);
1287 if (!desc_info) {
1288 ath12k_warn(dp->ab,
1289 "Invalid cookie in DP rx error descriptor retrieval: 0x%x\n",
1290 cookie);
1291 return -EINVAL;
1292 }
1293 }
1294
1295 if (desc_info->magic != ATH12K_DP_RX_DESC_MAGIC)
1296 ath12k_warn(dp->ab, "RX Exception, Check HW CC implementation");
1297
1298 msdu = desc_info->skb;
1299 desc_info->skb = NULL;
1300
1301 list_add_tail(&desc_info->list, used_list);
1302
1303 rxcb = ATH12K_SKB_RXCB(msdu);
1304 dma_unmap_single(dp->dev, rxcb->paddr,
1305 msdu->len + skb_tailroom(msdu),
1306 DMA_FROM_DEVICE);
1307
1308 if (drop) {
1309 dev_kfree_skb_any(msdu);
1310 return 0;
1311 }
1312
1313 rcu_read_lock();
1314 if (!rcu_dereference(ar->ab->pdevs_active[ar->pdev_idx])) {
1315 dev_kfree_skb_any(msdu);
1316 goto exit;
1317 }
1318
1319 if (test_bit(ATH12K_FLAG_CAC_RUNNING, &ar->dev_flags)) {
1320 dev_kfree_skb_any(msdu);
1321 goto exit;
1322 }
1323
1324 rx_desc = (struct hal_rx_desc *)msdu->data;
1325 ath12k_dp_extract_rx_desc_data(hal, &rx_info, rx_desc, rx_desc);
1326
1327 msdu_len = rx_info.msdu_len;
1328 if ((msdu_len + hal_rx_desc_sz) > DP_RX_BUFFER_SIZE) {
1329 ath12k_warn(dp->ab, "invalid msdu leng %u", msdu_len);
1330 ath12k_dbg_dump(dp->ab, ATH12K_DBG_DATA, NULL, "", rx_desc,
1331 sizeof(*rx_desc));
1332 dev_kfree_skb_any(msdu);
1333 goto exit;
1334 }
1335
1336 skb_put(msdu, hal_rx_desc_sz + msdu_len);
1337
1338 if (ath12k_wifi7_dp_rx_frag_h_mpdu(dp_pdev, msdu, desc, &rx_info)) {
1339 dev_kfree_skb_any(msdu);
1340 ath12k_wifi7_dp_rx_link_desc_return(dp, &desc->buf_addr_info,
1341 HAL_WBM_REL_BM_ACT_PUT_IN_IDLE);
1342 }
1343 exit:
1344 rcu_read_unlock();
1345 return 0;
1346 }
1347
ath12k_dp_h_msdu_buffer_type(struct ath12k_dp * dp,struct list_head * list,struct hal_reo_dest_ring * desc)1348 static int ath12k_dp_h_msdu_buffer_type(struct ath12k_dp *dp,
1349 struct list_head *list,
1350 struct hal_reo_dest_ring *desc)
1351 {
1352 struct ath12k_rx_desc_info *desc_info;
1353 struct ath12k_skb_rxcb *rxcb;
1354 struct sk_buff *msdu;
1355 u64 desc_va;
1356
1357 dp->device_stats.reo_excep_msdu_buf_type++;
1358
1359 desc_va = (u64)le32_to_cpu(desc->buf_va_hi) << 32 |
1360 le32_to_cpu(desc->buf_va_lo);
1361 desc_info = (struct ath12k_rx_desc_info *)(uintptr_t)desc_va;
1362 if (!desc_info) {
1363 u32 cookie;
1364
1365 cookie = le32_get_bits(desc->buf_addr_info.info1,
1366 BUFFER_ADDR_INFO1_SW_COOKIE);
1367 desc_info = ath12k_dp_get_rx_desc(dp, cookie);
1368 if (!desc_info) {
1369 ath12k_warn(dp->ab, "Invalid cookie in manual descriptor retrieval: 0x%x\n",
1370 cookie);
1371 return -EINVAL;
1372 }
1373 }
1374
1375 if (desc_info->magic != ATH12K_DP_RX_DESC_MAGIC) {
1376 ath12k_warn(dp->ab, "rx exception, magic check failed with value: %u\n",
1377 desc_info->magic);
1378 return -EINVAL;
1379 }
1380
1381 msdu = desc_info->skb;
1382 desc_info->skb = NULL;
1383 list_add_tail(&desc_info->list, list);
1384 rxcb = ATH12K_SKB_RXCB(msdu);
1385 dma_unmap_single(dp->dev, rxcb->paddr, msdu->len + skb_tailroom(msdu),
1386 DMA_FROM_DEVICE);
1387 dev_kfree_skb_any(msdu);
1388
1389 return 0;
1390 }
1391
ath12k_wifi7_dp_rx_process_err(struct ath12k_dp * dp,struct napi_struct * napi,int budget)1392 int ath12k_wifi7_dp_rx_process_err(struct ath12k_dp *dp, struct napi_struct *napi,
1393 int budget)
1394 {
1395 struct ath12k_base *ab = dp->ab;
1396 struct ath12k_hal *hal = dp->hal;
1397 struct ath12k_hw_group *ag = dp->ag;
1398 struct ath12k_dp_hw_group *dp_hw_grp = &ag->dp_hw_grp;
1399 struct ath12k_dp *partner_dp;
1400 struct list_head rx_desc_used_list[ATH12K_MAX_DEVICES];
1401 u32 msdu_cookies[HAL_NUM_RX_MSDUS_PER_LINK_DESC];
1402 int num_buffs_reaped[ATH12K_MAX_DEVICES] = {};
1403 struct dp_link_desc_bank *link_desc_banks;
1404 enum hal_rx_buf_return_buf_manager rbm;
1405 struct hal_rx_msdu_link *link_desc_va;
1406 int tot_n_bufs_reaped, quota, ret, i;
1407 struct hal_reo_dest_ring *reo_desc;
1408 struct dp_rxdma_ring *rx_ring;
1409 struct dp_srng *reo_except;
1410 struct ath12k_hw_link *hw_links = ag->hw_links;
1411 struct ath12k_pdev_dp *dp_pdev;
1412 u8 hw_link_id, device_id;
1413 u32 desc_bank, num_msdus;
1414 struct hal_srng *srng;
1415 dma_addr_t paddr;
1416 bool is_frag;
1417 bool drop;
1418 int pdev_idx;
1419 struct list_head *used_list;
1420 enum hal_wbm_rel_bm_act act;
1421
1422 tot_n_bufs_reaped = 0;
1423 quota = budget;
1424
1425 for (device_id = 0; device_id < ATH12K_MAX_DEVICES; device_id++)
1426 INIT_LIST_HEAD(&rx_desc_used_list[device_id]);
1427
1428 reo_except = &dp->reo_except_ring;
1429
1430 srng = &hal->srng_list[reo_except->ring_id];
1431
1432 spin_lock_bh(&srng->lock);
1433
1434 ath12k_hal_srng_access_begin(ab, srng);
1435
1436 while (budget &&
1437 (reo_desc = ath12k_hal_srng_dst_get_next_entry(ab, srng))) {
1438 drop = false;
1439 dp->device_stats.err_ring_pkts++;
1440
1441 hw_link_id = le32_get_bits(reo_desc->info0,
1442 HAL_REO_DEST_RING_INFO0_SRC_LINK_ID);
1443 device_id = hw_links[hw_link_id].device_id;
1444 partner_dp = ath12k_dp_hw_grp_to_dp(dp_hw_grp, device_id);
1445
1446 /* Below case is added to handle data packet from un-associated clients.
1447 * As it is expected that AST lookup will fail for
1448 * un-associated station's data packets.
1449 */
1450 if (le32_get_bits(reo_desc->info0, HAL_REO_DEST_RING_INFO0_BUFFER_TYPE) ==
1451 HAL_REO_DEST_RING_BUFFER_TYPE_MSDU) {
1452 if (!ath12k_dp_h_msdu_buffer_type(partner_dp,
1453 &rx_desc_used_list[device_id],
1454 reo_desc)) {
1455 num_buffs_reaped[device_id]++;
1456 tot_n_bufs_reaped++;
1457 }
1458 goto next_desc;
1459 }
1460
1461 ret = ath12k_wifi7_hal_desc_reo_parse_err(dp, reo_desc, &paddr,
1462 &desc_bank);
1463 if (ret) {
1464 ath12k_warn(ab, "failed to parse error reo desc %d\n",
1465 ret);
1466 continue;
1467 }
1468
1469 pdev_idx = ath12k_hw_mac_id_to_pdev_id(partner_dp->hw_params,
1470 hw_links[hw_link_id].pdev_idx);
1471
1472 link_desc_banks = partner_dp->link_desc_banks;
1473 link_desc_va = link_desc_banks[desc_bank].vaddr +
1474 (paddr - link_desc_banks[desc_bank].paddr);
1475 ath12k_wifi7_hal_rx_msdu_link_info_get(link_desc_va, &num_msdus,
1476 msdu_cookies, &rbm);
1477 if (rbm != partner_dp->idle_link_rbm &&
1478 rbm != HAL_RX_BUF_RBM_SW3_BM &&
1479 rbm != partner_dp->hal->hal_params->rx_buf_rbm) {
1480 act = HAL_WBM_REL_BM_ACT_REL_MSDU;
1481 dp->device_stats.invalid_rbm++;
1482 ath12k_warn(ab, "invalid return buffer manager %d\n", rbm);
1483 ath12k_wifi7_dp_rx_link_desc_return(partner_dp,
1484 &reo_desc->buf_addr_info,
1485 act);
1486 continue;
1487 }
1488
1489 is_frag = !!(le32_to_cpu(reo_desc->rx_mpdu_info.info0) &
1490 RX_MPDU_DESC_INFO0_FRAG_FLAG);
1491
1492 /* Process only rx fragments with one msdu per link desc below, and drop
1493 * msdu's indicated due to error reasons.
1494 * Dynamic fragmentation not supported in Multi-link client, so drop the
1495 * partner device buffers.
1496 */
1497 if (!is_frag || num_msdus > 1 ||
1498 partner_dp->device_id != dp->device_id) {
1499 drop = true;
1500 act = HAL_WBM_REL_BM_ACT_PUT_IN_IDLE;
1501
1502 /* Return the link desc back to wbm idle list */
1503 ath12k_wifi7_dp_rx_link_desc_return(partner_dp,
1504 &reo_desc->buf_addr_info,
1505 act);
1506 }
1507
1508 rcu_read_lock();
1509
1510 dp_pdev = ath12k_dp_to_pdev_dp(dp, pdev_idx);
1511 if (!dp_pdev) {
1512 rcu_read_unlock();
1513 continue;
1514 }
1515
1516 for (i = 0; i < num_msdus; i++) {
1517 used_list = &rx_desc_used_list[device_id];
1518
1519 if (!ath12k_wifi7_dp_process_rx_err_buf(dp_pdev, reo_desc,
1520 used_list,
1521 drop,
1522 msdu_cookies[i])) {
1523 num_buffs_reaped[device_id]++;
1524 tot_n_bufs_reaped++;
1525 }
1526 }
1527
1528 rcu_read_unlock();
1529
1530 next_desc:
1531 if (tot_n_bufs_reaped >= quota) {
1532 tot_n_bufs_reaped = quota;
1533 goto exit;
1534 }
1535
1536 budget = quota - tot_n_bufs_reaped;
1537 }
1538
1539 exit:
1540 ath12k_hal_srng_access_end(ab, srng);
1541
1542 spin_unlock_bh(&srng->lock);
1543
1544 for (device_id = 0; device_id < ATH12K_MAX_DEVICES; device_id++) {
1545 if (!num_buffs_reaped[device_id])
1546 continue;
1547
1548 partner_dp = ath12k_dp_hw_grp_to_dp(dp_hw_grp, device_id);
1549 rx_ring = &partner_dp->rx_refill_buf_ring;
1550
1551 ath12k_dp_rx_bufs_replenish(partner_dp, rx_ring,
1552 &rx_desc_used_list[device_id],
1553 num_buffs_reaped[device_id]);
1554 }
1555
1556 return tot_n_bufs_reaped;
1557 }
1558
1559 static void
ath12k_wifi7_dp_rx_null_q_desc_sg_drop(struct ath12k_dp * dp,int msdu_len,struct sk_buff_head * msdu_list)1560 ath12k_wifi7_dp_rx_null_q_desc_sg_drop(struct ath12k_dp *dp, int msdu_len,
1561 struct sk_buff_head *msdu_list)
1562 {
1563 struct sk_buff *skb, *tmp;
1564 struct ath12k_skb_rxcb *rxcb;
1565 int n_buffs;
1566
1567 n_buffs = DIV_ROUND_UP(msdu_len,
1568 (DP_RX_BUFFER_SIZE - dp->ab->hal.hal_desc_sz));
1569
1570 skb_queue_walk_safe(msdu_list, skb, tmp) {
1571 rxcb = ATH12K_SKB_RXCB(skb);
1572 if (rxcb->err_rel_src == HAL_WBM_REL_SRC_MODULE_REO &&
1573 rxcb->err_code == HAL_REO_DEST_RING_ERROR_CODE_DESC_ADDR_ZERO) {
1574 if (!n_buffs)
1575 break;
1576 __skb_unlink(skb, msdu_list);
1577 dev_kfree_skb_any(skb);
1578 n_buffs--;
1579 }
1580 }
1581 }
1582
ath12k_wifi7_dp_rx_h_null_q_desc(struct ath12k_pdev_dp * dp_pdev,struct sk_buff * msdu,struct hal_rx_desc_data * rx_info,struct sk_buff_head * msdu_list)1583 static int ath12k_wifi7_dp_rx_h_null_q_desc(struct ath12k_pdev_dp *dp_pdev,
1584 struct sk_buff *msdu,
1585 struct hal_rx_desc_data *rx_info,
1586 struct sk_buff_head *msdu_list)
1587 {
1588 struct ath12k_dp *dp = dp_pdev->dp;
1589 struct ath12k_base *ab = dp->ab;
1590 u16 msdu_len = rx_info->msdu_len;
1591 struct hal_rx_desc *desc = (struct hal_rx_desc *)msdu->data;
1592 u8 l3pad_bytes = rx_info->l3_pad_bytes;
1593 struct ath12k_skb_rxcb *rxcb = ATH12K_SKB_RXCB(msdu);
1594 u32 hal_rx_desc_sz = dp->ab->hal.hal_desc_sz;
1595
1596 if (!rxcb->is_frag && ((msdu_len + hal_rx_desc_sz) > DP_RX_BUFFER_SIZE)) {
1597 /* First buffer will be freed by the caller, so deduct it's length */
1598 msdu_len = msdu_len - (DP_RX_BUFFER_SIZE - hal_rx_desc_sz);
1599 ath12k_wifi7_dp_rx_null_q_desc_sg_drop(dp, msdu_len, msdu_list);
1600 return -EINVAL;
1601 }
1602
1603 /* Even after cleaning up the sg buffers in the msdu list with above check
1604 * any msdu received with continuation flag needs to be dropped as invalid.
1605 * This protects against some random err frame with continuation flag.
1606 */
1607 if (rxcb->is_continuation)
1608 return -EINVAL;
1609
1610 if (!rx_info->msdu_done) {
1611 ath12k_warn(ab,
1612 "msdu_done bit not set in null_q_des processing\n");
1613 __skb_queue_purge(msdu_list);
1614 return -EIO;
1615 }
1616
1617 /* Handle NULL queue descriptor violations arising out a missing
1618 * REO queue for a given peer or a given TID. This typically
1619 * may happen if a packet is received on a QOS enabled TID before the
1620 * ADDBA negotiation for that TID, when the TID queue is setup. Or
1621 * it may also happen for MC/BC frames if they are not routed to the
1622 * non-QOS TID queue, in the absence of any other default TID queue.
1623 * This error can show up both in a REO destination or WBM release ring.
1624 */
1625
1626 if (rxcb->is_frag) {
1627 skb_pull(msdu, hal_rx_desc_sz);
1628 } else {
1629 if ((hal_rx_desc_sz + l3pad_bytes + msdu_len) > DP_RX_BUFFER_SIZE)
1630 return -EINVAL;
1631
1632 skb_put(msdu, hal_rx_desc_sz + l3pad_bytes + msdu_len);
1633 skb_pull(msdu, hal_rx_desc_sz + l3pad_bytes);
1634 }
1635 if (unlikely(!ath12k_dp_rx_check_nwifi_hdr_len_valid(dp, desc, msdu, rx_info)))
1636 return -EINVAL;
1637
1638 ath12k_dp_rx_h_ppdu(dp_pdev, rx_info);
1639 ath12k_wifi7_dp_rx_h_mpdu(dp_pdev, msdu, desc, rx_info);
1640
1641 rxcb->tid = rx_info->tid;
1642
1643 /* Please note that caller will having the access to msdu and completing
1644 * rx with mac80211. Need not worry about cleaning up amsdu_list.
1645 */
1646
1647 return 0;
1648 }
1649
ath12k_wifi7_dp_rx_h_tkip_mic_err(struct ath12k_pdev_dp * dp_pdev,struct sk_buff * msdu,struct hal_rx_desc_data * rx_info)1650 static bool ath12k_wifi7_dp_rx_h_tkip_mic_err(struct ath12k_pdev_dp *dp_pdev,
1651 struct sk_buff *msdu,
1652 struct hal_rx_desc_data *rx_info)
1653 {
1654 struct ath12k_dp *dp = dp_pdev->dp;
1655 struct ath12k_base *ab = dp->ab;
1656 u16 msdu_len = rx_info->msdu_len;
1657 struct hal_rx_desc *desc = (struct hal_rx_desc *)msdu->data;
1658 u8 l3pad_bytes = rx_info->l3_pad_bytes;
1659 struct ath12k_skb_rxcb *rxcb = ATH12K_SKB_RXCB(msdu);
1660 u32 hal_rx_desc_sz = ab->hal.hal_desc_sz;
1661
1662 rxcb->is_first_msdu = rx_info->is_first_msdu;
1663 rxcb->is_last_msdu = rx_info->is_last_msdu;
1664
1665 if ((hal_rx_desc_sz + l3pad_bytes + msdu_len) > DP_RX_BUFFER_SIZE) {
1666 ath12k_dbg(ab, ATH12K_DBG_DATA,
1667 "invalid msdu len in tkip mic err %u\n", msdu_len);
1668 ath12k_dbg_dump(ab, ATH12K_DBG_DATA, NULL, "", desc,
1669 sizeof(*desc));
1670 return true;
1671 }
1672
1673 skb_put(msdu, hal_rx_desc_sz + l3pad_bytes + msdu_len);
1674 skb_pull(msdu, hal_rx_desc_sz + l3pad_bytes);
1675
1676 if (unlikely(!ath12k_dp_rx_check_nwifi_hdr_len_valid(dp, desc, msdu, rx_info)))
1677 return true;
1678
1679 ath12k_dp_rx_h_ppdu(dp_pdev, rx_info);
1680
1681 rx_info->rx_status->flag |= (RX_FLAG_MMIC_STRIPPED | RX_FLAG_MMIC_ERROR |
1682 RX_FLAG_DECRYPTED);
1683
1684 ath12k_dp_rx_h_undecap(dp_pdev, msdu, desc,
1685 HAL_ENCRYPT_TYPE_TKIP_MIC, false, rx_info);
1686 return false;
1687 }
1688
ath12k_wifi7_dp_rx_h_rxdma_err(struct ath12k_pdev_dp * dp_pdev,struct sk_buff * msdu,struct hal_rx_desc_data * rx_info)1689 static bool ath12k_wifi7_dp_rx_h_rxdma_err(struct ath12k_pdev_dp *dp_pdev,
1690 struct sk_buff *msdu,
1691 struct hal_rx_desc_data *rx_info)
1692 {
1693 struct ath12k_dp *dp = dp_pdev->dp;
1694 struct ath12k_skb_rxcb *rxcb = ATH12K_SKB_RXCB(msdu);
1695 bool drop = false;
1696
1697 dp->device_stats.rxdma_error[rxcb->err_code]++;
1698
1699 switch (rxcb->err_code) {
1700 case HAL_REO_ENTR_RING_RXDMA_ECODE_DECRYPT_ERR:
1701 case HAL_REO_ENTR_RING_RXDMA_ECODE_TKIP_MIC_ERR:
1702 if (rx_info->err_bitmap & HAL_RX_MPDU_ERR_TKIP_MIC) {
1703 drop = ath12k_wifi7_dp_rx_h_tkip_mic_err(dp_pdev, msdu, rx_info);
1704 break;
1705 }
1706 fallthrough;
1707 default:
1708 /* TODO: Review other rxdma error code to check if anything is
1709 * worth reporting to mac80211
1710 */
1711 drop = true;
1712 break;
1713 }
1714
1715 return drop;
1716 }
1717
ath12k_wifi7_dp_rx_h_reo_err(struct ath12k_pdev_dp * dp_pdev,struct sk_buff * msdu,struct hal_rx_desc_data * rx_info,struct sk_buff_head * msdu_list)1718 static bool ath12k_wifi7_dp_rx_h_reo_err(struct ath12k_pdev_dp *dp_pdev,
1719 struct sk_buff *msdu,
1720 struct hal_rx_desc_data *rx_info,
1721 struct sk_buff_head *msdu_list)
1722 {
1723 struct ath12k_dp *dp = dp_pdev->dp;
1724 struct ath12k_skb_rxcb *rxcb = ATH12K_SKB_RXCB(msdu);
1725 bool drop = false;
1726
1727 dp->device_stats.reo_error[rxcb->err_code]++;
1728
1729 switch (rxcb->err_code) {
1730 case HAL_REO_DEST_RING_ERROR_CODE_DESC_ADDR_ZERO:
1731 if (ath12k_wifi7_dp_rx_h_null_q_desc(dp_pdev, msdu, rx_info, msdu_list))
1732 drop = true;
1733 break;
1734 case HAL_REO_DEST_RING_ERROR_CODE_PN_CHECK_FAILED:
1735 /* TODO: Do not drop PN failed packets in the driver;
1736 * instead, it is good to drop such packets in mac80211
1737 * after incrementing the replay counters.
1738 */
1739 fallthrough;
1740 default:
1741 /* TODO: Review other errors and process them to mac80211
1742 * as appropriate.
1743 */
1744 drop = true;
1745 break;
1746 }
1747
1748 return drop;
1749 }
1750
ath12k_wifi7_dp_rx_wbm_err(struct ath12k_pdev_dp * dp_pdev,struct napi_struct * napi,struct sk_buff * msdu,struct sk_buff_head * msdu_list)1751 static void ath12k_wifi7_dp_rx_wbm_err(struct ath12k_pdev_dp *dp_pdev,
1752 struct napi_struct *napi,
1753 struct sk_buff *msdu,
1754 struct sk_buff_head *msdu_list)
1755 {
1756 struct ath12k_dp *dp = dp_pdev->dp;
1757 struct hal_rx_desc *rx_desc = (struct hal_rx_desc *)msdu->data;
1758 struct ath12k_skb_rxcb *rxcb = ATH12K_SKB_RXCB(msdu);
1759 struct ieee80211_rx_status rxs = {};
1760 struct hal_rx_desc_data rx_info;
1761 bool drop = true;
1762
1763 rx_info.addr2_present = false;
1764 rx_info.rx_status = &rxs;
1765
1766 ath12k_dp_extract_rx_desc_data(dp->hal, &rx_info, rx_desc, rx_desc);
1767
1768 switch (rxcb->err_rel_src) {
1769 case HAL_WBM_REL_SRC_MODULE_REO:
1770 drop = ath12k_wifi7_dp_rx_h_reo_err(dp_pdev, msdu, &rx_info, msdu_list);
1771 break;
1772 case HAL_WBM_REL_SRC_MODULE_RXDMA:
1773 drop = ath12k_wifi7_dp_rx_h_rxdma_err(dp_pdev, msdu, &rx_info);
1774 break;
1775 default:
1776 /* msdu will get freed */
1777 break;
1778 }
1779
1780 if (drop) {
1781 dev_kfree_skb_any(msdu);
1782 return;
1783 }
1784
1785 rx_info.rx_status->flag |= RX_FLAG_SKIP_MONITOR;
1786
1787 ath12k_dp_rx_deliver_msdu(dp_pdev, napi, msdu, &rx_info);
1788 }
1789
ath12k_wifi7_dp_setup_pn_check_reo_cmd(struct ath12k_hal_reo_cmd * cmd,struct ath12k_dp_rx_tid * rx_tid,u32 cipher,enum set_key_cmd key_cmd)1790 void ath12k_wifi7_dp_setup_pn_check_reo_cmd(struct ath12k_hal_reo_cmd *cmd,
1791 struct ath12k_dp_rx_tid *rx_tid,
1792 u32 cipher, enum set_key_cmd key_cmd)
1793 {
1794 cmd->flag = HAL_REO_CMD_FLG_NEED_STATUS;
1795 cmd->upd0 = HAL_REO_CMD_UPD0_PN |
1796 HAL_REO_CMD_UPD0_PN_SIZE |
1797 HAL_REO_CMD_UPD0_PN_VALID |
1798 HAL_REO_CMD_UPD0_PN_CHECK |
1799 HAL_REO_CMD_UPD0_SVLD;
1800
1801 switch (cipher) {
1802 case WLAN_CIPHER_SUITE_TKIP:
1803 case WLAN_CIPHER_SUITE_CCMP:
1804 case WLAN_CIPHER_SUITE_CCMP_256:
1805 case WLAN_CIPHER_SUITE_GCMP:
1806 case WLAN_CIPHER_SUITE_GCMP_256:
1807 if (key_cmd == SET_KEY) {
1808 cmd->upd1 |= HAL_REO_CMD_UPD1_PN_CHECK;
1809 cmd->pn_size = 48;
1810 }
1811 break;
1812 default:
1813 break;
1814 }
1815
1816 cmd->addr_lo = lower_32_bits(rx_tid->qbuf.paddr_aligned);
1817 cmd->addr_hi = upper_32_bits(rx_tid->qbuf.paddr_aligned);
1818 }
1819
ath12k_wifi7_dp_rx_process_wbm_err(struct ath12k_dp * dp,struct napi_struct * napi,int budget)1820 int ath12k_wifi7_dp_rx_process_wbm_err(struct ath12k_dp *dp,
1821 struct napi_struct *napi, int budget)
1822 {
1823 struct list_head rx_desc_used_list[ATH12K_MAX_DEVICES];
1824 struct ath12k_base *ab = dp->ab;
1825 struct ath12k_hal *hal = dp->hal;
1826 struct ath12k *ar;
1827 struct ath12k_pdev_dp *dp_pdev;
1828 struct ath12k_hw_group *ag = dp->ag;
1829 struct ath12k_dp_hw_group *dp_hw_grp = &ag->dp_hw_grp;
1830 struct ath12k_dp *partner_dp;
1831 struct dp_rxdma_ring *rx_ring;
1832 struct hal_rx_wbm_rel_info err_info;
1833 struct hal_srng *srng;
1834 struct sk_buff *msdu;
1835 struct sk_buff_head msdu_list, scatter_msdu_list;
1836 struct ath12k_skb_rxcb *rxcb;
1837 void *rx_desc;
1838 int num_buffs_reaped[ATH12K_MAX_DEVICES] = {};
1839 int total_num_buffs_reaped = 0;
1840 struct ath12k_rx_desc_info *desc_info;
1841 struct ath12k_device_dp_stats *device_stats = &dp->device_stats;
1842 struct ath12k_hw_link *hw_links = ag->hw_links;
1843 u8 hw_link_id, device_id;
1844 int ret, pdev_idx;
1845 struct hal_rx_desc *msdu_data;
1846
1847 __skb_queue_head_init(&msdu_list);
1848 __skb_queue_head_init(&scatter_msdu_list);
1849
1850 for (device_id = 0; device_id < ATH12K_MAX_DEVICES; device_id++)
1851 INIT_LIST_HEAD(&rx_desc_used_list[device_id]);
1852
1853 srng = &hal->srng_list[dp->rx_rel_ring.ring_id];
1854 spin_lock_bh(&srng->lock);
1855
1856 ath12k_hal_srng_access_begin(ab, srng);
1857
1858 while (budget) {
1859 rx_desc = ath12k_hal_srng_dst_get_next_entry(ab, srng);
1860 if (!rx_desc)
1861 break;
1862
1863 ret = ath12k_wifi7_hal_wbm_desc_parse_err(dp, rx_desc,
1864 &err_info);
1865 if (ret) {
1866 ath12k_warn(ab, "failed to parse rx error in wbm_rel ring desc %d\n",
1867 ret);
1868 continue;
1869 }
1870
1871 desc_info = err_info.rx_desc;
1872
1873 /* retry manual desc retrieval if hw cc is not done */
1874 if (!desc_info) {
1875 desc_info = ath12k_dp_get_rx_desc(dp, err_info.cookie);
1876 if (!desc_info) {
1877 ath12k_warn(ab, "Invalid cookie in DP WBM rx error descriptor retrieval: 0x%x\n",
1878 err_info.cookie);
1879 continue;
1880 }
1881 }
1882
1883 if (desc_info->magic != ATH12K_DP_RX_DESC_MAGIC)
1884 ath12k_warn(ab, "WBM RX err, Check HW CC implementation");
1885
1886 msdu = desc_info->skb;
1887 desc_info->skb = NULL;
1888
1889 device_id = desc_info->device_id;
1890 partner_dp = ath12k_dp_hw_grp_to_dp(dp_hw_grp, device_id);
1891 if (unlikely(!partner_dp)) {
1892 dev_kfree_skb_any(msdu);
1893
1894 /* In any case continuation bit is set
1895 * in the previous record, cleanup scatter_msdu_list
1896 */
1897 ath12k_dp_clean_up_skb_list(&scatter_msdu_list);
1898 continue;
1899 }
1900
1901 list_add_tail(&desc_info->list, &rx_desc_used_list[device_id]);
1902
1903 rxcb = ATH12K_SKB_RXCB(msdu);
1904 dma_unmap_single(partner_dp->dev, rxcb->paddr,
1905 msdu->len + skb_tailroom(msdu),
1906 DMA_FROM_DEVICE);
1907
1908 num_buffs_reaped[device_id]++;
1909 total_num_buffs_reaped++;
1910
1911 if (!err_info.continuation)
1912 budget--;
1913
1914 if (err_info.push_reason !=
1915 HAL_REO_DEST_RING_PUSH_REASON_ERR_DETECTED) {
1916 dev_kfree_skb_any(msdu);
1917 continue;
1918 }
1919
1920 msdu_data = (struct hal_rx_desc *)msdu->data;
1921 rxcb->err_rel_src = err_info.err_rel_src;
1922 rxcb->err_code = err_info.err_code;
1923 rxcb->is_first_msdu = err_info.first_msdu;
1924 rxcb->is_last_msdu = err_info.last_msdu;
1925 rxcb->is_continuation = err_info.continuation;
1926 rxcb->rx_desc = msdu_data;
1927 rxcb->peer_id = ath12k_wifi7_dp_rx_get_peer_id(dp, dp->peer_metadata_ver,
1928 err_info.peer_metadata);
1929
1930 if (err_info.continuation) {
1931 __skb_queue_tail(&scatter_msdu_list, msdu);
1932 continue;
1933 }
1934
1935 hw_link_id = ath12k_dp_rx_get_msdu_src_link(partner_dp->hal,
1936 msdu_data);
1937 if (hw_link_id >= ATH12K_GROUP_MAX_RADIO) {
1938 dev_kfree_skb_any(msdu);
1939
1940 /* In any case continuation bit is set
1941 * in the previous record, cleanup scatter_msdu_list
1942 */
1943 ath12k_dp_clean_up_skb_list(&scatter_msdu_list);
1944 continue;
1945 }
1946
1947 if (!skb_queue_empty(&scatter_msdu_list)) {
1948 struct sk_buff *msdu;
1949
1950 skb_queue_walk(&scatter_msdu_list, msdu) {
1951 rxcb = ATH12K_SKB_RXCB(msdu);
1952 rxcb->hw_link_id = hw_link_id;
1953 }
1954
1955 skb_queue_splice_tail_init(&scatter_msdu_list,
1956 &msdu_list);
1957 }
1958
1959 rxcb = ATH12K_SKB_RXCB(msdu);
1960 rxcb->hw_link_id = hw_link_id;
1961 __skb_queue_tail(&msdu_list, msdu);
1962 }
1963
1964 /* In any case continuation bit is set in the
1965 * last record, cleanup scatter_msdu_list
1966 */
1967 ath12k_dp_clean_up_skb_list(&scatter_msdu_list);
1968
1969 ath12k_hal_srng_access_end(ab, srng);
1970
1971 spin_unlock_bh(&srng->lock);
1972
1973 if (!total_num_buffs_reaped)
1974 goto done;
1975
1976 for (device_id = 0; device_id < ATH12K_MAX_DEVICES; device_id++) {
1977 if (!num_buffs_reaped[device_id])
1978 continue;
1979
1980 partner_dp = ath12k_dp_hw_grp_to_dp(dp_hw_grp, device_id);
1981 rx_ring = &partner_dp->rx_refill_buf_ring;
1982
1983 ath12k_dp_rx_bufs_replenish(dp, rx_ring,
1984 &rx_desc_used_list[device_id],
1985 num_buffs_reaped[device_id]);
1986 }
1987
1988 rcu_read_lock();
1989 while ((msdu = __skb_dequeue(&msdu_list))) {
1990 rxcb = ATH12K_SKB_RXCB(msdu);
1991 hw_link_id = rxcb->hw_link_id;
1992
1993 device_id = hw_links[hw_link_id].device_id;
1994 partner_dp = ath12k_dp_hw_grp_to_dp(dp_hw_grp, device_id);
1995 if (unlikely(!partner_dp)) {
1996 ath12k_dbg(ab, ATH12K_DBG_DATA,
1997 "Unable to process WBM error msdu due to invalid hw link id %d device id %d\n",
1998 hw_link_id, device_id);
1999 dev_kfree_skb_any(msdu);
2000 continue;
2001 }
2002
2003 pdev_idx = ath12k_hw_mac_id_to_pdev_id(partner_dp->hw_params,
2004 hw_links[hw_link_id].pdev_idx);
2005
2006 dp_pdev = ath12k_dp_to_pdev_dp(partner_dp, pdev_idx);
2007 if (!dp_pdev) {
2008 dev_kfree_skb_any(msdu);
2009 continue;
2010 }
2011 ar = ath12k_pdev_dp_to_ar(dp_pdev);
2012
2013 if (!ar || !rcu_dereference(ar->ab->pdevs_active[pdev_idx])) {
2014 dev_kfree_skb_any(msdu);
2015 continue;
2016 }
2017
2018 if (test_bit(ATH12K_FLAG_CAC_RUNNING, &ar->dev_flags)) {
2019 dev_kfree_skb_any(msdu);
2020 continue;
2021 }
2022
2023 if (rxcb->err_rel_src < HAL_WBM_REL_SRC_MODULE_MAX) {
2024 device_id = dp_pdev->dp->device_id;
2025 device_stats->rx_wbm_rel_source[rxcb->err_rel_src][device_id]++;
2026 }
2027
2028 ath12k_wifi7_dp_rx_wbm_err(dp_pdev, napi, msdu, &msdu_list);
2029 }
2030 rcu_read_unlock();
2031 done:
2032 return total_num_buffs_reaped;
2033 }
2034
ath12k_dp_rxdma_ring_sel_config_qcn9274(struct ath12k_base * ab)2035 int ath12k_dp_rxdma_ring_sel_config_qcn9274(struct ath12k_base *ab)
2036 {
2037 struct ath12k_dp *dp = ath12k_ab_to_dp(ab);
2038 struct htt_rx_ring_tlv_filter tlv_filter = {};
2039 u32 ring_id;
2040 int ret;
2041 u32 hal_rx_desc_sz = ab->hal.hal_desc_sz;
2042
2043 ring_id = dp->rx_refill_buf_ring.refill_buf_ring.ring_id;
2044
2045 tlv_filter.rx_filter = HTT_RX_TLV_FLAGS_RXDMA_RING;
2046 tlv_filter.pkt_filter_flags2 = HTT_RX_FP_CTRL_PKT_FILTER_TLV_FLAGS2_BAR;
2047 tlv_filter.pkt_filter_flags3 = HTT_RX_FP_DATA_PKT_FILTER_TLV_FLASG3_MCAST |
2048 HTT_RX_FP_DATA_PKT_FILTER_TLV_FLASG3_UCAST |
2049 HTT_RX_FP_DATA_PKT_FILTER_TLV_FLASG3_NULL_DATA;
2050 tlv_filter.offset_valid = true;
2051 tlv_filter.rx_packet_offset = hal_rx_desc_sz;
2052
2053 tlv_filter.rx_mpdu_start_offset =
2054 ath12k_hal_rx_desc_get_mpdu_start_offset_qcn9274();
2055 tlv_filter.rx_msdu_end_offset =
2056 ath12k_hal_rx_desc_get_msdu_end_offset_qcn9274();
2057
2058 tlv_filter.rx_mpdu_start_wmask = ath12k_hal_rx_mpdu_start_wmask_get_qcn9274();
2059 tlv_filter.rx_msdu_end_wmask = ath12k_hal_rx_msdu_end_wmask_get_qcn9274();
2060 ath12k_dbg(ab, ATH12K_DBG_DATA,
2061 "Configuring compact tlv masks rx_mpdu_start_wmask 0x%x rx_msdu_end_wmask 0x%x\n",
2062 tlv_filter.rx_mpdu_start_wmask, tlv_filter.rx_msdu_end_wmask);
2063
2064 ret = ath12k_dp_tx_htt_rx_filter_setup(ab, ring_id, 0,
2065 HAL_RXDMA_BUF,
2066 DP_RXDMA_REFILL_RING_SIZE,
2067 &tlv_filter);
2068
2069 return ret;
2070 }
2071
ath12k_dp_rxdma_ring_sel_config_wcn7850(struct ath12k_base * ab)2072 int ath12k_dp_rxdma_ring_sel_config_wcn7850(struct ath12k_base *ab)
2073 {
2074 struct ath12k_dp *dp = ath12k_ab_to_dp(ab);
2075 struct htt_rx_ring_tlv_filter tlv_filter = {};
2076 u32 ring_id;
2077 int ret = 0;
2078 u32 hal_rx_desc_sz = ab->hal.hal_desc_sz;
2079 int i;
2080
2081 ring_id = dp->rx_refill_buf_ring.refill_buf_ring.ring_id;
2082
2083 tlv_filter.rx_filter = HTT_RX_TLV_FLAGS_RXDMA_RING;
2084 tlv_filter.pkt_filter_flags2 = HTT_RX_FP_CTRL_PKT_FILTER_TLV_FLAGS2_BAR;
2085 tlv_filter.pkt_filter_flags3 = HTT_RX_FP_DATA_PKT_FILTER_TLV_FLASG3_MCAST |
2086 HTT_RX_FP_DATA_PKT_FILTER_TLV_FLASG3_UCAST |
2087 HTT_RX_FP_DATA_PKT_FILTER_TLV_FLASG3_NULL_DATA;
2088 tlv_filter.offset_valid = true;
2089 tlv_filter.rx_packet_offset = hal_rx_desc_sz;
2090
2091 tlv_filter.rx_header_offset = offsetof(struct hal_rx_desc_wcn7850, pkt_hdr_tlv);
2092
2093 tlv_filter.rx_mpdu_start_offset =
2094 ath12k_hal_rx_desc_get_mpdu_start_offset_wcn7850();
2095 tlv_filter.rx_msdu_end_offset =
2096 ath12k_hal_rx_desc_get_msdu_end_offset_wcn7850();
2097
2098 /* TODO: Selectively subscribe to required qwords within msdu_end
2099 * and mpdu_start and setup the mask in below msg
2100 * and modify the rx_desc struct
2101 */
2102
2103 for (i = 0; i < ab->hw_params->num_rxdma_per_pdev; i++) {
2104 ring_id = dp->rx_mac_buf_ring[i].ring_id;
2105 ret = ath12k_dp_tx_htt_rx_filter_setup(ab, ring_id, i,
2106 HAL_RXDMA_BUF,
2107 DP_RXDMA_REFILL_RING_SIZE,
2108 &tlv_filter);
2109 }
2110
2111 return ret;
2112 }
2113
ath12k_dp_rxdma_ring_sel_config_qcc2072(struct ath12k_base * ab)2114 int ath12k_dp_rxdma_ring_sel_config_qcc2072(struct ath12k_base *ab)
2115 {
2116 struct ath12k_dp *dp = ath12k_ab_to_dp(ab);
2117 struct htt_rx_ring_tlv_filter tlv_filter = {};
2118 u32 ring_id;
2119 int ret = 0;
2120 u32 hal_rx_desc_sz = ab->hal.hal_desc_sz;
2121 int i;
2122
2123 ring_id = dp->rx_refill_buf_ring.refill_buf_ring.ring_id;
2124
2125 tlv_filter.rx_filter = HTT_RX_TLV_FLAGS_RXDMA_RING;
2126 tlv_filter.pkt_filter_flags2 = HTT_RX_FP_CTRL_PKT_FILTER_TLV_FLAGS2_BAR;
2127 tlv_filter.pkt_filter_flags3 = HTT_RX_FP_DATA_PKT_FILTER_TLV_FLASG3_MCAST |
2128 HTT_RX_FP_DATA_PKT_FILTER_TLV_FLASG3_UCAST |
2129 HTT_RX_FP_DATA_PKT_FILTER_TLV_FLASG3_NULL_DATA;
2130 tlv_filter.offset_valid = true;
2131 tlv_filter.rx_packet_offset = hal_rx_desc_sz;
2132
2133 tlv_filter.rx_header_offset = offsetof(struct hal_rx_desc_qcc2072, pkt_hdr_tlv);
2134
2135 tlv_filter.rx_mpdu_start_offset =
2136 ath12k_hal_rx_desc_get_mpdu_start_offset_qcc2072();
2137 tlv_filter.rx_msdu_end_offset =
2138 ath12k_hal_rx_desc_get_msdu_end_offset_qcc2072();
2139
2140 /*
2141 * TODO: Selectively subscribe to required qwords within msdu_end
2142 * and mpdu_start and setup the mask in below msg
2143 * and modify the rx_desc struct
2144 */
2145
2146 for (i = 0; i < ab->hw_params->num_rxdma_per_pdev; i++) {
2147 ring_id = dp->rx_mac_buf_ring[i].ring_id;
2148 ret = ath12k_dp_tx_htt_rx_filter_setup(ab, ring_id, i,
2149 HAL_RXDMA_BUF,
2150 DP_RXDMA_REFILL_RING_SIZE,
2151 &tlv_filter);
2152 }
2153
2154 return ret;
2155 }
2156
ath12k_wifi7_dp_rx_process_reo_status(struct ath12k_dp * dp)2157 void ath12k_wifi7_dp_rx_process_reo_status(struct ath12k_dp *dp)
2158 {
2159 struct ath12k_base *ab = dp->ab;
2160 struct ath12k_hal *hal = dp->hal;
2161 struct hal_srng *srng;
2162 struct ath12k_dp_rx_reo_cmd *cmd, *tmp;
2163 bool found = false;
2164 u16 tag;
2165 struct hal_reo_status reo_status;
2166 void *hdr, *desc;
2167
2168 srng = &hal->srng_list[dp->reo_status_ring.ring_id];
2169
2170 memset(&reo_status, 0, sizeof(reo_status));
2171
2172 spin_lock_bh(&srng->lock);
2173
2174 ath12k_hal_srng_access_begin(ab, srng);
2175
2176 while ((hdr = ath12k_hal_srng_dst_get_next_entry(ab, srng))) {
2177 tag = hal->ops->reo_status_dec_tlv_hdr(hdr, &desc);
2178
2179 switch (tag) {
2180 case HAL_REO_GET_QUEUE_STATS_STATUS:
2181 ath12k_wifi7_hal_reo_status_queue_stats(ab, desc,
2182 &reo_status);
2183 break;
2184 case HAL_REO_FLUSH_QUEUE_STATUS:
2185 ath12k_wifi7_hal_reo_flush_queue_status(ab, desc,
2186 &reo_status);
2187 break;
2188 case HAL_REO_FLUSH_CACHE_STATUS:
2189 ath12k_wifi7_hal_reo_flush_cache_status(ab, desc,
2190 &reo_status);
2191 break;
2192 case HAL_REO_UNBLOCK_CACHE_STATUS:
2193 ath12k_wifi7_hal_reo_unblk_cache_status(ab, desc,
2194 &reo_status);
2195 break;
2196 case HAL_REO_FLUSH_TIMEOUT_LIST_STATUS:
2197 ath12k_wifi7_hal_reo_flush_timeout_list_status(ab, desc,
2198 &reo_status);
2199 break;
2200 case HAL_REO_DESCRIPTOR_THRESHOLD_REACHED_STATUS:
2201 ath12k_wifi7_hal_reo_desc_thresh_reached_status(ab, desc,
2202 &reo_status);
2203 break;
2204 case HAL_REO_UPDATE_RX_REO_QUEUE_STATUS:
2205 ath12k_wifi7_hal_reo_update_rx_reo_queue_status(ab, desc,
2206 &reo_status);
2207 break;
2208 default:
2209 ath12k_warn(ab, "Unknown reo status type %d\n", tag);
2210 continue;
2211 }
2212
2213 spin_lock_bh(&dp->reo_cmd_lock);
2214 list_for_each_entry_safe(cmd, tmp, &dp->reo_cmd_list, list) {
2215 if (reo_status.uniform_hdr.cmd_num == cmd->cmd_num) {
2216 found = true;
2217 list_del(&cmd->list);
2218 break;
2219 }
2220 }
2221 spin_unlock_bh(&dp->reo_cmd_lock);
2222
2223 if (found) {
2224 cmd->handler(dp, (void *)&cmd->data,
2225 reo_status.uniform_hdr.cmd_status);
2226 kfree(cmd);
2227 }
2228
2229 found = false;
2230 }
2231
2232 ath12k_hal_srng_access_end(ab, srng);
2233
2234 spin_unlock_bh(&srng->lock);
2235 }
2236
2237 bool
ath12k_wifi7_dp_rxdesc_mpdu_valid(struct ath12k_base * ab,struct hal_rx_desc * rx_desc)2238 ath12k_wifi7_dp_rxdesc_mpdu_valid(struct ath12k_base *ab,
2239 struct hal_rx_desc *rx_desc)
2240 {
2241 u32 tlv_tag;
2242
2243 tlv_tag = ab->hal.ops->rx_desc_get_mpdu_start_tag(rx_desc);
2244
2245 return tlv_tag == HAL_RX_MPDU_START;
2246 }
2247