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 <linux/iio/iio.h> 22 #include <linux/iio/sysfs.h> 23 24 #include "ad5446.h" 25 26 static int ad5446_write(struct ad5446_state *st, unsigned val) 27 { 28 __be16 data = cpu_to_be16(val); 29 return spi_write(st->spi, &data, sizeof(data)); 30 } 31 32 static int ad5660_write(struct ad5446_state *st, unsigned val) 33 { 34 uint8_t data[3]; 35 36 data[0] = (val >> 16) & 0xFF; 37 data[1] = (val >> 8) & 0xFF; 38 data[2] = val & 0xFF; 39 40 return spi_write(st->spi, data, sizeof(data)); 41 } 42 43 static const char * const ad5446_powerdown_modes[] = { 44 "1kohm_to_gnd", "100kohm_to_gnd", "three_state" 45 }; 46 47 static int ad5446_set_powerdown_mode(struct iio_dev *indio_dev, 48 const struct iio_chan_spec *chan, unsigned int mode) 49 { 50 struct ad5446_state *st = iio_priv(indio_dev); 51 52 st->pwr_down_mode = mode + 1; 53 54 return 0; 55 } 56 57 static int ad5446_get_powerdown_mode(struct iio_dev *indio_dev, 58 const struct iio_chan_spec *chan) 59 { 60 struct ad5446_state *st = iio_priv(indio_dev); 61 62 return st->pwr_down_mode - 1; 63 } 64 65 static const struct iio_enum ad5446_powerdown_mode_enum = { 66 .items = ad5446_powerdown_modes, 67 .num_items = ARRAY_SIZE(ad5446_powerdown_modes), 68 .get = ad5446_get_powerdown_mode, 69 .set = ad5446_set_powerdown_mode, 70 }; 71 72 static ssize_t ad5446_read_dac_powerdown(struct iio_dev *indio_dev, 73 uintptr_t private, 74 const struct iio_chan_spec *chan, 75 char *buf) 76 { 77 struct ad5446_state *st = iio_priv(indio_dev); 78 79 return sprintf(buf, "%d\n", st->pwr_down); 80 } 81 82 static ssize_t ad5446_write_dac_powerdown(struct iio_dev *indio_dev, 83 uintptr_t private, 84 const struct iio_chan_spec *chan, 85 const char *buf, size_t len) 86 { 87 struct ad5446_state *st = iio_priv(indio_dev); 88 unsigned int shift; 89 unsigned int val; 90 bool powerdown; 91 int ret; 92 93 ret = strtobool(buf, &powerdown); 94 if (ret) 95 return ret; 96 97 mutex_lock(&indio_dev->mlock); 98 st->pwr_down = powerdown; 99 100 if (st->pwr_down) { 101 shift = chan->scan_type.realbits + chan->scan_type.shift; 102 val = st->pwr_down_mode << shift; 103 } else { 104 val = st->cached_val; 105 } 106 107 ret = st->chip_info->write(st, val); 108 mutex_unlock(&indio_dev->mlock); 109 110 return ret ? ret : len; 111 } 112 113 static const struct iio_chan_spec_ext_info ad5064_ext_info_powerdown[] = { 114 { 115 .name = "powerdown", 116 .read = ad5446_read_dac_powerdown, 117 .write = ad5446_write_dac_powerdown, 118 }, 119 IIO_ENUM("powerdown_mode", false, &ad5446_powerdown_mode_enum), 120 IIO_ENUM_AVAILABLE("powerdown_mode", &ad5446_powerdown_mode_enum), 121 { }, 122 }; 123 124 #define _AD5446_CHANNEL(bits, storage, shift, ext) { \ 125 .type = IIO_VOLTAGE, \ 126 .indexed = 1, \ 127 .output = 1, \ 128 .channel = 0, \ 129 .info_mask = IIO_CHAN_INFO_RAW_SEPARATE_BIT | \ 130 IIO_CHAN_INFO_SCALE_SHARED_BIT, \ 131 .scan_type = IIO_ST('u', (bits), (storage), (shift)), \ 132 .ext_info = (ext), \ 133 } 134 135 #define AD5446_CHANNEL(bits, storage, shift) \ 136 _AD5446_CHANNEL(bits, storage, shift, NULL) 137 138 #define AD5446_CHANNEL_POWERDOWN(bits, storage, shift) \ 139 _AD5446_CHANNEL(bits, storage, shift, ad5064_ext_info_powerdown) 140 141 static const struct ad5446_chip_info ad5446_chip_info_tbl[] = { 142 [ID_AD5444] = { 143 .channel = AD5446_CHANNEL(12, 16, 2), 144 .write = ad5446_write, 145 }, 146 [ID_AD5446] = { 147 .channel = AD5446_CHANNEL(14, 16, 0), 148 .write = ad5446_write, 149 }, 150 [ID_AD5450] = { 151 .channel = AD5446_CHANNEL(8, 16, 6), 152 .write = ad5446_write, 153 }, 154 [ID_AD5451] = { 155 .channel = AD5446_CHANNEL(10, 16, 4), 156 .write = ad5446_write, 157 }, 158 [ID_AD5541A] = { 159 .channel = AD5446_CHANNEL(16, 16, 0), 160 .write = ad5446_write, 161 }, 162 [ID_AD5512A] = { 163 .channel = AD5446_CHANNEL(12, 16, 4), 164 .write = ad5446_write, 165 }, 166 [ID_AD5553] = { 167 .channel = AD5446_CHANNEL(14, 16, 0), 168 .write = ad5446_write, 169 }, 170 [ID_AD5601] = { 171 .channel = AD5446_CHANNEL_POWERDOWN(8, 16, 6), 172 .write = ad5446_write, 173 }, 174 [ID_AD5611] = { 175 .channel = AD5446_CHANNEL_POWERDOWN(10, 16, 4), 176 .write = ad5446_write, 177 }, 178 [ID_AD5621] = { 179 .channel = AD5446_CHANNEL_POWERDOWN(12, 16, 2), 180 .write = ad5446_write, 181 }, 182 [ID_AD5620_2500] = { 183 .channel = AD5446_CHANNEL_POWERDOWN(12, 16, 2), 184 .int_vref_mv = 2500, 185 .write = ad5446_write, 186 }, 187 [ID_AD5620_1250] = { 188 .channel = AD5446_CHANNEL_POWERDOWN(12, 16, 2), 189 .int_vref_mv = 1250, 190 .write = ad5446_write, 191 }, 192 [ID_AD5640_2500] = { 193 .channel = AD5446_CHANNEL_POWERDOWN(14, 16, 0), 194 .int_vref_mv = 2500, 195 .write = ad5446_write, 196 }, 197 [ID_AD5640_1250] = { 198 .channel = AD5446_CHANNEL_POWERDOWN(14, 16, 0), 199 .int_vref_mv = 1250, 200 .write = ad5446_write, 201 }, 202 [ID_AD5660_2500] = { 203 .channel = AD5446_CHANNEL_POWERDOWN(16, 16, 0), 204 .int_vref_mv = 2500, 205 .write = ad5660_write, 206 }, 207 [ID_AD5660_1250] = { 208 .channel = AD5446_CHANNEL_POWERDOWN(16, 16, 0), 209 .int_vref_mv = 1250, 210 .write = ad5660_write, 211 }, 212 [ID_AD5662] = { 213 .channel = AD5446_CHANNEL_POWERDOWN(16, 16, 0), 214 .write = ad5660_write, 215 }, 216 }; 217 218 static int ad5446_read_raw(struct iio_dev *indio_dev, 219 struct iio_chan_spec const *chan, 220 int *val, 221 int *val2, 222 long m) 223 { 224 struct ad5446_state *st = iio_priv(indio_dev); 225 unsigned long scale_uv; 226 227 switch (m) { 228 case IIO_CHAN_INFO_RAW: 229 *val = st->cached_val; 230 return IIO_VAL_INT; 231 case IIO_CHAN_INFO_SCALE: 232 scale_uv = (st->vref_mv * 1000) >> chan->scan_type.realbits; 233 *val = scale_uv / 1000; 234 *val2 = (scale_uv % 1000) * 1000; 235 return IIO_VAL_INT_PLUS_MICRO; 236 237 } 238 return -EINVAL; 239 } 240 241 static int ad5446_write_raw(struct iio_dev *indio_dev, 242 struct iio_chan_spec const *chan, 243 int val, 244 int val2, 245 long mask) 246 { 247 struct ad5446_state *st = iio_priv(indio_dev); 248 int ret = 0; 249 250 switch (mask) { 251 case IIO_CHAN_INFO_RAW: 252 if (val >= (1 << chan->scan_type.realbits) || val < 0) 253 return -EINVAL; 254 255 val <<= chan->scan_type.shift; 256 mutex_lock(&indio_dev->mlock); 257 st->cached_val = val; 258 if (!st->pwr_down) 259 ret = st->chip_info->write(st, val); 260 mutex_unlock(&indio_dev->mlock); 261 break; 262 default: 263 ret = -EINVAL; 264 } 265 266 return ret; 267 } 268 269 static const struct iio_info ad5446_info = { 270 .read_raw = ad5446_read_raw, 271 .write_raw = ad5446_write_raw, 272 .driver_module = THIS_MODULE, 273 }; 274 275 static int __devinit ad5446_probe(struct spi_device *spi) 276 { 277 struct ad5446_state *st; 278 struct iio_dev *indio_dev; 279 struct regulator *reg; 280 int ret, voltage_uv = 0; 281 282 reg = regulator_get(&spi->dev, "vcc"); 283 if (!IS_ERR(reg)) { 284 ret = regulator_enable(reg); 285 if (ret) 286 goto error_put_reg; 287 288 voltage_uv = regulator_get_voltage(reg); 289 } 290 291 indio_dev = iio_device_alloc(sizeof(*st)); 292 if (indio_dev == NULL) { 293 ret = -ENOMEM; 294 goto error_disable_reg; 295 } 296 st = iio_priv(indio_dev); 297 st->chip_info = 298 &ad5446_chip_info_tbl[spi_get_device_id(spi)->driver_data]; 299 300 spi_set_drvdata(spi, indio_dev); 301 st->reg = reg; 302 st->spi = spi; 303 304 /* Establish that the iio_dev is a child of the spi device */ 305 indio_dev->dev.parent = &spi->dev; 306 indio_dev->name = spi_get_device_id(spi)->name; 307 indio_dev->info = &ad5446_info; 308 indio_dev->modes = INDIO_DIRECT_MODE; 309 indio_dev->channels = &st->chip_info->channel; 310 indio_dev->num_channels = 1; 311 312 st->pwr_down_mode = MODE_PWRDWN_1k; 313 314 if (st->chip_info->int_vref_mv) 315 st->vref_mv = st->chip_info->int_vref_mv; 316 else if (voltage_uv) 317 st->vref_mv = voltage_uv / 1000; 318 else 319 dev_warn(&spi->dev, "reference voltage unspecified\n"); 320 321 ret = iio_device_register(indio_dev); 322 if (ret) 323 goto error_free_device; 324 325 return 0; 326 327 error_free_device: 328 iio_device_free(indio_dev); 329 error_disable_reg: 330 if (!IS_ERR(reg)) 331 regulator_disable(reg); 332 error_put_reg: 333 if (!IS_ERR(reg)) 334 regulator_put(reg); 335 336 return ret; 337 } 338 339 static int ad5446_remove(struct spi_device *spi) 340 { 341 struct iio_dev *indio_dev = spi_get_drvdata(spi); 342 struct ad5446_state *st = iio_priv(indio_dev); 343 344 iio_device_unregister(indio_dev); 345 if (!IS_ERR(st->reg)) { 346 regulator_disable(st->reg); 347 regulator_put(st->reg); 348 } 349 iio_device_free(indio_dev); 350 351 return 0; 352 } 353 354 static const struct spi_device_id ad5446_id[] = { 355 {"ad5444", ID_AD5444}, 356 {"ad5446", ID_AD5446}, 357 {"ad5450", ID_AD5450}, 358 {"ad5451", ID_AD5451}, 359 {"ad5452", ID_AD5444}, /* ad5452 is compatible to the ad5444 */ 360 {"ad5453", ID_AD5446}, /* ad5453 is compatible to the ad5446 */ 361 {"ad5512a", ID_AD5512A}, 362 {"ad5541a", ID_AD5541A}, 363 {"ad5542a", ID_AD5541A}, /* ad5541a and ad5542a are compatible */ 364 {"ad5543", ID_AD5541A}, /* ad5541a and ad5543 are compatible */ 365 {"ad5553", ID_AD5553}, 366 {"ad5601", ID_AD5601}, 367 {"ad5611", ID_AD5611}, 368 {"ad5621", ID_AD5621}, 369 {"ad5620-2500", ID_AD5620_2500}, /* AD5620/40/60: */ 370 {"ad5620-1250", ID_AD5620_1250}, /* part numbers may look differently */ 371 {"ad5640-2500", ID_AD5640_2500}, 372 {"ad5640-1250", ID_AD5640_1250}, 373 {"ad5660-2500", ID_AD5660_2500}, 374 {"ad5660-1250", ID_AD5660_1250}, 375 {"ad5662", ID_AD5662}, 376 {} 377 }; 378 MODULE_DEVICE_TABLE(spi, ad5446_id); 379 380 static struct spi_driver ad5446_driver = { 381 .driver = { 382 .name = "ad5446", 383 .owner = THIS_MODULE, 384 }, 385 .probe = ad5446_probe, 386 .remove = __devexit_p(ad5446_remove), 387 .id_table = ad5446_id, 388 }; 389 module_spi_driver(ad5446_driver); 390 391 MODULE_AUTHOR("Michael Hennerich <hennerich@blackfin.uclinux.org>"); 392 MODULE_DESCRIPTION("Analog Devices AD5444/AD5446 DAC"); 393 MODULE_LICENSE("GPL v2"); 394