1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * Support code for Analog Devices Sigma-Delta ADCs 4 * 5 * Copyright 2012 Analog Devices Inc. 6 * Author: Lars-Peter Clausen <lars@metafoo.de> 7 */ 8 9 #include <linux/align.h> 10 #include <linux/bitmap.h> 11 #include <linux/bitops.h> 12 #include <linux/cleanup.h> 13 #include <linux/completion.h> 14 #include <linux/device.h> 15 #include <linux/err.h> 16 #include <linux/export.h> 17 #include <linux/find.h> 18 #include <linux/gpio/consumer.h> 19 #include <linux/interrupt.h> 20 #include <linux/module.h> 21 #include <linux/property.h> 22 #include <linux/slab.h> 23 #include <linux/spi/offload/consumer.h> 24 #include <linux/spi/spi.h> 25 #include <linux/spinlock.h> 26 #include <linux/string.h> 27 #include <linux/types.h> 28 #include <linux/unaligned.h> 29 30 #include <linux/iio/adc/ad_sigma_delta.h> 31 #include <linux/iio/buffer-dmaengine.h> 32 #include <linux/iio/buffer.h> 33 #include <linux/iio/iio.h> 34 #include <linux/iio/trigger_consumer.h> 35 #include <linux/iio/trigger.h> 36 #include <linux/iio/triggered_buffer.h> 37 38 #define AD_SD_COMM_CHAN_MASK 0x3 39 40 #define AD_SD_REG_COMM 0x00 41 #define AD_SD_REG_STATUS 0x00 42 #define AD_SD_REG_DATA 0x03 43 44 #define AD_SD_REG_STATUS_RDY 0x80 45 46 /** 47 * ad_sd_set_comm() - Set communications register 48 * 49 * @sigma_delta: The sigma delta device 50 * @comm: New value for the communications register 51 */ 52 void ad_sd_set_comm(struct ad_sigma_delta *sigma_delta, u8 comm) 53 { 54 /* 55 * Some variants use the lower two bits of the communications register 56 * to select the channel. 57 */ 58 sigma_delta->comm = comm & AD_SD_COMM_CHAN_MASK; 59 } 60 EXPORT_SYMBOL_NS_GPL(ad_sd_set_comm, "IIO_AD_SIGMA_DELTA"); 61 62 /** 63 * ad_sd_write_reg() - Write a register 64 * 65 * @sigma_delta: The sigma delta device 66 * @reg: Address of the register 67 * @size: Size of the register (0-3) 68 * @val: Value to write to the register 69 * 70 * Returns 0 on success, an error code otherwise. 71 **/ 72 int ad_sd_write_reg(struct ad_sigma_delta *sigma_delta, unsigned int reg, 73 unsigned int size, unsigned int val) 74 { 75 u8 *data = sigma_delta->tx_buf; 76 struct spi_transfer t = { 77 .tx_buf = data, 78 .len = size + 1, 79 .cs_change = sigma_delta->keep_cs_asserted, 80 }; 81 struct spi_message m; 82 int ret; 83 84 data[0] = (reg << sigma_delta->info->addr_shift) | sigma_delta->comm; 85 86 switch (size) { 87 case 3: 88 put_unaligned_be24(val, &data[1]); 89 break; 90 case 2: 91 put_unaligned_be16(val, &data[1]); 92 break; 93 case 1: 94 data[1] = val; 95 break; 96 case 0: 97 break; 98 default: 99 return -EINVAL; 100 } 101 102 spi_message_init(&m); 103 spi_message_add_tail(&t, &m); 104 105 if (sigma_delta->bus_locked) 106 ret = spi_sync_locked(sigma_delta->spi, &m); 107 else 108 ret = spi_sync(sigma_delta->spi, &m); 109 110 return ret; 111 } 112 EXPORT_SYMBOL_NS_GPL(ad_sd_write_reg, "IIO_AD_SIGMA_DELTA"); 113 114 static void ad_sd_set_read_reg_addr(struct ad_sigma_delta *sigma_delta, u8 reg, 115 u8 *data) 116 { 117 data[0] = reg << sigma_delta->info->addr_shift; 118 data[0] |= sigma_delta->info->read_mask; 119 data[0] |= sigma_delta->comm; 120 } 121 122 static int ad_sd_read_reg_raw(struct ad_sigma_delta *sigma_delta, 123 unsigned int reg, unsigned int size, u8 *val) 124 { 125 u8 *data = sigma_delta->tx_buf; 126 int ret; 127 struct spi_transfer t[] = { 128 { 129 .tx_buf = data, 130 .len = 1, 131 }, { 132 .rx_buf = val, 133 .len = size, 134 .cs_change = sigma_delta->keep_cs_asserted, 135 }, 136 }; 137 struct spi_message m; 138 139 spi_message_init(&m); 140 141 if (sigma_delta->info->has_registers) { 142 ad_sd_set_read_reg_addr(sigma_delta, reg, data); 143 spi_message_add_tail(&t[0], &m); 144 } 145 spi_message_add_tail(&t[1], &m); 146 147 if (sigma_delta->bus_locked) 148 ret = spi_sync_locked(sigma_delta->spi, &m); 149 else 150 ret = spi_sync(sigma_delta->spi, &m); 151 152 return ret; 153 } 154 155 /** 156 * ad_sd_read_reg() - Read a register 157 * 158 * @sigma_delta: The sigma delta device 159 * @reg: Address of the register 160 * @size: Size of the register (1-4) 161 * @val: Read value 162 * 163 * Returns 0 on success, an error code otherwise. 164 **/ 165 int ad_sd_read_reg(struct ad_sigma_delta *sigma_delta, 166 unsigned int reg, unsigned int size, unsigned int *val) 167 { 168 int ret; 169 170 ret = ad_sd_read_reg_raw(sigma_delta, reg, size, sigma_delta->rx_buf); 171 if (ret < 0) 172 goto out; 173 174 switch (size) { 175 case 4: 176 *val = get_unaligned_be32(sigma_delta->rx_buf); 177 break; 178 case 3: 179 *val = get_unaligned_be24(sigma_delta->rx_buf); 180 break; 181 case 2: 182 *val = get_unaligned_be16(sigma_delta->rx_buf); 183 break; 184 case 1: 185 *val = sigma_delta->rx_buf[0]; 186 break; 187 default: 188 ret = -EINVAL; 189 break; 190 } 191 192 out: 193 return ret; 194 } 195 EXPORT_SYMBOL_NS_GPL(ad_sd_read_reg, "IIO_AD_SIGMA_DELTA"); 196 197 /** 198 * ad_sd_reset() - Reset the serial interface 199 * 200 * @sigma_delta: The sigma delta device 201 * 202 * Returns 0 on success, an error code otherwise. 203 **/ 204 int ad_sd_reset(struct ad_sigma_delta *sigma_delta) 205 { 206 unsigned int reset_length = sigma_delta->info->num_resetclks; 207 unsigned int size; 208 u8 *buf; 209 int ret; 210 211 size = BITS_TO_BYTES(reset_length); 212 buf = kcalloc(size, sizeof(*buf), GFP_KERNEL); 213 if (!buf) 214 return -ENOMEM; 215 216 memset(buf, 0xff, size); 217 ret = spi_write(sigma_delta->spi, buf, size); 218 kfree(buf); 219 220 return ret; 221 } 222 EXPORT_SYMBOL_NS_GPL(ad_sd_reset, "IIO_AD_SIGMA_DELTA"); 223 224 static bool ad_sd_disable_irq(struct ad_sigma_delta *sigma_delta) 225 { 226 guard(spinlock_irqsave)(&sigma_delta->irq_lock); 227 228 /* It's already off, return false to indicate nothing was changed */ 229 if (sigma_delta->irq_dis) 230 return false; 231 232 sigma_delta->irq_dis = true; 233 disable_irq_nosync(sigma_delta->irq_line); 234 return true; 235 } 236 237 static void ad_sd_enable_irq(struct ad_sigma_delta *sigma_delta) 238 { 239 guard(spinlock_irqsave)(&sigma_delta->irq_lock); 240 241 sigma_delta->irq_dis = false; 242 enable_irq(sigma_delta->irq_line); 243 } 244 245 #define AD_SD_CLEAR_DATA_BUFLEN 9 246 247 /* Called with `sigma_delta->bus_locked == true` only. */ 248 static int ad_sigma_delta_clear_pending_event(struct ad_sigma_delta *sigma_delta) 249 { 250 bool pending_event; 251 unsigned int data_read_len = BITS_TO_BYTES(sigma_delta->info->num_resetclks); 252 u8 *data; 253 struct spi_transfer t[] = { 254 { 255 .len = 1, 256 }, { 257 .len = data_read_len, 258 } 259 }; 260 struct spi_message m; 261 int ret; 262 263 /* 264 * Read R̅D̅Y̅ pin (if possible) or status register to check if there is an 265 * old event. 266 */ 267 if (sigma_delta->rdy_gpiod) { 268 pending_event = gpiod_get_value(sigma_delta->rdy_gpiod); 269 } else { 270 unsigned int status_reg; 271 272 ret = ad_sd_read_reg(sigma_delta, AD_SD_REG_STATUS, 1, &status_reg); 273 if (ret) 274 return ret; 275 276 pending_event = !(status_reg & AD_SD_REG_STATUS_RDY); 277 } 278 279 if (!pending_event) 280 return 0; 281 282 /* 283 * In general the size of the data register is unknown. It varies from 284 * device to device, might be one byte longer if CONTROL.DATA_STATUS is 285 * set and even varies on some devices depending on which input is 286 * selected. So send one byte to start reading the data register and 287 * then just clock for some bytes with DIN (aka MOSI) high to not 288 * confuse the register access state machine after the data register was 289 * completely read. Note however that the sequence length must be 290 * shorter than the reset procedure. 291 */ 292 293 data = kzalloc(data_read_len + 1, GFP_KERNEL); 294 if (!data) 295 return -ENOMEM; 296 297 spi_message_init(&m); 298 if (sigma_delta->info->has_registers) { 299 unsigned int data_reg = sigma_delta->info->data_reg ?: AD_SD_REG_DATA; 300 301 ad_sd_set_read_reg_addr(sigma_delta, data_reg, data); 302 t[0].tx_buf = data; 303 spi_message_add_tail(&t[0], &m); 304 } 305 306 /* 307 * The first transferred byte is part of the real data register, 308 * so this doesn't need to be 0xff. In the remaining 309 * `data_read_len - 1` bytes are less than $num_resetclks ones. 310 */ 311 t[1].tx_buf = data + 1; 312 data[1] = 0x00; 313 memset(data + 2, 0xff, data_read_len - 1); 314 spi_message_add_tail(&t[1], &m); 315 316 ret = spi_sync_locked(sigma_delta->spi, &m); 317 318 kfree(data); 319 320 return ret; 321 } 322 323 int ad_sd_calibrate(struct ad_sigma_delta *sigma_delta, 324 unsigned int mode, unsigned int channel) 325 { 326 int ret; 327 unsigned long time_left; 328 329 ret = ad_sigma_delta_set_channel(sigma_delta, channel); 330 if (ret) 331 return ret; 332 333 spi_bus_lock(sigma_delta->spi->controller); 334 sigma_delta->bus_locked = true; 335 sigma_delta->keep_cs_asserted = true; 336 reinit_completion(&sigma_delta->completion); 337 338 ret = ad_sigma_delta_clear_pending_event(sigma_delta); 339 if (ret) 340 goto out; 341 342 ret = ad_sigma_delta_set_mode(sigma_delta, mode); 343 if (ret < 0) 344 goto out; 345 346 ad_sd_enable_irq(sigma_delta); 347 time_left = wait_for_completion_timeout(&sigma_delta->completion, 2 * HZ); 348 if (time_left == 0) { 349 ad_sd_disable_irq(sigma_delta); 350 ret = -EIO; 351 } else { 352 ret = 0; 353 } 354 out: 355 sigma_delta->keep_cs_asserted = false; 356 ad_sigma_delta_set_mode(sigma_delta, AD_SD_MODE_IDLE); 357 ad_sigma_delta_disable_one(sigma_delta, channel); 358 sigma_delta->bus_locked = false; 359 spi_bus_unlock(sigma_delta->spi->controller); 360 361 return ret; 362 } 363 EXPORT_SYMBOL_NS_GPL(ad_sd_calibrate, "IIO_AD_SIGMA_DELTA"); 364 365 /** 366 * ad_sd_calibrate_all() - Performs channel calibration 367 * @sigma_delta: The sigma delta device 368 * @cb: Array of channels and calibration type to perform 369 * @n: Number of items in cb 370 * 371 * Returns 0 on success, an error code otherwise. 372 **/ 373 int ad_sd_calibrate_all(struct ad_sigma_delta *sigma_delta, 374 const struct ad_sd_calib_data *cb, unsigned int n) 375 { 376 unsigned int i; 377 int ret; 378 379 for (i = 0; i < n; i++) { 380 ret = ad_sd_calibrate(sigma_delta, cb[i].mode, cb[i].channel); 381 if (ret) 382 return ret; 383 } 384 385 return 0; 386 } 387 EXPORT_SYMBOL_NS_GPL(ad_sd_calibrate_all, "IIO_AD_SIGMA_DELTA"); 388 389 /** 390 * ad_sigma_delta_single_conversion() - Performs a single data conversion 391 * @indio_dev: The IIO device 392 * @chan: The conversion is done for this channel 393 * @val: Pointer to the location where to store the read value 394 * 395 * Returns: 0 on success, an error value otherwise. 396 */ 397 int ad_sigma_delta_single_conversion(struct iio_dev *indio_dev, 398 const struct iio_chan_spec *chan, int *val) 399 { 400 struct ad_sigma_delta *sigma_delta = iio_device_get_drvdata(indio_dev); 401 unsigned int sample, raw_sample; 402 unsigned int data_reg; 403 int ret = 0; 404 405 if (!iio_device_claim_direct(indio_dev)) 406 return -EBUSY; 407 408 ret = ad_sigma_delta_set_channel(sigma_delta, chan->address); 409 if (ret) 410 goto out_release; 411 412 spi_bus_lock(sigma_delta->spi->controller); 413 sigma_delta->bus_locked = true; 414 sigma_delta->keep_cs_asserted = true; 415 reinit_completion(&sigma_delta->completion); 416 417 ret = ad_sigma_delta_clear_pending_event(sigma_delta); 418 if (ret) 419 goto out_unlock; 420 421 ad_sigma_delta_set_mode(sigma_delta, AD_SD_MODE_SINGLE); 422 423 ad_sd_enable_irq(sigma_delta); 424 ret = wait_for_completion_interruptible_timeout( 425 &sigma_delta->completion, HZ); 426 427 if (ret == 0) 428 ret = -EIO; 429 if (ret < 0) 430 goto out; 431 432 if (sigma_delta->info->data_reg != 0) 433 data_reg = sigma_delta->info->data_reg; 434 else 435 data_reg = AD_SD_REG_DATA; 436 437 ret = ad_sd_read_reg(sigma_delta, data_reg, 438 BITS_TO_BYTES(chan->scan_type.realbits + chan->scan_type.shift), 439 &raw_sample); 440 441 out: 442 ad_sd_disable_irq(sigma_delta); 443 444 ad_sigma_delta_set_mode(sigma_delta, AD_SD_MODE_IDLE); 445 ad_sigma_delta_disable_one(sigma_delta, chan->address); 446 447 out_unlock: 448 sigma_delta->keep_cs_asserted = false; 449 sigma_delta->bus_locked = false; 450 spi_bus_unlock(sigma_delta->spi->controller); 451 out_release: 452 iio_device_release_direct(indio_dev); 453 454 if (ret) 455 return ret; 456 457 sample = raw_sample >> chan->scan_type.shift; 458 sample &= (1 << chan->scan_type.realbits) - 1; 459 *val = sample; 460 461 ret = ad_sigma_delta_postprocess_sample(sigma_delta, raw_sample); 462 if (ret) 463 return ret; 464 465 return IIO_VAL_INT; 466 } 467 EXPORT_SYMBOL_NS_GPL(ad_sigma_delta_single_conversion, "IIO_AD_SIGMA_DELTA"); 468 469 static int ad_sd_buffer_postenable(struct iio_dev *indio_dev) 470 { 471 struct ad_sigma_delta *sigma_delta = iio_device_get_drvdata(indio_dev); 472 const struct iio_scan_type *scan_type = &indio_dev->channels[0].scan_type; 473 struct spi_transfer *xfer = sigma_delta->sample_xfer; 474 unsigned int i, slot, channel; 475 u8 *samples_buf; 476 int ret; 477 478 if (sigma_delta->num_slots == 1) { 479 channel = find_first_bit(indio_dev->active_scan_mask, 480 iio_get_masklength(indio_dev)); 481 ret = ad_sigma_delta_set_channel(sigma_delta, 482 indio_dev->channels[channel].address); 483 if (ret) 484 return ret; 485 slot = 1; 486 } else { 487 /* 488 * At this point update_scan_mode already enabled the required channels. 489 * For sigma-delta sequencer drivers with multiple slots, an update_scan_mode 490 * implementation is mandatory. 491 */ 492 slot = 0; 493 iio_for_each_active_channel(indio_dev, i) { 494 sigma_delta->slots[slot] = indio_dev->channels[i].address; 495 slot++; 496 } 497 } 498 499 sigma_delta->active_slots = slot; 500 sigma_delta->current_slot = 0; 501 502 if (ad_sigma_delta_has_spi_offload(sigma_delta)) { 503 xfer[1].offload_flags = SPI_OFFLOAD_XFER_RX_STREAM; 504 xfer[1].bits_per_word = scan_type->realbits; 505 xfer[1].len = spi_bpw_to_bytes(scan_type->realbits); 506 } else { 507 unsigned int samples_buf_size, scan_size; 508 509 if (sigma_delta->active_slots > 1) { 510 ret = ad_sigma_delta_append_status(sigma_delta, true); 511 if (ret) 512 return ret; 513 } 514 515 samples_buf_size = 516 ALIGN(slot * BITS_TO_BYTES(scan_type->storagebits), 517 sizeof(s64)); 518 samples_buf_size += sizeof(s64); 519 samples_buf = devm_krealloc(&sigma_delta->spi->dev, 520 sigma_delta->samples_buf, 521 samples_buf_size, GFP_KERNEL); 522 if (!samples_buf) 523 return -ENOMEM; 524 525 sigma_delta->samples_buf = samples_buf; 526 scan_size = BITS_TO_BYTES(scan_type->realbits + scan_type->shift); 527 /* For 24-bit data, there is an extra byte of padding. */ 528 xfer[1].rx_buf = &sigma_delta->rx_buf[scan_size == 3 ? 1 : 0]; 529 xfer[1].len = scan_size + (sigma_delta->status_appended ? 1 : 0); 530 } 531 xfer[1].cs_change = 1; 532 533 if (sigma_delta->info->has_registers) { 534 xfer[0].tx_buf = &sigma_delta->sample_addr; 535 xfer[0].len = 1; 536 537 ad_sd_set_read_reg_addr(sigma_delta, 538 sigma_delta->info->data_reg ?: AD_SD_REG_DATA, 539 &sigma_delta->sample_addr); 540 spi_message_init_with_transfers(&sigma_delta->sample_msg, xfer, 2); 541 } else { 542 spi_message_init_with_transfers(&sigma_delta->sample_msg, 543 &xfer[1], 1); 544 } 545 546 sigma_delta->sample_msg.offload = sigma_delta->offload; 547 548 ret = spi_optimize_message(sigma_delta->spi, &sigma_delta->sample_msg); 549 if (ret) 550 return ret; 551 552 spi_bus_lock(sigma_delta->spi->controller); 553 sigma_delta->bus_locked = true; 554 sigma_delta->keep_cs_asserted = true; 555 556 ret = ad_sigma_delta_clear_pending_event(sigma_delta); 557 if (ret) 558 goto err_unlock; 559 560 ret = ad_sigma_delta_set_mode(sigma_delta, AD_SD_MODE_CONTINUOUS); 561 if (ret) 562 goto err_unlock; 563 564 if (ad_sigma_delta_has_spi_offload(sigma_delta)) { 565 struct spi_offload_trigger_config config = { 566 .type = SPI_OFFLOAD_TRIGGER_DATA_READY, 567 }; 568 569 ret = spi_offload_trigger_enable(sigma_delta->offload, 570 sigma_delta->offload_trigger, 571 &config); 572 if (ret) 573 goto err_unlock; 574 } else { 575 ad_sd_enable_irq(sigma_delta); 576 } 577 578 return 0; 579 580 err_unlock: 581 spi_bus_unlock(sigma_delta->spi->controller); 582 spi_unoptimize_message(&sigma_delta->sample_msg); 583 584 return ret; 585 } 586 587 static int ad_sd_buffer_predisable(struct iio_dev *indio_dev) 588 { 589 struct ad_sigma_delta *sigma_delta = iio_device_get_drvdata(indio_dev); 590 591 if (ad_sigma_delta_has_spi_offload(sigma_delta)) { 592 spi_offload_trigger_disable(sigma_delta->offload, 593 sigma_delta->offload_trigger); 594 } else { 595 reinit_completion(&sigma_delta->completion); 596 wait_for_completion_timeout(&sigma_delta->completion, HZ); 597 598 ad_sd_disable_irq(sigma_delta); 599 } 600 601 sigma_delta->keep_cs_asserted = false; 602 ad_sigma_delta_set_mode(sigma_delta, AD_SD_MODE_IDLE); 603 604 if (sigma_delta->status_appended) 605 ad_sigma_delta_append_status(sigma_delta, false); 606 607 ad_sigma_delta_disable_all(sigma_delta); 608 sigma_delta->bus_locked = false; 609 spi_bus_unlock(sigma_delta->spi->controller); 610 spi_unoptimize_message(&sigma_delta->sample_msg); 611 612 return 0; 613 } 614 615 static irqreturn_t ad_sd_trigger_handler(int irq, void *p) 616 { 617 struct iio_poll_func *pf = p; 618 struct iio_dev *indio_dev = pf->indio_dev; 619 const struct iio_scan_type *scan_type = &indio_dev->channels[0].scan_type; 620 struct ad_sigma_delta *sigma_delta = iio_device_get_drvdata(indio_dev); 621 u8 *data = sigma_delta->rx_buf; 622 unsigned int sample_size; 623 unsigned int sample_pos; 624 unsigned int status_pos; 625 unsigned int reg_size; 626 int ret; 627 628 reg_size = BITS_TO_BYTES(scan_type->realbits + scan_type->shift); 629 /* For 24-bit data, there is an extra byte of padding. */ 630 status_pos = reg_size + (reg_size == 3 ? 1 : 0); 631 632 ret = spi_sync_locked(sigma_delta->spi, &sigma_delta->sample_msg); 633 if (ret) 634 goto irq_handled; 635 636 /* 637 * For devices sampling only one channel at 638 * once, there is no need for sample number tracking. 639 */ 640 if (sigma_delta->active_slots == 1) { 641 iio_push_to_buffers_with_timestamp(indio_dev, data, pf->timestamp); 642 goto irq_handled; 643 } 644 645 if (sigma_delta->status_appended) { 646 u8 converted_channel; 647 648 converted_channel = data[status_pos] & sigma_delta->info->status_ch_mask; 649 if (converted_channel != sigma_delta->slots[sigma_delta->current_slot]) { 650 /* 651 * Desync occurred during continuous sampling of multiple channels. 652 * Drop this incomplete sample and start from first channel again. 653 */ 654 655 sigma_delta->current_slot = 0; 656 goto irq_handled; 657 } 658 } 659 660 sample_size = BITS_TO_BYTES(scan_type->storagebits); 661 sample_pos = sample_size * sigma_delta->current_slot; 662 memcpy(&sigma_delta->samples_buf[sample_pos], data, sample_size); 663 sigma_delta->current_slot++; 664 665 if (sigma_delta->current_slot == sigma_delta->active_slots) { 666 sigma_delta->current_slot = 0; 667 iio_push_to_buffers_with_timestamp(indio_dev, sigma_delta->samples_buf, 668 pf->timestamp); 669 } 670 671 irq_handled: 672 iio_trigger_notify_done(indio_dev->trig); 673 ad_sd_enable_irq(sigma_delta); 674 675 return IRQ_HANDLED; 676 } 677 678 static bool ad_sd_validate_scan_mask(struct iio_dev *indio_dev, const unsigned long *mask) 679 { 680 struct ad_sigma_delta *sigma_delta = iio_device_get_drvdata(indio_dev); 681 682 return bitmap_weight(mask, iio_get_masklength(indio_dev)) <= sigma_delta->num_slots; 683 } 684 685 static const struct iio_buffer_setup_ops ad_sd_buffer_setup_ops = { 686 .postenable = &ad_sd_buffer_postenable, 687 .predisable = &ad_sd_buffer_predisable, 688 .validate_scan_mask = &ad_sd_validate_scan_mask, 689 }; 690 691 static irqreturn_t ad_sd_data_rdy_trig_poll(int irq, void *private) 692 { 693 struct ad_sigma_delta *sigma_delta = private; 694 695 /* 696 * AD7124 and a few others use the same physical line for interrupt 697 * reporting (R̅D̅Y̅) and MISO. 698 * As MISO toggles when reading a register, this likely results in a 699 * pending interrupt. This has two consequences: a) The irq might 700 * trigger immediately after it's enabled even though the conversion 701 * isn't done yet; and b) checking the STATUS register's R̅D̅Y̅ flag is 702 * off-limits as reading that would trigger another irq event. 703 * 704 * So read the MOSI line as GPIO (if available) and only trigger the irq 705 * if the line is active. Without such a GPIO assume this is a valid 706 * interrupt. 707 * 708 * Also as disable_irq_nosync() is used to disable the irq, only act if 709 * the irq wasn't disabled before. 710 */ 711 if ((!sigma_delta->rdy_gpiod || gpiod_get_value(sigma_delta->rdy_gpiod)) && 712 ad_sd_disable_irq(sigma_delta)) { 713 complete(&sigma_delta->completion); 714 if (sigma_delta->trig) 715 iio_trigger_poll(sigma_delta->trig); 716 717 return IRQ_HANDLED; 718 } 719 720 return IRQ_NONE; 721 } 722 723 /** 724 * ad_sd_validate_trigger() - validate_trigger callback for ad_sigma_delta devices 725 * @indio_dev: The IIO device 726 * @trig: The new trigger 727 * 728 * Returns: 0 if the 'trig' matches the trigger registered by the ad_sigma_delta 729 * device, -EINVAL otherwise. 730 */ 731 int ad_sd_validate_trigger(struct iio_dev *indio_dev, struct iio_trigger *trig) 732 { 733 struct ad_sigma_delta *sigma_delta = iio_device_get_drvdata(indio_dev); 734 735 if (sigma_delta->trig != trig) 736 return -EINVAL; 737 738 return 0; 739 } 740 EXPORT_SYMBOL_NS_GPL(ad_sd_validate_trigger, "IIO_AD_SIGMA_DELTA"); 741 742 static int devm_ad_sd_probe_trigger(struct device *dev, struct iio_dev *indio_dev) 743 { 744 struct ad_sigma_delta *sigma_delta = iio_device_get_drvdata(indio_dev); 745 unsigned long irq_flags = irq_get_trigger_type(sigma_delta->irq_line); 746 int ret; 747 748 init_completion(&sigma_delta->completion); 749 750 sigma_delta->irq_dis = true; 751 752 /* the IRQ core clears IRQ_DISABLE_UNLAZY flag when freeing an IRQ */ 753 irq_set_status_flags(sigma_delta->irq_line, IRQ_DISABLE_UNLAZY); 754 755 /* Allow overwriting the flags from firmware */ 756 if (!irq_flags) 757 irq_flags = sigma_delta->info->irq_flags; 758 759 ret = devm_request_irq(dev, sigma_delta->irq_line, 760 ad_sd_data_rdy_trig_poll, 761 irq_flags | IRQF_NO_AUTOEN, 762 indio_dev->name, 763 sigma_delta); 764 if (ret) 765 return ret; 766 767 if (ad_sigma_delta_has_spi_offload(sigma_delta)) { 768 sigma_delta->offload_trigger = 769 devm_spi_offload_trigger_get(dev, sigma_delta->offload, 770 SPI_OFFLOAD_TRIGGER_DATA_READY); 771 if (IS_ERR(sigma_delta->offload_trigger)) 772 return dev_err_probe(dev, PTR_ERR(sigma_delta->offload_trigger), 773 "Failed to get SPI offload trigger\n"); 774 } else { 775 if (dev != &sigma_delta->spi->dev) 776 return dev_err_probe(dev, -EFAULT, 777 "Trigger parent should be '%s', got '%s'\n", 778 dev_name(dev), dev_name(&sigma_delta->spi->dev)); 779 780 sigma_delta->trig = devm_iio_trigger_alloc(dev, "%s-dev%d", 781 indio_dev->name, iio_device_id(indio_dev)); 782 if (!sigma_delta->trig) 783 return -ENOMEM; 784 785 iio_trigger_set_drvdata(sigma_delta->trig, sigma_delta); 786 787 ret = devm_iio_trigger_register(dev, sigma_delta->trig); 788 if (ret) 789 return ret; 790 791 /* select default trigger */ 792 indio_dev->trig = iio_trigger_get(sigma_delta->trig); 793 } 794 795 return 0; 796 } 797 798 /** 799 * devm_ad_sd_setup_buffer_and_trigger() - Device-managed buffer & trigger setup 800 * @dev: Device object to which to bind the life-time of the resources attached 801 * @indio_dev: The IIO device 802 */ 803 int devm_ad_sd_setup_buffer_and_trigger(struct device *dev, struct iio_dev *indio_dev) 804 { 805 struct ad_sigma_delta *sigma_delta = iio_device_get_drvdata(indio_dev); 806 int ret; 807 808 sigma_delta->slots = devm_kcalloc(dev, sigma_delta->num_slots, 809 sizeof(*sigma_delta->slots), GFP_KERNEL); 810 if (!sigma_delta->slots) 811 return -ENOMEM; 812 813 if (ad_sigma_delta_has_spi_offload(sigma_delta)) { 814 struct dma_chan *rx_dma; 815 816 rx_dma = devm_spi_offload_rx_stream_request_dma_chan(dev, 817 sigma_delta->offload); 818 if (IS_ERR(rx_dma)) 819 return dev_err_probe(dev, PTR_ERR(rx_dma), 820 "Failed to get RX DMA channel\n"); 821 822 ret = devm_iio_dmaengine_buffer_setup_with_handle(dev, indio_dev, 823 rx_dma, IIO_BUFFER_DIRECTION_IN); 824 if (ret) 825 return dev_err_probe(dev, ret, "Cannot setup DMA buffer\n"); 826 827 indio_dev->setup_ops = &ad_sd_buffer_setup_ops; 828 } else { 829 ret = devm_iio_triggered_buffer_setup(dev, indio_dev, 830 &iio_pollfunc_store_time, 831 &ad_sd_trigger_handler, 832 &ad_sd_buffer_setup_ops); 833 if (ret) 834 return ret; 835 } 836 837 return devm_ad_sd_probe_trigger(dev, indio_dev); 838 } 839 EXPORT_SYMBOL_NS_GPL(devm_ad_sd_setup_buffer_and_trigger, "IIO_AD_SIGMA_DELTA"); 840 841 /** 842 * ad_sd_init() - Initializes a ad_sigma_delta struct 843 * @sigma_delta: The ad_sigma_delta device 844 * @indio_dev: The IIO device which the Sigma Delta device is used for 845 * @spi: The SPI device for the ad_sigma_delta device 846 * @info: Device specific callbacks and options 847 * 848 * This function needs to be called before any other operations are performed on 849 * the ad_sigma_delta struct. 850 */ 851 int ad_sd_init(struct ad_sigma_delta *sigma_delta, struct iio_dev *indio_dev, 852 struct spi_device *spi, const struct ad_sigma_delta_info *info) 853 { 854 sigma_delta->spi = spi; 855 sigma_delta->info = info; 856 857 /* If the field is unset in ad_sigma_delta_info, assume there can only be 1 slot. */ 858 if (!info->num_slots) 859 sigma_delta->num_slots = 1; 860 else 861 sigma_delta->num_slots = info->num_slots; 862 863 if (sigma_delta->num_slots > 1) { 864 if (!indio_dev->info->update_scan_mode) { 865 dev_err(&spi->dev, "iio_dev lacks update_scan_mode().\n"); 866 return -EINVAL; 867 } 868 869 if (!info->disable_all) { 870 dev_err(&spi->dev, "ad_sigma_delta_info lacks disable_all().\n"); 871 return -EINVAL; 872 } 873 } 874 875 spin_lock_init(&sigma_delta->irq_lock); 876 877 if (info->has_named_irqs) { 878 sigma_delta->irq_line = fwnode_irq_get_byname(dev_fwnode(&spi->dev), 879 "rdy"); 880 if (sigma_delta->irq_line < 0) 881 return dev_err_probe(&spi->dev, sigma_delta->irq_line, 882 "Interrupt 'rdy' is required\n"); 883 } else { 884 sigma_delta->irq_line = spi->irq; 885 } 886 887 sigma_delta->rdy_gpiod = devm_gpiod_get_optional(&spi->dev, "rdy", GPIOD_IN); 888 if (IS_ERR(sigma_delta->rdy_gpiod)) 889 return dev_err_probe(&spi->dev, PTR_ERR(sigma_delta->rdy_gpiod), 890 "Failed to find rdy gpio\n"); 891 892 if (sigma_delta->rdy_gpiod && !sigma_delta->irq_line) { 893 sigma_delta->irq_line = gpiod_to_irq(sigma_delta->rdy_gpiod); 894 if (sigma_delta->irq_line < 0) 895 return sigma_delta->irq_line; 896 } 897 898 if (info->supports_spi_offload) { 899 struct spi_offload_config offload_config = { 900 .capability_flags = SPI_OFFLOAD_CAP_TRIGGER | 901 SPI_OFFLOAD_CAP_RX_STREAM_DMA, 902 }; 903 int ret; 904 905 sigma_delta->offload = devm_spi_offload_get(&spi->dev, spi, 906 &offload_config); 907 ret = PTR_ERR_OR_ZERO(sigma_delta->offload); 908 if (ret && ret != -ENODEV) 909 return dev_err_probe(&spi->dev, ret, "Failed to get SPI offload\n"); 910 } 911 912 iio_device_set_drvdata(indio_dev, sigma_delta); 913 914 return 0; 915 } 916 EXPORT_SYMBOL_NS_GPL(ad_sd_init, "IIO_AD_SIGMA_DELTA"); 917 918 MODULE_AUTHOR("Lars-Peter Clausen <lars@metafoo.de>"); 919 MODULE_DESCRIPTION("Analog Devices Sigma-Delta ADCs"); 920 MODULE_LICENSE("GPL v2"); 921 MODULE_IMPORT_NS("IIO_DMAENGINE_BUFFER"); 922