1 /* 2 * AD5686R, AD5685R, AD5684R Digital to analog converters driver 3 * 4 * Copyright 2011 Analog Devices Inc. 5 * 6 * Licensed under the GPL-2. 7 */ 8 9 #include <linux/interrupt.h> 10 #include <linux/fs.h> 11 #include <linux/device.h> 12 #include <linux/module.h> 13 #include <linux/kernel.h> 14 #include <linux/spi/spi.h> 15 #include <linux/slab.h> 16 #include <linux/sysfs.h> 17 #include <linux/regulator/consumer.h> 18 19 #include <linux/iio/iio.h> 20 #include <linux/iio/sysfs.h> 21 22 #define AD5686_DAC_CHANNELS 4 23 24 #define AD5686_ADDR(x) ((x) << 16) 25 #define AD5686_CMD(x) ((x) << 20) 26 27 #define AD5686_ADDR_DAC(chan) (0x1 << (chan)) 28 #define AD5686_ADDR_ALL_DAC 0xF 29 30 #define AD5686_CMD_NOOP 0x0 31 #define AD5686_CMD_WRITE_INPUT_N 0x1 32 #define AD5686_CMD_UPDATE_DAC_N 0x2 33 #define AD5686_CMD_WRITE_INPUT_N_UPDATE_N 0x3 34 #define AD5686_CMD_POWERDOWN_DAC 0x4 35 #define AD5686_CMD_LDAC_MASK 0x5 36 #define AD5686_CMD_RESET 0x6 37 #define AD5686_CMD_INTERNAL_REFER_SETUP 0x7 38 #define AD5686_CMD_DAISY_CHAIN_ENABLE 0x8 39 #define AD5686_CMD_READBACK_ENABLE 0x9 40 41 #define AD5686_LDAC_PWRDN_NONE 0x0 42 #define AD5686_LDAC_PWRDN_1K 0x1 43 #define AD5686_LDAC_PWRDN_100K 0x2 44 #define AD5686_LDAC_PWRDN_3STATE 0x3 45 46 /** 47 * struct ad5686_chip_info - chip specific information 48 * @int_vref_mv: AD5620/40/60: the internal reference voltage 49 * @channel: channel specification 50 */ 51 52 struct ad5686_chip_info { 53 u16 int_vref_mv; 54 struct iio_chan_spec channel[AD5686_DAC_CHANNELS]; 55 }; 56 57 /** 58 * struct ad5446_state - driver instance specific data 59 * @spi: spi_device 60 * @chip_info: chip model specific constants, available modes etc 61 * @reg: supply regulator 62 * @vref_mv: actual reference voltage used 63 * @pwr_down_mask: power down mask 64 * @pwr_down_mode: current power down mode 65 * @data: spi transfer buffers 66 */ 67 68 struct ad5686_state { 69 struct spi_device *spi; 70 const struct ad5686_chip_info *chip_info; 71 struct regulator *reg; 72 unsigned short vref_mv; 73 unsigned pwr_down_mask; 74 unsigned pwr_down_mode; 75 /* 76 * DMA (thus cache coherency maintenance) requires the 77 * transfer buffers to live in their own cache lines. 78 */ 79 80 union { 81 u32 d32; 82 u8 d8[4]; 83 } data[3] ____cacheline_aligned; 84 }; 85 86 /** 87 * ad5686_supported_device_ids: 88 */ 89 90 enum ad5686_supported_device_ids { 91 ID_AD5684, 92 ID_AD5685, 93 ID_AD5686, 94 }; 95 static int ad5686_spi_write(struct ad5686_state *st, 96 u8 cmd, u8 addr, u16 val, u8 shift) 97 { 98 val <<= shift; 99 100 st->data[0].d32 = cpu_to_be32(AD5686_CMD(cmd) | 101 AD5686_ADDR(addr) | 102 val); 103 104 return spi_write(st->spi, &st->data[0].d8[1], 3); 105 } 106 107 static int ad5686_spi_read(struct ad5686_state *st, u8 addr) 108 { 109 struct spi_transfer t[] = { 110 { 111 .tx_buf = &st->data[0].d8[1], 112 .len = 3, 113 .cs_change = 1, 114 }, { 115 .tx_buf = &st->data[1].d8[1], 116 .rx_buf = &st->data[2].d8[1], 117 .len = 3, 118 }, 119 }; 120 int ret; 121 122 st->data[0].d32 = cpu_to_be32(AD5686_CMD(AD5686_CMD_READBACK_ENABLE) | 123 AD5686_ADDR(addr)); 124 st->data[1].d32 = cpu_to_be32(AD5686_CMD(AD5686_CMD_NOOP)); 125 126 ret = spi_sync_transfer(st->spi, t, ARRAY_SIZE(t)); 127 if (ret < 0) 128 return ret; 129 130 return be32_to_cpu(st->data[2].d32); 131 } 132 133 static const char * const ad5686_powerdown_modes[] = { 134 "1kohm_to_gnd", 135 "100kohm_to_gnd", 136 "three_state" 137 }; 138 139 static int ad5686_get_powerdown_mode(struct iio_dev *indio_dev, 140 const struct iio_chan_spec *chan) 141 { 142 struct ad5686_state *st = iio_priv(indio_dev); 143 144 return ((st->pwr_down_mode >> (chan->channel * 2)) & 0x3) - 1; 145 } 146 147 static int ad5686_set_powerdown_mode(struct iio_dev *indio_dev, 148 const struct iio_chan_spec *chan, unsigned int mode) 149 { 150 struct ad5686_state *st = iio_priv(indio_dev); 151 152 st->pwr_down_mode &= ~(0x3 << (chan->channel * 2)); 153 st->pwr_down_mode |= ((mode + 1) << (chan->channel * 2)); 154 155 return 0; 156 } 157 158 static const struct iio_enum ad5686_powerdown_mode_enum = { 159 .items = ad5686_powerdown_modes, 160 .num_items = ARRAY_SIZE(ad5686_powerdown_modes), 161 .get = ad5686_get_powerdown_mode, 162 .set = ad5686_set_powerdown_mode, 163 }; 164 165 static ssize_t ad5686_read_dac_powerdown(struct iio_dev *indio_dev, 166 uintptr_t private, const struct iio_chan_spec *chan, char *buf) 167 { 168 struct ad5686_state *st = iio_priv(indio_dev); 169 170 return sprintf(buf, "%d\n", !!(st->pwr_down_mask & 171 (0x3 << (chan->channel * 2)))); 172 } 173 174 static ssize_t ad5686_write_dac_powerdown(struct iio_dev *indio_dev, 175 uintptr_t private, const struct iio_chan_spec *chan, const char *buf, 176 size_t len) 177 { 178 bool readin; 179 int ret; 180 struct ad5686_state *st = iio_priv(indio_dev); 181 182 ret = strtobool(buf, &readin); 183 if (ret) 184 return ret; 185 186 if (readin) 187 st->pwr_down_mask |= (0x3 << (chan->channel * 2)); 188 else 189 st->pwr_down_mask &= ~(0x3 << (chan->channel * 2)); 190 191 ret = ad5686_spi_write(st, AD5686_CMD_POWERDOWN_DAC, 0, 192 st->pwr_down_mask & st->pwr_down_mode, 0); 193 194 return ret ? ret : len; 195 } 196 197 static int ad5686_read_raw(struct iio_dev *indio_dev, 198 struct iio_chan_spec const *chan, 199 int *val, 200 int *val2, 201 long m) 202 { 203 struct ad5686_state *st = iio_priv(indio_dev); 204 int ret; 205 206 switch (m) { 207 case IIO_CHAN_INFO_RAW: 208 mutex_lock(&indio_dev->mlock); 209 ret = ad5686_spi_read(st, chan->address); 210 mutex_unlock(&indio_dev->mlock); 211 if (ret < 0) 212 return ret; 213 *val = ret; 214 return IIO_VAL_INT; 215 case IIO_CHAN_INFO_SCALE: 216 *val = st->vref_mv; 217 *val2 = chan->scan_type.realbits; 218 return IIO_VAL_FRACTIONAL_LOG2; 219 } 220 return -EINVAL; 221 } 222 223 static int ad5686_write_raw(struct iio_dev *indio_dev, 224 struct iio_chan_spec const *chan, 225 int val, 226 int val2, 227 long mask) 228 { 229 struct ad5686_state *st = iio_priv(indio_dev); 230 int ret; 231 232 switch (mask) { 233 case IIO_CHAN_INFO_RAW: 234 if (val > (1 << chan->scan_type.realbits) || val < 0) 235 return -EINVAL; 236 237 mutex_lock(&indio_dev->mlock); 238 ret = ad5686_spi_write(st, 239 AD5686_CMD_WRITE_INPUT_N_UPDATE_N, 240 chan->address, 241 val, 242 chan->scan_type.shift); 243 mutex_unlock(&indio_dev->mlock); 244 break; 245 default: 246 ret = -EINVAL; 247 } 248 249 return ret; 250 } 251 252 static const struct iio_info ad5686_info = { 253 .read_raw = ad5686_read_raw, 254 .write_raw = ad5686_write_raw, 255 .driver_module = THIS_MODULE, 256 }; 257 258 static const struct iio_chan_spec_ext_info ad5686_ext_info[] = { 259 { 260 .name = "powerdown", 261 .read = ad5686_read_dac_powerdown, 262 .write = ad5686_write_dac_powerdown, 263 .shared = IIO_SEPARATE, 264 }, 265 IIO_ENUM("powerdown_mode", IIO_SEPARATE, &ad5686_powerdown_mode_enum), 266 IIO_ENUM_AVAILABLE("powerdown_mode", &ad5686_powerdown_mode_enum), 267 { }, 268 }; 269 270 #define AD5868_CHANNEL(chan, bits, shift) { \ 271 .type = IIO_VOLTAGE, \ 272 .indexed = 1, \ 273 .output = 1, \ 274 .channel = chan, \ 275 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW), \ 276 .info_mask_shared_by_type = BIT(IIO_CHAN_INFO_SCALE),\ 277 .address = AD5686_ADDR_DAC(chan), \ 278 .scan_type = IIO_ST('u', bits, 16, shift), \ 279 .ext_info = ad5686_ext_info, \ 280 } 281 282 static const struct ad5686_chip_info ad5686_chip_info_tbl[] = { 283 [ID_AD5684] = { 284 .channel[0] = AD5868_CHANNEL(0, 12, 4), 285 .channel[1] = AD5868_CHANNEL(1, 12, 4), 286 .channel[2] = AD5868_CHANNEL(2, 12, 4), 287 .channel[3] = AD5868_CHANNEL(3, 12, 4), 288 .int_vref_mv = 2500, 289 }, 290 [ID_AD5685] = { 291 .channel[0] = AD5868_CHANNEL(0, 14, 2), 292 .channel[1] = AD5868_CHANNEL(1, 14, 2), 293 .channel[2] = AD5868_CHANNEL(2, 14, 2), 294 .channel[3] = AD5868_CHANNEL(3, 14, 2), 295 .int_vref_mv = 2500, 296 }, 297 [ID_AD5686] = { 298 .channel[0] = AD5868_CHANNEL(0, 16, 0), 299 .channel[1] = AD5868_CHANNEL(1, 16, 0), 300 .channel[2] = AD5868_CHANNEL(2, 16, 0), 301 .channel[3] = AD5868_CHANNEL(3, 16, 0), 302 .int_vref_mv = 2500, 303 }, 304 }; 305 306 307 static int ad5686_probe(struct spi_device *spi) 308 { 309 struct ad5686_state *st; 310 struct iio_dev *indio_dev; 311 int ret, regdone = 0, voltage_uv = 0; 312 313 indio_dev = devm_iio_device_alloc(&spi->dev, sizeof(*st)); 314 if (indio_dev == NULL) 315 return -ENOMEM; 316 317 st = iio_priv(indio_dev); 318 spi_set_drvdata(spi, indio_dev); 319 320 st->reg = devm_regulator_get(&spi->dev, "vcc"); 321 if (!IS_ERR(st->reg)) { 322 ret = regulator_enable(st->reg); 323 if (ret) 324 return ret; 325 326 ret = regulator_get_voltage(st->reg); 327 if (ret < 0) 328 goto error_disable_reg; 329 330 voltage_uv = ret; 331 } 332 333 st->chip_info = 334 &ad5686_chip_info_tbl[spi_get_device_id(spi)->driver_data]; 335 336 if (voltage_uv) 337 st->vref_mv = voltage_uv / 1000; 338 else 339 st->vref_mv = st->chip_info->int_vref_mv; 340 341 st->spi = spi; 342 343 /* Set all the power down mode for all channels to 1K pulldown */ 344 st->pwr_down_mode = 0x55; 345 346 indio_dev->dev.parent = &spi->dev; 347 indio_dev->name = spi_get_device_id(spi)->name; 348 indio_dev->info = &ad5686_info; 349 indio_dev->modes = INDIO_DIRECT_MODE; 350 indio_dev->channels = st->chip_info->channel; 351 indio_dev->num_channels = AD5686_DAC_CHANNELS; 352 353 regdone = 1; 354 ret = ad5686_spi_write(st, AD5686_CMD_INTERNAL_REFER_SETUP, 0, 355 !!voltage_uv, 0); 356 if (ret) 357 goto error_disable_reg; 358 359 ret = iio_device_register(indio_dev); 360 if (ret) 361 goto error_disable_reg; 362 363 return 0; 364 365 error_disable_reg: 366 if (!IS_ERR(st->reg)) 367 regulator_disable(st->reg); 368 return ret; 369 } 370 371 static int ad5686_remove(struct spi_device *spi) 372 { 373 struct iio_dev *indio_dev = spi_get_drvdata(spi); 374 struct ad5686_state *st = iio_priv(indio_dev); 375 376 iio_device_unregister(indio_dev); 377 if (!IS_ERR(st->reg)) 378 regulator_disable(st->reg); 379 380 return 0; 381 } 382 383 static const struct spi_device_id ad5686_id[] = { 384 {"ad5684", ID_AD5684}, 385 {"ad5685", ID_AD5685}, 386 {"ad5686", ID_AD5686}, 387 {} 388 }; 389 MODULE_DEVICE_TABLE(spi, ad5686_id); 390 391 static struct spi_driver ad5686_driver = { 392 .driver = { 393 .name = "ad5686", 394 .owner = THIS_MODULE, 395 }, 396 .probe = ad5686_probe, 397 .remove = ad5686_remove, 398 .id_table = ad5686_id, 399 }; 400 module_spi_driver(ad5686_driver); 401 402 MODULE_AUTHOR("Michael Hennerich <hennerich@blackfin.uclinux.org>"); 403 MODULE_DESCRIPTION("Analog Devices AD5686/85/84 DAC"); 404 MODULE_LICENSE("GPL v2"); 405