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