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