1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /*
3  * Copyright 2014-2015 Analog Devices Inc.
4  *  Author: Lars-Peter Clausen <lars@metafoo.de>
5  */
6 
7 #include <linux/slab.h>
8 #include <linux/kernel.h>
9 #include <linux/dmaengine.h>
10 #include <linux/dma-mapping.h>
11 #include <linux/spinlock.h>
12 #include <linux/err.h>
13 #include <linux/module.h>
14 
15 #include <linux/iio/iio.h>
16 #include <linux/iio/sysfs.h>
17 #include <linux/iio/buffer.h>
18 #include <linux/iio/buffer_impl.h>
19 #include <linux/iio/buffer-dma.h>
20 #include <linux/iio/buffer-dmaengine.h>
21 
22 /*
23  * The IIO DMAengine buffer combines the generic IIO DMA buffer infrastructure
24  * with the DMAengine framework. The generic IIO DMA buffer infrastructure is
25  * used to manage the buffer memory and implement the IIO buffer operations
26  * while the DMAengine framework is used to perform the DMA transfers. Combined
27  * this results in a device independent fully functional DMA buffer
28  * implementation that can be used by device drivers for peripherals which are
29  * connected to a DMA controller which has a DMAengine driver implementation.
30  */
31 
32 struct dmaengine_buffer {
33 	struct iio_dma_buffer_queue queue;
34 
35 	struct dma_chan *chan;
36 	struct list_head active;
37 
38 	size_t align;
39 	size_t max_size;
40 };
41 
42 static struct dmaengine_buffer *iio_buffer_to_dmaengine_buffer(
43 		struct iio_buffer *buffer)
44 {
45 	return container_of(buffer, struct dmaengine_buffer, queue.buffer);
46 }
47 
48 static void iio_dmaengine_buffer_block_done(void *data)
49 {
50 	struct iio_dma_buffer_block *block = data;
51 	unsigned long flags;
52 
53 	spin_lock_irqsave(&block->queue->list_lock, flags);
54 	list_del(&block->head);
55 	spin_unlock_irqrestore(&block->queue->list_lock, flags);
56 	iio_dma_buffer_block_done(block);
57 }
58 
59 static int iio_dmaengine_buffer_submit_block(struct iio_dma_buffer_queue *queue,
60 	struct iio_dma_buffer_block *block)
61 {
62 	struct dmaengine_buffer *dmaengine_buffer =
63 		iio_buffer_to_dmaengine_buffer(&queue->buffer);
64 	struct dma_async_tx_descriptor *desc;
65 	dma_cookie_t cookie;
66 
67 	block->bytes_used = min(block->size, dmaengine_buffer->max_size);
68 	block->bytes_used = rounddown(block->bytes_used,
69 			dmaengine_buffer->align);
70 
71 	desc = dmaengine_prep_slave_single(dmaengine_buffer->chan,
72 		block->phys_addr, block->bytes_used, DMA_DEV_TO_MEM,
73 		DMA_PREP_INTERRUPT);
74 	if (!desc)
75 		return -ENOMEM;
76 
77 	desc->callback = iio_dmaengine_buffer_block_done;
78 	desc->callback_param = block;
79 
80 	cookie = dmaengine_submit(desc);
81 	if (dma_submit_error(cookie))
82 		return dma_submit_error(cookie);
83 
84 	spin_lock_irq(&dmaengine_buffer->queue.list_lock);
85 	list_add_tail(&block->head, &dmaengine_buffer->active);
86 	spin_unlock_irq(&dmaengine_buffer->queue.list_lock);
87 
88 	dma_async_issue_pending(dmaengine_buffer->chan);
89 
90 	return 0;
91 }
92 
93 static void iio_dmaengine_buffer_abort(struct iio_dma_buffer_queue *queue)
94 {
95 	struct dmaengine_buffer *dmaengine_buffer =
96 		iio_buffer_to_dmaengine_buffer(&queue->buffer);
97 
98 	dmaengine_terminate_sync(dmaengine_buffer->chan);
99 	iio_dma_buffer_block_list_abort(queue, &dmaengine_buffer->active);
100 }
101 
102 static void iio_dmaengine_buffer_release(struct iio_buffer *buf)
103 {
104 	struct dmaengine_buffer *dmaengine_buffer =
105 		iio_buffer_to_dmaengine_buffer(buf);
106 
107 	iio_dma_buffer_release(&dmaengine_buffer->queue);
108 	kfree(dmaengine_buffer);
109 }
110 
111 static const struct iio_buffer_access_funcs iio_dmaengine_buffer_ops = {
112 	.read = iio_dma_buffer_read,
113 	.set_bytes_per_datum = iio_dma_buffer_set_bytes_per_datum,
114 	.set_length = iio_dma_buffer_set_length,
115 	.request_update = iio_dma_buffer_request_update,
116 	.enable = iio_dma_buffer_enable,
117 	.disable = iio_dma_buffer_disable,
118 	.data_available = iio_dma_buffer_data_available,
119 	.release = iio_dmaengine_buffer_release,
120 
121 	.modes = INDIO_BUFFER_HARDWARE,
122 	.flags = INDIO_BUFFER_FLAG_FIXED_WATERMARK,
123 };
124 
125 static const struct iio_dma_buffer_ops iio_dmaengine_default_ops = {
126 	.submit = iio_dmaengine_buffer_submit_block,
127 	.abort = iio_dmaengine_buffer_abort,
128 };
129 
130 static ssize_t iio_dmaengine_buffer_get_length_align(struct device *dev,
131 	struct device_attribute *attr, char *buf)
132 {
133 	struct iio_dev *indio_dev = dev_to_iio_dev(dev);
134 	struct dmaengine_buffer *dmaengine_buffer =
135 		iio_buffer_to_dmaengine_buffer(indio_dev->buffer);
136 
137 	return sprintf(buf, "%zu\n", dmaengine_buffer->align);
138 }
139 
140 static IIO_DEVICE_ATTR(length_align_bytes, 0444,
141 		       iio_dmaengine_buffer_get_length_align, NULL, 0);
142 
143 static const struct attribute *iio_dmaengine_buffer_attrs[] = {
144 	&iio_dev_attr_length_align_bytes.dev_attr.attr,
145 	NULL,
146 };
147 
148 /**
149  * iio_dmaengine_buffer_alloc() - Allocate new buffer which uses DMAengine
150  * @dev: Parent device for the buffer
151  * @channel: DMA channel name, typically "rx".
152  *
153  * This allocates a new IIO buffer which internally uses the DMAengine framework
154  * to perform its transfers. The parent device will be used to request the DMA
155  * channel.
156  *
157  * Once done using the buffer iio_dmaengine_buffer_free() should be used to
158  * release it.
159  */
160 struct iio_buffer *iio_dmaengine_buffer_alloc(struct device *dev,
161 	const char *channel)
162 {
163 	struct dmaengine_buffer *dmaengine_buffer;
164 	unsigned int width, src_width, dest_width;
165 	struct dma_slave_caps caps;
166 	struct dma_chan *chan;
167 	int ret;
168 
169 	dmaengine_buffer = kzalloc(sizeof(*dmaengine_buffer), GFP_KERNEL);
170 	if (!dmaengine_buffer)
171 		return ERR_PTR(-ENOMEM);
172 
173 	chan = dma_request_chan(dev, channel);
174 	if (IS_ERR(chan)) {
175 		ret = PTR_ERR(chan);
176 		goto err_free;
177 	}
178 
179 	ret = dma_get_slave_caps(chan, &caps);
180 	if (ret < 0)
181 		goto err_free;
182 
183 	/* Needs to be aligned to the maximum of the minimums */
184 	if (caps.src_addr_widths)
185 		src_width = __ffs(caps.src_addr_widths);
186 	else
187 		src_width = 1;
188 	if (caps.dst_addr_widths)
189 		dest_width = __ffs(caps.dst_addr_widths);
190 	else
191 		dest_width = 1;
192 	width = max(src_width, dest_width);
193 
194 	INIT_LIST_HEAD(&dmaengine_buffer->active);
195 	dmaengine_buffer->chan = chan;
196 	dmaengine_buffer->align = width;
197 	dmaengine_buffer->max_size = dma_get_max_seg_size(chan->device->dev);
198 
199 	iio_dma_buffer_init(&dmaengine_buffer->queue, chan->device->dev,
200 		&iio_dmaengine_default_ops);
201 	iio_buffer_set_attrs(&dmaengine_buffer->queue.buffer,
202 		iio_dmaengine_buffer_attrs);
203 
204 	dmaengine_buffer->queue.buffer.access = &iio_dmaengine_buffer_ops;
205 
206 	return &dmaengine_buffer->queue.buffer;
207 
208 err_free:
209 	kfree(dmaengine_buffer);
210 	return ERR_PTR(ret);
211 }
212 EXPORT_SYMBOL(iio_dmaengine_buffer_alloc);
213 
214 /**
215  * iio_dmaengine_buffer_free() - Free dmaengine buffer
216  * @buffer: Buffer to free
217  *
218  * Frees a buffer previously allocated with iio_dmaengine_buffer_alloc().
219  */
220 void iio_dmaengine_buffer_free(struct iio_buffer *buffer)
221 {
222 	struct dmaengine_buffer *dmaengine_buffer =
223 		iio_buffer_to_dmaengine_buffer(buffer);
224 
225 	iio_dma_buffer_exit(&dmaengine_buffer->queue);
226 	dma_release_channel(dmaengine_buffer->chan);
227 
228 	iio_buffer_put(buffer);
229 }
230 EXPORT_SYMBOL_GPL(iio_dmaengine_buffer_free);
231 
232 static void __devm_iio_dmaengine_buffer_free(struct device *dev, void *res)
233 {
234 	iio_dmaengine_buffer_free(*(struct iio_buffer **)res);
235 }
236 
237 /**
238  * devm_iio_dmaengine_buffer_alloc() - Resource-managed iio_dmaengine_buffer_alloc()
239  * @dev: Parent device for the buffer
240  * @channel: DMA channel name, typically "rx".
241  *
242  * This allocates a new IIO buffer which internally uses the DMAengine framework
243  * to perform its transfers. The parent device will be used to request the DMA
244  * channel.
245  *
246  * The buffer will be automatically de-allocated once the device gets destroyed.
247  */
248 struct iio_buffer *devm_iio_dmaengine_buffer_alloc(struct device *dev,
249 	const char *channel)
250 {
251 	struct iio_buffer **bufferp, *buffer;
252 
253 	bufferp = devres_alloc(__devm_iio_dmaengine_buffer_free,
254 			       sizeof(*bufferp), GFP_KERNEL);
255 	if (!bufferp)
256 		return ERR_PTR(-ENOMEM);
257 
258 	buffer = iio_dmaengine_buffer_alloc(dev, channel);
259 	if (IS_ERR(buffer)) {
260 		devres_free(bufferp);
261 		return buffer;
262 	}
263 
264 	*bufferp = buffer;
265 	devres_add(dev, bufferp);
266 
267 	return buffer;
268 }
269 EXPORT_SYMBOL_GPL(devm_iio_dmaengine_buffer_alloc);
270 
271 MODULE_AUTHOR("Lars-Peter Clausen <lars@metafoo.de>");
272 MODULE_DESCRIPTION("DMA buffer for the IIO framework");
273 MODULE_LICENSE("GPL");
274