blob: 9233fcdb6c1edb67befd534b681c0db80c26024b [file] [log] [blame]
Przemyslaw Marczak5decbf52015-10-27 13:08:00 +01001/*
2 * Copyright (C) 2015 Samsung Electronics
3 * Przemyslaw Marczak <p.marczak@samsung.com>
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
17DECLARE_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
27extern void sdelay(unsigned long loops);
28#endif
29
30static 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
50static 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
72int 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
83int 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
93int 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
112int 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
131int 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
157int 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
184int 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
204static 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
232int 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
252try_manual:
253 if (ret != -ENOSYS)
254 return ret;
255
256 return _adc_channels_single_shot(dev, channel_mask, channels);
257}
258
259static 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
284static 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
303int 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;
315nodev:
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
324int 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;
336nodev:
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
345static int adc_vdd_platdata_set(struct udevice *dev)
346{
347 struct adc_uclass_platdata *uc_pdata = dev_get_uclass_platdata(dev);
348 int ret, offset = dev->of_offset;
349 const void *fdt = gd->fdt_blob;
350 char *prop;
351
352 prop = "vdd-polarity-negative";
353 uc_pdata->vdd_polarity_negative = fdtdec_get_bool(fdt, offset, prop);
354
355 ret = adc_vdd_platdata_update(dev);
356 if (ret != -ENOENT)
357 return ret;
358
359 /* No vdd-supply phandle. */
360 prop = "vdd-microvolts";
361 uc_pdata->vdd_microvolts = fdtdec_get_int(fdt, offset, prop, -ENODATA);
362
363 return 0;
364}
365
366static int adc_vss_platdata_set(struct udevice *dev)
367{
368 struct adc_uclass_platdata *uc_pdata = dev_get_uclass_platdata(dev);
369 int ret, offset = dev->of_offset;
370 const void *fdt = gd->fdt_blob;
371 char *prop;
372
373 prop = "vss-polarity-negative";
374 uc_pdata->vss_polarity_negative = fdtdec_get_bool(fdt, offset, prop);
375
376 ret = adc_vss_platdata_update(dev);
377 if (ret != -ENOENT)
378 return ret;
379
380 /* No vss-supply phandle. */
381 prop = "vss-microvolts";
382 uc_pdata->vss_microvolts = fdtdec_get_int(fdt, offset, prop, -ENODATA);
383
384 return 0;
385}
386
387static int adc_pre_probe(struct udevice *dev)
388{
389 int ret;
390
391 /* Set ADC VDD platdata: polarity, uV, regulator (phandle). */
392 ret = adc_vdd_platdata_set(dev);
393 if (ret)
394 error("%s: Can't update Vdd. Error: %d", dev->name, ret);
395
396 /* Set ADC VSS platdata: polarity, uV, regulator (phandle). */
397 ret = adc_vss_platdata_set(dev);
398 if (ret)
399 error("%s: Can't update Vss. Error: %d", dev->name, ret);
400
401 return 0;
402}
403
404UCLASS_DRIVER(adc) = {
405 .id = UCLASS_ADC,
406 .name = "adc",
407 .pre_probe = adc_pre_probe,
408 .per_device_platdata_auto_alloc_size = ADC_UCLASS_PLATDATA_SIZE,
409};