xref: /freebsd/sys/contrib/dev/athk/ath11k/ce.c (revision 28348cae)
1 // SPDX-License-Identifier: BSD-3-Clause-Clear
2 /*
3  * Copyright (c) 2018-2019 The Linux Foundation. All rights reserved.
4  * Copyright (c) 2021, Qualcomm Innovation Center, Inc. All rights reserved.
5  */
6 
7 #include "dp_rx.h"
8 #include "debug.h"
9 #include "hif.h"
10 
11 const struct ce_attr ath11k_host_ce_config_ipq8074[] = {
12 	/* CE0: host->target HTC control and raw streams */
13 	{
14 		.flags = CE_ATTR_FLAGS,
15 		.src_nentries = 16,
16 		.src_sz_max = 2048,
17 		.dest_nentries = 0,
18 		.send_cb = ath11k_htc_tx_completion_handler,
19 	},
20 
21 	/* CE1: target->host HTT + HTC control */
22 	{
23 		.flags = CE_ATTR_FLAGS,
24 		.src_nentries = 0,
25 		.src_sz_max = 2048,
26 		.dest_nentries = 512,
27 		.recv_cb = ath11k_htc_rx_completion_handler,
28 	},
29 
30 	/* CE2: target->host WMI */
31 	{
32 		.flags = CE_ATTR_FLAGS,
33 		.src_nentries = 0,
34 		.src_sz_max = 2048,
35 		.dest_nentries = 512,
36 		.recv_cb = ath11k_htc_rx_completion_handler,
37 	},
38 
39 	/* CE3: host->target WMI (mac0) */
40 	{
41 		.flags = CE_ATTR_FLAGS,
42 		.src_nentries = 32,
43 		.src_sz_max = 2048,
44 		.dest_nentries = 0,
45 		.send_cb = ath11k_htc_tx_completion_handler,
46 	},
47 
48 	/* CE4: host->target HTT */
49 	{
50 		.flags = CE_ATTR_FLAGS | CE_ATTR_DIS_INTR,
51 		.src_nentries = 2048,
52 		.src_sz_max = 256,
53 		.dest_nentries = 0,
54 	},
55 
56 	/* CE5: target->host pktlog */
57 	{
58 		.flags = CE_ATTR_FLAGS,
59 		.src_nentries = 0,
60 		.src_sz_max = 2048,
61 		.dest_nentries = 512,
62 		.recv_cb = ath11k_dp_htt_htc_t2h_msg_handler,
63 	},
64 
65 	/* CE6: target autonomous hif_memcpy */
66 	{
67 		.flags = CE_ATTR_FLAGS | CE_ATTR_DIS_INTR,
68 		.src_nentries = 0,
69 		.src_sz_max = 0,
70 		.dest_nentries = 0,
71 	},
72 
73 	/* CE7: host->target WMI (mac1) */
74 	{
75 		.flags = CE_ATTR_FLAGS,
76 		.src_nentries = 32,
77 		.src_sz_max = 2048,
78 		.dest_nentries = 0,
79 		.send_cb = ath11k_htc_tx_completion_handler,
80 	},
81 
82 	/* CE8: target autonomous hif_memcpy */
83 	{
84 		.flags = CE_ATTR_FLAGS | CE_ATTR_DIS_INTR,
85 		.src_nentries = 0,
86 		.src_sz_max = 0,
87 		.dest_nentries = 0,
88 	},
89 
90 	/* CE9: host->target WMI (mac2) */
91 	{
92 		.flags = CE_ATTR_FLAGS,
93 		.src_nentries = 32,
94 		.src_sz_max = 2048,
95 		.dest_nentries = 0,
96 		.send_cb = ath11k_htc_tx_completion_handler,
97 	},
98 
99 	/* CE10: target->host HTT */
100 	{
101 		.flags = CE_ATTR_FLAGS,
102 		.src_nentries = 0,
103 		.src_sz_max = 2048,
104 		.dest_nentries = 512,
105 		.recv_cb = ath11k_htc_rx_completion_handler,
106 	},
107 
108 	/* CE11: Not used */
109 	{
110 		.flags = CE_ATTR_FLAGS,
111 		.src_nentries = 0,
112 		.src_sz_max = 0,
113 		.dest_nentries = 0,
114 	},
115 };
116 
117 const struct ce_attr ath11k_host_ce_config_qca6390[] = {
118 	/* CE0: host->target HTC control and raw streams */
119 	{
120 		.flags = CE_ATTR_FLAGS,
121 		.src_nentries = 16,
122 		.src_sz_max = 2048,
123 		.dest_nentries = 0,
124 	},
125 
126 	/* CE1: target->host HTT + HTC control */
127 	{
128 		.flags = CE_ATTR_FLAGS,
129 		.src_nentries = 0,
130 		.src_sz_max = 2048,
131 		.dest_nentries = 512,
132 		.recv_cb = ath11k_htc_rx_completion_handler,
133 	},
134 
135 	/* CE2: target->host WMI */
136 	{
137 		.flags = CE_ATTR_FLAGS,
138 		.src_nentries = 0,
139 		.src_sz_max = 2048,
140 		.dest_nentries = 512,
141 		.recv_cb = ath11k_htc_rx_completion_handler,
142 	},
143 
144 	/* CE3: host->target WMI (mac0) */
145 	{
146 		.flags = CE_ATTR_FLAGS,
147 		.src_nentries = 32,
148 		.src_sz_max = 2048,
149 		.dest_nentries = 0,
150 		.send_cb = ath11k_htc_tx_completion_handler,
151 	},
152 
153 	/* CE4: host->target HTT */
154 	{
155 		.flags = CE_ATTR_FLAGS | CE_ATTR_DIS_INTR,
156 		.src_nentries = 2048,
157 		.src_sz_max = 256,
158 		.dest_nentries = 0,
159 	},
160 
161 	/* CE5: target->host pktlog */
162 	{
163 		.flags = CE_ATTR_FLAGS,
164 		.src_nentries = 0,
165 		.src_sz_max = 2048,
166 		.dest_nentries = 512,
167 		.recv_cb = ath11k_dp_htt_htc_t2h_msg_handler,
168 	},
169 
170 	/* CE6: target autonomous hif_memcpy */
171 	{
172 		.flags = CE_ATTR_FLAGS | CE_ATTR_DIS_INTR,
173 		.src_nentries = 0,
174 		.src_sz_max = 0,
175 		.dest_nentries = 0,
176 	},
177 
178 	/* CE7: host->target WMI (mac1) */
179 	{
180 		.flags = CE_ATTR_FLAGS,
181 		.src_nentries = 32,
182 		.src_sz_max = 2048,
183 		.dest_nentries = 0,
184 		.send_cb = ath11k_htc_tx_completion_handler,
185 	},
186 
187 	/* CE8: target autonomous hif_memcpy */
188 	{
189 		.flags = CE_ATTR_FLAGS,
190 		.src_nentries = 0,
191 		.src_sz_max = 0,
192 		.dest_nentries = 0,
193 	},
194 
195 };
196 
197 const struct ce_attr ath11k_host_ce_config_qcn9074[] = {
198 	/* CE0: host->target HTC control and raw streams */
199 	{
200 		.flags = CE_ATTR_FLAGS,
201 		.src_nentries = 16,
202 		.src_sz_max = 2048,
203 		.dest_nentries = 0,
204 	},
205 
206 	/* CE1: target->host HTT + HTC control */
207 	{
208 		.flags = CE_ATTR_FLAGS,
209 		.src_nentries = 0,
210 		.src_sz_max = 2048,
211 		.dest_nentries = 512,
212 		.recv_cb = ath11k_htc_rx_completion_handler,
213 	},
214 
215 	/* CE2: target->host WMI */
216 	{
217 		.flags = CE_ATTR_FLAGS,
218 		.src_nentries = 0,
219 		.src_sz_max = 2048,
220 		.dest_nentries = 32,
221 		.recv_cb = ath11k_htc_rx_completion_handler,
222 	},
223 
224 	/* CE3: host->target WMI (mac0) */
225 	{
226 		.flags = CE_ATTR_FLAGS,
227 		.src_nentries = 32,
228 		.src_sz_max = 2048,
229 		.dest_nentries = 0,
230 		.send_cb = ath11k_htc_tx_completion_handler,
231 	},
232 
233 	/* CE4: host->target HTT */
234 	{
235 		.flags = CE_ATTR_FLAGS | CE_ATTR_DIS_INTR,
236 		.src_nentries = 2048,
237 		.src_sz_max = 256,
238 		.dest_nentries = 0,
239 	},
240 
241 	/* CE5: target->host pktlog */
242 	{
243 		.flags = CE_ATTR_FLAGS,
244 		.src_nentries = 0,
245 		.src_sz_max = 2048,
246 		.dest_nentries = 512,
247 		.recv_cb = ath11k_dp_htt_htc_t2h_msg_handler,
248 	},
249 };
250 
ath11k_ce_need_shadow_fix(int ce_id)251 static bool ath11k_ce_need_shadow_fix(int ce_id)
252 {
253 	/* only ce4 needs shadow workaround */
254 	if (ce_id == 4)
255 		return true;
256 	return false;
257 }
258 
ath11k_ce_stop_shadow_timers(struct ath11k_base * ab)259 void ath11k_ce_stop_shadow_timers(struct ath11k_base *ab)
260 {
261 	int i;
262 
263 	if (!ab->hw_params.supports_shadow_regs)
264 		return;
265 
266 	for (i = 0; i < ab->hw_params.ce_count; i++)
267 		if (ath11k_ce_need_shadow_fix(i))
268 			ath11k_dp_shadow_stop_timer(ab, &ab->ce.hp_timer[i]);
269 }
270 
ath11k_ce_rx_buf_enqueue_pipe(struct ath11k_ce_pipe * pipe,struct sk_buff * skb,dma_addr_t paddr)271 static int ath11k_ce_rx_buf_enqueue_pipe(struct ath11k_ce_pipe *pipe,
272 					 struct sk_buff *skb, dma_addr_t paddr)
273 {
274 	struct ath11k_base *ab = pipe->ab;
275 	struct ath11k_ce_ring *ring = pipe->dest_ring;
276 	struct hal_srng *srng;
277 	unsigned int write_index;
278 	unsigned int nentries_mask = ring->nentries_mask;
279 	u32 *desc;
280 	int ret;
281 
282 	lockdep_assert_held(&ab->ce.ce_lock);
283 
284 	write_index = ring->write_index;
285 
286 	srng = &ab->hal.srng_list[ring->hal_ring_id];
287 
288 	spin_lock_bh(&srng->lock);
289 
290 	ath11k_hal_srng_access_begin(ab, srng);
291 
292 	if (unlikely(ath11k_hal_srng_src_num_free(ab, srng, false) < 1)) {
293 		ret = -ENOSPC;
294 		goto exit;
295 	}
296 
297 	desc = ath11k_hal_srng_src_get_next_entry(ab, srng);
298 	if (!desc) {
299 		ret = -ENOSPC;
300 		goto exit;
301 	}
302 
303 	ath11k_hal_ce_dst_set_desc(desc, paddr);
304 
305 	ring->skb[write_index] = skb;
306 	write_index = CE_RING_IDX_INCR(nentries_mask, write_index);
307 	ring->write_index = write_index;
308 
309 	pipe->rx_buf_needed--;
310 
311 	ret = 0;
312 exit:
313 	ath11k_hal_srng_access_end(ab, srng);
314 
315 	spin_unlock_bh(&srng->lock);
316 
317 	return ret;
318 }
319 
ath11k_ce_rx_post_pipe(struct ath11k_ce_pipe * pipe)320 static int ath11k_ce_rx_post_pipe(struct ath11k_ce_pipe *pipe)
321 {
322 	struct ath11k_base *ab = pipe->ab;
323 	struct sk_buff *skb;
324 	dma_addr_t paddr;
325 	int ret = 0;
326 
327 	if (!(pipe->dest_ring || pipe->status_ring))
328 		return 0;
329 
330 	spin_lock_bh(&ab->ce.ce_lock);
331 	while (pipe->rx_buf_needed) {
332 		skb = dev_alloc_skb(pipe->buf_sz);
333 		if (!skb) {
334 			ret = -ENOMEM;
335 			goto exit;
336 		}
337 
338 		WARN_ON_ONCE(!IS_ALIGNED((unsigned long)skb->data, 4));
339 
340 		paddr = dma_map_single(ab->dev, skb->data,
341 				       skb->len + skb_tailroom(skb),
342 				       DMA_FROM_DEVICE);
343 		if (unlikely(dma_mapping_error(ab->dev, paddr))) {
344 			ath11k_warn(ab, "failed to dma map ce rx buf\n");
345 			dev_kfree_skb_any(skb);
346 			ret = -EIO;
347 			goto exit;
348 		}
349 
350 		ATH11K_SKB_RXCB(skb)->paddr = paddr;
351 
352 		ret = ath11k_ce_rx_buf_enqueue_pipe(pipe, skb, paddr);
353 
354 		if (ret) {
355 			ath11k_warn(ab, "failed to enqueue rx buf: %d\n", ret);
356 			dma_unmap_single(ab->dev, paddr,
357 					 skb->len + skb_tailroom(skb),
358 					 DMA_FROM_DEVICE);
359 			dev_kfree_skb_any(skb);
360 			goto exit;
361 		}
362 	}
363 
364 exit:
365 	spin_unlock_bh(&ab->ce.ce_lock);
366 	return ret;
367 }
368 
ath11k_ce_completed_recv_next(struct ath11k_ce_pipe * pipe,struct sk_buff ** skb,int * nbytes)369 static int ath11k_ce_completed_recv_next(struct ath11k_ce_pipe *pipe,
370 					 struct sk_buff **skb, int *nbytes)
371 {
372 	struct ath11k_base *ab = pipe->ab;
373 	struct hal_srng *srng;
374 	unsigned int sw_index;
375 	unsigned int nentries_mask;
376 	u32 *desc;
377 	int ret = 0;
378 
379 	spin_lock_bh(&ab->ce.ce_lock);
380 
381 	sw_index = pipe->dest_ring->sw_index;
382 	nentries_mask = pipe->dest_ring->nentries_mask;
383 
384 	srng = &ab->hal.srng_list[pipe->status_ring->hal_ring_id];
385 
386 	spin_lock_bh(&srng->lock);
387 
388 	ath11k_hal_srng_access_begin(ab, srng);
389 
390 	desc = ath11k_hal_srng_dst_get_next_entry(ab, srng);
391 	if (!desc) {
392 		ret = -EIO;
393 		goto err;
394 	}
395 
396 	*nbytes = ath11k_hal_ce_dst_status_get_length(desc);
397 	if (*nbytes == 0) {
398 		ret = -EIO;
399 		goto err;
400 	}
401 
402 	*skb = pipe->dest_ring->skb[sw_index];
403 	pipe->dest_ring->skb[sw_index] = NULL;
404 
405 	sw_index = CE_RING_IDX_INCR(nentries_mask, sw_index);
406 	pipe->dest_ring->sw_index = sw_index;
407 
408 	pipe->rx_buf_needed++;
409 err:
410 	ath11k_hal_srng_access_end(ab, srng);
411 
412 	spin_unlock_bh(&srng->lock);
413 
414 	spin_unlock_bh(&ab->ce.ce_lock);
415 
416 	return ret;
417 }
418 
ath11k_ce_recv_process_cb(struct ath11k_ce_pipe * pipe)419 static void ath11k_ce_recv_process_cb(struct ath11k_ce_pipe *pipe)
420 {
421 	struct ath11k_base *ab = pipe->ab;
422 	struct sk_buff *skb;
423 	struct sk_buff_head list;
424 	unsigned int nbytes, max_nbytes;
425 	int ret;
426 
427 	__skb_queue_head_init(&list);
428 	while (ath11k_ce_completed_recv_next(pipe, &skb, &nbytes) == 0) {
429 		max_nbytes = skb->len + skb_tailroom(skb);
430 		dma_unmap_single(ab->dev, ATH11K_SKB_RXCB(skb)->paddr,
431 				 max_nbytes, DMA_FROM_DEVICE);
432 
433 		if (unlikely(max_nbytes < nbytes)) {
434 			ath11k_warn(ab, "rxed more than expected (nbytes %d, max %d)",
435 				    nbytes, max_nbytes);
436 			dev_kfree_skb_any(skb);
437 			continue;
438 		}
439 
440 		skb_put(skb, nbytes);
441 		__skb_queue_tail(&list, skb);
442 	}
443 
444 	while ((skb = __skb_dequeue(&list))) {
445 		ath11k_dbg(ab, ATH11K_DBG_CE, "rx ce pipe %d len %d\n",
446 			   pipe->pipe_num, skb->len);
447 		pipe->recv_cb(ab, skb);
448 	}
449 
450 	ret = ath11k_ce_rx_post_pipe(pipe);
451 	if (ret && ret != -ENOSPC) {
452 		ath11k_warn(ab, "failed to post rx buf to pipe: %d err: %d\n",
453 			    pipe->pipe_num, ret);
454 		mod_timer(&ab->rx_replenish_retry,
455 			  jiffies + ATH11K_CE_RX_POST_RETRY_JIFFIES);
456 	}
457 }
458 
ath11k_ce_completed_send_next(struct ath11k_ce_pipe * pipe)459 static struct sk_buff *ath11k_ce_completed_send_next(struct ath11k_ce_pipe *pipe)
460 {
461 	struct ath11k_base *ab = pipe->ab;
462 	struct hal_srng *srng;
463 	unsigned int sw_index;
464 	unsigned int nentries_mask;
465 	struct sk_buff *skb;
466 	u32 *desc;
467 
468 	spin_lock_bh(&ab->ce.ce_lock);
469 
470 	sw_index = pipe->src_ring->sw_index;
471 	nentries_mask = pipe->src_ring->nentries_mask;
472 
473 	srng = &ab->hal.srng_list[pipe->src_ring->hal_ring_id];
474 
475 	spin_lock_bh(&srng->lock);
476 
477 	ath11k_hal_srng_access_begin(ab, srng);
478 
479 	desc = ath11k_hal_srng_src_reap_next(ab, srng);
480 	if (!desc) {
481 		skb = ERR_PTR(-EIO);
482 		goto err_unlock;
483 	}
484 
485 	skb = pipe->src_ring->skb[sw_index];
486 
487 	pipe->src_ring->skb[sw_index] = NULL;
488 
489 	sw_index = CE_RING_IDX_INCR(nentries_mask, sw_index);
490 	pipe->src_ring->sw_index = sw_index;
491 
492 err_unlock:
493 	spin_unlock_bh(&srng->lock);
494 
495 	spin_unlock_bh(&ab->ce.ce_lock);
496 
497 	return skb;
498 }
499 
ath11k_ce_tx_process_cb(struct ath11k_ce_pipe * pipe)500 static void ath11k_ce_tx_process_cb(struct ath11k_ce_pipe *pipe)
501 {
502 	struct ath11k_base *ab = pipe->ab;
503 	struct sk_buff *skb;
504 	struct sk_buff_head list;
505 
506 	__skb_queue_head_init(&list);
507 	while (!IS_ERR(skb = ath11k_ce_completed_send_next(pipe))) {
508 		if (!skb)
509 			continue;
510 
511 		dma_unmap_single(ab->dev, ATH11K_SKB_CB(skb)->paddr, skb->len,
512 				 DMA_TO_DEVICE);
513 
514 		if ((!pipe->send_cb) || ab->hw_params.credit_flow) {
515 			dev_kfree_skb_any(skb);
516 			continue;
517 		}
518 
519 		__skb_queue_tail(&list, skb);
520 	}
521 
522 	while ((skb = __skb_dequeue(&list))) {
523 		ath11k_dbg(ab, ATH11K_DBG_CE, "tx ce pipe %d len %d\n",
524 			   pipe->pipe_num, skb->len);
525 		pipe->send_cb(ab, skb);
526 	}
527 }
528 
ath11k_ce_srng_msi_ring_params_setup(struct ath11k_base * ab,u32 ce_id,struct hal_srng_params * ring_params)529 static void ath11k_ce_srng_msi_ring_params_setup(struct ath11k_base *ab, u32 ce_id,
530 						 struct hal_srng_params *ring_params)
531 {
532 	u32 msi_data_start;
533 	u32 msi_data_count, msi_data_idx;
534 	u32 msi_irq_start;
535 	u32 addr_lo;
536 	u32 addr_hi;
537 	int ret;
538 
539 	ret = ath11k_get_user_msi_vector(ab, "CE",
540 					 &msi_data_count, &msi_data_start,
541 					 &msi_irq_start);
542 
543 	if (ret)
544 		return;
545 
546 	ath11k_get_msi_address(ab, &addr_lo, &addr_hi);
547 	ath11k_get_ce_msi_idx(ab, ce_id, &msi_data_idx);
548 
549 	ring_params->msi_addr = addr_lo;
550 	ring_params->msi_addr |= (dma_addr_t)(((uint64_t)addr_hi) << 32);
551 	ring_params->msi_data = (msi_data_idx % msi_data_count) + msi_data_start;
552 	ring_params->flags |= HAL_SRNG_FLAGS_MSI_INTR;
553 }
554 
ath11k_ce_init_ring(struct ath11k_base * ab,struct ath11k_ce_ring * ce_ring,int ce_id,enum hal_ring_type type)555 static int ath11k_ce_init_ring(struct ath11k_base *ab,
556 			       struct ath11k_ce_ring *ce_ring,
557 			       int ce_id, enum hal_ring_type type)
558 {
559 	struct hal_srng_params params = { 0 };
560 	int ret;
561 
562 	params.ring_base_paddr = ce_ring->base_addr_ce_space;
563 	params.ring_base_vaddr = ce_ring->base_addr_owner_space;
564 	params.num_entries = ce_ring->nentries;
565 
566 	if (!(CE_ATTR_DIS_INTR & ab->hw_params.host_ce_config[ce_id].flags))
567 		ath11k_ce_srng_msi_ring_params_setup(ab, ce_id, &params);
568 
569 	switch (type) {
570 	case HAL_CE_SRC:
571 		if (!(CE_ATTR_DIS_INTR & ab->hw_params.host_ce_config[ce_id].flags))
572 			params.intr_batch_cntr_thres_entries = 1;
573 		break;
574 	case HAL_CE_DST:
575 		params.max_buffer_len = ab->hw_params.host_ce_config[ce_id].src_sz_max;
576 		if (!(ab->hw_params.host_ce_config[ce_id].flags & CE_ATTR_DIS_INTR)) {
577 			params.intr_timer_thres_us = 1024;
578 			params.flags |= HAL_SRNG_FLAGS_LOW_THRESH_INTR_EN;
579 			params.low_threshold = ce_ring->nentries - 3;
580 		}
581 		break;
582 	case HAL_CE_DST_STATUS:
583 		if (!(ab->hw_params.host_ce_config[ce_id].flags & CE_ATTR_DIS_INTR)) {
584 			params.intr_batch_cntr_thres_entries = 1;
585 			params.intr_timer_thres_us = 0x1000;
586 		}
587 		break;
588 	default:
589 		ath11k_warn(ab, "Invalid CE ring type %d\n", type);
590 		return -EINVAL;
591 	}
592 
593 	/* TODO: Init other params needed by HAL to init the ring */
594 
595 	ret = ath11k_hal_srng_setup(ab, type, ce_id, 0, &params);
596 	if (ret < 0) {
597 		ath11k_warn(ab, "failed to setup srng: %d ring_id %d\n",
598 			    ret, ce_id);
599 		return ret;
600 	}
601 
602 	ce_ring->hal_ring_id = ret;
603 
604 	if (ab->hw_params.supports_shadow_regs &&
605 	    ath11k_ce_need_shadow_fix(ce_id))
606 		ath11k_dp_shadow_init_timer(ab, &ab->ce.hp_timer[ce_id],
607 					    ATH11K_SHADOW_CTRL_TIMER_INTERVAL,
608 					    ce_ring->hal_ring_id);
609 
610 	return 0;
611 }
612 
613 static struct ath11k_ce_ring *
ath11k_ce_alloc_ring(struct ath11k_base * ab,int nentries,int desc_sz)614 ath11k_ce_alloc_ring(struct ath11k_base *ab, int nentries, int desc_sz)
615 {
616 	struct ath11k_ce_ring *ce_ring;
617 	dma_addr_t base_addr;
618 
619 	ce_ring = kzalloc(struct_size(ce_ring, skb, nentries), GFP_KERNEL);
620 	if (ce_ring == NULL)
621 		return ERR_PTR(-ENOMEM);
622 
623 	ce_ring->nentries = nentries;
624 	ce_ring->nentries_mask = nentries - 1;
625 
626 	/* Legacy platforms that do not support cache
627 	 * coherent DMA are unsupported
628 	 */
629 	ce_ring->base_addr_owner_space_unaligned =
630 		dma_alloc_coherent(ab->dev,
631 				   nentries * desc_sz + CE_DESC_RING_ALIGN,
632 				   &base_addr, GFP_KERNEL);
633 	if (!ce_ring->base_addr_owner_space_unaligned) {
634 		kfree(ce_ring);
635 		return ERR_PTR(-ENOMEM);
636 	}
637 
638 	ce_ring->base_addr_ce_space_unaligned = base_addr;
639 
640 	ce_ring->base_addr_owner_space = PTR_ALIGN(
641 			ce_ring->base_addr_owner_space_unaligned,
642 			CE_DESC_RING_ALIGN);
643 	ce_ring->base_addr_ce_space = ALIGN(
644 			ce_ring->base_addr_ce_space_unaligned,
645 			CE_DESC_RING_ALIGN);
646 
647 	return ce_ring;
648 }
649 
ath11k_ce_alloc_pipe(struct ath11k_base * ab,int ce_id)650 static int ath11k_ce_alloc_pipe(struct ath11k_base *ab, int ce_id)
651 {
652 	struct ath11k_ce_pipe *pipe = &ab->ce.ce_pipe[ce_id];
653 	const struct ce_attr *attr = &ab->hw_params.host_ce_config[ce_id];
654 	struct ath11k_ce_ring *ring;
655 	int nentries;
656 	int desc_sz;
657 
658 	pipe->attr_flags = attr->flags;
659 
660 	if (attr->src_nentries) {
661 		pipe->send_cb = attr->send_cb;
662 		nentries = roundup_pow_of_two(attr->src_nentries);
663 		desc_sz = ath11k_hal_ce_get_desc_size(HAL_CE_DESC_SRC);
664 		ring = ath11k_ce_alloc_ring(ab, nentries, desc_sz);
665 		if (IS_ERR(ring))
666 			return PTR_ERR(ring);
667 		pipe->src_ring = ring;
668 	}
669 
670 	if (attr->dest_nentries) {
671 		pipe->recv_cb = attr->recv_cb;
672 		nentries = roundup_pow_of_two(attr->dest_nentries);
673 		desc_sz = ath11k_hal_ce_get_desc_size(HAL_CE_DESC_DST);
674 		ring = ath11k_ce_alloc_ring(ab, nentries, desc_sz);
675 		if (IS_ERR(ring))
676 			return PTR_ERR(ring);
677 		pipe->dest_ring = ring;
678 
679 		desc_sz = ath11k_hal_ce_get_desc_size(HAL_CE_DESC_DST_STATUS);
680 		ring = ath11k_ce_alloc_ring(ab, nentries, desc_sz);
681 		if (IS_ERR(ring))
682 			return PTR_ERR(ring);
683 		pipe->status_ring = ring;
684 	}
685 
686 	return 0;
687 }
688 
ath11k_ce_per_engine_service(struct ath11k_base * ab,u16 ce_id)689 void ath11k_ce_per_engine_service(struct ath11k_base *ab, u16 ce_id)
690 {
691 	struct ath11k_ce_pipe *pipe = &ab->ce.ce_pipe[ce_id];
692 	const struct ce_attr *attr = &ab->hw_params.host_ce_config[ce_id];
693 
694 	if (attr->src_nentries)
695 		ath11k_ce_tx_process_cb(pipe);
696 
697 	if (pipe->recv_cb)
698 		ath11k_ce_recv_process_cb(pipe);
699 }
700 
ath11k_ce_poll_send_completed(struct ath11k_base * ab,u8 pipe_id)701 void ath11k_ce_poll_send_completed(struct ath11k_base *ab, u8 pipe_id)
702 {
703 	struct ath11k_ce_pipe *pipe = &ab->ce.ce_pipe[pipe_id];
704 	const struct ce_attr *attr =  &ab->hw_params.host_ce_config[pipe_id];
705 
706 	if ((pipe->attr_flags & CE_ATTR_DIS_INTR) && attr->src_nentries)
707 		ath11k_ce_tx_process_cb(pipe);
708 }
709 EXPORT_SYMBOL(ath11k_ce_per_engine_service);
710 
ath11k_ce_send(struct ath11k_base * ab,struct sk_buff * skb,u8 pipe_id,u16 transfer_id)711 int ath11k_ce_send(struct ath11k_base *ab, struct sk_buff *skb, u8 pipe_id,
712 		   u16 transfer_id)
713 {
714 	struct ath11k_ce_pipe *pipe = &ab->ce.ce_pipe[pipe_id];
715 	struct hal_srng *srng;
716 	u32 *desc;
717 	unsigned int write_index, sw_index;
718 	unsigned int nentries_mask;
719 	int ret = 0;
720 	u8 byte_swap_data = 0;
721 	int num_used;
722 
723 	/* Check if some entries could be regained by handling tx completion if
724 	 * the CE has interrupts disabled and the used entries is more than the
725 	 * defined usage threshold.
726 	 */
727 	if (pipe->attr_flags & CE_ATTR_DIS_INTR) {
728 		spin_lock_bh(&ab->ce.ce_lock);
729 		write_index = pipe->src_ring->write_index;
730 
731 		sw_index = pipe->src_ring->sw_index;
732 
733 		if (write_index >= sw_index)
734 			num_used = write_index - sw_index;
735 		else
736 			num_used = pipe->src_ring->nentries - sw_index +
737 				   write_index;
738 
739 		spin_unlock_bh(&ab->ce.ce_lock);
740 
741 		if (num_used > ATH11K_CE_USAGE_THRESHOLD)
742 			ath11k_ce_poll_send_completed(ab, pipe->pipe_num);
743 	}
744 
745 	if (test_bit(ATH11K_FLAG_CRASH_FLUSH, &ab->dev_flags))
746 		return -ESHUTDOWN;
747 
748 	spin_lock_bh(&ab->ce.ce_lock);
749 
750 	write_index = pipe->src_ring->write_index;
751 	nentries_mask = pipe->src_ring->nentries_mask;
752 
753 	srng = &ab->hal.srng_list[pipe->src_ring->hal_ring_id];
754 
755 	spin_lock_bh(&srng->lock);
756 
757 	ath11k_hal_srng_access_begin(ab, srng);
758 
759 	if (unlikely(ath11k_hal_srng_src_num_free(ab, srng, false) < 1)) {
760 		ath11k_hal_srng_access_end(ab, srng);
761 		ret = -ENOBUFS;
762 		goto err_unlock;
763 	}
764 
765 	desc = ath11k_hal_srng_src_get_next_reaped(ab, srng);
766 	if (!desc) {
767 		ath11k_hal_srng_access_end(ab, srng);
768 		ret = -ENOBUFS;
769 		goto err_unlock;
770 	}
771 
772 	if (pipe->attr_flags & CE_ATTR_BYTE_SWAP_DATA)
773 		byte_swap_data = 1;
774 
775 	ath11k_hal_ce_src_set_desc(desc, ATH11K_SKB_CB(skb)->paddr,
776 				   skb->len, transfer_id, byte_swap_data);
777 
778 	pipe->src_ring->skb[write_index] = skb;
779 	pipe->src_ring->write_index = CE_RING_IDX_INCR(nentries_mask,
780 						       write_index);
781 
782 	ath11k_hal_srng_access_end(ab, srng);
783 
784 	if (ath11k_ce_need_shadow_fix(pipe_id))
785 		ath11k_dp_shadow_start_timer(ab, srng, &ab->ce.hp_timer[pipe_id]);
786 
787 	spin_unlock_bh(&srng->lock);
788 
789 	spin_unlock_bh(&ab->ce.ce_lock);
790 
791 	return 0;
792 
793 err_unlock:
794 	spin_unlock_bh(&srng->lock);
795 
796 	spin_unlock_bh(&ab->ce.ce_lock);
797 
798 	return ret;
799 }
800 
ath11k_ce_rx_pipe_cleanup(struct ath11k_ce_pipe * pipe)801 static void ath11k_ce_rx_pipe_cleanup(struct ath11k_ce_pipe *pipe)
802 {
803 	struct ath11k_base *ab = pipe->ab;
804 	struct ath11k_ce_ring *ring = pipe->dest_ring;
805 	struct sk_buff *skb;
806 	int i;
807 
808 	if (!(ring && pipe->buf_sz))
809 		return;
810 
811 	for (i = 0; i < ring->nentries; i++) {
812 		skb = ring->skb[i];
813 		if (!skb)
814 			continue;
815 
816 		ring->skb[i] = NULL;
817 		dma_unmap_single(ab->dev, ATH11K_SKB_RXCB(skb)->paddr,
818 				 skb->len + skb_tailroom(skb), DMA_FROM_DEVICE);
819 		dev_kfree_skb_any(skb);
820 	}
821 }
822 
ath11k_ce_shadow_config(struct ath11k_base * ab)823 static void ath11k_ce_shadow_config(struct ath11k_base *ab)
824 {
825 	int i;
826 
827 	for (i = 0; i < ab->hw_params.ce_count; i++) {
828 		if (ab->hw_params.host_ce_config[i].src_nentries)
829 			ath11k_hal_srng_update_shadow_config(ab,
830 							     HAL_CE_SRC, i);
831 
832 		if (ab->hw_params.host_ce_config[i].dest_nentries) {
833 			ath11k_hal_srng_update_shadow_config(ab,
834 							     HAL_CE_DST, i);
835 
836 			ath11k_hal_srng_update_shadow_config(ab,
837 							     HAL_CE_DST_STATUS, i);
838 		}
839 	}
840 }
841 
ath11k_ce_get_shadow_config(struct ath11k_base * ab,u32 ** shadow_cfg,u32 * shadow_cfg_len)842 void ath11k_ce_get_shadow_config(struct ath11k_base *ab,
843 				 u32 **shadow_cfg, u32 *shadow_cfg_len)
844 {
845 	if (!ab->hw_params.supports_shadow_regs)
846 		return;
847 
848 	ath11k_hal_srng_get_shadow_config(ab, shadow_cfg, shadow_cfg_len);
849 
850 	/* shadow is already configured */
851 	if (*shadow_cfg_len)
852 		return;
853 
854 	/* shadow isn't configured yet, configure now.
855 	 * non-CE srngs are configured firstly, then
856 	 * all CE srngs.
857 	 */
858 	ath11k_hal_srng_shadow_config(ab);
859 	ath11k_ce_shadow_config(ab);
860 
861 	/* get the shadow configuration */
862 	ath11k_hal_srng_get_shadow_config(ab, shadow_cfg, shadow_cfg_len);
863 }
864 EXPORT_SYMBOL(ath11k_ce_get_shadow_config);
865 
ath11k_ce_cleanup_pipes(struct ath11k_base * ab)866 void ath11k_ce_cleanup_pipes(struct ath11k_base *ab)
867 {
868 	struct ath11k_ce_pipe *pipe;
869 	int pipe_num;
870 
871 	ath11k_ce_stop_shadow_timers(ab);
872 
873 	for (pipe_num = 0; pipe_num < ab->hw_params.ce_count; pipe_num++) {
874 		pipe = &ab->ce.ce_pipe[pipe_num];
875 		ath11k_ce_rx_pipe_cleanup(pipe);
876 
877 		/* Cleanup any src CE's which have interrupts disabled */
878 		ath11k_ce_poll_send_completed(ab, pipe_num);
879 
880 		/* NOTE: Should we also clean up tx buffer in all pipes? */
881 	}
882 }
883 EXPORT_SYMBOL(ath11k_ce_cleanup_pipes);
884 
ath11k_ce_rx_post_buf(struct ath11k_base * ab)885 void ath11k_ce_rx_post_buf(struct ath11k_base *ab)
886 {
887 	struct ath11k_ce_pipe *pipe;
888 	int i;
889 	int ret;
890 
891 	for (i = 0; i < ab->hw_params.ce_count; i++) {
892 		pipe = &ab->ce.ce_pipe[i];
893 		ret = ath11k_ce_rx_post_pipe(pipe);
894 		if (ret) {
895 			if (ret == -ENOSPC)
896 				continue;
897 
898 			ath11k_warn(ab, "failed to post rx buf to pipe: %d err: %d\n",
899 				    i, ret);
900 			mod_timer(&ab->rx_replenish_retry,
901 				  jiffies + ATH11K_CE_RX_POST_RETRY_JIFFIES);
902 
903 			return;
904 		}
905 	}
906 }
907 EXPORT_SYMBOL(ath11k_ce_rx_post_buf);
908 
ath11k_ce_rx_replenish_retry(struct timer_list * t)909 void ath11k_ce_rx_replenish_retry(struct timer_list *t)
910 {
911 	struct ath11k_base *ab = from_timer(ab, t, rx_replenish_retry);
912 
913 	ath11k_ce_rx_post_buf(ab);
914 }
915 
ath11k_ce_init_pipes(struct ath11k_base * ab)916 int ath11k_ce_init_pipes(struct ath11k_base *ab)
917 {
918 	struct ath11k_ce_pipe *pipe;
919 	int i;
920 	int ret;
921 
922 	for (i = 0; i < ab->hw_params.ce_count; i++) {
923 		pipe = &ab->ce.ce_pipe[i];
924 
925 		if (pipe->src_ring) {
926 			ret = ath11k_ce_init_ring(ab, pipe->src_ring, i,
927 						  HAL_CE_SRC);
928 			if (ret) {
929 				ath11k_warn(ab, "failed to init src ring: %d\n",
930 					    ret);
931 				/* Should we clear any partial init */
932 				return ret;
933 			}
934 
935 			pipe->src_ring->write_index = 0;
936 			pipe->src_ring->sw_index = 0;
937 		}
938 
939 		if (pipe->dest_ring) {
940 			ret = ath11k_ce_init_ring(ab, pipe->dest_ring, i,
941 						  HAL_CE_DST);
942 			if (ret) {
943 				ath11k_warn(ab, "failed to init dest ring: %d\n",
944 					    ret);
945 				/* Should we clear any partial init */
946 				return ret;
947 			}
948 
949 			pipe->rx_buf_needed = pipe->dest_ring->nentries ?
950 					      pipe->dest_ring->nentries - 2 : 0;
951 
952 			pipe->dest_ring->write_index = 0;
953 			pipe->dest_ring->sw_index = 0;
954 		}
955 
956 		if (pipe->status_ring) {
957 			ret = ath11k_ce_init_ring(ab, pipe->status_ring, i,
958 						  HAL_CE_DST_STATUS);
959 			if (ret) {
960 				ath11k_warn(ab, "failed to init dest status ing: %d\n",
961 					    ret);
962 				/* Should we clear any partial init */
963 				return ret;
964 			}
965 
966 			pipe->status_ring->write_index = 0;
967 			pipe->status_ring->sw_index = 0;
968 		}
969 	}
970 
971 	return 0;
972 }
973 
ath11k_ce_free_pipes(struct ath11k_base * ab)974 void ath11k_ce_free_pipes(struct ath11k_base *ab)
975 {
976 	struct ath11k_ce_pipe *pipe;
977 	struct ath11k_ce_ring *ce_ring;
978 	int desc_sz;
979 	int i;
980 
981 	for (i = 0; i < ab->hw_params.ce_count; i++) {
982 		pipe = &ab->ce.ce_pipe[i];
983 
984 		if (ath11k_ce_need_shadow_fix(i))
985 			ath11k_dp_shadow_stop_timer(ab, &ab->ce.hp_timer[i]);
986 
987 		if (pipe->src_ring) {
988 			desc_sz = ath11k_hal_ce_get_desc_size(HAL_CE_DESC_SRC);
989 			ce_ring = pipe->src_ring;
990 			dma_free_coherent(ab->dev,
991 					  pipe->src_ring->nentries * desc_sz +
992 					  CE_DESC_RING_ALIGN,
993 					  ce_ring->base_addr_owner_space_unaligned,
994 					  ce_ring->base_addr_ce_space_unaligned);
995 			kfree(pipe->src_ring);
996 			pipe->src_ring = NULL;
997 		}
998 
999 		if (pipe->dest_ring) {
1000 			desc_sz = ath11k_hal_ce_get_desc_size(HAL_CE_DESC_DST);
1001 			ce_ring = pipe->dest_ring;
1002 			dma_free_coherent(ab->dev,
1003 					  pipe->dest_ring->nentries * desc_sz +
1004 					  CE_DESC_RING_ALIGN,
1005 					  ce_ring->base_addr_owner_space_unaligned,
1006 					  ce_ring->base_addr_ce_space_unaligned);
1007 			kfree(pipe->dest_ring);
1008 			pipe->dest_ring = NULL;
1009 		}
1010 
1011 		if (pipe->status_ring) {
1012 			desc_sz =
1013 			  ath11k_hal_ce_get_desc_size(HAL_CE_DESC_DST_STATUS);
1014 			ce_ring = pipe->status_ring;
1015 			dma_free_coherent(ab->dev,
1016 					  pipe->status_ring->nentries * desc_sz +
1017 					  CE_DESC_RING_ALIGN,
1018 					  ce_ring->base_addr_owner_space_unaligned,
1019 					  ce_ring->base_addr_ce_space_unaligned);
1020 			kfree(pipe->status_ring);
1021 			pipe->status_ring = NULL;
1022 		}
1023 	}
1024 }
1025 EXPORT_SYMBOL(ath11k_ce_free_pipes);
1026 
ath11k_ce_alloc_pipes(struct ath11k_base * ab)1027 int ath11k_ce_alloc_pipes(struct ath11k_base *ab)
1028 {
1029 	struct ath11k_ce_pipe *pipe;
1030 	int i;
1031 	int ret;
1032 	const struct ce_attr *attr;
1033 
1034 	spin_lock_init(&ab->ce.ce_lock);
1035 
1036 	for (i = 0; i < ab->hw_params.ce_count; i++) {
1037 		attr = &ab->hw_params.host_ce_config[i];
1038 		pipe = &ab->ce.ce_pipe[i];
1039 		pipe->pipe_num = i;
1040 		pipe->ab = ab;
1041 		pipe->buf_sz = attr->src_sz_max;
1042 
1043 		ret = ath11k_ce_alloc_pipe(ab, i);
1044 		if (ret) {
1045 			/* Free any partial successful allocation */
1046 			ath11k_ce_free_pipes(ab);
1047 			return ret;
1048 		}
1049 	}
1050 
1051 	return 0;
1052 }
1053 EXPORT_SYMBOL(ath11k_ce_alloc_pipes);
1054 
1055 /* For Big Endian Host, Copy Engine byte_swap is enabled
1056  * When Copy Engine does byte_swap, need to byte swap again for the
1057  * Host to get/put buffer content in the correct byte order
1058  */
ath11k_ce_byte_swap(void * mem,u32 len)1059 void ath11k_ce_byte_swap(void *mem, u32 len)
1060 {
1061 	int i;
1062 #if defined(__FreeBSD__)
1063 	u32 *m = mem;
1064 #endif
1065 
1066 	if (IS_ENABLED(CONFIG_CPU_BIG_ENDIAN)) {
1067 		if (!mem)
1068 			return;
1069 
1070 		for (i = 0; i < (len / 4); i++) {
1071 #if defined(__linux__)
1072 			*(u32 *)mem = swab32(*(u32 *)mem);
1073 			mem += 4;
1074 #elif defined(__FreeBSD__)
1075 			*m = swab32(*m);
1076 			m++;
1077 #endif
1078 		}
1079 	}
1080 }
1081 
ath11k_ce_get_attr_flags(struct ath11k_base * ab,int ce_id)1082 int ath11k_ce_get_attr_flags(struct ath11k_base *ab, int ce_id)
1083 {
1084 	if (ce_id >= ab->hw_params.ce_count)
1085 		return -EINVAL;
1086 
1087 	return ab->hw_params.host_ce_config[ce_id].flags;
1088 }
1089 EXPORT_SYMBOL(ath11k_ce_get_attr_flags);
1090