drivers/iio/adc/qcom-spmi-iadc.c

   1 /*
   2  * Copyright (c) 2012-2014, The Linux Foundation. All rights reserved.
   3  *
   4  * This program is free software; you can redistribute it and/or modify
   5  * it under the terms of the GNU General Public License version 2 and
   6  * only version 2 as published by the Free Software Foundation.
   7  *
   8  * This program is distributed in the hope that it will be useful,
   9  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  10  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  11  * GNU General Public License for more details.
  12  */
  13
  14 #include <linux/bitops.h>
  15 #include <linux/completion.h>
  16 #include <linux/delay.h>
  17 #include <linux/err.h>
  18 #include <linux/iio/iio.h>
  19 #include <linux/interrupt.h>
  20 #include <linux/kernel.h>
  21 #include <linux/mutex.h>
  22 #include <linux/module.h>
  23 #include <linux/of.h>
  24 #include <linux/of_device.h>
  25 #include <linux/platform_device.h>
  26 #include <linux/regmap.h>
  27 #include <linux/slab.h>
  28
  29 /* IADC register and bit definition */
  30 #define IADC_REVISION2                          0x1
  31 #define IADC_REVISION2_SUPPORTED_IADC           1
  32
  33 #define IADC_PERPH_TYPE                         0x4
  34 #define IADC_PERPH_TYPE_ADC                     8
  35
  36 #define IADC_PERPH_SUBTYPE                      0x5
  37 #define IADC_PERPH_SUBTYPE_IADC                 3
  38
  39 #define IADC_STATUS1                            0x8
  40 #define IADC_STATUS1_OP_MODE                    4
  41 #define IADC_STATUS1_REQ_STS                    BIT(1)
  42 #define IADC_STATUS1_EOC                        BIT(0)
  43 #define IADC_STATUS1_REQ_STS_EOC_MASK           0x3
  44
  45 #define IADC_MODE_CTL                           0x40
  46 #define IADC_OP_MODE_SHIFT                      3
  47 #define IADC_OP_MODE_NORMAL                     0
  48 #define IADC_TRIM_EN                            BIT(0)
  49
  50 #define IADC_EN_CTL1                            0x46
  51 #define IADC_EN_CTL1_SET                        BIT(7)
  52
  53 #define IADC_CH_SEL_CTL                         0x48
  54
  55 #define IADC_DIG_PARAM                          0x50
  56 #define IADC_DIG_DEC_RATIO_SEL_SHIFT            2
  57
  58 #define IADC_HW_SETTLE_DELAY                    0x51
  59
  60 #define IADC_CONV_REQ                           0x52
  61 #define IADC_CONV_REQ_SET                       BIT(7)
  62
  63 #define IADC_FAST_AVG_CTL                       0x5a
  64 #define IADC_FAST_AVG_EN                        0x5b
  65 #define IADC_FAST_AVG_EN_SET                    BIT(7)
  66
  67 #define IADC_PERH_RESET_CTL3                    0xda
  68 #define IADC_FOLLOW_WARM_RB                     BIT(2)
  69
  70 #define IADC_DATA                               0x60    /* 16 bits */
  71
  72 #define IADC_SEC_ACCESS                         0xd0
  73 #define IADC_SEC_ACCESS_DATA                    0xa5
  74
  75 #define IADC_NOMINAL_RSENSE                     0xf4
  76 #define IADC_NOMINAL_RSENSE_SIGN_MASK           BIT(7)
  77
  78 #define IADC_REF_GAIN_MICRO_VOLTS               17857
  79
  80 #define IADC_INT_RSENSE_DEVIATION               15625   /* nano Ohms per bit */
  81
  82 #define IADC_INT_RSENSE_IDEAL_VALUE             10000   /* micro Ohms */
  83 #define IADC_INT_RSENSE_DEFAULT_VALUE           7800    /* micro Ohms */
  84 #define IADC_INT_RSENSE_DEFAULT_GF              9000    /* micro Ohms */
  85 #define IADC_INT_RSENSE_DEFAULT_SMIC            9700    /* micro Ohms */
  86
  87 #define IADC_CONV_TIME_MIN_US                   2000
  88 #define IADC_CONV_TIME_MAX_US                   2100
  89
  90 #define IADC_DEF_PRESCALING                     0 /* 1:1 */
  91 #define IADC_DEF_DECIMATION                     0 /* 512 */
  92 #define IADC_DEF_HW_SETTLE_TIME                 0 /* 0 us */
  93 #define IADC_DEF_AVG_SAMPLES                    0 /* 1 sample */
  94
  95 /* IADC channel list */
  96 #define IADC_INT_RSENSE                         0
  97 #define IADC_EXT_RSENSE                         1
  98 #define IADC_GAIN_17P857MV                      3
  99 #define IADC_EXT_OFFSET_CSP_CSN                 5
 100 #define IADC_INT_OFFSET_CSP2_CSN2               6
 101
 102 /**
 103  * struct iadc_chip - IADC Current ADC device structure.
 104  * @regmap: regmap for register read/write.
 105  * @dev: This device pointer.
 106  * @base: base offset for the ADC peripheral.
 107  * @rsense: Values of the internal and external sense resister in micro Ohms.
 108  * @poll_eoc: Poll for end of conversion instead of waiting for IRQ.
 109  * @offset: Raw offset values for the internal and external channels.
 110  * @gain: Raw gain of the channels.
 111  * @lock: ADC lock for access to the peripheral.
 112  * @complete: ADC notification after end of conversion interrupt is received.
 113  */
 114 struct iadc_chip {
 115         struct regmap   *regmap;
 116         struct device   *dev;
 117         u16             base;
 118         bool            poll_eoc;
 119         u32             rsense[2];
 120         u16             offset[2];
 121         u16             gain;
 122         struct mutex    lock;
 123         struct completion complete;
 124 };
 125
 126 static int iadc_read(struct iadc_chip *iadc, u16 offset, u8 *data)
 127 {
 128         unsigned int val;
 129         int ret;
 130
 131         ret = regmap_read(iadc->regmap, iadc->base + offset, &val);
 132         if (ret < 0)
 133                 return ret;
 134
 135         *data = val;
 136         return 0;
 137 }
 138
 139 static int iadc_write(struct iadc_chip *iadc, u16 offset, u8 data)
 140 {
 141         return regmap_write(iadc->regmap, iadc->base + offset, data);
 142 }
 143
 144 static int iadc_reset(struct iadc_chip *iadc)
 145 {
 146         u8 data;
 147         int ret;
 148
 149         ret = iadc_write(iadc, IADC_SEC_ACCESS, IADC_SEC_ACCESS_DATA);
 150         if (ret < 0)
 151                 return ret;
 152
 153         ret = iadc_read(iadc, IADC_PERH_RESET_CTL3, &data);
 154         if (ret < 0)
 155                 return ret;
 156
 157         ret = iadc_write(iadc, IADC_SEC_ACCESS, IADC_SEC_ACCESS_DATA);
 158         if (ret < 0)
 159                 return ret;
 160
 161         data |= IADC_FOLLOW_WARM_RB;
 162
 163         return iadc_write(iadc, IADC_PERH_RESET_CTL3, data);
 164 }
 165
 166 static int iadc_set_state(struct iadc_chip *iadc, bool state)
 167 {
 168         return iadc_write(iadc, IADC_EN_CTL1, state ? IADC_EN_CTL1_SET : 0);
 169 }
 170
 171 static void iadc_status_show(struct iadc_chip *iadc)
 172 {
 173         u8 mode, sta1, chan, dig, en, req;
 174         int ret;
 175
 176         ret = iadc_read(iadc, IADC_MODE_CTL, &mode);
 177         if (ret < 0)
 178                 return;
 179
 180         ret = iadc_read(iadc, IADC_DIG_PARAM, &dig);
 181         if (ret < 0)
 182                 return;
 183
 184         ret = iadc_read(iadc, IADC_CH_SEL_CTL, &chan);
 185         if (ret < 0)
 186                 return;
 187
 188         ret = iadc_read(iadc, IADC_CONV_REQ, &req);
 189         if (ret < 0)
 190                 return;
 191
 192         ret = iadc_read(iadc, IADC_STATUS1, &sta1);
 193         if (ret < 0)
 194                 return;
 195
 196         ret = iadc_read(iadc, IADC_EN_CTL1, &en);
 197         if (ret < 0)
 198                 return;
 199
 200         dev_err(iadc->dev,
 201                 "mode:%02x en:%02x chan:%02x dig:%02x req:%02x sta1:%02x\n",
 202                 mode, en, chan, dig, req, sta1);
 203 }
 204
 205 static int iadc_configure(struct iadc_chip *iadc, int channel)
 206 {
 207         u8 decim, mode;
 208         int ret;
 209
 210         /* Mode selection */
 211         mode = (IADC_OP_MODE_NORMAL << IADC_OP_MODE_SHIFT) | IADC_TRIM_EN;
 212         ret = iadc_write(iadc, IADC_MODE_CTL, mode);
 213         if (ret < 0)
 214                 return ret;
 215
 216         /* Channel selection */
 217         ret = iadc_write(iadc, IADC_CH_SEL_CTL, channel);
 218         if (ret < 0)
 219                 return ret;
 220
 221         /* Digital parameter setup */
 222         decim = IADC_DEF_DECIMATION << IADC_DIG_DEC_RATIO_SEL_SHIFT;
 223         ret = iadc_write(iadc, IADC_DIG_PARAM, decim);
 224         if (ret < 0)
 225                 return ret;
 226
 227         /* HW settle time delay */
 228         ret = iadc_write(iadc, IADC_HW_SETTLE_DELAY, IADC_DEF_HW_SETTLE_TIME);
 229         if (ret < 0)
 230                 return ret;
 231
 232         ret = iadc_write(iadc, IADC_FAST_AVG_CTL, IADC_DEF_AVG_SAMPLES);
 233         if (ret < 0)
 234                 return ret;
 235
 236         if (IADC_DEF_AVG_SAMPLES)
 237                 ret = iadc_write(iadc, IADC_FAST_AVG_EN, IADC_FAST_AVG_EN_SET);
 238         else
 239                 ret = iadc_write(iadc, IADC_FAST_AVG_EN, 0);
 240
 241         if (ret < 0)
 242                 return ret;
 243
 244         if (!iadc->poll_eoc)
 245                 reinit_completion(&iadc->complete);
 246
 247         ret = iadc_set_state(iadc, true);
 248         if (ret < 0)
 249                 return ret;
 250
 251         /* Request conversion */
 252         return iadc_write(iadc, IADC_CONV_REQ, IADC_CONV_REQ_SET);
 253 }
 254
 255 static int iadc_poll_wait_eoc(struct iadc_chip *iadc, unsigned int interval_us)
 256 {
 257         unsigned int count, retry;
 258         int ret;
 259         u8 sta1;
 260
 261         retry = interval_us / IADC_CONV_TIME_MIN_US;
 262
 263         for (count = 0; count < retry; count++) {
 264                 ret = iadc_read(iadc, IADC_STATUS1, &sta1);
 265                 if (ret < 0)
 266                         return ret;
 267
 268                 sta1 &= IADC_STATUS1_REQ_STS_EOC_MASK;
 269                 if (sta1 == IADC_STATUS1_EOC)
 270                         return 0;
 271
 272                 usleep_range(IADC_CONV_TIME_MIN_US, IADC_CONV_TIME_MAX_US);
 273         }
 274
 275         iadc_status_show(iadc);
 276
 277         return -ETIMEDOUT;
 278 }
 279
 280 static int iadc_read_result(struct iadc_chip *iadc, u16 *data)
 281 {
 282         return regmap_bulk_read(iadc->regmap, iadc->base + IADC_DATA, data, 2);
 283 }
 284
 285 static int iadc_do_conversion(struct iadc_chip *iadc, int chan, u16 *data)
 286 {
 287         unsigned int wait;
 288         int ret;
 289
 290         ret = iadc_configure(iadc, chan);
 291         if (ret < 0)
 292                 goto exit;
 293
 294         wait = BIT(IADC_DEF_AVG_SAMPLES) * IADC_CONV_TIME_MIN_US * 2;
 295
 296         if (iadc->poll_eoc) {
 297                 ret = iadc_poll_wait_eoc(iadc, wait);
 298         } else {
 299                 ret = wait_for_completion_timeout(&iadc->complete,
 300                         usecs_to_jiffies(wait));
 301                 if (!ret)
 302                         ret = -ETIMEDOUT;
 303                 else
 304                         /* double check conversion status */
 305                         ret = iadc_poll_wait_eoc(iadc, IADC_CONV_TIME_MIN_US);
 306         }
 307
 308         if (!ret)
 309                 ret = iadc_read_result(iadc, data);
 310 exit:
 311         iadc_set_state(iadc, false);
 312         if (ret < 0)
 313                 dev_err(iadc->dev, "conversion failed\n");
 314
 315         return ret;
 316 }
 317
 318 static int iadc_read_raw(struct iio_dev *indio_dev,
 319                          struct iio_chan_spec const *chan,
 320                          int *val, int *val2, long mask)
 321 {
 322         struct iadc_chip *iadc = iio_priv(indio_dev);
 323         s32 isense_ua, vsense_uv;
 324         u16 adc_raw, vsense_raw;
 325         int ret;
 326
 327         switch (mask) {
 328         case IIO_CHAN_INFO_RAW:
 329                 mutex_lock(&iadc->lock);
 330                 ret = iadc_do_conversion(iadc, chan->channel, &adc_raw);
 331                 mutex_unlock(&iadc->lock);
 332                 if (ret < 0)
 333                         return ret;
 334
 335                 vsense_raw = adc_raw - iadc->offset[chan->channel];
 336
 337                 vsense_uv = vsense_raw * IADC_REF_GAIN_MICRO_VOLTS;
 338                 vsense_uv /= (s32)iadc->gain - iadc->offset[chan->channel];
 339
 340                 isense_ua = vsense_uv / iadc->rsense[chan->channel];
 341
 342                 dev_dbg(iadc->dev, "off %d gain %d adc %d %duV I %duA\n",
 343                         iadc->offset[chan->channel], iadc->gain,
 344                         adc_raw, vsense_uv, isense_ua);
 345
 346                 *val = isense_ua;
 347                 return IIO_VAL_INT;
 348         case IIO_CHAN_INFO_SCALE:
 349                 *val = 0;
 350                 *val2 = 1000;
 351                 return IIO_VAL_INT_PLUS_MICRO;
 352         }
 353
 354         return -EINVAL;
 355 }
 356
 357 static const struct iio_info iadc_info = {
 358         .read_raw = iadc_read_raw,
 359         .driver_module = THIS_MODULE,
 360 };
 361
 362 static irqreturn_t iadc_isr(int irq, void *dev_id)
 363 {
 364         struct iadc_chip *iadc = dev_id;
 365
 366         complete(&iadc->complete);
 367
 368         return IRQ_HANDLED;
 369 }
 370
 371 static int iadc_update_offset(struct iadc_chip *iadc)
 372 {
 373         int ret;
 374
 375         ret = iadc_do_conversion(iadc, IADC_GAIN_17P857MV, &iadc->gain);
 376         if (ret < 0)
 377                 return ret;
 378
 379         ret = iadc_do_conversion(iadc, IADC_INT_OFFSET_CSP2_CSN2,
 380                                  &iadc->offset[IADC_INT_RSENSE]);
 381         if (ret < 0)
 382                 return ret;
 383
 384         if (iadc->gain == iadc->offset[IADC_INT_RSENSE]) {
 385                 dev_err(iadc->dev, "error: internal offset == gain %d\n",
 386                         iadc->gain);
 387                 return -EINVAL;
 388         }
 389
 390         ret = iadc_do_conversion(iadc, IADC_EXT_OFFSET_CSP_CSN,
 391                                  &iadc->offset[IADC_EXT_RSENSE]);
 392         if (ret < 0)
 393                 return ret;
 394
 395         if (iadc->gain == iadc->offset[IADC_EXT_RSENSE]) {
 396                 dev_err(iadc->dev, "error: external offset == gain %d\n",
 397                         iadc->gain);
 398                 return -EINVAL;
 399         }
 400
 401         return 0;
 402 }
 403
 404 static int iadc_version_check(struct iadc_chip *iadc)
 405 {
 406         u8 val;
 407         int ret;
 408
 409         ret = iadc_read(iadc, IADC_PERPH_TYPE, &val);
 410         if (ret < 0)
 411                 return ret;
 412
 413         if (val < IADC_PERPH_TYPE_ADC) {
 414                 dev_err(iadc->dev, "%d is not ADC\n", val);
 415                 return -EINVAL;
 416         }
 417
 418         ret = iadc_read(iadc, IADC_PERPH_SUBTYPE, &val);
 419         if (ret < 0)
 420                 return ret;
 421
 422         if (val < IADC_PERPH_SUBTYPE_IADC) {
 423                 dev_err(iadc->dev, "%d is not IADC\n", val);
 424                 return -EINVAL;
 425         }
 426
 427         ret = iadc_read(iadc, IADC_REVISION2, &val);
 428         if (ret < 0)
 429                 return ret;
 430
 431         if (val < IADC_REVISION2_SUPPORTED_IADC) {
 432                 dev_err(iadc->dev, "revision %d not supported\n", val);
 433                 return -EINVAL;
 434         }
 435
 436         return 0;
 437 }
 438
 439 static int iadc_rsense_read(struct iadc_chip *iadc, struct device_node *node)
 440 {
 441         int ret, sign, int_sense;
 442         u8 deviation;
 443
 444         ret = of_property_read_u32(node, "qcom,external-resistor-micro-ohms",
 445                                    &iadc->rsense[IADC_EXT_RSENSE]);
 446         if (ret < 0)
 447                 iadc->rsense[IADC_EXT_RSENSE] = IADC_INT_RSENSE_IDEAL_VALUE;
 448
 449         if (!iadc->rsense[IADC_EXT_RSENSE]) {
 450                 dev_err(iadc->dev, "external resistor can't be zero Ohms");
 451                 return -EINVAL;
 452         }
 453
 454         ret = iadc_read(iadc, IADC_NOMINAL_RSENSE, &deviation);
 455         if (ret < 0)
 456                 return ret;
 457
 458         /*
 459          * Deviation value stored is an offset from 10 mili Ohms, bit 7 is
 460          * the sign, the remaining bits have an LSB of 15625 nano Ohms.
 461          */
 462         sign = (deviation & IADC_NOMINAL_RSENSE_SIGN_MASK) ? -1 : 1;
 463
 464         deviation &= ~IADC_NOMINAL_RSENSE_SIGN_MASK;
 465
 466         /* Scale it to nono Ohms */
 467         int_sense = IADC_INT_RSENSE_IDEAL_VALUE * 1000;
 468         int_sense += sign * deviation * IADC_INT_RSENSE_DEVIATION;
 469         int_sense /= 1000; /* micro Ohms */
 470
 471         iadc->rsense[IADC_INT_RSENSE] = int_sense;
 472         return 0;
 473 }
 474
 475 static const struct iio_chan_spec iadc_channels[] = {
 476         {
 477                 .type = IIO_CURRENT,
 478                 .datasheet_name = "INTERNAL_RSENSE",
 479                 .channel = 0,
 480                 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW) |
 481                                       BIT(IIO_CHAN_INFO_SCALE),
 482                 .indexed = 1,
 483         },
 484         {
 485                 .type = IIO_CURRENT,
 486                 .datasheet_name = "EXTERNAL_RSENSE",
 487                 .channel = 1,
 488                 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW) |
 489                                       BIT(IIO_CHAN_INFO_SCALE),
 490                 .indexed = 1,
 491         },
 492 };
 493
 494 static int iadc_probe(struct platform_device *pdev)
 495 {
 496         struct device_node *node = pdev->dev.of_node;
 497         struct device *dev = &pdev->dev;
 498         struct iio_dev *indio_dev;
 499         struct iadc_chip *iadc;
 500         int ret, irq_eoc;
 501         u32 res;
 502
 503         indio_dev = devm_iio_device_alloc(dev, sizeof(*iadc));
 504         if (!indio_dev)
 505                 return -ENOMEM;
 506
 507         iadc = iio_priv(indio_dev);
 508         iadc->dev = dev;
 509
 510         iadc->regmap = dev_get_regmap(dev->parent, NULL);
 511         if (!iadc->regmap)
 512                 return -ENODEV;
 513
 514         init_completion(&iadc->complete);
 515         mutex_init(&iadc->lock);
 516
 517         ret = of_property_read_u32(node, "reg", &res);
 518         if (ret < 0)
 519                 return -ENODEV;
 520
 521         iadc->base = res;
 522
 523         ret = iadc_version_check(iadc);
 524         if (ret < 0)
 525                 return -ENODEV;
 526
 527         ret = iadc_rsense_read(iadc, node);
 528         if (ret < 0)
 529                 return -ENODEV;
 530
 531         dev_dbg(iadc->dev, "sense resistors %d and %d micro Ohm\n",
 532                 iadc->rsense[IADC_INT_RSENSE],
 533                 iadc->rsense[IADC_EXT_RSENSE]);
 534
 535         irq_eoc = platform_get_irq(pdev, 0);
 536         if (irq_eoc == -EPROBE_DEFER)
 537                 return irq_eoc;
 538
 539         if (irq_eoc < 0)
 540                 iadc->poll_eoc = true;
 541
 542         ret = iadc_reset(iadc);
 543         if (ret < 0) {
 544                 dev_err(dev, "reset failed\n");
 545                 return ret;
 546         }
 547
 548         if (!iadc->poll_eoc) {
 549                 ret = devm_request_irq(dev, irq_eoc, iadc_isr, 0,
 550                                         "spmi-iadc", iadc);
 551                 if (!ret)
 552                         enable_irq_wake(irq_eoc);
 553                 else
 554                         return ret;
 555         } else {
 556                 device_init_wakeup(iadc->dev, 1);
 557         }
 558
 559         ret = iadc_update_offset(iadc);
 560         if (ret < 0) {
 561                 dev_err(dev, "failed offset calibration\n");
 562                 return ret;
 563         }
 564
 565         indio_dev->dev.parent = dev;
 566         indio_dev->dev.of_node = node;
 567         indio_dev->name = pdev->name;
 568         indio_dev->modes = INDIO_DIRECT_MODE;
 569         indio_dev->info = &iadc_info;
 570         indio_dev->channels = iadc_channels;
 571         indio_dev->num_channels = ARRAY_SIZE(iadc_channels);
 572
 573         return devm_iio_device_register(dev, indio_dev);
 574 }
 575
 576 static const struct of_device_id iadc_match_table[] = {
 577         { .compatible = "qcom,spmi-iadc" },
 578         { }
 579 };
 580
 581 MODULE_DEVICE_TABLE(of, iadc_match_table);
 582
 583 static struct platform_driver iadc_driver = {
 584         .driver = {
 585                    .name = "qcom-spmi-iadc",
 586                    .of_match_table = iadc_match_table,
 587         },
 588         .probe = iadc_probe,
 589 };
 590
 591 module_platform_driver(iadc_driver);
 592
 593 MODULE_ALIAS("platform:qcom-spmi-iadc");
 594 MODULE_DESCRIPTION("Qualcomm SPMI PMIC current ADC driver");
 595 MODULE_LICENSE("GPL v2");
 596 MODULE_AUTHOR("Ivan T. Ivanov <iivanov@mm-sol.com>");