1 /*
2 * AD5446 SPI DAC driver
3 *
4 * Copyright 2010 Analog Devices Inc.
5 *
6 * Licensed under the GPL-2 or later.
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/regulator/consumer.h>
18 #include <linux/err.h>
19 #include <linux/module.h>
20
21 #include "../iio.h"
22 #include "../sysfs.h"
23 #include "dac.h"
24
25 #include "ad5446.h"
26
ad5446_store_sample(struct ad5446_state * st,unsigned val)27 static void ad5446_store_sample(struct ad5446_state *st, unsigned val)
28 {
29 st->data.d16 = cpu_to_be16(AD5446_LOAD | val);
30 }
31
ad5542_store_sample(struct ad5446_state * st,unsigned val)32 static void ad5542_store_sample(struct ad5446_state *st, unsigned val)
33 {
34 st->data.d16 = cpu_to_be16(val);
35 }
36
ad5620_store_sample(struct ad5446_state * st,unsigned val)37 static void ad5620_store_sample(struct ad5446_state *st, unsigned val)
38 {
39 st->data.d16 = cpu_to_be16(AD5620_LOAD | val);
40 }
41
ad5660_store_sample(struct ad5446_state * st,unsigned val)42 static void ad5660_store_sample(struct ad5446_state *st, unsigned val)
43 {
44 val |= AD5660_LOAD;
45 st->data.d24[0] = (val >> 16) & 0xFF;
46 st->data.d24[1] = (val >> 8) & 0xFF;
47 st->data.d24[2] = val & 0xFF;
48 }
49
ad5620_store_pwr_down(struct ad5446_state * st,unsigned mode)50 static void ad5620_store_pwr_down(struct ad5446_state *st, unsigned mode)
51 {
52 st->data.d16 = cpu_to_be16(mode << 14);
53 }
54
ad5660_store_pwr_down(struct ad5446_state * st,unsigned mode)55 static void ad5660_store_pwr_down(struct ad5446_state *st, unsigned mode)
56 {
57 unsigned val = mode << 16;
58
59 st->data.d24[0] = (val >> 16) & 0xFF;
60 st->data.d24[1] = (val >> 8) & 0xFF;
61 st->data.d24[2] = val & 0xFF;
62 }
63
ad5446_write_powerdown_mode(struct device * dev,struct device_attribute * attr,const char * buf,size_t len)64 static ssize_t ad5446_write_powerdown_mode(struct device *dev,
65 struct device_attribute *attr,
66 const char *buf, size_t len)
67 {
68 struct iio_dev *indio_dev = dev_get_drvdata(dev);
69 struct ad5446_state *st = iio_priv(indio_dev);
70
71 if (sysfs_streq(buf, "1kohm_to_gnd"))
72 st->pwr_down_mode = MODE_PWRDWN_1k;
73 else if (sysfs_streq(buf, "100kohm_to_gnd"))
74 st->pwr_down_mode = MODE_PWRDWN_100k;
75 else if (sysfs_streq(buf, "three_state"))
76 st->pwr_down_mode = MODE_PWRDWN_TRISTATE;
77 else
78 return -EINVAL;
79
80 return len;
81 }
82
ad5446_read_powerdown_mode(struct device * dev,struct device_attribute * attr,char * buf)83 static ssize_t ad5446_read_powerdown_mode(struct device *dev,
84 struct device_attribute *attr, char *buf)
85 {
86 struct iio_dev *indio_dev = dev_get_drvdata(dev);
87 struct ad5446_state *st = iio_priv(indio_dev);
88
89 char mode[][15] = {"", "1kohm_to_gnd", "100kohm_to_gnd", "three_state"};
90
91 return sprintf(buf, "%s\n", mode[st->pwr_down_mode]);
92 }
93
ad5446_read_dac_powerdown(struct device * dev,struct device_attribute * attr,char * buf)94 static ssize_t ad5446_read_dac_powerdown(struct device *dev,
95 struct device_attribute *attr,
96 char *buf)
97 {
98 struct iio_dev *indio_dev = dev_get_drvdata(dev);
99 struct ad5446_state *st = iio_priv(indio_dev);
100
101 return sprintf(buf, "%d\n", st->pwr_down);
102 }
103
ad5446_write_dac_powerdown(struct device * dev,struct device_attribute * attr,const char * buf,size_t len)104 static ssize_t ad5446_write_dac_powerdown(struct device *dev,
105 struct device_attribute *attr,
106 const char *buf, size_t len)
107 {
108 struct iio_dev *indio_dev = dev_get_drvdata(dev);
109 struct ad5446_state *st = iio_priv(indio_dev);
110 unsigned long readin;
111 int ret;
112
113 ret = strict_strtol(buf, 10, &readin);
114 if (ret)
115 return ret;
116
117 if (readin > 1)
118 ret = -EINVAL;
119
120 mutex_lock(&indio_dev->mlock);
121 st->pwr_down = readin;
122
123 if (st->pwr_down)
124 st->chip_info->store_pwr_down(st, st->pwr_down_mode);
125 else
126 st->chip_info->store_sample(st, st->cached_val);
127
128 ret = spi_sync(st->spi, &st->msg);
129 mutex_unlock(&indio_dev->mlock);
130
131 return ret ? ret : len;
132 }
133
134 static IIO_DEVICE_ATTR(out_voltage_powerdown_mode, S_IRUGO | S_IWUSR,
135 ad5446_read_powerdown_mode,
136 ad5446_write_powerdown_mode, 0);
137
138 static IIO_CONST_ATTR(out_voltage_powerdown_mode_available,
139 "1kohm_to_gnd 100kohm_to_gnd three_state");
140
141 static IIO_DEVICE_ATTR(out_voltage0_powerdown, S_IRUGO | S_IWUSR,
142 ad5446_read_dac_powerdown,
143 ad5446_write_dac_powerdown, 0);
144
145 static struct attribute *ad5446_attributes[] = {
146 &iio_dev_attr_out_voltage0_powerdown.dev_attr.attr,
147 &iio_dev_attr_out_voltage_powerdown_mode.dev_attr.attr,
148 &iio_const_attr_out_voltage_powerdown_mode_available.dev_attr.attr,
149 NULL,
150 };
151
ad5446_attr_is_visible(struct kobject * kobj,struct attribute * attr,int n)152 static umode_t ad5446_attr_is_visible(struct kobject *kobj,
153 struct attribute *attr, int n)
154 {
155 struct device *dev = container_of(kobj, struct device, kobj);
156 struct iio_dev *indio_dev = dev_get_drvdata(dev);
157 struct ad5446_state *st = iio_priv(indio_dev);
158
159 umode_t mode = attr->mode;
160
161 if (!st->chip_info->store_pwr_down &&
162 (attr == &iio_dev_attr_out_voltage0_powerdown.dev_attr.attr ||
163 attr == &iio_dev_attr_out_voltage_powerdown_mode.
164 dev_attr.attr ||
165 attr ==
166 &iio_const_attr_out_voltage_powerdown_mode_available.
167 dev_attr.attr))
168 mode = 0;
169
170 return mode;
171 }
172
173 static const struct attribute_group ad5446_attribute_group = {
174 .attrs = ad5446_attributes,
175 .is_visible = ad5446_attr_is_visible,
176 };
177
178 #define AD5446_CHANNEL(bits, storage, shift) { \
179 .type = IIO_VOLTAGE, \
180 .indexed = 1, \
181 .output = 1, \
182 .channel = 0, \
183 .info_mask = IIO_CHAN_INFO_SCALE_SHARED_BIT, \
184 .scan_type = IIO_ST('u', (bits), (storage), (shift)) \
185 }
186
187 static const struct ad5446_chip_info ad5446_chip_info_tbl[] = {
188 [ID_AD5444] = {
189 .channel = AD5446_CHANNEL(12, 16, 2),
190 .store_sample = ad5446_store_sample,
191 },
192 [ID_AD5446] = {
193 .channel = AD5446_CHANNEL(14, 16, 0),
194 .store_sample = ad5446_store_sample,
195 },
196 [ID_AD5541A] = {
197 .channel = AD5446_CHANNEL(16, 16, 0),
198 .store_sample = ad5542_store_sample,
199 },
200 [ID_AD5542A] = {
201 .channel = AD5446_CHANNEL(16, 16, 0),
202 .store_sample = ad5542_store_sample,
203 },
204 [ID_AD5543] = {
205 .channel = AD5446_CHANNEL(16, 16, 0),
206 .store_sample = ad5542_store_sample,
207 },
208 [ID_AD5512A] = {
209 .channel = AD5446_CHANNEL(12, 16, 4),
210 .store_sample = ad5542_store_sample,
211 },
212 [ID_AD5553] = {
213 .channel = AD5446_CHANNEL(14, 16, 0),
214 .store_sample = ad5542_store_sample,
215 },
216 [ID_AD5601] = {
217 .channel = AD5446_CHANNEL(8, 16, 6),
218 .store_sample = ad5542_store_sample,
219 .store_pwr_down = ad5620_store_pwr_down,
220 },
221 [ID_AD5611] = {
222 .channel = AD5446_CHANNEL(10, 16, 4),
223 .store_sample = ad5542_store_sample,
224 .store_pwr_down = ad5620_store_pwr_down,
225 },
226 [ID_AD5621] = {
227 .channel = AD5446_CHANNEL(12, 16, 2),
228 .store_sample = ad5542_store_sample,
229 .store_pwr_down = ad5620_store_pwr_down,
230 },
231 [ID_AD5620_2500] = {
232 .channel = AD5446_CHANNEL(12, 16, 2),
233 .int_vref_mv = 2500,
234 .store_sample = ad5620_store_sample,
235 .store_pwr_down = ad5620_store_pwr_down,
236 },
237 [ID_AD5620_1250] = {
238 .channel = AD5446_CHANNEL(12, 16, 2),
239 .int_vref_mv = 1250,
240 .store_sample = ad5620_store_sample,
241 .store_pwr_down = ad5620_store_pwr_down,
242 },
243 [ID_AD5640_2500] = {
244 .channel = AD5446_CHANNEL(14, 16, 0),
245 .int_vref_mv = 2500,
246 .store_sample = ad5620_store_sample,
247 .store_pwr_down = ad5620_store_pwr_down,
248 },
249 [ID_AD5640_1250] = {
250 .channel = AD5446_CHANNEL(14, 16, 0),
251 .int_vref_mv = 1250,
252 .store_sample = ad5620_store_sample,
253 .store_pwr_down = ad5620_store_pwr_down,
254 },
255 [ID_AD5660_2500] = {
256 .channel = AD5446_CHANNEL(16, 16, 0),
257 .int_vref_mv = 2500,
258 .store_sample = ad5660_store_sample,
259 .store_pwr_down = ad5660_store_pwr_down,
260 },
261 [ID_AD5660_1250] = {
262 .channel = AD5446_CHANNEL(16, 16, 0),
263 .int_vref_mv = 1250,
264 .store_sample = ad5660_store_sample,
265 .store_pwr_down = ad5660_store_pwr_down,
266 },
267 };
268
ad5446_read_raw(struct iio_dev * indio_dev,struct iio_chan_spec const * chan,int * val,int * val2,long m)269 static int ad5446_read_raw(struct iio_dev *indio_dev,
270 struct iio_chan_spec const *chan,
271 int *val,
272 int *val2,
273 long m)
274 {
275 struct ad5446_state *st = iio_priv(indio_dev);
276 unsigned long scale_uv;
277
278 switch (m) {
279 case IIO_CHAN_INFO_SCALE:
280 scale_uv = (st->vref_mv * 1000) >> chan->scan_type.realbits;
281 *val = scale_uv / 1000;
282 *val2 = (scale_uv % 1000) * 1000;
283 return IIO_VAL_INT_PLUS_MICRO;
284
285 }
286 return -EINVAL;
287 }
288
ad5446_write_raw(struct iio_dev * indio_dev,struct iio_chan_spec const * chan,int val,int val2,long mask)289 static int ad5446_write_raw(struct iio_dev *indio_dev,
290 struct iio_chan_spec const *chan,
291 int val,
292 int val2,
293 long mask)
294 {
295 struct ad5446_state *st = iio_priv(indio_dev);
296 int ret;
297
298 switch (mask) {
299 case 0:
300 if (val >= (1 << chan->scan_type.realbits) || val < 0)
301 return -EINVAL;
302
303 val <<= chan->scan_type.shift;
304 mutex_lock(&indio_dev->mlock);
305 st->cached_val = val;
306 st->chip_info->store_sample(st, val);
307 ret = spi_sync(st->spi, &st->msg);
308 mutex_unlock(&indio_dev->mlock);
309 break;
310 default:
311 ret = -EINVAL;
312 }
313
314 return ret;
315 }
316
317 static const struct iio_info ad5446_info = {
318 .read_raw = ad5446_read_raw,
319 .write_raw = ad5446_write_raw,
320 .attrs = &ad5446_attribute_group,
321 .driver_module = THIS_MODULE,
322 };
323
ad5446_probe(struct spi_device * spi)324 static int __devinit ad5446_probe(struct spi_device *spi)
325 {
326 struct ad5446_state *st;
327 struct iio_dev *indio_dev;
328 struct regulator *reg;
329 int ret, voltage_uv = 0;
330
331 reg = regulator_get(&spi->dev, "vcc");
332 if (!IS_ERR(reg)) {
333 ret = regulator_enable(reg);
334 if (ret)
335 goto error_put_reg;
336
337 voltage_uv = regulator_get_voltage(reg);
338 }
339
340 indio_dev = iio_allocate_device(sizeof(*st));
341 if (indio_dev == NULL) {
342 ret = -ENOMEM;
343 goto error_disable_reg;
344 }
345 st = iio_priv(indio_dev);
346 st->chip_info =
347 &ad5446_chip_info_tbl[spi_get_device_id(spi)->driver_data];
348
349 spi_set_drvdata(spi, indio_dev);
350 st->reg = reg;
351 st->spi = spi;
352
353 /* Estabilish that the iio_dev is a child of the spi device */
354 indio_dev->dev.parent = &spi->dev;
355 indio_dev->name = spi_get_device_id(spi)->name;
356 indio_dev->info = &ad5446_info;
357 indio_dev->modes = INDIO_DIRECT_MODE;
358 indio_dev->channels = &st->chip_info->channel;
359 indio_dev->num_channels = 1;
360
361 /* Setup default message */
362
363 st->xfer.tx_buf = &st->data;
364 st->xfer.len = st->chip_info->channel.scan_type.storagebits / 8;
365
366 spi_message_init(&st->msg);
367 spi_message_add_tail(&st->xfer, &st->msg);
368
369 switch (spi_get_device_id(spi)->driver_data) {
370 case ID_AD5620_2500:
371 case ID_AD5620_1250:
372 case ID_AD5640_2500:
373 case ID_AD5640_1250:
374 case ID_AD5660_2500:
375 case ID_AD5660_1250:
376 st->vref_mv = st->chip_info->int_vref_mv;
377 break;
378 default:
379 if (voltage_uv)
380 st->vref_mv = voltage_uv / 1000;
381 else
382 dev_warn(&spi->dev,
383 "reference voltage unspecified\n");
384 }
385
386 ret = iio_device_register(indio_dev);
387 if (ret)
388 goto error_free_device;
389
390 return 0;
391
392 error_free_device:
393 iio_free_device(indio_dev);
394 error_disable_reg:
395 if (!IS_ERR(reg))
396 regulator_disable(reg);
397 error_put_reg:
398 if (!IS_ERR(reg))
399 regulator_put(reg);
400
401 return ret;
402 }
403
ad5446_remove(struct spi_device * spi)404 static int ad5446_remove(struct spi_device *spi)
405 {
406 struct iio_dev *indio_dev = spi_get_drvdata(spi);
407 struct ad5446_state *st = iio_priv(indio_dev);
408
409 iio_device_unregister(indio_dev);
410 if (!IS_ERR(st->reg)) {
411 regulator_disable(st->reg);
412 regulator_put(st->reg);
413 }
414 iio_free_device(indio_dev);
415
416 return 0;
417 }
418
419 static const struct spi_device_id ad5446_id[] = {
420 {"ad5444", ID_AD5444},
421 {"ad5446", ID_AD5446},
422 {"ad5512a", ID_AD5512A},
423 {"ad5541a", ID_AD5541A},
424 {"ad5542a", ID_AD5542A},
425 {"ad5543", ID_AD5543},
426 {"ad5553", ID_AD5553},
427 {"ad5601", ID_AD5601},
428 {"ad5611", ID_AD5611},
429 {"ad5621", ID_AD5621},
430 {"ad5620-2500", ID_AD5620_2500}, /* AD5620/40/60: */
431 {"ad5620-1250", ID_AD5620_1250}, /* part numbers may look differently */
432 {"ad5640-2500", ID_AD5640_2500},
433 {"ad5640-1250", ID_AD5640_1250},
434 {"ad5660-2500", ID_AD5660_2500},
435 {"ad5660-1250", ID_AD5660_1250},
436 {}
437 };
438 MODULE_DEVICE_TABLE(spi, ad5446_id);
439
440 static struct spi_driver ad5446_driver = {
441 .driver = {
442 .name = "ad5446",
443 .owner = THIS_MODULE,
444 },
445 .probe = ad5446_probe,
446 .remove = __devexit_p(ad5446_remove),
447 .id_table = ad5446_id,
448 };
449 module_spi_driver(ad5446_driver);
450
451 MODULE_AUTHOR("Michael Hennerich <hennerich@blackfin.uclinux.org>");
452 MODULE_DESCRIPTION("Analog Devices AD5444/AD5446 DAC");
453 MODULE_LICENSE("GPL v2");
454