drivers/iio/industrialio-core.c

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