forked from Qortal/Brooklyn
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
525 lines
12 KiB
525 lines
12 KiB
// SPDX-License-Identifier: GPL-2.0-only |
|
/* |
|
* kxsd9.c simple support for the Kionix KXSD9 3D |
|
* accelerometer. |
|
* |
|
* Copyright (c) 2008-2009 Jonathan Cameron <[email protected]> |
|
* |
|
* The i2c interface is very similar, so shouldn't be a problem once |
|
* I have a suitable wire made up. |
|
* |
|
* TODO: Support the motion detector |
|
*/ |
|
|
|
#include <linux/device.h> |
|
#include <linux/kernel.h> |
|
#include <linux/sysfs.h> |
|
#include <linux/slab.h> |
|
#include <linux/module.h> |
|
#include <linux/regmap.h> |
|
#include <linux/bitops.h> |
|
#include <linux/delay.h> |
|
#include <linux/regulator/consumer.h> |
|
#include <linux/pm_runtime.h> |
|
#include <linux/iio/iio.h> |
|
#include <linux/iio/sysfs.h> |
|
#include <linux/iio/buffer.h> |
|
#include <linux/iio/triggered_buffer.h> |
|
#include <linux/iio/trigger_consumer.h> |
|
|
|
#include "kxsd9.h" |
|
|
|
#define KXSD9_REG_X 0x00 |
|
#define KXSD9_REG_Y 0x02 |
|
#define KXSD9_REG_Z 0x04 |
|
#define KXSD9_REG_AUX 0x06 |
|
#define KXSD9_REG_RESET 0x0a |
|
#define KXSD9_REG_CTRL_C 0x0c |
|
|
|
#define KXSD9_CTRL_C_FS_MASK 0x03 |
|
#define KXSD9_CTRL_C_FS_8G 0x00 |
|
#define KXSD9_CTRL_C_FS_6G 0x01 |
|
#define KXSD9_CTRL_C_FS_4G 0x02 |
|
#define KXSD9_CTRL_C_FS_2G 0x03 |
|
#define KXSD9_CTRL_C_MOT_LAT BIT(3) |
|
#define KXSD9_CTRL_C_MOT_LEV BIT(4) |
|
#define KXSD9_CTRL_C_LP_MASK 0xe0 |
|
#define KXSD9_CTRL_C_LP_NONE 0x00 |
|
#define KXSD9_CTRL_C_LP_2000HZC BIT(5) |
|
#define KXSD9_CTRL_C_LP_2000HZB BIT(6) |
|
#define KXSD9_CTRL_C_LP_2000HZA (BIT(5)|BIT(6)) |
|
#define KXSD9_CTRL_C_LP_1000HZ BIT(7) |
|
#define KXSD9_CTRL_C_LP_500HZ (BIT(7)|BIT(5)) |
|
#define KXSD9_CTRL_C_LP_100HZ (BIT(7)|BIT(6)) |
|
#define KXSD9_CTRL_C_LP_50HZ (BIT(7)|BIT(6)|BIT(5)) |
|
|
|
#define KXSD9_REG_CTRL_B 0x0d |
|
|
|
#define KXSD9_CTRL_B_CLK_HLD BIT(7) |
|
#define KXSD9_CTRL_B_ENABLE BIT(6) |
|
#define KXSD9_CTRL_B_ST BIT(5) /* Self-test */ |
|
|
|
#define KXSD9_REG_CTRL_A 0x0e |
|
|
|
/** |
|
* struct kxsd9_state - device related storage |
|
* @dev: pointer to the parent device |
|
* @map: regmap to the device |
|
* @orientation: mounting matrix, flipped axis etc |
|
* @regs: regulators for this device, VDD and IOVDD |
|
* @scale: the current scaling setting |
|
*/ |
|
struct kxsd9_state { |
|
struct device *dev; |
|
struct regmap *map; |
|
struct iio_mount_matrix orientation; |
|
struct regulator_bulk_data regs[2]; |
|
u8 scale; |
|
}; |
|
|
|
#define KXSD9_SCALE_2G "0.011978" |
|
#define KXSD9_SCALE_4G "0.023927" |
|
#define KXSD9_SCALE_6G "0.035934" |
|
#define KXSD9_SCALE_8G "0.047853" |
|
|
|
/* reverse order */ |
|
static const int kxsd9_micro_scales[4] = { 47853, 35934, 23927, 11978 }; |
|
|
|
#define KXSD9_ZERO_G_OFFSET -2048 |
|
|
|
/* |
|
* Regulator names |
|
*/ |
|
static const char kxsd9_reg_vdd[] = "vdd"; |
|
static const char kxsd9_reg_iovdd[] = "iovdd"; |
|
|
|
static int kxsd9_write_scale(struct iio_dev *indio_dev, int micro) |
|
{ |
|
int ret, i; |
|
struct kxsd9_state *st = iio_priv(indio_dev); |
|
bool foundit = false; |
|
|
|
for (i = 0; i < 4; i++) |
|
if (micro == kxsd9_micro_scales[i]) { |
|
foundit = true; |
|
break; |
|
} |
|
if (!foundit) |
|
return -EINVAL; |
|
|
|
ret = regmap_update_bits(st->map, |
|
KXSD9_REG_CTRL_C, |
|
KXSD9_CTRL_C_FS_MASK, |
|
i); |
|
if (ret < 0) |
|
goto error_ret; |
|
|
|
/* Cached scale when the sensor is powered down */ |
|
st->scale = i; |
|
|
|
error_ret: |
|
return ret; |
|
} |
|
|
|
static IIO_CONST_ATTR(accel_scale_available, |
|
KXSD9_SCALE_2G " " |
|
KXSD9_SCALE_4G " " |
|
KXSD9_SCALE_6G " " |
|
KXSD9_SCALE_8G); |
|
|
|
static struct attribute *kxsd9_attributes[] = { |
|
&iio_const_attr_accel_scale_available.dev_attr.attr, |
|
NULL, |
|
}; |
|
|
|
static int kxsd9_write_raw(struct iio_dev *indio_dev, |
|
struct iio_chan_spec const *chan, |
|
int val, |
|
int val2, |
|
long mask) |
|
{ |
|
int ret = -EINVAL; |
|
struct kxsd9_state *st = iio_priv(indio_dev); |
|
|
|
pm_runtime_get_sync(st->dev); |
|
|
|
if (mask == IIO_CHAN_INFO_SCALE) { |
|
/* Check no integer component */ |
|
if (val) |
|
return -EINVAL; |
|
ret = kxsd9_write_scale(indio_dev, val2); |
|
} |
|
|
|
pm_runtime_mark_last_busy(st->dev); |
|
pm_runtime_put_autosuspend(st->dev); |
|
|
|
return ret; |
|
} |
|
|
|
static int kxsd9_read_raw(struct iio_dev *indio_dev, |
|
struct iio_chan_spec const *chan, |
|
int *val, int *val2, long mask) |
|
{ |
|
int ret = -EINVAL; |
|
struct kxsd9_state *st = iio_priv(indio_dev); |
|
unsigned int regval; |
|
__be16 raw_val; |
|
u16 nval; |
|
|
|
pm_runtime_get_sync(st->dev); |
|
|
|
switch (mask) { |
|
case IIO_CHAN_INFO_RAW: |
|
ret = regmap_bulk_read(st->map, chan->address, &raw_val, |
|
sizeof(raw_val)); |
|
if (ret) |
|
goto error_ret; |
|
nval = be16_to_cpu(raw_val); |
|
/* Only 12 bits are valid */ |
|
nval >>= 4; |
|
*val = nval; |
|
ret = IIO_VAL_INT; |
|
break; |
|
case IIO_CHAN_INFO_OFFSET: |
|
/* This has a bias of -2048 */ |
|
*val = KXSD9_ZERO_G_OFFSET; |
|
ret = IIO_VAL_INT; |
|
break; |
|
case IIO_CHAN_INFO_SCALE: |
|
ret = regmap_read(st->map, |
|
KXSD9_REG_CTRL_C, |
|
®val); |
|
if (ret < 0) |
|
goto error_ret; |
|
*val = 0; |
|
*val2 = kxsd9_micro_scales[regval & KXSD9_CTRL_C_FS_MASK]; |
|
ret = IIO_VAL_INT_PLUS_MICRO; |
|
break; |
|
} |
|
|
|
error_ret: |
|
pm_runtime_mark_last_busy(st->dev); |
|
pm_runtime_put_autosuspend(st->dev); |
|
|
|
return ret; |
|
}; |
|
|
|
static irqreturn_t kxsd9_trigger_handler(int irq, void *p) |
|
{ |
|
const struct iio_poll_func *pf = p; |
|
struct iio_dev *indio_dev = pf->indio_dev; |
|
struct kxsd9_state *st = iio_priv(indio_dev); |
|
/* |
|
* Ensure correct positioning and alignment of timestamp. |
|
* No need to zero initialize as all elements written. |
|
*/ |
|
struct { |
|
__be16 chan[4]; |
|
s64 ts __aligned(8); |
|
} hw_values; |
|
int ret; |
|
|
|
ret = regmap_bulk_read(st->map, |
|
KXSD9_REG_X, |
|
hw_values.chan, |
|
sizeof(hw_values.chan)); |
|
if (ret) { |
|
dev_err(st->dev, |
|
"error reading data\n"); |
|
return ret; |
|
} |
|
|
|
iio_push_to_buffers_with_timestamp(indio_dev, |
|
&hw_values, |
|
iio_get_time_ns(indio_dev)); |
|
iio_trigger_notify_done(indio_dev->trig); |
|
|
|
return IRQ_HANDLED; |
|
} |
|
|
|
static int kxsd9_buffer_preenable(struct iio_dev *indio_dev) |
|
{ |
|
struct kxsd9_state *st = iio_priv(indio_dev); |
|
|
|
pm_runtime_get_sync(st->dev); |
|
|
|
return 0; |
|
} |
|
|
|
static int kxsd9_buffer_postdisable(struct iio_dev *indio_dev) |
|
{ |
|
struct kxsd9_state *st = iio_priv(indio_dev); |
|
|
|
pm_runtime_mark_last_busy(st->dev); |
|
pm_runtime_put_autosuspend(st->dev); |
|
|
|
return 0; |
|
} |
|
|
|
static const struct iio_buffer_setup_ops kxsd9_buffer_setup_ops = { |
|
.preenable = kxsd9_buffer_preenable, |
|
.postdisable = kxsd9_buffer_postdisable, |
|
}; |
|
|
|
static const struct iio_mount_matrix * |
|
kxsd9_get_mount_matrix(const struct iio_dev *indio_dev, |
|
const struct iio_chan_spec *chan) |
|
{ |
|
struct kxsd9_state *st = iio_priv(indio_dev); |
|
|
|
return &st->orientation; |
|
} |
|
|
|
static const struct iio_chan_spec_ext_info kxsd9_ext_info[] = { |
|
IIO_MOUNT_MATRIX(IIO_SHARED_BY_TYPE, kxsd9_get_mount_matrix), |
|
{ }, |
|
}; |
|
|
|
#define KXSD9_ACCEL_CHAN(axis, index) \ |
|
{ \ |
|
.type = IIO_ACCEL, \ |
|
.modified = 1, \ |
|
.channel2 = IIO_MOD_##axis, \ |
|
.info_mask_separate = BIT(IIO_CHAN_INFO_RAW), \ |
|
.info_mask_shared_by_type = BIT(IIO_CHAN_INFO_SCALE) | \ |
|
BIT(IIO_CHAN_INFO_OFFSET), \ |
|
.ext_info = kxsd9_ext_info, \ |
|
.address = KXSD9_REG_##axis, \ |
|
.scan_index = index, \ |
|
.scan_type = { \ |
|
.sign = 'u', \ |
|
.realbits = 12, \ |
|
.storagebits = 16, \ |
|
.shift = 4, \ |
|
.endianness = IIO_BE, \ |
|
}, \ |
|
} |
|
|
|
static const struct iio_chan_spec kxsd9_channels[] = { |
|
KXSD9_ACCEL_CHAN(X, 0), |
|
KXSD9_ACCEL_CHAN(Y, 1), |
|
KXSD9_ACCEL_CHAN(Z, 2), |
|
{ |
|
.type = IIO_VOLTAGE, |
|
.info_mask_separate = BIT(IIO_CHAN_INFO_RAW), |
|
.indexed = 1, |
|
.address = KXSD9_REG_AUX, |
|
.scan_index = 3, |
|
.scan_type = { |
|
.sign = 'u', |
|
.realbits = 12, |
|
.storagebits = 16, |
|
.shift = 4, |
|
.endianness = IIO_BE, |
|
}, |
|
}, |
|
IIO_CHAN_SOFT_TIMESTAMP(4), |
|
}; |
|
|
|
static const struct attribute_group kxsd9_attribute_group = { |
|
.attrs = kxsd9_attributes, |
|
}; |
|
|
|
static int kxsd9_power_up(struct kxsd9_state *st) |
|
{ |
|
int ret; |
|
|
|
/* Enable the regulators */ |
|
ret = regulator_bulk_enable(ARRAY_SIZE(st->regs), st->regs); |
|
if (ret) { |
|
dev_err(st->dev, "Cannot enable regulators\n"); |
|
return ret; |
|
} |
|
|
|
/* Power up */ |
|
ret = regmap_write(st->map, |
|
KXSD9_REG_CTRL_B, |
|
KXSD9_CTRL_B_ENABLE); |
|
if (ret) |
|
return ret; |
|
|
|
/* |
|
* Set 1000Hz LPF, 2g fullscale, motion wakeup threshold 1g, |
|
* latched wakeup |
|
*/ |
|
ret = regmap_write(st->map, |
|
KXSD9_REG_CTRL_C, |
|
KXSD9_CTRL_C_LP_1000HZ | |
|
KXSD9_CTRL_C_MOT_LEV | |
|
KXSD9_CTRL_C_MOT_LAT | |
|
st->scale); |
|
if (ret) |
|
return ret; |
|
|
|
/* |
|
* Power-up time depends on the LPF setting, but typ 15.9 ms, let's |
|
* set 20 ms to allow for some slack. |
|
*/ |
|
msleep(20); |
|
|
|
return 0; |
|
}; |
|
|
|
static int kxsd9_power_down(struct kxsd9_state *st) |
|
{ |
|
int ret; |
|
|
|
/* |
|
* Set into low power mode - since there may be more users of the |
|
* regulators this is the first step of the power saving: it will |
|
* make sure we conserve power even if there are others users on the |
|
* regulators. |
|
*/ |
|
ret = regmap_update_bits(st->map, |
|
KXSD9_REG_CTRL_B, |
|
KXSD9_CTRL_B_ENABLE, |
|
0); |
|
if (ret) |
|
return ret; |
|
|
|
/* Disable the regulators */ |
|
ret = regulator_bulk_disable(ARRAY_SIZE(st->regs), st->regs); |
|
if (ret) { |
|
dev_err(st->dev, "Cannot disable regulators\n"); |
|
return ret; |
|
} |
|
|
|
return 0; |
|
} |
|
|
|
static const struct iio_info kxsd9_info = { |
|
.read_raw = &kxsd9_read_raw, |
|
.write_raw = &kxsd9_write_raw, |
|
.attrs = &kxsd9_attribute_group, |
|
}; |
|
|
|
/* Four channels apart from timestamp, scan mask = 0x0f */ |
|
static const unsigned long kxsd9_scan_masks[] = { 0xf, 0 }; |
|
|
|
int kxsd9_common_probe(struct device *dev, |
|
struct regmap *map, |
|
const char *name) |
|
{ |
|
struct iio_dev *indio_dev; |
|
struct kxsd9_state *st; |
|
int ret; |
|
|
|
indio_dev = devm_iio_device_alloc(dev, sizeof(*st)); |
|
if (!indio_dev) |
|
return -ENOMEM; |
|
|
|
st = iio_priv(indio_dev); |
|
st->dev = dev; |
|
st->map = map; |
|
|
|
indio_dev->channels = kxsd9_channels; |
|
indio_dev->num_channels = ARRAY_SIZE(kxsd9_channels); |
|
indio_dev->name = name; |
|
indio_dev->info = &kxsd9_info; |
|
indio_dev->modes = INDIO_DIRECT_MODE; |
|
indio_dev->available_scan_masks = kxsd9_scan_masks; |
|
|
|
/* Read the mounting matrix, if present */ |
|
ret = iio_read_mount_matrix(dev, "mount-matrix", &st->orientation); |
|
if (ret) |
|
return ret; |
|
|
|
/* Fetch and turn on regulators */ |
|
st->regs[0].supply = kxsd9_reg_vdd; |
|
st->regs[1].supply = kxsd9_reg_iovdd; |
|
ret = devm_regulator_bulk_get(dev, |
|
ARRAY_SIZE(st->regs), |
|
st->regs); |
|
if (ret) { |
|
dev_err(dev, "Cannot get regulators\n"); |
|
return ret; |
|
} |
|
/* Default scaling */ |
|
st->scale = KXSD9_CTRL_C_FS_2G; |
|
|
|
kxsd9_power_up(st); |
|
|
|
ret = iio_triggered_buffer_setup(indio_dev, |
|
iio_pollfunc_store_time, |
|
kxsd9_trigger_handler, |
|
&kxsd9_buffer_setup_ops); |
|
if (ret) { |
|
dev_err(dev, "triggered buffer setup failed\n"); |
|
goto err_power_down; |
|
} |
|
|
|
ret = iio_device_register(indio_dev); |
|
if (ret) |
|
goto err_cleanup_buffer; |
|
|
|
dev_set_drvdata(dev, indio_dev); |
|
|
|
/* Enable runtime PM */ |
|
pm_runtime_get_noresume(dev); |
|
pm_runtime_set_active(dev); |
|
pm_runtime_enable(dev); |
|
/* |
|
* Set autosuspend to two orders of magnitude larger than the |
|
* start-up time. 20ms start-up time means 2000ms autosuspend, |
|
* i.e. 2 seconds. |
|
*/ |
|
pm_runtime_set_autosuspend_delay(dev, 2000); |
|
pm_runtime_use_autosuspend(dev); |
|
pm_runtime_put(dev); |
|
|
|
return 0; |
|
|
|
err_cleanup_buffer: |
|
iio_triggered_buffer_cleanup(indio_dev); |
|
err_power_down: |
|
kxsd9_power_down(st); |
|
|
|
return ret; |
|
} |
|
EXPORT_SYMBOL(kxsd9_common_probe); |
|
|
|
int kxsd9_common_remove(struct device *dev) |
|
{ |
|
struct iio_dev *indio_dev = dev_get_drvdata(dev); |
|
struct kxsd9_state *st = iio_priv(indio_dev); |
|
|
|
iio_triggered_buffer_cleanup(indio_dev); |
|
iio_device_unregister(indio_dev); |
|
pm_runtime_get_sync(dev); |
|
pm_runtime_put_noidle(dev); |
|
pm_runtime_disable(dev); |
|
kxsd9_power_down(st); |
|
|
|
return 0; |
|
} |
|
EXPORT_SYMBOL(kxsd9_common_remove); |
|
|
|
#ifdef CONFIG_PM |
|
static int kxsd9_runtime_suspend(struct device *dev) |
|
{ |
|
struct iio_dev *indio_dev = dev_get_drvdata(dev); |
|
struct kxsd9_state *st = iio_priv(indio_dev); |
|
|
|
return kxsd9_power_down(st); |
|
} |
|
|
|
static int kxsd9_runtime_resume(struct device *dev) |
|
{ |
|
struct iio_dev *indio_dev = dev_get_drvdata(dev); |
|
struct kxsd9_state *st = iio_priv(indio_dev); |
|
|
|
return kxsd9_power_up(st); |
|
} |
|
#endif /* CONFIG_PM */ |
|
|
|
const struct dev_pm_ops kxsd9_dev_pm_ops = { |
|
SET_SYSTEM_SLEEP_PM_OPS(pm_runtime_force_suspend, |
|
pm_runtime_force_resume) |
|
SET_RUNTIME_PM_OPS(kxsd9_runtime_suspend, |
|
kxsd9_runtime_resume, NULL) |
|
}; |
|
EXPORT_SYMBOL(kxsd9_dev_pm_ops); |
|
|
|
MODULE_AUTHOR("Jonathan Cameron <[email protected]>"); |
|
MODULE_DESCRIPTION("Kionix KXSD9 driver"); |
|
MODULE_LICENSE("GPL v2");
|
|
|