2 * Copyright (C) 2015 Samsung Electronics
3 * Przemyslaw Marczak <p.marczak@samsung.com>
5 * SPDX-License-Identifier: GPL-2.0+
12 #include <dm/device-internal.h>
13 #include <dm/uclass-internal.h>
15 #include <power/regulator.h>
17 #define ADC_UCLASS_PLATDATA_SIZE sizeof(struct adc_uclass_platdata)
18 #define CHECK_NUMBER true
19 #define CHECK_MASK (!CHECK_NUMBER)
21 /* TODO: add support for timer uclass (for early calls) */
22 #ifdef CONFIG_SANDBOX_ARCH
23 #define sdelay(x) udelay(x)
25 extern void sdelay(unsigned long loops);
28 static int check_channel(struct udevice *dev, int value, bool number_or_mask,
29 const char *caller_function)
31 struct adc_uclass_platdata *uc_pdata = dev_get_uclass_platdata(dev);
32 unsigned mask = number_or_mask ? (1 << value) : value;
34 /* For the real ADC hardware, some ADC channels can be inactive.
35 * For example if device has 4 analog channels, and only channels
36 * 1-st and 3-rd are valid, then channel mask is: 0b1010, so request
37 * with mask 0b1110 should return an error.
39 if ((uc_pdata->channel_mask >= mask) && (uc_pdata->channel_mask & mask))
42 printf("Error in %s/%s().\nWrong channel selection for device: %s\n",
43 __FILE__, caller_function, dev->name);
48 static int adc_supply_enable(struct udevice *dev)
50 struct adc_uclass_platdata *uc_pdata = dev_get_uclass_platdata(dev);
51 const char *supply_type;
54 if (uc_pdata->vdd_supply) {
56 ret = regulator_set_enable(uc_pdata->vdd_supply, true);
59 if (!ret && uc_pdata->vss_supply) {
61 ret = regulator_set_enable(uc_pdata->vss_supply, true);
65 pr_err("%s: can't enable %s-supply!", dev->name, supply_type);
70 int adc_data_mask(struct udevice *dev, unsigned int *data_mask)
72 struct adc_uclass_platdata *uc_pdata = dev_get_uclass_platdata(dev);
77 *data_mask = uc_pdata->data_mask;
81 int adc_stop(struct udevice *dev)
83 const struct adc_ops *ops = dev_get_driver_ops(dev);
88 return ops->stop(dev);
91 int adc_start_channel(struct udevice *dev, int channel)
93 const struct adc_ops *ops = dev_get_driver_ops(dev);
96 if (!ops->start_channel)
99 ret = check_channel(dev, channel, CHECK_NUMBER, __func__);
103 ret = adc_supply_enable(dev);
107 return ops->start_channel(dev, channel);
110 int adc_start_channels(struct udevice *dev, unsigned int channel_mask)
112 const struct adc_ops *ops = dev_get_driver_ops(dev);
115 if (!ops->start_channels)
118 ret = check_channel(dev, channel_mask, CHECK_MASK, __func__);
122 ret = adc_supply_enable(dev);
126 return ops->start_channels(dev, channel_mask);
129 int adc_channel_data(struct udevice *dev, int channel, unsigned int *data)
131 struct adc_uclass_platdata *uc_pdata = dev_get_uclass_platdata(dev);
132 const struct adc_ops *ops = dev_get_driver_ops(dev);
133 unsigned int timeout_us = uc_pdata->data_timeout_us;
136 if (!ops->channel_data)
139 ret = check_channel(dev, channel, CHECK_NUMBER, __func__);
144 ret = ops->channel_data(dev, channel, data);
145 if (!ret || ret != -EBUSY)
148 /* TODO: use timer uclass (for early calls). */
150 } while (timeout_us--);
155 int adc_channels_data(struct udevice *dev, unsigned int channel_mask,
156 struct adc_channel *channels)
158 struct adc_uclass_platdata *uc_pdata = dev_get_uclass_platdata(dev);
159 unsigned int timeout_us = uc_pdata->multidata_timeout_us;
160 const struct adc_ops *ops = dev_get_driver_ops(dev);
163 if (!ops->channels_data)
166 ret = check_channel(dev, channel_mask, CHECK_MASK, __func__);
171 ret = ops->channels_data(dev, channel_mask, channels);
172 if (!ret || ret != -EBUSY)
175 /* TODO: use timer uclass (for early calls). */
177 } while (timeout_us--);
182 int adc_channel_single_shot(const char *name, int channel, unsigned int *data)
187 ret = uclass_get_device_by_name(UCLASS_ADC, name, &dev);
191 ret = adc_start_channel(dev, channel);
195 ret = adc_channel_data(dev, channel, data);
202 static int _adc_channels_single_shot(struct udevice *dev,
203 unsigned int channel_mask,
204 struct adc_channel *channels)
209 for (channel = 0; channel <= ADC_MAX_CHANNEL; channel++) {
210 /* Check channel bit. */
211 if (!((channel_mask >> channel) & 0x1))
214 ret = adc_start_channel(dev, channel);
218 ret = adc_channel_data(dev, channel, &data);
222 channels->id = channel;
223 channels->data = data;
230 int adc_channels_single_shot(const char *name, unsigned int channel_mask,
231 struct adc_channel *channels)
236 ret = uclass_get_device_by_name(UCLASS_ADC, name, &dev);
240 ret = adc_start_channels(dev, channel_mask);
244 ret = adc_channels_data(dev, channel_mask, channels);
254 return _adc_channels_single_shot(dev, channel_mask, channels);
257 static int adc_vdd_platdata_update(struct udevice *dev)
259 struct adc_uclass_platdata *uc_pdata = dev_get_uclass_platdata(dev);
263 * This function can't return supply device before its bind.
264 * Please pay attention to proper fdt scan sequence. If ADC device
265 * will bind before its supply regulator device, then the below 'get'
266 * will return an error.
268 ret = device_get_supply_regulator(dev, "vdd-supply",
269 &uc_pdata->vdd_supply);
273 ret = regulator_get_value(uc_pdata->vdd_supply);
277 uc_pdata->vdd_microvolts = ret;
282 static int adc_vss_platdata_update(struct udevice *dev)
284 struct adc_uclass_platdata *uc_pdata = dev_get_uclass_platdata(dev);
287 ret = device_get_supply_regulator(dev, "vss-supply",
288 &uc_pdata->vss_supply);
292 ret = regulator_get_value(uc_pdata->vss_supply);
296 uc_pdata->vss_microvolts = ret;
301 int adc_vdd_value(struct udevice *dev, int *uV)
303 struct adc_uclass_platdata *uc_pdata = dev_get_uclass_platdata(dev);
304 int ret, value_sign = uc_pdata->vdd_polarity_negative ? -1 : 1;
306 if (!uc_pdata->vdd_supply)
309 /* Update the regulator Value. */
310 ret = adc_vdd_platdata_update(dev);
314 if (uc_pdata->vdd_microvolts == -ENODATA)
317 *uV = uc_pdata->vdd_microvolts * value_sign;
322 int adc_vss_value(struct udevice *dev, int *uV)
324 struct adc_uclass_platdata *uc_pdata = dev_get_uclass_platdata(dev);
325 int ret, value_sign = uc_pdata->vss_polarity_negative ? -1 : 1;
327 if (!uc_pdata->vss_supply)
330 /* Update the regulator Value. */
331 ret = adc_vss_platdata_update(dev);
335 if (uc_pdata->vss_microvolts == -ENODATA)
338 *uV = uc_pdata->vss_microvolts * value_sign;
343 static int adc_vdd_platdata_set(struct udevice *dev)
345 struct adc_uclass_platdata *uc_pdata = dev_get_uclass_platdata(dev);
349 prop = "vdd-polarity-negative";
350 uc_pdata->vdd_polarity_negative = dev_read_bool(dev, prop);
352 ret = adc_vdd_platdata_update(dev);
356 /* No vdd-supply phandle. */
357 prop = "vdd-microvolts";
358 uc_pdata->vdd_microvolts = dev_read_u32_default(dev, prop, -ENODATA);
363 static int adc_vss_platdata_set(struct udevice *dev)
365 struct adc_uclass_platdata *uc_pdata = dev_get_uclass_platdata(dev);
369 prop = "vss-polarity-negative";
370 uc_pdata->vss_polarity_negative = dev_read_bool(dev, prop);
372 ret = adc_vss_platdata_update(dev);
376 /* No vss-supply phandle. */
377 prop = "vss-microvolts";
378 uc_pdata->vss_microvolts = dev_read_u32_default(dev, prop, -ENODATA);
383 static int adc_pre_probe(struct udevice *dev)
387 /* Set ADC VDD platdata: polarity, uV, regulator (phandle). */
388 ret = adc_vdd_platdata_set(dev);
390 pr_err("%s: Can't update Vdd. Error: %d", dev->name, ret);
392 /* Set ADC VSS platdata: polarity, uV, regulator (phandle). */
393 ret = adc_vss_platdata_set(dev);
395 pr_err("%s: Can't update Vss. Error: %d", dev->name, ret);
400 UCLASS_DRIVER(adc) = {
403 .pre_probe = adc_pre_probe,
404 .per_device_platdata_auto_alloc_size = ADC_UCLASS_PLATDATA_SIZE,