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
35  * them with data. Block on the outgoing queue have been filled with data and
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,  in iio_buffer_block_release()  local
98 	WARN_ON(block->state != IIO_BLOCK_STATE_DEAD);  in iio_buffer_block_release()
100 	dma_free_coherent(block->queue->dev, PAGE_ALIGN(block->size),  in iio_buffer_block_release()
101 					block->vaddr, block->phys_addr);  in iio_buffer_block_release()
103 	iio_buffer_put(&block->queue->buffer);  in iio_buffer_block_release()
104 	kfree(block);  in iio_buffer_block_release()
107 static void iio_buffer_block_get(struct iio_dma_buffer_block *block)  in iio_buffer_block_get()  argument
109 	kref_get(&block->kref);  in iio_buffer_block_get()
112 static void iio_buffer_block_put(struct iio_dma_buffer_block *block)  in iio_buffer_block_put()  argument
114 	kref_put(&block->kref, iio_buffer_block_release);  in iio_buffer_block_put()
126 	struct iio_dma_buffer_block *block, *_block;  in iio_dma_buffer_cleanup_worker()  local
133 	list_for_each_entry_safe(block, _block, &block_list, head)  in iio_dma_buffer_cleanup_worker()
134 		iio_buffer_block_release(&block->kref);  in iio_dma_buffer_cleanup_worker()
140 	struct iio_dma_buffer_block *block;  in iio_buffer_block_release_atomic()  local
143 	block = container_of(kref, struct iio_dma_buffer_block, kref);  in iio_buffer_block_release_atomic()
146 	list_add_tail(&block->head, &iio_dma_buffer_dead_blocks);  in iio_buffer_block_release_atomic()
155 static void iio_buffer_block_put_atomic(struct iio_dma_buffer_block *block)  in iio_buffer_block_put_atomic()  argument
157 	kref_put(&block->kref, iio_buffer_block_release_atomic);  in iio_buffer_block_put_atomic()
168 	struct iio_dma_buffer_block *block;  in iio_dma_buffer_alloc_block()  local
170 	block = kzalloc(sizeof(*block), GFP_KERNEL);  in iio_dma_buffer_alloc_block()
171 	if (!block)  in iio_dma_buffer_alloc_block()
174 	block->vaddr = dma_alloc_coherent(queue->dev, PAGE_ALIGN(size),  in iio_dma_buffer_alloc_block()
175 		&block->phys_addr, GFP_KERNEL);  in iio_dma_buffer_alloc_block()
176 	if (!block->vaddr) {  in iio_dma_buffer_alloc_block()
177 		kfree(block);  in iio_dma_buffer_alloc_block()
181 	block->size = size;  in iio_dma_buffer_alloc_block()
182 	block->state = IIO_BLOCK_STATE_DONE;  in iio_dma_buffer_alloc_block()
183 	block->queue = queue;  in iio_dma_buffer_alloc_block()
184 	INIT_LIST_HEAD(&block->head);  in iio_dma_buffer_alloc_block()
185 	kref_init(&block->kref);  in iio_dma_buffer_alloc_block()
189 	return block;  in iio_dma_buffer_alloc_block()
192 static void _iio_dma_buffer_block_done(struct iio_dma_buffer_block *block)  in _iio_dma_buffer_block_done()  argument
194 	if (block->state != IIO_BLOCK_STATE_DEAD)  in _iio_dma_buffer_block_done()
195 		block->state = IIO_BLOCK_STATE_DONE;  in _iio_dma_buffer_block_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)  in iio_dma_buffer_block_done()  argument
207 	struct iio_dma_buffer_queue *queue = block->queue;  in iio_dma_buffer_block_done()
211 	_iio_dma_buffer_block_done(block);  in iio_dma_buffer_block_done()
214 	iio_buffer_block_put_atomic(block);  in iio_dma_buffer_block_done()
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;  in iio_dma_buffer_block_list_abort()  local
236 	list_for_each_entry_safe(block, _block, list, head) {  in iio_dma_buffer_block_list_abort()
237 		list_del(&block->head);  in iio_dma_buffer_block_list_abort()
238 		block->bytes_used = 0;  in iio_dma_buffer_block_list_abort()
239 		_iio_dma_buffer_block_done(block);  in iio_dma_buffer_block_list_abort()
240 		iio_buffer_block_put_atomic(block);  in iio_dma_buffer_block_list_abort()
248 static bool iio_dma_block_reusable(struct iio_dma_buffer_block *block)  in iio_dma_block_reusable()  argument
251 	 * If the core owns the block it can be re-used. This should be the  in iio_dma_block_reusable()
253 	 * not support abort and has not given back the block yet.  in iio_dma_block_reusable()
255 	switch (block->state) {  in iio_dma_block_reusable()
274 	struct iio_dma_buffer_block *block;  in iio_dma_buffer_request_update()  local
282 	 * buffering scheme with usually one block at a time being used by the  in iio_dma_buffer_request_update()
299 		block = queue->fileio.blocks[i];  in iio_dma_buffer_request_update()
302 		if (block && (!iio_dma_block_reusable(block) || !try_reuse))  in iio_dma_buffer_request_update()
303 			block->state = IIO_BLOCK_STATE_DEAD;  in iio_dma_buffer_request_update()
317 			block = queue->fileio.blocks[i];  in iio_dma_buffer_request_update()
318 			if (block->state == IIO_BLOCK_STATE_DEAD) {  in iio_dma_buffer_request_update()
320 				iio_buffer_block_put(block);  in iio_dma_buffer_request_update()
321 				block = NULL;  in iio_dma_buffer_request_update()
323 				block->size = size;  in iio_dma_buffer_request_update()
326 			block = NULL;  in iio_dma_buffer_request_update()
329 		if (!block) {  in iio_dma_buffer_request_update()
330 			block = iio_dma_buffer_alloc_block(queue, size);  in iio_dma_buffer_request_update()
331 			if (!block) {  in iio_dma_buffer_request_update()
335 			queue->fileio.blocks[i] = block;  in iio_dma_buffer_request_update()
338 		block->state = IIO_BLOCK_STATE_QUEUED;  in iio_dma_buffer_request_update()
339 		list_add_tail(&block->head, &queue->incoming);  in iio_dma_buffer_request_update()
373 	struct iio_dma_buffer_block *block)  in iio_dma_buffer_submit_block()  argument
378 	 * If the hardware has already been removed we put the block into  in iio_dma_buffer_submit_block()
385 	block->state = IIO_BLOCK_STATE_ACTIVE;  in iio_dma_buffer_submit_block()
386 	iio_buffer_block_get(block);  in iio_dma_buffer_submit_block()
387 	ret = queue->ops->submit(queue, block);  in iio_dma_buffer_submit_block()
399 		iio_buffer_block_put(block);  in iio_dma_buffer_submit_block()
417 	struct iio_dma_buffer_block *block, *_block;  in iio_dma_buffer_enable()  local
421 	list_for_each_entry_safe(block, _block, &queue->incoming, head) {  in iio_dma_buffer_enable()
422 		list_del(&block->head);  in iio_dma_buffer_enable()
423 		iio_dma_buffer_submit_block(queue, block);  in iio_dma_buffer_enable()
456 	struct iio_dma_buffer_block *block)  in iio_dma_buffer_enqueue()  argument
458 	if (block->state == IIO_BLOCK_STATE_DEAD) {  in iio_dma_buffer_enqueue()
459 		iio_buffer_block_put(block);  in iio_dma_buffer_enqueue()
461 		iio_dma_buffer_submit_block(queue, block);  in iio_dma_buffer_enqueue()
463 		block->state = IIO_BLOCK_STATE_QUEUED;  in iio_dma_buffer_enqueue()
464 		list_add_tail(&block->head, &queue->incoming);  in iio_dma_buffer_enqueue()
471 	struct iio_dma_buffer_block *block;  in iio_dma_buffer_dequeue()  local
477 	block = queue->fileio.blocks[idx];  in iio_dma_buffer_dequeue()
479 	if (block->state == IIO_BLOCK_STATE_DONE) {  in iio_dma_buffer_dequeue()
483 		block = NULL;  in iio_dma_buffer_dequeue()
488 	return block;  in iio_dma_buffer_dequeue()
504 	struct iio_dma_buffer_block *block;  in iio_dma_buffer_read()  local
513 		block = iio_dma_buffer_dequeue(queue);  in iio_dma_buffer_read()
514 		if (block == NULL) {  in iio_dma_buffer_read()
519 		queue->fileio.active_block = block;  in iio_dma_buffer_read()
521 		block = queue->fileio.active_block;  in iio_dma_buffer_read()
525 	if (n > block->bytes_used - queue->fileio.pos)  in iio_dma_buffer_read()
526 		n = block->bytes_used - queue->fileio.pos;  in iio_dma_buffer_read()
528 	if (copy_to_user(user_buffer, block->vaddr + queue->fileio.pos, n)) {  in iio_dma_buffer_read()
535 	if (queue->fileio.pos == block->bytes_used) {  in iio_dma_buffer_read()
537 		iio_dma_buffer_enqueue(queue, block);  in iio_dma_buffer_read()
559 	struct iio_dma_buffer_block *block;  in iio_dma_buffer_data_available()  local
564 	 * For counting the available bytes we'll use the size of the block not  in iio_dma_buffer_data_available()
565 	 * the number of actual bytes available in the block. Otherwise it is  in iio_dma_buffer_data_available()
577 		block = queue->fileio.blocks[i];  in iio_dma_buffer_data_available()
579 		if (block != queue->fileio.active_block  in iio_dma_buffer_data_available()
580 		    && block->state == IIO_BLOCK_STATE_DONE)  in iio_dma_buffer_data_available()
581 			data_available += block->size;  in iio_dma_buffer_data_available()