drivers/iio/industrialio-core.c

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