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/iio/iio.h> 29#include "iio_core.h" 30#include "iio_core_trigger.h" 31#include <linux/iio/sysfs.h> 32#include <linux/iio/events.h> 33#include <linux/iio/buffer.h> 34 35/* IDA to assign each registered device a unique id */ 36static DEFINE_IDA(iio_ida); 37 38static dev_t iio_devt; 39 40#define IIO_DEV_MAX 256 41struct bus_type iio_bus_type = { 42 .name = "iio", 43}; 44EXPORT_SYMBOL(iio_bus_type); 45 46static struct dentry *iio_debugfs_dentry; 47 48static const char * const iio_direction[] = { 49 [0] = "in", 50 [1] = "out", 51}; 52 53static const char * const iio_chan_type_name_spec[] = { 54 [IIO_VOLTAGE] = "voltage", 55 [IIO_CURRENT] = "current", 56 [IIO_POWER] = "power", 57 [IIO_ACCEL] = "accel", 58 [IIO_ANGL_VEL] = "anglvel", 59 [IIO_MAGN] = "magn", 60 [IIO_LIGHT] = "illuminance", 61 [IIO_INTENSITY] = "intensity", 62 [IIO_PROXIMITY] = "proximity", 63 [IIO_TEMP] = "temp", 64 [IIO_INCLI] = "incli", 65 [IIO_ROT] = "rot", 66 [IIO_ANGL] = "angl", 67 [IIO_TIMESTAMP] = "timestamp", 68 [IIO_CAPACITANCE] = "capacitance", 69 [IIO_ALTVOLTAGE] = "altvoltage", 70 [IIO_CCT] = "cct", 71 [IIO_PRESSURE] = "pressure", 72 [IIO_HUMIDITYRELATIVE] = "humidityrelative", 73 [IIO_ACTIVITY] = "activity", 74 [IIO_STEPS] = "steps", 75 [IIO_ENERGY] = "energy", 76 [IIO_DISTANCE] = "distance", 77 [IIO_VELOCITY] = "velocity", 78}; 79 80static const char * const iio_modifier_names[] = { 81 [IIO_MOD_X] = "x", 82 [IIO_MOD_Y] = "y", 83 [IIO_MOD_Z] = "z", 84 [IIO_MOD_ROOT_SUM_SQUARED_X_Y] = "sqrt(x^2+y^2)", 85 [IIO_MOD_SUM_SQUARED_X_Y_Z] = "x^2+y^2+z^2", 86 [IIO_MOD_LIGHT_BOTH] = "both", 87 [IIO_MOD_LIGHT_IR] = "ir", 88 [IIO_MOD_LIGHT_CLEAR] = "clear", 89 [IIO_MOD_LIGHT_RED] = "red", 90 [IIO_MOD_LIGHT_GREEN] = "green", 91 [IIO_MOD_LIGHT_BLUE] = "blue", 92 [IIO_MOD_QUATERNION] = "quaternion", 93 [IIO_MOD_TEMP_AMBIENT] = "ambient", 94 [IIO_MOD_TEMP_OBJECT] = "object", 95 [IIO_MOD_NORTH_MAGN] = "from_north_magnetic", 96 [IIO_MOD_NORTH_TRUE] = "from_north_true", 97 [IIO_MOD_NORTH_MAGN_TILT_COMP] = "from_north_magnetic_tilt_comp", 98 [IIO_MOD_NORTH_TRUE_TILT_COMP] = "from_north_true_tilt_comp", 99 [IIO_MOD_RUNNING] = "running", 100 [IIO_MOD_JOGGING] = "jogging", 101 [IIO_MOD_WALKING] = "walking", 102 [IIO_MOD_STILL] = "still", 103 [IIO_MOD_ROOT_SUM_SQUARED_X_Y_Z] = "sqrt(x^2+y^2+z^2)", 104}; 105 106/* relies on pairs of these shared then separate */ 107static const char * const iio_chan_info_postfix[] = { 108 [IIO_CHAN_INFO_RAW] = "raw", 109 [IIO_CHAN_INFO_PROCESSED] = "input", 110 [IIO_CHAN_INFO_SCALE] = "scale", 111 [IIO_CHAN_INFO_OFFSET] = "offset", 112 [IIO_CHAN_INFO_CALIBSCALE] = "calibscale", 113 [IIO_CHAN_INFO_CALIBBIAS] = "calibbias", 114 [IIO_CHAN_INFO_PEAK] = "peak_raw", 115 [IIO_CHAN_INFO_PEAK_SCALE] = "peak_scale", 116 [IIO_CHAN_INFO_QUADRATURE_CORRECTION_RAW] = "quadrature_correction_raw", 117 [IIO_CHAN_INFO_AVERAGE_RAW] = "mean_raw", 118 [IIO_CHAN_INFO_LOW_PASS_FILTER_3DB_FREQUENCY] 119 = "filter_low_pass_3db_frequency", 120 [IIO_CHAN_INFO_SAMP_FREQ] = "sampling_frequency", 121 [IIO_CHAN_INFO_FREQUENCY] = "frequency", 122 [IIO_CHAN_INFO_PHASE] = "phase", 123 [IIO_CHAN_INFO_HARDWAREGAIN] = "hardwaregain", 124 [IIO_CHAN_INFO_HYSTERESIS] = "hysteresis", 125 [IIO_CHAN_INFO_INT_TIME] = "integration_time", 126 [IIO_CHAN_INFO_ENABLE] = "en", 127 [IIO_CHAN_INFO_CALIBHEIGHT] = "calibheight", 128 [IIO_CHAN_INFO_CALIBWEIGHT] = "calibweight", 129 [IIO_CHAN_INFO_DEBOUNCE_COUNT] = "debounce_count", 130 [IIO_CHAN_INFO_DEBOUNCE_TIME] = "debounce_time", 131}; 132 133/** 134 * iio_find_channel_from_si() - get channel from its scan index 135 * @indio_dev: device 136 * @si: scan index to match 137 */ 138const struct iio_chan_spec 139*iio_find_channel_from_si(struct iio_dev *indio_dev, int si) 140{ 141 int i; 142 143 for (i = 0; i < indio_dev->num_channels; i++) 144 if (indio_dev->channels[i].scan_index == si) 145 return &indio_dev->channels[i]; 146 return NULL; 147} 148 149/* This turns up an awful lot */ 150ssize_t iio_read_const_attr(struct device *dev, 151 struct device_attribute *attr, 152 char *buf) 153{ 154 return sprintf(buf, "%s\n", to_iio_const_attr(attr)->string); 155} 156EXPORT_SYMBOL(iio_read_const_attr); 157 158static int __init iio_init(void) 159{ 160 int ret; 161 162 /* Register sysfs bus */ 163 ret = bus_register(&iio_bus_type); 164 if (ret < 0) { 165 pr_err("could not register bus type\n"); 166 goto error_nothing; 167 } 168 169 ret = alloc_chrdev_region(&iio_devt, 0, IIO_DEV_MAX, "iio"); 170 if (ret < 0) { 171 pr_err("failed to allocate char dev region\n"); 172 goto error_unregister_bus_type; 173 } 174 175 iio_debugfs_dentry = debugfs_create_dir("iio", NULL); 176 177 return 0; 178 179error_unregister_bus_type: 180 bus_unregister(&iio_bus_type); 181error_nothing: 182 return ret; 183} 184 185static void __exit iio_exit(void) 186{ 187 if (iio_devt) 188 unregister_chrdev_region(iio_devt, IIO_DEV_MAX); 189 bus_unregister(&iio_bus_type); 190 debugfs_remove(iio_debugfs_dentry); 191} 192 193#if defined(CONFIG_DEBUG_FS) 194static ssize_t iio_debugfs_read_reg(struct file *file, char __user *userbuf, 195 size_t count, loff_t *ppos) 196{ 197 struct iio_dev *indio_dev = file->private_data; 198 char buf[20]; 199 unsigned val = 0; 200 ssize_t len; 201 int ret; 202 203 ret = indio_dev->info->debugfs_reg_access(indio_dev, 204 indio_dev->cached_reg_addr, 205 0, &val); 206 if (ret) 207 dev_err(indio_dev->dev.parent, "%s: read failed\n", __func__); 208 209 len = snprintf(buf, sizeof(buf), "0x%X\n", val); 210 211 return simple_read_from_buffer(userbuf, count, ppos, buf, len); 212} 213 214static ssize_t iio_debugfs_write_reg(struct file *file, 215 const char __user *userbuf, size_t count, loff_t *ppos) 216{ 217 struct iio_dev *indio_dev = file->private_data; 218 unsigned reg, val; 219 char buf[80]; 220 int ret; 221 222 count = min_t(size_t, count, (sizeof(buf)-1)); 223 if (copy_from_user(buf, userbuf, count)) 224 return -EFAULT; 225 226 buf[count] = 0; 227 228 ret = sscanf(buf, "%i %i", ®, &val); 229 230 switch (ret) { 231 case 1: 232 indio_dev->cached_reg_addr = reg; 233 break; 234 case 2: 235 indio_dev->cached_reg_addr = reg; 236 ret = indio_dev->info->debugfs_reg_access(indio_dev, reg, 237 val, NULL); 238 if (ret) { 239 dev_err(indio_dev->dev.parent, "%s: write failed\n", 240 __func__); 241 return ret; 242 } 243 break; 244 default: 245 return -EINVAL; 246 } 247 248 return count; 249} 250 251static const struct file_operations iio_debugfs_reg_fops = { 252 .open = simple_open, 253 .read = iio_debugfs_read_reg, 254 .write = iio_debugfs_write_reg, 255}; 256 257static void iio_device_unregister_debugfs(struct iio_dev *indio_dev) 258{ 259 debugfs_remove_recursive(indio_dev->debugfs_dentry); 260} 261 262static int iio_device_register_debugfs(struct iio_dev *indio_dev) 263{ 264 struct dentry *d; 265 266 if (indio_dev->info->debugfs_reg_access == NULL) 267 return 0; 268 269 if (!iio_debugfs_dentry) 270 return 0; 271 272 indio_dev->debugfs_dentry = 273 debugfs_create_dir(dev_name(&indio_dev->dev), 274 iio_debugfs_dentry); 275 if (indio_dev->debugfs_dentry == NULL) { 276 dev_warn(indio_dev->dev.parent, 277 "Failed to create debugfs directory\n"); 278 return -EFAULT; 279 } 280 281 d = debugfs_create_file("direct_reg_access", 0644, 282 indio_dev->debugfs_dentry, 283 indio_dev, &iio_debugfs_reg_fops); 284 if (!d) { 285 iio_device_unregister_debugfs(indio_dev); 286 return -ENOMEM; 287 } 288 289 return 0; 290} 291#else 292static int iio_device_register_debugfs(struct iio_dev *indio_dev) 293{ 294 return 0; 295} 296 297static void iio_device_unregister_debugfs(struct iio_dev *indio_dev) 298{ 299} 300#endif /* CONFIG_DEBUG_FS */ 301 302static ssize_t iio_read_channel_ext_info(struct device *dev, 303 struct device_attribute *attr, 304 char *buf) 305{ 306 struct iio_dev *indio_dev = dev_to_iio_dev(dev); 307 struct iio_dev_attr *this_attr = to_iio_dev_attr(attr); 308 const struct iio_chan_spec_ext_info *ext_info; 309 310 ext_info = &this_attr->c->ext_info[this_attr->address]; 311 312 return ext_info->read(indio_dev, ext_info->private, this_attr->c, buf); 313} 314 315static ssize_t iio_write_channel_ext_info(struct device *dev, 316 struct device_attribute *attr, 317 const char *buf, 318 size_t len) 319{ 320 struct iio_dev *indio_dev = dev_to_iio_dev(dev); 321 struct iio_dev_attr *this_attr = to_iio_dev_attr(attr); 322 const struct iio_chan_spec_ext_info *ext_info; 323 324 ext_info = &this_attr->c->ext_info[this_attr->address]; 325 326 return ext_info->write(indio_dev, ext_info->private, 327 this_attr->c, buf, len); 328} 329 330ssize_t iio_enum_available_read(struct iio_dev *indio_dev, 331 uintptr_t priv, const struct iio_chan_spec *chan, char *buf) 332{ 333 const struct iio_enum *e = (const struct iio_enum *)priv; 334 unsigned int i; 335 size_t len = 0; 336 337 if (!e->num_items) 338 return 0; 339 340 for (i = 0; i < e->num_items; ++i) 341 len += scnprintf(buf + len, PAGE_SIZE - len, "%s ", e->items[i]); 342 343 /* replace last space with a newline */ 344 buf[len - 1] = '\n'; 345 346 return len; 347} 348EXPORT_SYMBOL_GPL(iio_enum_available_read); 349 350ssize_t iio_enum_read(struct iio_dev *indio_dev, 351 uintptr_t priv, const struct iio_chan_spec *chan, char *buf) 352{ 353 const struct iio_enum *e = (const struct iio_enum *)priv; 354 int i; 355 356 if (!e->get) 357 return -EINVAL; 358 359 i = e->get(indio_dev, chan); 360 if (i < 0) 361 return i; 362 else if (i >= e->num_items) 363 return -EINVAL; 364 365 return snprintf(buf, PAGE_SIZE, "%s\n", e->items[i]); 366} 367EXPORT_SYMBOL_GPL(iio_enum_read); 368 369ssize_t iio_enum_write(struct iio_dev *indio_dev, 370 uintptr_t priv, const struct iio_chan_spec *chan, const char *buf, 371 size_t len) 372{ 373 const struct iio_enum *e = (const struct iio_enum *)priv; 374 unsigned int i; 375 int ret; 376 377 if (!e->set) 378 return -EINVAL; 379 380 for (i = 0; i < e->num_items; i++) { 381 if (sysfs_streq(buf, e->items[i])) 382 break; 383 } 384 385 if (i == e->num_items) 386 return -EINVAL; 387 388 ret = e->set(indio_dev, chan, i); 389 return ret ? ret : len; 390} 391EXPORT_SYMBOL_GPL(iio_enum_write); 392 393/** 394 * iio_format_value() - Formats a IIO value into its string representation 395 * @buf: The buffer to which the formated value gets written 396 * @type: One of the IIO_VAL_... constants. This decides how the val and val2 397 * parameters are formatted. 398 * @vals: pointer to the values, exact meaning depends on the type parameter. 399 */ 400ssize_t iio_format_value(char *buf, unsigned int type, int size, int *vals) 401{ 402 unsigned long long tmp; 403 bool scale_db = false; 404 405 switch (type) { 406 case IIO_VAL_INT: 407 return sprintf(buf, "%d\n", vals[0]); 408 case IIO_VAL_INT_PLUS_MICRO_DB: 409 scale_db = true; 410 case IIO_VAL_INT_PLUS_MICRO: 411 if (vals[1] < 0) 412 return sprintf(buf, "-%ld.%06u%s\n", abs(vals[0]), 413 -vals[1], 414 scale_db ? " dB" : ""); 415 else 416 return sprintf(buf, "%d.%06u%s\n", vals[0], vals[1], 417 scale_db ? " dB" : ""); 418 case IIO_VAL_INT_PLUS_NANO: 419 if (vals[1] < 0) 420 return sprintf(buf, "-%ld.%09u\n", abs(vals[0]), 421 -vals[1]); 422 else 423 return sprintf(buf, "%d.%09u\n", vals[0], vals[1]); 424 case IIO_VAL_FRACTIONAL: 425 tmp = div_s64((s64)vals[0] * 1000000000LL, vals[1]); 426 vals[1] = do_div(tmp, 1000000000LL); 427 vals[0] = tmp; 428 return sprintf(buf, "%d.%09u\n", vals[0], vals[1]); 429 case IIO_VAL_FRACTIONAL_LOG2: 430 tmp = (s64)vals[0] * 1000000000LL >> vals[1]; 431 vals[1] = do_div(tmp, 1000000000LL); 432 vals[0] = tmp; 433 return sprintf(buf, "%d.%09u\n", vals[0], vals[1]); 434 case IIO_VAL_INT_MULTIPLE: 435 { 436 int i; 437 int len = 0; 438 439 for (i = 0; i < size; ++i) 440 len += snprintf(&buf[len], PAGE_SIZE - len, "%d ", 441 vals[i]); 442 len += snprintf(&buf[len], PAGE_SIZE - len, "\n"); 443 return len; 444 } 445 default: 446 return 0; 447 } 448} 449 450static ssize_t iio_read_channel_info(struct device *dev, 451 struct device_attribute *attr, 452 char *buf) 453{ 454 struct iio_dev *indio_dev = dev_to_iio_dev(dev); 455 struct iio_dev_attr *this_attr = to_iio_dev_attr(attr); 456 int vals[INDIO_MAX_RAW_ELEMENTS]; 457 int ret; 458 int val_len = 2; 459 460 if (indio_dev->info->read_raw_multi) 461 ret = indio_dev->info->read_raw_multi(indio_dev, this_attr->c, 462 INDIO_MAX_RAW_ELEMENTS, 463 vals, &val_len, 464 this_attr->address); 465 else 466 ret = indio_dev->info->read_raw(indio_dev, this_attr->c, 467 &vals[0], &vals[1], this_attr->address); 468 469 if (ret < 0) 470 return ret; 471 472 return iio_format_value(buf, ret, val_len, vals); 473} 474 475/** 476 * iio_str_to_fixpoint() - Parse a fixed-point number from a string 477 * @str: The string to parse 478 * @fract_mult: Multiplier for the first decimal place, should be a power of 10 479 * @integer: The integer part of the number 480 * @fract: The fractional part of the number 481 * 482 * Returns 0 on success, or a negative error code if the string could not be 483 * parsed. 484 */ 485int iio_str_to_fixpoint(const char *str, int fract_mult, 486 int *integer, int *fract) 487{ 488 int i = 0, f = 0; 489 bool integer_part = true, negative = false; 490 491 if (str[0] == '-') { 492 negative = true; 493 str++; 494 } else if (str[0] == '+') { 495 str++; 496 } 497 498 while (*str) { 499 if ('0' <= *str && *str <= '9') { 500 if (integer_part) { 501 i = i * 10 + *str - '0'; 502 } else { 503 f += fract_mult * (*str - '0'); 504 fract_mult /= 10; 505 } 506 } else if (*str == '\n') { 507 if (*(str + 1) == '\0') 508 break; 509 else 510 return -EINVAL; 511 } else if (*str == '.' && integer_part) { 512 integer_part = false; 513 } else { 514 return -EINVAL; 515 } 516 str++; 517 } 518 519 if (negative) { 520 if (i) 521 i = -i; 522 else 523 f = -f; 524 } 525 526 *integer = i; 527 *fract = f; 528 529 return 0; 530} 531EXPORT_SYMBOL_GPL(iio_str_to_fixpoint); 532 533static ssize_t iio_write_channel_info(struct device *dev, 534 struct device_attribute *attr, 535 const char *buf, 536 size_t len) 537{ 538 struct iio_dev *indio_dev = dev_to_iio_dev(dev); 539 struct iio_dev_attr *this_attr = to_iio_dev_attr(attr); 540 int ret, fract_mult = 100000; 541 int integer, fract; 542 543 /* Assumes decimal - precision based on number of digits */ 544 if (!indio_dev->info->write_raw) 545 return -EINVAL; 546 547 if (indio_dev->info->write_raw_get_fmt) 548 switch (indio_dev->info->write_raw_get_fmt(indio_dev, 549 this_attr->c, this_attr->address)) { 550 case IIO_VAL_INT_PLUS_MICRO: 551 fract_mult = 100000; 552 break; 553 case IIO_VAL_INT_PLUS_NANO: 554 fract_mult = 100000000; 555 break; 556 default: 557 return -EINVAL; 558 } 559 560 ret = iio_str_to_fixpoint(buf, fract_mult, &integer, &fract); 561 if (ret) 562 return ret; 563 564 ret = indio_dev->info->write_raw(indio_dev, this_attr->c, 565 integer, fract, this_attr->address); 566 if (ret) 567 return ret; 568 569 return len; 570} 571 572static 573int __iio_device_attr_init(struct device_attribute *dev_attr, 574 const char *postfix, 575 struct iio_chan_spec const *chan, 576 ssize_t (*readfunc)(struct device *dev, 577 struct device_attribute *attr, 578 char *buf), 579 ssize_t (*writefunc)(struct device *dev, 580 struct device_attribute *attr, 581 const char *buf, 582 size_t len), 583 enum iio_shared_by shared_by) 584{ 585 int ret = 0; 586 char *name = NULL; 587 char *full_postfix; 588 sysfs_attr_init(&dev_attr->attr); 589 590 /* Build up postfix of <extend_name>_<modifier>_postfix */ 591 if (chan->modified && (shared_by == IIO_SEPARATE)) { 592 if (chan->extend_name) 593 full_postfix = kasprintf(GFP_KERNEL, "%s_%s_%s", 594 iio_modifier_names[chan 595 ->channel2], 596 chan->extend_name, 597 postfix); 598 else 599 full_postfix = kasprintf(GFP_KERNEL, "%s_%s", 600 iio_modifier_names[chan 601 ->channel2], 602 postfix); 603 } else { 604 if (chan->extend_name == NULL || shared_by != IIO_SEPARATE) 605 full_postfix = kstrdup(postfix, GFP_KERNEL); 606 else 607 full_postfix = kasprintf(GFP_KERNEL, 608 "%s_%s", 609 chan->extend_name, 610 postfix); 611 } 612 if (full_postfix == NULL) 613 return -ENOMEM; 614 615 if (chan->differential) { /* Differential can not have modifier */ 616 switch (shared_by) { 617 case IIO_SHARED_BY_ALL: 618 name = kasprintf(GFP_KERNEL, "%s", full_postfix); 619 break; 620 case IIO_SHARED_BY_DIR: 621 name = kasprintf(GFP_KERNEL, "%s_%s", 622 iio_direction[chan->output], 623 full_postfix); 624 break; 625 case IIO_SHARED_BY_TYPE: 626 name = kasprintf(GFP_KERNEL, "%s_%s-%s_%s", 627 iio_direction[chan->output], 628 iio_chan_type_name_spec[chan->type], 629 iio_chan_type_name_spec[chan->type], 630 full_postfix); 631 break; 632 case IIO_SEPARATE: 633 if (!chan->indexed) { 634 WARN_ON("Differential channels must be indexed\n"); 635 ret = -EINVAL; 636 goto error_free_full_postfix; 637 } 638 name = kasprintf(GFP_KERNEL, 639 "%s_%s%d-%s%d_%s", 640 iio_direction[chan->output], 641 iio_chan_type_name_spec[chan->type], 642 chan->channel, 643 iio_chan_type_name_spec[chan->type], 644 chan->channel2, 645 full_postfix); 646 break; 647 } 648 } else { /* Single ended */ 649 switch (shared_by) { 650 case IIO_SHARED_BY_ALL: 651 name = kasprintf(GFP_KERNEL, "%s", full_postfix); 652 break; 653 case IIO_SHARED_BY_DIR: 654 name = kasprintf(GFP_KERNEL, "%s_%s", 655 iio_direction[chan->output], 656 full_postfix); 657 break; 658 case IIO_SHARED_BY_TYPE: 659 name = kasprintf(GFP_KERNEL, "%s_%s_%s", 660 iio_direction[chan->output], 661 iio_chan_type_name_spec[chan->type], 662 full_postfix); 663 break; 664 665 case IIO_SEPARATE: 666 if (chan->indexed) 667 name = kasprintf(GFP_KERNEL, "%s_%s%d_%s", 668 iio_direction[chan->output], 669 iio_chan_type_name_spec[chan->type], 670 chan->channel, 671 full_postfix); 672 else 673 name = kasprintf(GFP_KERNEL, "%s_%s_%s", 674 iio_direction[chan->output], 675 iio_chan_type_name_spec[chan->type], 676 full_postfix); 677 break; 678 } 679 } 680 if (name == NULL) { 681 ret = -ENOMEM; 682 goto error_free_full_postfix; 683 } 684 dev_attr->attr.name = name; 685 686 if (readfunc) { 687 dev_attr->attr.mode |= S_IRUGO; 688 dev_attr->show = readfunc; 689 } 690 691 if (writefunc) { 692 dev_attr->attr.mode |= S_IWUSR; 693 dev_attr->store = writefunc; 694 } 695 696error_free_full_postfix: 697 kfree(full_postfix); 698 699 return ret; 700} 701 702static void __iio_device_attr_deinit(struct device_attribute *dev_attr) 703{ 704 kfree(dev_attr->attr.name); 705} 706 707int __iio_add_chan_devattr(const char *postfix, 708 struct iio_chan_spec const *chan, 709 ssize_t (*readfunc)(struct device *dev, 710 struct device_attribute *attr, 711 char *buf), 712 ssize_t (*writefunc)(struct device *dev, 713 struct device_attribute *attr, 714 const char *buf, 715 size_t len), 716 u64 mask, 717 enum iio_shared_by shared_by, 718 struct device *dev, 719 struct list_head *attr_list) 720{ 721 int ret; 722 struct iio_dev_attr *iio_attr, *t; 723 724 iio_attr = kzalloc(sizeof(*iio_attr), GFP_KERNEL); 725 if (iio_attr == NULL) 726 return -ENOMEM; 727 ret = __iio_device_attr_init(&iio_attr->dev_attr, 728 postfix, chan, 729 readfunc, writefunc, shared_by); 730 if (ret) 731 goto error_iio_dev_attr_free; 732 iio_attr->c = chan; 733 iio_attr->address = mask; 734 list_for_each_entry(t, attr_list, l) 735 if (strcmp(t->dev_attr.attr.name, 736 iio_attr->dev_attr.attr.name) == 0) { 737 if (shared_by == IIO_SEPARATE) 738 dev_err(dev, "tried to double register : %s\n", 739 t->dev_attr.attr.name); 740 ret = -EBUSY; 741 goto error_device_attr_deinit; 742 } 743 list_add(&iio_attr->l, attr_list); 744 745 return 0; 746 747error_device_attr_deinit: 748 __iio_device_attr_deinit(&iio_attr->dev_attr); 749error_iio_dev_attr_free: 750 kfree(iio_attr); 751 return ret; 752} 753 754static int iio_device_add_info_mask_type(struct iio_dev *indio_dev, 755 struct iio_chan_spec const *chan, 756 enum iio_shared_by shared_by, 757 const long *infomask) 758{ 759 int i, ret, attrcount = 0; 760 761 for_each_set_bit(i, infomask, sizeof(infomask)*8) { 762 if (i >= ARRAY_SIZE(iio_chan_info_postfix)) 763 return -EINVAL; 764 ret = __iio_add_chan_devattr(iio_chan_info_postfix[i], 765 chan, 766 &iio_read_channel_info, 767 &iio_write_channel_info, 768 i, 769 shared_by, 770 &indio_dev->dev, 771 &indio_dev->channel_attr_list); 772 if ((ret == -EBUSY) && (shared_by != IIO_SEPARATE)) 773 continue; 774 else if (ret < 0) 775 return ret; 776 attrcount++; 777 } 778 779 return attrcount; 780} 781 782static int iio_device_add_channel_sysfs(struct iio_dev *indio_dev, 783 struct iio_chan_spec const *chan) 784{ 785 int ret, attrcount = 0; 786 const struct iio_chan_spec_ext_info *ext_info; 787 788 if (chan->channel < 0) 789 return 0; 790 ret = iio_device_add_info_mask_type(indio_dev, chan, 791 IIO_SEPARATE, 792 &chan->info_mask_separate); 793 if (ret < 0) 794 return ret; 795 attrcount += ret; 796 797 ret = iio_device_add_info_mask_type(indio_dev, chan, 798 IIO_SHARED_BY_TYPE, 799 &chan->info_mask_shared_by_type); 800 if (ret < 0) 801 return ret; 802 attrcount += ret; 803 804 ret = iio_device_add_info_mask_type(indio_dev, chan, 805 IIO_SHARED_BY_DIR, 806 &chan->info_mask_shared_by_dir); 807 if (ret < 0) 808 return ret; 809 attrcount += ret; 810 811 ret = iio_device_add_info_mask_type(indio_dev, chan, 812 IIO_SHARED_BY_ALL, 813 &chan->info_mask_shared_by_all); 814 if (ret < 0) 815 return ret; 816 attrcount += ret; 817 818 if (chan->ext_info) { 819 unsigned int i = 0; 820 for (ext_info = chan->ext_info; ext_info->name; ext_info++) { 821 ret = __iio_add_chan_devattr(ext_info->name, 822 chan, 823 ext_info->read ? 824 &iio_read_channel_ext_info : NULL, 825 ext_info->write ? 826 &iio_write_channel_ext_info : NULL, 827 i, 828 ext_info->shared, 829 &indio_dev->dev, 830 &indio_dev->channel_attr_list); 831 i++; 832 if (ret == -EBUSY && ext_info->shared) 833 continue; 834 835 if (ret) 836 return ret; 837 838 attrcount++; 839 } 840 } 841 842 return attrcount; 843} 844 845/** 846 * iio_free_chan_devattr_list() - Free a list of IIO device attributes 847 * @attr_list: List of IIO device attributes 848 * 849 * This function frees the memory allocated for each of the IIO device 850 * attributes in the list. 851 */ 852void iio_free_chan_devattr_list(struct list_head *attr_list) 853{ 854 struct iio_dev_attr *p, *n; 855 856 list_for_each_entry_safe(p, n, attr_list, l) { 857 kfree(p->dev_attr.attr.name); 858 list_del(&p->l); 859 kfree(p); 860 } 861} 862 863static ssize_t iio_show_dev_name(struct device *dev, 864 struct device_attribute *attr, 865 char *buf) 866{ 867 struct iio_dev *indio_dev = dev_to_iio_dev(dev); 868 return snprintf(buf, PAGE_SIZE, "%s\n", indio_dev->name); 869} 870 871static DEVICE_ATTR(name, S_IRUGO, iio_show_dev_name, NULL); 872 873static int iio_device_register_sysfs(struct iio_dev *indio_dev) 874{ 875 int i, ret = 0, attrcount, attrn, attrcount_orig = 0; 876 struct iio_dev_attr *p; 877 struct attribute **attr; 878 879 /* First count elements in any existing group */ 880 if (indio_dev->info->attrs) { 881 attr = indio_dev->info->attrs->attrs; 882 while (*attr++ != NULL) 883 attrcount_orig++; 884 } 885 attrcount = attrcount_orig; 886 /* 887 * New channel registration method - relies on the fact a group does 888 * not need to be initialized if its name is NULL. 889 */ 890 if (indio_dev->channels) 891 for (i = 0; i < indio_dev->num_channels; i++) { 892 ret = iio_device_add_channel_sysfs(indio_dev, 893 &indio_dev 894 ->channels[i]); 895 if (ret < 0) 896 goto error_clear_attrs; 897 attrcount += ret; 898 } 899 900 if (indio_dev->name) 901 attrcount++; 902 903 indio_dev->chan_attr_group.attrs = kcalloc(attrcount + 1, 904 sizeof(indio_dev->chan_attr_group.attrs[0]), 905 GFP_KERNEL); 906 if (indio_dev->chan_attr_group.attrs == NULL) { 907 ret = -ENOMEM; 908 goto error_clear_attrs; 909 } 910 /* Copy across original attributes */ 911 if (indio_dev->info->attrs) 912 memcpy(indio_dev->chan_attr_group.attrs, 913 indio_dev->info->attrs->attrs, 914 sizeof(indio_dev->chan_attr_group.attrs[0]) 915 *attrcount_orig); 916 attrn = attrcount_orig; 917 /* Add all elements from the list. */ 918 list_for_each_entry(p, &indio_dev->channel_attr_list, l) 919 indio_dev->chan_attr_group.attrs[attrn++] = &p->dev_attr.attr; 920 if (indio_dev->name) 921 indio_dev->chan_attr_group.attrs[attrn++] = &dev_attr_name.attr; 922 923 indio_dev->groups[indio_dev->groupcounter++] = 924 &indio_dev->chan_attr_group; 925 926 return 0; 927 928error_clear_attrs: 929 iio_free_chan_devattr_list(&indio_dev->channel_attr_list); 930 931 return ret; 932} 933 934static void iio_device_unregister_sysfs(struct iio_dev *indio_dev) 935{ 936 937 iio_free_chan_devattr_list(&indio_dev->channel_attr_list); 938 kfree(indio_dev->chan_attr_group.attrs); 939 indio_dev->chan_attr_group.attrs = NULL; 940} 941 942static void iio_dev_release(struct device *device) 943{ 944 struct iio_dev *indio_dev = dev_to_iio_dev(device); 945 if (indio_dev->modes & INDIO_BUFFER_TRIGGERED) 946 iio_device_unregister_trigger_consumer(indio_dev); 947 iio_device_unregister_eventset(indio_dev); 948 iio_device_unregister_sysfs(indio_dev); 949 950 iio_buffer_put(indio_dev->buffer); 951 952 ida_simple_remove(&iio_ida, indio_dev->id); 953 kfree(indio_dev); 954} 955 956struct device_type iio_device_type = { 957 .name = "iio_device", 958 .release = iio_dev_release, 959}; 960 961/** 962 * iio_device_alloc() - allocate an iio_dev from a driver 963 * @sizeof_priv: Space to allocate for private structure. 964 **/ 965struct iio_dev *iio_device_alloc(int sizeof_priv) 966{ 967 struct iio_dev *dev; 968 size_t alloc_size; 969 970 alloc_size = sizeof(struct iio_dev); 971 if (sizeof_priv) { 972 alloc_size = ALIGN(alloc_size, IIO_ALIGN); 973 alloc_size += sizeof_priv; 974 } 975 /* ensure 32-byte alignment of whole construct ? */ 976 alloc_size += IIO_ALIGN - 1; 977 978 dev = kzalloc(alloc_size, GFP_KERNEL); 979 980 if (dev) { 981 dev->dev.groups = dev->groups; 982 dev->dev.type = &iio_device_type; 983 dev->dev.bus = &iio_bus_type; 984 device_initialize(&dev->dev); 985 dev_set_drvdata(&dev->dev, (void *)dev); 986 mutex_init(&dev->mlock); 987 mutex_init(&dev->info_exist_lock); 988 INIT_LIST_HEAD(&dev->channel_attr_list); 989 990 dev->id = ida_simple_get(&iio_ida, 0, 0, GFP_KERNEL); 991 if (dev->id < 0) { 992 /* cannot use a dev_err as the name isn't available */ 993 pr_err("failed to get device id\n"); 994 kfree(dev); 995 return NULL; 996 } 997 dev_set_name(&dev->dev, "iio:device%d", dev->id); 998 INIT_LIST_HEAD(&dev->buffer_list); 999 } 1000 1001 return dev; 1002} 1003EXPORT_SYMBOL(iio_device_alloc); 1004 1005/** 1006 * iio_device_free() - free an iio_dev from a driver 1007 * @dev: the iio_dev associated with the device 1008 **/ 1009void iio_device_free(struct iio_dev *dev) 1010{ 1011 if (dev) 1012 put_device(&dev->dev); 1013} 1014EXPORT_SYMBOL(iio_device_free); 1015 1016static void devm_iio_device_release(struct device *dev, void *res) 1017{ 1018 iio_device_free(*(struct iio_dev **)res); 1019} 1020 1021static int devm_iio_device_match(struct device *dev, void *res, void *data) 1022{ 1023 struct iio_dev **r = res; 1024 if (!r || !*r) { 1025 WARN_ON(!r || !*r); 1026 return 0; 1027 } 1028 return *r == data; 1029} 1030 1031/** 1032 * devm_iio_device_alloc - Resource-managed iio_device_alloc() 1033 * @dev: Device to allocate iio_dev for 1034 * @sizeof_priv: Space to allocate for private structure. 1035 * 1036 * Managed iio_device_alloc. iio_dev allocated with this function is 1037 * automatically freed on driver detach. 1038 * 1039 * If an iio_dev allocated with this function needs to be freed separately, 1040 * devm_iio_device_free() must be used. 1041 * 1042 * RETURNS: 1043 * Pointer to allocated iio_dev on success, NULL on failure. 1044 */ 1045struct iio_dev *devm_iio_device_alloc(struct device *dev, int sizeof_priv) 1046{ 1047 struct iio_dev **ptr, *iio_dev; 1048 1049 ptr = devres_alloc(devm_iio_device_release, sizeof(*ptr), 1050 GFP_KERNEL); 1051 if (!ptr) 1052 return NULL; 1053 1054 iio_dev = iio_device_alloc(sizeof_priv); 1055 if (iio_dev) { 1056 *ptr = iio_dev; 1057 devres_add(dev, ptr); 1058 } else { 1059 devres_free(ptr); 1060 } 1061 1062 return iio_dev; 1063} 1064EXPORT_SYMBOL_GPL(devm_iio_device_alloc); 1065 1066/** 1067 * devm_iio_device_free - Resource-managed iio_device_free() 1068 * @dev: Device this iio_dev belongs to 1069 * @iio_dev: the iio_dev associated with the device 1070 * 1071 * Free iio_dev allocated with devm_iio_device_alloc(). 1072 */ 1073void devm_iio_device_free(struct device *dev, struct iio_dev *iio_dev) 1074{ 1075 int rc; 1076 1077 rc = devres_release(dev, devm_iio_device_release, 1078 devm_iio_device_match, iio_dev); 1079 WARN_ON(rc); 1080} 1081EXPORT_SYMBOL_GPL(devm_iio_device_free); 1082 1083/** 1084 * iio_chrdev_open() - chrdev file open for buffer access and ioctls 1085 **/ 1086static int iio_chrdev_open(struct inode *inode, struct file *filp) 1087{ 1088 struct iio_dev *indio_dev = container_of(inode->i_cdev, 1089 struct iio_dev, chrdev); 1090 1091 if (test_and_set_bit(IIO_BUSY_BIT_POS, &indio_dev->flags)) 1092 return -EBUSY; 1093 1094 iio_device_get(indio_dev); 1095 1096 filp->private_data = indio_dev; 1097 1098 return 0; 1099} 1100 1101/** 1102 * iio_chrdev_release() - chrdev file close buffer access and ioctls 1103 **/ 1104static int iio_chrdev_release(struct inode *inode, struct file *filp) 1105{ 1106 struct iio_dev *indio_dev = container_of(inode->i_cdev, 1107 struct iio_dev, chrdev); 1108 clear_bit(IIO_BUSY_BIT_POS, &indio_dev->flags); 1109 iio_device_put(indio_dev); 1110 1111 return 0; 1112} 1113 1114/* Somewhat of a cross file organization violation - ioctls here are actually 1115 * event related */ 1116static long iio_ioctl(struct file *filp, unsigned int cmd, unsigned long arg) 1117{ 1118 struct iio_dev *indio_dev = filp->private_data; 1119 int __user *ip = (int __user *)arg; 1120 int fd; 1121 1122 if (!indio_dev->info) 1123 return -ENODEV; 1124 1125 if (cmd == IIO_GET_EVENT_FD_IOCTL) { 1126 fd = iio_event_getfd(indio_dev); 1127 if (copy_to_user(ip, &fd, sizeof(fd))) 1128 return -EFAULT; 1129 return 0; 1130 } 1131 return -EINVAL; 1132} 1133 1134static const struct file_operations iio_buffer_fileops = { 1135 .read = iio_buffer_read_first_n_outer_addr, 1136 .release = iio_chrdev_release, 1137 .open = iio_chrdev_open, 1138 .poll = iio_buffer_poll_addr, 1139 .owner = THIS_MODULE, 1140 .llseek = noop_llseek, 1141 .unlocked_ioctl = iio_ioctl, 1142 .compat_ioctl = iio_ioctl, 1143}; 1144 1145static int iio_check_unique_scan_index(struct iio_dev *indio_dev) 1146{ 1147 int i, j; 1148 const struct iio_chan_spec *channels = indio_dev->channels; 1149 1150 if (!(indio_dev->modes & INDIO_ALL_BUFFER_MODES)) 1151 return 0; 1152 1153 for (i = 0; i < indio_dev->num_channels - 1; i++) { 1154 if (channels[i].scan_index < 0) 1155 continue; 1156 for (j = i + 1; j < indio_dev->num_channels; j++) 1157 if (channels[i].scan_index == channels[j].scan_index) { 1158 dev_err(&indio_dev->dev, 1159 "Duplicate scan index %d\n", 1160 channels[i].scan_index); 1161 return -EINVAL; 1162 } 1163 } 1164 1165 return 0; 1166} 1167 1168static const struct iio_buffer_setup_ops noop_ring_setup_ops; 1169 1170/** 1171 * iio_device_register() - register a device with the IIO subsystem 1172 * @indio_dev: Device structure filled by the device driver 1173 **/ 1174int iio_device_register(struct iio_dev *indio_dev) 1175{ 1176 int ret; 1177 1178 /* If the calling driver did not initialize of_node, do it here */ 1179 if (!indio_dev->dev.of_node && indio_dev->dev.parent) 1180 indio_dev->dev.of_node = indio_dev->dev.parent->of_node; 1181 1182 ret = iio_check_unique_scan_index(indio_dev); 1183 if (ret < 0) 1184 return ret; 1185 1186 /* configure elements for the chrdev */ 1187 indio_dev->dev.devt = MKDEV(MAJOR(iio_devt), indio_dev->id); 1188 1189 ret = iio_device_register_debugfs(indio_dev); 1190 if (ret) { 1191 dev_err(indio_dev->dev.parent, 1192 "Failed to register debugfs interfaces\n"); 1193 return ret; 1194 } 1195 1196 ret = iio_buffer_alloc_sysfs_and_mask(indio_dev); 1197 if (ret) { 1198 dev_err(indio_dev->dev.parent, 1199 "Failed to create buffer sysfs interfaces\n"); 1200 goto error_unreg_debugfs; 1201 } 1202 1203 ret = iio_device_register_sysfs(indio_dev); 1204 if (ret) { 1205 dev_err(indio_dev->dev.parent, 1206 "Failed to register sysfs interfaces\n"); 1207 goto error_buffer_free_sysfs; 1208 } 1209 ret = iio_device_register_eventset(indio_dev); 1210 if (ret) { 1211 dev_err(indio_dev->dev.parent, 1212 "Failed to register event set\n"); 1213 goto error_free_sysfs; 1214 } 1215 if (indio_dev->modes & INDIO_BUFFER_TRIGGERED) 1216 iio_device_register_trigger_consumer(indio_dev); 1217 1218 if ((indio_dev->modes & INDIO_ALL_BUFFER_MODES) && 1219 indio_dev->setup_ops == NULL) 1220 indio_dev->setup_ops = &noop_ring_setup_ops; 1221 1222 cdev_init(&indio_dev->chrdev, &iio_buffer_fileops); 1223 indio_dev->chrdev.owner = indio_dev->info->driver_module; 1224 indio_dev->chrdev.kobj.parent = &indio_dev->dev.kobj; 1225 ret = cdev_add(&indio_dev->chrdev, indio_dev->dev.devt, 1); 1226 if (ret < 0) 1227 goto error_unreg_eventset; 1228 1229 ret = device_add(&indio_dev->dev); 1230 if (ret < 0) 1231 goto error_cdev_del; 1232 1233 return 0; 1234error_cdev_del: 1235 cdev_del(&indio_dev->chrdev); 1236error_unreg_eventset: 1237 iio_device_unregister_eventset(indio_dev); 1238error_free_sysfs: 1239 iio_device_unregister_sysfs(indio_dev); 1240error_buffer_free_sysfs: 1241 iio_buffer_free_sysfs_and_mask(indio_dev); 1242error_unreg_debugfs: 1243 iio_device_unregister_debugfs(indio_dev); 1244 return ret; 1245} 1246EXPORT_SYMBOL(iio_device_register); 1247 1248/** 1249 * iio_device_unregister() - unregister a device from the IIO subsystem 1250 * @indio_dev: Device structure representing the device. 1251 **/ 1252void iio_device_unregister(struct iio_dev *indio_dev) 1253{ 1254 mutex_lock(&indio_dev->info_exist_lock); 1255 1256 device_del(&indio_dev->dev); 1257 1258 if (indio_dev->chrdev.dev) 1259 cdev_del(&indio_dev->chrdev); 1260 iio_device_unregister_debugfs(indio_dev); 1261 1262 iio_disable_all_buffers(indio_dev); 1263 1264 indio_dev->info = NULL; 1265 1266 iio_device_wakeup_eventset(indio_dev); 1267 iio_buffer_wakeup_poll(indio_dev); 1268 1269 mutex_unlock(&indio_dev->info_exist_lock); 1270 1271 iio_buffer_free_sysfs_and_mask(indio_dev); 1272} 1273EXPORT_SYMBOL(iio_device_unregister); 1274 1275static void devm_iio_device_unreg(struct device *dev, void *res) 1276{ 1277 iio_device_unregister(*(struct iio_dev **)res); 1278} 1279 1280/** 1281 * devm_iio_device_register - Resource-managed iio_device_register() 1282 * @dev: Device to allocate iio_dev for 1283 * @indio_dev: Device structure filled by the device driver 1284 * 1285 * Managed iio_device_register. The IIO device registered with this 1286 * function is automatically unregistered on driver detach. This function 1287 * calls iio_device_register() internally. Refer to that function for more 1288 * information. 1289 * 1290 * If an iio_dev registered with this function needs to be unregistered 1291 * separately, devm_iio_device_unregister() must be used. 1292 * 1293 * RETURNS: 1294 * 0 on success, negative error number on failure. 1295 */ 1296int devm_iio_device_register(struct device *dev, struct iio_dev *indio_dev) 1297{ 1298 struct iio_dev **ptr; 1299 int ret; 1300 1301 ptr = devres_alloc(devm_iio_device_unreg, sizeof(*ptr), GFP_KERNEL); 1302 if (!ptr) 1303 return -ENOMEM; 1304 1305 *ptr = indio_dev; 1306 ret = iio_device_register(indio_dev); 1307 if (!ret) 1308 devres_add(dev, ptr); 1309 else 1310 devres_free(ptr); 1311 1312 return ret; 1313} 1314EXPORT_SYMBOL_GPL(devm_iio_device_register); 1315 1316/** 1317 * devm_iio_device_unregister - Resource-managed iio_device_unregister() 1318 * @dev: Device this iio_dev belongs to 1319 * @indio_dev: the iio_dev associated with the device 1320 * 1321 * Unregister iio_dev registered with devm_iio_device_register(). 1322 */ 1323void devm_iio_device_unregister(struct device *dev, struct iio_dev *indio_dev) 1324{ 1325 int rc; 1326 1327 rc = devres_release(dev, devm_iio_device_unreg, 1328 devm_iio_device_match, indio_dev); 1329 WARN_ON(rc); 1330} 1331EXPORT_SYMBOL_GPL(devm_iio_device_unregister); 1332 1333subsys_initcall(iio_init); 1334module_exit(iio_exit); 1335 1336MODULE_AUTHOR("Jonathan Cameron <jic23@kernel.org>"); 1337MODULE_DESCRIPTION("Industrial I/O core"); 1338MODULE_LICENSE("GPL"); 1339