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

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

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

DECLARE_GLOBAL_DATA_PTR;

#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)
		error("%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_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.
	 */
	ret = device_get_supply_regulator(dev, "vdd-supply",
					  &uc_pdata->vdd_supply);
	if (ret)
		return ret;

	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;

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

	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;

	if (!uc_pdata->vdd_supply)
		goto nodev;

	/* Update the regulator Value. */
	ret = adc_vdd_platdata_update(dev);
	if (ret)
		return ret;
nodev:
	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;

	if (!uc_pdata->vss_supply)
		goto nodev;

	/* Update the regulator Value. */
	ret = adc_vss_platdata_update(dev);
	if (ret)
		return ret;
nodev:
	if (uc_pdata->vss_microvolts == -ENODATA)
		return -ENODATA;

	*uV = uc_pdata->vss_microvolts * value_sign;

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

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