]> git.sur5r.net Git - u-boot/blob - drivers/adc/adc-uclass.c
arm: imx6ul: Add Engicam GEAM6UL Starter Kit initial support
[u-boot] / drivers / adc / adc-uclass.c
1 /*
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
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);
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
366 static 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
387 static 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
404 UCLASS_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 };