[u-boot.git] / drivers / adc / adc-uclass.c

// SPDX-License-Identifier: GPL-2.0+
/*
 * Copyright (C) 2015 Samsung Electronics
 * Przemyslaw Marczak <[email protected]>
 */

#include <common.h>
#include <errno.h>
#include <div64.h>
#include <dm.h>
#include <dm/lists.h>
#include <dm/device-internal.h>
#include <dm/uclass-internal.h>
#include <adc.h>
#include <linux/delay.h>
#include <power/regulator.h>

#define ADC_UCLASS_PLATDATA_SIZE	sizeof(struct adc_uclass_platdata)
#define CHECK_NUMBER			true
#define CHECK_MASK			(!CHECK_NUMBER)

/* TODO: add support for timer uclass (for early calls) */
#ifdef CONFIG_SANDBOX_ARCH
#define sdelay(x)	udelay(x)
#else
extern void sdelay(unsigned long loops);
#endif

static int check_channel(struct udevice *dev, int value, bool number_or_mask,
			 const char *caller_function)
{
	struct adc_uclass_platdata *uc_pdata = dev_get_uclass_platdata(dev);
	unsigned mask = number_or_mask ? (1 << value) : value;

	/* For the real ADC hardware, some ADC channels can be inactive.
	 * For example if device has 4 analog channels, and only channels
	 * 1-st and 3-rd are valid, then channel mask is: 0b1010, so request
	 * with mask 0b1110 should return an error.
	*/
	if ((uc_pdata->channel_mask >= mask) && (uc_pdata->channel_mask & mask))
		return 0;

	printf("Error in %s/%s().\nWrong channel selection for device: %s\n",
	       __FILE__, caller_function, dev->name);

	return -EINVAL;
}

static int adc_supply_enable(struct udevice *dev)
{
	struct adc_uclass_platdata *uc_pdata = dev_get_uclass_platdata(dev);
	const char *supply_type;
	int ret = 0;

	if (uc_pdata->vdd_supply) {
		supply_type = "vdd";
		ret = regulator_set_enable(uc_pdata->vdd_supply, true);
	}

	if (!ret && uc_pdata->vss_supply) {
		supply_type = "vss";
		ret = regulator_set_enable(uc_pdata->vss_supply, true);
	}

	if (ret)
		pr_err("%s: can't enable %s-supply!", dev->name, supply_type);

	return ret;
}

int adc_data_mask(struct udevice *dev, unsigned int *data_mask)
{
	struct adc_uclass_platdata *uc_pdata = dev_get_uclass_platdata(dev);

	if (!uc_pdata)
		return -ENOSYS;

	*data_mask = uc_pdata->data_mask;
	return 0;
}

int adc_channel_mask(struct udevice *dev, unsigned int *channel_mask)
{
	struct adc_uclass_platdata *uc_pdata = dev_get_uclass_platdata(dev);

	if (!uc_pdata)
		return -ENOSYS;

	*channel_mask = uc_pdata->channel_mask;

	return 0;
}

int adc_stop(struct udevice *dev)
{
	const struct adc_ops *ops = dev_get_driver_ops(dev);

	if (!ops->stop)
		return -ENOSYS;

	return ops->stop(dev);
}

int adc_start_channel(struct udevice *dev, int channel)
{
	const struct adc_ops *ops = dev_get_driver_ops(dev);
	int ret;

	if (!ops->start_channel)
		return -ENOSYS;

	ret = check_channel(dev, channel, CHECK_NUMBER, __func__);
	if (ret)
		return ret;

	ret = adc_supply_enable(dev);
	if (ret)
		return ret;

	return ops->start_channel(dev, channel);
}

int adc_start_channels(struct udevice *dev, unsigned int channel_mask)
{
	const struct adc_ops *ops = dev_get_driver_ops(dev);
	int ret;

	if (!ops->start_channels)
		return -ENOSYS;

	ret = check_channel(dev, channel_mask, CHECK_MASK, __func__);
	if (ret)
		return ret;

	ret = adc_supply_enable(dev);
	if (ret)
		return ret;

	return ops->start_channels(dev, channel_mask);
}

int adc_channel_data(struct udevice *dev, int channel, unsigned int *data)
{
	struct adc_uclass_platdata *uc_pdata = dev_get_uclass_platdata(dev);
	const struct adc_ops *ops = dev_get_driver_ops(dev);
	unsigned int timeout_us = uc_pdata->data_timeout_us;
	int ret;

	if (!ops->channel_data)
		return -ENOSYS;

	ret = check_channel(dev, channel, CHECK_NUMBER, __func__);
	if (ret)
		return ret;

	do {
		ret = ops->channel_data(dev, channel, data);
		if (!ret || ret != -EBUSY)
			break;

		/* TODO: use timer uclass (for early calls). */
		sdelay(5);
	} while (timeout_us--);

	return ret;
}

int adc_channels_data(struct udevice *dev, unsigned int channel_mask,
		      struct adc_channel *channels)
{
	struct adc_uclass_platdata *uc_pdata = dev_get_uclass_platdata(dev);
	unsigned int timeout_us = uc_pdata->multidata_timeout_us;
	const struct adc_ops *ops = dev_get_driver_ops(dev);
	int ret;

	if (!ops->channels_data)
		return -ENOSYS;

	ret = check_channel(dev, channel_mask, CHECK_MASK, __func__);
	if (ret)
		return ret;

	do {
		ret = ops->channels_data(dev, channel_mask, channels);
		if (!ret || ret != -EBUSY)
			break;

		/* TODO: use timer uclass (for early calls). */
		sdelay(5);
	} while (timeout_us--);

	return ret;
}

int adc_channel_single_shot(const char *name, int channel, unsigned int *data)
{
	struct udevice *dev;
	int ret;

	ret = uclass_get_device_by_name(UCLASS_ADC, name, &dev);
	if (ret)
		return ret;

	ret = adc_start_channel(dev, channel);
	if (ret)
		return ret;

	ret = adc_channel_data(dev, channel, data);
	if (ret)
		return ret;

	return 0;
}

static int _adc_channels_single_shot(struct udevice *dev,
				     unsigned int channel_mask,
				     struct adc_channel *channels)
{
	unsigned int data;
	int channel, ret;

	for (channel = 0; channel <= ADC_MAX_CHANNEL; channel++) {
		/* Check channel bit. */
		if (!((channel_mask >> channel) & 0x1))
			continue;

		ret = adc_start_channel(dev, channel);
		if (ret)
			return ret;

		ret = adc_channel_data(dev, channel, &data);
		if (ret)
			return ret;

		channels->id = channel;
		channels->data = data;
		channels++;
	}

	return 0;
}

int adc_channels_single_shot(const char *name, unsigned int channel_mask,
			     struct adc_channel *channels)
{
	struct udevice *dev;
	int ret;

	ret = uclass_get_device_by_name(UCLASS_ADC, name, &dev);
	if (ret)
		return ret;

	ret = adc_start_channels(dev, channel_mask);
	if (ret)
		goto try_manual;

	ret = adc_channels_data(dev, channel_mask, channels);
	if (ret)
		return ret;

	return 0;

try_manual:
	if (ret != -ENOSYS)
		return ret;

	return _adc_channels_single_shot(dev, channel_mask, channels);
}

static int adc_vdd_platdata_update(struct udevice *dev)
{
	struct adc_uclass_platdata *uc_pdata = dev_get_uclass_platdata(dev);
	int ret;

	/* Warning!
	 * This function can't return supply device before its bind.
	 * Please pay attention to proper fdt scan sequence. If ADC device
	 * will bind before its supply regulator device, then the below 'get'
	 * will return an error.
	 */
	if (!uc_pdata->vdd_supply)
		return 0;

	ret = regulator_get_value(uc_pdata->vdd_supply);
	if (ret < 0)
		return ret;

	uc_pdata->vdd_microvolts = ret;

	return 0;
}

static int adc_vss_platdata_update(struct udevice *dev)
{
	struct adc_uclass_platdata *uc_pdata = dev_get_uclass_platdata(dev);
	int ret;

	if (!uc_pdata->vss_supply)
		return 0;

	ret = regulator_get_value(uc_pdata->vss_supply);
	if (ret < 0)
		return ret;

	uc_pdata->vss_microvolts = ret;

	return 0;
}

int adc_vdd_value(struct udevice *dev, int *uV)
{
	struct adc_uclass_platdata *uc_pdata = dev_get_uclass_platdata(dev);
	int ret, value_sign = uc_pdata->vdd_polarity_negative ? -1 : 1;

	/* Update the regulator Value. */
	ret = adc_vdd_platdata_update(dev);
	if (ret)
		return ret;

	if (uc_pdata->vdd_microvolts == -ENODATA)
		return -ENODATA;

	*uV = uc_pdata->vdd_microvolts * value_sign;

	return 0;
}

int adc_vss_value(struct udevice *dev, int *uV)
{
	struct adc_uclass_platdata *uc_pdata = dev_get_uclass_platdata(dev);
	int ret, value_sign = uc_pdata->vss_polarity_negative ? -1 : 1;

	/* Update the regulator Value. */
	ret = adc_vss_platdata_update(dev);
	if (ret)
		return ret;

	if (uc_pdata->vss_microvolts == -ENODATA)
		return -ENODATA;

	*uV = uc_pdata->vss_microvolts * value_sign;

	return 0;
}

int adc_raw_to_uV(struct udevice *dev, unsigned int raw, int *uV)
{
	unsigned int data_mask;
	int ret, val, vref;
	u64 raw64 = raw;

	ret = adc_vdd_value(dev, &vref);
	if (ret)
		return ret;

	if (!adc_vss_value(dev, &val))
		vref -= val;

	ret = adc_data_mask(dev, &data_mask);
	if (ret)
		return ret;

	raw64 *= vref;
	do_div(raw64, data_mask);
	*uV = raw64;

	return 0;
}

static int adc_vdd_platdata_set(struct udevice *dev)
{
	struct adc_uclass_platdata *uc_pdata = dev_get_uclass_platdata(dev);
	int ret;
	char *prop;

	prop = "vdd-polarity-negative";
	uc_pdata->vdd_polarity_negative = dev_read_bool(dev, prop);

	/* Optionally get regulators */
	ret = device_get_supply_regulator(dev, "vdd-supply",
					  &uc_pdata->vdd_supply);
	if (!ret)
		return adc_vdd_platdata_update(dev);

	if (ret != -ENOENT)
		return ret;

	/* No vdd-supply phandle. */
	prop  = "vdd-microvolts";
	uc_pdata->vdd_microvolts = dev_read_u32_default(dev, prop, -ENODATA);

	return 0;
}

static int adc_vss_platdata_set(struct udevice *dev)
{
	struct adc_uclass_platdata *uc_pdata = dev_get_uclass_platdata(dev);
	int ret;
	char *prop;

	prop = "vss-polarity-negative";
	uc_pdata->vss_polarity_negative = dev_read_bool(dev, prop);

	ret = device_get_supply_regulator(dev, "vss-supply",
					  &uc_pdata->vss_supply);
	if (!ret)
		return adc_vss_platdata_update(dev);

	if (ret != -ENOENT)
		return ret;

	/* No vss-supply phandle. */
	prop = "vss-microvolts";
	uc_pdata->vss_microvolts = dev_read_u32_default(dev, prop, -ENODATA);

	return 0;
}

static int adc_pre_probe(struct udevice *dev)
{
	int ret;

	/* Set ADC VDD platdata: polarity, uV, regulator (phandle). */
	ret = adc_vdd_platdata_set(dev);
	if (ret)
		pr_err("%s: Can't update Vdd. Error: %d", dev->name, ret);

	/* Set ADC VSS platdata: polarity, uV, regulator (phandle). */
	ret = adc_vss_platdata_set(dev);
	if (ret)
		pr_err("%s: Can't update Vss. Error: %d", dev->name, ret);

	return 0;
}

UCLASS_DRIVER(adc) = {
	.id	= UCLASS_ADC,
	.name	= "adc",
	.pre_probe =  adc_pre_probe,
	.per_device_platdata_auto	= ADC_UCLASS_PLATDATA_SIZE,
};
Commit	Line	Data
83d290c5	1	// SPDX-License-Identifier: GPL-2.0+
5decbf53 PM	2	/*
	3	* Copyright (C) 2015 Samsung Electronics
	4	* Przemyslaw Marczak <[email protected]>
5decbf53 PM	5	*/
	6
	7	#include <common.h>
	8	#include <errno.h>
63f004e7	9	#include <div64.h>
5decbf53 PM	10	#include <dm.h>
	11	#include <dm/lists.h>
	12	#include <dm/device-internal.h>
	13	#include <dm/uclass-internal.h>
	14	#include <adc.h>
c05ed00a	15	#include <linux/delay.h>
5decbf53 PM	16	#include <power/regulator.h>
5decbf53 PM	17
5decbf53 PM	18	#define ADC_UCLASS_PLATDATA_SIZE sizeof(struct adc_uclass_platdata)
	19	#define CHECK_NUMBER true
	20	#define CHECK_MASK (!CHECK_NUMBER)
	21
	22	/* TODO: add support for timer uclass (for early calls) */
	23	#ifdef CONFIG_SANDBOX_ARCH
	24	#define sdelay(x) udelay(x)
	25	#else
	26	extern void sdelay(unsigned long loops);
	27	#endif
	28
	29	static int check_channel(struct udevice *dev, int value, bool number_or_mask,
	30	const char *caller_function)
	31	{
	32	struct adc_uclass_platdata *uc_pdata = dev_get_uclass_platdata(dev);
	33	unsigned mask = number_or_mask ? (1 << value) : value;
	34
	35	/* For the real ADC hardware, some ADC channels can be inactive.
	36	* For example if device has 4 analog channels, and only channels
	37	* 1-st and 3-rd are valid, then channel mask is: 0b1010, so request
	38	* with mask 0b1110 should return an error.
	39	*/
	40	if ((uc_pdata->channel_mask >= mask) && (uc_pdata->channel_mask & mask))
	41	return 0;
	42
	43	printf("Error in %s/%s().\nWrong channel selection for device: %s\n",
	44	__FILE__, caller_function, dev->name);
	45
	46	return -EINVAL;
	47	}
	48
	49	static int adc_supply_enable(struct udevice *dev)
	50	{
	51	struct adc_uclass_platdata *uc_pdata = dev_get_uclass_platdata(dev);
	52	const char *supply_type;
	53	int ret = 0;
	54
	55	if (uc_pdata->vdd_supply) {
	56	supply_type = "vdd";
	57	ret = regulator_set_enable(uc_pdata->vdd_supply, true);
	58	}
	59
	60	if (!ret && uc_pdata->vss_supply) {
	61	supply_type = "vss";
	62	ret = regulator_set_enable(uc_pdata->vss_supply, true);
	63	}
	64
	65	if (ret)
9b643e31	66	pr_err("%s: can't enable %s-supply!", dev->name, supply_type);
5decbf53 PM	67
	68	return ret;
	69	}
	70
	71	int adc_data_mask(struct udevice dev, unsigned int data_mask)
	72	{
	73	struct adc_uclass_platdata *uc_pdata = dev_get_uclass_platdata(dev);
	74
	75	if (!uc_pdata)
	76	return -ENOSYS;
	77
	78	*data_mask = uc_pdata->data_mask;
	79	return 0;
	80	}
	81
63f004e7 FG	82	int adc_channel_mask(struct udevice dev, unsigned int channel_mask)
	83	{
	84	struct adc_uclass_platdata *uc_pdata = dev_get_uclass_platdata(dev);
	85
	86	if (!uc_pdata)
	87	return -ENOSYS;
	88
	89	*channel_mask = uc_pdata->channel_mask;
	90
	91	return 0;
	92	}
	93
5decbf53 PM	94	int adc_stop(struct udevice *dev)
	95	{
	96	const struct adc_ops *ops = dev_get_driver_ops(dev);
	97
	98	if (!ops->stop)
	99	return -ENOSYS;
	100
	101	return ops->stop(dev);
	102	}
	103
	104	int adc_start_channel(struct udevice *dev, int channel)
	105	{
	106	const struct adc_ops *ops = dev_get_driver_ops(dev);
	107	int ret;
	108
	109	if (!ops->start_channel)
	110	return -ENOSYS;
	111
	112	ret = check_channel(dev, channel, CHECK_NUMBER, __func__);
	113	if (ret)
	114	return ret;
	115
	116	ret = adc_supply_enable(dev);
	117	if (ret)
	118	return ret;
	119
	120	return ops->start_channel(dev, channel);
	121	}
	122
	123	int adc_start_channels(struct udevice *dev, unsigned int channel_mask)
	124	{
	125	const struct adc_ops *ops = dev_get_driver_ops(dev);
	126	int ret;
	127
	128	if (!ops->start_channels)
	129	return -ENOSYS;
	130
	131	ret = check_channel(dev, channel_mask, CHECK_MASK, __func__);
	132	if (ret)
	133	return ret;
	134
	135	ret = adc_supply_enable(dev);
	136	if (ret)
	137	return ret;
	138
	139	return ops->start_channels(dev, channel_mask);
	140	}
	141
	142	int adc_channel_data(struct udevice dev, int channel, unsigned int data)
	143	{
	144	struct adc_uclass_platdata *uc_pdata = dev_get_uclass_platdata(dev);
	145	const struct adc_ops *ops = dev_get_driver_ops(dev);
	146	unsigned int timeout_us = uc_pdata->data_timeout_us;
	147	int ret;
	148
	149	if (!ops->channel_data)
	150	return -ENOSYS;
	151
	152	ret = check_channel(dev, channel, CHECK_NUMBER, __func__);
	153	if (ret)
	154	return ret;
	155
	156	do {
	157	ret = ops->channel_data(dev, channel, data);
158	if (!ret \|\| ret != -EBUSY)
159	break;
160
161	/* TODO: use timer uclass (for early calls). */
162	sdelay(5);
163	} while (timeout_us--);
164
165	return ret;
166	}
167
168	int adc_channels_data(struct udevice *dev, unsigned int channel_mask,
169	struct adc_channel *channels)
170	{
171	struct adc_uclass_platdata *uc_pdata = dev_get_uclass_platdata(dev);
172	unsigned int timeout_us = uc_pdata->multidata_timeout_us;
173	const struct adc_ops *ops = dev_get_driver_ops(dev);
174	int ret;
175
176	if (!ops->channels_data)
177	return -ENOSYS;
178
179	ret = check_channel(dev, channel_mask, CHECK_MASK, __func__);
180	if (ret)
181	return ret;
182
183	do {
184	ret = ops->channels_data(dev, channel_mask, channels);
185	if (!ret \|\| ret != -EBUSY)
186	break;
187
188	/* TODO: use timer uclass (for early calls). */
189	sdelay(5);
190	} while (timeout_us--);
191
192	return ret;
193	}
194
195	int adc_channel_single_shot(const char name, int channel, unsigned int data)
196	{
197	struct udevice *dev;
198	int ret;
199
200	ret = uclass_get_device_by_name(UCLASS_ADC, name, &dev);
201	if (ret)
202	return ret;
203
204	ret = adc_start_channel(dev, channel);
205	if (ret)
206	return ret;
207
208	ret = adc_channel_data(dev, channel, data);
209	if (ret)
210	return ret;
211
212	return 0;
213	}
214
215	static int _adc_channels_single_shot(struct udevice *dev,
216	unsigned int channel_mask,
217	struct adc_channel *channels)
218	{
219	unsigned int data;
220	int channel, ret;
221
222	for (channel = 0; channel <= ADC_MAX_CHANNEL; channel++) {
223	/* Check channel bit. */
224	if (!((channel_mask >> channel) & 0x1))
225	continue;
226
227	ret = adc_start_channel(dev, channel);
228	if (ret)
229	return ret;
230
231	ret = adc_channel_data(dev, channel, &data);
232	if (ret)
233	return ret;
234
235	channels->id = channel;
236	channels->data = data;
237	channels++;
238	}
239
240	return 0;
241	}
242
243	int adc_channels_single_shot(const char *name, unsigned int channel_mask,
244	struct adc_channel *channels)
245	{
246	struct udevice *dev;
247	int ret;
248
249	ret = uclass_get_device_by_name(UCLASS_ADC, name, &dev);
250	if (ret)
251	return ret;
252
253	ret = adc_start_channels(dev, channel_mask);
254	if (ret)
255	goto try_manual;
256
257	ret = adc_channels_data(dev, channel_mask, channels);
258	if (ret)
259	return ret;
260
261	return 0;
262
263	try_manual:
264	if (ret != -ENOSYS)
265	return ret;
266
267	return _adc_channels_single_shot(dev, channel_mask, channels);
268	}
269
270	static int adc_vdd_platdata_update(struct udevice *dev)
271	{
272	struct adc_uclass_platdata *uc_pdata = dev_get_uclass_platdata(dev);
273	int ret;
274
275	/* Warning!
276	* This function can't return supply device before its bind.
277	* Please pay attention to proper fdt scan sequence. If ADC device
278	* will bind before its supply regulator device, then the below 'get'
279	* will return an error.
280	*/
a4a87f7b FG	281	if (!uc_pdata->vdd_supply)
a4a87f7b FG	282	return 0;
5decbf53 PM	283
	284	ret = regulator_get_value(uc_pdata->vdd_supply);
	285	if (ret < 0)
	286	return ret;
	287
	288	uc_pdata->vdd_microvolts = ret;
	289
	290	return 0;
	291	}
	292
	293	static int adc_vss_platdata_update(struct udevice *dev)
	294	{
	295	struct adc_uclass_platdata *uc_pdata = dev_get_uclass_platdata(dev);
	296	int ret;
	297
a4a87f7b FG	298	if (!uc_pdata->vss_supply)
a4a87f7b FG	299	return 0;
5decbf53 PM	300
	301	ret = regulator_get_value(uc_pdata->vss_supply);
	302	if (ret < 0)
	303	return ret;
	304
	305	uc_pdata->vss_microvolts = ret;
	306
	307	return 0;
	308	}
	309
	310	int adc_vdd_value(struct udevice dev, int uV)
	311	{
	312	struct adc_uclass_platdata *uc_pdata = dev_get_uclass_platdata(dev);
	313	int ret, value_sign = uc_pdata->vdd_polarity_negative ? -1 : 1;
	314
5decbf53 PM	315	/* Update the regulator Value. */
	316	ret = adc_vdd_platdata_update(dev);
	317	if (ret)
	318	return ret;
a4a87f7b	319
5decbf53 PM	320	if (uc_pdata->vdd_microvolts == -ENODATA)
	321	return -ENODATA;
	322
	323	uV = uc_pdata->vdd_microvolts value_sign;
	324
	325	return 0;
	326	}
	327
	328	int adc_vss_value(struct udevice dev, int uV)
	329	{
	330	struct adc_uclass_platdata *uc_pdata = dev_get_uclass_platdata(dev);
	331	int ret, value_sign = uc_pdata->vss_polarity_negative ? -1 : 1;
	332
5decbf53 PM	333	/* Update the regulator Value. */
	334	ret = adc_vss_platdata_update(dev);
	335	if (ret)
	336	return ret;
a4a87f7b	337
5decbf53 PM	338	if (uc_pdata->vss_microvolts == -ENODATA)
	339	return -ENODATA;
	340
	341	uV = uc_pdata->vss_microvolts value_sign;
	342
	343	return 0;
	344	}
	345
63f004e7 FG	346	int adc_raw_to_uV(struct udevice dev, unsigned int raw, int uV)
	347	{
	348	unsigned int data_mask;
	349	int ret, val, vref;
	350	u64 raw64 = raw;
	351
	352	ret = adc_vdd_value(dev, &vref);
	353	if (ret)
	354	return ret;
	355
	356	if (!adc_vss_value(dev, &val))
	357	vref -= val;
	358
	359	ret = adc_data_mask(dev, &data_mask);
	360	if (ret)
	361	return ret;
	362
	363	raw64 *= vref;
	364	do_div(raw64, data_mask);
	365	*uV = raw64;
	366
	367	return 0;
	368	}
	369
5decbf53 PM	370	static int adc_vdd_platdata_set(struct udevice *dev)
	371	{
	372	struct adc_uclass_platdata *uc_pdata = dev_get_uclass_platdata(dev);
53d788d8	373	int ret;
5decbf53 PM	374	char *prop;
	375
	376	prop = "vdd-polarity-negative";
53d788d8	377	uc_pdata->vdd_polarity_negative = dev_read_bool(dev, prop);
5decbf53	378
a4a87f7b FG	379	/* Optionally get regulators */
	380	ret = device_get_supply_regulator(dev, "vdd-supply",
	381	&uc_pdata->vdd_supply);
	382	if (!ret)
	383	return adc_vdd_platdata_update(dev);
	384
5decbf53 PM	385	if (ret != -ENOENT)
	386	return ret;
	387
	388	/* No vdd-supply phandle. */
	389	prop = "vdd-microvolts";
53d788d8	390	uc_pdata->vdd_microvolts = dev_read_u32_default(dev, prop, -ENODATA);
5decbf53 PM	391
	392	return 0;
	393	}
	394
	395	static int adc_vss_platdata_set(struct udevice *dev)
	396	{
	397	struct adc_uclass_platdata *uc_pdata = dev_get_uclass_platdata(dev);
53d788d8	398	int ret;
5decbf53 PM	399	char *prop;
	400
	401	prop = "vss-polarity-negative";
53d788d8	402	uc_pdata->vss_polarity_negative = dev_read_bool(dev, prop);
5decbf53	403
a4a87f7b FG	404	ret = device_get_supply_regulator(dev, "vss-supply",
	405	&uc_pdata->vss_supply);
	406	if (!ret)
	407	return adc_vss_platdata_update(dev);
	408
5decbf53 PM	409	if (ret != -ENOENT)
	410	return ret;
	411
	412	/* No vss-supply phandle. */
	413	prop = "vss-microvolts";
53d788d8	414	uc_pdata->vss_microvolts = dev_read_u32_default(dev, prop, -ENODATA);
5decbf53 PM	415
	416	return 0;
	417	}
	418
	419	static int adc_pre_probe(struct udevice *dev)
	420	{
	421	int ret;
	422
	423	/* Set ADC VDD platdata: polarity, uV, regulator (phandle). */
	424	ret = adc_vdd_platdata_set(dev);
	425	if (ret)
9b643e31	426	pr_err("%s: Can't update Vdd. Error: %d", dev->name, ret);
5decbf53 PM	427
	428	/* Set ADC VSS platdata: polarity, uV, regulator (phandle). */
	429	ret = adc_vss_platdata_set(dev);
	430	if (ret)
9b643e31	431	pr_err("%s: Can't update Vss. Error: %d", dev->name, ret);
5decbf53 PM	432
	433	return 0;
	434	}
	435
	436	UCLASS_DRIVER(adc) = {
	437	.id = UCLASS_ADC,
	438	.name = "adc",
	439	.pre_probe = adc_pre_probe,
41575d8e	440	.per_device_platdata_auto = ADC_UCLASS_PLATDATA_SIZE,
5decbf53	441	};