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>"); 597