iio/buffer/industrialio-buffer-cb.c

0001 // SPDX-License-Identifier: GPL-2.0-only
0002 /* The industrial I/O callback buffer
0003  */
0004
0005 #include <linux/kernel.h>
0006 #include <linux/module.h>
0007 #include <linux/slab.h>
0008 #include <linux/err.h>
0009 #include <linux/export.h>
0010 #include <linux/iio/iio.h>
0011 #include <linux/iio/buffer_impl.h>
0012 #include <linux/iio/consumer.h>
0013
0014 struct iio_cb_buffer {
0015     struct iio_buffer buffer;
0016     int (*cb)(const void *data, void *private);
0017     void *private;
0018     struct iio_channel *channels;
0019     struct iio_dev *indio_dev;
0020 };
0021
0022 static struct iio_cb_buffer *buffer_to_cb_buffer(struct iio_buffer *buffer)
0023 {
0024     return container_of(buffer, struct iio_cb_buffer, buffer);
0025 }
0026
0027 static int iio_buffer_cb_store_to(struct iio_buffer *buffer, const void *data)
0028 {
0029     struct iio_cb_buffer *cb_buff = buffer_to_cb_buffer(buffer);
0030     return cb_buff->cb(data, cb_buff->private);
0031 }
0032
0033 static void iio_buffer_cb_release(struct iio_buffer *buffer)
0034 {
0035     struct iio_cb_buffer *cb_buff = buffer_to_cb_buffer(buffer);
0036
0037     bitmap_free(cb_buff->buffer.scan_mask);
0038     kfree(cb_buff);
0039 }
0040
0041 static const struct iio_buffer_access_funcs iio_cb_access = {
0042     .store_to = &iio_buffer_cb_store_to,
0043     .release = &iio_buffer_cb_release,
0044
0045     .modes = INDIO_BUFFER_SOFTWARE | INDIO_BUFFER_TRIGGERED,
0046 };
0047
0048 struct iio_cb_buffer *iio_channel_get_all_cb(struct device *dev,
0049                          int (*cb)(const void *data,
0050                                void *private),
0051                          void *private)
0052 {
0053     int ret;
0054     struct iio_cb_buffer *cb_buff;
0055     struct iio_channel *chan;
0056
0057     if (!cb) {
0058         dev_err(dev, "Invalid arguments: A callback must be provided!\n");
0059         return ERR_PTR(-EINVAL);
0060     }
0061
0062     cb_buff = kzalloc(sizeof(*cb_buff), GFP_KERNEL);
0063     if (cb_buff == NULL)
0064         return ERR_PTR(-ENOMEM);
0065
0066     iio_buffer_init(&cb_buff->buffer);
0067
0068     cb_buff->private = private;
0069     cb_buff->cb = cb;
0070     cb_buff->buffer.access = &iio_cb_access;
0071     INIT_LIST_HEAD(&cb_buff->buffer.demux_list);
0072
0073     cb_buff->channels = iio_channel_get_all(dev);
0074     if (IS_ERR(cb_buff->channels)) {
0075         ret = PTR_ERR(cb_buff->channels);
0076         goto error_free_cb_buff;
0077     }
0078
0079     cb_buff->indio_dev = cb_buff->channels[0].indio_dev;
0080     cb_buff->buffer.scan_mask = bitmap_zalloc(cb_buff->indio_dev->masklength,
0081                           GFP_KERNEL);
0082     if (cb_buff->buffer.scan_mask == NULL) {
0083         ret = -ENOMEM;
0084         goto error_release_channels;
0085     }
0086     chan = &cb_buff->channels[0];
0087     while (chan->indio_dev) {
0088         if (chan->indio_dev != cb_buff->indio_dev) {
0089             ret = -EINVAL;
0090             goto error_free_scan_mask;
0091         }
0092         set_bit(chan->channel->scan_index,
0093             cb_buff->buffer.scan_mask);
0094         chan++;
0095     }
0096
0097     return cb_buff;
0098
0099 error_free_scan_mask:
0100     bitmap_free(cb_buff->buffer.scan_mask);
0101 error_release_channels:
0102     iio_channel_release_all(cb_buff->channels);
0103 error_free_cb_buff:
0104     kfree(cb_buff);
0105     return ERR_PTR(ret);
0106 }
0107 EXPORT_SYMBOL_GPL(iio_channel_get_all_cb);
0108
0109 int iio_channel_cb_set_buffer_watermark(struct iio_cb_buffer *cb_buff,
0110                     size_t watermark)
0111 {
0112     if (!watermark)
0113         return -EINVAL;
0114     cb_buff->buffer.watermark = watermark;
0115
0116     return 0;
0117 }
0118 EXPORT_SYMBOL_GPL(iio_channel_cb_set_buffer_watermark);
0119
0120 int iio_channel_start_all_cb(struct iio_cb_buffer *cb_buff)
0121 {
0122     return iio_update_buffers(cb_buff->indio_dev, &cb_buff->buffer,
0123                   NULL);
0124 }
0125 EXPORT_SYMBOL_GPL(iio_channel_start_all_cb);
0126
0127 void iio_channel_stop_all_cb(struct iio_cb_buffer *cb_buff)
0128 {
0129     iio_update_buffers(cb_buff->indio_dev, NULL, &cb_buff->buffer);
0130 }
0131 EXPORT_SYMBOL_GPL(iio_channel_stop_all_cb);
0132
0133 void iio_channel_release_all_cb(struct iio_cb_buffer *cb_buff)
0134 {
0135     iio_channel_release_all(cb_buff->channels);
0136     iio_buffer_put(&cb_buff->buffer);
0137 }
0138 EXPORT_SYMBOL_GPL(iio_channel_release_all_cb);
0139
0140 struct iio_channel
0141 *iio_channel_cb_get_channels(const struct iio_cb_buffer *cb_buffer)
0142 {
0143     return cb_buffer->channels;
0144 }
0145 EXPORT_SYMBOL_GPL(iio_channel_cb_get_channels);
0146
0147 struct iio_dev
0148 *iio_channel_cb_get_iio_dev(const struct iio_cb_buffer *cb_buffer)
0149 {
0150     return cb_buffer->indio_dev;
0151 }
0152 EXPORT_SYMBOL_GPL(iio_channel_cb_get_iio_dev);
0153
0154 MODULE_AUTHOR("Jonathan Cameron <jic23@kernel.org>");
0155 MODULE_DESCRIPTION("Industrial I/O callback buffer");
0156 MODULE_LICENSE("GPL");