[deliverable/linux.git] / drivers / iio / dac / ad5380.c

/*
 * Analog devices AD5380, AD5381, AD5382, AD5383, AD5390, AD5391, AD5392
 * multi-channel Digital to Analog Converters driver
 *
 * Copyright 2011 Analog Devices Inc.
 *
 * Licensed under the GPL-2.
 */

#include <linux/device.h>
#include <linux/err.h>
#include <linux/i2c.h>
#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/spi/spi.h>
#include <linux/slab.h>
#include <linux/sysfs.h>
#include <linux/regmap.h>
#include <linux/regulator/consumer.h>

#include <linux/iio/iio.h>
#include <linux/iio/sysfs.h>

#define AD5380_REG_DATA(x)	(((x) << 2) | 3)
#define AD5380_REG_OFFSET(x)	(((x) << 2) | 2)
#define AD5380_REG_GAIN(x)	(((x) << 2) | 1)
#define AD5380_REG_SF_PWR_DOWN	(8 << 2)
#define AD5380_REG_SF_PWR_UP	(9 << 2)
#define AD5380_REG_SF_CTRL	(12 << 2)

#define AD5380_CTRL_PWR_DOWN_MODE_OFFSET	13
#define AD5380_CTRL_INT_VREF_2V5		BIT(12)
#define AD5380_CTRL_INT_VREF_EN			BIT(10)

/**
 * struct ad5380_chip_info - chip specific information
 * @channel_template:	channel specification template
 * @num_channels:	number of channels
 * @int_vref:		internal vref in uV
*/

struct ad5380_chip_info {
	struct iio_chan_spec	channel_template;
	unsigned int		num_channels;
	unsigned int		int_vref;
};

/**
 * struct ad5380_state - driver instance specific data
 * @regmap:		regmap instance used by the device
 * @chip_info:		chip model specific constants, available modes etc
 * @vref_reg:		vref supply regulator
 * @vref:		actual reference voltage used in uA
 * @pwr_down:		whether the chip is currently in power down mode
 */

struct ad5380_state {
	struct regmap			*regmap;
	const struct ad5380_chip_info	*chip_info;
	struct regulator		*vref_reg;
	int				vref;
	bool				pwr_down;
};

enum ad5380_type {
	ID_AD5380_3,
	ID_AD5380_5,
	ID_AD5381_3,
	ID_AD5381_5,
	ID_AD5382_3,
	ID_AD5382_5,
	ID_AD5383_3,
	ID_AD5383_5,
	ID_AD5390_3,
	ID_AD5390_5,
	ID_AD5391_3,
	ID_AD5391_5,
	ID_AD5392_3,
	ID_AD5392_5,
};

static ssize_t ad5380_read_dac_powerdown(struct iio_dev *indio_dev,
	uintptr_t private, const struct iio_chan_spec *chan, char *buf)
{
	struct ad5380_state *st = iio_priv(indio_dev);

	return sprintf(buf, "%d\n", st->pwr_down);
}

static ssize_t ad5380_write_dac_powerdown(struct iio_dev *indio_dev,
	 uintptr_t private, const struct iio_chan_spec *chan, const char *buf,
	 size_t len)
{
	struct ad5380_state *st = iio_priv(indio_dev);
	bool pwr_down;
	int ret;

	ret = strtobool(buf, &pwr_down);
	if (ret)
		return ret;

	mutex_lock(&indio_dev->mlock);

	if (pwr_down)
		ret = regmap_write(st->regmap, AD5380_REG_SF_PWR_DOWN, 0);
	else
		ret = regmap_write(st->regmap, AD5380_REG_SF_PWR_UP, 0);

	st->pwr_down = pwr_down;

	mutex_unlock(&indio_dev->mlock);

	return ret ? ret : len;
}

static const char * const ad5380_powerdown_modes[] = {
	"100kohm_to_gnd",
	"three_state",
};

static int ad5380_get_powerdown_mode(struct iio_dev *indio_dev,
	const struct iio_chan_spec *chan)
{
	struct ad5380_state *st = iio_priv(indio_dev);
	unsigned int mode;
	int ret;

	ret = regmap_read(st->regmap, AD5380_REG_SF_CTRL, &mode);
	if (ret)
		return ret;

	mode = (mode >> AD5380_CTRL_PWR_DOWN_MODE_OFFSET) & 1;

	return mode;
}

static int ad5380_set_powerdown_mode(struct iio_dev *indio_dev,
	const struct iio_chan_spec *chan, unsigned int mode)
{
	struct ad5380_state *st = iio_priv(indio_dev);
	int ret;

	ret = regmap_update_bits(st->regmap, AD5380_REG_SF_CTRL,
		1 << AD5380_CTRL_PWR_DOWN_MODE_OFFSET,
		mode << AD5380_CTRL_PWR_DOWN_MODE_OFFSET);

	return ret;
}

static const struct iio_enum ad5380_powerdown_mode_enum = {
	.items = ad5380_powerdown_modes,
	.num_items = ARRAY_SIZE(ad5380_powerdown_modes),
	.get = ad5380_get_powerdown_mode,
	.set = ad5380_set_powerdown_mode,
};

static unsigned int ad5380_info_to_reg(struct iio_chan_spec const *chan,
	long info)
{
	switch (info) {
	case 0:
		return AD5380_REG_DATA(chan->address);
	case IIO_CHAN_INFO_CALIBBIAS:
		return AD5380_REG_OFFSET(chan->address);
	case IIO_CHAN_INFO_CALIBSCALE:
		return AD5380_REG_GAIN(chan->address);
	default:
		break;
	}

	return 0;
}

static int ad5380_write_raw(struct iio_dev *indio_dev,
	struct iio_chan_spec const *chan, int val, int val2, long info)
{
	const unsigned int max_val = (1 << chan->scan_type.realbits);
	struct ad5380_state *st = iio_priv(indio_dev);

	switch (info) {
	case IIO_CHAN_INFO_RAW:
	case IIO_CHAN_INFO_CALIBSCALE:
		if (val >= max_val || val < 0)
			return -EINVAL;

		return regmap_write(st->regmap,
			ad5380_info_to_reg(chan, info),
			val << chan->scan_type.shift);
	case IIO_CHAN_INFO_CALIBBIAS:
		val += (1 << chan->scan_type.realbits) / 2;
		if (val >= max_val || val < 0)
			return -EINVAL;

		return regmap_write(st->regmap,
			AD5380_REG_OFFSET(chan->address),
			val << chan->scan_type.shift);
	default:
		break;
	}
	return -EINVAL;
}

static int ad5380_read_raw(struct iio_dev *indio_dev,
	struct iio_chan_spec const *chan, int *val, int *val2, long info)
{
	struct ad5380_state *st = iio_priv(indio_dev);
	int ret;

	switch (info) {
	case IIO_CHAN_INFO_RAW:
	case IIO_CHAN_INFO_CALIBSCALE:
		ret = regmap_read(st->regmap, ad5380_info_to_reg(chan, info),
					val);
		if (ret)
			return ret;
		*val >>= chan->scan_type.shift;
		return IIO_VAL_INT;
	case IIO_CHAN_INFO_CALIBBIAS:
		ret = regmap_read(st->regmap, AD5380_REG_OFFSET(chan->address),
					val);
		if (ret)
			return ret;
		*val >>= chan->scan_type.shift;
		val -= (1 << chan->scan_type.realbits) / 2;
		return IIO_VAL_INT;
	case IIO_CHAN_INFO_SCALE:
		*val = 2 * st->vref;
		*val2 = chan->scan_type.realbits;
		return IIO_VAL_FRACTIONAL_LOG2;
	default:
		break;
	}

	return -EINVAL;
}

static const struct iio_info ad5380_info = {
	.read_raw = ad5380_read_raw,
	.write_raw = ad5380_write_raw,
	.driver_module = THIS_MODULE,
};

static struct iio_chan_spec_ext_info ad5380_ext_info[] = {
	{
		.name = "powerdown",
		.read = ad5380_read_dac_powerdown,
		.write = ad5380_write_dac_powerdown,
		.shared = IIO_SEPARATE,
	},
	IIO_ENUM("powerdown_mode", IIO_SHARED_BY_TYPE,
		 &ad5380_powerdown_mode_enum),
	IIO_ENUM_AVAILABLE("powerdown_mode", &ad5380_powerdown_mode_enum),
	{ },
};

#define AD5380_CHANNEL(_bits) {					\
	.type = IIO_VOLTAGE,					\
	.indexed = 1,						\
	.output = 1,						\
	.info_mask_separate = BIT(IIO_CHAN_INFO_RAW) |		\
		BIT(IIO_CHAN_INFO_CALIBSCALE) |			\
		BIT(IIO_CHAN_INFO_CALIBBIAS),			\
	.info_mask_shared_by_type = BIT(IIO_CHAN_INFO_SCALE),	\
	.scan_type = {						\
		.sign = 'u',					\
		.realbits = (_bits),				\
		.storagebits =  16,				\
		.shift = 14 - (_bits),				\
	},							\
	.ext_info = ad5380_ext_info,				\
}

static const struct ad5380_chip_info ad5380_chip_info_tbl[] = {
	[ID_AD5380_3] = {
		.channel_template = AD5380_CHANNEL(14),
		.num_channels = 40,
		.int_vref = 1250,
	},
	[ID_AD5380_5] = {
		.channel_template = AD5380_CHANNEL(14),
		.num_channels = 40,
		.int_vref = 2500,
	},
	[ID_AD5381_3] = {
		.channel_template = AD5380_CHANNEL(12),
		.num_channels = 16,
		.int_vref = 1250,
	},
	[ID_AD5381_5] = {
		.channel_template = AD5380_CHANNEL(12),
		.num_channels = 16,
		.int_vref = 2500,
	},
	[ID_AD5382_3] = {
		.channel_template = AD5380_CHANNEL(14),
		.num_channels = 32,
		.int_vref = 1250,
	},
	[ID_AD5382_5] = {
		.channel_template = AD5380_CHANNEL(14),
		.num_channels = 32,
		.int_vref = 2500,
	},
	[ID_AD5383_3] = {
		.channel_template = AD5380_CHANNEL(12),
		.num_channels = 32,
		.int_vref = 1250,
	},
	[ID_AD5383_5] = {
		.channel_template = AD5380_CHANNEL(12),
		.num_channels = 32,
		.int_vref = 2500,
	},
	[ID_AD5390_3] = {
		.channel_template = AD5380_CHANNEL(14),
		.num_channels = 16,
		.int_vref = 1250,
	},
	[ID_AD5390_5] = {
		.channel_template = AD5380_CHANNEL(14),
		.num_channels = 16,
		.int_vref = 2500,
	},
	[ID_AD5391_3] = {
		.channel_template = AD5380_CHANNEL(12),
		.num_channels = 16,
		.int_vref = 1250,
	},
	[ID_AD5391_5] = {
		.channel_template = AD5380_CHANNEL(12),
		.num_channels = 16,
		.int_vref = 2500,
	},
	[ID_AD5392_3] = {
		.channel_template = AD5380_CHANNEL(14),
		.num_channels = 8,
		.int_vref = 1250,
	},
	[ID_AD5392_5] = {
		.channel_template = AD5380_CHANNEL(14),
		.num_channels = 8,
		.int_vref = 2500,
	},
};

static int ad5380_alloc_channels(struct iio_dev *indio_dev)
{
	struct ad5380_state *st = iio_priv(indio_dev);
	struct iio_chan_spec *channels;
	unsigned int i;

	channels = kcalloc(st->chip_info->num_channels,
			   sizeof(struct iio_chan_spec), GFP_KERNEL);

	if (!channels)
		return -ENOMEM;

	for (i = 0; i < st->chip_info->num_channels; ++i) {
		channels[i] = st->chip_info->channel_template;
		channels[i].channel = i;
		channels[i].address = i;
	}

	indio_dev->channels = channels;

	return 0;
}

static int ad5380_probe(struct device *dev, struct regmap *regmap,
			enum ad5380_type type, const char *name)
{
	struct iio_dev *indio_dev;
	struct ad5380_state *st;
	unsigned int ctrl = 0;
	int ret;

	indio_dev = devm_iio_device_alloc(dev, sizeof(*st));
	if (indio_dev == NULL) {
		dev_err(dev, "Failed to allocate iio device\n");
		return -ENOMEM;
	}

	st = iio_priv(indio_dev);
	dev_set_drvdata(dev, indio_dev);

	st->chip_info = &ad5380_chip_info_tbl[type];
	st->regmap = regmap;

	indio_dev->dev.parent = dev;
	indio_dev->name = name;
	indio_dev->info = &ad5380_info;
	indio_dev->modes = INDIO_DIRECT_MODE;
	indio_dev->num_channels = st->chip_info->num_channels;

	ret = ad5380_alloc_channels(indio_dev);
	if (ret) {
		dev_err(dev, "Failed to allocate channel spec: %d\n", ret);
		return ret;
	}

	if (st->chip_info->int_vref == 2500)
		ctrl |= AD5380_CTRL_INT_VREF_2V5;

	st->vref_reg = devm_regulator_get(dev, "vref");
	if (!IS_ERR(st->vref_reg)) {
		ret = regulator_enable(st->vref_reg);
		if (ret) {
			dev_err(dev, "Failed to enable vref regulators: %d\n",
				ret);
			goto error_free_reg;
		}

		ret = regulator_get_voltage(st->vref_reg);
		if (ret < 0)
			goto error_disable_reg;

		st->vref = ret / 1000;
	} else {
		st->vref = st->chip_info->int_vref;
		ctrl |= AD5380_CTRL_INT_VREF_EN;
	}

	ret = regmap_write(st->regmap, AD5380_REG_SF_CTRL, ctrl);
	if (ret) {
		dev_err(dev, "Failed to write to device: %d\n", ret);
		goto error_disable_reg;
	}

	ret = iio_device_register(indio_dev);
	if (ret) {
		dev_err(dev, "Failed to register iio device: %d\n", ret);
		goto error_disable_reg;
	}

	return 0;

error_disable_reg:
	if (!IS_ERR(st->vref_reg))
		regulator_disable(st->vref_reg);
error_free_reg:
	kfree(indio_dev->channels);

	return ret;
}

static int ad5380_remove(struct device *dev)
{
	struct iio_dev *indio_dev = dev_get_drvdata(dev);
	struct ad5380_state *st = iio_priv(indio_dev);

	iio_device_unregister(indio_dev);

	kfree(indio_dev->channels);

	if (!IS_ERR(st->vref_reg)) {
		regulator_disable(st->vref_reg);
	}

	return 0;
}

static bool ad5380_reg_false(struct device *dev, unsigned int reg)
{
	return false;
}

static const struct regmap_config ad5380_regmap_config = {
	.reg_bits = 10,
	.val_bits = 14,

	.max_register = AD5380_REG_DATA(40),
	.cache_type = REGCACHE_RBTREE,

	.volatile_reg = ad5380_reg_false,
	.readable_reg = ad5380_reg_false,
};

#if IS_ENABLED(CONFIG_SPI_MASTER)

static int ad5380_spi_probe(struct spi_device *spi)
{
	const struct spi_device_id *id = spi_get_device_id(spi);
	struct regmap *regmap;

	regmap = devm_regmap_init_spi(spi, &ad5380_regmap_config);

	if (IS_ERR(regmap))
		return PTR_ERR(regmap);

	return ad5380_probe(&spi->dev, regmap, id->driver_data, id->name);
}

static int ad5380_spi_remove(struct spi_device *spi)
{
	return ad5380_remove(&spi->dev);
}

static const struct spi_device_id ad5380_spi_ids[] = {
	{ "ad5380-3", ID_AD5380_3 },
	{ "ad5380-5", ID_AD5380_5 },
	{ "ad5381-3", ID_AD5381_3 },
	{ "ad5381-5", ID_AD5381_5 },
	{ "ad5382-3", ID_AD5382_3 },
	{ "ad5382-5", ID_AD5382_5 },
	{ "ad5383-3", ID_AD5383_3 },
	{ "ad5383-5", ID_AD5383_5 },
	{ "ad5384-3", ID_AD5380_3 },
	{ "ad5384-5", ID_AD5380_5 },
	{ "ad5390-3", ID_AD5390_3 },
	{ "ad5390-5", ID_AD5390_5 },
	{ "ad5391-3", ID_AD5391_3 },
	{ "ad5391-5", ID_AD5391_5 },
	{ "ad5392-3", ID_AD5392_3 },
	{ "ad5392-5", ID_AD5392_5 },
	{ }
};
MODULE_DEVICE_TABLE(spi, ad5380_spi_ids);

static struct spi_driver ad5380_spi_driver = {
	.driver = {
		   .name = "ad5380",
	},
	.probe = ad5380_spi_probe,
	.remove = ad5380_spi_remove,
	.id_table = ad5380_spi_ids,
};

static inline int ad5380_spi_register_driver(void)
{
	return spi_register_driver(&ad5380_spi_driver);
}

static inline void ad5380_spi_unregister_driver(void)
{
	spi_unregister_driver(&ad5380_spi_driver);
}

#else

static inline int ad5380_spi_register_driver(void)
{
	return 0;
}

static inline void ad5380_spi_unregister_driver(void)
{
}

#endif

#if IS_ENABLED(CONFIG_I2C)

static int ad5380_i2c_probe(struct i2c_client *i2c,
			    const struct i2c_device_id *id)
{
	struct regmap *regmap;

	regmap = devm_regmap_init_i2c(i2c, &ad5380_regmap_config);

	if (IS_ERR(regmap))
		return PTR_ERR(regmap);

	return ad5380_probe(&i2c->dev, regmap, id->driver_data, id->name);
}

static int ad5380_i2c_remove(struct i2c_client *i2c)
{
	return ad5380_remove(&i2c->dev);
}

static const struct i2c_device_id ad5380_i2c_ids[] = {
	{ "ad5380-3", ID_AD5380_3 },
	{ "ad5380-5", ID_AD5380_5 },
	{ "ad5381-3", ID_AD5381_3 },
	{ "ad5381-5", ID_AD5381_5 },
	{ "ad5382-3", ID_AD5382_3 },
	{ "ad5382-5", ID_AD5382_5 },
	{ "ad5383-3", ID_AD5383_3 },
	{ "ad5383-5", ID_AD5383_5 },
	{ "ad5384-3", ID_AD5380_3 },
	{ "ad5384-5", ID_AD5380_5 },
	{ "ad5390-3", ID_AD5390_3 },
	{ "ad5390-5", ID_AD5390_5 },
	{ "ad5391-3", ID_AD5391_3 },
	{ "ad5391-5", ID_AD5391_5 },
	{ "ad5392-3", ID_AD5392_3 },
	{ "ad5392-5", ID_AD5392_5 },
	{ }
};
MODULE_DEVICE_TABLE(i2c, ad5380_i2c_ids);

static struct i2c_driver ad5380_i2c_driver = {
	.driver = {
		   .name = "ad5380",
	},
	.probe = ad5380_i2c_probe,
	.remove = ad5380_i2c_remove,
	.id_table = ad5380_i2c_ids,
};

static inline int ad5380_i2c_register_driver(void)
{
	return i2c_add_driver(&ad5380_i2c_driver);
}

static inline void ad5380_i2c_unregister_driver(void)
{
	i2c_del_driver(&ad5380_i2c_driver);
}

#else

static inline int ad5380_i2c_register_driver(void)
{
	return 0;
}

static inline void ad5380_i2c_unregister_driver(void)
{
}

#endif

static int __init ad5380_spi_init(void)
{
	int ret;

	ret = ad5380_spi_register_driver();
	if (ret)
		return ret;

	ret = ad5380_i2c_register_driver();
	if (ret) {
		ad5380_spi_unregister_driver();
		return ret;
	}

	return 0;
}
module_init(ad5380_spi_init);

static void __exit ad5380_spi_exit(void)
{
	ad5380_i2c_unregister_driver();
	ad5380_spi_unregister_driver();

}
module_exit(ad5380_spi_exit);

MODULE_AUTHOR("Lars-Peter Clausen <lars@metafoo.de>");
MODULE_DESCRIPTION("Analog Devices AD5380/81/82/83/84/90/91/92 DAC");
MODULE_LICENSE("GPL v2");
Commit	Line	Data
c03f2c53 LPC	1	/*
	2	* Analog devices AD5380, AD5381, AD5382, AD5383, AD5390, AD5391, AD5392
	3	* multi-channel Digital to Analog Converters driver
	4	*
	5	* Copyright 2011 Analog Devices Inc.
	6	*
	7	* Licensed under the GPL-2.
	8	*/
	9
	10	#include <linux/device.h>
	11	#include <linux/err.h>
	12	#include <linux/i2c.h>
	13	#include <linux/kernel.h>
	14	#include <linux/module.h>
	15	#include <linux/spi/spi.h>
	16	#include <linux/slab.h>
	17	#include <linux/sysfs.h>
	18	#include <linux/regmap.h>
	19	#include <linux/regulator/consumer.h>
	20
06458e27 JC	21	#include <linux/iio/iio.h>
06458e27 JC	22	#include <linux/iio/sysfs.h>
c03f2c53 LPC	23
	24	#define AD5380_REG_DATA(x) (((x) << 2) \| 3)
	25	#define AD5380_REG_OFFSET(x) (((x) << 2) \| 2)
	26	#define AD5380_REG_GAIN(x) (((x) << 2) \| 1)
	27	#define AD5380_REG_SF_PWR_DOWN (8 << 2)
	28	#define AD5380_REG_SF_PWR_UP (9 << 2)
	29	#define AD5380_REG_SF_CTRL (12 << 2)
	30
	31	#define AD5380_CTRL_PWR_DOWN_MODE_OFFSET 13
	32	#define AD5380_CTRL_INT_VREF_2V5 BIT(12)
	33	#define AD5380_CTRL_INT_VREF_EN BIT(10)
	34
	35	/**
	36	* struct ad5380_chip_info - chip specific information
	37	* @channel_template: channel specification template
	38	* @num_channels: number of channels
	39	* @int_vref: internal vref in uV
	40	*/
	41
	42	struct ad5380_chip_info {
	43	struct iio_chan_spec channel_template;
	44	unsigned int num_channels;
	45	unsigned int int_vref;
	46	};
	47
	48	/**
	49	* struct ad5380_state - driver instance specific data
	50	* @regmap: regmap instance used by the device
	51	* @chip_info: chip model specific constants, available modes etc
	52	* @vref_reg: vref supply regulator
	53	* @vref: actual reference voltage used in uA
	54	* @pwr_down: whether the chip is currently in power down mode
	55	*/
	56
	57	struct ad5380_state {
	58	struct regmap *regmap;
	59	const struct ad5380_chip_info *chip_info;
	60	struct regulator *vref_reg;
	61	int vref;
	62	bool pwr_down;
	63	};
	64
	65	enum ad5380_type {
	66	ID_AD5380_3,
	67	ID_AD5380_5,
	68	ID_AD5381_3,
	69	ID_AD5381_5,
	70	ID_AD5382_3,
	71	ID_AD5382_5,
	72	ID_AD5383_3,
	73	ID_AD5383_5,
	74	ID_AD5390_3,
	75	ID_AD5390_5,
	76	ID_AD5391_3,
	77	ID_AD5391_5,
	78	ID_AD5392_3,
	79	ID_AD5392_5,
	80	};
	81
868e0862 LPC	82	static ssize_t ad5380_read_dac_powerdown(struct iio_dev *indio_dev,
868e0862 LPC	83	uintptr_t private, const struct iio_chan_spec chan, char buf)
c03f2c53	84	{
c03f2c53 LPC	85	struct ad5380_state *st = iio_priv(indio_dev);
	86
	87	return sprintf(buf, "%d\n", st->pwr_down);
	88	}
	89
868e0862 LPC	90	static ssize_t ad5380_write_dac_powerdown(struct iio_dev *indio_dev,
	91	uintptr_t private, const struct iio_chan_spec chan, const char buf,
	92	size_t len)
c03f2c53	93	{
c03f2c53 LPC	94	struct ad5380_state *st = iio_priv(indio_dev);
	95	bool pwr_down;
	96	int ret;
	97
	98	ret = strtobool(buf, &pwr_down);
	99	if (ret)
	100	return ret;
	101
	102	mutex_lock(&indio_dev->mlock);
	103
	104	if (pwr_down)
	105	ret = regmap_write(st->regmap, AD5380_REG_SF_PWR_DOWN, 0);
	106	else
	107	ret = regmap_write(st->regmap, AD5380_REG_SF_PWR_UP, 0);
	108
	109	st->pwr_down = pwr_down;
	110
	111	mutex_unlock(&indio_dev->mlock);
	112
	113	return ret ? ret : len;
	114	}
	115
868e0862 LPC	116	static const char * const ad5380_powerdown_modes[] = {
	117	"100kohm_to_gnd",
	118	"three_state",
c03f2c53 LPC	119	};
c03f2c53 LPC	120
868e0862 LPC	121	static int ad5380_get_powerdown_mode(struct iio_dev *indio_dev,
868e0862 LPC	122	const struct iio_chan_spec *chan)
c03f2c53	123	{
c03f2c53 LPC	124	struct ad5380_state *st = iio_priv(indio_dev);
	125	unsigned int mode;
	126	int ret;
	127
	128	ret = regmap_read(st->regmap, AD5380_REG_SF_CTRL, &mode);
	129	if (ret)
	130	return ret;
	131
	132	mode = (mode >> AD5380_CTRL_PWR_DOWN_MODE_OFFSET) & 1;
	133
868e0862	134	return mode;
c03f2c53 LPC	135	}
c03f2c53 LPC	136
868e0862 LPC	137	static int ad5380_set_powerdown_mode(struct iio_dev *indio_dev,
868e0862 LPC	138	const struct iio_chan_spec *chan, unsigned int mode)
c03f2c53	139	{
c03f2c53	140	struct ad5380_state *st = iio_priv(indio_dev);
c03f2c53 LPC	141	int ret;
c03f2c53 LPC	142
c03f2c53 LPC	143	ret = regmap_update_bits(st->regmap, AD5380_REG_SF_CTRL,
c03f2c53 LPC	144	1 << AD5380_CTRL_PWR_DOWN_MODE_OFFSET,
868e0862	145	mode << AD5380_CTRL_PWR_DOWN_MODE_OFFSET);
c03f2c53	146
868e0862	147	return ret;
c03f2c53 LPC	148	}
c03f2c53 LPC	149
868e0862 LPC	150	static const struct iio_enum ad5380_powerdown_mode_enum = {
	151	.items = ad5380_powerdown_modes,
	152	.num_items = ARRAY_SIZE(ad5380_powerdown_modes),
	153	.get = ad5380_get_powerdown_mode,
	154	.set = ad5380_set_powerdown_mode,
c03f2c53 LPC	155	};
	156
	157	static unsigned int ad5380_info_to_reg(struct iio_chan_spec const *chan,
	158	long info)
	159	{
	160	switch (info) {
	161	case 0:
	162	return AD5380_REG_DATA(chan->address);
	163	case IIO_CHAN_INFO_CALIBBIAS:
	164	return AD5380_REG_OFFSET(chan->address);
	165	case IIO_CHAN_INFO_CALIBSCALE:
	166	return AD5380_REG_GAIN(chan->address);
	167	default:
	168	break;
	169	}
	170
	171	return 0;
	172	}
	173
	174	static int ad5380_write_raw(struct iio_dev *indio_dev,
	175	struct iio_chan_spec const *chan, int val, int val2, long info)
	176	{
	177	const unsigned int max_val = (1 << chan->scan_type.realbits);
	178	struct ad5380_state *st = iio_priv(indio_dev);
	179
	180	switch (info) {
09f4eb40	181	case IIO_CHAN_INFO_RAW:
c03f2c53 LPC	182	case IIO_CHAN_INFO_CALIBSCALE:
	183	if (val >= max_val \|\| val < 0)
	184	return -EINVAL;
	185
	186	return regmap_write(st->regmap,
	187	ad5380_info_to_reg(chan, info),
	188	val << chan->scan_type.shift);
	189	case IIO_CHAN_INFO_CALIBBIAS:
	190	val += (1 << chan->scan_type.realbits) / 2;
	191	if (val >= max_val \|\| val < 0)
	192	return -EINVAL;
	193
	194	return regmap_write(st->regmap,
	195	AD5380_REG_OFFSET(chan->address),
	196	val << chan->scan_type.shift);
	197	default:
	198	break;
	199	}
	200	return -EINVAL;
	201	}
	202
	203	static int ad5380_read_raw(struct iio_dev *indio_dev,
	204	struct iio_chan_spec const chan, int val, int *val2, long info)
	205	{
	206	struct ad5380_state *st = iio_priv(indio_dev);
c03f2c53 LPC	207	int ret;
	208
	209	switch (info) {
09f4eb40	210	case IIO_CHAN_INFO_RAW:
c03f2c53 LPC	211	case IIO_CHAN_INFO_CALIBSCALE:
	212	ret = regmap_read(st->regmap, ad5380_info_to_reg(chan, info),
	213	val);
	214	if (ret)
	215	return ret;
	216	*val >>= chan->scan_type.shift;
	217	return IIO_VAL_INT;
	218	case IIO_CHAN_INFO_CALIBBIAS:
	219	ret = regmap_read(st->regmap, AD5380_REG_OFFSET(chan->address),
	220	val);
	221	if (ret)
	222	return ret;
	223	*val >>= chan->scan_type.shift;
	224	val -= (1 << chan->scan_type.realbits) / 2;
	225	return IIO_VAL_INT;
	226	case IIO_CHAN_INFO_SCALE:
4f2c1885 LPC	227	val = 2 st->vref;
	228	*val2 = chan->scan_type.realbits;
	229	return IIO_VAL_FRACTIONAL_LOG2;
c03f2c53 LPC	230	default:
	231	break;
	232	}
	233
	234	return -EINVAL;
	235	}
	236
	237	static const struct iio_info ad5380_info = {
	238	.read_raw = ad5380_read_raw,
	239	.write_raw = ad5380_write_raw,
c03f2c53 LPC	240	.driver_module = THIS_MODULE,
	241	};
	242
868e0862 LPC	243	static struct iio_chan_spec_ext_info ad5380_ext_info[] = {
	244	{
	245	.name = "powerdown",
	246	.read = ad5380_read_dac_powerdown,
	247	.write = ad5380_write_dac_powerdown,
3704432f	248	.shared = IIO_SEPARATE,
868e0862	249	},
3704432f JC	250	IIO_ENUM("powerdown_mode", IIO_SHARED_BY_TYPE,
3704432f JC	251	&ad5380_powerdown_mode_enum),
868e0862 LPC	252	IIO_ENUM_AVAILABLE("powerdown_mode", &ad5380_powerdown_mode_enum),
	253	{ },
	254	};
	255
	256	#define AD5380_CHANNEL(_bits) { \
	257	.type = IIO_VOLTAGE, \
	258	.indexed = 1, \
	259	.output = 1, \
c69e1397 JC	260	.info_mask_separate = BIT(IIO_CHAN_INFO_RAW) \| \
	261	BIT(IIO_CHAN_INFO_CALIBSCALE) \| \
	262	BIT(IIO_CHAN_INFO_CALIBBIAS), \
	263	.info_mask_shared_by_type = BIT(IIO_CHAN_INFO_SCALE), \
da9b1a21 JC	264	.scan_type = { \
	265	.sign = 'u', \
	266	.realbits = (_bits), \
	267	.storagebits = 16, \
	268	.shift = 14 - (_bits), \
	269	}, \
868e0862 LPC	270	.ext_info = ad5380_ext_info, \
	271	}
	272
	273	static const struct ad5380_chip_info ad5380_chip_info_tbl[] = {
	274	[ID_AD5380_3] = {
	275	.channel_template = AD5380_CHANNEL(14),
	276	.num_channels = 40,
4f2c1885	277	.int_vref = 1250,
868e0862 LPC	278	},
	279	[ID_AD5380_5] = {
	280	.channel_template = AD5380_CHANNEL(14),
	281	.num_channels = 40,
4f2c1885	282	.int_vref = 2500,
868e0862 LPC	283	},
	284	[ID_AD5381_3] = {
	285	.channel_template = AD5380_CHANNEL(12),
	286	.num_channels = 16,
4f2c1885	287	.int_vref = 1250,
868e0862 LPC	288	},
	289	[ID_AD5381_5] = {
	290	.channel_template = AD5380_CHANNEL(12),
	291	.num_channels = 16,
4f2c1885	292	.int_vref = 2500,
868e0862 LPC	293	},
	294	[ID_AD5382_3] = {
	295	.channel_template = AD5380_CHANNEL(14),
	296	.num_channels = 32,
4f2c1885	297	.int_vref = 1250,
868e0862 LPC	298	},
	299	[ID_AD5382_5] = {
	300	.channel_template = AD5380_CHANNEL(14),
	301	.num_channels = 32,
4f2c1885	302	.int_vref = 2500,
868e0862 LPC	303	},
	304	[ID_AD5383_3] = {
	305	.channel_template = AD5380_CHANNEL(12),
	306	.num_channels = 32,
4f2c1885	307	.int_vref = 1250,
868e0862 LPC	308	},
	309	[ID_AD5383_5] = {
	310	.channel_template = AD5380_CHANNEL(12),
	311	.num_channels = 32,
4f2c1885	312	.int_vref = 2500,
868e0862 LPC	313	},
	314	[ID_AD5390_3] = {
	315	.channel_template = AD5380_CHANNEL(14),
	316	.num_channels = 16,
4f2c1885	317	.int_vref = 1250,
868e0862 LPC	318	},
	319	[ID_AD5390_5] = {
	320	.channel_template = AD5380_CHANNEL(14),
	321	.num_channels = 16,
4f2c1885	322	.int_vref = 2500,
868e0862 LPC	323	},
	324	[ID_AD5391_3] = {
	325	.channel_template = AD5380_CHANNEL(12),
	326	.num_channels = 16,
4f2c1885	327	.int_vref = 1250,
868e0862 LPC	328	},
	329	[ID_AD5391_5] = {
	330	.channel_template = AD5380_CHANNEL(12),
	331	.num_channels = 16,
4f2c1885	332	.int_vref = 2500,
868e0862 LPC	333	},
	334	[ID_AD5392_3] = {
	335	.channel_template = AD5380_CHANNEL(14),
	336	.num_channels = 8,
4f2c1885	337	.int_vref = 1250,
868e0862 LPC	338	},
	339	[ID_AD5392_5] = {
	340	.channel_template = AD5380_CHANNEL(14),
	341	.num_channels = 8,
4f2c1885	342	.int_vref = 2500,
868e0862 LPC	343	},
	344	};
	345
fc52692c	346	static int ad5380_alloc_channels(struct iio_dev *indio_dev)
c03f2c53 LPC	347	{
	348	struct ad5380_state *st = iio_priv(indio_dev);
	349	struct iio_chan_spec *channels;
	350	unsigned int i;
	351
09f993e6 AL	352	channels = kcalloc(st->chip_info->num_channels,
09f993e6 AL	353	sizeof(struct iio_chan_spec), GFP_KERNEL);
c03f2c53 LPC	354
	355	if (!channels)
	356	return -ENOMEM;
	357
	358	for (i = 0; i < st->chip_info->num_channels; ++i) {
	359	channels[i] = st->chip_info->channel_template;
	360	channels[i].channel = i;
	361	channels[i].address = i;
	362	}
	363
	364	indio_dev->channels = channels;
	365
	366	return 0;
	367	}
	368
fc52692c GKH	369	static int ad5380_probe(struct device dev, struct regmap regmap,
fc52692c GKH	370	enum ad5380_type type, const char *name)
c03f2c53 LPC	371	{
	372	struct iio_dev *indio_dev;
	373	struct ad5380_state *st;
	374	unsigned int ctrl = 0;
	375	int ret;
	376
c815ad37	377	indio_dev = devm_iio_device_alloc(dev, sizeof(*st));
c03f2c53 LPC	378	if (indio_dev == NULL) {
c03f2c53 LPC	379	dev_err(dev, "Failed to allocate iio device\n");
c815ad37	380	return -ENOMEM;
c03f2c53 LPC	381	}
	382
	383	st = iio_priv(indio_dev);
	384	dev_set_drvdata(dev, indio_dev);
	385
	386	st->chip_info = &ad5380_chip_info_tbl[type];
	387	st->regmap = regmap;
	388
	389	indio_dev->dev.parent = dev;
	390	indio_dev->name = name;
	391	indio_dev->info = &ad5380_info;
	392	indio_dev->modes = INDIO_DIRECT_MODE;
	393	indio_dev->num_channels = st->chip_info->num_channels;
	394
	395	ret = ad5380_alloc_channels(indio_dev);
	396	if (ret) {
	397	dev_err(dev, "Failed to allocate channel spec: %d\n", ret);
c815ad37	398	return ret;
c03f2c53 LPC	399	}
c03f2c53 LPC	400
4f2c1885	401	if (st->chip_info->int_vref == 2500)
c03f2c53 LPC	402	ctrl \|= AD5380_CTRL_INT_VREF_2V5;
c03f2c53 LPC	403
c815ad37	404	st->vref_reg = devm_regulator_get(dev, "vref");
c03f2c53 LPC	405	if (!IS_ERR(st->vref_reg)) {
	406	ret = regulator_enable(st->vref_reg);
	407	if (ret) {
	408	dev_err(dev, "Failed to enable vref regulators: %d\n",
	409	ret);
	410	goto error_free_reg;
	411	}
	412
272cc9c8 AL	413	ret = regulator_get_voltage(st->vref_reg);
	414	if (ret < 0)
	415	goto error_disable_reg;
	416
4f2c1885	417	st->vref = ret / 1000;
c03f2c53 LPC	418	} else {
	419	st->vref = st->chip_info->int_vref;
	420	ctrl \|= AD5380_CTRL_INT_VREF_EN;
	421	}
	422
	423	ret = regmap_write(st->regmap, AD5380_REG_SF_CTRL, ctrl);
	424	if (ret) {
	425	dev_err(dev, "Failed to write to device: %d\n", ret);
	426	goto error_disable_reg;
	427	}
	428
	429	ret = iio_device_register(indio_dev);
	430	if (ret) {
	431	dev_err(dev, "Failed to register iio device: %d\n", ret);
	432	goto error_disable_reg;
	433	}
	434
	435	return 0;
	436
	437	error_disable_reg:
	438	if (!IS_ERR(st->vref_reg))
	439	regulator_disable(st->vref_reg);
	440	error_free_reg:
c03f2c53	441	kfree(indio_dev->channels);
c03f2c53 LPC	442
	443	return ret;
	444	}
	445
fc52692c	446	static int ad5380_remove(struct device *dev)
c03f2c53 LPC	447	{
	448	struct iio_dev *indio_dev = dev_get_drvdata(dev);
	449	struct ad5380_state *st = iio_priv(indio_dev);
	450
	451	iio_device_unregister(indio_dev);
	452
	453	kfree(indio_dev->channels);
	454
	455	if (!IS_ERR(st->vref_reg)) {
	456	regulator_disable(st->vref_reg);
c03f2c53 LPC	457	}
c03f2c53 LPC	458
c03f2c53 LPC	459	return 0;
	460	}
	461
	462	static bool ad5380_reg_false(struct device *dev, unsigned int reg)
	463	{
	464	return false;
	465	}
	466
	467	static const struct regmap_config ad5380_regmap_config = {
	468	.reg_bits = 10,
	469	.val_bits = 14,
	470
	471	.max_register = AD5380_REG_DATA(40),
	472	.cache_type = REGCACHE_RBTREE,
	473
	474	.volatile_reg = ad5380_reg_false,
	475	.readable_reg = ad5380_reg_false,
	476	};
	477
	478	#if IS_ENABLED(CONFIG_SPI_MASTER)
	479
fc52692c	480	static int ad5380_spi_probe(struct spi_device *spi)
c03f2c53 LPC	481	{
	482	const struct spi_device_id *id = spi_get_device_id(spi);
	483	struct regmap *regmap;
	484
d03fcfe6	485	regmap = devm_regmap_init_spi(spi, &ad5380_regmap_config);
c03f2c53 LPC	486
	487	if (IS_ERR(regmap))
	488	return PTR_ERR(regmap);
	489
	490	return ad5380_probe(&spi->dev, regmap, id->driver_data, id->name);
	491	}
	492
fc52692c	493	static int ad5380_spi_remove(struct spi_device *spi)
c03f2c53 LPC	494	{
	495	return ad5380_remove(&spi->dev);
	496	}
	497
	498	static const struct spi_device_id ad5380_spi_ids[] = {
	499	{ "ad5380-3", ID_AD5380_3 },
	500	{ "ad5380-5", ID_AD5380_5 },
	501	{ "ad5381-3", ID_AD5381_3 },
	502	{ "ad5381-5", ID_AD5381_5 },
	503	{ "ad5382-3", ID_AD5382_3 },
	504	{ "ad5382-5", ID_AD5382_5 },
	505	{ "ad5383-3", ID_AD5383_3 },
	506	{ "ad5383-5", ID_AD5383_5 },
	507	{ "ad5384-3", ID_AD5380_3 },
	508	{ "ad5384-5", ID_AD5380_5 },
	509	{ "ad5390-3", ID_AD5390_3 },
	510	{ "ad5390-5", ID_AD5390_5 },
	511	{ "ad5391-3", ID_AD5391_3 },
	512	{ "ad5391-5", ID_AD5391_5 },
	513	{ "ad5392-3", ID_AD5392_3 },
	514	{ "ad5392-5", ID_AD5392_5 },
	515	{ }
	516	};
	517	MODULE_DEVICE_TABLE(spi, ad5380_spi_ids);
	518
	519	static struct spi_driver ad5380_spi_driver = {
	520	.driver = {
	521	.name = "ad5380",
c03f2c53 LPC	522	},
c03f2c53 LPC	523	.probe = ad5380_spi_probe,
fc52692c	524	.remove = ad5380_spi_remove,
c03f2c53 LPC	525	.id_table = ad5380_spi_ids,
	526	};
	527
	528	static inline int ad5380_spi_register_driver(void)
	529	{
	530	return spi_register_driver(&ad5380_spi_driver);
	531	}
	532
	533	static inline void ad5380_spi_unregister_driver(void)
	534	{
	535	spi_unregister_driver(&ad5380_spi_driver);
	536	}
	537
	538	#else
	539
	540	static inline int ad5380_spi_register_driver(void)
	541	{
	542	return 0;
	543	}
	544
	545	static inline void ad5380_spi_unregister_driver(void)
	546	{
	547	}
	548
	549	#endif
	550
	551	#if IS_ENABLED(CONFIG_I2C)
	552
fc52692c GKH	553	static int ad5380_i2c_probe(struct i2c_client *i2c,
fc52692c GKH	554	const struct i2c_device_id *id)
c03f2c53 LPC	555	{
	556	struct regmap *regmap;
	557
d03fcfe6	558	regmap = devm_regmap_init_i2c(i2c, &ad5380_regmap_config);
c03f2c53 LPC	559
	560	if (IS_ERR(regmap))
	561	return PTR_ERR(regmap);
	562
	563	return ad5380_probe(&i2c->dev, regmap, id->driver_data, id->name);
	564	}
	565
fc52692c	566	static int ad5380_i2c_remove(struct i2c_client *i2c)
c03f2c53 LPC	567	{
	568	return ad5380_remove(&i2c->dev);
	569	}
	570
	571	static const struct i2c_device_id ad5380_i2c_ids[] = {
	572	{ "ad5380-3", ID_AD5380_3 },
	573	{ "ad5380-5", ID_AD5380_5 },
	574	{ "ad5381-3", ID_AD5381_3 },
	575	{ "ad5381-5", ID_AD5381_5 },
	576	{ "ad5382-3", ID_AD5382_3 },
	577	{ "ad5382-5", ID_AD5382_5 },
	578	{ "ad5383-3", ID_AD5383_3 },
	579	{ "ad5383-5", ID_AD5383_5 },
	580	{ "ad5384-3", ID_AD5380_3 },
	581	{ "ad5384-5", ID_AD5380_5 },
	582	{ "ad5390-3", ID_AD5390_3 },
	583	{ "ad5390-5", ID_AD5390_5 },
	584	{ "ad5391-3", ID_AD5391_3 },
	585	{ "ad5391-5", ID_AD5391_5 },
	586	{ "ad5392-3", ID_AD5392_3 },
	587	{ "ad5392-5", ID_AD5392_5 },
	588	{ }
	589	};
	590	MODULE_DEVICE_TABLE(i2c, ad5380_i2c_ids);
	591
	592	static struct i2c_driver ad5380_i2c_driver = {
	593	.driver = {
	594	.name = "ad5380",
c03f2c53 LPC	595	},
c03f2c53 LPC	596	.probe = ad5380_i2c_probe,
fc52692c	597	.remove = ad5380_i2c_remove,
c03f2c53 LPC	598	.id_table = ad5380_i2c_ids,
	599	};
	600
	601	static inline int ad5380_i2c_register_driver(void)
	602	{
	603	return i2c_add_driver(&ad5380_i2c_driver);
	604	}
	605
	606	static inline void ad5380_i2c_unregister_driver(void)
	607	{
	608	i2c_del_driver(&ad5380_i2c_driver);
	609	}
	610
	611	#else
	612
	613	static inline int ad5380_i2c_register_driver(void)
	614	{
	615	return 0;
	616	}
	617
	618	static inline void ad5380_i2c_unregister_driver(void)
	619	{
	620	}
	621
	622	#endif
	623
	624	static int __init ad5380_spi_init(void)
	625	{
	626	int ret;
	627
	628	ret = ad5380_spi_register_driver();
	629	if (ret)
	630	return ret;
	631
	632	ret = ad5380_i2c_register_driver();
	633	if (ret) {
	634	ad5380_spi_unregister_driver();
	635	return ret;
	636	}
	637
	638	return 0;
	639	}
	640	module_init(ad5380_spi_init);
	641
	642	static void __exit ad5380_spi_exit(void)
	643	{
	644	ad5380_i2c_unregister_driver();
	645	ad5380_spi_unregister_driver();
	646
	647	}
	648	module_exit(ad5380_spi_exit);
	649
	650	MODULE_AUTHOR("Lars-Peter Clausen <lars@metafoo.de>");
	651	MODULE_DESCRIPTION("Analog Devices AD5380/81/82/83/84/90/91/92 DAC");
	652	MODULE_LICENSE("GPL v2");