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