1 // SPDX-License-Identifier: GPL-2.0+
2 /*
3 * ADS8344 16-bit 8-Channel ADC driver
4 *
5 * Author: Gregory CLEMENT <gregory.clement@bootlin.com>
6 *
7 * Datasheet: http://www.ti.com/lit/ds/symlink/ads8344.pdf
8 */
9
10 #include <linux/delay.h>
11 #include <linux/iio/buffer.h>
12 #include <linux/iio/iio.h>
13 #include <linux/module.h>
14 #include <linux/regulator/consumer.h>
15 #include <linux/spi/spi.h>
16
17 #define ADS8344_START BIT(7)
18 #define ADS8344_SINGLE_END BIT(2)
19 #define ADS8344_CHANNEL(channel) ((channel) << 4)
20 #define ADS8344_CLOCK_INTERNAL 0x2 /* PD1 = 1 and PD0 = 0 */
21
22 struct ads8344 {
23 struct spi_device *spi;
24 struct regulator *reg;
25 /*
26 * Lock protecting access to adc->tx_buff and rx_buff,
27 * especially from concurrent read on sysfs file.
28 */
29 struct mutex lock;
30
31 u8 tx_buf ____cacheline_aligned;
32 u16 rx_buf;
33 };
34
35 #define ADS8344_VOLTAGE_CHANNEL(chan, si) \
36 { \
37 .type = IIO_VOLTAGE, \
38 .indexed = 1, \
39 .channel = chan, \
40 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW), \
41 .info_mask_shared_by_type = BIT(IIO_CHAN_INFO_SCALE), \
42 }
43
44 #define ADS8344_VOLTAGE_CHANNEL_DIFF(chan1, chan2, si) \
45 { \
46 .type = IIO_VOLTAGE, \
47 .indexed = 1, \
48 .channel = (chan1), \
49 .channel2 = (chan2), \
50 .differential = 1, \
51 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW), \
52 .info_mask_shared_by_type = BIT(IIO_CHAN_INFO_SCALE), \
53 }
54
55 static const struct iio_chan_spec ads8344_channels[] = {
56 ADS8344_VOLTAGE_CHANNEL(0, 0),
57 ADS8344_VOLTAGE_CHANNEL(1, 4),
58 ADS8344_VOLTAGE_CHANNEL(2, 1),
59 ADS8344_VOLTAGE_CHANNEL(3, 5),
60 ADS8344_VOLTAGE_CHANNEL(4, 2),
61 ADS8344_VOLTAGE_CHANNEL(5, 6),
62 ADS8344_VOLTAGE_CHANNEL(6, 3),
63 ADS8344_VOLTAGE_CHANNEL(7, 7),
64 ADS8344_VOLTAGE_CHANNEL_DIFF(0, 1, 8),
65 ADS8344_VOLTAGE_CHANNEL_DIFF(2, 3, 9),
66 ADS8344_VOLTAGE_CHANNEL_DIFF(4, 5, 10),
67 ADS8344_VOLTAGE_CHANNEL_DIFF(6, 7, 11),
68 ADS8344_VOLTAGE_CHANNEL_DIFF(1, 0, 12),
69 ADS8344_VOLTAGE_CHANNEL_DIFF(3, 2, 13),
70 ADS8344_VOLTAGE_CHANNEL_DIFF(5, 4, 14),
71 ADS8344_VOLTAGE_CHANNEL_DIFF(7, 6, 15),
72 };
73
ads8344_adc_conversion(struct ads8344 * adc,int channel,bool differential)74 static int ads8344_adc_conversion(struct ads8344 *adc, int channel,
75 bool differential)
76 {
77 struct spi_device *spi = adc->spi;
78 int ret;
79
80 adc->tx_buf = ADS8344_START;
81 if (!differential)
82 adc->tx_buf |= ADS8344_SINGLE_END;
83 adc->tx_buf |= ADS8344_CHANNEL(channel);
84 adc->tx_buf |= ADS8344_CLOCK_INTERNAL;
85
86 ret = spi_write(spi, &adc->tx_buf, 1);
87 if (ret)
88 return ret;
89
90 udelay(9);
91
92 ret = spi_read(spi, &adc->rx_buf, 2);
93 if (ret)
94 return ret;
95
96 return adc->rx_buf;
97 }
98
ads8344_read_raw(struct iio_dev * iio,struct iio_chan_spec const * channel,int * value,int * shift,long mask)99 static int ads8344_read_raw(struct iio_dev *iio,
100 struct iio_chan_spec const *channel, int *value,
101 int *shift, long mask)
102 {
103 struct ads8344 *adc = iio_priv(iio);
104
105 switch (mask) {
106 case IIO_CHAN_INFO_RAW:
107 mutex_lock(&adc->lock);
108 *value = ads8344_adc_conversion(adc, channel->scan_index,
109 channel->differential);
110 mutex_unlock(&adc->lock);
111 if (*value < 0)
112 return *value;
113
114 return IIO_VAL_INT;
115 case IIO_CHAN_INFO_SCALE:
116 *value = regulator_get_voltage(adc->reg);
117 if (*value < 0)
118 return *value;
119
120 /* convert regulator output voltage to mV */
121 *value /= 1000;
122 *shift = 16;
123
124 return IIO_VAL_FRACTIONAL_LOG2;
125 default:
126 return -EINVAL;
127 }
128 }
129
130 static const struct iio_info ads8344_info = {
131 .read_raw = ads8344_read_raw,
132 };
133
ads8344_probe(struct spi_device * spi)134 static int ads8344_probe(struct spi_device *spi)
135 {
136 struct iio_dev *indio_dev;
137 struct ads8344 *adc;
138 int ret;
139
140 indio_dev = devm_iio_device_alloc(&spi->dev, sizeof(*adc));
141 if (!indio_dev)
142 return -ENOMEM;
143
144 adc = iio_priv(indio_dev);
145 adc->spi = spi;
146 mutex_init(&adc->lock);
147
148 indio_dev->name = dev_name(&spi->dev);
149 indio_dev->dev.parent = &spi->dev;
150 indio_dev->dev.of_node = spi->dev.of_node;
151 indio_dev->info = &ads8344_info;
152 indio_dev->modes = INDIO_DIRECT_MODE;
153 indio_dev->channels = ads8344_channels;
154 indio_dev->num_channels = ARRAY_SIZE(ads8344_channels);
155
156 adc->reg = devm_regulator_get(&spi->dev, "vref");
157 if (IS_ERR(adc->reg))
158 return PTR_ERR(adc->reg);
159
160 ret = regulator_enable(adc->reg);
161 if (ret)
162 return ret;
163
164 spi_set_drvdata(spi, indio_dev);
165
166 ret = iio_device_register(indio_dev);
167 if (ret) {
168 regulator_disable(adc->reg);
169 return ret;
170 }
171
172 return 0;
173 }
174
ads8344_remove(struct spi_device * spi)175 static int ads8344_remove(struct spi_device *spi)
176 {
177 struct iio_dev *indio_dev = spi_get_drvdata(spi);
178 struct ads8344 *adc = iio_priv(indio_dev);
179
180 iio_device_unregister(indio_dev);
181 regulator_disable(adc->reg);
182
183 return 0;
184 }
185
186 static const struct of_device_id ads8344_of_match[] = {
187 { .compatible = "ti,ads8344", },
188 {}
189 };
190 MODULE_DEVICE_TABLE(of, ads8344_of_match);
191
192 static struct spi_driver ads8344_driver = {
193 .driver = {
194 .name = "ads8344",
195 .of_match_table = ads8344_of_match,
196 },
197 .probe = ads8344_probe,
198 .remove = ads8344_remove,
199 };
200 module_spi_driver(ads8344_driver);
201
202 MODULE_AUTHOR("Gregory CLEMENT <gregory.clement@bootlin.com>");
203 MODULE_DESCRIPTION("ADS8344 driver");
204 MODULE_LICENSE("GPL");
205