Re: [PATCH] staging: iio: adc: Enable driver support for ad799x AD converters

[Jonathan Cameron <jic23@cam.ac.uk>]

On 10/01/10 16:07, Hennerich, Michael wrote:
> Jonathan Cameron wrote on 2010-10-01:
>> Hi Michael,
>>
>> I was pretty much happy with this last time round. Couple of comments
>> inline. The new line missing in the Makefile is probably the only one
>> that I'd advocate doing pre merge.
>>
>> The precision attrs have gone away to be replaced by the more
>> informative type attributes in the scan_elements directory.  This can
>> trivially be done as an additional patch post merge.
>>
>> There are some subtle changes to the event naming (post discussion on
>> lkml) but I'll just do this driver alongside the others in the patch
>> set implementing those changes. This is the first driver providing
>> hyst so that attribute will also need documenting. Again that should
>> happen post merge.
>>
>> I think we can also take advantage of some of the helper functions
>> that are now in place for buffer registration (came out of Barry's
>> work), but that can definitely happen at a later date.
>>
>> So in summary I'm happy to see this merge right now.  The sooner the
>> better as far as I'm concerned
> 
> Hi Jonathan,
> 
> We have a few more iio drivers in our repository. Over the next couple
> of weeks I'm trying to get them out.
Excellent.
> 
>> because I would like it to go in before
>> the event clean up series currently sat in my tree. That way I can
>> update this one at the same time.
> 
> Oops - this patch was already against your tree:
> http://git.kernel.org/?p=linux/kernel/git/jic23/iio_temp.git
 
> Need to check if it works on Greg's staging.
Ah. Shouldn't be too bad.  That's what I get for putting temporary trees
up - that one only exists for testing the adis16260 and adis16350 driver
changes.

> ...It's time to get out of staging
Couple of big bits that I think will need doing before we are ready
to run that gauntlet. Now its mainly stuff around the buffer code.

> 
>> Acked-by: Jonathan Cameron <jic23@cam.ac.uk>
>>
>> Please send on to Greg KH <greg@kroah.com> for him to merge.
>>
>> Thanks,
>>
>> Jonathan
>>
>>> Driver for ad7991, ad7995, ad7999, ad7992, ad7993, ad7994, ad7997
>>> and
>>> ad7998 multichannel ADC.
>>>
>>> Signed-off-by: Michael Hennerich <michael.hennerich@analog.com>
>>> ---
>>>  drivers/staging/iio/adc/Kconfig       |   20 +
>>>  drivers/staging/iio/adc/Makefile      |    4 +
>>>  drivers/staging/iio/adc/ad799x.h      |  157 ++++++
>>>  drivers/staging/iio/adc/ad799x_core.c |  918
>>> +++++++++++++++++++++++++++++++++
>>> drivers/staging/iio/adc/ad799x_ring.c |  246 +++++++++
>>>  5 files changed, 1345 insertions(+), 0 deletions(-)  create mode
>>> 100644 drivers/staging/iio/adc/ad799x.h  create mode 100644
>>> drivers/staging/iio/adc/ad799x_core.c
>>>  create mode 100644 drivers/staging/iio/adc/ad799x_ring.c
>>> diff --git a/drivers/staging/iio/adc/Kconfig
>>> b/drivers/staging/iio/adc/Kconfig index 0835fbc..3ea4da8 100644
>>> --- a/drivers/staging/iio/adc/Kconfig
>>> +++ b/drivers/staging/iio/adc/Kconfig
>>> @@ -26,3 +26,23 @@ config MAX1363_RING_BUFFER
>>>      help
>>>        Say yes here to include ring buffer support in the MAX1363
>>>        ADC driver.
>>> +
>>> +config AD799X
>>> +    tristate "Analog Devices AD799x ADC driver"
>> I'll express my usual anti comment on driver names with wild cards,
>> but as there are hardly any numbers left in the range it is probably
>> fine here.
>>> +    depends on I2C
>>> +    select IIO_TRIGGER if IIO_RING_BUFFER
>>> +    select AD799X_RING_BUFFER
>>> +    help
>>> +      Say yes here to build support for Analog Devices:
>>> +      ad7991, ad7995, ad7999, ad7992, ad7993, ad7994, ad7997, ad7998
>>> +      i2c analog to digital convertors (ADC). Provides direct access
>>> +      via sysfs.
>>> +
>>> +config AD799X_RING_BUFFER
>>> +    bool "Analog Devices AD799x: use ring buffer"
>>> +    depends on AD799X
>>> +    select IIO_RING_BUFFER
>>> +    select IIO_SW_RING
>>> +    help
>>> +      Say yes here to include ring buffer support in the AD799X
>>> +      ADC driver.
>>> diff --git a/drivers/staging/iio/adc/Makefile
>>> b/drivers/staging/iio/adc/Makefile
>>> index 688510f..f4aa63a 100644
>>> --- a/drivers/staging/iio/adc/Makefile
>>> +++ b/drivers/staging/iio/adc/Makefile
>>> @@ -6,3 +6,7 @@ max1363-y := max1363_core.o  max1363-y +=
>>> max1363_ring.o
>>>
>>>  obj-$(CONFIG_MAX1363) += max1363.o
>>> + +ad799x-y := ad799x_core.o +ad799x-$(CONFIG_AD799X_RING_BUFFER) +=
>>> ad799x_ring.o +obj-$(CONFIG_AD799X) += ad799x.o Please add a new line
>>> after this. \ No newline at end of file diff --git
>>> a/drivers/staging/iio/adc/ad799x.h b/drivers/staging/iio/adc/ad799x.h
>>> new file mode 100644 index 0000000..73f3ec5 --- /dev/null +++
>>> b/drivers/staging/iio/adc/ad799x.h @@ -0,0 +1,157 @@ +/* + * Copyright
>>> (C) 2010 Michael Hennerich, Analog Devices Inc. + * Copyright (C)
>>> 2008-2010 Jonathan Cameron + * + * This program is free software; you
>>> can redistribute it and/or +modify + * it under the terms of the GNU
>>> General Public License version 2 +as + * published by the Free Software
>>> Foundation. + * + * ad799x.h + */ + +#ifndef _AD799X_H_ +#define
>>> _AD799X_H_ + +#define AD799X_CHANNEL_SHIFT                   4 + +/* + * AD7991, AD7995
>>> and AD7999 defines  */ + +#define AD7991_REF_SEL                             0x08 +#define
>>> AD7991_FLTR                          0x04 +#define AD7991_BIT_TRIAL_DELAY                    0x02 +#define
>>> AD7991_SAMPLE_DELAY                  0x01 + +/* + * AD7992, AD7993, AD7994, AD7997 and
>>> AD7998 defines  */ + +#define AD7998_FLTR                            0x08 +#define
>>> AD7998_ALERT_EN                              0x04 +#define AD7998_BUSY_ALERT                 0x02 +#define
>>> AD7998_BUSY_ALERT_POL                        0x01 + +#define AD7998_CONV_RES_REG                     0x0
>>> +#define AD7998_ALERT_STAT_REG                       0x1 +#define AD7998_CONF_REG                            0x2
>>> +#define AD7998_CYCLE_TMR_REG                        0x3 +#define
>>> AD7998_DATALOW_CH1_REG                       0x4 +#define AD7998_DATAHIGH_CH1_REG                    0x5
>>> +#define AD7998_HYST_CH1_REG                 0x6 +#define
>>> AD7998_DATALOW_CH2_REG                       0x7 +#define AD7998_DATAHIGH_CH2_REG                    0x8
>>> +#define AD7998_HYST_CH2_REG                 0x9 +#define
>>> AD7998_DATALOW_CH3_REG                       0xA +#define AD7998_DATAHIGH_CH3_REG                    0xB
>>> +#define AD7998_HYST_CH3_REG                 0xC +#define
>>> AD7998_DATALOW_CH4_REG                       0xD +#define AD7998_DATAHIGH_CH4_REG                    0xE
>>> +#define AD7998_HYST_CH4_REG                 0xF + +#define AD7998_CYC_MASK                          0x7
>>> +#define AD7998_CYC_DIS                              0x0 +#define AD7998_CYC_TCONF_32                        0x1
>>> +#define AD7998_CYC_TCONF_64                 0x2 +#define AD7998_CYC_TCONF_128                       0x3
>>> +#define AD7998_CYC_TCONF_256                        0x4 +#define AD7998_CYC_TCONF_512                       0x5
>>> +#define AD7998_CYC_TCONF_1024                       0x6 +#define
>>> AD7998_CYC_TCONF_2048                        0x7 + +#define AD7998_ALERT_STAT_CLEAR                  0xFF +
>>> +/* + * AD7997 and AD7997 defines + */ + +#define
>>> AD7997_8_READ_SINGLE                 0x80 +#define AD7997_8_READ_SEQUENCE                    0x70 +
>>> +enum { +    ad7991, +       ad7995, +       ad7999, +       ad7992, +       ad7993, +       ad7994,
>>> +    ad7997, +       ad7998 +}; + +struct ad799x_state; + +/** + * struct
>>> ad799x_chip_info - chip specifc information + * @num_inputs:         number of
>>> physical inputs on chip + * @bits:           accuracy of the adc in bits + *
>>> @int_vref_mv:        the internal reference voltage + * @monitor_mode:       whether
>>> the chip supports monitor interrupts + * @default_config:    device
>>> default configuration + * @dev_attrs:                pointer to the device attribute
>>> group + * @scan_attrs:               pointer to the scan element attribute group + *
>>> @event_attrs:        pointer to the monitor event attribute group + *
>>> @ad799x_set_scan_mode: function pointer to the device specific +mode
>>> function + + */ +struct ad799x_chip_info { + u8                              num_inputs;
>>> +    u8                              bits; + u16                             int_vref_mv; +  bool                            monitor_mode;
>>> +    u16                             default_config; +       struct attribute_group          *dev_attrs; +   struct
>>> attribute_group              *scan_attrs; +  struct attribute_group          *event_attrs;
>>> +    int (*ad799x_set_scan_mode)     (struct ad799x_state *st, +                                     unsigned
>>> mask); +}; + +struct ad799x_state { +        struct iio_dev                  *indio_dev;
>>> +    struct i2c_client               *client; +      const struct
>>> ad799x_chip_info     *chip_info; +   struct work_struct              poll_work; +    struct
>>> work_struct          work_thresh; +  atomic_t                        protect_ring; + struct
>>> iio_trigger          *trig; +        struct regulator                *reg; + s64                             last_timestamp;
>>> +    u16                             int_vref_mv; +  unsigned                        id; +   char                            *name;
>>> +    u16                             config; +}; + +/* + * TODO: struct ad799x_platform_data needs
>>> to go into +inlude/linux/iio Typo in comment. + */ + +struct
>>> ad799x_platform_data { +     u16                             vref_mv; +}; + +int
>>> ad799x_set_scan_mode(struct ad799x_state *st, unsigned mask); + +#ifdef
>>> CONFIG_AD799X_RING_BUFFER +int ad799x_single_channel_from_ring(struct
>>> ad799x_state *st, long +mask); int
>>> ad799x_register_ring_funcs_and_init(struct iio_dev +*indio_dev); void
>>> ad799x_ring_cleanup(struct iio_dev *indio_dev); +#else /*
>>> CONFIG_AD799X_RING_BUFFER */ int
>>> +ad799x_single_channel_from_ring(struct ad799x_state *st, long mask) {
>>> +    return -EINVAL; +} + + +static inline int
>>> +ad799x_register_ring_funcs_and_init(struct iio_dev *indio_dev) {
>>> +    return 0; +} + +static inline void ad799x_ring_cleanup(struct iio_dev
>>> *indio_dev) { } +#endif /* CONFIG_AD799X_RING_BUFFER */ #endif /*
>>> _AD799X_H_ */ diff --git a/drivers/staging/iio/adc/ad799x_core.c
>>> b/drivers/staging/iio/adc/ad799x_core.c new file mode 100644 index
>>> 0000000..772c664 --- /dev/null +++
>>> b/drivers/staging/iio/adc/ad799x_core.c @@ -0,0 +1,918 @@ +/* + *
>>> iio/adc/ad799x.c + * Copyright (C) 2010 Michael Hennerich, Analog
>>> Devices Inc. + * + * based on iio/adc/max1363 + * Copyright (C)
>>> 2008-2010 Jonathan Cameron + * + * based on
>>> linux/drivers/i2c/chips/max123x + * Copyright (C) 2002-2004 Stefan
>>> Eletzhofer + * + * based on linux/drivers/acron/char/pcf8583.c + *
>>> Copyright (C) 2000 Russell King + * + * This program is free software;
>>> you can redistribute it and/or +modify + * it under the terms of the
>>> GNU General Public License version 2 +as + * published by the Free
>>> Software Foundation. + * + * ad799x.c + * + * Support for ad7991,
>>> ad7995, ad7999, ad7992, ad7993, ad7994, +ad7997, + * ad7998 and similar
>>> chips. + * + */ + +#include <linux/interrupt.h> +#include
>>> <linux/workqueue.h> +#include <linux/device.h> +#include
>>> <linux/kernel.h> +#include <linux/sysfs.h> +#include <linux/list.h>
>>> +#include <linux/i2c.h> +#include <linux/regulator/consumer.h> #include
>>> <linux/slab.h> +#include <linux/types.h> #include <linux/err.h> +
>>> +#include "../iio.h" +#include "../sysfs.h" + +#include
>>> "../ring_generic.h" +#include "adc.h" +#include "ad799x.h" + +/* + *
>>> ad799x register access by I2C + */ +static int ad799x_i2c_read16(struct
>>> ad799x_state *st, u8 reg, u16 +*data) { +    struct i2c_client *client =
>>> st->client; +        int ret = 0; + +        ret = i2c_smbus_read_word_data(client,
>>> reg); +      if (ret < 0) { +                dev_err(&client->dev, "I2C read error\n");
>>> +            return ret; +   } + +   *data = swab16((u16)ret); + +   return 0; +} +
>>> +static int ad799x_i2c_read8(struct ad799x_state *st, u8 reg, u8
>>> +*data) { +  struct i2c_client *client = st->client; +       int ret = 0; +
>>> +    ret = i2c_smbus_read_word_data(client, reg); +  if (ret < 0) {
>>> +            dev_err(&client->dev, "I2C read error\n"); +            return ret; +   } +
>>> +    *data = ret; + +        return 0; +} + +static int ad799x_i2c_write16(struct
>>> ad799x_state *st, u8 reg, u16 +data) { +     struct i2c_client *client =
>>> st->client; +        int ret = 0; + +        ret = i2c_smbus_write_word_data(client,
>>> reg, swab16(data)); +        if (ret < 0) +          dev_err(&client->dev, "I2C write
>>> error\n"); + +       return ret; +} + +static int ad799x_i2c_write8(struct
>>> ad799x_state *st, u8 reg, u8 +data) { +      struct i2c_client *client =
>>> st->client; +        int ret = 0; + +        ret = i2c_smbus_write_byte_data(client,
>>> reg, data); +        if (ret < 0) +          dev_err(&client->dev, "I2C write
>>> error\n"); + +       return ret; +} + +static int
>>> ad799x_scan_el_set_state(struct iio_scan_el *scan_el, +
>>> struct iio_dev *indio_dev, +                                bool state) +{ + struct
>>> ad799x_state *st = indio_dev->dev_data; +    return
>>> ad799x_set_scan_mode(st, st->indio_dev->ring->scan_mask); } + +/* Here
>>> we claim all are 16 bits. This currently does no harm and +saves + * us
>>> a lot of scan element listings */ + +#define
>>> AD799X_SCAN_EL(number)                                               \ +     IIO_SCAN_EL_C(in##number, number, 0,
>>> ad799x_scan_el_set_state); + +static AD799X_SCAN_EL(0); +static
>>> AD799X_SCAN_EL(1); +static AD799X_SCAN_EL(2); +static
>>> AD799X_SCAN_EL(3); +static AD799X_SCAN_EL(4); +static
>>> AD799X_SCAN_EL(5); +static AD799X_SCAN_EL(6); +static
>>> AD799X_SCAN_EL(7); + +static ssize_t ad799x_show_precision(struct
>>> device *dev, +                               struct device_attribute *attr, +                                char *buf) +{
>>> +    struct iio_dev *dev_info = dev_get_drvdata(dev); +      struct
>>> ad799x_state *st = iio_dev_get_devdata(dev_info); +  return sprintf(buf,
>>> "%d\n", st->chip_info->bits); } + +static IIO_DEVICE_ATTR(in_precision,
>>> S_IRUGO, ad799x_show_precision, +                   NULL, 0); + +static int
>>> ad7991_5_9_set_scan_mode(struct ad799x_state *st, unsigned +mask) {
>>> +    return i2c_smbus_write_byte(st->client, +               st->config | (mask <<
>>> AD799X_CHANNEL_SHIFT)); } + +static int ad7992_3_4_set_scan_mode(struct
>>> ad799x_state *st, unsigned +mask) { +        return ad799x_i2c_write8(st,
>>> AD7998_CONF_REG, +           st->config | (mask << AD799X_CHANNEL_SHIFT)); } +
>>> +static int ad7997_8_set_scan_mode(struct ad799x_state *st, unsigned
>>> +mask) { +   return ad799x_i2c_write16(st, AD7998_CONF_REG, +                st->config
>>> | (mask << AD799X_CHANNEL_SHIFT)); } + +int ad799x_set_scan_mode(struct
>>> ad799x_state *st, unsigned mask) { + int ret; + +    if
>>> (st->chip_info->ad799x_set_scan_mode != NULL) { +            ret =
>>> st->chip_info->ad799x_set_scan_mode(st, mask); +             return (ret > 0) ? 0
>>> : ret; +     } + +   return 0; +} + +static ssize_t
>>> ad799x_read_single_channel(struct device *dev, +                                struct
>>> device_attribute *attr, +                               char *buf) +{ +      struct iio_dev
>>> *dev_info = dev_get_drvdata(dev); +  struct ad799x_state *st =
>>> iio_dev_get_devdata(dev_info); +     struct iio_dev_attr *this_attr =
>>> to_iio_dev_attr(attr); +     int ret = 0, len = 0; + u32 data ; +    u16
>>> rxbuf[1]; +  u8 cmd; +       long mask; + +  mutex_lock(&dev_info->mlock);
>>> +    mask = 1 << this_attr->address; +       /* If ring buffer capture is
>>> occuring, query the buffer */ +      if (iio_ring_enabled(dev_info)) {
>>> +            data = ad799x_single_channel_from_ring(st, mask); +             if (data < 0) {
>>> +                    ret = data; +                   goto error_ret; +               } +     } else { +              switch (st->id)
>>> { +          case ad7991: +          case ad7995: +          case ad7999: +                  cmd = st->config
>>> | (mask << AD799X_CHANNEL_SHIFT); +                  break; +                case ad7992: +          case
>>> ad7993: +            case ad7994: +                  cmd = mask << AD799X_CHANNEL_SHIFT;
>>> +                    break; +                case ad7997: +          case ad7998: +                  cmd =
>>> (this_attr->address << +                             AD799X_CHANNEL_SHIFT) |
>>> AD7997_8_READ_SINGLE; +                      break; +                default: +                      cmd = 0; + +            } +             ret
>>> = ad799x_i2c_read16(st, cmd, rxbuf); +               if (ret < 0) +                  goto
>>> error_ret; + +               data = rxbuf[0] & 0xFFF; +      } + +   /* Pretty print the
>>> result */ +  len = sprintf(buf, "%u\n", data); + +error_ret:
>>> +    mutex_unlock(&dev_info->mlock); +       return ret ? ret : len; +} +
>>> +static ssize_t ad799x_read_frequency(struct device *dev, +                                  struct
>>> device_attribute *attr, +                                    char *buf) +{ + struct iio_dev *dev_info
>>> = dev_get_drvdata(dev); +    struct ad799x_state *st =
>>> iio_dev_get_devdata(dev_info); + +   int ret, len = 0; +     u8 val; +       ret =
>>> ad799x_i2c_read8(st, AD7998_CYCLE_TMR_REG, &val); +  if (ret) +              return
>>> ret; + +     val &= AD7998_CYC_MASK; + +     switch (val) { +        case
>>> AD7998_CYC_DIS: +            len = sprintf(buf, "0\n"); +            break; +        case
>>> AD7998_CYC_TCONF_32: +               len = sprintf(buf, "15625\n"); +                break; +        case
>>> AD7998_CYC_TCONF_64: +               len = sprintf(buf, "7812\n"); +         break; +        case
>>> AD7998_CYC_TCONF_128: +              len = sprintf(buf, "3906\n"); +         break; +        case
>>> AD7998_CYC_TCONF_256: +              len = sprintf(buf, "1953\n"); +         break; +        case
>>> AD7998_CYC_TCONF_512: +              len = sprintf(buf, "976\n"); +          break; +        case
>>> AD7998_CYC_TCONF_1024: +             len = sprintf(buf, "488\n"); +          break; +        case
>>> AD7998_CYC_TCONF_2048: +             len = sprintf(buf, "244\n"); +          break; +        }
>>> +    return len; +} + +static ssize_t ad799x_write_frequency(struct device
>>> *dev, +                                       struct device_attribute *attr, +                                        const char *buf,
>>> +                                     size_t len) +{ +       struct iio_dev *dev_info =
>>> dev_get_drvdata(dev); +      struct ad799x_state *st =
>>> iio_dev_get_devdata(dev_info); + +   long val; +     int ret; +      u8 t; + +       ret
>>> = strict_strtol(buf, 10, &val); +    if (ret) +              return ret; +
>>> +    mutex_lock(&dev_info->mlock); + ret = ad799x_i2c_read8(st,
>>> AD7998_CYCLE_TMR_REG, &t); + if (ret) +              goto error_ret_mutex; + /*
>>> Wipe the bits clean */ +     t &= ~AD7998_CYC_MASK; + +      switch (val) {
>>> +    case 15625: +           t |= AD7998_CYC_TCONF_32; +             break; +        case 7812: +            t
>>> |= AD7998_CYC_TCONF_64; +            break; +        case 3906: +            t |=
>>> AD7998_CYC_TCONF_128; +              break; +        case 1953: +            t |=
>>> AD7998_CYC_TCONF_256; +              break; +        case 976: +             t |=
>>> AD7998_CYC_TCONF_512; +              break; +        case 488: +             t |=
>>> AD7998_CYC_TCONF_1024; +             break; +        case 244: +             t |=
>>> AD7998_CYC_TCONF_2048; +             break; +        case  0: +              t |= AD7998_CYC_DIS;
>>> +            break; +        default: +              ret = -EINVAL; +                goto error_ret_mutex; + } +
>>> +    ret = ad799x_i2c_write8(st, AD7998_CYCLE_TMR_REG, t); +
>>> +error_ret_mutex: +  mutex_unlock(&dev_info->mlock); + +     return ret ?
>>> ret : len; +} + + +static ssize_t ad799x_read_channel_config(struct
>>> device *dev, +                                       struct device_attribute *attr, +                                        char *buf) +{
>>> +    struct iio_dev *dev_info = dev_get_drvdata(dev); +      struct
>>> ad799x_state *st = iio_dev_get_devdata(dev_info); +  struct
>>> iio_event_attr *this_attr = to_iio_event_attr(attr); + +     int ret; +      u16
>>> val; +       ret = ad799x_i2c_read16(st, this_attr->mask, &val); +   if (ret)
>>> +            return ret; + + return sprintf(buf, "%d\n", val); +} + +static
>>> ssize_t ad799x_write_channel_config(struct device *dev, +                                     struct
>>> device_attribute *attr, +                                     const char *buf, +                                      size_t len) +{
>>> +    struct iio_dev *dev_info = dev_get_drvdata(dev); +      struct
>>> ad799x_state *st = iio_dev_get_devdata(dev_info); +  struct
>>> iio_event_attr *this_attr = to_iio_event_attr(attr); + +     long val;
>>> +    int ret; + +    ret = strict_strtol(buf, 10, &val); +   if (ret) +              return
>>> ret; + +     mutex_lock(&dev_info->mlock); + ret = ad799x_i2c_write16(st,
>>> this_attr->mask, val); +     mutex_unlock(&dev_info->mlock); + +     return ret
>>> ? ret : len; +} + +static void ad799x_interrupt_bh(struct work_struct
>>> *work_s) { + struct ad799x_state *st = container_of(work_s, +                struct
>>> ad799x_state, work_thresh); +        u8 status; +    int i; + +      if
>>> (ad799x_i2c_read8(st, AD7998_ALERT_STAT_REG, &status)) +             goto err_out;
>>> + +  if (!status) +          goto err_out; + +       ad799x_i2c_write8(st,
>>> AD7998_ALERT_STAT_REG, +AD7998_ALERT_STAT_CLEAR); + +        for (i = 0; i <
>>> 8; i++) { +          if (status & (1 << i)) +                        iio_push_event(st->indio_dev,
>>> 0, +                         i & 0x1 ? +                             IIO_EVENT_CODE_IN_HIGH_THRESH(i >> 1) :
>>> +                            IIO_EVENT_CODE_IN_LOW_THRESH(i >> 1), +                         st->last_timestamp);
>>> +    } + +err_out: + enable_irq(st->client->irq); +} + +static int
>>> ad799x_interrupt(struct iio_dev *dev_info, +         int index, +            s64
>>> timestamp, +         int no_test) +{ +       struct ad799x_state *st =
>>> dev_info->dev_data; + +      st->last_timestamp = timestamp;
>>> +    schedule_work(&st->work_thresh); +      return 0; +} +
>>> +IIO_EVENT_SH(ad799x, &ad799x_interrupt); + +/* Direct read attribtues
>>> */ +static IIO_DEV_ATTR_IN_RAW(0, ad799x_read_single_channel, 0);
>>> +static IIO_DEV_ATTR_IN_RAW(1, ad799x_read_single_channel, 1); +static
>>> IIO_DEV_ATTR_IN_RAW(2, ad799x_read_single_channel, 2); +static
>>> IIO_DEV_ATTR_IN_RAW(3, ad799x_read_single_channel, 3); +static
>>> IIO_DEV_ATTR_IN_RAW(4, ad799x_read_single_channel, 4); +static
>>> IIO_DEV_ATTR_IN_RAW(5, ad799x_read_single_channel, 5); +static
>>> IIO_DEV_ATTR_IN_RAW(6, ad799x_read_single_channel, 6); +static
>>> IIO_DEV_ATTR_IN_RAW(7, ad799x_read_single_channel, 7); + +static
>>> ssize_t ad799x_show_scale(struct device *dev, +                              struct
>>> device_attribute *attr, +                            char *buf) +{ + /* Driver currently only
>>> support internal vref */ +   struct iio_dev *dev_info =
>>> dev_get_drvdata(dev); +      struct ad799x_state *st =
>>> iio_dev_get_devdata(dev_info); +     /* Corresponds to Vref / 2^(bits) */ +
>>> +    if ((1 << (st->chip_info->bits + 1)) +      > st->int_vref_mv)
>>> +            return sprintf(buf, "0.5\n"); + else +          return sprintf(buf, "%d\n",
>>> +                    st->int_vref_mv >> st->chip_info->bits); } + +static
>>> IIO_DEVICE_ATTR(in_scale, S_IRUGO, ad799x_show_scale, NULL, +0); +
>>> +static ssize_t ad799x_show_name(struct device *dev, +                                struct
>>> device_attribute *attr, +                             char *buf) +{ +        struct iio_dev *dev_info
>>> = dev_get_drvdata(dev); +    struct ad799x_state *st =
>>> iio_dev_get_devdata(dev_info); +     return sprintf(buf, "%s\n",
>>> st->client->name); } + +static IIO_DEVICE_ATTR(name, S_IRUGO,
>>> ad799x_show_name, NULL, 0); + +static struct attribute
>>> *ad7991_5_9_3_4_device_attrs[] = {
>>> +    &iio_dev_attr_in0_raw.dev_attr.attr,
>>> +    &iio_dev_attr_in1_raw.dev_attr.attr,
>>> +    &iio_dev_attr_in2_raw.dev_attr.attr,
>>> +    &iio_dev_attr_in3_raw.dev_attr.attr,
>>> +    &iio_dev_attr_name.dev_attr.attr,
>>> +    &iio_dev_attr_in_scale.dev_attr.attr, + NULL +}; + +static struct
>>> attribute_group ad7991_5_9_3_4_dev_attr_group = { +  .attrs =
>>> ad7991_5_9_3_4_device_attrs, }; + +static struct attribute
>>> *ad7991_5_9_3_4_scan_el_attrs[] = { +        &iio_scan_el_in0.dev_attr.attr,
>>> +    &iio_const_attr_in0_index.dev_attr.attr,
>>> +    &iio_scan_el_in1.dev_attr.attr,
>>> +    &iio_const_attr_in1_index.dev_attr.attr,
>>> +    &iio_scan_el_in2.dev_attr.attr,
>>> +    &iio_const_attr_in2_index.dev_attr.attr,
>>> +    &iio_scan_el_in3.dev_attr.attr,
>>> +    &iio_const_attr_in3_index.dev_attr.attr,
>> The precision attribute has been replaced by the _type attributes in the
>> scan_elements directory as they give all the information in one consice
>> form.  Lets do that change as an additional patch post merge though.
>>
>>> +    &iio_dev_attr_in_precision.dev_attr.attr,
>>> +    NULL,
>>> +};
>>> +
>>> +static struct attribute_group ad7991_5_9_3_4_scan_el_group = {
>>> +    .name = "scan_elements",
>>> +    .attrs = ad7991_5_9_3_4_scan_el_attrs, };
>>> +
>>> +static struct attribute *ad7992_device_attrs[] = {
>>> +    &iio_dev_attr_in0_raw.dev_attr.attr,
>>> +    &iio_dev_attr_in1_raw.dev_attr.attr,
>>> +    &iio_dev_attr_name.dev_attr.attr,
>>> +    &iio_dev_attr_in_scale.dev_attr.attr,
>>> +    NULL
>>> +};
>>> +
>>> +static struct attribute_group ad7992_dev_attr_group = {
>>> +    .attrs = ad7992_device_attrs,
>>> +};
>>> +
>>> +static struct attribute *ad7992_scan_el_attrs[] = {
>>> +    &iio_scan_el_in0.dev_attr.attr,
>>> +    &iio_const_attr_in0_index.dev_attr.attr,
>>> +    &iio_scan_el_in1.dev_attr.attr,
>>> +    &iio_const_attr_in1_index.dev_attr.attr,
>>> +    &iio_dev_attr_in_precision.dev_attr.attr,
>>> +    NULL,
>>> +};
>>> +
>>> +static struct attribute_group ad7992_scan_el_group = {
>>> +    .name = "scan_elements",
>>> +    .attrs = ad7992_scan_el_attrs,
>>> +};
>>> +
>>> +static struct attribute *ad7997_8_device_attrs[] = {
>>> +    &iio_dev_attr_in0_raw.dev_attr.attr,
>>> +    &iio_dev_attr_in1_raw.dev_attr.attr,
>>> +    &iio_dev_attr_in2_raw.dev_attr.attr,
>>> +    &iio_dev_attr_in3_raw.dev_attr.attr,
>>> +    &iio_dev_attr_in4_raw.dev_attr.attr,
>>> +    &iio_dev_attr_in5_raw.dev_attr.attr,
>>> +    &iio_dev_attr_in6_raw.dev_attr.attr,
>>> +    &iio_dev_attr_in7_raw.dev_attr.attr,
>>> +    &iio_dev_attr_name.dev_attr.attr,
>>> +    &iio_dev_attr_in_scale.dev_attr.attr,
>>> +    NULL
>>> +};
>>> +
>>> +static struct attribute_group ad7997_8_dev_attr_group = {
>>> +    .attrs = ad7997_8_device_attrs,
>>> +};
>>> +
>>> +static struct attribute *ad7997_8_scan_el_attrs[] = {
>>> +    &iio_scan_el_in0.dev_attr.attr,
>>> +    &iio_const_attr_in0_index.dev_attr.attr,
>>> +    &iio_scan_el_in1.dev_attr.attr,
>>> +    &iio_const_attr_in1_index.dev_attr.attr,
>>> +    &iio_scan_el_in2.dev_attr.attr,
>>> +    &iio_const_attr_in2_index.dev_attr.attr,
>>> +    &iio_scan_el_in3.dev_attr.attr,
>>> +    &iio_const_attr_in3_index.dev_attr.attr,
>>> +    &iio_scan_el_in4.dev_attr.attr,
>>> +    &iio_const_attr_in4_index.dev_attr.attr,
>>> +    &iio_scan_el_in5.dev_attr.attr,
>>> +    &iio_const_attr_in5_index.dev_attr.attr,
>>> +    &iio_scan_el_in6.dev_attr.attr,
>>> +    &iio_const_attr_in6_index.dev_attr.attr,
>>> +    &iio_scan_el_in7.dev_attr.attr,
>>> +    &iio_const_attr_in7_index.dev_attr.attr,
>>> +    &iio_dev_attr_in_precision.dev_attr.attr,
>>> +    NULL,
>>> +};
>>> +
>>> +static struct attribute_group ad7997_8_scan_el_group = {
>>> +    .name = "scan_elements",
>>> +    .attrs = ad7997_8_scan_el_attrs,
>>> +};
>>> +
>>> +IIO_EVENT_ATTR_SH(in0_thresh_low_value,
>>> +              iio_event_ad799x,
>>> +              ad799x_read_channel_config,
>>> +              ad799x_write_channel_config,
>>> +              AD7998_DATALOW_CH1_REG);
>>> +
>>> +IIO_EVENT_ATTR_SH(in0_thresh_high_value,
>>> +              iio_event_ad799x,
>>> +              ad799x_read_channel_config,
>>> +              ad799x_write_channel_config,
>>> +              AD7998_DATAHIGH_CH1_REG);
>>> +
>>> +IIO_EVENT_ATTR_SH(in0_thresh_both_hyst_raw,
>>> +              iio_event_ad799x,
>>> +              ad799x_read_channel_config,
>>> +              ad799x_write_channel_config,
>>> +              AD7998_HYST_CH1_REG);
>>> +
>>> +IIO_EVENT_ATTR_SH(in1_thresh_low_value,
>>> +              iio_event_ad799x,
>>> +              ad799x_read_channel_config,
>>> +              ad799x_write_channel_config,
>>> +              AD7998_DATALOW_CH2_REG);
>>> +
>>> +IIO_EVENT_ATTR_SH(in1_thresh_high_value,
>>> +              iio_event_ad799x,
>>> +              ad799x_read_channel_config,
>>> +              ad799x_write_channel_config,
>>> +              AD7998_DATAHIGH_CH2_REG);
>>> +
>>> +IIO_EVENT_ATTR_SH(in1_thresh_both_hyst_raw,
>>> +              iio_event_ad799x,
>>> +              ad799x_read_channel_config,
>>> +              ad799x_write_channel_config,
>>> +              AD7998_HYST_CH2_REG);
>>> +
>>> +IIO_EVENT_ATTR_SH(in2_thresh_low_value,
>>> +              iio_event_ad799x,
>>> +              ad799x_read_channel_config,
>>> +              ad799x_write_channel_config,
>>> +              AD7998_DATALOW_CH3_REG);
>>> +
>>> +IIO_EVENT_ATTR_SH(in2_thresh_high_value,
>>> +              iio_event_ad799x,
>>> +              ad799x_read_channel_config,
>>> +              ad799x_write_channel_config,
>>> +              AD7998_DATAHIGH_CH3_REG);
>>> +
>>> +IIO_EVENT_ATTR_SH(in2_thresh_both_hyst_raw,
>>> +              iio_event_ad799x,
>>> +              ad799x_read_channel_config,
>>> +              ad799x_write_channel_config,
>>> +              AD7998_HYST_CH3_REG);
>>> +
>>> +IIO_EVENT_ATTR_SH(in3_thresh_low_value,
>>> +              iio_event_ad799x,
>>> +              ad799x_read_channel_config,
>>> +              ad799x_write_channel_config,
>>> +              AD7998_DATALOW_CH4_REG);
>>> +
>>> +IIO_EVENT_ATTR_SH(in3_thresh_high_value,
>>> +              iio_event_ad799x,
>>> +              ad799x_read_channel_config,
>>> +              ad799x_write_channel_config,
>>> +              AD7998_DATAHIGH_CH4_REG);
>>> +
>>> +IIO_EVENT_ATTR_SH(in3_thresh_both_hyst_raw,
>>> +              iio_event_ad799x,
>>> +              ad799x_read_channel_config,
>>> +              ad799x_write_channel_config,
>>> +              AD7998_HYST_CH4_REG);
>>> +
>>> +static IIO_DEV_ATTR_SAMP_FREQ(S_IWUSR | S_IRUGO,
>>> +                          ad799x_read_frequency,
>>> +                          ad799x_write_frequency);
>>> +static IIO_CONST_ATTR_SAMP_FREQ_AVAIL("15625 7812 3906 1953 976 488
>>> +244 0");
>>> +
>>> +static struct attribute *ad7993_4_7_8_event_attributes[] = {
>>> +    &iio_event_attr_in0_thresh_low_value.dev_attr.attr,
>>> +    &iio_event_attr_in0_thresh_high_value.dev_attr.attr,
>>> +    &iio_event_attr_in0_thresh_both_hyst_raw.dev_attr.attr,
>>> +    &iio_event_attr_in1_thresh_low_value.dev_attr.attr,
>>> +    &iio_event_attr_in1_thresh_high_value.dev_attr.attr,
>>> +    &iio_event_attr_in1_thresh_both_hyst_raw.dev_attr.attr,
>>> +    &iio_event_attr_in2_thresh_low_value.dev_attr.attr,
>>> +    &iio_event_attr_in2_thresh_high_value.dev_attr.attr,
>>> +    &iio_event_attr_in2_thresh_both_hyst_raw.dev_attr.attr,
>>> +    &iio_event_attr_in3_thresh_low_value.dev_attr.attr,
>>> +    &iio_event_attr_in3_thresh_high_value.dev_attr.attr,
>>> +    &iio_event_attr_in3_thresh_both_hyst_raw.dev_attr.attr,
>>> +    &iio_dev_attr_sampling_frequency.dev_attr.attr,
>>> +    &iio_const_attr_sampling_frequency_available.dev_attr.attr,
>>> +    NULL,
>>> +};
>>> +
>>> +static struct attribute_group ad7993_4_7_8_event_attrs_group = {
>>> +    .attrs = ad7993_4_7_8_event_attributes, };
>>> +
>>> +static struct attribute *ad7992_event_attributes[] = {
>>> +    &iio_event_attr_in0_thresh_low_value.dev_attr.attr,
>>> +    &iio_event_attr_in0_thresh_high_value.dev_attr.attr,
>>> +    &iio_event_attr_in0_thresh_both_hyst_raw.dev_attr.attr,
>>> +    &iio_event_attr_in1_thresh_low_value.dev_attr.attr,
>>> +    &iio_event_attr_in1_thresh_high_value.dev_attr.attr,
>>> +    &iio_event_attr_in1_thresh_both_hyst_raw.dev_attr.attr,
>>> +    &iio_dev_attr_sampling_frequency.dev_attr.attr,
>>> +    &iio_const_attr_sampling_frequency_available.dev_attr.attr,
>>> +    NULL,
>>> +};
>>> +
>>> +static struct attribute_group ad7992_event_attrs_group = {
>>> +    .attrs = ad7992_event_attributes,
>>> +};
>>> +
>>> +static const struct ad799x_chip_info ad799x_chip_info_tbl[] = {
>>> +    [ad7991] = {
>>> +            .num_inputs = 4,
>>> +            .bits = 12,
>>> +            .int_vref_mv = 4096,
>>> +            .dev_attrs = &ad7991_5_9_3_4_dev_attr_group,
>>> +            .scan_attrs = &ad7991_5_9_3_4_scan_el_group,
>>> +            .ad799x_set_scan_mode = ad7991_5_9_set_scan_mode,
>>> +    },
>>> +    [ad7995] = {
>>> +            .num_inputs = 4,
>>> +            .bits = 10,
>>> +            .int_vref_mv = 1024,
>>> +            .dev_attrs = &ad7991_5_9_3_4_dev_attr_group,
>>> +            .scan_attrs = &ad7991_5_9_3_4_scan_el_group,
>>> +            .ad799x_set_scan_mode = ad7991_5_9_set_scan_mode,
>>> +    },
>>> +    [ad7999] = {
>>> +            .num_inputs = 4,
>>> +            .bits = 10,
>>> +            .int_vref_mv = 1024,
>>> +            .dev_attrs = &ad7991_5_9_3_4_dev_attr_group,
>>> +            .scan_attrs = &ad7991_5_9_3_4_scan_el_group,
>>> +            .ad799x_set_scan_mode = ad7991_5_9_set_scan_mode,
>>> +    },
>>> +    [ad7992] = {
>>> +            .num_inputs = 2,
>>> +            .bits = 12,
>>> +            .int_vref_mv = 4096,
>>> +            .monitor_mode = true,
>>> +            .default_config = AD7998_ALERT_EN,
>>> +            .dev_attrs = &ad7992_dev_attr_group,
>>> +            .scan_attrs = &ad7992_scan_el_group,
>>> +            .event_attrs = &ad7992_event_attrs_group,
>>> +            .ad799x_set_scan_mode = ad7992_3_4_set_scan_mode,
>>> +    },
>>> +    [ad7993] = {
>>> +            .num_inputs = 4,
>>> +            .bits = 10,
>>> +            .int_vref_mv = 1024,
>>> +            .monitor_mode = true,
>>> +            .default_config = AD7998_ALERT_EN,
>>> +            .dev_attrs = &ad7991_5_9_3_4_dev_attr_group,
>>> +            .scan_attrs = &ad7991_5_9_3_4_scan_el_group,
>>> +            .event_attrs = &ad7993_4_7_8_event_attrs_group,
>>> +            .ad799x_set_scan_mode = ad7992_3_4_set_scan_mode,
>>> +    },
>>> +    [ad7994] = {
>>> +            .num_inputs = 4,
>>> +            .bits = 12,
>>> +            .int_vref_mv = 4096,
>>> +            .monitor_mode = true,
>>> +            .default_config = AD7998_ALERT_EN,
>>> +            .dev_attrs = &ad7991_5_9_3_4_dev_attr_group,
>>> +            .scan_attrs = &ad7991_5_9_3_4_scan_el_group,
>>> +            .event_attrs = &ad7993_4_7_8_event_attrs_group,
>>> +            .ad799x_set_scan_mode = ad7992_3_4_set_scan_mode,
>>> +    },
>>> +    [ad7997] = {
>>> +            .num_inputs = 8,
>>> +            .bits = 10,
>>> +            .int_vref_mv = 1024,
>>> +            .monitor_mode = true,
>>> +            .default_config = AD7998_ALERT_EN,
>>> +            .dev_attrs = &ad7997_8_dev_attr_group,
>>> +            .scan_attrs = &ad7997_8_scan_el_group,
>>> +            .event_attrs = &ad7993_4_7_8_event_attrs_group,
>>> +            .ad799x_set_scan_mode = ad7997_8_set_scan_mode,
>>> +    },
>>> +    [ad7998] = {
>>> +            .num_inputs = 8,
>>> +            .bits = 12,
>>> +            .int_vref_mv = 4096,
>>> +            .monitor_mode = true,
>>> +            .default_config = AD7998_ALERT_EN,
>>> +            .dev_attrs = &ad7997_8_dev_attr_group,
>>> +            .scan_attrs = &ad7997_8_scan_el_group,
>>> +            .event_attrs = &ad7993_4_7_8_event_attrs_group,
>>> +            .ad799x_set_scan_mode = ad7997_8_set_scan_mode,
>>> +    },
>>> +};
>>> +
>>> +static int __devinit ad799x_probe(struct i2c_client *client,
>>> +                               const struct i2c_device_id *id) {
>>> +    int ret, regdone = 0;
>>> +    struct ad799x_platform_data *pdata = client->dev.platform_data;
>>> +    struct ad799x_state *st = kzalloc(sizeof(*st), GFP_KERNEL);
>>> +    if (st == NULL) {
>>> +            ret = -ENOMEM;
>>> +            goto error_ret;
>>> +    }
>>> +
>>> +    /* this is only used for device removal purposes */
>>> +    i2c_set_clientdata(client, st);
>>> +
>>> +    atomic_set(&st->protect_ring, 0);
>>> +    st->id = id->driver_data;
>>> +    st->chip_info = &ad799x_chip_info_tbl[st->id];
>>> +    st->config = st->chip_info->default_config;
>>> +
>>> +    /* TODO: Add pdata options for filtering and bit delay */
>> We also need to add userspace attributes to cover filtering for these
>> devices.  However, that is definitely a discussion for another day!
>>> + +  if (pdata) +            st->int_vref_mv = pdata->vref_mv; +     else
>>> +            st->int_vref_mv = st->chip_info->int_vref_mv; + +       st->reg =
>>> regulator_get(&client->dev, "vcc"); +        if (!IS_ERR(st->reg)) { +               ret =
>>> regulator_enable(st->reg); +         if (ret) +                      goto error_put_reg; +   }
>>> +    st->client = client; + +        st->indio_dev = iio_allocate_device(); +        if
>>> (st->indio_dev == NULL) { +          ret = -ENOMEM; +                goto error_disable_reg;
>>> +    } + +   /* Estabilish that the iio_dev is a child of the i2c device */
>>> +    st->indio_dev->dev.parent = &client->dev; +     st->indio_dev->attrs =
>>> st->chip_info->dev_attrs; +  st->indio_dev->event_attrs =
>>> st->chip_info->event_attrs; + +      st->indio_dev->dev_data = (void *)(st);
>>> +    st->indio_dev->driver_module = THIS_MODULE; +   st->indio_dev->modes =
>>> INDIO_DIRECT_MODE; + st->indio_dev->num_interrupt_lines = 1; + +     ret =
>>> ad799x_set_scan_mode(st, 0); +       if (ret) +              goto error_free_device; +
>>> +    ret = ad799x_register_ring_funcs_and_init(st->indio_dev); +     if (ret)
>>> +            goto error_free_device; + +     ret =
>>> iio_device_register(st->indio_dev); +        if (ret) +              goto
>>> error_cleanup_ring; +        regdone = 1; + +        ret =
>>> iio_ring_buffer_register(st->indio_dev->ring, 0); +  if (ret) +              goto
>>> error_cleanup_ring; + +      if (client->irq > 0 &&
>>> st->chip_info->monitor_mode) { +             INIT_WORK(&st->work_thresh,
>>> ad799x_interrupt_bh); + +            ret =
>>> iio_register_interrupt_line(client->irq, +                           st->indio_dev, +                                0,
>>> +                            IRQF_TRIGGER_FALLING, +                         client->name); +                if (ret) +                      goto
>>> error_cleanup_ring; + +              /* +             * The event handler list element refer
>>> to iio_event_ad799x. +                * All event attributes bind to the same event
>>> handler. +            * So, only register event handler once. +               */
>>> +            iio_add_event_to_list(&iio_event_ad799x,
>>> +                            &st->indio_dev->interrupts[0]->ev_list); +      } + +   return 0;
>>> +error_cleanup_ring: +       ad799x_ring_cleanup(st->indio_dev);
>>> +error_free_device: +        if (!regdone) +         iio_free_device(st->indio_dev);
>>> +    else +          iio_device_unregister(st->indio_dev); +error_disable_reg:
>>> +    if (!IS_ERR(st->reg)) +         regulator_disable(st->reg); +error_put_reg:
>>> +    if (!IS_ERR(st->reg)) +         regulator_put(st->reg); +       kfree(st);
>>> +error_ret: +        return ret; +} + +static __devexit int
>>> ad799x_remove(struct i2c_client *client) { + struct ad799x_state *st =
>>> i2c_get_clientdata(client); +        struct iio_dev *indio_dev =
>>> st->indio_dev; + +   if (client->irq > 0 && st->chip_info->monitor_mode)
>>> +            iio_unregister_interrupt_line(indio_dev, 0); +
>>> +    iio_ring_buffer_unregister(indio_dev->ring);
>>> +    ad799x_ring_cleanup(indio_dev); +       iio_device_unregister(indio_dev);
>>> +    if (!IS_ERR(st->reg)) { +               regulator_disable(st->reg);
>>> +            regulator_put(st->reg); +       } +     kfree(st); + +  return 0; +} + +static
>>> const struct i2c_device_id ad799x_id[] = { + { "ad7991", ad7991 }, + {
>>> "ad7995", ad7995 }, +        { "ad7999", ad7999 }, + { "ad7992", ad7992 }, + {
>>> "ad7993", ad7993 }, +        { "ad7994", ad7994 }, + { "ad7997", ad7997 }, + {
>>> "ad7998", ad7998 }, +        {} +}; + +MODULE_DEVICE_TABLE(i2c, ad799x_id); +
>>> +static struct i2c_driver ad799x_driver = { +        .driver = { +           .name =
>>> "ad799x", +  }, +    .probe = ad799x_probe, +        .remove =
>>> __devexit_p(ad799x_remove), +        .id_table = ad799x_id, +}; + +static
>>> __init int ad799x_init(void) { +     return i2c_add_driver(&ad799x_driver);
>>> } + +static __exit void ad799x_exit(void) {
>>> +    i2c_del_driver(&ad799x_driver); +} + +MODULE_AUTHOR("Michael
>>> Hennerich +<hennerich@blackfin.uclinux.org>");
>>> +MODULE_DESCRIPTION("Analog Devices AD799x ADC"); +MODULE_LICENSE("GPL
>>> v2"); MODULE_ALIAS("i2c:ad799x"); + +module_init(ad799x_init);
>>> +module_exit(ad799x_exit); diff --git
>>> a/drivers/staging/iio/adc/ad799x_ring.c
>>> b/drivers/staging/iio/adc/ad799x_ring.c new file mode 100644 index
>>> 0000000..0f2041a --- /dev/null +++
>>> b/drivers/staging/iio/adc/ad799x_ring.c @@ -0,0 +1,246 @@ +/* + *
>>> Copyright (C) 2010 Michael Hennerich, Analog Devices Inc. + * Copyright
>>> (C) 2008-2010 Jonathan Cameron + * + * This program is free software;
>>> you can redistribute it and/or +modify + * it under the terms of the
>>> GNU General Public License version 2 +as + * published by the Free
>>> Software Foundation. + * + * ad799x_ring.c + */ + +#include
>>> <linux/interrupt.h> +#include <linux/workqueue.h> +#include
>>> <linux/device.h> +#include <linux/slab.h> +#include <linux/kernel.h>
>>> +#include <linux/sysfs.h> +#include <linux/list.h> +#include
>>> <linux/i2c.h> +#include <linux/bitops.h> + +#include "../iio.h"
>>> +#include "../ring_generic.h" +#include "../ring_sw.h" +#include
>>> "../trigger.h" +#include "../sysfs.h" + +#include "ad799x.h" + +int
>>> ad799x_single_channel_from_ring(struct ad799x_state *st, long +mask) {
>>> +    unsigned long numvals; +        int count = 0, ret; +   u16 *ring_data; +       if
>>> (!(st->indio_dev->ring->scan_mask & mask)) { +               ret = -EBUSY; +         goto
>>> error_ret; + } +     numvals = st->indio_dev->ring->scan_count; +
>>> +    ring_data = kmalloc(numvals*2, GFP_KERNEL); +   if (ring_data == NULL)
>>> { +          ret = -ENOMEM; +                goto error_ret; +       } +     ret =
>>> st->indio_dev->ring->access.read_last(st->indio_dev->ring, +                                         (u8
>>> *) ring_data); +     if (ret) +              goto error_free_ring_data; +    /* Need a
>>> count of channels prior to this one */ +     mask >>= 1; +   while (mask) {
>>> +            if (mask & st->indio_dev->ring->scan_mask) +                    count++; +              mask >>=
>>> 1; + } + +   ret = be16_to_cpu(ring_data[count]) & 0xFFF; +
>>> +error_free_ring_data: +     kfree(ring_data); +error_ret: + return ret; +}
>>> + +/** + * ad799x_ring_preenable() setup the parameters of the ring
>>> before +enabling + * + * The complex nature of the setting of the nuber
>>> of bytes per +datum is due + * to this driver currently ensuring that
>>> the timestamp is stored +at an 8 + * byte boundary. + **/ +static int
>>> ad799x_ring_preenable(struct iio_dev *indio_dev) { + struct
>>> ad799x_state *st = indio_dev->dev_data; +    size_t d_size; +        unsigned
>>> long numvals; + +    /* +     * Need to figure out the current mode based
>>> upon the requested +  * scan mask in iio_dev +        */ + + if (st->id ==
>>> ad7997 || st->id == ad7998) +                ad799x_set_scan_mode(st,
>>> st->indio_dev->ring->scan_mask); + + numvals =
>>> st->indio_dev->ring->scan_count; + + if
>>> (indio_dev->ring->access.set_bytes_per_datum) { +            d_size = numvals*2 +
>>> sizeof(s64); +               if (d_size % 8) +                       d_size += 8 - (d_size % 8);
>>> +            indio_dev->ring->access.set_bytes_per_datum(indio_dev- ring,
>>> +                                                        d_size); +  } + +   return 0; +} + +/** + *
>>> ad799x_poll_func_th() th of trigger launched polling to ring +buffer +
>>> * + * As sampling only occurs on i2c comms occuring, leave
>>> +timestamping until + * then.  Some triggers will generate their own
>>> time stamp. +Currently + * there is no way of notifying them when no
>>> one cares. + **/ +static void ad799x_poll_func_th(struct iio_dev
>>> *indio_dev, s64 +time) { +   struct ad799x_state *st =
>>> indio_dev->dev_data; + +     schedule_work(&st->poll_work); + +      return; +}
>>> +/** + * ad799x_poll_bh_to_ring() bh of trigger launched polling to
>>> ring buffer + * @work_s:     the work struct through which this was
>>> scheduled + * + * Currently there is no option in this driver to
>>> disable the +saving of + * timestamps within the ring. + * I think the
>>> one copy of this at a time was to avoid problems if +the + * trigger
>>> was set far too high and the reads then locked up the computer. + **/
>>> +static void ad799x_poll_bh_to_ring(struct work_struct *work_s) {
>>> +    struct ad799x_state *st = container_of(work_s, struct ad799x_state,
>>> +                                              poll_work); + struct iio_dev *indio_dev = st->indio_dev;
>>> +    struct iio_sw_ring_buffer *ring = iio_to_sw_ring(indio_dev- ring);
>>> +    s64 time_ns; +  __u8 *rxbuf; +  int b_sent; +   size_t d_size; +        u8 cmd;
>>> + +  unsigned long numvals = st->indio_dev->ring->scan_count; + +    /*
>>> Ensure the timestamp is 8 byte aligned */ +  d_size = numvals*2 +
>>> sizeof(s64); + +     if (d_size % sizeof(s64)) +             d_size += sizeof(s64) -
>>> (d_size % sizeof(s64)); + +  /* Ensure only one copy of this function
>>> running at a time */ +       if (atomic_inc_return(&st->protect_ring) > 1)
>>> +            return; + +     /* Monitor mode prevents reading. Whilst not currently
>>> implemented +         * might as well have this test in here in the meantime
>>> as it does +  * no harm. +    */ +   if (numvals == 0) +             return; + +     rxbuf
>>> = kmalloc(d_size,    GFP_KERNEL); +  if (rxbuf == NULL) +            return; +
>>> +    switch (st->id) { +     case ad7991: +  case ad7995: +  case ad7999: +          cmd
>>> = st->config | (st->indio_dev->ring->scan_mask <<
>>> +                    AD799X_CHANNEL_SHIFT); +                break; +        case ad7992: +  case ad7993:
>>> +    case ad7994: +          cmd = (st->indio_dev->ring->scan_mask <<
>>> +                    AD799X_CHANNEL_SHIFT) | AD7998_CONV_RES_REG; +          break; +        case
>>> ad7997: +    case ad7998: +          cmd = AD7997_8_READ_SEQUENCE |
>>> AD7998_CONV_RES_REG; +               break; +        default: +              cmd = 0; +      } + +   b_sent =
>>> i2c_smbus_read_i2c_block_data(st->client, +                  cmd, numvals*2, rxbuf);
>>> +    if (b_sent < 0) +               goto done; + +  time_ns = iio_get_time_ns(); +
>>> +    memcpy(rxbuf + d_size - sizeof(s64), &time_ns, sizeof(time_ns)); +
>>> +    indio_dev->ring->access.store_to(&ring->buf, rxbuf, time_ns); +done:
>>> +    kfree(rxbuf); + atomic_dec(&st->protect_ring); +} + + +int
>>> ad799x_register_ring_funcs_and_init(struct iio_dev *indio_dev) {
>>> +    struct ad799x_state *st = indio_dev->dev_data; +        int ret = 0; +
>>> +    indio_dev->ring = iio_sw_rb_allocate(indio_dev); +      if
>>> (!indio_dev->ring) { +               ret = -ENOMEM; +                goto error_ret; +       } +     /*
>>> Effectively select the ring buffer implementation */
>>> +    iio_ring_sw_register_funcs(&st->indio_dev->ring->access);
>>> +    indio_dev->pollfunc = kzalloc(sizeof(*indio_dev->pollfunc),
>>> GFP_KERNEL); +       if (indio_dev->pollfunc == NULL) { +            ret = -ENOMEM;
>>> +            goto error_deallocate_sw_rb; +  } +     /* Configure the polling function
>>> called on trigger interrupts */ +    indio_dev->pollfunc->poll_func_main =
>>> &ad799x_poll_func_th; +      indio_dev->pollfunc->private_data = indio_dev;
>>> + +  /* Ring buffer functions - here trigger setup related */ +
>>> +    indio_dev->ring->preenable = &ad799x_ring_preenable;
>>> +    indio_dev->ring->postenable = &iio_triggered_ring_postenable;
>>> +    indio_dev->ring->predisable = &iio_triggered_ring_predisable; +
>>> +    INIT_WORK(&st->poll_work, &ad799x_poll_bh_to_ring); +
>>> +    indio_dev->ring->scan_el_attrs = st->chip_info->scan_attrs; + + /*
>>> Flag that polled ring buffering is possible */ +     indio_dev->modes |=
>>> INDIO_RING_TRIGGERED; +      return 0; +error_deallocate_sw_rb:
>>> +    iio_sw_rb_free(indio_dev->ring); +error_ret: +  return ret; +} + +void
>>> ad799x_ring_cleanup(struct iio_dev *indio_dev) { +   /* ensure that the
>>> trigger has been detached */ +       if (indio_dev->trig) {
>>> +            iio_put_trigger(indio_dev->trig);
>>> +            iio_trigger_dettach_poll_func(indio_dev->trig, +
>>> indio_dev->pollfunc); +      } +     kfree(indio_dev->pollfunc);
>>> +    iio_sw_rb_free(indio_dev->ring); +}
> 
> Greetings,
> Michael
> 
> Analog Devices GmbH      Wilhelm-Wagenfeld-Str. 6      80807 Muenchen
> Sitz der Gesellschaft Muenchen, Registergericht Muenchen HRB 4036 Geschaeftsfuehrer Thomas Wessel, William A. Martin, Margaret Seif
> 
>