1
2
3
4
5
6
7
8
9#include <linux/interrupt.h>
10#include <linux/workqueue.h>
11#include <linux/device.h>
12#include <linux/kernel.h>
13#include <linux/slab.h>
14#include <linux/sysfs.h>
15#include <linux/list.h>
16#include <linux/spi/spi.h>
17#include <linux/i2c.h>
18#include <linux/regulator/consumer.h>
19#include <linux/err.h>
20#include <linux/module.h>
21
22#include <linux/iio/iio.h>
23#include <linux/iio/sysfs.h>
24
25#define MODE_PWRDWN_1k 0x1
26#define MODE_PWRDWN_100k 0x2
27#define MODE_PWRDWN_TRISTATE 0x3
28
29
30
31
32
33
34
35
36
37struct ad5446_state {
38 struct device *dev;
39 const struct ad5446_chip_info *chip_info;
40 struct regulator *reg;
41 unsigned short vref_mv;
42 unsigned cached_val;
43 unsigned pwr_down_mode;
44 unsigned pwr_down;
45};
46
47
48
49
50
51
52
53
54struct ad5446_chip_info {
55 struct iio_chan_spec channel;
56 u16 int_vref_mv;
57 int (*write)(struct ad5446_state *st, unsigned val);
58};
59
60static const char * const ad5446_powerdown_modes[] = {
61 "1kohm_to_gnd", "100kohm_to_gnd", "three_state"
62};
63
64static int ad5446_set_powerdown_mode(struct iio_dev *indio_dev,
65 const struct iio_chan_spec *chan, unsigned int mode)
66{
67 struct ad5446_state *st = iio_priv(indio_dev);
68
69 st->pwr_down_mode = mode + 1;
70
71 return 0;
72}
73
74static int ad5446_get_powerdown_mode(struct iio_dev *indio_dev,
75 const struct iio_chan_spec *chan)
76{
77 struct ad5446_state *st = iio_priv(indio_dev);
78
79 return st->pwr_down_mode - 1;
80}
81
82static const struct iio_enum ad5446_powerdown_mode_enum = {
83 .items = ad5446_powerdown_modes,
84 .num_items = ARRAY_SIZE(ad5446_powerdown_modes),
85 .get = ad5446_get_powerdown_mode,
86 .set = ad5446_set_powerdown_mode,
87};
88
89static ssize_t ad5446_read_dac_powerdown(struct iio_dev *indio_dev,
90 uintptr_t private,
91 const struct iio_chan_spec *chan,
92 char *buf)
93{
94 struct ad5446_state *st = iio_priv(indio_dev);
95
96 return sprintf(buf, "%d\n", st->pwr_down);
97}
98
99static ssize_t ad5446_write_dac_powerdown(struct iio_dev *indio_dev,
100 uintptr_t private,
101 const struct iio_chan_spec *chan,
102 const char *buf, size_t len)
103{
104 struct ad5446_state *st = iio_priv(indio_dev);
105 unsigned int shift;
106 unsigned int val;
107 bool powerdown;
108 int ret;
109
110 ret = strtobool(buf, &powerdown);
111 if (ret)
112 return ret;
113
114 mutex_lock(&indio_dev->mlock);
115 st->pwr_down = powerdown;
116
117 if (st->pwr_down) {
118 shift = chan->scan_type.realbits + chan->scan_type.shift;
119 val = st->pwr_down_mode << shift;
120 } else {
121 val = st->cached_val;
122 }
123
124 ret = st->chip_info->write(st, val);
125 mutex_unlock(&indio_dev->mlock);
126
127 return ret ? ret : len;
128}
129
130static const struct iio_chan_spec_ext_info ad5446_ext_info_powerdown[] = {
131 {
132 .name = "powerdown",
133 .read = ad5446_read_dac_powerdown,
134 .write = ad5446_write_dac_powerdown,
135 },
136 IIO_ENUM("powerdown_mode", false, &ad5446_powerdown_mode_enum),
137 IIO_ENUM_AVAILABLE("powerdown_mode", &ad5446_powerdown_mode_enum),
138 { },
139};
140
141#define _AD5446_CHANNEL(bits, storage, shift, ext) { \
142 .type = IIO_VOLTAGE, \
143 .indexed = 1, \
144 .output = 1, \
145 .channel = 0, \
146 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW), \
147 .info_mask_shared_by_type = BIT(IIO_CHAN_INFO_SCALE), \
148 .scan_type = IIO_ST('u', (bits), (storage), (shift)), \
149 .ext_info = (ext), \
150}
151
152#define AD5446_CHANNEL(bits, storage, shift) \
153 _AD5446_CHANNEL(bits, storage, shift, NULL)
154
155#define AD5446_CHANNEL_POWERDOWN(bits, storage, shift) \
156 _AD5446_CHANNEL(bits, storage, shift, ad5446_ext_info_powerdown)
157
158static int ad5446_read_raw(struct iio_dev *indio_dev,
159 struct iio_chan_spec const *chan,
160 int *val,
161 int *val2,
162 long m)
163{
164 struct ad5446_state *st = iio_priv(indio_dev);
165 unsigned long scale_uv;
166
167 switch (m) {
168 case IIO_CHAN_INFO_RAW:
169 *val = st->cached_val;
170 return IIO_VAL_INT;
171 case IIO_CHAN_INFO_SCALE:
172 scale_uv = (st->vref_mv * 1000) >> chan->scan_type.realbits;
173 *val = scale_uv / 1000;
174 *val2 = (scale_uv % 1000) * 1000;
175 return IIO_VAL_INT_PLUS_MICRO;
176
177 }
178 return -EINVAL;
179}
180
181static int ad5446_write_raw(struct iio_dev *indio_dev,
182 struct iio_chan_spec const *chan,
183 int val,
184 int val2,
185 long mask)
186{
187 struct ad5446_state *st = iio_priv(indio_dev);
188 int ret = 0;
189
190 switch (mask) {
191 case IIO_CHAN_INFO_RAW:
192 if (val >= (1 << chan->scan_type.realbits) || val < 0)
193 return -EINVAL;
194
195 val <<= chan->scan_type.shift;
196 mutex_lock(&indio_dev->mlock);
197 st->cached_val = val;
198 if (!st->pwr_down)
199 ret = st->chip_info->write(st, val);
200 mutex_unlock(&indio_dev->mlock);
201 break;
202 default:
203 ret = -EINVAL;
204 }
205
206 return ret;
207}
208
209static const struct iio_info ad5446_info = {
210 .read_raw = ad5446_read_raw,
211 .write_raw = ad5446_write_raw,
212 .driver_module = THIS_MODULE,
213};
214
215static int ad5446_probe(struct device *dev, const char *name,
216 const struct ad5446_chip_info *chip_info)
217{
218 struct ad5446_state *st;
219 struct iio_dev *indio_dev;
220 struct regulator *reg;
221 int ret, voltage_uv = 0;
222
223 reg = devm_regulator_get(dev, "vcc");
224 if (!IS_ERR(reg)) {
225 ret = regulator_enable(reg);
226 if (ret)
227 return ret;
228
229 ret = regulator_get_voltage(reg);
230 if (ret < 0)
231 goto error_disable_reg;
232
233 voltage_uv = ret;
234 }
235
236 indio_dev = devm_iio_device_alloc(dev, sizeof(*st));
237 if (indio_dev == NULL) {
238 ret = -ENOMEM;
239 goto error_disable_reg;
240 }
241 st = iio_priv(indio_dev);
242 st->chip_info = chip_info;
243
244 dev_set_drvdata(dev, indio_dev);
245 st->reg = reg;
246 st->dev = dev;
247
248
249 indio_dev->dev.parent = dev;
250 indio_dev->name = name;
251 indio_dev->info = &ad5446_info;
252 indio_dev->modes = INDIO_DIRECT_MODE;
253 indio_dev->channels = &st->chip_info->channel;
254 indio_dev->num_channels = 1;
255
256 st->pwr_down_mode = MODE_PWRDWN_1k;
257
258 if (st->chip_info->int_vref_mv)
259 st->vref_mv = st->chip_info->int_vref_mv;
260 else if (voltage_uv)
261 st->vref_mv = voltage_uv / 1000;
262 else
263 dev_warn(dev, "reference voltage unspecified\n");
264
265 ret = iio_device_register(indio_dev);
266 if (ret)
267 goto error_disable_reg;
268
269 return 0;
270
271error_disable_reg:
272 if (!IS_ERR(reg))
273 regulator_disable(reg);
274 return ret;
275}
276
277static int ad5446_remove(struct device *dev)
278{
279 struct iio_dev *indio_dev = dev_get_drvdata(dev);
280 struct ad5446_state *st = iio_priv(indio_dev);
281
282 iio_device_unregister(indio_dev);
283 if (!IS_ERR(st->reg))
284 regulator_disable(st->reg);
285
286 return 0;
287}
288
289#if IS_ENABLED(CONFIG_SPI_MASTER)
290
291static int ad5446_write(struct ad5446_state *st, unsigned val)
292{
293 struct spi_device *spi = to_spi_device(st->dev);
294 __be16 data = cpu_to_be16(val);
295
296 return spi_write(spi, &data, sizeof(data));
297}
298
299static int ad5660_write(struct ad5446_state *st, unsigned val)
300{
301 struct spi_device *spi = to_spi_device(st->dev);
302 uint8_t data[3];
303
304 data[0] = (val >> 16) & 0xFF;
305 data[1] = (val >> 8) & 0xFF;
306 data[2] = val & 0xFF;
307
308 return spi_write(spi, data, sizeof(data));
309}
310
311
312
313
314
315
316
317
318enum ad5446_supported_spi_device_ids {
319 ID_AD5300,
320 ID_AD5310,
321 ID_AD5320,
322 ID_AD5444,
323 ID_AD5446,
324 ID_AD5450,
325 ID_AD5451,
326 ID_AD5541A,
327 ID_AD5512A,
328 ID_AD5553,
329 ID_AD5601,
330 ID_AD5611,
331 ID_AD5621,
332 ID_AD5620_2500,
333 ID_AD5620_1250,
334 ID_AD5640_2500,
335 ID_AD5640_1250,
336 ID_AD5660_2500,
337 ID_AD5660_1250,
338 ID_AD5662,
339};
340
341static const struct ad5446_chip_info ad5446_spi_chip_info[] = {
342 [ID_AD5300] = {
343 .channel = AD5446_CHANNEL_POWERDOWN(8, 16, 4),
344 .write = ad5446_write,
345 },
346 [ID_AD5310] = {
347 .channel = AD5446_CHANNEL_POWERDOWN(10, 16, 2),
348 .write = ad5446_write,
349 },
350 [ID_AD5320] = {
351 .channel = AD5446_CHANNEL_POWERDOWN(12, 16, 0),
352 .write = ad5446_write,
353 },
354 [ID_AD5444] = {
355 .channel = AD5446_CHANNEL(12, 16, 2),
356 .write = ad5446_write,
357 },
358 [ID_AD5446] = {
359 .channel = AD5446_CHANNEL(14, 16, 0),
360 .write = ad5446_write,
361 },
362 [ID_AD5450] = {
363 .channel = AD5446_CHANNEL(8, 16, 6),
364 .write = ad5446_write,
365 },
366 [ID_AD5451] = {
367 .channel = AD5446_CHANNEL(10, 16, 4),
368 .write = ad5446_write,
369 },
370 [ID_AD5541A] = {
371 .channel = AD5446_CHANNEL(16, 16, 0),
372 .write = ad5446_write,
373 },
374 [ID_AD5512A] = {
375 .channel = AD5446_CHANNEL(12, 16, 4),
376 .write = ad5446_write,
377 },
378 [ID_AD5553] = {
379 .channel = AD5446_CHANNEL(14, 16, 0),
380 .write = ad5446_write,
381 },
382 [ID_AD5601] = {
383 .channel = AD5446_CHANNEL_POWERDOWN(8, 16, 6),
384 .write = ad5446_write,
385 },
386 [ID_AD5611] = {
387 .channel = AD5446_CHANNEL_POWERDOWN(10, 16, 4),
388 .write = ad5446_write,
389 },
390 [ID_AD5621] = {
391 .channel = AD5446_CHANNEL_POWERDOWN(12, 16, 2),
392 .write = ad5446_write,
393 },
394 [ID_AD5620_2500] = {
395 .channel = AD5446_CHANNEL_POWERDOWN(12, 16, 2),
396 .int_vref_mv = 2500,
397 .write = ad5446_write,
398 },
399 [ID_AD5620_1250] = {
400 .channel = AD5446_CHANNEL_POWERDOWN(12, 16, 2),
401 .int_vref_mv = 1250,
402 .write = ad5446_write,
403 },
404 [ID_AD5640_2500] = {
405 .channel = AD5446_CHANNEL_POWERDOWN(14, 16, 0),
406 .int_vref_mv = 2500,
407 .write = ad5446_write,
408 },
409 [ID_AD5640_1250] = {
410 .channel = AD5446_CHANNEL_POWERDOWN(14, 16, 0),
411 .int_vref_mv = 1250,
412 .write = ad5446_write,
413 },
414 [ID_AD5660_2500] = {
415 .channel = AD5446_CHANNEL_POWERDOWN(16, 16, 0),
416 .int_vref_mv = 2500,
417 .write = ad5660_write,
418 },
419 [ID_AD5660_1250] = {
420 .channel = AD5446_CHANNEL_POWERDOWN(16, 16, 0),
421 .int_vref_mv = 1250,
422 .write = ad5660_write,
423 },
424 [ID_AD5662] = {
425 .channel = AD5446_CHANNEL_POWERDOWN(16, 16, 0),
426 .write = ad5660_write,
427 },
428};
429
430static const struct spi_device_id ad5446_spi_ids[] = {
431 {"ad5300", ID_AD5300},
432 {"ad5310", ID_AD5310},
433 {"ad5320", ID_AD5320},
434 {"ad5444", ID_AD5444},
435 {"ad5446", ID_AD5446},
436 {"ad5450", ID_AD5450},
437 {"ad5451", ID_AD5451},
438 {"ad5452", ID_AD5444},
439 {"ad5453", ID_AD5446},
440 {"ad5512a", ID_AD5512A},
441 {"ad5541a", ID_AD5541A},
442 {"ad5542a", ID_AD5541A},
443 {"ad5543", ID_AD5541A},
444 {"ad5553", ID_AD5553},
445 {"ad5601", ID_AD5601},
446 {"ad5611", ID_AD5611},
447 {"ad5621", ID_AD5621},
448 {"ad5620-2500", ID_AD5620_2500},
449 {"ad5620-1250", ID_AD5620_1250},
450 {"ad5640-2500", ID_AD5640_2500},
451 {"ad5640-1250", ID_AD5640_1250},
452 {"ad5660-2500", ID_AD5660_2500},
453 {"ad5660-1250", ID_AD5660_1250},
454 {"ad5662", ID_AD5662},
455 {}
456};
457MODULE_DEVICE_TABLE(spi, ad5446_spi_ids);
458
459static int ad5446_spi_probe(struct spi_device *spi)
460{
461 const struct spi_device_id *id = spi_get_device_id(spi);
462
463 return ad5446_probe(&spi->dev, id->name,
464 &ad5446_spi_chip_info[id->driver_data]);
465}
466
467static int ad5446_spi_remove(struct spi_device *spi)
468{
469 return ad5446_remove(&spi->dev);
470}
471
472static struct spi_driver ad5446_spi_driver = {
473 .driver = {
474 .name = "ad5446",
475 .owner = THIS_MODULE,
476 },
477 .probe = ad5446_spi_probe,
478 .remove = ad5446_spi_remove,
479 .id_table = ad5446_spi_ids,
480};
481
482static int __init ad5446_spi_register_driver(void)
483{
484 return spi_register_driver(&ad5446_spi_driver);
485}
486
487static void ad5446_spi_unregister_driver(void)
488{
489 spi_unregister_driver(&ad5446_spi_driver);
490}
491
492#else
493
494static inline int ad5446_spi_register_driver(void) { return 0; }
495static inline void ad5446_spi_unregister_driver(void) { }
496
497#endif
498
499#if IS_ENABLED(CONFIG_I2C)
500
501static int ad5622_write(struct ad5446_state *st, unsigned val)
502{
503 struct i2c_client *client = to_i2c_client(st->dev);
504 __be16 data = cpu_to_be16(val);
505
506 return i2c_master_send(client, (char *)&data, sizeof(data));
507}
508
509
510
511
512
513
514
515
516enum ad5446_supported_i2c_device_ids {
517 ID_AD5602,
518 ID_AD5612,
519 ID_AD5622,
520};
521
522static const struct ad5446_chip_info ad5446_i2c_chip_info[] = {
523 [ID_AD5602] = {
524 .channel = AD5446_CHANNEL_POWERDOWN(8, 16, 4),
525 .write = ad5622_write,
526 },
527 [ID_AD5612] = {
528 .channel = AD5446_CHANNEL_POWERDOWN(10, 16, 2),
529 .write = ad5622_write,
530 },
531 [ID_AD5622] = {
532 .channel = AD5446_CHANNEL_POWERDOWN(12, 16, 0),
533 .write = ad5622_write,
534 },
535};
536
537static int ad5446_i2c_probe(struct i2c_client *i2c,
538 const struct i2c_device_id *id)
539{
540 return ad5446_probe(&i2c->dev, id->name,
541 &ad5446_i2c_chip_info[id->driver_data]);
542}
543
544static int ad5446_i2c_remove(struct i2c_client *i2c)
545{
546 return ad5446_remove(&i2c->dev);
547}
548
549static const struct i2c_device_id ad5446_i2c_ids[] = {
550 {"ad5301", ID_AD5602},
551 {"ad5311", ID_AD5612},
552 {"ad5321", ID_AD5622},
553 {"ad5602", ID_AD5602},
554 {"ad5612", ID_AD5612},
555 {"ad5622", ID_AD5622},
556 {}
557};
558MODULE_DEVICE_TABLE(i2c, ad5446_i2c_ids);
559
560static struct i2c_driver ad5446_i2c_driver = {
561 .driver = {
562 .name = "ad5446",
563 .owner = THIS_MODULE,
564 },
565 .probe = ad5446_i2c_probe,
566 .remove = ad5446_i2c_remove,
567 .id_table = ad5446_i2c_ids,
568};
569
570static int __init ad5446_i2c_register_driver(void)
571{
572 return i2c_add_driver(&ad5446_i2c_driver);
573}
574
575static void __exit ad5446_i2c_unregister_driver(void)
576{
577 i2c_del_driver(&ad5446_i2c_driver);
578}
579
580#else
581
582static inline int ad5446_i2c_register_driver(void) { return 0; }
583static inline void ad5446_i2c_unregister_driver(void) { }
584
585#endif
586
587static int __init ad5446_init(void)
588{
589 int ret;
590
591 ret = ad5446_spi_register_driver();
592 if (ret)
593 return ret;
594
595 ret = ad5446_i2c_register_driver();
596 if (ret) {
597 ad5446_spi_unregister_driver();
598 return ret;
599 }
600
601 return 0;
602}
603module_init(ad5446_init);
604
605static void __exit ad5446_exit(void)
606{
607 ad5446_i2c_unregister_driver();
608 ad5446_spi_unregister_driver();
609}
610module_exit(ad5446_exit);
611
612MODULE_AUTHOR("Michael Hennerich <hennerich@blackfin.uclinux.org>");
613MODULE_DESCRIPTION("Analog Devices AD5444/AD5446 DAC");
614MODULE_LICENSE("GPL v2");
615