// SPDX-License-Identifier: GPL-2.0-or-later
|
/*
|
* ADXL345/346 Three-Axis Digital Accelerometers
|
*
|
* Enter bugs at http://blackfin.uclinux.org/
|
*
|
* Copyright (C) 2009 Michael Hennerich, Analog Devices Inc.
|
*/
|
|
#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);
|
}
|
|
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);
|
}
|
|
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);
|
}
|
|
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);
|
}
|
}
|
|
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);
|
}
|
|
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;
|
}
|
|
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);
|
}
|
|
static void __adxl34x_enable(struct adxl34x *ac)
|
{
|
AC_WRITE(ac, POWER_CTL, ac->pdata.power_mode | PCTL_MEASURE);
|
}
|
|
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);
|
}
|
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);
|
}
|
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);
|
}
|
|
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;
|
}
|
|
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;
|
}
|
|
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;
|
}
|
|
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));
|
}
|
|
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;
|
}
|
|
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);
|
}
|
|
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;
|
}
|
|
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;
|
}
|
|
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 *attr,
|
const char *buf, size_t count)
|
{
|
struct adxl34x *ac = dev_get_drvdata(dev);
|
unsigned int val;
|
int error;
|
|
/*
|
* This allows basic ADXL register write access for debug purposes.
|
*/
|
error = kstrtouint(buf, 16, &val);
|
if (error)
|
return error;
|
|
mutex_lock(&ac->mutex);
|
AC_WRITE(ac, val >> 8, val & 0xFF);
|
mutex_unlock(&ac->mutex);
|
|
return count;
|
}
|
|
static DEVICE_ATTR(write, 0664, NULL, adxl34x_write_store);
|
#endif
|
|
static struct attribute *adxl34x_attributes[] = {
|
&dev_attr_disable.attr,
|
&dev_attr_calibrate.attr,
|
&dev_attr_rate.attr,
|
&dev_attr_autosleep.attr,
|
&dev_attr_position.attr,
|
#ifdef ADXL_DEBUG
|
&dev_attr_write.attr,
|
#endif
|
NULL
|
};
|
|
static const struct attribute_group adxl34x_attr_group = {
|
.attrs = adxl34x_attributes,
|
};
|
|
static int adxl34x_input_open(struct input_dev *input)
|
{
|
struct adxl34x *ac = input_get_drvdata(input);
|
|
mutex_lock(&ac->mutex);
|
|
if (!ac->suspended && !ac->disabled)
|
__adxl34x_enable(ac);
|
|
ac->opened = true;
|
|
mutex_unlock(&ac->mutex);
|
|
return 0;
|
}
|
|
static void adxl34x_input_close(struct input_dev *input)
|
{
|
struct adxl34x *ac = input_get_drvdata(input);
|
|
mutex_lock(&ac->mutex);
|
|
if (!ac->suspended && !ac->disabled)
|
__adxl34x_disable(ac);
|
|
ac->opened = false;
|
|
mutex_unlock(&ac->mutex);
|
}
|
|
struct adxl34x *adxl34x_probe(struct device *dev, int irq,
|
bool fifo_delay_default,
|
const struct adxl34x_bus_ops *bops)
|
{
|
struct adxl34x *ac;
|
struct input_dev *input_dev;
|
const struct adxl34x_platform_data *pdata;
|
int err, range, i;
|
int revid;
|
|
if (!irq) {
|
dev_err(dev, "no IRQ?\n");
|
err = -ENODEV;
|
goto err_out;
|
}
|
|
ac = kzalloc(sizeof(*ac), GFP_KERNEL);
|
input_dev = input_allocate_device();
|
if (!ac || !input_dev) {
|
err = -ENOMEM;
|
goto err_free_mem;
|
}
|
|
ac->fifo_delay = fifo_delay_default;
|
|
pdata = dev_get_platdata(dev);
|
if (!pdata) {
|
dev_dbg(dev,
|
"No platform data: Using default initialization\n");
|
pdata = &adxl34x_default_init;
|
}
|
|
ac->pdata = *pdata;
|
pdata = &ac->pdata;
|
|
ac->input = input_dev;
|
ac->dev = dev;
|
ac->irq = irq;
|
ac->bops = bops;
|
|
mutex_init(&ac->mutex);
|
|
input_dev->name = "ADXL34x accelerometer";
|
revid = AC_READ(ac, DEVID);
|
|
switch (revid) {
|
case ID_ADXL345:
|
ac->model = 345;
|
break;
|
case ID_ADXL346:
|
ac->model = 346;
|
break;
|
default:
|
dev_err(dev, "Failed to probe %s\n", input_dev->name);
|
err = -ENODEV;
|
goto err_free_mem;
|
}
|
|
snprintf(ac->phys, sizeof(ac->phys), "%s/input0", dev_name(dev));
|
|
input_dev->phys = ac->phys;
|
input_dev->dev.parent = dev;
|
input_dev->id.product = ac->model;
|
input_dev->id.bustype = bops->bustype;
|
input_dev->open = adxl34x_input_open;
|
input_dev->close = adxl34x_input_close;
|
|
input_set_drvdata(input_dev, ac);
|
|
__set_bit(ac->pdata.ev_type, input_dev->evbit);
|
|
if (ac->pdata.ev_type == EV_REL) {
|
__set_bit(REL_X, input_dev->relbit);
|
__set_bit(REL_Y, input_dev->relbit);
|
__set_bit(REL_Z, input_dev->relbit);
|
} else {
|
/* EV_ABS */
|
__set_bit(ABS_X, input_dev->absbit);
|
__set_bit(ABS_Y, input_dev->absbit);
|
__set_bit(ABS_Z, input_dev->absbit);
|
|
if (pdata->data_range & FULL_RES)
|
range = ADXL_FULLRES_MAX_VAL; /* Signed 13-bit */
|
else
|
range = ADXL_FIXEDRES_MAX_VAL; /* Signed 10-bit */
|
|
input_set_abs_params(input_dev, ABS_X, -range, range, 3, 3);
|
input_set_abs_params(input_dev, ABS_Y, -range, range, 3, 3);
|
input_set_abs_params(input_dev, ABS_Z, -range, range, 3, 3);
|
}
|
|
__set_bit(EV_KEY, input_dev->evbit);
|
__set_bit(pdata->ev_code_tap[ADXL_X_AXIS], input_dev->keybit);
|
__set_bit(pdata->ev_code_tap[ADXL_Y_AXIS], input_dev->keybit);
|
__set_bit(pdata->ev_code_tap[ADXL_Z_AXIS], input_dev->keybit);
|
|
if (pdata->ev_code_ff) {
|
ac->int_mask = FREE_FALL;
|
__set_bit(pdata->ev_code_ff, input_dev->keybit);
|
}
|
|
if (pdata->ev_code_act_inactivity)
|
__set_bit(pdata->ev_code_act_inactivity, input_dev->keybit);
|
|
ac->int_mask |= ACTIVITY | INACTIVITY;
|
|
if (pdata->watermark) {
|
ac->int_mask |= WATERMARK;
|
if (FIFO_MODE(pdata->fifo_mode) == FIFO_BYPASS)
|
ac->pdata.fifo_mode |= FIFO_STREAM;
|
} else {
|
ac->int_mask |= DATA_READY;
|
}
|
|
if (pdata->tap_axis_control & (TAP_X_EN | TAP_Y_EN | TAP_Z_EN))
|
ac->int_mask |= SINGLE_TAP | DOUBLE_TAP;
|
|
if (FIFO_MODE(pdata->fifo_mode) == FIFO_BYPASS)
|
ac->fifo_delay = false;
|
|
AC_WRITE(ac, POWER_CTL, 0);
|
|
err = request_threaded_irq(ac->irq, NULL, adxl34x_irq,
|
IRQF_TRIGGER_HIGH | IRQF_ONESHOT,
|
dev_name(dev), ac);
|
if (err) {
|
dev_err(dev, "irq %d busy?\n", ac->irq);
|
goto err_free_mem;
|
}
|
|
err = sysfs_create_group(&dev->kobj, &adxl34x_attr_group);
|
if (err)
|
goto err_free_irq;
|
|
err = input_register_device(input_dev);
|
if (err)
|
goto err_remove_attr;
|
|
AC_WRITE(ac, OFSX, pdata->x_axis_offset);
|
ac->hwcal.x = pdata->x_axis_offset;
|
AC_WRITE(ac, OFSY, pdata->y_axis_offset);
|
ac->hwcal.y = pdata->y_axis_offset;
|
AC_WRITE(ac, OFSZ, pdata->z_axis_offset);
|
ac->hwcal.z = pdata->z_axis_offset;
|
AC_WRITE(ac, THRESH_TAP, pdata->tap_threshold);
|
AC_WRITE(ac, DUR, pdata->tap_duration);
|
AC_WRITE(ac, LATENT, pdata->tap_latency);
|
AC_WRITE(ac, WINDOW, pdata->tap_window);
|
AC_WRITE(ac, THRESH_ACT, pdata->activity_threshold);
|
AC_WRITE(ac, THRESH_INACT, pdata->inactivity_threshold);
|
AC_WRITE(ac, TIME_INACT, pdata->inactivity_time);
|
AC_WRITE(ac, THRESH_FF, pdata->free_fall_threshold);
|
AC_WRITE(ac, TIME_FF, pdata->free_fall_time);
|
AC_WRITE(ac, TAP_AXES, pdata->tap_axis_control);
|
AC_WRITE(ac, ACT_INACT_CTL, pdata->act_axis_control);
|
AC_WRITE(ac, BW_RATE, RATE(ac->pdata.data_rate) |
|
(pdata->low_power_mode ? LOW_POWER : 0));
|
AC_WRITE(ac, DATA_FORMAT, pdata->data_range);
|
AC_WRITE(ac, FIFO_CTL, FIFO_MODE(pdata->fifo_mode) |
|
SAMPLES(pdata->watermark));
|
|
if (pdata->use_int2) {
|
/* Map all INTs to INT2 */
|
AC_WRITE(ac, INT_MAP, ac->int_mask | OVERRUN);
|
} else {
|
/* Map all INTs to INT1 */
|
AC_WRITE(ac, INT_MAP, 0);
|
}
|
|
if (ac->model == 346 && ac->pdata.orientation_enable) {
|
AC_WRITE(ac, ORIENT_CONF,
|
ORIENT_DEADZONE(ac->pdata.deadzone_angle) |
|
ORIENT_DIVISOR(ac->pdata.divisor_length));
|
|
ac->orient2d_saved = 1234;
|
ac->orient3d_saved = 1234;
|
|
if (pdata->orientation_enable & ADXL_EN_ORIENTATION_3D)
|
for (i = 0; i < ARRAY_SIZE(pdata->ev_codes_orient_3d); i++)
|
__set_bit(pdata->ev_codes_orient_3d[i],
|
input_dev->keybit);
|
|
if (pdata->orientation_enable & ADXL_EN_ORIENTATION_2D)
|
for (i = 0; i < ARRAY_SIZE(pdata->ev_codes_orient_2d); i++)
|
__set_bit(pdata->ev_codes_orient_2d[i],
|
input_dev->keybit);
|
} else {
|
ac->pdata.orientation_enable = 0;
|
}
|
|
AC_WRITE(ac, INT_ENABLE, ac->int_mask | OVERRUN);
|
|
ac->pdata.power_mode &= (PCTL_AUTO_SLEEP | PCTL_LINK);
|
|
return ac;
|
|
err_remove_attr:
|
sysfs_remove_group(&dev->kobj, &adxl34x_attr_group);
|
err_free_irq:
|
free_irq(ac->irq, ac);
|
err_free_mem:
|
input_free_device(input_dev);
|
kfree(ac);
|
err_out:
|
return ERR_PTR(err);
|
}
|
EXPORT_SYMBOL_GPL(adxl34x_probe);
|
|
int adxl34x_remove(struct adxl34x *ac)
|
{
|
sysfs_remove_group(&ac->dev->kobj, &adxl34x_attr_group);
|
free_irq(ac->irq, ac);
|
input_unregister_device(ac->input);
|
dev_dbg(ac->dev, "unregistered accelerometer\n");
|
kfree(ac);
|
|
return 0;
|
}
|
EXPORT_SYMBOL_GPL(adxl34x_remove);
|
|
MODULE_AUTHOR("Michael Hennerich <hennerich@blackfin.uclinux.org>");
|
MODULE_DESCRIPTION("ADXL345/346 Three-Axis Digital Accelerometer Driver");
|
MODULE_LICENSE("GPL");
|
