drivers/iio/adc/nau7802.c

   1 /*
   2  * Driver for the Nuvoton NAU7802 ADC
   3  *
   4  * Copyright 2013 Free Electrons
   5  *
   6  * Licensed under the GPLv2 or later.
   7  */
   8
   9 #include <linux/delay.h>
  10 #include <linux/i2c.h>
  11 #include <linux/interrupt.h>
  12 #include <linux/module.h>
  13 #include <linux/wait.h>
  14 #include <linux/log2.h>
  15 #include <linux/of.h>
  16
  17 #include <linux/iio/iio.h>
  18 #include <linux/iio/sysfs.h>
  19
  20 #define NAU7802_REG_PUCTRL      0x00
  21 #define NAU7802_PUCTRL_RR(x)            (x << 0)
  22 #define NAU7802_PUCTRL_RR_BIT           NAU7802_PUCTRL_RR(1)
  23 #define NAU7802_PUCTRL_PUD(x)           (x << 1)
  24 #define NAU7802_PUCTRL_PUD_BIT          NAU7802_PUCTRL_PUD(1)
  25 #define NAU7802_PUCTRL_PUA(x)           (x << 2)
  26 #define NAU7802_PUCTRL_PUA_BIT          NAU7802_PUCTRL_PUA(1)
  27 #define NAU7802_PUCTRL_PUR(x)           (x << 3)
  28 #define NAU7802_PUCTRL_PUR_BIT          NAU7802_PUCTRL_PUR(1)
  29 #define NAU7802_PUCTRL_CS(x)            (x << 4)
  30 #define NAU7802_PUCTRL_CS_BIT           NAU7802_PUCTRL_CS(1)
  31 #define NAU7802_PUCTRL_CR(x)            (x << 5)
  32 #define NAU7802_PUCTRL_CR_BIT           NAU7802_PUCTRL_CR(1)
  33 #define NAU7802_PUCTRL_AVDDS(x)         (x << 7)
  34 #define NAU7802_PUCTRL_AVDDS_BIT        NAU7802_PUCTRL_AVDDS(1)
  35 #define NAU7802_REG_CTRL1       0x01
  36 #define NAU7802_CTRL1_VLDO(x)           (x << 3)
  37 #define NAU7802_CTRL1_GAINS(x)          (x)
  38 #define NAU7802_CTRL1_GAINS_BITS        0x07
  39 #define NAU7802_REG_CTRL2       0x02
  40 #define NAU7802_CTRL2_CHS(x)            (x << 7)
  41 #define NAU7802_CTRL2_CRS(x)            (x << 4)
  42 #define NAU7802_SAMP_FREQ_320   0x07
  43 #define NAU7802_CTRL2_CHS_BIT           NAU7802_CTRL2_CHS(1)
  44 #define NAU7802_REG_ADC_B2      0x12
  45 #define NAU7802_REG_ADC_B1      0x13
  46 #define NAU7802_REG_ADC_B0      0x14
  47 #define NAU7802_REG_ADC_CTRL    0x15
  48
  49 #define NAU7802_MIN_CONVERSIONS 6
  50
  51 struct nau7802_state {
  52         struct i2c_client       *client;
  53         s32                     last_value;
  54         struct mutex            lock;
  55         struct mutex            data_lock;
  56         u32                     vref_mv;
  57         u32                     conversion_count;
  58         u32                     min_conversions;
  59         u8                      sample_rate;
  60         u32                     scale_avail[8];
  61         struct completion       value_ok;
  62 };
  63
  64 #define NAU7802_CHANNEL(chan) {                                 \
  65         .type = IIO_VOLTAGE,                                    \
  66         .indexed = 1,                                           \
  67         .channel = (chan),                                      \
  68         .scan_index = (chan),                                   \
  69         .info_mask_separate = BIT(IIO_CHAN_INFO_RAW),           \
  70         .info_mask_shared_by_type = BIT(IIO_CHAN_INFO_SCALE) |  \
  71                                 BIT(IIO_CHAN_INFO_SAMP_FREQ)    \
  72 }
  73
  74 static const struct iio_chan_spec nau7802_chan_array[] = {
  75         NAU7802_CHANNEL(0),
  76         NAU7802_CHANNEL(1),
  77 };
  78
  79 static const u16 nau7802_sample_freq_avail[] = {10, 20, 40, 80,
  80                                                 10, 10, 10, 320};
  81
  82 static ssize_t nau7802_show_scales(struct device *dev,
  83                                    struct device_attribute *attr, char *buf)
  84 {
  85         struct nau7802_state *st = iio_priv(dev_to_iio_dev(dev));
  86         int i, len = 0;
  87
  88         for (i = 0; i < ARRAY_SIZE(st->scale_avail); i++)
  89                 len += scnprintf(buf + len, PAGE_SIZE - len, "0.%09d ",
  90                                  st->scale_avail[i]);
  91
  92         buf[len-1] = '\n';
  93
  94         return len;
  95 }
  96
  97 static IIO_CONST_ATTR_SAMP_FREQ_AVAIL("10 40 80 320");
  98
  99 static IIO_DEVICE_ATTR(in_voltage_scale_available, S_IRUGO, nau7802_show_scales,
 100                        NULL, 0);
 101
 102 static struct attribute *nau7802_attributes[] = {
 103         &iio_const_attr_sampling_frequency_available.dev_attr.attr,
 104         &iio_dev_attr_in_voltage_scale_available.dev_attr.attr,
 105         NULL
 106 };
 107
 108 static const struct attribute_group nau7802_attribute_group = {
 109         .attrs = nau7802_attributes,
 110 };
 111
 112 static int nau7802_set_gain(struct nau7802_state *st, int gain)
 113 {
 114         int ret;
 115
 116         mutex_lock(&st->lock);
 117         st->conversion_count = 0;
 118
 119         ret = i2c_smbus_read_byte_data(st->client, NAU7802_REG_CTRL1);
 120         if (ret < 0)
 121                 goto nau7802_sysfs_set_gain_out;
 122         ret = i2c_smbus_write_byte_data(st->client, NAU7802_REG_CTRL1,
 123                                         (ret & (~NAU7802_CTRL1_GAINS_BITS)) |
 124                                         gain);
 125
 126 nau7802_sysfs_set_gain_out:
 127         mutex_unlock(&st->lock);
 128
 129         return ret;
 130 }
 131
 132 static int nau7802_read_conversion(struct nau7802_state *st)
 133 {
 134         int data;
 135
 136         mutex_lock(&st->data_lock);
 137         data = i2c_smbus_read_byte_data(st->client, NAU7802_REG_ADC_B2);
 138         if (data < 0)
 139                 goto nau7802_read_conversion_out;
 140         st->last_value = data << 16;
 141
 142         data = i2c_smbus_read_byte_data(st->client, NAU7802_REG_ADC_B1);
 143         if (data < 0)
 144                 goto nau7802_read_conversion_out;
 145         st->last_value |= data << 8;
 146
 147         data = i2c_smbus_read_byte_data(st->client, NAU7802_REG_ADC_B0);
 148         if (data < 0)
 149                 goto nau7802_read_conversion_out;
 150         st->last_value |= data;
 151
 152         st->last_value = sign_extend32(st->last_value, 23);
 153
 154 nau7802_read_conversion_out:
 155         mutex_unlock(&st->data_lock);
 156
 157         return data;
 158 }
 159
 160 /*
 161  * Conversions are synchronised on the rising edge of NAU7802_PUCTRL_CS_BIT
 162  */
 163 static int nau7802_sync(struct nau7802_state *st)
 164 {
 165         int ret;
 166
 167         ret = i2c_smbus_read_byte_data(st->client, NAU7802_REG_PUCTRL);
 168         if (ret < 0)
 169                 return ret;
 170         ret = i2c_smbus_write_byte_data(st->client, NAU7802_REG_PUCTRL,
 171                                 ret | NAU7802_PUCTRL_CS_BIT);
 172
 173         return ret;
 174 }
 175
 176 static irqreturn_t nau7802_eoc_trigger(int irq, void *private)
 177 {
 178         struct iio_dev *indio_dev = private;
 179         struct nau7802_state *st = iio_priv(indio_dev);
 180         int status;
 181
 182         status = i2c_smbus_read_byte_data(st->client, NAU7802_REG_PUCTRL);
 183         if (status < 0)
 184                 return IRQ_HANDLED;
 185
 186         if (!(status & NAU7802_PUCTRL_CR_BIT))
 187                 return IRQ_NONE;
 188
 189         if (nau7802_read_conversion(st) < 0)
 190                 return IRQ_HANDLED;
 191
 192         /*
 193          * Because there is actually only one ADC for both channels, we have to
 194          * wait for enough conversions to happen before getting a significant
 195          * value when changing channels and the values are far apart.
 196          */
 197         if (st->conversion_count < NAU7802_MIN_CONVERSIONS)
 198                 st->conversion_count++;
 199         if (st->conversion_count >= NAU7802_MIN_CONVERSIONS)
 200                 complete(&st->value_ok);
 201
 202         return IRQ_HANDLED;
 203 }
 204
 205 static int nau7802_read_irq(struct iio_dev *indio_dev,
 206                         struct iio_chan_spec const *chan,
 207                         int *val)
 208 {
 209         struct nau7802_state *st = iio_priv(indio_dev);
 210         int ret;
 211
 212         reinit_completion(&st->value_ok);
 213         enable_irq(st->client->irq);
 214
 215         nau7802_sync(st);
 216
 217         /* read registers to ensure we flush everything */
 218         ret = nau7802_read_conversion(st);
 219         if (ret < 0)
 220                 goto read_chan_info_failure;
 221
 222         /* Wait for a conversion to finish */
 223         ret = wait_for_completion_interruptible_timeout(&st->value_ok,
 224                         msecs_to_jiffies(1000));
 225         if (ret == 0)
 226                 ret = -ETIMEDOUT;
 227
 228         if (ret < 0)
 229                 goto read_chan_info_failure;
 230
 231         disable_irq(st->client->irq);
 232
 233         *val = st->last_value;
 234
 235         return IIO_VAL_INT;
 236
 237 read_chan_info_failure:
 238         disable_irq(st->client->irq);
 239
 240         return ret;
 241 }
 242
 243 static int nau7802_read_poll(struct iio_dev *indio_dev,
 244                         struct iio_chan_spec const *chan,
 245                         int *val)
 246 {
 247         struct nau7802_state *st = iio_priv(indio_dev);
 248         int ret;
 249
 250         nau7802_sync(st);
 251
 252         /* read registers to ensure we flush everything */
 253         ret = nau7802_read_conversion(st);
 254         if (ret < 0)
 255                 return ret;
 256
 257         /*
 258          * Because there is actually only one ADC for both channels, we have to
 259          * wait for enough conversions to happen before getting a significant
 260          * value when changing channels and the values are far appart.
 261          */
 262         do {
 263                 ret = i2c_smbus_read_byte_data(st->client, NAU7802_REG_PUCTRL);
 264                 if (ret < 0)
 265                         return ret;
 266
 267                 while (!(ret & NAU7802_PUCTRL_CR_BIT)) {
 268                         if (st->sample_rate != NAU7802_SAMP_FREQ_320)
 269                                 msleep(20);
 270                         else
 271                                 mdelay(4);
 272                         ret = i2c_smbus_read_byte_data(st->client,
 273                                                         NAU7802_REG_PUCTRL);
 274                         if (ret < 0)
 275                                 return ret;
 276                 }
 277
 278                 ret = nau7802_read_conversion(st);
 279                 if (ret < 0)
 280                         return ret;
 281                 if (st->conversion_count < NAU7802_MIN_CONVERSIONS)
 282                         st->conversion_count++;
 283         } while (st->conversion_count < NAU7802_MIN_CONVERSIONS);
 284
 285         *val = st->last_value;
 286
 287         return IIO_VAL_INT;
 288 }
 289
 290 static int nau7802_read_raw(struct iio_dev *indio_dev,
 291                             struct iio_chan_spec const *chan,
 292                             int *val, int *val2, long mask)
 293 {
 294         struct nau7802_state *st = iio_priv(indio_dev);
 295         int ret;
 296
 297         switch (mask) {
 298         case IIO_CHAN_INFO_RAW:
 299                 mutex_lock(&st->lock);
 300                 /*
 301                  * Select the channel to use
 302                  *   - Channel 1 is value 0 in the CHS register
 303                  *   - Channel 2 is value 1 in the CHS register
 304                  */
 305                 ret = i2c_smbus_read_byte_data(st->client, NAU7802_REG_CTRL2);
 306                 if (ret < 0) {
 307                         mutex_unlock(&st->lock);
 308                         return ret;
 309                 }
 310
 311                 if (((ret & NAU7802_CTRL2_CHS_BIT) && !chan->channel) ||
 312                                 (!(ret & NAU7802_CTRL2_CHS_BIT) &&
 313                                  chan->channel)) {
 314                         st->conversion_count = 0;
 315                         ret = i2c_smbus_write_byte_data(st->client,
 316                                         NAU7802_REG_CTRL2,
 317                                         NAU7802_CTRL2_CHS(chan->channel) |
 318                                         NAU7802_CTRL2_CRS(st->sample_rate));
 319
 320                         if (ret < 0) {
 321                                 mutex_unlock(&st->lock);
 322                                 return ret;
 323                         }
 324                 }
 325
 326                 if (st->client->irq)
 327                         ret = nau7802_read_irq(indio_dev, chan, val);
 328                 else
 329                         ret = nau7802_read_poll(indio_dev, chan, val);
 330
 331                 mutex_unlock(&st->lock);
 332                 return ret;
 333
 334         case IIO_CHAN_INFO_SCALE:
 335                 ret = i2c_smbus_read_byte_data(st->client, NAU7802_REG_CTRL1);
 336                 if (ret < 0)
 337                         return ret;
 338
 339                 /*
 340                  * We have 24 bits of signed data, that means 23 bits of data
 341                  * plus the sign bit
 342                  */
 343                 *val = st->vref_mv;
 344                 *val2 = 23 + (ret & NAU7802_CTRL1_GAINS_BITS);
 345
 346                 return IIO_VAL_FRACTIONAL_LOG2;
 347
 348         case IIO_CHAN_INFO_SAMP_FREQ:
 349                 *val =  nau7802_sample_freq_avail[st->sample_rate];
 350                 *val2 = 0;
 351                 return IIO_VAL_INT;
 352
 353         default:
 354                 break;
 355         }
 356
 357         return -EINVAL;
 358 }
 359
 360 static int nau7802_write_raw(struct iio_dev *indio_dev,
 361                              struct iio_chan_spec const *chan,
 362                              int val, int val2, long mask)
 363 {
 364         struct nau7802_state *st = iio_priv(indio_dev);
 365         int i, ret;
 366
 367         switch (mask) {
 368         case IIO_CHAN_INFO_SCALE:
 369                 for (i = 0; i < ARRAY_SIZE(st->scale_avail); i++)
 370                         if (val2 == st->scale_avail[i])
 371                                 return nau7802_set_gain(st, i);
 372
 373                 break;
 374
 375         case IIO_CHAN_INFO_SAMP_FREQ:
 376                 for (i = 0; i < ARRAY_SIZE(nau7802_sample_freq_avail); i++)
 377                         if (val == nau7802_sample_freq_avail[i]) {
 378                                 mutex_lock(&st->lock);
 379                                 st->sample_rate = i;
 380                                 st->conversion_count = 0;
 381                                 ret = i2c_smbus_write_byte_data(st->client,
 382                                         NAU7802_REG_CTRL2,
 383                                         NAU7802_CTRL2_CRS(st->sample_rate));
 384                                 mutex_unlock(&st->lock);
 385                                 return ret;
 386                         }
 387
 388                 break;
 389
 390         default:
 391                 break;
 392         }
 393
 394         return -EINVAL;
 395 }
 396
 397 static int nau7802_write_raw_get_fmt(struct iio_dev *indio_dev,
 398                                      struct iio_chan_spec const *chan,
 399                                      long mask)
 400 {
 401         return IIO_VAL_INT_PLUS_NANO;
 402 }
 403
 404 static const struct iio_info nau7802_info = {
 405         .driver_module = THIS_MODULE,
 406         .read_raw = &nau7802_read_raw,
 407         .write_raw = &nau7802_write_raw,
 408         .write_raw_get_fmt = nau7802_write_raw_get_fmt,
 409         .attrs = &nau7802_attribute_group,
 410 };
 411
 412 static int nau7802_probe(struct i2c_client *client,
 413                         const struct i2c_device_id *id)
 414 {
 415         struct iio_dev *indio_dev;
 416         struct nau7802_state *st;
 417         struct device_node *np = client->dev.of_node;
 418         int i, ret;
 419         u8 data;
 420         u32 tmp = 0;
 421
 422         if (!client->dev.of_node) {
 423                 dev_err(&client->dev, "No device tree node available.\n");
 424                 return -EINVAL;
 425         }
 426
 427         indio_dev = devm_iio_device_alloc(&client->dev, sizeof(*st));
 428         if (indio_dev == NULL)
 429                 return -ENOMEM;
 430
 431         st = iio_priv(indio_dev);
 432
 433         i2c_set_clientdata(client, indio_dev);
 434
 435         indio_dev->dev.parent = &client->dev;
 436         indio_dev->dev.of_node = client->dev.of_node;
 437         indio_dev->name = dev_name(&client->dev);
 438         indio_dev->modes = INDIO_DIRECT_MODE;
 439         indio_dev->info = &nau7802_info;
 440
 441         st->client = client;
 442
 443         /* Reset the device */
 444         ret = i2c_smbus_write_byte_data(st->client, NAU7802_REG_PUCTRL,
 445                                   NAU7802_PUCTRL_RR_BIT);
 446         if (ret < 0)
 447                 return ret;
 448
 449         /* Enter normal operation mode */
 450         ret = i2c_smbus_write_byte_data(st->client, NAU7802_REG_PUCTRL,
 451                                   NAU7802_PUCTRL_PUD_BIT);
 452         if (ret < 0)
 453                 return ret;
 454
 455         /*
 456          * After about 200 usecs, the device should be ready and then
 457          * the Power Up bit will be set to 1. If not, wait for it.
 458          */
 459         udelay(210);
 460         ret = i2c_smbus_read_byte_data(st->client, NAU7802_REG_PUCTRL);
 461         if (ret < 0)
 462                 return ret;
 463         if (!(ret & NAU7802_PUCTRL_PUR_BIT))
 464                 return ret;
 465
 466         of_property_read_u32(np, "nuvoton,vldo", &tmp);
 467         st->vref_mv = tmp;
 468
 469         data = NAU7802_PUCTRL_PUD_BIT | NAU7802_PUCTRL_PUA_BIT |
 470                 NAU7802_PUCTRL_CS_BIT;
 471         if (tmp >= 2400)
 472                 data |= NAU7802_PUCTRL_AVDDS_BIT;
 473
 474         ret = i2c_smbus_write_byte_data(st->client, NAU7802_REG_PUCTRL, data);
 475         if (ret < 0)
 476                 return ret;
 477         ret = i2c_smbus_write_byte_data(st->client, NAU7802_REG_ADC_CTRL, 0x30);
 478         if (ret < 0)
 479                 return ret;
 480
 481         if (tmp >= 2400) {
 482                 data = NAU7802_CTRL1_VLDO((4500 - tmp) / 300);
 483                 ret = i2c_smbus_write_byte_data(st->client, NAU7802_REG_CTRL1,
 484                                                 data);
 485                 if (ret < 0)
 486                         return ret;
 487         }
 488
 489         /* Populate available ADC input ranges */
 490         for (i = 0; i < ARRAY_SIZE(st->scale_avail); i++)
 491                 st->scale_avail[i] = (((u64)st->vref_mv) * 1000000000ULL)
 492                                            >> (23 + i);
 493
 494         init_completion(&st->value_ok);
 495
 496         /*
 497          * The ADC fires continuously and we can't do anything about
 498          * it. So we need to have the IRQ disabled by default, and we
 499          * will enable them back when we will need them..
 500          */
 501         if (client->irq) {
 502                 ret = request_threaded_irq(client->irq,
 503                                 NULL,
 504                                 nau7802_eoc_trigger,
 505                                 IRQF_TRIGGER_HIGH | IRQF_ONESHOT,
 506                                 client->dev.driver->name,
 507                                 indio_dev);
 508                 if (ret) {
 509                         /*
 510                          * What may happen here is that our IRQ controller is
 511                          * not able to get level interrupt but this is required
 512                          * by this ADC as when going over 40 sample per second,
 513                          * the interrupt line may stay high between conversions.
 514                          * So, we continue no matter what but we switch to
 515                          * polling mode.
 516                          */
 517                         dev_info(&client->dev,
 518                                 "Failed to allocate IRQ, using polling mode\n");
 519                         client->irq = 0;
 520                 } else
 521                         disable_irq(client->irq);
 522         }
 523
 524         if (!client->irq) {
 525                 /*
 526                  * We are polling, use the fastest sample rate by
 527                  * default
 528                  */
 529                 st->sample_rate = NAU7802_SAMP_FREQ_320;
 530                 ret = i2c_smbus_write_byte_data(st->client, NAU7802_REG_CTRL2,
 531                                           NAU7802_CTRL2_CRS(st->sample_rate));
 532                 if (ret)
 533                         goto error_free_irq;
 534         }
 535
 536         /* Setup the ADC channels available on the board */
 537         indio_dev->num_channels = ARRAY_SIZE(nau7802_chan_array);
 538         indio_dev->channels = nau7802_chan_array;
 539
 540         mutex_init(&st->lock);
 541         mutex_init(&st->data_lock);
 542
 543         ret = iio_device_register(indio_dev);
 544         if (ret < 0) {
 545                 dev_err(&client->dev, "Couldn't register the device.\n");
 546                 goto error_device_register;
 547         }
 548
 549         return 0;
 550
 551 error_device_register:
 552         mutex_destroy(&st->lock);
 553         mutex_destroy(&st->data_lock);
 554 error_free_irq:
 555         if (client->irq)
 556                 free_irq(client->irq, indio_dev);
 557
 558         return ret;
 559 }
 560
 561 static int nau7802_remove(struct i2c_client *client)
 562 {
 563         struct iio_dev *indio_dev = i2c_get_clientdata(client);
 564         struct nau7802_state *st = iio_priv(indio_dev);
 565
 566         iio_device_unregister(indio_dev);
 567         mutex_destroy(&st->lock);
 568         mutex_destroy(&st->data_lock);
 569         if (client->irq)
 570                 free_irq(client->irq, indio_dev);
 571
 572         return 0;
 573 }
 574
 575 static const struct i2c_device_id nau7802_i2c_id[] = {
 576         { "nau7802", 0 },
 577         { }
 578 };
 579 MODULE_DEVICE_TABLE(i2c, nau7802_i2c_id);
 580
 581 static const struct of_device_id nau7802_dt_ids[] = {
 582         { .compatible = "nuvoton,nau7802" },
 583         {},
 584 };
 585 MODULE_DEVICE_TABLE(of, nau7802_dt_ids);
 586
 587 static struct i2c_driver nau7802_driver = {
 588         .probe = nau7802_probe,
 589         .remove = nau7802_remove,
 590         .id_table = nau7802_i2c_id,
 591         .driver = {
 592                    .name = "nau7802",
 593                    .of_match_table = nau7802_dt_ids,
 594         },
 595 };
 596
 597 module_i2c_driver(nau7802_driver);
 598
 599 MODULE_LICENSE("GPL");
 600 MODULE_DESCRIPTION("Nuvoton NAU7802 ADC Driver");
 601 MODULE_AUTHOR("Maxime Ripard <maxime.ripard@free-electrons.com>");
 602 MODULE_AUTHOR("Alexandre Belloni <alexandre.belloni@free-electrons.com>");