1 // SPDX-License-Identifier: GPL-2.0+ 2 /* 3 * AD4000 SPI ADC driver 4 * 5 * Copyright 2024 Analog Devices Inc. 6 */ 7 #include <linux/bits.h> 8 #include <linux/bitfield.h> 9 #include <linux/byteorder/generic.h> 10 #include <linux/cleanup.h> 11 #include <linux/device.h> 12 #include <linux/err.h> 13 #include <linux/math.h> 14 #include <linux/module.h> 15 #include <linux/mod_devicetable.h> 16 #include <linux/gpio/consumer.h> 17 #include <linux/regulator/consumer.h> 18 #include <linux/spi/spi.h> 19 #include <linux/units.h> 20 #include <linux/util_macros.h> 21 #include <linux/iio/iio.h> 22 23 #include <linux/iio/buffer.h> 24 #include <linux/iio/triggered_buffer.h> 25 #include <linux/iio/trigger_consumer.h> 26 27 #define AD4000_READ_COMMAND 0x54 28 #define AD4000_WRITE_COMMAND 0x14 29 30 #define AD4000_CONFIG_REG_DEFAULT 0xE1 31 32 /* AD4000 Configuration Register programmable bits */ 33 #define AD4000_CFG_SPAN_COMP BIT(3) /* Input span compression */ 34 #define AD4000_CFG_HIGHZ BIT(2) /* High impedance mode */ 35 36 #define AD4000_SCALE_OPTIONS 2 37 38 #define __AD4000_DIFF_CHANNEL(_sign, _real_bits, _storage_bits, _reg_access) \ 39 { \ 40 .type = IIO_VOLTAGE, \ 41 .indexed = 1, \ 42 .differential = 1, \ 43 .channel = 0, \ 44 .channel2 = 1, \ 45 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW) | \ 46 BIT(IIO_CHAN_INFO_SCALE), \ 47 .info_mask_separate_available = _reg_access ? BIT(IIO_CHAN_INFO_SCALE) : 0,\ 48 .scan_index = 0, \ 49 .scan_type = { \ 50 .sign = _sign, \ 51 .realbits = _real_bits, \ 52 .storagebits = _storage_bits, \ 53 .shift = _storage_bits - _real_bits, \ 54 .endianness = IIO_BE, \ 55 }, \ 56 } 57 58 #define AD4000_DIFF_CHANNEL(_sign, _real_bits, _reg_access) \ 59 __AD4000_DIFF_CHANNEL((_sign), (_real_bits), \ 60 ((_real_bits) > 16 ? 32 : 16), (_reg_access)) 61 62 #define AD4000_DIFF_CHANNELS(_sign, _real_bits, _reg_access) \ 63 { \ 64 AD4000_DIFF_CHANNEL(_sign, _real_bits, _reg_access), \ 65 IIO_CHAN_SOFT_TIMESTAMP(1), \ 66 } 67 68 #define __AD4000_PSEUDO_DIFF_CHANNEL(_sign, _real_bits, _storage_bits, _reg_access)\ 69 { \ 70 .type = IIO_VOLTAGE, \ 71 .indexed = 1, \ 72 .channel = 0, \ 73 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW) | \ 74 BIT(IIO_CHAN_INFO_SCALE) | \ 75 BIT(IIO_CHAN_INFO_OFFSET), \ 76 .info_mask_separate_available = _reg_access ? BIT(IIO_CHAN_INFO_SCALE) : 0,\ 77 .scan_index = 0, \ 78 .scan_type = { \ 79 .sign = _sign, \ 80 .realbits = _real_bits, \ 81 .storagebits = _storage_bits, \ 82 .shift = _storage_bits - _real_bits, \ 83 .endianness = IIO_BE, \ 84 }, \ 85 } 86 87 #define AD4000_PSEUDO_DIFF_CHANNEL(_sign, _real_bits, _reg_access) \ 88 __AD4000_PSEUDO_DIFF_CHANNEL((_sign), (_real_bits), \ 89 ((_real_bits) > 16 ? 32 : 16), (_reg_access)) 90 91 #define AD4000_PSEUDO_DIFF_CHANNELS(_sign, _real_bits, _reg_access) \ 92 { \ 93 AD4000_PSEUDO_DIFF_CHANNEL(_sign, _real_bits, _reg_access), \ 94 IIO_CHAN_SOFT_TIMESTAMP(1), \ 95 } 96 97 static const char * const ad4000_power_supplies[] = { 98 "vdd", "vio" 99 }; 100 101 enum ad4000_sdi { 102 AD4000_SDI_MOSI, 103 AD4000_SDI_VIO, 104 AD4000_SDI_CS, 105 AD4000_SDI_GND, 106 }; 107 108 /* maps adi,sdi-pin property value to enum */ 109 static const char * const ad4000_sdi_pin[] = { 110 [AD4000_SDI_MOSI] = "sdi", 111 [AD4000_SDI_VIO] = "high", 112 [AD4000_SDI_CS] = "cs", 113 [AD4000_SDI_GND] = "low", 114 }; 115 116 /* Gains stored as fractions of 1000 so they can be expressed by integers. */ 117 static const int ad4000_gains[] = { 118 454, 909, 1000, 1900, 119 }; 120 121 struct ad4000_time_spec { 122 int t_conv_ns; 123 int t_quiet2_ns; 124 }; 125 126 /* 127 * Same timing specifications for all of AD4000, AD4001, ..., AD4008, AD4010, 128 * ADAQ4001, and ADAQ4003. 129 */ 130 static const struct ad4000_time_spec ad4000_t_spec = { 131 .t_conv_ns = 320, 132 .t_quiet2_ns = 60, 133 }; 134 135 /* AD4020, AD4021, AD4022 */ 136 static const struct ad4000_time_spec ad4020_t_spec = { 137 .t_conv_ns = 350, 138 .t_quiet2_ns = 60, 139 }; 140 141 /* AD7983, AD7984 */ 142 static const struct ad4000_time_spec ad7983_t_spec = { 143 .t_conv_ns = 500, 144 .t_quiet2_ns = 0, 145 }; 146 147 /* AD7980, AD7982 */ 148 static const struct ad4000_time_spec ad7980_t_spec = { 149 .t_conv_ns = 800, 150 .t_quiet2_ns = 0, 151 }; 152 153 /* AD7946, AD7686, AD7688, AD7988-5, AD7693 */ 154 static const struct ad4000_time_spec ad7686_t_spec = { 155 .t_conv_ns = 1600, 156 .t_quiet2_ns = 0, 157 }; 158 159 /* AD7690 */ 160 static const struct ad4000_time_spec ad7690_t_spec = { 161 .t_conv_ns = 2100, 162 .t_quiet2_ns = 0, 163 }; 164 165 /* AD7942, AD7685, AD7687 */ 166 static const struct ad4000_time_spec ad7687_t_spec = { 167 .t_conv_ns = 3200, 168 .t_quiet2_ns = 0, 169 }; 170 171 /* AD7691 */ 172 static const struct ad4000_time_spec ad7691_t_spec = { 173 .t_conv_ns = 3700, 174 .t_quiet2_ns = 0, 175 }; 176 177 /* AD7988-1 */ 178 static const struct ad4000_time_spec ad7988_1_t_spec = { 179 .t_conv_ns = 9500, 180 .t_quiet2_ns = 0, 181 }; 182 183 struct ad4000_chip_info { 184 const char *dev_name; 185 struct iio_chan_spec chan_spec[2]; 186 struct iio_chan_spec reg_access_chan_spec[2]; 187 const struct ad4000_time_spec *time_spec; 188 bool has_hardware_gain; 189 }; 190 191 static const struct ad4000_chip_info ad4000_chip_info = { 192 .dev_name = "ad4000", 193 .chan_spec = AD4000_PSEUDO_DIFF_CHANNELS('u', 16, 0), 194 .reg_access_chan_spec = AD4000_PSEUDO_DIFF_CHANNELS('u', 16, 1), 195 .time_spec = &ad4000_t_spec, 196 }; 197 198 static const struct ad4000_chip_info ad4001_chip_info = { 199 .dev_name = "ad4001", 200 .chan_spec = AD4000_DIFF_CHANNELS('s', 16, 0), 201 .reg_access_chan_spec = AD4000_DIFF_CHANNELS('s', 16, 1), 202 .time_spec = &ad4000_t_spec, 203 }; 204 205 static const struct ad4000_chip_info ad4002_chip_info = { 206 .dev_name = "ad4002", 207 .chan_spec = AD4000_PSEUDO_DIFF_CHANNELS('u', 18, 0), 208 .reg_access_chan_spec = AD4000_PSEUDO_DIFF_CHANNELS('u', 18, 1), 209 .time_spec = &ad4000_t_spec, 210 }; 211 212 static const struct ad4000_chip_info ad4003_chip_info = { 213 .dev_name = "ad4003", 214 .chan_spec = AD4000_DIFF_CHANNELS('s', 18, 0), 215 .reg_access_chan_spec = AD4000_DIFF_CHANNELS('s', 18, 1), 216 .time_spec = &ad4000_t_spec, 217 }; 218 219 static const struct ad4000_chip_info ad4004_chip_info = { 220 .dev_name = "ad4004", 221 .chan_spec = AD4000_PSEUDO_DIFF_CHANNELS('u', 16, 0), 222 .reg_access_chan_spec = AD4000_PSEUDO_DIFF_CHANNELS('u', 16, 1), 223 .time_spec = &ad4000_t_spec, 224 }; 225 226 static const struct ad4000_chip_info ad4005_chip_info = { 227 .dev_name = "ad4005", 228 .chan_spec = AD4000_DIFF_CHANNELS('s', 16, 0), 229 .reg_access_chan_spec = AD4000_DIFF_CHANNELS('s', 16, 1), 230 .time_spec = &ad4000_t_spec, 231 }; 232 233 static const struct ad4000_chip_info ad4006_chip_info = { 234 .dev_name = "ad4006", 235 .chan_spec = AD4000_PSEUDO_DIFF_CHANNELS('u', 18, 0), 236 .reg_access_chan_spec = AD4000_PSEUDO_DIFF_CHANNELS('u', 18, 1), 237 .time_spec = &ad4000_t_spec, 238 }; 239 240 static const struct ad4000_chip_info ad4007_chip_info = { 241 .dev_name = "ad4007", 242 .chan_spec = AD4000_DIFF_CHANNELS('s', 18, 0), 243 .reg_access_chan_spec = AD4000_DIFF_CHANNELS('s', 18, 1), 244 .time_spec = &ad4000_t_spec, 245 }; 246 247 static const struct ad4000_chip_info ad4008_chip_info = { 248 .dev_name = "ad4008", 249 .chan_spec = AD4000_PSEUDO_DIFF_CHANNELS('u', 16, 0), 250 .reg_access_chan_spec = AD4000_PSEUDO_DIFF_CHANNELS('u', 16, 1), 251 .time_spec = &ad4000_t_spec, 252 }; 253 254 static const struct ad4000_chip_info ad4010_chip_info = { 255 .dev_name = "ad4010", 256 .chan_spec = AD4000_PSEUDO_DIFF_CHANNELS('u', 18, 0), 257 .reg_access_chan_spec = AD4000_PSEUDO_DIFF_CHANNELS('u', 18, 1), 258 .time_spec = &ad4000_t_spec, 259 }; 260 261 static const struct ad4000_chip_info ad4011_chip_info = { 262 .dev_name = "ad4011", 263 .chan_spec = AD4000_DIFF_CHANNELS('s', 18, 0), 264 .reg_access_chan_spec = AD4000_DIFF_CHANNELS('s', 18, 1), 265 .time_spec = &ad4000_t_spec, 266 }; 267 268 static const struct ad4000_chip_info ad4020_chip_info = { 269 .dev_name = "ad4020", 270 .chan_spec = AD4000_DIFF_CHANNELS('s', 20, 0), 271 .reg_access_chan_spec = AD4000_DIFF_CHANNELS('s', 20, 1), 272 .time_spec = &ad4020_t_spec, 273 }; 274 275 static const struct ad4000_chip_info ad4021_chip_info = { 276 .dev_name = "ad4021", 277 .chan_spec = AD4000_DIFF_CHANNELS('s', 20, 0), 278 .reg_access_chan_spec = AD4000_DIFF_CHANNELS('s', 20, 1), 279 .time_spec = &ad4020_t_spec, 280 }; 281 282 static const struct ad4000_chip_info ad4022_chip_info = { 283 .dev_name = "ad4022", 284 .chan_spec = AD4000_DIFF_CHANNELS('s', 20, 0), 285 .reg_access_chan_spec = AD4000_DIFF_CHANNELS('s', 20, 1), 286 .time_spec = &ad4020_t_spec, 287 }; 288 289 static const struct ad4000_chip_info adaq4001_chip_info = { 290 .dev_name = "adaq4001", 291 .chan_spec = AD4000_DIFF_CHANNELS('s', 16, 0), 292 .reg_access_chan_spec = AD4000_DIFF_CHANNELS('s', 16, 1), 293 .time_spec = &ad4000_t_spec, 294 .has_hardware_gain = true, 295 }; 296 297 static const struct ad4000_chip_info adaq4003_chip_info = { 298 .dev_name = "adaq4003", 299 .chan_spec = AD4000_DIFF_CHANNELS('s', 18, 0), 300 .reg_access_chan_spec = AD4000_DIFF_CHANNELS('s', 18, 1), 301 .time_spec = &ad4000_t_spec, 302 .has_hardware_gain = true, 303 }; 304 305 static const struct ad4000_chip_info ad7685_chip_info = { 306 .dev_name = "ad7685", 307 .chan_spec = AD4000_PSEUDO_DIFF_CHANNELS('u', 16, 0), 308 .time_spec = &ad7687_t_spec, 309 }; 310 311 static const struct ad4000_chip_info ad7686_chip_info = { 312 .dev_name = "ad7686", 313 .chan_spec = AD4000_PSEUDO_DIFF_CHANNELS('u', 16, 0), 314 .time_spec = &ad7686_t_spec, 315 }; 316 317 static const struct ad4000_chip_info ad7687_chip_info = { 318 .dev_name = "ad7687", 319 .chan_spec = AD4000_DIFF_CHANNELS('s', 16, 0), 320 .time_spec = &ad7687_t_spec, 321 }; 322 323 static const struct ad4000_chip_info ad7688_chip_info = { 324 .dev_name = "ad7688", 325 .chan_spec = AD4000_DIFF_CHANNELS('s', 16, 0), 326 .time_spec = &ad7686_t_spec, 327 }; 328 329 static const struct ad4000_chip_info ad7690_chip_info = { 330 .dev_name = "ad7690", 331 .chan_spec = AD4000_DIFF_CHANNELS('s', 18, 0), 332 .time_spec = &ad7690_t_spec, 333 }; 334 335 static const struct ad4000_chip_info ad7691_chip_info = { 336 .dev_name = "ad7691", 337 .chan_spec = AD4000_DIFF_CHANNELS('s', 18, 0), 338 .time_spec = &ad7691_t_spec, 339 }; 340 341 static const struct ad4000_chip_info ad7693_chip_info = { 342 .dev_name = "ad7693", 343 .chan_spec = AD4000_DIFF_CHANNELS('s', 16, 0), 344 .time_spec = &ad7686_t_spec, 345 }; 346 347 static const struct ad4000_chip_info ad7942_chip_info = { 348 .dev_name = "ad7942", 349 .chan_spec = AD4000_PSEUDO_DIFF_CHANNELS('u', 14, 0), 350 .time_spec = &ad7687_t_spec, 351 }; 352 353 static const struct ad4000_chip_info ad7946_chip_info = { 354 .dev_name = "ad7946", 355 .chan_spec = AD4000_PSEUDO_DIFF_CHANNELS('u', 14, 0), 356 .time_spec = &ad7686_t_spec, 357 }; 358 359 static const struct ad4000_chip_info ad7980_chip_info = { 360 .dev_name = "ad7980", 361 .chan_spec = AD4000_PSEUDO_DIFF_CHANNELS('u', 16, 0), 362 .time_spec = &ad7980_t_spec, 363 }; 364 365 static const struct ad4000_chip_info ad7982_chip_info = { 366 .dev_name = "ad7982", 367 .chan_spec = AD4000_DIFF_CHANNELS('s', 18, 0), 368 .time_spec = &ad7980_t_spec, 369 }; 370 371 static const struct ad4000_chip_info ad7983_chip_info = { 372 .dev_name = "ad7983", 373 .chan_spec = AD4000_PSEUDO_DIFF_CHANNELS('u', 16, 0), 374 .time_spec = &ad7983_t_spec, 375 }; 376 377 static const struct ad4000_chip_info ad7984_chip_info = { 378 .dev_name = "ad7984", 379 .chan_spec = AD4000_DIFF_CHANNELS('s', 18, 0), 380 .time_spec = &ad7983_t_spec, 381 }; 382 383 static const struct ad4000_chip_info ad7988_1_chip_info = { 384 .dev_name = "ad7988-1", 385 .chan_spec = AD4000_PSEUDO_DIFF_CHANNELS('u', 16, 0), 386 .time_spec = &ad7988_1_t_spec, 387 }; 388 389 static const struct ad4000_chip_info ad7988_5_chip_info = { 390 .dev_name = "ad7988-5", 391 .chan_spec = AD4000_PSEUDO_DIFF_CHANNELS('u', 16, 0), 392 .time_spec = &ad7686_t_spec, 393 }; 394 395 struct ad4000_state { 396 struct spi_device *spi; 397 struct gpio_desc *cnv_gpio; 398 struct spi_transfer xfers[2]; 399 struct spi_message msg; 400 struct mutex lock; /* Protect read modify write cycle */ 401 int vref_mv; 402 enum ad4000_sdi sdi_pin; 403 bool span_comp; 404 u16 gain_milli; 405 int scale_tbl[AD4000_SCALE_OPTIONS][2]; 406 const struct ad4000_time_spec *time_spec; 407 408 /* 409 * DMA (thus cache coherency maintenance) requires the transfer buffers 410 * to live in their own cache lines. 411 */ 412 struct { 413 union { 414 __be16 sample_buf16; 415 __be32 sample_buf32; 416 } data; 417 aligned_s64 timestamp; 418 } scan __aligned(IIO_DMA_MINALIGN); 419 u8 tx_buf[2]; 420 u8 rx_buf[2]; 421 }; 422 423 static void ad4000_fill_scale_tbl(struct ad4000_state *st, 424 struct iio_chan_spec const *chan) 425 { 426 int val, tmp0, tmp1; 427 int scale_bits; 428 u64 tmp2; 429 430 /* 431 * ADCs that output two's complement code have one less bit to express 432 * voltage magnitude. 433 */ 434 if (chan->scan_type.sign == 's') 435 scale_bits = chan->scan_type.realbits - 1; 436 else 437 scale_bits = chan->scan_type.realbits; 438 439 /* 440 * The gain is stored as a fraction of 1000 and, as we need to 441 * divide vref_mv by the gain, we invert the gain/1000 fraction. 442 * Also multiply by an extra MILLI to preserve precision. 443 * Thus, we have MILLI * MILLI equals MICRO as fraction numerator. 444 */ 445 val = mult_frac(st->vref_mv, MICRO, st->gain_milli); 446 447 /* Would multiply by NANO here but we multiplied by extra MILLI */ 448 tmp2 = shift_right((u64)val * MICRO, scale_bits); 449 tmp0 = div_s64_rem(tmp2, NANO, &tmp1); 450 451 /* Store scale for when span compression is disabled */ 452 st->scale_tbl[0][0] = tmp0; /* Integer part */ 453 st->scale_tbl[0][1] = abs(tmp1); /* Fractional part */ 454 455 /* Store scale for when span compression is enabled */ 456 st->scale_tbl[1][0] = tmp0; 457 458 /* The integer part is always zero so don't bother to divide it. */ 459 if (chan->differential) 460 st->scale_tbl[1][1] = DIV_ROUND_CLOSEST(abs(tmp1) * 4, 5); 461 else 462 st->scale_tbl[1][1] = DIV_ROUND_CLOSEST(abs(tmp1) * 9, 10); 463 } 464 465 static int ad4000_write_reg(struct ad4000_state *st, uint8_t val) 466 { 467 st->tx_buf[0] = AD4000_WRITE_COMMAND; 468 st->tx_buf[1] = val; 469 return spi_write(st->spi, st->tx_buf, ARRAY_SIZE(st->tx_buf)); 470 } 471 472 static int ad4000_read_reg(struct ad4000_state *st, unsigned int *val) 473 { 474 struct spi_transfer t = { 475 .tx_buf = st->tx_buf, 476 .rx_buf = st->rx_buf, 477 .len = 2, 478 }; 479 int ret; 480 481 st->tx_buf[0] = AD4000_READ_COMMAND; 482 ret = spi_sync_transfer(st->spi, &t, 1); 483 if (ret < 0) 484 return ret; 485 486 *val = st->rx_buf[1]; 487 return ret; 488 } 489 490 static int ad4000_convert_and_acquire(struct ad4000_state *st) 491 { 492 int ret; 493 494 /* 495 * In 4-wire mode, the CNV line is held high for the entire conversion 496 * and acquisition process. In other modes, the CNV GPIO is optional 497 * and, if provided, replaces controller CS. If CNV GPIO is not defined 498 * gpiod_set_value_cansleep() has no effect. 499 */ 500 gpiod_set_value_cansleep(st->cnv_gpio, 1); 501 ret = spi_sync(st->spi, &st->msg); 502 gpiod_set_value_cansleep(st->cnv_gpio, 0); 503 504 return ret; 505 } 506 507 static int ad4000_single_conversion(struct iio_dev *indio_dev, 508 const struct iio_chan_spec *chan, int *val) 509 { 510 struct ad4000_state *st = iio_priv(indio_dev); 511 u32 sample; 512 int ret; 513 514 ret = ad4000_convert_and_acquire(st); 515 if (ret < 0) 516 return ret; 517 518 if (chan->scan_type.storagebits > 16) 519 sample = be32_to_cpu(st->scan.data.sample_buf32); 520 else 521 sample = be16_to_cpu(st->scan.data.sample_buf16); 522 523 sample >>= chan->scan_type.shift; 524 525 if (chan->scan_type.sign == 's') 526 *val = sign_extend32(sample, chan->scan_type.realbits - 1); 527 else 528 *val = sample; 529 530 return IIO_VAL_INT; 531 } 532 533 static int ad4000_read_raw(struct iio_dev *indio_dev, 534 struct iio_chan_spec const *chan, int *val, 535 int *val2, long info) 536 { 537 struct ad4000_state *st = iio_priv(indio_dev); 538 539 switch (info) { 540 case IIO_CHAN_INFO_RAW: 541 iio_device_claim_direct_scoped(return -EBUSY, indio_dev) 542 return ad4000_single_conversion(indio_dev, chan, val); 543 unreachable(); 544 case IIO_CHAN_INFO_SCALE: 545 *val = st->scale_tbl[st->span_comp][0]; 546 *val2 = st->scale_tbl[st->span_comp][1]; 547 return IIO_VAL_INT_PLUS_NANO; 548 case IIO_CHAN_INFO_OFFSET: 549 *val = 0; 550 if (st->span_comp) 551 *val = mult_frac(st->vref_mv, 1, 10); 552 553 return IIO_VAL_INT; 554 default: 555 return -EINVAL; 556 } 557 } 558 559 static int ad4000_read_avail(struct iio_dev *indio_dev, 560 struct iio_chan_spec const *chan, 561 const int **vals, int *type, int *length, 562 long info) 563 { 564 struct ad4000_state *st = iio_priv(indio_dev); 565 566 switch (info) { 567 case IIO_CHAN_INFO_SCALE: 568 *vals = (int *)st->scale_tbl; 569 *length = AD4000_SCALE_OPTIONS * 2; 570 *type = IIO_VAL_INT_PLUS_NANO; 571 return IIO_AVAIL_LIST; 572 default: 573 return -EINVAL; 574 } 575 } 576 577 static int ad4000_write_raw_get_fmt(struct iio_dev *indio_dev, 578 struct iio_chan_spec const *chan, long mask) 579 { 580 switch (mask) { 581 case IIO_CHAN_INFO_SCALE: 582 return IIO_VAL_INT_PLUS_NANO; 583 default: 584 return IIO_VAL_INT_PLUS_MICRO; 585 } 586 } 587 588 static int ad4000_write_raw(struct iio_dev *indio_dev, 589 struct iio_chan_spec const *chan, int val, int val2, 590 long mask) 591 { 592 struct ad4000_state *st = iio_priv(indio_dev); 593 unsigned int reg_val; 594 bool span_comp_en; 595 int ret; 596 597 switch (mask) { 598 case IIO_CHAN_INFO_SCALE: 599 iio_device_claim_direct_scoped(return -EBUSY, indio_dev) { 600 guard(mutex)(&st->lock); 601 602 ret = ad4000_read_reg(st, ®_val); 603 if (ret < 0) 604 return ret; 605 606 span_comp_en = val2 == st->scale_tbl[1][1]; 607 reg_val &= ~AD4000_CFG_SPAN_COMP; 608 reg_val |= FIELD_PREP(AD4000_CFG_SPAN_COMP, span_comp_en); 609 610 ret = ad4000_write_reg(st, reg_val); 611 if (ret < 0) 612 return ret; 613 614 st->span_comp = span_comp_en; 615 return 0; 616 } 617 unreachable(); 618 default: 619 return -EINVAL; 620 } 621 } 622 623 static irqreturn_t ad4000_trigger_handler(int irq, void *p) 624 { 625 struct iio_poll_func *pf = p; 626 struct iio_dev *indio_dev = pf->indio_dev; 627 struct ad4000_state *st = iio_priv(indio_dev); 628 int ret; 629 630 ret = ad4000_convert_and_acquire(st); 631 if (ret < 0) 632 goto err_out; 633 634 iio_push_to_buffers_with_timestamp(indio_dev, &st->scan, pf->timestamp); 635 636 err_out: 637 iio_trigger_notify_done(indio_dev->trig); 638 return IRQ_HANDLED; 639 } 640 641 static const struct iio_info ad4000_reg_access_info = { 642 .read_raw = &ad4000_read_raw, 643 .read_avail = &ad4000_read_avail, 644 .write_raw = &ad4000_write_raw, 645 .write_raw_get_fmt = &ad4000_write_raw_get_fmt, 646 }; 647 648 static const struct iio_info ad4000_info = { 649 .read_raw = &ad4000_read_raw, 650 }; 651 652 /* 653 * This executes a data sample transfer for when the device connections are 654 * in "3-wire" mode, selected when the adi,sdi-pin device tree property is 655 * absent or set to "high". In this connection mode, the ADC SDI pin is 656 * connected to MOSI or to VIO and ADC CNV pin is connected either to a SPI 657 * controller CS or to a GPIO. 658 * AD4000 series of devices initiate conversions on the rising edge of CNV pin. 659 * 660 * If the CNV pin is connected to an SPI controller CS line (which is by default 661 * active low), the ADC readings would have a latency (delay) of one read. 662 * Moreover, since we also do ADC sampling for filling the buffer on triggered 663 * buffer mode, the timestamps of buffer readings would be disarranged. 664 * To prevent the read latency and reduce the time discrepancy between the 665 * sample read request and the time of actual sampling by the ADC, do a 666 * preparatory transfer to pulse the CS/CNV line. 667 */ 668 static int ad4000_prepare_3wire_mode_message(struct ad4000_state *st, 669 const struct iio_chan_spec *chan) 670 { 671 struct spi_transfer *xfers = st->xfers; 672 673 xfers[0].cs_change = 1; 674 xfers[0].cs_change_delay.value = st->time_spec->t_conv_ns; 675 xfers[0].cs_change_delay.unit = SPI_DELAY_UNIT_NSECS; 676 677 xfers[1].rx_buf = &st->scan.data; 678 xfers[1].len = BITS_TO_BYTES(chan->scan_type.storagebits); 679 xfers[1].delay.value = st->time_spec->t_quiet2_ns; 680 xfers[1].delay.unit = SPI_DELAY_UNIT_NSECS; 681 682 spi_message_init_with_transfers(&st->msg, st->xfers, 2); 683 684 return devm_spi_optimize_message(&st->spi->dev, st->spi, &st->msg); 685 } 686 687 /* 688 * This executes a data sample transfer for when the device connections are 689 * in "4-wire" mode, selected when the adi,sdi-pin device tree property is 690 * set to "cs". In this connection mode, the controller CS pin is connected to 691 * ADC SDI pin and a GPIO is connected to ADC CNV pin. 692 * The GPIO connected to ADC CNV pin is set outside of the SPI transfer. 693 */ 694 static int ad4000_prepare_4wire_mode_message(struct ad4000_state *st, 695 const struct iio_chan_spec *chan) 696 { 697 struct spi_transfer *xfers = st->xfers; 698 699 /* 700 * Dummy transfer to cause enough delay between CNV going high and SDI 701 * going low. 702 */ 703 xfers[0].cs_off = 1; 704 xfers[0].delay.value = st->time_spec->t_conv_ns; 705 xfers[0].delay.unit = SPI_DELAY_UNIT_NSECS; 706 707 xfers[1].rx_buf = &st->scan.data; 708 xfers[1].len = BITS_TO_BYTES(chan->scan_type.storagebits); 709 710 spi_message_init_with_transfers(&st->msg, st->xfers, 2); 711 712 return devm_spi_optimize_message(&st->spi->dev, st->spi, &st->msg); 713 } 714 715 static int ad4000_config(struct ad4000_state *st) 716 { 717 unsigned int reg_val = AD4000_CONFIG_REG_DEFAULT; 718 719 if (device_property_present(&st->spi->dev, "adi,high-z-input")) 720 reg_val |= FIELD_PREP(AD4000_CFG_HIGHZ, 1); 721 722 return ad4000_write_reg(st, reg_val); 723 } 724 725 static int ad4000_probe(struct spi_device *spi) 726 { 727 const struct ad4000_chip_info *chip; 728 struct device *dev = &spi->dev; 729 struct iio_dev *indio_dev; 730 struct ad4000_state *st; 731 int gain_idx, ret; 732 733 indio_dev = devm_iio_device_alloc(dev, sizeof(*st)); 734 if (!indio_dev) 735 return -ENOMEM; 736 737 chip = spi_get_device_match_data(spi); 738 if (!chip) 739 return -EINVAL; 740 741 st = iio_priv(indio_dev); 742 st->spi = spi; 743 st->time_spec = chip->time_spec; 744 745 ret = devm_regulator_bulk_get_enable(dev, ARRAY_SIZE(ad4000_power_supplies), 746 ad4000_power_supplies); 747 if (ret) 748 return dev_err_probe(dev, ret, "Failed to enable power supplies\n"); 749 750 ret = devm_regulator_get_enable_read_voltage(dev, "ref"); 751 if (ret < 0) 752 return dev_err_probe(dev, ret, 753 "Failed to get ref regulator reference\n"); 754 st->vref_mv = ret / 1000; 755 756 st->cnv_gpio = devm_gpiod_get_optional(dev, "cnv", GPIOD_OUT_HIGH); 757 if (IS_ERR(st->cnv_gpio)) 758 return dev_err_probe(dev, PTR_ERR(st->cnv_gpio), 759 "Failed to get CNV GPIO"); 760 761 ret = device_property_match_property_string(dev, "adi,sdi-pin", 762 ad4000_sdi_pin, 763 ARRAY_SIZE(ad4000_sdi_pin)); 764 if (ret < 0 && ret != -EINVAL) 765 return dev_err_probe(dev, ret, 766 "getting adi,sdi-pin property failed\n"); 767 768 /* Default to usual SPI connections if pin properties are not present */ 769 st->sdi_pin = ret == -EINVAL ? AD4000_SDI_MOSI : ret; 770 switch (st->sdi_pin) { 771 case AD4000_SDI_MOSI: 772 indio_dev->info = &ad4000_reg_access_info; 773 indio_dev->channels = chip->reg_access_chan_spec; 774 775 /* 776 * In "3-wire mode", the ADC SDI line must be kept high when 777 * data is not being clocked out of the controller. 778 * Request the SPI controller to make MOSI idle high. 779 */ 780 spi->mode |= SPI_MOSI_IDLE_HIGH; 781 ret = spi_setup(spi); 782 if (ret < 0) 783 return ret; 784 785 ret = ad4000_prepare_3wire_mode_message(st, &indio_dev->channels[0]); 786 if (ret) 787 return ret; 788 789 ret = ad4000_config(st); 790 if (ret < 0) 791 return dev_err_probe(dev, ret, "Failed to config device\n"); 792 793 break; 794 case AD4000_SDI_VIO: 795 indio_dev->info = &ad4000_info; 796 indio_dev->channels = chip->chan_spec; 797 ret = ad4000_prepare_3wire_mode_message(st, &indio_dev->channels[0]); 798 if (ret) 799 return ret; 800 801 break; 802 case AD4000_SDI_CS: 803 indio_dev->info = &ad4000_info; 804 indio_dev->channels = chip->chan_spec; 805 ret = ad4000_prepare_4wire_mode_message(st, &indio_dev->channels[0]); 806 if (ret) 807 return ret; 808 809 break; 810 case AD4000_SDI_GND: 811 return dev_err_probe(dev, -EPROTONOSUPPORT, 812 "Unsupported connection mode\n"); 813 814 default: 815 return dev_err_probe(dev, -EINVAL, "Unrecognized connection mode\n"); 816 } 817 818 indio_dev->name = chip->dev_name; 819 indio_dev->num_channels = 2; 820 821 ret = devm_mutex_init(dev, &st->lock); 822 if (ret) 823 return ret; 824 825 st->gain_milli = 1000; 826 if (chip->has_hardware_gain) { 827 ret = device_property_read_u16(dev, "adi,gain-milli", 828 &st->gain_milli); 829 if (!ret) { 830 /* Match gain value from dt to one of supported gains */ 831 gain_idx = find_closest(st->gain_milli, ad4000_gains, 832 ARRAY_SIZE(ad4000_gains)); 833 st->gain_milli = ad4000_gains[gain_idx]; 834 } else { 835 return dev_err_probe(dev, ret, 836 "Failed to read gain property\n"); 837 } 838 } 839 840 ad4000_fill_scale_tbl(st, &indio_dev->channels[0]); 841 842 ret = devm_iio_triggered_buffer_setup(dev, indio_dev, 843 &iio_pollfunc_store_time, 844 &ad4000_trigger_handler, NULL); 845 if (ret) 846 return ret; 847 848 return devm_iio_device_register(dev, indio_dev); 849 } 850 851 static const struct spi_device_id ad4000_id[] = { 852 { "ad4000", (kernel_ulong_t)&ad4000_chip_info }, 853 { "ad4001", (kernel_ulong_t)&ad4001_chip_info }, 854 { "ad4002", (kernel_ulong_t)&ad4002_chip_info }, 855 { "ad4003", (kernel_ulong_t)&ad4003_chip_info }, 856 { "ad4004", (kernel_ulong_t)&ad4004_chip_info }, 857 { "ad4005", (kernel_ulong_t)&ad4005_chip_info }, 858 { "ad4006", (kernel_ulong_t)&ad4006_chip_info }, 859 { "ad4007", (kernel_ulong_t)&ad4007_chip_info }, 860 { "ad4008", (kernel_ulong_t)&ad4008_chip_info }, 861 { "ad4010", (kernel_ulong_t)&ad4010_chip_info }, 862 { "ad4011", (kernel_ulong_t)&ad4011_chip_info }, 863 { "ad4020", (kernel_ulong_t)&ad4020_chip_info }, 864 { "ad4021", (kernel_ulong_t)&ad4021_chip_info }, 865 { "ad4022", (kernel_ulong_t)&ad4022_chip_info }, 866 { "adaq4001", (kernel_ulong_t)&adaq4001_chip_info }, 867 { "adaq4003", (kernel_ulong_t)&adaq4003_chip_info }, 868 { "ad7685", (kernel_ulong_t)&ad7685_chip_info }, 869 { "ad7686", (kernel_ulong_t)&ad7686_chip_info }, 870 { "ad7687", (kernel_ulong_t)&ad7687_chip_info }, 871 { "ad7688", (kernel_ulong_t)&ad7688_chip_info }, 872 { "ad7690", (kernel_ulong_t)&ad7690_chip_info }, 873 { "ad7691", (kernel_ulong_t)&ad7691_chip_info }, 874 { "ad7693", (kernel_ulong_t)&ad7693_chip_info }, 875 { "ad7942", (kernel_ulong_t)&ad7942_chip_info }, 876 { "ad7946", (kernel_ulong_t)&ad7946_chip_info }, 877 { "ad7980", (kernel_ulong_t)&ad7980_chip_info }, 878 { "ad7982", (kernel_ulong_t)&ad7982_chip_info }, 879 { "ad7983", (kernel_ulong_t)&ad7983_chip_info }, 880 { "ad7984", (kernel_ulong_t)&ad7984_chip_info }, 881 { "ad7988-1", (kernel_ulong_t)&ad7988_1_chip_info }, 882 { "ad7988-5", (kernel_ulong_t)&ad7988_5_chip_info }, 883 { } 884 }; 885 MODULE_DEVICE_TABLE(spi, ad4000_id); 886 887 static const struct of_device_id ad4000_of_match[] = { 888 { .compatible = "adi,ad4000", .data = &ad4000_chip_info }, 889 { .compatible = "adi,ad4001", .data = &ad4001_chip_info }, 890 { .compatible = "adi,ad4002", .data = &ad4002_chip_info }, 891 { .compatible = "adi,ad4003", .data = &ad4003_chip_info }, 892 { .compatible = "adi,ad4004", .data = &ad4004_chip_info }, 893 { .compatible = "adi,ad4005", .data = &ad4005_chip_info }, 894 { .compatible = "adi,ad4006", .data = &ad4006_chip_info }, 895 { .compatible = "adi,ad4007", .data = &ad4007_chip_info }, 896 { .compatible = "adi,ad4008", .data = &ad4008_chip_info }, 897 { .compatible = "adi,ad4010", .data = &ad4010_chip_info }, 898 { .compatible = "adi,ad4011", .data = &ad4011_chip_info }, 899 { .compatible = "adi,ad4020", .data = &ad4020_chip_info }, 900 { .compatible = "adi,ad4021", .data = &ad4021_chip_info }, 901 { .compatible = "adi,ad4022", .data = &ad4022_chip_info }, 902 { .compatible = "adi,adaq4001", .data = &adaq4001_chip_info }, 903 { .compatible = "adi,adaq4003", .data = &adaq4003_chip_info }, 904 { .compatible = "adi,ad7685", .data = &ad7685_chip_info }, 905 { .compatible = "adi,ad7686", .data = &ad7686_chip_info }, 906 { .compatible = "adi,ad7687", .data = &ad7687_chip_info }, 907 { .compatible = "adi,ad7688", .data = &ad7688_chip_info }, 908 { .compatible = "adi,ad7690", .data = &ad7690_chip_info }, 909 { .compatible = "adi,ad7691", .data = &ad7691_chip_info }, 910 { .compatible = "adi,ad7693", .data = &ad7693_chip_info }, 911 { .compatible = "adi,ad7942", .data = &ad7942_chip_info }, 912 { .compatible = "adi,ad7946", .data = &ad7946_chip_info }, 913 { .compatible = "adi,ad7980", .data = &ad7980_chip_info }, 914 { .compatible = "adi,ad7982", .data = &ad7982_chip_info }, 915 { .compatible = "adi,ad7983", .data = &ad7983_chip_info }, 916 { .compatible = "adi,ad7984", .data = &ad7984_chip_info }, 917 { .compatible = "adi,ad7988-1", .data = &ad7988_1_chip_info }, 918 { .compatible = "adi,ad7988-5", .data = &ad7988_5_chip_info }, 919 { } 920 }; 921 MODULE_DEVICE_TABLE(of, ad4000_of_match); 922 923 static struct spi_driver ad4000_driver = { 924 .driver = { 925 .name = "ad4000", 926 .of_match_table = ad4000_of_match, 927 }, 928 .probe = ad4000_probe, 929 .id_table = ad4000_id, 930 }; 931 module_spi_driver(ad4000_driver); 932 933 MODULE_AUTHOR("Marcelo Schmitt <marcelo.schmitt@analog.com>"); 934 MODULE_DESCRIPTION("Analog Devices AD4000 ADC driver"); 935 MODULE_LICENSE("GPL"); 936