1 | // SPDX-License-Identifier: GPL-2.0-only |
2 | /* |
3 | * TI ADC108S102 SPI ADC driver |
4 | * |
5 | * Copyright (c) 2013-2015 Intel Corporation. |
6 | * Copyright (c) 2017 Siemens AG |
7 | * |
8 | * This IIO device driver is designed to work with the following |
9 | * analog to digital converters from Texas Instruments: |
10 | * ADC108S102 |
11 | * ADC128S102 |
12 | * The communication with ADC chip is via the SPI bus (mode 3). |
13 | */ |
14 | |
15 | #include <linux/acpi.h> |
16 | #include <linux/iio/iio.h> |
17 | #include <linux/iio/buffer.h> |
18 | #include <linux/iio/types.h> |
19 | #include <linux/iio/triggered_buffer.h> |
20 | #include <linux/iio/trigger_consumer.h> |
21 | #include <linux/interrupt.h> |
22 | #include <linux/module.h> |
23 | #include <linux/mod_devicetable.h> |
24 | #include <linux/property.h> |
25 | #include <linux/regulator/consumer.h> |
26 | #include <linux/spi/spi.h> |
27 | |
28 | /* |
29 | * In case of ACPI, we use the hard-wired 5000 mV of the Galileo and IOT2000 |
30 | * boards as default for the reference pin VA. Device tree users encode that |
31 | * via the vref-supply regulator. |
32 | */ |
33 | #define ADC108S102_VA_MV_ACPI_DEFAULT 5000 |
34 | |
35 | /* |
36 | * Defining the ADC resolution being 12 bits, we can use the same driver for |
37 | * both ADC108S102 (10 bits resolution) and ADC128S102 (12 bits resolution) |
38 | * chips. The ADC108S102 effectively returns a 12-bit result with the 2 |
39 | * least-significant bits unset. |
40 | */ |
41 | #define ADC108S102_BITS 12 |
42 | #define ADC108S102_MAX_CHANNELS 8 |
43 | |
44 | /* |
45 | * 16-bit SPI command format: |
46 | * [15:14] Ignored |
47 | * [13:11] 3-bit channel address |
48 | * [10:0] Ignored |
49 | */ |
50 | #define ADC108S102_CMD(ch) ((u16)(ch) << 11) |
51 | |
52 | /* |
53 | * 16-bit SPI response format: |
54 | * [15:12] Zeros |
55 | * [11:0] 12-bit ADC sample (for ADC108S102, [1:0] will always be 0). |
56 | */ |
57 | #define ADC108S102_RES_DATA(res) ((u16)res & GENMASK(11, 0)) |
58 | |
59 | struct adc108s102_state { |
60 | struct spi_device *spi; |
61 | struct regulator *reg; |
62 | u32 va_millivolt; |
63 | /* SPI transfer used by triggered buffer handler*/ |
64 | struct spi_transfer ring_xfer; |
65 | /* SPI transfer used by direct scan */ |
66 | struct spi_transfer scan_single_xfer; |
67 | /* SPI message used by ring_xfer SPI transfer */ |
68 | struct spi_message ring_msg; |
69 | /* SPI message used by scan_single_xfer SPI transfer */ |
70 | struct spi_message scan_single_msg; |
71 | |
72 | /* |
73 | * SPI message buffers: |
74 | * tx_buf: |C0|C1|C2|C3|C4|C5|C6|C7|XX| |
75 | * rx_buf: |XX|R0|R1|R2|R3|R4|R5|R6|R7|tt|tt|tt|tt| |
76 | * |
77 | * tx_buf: 8 channel read commands, plus 1 dummy command |
78 | * rx_buf: 1 dummy response, 8 channel responses |
79 | */ |
80 | __be16 rx_buf[9] __aligned(IIO_DMA_MINALIGN); |
81 | __be16 tx_buf[9] __aligned(IIO_DMA_MINALIGN); |
82 | }; |
83 | |
84 | #define ADC108S102_V_CHAN(index) \ |
85 | { \ |
86 | .type = IIO_VOLTAGE, \ |
87 | .indexed = 1, \ |
88 | .channel = index, \ |
89 | .info_mask_separate = BIT(IIO_CHAN_INFO_RAW) | \ |
90 | BIT(IIO_CHAN_INFO_SCALE), \ |
91 | .address = index, \ |
92 | .scan_index = index, \ |
93 | .scan_type = { \ |
94 | .sign = 'u', \ |
95 | .realbits = ADC108S102_BITS, \ |
96 | .storagebits = 16, \ |
97 | .endianness = IIO_BE, \ |
98 | }, \ |
99 | } |
100 | |
101 | static const struct iio_chan_spec adc108s102_channels[] = { |
102 | ADC108S102_V_CHAN(0), |
103 | ADC108S102_V_CHAN(1), |
104 | ADC108S102_V_CHAN(2), |
105 | ADC108S102_V_CHAN(3), |
106 | ADC108S102_V_CHAN(4), |
107 | ADC108S102_V_CHAN(5), |
108 | ADC108S102_V_CHAN(6), |
109 | ADC108S102_V_CHAN(7), |
110 | IIO_CHAN_SOFT_TIMESTAMP(8), |
111 | }; |
112 | |
113 | static int adc108s102_update_scan_mode(struct iio_dev *indio_dev, |
114 | unsigned long const *active_scan_mask) |
115 | { |
116 | struct adc108s102_state *st = iio_priv(indio_dev); |
117 | unsigned int bit, cmds; |
118 | |
119 | /* |
120 | * Fill in the first x shorts of tx_buf with the number of channels |
121 | * enabled for sampling by the triggered buffer. |
122 | */ |
123 | cmds = 0; |
124 | for_each_set_bit(bit, active_scan_mask, ADC108S102_MAX_CHANNELS) |
125 | st->tx_buf[cmds++] = cpu_to_be16(ADC108S102_CMD(bit)); |
126 | |
127 | /* One dummy command added, to clock in the last response */ |
128 | st->tx_buf[cmds++] = 0x00; |
129 | |
130 | /* build SPI ring message */ |
131 | st->ring_xfer.tx_buf = &st->tx_buf[0]; |
132 | st->ring_xfer.rx_buf = &st->rx_buf[0]; |
133 | st->ring_xfer.len = cmds * sizeof(st->tx_buf[0]); |
134 | |
135 | spi_message_init_with_transfers(m: &st->ring_msg, xfers: &st->ring_xfer, num_xfers: 1); |
136 | |
137 | return 0; |
138 | } |
139 | |
140 | static irqreturn_t adc108s102_trigger_handler(int irq, void *p) |
141 | { |
142 | struct iio_poll_func *pf = p; |
143 | struct iio_dev *indio_dev = pf->indio_dev; |
144 | struct adc108s102_state *st = iio_priv(indio_dev); |
145 | int ret; |
146 | |
147 | ret = spi_sync(spi: st->spi, message: &st->ring_msg); |
148 | if (ret < 0) |
149 | goto out_notify; |
150 | |
151 | /* Skip the dummy response in the first slot */ |
152 | iio_push_to_buffers_with_ts_unaligned(indio_dev, |
153 | data: &st->rx_buf[1], |
154 | data_sz: st->ring_xfer.len - sizeof(st->rx_buf[1]), |
155 | timestamp: iio_get_time_ns(indio_dev)); |
156 | |
157 | out_notify: |
158 | iio_trigger_notify_done(trig: indio_dev->trig); |
159 | |
160 | return IRQ_HANDLED; |
161 | } |
162 | |
163 | static int adc108s102_scan_direct(struct adc108s102_state *st, unsigned int ch) |
164 | { |
165 | int ret; |
166 | |
167 | st->tx_buf[0] = cpu_to_be16(ADC108S102_CMD(ch)); |
168 | ret = spi_sync(spi: st->spi, message: &st->scan_single_msg); |
169 | if (ret) |
170 | return ret; |
171 | |
172 | /* Skip the dummy response in the first slot */ |
173 | return be16_to_cpu(st->rx_buf[1]); |
174 | } |
175 | |
176 | static int adc108s102_read_raw(struct iio_dev *indio_dev, |
177 | struct iio_chan_spec const *chan, |
178 | int *val, int *val2, long m) |
179 | { |
180 | struct adc108s102_state *st = iio_priv(indio_dev); |
181 | int ret; |
182 | |
183 | switch (m) { |
184 | case IIO_CHAN_INFO_RAW: |
185 | ret = iio_device_claim_direct_mode(indio_dev); |
186 | if (ret) |
187 | return ret; |
188 | |
189 | ret = adc108s102_scan_direct(st, ch: chan->address); |
190 | |
191 | iio_device_release_direct_mode(indio_dev); |
192 | |
193 | if (ret < 0) |
194 | return ret; |
195 | |
196 | *val = ADC108S102_RES_DATA(ret); |
197 | |
198 | return IIO_VAL_INT; |
199 | case IIO_CHAN_INFO_SCALE: |
200 | if (chan->type != IIO_VOLTAGE) |
201 | break; |
202 | |
203 | *val = st->va_millivolt; |
204 | *val2 = chan->scan_type.realbits; |
205 | |
206 | return IIO_VAL_FRACTIONAL_LOG2; |
207 | default: |
208 | break; |
209 | } |
210 | |
211 | return -EINVAL; |
212 | } |
213 | |
214 | static const struct iio_info adc108s102_info = { |
215 | .read_raw = &adc108s102_read_raw, |
216 | .update_scan_mode = &adc108s102_update_scan_mode, |
217 | }; |
218 | |
219 | static void adc108s102_reg_disable(void *reg) |
220 | { |
221 | regulator_disable(regulator: reg); |
222 | } |
223 | |
224 | static int adc108s102_probe(struct spi_device *spi) |
225 | { |
226 | struct adc108s102_state *st; |
227 | struct iio_dev *indio_dev; |
228 | int ret; |
229 | |
230 | indio_dev = devm_iio_device_alloc(parent: &spi->dev, sizeof_priv: sizeof(*st)); |
231 | if (!indio_dev) |
232 | return -ENOMEM; |
233 | |
234 | st = iio_priv(indio_dev); |
235 | |
236 | if (ACPI_COMPANION(&spi->dev)) { |
237 | st->va_millivolt = ADC108S102_VA_MV_ACPI_DEFAULT; |
238 | } else { |
239 | st->reg = devm_regulator_get(dev: &spi->dev, id: "vref" ); |
240 | if (IS_ERR(ptr: st->reg)) |
241 | return PTR_ERR(ptr: st->reg); |
242 | |
243 | ret = regulator_enable(regulator: st->reg); |
244 | if (ret < 0) { |
245 | dev_err(&spi->dev, "Cannot enable vref regulator\n" ); |
246 | return ret; |
247 | } |
248 | ret = devm_add_action_or_reset(&spi->dev, adc108s102_reg_disable, |
249 | st->reg); |
250 | if (ret) |
251 | return ret; |
252 | |
253 | ret = regulator_get_voltage(regulator: st->reg); |
254 | if (ret < 0) { |
255 | dev_err(&spi->dev, "vref get voltage failed\n" ); |
256 | return ret; |
257 | } |
258 | |
259 | st->va_millivolt = ret / 1000; |
260 | } |
261 | |
262 | st->spi = spi; |
263 | |
264 | indio_dev->name = spi->modalias; |
265 | indio_dev->modes = INDIO_DIRECT_MODE; |
266 | indio_dev->channels = adc108s102_channels; |
267 | indio_dev->num_channels = ARRAY_SIZE(adc108s102_channels); |
268 | indio_dev->info = &adc108s102_info; |
269 | |
270 | /* Setup default message */ |
271 | st->scan_single_xfer.tx_buf = st->tx_buf; |
272 | st->scan_single_xfer.rx_buf = st->rx_buf; |
273 | st->scan_single_xfer.len = 2 * sizeof(st->tx_buf[0]); |
274 | |
275 | spi_message_init_with_transfers(m: &st->scan_single_msg, |
276 | xfers: &st->scan_single_xfer, num_xfers: 1); |
277 | |
278 | ret = devm_iio_triggered_buffer_setup(&spi->dev, indio_dev, NULL, |
279 | &adc108s102_trigger_handler, |
280 | NULL); |
281 | if (ret) |
282 | return ret; |
283 | |
284 | ret = devm_iio_device_register(&spi->dev, indio_dev); |
285 | if (ret) |
286 | dev_err(&spi->dev, "Failed to register IIO device\n" ); |
287 | return ret; |
288 | } |
289 | |
290 | static const struct of_device_id adc108s102_of_match[] = { |
291 | { .compatible = "ti,adc108s102" }, |
292 | { } |
293 | }; |
294 | MODULE_DEVICE_TABLE(of, adc108s102_of_match); |
295 | |
296 | #ifdef CONFIG_ACPI |
297 | static const struct acpi_device_id adc108s102_acpi_ids[] = { |
298 | { "INT3495" , 0 }, |
299 | { } |
300 | }; |
301 | MODULE_DEVICE_TABLE(acpi, adc108s102_acpi_ids); |
302 | #endif |
303 | |
304 | static const struct spi_device_id adc108s102_id[] = { |
305 | { "adc108s102" , 0 }, |
306 | { } |
307 | }; |
308 | MODULE_DEVICE_TABLE(spi, adc108s102_id); |
309 | |
310 | static struct spi_driver adc108s102_driver = { |
311 | .driver = { |
312 | .name = "adc108s102" , |
313 | .of_match_table = adc108s102_of_match, |
314 | .acpi_match_table = ACPI_PTR(adc108s102_acpi_ids), |
315 | }, |
316 | .probe = adc108s102_probe, |
317 | .id_table = adc108s102_id, |
318 | }; |
319 | module_spi_driver(adc108s102_driver); |
320 | |
321 | MODULE_AUTHOR("Bogdan Pricop <bogdan.pricop@emutex.com>" ); |
322 | MODULE_DESCRIPTION("Texas Instruments ADC108S102 and ADC128S102 driver" ); |
323 | MODULE_LICENSE("GPL v2" ); |
324 | |