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 */ 36 static DEFINE_IDA(iio_ida); 37 38 static dev_t iio_devt; 39 40 #define IIO_DEV_MAX 256 41 struct bus_type iio_bus_type = { 42 .name = "iio", 43 }; 44 EXPORT_SYMBOL(iio_bus_type); 45 46 static struct dentry *iio_debugfs_dentry; 47 48 static const char * const iio_direction[] = { 49 [0] = "in", 50 [1] = "out", 51 }; 52 53 static 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 80 static 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 */ 107 static 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 */ 138 const 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 */ 150 ssize_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 } 156 EXPORT_SYMBOL(iio_read_const_attr); 157 158 static 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 179 error_unregister_bus_type: 180 bus_unregister(&iio_bus_type); 181 error_nothing: 182 return ret; 183 } 184 185 static 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) 194 static 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 214 static 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 251 static 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 257 static void iio_device_unregister_debugfs(struct iio_dev *indio_dev) 258 { 259 debugfs_remove_recursive(indio_dev->debugfs_dentry); 260 } 261 262 static 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 292 static int iio_device_register_debugfs(struct iio_dev *indio_dev) 293 { 294 return 0; 295 } 296 297 static void iio_device_unregister_debugfs(struct iio_dev *indio_dev) 298 { 299 } 300 #endif /* CONFIG_DEBUG_FS */ 301 302 static 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 315 static 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 330 ssize_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 } 348 EXPORT_SYMBOL_GPL(iio_enum_available_read); 349 350 ssize_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 } 367 EXPORT_SYMBOL_GPL(iio_enum_read); 368 369 ssize_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 } 391 EXPORT_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 */ 400 ssize_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 450 static 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 */ 485 int 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 } 531 EXPORT_SYMBOL_GPL(iio_str_to_fixpoint); 532 533 static 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 572 static 573 int __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 696 error_free_full_postfix: 697 kfree(full_postfix); 698 699 return ret; 700 } 701 702 static void __iio_device_attr_deinit(struct device_attribute *dev_attr) 703 { 704 kfree(dev_attr->attr.name); 705 } 706 707 int __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 747 error_device_attr_deinit: 748 __iio_device_attr_deinit(&iio_attr->dev_attr); 749 error_iio_dev_attr_free: 750 kfree(iio_attr); 751 return ret; 752 } 753 754 static 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 782 static 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. Note: if you want to reuse the list after calling 851 * this function you have to reinitialize it using INIT_LIST_HEAD(). 852 */ 853 void iio_free_chan_devattr_list(struct list_head *attr_list) 854 { 855 struct iio_dev_attr *p, *n; 856 857 list_for_each_entry_safe(p, n, attr_list, l) { 858 kfree(p->dev_attr.attr.name); 859 kfree(p); 860 } 861 } 862 863 static 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 871 static DEVICE_ATTR(name, S_IRUGO, iio_show_dev_name, NULL); 872 873 static 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 928 error_clear_attrs: 929 iio_free_chan_devattr_list(&indio_dev->channel_attr_list); 930 931 return ret; 932 } 933 934 static 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 } 940 941 static void iio_dev_release(struct device *device) 942 { 943 struct iio_dev *indio_dev = dev_to_iio_dev(device); 944 if (indio_dev->modes & INDIO_BUFFER_TRIGGERED) 945 iio_device_unregister_trigger_consumer(indio_dev); 946 iio_device_unregister_eventset(indio_dev); 947 iio_device_unregister_sysfs(indio_dev); 948 949 iio_buffer_put(indio_dev->buffer); 950 951 ida_simple_remove(&iio_ida, indio_dev->id); 952 kfree(indio_dev); 953 } 954 955 struct device_type iio_device_type = { 956 .name = "iio_device", 957 .release = iio_dev_release, 958 }; 959 960 /** 961 * iio_device_alloc() - allocate an iio_dev from a driver 962 * @sizeof_priv: Space to allocate for private structure. 963 **/ 964 struct iio_dev *iio_device_alloc(int sizeof_priv) 965 { 966 struct iio_dev *dev; 967 size_t alloc_size; 968 969 alloc_size = sizeof(struct iio_dev); 970 if (sizeof_priv) { 971 alloc_size = ALIGN(alloc_size, IIO_ALIGN); 972 alloc_size += sizeof_priv; 973 } 974 /* ensure 32-byte alignment of whole construct ? */ 975 alloc_size += IIO_ALIGN - 1; 976 977 dev = kzalloc(alloc_size, GFP_KERNEL); 978 979 if (dev) { 980 dev->dev.groups = dev->groups; 981 dev->dev.type = &iio_device_type; 982 dev->dev.bus = &iio_bus_type; 983 device_initialize(&dev->dev); 984 dev_set_drvdata(&dev->dev, (void *)dev); 985 mutex_init(&dev->mlock); 986 mutex_init(&dev->info_exist_lock); 987 INIT_LIST_HEAD(&dev->channel_attr_list); 988 989 dev->id = ida_simple_get(&iio_ida, 0, 0, GFP_KERNEL); 990 if (dev->id < 0) { 991 /* cannot use a dev_err as the name isn't available */ 992 pr_err("failed to get device id\n"); 993 kfree(dev); 994 return NULL; 995 } 996 dev_set_name(&dev->dev, "iio:device%d", dev->id); 997 INIT_LIST_HEAD(&dev->buffer_list); 998 } 999 1000 return dev; 1001 } 1002 EXPORT_SYMBOL(iio_device_alloc); 1003 1004 /** 1005 * iio_device_free() - free an iio_dev from a driver 1006 * @dev: the iio_dev associated with the device 1007 **/ 1008 void iio_device_free(struct iio_dev *dev) 1009 { 1010 if (dev) 1011 put_device(&dev->dev); 1012 } 1013 EXPORT_SYMBOL(iio_device_free); 1014 1015 static void devm_iio_device_release(struct device *dev, void *res) 1016 { 1017 iio_device_free(*(struct iio_dev **)res); 1018 } 1019 1020 static int devm_iio_device_match(struct device *dev, void *res, void *data) 1021 { 1022 struct iio_dev **r = res; 1023 if (!r || !*r) { 1024 WARN_ON(!r || !*r); 1025 return 0; 1026 } 1027 return *r == data; 1028 } 1029 1030 /** 1031 * devm_iio_device_alloc - Resource-managed iio_device_alloc() 1032 * @dev: Device to allocate iio_dev for 1033 * @sizeof_priv: Space to allocate for private structure. 1034 * 1035 * Managed iio_device_alloc. iio_dev allocated with this function is 1036 * automatically freed on driver detach. 1037 * 1038 * If an iio_dev allocated with this function needs to be freed separately, 1039 * devm_iio_device_free() must be used. 1040 * 1041 * RETURNS: 1042 * Pointer to allocated iio_dev on success, NULL on failure. 1043 */ 1044 struct iio_dev *devm_iio_device_alloc(struct device *dev, int sizeof_priv) 1045 { 1046 struct iio_dev **ptr, *iio_dev; 1047 1048 ptr = devres_alloc(devm_iio_device_release, sizeof(*ptr), 1049 GFP_KERNEL); 1050 if (!ptr) 1051 return NULL; 1052 1053 iio_dev = iio_device_alloc(sizeof_priv); 1054 if (iio_dev) { 1055 *ptr = iio_dev; 1056 devres_add(dev, ptr); 1057 } else { 1058 devres_free(ptr); 1059 } 1060 1061 return iio_dev; 1062 } 1063 EXPORT_SYMBOL_GPL(devm_iio_device_alloc); 1064 1065 /** 1066 * devm_iio_device_free - Resource-managed iio_device_free() 1067 * @dev: Device this iio_dev belongs to 1068 * @iio_dev: the iio_dev associated with the device 1069 * 1070 * Free iio_dev allocated with devm_iio_device_alloc(). 1071 */ 1072 void devm_iio_device_free(struct device *dev, struct iio_dev *iio_dev) 1073 { 1074 int rc; 1075 1076 rc = devres_release(dev, devm_iio_device_release, 1077 devm_iio_device_match, iio_dev); 1078 WARN_ON(rc); 1079 } 1080 EXPORT_SYMBOL_GPL(devm_iio_device_free); 1081 1082 /** 1083 * iio_chrdev_open() - chrdev file open for buffer access and ioctls 1084 **/ 1085 static int iio_chrdev_open(struct inode *inode, struct file *filp) 1086 { 1087 struct iio_dev *indio_dev = container_of(inode->i_cdev, 1088 struct iio_dev, chrdev); 1089 1090 if (test_and_set_bit(IIO_BUSY_BIT_POS, &indio_dev->flags)) 1091 return -EBUSY; 1092 1093 iio_device_get(indio_dev); 1094 1095 filp->private_data = indio_dev; 1096 1097 return 0; 1098 } 1099 1100 /** 1101 * iio_chrdev_release() - chrdev file close buffer access and ioctls 1102 **/ 1103 static int iio_chrdev_release(struct inode *inode, struct file *filp) 1104 { 1105 struct iio_dev *indio_dev = container_of(inode->i_cdev, 1106 struct iio_dev, chrdev); 1107 clear_bit(IIO_BUSY_BIT_POS, &indio_dev->flags); 1108 iio_device_put(indio_dev); 1109 1110 return 0; 1111 } 1112 1113 /* Somewhat of a cross file organization violation - ioctls here are actually 1114 * event related */ 1115 static long iio_ioctl(struct file *filp, unsigned int cmd, unsigned long arg) 1116 { 1117 struct iio_dev *indio_dev = filp->private_data; 1118 int __user *ip = (int __user *)arg; 1119 int fd; 1120 1121 if (!indio_dev->info) 1122 return -ENODEV; 1123 1124 if (cmd == IIO_GET_EVENT_FD_IOCTL) { 1125 fd = iio_event_getfd(indio_dev); 1126 if (copy_to_user(ip, &fd, sizeof(fd))) 1127 return -EFAULT; 1128 return 0; 1129 } 1130 return -EINVAL; 1131 } 1132 1133 static const struct file_operations iio_buffer_fileops = { 1134 .read = iio_buffer_read_first_n_outer_addr, 1135 .release = iio_chrdev_release, 1136 .open = iio_chrdev_open, 1137 .poll = iio_buffer_poll_addr, 1138 .owner = THIS_MODULE, 1139 .llseek = noop_llseek, 1140 .unlocked_ioctl = iio_ioctl, 1141 .compat_ioctl = iio_ioctl, 1142 }; 1143 1144 static int iio_check_unique_scan_index(struct iio_dev *indio_dev) 1145 { 1146 int i, j; 1147 const struct iio_chan_spec *channels = indio_dev->channels; 1148 1149 if (!(indio_dev->modes & INDIO_ALL_BUFFER_MODES)) 1150 return 0; 1151 1152 for (i = 0; i < indio_dev->num_channels - 1; i++) { 1153 if (channels[i].scan_index < 0) 1154 continue; 1155 for (j = i + 1; j < indio_dev->num_channels; j++) 1156 if (channels[i].scan_index == channels[j].scan_index) { 1157 dev_err(&indio_dev->dev, 1158 "Duplicate scan index %d\n", 1159 channels[i].scan_index); 1160 return -EINVAL; 1161 } 1162 } 1163 1164 return 0; 1165 } 1166 1167 static const struct iio_buffer_setup_ops noop_ring_setup_ops; 1168 1169 /** 1170 * iio_device_register() - register a device with the IIO subsystem 1171 * @indio_dev: Device structure filled by the device driver 1172 **/ 1173 int iio_device_register(struct iio_dev *indio_dev) 1174 { 1175 int ret; 1176 1177 /* If the calling driver did not initialize of_node, do it here */ 1178 if (!indio_dev->dev.of_node && indio_dev->dev.parent) 1179 indio_dev->dev.of_node = indio_dev->dev.parent->of_node; 1180 1181 ret = iio_check_unique_scan_index(indio_dev); 1182 if (ret < 0) 1183 return ret; 1184 1185 /* configure elements for the chrdev */ 1186 indio_dev->dev.devt = MKDEV(MAJOR(iio_devt), indio_dev->id); 1187 1188 ret = iio_device_register_debugfs(indio_dev); 1189 if (ret) { 1190 dev_err(indio_dev->dev.parent, 1191 "Failed to register debugfs interfaces\n"); 1192 return ret; 1193 } 1194 1195 ret = iio_buffer_alloc_sysfs_and_mask(indio_dev); 1196 if (ret) { 1197 dev_err(indio_dev->dev.parent, 1198 "Failed to create buffer sysfs interfaces\n"); 1199 goto error_unreg_debugfs; 1200 } 1201 1202 ret = iio_device_register_sysfs(indio_dev); 1203 if (ret) { 1204 dev_err(indio_dev->dev.parent, 1205 "Failed to register sysfs interfaces\n"); 1206 goto error_buffer_free_sysfs; 1207 } 1208 ret = iio_device_register_eventset(indio_dev); 1209 if (ret) { 1210 dev_err(indio_dev->dev.parent, 1211 "Failed to register event set\n"); 1212 goto error_free_sysfs; 1213 } 1214 if (indio_dev->modes & INDIO_BUFFER_TRIGGERED) 1215 iio_device_register_trigger_consumer(indio_dev); 1216 1217 if ((indio_dev->modes & INDIO_ALL_BUFFER_MODES) && 1218 indio_dev->setup_ops == NULL) 1219 indio_dev->setup_ops = &noop_ring_setup_ops; 1220 1221 cdev_init(&indio_dev->chrdev, &iio_buffer_fileops); 1222 indio_dev->chrdev.owner = indio_dev->info->driver_module; 1223 indio_dev->chrdev.kobj.parent = &indio_dev->dev.kobj; 1224 ret = cdev_add(&indio_dev->chrdev, indio_dev->dev.devt, 1); 1225 if (ret < 0) 1226 goto error_unreg_eventset; 1227 1228 ret = device_add(&indio_dev->dev); 1229 if (ret < 0) 1230 goto error_cdev_del; 1231 1232 return 0; 1233 error_cdev_del: 1234 cdev_del(&indio_dev->chrdev); 1235 error_unreg_eventset: 1236 iio_device_unregister_eventset(indio_dev); 1237 error_free_sysfs: 1238 iio_device_unregister_sysfs(indio_dev); 1239 error_buffer_free_sysfs: 1240 iio_buffer_free_sysfs_and_mask(indio_dev); 1241 error_unreg_debugfs: 1242 iio_device_unregister_debugfs(indio_dev); 1243 return ret; 1244 } 1245 EXPORT_SYMBOL(iio_device_register); 1246 1247 /** 1248 * iio_device_unregister() - unregister a device from the IIO subsystem 1249 * @indio_dev: Device structure representing the device. 1250 **/ 1251 void iio_device_unregister(struct iio_dev *indio_dev) 1252 { 1253 mutex_lock(&indio_dev->info_exist_lock); 1254 1255 device_del(&indio_dev->dev); 1256 1257 if (indio_dev->chrdev.dev) 1258 cdev_del(&indio_dev->chrdev); 1259 iio_device_unregister_debugfs(indio_dev); 1260 1261 iio_disable_all_buffers(indio_dev); 1262 1263 indio_dev->info = NULL; 1264 1265 iio_device_wakeup_eventset(indio_dev); 1266 iio_buffer_wakeup_poll(indio_dev); 1267 1268 mutex_unlock(&indio_dev->info_exist_lock); 1269 1270 iio_buffer_free_sysfs_and_mask(indio_dev); 1271 } 1272 EXPORT_SYMBOL(iio_device_unregister); 1273 1274 static void devm_iio_device_unreg(struct device *dev, void *res) 1275 { 1276 iio_device_unregister(*(struct iio_dev **)res); 1277 } 1278 1279 /** 1280 * devm_iio_device_register - Resource-managed iio_device_register() 1281 * @dev: Device to allocate iio_dev for 1282 * @indio_dev: Device structure filled by the device driver 1283 * 1284 * Managed iio_device_register. The IIO device registered with this 1285 * function is automatically unregistered on driver detach. This function 1286 * calls iio_device_register() internally. Refer to that function for more 1287 * information. 1288 * 1289 * If an iio_dev registered with this function needs to be unregistered 1290 * separately, devm_iio_device_unregister() must be used. 1291 * 1292 * RETURNS: 1293 * 0 on success, negative error number on failure. 1294 */ 1295 int devm_iio_device_register(struct device *dev, struct iio_dev *indio_dev) 1296 { 1297 struct iio_dev **ptr; 1298 int ret; 1299 1300 ptr = devres_alloc(devm_iio_device_unreg, sizeof(*ptr), GFP_KERNEL); 1301 if (!ptr) 1302 return -ENOMEM; 1303 1304 *ptr = indio_dev; 1305 ret = iio_device_register(indio_dev); 1306 if (!ret) 1307 devres_add(dev, ptr); 1308 else 1309 devres_free(ptr); 1310 1311 return ret; 1312 } 1313 EXPORT_SYMBOL_GPL(devm_iio_device_register); 1314 1315 /** 1316 * devm_iio_device_unregister - Resource-managed iio_device_unregister() 1317 * @dev: Device this iio_dev belongs to 1318 * @indio_dev: the iio_dev associated with the device 1319 * 1320 * Unregister iio_dev registered with devm_iio_device_register(). 1321 */ 1322 void devm_iio_device_unregister(struct device *dev, struct iio_dev *indio_dev) 1323 { 1324 int rc; 1325 1326 rc = devres_release(dev, devm_iio_device_unreg, 1327 devm_iio_device_match, indio_dev); 1328 WARN_ON(rc); 1329 } 1330 EXPORT_SYMBOL_GPL(devm_iio_device_unregister); 1331 1332 subsys_initcall(iio_init); 1333 module_exit(iio_exit); 1334 1335 MODULE_AUTHOR("Jonathan Cameron <jic23@kernel.org>"); 1336 MODULE_DESCRIPTION("Industrial I/O core"); 1337 MODULE_LICENSE("GPL"); 1338