1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * Copyright 2013-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/module.h> 10 #include <linux/device.h> 11 #include <linux/workqueue.h> 12 #include <linux/mutex.h> 13 #include <linux/sched.h> 14 #include <linux/poll.h> 15 #include <linux/iio/buffer.h> 16 #include <linux/iio/buffer_impl.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, EPOLLIN | EPOLLRDNORM); 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, EPOLLIN | EPOLLRDNORM); 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, unsigned 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"); 684