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 */
42union ds4424_raw_data {
43 struct {
44 u8 dx:7;
45 u8 source_bit:1;
46 };
47 u8 bits;
48};
49
50enum ds4424_device_ids {
51 ID_DS4422,
52 ID_DS4424,
53};
54
55struct 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
63static 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
70static 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(client: data->client, DS4424_DAC_ADDR(channel));
78 if (ret < 0)
79 goto fail;
80
81 *val = ret;
82
83fail:
84 mutex_unlock(lock: &data->lock);
85 return ret;
86}
87
88static 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(client: data->client,
96 DS4424_DAC_ADDR(chan->channel), value: val);
97 if (ret < 0)
98 goto fail;
99
100 data->raw[chan->channel] = val;
101
102fail:
103 mutex_unlock(lock: &data->lock);
104 return ret;
105}
106
107static 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, channel: 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
133static 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, val: raw.bits, chan);
156
157 default:
158 return -EINVAL;
159 }
160}
161
162static int ds4424_verify_chip(struct iio_dev *indio_dev)
163{
164 int ret, val;
165
166 ret = ds4424_get_value(indio_dev, val: &val, channel: 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
174static int 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, val: 0,
185 chan: &indio_dev->channels[i]);
186 if (ret < 0)
187 return ret;
188 }
189 return ret;
190}
191
192static int 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, val: data->save[i],
202 chan: &indio_dev->channels[i]);
203 if (ret < 0)
204 return ret;
205 }
206 return ret;
207}
208
209static DEFINE_SIMPLE_DEV_PM_OPS(ds4424_pm_ops, ds4424_suspend, ds4424_resume);
210
211static const struct iio_info ds4424_info = {
212 .read_raw = ds4424_read_raw,
213 .write_raw = ds4424_write_raw,
214};
215
216static int ds4424_probe(struct i2c_client *client)
217{
218 const struct i2c_device_id *id = i2c_client_get_device_id(client);
219 struct ds4424_data *data;
220 struct iio_dev *indio_dev;
221 int ret;
222
223 indio_dev = devm_iio_device_alloc(parent: &client->dev, sizeof_priv: sizeof(*data));
224 if (!indio_dev)
225 return -ENOMEM;
226
227 data = iio_priv(indio_dev);
228 i2c_set_clientdata(client, data: indio_dev);
229 data->client = client;
230 indio_dev->name = id->name;
231
232 data->vcc_reg = devm_regulator_get(dev: &client->dev, id: "vcc");
233 if (IS_ERR(ptr: data->vcc_reg))
234 return dev_err_probe(dev: &client->dev, err: PTR_ERR(ptr: data->vcc_reg),
235 fmt: "Failed to get vcc-supply regulator.\n");
236
237 mutex_init(&data->lock);
238 ret = regulator_enable(regulator: data->vcc_reg);
239 if (ret < 0) {
240 dev_err(&client->dev,
241 "Unable to enable the regulator.\n");
242 return ret;
243 }
244
245 usleep_range(min: 1000, max: 1200);
246 ret = ds4424_verify_chip(indio_dev);
247 if (ret < 0)
248 goto fail;
249
250 switch (id->driver_data) {
251 case ID_DS4422:
252 indio_dev->num_channels = DS4422_MAX_DAC_CHANNELS;
253 break;
254 case ID_DS4424:
255 indio_dev->num_channels = DS4424_MAX_DAC_CHANNELS;
256 break;
257 default:
258 dev_err(&client->dev,
259 "ds4424: Invalid chip id.\n");
260 ret = -ENXIO;
261 goto fail;
262 }
263
264 indio_dev->channels = ds4424_channels;
265 indio_dev->modes = INDIO_DIRECT_MODE;
266 indio_dev->info = &ds4424_info;
267
268 ret = iio_device_register(indio_dev);
269 if (ret < 0) {
270 dev_err(&client->dev,
271 "iio_device_register failed. ret: %d\n", ret);
272 goto fail;
273 }
274
275 return ret;
276
277fail:
278 regulator_disable(regulator: data->vcc_reg);
279 return ret;
280}
281
282static void ds4424_remove(struct i2c_client *client)
283{
284 struct iio_dev *indio_dev = i2c_get_clientdata(client);
285 struct ds4424_data *data = iio_priv(indio_dev);
286
287 iio_device_unregister(indio_dev);
288 regulator_disable(regulator: data->vcc_reg);
289}
290
291static const struct i2c_device_id ds4424_id[] = {
292 { "ds4422", ID_DS4422 },
293 { "ds4424", ID_DS4424 },
294 { }
295};
296
297MODULE_DEVICE_TABLE(i2c, ds4424_id);
298
299static const struct of_device_id ds4424_of_match[] = {
300 { .compatible = "maxim,ds4422" },
301 { .compatible = "maxim,ds4424" },
302 { }
303};
304
305MODULE_DEVICE_TABLE(of, ds4424_of_match);
306
307static struct i2c_driver ds4424_driver = {
308 .driver = {
309 .name = "ds4424",
310 .of_match_table = ds4424_of_match,
311 .pm = pm_sleep_ptr(&ds4424_pm_ops),
312 },
313 .probe = ds4424_probe,
314 .remove = ds4424_remove,
315 .id_table = ds4424_id,
316};
317module_i2c_driver(ds4424_driver);
318
319MODULE_DESCRIPTION("Maxim DS4424 DAC Driver");
320MODULE_AUTHOR("Ismail H. Kose <ismail.kose@maximintegrated.com>");
321MODULE_AUTHOR("Vishal Sood <vishal.sood@maximintegrated.com>");
322MODULE_AUTHOR("David Jung <david.jung@maximintegrated.com>");
323MODULE_LICENSE("GPL v2");
324

source code of linux/drivers/iio/dac/ds4424.c