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