iio/buffer/industrialio-buffer-dma.c

21  * For DMA buffers the storage is sub-divided into so called blocks. Each block
22  * has its own memory buffer. The size of the block is the granularity at which
24  * basic unit of data exchange from one sample to one block decreases the
27  * sample the overhead will be x for each sample. Whereas when using a block
38  * A block can be in one of the following states:
40  *    the block.
43  *  * Owned by the DMA controller: The DMA controller is processing the block
48  *  * Dead: A block that is dead has been marked as to be freed. It might still
51  *    incoming or outgoing queue the block will be freed.
54  * with both the block structure as well as the storage memory for the block
55  * will be freed when the last reference to the block is dropped. This means a
56  * block must not be accessed without holding a reference.
64  * converter to the memory region of the block. Once the DMA transfer has been
66  * block.
68  * Prior to this it must set the bytes_used field of the block contains
70  * size of the block, but if the DMA hardware has certain alignment requirements
73  * datum, i.e. the block must not contain partial samples.
75  * The driver must call iio_dma_buffer_block_done() for each block it has
77  * perform a DMA transfer for the block, e.g. because the buffer was disabled
78  * before the block transfer was started. In this case it should set bytes_used
95 	struct iio_dma_buffer_block *block = container_of(kref,
98 	WARN_ON(block->state != IIO_BLOCK_STATE_DEAD);
100 	dma_free_coherent(block->queue->dev, PAGE_ALIGN(block->size),
101 					block->vaddr, block->phys_addr);
103 	iio_buffer_put(&block->queue->buffer);
104 	kfree(block);
107 static void iio_buffer_block_get(struct iio_dma_buffer_block *block)
109 	kref_get(&block->kref);
112 static void iio_buffer_block_put(struct iio_dma_buffer_block *block)
114 	kref_put(&block->kref, iio_buffer_block_release);
126 	struct iio_dma_buffer_block *block, *_block;
133 	list_for_each_entry_safe(block, _block, &block_list, head)
134 		iio_buffer_block_release(&block->kref);
140 	struct iio_dma_buffer_block *block;
143 	block = container_of(kref, struct iio_dma_buffer_block, kref);
146 	list_add_tail(&block->head, &iio_dma_buffer_dead_blocks);
155 static void iio_buffer_block_put_atomic(struct iio_dma_buffer_block *block)
157 	kref_put(&block->kref, iio_buffer_block_release_atomic);
168 	struct iio_dma_buffer_block *block;
170 	block = kzalloc(sizeof(*block), GFP_KERNEL);
171 	if (!block)
174 	block->vaddr = dma_alloc_coherent(queue->dev, PAGE_ALIGN(size),
175 		&block->phys_addr, GFP_KERNEL);
176 	if (!block->vaddr) {
177 		kfree(block);
181 	block->size = size;
182 	block->state = IIO_BLOCK_STATE_DONE;
183 	block->queue = queue;
184 	INIT_LIST_HEAD(&block->head);
185 	kref_init(&block->kref);
189 	return block;
192 static void _iio_dma_buffer_block_done(struct iio_dma_buffer_block *block)
194 	if (block->state != IIO_BLOCK_STATE_DEAD)
195 		block->state = IIO_BLOCK_STATE_DONE;
199  * iio_dma_buffer_block_done() - Indicate that a block has been completed
200  * @block: The completed block
202  * Should be called when the DMA controller has finished handling the block to
203  * pass back ownership of the block to the queue.
205 void iio_dma_buffer_block_done(struct iio_dma_buffer_block *block)
207 	struct iio_dma_buffer_queue *queue = block->queue;
211 	_iio_dma_buffer_block_done(block);
214 	iio_buffer_block_put_atomic(block);
220  * iio_dma_buffer_block_list_abort() - Indicate that a list block has been
226  * stopped. This will set bytes_used to 0 for each block in the list and then
232 	struct iio_dma_buffer_block *block, *_block;
236 	list_for_each_entry_safe(block, _block, list, head) {
237 		list_del(&block->head);
238 		block->bytes_used = 0;
239 		_iio_dma_buffer_block_done(block);
240 		iio_buffer_block_put_atomic(block);
248 static bool iio_dma_block_reusable(struct iio_dma_buffer_block *block)
251 	 * If the core owns the block it can be re-used. This should be the
253 	 * not support abort and has not given back the block yet.
255 	switch (block->state) {
274 	struct iio_dma_buffer_block *block;
282 	 * buffering scheme with usually one block at a time being used by the
299 		block = queue->fileio.blocks[i];
302 		if (block && (!iio_dma_block_reusable(block) || !try_reuse))
303 			block->state = IIO_BLOCK_STATE_DEAD;
317 			block = queue->fileio.blocks[i];
318 			if (block->state == IIO_BLOCK_STATE_DEAD) {
320 				iio_buffer_block_put(block);
321 				block = NULL;
323 				block->size = size;
326 			block = NULL;
329 		if (!block) {
330 			block = iio_dma_buffer_alloc_block(queue, size);
331 			if (!block) {
335 			queue->fileio.blocks[i] = block;
338 		block->state = IIO_BLOCK_STATE_QUEUED;
339 		list_add_tail(&block->head, &queue->incoming);
373 	struct iio_dma_buffer_block *block)
378 	 * If the hardware has already been removed we put the block into
385 	block->state = IIO_BLOCK_STATE_ACTIVE;
386 	iio_buffer_block_get(block);
387 	ret = queue->ops->submit(queue, block);
399 		iio_buffer_block_put(block);
417 	struct iio_dma_buffer_block *block, *_block;
421 	list_for_each_entry_safe(block, _block, &queue->incoming, head) {
422 		list_del(&block->head);
423 		iio_dma_buffer_submit_block(queue, block);
456 	struct iio_dma_buffer_block *block)
458 	if (block->state == IIO_BLOCK_STATE_DEAD) {
459 		iio_buffer_block_put(block);
461 		iio_dma_buffer_submit_block(queue, block);
463 		block->state = IIO_BLOCK_STATE_QUEUED;
464 		list_add_tail(&block->head, &queue->incoming);
471 	struct iio_dma_buffer_block *block;
477 	block = queue->fileio.blocks[idx];
479 	if (block->state == IIO_BLOCK_STATE_DONE) {
483 		block = NULL;
488 	return block;
504 	struct iio_dma_buffer_block *block;
513 		block = iio_dma_buffer_dequeue(queue);
514 		if (block == NULL) {
519 		queue->fileio.active_block = block;
521 		block = queue->fileio.active_block;
525 	if (n > block->bytes_used - queue->fileio.pos)
526 		n = block->bytes_used - queue->fileio.pos;
528 	if (copy_to_user(user_buffer, block->vaddr + queue->fileio.pos, n)) {
535 	if (queue->fileio.pos == block->bytes_used) {
537 		iio_dma_buffer_enqueue(queue, block);
559 	struct iio_dma_buffer_block *block;
564 	 * For counting the available bytes we'll use the size of the block not
565 	 * the number of actual bytes available in the block. Otherwise it is
577 		block = queue->fileio.blocks[i];
579 		if (block != queue->fileio.active_block
580 		    && block->state == IIO_BLOCK_STATE_DONE)
581 			data_available += block->size;