GNU Linux-libre 4.9.322-gnu1
[releases.git] / drivers / iio / adc / ti-adc161s626.c
1 /*
2  * ti-adc161s626.c - Texas Instruments ADC161S626 1-channel differential ADC
3  *
4  * ADC Devices Supported:
5  *  adc141s626 - 14-bit ADC
6  *  adc161s626 - 16-bit ADC
7  *
8  * Copyright (C) 2016 Matt Ranostay <mranostay@gmail.com>
9  *
10  * This program is free software; you can redistribute it and/or modify
11  * it under the terms of the GNU General Public License as published by
12  * the Free Software Foundation; either version 2 of the License, or
13  * (at your option) any later version.
14  *
15  * This program is distributed in the hope that it will be useful,
16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18  * GNU General Public License for more details.
19  */
20
21 #include <linux/module.h>
22 #include <linux/init.h>
23 #include <linux/err.h>
24 #include <linux/spi/spi.h>
25 #include <linux/iio/iio.h>
26 #include <linux/iio/trigger.h>
27 #include <linux/iio/buffer.h>
28 #include <linux/iio/trigger_consumer.h>
29 #include <linux/iio/triggered_buffer.h>
30
31 #define TI_ADC_DRV_NAME "ti-adc161s626"
32
33 enum {
34         TI_ADC141S626,
35         TI_ADC161S626,
36 };
37
38 static const struct iio_chan_spec ti_adc141s626_channels[] = {
39         {
40                 .type = IIO_VOLTAGE,
41                 .channel = 0,
42                 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW),
43                 .scan_index = 0,
44                 .scan_type = {
45                         .sign = 's',
46                         .realbits = 14,
47                         .storagebits = 16,
48                 },
49         },
50         IIO_CHAN_SOFT_TIMESTAMP(1),
51 };
52
53 static const struct iio_chan_spec ti_adc161s626_channels[] = {
54         {
55                 .type = IIO_VOLTAGE,
56                 .channel = 0,
57                 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW),
58                 .scan_index = 0,
59                 .scan_type = {
60                         .sign = 's',
61                         .realbits = 16,
62                         .storagebits = 16,
63                 },
64         },
65         IIO_CHAN_SOFT_TIMESTAMP(1),
66 };
67
68 struct ti_adc_data {
69         struct iio_dev *indio_dev;
70         struct spi_device *spi;
71         u8 read_size;
72         u8 shift;
73
74         u8 buffer[16] ____cacheline_aligned;
75 };
76
77 static int ti_adc_read_measurement(struct ti_adc_data *data,
78                                    struct iio_chan_spec const *chan, int *val)
79 {
80         int ret;
81
82         switch (data->read_size) {
83         case 2: {
84                 __be16 buf;
85
86                 ret = spi_read(data->spi, (void *) &buf, 2);
87                 if (ret)
88                         return ret;
89
90                 *val = be16_to_cpu(buf);
91                 break;
92         }
93         case 3: {
94                 __be32 buf;
95
96                 ret = spi_read(data->spi, (void *) &buf, 3);
97                 if (ret)
98                         return ret;
99
100                 *val = be32_to_cpu(buf) >> 8;
101                 break;
102         }
103         default:
104                 return -EINVAL;
105         }
106
107         *val = sign_extend32(*val >> data->shift, chan->scan_type.realbits - 1);
108
109         return 0;
110 }
111
112 static irqreturn_t ti_adc_trigger_handler(int irq, void *private)
113 {
114         struct iio_poll_func *pf = private;
115         struct iio_dev *indio_dev = pf->indio_dev;
116         struct ti_adc_data *data = iio_priv(indio_dev);
117         int ret;
118
119         ret = ti_adc_read_measurement(data, &indio_dev->channels[0],
120                                      (int *) &data->buffer);
121         if (!ret)
122                 iio_push_to_buffers_with_timestamp(indio_dev,
123                                         data->buffer,
124                                         iio_get_time_ns(indio_dev));
125
126         iio_trigger_notify_done(indio_dev->trig);
127
128         return IRQ_HANDLED;
129 }
130
131 static int ti_adc_read_raw(struct iio_dev *indio_dev,
132                            struct iio_chan_spec const *chan,
133                            int *val, int *val2, long mask)
134 {
135         struct ti_adc_data *data = iio_priv(indio_dev);
136         int ret;
137
138         if (mask != IIO_CHAN_INFO_RAW)
139                 return -EINVAL;
140
141         ret = iio_device_claim_direct_mode(indio_dev);
142         if (ret)
143                 return ret;
144
145         ret = ti_adc_read_measurement(data, chan, val);
146         iio_device_release_direct_mode(indio_dev);
147
148         if (!ret)
149                 return IIO_VAL_INT;
150
151         return 0;
152 }
153
154 static const struct iio_info ti_adc_info = {
155         .driver_module = THIS_MODULE,
156         .read_raw = ti_adc_read_raw,
157 };
158
159 static int ti_adc_probe(struct spi_device *spi)
160 {
161         struct iio_dev *indio_dev;
162         struct ti_adc_data *data;
163         int ret;
164
165         indio_dev = devm_iio_device_alloc(&spi->dev, sizeof(*data));
166         if (!indio_dev)
167                 return -ENOMEM;
168
169         indio_dev->info = &ti_adc_info;
170         indio_dev->dev.parent = &spi->dev;
171         indio_dev->dev.of_node = spi->dev.of_node;
172         indio_dev->name = TI_ADC_DRV_NAME;
173         indio_dev->modes = INDIO_DIRECT_MODE;
174         spi_set_drvdata(spi, indio_dev);
175
176         data = iio_priv(indio_dev);
177         data->spi = spi;
178
179         switch (spi_get_device_id(spi)->driver_data) {
180         case TI_ADC141S626:
181                 indio_dev->channels = ti_adc141s626_channels;
182                 indio_dev->num_channels = ARRAY_SIZE(ti_adc141s626_channels);
183                 data->shift = 0;
184                 data->read_size = 2;
185                 break;
186         case TI_ADC161S626:
187                 indio_dev->channels = ti_adc161s626_channels;
188                 indio_dev->num_channels = ARRAY_SIZE(ti_adc161s626_channels);
189                 data->shift = 6;
190                 data->read_size = 3;
191                 break;
192         }
193
194         ret = iio_triggered_buffer_setup(indio_dev, NULL,
195                                          ti_adc_trigger_handler, NULL);
196         if (ret)
197                 return ret;
198
199         ret = iio_device_register(indio_dev);
200         if (ret)
201                 goto error_unreg_buffer;
202
203         return 0;
204
205 error_unreg_buffer:
206         iio_triggered_buffer_cleanup(indio_dev);
207
208         return ret;
209 }
210
211 static int ti_adc_remove(struct spi_device *spi)
212 {
213         struct iio_dev *indio_dev = spi_get_drvdata(spi);
214
215         iio_device_unregister(indio_dev);
216         iio_triggered_buffer_cleanup(indio_dev);
217
218         return 0;
219 }
220
221 static const struct of_device_id ti_adc_dt_ids[] = {
222         { .compatible = "ti,adc141s626", },
223         { .compatible = "ti,adc161s626", },
224         {}
225 };
226 MODULE_DEVICE_TABLE(of, ti_adc_dt_ids);
227
228 static const struct spi_device_id ti_adc_id[] = {
229         {"adc141s626", TI_ADC141S626},
230         {"adc161s626", TI_ADC161S626},
231         {},
232 };
233 MODULE_DEVICE_TABLE(spi, ti_adc_id);
234
235 static struct spi_driver ti_adc_driver = {
236         .driver = {
237                 .name   = TI_ADC_DRV_NAME,
238                 .of_match_table = of_match_ptr(ti_adc_dt_ids),
239         },
240         .probe          = ti_adc_probe,
241         .remove         = ti_adc_remove,
242         .id_table       = ti_adc_id,
243 };
244 module_spi_driver(ti_adc_driver);
245
246 MODULE_AUTHOR("Matt Ranostay <mranostay@gmail.com>");
247 MODULE_DESCRIPTION("Texas Instruments ADC1x1S 1-channel differential ADC");
248 MODULE_LICENSE("GPL");