| // SPDX-License-Identifier: GPL-2.0-only | |
| /* | |
| * kxsd9.c simple support for the Kionix KXSD9 3D | |
| * accelerometer. | |
| * | |
| * Copyright (c) 2008-2009 Jonathan Cameron <jic23@kernel.org> | |
| * | |
| * 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/types.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) | |
| ret = -EINVAL; | |
| else | |
| ret = kxsd9_write_scale(indio_dev, val2); | |
| } | |
| 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_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]; | |
| aligned_s64 ts; | |
| } 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: %d\n", ret); | |
| goto out; | |
| } | |
| iio_push_to_buffers_with_ts(indio_dev, &hw_values, sizeof(hw_values), | |
| iio_get_time_ns(indio_dev)); | |
| out: | |
| 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_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_clear_bits(st->map, KXSD9_REG_CTRL_B, KXSD9_CTRL_B_ENABLE); | |
| 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, &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_NS(kxsd9_common_probe, "IIO_KXSD9"); | |
| void 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); | |
| } | |
| EXPORT_SYMBOL_NS(kxsd9_common_remove, "IIO_KXSD9"); | |
| 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); | |
| } | |
| EXPORT_NS_RUNTIME_DEV_PM_OPS(kxsd9_dev_pm_ops, kxsd9_runtime_suspend, | |
| kxsd9_runtime_resume, NULL, IIO_KXSD9); | |
| MODULE_AUTHOR("Jonathan Cameron <jic23@kernel.org>"); | |
| MODULE_DESCRIPTION("Kionix KXSD9 driver"); | |
| MODULE_LICENSE("GPL v2"); |