/drivers/staging/iio/adc/ad7745.c
C | 674 lines | 520 code | 127 blank | 27 comment | 29 complexity | 117b6c4faa65523bfb7c8bdbfb680102 MD5 | raw file
Possible License(s): LGPL-2.0, AGPL-1.0, GPL-2.0
1/* 2 * AD774X capacitive sensor driver supporting AD7745/6/7 3 * 4 * Copyright 2010 Analog Devices Inc. 5 * 6 * Licensed under the GPL-2 or later. 7 */ 8 9#include <linux/interrupt.h> 10#include <linux/gpio.h> 11#include <linux/device.h> 12#include <linux/kernel.h> 13#include <linux/slab.h> 14#include <linux/sysfs.h> 15#include <linux/list.h> 16#include <linux/i2c.h> 17 18#include "../iio.h" 19#include "../sysfs.h" 20 21/* 22 * AD774X registers definition 23 */ 24 25#define AD774X_STATUS 0 26#define AD774X_STATUS_RDY (1 << 2) 27#define AD774X_STATUS_RDYVT (1 << 1) 28#define AD774X_STATUS_RDYCAP (1 << 0) 29#define AD774X_CAP_DATA_HIGH 1 30#define AD774X_CAP_DATA_MID 2 31#define AD774X_CAP_DATA_LOW 3 32#define AD774X_VT_DATA_HIGH 4 33#define AD774X_VT_DATA_MID 5 34#define AD774X_VT_DATA_LOW 6 35#define AD774X_CAP_SETUP 7 36#define AD774X_VT_SETUP 8 37#define AD774X_EXEC_SETUP 9 38#define AD774X_CFG 10 39#define AD774X_CAPDACA 11 40#define AD774X_CAPDACB 12 41#define AD774X_CAPDAC_EN (1 << 7) 42#define AD774X_CAP_OFFH 13 43#define AD774X_CAP_OFFL 14 44#define AD774X_CAP_GAINH 15 45#define AD774X_CAP_GAINL 16 46#define AD774X_VOLT_GAINH 17 47#define AD774X_VOLT_GAINL 18 48 49#define AD774X_MAX_CONV_MODE 6 50 51/* 52 * struct ad774x_chip_info - chip specifc information 53 */ 54 55struct ad774x_chip_info { 56 struct i2c_client *client; 57 bool inter; 58 u16 cap_offs; /* Capacitive offset */ 59 u16 cap_gain; /* Capacitive gain calibration */ 60 u16 volt_gain; /* Voltage gain calibration */ 61 u8 cap_setup; 62 u8 vt_setup; 63 u8 exec_setup; 64 65 char *conversion_mode; 66}; 67 68struct ad774x_conversion_mode { 69 char *name; 70 u8 reg_cfg; 71}; 72 73static struct ad774x_conversion_mode 74ad774x_conv_mode_table[AD774X_MAX_CONV_MODE] = { 75 { "idle", 0 }, 76 { "continuous-conversion", 1 }, 77 { "single-conversion", 2 }, 78 { "power-down", 3 }, 79 { "offset-calibration", 5 }, 80 { "gain-calibration", 6 }, 81}; 82 83/* 84 * ad774x register access by I2C 85 */ 86 87static int ad774x_i2c_read(struct ad774x_chip_info *chip, u8 reg, u8 *data, int len) 88{ 89 struct i2c_client *client = chip->client; 90 int ret; 91 92 ret = i2c_master_send(client, ®, 1); 93 if (ret < 0) { 94 dev_err(&client->dev, "I2C write error\n"); 95 return ret; 96 } 97 98 ret = i2c_master_recv(client, data, len); 99 if (ret < 0) { 100 dev_err(&client->dev, "I2C read error\n"); 101 return ret; 102 } 103 104 return ret; 105} 106 107static int ad774x_i2c_write(struct ad774x_chip_info *chip, u8 reg, u8 data) 108{ 109 struct i2c_client *client = chip->client; 110 int ret; 111 112 u8 tx[2] = { 113 reg, 114 data, 115 }; 116 117 ret = i2c_master_send(client, tx, 2); 118 if (ret < 0) 119 dev_err(&client->dev, "I2C write error\n"); 120 121 return ret; 122} 123 124/* 125 * sysfs nodes 126 */ 127 128#define IIO_DEV_ATTR_AVAIL_CONVERSION_MODES(_show) \ 129 IIO_DEVICE_ATTR(available_conversion_modes, S_IRUGO, _show, NULL, 0) 130#define IIO_DEV_ATTR_CONVERSION_MODE(_mode, _show, _store) \ 131 IIO_DEVICE_ATTR(conversion_mode, _mode, _show, _store, 0) 132#define IIO_DEV_ATTR_CAP_SETUP(_mode, _show, _store) \ 133 IIO_DEVICE_ATTR(cap_setup, _mode, _show, _store, 0) 134#define IIO_DEV_ATTR_VT_SETUP(_mode, _show, _store) \ 135 IIO_DEVICE_ATTR(in0_setup, _mode, _show, _store, 0) 136#define IIO_DEV_ATTR_EXEC_SETUP(_mode, _show, _store) \ 137 IIO_DEVICE_ATTR(exec_setup, _mode, _show, _store, 0) 138#define IIO_DEV_ATTR_VOLT_GAIN(_mode, _show, _store) \ 139 IIO_DEVICE_ATTR(in0_gain, _mode, _show, _store, 0) 140#define IIO_DEV_ATTR_CAP_OFFS(_mode, _show, _store) \ 141 IIO_DEVICE_ATTR(cap_offs, _mode, _show, _store, 0) 142#define IIO_DEV_ATTR_CAP_GAIN(_mode, _show, _store) \ 143 IIO_DEVICE_ATTR(cap_gain, _mode, _show, _store, 0) 144#define IIO_DEV_ATTR_CAP_DATA(_show) \ 145 IIO_DEVICE_ATTR(cap0_raw, S_IRUGO, _show, NULL, 0) 146#define IIO_DEV_ATTR_VT_DATA(_show) \ 147 IIO_DEVICE_ATTR(in0_raw, S_IRUGO, _show, NULL, 0) 148 149static ssize_t ad774x_show_conversion_modes(struct device *dev, 150 struct device_attribute *attr, 151 char *buf) 152{ 153 int i; 154 int len = 0; 155 156 for (i = 0; i < AD774X_MAX_CONV_MODE; i++) 157 len += sprintf(buf + len, "%s ", ad774x_conv_mode_table[i].name); 158 159 len += sprintf(buf + len, "\n"); 160 161 return len; 162} 163 164static IIO_DEV_ATTR_AVAIL_CONVERSION_MODES(ad774x_show_conversion_modes); 165 166static ssize_t ad774x_show_conversion_mode(struct device *dev, 167 struct device_attribute *attr, 168 char *buf) 169{ 170 struct iio_dev *dev_info = dev_get_drvdata(dev); 171 struct ad774x_chip_info *chip = iio_priv(dev_info); 172 173 return sprintf(buf, "%s\n", chip->conversion_mode); 174} 175 176static ssize_t ad774x_store_conversion_mode(struct device *dev, 177 struct device_attribute *attr, 178 const char *buf, 179 size_t len) 180{ 181 struct iio_dev *dev_info = dev_get_drvdata(dev); 182 struct ad774x_chip_info *chip = iio_priv(dev_info); 183 u8 cfg; 184 int i; 185 186 ad774x_i2c_read(chip, AD774X_CFG, &cfg, 1); 187 188 for (i = 0; i < AD774X_MAX_CONV_MODE; i++) { 189 if (strncmp(buf, ad774x_conv_mode_table[i].name, 190 strlen(ad774x_conv_mode_table[i].name) - 1) == 0) { 191 chip->conversion_mode = ad774x_conv_mode_table[i].name; 192 cfg |= 0x18 | ad774x_conv_mode_table[i].reg_cfg; 193 ad774x_i2c_write(chip, AD774X_CFG, cfg); 194 return len; 195 } 196 } 197 198 dev_err(dev, "not supported conversion mode\n"); 199 200 return -EINVAL; 201} 202 203static IIO_DEV_ATTR_CONVERSION_MODE(S_IRUGO | S_IWUSR, 204 ad774x_show_conversion_mode, 205 ad774x_store_conversion_mode); 206 207static ssize_t ad774x_show_dac_value(struct device *dev, 208 struct device_attribute *attr, 209 char *buf) 210{ 211 struct iio_dev *dev_info = dev_get_drvdata(dev); 212 struct ad774x_chip_info *chip = iio_priv(dev_info); 213 struct iio_dev_attr *this_attr = to_iio_dev_attr(attr); 214 u8 data; 215 216 ad774x_i2c_read(chip, this_attr->address, &data, 1); 217 218 return sprintf(buf, "%02x\n", data & 0x7F); 219} 220 221static ssize_t ad774x_store_dac_value(struct device *dev, 222 struct device_attribute *attr, 223 const char *buf, 224 size_t len) 225{ 226 struct iio_dev *dev_info = dev_get_drvdata(dev); 227 struct ad774x_chip_info *chip = iio_priv(dev_info); 228 struct iio_dev_attr *this_attr = to_iio_dev_attr(attr); 229 unsigned long data; 230 int ret; 231 232 ret = strict_strtoul(buf, 10, &data); 233 234 if (!ret) { 235 ad774x_i2c_write(chip, this_attr->address, 236 (data ? AD774X_CAPDAC_EN : 0) | (data & 0x7F)); 237 return len; 238 } 239 240 return -EINVAL; 241} 242 243static IIO_DEVICE_ATTR(capdac0_raw, S_IRUGO | S_IWUSR, 244 ad774x_show_dac_value, 245 ad774x_store_dac_value, 246 AD774X_CAPDACA); 247 248static IIO_DEVICE_ATTR(capdac1_raw, S_IRUGO | S_IWUSR, 249 ad774x_show_dac_value, 250 ad774x_store_dac_value, 251 AD774X_CAPDACB); 252 253static ssize_t ad774x_show_cap_setup(struct device *dev, 254 struct device_attribute *attr, 255 char *buf) 256{ 257 struct iio_dev *dev_info = dev_get_drvdata(dev); 258 struct ad774x_chip_info *chip = iio_priv(dev_info); 259 260 return sprintf(buf, "0x%02x\n", chip->cap_setup); 261} 262 263static ssize_t ad774x_store_cap_setup(struct device *dev, 264 struct device_attribute *attr, 265 const char *buf, 266 size_t len) 267{ 268 struct iio_dev *dev_info = dev_get_drvdata(dev); 269 struct ad774x_chip_info *chip = iio_priv(dev_info); 270 unsigned long data; 271 int ret; 272 273 ret = strict_strtoul(buf, 10, &data); 274 275 if ((!ret) && (data < 0x100)) { 276 ad774x_i2c_write(chip, AD774X_CAP_SETUP, data); 277 chip->cap_setup = data; 278 return len; 279 } 280 281 return -EINVAL; 282} 283 284static IIO_DEV_ATTR_CAP_SETUP(S_IRUGO | S_IWUSR, 285 ad774x_show_cap_setup, 286 ad774x_store_cap_setup); 287 288static ssize_t ad774x_show_vt_setup(struct device *dev, 289 struct device_attribute *attr, 290 char *buf) 291{ 292 struct iio_dev *dev_info = dev_get_drvdata(dev); 293 struct ad774x_chip_info *chip = iio_priv(dev_info); 294 295 return sprintf(buf, "0x%02x\n", chip->vt_setup); 296} 297 298static ssize_t ad774x_store_vt_setup(struct device *dev, 299 struct device_attribute *attr, 300 const char *buf, 301 size_t len) 302{ 303 struct iio_dev *dev_info = dev_get_drvdata(dev); 304 struct ad774x_chip_info *chip = iio_priv(dev_info); 305 unsigned long data; 306 int ret; 307 308 ret = strict_strtoul(buf, 10, &data); 309 310 if ((!ret) && (data < 0x100)) { 311 ad774x_i2c_write(chip, AD774X_VT_SETUP, data); 312 chip->vt_setup = data; 313 return len; 314 } 315 316 return -EINVAL; 317} 318 319static IIO_DEV_ATTR_VT_SETUP(S_IRUGO | S_IWUSR, 320 ad774x_show_vt_setup, 321 ad774x_store_vt_setup); 322 323static ssize_t ad774x_show_exec_setup(struct device *dev, 324 struct device_attribute *attr, 325 char *buf) 326{ 327 struct iio_dev *dev_info = dev_get_drvdata(dev); 328 struct ad774x_chip_info *chip = iio_priv(dev_info); 329 330 return sprintf(buf, "0x%02x\n", chip->exec_setup); 331} 332 333static ssize_t ad774x_store_exec_setup(struct device *dev, 334 struct device_attribute *attr, 335 const char *buf, 336 size_t len) 337{ 338 struct iio_dev *dev_info = dev_get_drvdata(dev); 339 struct ad774x_chip_info *chip = iio_priv(dev_info); 340 unsigned long data; 341 int ret; 342 343 ret = strict_strtoul(buf, 10, &data); 344 345 if ((!ret) && (data < 0x100)) { 346 ad774x_i2c_write(chip, AD774X_EXEC_SETUP, data); 347 chip->exec_setup = data; 348 return len; 349 } 350 351 return -EINVAL; 352} 353 354static IIO_DEV_ATTR_EXEC_SETUP(S_IRUGO | S_IWUSR, 355 ad774x_show_exec_setup, 356 ad774x_store_exec_setup); 357 358static ssize_t ad774x_show_volt_gain(struct device *dev, 359 struct device_attribute *attr, 360 char *buf) 361{ 362 struct iio_dev *dev_info = dev_get_drvdata(dev); 363 struct ad774x_chip_info *chip = iio_priv(dev_info); 364 365 return sprintf(buf, "%d\n", chip->volt_gain); 366} 367 368static ssize_t ad774x_store_volt_gain(struct device *dev, 369 struct device_attribute *attr, 370 const char *buf, 371 size_t len) 372{ 373 struct iio_dev *dev_info = dev_get_drvdata(dev); 374 struct ad774x_chip_info *chip = iio_priv(dev_info); 375 unsigned long data; 376 int ret; 377 378 ret = strict_strtoul(buf, 10, &data); 379 380 if ((!ret) && (data < 0x10000)) { 381 ad774x_i2c_write(chip, AD774X_VOLT_GAINH, data >> 8); 382 ad774x_i2c_write(chip, AD774X_VOLT_GAINL, data); 383 chip->volt_gain = data; 384 return len; 385 } 386 387 return -EINVAL; 388} 389 390static IIO_DEV_ATTR_VOLT_GAIN(S_IRUGO | S_IWUSR, 391 ad774x_show_volt_gain, 392 ad774x_store_volt_gain); 393 394static ssize_t ad774x_show_cap_data(struct device *dev, 395 struct device_attribute *attr, 396 char *buf) 397{ 398 struct iio_dev *dev_info = dev_get_drvdata(dev); 399 struct ad774x_chip_info *chip = iio_priv(dev_info); 400 unsigned long data; 401 char tmp[3]; 402 403 ad774x_i2c_read(chip, AD774X_CAP_DATA_HIGH, tmp, 3); 404 data = ((int)tmp[0] << 16) | ((int)tmp[1] << 8) | (int)tmp[2]; 405 406 return sprintf(buf, "%ld\n", data); 407} 408 409static IIO_DEV_ATTR_CAP_DATA(ad774x_show_cap_data); 410 411static ssize_t ad774x_show_vt_data(struct device *dev, 412 struct device_attribute *attr, 413 char *buf) 414{ 415 struct iio_dev *dev_info = dev_get_drvdata(dev); 416 struct ad774x_chip_info *chip = iio_priv(dev_info); 417 unsigned long data; 418 char tmp[3]; 419 420 ad774x_i2c_read(chip, AD774X_VT_DATA_HIGH, tmp, 3); 421 data = ((int)tmp[0] << 16) | ((int)tmp[1] << 8) | (int)tmp[2]; 422 423 return sprintf(buf, "%ld\n", data); 424} 425 426static IIO_DEV_ATTR_VT_DATA(ad774x_show_vt_data); 427 428static ssize_t ad774x_show_cap_offs(struct device *dev, 429 struct device_attribute *attr, 430 char *buf) 431{ 432 struct iio_dev *dev_info = dev_get_drvdata(dev); 433 struct ad774x_chip_info *chip = iio_priv(dev_info); 434 435 return sprintf(buf, "%d\n", chip->cap_offs); 436} 437 438static ssize_t ad774x_store_cap_offs(struct device *dev, 439 struct device_attribute *attr, 440 const char *buf, 441 size_t len) 442{ 443 struct iio_dev *dev_info = dev_get_drvdata(dev); 444 struct ad774x_chip_info *chip = iio_priv(dev_info); 445 unsigned long data; 446 int ret; 447 448 ret = strict_strtoul(buf, 10, &data); 449 450 if ((!ret) && (data < 0x10000)) { 451 ad774x_i2c_write(chip, AD774X_CAP_OFFH, data >> 8); 452 ad774x_i2c_write(chip, AD774X_CAP_OFFL, data); 453 chip->cap_offs = data; 454 return len; 455 } 456 457 return -EINVAL; 458} 459 460static IIO_DEV_ATTR_CAP_OFFS(S_IRUGO | S_IWUSR, 461 ad774x_show_cap_offs, 462 ad774x_store_cap_offs); 463 464static ssize_t ad774x_show_cap_gain(struct device *dev, 465 struct device_attribute *attr, 466 char *buf) 467{ 468 struct iio_dev *dev_info = dev_get_drvdata(dev); 469 struct ad774x_chip_info *chip = iio_priv(dev_info); 470 471 return sprintf(buf, "%d\n", chip->cap_gain); 472} 473 474static ssize_t ad774x_store_cap_gain(struct device *dev, 475 struct device_attribute *attr, 476 const char *buf, 477 size_t len) 478{ 479 struct iio_dev *dev_info = dev_get_drvdata(dev); 480 struct ad774x_chip_info *chip = iio_priv(dev_info); 481 unsigned long data; 482 int ret; 483 484 ret = strict_strtoul(buf, 10, &data); 485 486 if ((!ret) && (data < 0x10000)) { 487 ad774x_i2c_write(chip, AD774X_CAP_GAINH, data >> 8); 488 ad774x_i2c_write(chip, AD774X_CAP_GAINL, data); 489 chip->cap_gain = data; 490 return len; 491 } 492 493 return -EINVAL; 494} 495 496static IIO_DEV_ATTR_CAP_GAIN(S_IRUGO | S_IWUSR, 497 ad774x_show_cap_gain, 498 ad774x_store_cap_gain); 499 500static struct attribute *ad774x_attributes[] = { 501 &iio_dev_attr_available_conversion_modes.dev_attr.attr, 502 &iio_dev_attr_conversion_mode.dev_attr.attr, 503 &iio_dev_attr_cap_setup.dev_attr.attr, 504 &iio_dev_attr_in0_setup.dev_attr.attr, 505 &iio_dev_attr_exec_setup.dev_attr.attr, 506 &iio_dev_attr_cap_offs.dev_attr.attr, 507 &iio_dev_attr_cap_gain.dev_attr.attr, 508 &iio_dev_attr_in0_gain.dev_attr.attr, 509 &iio_dev_attr_in0_raw.dev_attr.attr, 510 &iio_dev_attr_cap0_raw.dev_attr.attr, 511 &iio_dev_attr_capdac0_raw.dev_attr.attr, 512 &iio_dev_attr_capdac1_raw.dev_attr.attr, 513 NULL, 514}; 515 516static const struct attribute_group ad774x_attribute_group = { 517 .attrs = ad774x_attributes, 518}; 519 520/* 521 * data ready events 522 */ 523 524#define IIO_EVENT_CODE_CAP_RDY 0 525#define IIO_EVENT_CODE_VT_RDY 1 526 527#define IIO_EVENT_ATTR_CAP_RDY_SH(_evlist, _show, _store, _mask) \ 528 IIO_EVENT_ATTR_SH(cap_rdy, _evlist, _show, _store, _mask) 529 530#define IIO_EVENT_ATTR_VT_RDY_SH(_evlist, _show, _store, _mask) \ 531 IIO_EVENT_ATTR_SH(vt_rdy, _evlist, _show, _store, _mask) 532 533static irqreturn_t ad774x_event_handler(int irq, void *private) 534{ 535 struct iio_dev *indio_dev = private; 536 struct ad774x_chip_info *chip = iio_priv(indio_dev); 537 u8 int_status; 538 539 ad774x_i2c_read(chip, AD774X_STATUS, &int_status, 1); 540 541 if (int_status & AD774X_STATUS_RDYCAP) 542 iio_push_event(indio_dev, 0, 543 IIO_EVENT_CODE_CAP_RDY, 544 iio_get_time_ns()); 545 546 if (int_status & AD774X_STATUS_RDYVT) 547 iio_push_event(indio_dev, 0, 548 IIO_EVENT_CODE_VT_RDY, 549 iio_get_time_ns()); 550 551 return IRQ_HANDLED; 552} 553 554static IIO_CONST_ATTR(cap_rdy_en, "1"); 555static IIO_CONST_ATTR(vt_rdy_en, "1"); 556 557static struct attribute *ad774x_event_attributes[] = { 558 &iio_const_attr_cap_rdy_en.dev_attr.attr, 559 &iio_const_attr_vt_rdy_en.dev_attr.attr, 560 NULL, 561}; 562 563static struct attribute_group ad774x_event_attribute_group = { 564 .attrs = ad774x_event_attributes, 565}; 566 567static const struct iio_info ad774x_info = { 568 .attrs = &ad774x_event_attribute_group, 569 .event_attrs = &ad774x_event_attribute_group, 570 .num_interrupt_lines = 1, 571 .driver_module = THIS_MODULE, 572}; 573/* 574 * device probe and remove 575 */ 576 577static int __devinit ad774x_probe(struct i2c_client *client, 578 const struct i2c_device_id *id) 579{ 580 int ret = 0, regdone = 0; 581 struct ad774x_chip_info *chip; 582 struct iio_dev *indio_dev; 583 584 indio_dev = iio_allocate_device(sizeof(*chip)); 585 if (indio_dev == NULL) { 586 ret = -ENOMEM; 587 goto error_ret; 588 } 589 chip = iio_priv(indio_dev); 590 /* this is only used for device removal purposes */ 591 i2c_set_clientdata(client, indio_dev); 592 593 chip->client = client; 594 595 /* Establish that the iio_dev is a child of the i2c device */ 596 indio_dev->name = id->name; 597 indio_dev->dev.parent = &client->dev; 598 indio_dev->info = &ad774x_info; 599 indio_dev->modes = INDIO_DIRECT_MODE; 600 601 ret = iio_device_register(indio_dev); 602 if (ret) 603 goto error_free_dev; 604 regdone = 1; 605 606 if (client->irq) { 607 ret = request_threaded_irq(client->irq, 608 NULL, 609 &ad774x_event_handler, 610 IRQF_TRIGGER_FALLING, 611 "ad774x", 612 indio_dev); 613 if (ret) 614 goto error_free_dev; 615 } 616 617 dev_err(&client->dev, "%s capacitive sensor registered, irq: %d\n", id->name, client->irq); 618 619 return 0; 620 621error_free_dev: 622 if (regdone) 623 free_irq(client->irq, indio_dev); 624 else 625 iio_free_device(indio_dev); 626error_ret: 627 return ret; 628} 629 630static int __devexit ad774x_remove(struct i2c_client *client) 631{ 632 struct iio_dev *indio_dev = i2c_get_clientdata(client); 633 634 if (client->irq) 635 free_irq(client->irq, indio_dev); 636 iio_device_unregister(indio_dev); 637 638 return 0; 639} 640 641static const struct i2c_device_id ad774x_id[] = { 642 { "ad7745", 0 }, 643 { "ad7746", 0 }, 644 { "ad7747", 0 }, 645 {} 646}; 647 648MODULE_DEVICE_TABLE(i2c, ad774x_id); 649 650static struct i2c_driver ad774x_driver = { 651 .driver = { 652 .name = "ad774x", 653 }, 654 .probe = ad774x_probe, 655 .remove = __devexit_p(ad774x_remove), 656 .id_table = ad774x_id, 657}; 658 659static __init int ad774x_init(void) 660{ 661 return i2c_add_driver(&ad774x_driver); 662} 663 664static __exit void ad774x_exit(void) 665{ 666 i2c_del_driver(&ad774x_driver); 667} 668 669MODULE_AUTHOR("Barry Song <21cnbao@gmail.com>"); 670MODULE_DESCRIPTION("Analog Devices ad7745/6/7 capacitive sensor driver"); 671MODULE_LICENSE("GPL v2"); 672 673module_init(ad774x_init); 674module_exit(ad774x_exit);