cregit-Linux how code gets into the kernel

Release 4.11 drivers/input/misc/adxl34x.c

/*
 * ADXL345/346 Three-Axis Digital Accelerometers
 *
 * Enter bugs at http://blackfin.uclinux.org/
 *
 * Copyright (C) 2009 Michael Hennerich, Analog Devices Inc.
 * Licensed under the GPL-2 or later.
 */

#include <linux/device.h>
#include <linux/delay.h>
#include <linux/input.h>
#include <linux/interrupt.h>
#include <linux/irq.h>
#include <linux/slab.h>
#include <linux/workqueue.h>
#include <linux/input/adxl34x.h>
#include <linux/module.h>

#include "adxl34x.h"

/* ADXL345/6 Register Map */

#define DEVID		0x00	
/* R   Device ID */

#define THRESH_TAP	0x1D	
/* R/W Tap threshold */

#define OFSX		0x1E	
/* R/W X-axis offset */

#define OFSY		0x1F	
/* R/W Y-axis offset */

#define OFSZ		0x20	
/* R/W Z-axis offset */

#define DUR		0x21	
/* R/W Tap duration */

#define LATENT		0x22	
/* R/W Tap latency */

#define WINDOW		0x23	
/* R/W Tap window */

#define THRESH_ACT	0x24	
/* R/W Activity threshold */

#define THRESH_INACT	0x25	
/* R/W Inactivity threshold */

#define TIME_INACT	0x26	
/* R/W Inactivity time */

#define ACT_INACT_CTL	0x27	
/* R/W Axis enable control for activity and */
				/* inactivity detection */

#define THRESH_FF	0x28	
/* R/W Free-fall threshold */

#define TIME_FF		0x29	
/* R/W Free-fall time */

#define TAP_AXES	0x2A	
/* R/W Axis control for tap/double tap */

#define ACT_TAP_STATUS	0x2B	
/* R   Source of tap/double tap */

#define BW_RATE		0x2C	
/* R/W Data rate and power mode control */

#define POWER_CTL	0x2D	
/* R/W Power saving features control */

#define INT_ENABLE	0x2E	
/* R/W Interrupt enable control */

#define INT_MAP		0x2F	
/* R/W Interrupt mapping control */

#define INT_SOURCE	0x30	
/* R   Source of interrupts */

#define DATA_FORMAT	0x31	
/* R/W Data format control */

#define DATAX0		0x32	
/* R   X-Axis Data 0 */

#define DATAX1		0x33	
/* R   X-Axis Data 1 */

#define DATAY0		0x34	
/* R   Y-Axis Data 0 */

#define DATAY1		0x35	
/* R   Y-Axis Data 1 */

#define DATAZ0		0x36	
/* R   Z-Axis Data 0 */

#define DATAZ1		0x37	
/* R   Z-Axis Data 1 */

#define FIFO_CTL	0x38	
/* R/W FIFO control */

#define FIFO_STATUS	0x39	
/* R   FIFO status */

#define TAP_SIGN	0x3A	
/* R   Sign and source for tap/double tap */
/* Orientation ADXL346 only */

#define ORIENT_CONF	0x3B	
/* R/W Orientation configuration */

#define ORIENT		0x3C	
/* R   Orientation status */

/* DEVIDs */

#define ID_ADXL345	0xE5

#define ID_ADXL346	0xE6

/* INT_ENABLE/INT_MAP/INT_SOURCE Bits */

#define DATA_READY	(1 << 7)

#define SINGLE_TAP	(1 << 6)

#define DOUBLE_TAP	(1 << 5)

#define ACTIVITY	(1 << 4)

#define INACTIVITY	(1 << 3)

#define FREE_FALL	(1 << 2)

#define WATERMARK	(1 << 1)

#define OVERRUN		(1 << 0)

/* ACT_INACT_CONTROL Bits */

#define ACT_ACDC	(1 << 7)

#define ACT_X_EN	(1 << 6)

#define ACT_Y_EN	(1 << 5)

#define ACT_Z_EN	(1 << 4)

#define INACT_ACDC	(1 << 3)

#define INACT_X_EN	(1 << 2)

#define INACT_Y_EN	(1 << 1)

#define INACT_Z_EN	(1 << 0)

/* TAP_AXES Bits */

#define SUPPRESS	(1 << 3)

#define TAP_X_EN	(1 << 2)

#define TAP_Y_EN	(1 << 1)

#define TAP_Z_EN	(1 << 0)

/* ACT_TAP_STATUS Bits */

#define ACT_X_SRC	(1 << 6)

#define ACT_Y_SRC	(1 << 5)

#define ACT_Z_SRC	(1 << 4)

#define ASLEEP		(1 << 3)

#define TAP_X_SRC	(1 << 2)

#define TAP_Y_SRC	(1 << 1)

#define TAP_Z_SRC	(1 << 0)

/* BW_RATE Bits */

#define LOW_POWER	(1 << 4)

#define RATE(x)		((x) & 0xF)

/* POWER_CTL Bits */

#define PCTL_LINK	(1 << 5)

#define PCTL_AUTO_SLEEP (1 << 4)

#define PCTL_MEASURE	(1 << 3)

#define PCTL_SLEEP	(1 << 2)

#define PCTL_WAKEUP(x)	((x) & 0x3)

/* DATA_FORMAT Bits */

#define SELF_TEST	(1 << 7)

#define SPI		(1 << 6)

#define INT_INVERT	(1 << 5)

#define FULL_RES	(1 << 3)

#define JUSTIFY		(1 << 2)

#define RANGE(x)	((x) & 0x3)

#define RANGE_PM_2g	0

#define RANGE_PM_4g	1

#define RANGE_PM_8g	2

#define RANGE_PM_16g	3

/*
 * Maximum value our axis may get in full res mode for the input device
 * (signed 13 bits)
 */

#define ADXL_FULLRES_MAX_VAL 4096

/*
 * Maximum value our axis may get in fixed res mode for the input device
 * (signed 10 bits)
 */

#define ADXL_FIXEDRES_MAX_VAL 512

/* FIFO_CTL Bits */

#define FIFO_MODE(x)	(((x) & 0x3) << 6)

#define FIFO_BYPASS	0

#define FIFO_FIFO	1

#define FIFO_STREAM	2

#define FIFO_TRIGGER	3

#define TRIGGER		(1 << 5)

#define SAMPLES(x)	((x) & 0x1F)

/* FIFO_STATUS Bits */

#define FIFO_TRIG	(1 << 7)

#define ENTRIES(x)	((x) & 0x3F)

/* TAP_SIGN Bits ADXL346 only */

#define XSIGN		(1 << 6)

#define YSIGN		(1 << 5)

#define ZSIGN		(1 << 4)

#define XTAP		(1 << 3)

#define YTAP		(1 << 2)

#define ZTAP		(1 << 1)

/* ORIENT_CONF ADXL346 only */

#define ORIENT_DEADZONE(x)	(((x) & 0x7) << 4)

#define ORIENT_DIVISOR(x)	((x) & 0x7)

/* ORIENT ADXL346 only */

#define ADXL346_2D_VALID		(1 << 6)

#define ADXL346_2D_ORIENT(x)		(((x) & 0x30) >> 4)

#define ADXL346_3D_VALID		(1 << 3)

#define ADXL346_3D_ORIENT(x)		((x) & 0x7)

#define ADXL346_2D_PORTRAIT_POS		0	
/* +X */

#define ADXL346_2D_PORTRAIT_NEG		1	
/* -X */

#define ADXL346_2D_LANDSCAPE_POS	2	
/* +Y */

#define ADXL346_2D_LANDSCAPE_NEG	3	
/* -Y */


#define ADXL346_3D_FRONT		3	
/* +X */

#define ADXL346_3D_BACK			4	
/* -X */

#define ADXL346_3D_RIGHT		2	
/* +Y */

#define ADXL346_3D_LEFT			5	
/* -Y */

#define ADXL346_3D_TOP			1	
/* +Z */

#define ADXL346_3D_BOTTOM		6	
/* -Z */


#undef ADXL_DEBUG


#define ADXL_X_AXIS			0

#define ADXL_Y_AXIS			1

#define ADXL_Z_AXIS			2


#define AC_READ(ac, reg)	((ac)->bops->read((ac)->dev, reg))

#define AC_WRITE(ac, reg, val)	((ac)->bops->write((ac)->dev, reg, val))


struct axis_triple {
	
int x;
	
int y;
	
int z;
};


struct adxl34x {
	
struct device *dev;
	
struct input_dev *input;
	
struct mutex mutex;	/* reentrant protection for struct */
	
struct adxl34x_platform_data pdata;
	
struct axis_triple swcal;
	
struct axis_triple hwcal;
	
struct axis_triple saved;
	
char phys[32];
	
unsigned orient2d_saved;
	
unsigned orient3d_saved;
	
bool disabled;	/* P: mutex */
	
bool opened;	/* P: mutex */
	
bool suspended;	/* P: mutex */
	
bool fifo_delay;
	
int irq;
	
unsigned model;
	
unsigned int_mask;

	
const struct adxl34x_bus_ops *bops;
};


static const struct adxl34x_platform_data adxl34x_default_init = {
	.tap_threshold = 35,
	.tap_duration = 3,
	.tap_latency = 20,
	.tap_window = 20,
	.tap_axis_control = ADXL_TAP_X_EN | ADXL_TAP_Y_EN | ADXL_TAP_Z_EN,
	.act_axis_control = 0xFF,
	.activity_threshold = 6,
	.inactivity_threshold = 4,
	.inactivity_time = 3,
	.free_fall_threshold = 8,
	.free_fall_time = 0x20,
	.data_rate = 8,
	.data_range = ADXL_FULL_RES,

	.ev_type = EV_ABS,
	.ev_code_x = ABS_X,	/* EV_REL */
	.ev_code_y = ABS_Y,	/* EV_REL */
	.ev_code_z = ABS_Z,	/* EV_REL */

	.ev_code_tap = {BTN_TOUCH, BTN_TOUCH, BTN_TOUCH}, /* EV_KEY {x,y,z} */
	.power_mode = ADXL_AUTO_SLEEP | ADXL_LINK,
	.fifo_mode = ADXL_FIFO_STREAM,
	.watermark = 0,
};


static void adxl34x_get_triple(struct adxl34x *ac, struct axis_triple *axis) { short buf[3]; ac->bops->read_block(ac->dev, DATAX0, DATAZ1 - DATAX0 + 1, buf); mutex_lock(&ac->mutex); ac->saved.x = (s16) le16_to_cpu(buf[0]); axis->x = ac->saved.x; ac->saved.y = (s16) le16_to_cpu(buf[1]); axis->y = ac->saved.y; ac->saved.z = (s16) le16_to_cpu(buf[2]); axis->z = ac->saved.z; mutex_unlock(&ac->mutex); }

Contributors

PersonTokensPropCommitsCommitProp
Michael Hennerich140100.00%1100.00%
Total140100.00%1100.00%


static void adxl34x_service_ev_fifo(struct adxl34x *ac) { struct adxl34x_platform_data *pdata = &ac->pdata; struct axis_triple axis; adxl34x_get_triple(ac, &axis); input_event(ac->input, pdata->ev_type, pdata->ev_code_x, axis.x - ac->swcal.x); input_event(ac->input, pdata->ev_type, pdata->ev_code_y, axis.y - ac->swcal.y); input_event(ac->input, pdata->ev_type, pdata->ev_code_z, axis.z - ac->swcal.z); }

Contributors

PersonTokensPropCommitsCommitProp
Michael Hennerich108100.00%1100.00%
Total108100.00%1100.00%


static void adxl34x_report_key_single(struct input_dev *input, int key) { input_report_key(input, key, true); input_sync(input); input_report_key(input, key, false); }

Contributors

PersonTokensPropCommitsCommitProp
Michael Hennerich37100.00%1100.00%
Total37100.00%1100.00%


static void adxl34x_send_key_events(struct adxl34x *ac, struct adxl34x_platform_data *pdata, int status, int press) { int i; for (i = ADXL_X_AXIS; i <= ADXL_Z_AXIS; i++) { if (status & (1 << (ADXL_Z_AXIS - i))) input_report_key(ac->input, pdata->ev_code_tap[i], press); } }

Contributors

PersonTokensPropCommitsCommitProp
Michael Hennerich70100.00%1100.00%
Total70100.00%1100.00%


static void adxl34x_do_tap(struct adxl34x *ac, struct adxl34x_platform_data *pdata, int status) { adxl34x_send_key_events(ac, pdata, status, true); input_sync(ac->input); adxl34x_send_key_events(ac, pdata, status, false); }

Contributors

PersonTokensPropCommitsCommitProp
Michael Hennerich48100.00%1100.00%
Total48100.00%1100.00%


static irqreturn_t adxl34x_irq(int irq, void *handle) { struct adxl34x *ac = handle; struct adxl34x_platform_data *pdata = &ac->pdata; int int_stat, tap_stat, samples, orient, orient_code; /* * ACT_TAP_STATUS should be read before clearing the interrupt * Avoid reading ACT_TAP_STATUS in case TAP detection is disabled */ if (pdata->tap_axis_control & (TAP_X_EN | TAP_Y_EN | TAP_Z_EN)) tap_stat = AC_READ(ac, ACT_TAP_STATUS); else tap_stat = 0; int_stat = AC_READ(ac, INT_SOURCE); if (int_stat & FREE_FALL) adxl34x_report_key_single(ac->input, pdata->ev_code_ff); if (int_stat & OVERRUN) dev_dbg(ac->dev, "OVERRUN\n"); if (int_stat & (SINGLE_TAP | DOUBLE_TAP)) { adxl34x_do_tap(ac, pdata, tap_stat); if (int_stat & DOUBLE_TAP) adxl34x_do_tap(ac, pdata, tap_stat); } if (pdata->ev_code_act_inactivity) { if (int_stat & ACTIVITY) input_report_key(ac->input, pdata->ev_code_act_inactivity, 1); if (int_stat & INACTIVITY) input_report_key(ac->input, pdata->ev_code_act_inactivity, 0); } /* * ORIENTATION SENSING ADXL346 only */ if (pdata->orientation_enable) { orient = AC_READ(ac, ORIENT); if ((pdata->orientation_enable & ADXL_EN_ORIENTATION_2D) && (orient & ADXL346_2D_VALID)) { orient_code = ADXL346_2D_ORIENT(orient); /* Report orientation only when it changes */ if (ac->orient2d_saved != orient_code) { ac->orient2d_saved = orient_code; adxl34x_report_key_single(ac->input, pdata->ev_codes_orient_2d[orient_code]); } } if ((pdata->orientation_enable & ADXL_EN_ORIENTATION_3D) && (orient & ADXL346_3D_VALID)) { orient_code = ADXL346_3D_ORIENT(orient) - 1; /* Report orientation only when it changes */ if (ac->orient3d_saved != orient_code) { ac->orient3d_saved = orient_code; adxl34x_report_key_single(ac->input, pdata->ev_codes_orient_3d[orient_code]); } } } if (int_stat & (DATA_READY | WATERMARK)) { if (pdata->fifo_mode) samples = ENTRIES(AC_READ(ac, FIFO_STATUS)) + 1; else samples = 1; for (; samples > 0; samples--) { adxl34x_service_ev_fifo(ac); /* * To ensure that the FIFO has * completely popped, there must be at least 5 us between * the end of reading the data registers, signified by the * transition to register 0x38 from 0x37 or the CS pin * going high, and the start of new reads of the FIFO or * reading the FIFO_STATUS register. For SPI operation at * 1.5 MHz or lower, the register addressing portion of the * transmission is sufficient delay to ensure the FIFO has * completely popped. It is necessary for SPI operation * greater than 1.5 MHz to de-assert the CS pin to ensure a * total of 5 us, which is at most 3.4 us at 5 MHz * operation. */ if (ac->fifo_delay && (samples > 1)) udelay(3); } } input_sync(ac->input); return IRQ_HANDLED; }

Contributors

PersonTokensPropCommitsCommitProp
Michael Hennerich407100.00%2100.00%
Total407100.00%2100.00%


static void __adxl34x_disable(struct adxl34x *ac) { /* * A '0' places the ADXL34x into standby mode * with minimum power consumption. */ AC_WRITE(ac, POWER_CTL, 0); }

Contributors

PersonTokensPropCommitsCommitProp
Michael Hennerich2095.24%150.00%
Dmitry Torokhov14.76%150.00%
Total21100.00%2100.00%


static void __adxl34x_enable(struct adxl34x *ac) { AC_WRITE(ac, POWER_CTL, ac->pdata.power_mode | PCTL_MEASURE); }

Contributors

PersonTokensPropCommitsCommitProp
Michael Hennerich26100.00%1100.00%
Total26100.00%1100.00%


void adxl34x_suspend(struct adxl34x *ac) { mutex_lock(&ac->mutex); if (!ac->suspended && !ac->disabled && ac->opened) __adxl34x_disable(ac); ac->suspended = true; mutex_unlock(&ac->mutex); }

Contributors

PersonTokensPropCommitsCommitProp
Michael Hennerich3056.60%150.00%
Dmitry Torokhov2343.40%150.00%
Total53100.00%2100.00%

EXPORT_SYMBOL_GPL(adxl34x_suspend);
void adxl34x_resume(struct adxl34x *ac) { mutex_lock(&ac->mutex); if (ac->suspended && !ac->disabled && ac->opened) __adxl34x_enable(ac); ac->suspended = false; mutex_unlock(&ac->mutex); }

Contributors

PersonTokensPropCommitsCommitProp
Michael Hennerich3057.69%150.00%
Dmitry Torokhov2242.31%150.00%
Total52100.00%2100.00%

EXPORT_SYMBOL_GPL(adxl34x_resume);
static ssize_t adxl34x_disable_show(struct device *dev, struct device_attribute *attr, char *buf) { struct adxl34x *ac = dev_get_drvdata(dev); return sprintf(buf, "%u\n", ac->disabled); }

Contributors

PersonTokensPropCommitsCommitProp
Michael Hennerich42100.00%1100.00%
Total42100.00%1100.00%


static ssize_t adxl34x_disable_store(struct device *dev, struct device_attribute *attr, const char *buf, size_t count) { struct adxl34x *ac = dev_get_drvdata(dev); unsigned int val; int error; error = kstrtouint(buf, 10, &val); if (error) return error; mutex_lock(&ac->mutex); if (!ac->suspended && ac->opened) { if (val) { if (!ac->disabled) __adxl34x_disable(ac); } else { if (ac->disabled) __adxl34x_enable(ac); } } ac->disabled = !!val; mutex_unlock(&ac->mutex); return count; }

Contributors

PersonTokensPropCommitsCommitProp
Michael Hennerich7456.06%133.33%
Dmitry Torokhov5642.42%133.33%
JJ Ding21.52%133.33%
Total132100.00%3100.00%

static DEVICE_ATTR(disable, 0664, adxl34x_disable_show, adxl34x_disable_store);
static ssize_t adxl34x_calibrate_show(struct device *dev, struct device_attribute *attr, char *buf) { struct adxl34x *ac = dev_get_drvdata(dev); ssize_t count; mutex_lock(&ac->mutex); count = sprintf(buf, "%d,%d,%d\n", ac->hwcal.x * 4 + ac->swcal.x, ac->hwcal.y * 4 + ac->swcal.y, ac->hwcal.z * 4 + ac->swcal.z); mutex_unlock(&ac->mutex); return count; }

Contributors

PersonTokensPropCommitsCommitProp
Michael Hennerich103100.00%1100.00%
Total103100.00%1100.00%


static ssize_t adxl34x_calibrate_store(struct device *dev, struct device_attribute *attr, const char *buf, size_t count) { struct adxl34x *ac = dev_get_drvdata(dev); /* * Hardware offset calibration has a resolution of 15.6 mg/LSB. * We use HW calibration and handle the remaining bits in SW. (4mg/LSB) */ mutex_lock(&ac->mutex); ac->hwcal.x -= (ac->saved.x / 4); ac->swcal.x = ac->saved.x % 4; ac->hwcal.y -= (ac->saved.y / 4); ac->swcal.y = ac->saved.y % 4; ac->hwcal.z -= (ac->saved.z / 4); ac->swcal.z = ac->saved.z % 4; AC_WRITE(ac, OFSX, (s8) ac->hwcal.x); AC_WRITE(ac, OFSY, (s8) ac->hwcal.y); AC_WRITE(ac, OFSZ, (s8) ac->hwcal.z); mutex_unlock(&ac->mutex); return count; }

Contributors

PersonTokensPropCommitsCommitProp
Michael Hennerich192100.00%1100.00%
Total192100.00%1100.00%

static DEVICE_ATTR(calibrate, 0664, adxl34x_calibrate_show, adxl34x_calibrate_store);
static ssize_t adxl34x_rate_show(struct device *dev, struct device_attribute *attr, char *buf) { struct adxl34x *ac = dev_get_drvdata(dev); return sprintf(buf, "%u\n", RATE(ac->pdata.data_rate)); }

Contributors

PersonTokensPropCommitsCommitProp
Michael Hennerich47100.00%1100.00%
Total47100.00%1100.00%


static ssize_t adxl34x_rate_store(struct device *dev, struct device_attribute *attr, const char *buf, size_t count) { struct adxl34x *ac = dev_get_drvdata(dev); unsigned char val; int error; error = kstrtou8(buf, 10, &val); if (error) return error; mutex_lock(&ac->mutex); ac->pdata.data_rate = RATE(val); AC_WRITE(ac, BW_RATE, ac->pdata.data_rate | (ac->pdata.low_power_mode ? LOW_POWER : 0)); mutex_unlock(&ac->mutex); return count; }

Contributors

PersonTokensPropCommitsCommitProp
Michael Hennerich11398.26%150.00%
JJ Ding21.74%150.00%
Total115100.00%2100.00%

static DEVICE_ATTR(rate, 0664, adxl34x_rate_show, adxl34x_rate_store);
static ssize_t adxl34x_autosleep_show(struct device *dev, struct device_attribute *attr, char *buf) { struct adxl34x *ac = dev_get_drvdata(dev); return sprintf(buf, "%u\n", ac->pdata.power_mode & (PCTL_AUTO_SLEEP | PCTL_LINK) ? 1 : 0); }

Contributors

PersonTokensPropCommitsCommitProp
Michael Hennerich54100.00%1100.00%
Total54100.00%1100.00%


static ssize_t adxl34x_autosleep_store(struct device *dev, struct device_attribute *attr, const char *buf, size_t count) { struct adxl34x *ac = dev_get_drvdata(dev); unsigned int val; int error; error = kstrtouint(buf, 10, &val); if (error) return error; mutex_lock(&ac->mutex); if (val) ac->pdata.power_mode |= (PCTL_AUTO_SLEEP | PCTL_LINK); else ac->pdata.power_mode &= ~(PCTL_AUTO_SLEEP | PCTL_LINK); if (!ac->disabled && !ac->suspended && ac->opened) AC_WRITE(ac, POWER_CTL, ac->pdata.power_mode | PCTL_MEASURE); mutex_unlock(&ac->mutex); return count; }

Contributors

PersonTokensPropCommitsCommitProp
Michael Hennerich13395.00%133.33%
Dmitry Torokhov53.57%133.33%
JJ Ding21.43%133.33%
Total140100.00%3100.00%

static DEVICE_ATTR(autosleep, 0664, adxl34x_autosleep_show, adxl34x_autosleep_store);
static ssize_t adxl34x_position_show(struct device *dev, struct device_attribute *attr, char *buf) { struct adxl34x *ac = dev_get_drvdata(dev); ssize_t count; mutex_lock(&ac->mutex); count = sprintf(buf, "(%d, %d, %d)\n", ac->saved.x, ac->saved.y, ac->saved.z); mutex_unlock(&ac->mutex); return count; }

Contributors

PersonTokensPropCommitsCommitProp
Michael Hennerich79100.00%1100.00%
Total79100.00%1100.00%

static DEVICE_ATTR(position, S_IRUGO, adxl34x_position_show, NULL); #ifdef ADXL_DEBUG
static ssize_t adxl34x_write_store(struct device *dev, struct device_attribute *