root/drivers/iio/buffer/industrialio-hw-consumer.c

DEFINITIONS

1. iio_buffer_to_hw_consumer_buffer
2. iio_hw_buf_release
3. iio_hw_consumer_get_buffer
4. iio_hw_consumer_alloc
5. iio_hw_consumer_free
6. devm_iio_hw_consumer_release
7. devm_iio_hw_consumer_match
8. devm_iio_hw_consumer_alloc
9. devm_iio_hw_consumer_free
10. iio_hw_consumer_enable
11. iio_hw_consumer_disable

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * Copyright 2017 Analog Devices Inc.
   4  *  Author: Lars-Peter Clausen <lars@metafoo.de>
   5  */
   6 
   7 #include <linux/err.h>
   8 #include <linux/export.h>
   9 #include <linux/slab.h>
  10 #include <linux/module.h>
  11 
  12 #include <linux/iio/iio.h>
  13 #include <linux/iio/consumer.h>
  14 #include <linux/iio/hw-consumer.h>
  15 #include <linux/iio/buffer_impl.h>
  16 
  17 /**
  18  * struct iio_hw_consumer - IIO hw consumer block
  19  * @buffers: hardware buffers list head.
  20  * @channels: IIO provider channels.
  21  */
  22 struct iio_hw_consumer {
  23         struct list_head buffers;
  24         struct iio_channel *channels;
  25 };
  26 
  27 struct hw_consumer_buffer {
  28         struct list_head head;
  29         struct iio_dev *indio_dev;
  30         struct iio_buffer buffer;
  31         long scan_mask[];
  32 };
  33 
  34 static struct hw_consumer_buffer *iio_buffer_to_hw_consumer_buffer(
  35         struct iio_buffer *buffer)
  36 {
  37         return container_of(buffer, struct hw_consumer_buffer, buffer);
  38 }
  39 
  40 static void iio_hw_buf_release(struct iio_buffer *buffer)
  41 {
  42         struct hw_consumer_buffer *hw_buf =
  43                 iio_buffer_to_hw_consumer_buffer(buffer);
  44         kfree(hw_buf);
  45 }
  46 
  47 static const struct iio_buffer_access_funcs iio_hw_buf_access = {
  48         .release = &iio_hw_buf_release,
  49         .modes = INDIO_BUFFER_HARDWARE,
  50 };
  51 
  52 static struct hw_consumer_buffer *iio_hw_consumer_get_buffer(
  53         struct iio_hw_consumer *hwc, struct iio_dev *indio_dev)
  54 {
  55         size_t mask_size = BITS_TO_LONGS(indio_dev->masklength) * sizeof(long);
  56         struct hw_consumer_buffer *buf;
  57 
  58         list_for_each_entry(buf, &hwc->buffers, head) {
  59                 if (buf->indio_dev == indio_dev)
  60                         return buf;
  61         }
  62 
  63         buf = kzalloc(sizeof(*buf) + mask_size, GFP_KERNEL);
  64         if (!buf)
  65                 return NULL;
  66 
  67         buf->buffer.access = &iio_hw_buf_access;
  68         buf->indio_dev = indio_dev;
  69         buf->buffer.scan_mask = buf->scan_mask;
  70 
  71         iio_buffer_init(&buf->buffer);
  72         list_add_tail(&buf->head, &hwc->buffers);
  73 
  74         return buf;
  75 }
  76 
  77 /**
  78  * iio_hw_consumer_alloc() - Allocate IIO hardware consumer
  79  * @dev: Pointer to consumer device.
  80  *
  81  * Returns a valid iio_hw_consumer on success or a ERR_PTR() on failure.
  82  */
  83 struct iio_hw_consumer *iio_hw_consumer_alloc(struct device *dev)
  84 {
  85         struct hw_consumer_buffer *buf;
  86         struct iio_hw_consumer *hwc;
  87         struct iio_channel *chan;
  88         int ret;
  89 
  90         hwc = kzalloc(sizeof(*hwc), GFP_KERNEL);
  91         if (!hwc)
  92                 return ERR_PTR(-ENOMEM);
  93 
  94         INIT_LIST_HEAD(&hwc->buffers);
  95 
  96         hwc->channels = iio_channel_get_all(dev);
  97         if (IS_ERR(hwc->channels)) {
  98                 ret = PTR_ERR(hwc->channels);
  99                 goto err_free_hwc;
 100         }
 101 
 102         chan = &hwc->channels[0];
 103         while (chan->indio_dev) {
 104                 buf = iio_hw_consumer_get_buffer(hwc, chan->indio_dev);
 105                 if (!buf) {
 106                         ret = -ENOMEM;
 107                         goto err_put_buffers;
 108                 }
 109                 set_bit(chan->channel->scan_index, buf->buffer.scan_mask);
 110                 chan++;
 111         }
 112 
 113         return hwc;
 114 
 115 err_put_buffers:
 116         list_for_each_entry(buf, &hwc->buffers, head)
 117                 iio_buffer_put(&buf->buffer);
 118         iio_channel_release_all(hwc->channels);
 119 err_free_hwc:
 120         kfree(hwc);
 121         return ERR_PTR(ret);
 122 }
 123 EXPORT_SYMBOL_GPL(iio_hw_consumer_alloc);
 124 
 125 /**
 126  * iio_hw_consumer_free() - Free IIO hardware consumer
 127  * @hwc: hw consumer to free.
 128  */
 129 void iio_hw_consumer_free(struct iio_hw_consumer *hwc)
 130 {
 131         struct hw_consumer_buffer *buf, *n;
 132 
 133         iio_channel_release_all(hwc->channels);
 134         list_for_each_entry_safe(buf, n, &hwc->buffers, head)
 135                 iio_buffer_put(&buf->buffer);
 136         kfree(hwc);
 137 }
 138 EXPORT_SYMBOL_GPL(iio_hw_consumer_free);
 139 
 140 static void devm_iio_hw_consumer_release(struct device *dev, void *res)
 141 {
 142         iio_hw_consumer_free(*(struct iio_hw_consumer **)res);
 143 }
 144 
 145 static int devm_iio_hw_consumer_match(struct device *dev, void *res, void *data)
 146 {
 147         struct iio_hw_consumer **r = res;
 148 
 149         if (!r || !*r) {
 150                 WARN_ON(!r || !*r);
 151                 return 0;
 152         }
 153         return *r == data;
 154 }
 155 
 156 /**
 157  * devm_iio_hw_consumer_alloc - Resource-managed iio_hw_consumer_alloc()
 158  * @dev: Pointer to consumer device.
 159  *
 160  * Managed iio_hw_consumer_alloc. iio_hw_consumer allocated with this function
 161  * is automatically freed on driver detach.
 162  *
 163  * If an iio_hw_consumer allocated with this function needs to be freed
 164  * separately, devm_iio_hw_consumer_free() must be used.
 165  *
 166  * returns pointer to allocated iio_hw_consumer on success, NULL on failure.
 167  */
 168 struct iio_hw_consumer *devm_iio_hw_consumer_alloc(struct device *dev)
 169 {
 170         struct iio_hw_consumer **ptr, *iio_hwc;
 171 
 172         ptr = devres_alloc(devm_iio_hw_consumer_release, sizeof(*ptr),
 173                            GFP_KERNEL);
 174         if (!ptr)
 175                 return NULL;
 176 
 177         iio_hwc = iio_hw_consumer_alloc(dev);
 178         if (IS_ERR(iio_hwc)) {
 179                 devres_free(ptr);
 180         } else {
 181                 *ptr = iio_hwc;
 182                 devres_add(dev, ptr);
 183         }
 184 
 185         return iio_hwc;
 186 }
 187 EXPORT_SYMBOL_GPL(devm_iio_hw_consumer_alloc);
 188 
 189 /**
 190  * devm_iio_hw_consumer_free - Resource-managed iio_hw_consumer_free()
 191  * @dev: Pointer to consumer device.
 192  * @hwc: iio_hw_consumer to free.
 193  *
 194  * Free iio_hw_consumer allocated with devm_iio_hw_consumer_alloc().
 195  */
 196 void devm_iio_hw_consumer_free(struct device *dev, struct iio_hw_consumer *hwc)
 197 {
 198         int rc;
 199 
 200         rc = devres_release(dev, devm_iio_hw_consumer_release,
 201                             devm_iio_hw_consumer_match, hwc);
 202         WARN_ON(rc);
 203 }
 204 EXPORT_SYMBOL_GPL(devm_iio_hw_consumer_free);
 205 
 206 /**
 207  * iio_hw_consumer_enable() - Enable IIO hardware consumer
 208  * @hwc: iio_hw_consumer to enable.
 209  *
 210  * Returns 0 on success.
 211  */
 212 int iio_hw_consumer_enable(struct iio_hw_consumer *hwc)
 213 {
 214         struct hw_consumer_buffer *buf;
 215         int ret;
 216 
 217         list_for_each_entry(buf, &hwc->buffers, head) {
 218                 ret = iio_update_buffers(buf->indio_dev, &buf->buffer, NULL);
 219                 if (ret)
 220                         goto err_disable_buffers;
 221         }
 222 
 223         return 0;
 224 
 225 err_disable_buffers:
 226         list_for_each_entry_continue_reverse(buf, &hwc->buffers, head)
 227                 iio_update_buffers(buf->indio_dev, NULL, &buf->buffer);
 228         return ret;
 229 }
 230 EXPORT_SYMBOL_GPL(iio_hw_consumer_enable);
 231 
 232 /**
 233  * iio_hw_consumer_disable() - Disable IIO hardware consumer
 234  * @hwc: iio_hw_consumer to disable.
 235  */
 236 void iio_hw_consumer_disable(struct iio_hw_consumer *hwc)
 237 {
 238         struct hw_consumer_buffer *buf;
 239 
 240         list_for_each_entry(buf, &hwc->buffers, head)
 241                 iio_update_buffers(buf->indio_dev, NULL, &buf->buffer);
 242 }
 243 EXPORT_SYMBOL_GPL(iio_hw_consumer_disable);
 244 
 245 MODULE_AUTHOR("Lars-Peter Clausen <lars@metafoo.de>");
 246 MODULE_DESCRIPTION("Hardware consumer buffer the IIO framework");
 247 MODULE_LICENSE("GPL v2");