xref: /openbmc/linux/drivers/iio/adc/axp20x_adc.c (revision c286b047)
1 // SPDX-License-Identifier: GPL-2.0-only
2 /* ADC driver for AXP20X and AXP22X PMICs
3  *
4  * Copyright (c) 2016 Free Electrons NextThing Co.
5  *	Quentin Schulz <quentin.schulz@free-electrons.com>
6  */
7 
8 #include <linux/bitfield.h>
9 #include <linux/completion.h>
10 #include <linux/interrupt.h>
11 #include <linux/io.h>
12 #include <linux/module.h>
13 #include <linux/mod_devicetable.h>
14 #include <linux/platform_device.h>
15 #include <linux/pm_runtime.h>
16 #include <linux/property.h>
17 #include <linux/regmap.h>
18 #include <linux/thermal.h>
19 
20 #include <linux/iio/iio.h>
21 #include <linux/iio/driver.h>
22 #include <linux/iio/machine.h>
23 #include <linux/mfd/axp20x.h>
24 
25 #define AXP20X_ADC_EN1_MASK			GENMASK(7, 0)
26 #define AXP20X_ADC_EN2_MASK			(GENMASK(3, 2) | BIT(7))
27 
28 #define AXP22X_ADC_EN1_MASK			(GENMASK(7, 5) | BIT(0))
29 
30 #define AXP20X_GPIO10_IN_RANGE_GPIO0		BIT(0)
31 #define AXP20X_GPIO10_IN_RANGE_GPIO1		BIT(1)
32 
33 #define AXP20X_ADC_RATE_MASK			GENMASK(7, 6)
34 #define AXP20X_ADC_RATE_HZ(x)			((ilog2((x) / 25) << 6) & AXP20X_ADC_RATE_MASK)
35 
36 #define AXP22X_ADC_RATE_HZ(x)			((ilog2((x) / 100) << 6) & AXP20X_ADC_RATE_MASK)
37 
38 #define AXP813_V_I_ADC_RATE_MASK		GENMASK(5, 4)
39 #define AXP813_ADC_RATE_MASK			(AXP20X_ADC_RATE_MASK | AXP813_V_I_ADC_RATE_MASK)
40 #define AXP813_TS_GPIO0_ADC_RATE_HZ(x)		AXP20X_ADC_RATE_HZ(x)
41 #define AXP813_V_I_ADC_RATE_HZ(x)		((ilog2((x) / 100) << 4) & AXP813_V_I_ADC_RATE_MASK)
42 #define AXP813_ADC_RATE_HZ(x)			(AXP20X_ADC_RATE_HZ(x) | AXP813_V_I_ADC_RATE_HZ(x))
43 
44 #define AXP20X_ADC_CHANNEL(_channel, _name, _type, _reg)	\
45 	{							\
46 		.type = _type,					\
47 		.indexed = 1,					\
48 		.channel = _channel,				\
49 		.address = _reg,				\
50 		.info_mask_separate = BIT(IIO_CHAN_INFO_RAW) |	\
51 				      BIT(IIO_CHAN_INFO_SCALE),	\
52 		.datasheet_name = _name,			\
53 	}
54 
55 #define AXP20X_ADC_CHANNEL_OFFSET(_channel, _name, _type, _reg) \
56 	{							\
57 		.type = _type,					\
58 		.indexed = 1,					\
59 		.channel = _channel,				\
60 		.address = _reg,				\
61 		.info_mask_separate = BIT(IIO_CHAN_INFO_RAW) |	\
62 				      BIT(IIO_CHAN_INFO_SCALE) |\
63 				      BIT(IIO_CHAN_INFO_OFFSET),\
64 		.datasheet_name = _name,			\
65 	}
66 
67 struct axp_data;
68 
69 struct axp20x_adc_iio {
70 	struct regmap		*regmap;
71 	const struct axp_data	*data;
72 };
73 
74 enum axp20x_adc_channel_v {
75 	AXP20X_ACIN_V = 0,
76 	AXP20X_VBUS_V,
77 	AXP20X_TS_IN,
78 	AXP20X_GPIO0_V,
79 	AXP20X_GPIO1_V,
80 	AXP20X_IPSOUT_V,
81 	AXP20X_BATT_V,
82 };
83 
84 enum axp20x_adc_channel_i {
85 	AXP20X_ACIN_I = 0,
86 	AXP20X_VBUS_I,
87 	AXP20X_BATT_CHRG_I,
88 	AXP20X_BATT_DISCHRG_I,
89 };
90 
91 enum axp22x_adc_channel_v {
92 	AXP22X_TS_IN = 0,
93 	AXP22X_BATT_V,
94 };
95 
96 enum axp22x_adc_channel_i {
97 	AXP22X_BATT_CHRG_I = 1,
98 	AXP22X_BATT_DISCHRG_I,
99 };
100 
101 enum axp813_adc_channel_v {
102 	AXP813_TS_IN = 0,
103 	AXP813_GPIO0_V,
104 	AXP813_BATT_V,
105 };
106 
107 static struct iio_map axp20x_maps[] = {
108 	{
109 		.consumer_dev_name = "axp20x-usb-power-supply",
110 		.consumer_channel = "vbus_v",
111 		.adc_channel_label = "vbus_v",
112 	}, {
113 		.consumer_dev_name = "axp20x-usb-power-supply",
114 		.consumer_channel = "vbus_i",
115 		.adc_channel_label = "vbus_i",
116 	}, {
117 		.consumer_dev_name = "axp20x-ac-power-supply",
118 		.consumer_channel = "acin_v",
119 		.adc_channel_label = "acin_v",
120 	}, {
121 		.consumer_dev_name = "axp20x-ac-power-supply",
122 		.consumer_channel = "acin_i",
123 		.adc_channel_label = "acin_i",
124 	}, {
125 		.consumer_dev_name = "axp20x-battery-power-supply",
126 		.consumer_channel = "batt_v",
127 		.adc_channel_label = "batt_v",
128 	}, {
129 		.consumer_dev_name = "axp20x-battery-power-supply",
130 		.consumer_channel = "batt_chrg_i",
131 		.adc_channel_label = "batt_chrg_i",
132 	}, {
133 		.consumer_dev_name = "axp20x-battery-power-supply",
134 		.consumer_channel = "batt_dischrg_i",
135 		.adc_channel_label = "batt_dischrg_i",
136 	}, { /* sentinel */ }
137 };
138 
139 static struct iio_map axp22x_maps[] = {
140 	{
141 		.consumer_dev_name = "axp20x-battery-power-supply",
142 		.consumer_channel = "batt_v",
143 		.adc_channel_label = "batt_v",
144 	}, {
145 		.consumer_dev_name = "axp20x-battery-power-supply",
146 		.consumer_channel = "batt_chrg_i",
147 		.adc_channel_label = "batt_chrg_i",
148 	}, {
149 		.consumer_dev_name = "axp20x-battery-power-supply",
150 		.consumer_channel = "batt_dischrg_i",
151 		.adc_channel_label = "batt_dischrg_i",
152 	}, { /* sentinel */ }
153 };
154 
155 /*
156  * Channels are mapped by physical system. Their channels share the same index.
157  * i.e. acin_i is in_current0_raw and acin_v is in_voltage0_raw.
158  * The only exception is for the battery. batt_v will be in_voltage6_raw and
159  * charge current in_current6_raw and discharge current will be in_current7_raw.
160  */
161 static const struct iio_chan_spec axp20x_adc_channels[] = {
162 	AXP20X_ADC_CHANNEL(AXP20X_ACIN_V, "acin_v", IIO_VOLTAGE,
163 			   AXP20X_ACIN_V_ADC_H),
164 	AXP20X_ADC_CHANNEL(AXP20X_ACIN_I, "acin_i", IIO_CURRENT,
165 			   AXP20X_ACIN_I_ADC_H),
166 	AXP20X_ADC_CHANNEL(AXP20X_VBUS_V, "vbus_v", IIO_VOLTAGE,
167 			   AXP20X_VBUS_V_ADC_H),
168 	AXP20X_ADC_CHANNEL(AXP20X_VBUS_I, "vbus_i", IIO_CURRENT,
169 			   AXP20X_VBUS_I_ADC_H),
170 	{
171 		.type = IIO_TEMP,
172 		.address = AXP20X_TEMP_ADC_H,
173 		.info_mask_separate = BIT(IIO_CHAN_INFO_RAW) |
174 				      BIT(IIO_CHAN_INFO_SCALE) |
175 				      BIT(IIO_CHAN_INFO_OFFSET),
176 		.datasheet_name = "pmic_temp",
177 	},
178 	AXP20X_ADC_CHANNEL_OFFSET(AXP20X_GPIO0_V, "gpio0_v", IIO_VOLTAGE,
179 				  AXP20X_GPIO0_V_ADC_H),
180 	AXP20X_ADC_CHANNEL_OFFSET(AXP20X_GPIO1_V, "gpio1_v", IIO_VOLTAGE,
181 				  AXP20X_GPIO1_V_ADC_H),
182 	AXP20X_ADC_CHANNEL(AXP20X_IPSOUT_V, "ipsout_v", IIO_VOLTAGE,
183 			   AXP20X_IPSOUT_V_HIGH_H),
184 	AXP20X_ADC_CHANNEL(AXP20X_BATT_V, "batt_v", IIO_VOLTAGE,
185 			   AXP20X_BATT_V_H),
186 	AXP20X_ADC_CHANNEL(AXP20X_BATT_CHRG_I, "batt_chrg_i", IIO_CURRENT,
187 			   AXP20X_BATT_CHRG_I_H),
188 	AXP20X_ADC_CHANNEL(AXP20X_BATT_DISCHRG_I, "batt_dischrg_i", IIO_CURRENT,
189 			   AXP20X_BATT_DISCHRG_I_H),
190 	AXP20X_ADC_CHANNEL(AXP20X_TS_IN, "ts_v", IIO_VOLTAGE,
191 			   AXP20X_TS_IN_H),
192 };
193 
194 static const struct iio_chan_spec axp22x_adc_channels[] = {
195 	{
196 		.type = IIO_TEMP,
197 		.address = AXP22X_PMIC_TEMP_H,
198 		.info_mask_separate = BIT(IIO_CHAN_INFO_RAW) |
199 				      BIT(IIO_CHAN_INFO_SCALE) |
200 				      BIT(IIO_CHAN_INFO_OFFSET),
201 		.datasheet_name = "pmic_temp",
202 	},
203 	AXP20X_ADC_CHANNEL(AXP22X_BATT_V, "batt_v", IIO_VOLTAGE,
204 			   AXP20X_BATT_V_H),
205 	AXP20X_ADC_CHANNEL(AXP22X_BATT_CHRG_I, "batt_chrg_i", IIO_CURRENT,
206 			   AXP20X_BATT_CHRG_I_H),
207 	AXP20X_ADC_CHANNEL(AXP22X_BATT_DISCHRG_I, "batt_dischrg_i", IIO_CURRENT,
208 			   AXP20X_BATT_DISCHRG_I_H),
209 	AXP20X_ADC_CHANNEL(AXP22X_TS_IN, "ts_v", IIO_VOLTAGE,
210 			   AXP22X_TS_ADC_H),
211 };
212 
213 static const struct iio_chan_spec axp813_adc_channels[] = {
214 	{
215 		.type = IIO_TEMP,
216 		.address = AXP22X_PMIC_TEMP_H,
217 		.info_mask_separate = BIT(IIO_CHAN_INFO_RAW) |
218 				      BIT(IIO_CHAN_INFO_SCALE) |
219 				      BIT(IIO_CHAN_INFO_OFFSET),
220 		.datasheet_name = "pmic_temp",
221 	},
222 	AXP20X_ADC_CHANNEL(AXP813_GPIO0_V, "gpio0_v", IIO_VOLTAGE,
223 			   AXP288_GP_ADC_H),
224 	AXP20X_ADC_CHANNEL(AXP813_BATT_V, "batt_v", IIO_VOLTAGE,
225 			   AXP20X_BATT_V_H),
226 	AXP20X_ADC_CHANNEL(AXP22X_BATT_CHRG_I, "batt_chrg_i", IIO_CURRENT,
227 			   AXP20X_BATT_CHRG_I_H),
228 	AXP20X_ADC_CHANNEL(AXP22X_BATT_DISCHRG_I, "batt_dischrg_i", IIO_CURRENT,
229 			   AXP20X_BATT_DISCHRG_I_H),
230 	AXP20X_ADC_CHANNEL(AXP813_TS_IN, "ts_v", IIO_VOLTAGE,
231 			   AXP288_TS_ADC_H),
232 };
233 
axp20x_adc_raw(struct iio_dev * indio_dev,struct iio_chan_spec const * chan,int * val)234 static int axp20x_adc_raw(struct iio_dev *indio_dev,
235 			  struct iio_chan_spec const *chan, int *val)
236 {
237 	struct axp20x_adc_iio *info = iio_priv(indio_dev);
238 	int ret, size;
239 
240 	/*
241 	 * N.B.:  Unlike the Chinese datasheets tell, the charging current is
242 	 * stored on 12 bits, not 13 bits. Only discharging current is on 13
243 	 * bits.
244 	 */
245 	if (chan->type == IIO_CURRENT && chan->channel == AXP20X_BATT_DISCHRG_I)
246 		size = 13;
247 	else
248 		size = 12;
249 
250 	ret = axp20x_read_variable_width(info->regmap, chan->address, size);
251 	if (ret < 0)
252 		return ret;
253 
254 	*val = ret;
255 	return IIO_VAL_INT;
256 }
257 
axp22x_adc_raw(struct iio_dev * indio_dev,struct iio_chan_spec const * chan,int * val)258 static int axp22x_adc_raw(struct iio_dev *indio_dev,
259 			  struct iio_chan_spec const *chan, int *val)
260 {
261 	struct axp20x_adc_iio *info = iio_priv(indio_dev);
262 	int ret;
263 
264 	ret = axp20x_read_variable_width(info->regmap, chan->address, 12);
265 	if (ret < 0)
266 		return ret;
267 
268 	*val = ret;
269 	return IIO_VAL_INT;
270 }
271 
axp813_adc_raw(struct iio_dev * indio_dev,struct iio_chan_spec const * chan,int * val)272 static int axp813_adc_raw(struct iio_dev *indio_dev,
273 			  struct iio_chan_spec const *chan, int *val)
274 {
275 	struct axp20x_adc_iio *info = iio_priv(indio_dev);
276 	int ret;
277 
278 	ret = axp20x_read_variable_width(info->regmap, chan->address, 12);
279 	if (ret < 0)
280 		return ret;
281 
282 	*val = ret;
283 	return IIO_VAL_INT;
284 }
285 
axp20x_adc_scale_voltage(int channel,int * val,int * val2)286 static int axp20x_adc_scale_voltage(int channel, int *val, int *val2)
287 {
288 	switch (channel) {
289 	case AXP20X_ACIN_V:
290 	case AXP20X_VBUS_V:
291 		*val = 1;
292 		*val2 = 700000;
293 		return IIO_VAL_INT_PLUS_MICRO;
294 
295 	case AXP20X_GPIO0_V:
296 	case AXP20X_GPIO1_V:
297 		*val = 0;
298 		*val2 = 500000;
299 		return IIO_VAL_INT_PLUS_MICRO;
300 
301 	case AXP20X_BATT_V:
302 		*val = 1;
303 		*val2 = 100000;
304 		return IIO_VAL_INT_PLUS_MICRO;
305 
306 	case AXP20X_IPSOUT_V:
307 		*val = 1;
308 		*val2 = 400000;
309 		return IIO_VAL_INT_PLUS_MICRO;
310 
311 	case AXP20X_TS_IN:
312 		/* 0.8 mV per LSB */
313 		*val = 0;
314 		*val2 = 800000;
315 		return IIO_VAL_INT_PLUS_MICRO;
316 
317 	default:
318 		return -EINVAL;
319 	}
320 }
321 
axp22x_adc_scale_voltage(int channel,int * val,int * val2)322 static int axp22x_adc_scale_voltage(int channel, int *val, int *val2)
323 {
324 	switch (channel) {
325 	case AXP22X_BATT_V:
326 		/* 1.1 mV per LSB */
327 		*val = 1;
328 		*val2 = 100000;
329 		return IIO_VAL_INT_PLUS_MICRO;
330 
331 	case AXP22X_TS_IN:
332 		/* 0.8 mV per LSB */
333 		*val = 0;
334 		*val2 = 800000;
335 		return IIO_VAL_INT_PLUS_MICRO;
336 
337 	default:
338 		return -EINVAL;
339 	}
340 }
axp813_adc_scale_voltage(int channel,int * val,int * val2)341 static int axp813_adc_scale_voltage(int channel, int *val, int *val2)
342 {
343 	switch (channel) {
344 	case AXP813_GPIO0_V:
345 		*val = 0;
346 		*val2 = 800000;
347 		return IIO_VAL_INT_PLUS_MICRO;
348 
349 	case AXP813_BATT_V:
350 		*val = 1;
351 		*val2 = 100000;
352 		return IIO_VAL_INT_PLUS_MICRO;
353 
354 	case AXP813_TS_IN:
355 		/* 0.8 mV per LSB */
356 		*val = 0;
357 		*val2 = 800000;
358 		return IIO_VAL_INT_PLUS_MICRO;
359 
360 	default:
361 		return -EINVAL;
362 	}
363 }
364 
axp20x_adc_scale_current(int channel,int * val,int * val2)365 static int axp20x_adc_scale_current(int channel, int *val, int *val2)
366 {
367 	switch (channel) {
368 	case AXP20X_ACIN_I:
369 		*val = 0;
370 		*val2 = 625000;
371 		return IIO_VAL_INT_PLUS_MICRO;
372 
373 	case AXP20X_VBUS_I:
374 		*val = 0;
375 		*val2 = 375000;
376 		return IIO_VAL_INT_PLUS_MICRO;
377 
378 	case AXP20X_BATT_DISCHRG_I:
379 	case AXP20X_BATT_CHRG_I:
380 		*val = 0;
381 		*val2 = 500000;
382 		return IIO_VAL_INT_PLUS_MICRO;
383 
384 	default:
385 		return -EINVAL;
386 	}
387 }
388 
axp20x_adc_scale(struct iio_chan_spec const * chan,int * val,int * val2)389 static int axp20x_adc_scale(struct iio_chan_spec const *chan, int *val,
390 			    int *val2)
391 {
392 	switch (chan->type) {
393 	case IIO_VOLTAGE:
394 		return axp20x_adc_scale_voltage(chan->channel, val, val2);
395 
396 	case IIO_CURRENT:
397 		return axp20x_adc_scale_current(chan->channel, val, val2);
398 
399 	case IIO_TEMP:
400 		*val = 100;
401 		return IIO_VAL_INT;
402 
403 	default:
404 		return -EINVAL;
405 	}
406 }
407 
axp22x_adc_scale(struct iio_chan_spec const * chan,int * val,int * val2)408 static int axp22x_adc_scale(struct iio_chan_spec const *chan, int *val,
409 			    int *val2)
410 {
411 	switch (chan->type) {
412 	case IIO_VOLTAGE:
413 		return axp22x_adc_scale_voltage(chan->channel, val, val2);
414 
415 	case IIO_CURRENT:
416 		*val = 1;
417 		return IIO_VAL_INT;
418 
419 	case IIO_TEMP:
420 		*val = 100;
421 		return IIO_VAL_INT;
422 
423 	default:
424 		return -EINVAL;
425 	}
426 }
427 
axp813_adc_scale(struct iio_chan_spec const * chan,int * val,int * val2)428 static int axp813_adc_scale(struct iio_chan_spec const *chan, int *val,
429 			    int *val2)
430 {
431 	switch (chan->type) {
432 	case IIO_VOLTAGE:
433 		return axp813_adc_scale_voltage(chan->channel, val, val2);
434 
435 	case IIO_CURRENT:
436 		*val = 1;
437 		return IIO_VAL_INT;
438 
439 	case IIO_TEMP:
440 		*val = 100;
441 		return IIO_VAL_INT;
442 
443 	default:
444 		return -EINVAL;
445 	}
446 }
447 
axp20x_adc_offset_voltage(struct iio_dev * indio_dev,int channel,int * val)448 static int axp20x_adc_offset_voltage(struct iio_dev *indio_dev, int channel,
449 				     int *val)
450 {
451 	struct axp20x_adc_iio *info = iio_priv(indio_dev);
452 	unsigned int regval;
453 	int ret;
454 
455 	ret = regmap_read(info->regmap, AXP20X_GPIO10_IN_RANGE, &regval);
456 	if (ret < 0)
457 		return ret;
458 
459 	switch (channel) {
460 	case AXP20X_GPIO0_V:
461 		regval = FIELD_GET(AXP20X_GPIO10_IN_RANGE_GPIO0, regval);
462 		break;
463 
464 	case AXP20X_GPIO1_V:
465 		regval = FIELD_GET(AXP20X_GPIO10_IN_RANGE_GPIO1, regval);
466 		break;
467 
468 	default:
469 		return -EINVAL;
470 	}
471 
472 	*val = regval ? 700000 : 0;
473 	return IIO_VAL_INT;
474 }
475 
axp20x_adc_offset(struct iio_dev * indio_dev,struct iio_chan_spec const * chan,int * val)476 static int axp20x_adc_offset(struct iio_dev *indio_dev,
477 			     struct iio_chan_spec const *chan, int *val)
478 {
479 	switch (chan->type) {
480 	case IIO_VOLTAGE:
481 		return axp20x_adc_offset_voltage(indio_dev, chan->channel, val);
482 
483 	case IIO_TEMP:
484 		*val = -1447;
485 		return IIO_VAL_INT;
486 
487 	default:
488 		return -EINVAL;
489 	}
490 }
491 
axp20x_read_raw(struct iio_dev * indio_dev,struct iio_chan_spec const * chan,int * val,int * val2,long mask)492 static int axp20x_read_raw(struct iio_dev *indio_dev,
493 			   struct iio_chan_spec const *chan, int *val,
494 			   int *val2, long mask)
495 {
496 	switch (mask) {
497 	case IIO_CHAN_INFO_OFFSET:
498 		return axp20x_adc_offset(indio_dev, chan, val);
499 
500 	case IIO_CHAN_INFO_SCALE:
501 		return axp20x_adc_scale(chan, val, val2);
502 
503 	case IIO_CHAN_INFO_RAW:
504 		return axp20x_adc_raw(indio_dev, chan, val);
505 
506 	default:
507 		return -EINVAL;
508 	}
509 }
510 
axp22x_read_raw(struct iio_dev * indio_dev,struct iio_chan_spec const * chan,int * val,int * val2,long mask)511 static int axp22x_read_raw(struct iio_dev *indio_dev,
512 			   struct iio_chan_spec const *chan, int *val,
513 			   int *val2, long mask)
514 {
515 	switch (mask) {
516 	case IIO_CHAN_INFO_OFFSET:
517 		/* For PMIC temp only */
518 		*val = -2677;
519 		return IIO_VAL_INT;
520 
521 	case IIO_CHAN_INFO_SCALE:
522 		return axp22x_adc_scale(chan, val, val2);
523 
524 	case IIO_CHAN_INFO_RAW:
525 		return axp22x_adc_raw(indio_dev, chan, val);
526 
527 	default:
528 		return -EINVAL;
529 	}
530 }
531 
axp813_read_raw(struct iio_dev * indio_dev,struct iio_chan_spec const * chan,int * val,int * val2,long mask)532 static int axp813_read_raw(struct iio_dev *indio_dev,
533 			   struct iio_chan_spec const *chan, int *val,
534 			   int *val2, long mask)
535 {
536 	switch (mask) {
537 	case IIO_CHAN_INFO_OFFSET:
538 		*val = -2667;
539 		return IIO_VAL_INT;
540 
541 	case IIO_CHAN_INFO_SCALE:
542 		return axp813_adc_scale(chan, val, val2);
543 
544 	case IIO_CHAN_INFO_RAW:
545 		return axp813_adc_raw(indio_dev, chan, val);
546 
547 	default:
548 		return -EINVAL;
549 	}
550 }
551 
axp20x_write_raw(struct iio_dev * indio_dev,struct iio_chan_spec const * chan,int val,int val2,long mask)552 static int axp20x_write_raw(struct iio_dev *indio_dev,
553 			    struct iio_chan_spec const *chan, int val, int val2,
554 			    long mask)
555 {
556 	struct axp20x_adc_iio *info = iio_priv(indio_dev);
557 	unsigned int regmask, regval;
558 
559 	/*
560 	 * The AXP20X PMIC allows the user to choose between 0V and 0.7V offsets
561 	 * for (independently) GPIO0 and GPIO1 when in ADC mode.
562 	 */
563 	if (mask != IIO_CHAN_INFO_OFFSET)
564 		return -EINVAL;
565 
566 	if (val != 0 && val != 700000)
567 		return -EINVAL;
568 
569 	switch (chan->channel) {
570 	case AXP20X_GPIO0_V:
571 		regmask = AXP20X_GPIO10_IN_RANGE_GPIO0;
572 		regval = FIELD_PREP(AXP20X_GPIO10_IN_RANGE_GPIO0, !!val);
573 		break;
574 
575 	case AXP20X_GPIO1_V:
576 		regmask = AXP20X_GPIO10_IN_RANGE_GPIO1;
577 		regval = FIELD_PREP(AXP20X_GPIO10_IN_RANGE_GPIO1, !!val);
578 		break;
579 
580 	default:
581 		return -EINVAL;
582 	}
583 
584 	return regmap_update_bits(info->regmap, AXP20X_GPIO10_IN_RANGE, regmask, regval);
585 }
586 
587 static const struct iio_info axp20x_adc_iio_info = {
588 	.read_raw = axp20x_read_raw,
589 	.write_raw = axp20x_write_raw,
590 };
591 
592 static const struct iio_info axp22x_adc_iio_info = {
593 	.read_raw = axp22x_read_raw,
594 };
595 
596 static const struct iio_info axp813_adc_iio_info = {
597 	.read_raw = axp813_read_raw,
598 };
599 
axp20x_adc_rate(struct axp20x_adc_iio * info,int rate)600 static int axp20x_adc_rate(struct axp20x_adc_iio *info, int rate)
601 {
602 	return regmap_update_bits(info->regmap, AXP20X_ADC_RATE,
603 				  AXP20X_ADC_RATE_MASK,
604 				  AXP20X_ADC_RATE_HZ(rate));
605 }
606 
axp22x_adc_rate(struct axp20x_adc_iio * info,int rate)607 static int axp22x_adc_rate(struct axp20x_adc_iio *info, int rate)
608 {
609 	return regmap_update_bits(info->regmap, AXP20X_ADC_RATE,
610 				  AXP20X_ADC_RATE_MASK,
611 				  AXP22X_ADC_RATE_HZ(rate));
612 }
613 
axp813_adc_rate(struct axp20x_adc_iio * info,int rate)614 static int axp813_adc_rate(struct axp20x_adc_iio *info, int rate)
615 {
616 	return regmap_update_bits(info->regmap, AXP813_ADC_RATE,
617 				 AXP813_ADC_RATE_MASK,
618 				 AXP813_ADC_RATE_HZ(rate));
619 }
620 
621 struct axp_data {
622 	const struct iio_info		*iio_info;
623 	int				num_channels;
624 	struct iio_chan_spec const	*channels;
625 	unsigned long			adc_en1_mask;
626 	unsigned long			adc_en2_mask;
627 	int				(*adc_rate)(struct axp20x_adc_iio *info,
628 						    int rate);
629 	struct iio_map			*maps;
630 };
631 
632 static const struct axp_data axp20x_data = {
633 	.iio_info = &axp20x_adc_iio_info,
634 	.num_channels = ARRAY_SIZE(axp20x_adc_channels),
635 	.channels = axp20x_adc_channels,
636 	.adc_en1_mask = AXP20X_ADC_EN1_MASK,
637 	.adc_en2_mask = AXP20X_ADC_EN2_MASK,
638 	.adc_rate = axp20x_adc_rate,
639 	.maps = axp20x_maps,
640 };
641 
642 static const struct axp_data axp22x_data = {
643 	.iio_info = &axp22x_adc_iio_info,
644 	.num_channels = ARRAY_SIZE(axp22x_adc_channels),
645 	.channels = axp22x_adc_channels,
646 	.adc_en1_mask = AXP22X_ADC_EN1_MASK,
647 	.adc_rate = axp22x_adc_rate,
648 	.maps = axp22x_maps,
649 };
650 
651 static const struct axp_data axp813_data = {
652 	.iio_info = &axp813_adc_iio_info,
653 	.num_channels = ARRAY_SIZE(axp813_adc_channels),
654 	.channels = axp813_adc_channels,
655 	.adc_en1_mask = AXP22X_ADC_EN1_MASK,
656 	.adc_rate = axp813_adc_rate,
657 	.maps = axp22x_maps,
658 };
659 
660 static const struct of_device_id axp20x_adc_of_match[] = {
661 	{ .compatible = "x-powers,axp209-adc", .data = (void *)&axp20x_data, },
662 	{ .compatible = "x-powers,axp221-adc", .data = (void *)&axp22x_data, },
663 	{ .compatible = "x-powers,axp813-adc", .data = (void *)&axp813_data, },
664 	{ /* sentinel */ }
665 };
666 MODULE_DEVICE_TABLE(of, axp20x_adc_of_match);
667 
668 static const struct platform_device_id axp20x_adc_id_match[] = {
669 	{ .name = "axp20x-adc", .driver_data = (kernel_ulong_t)&axp20x_data, },
670 	{ .name = "axp22x-adc", .driver_data = (kernel_ulong_t)&axp22x_data, },
671 	{ .name = "axp813-adc", .driver_data = (kernel_ulong_t)&axp813_data, },
672 	{ /* sentinel */ },
673 };
674 MODULE_DEVICE_TABLE(platform, axp20x_adc_id_match);
675 
axp20x_probe(struct platform_device * pdev)676 static int axp20x_probe(struct platform_device *pdev)
677 {
678 	struct axp20x_adc_iio *info;
679 	struct iio_dev *indio_dev;
680 	struct axp20x_dev *axp20x_dev;
681 	int ret;
682 
683 	axp20x_dev = dev_get_drvdata(pdev->dev.parent);
684 
685 	indio_dev = devm_iio_device_alloc(&pdev->dev, sizeof(*info));
686 	if (!indio_dev)
687 		return -ENOMEM;
688 
689 	info = iio_priv(indio_dev);
690 	platform_set_drvdata(pdev, indio_dev);
691 
692 	info->regmap = axp20x_dev->regmap;
693 	indio_dev->modes = INDIO_DIRECT_MODE;
694 
695 	if (!dev_fwnode(&pdev->dev)) {
696 		const struct platform_device_id *id;
697 
698 		id = platform_get_device_id(pdev);
699 		info->data = (const struct axp_data *)id->driver_data;
700 	} else {
701 		struct device *dev = &pdev->dev;
702 
703 		info->data = device_get_match_data(dev);
704 	}
705 
706 	indio_dev->name = platform_get_device_id(pdev)->name;
707 	indio_dev->info = info->data->iio_info;
708 	indio_dev->num_channels = info->data->num_channels;
709 	indio_dev->channels = info->data->channels;
710 
711 	/* Enable the ADCs on IP */
712 	regmap_write(info->regmap, AXP20X_ADC_EN1, info->data->adc_en1_mask);
713 
714 	if (info->data->adc_en2_mask)
715 		regmap_update_bits(info->regmap, AXP20X_ADC_EN2,
716 				   info->data->adc_en2_mask,
717 				   info->data->adc_en2_mask);
718 
719 	/* Configure ADCs rate */
720 	info->data->adc_rate(info, 100);
721 
722 	ret = iio_map_array_register(indio_dev, info->data->maps);
723 	if (ret < 0) {
724 		dev_err(&pdev->dev, "failed to register IIO maps: %d\n", ret);
725 		goto fail_map;
726 	}
727 
728 	ret = iio_device_register(indio_dev);
729 	if (ret < 0) {
730 		dev_err(&pdev->dev, "could not register the device\n");
731 		goto fail_register;
732 	}
733 
734 	return 0;
735 
736 fail_register:
737 	iio_map_array_unregister(indio_dev);
738 
739 fail_map:
740 	regmap_write(info->regmap, AXP20X_ADC_EN1, 0);
741 
742 	if (info->data->adc_en2_mask)
743 		regmap_write(info->regmap, AXP20X_ADC_EN2, 0);
744 
745 	return ret;
746 }
747 
axp20x_remove(struct platform_device * pdev)748 static int axp20x_remove(struct platform_device *pdev)
749 {
750 	struct iio_dev *indio_dev = platform_get_drvdata(pdev);
751 	struct axp20x_adc_iio *info = iio_priv(indio_dev);
752 
753 	iio_device_unregister(indio_dev);
754 	iio_map_array_unregister(indio_dev);
755 
756 	regmap_write(info->regmap, AXP20X_ADC_EN1, 0);
757 
758 	if (info->data->adc_en2_mask)
759 		regmap_write(info->regmap, AXP20X_ADC_EN2, 0);
760 
761 	return 0;
762 }
763 
764 static struct platform_driver axp20x_adc_driver = {
765 	.driver = {
766 		.name = "axp20x-adc",
767 		.of_match_table = axp20x_adc_of_match,
768 	},
769 	.id_table = axp20x_adc_id_match,
770 	.probe = axp20x_probe,
771 	.remove = axp20x_remove,
772 };
773 
774 module_platform_driver(axp20x_adc_driver);
775 
776 MODULE_DESCRIPTION("ADC driver for AXP20X and AXP22X PMICs");
777 MODULE_AUTHOR("Quentin Schulz <quentin.schulz@free-electrons.com>");
778 MODULE_LICENSE("GPL");
779