[linux-2.6-block.git] / drivers / input / misc / mma8450.c

// SPDX-License-Identifier: GPL-2.0-or-later
/*
 *  Driver for Freescale's 3-Axis Accelerometer MMA8450
 *
 *  Copyright (C) 2011 Freescale Semiconductor, Inc. All Rights Reserved.
 */

#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/slab.h>
#include <linux/delay.h>
#include <linux/i2c.h>
#include <linux/input.h>
#include <linux/mod_devicetable.h>

#define MMA8450_DRV_NAME	"mma8450"

#define MODE_CHANGE_DELAY_MS	100
#define POLL_INTERVAL		100
#define POLL_INTERVAL_MAX	500

/* register definitions */
#define MMA8450_STATUS		0x00
#define MMA8450_STATUS_ZXYDR	0x08

#define MMA8450_OUT_X8		0x01
#define MMA8450_OUT_Y8		0x02
#define MMA8450_OUT_Z8		0x03

#define MMA8450_OUT_X_LSB	0x05
#define MMA8450_OUT_X_MSB	0x06
#define MMA8450_OUT_Y_LSB	0x07
#define MMA8450_OUT_Y_MSB	0x08
#define MMA8450_OUT_Z_LSB	0x09
#define MMA8450_OUT_Z_MSB	0x0a

#define MMA8450_XYZ_DATA_CFG	0x16

#define MMA8450_CTRL_REG1	0x38
#define MMA8450_CTRL_REG2	0x39

static int mma8450_read(struct i2c_client *c, unsigned int off)
{
	int ret;

	ret = i2c_smbus_read_byte_data(c, off);
	if (ret < 0)
		dev_err(&c->dev,
			"failed to read register 0x%02x, error %d\n",
			off, ret);

	return ret;
}

static int mma8450_write(struct i2c_client *c, unsigned int off, u8 v)
{
	int error;

	error = i2c_smbus_write_byte_data(c, off, v);
	if (error < 0) {
		dev_err(&c->dev,
			"failed to write to register 0x%02x, error %d\n",
			off, error);
		return error;
	}

	return 0;
}

static int mma8450_read_block(struct i2c_client *c, unsigned int off,
			      u8 *buf, size_t size)
{
	int err;

	err = i2c_smbus_read_i2c_block_data(c, off, size, buf);
	if (err < 0) {
		dev_err(&c->dev,
			"failed to read block data at 0x%02x, error %d\n",
			MMA8450_OUT_X_LSB, err);
		return err;
	}

	return 0;
}

static void mma8450_poll(struct input_dev *input)
{
	struct i2c_client *c = input_get_drvdata(input);
	int x, y, z;
	int ret;
	u8 buf[6];

	ret = mma8450_read(c, MMA8450_STATUS);
	if (ret < 0)
		return;

	if (!(ret & MMA8450_STATUS_ZXYDR))
		return;

	ret = mma8450_read_block(c, MMA8450_OUT_X_LSB, buf, sizeof(buf));
	if (ret < 0)
		return;

	x = ((int)(s8)buf[1] << 4) | (buf[0] & 0xf);
	y = ((int)(s8)buf[3] << 4) | (buf[2] & 0xf);
	z = ((int)(s8)buf[5] << 4) | (buf[4] & 0xf);

	input_report_abs(input, ABS_X, x);
	input_report_abs(input, ABS_Y, y);
	input_report_abs(input, ABS_Z, z);
	input_sync(input);
}

/* Initialize the MMA8450 chip */
static int mma8450_open(struct input_dev *input)
{
	struct i2c_client *c = input_get_drvdata(input);
	int err;

	/* enable all events from X/Y/Z, no FIFO */
	err = mma8450_write(c, MMA8450_XYZ_DATA_CFG, 0x07);
	if (err)
		return err;

	/*
	 * Sleep mode poll rate - 50Hz
	 * System output data rate - 400Hz
	 * Full scale selection - Active, +/- 2G
	 */
	err = mma8450_write(c, MMA8450_CTRL_REG1, 0x01);
	if (err)
		return err;

	msleep(MODE_CHANGE_DELAY_MS);
	return 0;
}

static void mma8450_close(struct input_dev *input)
{
	struct i2c_client *c = input_get_drvdata(input);

	mma8450_write(c, MMA8450_CTRL_REG1, 0x00);
	mma8450_write(c, MMA8450_CTRL_REG2, 0x01);
}

/*
 * I2C init/probing/exit functions
 */
static int mma8450_probe(struct i2c_client *c)
{
	struct input_dev *input;
	int err;

	input = devm_input_allocate_device(&c->dev);
	if (!input)
		return -ENOMEM;

	input_set_drvdata(input, c);

	input->name = MMA8450_DRV_NAME;
	input->id.bustype = BUS_I2C;

	input->open = mma8450_open;
	input->close = mma8450_close;

	input_set_abs_params(input, ABS_X, -2048, 2047, 32, 32);
	input_set_abs_params(input, ABS_Y, -2048, 2047, 32, 32);
	input_set_abs_params(input, ABS_Z, -2048, 2047, 32, 32);

	err = input_setup_polling(input, mma8450_poll);
	if (err) {
		dev_err(&c->dev, "failed to set up polling\n");
		return err;
	}

	input_set_poll_interval(input, POLL_INTERVAL);
	input_set_max_poll_interval(input, POLL_INTERVAL_MAX);

	err = input_register_device(input);
	if (err) {
		dev_err(&c->dev, "failed to register input device\n");
		return err;
	}

	return 0;
}

static const struct i2c_device_id mma8450_id[] = {
	{ MMA8450_DRV_NAME },
	{ }
};
MODULE_DEVICE_TABLE(i2c, mma8450_id);

static const struct of_device_id mma8450_dt_ids[] = {
	{ .compatible = "fsl,mma8450", },
	{ /* sentinel */ }
};
MODULE_DEVICE_TABLE(of, mma8450_dt_ids);

static struct i2c_driver mma8450_driver = {
	.driver = {
		.name	= MMA8450_DRV_NAME,
		.of_match_table = mma8450_dt_ids,
	},
	.probe		= mma8450_probe,
	.id_table	= mma8450_id,
};

module_i2c_driver(mma8450_driver);

MODULE_AUTHOR("Freescale Semiconductor, Inc.");
MODULE_DESCRIPTION("MMA8450 3-Axis Accelerometer Driver");
MODULE_LICENSE("GPL");
Commit	Line	Data
74ba9207	1	// SPDX-License-Identifier: GPL-2.0-or-later
3ead8b5d EM	2	/*
	3	* Driver for Freescale's 3-Axis Accelerometer MMA8450
	4	*
	5	* Copyright (C) 2011 Freescale Semiconductor, Inc. All Rights Reserved.
3ead8b5d EM	6	*/
	7
	8	#include <linux/kernel.h>
	9	#include <linux/module.h>
	10	#include <linux/slab.h>
	11	#include <linux/delay.h>
	12	#include <linux/i2c.h>
867e8820	13	#include <linux/input.h>
dbce1a7d	14	#include <linux/mod_devicetable.h>
3ead8b5d EM	15
	16	#define MMA8450_DRV_NAME "mma8450"
	17
	18	#define MODE_CHANGE_DELAY_MS 100
	19	#define POLL_INTERVAL 100
	20	#define POLL_INTERVAL_MAX 500
	21
	22	/* register definitions */
	23	#define MMA8450_STATUS 0x00
	24	#define MMA8450_STATUS_ZXYDR 0x08
	25
	26	#define MMA8450_OUT_X8 0x01
	27	#define MMA8450_OUT_Y8 0x02
	28	#define MMA8450_OUT_Z8 0x03
	29
	30	#define MMA8450_OUT_X_LSB 0x05
	31	#define MMA8450_OUT_X_MSB 0x06
	32	#define MMA8450_OUT_Y_LSB 0x07
	33	#define MMA8450_OUT_Y_MSB 0x08
	34	#define MMA8450_OUT_Z_LSB 0x09
	35	#define MMA8450_OUT_Z_MSB 0x0a
	36
	37	#define MMA8450_XYZ_DATA_CFG 0x16
	38
	39	#define MMA8450_CTRL_REG1 0x38
	40	#define MMA8450_CTRL_REG2 0x39
	41
867e8820	42	static int mma8450_read(struct i2c_client *c, unsigned int off)
3ead8b5d	43	{
3ead8b5d EM	44	int ret;
	45
	46	ret = i2c_smbus_read_byte_data(c, off);
	47	if (ret < 0)
	48	dev_err(&c->dev,
	49	"failed to read register 0x%02x, error %d\n",
	50	off, ret);
	51
	52	return ret;
	53	}
	54
867e8820	55	static int mma8450_write(struct i2c_client *c, unsigned int off, u8 v)
3ead8b5d	56	{
3ead8b5d EM	57	int error;
	58
	59	error = i2c_smbus_write_byte_data(c, off, v);
	60	if (error < 0) {
	61	dev_err(&c->dev,
	62	"failed to write to register 0x%02x, error %d\n",
	63	off, error);
	64	return error;
	65	}
	66
	67	return 0;
	68	}
	69
867e8820	70	static int mma8450_read_block(struct i2c_client *c, unsigned int off,
cb31f898	71	u8 *buf, size_t size)
3ead8b5d	72	{
3ead8b5d EM	73	int err;
3ead8b5d EM	74
cb31f898	75	err = i2c_smbus_read_i2c_block_data(c, off, size, buf);
3ead8b5d EM	76	if (err < 0) {
	77	dev_err(&c->dev,
	78	"failed to read block data at 0x%02x, error %d\n",
	79	MMA8450_OUT_X_LSB, err);
	80	return err;
	81	}
	82
3ead8b5d EM	83	return 0;
	84	}
	85
867e8820	86	static void mma8450_poll(struct input_dev *input)
3ead8b5d	87	{
867e8820	88	struct i2c_client *c = input_get_drvdata(input);
3ead8b5d EM	89	int x, y, z;
3ead8b5d EM	90	int ret;
cb31f898	91	u8 buf[6];
3ead8b5d	92
867e8820	93	ret = mma8450_read(c, MMA8450_STATUS);
3ead8b5d EM	94	if (ret < 0)
	95	return;
	96
	97	if (!(ret & MMA8450_STATUS_ZXYDR))
	98	return;
	99
867e8820	100	ret = mma8450_read_block(c, MMA8450_OUT_X_LSB, buf, sizeof(buf));
cb31f898	101	if (ret < 0)
3ead8b5d EM	102	return;
3ead8b5d EM	103
257a1ec6 SR	104	x = ((int)(s8)buf[1] << 4) \| (buf[0] & 0xf);
	105	y = ((int)(s8)buf[3] << 4) \| (buf[2] & 0xf);
	106	z = ((int)(s8)buf[5] << 4) \| (buf[4] & 0xf);
cb31f898	107
867e8820 DT	108	input_report_abs(input, ABS_X, x);
	109	input_report_abs(input, ABS_Y, y);
	110	input_report_abs(input, ABS_Z, z);
	111	input_sync(input);
3ead8b5d EM	112	}
	113
	114	/* Initialize the MMA8450 chip */
867e8820	115	static int mma8450_open(struct input_dev *input)
3ead8b5d	116	{
867e8820	117	struct i2c_client *c = input_get_drvdata(input);
3ead8b5d EM	118	int err;
	119
	120	/* enable all events from X/Y/Z, no FIFO */
867e8820	121	err = mma8450_write(c, MMA8450_XYZ_DATA_CFG, 0x07);
3ead8b5d	122	if (err)
867e8820	123	return err;
3ead8b5d EM	124
	125	/*
	126	* Sleep mode poll rate - 50Hz
	127	* System output data rate - 400Hz
	128	* Full scale selection - Active, +/- 2G
	129	*/
867e8820 DT	130	err = mma8450_write(c, MMA8450_CTRL_REG1, 0x01);
	131	if (err)
	132	return err;
3ead8b5d EM	133
3ead8b5d EM	134	msleep(MODE_CHANGE_DELAY_MS);
867e8820	135	return 0;
3ead8b5d EM	136	}
3ead8b5d EM	137
867e8820	138	static void mma8450_close(struct input_dev *input)
3ead8b5d	139	{
867e8820	140	struct i2c_client *c = input_get_drvdata(input);
3ead8b5d	141
867e8820 DT	142	mma8450_write(c, MMA8450_CTRL_REG1, 0x00);
867e8820 DT	143	mma8450_write(c, MMA8450_CTRL_REG2, 0x01);
3ead8b5d EM	144	}
	145
	146	/*
	147	* I2C init/probing/exit functions
	148	*/
7f4a8e20	149	static int mma8450_probe(struct i2c_client *c)
3ead8b5d	150	{
867e8820	151	struct input_dev *input;
3ead8b5d EM	152	int err;
3ead8b5d EM	153
867e8820 DT	154	input = devm_input_allocate_device(&c->dev);
867e8820 DT	155	if (!input)
5037a179 DT	156	return -ENOMEM;
5037a179 DT	157
867e8820 DT	158	input_set_drvdata(input, c);
	159
	160	input->name = MMA8450_DRV_NAME;
	161	input->id.bustype = BUS_I2C;
	162
	163	input->open = mma8450_open;
	164	input->close = mma8450_close;
3ead8b5d	165
867e8820 DT	166	input_set_abs_params(input, ABS_X, -2048, 2047, 32, 32);
	167	input_set_abs_params(input, ABS_Y, -2048, 2047, 32, 32);
	168	input_set_abs_params(input, ABS_Z, -2048, 2047, 32, 32);
3ead8b5d	169
867e8820 DT	170	err = input_setup_polling(input, mma8450_poll);
	171	if (err) {
	172	dev_err(&c->dev, "failed to set up polling\n");
	173	return err;
	174	}
3ead8b5d	175
867e8820 DT	176	input_set_poll_interval(input, POLL_INTERVAL);
867e8820 DT	177	input_set_max_poll_interval(input, POLL_INTERVAL_MAX);
3ead8b5d	178
867e8820	179	err = input_register_device(input);
3ead8b5d	180	if (err) {
867e8820	181	dev_err(&c->dev, "failed to register input device\n");
5037a179	182	return err;
3ead8b5d EM	183	}
3ead8b5d EM	184
3ead8b5d EM	185	return 0;
	186	}
	187
	188	static const struct i2c_device_id mma8450_id[] = {
5852f2af UKK	189	{ MMA8450_DRV_NAME },
5852f2af UKK	190	{ }
3ead8b5d EM	191	};
	192	MODULE_DEVICE_TABLE(i2c, mma8450_id);
	193
71ff069c SG	194	static const struct of_device_id mma8450_dt_ids[] = {
	195	{ .compatible = "fsl,mma8450", },
	196	{ /* sentinel */ }
	197	};
cd566c64	198	MODULE_DEVICE_TABLE(of, mma8450_dt_ids);
71ff069c	199
3ead8b5d EM	200	static struct i2c_driver mma8450_driver = {
	201	.driver = {
	202	.name = MMA8450_DRV_NAME,
71ff069c	203	.of_match_table = mma8450_dt_ids,
3ead8b5d	204	},
d8bde56d	205	.probe = mma8450_probe,
3ead8b5d EM	206	.id_table = mma8450_id,
	207	};
	208
1b92c1cf	209	module_i2c_driver(mma8450_driver);
3ead8b5d EM	210
	211	MODULE_AUTHOR("Freescale Semiconductor, Inc.");
	212	MODULE_DESCRIPTION("MMA8450 3-Axis Accelerometer Driver");
	213	MODULE_LICENSE("GPL");