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 */
 22struct iio_hw_consumer {
 23	struct list_head buffers;
 24	struct iio_channel *channels;
 25};
 26
 27struct 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
 34static 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
 40static 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
 47static const struct iio_buffer_access_funcs iio_hw_buf_access = {
 48	.release = &iio_hw_buf_release,
 49	.modes = INDIO_BUFFER_HARDWARE,
 50};
 51
 52static 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 */
 83struct 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
115err_put_buffers:
116	list_for_each_entry(buf, &hwc->buffers, head)
117		iio_buffer_put(&buf->buffer);
118	iio_channel_release_all(hwc->channels);
119err_free_hwc:
120	kfree(hwc);
121	return ERR_PTR(ret);
122}
123EXPORT_SYMBOL_GPL(iio_hw_consumer_alloc);
124
125/**
126 * iio_hw_consumer_free() - Free IIO hardware consumer
127 * @hwc: hw consumer to free.
128 */
129void 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}
138EXPORT_SYMBOL_GPL(iio_hw_consumer_free);
139
140static void devm_iio_hw_consumer_release(struct device *dev, void *res)
141{
142	iio_hw_consumer_free(*(struct iio_hw_consumer **)res);
143}
144
145static 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 */
168struct 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}
187EXPORT_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 */
196void 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}
204EXPORT_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 */
212int 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
225err_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}
230EXPORT_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 */
236void 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}
243EXPORT_SYMBOL_GPL(iio_hw_consumer_disable);
244
245MODULE_AUTHOR("Lars-Peter Clausen <lars@metafoo.de>");
246MODULE_DESCRIPTION("Hardware consumer buffer the IIO framework");
247MODULE_LICENSE("GPL v2");