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 #include <linux/module.h>
  15
  16 #include "../iio.h"
  17 #include "../sysfs.h"
  18
  19 /*
  20  * AD7150 registers definition
  21  */
  22
  23 #define AD7150_STATUS              0
  24 #define AD7150_STATUS_OUT1         (1 << 3)
  25 #define AD7150_STATUS_OUT2         (1 << 5)
  26 #define AD7150_CH1_DATA_HIGH       1
  27 #define AD7150_CH2_DATA_HIGH       3
  28 #define AD7150_CH1_AVG_HIGH        5
  29 #define AD7150_CH2_AVG_HIGH        7
  30 #define AD7150_CH1_SENSITIVITY     9
  31 #define AD7150_CH1_THR_HOLD_H      9
  32 #define AD7150_CH1_TIMEOUT         10
  33 #define AD7150_CH1_SETUP           11
  34 #define AD7150_CH2_SENSITIVITY     12
  35 #define AD7150_CH2_THR_HOLD_H      12
  36 #define AD7150_CH2_TIMEOUT         13
  37 #define AD7150_CH2_SETUP           14
  38 #define AD7150_CFG                 15
  39 #define AD7150_CFG_FIX             (1 << 7)
  40 #define AD7150_PD_TIMER            16
  41 #define AD7150_CH1_CAPDAC          17
  42 #define AD7150_CH2_CAPDAC          18
  43 #define AD7150_SN3                 19
  44 #define AD7150_SN2                 20
  45 #define AD7150_SN1                 21
  46 #define AD7150_SN0                 22
  47 #define AD7150_ID                  23
  48
  49 #define AD7150_MAX_CONV_MODE       4
  50
  51 /**
  52  * Todo list:
  53  * - Review whether old_state usage makes sense.
  54  * - get rid of explicit control of conversion mode
  55  */
  56
  57 /**
  58  * struct ad7150_chip_info - instance specific chip data
  59  * @client: i2c client for this device
  60  * @current_event: device always has one type of event enabled.
  61  *      This element stores the event code of the current one.
  62  * @threshold: thresholds for simple capacitance value events
  63  * @thresh_sensitivity: threshold for simple capacitance offset
  64  *      from 'average' value.
  65  * @mag_sensitity: threshold for magnitude of capacitance offset from
  66  *      from 'average' value.
  67  * @thresh_timeout: a timeout, in samples from the moment an
  68  *      adaptive threshold event occurs to when the average
  69  *      value jumps to current value.
  70  * @mag_timeout: a timeout, in sample from the moment an
  71  *      adaptive magnitude event occurs to when the average
  72  *      value jumps to the current value.
  73  * @old_state: store state from previous event, allowing confirmation
  74  *      of new condition.
  75  * @conversion_mode: the current conversion mode.
  76  * @state_lock: ensure consistent state of this structure wrt the
  77  *      hardware.
  78  */
  79 struct ad7150_chip_info {
  80         struct i2c_client *client;
  81         u64 current_event;
  82         u16 threshold[2][2];
  83         u8 thresh_sensitivity[2][2];
  84         u8 mag_sensitivity[2][2];
  85         u8 thresh_timeout[2][2];
  86         u8 mag_timeout[2][2];
  87         int old_state;
  88         char *conversion_mode;
  89         struct mutex state_lock;
  90 };
  91
  92 /*
  93  * sysfs nodes
  94  */
  95
  96 static const u8 ad7150_addresses[][6] = {
  97         { AD7150_CH1_DATA_HIGH, AD7150_CH1_AVG_HIGH,
  98           AD7150_CH1_SETUP, AD7150_CH1_THR_HOLD_H,
  99           AD7150_CH1_SENSITIVITY, AD7150_CH1_TIMEOUT },
 100         { AD7150_CH2_DATA_HIGH, AD7150_CH2_AVG_HIGH,
 101           AD7150_CH2_SETUP, AD7150_CH2_THR_HOLD_H,
 102           AD7150_CH2_SENSITIVITY, AD7150_CH2_TIMEOUT },
 103 };
 104
 105 static int ad7150_read_raw(struct iio_dev *indio_dev,
 106                            struct iio_chan_spec const *chan,
 107                            int *val,
 108                            int *val2,
 109                            long mask)
 110 {
 111         int ret;
 112         struct ad7150_chip_info *chip = iio_priv(indio_dev);
 113
 114         switch (mask) {
 115         case 0:
 116                 ret = i2c_smbus_read_word_data(chip->client,
 117                                         ad7150_addresses[chan->channel][0]);
 118                 if (ret < 0)
 119                         return ret;
 120                 *val = swab16(ret);
 121                 return IIO_VAL_INT;
 122         case (1 << IIO_CHAN_INFO_AVERAGE_RAW_SEPARATE):
 123                 ret = i2c_smbus_read_word_data(chip->client,
 124                                         ad7150_addresses[chan->channel][1]);
 125                 if (ret < 0)
 126                         return ret;
 127                 *val = swab16(ret);
 128                 return IIO_VAL_INT;
 129         default:
 130                 return -EINVAL;
 131         }
 132 }
 133
 134 static int ad7150_read_event_config(struct iio_dev *indio_dev, u64 event_code)
 135 {
 136         int ret;
 137         u8 threshtype;
 138         bool adaptive;
 139         struct ad7150_chip_info *chip = iio_priv(indio_dev);
 140         int rising = !!(IIO_EVENT_CODE_EXTRACT_DIR(event_code) ==
 141                         IIO_EV_DIR_RISING);
 142
 143         ret = i2c_smbus_read_byte_data(chip->client, AD7150_CFG);
 144         if (ret < 0)
 145                 return ret;
 146
 147         threshtype = (ret >> 5) & 0x03;
 148         adaptive = !!(ret & 0x80);
 149
 150         switch (IIO_EVENT_CODE_EXTRACT_TYPE(event_code)) {
 151         case IIO_EV_TYPE_MAG_ADAPTIVE:
 152                 if (rising)
 153                         return adaptive && (threshtype == 0x1);
 154                 else
 155                         return adaptive && (threshtype == 0x0);
 156         case IIO_EV_TYPE_THRESH_ADAPTIVE:
 157                 if (rising)
 158                         return adaptive && (threshtype == 0x3);
 159                 else
 160                         return adaptive && (threshtype == 0x2);
 161
 162         case IIO_EV_TYPE_THRESH:
 163                 if (rising)
 164                         return !adaptive && (threshtype == 0x1);
 165                 else
 166                         return !adaptive && (threshtype == 0x0);
 167         };
 168         return -EINVAL;
 169 }
 170
 171 /* lock should be held */
 172 static int ad7150_write_event_params(struct iio_dev *indio_dev, u64 event_code)
 173 {
 174         int ret;
 175         u16 value;
 176         u8 sens, timeout;
 177         struct ad7150_chip_info *chip = iio_priv(indio_dev);
 178         int chan = IIO_EVENT_CODE_EXTRACT_NUM(event_code);
 179         int rising = !!(IIO_EVENT_CODE_EXTRACT_DIR(event_code) ==
 180                         IIO_EV_DIR_RISING);
 181
 182         if (event_code != chip->current_event)
 183                 return 0;
 184
 185         switch (IIO_EVENT_CODE_EXTRACT_TYPE(event_code)) {
 186                 /* Note completely different from the adaptive versions */
 187         case IIO_EV_TYPE_THRESH:
 188                 value = chip->threshold[rising][chan];
 189                 ret = i2c_smbus_write_word_data(chip->client,
 190                                                 ad7150_addresses[chan][3],
 191                                                 swab16(value));
 192                 if (ret < 0)
 193                         return ret;
 194                 return 0;
 195         case IIO_EV_TYPE_MAG_ADAPTIVE:
 196                 sens = chip->mag_sensitivity[rising][chan];
 197                 timeout = chip->mag_timeout[rising][chan];
 198                 break;
 199         case IIO_EV_TYPE_THRESH_ADAPTIVE:
 200                 sens = chip->thresh_sensitivity[rising][chan];
 201                 timeout = chip->thresh_timeout[rising][chan];
 202                 break;
 203         default:
 204                 return -EINVAL;
 205         };
 206         ret = i2c_smbus_write_byte_data(chip->client,
 207                                         ad7150_addresses[chan][4],
 208                                         sens);
 209         if (ret < 0)
 210                 return ret;
 211
 212         ret = i2c_smbus_write_byte_data(chip->client,
 213                                         ad7150_addresses[chan][5],
 214                                         timeout);
 215         if (ret < 0)
 216                 return ret;
 217
 218         return 0;
 219 }
 220
 221 static int ad7150_write_event_config(struct iio_dev *indio_dev,
 222                                      u64 event_code, int state)
 223 {
 224         u8 thresh_type, cfg, adaptive;
 225         int ret;
 226         struct ad7150_chip_info *chip = iio_priv(indio_dev);
 227         int rising = !!(IIO_EVENT_CODE_EXTRACT_DIR(event_code) ==
 228                         IIO_EV_DIR_RISING);
 229
 230         /* Something must always be turned on */
 231         if (state == 0)
 232                 return -EINVAL;
 233
 234         if (event_code == chip->current_event)
 235                 return 0;
 236         mutex_lock(&chip->state_lock);
 237         ret = i2c_smbus_read_byte_data(chip->client, AD7150_CFG);
 238         if (ret < 0)
 239                 goto error_ret;
 240
 241         cfg = ret & ~((0x03 << 5) | (0x1 << 7));
 242
 243         switch (IIO_EVENT_CODE_EXTRACT_TYPE(event_code)) {
 244         case IIO_EV_TYPE_MAG_ADAPTIVE:
 245                 adaptive = 1;
 246                 if (rising)
 247                         thresh_type = 0x1;
 248                 else
 249                         thresh_type = 0x0;
 250                 break;
 251         case IIO_EV_TYPE_THRESH_ADAPTIVE:
 252                 adaptive = 1;
 253                 if (rising)
 254                         thresh_type = 0x3;
 255                 else
 256                         thresh_type = 0x2;
 257                 break;
 258         case IIO_EV_TYPE_THRESH:
 259                 adaptive = 0;
 260                 if (rising)
 261                         thresh_type = 0x1;
 262                 else
 263                         thresh_type = 0x0;
 264                 break;
 265         default:
 266                 ret = -EINVAL;
 267                 goto error_ret;
 268         };
 269
 270         cfg |= (!adaptive << 7) | (thresh_type << 5);
 271
 272         ret = i2c_smbus_write_byte_data(chip->client, AD7150_CFG, cfg);
 273         if (ret < 0)
 274                 goto error_ret;
 275
 276         chip->current_event = event_code;
 277
 278         /* update control attributes */
 279         ret = ad7150_write_event_params(indio_dev, event_code);
 280 error_ret:
 281         mutex_unlock(&chip->state_lock);
 282
 283         return 0;
 284 }
 285
 286 static int ad7150_read_event_value(struct iio_dev *indio_dev,
 287                                    u64 event_code,
 288                                    int *val)
 289 {
 290         int chan = IIO_EVENT_CODE_EXTRACT_NUM(event_code);
 291         struct ad7150_chip_info *chip = iio_priv(indio_dev);
 292         int rising = !!(IIO_EVENT_CODE_EXTRACT_DIR(event_code) ==
 293                         IIO_EV_DIR_RISING);
 294
 295         /* Complex register sharing going on here */
 296         switch (IIO_EVENT_CODE_EXTRACT_TYPE(event_code)) {
 297         case IIO_EV_TYPE_MAG_ADAPTIVE:
 298                 *val = chip->mag_sensitivity[rising][chan];
 299                 return 0;
 300
 301         case IIO_EV_TYPE_THRESH_ADAPTIVE:
 302                 *val = chip->thresh_sensitivity[rising][chan];
 303                 return 0;
 304
 305         case IIO_EV_TYPE_THRESH:
 306                 *val = chip->threshold[rising][chan];
 307                 return 0;
 308
 309         default:
 310                 return -EINVAL;
 311         };
 312 }
 313
 314 static int ad7150_write_event_value(struct iio_dev *indio_dev,
 315                                    u64 event_code,
 316                                    int val)
 317 {
 318         int ret;
 319         struct ad7150_chip_info *chip = iio_priv(indio_dev);
 320         int chan = IIO_EVENT_CODE_EXTRACT_NUM(event_code);
 321         int rising = !!(IIO_EVENT_CODE_EXTRACT_DIR(event_code) ==
 322                         IIO_EV_DIR_RISING);
 323
 324         mutex_lock(&chip->state_lock);
 325         switch (IIO_EVENT_CODE_EXTRACT_TYPE(event_code)) {
 326         case IIO_EV_TYPE_MAG_ADAPTIVE:
 327                 chip->mag_sensitivity[rising][chan] = val;
 328                 break;
 329         case IIO_EV_TYPE_THRESH_ADAPTIVE:
 330                 chip->thresh_sensitivity[rising][chan] = val;
 331                 break;
 332         case IIO_EV_TYPE_THRESH:
 333                 chip->threshold[rising][chan] = val;
 334                 break;
 335         default:
 336                 ret = -EINVAL;
 337                 goto error_ret;
 338         };
 339
 340         /* write back if active */
 341         ret = ad7150_write_event_params(indio_dev, event_code);
 342
 343         mutex_unlock(&chip->state_lock);
 344 error_ret:
 345         return ret;
 346 }
 347
 348 static ssize_t ad7150_show_timeout(struct device *dev,
 349                                    struct device_attribute *attr,
 350                                    char *buf)
 351 {
 352         struct iio_dev *dev_info = dev_get_drvdata(dev);
 353         struct ad7150_chip_info *chip = iio_priv(dev_info);
 354         struct iio_dev_attr *this_attr = to_iio_dev_attr(attr);
 355         u8 value;
 356
 357         /* use the event code for consistency reasons */
 358         int chan = IIO_EVENT_CODE_EXTRACT_NUM(this_attr->address);
 359         int rising = !!(IIO_EVENT_CODE_EXTRACT_DIR(this_attr->address)
 360                         == IIO_EV_DIR_RISING);
 361
 362         switch (IIO_EVENT_CODE_EXTRACT_TYPE(this_attr->address)) {
 363         case IIO_EV_TYPE_MAG_ADAPTIVE:
 364                 value = chip->mag_timeout[rising][chan];
 365                 break;
 366         case IIO_EV_TYPE_THRESH_ADAPTIVE:
 367                 value = chip->thresh_timeout[rising][chan];
 368                 break;
 369         default:
 370                 return -EINVAL;
 371         };
 372
 373         return sprintf(buf, "%d\n", value);
 374 }
 375
 376 static ssize_t ad7150_store_timeout(struct device *dev,
 377                 struct device_attribute *attr,
 378                 const char *buf,
 379                 size_t len)
 380 {
 381         struct iio_dev *indio_dev = dev_get_drvdata(dev);
 382         struct ad7150_chip_info *chip = iio_priv(indio_dev);
 383         struct iio_dev_attr *this_attr = to_iio_dev_attr(attr);
 384         int chan = IIO_EVENT_CODE_EXTRACT_NUM(this_attr->address);
 385         int rising = !!(IIO_EVENT_CODE_EXTRACT_DIR(this_attr->address) ==
 386                         IIO_EV_DIR_RISING);
 387         u8 data;
 388         int ret;
 389
 390         ret = kstrtou8(buf, 10, &data);
 391         if (ret < 0)
 392                 return ret;
 393
 394         mutex_lock(&chip->state_lock);
 395         switch (IIO_EVENT_CODE_EXTRACT_TYPE(this_attr->address)) {
 396         case IIO_EV_TYPE_MAG_ADAPTIVE:
 397                 chip->mag_timeout[rising][chan] = data;
 398                 break;
 399         case IIO_EV_TYPE_THRESH_ADAPTIVE:
 400                 chip->thresh_timeout[rising][chan] = data;
 401                 break;
 402         default:
 403                 ret = -EINVAL;
 404                 goto error_ret;
 405         };
 406
 407         ret = ad7150_write_event_params(indio_dev, this_attr->address);
 408 error_ret:
 409         mutex_unlock(&chip->state_lock);
 410
 411         if (ret < 0)
 412                 return ret;
 413
 414         return len;
 415 }
 416
 417 #define AD7150_TIMEOUT(chan, type, dir, ev_type, ev_dir)                \
 418         IIO_DEVICE_ATTR(in_capacitance##chan##_##type##_##dir##_timeout, \
 419                 S_IRUGO | S_IWUSR,                                      \
 420                 &ad7150_show_timeout,                                   \
 421                 &ad7150_store_timeout,                                  \
 422                 IIO_UNMOD_EVENT_CODE(IIO_CAPACITANCE,                   \
 423                                      chan,                              \
 424                                      IIO_EV_TYPE_##ev_type,             \
 425                                      IIO_EV_DIR_##ev_dir))
 426 static AD7150_TIMEOUT(0, mag_adaptive, rising, MAG_ADAPTIVE, RISING);
 427 static AD7150_TIMEOUT(0, mag_adaptive, falling, MAG_ADAPTIVE, FALLING);
 428 static AD7150_TIMEOUT(1, mag_adaptive, rising, MAG_ADAPTIVE, RISING);
 429 static AD7150_TIMEOUT(1, mag_adaptive, falling, MAG_ADAPTIVE, FALLING);
 430 static AD7150_TIMEOUT(0, thresh_adaptive, rising, THRESH_ADAPTIVE, RISING);
 431 static AD7150_TIMEOUT(0, thresh_adaptive, falling, THRESH_ADAPTIVE, FALLING);
 432 static AD7150_TIMEOUT(1, thresh_adaptive, rising, THRESH_ADAPTIVE, RISING);
 433 static AD7150_TIMEOUT(1, thresh_adaptive, falling, THRESH_ADAPTIVE, FALLING);
 434
 435 static const struct iio_chan_spec ad7150_channels[] = {
 436         {
 437                 .type = IIO_CAPACITANCE,
 438                 .indexed = 1,
 439                 .channel = 0,
 440                 .info_mask = (1 << IIO_CHAN_INFO_AVERAGE_RAW_SEPARATE),
 441                 .event_mask =
 442                 IIO_EV_BIT(IIO_EV_TYPE_THRESH, IIO_EV_DIR_RISING) |
 443                 IIO_EV_BIT(IIO_EV_TYPE_THRESH, IIO_EV_DIR_FALLING) |
 444                 IIO_EV_BIT(IIO_EV_TYPE_THRESH_ADAPTIVE, IIO_EV_DIR_RISING) |
 445                 IIO_EV_BIT(IIO_EV_TYPE_THRESH_ADAPTIVE, IIO_EV_DIR_FALLING) |
 446                 IIO_EV_BIT(IIO_EV_TYPE_MAG_ADAPTIVE, IIO_EV_DIR_RISING) |
 447                 IIO_EV_BIT(IIO_EV_TYPE_MAG_ADAPTIVE, IIO_EV_DIR_FALLING)
 448         }, {
 449                 .type = IIO_CAPACITANCE,
 450                 .indexed = 1,
 451                 .channel = 1,
 452                 .info_mask = (1 << IIO_CHAN_INFO_AVERAGE_RAW_SEPARATE),
 453                 .event_mask =
 454                 IIO_EV_BIT(IIO_EV_TYPE_THRESH, IIO_EV_DIR_RISING) |
 455                 IIO_EV_BIT(IIO_EV_TYPE_THRESH, IIO_EV_DIR_FALLING) |
 456                 IIO_EV_BIT(IIO_EV_TYPE_THRESH_ADAPTIVE, IIO_EV_DIR_RISING) |
 457                 IIO_EV_BIT(IIO_EV_TYPE_THRESH_ADAPTIVE, IIO_EV_DIR_FALLING) |
 458                 IIO_EV_BIT(IIO_EV_TYPE_MAG_ADAPTIVE, IIO_EV_DIR_RISING) |
 459                 IIO_EV_BIT(IIO_EV_TYPE_MAG_ADAPTIVE, IIO_EV_DIR_FALLING)
 460         },
 461 };
 462
 463 /*
 464  * threshold events
 465  */
 466
 467 static irqreturn_t ad7150_event_handler(int irq, void *private)
 468 {
 469         struct iio_dev *indio_dev = private;
 470         struct ad7150_chip_info *chip = iio_priv(indio_dev);
 471         u8 int_status;
 472         s64 timestamp = iio_get_time_ns();
 473         int ret;
 474
 475         ret = i2c_smbus_read_byte_data(chip->client, AD7150_STATUS);
 476         if (ret < 0)
 477                 return IRQ_HANDLED;
 478
 479         int_status = ret;
 480
 481         if ((int_status & AD7150_STATUS_OUT1) &&
 482             !(chip->old_state & AD7150_STATUS_OUT1))
 483                 iio_push_event(indio_dev,
 484                                IIO_UNMOD_EVENT_CODE(IIO_IN,
 485                                                     0,
 486                                                     IIO_EV_TYPE_THRESH,
 487                                                     IIO_EV_DIR_RISING),
 488                                 timestamp);
 489         else if ((!(int_status & AD7150_STATUS_OUT1)) &&
 490                  (chip->old_state & AD7150_STATUS_OUT1))
 491                 iio_push_event(indio_dev,
 492                                IIO_UNMOD_EVENT_CODE(IIO_IN,
 493                                                     0,
 494                                                     IIO_EV_TYPE_THRESH,
 495                                                     IIO_EV_DIR_FALLING),
 496                                timestamp);
 497
 498         if ((int_status & AD7150_STATUS_OUT2) &&
 499             !(chip->old_state & AD7150_STATUS_OUT2))
 500                 iio_push_event(indio_dev,
 501                                IIO_UNMOD_EVENT_CODE(IIO_IN,
 502                                                     1,
 503                                                     IIO_EV_TYPE_THRESH,
 504                                                     IIO_EV_DIR_RISING),
 505                                timestamp);
 506         else if ((!(int_status & AD7150_STATUS_OUT2)) &&
 507                  (chip->old_state & AD7150_STATUS_OUT2))
 508                 iio_push_event(indio_dev,
 509                                IIO_UNMOD_EVENT_CODE(IIO_IN,
 510                                                     1,
 511                                                     IIO_EV_TYPE_THRESH,
 512                                                     IIO_EV_DIR_FALLING),
 513                                timestamp);
 514         /* store the status to avoid repushing same events */
 515         chip->old_state = int_status;
 516
 517         return IRQ_HANDLED;
 518 }
 519
 520 /* Timeouts not currently handled by core */
 521 static struct attribute *ad7150_event_attributes[] = {
 522         &iio_dev_attr_in_capacitance0_mag_adaptive_rising_timeout
 523         .dev_attr.attr,
 524         &iio_dev_attr_in_capacitance0_mag_adaptive_falling_timeout
 525         .dev_attr.attr,
 526         &iio_dev_attr_in_capacitance1_mag_adaptive_rising_timeout
 527         .dev_attr.attr,
 528         &iio_dev_attr_in_capacitance1_mag_adaptive_falling_timeout
 529         .dev_attr.attr,
 530         &iio_dev_attr_in_capacitance0_thresh_adaptive_rising_timeout
 531         .dev_attr.attr,
 532         &iio_dev_attr_in_capacitance0_thresh_adaptive_falling_timeout
 533         .dev_attr.attr,
 534         &iio_dev_attr_in_capacitance1_thresh_adaptive_rising_timeout
 535         .dev_attr.attr,
 536         &iio_dev_attr_in_capacitance1_thresh_adaptive_falling_timeout
 537         .dev_attr.attr,
 538         NULL,
 539 };
 540
 541 static struct attribute_group ad7150_event_attribute_group = {
 542         .attrs = ad7150_event_attributes,
 543         .name = "events",
 544 };
 545
 546 static const struct iio_info ad7150_info = {
 547         .event_attrs = &ad7150_event_attribute_group,
 548         .driver_module = THIS_MODULE,
 549         .read_raw = &ad7150_read_raw,
 550         .read_event_config = &ad7150_read_event_config,
 551         .write_event_config = &ad7150_write_event_config,
 552         .read_event_value = &ad7150_read_event_value,
 553         .write_event_value = &ad7150_write_event_value,
 554 };
 555
 556 /*
 557  * device probe and remove
 558  */
 559
 560 static int __devinit ad7150_probe(struct i2c_client *client,
 561                 const struct i2c_device_id *id)
 562 {
 563         int ret;
 564         struct ad7150_chip_info *chip;
 565         struct iio_dev *indio_dev;
 566
 567         indio_dev = iio_allocate_device(sizeof(*chip));
 568         if (indio_dev == NULL) {
 569                 ret = -ENOMEM;
 570                 goto error_ret;
 571         }
 572         chip = iio_priv(indio_dev);
 573         mutex_init(&chip->state_lock);
 574         /* this is only used for device removal purposes */
 575         i2c_set_clientdata(client, indio_dev);
 576
 577         chip->client = client;
 578
 579         indio_dev->name = id->name;
 580         indio_dev->channels = ad7150_channels;
 581         indio_dev->num_channels = ARRAY_SIZE(ad7150_channels);
 582         /* Establish that the iio_dev is a child of the i2c device */
 583         indio_dev->dev.parent = &client->dev;
 584
 585         indio_dev->info = &ad7150_info;
 586
 587         indio_dev->modes = INDIO_DIRECT_MODE;
 588
 589         if (client->irq) {
 590                 ret = request_threaded_irq(client->irq,
 591                                            NULL,
 592                                            &ad7150_event_handler,
 593                                            IRQF_TRIGGER_RISING |
 594                                            IRQF_TRIGGER_FALLING,
 595                                            "ad7150",
 596                                            indio_dev);
 597                 if (ret)
 598                         goto error_free_dev;
 599         }
 600
 601         ret = iio_device_register(indio_dev);
 602         if (ret)
 603                 goto error_free_irq;
 604
 605         dev_info(&client->dev, "%s capacitive sensor registered,irq: %d\n",
 606                  id->name, client->irq);
 607
 608         return 0;
 609 error_free_irq:
 610         if (client->irq)
 611                 free_irq(client->irq, indio_dev);
 612
 613 error_free_dev:
 614         iio_free_device(indio_dev);
 615 error_ret:
 616         return ret;
 617 }
 618
 619 static int __devexit ad7150_remove(struct i2c_client *client)
 620 {
 621         struct iio_dev *indio_dev = i2c_get_clientdata(client);
 622
 623         if (client->irq)
 624                 free_irq(client->irq, indio_dev);
 625         iio_device_unregister(indio_dev);
 626
 627         return 0;
 628 }
 629
 630 static const struct i2c_device_id ad7150_id[] = {
 631         { "ad7150", 0 },
 632         { "ad7151", 0 },
 633         { "ad7156", 0 },
 634         {}
 635 };
 636
 637 MODULE_DEVICE_TABLE(i2c, ad7150_id);
 638
 639 static struct i2c_driver ad7150_driver = {
 640         .driver = {
 641                 .name = "ad7150",
 642         },
 643         .probe = ad7150_probe,
 644         .remove = __devexit_p(ad7150_remove),
 645         .id_table = ad7150_id,
 646 };
 647
 648 static __init int ad7150_init(void)
 649 {
 650         return i2c_add_driver(&ad7150_driver);
 651 }
 652
 653 static __exit void ad7150_exit(void)
 654 {
 655         i2c_del_driver(&ad7150_driver);
 656 }
 657
 658 MODULE_AUTHOR("Barry Song <21cnbao@gmail.com>");
 659 MODULE_DESCRIPTION("Analog Devices ad7150/1/6 capacitive sensor driver");
 660 MODULE_LICENSE("GPL v2");
 661
 662 module_init(ad7150_init);
 663 module_exit(ad7150_exit);