drivers:hwmon: add support for lsm303dlhc sensor

Adding support for lsm303dlhc acclerometer and
magnetometer sensor chip.

ST-Ericsson ID: 317051
ST-Ericsson FOSS-OUT ID: NA
ST-Ericsson Linux next: NA

Change-Id: If55ac20c2665b44d3af45d7af0f2e3e16570d8a7
Signed-off-by: Chethan Krishna N <chethan.krishna@stericsson.com>
Reviewed-on: http://gerrit.lud.stericsson.com/gerrit/26993
Reviewed-by: QATEST
Reviewed-by: Srinidhi KASAGAR <srinidhi.kasagar@stericsson.com>

5 files changed, 680 insertions, 0 deletions

diff --git a/drivers/hwmon/Kconfig b/drivers/hwmon/Kconfig
index 72524d16630..cd1468b1b3a 100644
--- a/drivers/hwmon/Kconfig
+++ b/drivers/hwmon/Kconfig
@@ -710,6 +710,20 @@ config SENSORS_LSM303DLH_INPUT_DEVICE
 	  interrupts, need to be enabled only when input device support
 	  is required.
 
+config SENSORS_LSM303DLHC
+	tristate "ST LSM303DLHC 3-axis accelerometer and 3-axis magnetometer"
+	depends on I2C
+	default n
+	help
+	  This driver provides support for the LSM303DLHC chip which includes a
+	  3-axis accelerometer and a 3-axis magnetometer.
+
+	  This driver can also be built as modules.  If so, the module for
+	  accelerometer will be called lsm303dlhc_a and for magnetometer it will
+	  be called lsm303dlh_m.
+
+	  Say Y here if you have a device containing lsm303dlhc chip.
+
 config SENSORS_L3G4200D
 	tristate "ST L3G4200D 3-axis gyroscope"
 	depends on I2C
diff --git a/drivers/hwmon/Makefile b/drivers/hwmon/Makefile
index 93773c975d3..27eb2a571f8 100644
--- a/drivers/hwmon/Makefile
+++ b/drivers/hwmon/Makefile
@@ -85,6 +85,7 @@ obj-$(CONFIG_SENSORS_LM95241)	+= lm95241.o
 obj-$(CONFIG_SENSORS_LM95245)	+= lm95245.o
 obj-$(CONFIG_SENSORS_LTC4151)	+= ltc4151.o
 obj-$(CONFIG_SENSORS_LSM303DLH) += lsm303dlh_a.o lsm303dlh_m.o
+obj-$(CONFIG_SENSORS_LSM303DLHC) += lsm303dlhc_a.o lsm303dlh_m.o
 obj-$(CONFIG_SENSORS_L3G4200D) += l3g4200d.o
 obj-$(CONFIG_SENSORS_LTC4215)	+= ltc4215.o
 obj-$(CONFIG_SENSORS_LTC4245)	+= ltc4245.o
diff --git a/drivers/hwmon/lsm303dlh_a.c b/drivers/hwmon/lsm303dlh_a.c
index af0ceee2e45..d3c30bc49e0 100644
--- a/drivers/hwmon/lsm303dlh_a.c
+++ b/drivers/hwmon/lsm303dlh_a.c
@@ -198,6 +198,7 @@ struct lsm303dlh_a_data {
 	unsigned char interrupt_duration[2];
 	unsigned char interrupt_threshold[2];
 	int device_status;
+	int id;
 };
 
 #ifdef CONFIG_HAS_EARLYSUSPEND
@@ -990,6 +991,18 @@ static ssize_t lsm303dlh_a_store_sleepwake(struct device *dev,
 	return count;
 }
 
+static ssize_t lsm303dlh_a_show_id(struct device *dev,
+					struct device_attribute *attr,
+					char *buf)
+{
+	struct platform_device *pdev = to_platform_device(dev);
+	struct lsm303dlh_a_data *ddata = platform_get_drvdata(pdev);
+
+	return sprintf(buf, "%d\n", ddata->id);
+}
+
+static DEVICE_ATTR(id, S_IRUGO, lsm303dlh_a_show_id, NULL);
+
 static DEVICE_ATTR(data, S_IRUGO, lsm303dlh_a_show_data, NULL);
 
 static DEVICE_ATTR(range, S_IWUGO | S_IRUGO,
@@ -1027,6 +1040,7 @@ static DEVICE_ATTR(interrupt_threshold, S_IWUGO | S_IRUGO,
 #endif
 
 static struct attribute *lsm303dlh_a_attributes[] = {
+	&dev_attr_id.attr,
 	&dev_attr_data.attr,
 	&dev_attr_range.attr,
 	&dev_attr_mode.attr,
@@ -1089,6 +1103,7 @@ static int __devinit lsm303dlh_a_probe(struct i2c_client *client,
 
 	dev_info(&client->dev, "3-Axis Accelerometer, ID : %d\n",
 			 ret);
+	ddata->id = ret;
 
 	mutex_init(&ddata->lock);
 
diff --git a/drivers/hwmon/lsm303dlh_m.c b/drivers/hwmon/lsm303dlh_m.c
index 5d35dc2208d..254f44d40c6 100644
--- a/drivers/hwmon/lsm303dlh_m.c
+++ b/drivers/hwmon/lsm303dlh_m.c
@@ -117,6 +117,10 @@
 #define LSM303DLH_M_RATE_30_00 0x05
 #define LSM303DLH_M_RATE_75_00 0x06
 
+#ifdef CONFIG_SENSORS_LSM303DLHC
+#define LSM303DLH_M_RATE_220_00 0x07
+#endif
+
 /* Multiple byte transfer enable */
 #define MULTIPLE_I2C_TR 0x80
 
diff --git a/drivers/hwmon/lsm303dlhc_a.c b/drivers/hwmon/lsm303dlhc_a.c
new file mode 100644
index 00000000000..2da79affdd1
--- /dev/null
+++ b/drivers/hwmon/lsm303dlhc_a.c
@@ -0,0 +1,646 @@
+/*
+ * ST LSM303DLHC 3-Axis Accelerometer Driver
+ *
+ * Copyright (C) ST-Ericsson SA 2011
+ * Author: Chethan Krishna N <chethan.krishna@stericsson.com> for ST-Ericsson
+ * Licence terms: GNU General Public Licence (GPL) version 2
+ */
+
+#include <linux/i2c.h>
+#include <linux/mutex.h>
+#include <linux/slab.h>
+#include <linux/delay.h>
+#include <linux/platform_device.h>
+#include <linux/err.h>
+
+#include <linux/lsm303dlh.h>
+#include <linux/regulator/consumer.h>
+
+#define WHO_AM_I    0x0F
+
+/* lsm303dlhc accelerometer registers */
+#define CTRL_REG1				0x20
+#define CTRL_REG2				0x21
+#define CTRL_REG3				0x22
+#define CTRL_REG4				0x23
+#define CTRL_REG5				0x24
+#define CTRL_REG6				0x25
+
+/* lsm303dlhc accelerometer defines */
+#define LSM303DLHC_A_MODE_OFF		0x00
+#define LSM303DLHC_A_MODE_ON		0x04
+#define LSM303DLHC_A_MODE_MAX		0x09
+#define LSM303DLHC_A_CR1_MODE_BIT	4
+#define LSM303DLHC_A_CR1_MODE_MASK	(0xF << LSM303DLHC_A_CR1_MODE_BIT)
+ #define LSM303DLHC_A_CR1_AXIS_ENABLE 7
+
+/* Range */
+#define LSM303DLHC_A_RANGE_2G 0x00
+#define LSM303DLHC_A_RANGE_4G 0x01
+#define LSM303DLHC_A_RANGE_8G 0x02
+#define LSM303DLHC_A_RANGE_16G 0x03
+#define LSM303DLHC_A_CR4_FS_BIT 4
+
+/* Sensitivity adjustment */
+#define SHIFT_ADJ_2G 4 /*    1/16*/
+#define SHIFT_ADJ_4G 3 /*    2/16*/
+#define SHIFT_ADJ_8G 2 /* ~3.9/16*/
+#define SHIFT_ADJ_16G 1 /* ~3.9/16*/
+
+#define AXISDATA_REG    0x29    /* axis data */
+
+/* lsm303dlh magnetometer registers */
+#define IRA_REG_M	0x0A
+
+/* multiple byte transfer enable */
+#define MULTIPLE_I2C_TR			0x80
+
+/* device status defines */
+#define DEVICE_OFF 0
+#define DEVICE_ON 1
+#define DEVICE_SUSPENDED 2
+
+struct lsm303dlhc_a_t {
+	short	x;
+	short	y;
+	short	z;
+};
+
+/**
+ * struct lsm303dlhc_a_data - data structure used by lsm303dlhc_a driver
+ * @client: i2c client
+ * @lock: mutex lock for sysfs operations
+ * @data: lsm303dlhc_a_t struct containing x, y and z values
+ * @pdata: lsm303dlh platform data
+ * @regulator: regulator
+ * @range: current range value of accelerometer
+ * @mode: current mode of operation
+ * @rate: current sampling rate
+ * @shift_adjust: current shift adjust value set according to range
+ * @device_status: device is ON, OFF or SUSPENDED
+ * @id: accelerometer device id
+ */
+struct lsm303dlhc_a_data {
+	struct i2c_client *client;
+	/* lock for sysfs operations */
+	struct mutex lock;
+	struct lsm303dlhc_a_t data;
+	struct lsm303dlh_platform_data pdata;
+	struct regulator *regulator;
+	unsigned char range;
+	unsigned char mode;
+	unsigned char rate;
+	int shift_adjust;
+	int device_status;
+	int id;
+};
+
+static int lsm303dlhc_a_write(struct lsm303dlhc_a_data *ddata, u8 reg,
+		u8 val, char *msg)
+{
+	int ret = i2c_smbus_write_byte_data(ddata->client, reg, val);
+	if (ret < 0)
+		dev_err(&ddata->client->dev,
+			"i2c_smbus_write_byte_data failed error %d\
+			Register (%s)\n", ret, msg);
+	return ret;
+}
+
+static int lsm303dlhc_a_read(struct lsm303dlhc_a_data *ddata, u8 reg, char *msg)
+{
+	int ret = i2c_smbus_read_byte_data(ddata->client, reg);
+	if (ret < 0)
+		dev_err(&ddata->client->dev,
+			"i2c_smbus_read_byte_data failed error %d\
+			 Register (%s)\n", ret, msg);
+	return ret;
+}
+
+#ifdef (CONFIG_PM)
+static int lsm303dlhc_a_do_suspend(struct lsm303dlhc_a_data *ddata)
+{
+	int ret;
+
+	mutex_lock(&ddata->lock);
+
+	if (ddata->mode == LSM303DLHC_A_MODE_OFF) {
+		ret = 0;
+		goto exit;
+	}
+
+	ret = lsm303dlhc_a_write(ddata, CTRL_REG1,
+			LSM303DLHC_A_MODE_OFF, "CONTROL");
+
+	if (ddata->regulator)
+		regulator_disable(ddata->regulator);
+
+	ddata->device_status = DEVICE_SUSPENDED;
+
+exit:
+	mutex_unlock(&ddata->lock);
+
+	return ret;
+}
+
+static int lsm303dlhc_a_restore(struct lsm303dlhc_a_data *ddata)
+{
+	unsigned char reg;
+	unsigned char shifted_mode = (ddata->mode << LSM303DLHC_A_CR1_MODE_BIT);
+	int ret = 0;
+
+	mutex_lock(&ddata->lock);
+
+	if (ddata->device_status == DEVICE_ON) {
+		mutex_unlock(&ddata->lock);
+		return 0;
+	}
+
+	/* in correct mode, no need to change it */
+	if (ddata->mode == LSM303DLHC_A_MODE_OFF) {
+		ddata->device_status = DEVICE_OFF;
+		goto fail;
+	} else
+		ddata->device_status = DEVICE_ON;
+
+	if (ddata->regulator)
+		regulator_enable(ddata->regulator);
+
+	/* BDU should be enabled by default/recommened */
+	reg = ddata->range;
+	shifted_mode |= LSM303DLHC_A_CR1_AXIS_ENABLE;
+
+	ret = lsm303dlhc_a_write(ddata, CTRL_REG1, shifted_mode,
+			"CTRL_REG1");
+	if (ret < 0)
+		goto fail;
+
+	ret = lsm303dlhc_a_write(ddata, CTRL_REG4, reg, "CTRL_REG4");
+
+	if (ret < 0)
+		goto fail;
+
+	/* write to the boot bit to reboot memory content */
+	ret = lsm303dlhc_a_write(ddata, CTRL_REG5, 0x80, "CTRL_REG5");
+
+	if (ret < 0)
+		goto fail;
+
+fail:
+	if (ret < 0)
+		dev_err(&ddata->client->dev,
+				"could not restore the device %d\n", ret);
+	mutex_unlock(&ddata->lock);
+	return ret;
+}
+#endif
+
+static int lsm303dlhc_a_readdata(struct lsm303dlhc_a_data *ddata)
+{
+	unsigned char acc_data[6];
+	short data[3];
+
+	int ret = i2c_smbus_read_i2c_block_data(ddata->client,
+			AXISDATA_REG | MULTIPLE_I2C_TR, 6, acc_data);
+	if (ret < 0) {
+		dev_err(&ddata->client->dev,
+				"i2c_smbus_read_byte_data failed error %d\
+				Register AXISDATA_REG \n", ret);
+		return ret;
+	}
+
+	data[0] = (short) (((acc_data[1]) << 8) | acc_data[0]);
+	data[1] = (short) (((acc_data[3]) << 8) | acc_data[2]);
+	data[2] = (short) (((acc_data[5]) << 8) | acc_data[4]);
+
+	data[0] >>= ddata->shift_adjust;
+	data[1] >>= ddata->shift_adjust;
+	data[2] >>= ddata->shift_adjust;
+
+	/* taking position and orientation of x,y,z axis into account*/
+
+	data[ddata->pdata.axis_map_x] = ddata->pdata.negative_x ?
+		-data[ddata->pdata.axis_map_x] : data[ddata->pdata.axis_map_x];
+	data[ddata->pdata.axis_map_y] = ddata->pdata.negative_y ?
+		-data[ddata->pdata.axis_map_y] : data[ddata->pdata.axis_map_y];
+	data[ddata->pdata.axis_map_z] = ddata->pdata.negative_z ?
+		-data[ddata->pdata.axis_map_z] : data[ddata->pdata.axis_map_z];
+
+	ddata->data.x = data[ddata->pdata.axis_map_x];
+	ddata->data.y = data[ddata->pdata.axis_map_y];
+	ddata->data.z = data[ddata->pdata.axis_map_z];
+
+	return ret;
+}
+
+static ssize_t lsm303dlhc_a_show_data(struct device *dev,
+					struct device_attribute *attr,
+					char *buf)
+{
+	struct platform_device *pdev = to_platform_device(dev);
+	struct lsm303dlhc_a_data *ddata = platform_get_drvdata(pdev);
+	int ret = 0;
+
+	mutex_lock(&ddata->lock);
+
+	if (ddata->mode == LSM303DLHC_A_MODE_OFF ||
+			ddata->device_status == DEVICE_SUSPENDED) {
+		mutex_unlock(&ddata->lock);
+		return ret;
+	}
+
+	ret = lsm303dlhc_a_readdata(ddata);
+
+	if (ret < 0) {
+		mutex_unlock(&ddata->lock);
+		return ret;
+	}
+
+	mutex_unlock(&ddata->lock);
+
+	return sprintf(buf, "%8x:%8x:%8x\n", ddata->data.x, ddata->data.y,
+			ddata->data.z);
+}
+
+static ssize_t lsm303dlhc_a_show_range(struct device *dev,
+					struct device_attribute *attr,
+					char *buf)
+{
+	struct platform_device *pdev = to_platform_device(dev);
+	struct lsm303dlhc_a_data *ddata = platform_get_drvdata(pdev);
+
+	return sprintf(buf, "%d\n", ddata->range >> LSM303DLHC_A_CR4_FS_BIT);
+}
+
+static ssize_t lsm303dlhc_a_store_range(struct device *dev,
+					struct device_attribute *attr,
+					const char *buf, size_t count)
+{
+	struct platform_device *pdev = to_platform_device(dev);
+	struct lsm303dlhc_a_data *ddata = platform_get_drvdata(pdev);
+	long val;
+	int error;
+
+	error = strict_strtol(buf, 0, &val);
+	if (error)
+		return error;
+
+	if (val < LSM303DLHC_A_RANGE_2G || val > LSM303DLHC_A_RANGE_16G)
+		return -EINVAL;
+
+	mutex_lock(&ddata->lock);
+
+	if (ddata->mode == LSM303DLHC_A_MODE_OFF) {
+		dev_info(&ddata->client->dev,
+				"device is switched off,make it ON using MODE");
+		mutex_unlock(&ddata->lock);
+		return count;
+	}
+
+	ddata->range = val;
+	ddata->range <<= LSM303DLHC_A_CR4_FS_BIT;
+
+	error = lsm303dlhc_a_write(ddata, CTRL_REG4, ddata->range,
+	"CTRL_REG4");
+	if (error < 0)
+		return error;
+
+	switch (val) {
+	case LSM303DLHC_A_RANGE_2G:
+		ddata->shift_adjust = SHIFT_ADJ_2G;
+		break;
+	case LSM303DLHC_A_RANGE_4G:
+		ddata->shift_adjust = SHIFT_ADJ_4G;
+		break;
+	case LSM303DLHC_A_RANGE_8G:
+		ddata->shift_adjust = SHIFT_ADJ_8G;
+		break;
+	case LSM303DLHC_A_RANGE_16G:
+		ddata->shift_adjust = SHIFT_ADJ_16G;
+		break;
+	default:
+		return -EINVAL;
+	}
+
+	mutex_unlock(&ddata->lock);
+
+	return count;
+}
+
+static ssize_t lsm303dlhc_a_show_mode(struct device *dev,
+					struct device_attribute *attr,
+					char *buf)
+{
+	struct platform_device *pdev = to_platform_device(dev);
+	struct lsm303dlhc_a_data *ddata = platform_get_drvdata(pdev);
+
+	return sprintf(buf, "%d\n", ddata->mode);
+}
+
+static ssize_t lsm303dlhc_a_store_mode(struct device *dev,
+					struct device_attribute *attr,
+					const char *buf, size_t count)
+{
+	struct platform_device *pdev = to_platform_device(dev);
+	struct lsm303dlhc_a_data *ddata = platform_get_drvdata(pdev);
+	long val;
+	unsigned char data;
+	int error;
+	bool set_boot_bit = false;
+
+	error = strict_strtol(buf, 0, &val);
+	if (error)
+		return error;
+
+	mutex_lock(&ddata->lock);
+
+	/* not in correct range */
+
+	if (val < LSM303DLHC_A_MODE_OFF || val > LSM303DLHC_A_MODE_MAX) {
+		mutex_unlock(&ddata->lock);
+		return -EINVAL;
+	}
+
+	if (ddata->device_status == DEVICE_SUSPENDED) {
+		if (val == LSM303DLHC_A_MODE_OFF) {
+			ddata->mode = val;
+			mutex_unlock(&ddata->lock);
+			return count;
+		} else {
+			/* device is turning on after suspend, reset memory */
+			set_boot_bit = true;
+		}
+	}
+
+	/*  if same mode as existing, return */
+	if (ddata->mode == val) {
+		mutex_unlock(&ddata->lock);
+		return count;
+	}
+
+	/* turn on the supplies if already off */
+	if (ddata->regulator && ddata->mode == LSM303DLHC_A_MODE_OFF
+			&& (ddata->device_status == DEVICE_OFF
+				|| ddata->device_status == DEVICE_SUSPENDED)) {
+		regulator_enable(ddata->regulator);
+		ddata->device_status = DEVICE_ON;
+	}
+
+	data = lsm303dlhc_a_read(ddata, CTRL_REG1, "CTRL_REG1");
+
+	data &= ~LSM303DLHC_A_CR1_MODE_MASK;
+
+	ddata->mode = val;
+
+	data |= ((val << LSM303DLHC_A_CR1_MODE_BIT)
+			& LSM303DLHC_A_CR1_MODE_MASK);
+
+	error = lsm303dlhc_a_write(ddata, CTRL_REG1, data, "CTRL_REG1");
+	if (error < 0) {
+		if (ddata->regulator && ddata->device_status == DEVICE_ON) {
+			regulator_disable(ddata->regulator);
+			ddata->device_status = DEVICE_OFF;
+		}
+		mutex_unlock(&ddata->lock);
+		return error;
+	}
+
+	/*
+	 * Power on request when device is in suspended state
+	 * write to the boot bit in CTRL_REG2 to reboot memory content
+	 * and ensure correct device behavior after it resumes
+	 */
+	if (set_boot_bit) {
+		error = lsm303dlhc_a_write(ddata, CTRL_REG5, 0x80, "CTRL_REG5");
+		if (error < 0) {
+			if (ddata->regulator &&
+					ddata->device_status == DEVICE_ON) {
+				regulator_disable(ddata->regulator);
+				ddata->device_status = DEVICE_OFF;
+			}
+			mutex_unlock(&ddata->lock);
+			return error;
+		}
+	}
+
+	if (val == LSM303DLHC_A_MODE_OFF) {
+
+		/*
+		 * No need to store context here
+		 * it is not like suspend/resume
+		 * but fall back to default values
+		 */
+		ddata->range = LSM303DLHC_A_RANGE_2G;
+		ddata->shift_adjust = SHIFT_ADJ_2G;
+
+		if (ddata->regulator && ddata->device_status == DEVICE_ON) {
+			regulator_disable(ddata->regulator);
+			ddata->device_status = DEVICE_OFF;
+		}
+	}
+	mutex_unlock(&ddata->lock);
+
+	return count;
+}
+
+static ssize_t lsm303dlhc_a_show_id(struct device *dev,
+					struct device_attribute *attr,
+					char *buf)
+{
+	struct platform_device *pdev = to_platform_device(dev);
+	struct lsm303dlhc_a_data *ddata = platform_get_drvdata(pdev);
+
+	return sprintf(buf, "%d\n", ddata->id);
+}
+
+static DEVICE_ATTR(id, S_IRUGO, lsm303dlhc_a_show_id, NULL);
+
+static DEVICE_ATTR(data, S_IRUGO, lsm303dlhc_a_show_data, NULL);
+
+static DEVICE_ATTR(range, S_IWUGO | S_IRUGO,
+		lsm303dlhc_a_show_range, lsm303dlhc_a_store_range);
+
+static DEVICE_ATTR(mode, S_IWUGO | S_IRUGO,
+		lsm303dlhc_a_show_mode, lsm303dlhc_a_store_mode);
+
+static struct attribute *lsm303dlhc_a_attributes[] = {
+	&dev_attr_data.attr,
+	&dev_attr_range.attr,
+	&dev_attr_mode.attr,
+	&dev_attr_id.attr,
+	NULL
+};
+
+static const struct attribute_group lsm303dlhc_a_attr_group = {
+	.attrs = lsm303dlhc_a_attributes,
+};
+
+static int __devinit lsm303dlhc_a_probe(struct i2c_client *client,
+						const struct i2c_device_id *id)
+{
+	int ret;
+	struct lsm303dlhc_a_data *adata = NULL;
+
+	adata = kzalloc(sizeof(struct lsm303dlhc_a_data), GFP_KERNEL);
+	if (adata == NULL) {
+		ret = -ENOMEM;
+		goto err_op_failed;
+	}
+
+	adata->client = client;
+	i2c_set_clientdata(client, adata);
+
+	/* copy platform specific data */
+	memcpy(&adata->pdata, client->dev.platform_data, sizeof(adata->pdata));
+	adata->mode = LSM303DLHC_A_MODE_OFF;
+	adata->range = LSM303DLHC_A_RANGE_2G;
+	adata->shift_adjust = SHIFT_ADJ_2G;
+	adata->device_status = DEVICE_OFF;
+	dev_set_name(&client->dev, adata->pdata.name_a);
+
+	adata->regulator = regulator_get(&client->dev, "v-accel");
+	if (IS_ERR(adata->regulator)) {
+		dev_err(&client->dev, "failed to get regulator\n");
+		ret = PTR_ERR(adata->regulator);
+		adata->regulator = NULL;
+	}
+
+	if (adata->regulator) {
+		regulator_enable(adata->regulator);
+		adata->device_status = DEVICE_ON;
+	}
+
+	ret = lsm303dlhc_a_read(adata, WHO_AM_I, "WHO_AM_I");
+	if (ret < 0)
+		goto exit_free_regulator;
+
+	dev_info(&client->dev, "3-Axis Accelerometer, ID : %d\n",
+			 ret);
+	adata->id = ret;
+
+	mutex_init(&adata->lock);
+
+	ret = sysfs_create_group(&client->dev.kobj, &lsm303dlhc_a_attr_group);
+	if (ret)
+		goto exit_free_regulator;
+
+	if (adata->device_status == DEVICE_ON && adata->regulator) {
+		regulator_disable(adata->regulator);
+		adata->device_status = DEVICE_OFF;
+	}
+
+	return ret;
+
+exit_free_regulator:
+	if (adata->device_status == DEVICE_ON && adata->regulator) {
+		regulator_disable(adata->regulator);
+		regulator_put(adata->regulator);
+		adata->device_status = DEVICE_OFF;
+	}
+err_op_failed:
+	kfree(adata);
+	dev_err(&client->dev, "probe function fails %x", ret);
+	return ret;
+}
+
+static int __devexit lsm303dlhc_a_remove(struct i2c_client *client)
+{
+	int ret;
+	struct lsm303dlhc_a_data *adata;
+
+	adata = i2c_get_clientdata(client);
+	sysfs_remove_group(&client->dev.kobj, &lsm303dlhc_a_attr_group);
+
+	/* safer to make device off */
+	if (adata->mode != LSM303DLHC_A_MODE_OFF) {
+		ret = lsm303dlhc_a_write(adata, CTRL_REG1, 0, "CONTROL");
+
+		if (ret < 0) {
+			dev_err(&client->dev,
+					"could not turn off the device %d",
+					ret);
+			return ret;
+		}
+
+		if (adata->regulator && adata->device_status == DEVICE_ON) {
+			regulator_disable(adata->regulator);
+			regulator_put(adata->regulator);
+			adata->device_status = DEVICE_OFF;
+		}
+	}
+
+	i2c_set_clientdata(client, NULL);
+	kfree(adata);
+
+	return 0;
+}
+
+#ifdef (CONFIG_PM)
+static int lsm303dlhc_a_suspend(struct device *dev)
+{
+	struct lsm303dlhc_a_data *ddata;
+	int ret;
+
+	ddata = dev_get_drvdata(dev);
+
+	ret = lsm303dlhc_a_do_suspend(ddata);
+	if (ret < 0)
+		dev_err(&ddata->client->dev,
+				"Error while suspending the device");
+
+	return ret;
+}
+
+static int lsm303dlhc_a_resume(struct device *dev)
+{
+	struct lsm303dlhc_a_data *ddata;
+	int ret;
+
+	ddata = dev_get_drvdata(dev);
+
+	ret	= lsm303dlhc_a_restore(ddata);
+
+	if (ret < 0)
+		dev_err(&ddata->client->dev,
+				"Error while resuming the device");
+
+	return ret;
+}
+static const struct dev_pm_ops lsm303dlhc_a_dev_pm_ops = {
+	.suspend = lsm303dlhc_a_suspend,
+	.resume  = lsm303dlhc_a_resume,
+};
+#endif /* CONFIG_PM */
+
+static const struct i2c_device_id lsm303dlhc_a_id[] = {
+	{ "lsm303dlhc_a", 0 },
+	{ },
+};
+
+static struct i2c_driver lsm303dlhc_a_driver = {
+	.probe		= lsm303dlhc_a_probe,
+	.remove		= lsm303dlhc_a_remove,
+	.id_table	= lsm303dlhc_a_id,
+	.driver = {
+		.name = "lsm303dlhc_a",
+	#ifdef (CONFIG_PM)
+		.pm	=	&lsm303dlhc_a_dev_pm_ops,
+	#endif
+	},
+};
+
+static int __init lsm303dlhc_a_init(void)
+{
+	return i2c_add_driver(&lsm303dlhc_a_driver);
+}
+
+static void __exit lsm303dlhc_a_exit(void)
+{
+	i2c_del_driver(&lsm303dlhc_a_driver);
+}
+
+module_init(lsm303dlhc_a_init)
+module_exit(lsm303dlhc_a_exit)
+
+MODULE_DESCRIPTION("lSM303DLH 3-Axis Accelerometer Driver");
+MODULE_LICENSE("GPL");
+MODULE_AUTHOR("STMicroelectronics");