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 #include <linux/kernel.h> 13 #include <linux/module.h> 14 #include <linux/idr.h> 15 #include <linux/kdev_t.h> 16 #include <linux/err.h> 17 #include <linux/device.h> 18 #include <linux/fs.h> 19 #include <linux/poll.h> 20 #include <linux/sched.h> 21 #include <linux/wait.h> 22 #include <linux/cdev.h> 23 #include <linux/slab.h> 24 #include <linux/anon_inodes.h> 25 #include <linux/debugfs.h> 26 #include <linux/iio/iio.h> 27 #include "iio_core.h" 28 #include "iio_core_trigger.h" 29 #include <linux/iio/sysfs.h> 30 #include <linux/iio/events.h> 31 32 /* IDA to assign each registered device a unique id */ 33 static DEFINE_IDA(iio_ida); 34 35 static dev_t iio_devt; 36 37 #define IIO_DEV_MAX 256 38 struct bus_type iio_bus_type = { 39 .name = "iio", 40 }; 41 EXPORT_SYMBOL(iio_bus_type); 42 43 static struct dentry *iio_debugfs_dentry; 44 45 static const char * const iio_direction[] = { 46 [0] = "in", 47 [1] = "out", 48 }; 49 50 static const char * const iio_chan_type_name_spec[] = { 51 [IIO_VOLTAGE] = "voltage", 52 [IIO_CURRENT] = "current", 53 [IIO_POWER] = "power", 54 [IIO_ACCEL] = "accel", 55 [IIO_ANGL_VEL] = "anglvel", 56 [IIO_MAGN] = "magn", 57 [IIO_LIGHT] = "illuminance", 58 [IIO_INTENSITY] = "intensity", 59 [IIO_PROXIMITY] = "proximity", 60 [IIO_TEMP] = "temp", 61 [IIO_INCLI] = "incli", 62 [IIO_ROT] = "rot", 63 [IIO_ANGL] = "angl", 64 [IIO_TIMESTAMP] = "timestamp", 65 [IIO_CAPACITANCE] = "capacitance", 66 [IIO_ALTVOLTAGE] = "altvoltage", 67 [IIO_CCT] = "cct", 68 }; 69 70 static const char * const iio_modifier_names[] = { 71 [IIO_MOD_X] = "x", 72 [IIO_MOD_Y] = "y", 73 [IIO_MOD_Z] = "z", 74 [IIO_MOD_ROOT_SUM_SQUARED_X_Y] = "sqrt(x^2+y^2)", 75 [IIO_MOD_SUM_SQUARED_X_Y_Z] = "x^2+y^2+z^2", 76 [IIO_MOD_LIGHT_BOTH] = "both", 77 [IIO_MOD_LIGHT_IR] = "ir", 78 [IIO_MOD_LIGHT_CLEAR] = "clear", 79 [IIO_MOD_LIGHT_RED] = "red", 80 [IIO_MOD_LIGHT_GREEN] = "green", 81 [IIO_MOD_LIGHT_BLUE] = "blue", 82 }; 83 84 /* relies on pairs of these shared then separate */ 85 static const char * const iio_chan_info_postfix[] = { 86 [IIO_CHAN_INFO_RAW] = "raw", 87 [IIO_CHAN_INFO_PROCESSED] = "input", 88 [IIO_CHAN_INFO_SCALE] = "scale", 89 [IIO_CHAN_INFO_OFFSET] = "offset", 90 [IIO_CHAN_INFO_CALIBSCALE] = "calibscale", 91 [IIO_CHAN_INFO_CALIBBIAS] = "calibbias", 92 [IIO_CHAN_INFO_PEAK] = "peak_raw", 93 [IIO_CHAN_INFO_PEAK_SCALE] = "peak_scale", 94 [IIO_CHAN_INFO_QUADRATURE_CORRECTION_RAW] = "quadrature_correction_raw", 95 [IIO_CHAN_INFO_AVERAGE_RAW] = "mean_raw", 96 [IIO_CHAN_INFO_LOW_PASS_FILTER_3DB_FREQUENCY] 97 = "filter_low_pass_3db_frequency", 98 [IIO_CHAN_INFO_SAMP_FREQ] = "sampling_frequency", 99 [IIO_CHAN_INFO_FREQUENCY] = "frequency", 100 [IIO_CHAN_INFO_PHASE] = "phase", 101 [IIO_CHAN_INFO_HARDWAREGAIN] = "hardwaregain", 102 [IIO_CHAN_INFO_HYSTERESIS] = "hysteresis", 103 }; 104 105 const struct iio_chan_spec 106 *iio_find_channel_from_si(struct iio_dev *indio_dev, int si) 107 { 108 int i; 109 110 for (i = 0; i < indio_dev->num_channels; i++) 111 if (indio_dev->channels[i].scan_index == si) 112 return &indio_dev->channels[i]; 113 return NULL; 114 } 115 116 /* This turns up an awful lot */ 117 ssize_t iio_read_const_attr(struct device *dev, 118 struct device_attribute *attr, 119 char *buf) 120 { 121 return sprintf(buf, "%s\n", to_iio_const_attr(attr)->string); 122 } 123 EXPORT_SYMBOL(iio_read_const_attr); 124 125 static int __init iio_init(void) 126 { 127 int ret; 128 129 /* Register sysfs bus */ 130 ret = bus_register(&iio_bus_type); 131 if (ret < 0) { 132 printk(KERN_ERR 133 "%s could not register bus type\n", 134 __FILE__); 135 goto error_nothing; 136 } 137 138 ret = alloc_chrdev_region(&iio_devt, 0, IIO_DEV_MAX, "iio"); 139 if (ret < 0) { 140 printk(KERN_ERR "%s: failed to allocate char dev region\n", 141 __FILE__); 142 goto error_unregister_bus_type; 143 } 144 145 iio_debugfs_dentry = debugfs_create_dir("iio", NULL); 146 147 return 0; 148 149 error_unregister_bus_type: 150 bus_unregister(&iio_bus_type); 151 error_nothing: 152 return ret; 153 } 154 155 static void __exit iio_exit(void) 156 { 157 if (iio_devt) 158 unregister_chrdev_region(iio_devt, IIO_DEV_MAX); 159 bus_unregister(&iio_bus_type); 160 debugfs_remove(iio_debugfs_dentry); 161 } 162 163 #if defined(CONFIG_DEBUG_FS) 164 static ssize_t iio_debugfs_read_reg(struct file *file, char __user *userbuf, 165 size_t count, loff_t *ppos) 166 { 167 struct iio_dev *indio_dev = file->private_data; 168 char buf[20]; 169 unsigned val = 0; 170 ssize_t len; 171 int ret; 172 173 ret = indio_dev->info->debugfs_reg_access(indio_dev, 174 indio_dev->cached_reg_addr, 175 0, &val); 176 if (ret) 177 dev_err(indio_dev->dev.parent, "%s: read failed\n", __func__); 178 179 len = snprintf(buf, sizeof(buf), "0x%X\n", val); 180 181 return simple_read_from_buffer(userbuf, count, ppos, buf, len); 182 } 183 184 static ssize_t iio_debugfs_write_reg(struct file *file, 185 const char __user *userbuf, size_t count, loff_t *ppos) 186 { 187 struct iio_dev *indio_dev = file->private_data; 188 unsigned reg, val; 189 char buf[80]; 190 int ret; 191 192 count = min_t(size_t, count, (sizeof(buf)-1)); 193 if (copy_from_user(buf, userbuf, count)) 194 return -EFAULT; 195 196 buf[count] = 0; 197 198 ret = sscanf(buf, "%i %i", ®, &val); 199 200 switch (ret) { 201 case 1: 202 indio_dev->cached_reg_addr = reg; 203 break; 204 case 2: 205 indio_dev->cached_reg_addr = reg; 206 ret = indio_dev->info->debugfs_reg_access(indio_dev, reg, 207 val, NULL); 208 if (ret) { 209 dev_err(indio_dev->dev.parent, "%s: write failed\n", 210 __func__); 211 return ret; 212 } 213 break; 214 default: 215 return -EINVAL; 216 } 217 218 return count; 219 } 220 221 static const struct file_operations iio_debugfs_reg_fops = { 222 .open = simple_open, 223 .read = iio_debugfs_read_reg, 224 .write = iio_debugfs_write_reg, 225 }; 226 227 static void iio_device_unregister_debugfs(struct iio_dev *indio_dev) 228 { 229 debugfs_remove_recursive(indio_dev->debugfs_dentry); 230 } 231 232 static int iio_device_register_debugfs(struct iio_dev *indio_dev) 233 { 234 struct dentry *d; 235 236 if (indio_dev->info->debugfs_reg_access == NULL) 237 return 0; 238 239 if (!iio_debugfs_dentry) 240 return 0; 241 242 indio_dev->debugfs_dentry = 243 debugfs_create_dir(dev_name(&indio_dev->dev), 244 iio_debugfs_dentry); 245 if (indio_dev->debugfs_dentry == NULL) { 246 dev_warn(indio_dev->dev.parent, 247 "Failed to create debugfs directory\n"); 248 return -EFAULT; 249 } 250 251 d = debugfs_create_file("direct_reg_access", 0644, 252 indio_dev->debugfs_dentry, 253 indio_dev, &iio_debugfs_reg_fops); 254 if (!d) { 255 iio_device_unregister_debugfs(indio_dev); 256 return -ENOMEM; 257 } 258 259 return 0; 260 } 261 #else 262 static int iio_device_register_debugfs(struct iio_dev *indio_dev) 263 { 264 return 0; 265 } 266 267 static void iio_device_unregister_debugfs(struct iio_dev *indio_dev) 268 { 269 } 270 #endif /* CONFIG_DEBUG_FS */ 271 272 static ssize_t iio_read_channel_ext_info(struct device *dev, 273 struct device_attribute *attr, 274 char *buf) 275 { 276 struct iio_dev *indio_dev = dev_to_iio_dev(dev); 277 struct iio_dev_attr *this_attr = to_iio_dev_attr(attr); 278 const struct iio_chan_spec_ext_info *ext_info; 279 280 ext_info = &this_attr->c->ext_info[this_attr->address]; 281 282 return ext_info->read(indio_dev, ext_info->private, this_attr->c, buf); 283 } 284 285 static ssize_t iio_write_channel_ext_info(struct device *dev, 286 struct device_attribute *attr, 287 const char *buf, 288 size_t len) 289 { 290 struct iio_dev *indio_dev = dev_to_iio_dev(dev); 291 struct iio_dev_attr *this_attr = to_iio_dev_attr(attr); 292 const struct iio_chan_spec_ext_info *ext_info; 293 294 ext_info = &this_attr->c->ext_info[this_attr->address]; 295 296 return ext_info->write(indio_dev, ext_info->private, 297 this_attr->c, buf, len); 298 } 299 300 ssize_t iio_enum_available_read(struct iio_dev *indio_dev, 301 uintptr_t priv, const struct iio_chan_spec *chan, char *buf) 302 { 303 const struct iio_enum *e = (const struct iio_enum *)priv; 304 unsigned int i; 305 size_t len = 0; 306 307 if (!e->num_items) 308 return 0; 309 310 for (i = 0; i < e->num_items; ++i) 311 len += scnprintf(buf + len, PAGE_SIZE - len, "%s ", e->items[i]); 312 313 /* replace last space with a newline */ 314 buf[len - 1] = '\n'; 315 316 return len; 317 } 318 EXPORT_SYMBOL_GPL(iio_enum_available_read); 319 320 ssize_t iio_enum_read(struct iio_dev *indio_dev, 321 uintptr_t priv, const struct iio_chan_spec *chan, char *buf) 322 { 323 const struct iio_enum *e = (const struct iio_enum *)priv; 324 int i; 325 326 if (!e->get) 327 return -EINVAL; 328 329 i = e->get(indio_dev, chan); 330 if (i < 0) 331 return i; 332 else if (i >= e->num_items) 333 return -EINVAL; 334 335 return sprintf(buf, "%s\n", e->items[i]); 336 } 337 EXPORT_SYMBOL_GPL(iio_enum_read); 338 339 ssize_t iio_enum_write(struct iio_dev *indio_dev, 340 uintptr_t priv, const struct iio_chan_spec *chan, const char *buf, 341 size_t len) 342 { 343 const struct iio_enum *e = (const struct iio_enum *)priv; 344 unsigned int i; 345 int ret; 346 347 if (!e->set) 348 return -EINVAL; 349 350 for (i = 0; i < e->num_items; i++) { 351 if (sysfs_streq(buf, e->items[i])) 352 break; 353 } 354 355 if (i == e->num_items) 356 return -EINVAL; 357 358 ret = e->set(indio_dev, chan, i); 359 return ret ? ret : len; 360 } 361 EXPORT_SYMBOL_GPL(iio_enum_write); 362 363 static ssize_t iio_read_channel_info(struct device *dev, 364 struct device_attribute *attr, 365 char *buf) 366 { 367 struct iio_dev *indio_dev = dev_to_iio_dev(dev); 368 struct iio_dev_attr *this_attr = to_iio_dev_attr(attr); 369 unsigned long long tmp; 370 int val, val2; 371 bool scale_db = false; 372 int ret = indio_dev->info->read_raw(indio_dev, this_attr->c, 373 &val, &val2, this_attr->address); 374 375 if (ret < 0) 376 return ret; 377 378 switch (ret) { 379 case IIO_VAL_INT: 380 return sprintf(buf, "%d\n", val); 381 case IIO_VAL_INT_PLUS_MICRO_DB: 382 scale_db = true; 383 case IIO_VAL_INT_PLUS_MICRO: 384 if (val2 < 0) 385 return sprintf(buf, "-%d.%06u%s\n", val, -val2, 386 scale_db ? " dB" : ""); 387 else 388 return sprintf(buf, "%d.%06u%s\n", val, val2, 389 scale_db ? " dB" : ""); 390 case IIO_VAL_INT_PLUS_NANO: 391 if (val2 < 0) 392 return sprintf(buf, "-%d.%09u\n", val, -val2); 393 else 394 return sprintf(buf, "%d.%09u\n", val, val2); 395 case IIO_VAL_FRACTIONAL: 396 tmp = div_s64((s64)val * 1000000000LL, val2); 397 val2 = do_div(tmp, 1000000000LL); 398 val = tmp; 399 return sprintf(buf, "%d.%09u\n", val, val2); 400 default: 401 return 0; 402 } 403 } 404 405 static ssize_t iio_write_channel_info(struct device *dev, 406 struct device_attribute *attr, 407 const char *buf, 408 size_t len) 409 { 410 struct iio_dev *indio_dev = dev_to_iio_dev(dev); 411 struct iio_dev_attr *this_attr = to_iio_dev_attr(attr); 412 int ret, integer = 0, fract = 0, fract_mult = 100000; 413 bool integer_part = true, negative = false; 414 415 /* Assumes decimal - precision based on number of digits */ 416 if (!indio_dev->info->write_raw) 417 return -EINVAL; 418 419 if (indio_dev->info->write_raw_get_fmt) 420 switch (indio_dev->info->write_raw_get_fmt(indio_dev, 421 this_attr->c, this_attr->address)) { 422 case IIO_VAL_INT_PLUS_MICRO: 423 fract_mult = 100000; 424 break; 425 case IIO_VAL_INT_PLUS_NANO: 426 fract_mult = 100000000; 427 break; 428 default: 429 return -EINVAL; 430 } 431 432 if (buf[0] == '-') { 433 negative = true; 434 buf++; 435 } 436 437 while (*buf) { 438 if ('0' <= *buf && *buf <= '9') { 439 if (integer_part) 440 integer = integer*10 + *buf - '0'; 441 else { 442 fract += fract_mult*(*buf - '0'); 443 if (fract_mult == 1) 444 break; 445 fract_mult /= 10; 446 } 447 } else if (*buf == '\n') { 448 if (*(buf + 1) == '\0') 449 break; 450 else 451 return -EINVAL; 452 } else if (*buf == '.') { 453 integer_part = false; 454 } else { 455 return -EINVAL; 456 } 457 buf++; 458 } 459 if (negative) { 460 if (integer) 461 integer = -integer; 462 else 463 fract = -fract; 464 } 465 466 ret = indio_dev->info->write_raw(indio_dev, this_attr->c, 467 integer, fract, this_attr->address); 468 if (ret) 469 return ret; 470 471 return len; 472 } 473 474 static 475 int __iio_device_attr_init(struct device_attribute *dev_attr, 476 const char *postfix, 477 struct iio_chan_spec const *chan, 478 ssize_t (*readfunc)(struct device *dev, 479 struct device_attribute *attr, 480 char *buf), 481 ssize_t (*writefunc)(struct device *dev, 482 struct device_attribute *attr, 483 const char *buf, 484 size_t len), 485 bool generic) 486 { 487 int ret; 488 char *name_format, *full_postfix; 489 sysfs_attr_init(&dev_attr->attr); 490 491 /* Build up postfix of <extend_name>_<modifier>_postfix */ 492 if (chan->modified && !generic) { 493 if (chan->extend_name) 494 full_postfix = kasprintf(GFP_KERNEL, "%s_%s_%s", 495 iio_modifier_names[chan 496 ->channel2], 497 chan->extend_name, 498 postfix); 499 else 500 full_postfix = kasprintf(GFP_KERNEL, "%s_%s", 501 iio_modifier_names[chan 502 ->channel2], 503 postfix); 504 } else { 505 if (chan->extend_name == NULL) 506 full_postfix = kstrdup(postfix, GFP_KERNEL); 507 else 508 full_postfix = kasprintf(GFP_KERNEL, 509 "%s_%s", 510 chan->extend_name, 511 postfix); 512 } 513 if (full_postfix == NULL) { 514 ret = -ENOMEM; 515 goto error_ret; 516 } 517 518 if (chan->differential) { /* Differential can not have modifier */ 519 if (generic) 520 name_format 521 = kasprintf(GFP_KERNEL, "%s_%s-%s_%s", 522 iio_direction[chan->output], 523 iio_chan_type_name_spec[chan->type], 524 iio_chan_type_name_spec[chan->type], 525 full_postfix); 526 else if (chan->indexed) 527 name_format 528 = kasprintf(GFP_KERNEL, "%s_%s%d-%s%d_%s", 529 iio_direction[chan->output], 530 iio_chan_type_name_spec[chan->type], 531 chan->channel, 532 iio_chan_type_name_spec[chan->type], 533 chan->channel2, 534 full_postfix); 535 else { 536 WARN_ON("Differential channels must be indexed\n"); 537 ret = -EINVAL; 538 goto error_free_full_postfix; 539 } 540 } else { /* Single ended */ 541 if (generic) 542 name_format 543 = kasprintf(GFP_KERNEL, "%s_%s_%s", 544 iio_direction[chan->output], 545 iio_chan_type_name_spec[chan->type], 546 full_postfix); 547 else if (chan->indexed) 548 name_format 549 = kasprintf(GFP_KERNEL, "%s_%s%d_%s", 550 iio_direction[chan->output], 551 iio_chan_type_name_spec[chan->type], 552 chan->channel, 553 full_postfix); 554 else 555 name_format 556 = kasprintf(GFP_KERNEL, "%s_%s_%s", 557 iio_direction[chan->output], 558 iio_chan_type_name_spec[chan->type], 559 full_postfix); 560 } 561 if (name_format == NULL) { 562 ret = -ENOMEM; 563 goto error_free_full_postfix; 564 } 565 dev_attr->attr.name = kasprintf(GFP_KERNEL, 566 name_format, 567 chan->channel, 568 chan->channel2); 569 if (dev_attr->attr.name == NULL) { 570 ret = -ENOMEM; 571 goto error_free_name_format; 572 } 573 574 if (readfunc) { 575 dev_attr->attr.mode |= S_IRUGO; 576 dev_attr->show = readfunc; 577 } 578 579 if (writefunc) { 580 dev_attr->attr.mode |= S_IWUSR; 581 dev_attr->store = writefunc; 582 } 583 kfree(name_format); 584 kfree(full_postfix); 585 586 return 0; 587 588 error_free_name_format: 589 kfree(name_format); 590 error_free_full_postfix: 591 kfree(full_postfix); 592 error_ret: 593 return ret; 594 } 595 596 static void __iio_device_attr_deinit(struct device_attribute *dev_attr) 597 { 598 kfree(dev_attr->attr.name); 599 } 600 601 int __iio_add_chan_devattr(const char *postfix, 602 struct iio_chan_spec const *chan, 603 ssize_t (*readfunc)(struct device *dev, 604 struct device_attribute *attr, 605 char *buf), 606 ssize_t (*writefunc)(struct device *dev, 607 struct device_attribute *attr, 608 const char *buf, 609 size_t len), 610 u64 mask, 611 bool generic, 612 struct device *dev, 613 struct list_head *attr_list) 614 { 615 int ret; 616 struct iio_dev_attr *iio_attr, *t; 617 618 iio_attr = kzalloc(sizeof *iio_attr, GFP_KERNEL); 619 if (iio_attr == NULL) { 620 ret = -ENOMEM; 621 goto error_ret; 622 } 623 ret = __iio_device_attr_init(&iio_attr->dev_attr, 624 postfix, chan, 625 readfunc, writefunc, generic); 626 if (ret) 627 goto error_iio_dev_attr_free; 628 iio_attr->c = chan; 629 iio_attr->address = mask; 630 list_for_each_entry(t, attr_list, l) 631 if (strcmp(t->dev_attr.attr.name, 632 iio_attr->dev_attr.attr.name) == 0) { 633 if (!generic) 634 dev_err(dev, "tried to double register : %s\n", 635 t->dev_attr.attr.name); 636 ret = -EBUSY; 637 goto error_device_attr_deinit; 638 } 639 list_add(&iio_attr->l, attr_list); 640 641 return 0; 642 643 error_device_attr_deinit: 644 __iio_device_attr_deinit(&iio_attr->dev_attr); 645 error_iio_dev_attr_free: 646 kfree(iio_attr); 647 error_ret: 648 return ret; 649 } 650 651 static int iio_device_add_channel_sysfs(struct iio_dev *indio_dev, 652 struct iio_chan_spec const *chan) 653 { 654 int ret, attrcount = 0; 655 int i; 656 const struct iio_chan_spec_ext_info *ext_info; 657 658 if (chan->channel < 0) 659 return 0; 660 for_each_set_bit(i, &chan->info_mask, sizeof(long)*8) { 661 ret = __iio_add_chan_devattr(iio_chan_info_postfix[i/2], 662 chan, 663 &iio_read_channel_info, 664 &iio_write_channel_info, 665 i/2, 666 !(i%2), 667 &indio_dev->dev, 668 &indio_dev->channel_attr_list); 669 if (ret == -EBUSY && (i%2 == 0)) { 670 ret = 0; 671 continue; 672 } 673 if (ret < 0) 674 goto error_ret; 675 attrcount++; 676 } 677 678 if (chan->ext_info) { 679 unsigned int i = 0; 680 for (ext_info = chan->ext_info; ext_info->name; ext_info++) { 681 ret = __iio_add_chan_devattr(ext_info->name, 682 chan, 683 ext_info->read ? 684 &iio_read_channel_ext_info : NULL, 685 ext_info->write ? 686 &iio_write_channel_ext_info : NULL, 687 i, 688 ext_info->shared, 689 &indio_dev->dev, 690 &indio_dev->channel_attr_list); 691 i++; 692 if (ret == -EBUSY && ext_info->shared) 693 continue; 694 695 if (ret) 696 goto error_ret; 697 698 attrcount++; 699 } 700 } 701 702 ret = attrcount; 703 error_ret: 704 return ret; 705 } 706 707 static void iio_device_remove_and_free_read_attr(struct iio_dev *indio_dev, 708 struct iio_dev_attr *p) 709 { 710 kfree(p->dev_attr.attr.name); 711 kfree(p); 712 } 713 714 static ssize_t iio_show_dev_name(struct device *dev, 715 struct device_attribute *attr, 716 char *buf) 717 { 718 struct iio_dev *indio_dev = dev_to_iio_dev(dev); 719 return sprintf(buf, "%s\n", indio_dev->name); 720 } 721 722 static DEVICE_ATTR(name, S_IRUGO, iio_show_dev_name, NULL); 723 724 static int iio_device_register_sysfs(struct iio_dev *indio_dev) 725 { 726 int i, ret = 0, attrcount, attrn, attrcount_orig = 0; 727 struct iio_dev_attr *p, *n; 728 struct attribute **attr; 729 730 /* First count elements in any existing group */ 731 if (indio_dev->info->attrs) { 732 attr = indio_dev->info->attrs->attrs; 733 while (*attr++ != NULL) 734 attrcount_orig++; 735 } 736 attrcount = attrcount_orig; 737 /* 738 * New channel registration method - relies on the fact a group does 739 * not need to be initialized if its name is NULL. 740 */ 741 if (indio_dev->channels) 742 for (i = 0; i < indio_dev->num_channels; i++) { 743 ret = iio_device_add_channel_sysfs(indio_dev, 744 &indio_dev 745 ->channels[i]); 746 if (ret < 0) 747 goto error_clear_attrs; 748 attrcount += ret; 749 } 750 751 if (indio_dev->name) 752 attrcount++; 753 754 indio_dev->chan_attr_group.attrs = kcalloc(attrcount + 1, 755 sizeof(indio_dev->chan_attr_group.attrs[0]), 756 GFP_KERNEL); 757 if (indio_dev->chan_attr_group.attrs == NULL) { 758 ret = -ENOMEM; 759 goto error_clear_attrs; 760 } 761 /* Copy across original attributes */ 762 if (indio_dev->info->attrs) 763 memcpy(indio_dev->chan_attr_group.attrs, 764 indio_dev->info->attrs->attrs, 765 sizeof(indio_dev->chan_attr_group.attrs[0]) 766 *attrcount_orig); 767 attrn = attrcount_orig; 768 /* Add all elements from the list. */ 769 list_for_each_entry(p, &indio_dev->channel_attr_list, l) 770 indio_dev->chan_attr_group.attrs[attrn++] = &p->dev_attr.attr; 771 if (indio_dev->name) 772 indio_dev->chan_attr_group.attrs[attrn++] = &dev_attr_name.attr; 773 774 indio_dev->groups[indio_dev->groupcounter++] = 775 &indio_dev->chan_attr_group; 776 777 return 0; 778 779 error_clear_attrs: 780 list_for_each_entry_safe(p, n, 781 &indio_dev->channel_attr_list, l) { 782 list_del(&p->l); 783 iio_device_remove_and_free_read_attr(indio_dev, p); 784 } 785 786 return ret; 787 } 788 789 static void iio_device_unregister_sysfs(struct iio_dev *indio_dev) 790 { 791 792 struct iio_dev_attr *p, *n; 793 794 list_for_each_entry_safe(p, n, &indio_dev->channel_attr_list, l) { 795 list_del(&p->l); 796 iio_device_remove_and_free_read_attr(indio_dev, p); 797 } 798 kfree(indio_dev->chan_attr_group.attrs); 799 } 800 801 static void iio_dev_release(struct device *device) 802 { 803 struct iio_dev *indio_dev = dev_to_iio_dev(device); 804 if (indio_dev->chrdev.dev) 805 cdev_del(&indio_dev->chrdev); 806 if (indio_dev->modes & INDIO_BUFFER_TRIGGERED) 807 iio_device_unregister_trigger_consumer(indio_dev); 808 iio_device_unregister_eventset(indio_dev); 809 iio_device_unregister_sysfs(indio_dev); 810 iio_device_unregister_debugfs(indio_dev); 811 812 ida_simple_remove(&iio_ida, indio_dev->id); 813 kfree(indio_dev); 814 } 815 816 static struct device_type iio_dev_type = { 817 .name = "iio_device", 818 .release = iio_dev_release, 819 }; 820 821 struct iio_dev *iio_device_alloc(int sizeof_priv) 822 { 823 struct iio_dev *dev; 824 size_t alloc_size; 825 826 alloc_size = sizeof(struct iio_dev); 827 if (sizeof_priv) { 828 alloc_size = ALIGN(alloc_size, IIO_ALIGN); 829 alloc_size += sizeof_priv; 830 } 831 /* ensure 32-byte alignment of whole construct ? */ 832 alloc_size += IIO_ALIGN - 1; 833 834 dev = kzalloc(alloc_size, GFP_KERNEL); 835 836 if (dev) { 837 dev->dev.groups = dev->groups; 838 dev->dev.type = &iio_dev_type; 839 dev->dev.bus = &iio_bus_type; 840 device_initialize(&dev->dev); 841 dev_set_drvdata(&dev->dev, (void *)dev); 842 mutex_init(&dev->mlock); 843 mutex_init(&dev->info_exist_lock); 844 INIT_LIST_HEAD(&dev->channel_attr_list); 845 846 dev->id = ida_simple_get(&iio_ida, 0, 0, GFP_KERNEL); 847 if (dev->id < 0) { 848 /* cannot use a dev_err as the name isn't available */ 849 printk(KERN_ERR "Failed to get id\n"); 850 kfree(dev); 851 return NULL; 852 } 853 dev_set_name(&dev->dev, "iio:device%d", dev->id); 854 } 855 856 return dev; 857 } 858 EXPORT_SYMBOL(iio_device_alloc); 859 860 void iio_device_free(struct iio_dev *dev) 861 { 862 if (dev) 863 put_device(&dev->dev); 864 } 865 EXPORT_SYMBOL(iio_device_free); 866 867 /** 868 * iio_chrdev_open() - chrdev file open for buffer access and ioctls 869 **/ 870 static int iio_chrdev_open(struct inode *inode, struct file *filp) 871 { 872 struct iio_dev *indio_dev = container_of(inode->i_cdev, 873 struct iio_dev, chrdev); 874 875 if (test_and_set_bit(IIO_BUSY_BIT_POS, &indio_dev->flags)) 876 return -EBUSY; 877 878 filp->private_data = indio_dev; 879 880 return 0; 881 } 882 883 /** 884 * iio_chrdev_release() - chrdev file close buffer access and ioctls 885 **/ 886 static int iio_chrdev_release(struct inode *inode, struct file *filp) 887 { 888 struct iio_dev *indio_dev = container_of(inode->i_cdev, 889 struct iio_dev, chrdev); 890 clear_bit(IIO_BUSY_BIT_POS, &indio_dev->flags); 891 return 0; 892 } 893 894 /* Somewhat of a cross file organization violation - ioctls here are actually 895 * event related */ 896 static long iio_ioctl(struct file *filp, unsigned int cmd, unsigned long arg) 897 { 898 struct iio_dev *indio_dev = filp->private_data; 899 int __user *ip = (int __user *)arg; 900 int fd; 901 902 if (cmd == IIO_GET_EVENT_FD_IOCTL) { 903 fd = iio_event_getfd(indio_dev); 904 if (copy_to_user(ip, &fd, sizeof(fd))) 905 return -EFAULT; 906 return 0; 907 } 908 return -EINVAL; 909 } 910 911 static const struct file_operations iio_buffer_fileops = { 912 .read = iio_buffer_read_first_n_outer_addr, 913 .release = iio_chrdev_release, 914 .open = iio_chrdev_open, 915 .poll = iio_buffer_poll_addr, 916 .owner = THIS_MODULE, 917 .llseek = noop_llseek, 918 .unlocked_ioctl = iio_ioctl, 919 .compat_ioctl = iio_ioctl, 920 }; 921 922 static const struct iio_buffer_setup_ops noop_ring_setup_ops; 923 924 int iio_device_register(struct iio_dev *indio_dev) 925 { 926 int ret; 927 928 /* configure elements for the chrdev */ 929 indio_dev->dev.devt = MKDEV(MAJOR(iio_devt), indio_dev->id); 930 931 ret = iio_device_register_debugfs(indio_dev); 932 if (ret) { 933 dev_err(indio_dev->dev.parent, 934 "Failed to register debugfs interfaces\n"); 935 goto error_ret; 936 } 937 ret = iio_device_register_sysfs(indio_dev); 938 if (ret) { 939 dev_err(indio_dev->dev.parent, 940 "Failed to register sysfs interfaces\n"); 941 goto error_unreg_debugfs; 942 } 943 ret = iio_device_register_eventset(indio_dev); 944 if (ret) { 945 dev_err(indio_dev->dev.parent, 946 "Failed to register event set\n"); 947 goto error_free_sysfs; 948 } 949 if (indio_dev->modes & INDIO_BUFFER_TRIGGERED) 950 iio_device_register_trigger_consumer(indio_dev); 951 952 if ((indio_dev->modes & INDIO_ALL_BUFFER_MODES) && 953 indio_dev->setup_ops == NULL) 954 indio_dev->setup_ops = &noop_ring_setup_ops; 955 956 ret = device_add(&indio_dev->dev); 957 if (ret < 0) 958 goto error_unreg_eventset; 959 cdev_init(&indio_dev->chrdev, &iio_buffer_fileops); 960 indio_dev->chrdev.owner = indio_dev->info->driver_module; 961 ret = cdev_add(&indio_dev->chrdev, indio_dev->dev.devt, 1); 962 if (ret < 0) 963 goto error_del_device; 964 return 0; 965 966 error_del_device: 967 device_del(&indio_dev->dev); 968 error_unreg_eventset: 969 iio_device_unregister_eventset(indio_dev); 970 error_free_sysfs: 971 iio_device_unregister_sysfs(indio_dev); 972 error_unreg_debugfs: 973 iio_device_unregister_debugfs(indio_dev); 974 error_ret: 975 return ret; 976 } 977 EXPORT_SYMBOL(iio_device_register); 978 979 void iio_device_unregister(struct iio_dev *indio_dev) 980 { 981 mutex_lock(&indio_dev->info_exist_lock); 982 indio_dev->info = NULL; 983 mutex_unlock(&indio_dev->info_exist_lock); 984 device_del(&indio_dev->dev); 985 } 986 EXPORT_SYMBOL(iio_device_unregister); 987 subsys_initcall(iio_init); 988 module_exit(iio_exit); 989 990 MODULE_AUTHOR("Jonathan Cameron <jic23@kernel.org>"); 991 MODULE_DESCRIPTION("Industrial I/O core"); 992 MODULE_LICENSE("GPL"); 993