drivers/iio/adc/ad_sigma_delta.c

   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/interrupt.h>
  10 #include <linux/device.h>
  11 #include <linux/kernel.h>
  12 #include <linux/slab.h>
  13 #include <linux/spi/spi.h>
  14 #include <linux/err.h>
  15 #include <linux/module.h>
  16
  17 #include <linux/iio/iio.h>
  18 #include <linux/iio/sysfs.h>
  19 #include <linux/iio/buffer.h>
  20 #include <linux/iio/trigger.h>
  21 #include <linux/iio/trigger_consumer.h>
  22 #include <linux/iio/triggered_buffer.h>
  23 #include <linux/iio/adc/ad_sigma_delta.h>
  24
  25 #include <asm/unaligned.h>
  26
  27
  28 #define AD_SD_COMM_CHAN_MASK    0x3
  29
  30 #define AD_SD_REG_COMM          0x00
  31 #define AD_SD_REG_DATA          0x03
  32
  33 /**
  34  * ad_sd_set_comm() - Set communications register
  35  *
  36  * @sigma_delta: The sigma delta device
  37  * @comm: New value for the communications register
  38  */
  39 void ad_sd_set_comm(struct ad_sigma_delta *sigma_delta, uint8_t comm)
  40 {
  41         /* Some variants use the lower two bits of the communications register
  42          * to select the channel */
  43         sigma_delta->comm = comm & AD_SD_COMM_CHAN_MASK;
  44 }
  45 EXPORT_SYMBOL_GPL(ad_sd_set_comm);
  46
  47 /**
  48  * ad_sd_write_reg() - Write a register
  49  *
  50  * @sigma_delta: The sigma delta device
  51  * @reg: Address of the register
  52  * @size: Size of the register (0-3)
  53  * @val: Value to write to the register
  54  *
  55  * Returns 0 on success, an error code otherwise.
  56  **/
  57 int ad_sd_write_reg(struct ad_sigma_delta *sigma_delta, unsigned int reg,
  58         unsigned int size, unsigned int val)
  59 {
  60         uint8_t *data = sigma_delta->tx_buf;
  61         struct spi_transfer t = {
  62                 .tx_buf         = data,
  63                 .len            = size + 1,
  64                 .cs_change      = sigma_delta->keep_cs_asserted,
  65         };
  66         struct spi_message m;
  67         int ret;
  68
  69         data[0] = (reg << sigma_delta->info->addr_shift) | sigma_delta->comm;
  70
  71         switch (size) {
  72         case 3:
  73                 put_unaligned_be24(val, &data[1]);
  74                 break;
  75         case 2:
  76                 put_unaligned_be16(val, &data[1]);
  77                 break;
  78         case 1:
  79                 data[1] = val;
  80                 break;
  81         case 0:
  82                 break;
  83         default:
  84                 return -EINVAL;
  85         }
  86
  87         spi_message_init(&m);
  88         spi_message_add_tail(&t, &m);
  89
  90         if (sigma_delta->bus_locked)
  91                 ret = spi_sync_locked(sigma_delta->spi, &m);
  92         else
  93                 ret = spi_sync(sigma_delta->spi, &m);
  94
  95         return ret;
  96 }
  97 EXPORT_SYMBOL_GPL(ad_sd_write_reg);
  98
  99 static int ad_sd_read_reg_raw(struct ad_sigma_delta *sigma_delta,
 100         unsigned int reg, unsigned int size, uint8_t *val)
 101 {
 102         uint8_t *data = sigma_delta->tx_buf;
 103         int ret;
 104         struct spi_transfer t[] = {
 105                 {
 106                         .tx_buf = data,
 107                         .len = 1,
 108                 }, {
 109                         .rx_buf = val,
 110                         .len = size,
 111                         .cs_change = sigma_delta->bus_locked,
 112                 },
 113         };
 114         struct spi_message m;
 115
 116         spi_message_init(&m);
 117
 118         if (sigma_delta->info->has_registers) {
 119                 data[0] = reg << sigma_delta->info->addr_shift;
 120                 data[0] |= sigma_delta->info->read_mask;
 121                 data[0] |= sigma_delta->comm;
 122                 spi_message_add_tail(&t[0], &m);
 123         }
 124         spi_message_add_tail(&t[1], &m);
 125
 126         if (sigma_delta->bus_locked)
 127                 ret = spi_sync_locked(sigma_delta->spi, &m);
 128         else
 129                 ret = spi_sync(sigma_delta->spi, &m);
 130
 131         return ret;
 132 }
 133
 134 /**
 135  * ad_sd_read_reg() - Read a register
 136  *
 137  * @sigma_delta: The sigma delta device
 138  * @reg: Address of the register
 139  * @size: Size of the register (1-4)
 140  * @val: Read value
 141  *
 142  * Returns 0 on success, an error code otherwise.
 143  **/
 144 int ad_sd_read_reg(struct ad_sigma_delta *sigma_delta,
 145         unsigned int reg, unsigned int size, unsigned int *val)
 146 {
 147         int ret;
 148
 149         ret = ad_sd_read_reg_raw(sigma_delta, reg, size, sigma_delta->rx_buf);
 150         if (ret < 0)
 151                 goto out;
 152
 153         switch (size) {
 154         case 4:
 155                 *val = get_unaligned_be32(sigma_delta->rx_buf);
 156                 break;
 157         case 3:
 158                 *val = get_unaligned_be24(sigma_delta->rx_buf);
 159                 break;
 160         case 2:
 161                 *val = get_unaligned_be16(sigma_delta->rx_buf);
 162                 break;
 163         case 1:
 164                 *val = sigma_delta->rx_buf[0];
 165                 break;
 166         default:
 167                 ret = -EINVAL;
 168                 break;
 169         }
 170
 171 out:
 172         return ret;
 173 }
 174 EXPORT_SYMBOL_GPL(ad_sd_read_reg);
 175
 176 /**
 177  * ad_sd_reset() - Reset the serial interface
 178  *
 179  * @sigma_delta: The sigma delta device
 180  * @reset_length: Number of SCLKs with DIN = 1
 181  *
 182  * Returns 0 on success, an error code otherwise.
 183  **/
 184 int ad_sd_reset(struct ad_sigma_delta *sigma_delta,
 185         unsigned int reset_length)
 186 {
 187         uint8_t *buf;
 188         unsigned int size;
 189         int ret;
 190
 191         size = DIV_ROUND_UP(reset_length, 8);
 192         buf = kcalloc(size, sizeof(*buf), GFP_KERNEL);
 193         if (!buf)
 194                 return -ENOMEM;
 195
 196         memset(buf, 0xff, size);
 197         ret = spi_write(sigma_delta->spi, buf, size);
 198         kfree(buf);
 199
 200         return ret;
 201 }
 202 EXPORT_SYMBOL_GPL(ad_sd_reset);
 203
 204 int ad_sd_calibrate(struct ad_sigma_delta *sigma_delta,
 205         unsigned int mode, unsigned int channel)
 206 {
 207         int ret;
 208         unsigned long timeout;
 209
 210         ret = ad_sigma_delta_set_channel(sigma_delta, channel);
 211         if (ret)
 212                 return ret;
 213
 214         spi_bus_lock(sigma_delta->spi->master);
 215         sigma_delta->bus_locked = true;
 216         sigma_delta->keep_cs_asserted = true;
 217         reinit_completion(&sigma_delta->completion);
 218
 219         ret = ad_sigma_delta_set_mode(sigma_delta, mode);
 220         if (ret < 0)
 221                 goto out;
 222
 223         sigma_delta->irq_dis = false;
 224         enable_irq(sigma_delta->spi->irq);
 225         timeout = wait_for_completion_timeout(&sigma_delta->completion, 2 * HZ);
 226         if (timeout == 0) {
 227                 sigma_delta->irq_dis = true;
 228                 disable_irq_nosync(sigma_delta->spi->irq);
 229                 ret = -EIO;
 230         } else {
 231                 ret = 0;
 232         }
 233 out:
 234         sigma_delta->keep_cs_asserted = false;
 235         ad_sigma_delta_set_mode(sigma_delta, AD_SD_MODE_IDLE);
 236         sigma_delta->bus_locked = false;
 237         spi_bus_unlock(sigma_delta->spi->master);
 238
 239         return ret;
 240 }
 241 EXPORT_SYMBOL_GPL(ad_sd_calibrate);
 242
 243 /**
 244  * ad_sd_calibrate_all() - Performs channel calibration
 245  * @sigma_delta: The sigma delta device
 246  * @cb: Array of channels and calibration type to perform
 247  * @n: Number of items in cb
 248  *
 249  * Returns 0 on success, an error code otherwise.
 250  **/
 251 int ad_sd_calibrate_all(struct ad_sigma_delta *sigma_delta,
 252         const struct ad_sd_calib_data *cb, unsigned int n)
 253 {
 254         unsigned int i;
 255         int ret;
 256
 257         for (i = 0; i < n; i++) {
 258                 ret = ad_sd_calibrate(sigma_delta, cb[i].mode, cb[i].channel);
 259                 if (ret)
 260                         return ret;
 261         }
 262
 263         return 0;
 264 }
 265 EXPORT_SYMBOL_GPL(ad_sd_calibrate_all);
 266
 267 /**
 268  * ad_sigma_delta_single_conversion() - Performs a single data conversion
 269  * @indio_dev: The IIO device
 270  * @chan: The conversion is done for this channel
 271  * @val: Pointer to the location where to store the read value
 272  *
 273  * Returns: 0 on success, an error value otherwise.
 274  */
 275 int ad_sigma_delta_single_conversion(struct iio_dev *indio_dev,
 276         const struct iio_chan_spec *chan, int *val)
 277 {
 278         struct ad_sigma_delta *sigma_delta = iio_device_get_drvdata(indio_dev);
 279         unsigned int sample, raw_sample;
 280         unsigned int data_reg;
 281         int ret = 0;
 282
 283         if (iio_buffer_enabled(indio_dev))
 284                 return -EBUSY;
 285
 286         mutex_lock(&indio_dev->mlock);
 287         ad_sigma_delta_set_channel(sigma_delta, chan->address);
 288
 289         spi_bus_lock(sigma_delta->spi->master);
 290         sigma_delta->bus_locked = true;
 291         sigma_delta->keep_cs_asserted = true;
 292         reinit_completion(&sigma_delta->completion);
 293
 294         ad_sigma_delta_set_mode(sigma_delta, AD_SD_MODE_SINGLE);
 295
 296         sigma_delta->irq_dis = false;
 297         enable_irq(sigma_delta->spi->irq);
 298         ret = wait_for_completion_interruptible_timeout(
 299                         &sigma_delta->completion, HZ);
 300
 301         if (ret == 0)
 302                 ret = -EIO;
 303         if (ret < 0)
 304                 goto out;
 305
 306         if (sigma_delta->info->data_reg != 0)
 307                 data_reg = sigma_delta->info->data_reg;
 308         else
 309                 data_reg = AD_SD_REG_DATA;
 310
 311         ret = ad_sd_read_reg(sigma_delta, data_reg,
 312                 DIV_ROUND_UP(chan->scan_type.realbits + chan->scan_type.shift, 8),
 313                 &raw_sample);
 314
 315 out:
 316         if (!sigma_delta->irq_dis) {
 317                 disable_irq_nosync(sigma_delta->spi->irq);
 318                 sigma_delta->irq_dis = true;
 319         }
 320
 321         sigma_delta->keep_cs_asserted = false;
 322         ad_sigma_delta_set_mode(sigma_delta, AD_SD_MODE_IDLE);
 323         sigma_delta->bus_locked = false;
 324         spi_bus_unlock(sigma_delta->spi->master);
 325         mutex_unlock(&indio_dev->mlock);
 326
 327         if (ret)
 328                 return ret;
 329
 330         sample = raw_sample >> chan->scan_type.shift;
 331         sample &= (1 << chan->scan_type.realbits) - 1;
 332         *val = sample;
 333
 334         ret = ad_sigma_delta_postprocess_sample(sigma_delta, raw_sample);
 335         if (ret)
 336                 return ret;
 337
 338         return IIO_VAL_INT;
 339 }
 340 EXPORT_SYMBOL_GPL(ad_sigma_delta_single_conversion);
 341
 342 static int ad_sd_buffer_postenable(struct iio_dev *indio_dev)
 343 {
 344         struct ad_sigma_delta *sigma_delta = iio_device_get_drvdata(indio_dev);
 345         unsigned int channel;
 346         int ret;
 347
 348         channel = find_first_bit(indio_dev->active_scan_mask,
 349                                  indio_dev->masklength);
 350         ret = ad_sigma_delta_set_channel(sigma_delta,
 351                 indio_dev->channels[channel].address);
 352         if (ret)
 353                 return ret;
 354
 355         spi_bus_lock(sigma_delta->spi->master);
 356         sigma_delta->bus_locked = true;
 357         sigma_delta->keep_cs_asserted = true;
 358
 359         ret = ad_sigma_delta_set_mode(sigma_delta, AD_SD_MODE_CONTINUOUS);
 360         if (ret)
 361                 goto err_unlock;
 362
 363         sigma_delta->irq_dis = false;
 364         enable_irq(sigma_delta->spi->irq);
 365
 366         return 0;
 367
 368 err_unlock:
 369         spi_bus_unlock(sigma_delta->spi->master);
 370
 371         return ret;
 372 }
 373
 374 static int ad_sd_buffer_postdisable(struct iio_dev *indio_dev)
 375 {
 376         struct ad_sigma_delta *sigma_delta = iio_device_get_drvdata(indio_dev);
 377
 378         reinit_completion(&sigma_delta->completion);
 379         wait_for_completion_timeout(&sigma_delta->completion, HZ);
 380
 381         if (!sigma_delta->irq_dis) {
 382                 disable_irq_nosync(sigma_delta->spi->irq);
 383                 sigma_delta->irq_dis = true;
 384         }
 385
 386         sigma_delta->keep_cs_asserted = false;
 387         ad_sigma_delta_set_mode(sigma_delta, AD_SD_MODE_IDLE);
 388
 389         sigma_delta->bus_locked = false;
 390         return spi_bus_unlock(sigma_delta->spi->master);
 391 }
 392
 393 static irqreturn_t ad_sd_trigger_handler(int irq, void *p)
 394 {
 395         struct iio_poll_func *pf = p;
 396         struct iio_dev *indio_dev = pf->indio_dev;
 397         struct ad_sigma_delta *sigma_delta = iio_device_get_drvdata(indio_dev);
 398         uint8_t *data = sigma_delta->rx_buf;
 399         unsigned int reg_size;
 400         unsigned int data_reg;
 401
 402         reg_size = indio_dev->channels[0].scan_type.realbits +
 403                         indio_dev->channels[0].scan_type.shift;
 404         reg_size = DIV_ROUND_UP(reg_size, 8);
 405
 406         if (sigma_delta->info->data_reg != 0)
 407                 data_reg = sigma_delta->info->data_reg;
 408         else
 409                 data_reg = AD_SD_REG_DATA;
 410
 411         switch (reg_size) {
 412         case 4:
 413         case 2:
 414         case 1:
 415                 ad_sd_read_reg_raw(sigma_delta, data_reg, reg_size, &data[0]);
 416                 break;
 417         case 3:
 418                 /* We store 24 bit samples in a 32 bit word. Keep the upper
 419                  * byte set to zero. */
 420                 ad_sd_read_reg_raw(sigma_delta, data_reg, reg_size, &data[1]);
 421                 break;
 422         }
 423
 424         iio_push_to_buffers_with_timestamp(indio_dev, data, pf->timestamp);
 425
 426         iio_trigger_notify_done(indio_dev->trig);
 427         sigma_delta->irq_dis = false;
 428         enable_irq(sigma_delta->spi->irq);
 429
 430         return IRQ_HANDLED;
 431 }
 432
 433 static const struct iio_buffer_setup_ops ad_sd_buffer_setup_ops = {
 434         .postenable = &ad_sd_buffer_postenable,
 435         .postdisable = &ad_sd_buffer_postdisable,
 436         .validate_scan_mask = &iio_validate_scan_mask_onehot,
 437 };
 438
 439 static irqreturn_t ad_sd_data_rdy_trig_poll(int irq, void *private)
 440 {
 441         struct ad_sigma_delta *sigma_delta = private;
 442
 443         complete(&sigma_delta->completion);
 444         disable_irq_nosync(irq);
 445         sigma_delta->irq_dis = true;
 446         iio_trigger_poll(sigma_delta->trig);
 447
 448         return IRQ_HANDLED;
 449 }
 450
 451 /**
 452  * ad_sd_validate_trigger() - validate_trigger callback for ad_sigma_delta devices
 453  * @indio_dev: The IIO device
 454  * @trig: The new trigger
 455  *
 456  * Returns: 0 if the 'trig' matches the trigger registered by the ad_sigma_delta
 457  * device, -EINVAL otherwise.
 458  */
 459 int ad_sd_validate_trigger(struct iio_dev *indio_dev, struct iio_trigger *trig)
 460 {
 461         struct ad_sigma_delta *sigma_delta = iio_device_get_drvdata(indio_dev);
 462
 463         if (sigma_delta->trig != trig)
 464                 return -EINVAL;
 465
 466         return 0;
 467 }
 468 EXPORT_SYMBOL_GPL(ad_sd_validate_trigger);
 469
 470 static const struct iio_trigger_ops ad_sd_trigger_ops = {
 471 };
 472
 473 static int ad_sd_probe_trigger(struct iio_dev *indio_dev)
 474 {
 475         struct ad_sigma_delta *sigma_delta = iio_device_get_drvdata(indio_dev);
 476         int ret;
 477
 478         sigma_delta->trig = iio_trigger_alloc("%s-dev%d", indio_dev->name,
 479                                                 indio_dev->id);
 480         if (sigma_delta->trig == NULL) {
 481                 ret = -ENOMEM;
 482                 goto error_ret;
 483         }
 484         sigma_delta->trig->ops = &ad_sd_trigger_ops;
 485         init_completion(&sigma_delta->completion);
 486
 487         ret = request_irq(sigma_delta->spi->irq,
 488                           ad_sd_data_rdy_trig_poll,
 489                           sigma_delta->info->irq_flags,
 490                           indio_dev->name,
 491                           sigma_delta);
 492         if (ret)
 493                 goto error_free_trig;
 494
 495         if (!sigma_delta->irq_dis) {
 496                 sigma_delta->irq_dis = true;
 497                 disable_irq_nosync(sigma_delta->spi->irq);
 498         }
 499         sigma_delta->trig->dev.parent = &sigma_delta->spi->dev;
 500         iio_trigger_set_drvdata(sigma_delta->trig, sigma_delta);
 501
 502         ret = iio_trigger_register(sigma_delta->trig);
 503         if (ret)
 504                 goto error_free_irq;
 505
 506         /* select default trigger */
 507         indio_dev->trig = iio_trigger_get(sigma_delta->trig);
 508
 509         return 0;
 510
 511 error_free_irq:
 512         free_irq(sigma_delta->spi->irq, sigma_delta);
 513 error_free_trig:
 514         iio_trigger_free(sigma_delta->trig);
 515 error_ret:
 516         return ret;
 517 }
 518
 519 static void ad_sd_remove_trigger(struct iio_dev *indio_dev)
 520 {
 521         struct ad_sigma_delta *sigma_delta = iio_device_get_drvdata(indio_dev);
 522
 523         iio_trigger_unregister(sigma_delta->trig);
 524         free_irq(sigma_delta->spi->irq, sigma_delta);
 525         iio_trigger_free(sigma_delta->trig);
 526 }
 527
 528 /**
 529  * ad_sd_setup_buffer_and_trigger() -
 530  * @indio_dev: The IIO device
 531  */
 532 int ad_sd_setup_buffer_and_trigger(struct iio_dev *indio_dev)
 533 {
 534         int ret;
 535
 536         ret = iio_triggered_buffer_setup(indio_dev, &iio_pollfunc_store_time,
 537                         &ad_sd_trigger_handler, &ad_sd_buffer_setup_ops);
 538         if (ret)
 539                 return ret;
 540
 541         ret = ad_sd_probe_trigger(indio_dev);
 542         if (ret) {
 543                 iio_triggered_buffer_cleanup(indio_dev);
 544                 return ret;
 545         }
 546
 547         return 0;
 548 }
 549 EXPORT_SYMBOL_GPL(ad_sd_setup_buffer_and_trigger);
 550
 551 /**
 552  * ad_sd_cleanup_buffer_and_trigger() -
 553  * @indio_dev: The IIO device
 554  */
 555 void ad_sd_cleanup_buffer_and_trigger(struct iio_dev *indio_dev)
 556 {
 557         ad_sd_remove_trigger(indio_dev);
 558         iio_triggered_buffer_cleanup(indio_dev);
 559 }
 560 EXPORT_SYMBOL_GPL(ad_sd_cleanup_buffer_and_trigger);
 561
 562 /**
 563  * ad_sd_init() - Initializes a ad_sigma_delta struct
 564  * @sigma_delta: The ad_sigma_delta device
 565  * @indio_dev: The IIO device which the Sigma Delta device is used for
 566  * @spi: The SPI device for the ad_sigma_delta device
 567  * @info: Device specific callbacks and options
 568  *
 569  * This function needs to be called before any other operations are performed on
 570  * the ad_sigma_delta struct.
 571  */
 572 int ad_sd_init(struct ad_sigma_delta *sigma_delta, struct iio_dev *indio_dev,
 573         struct spi_device *spi, const struct ad_sigma_delta_info *info)
 574 {
 575         sigma_delta->spi = spi;
 576         sigma_delta->info = info;
 577         iio_device_set_drvdata(indio_dev, sigma_delta);
 578
 579         return 0;
 580 }
 581 EXPORT_SYMBOL_GPL(ad_sd_init);
 582
 583 MODULE_AUTHOR("Lars-Peter Clausen <lars@metafoo.de>");
 584 MODULE_DESCRIPTION("Analog Devices Sigma-Delta ADCs");
 585 MODULE_LICENSE("GPL v2");