1 // SPDX-License-Identifier: GPL-2.0 2 /* 3 * LTC2664 4 channel, 12-/16-Bit Voltage Output SoftSpan DAC driver 4 * LTC2672 5 channel, 12-/16-Bit Current Output Softspan DAC driver 5 * 6 * Copyright 2024 Analog Devices Inc. 7 */ 8 9 #include <linux/bitfield.h> 10 #include <linux/cleanup.h> 11 #include <linux/device.h> 12 #include <linux/gpio/consumer.h> 13 #include <linux/iio/iio.h> 14 #include <linux/kernel.h> 15 #include <linux/math64.h> 16 #include <linux/module.h> 17 #include <linux/mutex.h> 18 #include <linux/property.h> 19 #include <linux/regmap.h> 20 #include <linux/regulator/consumer.h> 21 #include <linux/spi/spi.h> 22 23 #define LTC2664_CMD_WRITE_N(n) (0x00 + (n)) 24 #define LTC2664_CMD_UPDATE_N(n) (0x10 + (n)) 25 #define LTC2664_CMD_WRITE_N_UPDATE_ALL 0x20 26 #define LTC2664_CMD_WRITE_N_UPDATE_N(n) (0x30 + (n)) 27 #define LTC2664_CMD_POWER_DOWN_N(n) (0x40 + (n)) 28 #define LTC2664_CMD_POWER_DOWN_ALL 0x50 29 #define LTC2664_CMD_SPAN_N(n) (0x60 + (n)) 30 #define LTC2664_CMD_CONFIG 0x70 31 #define LTC2664_CMD_MUX 0xB0 32 #define LTC2664_CMD_TOGGLE_SEL 0xC0 33 #define LTC2664_CMD_GLOBAL_TOGGLE 0xD0 34 #define LTC2664_CMD_NO_OPERATION 0xF0 35 #define LTC2664_REF_DISABLE 0x0001 36 #define LTC2664_MSPAN_SOFTSPAN 7 37 38 #define LTC2672_MAX_CHANNEL 5 39 #define LTC2672_MAX_SPAN 7 40 #define LTC2672_SCALE_MULTIPLIER(n) (50 * BIT(n)) 41 42 enum { 43 LTC2664_SPAN_RANGE_0V_5V, 44 LTC2664_SPAN_RANGE_0V_10V, 45 LTC2664_SPAN_RANGE_M5V_5V, 46 LTC2664_SPAN_RANGE_M10V_10V, 47 LTC2664_SPAN_RANGE_M2V5_2V5, 48 }; 49 50 enum { 51 LTC2664_INPUT_A, 52 LTC2664_INPUT_B, 53 LTC2664_INPUT_B_AVAIL, 54 LTC2664_POWERDOWN, 55 LTC2664_POWERDOWN_MODE, 56 LTC2664_TOGGLE_EN, 57 LTC2664_GLOBAL_TOGGLE, 58 }; 59 60 static const u16 ltc2664_mspan_lut[8][2] = { 61 { LTC2664_SPAN_RANGE_M10V_10V, 32768 }, /* MPS2=0, MPS1=0, MSP0=0 (0)*/ 62 { LTC2664_SPAN_RANGE_M5V_5V, 32768 }, /* MPS2=0, MPS1=0, MSP0=1 (1)*/ 63 { LTC2664_SPAN_RANGE_M2V5_2V5, 32768 }, /* MPS2=0, MPS1=1, MSP0=0 (2)*/ 64 { LTC2664_SPAN_RANGE_0V_10V, 0 }, /* MPS2=0, MPS1=1, MSP0=1 (3)*/ 65 { LTC2664_SPAN_RANGE_0V_10V, 32768 }, /* MPS2=1, MPS1=0, MSP0=0 (4)*/ 66 { LTC2664_SPAN_RANGE_0V_5V, 0 }, /* MPS2=1, MPS1=0, MSP0=1 (5)*/ 67 { LTC2664_SPAN_RANGE_0V_5V, 32768 }, /* MPS2=1, MPS1=1, MSP0=0 (6)*/ 68 { LTC2664_SPAN_RANGE_0V_5V, 0 } /* MPS2=1, MPS1=1, MSP0=1 (7)*/ 69 }; 70 71 struct ltc2664_state; 72 73 struct ltc2664_chip_info { 74 const char *name; 75 int (*scale_get)(const struct ltc2664_state *st, int c); 76 int (*offset_get)(const struct ltc2664_state *st, int c); 77 int measurement_type; 78 unsigned int num_channels; 79 const int (*span_helper)[2]; 80 unsigned int num_span; 81 unsigned int internal_vref_mv; 82 bool manual_span_support; 83 bool rfsadj_support; 84 }; 85 86 struct ltc2664_chan { 87 /* indicates if the channel should be toggled */ 88 bool toggle_chan; 89 /* indicates if the channel is in powered down state */ 90 bool powerdown; 91 /* span code of the channel */ 92 u8 span; 93 /* raw data of the current state of the chip registers (A/B) */ 94 u16 raw[2]; 95 }; 96 97 struct ltc2664_state { 98 struct spi_device *spi; 99 struct regmap *regmap; 100 struct ltc2664_chan channels[LTC2672_MAX_CHANNEL]; 101 /* lock to protect against multiple access to the device and shared data */ 102 struct mutex lock; 103 const struct ltc2664_chip_info *chip_info; 104 struct iio_chan_spec *iio_channels; 105 int vref_mv; 106 u32 rfsadj_ohms; 107 u32 toggle_sel; 108 bool global_toggle; 109 }; 110 111 static const int ltc2664_span_helper[][2] = { 112 { 0, 5000 }, 113 { 0, 10000 }, 114 { -5000, 5000 }, 115 { -10000, 10000 }, 116 { -2500, 2500 }, 117 }; 118 119 static const int ltc2672_span_helper[][2] = { 120 { 0, 0 }, 121 { 0, 3125 }, 122 { 0, 6250 }, 123 { 0, 12500 }, 124 { 0, 25000 }, 125 { 0, 50000 }, 126 { 0, 100000 }, 127 { 0, 200000 }, 128 { 0, 300000 }, 129 }; 130 131 static int ltc2664_scale_get(const struct ltc2664_state *st, int c) 132 { 133 const struct ltc2664_chan *chan = &st->channels[c]; 134 const int (*span_helper)[2] = st->chip_info->span_helper; 135 int span, fs; 136 137 span = chan->span; 138 if (span < 0) 139 return span; 140 141 fs = span_helper[span][1] - span_helper[span][0]; 142 143 return fs * st->vref_mv / 2500; 144 } 145 146 static int ltc2672_scale_get(const struct ltc2664_state *st, int c) 147 { 148 const struct ltc2664_chan *chan = &st->channels[c]; 149 int span, fs; 150 151 span = chan->span - 1; 152 if (span < 0) 153 return span; 154 155 fs = 1000 * st->vref_mv; 156 157 if (span == LTC2672_MAX_SPAN) 158 return mul_u64_u32_div(4800, fs, st->rfsadj_ohms); 159 160 return mul_u64_u32_div(LTC2672_SCALE_MULTIPLIER(span), fs, st->rfsadj_ohms); 161 } 162 163 static int ltc2664_offset_get(const struct ltc2664_state *st, int c) 164 { 165 const struct ltc2664_chan *chan = &st->channels[c]; 166 int span; 167 168 span = chan->span; 169 if (span < 0) 170 return span; 171 172 if (st->chip_info->span_helper[span][0] < 0) 173 return -32768; 174 175 return 0; 176 } 177 178 static int ltc2664_dac_code_write(struct ltc2664_state *st, u32 chan, u32 input, 179 u16 code) 180 { 181 struct ltc2664_chan *c = &st->channels[chan]; 182 int ret, reg; 183 184 guard(mutex)(&st->lock); 185 /* select the correct input register to write to */ 186 if (c->toggle_chan) { 187 ret = regmap_write(st->regmap, LTC2664_CMD_TOGGLE_SEL, 188 input << chan); 189 if (ret) 190 return ret; 191 } 192 /* 193 * If in toggle mode the dac should be updated by an 194 * external signal (or sw toggle) and not here. 195 */ 196 if (st->toggle_sel & BIT(chan)) 197 reg = LTC2664_CMD_WRITE_N(chan); 198 else 199 reg = LTC2664_CMD_WRITE_N_UPDATE_N(chan); 200 201 ret = regmap_write(st->regmap, reg, code); 202 if (ret) 203 return ret; 204 205 c->raw[input] = code; 206 207 if (c->toggle_chan) { 208 ret = regmap_write(st->regmap, LTC2664_CMD_TOGGLE_SEL, 209 st->toggle_sel); 210 if (ret) 211 return ret; 212 } 213 214 return 0; 215 } 216 217 static void ltc2664_dac_code_read(struct ltc2664_state *st, u32 chan, u32 input, 218 u32 *code) 219 { 220 guard(mutex)(&st->lock); 221 *code = st->channels[chan].raw[input]; 222 } 223 224 static const int ltc2664_raw_range[] = { 0, 1, U16_MAX }; 225 226 static int ltc2664_read_avail(struct iio_dev *indio_dev, 227 struct iio_chan_spec const *chan, 228 const int **vals, int *type, int *length, 229 long info) 230 { 231 switch (info) { 232 case IIO_CHAN_INFO_RAW: 233 *vals = ltc2664_raw_range; 234 *type = IIO_VAL_INT; 235 236 return IIO_AVAIL_RANGE; 237 default: 238 return -EINVAL; 239 } 240 } 241 242 static int ltc2664_read_raw(struct iio_dev *indio_dev, 243 struct iio_chan_spec const *chan, int *val, 244 int *val2, long info) 245 { 246 struct ltc2664_state *st = iio_priv(indio_dev); 247 248 switch (info) { 249 case IIO_CHAN_INFO_RAW: 250 ltc2664_dac_code_read(st, chan->channel, LTC2664_INPUT_A, val); 251 252 return IIO_VAL_INT; 253 case IIO_CHAN_INFO_OFFSET: 254 *val = st->chip_info->offset_get(st, chan->channel); 255 256 return IIO_VAL_INT; 257 case IIO_CHAN_INFO_SCALE: 258 *val = st->chip_info->scale_get(st, chan->channel); 259 260 *val2 = 16; 261 return IIO_VAL_FRACTIONAL_LOG2; 262 default: 263 return -EINVAL; 264 } 265 } 266 267 static int ltc2664_write_raw(struct iio_dev *indio_dev, 268 struct iio_chan_spec const *chan, int val, 269 int val2, long info) 270 { 271 struct ltc2664_state *st = iio_priv(indio_dev); 272 273 switch (info) { 274 case IIO_CHAN_INFO_RAW: 275 if (val > U16_MAX || val < 0) 276 return -EINVAL; 277 278 return ltc2664_dac_code_write(st, chan->channel, 279 LTC2664_INPUT_A, val); 280 default: 281 return -EINVAL; 282 } 283 } 284 285 static ssize_t ltc2664_reg_bool_get(struct iio_dev *indio_dev, 286 uintptr_t private, 287 const struct iio_chan_spec *chan, 288 char *buf) 289 { 290 struct ltc2664_state *st = iio_priv(indio_dev); 291 u32 val; 292 293 guard(mutex)(&st->lock); 294 switch (private) { 295 case LTC2664_POWERDOWN: 296 val = st->channels[chan->channel].powerdown; 297 298 return sysfs_emit(buf, "%u\n", val); 299 case LTC2664_POWERDOWN_MODE: 300 return sysfs_emit(buf, "42kohm_to_gnd\n"); 301 case LTC2664_TOGGLE_EN: 302 val = !!(st->toggle_sel & BIT(chan->channel)); 303 304 return sysfs_emit(buf, "%u\n", val); 305 case LTC2664_GLOBAL_TOGGLE: 306 val = st->global_toggle; 307 308 return sysfs_emit(buf, "%u\n", val); 309 default: 310 return -EINVAL; 311 } 312 } 313 314 static ssize_t ltc2664_reg_bool_set(struct iio_dev *indio_dev, 315 uintptr_t private, 316 const struct iio_chan_spec *chan, 317 const char *buf, size_t len) 318 { 319 struct ltc2664_state *st = iio_priv(indio_dev); 320 int ret; 321 bool en; 322 323 ret = kstrtobool(buf, &en); 324 if (ret) 325 return ret; 326 327 guard(mutex)(&st->lock); 328 switch (private) { 329 case LTC2664_POWERDOWN: 330 ret = regmap_write(st->regmap, 331 en ? LTC2664_CMD_POWER_DOWN_N(chan->channel) : 332 LTC2664_CMD_UPDATE_N(chan->channel), en); 333 if (ret) 334 return ret; 335 336 st->channels[chan->channel].powerdown = en; 337 338 return len; 339 case LTC2664_TOGGLE_EN: 340 if (en) 341 st->toggle_sel |= BIT(chan->channel); 342 else 343 st->toggle_sel &= ~BIT(chan->channel); 344 345 ret = regmap_write(st->regmap, LTC2664_CMD_TOGGLE_SEL, 346 st->toggle_sel); 347 if (ret) 348 return ret; 349 350 return len; 351 case LTC2664_GLOBAL_TOGGLE: 352 ret = regmap_write(st->regmap, LTC2664_CMD_GLOBAL_TOGGLE, en); 353 if (ret) 354 return ret; 355 356 st->global_toggle = en; 357 358 return len; 359 default: 360 return -EINVAL; 361 } 362 } 363 364 static ssize_t ltc2664_dac_input_read(struct iio_dev *indio_dev, 365 uintptr_t private, 366 const struct iio_chan_spec *chan, 367 char *buf) 368 { 369 struct ltc2664_state *st = iio_priv(indio_dev); 370 u32 val; 371 372 if (private == LTC2664_INPUT_B_AVAIL) 373 return sysfs_emit(buf, "[%u %u %u]\n", ltc2664_raw_range[0], 374 ltc2664_raw_range[1], 375 ltc2664_raw_range[2] / 4); 376 377 ltc2664_dac_code_read(st, chan->channel, private, &val); 378 379 return sysfs_emit(buf, "%u\n", val); 380 } 381 382 static ssize_t ltc2664_dac_input_write(struct iio_dev *indio_dev, 383 uintptr_t private, 384 const struct iio_chan_spec *chan, 385 const char *buf, size_t len) 386 { 387 struct ltc2664_state *st = iio_priv(indio_dev); 388 int ret; 389 u16 val; 390 391 if (private == LTC2664_INPUT_B_AVAIL) 392 return -EINVAL; 393 394 ret = kstrtou16(buf, 10, &val); 395 if (ret) 396 return ret; 397 398 ret = ltc2664_dac_code_write(st, chan->channel, private, val); 399 if (ret) 400 return ret; 401 402 return len; 403 } 404 405 static int ltc2664_reg_access(struct iio_dev *indio_dev, 406 unsigned int reg, 407 unsigned int writeval, 408 unsigned int *readval) 409 { 410 struct ltc2664_state *st = iio_priv(indio_dev); 411 412 if (readval) 413 return -EOPNOTSUPP; 414 415 return regmap_write(st->regmap, reg, writeval); 416 } 417 418 #define LTC2664_CHAN_EXT_INFO(_name, _what, _shared, _read, _write) { \ 419 .name = _name, \ 420 .read = (_read), \ 421 .write = (_write), \ 422 .private = (_what), \ 423 .shared = (_shared), \ 424 } 425 426 /* 427 * For toggle mode we only expose the symbol attr (sw_toggle) in case a TGPx is 428 * not provided in dts. 429 */ 430 static const struct iio_chan_spec_ext_info ltc2664_toggle_sym_ext_info[] = { 431 LTC2664_CHAN_EXT_INFO("raw0", LTC2664_INPUT_A, IIO_SEPARATE, 432 ltc2664_dac_input_read, ltc2664_dac_input_write), 433 LTC2664_CHAN_EXT_INFO("raw1", LTC2664_INPUT_B, IIO_SEPARATE, 434 ltc2664_dac_input_read, ltc2664_dac_input_write), 435 LTC2664_CHAN_EXT_INFO("powerdown", LTC2664_POWERDOWN, IIO_SEPARATE, 436 ltc2664_reg_bool_get, ltc2664_reg_bool_set), 437 LTC2664_CHAN_EXT_INFO("powerdown_mode", LTC2664_POWERDOWN_MODE, 438 IIO_SEPARATE, ltc2664_reg_bool_get, NULL), 439 LTC2664_CHAN_EXT_INFO("symbol", LTC2664_GLOBAL_TOGGLE, IIO_SEPARATE, 440 ltc2664_reg_bool_get, ltc2664_reg_bool_set), 441 LTC2664_CHAN_EXT_INFO("toggle_en", LTC2664_TOGGLE_EN, 442 IIO_SEPARATE, ltc2664_reg_bool_get, 443 ltc2664_reg_bool_set), 444 { } 445 }; 446 447 static const struct iio_chan_spec_ext_info ltc2664_ext_info[] = { 448 LTC2664_CHAN_EXT_INFO("powerdown", LTC2664_POWERDOWN, IIO_SEPARATE, 449 ltc2664_reg_bool_get, ltc2664_reg_bool_set), 450 LTC2664_CHAN_EXT_INFO("powerdown_mode", LTC2664_POWERDOWN_MODE, 451 IIO_SEPARATE, ltc2664_reg_bool_get, NULL), 452 { } 453 }; 454 455 static const struct iio_chan_spec ltc2664_channel_template = { 456 .indexed = 1, 457 .output = 1, 458 .info_mask_separate = BIT(IIO_CHAN_INFO_SCALE) | 459 BIT(IIO_CHAN_INFO_OFFSET) | 460 BIT(IIO_CHAN_INFO_RAW), 461 .info_mask_separate_available = BIT(IIO_CHAN_INFO_RAW), 462 .ext_info = ltc2664_ext_info, 463 }; 464 465 static const struct ltc2664_chip_info ltc2664_chip = { 466 .name = "ltc2664", 467 .scale_get = ltc2664_scale_get, 468 .offset_get = ltc2664_offset_get, 469 .measurement_type = IIO_VOLTAGE, 470 .num_channels = 4, 471 .span_helper = ltc2664_span_helper, 472 .num_span = ARRAY_SIZE(ltc2664_span_helper), 473 .internal_vref_mv = 2500, 474 .manual_span_support = true, 475 .rfsadj_support = false, 476 }; 477 478 static const struct ltc2664_chip_info ltc2672_chip = { 479 .name = "ltc2672", 480 .scale_get = ltc2672_scale_get, 481 .offset_get = ltc2664_offset_get, 482 .measurement_type = IIO_CURRENT, 483 .num_channels = 5, 484 .span_helper = ltc2672_span_helper, 485 .num_span = ARRAY_SIZE(ltc2672_span_helper), 486 .internal_vref_mv = 1250, 487 .manual_span_support = false, 488 .rfsadj_support = true, 489 }; 490 491 static int ltc2664_set_span(const struct ltc2664_state *st, int min, int max, 492 int chan) 493 { 494 const struct ltc2664_chip_info *chip_info = st->chip_info; 495 const int (*span_helper)[2] = chip_info->span_helper; 496 int span, ret; 497 498 for (span = 0; span < chip_info->num_span; span++) { 499 if (min == span_helper[span][0] && max == span_helper[span][1]) 500 break; 501 } 502 503 if (span == chip_info->num_span) 504 return -EINVAL; 505 506 ret = regmap_write(st->regmap, LTC2664_CMD_SPAN_N(chan), span); 507 if (ret) 508 return ret; 509 510 return span; 511 } 512 513 static int ltc2664_channel_config(struct ltc2664_state *st) 514 { 515 const struct ltc2664_chip_info *chip_info = st->chip_info; 516 struct device *dev = &st->spi->dev; 517 u32 reg, tmp[2], mspan; 518 int ret; 519 520 mspan = LTC2664_MSPAN_SOFTSPAN; 521 ret = device_property_read_u32(dev, "adi,manual-span-operation-config", 522 &mspan); 523 if (!ret) { 524 if (!chip_info->manual_span_support) 525 return dev_err_probe(dev, -EINVAL, 526 "adi,manual-span-operation-config not supported\n"); 527 528 if (mspan >= ARRAY_SIZE(ltc2664_mspan_lut)) 529 return dev_err_probe(dev, -EINVAL, 530 "adi,manual-span-operation-config not in range\n"); 531 } 532 533 st->rfsadj_ohms = 20000; 534 ret = device_property_read_u32(dev, "adi,rfsadj-ohms", &st->rfsadj_ohms); 535 if (!ret) { 536 if (!chip_info->rfsadj_support) 537 return dev_err_probe(dev, -EINVAL, 538 "adi,rfsadj-ohms not supported\n"); 539 540 if (st->rfsadj_ohms < 19000 || st->rfsadj_ohms > 41000) 541 return dev_err_probe(dev, -EINVAL, 542 "adi,rfsadj-ohms not in range\n"); 543 } 544 545 device_for_each_child_node_scoped(dev, child) { 546 struct ltc2664_chan *chan; 547 548 ret = fwnode_property_read_u32(child, "reg", ®); 549 if (ret) 550 return dev_err_probe(dev, ret, 551 "Failed to get reg property\n"); 552 553 if (reg >= chip_info->num_channels) 554 return dev_err_probe(dev, -EINVAL, 555 "reg bigger than: %d\n", 556 chip_info->num_channels); 557 558 chan = &st->channels[reg]; 559 560 if (fwnode_property_read_bool(child, "adi,toggle-mode")) { 561 chan->toggle_chan = true; 562 /* assume sw toggle ABI */ 563 st->iio_channels[reg].ext_info = ltc2664_toggle_sym_ext_info; 564 565 /* 566 * Clear IIO_CHAN_INFO_RAW bit as toggle channels expose 567 * out_voltage/current_raw{0|1} files. 568 */ 569 __clear_bit(IIO_CHAN_INFO_RAW, 570 &st->iio_channels[reg].info_mask_separate); 571 } 572 573 chan->raw[0] = ltc2664_mspan_lut[mspan][1]; 574 chan->raw[1] = ltc2664_mspan_lut[mspan][1]; 575 576 chan->span = ltc2664_mspan_lut[mspan][0]; 577 578 ret = fwnode_property_read_u32_array(child, "output-range-microvolt", 579 tmp, ARRAY_SIZE(tmp)); 580 if (!ret && mspan == LTC2664_MSPAN_SOFTSPAN) { 581 ret = ltc2664_set_span(st, tmp[0] / 1000, tmp[1] / 1000, reg); 582 if (ret < 0) 583 return dev_err_probe(dev, ret, 584 "Failed to set span\n"); 585 chan->span = ret; 586 } 587 588 ret = fwnode_property_read_u32_array(child, "output-range-microamp", 589 tmp, ARRAY_SIZE(tmp)); 590 if (!ret) { 591 ret = ltc2664_set_span(st, 0, tmp[1] / 1000, reg); 592 if (ret < 0) 593 return dev_err_probe(dev, ret, 594 "Failed to set span\n"); 595 chan->span = ret; 596 } 597 } 598 599 return 0; 600 } 601 602 static int ltc2664_setup(struct ltc2664_state *st) 603 { 604 const struct ltc2664_chip_info *chip_info = st->chip_info; 605 struct gpio_desc *gpio; 606 int ret, i; 607 608 /* If we have a clr/reset pin, use that to reset the chip. */ 609 gpio = devm_gpiod_get_optional(&st->spi->dev, "reset", GPIOD_OUT_HIGH); 610 if (IS_ERR(gpio)) 611 return dev_err_probe(&st->spi->dev, PTR_ERR(gpio), 612 "Failed to get reset gpio"); 613 if (gpio) { 614 fsleep(1000); 615 gpiod_set_value_cansleep(gpio, 0); 616 } 617 618 /* 619 * Duplicate the default channel configuration as it can change during 620 * @ltc2664_channel_config() 621 */ 622 st->iio_channels = devm_kcalloc(&st->spi->dev, 623 chip_info->num_channels, 624 sizeof(struct iio_chan_spec), 625 GFP_KERNEL); 626 if (!st->iio_channels) 627 return -ENOMEM; 628 629 for (i = 0; i < chip_info->num_channels; i++) { 630 st->iio_channels[i] = ltc2664_channel_template; 631 st->iio_channels[i].type = chip_info->measurement_type; 632 st->iio_channels[i].channel = i; 633 } 634 635 ret = ltc2664_channel_config(st); 636 if (ret) 637 return ret; 638 639 return regmap_set_bits(st->regmap, LTC2664_CMD_CONFIG, LTC2664_REF_DISABLE); 640 } 641 642 static const struct regmap_config ltc2664_regmap_config = { 643 .reg_bits = 8, 644 .val_bits = 16, 645 .max_register = LTC2664_CMD_NO_OPERATION, 646 }; 647 648 static const struct iio_info ltc2664_info = { 649 .write_raw = ltc2664_write_raw, 650 .read_raw = ltc2664_read_raw, 651 .read_avail = ltc2664_read_avail, 652 .debugfs_reg_access = ltc2664_reg_access, 653 }; 654 655 static int ltc2664_probe(struct spi_device *spi) 656 { 657 static const char * const regulators[] = { "vcc", "iovcc", "v-neg" }; 658 const struct ltc2664_chip_info *chip_info; 659 struct device *dev = &spi->dev; 660 struct iio_dev *indio_dev; 661 struct ltc2664_state *st; 662 int ret; 663 664 indio_dev = devm_iio_device_alloc(dev, sizeof(*st)); 665 if (!indio_dev) 666 return -ENOMEM; 667 668 st = iio_priv(indio_dev); 669 st->spi = spi; 670 671 chip_info = spi_get_device_match_data(spi); 672 if (!chip_info) 673 return -ENODEV; 674 675 st->chip_info = chip_info; 676 677 ret = devm_mutex_init(dev, &st->lock); 678 if (ret) 679 return ret; 680 681 st->regmap = devm_regmap_init_spi(spi, <c2664_regmap_config); 682 if (IS_ERR(st->regmap)) 683 return dev_err_probe(dev, PTR_ERR(st->regmap), 684 "Failed to init regmap"); 685 686 ret = devm_regulator_bulk_get_enable(dev, ARRAY_SIZE(regulators), 687 regulators); 688 if (ret) 689 return dev_err_probe(dev, ret, "Failed to enable regulators\n"); 690 691 ret = devm_regulator_get_enable_read_voltage(dev, "ref"); 692 if (ret < 0 && ret != -ENODEV) 693 return ret; 694 695 st->vref_mv = ret > 0 ? ret / 1000 : chip_info->internal_vref_mv; 696 697 ret = ltc2664_setup(st); 698 if (ret) 699 return ret; 700 701 indio_dev->name = chip_info->name; 702 indio_dev->info = <c2664_info; 703 indio_dev->modes = INDIO_DIRECT_MODE; 704 indio_dev->channels = st->iio_channels; 705 indio_dev->num_channels = chip_info->num_channels; 706 707 return devm_iio_device_register(dev, indio_dev); 708 } 709 710 static const struct spi_device_id ltc2664_id[] = { 711 { .name = "ltc2664", .driver_data = (kernel_ulong_t)<c2664_chip }, 712 { .name = "ltc2672", .driver_data = (kernel_ulong_t)<c2672_chip }, 713 { } 714 }; 715 MODULE_DEVICE_TABLE(spi, ltc2664_id); 716 717 static const struct of_device_id ltc2664_of_id[] = { 718 { .compatible = "adi,ltc2664", .data = <c2664_chip }, 719 { .compatible = "adi,ltc2672", .data = <c2672_chip }, 720 { } 721 }; 722 MODULE_DEVICE_TABLE(of, ltc2664_of_id); 723 724 static struct spi_driver ltc2664_driver = { 725 .driver = { 726 .name = "ltc2664", 727 .of_match_table = ltc2664_of_id, 728 }, 729 .probe = ltc2664_probe, 730 .id_table = ltc2664_id, 731 }; 732 module_spi_driver(ltc2664_driver); 733 734 MODULE_AUTHOR("Michael Hennerich <michael.hennerich@analog.com>"); 735 MODULE_AUTHOR("Kim Seer Paller <kimseer.paller@analog.com>"); 736 MODULE_DESCRIPTION("Analog Devices LTC2664 and LTC2672 DAC"); 737 MODULE_LICENSE("GPL"); 738