1
2
3
4
5
6
7
8
9
10
11
12#include <linux/device.h>
13#include <linux/kernel.h>
14#include <linux/slab.h>
15#include <linux/sysfs.h>
16#include <linux/spi/spi.h>
17#include <linux/regulator/consumer.h>
18#include <linux/gpio/consumer.h>
19#include <linux/err.h>
20#include <linux/module.h>
21#include <linux/bitrev.h>
22
23#include <linux/iio/iio.h>
24#include <linux/iio/sysfs.h>
25
26enum ad8366_type {
27 ID_AD8366,
28 ID_ADA4961,
29 ID_ADL5240,
30};
31
32struct ad8366_info {
33 int gain_min;
34 int gain_max;
35};
36
37struct ad8366_state {
38 struct spi_device *spi;
39 struct regulator *reg;
40 struct mutex lock;
41 struct gpio_desc *reset_gpio;
42 unsigned char ch[2];
43 enum ad8366_type type;
44 struct ad8366_info *info;
45
46
47
48
49 unsigned char data[2] ____cacheline_aligned;
50};
51
52static struct ad8366_info ad8366_infos[] = {
53 [ID_AD8366] = {
54 .gain_min = 4500,
55 .gain_max = 20500,
56 },
57 [ID_ADA4961] = {
58 .gain_min = -6000,
59 .gain_max = 15000,
60 },
61 [ID_ADL5240] = {
62 .gain_min = -11500,
63 .gain_max = 20000,
64 },
65};
66
67static int ad8366_write(struct iio_dev *indio_dev,
68 unsigned char ch_a, unsigned char ch_b)
69{
70 struct ad8366_state *st = iio_priv(indio_dev);
71 int ret;
72
73 switch (st->type) {
74 case ID_AD8366:
75 ch_a = bitrev8(ch_a & 0x3F);
76 ch_b = bitrev8(ch_b & 0x3F);
77
78 st->data[0] = ch_b >> 4;
79 st->data[1] = (ch_b << 4) | (ch_a >> 2);
80 break;
81 case ID_ADA4961:
82 st->data[0] = ch_a & 0x1F;
83 break;
84 case ID_ADL5240:
85 st->data[0] = (ch_a & 0x3F);
86 break;
87 }
88
89 ret = spi_write(st->spi, st->data, indio_dev->num_channels);
90 if (ret < 0)
91 dev_err(&indio_dev->dev, "write failed (%d)", ret);
92
93 return ret;
94}
95
96static int ad8366_read_raw(struct iio_dev *indio_dev,
97 struct iio_chan_spec const *chan,
98 int *val,
99 int *val2,
100 long m)
101{
102 struct ad8366_state *st = iio_priv(indio_dev);
103 int ret;
104 int code, gain = 0;
105
106 mutex_lock(&st->lock);
107 switch (m) {
108 case IIO_CHAN_INFO_HARDWAREGAIN:
109 code = st->ch[chan->channel];
110
111 switch (st->type) {
112 case ID_AD8366:
113 gain = code * 253 + 4500;
114 break;
115 case ID_ADA4961:
116 gain = 15000 - code * 1000;
117 break;
118 case ID_ADL5240:
119 gain = 20000 - 31500 + code * 500;
120 break;
121 }
122
123
124 *val = gain / 1000;
125 *val2 = (gain % 1000) * 1000;
126
127 ret = IIO_VAL_INT_PLUS_MICRO_DB;
128 break;
129 default:
130 ret = -EINVAL;
131 }
132 mutex_unlock(&st->lock);
133
134 return ret;
135};
136
137static int ad8366_write_raw(struct iio_dev *indio_dev,
138 struct iio_chan_spec const *chan,
139 int val,
140 int val2,
141 long mask)
142{
143 struct ad8366_state *st = iio_priv(indio_dev);
144 struct ad8366_info *inf = st->info;
145 int code = 0, gain;
146 int ret;
147
148
149 if (val < 0)
150 gain = (val * 1000) - (val2 / 1000);
151 else
152 gain = (val * 1000) + (val2 / 1000);
153
154 if (gain > inf->gain_max || gain < inf->gain_min)
155 return -EINVAL;
156
157 switch (st->type) {
158 case ID_AD8366:
159 code = (gain - 4500) / 253;
160 break;
161 case ID_ADA4961:
162 code = (15000 - gain) / 1000;
163 break;
164 case ID_ADL5240:
165 code = ((gain - 500 - 20000) / 500) & 0x3F;
166 break;
167 }
168
169 mutex_lock(&st->lock);
170 switch (mask) {
171 case IIO_CHAN_INFO_HARDWAREGAIN:
172 st->ch[chan->channel] = code;
173 ret = ad8366_write(indio_dev, st->ch[0], st->ch[1]);
174 break;
175 default:
176 ret = -EINVAL;
177 }
178 mutex_unlock(&st->lock);
179
180 return ret;
181}
182
183static const struct iio_info ad8366_info = {
184 .read_raw = &ad8366_read_raw,
185 .write_raw = &ad8366_write_raw,
186};
187
188#define AD8366_CHAN(_channel) { \
189 .type = IIO_VOLTAGE, \
190 .output = 1, \
191 .indexed = 1, \
192 .channel = _channel, \
193 .info_mask_separate = BIT(IIO_CHAN_INFO_HARDWAREGAIN),\
194}
195
196static const struct iio_chan_spec ad8366_channels[] = {
197 AD8366_CHAN(0),
198 AD8366_CHAN(1),
199};
200
201static const struct iio_chan_spec ada4961_channels[] = {
202 AD8366_CHAN(0),
203};
204
205static int ad8366_probe(struct spi_device *spi)
206{
207 struct iio_dev *indio_dev;
208 struct ad8366_state *st;
209 int ret;
210
211 indio_dev = devm_iio_device_alloc(&spi->dev, sizeof(*st));
212 if (indio_dev == NULL)
213 return -ENOMEM;
214
215 st = iio_priv(indio_dev);
216
217 st->reg = devm_regulator_get(&spi->dev, "vcc");
218 if (!IS_ERR(st->reg)) {
219 ret = regulator_enable(st->reg);
220 if (ret)
221 return ret;
222 }
223
224 spi_set_drvdata(spi, indio_dev);
225 mutex_init(&st->lock);
226 st->spi = spi;
227 st->type = spi_get_device_id(spi)->driver_data;
228
229 switch (st->type) {
230 case ID_AD8366:
231 indio_dev->channels = ad8366_channels;
232 indio_dev->num_channels = ARRAY_SIZE(ad8366_channels);
233 break;
234 case ID_ADA4961:
235 case ID_ADL5240:
236 st->reset_gpio = devm_gpiod_get(&spi->dev, "reset",
237 GPIOD_OUT_HIGH);
238 indio_dev->channels = ada4961_channels;
239 indio_dev->num_channels = ARRAY_SIZE(ada4961_channels);
240 break;
241 default:
242 dev_err(&spi->dev, "Invalid device ID\n");
243 ret = -EINVAL;
244 goto error_disable_reg;
245 }
246
247 st->info = &ad8366_infos[st->type];
248 indio_dev->dev.parent = &spi->dev;
249 indio_dev->name = spi_get_device_id(spi)->name;
250 indio_dev->info = &ad8366_info;
251 indio_dev->modes = INDIO_DIRECT_MODE;
252
253 ret = ad8366_write(indio_dev, 0 , 0);
254 if (ret < 0)
255 goto error_disable_reg;
256
257 ret = iio_device_register(indio_dev);
258 if (ret)
259 goto error_disable_reg;
260
261 return 0;
262
263error_disable_reg:
264 if (!IS_ERR(st->reg))
265 regulator_disable(st->reg);
266
267 return ret;
268}
269
270static int ad8366_remove(struct spi_device *spi)
271{
272 struct iio_dev *indio_dev = spi_get_drvdata(spi);
273 struct ad8366_state *st = iio_priv(indio_dev);
274 struct regulator *reg = st->reg;
275
276 iio_device_unregister(indio_dev);
277
278 if (!IS_ERR(reg))
279 regulator_disable(reg);
280
281 return 0;
282}
283
284static const struct spi_device_id ad8366_id[] = {
285 {"ad8366", ID_AD8366},
286 {"ada4961", ID_ADA4961},
287 {"adl5240", ID_ADL5240},
288 {}
289};
290MODULE_DEVICE_TABLE(spi, ad8366_id);
291
292static struct spi_driver ad8366_driver = {
293 .driver = {
294 .name = KBUILD_MODNAME,
295 },
296 .probe = ad8366_probe,
297 .remove = ad8366_remove,
298 .id_table = ad8366_id,
299};
300
301module_spi_driver(ad8366_driver);
302
303MODULE_AUTHOR("Michael Hennerich <michael.hennerich@analog.com>");
304MODULE_DESCRIPTION("Analog Devices AD8366 and similar Gain Amplifiers");
305MODULE_LICENSE("GPL v2");
306
