Lines Matching +full:back +full:- +full:to +full:- +full:back
1 // SPDX-License-Identifier: GPL-2.0-only
3 * Framework to handle complex IIO aggregate devices.
5 * The typical architecture is to have one device as the frontend device which
7 * userspace interface is expected to be registers/managed by the frontend
8 * device which will callback into the backends when needed (to get/set some
11 * -------------------------------------------------------
12 * ------------------ | ------------ ------------ ------- FPGA|
13 * | ADC |------------------------| | ADC CORE |---------| DMA CORE |------| RAM | |
14 * | (Frontend/IIO) | Serial Data (eg: LVDS) | |(backend) |---------| |------| | |
15 * | |------------------------| ------------ ------------ ------- |
16 * ------------------ -------------------------------------------------------
19 * - Backends should register themselves with devm_iio_backend_register()
20 * - Frontend devices should get backends with devm_iio_backend_get()
22 * Also to note that the primary target for this framework are converters like
26 * struct begins to grow out of control, we can always refactor things so that
27 * the industrialio-backend.c is only left with the really generic stuff. Then,
30 * Copyright (C) 2023-2024 Analog Devices Inc.
32 #define dev_fmt(fmt) "iio-backend: " fmt
57 * that we need to free the buffer in a device managed action.
60 struct iio_backend *back; member
68 * Helper macros to call backend ops. Makes sure the option is supported.
70 #define iio_backend_check_op(back, op) ({ \ argument
71 struct iio_backend *____back = back; \
74 if (!____back->ops->op) \
75 ____ret = -EOPNOTSUPP; \
80 #define iio_backend_op_call(back, op, args...) ({ \ argument
81 struct iio_backend *__back = back; \
86 __ret = __back->ops->op(__back, ##args); \
91 #define iio_backend_ptr_op_call(back, op, args...) ({ \ argument
92 struct iio_backend *__back = back; \
100 ptr_err = __back->ops->op(__back, ##args); \
105 #define iio_backend_void_op_call(back, op, args...) { \ argument
106 struct iio_backend *__back = back; \
111 __back->ops->op(__back, ##args); \
115 * iio_backend_chan_enable - Enable a backend channel
116 * @back: Backend device
122 int iio_backend_chan_enable(struct iio_backend *back, unsigned int chan) in iio_backend_chan_enable() argument
124 return iio_backend_op_call(back, chan_enable, chan); in iio_backend_chan_enable()
129 * iio_backend_chan_disable - Disable a backend channel
130 * @back: Backend device
136 int iio_backend_chan_disable(struct iio_backend *back, unsigned int chan) in iio_backend_chan_disable() argument
138 return iio_backend_op_call(back, chan_disable, chan); in iio_backend_chan_disable()
142 static void __iio_backend_disable(void *back) in __iio_backend_disable() argument
144 iio_backend_void_op_call(back, disable); in __iio_backend_disable()
148 * devm_iio_backend_enable - Device managed backend enable
150 * @back: Backend device
155 int devm_iio_backend_enable(struct device *dev, struct iio_backend *back) in devm_iio_backend_enable() argument
159 ret = iio_backend_op_call(back, enable); in devm_iio_backend_enable()
163 return devm_add_action_or_reset(dev, __iio_backend_disable, back); in devm_iio_backend_enable()
168 * iio_backend_data_format_set - Configure the channel data format
169 * @back: Backend device
173 * Properly configure a channel with respect to the expected data format. A
179 int iio_backend_data_format_set(struct iio_backend *back, unsigned int chan, in iio_backend_data_format_set() argument
182 if (!data || data->type >= IIO_BACKEND_DATA_TYPE_MAX) in iio_backend_data_format_set()
183 return -EINVAL; in iio_backend_data_format_set()
185 return iio_backend_op_call(back, data_format_set, chan, data); in iio_backend_data_format_set()
193 iio_backend_void_op_call(pair->back, free_buffer, pair->buffer); in iio_backend_free_buffer()
197 * devm_iio_backend_request_buffer - Device managed buffer request
199 * @back: Backend device
203 * INDIO_BUFFER_HARDWARE) is up to the backend to decide. This is because,
212 struct iio_backend *back, in devm_iio_backend_request_buffer() argument
220 return -ENOMEM; in devm_iio_backend_request_buffer()
222 buffer = iio_backend_ptr_op_call(back, request_buffer, indio_dev); in devm_iio_backend_request_buffer()
227 pair->back = back; in devm_iio_backend_request_buffer()
228 pair->buffer = buffer; in devm_iio_backend_request_buffer()
236 struct iio_backend *back = arg; in iio_backend_release() local
238 module_put(back->owner); in iio_backend_release()
241 static int __devm_iio_backend_get(struct device *dev, struct iio_backend *back) in __devm_iio_backend_get() argument
252 if (!try_module_get(back->owner)) in __devm_iio_backend_get()
253 return dev_err_probe(dev, -ENODEV, in __devm_iio_backend_get()
256 ret = devm_add_action_or_reset(dev, iio_backend_release, back); in __devm_iio_backend_get()
260 link = device_link_add(dev, back->dev, DL_FLAG_AUTOREMOVE_CONSUMER); in __devm_iio_backend_get()
262 return dev_err_probe(dev, -EINVAL, in __devm_iio_backend_get()
263 "Could not link to supplier(%s)\n", in __devm_iio_backend_get()
264 dev_name(back->dev)); in __devm_iio_backend_get()
266 dev_dbg(dev, "Found backend(%s) device\n", dev_name(back->dev)); in __devm_iio_backend_get()
272 * devm_iio_backend_get - Device managed backend device get
284 struct iio_backend *back; in devm_iio_backend_get() local
289 ret = device_property_match_string(dev, "io-backend-names", in devm_iio_backend_get()
298 fwnode = fwnode_find_reference(dev_fwnode(dev), "io-backends", index); in devm_iio_backend_get()
306 list_for_each_entry(back, &iio_back_list, entry) { in devm_iio_backend_get()
307 if (!device_match_fwnode(back->dev, fwnode)) in devm_iio_backend_get()
311 ret = __devm_iio_backend_get(dev, back); in devm_iio_backend_get()
315 return back; in devm_iio_backend_get()
319 return ERR_PTR(-EPROBE_DEFER); in devm_iio_backend_get()
324 * __devm_iio_backend_get_from_fwnode_lookup - Device managed fwnode backend device get
330 * user of this framework to break it's DT ABI.
339 struct iio_backend *back; in __devm_iio_backend_get_from_fwnode_lookup() local
343 list_for_each_entry(back, &iio_back_list, entry) { in __devm_iio_backend_get_from_fwnode_lookup()
344 if (!device_match_fwnode(back->dev, fwnode)) in __devm_iio_backend_get_from_fwnode_lookup()
347 ret = __devm_iio_backend_get(dev, back); in __devm_iio_backend_get_from_fwnode_lookup()
351 return back; in __devm_iio_backend_get_from_fwnode_lookup()
354 return ERR_PTR(-EPROBE_DEFER); in __devm_iio_backend_get_from_fwnode_lookup()
359 * iio_backend_get_priv - Get driver private data
360 * @back: Backend device
362 void *iio_backend_get_priv(const struct iio_backend *back) in iio_backend_get_priv() argument
364 return back->priv; in iio_backend_get_priv()
370 struct iio_backend *back = arg; in iio_backend_unregister() local
373 list_del(&back->entry); in iio_backend_unregister()
377 * devm_iio_backend_register - Device managed backend device register
382 * @ops is mandatory. Not providing it results in -EINVAL.
390 struct iio_backend *back; in devm_iio_backend_register() local
393 return dev_err_probe(dev, -EINVAL, "No backend ops given\n"); in devm_iio_backend_register()
401 back = devm_kzalloc(dev, sizeof(*back), GFP_KERNEL); in devm_iio_backend_register()
402 if (!back) in devm_iio_backend_register()
403 return -ENOMEM; in devm_iio_backend_register()
405 back->ops = ops; in devm_iio_backend_register()
406 back->owner = dev->driver->owner; in devm_iio_backend_register()
407 back->dev = dev; in devm_iio_backend_register()
408 back->priv = priv; in devm_iio_backend_register()
410 list_add(&back->entry, &iio_back_list); in devm_iio_backend_register()
412 return devm_add_action_or_reset(dev, iio_backend_unregister, back); in devm_iio_backend_register()
417 MODULE_DESCRIPTION("Framework to handle complex IIO aggregate devices");