1// SPDX-License-Identifier: GPL-2.0-only
2/* Copyright (C) 2023 Intel Corporation */
3
4#include "idpf_controlq.h"
5
6/**
7 * idpf_ctlq_alloc_desc_ring - Allocate Control Queue (CQ) rings
8 * @hw: pointer to hw struct
9 * @cq: pointer to the specific Control queue
10 */
11static int idpf_ctlq_alloc_desc_ring(struct idpf_hw *hw,
12				     struct idpf_ctlq_info *cq)
13{
14	size_t size = cq->ring_size * sizeof(struct idpf_ctlq_desc);
15
16	cq->desc_ring.va = idpf_alloc_dma_mem(hw, &cq->desc_ring, size);
17	if (!cq->desc_ring.va)
18		return -ENOMEM;
19
20	return 0;
21}
22
23/**
24 * idpf_ctlq_alloc_bufs - Allocate Control Queue (CQ) buffers
25 * @hw: pointer to hw struct
26 * @cq: pointer to the specific Control queue
27 *
28 * Allocate the buffer head for all control queues, and if it's a receive
29 * queue, allocate DMA buffers
30 */
31static int idpf_ctlq_alloc_bufs(struct idpf_hw *hw,
32				struct idpf_ctlq_info *cq)
33{
34	int i;
35
36	/* Do not allocate DMA buffers for transmit queues */
37	if (cq->cq_type == IDPF_CTLQ_TYPE_MAILBOX_TX)
38		return 0;
39
40	/* We'll be allocating the buffer info memory first, then we can
41	 * allocate the mapped buffers for the event processing
42	 */
43	cq->bi.rx_buff = kcalloc(cq->ring_size, sizeof(struct idpf_dma_mem *),
44				 GFP_KERNEL);
45	if (!cq->bi.rx_buff)
46		return -ENOMEM;
47
48	/* allocate the mapped buffers (except for the last one) */
49	for (i = 0; i < cq->ring_size - 1; i++) {
50		struct idpf_dma_mem *bi;
51		int num = 1; /* number of idpf_dma_mem to be allocated */
52
53		cq->bi.rx_buff[i] = kcalloc(num, sizeof(struct idpf_dma_mem),
54					    GFP_KERNEL);
55		if (!cq->bi.rx_buff[i])
56			goto unwind_alloc_cq_bufs;
57
58		bi = cq->bi.rx_buff[i];
59
60		bi->va = idpf_alloc_dma_mem(hw, bi, cq->buf_size);
61		if (!bi->va) {
62			/* unwind will not free the failed entry */
63			kfree(cq->bi.rx_buff[i]);
64			goto unwind_alloc_cq_bufs;
65		}
66	}
67
68	return 0;
69
70unwind_alloc_cq_bufs:
71	/* don't try to free the one that failed... */
72	i--;
73	for (; i >= 0; i--) {
74		idpf_free_dma_mem(hw, cq->bi.rx_buff[i]);
75		kfree(cq->bi.rx_buff[i]);
76	}
77	kfree(cq->bi.rx_buff);
78
79	return -ENOMEM;
80}
81
82/**
83 * idpf_ctlq_free_desc_ring - Free Control Queue (CQ) rings
84 * @hw: pointer to hw struct
85 * @cq: pointer to the specific Control queue
86 *
87 * This assumes the posted send buffers have already been cleaned
88 * and de-allocated
89 */
90static void idpf_ctlq_free_desc_ring(struct idpf_hw *hw,
91				     struct idpf_ctlq_info *cq)
92{
93	idpf_free_dma_mem(hw, &cq->desc_ring);
94}
95
96/**
97 * idpf_ctlq_free_bufs - Free CQ buffer info elements
98 * @hw: pointer to hw struct
99 * @cq: pointer to the specific Control queue
100 *
101 * Free the DMA buffers for RX queues, and DMA buffer header for both RX and TX
102 * queues.  The upper layers are expected to manage freeing of TX DMA buffers
103 */
104static void idpf_ctlq_free_bufs(struct idpf_hw *hw, struct idpf_ctlq_info *cq)
105{
106	void *bi;
107
108	if (cq->cq_type == IDPF_CTLQ_TYPE_MAILBOX_RX) {
109		int i;
110
111		/* free DMA buffers for rx queues*/
112		for (i = 0; i < cq->ring_size; i++) {
113			if (cq->bi.rx_buff[i]) {
114				idpf_free_dma_mem(hw, cq->bi.rx_buff[i]);
115				kfree(cq->bi.rx_buff[i]);
116			}
117		}
118
119		bi = (void *)cq->bi.rx_buff;
120	} else {
121		bi = (void *)cq->bi.tx_msg;
122	}
123
124	/* free the buffer header */
125	kfree(bi);
126}
127
128/**
129 * idpf_ctlq_dealloc_ring_res - Free memory allocated for control queue
130 * @hw: pointer to hw struct
131 * @cq: pointer to the specific Control queue
132 *
133 * Free the memory used by the ring, buffers and other related structures
134 */
135void idpf_ctlq_dealloc_ring_res(struct idpf_hw *hw, struct idpf_ctlq_info *cq)
136{
137	/* free ring buffers and the ring itself */
138	idpf_ctlq_free_bufs(hw, cq);
139	idpf_ctlq_free_desc_ring(hw, cq);
140}
141
142/**
143 * idpf_ctlq_alloc_ring_res - allocate memory for descriptor ring and bufs
144 * @hw: pointer to hw struct
145 * @cq: pointer to control queue struct
146 *
147 * Do *NOT* hold cq_lock when calling this as the memory allocation routines
148 * called are not going to be atomic context safe
149 */
150int idpf_ctlq_alloc_ring_res(struct idpf_hw *hw, struct idpf_ctlq_info *cq)
151{
152	int err;
153
154	/* allocate the ring memory */
155	err = idpf_ctlq_alloc_desc_ring(hw, cq);
156	if (err)
157		return err;
158
159	/* allocate buffers in the rings */
160	err = idpf_ctlq_alloc_bufs(hw, cq);
161	if (err)
162		goto idpf_init_cq_free_ring;
163
164	/* success! */
165	return 0;
166
167idpf_init_cq_free_ring:
168	idpf_free_dma_mem(hw, &cq->desc_ring);
169
170	return err;
171}
172