1 /* The industrial I/O core
2  *
3  * Copyright (c) 2008 Jonathan Cameron
4  *
5  * This program is free software; you can redistribute it and/or modify it
6  * under the terms of the GNU General Public License version 2 as published by
7  * the Free Software Foundation.
8  *
9  * Based on elements of hwmon and input subsystems.
10  */
11 
12 #define pr_fmt(fmt) "iio-core: " fmt
13 
14 #include <linux/kernel.h>
15 #include <linux/module.h>
16 #include <linux/idr.h>
17 #include <linux/kdev_t.h>
18 #include <linux/err.h>
19 #include <linux/device.h>
20 #include <linux/fs.h>
21 #include <linux/poll.h>
22 #include <linux/sched.h>
23 #include <linux/wait.h>
24 #include <linux/cdev.h>
25 #include <linux/slab.h>
26 #include <linux/anon_inodes.h>
27 #include <linux/debugfs.h>
28 #include <linux/mutex.h>
29 #include <linux/iio/iio.h>
30 #include "iio_core.h"
31 #include "iio_core_trigger.h"
32 #include <linux/iio/sysfs.h>
33 #include <linux/iio/events.h>
34 #include <linux/iio/buffer.h>
35 #include <linux/iio/buffer_impl.h>
36 
37 /* IDA to assign each registered device a unique id */
38 static DEFINE_IDA(iio_ida);
39 
40 static dev_t iio_devt;
41 
42 #define IIO_DEV_MAX 256
43 struct bus_type iio_bus_type = {
44 	.name = "iio",
45 };
46 EXPORT_SYMBOL(iio_bus_type);
47 
48 static struct dentry *iio_debugfs_dentry;
49 
50 static const char * const iio_direction[] = {
51 	[0] = "in",
52 	[1] = "out",
53 };
54 
55 static const char * const iio_chan_type_name_spec[] = {
56 	[IIO_VOLTAGE] = "voltage",
57 	[IIO_CURRENT] = "current",
58 	[IIO_POWER] = "power",
59 	[IIO_ACCEL] = "accel",
60 	[IIO_ANGL_VEL] = "anglvel",
61 	[IIO_MAGN] = "magn",
62 	[IIO_LIGHT] = "illuminance",
63 	[IIO_INTENSITY] = "intensity",
64 	[IIO_PROXIMITY] = "proximity",
65 	[IIO_TEMP] = "temp",
66 	[IIO_INCLI] = "incli",
67 	[IIO_ROT] = "rot",
68 	[IIO_ANGL] = "angl",
69 	[IIO_TIMESTAMP] = "timestamp",
70 	[IIO_CAPACITANCE] = "capacitance",
71 	[IIO_ALTVOLTAGE] = "altvoltage",
72 	[IIO_CCT] = "cct",
73 	[IIO_PRESSURE] = "pressure",
74 	[IIO_HUMIDITYRELATIVE] = "humidityrelative",
75 	[IIO_ACTIVITY] = "activity",
76 	[IIO_STEPS] = "steps",
77 	[IIO_ENERGY] = "energy",
78 	[IIO_DISTANCE] = "distance",
79 	[IIO_VELOCITY] = "velocity",
80 	[IIO_CONCENTRATION] = "concentration",
81 	[IIO_RESISTANCE] = "resistance",
82 	[IIO_PH] = "ph",
83 	[IIO_UVINDEX] = "uvindex",
84 	[IIO_ELECTRICALCONDUCTIVITY] = "electricalconductivity",
85 	[IIO_COUNT] = "count",
86 	[IIO_INDEX] = "index",
87 	[IIO_GRAVITY]  = "gravity",
88 	[IIO_POSITIONRELATIVE]  = "positionrelative",
89 	[IIO_PHASE] = "phase",
90 };
91 
92 static const char * const iio_modifier_names[] = {
93 	[IIO_MOD_X] = "x",
94 	[IIO_MOD_Y] = "y",
95 	[IIO_MOD_Z] = "z",
96 	[IIO_MOD_X_AND_Y] = "x&y",
97 	[IIO_MOD_X_AND_Z] = "x&z",
98 	[IIO_MOD_Y_AND_Z] = "y&z",
99 	[IIO_MOD_X_AND_Y_AND_Z] = "x&y&z",
100 	[IIO_MOD_X_OR_Y] = "x|y",
101 	[IIO_MOD_X_OR_Z] = "x|z",
102 	[IIO_MOD_Y_OR_Z] = "y|z",
103 	[IIO_MOD_X_OR_Y_OR_Z] = "x|y|z",
104 	[IIO_MOD_ROOT_SUM_SQUARED_X_Y] = "sqrt(x^2+y^2)",
105 	[IIO_MOD_SUM_SQUARED_X_Y_Z] = "x^2+y^2+z^2",
106 	[IIO_MOD_LIGHT_BOTH] = "both",
107 	[IIO_MOD_LIGHT_IR] = "ir",
108 	[IIO_MOD_LIGHT_CLEAR] = "clear",
109 	[IIO_MOD_LIGHT_RED] = "red",
110 	[IIO_MOD_LIGHT_GREEN] = "green",
111 	[IIO_MOD_LIGHT_BLUE] = "blue",
112 	[IIO_MOD_LIGHT_UV] = "uv",
113 	[IIO_MOD_LIGHT_DUV] = "duv",
114 	[IIO_MOD_QUATERNION] = "quaternion",
115 	[IIO_MOD_TEMP_AMBIENT] = "ambient",
116 	[IIO_MOD_TEMP_OBJECT] = "object",
117 	[IIO_MOD_NORTH_MAGN] = "from_north_magnetic",
118 	[IIO_MOD_NORTH_TRUE] = "from_north_true",
119 	[IIO_MOD_NORTH_MAGN_TILT_COMP] = "from_north_magnetic_tilt_comp",
120 	[IIO_MOD_NORTH_TRUE_TILT_COMP] = "from_north_true_tilt_comp",
121 	[IIO_MOD_RUNNING] = "running",
122 	[IIO_MOD_JOGGING] = "jogging",
123 	[IIO_MOD_WALKING] = "walking",
124 	[IIO_MOD_STILL] = "still",
125 	[IIO_MOD_ROOT_SUM_SQUARED_X_Y_Z] = "sqrt(x^2+y^2+z^2)",
126 	[IIO_MOD_I] = "i",
127 	[IIO_MOD_Q] = "q",
128 	[IIO_MOD_CO2] = "co2",
129 	[IIO_MOD_VOC] = "voc",
130 };
131 
132 /* relies on pairs of these shared then separate */
133 static const char * const iio_chan_info_postfix[] = {
134 	[IIO_CHAN_INFO_RAW] = "raw",
135 	[IIO_CHAN_INFO_PROCESSED] = "input",
136 	[IIO_CHAN_INFO_SCALE] = "scale",
137 	[IIO_CHAN_INFO_OFFSET] = "offset",
138 	[IIO_CHAN_INFO_CALIBSCALE] = "calibscale",
139 	[IIO_CHAN_INFO_CALIBBIAS] = "calibbias",
140 	[IIO_CHAN_INFO_PEAK] = "peak_raw",
141 	[IIO_CHAN_INFO_PEAK_SCALE] = "peak_scale",
142 	[IIO_CHAN_INFO_QUADRATURE_CORRECTION_RAW] = "quadrature_correction_raw",
143 	[IIO_CHAN_INFO_AVERAGE_RAW] = "mean_raw",
144 	[IIO_CHAN_INFO_LOW_PASS_FILTER_3DB_FREQUENCY]
145 	= "filter_low_pass_3db_frequency",
146 	[IIO_CHAN_INFO_HIGH_PASS_FILTER_3DB_FREQUENCY]
147 	= "filter_high_pass_3db_frequency",
148 	[IIO_CHAN_INFO_SAMP_FREQ] = "sampling_frequency",
149 	[IIO_CHAN_INFO_FREQUENCY] = "frequency",
150 	[IIO_CHAN_INFO_PHASE] = "phase",
151 	[IIO_CHAN_INFO_HARDWAREGAIN] = "hardwaregain",
152 	[IIO_CHAN_INFO_HYSTERESIS] = "hysteresis",
153 	[IIO_CHAN_INFO_INT_TIME] = "integration_time",
154 	[IIO_CHAN_INFO_ENABLE] = "en",
155 	[IIO_CHAN_INFO_CALIBHEIGHT] = "calibheight",
156 	[IIO_CHAN_INFO_CALIBWEIGHT] = "calibweight",
157 	[IIO_CHAN_INFO_DEBOUNCE_COUNT] = "debounce_count",
158 	[IIO_CHAN_INFO_DEBOUNCE_TIME] = "debounce_time",
159 	[IIO_CHAN_INFO_CALIBEMISSIVITY] = "calibemissivity",
160 	[IIO_CHAN_INFO_OVERSAMPLING_RATIO] = "oversampling_ratio",
161 };
162 
163 /**
164  * iio_find_channel_from_si() - get channel from its scan index
165  * @indio_dev:		device
166  * @si:			scan index to match
167  */
168 const struct iio_chan_spec
169 *iio_find_channel_from_si(struct iio_dev *indio_dev, int si)
170 {
171 	int i;
172 
173 	for (i = 0; i < indio_dev->num_channels; i++)
174 		if (indio_dev->channels[i].scan_index == si)
175 			return &indio_dev->channels[i];
176 	return NULL;
177 }
178 
179 /* This turns up an awful lot */
180 ssize_t iio_read_const_attr(struct device *dev,
181 			    struct device_attribute *attr,
182 			    char *buf)
183 {
184 	return sprintf(buf, "%s\n", to_iio_const_attr(attr)->string);
185 }
186 EXPORT_SYMBOL(iio_read_const_attr);
187 
188 static int iio_device_set_clock(struct iio_dev *indio_dev, clockid_t clock_id)
189 {
190 	int ret;
191 	const struct iio_event_interface *ev_int = indio_dev->event_interface;
192 
193 	ret = mutex_lock_interruptible(&indio_dev->mlock);
194 	if (ret)
195 		return ret;
196 	if ((ev_int && iio_event_enabled(ev_int)) ||
197 	    iio_buffer_enabled(indio_dev)) {
198 		mutex_unlock(&indio_dev->mlock);
199 		return -EBUSY;
200 	}
201 	indio_dev->clock_id = clock_id;
202 	mutex_unlock(&indio_dev->mlock);
203 
204 	return 0;
205 }
206 
207 /**
208  * iio_get_time_ns() - utility function to get a time stamp for events etc
209  * @indio_dev: device
210  */
211 s64 iio_get_time_ns(const struct iio_dev *indio_dev)
212 {
213 	struct timespec64 tp;
214 
215 	switch (iio_device_get_clock(indio_dev)) {
216 	case CLOCK_REALTIME:
217 		return ktime_get_real_ns();
218 	case CLOCK_MONOTONIC:
219 		return ktime_get_ns();
220 	case CLOCK_MONOTONIC_RAW:
221 		return ktime_get_raw_ns();
222 	case CLOCK_REALTIME_COARSE:
223 		return ktime_to_ns(ktime_get_coarse_real());
224 	case CLOCK_MONOTONIC_COARSE:
225 		ktime_get_coarse_ts64(&tp);
226 		return timespec64_to_ns(&tp);
227 	case CLOCK_BOOTTIME:
228 		return ktime_get_boot_ns();
229 	case CLOCK_TAI:
230 		return ktime_get_tai_ns();
231 	default:
232 		BUG();
233 	}
234 }
235 EXPORT_SYMBOL(iio_get_time_ns);
236 
237 /**
238  * iio_get_time_res() - utility function to get time stamp clock resolution in
239  *                      nano seconds.
240  * @indio_dev: device
241  */
242 unsigned int iio_get_time_res(const struct iio_dev *indio_dev)
243 {
244 	switch (iio_device_get_clock(indio_dev)) {
245 	case CLOCK_REALTIME:
246 	case CLOCK_MONOTONIC:
247 	case CLOCK_MONOTONIC_RAW:
248 	case CLOCK_BOOTTIME:
249 	case CLOCK_TAI:
250 		return hrtimer_resolution;
251 	case CLOCK_REALTIME_COARSE:
252 	case CLOCK_MONOTONIC_COARSE:
253 		return LOW_RES_NSEC;
254 	default:
255 		BUG();
256 	}
257 }
258 EXPORT_SYMBOL(iio_get_time_res);
259 
260 static int __init iio_init(void)
261 {
262 	int ret;
263 
264 	/* Register sysfs bus */
265 	ret  = bus_register(&iio_bus_type);
266 	if (ret < 0) {
267 		pr_err("could not register bus type\n");
268 		goto error_nothing;
269 	}
270 
271 	ret = alloc_chrdev_region(&iio_devt, 0, IIO_DEV_MAX, "iio");
272 	if (ret < 0) {
273 		pr_err("failed to allocate char dev region\n");
274 		goto error_unregister_bus_type;
275 	}
276 
277 	iio_debugfs_dentry = debugfs_create_dir("iio", NULL);
278 
279 	return 0;
280 
281 error_unregister_bus_type:
282 	bus_unregister(&iio_bus_type);
283 error_nothing:
284 	return ret;
285 }
286 
287 static void __exit iio_exit(void)
288 {
289 	if (iio_devt)
290 		unregister_chrdev_region(iio_devt, IIO_DEV_MAX);
291 	bus_unregister(&iio_bus_type);
292 	debugfs_remove(iio_debugfs_dentry);
293 }
294 
295 #if defined(CONFIG_DEBUG_FS)
296 static ssize_t iio_debugfs_read_reg(struct file *file, char __user *userbuf,
297 			      size_t count, loff_t *ppos)
298 {
299 	struct iio_dev *indio_dev = file->private_data;
300 	char buf[20];
301 	unsigned val = 0;
302 	ssize_t len;
303 	int ret;
304 
305 	ret = indio_dev->info->debugfs_reg_access(indio_dev,
306 						  indio_dev->cached_reg_addr,
307 						  0, &val);
308 	if (ret) {
309 		dev_err(indio_dev->dev.parent, "%s: read failed\n", __func__);
310 		return ret;
311 	}
312 
313 	len = snprintf(buf, sizeof(buf), "0x%X\n", val);
314 
315 	return simple_read_from_buffer(userbuf, count, ppos, buf, len);
316 }
317 
318 static ssize_t iio_debugfs_write_reg(struct file *file,
319 		     const char __user *userbuf, size_t count, loff_t *ppos)
320 {
321 	struct iio_dev *indio_dev = file->private_data;
322 	unsigned reg, val;
323 	char buf[80];
324 	int ret;
325 
326 	count = min_t(size_t, count, (sizeof(buf)-1));
327 	if (copy_from_user(buf, userbuf, count))
328 		return -EFAULT;
329 
330 	buf[count] = 0;
331 
332 	ret = sscanf(buf, "%i %i", &reg, &val);
333 
334 	switch (ret) {
335 	case 1:
336 		indio_dev->cached_reg_addr = reg;
337 		break;
338 	case 2:
339 		indio_dev->cached_reg_addr = reg;
340 		ret = indio_dev->info->debugfs_reg_access(indio_dev, reg,
341 							  val, NULL);
342 		if (ret) {
343 			dev_err(indio_dev->dev.parent, "%s: write failed\n",
344 				__func__);
345 			return ret;
346 		}
347 		break;
348 	default:
349 		return -EINVAL;
350 	}
351 
352 	return count;
353 }
354 
355 static const struct file_operations iio_debugfs_reg_fops = {
356 	.open = simple_open,
357 	.read = iio_debugfs_read_reg,
358 	.write = iio_debugfs_write_reg,
359 };
360 
361 static void iio_device_unregister_debugfs(struct iio_dev *indio_dev)
362 {
363 	debugfs_remove_recursive(indio_dev->debugfs_dentry);
364 }
365 
366 static int iio_device_register_debugfs(struct iio_dev *indio_dev)
367 {
368 	struct dentry *d;
369 
370 	if (indio_dev->info->debugfs_reg_access == NULL)
371 		return 0;
372 
373 	if (!iio_debugfs_dentry)
374 		return 0;
375 
376 	indio_dev->debugfs_dentry =
377 		debugfs_create_dir(dev_name(&indio_dev->dev),
378 				   iio_debugfs_dentry);
379 	if (indio_dev->debugfs_dentry == NULL) {
380 		dev_warn(indio_dev->dev.parent,
381 			 "Failed to create debugfs directory\n");
382 		return -EFAULT;
383 	}
384 
385 	d = debugfs_create_file("direct_reg_access", 0644,
386 				indio_dev->debugfs_dentry,
387 				indio_dev, &iio_debugfs_reg_fops);
388 	if (!d) {
389 		iio_device_unregister_debugfs(indio_dev);
390 		return -ENOMEM;
391 	}
392 
393 	return 0;
394 }
395 #else
396 static int iio_device_register_debugfs(struct iio_dev *indio_dev)
397 {
398 	return 0;
399 }
400 
401 static void iio_device_unregister_debugfs(struct iio_dev *indio_dev)
402 {
403 }
404 #endif /* CONFIG_DEBUG_FS */
405 
406 static ssize_t iio_read_channel_ext_info(struct device *dev,
407 				     struct device_attribute *attr,
408 				     char *buf)
409 {
410 	struct iio_dev *indio_dev = dev_to_iio_dev(dev);
411 	struct iio_dev_attr *this_attr = to_iio_dev_attr(attr);
412 	const struct iio_chan_spec_ext_info *ext_info;
413 
414 	ext_info = &this_attr->c->ext_info[this_attr->address];
415 
416 	return ext_info->read(indio_dev, ext_info->private, this_attr->c, buf);
417 }
418 
419 static ssize_t iio_write_channel_ext_info(struct device *dev,
420 				     struct device_attribute *attr,
421 				     const char *buf,
422 					 size_t len)
423 {
424 	struct iio_dev *indio_dev = dev_to_iio_dev(dev);
425 	struct iio_dev_attr *this_attr = to_iio_dev_attr(attr);
426 	const struct iio_chan_spec_ext_info *ext_info;
427 
428 	ext_info = &this_attr->c->ext_info[this_attr->address];
429 
430 	return ext_info->write(indio_dev, ext_info->private,
431 			       this_attr->c, buf, len);
432 }
433 
434 ssize_t iio_enum_available_read(struct iio_dev *indio_dev,
435 	uintptr_t priv, const struct iio_chan_spec *chan, char *buf)
436 {
437 	const struct iio_enum *e = (const struct iio_enum *)priv;
438 	unsigned int i;
439 	size_t len = 0;
440 
441 	if (!e->num_items)
442 		return 0;
443 
444 	for (i = 0; i < e->num_items; ++i)
445 		len += scnprintf(buf + len, PAGE_SIZE - len, "%s ", e->items[i]);
446 
447 	/* replace last space with a newline */
448 	buf[len - 1] = '\n';
449 
450 	return len;
451 }
452 EXPORT_SYMBOL_GPL(iio_enum_available_read);
453 
454 ssize_t iio_enum_read(struct iio_dev *indio_dev,
455 	uintptr_t priv, const struct iio_chan_spec *chan, char *buf)
456 {
457 	const struct iio_enum *e = (const struct iio_enum *)priv;
458 	int i;
459 
460 	if (!e->get)
461 		return -EINVAL;
462 
463 	i = e->get(indio_dev, chan);
464 	if (i < 0)
465 		return i;
466 	else if (i >= e->num_items)
467 		return -EINVAL;
468 
469 	return snprintf(buf, PAGE_SIZE, "%s\n", e->items[i]);
470 }
471 EXPORT_SYMBOL_GPL(iio_enum_read);
472 
473 ssize_t iio_enum_write(struct iio_dev *indio_dev,
474 	uintptr_t priv, const struct iio_chan_spec *chan, const char *buf,
475 	size_t len)
476 {
477 	const struct iio_enum *e = (const struct iio_enum *)priv;
478 	int ret;
479 
480 	if (!e->set)
481 		return -EINVAL;
482 
483 	ret = __sysfs_match_string(e->items, e->num_items, buf);
484 	if (ret < 0)
485 		return ret;
486 
487 	ret = e->set(indio_dev, chan, ret);
488 	return ret ? ret : len;
489 }
490 EXPORT_SYMBOL_GPL(iio_enum_write);
491 
492 static const struct iio_mount_matrix iio_mount_idmatrix = {
493 	.rotation = {
494 		"1", "0", "0",
495 		"0", "1", "0",
496 		"0", "0", "1"
497 	}
498 };
499 
500 static int iio_setup_mount_idmatrix(const struct device *dev,
501 				    struct iio_mount_matrix *matrix)
502 {
503 	*matrix = iio_mount_idmatrix;
504 	dev_info(dev, "mounting matrix not found: using identity...\n");
505 	return 0;
506 }
507 
508 ssize_t iio_show_mount_matrix(struct iio_dev *indio_dev, uintptr_t priv,
509 			      const struct iio_chan_spec *chan, char *buf)
510 {
511 	const struct iio_mount_matrix *mtx = ((iio_get_mount_matrix_t *)
512 					      priv)(indio_dev, chan);
513 
514 	if (IS_ERR(mtx))
515 		return PTR_ERR(mtx);
516 
517 	if (!mtx)
518 		mtx = &iio_mount_idmatrix;
519 
520 	return snprintf(buf, PAGE_SIZE, "%s, %s, %s; %s, %s, %s; %s, %s, %s\n",
521 			mtx->rotation[0], mtx->rotation[1], mtx->rotation[2],
522 			mtx->rotation[3], mtx->rotation[4], mtx->rotation[5],
523 			mtx->rotation[6], mtx->rotation[7], mtx->rotation[8]);
524 }
525 EXPORT_SYMBOL_GPL(iio_show_mount_matrix);
526 
527 /**
528  * of_iio_read_mount_matrix() - retrieve iio device mounting matrix from
529  *                              device-tree "mount-matrix" property
530  * @dev:	device the mounting matrix property is assigned to
531  * @propname:	device specific mounting matrix property name
532  * @matrix:	where to store retrieved matrix
533  *
534  * If device is assigned no mounting matrix property, a default 3x3 identity
535  * matrix will be filled in.
536  *
537  * Return: 0 if success, or a negative error code on failure.
538  */
539 #ifdef CONFIG_OF
540 int of_iio_read_mount_matrix(const struct device *dev,
541 			     const char *propname,
542 			     struct iio_mount_matrix *matrix)
543 {
544 	if (dev->of_node) {
545 		int err = of_property_read_string_array(dev->of_node,
546 				propname, matrix->rotation,
547 				ARRAY_SIZE(iio_mount_idmatrix.rotation));
548 
549 		if (err == ARRAY_SIZE(iio_mount_idmatrix.rotation))
550 			return 0;
551 
552 		if (err >= 0)
553 			/* Invalid number of matrix entries. */
554 			return -EINVAL;
555 
556 		if (err != -EINVAL)
557 			/* Invalid matrix declaration format. */
558 			return err;
559 	}
560 
561 	/* Matrix was not declared at all: fallback to identity. */
562 	return iio_setup_mount_idmatrix(dev, matrix);
563 }
564 #else
565 int of_iio_read_mount_matrix(const struct device *dev,
566 			     const char *propname,
567 			     struct iio_mount_matrix *matrix)
568 {
569 	return iio_setup_mount_idmatrix(dev, matrix);
570 }
571 #endif
572 EXPORT_SYMBOL(of_iio_read_mount_matrix);
573 
574 static ssize_t __iio_format_value(char *buf, size_t len, unsigned int type,
575 				  int size, const int *vals)
576 {
577 	unsigned long long tmp;
578 	int tmp0, tmp1;
579 	bool scale_db = false;
580 
581 	switch (type) {
582 	case IIO_VAL_INT:
583 		return snprintf(buf, len, "%d", vals[0]);
584 	case IIO_VAL_INT_PLUS_MICRO_DB:
585 		scale_db = true;
586 		/* fall through */
587 	case IIO_VAL_INT_PLUS_MICRO:
588 		if (vals[1] < 0)
589 			return snprintf(buf, len, "-%d.%06u%s", abs(vals[0]),
590 					-vals[1], scale_db ? " dB" : "");
591 		else
592 			return snprintf(buf, len, "%d.%06u%s", vals[0], vals[1],
593 					scale_db ? " dB" : "");
594 	case IIO_VAL_INT_PLUS_NANO:
595 		if (vals[1] < 0)
596 			return snprintf(buf, len, "-%d.%09u", abs(vals[0]),
597 					-vals[1]);
598 		else
599 			return snprintf(buf, len, "%d.%09u", vals[0], vals[1]);
600 	case IIO_VAL_FRACTIONAL:
601 		tmp = div_s64((s64)vals[0] * 1000000000LL, vals[1]);
602 		tmp1 = vals[1];
603 		tmp0 = (int)div_s64_rem(tmp, 1000000000, &tmp1);
604 		return snprintf(buf, len, "%d.%09u", tmp0, abs(tmp1));
605 	case IIO_VAL_FRACTIONAL_LOG2:
606 		tmp = shift_right((s64)vals[0] * 1000000000LL, vals[1]);
607 		tmp0 = (int)div_s64_rem(tmp, 1000000000LL, &tmp1);
608 		return snprintf(buf, len, "%d.%09u", tmp0, abs(tmp1));
609 	case IIO_VAL_INT_MULTIPLE:
610 	{
611 		int i;
612 		int l = 0;
613 
614 		for (i = 0; i < size; ++i) {
615 			l += snprintf(&buf[l], len - l, "%d ", vals[i]);
616 			if (l >= len)
617 				break;
618 		}
619 		return l;
620 	}
621 	default:
622 		return 0;
623 	}
624 }
625 
626 /**
627  * iio_format_value() - Formats a IIO value into its string representation
628  * @buf:	The buffer to which the formatted value gets written
629  *		which is assumed to be big enough (i.e. PAGE_SIZE).
630  * @type:	One of the IIO_VAL_* constants. This decides how the val
631  *		and val2 parameters are formatted.
632  * @size:	Number of IIO value entries contained in vals
633  * @vals:	Pointer to the values, exact meaning depends on the
634  *		type parameter.
635  *
636  * Return: 0 by default, a negative number on failure or the
637  *	   total number of characters written for a type that belongs
638  *	   to the IIO_VAL_* constant.
639  */
640 ssize_t iio_format_value(char *buf, unsigned int type, int size, int *vals)
641 {
642 	ssize_t len;
643 
644 	len = __iio_format_value(buf, PAGE_SIZE, type, size, vals);
645 	if (len >= PAGE_SIZE - 1)
646 		return -EFBIG;
647 
648 	return len + sprintf(buf + len, "\n");
649 }
650 EXPORT_SYMBOL_GPL(iio_format_value);
651 
652 static ssize_t iio_read_channel_info(struct device *dev,
653 				     struct device_attribute *attr,
654 				     char *buf)
655 {
656 	struct iio_dev *indio_dev = dev_to_iio_dev(dev);
657 	struct iio_dev_attr *this_attr = to_iio_dev_attr(attr);
658 	int vals[INDIO_MAX_RAW_ELEMENTS];
659 	int ret;
660 	int val_len = 2;
661 
662 	if (indio_dev->info->read_raw_multi)
663 		ret = indio_dev->info->read_raw_multi(indio_dev, this_attr->c,
664 							INDIO_MAX_RAW_ELEMENTS,
665 							vals, &val_len,
666 							this_attr->address);
667 	else
668 		ret = indio_dev->info->read_raw(indio_dev, this_attr->c,
669 				    &vals[0], &vals[1], this_attr->address);
670 
671 	if (ret < 0)
672 		return ret;
673 
674 	return iio_format_value(buf, ret, val_len, vals);
675 }
676 
677 static ssize_t iio_format_avail_list(char *buf, const int *vals,
678 				     int type, int length)
679 {
680 	int i;
681 	ssize_t len = 0;
682 
683 	switch (type) {
684 	case IIO_VAL_INT:
685 		for (i = 0; i < length; i++) {
686 			len += __iio_format_value(buf + len, PAGE_SIZE - len,
687 						  type, 1, &vals[i]);
688 			if (len >= PAGE_SIZE)
689 				return -EFBIG;
690 			if (i < length - 1)
691 				len += snprintf(buf + len, PAGE_SIZE - len,
692 						" ");
693 			else
694 				len += snprintf(buf + len, PAGE_SIZE - len,
695 						"\n");
696 			if (len >= PAGE_SIZE)
697 				return -EFBIG;
698 		}
699 		break;
700 	default:
701 		for (i = 0; i < length / 2; i++) {
702 			len += __iio_format_value(buf + len, PAGE_SIZE - len,
703 						  type, 2, &vals[i * 2]);
704 			if (len >= PAGE_SIZE)
705 				return -EFBIG;
706 			if (i < length / 2 - 1)
707 				len += snprintf(buf + len, PAGE_SIZE - len,
708 						" ");
709 			else
710 				len += snprintf(buf + len, PAGE_SIZE - len,
711 						"\n");
712 			if (len >= PAGE_SIZE)
713 				return -EFBIG;
714 		}
715 	}
716 
717 	return len;
718 }
719 
720 static ssize_t iio_format_avail_range(char *buf, const int *vals, int type)
721 {
722 	int i;
723 	ssize_t len;
724 
725 	len = snprintf(buf, PAGE_SIZE, "[");
726 	switch (type) {
727 	case IIO_VAL_INT:
728 		for (i = 0; i < 3; i++) {
729 			len += __iio_format_value(buf + len, PAGE_SIZE - len,
730 						  type, 1, &vals[i]);
731 			if (len >= PAGE_SIZE)
732 				return -EFBIG;
733 			if (i < 2)
734 				len += snprintf(buf + len, PAGE_SIZE - len,
735 						" ");
736 			else
737 				len += snprintf(buf + len, PAGE_SIZE - len,
738 						"]\n");
739 			if (len >= PAGE_SIZE)
740 				return -EFBIG;
741 		}
742 		break;
743 	default:
744 		for (i = 0; i < 3; i++) {
745 			len += __iio_format_value(buf + len, PAGE_SIZE - len,
746 						  type, 2, &vals[i * 2]);
747 			if (len >= PAGE_SIZE)
748 				return -EFBIG;
749 			if (i < 2)
750 				len += snprintf(buf + len, PAGE_SIZE - len,
751 						" ");
752 			else
753 				len += snprintf(buf + len, PAGE_SIZE - len,
754 						"]\n");
755 			if (len >= PAGE_SIZE)
756 				return -EFBIG;
757 		}
758 	}
759 
760 	return len;
761 }
762 
763 static ssize_t iio_read_channel_info_avail(struct device *dev,
764 					   struct device_attribute *attr,
765 					   char *buf)
766 {
767 	struct iio_dev *indio_dev = dev_to_iio_dev(dev);
768 	struct iio_dev_attr *this_attr = to_iio_dev_attr(attr);
769 	const int *vals;
770 	int ret;
771 	int length;
772 	int type;
773 
774 	ret = indio_dev->info->read_avail(indio_dev, this_attr->c,
775 					  &vals, &type, &length,
776 					  this_attr->address);
777 
778 	if (ret < 0)
779 		return ret;
780 	switch (ret) {
781 	case IIO_AVAIL_LIST:
782 		return iio_format_avail_list(buf, vals, type, length);
783 	case IIO_AVAIL_RANGE:
784 		return iio_format_avail_range(buf, vals, type);
785 	default:
786 		return -EINVAL;
787 	}
788 }
789 
790 /**
791  * iio_str_to_fixpoint() - Parse a fixed-point number from a string
792  * @str: The string to parse
793  * @fract_mult: Multiplier for the first decimal place, should be a power of 10
794  * @integer: The integer part of the number
795  * @fract: The fractional part of the number
796  *
797  * Returns 0 on success, or a negative error code if the string could not be
798  * parsed.
799  */
800 int iio_str_to_fixpoint(const char *str, int fract_mult,
801 	int *integer, int *fract)
802 {
803 	int i = 0, f = 0;
804 	bool integer_part = true, negative = false;
805 
806 	if (fract_mult == 0) {
807 		*fract = 0;
808 
809 		return kstrtoint(str, 0, integer);
810 	}
811 
812 	if (str[0] == '-') {
813 		negative = true;
814 		str++;
815 	} else if (str[0] == '+') {
816 		str++;
817 	}
818 
819 	while (*str) {
820 		if ('0' <= *str && *str <= '9') {
821 			if (integer_part) {
822 				i = i * 10 + *str - '0';
823 			} else {
824 				f += fract_mult * (*str - '0');
825 				fract_mult /= 10;
826 			}
827 		} else if (*str == '\n') {
828 			if (*(str + 1) == '\0')
829 				break;
830 			else
831 				return -EINVAL;
832 		} else if (*str == '.' && integer_part) {
833 			integer_part = false;
834 		} else {
835 			return -EINVAL;
836 		}
837 		str++;
838 	}
839 
840 	if (negative) {
841 		if (i)
842 			i = -i;
843 		else
844 			f = -f;
845 	}
846 
847 	*integer = i;
848 	*fract = f;
849 
850 	return 0;
851 }
852 EXPORT_SYMBOL_GPL(iio_str_to_fixpoint);
853 
854 static ssize_t iio_write_channel_info(struct device *dev,
855 				      struct device_attribute *attr,
856 				      const char *buf,
857 				      size_t len)
858 {
859 	struct iio_dev *indio_dev = dev_to_iio_dev(dev);
860 	struct iio_dev_attr *this_attr = to_iio_dev_attr(attr);
861 	int ret, fract_mult = 100000;
862 	int integer, fract;
863 
864 	/* Assumes decimal - precision based on number of digits */
865 	if (!indio_dev->info->write_raw)
866 		return -EINVAL;
867 
868 	if (indio_dev->info->write_raw_get_fmt)
869 		switch (indio_dev->info->write_raw_get_fmt(indio_dev,
870 			this_attr->c, this_attr->address)) {
871 		case IIO_VAL_INT:
872 			fract_mult = 0;
873 			break;
874 		case IIO_VAL_INT_PLUS_MICRO:
875 			fract_mult = 100000;
876 			break;
877 		case IIO_VAL_INT_PLUS_NANO:
878 			fract_mult = 100000000;
879 			break;
880 		default:
881 			return -EINVAL;
882 		}
883 
884 	ret = iio_str_to_fixpoint(buf, fract_mult, &integer, &fract);
885 	if (ret)
886 		return ret;
887 
888 	ret = indio_dev->info->write_raw(indio_dev, this_attr->c,
889 					 integer, fract, this_attr->address);
890 	if (ret)
891 		return ret;
892 
893 	return len;
894 }
895 
896 static
897 int __iio_device_attr_init(struct device_attribute *dev_attr,
898 			   const char *postfix,
899 			   struct iio_chan_spec const *chan,
900 			   ssize_t (*readfunc)(struct device *dev,
901 					       struct device_attribute *attr,
902 					       char *buf),
903 			   ssize_t (*writefunc)(struct device *dev,
904 						struct device_attribute *attr,
905 						const char *buf,
906 						size_t len),
907 			   enum iio_shared_by shared_by)
908 {
909 	int ret = 0;
910 	char *name = NULL;
911 	char *full_postfix;
912 	sysfs_attr_init(&dev_attr->attr);
913 
914 	/* Build up postfix of <extend_name>_<modifier>_postfix */
915 	if (chan->modified && (shared_by == IIO_SEPARATE)) {
916 		if (chan->extend_name)
917 			full_postfix = kasprintf(GFP_KERNEL, "%s_%s_%s",
918 						 iio_modifier_names[chan
919 								    ->channel2],
920 						 chan->extend_name,
921 						 postfix);
922 		else
923 			full_postfix = kasprintf(GFP_KERNEL, "%s_%s",
924 						 iio_modifier_names[chan
925 								    ->channel2],
926 						 postfix);
927 	} else {
928 		if (chan->extend_name == NULL || shared_by != IIO_SEPARATE)
929 			full_postfix = kstrdup(postfix, GFP_KERNEL);
930 		else
931 			full_postfix = kasprintf(GFP_KERNEL,
932 						 "%s_%s",
933 						 chan->extend_name,
934 						 postfix);
935 	}
936 	if (full_postfix == NULL)
937 		return -ENOMEM;
938 
939 	if (chan->differential) { /* Differential can not have modifier */
940 		switch (shared_by) {
941 		case IIO_SHARED_BY_ALL:
942 			name = kasprintf(GFP_KERNEL, "%s", full_postfix);
943 			break;
944 		case IIO_SHARED_BY_DIR:
945 			name = kasprintf(GFP_KERNEL, "%s_%s",
946 						iio_direction[chan->output],
947 						full_postfix);
948 			break;
949 		case IIO_SHARED_BY_TYPE:
950 			name = kasprintf(GFP_KERNEL, "%s_%s-%s_%s",
951 					    iio_direction[chan->output],
952 					    iio_chan_type_name_spec[chan->type],
953 					    iio_chan_type_name_spec[chan->type],
954 					    full_postfix);
955 			break;
956 		case IIO_SEPARATE:
957 			if (!chan->indexed) {
958 				WARN(1, "Differential channels must be indexed\n");
959 				ret = -EINVAL;
960 				goto error_free_full_postfix;
961 			}
962 			name = kasprintf(GFP_KERNEL,
963 					    "%s_%s%d-%s%d_%s",
964 					    iio_direction[chan->output],
965 					    iio_chan_type_name_spec[chan->type],
966 					    chan->channel,
967 					    iio_chan_type_name_spec[chan->type],
968 					    chan->channel2,
969 					    full_postfix);
970 			break;
971 		}
972 	} else { /* Single ended */
973 		switch (shared_by) {
974 		case IIO_SHARED_BY_ALL:
975 			name = kasprintf(GFP_KERNEL, "%s", full_postfix);
976 			break;
977 		case IIO_SHARED_BY_DIR:
978 			name = kasprintf(GFP_KERNEL, "%s_%s",
979 						iio_direction[chan->output],
980 						full_postfix);
981 			break;
982 		case IIO_SHARED_BY_TYPE:
983 			name = kasprintf(GFP_KERNEL, "%s_%s_%s",
984 					    iio_direction[chan->output],
985 					    iio_chan_type_name_spec[chan->type],
986 					    full_postfix);
987 			break;
988 
989 		case IIO_SEPARATE:
990 			if (chan->indexed)
991 				name = kasprintf(GFP_KERNEL, "%s_%s%d_%s",
992 						    iio_direction[chan->output],
993 						    iio_chan_type_name_spec[chan->type],
994 						    chan->channel,
995 						    full_postfix);
996 			else
997 				name = kasprintf(GFP_KERNEL, "%s_%s_%s",
998 						    iio_direction[chan->output],
999 						    iio_chan_type_name_spec[chan->type],
1000 						    full_postfix);
1001 			break;
1002 		}
1003 	}
1004 	if (name == NULL) {
1005 		ret = -ENOMEM;
1006 		goto error_free_full_postfix;
1007 	}
1008 	dev_attr->attr.name = name;
1009 
1010 	if (readfunc) {
1011 		dev_attr->attr.mode |= S_IRUGO;
1012 		dev_attr->show = readfunc;
1013 	}
1014 
1015 	if (writefunc) {
1016 		dev_attr->attr.mode |= S_IWUSR;
1017 		dev_attr->store = writefunc;
1018 	}
1019 
1020 error_free_full_postfix:
1021 	kfree(full_postfix);
1022 
1023 	return ret;
1024 }
1025 
1026 static void __iio_device_attr_deinit(struct device_attribute *dev_attr)
1027 {
1028 	kfree(dev_attr->attr.name);
1029 }
1030 
1031 int __iio_add_chan_devattr(const char *postfix,
1032 			   struct iio_chan_spec const *chan,
1033 			   ssize_t (*readfunc)(struct device *dev,
1034 					       struct device_attribute *attr,
1035 					       char *buf),
1036 			   ssize_t (*writefunc)(struct device *dev,
1037 						struct device_attribute *attr,
1038 						const char *buf,
1039 						size_t len),
1040 			   u64 mask,
1041 			   enum iio_shared_by shared_by,
1042 			   struct device *dev,
1043 			   struct list_head *attr_list)
1044 {
1045 	int ret;
1046 	struct iio_dev_attr *iio_attr, *t;
1047 
1048 	iio_attr = kzalloc(sizeof(*iio_attr), GFP_KERNEL);
1049 	if (iio_attr == NULL)
1050 		return -ENOMEM;
1051 	ret = __iio_device_attr_init(&iio_attr->dev_attr,
1052 				     postfix, chan,
1053 				     readfunc, writefunc, shared_by);
1054 	if (ret)
1055 		goto error_iio_dev_attr_free;
1056 	iio_attr->c = chan;
1057 	iio_attr->address = mask;
1058 	list_for_each_entry(t, attr_list, l)
1059 		if (strcmp(t->dev_attr.attr.name,
1060 			   iio_attr->dev_attr.attr.name) == 0) {
1061 			if (shared_by == IIO_SEPARATE)
1062 				dev_err(dev, "tried to double register : %s\n",
1063 					t->dev_attr.attr.name);
1064 			ret = -EBUSY;
1065 			goto error_device_attr_deinit;
1066 		}
1067 	list_add(&iio_attr->l, attr_list);
1068 
1069 	return 0;
1070 
1071 error_device_attr_deinit:
1072 	__iio_device_attr_deinit(&iio_attr->dev_attr);
1073 error_iio_dev_attr_free:
1074 	kfree(iio_attr);
1075 	return ret;
1076 }
1077 
1078 static int iio_device_add_info_mask_type(struct iio_dev *indio_dev,
1079 					 struct iio_chan_spec const *chan,
1080 					 enum iio_shared_by shared_by,
1081 					 const long *infomask)
1082 {
1083 	int i, ret, attrcount = 0;
1084 
1085 	for_each_set_bit(i, infomask, sizeof(*infomask)*8) {
1086 		if (i >= ARRAY_SIZE(iio_chan_info_postfix))
1087 			return -EINVAL;
1088 		ret = __iio_add_chan_devattr(iio_chan_info_postfix[i],
1089 					     chan,
1090 					     &iio_read_channel_info,
1091 					     &iio_write_channel_info,
1092 					     i,
1093 					     shared_by,
1094 					     &indio_dev->dev,
1095 					     &indio_dev->channel_attr_list);
1096 		if ((ret == -EBUSY) && (shared_by != IIO_SEPARATE))
1097 			continue;
1098 		else if (ret < 0)
1099 			return ret;
1100 		attrcount++;
1101 	}
1102 
1103 	return attrcount;
1104 }
1105 
1106 static int iio_device_add_info_mask_type_avail(struct iio_dev *indio_dev,
1107 					       struct iio_chan_spec const *chan,
1108 					       enum iio_shared_by shared_by,
1109 					       const long *infomask)
1110 {
1111 	int i, ret, attrcount = 0;
1112 	char *avail_postfix;
1113 
1114 	for_each_set_bit(i, infomask, sizeof(*infomask) * 8) {
1115 		avail_postfix = kasprintf(GFP_KERNEL,
1116 					  "%s_available",
1117 					  iio_chan_info_postfix[i]);
1118 		if (!avail_postfix)
1119 			return -ENOMEM;
1120 
1121 		ret = __iio_add_chan_devattr(avail_postfix,
1122 					     chan,
1123 					     &iio_read_channel_info_avail,
1124 					     NULL,
1125 					     i,
1126 					     shared_by,
1127 					     &indio_dev->dev,
1128 					     &indio_dev->channel_attr_list);
1129 		kfree(avail_postfix);
1130 		if ((ret == -EBUSY) && (shared_by != IIO_SEPARATE))
1131 			continue;
1132 		else if (ret < 0)
1133 			return ret;
1134 		attrcount++;
1135 	}
1136 
1137 	return attrcount;
1138 }
1139 
1140 static int iio_device_add_channel_sysfs(struct iio_dev *indio_dev,
1141 					struct iio_chan_spec const *chan)
1142 {
1143 	int ret, attrcount = 0;
1144 	const struct iio_chan_spec_ext_info *ext_info;
1145 
1146 	if (chan->channel < 0)
1147 		return 0;
1148 	ret = iio_device_add_info_mask_type(indio_dev, chan,
1149 					    IIO_SEPARATE,
1150 					    &chan->info_mask_separate);
1151 	if (ret < 0)
1152 		return ret;
1153 	attrcount += ret;
1154 
1155 	ret = iio_device_add_info_mask_type_avail(indio_dev, chan,
1156 						  IIO_SEPARATE,
1157 						  &chan->
1158 						  info_mask_separate_available);
1159 	if (ret < 0)
1160 		return ret;
1161 	attrcount += ret;
1162 
1163 	ret = iio_device_add_info_mask_type(indio_dev, chan,
1164 					    IIO_SHARED_BY_TYPE,
1165 					    &chan->info_mask_shared_by_type);
1166 	if (ret < 0)
1167 		return ret;
1168 	attrcount += ret;
1169 
1170 	ret = iio_device_add_info_mask_type_avail(indio_dev, chan,
1171 						  IIO_SHARED_BY_TYPE,
1172 						  &chan->
1173 						  info_mask_shared_by_type_available);
1174 	if (ret < 0)
1175 		return ret;
1176 	attrcount += ret;
1177 
1178 	ret = iio_device_add_info_mask_type(indio_dev, chan,
1179 					    IIO_SHARED_BY_DIR,
1180 					    &chan->info_mask_shared_by_dir);
1181 	if (ret < 0)
1182 		return ret;
1183 	attrcount += ret;
1184 
1185 	ret = iio_device_add_info_mask_type_avail(indio_dev, chan,
1186 						  IIO_SHARED_BY_DIR,
1187 						  &chan->info_mask_shared_by_dir_available);
1188 	if (ret < 0)
1189 		return ret;
1190 	attrcount += ret;
1191 
1192 	ret = iio_device_add_info_mask_type(indio_dev, chan,
1193 					    IIO_SHARED_BY_ALL,
1194 					    &chan->info_mask_shared_by_all);
1195 	if (ret < 0)
1196 		return ret;
1197 	attrcount += ret;
1198 
1199 	ret = iio_device_add_info_mask_type_avail(indio_dev, chan,
1200 						  IIO_SHARED_BY_ALL,
1201 						  &chan->info_mask_shared_by_all_available);
1202 	if (ret < 0)
1203 		return ret;
1204 	attrcount += ret;
1205 
1206 	if (chan->ext_info) {
1207 		unsigned int i = 0;
1208 		for (ext_info = chan->ext_info; ext_info->name; ext_info++) {
1209 			ret = __iio_add_chan_devattr(ext_info->name,
1210 					chan,
1211 					ext_info->read ?
1212 					    &iio_read_channel_ext_info : NULL,
1213 					ext_info->write ?
1214 					    &iio_write_channel_ext_info : NULL,
1215 					i,
1216 					ext_info->shared,
1217 					&indio_dev->dev,
1218 					&indio_dev->channel_attr_list);
1219 			i++;
1220 			if (ret == -EBUSY && ext_info->shared)
1221 				continue;
1222 
1223 			if (ret)
1224 				return ret;
1225 
1226 			attrcount++;
1227 		}
1228 	}
1229 
1230 	return attrcount;
1231 }
1232 
1233 /**
1234  * iio_free_chan_devattr_list() - Free a list of IIO device attributes
1235  * @attr_list: List of IIO device attributes
1236  *
1237  * This function frees the memory allocated for each of the IIO device
1238  * attributes in the list.
1239  */
1240 void iio_free_chan_devattr_list(struct list_head *attr_list)
1241 {
1242 	struct iio_dev_attr *p, *n;
1243 
1244 	list_for_each_entry_safe(p, n, attr_list, l) {
1245 		kfree(p->dev_attr.attr.name);
1246 		list_del(&p->l);
1247 		kfree(p);
1248 	}
1249 }
1250 
1251 static ssize_t iio_show_dev_name(struct device *dev,
1252 				 struct device_attribute *attr,
1253 				 char *buf)
1254 {
1255 	struct iio_dev *indio_dev = dev_to_iio_dev(dev);
1256 	return snprintf(buf, PAGE_SIZE, "%s\n", indio_dev->name);
1257 }
1258 
1259 static DEVICE_ATTR(name, S_IRUGO, iio_show_dev_name, NULL);
1260 
1261 static ssize_t iio_show_timestamp_clock(struct device *dev,
1262 					struct device_attribute *attr,
1263 					char *buf)
1264 {
1265 	const struct iio_dev *indio_dev = dev_to_iio_dev(dev);
1266 	const clockid_t clk = iio_device_get_clock(indio_dev);
1267 	const char *name;
1268 	ssize_t sz;
1269 
1270 	switch (clk) {
1271 	case CLOCK_REALTIME:
1272 		name = "realtime\n";
1273 		sz = sizeof("realtime\n");
1274 		break;
1275 	case CLOCK_MONOTONIC:
1276 		name = "monotonic\n";
1277 		sz = sizeof("monotonic\n");
1278 		break;
1279 	case CLOCK_MONOTONIC_RAW:
1280 		name = "monotonic_raw\n";
1281 		sz = sizeof("monotonic_raw\n");
1282 		break;
1283 	case CLOCK_REALTIME_COARSE:
1284 		name = "realtime_coarse\n";
1285 		sz = sizeof("realtime_coarse\n");
1286 		break;
1287 	case CLOCK_MONOTONIC_COARSE:
1288 		name = "monotonic_coarse\n";
1289 		sz = sizeof("monotonic_coarse\n");
1290 		break;
1291 	case CLOCK_BOOTTIME:
1292 		name = "boottime\n";
1293 		sz = sizeof("boottime\n");
1294 		break;
1295 	case CLOCK_TAI:
1296 		name = "tai\n";
1297 		sz = sizeof("tai\n");
1298 		break;
1299 	default:
1300 		BUG();
1301 	}
1302 
1303 	memcpy(buf, name, sz);
1304 	return sz;
1305 }
1306 
1307 static ssize_t iio_store_timestamp_clock(struct device *dev,
1308 					 struct device_attribute *attr,
1309 					 const char *buf, size_t len)
1310 {
1311 	clockid_t clk;
1312 	int ret;
1313 
1314 	if (sysfs_streq(buf, "realtime"))
1315 		clk = CLOCK_REALTIME;
1316 	else if (sysfs_streq(buf, "monotonic"))
1317 		clk = CLOCK_MONOTONIC;
1318 	else if (sysfs_streq(buf, "monotonic_raw"))
1319 		clk = CLOCK_MONOTONIC_RAW;
1320 	else if (sysfs_streq(buf, "realtime_coarse"))
1321 		clk = CLOCK_REALTIME_COARSE;
1322 	else if (sysfs_streq(buf, "monotonic_coarse"))
1323 		clk = CLOCK_MONOTONIC_COARSE;
1324 	else if (sysfs_streq(buf, "boottime"))
1325 		clk = CLOCK_BOOTTIME;
1326 	else if (sysfs_streq(buf, "tai"))
1327 		clk = CLOCK_TAI;
1328 	else
1329 		return -EINVAL;
1330 
1331 	ret = iio_device_set_clock(dev_to_iio_dev(dev), clk);
1332 	if (ret)
1333 		return ret;
1334 
1335 	return len;
1336 }
1337 
1338 static DEVICE_ATTR(current_timestamp_clock, S_IRUGO | S_IWUSR,
1339 		   iio_show_timestamp_clock, iio_store_timestamp_clock);
1340 
1341 static int iio_device_register_sysfs(struct iio_dev *indio_dev)
1342 {
1343 	int i, ret = 0, attrcount, attrn, attrcount_orig = 0;
1344 	struct iio_dev_attr *p;
1345 	struct attribute **attr, *clk = NULL;
1346 
1347 	/* First count elements in any existing group */
1348 	if (indio_dev->info->attrs) {
1349 		attr = indio_dev->info->attrs->attrs;
1350 		while (*attr++ != NULL)
1351 			attrcount_orig++;
1352 	}
1353 	attrcount = attrcount_orig;
1354 	/*
1355 	 * New channel registration method - relies on the fact a group does
1356 	 * not need to be initialized if its name is NULL.
1357 	 */
1358 	if (indio_dev->channels)
1359 		for (i = 0; i < indio_dev->num_channels; i++) {
1360 			const struct iio_chan_spec *chan =
1361 				&indio_dev->channels[i];
1362 
1363 			if (chan->type == IIO_TIMESTAMP)
1364 				clk = &dev_attr_current_timestamp_clock.attr;
1365 
1366 			ret = iio_device_add_channel_sysfs(indio_dev, chan);
1367 			if (ret < 0)
1368 				goto error_clear_attrs;
1369 			attrcount += ret;
1370 		}
1371 
1372 	if (indio_dev->event_interface)
1373 		clk = &dev_attr_current_timestamp_clock.attr;
1374 
1375 	if (indio_dev->name)
1376 		attrcount++;
1377 	if (clk)
1378 		attrcount++;
1379 
1380 	indio_dev->chan_attr_group.attrs = kcalloc(attrcount + 1,
1381 						   sizeof(indio_dev->chan_attr_group.attrs[0]),
1382 						   GFP_KERNEL);
1383 	if (indio_dev->chan_attr_group.attrs == NULL) {
1384 		ret = -ENOMEM;
1385 		goto error_clear_attrs;
1386 	}
1387 	/* Copy across original attributes */
1388 	if (indio_dev->info->attrs)
1389 		memcpy(indio_dev->chan_attr_group.attrs,
1390 		       indio_dev->info->attrs->attrs,
1391 		       sizeof(indio_dev->chan_attr_group.attrs[0])
1392 		       *attrcount_orig);
1393 	attrn = attrcount_orig;
1394 	/* Add all elements from the list. */
1395 	list_for_each_entry(p, &indio_dev->channel_attr_list, l)
1396 		indio_dev->chan_attr_group.attrs[attrn++] = &p->dev_attr.attr;
1397 	if (indio_dev->name)
1398 		indio_dev->chan_attr_group.attrs[attrn++] = &dev_attr_name.attr;
1399 	if (clk)
1400 		indio_dev->chan_attr_group.attrs[attrn++] = clk;
1401 
1402 	indio_dev->groups[indio_dev->groupcounter++] =
1403 		&indio_dev->chan_attr_group;
1404 
1405 	return 0;
1406 
1407 error_clear_attrs:
1408 	iio_free_chan_devattr_list(&indio_dev->channel_attr_list);
1409 
1410 	return ret;
1411 }
1412 
1413 static void iio_device_unregister_sysfs(struct iio_dev *indio_dev)
1414 {
1415 
1416 	iio_free_chan_devattr_list(&indio_dev->channel_attr_list);
1417 	kfree(indio_dev->chan_attr_group.attrs);
1418 	indio_dev->chan_attr_group.attrs = NULL;
1419 }
1420 
1421 static void iio_dev_release(struct device *device)
1422 {
1423 	struct iio_dev *indio_dev = dev_to_iio_dev(device);
1424 	if (indio_dev->modes & INDIO_ALL_TRIGGERED_MODES)
1425 		iio_device_unregister_trigger_consumer(indio_dev);
1426 	iio_device_unregister_eventset(indio_dev);
1427 	iio_device_unregister_sysfs(indio_dev);
1428 
1429 	iio_buffer_put(indio_dev->buffer);
1430 
1431 	ida_simple_remove(&iio_ida, indio_dev->id);
1432 	kfree(indio_dev);
1433 }
1434 
1435 struct device_type iio_device_type = {
1436 	.name = "iio_device",
1437 	.release = iio_dev_release,
1438 };
1439 
1440 /**
1441  * iio_device_alloc() - allocate an iio_dev from a driver
1442  * @sizeof_priv:	Space to allocate for private structure.
1443  **/
1444 struct iio_dev *iio_device_alloc(int sizeof_priv)
1445 {
1446 	struct iio_dev *dev;
1447 	size_t alloc_size;
1448 
1449 	alloc_size = sizeof(struct iio_dev);
1450 	if (sizeof_priv) {
1451 		alloc_size = ALIGN(alloc_size, IIO_ALIGN);
1452 		alloc_size += sizeof_priv;
1453 	}
1454 	/* ensure 32-byte alignment of whole construct ? */
1455 	alloc_size += IIO_ALIGN - 1;
1456 
1457 	dev = kzalloc(alloc_size, GFP_KERNEL);
1458 
1459 	if (dev) {
1460 		dev->dev.groups = dev->groups;
1461 		dev->dev.type = &iio_device_type;
1462 		dev->dev.bus = &iio_bus_type;
1463 		device_initialize(&dev->dev);
1464 		dev_set_drvdata(&dev->dev, (void *)dev);
1465 		mutex_init(&dev->mlock);
1466 		mutex_init(&dev->info_exist_lock);
1467 		INIT_LIST_HEAD(&dev->channel_attr_list);
1468 
1469 		dev->id = ida_simple_get(&iio_ida, 0, 0, GFP_KERNEL);
1470 		if (dev->id < 0) {
1471 			/* cannot use a dev_err as the name isn't available */
1472 			pr_err("failed to get device id\n");
1473 			kfree(dev);
1474 			return NULL;
1475 		}
1476 		dev_set_name(&dev->dev, "iio:device%d", dev->id);
1477 		INIT_LIST_HEAD(&dev->buffer_list);
1478 	}
1479 
1480 	return dev;
1481 }
1482 EXPORT_SYMBOL(iio_device_alloc);
1483 
1484 /**
1485  * iio_device_free() - free an iio_dev from a driver
1486  * @dev:		the iio_dev associated with the device
1487  **/
1488 void iio_device_free(struct iio_dev *dev)
1489 {
1490 	if (dev)
1491 		put_device(&dev->dev);
1492 }
1493 EXPORT_SYMBOL(iio_device_free);
1494 
1495 static void devm_iio_device_release(struct device *dev, void *res)
1496 {
1497 	iio_device_free(*(struct iio_dev **)res);
1498 }
1499 
1500 int devm_iio_device_match(struct device *dev, void *res, void *data)
1501 {
1502 	struct iio_dev **r = res;
1503 	if (!r || !*r) {
1504 		WARN_ON(!r || !*r);
1505 		return 0;
1506 	}
1507 	return *r == data;
1508 }
1509 EXPORT_SYMBOL_GPL(devm_iio_device_match);
1510 
1511 /**
1512  * devm_iio_device_alloc - Resource-managed iio_device_alloc()
1513  * @dev:		Device to allocate iio_dev for
1514  * @sizeof_priv:	Space to allocate for private structure.
1515  *
1516  * Managed iio_device_alloc. iio_dev allocated with this function is
1517  * automatically freed on driver detach.
1518  *
1519  * If an iio_dev allocated with this function needs to be freed separately,
1520  * devm_iio_device_free() must be used.
1521  *
1522  * RETURNS:
1523  * Pointer to allocated iio_dev on success, NULL on failure.
1524  */
1525 struct iio_dev *devm_iio_device_alloc(struct device *dev, int sizeof_priv)
1526 {
1527 	struct iio_dev **ptr, *iio_dev;
1528 
1529 	ptr = devres_alloc(devm_iio_device_release, sizeof(*ptr),
1530 			   GFP_KERNEL);
1531 	if (!ptr)
1532 		return NULL;
1533 
1534 	iio_dev = iio_device_alloc(sizeof_priv);
1535 	if (iio_dev) {
1536 		*ptr = iio_dev;
1537 		devres_add(dev, ptr);
1538 	} else {
1539 		devres_free(ptr);
1540 	}
1541 
1542 	return iio_dev;
1543 }
1544 EXPORT_SYMBOL_GPL(devm_iio_device_alloc);
1545 
1546 /**
1547  * devm_iio_device_free - Resource-managed iio_device_free()
1548  * @dev:		Device this iio_dev belongs to
1549  * @iio_dev:		the iio_dev associated with the device
1550  *
1551  * Free iio_dev allocated with devm_iio_device_alloc().
1552  */
1553 void devm_iio_device_free(struct device *dev, struct iio_dev *iio_dev)
1554 {
1555 	int rc;
1556 
1557 	rc = devres_release(dev, devm_iio_device_release,
1558 			    devm_iio_device_match, iio_dev);
1559 	WARN_ON(rc);
1560 }
1561 EXPORT_SYMBOL_GPL(devm_iio_device_free);
1562 
1563 /**
1564  * iio_chrdev_open() - chrdev file open for buffer access and ioctls
1565  * @inode:	Inode structure for identifying the device in the file system
1566  * @filp:	File structure for iio device used to keep and later access
1567  *		private data
1568  *
1569  * Return: 0 on success or -EBUSY if the device is already opened
1570  **/
1571 static int iio_chrdev_open(struct inode *inode, struct file *filp)
1572 {
1573 	struct iio_dev *indio_dev = container_of(inode->i_cdev,
1574 						struct iio_dev, chrdev);
1575 
1576 	if (test_and_set_bit(IIO_BUSY_BIT_POS, &indio_dev->flags))
1577 		return -EBUSY;
1578 
1579 	iio_device_get(indio_dev);
1580 
1581 	filp->private_data = indio_dev;
1582 
1583 	return 0;
1584 }
1585 
1586 /**
1587  * iio_chrdev_release() - chrdev file close buffer access and ioctls
1588  * @inode:	Inode structure pointer for the char device
1589  * @filp:	File structure pointer for the char device
1590  *
1591  * Return: 0 for successful release
1592  */
1593 static int iio_chrdev_release(struct inode *inode, struct file *filp)
1594 {
1595 	struct iio_dev *indio_dev = container_of(inode->i_cdev,
1596 						struct iio_dev, chrdev);
1597 	clear_bit(IIO_BUSY_BIT_POS, &indio_dev->flags);
1598 	iio_device_put(indio_dev);
1599 
1600 	return 0;
1601 }
1602 
1603 /* Somewhat of a cross file organization violation - ioctls here are actually
1604  * event related */
1605 static long iio_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
1606 {
1607 	struct iio_dev *indio_dev = filp->private_data;
1608 	int __user *ip = (int __user *)arg;
1609 	int fd;
1610 
1611 	if (!indio_dev->info)
1612 		return -ENODEV;
1613 
1614 	if (cmd == IIO_GET_EVENT_FD_IOCTL) {
1615 		fd = iio_event_getfd(indio_dev);
1616 		if (fd < 0)
1617 			return fd;
1618 		if (copy_to_user(ip, &fd, sizeof(fd)))
1619 			return -EFAULT;
1620 		return 0;
1621 	}
1622 	return -EINVAL;
1623 }
1624 
1625 static const struct file_operations iio_buffer_fileops = {
1626 	.read = iio_buffer_read_first_n_outer_addr,
1627 	.release = iio_chrdev_release,
1628 	.open = iio_chrdev_open,
1629 	.poll = iio_buffer_poll_addr,
1630 	.owner = THIS_MODULE,
1631 	.llseek = noop_llseek,
1632 	.unlocked_ioctl = iio_ioctl,
1633 	.compat_ioctl = iio_ioctl,
1634 };
1635 
1636 static int iio_check_unique_scan_index(struct iio_dev *indio_dev)
1637 {
1638 	int i, j;
1639 	const struct iio_chan_spec *channels = indio_dev->channels;
1640 
1641 	if (!(indio_dev->modes & INDIO_ALL_BUFFER_MODES))
1642 		return 0;
1643 
1644 	for (i = 0; i < indio_dev->num_channels - 1; i++) {
1645 		if (channels[i].scan_index < 0)
1646 			continue;
1647 		for (j = i + 1; j < indio_dev->num_channels; j++)
1648 			if (channels[i].scan_index == channels[j].scan_index) {
1649 				dev_err(&indio_dev->dev,
1650 					"Duplicate scan index %d\n",
1651 					channels[i].scan_index);
1652 				return -EINVAL;
1653 			}
1654 	}
1655 
1656 	return 0;
1657 }
1658 
1659 static const struct iio_buffer_setup_ops noop_ring_setup_ops;
1660 
1661 int __iio_device_register(struct iio_dev *indio_dev, struct module *this_mod)
1662 {
1663 	int ret;
1664 
1665 	indio_dev->driver_module = this_mod;
1666 	/* If the calling driver did not initialize of_node, do it here */
1667 	if (!indio_dev->dev.of_node && indio_dev->dev.parent)
1668 		indio_dev->dev.of_node = indio_dev->dev.parent->of_node;
1669 
1670 	ret = iio_check_unique_scan_index(indio_dev);
1671 	if (ret < 0)
1672 		return ret;
1673 
1674 	if (!indio_dev->info)
1675 		return -EINVAL;
1676 
1677 	/* configure elements for the chrdev */
1678 	indio_dev->dev.devt = MKDEV(MAJOR(iio_devt), indio_dev->id);
1679 
1680 	ret = iio_device_register_debugfs(indio_dev);
1681 	if (ret) {
1682 		dev_err(indio_dev->dev.parent,
1683 			"Failed to register debugfs interfaces\n");
1684 		return ret;
1685 	}
1686 
1687 	ret = iio_buffer_alloc_sysfs_and_mask(indio_dev);
1688 	if (ret) {
1689 		dev_err(indio_dev->dev.parent,
1690 			"Failed to create buffer sysfs interfaces\n");
1691 		goto error_unreg_debugfs;
1692 	}
1693 
1694 	ret = iio_device_register_sysfs(indio_dev);
1695 	if (ret) {
1696 		dev_err(indio_dev->dev.parent,
1697 			"Failed to register sysfs interfaces\n");
1698 		goto error_buffer_free_sysfs;
1699 	}
1700 	ret = iio_device_register_eventset(indio_dev);
1701 	if (ret) {
1702 		dev_err(indio_dev->dev.parent,
1703 			"Failed to register event set\n");
1704 		goto error_free_sysfs;
1705 	}
1706 	if (indio_dev->modes & INDIO_ALL_TRIGGERED_MODES)
1707 		iio_device_register_trigger_consumer(indio_dev);
1708 
1709 	if ((indio_dev->modes & INDIO_ALL_BUFFER_MODES) &&
1710 		indio_dev->setup_ops == NULL)
1711 		indio_dev->setup_ops = &noop_ring_setup_ops;
1712 
1713 	cdev_init(&indio_dev->chrdev, &iio_buffer_fileops);
1714 
1715 	indio_dev->chrdev.owner = this_mod;
1716 
1717 	ret = cdev_device_add(&indio_dev->chrdev, &indio_dev->dev);
1718 	if (ret < 0)
1719 		goto error_unreg_eventset;
1720 
1721 	return 0;
1722 
1723 error_unreg_eventset:
1724 	iio_device_unregister_eventset(indio_dev);
1725 error_free_sysfs:
1726 	iio_device_unregister_sysfs(indio_dev);
1727 error_buffer_free_sysfs:
1728 	iio_buffer_free_sysfs_and_mask(indio_dev);
1729 error_unreg_debugfs:
1730 	iio_device_unregister_debugfs(indio_dev);
1731 	return ret;
1732 }
1733 EXPORT_SYMBOL(__iio_device_register);
1734 
1735 /**
1736  * iio_device_unregister() - unregister a device from the IIO subsystem
1737  * @indio_dev:		Device structure representing the device.
1738  **/
1739 void iio_device_unregister(struct iio_dev *indio_dev)
1740 {
1741 	mutex_lock(&indio_dev->info_exist_lock);
1742 
1743 	cdev_device_del(&indio_dev->chrdev, &indio_dev->dev);
1744 
1745 	iio_device_unregister_debugfs(indio_dev);
1746 
1747 	iio_disable_all_buffers(indio_dev);
1748 
1749 	indio_dev->info = NULL;
1750 
1751 	iio_device_wakeup_eventset(indio_dev);
1752 	iio_buffer_wakeup_poll(indio_dev);
1753 
1754 	mutex_unlock(&indio_dev->info_exist_lock);
1755 
1756 	iio_buffer_free_sysfs_and_mask(indio_dev);
1757 }
1758 EXPORT_SYMBOL(iio_device_unregister);
1759 
1760 static void devm_iio_device_unreg(struct device *dev, void *res)
1761 {
1762 	iio_device_unregister(*(struct iio_dev **)res);
1763 }
1764 
1765 int __devm_iio_device_register(struct device *dev, struct iio_dev *indio_dev,
1766 			       struct module *this_mod)
1767 {
1768 	struct iio_dev **ptr;
1769 	int ret;
1770 
1771 	ptr = devres_alloc(devm_iio_device_unreg, sizeof(*ptr), GFP_KERNEL);
1772 	if (!ptr)
1773 		return -ENOMEM;
1774 
1775 	*ptr = indio_dev;
1776 	ret = __iio_device_register(indio_dev, this_mod);
1777 	if (!ret)
1778 		devres_add(dev, ptr);
1779 	else
1780 		devres_free(ptr);
1781 
1782 	return ret;
1783 }
1784 EXPORT_SYMBOL_GPL(__devm_iio_device_register);
1785 
1786 /**
1787  * devm_iio_device_unregister - Resource-managed iio_device_unregister()
1788  * @dev:	Device this iio_dev belongs to
1789  * @indio_dev:	the iio_dev associated with the device
1790  *
1791  * Unregister iio_dev registered with devm_iio_device_register().
1792  */
1793 void devm_iio_device_unregister(struct device *dev, struct iio_dev *indio_dev)
1794 {
1795 	int rc;
1796 
1797 	rc = devres_release(dev, devm_iio_device_unreg,
1798 			    devm_iio_device_match, indio_dev);
1799 	WARN_ON(rc);
1800 }
1801 EXPORT_SYMBOL_GPL(devm_iio_device_unregister);
1802 
1803 /**
1804  * iio_device_claim_direct_mode - Keep device in direct mode
1805  * @indio_dev:	the iio_dev associated with the device
1806  *
1807  * If the device is in direct mode it is guaranteed to stay
1808  * that way until iio_device_release_direct_mode() is called.
1809  *
1810  * Use with iio_device_release_direct_mode()
1811  *
1812  * Returns: 0 on success, -EBUSY on failure
1813  */
1814 int iio_device_claim_direct_mode(struct iio_dev *indio_dev)
1815 {
1816 	mutex_lock(&indio_dev->mlock);
1817 
1818 	if (iio_buffer_enabled(indio_dev)) {
1819 		mutex_unlock(&indio_dev->mlock);
1820 		return -EBUSY;
1821 	}
1822 	return 0;
1823 }
1824 EXPORT_SYMBOL_GPL(iio_device_claim_direct_mode);
1825 
1826 /**
1827  * iio_device_release_direct_mode - releases claim on direct mode
1828  * @indio_dev:	the iio_dev associated with the device
1829  *
1830  * Release the claim. Device is no longer guaranteed to stay
1831  * in direct mode.
1832  *
1833  * Use with iio_device_claim_direct_mode()
1834  */
1835 void iio_device_release_direct_mode(struct iio_dev *indio_dev)
1836 {
1837 	mutex_unlock(&indio_dev->mlock);
1838 }
1839 EXPORT_SYMBOL_GPL(iio_device_release_direct_mode);
1840 
1841 subsys_initcall(iio_init);
1842 module_exit(iio_exit);
1843 
1844 MODULE_AUTHOR("Jonathan Cameron <jic23@kernel.org>");
1845 MODULE_DESCRIPTION("Industrial I/O core");
1846 MODULE_LICENSE("GPL");
1847