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