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 */ 37static DEFINE_IDA(iio_ida); 38 39static dev_t iio_devt; 40 41#define IIO_DEV_MAX 256 42struct bus_type iio_bus_type = { 43 .name = "iio", 44}; 45EXPORT_SYMBOL(iio_bus_type); 46 47static struct dentry *iio_debugfs_dentry; 48 49static const char * const iio_direction[] = { 50 [0] = "in", 51 [1] = "out", 52}; 53 54static 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 92static 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 */ 140static 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 */ 177struct 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} 182EXPORT_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 */ 190const 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 */ 202ssize_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} 208EXPORT_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 */ 215int 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} 234EXPORT_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 */ 240s64 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} 264EXPORT_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 */ 271unsigned 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} 287EXPORT_SYMBOL(iio_get_time_res); 288 289static 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 310error_unregister_bus_type: 311 bus_unregister(&iio_bus_type); 312error_nothing: 313 return ret; 314} 315 316static 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) 325static 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 355static 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", ®, &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 393static 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 399static 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 405static 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 426static void iio_device_register_debugfs(struct iio_dev *indio_dev) 427{ 428} 429 430static void iio_device_unregister_debugfs(struct iio_dev *indio_dev) 431{ 432} 433#endif /* CONFIG_DEBUG_FS */ 434 435static 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 448static 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 463ssize_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} 481EXPORT_SYMBOL_GPL(iio_enum_available_read); 482 483ssize_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} 500EXPORT_SYMBOL_GPL(iio_enum_read); 501 502ssize_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} 519EXPORT_SYMBOL_GPL(iio_enum_write); 520 521static 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 529static 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 537ssize_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} 554EXPORT_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 */ 568int 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} 590EXPORT_SYMBOL(iio_read_mount_matrix); 591 592static 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 bool scale_db = false; 598 599 switch (type) { 600 case IIO_VAL_INT: 601 return scnprintf(buf, len, "%d", vals[0]); 602 case IIO_VAL_INT_PLUS_MICRO_DB: 603 scale_db = true; 604 fallthrough; 605 case IIO_VAL_INT_PLUS_MICRO: 606 if (vals[1] < 0) 607 return scnprintf(buf, len, "-%d.%06u%s", abs(vals[0]), 608 -vals[1], scale_db ? " dB" : ""); 609 else 610 return scnprintf(buf, len, "%d.%06u%s", vals[0], vals[1], 611 scale_db ? " dB" : ""); 612 case IIO_VAL_INT_PLUS_NANO: 613 if (vals[1] < 0) 614 return scnprintf(buf, len, "-%d.%09u", abs(vals[0]), 615 -vals[1]); 616 else 617 return scnprintf(buf, len, "%d.%09u", vals[0], vals[1]); 618 case IIO_VAL_FRACTIONAL: 619 tmp = div_s64((s64)vals[0] * 1000000000LL, vals[1]); 620 tmp1 = vals[1]; 621 tmp0 = (int)div_s64_rem(tmp, 1000000000, &tmp1); 622 return scnprintf(buf, len, "%d.%09u", tmp0, abs(tmp1)); 623 case IIO_VAL_FRACTIONAL_LOG2: 624 tmp = shift_right((s64)vals[0] * 1000000000LL, vals[1]); 625 tmp0 = (int)div_s64_rem(tmp, 1000000000LL, &tmp1); 626 return scnprintf(buf, len, "%d.%09u", tmp0, abs(tmp1)); 627 case IIO_VAL_INT_MULTIPLE: 628 { 629 int i; 630 int l = 0; 631 632 for (i = 0; i < size; ++i) { 633 l += scnprintf(&buf[l], len - l, "%d ", vals[i]); 634 if (l >= len) 635 break; 636 } 637 return l; 638 } 639 case IIO_VAL_CHAR: 640 return scnprintf(buf, len, "%c", (char)vals[0]); 641 default: 642 return 0; 643 } 644} 645 646/** 647 * iio_format_value() - Formats a IIO value into its string representation 648 * @buf: The buffer to which the formatted value gets written 649 * which is assumed to be big enough (i.e. PAGE_SIZE). 650 * @type: One of the IIO_VAL_* constants. This decides how the val 651 * and val2 parameters are formatted. 652 * @size: Number of IIO value entries contained in vals 653 * @vals: Pointer to the values, exact meaning depends on the 654 * type parameter. 655 * 656 * Return: 0 by default, a negative number on failure or the 657 * total number of characters written for a type that belongs 658 * to the IIO_VAL_* constant. 659 */ 660ssize_t iio_format_value(char *buf, unsigned int type, int size, int *vals) 661{ 662 ssize_t len; 663 664 len = __iio_format_value(buf, PAGE_SIZE, type, size, vals); 665 if (len >= PAGE_SIZE - 1) 666 return -EFBIG; 667 668 return len + sprintf(buf + len, "\n"); 669} 670EXPORT_SYMBOL_GPL(iio_format_value); 671 672static ssize_t iio_read_channel_info(struct device *dev, 673 struct device_attribute *attr, 674 char *buf) 675{ 676 struct iio_dev *indio_dev = dev_to_iio_dev(dev); 677 struct iio_dev_attr *this_attr = to_iio_dev_attr(attr); 678 int vals[INDIO_MAX_RAW_ELEMENTS]; 679 int ret; 680 int val_len = 2; 681 682 if (indio_dev->info->read_raw_multi) 683 ret = indio_dev->info->read_raw_multi(indio_dev, this_attr->c, 684 INDIO_MAX_RAW_ELEMENTS, 685 vals, &val_len, 686 this_attr->address); 687 else 688 ret = indio_dev->info->read_raw(indio_dev, this_attr->c, 689 &vals[0], &vals[1], this_attr->address); 690 691 if (ret < 0) 692 return ret; 693 694 return iio_format_value(buf, ret, val_len, vals); 695} 696 697static ssize_t iio_format_avail_list(char *buf, const int *vals, 698 int type, int length) 699{ 700 int i; 701 ssize_t len = 0; 702 703 switch (type) { 704 case IIO_VAL_INT: 705 for (i = 0; i < length; i++) { 706 len += __iio_format_value(buf + len, PAGE_SIZE - len, 707 type, 1, &vals[i]); 708 if (len >= PAGE_SIZE) 709 return -EFBIG; 710 if (i < length - 1) 711 len += scnprintf(buf + len, PAGE_SIZE - len, 712 " "); 713 else 714 len += scnprintf(buf + len, PAGE_SIZE - len, 715 "\n"); 716 if (len >= PAGE_SIZE) 717 return -EFBIG; 718 } 719 break; 720 default: 721 for (i = 0; i < length / 2; i++) { 722 len += __iio_format_value(buf + len, PAGE_SIZE - len, 723 type, 2, &vals[i * 2]); 724 if (len >= PAGE_SIZE) 725 return -EFBIG; 726 if (i < length / 2 - 1) 727 len += scnprintf(buf + len, PAGE_SIZE - len, 728 " "); 729 else 730 len += scnprintf(buf + len, PAGE_SIZE - len, 731 "\n"); 732 if (len >= PAGE_SIZE) 733 return -EFBIG; 734 } 735 } 736 737 return len; 738} 739 740static ssize_t iio_format_avail_range(char *buf, const int *vals, int type) 741{ 742 int i; 743 ssize_t len; 744 745 len = snprintf(buf, PAGE_SIZE, "["); 746 switch (type) { 747 case IIO_VAL_INT: 748 for (i = 0; i < 3; i++) { 749 len += __iio_format_value(buf + len, PAGE_SIZE - len, 750 type, 1, &vals[i]); 751 if (len >= PAGE_SIZE) 752 return -EFBIG; 753 if (i < 2) 754 len += scnprintf(buf + len, PAGE_SIZE - len, 755 " "); 756 else 757 len += scnprintf(buf + len, PAGE_SIZE - len, 758 "]\n"); 759 if (len >= PAGE_SIZE) 760 return -EFBIG; 761 } 762 break; 763 default: 764 for (i = 0; i < 3; i++) { 765 len += __iio_format_value(buf + len, PAGE_SIZE - len, 766 type, 2, &vals[i * 2]); 767 if (len >= PAGE_SIZE) 768 return -EFBIG; 769 if (i < 2) 770 len += scnprintf(buf + len, PAGE_SIZE - len, 771 " "); 772 else 773 len += scnprintf(buf + len, PAGE_SIZE - len, 774 "]\n"); 775 if (len >= PAGE_SIZE) 776 return -EFBIG; 777 } 778 } 779 780 return len; 781} 782 783static ssize_t iio_read_channel_info_avail(struct device *dev, 784 struct device_attribute *attr, 785 char *buf) 786{ 787 struct iio_dev *indio_dev = dev_to_iio_dev(dev); 788 struct iio_dev_attr *this_attr = to_iio_dev_attr(attr); 789 const int *vals; 790 int ret; 791 int length; 792 int type; 793 794 ret = indio_dev->info->read_avail(indio_dev, this_attr->c, 795 &vals, &type, &length, 796 this_attr->address); 797 798 if (ret < 0) 799 return ret; 800 switch (ret) { 801 case IIO_AVAIL_LIST: 802 return iio_format_avail_list(buf, vals, type, length); 803 case IIO_AVAIL_RANGE: 804 return iio_format_avail_range(buf, vals, type); 805 default: 806 return -EINVAL; 807 } 808} 809 810/** 811 * __iio_str_to_fixpoint() - Parse a fixed-point number from a string 812 * @str: The string to parse 813 * @fract_mult: Multiplier for the first decimal place, should be a power of 10 814 * @integer: The integer part of the number 815 * @fract: The fractional part of the number 816 * @scale_db: True if this should parse as dB 817 * 818 * Returns 0 on success, or a negative error code if the string could not be 819 * parsed. 820 */ 821static int __iio_str_to_fixpoint(const char *str, int fract_mult, 822 int *integer, int *fract, bool scale_db) 823{ 824 int i = 0, f = 0; 825 bool integer_part = true, negative = false; 826 827 if (fract_mult == 0) { 828 *fract = 0; 829 830 return kstrtoint(str, 0, integer); 831 } 832 833 if (str[0] == '-') { 834 negative = true; 835 str++; 836 } else if (str[0] == '+') { 837 str++; 838 } 839 840 while (*str) { 841 if ('0' <= *str && *str <= '9') { 842 if (integer_part) { 843 i = i * 10 + *str - '0'; 844 } else { 845 f += fract_mult * (*str - '0'); 846 fract_mult /= 10; 847 } 848 } else if (*str == '\n') { 849 if (*(str + 1) == '\0') 850 break; 851 else 852 return -EINVAL; 853 } else if (!strncmp(str, " dB", sizeof(" dB") - 1) && scale_db) { 854 /* Ignore the dB suffix */ 855 str += sizeof(" dB") - 1; 856 continue; 857 } else if (!strncmp(str, "dB", sizeof("dB") - 1) && scale_db) { 858 /* Ignore the dB suffix */ 859 str += sizeof("dB") - 1; 860 continue; 861 } else if (*str == '.' && integer_part) { 862 integer_part = false; 863 } else { 864 return -EINVAL; 865 } 866 str++; 867 } 868 869 if (negative) { 870 if (i) 871 i = -i; 872 else 873 f = -f; 874 } 875 876 *integer = i; 877 *fract = f; 878 879 return 0; 880} 881 882/** 883 * iio_str_to_fixpoint() - Parse a fixed-point number from a string 884 * @str: The string to parse 885 * @fract_mult: Multiplier for the first decimal place, should be a power of 10 886 * @integer: The integer part of the number 887 * @fract: The fractional part of the number 888 * 889 * Returns 0 on success, or a negative error code if the string could not be 890 * parsed. 891 */ 892int iio_str_to_fixpoint(const char *str, int fract_mult, 893 int *integer, int *fract) 894{ 895 return __iio_str_to_fixpoint(str, fract_mult, integer, fract, false); 896} 897EXPORT_SYMBOL_GPL(iio_str_to_fixpoint); 898 899static ssize_t iio_write_channel_info(struct device *dev, 900 struct device_attribute *attr, 901 const char *buf, 902 size_t len) 903{ 904 struct iio_dev *indio_dev = dev_to_iio_dev(dev); 905 struct iio_dev_attr *this_attr = to_iio_dev_attr(attr); 906 int ret, fract_mult = 100000; 907 int integer, fract = 0; 908 bool is_char = false; 909 bool scale_db = false; 910 911 /* Assumes decimal - precision based on number of digits */ 912 if (!indio_dev->info->write_raw) 913 return -EINVAL; 914 915 if (indio_dev->info->write_raw_get_fmt) 916 switch (indio_dev->info->write_raw_get_fmt(indio_dev, 917 this_attr->c, this_attr->address)) { 918 case IIO_VAL_INT: 919 fract_mult = 0; 920 break; 921 case IIO_VAL_INT_PLUS_MICRO_DB: 922 scale_db = true; 923 fallthrough; 924 case IIO_VAL_INT_PLUS_MICRO: 925 fract_mult = 100000; 926 break; 927 case IIO_VAL_INT_PLUS_NANO: 928 fract_mult = 100000000; 929 break; 930 case IIO_VAL_CHAR: 931 is_char = true; 932 break; 933 default: 934 return -EINVAL; 935 } 936 937 if (is_char) { 938 char ch; 939 940 if (sscanf(buf, "%c", &ch) != 1) 941 return -EINVAL; 942 integer = ch; 943 } else { 944 ret = __iio_str_to_fixpoint(buf, fract_mult, &integer, &fract, 945 scale_db); 946 if (ret) 947 return ret; 948 } 949 950 ret = indio_dev->info->write_raw(indio_dev, this_attr->c, 951 integer, fract, this_attr->address); 952 if (ret) 953 return ret; 954 955 return len; 956} 957 958static 959int __iio_device_attr_init(struct device_attribute *dev_attr, 960 const char *postfix, 961 struct iio_chan_spec const *chan, 962 ssize_t (*readfunc)(struct device *dev, 963 struct device_attribute *attr, 964 char *buf), 965 ssize_t (*writefunc)(struct device *dev, 966 struct device_attribute *attr, 967 const char *buf, 968 size_t len), 969 enum iio_shared_by shared_by) 970{ 971 int ret = 0; 972 char *name = NULL; 973 char *full_postfix; 974 sysfs_attr_init(&dev_attr->attr); 975 976 /* Build up postfix of <extend_name>_<modifier>_postfix */ 977 if (chan->modified && (shared_by == IIO_SEPARATE)) { 978 if (chan->extend_name) 979 full_postfix = kasprintf(GFP_KERNEL, "%s_%s_%s", 980 iio_modifier_names[chan 981 ->channel2], 982 chan->extend_name, 983 postfix); 984 else 985 full_postfix = kasprintf(GFP_KERNEL, "%s_%s", 986 iio_modifier_names[chan 987 ->channel2], 988 postfix); 989 } else { 990 if (chan->extend_name == NULL || shared_by != IIO_SEPARATE) 991 full_postfix = kstrdup(postfix, GFP_KERNEL); 992 else 993 full_postfix = kasprintf(GFP_KERNEL, 994 "%s_%s", 995 chan->extend_name, 996 postfix); 997 } 998 if (full_postfix == NULL) 999 return -ENOMEM; 1000 1001 if (chan->differential) { /* Differential can not have modifier */ 1002 switch (shared_by) { 1003 case IIO_SHARED_BY_ALL: 1004 name = kasprintf(GFP_KERNEL, "%s", full_postfix); 1005 break; 1006 case IIO_SHARED_BY_DIR: 1007 name = kasprintf(GFP_KERNEL, "%s_%s", 1008 iio_direction[chan->output], 1009 full_postfix); 1010 break; 1011 case IIO_SHARED_BY_TYPE: 1012 name = kasprintf(GFP_KERNEL, "%s_%s-%s_%s", 1013 iio_direction[chan->output], 1014 iio_chan_type_name_spec[chan->type], 1015 iio_chan_type_name_spec[chan->type], 1016 full_postfix); 1017 break; 1018 case IIO_SEPARATE: 1019 if (!chan->indexed) { 1020 WARN(1, "Differential channels must be indexed\n"); 1021 ret = -EINVAL; 1022 goto error_free_full_postfix; 1023 } 1024 name = kasprintf(GFP_KERNEL, 1025 "%s_%s%d-%s%d_%s", 1026 iio_direction[chan->output], 1027 iio_chan_type_name_spec[chan->type], 1028 chan->channel, 1029 iio_chan_type_name_spec[chan->type], 1030 chan->channel2, 1031 full_postfix); 1032 break; 1033 } 1034 } else { /* Single ended */ 1035 switch (shared_by) { 1036 case IIO_SHARED_BY_ALL: 1037 name = kasprintf(GFP_KERNEL, "%s", full_postfix); 1038 break; 1039 case IIO_SHARED_BY_DIR: 1040 name = kasprintf(GFP_KERNEL, "%s_%s", 1041 iio_direction[chan->output], 1042 full_postfix); 1043 break; 1044 case IIO_SHARED_BY_TYPE: 1045 name = kasprintf(GFP_KERNEL, "%s_%s_%s", 1046 iio_direction[chan->output], 1047 iio_chan_type_name_spec[chan->type], 1048 full_postfix); 1049 break; 1050 1051 case IIO_SEPARATE: 1052 if (chan->indexed) 1053 name = kasprintf(GFP_KERNEL, "%s_%s%d_%s", 1054 iio_direction[chan->output], 1055 iio_chan_type_name_spec[chan->type], 1056 chan->channel, 1057 full_postfix); 1058 else 1059 name = kasprintf(GFP_KERNEL, "%s_%s_%s", 1060 iio_direction[chan->output], 1061 iio_chan_type_name_spec[chan->type], 1062 full_postfix); 1063 break; 1064 } 1065 } 1066 if (name == NULL) { 1067 ret = -ENOMEM; 1068 goto error_free_full_postfix; 1069 } 1070 dev_attr->attr.name = name; 1071 1072 if (readfunc) { 1073 dev_attr->attr.mode |= S_IRUGO; 1074 dev_attr->show = readfunc; 1075 } 1076 1077 if (writefunc) { 1078 dev_attr->attr.mode |= S_IWUSR; 1079 dev_attr->store = writefunc; 1080 } 1081 1082error_free_full_postfix: 1083 kfree(full_postfix); 1084 1085 return ret; 1086} 1087 1088static void __iio_device_attr_deinit(struct device_attribute *dev_attr) 1089{ 1090 kfree(dev_attr->attr.name); 1091} 1092 1093int __iio_add_chan_devattr(const char *postfix, 1094 struct iio_chan_spec const *chan, 1095 ssize_t (*readfunc)(struct device *dev, 1096 struct device_attribute *attr, 1097 char *buf), 1098 ssize_t (*writefunc)(struct device *dev, 1099 struct device_attribute *attr, 1100 const char *buf, 1101 size_t len), 1102 u64 mask, 1103 enum iio_shared_by shared_by, 1104 struct device *dev, 1105 struct list_head *attr_list) 1106{ 1107 int ret; 1108 struct iio_dev_attr *iio_attr, *t; 1109 1110 iio_attr = kzalloc(sizeof(*iio_attr), GFP_KERNEL); 1111 if (iio_attr == NULL) 1112 return -ENOMEM; 1113 ret = __iio_device_attr_init(&iio_attr->dev_attr, 1114 postfix, chan, 1115 readfunc, writefunc, shared_by); 1116 if (ret) 1117 goto error_iio_dev_attr_free; 1118 iio_attr->c = chan; 1119 iio_attr->address = mask; 1120 list_for_each_entry(t, attr_list, l) 1121 if (strcmp(t->dev_attr.attr.name, 1122 iio_attr->dev_attr.attr.name) == 0) { 1123 if (shared_by == IIO_SEPARATE) 1124 dev_err(dev, "tried to double register : %s\n", 1125 t->dev_attr.attr.name); 1126 ret = -EBUSY; 1127 goto error_device_attr_deinit; 1128 } 1129 list_add(&iio_attr->l, attr_list); 1130 1131 return 0; 1132 1133error_device_attr_deinit: 1134 __iio_device_attr_deinit(&iio_attr->dev_attr); 1135error_iio_dev_attr_free: 1136 kfree(iio_attr); 1137 return ret; 1138} 1139 1140static int iio_device_add_info_mask_type(struct iio_dev *indio_dev, 1141 struct iio_chan_spec const *chan, 1142 enum iio_shared_by shared_by, 1143 const long *infomask) 1144{ 1145 struct iio_dev_opaque *iio_dev_opaque = to_iio_dev_opaque(indio_dev); 1146 int i, ret, attrcount = 0; 1147 1148 for_each_set_bit(i, infomask, sizeof(*infomask)*8) { 1149 if (i >= ARRAY_SIZE(iio_chan_info_postfix)) 1150 return -EINVAL; 1151 ret = __iio_add_chan_devattr(iio_chan_info_postfix[i], 1152 chan, 1153 &iio_read_channel_info, 1154 &iio_write_channel_info, 1155 i, 1156 shared_by, 1157 &indio_dev->dev, 1158 &iio_dev_opaque->channel_attr_list); 1159 if ((ret == -EBUSY) && (shared_by != IIO_SEPARATE)) 1160 continue; 1161 else if (ret < 0) 1162 return ret; 1163 attrcount++; 1164 } 1165 1166 return attrcount; 1167} 1168 1169static int iio_device_add_info_mask_type_avail(struct iio_dev *indio_dev, 1170 struct iio_chan_spec const *chan, 1171 enum iio_shared_by shared_by, 1172 const long *infomask) 1173{ 1174 struct iio_dev_opaque *iio_dev_opaque = to_iio_dev_opaque(indio_dev); 1175 int i, ret, attrcount = 0; 1176 char *avail_postfix; 1177 1178 for_each_set_bit(i, infomask, sizeof(*infomask) * 8) { 1179 if (i >= ARRAY_SIZE(iio_chan_info_postfix)) 1180 return -EINVAL; 1181 avail_postfix = kasprintf(GFP_KERNEL, 1182 "%s_available", 1183 iio_chan_info_postfix[i]); 1184 if (!avail_postfix) 1185 return -ENOMEM; 1186 1187 ret = __iio_add_chan_devattr(avail_postfix, 1188 chan, 1189 &iio_read_channel_info_avail, 1190 NULL, 1191 i, 1192 shared_by, 1193 &indio_dev->dev, 1194 &iio_dev_opaque->channel_attr_list); 1195 kfree(avail_postfix); 1196 if ((ret == -EBUSY) && (shared_by != IIO_SEPARATE)) 1197 continue; 1198 else if (ret < 0) 1199 return ret; 1200 attrcount++; 1201 } 1202 1203 return attrcount; 1204} 1205 1206static int iio_device_add_channel_sysfs(struct iio_dev *indio_dev, 1207 struct iio_chan_spec const *chan) 1208{ 1209 struct iio_dev_opaque *iio_dev_opaque = to_iio_dev_opaque(indio_dev); 1210 int ret, attrcount = 0; 1211 const struct iio_chan_spec_ext_info *ext_info; 1212 1213 if (chan->channel < 0) 1214 return 0; 1215 ret = iio_device_add_info_mask_type(indio_dev, chan, 1216 IIO_SEPARATE, 1217 &chan->info_mask_separate); 1218 if (ret < 0) 1219 return ret; 1220 attrcount += ret; 1221 1222 ret = iio_device_add_info_mask_type_avail(indio_dev, chan, 1223 IIO_SEPARATE, 1224 &chan-> 1225 info_mask_separate_available); 1226 if (ret < 0) 1227 return ret; 1228 attrcount += ret; 1229 1230 ret = iio_device_add_info_mask_type(indio_dev, chan, 1231 IIO_SHARED_BY_TYPE, 1232 &chan->info_mask_shared_by_type); 1233 if (ret < 0) 1234 return ret; 1235 attrcount += ret; 1236 1237 ret = iio_device_add_info_mask_type_avail(indio_dev, chan, 1238 IIO_SHARED_BY_TYPE, 1239 &chan-> 1240 info_mask_shared_by_type_available); 1241 if (ret < 0) 1242 return ret; 1243 attrcount += ret; 1244 1245 ret = iio_device_add_info_mask_type(indio_dev, chan, 1246 IIO_SHARED_BY_DIR, 1247 &chan->info_mask_shared_by_dir); 1248 if (ret < 0) 1249 return ret; 1250 attrcount += ret; 1251 1252 ret = iio_device_add_info_mask_type_avail(indio_dev, chan, 1253 IIO_SHARED_BY_DIR, 1254 &chan->info_mask_shared_by_dir_available); 1255 if (ret < 0) 1256 return ret; 1257 attrcount += ret; 1258 1259 ret = iio_device_add_info_mask_type(indio_dev, chan, 1260 IIO_SHARED_BY_ALL, 1261 &chan->info_mask_shared_by_all); 1262 if (ret < 0) 1263 return ret; 1264 attrcount += ret; 1265 1266 ret = iio_device_add_info_mask_type_avail(indio_dev, chan, 1267 IIO_SHARED_BY_ALL, 1268 &chan->info_mask_shared_by_all_available); 1269 if (ret < 0) 1270 return ret; 1271 attrcount += ret; 1272 1273 if (chan->ext_info) { 1274 unsigned int i = 0; 1275 for (ext_info = chan->ext_info; ext_info->name; ext_info++) { 1276 ret = __iio_add_chan_devattr(ext_info->name, 1277 chan, 1278 ext_info->read ? 1279 &iio_read_channel_ext_info : NULL, 1280 ext_info->write ? 1281 &iio_write_channel_ext_info : NULL, 1282 i, 1283 ext_info->shared, 1284 &indio_dev->dev, 1285 &iio_dev_opaque->channel_attr_list); 1286 i++; 1287 if (ret == -EBUSY && ext_info->shared) 1288 continue; 1289 1290 if (ret) 1291 return ret; 1292 1293 attrcount++; 1294 } 1295 } 1296 1297 return attrcount; 1298} 1299 1300/** 1301 * iio_free_chan_devattr_list() - Free a list of IIO device attributes 1302 * @attr_list: List of IIO device attributes 1303 * 1304 * This function frees the memory allocated for each of the IIO device 1305 * attributes in the list. 1306 */ 1307void iio_free_chan_devattr_list(struct list_head *attr_list) 1308{ 1309 struct iio_dev_attr *p, *n; 1310 1311 list_for_each_entry_safe(p, n, attr_list, l) { 1312 kfree(p->dev_attr.attr.name); 1313 list_del(&p->l); 1314 kfree(p); 1315 } 1316} 1317 1318static ssize_t iio_show_dev_name(struct device *dev, 1319 struct device_attribute *attr, 1320 char *buf) 1321{ 1322 struct iio_dev *indio_dev = dev_to_iio_dev(dev); 1323 return snprintf(buf, PAGE_SIZE, "%s\n", indio_dev->name); 1324} 1325 1326static DEVICE_ATTR(name, S_IRUGO, iio_show_dev_name, NULL); 1327 1328static ssize_t iio_show_dev_label(struct device *dev, 1329 struct device_attribute *attr, 1330 char *buf) 1331{ 1332 struct iio_dev *indio_dev = dev_to_iio_dev(dev); 1333 return snprintf(buf, PAGE_SIZE, "%s\n", indio_dev->label); 1334} 1335 1336static DEVICE_ATTR(label, S_IRUGO, iio_show_dev_label, NULL); 1337 1338static ssize_t iio_show_timestamp_clock(struct device *dev, 1339 struct device_attribute *attr, 1340 char *buf) 1341{ 1342 const struct iio_dev *indio_dev = dev_to_iio_dev(dev); 1343 const clockid_t clk = iio_device_get_clock(indio_dev); 1344 const char *name; 1345 ssize_t sz; 1346 1347 switch (clk) { 1348 case CLOCK_REALTIME: 1349 name = "realtime\n"; 1350 sz = sizeof("realtime\n"); 1351 break; 1352 case CLOCK_MONOTONIC: 1353 name = "monotonic\n"; 1354 sz = sizeof("monotonic\n"); 1355 break; 1356 case CLOCK_MONOTONIC_RAW: 1357 name = "monotonic_raw\n"; 1358 sz = sizeof("monotonic_raw\n"); 1359 break; 1360 case CLOCK_REALTIME_COARSE: 1361 name = "realtime_coarse\n"; 1362 sz = sizeof("realtime_coarse\n"); 1363 break; 1364 case CLOCK_MONOTONIC_COARSE: 1365 name = "monotonic_coarse\n"; 1366 sz = sizeof("monotonic_coarse\n"); 1367 break; 1368 case CLOCK_BOOTTIME: 1369 name = "boottime\n"; 1370 sz = sizeof("boottime\n"); 1371 break; 1372 case CLOCK_TAI: 1373 name = "tai\n"; 1374 sz = sizeof("tai\n"); 1375 break; 1376 default: 1377 BUG(); 1378 } 1379 1380 memcpy(buf, name, sz); 1381 return sz; 1382} 1383 1384static ssize_t iio_store_timestamp_clock(struct device *dev, 1385 struct device_attribute *attr, 1386 const char *buf, size_t len) 1387{ 1388 clockid_t clk; 1389 int ret; 1390 1391 if (sysfs_streq(buf, "realtime")) 1392 clk = CLOCK_REALTIME; 1393 else if (sysfs_streq(buf, "monotonic")) 1394 clk = CLOCK_MONOTONIC; 1395 else if (sysfs_streq(buf, "monotonic_raw")) 1396 clk = CLOCK_MONOTONIC_RAW; 1397 else if (sysfs_streq(buf, "realtime_coarse")) 1398 clk = CLOCK_REALTIME_COARSE; 1399 else if (sysfs_streq(buf, "monotonic_coarse")) 1400 clk = CLOCK_MONOTONIC_COARSE; 1401 else if (sysfs_streq(buf, "boottime")) 1402 clk = CLOCK_BOOTTIME; 1403 else if (sysfs_streq(buf, "tai")) 1404 clk = CLOCK_TAI; 1405 else 1406 return -EINVAL; 1407 1408 ret = iio_device_set_clock(dev_to_iio_dev(dev), clk); 1409 if (ret) 1410 return ret; 1411 1412 return len; 1413} 1414 1415static DEVICE_ATTR(current_timestamp_clock, S_IRUGO | S_IWUSR, 1416 iio_show_timestamp_clock, iio_store_timestamp_clock); 1417 1418static int iio_device_register_sysfs(struct iio_dev *indio_dev) 1419{ 1420 struct iio_dev_opaque *iio_dev_opaque = to_iio_dev_opaque(indio_dev); 1421 int i, ret = 0, attrcount, attrn, attrcount_orig = 0; 1422 struct iio_dev_attr *p; 1423 struct attribute **attr, *clk = NULL; 1424 1425 /* First count elements in any existing group */ 1426 if (indio_dev->info->attrs) { 1427 attr = indio_dev->info->attrs->attrs; 1428 while (*attr++ != NULL) 1429 attrcount_orig++; 1430 } 1431 attrcount = attrcount_orig; 1432 /* 1433 * New channel registration method - relies on the fact a group does 1434 * not need to be initialized if its name is NULL. 1435 */ 1436 if (indio_dev->channels) 1437 for (i = 0; i < indio_dev->num_channels; i++) { 1438 const struct iio_chan_spec *chan = 1439 &indio_dev->channels[i]; 1440 1441 if (chan->type == IIO_TIMESTAMP) 1442 clk = &dev_attr_current_timestamp_clock.attr; 1443 1444 ret = iio_device_add_channel_sysfs(indio_dev, chan); 1445 if (ret < 0) 1446 goto error_clear_attrs; 1447 attrcount += ret; 1448 } 1449 1450 if (iio_dev_opaque->event_interface) 1451 clk = &dev_attr_current_timestamp_clock.attr; 1452 1453 if (indio_dev->name) 1454 attrcount++; 1455 if (indio_dev->label) 1456 attrcount++; 1457 if (clk) 1458 attrcount++; 1459 1460 iio_dev_opaque->chan_attr_group.attrs = 1461 kcalloc(attrcount + 1, 1462 sizeof(iio_dev_opaque->chan_attr_group.attrs[0]), 1463 GFP_KERNEL); 1464 if (iio_dev_opaque->chan_attr_group.attrs == NULL) { 1465 ret = -ENOMEM; 1466 goto error_clear_attrs; 1467 } 1468 /* Copy across original attributes */ 1469 if (indio_dev->info->attrs) 1470 memcpy(iio_dev_opaque->chan_attr_group.attrs, 1471 indio_dev->info->attrs->attrs, 1472 sizeof(iio_dev_opaque->chan_attr_group.attrs[0]) 1473 *attrcount_orig); 1474 attrn = attrcount_orig; 1475 /* Add all elements from the list. */ 1476 list_for_each_entry(p, &iio_dev_opaque->channel_attr_list, l) 1477 iio_dev_opaque->chan_attr_group.attrs[attrn++] = &p->dev_attr.attr; 1478 if (indio_dev->name) 1479 iio_dev_opaque->chan_attr_group.attrs[attrn++] = &dev_attr_name.attr; 1480 if (indio_dev->label) 1481 iio_dev_opaque->chan_attr_group.attrs[attrn++] = &dev_attr_label.attr; 1482 if (clk) 1483 iio_dev_opaque->chan_attr_group.attrs[attrn++] = clk; 1484 1485 indio_dev->groups[indio_dev->groupcounter++] = 1486 &iio_dev_opaque->chan_attr_group; 1487 1488 return 0; 1489 1490error_clear_attrs: 1491 iio_free_chan_devattr_list(&iio_dev_opaque->channel_attr_list); 1492 1493 return ret; 1494} 1495 1496static void iio_device_unregister_sysfs(struct iio_dev *indio_dev) 1497{ 1498 struct iio_dev_opaque *iio_dev_opaque = to_iio_dev_opaque(indio_dev); 1499 1500 iio_free_chan_devattr_list(&iio_dev_opaque->channel_attr_list); 1501 kfree(iio_dev_opaque->chan_attr_group.attrs); 1502 iio_dev_opaque->chan_attr_group.attrs = NULL; 1503} 1504 1505static void iio_dev_release(struct device *device) 1506{ 1507 struct iio_dev *indio_dev = dev_to_iio_dev(device); 1508 struct iio_dev_opaque *iio_dev_opaque = to_iio_dev_opaque(indio_dev); 1509 1510 if (indio_dev->modes & INDIO_ALL_TRIGGERED_MODES) 1511 iio_device_unregister_trigger_consumer(indio_dev); 1512 iio_device_unregister_eventset(indio_dev); 1513 iio_device_unregister_sysfs(indio_dev); 1514 1515 iio_buffer_put(indio_dev->buffer); 1516 1517 ida_simple_remove(&iio_ida, indio_dev->id); 1518 kfree(iio_dev_opaque); 1519} 1520 1521struct device_type iio_device_type = { 1522 .name = "iio_device", 1523 .release = iio_dev_release, 1524}; 1525 1526/** 1527 * iio_device_alloc() - allocate an iio_dev from a driver 1528 * @parent: Parent device. 1529 * @sizeof_priv: Space to allocate for private structure. 1530 **/ 1531struct iio_dev *iio_device_alloc(struct device *parent, int sizeof_priv) 1532{ 1533 struct iio_dev_opaque *iio_dev_opaque; 1534 struct iio_dev *dev; 1535 size_t alloc_size; 1536 1537 alloc_size = sizeof(struct iio_dev_opaque); 1538 if (sizeof_priv) { 1539 alloc_size = ALIGN(alloc_size, IIO_ALIGN); 1540 alloc_size += sizeof_priv; 1541 } 1542 1543 iio_dev_opaque = kzalloc(alloc_size, GFP_KERNEL); 1544 if (!iio_dev_opaque) 1545 return NULL; 1546 1547 dev = &iio_dev_opaque->indio_dev; 1548 dev->priv = (char *)iio_dev_opaque + 1549 ALIGN(sizeof(struct iio_dev_opaque), IIO_ALIGN); 1550 1551 dev->dev.parent = parent; 1552 dev->dev.groups = dev->groups; 1553 dev->dev.type = &iio_device_type; 1554 dev->dev.bus = &iio_bus_type; 1555 device_initialize(&dev->dev); 1556 dev_set_drvdata(&dev->dev, (void *)dev); 1557 mutex_init(&dev->mlock); 1558 mutex_init(&dev->info_exist_lock); 1559 INIT_LIST_HEAD(&iio_dev_opaque->channel_attr_list); 1560 1561 dev->id = ida_simple_get(&iio_ida, 0, 0, GFP_KERNEL); 1562 if (dev->id < 0) { 1563 /* cannot use a dev_err as the name isn't available */ 1564 pr_err("failed to get device id\n"); 1565 kfree(iio_dev_opaque); 1566 return NULL; 1567 } 1568 dev_set_name(&dev->dev, "iio:device%d", dev->id); 1569 INIT_LIST_HEAD(&iio_dev_opaque->buffer_list); 1570 1571 return dev; 1572} 1573EXPORT_SYMBOL(iio_device_alloc); 1574 1575/** 1576 * iio_device_free() - free an iio_dev from a driver 1577 * @dev: the iio_dev associated with the device 1578 **/ 1579void iio_device_free(struct iio_dev *dev) 1580{ 1581 if (dev) 1582 put_device(&dev->dev); 1583} 1584EXPORT_SYMBOL(iio_device_free); 1585 1586static void devm_iio_device_release(struct device *dev, void *res) 1587{ 1588 iio_device_free(*(struct iio_dev **)res); 1589} 1590 1591/** 1592 * devm_iio_device_alloc - Resource-managed iio_device_alloc() 1593 * @parent: Device to allocate iio_dev for, and parent for this IIO device 1594 * @sizeof_priv: Space to allocate for private structure. 1595 * 1596 * Managed iio_device_alloc. iio_dev allocated with this function is 1597 * automatically freed on driver detach. 1598 * 1599 * RETURNS: 1600 * Pointer to allocated iio_dev on success, NULL on failure. 1601 */ 1602struct iio_dev *devm_iio_device_alloc(struct device *parent, int sizeof_priv) 1603{ 1604 struct iio_dev **ptr, *iio_dev; 1605 1606 ptr = devres_alloc(devm_iio_device_release, sizeof(*ptr), 1607 GFP_KERNEL); 1608 if (!ptr) 1609 return NULL; 1610 1611 iio_dev = iio_device_alloc(parent, sizeof_priv); 1612 if (iio_dev) { 1613 *ptr = iio_dev; 1614 devres_add(parent, ptr); 1615 } else { 1616 devres_free(ptr); 1617 } 1618 1619 return iio_dev; 1620} 1621EXPORT_SYMBOL_GPL(devm_iio_device_alloc); 1622 1623/** 1624 * iio_chrdev_open() - chrdev file open for buffer access and ioctls 1625 * @inode: Inode structure for identifying the device in the file system 1626 * @filp: File structure for iio device used to keep and later access 1627 * private data 1628 * 1629 * Return: 0 on success or -EBUSY if the device is already opened 1630 **/ 1631static int iio_chrdev_open(struct inode *inode, struct file *filp) 1632{ 1633 struct iio_dev *indio_dev = container_of(inode->i_cdev, 1634 struct iio_dev, chrdev); 1635 1636 if (test_and_set_bit(IIO_BUSY_BIT_POS, &indio_dev->flags)) 1637 return -EBUSY; 1638 1639 iio_device_get(indio_dev); 1640 1641 filp->private_data = indio_dev; 1642 1643 return 0; 1644} 1645 1646/** 1647 * iio_chrdev_release() - chrdev file close buffer access and ioctls 1648 * @inode: Inode structure pointer for the char device 1649 * @filp: File structure pointer for the char device 1650 * 1651 * Return: 0 for successful release 1652 */ 1653static int iio_chrdev_release(struct inode *inode, struct file *filp) 1654{ 1655 struct iio_dev *indio_dev = container_of(inode->i_cdev, 1656 struct iio_dev, chrdev); 1657 clear_bit(IIO_BUSY_BIT_POS, &indio_dev->flags); 1658 iio_device_put(indio_dev); 1659 1660 return 0; 1661} 1662 1663/* Somewhat of a cross file organization violation - ioctls here are actually 1664 * event related */ 1665static long iio_ioctl(struct file *filp, unsigned int cmd, unsigned long arg) 1666{ 1667 struct iio_dev *indio_dev = filp->private_data; 1668 int __user *ip = (int __user *)arg; 1669 int fd; 1670 1671 if (!indio_dev->info) 1672 return -ENODEV; 1673 1674 if (cmd == IIO_GET_EVENT_FD_IOCTL) { 1675 fd = iio_event_getfd(indio_dev); 1676 if (fd < 0) 1677 return fd; 1678 if (copy_to_user(ip, &fd, sizeof(fd))) 1679 return -EFAULT; 1680 return 0; 1681 } 1682 return -EINVAL; 1683} 1684 1685static const struct file_operations iio_buffer_fileops = { 1686 .read = iio_buffer_read_outer_addr, 1687 .release = iio_chrdev_release, 1688 .open = iio_chrdev_open, 1689 .poll = iio_buffer_poll_addr, 1690 .owner = THIS_MODULE, 1691 .llseek = noop_llseek, 1692 .unlocked_ioctl = iio_ioctl, 1693 .compat_ioctl = compat_ptr_ioctl, 1694}; 1695 1696static int iio_check_unique_scan_index(struct iio_dev *indio_dev) 1697{ 1698 int i, j; 1699 const struct iio_chan_spec *channels = indio_dev->channels; 1700 1701 if (!(indio_dev->modes & INDIO_ALL_BUFFER_MODES)) 1702 return 0; 1703 1704 for (i = 0; i < indio_dev->num_channels - 1; i++) { 1705 if (channels[i].scan_index < 0) 1706 continue; 1707 for (j = i + 1; j < indio_dev->num_channels; j++) 1708 if (channels[i].scan_index == channels[j].scan_index) { 1709 dev_err(&indio_dev->dev, 1710 "Duplicate scan index %d\n", 1711 channels[i].scan_index); 1712 return -EINVAL; 1713 } 1714 } 1715 1716 return 0; 1717} 1718 1719static const struct iio_buffer_setup_ops noop_ring_setup_ops; 1720 1721int __iio_device_register(struct iio_dev *indio_dev, struct module *this_mod) 1722{ 1723 const char *label; 1724 int ret; 1725 1726 if (!indio_dev->info) 1727 return -EINVAL; 1728 1729 indio_dev->driver_module = this_mod; 1730 /* If the calling driver did not initialize of_node, do it here */ 1731 if (!indio_dev->dev.of_node && indio_dev->dev.parent) 1732 indio_dev->dev.of_node = indio_dev->dev.parent->of_node; 1733 1734 label = of_get_property(indio_dev->dev.of_node, "label", NULL); 1735 if (label) 1736 indio_dev->label = label; 1737 1738 ret = iio_check_unique_scan_index(indio_dev); 1739 if (ret < 0) 1740 return ret; 1741 1742 /* configure elements for the chrdev */ 1743 indio_dev->dev.devt = MKDEV(MAJOR(iio_devt), indio_dev->id); 1744 1745 iio_device_register_debugfs(indio_dev); 1746 1747 ret = iio_buffer_alloc_sysfs_and_mask(indio_dev); 1748 if (ret) { 1749 dev_err(indio_dev->dev.parent, 1750 "Failed to create buffer sysfs interfaces\n"); 1751 goto error_unreg_debugfs; 1752 } 1753 1754 ret = iio_device_register_sysfs(indio_dev); 1755 if (ret) { 1756 dev_err(indio_dev->dev.parent, 1757 "Failed to register sysfs interfaces\n"); 1758 goto error_buffer_free_sysfs; 1759 } 1760 ret = iio_device_register_eventset(indio_dev); 1761 if (ret) { 1762 dev_err(indio_dev->dev.parent, 1763 "Failed to register event set\n"); 1764 goto error_free_sysfs; 1765 } 1766 if (indio_dev->modes & INDIO_ALL_TRIGGERED_MODES) 1767 iio_device_register_trigger_consumer(indio_dev); 1768 1769 if ((indio_dev->modes & INDIO_ALL_BUFFER_MODES) && 1770 indio_dev->setup_ops == NULL) 1771 indio_dev->setup_ops = &noop_ring_setup_ops; 1772 1773 cdev_init(&indio_dev->chrdev, &iio_buffer_fileops); 1774 1775 indio_dev->chrdev.owner = this_mod; 1776 1777 ret = cdev_device_add(&indio_dev->chrdev, &indio_dev->dev); 1778 if (ret < 0) 1779 goto error_unreg_eventset; 1780 1781 return 0; 1782 1783error_unreg_eventset: 1784 iio_device_unregister_eventset(indio_dev); 1785error_free_sysfs: 1786 iio_device_unregister_sysfs(indio_dev); 1787error_buffer_free_sysfs: 1788 iio_buffer_free_sysfs_and_mask(indio_dev); 1789error_unreg_debugfs: 1790 iio_device_unregister_debugfs(indio_dev); 1791 return ret; 1792} 1793EXPORT_SYMBOL(__iio_device_register); 1794 1795/** 1796 * iio_device_unregister() - unregister a device from the IIO subsystem 1797 * @indio_dev: Device structure representing the device. 1798 **/ 1799void iio_device_unregister(struct iio_dev *indio_dev) 1800{ 1801 cdev_device_del(&indio_dev->chrdev, &indio_dev->dev); 1802 1803 mutex_lock(&indio_dev->info_exist_lock); 1804 1805 iio_device_unregister_debugfs(indio_dev); 1806 1807 iio_disable_all_buffers(indio_dev); 1808 1809 indio_dev->info = NULL; 1810 1811 iio_device_wakeup_eventset(indio_dev); 1812 iio_buffer_wakeup_poll(indio_dev); 1813 1814 mutex_unlock(&indio_dev->info_exist_lock); 1815 1816 iio_buffer_free_sysfs_and_mask(indio_dev); 1817} 1818EXPORT_SYMBOL(iio_device_unregister); 1819 1820static void devm_iio_device_unreg(struct device *dev, void *res) 1821{ 1822 iio_device_unregister(*(struct iio_dev **)res); 1823} 1824 1825int __devm_iio_device_register(struct device *dev, struct iio_dev *indio_dev, 1826 struct module *this_mod) 1827{ 1828 struct iio_dev **ptr; 1829 int ret; 1830 1831 ptr = devres_alloc(devm_iio_device_unreg, sizeof(*ptr), GFP_KERNEL); 1832 if (!ptr) 1833 return -ENOMEM; 1834 1835 *ptr = indio_dev; 1836 ret = __iio_device_register(indio_dev, this_mod); 1837 if (!ret) 1838 devres_add(dev, ptr); 1839 else 1840 devres_free(ptr); 1841 1842 return ret; 1843} 1844EXPORT_SYMBOL_GPL(__devm_iio_device_register); 1845 1846/** 1847 * iio_device_claim_direct_mode - Keep device in direct mode 1848 * @indio_dev: the iio_dev associated with the device 1849 * 1850 * If the device is in direct mode it is guaranteed to stay 1851 * that way until iio_device_release_direct_mode() is called. 1852 * 1853 * Use with iio_device_release_direct_mode() 1854 * 1855 * Returns: 0 on success, -EBUSY on failure 1856 */ 1857int iio_device_claim_direct_mode(struct iio_dev *indio_dev) 1858{ 1859 mutex_lock(&indio_dev->mlock); 1860 1861 if (iio_buffer_enabled(indio_dev)) { 1862 mutex_unlock(&indio_dev->mlock); 1863 return -EBUSY; 1864 } 1865 return 0; 1866} 1867EXPORT_SYMBOL_GPL(iio_device_claim_direct_mode); 1868 1869/** 1870 * iio_device_release_direct_mode - releases claim on direct mode 1871 * @indio_dev: the iio_dev associated with the device 1872 * 1873 * Release the claim. Device is no longer guaranteed to stay 1874 * in direct mode. 1875 * 1876 * Use with iio_device_claim_direct_mode() 1877 */ 1878void iio_device_release_direct_mode(struct iio_dev *indio_dev) 1879{ 1880 mutex_unlock(&indio_dev->mlock); 1881} 1882EXPORT_SYMBOL_GPL(iio_device_release_direct_mode); 1883 1884subsys_initcall(iio_init); 1885module_exit(iio_exit); 1886 1887MODULE_AUTHOR("Jonathan Cameron <jic23@kernel.org>"); 1888MODULE_DESCRIPTION("Industrial I/O core"); 1889MODULE_LICENSE("GPL"); 1890