1 // SPDX-License-Identifier: GPL-2.0-only 2 /* The industrial I/O callback buffer 3 */ 4 5 #include <linux/kernel.h> 6 #include <linux/module.h> 7 #include <linux/slab.h> 8 #include <linux/err.h> 9 #include <linux/export.h> 10 #include <linux/iio/iio.h> 11 #include <linux/iio/buffer_impl.h> 12 #include <linux/iio/consumer.h> 13 14 struct iio_cb_buffer { 15 struct iio_buffer buffer; 16 int (*cb)(const void *data, void *private); 17 void *private; 18 struct iio_channel *channels; 19 struct iio_dev *indio_dev; 20 }; 21 22 static struct iio_cb_buffer *buffer_to_cb_buffer(struct iio_buffer *buffer) 23 { 24 return container_of(buffer, struct iio_cb_buffer, buffer); 25 } 26 27 static int iio_buffer_cb_store_to(struct iio_buffer *buffer, const void *data) 28 { 29 struct iio_cb_buffer *cb_buff = buffer_to_cb_buffer(buffer); 30 return cb_buff->cb(data, cb_buff->private); 31 } 32 33 static void iio_buffer_cb_release(struct iio_buffer *buffer) 34 { 35 struct iio_cb_buffer *cb_buff = buffer_to_cb_buffer(buffer); 36 37 bitmap_free(cb_buff->buffer.scan_mask); 38 kfree(cb_buff); 39 } 40 41 static const struct iio_buffer_access_funcs iio_cb_access = { 42 .store_to = &iio_buffer_cb_store_to, 43 .release = &iio_buffer_cb_release, 44 45 .modes = INDIO_BUFFER_SOFTWARE | INDIO_BUFFER_TRIGGERED, 46 }; 47 48 struct iio_cb_buffer *iio_channel_get_all_cb(struct device *dev, 49 int (*cb)(const void *data, 50 void *private), 51 void *private) 52 { 53 int ret; 54 struct iio_cb_buffer *cb_buff; 55 struct iio_channel *chan; 56 57 if (!cb) { 58 dev_err(dev, "Invalid arguments: A callback must be provided!\n"); 59 return ERR_PTR(-EINVAL); 60 } 61 62 cb_buff = kzalloc(sizeof(*cb_buff), GFP_KERNEL); 63 if (cb_buff == NULL) 64 return ERR_PTR(-ENOMEM); 65 66 iio_buffer_init(&cb_buff->buffer); 67 68 cb_buff->private = private; 69 cb_buff->cb = cb; 70 cb_buff->buffer.access = &iio_cb_access; 71 72 cb_buff->channels = iio_channel_get_all(dev); 73 if (IS_ERR(cb_buff->channels)) { 74 ret = PTR_ERR(cb_buff->channels); 75 goto error_free_cb_buff; 76 } 77 78 cb_buff->indio_dev = cb_buff->channels[0].indio_dev; 79 cb_buff->buffer.scan_mask = bitmap_zalloc(iio_get_masklength(cb_buff->indio_dev), 80 GFP_KERNEL); 81 if (cb_buff->buffer.scan_mask == NULL) { 82 ret = -ENOMEM; 83 goto error_release_channels; 84 } 85 chan = &cb_buff->channels[0]; 86 while (chan->indio_dev) { 87 if (chan->indio_dev != cb_buff->indio_dev) { 88 ret = -EINVAL; 89 goto error_free_scan_mask; 90 } 91 set_bit(chan->channel->scan_index, 92 cb_buff->buffer.scan_mask); 93 chan++; 94 } 95 96 return cb_buff; 97 98 error_free_scan_mask: 99 bitmap_free(cb_buff->buffer.scan_mask); 100 error_release_channels: 101 iio_channel_release_all(cb_buff->channels); 102 error_free_cb_buff: 103 kfree(cb_buff); 104 return ERR_PTR(ret); 105 } 106 EXPORT_SYMBOL_GPL(iio_channel_get_all_cb); 107 108 int iio_channel_cb_set_buffer_watermark(struct iio_cb_buffer *cb_buff, 109 size_t watermark) 110 { 111 if (!watermark) 112 return -EINVAL; 113 cb_buff->buffer.watermark = watermark; 114 115 return 0; 116 } 117 EXPORT_SYMBOL_GPL(iio_channel_cb_set_buffer_watermark); 118 119 int iio_channel_start_all_cb(struct iio_cb_buffer *cb_buff) 120 { 121 return iio_update_buffers(cb_buff->indio_dev, &cb_buff->buffer, 122 NULL); 123 } 124 EXPORT_SYMBOL_GPL(iio_channel_start_all_cb); 125 126 void iio_channel_stop_all_cb(struct iio_cb_buffer *cb_buff) 127 { 128 iio_update_buffers(cb_buff->indio_dev, NULL, &cb_buff->buffer); 129 } 130 EXPORT_SYMBOL_GPL(iio_channel_stop_all_cb); 131 132 void iio_channel_release_all_cb(struct iio_cb_buffer *cb_buff) 133 { 134 iio_channel_release_all(cb_buff->channels); 135 iio_buffer_put(&cb_buff->buffer); 136 } 137 EXPORT_SYMBOL_GPL(iio_channel_release_all_cb); 138 139 struct iio_channel 140 *iio_channel_cb_get_channels(const struct iio_cb_buffer *cb_buffer) 141 { 142 return cb_buffer->channels; 143 } 144 EXPORT_SYMBOL_GPL(iio_channel_cb_get_channels); 145 146 struct iio_dev 147 *iio_channel_cb_get_iio_dev(const struct iio_cb_buffer *cb_buffer) 148 { 149 return cb_buffer->indio_dev; 150 } 151 EXPORT_SYMBOL_GPL(iio_channel_cb_get_iio_dev); 152 153 MODULE_AUTHOR("Jonathan Cameron <jic23@kernel.org>"); 154 MODULE_DESCRIPTION("Industrial I/O callback buffer"); 155 MODULE_LICENSE("GPL"); 156