Quelle  ad7091r-base.c   Sprache: C

// SPDX-License-Identifier: GPL-2.0
/*
 * AD7091RX Analog to Digital converter driver
 *
 * Copyright 2014-2019 Analog Devices Inc.
 */

#include <linux/bitops.h>
#include <linux/bitfield.h>
#include <linux/cleanup.h>
#include <linux/iio/events.h>
#include <linux/iio/iio.h>
#include <linux/interrupt.h>
#include <linux/module.h>
#include <linux/regmap.h>
#include <linux/regulator/consumer.h>

#include "ad7091r-base.h"

const struct iio_event_spec ad7091r_events[] = {
 {
  .type = IIO_EV_TYPE_THRESH,
  .dir = IIO_EV_DIR_RISING,
  .mask_separate = BIT(IIO_EV_INFO_VALUE) |
     BIT(IIO_EV_INFO_ENABLE),
 },
 {
  .type = IIO_EV_TYPE_THRESH,
  .dir = IIO_EV_DIR_FALLING,
  .mask_separate = BIT(IIO_EV_INFO_VALUE) |
     BIT(IIO_EV_INFO_ENABLE),
 },
 {
  .type = IIO_EV_TYPE_THRESH,
  .dir = IIO_EV_DIR_EITHER,
  .mask_separate = BIT(IIO_EV_INFO_HYSTERESIS),
 },
};
EXPORT_SYMBOL_NS_GPL(ad7091r_events, "IIO_AD7091R");

static int ad7091r_set_channel(struct ad7091r_state *st, unsigned int channel)
{
 unsigned int dummy;
 int ret;

 /* AD7091R_REG_CHANNEL specified which channels to be converted */
 ret = regmap_write(st->map, AD7091R_REG_CHANNEL,
   BIT(channel) | (BIT(channel) << 8));
 if (ret)
  return ret;

 /*
 * There is a latency of one conversion before the channel conversion
 * sequence is updated
 */
 return regmap_read(st->map, AD7091R_REG_RESULT, &dummy);
}

static int ad7091r_read_one(struct iio_dev *iio_dev,
  unsigned int channel, unsigned int *read_val)
{
 struct ad7091r_state *st = iio_priv(iio_dev);
 unsigned int val;
 int ret;

 ret = ad7091r_set_channel(st, channel);
 if (ret)
  return ret;

 ret = regmap_read(st->map, AD7091R_REG_RESULT, &val);
 if (ret)
  return ret;

 if (st->chip_info->reg_result_chan_id(val) != channel)
  return -EIO;

 *read_val = AD7091R_REG_RESULT_CONV_RESULT(val);

 return 0;
}

static int ad7091r_read_raw(struct iio_dev *iio_dev,
      struct iio_chan_spec const *chan,
      int *val, int *val2, long m)
{
 struct ad7091r_state *st = iio_priv(iio_dev);
 unsigned int read_val;
 int ret;

 guard(mutex)(&st->lock);

 switch (m) {
 case IIO_CHAN_INFO_RAW:
  if (st->mode != AD7091R_MODE_COMMAND)
   return -EBUSY;

  ret = ad7091r_read_one(iio_dev, chan->channel, &read_val);
  if (ret)
   return ret;

  *val = read_val;
  return IIO_VAL_INT;

 case IIO_CHAN_INFO_SCALE:
  if (st->vref) {
   ret = regulator_get_voltage(st->vref);
   if (ret < 0)
    return ret;

   *val = ret / 1000;
  } else {
   *val = st->chip_info->vref_mV;
  }

  *val2 = chan->scan_type.realbits;
  return IIO_VAL_FRACTIONAL_LOG2;

 default:
  return -EINVAL;
 }
}

static int ad7091r_read_event_config(struct iio_dev *indio_dev,
         const struct iio_chan_spec *chan,
         enum iio_event_type type,
         enum iio_event_direction dir)
{
 struct ad7091r_state *st = iio_priv(indio_dev);
 int val, ret;

 switch (dir) {
 case IIO_EV_DIR_RISING:
  ret = regmap_read(st->map,
      AD7091R_REG_CH_HIGH_LIMIT(chan->channel),
      &val);
  if (ret)
   return ret;
  return val != AD7091R_HIGH_LIMIT;
 case IIO_EV_DIR_FALLING:
  ret = regmap_read(st->map,
      AD7091R_REG_CH_LOW_LIMIT(chan->channel),
      &val);
  if (ret)
   return ret;
  return val != AD7091R_LOW_LIMIT;
 default:
  return -EINVAL;
 }
}

static int ad7091r_write_event_config(struct iio_dev *indio_dev,
          const struct iio_chan_spec *chan,
          enum iio_event_type type,
          enum iio_event_direction dir,
          bool state)
{
 struct ad7091r_state *st = iio_priv(indio_dev);

 if (state) {
  return regmap_set_bits(st->map, AD7091R_REG_CONF,
           AD7091R_REG_CONF_ALERT_EN);
 } else {
  /*
 * Set thresholds either to 0 or to 2^12 - 1 as appropriate to
 * prevent alerts and thus disable event generation.
 */
  switch (dir) {
  case IIO_EV_DIR_RISING:
   return regmap_write(st->map,
         AD7091R_REG_CH_HIGH_LIMIT(chan->channel),
         AD7091R_HIGH_LIMIT);
  case IIO_EV_DIR_FALLING:
   return regmap_write(st->map,
         AD7091R_REG_CH_LOW_LIMIT(chan->channel),
         AD7091R_LOW_LIMIT);
  default:
   return -EINVAL;
  }
 }
}

static int ad7091r_read_event_value(struct iio_dev *indio_dev,
        const struct iio_chan_spec *chan,
        enum iio_event_type type,
        enum iio_event_direction dir,
        enum iio_event_info info, int *val, int *val2)
{
 struct ad7091r_state *st = iio_priv(indio_dev);
 int ret;

 switch (info) {
 case IIO_EV_INFO_VALUE:
  switch (dir) {
  case IIO_EV_DIR_RISING:
   ret = regmap_read(st->map,
       AD7091R_REG_CH_HIGH_LIMIT(chan->channel),
       val);
   if (ret)
    return ret;
   return IIO_VAL_INT;
  case IIO_EV_DIR_FALLING:
   ret = regmap_read(st->map,
       AD7091R_REG_CH_LOW_LIMIT(chan->channel),
       val);
   if (ret)
    return ret;
   return IIO_VAL_INT;
  default:
   return -EINVAL;
  }
 case IIO_EV_INFO_HYSTERESIS:
  ret = regmap_read(st->map,
      AD7091R_REG_CH_HYSTERESIS(chan->channel),
      val);
  if (ret)
   return ret;
  return IIO_VAL_INT;
 default:
  return -EINVAL;
 }
}

static int ad7091r_write_event_value(struct iio_dev *indio_dev,
         const struct iio_chan_spec *chan,
         enum iio_event_type type,
         enum iio_event_direction dir,
         enum iio_event_info info, int val, int val2)
{
 struct ad7091r_state *st = iio_priv(indio_dev);

 switch (info) {
 case IIO_EV_INFO_VALUE:
  switch (dir) {
  case IIO_EV_DIR_RISING:
   return regmap_write(st->map,
         AD7091R_REG_CH_HIGH_LIMIT(chan->channel),
         val);
  case IIO_EV_DIR_FALLING:
   return regmap_write(st->map,
         AD7091R_REG_CH_LOW_LIMIT(chan->channel),
         val);
  default:
   return -EINVAL;
  }
 case IIO_EV_INFO_HYSTERESIS:
  return regmap_write(st->map,
        AD7091R_REG_CH_HYSTERESIS(chan->channel),
        val);
 default:
  return -EINVAL;
 }
}

static const struct iio_info ad7091r_info = {
 .read_raw = ad7091r_read_raw,
 .read_event_config = &ad7091r_read_event_config,
 .write_event_config = &ad7091r_write_event_config,
 .read_event_value = &ad7091r_read_event_value,
 .write_event_value = &ad7091r_write_event_value,
};

static irqreturn_t ad7091r_event_handler(int irq, void *private)
{
 struct iio_dev *iio_dev = private;
 struct ad7091r_state *st = iio_priv(iio_dev);
 unsigned int i, read_val;
 int ret;
 s64 timestamp = iio_get_time_ns(iio_dev);

 ret = regmap_read(st->map, AD7091R_REG_ALERT, &read_val);
 if (ret)
  return IRQ_HANDLED;

 for (i = 0; i < st->chip_info->num_channels; i++) {
  if (read_val & BIT(i * 2))
   iio_push_event(iio_dev,
     IIO_UNMOD_EVENT_CODE(IIO_VOLTAGE, i,
      IIO_EV_TYPE_THRESH,
      IIO_EV_DIR_RISING), timestamp);
  if (read_val & BIT(i * 2 + 1))
   iio_push_event(iio_dev,
     IIO_UNMOD_EVENT_CODE(IIO_VOLTAGE, i,
      IIO_EV_TYPE_THRESH,
      IIO_EV_DIR_FALLING), timestamp);
 }

 return IRQ_HANDLED;
}

static void ad7091r_remove(void *data)
{
 struct ad7091r_state *st = data;

 regulator_disable(st->vref);
}

int ad7091r_probe(struct device *dev, const struct ad7091r_init_info *init_info,
    int irq)
{
 struct iio_dev *iio_dev;
 struct ad7091r_state *st;
 int ret;

 iio_dev = devm_iio_device_alloc(dev, sizeof(*st));
 if (!iio_dev)
  return -ENOMEM;

 st = iio_priv(iio_dev);
 st->dev = dev;
 init_info->init_adc_regmap(st, init_info->regmap_config);
 if (IS_ERR(st->map))
  return dev_err_probe(st->dev, PTR_ERR(st->map),
         "Error initializing regmap\n");

 iio_dev->info = &ad7091r_info;
 iio_dev->modes = INDIO_DIRECT_MODE;

 if (init_info->setup) {
  ret = init_info->setup(st);
  if (ret < 0)
   return ret;
 }

 if (irq) {
  st->chip_info = init_info->info_irq;
  ret = regmap_update_bits(st->map, AD7091R_REG_CONF,
      AD7091R_REG_CONF_ALERT_EN, BIT(4));
  if (ret)
   return ret;

  ret = devm_request_threaded_irq(dev, irq, NULL,
      ad7091r_event_handler,
      IRQF_TRIGGER_FALLING |
      IRQF_ONESHOT,
      st->chip_info->name, iio_dev);
  if (ret)
   return ret;
 } else {
  st->chip_info = init_info->info_no_irq;
 }

 iio_dev->name = st->chip_info->name;
 iio_dev->num_channels = st->chip_info->num_channels;
 iio_dev->channels = st->chip_info->channels;

 st->vref = devm_regulator_get_optional(dev, "vref");
 if (IS_ERR(st->vref)) {
  if (PTR_ERR(st->vref) == -EPROBE_DEFER)
   return -EPROBE_DEFER;

  st->vref = NULL;
  /* Enable internal vref */
  ret = regmap_set_bits(st->map, AD7091R_REG_CONF,
          AD7091R_REG_CONF_INT_VREF);
  if (ret)
   return dev_err_probe(st->dev, ret,
          "Error on enable internal reference\n");
 } else {
  ret = regulator_enable(st->vref);
  if (ret)
   return ret;
  ret = devm_add_action_or_reset(dev, ad7091r_remove, st);
  if (ret)
   return ret;
 }

 /* Use command mode by default to convert only desired channels*/
 ret = st->chip_info->set_mode(st, AD7091R_MODE_COMMAND);
 if (ret)
  return ret;

 return devm_iio_device_register(dev, iio_dev);
}
EXPORT_SYMBOL_NS_GPL(ad7091r_probe, "IIO_AD7091R");

bool ad7091r_writeable_reg(struct device *dev, unsigned int reg)
{
 switch (reg) {
 case AD7091R_REG_RESULT:
 case AD7091R_REG_ALERT:
  return false;
 default:
  return true;
 }
}
EXPORT_SYMBOL_NS_GPL(ad7091r_writeable_reg, "IIO_AD7091R");

bool ad7091r_volatile_reg(struct device *dev, unsigned int reg)
{
 /* The volatile ad7091r registers are also the only RO ones. */
 return !ad7091r_writeable_reg(dev, reg);
}
EXPORT_SYMBOL_NS_GPL(ad7091r_volatile_reg, "IIO_AD7091R");

MODULE_AUTHOR("Beniamin Bia ");
MODULE_DESCRIPTION("Analog Devices AD7091Rx multi-channel converters");
MODULE_LICENSE("GPL v2");