xref: /linux/drivers/iio/industrialio-core.c (revision c4ec8dedca961db056ec85cb7ca8c9f7e2e92252)
1d2912cb1SThomas Gleixner // SPDX-License-Identifier: GPL-2.0-only
265659a8dSAndy Shevchenko /*
365659a8dSAndy Shevchenko  * The industrial I/O core
4a980e046SJonathan Cameron  *
5a980e046SJonathan Cameron  * Copyright (c) 2008 Jonathan Cameron
6a980e046SJonathan Cameron  *
7a980e046SJonathan Cameron  * Based on elements of hwmon and input subsystems.
8a980e046SJonathan Cameron  */
9a980e046SJonathan Cameron 
103176dd5dSSachin Kamat #define pr_fmt(fmt) "iio-core: " fmt
113176dd5dSSachin Kamat 
1205f59abaSAndy Shevchenko #include <linux/anon_inodes.h>
1305f59abaSAndy Shevchenko #include <linux/cdev.h>
1442ea5992SNuno Sa #include <linux/cleanup.h>
1505f59abaSAndy Shevchenko #include <linux/debugfs.h>
1605f59abaSAndy Shevchenko #include <linux/device.h>
1705f59abaSAndy Shevchenko #include <linux/err.h>
1805f59abaSAndy Shevchenko #include <linux/fs.h>
19a980e046SJonathan Cameron #include <linux/idr.h>
20a980e046SJonathan Cameron #include <linux/kdev_t.h>
2105f59abaSAndy Shevchenko #include <linux/kernel.h>
2205f59abaSAndy Shevchenko #include <linux/module.h>
2305f59abaSAndy Shevchenko #include <linux/mutex.h>
24a980e046SJonathan Cameron #include <linux/poll.h>
25fb158971SAndy Shevchenko #include <linux/property.h>
26a980e046SJonathan Cameron #include <linux/sched.h>
27a980e046SJonathan Cameron #include <linux/slab.h>
2805f59abaSAndy Shevchenko #include <linux/wait.h>
2905f59abaSAndy Shevchenko 
309e69c935SLars-Peter Clausen #include <linux/iio/buffer.h>
3133dd94cbSJonathan Cameron #include <linux/iio/buffer_impl.h>
3205f59abaSAndy Shevchenko #include <linux/iio/events.h>
3305f59abaSAndy Shevchenko #include <linux/iio/iio-opaque.h>
3405f59abaSAndy Shevchenko #include <linux/iio/iio.h>
3505f59abaSAndy Shevchenko #include <linux/iio/sysfs.h>
3605f59abaSAndy Shevchenko 
3705f59abaSAndy Shevchenko #include "iio_core.h"
3805f59abaSAndy Shevchenko #include "iio_core_trigger.h"
39a980e046SJonathan Cameron 
40a980e046SJonathan Cameron /* IDA to assign each registered device a unique id */
41a980e046SJonathan Cameron static DEFINE_IDA(iio_ida);
42a980e046SJonathan Cameron 
43a980e046SJonathan Cameron static dev_t iio_devt;
44a980e046SJonathan Cameron 
45a980e046SJonathan Cameron #define IIO_DEV_MAX 256
4689b1b86fSRicardo B. Marliere const struct bus_type iio_bus_type = {
47a980e046SJonathan Cameron 	.name = "iio",
48a980e046SJonathan Cameron };
49a980e046SJonathan Cameron EXPORT_SYMBOL(iio_bus_type);
50a980e046SJonathan Cameron 
51a980e046SJonathan Cameron static struct dentry *iio_debugfs_dentry;
52a980e046SJonathan Cameron 
53a980e046SJonathan Cameron static const char * const iio_direction[] = {
54a980e046SJonathan Cameron 	[0] = "in",
55a980e046SJonathan Cameron 	[1] = "out",
56a980e046SJonathan Cameron };
57a980e046SJonathan Cameron 
58a980e046SJonathan Cameron static const char * const iio_chan_type_name_spec[] = {
59a980e046SJonathan Cameron 	[IIO_VOLTAGE] = "voltage",
60a980e046SJonathan Cameron 	[IIO_CURRENT] = "current",
61a980e046SJonathan Cameron 	[IIO_POWER] = "power",
62a980e046SJonathan Cameron 	[IIO_ACCEL] = "accel",
63a980e046SJonathan Cameron 	[IIO_ANGL_VEL] = "anglvel",
64a980e046SJonathan Cameron 	[IIO_MAGN] = "magn",
65a980e046SJonathan Cameron 	[IIO_LIGHT] = "illuminance",
66a980e046SJonathan Cameron 	[IIO_INTENSITY] = "intensity",
67a980e046SJonathan Cameron 	[IIO_PROXIMITY] = "proximity",
68a980e046SJonathan Cameron 	[IIO_TEMP] = "temp",
69a980e046SJonathan Cameron 	[IIO_INCLI] = "incli",
70a980e046SJonathan Cameron 	[IIO_ROT] = "rot",
71a980e046SJonathan Cameron 	[IIO_ANGL] = "angl",
72a980e046SJonathan Cameron 	[IIO_TIMESTAMP] = "timestamp",
73a980e046SJonathan Cameron 	[IIO_CAPACITANCE] = "capacitance",
74a6b12855SMichael Hennerich 	[IIO_ALTVOLTAGE] = "altvoltage",
7521cd1fabSJon Brenner 	[IIO_CCT] = "cct",
76c4f0c693SLars-Peter Clausen 	[IIO_PRESSURE] = "pressure",
77ac216aa2SHarald Geyer 	[IIO_HUMIDITYRELATIVE] = "humidityrelative",
7855aebeb9SDaniel Baluta 	[IIO_ACTIVITY] = "activity",
79a88bfe78SIrina Tirdea 	[IIO_STEPS] = "steps",
8072c66644SIrina Tirdea 	[IIO_ENERGY] = "energy",
81cc3c9eecSIrina Tirdea 	[IIO_DISTANCE] = "distance",
825a1a9329SIrina Tirdea 	[IIO_VELOCITY] = "velocity",
838ff6b3bcSMatt Ranostay 	[IIO_CONCENTRATION] = "concentration",
84d38d5469SMatt Ranostay 	[IIO_RESISTANCE] = "resistance",
85ecb3a7ccSMatt Ranostay 	[IIO_PH] = "ph",
86d409404cSPeter Meerwald-Stadler 	[IIO_UVINDEX] = "uvindex",
874b9d2090SMatt Ranostay 	[IIO_ELECTRICALCONDUCTIVITY] = "electricalconductivity",
881a8f324aSWilliam Breathitt Gray 	[IIO_COUNT] = "count",
891a8f324aSWilliam Breathitt Gray 	[IIO_INDEX] = "index",
90571299d0SSong Hongyan 	[IIO_GRAVITY]  = "gravity",
913055a6cfSEugen Hristev 	[IIO_POSITIONRELATIVE]  = "positionrelative",
92c73314e6SMathieu Othacehe 	[IIO_PHASE] = "phase",
9317abc9ecSTomasz Duszynski 	[IIO_MASSCONCENTRATION] = "massconcentration",
94744f4990SRamona Bolboaca 	[IIO_DELTA_ANGL] = "deltaangl",
9594a39f2cSRamona Bolboaca 	[IIO_DELTA_VELOCITY] = "deltavelocity",
9642f31175SBasavaraj Natikar 	[IIO_COLORTEMP] = "colortemp",
9706790d4cSBasavaraj Natikar 	[IIO_CHROMATICITY] = "chromaticity",
98a980e046SJonathan Cameron };
99a980e046SJonathan Cameron 
100a980e046SJonathan Cameron static const char * const iio_modifier_names[] = {
101a980e046SJonathan Cameron 	[IIO_MOD_X] = "x",
102a980e046SJonathan Cameron 	[IIO_MOD_Y] = "y",
103a980e046SJonathan Cameron 	[IIO_MOD_Z] = "z",
1044b8d8015SPeter Meerwald 	[IIO_MOD_X_AND_Y] = "x&y",
1054b8d8015SPeter Meerwald 	[IIO_MOD_X_AND_Z] = "x&z",
1064b8d8015SPeter Meerwald 	[IIO_MOD_Y_AND_Z] = "y&z",
1074b8d8015SPeter Meerwald 	[IIO_MOD_X_AND_Y_AND_Z] = "x&y&z",
1084b8d8015SPeter Meerwald 	[IIO_MOD_X_OR_Y] = "x|y",
1094b8d8015SPeter Meerwald 	[IIO_MOD_X_OR_Z] = "x|z",
1104b8d8015SPeter Meerwald 	[IIO_MOD_Y_OR_Z] = "y|z",
1114b8d8015SPeter Meerwald 	[IIO_MOD_X_OR_Y_OR_Z] = "x|y|z",
1128f5879b2SJonathan Cameron 	[IIO_MOD_ROOT_SUM_SQUARED_X_Y] = "sqrt(x^2+y^2)",
113cf82cb81SJonathan Cameron 	[IIO_MOD_SUM_SQUARED_X_Y_Z] = "x^2+y^2+z^2",
114a980e046SJonathan Cameron 	[IIO_MOD_LIGHT_BOTH] = "both",
115a980e046SJonathan Cameron 	[IIO_MOD_LIGHT_IR] = "ir",
11621cd1fabSJon Brenner 	[IIO_MOD_LIGHT_CLEAR] = "clear",
11721cd1fabSJon Brenner 	[IIO_MOD_LIGHT_RED] = "red",
11821cd1fabSJon Brenner 	[IIO_MOD_LIGHT_GREEN] = "green",
11921cd1fabSJon Brenner 	[IIO_MOD_LIGHT_BLUE] = "blue",
1202c5ff1f9SPeter Meerwald-Stadler 	[IIO_MOD_LIGHT_UV] = "uv",
121b89710bdSJavier Carrasco 	[IIO_MOD_LIGHT_UVA] = "uva",
122b89710bdSJavier Carrasco 	[IIO_MOD_LIGHT_UVB] = "uvb",
123c0e4e0fdSMaxime Roussin-Bélanger 	[IIO_MOD_LIGHT_DUV] = "duv",
1245082f405SSrinivas Pandruvada 	[IIO_MOD_QUATERNION] = "quaternion",
125638b43b3SPeter Meerwald 	[IIO_MOD_TEMP_AMBIENT] = "ambient",
126638b43b3SPeter Meerwald 	[IIO_MOD_TEMP_OBJECT] = "object",
12711b8ddabSReyad Attiyat 	[IIO_MOD_NORTH_MAGN] = "from_north_magnetic",
12811b8ddabSReyad Attiyat 	[IIO_MOD_NORTH_TRUE] = "from_north_true",
12911b8ddabSReyad Attiyat 	[IIO_MOD_NORTH_MAGN_TILT_COMP] = "from_north_magnetic_tilt_comp",
13011b8ddabSReyad Attiyat 	[IIO_MOD_NORTH_TRUE_TILT_COMP] = "from_north_true_tilt_comp",
13155aebeb9SDaniel Baluta 	[IIO_MOD_RUNNING] = "running",
13255aebeb9SDaniel Baluta 	[IIO_MOD_JOGGING] = "jogging",
13355aebeb9SDaniel Baluta 	[IIO_MOD_WALKING] = "walking",
13455aebeb9SDaniel Baluta 	[IIO_MOD_STILL] = "still",
1355a1a9329SIrina Tirdea 	[IIO_MOD_ROOT_SUM_SQUARED_X_Y_Z] = "sqrt(x^2+y^2+z^2)",
1361ce87f21SLars-Peter Clausen 	[IIO_MOD_I] = "i",
1371ce87f21SLars-Peter Clausen 	[IIO_MOD_Q] = "q",
1388ff6b3bcSMatt Ranostay 	[IIO_MOD_CO2] = "co2",
1398ff6b3bcSMatt Ranostay 	[IIO_MOD_VOC] = "voc",
14017abc9ecSTomasz Duszynski 	[IIO_MOD_PM1] = "pm1",
14117abc9ecSTomasz Duszynski 	[IIO_MOD_PM2P5] = "pm2p5",
14217abc9ecSTomasz Duszynski 	[IIO_MOD_PM4] = "pm4",
14317abc9ecSTomasz Duszynski 	[IIO_MOD_PM10] = "pm10",
14425f02d32SMatt Ranostay 	[IIO_MOD_ETHANOL] = "ethanol",
14525f02d32SMatt Ranostay 	[IIO_MOD_H2] = "h2",
1464ffa22fdSMatt Ranostay 	[IIO_MOD_O2] = "o2",
147bcc57a48SAndrea Merello 	[IIO_MOD_LINEAR_X] = "linear_x",
148bcc57a48SAndrea Merello 	[IIO_MOD_LINEAR_Y] = "linear_y",
149bcc57a48SAndrea Merello 	[IIO_MOD_LINEAR_Z] = "linear_z",
150dcedf145SAndrea Merello 	[IIO_MOD_PITCH] = "pitch",
151dcedf145SAndrea Merello 	[IIO_MOD_YAW] = "yaw",
152dcedf145SAndrea Merello 	[IIO_MOD_ROLL] = "roll",
153a980e046SJonathan Cameron };
154a980e046SJonathan Cameron 
155a980e046SJonathan Cameron /* relies on pairs of these shared then separate */
156a980e046SJonathan Cameron static const char * const iio_chan_info_postfix[] = {
157a980e046SJonathan Cameron 	[IIO_CHAN_INFO_RAW] = "raw",
158a980e046SJonathan Cameron 	[IIO_CHAN_INFO_PROCESSED] = "input",
159a980e046SJonathan Cameron 	[IIO_CHAN_INFO_SCALE] = "scale",
160a980e046SJonathan Cameron 	[IIO_CHAN_INFO_OFFSET] = "offset",
161a980e046SJonathan Cameron 	[IIO_CHAN_INFO_CALIBSCALE] = "calibscale",
162a980e046SJonathan Cameron 	[IIO_CHAN_INFO_CALIBBIAS] = "calibbias",
163a980e046SJonathan Cameron 	[IIO_CHAN_INFO_PEAK] = "peak_raw",
164a980e046SJonathan Cameron 	[IIO_CHAN_INFO_PEAK_SCALE] = "peak_scale",
165a980e046SJonathan Cameron 	[IIO_CHAN_INFO_QUADRATURE_CORRECTION_RAW] = "quadrature_correction_raw",
166a980e046SJonathan Cameron 	[IIO_CHAN_INFO_AVERAGE_RAW] = "mean_raw",
167a980e046SJonathan Cameron 	[IIO_CHAN_INFO_LOW_PASS_FILTER_3DB_FREQUENCY]
168a980e046SJonathan Cameron 	= "filter_low_pass_3db_frequency",
1693f7f642bSMartin Fuzzey 	[IIO_CHAN_INFO_HIGH_PASS_FILTER_3DB_FREQUENCY]
1703f7f642bSMartin Fuzzey 	= "filter_high_pass_3db_frequency",
171a980e046SJonathan Cameron 	[IIO_CHAN_INFO_SAMP_FREQ] = "sampling_frequency",
172a6b12855SMichael Hennerich 	[IIO_CHAN_INFO_FREQUENCY] = "frequency",
173a6b12855SMichael Hennerich 	[IIO_CHAN_INFO_PHASE] = "phase",
174b65d6212SMichael Hennerich 	[IIO_CHAN_INFO_HARDWAREGAIN] = "hardwaregain",
1757c9ab035Ssrinivas pandruvada 	[IIO_CHAN_INFO_HYSTERESIS] = "hysteresis",
1761c71a286SYe Xiang 	[IIO_CHAN_INFO_HYSTERESIS_RELATIVE] = "hysteresis_relative",
177899d90bdSPeter Meerwald 	[IIO_CHAN_INFO_INT_TIME] = "integration_time",
178a88bfe78SIrina Tirdea 	[IIO_CHAN_INFO_ENABLE] = "en",
179bcdf28fbSIrina Tirdea 	[IIO_CHAN_INFO_CALIBHEIGHT] = "calibheight",
180d37f6836SIrina Tirdea 	[IIO_CHAN_INFO_CALIBWEIGHT] = "calibweight",
1812f0ecb7cSIrina Tirdea 	[IIO_CHAN_INFO_DEBOUNCE_COUNT] = "debounce_count",
1822f0ecb7cSIrina Tirdea 	[IIO_CHAN_INFO_DEBOUNCE_TIME] = "debounce_time",
183c8a85854SVianney le Clément de Saint-Marcq 	[IIO_CHAN_INFO_CALIBEMISSIVITY] = "calibemissivity",
184faaa4495SIrina Tirdea 	[IIO_CHAN_INFO_OVERSAMPLING_RATIO] = "oversampling_ratio",
185ddfb97d8SAndrea Merello 	[IIO_CHAN_INFO_THERMOCOUPLE_TYPE] = "thermocouple_type",
186dde8ceecSCrt Mori 	[IIO_CHAN_INFO_CALIBAMBIENT] = "calibambient",
1875c64990bSJonathan Cameron 	[IIO_CHAN_INFO_ZEROPOINT] = "zeropoint",
1885bc2ea60SJavier Carrasco 	[IIO_CHAN_INFO_TROUGH] = "trough_raw",
189a980e046SJonathan Cameron };
19015ea2878SJonathan Cameron /**
19115ea2878SJonathan Cameron  * iio_device_id() - query the unique ID for the device
19215ea2878SJonathan Cameron  * @indio_dev:		Device structure whose ID is being queried
19315ea2878SJonathan Cameron  *
19415ea2878SJonathan Cameron  * The IIO device ID is a unique index used for example for the naming
19565659a8dSAndy Shevchenko  * of the character device /dev/iio\:device[ID].
19665659a8dSAndy Shevchenko  *
19765659a8dSAndy Shevchenko  * Returns: Unique ID for the device.
19815ea2878SJonathan Cameron  */
19915ea2878SJonathan Cameron int iio_device_id(struct iio_dev *indio_dev)
20015ea2878SJonathan Cameron {
20115ea2878SJonathan Cameron 	struct iio_dev_opaque *iio_dev_opaque = to_iio_dev_opaque(indio_dev);
20215ea2878SJonathan Cameron 
20315ea2878SJonathan Cameron 	return iio_dev_opaque->id;
20415ea2878SJonathan Cameron }
20515ea2878SJonathan Cameron EXPORT_SYMBOL_GPL(iio_device_id);
206a980e046SJonathan Cameron 
207d9a0e73cSLars-Peter Clausen /**
2082f53b4adSMiquel Raynal  * iio_buffer_enabled() - helper function to test if the buffer is enabled
2092f53b4adSMiquel Raynal  * @indio_dev:		IIO device structure for device
21065659a8dSAndy Shevchenko  *
21165659a8dSAndy Shevchenko  * Returns: True, if the buffer is enabled.
2122f53b4adSMiquel Raynal  */
2132f53b4adSMiquel Raynal bool iio_buffer_enabled(struct iio_dev *indio_dev)
2142f53b4adSMiquel Raynal {
21551570c9dSMiquel Raynal 	struct iio_dev_opaque *iio_dev_opaque = to_iio_dev_opaque(indio_dev);
21651570c9dSMiquel Raynal 
217e7748c17SDavid Lechner 	return iio_dev_opaque->currentmode & INDIO_ALL_BUFFER_MODES;
2182f53b4adSMiquel Raynal }
2192f53b4adSMiquel Raynal EXPORT_SYMBOL_GPL(iio_buffer_enabled);
2202f53b4adSMiquel Raynal 
22196fb1b67SAlexandru Ardelean #if defined(CONFIG_DEBUG_FS)
222c9561fd2SJonathan Cameron /*
22396fb1b67SAlexandru Ardelean  * There's also a CONFIG_DEBUG_FS guard in include/linux/iio/iio.h for
22496fb1b67SAlexandru Ardelean  * iio_get_debugfs_dentry() to make it inline if CONFIG_DEBUG_FS is undefined
22596fb1b67SAlexandru Ardelean  */
22696fb1b67SAlexandru Ardelean struct dentry *iio_get_debugfs_dentry(struct iio_dev *indio_dev)
22796fb1b67SAlexandru Ardelean {
22896fb1b67SAlexandru Ardelean 	struct iio_dev_opaque *iio_dev_opaque = to_iio_dev_opaque(indio_dev);
2299d9ec8d0SJoe Simmons-Talbott 
23096fb1b67SAlexandru Ardelean 	return iio_dev_opaque->debugfs_dentry;
23196fb1b67SAlexandru Ardelean }
23296fb1b67SAlexandru Ardelean EXPORT_SYMBOL_GPL(iio_get_debugfs_dentry);
23396fb1b67SAlexandru Ardelean #endif
23496fb1b67SAlexandru Ardelean 
235a7e57dceSSachin Kamat /**
236a7e57dceSSachin Kamat  * iio_find_channel_from_si() - get channel from its scan index
237a7e57dceSSachin Kamat  * @indio_dev:		device
238a7e57dceSSachin Kamat  * @si:			scan index to match
23965659a8dSAndy Shevchenko  *
24065659a8dSAndy Shevchenko  * Returns:
24165659a8dSAndy Shevchenko  * Constant pointer to iio_chan_spec, if scan index matches, NULL on failure.
242a7e57dceSSachin Kamat  */
243a980e046SJonathan Cameron const struct iio_chan_spec
244a980e046SJonathan Cameron *iio_find_channel_from_si(struct iio_dev *indio_dev, int si)
245a980e046SJonathan Cameron {
246a980e046SJonathan Cameron 	int i;
247a980e046SJonathan Cameron 
248a980e046SJonathan Cameron 	for (i = 0; i < indio_dev->num_channels; i++)
249a980e046SJonathan Cameron 		if (indio_dev->channels[i].scan_index == si)
250a980e046SJonathan Cameron 			return &indio_dev->channels[i];
251a980e046SJonathan Cameron 	return NULL;
252a980e046SJonathan Cameron }
253a980e046SJonathan Cameron 
254a980e046SJonathan Cameron /* This turns up an awful lot */
255a980e046SJonathan Cameron ssize_t iio_read_const_attr(struct device *dev,
256a980e046SJonathan Cameron 			    struct device_attribute *attr,
257a980e046SJonathan Cameron 			    char *buf)
258a980e046SJonathan Cameron {
25983ca56b6SLars-Peter Clausen 	return sysfs_emit(buf, "%s\n", to_iio_const_attr(attr)->string);
260a980e046SJonathan Cameron }
261a980e046SJonathan Cameron EXPORT_SYMBOL(iio_read_const_attr);
262a980e046SJonathan Cameron 
26369f0793eSGwendal Grignou /**
26469f0793eSGwendal Grignou  * iio_device_set_clock() - Set current timestamping clock for the device
26569f0793eSGwendal Grignou  * @indio_dev: IIO device structure containing the device
26665659a8dSAndy Shevchenko  * @clock_id: timestamping clock POSIX identifier to set.
26765659a8dSAndy Shevchenko  *
26865659a8dSAndy Shevchenko  * Returns: 0 on success, or a negative error code.
26969f0793eSGwendal Grignou  */
27069f0793eSGwendal Grignou int iio_device_set_clock(struct iio_dev *indio_dev, clockid_t clock_id)
271bc2b7dabSGregor Boirie {
272bc2b7dabSGregor Boirie 	int ret;
273fa83c3baSAlexandru Ardelean 	struct iio_dev_opaque *iio_dev_opaque = to_iio_dev_opaque(indio_dev);
274fa83c3baSAlexandru Ardelean 	const struct iio_event_interface *ev_int = iio_dev_opaque->event_interface;
275bc2b7dabSGregor Boirie 
27616afe125SNuno Sá 	ret = mutex_lock_interruptible(&iio_dev_opaque->mlock);
277bc2b7dabSGregor Boirie 	if (ret)
278bc2b7dabSGregor Boirie 		return ret;
279bc2b7dabSGregor Boirie 	if ((ev_int && iio_event_enabled(ev_int)) ||
280bc2b7dabSGregor Boirie 	    iio_buffer_enabled(indio_dev)) {
28116afe125SNuno Sá 		mutex_unlock(&iio_dev_opaque->mlock);
282bc2b7dabSGregor Boirie 		return -EBUSY;
283bc2b7dabSGregor Boirie 	}
28462a486c4SJonathan Cameron 	iio_dev_opaque->clock_id = clock_id;
28516afe125SNuno Sá 	mutex_unlock(&iio_dev_opaque->mlock);
286bc2b7dabSGregor Boirie 
287bc2b7dabSGregor Boirie 	return 0;
288bc2b7dabSGregor Boirie }
28969f0793eSGwendal Grignou EXPORT_SYMBOL(iio_device_set_clock);
290bc2b7dabSGregor Boirie 
291bc2b7dabSGregor Boirie /**
29262a486c4SJonathan Cameron  * iio_device_get_clock() - Retrieve current timestamping clock for the device
29362a486c4SJonathan Cameron  * @indio_dev: IIO device structure containing the device
29465659a8dSAndy Shevchenko  *
29565659a8dSAndy Shevchenko  * Returns: Clock ID of the current timestamping clock for the device.
29662a486c4SJonathan Cameron  */
29762a486c4SJonathan Cameron clockid_t iio_device_get_clock(const struct iio_dev *indio_dev)
29862a486c4SJonathan Cameron {
29962a486c4SJonathan Cameron 	struct iio_dev_opaque *iio_dev_opaque = to_iio_dev_opaque(indio_dev);
30062a486c4SJonathan Cameron 
30162a486c4SJonathan Cameron 	return iio_dev_opaque->clock_id;
30262a486c4SJonathan Cameron }
30362a486c4SJonathan Cameron EXPORT_SYMBOL(iio_device_get_clock);
30462a486c4SJonathan Cameron 
30562a486c4SJonathan Cameron /**
306bc2b7dabSGregor Boirie  * iio_get_time_ns() - utility function to get a time stamp for events etc
307bc2b7dabSGregor Boirie  * @indio_dev: device
30865659a8dSAndy Shevchenko  *
30965659a8dSAndy Shevchenko  * Returns: Timestamp of the event in nanoseconds.
310bc2b7dabSGregor Boirie  */
311bc2b7dabSGregor Boirie s64 iio_get_time_ns(const struct iio_dev *indio_dev)
312bc2b7dabSGregor Boirie {
31345e7f5d2SArnd Bergmann 	struct timespec64 tp;
314bc2b7dabSGregor Boirie 
315bc2b7dabSGregor Boirie 	switch (iio_device_get_clock(indio_dev)) {
316bc2b7dabSGregor Boirie 	case CLOCK_REALTIME:
31745e7f5d2SArnd Bergmann 		return ktime_get_real_ns();
318bc2b7dabSGregor Boirie 	case CLOCK_MONOTONIC:
31945e7f5d2SArnd Bergmann 		return ktime_get_ns();
320bc2b7dabSGregor Boirie 	case CLOCK_MONOTONIC_RAW:
32145e7f5d2SArnd Bergmann 		return ktime_get_raw_ns();
322bc2b7dabSGregor Boirie 	case CLOCK_REALTIME_COARSE:
32345e7f5d2SArnd Bergmann 		return ktime_to_ns(ktime_get_coarse_real());
324bc2b7dabSGregor Boirie 	case CLOCK_MONOTONIC_COARSE:
32545e7f5d2SArnd Bergmann 		ktime_get_coarse_ts64(&tp);
32645e7f5d2SArnd Bergmann 		return timespec64_to_ns(&tp);
327bc2b7dabSGregor Boirie 	case CLOCK_BOOTTIME:
3289285ec4cSJason A. Donenfeld 		return ktime_get_boottime_ns();
329bc2b7dabSGregor Boirie 	case CLOCK_TAI:
3309285ec4cSJason A. Donenfeld 		return ktime_get_clocktai_ns();
331bc2b7dabSGregor Boirie 	default:
332bc2b7dabSGregor Boirie 		BUG();
333bc2b7dabSGregor Boirie 	}
334bc2b7dabSGregor Boirie }
335bc2b7dabSGregor Boirie EXPORT_SYMBOL(iio_get_time_ns);
336bc2b7dabSGregor Boirie 
337a980e046SJonathan Cameron static int __init iio_init(void)
338a980e046SJonathan Cameron {
339a980e046SJonathan Cameron 	int ret;
340a980e046SJonathan Cameron 
341a980e046SJonathan Cameron 	/* Register sysfs bus */
342a980e046SJonathan Cameron 	ret  = bus_register(&iio_bus_type);
343a980e046SJonathan Cameron 	if (ret < 0) {
3443176dd5dSSachin Kamat 		pr_err("could not register bus type\n");
345a980e046SJonathan Cameron 		goto error_nothing;
346a980e046SJonathan Cameron 	}
347a980e046SJonathan Cameron 
348a980e046SJonathan Cameron 	ret = alloc_chrdev_region(&iio_devt, 0, IIO_DEV_MAX, "iio");
349a980e046SJonathan Cameron 	if (ret < 0) {
3503176dd5dSSachin Kamat 		pr_err("failed to allocate char dev region\n");
351a980e046SJonathan Cameron 		goto error_unregister_bus_type;
352a980e046SJonathan Cameron 	}
353a980e046SJonathan Cameron 
354a980e046SJonathan Cameron 	iio_debugfs_dentry = debugfs_create_dir("iio", NULL);
355a980e046SJonathan Cameron 
356a980e046SJonathan Cameron 	return 0;
357a980e046SJonathan Cameron 
358a980e046SJonathan Cameron error_unregister_bus_type:
359a980e046SJonathan Cameron 	bus_unregister(&iio_bus_type);
360a980e046SJonathan Cameron error_nothing:
361a980e046SJonathan Cameron 	return ret;
362a980e046SJonathan Cameron }
363a980e046SJonathan Cameron 
364a980e046SJonathan Cameron static void __exit iio_exit(void)
365a980e046SJonathan Cameron {
366a980e046SJonathan Cameron 	if (iio_devt)
367a980e046SJonathan Cameron 		unregister_chrdev_region(iio_devt, IIO_DEV_MAX);
368a980e046SJonathan Cameron 	bus_unregister(&iio_bus_type);
369a980e046SJonathan Cameron 	debugfs_remove(iio_debugfs_dentry);
370a980e046SJonathan Cameron }
371a980e046SJonathan Cameron 
372a980e046SJonathan Cameron #if defined(CONFIG_DEBUG_FS)
373a980e046SJonathan Cameron static ssize_t iio_debugfs_read_reg(struct file *file, char __user *userbuf,
374a980e046SJonathan Cameron 			      size_t count, loff_t *ppos)
375a980e046SJonathan Cameron {
376a980e046SJonathan Cameron 	struct iio_dev *indio_dev = file->private_data;
37796fb1b67SAlexandru Ardelean 	struct iio_dev_opaque *iio_dev_opaque = to_iio_dev_opaque(indio_dev);
378abeba59fSJoe Simmons-Talbott 	unsigned int val = 0;
379a980e046SJonathan Cameron 	int ret;
380a980e046SJonathan Cameron 
3812ddc982aSAlexandru Tachici 	if (*ppos > 0)
3822ddc982aSAlexandru Tachici 		return simple_read_from_buffer(userbuf, count, ppos,
38396fb1b67SAlexandru Ardelean 					       iio_dev_opaque->read_buf,
38496fb1b67SAlexandru Ardelean 					       iio_dev_opaque->read_buf_len);
3852ddc982aSAlexandru Tachici 
386a980e046SJonathan Cameron 	ret = indio_dev->info->debugfs_reg_access(indio_dev,
38796fb1b67SAlexandru Ardelean 						  iio_dev_opaque->cached_reg_addr,
388a980e046SJonathan Cameron 						  0, &val);
3893d62c78aSMatt Fornero 	if (ret) {
390a980e046SJonathan Cameron 		dev_err(indio_dev->dev.parent, "%s: read failed\n", __func__);
3913d62c78aSMatt Fornero 		return ret;
3923d62c78aSMatt Fornero 	}
393a980e046SJonathan Cameron 
39496fb1b67SAlexandru Ardelean 	iio_dev_opaque->read_buf_len = snprintf(iio_dev_opaque->read_buf,
39596fb1b67SAlexandru Ardelean 						sizeof(iio_dev_opaque->read_buf),
3962ddc982aSAlexandru Tachici 						"0x%X\n", val);
397a980e046SJonathan Cameron 
3982ddc982aSAlexandru Tachici 	return simple_read_from_buffer(userbuf, count, ppos,
39996fb1b67SAlexandru Ardelean 				       iio_dev_opaque->read_buf,
40096fb1b67SAlexandru Ardelean 				       iio_dev_opaque->read_buf_len);
401a980e046SJonathan Cameron }
402a980e046SJonathan Cameron 
403a980e046SJonathan Cameron static ssize_t iio_debugfs_write_reg(struct file *file,
404a980e046SJonathan Cameron 		     const char __user *userbuf, size_t count, loff_t *ppos)
405a980e046SJonathan Cameron {
406a980e046SJonathan Cameron 	struct iio_dev *indio_dev = file->private_data;
40796fb1b67SAlexandru Ardelean 	struct iio_dev_opaque *iio_dev_opaque = to_iio_dev_opaque(indio_dev);
408abeba59fSJoe Simmons-Talbott 	unsigned int reg, val;
409a980e046SJonathan Cameron 	char buf[80];
410a980e046SJonathan Cameron 	int ret;
411a980e046SJonathan Cameron 
412cb1d1753SAndy Shevchenko 	count = min(count, sizeof(buf) - 1);
413a980e046SJonathan Cameron 	if (copy_from_user(buf, userbuf, count))
414a980e046SJonathan Cameron 		return -EFAULT;
415a980e046SJonathan Cameron 
416a980e046SJonathan Cameron 	buf[count] = 0;
417a980e046SJonathan Cameron 
418a980e046SJonathan Cameron 	ret = sscanf(buf, "%i %i", &reg, &val);
419a980e046SJonathan Cameron 
420a980e046SJonathan Cameron 	switch (ret) {
421a980e046SJonathan Cameron 	case 1:
42296fb1b67SAlexandru Ardelean 		iio_dev_opaque->cached_reg_addr = reg;
423a980e046SJonathan Cameron 		break;
424a980e046SJonathan Cameron 	case 2:
42596fb1b67SAlexandru Ardelean 		iio_dev_opaque->cached_reg_addr = reg;
426a980e046SJonathan Cameron 		ret = indio_dev->info->debugfs_reg_access(indio_dev, reg,
427a980e046SJonathan Cameron 							  val, NULL);
428a980e046SJonathan Cameron 		if (ret) {
429a980e046SJonathan Cameron 			dev_err(indio_dev->dev.parent, "%s: write failed\n",
430a980e046SJonathan Cameron 				__func__);
431a980e046SJonathan Cameron 			return ret;
432a980e046SJonathan Cameron 		}
433a980e046SJonathan Cameron 		break;
434a980e046SJonathan Cameron 	default:
435a980e046SJonathan Cameron 		return -EINVAL;
436a980e046SJonathan Cameron 	}
437a980e046SJonathan Cameron 
438a980e046SJonathan Cameron 	return count;
439a980e046SJonathan Cameron }
440a980e046SJonathan Cameron 
441a980e046SJonathan Cameron static const struct file_operations iio_debugfs_reg_fops = {
4425a28c873SAxel Lin 	.open = simple_open,
443a980e046SJonathan Cameron 	.read = iio_debugfs_read_reg,
444a980e046SJonathan Cameron 	.write = iio_debugfs_write_reg,
445a980e046SJonathan Cameron };
446a980e046SJonathan Cameron 
447a980e046SJonathan Cameron static void iio_device_unregister_debugfs(struct iio_dev *indio_dev)
448a980e046SJonathan Cameron {
44996fb1b67SAlexandru Ardelean 	struct iio_dev_opaque *iio_dev_opaque = to_iio_dev_opaque(indio_dev);
4509d9ec8d0SJoe Simmons-Talbott 
45196fb1b67SAlexandru Ardelean 	debugfs_remove_recursive(iio_dev_opaque->debugfs_dentry);
452a980e046SJonathan Cameron }
453a980e046SJonathan Cameron 
4548915aacaSGreg Kroah-Hartman static void iio_device_register_debugfs(struct iio_dev *indio_dev)
455a980e046SJonathan Cameron {
45696fb1b67SAlexandru Ardelean 	struct iio_dev_opaque *iio_dev_opaque;
45796fb1b67SAlexandru Ardelean 
458a980e046SJonathan Cameron 	if (indio_dev->info->debugfs_reg_access == NULL)
4598915aacaSGreg Kroah-Hartman 		return;
460a980e046SJonathan Cameron 
461abd5a2fbSAxel Lin 	if (!iio_debugfs_dentry)
4628915aacaSGreg Kroah-Hartman 		return;
463a980e046SJonathan Cameron 
46496fb1b67SAlexandru Ardelean 	iio_dev_opaque = to_iio_dev_opaque(indio_dev);
46596fb1b67SAlexandru Ardelean 
46696fb1b67SAlexandru Ardelean 	iio_dev_opaque->debugfs_dentry =
467a980e046SJonathan Cameron 		debugfs_create_dir(dev_name(&indio_dev->dev),
468a980e046SJonathan Cameron 				   iio_debugfs_dentry);
469a980e046SJonathan Cameron 
4708915aacaSGreg Kroah-Hartman 	debugfs_create_file("direct_reg_access", 0644,
47196fb1b67SAlexandru Ardelean 			    iio_dev_opaque->debugfs_dentry, indio_dev,
4728915aacaSGreg Kroah-Hartman 			    &iio_debugfs_reg_fops);
473a980e046SJonathan Cameron }
474a980e046SJonathan Cameron #else
4758915aacaSGreg Kroah-Hartman static void iio_device_register_debugfs(struct iio_dev *indio_dev)
476a980e046SJonathan Cameron {
477a980e046SJonathan Cameron }
478a980e046SJonathan Cameron 
479a980e046SJonathan Cameron static void iio_device_unregister_debugfs(struct iio_dev *indio_dev)
480a980e046SJonathan Cameron {
481a980e046SJonathan Cameron }
482a980e046SJonathan Cameron #endif /* CONFIG_DEBUG_FS */
483a980e046SJonathan Cameron 
484a980e046SJonathan Cameron static ssize_t iio_read_channel_ext_info(struct device *dev,
485a980e046SJonathan Cameron 				     struct device_attribute *attr,
486a980e046SJonathan Cameron 				     char *buf)
487a980e046SJonathan Cameron {
488e53f5ac5SLars-Peter Clausen 	struct iio_dev *indio_dev = dev_to_iio_dev(dev);
489a980e046SJonathan Cameron 	struct iio_dev_attr *this_attr = to_iio_dev_attr(attr);
490a980e046SJonathan Cameron 	const struct iio_chan_spec_ext_info *ext_info;
491a980e046SJonathan Cameron 
492a980e046SJonathan Cameron 	ext_info = &this_attr->c->ext_info[this_attr->address];
493a980e046SJonathan Cameron 
494fc6d1139SMichael Hennerich 	return ext_info->read(indio_dev, ext_info->private, this_attr->c, buf);
495a980e046SJonathan Cameron }
496a980e046SJonathan Cameron 
497a980e046SJonathan Cameron static ssize_t iio_write_channel_ext_info(struct device *dev,
498a980e046SJonathan Cameron 				     struct device_attribute *attr,
499b662f4baSAndy Shevchenko 				     const char *buf, size_t len)
500a980e046SJonathan Cameron {
501e53f5ac5SLars-Peter Clausen 	struct iio_dev *indio_dev = dev_to_iio_dev(dev);
502a980e046SJonathan Cameron 	struct iio_dev_attr *this_attr = to_iio_dev_attr(attr);
503a980e046SJonathan Cameron 	const struct iio_chan_spec_ext_info *ext_info;
504a980e046SJonathan Cameron 
505a980e046SJonathan Cameron 	ext_info = &this_attr->c->ext_info[this_attr->address];
506a980e046SJonathan Cameron 
507fc6d1139SMichael Hennerich 	return ext_info->write(indio_dev, ext_info->private,
508fc6d1139SMichael Hennerich 			       this_attr->c, buf, len);
509a980e046SJonathan Cameron }
510a980e046SJonathan Cameron 
5115212cc8aSLars-Peter Clausen ssize_t iio_enum_available_read(struct iio_dev *indio_dev,
5125212cc8aSLars-Peter Clausen 	uintptr_t priv, const struct iio_chan_spec *chan, char *buf)
5135212cc8aSLars-Peter Clausen {
5145212cc8aSLars-Peter Clausen 	const struct iio_enum *e = (const struct iio_enum *)priv;
5155212cc8aSLars-Peter Clausen 	unsigned int i;
5165212cc8aSLars-Peter Clausen 	size_t len = 0;
5175212cc8aSLars-Peter Clausen 
5185212cc8aSLars-Peter Clausen 	if (!e->num_items)
5195212cc8aSLars-Peter Clausen 		return 0;
5205212cc8aSLars-Peter Clausen 
521d9a0e73cSLars-Peter Clausen 	for (i = 0; i < e->num_items; ++i) {
522d9a0e73cSLars-Peter Clausen 		if (!e->items[i])
523d9a0e73cSLars-Peter Clausen 			continue;
5240207483bSLars-Peter Clausen 		len += sysfs_emit_at(buf, len, "%s ", e->items[i]);
525d9a0e73cSLars-Peter Clausen 	}
5265212cc8aSLars-Peter Clausen 
5275212cc8aSLars-Peter Clausen 	/* replace last space with a newline */
5285212cc8aSLars-Peter Clausen 	buf[len - 1] = '\n';
5295212cc8aSLars-Peter Clausen 
5305212cc8aSLars-Peter Clausen 	return len;
5315212cc8aSLars-Peter Clausen }
5325212cc8aSLars-Peter Clausen EXPORT_SYMBOL_GPL(iio_enum_available_read);
5335212cc8aSLars-Peter Clausen 
5345212cc8aSLars-Peter Clausen ssize_t iio_enum_read(struct iio_dev *indio_dev,
5355212cc8aSLars-Peter Clausen 	uintptr_t priv, const struct iio_chan_spec *chan, char *buf)
5365212cc8aSLars-Peter Clausen {
5375212cc8aSLars-Peter Clausen 	const struct iio_enum *e = (const struct iio_enum *)priv;
5385212cc8aSLars-Peter Clausen 	int i;
5395212cc8aSLars-Peter Clausen 
5405212cc8aSLars-Peter Clausen 	if (!e->get)
5415212cc8aSLars-Peter Clausen 		return -EINVAL;
5425212cc8aSLars-Peter Clausen 
5435212cc8aSLars-Peter Clausen 	i = e->get(indio_dev, chan);
5445212cc8aSLars-Peter Clausen 	if (i < 0)
5455212cc8aSLars-Peter Clausen 		return i;
5461702df5dSAndy Shevchenko 	if (i >= e->num_items || !e->items[i])
5475212cc8aSLars-Peter Clausen 		return -EINVAL;
5485212cc8aSLars-Peter Clausen 
54983ca56b6SLars-Peter Clausen 	return sysfs_emit(buf, "%s\n", e->items[i]);
5505212cc8aSLars-Peter Clausen }
5515212cc8aSLars-Peter Clausen EXPORT_SYMBOL_GPL(iio_enum_read);
5525212cc8aSLars-Peter Clausen 
5535212cc8aSLars-Peter Clausen ssize_t iio_enum_write(struct iio_dev *indio_dev,
5545212cc8aSLars-Peter Clausen 	uintptr_t priv, const struct iio_chan_spec *chan, const char *buf,
5555212cc8aSLars-Peter Clausen 	size_t len)
5565212cc8aSLars-Peter Clausen {
5575212cc8aSLars-Peter Clausen 	const struct iio_enum *e = (const struct iio_enum *)priv;
5585212cc8aSLars-Peter Clausen 	int ret;
5595212cc8aSLars-Peter Clausen 
5605212cc8aSLars-Peter Clausen 	if (!e->set)
5615212cc8aSLars-Peter Clausen 		return -EINVAL;
5625212cc8aSLars-Peter Clausen 
563122fb873SAndy Shevchenko 	ret = __sysfs_match_string(e->items, e->num_items, buf);
56402e9a0ffSAndy Shevchenko 	if (ret < 0)
56502e9a0ffSAndy Shevchenko 		return ret;
5665212cc8aSLars-Peter Clausen 
56702e9a0ffSAndy Shevchenko 	ret = e->set(indio_dev, chan, ret);
5685212cc8aSLars-Peter Clausen 	return ret ? ret : len;
5695212cc8aSLars-Peter Clausen }
5705212cc8aSLars-Peter Clausen EXPORT_SYMBOL_GPL(iio_enum_write);
5715212cc8aSLars-Peter Clausen 
572dfc57732SGregor Boirie static const struct iio_mount_matrix iio_mount_idmatrix = {
573dfc57732SGregor Boirie 	.rotation = {
574dfc57732SGregor Boirie 		"1", "0", "0",
575dfc57732SGregor Boirie 		"0", "1", "0",
576dfc57732SGregor Boirie 		"0", "0", "1"
577dfc57732SGregor Boirie 	}
578dfc57732SGregor Boirie };
579dfc57732SGregor Boirie 
580dfc57732SGregor Boirie static int iio_setup_mount_idmatrix(const struct device *dev,
581dfc57732SGregor Boirie 				    struct iio_mount_matrix *matrix)
582dfc57732SGregor Boirie {
583dfc57732SGregor Boirie 	*matrix = iio_mount_idmatrix;
584dfc57732SGregor Boirie 	dev_info(dev, "mounting matrix not found: using identity...\n");
585dfc57732SGregor Boirie 	return 0;
586dfc57732SGregor Boirie }
587dfc57732SGregor Boirie 
588dfc57732SGregor Boirie ssize_t iio_show_mount_matrix(struct iio_dev *indio_dev, uintptr_t priv,
589dfc57732SGregor Boirie 			      const struct iio_chan_spec *chan, char *buf)
590dfc57732SGregor Boirie {
591b662f4baSAndy Shevchenko 	const struct iio_mount_matrix *mtx;
592dfc57732SGregor Boirie 
593b662f4baSAndy Shevchenko 	mtx = ((iio_get_mount_matrix_t *)priv)(indio_dev, chan);
594dfc57732SGregor Boirie 	if (IS_ERR(mtx))
595dfc57732SGregor Boirie 		return PTR_ERR(mtx);
596dfc57732SGregor Boirie 
597dfc57732SGregor Boirie 	if (!mtx)
598dfc57732SGregor Boirie 		mtx = &iio_mount_idmatrix;
599dfc57732SGregor Boirie 
60083ca56b6SLars-Peter Clausen 	return sysfs_emit(buf, "%s, %s, %s; %s, %s, %s; %s, %s, %s\n",
601dfc57732SGregor Boirie 			  mtx->rotation[0], mtx->rotation[1], mtx->rotation[2],
602dfc57732SGregor Boirie 			  mtx->rotation[3], mtx->rotation[4], mtx->rotation[5],
603dfc57732SGregor Boirie 			  mtx->rotation[6], mtx->rotation[7], mtx->rotation[8]);
604dfc57732SGregor Boirie }
605dfc57732SGregor Boirie EXPORT_SYMBOL_GPL(iio_show_mount_matrix);
606dfc57732SGregor Boirie 
607dfc57732SGregor Boirie /**
608fb158971SAndy Shevchenko  * iio_read_mount_matrix() - retrieve iio device mounting matrix from
609fb158971SAndy Shevchenko  *                           device "mount-matrix" property
610dfc57732SGregor Boirie  * @dev:	device the mounting matrix property is assigned to
611dfc57732SGregor Boirie  * @matrix:	where to store retrieved matrix
612dfc57732SGregor Boirie  *
613dfc57732SGregor Boirie  * If device is assigned no mounting matrix property, a default 3x3 identity
614dfc57732SGregor Boirie  * matrix will be filled in.
615dfc57732SGregor Boirie  *
61665659a8dSAndy Shevchenko  * Returns: 0 if success, or a negative error code on failure.
617dfc57732SGregor Boirie  */
618b892770aSAndy Shevchenko int iio_read_mount_matrix(struct device *dev, struct iio_mount_matrix *matrix)
619dfc57732SGregor Boirie {
620fb158971SAndy Shevchenko 	size_t len = ARRAY_SIZE(iio_mount_idmatrix.rotation);
621fb158971SAndy Shevchenko 	int err;
622dfc57732SGregor Boirie 
623b892770aSAndy Shevchenko 	err = device_property_read_string_array(dev, "mount-matrix", matrix->rotation, len);
624fb158971SAndy Shevchenko 	if (err == len)
625dfc57732SGregor Boirie 		return 0;
626dfc57732SGregor Boirie 
627dfc57732SGregor Boirie 	if (err >= 0)
628dfc57732SGregor Boirie 		/* Invalid number of matrix entries. */
629dfc57732SGregor Boirie 		return -EINVAL;
630dfc57732SGregor Boirie 
631dfc57732SGregor Boirie 	if (err != -EINVAL)
632dfc57732SGregor Boirie 		/* Invalid matrix declaration format. */
633dfc57732SGregor Boirie 		return err;
634dfc57732SGregor Boirie 
635dfc57732SGregor Boirie 	/* Matrix was not declared at all: fallback to identity. */
636dfc57732SGregor Boirie 	return iio_setup_mount_idmatrix(dev, matrix);
637dfc57732SGregor Boirie }
638fb158971SAndy Shevchenko EXPORT_SYMBOL(iio_read_mount_matrix);
639dfc57732SGregor Boirie 
6406b92ba0aSLars-Peter Clausen static ssize_t __iio_format_value(char *buf, size_t offset, unsigned int type,
64151239600SJonathan Cameron 				  int size, const int *vals)
64251239600SJonathan Cameron {
64351239600SJonathan Cameron 	int tmp0, tmp1;
6440e7a3978SAnand Ashok Dumbre 	s64 tmp2;
64551239600SJonathan Cameron 	bool scale_db = false;
64651239600SJonathan Cameron 
64751239600SJonathan Cameron 	switch (type) {
64851239600SJonathan Cameron 	case IIO_VAL_INT:
6496b92ba0aSLars-Peter Clausen 		return sysfs_emit_at(buf, offset, "%d", vals[0]);
65051239600SJonathan Cameron 	case IIO_VAL_INT_PLUS_MICRO_DB:
65151239600SJonathan Cameron 		scale_db = true;
652df561f66SGustavo A. R. Silva 		fallthrough;
65351239600SJonathan Cameron 	case IIO_VAL_INT_PLUS_MICRO:
65451239600SJonathan Cameron 		if (vals[1] < 0)
6556b92ba0aSLars-Peter Clausen 			return sysfs_emit_at(buf, offset, "-%d.%06u%s",
6566b92ba0aSLars-Peter Clausen 					     abs(vals[0]), -vals[1],
65751239600SJonathan Cameron 					     scale_db ? " dB" : "");
6586b92ba0aSLars-Peter Clausen 		else
6596b92ba0aSLars-Peter Clausen 			return sysfs_emit_at(buf, offset, "%d.%06u%s", vals[0],
6606b92ba0aSLars-Peter Clausen 					     vals[1], scale_db ? " dB" : "");
66151239600SJonathan Cameron 	case IIO_VAL_INT_PLUS_NANO:
66251239600SJonathan Cameron 		if (vals[1] < 0)
6636b92ba0aSLars-Peter Clausen 			return sysfs_emit_at(buf, offset, "-%d.%09u",
6646b92ba0aSLars-Peter Clausen 					     abs(vals[0]), -vals[1]);
66551239600SJonathan Cameron 		else
6666b92ba0aSLars-Peter Clausen 			return sysfs_emit_at(buf, offset, "%d.%09u", vals[0],
6676b92ba0aSLars-Peter Clausen 					     vals[1]);
66851239600SJonathan Cameron 	case IIO_VAL_FRACTIONAL:
6690e7a3978SAnand Ashok Dumbre 		tmp2 = div_s64((s64)vals[0] * 1000000000LL, vals[1]);
67051239600SJonathan Cameron 		tmp1 = vals[1];
6710e7a3978SAnand Ashok Dumbre 		tmp0 = (int)div_s64_rem(tmp2, 1000000000, &tmp1);
6720e7a3978SAnand Ashok Dumbre 		if ((tmp2 < 0) && (tmp0 == 0))
6736b92ba0aSLars-Peter Clausen 			return sysfs_emit_at(buf, offset, "-0.%09u", abs(tmp1));
6740e7a3978SAnand Ashok Dumbre 		else
6756b92ba0aSLars-Peter Clausen 			return sysfs_emit_at(buf, offset, "%d.%09u", tmp0,
6766b92ba0aSLars-Peter Clausen 					     abs(tmp1));
67751239600SJonathan Cameron 	case IIO_VAL_FRACTIONAL_LOG2:
6782646a95dSLars-Peter Clausen 		tmp2 = shift_right((s64)vals[0] * 1000000000LL, vals[1]);
6792646a95dSLars-Peter Clausen 		tmp0 = (int)div_s64_rem(tmp2, 1000000000LL, &tmp1);
68038a52cdeSLars-Peter Clausen 		if (tmp0 == 0 && tmp2 < 0)
6816b92ba0aSLars-Peter Clausen 			return sysfs_emit_at(buf, offset, "-0.%09u", abs(tmp1));
68238a52cdeSLars-Peter Clausen 		else
6836b92ba0aSLars-Peter Clausen 			return sysfs_emit_at(buf, offset, "%d.%09u", tmp0,
6846b92ba0aSLars-Peter Clausen 					     abs(tmp1));
68551239600SJonathan Cameron 	case IIO_VAL_INT_MULTIPLE:
68651239600SJonathan Cameron 	{
68751239600SJonathan Cameron 		int i;
68851239600SJonathan Cameron 		int l = 0;
68951239600SJonathan Cameron 
6906b92ba0aSLars-Peter Clausen 		for (i = 0; i < size; ++i)
6916b92ba0aSLars-Peter Clausen 			l += sysfs_emit_at(buf, offset + l, "%d ", vals[i]);
69251239600SJonathan Cameron 		return l;
69351239600SJonathan Cameron 	}
6948cb34036SAndrea Merello 	case IIO_VAL_CHAR:
6956b92ba0aSLars-Peter Clausen 		return sysfs_emit_at(buf, offset, "%c", (char)vals[0]);
6966bb835f3SAndriy Tryshnivskyy 	case IIO_VAL_INT_64:
6976bb835f3SAndriy Tryshnivskyy 		tmp2 = (s64)((((u64)vals[1]) << 32) | (u32)vals[0]);
6986bb835f3SAndriy Tryshnivskyy 		return sysfs_emit_at(buf, offset, "%lld", tmp2);
69951239600SJonathan Cameron 	default:
70051239600SJonathan Cameron 		return 0;
70151239600SJonathan Cameron 	}
70251239600SJonathan Cameron }
70351239600SJonathan Cameron 
7043661f3f5SLars-Peter Clausen /**
7053661f3f5SLars-Peter Clausen  * iio_format_value() - Formats a IIO value into its string representation
7062498dcf6SCristina Opriceana  * @buf:	The buffer to which the formatted value gets written
70751239600SJonathan Cameron  *		which is assumed to be big enough (i.e. PAGE_SIZE).
708c175cb7cSRandy Dunlap  * @type:	One of the IIO_VAL_* constants. This decides how the val
7092498dcf6SCristina Opriceana  *		and val2 parameters are formatted.
7102498dcf6SCristina Opriceana  * @size:	Number of IIO value entries contained in vals
7112498dcf6SCristina Opriceana  * @vals:	Pointer to the values, exact meaning depends on the
7122498dcf6SCristina Opriceana  *		type parameter.
7132498dcf6SCristina Opriceana  *
71465659a8dSAndy Shevchenko  * Returns:
71565659a8dSAndy Shevchenko  * 0 by default, a negative number on failure or the total number of characters
71665659a8dSAndy Shevchenko  * written for a type that belongs to the IIO_VAL_* constant.
7173661f3f5SLars-Peter Clausen  */
7189fbfb4b3SSrinivas Pandruvada ssize_t iio_format_value(char *buf, unsigned int type, int size, int *vals)
719a980e046SJonathan Cameron {
72051239600SJonathan Cameron 	ssize_t len;
721a980e046SJonathan Cameron 
7226b92ba0aSLars-Peter Clausen 	len = __iio_format_value(buf, 0, type, size, vals);
72351239600SJonathan Cameron 	if (len >= PAGE_SIZE - 1)
72451239600SJonathan Cameron 		return -EFBIG;
7259fbfb4b3SSrinivas Pandruvada 
7266b92ba0aSLars-Peter Clausen 	return len + sysfs_emit_at(buf, len, "\n");
72767eedba3SMichael Hennerich }
7287d2c2acaSAndrew F. Davis EXPORT_SYMBOL_GPL(iio_format_value);
729a980e046SJonathan Cameron 
7301d4ef9b3SCristian Pop static ssize_t iio_read_channel_label(struct device *dev,
7311d4ef9b3SCristian Pop 				      struct device_attribute *attr,
7321d4ef9b3SCristian Pop 				      char *buf)
7331d4ef9b3SCristian Pop {
7341d4ef9b3SCristian Pop 	struct iio_dev *indio_dev = dev_to_iio_dev(dev);
7351d4ef9b3SCristian Pop 	struct iio_dev_attr *this_attr = to_iio_dev_attr(attr);
7361d4ef9b3SCristian Pop 
73713efdc3dSPaul Cercueil 	if (indio_dev->info->read_label)
7381d4ef9b3SCristian Pop 		return indio_dev->info->read_label(indio_dev, this_attr->c, buf);
73913efdc3dSPaul Cercueil 
74013efdc3dSPaul Cercueil 	if (this_attr->c->extend_name)
741c3154defSLars-Peter Clausen 		return sysfs_emit(buf, "%s\n", this_attr->c->extend_name);
74213efdc3dSPaul Cercueil 
74313efdc3dSPaul Cercueil 	return -EINVAL;
7441d4ef9b3SCristian Pop }
7451d4ef9b3SCristian Pop 
7463661f3f5SLars-Peter Clausen static ssize_t iio_read_channel_info(struct device *dev,
7473661f3f5SLars-Peter Clausen 				     struct device_attribute *attr,
7483661f3f5SLars-Peter Clausen 				     char *buf)
7493661f3f5SLars-Peter Clausen {
7503661f3f5SLars-Peter Clausen 	struct iio_dev *indio_dev = dev_to_iio_dev(dev);
7513661f3f5SLars-Peter Clausen 	struct iio_dev_attr *this_attr = to_iio_dev_attr(attr);
7529fbfb4b3SSrinivas Pandruvada 	int vals[INDIO_MAX_RAW_ELEMENTS];
7539fbfb4b3SSrinivas Pandruvada 	int ret;
7549fbfb4b3SSrinivas Pandruvada 	int val_len = 2;
7559fbfb4b3SSrinivas Pandruvada 
7569fbfb4b3SSrinivas Pandruvada 	if (indio_dev->info->read_raw_multi)
7579fbfb4b3SSrinivas Pandruvada 		ret = indio_dev->info->read_raw_multi(indio_dev, this_attr->c,
7589fbfb4b3SSrinivas Pandruvada 							INDIO_MAX_RAW_ELEMENTS,
7599fbfb4b3SSrinivas Pandruvada 							vals, &val_len,
7609fbfb4b3SSrinivas Pandruvada 							this_attr->address);
761*c4ec8dedSJulien Stephan 	else if (indio_dev->info->read_raw)
7629fbfb4b3SSrinivas Pandruvada 		ret = indio_dev->info->read_raw(indio_dev, this_attr->c,
7639fbfb4b3SSrinivas Pandruvada 				    &vals[0], &vals[1], this_attr->address);
764*c4ec8dedSJulien Stephan 	else
765*c4ec8dedSJulien Stephan 		return -EINVAL;
7663661f3f5SLars-Peter Clausen 
7673661f3f5SLars-Peter Clausen 	if (ret < 0)
7683661f3f5SLars-Peter Clausen 		return ret;
7693661f3f5SLars-Peter Clausen 
7709fbfb4b3SSrinivas Pandruvada 	return iio_format_value(buf, ret, val_len, vals);
7713661f3f5SLars-Peter Clausen }
7723661f3f5SLars-Peter Clausen 
773eda20ba1SLars-Peter Clausen static ssize_t iio_format_list(char *buf, const int *vals, int type, int length,
774eda20ba1SLars-Peter Clausen 			       const char *prefix, const char *suffix)
77551239600SJonathan Cameron {
776eda20ba1SLars-Peter Clausen 	ssize_t len;
777e08b60d3SLars-Peter Clausen 	int stride;
77851239600SJonathan Cameron 	int i;
779eda20ba1SLars-Peter Clausen 
78051239600SJonathan Cameron 	switch (type) {
78151239600SJonathan Cameron 	case IIO_VAL_INT:
782e08b60d3SLars-Peter Clausen 		stride = 1;
78351239600SJonathan Cameron 		break;
78451239600SJonathan Cameron 	default:
785e08b60d3SLars-Peter Clausen 		stride = 2;
786e08b60d3SLars-Peter Clausen 		break;
787e08b60d3SLars-Peter Clausen 	}
788e08b60d3SLars-Peter Clausen 
7896b92ba0aSLars-Peter Clausen 	len = sysfs_emit(buf, prefix);
790e08b60d3SLars-Peter Clausen 
791e08b60d3SLars-Peter Clausen 	for (i = 0; i <= length - stride; i += stride) {
792e08b60d3SLars-Peter Clausen 		if (i != 0) {
7936b92ba0aSLars-Peter Clausen 			len += sysfs_emit_at(buf, len, " ");
79451239600SJonathan Cameron 			if (len >= PAGE_SIZE)
79551239600SJonathan Cameron 				return -EFBIG;
79651239600SJonathan Cameron 		}
797e08b60d3SLars-Peter Clausen 
7986b92ba0aSLars-Peter Clausen 		len += __iio_format_value(buf, len, type, stride, &vals[i]);
799e08b60d3SLars-Peter Clausen 		if (len >= PAGE_SIZE)
800e08b60d3SLars-Peter Clausen 			return -EFBIG;
80151239600SJonathan Cameron 	}
80251239600SJonathan Cameron 
8036b92ba0aSLars-Peter Clausen 	len += sysfs_emit_at(buf, len, "%s\n", suffix);
804e08b60d3SLars-Peter Clausen 
80551239600SJonathan Cameron 	return len;
80651239600SJonathan Cameron }
80751239600SJonathan Cameron 
808eda20ba1SLars-Peter Clausen static ssize_t iio_format_avail_list(char *buf, const int *vals,
809eda20ba1SLars-Peter Clausen 				     int type, int length)
810eda20ba1SLars-Peter Clausen {
811eda20ba1SLars-Peter Clausen 
812eda20ba1SLars-Peter Clausen 	return iio_format_list(buf, vals, type, length, "", "");
813eda20ba1SLars-Peter Clausen }
814eda20ba1SLars-Peter Clausen 
81551239600SJonathan Cameron static ssize_t iio_format_avail_range(char *buf, const int *vals, int type)
81651239600SJonathan Cameron {
8175e1f9185SFawzi Khaber 	int length;
8185e1f9185SFawzi Khaber 
8195e1f9185SFawzi Khaber 	/*
8205e1f9185SFawzi Khaber 	 * length refers to the array size , not the number of elements.
8215e1f9185SFawzi Khaber 	 * The purpose is to print the range [min , step ,max] so length should
8225e1f9185SFawzi Khaber 	 * be 3 in case of int, and 6 for other types.
8235e1f9185SFawzi Khaber 	 */
8245e1f9185SFawzi Khaber 	switch (type) {
8255e1f9185SFawzi Khaber 	case IIO_VAL_INT:
8265e1f9185SFawzi Khaber 		length = 3;
8275e1f9185SFawzi Khaber 		break;
8285e1f9185SFawzi Khaber 	default:
8295e1f9185SFawzi Khaber 		length = 6;
8305e1f9185SFawzi Khaber 		break;
8315e1f9185SFawzi Khaber 	}
8325e1f9185SFawzi Khaber 
8335e1f9185SFawzi Khaber 	return iio_format_list(buf, vals, type, length, "[", "]");
83451239600SJonathan Cameron }
83551239600SJonathan Cameron 
83651239600SJonathan Cameron static ssize_t iio_read_channel_info_avail(struct device *dev,
83751239600SJonathan Cameron 					   struct device_attribute *attr,
83851239600SJonathan Cameron 					   char *buf)
83951239600SJonathan Cameron {
84051239600SJonathan Cameron 	struct iio_dev *indio_dev = dev_to_iio_dev(dev);
84151239600SJonathan Cameron 	struct iio_dev_attr *this_attr = to_iio_dev_attr(attr);
84251239600SJonathan Cameron 	const int *vals;
84351239600SJonathan Cameron 	int ret;
84451239600SJonathan Cameron 	int length;
84551239600SJonathan Cameron 	int type;
84651239600SJonathan Cameron 
847*c4ec8dedSJulien Stephan 	if (!indio_dev->info->read_avail)
848*c4ec8dedSJulien Stephan 		return -EINVAL;
849*c4ec8dedSJulien Stephan 
85051239600SJonathan Cameron 	ret = indio_dev->info->read_avail(indio_dev, this_attr->c,
85151239600SJonathan Cameron 					  &vals, &type, &length,
85251239600SJonathan Cameron 					  this_attr->address);
85351239600SJonathan Cameron 
85451239600SJonathan Cameron 	if (ret < 0)
85551239600SJonathan Cameron 		return ret;
85651239600SJonathan Cameron 	switch (ret) {
85751239600SJonathan Cameron 	case IIO_AVAIL_LIST:
85851239600SJonathan Cameron 		return iio_format_avail_list(buf, vals, type, length);
85951239600SJonathan Cameron 	case IIO_AVAIL_RANGE:
86051239600SJonathan Cameron 		return iio_format_avail_range(buf, vals, type);
86151239600SJonathan Cameron 	default:
86251239600SJonathan Cameron 		return -EINVAL;
86351239600SJonathan Cameron 	}
86451239600SJonathan Cameron }
86551239600SJonathan Cameron 
8666807d721SLars-Peter Clausen /**
867b8528224SBeniamin Bia  * __iio_str_to_fixpoint() - Parse a fixed-point number from a string
8686807d721SLars-Peter Clausen  * @str: The string to parse
8696807d721SLars-Peter Clausen  * @fract_mult: Multiplier for the first decimal place, should be a power of 10
8706807d721SLars-Peter Clausen  * @integer: The integer part of the number
8716807d721SLars-Peter Clausen  * @fract: The fractional part of the number
872b8528224SBeniamin Bia  * @scale_db: True if this should parse as dB
8736807d721SLars-Peter Clausen  *
87465659a8dSAndy Shevchenko  * Returns:
87565659a8dSAndy Shevchenko  * 0 on success, or a negative error code if the string could not be parsed.
8766807d721SLars-Peter Clausen  */
877b8528224SBeniamin Bia static int __iio_str_to_fixpoint(const char *str, int fract_mult,
878b8528224SBeniamin Bia 				 int *integer, int *fract, bool scale_db)
8796807d721SLars-Peter Clausen {
8806807d721SLars-Peter Clausen 	int i = 0, f = 0;
8816807d721SLars-Peter Clausen 	bool integer_part = true, negative = false;
8826807d721SLars-Peter Clausen 
883f47dff32SSean Nyekjaer 	if (fract_mult == 0) {
884f47dff32SSean Nyekjaer 		*fract = 0;
885f47dff32SSean Nyekjaer 
886f47dff32SSean Nyekjaer 		return kstrtoint(str, 0, integer);
887f47dff32SSean Nyekjaer 	}
888f47dff32SSean Nyekjaer 
8896807d721SLars-Peter Clausen 	if (str[0] == '-') {
8906807d721SLars-Peter Clausen 		negative = true;
8916807d721SLars-Peter Clausen 		str++;
8926807d721SLars-Peter Clausen 	} else if (str[0] == '+') {
8936807d721SLars-Peter Clausen 		str++;
8946807d721SLars-Peter Clausen 	}
8956807d721SLars-Peter Clausen 
8966807d721SLars-Peter Clausen 	while (*str) {
8976807d721SLars-Peter Clausen 		if ('0' <= *str && *str <= '9') {
8986807d721SLars-Peter Clausen 			if (integer_part) {
8996807d721SLars-Peter Clausen 				i = i * 10 + *str - '0';
9006807d721SLars-Peter Clausen 			} else {
9016807d721SLars-Peter Clausen 				f += fract_mult * (*str - '0');
9026807d721SLars-Peter Clausen 				fract_mult /= 10;
9036807d721SLars-Peter Clausen 			}
9046807d721SLars-Peter Clausen 		} else if (*str == '\n') {
9056807d721SLars-Peter Clausen 			if (*(str + 1) == '\0')
9066807d721SLars-Peter Clausen 				break;
9076807d721SLars-Peter Clausen 			return -EINVAL;
908b8528224SBeniamin Bia 		} else if (!strncmp(str, " dB", sizeof(" dB") - 1) && scale_db) {
909b8528224SBeniamin Bia 			/* Ignore the dB suffix */
910b8528224SBeniamin Bia 			str += sizeof(" dB") - 1;
911b8528224SBeniamin Bia 			continue;
912b8528224SBeniamin Bia 		} else if (!strncmp(str, "dB", sizeof("dB") - 1) && scale_db) {
913b8528224SBeniamin Bia 			/* Ignore the dB suffix */
914b8528224SBeniamin Bia 			str += sizeof("dB") - 1;
915b8528224SBeniamin Bia 			continue;
9166807d721SLars-Peter Clausen 		} else if (*str == '.' && integer_part) {
9176807d721SLars-Peter Clausen 			integer_part = false;
9186807d721SLars-Peter Clausen 		} else {
9196807d721SLars-Peter Clausen 			return -EINVAL;
9206807d721SLars-Peter Clausen 		}
9216807d721SLars-Peter Clausen 		str++;
9226807d721SLars-Peter Clausen 	}
9236807d721SLars-Peter Clausen 
9246807d721SLars-Peter Clausen 	if (negative) {
9256807d721SLars-Peter Clausen 		if (i)
9266807d721SLars-Peter Clausen 			i = -i;
9276807d721SLars-Peter Clausen 		else
9286807d721SLars-Peter Clausen 			f = -f;
9296807d721SLars-Peter Clausen 	}
9306807d721SLars-Peter Clausen 
9316807d721SLars-Peter Clausen 	*integer = i;
9326807d721SLars-Peter Clausen 	*fract = f;
9336807d721SLars-Peter Clausen 
9346807d721SLars-Peter Clausen 	return 0;
9356807d721SLars-Peter Clausen }
936b8528224SBeniamin Bia 
937b8528224SBeniamin Bia /**
938b8528224SBeniamin Bia  * iio_str_to_fixpoint() - Parse a fixed-point number from a string
939b8528224SBeniamin Bia  * @str: The string to parse
940b8528224SBeniamin Bia  * @fract_mult: Multiplier for the first decimal place, should be a power of 10
941b8528224SBeniamin Bia  * @integer: The integer part of the number
942b8528224SBeniamin Bia  * @fract: The fractional part of the number
943b8528224SBeniamin Bia  *
94465659a8dSAndy Shevchenko  * Returns:
94565659a8dSAndy Shevchenko  * 0 on success, or a negative error code if the string could not be parsed.
946b8528224SBeniamin Bia  */
947b8528224SBeniamin Bia int iio_str_to_fixpoint(const char *str, int fract_mult,
948b8528224SBeniamin Bia 			int *integer, int *fract)
949b8528224SBeniamin Bia {
950b8528224SBeniamin Bia 	return __iio_str_to_fixpoint(str, fract_mult, integer, fract, false);
951b8528224SBeniamin Bia }
9526807d721SLars-Peter Clausen EXPORT_SYMBOL_GPL(iio_str_to_fixpoint);
9536807d721SLars-Peter Clausen 
954a980e046SJonathan Cameron static ssize_t iio_write_channel_info(struct device *dev,
955a980e046SJonathan Cameron 				      struct device_attribute *attr,
956a980e046SJonathan Cameron 				      const char *buf,
957a980e046SJonathan Cameron 				      size_t len)
958a980e046SJonathan Cameron {
959e53f5ac5SLars-Peter Clausen 	struct iio_dev *indio_dev = dev_to_iio_dev(dev);
960a980e046SJonathan Cameron 	struct iio_dev_attr *this_attr = to_iio_dev_attr(attr);
9616807d721SLars-Peter Clausen 	int ret, fract_mult = 100000;
9628cb34036SAndrea Merello 	int integer, fract = 0;
9638cb34036SAndrea Merello 	bool is_char = false;
964b8528224SBeniamin Bia 	bool scale_db = false;
965a980e046SJonathan Cameron 
966a980e046SJonathan Cameron 	/* Assumes decimal - precision based on number of digits */
967a980e046SJonathan Cameron 	if (!indio_dev->info->write_raw)
968a980e046SJonathan Cameron 		return -EINVAL;
969a980e046SJonathan Cameron 
970a980e046SJonathan Cameron 	if (indio_dev->info->write_raw_get_fmt)
971a980e046SJonathan Cameron 		switch (indio_dev->info->write_raw_get_fmt(indio_dev,
972a980e046SJonathan Cameron 			this_attr->c, this_attr->address)) {
973f47dff32SSean Nyekjaer 		case IIO_VAL_INT:
974f47dff32SSean Nyekjaer 			fract_mult = 0;
975f47dff32SSean Nyekjaer 			break;
976b8528224SBeniamin Bia 		case IIO_VAL_INT_PLUS_MICRO_DB:
977b8528224SBeniamin Bia 			scale_db = true;
978df561f66SGustavo A. R. Silva 			fallthrough;
979a980e046SJonathan Cameron 		case IIO_VAL_INT_PLUS_MICRO:
980a980e046SJonathan Cameron 			fract_mult = 100000;
981a980e046SJonathan Cameron 			break;
982a980e046SJonathan Cameron 		case IIO_VAL_INT_PLUS_NANO:
983a980e046SJonathan Cameron 			fract_mult = 100000000;
984a980e046SJonathan Cameron 			break;
9858cb34036SAndrea Merello 		case IIO_VAL_CHAR:
9868cb34036SAndrea Merello 			is_char = true;
9878cb34036SAndrea Merello 			break;
988a980e046SJonathan Cameron 		default:
989a980e046SJonathan Cameron 			return -EINVAL;
990a980e046SJonathan Cameron 		}
991a980e046SJonathan Cameron 
9928cb34036SAndrea Merello 	if (is_char) {
9938cb34036SAndrea Merello 		char ch;
9948cb34036SAndrea Merello 
9958cb34036SAndrea Merello 		if (sscanf(buf, "%c", &ch) != 1)
9968cb34036SAndrea Merello 			return -EINVAL;
9978cb34036SAndrea Merello 		integer = ch;
9988cb34036SAndrea Merello 	} else {
999b8528224SBeniamin Bia 		ret = __iio_str_to_fixpoint(buf, fract_mult, &integer, &fract,
1000b8528224SBeniamin Bia 					    scale_db);
1001b8528224SBeniamin Bia 		if (ret)
1002b8528224SBeniamin Bia 			return ret;
10035403f280SMircea Caprioru 	}
1004a980e046SJonathan Cameron 
1005a980e046SJonathan Cameron 	ret = indio_dev->info->write_raw(indio_dev, this_attr->c,
1006a980e046SJonathan Cameron 					 integer, fract, this_attr->address);
1007a980e046SJonathan Cameron 	if (ret)
1008a980e046SJonathan Cameron 		return ret;
1009a980e046SJonathan Cameron 
1010a980e046SJonathan Cameron 	return len;
1011a980e046SJonathan Cameron }
1012a980e046SJonathan Cameron 
1013a980e046SJonathan Cameron static
1014a980e046SJonathan Cameron int __iio_device_attr_init(struct device_attribute *dev_attr,
1015a980e046SJonathan Cameron 			   const char *postfix,
1016a980e046SJonathan Cameron 			   struct iio_chan_spec const *chan,
1017a980e046SJonathan Cameron 			   ssize_t (*readfunc)(struct device *dev,
1018a980e046SJonathan Cameron 					       struct device_attribute *attr,
1019a980e046SJonathan Cameron 					       char *buf),
1020a980e046SJonathan Cameron 			   ssize_t (*writefunc)(struct device *dev,
1021a980e046SJonathan Cameron 						struct device_attribute *attr,
1022a980e046SJonathan Cameron 						const char *buf,
1023a980e046SJonathan Cameron 						size_t len),
10243704432fSJonathan Cameron 			   enum iio_shared_by shared_by)
1025a980e046SJonathan Cameron {
10263704432fSJonathan Cameron 	int ret = 0;
10277bbcf7e1SLars-Peter Clausen 	char *name = NULL;
10283704432fSJonathan Cameron 	char *full_postfix;
10299d9ec8d0SJoe Simmons-Talbott 
1030a980e046SJonathan Cameron 	sysfs_attr_init(&dev_attr->attr);
1031a980e046SJonathan Cameron 
1032a980e046SJonathan Cameron 	/* Build up postfix of <extend_name>_<modifier>_postfix */
10333704432fSJonathan Cameron 	if (chan->modified && (shared_by == IIO_SEPARATE)) {
1034a980e046SJonathan Cameron 		if (chan->extend_name)
1035a980e046SJonathan Cameron 			full_postfix = kasprintf(GFP_KERNEL, "%s_%s_%s",
1036b662f4baSAndy Shevchenko 						 iio_modifier_names[chan->channel2],
1037a980e046SJonathan Cameron 						 chan->extend_name,
1038a980e046SJonathan Cameron 						 postfix);
1039a980e046SJonathan Cameron 		else
1040a980e046SJonathan Cameron 			full_postfix = kasprintf(GFP_KERNEL, "%s_%s",
1041b662f4baSAndy Shevchenko 						 iio_modifier_names[chan->channel2],
1042a980e046SJonathan Cameron 						 postfix);
1043a980e046SJonathan Cameron 	} else {
104477bfa8baSLars-Peter Clausen 		if (chan->extend_name == NULL || shared_by != IIO_SEPARATE)
1045a980e046SJonathan Cameron 			full_postfix = kstrdup(postfix, GFP_KERNEL);
1046a980e046SJonathan Cameron 		else
1047a980e046SJonathan Cameron 			full_postfix = kasprintf(GFP_KERNEL,
1048a980e046SJonathan Cameron 						 "%s_%s",
1049a980e046SJonathan Cameron 						 chan->extend_name,
1050a980e046SJonathan Cameron 						 postfix);
1051a980e046SJonathan Cameron 	}
10523704432fSJonathan Cameron 	if (full_postfix == NULL)
10533704432fSJonathan Cameron 		return -ENOMEM;
1054a980e046SJonathan Cameron 
1055a980e046SJonathan Cameron 	if (chan->differential) { /* Differential can not have modifier */
10563704432fSJonathan Cameron 		switch (shared_by) {
1057c006ec83SJonathan Cameron 		case IIO_SHARED_BY_ALL:
10587bbcf7e1SLars-Peter Clausen 			name = kasprintf(GFP_KERNEL, "%s", full_postfix);
1059c006ec83SJonathan Cameron 			break;
1060c006ec83SJonathan Cameron 		case IIO_SHARED_BY_DIR:
10617bbcf7e1SLars-Peter Clausen 			name = kasprintf(GFP_KERNEL, "%s_%s",
1062c006ec83SJonathan Cameron 						iio_direction[chan->output],
1063c006ec83SJonathan Cameron 						full_postfix);
1064c006ec83SJonathan Cameron 			break;
10653704432fSJonathan Cameron 		case IIO_SHARED_BY_TYPE:
10667bbcf7e1SLars-Peter Clausen 			name = kasprintf(GFP_KERNEL, "%s_%s-%s_%s",
1067a980e046SJonathan Cameron 					    iio_direction[chan->output],
1068a980e046SJonathan Cameron 					    iio_chan_type_name_spec[chan->type],
1069a980e046SJonathan Cameron 					    iio_chan_type_name_spec[chan->type],
1070a980e046SJonathan Cameron 					    full_postfix);
10713704432fSJonathan Cameron 			break;
10723704432fSJonathan Cameron 		case IIO_SEPARATE:
10733704432fSJonathan Cameron 			if (!chan->indexed) {
1074231bfe53SDan Carpenter 				WARN(1, "Differential channels must be indexed\n");
10753704432fSJonathan Cameron 				ret = -EINVAL;
10763704432fSJonathan Cameron 				goto error_free_full_postfix;
10773704432fSJonathan Cameron 			}
10787bbcf7e1SLars-Peter Clausen 			name = kasprintf(GFP_KERNEL,
10793704432fSJonathan Cameron 					    "%s_%s%d-%s%d_%s",
1080a980e046SJonathan Cameron 					    iio_direction[chan->output],
1081a980e046SJonathan Cameron 					    iio_chan_type_name_spec[chan->type],
1082a980e046SJonathan Cameron 					    chan->channel,
1083a980e046SJonathan Cameron 					    iio_chan_type_name_spec[chan->type],
1084a980e046SJonathan Cameron 					    chan->channel2,
1085a980e046SJonathan Cameron 					    full_postfix);
10863704432fSJonathan Cameron 			break;
1087a980e046SJonathan Cameron 		}
1088a980e046SJonathan Cameron 	} else { /* Single ended */
10893704432fSJonathan Cameron 		switch (shared_by) {
1090c006ec83SJonathan Cameron 		case IIO_SHARED_BY_ALL:
10917bbcf7e1SLars-Peter Clausen 			name = kasprintf(GFP_KERNEL, "%s", full_postfix);
1092c006ec83SJonathan Cameron 			break;
1093c006ec83SJonathan Cameron 		case IIO_SHARED_BY_DIR:
10947bbcf7e1SLars-Peter Clausen 			name = kasprintf(GFP_KERNEL, "%s_%s",
1095c006ec83SJonathan Cameron 						iio_direction[chan->output],
1096c006ec83SJonathan Cameron 						full_postfix);
1097c006ec83SJonathan Cameron 			break;
10983704432fSJonathan Cameron 		case IIO_SHARED_BY_TYPE:
10997bbcf7e1SLars-Peter Clausen 			name = kasprintf(GFP_KERNEL, "%s_%s_%s",
1100a980e046SJonathan Cameron 					    iio_direction[chan->output],
1101a980e046SJonathan Cameron 					    iio_chan_type_name_spec[chan->type],
1102a980e046SJonathan Cameron 					    full_postfix);
11033704432fSJonathan Cameron 			break;
11043704432fSJonathan Cameron 
11053704432fSJonathan Cameron 		case IIO_SEPARATE:
11063704432fSJonathan Cameron 			if (chan->indexed)
11077bbcf7e1SLars-Peter Clausen 				name = kasprintf(GFP_KERNEL, "%s_%s%d_%s",
1108a980e046SJonathan Cameron 						    iio_direction[chan->output],
1109a980e046SJonathan Cameron 						    iio_chan_type_name_spec[chan->type],
1110a980e046SJonathan Cameron 						    chan->channel,
1111a980e046SJonathan Cameron 						    full_postfix);
1112a980e046SJonathan Cameron 			else
11137bbcf7e1SLars-Peter Clausen 				name = kasprintf(GFP_KERNEL, "%s_%s_%s",
1114a980e046SJonathan Cameron 						    iio_direction[chan->output],
1115a980e046SJonathan Cameron 						    iio_chan_type_name_spec[chan->type],
1116a980e046SJonathan Cameron 						    full_postfix);
11173704432fSJonathan Cameron 			break;
11183704432fSJonathan Cameron 		}
1119a980e046SJonathan Cameron 	}
11207bbcf7e1SLars-Peter Clausen 	if (name == NULL) {
1121a980e046SJonathan Cameron 		ret = -ENOMEM;
1122a980e046SJonathan Cameron 		goto error_free_full_postfix;
1123a980e046SJonathan Cameron 	}
11247bbcf7e1SLars-Peter Clausen 	dev_attr->attr.name = name;
1125a980e046SJonathan Cameron 
1126a980e046SJonathan Cameron 	if (readfunc) {
11279cf0b618SJoe Simmons-Talbott 		dev_attr->attr.mode |= 0444;
1128a980e046SJonathan Cameron 		dev_attr->show = readfunc;
1129a980e046SJonathan Cameron 	}
1130a980e046SJonathan Cameron 
1131a980e046SJonathan Cameron 	if (writefunc) {
11329cf0b618SJoe Simmons-Talbott 		dev_attr->attr.mode |= 0200;
1133a980e046SJonathan Cameron 		dev_attr->store = writefunc;
1134a980e046SJonathan Cameron 	}
11357bbcf7e1SLars-Peter Clausen 
1136a980e046SJonathan Cameron error_free_full_postfix:
1137a980e046SJonathan Cameron 	kfree(full_postfix);
11383704432fSJonathan Cameron 
1139a980e046SJonathan Cameron 	return ret;
1140a980e046SJonathan Cameron }
1141a980e046SJonathan Cameron 
1142a980e046SJonathan Cameron static void __iio_device_attr_deinit(struct device_attribute *dev_attr)
1143a980e046SJonathan Cameron {
1144a980e046SJonathan Cameron 	kfree(dev_attr->attr.name);
1145a980e046SJonathan Cameron }
1146a980e046SJonathan Cameron 
1147a980e046SJonathan Cameron int __iio_add_chan_devattr(const char *postfix,
1148a980e046SJonathan Cameron 			   struct iio_chan_spec const *chan,
1149a980e046SJonathan Cameron 			   ssize_t (*readfunc)(struct device *dev,
1150a980e046SJonathan Cameron 					       struct device_attribute *attr,
1151a980e046SJonathan Cameron 					       char *buf),
1152a980e046SJonathan Cameron 			   ssize_t (*writefunc)(struct device *dev,
1153a980e046SJonathan Cameron 						struct device_attribute *attr,
1154a980e046SJonathan Cameron 						const char *buf,
1155a980e046SJonathan Cameron 						size_t len),
1156a980e046SJonathan Cameron 			   u64 mask,
11573704432fSJonathan Cameron 			   enum iio_shared_by shared_by,
1158a980e046SJonathan Cameron 			   struct device *dev,
11593e3d11b2SAlexandru Ardelean 			   struct iio_buffer *buffer,
1160a980e046SJonathan Cameron 			   struct list_head *attr_list)
1161a980e046SJonathan Cameron {
1162a980e046SJonathan Cameron 	int ret;
1163a980e046SJonathan Cameron 	struct iio_dev_attr *iio_attr, *t;
1164a980e046SJonathan Cameron 
1165670c1103SSachin Kamat 	iio_attr = kzalloc(sizeof(*iio_attr), GFP_KERNEL);
116692825ff9SHartmut Knaack 	if (iio_attr == NULL)
116792825ff9SHartmut Knaack 		return -ENOMEM;
1168a980e046SJonathan Cameron 	ret = __iio_device_attr_init(&iio_attr->dev_attr,
1169a980e046SJonathan Cameron 				     postfix, chan,
11703704432fSJonathan Cameron 				     readfunc, writefunc, shared_by);
1171a980e046SJonathan Cameron 	if (ret)
1172a980e046SJonathan Cameron 		goto error_iio_dev_attr_free;
1173a980e046SJonathan Cameron 	iio_attr->c = chan;
1174a980e046SJonathan Cameron 	iio_attr->address = mask;
11753e3d11b2SAlexandru Ardelean 	iio_attr->buffer = buffer;
1176a980e046SJonathan Cameron 	list_for_each_entry(t, attr_list, l)
1177a980e046SJonathan Cameron 		if (strcmp(t->dev_attr.attr.name,
1178a980e046SJonathan Cameron 			   iio_attr->dev_attr.attr.name) == 0) {
11793704432fSJonathan Cameron 			if (shared_by == IIO_SEPARATE)
1180a980e046SJonathan Cameron 				dev_err(dev, "tried to double register : %s\n",
1181a980e046SJonathan Cameron 					t->dev_attr.attr.name);
1182a980e046SJonathan Cameron 			ret = -EBUSY;
1183a980e046SJonathan Cameron 			goto error_device_attr_deinit;
1184a980e046SJonathan Cameron 		}
1185a980e046SJonathan Cameron 	list_add(&iio_attr->l, attr_list);
1186a980e046SJonathan Cameron 
1187a980e046SJonathan Cameron 	return 0;
1188a980e046SJonathan Cameron 
1189a980e046SJonathan Cameron error_device_attr_deinit:
1190a980e046SJonathan Cameron 	__iio_device_attr_deinit(&iio_attr->dev_attr);
1191a980e046SJonathan Cameron error_iio_dev_attr_free:
1192a980e046SJonathan Cameron 	kfree(iio_attr);
1193a980e046SJonathan Cameron 	return ret;
1194a980e046SJonathan Cameron }
1195a980e046SJonathan Cameron 
11961d4ef9b3SCristian Pop static int iio_device_add_channel_label(struct iio_dev *indio_dev,
11971d4ef9b3SCristian Pop 					 struct iio_chan_spec const *chan)
11981d4ef9b3SCristian Pop {
11991d4ef9b3SCristian Pop 	struct iio_dev_opaque *iio_dev_opaque = to_iio_dev_opaque(indio_dev);
12001d4ef9b3SCristian Pop 	int ret;
12011d4ef9b3SCristian Pop 
120213efdc3dSPaul Cercueil 	if (!indio_dev->info->read_label && !chan->extend_name)
12031d4ef9b3SCristian Pop 		return 0;
12041d4ef9b3SCristian Pop 
12051d4ef9b3SCristian Pop 	ret = __iio_add_chan_devattr("label",
12061d4ef9b3SCristian Pop 				     chan,
12071d4ef9b3SCristian Pop 				     &iio_read_channel_label,
12081d4ef9b3SCristian Pop 				     NULL,
12091d4ef9b3SCristian Pop 				     0,
12101d4ef9b3SCristian Pop 				     IIO_SEPARATE,
12111d4ef9b3SCristian Pop 				     &indio_dev->dev,
12123e3d11b2SAlexandru Ardelean 				     NULL,
12131d4ef9b3SCristian Pop 				     &iio_dev_opaque->channel_attr_list);
12141d4ef9b3SCristian Pop 	if (ret < 0)
12151d4ef9b3SCristian Pop 		return ret;
12161d4ef9b3SCristian Pop 
12171d4ef9b3SCristian Pop 	return 1;
12181d4ef9b3SCristian Pop }
12191d4ef9b3SCristian Pop 
12203704432fSJonathan Cameron static int iio_device_add_info_mask_type(struct iio_dev *indio_dev,
12213704432fSJonathan Cameron 					 struct iio_chan_spec const *chan,
12223704432fSJonathan Cameron 					 enum iio_shared_by shared_by,
12233704432fSJonathan Cameron 					 const long *infomask)
12243704432fSJonathan Cameron {
1225207c2d27SAlexandru Ardelean 	struct iio_dev_opaque *iio_dev_opaque = to_iio_dev_opaque(indio_dev);
12263704432fSJonathan Cameron 	int i, ret, attrcount = 0;
12273704432fSJonathan Cameron 
12281016d567SOrson Zhai 	for_each_set_bit(i, infomask, sizeof(*infomask)*8) {
1229ef4b4856SJonathan Cameron 		if (i >= ARRAY_SIZE(iio_chan_info_postfix))
1230ef4b4856SJonathan Cameron 			return -EINVAL;
12313704432fSJonathan Cameron 		ret = __iio_add_chan_devattr(iio_chan_info_postfix[i],
12323704432fSJonathan Cameron 					     chan,
12333704432fSJonathan Cameron 					     &iio_read_channel_info,
12343704432fSJonathan Cameron 					     &iio_write_channel_info,
12353704432fSJonathan Cameron 					     i,
12363704432fSJonathan Cameron 					     shared_by,
12373704432fSJonathan Cameron 					     &indio_dev->dev,
12383e3d11b2SAlexandru Ardelean 					     NULL,
1239207c2d27SAlexandru Ardelean 					     &iio_dev_opaque->channel_attr_list);
12403704432fSJonathan Cameron 		if ((ret == -EBUSY) && (shared_by != IIO_SEPARATE))
12413704432fSJonathan Cameron 			continue;
12421702df5dSAndy Shevchenko 		if (ret < 0)
12433704432fSJonathan Cameron 			return ret;
12443704432fSJonathan Cameron 		attrcount++;
12453704432fSJonathan Cameron 	}
12463704432fSJonathan Cameron 
12473704432fSJonathan Cameron 	return attrcount;
12483704432fSJonathan Cameron }
12493704432fSJonathan Cameron 
125051239600SJonathan Cameron static int iio_device_add_info_mask_type_avail(struct iio_dev *indio_dev,
125151239600SJonathan Cameron 					       struct iio_chan_spec const *chan,
125251239600SJonathan Cameron 					       enum iio_shared_by shared_by,
125351239600SJonathan Cameron 					       const long *infomask)
125451239600SJonathan Cameron {
1255207c2d27SAlexandru Ardelean 	struct iio_dev_opaque *iio_dev_opaque = to_iio_dev_opaque(indio_dev);
125651239600SJonathan Cameron 	int i, ret, attrcount = 0;
125751239600SJonathan Cameron 	char *avail_postfix;
125851239600SJonathan Cameron 
12591016d567SOrson Zhai 	for_each_set_bit(i, infomask, sizeof(*infomask) * 8) {
1260936d3e53SYoung Xiao 		if (i >= ARRAY_SIZE(iio_chan_info_postfix))
1261936d3e53SYoung Xiao 			return -EINVAL;
126251239600SJonathan Cameron 		avail_postfix = kasprintf(GFP_KERNEL,
126351239600SJonathan Cameron 					  "%s_available",
126451239600SJonathan Cameron 					  iio_chan_info_postfix[i]);
126551239600SJonathan Cameron 		if (!avail_postfix)
126651239600SJonathan Cameron 			return -ENOMEM;
126751239600SJonathan Cameron 
126851239600SJonathan Cameron 		ret = __iio_add_chan_devattr(avail_postfix,
126951239600SJonathan Cameron 					     chan,
127051239600SJonathan Cameron 					     &iio_read_channel_info_avail,
127151239600SJonathan Cameron 					     NULL,
127251239600SJonathan Cameron 					     i,
127351239600SJonathan Cameron 					     shared_by,
127451239600SJonathan Cameron 					     &indio_dev->dev,
12753e3d11b2SAlexandru Ardelean 					     NULL,
1276207c2d27SAlexandru Ardelean 					     &iio_dev_opaque->channel_attr_list);
127751239600SJonathan Cameron 		kfree(avail_postfix);
127851239600SJonathan Cameron 		if ((ret == -EBUSY) && (shared_by != IIO_SEPARATE))
127951239600SJonathan Cameron 			continue;
12801702df5dSAndy Shevchenko 		if (ret < 0)
128151239600SJonathan Cameron 			return ret;
128251239600SJonathan Cameron 		attrcount++;
128351239600SJonathan Cameron 	}
128451239600SJonathan Cameron 
128551239600SJonathan Cameron 	return attrcount;
128651239600SJonathan Cameron }
128751239600SJonathan Cameron 
1288a980e046SJonathan Cameron static int iio_device_add_channel_sysfs(struct iio_dev *indio_dev,
1289a980e046SJonathan Cameron 					struct iio_chan_spec const *chan)
1290a980e046SJonathan Cameron {
1291207c2d27SAlexandru Ardelean 	struct iio_dev_opaque *iio_dev_opaque = to_iio_dev_opaque(indio_dev);
1292a980e046SJonathan Cameron 	int ret, attrcount = 0;
1293a980e046SJonathan Cameron 	const struct iio_chan_spec_ext_info *ext_info;
1294a980e046SJonathan Cameron 
1295a980e046SJonathan Cameron 	if (chan->channel < 0)
1296a980e046SJonathan Cameron 		return 0;
12973704432fSJonathan Cameron 	ret = iio_device_add_info_mask_type(indio_dev, chan,
12983704432fSJonathan Cameron 					    IIO_SEPARATE,
12993704432fSJonathan Cameron 					    &chan->info_mask_separate);
13008655cc49SJonathan Cameron 	if (ret < 0)
13013704432fSJonathan Cameron 		return ret;
13023704432fSJonathan Cameron 	attrcount += ret;
13033704432fSJonathan Cameron 
130451239600SJonathan Cameron 	ret = iio_device_add_info_mask_type_avail(indio_dev, chan,
130551239600SJonathan Cameron 						  IIO_SEPARATE,
1306682ca76bSJoe Simmons-Talbott 						  &chan->info_mask_separate_available);
130751239600SJonathan Cameron 	if (ret < 0)
130851239600SJonathan Cameron 		return ret;
130951239600SJonathan Cameron 	attrcount += ret;
131051239600SJonathan Cameron 
13113704432fSJonathan Cameron 	ret = iio_device_add_info_mask_type(indio_dev, chan,
13123704432fSJonathan Cameron 					    IIO_SHARED_BY_TYPE,
13133704432fSJonathan Cameron 					    &chan->info_mask_shared_by_type);
13143704432fSJonathan Cameron 	if (ret < 0)
13153704432fSJonathan Cameron 		return ret;
13163704432fSJonathan Cameron 	attrcount += ret;
1317a980e046SJonathan Cameron 
131851239600SJonathan Cameron 	ret = iio_device_add_info_mask_type_avail(indio_dev, chan,
131951239600SJonathan Cameron 						  IIO_SHARED_BY_TYPE,
1320682ca76bSJoe Simmons-Talbott 						  &chan->info_mask_shared_by_type_available);
132151239600SJonathan Cameron 	if (ret < 0)
132251239600SJonathan Cameron 		return ret;
132351239600SJonathan Cameron 	attrcount += ret;
132451239600SJonathan Cameron 
1325c006ec83SJonathan Cameron 	ret = iio_device_add_info_mask_type(indio_dev, chan,
1326c006ec83SJonathan Cameron 					    IIO_SHARED_BY_DIR,
1327c006ec83SJonathan Cameron 					    &chan->info_mask_shared_by_dir);
1328c006ec83SJonathan Cameron 	if (ret < 0)
1329c006ec83SJonathan Cameron 		return ret;
1330c006ec83SJonathan Cameron 	attrcount += ret;
1331c006ec83SJonathan Cameron 
133251239600SJonathan Cameron 	ret = iio_device_add_info_mask_type_avail(indio_dev, chan,
133351239600SJonathan Cameron 						  IIO_SHARED_BY_DIR,
133451239600SJonathan Cameron 						  &chan->info_mask_shared_by_dir_available);
133551239600SJonathan Cameron 	if (ret < 0)
133651239600SJonathan Cameron 		return ret;
133751239600SJonathan Cameron 	attrcount += ret;
133851239600SJonathan Cameron 
1339c006ec83SJonathan Cameron 	ret = iio_device_add_info_mask_type(indio_dev, chan,
1340c006ec83SJonathan Cameron 					    IIO_SHARED_BY_ALL,
1341c006ec83SJonathan Cameron 					    &chan->info_mask_shared_by_all);
1342c006ec83SJonathan Cameron 	if (ret < 0)
1343c006ec83SJonathan Cameron 		return ret;
1344c006ec83SJonathan Cameron 	attrcount += ret;
1345c006ec83SJonathan Cameron 
134651239600SJonathan Cameron 	ret = iio_device_add_info_mask_type_avail(indio_dev, chan,
134751239600SJonathan Cameron 						  IIO_SHARED_BY_ALL,
134851239600SJonathan Cameron 						  &chan->info_mask_shared_by_all_available);
134951239600SJonathan Cameron 	if (ret < 0)
135051239600SJonathan Cameron 		return ret;
135151239600SJonathan Cameron 	attrcount += ret;
135251239600SJonathan Cameron 
13531d4ef9b3SCristian Pop 	ret = iio_device_add_channel_label(indio_dev, chan);
13541d4ef9b3SCristian Pop 	if (ret < 0)
13551d4ef9b3SCristian Pop 		return ret;
13561d4ef9b3SCristian Pop 	attrcount += ret;
13571d4ef9b3SCristian Pop 
1358a980e046SJonathan Cameron 	if (chan->ext_info) {
1359a980e046SJonathan Cameron 		unsigned int i = 0;
13609d9ec8d0SJoe Simmons-Talbott 
1361a980e046SJonathan Cameron 		for (ext_info = chan->ext_info; ext_info->name; ext_info++) {
1362a980e046SJonathan Cameron 			ret = __iio_add_chan_devattr(ext_info->name,
1363a980e046SJonathan Cameron 					chan,
1364a980e046SJonathan Cameron 					ext_info->read ?
1365a980e046SJonathan Cameron 					    &iio_read_channel_ext_info : NULL,
1366a980e046SJonathan Cameron 					ext_info->write ?
1367a980e046SJonathan Cameron 					    &iio_write_channel_ext_info : NULL,
1368a980e046SJonathan Cameron 					i,
1369a980e046SJonathan Cameron 					ext_info->shared,
1370a980e046SJonathan Cameron 					&indio_dev->dev,
13713e3d11b2SAlexandru Ardelean 					NULL,
1372207c2d27SAlexandru Ardelean 					&iio_dev_opaque->channel_attr_list);
1373a980e046SJonathan Cameron 			i++;
1374a980e046SJonathan Cameron 			if (ret == -EBUSY && ext_info->shared)
1375a980e046SJonathan Cameron 				continue;
1376a980e046SJonathan Cameron 
1377a980e046SJonathan Cameron 			if (ret)
13783704432fSJonathan Cameron 				return ret;
1379a980e046SJonathan Cameron 
1380a980e046SJonathan Cameron 			attrcount++;
1381a980e046SJonathan Cameron 		}
1382a980e046SJonathan Cameron 	}
1383a980e046SJonathan Cameron 
13843704432fSJonathan Cameron 	return attrcount;
1385a980e046SJonathan Cameron }
1386a980e046SJonathan Cameron 
138784088ebdSLars-Peter Clausen /**
138884088ebdSLars-Peter Clausen  * iio_free_chan_devattr_list() - Free a list of IIO device attributes
138984088ebdSLars-Peter Clausen  * @attr_list: List of IIO device attributes
139084088ebdSLars-Peter Clausen  *
139184088ebdSLars-Peter Clausen  * This function frees the memory allocated for each of the IIO device
1392c1b03ab5SMartin Fuzzey  * attributes in the list.
139384088ebdSLars-Peter Clausen  */
139484088ebdSLars-Peter Clausen void iio_free_chan_devattr_list(struct list_head *attr_list)
1395a980e046SJonathan Cameron {
139684088ebdSLars-Peter Clausen 	struct iio_dev_attr *p, *n;
139784088ebdSLars-Peter Clausen 
139884088ebdSLars-Peter Clausen 	list_for_each_entry_safe(p, n, attr_list, l) {
139915097c7aSAlexandru Ardelean 		kfree_const(p->dev_attr.attr.name);
1400c1b03ab5SMartin Fuzzey 		list_del(&p->l);
1401a980e046SJonathan Cameron 		kfree(p);
1402a980e046SJonathan Cameron 	}
140384088ebdSLars-Peter Clausen }
1404a980e046SJonathan Cameron 
14059cf0b618SJoe Simmons-Talbott static ssize_t name_show(struct device *dev, struct device_attribute *attr,
1406a980e046SJonathan Cameron 			 char *buf)
1407a980e046SJonathan Cameron {
1408e53f5ac5SLars-Peter Clausen 	struct iio_dev *indio_dev = dev_to_iio_dev(dev);
14099d9ec8d0SJoe Simmons-Talbott 
141083ca56b6SLars-Peter Clausen 	return sysfs_emit(buf, "%s\n", indio_dev->name);
1411a980e046SJonathan Cameron }
1412a980e046SJonathan Cameron 
14139cf0b618SJoe Simmons-Talbott static DEVICE_ATTR_RO(name);
1414a980e046SJonathan Cameron 
14159cf0b618SJoe Simmons-Talbott static ssize_t label_show(struct device *dev, struct device_attribute *attr,
14162c3d0c9fSPhil Reid 			  char *buf)
14172c3d0c9fSPhil Reid {
14182c3d0c9fSPhil Reid 	struct iio_dev *indio_dev = dev_to_iio_dev(dev);
14199d9ec8d0SJoe Simmons-Talbott 
142083ca56b6SLars-Peter Clausen 	return sysfs_emit(buf, "%s\n", indio_dev->label);
14212c3d0c9fSPhil Reid }
14222c3d0c9fSPhil Reid 
14239cf0b618SJoe Simmons-Talbott static DEVICE_ATTR_RO(label);
14242c3d0c9fSPhil Reid 
1425971ddd4bSAndy Shevchenko static const char * const clock_names[] = {
1426971ddd4bSAndy Shevchenko 	[CLOCK_REALTIME]	 	= "realtime",
1427971ddd4bSAndy Shevchenko 	[CLOCK_MONOTONIC]	 	= "monotonic",
1428971ddd4bSAndy Shevchenko 	[CLOCK_PROCESS_CPUTIME_ID]	= "process_cputime_id",
1429971ddd4bSAndy Shevchenko 	[CLOCK_THREAD_CPUTIME_ID]	= "thread_cputime_id",
1430971ddd4bSAndy Shevchenko 	[CLOCK_MONOTONIC_RAW]	 	= "monotonic_raw",
1431971ddd4bSAndy Shevchenko 	[CLOCK_REALTIME_COARSE]	 	= "realtime_coarse",
1432971ddd4bSAndy Shevchenko 	[CLOCK_MONOTONIC_COARSE] 	= "monotonic_coarse",
1433971ddd4bSAndy Shevchenko 	[CLOCK_BOOTTIME]	 	= "boottime",
1434971ddd4bSAndy Shevchenko 	[CLOCK_REALTIME_ALARM]		= "realtime_alarm",
1435971ddd4bSAndy Shevchenko 	[CLOCK_BOOTTIME_ALARM]		= "boottime_alarm",
1436971ddd4bSAndy Shevchenko 	[CLOCK_SGI_CYCLE]		= "sgi_cycle",
1437971ddd4bSAndy Shevchenko 	[CLOCK_TAI]		 	= "tai",
1438971ddd4bSAndy Shevchenko };
1439971ddd4bSAndy Shevchenko 
14409cf0b618SJoe Simmons-Talbott static ssize_t current_timestamp_clock_show(struct device *dev,
1441bc2b7dabSGregor Boirie 					    struct device_attribute *attr,
1442bc2b7dabSGregor Boirie 					    char *buf)
1443bc2b7dabSGregor Boirie {
1444bc2b7dabSGregor Boirie 	const struct iio_dev *indio_dev = dev_to_iio_dev(dev);
1445bc2b7dabSGregor Boirie 	const clockid_t clk = iio_device_get_clock(indio_dev);
1446bc2b7dabSGregor Boirie 
1447bc2b7dabSGregor Boirie 	switch (clk) {
1448bc2b7dabSGregor Boirie 	case CLOCK_REALTIME:
1449bc2b7dabSGregor Boirie 	case CLOCK_MONOTONIC:
1450bc2b7dabSGregor Boirie 	case CLOCK_MONOTONIC_RAW:
1451bc2b7dabSGregor Boirie 	case CLOCK_REALTIME_COARSE:
1452bc2b7dabSGregor Boirie 	case CLOCK_MONOTONIC_COARSE:
1453bc2b7dabSGregor Boirie 	case CLOCK_BOOTTIME:
1454bc2b7dabSGregor Boirie 	case CLOCK_TAI:
1455bc2b7dabSGregor Boirie 		break;
1456bc2b7dabSGregor Boirie 	default:
1457bc2b7dabSGregor Boirie 		BUG();
1458bc2b7dabSGregor Boirie 	}
1459bc2b7dabSGregor Boirie 
1460971ddd4bSAndy Shevchenko 	return sysfs_emit(buf, "%s\n", clock_names[clk]);
1461bc2b7dabSGregor Boirie }
1462bc2b7dabSGregor Boirie 
14639cf0b618SJoe Simmons-Talbott static ssize_t current_timestamp_clock_store(struct device *dev,
1464bc2b7dabSGregor Boirie 					     struct device_attribute *attr,
1465bc2b7dabSGregor Boirie 					     const char *buf, size_t len)
1466bc2b7dabSGregor Boirie {
1467bc2b7dabSGregor Boirie 	clockid_t clk;
1468bc2b7dabSGregor Boirie 	int ret;
1469bc2b7dabSGregor Boirie 
1470971ddd4bSAndy Shevchenko 	ret = sysfs_match_string(clock_names, buf);
1471971ddd4bSAndy Shevchenko 	if (ret < 0)
1472971ddd4bSAndy Shevchenko 		return ret;
1473971ddd4bSAndy Shevchenko 	clk = ret;
1474971ddd4bSAndy Shevchenko 
1475971ddd4bSAndy Shevchenko 	switch (clk) {
1476971ddd4bSAndy Shevchenko 	case CLOCK_REALTIME:
1477971ddd4bSAndy Shevchenko 	case CLOCK_MONOTONIC:
1478971ddd4bSAndy Shevchenko 	case CLOCK_MONOTONIC_RAW:
1479971ddd4bSAndy Shevchenko 	case CLOCK_REALTIME_COARSE:
1480971ddd4bSAndy Shevchenko 	case CLOCK_MONOTONIC_COARSE:
1481971ddd4bSAndy Shevchenko 	case CLOCK_BOOTTIME:
1482971ddd4bSAndy Shevchenko 	case CLOCK_TAI:
1483971ddd4bSAndy Shevchenko 		break;
1484971ddd4bSAndy Shevchenko 	default:
1485bc2b7dabSGregor Boirie 		return -EINVAL;
1486971ddd4bSAndy Shevchenko 	}
1487bc2b7dabSGregor Boirie 
1488bc2b7dabSGregor Boirie 	ret = iio_device_set_clock(dev_to_iio_dev(dev), clk);
1489bc2b7dabSGregor Boirie 	if (ret)
1490bc2b7dabSGregor Boirie 		return ret;
1491bc2b7dabSGregor Boirie 
1492bc2b7dabSGregor Boirie 	return len;
1493bc2b7dabSGregor Boirie }
1494bc2b7dabSGregor Boirie 
149532f17172SAlexandru Ardelean int iio_device_register_sysfs_group(struct iio_dev *indio_dev,
149632f17172SAlexandru Ardelean 				    const struct attribute_group *group)
149732f17172SAlexandru Ardelean {
149832f17172SAlexandru Ardelean 	struct iio_dev_opaque *iio_dev_opaque = to_iio_dev_opaque(indio_dev);
149932f17172SAlexandru Ardelean 	const struct attribute_group **new, **old = iio_dev_opaque->groups;
150032f17172SAlexandru Ardelean 	unsigned int cnt = iio_dev_opaque->groupcounter;
150132f17172SAlexandru Ardelean 
15025a0821e0SAndy Shevchenko 	new = krealloc_array(old, cnt + 2, sizeof(*new), GFP_KERNEL);
150332f17172SAlexandru Ardelean 	if (!new)
150432f17172SAlexandru Ardelean 		return -ENOMEM;
150532f17172SAlexandru Ardelean 
150632f17172SAlexandru Ardelean 	new[iio_dev_opaque->groupcounter++] = group;
150732f17172SAlexandru Ardelean 	new[iio_dev_opaque->groupcounter] = NULL;
150832f17172SAlexandru Ardelean 
150932f17172SAlexandru Ardelean 	iio_dev_opaque->groups = new;
151032f17172SAlexandru Ardelean 
151132f17172SAlexandru Ardelean 	return 0;
151232f17172SAlexandru Ardelean }
151332f17172SAlexandru Ardelean 
15149cf0b618SJoe Simmons-Talbott static DEVICE_ATTR_RW(current_timestamp_clock);
1515bc2b7dabSGregor Boirie 
1516a980e046SJonathan Cameron static int iio_device_register_sysfs(struct iio_dev *indio_dev)
1517a980e046SJonathan Cameron {
1518207c2d27SAlexandru Ardelean 	struct iio_dev_opaque *iio_dev_opaque = to_iio_dev_opaque(indio_dev);
1519a980e046SJonathan Cameron 	int i, ret = 0, attrcount, attrn, attrcount_orig = 0;
152084088ebdSLars-Peter Clausen 	struct iio_dev_attr *p;
1521bc2b7dabSGregor Boirie 	struct attribute **attr, *clk = NULL;
1522a980e046SJonathan Cameron 
1523a980e046SJonathan Cameron 	/* First count elements in any existing group */
1524a980e046SJonathan Cameron 	if (indio_dev->info->attrs) {
1525a980e046SJonathan Cameron 		attr = indio_dev->info->attrs->attrs;
1526a980e046SJonathan Cameron 		while (*attr++ != NULL)
1527a980e046SJonathan Cameron 			attrcount_orig++;
1528a980e046SJonathan Cameron 	}
1529a980e046SJonathan Cameron 	attrcount = attrcount_orig;
1530a980e046SJonathan Cameron 	/*
1531a980e046SJonathan Cameron 	 * New channel registration method - relies on the fact a group does
1532d25b3808SPeter Meerwald 	 * not need to be initialized if its name is NULL.
1533a980e046SJonathan Cameron 	 */
1534a980e046SJonathan Cameron 	if (indio_dev->channels)
1535a980e046SJonathan Cameron 		for (i = 0; i < indio_dev->num_channels; i++) {
1536bc2b7dabSGregor Boirie 			const struct iio_chan_spec *chan =
1537bc2b7dabSGregor Boirie 				&indio_dev->channels[i];
1538bc2b7dabSGregor Boirie 
1539bc2b7dabSGregor Boirie 			if (chan->type == IIO_TIMESTAMP)
1540bc2b7dabSGregor Boirie 				clk = &dev_attr_current_timestamp_clock.attr;
1541bc2b7dabSGregor Boirie 
1542bc2b7dabSGregor Boirie 			ret = iio_device_add_channel_sysfs(indio_dev, chan);
1543a980e046SJonathan Cameron 			if (ret < 0)
1544a980e046SJonathan Cameron 				goto error_clear_attrs;
1545a980e046SJonathan Cameron 			attrcount += ret;
1546a980e046SJonathan Cameron 		}
1547a980e046SJonathan Cameron 
1548fa83c3baSAlexandru Ardelean 	if (iio_dev_opaque->event_interface)
1549bc2b7dabSGregor Boirie 		clk = &dev_attr_current_timestamp_clock.attr;
1550bc2b7dabSGregor Boirie 
1551a980e046SJonathan Cameron 	if (indio_dev->name)
1552a980e046SJonathan Cameron 		attrcount++;
15532c3d0c9fSPhil Reid 	if (indio_dev->label)
15542c3d0c9fSPhil Reid 		attrcount++;
1555bc2b7dabSGregor Boirie 	if (clk)
1556bc2b7dabSGregor Boirie 		attrcount++;
1557a980e046SJonathan Cameron 
1558207c2d27SAlexandru Ardelean 	iio_dev_opaque->chan_attr_group.attrs =
1559207c2d27SAlexandru Ardelean 		kcalloc(attrcount + 1,
1560207c2d27SAlexandru Ardelean 			sizeof(iio_dev_opaque->chan_attr_group.attrs[0]),
1561a980e046SJonathan Cameron 			GFP_KERNEL);
1562207c2d27SAlexandru Ardelean 	if (iio_dev_opaque->chan_attr_group.attrs == NULL) {
1563a980e046SJonathan Cameron 		ret = -ENOMEM;
1564a980e046SJonathan Cameron 		goto error_clear_attrs;
1565a980e046SJonathan Cameron 	}
1566e0d27ea3SAndrea Merello 	/* Copy across original attributes, and point to original binary attributes */
156718b4c9cdSHans de Goede 	if (indio_dev->info->attrs) {
1568207c2d27SAlexandru Ardelean 		memcpy(iio_dev_opaque->chan_attr_group.attrs,
1569a980e046SJonathan Cameron 		       indio_dev->info->attrs->attrs,
1570207c2d27SAlexandru Ardelean 		       sizeof(iio_dev_opaque->chan_attr_group.attrs[0])
1571a980e046SJonathan Cameron 		       *attrcount_orig);
157218b4c9cdSHans de Goede 		iio_dev_opaque->chan_attr_group.is_visible =
157318b4c9cdSHans de Goede 			indio_dev->info->attrs->is_visible;
1574e0d27ea3SAndrea Merello 		iio_dev_opaque->chan_attr_group.bin_attrs =
1575e0d27ea3SAndrea Merello 			indio_dev->info->attrs->bin_attrs;
157618b4c9cdSHans de Goede 	}
1577a980e046SJonathan Cameron 	attrn = attrcount_orig;
1578a980e046SJonathan Cameron 	/* Add all elements from the list. */
1579207c2d27SAlexandru Ardelean 	list_for_each_entry(p, &iio_dev_opaque->channel_attr_list, l)
1580207c2d27SAlexandru Ardelean 		iio_dev_opaque->chan_attr_group.attrs[attrn++] = &p->dev_attr.attr;
1581a980e046SJonathan Cameron 	if (indio_dev->name)
1582207c2d27SAlexandru Ardelean 		iio_dev_opaque->chan_attr_group.attrs[attrn++] = &dev_attr_name.attr;
15832c3d0c9fSPhil Reid 	if (indio_dev->label)
1584207c2d27SAlexandru Ardelean 		iio_dev_opaque->chan_attr_group.attrs[attrn++] = &dev_attr_label.attr;
1585bc2b7dabSGregor Boirie 	if (clk)
1586207c2d27SAlexandru Ardelean 		iio_dev_opaque->chan_attr_group.attrs[attrn++] = clk;
1587a980e046SJonathan Cameron 
158832f17172SAlexandru Ardelean 	ret = iio_device_register_sysfs_group(indio_dev,
158932f17172SAlexandru Ardelean 					      &iio_dev_opaque->chan_attr_group);
159032f17172SAlexandru Ardelean 	if (ret)
159195a0d596SDinghao Liu 		goto error_free_chan_attrs;
1592a980e046SJonathan Cameron 
1593a980e046SJonathan Cameron 	return 0;
1594a980e046SJonathan Cameron 
159595a0d596SDinghao Liu error_free_chan_attrs:
159695a0d596SDinghao Liu 	kfree(iio_dev_opaque->chan_attr_group.attrs);
159795a0d596SDinghao Liu 	iio_dev_opaque->chan_attr_group.attrs = NULL;
1598a980e046SJonathan Cameron error_clear_attrs:
1599207c2d27SAlexandru Ardelean 	iio_free_chan_devattr_list(&iio_dev_opaque->channel_attr_list);
1600a980e046SJonathan Cameron 
1601a980e046SJonathan Cameron 	return ret;
1602a980e046SJonathan Cameron }
1603a980e046SJonathan Cameron 
1604a980e046SJonathan Cameron static void iio_device_unregister_sysfs(struct iio_dev *indio_dev)
1605a980e046SJonathan Cameron {
1606207c2d27SAlexandru Ardelean 	struct iio_dev_opaque *iio_dev_opaque = to_iio_dev_opaque(indio_dev);
1607a980e046SJonathan Cameron 
1608207c2d27SAlexandru Ardelean 	iio_free_chan_devattr_list(&iio_dev_opaque->channel_attr_list);
1609207c2d27SAlexandru Ardelean 	kfree(iio_dev_opaque->chan_attr_group.attrs);
1610207c2d27SAlexandru Ardelean 	iio_dev_opaque->chan_attr_group.attrs = NULL;
161132f17172SAlexandru Ardelean 	kfree(iio_dev_opaque->groups);
161219833c40SYang Yingliang 	iio_dev_opaque->groups = NULL;
1613a980e046SJonathan Cameron }
1614a980e046SJonathan Cameron 
1615a980e046SJonathan Cameron static void iio_dev_release(struct device *device)
1616a980e046SJonathan Cameron {
1617e53f5ac5SLars-Peter Clausen 	struct iio_dev *indio_dev = dev_to_iio_dev(device);
16186d4ebd56SAlexandru Ardelean 	struct iio_dev_opaque *iio_dev_opaque = to_iio_dev_opaque(indio_dev);
16196d4ebd56SAlexandru Ardelean 
1620d89e119aSBenjamin Gaignard 	if (indio_dev->modes & INDIO_ALL_TRIGGERED_MODES)
1621a980e046SJonathan Cameron 		iio_device_unregister_trigger_consumer(indio_dev);
1622a980e046SJonathan Cameron 	iio_device_unregister_eventset(indio_dev);
1623a980e046SJonathan Cameron 	iio_device_unregister_sysfs(indio_dev);
1624e407fd65SLars-Peter Clausen 
1625218bc53dSAlexandru Ardelean 	iio_device_detach_buffers(indio_dev);
16269e69c935SLars-Peter Clausen 
16272bc9cd66SVincent Whitchurch 	lockdep_unregister_key(&iio_dev_opaque->mlock_key);
16282bc9cd66SVincent Whitchurch 
1629319dbcd8Skeliu 	ida_free(&iio_ida, iio_dev_opaque->id);
16306d4ebd56SAlexandru Ardelean 	kfree(iio_dev_opaque);
1631a980e046SJonathan Cameron }
1632a980e046SJonathan Cameron 
16333c33b7b8SLars-Peter Clausen const struct device_type iio_device_type = {
1634a980e046SJonathan Cameron 	.name = "iio_device",
1635a980e046SJonathan Cameron 	.release = iio_dev_release,
1636a980e046SJonathan Cameron };
1637a980e046SJonathan Cameron 
1638a7e57dceSSachin Kamat /**
1639a7e57dceSSachin Kamat  * iio_device_alloc() - allocate an iio_dev from a driver
1640c9561fd2SJonathan Cameron  * @parent:		Parent device.
1641a7e57dceSSachin Kamat  * @sizeof_priv:	Space to allocate for private structure.
164265659a8dSAndy Shevchenko  *
164365659a8dSAndy Shevchenko  * Returns:
164465659a8dSAndy Shevchenko  * Pointer to allocated iio_dev on success, NULL on failure.
164565659a8dSAndy Shevchenko  */
164678289b4aSAlexandru Ardelean struct iio_dev *iio_device_alloc(struct device *parent, int sizeof_priv)
1647a980e046SJonathan Cameron {
16486d4ebd56SAlexandru Ardelean 	struct iio_dev_opaque *iio_dev_opaque;
16490d596bb2SAlexandru Ardelean 	struct iio_dev *indio_dev;
1650a980e046SJonathan Cameron 	size_t alloc_size;
1651a980e046SJonathan Cameron 
16525c4e4115SAndy Shevchenko 	if (sizeof_priv)
16535c4e4115SAndy Shevchenko 		alloc_size = ALIGN(sizeof(*iio_dev_opaque), IIO_DMA_MINALIGN) + sizeof_priv;
16545c4e4115SAndy Shevchenko 	else
16555c4e4115SAndy Shevchenko 		alloc_size = sizeof(*iio_dev_opaque);
1656a980e046SJonathan Cameron 
16576d4ebd56SAlexandru Ardelean 	iio_dev_opaque = kzalloc(alloc_size, GFP_KERNEL);
16586d4ebd56SAlexandru Ardelean 	if (!iio_dev_opaque)
16590d4b2184SJonathan Cameron 		return NULL;
1660a980e046SJonathan Cameron 
16610d596bb2SAlexandru Ardelean 	indio_dev = &iio_dev_opaque->indio_dev;
1662f0245ab3SAndy Shevchenko 
1663f0245ab3SAndy Shevchenko 	if (sizeof_priv)
16640d596bb2SAlexandru Ardelean 		indio_dev->priv = (char *)iio_dev_opaque +
1665f0245ab3SAndy Shevchenko 			ALIGN(sizeof(*iio_dev_opaque), IIO_DMA_MINALIGN);
16666d4ebd56SAlexandru Ardelean 
16670d596bb2SAlexandru Ardelean 	indio_dev->dev.parent = parent;
16680d596bb2SAlexandru Ardelean 	indio_dev->dev.type = &iio_device_type;
16690d596bb2SAlexandru Ardelean 	indio_dev->dev.bus = &iio_bus_type;
16700d596bb2SAlexandru Ardelean 	device_initialize(&indio_dev->dev);
167116afe125SNuno Sá 	mutex_init(&iio_dev_opaque->mlock);
1672b804e2b7SJonathan Cameron 	mutex_init(&iio_dev_opaque->info_exist_lock);
1673207c2d27SAlexandru Ardelean 	INIT_LIST_HEAD(&iio_dev_opaque->channel_attr_list);
1674a980e046SJonathan Cameron 
1675319dbcd8Skeliu 	iio_dev_opaque->id = ida_alloc(&iio_ida, GFP_KERNEL);
167615ea2878SJonathan Cameron 	if (iio_dev_opaque->id < 0) {
1677a980e046SJonathan Cameron 		/* cannot use a dev_err as the name isn't available */
16783176dd5dSSachin Kamat 		pr_err("failed to get device id\n");
16796d4ebd56SAlexandru Ardelean 		kfree(iio_dev_opaque);
1680a980e046SJonathan Cameron 		return NULL;
1681a980e046SJonathan Cameron 	}
1682fe6f45f6SYang Yingliang 
1683fe6f45f6SYang Yingliang 	if (dev_set_name(&indio_dev->dev, "iio:device%d", iio_dev_opaque->id)) {
1684319dbcd8Skeliu 		ida_free(&iio_ida, iio_dev_opaque->id);
1685fe6f45f6SYang Yingliang 		kfree(iio_dev_opaque);
1686fe6f45f6SYang Yingliang 		return NULL;
1687fe6f45f6SYang Yingliang 	}
1688fe6f45f6SYang Yingliang 
16896a8c6b26SAlexandru Ardelean 	INIT_LIST_HEAD(&iio_dev_opaque->buffer_list);
16908dedcc3eSAlexandru Ardelean 	INIT_LIST_HEAD(&iio_dev_opaque->ioctl_handlers);
1691a980e046SJonathan Cameron 
16922bc9cd66SVincent Whitchurch 	lockdep_register_key(&iio_dev_opaque->mlock_key);
169316afe125SNuno Sá 	lockdep_set_class(&iio_dev_opaque->mlock, &iio_dev_opaque->mlock_key);
16942bc9cd66SVincent Whitchurch 
16950d596bb2SAlexandru Ardelean 	return indio_dev;
1696a980e046SJonathan Cameron }
16977cbb7537SLars-Peter Clausen EXPORT_SYMBOL(iio_device_alloc);
1698a980e046SJonathan Cameron 
1699a7e57dceSSachin Kamat /**
1700a7e57dceSSachin Kamat  * iio_device_free() - free an iio_dev from a driver
1701a7e57dceSSachin Kamat  * @dev:		the iio_dev associated with the device
170265659a8dSAndy Shevchenko  */
17037cbb7537SLars-Peter Clausen void iio_device_free(struct iio_dev *dev)
1704a980e046SJonathan Cameron {
1705e407fd65SLars-Peter Clausen 	if (dev)
1706e407fd65SLars-Peter Clausen 		put_device(&dev->dev);
1707a980e046SJonathan Cameron }
17087cbb7537SLars-Peter Clausen EXPORT_SYMBOL(iio_device_free);
1709a980e046SJonathan Cameron 
1710cf5724e9SYicong Yang static void devm_iio_device_release(void *iio_dev)
17119dabaf5eSGrygorii Strashko {
1712cf5724e9SYicong Yang 	iio_device_free(iio_dev);
17139dabaf5eSGrygorii Strashko }
17149dabaf5eSGrygorii Strashko 
1715a7e57dceSSachin Kamat /**
1716a7e57dceSSachin Kamat  * devm_iio_device_alloc - Resource-managed iio_device_alloc()
171778289b4aSAlexandru Ardelean  * @parent:		Device to allocate iio_dev for, and parent for this IIO device
1718a7e57dceSSachin Kamat  * @sizeof_priv:	Space to allocate for private structure.
1719a7e57dceSSachin Kamat  *
1720a7e57dceSSachin Kamat  * Managed iio_device_alloc. iio_dev allocated with this function is
1721a7e57dceSSachin Kamat  * automatically freed on driver detach.
1722a7e57dceSSachin Kamat  *
172365659a8dSAndy Shevchenko  * Returns:
1724a7e57dceSSachin Kamat  * Pointer to allocated iio_dev on success, NULL on failure.
1725a7e57dceSSachin Kamat  */
172678289b4aSAlexandru Ardelean struct iio_dev *devm_iio_device_alloc(struct device *parent, int sizeof_priv)
17279dabaf5eSGrygorii Strashko {
1728cf5724e9SYicong Yang 	struct iio_dev *iio_dev;
1729cf5724e9SYicong Yang 	int ret;
17309dabaf5eSGrygorii Strashko 
173178289b4aSAlexandru Ardelean 	iio_dev = iio_device_alloc(parent, sizeof_priv);
1732cf5724e9SYicong Yang 	if (!iio_dev)
1733cf5724e9SYicong Yang 		return NULL;
1734cf5724e9SYicong Yang 
1735cf5724e9SYicong Yang 	ret = devm_add_action_or_reset(parent, devm_iio_device_release,
1736cf5724e9SYicong Yang 				       iio_dev);
1737cf5724e9SYicong Yang 	if (ret)
173843fa7394SDan Carpenter 		return NULL;
17399dabaf5eSGrygorii Strashko 
17409dabaf5eSGrygorii Strashko 	return iio_dev;
17419dabaf5eSGrygorii Strashko }
17429dabaf5eSGrygorii Strashko EXPORT_SYMBOL_GPL(devm_iio_device_alloc);
17439dabaf5eSGrygorii Strashko 
1744a7e57dceSSachin Kamat /**
1745a980e046SJonathan Cameron  * iio_chrdev_open() - chrdev file open for buffer access and ioctls
17462498dcf6SCristina Opriceana  * @inode:	Inode structure for identifying the device in the file system
17472498dcf6SCristina Opriceana  * @filp:	File structure for iio device used to keep and later access
17482498dcf6SCristina Opriceana  *		private data
17492498dcf6SCristina Opriceana  *
175065659a8dSAndy Shevchenko  * Returns: 0 on success or -EBUSY if the device is already opened
175165659a8dSAndy Shevchenko  */
1752a980e046SJonathan Cameron static int iio_chrdev_open(struct inode *inode, struct file *filp)
1753a980e046SJonathan Cameron {
1754396f7234SJonathan Cameron 	struct iio_dev_opaque *iio_dev_opaque =
1755396f7234SJonathan Cameron 		container_of(inode->i_cdev, struct iio_dev_opaque, chrdev);
1756396f7234SJonathan Cameron 	struct iio_dev *indio_dev = &iio_dev_opaque->indio_dev;
1757be24dcb1SAlexandru Ardelean 	struct iio_dev_buffer_pair *ib;
1758a980e046SJonathan Cameron 
17598b1c82cbSJonathan Cameron 	if (test_and_set_bit(IIO_BUSY_BIT_POS, &iio_dev_opaque->flags))
1760a980e046SJonathan Cameron 		return -EBUSY;
1761a980e046SJonathan Cameron 
1762cadc2125SLars-Peter Clausen 	iio_device_get(indio_dev);
1763cadc2125SLars-Peter Clausen 
1764be24dcb1SAlexandru Ardelean 	ib = kmalloc(sizeof(*ib), GFP_KERNEL);
1765be24dcb1SAlexandru Ardelean 	if (!ib) {
1766be24dcb1SAlexandru Ardelean 		iio_device_put(indio_dev);
17678b1c82cbSJonathan Cameron 		clear_bit(IIO_BUSY_BIT_POS, &iio_dev_opaque->flags);
1768be24dcb1SAlexandru Ardelean 		return -ENOMEM;
1769be24dcb1SAlexandru Ardelean 	}
1770be24dcb1SAlexandru Ardelean 
1771be24dcb1SAlexandru Ardelean 	ib->indio_dev = indio_dev;
1772be24dcb1SAlexandru Ardelean 	ib->buffer = indio_dev->buffer;
1773be24dcb1SAlexandru Ardelean 
1774be24dcb1SAlexandru Ardelean 	filp->private_data = ib;
1775a980e046SJonathan Cameron 
1776a980e046SJonathan Cameron 	return 0;
1777a980e046SJonathan Cameron }
1778a980e046SJonathan Cameron 
1779a980e046SJonathan Cameron /**
1780a980e046SJonathan Cameron  * iio_chrdev_release() - chrdev file close buffer access and ioctls
17812498dcf6SCristina Opriceana  * @inode:	Inode structure pointer for the char device
17822498dcf6SCristina Opriceana  * @filp:	File structure pointer for the char device
17832498dcf6SCristina Opriceana  *
178465659a8dSAndy Shevchenko  * Returns: 0 for successful release.
17852498dcf6SCristina Opriceana  */
1786a980e046SJonathan Cameron static int iio_chrdev_release(struct inode *inode, struct file *filp)
1787a980e046SJonathan Cameron {
1788be24dcb1SAlexandru Ardelean 	struct iio_dev_buffer_pair *ib = filp->private_data;
1789396f7234SJonathan Cameron 	struct iio_dev_opaque *iio_dev_opaque =
1790396f7234SJonathan Cameron 		container_of(inode->i_cdev, struct iio_dev_opaque, chrdev);
1791396f7234SJonathan Cameron 	struct iio_dev *indio_dev = &iio_dev_opaque->indio_dev;
17929d9ec8d0SJoe Simmons-Talbott 
1793be24dcb1SAlexandru Ardelean 	kfree(ib);
17948b1c82cbSJonathan Cameron 	clear_bit(IIO_BUSY_BIT_POS, &iio_dev_opaque->flags);
1795cadc2125SLars-Peter Clausen 	iio_device_put(indio_dev);
1796cadc2125SLars-Peter Clausen 
1797a980e046SJonathan Cameron 	return 0;
1798a980e046SJonathan Cameron }
1799a980e046SJonathan Cameron 
18008dedcc3eSAlexandru Ardelean void iio_device_ioctl_handler_register(struct iio_dev *indio_dev,
18018dedcc3eSAlexandru Ardelean 				       struct iio_ioctl_handler *h)
18028dedcc3eSAlexandru Ardelean {
18038dedcc3eSAlexandru Ardelean 	struct iio_dev_opaque *iio_dev_opaque = to_iio_dev_opaque(indio_dev);
18048dedcc3eSAlexandru Ardelean 
18058dedcc3eSAlexandru Ardelean 	list_add_tail(&h->entry, &iio_dev_opaque->ioctl_handlers);
18068dedcc3eSAlexandru Ardelean }
18078dedcc3eSAlexandru Ardelean 
18088dedcc3eSAlexandru Ardelean void iio_device_ioctl_handler_unregister(struct iio_ioctl_handler *h)
18098dedcc3eSAlexandru Ardelean {
18108dedcc3eSAlexandru Ardelean 	list_del(&h->entry);
18118dedcc3eSAlexandru Ardelean }
18128dedcc3eSAlexandru Ardelean 
1813a980e046SJonathan Cameron static long iio_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
1814a980e046SJonathan Cameron {
1815be24dcb1SAlexandru Ardelean 	struct iio_dev_buffer_pair *ib = filp->private_data;
1816be24dcb1SAlexandru Ardelean 	struct iio_dev *indio_dev = ib->indio_dev;
18178dedcc3eSAlexandru Ardelean 	struct iio_dev_opaque *iio_dev_opaque = to_iio_dev_opaque(indio_dev);
18188dedcc3eSAlexandru Ardelean 	struct iio_ioctl_handler *h;
181942ea5992SNuno Sa 	int ret;
1820a980e046SJonathan Cameron 
182142ea5992SNuno Sa 	guard(mutex)(&iio_dev_opaque->info_exist_lock);
182265659a8dSAndy Shevchenko 	/*
18238dedcc3eSAlexandru Ardelean 	 * The NULL check here is required to prevent crashing when a device
18248dedcc3eSAlexandru Ardelean 	 * is being removed while userspace would still have open file handles
18258dedcc3eSAlexandru Ardelean 	 * to try to access this device.
18268dedcc3eSAlexandru Ardelean 	 */
1827f18e7a06SLars-Peter Clausen 	if (!indio_dev->info)
182842ea5992SNuno Sa 		return -ENODEV;
1829f18e7a06SLars-Peter Clausen 
18308dedcc3eSAlexandru Ardelean 	list_for_each_entry(h, &iio_dev_opaque->ioctl_handlers, entry) {
18318dedcc3eSAlexandru Ardelean 		ret = h->ioctl(indio_dev, filp, cmd, arg);
18328dedcc3eSAlexandru Ardelean 		if (ret != IIO_IOCTL_UNHANDLED)
183342ea5992SNuno Sa 			return ret;
1834a980e046SJonathan Cameron 	}
18358dedcc3eSAlexandru Ardelean 
183642ea5992SNuno Sa 	return -ENODEV;
1837a980e046SJonathan Cameron }
1838a980e046SJonathan Cameron 
1839a980e046SJonathan Cameron static const struct file_operations iio_buffer_fileops = {
1840a980e046SJonathan Cameron 	.owner = THIS_MODULE,
1841a980e046SJonathan Cameron 	.llseek = noop_llseek,
1842ee8caea0SAlexandru Ardelean 	.read = iio_buffer_read_outer_addr,
18439eeee3b0SMihail Chindris 	.write = iio_buffer_write_outer_addr,
1844ee8caea0SAlexandru Ardelean 	.poll = iio_buffer_poll_addr,
1845a980e046SJonathan Cameron 	.unlocked_ioctl = iio_ioctl,
18461832f2d8SArnd Bergmann 	.compat_ioctl = compat_ptr_ioctl,
1847ee8caea0SAlexandru Ardelean 	.open = iio_chrdev_open,
1848ee8caea0SAlexandru Ardelean 	.release = iio_chrdev_release,
1849a980e046SJonathan Cameron };
1850a980e046SJonathan Cameron 
18518ebaa3ffSAlexandru Ardelean static const struct file_operations iio_event_fileops = {
18528ebaa3ffSAlexandru Ardelean 	.owner = THIS_MODULE,
18538ebaa3ffSAlexandru Ardelean 	.llseek = noop_llseek,
18548ebaa3ffSAlexandru Ardelean 	.unlocked_ioctl = iio_ioctl,
18558ebaa3ffSAlexandru Ardelean 	.compat_ioctl = compat_ptr_ioctl,
18568ebaa3ffSAlexandru Ardelean 	.open = iio_chrdev_open,
18578ebaa3ffSAlexandru Ardelean 	.release = iio_chrdev_release,
18588ebaa3ffSAlexandru Ardelean };
18598ebaa3ffSAlexandru Ardelean 
18608f5d8727SVlad Dogaru static int iio_check_unique_scan_index(struct iio_dev *indio_dev)
18618f5d8727SVlad Dogaru {
18628f5d8727SVlad Dogaru 	int i, j;
18638f5d8727SVlad Dogaru 	const struct iio_chan_spec *channels = indio_dev->channels;
18648f5d8727SVlad Dogaru 
18658f5d8727SVlad Dogaru 	if (!(indio_dev->modes & INDIO_ALL_BUFFER_MODES))
18668f5d8727SVlad Dogaru 		return 0;
18678f5d8727SVlad Dogaru 
18688f5d8727SVlad Dogaru 	for (i = 0; i < indio_dev->num_channels - 1; i++) {
18698f5d8727SVlad Dogaru 		if (channels[i].scan_index < 0)
18708f5d8727SVlad Dogaru 			continue;
18718f5d8727SVlad Dogaru 		for (j = i + 1; j < indio_dev->num_channels; j++)
18728f5d8727SVlad Dogaru 			if (channels[i].scan_index == channels[j].scan_index) {
18738f5d8727SVlad Dogaru 				dev_err(&indio_dev->dev,
18748f5d8727SVlad Dogaru 					"Duplicate scan index %d\n",
18758f5d8727SVlad Dogaru 					channels[i].scan_index);
18768f5d8727SVlad Dogaru 				return -EINVAL;
18778f5d8727SVlad Dogaru 			}
18788f5d8727SVlad Dogaru 	}
18798f5d8727SVlad Dogaru 
18808f5d8727SVlad Dogaru 	return 0;
18818f5d8727SVlad Dogaru }
18828f5d8727SVlad Dogaru 
18830e0761f8SPaul Cercueil static int iio_check_extended_name(const struct iio_dev *indio_dev)
18840e0761f8SPaul Cercueil {
18850e0761f8SPaul Cercueil 	unsigned int i;
18860e0761f8SPaul Cercueil 
18870e0761f8SPaul Cercueil 	if (!indio_dev->info->read_label)
18880e0761f8SPaul Cercueil 		return 0;
18890e0761f8SPaul Cercueil 
18900e0761f8SPaul Cercueil 	for (i = 0; i < indio_dev->num_channels; i++) {
18910e0761f8SPaul Cercueil 		if (indio_dev->channels[i].extend_name) {
18920e0761f8SPaul Cercueil 			dev_err(&indio_dev->dev,
18930e0761f8SPaul Cercueil 				"Cannot use labels and extend_name at the same time\n");
18940e0761f8SPaul Cercueil 			return -EINVAL;
18950e0761f8SPaul Cercueil 		}
18960e0761f8SPaul Cercueil 	}
18970e0761f8SPaul Cercueil 
18980e0761f8SPaul Cercueil 	return 0;
18990e0761f8SPaul Cercueil }
19000e0761f8SPaul Cercueil 
1901a980e046SJonathan Cameron static const struct iio_buffer_setup_ops noop_ring_setup_ops;
1902a980e046SJonathan Cameron 
19032718f154SMatti Vaittinen static void iio_sanity_check_avail_scan_masks(struct iio_dev *indio_dev)
19042718f154SMatti Vaittinen {
19052718f154SMatti Vaittinen 	unsigned int num_masks, masklength, longs_per_mask;
19062718f154SMatti Vaittinen 	const unsigned long *av_masks;
19072718f154SMatti Vaittinen 	int i;
19082718f154SMatti Vaittinen 
19092718f154SMatti Vaittinen 	av_masks = indio_dev->available_scan_masks;
19102718f154SMatti Vaittinen 	masklength = indio_dev->masklength;
19112718f154SMatti Vaittinen 	longs_per_mask = BITS_TO_LONGS(masklength);
19122718f154SMatti Vaittinen 
19132718f154SMatti Vaittinen 	/*
19142718f154SMatti Vaittinen 	 * The code determining how many available_scan_masks is in the array
19152718f154SMatti Vaittinen 	 * will be assuming the end of masks when first long with all bits
19162718f154SMatti Vaittinen 	 * zeroed is encountered. This is incorrect for masks where mask
19172718f154SMatti Vaittinen 	 * consists of more than one long, and where some of the available masks
19182718f154SMatti Vaittinen 	 * has long worth of bits zeroed (but has subsequent bit(s) set). This
19192718f154SMatti Vaittinen 	 * is a safety measure against bug where array of masks is terminated by
19202718f154SMatti Vaittinen 	 * a single zero while mask width is greater than width of a long.
19212718f154SMatti Vaittinen 	 */
19222718f154SMatti Vaittinen 	if (longs_per_mask > 1)
19232718f154SMatti Vaittinen 		dev_warn(indio_dev->dev.parent,
19242718f154SMatti Vaittinen 			 "multi long available scan masks not fully supported\n");
19252718f154SMatti Vaittinen 
19262718f154SMatti Vaittinen 	if (bitmap_empty(av_masks, masklength))
19272718f154SMatti Vaittinen 		dev_warn(indio_dev->dev.parent, "empty scan mask\n");
19282718f154SMatti Vaittinen 
19292718f154SMatti Vaittinen 	for (num_masks = 0; *av_masks; num_masks++)
19302718f154SMatti Vaittinen 		av_masks += longs_per_mask;
19312718f154SMatti Vaittinen 
19322718f154SMatti Vaittinen 	if (num_masks < 2)
19332718f154SMatti Vaittinen 		return;
19342718f154SMatti Vaittinen 
19352718f154SMatti Vaittinen 	av_masks = indio_dev->available_scan_masks;
19362718f154SMatti Vaittinen 
19372718f154SMatti Vaittinen 	/*
19382718f154SMatti Vaittinen 	 * Go through all the masks from first to one before the last, and see
19392718f154SMatti Vaittinen 	 * that no mask found later from the available_scan_masks array is a
19402718f154SMatti Vaittinen 	 * subset of mask found earlier. If this happens, then the mask found
19412718f154SMatti Vaittinen 	 * later will never get used because scanning the array is stopped when
19422718f154SMatti Vaittinen 	 * the first suitable mask is found. Drivers should order the array of
19432718f154SMatti Vaittinen 	 * available masks in the order of preference (presumably the least
19442718f154SMatti Vaittinen 	 * costy to access masks first).
19452718f154SMatti Vaittinen 	 */
19462718f154SMatti Vaittinen 	for (i = 0; i < num_masks - 1; i++) {
19472718f154SMatti Vaittinen 		const unsigned long *mask1;
19482718f154SMatti Vaittinen 		int j;
19492718f154SMatti Vaittinen 
19502718f154SMatti Vaittinen 		mask1 = av_masks + i * longs_per_mask;
19512718f154SMatti Vaittinen 		for (j = i + 1; j < num_masks; j++) {
19522718f154SMatti Vaittinen 			const unsigned long *mask2;
19532718f154SMatti Vaittinen 
19542718f154SMatti Vaittinen 			mask2 = av_masks + j * longs_per_mask;
19552718f154SMatti Vaittinen 			if (bitmap_subset(mask2, mask1, masklength))
19562718f154SMatti Vaittinen 				dev_warn(indio_dev->dev.parent,
19572718f154SMatti Vaittinen 					 "available_scan_mask %d subset of %d. Never used\n",
19582718f154SMatti Vaittinen 					 j, i);
19592718f154SMatti Vaittinen 		}
19602718f154SMatti Vaittinen 	}
19612718f154SMatti Vaittinen }
19622718f154SMatti Vaittinen 
196363b19547SJonathan Cameron int __iio_device_register(struct iio_dev *indio_dev, struct module *this_mod)
1964a980e046SJonathan Cameron {
19658ebaa3ffSAlexandru Ardelean 	struct iio_dev_opaque *iio_dev_opaque = to_iio_dev_opaque(indio_dev);
1966b2a69969SMilan Zamazal 	struct fwnode_handle *fwnode = NULL;
1967a980e046SJonathan Cameron 	int ret;
1968a980e046SJonathan Cameron 
1969a17cb784SAlexandru Ardelean 	if (!indio_dev->info)
1970a17cb784SAlexandru Ardelean 		return -EINVAL;
1971a17cb784SAlexandru Ardelean 
19726eaf9f6aSJonathan Cameron 	iio_dev_opaque->driver_module = this_mod;
197317d82b47SGuenter Roeck 
197481366556SAndy Shevchenko 	/* If the calling driver did not initialize firmware node, do it here */
197581366556SAndy Shevchenko 	if (dev_fwnode(&indio_dev->dev))
197681366556SAndy Shevchenko 		fwnode = dev_fwnode(&indio_dev->dev);
1977b2a69969SMilan Zamazal 	/* The default dummy IIO device has no parent */
1978b2a69969SMilan Zamazal 	else if (indio_dev->dev.parent)
197981366556SAndy Shevchenko 		fwnode = dev_fwnode(indio_dev->dev.parent);
198081366556SAndy Shevchenko 	device_set_node(&indio_dev->dev, fwnode);
198181366556SAndy Shevchenko 
198281366556SAndy Shevchenko 	fwnode_property_read_string(fwnode, "label", &indio_dev->label);
19832c3d0c9fSPhil Reid 
19848f5d8727SVlad Dogaru 	ret = iio_check_unique_scan_index(indio_dev);
19858f5d8727SVlad Dogaru 	if (ret < 0)
19868f5d8727SVlad Dogaru 		return ret;
19878f5d8727SVlad Dogaru 
19880e0761f8SPaul Cercueil 	ret = iio_check_extended_name(indio_dev);
19890e0761f8SPaul Cercueil 	if (ret < 0)
19900e0761f8SPaul Cercueil 		return ret;
19910e0761f8SPaul Cercueil 
19928915aacaSGreg Kroah-Hartman 	iio_device_register_debugfs(indio_dev);
19933e1b6c95SLars-Peter Clausen 
1994ee708e6bSAlexandru Ardelean 	ret = iio_buffers_alloc_sysfs_and_mask(indio_dev);
19953e1b6c95SLars-Peter Clausen 	if (ret) {
19963e1b6c95SLars-Peter Clausen 		dev_err(indio_dev->dev.parent,
19973e1b6c95SLars-Peter Clausen 			"Failed to create buffer sysfs interfaces\n");
19983e1b6c95SLars-Peter Clausen 		goto error_unreg_debugfs;
19993e1b6c95SLars-Peter Clausen 	}
20003e1b6c95SLars-Peter Clausen 
20012718f154SMatti Vaittinen 	if (indio_dev->available_scan_masks)
20022718f154SMatti Vaittinen 		iio_sanity_check_avail_scan_masks(indio_dev);
20032718f154SMatti Vaittinen 
2004a980e046SJonathan Cameron 	ret = iio_device_register_sysfs(indio_dev);
2005a980e046SJonathan Cameron 	if (ret) {
2006a980e046SJonathan Cameron 		dev_err(indio_dev->dev.parent,
2007a980e046SJonathan Cameron 			"Failed to register sysfs interfaces\n");
20083e1b6c95SLars-Peter Clausen 		goto error_buffer_free_sysfs;
2009a980e046SJonathan Cameron 	}
2010a980e046SJonathan Cameron 	ret = iio_device_register_eventset(indio_dev);
2011a980e046SJonathan Cameron 	if (ret) {
2012a980e046SJonathan Cameron 		dev_err(indio_dev->dev.parent,
2013a980e046SJonathan Cameron 			"Failed to register event set\n");
2014a980e046SJonathan Cameron 		goto error_free_sysfs;
2015a980e046SJonathan Cameron 	}
2016d89e119aSBenjamin Gaignard 	if (indio_dev->modes & INDIO_ALL_TRIGGERED_MODES)
2017a980e046SJonathan Cameron 		iio_device_register_trigger_consumer(indio_dev);
2018a980e046SJonathan Cameron 
2019a980e046SJonathan Cameron 	if ((indio_dev->modes & INDIO_ALL_BUFFER_MODES) &&
2020a980e046SJonathan Cameron 		indio_dev->setup_ops == NULL)
2021a980e046SJonathan Cameron 		indio_dev->setup_ops = &noop_ring_setup_ops;
2022a980e046SJonathan Cameron 
2023ee708e6bSAlexandru Ardelean 	if (iio_dev_opaque->attached_buffers_cnt)
2024396f7234SJonathan Cameron 		cdev_init(&iio_dev_opaque->chrdev, &iio_buffer_fileops);
20258ebaa3ffSAlexandru Ardelean 	else if (iio_dev_opaque->event_interface)
2026396f7234SJonathan Cameron 		cdev_init(&iio_dev_opaque->chrdev, &iio_event_fileops);
202763b19547SJonathan Cameron 
2028ee708e6bSAlexandru Ardelean 	if (iio_dev_opaque->attached_buffers_cnt || iio_dev_opaque->event_interface) {
202915ea2878SJonathan Cameron 		indio_dev->dev.devt = MKDEV(MAJOR(iio_devt), iio_dev_opaque->id);
2030396f7234SJonathan Cameron 		iio_dev_opaque->chrdev.owner = this_mod;
20318ebaa3ffSAlexandru Ardelean 	}
203238923911SLogan Gunthorpe 
203332f17172SAlexandru Ardelean 	/* assign device groups now; they should be all registered now */
203432f17172SAlexandru Ardelean 	indio_dev->dev.groups = iio_dev_opaque->groups;
203532f17172SAlexandru Ardelean 
2036396f7234SJonathan Cameron 	ret = cdev_device_add(&iio_dev_opaque->chrdev, &indio_dev->dev);
2037a980e046SJonathan Cameron 	if (ret < 0)
20380d5b7daeSLars-Peter Clausen 		goto error_unreg_eventset;
2039a980e046SJonathan Cameron 
20400d5b7daeSLars-Peter Clausen 	return 0;
204138923911SLogan Gunthorpe 
2042a980e046SJonathan Cameron error_unreg_eventset:
2043a980e046SJonathan Cameron 	iio_device_unregister_eventset(indio_dev);
2044a980e046SJonathan Cameron error_free_sysfs:
2045a980e046SJonathan Cameron 	iio_device_unregister_sysfs(indio_dev);
20463e1b6c95SLars-Peter Clausen error_buffer_free_sysfs:
2047ee708e6bSAlexandru Ardelean 	iio_buffers_free_sysfs_and_mask(indio_dev);
2048a980e046SJonathan Cameron error_unreg_debugfs:
2049a980e046SJonathan Cameron 	iio_device_unregister_debugfs(indio_dev);
2050a980e046SJonathan Cameron 	return ret;
2051a980e046SJonathan Cameron }
205263b19547SJonathan Cameron EXPORT_SYMBOL(__iio_device_register);
2053a980e046SJonathan Cameron 
2054a7e57dceSSachin Kamat /**
2055a7e57dceSSachin Kamat  * iio_device_unregister() - unregister a device from the IIO subsystem
2056a7e57dceSSachin Kamat  * @indio_dev:		Device structure representing the device.
205765659a8dSAndy Shevchenko  */
2058a980e046SJonathan Cameron void iio_device_unregister(struct iio_dev *indio_dev)
2059a980e046SJonathan Cameron {
2060396f7234SJonathan Cameron 	struct iio_dev_opaque *iio_dev_opaque = to_iio_dev_opaque(indio_dev);
2061396f7234SJonathan Cameron 
2062396f7234SJonathan Cameron 	cdev_device_del(&iio_dev_opaque->chrdev, &indio_dev->dev);
2063a87c82e4SLars-Peter Clausen 
206442ea5992SNuno Sa 	scoped_guard(mutex, &iio_dev_opaque->info_exist_lock) {
2065bc4c9612SLars-Peter Clausen 		iio_device_unregister_debugfs(indio_dev);
20660d5b7daeSLars-Peter Clausen 
2067a87c82e4SLars-Peter Clausen 		iio_disable_all_buffers(indio_dev);
2068a87c82e4SLars-Peter Clausen 
2069a980e046SJonathan Cameron 		indio_dev->info = NULL;
2070d2f0a48fSLars-Peter Clausen 
2071d2f0a48fSLars-Peter Clausen 		iio_device_wakeup_eventset(indio_dev);
2072d2f0a48fSLars-Peter Clausen 		iio_buffer_wakeup_poll(indio_dev);
207342ea5992SNuno Sa 	}
20743e1b6c95SLars-Peter Clausen 
2075ee708e6bSAlexandru Ardelean 	iio_buffers_free_sysfs_and_mask(indio_dev);
2076a980e046SJonathan Cameron }
2077a980e046SJonathan Cameron EXPORT_SYMBOL(iio_device_unregister);
20788caa07c0SSachin Kamat 
2079cf5724e9SYicong Yang static void devm_iio_device_unreg(void *indio_dev)
20808caa07c0SSachin Kamat {
2081cf5724e9SYicong Yang 	iio_device_unregister(indio_dev);
20828caa07c0SSachin Kamat }
20838caa07c0SSachin Kamat 
208463b19547SJonathan Cameron int __devm_iio_device_register(struct device *dev, struct iio_dev *indio_dev,
208563b19547SJonathan Cameron 			       struct module *this_mod)
20868caa07c0SSachin Kamat {
20878caa07c0SSachin Kamat 	int ret;
20888caa07c0SSachin Kamat 
208963b19547SJonathan Cameron 	ret = __iio_device_register(indio_dev, this_mod);
2090cf5724e9SYicong Yang 	if (ret)
20918caa07c0SSachin Kamat 		return ret;
2092cf5724e9SYicong Yang 
2093cf5724e9SYicong Yang 	return devm_add_action_or_reset(dev, devm_iio_device_unreg, indio_dev);
20948caa07c0SSachin Kamat }
209563b19547SJonathan Cameron EXPORT_SYMBOL_GPL(__devm_iio_device_register);
20968caa07c0SSachin Kamat 
20978caa07c0SSachin Kamat /**
209808a33805SAlison Schofield  * iio_device_claim_direct_mode - Keep device in direct mode
209908a33805SAlison Schofield  * @indio_dev:	the iio_dev associated with the device
210008a33805SAlison Schofield  *
210108a33805SAlison Schofield  * If the device is in direct mode it is guaranteed to stay
210208a33805SAlison Schofield  * that way until iio_device_release_direct_mode() is called.
210308a33805SAlison Schofield  *
210408a33805SAlison Schofield  * Use with iio_device_release_direct_mode()
210508a33805SAlison Schofield  *
210665659a8dSAndy Shevchenko  * Returns: 0 on success, -EBUSY on failure.
210708a33805SAlison Schofield  */
210808a33805SAlison Schofield int iio_device_claim_direct_mode(struct iio_dev *indio_dev)
210908a33805SAlison Schofield {
211016afe125SNuno Sá 	struct iio_dev_opaque *iio_dev_opaque = to_iio_dev_opaque(indio_dev);
211116afe125SNuno Sá 
211216afe125SNuno Sá 	mutex_lock(&iio_dev_opaque->mlock);
211308a33805SAlison Schofield 
211408a33805SAlison Schofield 	if (iio_buffer_enabled(indio_dev)) {
211516afe125SNuno Sá 		mutex_unlock(&iio_dev_opaque->mlock);
211608a33805SAlison Schofield 		return -EBUSY;
211708a33805SAlison Schofield 	}
211808a33805SAlison Schofield 	return 0;
211908a33805SAlison Schofield }
212008a33805SAlison Schofield EXPORT_SYMBOL_GPL(iio_device_claim_direct_mode);
212108a33805SAlison Schofield 
212208a33805SAlison Schofield /**
212308a33805SAlison Schofield  * iio_device_release_direct_mode - releases claim on direct mode
212408a33805SAlison Schofield  * @indio_dev:	the iio_dev associated with the device
212508a33805SAlison Schofield  *
212608a33805SAlison Schofield  * Release the claim. Device is no longer guaranteed to stay
212708a33805SAlison Schofield  * in direct mode.
212808a33805SAlison Schofield  *
212908a33805SAlison Schofield  * Use with iio_device_claim_direct_mode()
213008a33805SAlison Schofield  */
213108a33805SAlison Schofield void iio_device_release_direct_mode(struct iio_dev *indio_dev)
213208a33805SAlison Schofield {
213316afe125SNuno Sá 	mutex_unlock(&to_iio_dev_opaque(indio_dev)->mlock);
213408a33805SAlison Schofield }
213508a33805SAlison Schofield EXPORT_SYMBOL_GPL(iio_device_release_direct_mode);
213608a33805SAlison Schofield 
21378c576f87SMiquel Raynal /**
21380a856542SNuno Sá  * iio_device_claim_buffer_mode - Keep device in buffer mode
21390a856542SNuno Sá  * @indio_dev:	the iio_dev associated with the device
21400a856542SNuno Sá  *
21410a856542SNuno Sá  * If the device is in buffer mode it is guaranteed to stay
21420a856542SNuno Sá  * that way until iio_device_release_buffer_mode() is called.
21430a856542SNuno Sá  *
21440a856542SNuno Sá  * Use with iio_device_release_buffer_mode().
21450a856542SNuno Sá  *
21460a856542SNuno Sá  * Returns: 0 on success, -EBUSY on failure.
21470a856542SNuno Sá  */
21480a856542SNuno Sá int iio_device_claim_buffer_mode(struct iio_dev *indio_dev)
21490a856542SNuno Sá {
215016afe125SNuno Sá 	struct iio_dev_opaque *iio_dev_opaque = to_iio_dev_opaque(indio_dev);
215116afe125SNuno Sá 
215216afe125SNuno Sá 	mutex_lock(&iio_dev_opaque->mlock);
21530a856542SNuno Sá 
21540a856542SNuno Sá 	if (iio_buffer_enabled(indio_dev))
21550a856542SNuno Sá 		return 0;
21560a856542SNuno Sá 
215716afe125SNuno Sá 	mutex_unlock(&iio_dev_opaque->mlock);
21580a856542SNuno Sá 	return -EBUSY;
21590a856542SNuno Sá }
21600a856542SNuno Sá EXPORT_SYMBOL_GPL(iio_device_claim_buffer_mode);
21610a856542SNuno Sá 
21620a856542SNuno Sá /**
21630a856542SNuno Sá  * iio_device_release_buffer_mode - releases claim on buffer mode
21640a856542SNuno Sá  * @indio_dev:	the iio_dev associated with the device
21650a856542SNuno Sá  *
21660a856542SNuno Sá  * Release the claim. Device is no longer guaranteed to stay
21670a856542SNuno Sá  * in buffer mode.
21680a856542SNuno Sá  *
21690a856542SNuno Sá  * Use with iio_device_claim_buffer_mode().
21700a856542SNuno Sá  */
21710a856542SNuno Sá void iio_device_release_buffer_mode(struct iio_dev *indio_dev)
21720a856542SNuno Sá {
217316afe125SNuno Sá 	mutex_unlock(&to_iio_dev_opaque(indio_dev)->mlock);
21740a856542SNuno Sá }
21750a856542SNuno Sá EXPORT_SYMBOL_GPL(iio_device_release_buffer_mode);
21760a856542SNuno Sá 
21770a856542SNuno Sá /**
21788c576f87SMiquel Raynal  * iio_device_get_current_mode() - helper function providing read-only access to
217951570c9dSMiquel Raynal  *				   the opaque @currentmode variable
21808c576f87SMiquel Raynal  * @indio_dev:			   IIO device structure for device
21818c576f87SMiquel Raynal  */
21828c576f87SMiquel Raynal int iio_device_get_current_mode(struct iio_dev *indio_dev)
21838c576f87SMiquel Raynal {
218451570c9dSMiquel Raynal 	struct iio_dev_opaque *iio_dev_opaque = to_iio_dev_opaque(indio_dev);
218551570c9dSMiquel Raynal 
218651570c9dSMiquel Raynal 	return iio_dev_opaque->currentmode;
21878c576f87SMiquel Raynal }
21888c576f87SMiquel Raynal EXPORT_SYMBOL_GPL(iio_device_get_current_mode);
21898c576f87SMiquel Raynal 
2190a980e046SJonathan Cameron subsys_initcall(iio_init);
2191a980e046SJonathan Cameron module_exit(iio_exit);
2192a980e046SJonathan Cameron 
2193c8b95952SJonathan Cameron MODULE_AUTHOR("Jonathan Cameron <jic23@kernel.org>");
2194a980e046SJonathan Cameron MODULE_DESCRIPTION("Industrial I/O core");
2195a980e046SJonathan Cameron MODULE_LICENSE("GPL");
2196