/*
* 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_byte_data(client, reg);
if (ret < 0) {
dev_err(&client->dev, "I2C read error\n");
return ret;
}
*data = (u8)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_type(struct device *dev,
struct device_attribute *attr,
char *buf)
{
struct iio_ring_buffer *ring = dev_get_drvdata(dev);
struct iio_dev *indio_dev = ring->indio_dev;
struct ad799x_state *st = indio_dev->dev_data;
return sprintf(buf, "%c%d/%d\n", st->chip_info->sign,
st->chip_info->bits, AD799X_STORAGEBITS);
}
static IIO_DEVICE_ATTR(in_type, S_IRUGO, ad799x_show_type, 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 :