Debian Codegraph @

drivers/net/wireless/ath/ath12k/wifi7/hal.c

raw
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 #include "hw.h"
7 #include "hal_desc.h"
8 #include "../hal.h"
9 #include "hal.h"
10 #include "hal_tx.h"
11 #include "../debug.h"
12 #include "../hif.h"
13 #include "hal_qcn9274.h"
14 #include "hal_wcn7850.h"
15 #include "hal_qcc2072.h"
16
17 static const struct ath12k_hw_version_map ath12k_wifi7_hw_ver_map[] = {
18 [ATH12K_HW_QCN9274_HW10] = {
19 .hal_ops = &hal_qcn9274_ops,
20 .hal_desc_sz = sizeof(struct hal_rx_desc_qcn9274_compact),
21 .tcl_to_wbm_rbm_map = ath12k_hal_tcl_to_wbm_rbm_map_qcn9274,
22 .hal_params = &ath12k_hw_hal_params_qcn9274,
23 .hw_regs = &qcn9274_v1_regs,
24 },
25 [ATH12K_HW_QCN9274_HW20] = {
26 .hal_ops = &hal_qcn9274_ops,
27 .hal_desc_sz = sizeof(struct hal_rx_desc_qcn9274_compact),
28 .tcl_to_wbm_rbm_map = ath12k_hal_tcl_to_wbm_rbm_map_qcn9274,
29 .hal_params = &ath12k_hw_hal_params_qcn9274,
30 .hw_regs = &qcn9274_v2_regs,
31 },
32 [ATH12K_HW_WCN7850_HW20] = {
33 .hal_ops = &hal_wcn7850_ops,
34 .hal_desc_sz = sizeof(struct hal_rx_desc_wcn7850),
35 .tcl_to_wbm_rbm_map = ath12k_hal_tcl_to_wbm_rbm_map_wcn7850,
36 .hal_params = &ath12k_hw_hal_params_wcn7850,
37 .hw_regs = &wcn7850_regs,
38 },
39 [ATH12K_HW_IPQ5332_HW10] = {
40 .hal_ops = &hal_qcn9274_ops,
41 .hal_desc_sz = sizeof(struct hal_rx_desc_qcn9274_compact),
42 .tcl_to_wbm_rbm_map = ath12k_hal_tcl_to_wbm_rbm_map_qcn9274,
43 .hal_params = &ath12k_hw_hal_params_ipq5332,
44 .hw_regs = &ipq5332_regs,
45 },
46 [ATH12K_HW_QCC2072_HW10] = {
47 .hal_ops = &hal_qcc2072_ops,
48 .hal_desc_sz = sizeof(struct hal_rx_desc_qcc2072),
49 .tcl_to_wbm_rbm_map = ath12k_hal_tcl_to_wbm_rbm_map_wcn7850,
50 .hal_params = &ath12k_hw_hal_params_wcn7850,
51 .hw_regs = &qcc2072_regs,
52 },
53 };
54
55 int ath12k_wifi7_hal_init(struct ath12k_base *ab)
56 {
57 struct ath12k_hal *hal = &ab->hal;
58
59 memset(hal, 0, sizeof(*hal));
60
61 hal->ops = ath12k_wifi7_hw_ver_map[ab->hw_rev].hal_ops;
62 hal->hal_desc_sz = ath12k_wifi7_hw_ver_map[ab->hw_rev].hal_desc_sz;
63 hal->tcl_to_wbm_rbm_map = ath12k_wifi7_hw_ver_map[ab->hw_rev].tcl_to_wbm_rbm_map;
64 hal->regs = ath12k_wifi7_hw_ver_map[ab->hw_rev].hw_regs;
65 hal->hal_params = ath12k_wifi7_hw_ver_map[ab->hw_rev].hal_params;
66 hal->hal_wbm_release_ring_tx_size = sizeof(struct hal_wbm_release_ring_tx);
67
68 return 0;
69 }
70
71 static unsigned int ath12k_wifi7_hal_reo1_ring_id_offset(struct ath12k_hal *hal)
72 {
73 return HAL_REO1_RING_ID(hal) - HAL_REO1_RING_BASE_LSB(hal);
74 }
75
76 static unsigned
77 int ath12k_wifi7_hal_reo1_ring_msi1_base_lsb_offset(struct ath12k_hal *hal)
78 {
79 return HAL_REO1_RING_MSI1_BASE_LSB(hal) - HAL_REO1_RING_BASE_LSB(hal);
80 }
81
82 static unsigned
83 int ath12k_wifi7_hal_reo1_ring_msi1_base_msb_offset(struct ath12k_hal *hal)
84 {
85 return HAL_REO1_RING_MSI1_BASE_MSB(hal) - HAL_REO1_RING_BASE_LSB(hal);
86 }
87
88 static unsigned int ath12k_wifi7_hal_reo1_ring_msi1_data_offset(struct ath12k_hal *hal)
89 {
90 return HAL_REO1_RING_MSI1_DATA(hal) - HAL_REO1_RING_BASE_LSB(hal);
91 }
92
93 static unsigned int ath12k_wifi7_hal_reo1_ring_base_msb_offset(struct ath12k_hal *hal)
94 {
95 return HAL_REO1_RING_BASE_MSB(hal) - HAL_REO1_RING_BASE_LSB(hal);
96 }
97
98 static unsigned
99 int ath12k_wifi7_hal_reo1_ring_producer_int_setup_offset(struct ath12k_hal *hal)
100 {
101 return HAL_REO1_RING_PRODUCER_INT_SETUP(hal) - HAL_REO1_RING_BASE_LSB(hal);
102 }
103
104 static unsigned int ath12k_wifi7_hal_reo1_ring_hp_addr_lsb_offset(struct ath12k_hal *hal)
105 {
106 return HAL_REO1_RING_HP_ADDR_LSB(hal) - HAL_REO1_RING_BASE_LSB(hal);
107 }
108
109 static unsigned int ath12k_wifi7_hal_reo1_ring_hp_addr_msb_offset(struct ath12k_hal *hal)
110 {
111 return HAL_REO1_RING_HP_ADDR_MSB(hal) - HAL_REO1_RING_BASE_LSB(hal);
112 }
113
114 static unsigned int ath12k_wifi7_hal_reo1_ring_misc_offset(struct ath12k_hal *hal)
115 {
116 return HAL_REO1_RING_MISC(hal) - HAL_REO1_RING_BASE_LSB(hal);
117 }
118
119 void ath12k_wifi7_hal_ce_dst_setup(struct ath12k_base *ab,
120 struct hal_srng *srng, int ring_num)
121 {
122 struct hal_srng_config *srng_config = &ab->hal.srng_config[HAL_CE_DST];
123 u32 addr;
124 u32 val;
125
126 addr = HAL_CE_DST_RING_CTRL +
127 srng_config->reg_start[HAL_SRNG_REG_GRP_R0] +
128 ring_num * srng_config->reg_size[HAL_SRNG_REG_GRP_R0];
129
130 val = ath12k_hif_read32(ab, addr);
131 val &= ~HAL_CE_DST_R0_DEST_CTRL_MAX_LEN;
132 val |= u32_encode_bits(srng->u.dst_ring.max_buffer_length,
133 HAL_CE_DST_R0_DEST_CTRL_MAX_LEN);
134 ath12k_hif_write32(ab, addr, val);
135 }
136
137 void ath12k_wifi7_hal_srng_dst_hw_init(struct ath12k_base *ab,
138 struct hal_srng *srng)
139 {
140 struct ath12k_hal *hal = &ab->hal;
141 u32 val;
142 u64 hp_addr;
143 u32 reg_base;
144
145 reg_base = srng->hwreg_base[HAL_SRNG_REG_GRP_R0];
146
147 if (srng->flags & HAL_SRNG_FLAGS_MSI_INTR) {
148 ath12k_hif_write32(ab, reg_base +
149 ath12k_wifi7_hal_reo1_ring_msi1_base_lsb_offset(hal),
150 srng->msi_addr);
151
152 val = u32_encode_bits(((u64)srng->msi_addr >> HAL_ADDR_MSB_REG_SHIFT),
153 HAL_REO1_RING_MSI1_BASE_MSB_ADDR) |
154 HAL_REO1_RING_MSI1_BASE_MSB_MSI1_ENABLE;
155 ath12k_hif_write32(ab, reg_base +
156 ath12k_wifi7_hal_reo1_ring_msi1_base_msb_offset(hal),
157 val);
158
159 ath12k_hif_write32(ab,
160 reg_base +
161 ath12k_wifi7_hal_reo1_ring_msi1_data_offset(hal),
162 srng->msi_data);
163 }
164
165 ath12k_hif_write32(ab, reg_base, srng->ring_base_paddr);
166
167 val = u32_encode_bits(((u64)srng->ring_base_paddr >> HAL_ADDR_MSB_REG_SHIFT),
168 HAL_REO1_RING_BASE_MSB_RING_BASE_ADDR_MSB) |
169 u32_encode_bits((srng->entry_size * srng->num_entries),
170 HAL_REO1_RING_BASE_MSB_RING_SIZE);
171 ath12k_hif_write32(ab, reg_base + ath12k_wifi7_hal_reo1_ring_base_msb_offset(hal),
172 val);
173
174 val = u32_encode_bits(srng->ring_id, HAL_REO1_RING_ID_RING_ID) |
175 u32_encode_bits(srng->entry_size, HAL_REO1_RING_ID_ENTRY_SIZE);
176 ath12k_hif_write32(ab, reg_base + ath12k_wifi7_hal_reo1_ring_id_offset(hal), val);
177
178 /* interrupt setup */
179 val = u32_encode_bits((srng->intr_timer_thres_us >> 3),
180 HAL_REO1_RING_PRDR_INT_SETUP_INTR_TMR_THOLD);
181
182 val |= u32_encode_bits((srng->intr_batch_cntr_thres_entries * srng->entry_size),
183 HAL_REO1_RING_PRDR_INT_SETUP_BATCH_COUNTER_THOLD);
184
185 ath12k_hif_write32(ab,
186 reg_base +
187 ath12k_wifi7_hal_reo1_ring_producer_int_setup_offset(hal),
188 val);
189
190 hp_addr = hal->rdp.paddr +
191 ((unsigned long)srng->u.dst_ring.hp_addr -
192 (unsigned long)hal->rdp.vaddr);
193 ath12k_hif_write32(ab, reg_base +
194 ath12k_wifi7_hal_reo1_ring_hp_addr_lsb_offset(hal),
195 hp_addr & HAL_ADDR_LSB_REG_MASK);
196 ath12k_hif_write32(ab, reg_base +
197 ath12k_wifi7_hal_reo1_ring_hp_addr_msb_offset(hal),
198 hp_addr >> HAL_ADDR_MSB_REG_SHIFT);
199
200 /* Initialize head and tail pointers to indicate ring is empty */
201 reg_base = srng->hwreg_base[HAL_SRNG_REG_GRP_R2];
202 ath12k_hif_write32(ab, reg_base, 0);
203 ath12k_hif_write32(ab, reg_base + HAL_REO1_RING_TP_OFFSET, 0);
204 *srng->u.dst_ring.hp_addr = 0;
205
206 reg_base = srng->hwreg_base[HAL_SRNG_REG_GRP_R0];
207 val = 0;
208 if (srng->flags & HAL_SRNG_FLAGS_DATA_TLV_SWAP)
209 val |= HAL_REO1_RING_MISC_DATA_TLV_SWAP;
210 if (srng->flags & HAL_SRNG_FLAGS_RING_PTR_SWAP)
211 val |= HAL_REO1_RING_MISC_HOST_FW_SWAP;
212 if (srng->flags & HAL_SRNG_FLAGS_MSI_SWAP)
213 val |= HAL_REO1_RING_MISC_MSI_SWAP;
214 val |= HAL_REO1_RING_MISC_SRNG_ENABLE;
215
216 ath12k_hif_write32(ab, reg_base + ath12k_wifi7_hal_reo1_ring_misc_offset(hal),
217 val);
218 }
219
220 void ath12k_wifi7_hal_srng_src_hw_init(struct ath12k_base *ab,
221 struct hal_srng *srng)
222 {
223 struct ath12k_hal *hal = &ab->hal;
224 u32 val;
225 u64 tp_addr;
226 u32 reg_base;
227
228 reg_base = srng->hwreg_base[HAL_SRNG_REG_GRP_R0];
229
230 if (srng->flags & HAL_SRNG_FLAGS_MSI_INTR) {
231 ath12k_hif_write32(ab, reg_base +
232 HAL_TCL1_RING_MSI1_BASE_LSB_OFFSET(hal),
233 srng->msi_addr);
234
235 val = u32_encode_bits(((u64)srng->msi_addr >> HAL_ADDR_MSB_REG_SHIFT),
236 HAL_TCL1_RING_MSI1_BASE_MSB_ADDR) |
237 HAL_TCL1_RING_MSI1_BASE_MSB_MSI1_ENABLE;
238 ath12k_hif_write32(ab, reg_base +
239 HAL_TCL1_RING_MSI1_BASE_MSB_OFFSET(hal),
240 val);
241
242 ath12k_hif_write32(ab, reg_base +
243 HAL_TCL1_RING_MSI1_DATA_OFFSET(hal),
244 srng->msi_data);
245 }
246
247 ath12k_hif_write32(ab, reg_base, srng->ring_base_paddr);
248
249 val = u32_encode_bits(((u64)srng->ring_base_paddr >> HAL_ADDR_MSB_REG_SHIFT),
250 HAL_TCL1_RING_BASE_MSB_RING_BASE_ADDR_MSB) |
251 u32_encode_bits((srng->entry_size * srng->num_entries),
252 HAL_TCL1_RING_BASE_MSB_RING_SIZE);
253 ath12k_hif_write32(ab, reg_base + HAL_TCL1_RING_BASE_MSB_OFFSET(hal), val);
254
255 val = u32_encode_bits(srng->entry_size, HAL_REO1_RING_ID_ENTRY_SIZE);
256 ath12k_hif_write32(ab, reg_base + HAL_TCL1_RING_ID_OFFSET(hal), val);
257
258 val = u32_encode_bits(srng->intr_timer_thres_us,
259 HAL_TCL1_RING_CONSR_INT_SETUP_IX0_INTR_TMR_THOLD);
260
261 val |= u32_encode_bits((srng->intr_batch_cntr_thres_entries * srng->entry_size),
262 HAL_TCL1_RING_CONSR_INT_SETUP_IX0_BATCH_COUNTER_THOLD);
263
264 ath12k_hif_write32(ab,
265 reg_base + HAL_TCL1_RING_CONSR_INT_SETUP_IX0_OFFSET(hal),
266 val);
267
268 val = 0;
269 if (srng->flags & HAL_SRNG_FLAGS_LOW_THRESH_INTR_EN) {
270 val |= u32_encode_bits(srng->u.src_ring.low_threshold,
271 HAL_TCL1_RING_CONSR_INT_SETUP_IX1_LOW_THOLD);
272 }
273 ath12k_hif_write32(ab,
274 reg_base + HAL_TCL1_RING_CONSR_INT_SETUP_IX1_OFFSET(hal),
275 val);
276
277 if (srng->ring_id != HAL_SRNG_RING_ID_WBM_IDLE_LINK) {
278 tp_addr = hal->rdp.paddr +
279 ((unsigned long)srng->u.src_ring.tp_addr -
280 (unsigned long)hal->rdp.vaddr);
281 ath12k_hif_write32(ab,
282 reg_base + HAL_TCL1_RING_TP_ADDR_LSB_OFFSET(hal),
283 tp_addr & HAL_ADDR_LSB_REG_MASK);
284 ath12k_hif_write32(ab,
285 reg_base + HAL_TCL1_RING_TP_ADDR_MSB_OFFSET(hal),
286 tp_addr >> HAL_ADDR_MSB_REG_SHIFT);
287 }
288
289 /* Initialize head and tail pointers to indicate ring is empty */
290 reg_base = srng->hwreg_base[HAL_SRNG_REG_GRP_R2];
291 ath12k_hif_write32(ab, reg_base, 0);
292 ath12k_hif_write32(ab, reg_base + HAL_TCL1_RING_TP_OFFSET, 0);
293 *srng->u.src_ring.tp_addr = 0;
294
295 reg_base = srng->hwreg_base[HAL_SRNG_REG_GRP_R0];
296 val = 0;
297 if (srng->flags & HAL_SRNG_FLAGS_DATA_TLV_SWAP)
298 val |= HAL_TCL1_RING_MISC_DATA_TLV_SWAP;
299 if (srng->flags & HAL_SRNG_FLAGS_RING_PTR_SWAP)
300 val |= HAL_TCL1_RING_MISC_HOST_FW_SWAP;
301 if (srng->flags & HAL_SRNG_FLAGS_MSI_SWAP)
302 val |= HAL_TCL1_RING_MISC_MSI_SWAP;
303
304 /* Loop count is not used for SRC rings */
305 val |= HAL_TCL1_RING_MISC_MSI_LOOPCNT_DISABLE;
306
307 val |= HAL_TCL1_RING_MISC_SRNG_ENABLE;
308
309 if (srng->ring_id == HAL_SRNG_RING_ID_WBM_IDLE_LINK)
310 val |= HAL_TCL1_RING_MISC_MSI_RING_ID_DISABLE;
311
312 ath12k_hif_write32(ab, reg_base + HAL_TCL1_RING_MISC_OFFSET(hal), val);
313 }
314
315 void ath12k_wifi7_hal_set_umac_srng_ptr_addr(struct ath12k_base *ab,
316 struct hal_srng *srng)
317 {
318 u32 reg_base = srng->hwreg_base[HAL_SRNG_REG_GRP_R2];
319
320 if (srng->ring_dir == HAL_SRNG_DIR_SRC) {
321 if (!ab->hw_params->supports_shadow_regs) {
322 srng->u.src_ring.hp_addr =
323 (u32 *)((unsigned long)ab->mem + reg_base);
324 } else {
325 ath12k_dbg(ab, ATH12K_DBG_HAL,
326 "hal reg_base 0x%x shadow 0x%lx\n",
327 reg_base,
328 (unsigned long)srng->u.src_ring.hp_addr -
329 (unsigned long)ab->mem);
330 }
331 } else {
332 if (!ab->hw_params->supports_shadow_regs) {
333 srng->u.dst_ring.tp_addr =
334 (u32 *)((unsigned long)ab->mem + reg_base +
335 (HAL_REO1_RING_TP - HAL_REO1_RING_HP));
336 } else {
337 ath12k_dbg(ab, ATH12K_DBG_HAL,
338 "target_reg 0x%x shadow 0x%lx\n",
339 reg_base + HAL_REO1_RING_TP - HAL_REO1_RING_HP,
340 (unsigned long)srng->u.dst_ring.tp_addr -
341 (unsigned long)ab->mem);
342 }
343 }
344 }
345
346 int ath12k_wifi7_hal_srng_get_ring_id(struct ath12k_hal *hal,
347 enum hal_ring_type type,
348 int ring_num, int mac_id)
349 {
350 struct hal_srng_config *srng_config = &hal->srng_config[type];
351 int ring_id;
352
353 if (ring_num >= srng_config->max_rings) {
354 ath12k_warn(hal, "invalid ring number :%d\n", ring_num);
355 return -EINVAL;
356 }
357
358 ring_id = srng_config->start_ring_id + ring_num;
359 if (srng_config->mac_type == ATH12K_HAL_SRNG_PMAC)
360 ring_id += mac_id * HAL_SRNG_RINGS_PER_PMAC;
361
362 if (WARN_ON(ring_id >= HAL_SRNG_RING_ID_MAX))
363 return -EINVAL;
364
365 return ring_id;
366 }
367
368 static
369 void ath12k_wifi7_hal_srng_update_hp_tp_addr(struct ath12k_base *ab,
370 int shadow_cfg_idx,
371 enum hal_ring_type ring_type,
372 int ring_num)
373 {
374 struct hal_srng *srng;
375 struct ath12k_hal *hal = &ab->hal;
376 int ring_id;
377 struct hal_srng_config *srng_config = &hal->srng_config[ring_type];
378
379 ring_id = ath12k_wifi7_hal_srng_get_ring_id(hal, ring_type, ring_num,
380 0);
381 if (ring_id < 0)
382 return;
383
384 srng = &hal->srng_list[ring_id];
385
386 if (srng_config->ring_dir == HAL_SRNG_DIR_DST)
387 srng->u.dst_ring.tp_addr = (u32 *)(HAL_SHADOW_REG(shadow_cfg_idx) +
388 (unsigned long)ab->mem);
389 else
390 srng->u.src_ring.hp_addr = (u32 *)(HAL_SHADOW_REG(shadow_cfg_idx) +
391 (unsigned long)ab->mem);
392 }
393
394 u32 ath12k_wifi7_hal_ce_get_desc_size(enum hal_ce_desc type)
395 {
396 switch (type) {
397 case HAL_CE_DESC_SRC:
398 return sizeof(struct hal_ce_srng_src_desc);
399 case HAL_CE_DESC_DST:
400 return sizeof(struct hal_ce_srng_dest_desc);
401 case HAL_CE_DESC_DST_STATUS:
402 return sizeof(struct hal_ce_srng_dst_status_desc);
403 }
404
405 return 0;
406 }
407
408 int ath12k_wifi7_hal_srng_update_shadow_config(struct ath12k_base *ab,
409 enum hal_ring_type ring_type,
410 int ring_num)
411 {
412 struct ath12k_hal *hal = &ab->hal;
413 struct hal_srng_config *srng_config = &hal->srng_config[ring_type];
414 int shadow_cfg_idx = hal->num_shadow_reg_configured;
415 u32 target_reg;
416
417 if (shadow_cfg_idx >= HAL_SHADOW_NUM_REGS_MAX)
418 return -EINVAL;
419
420 hal->num_shadow_reg_configured++;
421
422 target_reg = srng_config->reg_start[HAL_HP_OFFSET_IN_REG_START];
423 target_reg += srng_config->reg_size[HAL_HP_OFFSET_IN_REG_START] *
424 ring_num;
425
426 /* For destination ring, shadow the TP */
427 if (srng_config->ring_dir == HAL_SRNG_DIR_DST)
428 target_reg += HAL_OFFSET_FROM_HP_TO_TP;
429
430 hal->shadow_reg_addr[shadow_cfg_idx] = target_reg;
431
432 /* update hp/tp addr to hal structure*/
433 ath12k_wifi7_hal_srng_update_hp_tp_addr(ab, shadow_cfg_idx, ring_type,
434 ring_num);
435
436 ath12k_dbg(ab, ATH12K_DBG_HAL,
437 "target_reg %x, shadow reg 0x%x shadow_idx 0x%x, ring_type %d, ring num %d",
438 target_reg,
439 HAL_SHADOW_REG(shadow_cfg_idx),
440 shadow_cfg_idx,
441 ring_type, ring_num);
442
443 return 0;
444 }
445
446 void ath12k_wifi7_hal_ce_src_set_desc(struct hal_ce_srng_src_desc *desc,
447 dma_addr_t paddr,
448 u32 len, u32 id, u8 byte_swap_data)
449 {
450 desc->buffer_addr_low = cpu_to_le32(paddr & HAL_ADDR_LSB_REG_MASK);
451 desc->buffer_addr_info =
452 le32_encode_bits(((u64)paddr >> HAL_ADDR_MSB_REG_SHIFT),
453 HAL_CE_SRC_DESC_ADDR_INFO_ADDR_HI) |
454 le32_encode_bits(byte_swap_data,
455 HAL_CE_SRC_DESC_ADDR_INFO_BYTE_SWAP) |
456 le32_encode_bits(0, HAL_CE_SRC_DESC_ADDR_INFO_GATHER) |
457 le32_encode_bits(len, HAL_CE_SRC_DESC_ADDR_INFO_LEN);
458 desc->meta_info = le32_encode_bits(id, HAL_CE_SRC_DESC_META_INFO_DATA);
459 }
460
461 void ath12k_wifi7_hal_ce_dst_set_desc(struct hal_ce_srng_dest_desc *desc,
462 dma_addr_t paddr)
463 {
464 desc->buffer_addr_low = cpu_to_le32(paddr & HAL_ADDR_LSB_REG_MASK);
465 desc->buffer_addr_info =
466 le32_encode_bits(((u64)paddr >> HAL_ADDR_MSB_REG_SHIFT),
467 HAL_CE_DEST_DESC_ADDR_INFO_ADDR_HI);
468 }
469
470 void ath12k_wifi7_hal_set_link_desc_addr(struct hal_wbm_link_desc *desc,
471 u32 cookie, dma_addr_t paddr,
472 enum hal_rx_buf_return_buf_manager rbm)
473 {
474 desc->buf_addr_info.info0 = le32_encode_bits((paddr & HAL_ADDR_LSB_REG_MASK),
475 BUFFER_ADDR_INFO0_ADDR);
476 desc->buf_addr_info.info1 =
477 le32_encode_bits(((u64)paddr >> HAL_ADDR_MSB_REG_SHIFT),
478 BUFFER_ADDR_INFO1_ADDR) |
479 le32_encode_bits(rbm, BUFFER_ADDR_INFO1_RET_BUF_MGR) |
480 le32_encode_bits(cookie, BUFFER_ADDR_INFO1_SW_COOKIE);
481 }
482
483 u32 ath12k_wifi7_hal_ce_dst_status_get_length(struct hal_ce_srng_dst_status_desc *desc)
484 {
485 u32 len;
486
487 len = le32_get_bits(READ_ONCE(desc->flags), HAL_CE_DST_STATUS_DESC_FLAGS_LEN);
488 desc->flags &= ~cpu_to_le32(HAL_CE_DST_STATUS_DESC_FLAGS_LEN);
489
490 return len;
491 }
492
493 void
494 ath12k_wifi7_hal_setup_link_idle_list(struct ath12k_base *ab,
495 struct hal_wbm_idle_scatter_list *sbuf,
496 u32 nsbufs, u32 tot_link_desc,
497 u32 end_offset)
498 {
499 struct ath12k_hal *hal = &ab->hal;
500 struct ath12k_buffer_addr *link_addr;
501 int i;
502 u32 reg_scatter_buf_sz = HAL_WBM_IDLE_SCATTER_BUF_SIZE / 64;
503 u32 val;
504
505 link_addr = (void *)sbuf[0].vaddr + HAL_WBM_IDLE_SCATTER_BUF_SIZE;
506
507 for (i = 1; i < nsbufs; i++) {
508 link_addr->info0 = cpu_to_le32(sbuf[i].paddr & HAL_ADDR_LSB_REG_MASK);
509
510 link_addr->info1 =
511 le32_encode_bits((u64)sbuf[i].paddr >> HAL_ADDR_MSB_REG_SHIFT,
512 HAL_WBM_SCATTERED_DESC_MSB_BASE_ADDR_39_32) |
513 le32_encode_bits(BASE_ADDR_MATCH_TAG_VAL,
514 HAL_WBM_SCATTERED_DESC_MSB_BASE_ADDR_MATCH_TAG);
515
516 link_addr = (void *)sbuf[i].vaddr +
517 HAL_WBM_IDLE_SCATTER_BUF_SIZE;
518 }
519
520 val = u32_encode_bits(reg_scatter_buf_sz, HAL_WBM_SCATTER_BUFFER_SIZE) |
521 u32_encode_bits(0x1, HAL_WBM_LINK_DESC_IDLE_LIST_MODE);
522
523 ath12k_hif_write32(ab,
524 HAL_SEQ_WCSS_UMAC_WBM_REG +
525 HAL_WBM_R0_IDLE_LIST_CONTROL_ADDR(hal),
526 val);
527
528 val = u32_encode_bits(reg_scatter_buf_sz * nsbufs,
529 HAL_WBM_SCATTER_RING_SIZE_OF_IDLE_LINK_DESC_LIST);
530 ath12k_hif_write32(ab,
531 HAL_SEQ_WCSS_UMAC_WBM_REG +
532 HAL_WBM_R0_IDLE_LIST_SIZE_ADDR(hal),
533 val);
534
535 val = u32_encode_bits(sbuf[0].paddr & HAL_ADDR_LSB_REG_MASK,
536 BUFFER_ADDR_INFO0_ADDR);
537 ath12k_hif_write32(ab,
538 HAL_SEQ_WCSS_UMAC_WBM_REG +
539 HAL_WBM_SCATTERED_RING_BASE_LSB(hal),
540 val);
541
542 val = u32_encode_bits(BASE_ADDR_MATCH_TAG_VAL,
543 HAL_WBM_SCATTERED_DESC_MSB_BASE_ADDR_MATCH_TAG) |
544 u32_encode_bits((u64)sbuf[0].paddr >> HAL_ADDR_MSB_REG_SHIFT,
545 HAL_WBM_SCATTERED_DESC_MSB_BASE_ADDR_39_32);
546 ath12k_hif_write32(ab,
547 HAL_SEQ_WCSS_UMAC_WBM_REG +
548 HAL_WBM_SCATTERED_RING_BASE_MSB(hal),
549 val);
550
551 /* Setup head and tail pointers for the idle list */
552 val = u32_encode_bits(sbuf[nsbufs - 1].paddr, BUFFER_ADDR_INFO0_ADDR);
553 ath12k_hif_write32(ab,
554 HAL_SEQ_WCSS_UMAC_WBM_REG +
555 HAL_WBM_SCATTERED_DESC_PTR_HEAD_INFO_IX0(hal),
556 val);
557
558 val = u32_encode_bits(((u64)sbuf[nsbufs - 1].paddr >> HAL_ADDR_MSB_REG_SHIFT),
559 HAL_WBM_SCATTERED_DESC_MSB_BASE_ADDR_39_32) |
560 u32_encode_bits((end_offset >> 2),
561 HAL_WBM_SCATTERED_DESC_HEAD_P_OFFSET_IX1);
562 ath12k_hif_write32(ab,
563 HAL_SEQ_WCSS_UMAC_WBM_REG +
564 HAL_WBM_SCATTERED_DESC_PTR_HEAD_INFO_IX1(hal),
565 val);
566
567 val = u32_encode_bits(sbuf[0].paddr, BUFFER_ADDR_INFO0_ADDR);
568 ath12k_hif_write32(ab,
569 HAL_SEQ_WCSS_UMAC_WBM_REG +
570 HAL_WBM_SCATTERED_DESC_PTR_HEAD_INFO_IX0(hal),
571 val);
572
573 val = u32_encode_bits(sbuf[0].paddr, BUFFER_ADDR_INFO0_ADDR);
574 ath12k_hif_write32(ab,
575 HAL_SEQ_WCSS_UMAC_WBM_REG +
576 HAL_WBM_SCATTERED_DESC_PTR_TAIL_INFO_IX0(hal),
577 val);
578
579 val = u32_encode_bits(((u64)sbuf[0].paddr >> HAL_ADDR_MSB_REG_SHIFT),
580 HAL_WBM_SCATTERED_DESC_MSB_BASE_ADDR_39_32) |
581 u32_encode_bits(0, HAL_WBM_SCATTERED_DESC_TAIL_P_OFFSET_IX1);
582 ath12k_hif_write32(ab,
583 HAL_SEQ_WCSS_UMAC_WBM_REG +
584 HAL_WBM_SCATTERED_DESC_PTR_TAIL_INFO_IX1(hal),
585 val);
586
587 val = 2 * tot_link_desc;
588 ath12k_hif_write32(ab, HAL_SEQ_WCSS_UMAC_WBM_REG +
589 HAL_WBM_SCATTERED_DESC_PTR_HP_ADDR(hal),
590 val);
591
592 /* Enable the SRNG */
593 val = u32_encode_bits(1, HAL_WBM_IDLE_LINK_RING_MISC_SRNG_ENABLE) |
594 u32_encode_bits(1, HAL_WBM_IDLE_LINK_RING_MISC_RIND_ID_DISABLE);
595 ath12k_hif_write32(ab,
596 HAL_SEQ_WCSS_UMAC_WBM_REG +
597 HAL_WBM_IDLE_LINK_RING_MISC_ADDR(hal),
598 val);
599 }
600
601 void ath12k_wifi7_hal_tx_configure_bank_register(struct ath12k_base *ab,
602 u32 bank_config,
603 u8 bank_id)
604 {
605 ath12k_hif_write32(ab, HAL_TCL_SW_CONFIG_BANK_ADDR + 4 * bank_id,
606 bank_config);
607 }
608
609 void ath12k_wifi7_hal_reoq_lut_addr_read_enable(struct ath12k_base *ab)
610 {
611 struct ath12k_hal *hal = &ab->hal;
612
613 u32 val = ath12k_hif_read32(ab, HAL_SEQ_WCSS_UMAC_REO_REG +
614 HAL_REO1_QDESC_ADDR(hal));
615
616 ath12k_hif_write32(ab, HAL_SEQ_WCSS_UMAC_REO_REG + HAL_REO1_QDESC_ADDR(hal),
617 val | HAL_REO_QDESC_ADDR_READ_LUT_ENABLE);
618 }
619
620 void ath12k_wifi7_hal_reoq_lut_set_max_peerid(struct ath12k_base *ab)
621 {
622 struct ath12k_hal *hal = &ab->hal;
623
624 ath12k_hif_write32(ab, HAL_SEQ_WCSS_UMAC_REO_REG + HAL_REO1_QDESC_MAX_PEERID(hal),
625 HAL_REO_QDESC_MAX_PEERID);
626 }
627
628 void ath12k_wifi7_hal_write_reoq_lut_addr(struct ath12k_base *ab,
629 dma_addr_t paddr)
630 {
631 ath12k_hif_write32(ab, HAL_SEQ_WCSS_UMAC_REO_REG +
632 HAL_REO1_QDESC_LUT_BASE0(&ab->hal), paddr);
633 }
634
635 void ath12k_wifi7_hal_write_ml_reoq_lut_addr(struct ath12k_base *ab,
636 dma_addr_t paddr)
637 {
638 ath12k_hif_write32(ab, HAL_SEQ_WCSS_UMAC_REO_REG +
639 HAL_REO1_QDESC_LUT_BASE1(&ab->hal), paddr);
640 }
641
642 void ath12k_wifi7_hal_cc_config(struct ath12k_base *ab)
643 {
644 u32 cmem_base = ab->qmi.dev_mem[ATH12K_QMI_DEVMEM_CMEM_INDEX].start;
645 u32 reo_base = HAL_SEQ_WCSS_UMAC_REO_REG;
646 u32 wbm_base = HAL_SEQ_WCSS_UMAC_WBM_REG;
647 u32 val = 0;
648 struct ath12k_hal *hal = &ab->hal;
649
650 if (ath12k_ftm_mode)
651 return;
652
653 ath12k_hif_write32(ab, reo_base + HAL_REO1_SW_COOKIE_CFG0(hal), cmem_base);
654
655 val |= u32_encode_bits(ATH12K_CMEM_ADDR_MSB,
656 HAL_REO1_SW_COOKIE_CFG_CMEM_BASE_ADDR_MSB) |
657 u32_encode_bits(ATH12K_CC_PPT_MSB,
658 HAL_REO1_SW_COOKIE_CFG_COOKIE_PPT_MSB) |
659 u32_encode_bits(ATH12K_CC_SPT_MSB,
660 HAL_REO1_SW_COOKIE_CFG_COOKIE_SPT_MSB) |
661 u32_encode_bits(1, HAL_REO1_SW_COOKIE_CFG_ALIGN) |
662 u32_encode_bits(1, HAL_REO1_SW_COOKIE_CFG_ENABLE) |
663 u32_encode_bits(1, HAL_REO1_SW_COOKIE_CFG_GLOBAL_ENABLE);
664
665 ath12k_hif_write32(ab, reo_base + HAL_REO1_SW_COOKIE_CFG1(hal), val);
666
667 /* Enable HW CC for WBM */
668 ath12k_hif_write32(ab, wbm_base + HAL_WBM_SW_COOKIE_CFG0, cmem_base);
669
670 val = u32_encode_bits(ATH12K_CMEM_ADDR_MSB,
671 HAL_WBM_SW_COOKIE_CFG_CMEM_BASE_ADDR_MSB) |
672 u32_encode_bits(ATH12K_CC_PPT_MSB,
673 HAL_WBM_SW_COOKIE_CFG_COOKIE_PPT_MSB) |
674 u32_encode_bits(ATH12K_CC_SPT_MSB,
675 HAL_WBM_SW_COOKIE_CFG_COOKIE_SPT_MSB) |
676 u32_encode_bits(1, HAL_WBM_SW_COOKIE_CFG_ALIGN);
677
678 ath12k_hif_write32(ab, wbm_base + HAL_WBM_SW_COOKIE_CFG1, val);
679
680 /* Enable conversion complete indication */
681 val = ath12k_hif_read32(ab, wbm_base + HAL_WBM_SW_COOKIE_CFG2);
682 val |= u32_encode_bits(1, HAL_WBM_SW_COOKIE_CFG_RELEASE_PATH_EN) |
683 u32_encode_bits(1, HAL_WBM_SW_COOKIE_CFG_ERR_PATH_EN) |
684 u32_encode_bits(1, HAL_WBM_SW_COOKIE_CFG_CONV_IND_EN);
685
686 ath12k_hif_write32(ab, wbm_base + HAL_WBM_SW_COOKIE_CFG2, val);
687
688 /* Enable Cookie conversion for WBM2SW Rings */
689 val = ath12k_hif_read32(ab, wbm_base + HAL_WBM_SW_COOKIE_CONVERT_CFG);
690 val |= u32_encode_bits(1, HAL_WBM_SW_COOKIE_CONV_CFG_GLOBAL_EN) |
691 hal->hal_params->wbm2sw_cc_enable;
692
693 ath12k_hif_write32(ab, wbm_base + HAL_WBM_SW_COOKIE_CONVERT_CFG, val);
694 }
695
696 enum hal_rx_buf_return_buf_manager
697 ath12k_wifi7_hal_get_idle_link_rbm(struct ath12k_hal *hal, u8 device_id)
698 {
699 switch (device_id) {
700 case 0:
701 return HAL_RX_BUF_RBM_WBM_DEV0_IDLE_DESC_LIST;
702 case 1:
703 return HAL_RX_BUF_RBM_WBM_DEV1_IDLE_DESC_LIST;
704 case 2:
705 return HAL_RX_BUF_RBM_WBM_DEV2_IDLE_DESC_LIST;
706 default:
707 ath12k_warn(hal,
708 "invalid %d device id, so choose default rbm\n",
709 device_id);
710 WARN_ON(1);
711 return HAL_RX_BUF_RBM_WBM_DEV0_IDLE_DESC_LIST;
712 }
713 }