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
60 * This index is relative to the frontend. Meaning that for
69 * that we need to free the buffer in a device managed action.
72 struct iio_backend *back; member
80 * Helper macros to call backend ops. Makes sure the option is supported.
82 #define iio_backend_check_op(back, op) ({ \ argument
83 struct iio_backend *____back = back; \
86 if (!____back->ops->op) \
87 ____ret = -EOPNOTSUPP; \
92 #define iio_backend_op_call(back, op, args...) ({ \ argument
93 struct iio_backend *__back = back; \
98 __ret = __back->ops->op(__back, ##args); \
103 #define iio_backend_ptr_op_call(back, op, args...) ({ \ argument
104 struct iio_backend *__back = back; \
112 ptr_err = __back->ops->op(__back, ##args); \
117 #define iio_backend_void_op_call(back, op, args...) { \ argument
118 struct iio_backend *__back = back; \
123 __back->ops->op(__back, ##args); \
125 dev_dbg(__back->dev, "Op(%s) not implemented\n",\
133 struct iio_backend *back = file->private_data; in iio_backend_debugfs_read_reg() local
138 ret = iio_backend_op_call(back, debugfs_reg_access, in iio_backend_debugfs_read_reg()
139 back->cached_reg_addr, 0, &val); in iio_backend_debugfs_read_reg()
152 struct iio_backend *back = file->private_data; in iio_backend_debugfs_write_reg() local
158 rc = simple_write_to_buffer(buf, sizeof(buf) - 1, ppos, userbuf, count); in iio_backend_debugfs_write_reg()
164 ret = sscanf(buf, "%i %i", &back->cached_reg_addr, &val); in iio_backend_debugfs_write_reg()
170 ret = iio_backend_op_call(back, debugfs_reg_access, in iio_backend_debugfs_write_reg()
171 back->cached_reg_addr, val, NULL); in iio_backend_debugfs_write_reg()
176 return -EINVAL; in iio_backend_debugfs_write_reg()
190 struct iio_backend *back = file->private_data; in iio_backend_debugfs_read_name() local
194 len = scnprintf(name, sizeof(name), "%s\n", back->name); in iio_backend_debugfs_read_name()
205 * iio_backend_debugfs_add - Add debugfs interfaces for Backends
206 * @back: Backend device
209 void iio_backend_debugfs_add(struct iio_backend *back, in iio_backend_debugfs_add() argument
218 if (!back->ops->debugfs_reg_access && !back->name) in iio_backend_debugfs_add()
221 snprintf(name, sizeof(name), "backend%d", back->idx); in iio_backend_debugfs_add()
227 if (back->ops->debugfs_reg_access) in iio_backend_debugfs_add()
228 debugfs_create_file("direct_reg_access", 0600, back_d, back, in iio_backend_debugfs_add()
231 if (back->name) in iio_backend_debugfs_add()
232 debugfs_create_file("name", 0400, back_d, back, in iio_backend_debugfs_add()
238 * iio_backend_debugfs_print_chan_status - Print channel status
239 * @back: Backend device
241 * @buf: Buffer where to print the status
245 * interface and "ask" the backend to dump more details on why a test tone might
251 ssize_t iio_backend_debugfs_print_chan_status(struct iio_backend *back, in iio_backend_debugfs_print_chan_status() argument
256 return -ENODEV; in iio_backend_debugfs_print_chan_status()
258 return iio_backend_op_call(back, debugfs_print_chan_status, chan, buf, in iio_backend_debugfs_print_chan_status()
264 * iio_backend_chan_enable - Enable a backend channel
265 * @back: Backend device
271 int iio_backend_chan_enable(struct iio_backend *back, unsigned int chan) in iio_backend_chan_enable() argument
273 return iio_backend_op_call(back, chan_enable, chan); in iio_backend_chan_enable()
278 * iio_backend_chan_disable - Disable a backend channel
279 * @back: Backend device
285 int iio_backend_chan_disable(struct iio_backend *back, unsigned int chan) in iio_backend_chan_disable() argument
287 return iio_backend_op_call(back, chan_disable, chan); in iio_backend_chan_disable()
291 static void __iio_backend_disable(void *back) in __iio_backend_disable() argument
293 iio_backend_void_op_call(back, disable); in __iio_backend_disable()
297 * iio_backend_disable - Backend disable
298 * @back: Backend device
300 void iio_backend_disable(struct iio_backend *back) in iio_backend_disable() argument
302 __iio_backend_disable(back); in iio_backend_disable()
307 * iio_backend_enable - Backend enable
308 * @back: Backend device
313 int iio_backend_enable(struct iio_backend *back) in iio_backend_enable() argument
315 return iio_backend_op_call(back, enable); in iio_backend_enable()
320 * devm_iio_backend_enable - Device managed backend enable
322 * @back: Backend device
327 int devm_iio_backend_enable(struct device *dev, struct iio_backend *back) in devm_iio_backend_enable() argument
331 ret = iio_backend_enable(back); in devm_iio_backend_enable()
335 return devm_add_action_or_reset(dev, __iio_backend_disable, back); in devm_iio_backend_enable()
340 * iio_backend_data_format_set - Configure the channel data format
341 * @back: Backend device
345 * Properly configure a channel with respect to the expected data format. A
351 int iio_backend_data_format_set(struct iio_backend *back, unsigned int chan, in iio_backend_data_format_set() argument
354 if (!data || data->type >= IIO_BACKEND_DATA_TYPE_MAX) in iio_backend_data_format_set()
355 return -EINVAL; in iio_backend_data_format_set()
357 return iio_backend_op_call(back, data_format_set, chan, data); in iio_backend_data_format_set()
362 * iio_backend_data_source_set - Select data source
363 * @back: Backend device
367 * A given backend may have different sources to stream/sync data. This allows
368 * to choose that source.
373 int iio_backend_data_source_set(struct iio_backend *back, unsigned int chan, in iio_backend_data_source_set() argument
377 return -EINVAL; in iio_backend_data_source_set()
379 return iio_backend_op_call(back, data_source_set, chan, data); in iio_backend_data_source_set()
384 * iio_backend_set_sampling_freq - Set channel sampling rate
385 * @back: Backend device
392 int iio_backend_set_sampling_freq(struct iio_backend *back, unsigned int chan, in iio_backend_set_sampling_freq() argument
395 return iio_backend_op_call(back, set_sample_rate, chan, sample_rate_hz); in iio_backend_set_sampling_freq()
400 * iio_backend_test_pattern_set - Configure a test pattern
401 * @back: Backend device
411 int iio_backend_test_pattern_set(struct iio_backend *back, in iio_backend_test_pattern_set() argument
416 return -EINVAL; in iio_backend_test_pattern_set()
418 return iio_backend_op_call(back, test_pattern_set, chan, pattern); in iio_backend_test_pattern_set()
423 * iio_backend_chan_status - Get the channel status
424 * @back: Backend device
428 * Get the current state of the backend channel. Typically used to check if
434 int iio_backend_chan_status(struct iio_backend *back, unsigned int chan, in iio_backend_chan_status() argument
437 return iio_backend_op_call(back, chan_status, chan, error); in iio_backend_chan_status()
442 * iio_backend_iodelay_set - Set digital I/O delay
443 * @back: Backend device
447 * Controls delays on sending/receiving data. One usecase for this is to
457 int iio_backend_iodelay_set(struct iio_backend *back, unsigned int lane, in iio_backend_iodelay_set() argument
460 return iio_backend_op_call(back, iodelay_set, lane, taps); in iio_backend_iodelay_set()
465 * iio_backend_data_sample_trigger - Control when to sample data
466 * @back: Backend device
469 * Mostly useful for input backends. Configures the backend for when to sample
475 int iio_backend_data_sample_trigger(struct iio_backend *back, in iio_backend_data_sample_trigger() argument
479 return -EINVAL; in iio_backend_data_sample_trigger()
481 return iio_backend_op_call(back, data_sample_trigger, trigger); in iio_backend_data_sample_trigger()
489 iio_backend_void_op_call(pair->back, free_buffer, pair->buffer); in iio_backend_free_buffer()
493 * devm_iio_backend_request_buffer - Device managed buffer request
495 * @back: Backend device
499 * INDIO_BUFFER_HARDWARE) is up to the backend to decide. This is because,
508 struct iio_backend *back, in devm_iio_backend_request_buffer() argument
516 return -ENOMEM; in devm_iio_backend_request_buffer()
518 buffer = iio_backend_ptr_op_call(back, request_buffer, indio_dev); in devm_iio_backend_request_buffer()
523 pair->back = back; in devm_iio_backend_request_buffer()
524 pair->buffer = buffer; in devm_iio_backend_request_buffer()
531 * iio_backend_read_raw - Read a channel attribute from a backend device.
532 * @back: Backend device
536 * @mask: Specify the attribute to return
541 int iio_backend_read_raw(struct iio_backend *back, in iio_backend_read_raw() argument
545 return iio_backend_op_call(back, read_raw, chan, val, val2, mask); in iio_backend_read_raw()
551 struct iio_backend *back = ERR_PTR(-ENODEV), *iter; in iio_backend_from_indio_dev_parent() local
555 * The reason is that we want to catch frontend devices which have more in iio_backend_from_indio_dev_parent()
557 * For those cases, frontends need to explicitly define in iio_backend_from_indio_dev_parent()
562 if (dev == iter->frontend_dev) { in iio_backend_from_indio_dev_parent()
563 if (!IS_ERR(back)) { in iio_backend_from_indio_dev_parent()
565 "Multiple backends! get_iio_backend() needs to be implemented"); in iio_backend_from_indio_dev_parent()
566 return ERR_PTR(-ENODEV); in iio_backend_from_indio_dev_parent()
569 back = iter; in iio_backend_from_indio_dev_parent()
573 return back; in iio_backend_from_indio_dev_parent()
577 * iio_backend_ext_info_get - IIO ext_info read callback
579 * @private: Data private to the driver
581 * @buf: Buffer where to place the attribute data
583 * This helper is intended to be used by backends that extend an IIO channel
585 * backends are not supposed to give their own callbacks (as they would not have
586 * a way to get the backend from indio_dev). This is the getter.
589 * Number of bytes written to buf, negative error number on failure.
594 struct iio_backend *back; in iio_backend_ext_info_get() local
603 back = iio_backend_from_indio_dev_parent(indio_dev->dev.parent); in iio_backend_ext_info_get()
604 if (IS_ERR(back)) in iio_backend_ext_info_get()
605 return PTR_ERR(back); in iio_backend_ext_info_get()
607 return iio_backend_op_call(back, ext_info_get, private, chan, buf); in iio_backend_ext_info_get()
612 * iio_backend_ext_info_set - IIO ext_info write callback
614 * @private: Data private to the driver
619 * This helper is intended to be used by backends that extend an IIO channel
621 * backends are not supposed to give their own callbacks (as they would not have
622 * a way to get the backend from indio_dev). This is the setter.
631 struct iio_backend *back; in iio_backend_ext_info_set() local
633 back = iio_backend_from_indio_dev_parent(indio_dev->dev.parent); in iio_backend_ext_info_set()
634 if (IS_ERR(back)) in iio_backend_ext_info_set()
635 return PTR_ERR(back); in iio_backend_ext_info_set()
637 return iio_backend_op_call(back, ext_info_set, private, chan, buf, len); in iio_backend_ext_info_set()
642 * iio_backend_interface_type_get - get the interface type used.
643 * @back: Backend device
649 int iio_backend_interface_type_get(struct iio_backend *back, in iio_backend_interface_type_get() argument
654 ret = iio_backend_op_call(back, interface_type_get, type); in iio_backend_interface_type_get()
659 return -EINVAL; in iio_backend_interface_type_get()
666 * iio_backend_data_size_set - set the data width/size in the data bus.
667 * @back: Backend device
671 * interface/data bus. Hence, the backend device needs to be aware of it so
677 int iio_backend_data_size_set(struct iio_backend *back, unsigned int size) in iio_backend_data_size_set() argument
680 return -EINVAL; in iio_backend_data_size_set()
682 return iio_backend_op_call(back, data_size_set, size); in iio_backend_data_size_set()
687 * iio_backend_oversampling_ratio_set - set the oversampling ratio
688 * @back: Backend device
689 * @ratio: The oversampling ratio - value 1 corresponds to no oversampling.
694 int iio_backend_oversampling_ratio_set(struct iio_backend *back, in iio_backend_oversampling_ratio_set() argument
697 return iio_backend_op_call(back, oversampling_ratio_set, ratio); in iio_backend_oversampling_ratio_set()
702 * iio_backend_extend_chan_spec - Extend an IIO channel
703 * @back: Backend device
712 int iio_backend_extend_chan_spec(struct iio_backend *back, in iio_backend_extend_chan_spec() argument
715 const struct iio_chan_spec_ext_info *frontend_ext_info = chan->ext_info; in iio_backend_extend_chan_spec()
719 ret = iio_backend_op_call(back, extend_chan_spec, chan); in iio_backend_extend_chan_spec()
723 * Let's keep things simple for now. Don't allow to overwrite the in iio_backend_extend_chan_spec()
727 if (frontend_ext_info && chan->ext_info != frontend_ext_info) in iio_backend_extend_chan_spec()
728 return -EOPNOTSUPP; in iio_backend_extend_chan_spec()
729 if (!chan->ext_info) in iio_backend_extend_chan_spec()
732 /* Don't allow backends to get creative and force their own handlers */ in iio_backend_extend_chan_spec()
733 for (back_ext_info = chan->ext_info; back_ext_info->name; back_ext_info++) { in iio_backend_extend_chan_spec()
734 if (back_ext_info->read != iio_backend_ext_info_get) in iio_backend_extend_chan_spec()
735 return -EINVAL; in iio_backend_extend_chan_spec()
736 if (back_ext_info->write != iio_backend_ext_info_set) in iio_backend_extend_chan_spec()
737 return -EINVAL; in iio_backend_extend_chan_spec()
746 struct iio_backend *back = arg; in iio_backend_release() local
748 module_put(back->owner); in iio_backend_release()
751 static int __devm_iio_backend_get(struct device *dev, struct iio_backend *back) in __devm_iio_backend_get() argument
762 if (!try_module_get(back->owner)) in __devm_iio_backend_get()
763 return dev_err_probe(dev, -ENODEV, in __devm_iio_backend_get()
766 ret = devm_add_action_or_reset(dev, iio_backend_release, back); in __devm_iio_backend_get()
770 link = device_link_add(dev, back->dev, DL_FLAG_AUTOREMOVE_CONSUMER); in __devm_iio_backend_get()
772 return dev_err_probe(dev, -EINVAL, in __devm_iio_backend_get()
773 "Could not link to supplier(%s)\n", in __devm_iio_backend_get()
774 dev_name(back->dev)); in __devm_iio_backend_get()
776 back->frontend_dev = dev; in __devm_iio_backend_get()
778 dev_dbg(dev, "Found backend(%s) device\n", dev_name(back->dev)); in __devm_iio_backend_get()
784 * iio_backend_ddr_enable - Enable interface DDR (Double Data Rate) mode
785 * @back: Backend device
793 int iio_backend_ddr_enable(struct iio_backend *back) in iio_backend_ddr_enable() argument
795 return iio_backend_op_call(back, ddr_enable); in iio_backend_ddr_enable()
800 * iio_backend_ddr_disable - Disable interface DDR (Double Data Rate) mode
801 * @back: Backend device
808 int iio_backend_ddr_disable(struct iio_backend *back) in iio_backend_ddr_disable() argument
810 return iio_backend_op_call(back, ddr_disable); in iio_backend_ddr_disable()
815 * iio_backend_data_stream_enable - Enable data stream
816 * @back: Backend device
823 int iio_backend_data_stream_enable(struct iio_backend *back) in iio_backend_data_stream_enable() argument
825 return iio_backend_op_call(back, data_stream_enable); in iio_backend_data_stream_enable()
830 * iio_backend_data_stream_disable - Disable data stream
831 * @back: Backend device
838 int iio_backend_data_stream_disable(struct iio_backend *back) in iio_backend_data_stream_disable() argument
840 return iio_backend_op_call(back, data_stream_disable); in iio_backend_data_stream_disable()
845 * iio_backend_data_transfer_addr - Set data address.
846 * @back: Backend device
849 * Some devices may need to inform the backend about an address
850 * where to read or write the data.
855 int iio_backend_data_transfer_addr(struct iio_backend *back, u32 address) in iio_backend_data_transfer_addr() argument
857 return iio_backend_op_call(back, data_transfer_addr, address); in iio_backend_data_transfer_addr()
865 struct iio_backend *back; in __devm_iio_backend_fwnode_get() local
870 ret = device_property_match_string(dev, "io-backend-names", in __devm_iio_backend_fwnode_get()
879 fwnode_back = fwnode_find_reference(fwnode, "io-backends", index); in __devm_iio_backend_fwnode_get()
885 list_for_each_entry(back, &iio_back_list, entry) { in __devm_iio_backend_fwnode_get()
886 if (!device_match_fwnode(back->dev, fwnode_back)) in __devm_iio_backend_fwnode_get()
890 ret = __devm_iio_backend_get(dev, back); in __devm_iio_backend_fwnode_get()
895 back->idx = index; in __devm_iio_backend_fwnode_get()
897 return back; in __devm_iio_backend_fwnode_get()
901 return ERR_PTR(-EPROBE_DEFER); in __devm_iio_backend_fwnode_get()
905 * devm_iio_backend_get - Device managed backend device get
921 * devm_iio_backend_fwnode_get - Device managed backend firmware node get
940 * __devm_iio_backend_get_from_fwnode_lookup - Device managed fwnode backend device get
946 * user of this framework to break it's DT ABI.
955 struct iio_backend *back; in __devm_iio_backend_get_from_fwnode_lookup() local
959 list_for_each_entry(back, &iio_back_list, entry) { in __devm_iio_backend_get_from_fwnode_lookup()
960 if (!device_match_fwnode(back->dev, fwnode)) in __devm_iio_backend_get_from_fwnode_lookup()
963 ret = __devm_iio_backend_get(dev, back); in __devm_iio_backend_get_from_fwnode_lookup()
967 return back; in __devm_iio_backend_get_from_fwnode_lookup()
970 return ERR_PTR(-EPROBE_DEFER); in __devm_iio_backend_get_from_fwnode_lookup()
975 * iio_backend_get_priv - Get driver private data
976 * @back: Backend device
978 void *iio_backend_get_priv(const struct iio_backend *back) in iio_backend_get_priv() argument
980 return back->priv; in iio_backend_get_priv()
986 struct iio_backend *back = arg; in iio_backend_unregister() local
989 list_del(&back->entry); in iio_backend_unregister()
993 * devm_iio_backend_register - Device managed backend device register
998 * @info is mandatory. Not providing it results in -EINVAL.
1006 struct iio_backend *back; in devm_iio_backend_register() local
1008 if (!info || !info->ops) in devm_iio_backend_register()
1009 return dev_err_probe(dev, -EINVAL, "No backend ops given\n"); in devm_iio_backend_register()
1017 back = devm_kzalloc(dev, sizeof(*back), GFP_KERNEL); in devm_iio_backend_register()
1018 if (!back) in devm_iio_backend_register()
1019 return -ENOMEM; in devm_iio_backend_register()
1021 back->ops = info->ops; in devm_iio_backend_register()
1022 back->name = info->name; in devm_iio_backend_register()
1023 back->owner = dev->driver->owner; in devm_iio_backend_register()
1024 back->dev = dev; in devm_iio_backend_register()
1025 back->priv = priv; in devm_iio_backend_register()
1027 list_add(&back->entry, &iio_back_list); in devm_iio_backend_register()
1029 return devm_add_action_or_reset(dev, iio_backend_unregister, back); in devm_iio_backend_register()
1034 MODULE_DESCRIPTION("Framework to handle complex IIO aggregate devices");