1
2
3
4
5
6
7
8
9
10
11#include <linux/delay.h>
12#include <linux/i2c.h>
13#include <linux/iio/iio.h>
14#include <linux/iio/driver.h>
15#include <linux/iio/sysfs.h>
16#include <linux/module.h>
17#include <linux/of.h>
18#include <linux/regulator/consumer.h>
19
20#define LTC2497_ENABLE 0xA0
21#define LTC2497_SGL BIT(4)
22#define LTC2497_DIFF 0
23#define LTC2497_SIGN BIT(3)
24#define LTC2497_CONFIG_DEFAULT LTC2497_ENABLE
25#define LTC2497_CONVERSION_TIME_MS 150ULL
26
27struct ltc2497_st {
28 struct i2c_client *client;
29 struct regulator *ref;
30 ktime_t time_prev;
31 u8 addr_prev;
32
33
34
35
36 __be32 buf ____cacheline_aligned;
37};
38
39static int ltc2497_wait_conv(struct ltc2497_st *st)
40{
41 s64 time_elapsed;
42
43 time_elapsed = ktime_ms_delta(ktime_get(), st->time_prev);
44
45 if (time_elapsed < LTC2497_CONVERSION_TIME_MS) {
46
47
48
49 if (msleep_interruptible(
50 LTC2497_CONVERSION_TIME_MS - time_elapsed))
51 return -ERESTARTSYS;
52
53 return 0;
54 }
55
56 if (time_elapsed - LTC2497_CONVERSION_TIME_MS <= 0) {
57
58
59
60 return 0;
61 }
62
63 return 1;
64}
65
66static int ltc2497_read(struct ltc2497_st *st, u8 address, int *val)
67{
68 struct i2c_client *client = st->client;
69 int ret;
70
71 ret = ltc2497_wait_conv(st);
72 if (ret < 0)
73 return ret;
74
75 if (ret || st->addr_prev != address) {
76 ret = i2c_smbus_write_byte(st->client,
77 LTC2497_ENABLE | address);
78 if (ret < 0)
79 return ret;
80 st->addr_prev = address;
81 if (msleep_interruptible(LTC2497_CONVERSION_TIME_MS))
82 return -ERESTARTSYS;
83 }
84 ret = i2c_master_recv(client, (char *)&st->buf, 3);
85 if (ret < 0) {
86 dev_err(&client->dev, "i2c_master_recv failed\n");
87 return ret;
88 }
89 st->time_prev = ktime_get();
90
91
92
93
94 *val = (be32_to_cpu(st->buf) >> 14) - (1 << 17);
95
96 return ret;
97}
98
99static int ltc2497_read_raw(struct iio_dev *indio_dev,
100 struct iio_chan_spec const *chan,
101 int *val, int *val2, long mask)
102{
103 struct ltc2497_st *st = iio_priv(indio_dev);
104 int ret;
105
106 switch (mask) {
107 case IIO_CHAN_INFO_RAW:
108 mutex_lock(&indio_dev->mlock);
109 ret = ltc2497_read(st, chan->address, val);
110 mutex_unlock(&indio_dev->mlock);
111 if (ret < 0)
112 return ret;
113
114 return IIO_VAL_INT;
115
116 case IIO_CHAN_INFO_SCALE:
117 ret = regulator_get_voltage(st->ref);
118 if (ret < 0)
119 return ret;
120
121 *val = ret / 1000;
122 *val2 = 17;
123
124 return IIO_VAL_FRACTIONAL_LOG2;
125
126 default:
127 return -EINVAL;
128 }
129}
130
131#define LTC2497_CHAN(_chan, _addr, _ds_name) { \
132 .type = IIO_VOLTAGE, \
133 .indexed = 1, \
134 .channel = (_chan), \
135 .address = (_addr | (_chan / 2) | ((_chan & 1) ? LTC2497_SIGN : 0)), \
136 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW), \
137 .info_mask_shared_by_type = BIT(IIO_CHAN_INFO_SCALE), \
138 .datasheet_name = (_ds_name), \
139}
140
141#define LTC2497_CHAN_DIFF(_chan, _addr) { \
142 .type = IIO_VOLTAGE, \
143 .indexed = 1, \
144 .channel = (_chan) * 2 + ((_addr) & LTC2497_SIGN ? 1 : 0), \
145 .channel2 = (_chan) * 2 + ((_addr) & LTC2497_SIGN ? 0 : 1),\
146 .address = (_addr | _chan), \
147 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW), \
148 .info_mask_shared_by_type = BIT(IIO_CHAN_INFO_SCALE), \
149 .differential = 1, \
150}
151
152static const struct iio_chan_spec ltc2497_channel[] = {
153 LTC2497_CHAN(0, LTC2497_SGL, "CH0"),
154 LTC2497_CHAN(1, LTC2497_SGL, "CH1"),
155 LTC2497_CHAN(2, LTC2497_SGL, "CH2"),
156 LTC2497_CHAN(3, LTC2497_SGL, "CH3"),
157 LTC2497_CHAN(4, LTC2497_SGL, "CH4"),
158 LTC2497_CHAN(5, LTC2497_SGL, "CH5"),
159 LTC2497_CHAN(6, LTC2497_SGL, "CH6"),
160 LTC2497_CHAN(7, LTC2497_SGL, "CH7"),
161 LTC2497_CHAN(8, LTC2497_SGL, "CH8"),
162 LTC2497_CHAN(9, LTC2497_SGL, "CH9"),
163 LTC2497_CHAN(10, LTC2497_SGL, "CH10"),
164 LTC2497_CHAN(11, LTC2497_SGL, "CH11"),
165 LTC2497_CHAN(12, LTC2497_SGL, "CH12"),
166 LTC2497_CHAN(13, LTC2497_SGL, "CH13"),
167 LTC2497_CHAN(14, LTC2497_SGL, "CH14"),
168 LTC2497_CHAN(15, LTC2497_SGL, "CH15"),
169 LTC2497_CHAN_DIFF(0, LTC2497_DIFF),
170 LTC2497_CHAN_DIFF(1, LTC2497_DIFF),
171 LTC2497_CHAN_DIFF(2, LTC2497_DIFF),
172 LTC2497_CHAN_DIFF(3, LTC2497_DIFF),
173 LTC2497_CHAN_DIFF(4, LTC2497_DIFF),
174 LTC2497_CHAN_DIFF(5, LTC2497_DIFF),
175 LTC2497_CHAN_DIFF(6, LTC2497_DIFF),
176 LTC2497_CHAN_DIFF(7, LTC2497_DIFF),
177 LTC2497_CHAN_DIFF(0, LTC2497_DIFF | LTC2497_SIGN),
178 LTC2497_CHAN_DIFF(1, LTC2497_DIFF | LTC2497_SIGN),
179 LTC2497_CHAN_DIFF(2, LTC2497_DIFF | LTC2497_SIGN),
180 LTC2497_CHAN_DIFF(3, LTC2497_DIFF | LTC2497_SIGN),
181 LTC2497_CHAN_DIFF(4, LTC2497_DIFF | LTC2497_SIGN),
182 LTC2497_CHAN_DIFF(5, LTC2497_DIFF | LTC2497_SIGN),
183 LTC2497_CHAN_DIFF(6, LTC2497_DIFF | LTC2497_SIGN),
184 LTC2497_CHAN_DIFF(7, LTC2497_DIFF | LTC2497_SIGN),
185};
186
187static const struct iio_info ltc2497_info = {
188 .read_raw = ltc2497_read_raw,
189};
190
191static int ltc2497_probe(struct i2c_client *client,
192 const struct i2c_device_id *id)
193{
194 struct iio_dev *indio_dev;
195 struct ltc2497_st *st;
196 struct iio_map *plat_data;
197 int ret;
198
199 if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C |
200 I2C_FUNC_SMBUS_WRITE_BYTE))
201 return -EOPNOTSUPP;
202
203 indio_dev = devm_iio_device_alloc(&client->dev, sizeof(*st));
204 if (!indio_dev)
205 return -ENOMEM;
206
207 st = iio_priv(indio_dev);
208 i2c_set_clientdata(client, indio_dev);
209 st->client = client;
210
211 indio_dev->dev.parent = &client->dev;
212 indio_dev->name = id->name;
213 indio_dev->info = <c2497_info;
214 indio_dev->modes = INDIO_DIRECT_MODE;
215 indio_dev->channels = ltc2497_channel;
216 indio_dev->num_channels = ARRAY_SIZE(ltc2497_channel);
217
218 st->ref = devm_regulator_get(&client->dev, "vref");
219 if (IS_ERR(st->ref))
220 return PTR_ERR(st->ref);
221
222 ret = regulator_enable(st->ref);
223 if (ret < 0)
224 return ret;
225
226 if (client->dev.platform_data) {
227 plat_data = ((struct iio_map *)client->dev.platform_data);
228 ret = iio_map_array_register(indio_dev, plat_data);
229 if (ret) {
230 dev_err(&indio_dev->dev, "iio map err: %d\n", ret);
231 goto err_regulator_disable;
232 }
233 }
234
235 ret = i2c_smbus_write_byte(st->client, LTC2497_CONFIG_DEFAULT);
236 if (ret < 0)
237 goto err_array_unregister;
238
239 st->addr_prev = LTC2497_CONFIG_DEFAULT;
240 st->time_prev = ktime_get();
241
242 ret = iio_device_register(indio_dev);
243 if (ret < 0)
244 goto err_array_unregister;
245
246 return 0;
247
248err_array_unregister:
249 iio_map_array_unregister(indio_dev);
250
251err_regulator_disable:
252 regulator_disable(st->ref);
253
254 return ret;
255}
256
257static int ltc2497_remove(struct i2c_client *client)
258{
259 struct iio_dev *indio_dev = i2c_get_clientdata(client);
260 struct ltc2497_st *st = iio_priv(indio_dev);
261
262 iio_map_array_unregister(indio_dev);
263 iio_device_unregister(indio_dev);
264 regulator_disable(st->ref);
265
266 return 0;
267}
268
269static const struct i2c_device_id ltc2497_id[] = {
270 { "ltc2497", 0 },
271 { }
272};
273MODULE_DEVICE_TABLE(i2c, ltc2497_id);
274
275static const struct of_device_id ltc2497_of_match[] = {
276 { .compatible = "lltc,ltc2497", },
277 {},
278};
279MODULE_DEVICE_TABLE(of, ltc2497_of_match);
280
281static struct i2c_driver ltc2497_driver = {
282 .driver = {
283 .name = "ltc2497",
284 .of_match_table = of_match_ptr(ltc2497_of_match),
285 },
286 .probe = ltc2497_probe,
287 .remove = ltc2497_remove,
288 .id_table = ltc2497_id,
289};
290module_i2c_driver(ltc2497_driver);
291
292MODULE_AUTHOR("Michael Hennerich <michael.hennerich@analog.com>");
293MODULE_DESCRIPTION("Linear Technology LTC2497 ADC driver");
294MODULE_LICENSE("GPL v2");
295
