GNU Linux-libre 4.9.282-gnu1
[releases.git] / drivers / iio / buffer / industrialio-buffer-dma.c
1 /*
2  * Copyright 2013-2015 Analog Devices Inc.
3  *  Author: Lars-Peter Clausen <lars@metafoo.de>
4  *
5  * Licensed under the GPL-2.
6  */
7
8 #include <linux/slab.h>
9 #include <linux/kernel.h>
10 #include <linux/module.h>
11 #include <linux/device.h>
12 #include <linux/workqueue.h>
13 #include <linux/mutex.h>
14 #include <linux/sched.h>
15 #include <linux/poll.h>
16 #include <linux/iio/buffer.h>
17 #include <linux/iio/buffer-dma.h>
18 #include <linux/dma-mapping.h>
19 #include <linux/sizes.h>
20
21 /*
22  * For DMA buffers the storage is sub-divided into so called blocks. Each block
23  * has its own memory buffer. The size of the block is the granularity at which
24  * memory is exchanged between the hardware and the application. Increasing the
25  * basic unit of data exchange from one sample to one block decreases the
26  * management overhead that is associated with each sample. E.g. if we say the
27  * management overhead for one exchange is x and the unit of exchange is one
28  * sample the overhead will be x for each sample. Whereas when using a block
29  * which contains n samples the overhead per sample is reduced to x/n. This
30  * allows to achieve much higher samplerates than what can be sustained with
31  * the one sample approach.
32  *
33  * Blocks are exchanged between the DMA controller and the application via the
34  * means of two queues. The incoming queue and the outgoing queue. Blocks on the
35  * incoming queue are waiting for the DMA controller to pick them up and fill
36  * them with data. Block on the outgoing queue have been filled with data and
37  * are waiting for the application to dequeue them and read the data.
38  *
39  * A block can be in one of the following states:
40  *  * Owned by the application. In this state the application can read data from
41  *    the block.
42  *  * On the incoming list: Blocks on the incoming list are queued up to be
43  *    processed by the DMA controller.
44  *  * Owned by the DMA controller: The DMA controller is processing the block
45  *    and filling it with data.
46  *  * On the outgoing list: Blocks on the outgoing list have been successfully
47  *    processed by the DMA controller and contain data. They can be dequeued by
48  *    the application.
49  *  * Dead: A block that is dead has been marked as to be freed. It might still
50  *    be owned by either the application or the DMA controller at the moment.
51  *    But once they are done processing it instead of going to either the
52  *    incoming or outgoing queue the block will be freed.
53  *
54  * In addition to this blocks are reference counted and the memory associated
55  * with both the block structure as well as the storage memory for the block
56  * will be freed when the last reference to the block is dropped. This means a
57  * block must not be accessed without holding a reference.
58  *
59  * The iio_dma_buffer implementation provides a generic infrastructure for
60  * managing the blocks.
61  *
62  * A driver for a specific piece of hardware that has DMA capabilities need to
63  * implement the submit() callback from the iio_dma_buffer_ops structure. This
64  * callback is supposed to initiate the DMA transfer copying data from the
65  * converter to the memory region of the block. Once the DMA transfer has been
66  * completed the driver must call iio_dma_buffer_block_done() for the completed
67  * block.
68  *
69  * Prior to this it must set the bytes_used field of the block contains
70  * the actual number of bytes in the buffer. Typically this will be equal to the
71  * size of the block, but if the DMA hardware has certain alignment requirements
72  * for the transfer length it might choose to use less than the full size. In
73  * either case it is expected that bytes_used is a multiple of the bytes per
74  * datum, i.e. the block must not contain partial samples.
75  *
76  * The driver must call iio_dma_buffer_block_done() for each block it has
77  * received through its submit_block() callback, even if it does not actually
78  * perform a DMA transfer for the block, e.g. because the buffer was disabled
79  * before the block transfer was started. In this case it should set bytes_used
80  * to 0.
81  *
82  * In addition it is recommended that a driver implements the abort() callback.
83  * It will be called when the buffer is disabled and can be used to cancel
84  * pending and stop active transfers.
85  *
86  * The specific driver implementation should use the default callback
87  * implementations provided by this module for the iio_buffer_access_funcs
88  * struct. It may overload some callbacks with custom variants if the hardware
89  * has special requirements that are not handled by the generic functions. If a
90  * driver chooses to overload a callback it has to ensure that the generic
91  * callback is called from within the custom callback.
92  */
93
94 static void iio_buffer_block_release(struct kref *kref)
95 {
96         struct iio_dma_buffer_block *block = container_of(kref,
97                 struct iio_dma_buffer_block, kref);
98
99         WARN_ON(block->state != IIO_BLOCK_STATE_DEAD);
100
101         dma_free_coherent(block->queue->dev, PAGE_ALIGN(block->size),
102                                         block->vaddr, block->phys_addr);
103
104         iio_buffer_put(&block->queue->buffer);
105         kfree(block);
106 }
107
108 static void iio_buffer_block_get(struct iio_dma_buffer_block *block)
109 {
110         kref_get(&block->kref);
111 }
112
113 static void iio_buffer_block_put(struct iio_dma_buffer_block *block)
114 {
115         kref_put(&block->kref, iio_buffer_block_release);
116 }
117
118 /*
119  * dma_free_coherent can sleep, hence we need to take some special care to be
120  * able to drop a reference from an atomic context.
121  */
122 static LIST_HEAD(iio_dma_buffer_dead_blocks);
123 static DEFINE_SPINLOCK(iio_dma_buffer_dead_blocks_lock);
124
125 static void iio_dma_buffer_cleanup_worker(struct work_struct *work)
126 {
127         struct iio_dma_buffer_block *block, *_block;
128         LIST_HEAD(block_list);
129
130         spin_lock_irq(&iio_dma_buffer_dead_blocks_lock);
131         list_splice_tail_init(&iio_dma_buffer_dead_blocks, &block_list);
132         spin_unlock_irq(&iio_dma_buffer_dead_blocks_lock);
133
134         list_for_each_entry_safe(block, _block, &block_list, head)
135                 iio_buffer_block_release(&block->kref);
136 }
137 static DECLARE_WORK(iio_dma_buffer_cleanup_work, iio_dma_buffer_cleanup_worker);
138
139 static void iio_buffer_block_release_atomic(struct kref *kref)
140 {
141         struct iio_dma_buffer_block *block;
142         unsigned long flags;
143
144         block = container_of(kref, struct iio_dma_buffer_block, kref);
145
146         spin_lock_irqsave(&iio_dma_buffer_dead_blocks_lock, flags);
147         list_add_tail(&block->head, &iio_dma_buffer_dead_blocks);
148         spin_unlock_irqrestore(&iio_dma_buffer_dead_blocks_lock, flags);
149
150         schedule_work(&iio_dma_buffer_cleanup_work);
151 }
152
153 /*
154  * Version of iio_buffer_block_put() that can be called from atomic context
155  */
156 static void iio_buffer_block_put_atomic(struct iio_dma_buffer_block *block)
157 {
158         kref_put(&block->kref, iio_buffer_block_release_atomic);
159 }
160
161 static struct iio_dma_buffer_queue *iio_buffer_to_queue(struct iio_buffer *buf)
162 {
163         return container_of(buf, struct iio_dma_buffer_queue, buffer);
164 }
165
166 static struct iio_dma_buffer_block *iio_dma_buffer_alloc_block(
167         struct iio_dma_buffer_queue *queue, size_t size)
168 {
169         struct iio_dma_buffer_block *block;
170
171         block = kzalloc(sizeof(*block), GFP_KERNEL);
172         if (!block)
173                 return NULL;
174
175         block->vaddr = dma_alloc_coherent(queue->dev, PAGE_ALIGN(size),
176                 &block->phys_addr, GFP_KERNEL);
177         if (!block->vaddr) {
178                 kfree(block);
179                 return NULL;
180         }
181
182         block->size = size;
183         block->state = IIO_BLOCK_STATE_DEQUEUED;
184         block->queue = queue;
185         INIT_LIST_HEAD(&block->head);
186         kref_init(&block->kref);
187
188         iio_buffer_get(&queue->buffer);
189
190         return block;
191 }
192
193 static void _iio_dma_buffer_block_done(struct iio_dma_buffer_block *block)
194 {
195         struct iio_dma_buffer_queue *queue = block->queue;
196
197         /*
198          * The buffer has already been freed by the application, just drop the
199          * reference.
200          */
201         if (block->state != IIO_BLOCK_STATE_DEAD) {
202                 block->state = IIO_BLOCK_STATE_DONE;
203                 list_add_tail(&block->head, &queue->outgoing);
204         }
205 }
206
207 /**
208  * iio_dma_buffer_block_done() - Indicate that a block has been completed
209  * @block: The completed block
210  *
211  * Should be called when the DMA controller has finished handling the block to
212  * pass back ownership of the block to the queue.
213  */
214 void iio_dma_buffer_block_done(struct iio_dma_buffer_block *block)
215 {
216         struct iio_dma_buffer_queue *queue = block->queue;
217         unsigned long flags;
218
219         spin_lock_irqsave(&queue->list_lock, flags);
220         _iio_dma_buffer_block_done(block);
221         spin_unlock_irqrestore(&queue->list_lock, flags);
222
223         iio_buffer_block_put_atomic(block);
224         wake_up_interruptible_poll(&queue->buffer.pollq, POLLIN | POLLRDNORM);
225 }
226 EXPORT_SYMBOL_GPL(iio_dma_buffer_block_done);
227
228 /**
229  * iio_dma_buffer_block_list_abort() - Indicate that a list block has been
230  *   aborted
231  * @queue: Queue for which to complete blocks.
232  * @list: List of aborted blocks. All blocks in this list must be from @queue.
233  *
234  * Typically called from the abort() callback after the DMA controller has been
235  * stopped. This will set bytes_used to 0 for each block in the list and then
236  * hand the blocks back to the queue.
237  */
238 void iio_dma_buffer_block_list_abort(struct iio_dma_buffer_queue *queue,
239         struct list_head *list)
240 {
241         struct iio_dma_buffer_block *block, *_block;
242         unsigned long flags;
243
244         spin_lock_irqsave(&queue->list_lock, flags);
245         list_for_each_entry_safe(block, _block, list, head) {
246                 list_del(&block->head);
247                 block->bytes_used = 0;
248                 _iio_dma_buffer_block_done(block);
249                 iio_buffer_block_put_atomic(block);
250         }
251         spin_unlock_irqrestore(&queue->list_lock, flags);
252
253         wake_up_interruptible_poll(&queue->buffer.pollq, POLLIN | POLLRDNORM);
254 }
255 EXPORT_SYMBOL_GPL(iio_dma_buffer_block_list_abort);
256
257 static bool iio_dma_block_reusable(struct iio_dma_buffer_block *block)
258 {
259         /*
260          * If the core owns the block it can be re-used. This should be the
261          * default case when enabling the buffer, unless the DMA controller does
262          * not support abort and has not given back the block yet.
263          */
264         switch (block->state) {
265         case IIO_BLOCK_STATE_DEQUEUED:
266         case IIO_BLOCK_STATE_QUEUED:
267         case IIO_BLOCK_STATE_DONE:
268                 return true;
269         default:
270                 return false;
271         }
272 }
273
274 /**
275  * iio_dma_buffer_request_update() - DMA buffer request_update callback
276  * @buffer: The buffer which to request an update
277  *
278  * Should be used as the iio_dma_buffer_request_update() callback for
279  * iio_buffer_access_ops struct for DMA buffers.
280  */
281 int iio_dma_buffer_request_update(struct iio_buffer *buffer)
282 {
283         struct iio_dma_buffer_queue *queue = iio_buffer_to_queue(buffer);
284         struct iio_dma_buffer_block *block;
285         bool try_reuse = false;
286         size_t size;
287         int ret = 0;
288         int i;
289
290         /*
291          * Split the buffer into two even parts. This is used as a double
292          * buffering scheme with usually one block at a time being used by the
293          * DMA and the other one by the application.
294          */
295         size = DIV_ROUND_UP(queue->buffer.bytes_per_datum *
296                 queue->buffer.length, 2);
297
298         mutex_lock(&queue->lock);
299
300         /* Allocations are page aligned */
301         if (PAGE_ALIGN(queue->fileio.block_size) == PAGE_ALIGN(size))
302                 try_reuse = true;
303
304         queue->fileio.block_size = size;
305         queue->fileio.active_block = NULL;
306
307         spin_lock_irq(&queue->list_lock);
308         for (i = 0; i < ARRAY_SIZE(queue->fileio.blocks); i++) {
309                 block = queue->fileio.blocks[i];
310
311                 /* If we can't re-use it free it */
312                 if (block && (!iio_dma_block_reusable(block) || !try_reuse))
313                         block->state = IIO_BLOCK_STATE_DEAD;
314         }
315
316         /*
317          * At this point all blocks are either owned by the core or marked as
318          * dead. This means we can reset the lists without having to fear
319          * corrution.
320          */
321         INIT_LIST_HEAD(&queue->outgoing);
322         spin_unlock_irq(&queue->list_lock);
323
324         INIT_LIST_HEAD(&queue->incoming);
325
326         for (i = 0; i < ARRAY_SIZE(queue->fileio.blocks); i++) {
327                 if (queue->fileio.blocks[i]) {
328                         block = queue->fileio.blocks[i];
329                         if (block->state == IIO_BLOCK_STATE_DEAD) {
330                                 /* Could not reuse it */
331                                 iio_buffer_block_put(block);
332                                 block = NULL;
333                         } else {
334                                 block->size = size;
335                         }
336                 } else {
337                         block = NULL;
338                 }
339
340                 if (!block) {
341                         block = iio_dma_buffer_alloc_block(queue, size);
342                         if (!block) {
343                                 ret = -ENOMEM;
344                                 goto out_unlock;
345                         }
346                         queue->fileio.blocks[i] = block;
347                 }
348
349                 block->state = IIO_BLOCK_STATE_QUEUED;
350                 list_add_tail(&block->head, &queue->incoming);
351         }
352
353 out_unlock:
354         mutex_unlock(&queue->lock);
355
356         return ret;
357 }
358 EXPORT_SYMBOL_GPL(iio_dma_buffer_request_update);
359
360 static void iio_dma_buffer_submit_block(struct iio_dma_buffer_queue *queue,
361         struct iio_dma_buffer_block *block)
362 {
363         int ret;
364
365         /*
366          * If the hardware has already been removed we put the block into
367          * limbo. It will neither be on the incoming nor outgoing list, nor will
368          * it ever complete. It will just wait to be freed eventually.
369          */
370         if (!queue->ops)
371                 return;
372
373         block->state = IIO_BLOCK_STATE_ACTIVE;
374         iio_buffer_block_get(block);
375         ret = queue->ops->submit(queue, block);
376         if (ret) {
377                 /*
378                  * This is a bit of a problem and there is not much we can do
379                  * other then wait for the buffer to be disabled and re-enabled
380                  * and try again. But it should not really happen unless we run
381                  * out of memory or something similar.
382                  *
383                  * TODO: Implement support in the IIO core to allow buffers to
384                  * notify consumers that something went wrong and the buffer
385                  * should be disabled.
386                  */
387                 iio_buffer_block_put(block);
388         }
389 }
390
391 /**
392  * iio_dma_buffer_enable() - Enable DMA buffer
393  * @buffer: IIO buffer to enable
394  * @indio_dev: IIO device the buffer is attached to
395  *
396  * Needs to be called when the device that the buffer is attached to starts
397  * sampling. Typically should be the iio_buffer_access_ops enable callback.
398  *
399  * This will allocate the DMA buffers and start the DMA transfers.
400  */
401 int iio_dma_buffer_enable(struct iio_buffer *buffer,
402         struct iio_dev *indio_dev)
403 {
404         struct iio_dma_buffer_queue *queue = iio_buffer_to_queue(buffer);
405         struct iio_dma_buffer_block *block, *_block;
406
407         mutex_lock(&queue->lock);
408         queue->active = true;
409         list_for_each_entry_safe(block, _block, &queue->incoming, head) {
410                 list_del(&block->head);
411                 iio_dma_buffer_submit_block(queue, block);
412         }
413         mutex_unlock(&queue->lock);
414
415         return 0;
416 }
417 EXPORT_SYMBOL_GPL(iio_dma_buffer_enable);
418
419 /**
420  * iio_dma_buffer_disable() - Disable DMA buffer
421  * @buffer: IIO DMA buffer to disable
422  * @indio_dev: IIO device the buffer is attached to
423  *
424  * Needs to be called when the device that the buffer is attached to stops
425  * sampling. Typically should be the iio_buffer_access_ops disable callback.
426  */
427 int iio_dma_buffer_disable(struct iio_buffer *buffer,
428         struct iio_dev *indio_dev)
429 {
430         struct iio_dma_buffer_queue *queue = iio_buffer_to_queue(buffer);
431
432         mutex_lock(&queue->lock);
433         queue->active = false;
434
435         if (queue->ops && queue->ops->abort)
436                 queue->ops->abort(queue);
437         mutex_unlock(&queue->lock);
438
439         return 0;
440 }
441 EXPORT_SYMBOL_GPL(iio_dma_buffer_disable);
442
443 static void iio_dma_buffer_enqueue(struct iio_dma_buffer_queue *queue,
444         struct iio_dma_buffer_block *block)
445 {
446         if (block->state == IIO_BLOCK_STATE_DEAD) {
447                 iio_buffer_block_put(block);
448         } else if (queue->active) {
449                 iio_dma_buffer_submit_block(queue, block);
450         } else {
451                 block->state = IIO_BLOCK_STATE_QUEUED;
452                 list_add_tail(&block->head, &queue->incoming);
453         }
454 }
455
456 static struct iio_dma_buffer_block *iio_dma_buffer_dequeue(
457         struct iio_dma_buffer_queue *queue)
458 {
459         struct iio_dma_buffer_block *block;
460
461         spin_lock_irq(&queue->list_lock);
462         block = list_first_entry_or_null(&queue->outgoing, struct
463                 iio_dma_buffer_block, head);
464         if (block != NULL) {
465                 list_del(&block->head);
466                 block->state = IIO_BLOCK_STATE_DEQUEUED;
467         }
468         spin_unlock_irq(&queue->list_lock);
469
470         return block;
471 }
472
473 /**
474  * iio_dma_buffer_read() - DMA buffer read callback
475  * @buffer: Buffer to read form
476  * @n: Number of bytes to read
477  * @user_buffer: Userspace buffer to copy the data to
478  *
479  * Should be used as the read_first_n callback for iio_buffer_access_ops
480  * struct for DMA buffers.
481  */
482 int iio_dma_buffer_read(struct iio_buffer *buffer, size_t n,
483         char __user *user_buffer)
484 {
485         struct iio_dma_buffer_queue *queue = iio_buffer_to_queue(buffer);
486         struct iio_dma_buffer_block *block;
487         int ret;
488
489         if (n < buffer->bytes_per_datum)
490                 return -EINVAL;
491
492         mutex_lock(&queue->lock);
493
494         if (!queue->fileio.active_block) {
495                 block = iio_dma_buffer_dequeue(queue);
496                 if (block == NULL) {
497                         ret = 0;
498                         goto out_unlock;
499                 }
500                 queue->fileio.pos = 0;
501                 queue->fileio.active_block = block;
502         } else {
503                 block = queue->fileio.active_block;
504         }
505
506         n = rounddown(n, buffer->bytes_per_datum);
507         if (n > block->bytes_used - queue->fileio.pos)
508                 n = block->bytes_used - queue->fileio.pos;
509
510         if (copy_to_user(user_buffer, block->vaddr + queue->fileio.pos, n)) {
511                 ret = -EFAULT;
512                 goto out_unlock;
513         }
514
515         queue->fileio.pos += n;
516
517         if (queue->fileio.pos == block->bytes_used) {
518                 queue->fileio.active_block = NULL;
519                 iio_dma_buffer_enqueue(queue, block);
520         }
521
522         ret = n;
523
524 out_unlock:
525         mutex_unlock(&queue->lock);
526
527         return ret;
528 }
529 EXPORT_SYMBOL_GPL(iio_dma_buffer_read);
530
531 /**
532  * iio_dma_buffer_data_available() - DMA buffer data_available callback
533  * @buf: Buffer to check for data availability
534  *
535  * Should be used as the data_available callback for iio_buffer_access_ops
536  * struct for DMA buffers.
537  */
538 size_t iio_dma_buffer_data_available(struct iio_buffer *buf)
539 {
540         struct iio_dma_buffer_queue *queue = iio_buffer_to_queue(buf);
541         struct iio_dma_buffer_block *block;
542         size_t data_available = 0;
543
544         /*
545          * For counting the available bytes we'll use the size of the block not
546          * the number of actual bytes available in the block. Otherwise it is
547          * possible that we end up with a value that is lower than the watermark
548          * but won't increase since all blocks are in use.
549          */
550
551         mutex_lock(&queue->lock);
552         if (queue->fileio.active_block)
553                 data_available += queue->fileio.active_block->size;
554
555         spin_lock_irq(&queue->list_lock);
556         list_for_each_entry(block, &queue->outgoing, head)
557                 data_available += block->size;
558         spin_unlock_irq(&queue->list_lock);
559         mutex_unlock(&queue->lock);
560
561         return data_available;
562 }
563 EXPORT_SYMBOL_GPL(iio_dma_buffer_data_available);
564
565 /**
566  * iio_dma_buffer_set_bytes_per_datum() - DMA buffer set_bytes_per_datum callback
567  * @buffer: Buffer to set the bytes-per-datum for
568  * @bpd: The new bytes-per-datum value
569  *
570  * Should be used as the set_bytes_per_datum callback for iio_buffer_access_ops
571  * struct for DMA buffers.
572  */
573 int iio_dma_buffer_set_bytes_per_datum(struct iio_buffer *buffer, size_t bpd)
574 {
575         buffer->bytes_per_datum = bpd;
576
577         return 0;
578 }
579 EXPORT_SYMBOL_GPL(iio_dma_buffer_set_bytes_per_datum);
580
581 /**
582  * iio_dma_buffer_set_length - DMA buffer set_length callback
583  * @buffer: Buffer to set the length for
584  * @length: The new buffer length
585  *
586  * Should be used as the set_length callback for iio_buffer_access_ops
587  * struct for DMA buffers.
588  */
589 int iio_dma_buffer_set_length(struct iio_buffer *buffer, int length)
590 {
591         /* Avoid an invalid state */
592         if (length < 2)
593                 length = 2;
594         buffer->length = length;
595         buffer->watermark = length / 2;
596
597         return 0;
598 }
599 EXPORT_SYMBOL_GPL(iio_dma_buffer_set_length);
600
601 /**
602  * iio_dma_buffer_init() - Initialize DMA buffer queue
603  * @queue: Buffer to initialize
604  * @dev: DMA device
605  * @ops: DMA buffer queue callback operations
606  *
607  * The DMA device will be used by the queue to do DMA memory allocations. So it
608  * should refer to the device that will perform the DMA to ensure that
609  * allocations are done from a memory region that can be accessed by the device.
610  */
611 int iio_dma_buffer_init(struct iio_dma_buffer_queue *queue,
612         struct device *dev, const struct iio_dma_buffer_ops *ops)
613 {
614         iio_buffer_init(&queue->buffer);
615         queue->buffer.length = PAGE_SIZE;
616         queue->buffer.watermark = queue->buffer.length / 2;
617         queue->dev = dev;
618         queue->ops = ops;
619
620         INIT_LIST_HEAD(&queue->incoming);
621         INIT_LIST_HEAD(&queue->outgoing);
622
623         mutex_init(&queue->lock);
624         spin_lock_init(&queue->list_lock);
625
626         return 0;
627 }
628 EXPORT_SYMBOL_GPL(iio_dma_buffer_init);
629
630 /**
631  * iio_dma_buffer_exit() - Cleanup DMA buffer queue
632  * @queue: Buffer to cleanup
633  *
634  * After this function has completed it is safe to free any resources that are
635  * associated with the buffer and are accessed inside the callback operations.
636  */
637 void iio_dma_buffer_exit(struct iio_dma_buffer_queue *queue)
638 {
639         unsigned int i;
640
641         mutex_lock(&queue->lock);
642
643         spin_lock_irq(&queue->list_lock);
644         for (i = 0; i < ARRAY_SIZE(queue->fileio.blocks); i++) {
645                 if (!queue->fileio.blocks[i])
646                         continue;
647                 queue->fileio.blocks[i]->state = IIO_BLOCK_STATE_DEAD;
648         }
649         INIT_LIST_HEAD(&queue->outgoing);
650         spin_unlock_irq(&queue->list_lock);
651
652         INIT_LIST_HEAD(&queue->incoming);
653
654         for (i = 0; i < ARRAY_SIZE(queue->fileio.blocks); i++) {
655                 if (!queue->fileio.blocks[i])
656                         continue;
657                 iio_buffer_block_put(queue->fileio.blocks[i]);
658                 queue->fileio.blocks[i] = NULL;
659         }
660         queue->fileio.active_block = NULL;
661         queue->ops = NULL;
662
663         mutex_unlock(&queue->lock);
664 }
665 EXPORT_SYMBOL_GPL(iio_dma_buffer_exit);
666
667 /**
668  * iio_dma_buffer_release() - Release final buffer resources
669  * @queue: Buffer to release
670  *
671  * Frees resources that can't yet be freed in iio_dma_buffer_exit(). Should be
672  * called in the buffers release callback implementation right before freeing
673  * the memory associated with the buffer.
674  */
675 void iio_dma_buffer_release(struct iio_dma_buffer_queue *queue)
676 {
677         mutex_destroy(&queue->lock);
678 }
679 EXPORT_SYMBOL_GPL(iio_dma_buffer_release);
680
681 MODULE_AUTHOR("Lars-Peter Clausen <lars@metafoo.de>");
682 MODULE_DESCRIPTION("DMA buffer for the IIO framework");
683 MODULE_LICENSE("GPL v2");