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