1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3 * ADS1100 - Texas Instruments Analog-to-Digital Converter
4 *
5 * Copyright (c) 2023, Topic Embedded Products
6 *
7 * Datasheet: https://www.ti.com/lit/gpn/ads1100
8 * IIO driver for ADS1100 and ADS1000 ADC 16-bit I2C
9 */
10
11 #include <linux/bitfield.h>
12 #include <linux/bits.h>
13 #include <linux/cleanup.h>
14 #include <linux/delay.h>
15 #include <linux/module.h>
16 #include <linux/init.h>
17 #include <linux/i2c.h>
18 #include <linux/mutex.h>
19 #include <linux/property.h>
20 #include <linux/pm_runtime.h>
21 #include <linux/regulator/consumer.h>
22 #include <linux/units.h>
23
24 #include <linux/iio/iio.h>
25 #include <linux/iio/types.h>
26
27 /* The ADS1100 has a single byte config register */
28
29 /* Conversion in progress bit */
30 #define ADS1100_CFG_ST_BSY BIT(7)
31 /* Single conversion bit */
32 #define ADS1100_CFG_SC BIT(4)
33 /* Data rate */
34 #define ADS1100_DR_MASK GENMASK(3, 2)
35 /* Gain */
36 #define ADS1100_PGA_MASK GENMASK(1, 0)
37
38 #define ADS1100_CONTINUOUS 0
39 #define ADS1100_SINGLESHOT ADS1100_CFG_SC
40
41 #define ADS1100_SLEEP_DELAY_MS 2000
42
43 static const int ads1100_data_rate[] = { 128, 32, 16, 8 };
44 static const int ads1100_data_rate_bits[] = { 12, 14, 15, 16 };
45
46 struct ads1100_data {
47 struct i2c_client *client;
48 struct regulator *reg_vdd;
49 struct mutex lock;
50 int scale_avail[2 * 4]; /* 4 gain settings */
51 u8 config;
52 bool supports_data_rate; /* Only the ADS1100 can select the rate */
53 };
54
55 static const struct iio_chan_spec ads1100_channel = {
56 .type = IIO_VOLTAGE,
57 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW),
58 .info_mask_shared_by_all =
59 BIT(IIO_CHAN_INFO_SCALE) | BIT(IIO_CHAN_INFO_SAMP_FREQ),
60 .info_mask_shared_by_all_available =
61 BIT(IIO_CHAN_INFO_SCALE) | BIT(IIO_CHAN_INFO_SAMP_FREQ),
62 .scan_type = {
63 .sign = 's',
64 .realbits = 16,
65 .storagebits = 16,
66 .endianness = IIO_CPU,
67 },
68 .datasheet_name = "AIN",
69 };
70
ads1100_set_config_bits(struct ads1100_data * data,u8 mask,u8 value)71 static int ads1100_set_config_bits(struct ads1100_data *data, u8 mask, u8 value)
72 {
73 int ret;
74 u8 config = (data->config & ~mask) | (value & mask);
75
76 if (data->config == config)
77 return 0; /* Already done */
78
79 ret = i2c_master_send(data->client, &config, 1);
80 if (ret < 0)
81 return ret;
82
83 data->config = config;
84
85 return 0;
86 };
87
ads1100_data_bits(struct ads1100_data * data)88 static int ads1100_data_bits(struct ads1100_data *data)
89 {
90 return ads1100_data_rate_bits[FIELD_GET(ADS1100_DR_MASK, data->config)];
91 }
92
ads1100_get_adc_result(struct ads1100_data * data,int chan,int * val)93 static int ads1100_get_adc_result(struct ads1100_data *data, int chan, int *val)
94 {
95 int ret;
96 __be16 buffer;
97 s16 value;
98
99 if (chan != 0)
100 return -EINVAL;
101
102 ret = pm_runtime_resume_and_get(&data->client->dev);
103 if (ret < 0)
104 return ret;
105
106 ret = i2c_master_recv(data->client, (char *)&buffer, sizeof(buffer));
107
108 pm_runtime_mark_last_busy(&data->client->dev);
109 pm_runtime_put_autosuspend(&data->client->dev);
110
111 if (ret < 0) {
112 dev_err(&data->client->dev, "I2C read fail: %d\n", ret);
113 return ret;
114 }
115
116 /* Value is always 16-bit 2's complement */
117 value = be16_to_cpu(buffer);
118
119 /* Shift result to compensate for bit resolution vs. sample rate */
120 value <<= 16 - ads1100_data_bits(data);
121
122 *val = sign_extend32(value, 15);
123
124 return 0;
125 }
126
ads1100_set_scale(struct ads1100_data * data,int val,int val2)127 static int ads1100_set_scale(struct ads1100_data *data, int val, int val2)
128 {
129 int microvolts;
130 int gain;
131
132 /* With Vdd between 2.7 and 5V, the scale is always below 1 */
133 if (val)
134 return -EINVAL;
135
136 if (!val2)
137 return -EINVAL;
138
139 microvolts = regulator_get_voltage(data->reg_vdd);
140 /*
141 * val2 is in 'micro' units, n = val2 / 1000000
142 * result must be millivolts, d = microvolts / 1000
143 * the full-scale value is d/n, corresponds to 2^15,
144 * hence the gain = (d / n) >> 15, factoring out the 1000 and moving the
145 * bitshift so everything fits in 32-bits yields this formula.
146 */
147 gain = DIV_ROUND_CLOSEST(microvolts, BIT(15)) * MILLI / val2;
148 if (gain < BIT(0) || gain > BIT(3))
149 return -EINVAL;
150
151 ads1100_set_config_bits(data, ADS1100_PGA_MASK, ffs(gain) - 1);
152
153 return 0;
154 }
155
ads1100_set_data_rate(struct ads1100_data * data,int chan,int rate)156 static int ads1100_set_data_rate(struct ads1100_data *data, int chan, int rate)
157 {
158 unsigned int i;
159 unsigned int size;
160
161 size = data->supports_data_rate ? ARRAY_SIZE(ads1100_data_rate) : 1;
162 for (i = 0; i < size; i++) {
163 if (ads1100_data_rate[i] == rate)
164 return ads1100_set_config_bits(data, ADS1100_DR_MASK,
165 FIELD_PREP(ADS1100_DR_MASK, i));
166 }
167
168 return -EINVAL;
169 }
170
ads1100_get_vdd_millivolts(struct ads1100_data * data)171 static int ads1100_get_vdd_millivolts(struct ads1100_data *data)
172 {
173 return regulator_get_voltage(data->reg_vdd) / (MICRO / MILLI);
174 }
175
ads1100_calc_scale_avail(struct ads1100_data * data)176 static void ads1100_calc_scale_avail(struct ads1100_data *data)
177 {
178 int millivolts = ads1100_get_vdd_millivolts(data);
179 unsigned int i;
180
181 for (i = 0; i < ARRAY_SIZE(data->scale_avail) / 2; i++) {
182 data->scale_avail[i * 2 + 0] = millivolts;
183 data->scale_avail[i * 2 + 1] = 15 + i;
184 }
185 }
186
ads1100_read_avail(struct iio_dev * indio_dev,struct iio_chan_spec const * chan,const int ** vals,int * type,int * length,long mask)187 static int ads1100_read_avail(struct iio_dev *indio_dev,
188 struct iio_chan_spec const *chan,
189 const int **vals, int *type, int *length,
190 long mask)
191 {
192 struct ads1100_data *data = iio_priv(indio_dev);
193
194 if (chan->type != IIO_VOLTAGE)
195 return -EINVAL;
196
197 switch (mask) {
198 case IIO_CHAN_INFO_SAMP_FREQ:
199 *type = IIO_VAL_INT;
200 *vals = ads1100_data_rate;
201 if (data->supports_data_rate)
202 *length = ARRAY_SIZE(ads1100_data_rate);
203 else
204 *length = 1;
205 return IIO_AVAIL_LIST;
206 case IIO_CHAN_INFO_SCALE:
207 *type = IIO_VAL_FRACTIONAL_LOG2;
208 *vals = data->scale_avail;
209 *length = ARRAY_SIZE(data->scale_avail);
210 return IIO_AVAIL_LIST;
211 default:
212 return -EINVAL;
213 }
214 }
215
ads1100_read_raw(struct iio_dev * indio_dev,struct iio_chan_spec const * chan,int * val,int * val2,long mask)216 static int ads1100_read_raw(struct iio_dev *indio_dev,
217 struct iio_chan_spec const *chan, int *val,
218 int *val2, long mask)
219 {
220 int ret;
221 struct ads1100_data *data = iio_priv(indio_dev);
222
223 guard(mutex)(&data->lock);
224 switch (mask) {
225 case IIO_CHAN_INFO_RAW:
226 if (!iio_device_claim_direct(indio_dev))
227 return -EBUSY;
228
229 ret = ads1100_get_adc_result(data, chan->address, val);
230 iio_device_release_direct(indio_dev);
231 if (ret < 0)
232 return ret;
233
234 return IIO_VAL_INT;
235 case IIO_CHAN_INFO_SCALE:
236 /* full-scale is the supply voltage in millivolts */
237 *val = ads1100_get_vdd_millivolts(data);
238 *val2 = 15 + FIELD_GET(ADS1100_PGA_MASK, data->config);
239 return IIO_VAL_FRACTIONAL_LOG2;
240 case IIO_CHAN_INFO_SAMP_FREQ:
241 *val = ads1100_data_rate[FIELD_GET(ADS1100_DR_MASK,
242 data->config)];
243 return IIO_VAL_INT;
244 default:
245 return -EINVAL;
246 }
247 }
248
ads1100_write_raw(struct iio_dev * indio_dev,struct iio_chan_spec const * chan,int val,int val2,long mask)249 static int ads1100_write_raw(struct iio_dev *indio_dev,
250 struct iio_chan_spec const *chan, int val,
251 int val2, long mask)
252 {
253 struct ads1100_data *data = iio_priv(indio_dev);
254
255 guard(mutex)(&data->lock);
256 switch (mask) {
257 case IIO_CHAN_INFO_SCALE:
258 return ads1100_set_scale(data, val, val2);
259 case IIO_CHAN_INFO_SAMP_FREQ:
260 return ads1100_set_data_rate(data, chan->address, val);
261 default:
262 return -EINVAL;
263 }
264 }
265
266 static const struct iio_info ads1100_info = {
267 .read_avail = ads1100_read_avail,
268 .read_raw = ads1100_read_raw,
269 .write_raw = ads1100_write_raw,
270 };
271
ads1100_setup(struct ads1100_data * data)272 static int ads1100_setup(struct ads1100_data *data)
273 {
274 int ret;
275 u8 buffer[3];
276
277 /* Setup continuous sampling mode at 8sps */
278 buffer[0] = ADS1100_DR_MASK | ADS1100_CONTINUOUS;
279 ret = i2c_master_send(data->client, buffer, 1);
280 if (ret < 0)
281 return ret;
282
283 ret = i2c_master_recv(data->client, buffer, sizeof(buffer));
284 if (ret < 0)
285 return ret;
286
287 /* Config register returned in third byte, strip away the busy status */
288 data->config = buffer[2] & ~ADS1100_CFG_ST_BSY;
289
290 /* Detect the sample rate capability by checking the DR bits */
291 data->supports_data_rate = FIELD_GET(ADS1100_DR_MASK, buffer[2]) != 0;
292
293 return 0;
294 }
295
ads1100_reg_disable(void * reg)296 static void ads1100_reg_disable(void *reg)
297 {
298 regulator_disable(reg);
299 }
300
ads1100_disable_continuous(void * data)301 static void ads1100_disable_continuous(void *data)
302 {
303 ads1100_set_config_bits(data, ADS1100_CFG_SC, ADS1100_SINGLESHOT);
304 }
305
ads1100_probe(struct i2c_client * client)306 static int ads1100_probe(struct i2c_client *client)
307 {
308 struct iio_dev *indio_dev;
309 struct ads1100_data *data;
310 struct device *dev = &client->dev;
311 int ret;
312
313 indio_dev = devm_iio_device_alloc(dev, sizeof(*data));
314 if (!indio_dev)
315 return -ENOMEM;
316
317 data = iio_priv(indio_dev);
318 dev_set_drvdata(dev, data);
319 data->client = client;
320 mutex_init(&data->lock);
321
322 indio_dev->name = "ads1100";
323 indio_dev->modes = INDIO_DIRECT_MODE;
324 indio_dev->channels = &ads1100_channel;
325 indio_dev->num_channels = 1;
326 indio_dev->info = &ads1100_info;
327
328 data->reg_vdd = devm_regulator_get(dev, "vdd");
329 if (IS_ERR(data->reg_vdd))
330 return dev_err_probe(dev, PTR_ERR(data->reg_vdd),
331 "Failed to get vdd regulator\n");
332
333 ret = regulator_enable(data->reg_vdd);
334 if (ret < 0)
335 return dev_err_probe(dev, ret,
336 "Failed to enable vdd regulator\n");
337
338 ret = devm_add_action_or_reset(dev, ads1100_reg_disable, data->reg_vdd);
339 if (ret)
340 return ret;
341
342 ret = ads1100_setup(data);
343 if (ret)
344 return dev_err_probe(dev, ret,
345 "Failed to communicate with device\n");
346
347 ret = devm_add_action_or_reset(dev, ads1100_disable_continuous, data);
348 if (ret)
349 return ret;
350
351 ads1100_calc_scale_avail(data);
352
353 pm_runtime_set_autosuspend_delay(dev, ADS1100_SLEEP_DELAY_MS);
354 pm_runtime_use_autosuspend(dev);
355 pm_runtime_set_active(dev);
356 ret = devm_pm_runtime_enable(dev);
357 if (ret)
358 return dev_err_probe(dev, ret, "Failed to enable pm_runtime\n");
359
360 ret = devm_iio_device_register(dev, indio_dev);
361 if (ret)
362 return dev_err_probe(dev, ret,
363 "Failed to register IIO device\n");
364
365 return 0;
366 }
367
ads1100_runtime_suspend(struct device * dev)368 static int ads1100_runtime_suspend(struct device *dev)
369 {
370 struct ads1100_data *data = dev_get_drvdata(dev);
371
372 ads1100_set_config_bits(data, ADS1100_CFG_SC, ADS1100_SINGLESHOT);
373 regulator_disable(data->reg_vdd);
374
375 return 0;
376 }
377
ads1100_runtime_resume(struct device * dev)378 static int ads1100_runtime_resume(struct device *dev)
379 {
380 struct ads1100_data *data = dev_get_drvdata(dev);
381 int ret;
382
383 ret = regulator_enable(data->reg_vdd);
384 if (ret) {
385 dev_err(&data->client->dev, "Failed to enable Vdd\n");
386 return ret;
387 }
388
389 /*
390 * We'll always change the mode bit in the config register, so there is
391 * no need here to "force" a write to the config register. If the device
392 * has been power-cycled, we'll re-write its config register now.
393 */
394 return ads1100_set_config_bits(data, ADS1100_CFG_SC,
395 ADS1100_CONTINUOUS);
396 }
397
398 static DEFINE_RUNTIME_DEV_PM_OPS(ads1100_pm_ops,
399 ads1100_runtime_suspend,
400 ads1100_runtime_resume,
401 NULL);
402
403 static const struct i2c_device_id ads1100_id[] = {
404 { "ads1100" },
405 { "ads1000" },
406 { }
407 };
408
409 MODULE_DEVICE_TABLE(i2c, ads1100_id);
410
411 static const struct of_device_id ads1100_of_match[] = {
412 {.compatible = "ti,ads1100" },
413 {.compatible = "ti,ads1000" },
414 { }
415 };
416
417 MODULE_DEVICE_TABLE(of, ads1100_of_match);
418
419 static struct i2c_driver ads1100_driver = {
420 .driver = {
421 .name = "ads1100",
422 .of_match_table = ads1100_of_match,
423 .pm = pm_ptr(&ads1100_pm_ops),
424 },
425 .probe = ads1100_probe,
426 .id_table = ads1100_id,
427 };
428
429 module_i2c_driver(ads1100_driver);
430
431 MODULE_AUTHOR("Mike Looijmans <mike.looijmans@topic.nl>");
432 MODULE_DESCRIPTION("Texas Instruments ADS1100 ADC driver");
433 MODULE_LICENSE("GPL");
434