1
2
3
4
5
6
7
8
9
10
11
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
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
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
81
82#define IADC_INT_RSENSE_IDEAL_VALUE 10000
83#define IADC_INT_RSENSE_DEFAULT_VALUE 7800
84#define IADC_INT_RSENSE_DEFAULT_GF 9000
85#define IADC_INT_RSENSE_DEFAULT_SMIC 9700
86
87#define IADC_CONV_TIME_MIN_US 2000
88#define IADC_CONV_TIME_MAX_US 2100
89
90#define IADC_DEF_PRESCALING 0
91#define IADC_DEF_DECIMATION 0
92#define IADC_DEF_HW_SETTLE_TIME 0
93#define IADC_DEF_AVG_SAMPLES 0
94
95
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
104
105
106
107
108
109
110
111
112
113
114struct 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
126static 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
139static int iadc_write(struct iadc_chip *iadc, u16 offset, u8 data)
140{
141 return regmap_write(iadc->regmap, iadc->base + offset, data);
142}
143
144static 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
166static 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
171static 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
205static int iadc_configure(struct iadc_chip *iadc, int channel)
206{
207 u8 decim, mode;
208 int ret;
209
210
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
217 ret = iadc_write(iadc, IADC_CH_SEL_CTL, channel);
218 if (ret < 0)
219 return ret;
220
221
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
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
252 return iadc_write(iadc, IADC_CONV_REQ, IADC_CONV_REQ_SET);
253}
254
255static 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
280static 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
285static 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
305 ret = iadc_poll_wait_eoc(iadc, IADC_CONV_TIME_MIN_US);
306 }
307
308 if (!ret)
309 ret = iadc_read_result(iadc, data);
310exit:
311 iadc_set_state(iadc, false);
312 if (ret < 0)
313 dev_err(iadc->dev, "conversion failed\n");
314
315 return ret;
316}
317
318static 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
357static const struct iio_info iadc_info = {
358 .read_raw = iadc_read_raw,
359 .driver_module = THIS_MODULE,
360};
361
362static 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
371static 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
404static 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
439static 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
460
461
462 sign = (deviation & IADC_NOMINAL_RSENSE_SIGN_MASK) ? -1 : 1;
463
464 deviation &= ~IADC_NOMINAL_RSENSE_SIGN_MASK;
465
466
467 int_sense = IADC_INT_RSENSE_IDEAL_VALUE * 1000;
468 int_sense += sign * deviation * IADC_INT_RSENSE_DEVIATION;
469 int_sense /= 1000;
470
471 iadc->rsense[IADC_INT_RSENSE] = int_sense;
472 return 0;
473}
474
475static 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
494static 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
576static const struct of_device_id iadc_match_table[] = {
577 { .compatible = "qcom,spmi-iadc" },
578 { }
579};
580
581MODULE_DEVICE_TABLE(of, iadc_match_table);
582
583static 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
591module_platform_driver(iadc_driver);
592
593MODULE_ALIAS("platform:qcom-spmi-iadc");
594MODULE_DESCRIPTION("Qualcomm SPMI PMIC current ADC driver");
595MODULE_LICENSE("GPL v2");
596MODULE_AUTHOR("Ivan T. Ivanov <iivanov@mm-sol.com>");
597
