path: root/drivers/hwmon/lsm303dlh_a.c

/******************** (C) COPYRIGHT 2010 STMicroelectronics ********************
*
* File Name          : lsm303dlh_a_char.c
* Authors            : MH - C&I BU - Application Team
*		     : Carmine Iascone (carmine.iascone@st.com)
*		     : Matteo Dameno (matteo.dameno@st.com)
* Version            : V 0.3
* Date               : 24/02/2010
* Description        : LSM303DLH 6D module sensor API
*
********************************************************************************
*
* Author: Mian Yousaf Kaukab <mian.yousaf.kaukab@stericsson.com>
* Copyright 2010 (c) ST-Ericsson AB
*
********************************************************************************
*
* 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.
*
* THE PRESENT SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES
* OR CONDITIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED, FOR THE SOLE
* PURPOSE TO SUPPORT YOUR APPLICATION DEVELOPMENT.
* AS A RESULT, STMICROELECTRONICS SHALL NOT BE HELD LIABLE FOR ANY DIRECT,
* INDIRECT OR CONSEQUENTIAL DAMAGES WITH RESPECT TO ANY CLAIMS ARISING FROM THE
* CONTENT OF SUCH SOFTWARE AND/OR THE USE MADE BY CUSTOMERS OF THE CODING
* INFORMATION CONTAINED HEREIN IN CONNECTION WITH THEIR PRODUCTS.
*
* THIS SOFTWARE IS SPECIFICALLY DESIGNED FOR EXCLUSIVE USE WITH ST PARTS.
*
******************************************************************************/

#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/fs.h>
#include <linux/i2c.h>
#include <linux/i2c-dev.h>
#include <linux/uaccess.h>
#include <linux/lsm303dlh.h>
#include <linux/miscdevice.h>
#include <linux/input.h>
#include <linux/interrupt.h>

#include <linux/kthread.h>
#include <linux/delay.h>
#include <linux/freezer.h>

/* Temp defines till GPIO extender driver is fixed. */
/* #define A_USE_INT */
/* #define A_USE_GPIO_EXTENDER_INT */

/* lsm303dlh accelerometer registers */
#define WHO_AM_I    0x0F

/* ctrl 1: pm2 pm1 pm0 dr1 dr0 zenable yenable zenable */
#define CTRL_REG1       0x20    /* power control reg */
#define CTRL_REG2       0x21    /* power control reg */
#define CTRL_REG3       0x22    /* power control reg */
#define CTRL_REG4       0x23    /* interrupt control reg */
#define CTRL_REG5       0x24    /* interrupt control reg */
#define AXISDATA_REG    0x28
#define INT1_SRC_A_REG  0x31    /* interrupt 1 source reg */
#define INT2_SRC_A_REG  0x35    /* interrupt 2 source reg */

/* Sensitivity adjustment */
#define SHIFT_ADJ_2G 4 /*    1/16*/
#define SHIFT_ADJ_4G 3 /*    2/16*/
#define SHIFT_ADJ_8G 2 /* ~3.9/16*/

/* Control register 1 */
#define LSM303DLH_A_CR1_PM_BIT 5
#define LSM303DLH_A_CR1_PM_MASK (0x7 << LSM303DLH_A_CR1_PM_BIT)
#define LSM303DLH_A_CR1_DR_BIT 3
#define LSM303DLH_A_CR1_DR_MASK (0x3 << LSM303DLH_A_CR1_DR_BIT)
#define LSM303DLH_A_CR1_EN_BIT 0
#define LSM303DLH_A_CR1_EN_MASK (0x7 << LSM303DLH_A_CR1_EN_BIT)

/* Control register 2 */
#define LSM303DLH_A_CR4_ST_BIT 1
#define LSM303DLH_A_CR4_ST_MASK (0x1 << LSM303DLH_A_CR4_ST_BIT)
#define LSM303DLH_A_CR4_STS_BIT 3
#define LSM303DLH_A_CR4_STS_MASK (0x1 << LSM303DLH_A_CR4_STS_BIT)
#define LSM303DLH_A_CR4_FS_BIT 4
#define LSM303DLH_A_CR4_FS_MASK (0x3 << LSM303DLH_A_CR4_FS_BIT)
#define LSM303DLH_A_CR4_BLE_BIT 6
#define LSM303DLH_A_CR4_BLE_MASK (0x3 << LSM303DLH_A_CR4_BLE_BIT)

/* Control register 3 */
#define LSM303DLH_A_CR3_I1_BIT 0
#define LSM303DLH_A_CR3_I1_MASK (0x3 << LSM303DLH_A_CR3_I1_BIT)
#define LSM303DLH_A_CR3_LIR1_BIT 2
#define LSM303DLH_A_CR3_LIR1_MASK (0x1 << LSM303DLH_A_CR3_LIR1_BIT)
#define LSM303DLH_A_CR3_I2_BIT 3
#define LSM303DLH_A_CR3_I2_MASK (0x3 << LSM303DLH_A_CR3_I2_BIT)
#define LSM303DLH_A_CR3_LIR2_BIT 5
#define LSM303DLH_A_CR3_LIR2_MASK (0x1 << LSM303DLH_A_CR3_LIR2_BIT)
#define LSM303DLH_A_CR3_PPOD_BIT 6
#define LSM303DLH_A_CR3_PPOD_MASK (0x1 << LSM303DLH_A_CR3_PPOD_BIT)
#define LSM303DLH_A_CR3_IHL_BIT 7
#define LSM303DLH_A_CR3_IHL_MASK (0x1 << LSM303DLH_A_CR3_IHL_BIT)

#define LSM303DLH_A_CR3_I_SELF 0x0
#define LSM303DLH_A_CR3_I_OR   0x1
#define LSM303DLH_A_CR3_I_DATA 0x2
#define LSM303DLH_A_CR3_I_BOOT 0x3

#define LSM303DLH_A_CR3_LIR_LATCH 0x1

/*
 * lsm303dlh_a acceleration data
 * brief Structure containing acceleration values for x,y and z-axis in
 * signed short
 */

struct lsm303dlh_a_t {
	short	x; /* < x-axis acceleration data. Range -2048 to 2047. */
	short	y; /* < y-axis acceleration data. Range -2048 to 2047. */
	short	z; /* < z-axis acceleration data. Range -2048 to 2047. */
};

struct lsm303dlh_a_data {
	struct i2c_client *client;
	struct lsm303dlh_platform_data pdata;
	struct input_dev *input_dev;
	struct work_struct work;
	unsigned long a_open;
	u8 shift_adj;
	u8 ctrl_1;
	u8 mode;
	u8 rate;
	short ms;
#ifndef A_USE_INT
	struct task_struct *kthread;
#endif
};

static struct lsm303dlh_a_data *ldata;

/* set lsm303dlh accelerometer bandwidth */
int lsm303dlh_a_set_rate(unsigned char bw)
{
	unsigned char data;

	data = i2c_smbus_read_byte_data(ldata->client, CTRL_REG1);
	data &= ~LSM303DLH_A_CR1_DR_MASK;
	ldata->rate = bw;
	data |= ((bw << LSM303DLH_A_CR1_DR_BIT) & LSM303DLH_A_CR1_DR_MASK);

	return i2c_smbus_write_byte_data(ldata->client, CTRL_REG1, data);
}

/* read selected bandwidth from lsm303dlh_acc */
int lsm303dlh_a_get_bandwidth(unsigned char *bw)
{
	unsigned char data;

	data = i2c_smbus_read_byte_data(ldata->client, CTRL_REG1);
	data &= LSM303DLH_A_CR1_DR_MASK;
	data >>= LSM303DLH_A_CR1_DR_BIT;

	return data;
}

#ifndef A_USE_INT
static int lsm303dlh_a_kthread(void *data);
#endif


int lsm303dlh_a_set_mode(unsigned char mode)
{
	unsigned char data;
	int res;

	data = i2c_smbus_read_byte_data(ldata->client, CTRL_REG1);

	data &= ~LSM303DLH_A_CR1_PM_MASK;
	ldata->mode = mode;
	data |= ((mode << LSM303DLH_A_CR1_PM_BIT) & LSM303DLH_A_CR1_PM_MASK);

	res = i2c_smbus_write_byte_data(ldata->client, CTRL_REG1, data);
	if (res < 0)
		return res;

#ifndef A_USE_INT
	if (mode) {
		if (!ldata->kthread) {
			ldata->kthread = kthread_run(lsm303dlh_a_kthread, NULL,
				"klsm303dlh_a");
			if (IS_ERR(ldata->kthread))
				return PTR_ERR(ldata->kthread);
		}
	} else {
		if (ldata->kthread) {
			kthread_stop(ldata->kthread);
			ldata->kthread = NULL;
		}
	}
#endif

	return 0;
}

int lsm303dlh_a_set_range(unsigned char range)
{
	switch (range) {
	case LSM303DLH_A_RANGE_2G:
		ldata->shift_adj = SHIFT_ADJ_2G;
		break;
	case LSM303DLH_A_RANGE_4G:
		ldata->shift_adj = SHIFT_ADJ_4G;
		break;
	case LSM303DLH_A_RANGE_8G:
		ldata->shift_adj = SHIFT_ADJ_8G;
		break;
	default:
		return -EINVAL;
	}

	range <<= LSM303DLH_A_CR4_FS_BIT;

	return i2c_smbus_write_byte_data(ldata->client, CTRL_REG4, range);
}

/*  i2c read routine for lsm303dlh accelerometer */
static char lsm303dlh_a_i2c_read(unsigned char reg_addr,
				   unsigned char *data,
				   unsigned char len)
{
	int res;
	int i = 0;

	while (i < len) {
		res = i2c_smbus_read_byte_data(ldata->client, reg_addr++);
		if (res >= 0) {
			data[i] = res & 0xff;
			i++;
		} else {
			dev_err(&ldata->client->dev, "i2c read error\n");
			return res;
		}
	}

	return len;
}

/* X,Y and Z-axis acceleration data readout */
int lsm303dlh_a_read_xyz(struct lsm303dlh_a_t *data)
{
	int res;
	unsigned char acc_data[6];
	int hw_d[3] = { 0 };

	/* check lsm303dlh_a_client */
	if (ldata->client == NULL) {
		printk(KERN_ERR "I2C driver not install\n");
		return -EFAULT;
	}

	res = lsm303dlh_a_i2c_read(AXISDATA_REG, &acc_data[0], 6);

	if (res >= 0) {
		hw_d[0] = (short) (((acc_data[1]) << 8) | acc_data[0]);
		hw_d[1] = (short) (((acc_data[3]) << 8) | acc_data[2]);
		hw_d[2] = (short) (((acc_data[5]) << 8) | acc_data[4]);

		hw_d[0] >>= ldata->shift_adj;
		hw_d[1] >>= ldata->shift_adj;
		hw_d[2] >>= ldata->shift_adj;

		data->x = ldata->pdata.negative_x ?
			-hw_d[ldata->pdata.axis_map_x] :
			 hw_d[ldata->pdata.axis_map_x];
		data->y = ldata->pdata.negative_y ?
			-hw_d[ldata->pdata.axis_map_y] :
			 hw_d[ldata->pdata.axis_map_y];
		data->z = ldata->pdata.negative_z ?
			-hw_d[ldata->pdata.axis_map_z] :
			 hw_d[ldata->pdata.axis_map_z];
	}

	return res;
}

/*  open command for lsm303dlh_a device file  */
static int lsm303dlh_a_open(struct inode *inode, struct file *file)
{
	if (ldata->client == NULL) {
		printk(KERN_ERR"I2C driver not install\n");
		return -EINVAL;
	}

	if (test_and_set_bit(0, &ldata->a_open))
		return -EBUSY;

	dev_dbg(&ldata->client->dev, "lsm303dlh_a has been opened\n");

	return 0;
}

/*  release command for lsm303dlh_a device file */
static int lsm303dlh_a_close(struct inode *inode, struct file *file)
{
#ifndef A_USE_INT
	if (ldata->kthread) {
		kthread_stop(ldata->kthread);
		ldata->kthread = NULL;
	}
#endif

	clear_bit(0, &ldata->a_open);

	dev_dbg(&ldata->client->dev, "lsm303dlh_a has been closed\n");

	return 0;
}

/*  ioctl command for lsm303dlh_a device file */
static int lsm303dlh_a_ioctl(struct inode *inode, struct file *file,
			       unsigned int cmd, unsigned long arg)
{
	int err = 0;
	unsigned char data[6];

	/* check lsm303dlh_a_client */
	if (ldata->client == NULL) {
		printk(KERN_ERR "I2C driver not install\n");
		return -EFAULT;
	}

	/* cmd mapping */

	switch (cmd) {

	case LSM303DLH_A_SET_RANGE:
		if (copy_from_user(data, (unsigned char *)arg, 1) != 0) {
			dev_err(&ldata->client->dev, "copy_from_user error\n");
			return -EFAULT;
		}
		err = lsm303dlh_a_set_range(*data);
		return err;

	case LSM303DLH_A_SET_MODE:
		if (copy_from_user(data, (unsigned char *)arg, 1) != 0) {
			dev_err(&ldata->client->dev, "copy_from_user error\n");
			return -EFAULT;
		}
		err = lsm303dlh_a_set_mode(*data);

		return err;

	case LSM303DLH_A_SET_RATE:
		if (copy_from_user(data, (unsigned char *)arg, 1) != 0) {
			dev_err(&ldata->client->dev, "copy_from_user error\n");
			return -EFAULT;
		}
		err = lsm303dlh_a_set_rate(*data);
		return err;

	default:
		return 0;
	}
}

#ifndef A_USE_INT
static int lsm303dlh_a_calculate_ms(void)
{
	int ms;
	if (ldata->mode == LSM303DLH_A_MODE_NORMAL) {
		if (ldata->rate == LSM303DLH_A_RATE_50)
			ms = 20;
		else if (ldata->rate == LSM303DLH_A_RATE_100)
			ms = 10;
		else if (ldata->rate == LSM303DLH_A_RATE_400)
			ms = 2;
		else if (ldata->rate == LSM303DLH_A_RATE_1000)
			ms = 1;
		else
			ms = 1000;
	} else {
		if (ldata->mode == LSM303DLH_A_MODE_LP_HALF)
			ms = 2000;
		else if (ldata->mode == LSM303DLH_A_MODE_LP_1)
			ms = 1000;
		else if (ldata->mode == LSM303DLH_A_MODE_LP_2)
			ms = 500;
		else if (ldata->mode == LSM303DLH_A_MODE_LP_5)
			ms = 200;
		else if (ldata->mode == LSM303DLH_A_MODE_LP_10)
			ms = 100;
		else
			ms = 1000;
	}
	return ms;
}
#endif /* A_USE_INT */

#ifdef A_USE_INT
static void lsm303dlh_a_work_func(struct work_struct *work)
#else
static void lsm303dlh_a_work_func(void)
#endif /* A_USE_INT */
{
	int res;
	struct lsm303dlh_a_t abuf;

	/* Clear interrupt. */
	res = i2c_smbus_read_byte_data(ldata->client, INT1_SRC_A_REG);

	res = lsm303dlh_a_read_xyz(&abuf);

	if (res >= 0) {
		input_report_abs(ldata->input_dev, ABS_X, abuf.x);
		input_report_abs(ldata->input_dev, ABS_Y, abuf.y);
		input_report_abs(ldata->input_dev, ABS_Z, abuf.z);

		input_sync(ldata->input_dev);
	}

#ifdef A_USE_INT
	enable_irq(ldata->client->irq);
#endif
}

#ifndef A_USE_INT
/*
 * Kthread polling function
 * @data: unused - here to conform to threadfn prototype
 */
static int lsm303dlh_a_kthread(void *data)
{
	while (!kthread_should_stop()) {
		lsm303dlh_a_work_func();
		try_to_freeze();
		msleep_interruptible(lsm303dlh_a_calculate_ms());
	}

	return 0;
}
#endif /* A_USE_INT */

#ifdef A_USE_INT
#ifdef A_USE_GPIO_EXTENDER_INT
void lsm303dlh_a_interrupt(void *dev_id)
#else
static irqreturn_t lsm303dlh_a_interrupt(int irq, void *dev_id)
#endif /* A_USE_GPIO_EXTENDER_INT */
{
	struct lsm303dlh_a_data *adata = dev_id;
#ifndef A_USE_GPIO_EXTENDER_INT
	disable_irq(adata->client->irq);
#endif /* A_USE_GPIO_EXTENDER_INT */
	schedule_work(&adata->work);

#ifndef A_USE_GPIO_EXTENDER_INT
	return IRQ_HANDLED;
#endif /* A_USE_GPIO_EXTENDER_INT */
}
#endif /* A_USE_GPIO_EXTENDER_INT */

static const struct file_operations lsm303dlh_a_fops = {
	.owner = THIS_MODULE,
	.open = lsm303dlh_a_open,
	.release = lsm303dlh_a_close,
	.ioctl = lsm303dlh_a_ioctl,
};

static struct miscdevice lsm303dlh_a_misc_device = {
	.minor = MISC_DYNAMIC_MINOR,
	.name = "lsm303dlh_a",
	.fops = &lsm303dlh_a_fops,
};

static int lsm303dlh_a_validate_pdata(struct lsm303dlh_a_data *adata)
{
	if ((adata->pdata.axis_map_x > 2) ||
	    (adata->pdata.axis_map_y > 2) ||
	    (adata->pdata.axis_map_z > 2) ||
	    (adata->pdata.axis_map_x == adata->pdata.axis_map_y) ||
	    (adata->pdata.axis_map_x == adata->pdata.axis_map_z) ||
	    (adata->pdata.axis_map_y == adata->pdata.axis_map_z)) {
		dev_err(&adata->client->dev,
			"invalid axis_map value x:%u y:%u z%u\n",
			adata->pdata.axis_map_x, adata->pdata.axis_map_y,
			adata->pdata.axis_map_z);
		return -EINVAL;
	}

	/* Only allow 0 and 1 */
	if ((adata->pdata.negative_x > 1) ||
	    (adata->pdata.negative_y > 1) ||
	    (adata->pdata.negative_z > 1)) {
		dev_err(&adata->client->dev,
			"invalid negate value x:%u y:%u z:%u\n",
			adata->pdata.negative_x, adata->pdata.negative_y,
			adata->pdata.negative_z);
		return -EINVAL;
	}

#ifdef A_USE_GPIO_EXTENDER_INT
	if ((!adata->pdata.free_irq) || (!adata->pdata.register_irq))
		return -EINVAL;
#endif /* A_USE_GPIO_EXTENDER_INT */

	return 0;
}

static int lsm303dlh_a_probe(struct i2c_client *client,
			       const struct i2c_device_id *devid)
{
	int err = 0;
	int tempvalue;

	if (client->dev.platform_data == NULL) {
		dev_err(&client->dev, "platform data is NULL. exiting.\n");
		err = -ENODEV;
		goto exit;
	}
/* This check does not pass on i2c-stm?? */
#if 0
	if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) {
		err = -ENODEV;
		goto exit;
	}

	if (!i2c_check_functionality(client->adapter,
			I2C_FUNC_SMBUS_I2C_BLOCK)) {
		err = -ENODEV;
		goto exit;
	}
#endif

	/*
	 * OK. For now, we presume we have a valid client. We now create the
	 * client structure, even though we cannot fill it completely yet.
	 */
	ldata = kzalloc(sizeof(*ldata), GFP_KERNEL);
	if (ldata == NULL) {
		dev_err(&client->dev,
			"failed to allocate memory for module data\n");
		err = -ENOMEM;
		goto exit;
	}

	i2c_set_clientdata(client, ldata);
	ldata->client = client;

	memcpy(&ldata->pdata, client->dev.platform_data, sizeof(ldata->pdata));

	err = lsm303dlh_a_validate_pdata(ldata);
	if (err < 0) {
		dev_err(&client->dev, "failed to validate platform data\n");
		goto exit_kfree;
	}

	if (i2c_smbus_read_byte(client) < 0) {
		dev_err(&client->dev, "i2c_smbus_read_byte error!!\n");
		goto exit_kfree;
	} else {
		dev_info(&client->dev, "lsm303dlh_a Device detected!\n");
	}

	/* read chip id */
	tempvalue = i2c_smbus_read_byte_data(client, WHO_AM_I);
	if ((tempvalue & 0x00FF) == 0x0032) {
		dev_err(&client->dev, "i2c driver registered!\n");
	} else {
		err = -EINVAL;
		ldata->client = NULL;
		goto exit_kfree;
	}

#ifdef A_USE_INT
	INIT_WORK(&ldata->work, lsm303dlh_a_work_func);
#ifdef A_USE_GPIO_EXTENDER_INT
	if (ldata->pdata.register_irq(&client->dev, client,
		lsm303dlh_a_interrupt)) {
#else
	if (request_irq(client->irq, lsm303dlh_a_interrupt,
		IRQF_TRIGGER_HIGH, "lsm303dlh_a", ldata)) {
#endif /* A_USE_GPIO_EXTENDER_INT */
		err = -EBUSY;
		dev_err(&client->dev, "request irq failed\n");
		goto exit_kfree;
	}
#endif /* A_USE_INT */

	/* Set active high, latched interrupt when data is ready. */
	if (i2c_smbus_write_byte_data(client, CTRL_REG3,
		((LSM303DLH_A_CR3_I_DATA << LSM303DLH_A_CR3_I1_BIT) |
		(LSM303DLH_A_CR3_LIR_LATCH << LSM303DLH_A_CR3_LIR1_BIT)))) {
		dev_err(&client->dev, "interrutp configuration failed\n");
		err = -EINVAL;
		goto exit_free_irq;
	}

	if (misc_register(&lsm303dlh_a_misc_device)) {
		dev_err(&client->dev, "misc_register failed\n");
		err = -EINVAL;
		goto exit_free_irq;
	}

	ldata->input_dev = input_allocate_device();
	if (!ldata->input_dev) {
		err = -ENOMEM;
		dev_err(&client->dev, "Failed to allocate input device\n");
		goto exit_deregister_misc;
	}

	set_bit(EV_ABS, ldata->input_dev->evbit);

	/* x-axis acceleration */
	input_set_abs_params(ldata->input_dev, ABS_X, -2048, 2047, 0, 0);
	/* y-axis acceleration */
	input_set_abs_params(ldata->input_dev, ABS_Y, -2048, 2047, 0, 0);
	/* z-axis acceleration */
	input_set_abs_params(ldata->input_dev, ABS_Z, -2048, 2047, 0, 0);

	ldata->input_dev->name = "compass";

	err = input_register_device(ldata->input_dev);
	if (err) {
		dev_err(&client->dev, "Unable to register input device: %s\n",
			ldata->input_dev->name);
		goto exit_deregister_misc;
	}

	return 0;

exit_deregister_misc:
	misc_deregister(&lsm303dlh_a_misc_device);
exit_free_irq:
#ifdef A_USE_INT
#ifdef A_USE_GPIO_EXTENDER_INT
	ldata->pdata.free_irq(&client->dev);
#else
	free_irq(client->irq, ldata);
#endif /* A_USE_GPIO_EXTENDER_INT */
#endif /* A_USE_INT */

exit_kfree:
	kfree(ldata);
exit:
	dev_info(&client->dev, "%s: Driver Initialization failed\n", __FILE__);
	return err;
}

static int lsm303dlh_a_remove(struct i2c_client *client)
{
	dev_info(&client->dev, "lsm303dlh_a driver removing\n");
#ifdef A_USE_INT
#ifdef A_USE_GPIO_EXTENDER_INT
	ldata->pdata.free_irq(&client->dev);
#else
	free_irq(client->irq, ldata);
#endif /* A_USE_GPIO_EXTENDER_INT */
#endif /* A_USE_INT */

	misc_deregister(&lsm303dlh_a_misc_device);

	input_unregister_device(ldata->input_dev);

	kfree(ldata);

	return 0;
}
#ifdef CONFIG_PM
static int lsm303dlh_a_suspend(struct i2c_client *client, pm_message_t state)
{
	int res;

	dev_dbg(&client->dev, "lsm303dlh_a_suspend\n");

	res = i2c_smbus_read_byte_data(ldata->client, CTRL_REG1);
	if (res < 0)
		return res;

	ldata->ctrl_1 = res & 0xFF;

	/* Put sensor to sleep mode. */
	res = i2c_smbus_write_byte_data(ldata->client, CTRL_REG1, 0);
	if (res)
		return res;

#if defined(A_USE_INT) && !defined(A_USE_GPIO_EXTENDER_INT)
	disable_irq(client->irq);
#endif

	return 0;
}

static int lsm303dlh_a_resume(struct i2c_client *client)
{
	int res;

	dev_dbg(&client->dev, "lsm303dlh_a_resume\n");

	/* Resume sensor state. */
	res = i2c_smbus_write_byte_data(ldata->client, CTRL_REG1,
		ldata->ctrl_1);
	if (res)
		return res;

#if defined(A_USE_INT) && !defined(A_USE_GPIO_EXTENDER_INT)
	enable_irq(client->irq);
#endif

	return 0;
}
#endif

static const struct i2c_device_id lsm303dlh_a_id[] = {
	{ "lsm303dlh_a", 0 },
	{},
};

MODULE_DEVICE_TABLE(i2c, lsm303dlh_a_id);

static struct i2c_driver lsm303dlh_a_driver = {
	.class = I2C_CLASS_HWMON,
	.probe = lsm303dlh_a_probe,
	.remove = __devexit_p(lsm303dlh_a_remove),
	.id_table = lsm303dlh_a_id,
#ifdef CONFIG_PM
	.suspend = lsm303dlh_a_suspend,
	.resume = lsm303dlh_a_resume,
#endif
	.driver = {
	.owner = THIS_MODULE,
	.name = "lsm303dlh_a",
	},
};

static int __init lsm303dlh_a_init(void)
{
	return i2c_add_driver(&lsm303dlh_a_driver);
}

static void __exit lsm303dlh_a_exit(void)
{
	printk(KERN_INFO "lsm303dlh_a exit\n");

	i2c_del_driver(&lsm303dlh_a_driver);
	return;
}

module_init(lsm303dlh_a_init);
module_exit(lsm303dlh_a_exit);

MODULE_DESCRIPTION("lsm303dlh accelerometer driver");
MODULE_AUTHOR("STMicroelectronics");
MODULE_LICENSE("GPL");