GNU Linux-libre 6.9.1-gnu
[releases.git] / drivers / iio / industrialio-core.c
1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3  * The industrial I/O core
4  *
5  * Copyright (c) 2008 Jonathan Cameron
6  *
7  * Based on elements of hwmon and input subsystems.
8  */
9
10 #define pr_fmt(fmt) "iio-core: " fmt
11
12 #include <linux/anon_inodes.h>
13 #include <linux/cdev.h>
14 #include <linux/debugfs.h>
15 #include <linux/device.h>
16 #include <linux/err.h>
17 #include <linux/fs.h>
18 #include <linux/idr.h>
19 #include <linux/kdev_t.h>
20 #include <linux/kernel.h>
21 #include <linux/module.h>
22 #include <linux/mutex.h>
23 #include <linux/poll.h>
24 #include <linux/property.h>
25 #include <linux/sched.h>
26 #include <linux/slab.h>
27 #include <linux/wait.h>
28
29 #include <linux/iio/buffer.h>
30 #include <linux/iio/buffer_impl.h>
31 #include <linux/iio/events.h>
32 #include <linux/iio/iio-opaque.h>
33 #include <linux/iio/iio.h>
34 #include <linux/iio/sysfs.h>
35
36 #include "iio_core.h"
37 #include "iio_core_trigger.h"
38
39 /* IDA to assign each registered device a unique id */
40 static DEFINE_IDA(iio_ida);
41
42 static dev_t iio_devt;
43
44 #define IIO_DEV_MAX 256
45 const struct bus_type iio_bus_type = {
46         .name = "iio",
47 };
48 EXPORT_SYMBOL(iio_bus_type);
49
50 static struct dentry *iio_debugfs_dentry;
51
52 static const char * const iio_direction[] = {
53         [0] = "in",
54         [1] = "out",
55 };
56
57 static const char * const iio_chan_type_name_spec[] = {
58         [IIO_VOLTAGE] = "voltage",
59         [IIO_CURRENT] = "current",
60         [IIO_POWER] = "power",
61         [IIO_ACCEL] = "accel",
62         [IIO_ANGL_VEL] = "anglvel",
63         [IIO_MAGN] = "magn",
64         [IIO_LIGHT] = "illuminance",
65         [IIO_INTENSITY] = "intensity",
66         [IIO_PROXIMITY] = "proximity",
67         [IIO_TEMP] = "temp",
68         [IIO_INCLI] = "incli",
69         [IIO_ROT] = "rot",
70         [IIO_ANGL] = "angl",
71         [IIO_TIMESTAMP] = "timestamp",
72         [IIO_CAPACITANCE] = "capacitance",
73         [IIO_ALTVOLTAGE] = "altvoltage",
74         [IIO_CCT] = "cct",
75         [IIO_PRESSURE] = "pressure",
76         [IIO_HUMIDITYRELATIVE] = "humidityrelative",
77         [IIO_ACTIVITY] = "activity",
78         [IIO_STEPS] = "steps",
79         [IIO_ENERGY] = "energy",
80         [IIO_DISTANCE] = "distance",
81         [IIO_VELOCITY] = "velocity",
82         [IIO_CONCENTRATION] = "concentration",
83         [IIO_RESISTANCE] = "resistance",
84         [IIO_PH] = "ph",
85         [IIO_UVINDEX] = "uvindex",
86         [IIO_ELECTRICALCONDUCTIVITY] = "electricalconductivity",
87         [IIO_COUNT] = "count",
88         [IIO_INDEX] = "index",
89         [IIO_GRAVITY]  = "gravity",
90         [IIO_POSITIONRELATIVE]  = "positionrelative",
91         [IIO_PHASE] = "phase",
92         [IIO_MASSCONCENTRATION] = "massconcentration",
93         [IIO_DELTA_ANGL] = "deltaangl",
94         [IIO_DELTA_VELOCITY] = "deltavelocity",
95         [IIO_COLORTEMP] = "colortemp",
96         [IIO_CHROMATICITY] = "chromaticity",
97 };
98
99 static const char * const iio_modifier_names[] = {
100         [IIO_MOD_X] = "x",
101         [IIO_MOD_Y] = "y",
102         [IIO_MOD_Z] = "z",
103         [IIO_MOD_X_AND_Y] = "x&y",
104         [IIO_MOD_X_AND_Z] = "x&z",
105         [IIO_MOD_Y_AND_Z] = "y&z",
106         [IIO_MOD_X_AND_Y_AND_Z] = "x&y&z",
107         [IIO_MOD_X_OR_Y] = "x|y",
108         [IIO_MOD_X_OR_Z] = "x|z",
109         [IIO_MOD_Y_OR_Z] = "y|z",
110         [IIO_MOD_X_OR_Y_OR_Z] = "x|y|z",
111         [IIO_MOD_ROOT_SUM_SQUARED_X_Y] = "sqrt(x^2+y^2)",
112         [IIO_MOD_SUM_SQUARED_X_Y_Z] = "x^2+y^2+z^2",
113         [IIO_MOD_LIGHT_BOTH] = "both",
114         [IIO_MOD_LIGHT_IR] = "ir",
115         [IIO_MOD_LIGHT_CLEAR] = "clear",
116         [IIO_MOD_LIGHT_RED] = "red",
117         [IIO_MOD_LIGHT_GREEN] = "green",
118         [IIO_MOD_LIGHT_BLUE] = "blue",
119         [IIO_MOD_LIGHT_UV] = "uv",
120         [IIO_MOD_LIGHT_UVA] = "uva",
121         [IIO_MOD_LIGHT_UVB] = "uvb",
122         [IIO_MOD_LIGHT_DUV] = "duv",
123         [IIO_MOD_QUATERNION] = "quaternion",
124         [IIO_MOD_TEMP_AMBIENT] = "ambient",
125         [IIO_MOD_TEMP_OBJECT] = "object",
126         [IIO_MOD_NORTH_MAGN] = "from_north_magnetic",
127         [IIO_MOD_NORTH_TRUE] = "from_north_true",
128         [IIO_MOD_NORTH_MAGN_TILT_COMP] = "from_north_magnetic_tilt_comp",
129         [IIO_MOD_NORTH_TRUE_TILT_COMP] = "from_north_true_tilt_comp",
130         [IIO_MOD_RUNNING] = "running",
131         [IIO_MOD_JOGGING] = "jogging",
132         [IIO_MOD_WALKING] = "walking",
133         [IIO_MOD_STILL] = "still",
134         [IIO_MOD_ROOT_SUM_SQUARED_X_Y_Z] = "sqrt(x^2+y^2+z^2)",
135         [IIO_MOD_I] = "i",
136         [IIO_MOD_Q] = "q",
137         [IIO_MOD_CO2] = "co2",
138         [IIO_MOD_VOC] = "voc",
139         [IIO_MOD_PM1] = "pm1",
140         [IIO_MOD_PM2P5] = "pm2p5",
141         [IIO_MOD_PM4] = "pm4",
142         [IIO_MOD_PM10] = "pm10",
143         [IIO_MOD_ETHANOL] = "ethanol",
144         [IIO_MOD_H2] = "h2",
145         [IIO_MOD_O2] = "o2",
146         [IIO_MOD_LINEAR_X] = "linear_x",
147         [IIO_MOD_LINEAR_Y] = "linear_y",
148         [IIO_MOD_LINEAR_Z] = "linear_z",
149         [IIO_MOD_PITCH] = "pitch",
150         [IIO_MOD_YAW] = "yaw",
151         [IIO_MOD_ROLL] = "roll",
152 };
153
154 /* relies on pairs of these shared then separate */
155 static const char * const iio_chan_info_postfix[] = {
156         [IIO_CHAN_INFO_RAW] = "raw",
157         [IIO_CHAN_INFO_PROCESSED] = "input",
158         [IIO_CHAN_INFO_SCALE] = "scale",
159         [IIO_CHAN_INFO_OFFSET] = "offset",
160         [IIO_CHAN_INFO_CALIBSCALE] = "calibscale",
161         [IIO_CHAN_INFO_CALIBBIAS] = "calibbias",
162         [IIO_CHAN_INFO_PEAK] = "peak_raw",
163         [IIO_CHAN_INFO_PEAK_SCALE] = "peak_scale",
164         [IIO_CHAN_INFO_QUADRATURE_CORRECTION_RAW] = "quadrature_correction_raw",
165         [IIO_CHAN_INFO_AVERAGE_RAW] = "mean_raw",
166         [IIO_CHAN_INFO_LOW_PASS_FILTER_3DB_FREQUENCY]
167         = "filter_low_pass_3db_frequency",
168         [IIO_CHAN_INFO_HIGH_PASS_FILTER_3DB_FREQUENCY]
169         = "filter_high_pass_3db_frequency",
170         [IIO_CHAN_INFO_SAMP_FREQ] = "sampling_frequency",
171         [IIO_CHAN_INFO_FREQUENCY] = "frequency",
172         [IIO_CHAN_INFO_PHASE] = "phase",
173         [IIO_CHAN_INFO_HARDWAREGAIN] = "hardwaregain",
174         [IIO_CHAN_INFO_HYSTERESIS] = "hysteresis",
175         [IIO_CHAN_INFO_HYSTERESIS_RELATIVE] = "hysteresis_relative",
176         [IIO_CHAN_INFO_INT_TIME] = "integration_time",
177         [IIO_CHAN_INFO_ENABLE] = "en",
178         [IIO_CHAN_INFO_CALIBHEIGHT] = "calibheight",
179         [IIO_CHAN_INFO_CALIBWEIGHT] = "calibweight",
180         [IIO_CHAN_INFO_DEBOUNCE_COUNT] = "debounce_count",
181         [IIO_CHAN_INFO_DEBOUNCE_TIME] = "debounce_time",
182         [IIO_CHAN_INFO_CALIBEMISSIVITY] = "calibemissivity",
183         [IIO_CHAN_INFO_OVERSAMPLING_RATIO] = "oversampling_ratio",
184         [IIO_CHAN_INFO_THERMOCOUPLE_TYPE] = "thermocouple_type",
185         [IIO_CHAN_INFO_CALIBAMBIENT] = "calibambient",
186         [IIO_CHAN_INFO_ZEROPOINT] = "zeropoint",
187         [IIO_CHAN_INFO_TROUGH] = "trough_raw",
188 };
189 /**
190  * iio_device_id() - query the unique ID for the device
191  * @indio_dev:          Device structure whose ID is being queried
192  *
193  * The IIO device ID is a unique index used for example for the naming
194  * of the character device /dev/iio\:device[ID].
195  *
196  * Returns: Unique ID for the device.
197  */
198 int iio_device_id(struct iio_dev *indio_dev)
199 {
200         struct iio_dev_opaque *iio_dev_opaque = to_iio_dev_opaque(indio_dev);
201
202         return iio_dev_opaque->id;
203 }
204 EXPORT_SYMBOL_GPL(iio_device_id);
205
206 /**
207  * iio_buffer_enabled() - helper function to test if the buffer is enabled
208  * @indio_dev:          IIO device structure for device
209  *
210  * Returns: True, if the buffer is enabled.
211  */
212 bool iio_buffer_enabled(struct iio_dev *indio_dev)
213 {
214         struct iio_dev_opaque *iio_dev_opaque = to_iio_dev_opaque(indio_dev);
215
216         return iio_dev_opaque->currentmode & INDIO_ALL_BUFFER_MODES;
217 }
218 EXPORT_SYMBOL_GPL(iio_buffer_enabled);
219
220 #if defined(CONFIG_DEBUG_FS)
221 /*
222  * There's also a CONFIG_DEBUG_FS guard in include/linux/iio/iio.h for
223  * iio_get_debugfs_dentry() to make it inline if CONFIG_DEBUG_FS is undefined
224  */
225 struct dentry *iio_get_debugfs_dentry(struct iio_dev *indio_dev)
226 {
227         struct iio_dev_opaque *iio_dev_opaque = to_iio_dev_opaque(indio_dev);
228
229         return iio_dev_opaque->debugfs_dentry;
230 }
231 EXPORT_SYMBOL_GPL(iio_get_debugfs_dentry);
232 #endif
233
234 /**
235  * iio_find_channel_from_si() - get channel from its scan index
236  * @indio_dev:          device
237  * @si:                 scan index to match
238  *
239  * Returns:
240  * Constant pointer to iio_chan_spec, if scan index matches, NULL on failure.
241  */
242 const struct iio_chan_spec
243 *iio_find_channel_from_si(struct iio_dev *indio_dev, int si)
244 {
245         int i;
246
247         for (i = 0; i < indio_dev->num_channels; i++)
248                 if (indio_dev->channels[i].scan_index == si)
249                         return &indio_dev->channels[i];
250         return NULL;
251 }
252
253 /* This turns up an awful lot */
254 ssize_t iio_read_const_attr(struct device *dev,
255                             struct device_attribute *attr,
256                             char *buf)
257 {
258         return sysfs_emit(buf, "%s\n", to_iio_const_attr(attr)->string);
259 }
260 EXPORT_SYMBOL(iio_read_const_attr);
261
262 /**
263  * iio_device_set_clock() - Set current timestamping clock for the device
264  * @indio_dev: IIO device structure containing the device
265  * @clock_id: timestamping clock POSIX identifier to set.
266  *
267  * Returns: 0 on success, or a negative error code.
268  */
269 int iio_device_set_clock(struct iio_dev *indio_dev, clockid_t clock_id)
270 {
271         int ret;
272         struct iio_dev_opaque *iio_dev_opaque = to_iio_dev_opaque(indio_dev);
273         const struct iio_event_interface *ev_int = iio_dev_opaque->event_interface;
274
275         ret = mutex_lock_interruptible(&iio_dev_opaque->mlock);
276         if (ret)
277                 return ret;
278         if ((ev_int && iio_event_enabled(ev_int)) ||
279             iio_buffer_enabled(indio_dev)) {
280                 mutex_unlock(&iio_dev_opaque->mlock);
281                 return -EBUSY;
282         }
283         iio_dev_opaque->clock_id = clock_id;
284         mutex_unlock(&iio_dev_opaque->mlock);
285
286         return 0;
287 }
288 EXPORT_SYMBOL(iio_device_set_clock);
289
290 /**
291  * iio_device_get_clock() - Retrieve current timestamping clock for the device
292  * @indio_dev: IIO device structure containing the device
293  *
294  * Returns: Clock ID of the current timestamping clock for the device.
295  */
296 clockid_t iio_device_get_clock(const struct iio_dev *indio_dev)
297 {
298         struct iio_dev_opaque *iio_dev_opaque = to_iio_dev_opaque(indio_dev);
299
300         return iio_dev_opaque->clock_id;
301 }
302 EXPORT_SYMBOL(iio_device_get_clock);
303
304 /**
305  * iio_get_time_ns() - utility function to get a time stamp for events etc
306  * @indio_dev: device
307  *
308  * Returns: Timestamp of the event in nanoseconds.
309  */
310 s64 iio_get_time_ns(const struct iio_dev *indio_dev)
311 {
312         struct timespec64 tp;
313
314         switch (iio_device_get_clock(indio_dev)) {
315         case CLOCK_REALTIME:
316                 return ktime_get_real_ns();
317         case CLOCK_MONOTONIC:
318                 return ktime_get_ns();
319         case CLOCK_MONOTONIC_RAW:
320                 return ktime_get_raw_ns();
321         case CLOCK_REALTIME_COARSE:
322                 return ktime_to_ns(ktime_get_coarse_real());
323         case CLOCK_MONOTONIC_COARSE:
324                 ktime_get_coarse_ts64(&tp);
325                 return timespec64_to_ns(&tp);
326         case CLOCK_BOOTTIME:
327                 return ktime_get_boottime_ns();
328         case CLOCK_TAI:
329                 return ktime_get_clocktai_ns();
330         default:
331                 BUG();
332         }
333 }
334 EXPORT_SYMBOL(iio_get_time_ns);
335
336 static int __init iio_init(void)
337 {
338         int ret;
339
340         /* Register sysfs bus */
341         ret  = bus_register(&iio_bus_type);
342         if (ret < 0) {
343                 pr_err("could not register bus type\n");
344                 goto error_nothing;
345         }
346
347         ret = alloc_chrdev_region(&iio_devt, 0, IIO_DEV_MAX, "iio");
348         if (ret < 0) {
349                 pr_err("failed to allocate char dev region\n");
350                 goto error_unregister_bus_type;
351         }
352
353         iio_debugfs_dentry = debugfs_create_dir("iio", NULL);
354
355         return 0;
356
357 error_unregister_bus_type:
358         bus_unregister(&iio_bus_type);
359 error_nothing:
360         return ret;
361 }
362
363 static void __exit iio_exit(void)
364 {
365         if (iio_devt)
366                 unregister_chrdev_region(iio_devt, IIO_DEV_MAX);
367         bus_unregister(&iio_bus_type);
368         debugfs_remove(iio_debugfs_dentry);
369 }
370
371 #if defined(CONFIG_DEBUG_FS)
372 static ssize_t iio_debugfs_read_reg(struct file *file, char __user *userbuf,
373                               size_t count, loff_t *ppos)
374 {
375         struct iio_dev *indio_dev = file->private_data;
376         struct iio_dev_opaque *iio_dev_opaque = to_iio_dev_opaque(indio_dev);
377         unsigned int val = 0;
378         int ret;
379
380         if (*ppos > 0)
381                 return simple_read_from_buffer(userbuf, count, ppos,
382                                                iio_dev_opaque->read_buf,
383                                                iio_dev_opaque->read_buf_len);
384
385         ret = indio_dev->info->debugfs_reg_access(indio_dev,
386                                                   iio_dev_opaque->cached_reg_addr,
387                                                   0, &val);
388         if (ret) {
389                 dev_err(indio_dev->dev.parent, "%s: read failed\n", __func__);
390                 return ret;
391         }
392
393         iio_dev_opaque->read_buf_len = snprintf(iio_dev_opaque->read_buf,
394                                                 sizeof(iio_dev_opaque->read_buf),
395                                                 "0x%X\n", val);
396
397         return simple_read_from_buffer(userbuf, count, ppos,
398                                        iio_dev_opaque->read_buf,
399                                        iio_dev_opaque->read_buf_len);
400 }
401
402 static ssize_t iio_debugfs_write_reg(struct file *file,
403                      const char __user *userbuf, size_t count, loff_t *ppos)
404 {
405         struct iio_dev *indio_dev = file->private_data;
406         struct iio_dev_opaque *iio_dev_opaque = to_iio_dev_opaque(indio_dev);
407         unsigned int reg, val;
408         char buf[80];
409         int ret;
410
411         count = min(count, sizeof(buf) - 1);
412         if (copy_from_user(buf, userbuf, count))
413                 return -EFAULT;
414
415         buf[count] = 0;
416
417         ret = sscanf(buf, "%i %i", &reg, &val);
418
419         switch (ret) {
420         case 1:
421                 iio_dev_opaque->cached_reg_addr = reg;
422                 break;
423         case 2:
424                 iio_dev_opaque->cached_reg_addr = reg;
425                 ret = indio_dev->info->debugfs_reg_access(indio_dev, reg,
426                                                           val, NULL);
427                 if (ret) {
428                         dev_err(indio_dev->dev.parent, "%s: write failed\n",
429                                 __func__);
430                         return ret;
431                 }
432                 break;
433         default:
434                 return -EINVAL;
435         }
436
437         return count;
438 }
439
440 static const struct file_operations iio_debugfs_reg_fops = {
441         .open = simple_open,
442         .read = iio_debugfs_read_reg,
443         .write = iio_debugfs_write_reg,
444 };
445
446 static void iio_device_unregister_debugfs(struct iio_dev *indio_dev)
447 {
448         struct iio_dev_opaque *iio_dev_opaque = to_iio_dev_opaque(indio_dev);
449
450         debugfs_remove_recursive(iio_dev_opaque->debugfs_dentry);
451 }
452
453 static void iio_device_register_debugfs(struct iio_dev *indio_dev)
454 {
455         struct iio_dev_opaque *iio_dev_opaque;
456
457         if (indio_dev->info->debugfs_reg_access == NULL)
458                 return;
459
460         if (!iio_debugfs_dentry)
461                 return;
462
463         iio_dev_opaque = to_iio_dev_opaque(indio_dev);
464
465         iio_dev_opaque->debugfs_dentry =
466                 debugfs_create_dir(dev_name(&indio_dev->dev),
467                                    iio_debugfs_dentry);
468
469         debugfs_create_file("direct_reg_access", 0644,
470                             iio_dev_opaque->debugfs_dentry, indio_dev,
471                             &iio_debugfs_reg_fops);
472 }
473 #else
474 static void iio_device_register_debugfs(struct iio_dev *indio_dev)
475 {
476 }
477
478 static void iio_device_unregister_debugfs(struct iio_dev *indio_dev)
479 {
480 }
481 #endif /* CONFIG_DEBUG_FS */
482
483 static ssize_t iio_read_channel_ext_info(struct device *dev,
484                                      struct device_attribute *attr,
485                                      char *buf)
486 {
487         struct iio_dev *indio_dev = dev_to_iio_dev(dev);
488         struct iio_dev_attr *this_attr = to_iio_dev_attr(attr);
489         const struct iio_chan_spec_ext_info *ext_info;
490
491         ext_info = &this_attr->c->ext_info[this_attr->address];
492
493         return ext_info->read(indio_dev, ext_info->private, this_attr->c, buf);
494 }
495
496 static ssize_t iio_write_channel_ext_info(struct device *dev,
497                                      struct device_attribute *attr,
498                                      const char *buf, size_t len)
499 {
500         struct iio_dev *indio_dev = dev_to_iio_dev(dev);
501         struct iio_dev_attr *this_attr = to_iio_dev_attr(attr);
502         const struct iio_chan_spec_ext_info *ext_info;
503
504         ext_info = &this_attr->c->ext_info[this_attr->address];
505
506         return ext_info->write(indio_dev, ext_info->private,
507                                this_attr->c, buf, len);
508 }
509
510 ssize_t iio_enum_available_read(struct iio_dev *indio_dev,
511         uintptr_t priv, const struct iio_chan_spec *chan, char *buf)
512 {
513         const struct iio_enum *e = (const struct iio_enum *)priv;
514         unsigned int i;
515         size_t len = 0;
516
517         if (!e->num_items)
518                 return 0;
519
520         for (i = 0; i < e->num_items; ++i) {
521                 if (!e->items[i])
522                         continue;
523                 len += sysfs_emit_at(buf, len, "%s ", e->items[i]);
524         }
525
526         /* replace last space with a newline */
527         buf[len - 1] = '\n';
528
529         return len;
530 }
531 EXPORT_SYMBOL_GPL(iio_enum_available_read);
532
533 ssize_t iio_enum_read(struct iio_dev *indio_dev,
534         uintptr_t priv, const struct iio_chan_spec *chan, char *buf)
535 {
536         const struct iio_enum *e = (const struct iio_enum *)priv;
537         int i;
538
539         if (!e->get)
540                 return -EINVAL;
541
542         i = e->get(indio_dev, chan);
543         if (i < 0)
544                 return i;
545         if (i >= e->num_items || !e->items[i])
546                 return -EINVAL;
547
548         return sysfs_emit(buf, "%s\n", e->items[i]);
549 }
550 EXPORT_SYMBOL_GPL(iio_enum_read);
551
552 ssize_t iio_enum_write(struct iio_dev *indio_dev,
553         uintptr_t priv, const struct iio_chan_spec *chan, const char *buf,
554         size_t len)
555 {
556         const struct iio_enum *e = (const struct iio_enum *)priv;
557         int ret;
558
559         if (!e->set)
560                 return -EINVAL;
561
562         ret = __sysfs_match_string(e->items, e->num_items, buf);
563         if (ret < 0)
564                 return ret;
565
566         ret = e->set(indio_dev, chan, ret);
567         return ret ? ret : len;
568 }
569 EXPORT_SYMBOL_GPL(iio_enum_write);
570
571 static const struct iio_mount_matrix iio_mount_idmatrix = {
572         .rotation = {
573                 "1", "0", "0",
574                 "0", "1", "0",
575                 "0", "0", "1"
576         }
577 };
578
579 static int iio_setup_mount_idmatrix(const struct device *dev,
580                                     struct iio_mount_matrix *matrix)
581 {
582         *matrix = iio_mount_idmatrix;
583         dev_info(dev, "mounting matrix not found: using identity...\n");
584         return 0;
585 }
586
587 ssize_t iio_show_mount_matrix(struct iio_dev *indio_dev, uintptr_t priv,
588                               const struct iio_chan_spec *chan, char *buf)
589 {
590         const struct iio_mount_matrix *mtx;
591
592         mtx = ((iio_get_mount_matrix_t *)priv)(indio_dev, chan);
593         if (IS_ERR(mtx))
594                 return PTR_ERR(mtx);
595
596         if (!mtx)
597                 mtx = &iio_mount_idmatrix;
598
599         return sysfs_emit(buf, "%s, %s, %s; %s, %s, %s; %s, %s, %s\n",
600                           mtx->rotation[0], mtx->rotation[1], mtx->rotation[2],
601                           mtx->rotation[3], mtx->rotation[4], mtx->rotation[5],
602                           mtx->rotation[6], mtx->rotation[7], mtx->rotation[8]);
603 }
604 EXPORT_SYMBOL_GPL(iio_show_mount_matrix);
605
606 /**
607  * iio_read_mount_matrix() - retrieve iio device mounting matrix from
608  *                           device "mount-matrix" property
609  * @dev:        device the mounting matrix property is assigned to
610  * @matrix:     where to store retrieved matrix
611  *
612  * If device is assigned no mounting matrix property, a default 3x3 identity
613  * matrix will be filled in.
614  *
615  * Returns: 0 if success, or a negative error code on failure.
616  */
617 int iio_read_mount_matrix(struct device *dev, struct iio_mount_matrix *matrix)
618 {
619         size_t len = ARRAY_SIZE(iio_mount_idmatrix.rotation);
620         int err;
621
622         err = device_property_read_string_array(dev, "mount-matrix", matrix->rotation, len);
623         if (err == len)
624                 return 0;
625
626         if (err >= 0)
627                 /* Invalid number of matrix entries. */
628                 return -EINVAL;
629
630         if (err != -EINVAL)
631                 /* Invalid matrix declaration format. */
632                 return err;
633
634         /* Matrix was not declared at all: fallback to identity. */
635         return iio_setup_mount_idmatrix(dev, matrix);
636 }
637 EXPORT_SYMBOL(iio_read_mount_matrix);
638
639 static ssize_t __iio_format_value(char *buf, size_t offset, unsigned int type,
640                                   int size, const int *vals)
641 {
642         int tmp0, tmp1;
643         s64 tmp2;
644         bool scale_db = false;
645
646         switch (type) {
647         case IIO_VAL_INT:
648                 return sysfs_emit_at(buf, offset, "%d", vals[0]);
649         case IIO_VAL_INT_PLUS_MICRO_DB:
650                 scale_db = true;
651                 fallthrough;
652         case IIO_VAL_INT_PLUS_MICRO:
653                 if (vals[1] < 0)
654                         return sysfs_emit_at(buf, offset, "-%d.%06u%s",
655                                              abs(vals[0]), -vals[1],
656                                              scale_db ? " dB" : "");
657                 else
658                         return sysfs_emit_at(buf, offset, "%d.%06u%s", vals[0],
659                                              vals[1], scale_db ? " dB" : "");
660         case IIO_VAL_INT_PLUS_NANO:
661                 if (vals[1] < 0)
662                         return sysfs_emit_at(buf, offset, "-%d.%09u",
663                                              abs(vals[0]), -vals[1]);
664                 else
665                         return sysfs_emit_at(buf, offset, "%d.%09u", vals[0],
666                                              vals[1]);
667         case IIO_VAL_FRACTIONAL:
668                 tmp2 = div_s64((s64)vals[0] * 1000000000LL, vals[1]);
669                 tmp1 = vals[1];
670                 tmp0 = (int)div_s64_rem(tmp2, 1000000000, &tmp1);
671                 if ((tmp2 < 0) && (tmp0 == 0))
672                         return sysfs_emit_at(buf, offset, "-0.%09u", abs(tmp1));
673                 else
674                         return sysfs_emit_at(buf, offset, "%d.%09u", tmp0,
675                                              abs(tmp1));
676         case IIO_VAL_FRACTIONAL_LOG2:
677                 tmp2 = shift_right((s64)vals[0] * 1000000000LL, vals[1]);
678                 tmp0 = (int)div_s64_rem(tmp2, 1000000000LL, &tmp1);
679                 if (tmp0 == 0 && tmp2 < 0)
680                         return sysfs_emit_at(buf, offset, "-0.%09u", abs(tmp1));
681                 else
682                         return sysfs_emit_at(buf, offset, "%d.%09u", tmp0,
683                                              abs(tmp1));
684         case IIO_VAL_INT_MULTIPLE:
685         {
686                 int i;
687                 int l = 0;
688
689                 for (i = 0; i < size; ++i)
690                         l += sysfs_emit_at(buf, offset + l, "%d ", vals[i]);
691                 return l;
692         }
693         case IIO_VAL_CHAR:
694                 return sysfs_emit_at(buf, offset, "%c", (char)vals[0]);
695         case IIO_VAL_INT_64:
696                 tmp2 = (s64)((((u64)vals[1]) << 32) | (u32)vals[0]);
697                 return sysfs_emit_at(buf, offset, "%lld", tmp2);
698         default:
699                 return 0;
700         }
701 }
702
703 /**
704  * iio_format_value() - Formats a IIO value into its string representation
705  * @buf:        The buffer to which the formatted value gets written
706  *              which is assumed to be big enough (i.e. PAGE_SIZE).
707  * @type:       One of the IIO_VAL_* constants. This decides how the val
708  *              and val2 parameters are formatted.
709  * @size:       Number of IIO value entries contained in vals
710  * @vals:       Pointer to the values, exact meaning depends on the
711  *              type parameter.
712  *
713  * Returns:
714  * 0 by default, a negative number on failure or the total number of characters
715  * written for a type that belongs to the IIO_VAL_* constant.
716  */
717 ssize_t iio_format_value(char *buf, unsigned int type, int size, int *vals)
718 {
719         ssize_t len;
720
721         len = __iio_format_value(buf, 0, type, size, vals);
722         if (len >= PAGE_SIZE - 1)
723                 return -EFBIG;
724
725         return len + sysfs_emit_at(buf, len, "\n");
726 }
727 EXPORT_SYMBOL_GPL(iio_format_value);
728
729 static ssize_t iio_read_channel_label(struct device *dev,
730                                       struct device_attribute *attr,
731                                       char *buf)
732 {
733         struct iio_dev *indio_dev = dev_to_iio_dev(dev);
734         struct iio_dev_attr *this_attr = to_iio_dev_attr(attr);
735
736         if (indio_dev->info->read_label)
737                 return indio_dev->info->read_label(indio_dev, this_attr->c, buf);
738
739         if (this_attr->c->extend_name)
740                 return sysfs_emit(buf, "%s\n", this_attr->c->extend_name);
741
742         return -EINVAL;
743 }
744
745 static ssize_t iio_read_channel_info(struct device *dev,
746                                      struct device_attribute *attr,
747                                      char *buf)
748 {
749         struct iio_dev *indio_dev = dev_to_iio_dev(dev);
750         struct iio_dev_attr *this_attr = to_iio_dev_attr(attr);
751         int vals[INDIO_MAX_RAW_ELEMENTS];
752         int ret;
753         int val_len = 2;
754
755         if (indio_dev->info->read_raw_multi)
756                 ret = indio_dev->info->read_raw_multi(indio_dev, this_attr->c,
757                                                         INDIO_MAX_RAW_ELEMENTS,
758                                                         vals, &val_len,
759                                                         this_attr->address);
760         else
761                 ret = indio_dev->info->read_raw(indio_dev, this_attr->c,
762                                     &vals[0], &vals[1], this_attr->address);
763
764         if (ret < 0)
765                 return ret;
766
767         return iio_format_value(buf, ret, val_len, vals);
768 }
769
770 static ssize_t iio_format_list(char *buf, const int *vals, int type, int length,
771                                const char *prefix, const char *suffix)
772 {
773         ssize_t len;
774         int stride;
775         int i;
776
777         switch (type) {
778         case IIO_VAL_INT:
779                 stride = 1;
780                 break;
781         default:
782                 stride = 2;
783                 break;
784         }
785
786         len = sysfs_emit(buf, prefix);
787
788         for (i = 0; i <= length - stride; i += stride) {
789                 if (i != 0) {
790                         len += sysfs_emit_at(buf, len, " ");
791                         if (len >= PAGE_SIZE)
792                                 return -EFBIG;
793                 }
794
795                 len += __iio_format_value(buf, len, type, stride, &vals[i]);
796                 if (len >= PAGE_SIZE)
797                         return -EFBIG;
798         }
799
800         len += sysfs_emit_at(buf, len, "%s\n", suffix);
801
802         return len;
803 }
804
805 static ssize_t iio_format_avail_list(char *buf, const int *vals,
806                                      int type, int length)
807 {
808
809         return iio_format_list(buf, vals, type, length, "", "");
810 }
811
812 static ssize_t iio_format_avail_range(char *buf, const int *vals, int type)
813 {
814         int length;
815
816         /*
817          * length refers to the array size , not the number of elements.
818          * The purpose is to print the range [min , step ,max] so length should
819          * be 3 in case of int, and 6 for other types.
820          */
821         switch (type) {
822         case IIO_VAL_INT:
823                 length = 3;
824                 break;
825         default:
826                 length = 6;
827                 break;
828         }
829
830         return iio_format_list(buf, vals, type, length, "[", "]");
831 }
832
833 static ssize_t iio_read_channel_info_avail(struct device *dev,
834                                            struct device_attribute *attr,
835                                            char *buf)
836 {
837         struct iio_dev *indio_dev = dev_to_iio_dev(dev);
838         struct iio_dev_attr *this_attr = to_iio_dev_attr(attr);
839         const int *vals;
840         int ret;
841         int length;
842         int type;
843
844         ret = indio_dev->info->read_avail(indio_dev, this_attr->c,
845                                           &vals, &type, &length,
846                                           this_attr->address);
847
848         if (ret < 0)
849                 return ret;
850         switch (ret) {
851         case IIO_AVAIL_LIST:
852                 return iio_format_avail_list(buf, vals, type, length);
853         case IIO_AVAIL_RANGE:
854                 return iio_format_avail_range(buf, vals, type);
855         default:
856                 return -EINVAL;
857         }
858 }
859
860 /**
861  * __iio_str_to_fixpoint() - Parse a fixed-point number from a string
862  * @str: The string to parse
863  * @fract_mult: Multiplier for the first decimal place, should be a power of 10
864  * @integer: The integer part of the number
865  * @fract: The fractional part of the number
866  * @scale_db: True if this should parse as dB
867  *
868  * Returns:
869  * 0 on success, or a negative error code if the string could not be parsed.
870  */
871 static int __iio_str_to_fixpoint(const char *str, int fract_mult,
872                                  int *integer, int *fract, bool scale_db)
873 {
874         int i = 0, f = 0;
875         bool integer_part = true, negative = false;
876
877         if (fract_mult == 0) {
878                 *fract = 0;
879
880                 return kstrtoint(str, 0, integer);
881         }
882
883         if (str[0] == '-') {
884                 negative = true;
885                 str++;
886         } else if (str[0] == '+') {
887                 str++;
888         }
889
890         while (*str) {
891                 if ('0' <= *str && *str <= '9') {
892                         if (integer_part) {
893                                 i = i * 10 + *str - '0';
894                         } else {
895                                 f += fract_mult * (*str - '0');
896                                 fract_mult /= 10;
897                         }
898                 } else if (*str == '\n') {
899                         if (*(str + 1) == '\0')
900                                 break;
901                         return -EINVAL;
902                 } else if (!strncmp(str, " dB", sizeof(" dB") - 1) && scale_db) {
903                         /* Ignore the dB suffix */
904                         str += sizeof(" dB") - 1;
905                         continue;
906                 } else if (!strncmp(str, "dB", sizeof("dB") - 1) && scale_db) {
907                         /* Ignore the dB suffix */
908                         str += sizeof("dB") - 1;
909                         continue;
910                 } else if (*str == '.' && integer_part) {
911                         integer_part = false;
912                 } else {
913                         return -EINVAL;
914                 }
915                 str++;
916         }
917
918         if (negative) {
919                 if (i)
920                         i = -i;
921                 else
922                         f = -f;
923         }
924
925         *integer = i;
926         *fract = f;
927
928         return 0;
929 }
930
931 /**
932  * iio_str_to_fixpoint() - Parse a fixed-point number from a string
933  * @str: The string to parse
934  * @fract_mult: Multiplier for the first decimal place, should be a power of 10
935  * @integer: The integer part of the number
936  * @fract: The fractional part of the number
937  *
938  * Returns:
939  * 0 on success, or a negative error code if the string could not be parsed.
940  */
941 int iio_str_to_fixpoint(const char *str, int fract_mult,
942                         int *integer, int *fract)
943 {
944         return __iio_str_to_fixpoint(str, fract_mult, integer, fract, false);
945 }
946 EXPORT_SYMBOL_GPL(iio_str_to_fixpoint);
947
948 static ssize_t iio_write_channel_info(struct device *dev,
949                                       struct device_attribute *attr,
950                                       const char *buf,
951                                       size_t len)
952 {
953         struct iio_dev *indio_dev = dev_to_iio_dev(dev);
954         struct iio_dev_attr *this_attr = to_iio_dev_attr(attr);
955         int ret, fract_mult = 100000;
956         int integer, fract = 0;
957         bool is_char = false;
958         bool scale_db = false;
959
960         /* Assumes decimal - precision based on number of digits */
961         if (!indio_dev->info->write_raw)
962                 return -EINVAL;
963
964         if (indio_dev->info->write_raw_get_fmt)
965                 switch (indio_dev->info->write_raw_get_fmt(indio_dev,
966                         this_attr->c, this_attr->address)) {
967                 case IIO_VAL_INT:
968                         fract_mult = 0;
969                         break;
970                 case IIO_VAL_INT_PLUS_MICRO_DB:
971                         scale_db = true;
972                         fallthrough;
973                 case IIO_VAL_INT_PLUS_MICRO:
974                         fract_mult = 100000;
975                         break;
976                 case IIO_VAL_INT_PLUS_NANO:
977                         fract_mult = 100000000;
978                         break;
979                 case IIO_VAL_CHAR:
980                         is_char = true;
981                         break;
982                 default:
983                         return -EINVAL;
984                 }
985
986         if (is_char) {
987                 char ch;
988
989                 if (sscanf(buf, "%c", &ch) != 1)
990                         return -EINVAL;
991                 integer = ch;
992         } else {
993                 ret = __iio_str_to_fixpoint(buf, fract_mult, &integer, &fract,
994                                             scale_db);
995                 if (ret)
996                         return ret;
997         }
998
999         ret = indio_dev->info->write_raw(indio_dev, this_attr->c,
1000                                          integer, fract, this_attr->address);
1001         if (ret)
1002                 return ret;
1003
1004         return len;
1005 }
1006
1007 static
1008 int __iio_device_attr_init(struct device_attribute *dev_attr,
1009                            const char *postfix,
1010                            struct iio_chan_spec const *chan,
1011                            ssize_t (*readfunc)(struct device *dev,
1012                                                struct device_attribute *attr,
1013                                                char *buf),
1014                            ssize_t (*writefunc)(struct device *dev,
1015                                                 struct device_attribute *attr,
1016                                                 const char *buf,
1017                                                 size_t len),
1018                            enum iio_shared_by shared_by)
1019 {
1020         int ret = 0;
1021         char *name = NULL;
1022         char *full_postfix;
1023
1024         sysfs_attr_init(&dev_attr->attr);
1025
1026         /* Build up postfix of <extend_name>_<modifier>_postfix */
1027         if (chan->modified && (shared_by == IIO_SEPARATE)) {
1028                 if (chan->extend_name)
1029                         full_postfix = kasprintf(GFP_KERNEL, "%s_%s_%s",
1030                                                  iio_modifier_names[chan->channel2],
1031                                                  chan->extend_name,
1032                                                  postfix);
1033                 else
1034                         full_postfix = kasprintf(GFP_KERNEL, "%s_%s",
1035                                                  iio_modifier_names[chan->channel2],
1036                                                  postfix);
1037         } else {
1038                 if (chan->extend_name == NULL || shared_by != IIO_SEPARATE)
1039                         full_postfix = kstrdup(postfix, GFP_KERNEL);
1040                 else
1041                         full_postfix = kasprintf(GFP_KERNEL,
1042                                                  "%s_%s",
1043                                                  chan->extend_name,
1044                                                  postfix);
1045         }
1046         if (full_postfix == NULL)
1047                 return -ENOMEM;
1048
1049         if (chan->differential) { /* Differential can not have modifier */
1050                 switch (shared_by) {
1051                 case IIO_SHARED_BY_ALL:
1052                         name = kasprintf(GFP_KERNEL, "%s", full_postfix);
1053                         break;
1054                 case IIO_SHARED_BY_DIR:
1055                         name = kasprintf(GFP_KERNEL, "%s_%s",
1056                                                 iio_direction[chan->output],
1057                                                 full_postfix);
1058                         break;
1059                 case IIO_SHARED_BY_TYPE:
1060                         name = kasprintf(GFP_KERNEL, "%s_%s-%s_%s",
1061                                             iio_direction[chan->output],
1062                                             iio_chan_type_name_spec[chan->type],
1063                                             iio_chan_type_name_spec[chan->type],
1064                                             full_postfix);
1065                         break;
1066                 case IIO_SEPARATE:
1067                         if (!chan->indexed) {
1068                                 WARN(1, "Differential channels must be indexed\n");
1069                                 ret = -EINVAL;
1070                                 goto error_free_full_postfix;
1071                         }
1072                         name = kasprintf(GFP_KERNEL,
1073                                             "%s_%s%d-%s%d_%s",
1074                                             iio_direction[chan->output],
1075                                             iio_chan_type_name_spec[chan->type],
1076                                             chan->channel,
1077                                             iio_chan_type_name_spec[chan->type],
1078                                             chan->channel2,
1079                                             full_postfix);
1080                         break;
1081                 }
1082         } else { /* Single ended */
1083                 switch (shared_by) {
1084                 case IIO_SHARED_BY_ALL:
1085                         name = kasprintf(GFP_KERNEL, "%s", full_postfix);
1086                         break;
1087                 case IIO_SHARED_BY_DIR:
1088                         name = kasprintf(GFP_KERNEL, "%s_%s",
1089                                                 iio_direction[chan->output],
1090                                                 full_postfix);
1091                         break;
1092                 case IIO_SHARED_BY_TYPE:
1093                         name = kasprintf(GFP_KERNEL, "%s_%s_%s",
1094                                             iio_direction[chan->output],
1095                                             iio_chan_type_name_spec[chan->type],
1096                                             full_postfix);
1097                         break;
1098
1099                 case IIO_SEPARATE:
1100                         if (chan->indexed)
1101                                 name = kasprintf(GFP_KERNEL, "%s_%s%d_%s",
1102                                                     iio_direction[chan->output],
1103                                                     iio_chan_type_name_spec[chan->type],
1104                                                     chan->channel,
1105                                                     full_postfix);
1106                         else
1107                                 name = kasprintf(GFP_KERNEL, "%s_%s_%s",
1108                                                     iio_direction[chan->output],
1109                                                     iio_chan_type_name_spec[chan->type],
1110                                                     full_postfix);
1111                         break;
1112                 }
1113         }
1114         if (name == NULL) {
1115                 ret = -ENOMEM;
1116                 goto error_free_full_postfix;
1117         }
1118         dev_attr->attr.name = name;
1119
1120         if (readfunc) {
1121                 dev_attr->attr.mode |= 0444;
1122                 dev_attr->show = readfunc;
1123         }
1124
1125         if (writefunc) {
1126                 dev_attr->attr.mode |= 0200;
1127                 dev_attr->store = writefunc;
1128         }
1129
1130 error_free_full_postfix:
1131         kfree(full_postfix);
1132
1133         return ret;
1134 }
1135
1136 static void __iio_device_attr_deinit(struct device_attribute *dev_attr)
1137 {
1138         kfree(dev_attr->attr.name);
1139 }
1140
1141 int __iio_add_chan_devattr(const char *postfix,
1142                            struct iio_chan_spec const *chan,
1143                            ssize_t (*readfunc)(struct device *dev,
1144                                                struct device_attribute *attr,
1145                                                char *buf),
1146                            ssize_t (*writefunc)(struct device *dev,
1147                                                 struct device_attribute *attr,
1148                                                 const char *buf,
1149                                                 size_t len),
1150                            u64 mask,
1151                            enum iio_shared_by shared_by,
1152                            struct device *dev,
1153                            struct iio_buffer *buffer,
1154                            struct list_head *attr_list)
1155 {
1156         int ret;
1157         struct iio_dev_attr *iio_attr, *t;
1158
1159         iio_attr = kzalloc(sizeof(*iio_attr), GFP_KERNEL);
1160         if (iio_attr == NULL)
1161                 return -ENOMEM;
1162         ret = __iio_device_attr_init(&iio_attr->dev_attr,
1163                                      postfix, chan,
1164                                      readfunc, writefunc, shared_by);
1165         if (ret)
1166                 goto error_iio_dev_attr_free;
1167         iio_attr->c = chan;
1168         iio_attr->address = mask;
1169         iio_attr->buffer = buffer;
1170         list_for_each_entry(t, attr_list, l)
1171                 if (strcmp(t->dev_attr.attr.name,
1172                            iio_attr->dev_attr.attr.name) == 0) {
1173                         if (shared_by == IIO_SEPARATE)
1174                                 dev_err(dev, "tried to double register : %s\n",
1175                                         t->dev_attr.attr.name);
1176                         ret = -EBUSY;
1177                         goto error_device_attr_deinit;
1178                 }
1179         list_add(&iio_attr->l, attr_list);
1180
1181         return 0;
1182
1183 error_device_attr_deinit:
1184         __iio_device_attr_deinit(&iio_attr->dev_attr);
1185 error_iio_dev_attr_free:
1186         kfree(iio_attr);
1187         return ret;
1188 }
1189
1190 static int iio_device_add_channel_label(struct iio_dev *indio_dev,
1191                                          struct iio_chan_spec const *chan)
1192 {
1193         struct iio_dev_opaque *iio_dev_opaque = to_iio_dev_opaque(indio_dev);
1194         int ret;
1195
1196         if (!indio_dev->info->read_label && !chan->extend_name)
1197                 return 0;
1198
1199         ret = __iio_add_chan_devattr("label",
1200                                      chan,
1201                                      &iio_read_channel_label,
1202                                      NULL,
1203                                      0,
1204                                      IIO_SEPARATE,
1205                                      &indio_dev->dev,
1206                                      NULL,
1207                                      &iio_dev_opaque->channel_attr_list);
1208         if (ret < 0)
1209                 return ret;
1210
1211         return 1;
1212 }
1213
1214 static int iio_device_add_info_mask_type(struct iio_dev *indio_dev,
1215                                          struct iio_chan_spec const *chan,
1216                                          enum iio_shared_by shared_by,
1217                                          const long *infomask)
1218 {
1219         struct iio_dev_opaque *iio_dev_opaque = to_iio_dev_opaque(indio_dev);
1220         int i, ret, attrcount = 0;
1221
1222         for_each_set_bit(i, infomask, sizeof(*infomask)*8) {
1223                 if (i >= ARRAY_SIZE(iio_chan_info_postfix))
1224                         return -EINVAL;
1225                 ret = __iio_add_chan_devattr(iio_chan_info_postfix[i],
1226                                              chan,
1227                                              &iio_read_channel_info,
1228                                              &iio_write_channel_info,
1229                                              i,
1230                                              shared_by,
1231                                              &indio_dev->dev,
1232                                              NULL,
1233                                              &iio_dev_opaque->channel_attr_list);
1234                 if ((ret == -EBUSY) && (shared_by != IIO_SEPARATE))
1235                         continue;
1236                 if (ret < 0)
1237                         return ret;
1238                 attrcount++;
1239         }
1240
1241         return attrcount;
1242 }
1243
1244 static int iio_device_add_info_mask_type_avail(struct iio_dev *indio_dev,
1245                                                struct iio_chan_spec const *chan,
1246                                                enum iio_shared_by shared_by,
1247                                                const long *infomask)
1248 {
1249         struct iio_dev_opaque *iio_dev_opaque = to_iio_dev_opaque(indio_dev);
1250         int i, ret, attrcount = 0;
1251         char *avail_postfix;
1252
1253         for_each_set_bit(i, infomask, sizeof(*infomask) * 8) {
1254                 if (i >= ARRAY_SIZE(iio_chan_info_postfix))
1255                         return -EINVAL;
1256                 avail_postfix = kasprintf(GFP_KERNEL,
1257                                           "%s_available",
1258                                           iio_chan_info_postfix[i]);
1259                 if (!avail_postfix)
1260                         return -ENOMEM;
1261
1262                 ret = __iio_add_chan_devattr(avail_postfix,
1263                                              chan,
1264                                              &iio_read_channel_info_avail,
1265                                              NULL,
1266                                              i,
1267                                              shared_by,
1268                                              &indio_dev->dev,
1269                                              NULL,
1270                                              &iio_dev_opaque->channel_attr_list);
1271                 kfree(avail_postfix);
1272                 if ((ret == -EBUSY) && (shared_by != IIO_SEPARATE))
1273                         continue;
1274                 if (ret < 0)
1275                         return ret;
1276                 attrcount++;
1277         }
1278
1279         return attrcount;
1280 }
1281
1282 static int iio_device_add_channel_sysfs(struct iio_dev *indio_dev,
1283                                         struct iio_chan_spec const *chan)
1284 {
1285         struct iio_dev_opaque *iio_dev_opaque = to_iio_dev_opaque(indio_dev);
1286         int ret, attrcount = 0;
1287         const struct iio_chan_spec_ext_info *ext_info;
1288
1289         if (chan->channel < 0)
1290                 return 0;
1291         ret = iio_device_add_info_mask_type(indio_dev, chan,
1292                                             IIO_SEPARATE,
1293                                             &chan->info_mask_separate);
1294         if (ret < 0)
1295                 return ret;
1296         attrcount += ret;
1297
1298         ret = iio_device_add_info_mask_type_avail(indio_dev, chan,
1299                                                   IIO_SEPARATE,
1300                                                   &chan->info_mask_separate_available);
1301         if (ret < 0)
1302                 return ret;
1303         attrcount += ret;
1304
1305         ret = iio_device_add_info_mask_type(indio_dev, chan,
1306                                             IIO_SHARED_BY_TYPE,
1307                                             &chan->info_mask_shared_by_type);
1308         if (ret < 0)
1309                 return ret;
1310         attrcount += ret;
1311
1312         ret = iio_device_add_info_mask_type_avail(indio_dev, chan,
1313                                                   IIO_SHARED_BY_TYPE,
1314                                                   &chan->info_mask_shared_by_type_available);
1315         if (ret < 0)
1316                 return ret;
1317         attrcount += ret;
1318
1319         ret = iio_device_add_info_mask_type(indio_dev, chan,
1320                                             IIO_SHARED_BY_DIR,
1321                                             &chan->info_mask_shared_by_dir);
1322         if (ret < 0)
1323                 return ret;
1324         attrcount += ret;
1325
1326         ret = iio_device_add_info_mask_type_avail(indio_dev, chan,
1327                                                   IIO_SHARED_BY_DIR,
1328                                                   &chan->info_mask_shared_by_dir_available);
1329         if (ret < 0)
1330                 return ret;
1331         attrcount += ret;
1332
1333         ret = iio_device_add_info_mask_type(indio_dev, chan,
1334                                             IIO_SHARED_BY_ALL,
1335                                             &chan->info_mask_shared_by_all);
1336         if (ret < 0)
1337                 return ret;
1338         attrcount += ret;
1339
1340         ret = iio_device_add_info_mask_type_avail(indio_dev, chan,
1341                                                   IIO_SHARED_BY_ALL,
1342                                                   &chan->info_mask_shared_by_all_available);
1343         if (ret < 0)
1344                 return ret;
1345         attrcount += ret;
1346
1347         ret = iio_device_add_channel_label(indio_dev, chan);
1348         if (ret < 0)
1349                 return ret;
1350         attrcount += ret;
1351
1352         if (chan->ext_info) {
1353                 unsigned int i = 0;
1354
1355                 for (ext_info = chan->ext_info; ext_info->name; ext_info++) {
1356                         ret = __iio_add_chan_devattr(ext_info->name,
1357                                         chan,
1358                                         ext_info->read ?
1359                                             &iio_read_channel_ext_info : NULL,
1360                                         ext_info->write ?
1361                                             &iio_write_channel_ext_info : NULL,
1362                                         i,
1363                                         ext_info->shared,
1364                                         &indio_dev->dev,
1365                                         NULL,
1366                                         &iio_dev_opaque->channel_attr_list);
1367                         i++;
1368                         if (ret == -EBUSY && ext_info->shared)
1369                                 continue;
1370
1371                         if (ret)
1372                                 return ret;
1373
1374                         attrcount++;
1375                 }
1376         }
1377
1378         return attrcount;
1379 }
1380
1381 /**
1382  * iio_free_chan_devattr_list() - Free a list of IIO device attributes
1383  * @attr_list: List of IIO device attributes
1384  *
1385  * This function frees the memory allocated for each of the IIO device
1386  * attributes in the list.
1387  */
1388 void iio_free_chan_devattr_list(struct list_head *attr_list)
1389 {
1390         struct iio_dev_attr *p, *n;
1391
1392         list_for_each_entry_safe(p, n, attr_list, l) {
1393                 kfree_const(p->dev_attr.attr.name);
1394                 list_del(&p->l);
1395                 kfree(p);
1396         }
1397 }
1398
1399 static ssize_t name_show(struct device *dev, struct device_attribute *attr,
1400                          char *buf)
1401 {
1402         struct iio_dev *indio_dev = dev_to_iio_dev(dev);
1403
1404         return sysfs_emit(buf, "%s\n", indio_dev->name);
1405 }
1406
1407 static DEVICE_ATTR_RO(name);
1408
1409 static ssize_t label_show(struct device *dev, struct device_attribute *attr,
1410                           char *buf)
1411 {
1412         struct iio_dev *indio_dev = dev_to_iio_dev(dev);
1413
1414         return sysfs_emit(buf, "%s\n", indio_dev->label);
1415 }
1416
1417 static DEVICE_ATTR_RO(label);
1418
1419 static const char * const clock_names[] = {
1420         [CLOCK_REALTIME]                = "realtime",
1421         [CLOCK_MONOTONIC]               = "monotonic",
1422         [CLOCK_PROCESS_CPUTIME_ID]      = "process_cputime_id",
1423         [CLOCK_THREAD_CPUTIME_ID]       = "thread_cputime_id",
1424         [CLOCK_MONOTONIC_RAW]           = "monotonic_raw",
1425         [CLOCK_REALTIME_COARSE]         = "realtime_coarse",
1426         [CLOCK_MONOTONIC_COARSE]        = "monotonic_coarse",
1427         [CLOCK_BOOTTIME]                = "boottime",
1428         [CLOCK_REALTIME_ALARM]          = "realtime_alarm",
1429         [CLOCK_BOOTTIME_ALARM]          = "boottime_alarm",
1430         [CLOCK_SGI_CYCLE]               = "sgi_cycle",
1431         [CLOCK_TAI]                     = "tai",
1432 };
1433
1434 static ssize_t current_timestamp_clock_show(struct device *dev,
1435                                             struct device_attribute *attr,
1436                                             char *buf)
1437 {
1438         const struct iio_dev *indio_dev = dev_to_iio_dev(dev);
1439         const clockid_t clk = iio_device_get_clock(indio_dev);
1440
1441         switch (clk) {
1442         case CLOCK_REALTIME:
1443         case CLOCK_MONOTONIC:
1444         case CLOCK_MONOTONIC_RAW:
1445         case CLOCK_REALTIME_COARSE:
1446         case CLOCK_MONOTONIC_COARSE:
1447         case CLOCK_BOOTTIME:
1448         case CLOCK_TAI:
1449                 break;
1450         default:
1451                 BUG();
1452         }
1453
1454         return sysfs_emit(buf, "%s\n", clock_names[clk]);
1455 }
1456
1457 static ssize_t current_timestamp_clock_store(struct device *dev,
1458                                              struct device_attribute *attr,
1459                                              const char *buf, size_t len)
1460 {
1461         clockid_t clk;
1462         int ret;
1463
1464         ret = sysfs_match_string(clock_names, buf);
1465         if (ret < 0)
1466                 return ret;
1467         clk = ret;
1468
1469         switch (clk) {
1470         case CLOCK_REALTIME:
1471         case CLOCK_MONOTONIC:
1472         case CLOCK_MONOTONIC_RAW:
1473         case CLOCK_REALTIME_COARSE:
1474         case CLOCK_MONOTONIC_COARSE:
1475         case CLOCK_BOOTTIME:
1476         case CLOCK_TAI:
1477                 break;
1478         default:
1479                 return -EINVAL;
1480         }
1481
1482         ret = iio_device_set_clock(dev_to_iio_dev(dev), clk);
1483         if (ret)
1484                 return ret;
1485
1486         return len;
1487 }
1488
1489 int iio_device_register_sysfs_group(struct iio_dev *indio_dev,
1490                                     const struct attribute_group *group)
1491 {
1492         struct iio_dev_opaque *iio_dev_opaque = to_iio_dev_opaque(indio_dev);
1493         const struct attribute_group **new, **old = iio_dev_opaque->groups;
1494         unsigned int cnt = iio_dev_opaque->groupcounter;
1495
1496         new = krealloc_array(old, cnt + 2, sizeof(*new), GFP_KERNEL);
1497         if (!new)
1498                 return -ENOMEM;
1499
1500         new[iio_dev_opaque->groupcounter++] = group;
1501         new[iio_dev_opaque->groupcounter] = NULL;
1502
1503         iio_dev_opaque->groups = new;
1504
1505         return 0;
1506 }
1507
1508 static DEVICE_ATTR_RW(current_timestamp_clock);
1509
1510 static int iio_device_register_sysfs(struct iio_dev *indio_dev)
1511 {
1512         struct iio_dev_opaque *iio_dev_opaque = to_iio_dev_opaque(indio_dev);
1513         int i, ret = 0, attrcount, attrn, attrcount_orig = 0;
1514         struct iio_dev_attr *p;
1515         struct attribute **attr, *clk = NULL;
1516
1517         /* First count elements in any existing group */
1518         if (indio_dev->info->attrs) {
1519                 attr = indio_dev->info->attrs->attrs;
1520                 while (*attr++ != NULL)
1521                         attrcount_orig++;
1522         }
1523         attrcount = attrcount_orig;
1524         /*
1525          * New channel registration method - relies on the fact a group does
1526          * not need to be initialized if its name is NULL.
1527          */
1528         if (indio_dev->channels)
1529                 for (i = 0; i < indio_dev->num_channels; i++) {
1530                         const struct iio_chan_spec *chan =
1531                                 &indio_dev->channels[i];
1532
1533                         if (chan->type == IIO_TIMESTAMP)
1534                                 clk = &dev_attr_current_timestamp_clock.attr;
1535
1536                         ret = iio_device_add_channel_sysfs(indio_dev, chan);
1537                         if (ret < 0)
1538                                 goto error_clear_attrs;
1539                         attrcount += ret;
1540                 }
1541
1542         if (iio_dev_opaque->event_interface)
1543                 clk = &dev_attr_current_timestamp_clock.attr;
1544
1545         if (indio_dev->name)
1546                 attrcount++;
1547         if (indio_dev->label)
1548                 attrcount++;
1549         if (clk)
1550                 attrcount++;
1551
1552         iio_dev_opaque->chan_attr_group.attrs =
1553                 kcalloc(attrcount + 1,
1554                         sizeof(iio_dev_opaque->chan_attr_group.attrs[0]),
1555                         GFP_KERNEL);
1556         if (iio_dev_opaque->chan_attr_group.attrs == NULL) {
1557                 ret = -ENOMEM;
1558                 goto error_clear_attrs;
1559         }
1560         /* Copy across original attributes, and point to original binary attributes */
1561         if (indio_dev->info->attrs) {
1562                 memcpy(iio_dev_opaque->chan_attr_group.attrs,
1563                        indio_dev->info->attrs->attrs,
1564                        sizeof(iio_dev_opaque->chan_attr_group.attrs[0])
1565                        *attrcount_orig);
1566                 iio_dev_opaque->chan_attr_group.is_visible =
1567                         indio_dev->info->attrs->is_visible;
1568                 iio_dev_opaque->chan_attr_group.bin_attrs =
1569                         indio_dev->info->attrs->bin_attrs;
1570         }
1571         attrn = attrcount_orig;
1572         /* Add all elements from the list. */
1573         list_for_each_entry(p, &iio_dev_opaque->channel_attr_list, l)
1574                 iio_dev_opaque->chan_attr_group.attrs[attrn++] = &p->dev_attr.attr;
1575         if (indio_dev->name)
1576                 iio_dev_opaque->chan_attr_group.attrs[attrn++] = &dev_attr_name.attr;
1577         if (indio_dev->label)
1578                 iio_dev_opaque->chan_attr_group.attrs[attrn++] = &dev_attr_label.attr;
1579         if (clk)
1580                 iio_dev_opaque->chan_attr_group.attrs[attrn++] = clk;
1581
1582         ret = iio_device_register_sysfs_group(indio_dev,
1583                                               &iio_dev_opaque->chan_attr_group);
1584         if (ret)
1585                 goto error_free_chan_attrs;
1586
1587         return 0;
1588
1589 error_free_chan_attrs:
1590         kfree(iio_dev_opaque->chan_attr_group.attrs);
1591         iio_dev_opaque->chan_attr_group.attrs = NULL;
1592 error_clear_attrs:
1593         iio_free_chan_devattr_list(&iio_dev_opaque->channel_attr_list);
1594
1595         return ret;
1596 }
1597
1598 static void iio_device_unregister_sysfs(struct iio_dev *indio_dev)
1599 {
1600         struct iio_dev_opaque *iio_dev_opaque = to_iio_dev_opaque(indio_dev);
1601
1602         iio_free_chan_devattr_list(&iio_dev_opaque->channel_attr_list);
1603         kfree(iio_dev_opaque->chan_attr_group.attrs);
1604         iio_dev_opaque->chan_attr_group.attrs = NULL;
1605         kfree(iio_dev_opaque->groups);
1606         iio_dev_opaque->groups = NULL;
1607 }
1608
1609 static void iio_dev_release(struct device *device)
1610 {
1611         struct iio_dev *indio_dev = dev_to_iio_dev(device);
1612         struct iio_dev_opaque *iio_dev_opaque = to_iio_dev_opaque(indio_dev);
1613
1614         if (indio_dev->modes & INDIO_ALL_TRIGGERED_MODES)
1615                 iio_device_unregister_trigger_consumer(indio_dev);
1616         iio_device_unregister_eventset(indio_dev);
1617         iio_device_unregister_sysfs(indio_dev);
1618
1619         iio_device_detach_buffers(indio_dev);
1620
1621         lockdep_unregister_key(&iio_dev_opaque->mlock_key);
1622
1623         ida_free(&iio_ida, iio_dev_opaque->id);
1624         kfree(iio_dev_opaque);
1625 }
1626
1627 const struct device_type iio_device_type = {
1628         .name = "iio_device",
1629         .release = iio_dev_release,
1630 };
1631
1632 /**
1633  * iio_device_alloc() - allocate an iio_dev from a driver
1634  * @parent:             Parent device.
1635  * @sizeof_priv:        Space to allocate for private structure.
1636  *
1637  * Returns:
1638  * Pointer to allocated iio_dev on success, NULL on failure.
1639  */
1640 struct iio_dev *iio_device_alloc(struct device *parent, int sizeof_priv)
1641 {
1642         struct iio_dev_opaque *iio_dev_opaque;
1643         struct iio_dev *indio_dev;
1644         size_t alloc_size;
1645
1646         alloc_size = sizeof(struct iio_dev_opaque);
1647         if (sizeof_priv) {
1648                 alloc_size = ALIGN(alloc_size, IIO_DMA_MINALIGN);
1649                 alloc_size += sizeof_priv;
1650         }
1651
1652         iio_dev_opaque = kzalloc(alloc_size, GFP_KERNEL);
1653         if (!iio_dev_opaque)
1654                 return NULL;
1655
1656         indio_dev = &iio_dev_opaque->indio_dev;
1657         indio_dev->priv = (char *)iio_dev_opaque +
1658                 ALIGN(sizeof(struct iio_dev_opaque), IIO_DMA_MINALIGN);
1659
1660         indio_dev->dev.parent = parent;
1661         indio_dev->dev.type = &iio_device_type;
1662         indio_dev->dev.bus = &iio_bus_type;
1663         device_initialize(&indio_dev->dev);
1664         mutex_init(&iio_dev_opaque->mlock);
1665         mutex_init(&iio_dev_opaque->info_exist_lock);
1666         INIT_LIST_HEAD(&iio_dev_opaque->channel_attr_list);
1667
1668         iio_dev_opaque->id = ida_alloc(&iio_ida, GFP_KERNEL);
1669         if (iio_dev_opaque->id < 0) {
1670                 /* cannot use a dev_err as the name isn't available */
1671                 pr_err("failed to get device id\n");
1672                 kfree(iio_dev_opaque);
1673                 return NULL;
1674         }
1675
1676         if (dev_set_name(&indio_dev->dev, "iio:device%d", iio_dev_opaque->id)) {
1677                 ida_free(&iio_ida, iio_dev_opaque->id);
1678                 kfree(iio_dev_opaque);
1679                 return NULL;
1680         }
1681
1682         INIT_LIST_HEAD(&iio_dev_opaque->buffer_list);
1683         INIT_LIST_HEAD(&iio_dev_opaque->ioctl_handlers);
1684
1685         lockdep_register_key(&iio_dev_opaque->mlock_key);
1686         lockdep_set_class(&iio_dev_opaque->mlock, &iio_dev_opaque->mlock_key);
1687
1688         return indio_dev;
1689 }
1690 EXPORT_SYMBOL(iio_device_alloc);
1691
1692 /**
1693  * iio_device_free() - free an iio_dev from a driver
1694  * @dev:                the iio_dev associated with the device
1695  */
1696 void iio_device_free(struct iio_dev *dev)
1697 {
1698         if (dev)
1699                 put_device(&dev->dev);
1700 }
1701 EXPORT_SYMBOL(iio_device_free);
1702
1703 static void devm_iio_device_release(void *iio_dev)
1704 {
1705         iio_device_free(iio_dev);
1706 }
1707
1708 /**
1709  * devm_iio_device_alloc - Resource-managed iio_device_alloc()
1710  * @parent:             Device to allocate iio_dev for, and parent for this IIO device
1711  * @sizeof_priv:        Space to allocate for private structure.
1712  *
1713  * Managed iio_device_alloc. iio_dev allocated with this function is
1714  * automatically freed on driver detach.
1715  *
1716  * Returns:
1717  * Pointer to allocated iio_dev on success, NULL on failure.
1718  */
1719 struct iio_dev *devm_iio_device_alloc(struct device *parent, int sizeof_priv)
1720 {
1721         struct iio_dev *iio_dev;
1722         int ret;
1723
1724         iio_dev = iio_device_alloc(parent, sizeof_priv);
1725         if (!iio_dev)
1726                 return NULL;
1727
1728         ret = devm_add_action_or_reset(parent, devm_iio_device_release,
1729                                        iio_dev);
1730         if (ret)
1731                 return NULL;
1732
1733         return iio_dev;
1734 }
1735 EXPORT_SYMBOL_GPL(devm_iio_device_alloc);
1736
1737 /**
1738  * iio_chrdev_open() - chrdev file open for buffer access and ioctls
1739  * @inode:      Inode structure for identifying the device in the file system
1740  * @filp:       File structure for iio device used to keep and later access
1741  *              private data
1742  *
1743  * Returns: 0 on success or -EBUSY if the device is already opened
1744  */
1745 static int iio_chrdev_open(struct inode *inode, struct file *filp)
1746 {
1747         struct iio_dev_opaque *iio_dev_opaque =
1748                 container_of(inode->i_cdev, struct iio_dev_opaque, chrdev);
1749         struct iio_dev *indio_dev = &iio_dev_opaque->indio_dev;
1750         struct iio_dev_buffer_pair *ib;
1751
1752         if (test_and_set_bit(IIO_BUSY_BIT_POS, &iio_dev_opaque->flags))
1753                 return -EBUSY;
1754
1755         iio_device_get(indio_dev);
1756
1757         ib = kmalloc(sizeof(*ib), GFP_KERNEL);
1758         if (!ib) {
1759                 iio_device_put(indio_dev);
1760                 clear_bit(IIO_BUSY_BIT_POS, &iio_dev_opaque->flags);
1761                 return -ENOMEM;
1762         }
1763
1764         ib->indio_dev = indio_dev;
1765         ib->buffer = indio_dev->buffer;
1766
1767         filp->private_data = ib;
1768
1769         return 0;
1770 }
1771
1772 /**
1773  * iio_chrdev_release() - chrdev file close buffer access and ioctls
1774  * @inode:      Inode structure pointer for the char device
1775  * @filp:       File structure pointer for the char device
1776  *
1777  * Returns: 0 for successful release.
1778  */
1779 static int iio_chrdev_release(struct inode *inode, struct file *filp)
1780 {
1781         struct iio_dev_buffer_pair *ib = filp->private_data;
1782         struct iio_dev_opaque *iio_dev_opaque =
1783                 container_of(inode->i_cdev, struct iio_dev_opaque, chrdev);
1784         struct iio_dev *indio_dev = &iio_dev_opaque->indio_dev;
1785
1786         kfree(ib);
1787         clear_bit(IIO_BUSY_BIT_POS, &iio_dev_opaque->flags);
1788         iio_device_put(indio_dev);
1789
1790         return 0;
1791 }
1792
1793 void iio_device_ioctl_handler_register(struct iio_dev *indio_dev,
1794                                        struct iio_ioctl_handler *h)
1795 {
1796         struct iio_dev_opaque *iio_dev_opaque = to_iio_dev_opaque(indio_dev);
1797
1798         list_add_tail(&h->entry, &iio_dev_opaque->ioctl_handlers);
1799 }
1800
1801 void iio_device_ioctl_handler_unregister(struct iio_ioctl_handler *h)
1802 {
1803         list_del(&h->entry);
1804 }
1805
1806 static long iio_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
1807 {
1808         struct iio_dev_buffer_pair *ib = filp->private_data;
1809         struct iio_dev *indio_dev = ib->indio_dev;
1810         struct iio_dev_opaque *iio_dev_opaque = to_iio_dev_opaque(indio_dev);
1811         struct iio_ioctl_handler *h;
1812         int ret = -ENODEV;
1813
1814         mutex_lock(&iio_dev_opaque->info_exist_lock);
1815
1816         /*
1817          * The NULL check here is required to prevent crashing when a device
1818          * is being removed while userspace would still have open file handles
1819          * to try to access this device.
1820          */
1821         if (!indio_dev->info)
1822                 goto out_unlock;
1823
1824         list_for_each_entry(h, &iio_dev_opaque->ioctl_handlers, entry) {
1825                 ret = h->ioctl(indio_dev, filp, cmd, arg);
1826                 if (ret != IIO_IOCTL_UNHANDLED)
1827                         break;
1828         }
1829
1830         if (ret == IIO_IOCTL_UNHANDLED)
1831                 ret = -ENODEV;
1832
1833 out_unlock:
1834         mutex_unlock(&iio_dev_opaque->info_exist_lock);
1835
1836         return ret;
1837 }
1838
1839 static const struct file_operations iio_buffer_fileops = {
1840         .owner = THIS_MODULE,
1841         .llseek = noop_llseek,
1842         .read = iio_buffer_read_outer_addr,
1843         .write = iio_buffer_write_outer_addr,
1844         .poll = iio_buffer_poll_addr,
1845         .unlocked_ioctl = iio_ioctl,
1846         .compat_ioctl = compat_ptr_ioctl,
1847         .open = iio_chrdev_open,
1848         .release = iio_chrdev_release,
1849 };
1850
1851 static const struct file_operations iio_event_fileops = {
1852         .owner = THIS_MODULE,
1853         .llseek = noop_llseek,
1854         .unlocked_ioctl = iio_ioctl,
1855         .compat_ioctl = compat_ptr_ioctl,
1856         .open = iio_chrdev_open,
1857         .release = iio_chrdev_release,
1858 };
1859
1860 static int iio_check_unique_scan_index(struct iio_dev *indio_dev)
1861 {
1862         int i, j;
1863         const struct iio_chan_spec *channels = indio_dev->channels;
1864
1865         if (!(indio_dev->modes & INDIO_ALL_BUFFER_MODES))
1866                 return 0;
1867
1868         for (i = 0; i < indio_dev->num_channels - 1; i++) {
1869                 if (channels[i].scan_index < 0)
1870                         continue;
1871                 for (j = i + 1; j < indio_dev->num_channels; j++)
1872                         if (channels[i].scan_index == channels[j].scan_index) {
1873                                 dev_err(&indio_dev->dev,
1874                                         "Duplicate scan index %d\n",
1875                                         channels[i].scan_index);
1876                                 return -EINVAL;
1877                         }
1878         }
1879
1880         return 0;
1881 }
1882
1883 static int iio_check_extended_name(const struct iio_dev *indio_dev)
1884 {
1885         unsigned int i;
1886
1887         if (!indio_dev->info->read_label)
1888                 return 0;
1889
1890         for (i = 0; i < indio_dev->num_channels; i++) {
1891                 if (indio_dev->channels[i].extend_name) {
1892                         dev_err(&indio_dev->dev,
1893                                 "Cannot use labels and extend_name at the same time\n");
1894                         return -EINVAL;
1895                 }
1896         }
1897
1898         return 0;
1899 }
1900
1901 static const struct iio_buffer_setup_ops noop_ring_setup_ops;
1902
1903 static void iio_sanity_check_avail_scan_masks(struct iio_dev *indio_dev)
1904 {
1905         unsigned int num_masks, masklength, longs_per_mask;
1906         const unsigned long *av_masks;
1907         int i;
1908
1909         av_masks = indio_dev->available_scan_masks;
1910         masklength = indio_dev->masklength;
1911         longs_per_mask = BITS_TO_LONGS(masklength);
1912
1913         /*
1914          * The code determining how many available_scan_masks is in the array
1915          * will be assuming the end of masks when first long with all bits
1916          * zeroed is encountered. This is incorrect for masks where mask
1917          * consists of more than one long, and where some of the available masks
1918          * has long worth of bits zeroed (but has subsequent bit(s) set). This
1919          * is a safety measure against bug where array of masks is terminated by
1920          * a single zero while mask width is greater than width of a long.
1921          */
1922         if (longs_per_mask > 1)
1923                 dev_warn(indio_dev->dev.parent,
1924                          "multi long available scan masks not fully supported\n");
1925
1926         if (bitmap_empty(av_masks, masklength))
1927                 dev_warn(indio_dev->dev.parent, "empty scan mask\n");
1928
1929         for (num_masks = 0; *av_masks; num_masks++)
1930                 av_masks += longs_per_mask;
1931
1932         if (num_masks < 2)
1933                 return;
1934
1935         av_masks = indio_dev->available_scan_masks;
1936
1937         /*
1938          * Go through all the masks from first to one before the last, and see
1939          * that no mask found later from the available_scan_masks array is a
1940          * subset of mask found earlier. If this happens, then the mask found
1941          * later will never get used because scanning the array is stopped when
1942          * the first suitable mask is found. Drivers should order the array of
1943          * available masks in the order of preference (presumably the least
1944          * costy to access masks first).
1945          */
1946         for (i = 0; i < num_masks - 1; i++) {
1947                 const unsigned long *mask1;
1948                 int j;
1949
1950                 mask1 = av_masks + i * longs_per_mask;
1951                 for (j = i + 1; j < num_masks; j++) {
1952                         const unsigned long *mask2;
1953
1954                         mask2 = av_masks + j * longs_per_mask;
1955                         if (bitmap_subset(mask2, mask1, masklength))
1956                                 dev_warn(indio_dev->dev.parent,
1957                                          "available_scan_mask %d subset of %d. Never used\n",
1958                                          j, i);
1959                 }
1960         }
1961 }
1962
1963 int __iio_device_register(struct iio_dev *indio_dev, struct module *this_mod)
1964 {
1965         struct iio_dev_opaque *iio_dev_opaque = to_iio_dev_opaque(indio_dev);
1966         struct fwnode_handle *fwnode = NULL;
1967         int ret;
1968
1969         if (!indio_dev->info)
1970                 return -EINVAL;
1971
1972         iio_dev_opaque->driver_module = this_mod;
1973
1974         /* If the calling driver did not initialize firmware node, do it here */
1975         if (dev_fwnode(&indio_dev->dev))
1976                 fwnode = dev_fwnode(&indio_dev->dev);
1977         /* The default dummy IIO device has no parent */
1978         else if (indio_dev->dev.parent)
1979                 fwnode = dev_fwnode(indio_dev->dev.parent);
1980         device_set_node(&indio_dev->dev, fwnode);
1981
1982         fwnode_property_read_string(fwnode, "label", &indio_dev->label);
1983
1984         ret = iio_check_unique_scan_index(indio_dev);
1985         if (ret < 0)
1986                 return ret;
1987
1988         ret = iio_check_extended_name(indio_dev);
1989         if (ret < 0)
1990                 return ret;
1991
1992         iio_device_register_debugfs(indio_dev);
1993
1994         ret = iio_buffers_alloc_sysfs_and_mask(indio_dev);
1995         if (ret) {
1996                 dev_err(indio_dev->dev.parent,
1997                         "Failed to create buffer sysfs interfaces\n");
1998                 goto error_unreg_debugfs;
1999         }
2000
2001         if (indio_dev->available_scan_masks)
2002                 iio_sanity_check_avail_scan_masks(indio_dev);
2003
2004         ret = iio_device_register_sysfs(indio_dev);
2005         if (ret) {
2006                 dev_err(indio_dev->dev.parent,
2007                         "Failed to register sysfs interfaces\n");
2008                 goto error_buffer_free_sysfs;
2009         }
2010         ret = iio_device_register_eventset(indio_dev);
2011         if (ret) {
2012                 dev_err(indio_dev->dev.parent,
2013                         "Failed to register event set\n");
2014                 goto error_free_sysfs;
2015         }
2016         if (indio_dev->modes & INDIO_ALL_TRIGGERED_MODES)
2017                 iio_device_register_trigger_consumer(indio_dev);
2018
2019         if ((indio_dev->modes & INDIO_ALL_BUFFER_MODES) &&
2020                 indio_dev->setup_ops == NULL)
2021                 indio_dev->setup_ops = &noop_ring_setup_ops;
2022
2023         if (iio_dev_opaque->attached_buffers_cnt)
2024                 cdev_init(&iio_dev_opaque->chrdev, &iio_buffer_fileops);
2025         else if (iio_dev_opaque->event_interface)
2026                 cdev_init(&iio_dev_opaque->chrdev, &iio_event_fileops);
2027
2028         if (iio_dev_opaque->attached_buffers_cnt || iio_dev_opaque->event_interface) {
2029                 indio_dev->dev.devt = MKDEV(MAJOR(iio_devt), iio_dev_opaque->id);
2030                 iio_dev_opaque->chrdev.owner = this_mod;
2031         }
2032
2033         /* assign device groups now; they should be all registered now */
2034         indio_dev->dev.groups = iio_dev_opaque->groups;
2035
2036         ret = cdev_device_add(&iio_dev_opaque->chrdev, &indio_dev->dev);
2037         if (ret < 0)
2038                 goto error_unreg_eventset;
2039
2040         return 0;
2041
2042 error_unreg_eventset:
2043         iio_device_unregister_eventset(indio_dev);
2044 error_free_sysfs:
2045         iio_device_unregister_sysfs(indio_dev);
2046 error_buffer_free_sysfs:
2047         iio_buffers_free_sysfs_and_mask(indio_dev);
2048 error_unreg_debugfs:
2049         iio_device_unregister_debugfs(indio_dev);
2050         return ret;
2051 }
2052 EXPORT_SYMBOL(__iio_device_register);
2053
2054 /**
2055  * iio_device_unregister() - unregister a device from the IIO subsystem
2056  * @indio_dev:          Device structure representing the device.
2057  */
2058 void iio_device_unregister(struct iio_dev *indio_dev)
2059 {
2060         struct iio_dev_opaque *iio_dev_opaque = to_iio_dev_opaque(indio_dev);
2061
2062         cdev_device_del(&iio_dev_opaque->chrdev, &indio_dev->dev);
2063
2064         mutex_lock(&iio_dev_opaque->info_exist_lock);
2065
2066         iio_device_unregister_debugfs(indio_dev);
2067
2068         iio_disable_all_buffers(indio_dev);
2069
2070         indio_dev->info = NULL;
2071
2072         iio_device_wakeup_eventset(indio_dev);
2073         iio_buffer_wakeup_poll(indio_dev);
2074
2075         mutex_unlock(&iio_dev_opaque->info_exist_lock);
2076
2077         iio_buffers_free_sysfs_and_mask(indio_dev);
2078 }
2079 EXPORT_SYMBOL(iio_device_unregister);
2080
2081 static void devm_iio_device_unreg(void *indio_dev)
2082 {
2083         iio_device_unregister(indio_dev);
2084 }
2085
2086 int __devm_iio_device_register(struct device *dev, struct iio_dev *indio_dev,
2087                                struct module *this_mod)
2088 {
2089         int ret;
2090
2091         ret = __iio_device_register(indio_dev, this_mod);
2092         if (ret)
2093                 return ret;
2094
2095         return devm_add_action_or_reset(dev, devm_iio_device_unreg, indio_dev);
2096 }
2097 EXPORT_SYMBOL_GPL(__devm_iio_device_register);
2098
2099 /**
2100  * iio_device_claim_direct_mode - Keep device in direct mode
2101  * @indio_dev:  the iio_dev associated with the device
2102  *
2103  * If the device is in direct mode it is guaranteed to stay
2104  * that way until iio_device_release_direct_mode() is called.
2105  *
2106  * Use with iio_device_release_direct_mode()
2107  *
2108  * Returns: 0 on success, -EBUSY on failure.
2109  */
2110 int iio_device_claim_direct_mode(struct iio_dev *indio_dev)
2111 {
2112         struct iio_dev_opaque *iio_dev_opaque = to_iio_dev_opaque(indio_dev);
2113
2114         mutex_lock(&iio_dev_opaque->mlock);
2115
2116         if (iio_buffer_enabled(indio_dev)) {
2117                 mutex_unlock(&iio_dev_opaque->mlock);
2118                 return -EBUSY;
2119         }
2120         return 0;
2121 }
2122 EXPORT_SYMBOL_GPL(iio_device_claim_direct_mode);
2123
2124 /**
2125  * iio_device_release_direct_mode - releases claim on direct mode
2126  * @indio_dev:  the iio_dev associated with the device
2127  *
2128  * Release the claim. Device is no longer guaranteed to stay
2129  * in direct mode.
2130  *
2131  * Use with iio_device_claim_direct_mode()
2132  */
2133 void iio_device_release_direct_mode(struct iio_dev *indio_dev)
2134 {
2135         mutex_unlock(&to_iio_dev_opaque(indio_dev)->mlock);
2136 }
2137 EXPORT_SYMBOL_GPL(iio_device_release_direct_mode);
2138
2139 /**
2140  * iio_device_claim_buffer_mode - Keep device in buffer mode
2141  * @indio_dev:  the iio_dev associated with the device
2142  *
2143  * If the device is in buffer mode it is guaranteed to stay
2144  * that way until iio_device_release_buffer_mode() is called.
2145  *
2146  * Use with iio_device_release_buffer_mode().
2147  *
2148  * Returns: 0 on success, -EBUSY on failure.
2149  */
2150 int iio_device_claim_buffer_mode(struct iio_dev *indio_dev)
2151 {
2152         struct iio_dev_opaque *iio_dev_opaque = to_iio_dev_opaque(indio_dev);
2153
2154         mutex_lock(&iio_dev_opaque->mlock);
2155
2156         if (iio_buffer_enabled(indio_dev))
2157                 return 0;
2158
2159         mutex_unlock(&iio_dev_opaque->mlock);
2160         return -EBUSY;
2161 }
2162 EXPORT_SYMBOL_GPL(iio_device_claim_buffer_mode);
2163
2164 /**
2165  * iio_device_release_buffer_mode - releases claim on buffer mode
2166  * @indio_dev:  the iio_dev associated with the device
2167  *
2168  * Release the claim. Device is no longer guaranteed to stay
2169  * in buffer mode.
2170  *
2171  * Use with iio_device_claim_buffer_mode().
2172  */
2173 void iio_device_release_buffer_mode(struct iio_dev *indio_dev)
2174 {
2175         mutex_unlock(&to_iio_dev_opaque(indio_dev)->mlock);
2176 }
2177 EXPORT_SYMBOL_GPL(iio_device_release_buffer_mode);
2178
2179 /**
2180  * iio_device_get_current_mode() - helper function providing read-only access to
2181  *                                 the opaque @currentmode variable
2182  * @indio_dev:                     IIO device structure for device
2183  */
2184 int iio_device_get_current_mode(struct iio_dev *indio_dev)
2185 {
2186         struct iio_dev_opaque *iio_dev_opaque = to_iio_dev_opaque(indio_dev);
2187
2188         return iio_dev_opaque->currentmode;
2189 }
2190 EXPORT_SYMBOL_GPL(iio_device_get_current_mode);
2191
2192 subsys_initcall(iio_init);
2193 module_exit(iio_exit);
2194
2195 MODULE_AUTHOR("Jonathan Cameron <jic23@kernel.org>");
2196 MODULE_DESCRIPTION("Industrial I/O core");
2197 MODULE_LICENSE("GPL");