1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * Analog devices AD5380, AD5381, AD5382, AD5383, AD5390, AD5391, AD5392 4 * multi-channel Digital to Analog Converters driver 5 * 6 * Copyright 2011 Analog Devices Inc. 7 */ 8 9 #include <linux/device.h> 10 #include <linux/err.h> 11 #include <linux/i2c.h> 12 #include <linux/kernel.h> 13 #include <linux/module.h> 14 #include <linux/spi/spi.h> 15 #include <linux/slab.h> 16 #include <linux/sysfs.h> 17 #include <linux/regmap.h> 18 #include <linux/regulator/consumer.h> 19 20 #include <linux/iio/iio.h> 21 #include <linux/iio/sysfs.h> 22 23 #define AD5380_REG_DATA(x) (((x) << 2) | 3) 24 #define AD5380_REG_OFFSET(x) (((x) << 2) | 2) 25 #define AD5380_REG_GAIN(x) (((x) << 2) | 1) 26 #define AD5380_REG_SF_PWR_DOWN (8 << 2) 27 #define AD5380_REG_SF_PWR_UP (9 << 2) 28 #define AD5380_REG_SF_CTRL (12 << 2) 29 30 #define AD5380_CTRL_PWR_DOWN_MODE_OFFSET 13 31 #define AD5380_CTRL_INT_VREF_2V5 BIT(12) 32 #define AD5380_CTRL_INT_VREF_EN BIT(10) 33 34 /** 35 * struct ad5380_chip_info - chip specific information 36 * @channel_template: channel specification template 37 * @num_channels: number of channels 38 * @int_vref: internal vref in uV 39 */ 40 41 struct ad5380_chip_info { 42 struct iio_chan_spec channel_template; 43 unsigned int num_channels; 44 unsigned int int_vref; 45 }; 46 47 /** 48 * struct ad5380_state - driver instance specific data 49 * @regmap: regmap instance used by the device 50 * @chip_info: chip model specific constants, available modes etc 51 * @vref_reg: vref supply regulator 52 * @vref: actual reference voltage used in uA 53 * @pwr_down: whether the chip is currently in power down mode 54 * @lock: lock to protect the data buffer during regmap ops 55 */ 56 57 struct ad5380_state { 58 struct regmap *regmap; 59 const struct ad5380_chip_info *chip_info; 60 struct regulator *vref_reg; 61 int vref; 62 bool pwr_down; 63 struct mutex lock; 64 }; 65 66 enum ad5380_type { 67 ID_AD5380_3, 68 ID_AD5380_5, 69 ID_AD5381_3, 70 ID_AD5381_5, 71 ID_AD5382_3, 72 ID_AD5382_5, 73 ID_AD5383_3, 74 ID_AD5383_5, 75 ID_AD5390_3, 76 ID_AD5390_5, 77 ID_AD5391_3, 78 ID_AD5391_5, 79 ID_AD5392_3, 80 ID_AD5392_5, 81 }; 82 83 static ssize_t ad5380_read_dac_powerdown(struct iio_dev *indio_dev, 84 uintptr_t private, const struct iio_chan_spec *chan, char *buf) 85 { 86 struct ad5380_state *st = iio_priv(indio_dev); 87 88 return sysfs_emit(buf, "%d\n", st->pwr_down); 89 } 90 91 static ssize_t ad5380_write_dac_powerdown(struct iio_dev *indio_dev, 92 uintptr_t private, const struct iio_chan_spec *chan, const char *buf, 93 size_t len) 94 { 95 struct ad5380_state *st = iio_priv(indio_dev); 96 bool pwr_down; 97 int ret; 98 99 ret = strtobool(buf, &pwr_down); 100 if (ret) 101 return ret; 102 103 mutex_lock(&st->lock); 104 105 if (pwr_down) 106 ret = regmap_write(st->regmap, AD5380_REG_SF_PWR_DOWN, 0); 107 else 108 ret = regmap_write(st->regmap, AD5380_REG_SF_PWR_UP, 0); 109 110 st->pwr_down = pwr_down; 111 112 mutex_unlock(&st->lock); 113 114 return ret ? ret : len; 115 } 116 117 static const char * const ad5380_powerdown_modes[] = { 118 "100kohm_to_gnd", 119 "three_state", 120 }; 121 122 static int ad5380_get_powerdown_mode(struct iio_dev *indio_dev, 123 const struct iio_chan_spec *chan) 124 { 125 struct ad5380_state *st = iio_priv(indio_dev); 126 unsigned int mode; 127 int ret; 128 129 ret = regmap_read(st->regmap, AD5380_REG_SF_CTRL, &mode); 130 if (ret) 131 return ret; 132 133 mode = (mode >> AD5380_CTRL_PWR_DOWN_MODE_OFFSET) & 1; 134 135 return mode; 136 } 137 138 static int ad5380_set_powerdown_mode(struct iio_dev *indio_dev, 139 const struct iio_chan_spec *chan, unsigned int mode) 140 { 141 struct ad5380_state *st = iio_priv(indio_dev); 142 int ret; 143 144 ret = regmap_update_bits(st->regmap, AD5380_REG_SF_CTRL, 145 1 << AD5380_CTRL_PWR_DOWN_MODE_OFFSET, 146 mode << AD5380_CTRL_PWR_DOWN_MODE_OFFSET); 147 148 return ret; 149 } 150 151 static const struct iio_enum ad5380_powerdown_mode_enum = { 152 .items = ad5380_powerdown_modes, 153 .num_items = ARRAY_SIZE(ad5380_powerdown_modes), 154 .get = ad5380_get_powerdown_mode, 155 .set = ad5380_set_powerdown_mode, 156 }; 157 158 static unsigned int ad5380_info_to_reg(struct iio_chan_spec const *chan, 159 long info) 160 { 161 switch (info) { 162 case IIO_CHAN_INFO_RAW: 163 return AD5380_REG_DATA(chan->address); 164 case IIO_CHAN_INFO_CALIBBIAS: 165 return AD5380_REG_OFFSET(chan->address); 166 case IIO_CHAN_INFO_CALIBSCALE: 167 return AD5380_REG_GAIN(chan->address); 168 default: 169 break; 170 } 171 172 return 0; 173 } 174 175 static int ad5380_write_raw(struct iio_dev *indio_dev, 176 struct iio_chan_spec const *chan, int val, int val2, long info) 177 { 178 const unsigned int max_val = (1 << chan->scan_type.realbits); 179 struct ad5380_state *st = iio_priv(indio_dev); 180 181 switch (info) { 182 case IIO_CHAN_INFO_RAW: 183 case IIO_CHAN_INFO_CALIBSCALE: 184 if (val >= max_val || val < 0) 185 return -EINVAL; 186 187 return regmap_write(st->regmap, 188 ad5380_info_to_reg(chan, info), 189 val << chan->scan_type.shift); 190 case IIO_CHAN_INFO_CALIBBIAS: 191 val += (1 << chan->scan_type.realbits) / 2; 192 if (val >= max_val || val < 0) 193 return -EINVAL; 194 195 return regmap_write(st->regmap, 196 AD5380_REG_OFFSET(chan->address), 197 val << chan->scan_type.shift); 198 default: 199 break; 200 } 201 return -EINVAL; 202 } 203 204 static int ad5380_read_raw(struct iio_dev *indio_dev, 205 struct iio_chan_spec const *chan, int *val, int *val2, long info) 206 { 207 struct ad5380_state *st = iio_priv(indio_dev); 208 int ret; 209 210 switch (info) { 211 case IIO_CHAN_INFO_RAW: 212 case IIO_CHAN_INFO_CALIBSCALE: 213 ret = regmap_read(st->regmap, ad5380_info_to_reg(chan, info), 214 val); 215 if (ret) 216 return ret; 217 *val >>= chan->scan_type.shift; 218 return IIO_VAL_INT; 219 case IIO_CHAN_INFO_CALIBBIAS: 220 ret = regmap_read(st->regmap, AD5380_REG_OFFSET(chan->address), 221 val); 222 if (ret) 223 return ret; 224 *val >>= chan->scan_type.shift; 225 *val -= (1 << chan->scan_type.realbits) / 2; 226 return IIO_VAL_INT; 227 case IIO_CHAN_INFO_SCALE: 228 *val = 2 * st->vref; 229 *val2 = chan->scan_type.realbits; 230 return IIO_VAL_FRACTIONAL_LOG2; 231 default: 232 break; 233 } 234 235 return -EINVAL; 236 } 237 238 static const struct iio_info ad5380_info = { 239 .read_raw = ad5380_read_raw, 240 .write_raw = ad5380_write_raw, 241 }; 242 243 static const struct iio_chan_spec_ext_info ad5380_ext_info[] = { 244 { 245 .name = "powerdown", 246 .read = ad5380_read_dac_powerdown, 247 .write = ad5380_write_dac_powerdown, 248 .shared = IIO_SEPARATE, 249 }, 250 IIO_ENUM("powerdown_mode", IIO_SHARED_BY_TYPE, 251 &ad5380_powerdown_mode_enum), 252 IIO_ENUM_AVAILABLE("powerdown_mode", &ad5380_powerdown_mode_enum), 253 { }, 254 }; 255 256 #define AD5380_CHANNEL(_bits) { \ 257 .type = IIO_VOLTAGE, \ 258 .indexed = 1, \ 259 .output = 1, \ 260 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW) | \ 261 BIT(IIO_CHAN_INFO_CALIBSCALE) | \ 262 BIT(IIO_CHAN_INFO_CALIBBIAS), \ 263 .info_mask_shared_by_type = BIT(IIO_CHAN_INFO_SCALE), \ 264 .scan_type = { \ 265 .sign = 'u', \ 266 .realbits = (_bits), \ 267 .storagebits = 16, \ 268 .shift = 14 - (_bits), \ 269 }, \ 270 .ext_info = ad5380_ext_info, \ 271 } 272 273 static const struct ad5380_chip_info ad5380_chip_info_tbl[] = { 274 [ID_AD5380_3] = { 275 .channel_template = AD5380_CHANNEL(14), 276 .num_channels = 40, 277 .int_vref = 1250, 278 }, 279 [ID_AD5380_5] = { 280 .channel_template = AD5380_CHANNEL(14), 281 .num_channels = 40, 282 .int_vref = 2500, 283 }, 284 [ID_AD5381_3] = { 285 .channel_template = AD5380_CHANNEL(12), 286 .num_channels = 16, 287 .int_vref = 1250, 288 }, 289 [ID_AD5381_5] = { 290 .channel_template = AD5380_CHANNEL(12), 291 .num_channels = 16, 292 .int_vref = 2500, 293 }, 294 [ID_AD5382_3] = { 295 .channel_template = AD5380_CHANNEL(14), 296 .num_channels = 32, 297 .int_vref = 1250, 298 }, 299 [ID_AD5382_5] = { 300 .channel_template = AD5380_CHANNEL(14), 301 .num_channels = 32, 302 .int_vref = 2500, 303 }, 304 [ID_AD5383_3] = { 305 .channel_template = AD5380_CHANNEL(12), 306 .num_channels = 32, 307 .int_vref = 1250, 308 }, 309 [ID_AD5383_5] = { 310 .channel_template = AD5380_CHANNEL(12), 311 .num_channels = 32, 312 .int_vref = 2500, 313 }, 314 [ID_AD5390_3] = { 315 .channel_template = AD5380_CHANNEL(14), 316 .num_channels = 16, 317 .int_vref = 1250, 318 }, 319 [ID_AD5390_5] = { 320 .channel_template = AD5380_CHANNEL(14), 321 .num_channels = 16, 322 .int_vref = 2500, 323 }, 324 [ID_AD5391_3] = { 325 .channel_template = AD5380_CHANNEL(12), 326 .num_channels = 16, 327 .int_vref = 1250, 328 }, 329 [ID_AD5391_5] = { 330 .channel_template = AD5380_CHANNEL(12), 331 .num_channels = 16, 332 .int_vref = 2500, 333 }, 334 [ID_AD5392_3] = { 335 .channel_template = AD5380_CHANNEL(14), 336 .num_channels = 8, 337 .int_vref = 1250, 338 }, 339 [ID_AD5392_5] = { 340 .channel_template = AD5380_CHANNEL(14), 341 .num_channels = 8, 342 .int_vref = 2500, 343 }, 344 }; 345 346 static int ad5380_alloc_channels(struct iio_dev *indio_dev) 347 { 348 struct ad5380_state *st = iio_priv(indio_dev); 349 struct iio_chan_spec *channels; 350 unsigned int i; 351 352 channels = kcalloc(st->chip_info->num_channels, 353 sizeof(struct iio_chan_spec), GFP_KERNEL); 354 355 if (!channels) 356 return -ENOMEM; 357 358 for (i = 0; i < st->chip_info->num_channels; ++i) { 359 channels[i] = st->chip_info->channel_template; 360 channels[i].channel = i; 361 channels[i].address = i; 362 } 363 364 indio_dev->channels = channels; 365 366 return 0; 367 } 368 369 static int ad5380_probe(struct device *dev, struct regmap *regmap, 370 enum ad5380_type type, const char *name) 371 { 372 struct iio_dev *indio_dev; 373 struct ad5380_state *st; 374 unsigned int ctrl = 0; 375 int ret; 376 377 indio_dev = devm_iio_device_alloc(dev, sizeof(*st)); 378 if (indio_dev == NULL) { 379 dev_err(dev, "Failed to allocate iio device\n"); 380 return -ENOMEM; 381 } 382 383 st = iio_priv(indio_dev); 384 dev_set_drvdata(dev, indio_dev); 385 386 st->chip_info = &ad5380_chip_info_tbl[type]; 387 st->regmap = regmap; 388 389 indio_dev->name = name; 390 indio_dev->info = &ad5380_info; 391 indio_dev->modes = INDIO_DIRECT_MODE; 392 indio_dev->num_channels = st->chip_info->num_channels; 393 394 mutex_init(&st->lock); 395 396 ret = ad5380_alloc_channels(indio_dev); 397 if (ret) { 398 dev_err(dev, "Failed to allocate channel spec: %d\n", ret); 399 return ret; 400 } 401 402 if (st->chip_info->int_vref == 2500) 403 ctrl |= AD5380_CTRL_INT_VREF_2V5; 404 405 st->vref_reg = devm_regulator_get(dev, "vref"); 406 if (!IS_ERR(st->vref_reg)) { 407 ret = regulator_enable(st->vref_reg); 408 if (ret) { 409 dev_err(dev, "Failed to enable vref regulators: %d\n", 410 ret); 411 goto error_free_reg; 412 } 413 414 ret = regulator_get_voltage(st->vref_reg); 415 if (ret < 0) 416 goto error_disable_reg; 417 418 st->vref = ret / 1000; 419 } else { 420 st->vref = st->chip_info->int_vref; 421 ctrl |= AD5380_CTRL_INT_VREF_EN; 422 } 423 424 ret = regmap_write(st->regmap, AD5380_REG_SF_CTRL, ctrl); 425 if (ret) { 426 dev_err(dev, "Failed to write to device: %d\n", ret); 427 goto error_disable_reg; 428 } 429 430 ret = iio_device_register(indio_dev); 431 if (ret) { 432 dev_err(dev, "Failed to register iio device: %d\n", ret); 433 goto error_disable_reg; 434 } 435 436 return 0; 437 438 error_disable_reg: 439 if (!IS_ERR(st->vref_reg)) 440 regulator_disable(st->vref_reg); 441 error_free_reg: 442 kfree(indio_dev->channels); 443 444 return ret; 445 } 446 447 static void ad5380_remove(struct device *dev) 448 { 449 struct iio_dev *indio_dev = dev_get_drvdata(dev); 450 struct ad5380_state *st = iio_priv(indio_dev); 451 452 iio_device_unregister(indio_dev); 453 454 kfree(indio_dev->channels); 455 456 if (!IS_ERR(st->vref_reg)) 457 regulator_disable(st->vref_reg); 458 } 459 460 static bool ad5380_reg_false(struct device *dev, unsigned int reg) 461 { 462 return false; 463 } 464 465 static const struct regmap_config ad5380_regmap_config = { 466 .reg_bits = 10, 467 .val_bits = 14, 468 469 .max_register = AD5380_REG_DATA(40), 470 .cache_type = REGCACHE_RBTREE, 471 472 .volatile_reg = ad5380_reg_false, 473 .readable_reg = ad5380_reg_false, 474 }; 475 476 #if IS_ENABLED(CONFIG_SPI_MASTER) 477 478 static int ad5380_spi_probe(struct spi_device *spi) 479 { 480 const struct spi_device_id *id = spi_get_device_id(spi); 481 struct regmap *regmap; 482 483 regmap = devm_regmap_init_spi(spi, &ad5380_regmap_config); 484 485 if (IS_ERR(regmap)) 486 return PTR_ERR(regmap); 487 488 return ad5380_probe(&spi->dev, regmap, id->driver_data, id->name); 489 } 490 491 static int ad5380_spi_remove(struct spi_device *spi) 492 { 493 ad5380_remove(&spi->dev); 494 495 return 0; 496 } 497 498 static const struct spi_device_id ad5380_spi_ids[] = { 499 { "ad5380-3", ID_AD5380_3 }, 500 { "ad5380-5", ID_AD5380_5 }, 501 { "ad5381-3", ID_AD5381_3 }, 502 { "ad5381-5", ID_AD5381_5 }, 503 { "ad5382-3", ID_AD5382_3 }, 504 { "ad5382-5", ID_AD5382_5 }, 505 { "ad5383-3", ID_AD5383_3 }, 506 { "ad5383-5", ID_AD5383_5 }, 507 { "ad5384-3", ID_AD5380_3 }, 508 { "ad5384-5", ID_AD5380_5 }, 509 { "ad5390-3", ID_AD5390_3 }, 510 { "ad5390-5", ID_AD5390_5 }, 511 { "ad5391-3", ID_AD5391_3 }, 512 { "ad5391-5", ID_AD5391_5 }, 513 { "ad5392-3", ID_AD5392_3 }, 514 { "ad5392-5", ID_AD5392_5 }, 515 { } 516 }; 517 MODULE_DEVICE_TABLE(spi, ad5380_spi_ids); 518 519 static struct spi_driver ad5380_spi_driver = { 520 .driver = { 521 .name = "ad5380", 522 }, 523 .probe = ad5380_spi_probe, 524 .remove = ad5380_spi_remove, 525 .id_table = ad5380_spi_ids, 526 }; 527 528 static inline int ad5380_spi_register_driver(void) 529 { 530 return spi_register_driver(&ad5380_spi_driver); 531 } 532 533 static inline void ad5380_spi_unregister_driver(void) 534 { 535 spi_unregister_driver(&ad5380_spi_driver); 536 } 537 538 #else 539 540 static inline int ad5380_spi_register_driver(void) 541 { 542 return 0; 543 } 544 545 static inline void ad5380_spi_unregister_driver(void) 546 { 547 } 548 549 #endif 550 551 #if IS_ENABLED(CONFIG_I2C) 552 553 static int ad5380_i2c_probe(struct i2c_client *i2c, 554 const struct i2c_device_id *id) 555 { 556 struct regmap *regmap; 557 558 regmap = devm_regmap_init_i2c(i2c, &ad5380_regmap_config); 559 560 if (IS_ERR(regmap)) 561 return PTR_ERR(regmap); 562 563 return ad5380_probe(&i2c->dev, regmap, id->driver_data, id->name); 564 } 565 566 static int ad5380_i2c_remove(struct i2c_client *i2c) 567 { 568 ad5380_remove(&i2c->dev); 569 570 return 0; 571 } 572 573 static const struct i2c_device_id ad5380_i2c_ids[] = { 574 { "ad5380-3", ID_AD5380_3 }, 575 { "ad5380-5", ID_AD5380_5 }, 576 { "ad5381-3", ID_AD5381_3 }, 577 { "ad5381-5", ID_AD5381_5 }, 578 { "ad5382-3", ID_AD5382_3 }, 579 { "ad5382-5", ID_AD5382_5 }, 580 { "ad5383-3", ID_AD5383_3 }, 581 { "ad5383-5", ID_AD5383_5 }, 582 { "ad5384-3", ID_AD5380_3 }, 583 { "ad5384-5", ID_AD5380_5 }, 584 { "ad5390-3", ID_AD5390_3 }, 585 { "ad5390-5", ID_AD5390_5 }, 586 { "ad5391-3", ID_AD5391_3 }, 587 { "ad5391-5", ID_AD5391_5 }, 588 { "ad5392-3", ID_AD5392_3 }, 589 { "ad5392-5", ID_AD5392_5 }, 590 { } 591 }; 592 MODULE_DEVICE_TABLE(i2c, ad5380_i2c_ids); 593 594 static struct i2c_driver ad5380_i2c_driver = { 595 .driver = { 596 .name = "ad5380", 597 }, 598 .probe = ad5380_i2c_probe, 599 .remove = ad5380_i2c_remove, 600 .id_table = ad5380_i2c_ids, 601 }; 602 603 static inline int ad5380_i2c_register_driver(void) 604 { 605 return i2c_add_driver(&ad5380_i2c_driver); 606 } 607 608 static inline void ad5380_i2c_unregister_driver(void) 609 { 610 i2c_del_driver(&ad5380_i2c_driver); 611 } 612 613 #else 614 615 static inline int ad5380_i2c_register_driver(void) 616 { 617 return 0; 618 } 619 620 static inline void ad5380_i2c_unregister_driver(void) 621 { 622 } 623 624 #endif 625 626 static int __init ad5380_spi_init(void) 627 { 628 int ret; 629 630 ret = ad5380_spi_register_driver(); 631 if (ret) 632 return ret; 633 634 ret = ad5380_i2c_register_driver(); 635 if (ret) { 636 ad5380_spi_unregister_driver(); 637 return ret; 638 } 639 640 return 0; 641 } 642 module_init(ad5380_spi_init); 643 644 static void __exit ad5380_spi_exit(void) 645 { 646 ad5380_i2c_unregister_driver(); 647 ad5380_spi_unregister_driver(); 648 649 } 650 module_exit(ad5380_spi_exit); 651 652 MODULE_AUTHOR("Lars-Peter Clausen <lars@metafoo.de>"); 653 MODULE_DESCRIPTION("Analog Devices AD5380/81/82/83/84/90/91/92 DAC"); 654 MODULE_LICENSE("GPL v2"); 655