Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 5b264a62 authored by Barry Song's avatar Barry Song Committed by Greg Kroah-Hartman
Browse files

staging: iio: meter: new driver for ADE7854/58/68/78 devices 



Signed-off-by: default avatarBarry Song <barry.song@analog.com>
Signed-off-by: default avatarMichael Hennerich <michael.hennerich@analog.com>
Acked-by: default avatarJonathan Cameron <jic23@cam.ac.uk>
Signed-off-by: default avatarMike Frysinger <vapier@gentoo.org>
Signed-off-by: default avatarGreg Kroah-Hartman <gregkh@suse.de>
parent 2919fa54

drivers/staging/iio/meter/Kconfig

+27 −0
Original line number Diff line number Diff line
@@ -32,3 +32,30 @@ config ADE7759 
	help

	  Say yes here to build support for Analog Devices ADE7758 Active Energy

	  Metering IC with di/dt Sensor Interface.



config ADE7854

	tristate "Analog Devices ADE7854/58/68/78 Polyphase Multifunction Energy Metering IC Driver"

	depends on SPI || I2C

	help

	  Say yes here to build support for Analog Devices ADE7854/58/68/78 Polyphase

	  Multifunction Energy Metering IC Driver.



config ADE7854_I2C

	tristate "support I2C bus connection"

	depends on ADE7854 && I2C

	default y

	help

	  Say Y here if you have ADE7854/58/68/78 hooked to an I2C bus.



	  To compile this driver as a module, choose M here: the

	  module will be called ade7854-i2c.



config ADE7854_SPI

	tristate "support SPI bus connection"

	depends on ADE7854 && SPI

	default y

	help

	  Say Y here if you have ADE7854/58/68/78 hooked to a SPI bus.



	  To compile this driver as a module, choose M here: the

	  module will be called ade7854-spi.

drivers/staging/iio/meter/Makefile

+3 −0
Original line number Diff line number Diff line
@@ -10,3 +10,6 @@ ade7758-$(CONFIG_IIO_RING_BUFFER) += ade7758_ring.o ade7758_trigger.o 
obj-$(CONFIG_ADE7758) += ade7758.o



obj-$(CONFIG_ADE7759) += ade7759.o

obj-$(CONFIG_ADE7854) += ade7854.o

obj-$(CONFIG_ADE7854_I2C) += ade7854-i2c.o

obj-$(CONFIG_ADE7854_SPI) += ade7854-spi.o

drivers/staging/iio/meter/ade7854-i2c.c

0 → 100644
+272 −0
Original line number Diff line number Diff line 
/*

 * ADE7854/58/68/78 Polyphase Multifunction Energy Metering IC Driver (I2C Bus)

 *

 * Copyright 2010 Analog Devices Inc.

 *

 * Licensed under the GPL-2 or later.

 */



#include <linux/device.h>

#include <linux/kernel.h>

#include <linux/i2c.h>

#include <linux/slab.h>



#include "../iio.h"

#include "ade7854.h"



static int ade7854_i2c_write_reg_8(struct device *dev,

		u16 reg_address,

		u8 value)

{

	int ret;

	struct iio_dev *indio_dev = dev_get_drvdata(dev);

	struct ade7854_state *st = iio_dev_get_devdata(indio_dev);



	mutex_lock(&st->buf_lock);

	st->tx[0] = (reg_address >> 8) & 0xFF;

	st->tx[1] = reg_address & 0xFF;

	st->tx[2] = value;



	ret = i2c_master_send(st->i2c, st->tx, 3);

	mutex_unlock(&st->buf_lock);



	return ret;

}



static int ade7854_i2c_write_reg_16(struct device *dev,

		u16 reg_address,

		u16 value)

{

	int ret;

	struct iio_dev *indio_dev = dev_get_drvdata(dev);

	struct ade7854_state *st = iio_dev_get_devdata(indio_dev);



	mutex_lock(&st->buf_lock);

	st->tx[0] = (reg_address >> 8) & 0xFF;

	st->tx[1] = reg_address & 0xFF;

	st->tx[2] = (value >> 8) & 0xFF;

	st->tx[3] = value & 0xFF;



	ret = i2c_master_send(st->i2c, st->tx, 4);

	mutex_unlock(&st->buf_lock);



	return ret;

}



static int ade7854_i2c_write_reg_24(struct device *dev,

		u16 reg_address,

		u32 value)

{

	int ret;

	struct iio_dev *indio_dev = dev_get_drvdata(dev);

	struct ade7854_state *st = iio_dev_get_devdata(indio_dev);



	mutex_lock(&st->buf_lock);

	st->tx[0] = (reg_address >> 8) & 0xFF;

	st->tx[1] = reg_address & 0xFF;

	st->tx[2] = (value >> 16) & 0xFF;

	st->tx[3] = (value >> 8) & 0xFF;

	st->tx[4] = value & 0xFF;



	ret = i2c_master_send(st->i2c, st->tx, 5);

	mutex_unlock(&st->buf_lock);



	return ret;

}



static int ade7854_i2c_write_reg_32(struct device *dev,

		u16 reg_address,

		u32 value)

{

	int ret;

	struct iio_dev *indio_dev = dev_get_drvdata(dev);

	struct ade7854_state *st = iio_dev_get_devdata(indio_dev);



	mutex_lock(&st->buf_lock);

	st->tx[0] = (reg_address >> 8) & 0xFF;

	st->tx[1] = reg_address & 0xFF;

	st->tx[2] = (value >> 24) & 0xFF;

	st->tx[3] = (value >> 16) & 0xFF;

	st->tx[4] = (value >> 8) & 0xFF;

	st->tx[5] = value & 0xFF;



	ret = i2c_master_send(st->i2c, st->tx, 6);

	mutex_unlock(&st->buf_lock);



	return ret;

}



static int ade7854_i2c_read_reg_8(struct device *dev,

		u16 reg_address,

		u8 *val)

{

	struct iio_dev *indio_dev = dev_get_drvdata(dev);

	struct ade7854_state *st = iio_dev_get_devdata(indio_dev);

	int ret;



	mutex_lock(&st->buf_lock);

	st->tx[0] = (reg_address >> 8) & 0xFF;

	st->tx[1] = reg_address & 0xFF;



	ret = i2c_master_send(st->i2c, st->tx, 2);

	if (ret)

		goto out;



	ret = i2c_master_recv(st->i2c, st->rx, 1);

	if (ret)

		goto out;



	*val = st->rx[0];

out:

	mutex_unlock(&st->buf_lock);

	return ret;

}



static int ade7854_i2c_read_reg_16(struct device *dev,

		u16 reg_address,

		u16 *val)

{

	struct iio_dev *indio_dev = dev_get_drvdata(dev);

	struct ade7854_state *st = iio_dev_get_devdata(indio_dev);

	int ret;



	mutex_lock(&st->buf_lock);

	st->tx[0] = (reg_address >> 8) & 0xFF;

	st->tx[1] = reg_address & 0xFF;



	ret = i2c_master_send(st->i2c, st->tx, 2);

	if (ret)

		goto out;



	ret = i2c_master_recv(st->i2c, st->rx, 2);

	if (ret)

		goto out;



	*val = (st->rx[0] << 8) | st->rx[1];

out:

	mutex_unlock(&st->buf_lock);

	return ret;

}



static int ade7854_i2c_read_reg_24(struct device *dev,

		u16 reg_address,

		u32 *val)

{

	struct iio_dev *indio_dev = dev_get_drvdata(dev);

	struct ade7854_state *st = iio_dev_get_devdata(indio_dev);

	int ret;



	mutex_lock(&st->buf_lock);

	st->tx[0] = (reg_address >> 8) & 0xFF;

	st->tx[1] = reg_address & 0xFF;



	ret = i2c_master_send(st->i2c, st->tx, 2);

	if (ret)

		goto out;



	ret = i2c_master_recv(st->i2c, st->rx, 3);

	if (ret)

		goto out;



	*val = (st->rx[0] << 16) | (st->rx[1] << 8) | st->rx[2];

out:

	mutex_unlock(&st->buf_lock);

	return ret;

}



static int ade7854_i2c_read_reg_32(struct device *dev,

		u16 reg_address,

		u32 *val)

{

	struct iio_dev *indio_dev = dev_get_drvdata(dev);

	struct ade7854_state *st = iio_dev_get_devdata(indio_dev);

	int ret;



	mutex_lock(&st->buf_lock);

	st->tx[0] = (reg_address >> 8) & 0xFF;

	st->tx[1] = reg_address & 0xFF;



	ret = i2c_master_send(st->i2c, st->tx, 2);

	if (ret)

		goto out;



	ret = i2c_master_recv(st->i2c, st->rx, 3);

	if (ret)

		goto out;



	*val = (st->rx[0] << 24) | (st->rx[1] << 16) | (st->rx[2] << 8) | st->rx[3];

out:

	mutex_unlock(&st->buf_lock);

	return ret;

}



static int __devinit ade7854_i2c_probe(struct i2c_client *client,

		const struct i2c_device_id *id)

{

	int ret;

	struct ade7854_state *st = kzalloc(sizeof *st, GFP_KERNEL);

	if (!st) {

		ret =  -ENOMEM;

		return ret;

	}



	i2c_set_clientdata(client, st);

	st->read_reg_8 = ade7854_i2c_read_reg_8;

	st->read_reg_16 = ade7854_i2c_read_reg_16;

	st->read_reg_24 = ade7854_i2c_read_reg_24;

	st->read_reg_32 = ade7854_i2c_read_reg_32;

	st->write_reg_8 = ade7854_i2c_write_reg_8;

	st->write_reg_16 = ade7854_i2c_write_reg_16;

	st->write_reg_24 = ade7854_i2c_write_reg_24;

	st->write_reg_32 = ade7854_i2c_write_reg_32;

	st->i2c = client;

	st->irq = client->irq;



	ret = ade7854_probe(st, &client->dev);

	if (ret) {

		kfree(st);

		return ret;

	}



	return ret;

}



static int __devexit ade7854_i2c_remove(struct i2c_client *client)

{

	return ade7854_remove(i2c_get_clientdata(client));

}



static const struct i2c_device_id ade7854_id[] = {

	{ "ade7854", 0 },

	{ "ade7858", 0 },

	{ "ade7868", 0 },

	{ "ade7878", 0 },

	{ }

};

MODULE_DEVICE_TABLE(i2c, ade7854_id);



static struct i2c_driver ade7854_i2c_driver = {

	.driver = {

		.name = "ade7854",

	},

	.probe    = ade7854_i2c_probe,

	.remove   = __devexit_p(ade7854_i2c_remove),

	.id_table = ade7854_id,

};



static __init int ade7854_i2c_init(void)

{

	return i2c_add_driver(&ade7854_i2c_driver);

}

module_init(ade7854_i2c_init);



static __exit void ade7854_i2c_exit(void)

{

	i2c_del_driver(&ade7854_i2c_driver);

}

module_exit(ade7854_i2c_exit);





MODULE_AUTHOR("Barry Song <21cnbao@gmail.com>");

MODULE_DESCRIPTION("Analog Devices ADE7854/58/68/78 Polyphase Multifunction Energy Metering IC I2C Driver");

MODULE_LICENSE("GPL v2");

drivers/staging/iio/meter/ade7854-spi.c

0 → 100644
+360 −0
Original line number Diff line number Diff line 
/*

 * ADE7854/58/68/78 Polyphase Multifunction Energy Metering IC Driver (SPI Bus)

 *

 * Copyright 2010 Analog Devices Inc.

 *

 * Licensed under the GPL-2 or later.

 */



#include <linux/device.h>

#include <linux/kernel.h>

#include <linux/spi/spi.h>

#include <linux/slab.h>



#include "../iio.h"

#include "ade7854.h"



static int ade7854_spi_write_reg_8(struct device *dev,

		u16 reg_address,

		u8 value)

{

	int ret;

	struct spi_message msg;

	struct iio_dev *indio_dev = dev_get_drvdata(dev);

	struct ade7854_state *st = iio_dev_get_devdata(indio_dev);

	struct spi_transfer xfers[] = {

		{

			.tx_buf = st->tx,

			.bits_per_word = 8,

			.len = 4,

		}

	};



	mutex_lock(&st->buf_lock);

	st->tx[0] = ADE7854_WRITE_REG;

	st->tx[1] = (reg_address >> 8) & 0xFF;

	st->tx[2] = reg_address & 0xFF;

	st->tx[3] = value & 0xFF;



	spi_message_init(&msg);

	spi_message_add_tail(xfers, &msg);

	ret = spi_sync(st->spi, &msg);

	mutex_unlock(&st->buf_lock);



	return ret;

}



static int ade7854_spi_write_reg_16(struct device *dev,

		u16 reg_address,

		u16 value)

{

	int ret;

	struct spi_message msg;

	struct iio_dev *indio_dev = dev_get_drvdata(dev);

	struct ade7854_state *st = iio_dev_get_devdata(indio_dev);

	struct spi_transfer xfers[] = {

		{

			.tx_buf = st->tx,

			.bits_per_word = 8,

			.len = 5,

		}

	};



	mutex_lock(&st->buf_lock);

	st->tx[0] = ADE7854_WRITE_REG;

	st->tx[1] = (reg_address >> 8) & 0xFF;

	st->tx[2] = reg_address & 0xFF;

	st->tx[3] = (value >> 8) & 0xFF;

	st->tx[4] = value & 0xFF;



	spi_message_init(&msg);

	spi_message_add_tail(xfers, &msg);

	ret = spi_sync(st->spi, &msg);

	mutex_unlock(&st->buf_lock);



	return ret;

}



static int ade7854_spi_write_reg_24(struct device *dev,

		u16 reg_address,

		u32 value)

{

	int ret;

	struct spi_message msg;

	struct iio_dev *indio_dev = dev_get_drvdata(dev);

	struct ade7854_state *st = iio_dev_get_devdata(indio_dev);

	struct spi_transfer xfers[] = {

		{

			.tx_buf = st->tx,

			.bits_per_word = 8,

			.len = 6,

		}

	};



	mutex_lock(&st->buf_lock);

	st->tx[0] = ADE7854_WRITE_REG;

	st->tx[1] = (reg_address >> 8) & 0xFF;

	st->tx[2] = reg_address & 0xFF;

	st->tx[3] = (value >> 16) & 0xFF;

	st->tx[4] = (value >> 8) & 0xFF;

	st->tx[5] = value & 0xFF;



	spi_message_init(&msg);

	spi_message_add_tail(xfers, &msg);

	ret = spi_sync(st->spi, &msg);

	mutex_unlock(&st->buf_lock);



	return ret;

}



static int ade7854_spi_write_reg_32(struct device *dev,

		u16 reg_address,

		u32 value)

{

	int ret;

	struct spi_message msg;

	struct iio_dev *indio_dev = dev_get_drvdata(dev);

	struct ade7854_state *st = iio_dev_get_devdata(indio_dev);

	struct spi_transfer xfers[] = {

		{

			.tx_buf = st->tx,

			.bits_per_word = 8,

			.len = 7,

		}

	};



	mutex_lock(&st->buf_lock);

	st->tx[0] = ADE7854_WRITE_REG;

	st->tx[1] = (reg_address >> 8) & 0xFF;

	st->tx[2] = reg_address & 0xFF;

	st->tx[3] = (value >> 24) & 0xFF;

	st->tx[4] = (value >> 16) & 0xFF;

	st->tx[5] = (value >> 8) & 0xFF;

	st->tx[6] = value & 0xFF;



	spi_message_init(&msg);

	spi_message_add_tail(xfers, &msg);

	ret = spi_sync(st->spi, &msg);

	mutex_unlock(&st->buf_lock);



	return ret;

}



static int ade7854_spi_read_reg_8(struct device *dev,

		u16 reg_address,

		u8 *val)

{

	struct spi_message msg;

	struct iio_dev *indio_dev = dev_get_drvdata(dev);

	struct ade7854_state *st = iio_dev_get_devdata(indio_dev);

	int ret;

	struct spi_transfer xfers[] = {

		{

			.tx_buf = st->tx,

			.bits_per_word = 8,

			.len = 4,

		},

	};



	mutex_lock(&st->buf_lock);



	st->tx[0] = ADE7854_READ_REG;

	st->tx[1] = (reg_address >> 8) & 0xFF;

	st->tx[2] = reg_address & 0xFF;

	st->tx[3] = 0;



	spi_message_init(&msg);

	spi_message_add_tail(xfers, &msg);

	ret = spi_sync(st->spi, &msg);

	if (ret) {

		dev_err(&st->spi->dev, "problem when reading 8 bit register 0x%02X",

				reg_address);

		goto error_ret;

	}

	*val = st->rx[3];



error_ret:

	mutex_unlock(&st->buf_lock);

	return ret;

}



static int ade7854_spi_read_reg_16(struct device *dev,

		u16 reg_address,

		u16 *val)

{

	struct spi_message msg;

	struct iio_dev *indio_dev = dev_get_drvdata(dev);

	struct ade7854_state *st = iio_dev_get_devdata(indio_dev);

	int ret;

	struct spi_transfer xfers[] = {

		{

			.tx_buf = st->tx,

			.bits_per_word = 8,

			.len = 5,

		},

	};



	mutex_lock(&st->buf_lock);

	st->tx[0] = ADE7854_READ_REG;

	st->tx[1] = (reg_address >> 8) & 0xFF;

	st->tx[2] = reg_address & 0xFF;

	st->tx[3] = 0;

	st->tx[4] = 0;



	spi_message_init(&msg);

	spi_message_add_tail(xfers, &msg);

	ret = spi_sync(st->spi, &msg);

	if (ret) {

		dev_err(&st->spi->dev, "problem when reading 16 bit register 0x%02X",

				reg_address);

		goto error_ret;

	}

	*val = (st->rx[3] << 8) | st->rx[4];



error_ret:

	mutex_unlock(&st->buf_lock);

	return ret;

}



static int ade7854_spi_read_reg_24(struct device *dev,

		u16 reg_address,

		u32 *val)

{

	struct spi_message msg;

	struct iio_dev *indio_dev = dev_get_drvdata(dev);

	struct ade7854_state *st = iio_dev_get_devdata(indio_dev);

	int ret;

	struct spi_transfer xfers[] = {

		{

			.tx_buf = st->tx,

			.bits_per_word = 8,

			.len = 6,

		},

	};



	mutex_lock(&st->buf_lock);



	st->tx[0] = ADE7854_READ_REG;

	st->tx[1] = (reg_address >> 8) & 0xFF;

	st->tx[2] = reg_address & 0xFF;

	st->tx[3] = 0;

	st->tx[4] = 0;

	st->tx[5] = 0;



	spi_message_init(&msg);

	spi_message_add_tail(xfers, &msg);

	ret = spi_sync(st->spi, &msg);

	if (ret) {

		dev_err(&st->spi->dev, "problem when reading 24 bit register 0x%02X",

				reg_address);

		goto error_ret;

	}

	*val = (st->rx[3] << 16) | (st->rx[4] << 8) | st->rx[5];



error_ret:

	mutex_unlock(&st->buf_lock);

	return ret;

}



static int ade7854_spi_read_reg_32(struct device *dev,

		u16 reg_address,

		u32 *val)

{

	struct spi_message msg;

	struct iio_dev *indio_dev = dev_get_drvdata(dev);

	struct ade7854_state *st = iio_dev_get_devdata(indio_dev);

	int ret;

	struct spi_transfer xfers[] = {

		{

			.tx_buf = st->tx,

			.bits_per_word = 8,

			.len = 7,

		},

	};



	mutex_lock(&st->buf_lock);



	st->tx[0] = ADE7854_READ_REG;

	st->tx[1] = (reg_address >> 8) & 0xFF;

	st->tx[2] = reg_address & 0xFF;

	st->tx[3] = 0;

	st->tx[4] = 0;

	st->tx[5] = 0;

	st->tx[6] = 0;



	spi_message_init(&msg);

	spi_message_add_tail(xfers, &msg);

	ret = spi_sync(st->spi, &msg);

	if (ret) {

		dev_err(&st->spi->dev, "problem when reading 32 bit register 0x%02X",

				reg_address);

		goto error_ret;

	}

	*val = (st->rx[3] << 24) | (st->rx[4] << 16) | (st->rx[5] << 8) | st->rx[6];



error_ret:

	mutex_unlock(&st->buf_lock);

	return ret;

}



static int __devinit ade7854_spi_probe(struct spi_device *spi)

{

	int ret;

	struct ade7854_state *st = kzalloc(sizeof *st, GFP_KERNEL);

	if (!st) {

		ret =  -ENOMEM;

		return ret;

	}



	spi_set_drvdata(spi, st);

	st->read_reg_8 = ade7854_spi_read_reg_8;

	st->read_reg_16 = ade7854_spi_read_reg_16;

	st->read_reg_24 = ade7854_spi_read_reg_24;

	st->read_reg_32 = ade7854_spi_read_reg_32;

	st->write_reg_8 = ade7854_spi_write_reg_8;

	st->write_reg_16 = ade7854_spi_write_reg_16;

	st->write_reg_24 = ade7854_spi_write_reg_24;

	st->write_reg_32 = ade7854_spi_write_reg_32;

	st->irq = spi->irq;

	st->spi = spi;



	ret = ade7854_probe(st, &spi->dev);

	if (ret) {

		kfree(st);

		return ret;

	}



	return 0;

}



static int ade7854_spi_remove(struct spi_device *spi)

{

	ade7854_remove(spi_get_drvdata(spi));



	return 0;

}



static struct spi_driver ade7854_driver = {

	.driver = {

		.name = "ade7854",

		.owner = THIS_MODULE,

	},

	.probe = ade7854_spi_probe,

	.remove = __devexit_p(ade7854_spi_remove),

};



static __init int ade7854_init(void)

{

	return spi_register_driver(&ade7854_driver);

}

module_init(ade7854_init);



static __exit void ade7854_exit(void)

{

	spi_unregister_driver(&ade7854_driver);

}

module_exit(ade7854_exit);



MODULE_AUTHOR("Barry Song <21cnbao@gmail.com>");

MODULE_DESCRIPTION("Analog Devices ADE7854/58/68/78 Polyphase Multifunction Energy Metering IC SPI Driver");

MODULE_LICENSE("GPL v2");

drivers/staging/iio/meter/ade7854.c

0 → 100644
+680 −0

File added.

Preview size limit exceeded, changes collapsed.