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

Commit b029ffaf authored by Hemanth V's avatar Hemanth V Committed by Dmitry Torokhov
Browse files

Input: add CMA3000 accelerometer driver 



Add support for CMA3000 Tri-axis accelerometer, which supports Motion
detect, Measurement and Free fall modes. CMA3000 supports both I2C/SPI
bus for communication, currently the driver supports I2C based
communication.

Signed-off-by: default avatarHemanth V <hemanthv@ti.com>
Reviewed-by: default avatarJonathan Cameron <jic23@cam.ac.uk>
Reviewed-by: default avatarSergio Aguirre <saaguirre@ti.com>
Reviewed-by: default avatarShubhrajyoti <Shubhrajyoti@ti.com>
Signed-off-by: default avatarDmitry Torokhov <dtor@mail.ru>
parent 33e808c3

Documentation/input/cma3000_d0x.txt

0 → 100644
+115 −0
Original line number Diff line number Diff line 
Kernel driver for CMA3000-D0x

============================



Supported chips:

* VTI CMA3000-D0x

Datasheet:

  CMA3000-D0X Product Family Specification 8281000A.02.pdf

  <http://www.vti.fi/en/>



Author: Hemanth V <hemanthv@ti.com>





Description

-----------

CMA3000 Tri-axis accelerometer supports Motion detect, Measurement and

Free fall modes.



Motion Detect Mode: Its the low power mode where interrupts are generated only

when motion exceeds the defined thresholds.



Measurement Mode: This mode is used to read the acceleration data on X,Y,Z

axis and supports 400, 100, 40 Hz sample frequency.



Free fall Mode: This mode is intended to save system resources.



Threshold values: Chip supports defining threshold values for above modes

which includes time and g value. Refer product specifications for more details.



CMA3000 chip supports mutually exclusive I2C and SPI interfaces for

communication, currently the driver supports I2C based communication only.

Initial configuration for bus mode is set in non volatile memory and can later

be modified through bus interface command.



Driver reports acceleration data through input subsystem. It generates ABS_MISC

event with value 1 when free fall is detected.



Platform data need to be configured for initial default values.



Platform Data

-------------

fuzz_x: Noise on X Axis



fuzz_y: Noise on Y Axis



fuzz_z: Noise on Z Axis



g_range: G range in milli g i.e 2000 or 8000



mode: Default Operating mode



mdthr: Motion detect g range threshold value



mdfftmr: Motion detect and free fall time threshold value



ffthr: Free fall g range threshold value



Input Interface

--------------

Input driver version is 1.0.0

Input device ID: bus 0x18 vendor 0x0 product 0x0 version 0x0

Input device name: "cma3000-accelerometer"

Supported events:

  Event type 0 (Sync)

  Event type 3 (Absolute)

    Event code 0 (X)

      Value     47

      Min    -8000

      Max     8000

      Fuzz     200

    Event code 1 (Y)

      Value    -28

      Min    -8000

      Max     8000

      Fuzz     200

    Event code 2 (Z)

      Value    905

      Min    -8000

      Max     8000

      Fuzz     200

    Event code 40 (Misc)

      Value      0

      Min        0

      Max        1

  Event type 4 (Misc)





Register/Platform parameters Description

----------------------------------------



mode:

	0: power down mode

	1: 100 Hz Measurement mode

	2: 400 Hz Measurement mode

	3: 40 Hz Measurement mode

	4: Motion Detect mode (default)

	5: 100 Hz Free fall mode

	6: 40 Hz Free fall mode

	7: Power off mode



grange:

	2000: 2000 mg or 2G Range

	8000: 8000 mg or 8G Range



mdthr:

	X: X * 71mg (8G Range)

	X: X * 18mg (2G Range)



mdfftmr:

	X: (X & 0x70) * 100 ms (MDTMR)

	   (X & 0x0F) * 2.5 ms (FFTMR 400 Hz)

	   (X & 0x0F) * 10 ms  (FFTMR 100 Hz)



ffthr:

       X: (X >> 2) * 18mg (2G Range)

       X: (X & 0x0F) * 71 mg (8G Range)

drivers/input/misc/Kconfig

+24 −0
Original line number Diff line number Diff line
@@ -448,4 +448,28 @@ config INPUT_ADXL34X_SPI 
	  To compile this driver as a module, choose M here: the

	  module will be called adxl34x-spi.



config INPUT_CMA3000

	tristate "VTI CMA3000 Tri-axis accelerometer"

	help

	  Say Y here if you want to use VTI CMA3000_D0x Accelerometer

	  driver



	  This driver currently only supports I2C interface to the

	  controller. Also select the I2C method.



	  If unsure, say N



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

	  module will be called cma3000_d0x.



config INPUT_CMA3000_I2C

	tristate "Support I2C bus connection"

	depends on INPUT_CMA3000 && I2C

	help

	  Say Y here if you want to use VTI CMA3000_D0x Accelerometer

	  through I2C interface.



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

	  module will be called cma3000_d0x_i2c.



endif

drivers/input/misc/Makefile

+2 −0
Original line number Diff line number Diff line
@@ -18,6 +18,8 @@ obj-$(CONFIG_INPUT_ATI_REMOTE2) += ati_remote2.o 
obj-$(CONFIG_INPUT_ATLAS_BTNS)		+= atlas_btns.o

obj-$(CONFIG_INPUT_BFIN_ROTARY)		+= bfin_rotary.o

obj-$(CONFIG_INPUT_CM109)		+= cm109.o

obj-$(CONFIG_INPUT_CMA3000)		+= cma3000_d0x.o

obj-$(CONFIG_INPUT_CMA3000_I2C)		+= cma3000_d0x_i2c.o

obj-$(CONFIG_INPUT_COBALT_BTNS)		+= cobalt_btns.o

obj-$(CONFIG_INPUT_DM355EVM)		+= dm355evm_keys.o

obj-$(CONFIG_HP_SDC_RTC)		+= hp_sdc_rtc.o

drivers/input/misc/cma3000_d0x.c

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

 * VTI CMA3000_D0x Accelerometer driver

 *

 * Copyright (C) 2010 Texas Instruments

 * Author: Hemanth V <hemanthv@ti.com>

 *

 * 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.

 *

 * This program is distributed in the hope that it will be useful, but WITHOUT

 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for

 * more details.

 *

 * You should have received a copy of the GNU General Public License along with

 * this program.  If not, see <http://www.gnu.org/licenses/>.

 */



#include <linux/types.h>

#include <linux/interrupt.h>

#include <linux/delay.h>

#include <linux/slab.h>

#include <linux/input.h>

#include <linux/input/cma3000.h>



#include "cma3000_d0x.h"



#define CMA3000_WHOAMI      0x00

#define CMA3000_REVID       0x01

#define CMA3000_CTRL        0x02

#define CMA3000_STATUS      0x03

#define CMA3000_RSTR        0x04

#define CMA3000_INTSTATUS   0x05

#define CMA3000_DOUTX       0x06

#define CMA3000_DOUTY       0x07

#define CMA3000_DOUTZ       0x08

#define CMA3000_MDTHR       0x09

#define CMA3000_MDFFTMR     0x0A

#define CMA3000_FFTHR       0x0B



#define CMA3000_RANGE2G    (1 << 7)

#define CMA3000_RANGE8G    (0 << 7)

#define CMA3000_BUSI2C     (0 << 4)

#define CMA3000_MODEMASK   (7 << 1)

#define CMA3000_GRANGEMASK (1 << 7)



#define CMA3000_STATUS_PERR    1

#define CMA3000_INTSTATUS_FFDET (1 << 2)



/* Settling time delay in ms */

#define CMA3000_SETDELAY    30



/* Delay for clearing interrupt in us */

#define CMA3000_INTDELAY    44





/*

 * Bit weights in mg for bit 0, other bits need

 * multipy factor 2^n. Eight bit is the sign bit.

 */

#define BIT_TO_2G  18

#define BIT_TO_8G  71



struct cma3000_accl_data {

	const struct cma3000_bus_ops *bus_ops;

	const struct cma3000_platform_data *pdata;



	struct device *dev;

	struct input_dev *input_dev;



	int bit_to_mg;

	int irq;



	int g_range;

	u8 mode;



	struct mutex mutex;

	bool opened;

	bool suspended;

};



#define CMA3000_READ(data, reg, msg) \

	(data->bus_ops->read(data->dev, reg, msg))

#define CMA3000_SET(data, reg, val, msg) \

	((data)->bus_ops->write(data->dev, reg, val, msg))



/*

 * Conversion for each of the eight modes to g, depending

 * on G range i.e 2G or 8G. Some modes always operate in

 * 8G.

 */



static int mode_to_mg[8][2] = {

	{ 0, 0 },

	{ BIT_TO_8G, BIT_TO_2G },

	{ BIT_TO_8G, BIT_TO_2G },

	{ BIT_TO_8G, BIT_TO_8G },

	{ BIT_TO_8G, BIT_TO_8G },

	{ BIT_TO_8G, BIT_TO_2G },

	{ BIT_TO_8G, BIT_TO_2G },

	{ 0, 0},

};



static void decode_mg(struct cma3000_accl_data *data, int *datax,

				int *datay, int *dataz)

{

	/* Data in 2's complement, convert to mg */

	*datax = ((s8)*datax) * data->bit_to_mg;

	*datay = ((s8)*datay) * data->bit_to_mg;

	*dataz = ((s8)*dataz) * data->bit_to_mg;

}



static irqreturn_t cma3000_thread_irq(int irq, void *dev_id)

{

	struct cma3000_accl_data *data = dev_id;

	int datax, datay, dataz;

	u8 ctrl, mode, range, intr_status;



	intr_status = CMA3000_READ(data, CMA3000_INTSTATUS, "interrupt status");

	if (intr_status < 0)

		return IRQ_NONE;



	/* Check if free fall is detected, report immediately */

	if (intr_status & CMA3000_INTSTATUS_FFDET) {

		input_report_abs(data->input_dev, ABS_MISC, 1);

		input_sync(data->input_dev);

	} else {

		input_report_abs(data->input_dev, ABS_MISC, 0);

	}



	datax = CMA3000_READ(data, CMA3000_DOUTX, "X");

	datay = CMA3000_READ(data, CMA3000_DOUTY, "Y");

	dataz = CMA3000_READ(data, CMA3000_DOUTZ, "Z");



	ctrl = CMA3000_READ(data, CMA3000_CTRL, "ctrl");

	mode = (ctrl & CMA3000_MODEMASK) >> 1;

	range = (ctrl & CMA3000_GRANGEMASK) >> 7;



	data->bit_to_mg = mode_to_mg[mode][range];



	/* Interrupt not for this device */

	if (data->bit_to_mg == 0)

		return IRQ_NONE;



	/* Decode register values to milli g */

	decode_mg(data, &datax, &datay, &dataz);



	input_report_abs(data->input_dev, ABS_X, datax);

	input_report_abs(data->input_dev, ABS_Y, datay);

	input_report_abs(data->input_dev, ABS_Z, dataz);

	input_sync(data->input_dev);



	return IRQ_HANDLED;

}



static int cma3000_reset(struct cma3000_accl_data *data)

{

	int val;



	/* Reset sequence */

	CMA3000_SET(data, CMA3000_RSTR, 0x02, "Reset");

	CMA3000_SET(data, CMA3000_RSTR, 0x0A, "Reset");

	CMA3000_SET(data, CMA3000_RSTR, 0x04, "Reset");



	/* Settling time delay */

	mdelay(10);



	val = CMA3000_READ(data, CMA3000_STATUS, "Status");

	if (val < 0) {

		dev_err(data->dev, "Reset failed\n");

		return val;

	}



	if (val & CMA3000_STATUS_PERR) {

		dev_err(data->dev, "Parity Error\n");

		return -EIO;

	}



	return 0;

}



static int cma3000_poweron(struct cma3000_accl_data *data)

{

	const struct cma3000_platform_data *pdata = data->pdata;

	u8 ctrl = 0;

	int ret;



	if (data->g_range == CMARANGE_2G) {

		ctrl = (data->mode << 1) | CMA3000_RANGE2G;

	} else if (data->g_range == CMARANGE_8G) {

		ctrl = (data->mode << 1) | CMA3000_RANGE8G;

	} else {

		dev_info(data->dev,

			 "Invalid G range specified, assuming 8G\n");

		ctrl = (data->mode << 1) | CMA3000_RANGE8G;

	}



	ctrl |= data->bus_ops->ctrl_mod;



	CMA3000_SET(data, CMA3000_MDTHR, pdata->mdthr,

		    "Motion Detect Threshold");

	CMA3000_SET(data, CMA3000_MDFFTMR, pdata->mdfftmr,

		    "Time register");

	CMA3000_SET(data, CMA3000_FFTHR, pdata->ffthr,

		    "Free fall threshold");

	ret = CMA3000_SET(data, CMA3000_CTRL, ctrl, "Mode setting");

	if (ret < 0)

		return -EIO;



	msleep(CMA3000_SETDELAY);



	return 0;

}



static int cma3000_poweroff(struct cma3000_accl_data *data)

{

	int ret;



	ret = CMA3000_SET(data, CMA3000_CTRL, CMAMODE_POFF, "Mode setting");

	msleep(CMA3000_SETDELAY);



	return ret;

}



static int cma3000_open(struct input_dev *input_dev)

{

	struct cma3000_accl_data *data = input_get_drvdata(input_dev);



	mutex_lock(&data->mutex);



	if (!data->suspended)

		cma3000_poweron(data);



	data->opened = true;



	mutex_unlock(&data->mutex);



	return 0;

}



static void cma3000_close(struct input_dev *input_dev)

{

	struct cma3000_accl_data *data = input_get_drvdata(input_dev);



	mutex_lock(&data->mutex);



	if (!data->suspended)

		cma3000_poweroff(data);



	data->opened = false;



	mutex_unlock(&data->mutex);

}



void cma3000_suspend(struct cma3000_accl_data *data)

{

	mutex_lock(&data->mutex);



	if (!data->suspended && data->opened)

		cma3000_poweroff(data);



	data->suspended = true;



	mutex_unlock(&data->mutex);

}

EXPORT_SYMBOL(cma3000_suspend);





void cma3000_resume(struct cma3000_accl_data *data)

{

	mutex_lock(&data->mutex);



	if (data->suspended && data->opened)

		cma3000_poweron(data);



	data->suspended = false;



	mutex_unlock(&data->mutex);

}

EXPORT_SYMBOL(cma3000_resume);



struct cma3000_accl_data *cma3000_init(struct device *dev, int irq,

				       const struct cma3000_bus_ops *bops)

{

	const struct cma3000_platform_data *pdata = dev->platform_data;

	struct cma3000_accl_data *data;

	struct input_dev *input_dev;

	int rev;

	int error;



	if (!pdata) {

		dev_err(dev, "platform data not found\n");

		error = -EINVAL;

		goto err_out;

	}





	/* if no IRQ return error */

	if (irq == 0) {

		error = -EINVAL;

		goto err_out;

	}



	data = kzalloc(sizeof(struct cma3000_accl_data), GFP_KERNEL);

	input_dev = input_allocate_device();

	if (!data || !input_dev) {

		error = -ENOMEM;

		goto err_free_mem;

	}



	data->dev = dev;

	data->input_dev = input_dev;

	data->bus_ops = bops;

	data->pdata = pdata;

	data->irq = irq;

	mutex_init(&data->mutex);



	data->mode = pdata->mode;

	if (data->mode < CMAMODE_DEFAULT || data->mode > CMAMODE_POFF) {

		data->mode = CMAMODE_MOTDET;

		dev_warn(dev,

			 "Invalid mode specified, assuming Motion Detect\n");

	}



	data->g_range = pdata->g_range;

	if (data->g_range != CMARANGE_2G && data->g_range != CMARANGE_8G) {

		dev_info(dev,

			 "Invalid G range specified, assuming 8G\n");

		data->g_range = CMARANGE_8G;

	}



	input_dev->name = "cma3000-accelerometer";

	input_dev->id.bustype = bops->bustype;

	input_dev->open = cma3000_open;

	input_dev->close = cma3000_close;



	 __set_bit(EV_ABS, input_dev->evbit);



	input_set_abs_params(input_dev, ABS_X,

			-data->g_range, data->g_range, pdata->fuzz_x, 0);

	input_set_abs_params(input_dev, ABS_Y,

			-data->g_range, data->g_range, pdata->fuzz_y, 0);

	input_set_abs_params(input_dev, ABS_Z,

			-data->g_range, data->g_range, pdata->fuzz_z, 0);

	input_set_abs_params(input_dev, ABS_MISC, 0, 1, 0, 0);



	input_set_drvdata(input_dev, data);



	error = cma3000_reset(data);

	if (error)

		goto err_free_mem;



	rev = CMA3000_READ(data, CMA3000_REVID, "Revid");

	if (rev < 0) {

		error = rev;

		goto err_free_mem;

	}



	pr_info("CMA3000 Accelerometer: Revision %x\n", rev);



	error = request_threaded_irq(irq, NULL, cma3000_thread_irq,

				     pdata->irqflags | IRQF_ONESHOT,

				     "cma3000_d0x", data);

	if (error) {

		dev_err(dev, "request_threaded_irq failed\n");

		goto err_free_mem;

	}



	error = input_register_device(data->input_dev);

	if (error) {

		dev_err(dev, "Unable to register input device\n");

		goto err_free_irq;

	}



	return data;



err_free_irq:

	free_irq(irq, data);

err_free_mem:

	input_free_device(input_dev);

	kfree(data);

err_out:

	return ERR_PTR(error);

}

EXPORT_SYMBOL(cma3000_init);



void cma3000_exit(struct cma3000_accl_data *data)

{

	free_irq(data->irq, data);

	input_unregister_device(data->input_dev);

	kfree(data);

}

EXPORT_SYMBOL(cma3000_exit);



MODULE_DESCRIPTION("CMA3000-D0x Accelerometer Driver");

MODULE_LICENSE("GPL");

MODULE_AUTHOR("Hemanth V <hemanthv@ti.com>");

drivers/input/misc/cma3000_d0x.h

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

 * VTI CMA3000_D0x Accelerometer driver

 *

 * Copyright (C) 2010 Texas Instruments

 * Author: Hemanth V <hemanthv@ti.com>

 *

 * 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.

 *

 * This program is distributed in the hope that it will be useful, but WITHOUT

 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for

 * more details.

 *

 * You should have received a copy of the GNU General Public License along with

 * this program.  If not, see <http://www.gnu.org/licenses/>.

 */



#ifndef _INPUT_CMA3000_H

#define _INPUT_CMA3000_H



#include <linux/types.h>

#include <linux/input.h>



struct device;

struct cma3000_accl_data;



struct cma3000_bus_ops {

	u16 bustype;

	u8 ctrl_mod;

	int (*read)(struct device *, u8, char *);

	int (*write)(struct device *, u8, u8, char *);

};



struct cma3000_accl_data *cma3000_init(struct device *dev, int irq,

					const struct cma3000_bus_ops *bops);

void cma3000_exit(struct cma3000_accl_data *);

void cma3000_suspend(struct cma3000_accl_data *);

void cma3000_resume(struct cma3000_accl_data *);



#endif