GNU Linux-libre 4.19.314-gnu1
[releases.git] / drivers / iio / dac / ad5761.c
1 /*
2  * AD5721, AD5721R, AD5761, AD5761R, Voltage Output Digital to Analog Converter
3  *
4  * Copyright 2016 Qtechnology A/S
5  * 2016 Ricardo Ribalda <ricardo.ribalda@gmail.com>
6  *
7  * Licensed under the GPL-2.
8  */
9 #include <linux/kernel.h>
10 #include <linux/module.h>
11 #include <linux/spi/spi.h>
12 #include <linux/bitops.h>
13 #include <linux/iio/iio.h>
14 #include <linux/iio/sysfs.h>
15 #include <linux/regulator/consumer.h>
16 #include <linux/platform_data/ad5761.h>
17
18 #define AD5761_ADDR(addr)               ((addr & 0xf) << 16)
19 #define AD5761_ADDR_NOOP                0x0
20 #define AD5761_ADDR_DAC_WRITE           0x3
21 #define AD5761_ADDR_CTRL_WRITE_REG      0x4
22 #define AD5761_ADDR_SW_DATA_RESET       0x7
23 #define AD5761_ADDR_DAC_READ            0xb
24 #define AD5761_ADDR_CTRL_READ_REG       0xc
25 #define AD5761_ADDR_SW_FULL_RESET       0xf
26
27 #define AD5761_CTRL_USE_INTVREF         BIT(5)
28 #define AD5761_CTRL_ETS                 BIT(6)
29
30 /**
31  * struct ad5761_chip_info - chip specific information
32  * @int_vref:   Value of the internal reference voltage in mV - 0 if external
33  *              reference voltage is used
34  * @channel:    channel specification
35 */
36
37 struct ad5761_chip_info {
38         unsigned long int_vref;
39         const struct iio_chan_spec channel;
40 };
41
42 struct ad5761_range_params {
43         int m;
44         int c;
45 };
46
47 enum ad5761_supported_device_ids {
48         ID_AD5721,
49         ID_AD5721R,
50         ID_AD5761,
51         ID_AD5761R,
52 };
53
54 /**
55  * struct ad5761_state - driver instance specific data
56  * @spi:                spi_device
57  * @vref_reg:           reference voltage regulator
58  * @use_intref:         true when the internal voltage reference is used
59  * @vref:               actual voltage reference in mVolts
60  * @range:              output range mode used
61  * @data:               cache aligned spi buffer
62  */
63 struct ad5761_state {
64         struct spi_device               *spi;
65         struct regulator                *vref_reg;
66
67         bool use_intref;
68         int vref;
69         enum ad5761_voltage_range range;
70
71         /*
72          * DMA (thus cache coherency maintenance) requires the
73          * transfer buffers to live in their own cache lines.
74          */
75         union {
76                 __be32 d32;
77                 u8 d8[4];
78         } data[3] ____cacheline_aligned;
79 };
80
81 static const struct ad5761_range_params ad5761_range_params[] = {
82         [AD5761_VOLTAGE_RANGE_M10V_10V] = {
83                 .m = 80,
84                 .c = 40,
85         },
86         [AD5761_VOLTAGE_RANGE_0V_10V] = {
87                 .m = 40,
88                 .c = 0,
89         },
90         [AD5761_VOLTAGE_RANGE_M5V_5V] = {
91                 .m = 40,
92                 .c = 20,
93         },
94         [AD5761_VOLTAGE_RANGE_0V_5V] = {
95                 .m = 20,
96                 .c = 0,
97         },
98         [AD5761_VOLTAGE_RANGE_M2V5_7V5] = {
99                 .m = 40,
100                 .c = 10,
101         },
102         [AD5761_VOLTAGE_RANGE_M3V_3V] = {
103                 .m = 24,
104                 .c = 12,
105         },
106         [AD5761_VOLTAGE_RANGE_0V_16V] = {
107                 .m = 64,
108                 .c = 0,
109         },
110         [AD5761_VOLTAGE_RANGE_0V_20V] = {
111                 .m = 80,
112                 .c = 0,
113         },
114 };
115
116 static int _ad5761_spi_write(struct ad5761_state *st, u8 addr, u16 val)
117 {
118         st->data[0].d32 = cpu_to_be32(AD5761_ADDR(addr) | val);
119
120         return spi_write(st->spi, &st->data[0].d8[1], 3);
121 }
122
123 static int ad5761_spi_write(struct iio_dev *indio_dev, u8 addr, u16 val)
124 {
125         struct ad5761_state *st = iio_priv(indio_dev);
126         int ret;
127
128         mutex_lock(&indio_dev->mlock);
129         ret = _ad5761_spi_write(st, addr, val);
130         mutex_unlock(&indio_dev->mlock);
131
132         return ret;
133 }
134
135 static int _ad5761_spi_read(struct ad5761_state *st, u8 addr, u16 *val)
136 {
137         int ret;
138         struct spi_transfer xfers[] = {
139                 {
140                         .tx_buf = &st->data[0].d8[1],
141                         .bits_per_word = 8,
142                         .len = 3,
143                         .cs_change = true,
144                 }, {
145                         .tx_buf = &st->data[1].d8[1],
146                         .rx_buf = &st->data[2].d8[1],
147                         .bits_per_word = 8,
148                         .len = 3,
149                 },
150         };
151
152         st->data[0].d32 = cpu_to_be32(AD5761_ADDR(addr));
153         st->data[1].d32 = cpu_to_be32(AD5761_ADDR(AD5761_ADDR_NOOP));
154
155         ret = spi_sync_transfer(st->spi, xfers, ARRAY_SIZE(xfers));
156
157         *val = be32_to_cpu(st->data[2].d32);
158
159         return ret;
160 }
161
162 static int ad5761_spi_read(struct iio_dev *indio_dev, u8 addr, u16 *val)
163 {
164         struct ad5761_state *st = iio_priv(indio_dev);
165         int ret;
166
167         mutex_lock(&indio_dev->mlock);
168         ret = _ad5761_spi_read(st, addr, val);
169         mutex_unlock(&indio_dev->mlock);
170
171         return ret;
172 }
173
174 static int ad5761_spi_set_range(struct ad5761_state *st,
175                                 enum ad5761_voltage_range range)
176 {
177         u16 aux;
178         int ret;
179
180         aux = (range & 0x7) | AD5761_CTRL_ETS;
181
182         if (st->use_intref)
183                 aux |= AD5761_CTRL_USE_INTVREF;
184
185         ret = _ad5761_spi_write(st, AD5761_ADDR_SW_FULL_RESET, 0);
186         if (ret)
187                 return ret;
188
189         ret = _ad5761_spi_write(st, AD5761_ADDR_CTRL_WRITE_REG, aux);
190         if (ret)
191                 return ret;
192
193         st->range = range;
194
195         return 0;
196 }
197
198 static int ad5761_read_raw(struct iio_dev *indio_dev,
199                            struct iio_chan_spec const *chan,
200                            int *val,
201                            int *val2,
202                            long mask)
203 {
204         struct ad5761_state *st;
205         int ret;
206         u16 aux;
207
208         switch (mask) {
209         case IIO_CHAN_INFO_RAW:
210                 ret = ad5761_spi_read(indio_dev, AD5761_ADDR_DAC_READ, &aux);
211                 if (ret)
212                         return ret;
213                 *val = aux >> chan->scan_type.shift;
214                 return IIO_VAL_INT;
215         case IIO_CHAN_INFO_SCALE:
216                 st = iio_priv(indio_dev);
217                 *val = st->vref * ad5761_range_params[st->range].m;
218                 *val /= 10;
219                 *val2 = chan->scan_type.realbits;
220                 return IIO_VAL_FRACTIONAL_LOG2;
221         case IIO_CHAN_INFO_OFFSET:
222                 st = iio_priv(indio_dev);
223                 *val = -(1 << chan->scan_type.realbits);
224                 *val *= ad5761_range_params[st->range].c;
225                 *val /= ad5761_range_params[st->range].m;
226                 return IIO_VAL_INT;
227         default:
228                 return -EINVAL;
229         }
230 }
231
232 static int ad5761_write_raw(struct iio_dev *indio_dev,
233                             struct iio_chan_spec const *chan,
234                             int val,
235                             int val2,
236                             long mask)
237 {
238         u16 aux;
239
240         if (mask != IIO_CHAN_INFO_RAW)
241                 return -EINVAL;
242
243         if (val2 || (val << chan->scan_type.shift) > 0xffff || val < 0)
244                 return -EINVAL;
245
246         aux = val << chan->scan_type.shift;
247
248         return ad5761_spi_write(indio_dev, AD5761_ADDR_DAC_WRITE, aux);
249 }
250
251 static const struct iio_info ad5761_info = {
252         .read_raw = &ad5761_read_raw,
253         .write_raw = &ad5761_write_raw,
254 };
255
256 #define AD5761_CHAN(_bits) {                            \
257         .type = IIO_VOLTAGE,                            \
258         .output = 1,                                    \
259         .info_mask_separate = BIT(IIO_CHAN_INFO_RAW),   \
260         .info_mask_shared_by_type = BIT(IIO_CHAN_INFO_SCALE) |  \
261                 BIT(IIO_CHAN_INFO_OFFSET),              \
262         .scan_type = {                                  \
263                 .sign = 'u',                            \
264                 .realbits = (_bits),                    \
265                 .storagebits = 16,                      \
266                 .shift = 16 - (_bits),                  \
267         },                                              \
268 }
269
270 static const struct ad5761_chip_info ad5761_chip_infos[] = {
271         [ID_AD5721] = {
272                 .int_vref = 0,
273                 .channel = AD5761_CHAN(12),
274         },
275         [ID_AD5721R] = {
276                 .int_vref = 2500,
277                 .channel = AD5761_CHAN(12),
278         },
279         [ID_AD5761] = {
280                 .int_vref = 0,
281                 .channel = AD5761_CHAN(16),
282         },
283         [ID_AD5761R] = {
284                 .int_vref = 2500,
285                 .channel = AD5761_CHAN(16),
286         },
287 };
288
289 static int ad5761_get_vref(struct ad5761_state *st,
290                            const struct ad5761_chip_info *chip_info)
291 {
292         int ret;
293
294         st->vref_reg = devm_regulator_get_optional(&st->spi->dev, "vref");
295         if (PTR_ERR(st->vref_reg) == -ENODEV) {
296                 /* Use Internal regulator */
297                 if (!chip_info->int_vref) {
298                         dev_err(&st->spi->dev,
299                                 "Voltage reference not found\n");
300                         return -EIO;
301                 }
302
303                 st->use_intref = true;
304                 st->vref = chip_info->int_vref;
305                 return 0;
306         }
307
308         if (IS_ERR(st->vref_reg)) {
309                 dev_err(&st->spi->dev,
310                         "Error getting voltage reference regulator\n");
311                 return PTR_ERR(st->vref_reg);
312         }
313
314         ret = regulator_enable(st->vref_reg);
315         if (ret) {
316                 dev_err(&st->spi->dev,
317                          "Failed to enable voltage reference\n");
318                 return ret;
319         }
320
321         ret = regulator_get_voltage(st->vref_reg);
322         if (ret < 0) {
323                 dev_err(&st->spi->dev,
324                          "Failed to get voltage reference value\n");
325                 goto disable_regulator_vref;
326         }
327
328         if (ret < 2000000 || ret > 3000000) {
329                 dev_warn(&st->spi->dev,
330                          "Invalid external voltage ref. value %d uV\n", ret);
331                 ret = -EIO;
332                 goto disable_regulator_vref;
333         }
334
335         st->vref = ret / 1000;
336         st->use_intref = false;
337
338         return 0;
339
340 disable_regulator_vref:
341         regulator_disable(st->vref_reg);
342         st->vref_reg = NULL;
343         return ret;
344 }
345
346 static int ad5761_probe(struct spi_device *spi)
347 {
348         struct iio_dev *iio_dev;
349         struct ad5761_state *st;
350         int ret;
351         const struct ad5761_chip_info *chip_info =
352                 &ad5761_chip_infos[spi_get_device_id(spi)->driver_data];
353         enum ad5761_voltage_range voltage_range = AD5761_VOLTAGE_RANGE_0V_5V;
354         struct ad5761_platform_data *pdata = dev_get_platdata(&spi->dev);
355
356         iio_dev = devm_iio_device_alloc(&spi->dev, sizeof(*st));
357         if (!iio_dev)
358                 return -ENOMEM;
359
360         st = iio_priv(iio_dev);
361
362         st->spi = spi;
363         spi_set_drvdata(spi, iio_dev);
364
365         ret = ad5761_get_vref(st, chip_info);
366         if (ret)
367                 return ret;
368
369         if (pdata)
370                 voltage_range = pdata->voltage_range;
371
372         ret = ad5761_spi_set_range(st, voltage_range);
373         if (ret)
374                 goto disable_regulator_err;
375
376         iio_dev->dev.parent = &spi->dev;
377         iio_dev->info = &ad5761_info;
378         iio_dev->modes = INDIO_DIRECT_MODE;
379         iio_dev->channels = &chip_info->channel;
380         iio_dev->num_channels = 1;
381         iio_dev->name = spi_get_device_id(st->spi)->name;
382         ret = iio_device_register(iio_dev);
383         if (ret)
384                 goto disable_regulator_err;
385
386         return 0;
387
388 disable_regulator_err:
389         if (!IS_ERR_OR_NULL(st->vref_reg))
390                 regulator_disable(st->vref_reg);
391
392         return ret;
393 }
394
395 static int ad5761_remove(struct spi_device *spi)
396 {
397         struct iio_dev *iio_dev = spi_get_drvdata(spi);
398         struct ad5761_state *st = iio_priv(iio_dev);
399
400         iio_device_unregister(iio_dev);
401
402         if (!IS_ERR_OR_NULL(st->vref_reg))
403                 regulator_disable(st->vref_reg);
404
405         return 0;
406 }
407
408 static const struct spi_device_id ad5761_id[] = {
409         {"ad5721", ID_AD5721},
410         {"ad5721r", ID_AD5721R},
411         {"ad5761", ID_AD5761},
412         {"ad5761r", ID_AD5761R},
413         {}
414 };
415 MODULE_DEVICE_TABLE(spi, ad5761_id);
416
417 static struct spi_driver ad5761_driver = {
418         .driver = {
419                    .name = "ad5761",
420                    },
421         .probe = ad5761_probe,
422         .remove = ad5761_remove,
423         .id_table = ad5761_id,
424 };
425 module_spi_driver(ad5761_driver);
426
427 MODULE_AUTHOR("Ricardo Ribalda <ricardo.ribalda@gmail.com>");
428 MODULE_DESCRIPTION("Analog Devices AD5721, AD5721R, AD5761, AD5761R driver");
429 MODULE_LICENSE("GPL v2");