drivers/staging/iio/cdc/ad7152.c

   1 /*
   2  * AD7152 capacitive sensor driver supporting AD7152/3
   3  *
   4  * Copyright 2010-2011a 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/sysfs.h>
  14 #include <linux/i2c.h>
  15 #include <linux/module.h>
  16 #include <linux/delay.h>
  17
  18 #include <linux/iio/iio.h>
  19 #include <linux/iio/sysfs.h>
  20
  21 /*
  22  * TODO: Check compliance of calibbias with abi (units)
  23  */
  24 /*
  25  * AD7152 registers definition
  26  */
  27
  28 #define AD7152_REG_STATUS               0
  29 #define AD7152_REG_CH1_DATA_HIGH        1
  30 #define AD7152_REG_CH2_DATA_HIGH        3
  31 #define AD7152_REG_CH1_OFFS_HIGH        5
  32 #define AD7152_REG_CH2_OFFS_HIGH        7
  33 #define AD7152_REG_CH1_GAIN_HIGH        9
  34 #define AD7152_REG_CH1_SETUP            11
  35 #define AD7152_REG_CH2_GAIN_HIGH        12
  36 #define AD7152_REG_CH2_SETUP            14
  37 #define AD7152_REG_CFG                  15
  38 #define AD7152_REG_RESEVERD             16
  39 #define AD7152_REG_CAPDAC_POS           17
  40 #define AD7152_REG_CAPDAC_NEG           18
  41 #define AD7152_REG_CFG2                 26
  42
  43 /* Status Register Bit Designations (AD7152_REG_STATUS) */
  44 #define AD7152_STATUS_RDY1              BIT(0)
  45 #define AD7152_STATUS_RDY2              BIT(1)
  46 #define AD7152_STATUS_C1C2              BIT(2)
  47 #define AD7152_STATUS_PWDN              BIT(7)
  48
  49 /* Setup Register Bit Designations (AD7152_REG_CHx_SETUP) */
  50 #define AD7152_SETUP_CAPDIFF            (1 << 5)
  51 #define AD7152_SETUP_RANGE_2pF          (0 << 6)
  52 #define AD7152_SETUP_RANGE_0_5pF        (1 << 6)
  53 #define AD7152_SETUP_RANGE_1pF          (2 << 6)
  54 #define AD7152_SETUP_RANGE_4pF          (3 << 6)
  55 #define AD7152_SETUP_RANGE(x)           ((x) << 6)
  56
  57 /* Config Register Bit Designations (AD7152_REG_CFG) */
  58 #define AD7152_CONF_CH2EN               (1 << 3)
  59 #define AD7152_CONF_CH1EN               (1 << 4)
  60 #define AD7152_CONF_MODE_IDLE           (0 << 0)
  61 #define AD7152_CONF_MODE_CONT_CONV      (1 << 0)
  62 #define AD7152_CONF_MODE_SINGLE_CONV    (2 << 0)
  63 #define AD7152_CONF_MODE_OFFS_CAL       (5 << 0)
  64 #define AD7152_CONF_MODE_GAIN_CAL       (6 << 0)
  65
  66 /* Capdac Register Bit Designations (AD7152_REG_CAPDAC_XXX) */
  67 #define AD7152_CAPDAC_DACEN             (1 << 7)
  68 #define AD7152_CAPDAC_DACP(x)           ((x) & 0x1F)
  69
  70 /* CFG2 Register Bit Designations (AD7152_REG_CFG2) */
  71 #define AD7152_CFG2_OSR(x)              (((x) & 0x3) << 4)
  72
  73 enum {
  74         AD7152_DATA,
  75         AD7152_OFFS,
  76         AD7152_GAIN,
  77         AD7152_SETUP
  78 };
  79
  80 /*
  81  * struct ad7152_chip_info - chip specific information
  82  */
  83
  84 struct ad7152_chip_info {
  85         struct i2c_client *client;
  86         /*
  87          * Capacitive channel digital filter setup;
  88          * conversion time/update rate setup per channel
  89          */
  90         u8      filter_rate_setup;
  91         u8      setup[2];
  92         struct mutex state_lock;        /* protect hardware state */
  93 };
  94
  95 static inline ssize_t ad7152_start_calib(struct device *dev,
  96                                          struct device_attribute *attr,
  97                                          const char *buf,
  98                                          size_t len,
  99                                          u8 regval)
 100 {
 101         struct iio_dev *indio_dev = dev_to_iio_dev(dev);
 102         struct ad7152_chip_info *chip = iio_priv(indio_dev);
 103         struct iio_dev_attr *this_attr = to_iio_dev_attr(attr);
 104         bool doit;
 105         int ret, timeout = 10;
 106
 107         ret = strtobool(buf, &doit);
 108         if (ret < 0)
 109                 return ret;
 110
 111         if (!doit)
 112                 return 0;
 113
 114         if (this_attr->address == 0)
 115                 regval |= AD7152_CONF_CH1EN;
 116         else
 117                 regval |= AD7152_CONF_CH2EN;
 118
 119         mutex_lock(&chip->state_lock);
 120         ret = i2c_smbus_write_byte_data(chip->client, AD7152_REG_CFG, regval);
 121         if (ret < 0) {
 122                 mutex_unlock(&chip->state_lock);
 123                 return ret;
 124         }
 125
 126         do {
 127                 mdelay(20);
 128                 ret = i2c_smbus_read_byte_data(chip->client, AD7152_REG_CFG);
 129                 if (ret < 0) {
 130                         mutex_unlock(&chip->state_lock);
 131                         return ret;
 132                 }
 133         } while ((ret == regval) && timeout--);
 134
 135         mutex_unlock(&chip->state_lock);
 136         return len;
 137 }
 138
 139 static ssize_t ad7152_start_offset_calib(struct device *dev,
 140                                          struct device_attribute *attr,
 141                                          const char *buf,
 142                                          size_t len)
 143 {
 144         return ad7152_start_calib(dev, attr, buf, len,
 145                                   AD7152_CONF_MODE_OFFS_CAL);
 146 }
 147
 148 static ssize_t ad7152_start_gain_calib(struct device *dev,
 149                                        struct device_attribute *attr,
 150                                        const char *buf,
 151                                        size_t len)
 152 {
 153         return ad7152_start_calib(dev, attr, buf, len,
 154                                   AD7152_CONF_MODE_GAIN_CAL);
 155 }
 156
 157 static IIO_DEVICE_ATTR(in_capacitance0_calibbias_calibration,
 158                        0200, NULL, ad7152_start_offset_calib, 0);
 159 static IIO_DEVICE_ATTR(in_capacitance1_calibbias_calibration,
 160                        0200, NULL, ad7152_start_offset_calib, 1);
 161 static IIO_DEVICE_ATTR(in_capacitance0_calibscale_calibration,
 162                        0200, NULL, ad7152_start_gain_calib, 0);
 163 static IIO_DEVICE_ATTR(in_capacitance1_calibscale_calibration,
 164                        0200, NULL, ad7152_start_gain_calib, 1);
 165
 166 /* Values are Update Rate (Hz), Conversion Time (ms) + 1*/
 167 static const unsigned char ad7152_filter_rate_table[][2] = {
 168         {200, 5 + 1}, {50, 20 + 1}, {20, 50 + 1}, {17, 60 + 1},
 169 };
 170
 171 static IIO_CONST_ATTR_SAMP_FREQ_AVAIL("200 50 20 17");
 172
 173 static IIO_CONST_ATTR(in_capacitance_scale_available,
 174                       "0.000061050 0.000030525 0.000015263 0.000007631");
 175
 176 static struct attribute *ad7152_attributes[] = {
 177         &iio_dev_attr_in_capacitance0_calibbias_calibration.dev_attr.attr,
 178         &iio_dev_attr_in_capacitance1_calibbias_calibration.dev_attr.attr,
 179         &iio_dev_attr_in_capacitance0_calibscale_calibration.dev_attr.attr,
 180         &iio_dev_attr_in_capacitance1_calibscale_calibration.dev_attr.attr,
 181         &iio_const_attr_in_capacitance_scale_available.dev_attr.attr,
 182         &iio_const_attr_sampling_frequency_available.dev_attr.attr,
 183         NULL,
 184 };
 185
 186 static const struct attribute_group ad7152_attribute_group = {
 187         .attrs = ad7152_attributes,
 188 };
 189
 190 static const u8 ad7152_addresses[][4] = {
 191         { AD7152_REG_CH1_DATA_HIGH, AD7152_REG_CH1_OFFS_HIGH,
 192           AD7152_REG_CH1_GAIN_HIGH, AD7152_REG_CH1_SETUP },
 193         { AD7152_REG_CH2_DATA_HIGH, AD7152_REG_CH2_OFFS_HIGH,
 194           AD7152_REG_CH2_GAIN_HIGH, AD7152_REG_CH2_SETUP },
 195 };
 196
 197 /* Values are nano relative to pf base. */
 198 static const int ad7152_scale_table[] = {
 199         30525, 7631, 15263, 61050
 200 };
 201
 202 /**
 203  * read_raw handler for IIO_CHAN_INFO_SAMP_FREQ
 204  *
 205  * lock must be held
 206  **/
 207 static int ad7152_read_raw_samp_freq(struct device *dev, int *val)
 208 {
 209         struct ad7152_chip_info *chip = iio_priv(dev_to_iio_dev(dev));
 210
 211         *val = ad7152_filter_rate_table[chip->filter_rate_setup][0];
 212
 213         return 0;
 214 }
 215
 216 /**
 217  * write_raw handler for IIO_CHAN_INFO_SAMP_FREQ
 218  *
 219  * lock must be held
 220  **/
 221 static int ad7152_write_raw_samp_freq(struct device *dev, int val)
 222 {
 223         struct iio_dev *indio_dev = dev_to_iio_dev(dev);
 224         struct ad7152_chip_info *chip = iio_priv(indio_dev);
 225         int ret, i;
 226
 227         for (i = 0; i < ARRAY_SIZE(ad7152_filter_rate_table); i++)
 228                 if (val >= ad7152_filter_rate_table[i][0])
 229                         break;
 230
 231         if (i >= ARRAY_SIZE(ad7152_filter_rate_table))
 232                 i = ARRAY_SIZE(ad7152_filter_rate_table) - 1;
 233
 234         mutex_lock(&chip->state_lock);
 235         ret = i2c_smbus_write_byte_data(chip->client,
 236                                         AD7152_REG_CFG2, AD7152_CFG2_OSR(i));
 237         if (ret < 0) {
 238                 mutex_unlock(&chip->state_lock);
 239                 return ret;
 240         }
 241
 242         chip->filter_rate_setup = i;
 243         mutex_unlock(&chip->state_lock);
 244
 245         return ret;
 246 }
 247
 248 static int ad7152_write_raw(struct iio_dev *indio_dev,
 249                             struct iio_chan_spec const *chan,
 250                             int val,
 251                             int val2,
 252                             long mask)
 253 {
 254         struct ad7152_chip_info *chip = iio_priv(indio_dev);
 255         int ret, i;
 256
 257         mutex_lock(&chip->state_lock);
 258
 259         switch (mask) {
 260         case IIO_CHAN_INFO_CALIBSCALE:
 261                 if (val != 1) {
 262                         ret = -EINVAL;
 263                         goto out;
 264                 }
 265
 266                 val = (val2 * 1024) / 15625;
 267
 268                 ret = i2c_smbus_write_word_data(chip->client,
 269                                 ad7152_addresses[chan->channel][AD7152_GAIN],
 270                                 swab16(val));
 271                 if (ret < 0)
 272                         goto out;
 273
 274                 ret = 0;
 275                 break;
 276
 277         case IIO_CHAN_INFO_CALIBBIAS:
 278                 if ((val < 0) | (val > 0xFFFF)) {
 279                         ret = -EINVAL;
 280                         goto out;
 281                 }
 282                 ret = i2c_smbus_write_word_data(chip->client,
 283                                 ad7152_addresses[chan->channel][AD7152_OFFS],
 284                                 swab16(val));
 285                 if (ret < 0)
 286                         goto out;
 287
 288                 ret = 0;
 289                 break;
 290         case IIO_CHAN_INFO_SCALE:
 291                 if (val) {
 292                         ret = -EINVAL;
 293                         goto out;
 294                 }
 295                 for (i = 0; i < ARRAY_SIZE(ad7152_scale_table); i++)
 296                         if (val2 == ad7152_scale_table[i])
 297                                 break;
 298
 299                 chip->setup[chan->channel] &= ~AD7152_SETUP_RANGE_4pF;
 300                 chip->setup[chan->channel] |= AD7152_SETUP_RANGE(i);
 301
 302                 ret = i2c_smbus_write_byte_data(chip->client,
 303                                 ad7152_addresses[chan->channel][AD7152_SETUP],
 304                                 chip->setup[chan->channel]);
 305                 if (ret < 0)
 306                         goto out;
 307
 308                 ret = 0;
 309                 break;
 310         case IIO_CHAN_INFO_SAMP_FREQ:
 311                 if (val2) {
 312                         ret = -EINVAL;
 313                         goto out;
 314                 }
 315                 ret = ad7152_write_raw_samp_freq(&indio_dev->dev, val);
 316                 if (ret < 0)
 317                         goto out;
 318
 319                 ret = 0;
 320                 break;
 321         default:
 322                 ret = -EINVAL;
 323         }
 324
 325 out:
 326         mutex_unlock(&chip->state_lock);
 327         return ret;
 328 }
 329
 330 static int ad7152_read_raw(struct iio_dev *indio_dev,
 331                            struct iio_chan_spec const *chan,
 332                            int *val, int *val2,
 333                            long mask)
 334 {
 335         struct ad7152_chip_info *chip = iio_priv(indio_dev);
 336         int ret;
 337         u8 regval = 0;
 338
 339         mutex_lock(&chip->state_lock);
 340
 341         switch (mask) {
 342         case IIO_CHAN_INFO_RAW:
 343                 /* First set whether in differential mode */
 344
 345                 regval = chip->setup[chan->channel];
 346
 347                 if (chan->differential)
 348                         chip->setup[chan->channel] |= AD7152_SETUP_CAPDIFF;
 349                 else
 350                         chip->setup[chan->channel] &= ~AD7152_SETUP_CAPDIFF;
 351
 352                 if (regval != chip->setup[chan->channel]) {
 353                         ret = i2c_smbus_write_byte_data(chip->client,
 354                                 ad7152_addresses[chan->channel][AD7152_SETUP],
 355                                 chip->setup[chan->channel]);
 356                         if (ret < 0)
 357                                 goto out;
 358                 }
 359                 /* Make sure the channel is enabled */
 360                 if (chan->channel == 0)
 361                         regval = AD7152_CONF_CH1EN;
 362                 else
 363                         regval = AD7152_CONF_CH2EN;
 364
 365                 /* Trigger a single read */
 366                 regval |= AD7152_CONF_MODE_SINGLE_CONV;
 367                 ret = i2c_smbus_write_byte_data(chip->client, AD7152_REG_CFG,
 368                                 regval);
 369                 if (ret < 0)
 370                         goto out;
 371
 372                 msleep(ad7152_filter_rate_table[chip->filter_rate_setup][1]);
 373                 /* Now read the actual register */
 374                 ret = i2c_smbus_read_word_data(chip->client,
 375                                 ad7152_addresses[chan->channel][AD7152_DATA]);
 376                 if (ret < 0)
 377                         goto out;
 378                 *val = swab16(ret);
 379
 380                 if (chan->differential)
 381                         *val -= 0x8000;
 382
 383                 ret = IIO_VAL_INT;
 384                 break;
 385         case IIO_CHAN_INFO_CALIBSCALE:
 386
 387                 ret = i2c_smbus_read_word_data(chip->client,
 388                                 ad7152_addresses[chan->channel][AD7152_GAIN]);
 389                 if (ret < 0)
 390                         goto out;
 391                 /* 1 + gain_val / 2^16 */
 392                 *val = 1;
 393                 *val2 = (15625 * swab16(ret)) / 1024;
 394
 395                 ret = IIO_VAL_INT_PLUS_MICRO;
 396                 break;
 397         case IIO_CHAN_INFO_CALIBBIAS:
 398                 ret = i2c_smbus_read_word_data(chip->client,
 399                                 ad7152_addresses[chan->channel][AD7152_OFFS]);
 400                 if (ret < 0)
 401                         goto out;
 402                 *val = swab16(ret);
 403
 404                 ret = IIO_VAL_INT;
 405                 break;
 406         case IIO_CHAN_INFO_SCALE:
 407                 ret = i2c_smbus_read_byte_data(chip->client,
 408                                 ad7152_addresses[chan->channel][AD7152_SETUP]);
 409                 if (ret < 0)
 410                         goto out;
 411                 *val = 0;
 412                 *val2 = ad7152_scale_table[ret >> 6];
 413
 414                 ret = IIO_VAL_INT_PLUS_NANO;
 415                 break;
 416         case IIO_CHAN_INFO_SAMP_FREQ:
 417                 ret = ad7152_read_raw_samp_freq(&indio_dev->dev, val);
 418                 if (ret < 0)
 419                         goto out;
 420
 421                 ret = IIO_VAL_INT;
 422                 break;
 423         default:
 424                 ret = -EINVAL;
 425         }
 426 out:
 427         mutex_unlock(&chip->state_lock);
 428         return ret;
 429 }
 430
 431 static int ad7152_write_raw_get_fmt(struct iio_dev *indio_dev,
 432                                struct iio_chan_spec const *chan,
 433                                long mask)
 434 {
 435         switch (mask) {
 436         case IIO_CHAN_INFO_SCALE:
 437                 return IIO_VAL_INT_PLUS_NANO;
 438         default:
 439                 return IIO_VAL_INT_PLUS_MICRO;
 440         }
 441 }
 442
 443 static const struct iio_info ad7152_info = {
 444         .attrs = &ad7152_attribute_group,
 445         .read_raw = ad7152_read_raw,
 446         .write_raw = ad7152_write_raw,
 447         .write_raw_get_fmt = ad7152_write_raw_get_fmt,
 448         .driver_module = THIS_MODULE,
 449 };
 450
 451 static const struct iio_chan_spec ad7152_channels[] = {
 452         {
 453                 .type = IIO_CAPACITANCE,
 454                 .indexed = 1,
 455                 .channel = 0,
 456                 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW) |
 457                 BIT(IIO_CHAN_INFO_CALIBSCALE) |
 458                 BIT(IIO_CHAN_INFO_CALIBBIAS) |
 459                 BIT(IIO_CHAN_INFO_SCALE),
 460                 .info_mask_shared_by_all = BIT(IIO_CHAN_INFO_SAMP_FREQ),
 461         }, {
 462                 .type = IIO_CAPACITANCE,
 463                 .differential = 1,
 464                 .indexed = 1,
 465                 .channel = 0,
 466                 .channel2 = 2,
 467                 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW) |
 468                 BIT(IIO_CHAN_INFO_CALIBSCALE) |
 469                 BIT(IIO_CHAN_INFO_CALIBBIAS) |
 470                 BIT(IIO_CHAN_INFO_SCALE),
 471                 .info_mask_shared_by_all = BIT(IIO_CHAN_INFO_SAMP_FREQ),
 472         }, {
 473                 .type = IIO_CAPACITANCE,
 474                 .indexed = 1,
 475                 .channel = 1,
 476                 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW) |
 477                 BIT(IIO_CHAN_INFO_CALIBSCALE) |
 478                 BIT(IIO_CHAN_INFO_CALIBBIAS) |
 479                 BIT(IIO_CHAN_INFO_SCALE),
 480                 .info_mask_shared_by_all = BIT(IIO_CHAN_INFO_SAMP_FREQ),
 481         }, {
 482                 .type = IIO_CAPACITANCE,
 483                 .differential = 1,
 484                 .indexed = 1,
 485                 .channel = 1,
 486                 .channel2 = 3,
 487                 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW) |
 488                 BIT(IIO_CHAN_INFO_CALIBSCALE) |
 489                 BIT(IIO_CHAN_INFO_CALIBBIAS) |
 490                 BIT(IIO_CHAN_INFO_SCALE),
 491                 .info_mask_shared_by_all = BIT(IIO_CHAN_INFO_SAMP_FREQ),
 492         }
 493 };
 494
 495 /*
 496  * device probe and remove
 497  */
 498
 499 static int ad7152_probe(struct i2c_client *client,
 500                 const struct i2c_device_id *id)
 501 {
 502         int ret = 0;
 503         struct ad7152_chip_info *chip;
 504         struct iio_dev *indio_dev;
 505
 506         indio_dev = devm_iio_device_alloc(&client->dev, sizeof(*chip));
 507         if (!indio_dev)
 508                 return -ENOMEM;
 509         chip = iio_priv(indio_dev);
 510         /* this is only used for device removal purposes */
 511         i2c_set_clientdata(client, indio_dev);
 512
 513         chip->client = client;
 514         mutex_init(&chip->state_lock);
 515
 516         /* Establish that the iio_dev is a child of the i2c device */
 517         indio_dev->name = id->name;
 518         indio_dev->dev.parent = &client->dev;
 519         indio_dev->info = &ad7152_info;
 520         indio_dev->channels = ad7152_channels;
 521         if (id->driver_data == 0)
 522                 indio_dev->num_channels = ARRAY_SIZE(ad7152_channels);
 523         else
 524                 indio_dev->num_channels = 2;
 525         indio_dev->num_channels = ARRAY_SIZE(ad7152_channels);
 526         indio_dev->modes = INDIO_DIRECT_MODE;
 527
 528         ret = devm_iio_device_register(indio_dev->dev.parent, indio_dev);
 529         if (ret)
 530                 return ret;
 531
 532         dev_err(&client->dev, "%s capacitive sensor registered\n", id->name);
 533
 534         return 0;
 535 }
 536
 537 static const struct i2c_device_id ad7152_id[] = {
 538         { "ad7152", 0 },
 539         { "ad7153", 1 },
 540         {}
 541 };
 542
 543 MODULE_DEVICE_TABLE(i2c, ad7152_id);
 544
 545 static struct i2c_driver ad7152_driver = {
 546         .driver = {
 547                 .name = KBUILD_MODNAME,
 548         },
 549         .probe = ad7152_probe,
 550         .id_table = ad7152_id,
 551 };
 552 module_i2c_driver(ad7152_driver);
 553
 554 MODULE_AUTHOR("Barry Song <21cnbao@gmail.com>");
 555 MODULE_DESCRIPTION("Analog Devices AD7152/3 capacitive sensor driver");
 556 MODULE_LICENSE("GPL v2");