Quelle  ad7298.c

// SPDX-License-Identifier: GPL-2.0-only
/*
 * AD7298 SPI ADC driver
 *
 * Copyright 2011 Analog Devices Inc.
 */

#include <linux/device.h>
#include <linux/kernel.h>
#include <linux/slab.h>
#include <linux/sysfs.h>
#include <linux/spi/spi.h>
#include <linux/regulator/consumer.h>
#include <linux/err.h>
#include <linux/delay.h>
#include <linux/mod_devicetable.h>
#include <linux/module.h>
#include <linux/interrupt.h>
#include <linux/bitops.h>

#include <linux/iio/iio.h>
#include <linux/iio/sysfs.h>
#include <linux/iio/buffer.h>
#include <linux/iio/trigger_consumer.h>
#include <linux/iio/triggered_buffer.h>

#define AD7298_WRITE BIT(15) /* write to the control register */
#define AD7298_REPEAT BIT(14) /* repeated conversion enable */
#define AD7298_CH(x) BIT(13 - (x)) /* channel select */
#define AD7298_TSENSE BIT(5) /* temperature conversion enable */
#define AD7298_EXTREF BIT(2) /* external reference enable */
#define AD7298_TAVG BIT(1) /* temperature sensor averaging enable */
#define AD7298_PDD BIT(0) /* partial power down enable */

#define AD7298_MAX_CHAN  8
#define AD7298_INTREF_mV 2500

#define AD7298_CH_TEMP  9

struct ad7298_state {
 struct spi_device  *spi;
 struct regulator  *reg;
 unsigned   ext_ref;
 struct spi_transfer  ring_xfer[10];
 struct spi_transfer  scan_single_xfer[3];
 struct spi_message  ring_msg;
 struct spi_message  scan_single_msg;
 /*
 * DMA (thus cache coherency maintenance) requires the
 * transfer buffers to live in their own cache lines.
 */
 __be16    rx_buf[12] __aligned(IIO_DMA_MINALIGN);
 __be16    tx_buf[2];
};

#define AD7298_V_CHAN(index)      \
 {        \
  .type = IIO_VOLTAGE,     \
  .indexed = 1,      \
  .channel = index,     \
  .info_mask_separate = BIT(IIO_CHAN_INFO_RAW),  \
  .info_mask_shared_by_type = BIT(IIO_CHAN_INFO_SCALE), \
  .address = index,     \
  .scan_index = index,     \
  .scan_type = {      \
   .sign = 'u',     \
   .realbits = 12,     \
   .storagebits = 16,    \
   .endianness = IIO_BE,    \
  },       \
 }

static const struct iio_chan_spec ad7298_channels[] = {
 {
  .type = IIO_TEMP,
  .indexed = 1,
  .channel = 0,
  .info_mask_separate = BIT(IIO_CHAN_INFO_RAW) |
   BIT(IIO_CHAN_INFO_SCALE) |
   BIT(IIO_CHAN_INFO_OFFSET),
  .address = AD7298_CH_TEMP,
  .scan_index = -1,
  .scan_type = {
   .sign = 's',
   .realbits = 32,
   .storagebits = 32,
  },
 },
 AD7298_V_CHAN(0),
 AD7298_V_CHAN(1),
 AD7298_V_CHAN(2),
 AD7298_V_CHAN(3),
 AD7298_V_CHAN(4),
 AD7298_V_CHAN(5),
 AD7298_V_CHAN(6),
 AD7298_V_CHAN(7),
 IIO_CHAN_SOFT_TIMESTAMP(8),
};

/*
 * ad7298_update_scan_mode() setup the spi transfer buffer for the new scan mask
 */
static int ad7298_update_scan_mode(struct iio_dev *indio_dev,
 const unsigned long *active_scan_mask)
{
 struct ad7298_state *st = iio_priv(indio_dev);
 int i, m;
 unsigned short command;
 int scan_count;

 /* Now compute overall size */
 scan_count = bitmap_weight(active_scan_mask,
       iio_get_masklength(indio_dev));

 command = AD7298_WRITE | st->ext_ref;

 for (i = 0, m = AD7298_CH(0); i < AD7298_MAX_CHAN; i++, m >>= 1)
  if (test_bit(i, active_scan_mask))
   command |= m;

 st->tx_buf[0] = cpu_to_be16(command);

 /* build spi ring message */
 st->ring_xfer[0].tx_buf = &st->tx_buf[0];
 st->ring_xfer[0].len = 2;
 st->ring_xfer[0].cs_change = 1;
 st->ring_xfer[1].tx_buf = &st->tx_buf[1];
 st->ring_xfer[1].len = 2;
 st->ring_xfer[1].cs_change = 1;

 spi_message_init(&st->ring_msg);
 spi_message_add_tail(&st->ring_xfer[0], &st->ring_msg);
 spi_message_add_tail(&st->ring_xfer[1], &st->ring_msg);

 for (i = 0; i < scan_count; i++) {
  st->ring_xfer[i + 2].rx_buf = &st->rx_buf[i];
  st->ring_xfer[i + 2].len = 2;
  st->ring_xfer[i + 2].cs_change = 1;
  spi_message_add_tail(&st->ring_xfer[i + 2], &st->ring_msg);
 }
 /* make sure last transfer cs_change is not set */
 st->ring_xfer[i + 1].cs_change = 0;

 return 0;
}

static irqreturn_t ad7298_trigger_handler(int irq, void *p)
{
 struct iio_poll_func *pf = p;
 struct iio_dev *indio_dev = pf->indio_dev;
 struct ad7298_state *st = iio_priv(indio_dev);
 int b_sent;

 b_sent = spi_sync(st->spi, &st->ring_msg);
 if (b_sent)
  goto done;

 iio_push_to_buffers_with_ts(indio_dev, st->rx_buf, sizeof(st->rx_buf),
        iio_get_time_ns(indio_dev));

done:
 iio_trigger_notify_done(indio_dev->trig);

 return IRQ_HANDLED;
}

static int ad7298_scan_direct(struct ad7298_state *st, unsigned ch)
{
 int ret;
 st->tx_buf[0] = cpu_to_be16(AD7298_WRITE | st->ext_ref |
       (AD7298_CH(0) >> ch));

 ret = spi_sync(st->spi, &st->scan_single_msg);
 if (ret)
  return ret;

 return be16_to_cpu(st->rx_buf[0]);
}

static int ad7298_scan_temp(struct ad7298_state *st, int *val)
{
 int ret;
 __be16 buf;

 buf = cpu_to_be16(AD7298_WRITE | AD7298_TSENSE |
     AD7298_TAVG | st->ext_ref);

 ret = spi_write(st->spi, (u8 *)&buf, 2);
 if (ret)
  return ret;

 buf = cpu_to_be16(0);

 ret = spi_write(st->spi, (u8 *)&buf, 2);
 if (ret)
  return ret;

 usleep_range(101, 1000); /* sleep > 100us */

 ret = spi_read(st->spi, (u8 *)&buf, 2);
 if (ret)
  return ret;

 *val = sign_extend32(be16_to_cpu(buf), 11);

 return 0;
}

static int ad7298_get_ref_voltage(struct ad7298_state *st)
{
 int vref;

 if (st->reg) {
  vref = regulator_get_voltage(st->reg);
  if (vref < 0)
   return vref;

  return vref / 1000;
 } else {
  return AD7298_INTREF_mV;
 }
}

static int ad7298_read_raw(struct iio_dev *indio_dev,
      struct iio_chan_spec const *chan,
      int *val,
      int *val2,
      long m)
{
 int ret;
 struct ad7298_state *st = iio_priv(indio_dev);

 switch (m) {
 case IIO_CHAN_INFO_RAW:
  if (!iio_device_claim_direct(indio_dev))
   return -EBUSY;

  if (chan->address == AD7298_CH_TEMP)
   ret = ad7298_scan_temp(st, val);
  else
   ret = ad7298_scan_direct(st, chan->address);

  iio_device_release_direct(indio_dev);

  if (ret < 0)
   return ret;

  if (chan->address != AD7298_CH_TEMP)
   *val = ret & GENMASK(chan->scan_type.realbits - 1, 0);

  return IIO_VAL_INT;
 case IIO_CHAN_INFO_SCALE:
  switch (chan->type) {
  case IIO_VOLTAGE:
   *val = ad7298_get_ref_voltage(st);
   *val2 = chan->scan_type.realbits;
   return IIO_VAL_FRACTIONAL_LOG2;
  case IIO_TEMP:
   *val = ad7298_get_ref_voltage(st);
   *val2 = 10;
   return IIO_VAL_FRACTIONAL;
  default:
   return -EINVAL;
  }
 case IIO_CHAN_INFO_OFFSET:
  *val = 1093 - 2732500 / ad7298_get_ref_voltage(st);
  return IIO_VAL_INT;
 }
 return -EINVAL;
}

static const struct iio_info ad7298_info = {
 .read_raw = &ad7298_read_raw,
 .update_scan_mode = ad7298_update_scan_mode,
};

static void ad7298_reg_disable(void *data)
{
 struct regulator *reg = data;

 regulator_disable(reg);
}

static int ad7298_probe(struct spi_device *spi)
{
 struct ad7298_state *st;
 struct iio_dev *indio_dev;
 int ret;

 indio_dev = devm_iio_device_alloc(&spi->dev, sizeof(*st));
 if (indio_dev == NULL)
  return -ENOMEM;

 st = iio_priv(indio_dev);

 st->reg = devm_regulator_get_optional(&spi->dev, "vref");
 if (!IS_ERR(st->reg)) {
  st->ext_ref = AD7298_EXTREF;
 } else {
  ret = PTR_ERR(st->reg);
  if (ret != -ENODEV)
   return ret;

  st->reg = NULL;
 }

 if (st->reg) {
  ret = regulator_enable(st->reg);
  if (ret)
   return ret;

  ret = devm_add_action_or_reset(&spi->dev, ad7298_reg_disable,
            st->reg);
  if (ret)
   return ret;
 }

 st->spi = spi;

 indio_dev->name = spi_get_device_id(spi)->name;
 indio_dev->modes = INDIO_DIRECT_MODE;
 indio_dev->channels = ad7298_channels;
 indio_dev->num_channels = ARRAY_SIZE(ad7298_channels);
 indio_dev->info = &ad7298_info;

 /* Setup default message */

 st->scan_single_xfer[0].tx_buf = &st->tx_buf[0];
 st->scan_single_xfer[0].len = 2;
 st->scan_single_xfer[0].cs_change = 1;
 st->scan_single_xfer[1].tx_buf = &st->tx_buf[1];
 st->scan_single_xfer[1].len = 2;
 st->scan_single_xfer[1].cs_change = 1;
 st->scan_single_xfer[2].rx_buf = &st->rx_buf[0];
 st->scan_single_xfer[2].len = 2;

 spi_message_init(&st->scan_single_msg);
 spi_message_add_tail(&st->scan_single_xfer[0], &st->scan_single_msg);
 spi_message_add_tail(&st->scan_single_xfer[1], &st->scan_single_msg);
 spi_message_add_tail(&st->scan_single_xfer[2], &st->scan_single_msg);

 ret = devm_iio_triggered_buffer_setup(&spi->dev, indio_dev, NULL,
   &ad7298_trigger_handler, NULL);
 if (ret)
  return ret;

 return devm_iio_device_register(&spi->dev, indio_dev);
}

static const struct acpi_device_id ad7298_acpi_ids[] = {
 { "INT3494", 0 },
 { }
};
MODULE_DEVICE_TABLE(acpi, ad7298_acpi_ids);

static const struct spi_device_id ad7298_id[] = {
 { "ad7298", 0 },
 { }
};
MODULE_DEVICE_TABLE(spi, ad7298_id);

static struct spi_driver ad7298_driver = {
 .driver = {
  .name = "ad7298",
  .acpi_match_table = ad7298_acpi_ids,
 },
 .probe  = ad7298_probe,
 .id_table = ad7298_id,
};
module_spi_driver(ad7298_driver);

MODULE_AUTHOR("Michael Hennerich <michael.hennerich@analog.com>");
MODULE_DESCRIPTION("Analog Devices AD7298 ADC");
MODULE_LICENSE("GPL v2");