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. > 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. ...It's time to get out of staging > Acked-by: Jonathan Cameron <jic23@xxxxxxxxx> > > Please send on to Greg KH <greg@xxxxxxxxx> 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@xxxxxxxxxx> >> --- >> 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@xxxxxxxxxxxxxxxxxxxx>"); >> +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 -- To unsubscribe from this list: send the line "unsubscribe linux-iio" in the body of a message to majordomo@xxxxxxxxxxxxxxx More majordomo info at http://vger.kernel.org/majordomo-info.html
