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