GNU Linux-libre 4.19.314-gnu1
[releases.git] / drivers / iio / dac / ad5758.c
1 // SPDX-License-Identifier: GPL-2.0+
2 /*
3  * AD5758 Digital to analog converters driver
4  *
5  * Copyright 2018 Analog Devices Inc.
6  *
7  * TODO: Currently CRC is not supported in this driver
8  */
9 #include <linux/bsearch.h>
10 #include <linux/delay.h>
11 #include <linux/kernel.h>
12 #include <linux/module.h>
13 #include <linux/property.h>
14 #include <linux/spi/spi.h>
15
16 #include <linux/iio/iio.h>
17 #include <linux/iio/sysfs.h>
18
19 /* AD5758 registers definition */
20 #define AD5758_NOP                              0x00
21 #define AD5758_DAC_INPUT                        0x01
22 #define AD5758_DAC_OUTPUT                       0x02
23 #define AD5758_CLEAR_CODE                       0x03
24 #define AD5758_USER_GAIN                        0x04
25 #define AD5758_USER_OFFSET                      0x05
26 #define AD5758_DAC_CONFIG                       0x06
27 #define AD5758_SW_LDAC                          0x07
28 #define AD5758_KEY                              0x08
29 #define AD5758_GP_CONFIG1                       0x09
30 #define AD5758_GP_CONFIG2                       0x0A
31 #define AD5758_DCDC_CONFIG1                     0x0B
32 #define AD5758_DCDC_CONFIG2                     0x0C
33 #define AD5758_WDT_CONFIG                       0x0F
34 #define AD5758_DIGITAL_DIAG_CONFIG              0x10
35 #define AD5758_ADC_CONFIG                       0x11
36 #define AD5758_FAULT_PIN_CONFIG                 0x12
37 #define AD5758_TWO_STAGE_READBACK_SELECT        0x13
38 #define AD5758_DIGITAL_DIAG_RESULTS             0x14
39 #define AD5758_ANALOG_DIAG_RESULTS              0x15
40 #define AD5758_STATUS                           0x16
41 #define AD5758_CHIP_ID                          0x17
42 #define AD5758_FREQ_MONITOR                     0x18
43 #define AD5758_DEVICE_ID_0                      0x19
44 #define AD5758_DEVICE_ID_1                      0x1A
45 #define AD5758_DEVICE_ID_2                      0x1B
46 #define AD5758_DEVICE_ID_3                      0x1C
47
48 /* AD5758_DAC_CONFIG */
49 #define AD5758_DAC_CONFIG_RANGE_MSK             GENMASK(3, 0)
50 #define AD5758_DAC_CONFIG_RANGE_MODE(x)         (((x) & 0xF) << 0)
51 #define AD5758_DAC_CONFIG_INT_EN_MSK            BIT(5)
52 #define AD5758_DAC_CONFIG_INT_EN_MODE(x)        (((x) & 0x1) << 5)
53 #define AD5758_DAC_CONFIG_OUT_EN_MSK            BIT(6)
54 #define AD5758_DAC_CONFIG_OUT_EN_MODE(x)        (((x) & 0x1) << 6)
55 #define AD5758_DAC_CONFIG_SR_EN_MSK             BIT(8)
56 #define AD5758_DAC_CONFIG_SR_EN_MODE(x)         (((x) & 0x1) << 8)
57 #define AD5758_DAC_CONFIG_SR_CLOCK_MSK          GENMASK(12, 9)
58 #define AD5758_DAC_CONFIG_SR_CLOCK_MODE(x)      (((x) & 0xF) << 9)
59 #define AD5758_DAC_CONFIG_SR_STEP_MSK           GENMASK(15, 13)
60 #define AD5758_DAC_CONFIG_SR_STEP_MODE(x)       (((x) & 0x7) << 13)
61
62 /* AD5758_KEY */
63 #define AD5758_KEY_CODE_RESET_1                 0x15FA
64 #define AD5758_KEY_CODE_RESET_2                 0xAF51
65 #define AD5758_KEY_CODE_SINGLE_ADC_CONV         0x1ADC
66 #define AD5758_KEY_CODE_RESET_WDT               0x0D06
67 #define AD5758_KEY_CODE_CALIB_MEM_REFRESH       0xFCBA
68
69 /* AD5758_DCDC_CONFIG1 */
70 #define AD5758_DCDC_CONFIG1_DCDC_VPROG_MSK      GENMASK(4, 0)
71 #define AD5758_DCDC_CONFIG1_DCDC_VPROG_MODE(x)  (((x) & 0x1F) << 0)
72 #define AD5758_DCDC_CONFIG1_DCDC_MODE_MSK       GENMASK(6, 5)
73 #define AD5758_DCDC_CONFIG1_DCDC_MODE_MODE(x)   (((x) & 0x3) << 5)
74 #define AD5758_DCDC_CONFIG1_PROT_SW_EN_MSK      BIT(7)
75 #define AD5758_DCDC_CONFIG1_PROT_SW_EN_MODE(x)  (((x) & 0x1) << 7)
76
77 /* AD5758_DCDC_CONFIG2 */
78 #define AD5758_DCDC_CONFIG2_ILIMIT_MSK          GENMASK(3, 1)
79 #define AD5758_DCDC_CONFIG2_ILIMIT_MODE(x)      (((x) & 0x7) << 1)
80 #define AD5758_DCDC_CONFIG2_INTR_SAT_3WI_MSK    BIT(11)
81 #define AD5758_DCDC_CONFIG2_BUSY_3WI_MSK        BIT(12)
82
83 /* AD5758_DIGITAL_DIAG_RESULTS */
84 #define AD5758_CAL_MEM_UNREFRESHED_MSK          BIT(15)
85
86 #define AD5758_WR_FLAG_MSK(x)           (0x80 | ((x) & 0x1F))
87
88 #define AD5758_FULL_SCALE_MICRO 65535000000ULL
89
90 /**
91  * struct ad5758_state - driver instance specific data
92  * @spi:        spi_device
93  * @lock:       mutex lock
94  * @out_range:  struct which stores the output range
95  * @dc_dc_mode: variable which stores the mode of operation
96  * @dc_dc_ilim: variable which stores the dc-to-dc converter current limit
97  * @slew_time:  variable which stores the target slew time
98  * @pwr_down:   variable which contains whether a channel is powered down or not
99  * @data:       spi transfer buffers
100  */
101
102 struct ad5758_range {
103         int reg;
104         int min;
105         int max;
106 };
107
108 struct ad5758_state {
109         struct spi_device *spi;
110         struct mutex lock;
111         struct ad5758_range out_range;
112         unsigned int dc_dc_mode;
113         unsigned int dc_dc_ilim;
114         unsigned int slew_time;
115         bool pwr_down;
116         __be32 d32[3];
117 };
118
119 /**
120  * Output ranges corresponding to bits [3:0] from DAC_CONFIG register
121  * 0000: 0 V to 5 V voltage range
122  * 0001: 0 V to 10 V voltage range
123  * 0010: ±5 V voltage range
124  * 0011: ±10 V voltage range
125  * 1000: 0 mA to 20 mA current range
126  * 1001: 0 mA to 24 mA current range
127  * 1010: 4 mA to 20 mA current range
128  * 1011: ±20 mA current range
129  * 1100: ±24 mA current range
130  * 1101: -1 mA to +22 mA current range
131  */
132 enum ad5758_output_range {
133         AD5758_RANGE_0V_5V,
134         AD5758_RANGE_0V_10V,
135         AD5758_RANGE_PLUSMINUS_5V,
136         AD5758_RANGE_PLUSMINUS_10V,
137         AD5758_RANGE_0mA_20mA = 8,
138         AD5758_RANGE_0mA_24mA,
139         AD5758_RANGE_4mA_24mA,
140         AD5758_RANGE_PLUSMINUS_20mA,
141         AD5758_RANGE_PLUSMINUS_24mA,
142         AD5758_RANGE_MINUS_1mA_PLUS_22mA,
143 };
144
145 enum ad5758_dc_dc_mode {
146         AD5758_DCDC_MODE_POWER_OFF,
147         AD5758_DCDC_MODE_DPC_CURRENT,
148         AD5758_DCDC_MODE_DPC_VOLTAGE,
149         AD5758_DCDC_MODE_PPC_CURRENT,
150 };
151
152 static const struct ad5758_range ad5758_voltage_range[] = {
153         { AD5758_RANGE_0V_5V, 0, 5000000 },
154         { AD5758_RANGE_0V_10V, 0, 10000000 },
155         { AD5758_RANGE_PLUSMINUS_5V, -5000000, 5000000 },
156         { AD5758_RANGE_PLUSMINUS_10V, -10000000, 10000000 }
157 };
158
159 static const struct ad5758_range ad5758_current_range[] = {
160         { AD5758_RANGE_0mA_20mA, 0, 20000},
161         { AD5758_RANGE_0mA_24mA, 0, 24000 },
162         { AD5758_RANGE_4mA_24mA, 4, 24000 },
163         { AD5758_RANGE_PLUSMINUS_20mA, -20000, 20000 },
164         { AD5758_RANGE_PLUSMINUS_24mA, -24000, 24000 },
165         { AD5758_RANGE_MINUS_1mA_PLUS_22mA, -1000, 22000 },
166 };
167
168 static const int ad5758_sr_clk[16] = {
169         240000, 200000, 150000, 128000, 64000, 32000, 16000, 8000, 4000, 2000,
170         1000, 512, 256, 128, 64, 16
171 };
172
173 static const int ad5758_sr_step[8] = {
174         4, 12, 64, 120, 256, 500, 1820, 2048
175 };
176
177 static const int ad5758_dc_dc_ilim[6] = {
178         150000, 200000, 250000, 300000, 350000, 400000
179 };
180
181 static int ad5758_spi_reg_read(struct ad5758_state *st, unsigned int addr)
182 {
183         struct spi_transfer t[] = {
184                 {
185                         .tx_buf = &st->d32[0],
186                         .len = 4,
187                         .cs_change = 1,
188                 }, {
189                         .tx_buf = &st->d32[1],
190                         .rx_buf = &st->d32[2],
191                         .len = 4,
192                 },
193         };
194         int ret;
195
196         st->d32[0] = cpu_to_be32(
197                 (AD5758_WR_FLAG_MSK(AD5758_TWO_STAGE_READBACK_SELECT) << 24) |
198                 (addr << 8));
199         st->d32[1] = cpu_to_be32(AD5758_WR_FLAG_MSK(AD5758_NOP) << 24);
200
201         ret = spi_sync_transfer(st->spi, t, ARRAY_SIZE(t));
202         if (ret < 0)
203                 return ret;
204
205         return (be32_to_cpu(st->d32[2]) >> 8) & 0xFFFF;
206 }
207
208 static int ad5758_spi_reg_write(struct ad5758_state *st,
209                                 unsigned int addr,
210                                 unsigned int val)
211 {
212         st->d32[0] = cpu_to_be32((AD5758_WR_FLAG_MSK(addr) << 24) |
213                                  ((val & 0xFFFF) << 8));
214
215         return spi_write(st->spi, &st->d32[0], sizeof(st->d32[0]));
216 }
217
218 static int ad5758_spi_write_mask(struct ad5758_state *st,
219                                  unsigned int addr,
220                                  unsigned long int mask,
221                                  unsigned int val)
222 {
223         int regval;
224
225         regval = ad5758_spi_reg_read(st, addr);
226         if (regval < 0)
227                 return regval;
228
229         regval &= ~mask;
230         regval |= val;
231
232         return ad5758_spi_reg_write(st, addr, regval);
233 }
234
235 static int cmpfunc(const void *a, const void *b)
236 {
237         return *(int *)a - *(int *)b;
238 }
239
240 static int ad5758_find_closest_match(const int *array,
241                                      unsigned int size, int val)
242 {
243         int i;
244
245         for (i = 0; i < size; i++) {
246                 if (val <= array[i])
247                         return i;
248         }
249
250         return size - 1;
251 }
252
253 static int ad5758_wait_for_task_complete(struct ad5758_state *st,
254                                          unsigned int reg,
255                                          unsigned int mask)
256 {
257         unsigned int timeout;
258         int ret;
259
260         timeout = 10;
261         do {
262                 ret = ad5758_spi_reg_read(st, reg);
263                 if (ret < 0)
264                         return ret;
265
266                 if (!(ret & mask))
267                         return 0;
268
269                 usleep_range(100, 1000);
270         } while (--timeout);
271
272         dev_err(&st->spi->dev,
273                 "Error reading bit 0x%x in 0x%x register\n", mask, reg);
274
275         return -EIO;
276 }
277
278 static int ad5758_calib_mem_refresh(struct ad5758_state *st)
279 {
280         int ret;
281
282         ret = ad5758_spi_reg_write(st, AD5758_KEY,
283                                    AD5758_KEY_CODE_CALIB_MEM_REFRESH);
284         if (ret < 0) {
285                 dev_err(&st->spi->dev,
286                         "Failed to initiate a calibration memory refresh\n");
287                 return ret;
288         }
289
290         /* Wait to allow time for the internal calibrations to complete */
291         return ad5758_wait_for_task_complete(st, AD5758_DIGITAL_DIAG_RESULTS,
292                                              AD5758_CAL_MEM_UNREFRESHED_MSK);
293 }
294
295 static int ad5758_soft_reset(struct ad5758_state *st)
296 {
297         int ret;
298
299         ret = ad5758_spi_reg_write(st, AD5758_KEY, AD5758_KEY_CODE_RESET_1);
300         if (ret < 0)
301                 return ret;
302
303         ret = ad5758_spi_reg_write(st, AD5758_KEY, AD5758_KEY_CODE_RESET_2);
304
305         /* Perform a software reset and wait at least 100us */
306         usleep_range(100, 1000);
307
308         return ret;
309 }
310
311 static int ad5758_set_dc_dc_conv_mode(struct ad5758_state *st,
312                                       enum ad5758_dc_dc_mode mode)
313 {
314         int ret;
315
316         ret = ad5758_spi_write_mask(st, AD5758_DCDC_CONFIG1,
317                                     AD5758_DCDC_CONFIG1_DCDC_MODE_MSK,
318                                     AD5758_DCDC_CONFIG1_DCDC_MODE_MODE(mode));
319         if (ret < 0)
320                 return ret;
321
322         /*
323          * Poll the BUSY_3WI bit in the DCDC_CONFIG2 register until it is 0.
324          * This allows the 3-wire interface communication to complete.
325          */
326         ret = ad5758_wait_for_task_complete(st, AD5758_DCDC_CONFIG2,
327                                             AD5758_DCDC_CONFIG2_BUSY_3WI_MSK);
328         if (ret < 0)
329                 return ret;
330
331         st->dc_dc_mode = mode;
332
333         return ret;
334 }
335
336 static int ad5758_set_dc_dc_ilim(struct ad5758_state *st, unsigned int ilim)
337 {
338         int ret;
339
340         ret = ad5758_spi_write_mask(st, AD5758_DCDC_CONFIG2,
341                                     AD5758_DCDC_CONFIG2_ILIMIT_MSK,
342                                     AD5758_DCDC_CONFIG2_ILIMIT_MODE(ilim));
343         if (ret < 0)
344                 return ret;
345         /*
346          * Poll the BUSY_3WI bit in the DCDC_CONFIG2 register until it is 0.
347          * This allows the 3-wire interface communication to complete.
348          */
349         return ad5758_wait_for_task_complete(st, AD5758_DCDC_CONFIG2,
350                                              AD5758_DCDC_CONFIG2_BUSY_3WI_MSK);
351 }
352
353 static int ad5758_slew_rate_set(struct ad5758_state *st,
354                                 unsigned int sr_clk_idx,
355                                 unsigned int sr_step_idx)
356 {
357         unsigned int mode;
358         unsigned long int mask;
359         int ret;
360
361         mask = AD5758_DAC_CONFIG_SR_EN_MSK |
362                AD5758_DAC_CONFIG_SR_CLOCK_MSK |
363                AD5758_DAC_CONFIG_SR_STEP_MSK;
364         mode = AD5758_DAC_CONFIG_SR_EN_MODE(1) |
365                AD5758_DAC_CONFIG_SR_STEP_MODE(sr_step_idx) |
366                AD5758_DAC_CONFIG_SR_CLOCK_MODE(sr_clk_idx);
367
368         ret = ad5758_spi_write_mask(st, AD5758_DAC_CONFIG, mask, mode);
369         if (ret < 0)
370                 return ret;
371
372         /* Wait to allow time for the internal calibrations to complete */
373         return ad5758_wait_for_task_complete(st, AD5758_DIGITAL_DIAG_RESULTS,
374                                              AD5758_CAL_MEM_UNREFRESHED_MSK);
375 }
376
377 static int ad5758_slew_rate_config(struct ad5758_state *st)
378 {
379         unsigned int sr_clk_idx, sr_step_idx;
380         int i, res;
381         s64 diff_new, diff_old;
382         u64 sr_step, calc_slew_time;
383
384         sr_clk_idx = 0;
385         sr_step_idx = 0;
386         diff_old = S64_MAX;
387         /*
388          * The slew time can be determined by using the formula:
389          * Slew Time = (Full Scale Out / (Step Size x Update Clk Freq))
390          * where Slew time is expressed in microseconds
391          * Given the desired slew time, the following algorithm determines the
392          * best match for the step size and the update clock frequency.
393          */
394         for (i = 0; i < ARRAY_SIZE(ad5758_sr_clk); i++) {
395                 /*
396                  * Go through each valid update clock freq and determine a raw
397                  * value for the step size by using the formula:
398                  * Step Size = Full Scale Out / (Update Clk Freq * Slew Time)
399                  */
400                 sr_step = AD5758_FULL_SCALE_MICRO;
401                 do_div(sr_step, ad5758_sr_clk[i]);
402                 do_div(sr_step, st->slew_time);
403                 /*
404                  * After a raw value for step size was determined, find the
405                  * closest valid match
406                  */
407                 res = ad5758_find_closest_match(ad5758_sr_step,
408                                                 ARRAY_SIZE(ad5758_sr_step),
409                                                 sr_step);
410                 /* Calculate the slew time */
411                 calc_slew_time = AD5758_FULL_SCALE_MICRO;
412                 do_div(calc_slew_time, ad5758_sr_step[res]);
413                 do_div(calc_slew_time, ad5758_sr_clk[i]);
414                 /*
415                  * Determine with how many microseconds the calculated slew time
416                  * is different from the desired slew time and store the diff
417                  * for the next iteration
418                  */
419                 diff_new = abs(st->slew_time - calc_slew_time);
420                 if (diff_new < diff_old) {
421                         diff_old = diff_new;
422                         sr_clk_idx = i;
423                         sr_step_idx = res;
424                 }
425         }
426
427         return ad5758_slew_rate_set(st, sr_clk_idx, sr_step_idx);
428 }
429
430 static int ad5758_set_out_range(struct ad5758_state *st, int range)
431 {
432         int ret;
433
434         ret = ad5758_spi_write_mask(st, AD5758_DAC_CONFIG,
435                                     AD5758_DAC_CONFIG_RANGE_MSK,
436                                     AD5758_DAC_CONFIG_RANGE_MODE(range));
437         if (ret < 0)
438                 return ret;
439
440         /* Wait to allow time for the internal calibrations to complete */
441         return ad5758_wait_for_task_complete(st, AD5758_DIGITAL_DIAG_RESULTS,
442                                              AD5758_CAL_MEM_UNREFRESHED_MSK);
443 }
444
445 static int ad5758_fault_prot_switch_en(struct ad5758_state *st, bool enable)
446 {
447         int ret;
448
449         ret = ad5758_spi_write_mask(st, AD5758_DCDC_CONFIG1,
450                         AD5758_DCDC_CONFIG1_PROT_SW_EN_MSK,
451                         AD5758_DCDC_CONFIG1_PROT_SW_EN_MODE(enable));
452         if (ret < 0)
453                 return ret;
454         /*
455          * Poll the BUSY_3WI bit in the DCDC_CONFIG2 register until it is 0.
456          * This allows the 3-wire interface communication to complete.
457          */
458         return ad5758_wait_for_task_complete(st, AD5758_DCDC_CONFIG2,
459                                              AD5758_DCDC_CONFIG2_BUSY_3WI_MSK);
460 }
461
462 static int ad5758_internal_buffers_en(struct ad5758_state *st, bool enable)
463 {
464         int ret;
465
466         ret = ad5758_spi_write_mask(st, AD5758_DAC_CONFIG,
467                                     AD5758_DAC_CONFIG_INT_EN_MSK,
468                                     AD5758_DAC_CONFIG_INT_EN_MODE(enable));
469         if (ret < 0)
470                 return ret;
471
472         /* Wait to allow time for the internal calibrations to complete */
473         return ad5758_wait_for_task_complete(st, AD5758_DIGITAL_DIAG_RESULTS,
474                                              AD5758_CAL_MEM_UNREFRESHED_MSK);
475 }
476
477 static int ad5758_reg_access(struct iio_dev *indio_dev,
478                              unsigned int reg,
479                              unsigned int writeval,
480                              unsigned int *readval)
481 {
482         struct ad5758_state *st = iio_priv(indio_dev);
483         int ret;
484
485         mutex_lock(&st->lock);
486         if (readval) {
487                 ret = ad5758_spi_reg_read(st, reg);
488                 if (ret < 0) {
489                         mutex_unlock(&st->lock);
490                         return ret;
491                 }
492
493                 *readval = ret;
494                 ret = 0;
495         } else {
496                 ret = ad5758_spi_reg_write(st, reg, writeval);
497         }
498         mutex_unlock(&st->lock);
499
500         return ret;
501 }
502
503 static int ad5758_read_raw(struct iio_dev *indio_dev,
504                            struct iio_chan_spec const *chan,
505                            int *val, int *val2, long info)
506 {
507         struct ad5758_state *st = iio_priv(indio_dev);
508         int max, min, ret;
509
510         switch (info) {
511         case IIO_CHAN_INFO_RAW:
512                 mutex_lock(&st->lock);
513                 ret = ad5758_spi_reg_read(st, AD5758_DAC_INPUT);
514                 mutex_unlock(&st->lock);
515                 if (ret < 0)
516                         return ret;
517
518                 *val = ret;
519                 return IIO_VAL_INT;
520         case IIO_CHAN_INFO_SCALE:
521                 min = st->out_range.min;
522                 max = st->out_range.max;
523                 *val = (max - min) / 1000;
524                 *val2 = 16;
525                 return IIO_VAL_FRACTIONAL_LOG2;
526         case IIO_CHAN_INFO_OFFSET:
527                 min = st->out_range.min;
528                 max = st->out_range.max;
529                 *val = ((min * (1 << 16)) / (max - min)) / 1000;
530                 return IIO_VAL_INT;
531         default:
532                 return -EINVAL;
533         }
534 }
535
536 static int ad5758_write_raw(struct iio_dev *indio_dev,
537                             struct iio_chan_spec const *chan,
538                             int val, int val2, long info)
539 {
540         struct ad5758_state *st = iio_priv(indio_dev);
541         int ret;
542
543         switch (info) {
544         case IIO_CHAN_INFO_RAW:
545                 mutex_lock(&st->lock);
546                 ret = ad5758_spi_reg_write(st, AD5758_DAC_INPUT, val);
547                 mutex_unlock(&st->lock);
548                 return ret;
549         default:
550                 return -EINVAL;
551         }
552 }
553
554 static ssize_t ad5758_read_powerdown(struct iio_dev *indio_dev,
555                                      uintptr_t priv,
556                                      const struct iio_chan_spec *chan,
557                                      char *buf)
558 {
559         struct ad5758_state *st = iio_priv(indio_dev);
560
561         return sprintf(buf, "%d\n", st->pwr_down);
562 }
563
564 static ssize_t ad5758_write_powerdown(struct iio_dev *indio_dev,
565                                       uintptr_t priv,
566                                       struct iio_chan_spec const *chan,
567                                       const char *buf, size_t len)
568 {
569         struct ad5758_state *st = iio_priv(indio_dev);
570         bool pwr_down;
571         unsigned int dcdc_config1_mode, dc_dc_mode, dac_config_mode, val;
572         unsigned long int dcdc_config1_msk, dac_config_msk;
573         int ret;
574
575         ret = kstrtobool(buf, &pwr_down);
576         if (ret)
577                 return ret;
578
579         mutex_lock(&st->lock);
580         if (pwr_down) {
581                 dc_dc_mode = AD5758_DCDC_MODE_POWER_OFF;
582                 val = 0;
583         } else {
584                 dc_dc_mode = st->dc_dc_mode;
585                 val = 1;
586         }
587
588         dcdc_config1_mode = AD5758_DCDC_CONFIG1_DCDC_MODE_MODE(dc_dc_mode) |
589                             AD5758_DCDC_CONFIG1_PROT_SW_EN_MODE(val);
590         dcdc_config1_msk = AD5758_DCDC_CONFIG1_DCDC_MODE_MSK |
591                            AD5758_DCDC_CONFIG1_PROT_SW_EN_MSK;
592
593         ret = ad5758_spi_write_mask(st, AD5758_DCDC_CONFIG1,
594                                     dcdc_config1_msk,
595                                     dcdc_config1_mode);
596         if (ret < 0)
597                 goto err_unlock;
598
599         dac_config_mode = AD5758_DAC_CONFIG_OUT_EN_MODE(val) |
600                           AD5758_DAC_CONFIG_INT_EN_MODE(val);
601         dac_config_msk = AD5758_DAC_CONFIG_OUT_EN_MSK |
602                          AD5758_DAC_CONFIG_INT_EN_MSK;
603
604         ret = ad5758_spi_write_mask(st, AD5758_DAC_CONFIG,
605                                     dac_config_msk,
606                                     dac_config_mode);
607         if (ret < 0)
608                 goto err_unlock;
609
610         st->pwr_down = pwr_down;
611
612 err_unlock:
613         mutex_unlock(&st->lock);
614
615         return ret ? ret : len;
616 }
617
618 static const struct iio_info ad5758_info = {
619         .read_raw = ad5758_read_raw,
620         .write_raw = ad5758_write_raw,
621         .debugfs_reg_access = &ad5758_reg_access,
622 };
623
624 static const struct iio_chan_spec_ext_info ad5758_ext_info[] = {
625         {
626                 .name = "powerdown",
627                 .read = ad5758_read_powerdown,
628                 .write = ad5758_write_powerdown,
629                 .shared = IIO_SHARED_BY_TYPE,
630         },
631         { }
632 };
633
634 #define AD5758_DAC_CHAN(_chan_type) {                           \
635         .type = (_chan_type),                                   \
636         .info_mask_shared_by_type = BIT(IIO_CHAN_INFO_RAW) |    \
637                 BIT(IIO_CHAN_INFO_SCALE) |                      \
638                 BIT(IIO_CHAN_INFO_OFFSET),                      \
639         .indexed = 1,                                           \
640         .output = 1,                                            \
641         .ext_info = ad5758_ext_info,                            \
642 }
643
644 static const struct iio_chan_spec ad5758_voltage_ch[] = {
645         AD5758_DAC_CHAN(IIO_VOLTAGE)
646 };
647
648 static const struct iio_chan_spec ad5758_current_ch[] = {
649         AD5758_DAC_CHAN(IIO_CURRENT)
650 };
651
652 static bool ad5758_is_valid_mode(enum ad5758_dc_dc_mode mode)
653 {
654         switch (mode) {
655         case AD5758_DCDC_MODE_DPC_CURRENT:
656         case AD5758_DCDC_MODE_DPC_VOLTAGE:
657         case AD5758_DCDC_MODE_PPC_CURRENT:
658                 return true;
659         default:
660                 return false;
661         }
662 }
663
664 static int ad5758_crc_disable(struct ad5758_state *st)
665 {
666         unsigned int mask;
667
668         mask = (AD5758_WR_FLAG_MSK(AD5758_DIGITAL_DIAG_CONFIG) << 24) | 0x5C3A;
669         st->d32[0] = cpu_to_be32(mask);
670
671         return spi_write(st->spi, &st->d32[0], 4);
672 }
673
674 static int ad5758_find_out_range(struct ad5758_state *st,
675                                  const struct ad5758_range *range,
676                                  unsigned int size,
677                                  int min, int max)
678 {
679         int i;
680
681         for (i = 0; i < size; i++) {
682                 if ((min == range[i].min) && (max == range[i].max)) {
683                         st->out_range.reg = range[i].reg;
684                         st->out_range.min = range[i].min;
685                         st->out_range.max = range[i].max;
686
687                         return 0;
688                 }
689         }
690
691         return -EINVAL;
692 }
693
694 static int ad5758_parse_dt(struct ad5758_state *st)
695 {
696         unsigned int tmp, tmparray[2], size;
697         const struct ad5758_range *range;
698         int *index, ret;
699
700         st->dc_dc_ilim = 0;
701         ret = device_property_read_u32(&st->spi->dev,
702                                        "adi,dc-dc-ilim-microamp", &tmp);
703         if (ret) {
704                 dev_dbg(&st->spi->dev,
705                         "Missing \"dc-dc-ilim-microamp\" property\n");
706         } else {
707                 index = bsearch(&tmp, ad5758_dc_dc_ilim,
708                                 ARRAY_SIZE(ad5758_dc_dc_ilim),
709                                 sizeof(int), cmpfunc);
710                 if (!index)
711                         dev_dbg(&st->spi->dev, "dc-dc-ilim out of range\n");
712                 else
713                         st->dc_dc_ilim = index - ad5758_dc_dc_ilim;
714         }
715
716         ret = device_property_read_u32(&st->spi->dev, "adi,dc-dc-mode",
717                                        &st->dc_dc_mode);
718         if (ret) {
719                 dev_err(&st->spi->dev, "Missing \"dc-dc-mode\" property\n");
720                 return ret;
721         }
722
723         if (!ad5758_is_valid_mode(st->dc_dc_mode))
724                 return -EINVAL;
725
726         if (st->dc_dc_mode == AD5758_DCDC_MODE_DPC_VOLTAGE) {
727                 ret = device_property_read_u32_array(&st->spi->dev,
728                                                      "adi,range-microvolt",
729                                                      tmparray, 2);
730                 if (ret) {
731                         dev_err(&st->spi->dev,
732                                 "Missing \"range-microvolt\" property\n");
733                         return ret;
734                 }
735                 range = ad5758_voltage_range;
736                 size = ARRAY_SIZE(ad5758_voltage_range);
737         } else {
738                 ret = device_property_read_u32_array(&st->spi->dev,
739                                                      "adi,range-microamp",
740                                                      tmparray, 2);
741                 if (ret) {
742                         dev_err(&st->spi->dev,
743                                 "Missing \"range-microamp\" property\n");
744                         return ret;
745                 }
746                 range = ad5758_current_range;
747                 size = ARRAY_SIZE(ad5758_current_range);
748         }
749
750         ret = ad5758_find_out_range(st, range, size, tmparray[0], tmparray[1]);
751         if (ret) {
752                 dev_err(&st->spi->dev, "range invalid\n");
753                 return ret;
754         }
755
756         ret = device_property_read_u32(&st->spi->dev, "adi,slew-time-us", &tmp);
757         if (ret) {
758                 dev_dbg(&st->spi->dev, "Missing \"slew-time-us\" property\n");
759                 st->slew_time = 0;
760         } else {
761                 st->slew_time = tmp;
762         }
763
764         return 0;
765 }
766
767 static int ad5758_init(struct ad5758_state *st)
768 {
769         int regval, ret;
770
771         /* Disable CRC checks */
772         ret = ad5758_crc_disable(st);
773         if (ret < 0)
774                 return ret;
775
776         /* Perform a software reset */
777         ret = ad5758_soft_reset(st);
778         if (ret < 0)
779                 return ret;
780
781         /* Disable CRC checks */
782         ret = ad5758_crc_disable(st);
783         if (ret < 0)
784                 return ret;
785
786         /* Perform a calibration memory refresh */
787         ret = ad5758_calib_mem_refresh(st);
788         if (ret < 0)
789                 return ret;
790
791         regval = ad5758_spi_reg_read(st, AD5758_DIGITAL_DIAG_RESULTS);
792         if (regval < 0)
793                 return regval;
794
795         /* Clear all the error flags */
796         ret = ad5758_spi_reg_write(st, AD5758_DIGITAL_DIAG_RESULTS, regval);
797         if (ret < 0)
798                 return ret;
799
800         /* Set the dc-to-dc current limit */
801         ret = ad5758_set_dc_dc_ilim(st, st->dc_dc_ilim);
802         if (ret < 0)
803                 return ret;
804
805         /* Configure the dc-to-dc controller mode */
806         ret = ad5758_set_dc_dc_conv_mode(st, st->dc_dc_mode);
807         if (ret < 0)
808                 return ret;
809
810         /* Configure the output range */
811         ret = ad5758_set_out_range(st, st->out_range.reg);
812         if (ret < 0)
813                 return ret;
814
815         /* Enable Slew Rate Control, set the slew rate clock and step */
816         if (st->slew_time) {
817                 ret = ad5758_slew_rate_config(st);
818                 if (ret < 0)
819                         return ret;
820         }
821
822         /* Enable the VIOUT fault protection switch (FPS is closed) */
823         ret = ad5758_fault_prot_switch_en(st, 1);
824         if (ret < 0)
825                 return ret;
826
827         /* Power up the DAC and internal (INT) amplifiers */
828         ret = ad5758_internal_buffers_en(st, 1);
829         if (ret < 0)
830                 return ret;
831
832         /* Enable VIOUT */
833         return ad5758_spi_write_mask(st, AD5758_DAC_CONFIG,
834                                      AD5758_DAC_CONFIG_OUT_EN_MSK,
835                                      AD5758_DAC_CONFIG_OUT_EN_MODE(1));
836 }
837
838 static int ad5758_probe(struct spi_device *spi)
839 {
840         struct ad5758_state *st;
841         struct iio_dev *indio_dev;
842         int ret;
843
844         indio_dev = devm_iio_device_alloc(&spi->dev, sizeof(*st));
845         if (!indio_dev)
846                 return -ENOMEM;
847
848         st = iio_priv(indio_dev);
849         spi_set_drvdata(spi, indio_dev);
850
851         st->spi = spi;
852
853         mutex_init(&st->lock);
854
855         indio_dev->dev.parent = &spi->dev;
856         indio_dev->name = spi_get_device_id(spi)->name;
857         indio_dev->info = &ad5758_info;
858         indio_dev->modes = INDIO_DIRECT_MODE;
859         indio_dev->num_channels = 1;
860
861         ret = ad5758_parse_dt(st);
862         if (ret < 0)
863                 return ret;
864
865         if (st->dc_dc_mode == AD5758_DCDC_MODE_DPC_VOLTAGE)
866                 indio_dev->channels = ad5758_voltage_ch;
867         else
868                 indio_dev->channels = ad5758_current_ch;
869
870         ret = ad5758_init(st);
871         if (ret < 0) {
872                 dev_err(&spi->dev, "AD5758 init failed\n");
873                 return ret;
874         }
875
876         return devm_iio_device_register(&st->spi->dev, indio_dev);
877 }
878
879 static const struct spi_device_id ad5758_id[] = {
880         { "ad5758", 0 },
881         {}
882 };
883 MODULE_DEVICE_TABLE(spi, ad5758_id);
884
885 static struct spi_driver ad5758_driver = {
886         .driver = {
887                 .name = KBUILD_MODNAME,
888         },
889         .probe = ad5758_probe,
890         .id_table = ad5758_id,
891 };
892
893 module_spi_driver(ad5758_driver);
894
895 MODULE_AUTHOR("Stefan Popa <stefan.popa@analog.com>");
896 MODULE_DESCRIPTION("Analog Devices AD5758 DAC");
897 MODULE_LICENSE("GPL v2");