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