1
2
3
4
5
6
7
8
9
10
11
12
13#include <linux/module.h>
14#include <linux/spi/spi.h>
15#include <linux/iio/iio.h>
16#include <linux/regulator/consumer.h>
17#include <linux/iio/buffer.h>
18#include <linux/iio/trigger.h>
19#include <linux/iio/triggered_buffer.h>
20#include <linux/iio/trigger_consumer.h>
21
22enum {
23 adc0831,
24 adc0832,
25 adc0834,
26 adc0838,
27};
28
29struct adc0832 {
30 struct spi_device *spi;
31 struct regulator *reg;
32 struct mutex lock;
33 u8 mux_bits;
34
35 u8 tx_buf[2] ____cacheline_aligned;
36 u8 rx_buf[2];
37};
38
39#define ADC0832_VOLTAGE_CHANNEL(chan) \
40 { \
41 .type = IIO_VOLTAGE, \
42 .indexed = 1, \
43 .channel = chan, \
44 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW), \
45 .info_mask_shared_by_type = BIT(IIO_CHAN_INFO_SCALE), \
46 .scan_index = chan, \
47 .scan_type = { \
48 .sign = 'u', \
49 .realbits = 8, \
50 .storagebits = 8, \
51 }, \
52 }
53
54#define ADC0832_VOLTAGE_CHANNEL_DIFF(chan1, chan2, si) \
55 { \
56 .type = IIO_VOLTAGE, \
57 .indexed = 1, \
58 .channel = (chan1), \
59 .channel2 = (chan2), \
60 .differential = 1, \
61 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW), \
62 .info_mask_shared_by_type = BIT(IIO_CHAN_INFO_SCALE), \
63 .scan_index = si, \
64 .scan_type = { \
65 .sign = 'u', \
66 .realbits = 8, \
67 .storagebits = 8, \
68 }, \
69 }
70
71static const struct iio_chan_spec adc0831_channels[] = {
72 ADC0832_VOLTAGE_CHANNEL_DIFF(0, 1, 0),
73 IIO_CHAN_SOFT_TIMESTAMP(1),
74};
75
76static const struct iio_chan_spec adc0832_channels[] = {
77 ADC0832_VOLTAGE_CHANNEL(0),
78 ADC0832_VOLTAGE_CHANNEL(1),
79 ADC0832_VOLTAGE_CHANNEL_DIFF(0, 1, 2),
80 ADC0832_VOLTAGE_CHANNEL_DIFF(1, 0, 3),
81 IIO_CHAN_SOFT_TIMESTAMP(4),
82};
83
84static const struct iio_chan_spec adc0834_channels[] = {
85 ADC0832_VOLTAGE_CHANNEL(0),
86 ADC0832_VOLTAGE_CHANNEL(1),
87 ADC0832_VOLTAGE_CHANNEL(2),
88 ADC0832_VOLTAGE_CHANNEL(3),
89 ADC0832_VOLTAGE_CHANNEL_DIFF(0, 1, 4),
90 ADC0832_VOLTAGE_CHANNEL_DIFF(1, 0, 5),
91 ADC0832_VOLTAGE_CHANNEL_DIFF(2, 3, 6),
92 ADC0832_VOLTAGE_CHANNEL_DIFF(3, 2, 7),
93 IIO_CHAN_SOFT_TIMESTAMP(8),
94};
95
96static const struct iio_chan_spec adc0838_channels[] = {
97 ADC0832_VOLTAGE_CHANNEL(0),
98 ADC0832_VOLTAGE_CHANNEL(1),
99 ADC0832_VOLTAGE_CHANNEL(2),
100 ADC0832_VOLTAGE_CHANNEL(3),
101 ADC0832_VOLTAGE_CHANNEL(4),
102 ADC0832_VOLTAGE_CHANNEL(5),
103 ADC0832_VOLTAGE_CHANNEL(6),
104 ADC0832_VOLTAGE_CHANNEL(7),
105 ADC0832_VOLTAGE_CHANNEL_DIFF(0, 1, 8),
106 ADC0832_VOLTAGE_CHANNEL_DIFF(1, 0, 9),
107 ADC0832_VOLTAGE_CHANNEL_DIFF(2, 3, 10),
108 ADC0832_VOLTAGE_CHANNEL_DIFF(3, 2, 11),
109 ADC0832_VOLTAGE_CHANNEL_DIFF(4, 5, 12),
110 ADC0832_VOLTAGE_CHANNEL_DIFF(5, 4, 13),
111 ADC0832_VOLTAGE_CHANNEL_DIFF(6, 7, 14),
112 ADC0832_VOLTAGE_CHANNEL_DIFF(7, 6, 15),
113 IIO_CHAN_SOFT_TIMESTAMP(16),
114};
115
116static int adc0831_adc_conversion(struct adc0832 *adc)
117{
118 struct spi_device *spi = adc->spi;
119 int ret;
120
121 ret = spi_read(spi, &adc->rx_buf, 2);
122 if (ret)
123 return ret;
124
125
126
127
128 return (adc->rx_buf[0] << 2 & 0xff) | (adc->rx_buf[1] >> 6);
129}
130
131static int adc0832_adc_conversion(struct adc0832 *adc, int channel,
132 bool differential)
133{
134 struct spi_device *spi = adc->spi;
135 struct spi_transfer xfer = {
136 .tx_buf = adc->tx_buf,
137 .rx_buf = adc->rx_buf,
138 .len = 2,
139 };
140 int ret;
141
142 if (!adc->mux_bits)
143 return adc0831_adc_conversion(adc);
144
145
146 adc->tx_buf[0] = 1 << (adc->mux_bits + 1);
147
148 adc->tx_buf[0] |= differential ? 0 : (1 << adc->mux_bits);
149
150 adc->tx_buf[0] |= (channel % 2) << (adc->mux_bits - 1);
151
152 if (adc->mux_bits > 1)
153 adc->tx_buf[0] |= channel / 2;
154
155
156 adc->tx_buf[0] <<= 1;
157
158 ret = spi_sync_transfer(spi, &xfer, 1);
159 if (ret)
160 return ret;
161
162 return adc->rx_buf[1];
163}
164
165static int adc0832_read_raw(struct iio_dev *iio,
166 struct iio_chan_spec const *channel, int *value,
167 int *shift, long mask)
168{
169 struct adc0832 *adc = iio_priv(iio);
170
171 switch (mask) {
172 case IIO_CHAN_INFO_RAW:
173 mutex_lock(&adc->lock);
174 *value = adc0832_adc_conversion(adc, channel->channel,
175 channel->differential);
176 mutex_unlock(&adc->lock);
177 if (*value < 0)
178 return *value;
179
180 return IIO_VAL_INT;
181 case IIO_CHAN_INFO_SCALE:
182 *value = regulator_get_voltage(adc->reg);
183 if (*value < 0)
184 return *value;
185
186
187 *value /= 1000;
188 *shift = 8;
189
190 return IIO_VAL_FRACTIONAL_LOG2;
191 }
192
193 return -EINVAL;
194}
195
196static const struct iio_info adc0832_info = {
197 .read_raw = adc0832_read_raw,
198 .driver_module = THIS_MODULE,
199};
200
201static irqreturn_t adc0832_trigger_handler(int irq, void *p)
202{
203 struct iio_poll_func *pf = p;
204 struct iio_dev *indio_dev = pf->indio_dev;
205 struct adc0832 *adc = iio_priv(indio_dev);
206 u8 data[24] = { };
207 int scan_index;
208 int i = 0;
209
210 mutex_lock(&adc->lock);
211
212 for_each_set_bit(scan_index, indio_dev->active_scan_mask,
213 indio_dev->masklength) {
214 const struct iio_chan_spec *scan_chan =
215 &indio_dev->channels[scan_index];
216 int ret = adc0832_adc_conversion(adc, scan_chan->channel,
217 scan_chan->differential);
218 if (ret < 0) {
219 dev_warn(&adc->spi->dev,
220 "failed to get conversion data\n");
221 goto out;
222 }
223
224 data[i] = ret;
225 i++;
226 }
227 iio_push_to_buffers_with_timestamp(indio_dev, data,
228 iio_get_time_ns(indio_dev));
229out:
230 mutex_unlock(&adc->lock);
231
232 iio_trigger_notify_done(indio_dev->trig);
233
234 return IRQ_HANDLED;
235}
236
237static int adc0832_probe(struct spi_device *spi)
238{
239 struct iio_dev *indio_dev;
240 struct adc0832 *adc;
241 int ret;
242
243 indio_dev = devm_iio_device_alloc(&spi->dev, sizeof(*adc));
244 if (!indio_dev)
245 return -ENOMEM;
246
247 adc = iio_priv(indio_dev);
248 adc->spi = spi;
249 mutex_init(&adc->lock);
250
251 indio_dev->name = spi_get_device_id(spi)->name;
252 indio_dev->dev.parent = &spi->dev;
253 indio_dev->dev.of_node = spi->dev.of_node;
254 indio_dev->info = &adc0832_info;
255 indio_dev->modes = INDIO_DIRECT_MODE;
256
257 switch (spi_get_device_id(spi)->driver_data) {
258 case adc0831:
259 adc->mux_bits = 0;
260 indio_dev->channels = adc0831_channels;
261 indio_dev->num_channels = ARRAY_SIZE(adc0831_channels);
262 break;
263 case adc0832:
264 adc->mux_bits = 1;
265 indio_dev->channels = adc0832_channels;
266 indio_dev->num_channels = ARRAY_SIZE(adc0832_channels);
267 break;
268 case adc0834:
269 adc->mux_bits = 2;
270 indio_dev->channels = adc0834_channels;
271 indio_dev->num_channels = ARRAY_SIZE(adc0834_channels);
272 break;
273 case adc0838:
274 adc->mux_bits = 3;
275 indio_dev->channels = adc0838_channels;
276 indio_dev->num_channels = ARRAY_SIZE(adc0838_channels);
277 break;
278 default:
279 return -EINVAL;
280 }
281
282 adc->reg = devm_regulator_get(&spi->dev, "vref");
283 if (IS_ERR(adc->reg))
284 return PTR_ERR(adc->reg);
285
286 ret = regulator_enable(adc->reg);
287 if (ret)
288 return ret;
289
290 spi_set_drvdata(spi, indio_dev);
291
292 ret = iio_triggered_buffer_setup(indio_dev, NULL,
293 adc0832_trigger_handler, NULL);
294 if (ret)
295 goto err_reg_disable;
296
297 ret = iio_device_register(indio_dev);
298 if (ret)
299 goto err_buffer_cleanup;
300
301 return 0;
302err_buffer_cleanup:
303 iio_triggered_buffer_cleanup(indio_dev);
304err_reg_disable:
305 regulator_disable(adc->reg);
306
307 return ret;
308}
309
310static int adc0832_remove(struct spi_device *spi)
311{
312 struct iio_dev *indio_dev = spi_get_drvdata(spi);
313 struct adc0832 *adc = iio_priv(indio_dev);
314
315 iio_device_unregister(indio_dev);
316 iio_triggered_buffer_cleanup(indio_dev);
317 regulator_disable(adc->reg);
318
319 return 0;
320}
321
322#ifdef CONFIG_OF
323
324static const struct of_device_id adc0832_dt_ids[] = {
325 { .compatible = "ti,adc0831", },
326 { .compatible = "ti,adc0832", },
327 { .compatible = "ti,adc0834", },
328 { .compatible = "ti,adc0838", },
329 {}
330};
331MODULE_DEVICE_TABLE(of, adc0832_dt_ids);
332
333#endif
334
335static const struct spi_device_id adc0832_id[] = {
336 { "adc0831", adc0831 },
337 { "adc0832", adc0832 },
338 { "adc0834", adc0834 },
339 { "adc0838", adc0838 },
340 {}
341};
342MODULE_DEVICE_TABLE(spi, adc0832_id);
343
344static struct spi_driver adc0832_driver = {
345 .driver = {
346 .name = "adc0832",
347 .of_match_table = of_match_ptr(adc0832_dt_ids),
348 },
349 .probe = adc0832_probe,
350 .remove = adc0832_remove,
351 .id_table = adc0832_id,
352};
353module_spi_driver(adc0832_driver);
354
355MODULE_AUTHOR("Akinobu Mita <akinobu.mita@gmail.com>");
356MODULE_DESCRIPTION("ADC0831/ADC0832/ADC0834/ADC0838 driver");
357MODULE_LICENSE("GPL v2");
358
