1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3 * Maxim Integrated
4 * 7-bit, Multi-Channel Sink/Source Current DAC Driver
5 * Copyright (C) 2017 Maxim Integrated
6 */
7
8 #include <linux/kernel.h>
9 #include <linux/module.h>
10 #include <linux/i2c.h>
11 #include <linux/regulator/consumer.h>
12 #include <linux/err.h>
13 #include <linux/delay.h>
14 #include <linux/iio/iio.h>
15 #include <linux/iio/driver.h>
16 #include <linux/iio/machine.h>
17 #include <linux/iio/consumer.h>
18
19 #define DS4422_MAX_DAC_CHANNELS 2
20 #define DS4424_MAX_DAC_CHANNELS 4
21
22 #define DS4424_DAC_ADDR(chan) ((chan) + 0xf8)
23 #define DS4424_SOURCE_I 1
24 #define DS4424_SINK_I 0
25
26 #define DS4424_CHANNEL(chan) { \
27 .type = IIO_CURRENT, \
28 .indexed = 1, \
29 .output = 1, \
30 .channel = chan, \
31 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW), \
32 }
33
34 /*
35 * DS4424 DAC control register 8 bits
36 * [7] 0: to sink; 1: to source
37 * [6:0] steps to sink/source
38 * bit[7] looks like a sign bit, but the value of the register is
39 * not a two's complement code considering the bit[6:0] is a absolute
40 * distance from the zero point.
41 */
42 union ds4424_raw_data {
43 struct {
44 u8 dx:7;
45 u8 source_bit:1;
46 };
47 u8 bits;
48 };
49
50 enum ds4424_device_ids {
51 ID_DS4422,
52 ID_DS4424,
53 };
54
55 struct ds4424_data {
56 struct i2c_client *client;
57 struct mutex lock;
58 uint8_t save[DS4424_MAX_DAC_CHANNELS];
59 struct regulator *vcc_reg;
60 uint8_t raw[DS4424_MAX_DAC_CHANNELS];
61 };
62
63 static const struct iio_chan_spec ds4424_channels[] = {
64 DS4424_CHANNEL(0),
65 DS4424_CHANNEL(1),
66 DS4424_CHANNEL(2),
67 DS4424_CHANNEL(3),
68 };
69
ds4424_get_value(struct iio_dev * indio_dev,int * val,int channel)70 static int ds4424_get_value(struct iio_dev *indio_dev,
71 int *val, int channel)
72 {
73 struct ds4424_data *data = iio_priv(indio_dev);
74 int ret;
75
76 mutex_lock(&data->lock);
77 ret = i2c_smbus_read_byte_data(data->client, DS4424_DAC_ADDR(channel));
78 if (ret < 0)
79 goto fail;
80
81 *val = ret;
82
83 fail:
84 mutex_unlock(&data->lock);
85 return ret;
86 }
87
ds4424_set_value(struct iio_dev * indio_dev,int val,struct iio_chan_spec const * chan)88 static int ds4424_set_value(struct iio_dev *indio_dev,
89 int val, struct iio_chan_spec const *chan)
90 {
91 struct ds4424_data *data = iio_priv(indio_dev);
92 int ret;
93
94 mutex_lock(&data->lock);
95 ret = i2c_smbus_write_byte_data(data->client,
96 DS4424_DAC_ADDR(chan->channel), val);
97 if (ret < 0)
98 goto fail;
99
100 data->raw[chan->channel] = val;
101
102 fail:
103 mutex_unlock(&data->lock);
104 return ret;
105 }
106
ds4424_read_raw(struct iio_dev * indio_dev,struct iio_chan_spec const * chan,int * val,int * val2,long mask)107 static int ds4424_read_raw(struct iio_dev *indio_dev,
108 struct iio_chan_spec const *chan,
109 int *val, int *val2, long mask)
110 {
111 union ds4424_raw_data raw;
112 int ret;
113
114 switch (mask) {
115 case IIO_CHAN_INFO_RAW:
116 ret = ds4424_get_value(indio_dev, val, chan->channel);
117 if (ret < 0) {
118 pr_err("%s : ds4424_get_value returned %d\n",
119 __func__, ret);
120 return ret;
121 }
122 raw.bits = *val;
123 *val = raw.dx;
124 if (raw.source_bit == DS4424_SINK_I)
125 *val = -*val;
126 return IIO_VAL_INT;
127
128 default:
129 return -EINVAL;
130 }
131 }
132
ds4424_write_raw(struct iio_dev * indio_dev,struct iio_chan_spec const * chan,int val,int val2,long mask)133 static int ds4424_write_raw(struct iio_dev *indio_dev,
134 struct iio_chan_spec const *chan,
135 int val, int val2, long mask)
136 {
137 union ds4424_raw_data raw;
138
139 if (val2 != 0)
140 return -EINVAL;
141
142 switch (mask) {
143 case IIO_CHAN_INFO_RAW:
144 if (val < S8_MIN || val > S8_MAX)
145 return -EINVAL;
146
147 if (val > 0) {
148 raw.source_bit = DS4424_SOURCE_I;
149 raw.dx = val;
150 } else {
151 raw.source_bit = DS4424_SINK_I;
152 raw.dx = -val;
153 }
154
155 return ds4424_set_value(indio_dev, raw.bits, chan);
156
157 default:
158 return -EINVAL;
159 }
160 }
161
ds4424_verify_chip(struct iio_dev * indio_dev)162 static int ds4424_verify_chip(struct iio_dev *indio_dev)
163 {
164 int ret, val;
165
166 ret = ds4424_get_value(indio_dev, &val, 0);
167 if (ret < 0)
168 dev_err(&indio_dev->dev,
169 "%s failed. ret: %d\n", __func__, ret);
170
171 return ret;
172 }
173
ds4424_suspend(struct device * dev)174 static int __maybe_unused ds4424_suspend(struct device *dev)
175 {
176 struct i2c_client *client = to_i2c_client(dev);
177 struct iio_dev *indio_dev = i2c_get_clientdata(client);
178 struct ds4424_data *data = iio_priv(indio_dev);
179 int ret = 0;
180 int i;
181
182 for (i = 0; i < indio_dev->num_channels; i++) {
183 data->save[i] = data->raw[i];
184 ret = ds4424_set_value(indio_dev, 0,
185 &indio_dev->channels[i]);
186 if (ret < 0)
187 return ret;
188 }
189 return ret;
190 }
191
ds4424_resume(struct device * dev)192 static int __maybe_unused ds4424_resume(struct device *dev)
193 {
194 struct i2c_client *client = to_i2c_client(dev);
195 struct iio_dev *indio_dev = i2c_get_clientdata(client);
196 struct ds4424_data *data = iio_priv(indio_dev);
197 int ret = 0;
198 int i;
199
200 for (i = 0; i < indio_dev->num_channels; i++) {
201 ret = ds4424_set_value(indio_dev, data->save[i],
202 &indio_dev->channels[i]);
203 if (ret < 0)
204 return ret;
205 }
206 return ret;
207 }
208
209 static SIMPLE_DEV_PM_OPS(ds4424_pm_ops, ds4424_suspend, ds4424_resume);
210
211 static const struct iio_info ds4424_info = {
212 .read_raw = ds4424_read_raw,
213 .write_raw = ds4424_write_raw,
214 };
215
ds4424_probe(struct i2c_client * client,const struct i2c_device_id * id)216 static int ds4424_probe(struct i2c_client *client,
217 const struct i2c_device_id *id)
218 {
219 struct ds4424_data *data;
220 struct iio_dev *indio_dev;
221 int ret;
222
223 indio_dev = devm_iio_device_alloc(&client->dev, sizeof(*data));
224 if (!indio_dev) {
225 dev_err(&client->dev, "iio dev alloc failed.\n");
226 return -ENOMEM;
227 }
228
229 data = iio_priv(indio_dev);
230 i2c_set_clientdata(client, indio_dev);
231 data->client = client;
232 indio_dev->name = id->name;
233
234 data->vcc_reg = devm_regulator_get(&client->dev, "vcc");
235 if (IS_ERR(data->vcc_reg))
236 return dev_err_probe(&client->dev, PTR_ERR(data->vcc_reg),
237 "Failed to get vcc-supply regulator.\n");
238
239 mutex_init(&data->lock);
240 ret = regulator_enable(data->vcc_reg);
241 if (ret < 0) {
242 dev_err(&client->dev,
243 "Unable to enable the regulator.\n");
244 return ret;
245 }
246
247 usleep_range(1000, 1200);
248 ret = ds4424_verify_chip(indio_dev);
249 if (ret < 0)
250 goto fail;
251
252 switch (id->driver_data) {
253 case ID_DS4422:
254 indio_dev->num_channels = DS4422_MAX_DAC_CHANNELS;
255 break;
256 case ID_DS4424:
257 indio_dev->num_channels = DS4424_MAX_DAC_CHANNELS;
258 break;
259 default:
260 dev_err(&client->dev,
261 "ds4424: Invalid chip id.\n");
262 ret = -ENXIO;
263 goto fail;
264 }
265
266 indio_dev->channels = ds4424_channels;
267 indio_dev->modes = INDIO_DIRECT_MODE;
268 indio_dev->info = &ds4424_info;
269
270 ret = iio_device_register(indio_dev);
271 if (ret < 0) {
272 dev_err(&client->dev,
273 "iio_device_register failed. ret: %d\n", ret);
274 goto fail;
275 }
276
277 return ret;
278
279 fail:
280 regulator_disable(data->vcc_reg);
281 return ret;
282 }
283
ds4424_remove(struct i2c_client * client)284 static int ds4424_remove(struct i2c_client *client)
285 {
286 struct iio_dev *indio_dev = i2c_get_clientdata(client);
287 struct ds4424_data *data = iio_priv(indio_dev);
288
289 iio_device_unregister(indio_dev);
290 regulator_disable(data->vcc_reg);
291
292 return 0;
293 }
294
295 static const struct i2c_device_id ds4424_id[] = {
296 { "ds4422", ID_DS4422 },
297 { "ds4424", ID_DS4424 },
298 { }
299 };
300
301 MODULE_DEVICE_TABLE(i2c, ds4424_id);
302
303 static const struct of_device_id ds4424_of_match[] = {
304 { .compatible = "maxim,ds4422" },
305 { .compatible = "maxim,ds4424" },
306 { },
307 };
308
309 MODULE_DEVICE_TABLE(of, ds4424_of_match);
310
311 static struct i2c_driver ds4424_driver = {
312 .driver = {
313 .name = "ds4424",
314 .of_match_table = ds4424_of_match,
315 .pm = &ds4424_pm_ops,
316 },
317 .probe = ds4424_probe,
318 .remove = ds4424_remove,
319 .id_table = ds4424_id,
320 };
321 module_i2c_driver(ds4424_driver);
322
323 MODULE_DESCRIPTION("Maxim DS4424 DAC Driver");
324 MODULE_AUTHOR("Ismail H. Kose <ismail.kose@maximintegrated.com>");
325 MODULE_AUTHOR("Vishal Sood <vishal.sood@maximintegrated.com>");
326 MODULE_AUTHOR("David Jung <david.jung@maximintegrated.com>");
327 MODULE_LICENSE("GPL v2");
328