1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * Copyright (c) 2012 Analog Devices, Inc. 4 * Author: Lars-Peter Clausen <lars@metafoo.de> 5 */ 6 7 #include <linux/kernel.h> 8 #include <linux/export.h> 9 #include <linux/module.h> 10 #include <linux/iio/iio.h> 11 #include <linux/iio/buffer.h> 12 #include <linux/iio/kfifo_buf.h> 13 #include <linux/iio/triggered_buffer.h> 14 #include <linux/iio/trigger_consumer.h> 15 16 static const struct iio_buffer_setup_ops iio_triggered_buffer_setup_ops = { 17 .postenable = &iio_triggered_buffer_postenable, 18 .predisable = &iio_triggered_buffer_predisable, 19 }; 20 21 /** 22 * iio_triggered_buffer_setup() - Setup triggered buffer and pollfunc 23 * @indio_dev: IIO device structure 24 * @h: Function which will be used as pollfunc top half 25 * @thread: Function which will be used as pollfunc bottom half 26 * @setup_ops: Buffer setup functions to use for this device. 27 * If NULL the default setup functions for triggered 28 * buffers will be used. 29 * 30 * This function combines some common tasks which will normally be performed 31 * when setting up a triggered buffer. It will allocate the buffer and the 32 * pollfunc. 33 * 34 * Before calling this function the indio_dev structure should already be 35 * completely initialized, but not yet registered. In practice this means that 36 * this function should be called right before iio_device_register(). 37 * 38 * To free the resources allocated by this function call 39 * iio_triggered_buffer_cleanup(). 40 */ 41 int iio_triggered_buffer_setup(struct iio_dev *indio_dev, 42 irqreturn_t (*h)(int irq, void *p), 43 irqreturn_t (*thread)(int irq, void *p), 44 const struct iio_buffer_setup_ops *setup_ops) 45 { 46 struct iio_buffer *buffer; 47 int ret; 48 49 buffer = iio_kfifo_allocate(); 50 if (!buffer) { 51 ret = -ENOMEM; 52 goto error_ret; 53 } 54 55 iio_device_attach_buffer(indio_dev, buffer); 56 57 indio_dev->pollfunc = iio_alloc_pollfunc(h, 58 thread, 59 IRQF_ONESHOT, 60 indio_dev, 61 "%s_consumer%d", 62 indio_dev->name, 63 indio_dev->id); 64 if (indio_dev->pollfunc == NULL) { 65 ret = -ENOMEM; 66 goto error_kfifo_free; 67 } 68 69 /* Ring buffer functions - here trigger setup related */ 70 if (setup_ops) 71 indio_dev->setup_ops = setup_ops; 72 else 73 indio_dev->setup_ops = &iio_triggered_buffer_setup_ops; 74 75 /* Flag that polled ring buffering is possible */ 76 indio_dev->modes |= INDIO_BUFFER_TRIGGERED; 77 78 return 0; 79 80 error_kfifo_free: 81 iio_kfifo_free(indio_dev->buffer); 82 error_ret: 83 return ret; 84 } 85 EXPORT_SYMBOL(iio_triggered_buffer_setup); 86 87 /** 88 * iio_triggered_buffer_cleanup() - Free resources allocated by iio_triggered_buffer_setup() 89 * @indio_dev: IIO device structure 90 */ 91 void iio_triggered_buffer_cleanup(struct iio_dev *indio_dev) 92 { 93 iio_dealloc_pollfunc(indio_dev->pollfunc); 94 iio_kfifo_free(indio_dev->buffer); 95 } 96 EXPORT_SYMBOL(iio_triggered_buffer_cleanup); 97 98 static void devm_iio_triggered_buffer_clean(struct device *dev, void *res) 99 { 100 iio_triggered_buffer_cleanup(*(struct iio_dev **)res); 101 } 102 103 int devm_iio_triggered_buffer_setup(struct device *dev, 104 struct iio_dev *indio_dev, 105 irqreturn_t (*h)(int irq, void *p), 106 irqreturn_t (*thread)(int irq, void *p), 107 const struct iio_buffer_setup_ops *ops) 108 { 109 struct iio_dev **ptr; 110 int ret; 111 112 ptr = devres_alloc(devm_iio_triggered_buffer_clean, sizeof(*ptr), 113 GFP_KERNEL); 114 if (!ptr) 115 return -ENOMEM; 116 117 *ptr = indio_dev; 118 119 ret = iio_triggered_buffer_setup(indio_dev, h, thread, ops); 120 if (!ret) 121 devres_add(dev, ptr); 122 else 123 devres_free(ptr); 124 125 return ret; 126 } 127 EXPORT_SYMBOL_GPL(devm_iio_triggered_buffer_setup); 128 129 MODULE_AUTHOR("Lars-Peter Clausen <lars@metafoo.de>"); 130 MODULE_DESCRIPTION("IIO helper functions for setting up triggered buffers"); 131 MODULE_LICENSE("GPL"); 132