tjh.dev / kernel
Linux kernel mirror (for testing) git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel os linux
1
fork

Configure Feed

Select the types of activity you want to include in your feed.

iio: buffer-dma: Move exports into IIO_DMA_BUFFER namespace

Avoid unnecessary pollution of the global symbol namespace and move
global APIs into a specific namespace. Import that into the places that
use them

Signed-off-by: Nuno Sa <nuno.sa@analog.com>
Link: https://patch.msgid.link/20240726-dev-iio-dma-buf-mod-namespace-v1-1-8877cfe7f68e@analog.com
Signed-off-by: Jonathan Cameron <Jonathan.Cameron@huawei.com>

authored by

Nuno Sa and committed by
Jonathan Cameron 8cfb75d7 8293a60c

+19 -18
+18 -18
drivers/iio/buffer/industrialio-buffer-dma.c
··· 248 248 iio_dma_buffer_queue_wake(queue); 249 249 dma_fence_end_signalling(cookie); 250 250 } 251 - EXPORT_SYMBOL_GPL(iio_dma_buffer_block_done); 251 + EXPORT_SYMBOL_NS_GPL(iio_dma_buffer_block_done, IIO_DMA_BUFFER); 252 252 253 253 /** 254 254 * iio_dma_buffer_block_list_abort() - Indicate that a list block has been ··· 287 287 iio_dma_buffer_queue_wake(queue); 288 288 dma_fence_end_signalling(cookie); 289 289 } 290 - EXPORT_SYMBOL_GPL(iio_dma_buffer_block_list_abort); 290 + EXPORT_SYMBOL_NS_GPL(iio_dma_buffer_block_list_abort, IIO_DMA_BUFFER); 291 291 292 292 static bool iio_dma_block_reusable(struct iio_dma_buffer_block *block) 293 293 { ··· 420 420 421 421 return ret; 422 422 } 423 - EXPORT_SYMBOL_GPL(iio_dma_buffer_request_update); 423 + EXPORT_SYMBOL_NS_GPL(iio_dma_buffer_request_update, IIO_DMA_BUFFER); 424 424 425 425 static void iio_dma_buffer_fileio_free(struct iio_dma_buffer_queue *queue) 426 426 { ··· 506 506 507 507 return 0; 508 508 } 509 - EXPORT_SYMBOL_GPL(iio_dma_buffer_enable); 509 + EXPORT_SYMBOL_NS_GPL(iio_dma_buffer_enable, IIO_DMA_BUFFER); 510 510 511 511 /** 512 512 * iio_dma_buffer_disable() - Disable DMA buffer ··· 530 530 531 531 return 0; 532 532 } 533 - EXPORT_SYMBOL_GPL(iio_dma_buffer_disable); 533 + EXPORT_SYMBOL_NS_GPL(iio_dma_buffer_disable, IIO_DMA_BUFFER); 534 534 535 535 static void iio_dma_buffer_enqueue(struct iio_dma_buffer_queue *queue, 536 536 struct iio_dma_buffer_block *block) ··· 636 636 { 637 637 return iio_dma_buffer_io(buffer, n, user_buffer, false); 638 638 } 639 - EXPORT_SYMBOL_GPL(iio_dma_buffer_read); 639 + EXPORT_SYMBOL_NS_GPL(iio_dma_buffer_read, IIO_DMA_BUFFER); 640 640 641 641 /** 642 642 * iio_dma_buffer_write() - DMA buffer write callback ··· 653 653 return iio_dma_buffer_io(buffer, n, 654 654 (__force __user char *)user_buffer, true); 655 655 } 656 - EXPORT_SYMBOL_GPL(iio_dma_buffer_write); 656 + EXPORT_SYMBOL_NS_GPL(iio_dma_buffer_write, IIO_DMA_BUFFER); 657 657 658 658 /** 659 659 * iio_dma_buffer_usage() - DMA buffer data_available and ··· 696 696 697 697 return data_available; 698 698 } 699 - EXPORT_SYMBOL_GPL(iio_dma_buffer_usage); 699 + EXPORT_SYMBOL_NS_GPL(iio_dma_buffer_usage, IIO_DMA_BUFFER); 700 700 701 701 struct iio_dma_buffer_block * 702 702 iio_dma_buffer_attach_dmabuf(struct iio_buffer *buffer, ··· 723 723 724 724 return block; 725 725 } 726 - EXPORT_SYMBOL_GPL(iio_dma_buffer_attach_dmabuf); 726 + EXPORT_SYMBOL_NS_GPL(iio_dma_buffer_attach_dmabuf, IIO_DMA_BUFFER); 727 727 728 728 void iio_dma_buffer_detach_dmabuf(struct iio_buffer *buffer, 729 729 struct iio_dma_buffer_block *block) ··· 731 731 block->state = IIO_BLOCK_STATE_DEAD; 732 732 iio_buffer_block_put_atomic(block); 733 733 } 734 - EXPORT_SYMBOL_GPL(iio_dma_buffer_detach_dmabuf); 734 + EXPORT_SYMBOL_NS_GPL(iio_dma_buffer_detach_dmabuf, IIO_DMA_BUFFER); 735 735 736 736 static int iio_dma_can_enqueue_block(struct iio_dma_buffer_block *block) 737 737 { ··· 784 784 785 785 return ret; 786 786 } 787 - EXPORT_SYMBOL_GPL(iio_dma_buffer_enqueue_dmabuf); 787 + EXPORT_SYMBOL_NS_GPL(iio_dma_buffer_enqueue_dmabuf, IIO_DMA_BUFFER); 788 788 789 789 void iio_dma_buffer_lock_queue(struct iio_buffer *buffer) 790 790 { ··· 792 792 793 793 mutex_lock(&queue->lock); 794 794 } 795 - EXPORT_SYMBOL_GPL(iio_dma_buffer_lock_queue); 795 + EXPORT_SYMBOL_NS_GPL(iio_dma_buffer_lock_queue, IIO_DMA_BUFFER); 796 796 797 797 void iio_dma_buffer_unlock_queue(struct iio_buffer *buffer) 798 798 { ··· 800 800 801 801 mutex_unlock(&queue->lock); 802 802 } 803 - EXPORT_SYMBOL_GPL(iio_dma_buffer_unlock_queue); 803 + EXPORT_SYMBOL_NS_GPL(iio_dma_buffer_unlock_queue, IIO_DMA_BUFFER); 804 804 805 805 /** 806 806 * iio_dma_buffer_set_bytes_per_datum() - DMA buffer set_bytes_per_datum callback ··· 816 816 817 817 return 0; 818 818 } 819 - EXPORT_SYMBOL_GPL(iio_dma_buffer_set_bytes_per_datum); 819 + EXPORT_SYMBOL_NS_GPL(iio_dma_buffer_set_bytes_per_datum, IIO_DMA_BUFFER); 820 820 821 821 /** 822 822 * iio_dma_buffer_set_length - DMA buffer set_length callback ··· 836 836 837 837 return 0; 838 838 } 839 - EXPORT_SYMBOL_GPL(iio_dma_buffer_set_length); 839 + EXPORT_SYMBOL_NS_GPL(iio_dma_buffer_set_length, IIO_DMA_BUFFER); 840 840 841 841 /** 842 842 * iio_dma_buffer_init() - Initialize DMA buffer queue ··· 864 864 865 865 return 0; 866 866 } 867 - EXPORT_SYMBOL_GPL(iio_dma_buffer_init); 867 + EXPORT_SYMBOL_NS_GPL(iio_dma_buffer_init, IIO_DMA_BUFFER); 868 868 869 869 /** 870 870 * iio_dma_buffer_exit() - Cleanup DMA buffer queue ··· 882 882 883 883 mutex_unlock(&queue->lock); 884 884 } 885 - EXPORT_SYMBOL_GPL(iio_dma_buffer_exit); 885 + EXPORT_SYMBOL_NS_GPL(iio_dma_buffer_exit, IIO_DMA_BUFFER); 886 886 887 887 /** 888 888 * iio_dma_buffer_release() - Release final buffer resources ··· 896 896 { 897 897 mutex_destroy(&queue->lock); 898 898 } 899 - EXPORT_SYMBOL_GPL(iio_dma_buffer_release); 899 + EXPORT_SYMBOL_NS_GPL(iio_dma_buffer_release, IIO_DMA_BUFFER); 900 900 901 901 MODULE_AUTHOR("Lars-Peter Clausen <lars@metafoo.de>"); 902 902 MODULE_DESCRIPTION("DMA buffer for the IIO framework");
+1
drivers/iio/buffer/industrialio-buffer-dmaengine.c
··· 348 348 MODULE_AUTHOR("Lars-Peter Clausen <lars@metafoo.de>"); 349 349 MODULE_DESCRIPTION("DMA buffer for the IIO framework"); 350 350 MODULE_LICENSE("GPL"); 351 + MODULE_IMPORT_NS(IIO_DMA_BUFFER);