drivers/staging/iio/adc/ad7150.c

   1 /*
   2  * AD7150 capacitive sensor driver supporting AD7150/1/6
   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/device.h>
  11 #include <linux/kernel.h>
  12 #include <linux/slab.h>
  13 #include <linux/i2c.h>
  14
  15 #include "../iio.h"
  16 #include "../sysfs.h"
  17
  18 /*
  19  * AD7150 registers definition
  20  */
  21
  22 #define AD7150_STATUS              0
  23 #define AD7150_STATUS_OUT1         (1 << 3)
  24 #define AD7150_STATUS_OUT2         (1 << 5)
  25 #define AD7150_CH1_DATA_HIGH       1
  26 #define AD7150_CH1_DATA_LOW        2
  27 #define AD7150_CH2_DATA_HIGH       3
  28 #define AD7150_CH2_DATA_LOW        4
  29 #define AD7150_CH1_AVG_HIGH        5
  30 #define AD7150_CH1_AVG_LOW         6
  31 #define AD7150_CH2_AVG_HIGH        7
  32 #define AD7150_CH2_AVG_LOW         8
  33 #define AD7150_CH1_SENSITIVITY     9
  34 #define AD7150_CH1_THR_HOLD_H      9
  35 #define AD7150_CH1_TIMEOUT         10
  36 #define AD7150_CH1_THR_HOLD_L      10
  37 #define AD7150_CH1_SETUP           11
  38 #define AD7150_CH2_SENSITIVITY     12
  39 #define AD7150_CH2_THR_HOLD_H      12
  40 #define AD7150_CH2_TIMEOUT         13
  41 #define AD7150_CH2_THR_HOLD_L      13
  42 #define AD7150_CH2_SETUP           14
  43 #define AD7150_CFG                 15
  44 #define AD7150_CFG_FIX             (1 << 7)
  45 #define AD7150_PD_TIMER            16
  46 #define AD7150_CH1_CAPDAC          17
  47 #define AD7150_CH2_CAPDAC          18
  48 #define AD7150_SN3                 19
  49 #define AD7150_SN2                 20
  50 #define AD7150_SN1                 21
  51 #define AD7150_SN0                 22
  52 #define AD7150_ID                  23
  53
  54 #define AD7150_MAX_CONV_MODE       4
  55
  56 /*
  57  * struct ad7150_chip_info - chip specifc information
  58  */
  59
  60 struct ad7150_chip_info {
  61         const char *name;
  62         struct i2c_client *client;
  63         struct iio_dev *indio_dev;
  64         bool inter;
  65         u16 ch1_threshold;     /* Ch1 Threshold (in fixed threshold mode) */
  66         u8  ch1_sensitivity;   /* Ch1 Sensitivity (in adaptive threshold mode) */
  67         u8  ch1_timeout;       /* Ch1 Timeout (in adaptive threshold mode) */
  68         u8  ch1_setup;
  69         u16 ch2_threshold;     /* Ch2 Threshold (in fixed threshold mode) */
  70         u8  ch2_sensitivity;   /* Ch1 Sensitivity (in adaptive threshold mode) */
  71         u8  ch2_timeout;       /* Ch1 Timeout (in adaptive threshold mode) */
  72         u8  ch2_setup;
  73         u8  powerdown_timer;
  74         char threshold_mode[10]; /* adaptive/fixed threshold mode */
  75         int old_state;
  76         char *conversion_mode;
  77 };
  78
  79 struct ad7150_conversion_mode {
  80         char *name;
  81         u8 reg_cfg;
  82 };
  83
  84 static struct ad7150_conversion_mode
  85 ad7150_conv_mode_table[AD7150_MAX_CONV_MODE] = {
  86         { "idle", 0 },
  87         { "continuous-conversion", 1 },
  88         { "single-conversion", 2 },
  89         { "power-down", 3 },
  90 };
  91
  92 /*
  93  * ad7150 register access by I2C
  94  */
  95
  96 static int ad7150_i2c_read(struct ad7150_chip_info *chip, u8 reg, u8 *data, int len)
  97 {
  98         struct i2c_client *client = chip->client;
  99         int ret = 0;
 100
 101         ret = i2c_master_send(client, &reg, 1);
 102         if (ret < 0) {
 103                 dev_err(&client->dev, "I2C write error\n");
 104                 return ret;
 105         }
 106
 107         ret = i2c_master_recv(client, data, len);
 108         if (ret < 0) {
 109                 dev_err(&client->dev, "I2C read error\n");
 110                 return ret;
 111         }
 112
 113         return ret;
 114 }
 115
 116 static int ad7150_i2c_write(struct ad7150_chip_info *chip, u8 reg, u8 data)
 117 {
 118         struct i2c_client *client = chip->client;
 119         int ret = 0;
 120
 121         u8 tx[2] = {
 122                 reg,
 123                 data,
 124         };
 125
 126         ret = i2c_master_send(client, tx, 2);
 127         if (ret < 0)
 128                 dev_err(&client->dev, "I2C write error\n");
 129
 130         return ret;
 131 }
 132
 133 /*
 134  * sysfs nodes
 135  */
 136
 137 #define IIO_DEV_ATTR_AVAIL_CONVERSION_MODES(_show)                              \
 138         IIO_DEVICE_ATTR(available_conversion_modes, S_IRUGO, _show, NULL, 0)
 139 #define IIO_DEV_ATTR_CONVERSION_MODE(_mode, _show, _store)              \
 140         IIO_DEVICE_ATTR(conversion_mode, _mode, _show, _store, 0)
 141 #define IIO_DEV_ATTR_AVAIL_THRESHOLD_MODES(_show)                               \
 142         IIO_DEVICE_ATTR(available_threshold_modes, S_IRUGO, _show, NULL, 0)
 143 #define IIO_DEV_ATTR_THRESHOLD_MODE(_mode, _show, _store)               \
 144         IIO_DEVICE_ATTR(threshold_mode, _mode, _show, _store, 0)
 145 #define IIO_DEV_ATTR_CH1_THRESHOLD(_mode, _show, _store)              \
 146         IIO_DEVICE_ATTR(ch1_threshold, _mode, _show, _store, 0)
 147 #define IIO_DEV_ATTR_CH2_THRESHOLD(_mode, _show, _store)              \
 148         IIO_DEVICE_ATTR(ch2_threshold, _mode, _show, _store, 0)
 149 #define IIO_DEV_ATTR_CH1_SENSITIVITY(_mode, _show, _store)              \
 150         IIO_DEVICE_ATTR(ch1_sensitivity, _mode, _show, _store, 0)
 151 #define IIO_DEV_ATTR_CH2_SENSITIVITY(_mode, _show, _store)              \
 152         IIO_DEVICE_ATTR(ch2_sensitivity, _mode, _show, _store, 0)
 153 #define IIO_DEV_ATTR_CH1_TIMEOUT(_mode, _show, _store)          \
 154         IIO_DEVICE_ATTR(ch1_timeout, _mode, _show, _store, 0)
 155 #define IIO_DEV_ATTR_CH2_TIMEOUT(_mode, _show, _store)          \
 156         IIO_DEVICE_ATTR(ch2_timeout, _mode, _show, _store, 0)
 157 #define IIO_DEV_ATTR_CH1_VALUE(_show)           \
 158         IIO_DEVICE_ATTR(ch1_value, S_IRUGO, _show, NULL, 0)
 159 #define IIO_DEV_ATTR_CH2_VALUE(_show)           \
 160         IIO_DEVICE_ATTR(ch2_value, S_IRUGO, _show, NULL, 0)
 161 #define IIO_DEV_ATTR_CH1_SETUP(_mode, _show, _store)            \
 162         IIO_DEVICE_ATTR(ch1_setup, _mode, _show, _store, 0)
 163 #define IIO_DEV_ATTR_CH2_SETUP(_mode, _show, _store)              \
 164         IIO_DEVICE_ATTR(ch2_setup, _mode, _show, _store, 0)
 165 #define IIO_DEV_ATTR_POWERDOWN_TIMER(_mode, _show, _store)              \
 166         IIO_DEVICE_ATTR(powerdown_timer, _mode, _show, _store, 0)
 167
 168 static ssize_t ad7150_show_conversion_modes(struct device *dev,
 169                 struct device_attribute *attr,
 170                 char *buf)
 171 {
 172         int i;
 173         int len = 0;
 174
 175         for (i = 0; i < AD7150_MAX_CONV_MODE; i++)
 176                 len += sprintf(buf + len, "%s\n", ad7150_conv_mode_table[i].name);
 177
 178         return len;
 179 }
 180
 181 static IIO_DEV_ATTR_AVAIL_CONVERSION_MODES(ad7150_show_conversion_modes);
 182
 183 static ssize_t ad7150_show_conversion_mode(struct device *dev,
 184                 struct device_attribute *attr,
 185                 char *buf)
 186 {
 187         struct iio_dev *dev_info = dev_get_drvdata(dev);
 188         struct ad7150_chip_info *chip = dev_info->dev_data;
 189
 190         return sprintf(buf, "%s\n", chip->conversion_mode);
 191 }
 192
 193 static ssize_t ad7150_store_conversion_mode(struct device *dev,
 194                 struct device_attribute *attr,
 195                 const char *buf,
 196                 size_t len)
 197 {
 198         struct iio_dev *dev_info = dev_get_drvdata(dev);
 199         struct ad7150_chip_info *chip = dev_info->dev_data;
 200         u8 cfg;
 201         int i;
 202
 203         ad7150_i2c_read(chip, AD7150_CFG, &cfg, 1);
 204
 205         for (i = 0; i < AD7150_MAX_CONV_MODE; i++) {
 206                 if (strncmp(buf, ad7150_conv_mode_table[i].name,
 207                                 strlen(ad7150_conv_mode_table[i].name) - 1) == 0) {
 208                         chip->conversion_mode = ad7150_conv_mode_table[i].name;
 209                         cfg |= 0x18 | ad7150_conv_mode_table[i].reg_cfg;
 210                         ad7150_i2c_write(chip, AD7150_CFG, cfg);
 211                         return len;
 212                 }
 213         }
 214
 215         dev_err(dev, "not supported conversion mode\n");
 216
 217         return -EINVAL;
 218 }
 219
 220 static IIO_DEV_ATTR_CONVERSION_MODE(S_IRUGO | S_IWUSR,
 221                 ad7150_show_conversion_mode,
 222                 ad7150_store_conversion_mode);
 223
 224 static ssize_t ad7150_show_threshold_modes(struct device *dev,
 225                 struct device_attribute *attr,
 226                 char *buf)
 227 {
 228         return sprintf(buf, "adaptive\nfixed\n");
 229 }
 230
 231 static IIO_DEV_ATTR_AVAIL_THRESHOLD_MODES(ad7150_show_threshold_modes);
 232
 233 static ssize_t ad7150_show_ch1_value(struct device *dev,
 234                 struct device_attribute *attr,
 235                 char *buf)
 236 {
 237         struct iio_dev *dev_info = dev_get_drvdata(dev);
 238         struct ad7150_chip_info *chip = dev_info->dev_data;
 239         u8 data[2];
 240
 241         ad7150_i2c_read(chip, AD7150_CH1_DATA_HIGH, data, 2);
 242         return sprintf(buf, "%d\n", ((int) data[0] << 8) | data[1]);
 243 }
 244
 245 static IIO_DEV_ATTR_CH1_VALUE(ad7150_show_ch1_value);
 246
 247 static ssize_t ad7150_show_ch2_value(struct device *dev,
 248                 struct device_attribute *attr,
 249                 char *buf)
 250 {
 251         struct iio_dev *dev_info = dev_get_drvdata(dev);
 252         struct ad7150_chip_info *chip = dev_info->dev_data;
 253         u8 data[2];
 254
 255         ad7150_i2c_read(chip, AD7150_CH2_DATA_HIGH, data, 2);
 256         return sprintf(buf, "%d\n", ((int) data[0] << 8) | data[1]);
 257 }
 258
 259 static IIO_DEV_ATTR_CH2_VALUE(ad7150_show_ch2_value);
 260
 261 static ssize_t ad7150_show_threshold_mode(struct device *dev,
 262                 struct device_attribute *attr,
 263                 char *buf)
 264 {
 265         struct iio_dev *dev_info = dev_get_drvdata(dev);
 266         struct ad7150_chip_info *chip = dev_info->dev_data;
 267
 268         return sprintf(buf, "%s\n", chip->threshold_mode);
 269 }
 270
 271 static ssize_t ad7150_store_threshold_mode(struct device *dev,
 272                 struct device_attribute *attr,
 273                 const char *buf,
 274                 size_t len)
 275 {
 276         struct iio_dev *dev_info = dev_get_drvdata(dev);
 277         struct ad7150_chip_info *chip = dev_info->dev_data;
 278         u8 cfg;
 279
 280         ad7150_i2c_read(chip, AD7150_CFG, &cfg, 1);
 281
 282         if (strncmp(buf, "fixed", 5) == 0) {
 283                 strcpy(chip->threshold_mode, "fixed");
 284                 cfg |= AD7150_CFG_FIX;
 285                 ad7150_i2c_write(chip, AD7150_CFG, cfg);
 286
 287                 return len;
 288         } else if (strncmp(buf, "adaptive", 8) == 0) {
 289                 strcpy(chip->threshold_mode, "adaptive");
 290                 cfg &= ~AD7150_CFG_FIX;
 291                 ad7150_i2c_write(chip, AD7150_CFG, cfg);
 292
 293                 return len;
 294         }
 295
 296         dev_err(dev, "not supported threshold mode\n");
 297         return -EINVAL;
 298 }
 299
 300 static IIO_DEV_ATTR_THRESHOLD_MODE(S_IRUGO | S_IWUSR,
 301                 ad7150_show_threshold_mode,
 302                 ad7150_store_threshold_mode);
 303
 304 static ssize_t ad7150_show_ch1_threshold(struct device *dev,
 305                 struct device_attribute *attr,
 306                 char *buf)
 307 {
 308         struct iio_dev *dev_info = dev_get_drvdata(dev);
 309         struct ad7150_chip_info *chip = dev_info->dev_data;
 310
 311         return sprintf(buf, "%d\n", chip->ch1_threshold);
 312 }
 313
 314 static ssize_t ad7150_store_ch1_threshold(struct device *dev,
 315                 struct device_attribute *attr,
 316                 const char *buf,
 317                 size_t len)
 318 {
 319         struct iio_dev *dev_info = dev_get_drvdata(dev);
 320         struct ad7150_chip_info *chip = dev_info->dev_data;
 321         unsigned long data;
 322         int ret;
 323
 324         ret = strict_strtoul(buf, 10, &data);
 325
 326         if ((!ret) && (data < 0x10000)) {
 327                 ad7150_i2c_write(chip, AD7150_CH1_THR_HOLD_H, data >> 8);
 328                 ad7150_i2c_write(chip, AD7150_CH1_THR_HOLD_L, data);
 329                 chip->ch1_threshold = data;
 330                 return len;
 331         }
 332
 333         return -EINVAL;
 334 }
 335
 336 static IIO_DEV_ATTR_CH1_THRESHOLD(S_IRUGO | S_IWUSR,
 337                 ad7150_show_ch1_threshold,
 338                 ad7150_store_ch1_threshold);
 339
 340 static ssize_t ad7150_show_ch2_threshold(struct device *dev,
 341                 struct device_attribute *attr,
 342                 char *buf)
 343 {
 344         struct iio_dev *dev_info = dev_get_drvdata(dev);
 345         struct ad7150_chip_info *chip = dev_info->dev_data;
 346
 347         return sprintf(buf, "%d\n", chip->ch2_threshold);
 348 }
 349
 350 static ssize_t ad7150_store_ch2_threshold(struct device *dev,
 351                 struct device_attribute *attr,
 352                 const char *buf,
 353                 size_t len)
 354 {
 355         struct iio_dev *dev_info = dev_get_drvdata(dev);
 356         struct ad7150_chip_info *chip = dev_info->dev_data;
 357         unsigned long data;
 358         int ret;
 359
 360         ret = strict_strtoul(buf, 10, &data);
 361
 362         if ((!ret) && (data < 0x10000)) {
 363                 ad7150_i2c_write(chip, AD7150_CH2_THR_HOLD_H, data >> 8);
 364                 ad7150_i2c_write(chip, AD7150_CH2_THR_HOLD_L, data);
 365                 chip->ch2_threshold = data;
 366                 return len;
 367         }
 368
 369         return -EINVAL;
 370 }
 371
 372 static IIO_DEV_ATTR_CH2_THRESHOLD(S_IRUGO | S_IWUSR,
 373                 ad7150_show_ch2_threshold,
 374                 ad7150_store_ch2_threshold);
 375
 376 static ssize_t ad7150_show_ch1_sensitivity(struct device *dev,
 377                 struct device_attribute *attr,
 378                 char *buf)
 379 {
 380         struct iio_dev *dev_info = dev_get_drvdata(dev);
 381         struct ad7150_chip_info *chip = dev_info->dev_data;
 382
 383         return sprintf(buf, "%d\n", chip->ch1_sensitivity);
 384 }
 385
 386 static ssize_t ad7150_store_ch1_sensitivity(struct device *dev,
 387                 struct device_attribute *attr,
 388                 const char *buf,
 389                 size_t len)
 390 {
 391         struct iio_dev *dev_info = dev_get_drvdata(dev);
 392         struct ad7150_chip_info *chip = dev_info->dev_data;
 393         unsigned long data;
 394         int ret;
 395
 396         ret = strict_strtoul(buf, 10, &data);
 397
 398         if ((!ret) && (data < 0x100)) {
 399                 ad7150_i2c_write(chip, AD7150_CH1_SENSITIVITY, data);
 400                 chip->ch1_sensitivity = data;
 401                 return len;
 402         }
 403
 404         return -EINVAL;
 405 }
 406
 407 static IIO_DEV_ATTR_CH1_SENSITIVITY(S_IRUGO | S_IWUSR,
 408                 ad7150_show_ch1_sensitivity,
 409                 ad7150_store_ch1_sensitivity);
 410
 411 static ssize_t ad7150_show_ch2_sensitivity(struct device *dev,
 412                 struct device_attribute *attr,
 413                 char *buf)
 414 {
 415         struct iio_dev *dev_info = dev_get_drvdata(dev);
 416         struct ad7150_chip_info *chip = dev_info->dev_data;
 417
 418         return sprintf(buf, "%d\n", chip->ch2_sensitivity);
 419 }
 420
 421 static ssize_t ad7150_store_ch2_sensitivity(struct device *dev,
 422                 struct device_attribute *attr,
 423                 const char *buf,
 424                 size_t len)
 425 {
 426         struct iio_dev *dev_info = dev_get_drvdata(dev);
 427         struct ad7150_chip_info *chip = dev_info->dev_data;
 428         unsigned long data;
 429         int ret;
 430
 431         ret = strict_strtoul(buf, 10, &data);
 432
 433         if ((!ret) && (data < 0x100)) {
 434                 ad7150_i2c_write(chip, AD7150_CH2_SENSITIVITY, data);
 435                 chip->ch2_sensitivity = data;
 436                 return len;
 437         }
 438
 439         return -EINVAL;
 440 }
 441
 442 static IIO_DEV_ATTR_CH2_SENSITIVITY(S_IRUGO | S_IWUSR,
 443                 ad7150_show_ch2_sensitivity,
 444                 ad7150_store_ch2_sensitivity);
 445
 446 static ssize_t ad7150_show_ch1_timeout(struct device *dev,
 447                 struct device_attribute *attr,
 448                 char *buf)
 449 {
 450         struct iio_dev *dev_info = dev_get_drvdata(dev);
 451         struct ad7150_chip_info *chip = dev_info->dev_data;
 452
 453         return sprintf(buf, "%d\n", chip->ch1_timeout);
 454 }
 455
 456 static ssize_t ad7150_store_ch1_timeout(struct device *dev,
 457                 struct device_attribute *attr,
 458                 const char *buf,
 459                 size_t len)
 460 {
 461         struct iio_dev *dev_info = dev_get_drvdata(dev);
 462         struct ad7150_chip_info *chip = dev_info->dev_data;
 463         unsigned long data;
 464         int ret;
 465
 466         ret = strict_strtoul(buf, 10, &data);
 467
 468         if ((!ret) && (data < 0x100)) {
 469                 ad7150_i2c_write(chip, AD7150_CH1_TIMEOUT, data);
 470                 chip->ch1_timeout = data;
 471                 return len;
 472         }
 473
 474         return -EINVAL;
 475 }
 476
 477 static IIO_DEV_ATTR_CH1_TIMEOUT(S_IRUGO | S_IWUSR,
 478                 ad7150_show_ch1_timeout,
 479                 ad7150_store_ch1_timeout);
 480
 481 static ssize_t ad7150_show_ch2_timeout(struct device *dev,
 482                 struct device_attribute *attr,
 483                 char *buf)
 484 {
 485         struct iio_dev *dev_info = dev_get_drvdata(dev);
 486         struct ad7150_chip_info *chip = dev_info->dev_data;
 487
 488         return sprintf(buf, "%d\n", chip->ch2_timeout);
 489 }
 490
 491 static ssize_t ad7150_store_ch2_timeout(struct device *dev,
 492                 struct device_attribute *attr,
 493                 const char *buf,
 494                 size_t len)
 495 {
 496         struct iio_dev *dev_info = dev_get_drvdata(dev);
 497         struct ad7150_chip_info *chip = dev_info->dev_data;
 498         unsigned long data;
 499         int ret;
 500
 501         ret = strict_strtoul(buf, 10, &data);
 502
 503         if ((!ret) && (data < 0x100)) {
 504                 ad7150_i2c_write(chip, AD7150_CH2_TIMEOUT, data);
 505                 chip->ch2_timeout = data;
 506                 return len;
 507         }
 508
 509         return -EINVAL;
 510 }
 511
 512 static IIO_DEV_ATTR_CH2_TIMEOUT(S_IRUGO | S_IWUSR,
 513                 ad7150_show_ch2_timeout,
 514                 ad7150_store_ch2_timeout);
 515
 516 static ssize_t ad7150_show_ch1_setup(struct device *dev,
 517                 struct device_attribute *attr,
 518                 char *buf)
 519 {
 520         struct iio_dev *dev_info = dev_get_drvdata(dev);
 521         struct ad7150_chip_info *chip = dev_info->dev_data;
 522
 523         return sprintf(buf, "0x%02x\n", chip->ch1_setup);
 524 }
 525
 526 static ssize_t ad7150_store_ch1_setup(struct device *dev,
 527                 struct device_attribute *attr,
 528                 const char *buf,
 529                 size_t len)
 530 {
 531         struct iio_dev *dev_info = dev_get_drvdata(dev);
 532         struct ad7150_chip_info *chip = dev_info->dev_data;
 533         unsigned long data;
 534         int ret;
 535
 536         ret = strict_strtoul(buf, 10, &data);
 537
 538         if ((!ret) && (data < 0x100)) {
 539                 ad7150_i2c_write(chip, AD7150_CH1_SETUP, data);
 540                 chip->ch1_setup = data;
 541                 return len;
 542         }
 543
 544
 545         return -EINVAL;
 546 }
 547
 548 static IIO_DEV_ATTR_CH1_SETUP(S_IRUGO | S_IWUSR,
 549                 ad7150_show_ch1_setup,
 550                 ad7150_store_ch1_setup);
 551
 552 static ssize_t ad7150_show_ch2_setup(struct device *dev,
 553                 struct device_attribute *attr,
 554                 char *buf)
 555 {
 556         struct iio_dev *dev_info = dev_get_drvdata(dev);
 557         struct ad7150_chip_info *chip = dev_info->dev_data;
 558
 559         return sprintf(buf, "0x%02x\n", chip->ch2_setup);
 560 }
 561
 562 static ssize_t ad7150_store_ch2_setup(struct device *dev,
 563                 struct device_attribute *attr,
 564                 const char *buf,
 565                 size_t len)
 566 {
 567         struct iio_dev *dev_info = dev_get_drvdata(dev);
 568         struct ad7150_chip_info *chip = dev_info->dev_data;
 569         unsigned long data;
 570         int ret;
 571
 572         ret = strict_strtoul(buf, 10, &data);
 573
 574         if ((!ret) && (data < 0x100)) {
 575                 ad7150_i2c_write(chip, AD7150_CH2_SETUP, data);
 576                 chip->ch2_setup = data;
 577                 return len;
 578         }
 579
 580         return -EINVAL;
 581 }
 582
 583 static IIO_DEV_ATTR_CH2_SETUP(S_IRUGO | S_IWUSR,
 584                 ad7150_show_ch2_setup,
 585                 ad7150_store_ch2_setup);
 586
 587 static ssize_t ad7150_show_name(struct device *dev,
 588                 struct device_attribute *attr,
 589                 char *buf)
 590 {
 591         struct iio_dev *dev_info = dev_get_drvdata(dev);
 592         struct ad7150_chip_info *chip = dev_info->dev_data;
 593         return sprintf(buf, "%s\n", chip->name);
 594 }
 595
 596 static IIO_DEVICE_ATTR(name, S_IRUGO, ad7150_show_name, NULL, 0);
 597
 598 static ssize_t ad7150_show_powerdown_timer(struct device *dev,
 599                 struct device_attribute *attr,
 600                 char *buf)
 601 {
 602         struct iio_dev *dev_info = dev_get_drvdata(dev);
 603         struct ad7150_chip_info *chip = dev_info->dev_data;
 604
 605         return sprintf(buf, "0x%02x\n", chip->powerdown_timer);
 606 }
 607
 608 static ssize_t ad7150_store_powerdown_timer(struct device *dev,
 609                 struct device_attribute *attr,
 610                 const char *buf,
 611                 size_t len)
 612 {
 613         struct iio_dev *dev_info = dev_get_drvdata(dev);
 614         struct ad7150_chip_info *chip = dev_info->dev_data;
 615         unsigned long data;
 616         int ret;
 617
 618         ret = strict_strtoul(buf, 10, &data);
 619
 620         if ((!ret) && (data < 0x40)) {
 621                 chip->powerdown_timer = data;
 622                 return len;
 623         }
 624
 625         return -EINVAL;
 626 }
 627
 628 static IIO_DEV_ATTR_POWERDOWN_TIMER(S_IRUGO | S_IWUSR,
 629                 ad7150_show_powerdown_timer,
 630                 ad7150_store_powerdown_timer);
 631
 632 static struct attribute *ad7150_attributes[] = {
 633         &iio_dev_attr_available_threshold_modes.dev_attr.attr,
 634         &iio_dev_attr_threshold_mode.dev_attr.attr,
 635         &iio_dev_attr_ch1_threshold.dev_attr.attr,
 636         &iio_dev_attr_ch2_threshold.dev_attr.attr,
 637         &iio_dev_attr_ch1_timeout.dev_attr.attr,
 638         &iio_dev_attr_ch2_timeout.dev_attr.attr,
 639         &iio_dev_attr_ch1_setup.dev_attr.attr,
 640         &iio_dev_attr_ch2_setup.dev_attr.attr,
 641         &iio_dev_attr_ch1_sensitivity.dev_attr.attr,
 642         &iio_dev_attr_ch2_sensitivity.dev_attr.attr,
 643         &iio_dev_attr_powerdown_timer.dev_attr.attr,
 644         &iio_dev_attr_ch1_value.dev_attr.attr,
 645         &iio_dev_attr_ch2_value.dev_attr.attr,
 646         &iio_dev_attr_name.dev_attr.attr,
 647         NULL,
 648 };
 649
 650 static const struct attribute_group ad7150_attribute_group = {
 651         .attrs = ad7150_attributes,
 652 };
 653
 654 /*
 655  * threshold events
 656  */
 657
 658 #define IIO_EVENT_CODE_CH1_HIGH    IIO_BUFFER_EVENT_CODE(0)
 659 #define IIO_EVENT_CODE_CH1_LOW     IIO_BUFFER_EVENT_CODE(1)
 660 #define IIO_EVENT_CODE_CH2_HIGH    IIO_BUFFER_EVENT_CODE(2)
 661 #define IIO_EVENT_CODE_CH2_LOW     IIO_BUFFER_EVENT_CODE(3)
 662
 663 static irqreturn_t ad7150_event_handler(int irq, void *private)
 664 {
 665         struct iio_dev *indio_dev = private;
 666         struct ad7150_chip_info *chip = iio_dev_get_devdata(indio_dev);
 667         u8 int_status;
 668         s64 timestamp = iio_get_time_ns();
 669
 670         ad7150_i2c_read(chip, AD7150_STATUS, &int_status, 1);
 671
 672         if ((int_status & AD7150_STATUS_OUT1) && !(chip->old_state & AD7150_STATUS_OUT1))
 673                 iio_push_event(indio_dev, 0,
 674                                 IIO_EVENT_CODE_CH1_HIGH,
 675                                 timestamp);
 676         else if ((!(int_status & AD7150_STATUS_OUT1)) && (chip->old_state & AD7150_STATUS_OUT1))
 677                 iio_push_event(indio_dev, 0,
 678                                 IIO_EVENT_CODE_CH1_LOW,
 679                                 timestamp);
 680
 681         if ((int_status & AD7150_STATUS_OUT2) && !(chip->old_state & AD7150_STATUS_OUT2))
 682                 iio_push_event(indio_dev, 0,
 683                                 IIO_EVENT_CODE_CH2_HIGH,
 684                                 timestamp);
 685         else if ((!(int_status & AD7150_STATUS_OUT2)) && (chip->old_state & AD7150_STATUS_OUT2))
 686                 iio_push_event(indio_dev, 0,
 687                                 IIO_EVENT_CODE_CH2_LOW,
 688                                 timestamp);
 689         return IRQ_HANDLED;
 690 }
 691
 692 static IIO_CONST_ATTR(ch1_high_en, "1");
 693 static IIO_CONST_ATTR(ch2_high_en, "1");
 694 static IIO_CONST_ATTR(ch1_low_en, "1");
 695 static IIO_CONST_ATTR(ch2_low_en, "1");
 696
 697 static struct attribute *ad7150_event_attributes[] = {
 698         &iio_const_attr_ch1_high_en.dev_attr.attr,
 699         &iio_const_attr_ch2_high_en.dev_attr.attr,
 700         &iio_const_attr_ch1_low_en.dev_attr.attr,
 701         &iio_const_attr_ch2_low_en.dev_attr.attr,
 702         NULL,
 703 };
 704
 705 static struct attribute_group ad7150_event_attribute_group = {
 706         .attrs = ad7150_event_attributes,
 707 };
 708
 709 /*
 710  * device probe and remove
 711  */
 712
 713 static int __devinit ad7150_probe(struct i2c_client *client,
 714                 const struct i2c_device_id *id)
 715 {
 716         int ret = 0, regdone = 0;
 717         struct ad7150_chip_info *chip = kzalloc(sizeof(*chip), GFP_KERNEL);
 718         if (chip == NULL) {
 719                 ret = -ENOMEM;
 720                 goto error_ret;
 721         }
 722
 723         /* this is only used for device removal purposes */
 724         i2c_set_clientdata(client, chip);
 725
 726         chip->client = client;
 727         chip->name = id->name;
 728
 729         chip->indio_dev = iio_allocate_device(0);
 730         if (chip->indio_dev == NULL) {
 731                 ret = -ENOMEM;
 732                 goto error_free_chip;
 733         }
 734
 735         /* Echipabilish that the iio_dev is a child of the i2c device */
 736         chip->indio_dev->dev.parent = &client->dev;
 737         chip->indio_dev->attrs = &ad7150_attribute_group;
 738         chip->indio_dev->event_attrs = &ad7150_event_attribute_group;
 739         chip->indio_dev->dev_data = (void *)(chip);
 740         chip->indio_dev->driver_module = THIS_MODULE;
 741         chip->indio_dev->num_interrupt_lines = 1;
 742         chip->indio_dev->modes = INDIO_DIRECT_MODE;
 743
 744         ret = iio_device_register(chip->indio_dev);
 745         if (ret)
 746                 goto error_free_dev;
 747         regdone = 1;
 748
 749         if (client->irq) {
 750                 ret = request_threaded_irq(client->irq,
 751                                            NULL,
 752                                            &ad7150_event_handler,
 753                                            IRQF_TRIGGER_RISING |
 754                                            IRQF_TRIGGER_FALLING,
 755                                            "ad7150",
 756                                            chip->indio_dev);
 757                 if (ret)
 758                         goto error_free_dev;
 759         }
 760
 761         dev_err(&client->dev, "%s capacitive sensor registered, irq: %d\n", id->name, client->irq);
 762
 763         return 0;
 764
 765 error_free_dev:
 766         if (regdone)
 767                 iio_device_unregister(chip->indio_dev);
 768         else
 769                 iio_free_device(chip->indio_dev);
 770 error_free_chip:
 771         kfree(chip);
 772 error_ret:
 773         return ret;
 774 }
 775
 776 static int __devexit ad7150_remove(struct i2c_client *client)
 777 {
 778         struct ad7150_chip_info *chip = i2c_get_clientdata(client);
 779         struct iio_dev *indio_dev = chip->indio_dev;
 780
 781         if (client->irq)
 782                 free_irq(client->irq, indio_dev);
 783         iio_device_unregister(indio_dev);
 784         kfree(chip);
 785
 786         return 0;
 787 }
 788
 789 static const struct i2c_device_id ad7150_id[] = {
 790         { "ad7150", 0 },
 791         { "ad7151", 0 },
 792         { "ad7156", 0 },
 793         {}
 794 };
 795
 796 MODULE_DEVICE_TABLE(i2c, ad7150_id);
 797
 798 static struct i2c_driver ad7150_driver = {
 799         .driver = {
 800                 .name = "ad7150",
 801         },
 802         .probe = ad7150_probe,
 803         .remove = __devexit_p(ad7150_remove),
 804         .id_table = ad7150_id,
 805 };
 806
 807 static __init int ad7150_init(void)
 808 {
 809         return i2c_add_driver(&ad7150_driver);
 810 }
 811
 812 static __exit void ad7150_exit(void)
 813 {
 814         i2c_del_driver(&ad7150_driver);
 815 }
 816
 817 MODULE_AUTHOR("Barry Song <21cnbao@gmail.com>");
 818 MODULE_DESCRIPTION("Analog Devices ad7150/1/6 capacitive sensor driver");
 819 MODULE_LICENSE("GPL v2");
 820
 821 module_init(ad7150_init);
 822 module_exit(ad7150_exit);