Lines Matching +full:on +full:- +full:device
1 // SPDX-License-Identifier: GPL-2.0-only
5 * The typical architecture is to have one device as the frontend device which
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()
24 * devices. On top of that, this is "generic" for all IIO which means any kind
25 * of device can make use of the framework. That said, If the iio_backend_ops
27 * the industrialio-backend.c is only left with the really generic stuff. Then,
28 * we can build on top of it depending on the needs.
30 * Copyright (C) 2023-2024 Analog Devices Inc.
32 #define dev_fmt(fmt) "iio-backend: " fmt
36 #include <linux/device.h>
53 struct device *frontend_dev;
54 struct device *dev;
69 * that we need to free the buffer in a device managed action.
86 if (!____back->ops->op) \
87 ____ret = -EOPNOTSUPP; \
98 __ret = __back->ops->op(__back, ##args); \
112 ptr_err = __back->ops->op(__back, ##args); \
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()
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()
162 ret = sscanf(buf, "%i %i", &back->cached_reg_addr, &val); in iio_backend_debugfs_write_reg()
169 back->cached_reg_addr, val, NULL); in iio_backend_debugfs_write_reg()
174 return -EINVAL; in iio_backend_debugfs_write_reg()
188 struct iio_backend *back = file->private_data; in iio_backend_debugfs_read_name()
192 len = scnprintf(name, sizeof(name), "%s\n", back->name); in iio_backend_debugfs_read_name()
203 * iio_backend_debugfs_add - Add debugfs interfaces for Backends
204 * @back: Backend device
205 * @indio_dev: IIO device
216 if (!back->ops->debugfs_reg_access && !back->name) in iio_backend_debugfs_add()
219 snprintf(name, sizeof(name), "backend%d", back->idx); in iio_backend_debugfs_add()
225 if (back->ops->debugfs_reg_access) in iio_backend_debugfs_add()
229 if (back->name) in iio_backend_debugfs_add()
236 * iio_backend_debugfs_print_chan_status - Print channel status
237 * @back: Backend device
243 * interface and "ask" the backend to dump more details on why a test tone might
247 * Number of copied bytes on success, negative error code on failure.
254 return -ENODEV; in iio_backend_debugfs_print_chan_status()
262 * iio_backend_chan_enable - Enable a backend channel
263 * @back: Backend device
267 * 0 on success, negative error number on failure.
276 * iio_backend_chan_disable - Disable a backend channel
277 * @back: Backend device
281 * 0 on success, negative error number on failure.
295 * iio_backend_disable - Backend disable
296 * @back: Backend device
305 * iio_backend_enable - Backend enable
306 * @back: Backend device
309 * 0 on success, negative error number on failure.
318 * devm_iio_backend_enable - Device managed backend enable
319 * @dev: Consumer device for the backend
320 * @back: Backend device
323 * 0 on success, negative error number on failure.
325 int devm_iio_backend_enable(struct device *dev, struct iio_backend *back) in devm_iio_backend_enable()
338 * iio_backend_data_format_set - Configure the channel data format
339 * @back: Backend device
347 * 0 on success, negative error number on failure.
352 if (!data || data->type >= IIO_BACKEND_DATA_TYPE_MAX) in iio_backend_data_format_set()
353 return -EINVAL; in iio_backend_data_format_set()
360 * iio_backend_data_source_set - Select data source
361 * @back: Backend device
369 * 0 on success, negative error number on failure.
375 return -EINVAL; in iio_backend_data_source_set()
382 * iio_backend_set_sampling_freq - Set channel sampling rate
383 * @back: Backend device
388 * 0 on success, negative error number on failure.
398 * iio_backend_test_pattern_set - Configure a test pattern
399 * @back: Backend device
403 * Configure a test pattern on the backend. This is typically used for
404 * calibrating the timings on the data digital interface.
407 * 0 on success, negative error number on failure.
414 return -EINVAL; in iio_backend_test_pattern_set()
421 * iio_backend_chan_status - Get the channel status
422 * @back: Backend device
430 * 0 on success, negative error number on failure.
440 * iio_backend_iodelay_set - Set digital I/O delay
441 * @back: Backend device
445 * Controls delays on sending/receiving data. One usecase for this is to
450 * calibration points on the frontend device) and call this API.
453 * 0 on success, negative error number on failure.
463 * iio_backend_data_sample_trigger - Control when to sample data
464 * @back: Backend device
471 * 0 on success, negative error number on failure.
477 return -EINVAL; in iio_backend_data_sample_trigger()
487 iio_backend_void_op_call(pair->back, free_buffer, pair->buffer); in iio_backend_free_buffer()
491 * devm_iio_backend_request_buffer - Device managed buffer request
492 * @dev: Consumer device for the backend
493 * @back: Backend device
494 * @indio_dev: IIO device
500 * The backend .free_buffer() hooks is automatically called on @dev detach.
503 * 0 on success, negative error number on failure.
505 int devm_iio_backend_request_buffer(struct device *dev, in devm_iio_backend_request_buffer()
514 return -ENOMEM; in devm_iio_backend_request_buffer()
521 pair->back = back; in devm_iio_backend_request_buffer()
522 pair->buffer = buffer; in devm_iio_backend_request_buffer()
529 * iio_backend_read_raw - Read a channel attribute from a backend device.
530 * @back: Backend device
537 * 0 on success, negative error number on failure.
547 static struct iio_backend *iio_backend_from_indio_dev_parent(const struct device *dev) in iio_backend_from_indio_dev_parent()
549 struct iio_backend *back = ERR_PTR(-ENODEV), *iter; in iio_backend_from_indio_dev_parent()
560 if (dev == iter->frontend_dev) { in iio_backend_from_indio_dev_parent()
564 return ERR_PTR(-ENODEV); in iio_backend_from_indio_dev_parent()
575 * iio_backend_ext_info_get - IIO ext_info read callback
576 * @indio_dev: IIO device
587 * Number of bytes written to buf, negative error number on failure.
601 back = iio_backend_from_indio_dev_parent(indio_dev->dev.parent); in iio_backend_ext_info_get()
610 * iio_backend_ext_info_set - IIO ext_info write callback
611 * @indio_dev: IIO device
623 * Buffer length on success, negative error number on failure.
631 back = iio_backend_from_indio_dev_parent(indio_dev->dev.parent); in iio_backend_ext_info_set()
640 * iio_backend_extend_chan_spec - Extend an IIO channel
641 * @back: Backend device
648 * 0 on success, negative error number on failure.
653 const struct iio_chan_spec_ext_info *frontend_ext_info = chan->ext_info; in iio_backend_extend_chan_spec()
665 if (frontend_ext_info && chan->ext_info != frontend_ext_info) in iio_backend_extend_chan_spec()
666 return -EOPNOTSUPP; in iio_backend_extend_chan_spec()
667 if (!chan->ext_info) in iio_backend_extend_chan_spec()
671 for (back_ext_info = chan->ext_info; back_ext_info->name; back_ext_info++) { in iio_backend_extend_chan_spec()
672 if (back_ext_info->read != iio_backend_ext_info_get) in iio_backend_extend_chan_spec()
673 return -EINVAL; in iio_backend_extend_chan_spec()
674 if (back_ext_info->write != iio_backend_ext_info_set) in iio_backend_extend_chan_spec()
675 return -EINVAL; in iio_backend_extend_chan_spec()
686 module_put(back->owner); in iio_backend_release()
689 static int __devm_iio_backend_get(struct device *dev, struct iio_backend *back) in __devm_iio_backend_get()
700 if (!try_module_get(back->owner)) in __devm_iio_backend_get()
701 return dev_err_probe(dev, -ENODEV, in __devm_iio_backend_get()
708 link = device_link_add(dev, back->dev, DL_FLAG_AUTOREMOVE_CONSUMER); in __devm_iio_backend_get()
710 return dev_err_probe(dev, -EINVAL, in __devm_iio_backend_get()
712 dev_name(back->dev)); in __devm_iio_backend_get()
714 back->frontend_dev = dev; in __devm_iio_backend_get()
716 dev_dbg(dev, "Found backend(%s) device\n", dev_name(back->dev)); in __devm_iio_backend_get()
722 * iio_backend_ddr_enable - Enable interface DDR (Double Data Rate) mode
723 * @back: Backend device
729 * 0 on success, negative error number on failure.
738 * iio_backend_ddr_disable - Disable interface DDR (Double Data Rate) mode
739 * @back: Backend device
744 * 0 on success, negative error number on failure.
753 * iio_backend_data_stream_enable - Enable data stream
754 * @back: Backend device
759 * 0 on success, negative error number on failure.
768 * iio_backend_data_stream_disable - Disable data stream
769 * @back: Backend device
774 * 0 on success, negative error number on failure.
783 * iio_backend_data_transfer_addr - Set data address.
784 * @back: Backend device
791 * 0 on success, negative error number on failure.
799 static struct iio_backend *__devm_iio_backend_fwnode_get(struct device *dev, const char *name, in __devm_iio_backend_fwnode_get()
808 ret = device_property_match_string(dev, "io-backend-names", in __devm_iio_backend_fwnode_get()
817 fwnode_back = fwnode_find_reference(fwnode, "io-backends", index); in __devm_iio_backend_fwnode_get()
824 if (!device_match_fwnode(back->dev, fwnode_back)) in __devm_iio_backend_fwnode_get()
833 back->idx = index; in __devm_iio_backend_fwnode_get()
839 return ERR_PTR(-EPROBE_DEFER); in __devm_iio_backend_fwnode_get()
843 * devm_iio_backend_get - Device managed backend device get
844 * @dev: Consumer device for the backend
852 struct iio_backend *devm_iio_backend_get(struct device *dev, const char *name) in devm_iio_backend_get()
859 * devm_iio_backend_fwnode_get - Device managed backend firmware node get
860 * @dev: Consumer device for the backend
869 struct iio_backend *devm_iio_backend_fwnode_get(struct device *dev, in devm_iio_backend_fwnode_get()
878 * __devm_iio_backend_get_from_fwnode_lookup - Device managed fwnode backend device get
879 * @dev: Consumer device for the backend
880 * @fwnode: Firmware node of the backend device
882 * Search the backend list for a device matching @fwnode.
890 __devm_iio_backend_get_from_fwnode_lookup(struct device *dev, in __devm_iio_backend_get_from_fwnode_lookup()
898 if (!device_match_fwnode(back->dev, fwnode)) in __devm_iio_backend_get_from_fwnode_lookup()
908 return ERR_PTR(-EPROBE_DEFER); in __devm_iio_backend_get_from_fwnode_lookup()
913 * iio_backend_get_priv - Get driver private data
914 * @back: Backend device
918 return back->priv; in iio_backend_get_priv()
927 list_del(&back->entry); in iio_backend_unregister()
931 * devm_iio_backend_register - Device managed backend device register
932 * @dev: Backend device being registered
934 * @priv: Device private data
936 * @info is mandatory. Not providing it results in -EINVAL.
939 * 0 on success, negative error number on failure.
941 int devm_iio_backend_register(struct device *dev, in devm_iio_backend_register()
946 if (!info || !info->ops) in devm_iio_backend_register()
947 return dev_err_probe(dev, -EINVAL, "No backend ops given\n"); in devm_iio_backend_register()
950 * Through device_links, we guarantee that a frontend device cannot be in devm_iio_backend_register()
952 * the backend object lifetime with the device being passed since in devm_iio_backend_register()
957 return -ENOMEM; in devm_iio_backend_register()
959 back->ops = info->ops; in devm_iio_backend_register()
960 back->name = info->name; in devm_iio_backend_register()
961 back->owner = dev->driver->owner; in devm_iio_backend_register()
962 back->dev = dev; in devm_iio_backend_register()
963 back->priv = priv; in devm_iio_backend_register()
965 list_add(&back->entry, &iio_back_list); in devm_iio_backend_register()