Skip to content

L
linux
Commit 888a87b5 authored by Greg Kroah-Hartman's avatar Greg Kroah-Hartman
Browse files
Options

Merge tag 'iio-for-4.9c' of... 

Merge tag 'iio-for-4.9c' of git://git.kernel.org/pub/scm/linux/kernel/git/jic23/iio into staging-next

Jonathan writes:

Third set of new device support, functionality and cleanups for IIO in the 4.9 cycle.

Given Linus is hinting (strongly!) at an rc8 this last set is hopefully in
time for the 4.9 merge window.  The zpa2326 and si1145 drivers provide
fine illustrations that devices aren't getting any simpler!

I'm also particularly pleased Linus Walliej did such a thorough job of cleaning
up one of my old drivers.

New device support
* mCube MC3230 accelerometer
  - new fairly minimal driver.
* Murata zpa2326
  - extensive new driver supporting the rather 'novel' buffering of data this
    device provides and handling both it's own data ready trigger and other
    triggers rather elegantly.
* si1141, si1142, si1143, si1145, si1146 and si1147 proximity, UV, visible and
  IR sensors.
  - another extensive new driver supporting all the key bits of what this
    set of devices supplies including dataready triggers, buffers and all the
    various data channels.

Functionality
* kxsd9 - Linus brought this scratch driver I wrote in one afternoon years ago
  up to date adding lots of good stuff along the way.
  - SPI support after extensive rework of the driver.
  - Triggered buffer capture support.
  - Runtime PM.
  - Regulator handling.
  - Mounting matrix support.
* mma7660
  - Add MODULE_DEVICE_TABLE to support autoprobing.

Cleanups
* ad5933
  - Align some function arguements nicely.
* med_z188
  - Constify iio_info structure.
* sca3000
  - Implement IIO_CHAN_INFO_SAMP_FREQ rather than a hand rolled attr.
    There are still quite a few drivers that would benefit from similar updates.
* ssp_sensors
  - Constify iio_info structures in accel and gyro drivers.
parents 530a7061 ac45e57f
Show whitespace changes
Inline Side-by-side
Showing with 4367 additions and 238 deletions
Documentation/devicetree/bindings/i2c/trivial-devices.txt
View file @ 888a87b5
......@@ -57,6 +57,7 @@ maxim,ds1050 5 Bit Programmable, Pulse-Width Modulator
maxim,max1237 Low-Power, 4-/12-Channel, 2-Wire Serial, 12-Bit ADCs
maxim,max6625 9-Bit/12-Bit Temperature Sensors with I²C-Compatible Serial Interface
mc,rv3029c2 Real Time Clock Module with I2C-Bus
mcube,mc3230 mCube 3-axis 8-bit digital accelerometer
microchip,mcp4531-502 Microchip 7-bit Single I2C Digital Potentiometer (5k)
microchip,mcp4531-103 Microchip 7-bit Single I2C Digital Potentiometer (10k)
microchip,mcp4531-503 Microchip 7-bit Single I2C Digital Potentiometer (50k)
......
Documentation/devicetree/bindings/iio/pressure/zpa2326.txt 0 → 100644
View file @ 888a87b5
Murata ZPA2326 pressure sensor
Pressure sensor from Murata with SPI and I2C bus interfaces.
Required properties:
- compatible: "murata,zpa2326"
- reg: the I2C address or SPI chip select the device will respond to
Recommended properties for SPI bus usage:
- spi-max-frequency: maximum SPI bus frequency as documented in
Documentation/devicetree/bindings/spi/spi-bus.txt
Optional properties:
- vref-supply: an optional regulator that needs to be on to provide VREF
power to the sensor
- vdd-supply: an optional regulator that needs to be on to provide VDD
power to the sensor
- interrupt-parent: phandle to the parent interrupt controller as documented in
Documentation/devicetree/bindings/interrupt-controller/interrupts.txt
- interrupts: interrupt mapping for IRQ as documented in
Documentation/devicetree/bindings/interrupt-controller/interrupts.txt
Example:
zpa2326@5c {
compatible = "murata,zpa2326";
reg = <0x5c>;
interrupt-parent = <&gpio>;
interrupts = <12>;
vdd-supply = <&ldo_1v8_gnss>;
};
drivers/iio/accel/Kconfig
View file @ 888a87b5
......@@ -119,14 +119,35 @@ config IIO_ST_ACCEL_SPI_3AXIS
config KXSD9
tristate "Kionix KXSD9 Accelerometer Driver"
depends on SPI
select IIO_BUFFER
select IIO_TRIGGERED_BUFFER
help
Say yes here to build support for the Kionix KXSD9 accelerometer.
Currently this only supports the device via an SPI interface.
It can be accessed using an (optional) SPI or I2C interface.
To compile this driver as a module, choose M here: the module
will be called kxsd9.
config KXSD9_SPI
tristate "Kionix KXSD9 SPI transport"
depends on KXSD9
depends on SPI
default KXSD9
select REGMAP_SPI
help
Say yes here to enable the Kionix KXSD9 accelerometer
SPI transport channel.
config KXSD9_I2C
tristate "Kionix KXSD9 I2C transport"
depends on KXSD9
depends on I2C
default KXSD9
select REGMAP_I2C
help
Say yes here to enable the Kionix KXSD9 accelerometer
I2C transport channel.
config KXCJK1013
tristate "Kionix 3-Axis Accelerometer Driver"
depends on I2C
......@@ -140,6 +161,16 @@ config KXCJK1013
To compile this driver as a module, choose M here: the module will
be called kxcjk-1013.
config MC3230
tristate "mCube MC3230 Digital Accelerometer Driver"
depends on I2C
help
Say yes here to build support for the mCube MC3230 low-g tri-axial
digital accelerometer.
To compile this driver as a module, choose M here: the
module will be called mc3230.
config MMA7455
tristate
select IIO_BUFFER
......
drivers/iio/accel/Makefile
View file @ 888a87b5
......@@ -13,6 +13,9 @@ obj-$(CONFIG_DMARD09) += dmard09.o
obj-$(CONFIG_HID_SENSOR_ACCEL_3D) += hid-sensor-accel-3d.o
obj-$(CONFIG_KXCJK1013) += kxcjk-1013.o
obj-$(CONFIG_KXSD9) += kxsd9.o
obj-$(CONFIG_KXSD9_SPI) += kxsd9-spi.o
obj-$(CONFIG_KXSD9_I2C) += kxsd9-i2c.o
obj-$(CONFIG_MC3230) += mc3230.o
obj-$(CONFIG_MMA7455) += mma7455_core.o
obj-$(CONFIG_MMA7455_I2C) += mma7455_i2c.o
......
drivers/iio/accel/kxsd9-i2c.c 0 → 100644
View file @ 888a87b5
#include <linux/device.h>
#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/slab.h>
#include <linux/i2c.h>
#include <linux/delay.h>
#include <linux/regmap.h>
#include "kxsd9.h"
static int kxsd9_i2c_probe(struct i2c_client *i2c,
const struct i2c_device_id *id)
{
static const struct regmap_config config = {
.reg_bits = 8,
.val_bits = 8,
.max_register = 0x0e,
};
struct regmap *regmap;
regmap = devm_regmap_init_i2c(i2c, &config);
if (IS_ERR(regmap)) {
dev_err(&i2c->dev, "Failed to register i2c regmap %d\n",
(int)PTR_ERR(regmap));
return PTR_ERR(regmap);
}
return kxsd9_common_probe(&i2c->dev,
regmap,
i2c->name);
}
static int kxsd9_i2c_remove(struct i2c_client *client)
{
return kxsd9_common_remove(&client->dev);
}
#ifdef CONFIG_OF
static const struct of_device_id kxsd9_of_match[] = {
{ .compatible = "kionix,kxsd9", },
{ },
};
MODULE_DEVICE_TABLE(of, kxsd9_of_match);
#else
#define kxsd9_of_match NULL
#endif
static const struct i2c_device_id kxsd9_i2c_id[] = {
{"kxsd9", 0},
{ },
};
MODULE_DEVICE_TABLE(i2c, kxsd9_i2c_id);
static struct i2c_driver kxsd9_i2c_driver = {
.driver = {
.name = "kxsd9",
.of_match_table = of_match_ptr(kxsd9_of_match),
.pm = &kxsd9_dev_pm_ops,
},
.probe = kxsd9_i2c_probe,
.remove = kxsd9_i2c_remove,
.id_table = kxsd9_i2c_id,
};
module_i2c_driver(kxsd9_i2c_driver);
drivers/iio/accel/kxsd9-spi.c 0 → 100644
View file @ 888a87b5
#include <linux/device.h>
#include <linux/kernel.h>
#include <linux/spi/spi.h>
#include <linux/module.h>
#include <linux/slab.h>
#include <linux/regmap.h>
#include "kxsd9.h"
static int kxsd9_spi_probe(struct spi_device *spi)
{
static const struct regmap_config config = {
.reg_bits = 8,
.val_bits = 8,
.max_register = 0x0e,
};
struct regmap *regmap;
spi->mode = SPI_MODE_0;
regmap = devm_regmap_init_spi(spi, &config);
if (IS_ERR(regmap)) {
dev_err(&spi->dev, "%s: regmap allocation failed: %ld\n",
__func__, PTR_ERR(regmap));
return PTR_ERR(regmap);
}
return kxsd9_common_probe(&spi->dev,
regmap,
spi_get_device_id(spi)->name);
}
static int kxsd9_spi_remove(struct spi_device *spi)
{
return kxsd9_common_remove(&spi->dev);
}
static const struct spi_device_id kxsd9_spi_id[] = {
{"kxsd9", 0},
{ },
};
MODULE_DEVICE_TABLE(spi, kxsd9_spi_id);
static struct spi_driver kxsd9_spi_driver = {
.driver = {
.name = "kxsd9",
.pm = &kxsd9_dev_pm_ops,
},
.probe = kxsd9_spi_probe,
.remove = kxsd9_spi_remove,
.id_table = kxsd9_spi_id,
};
module_spi_driver(kxsd9_spi_driver);
MODULE_AUTHOR("Jonathan Cameron <jic23@kernel.org>");
MODULE_DESCRIPTION("Kionix KXSD9 SPI driver");
MODULE_LICENSE("GPL v2");
drivers/iio/accel/kxsd9.c
View file @ 888a87b5
......@@ -12,19 +12,25 @@
* I have a suitable wire made up.
*
* TODO: Support the motion detector
* Uses register address incrementing so could have a
* heavily optimized ring buffer access function.
*/
#include <linux/device.h>
#include <linux/kernel.h>
#include <linux/spi/spi.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
......@@ -33,28 +39,45 @@
#define KXSD9_REG_RESET 0x0a
#define KXSD9_REG_CTRL_C 0x0c
#define KXSD9_FS_MASK 0x03
#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_REG_CTRL_A 0x0e
#define KXSD9_READ(a) (0x80 | (a))
#define KXSD9_WRITE(a) (a)
#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
#define KXSD9_STATE_RX_SIZE 2
#define KXSD9_STATE_TX_SIZE 2
/**
* struct kxsd9_state - device related storage
* @buf_lock: protect the rx and tx buffers.
* @us: spi device
* @rx: single rx buffer storage
* @tx: single tx buffer 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 mutex buf_lock;
struct spi_device *us;
u8 rx[KXSD9_STATE_RX_SIZE] ____cacheline_aligned;
u8 tx[KXSD9_STATE_TX_SIZE];
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"
......@@ -65,6 +88,14 @@ struct kxsd9_state {
/* 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;
......@@ -79,42 +110,17 @@ static int kxsd9_write_scale(struct iio_dev *indio_dev, int micro)
if (!foundit)
return -EINVAL;
mutex_lock(&st->buf_lock);
ret = spi_w8r8(st->us, KXSD9_READ(KXSD9_REG_CTRL_C));
ret = regmap_update_bits(st->map,
KXSD9_REG_CTRL_C,
KXSD9_CTRL_C_FS_MASK,
i);
if (ret < 0)
goto error_ret;
st->tx[0] = KXSD9_WRITE(KXSD9_REG_CTRL_C);
st->tx[1] = (ret & ~KXSD9_FS_MASK) | i;
ret = spi_write(st->us, st->tx, 2);
error_ret:
mutex_unlock(&st->buf_lock);
return ret;
}
/* Cached scale when the sensor is powered down */
st->scale = i;
static int kxsd9_read(struct iio_dev *indio_dev, u8 address)
{
int ret;
struct kxsd9_state *st = iio_priv(indio_dev);
struct spi_transfer xfers[] = {
{
.bits_per_word = 8,
.len = 1,
.delay_usecs = 200,
.tx_buf = st->tx,
}, {
.bits_per_word = 8,
.len = 2,
.rx_buf = st->rx,
},
};
mutex_lock(&st->buf_lock);
st->tx[0] = KXSD9_READ(address);
ret = spi_sync_transfer(st->us, xfers, ARRAY_SIZE(xfers));
if (!ret)
ret = (((u16)(st->rx[0])) << 8) | (st->rx[1] & 0xF0);
mutex_unlock(&st->buf_lock);
error_ret:
return ret;
}
......@@ -136,6 +142,9 @@ static int kxsd9_write_raw(struct iio_dev *indio_dev,
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 */
......@@ -144,6 +153,9 @@ static int kxsd9_write_raw(struct iio_dev *indio_dev,
ret = kxsd9_write_scale(indio_dev, val2);
}
pm_runtime_mark_last_busy(st->dev);
pm_runtime_put_autosuspend(st->dev);
return ret;
}
......@@ -153,46 +165,154 @@ static int kxsd9_read_raw(struct iio_dev *indio_dev,
{
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 = kxsd9_read(indio_dev, chan->address);
if (ret < 0)
ret = regmap_bulk_read(st->map, chan->address, &raw_val,
sizeof(raw_val));
if (ret)
goto error_ret;
*val = 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 = spi_w8r8(st->us, KXSD9_READ(KXSD9_REG_CTRL_C));
ret = regmap_read(st->map,
KXSD9_REG_CTRL_C,
&regval);
if (ret < 0)
goto error_ret;
*val = 0;
*val2 = kxsd9_micro_scales[ret & KXSD9_FS_MASK];
*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);
int ret;
/* 4 * 16bit values AND timestamp */
__be16 hw_values[8];
ret = regmap_bulk_read(st->map,
KXSD9_REG_X,
&hw_values,
8);
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,
.postenable = iio_triggered_buffer_postenable,
.predisable = iio_triggered_buffer_predisable,
.postdisable = kxsd9_buffer_postdisable,
};
#define KXSD9_ACCEL_CHAN(axis) \
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), \
.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), KXSD9_ACCEL_CHAN(Y), KXSD9_ACCEL_CHAN(Z),
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 = {
......@@ -203,17 +323,69 @@ static int kxsd9_power_up(struct kxsd9_state *st)
{
int ret;
st->tx[0] = 0x0d;
st->tx[1] = 0x40;
ret = spi_write(st->us, st->tx, 2);
/* 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;
st->tx[0] = 0x0c;
st->tx[1] = 0x9b;
return spi_write(st->us, st->tx, 2);
/*
* 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,
......@@ -221,57 +393,136 @@ static const struct iio_info kxsd9_info = {
.driver_module = THIS_MODULE,
};
static int kxsd9_probe(struct spi_device *spi)
/* 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(&spi->dev, sizeof(*st));
indio_dev = devm_iio_device_alloc(dev, sizeof(*st));
if (!indio_dev)
return -ENOMEM;
st = iio_priv(indio_dev);
spi_set_drvdata(spi, indio_dev);
st->dev = dev;
st->map = map;
st->us = spi;
mutex_init(&st->buf_lock);
indio_dev->channels = kxsd9_channels;
indio_dev->num_channels = ARRAY_SIZE(kxsd9_channels);
indio_dev->name = spi_get_device_id(spi)->name;
indio_dev->dev.parent = &spi->dev;
indio_dev->name = name;
indio_dev->dev.parent = dev;
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 = of_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;
spi->mode = SPI_MODE_0;
spi_setup(spi);
kxsd9_power_up(st);
return iio_device_register(indio_dev);
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);
static int kxsd9_remove(struct spi_device *spi)
int kxsd9_common_remove(struct device *dev)
{
iio_device_unregister(spi_get_drvdata(spi));
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);
static const struct spi_device_id kxsd9_id[] = {
{"kxsd9", 0},
{ },
};
MODULE_DEVICE_TABLE(spi, kxsd9_id);
#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);
static struct spi_driver kxsd9_driver = {
.driver = {
.name = "kxsd9",
},
.probe = kxsd9_probe,
.remove = kxsd9_remove,
.id_table = kxsd9_id,
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)
};
module_spi_driver(kxsd9_driver);
EXPORT_SYMBOL(kxsd9_dev_pm_ops);
MODULE_AUTHOR("Jonathan Cameron <jic23@kernel.org>");
MODULE_DESCRIPTION("Kionix KXSD9 SPI driver");
MODULE_DESCRIPTION("Kionix KXSD9 driver");
MODULE_LICENSE("GPL v2");
drivers/iio/accel/kxsd9.h 0 → 100644
View file @ 888a87b5
#include <linux/device.h>
#include <linux/kernel.h>
#define KXSD9_STATE_RX_SIZE 2
#define KXSD9_STATE_TX_SIZE 2
int kxsd9_common_probe(struct device *dev,
struct regmap *map,
const char *name);
int kxsd9_common_remove(struct device *dev);
extern const struct dev_pm_ops kxsd9_dev_pm_ops;
drivers/iio/accel/mc3230.c 0 → 100644
View file @ 888a87b5
/**
* mCube MC3230 3-Axis Accelerometer
*
* Copyright (c) 2016 Hans de Goede <hdegoede@redhat.com>
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* IIO driver for mCube MC3230; 7-bit I2C address: 0x4c.
*/
#include <linux/i2c.h>
#include <linux/module.h>
#include <linux/iio/iio.h>
#include <linux/iio/sysfs.h>
#define MC3230_REG_XOUT 0x00
#define MC3230_REG_YOUT 0x01
#define MC3230_REG_ZOUT 0x02
#define MC3230_REG_MODE 0x07
#define MC3230_MODE_OPCON_MASK 0x03
#define MC3230_MODE_OPCON_WAKE 0x01
#define MC3230_MODE_OPCON_STANDBY 0x03
#define MC3230_REG_CHIP_ID 0x18
#define MC3230_CHIP_ID 0x01
#define MC3230_REG_PRODUCT_CODE 0x3b
#define MC3230_PRODUCT_CODE 0x19
/*
* The accelerometer has one measurement range:
*
* -1.5g - +1.5g (8-bit, signed)
*
* scale = (1.5 + 1.5) * 9.81 / (2^8 - 1) = 0.115411765
*/
static const int mc3230_nscale = 115411765;
#define MC3230_CHANNEL(reg, axis) { \
.type = IIO_ACCEL, \
.address = reg, \
.modified = 1, \
.channel2 = IIO_MOD_##axis, \
.info_mask_separate = BIT(IIO_CHAN_INFO_RAW), \
.info_mask_shared_by_type = BIT(IIO_CHAN_INFO_SCALE), \
}
static const struct iio_chan_spec mc3230_channels[] = {
MC3230_CHANNEL(MC3230_REG_XOUT, X),
MC3230_CHANNEL(MC3230_REG_YOUT, Y),
MC3230_CHANNEL(MC3230_REG_ZOUT, Z),
};
struct mc3230_data {
struct i2c_client *client;
};
static int mc3230_set_opcon(struct mc3230_data *data, int opcon)
{
int ret;
struct i2c_client *client = data->client;
ret = i2c_smbus_read_byte_data(client, MC3230_REG_MODE);
if (ret < 0) {
dev_err(&client->dev, "failed to read mode reg: %d\n", ret);
return ret;
}
ret &= ~MC3230_MODE_OPCON_MASK;
ret |= opcon;
ret = i2c_smbus_write_byte_data(client, MC3230_REG_MODE, ret);
if (ret < 0) {
dev_err(&client->dev, "failed to write mode reg: %d\n", ret);
return ret;
}
return 0;
}
static int mc3230_read_raw(struct iio_dev *indio_dev,
struct iio_chan_spec const *chan,
int *val, int *val2, long mask)
{
struct mc3230_data *data = iio_priv(indio_dev);
int ret;
switch (mask) {
case IIO_CHAN_INFO_RAW:
ret = i2c_smbus_read_byte_data(data->client, chan->address);
if (ret < 0)
return ret;
*val = sign_extend32(ret, 7);
return IIO_VAL_INT;
case IIO_CHAN_INFO_SCALE:
*val = 0;
*val2 = mc3230_nscale;
return IIO_VAL_INT_PLUS_NANO;
default:
return -EINVAL;
}
}
static const struct iio_info mc3230_info = {
.driver_module = THIS_MODULE,
.read_raw = mc3230_read_raw,
};
static int mc3230_probe(struct i2c_client *client,
const struct i2c_device_id *id)
{
int ret;
struct iio_dev *indio_dev;
struct mc3230_data *data;
/* First check chip-id and product-id */
ret = i2c_smbus_read_byte_data(client, MC3230_REG_CHIP_ID);
if (ret != MC3230_CHIP_ID)
return (ret < 0) ? ret : -ENODEV;
ret = i2c_smbus_read_byte_data(client, MC3230_REG_PRODUCT_CODE);
if (ret != MC3230_PRODUCT_CODE)
return (ret < 0) ? ret : -ENODEV;
indio_dev = devm_iio_device_alloc(&client->dev, sizeof(*data));
if (!indio_dev) {
dev_err(&client->dev, "iio allocation failed!\n");
return -ENOMEM;
}
data = iio_priv(indio_dev);
data->client = client;
i2c_set_clientdata(client, indio_dev);
indio_dev->dev.parent = &client->dev;
indio_dev->info = &mc3230_info;
indio_dev->name = "mc3230";
indio_dev->modes = INDIO_DIRECT_MODE;
indio_dev->channels = mc3230_channels;
indio_dev->num_channels = ARRAY_SIZE(mc3230_channels);
ret = mc3230_set_opcon(data, MC3230_MODE_OPCON_WAKE);
if (ret < 0)
return ret;
ret = iio_device_register(indio_dev);
if (ret < 0) {
dev_err(&client->dev, "device_register failed\n");
mc3230_set_opcon(data, MC3230_MODE_OPCON_STANDBY);
}
return ret;
}
static int mc3230_remove(struct i2c_client *client)
{
struct iio_dev *indio_dev = i2c_get_clientdata(client);
iio_device_unregister(indio_dev);
return mc3230_set_opcon(iio_priv(indio_dev), MC3230_MODE_OPCON_STANDBY);
}
#ifdef CONFIG_PM_SLEEP
static int mc3230_suspend(struct device *dev)
{
struct mc3230_data *data;
data = iio_priv(i2c_get_clientdata(to_i2c_client(dev)));
return mc3230_set_opcon(data, MC3230_MODE_OPCON_STANDBY);
}
static int mc3230_resume(struct device *dev)
{
struct mc3230_data *data;
data = iio_priv(i2c_get_clientdata(to_i2c_client(dev)));
return mc3230_set_opcon(data, MC3230_MODE_OPCON_WAKE);
}
#endif
static SIMPLE_DEV_PM_OPS(mc3230_pm_ops, mc3230_suspend, mc3230_resume);
static const struct i2c_device_id mc3230_i2c_id[] = {
{"mc3230", 0},
{}
};
MODULE_DEVICE_TABLE(i2c, mc3230_i2c_id);
static struct i2c_driver mc3230_driver = {
.driver = {
.name = "mc3230",
.pm = &mc3230_pm_ops,
},
.probe = mc3230_probe,
.remove = mc3230_remove,
.id_table = mc3230_i2c_id,
};
module_i2c_driver(mc3230_driver);
MODULE_AUTHOR("Hans de Goede <hdegoede@redhat.com>");
MODULE_DESCRIPTION("mCube MC3230 3-Axis Accelerometer driver");
MODULE_LICENSE("GPL v2");
drivers/iio/accel/mma7660.c
View file @ 888a87b5
......@@ -251,6 +251,7 @@ static const struct i2c_device_id mma7660_i2c_id[] = {
{"mma7660", 0},
{}
};
MODULE_DEVICE_TABLE(i2c, mma7660_i2c_id);
static const struct acpi_device_id mma7660_acpi_id[] = {
{"MMA7660", 0},
......
drivers/iio/accel/ssp_accel_sensor.c
View file @ 888a87b5
......@@ -74,7 +74,7 @@ static int ssp_accel_write_raw(struct iio_dev *indio_dev,
return -EINVAL;
}
static struct iio_info ssp_accel_iio_info = {
static const struct iio_info ssp_accel_iio_info = {
.read_raw = &ssp_accel_read_raw,
.write_raw = &ssp_accel_write_raw,
};
......
drivers/iio/adc/men_z188_adc.c
View file @ 888a87b5
......@@ -78,7 +78,7 @@ static int z188_iio_read_raw(struct iio_dev *iio_dev,
return ret;
}
static struct iio_info z188_adc_info = {
static const struct iio_info z188_adc_info = {
.read_raw = &z188_iio_read_raw,
.driver_module = THIS_MODULE,
};
......
drivers/iio/gyro/ssp_gyro_sensor.c
View file @ 888a87b5
......@@ -74,7 +74,7 @@ static int ssp_gyro_write_raw(struct iio_dev *indio_dev,
return -EINVAL;
}
static struct iio_info ssp_gyro_iio_info = {
static const struct iio_info ssp_gyro_iio_info = {
.read_raw = &ssp_gyro_read_raw,
.write_raw = &ssp_gyro_write_raw,
};
......
drivers/iio/light/Kconfig
View file @ 888a87b5
......@@ -267,6 +267,19 @@ config PA12203001
This driver can also be built as a module. If so, the module
will be called pa12203001.
config SI1145
tristate "SI1132 and SI1141/2/3/5/6/7 combined ALS, UV index and proximity sensor"
depends on I2C
select IIO_BUFFER
select IIO_TRIGGERED_BUFFER
help
Say Y here if you want to build a driver for the Silicon Labs SI1132 or
SI1141/2/3/5/6/7 combined ambient light, UV index and proximity sensor
chips.
To compile this driver as a module, choose M here: the module will be
called si1145.
config STK3310
tristate "STK3310 ALS and proximity sensor"
depends on I2C
......
drivers/iio/light/Makefile
View file @ 888a87b5
......@@ -26,6 +26,7 @@ obj-$(CONFIG_OPT3001) += opt3001.o
obj-$(CONFIG_PA12203001) += pa12203001.o
obj-$(CONFIG_RPR0521) += rpr0521.o
obj-$(CONFIG_SENSORS_TSL2563) += tsl2563.o
obj-$(CONFIG_SI1145) += si1145.o
obj-$(CONFIG_STK3310) += stk3310.o
obj-$(CONFIG_TCS3414) += tcs3414.o
obj-$(CONFIG_TCS3472) += tcs3472.o
......
drivers/iio/light/si1145.c 0 → 100644
View file @ 888a87b5
/*
* si1145.c - Support for Silabs SI1132 and SI1141/2/3/5/6/7 combined ambient
* light, UV index and proximity sensors
*
* Copyright 2014-16 Peter Meerwald-Stadler <pmeerw@pmeerw.net>
* Copyright 2016 Crestez Dan Leonard <leonard.crestez@intel.com>
*
* This file is subject to the terms and conditions of version 2 of
* the GNU General Public License. See the file COPYING in the main
* directory of this archive for more details.
*
* SI1132 (7-bit I2C slave address 0x60)
* SI1141/2/3 (7-bit I2C slave address 0x5a)
* SI1145/6/6 (7-bit I2C slave address 0x60)
*/
#include <linux/module.h>
#include <linux/i2c.h>
#include <linux/err.h>
#include <linux/slab.h>
#include <linux/delay.h>
#include <linux/irq.h>
#include <linux/gpio.h>
#include <linux/iio/iio.h>
#include <linux/iio/sysfs.h>
#include <linux/iio/trigger.h>
#include <linux/iio/trigger_consumer.h>
#include <linux/iio/triggered_buffer.h>
#include <linux/iio/buffer.h>
#include <linux/util_macros.h>
#define SI1145_REG_PART_ID 0x00
#define SI1145_REG_REV_ID 0x01
#define SI1145_REG_SEQ_ID 0x02
#define SI1145_REG_INT_CFG 0x03
#define SI1145_REG_IRQ_ENABLE 0x04
#define SI1145_REG_IRQ_MODE 0x05
#define SI1145_REG_HW_KEY 0x07
#define SI1145_REG_MEAS_RATE 0x08
#define SI1145_REG_PS_LED21 0x0f
#define SI1145_REG_PS_LED3 0x10
#define SI1145_REG_UCOEF1 0x13
#define SI1145_REG_UCOEF2 0x14
#define SI1145_REG_UCOEF3 0x15
#define SI1145_REG_UCOEF4 0x16
#define SI1145_REG_PARAM_WR 0x17
#define SI1145_REG_COMMAND 0x18
#define SI1145_REG_RESPONSE 0x20
#define SI1145_REG_IRQ_STATUS 0x21
#define SI1145_REG_ALSVIS_DATA 0x22
#define SI1145_REG_ALSIR_DATA 0x24
#define SI1145_REG_PS1_DATA 0x26
#define SI1145_REG_PS2_DATA 0x28
#define SI1145_REG_PS3_DATA 0x2a
#define SI1145_REG_AUX_DATA 0x2c
#define SI1145_REG_PARAM_RD 0x2e
#define SI1145_REG_CHIP_STAT 0x30
#define SI1145_UCOEF1_DEFAULT 0x7b
#define SI1145_UCOEF2_DEFAULT 0x6b
#define SI1145_UCOEF3_DEFAULT 0x01
#define SI1145_UCOEF4_DEFAULT 0x00
/* Helper to figure out PS_LED register / shift per channel */
#define SI1145_PS_LED_REG(ch) \
(((ch) == 2) ? SI1145_REG_PS_LED3 : SI1145_REG_PS_LED21)
#define SI1145_PS_LED_SHIFT(ch) \
(((ch) == 1) ? 4 : 0)
/* Parameter offsets */
#define SI1145_PARAM_CHLIST 0x01
#define SI1145_PARAM_PSLED12_SELECT 0x02
#define SI1145_PARAM_PSLED3_SELECT 0x03
#define SI1145_PARAM_PS_ENCODING 0x05
#define SI1145_PARAM_ALS_ENCODING 0x06
#define SI1145_PARAM_PS1_ADC_MUX 0x07
#define SI1145_PARAM_PS2_ADC_MUX 0x08
#define SI1145_PARAM_PS3_ADC_MUX 0x09
#define SI1145_PARAM_PS_ADC_COUNTER 0x0a
#define SI1145_PARAM_PS_ADC_GAIN 0x0b
#define SI1145_PARAM_PS_ADC_MISC 0x0c
#define SI1145_PARAM_ALS_ADC_MUX 0x0d
#define SI1145_PARAM_ALSIR_ADC_MUX 0x0e
#define SI1145_PARAM_AUX_ADC_MUX 0x0f
#define SI1145_PARAM_ALSVIS_ADC_COUNTER 0x10
#define SI1145_PARAM_ALSVIS_ADC_GAIN 0x11
#define SI1145_PARAM_ALSVIS_ADC_MISC 0x12
#define SI1145_PARAM_LED_RECOVERY 0x1c
#define SI1145_PARAM_ALSIR_ADC_COUNTER 0x1d
#define SI1145_PARAM_ALSIR_ADC_GAIN 0x1e
#define SI1145_PARAM_ALSIR_ADC_MISC 0x1f
#define SI1145_PARAM_ADC_OFFSET 0x1a
/* Channel enable masks for CHLIST parameter */
#define SI1145_CHLIST_EN_PS1 BIT(0)
#define SI1145_CHLIST_EN_PS2 BIT(1)
#define SI1145_CHLIST_EN_PS3 BIT(2)
#define SI1145_CHLIST_EN_ALSVIS BIT(4)
#define SI1145_CHLIST_EN_ALSIR BIT(5)
#define SI1145_CHLIST_EN_AUX BIT(6)
#define SI1145_CHLIST_EN_UV BIT(7)
/* Proximity measurement mode for ADC_MISC parameter */
#define SI1145_PS_ADC_MODE_NORMAL BIT(2)
/* Signal range mask for ADC_MISC parameter */
#define SI1145_ADC_MISC_RANGE BIT(5)
/* Commands for REG_COMMAND */
#define SI1145_CMD_NOP 0x00
#define SI1145_CMD_RESET 0x01
#define SI1145_CMD_PS_FORCE 0x05
#define SI1145_CMD_ALS_FORCE 0x06
#define SI1145_CMD_PSALS_FORCE 0x07
#define SI1145_CMD_PS_PAUSE 0x09
#define SI1145_CMD_ALS_PAUSE 0x0a
#define SI1145_CMD_PSALS_PAUSE 0x0b
#define SI1145_CMD_PS_AUTO 0x0d
#define SI1145_CMD_ALS_AUTO 0x0e
#define SI1145_CMD_PSALS_AUTO 0x0f
#define SI1145_CMD_PARAM_QUERY 0x80
#define SI1145_CMD_PARAM_SET 0xa0
#define SI1145_RSP_INVALID_SETTING 0x80
#define SI1145_RSP_COUNTER_MASK 0x0F
/* Minimum sleep after each command to ensure it's received */
#define SI1145_COMMAND_MINSLEEP_MS 5
/* Return -ETIMEDOUT after this long */
#define SI1145_COMMAND_TIMEOUT_MS 25
/* Interrupt configuration masks for INT_CFG register */
#define SI1145_INT_CFG_OE BIT(0) /* enable interrupt */
#define SI1145_INT_CFG_MODE BIT(1) /* auto reset interrupt pin */
/* Interrupt enable masks for IRQ_ENABLE register */
#define SI1145_MASK_ALL_IE (BIT(4) | BIT(3) | BIT(2) | BIT(0))
#define SI1145_MUX_TEMP 0x65
#define SI1145_MUX_VDD 0x75
/* Proximity LED current; see Table 2 in datasheet */
#define SI1145_LED_CURRENT_45mA 0x04
enum {
SI1132,
SI1141,
SI1142,
SI1143,
SI1145,
SI1146,
SI1147,
};
struct si1145_part_info {
u8 part;
const struct iio_info *iio_info;
const struct iio_chan_spec *channels;
unsigned int num_channels;
unsigned int num_leds;
bool uncompressed_meas_rate;
};
/**
* struct si1145_data - si1145 chip state data
* @client: I2C client
* @lock: mutex to protect shared state.
* @cmdlock: Low-level mutex to protect command execution only
* @rsp_seq: Next expected response number or -1 if counter reset required
* @scan_mask: Saved scan mask to avoid duplicate set_chlist
* @autonomous: If automatic measurements are active (for buffer support)
* @part_info: Part information
* @trig: Pointer to iio trigger
* @meas_rate: Value of MEAS_RATE register. Only set in HW in auto mode
*/
struct si1145_data {
struct i2c_client *client;
struct mutex lock;
struct mutex cmdlock;
int rsp_seq;
const struct si1145_part_info *part_info;
unsigned long scan_mask;
bool autonomous;
struct iio_trigger *trig;
int meas_rate;
};
/**
* __si1145_command_reset() - Send CMD_NOP and wait for response 0
*
* Does not modify data->rsp_seq
*
* Return: 0 on success and -errno on error.
*/
static int __si1145_command_reset(struct si1145_data *data)
{
struct device *dev = &data->client->dev;
unsigned long stop_jiffies;
int ret;
ret = i2c_smbus_write_byte_data(data->client, SI1145_REG_COMMAND,
SI1145_CMD_NOP);
if (ret < 0)
return ret;
msleep(SI1145_COMMAND_MINSLEEP_MS);
stop_jiffies = jiffies + SI1145_COMMAND_TIMEOUT_MS * HZ / 1000;
while (true) {
ret = i2c_smbus_read_byte_data(data->client,
SI1145_REG_RESPONSE);
if (ret <= 0)
return ret;
if (time_after(jiffies, stop_jiffies)) {
dev_warn(dev, "timeout on reset\n");
return -ETIMEDOUT;
}
msleep(SI1145_COMMAND_MINSLEEP_MS);
continue;
}
}
/**
* si1145_command() - Execute a command and poll the response register
*
* All conversion overflows are reported as -EOVERFLOW
* INVALID_SETTING is reported as -EINVAL
* Timeouts are reported as -ETIMEDOUT
*
* Return: 0 on success or -errno on failure
*/
static int si1145_command(struct si1145_data *data, u8 cmd)
{
struct device *dev = &data->client->dev;
unsigned long stop_jiffies;
int ret;
mutex_lock(&data->cmdlock);
if (data->rsp_seq < 0) {
ret = __si1145_command_reset(data);
if (ret < 0) {
dev_err(dev, "failed to reset command counter, ret=%d\n",
ret);
goto out;
}
data->rsp_seq = 0;
}
ret = i2c_smbus_write_byte_data(data->client, SI1145_REG_COMMAND, cmd);
if (ret) {
dev_warn(dev, "failed to write command, ret=%d\n", ret);
goto out;
}
/* Sleep a little to ensure the command is received */
msleep(SI1145_COMMAND_MINSLEEP_MS);
stop_jiffies = jiffies + SI1145_COMMAND_TIMEOUT_MS * HZ / 1000;
while (true) {
ret = i2c_smbus_read_byte_data(data->client,
SI1145_REG_RESPONSE);
if (ret < 0) {
dev_warn(dev, "failed to read response, ret=%d\n", ret);
break;
}
if ((ret & ~SI1145_RSP_COUNTER_MASK) == 0) {
if (ret == data->rsp_seq) {
if (time_after(jiffies, stop_jiffies)) {
dev_warn(dev, "timeout on command %#02hhx\n",
cmd);
ret = -ETIMEDOUT;
break;
}
msleep(SI1145_COMMAND_MINSLEEP_MS);
continue;
}
if (ret == ((data->rsp_seq + 1) &
SI1145_RSP_COUNTER_MASK)) {
data->rsp_seq = ret;
ret = 0;
break;
}
dev_warn(dev, "unexpected response counter %d instead of %d\n",
ret, (data->rsp_seq + 1) &
SI1145_RSP_COUNTER_MASK);
ret = -EIO;
} else {
if (ret == SI1145_RSP_INVALID_SETTING) {
dev_warn(dev, "INVALID_SETTING error on command %#02hhx\n",
cmd);
ret = -EINVAL;
} else {
/* All overflows are treated identically */
dev_dbg(dev, "overflow, ret=%d, cmd=%#02hhx\n",
ret, cmd);
ret = -EOVERFLOW;
}
}
/* Force a counter reset next time */
data->rsp_seq = -1;
break;
}
out:
mutex_unlock(&data->cmdlock);
return ret;
}
static int si1145_param_update(struct si1145_data *data, u8 op, u8 param,
u8 value)
{
int ret;
ret = i2c_smbus_write_byte_data(data->client,
SI1145_REG_PARAM_WR, value);
if (ret < 0)
return ret;
return si1145_command(data, op | (param & 0x1F));
}
static int si1145_param_set(struct si1145_data *data, u8 param, u8 value)
{
return si1145_param_update(data, SI1145_CMD_PARAM_SET, param, value);
}
/* Set param. Returns negative errno or current value */
static int si1145_param_query(struct si1145_data *data, u8 param)
{
int ret;
ret = si1145_command(data, SI1145_CMD_PARAM_QUERY | (param & 0x1F));
if (ret < 0)
return ret;
return i2c_smbus_read_byte_data(data->client, SI1145_REG_PARAM_RD);
}
/* Expand 8 bit compressed value to 16 bit, see Silabs AN498 */
static u16 si1145_uncompress(u8 x)
{
u16 result = 0;
u8 exponent = 0;
if (x < 8)
return 0;
exponent = (x & 0xf0) >> 4;
result = 0x10 | (x & 0x0f);
if (exponent >= 4)
return result << (exponent - 4);
return result >> (4 - exponent);
}
/* Compress 16 bit value to 8 bit, see Silabs AN498 */
static u8 si1145_compress(u16 x)
{
u32 exponent = 0;
u32 significand = 0;
u32 tmp = x;
if (x == 0x0000)
return 0x00;
if (x == 0x0001)
return 0x08;
while (1) {
tmp >>= 1;
exponent += 1;
if (tmp == 1)
break;
}
if (exponent < 5) {
significand = x << (4 - exponent);
return (exponent << 4) | (significand & 0xF);
}
significand = x >> (exponent - 5);
if (significand & 1) {
significand += 2;
if (significand & 0x0040) {
exponent += 1;
significand >>= 1;
}
}
return (exponent << 4) | ((significand >> 1) & 0xF);
}
/* Write meas_rate in hardware */
static int si1145_set_meas_rate(struct si1145_data *data, int interval)
{
if (data->part_info->uncompressed_meas_rate)
return i2c_smbus_write_word_data(data->client,
SI1145_REG_MEAS_RATE, interval);
else
return i2c_smbus_write_byte_data(data->client,
SI1145_REG_MEAS_RATE, interval);
}
static int si1145_read_samp_freq(struct si1145_data *data, int *val, int *val2)
{
*val = 32000;
if (data->part_info->uncompressed_meas_rate)
*val2 = data->meas_rate;
else
*val2 = si1145_uncompress(data->meas_rate);
return IIO_VAL_FRACTIONAL;
}
/* Set the samp freq in driver private data */
static int si1145_store_samp_freq(struct si1145_data *data, int val)
{
int ret = 0;
int meas_rate;
if (val <= 0 || val > 32000)
return -ERANGE;
meas_rate = 32000 / val;
mutex_lock(&data->lock);
if (data->autonomous) {
ret = si1145_set_meas_rate(data, meas_rate);
if (ret)
goto out;
}
if (data->part_info->uncompressed_meas_rate)
data->meas_rate = meas_rate;
else
data->meas_rate = si1145_compress(meas_rate);
out:
mutex_unlock(&data->lock);
return ret;
}
static irqreturn_t si1145_trigger_handler(int irq, void *private)
{
struct iio_poll_func *pf = private;
struct iio_dev *indio_dev = pf->indio_dev;
struct si1145_data *data = iio_priv(indio_dev);
/*
* Maximum buffer size:
* 6*2 bytes channels data + 4 bytes alignment +
* 8 bytes timestamp
*/
u8 buffer[24];
int i, j = 0;
int ret;
u8 irq_status = 0;
if (!data->autonomous) {
ret = si1145_command(data, SI1145_CMD_PSALS_FORCE);
if (ret < 0 && ret != -EOVERFLOW)
goto done;
} else {
irq_status = ret = i2c_smbus_read_byte_data(data->client,
SI1145_REG_IRQ_STATUS);
if (ret < 0)
goto done;
if (!(irq_status & SI1145_MASK_ALL_IE))
goto done;
}
for_each_set_bit(i, indio_dev->active_scan_mask,
indio_dev->masklength) {
int run = 1;
while (i + run < indio_dev->masklength) {
if (!test_bit(i + run, indio_dev->active_scan_mask))
break;
if (indio_dev->channels[i + run].address !=
indio_dev->channels[i].address + 2 * run)
break;
run++;
}
ret = i2c_smbus_read_i2c_block_data_or_emulated(
data->client, indio_dev->channels[i].address,
sizeof(u16) * run, &buffer[j]);
if (ret < 0)
goto done;
j += run * sizeof(u16);
i += run - 1;
}
if (data->autonomous) {
ret = i2c_smbus_write_byte_data(data->client,
SI1145_REG_IRQ_STATUS,
irq_status & SI1145_MASK_ALL_IE);
if (ret < 0)
goto done;
}
iio_push_to_buffers_with_timestamp(indio_dev, buffer,
iio_get_time_ns(indio_dev));
done:
iio_trigger_notify_done(indio_dev->trig);
return IRQ_HANDLED;
}
static int si1145_set_chlist(struct iio_dev *indio_dev, unsigned long scan_mask)
{
struct si1145_data *data = iio_priv(indio_dev);
u8 reg = 0, mux;
int ret;
int i;
/* channel list already set, no need to reprogram */
if (data->scan_mask == scan_mask)
return 0;
for_each_set_bit(i, &scan_mask, indio_dev->masklength) {
switch (indio_dev->channels[i].address) {
case SI1145_REG_ALSVIS_DATA:
reg |= SI1145_CHLIST_EN_ALSVIS;
break;
case SI1145_REG_ALSIR_DATA:
reg |= SI1145_CHLIST_EN_ALSIR;
break;
case SI1145_REG_PS1_DATA:
reg |= SI1145_CHLIST_EN_PS1;
break;
case SI1145_REG_PS2_DATA:
reg |= SI1145_CHLIST_EN_PS2;
break;
case SI1145_REG_PS3_DATA:
reg |= SI1145_CHLIST_EN_PS3;
break;
case SI1145_REG_AUX_DATA:
switch (indio_dev->channels[i].type) {
case IIO_UVINDEX:
reg |= SI1145_CHLIST_EN_UV;
break;
default:
reg |= SI1145_CHLIST_EN_AUX;
if (indio_dev->channels[i].type == IIO_TEMP)
mux = SI1145_MUX_TEMP;
else
mux = SI1145_MUX_VDD;
ret = si1145_param_set(data,
SI1145_PARAM_AUX_ADC_MUX, mux);
if (ret < 0)
return ret;
break;
}
}
}
data->scan_mask = scan_mask;
ret = si1145_param_set(data, SI1145_PARAM_CHLIST, reg);
return ret < 0 ? ret : 0;
}
static int si1145_measure(struct iio_dev *indio_dev,
struct iio_chan_spec const *chan)
{
struct si1145_data *data = iio_priv(indio_dev);
u8 cmd;
int ret;
ret = si1145_set_chlist(indio_dev, BIT(chan->scan_index));
if (ret < 0)
return ret;
cmd = (chan->type == IIO_PROXIMITY) ? SI1145_CMD_PS_FORCE :
SI1145_CMD_ALS_FORCE;
ret = si1145_command(data, cmd);
if (ret < 0 && ret != -EOVERFLOW)
return ret;
return i2c_smbus_read_word_data(data->client, chan->address);
}
/*
* Conversion between iio scale and ADC_GAIN values
* These could be further adjusted but proximity/intensity are dimensionless
*/
static const int si1145_proximity_scale_available[] = {
128, 64, 32, 16, 8, 4};
static const int si1145_intensity_scale_available[] = {
128, 64, 32, 16, 8, 4, 2, 1};
static IIO_CONST_ATTR(in_proximity_scale_available,
"128 64 32 16 8 4");
static IIO_CONST_ATTR(in_intensity_scale_available,
"128 64 32 16 8 4 2 1");
static IIO_CONST_ATTR(in_intensity_ir_scale_available,
"128 64 32 16 8 4 2 1");
static int si1145_scale_from_adcgain(int regval)
{
return 128 >> regval;
}
static int si1145_proximity_adcgain_from_scale(int val, int val2)
{
val = find_closest_descending(val, si1145_proximity_scale_available,
ARRAY_SIZE(si1145_proximity_scale_available));
if (val < 0 || val > 5 || val2 != 0)
return -EINVAL;
return val;
}
static int si1145_intensity_adcgain_from_scale(int val, int val2)
{
val = find_closest_descending(val, si1145_intensity_scale_available,
ARRAY_SIZE(si1145_intensity_scale_available));
if (val < 0 || val > 7 || val2 != 0)
return -EINVAL;
return val;
}
static int si1145_read_raw(struct iio_dev *indio_dev,
struct iio_chan_spec const *chan,
int *val, int *val2, long mask)
{
struct si1145_data *data = iio_priv(indio_dev);
int ret;
u8 reg;
switch (mask) {
case IIO_CHAN_INFO_RAW:
switch (chan->type) {
case IIO_INTENSITY:
case IIO_PROXIMITY:
case IIO_VOLTAGE:
case IIO_TEMP:
case IIO_UVINDEX:
ret = iio_device_claim_direct_mode(indio_dev);
if (ret)
return ret;
ret = si1145_measure(indio_dev, chan);
iio_device_release_direct_mode(indio_dev);
if (ret < 0)
return ret;
*val = ret;
return IIO_VAL_INT;
case IIO_CURRENT:
ret = i2c_smbus_read_byte_data(data->client,
SI1145_PS_LED_REG(chan->channel));
if (ret < 0)
return ret;
*val = (ret >> SI1145_PS_LED_SHIFT(chan->channel))
& 0x0f;
return IIO_VAL_INT;
default:
return -EINVAL;
}
case IIO_CHAN_INFO_SCALE:
switch (chan->type) {
case IIO_PROXIMITY:
reg = SI1145_PARAM_PS_ADC_GAIN;
break;
case IIO_INTENSITY:
if (chan->channel2 == IIO_MOD_LIGHT_IR)
reg = SI1145_PARAM_ALSIR_ADC_GAIN;
else
reg = SI1145_PARAM_ALSVIS_ADC_GAIN;
break;
case IIO_TEMP:
*val = 28;
*val2 = 571429;
return IIO_VAL_INT_PLUS_MICRO;
case IIO_UVINDEX:
*val = 0;
*val2 = 10000;
return IIO_VAL_INT_PLUS_MICRO;
default:
return -EINVAL;
}
ret = si1145_param_query(data, reg);
if (ret < 0)
return ret;
*val = si1145_scale_from_adcgain(ret & 0x07);
return IIO_VAL_INT;
case IIO_CHAN_INFO_OFFSET:
switch (chan->type) {
case IIO_TEMP:
/*
* -ADC offset - ADC counts @ 25°C -
* 35 * ADC counts / °C
*/
*val = -256 - 11136 + 25 * 35;
return IIO_VAL_INT;
default:
/*
* All ADC measurements have are by default offset
* by -256
* See AN498 5.6.3
*/
ret = si1145_param_query(data, SI1145_PARAM_ADC_OFFSET);
if (ret < 0)
return ret;
*val = -si1145_uncompress(ret);
return IIO_VAL_INT;
}
case IIO_CHAN_INFO_SAMP_FREQ:
return si1145_read_samp_freq(data, val, val2);
default:
return -EINVAL;
}
}
static int si1145_write_raw(struct iio_dev *indio_dev,
struct iio_chan_spec const *chan,
int val, int val2, long mask)
{
struct si1145_data *data = iio_priv(indio_dev);
u8 reg1, reg2, shift;
int ret;
switch (mask) {
case IIO_CHAN_INFO_SCALE:
switch (chan->type) {
case IIO_PROXIMITY:
val = si1145_proximity_adcgain_from_scale(val, val2);
if (val < 0)
return val;
reg1 = SI1145_PARAM_PS_ADC_GAIN;
reg2 = SI1145_PARAM_PS_ADC_COUNTER;
break;
case IIO_INTENSITY:
val = si1145_intensity_adcgain_from_scale(val, val2);
if (val < 0)
return val;
if (chan->channel2 == IIO_MOD_LIGHT_IR) {
reg1 = SI1145_PARAM_ALSIR_ADC_GAIN;
reg2 = SI1145_PARAM_ALSIR_ADC_COUNTER;
} else {
reg1 = SI1145_PARAM_ALSVIS_ADC_GAIN;
reg2 = SI1145_PARAM_ALSVIS_ADC_COUNTER;
}
break;
default:
return -EINVAL;
}
ret = iio_device_claim_direct_mode(indio_dev);
if (ret)
return ret;
ret = si1145_param_set(data, reg1, val);
if (ret < 0) {
iio_device_release_direct_mode(indio_dev);
return ret;
}
/* Set recovery period to one's complement of gain */
ret = si1145_param_set(data, reg2, (~val & 0x07) << 4);
iio_device_release_direct_mode(indio_dev);
return ret;
case IIO_CHAN_INFO_RAW:
if (chan->type != IIO_CURRENT)
return -EINVAL;
if (val < 0 || val > 15 || val2 != 0)
return -EINVAL;
reg1 = SI1145_PS_LED_REG(chan->channel);
shift = SI1145_PS_LED_SHIFT(chan->channel);
ret = iio_device_claim_direct_mode(indio_dev);
if (ret)
return ret;
ret = i2c_smbus_read_byte_data(data->client, reg1);
if (ret < 0) {
iio_device_release_direct_mode(indio_dev);
return ret;
}
ret = i2c_smbus_write_byte_data(data->client, reg1,
(ret & ~(0x0f << shift)) |
((val & 0x0f) << shift));
iio_device_release_direct_mode(indio_dev);
return ret;
case IIO_CHAN_INFO_SAMP_FREQ:
return si1145_store_samp_freq(data, val);
default:
return -EINVAL;
}
}
#define SI1145_ST { \
.sign = 'u', \
.realbits = 16, \
.storagebits = 16, \
.endianness = IIO_LE, \
}
#define SI1145_INTENSITY_CHANNEL(_si) { \
.type = IIO_INTENSITY, \
.info_mask_separate = BIT(IIO_CHAN_INFO_RAW) | \
BIT(IIO_CHAN_INFO_OFFSET) | \
BIT(IIO_CHAN_INFO_SCALE), \
.info_mask_shared_by_all = BIT(IIO_CHAN_INFO_SAMP_FREQ), \
.scan_type = SI1145_ST, \
.scan_index = _si, \
.address = SI1145_REG_ALSVIS_DATA, \
}
#define SI1145_INTENSITY_IR_CHANNEL(_si) { \
.type = IIO_INTENSITY, \
.info_mask_separate = BIT(IIO_CHAN_INFO_RAW) | \
BIT(IIO_CHAN_INFO_OFFSET) | \
BIT(IIO_CHAN_INFO_SCALE), \
.info_mask_shared_by_all = BIT(IIO_CHAN_INFO_SAMP_FREQ), \
.modified = 1, \
.channel2 = IIO_MOD_LIGHT_IR, \
.scan_type = SI1145_ST, \
.scan_index = _si, \
.address = SI1145_REG_ALSIR_DATA, \
}
#define SI1145_TEMP_CHANNEL(_si) { \
.type = IIO_TEMP, \
.info_mask_separate = BIT(IIO_CHAN_INFO_RAW) | \
BIT(IIO_CHAN_INFO_OFFSET) | \
BIT(IIO_CHAN_INFO_SCALE), \
.info_mask_shared_by_all = BIT(IIO_CHAN_INFO_SAMP_FREQ), \
.scan_type = SI1145_ST, \
.scan_index = _si, \
.address = SI1145_REG_AUX_DATA, \
}
#define SI1145_UV_CHANNEL(_si) { \
.type = IIO_UVINDEX, \
.info_mask_separate = BIT(IIO_CHAN_INFO_RAW) | \
BIT(IIO_CHAN_INFO_SCALE), \
.info_mask_shared_by_all = BIT(IIO_CHAN_INFO_SAMP_FREQ), \
.scan_type = SI1145_ST, \
.scan_index = _si, \
.address = SI1145_REG_AUX_DATA, \
}
#define SI1145_PROXIMITY_CHANNEL(_si, _ch) { \
.type = IIO_PROXIMITY, \
.indexed = 1, \
.channel = _ch, \
.info_mask_separate = BIT(IIO_CHAN_INFO_RAW), \
.info_mask_shared_by_type = BIT(IIO_CHAN_INFO_SCALE) | \
BIT(IIO_CHAN_INFO_OFFSET), \
.info_mask_shared_by_all = BIT(IIO_CHAN_INFO_SAMP_FREQ), \
.scan_type = SI1145_ST, \
.scan_index = _si, \
.address = SI1145_REG_PS1_DATA + _ch * 2, \
}
#define SI1145_VOLTAGE_CHANNEL(_si) { \
.type = IIO_VOLTAGE, \
.info_mask_separate = BIT(IIO_CHAN_INFO_RAW), \
.info_mask_shared_by_all = BIT(IIO_CHAN_INFO_SAMP_FREQ), \
.scan_type = SI1145_ST, \
.scan_index = _si, \
.address = SI1145_REG_AUX_DATA, \
}
#define SI1145_CURRENT_CHANNEL(_ch) { \
.type = IIO_CURRENT, \
.indexed = 1, \
.channel = _ch, \
.output = 1, \
.scan_index = -1, \
.info_mask_separate = BIT(IIO_CHAN_INFO_RAW), \
}
static const struct iio_chan_spec si1132_channels[] = {
SI1145_INTENSITY_CHANNEL(0),
SI1145_INTENSITY_IR_CHANNEL(1),
SI1145_TEMP_CHANNEL(2),
SI1145_VOLTAGE_CHANNEL(3),
SI1145_UV_CHANNEL(4),
IIO_CHAN_SOFT_TIMESTAMP(6),
};
static const struct iio_chan_spec si1141_channels[] = {
SI1145_INTENSITY_CHANNEL(0),
SI1145_INTENSITY_IR_CHANNEL(1),
SI1145_PROXIMITY_CHANNEL(2, 0),
SI1145_TEMP_CHANNEL(3),
SI1145_VOLTAGE_CHANNEL(4),
IIO_CHAN_SOFT_TIMESTAMP(5),
SI1145_CURRENT_CHANNEL(0),
};
static const struct iio_chan_spec si1142_channels[] = {
SI1145_INTENSITY_CHANNEL(0),
SI1145_INTENSITY_IR_CHANNEL(1),
SI1145_PROXIMITY_CHANNEL(2, 0),
SI1145_PROXIMITY_CHANNEL(3, 1),
SI1145_TEMP_CHANNEL(4),
SI1145_VOLTAGE_CHANNEL(5),
IIO_CHAN_SOFT_TIMESTAMP(6),
SI1145_CURRENT_CHANNEL(0),
SI1145_CURRENT_CHANNEL(1),
};
static const struct iio_chan_spec si1143_channels[] = {
SI1145_INTENSITY_CHANNEL(0),
SI1145_INTENSITY_IR_CHANNEL(1),
SI1145_PROXIMITY_CHANNEL(2, 0),
SI1145_PROXIMITY_CHANNEL(3, 1),
SI1145_PROXIMITY_CHANNEL(4, 2),
SI1145_TEMP_CHANNEL(5),
SI1145_VOLTAGE_CHANNEL(6),
IIO_CHAN_SOFT_TIMESTAMP(7),
SI1145_CURRENT_CHANNEL(0),
SI1145_CURRENT_CHANNEL(1),
SI1145_CURRENT_CHANNEL(2),
};
static const struct iio_chan_spec si1145_channels[] = {
SI1145_INTENSITY_CHANNEL(0),
SI1145_INTENSITY_IR_CHANNEL(1),
SI1145_PROXIMITY_CHANNEL(2, 0),
SI1145_TEMP_CHANNEL(3),
SI1145_VOLTAGE_CHANNEL(4),
SI1145_UV_CHANNEL(5),
IIO_CHAN_SOFT_TIMESTAMP(6),
SI1145_CURRENT_CHANNEL(0),
};
static const struct iio_chan_spec si1146_channels[] = {
SI1145_INTENSITY_CHANNEL(0),
SI1145_INTENSITY_IR_CHANNEL(1),
SI1145_TEMP_CHANNEL(2),
SI1145_VOLTAGE_CHANNEL(3),
SI1145_UV_CHANNEL(4),
SI1145_PROXIMITY_CHANNEL(5, 0),
SI1145_PROXIMITY_CHANNEL(6, 1),
IIO_CHAN_SOFT_TIMESTAMP(7),
SI1145_CURRENT_CHANNEL(0),
SI1145_CURRENT_CHANNEL(1),
};
static const struct iio_chan_spec si1147_channels[] = {
SI1145_INTENSITY_CHANNEL(0),
SI1145_INTENSITY_IR_CHANNEL(1),
SI1145_PROXIMITY_CHANNEL(2, 0),
SI1145_PROXIMITY_CHANNEL(3, 1),
SI1145_PROXIMITY_CHANNEL(4, 2),
SI1145_TEMP_CHANNEL(5),
SI1145_VOLTAGE_CHANNEL(6),
SI1145_UV_CHANNEL(7),
IIO_CHAN_SOFT_TIMESTAMP(8),
SI1145_CURRENT_CHANNEL(0),
SI1145_CURRENT_CHANNEL(1),
SI1145_CURRENT_CHANNEL(2),
};
static struct attribute *si1132_attributes[] = {
&iio_const_attr_in_intensity_scale_available.dev_attr.attr,
&iio_const_attr_in_intensity_ir_scale_available.dev_attr.attr,
NULL,
};
static struct attribute *si114x_attributes[] = {
&iio_const_attr_in_intensity_scale_available.dev_attr.attr,
&iio_const_attr_in_intensity_ir_scale_available.dev_attr.attr,
&iio_const_attr_in_proximity_scale_available.dev_attr.attr,
NULL,
};
static const struct attribute_group si1132_attribute_group = {
.attrs = si1132_attributes,
};
static const struct attribute_group si114x_attribute_group = {
.attrs = si114x_attributes,
};
static const struct iio_info si1132_info = {
.read_raw = si1145_read_raw,
.write_raw = si1145_write_raw,
.driver_module = THIS_MODULE,
.attrs = &si1132_attribute_group,
};
static const struct iio_info si114x_info = {
.read_raw = si1145_read_raw,
.write_raw = si1145_write_raw,
.driver_module = THIS_MODULE,
.attrs = &si114x_attribute_group,
};
#define SI1145_PART(id, iio_info, chans, leds, uncompressed_meas_rate) \
{id, iio_info, chans, ARRAY_SIZE(chans), leds, uncompressed_meas_rate}
static const struct si1145_part_info si1145_part_info[] = {
[SI1132] = SI1145_PART(0x32, &si1132_info, si1132_channels, 0, true),
[SI1141] = SI1145_PART(0x41, &si114x_info, si1141_channels, 1, false),
[SI1142] = SI1145_PART(0x42, &si114x_info, si1142_channels, 2, false),
[SI1143] = SI1145_PART(0x43, &si114x_info, si1143_channels, 3, false),
[SI1145] = SI1145_PART(0x45, &si114x_info, si1145_channels, 1, true),
[SI1146] = SI1145_PART(0x46, &si114x_info, si1146_channels, 2, true),
[SI1147] = SI1145_PART(0x47, &si114x_info, si1147_channels, 3, true),
};
static int si1145_initialize(struct si1145_data *data)
{
struct i2c_client *client = data->client;
int ret;
ret = i2c_smbus_write_byte_data(client, SI1145_REG_COMMAND,
SI1145_CMD_RESET);
if (ret < 0)
return ret;
msleep(SI1145_COMMAND_TIMEOUT_MS);
/* Hardware key, magic value */
ret = i2c_smbus_write_byte_data(client, SI1145_REG_HW_KEY, 0x17);
if (ret < 0)
return ret;
msleep(SI1145_COMMAND_TIMEOUT_MS);
/* Turn off autonomous mode */
ret = si1145_set_meas_rate(data, 0);
if (ret < 0)
return ret;
/* Initialize sampling freq to 10 Hz */
ret = si1145_store_samp_freq(data, 10);
if (ret < 0)
return ret;
/* Set LED currents to 45 mA; have 4 bits, see Table 2 in datasheet */
switch (data->part_info->num_leds) {
case 3:
ret = i2c_smbus_write_byte_data(client,
SI1145_REG_PS_LED3,
SI1145_LED_CURRENT_45mA);
if (ret < 0)
return ret;
/* fallthrough */
case 2:
ret = i2c_smbus_write_byte_data(client,
SI1145_REG_PS_LED21,
(SI1145_LED_CURRENT_45mA << 4) |
SI1145_LED_CURRENT_45mA);
break;
case 1:
ret = i2c_smbus_write_byte_data(client,
SI1145_REG_PS_LED21,
SI1145_LED_CURRENT_45mA);
break;
default:
ret = 0;
break;
}
if (ret < 0)
return ret;
/* Set normal proximity measurement mode */
ret = si1145_param_set(data, SI1145_PARAM_PS_ADC_MISC,
SI1145_PS_ADC_MODE_NORMAL);
if (ret < 0)
return ret;
ret = si1145_param_set(data, SI1145_PARAM_PS_ADC_GAIN, 0x01);
if (ret < 0)
return ret;
/* ADC_COUNTER should be one complement of ADC_GAIN */
ret = si1145_param_set(data, SI1145_PARAM_PS_ADC_COUNTER, 0x06 << 4);
if (ret < 0)
return ret;
/* Set ALS visible measurement mode */
ret = si1145_param_set(data, SI1145_PARAM_ALSVIS_ADC_MISC,
SI1145_ADC_MISC_RANGE);
if (ret < 0)
return ret;
ret = si1145_param_set(data, SI1145_PARAM_ALSVIS_ADC_GAIN, 0x03);
if (ret < 0)
return ret;
ret = si1145_param_set(data, SI1145_PARAM_ALSVIS_ADC_COUNTER,
0x04 << 4);
if (ret < 0)
return ret;
/* Set ALS IR measurement mode */
ret = si1145_param_set(data, SI1145_PARAM_ALSIR_ADC_MISC,
SI1145_ADC_MISC_RANGE);
if (ret < 0)
return ret;
ret = si1145_param_set(data, SI1145_PARAM_ALSIR_ADC_GAIN, 0x01);
if (ret < 0)
return ret;
ret = si1145_param_set(data, SI1145_PARAM_ALSIR_ADC_COUNTER,
0x06 << 4);
if (ret < 0)
return ret;
/*
* Initialize UCOEF to default values in datasheet
* These registers are normally zero on reset
*/
if (data->part_info == &si1145_part_info[SI1132] ||
data->part_info == &si1145_part_info[SI1145] ||
data->part_info == &si1145_part_info[SI1146] ||
data->part_info == &si1145_part_info[SI1147]) {
ret = i2c_smbus_write_byte_data(data->client,
SI1145_REG_UCOEF1,
SI1145_UCOEF1_DEFAULT);
if (ret < 0)
return ret;
ret = i2c_smbus_write_byte_data(data->client,
SI1145_REG_UCOEF2, SI1145_UCOEF2_DEFAULT);
if (ret < 0)
return ret;
ret = i2c_smbus_write_byte_data(data->client,
SI1145_REG_UCOEF3, SI1145_UCOEF3_DEFAULT);
if (ret < 0)
return ret;
ret = i2c_smbus_write_byte_data(data->client,
SI1145_REG_UCOEF4, SI1145_UCOEF4_DEFAULT);
if (ret < 0)
return ret;
}
return 0;
}
/*
* Program the channels we want to measure with CMD_PSALS_AUTO. No need for
* _postdisable as we stop with CMD_PSALS_PAUSE; single measurement (direct)
* mode reprograms the channels list anyway...
*/
static int si1145_buffer_preenable(struct iio_dev *indio_dev)
{
struct si1145_data *data = iio_priv(indio_dev);
int ret;
mutex_lock(&data->lock);
ret = si1145_set_chlist(indio_dev, *indio_dev->active_scan_mask);
mutex_unlock(&data->lock);
return ret;
}
static bool si1145_validate_scan_mask(struct iio_dev *indio_dev,
const unsigned long *scan_mask)
{
struct si1145_data *data = iio_priv(indio_dev);
unsigned int count = 0;
int i;
/* Check that at most one AUX channel is enabled */
for_each_set_bit(i, scan_mask, data->part_info->num_channels) {
if (indio_dev->channels[i].address == SI1145_REG_AUX_DATA)
count++;
}
return count <= 1;
}
static const struct iio_buffer_setup_ops si1145_buffer_setup_ops = {
.preenable = si1145_buffer_preenable,
.postenable = iio_triggered_buffer_postenable,
.predisable = iio_triggered_buffer_predisable,
.validate_scan_mask = si1145_validate_scan_mask,
};
/**
* si1145_trigger_set_state() - Set trigger state
*
* When not using triggers interrupts are disabled and measurement rate is
* set to zero in order to minimize power consumption.
*/
static int si1145_trigger_set_state(struct iio_trigger *trig, bool state)
{
struct iio_dev *indio_dev = iio_trigger_get_drvdata(trig);
struct si1145_data *data = iio_priv(indio_dev);
int err = 0, ret;
mutex_lock(&data->lock);
if (state) {
data->autonomous = true;
err = i2c_smbus_write_byte_data(data->client,
SI1145_REG_INT_CFG, SI1145_INT_CFG_OE);
if (err < 0)
goto disable;
err = i2c_smbus_write_byte_data(data->client,
SI1145_REG_IRQ_ENABLE, SI1145_MASK_ALL_IE);
if (err < 0)
goto disable;
err = si1145_set_meas_rate(data, data->meas_rate);
if (err < 0)
goto disable;
err = si1145_command(data, SI1145_CMD_PSALS_AUTO);
if (err < 0)
goto disable;
} else {
disable:
/* Disable as much as possible skipping errors */
ret = si1145_command(data, SI1145_CMD_PSALS_PAUSE);
if (ret < 0 && !err)
err = ret;
ret = si1145_set_meas_rate(data, 0);
if (ret < 0 && !err)
err = ret;
ret = i2c_smbus_write_byte_data(data->client,
SI1145_REG_IRQ_ENABLE, 0);
if (ret < 0 && !err)
err = ret;
ret = i2c_smbus_write_byte_data(data->client,
SI1145_REG_INT_CFG, 0);
if (ret < 0 && !err)
err = ret;
data->autonomous = false;
}
mutex_unlock(&data->lock);
return err;
}
static const struct iio_trigger_ops si1145_trigger_ops = {
.owner = THIS_MODULE,
.set_trigger_state = si1145_trigger_set_state,
};
static int si1145_probe_trigger(struct iio_dev *indio_dev)
{
struct si1145_data *data = iio_priv(indio_dev);
struct i2c_client *client = data->client;
struct iio_trigger *trig;
int ret;
trig = devm_iio_trigger_alloc(&client->dev,
"%s-dev%d", indio_dev->name, indio_dev->id);
if (!trig)
return -ENOMEM;
trig->dev.parent = &client->dev;
trig->ops = &si1145_trigger_ops;
iio_trigger_set_drvdata(trig, indio_dev);
ret = devm_request_irq(&client->dev, client->irq,
iio_trigger_generic_data_rdy_poll,
IRQF_TRIGGER_FALLING,
"si1145_irq",
trig);
if (ret < 0) {
dev_err(&client->dev, "irq request failed\n");
return ret;
}
ret = iio_trigger_register(trig);
if (ret)
return ret;
data->trig = trig;
indio_dev->trig = iio_trigger_get(data->trig);
return 0;
}
static void si1145_remove_trigger(struct iio_dev *indio_dev)
{
struct si1145_data *data = iio_priv(indio_dev);
if (data->trig) {
iio_trigger_unregister(data->trig);
data->trig = NULL;
}
}
static int si1145_probe(struct i2c_client *client,
const struct i2c_device_id *id)
{
struct si1145_data *data;
struct iio_dev *indio_dev;
u8 part_id, rev_id, seq_id;
int ret;
indio_dev = devm_iio_device_alloc(&client->dev, sizeof(*data));
if (!indio_dev)
return -ENOMEM;
data = iio_priv(indio_dev);
i2c_set_clientdata(client, indio_dev);
data->client = client;
data->part_info = &si1145_part_info[id->driver_data];
part_id = ret = i2c_smbus_read_byte_data(data->client,
SI1145_REG_PART_ID);
if (ret < 0)
return ret;
rev_id = ret = i2c_smbus_read_byte_data(data->client,
SI1145_REG_REV_ID);
if (ret < 0)
return ret;
seq_id = ret = i2c_smbus_read_byte_data(data->client,
SI1145_REG_SEQ_ID);
if (ret < 0)
return ret;
dev_info(&client->dev, "device ID part %#02hhx rev %#02hhx seq %#02hhx\n",
part_id, rev_id, seq_id);
if (part_id != data->part_info->part) {
dev_err(&client->dev, "part ID mismatch got %#02hhx, expected %#02x\n",
part_id, data->part_info->part);
return -ENODEV;
}
indio_dev->dev.parent = &client->dev;
indio_dev->name = id->name;
indio_dev->channels = data->part_info->channels;
indio_dev->num_channels = data->part_info->num_channels;
indio_dev->info = data->part_info->iio_info;
indio_dev->modes = INDIO_DIRECT_MODE;
mutex_init(&data->lock);
mutex_init(&data->cmdlock);
ret = si1145_initialize(data);
if (ret < 0)
return ret;
ret = iio_triggered_buffer_setup(indio_dev, NULL,
si1145_trigger_handler, &si1145_buffer_setup_ops);
if (ret < 0)
return ret;
if (client->irq) {
ret = si1145_probe_trigger(indio_dev);
if (ret < 0)
goto error_free_buffer;
} else {
dev_info(&client->dev, "no irq, using polling\n");
}
ret = iio_device_register(indio_dev);
if (ret < 0)
goto error_free_trigger;
return 0;
error_free_trigger:
si1145_remove_trigger(indio_dev);
error_free_buffer:
iio_triggered_buffer_cleanup(indio_dev);
return ret;
}
static const struct i2c_device_id si1145_ids[] = {
{ "si1132", SI1132 },
{ "si1141", SI1141 },
{ "si1142", SI1142 },
{ "si1143", SI1143 },
{ "si1145", SI1145 },
{ "si1146", SI1146 },
{ "si1147", SI1147 },
{ }
};
MODULE_DEVICE_TABLE(i2c, si1145_ids);
static int si1145_remove(struct i2c_client *client)
{
struct iio_dev *indio_dev = i2c_get_clientdata(client);
iio_device_unregister(indio_dev);
si1145_remove_trigger(indio_dev);
iio_triggered_buffer_cleanup(indio_dev);
return 0;
}
static struct i2c_driver si1145_driver = {
.driver = {
.name = "si1145",
},
.probe = si1145_probe,
.remove = si1145_remove,
.id_table = si1145_ids,
};
module_i2c_driver(si1145_driver);
MODULE_AUTHOR("Peter Meerwald-Stadler <pmeerw@pmeerw.net>");
MODULE_DESCRIPTION("Silabs SI1132 and SI1141/2/3/5/6/7 proximity, ambient light and UV index sensor driver");
MODULE_LICENSE("GPL");
drivers/iio/pressure/Kconfig
View file @ 888a87b5
......@@ -187,4 +187,26 @@ config HP206C
This driver can also be built as a module. If so, the module will
be called hp206c.
config ZPA2326
tristate "Murata ZPA2326 pressure sensor driver"
select IIO_BUFFER
select IIO_TRIGGERED_BUFFER
select REGMAP
select ZPA2326_I2C if I2C
select ZPA2326_SPI if SPI_MASTER
help
Say Y here to build support for the Murata ZPA2326 pressure and
temperature sensor.
To compile this driver as a module, choose M here: the module will
be called zpa2326.
config ZPA2326_I2C
tristate
select REGMAP_I2C
config ZPA2326_SPI
tristate
select REGMAP_SPI
endmenu
drivers/iio/pressure/Makefile
View file @ 888a87b5
......@@ -22,6 +22,9 @@ st_pressure-y := st_pressure_core.o
st_pressure-$(CONFIG_IIO_BUFFER) += st_pressure_buffer.o
obj-$(CONFIG_T5403) += t5403.o
obj-$(CONFIG_HP206C) += hp206c.o
obj-$(CONFIG_ZPA2326) += zpa2326.o
obj-$(CONFIG_ZPA2326_I2C) += zpa2326_i2c.o
obj-$(CONFIG_ZPA2326_SPI) += zpa2326_spi.o
obj-$(CONFIG_IIO_ST_PRESS_I2C) += st_pressure_i2c.o
obj-$(CONFIG_IIO_ST_PRESS_SPI) += st_pressure_spi.o
drivers/iio/pressure/zpa2326.c 0 → 100644
View file @ 888a87b5
/*
* Murata ZPA2326 pressure and temperature sensor IIO driver
*
* Copyright (c) 2016 Parrot S.A.
*
* Author: Gregor Boirie <gregor.boirie@parrot.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.
*/
/**
* DOC: ZPA2326 theory of operations
*
* This driver supports %INDIO_DIRECT_MODE and %INDIO_BUFFER_TRIGGERED IIO
* modes.
* A internal hardware trigger is also implemented to dispatch registered IIO
* trigger consumers upon "sample ready" interrupts.
*
* ZPA2326 hardware supports 2 sampling mode: one shot and continuous.
*
* A complete one shot sampling cycle gets device out of low power mode,
* performs pressure and temperature measurements, then automatically switches
* back to low power mode. It is meant for on demand sampling with optimal power
* saving at the cost of lower sampling rate and higher software overhead.
* This is a natural candidate for IIO read_raw hook implementation
* (%INDIO_DIRECT_MODE). It is also used for triggered buffering support to
* ensure explicit synchronization with external trigger events
* (%INDIO_BUFFER_TRIGGERED).
*
* The continuous mode works according to a periodic hardware measurement
* process continuously pushing samples into an internal hardware FIFO (for
* pressure samples only). Measurement cycle completion may be signaled by a
* "sample ready" interrupt.
* Typical software sequence of operations :
* - get device out of low power mode,
* - setup hardware sampling period,
* - at end of period, upon data ready interrupt: pop pressure samples out of
* hardware FIFO and fetch temperature sample
* - when no longer needed, stop sampling process by putting device into
* low power mode.
* This mode is used to implement %INDIO_BUFFER_TRIGGERED mode if device tree
* declares a valid interrupt line. In this case, the internal hardware trigger
* drives acquisition.
*
* Note that hardware sampling frequency is taken into account only when
* internal hardware trigger is attached as the highest sampling rate seems to
* be the most energy efficient.
*
* TODO:
* preset pressure threshold crossing / IIO events ;
* differential pressure sampling ;
* hardware samples averaging.
*/
#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/delay.h>
#include <linux/interrupt.h>
#include <linux/regulator/consumer.h>
#include <linux/pm_runtime.h>
#include <linux/regmap.h>
#include <linux/iio/iio.h>
#include <linux/iio/sysfs.h>
#include <linux/iio/buffer.h>
#include <linux/iio/trigger.h>
#include <linux/iio/trigger_consumer.h>
#include <linux/iio/triggered_buffer.h>
#include "zpa2326.h"
/* 200 ms should be enough for the longest conversion time in one-shot mode. */
#define ZPA2326_CONVERSION_JIFFIES (HZ / 5)
/* There should be a 1 ms delay (Tpup) after getting out of reset. */
#define ZPA2326_TPUP_USEC_MIN (1000)
#define ZPA2326_TPUP_USEC_MAX (2000)
/**
* struct zpa2326_frequency - Hardware sampling frequency descriptor
* @hz : Frequency in Hertz.
* @odr: Output Data Rate word as expected by %ZPA2326_CTRL_REG3_REG.
*/
struct zpa2326_frequency {
int hz;
u16 odr;
};
/*
* Keep these in strict ascending order: last array entry is expected to
* correspond to the highest sampling frequency.
*/
static const struct zpa2326_frequency zpa2326_sampling_frequencies[] = {
{ .hz = 1, .odr = 1 << ZPA2326_CTRL_REG3_ODR_SHIFT },
{ .hz = 5, .odr = 5 << ZPA2326_CTRL_REG3_ODR_SHIFT },
{ .hz = 11, .odr = 6 << ZPA2326_CTRL_REG3_ODR_SHIFT },
{ .hz = 23, .odr = 7 << ZPA2326_CTRL_REG3_ODR_SHIFT },
};
/* Return the highest hardware sampling frequency available. */
static const struct zpa2326_frequency *zpa2326_highest_frequency(void)
{
return &zpa2326_sampling_frequencies[
ARRAY_SIZE(zpa2326_sampling_frequencies) - 1];
}
/**
* struct zpa_private - Per-device internal private state
* @timestamp: Buffered samples ready datum.
* @regmap: Underlying I2C / SPI bus adapter used to abstract slave register
* accesses.
* @result: Allows sampling logic to get completion status of operations
* that interrupt handlers perform asynchronously.
* @data_ready: Interrupt handler uses this to wake user context up at sampling
* operation completion.
* @trigger: Optional hardware / interrupt driven trigger used to notify
* external devices a new sample is ready.
* @waken: Flag indicating whether or not device has just been powered on.
* @irq: Optional interrupt line: negative or zero if not declared into
* DT, in which case sampling logic keeps polling status register
* to detect completion.
* @frequency: Current hardware sampling frequency.
* @vref: Power / voltage reference.
* @vdd: Power supply.
*/
struct zpa2326_private {
s64 timestamp;
struct regmap *regmap;
int result;
struct completion data_ready;
struct iio_trigger *trigger;
bool waken;
int irq;
const struct zpa2326_frequency *frequency;
struct regulator *vref;
struct regulator *vdd;
};
#define zpa2326_err(_idev, _format, _arg...) \
dev_err(_idev->dev.parent, _format, ##_arg)
#define zpa2326_warn(_idev, _format, _arg...) \
dev_warn(_idev->dev.parent, _format, ##_arg)
#ifdef DEBUG
#define zpa2326_dbg(_idev, _format, _arg...) \
dev_dbg(_idev->dev.parent, _format, ##_arg)
#else
#define zpa2326_dbg(_idev, _format, _arg...)
#endif
bool zpa2326_isreg_writeable(struct device *dev, unsigned int reg)
{
switch (reg) {
case ZPA2326_REF_P_XL_REG:
case ZPA2326_REF_P_L_REG:
case ZPA2326_REF_P_H_REG:
case ZPA2326_RES_CONF_REG:
case ZPA2326_CTRL_REG0_REG:
case ZPA2326_CTRL_REG1_REG:
case ZPA2326_CTRL_REG2_REG:
case ZPA2326_CTRL_REG3_REG:
case ZPA2326_THS_P_LOW_REG:
case ZPA2326_THS_P_HIGH_REG:
return true;
default:
return false;
}
}
EXPORT_SYMBOL_GPL(zpa2326_isreg_writeable);
bool zpa2326_isreg_readable(struct device *dev, unsigned int reg)
{
switch (reg) {
case ZPA2326_REF_P_XL_REG:
case ZPA2326_REF_P_L_REG:
case ZPA2326_REF_P_H_REG:
case ZPA2326_DEVICE_ID_REG:
case ZPA2326_RES_CONF_REG:
case ZPA2326_CTRL_REG0_REG:
case ZPA2326_CTRL_REG1_REG:
case ZPA2326_CTRL_REG2_REG:
case ZPA2326_CTRL_REG3_REG:
case ZPA2326_INT_SOURCE_REG:
case ZPA2326_THS_P_LOW_REG:
case ZPA2326_THS_P_HIGH_REG:
case ZPA2326_STATUS_REG:
case ZPA2326_PRESS_OUT_XL_REG:
case ZPA2326_PRESS_OUT_L_REG:
case ZPA2326_PRESS_OUT_H_REG:
case ZPA2326_TEMP_OUT_L_REG:
case ZPA2326_TEMP_OUT_H_REG:
return true;
default:
return false;
}
}
EXPORT_SYMBOL_GPL(zpa2326_isreg_readable);
bool zpa2326_isreg_precious(struct device *dev, unsigned int reg)
{
switch (reg) {
case ZPA2326_INT_SOURCE_REG:
case ZPA2326_PRESS_OUT_H_REG:
return true;
default:
return false;
}
}
EXPORT_SYMBOL_GPL(zpa2326_isreg_precious);
/**
* zpa2326_enable_device() - Enable device, i.e. get out of low power mode.
* @indio_dev: The IIO device associated with the hardware to enable.
*
* Required to access complete register space and to perform any sampling
* or control operations.
*
* Return: Zero when successful, a negative error code otherwise.
*/
static int zpa2326_enable_device(const struct iio_dev *indio_dev)
{
int err;
err = regmap_write(((struct zpa2326_private *)
iio_priv(indio_dev))->regmap,
ZPA2326_CTRL_REG0_REG, ZPA2326_CTRL_REG0_ENABLE);
if (err) {
zpa2326_err(indio_dev, "failed to enable device (%d)", err);
return err;
}
zpa2326_dbg(indio_dev, "enabled");
return 0;
}
/**
* zpa2326_sleep() - Disable device, i.e. switch to low power mode.
* @indio_dev: The IIO device associated with the hardware to disable.
*
* Only %ZPA2326_DEVICE_ID_REG and %ZPA2326_CTRL_REG0_REG registers may be
* accessed once device is in the disabled state.
*
* Return: Zero when successful, a negative error code otherwise.
*/
static int zpa2326_sleep(const struct iio_dev *indio_dev)
{
int err;
err = regmap_write(((struct zpa2326_private *)
iio_priv(indio_dev))->regmap,
ZPA2326_CTRL_REG0_REG, 0);
if (err) {
zpa2326_err(indio_dev, "failed to sleep (%d)", err);
return err;
}
zpa2326_dbg(indio_dev, "sleeping");
return 0;
}
/**
* zpa2326_reset_device() - Reset device to default hardware state.
* @indio_dev: The IIO device associated with the hardware to reset.
*
* Disable sampling and empty hardware FIFO.
* Device must be enabled before reset, i.e. not in low power mode.
*
* Return: Zero when successful, a negative error code otherwise.
*/
static int zpa2326_reset_device(const struct iio_dev *indio_dev)
{
int err;
err = regmap_write(((struct zpa2326_private *)
iio_priv(indio_dev))->regmap,
ZPA2326_CTRL_REG2_REG, ZPA2326_CTRL_REG2_SWRESET);
if (err) {
zpa2326_err(indio_dev, "failed to reset device (%d)", err);
return err;
}
usleep_range(ZPA2326_TPUP_USEC_MIN, ZPA2326_TPUP_USEC_MAX);
zpa2326_dbg(indio_dev, "reset");
return 0;
}
/**
* zpa2326_start_oneshot() - Start a single sampling cycle, i.e. in one shot
* mode.
* @indio_dev: The IIO device associated with the sampling hardware.
*
* Device must have been previously enabled and configured for one shot mode.
* Device will be switched back to low power mode at end of cycle.
*
* Return: Zero when successful, a negative error code otherwise.
*/
static int zpa2326_start_oneshot(const struct iio_dev *indio_dev)
{
int err;
err = regmap_write(((struct zpa2326_private *)
iio_priv(indio_dev))->regmap,
ZPA2326_CTRL_REG0_REG,
ZPA2326_CTRL_REG0_ENABLE |
ZPA2326_CTRL_REG0_ONE_SHOT);
if (err) {
zpa2326_err(indio_dev, "failed to start one shot cycle (%d)",
err);
return err;
}
zpa2326_dbg(indio_dev, "one shot cycle started");
return 0;
}
/**
* zpa2326_power_on() - Power on device to allow subsequent configuration.
* @indio_dev: The IIO device associated with the sampling hardware.
* @private: Internal private state related to @indio_dev.
*
* Sampling will be disabled, preventing strange things from happening in our
* back. Hardware FIFO content will be cleared.
* When successful, device will be left in the enabled state to allow further
* configuration.
*
* Return: Zero when successful, a negative error code otherwise.
*/
static int zpa2326_power_on(const struct iio_dev *indio_dev,
const struct zpa2326_private *private)
{
int err;
err = regulator_enable(private->vref);
if (err)
return err;
err = regulator_enable(private->vdd);
if (err)
goto vref;
zpa2326_dbg(indio_dev, "powered on");
err = zpa2326_enable_device(indio_dev);
if (err)
goto vdd;
err = zpa2326_reset_device(indio_dev);
if (err)
goto sleep;
return 0;
sleep:
zpa2326_sleep(indio_dev);
vdd:
regulator_disable(private->vdd);
vref:
regulator_disable(private->vref);
zpa2326_dbg(indio_dev, "powered off");
return err;
}
/**
* zpa2326_power_off() - Power off device, i.e. disable attached power
* regulators.
* @indio_dev: The IIO device associated with the sampling hardware.
* @private: Internal private state related to @indio_dev.
*
* Return: Zero when successful, a negative error code otherwise.
*/
static void zpa2326_power_off(const struct iio_dev *indio_dev,
const struct zpa2326_private *private)
{
regulator_disable(private->vdd);
regulator_disable(private->vref);
zpa2326_dbg(indio_dev, "powered off");
}
/**
* zpa2326_config_oneshot() - Setup device for one shot / on demand mode.
* @indio_dev: The IIO device associated with the sampling hardware.
* @irq: Optional interrupt line the hardware uses to notify new data
* samples are ready. Negative or zero values indicate no interrupts
* are available, meaning polling is required.
*
* Output Data Rate is configured for the highest possible rate so that
* conversion time and power consumption are reduced to a minimum.
* Note that hardware internal averaging machinery (not implemented in this
* driver) is not applicable in this mode.
*
* Device must have been previously enabled before calling
* zpa2326_config_oneshot().
*
* Return: Zero when successful, a negative error code otherwise.
*/
static int zpa2326_config_oneshot(const struct iio_dev *indio_dev,
int irq)
{
struct regmap *regs = ((struct zpa2326_private *)
iio_priv(indio_dev))->regmap;
const struct zpa2326_frequency *freq = zpa2326_highest_frequency();
int err;
/* Setup highest available Output Data Rate for one shot mode. */
err = regmap_write(regs, ZPA2326_CTRL_REG3_REG, freq->odr);
if (err)
return err;
if (irq > 0) {
/* Request interrupt when new sample is available. */
err = regmap_write(regs, ZPA2326_CTRL_REG1_REG,
(u8)~ZPA2326_CTRL_REG1_MASK_DATA_READY);
if (err) {
dev_err(indio_dev->dev.parent,
"failed to setup one shot mode (%d)", err);
return err;
}
}
zpa2326_dbg(indio_dev, "one shot mode setup @%dHz", freq->hz);
return 0;
}
/**
* zpa2326_clear_fifo() - Clear remaining entries in hardware FIFO.
* @indio_dev: The IIO device associated with the sampling hardware.
* @min_count: Number of samples present within hardware FIFO.
*
* @min_count argument is a hint corresponding to the known minimum number of
* samples currently living in the FIFO. This allows to reduce the number of bus
* accesses by skipping status register read operation as long as we know for
* sure there are still entries left.
*
* Return: Zero when successful, a negative error code otherwise.
*/
static int zpa2326_clear_fifo(const struct iio_dev *indio_dev,
unsigned int min_count)
{
struct regmap *regs = ((struct zpa2326_private *)
iio_priv(indio_dev))->regmap;
int err;
unsigned int val;
if (!min_count) {
/*
* No hint: read status register to determine whether FIFO is
* empty or not.
*/
err = regmap_read(regs, ZPA2326_STATUS_REG, &val);
if (err < 0)
goto err;
if (val & ZPA2326_STATUS_FIFO_E)
/* Fifo is empty: nothing to trash. */
return 0;
}
/* Clear FIFO. */
do {
/*
* A single fetch from pressure MSB register is enough to pop
* values out of FIFO.
*/
err = regmap_read(regs, ZPA2326_PRESS_OUT_H_REG, &val);
if (err < 0)
goto err;
if (min_count) {
/*
* We know for sure there are at least min_count entries
* left in FIFO. Skip status register read.
*/
min_count--;
continue;
}
err = regmap_read(regs, ZPA2326_STATUS_REG, &val);
if (err < 0)
goto err;
} while (!(val & ZPA2326_STATUS_FIFO_E));
zpa2326_dbg(indio_dev, "FIFO cleared");
return 0;
err:
zpa2326_err(indio_dev, "failed to clear FIFO (%d)", err);
return err;
}
/**
* zpa2326_dequeue_pressure() - Retrieve the most recent pressure sample from
* hardware FIFO.
* @indio_dev: The IIO device associated with the sampling hardware.
* @pressure: Sampled pressure output.
*
* Note that ZPA2326 hardware FIFO stores pressure samples only.
*
* Return: Zero when successful, a negative error code otherwise.
*/
static int zpa2326_dequeue_pressure(const struct iio_dev *indio_dev,
u32 *pressure)
{
struct regmap *regs = ((struct zpa2326_private *)
iio_priv(indio_dev))->regmap;
unsigned int val;
int err;
int cleared = -1;
err = regmap_read(regs, ZPA2326_STATUS_REG, &val);
if (err < 0)
return err;
*pressure = 0;
if (val & ZPA2326_STATUS_P_OR) {
/*
* Fifo overrun : first sample dequeued from FIFO is the
* newest.
*/
zpa2326_warn(indio_dev, "FIFO overflow");
err = regmap_bulk_read(regs, ZPA2326_PRESS_OUT_XL_REG, pressure,
3);
if (err)
return err;
#define ZPA2326_FIFO_DEPTH (16U)
/* Hardware FIFO may hold no more than 16 pressure samples. */
return zpa2326_clear_fifo(indio_dev, ZPA2326_FIFO_DEPTH - 1);
}
/*
* Fifo has not overflown : retrieve newest sample. We need to pop
* values out until FIFO is empty : last fetched pressure is the newest.
* In nominal cases, we should find a single queued sample only.
*/
do {
err = regmap_bulk_read(regs, ZPA2326_PRESS_OUT_XL_REG, pressure,
3);
if (err)
return err;
err = regmap_read(regs, ZPA2326_STATUS_REG, &val);
if (err < 0)
return err;
cleared++;
} while (!(val & ZPA2326_STATUS_FIFO_E));
if (cleared)
/*
* Samples were pushed by hardware during previous rounds but we
* didn't consume them fast enough: inform user.
*/
zpa2326_dbg(indio_dev, "cleared %d FIFO entries", cleared);
return 0;
}
/**
* zpa2326_fill_sample_buffer() - Enqueue new channel samples to IIO buffer.
* @indio_dev: The IIO device associated with the sampling hardware.
* @private: Internal private state related to @indio_dev.
*
* Return: Zero when successful, a negative error code otherwise.
*/
static int zpa2326_fill_sample_buffer(struct iio_dev *indio_dev,
const struct zpa2326_private *private)
{
struct {
u32 pressure;
u16 temperature;
u64 timestamp;
} sample;
int err;
if (test_bit(0, indio_dev->active_scan_mask)) {
/* Get current pressure from hardware FIFO. */
err = zpa2326_dequeue_pressure(indio_dev, &sample.pressure);
if (err) {
zpa2326_warn(indio_dev, "failed to fetch pressure (%d)",
err);
return err;
}
}
if (test_bit(1, indio_dev->active_scan_mask)) {
/* Get current temperature. */
err = regmap_bulk_read(private->regmap, ZPA2326_TEMP_OUT_L_REG,
&sample.temperature, 2);
if (err) {
zpa2326_warn(indio_dev,
"failed to fetch temperature (%d)", err);
return err;
}
}
/*
* Now push samples using timestamp stored either :
* - by hardware interrupt handler if interrupt is available: see
* zpa2326_handle_irq(),
* - or oneshot completion polling machinery : see
* zpa2326_trigger_handler().
*/
zpa2326_dbg(indio_dev, "filling raw samples buffer");
iio_push_to_buffers_with_timestamp(indio_dev, &sample,
private->timestamp);
return 0;
}
#ifdef CONFIG_PM
static int zpa2326_runtime_suspend(struct device *parent)
{
const struct iio_dev *indio_dev = dev_get_drvdata(parent);
if (pm_runtime_autosuspend_expiration(parent))
/* Userspace changed autosuspend delay. */
return -EAGAIN;
zpa2326_power_off(indio_dev, iio_priv(indio_dev));
return 0;
}
static int zpa2326_runtime_resume(struct device *parent)
{
const struct iio_dev *indio_dev = dev_get_drvdata(parent);
return zpa2326_power_on(indio_dev, iio_priv(indio_dev));
}
const struct dev_pm_ops zpa2326_pm_ops = {
SET_SYSTEM_SLEEP_PM_OPS(pm_runtime_force_suspend,
pm_runtime_force_resume)
SET_RUNTIME_PM_OPS(zpa2326_runtime_suspend, zpa2326_runtime_resume,
NULL)
};
EXPORT_SYMBOL_GPL(zpa2326_pm_ops);
/**
* zpa2326_resume() - Request the PM layer to power supply the device.
* @indio_dev: The IIO device associated with the sampling hardware.
*
* Return:
* < 0 - a negative error code meaning failure ;
* 0 - success, device has just been powered up ;
* 1 - success, device was already powered.
*/
static int zpa2326_resume(const struct iio_dev *indio_dev)
{
int err;
err = pm_runtime_get_sync(indio_dev->dev.parent);
if (err < 0)
return err;
if (err > 0) {
/*
* Device was already power supplied: get it out of low power
* mode and inform caller.
*/
zpa2326_enable_device(indio_dev);
return 1;
}
/* Inform caller device has just been brought back to life. */
return 0;
}
/**
* zpa2326_suspend() - Schedule a power down using autosuspend feature of PM
* layer.
* @indio_dev: The IIO device associated with the sampling hardware.
*
* Device is switched to low power mode at first to save power even when
* attached regulator is a "dummy" one.
*/
static void zpa2326_suspend(struct iio_dev *indio_dev)
{
struct device *parent = indio_dev->dev.parent;
zpa2326_sleep(indio_dev);
pm_runtime_mark_last_busy(parent);
pm_runtime_put_autosuspend(parent);
}
static void zpa2326_init_runtime(struct device *parent)
{
pm_runtime_get_noresume(parent);
pm_runtime_set_active(parent);
pm_runtime_enable(parent);
pm_runtime_set_autosuspend_delay(parent, 1000);
pm_runtime_use_autosuspend(parent);
pm_runtime_mark_last_busy(parent);
pm_runtime_put_autosuspend(parent);
}
static void zpa2326_fini_runtime(struct device *parent)
{
pm_runtime_disable(parent);
pm_runtime_set_suspended(parent);
}
#else /* !CONFIG_PM */
static int zpa2326_resume(const struct iio_dev *indio_dev)
{
zpa2326_enable_device(indio_dev);
return 0;
}
static void zpa2326_suspend(struct iio_dev *indio_dev)
{
zpa2326_sleep(indio_dev);
}
#define zpa2326_init_runtime(_parent)
#define zpa2326_fini_runtime(_parent)
#endif /* !CONFIG_PM */
/**
* zpa2326_handle_irq() - Process hardware interrupts.
* @irq: Interrupt line the hardware uses to notify new data has arrived.
* @data: The IIO device associated with the sampling hardware.
*
* Timestamp buffered samples as soon as possible then schedule threaded bottom
* half.
*
* Return: Always successful.
*/
static irqreturn_t zpa2326_handle_irq(int irq, void *data)
{
struct iio_dev *indio_dev = (struct iio_dev *)data;
if (iio_buffer_enabled(indio_dev)) {
/* Timestamping needed for buffered sampling only. */
((struct zpa2326_private *)
iio_priv(indio_dev))->timestamp = iio_get_time_ns(indio_dev);
}
return IRQ_WAKE_THREAD;
}
/**
* zpa2326_handle_threaded_irq() - Interrupt bottom-half handler.
* @irq: Interrupt line the hardware uses to notify new data has arrived.
* @data: The IIO device associated with the sampling hardware.
*
* Mainly ensures interrupt is caused by a real "new sample available"
* condition. This relies upon the ability to perform blocking / sleeping bus
* accesses to slave's registers. This is why zpa2326_handle_threaded_irq() is
* called from within a thread, i.e. not called from hard interrupt context.
*
* When device is using its own internal hardware trigger in continuous sampling
* mode, data are available into hardware FIFO once interrupt has occurred. All
* we have to do is to dispatch the trigger, which in turn will fetch data and
* fill IIO buffer.
*
* When not using its own internal hardware trigger, the device has been
* configured in one-shot mode either by an external trigger or the IIO read_raw
* hook. This means one of the latter is currently waiting for sampling
* completion, in which case we must simply wake it up.
*
* See zpa2326_trigger_handler().
*
* Return:
* %IRQ_NONE - no consistent interrupt happened ;
* %IRQ_HANDLED - there was new samples available.
*/
static irqreturn_t zpa2326_handle_threaded_irq(int irq, void *data)
{
struct iio_dev *indio_dev = (struct iio_dev *)data;
struct zpa2326_private *priv = iio_priv(indio_dev);
unsigned int val;
bool cont;
irqreturn_t ret = IRQ_NONE;
/*
* Are we using our own internal trigger in triggered buffer mode, i.e.,
* currently working in continuous sampling mode ?
*/
cont = (iio_buffer_enabled(indio_dev) &&
iio_trigger_using_own(indio_dev));
/*
* Device works according to a level interrupt scheme: reading interrupt
* status de-asserts interrupt line.
*/
priv->result = regmap_read(priv->regmap, ZPA2326_INT_SOURCE_REG, &val);
if (priv->result < 0) {
if (cont)
return IRQ_NONE;
goto complete;
}
/* Data ready is the only interrupt source we requested. */
if (!(val & ZPA2326_INT_SOURCE_DATA_READY)) {
/*
* Interrupt happened but no new sample available: likely caused
* by spurious interrupts, in which case, returning IRQ_NONE
* allows to benefit from the generic spurious interrupts
* handling.
*/
zpa2326_warn(indio_dev, "unexpected interrupt status %02x",
val);
if (cont)
return IRQ_NONE;
priv->result = -ENODATA;
goto complete;
}
/* New sample available: dispatch internal trigger consumers. */
iio_trigger_poll_chained(priv->trigger);
if (cont)
/*
* Internal hardware trigger has been scheduled above : it will
* fetch data on its own.
*/
return IRQ_HANDLED;
ret = IRQ_HANDLED;
complete:
/*
* Wake up direct or externaly triggered buffer mode waiters: see
* zpa2326_sample_oneshot() and zpa2326_trigger_handler().
*/
complete(&priv->data_ready);
return ret;
}
/**
* zpa2326_wait_oneshot_completion() - Wait for oneshot data ready interrupt.
* @indio_dev: The IIO device associated with the sampling hardware.
* @private: Internal private state related to @indio_dev.
*
* Return: Zero when successful, a negative error code otherwise.
*/
static int zpa2326_wait_oneshot_completion(const struct iio_dev *indio_dev,
struct zpa2326_private *private)
{
int ret;
unsigned int val;
zpa2326_dbg(indio_dev, "waiting for one shot completion interrupt");
ret = wait_for_completion_interruptible_timeout(
&private->data_ready, ZPA2326_CONVERSION_JIFFIES);
if (ret > 0)
/*
* Interrupt handler completed before timeout: return operation
* status.
*/
return private->result;
/* Clear all interrupts just to be sure. */
regmap_read(private->regmap, ZPA2326_INT_SOURCE_REG, &val);
if (!ret)
/* Timed out. */
ret = -ETIME;
if (ret != -ERESTARTSYS)
zpa2326_warn(indio_dev, "no one shot interrupt occurred (%d)",
ret);
return ret;
}
static int zpa2326_init_managed_irq(struct device *parent,
struct iio_dev *indio_dev,
struct zpa2326_private *private,
int irq)
{
int err;
private->irq = irq;
if (irq <= 0) {
/*
* Platform declared no interrupt line: device will be polled
* for data availability.
*/
dev_info(parent, "no interrupt found, running in polling mode");
return 0;
}
init_completion(&private->data_ready);
/* Request handler to be scheduled into threaded interrupt context. */
err = devm_request_threaded_irq(parent, irq, zpa2326_handle_irq,
zpa2326_handle_threaded_irq,
IRQF_TRIGGER_RISING | IRQF_ONESHOT,
dev_name(parent), indio_dev);
if (err) {
dev_err(parent, "failed to request interrupt %d (%d)", irq,
err);
return err;
}
dev_info(parent, "using interrupt %d", irq);
return 0;
}
/**
* zpa2326_poll_oneshot_completion() - Actively poll for one shot data ready.
* @indio_dev: The IIO device associated with the sampling hardware.
*
* Loop over registers content to detect end of sampling cycle. Used when DT
* declared no valid interrupt lines.
*
* Return: Zero when successful, a negative error code otherwise.
*/
static int zpa2326_poll_oneshot_completion(const struct iio_dev *indio_dev)
{
unsigned long tmout = jiffies + ZPA2326_CONVERSION_JIFFIES;
struct regmap *regs = ((struct zpa2326_private *)
iio_priv(indio_dev))->regmap;
unsigned int val;
int err;
zpa2326_dbg(indio_dev, "polling for one shot completion");
/*
* At least, 100 ms is needed for the device to complete its one-shot
* cycle.
*/
if (msleep_interruptible(100))
return -ERESTARTSYS;
/* Poll for conversion completion in hardware. */
while (true) {
err = regmap_read(regs, ZPA2326_CTRL_REG0_REG, &val);
if (err < 0)
goto err;
if (!(val & ZPA2326_CTRL_REG0_ONE_SHOT))
/* One-shot bit self clears at conversion end. */
break;
if (time_after(jiffies, tmout)) {
/* Prevent from waiting forever : let's time out. */
err = -ETIME;
goto err;
}
usleep_range(10000, 20000);
}
/*
* In oneshot mode, pressure sample availability guarantees that
* temperature conversion has also completed : just check pressure
* status bit to keep things simple.
*/
err = regmap_read(regs, ZPA2326_STATUS_REG, &val);
if (err < 0)
goto err;
if (!(val & ZPA2326_STATUS_P_DA)) {
/* No sample available. */
err = -ENODATA;
goto err;
}
return 0;
err:
zpa2326_warn(indio_dev, "failed to poll one shot completion (%d)", err);
return err;
}
/**
* zpa2326_fetch_raw_sample() - Retrieve a raw sample and convert it to CPU
* endianness.
* @indio_dev: The IIO device associated with the sampling hardware.
* @type: Type of measurement / channel to fetch from.
* @value: Sample output.
*
* Return: Zero when successful, a negative error code otherwise.
*/
static int zpa2326_fetch_raw_sample(const struct iio_dev *indio_dev,
enum iio_chan_type type,
int *value)
{
struct regmap *regs = ((struct zpa2326_private *)
iio_priv(indio_dev))->regmap;
int err;
switch (type) {
case IIO_PRESSURE:
zpa2326_dbg(indio_dev, "fetching raw pressure sample");
err = regmap_bulk_read(regs, ZPA2326_PRESS_OUT_XL_REG, value,
3);
if (err) {
zpa2326_warn(indio_dev, "failed to fetch pressure (%d)",
err);
return err;
}
/* Pressure is a 24 bits wide little-endian unsigned int. */
*value = (((u8 *)value)[2] << 16) | (((u8 *)value)[1] << 8) |
((u8 *)value)[0];
return IIO_VAL_INT;
case IIO_TEMP:
zpa2326_dbg(indio_dev, "fetching raw temperature sample");
err = regmap_bulk_read(regs, ZPA2326_TEMP_OUT_L_REG, value, 2);
if (err) {
zpa2326_warn(indio_dev,
"failed to fetch temperature (%d)", err);
return err;
}
/* Temperature is a 16 bits wide little-endian signed int. */
*value = (int)le16_to_cpup((__le16 *)value);
return IIO_VAL_INT;
default:
return -EINVAL;
}
}
/**
* zpa2326_sample_oneshot() - Perform a complete one shot sampling cycle.
* @indio_dev: The IIO device associated with the sampling hardware.
* @type: Type of measurement / channel to fetch from.
* @value: Sample output.
*
* Return: Zero when successful, a negative error code otherwise.
*/
static int zpa2326_sample_oneshot(struct iio_dev *indio_dev,
enum iio_chan_type type,
int *value)
{
int ret;
struct zpa2326_private *priv;
ret = iio_device_claim_direct_mode(indio_dev);
if (ret)
return ret;
ret = zpa2326_resume(indio_dev);
if (ret < 0)
goto release;
priv = iio_priv(indio_dev);
if (ret > 0) {
/*
* We were already power supplied. Just clear hardware FIFO to
* get rid of samples acquired during previous rounds (if any).
* Sampling operation always generates both temperature and
* pressure samples. The latter are always enqueued into
* hardware FIFO. This may lead to situations were pressure
* samples still sit into FIFO when previous cycle(s) fetched
* temperature data only.
* Hence, we need to clear hardware FIFO content to prevent from
* getting outdated values at the end of current cycle.
*/
if (type == IIO_PRESSURE) {
ret = zpa2326_clear_fifo(indio_dev, 0);
if (ret)
goto suspend;
}
} else {
/*
* We have just been power supplied, i.e. device is in default
* "out of reset" state, meaning we need to reconfigure it
* entirely.
*/
ret = zpa2326_config_oneshot(indio_dev, priv->irq);
if (ret)
goto suspend;
}
/* Start a sampling cycle in oneshot mode. */
ret = zpa2326_start_oneshot(indio_dev);
if (ret)
goto suspend;
/* Wait for sampling cycle to complete. */
if (priv->irq > 0)
ret = zpa2326_wait_oneshot_completion(indio_dev, priv);
else
ret = zpa2326_poll_oneshot_completion(indio_dev);
if (ret)
goto suspend;
/* Retrieve raw sample value and convert it to CPU endianness. */
ret = zpa2326_fetch_raw_sample(indio_dev, type, value);
suspend:
zpa2326_suspend(indio_dev);
release:
iio_device_release_direct_mode(indio_dev);
return ret;
}
/**
* zpa2326_trigger_handler() - Perform an IIO buffered sampling round in one
* shot mode.
* @irq: The software interrupt assigned to @data
* @data: The IIO poll function dispatched by external trigger our device is
* attached to.
*
* Bottom-half handler called by the IIO trigger to which our device is
* currently attached. Allows us to synchronize this device buffered sampling
* either with external events (such as timer expiration, external device sample
* ready, etc...) or with its own interrupt (internal hardware trigger).
*
* When using an external trigger, basically run the same sequence of operations
* as for zpa2326_sample_oneshot() with the following hereafter. Hardware FIFO
* is not cleared since already done at buffering enable time and samples
* dequeueing always retrieves the most recent value.
*
* Otherwise, when internal hardware trigger has dispatched us, just fetch data
* from hardware FIFO.
*
* Fetched data will pushed unprocessed to IIO buffer since samples conversion
* is delegated to userspace in buffered mode (endianness, etc...).
*
* Return:
* %IRQ_NONE - no consistent interrupt happened ;
* %IRQ_HANDLED - there was new samples available.
*/
static irqreturn_t zpa2326_trigger_handler(int irq, void *data)
{
struct iio_dev *indio_dev = ((struct iio_poll_func *)
data)->indio_dev;
struct zpa2326_private *priv = iio_priv(indio_dev);
bool cont;
/*
* We have been dispatched, meaning we are in triggered buffer mode.
* Using our own internal trigger implies we are currently in continuous
* hardware sampling mode.
*/
cont = iio_trigger_using_own(indio_dev);
if (!cont) {
/* On demand sampling : start a one shot cycle. */
if (zpa2326_start_oneshot(indio_dev))
goto out;
/* Wait for sampling cycle to complete. */
if (priv->irq <= 0) {
/* No interrupt available: poll for completion. */
if (zpa2326_poll_oneshot_completion(indio_dev))
goto out;
/* Only timestamp sample once it is ready. */
priv->timestamp = iio_get_time_ns(indio_dev);
} else {
/* Interrupt handlers will timestamp for us. */
if (zpa2326_wait_oneshot_completion(indio_dev, priv))
goto out;
}
}
/* Enqueue to IIO buffer / userspace. */
zpa2326_fill_sample_buffer(indio_dev, priv);
out:
if (!cont)
/* Don't switch to low power if sampling continuously. */
zpa2326_sleep(indio_dev);
/* Inform attached trigger we are done. */
iio_trigger_notify_done(indio_dev->trig);
return IRQ_HANDLED;
}
/**
* zpa2326_preenable_buffer() - Prepare device for configuring triggered
* sampling
* modes.
* @indio_dev: The IIO device associated with the sampling hardware.
*
* Basically power up device.
* Called with IIO device's lock held.
*
* Return: Zero when successful, a negative error code otherwise.
*/
static int zpa2326_preenable_buffer(struct iio_dev *indio_dev)
{
int ret = zpa2326_resume(indio_dev);
if (ret < 0)
return ret;
/* Tell zpa2326_postenable_buffer() if we have just been powered on. */
((struct zpa2326_private *)
iio_priv(indio_dev))->waken = iio_priv(indio_dev);
return 0;
}
/**
* zpa2326_postenable_buffer() - Configure device for triggered sampling.
* @indio_dev: The IIO device associated with the sampling hardware.
*
* Basically setup one-shot mode if plugging external trigger.
* Otherwise, let internal trigger configure continuous sampling :
* see zpa2326_set_trigger_state().
*
* If an error is returned, IIO layer will call our postdisable hook for us,
* i.e. no need to explicitly power device off here.
* Called with IIO device's lock held.
*
* Called with IIO device's lock held.
*
* Return: Zero when successful, a negative error code otherwise.
*/
static int zpa2326_postenable_buffer(struct iio_dev *indio_dev)
{
const struct zpa2326_private *priv = iio_priv(indio_dev);
int err;
if (!priv->waken) {
/*
* We were already power supplied. Just clear hardware FIFO to
* get rid of samples acquired during previous rounds (if any).
*/
err = zpa2326_clear_fifo(indio_dev, 0);
if (err)
goto err;
}
if (!iio_trigger_using_own(indio_dev) && priv->waken) {
/*
* We are using an external trigger and we have just been
* powered up: reconfigure one-shot mode.
*/
err = zpa2326_config_oneshot(indio_dev, priv->irq);
if (err)
goto err;
}
/* Plug our own trigger event handler. */
err = iio_triggered_buffer_postenable(indio_dev);
if (err)
goto err;
return 0;
err:
zpa2326_err(indio_dev, "failed to enable buffering (%d)", err);
return err;
}
static int zpa2326_postdisable_buffer(struct iio_dev *indio_dev)
{
zpa2326_suspend(indio_dev);
return 0;
}
static const struct iio_buffer_setup_ops zpa2326_buffer_setup_ops = {
.preenable = zpa2326_preenable_buffer,
.postenable = zpa2326_postenable_buffer,
.predisable = iio_triggered_buffer_predisable,
.postdisable = zpa2326_postdisable_buffer
};
/**
* zpa2326_set_trigger_state() - Start / stop continuous sampling.
* @trig: The trigger being attached to IIO device associated with the sampling
* hardware.
* @state: Tell whether to start (true) or stop (false)
*
* Basically enable / disable hardware continuous sampling mode.
*
* Called with IIO device's lock held at postenable() or predisable() time.
*
* Return: Zero when successful, a negative error code otherwise.
*/
static int zpa2326_set_trigger_state(struct iio_trigger *trig, bool state)
{
const struct iio_dev *indio_dev = dev_get_drvdata(
trig->dev.parent);
const struct zpa2326_private *priv = iio_priv(indio_dev);
int err;
if (!state) {
/*
* Switch trigger off : in case of failure, interrupt is left
* disabled in order to prevent handler from accessing released
* resources.
*/
unsigned int val;
/*
* As device is working in continuous mode, handlers may be
* accessing resources we are currently freeing...
* Prevent this by disabling interrupt handlers and ensure
* the device will generate no more interrupts unless explicitly
* required to, i.e. by restoring back to default one shot mode.
*/
disable_irq(priv->irq);
/*
* Disable continuous sampling mode to restore settings for
* one shot / direct sampling operations.
*/
err = regmap_write(priv->regmap, ZPA2326_CTRL_REG3_REG,
zpa2326_highest_frequency()->odr);
if (err)
return err;
/*
* Now that device won't generate interrupts on its own,
* acknowledge any currently active interrupts (may happen on
* rare occasions while stopping continuous mode).
*/
err = regmap_read(priv->regmap, ZPA2326_INT_SOURCE_REG, &val);
if (err < 0)
return err;
/*
* Re-enable interrupts only if we can guarantee the device will
* generate no more interrupts to prevent handlers from
* accessing released resources.
*/
enable_irq(priv->irq);
zpa2326_dbg(indio_dev, "continuous mode stopped");
} else {
/*
* Switch trigger on : start continuous sampling at required
* frequency.
*/
if (priv->waken) {
/* Enable interrupt if getting out of reset. */
err = regmap_write(priv->regmap, ZPA2326_CTRL_REG1_REG,
(u8)
~ZPA2326_CTRL_REG1_MASK_DATA_READY);
if (err)
return err;
}
/* Enable continuous sampling at specified frequency. */
err = regmap_write(priv->regmap, ZPA2326_CTRL_REG3_REG,
ZPA2326_CTRL_REG3_ENABLE_MEAS |
priv->frequency->odr);
if (err)
return err;
zpa2326_dbg(indio_dev, "continuous mode setup @%dHz",
priv->frequency->hz);
}
return 0;
}
static const struct iio_trigger_ops zpa2326_trigger_ops = {
.owner = THIS_MODULE,
.set_trigger_state = zpa2326_set_trigger_state,
};
/**
* zpa2326_init_trigger() - Create an interrupt driven / hardware trigger
* allowing to notify external devices a new sample is
* ready.
* @parent: Hardware sampling device @indio_dev is a child of.
* @indio_dev: The IIO device associated with the sampling hardware.
* @private: Internal private state related to @indio_dev.
* @irq: Optional interrupt line the hardware uses to notify new data
* samples are ready. Negative or zero values indicate no interrupts
* are available, meaning polling is required.
*
* Only relevant when DT declares a valid interrupt line.
*
* Return: Zero when successful, a negative error code otherwise.
*/
static int zpa2326_init_managed_trigger(struct device *parent,
struct iio_dev *indio_dev,
struct zpa2326_private *private,
int irq)
{
struct iio_trigger *trigger;
int ret;
if (irq <= 0)
return 0;
trigger = devm_iio_trigger_alloc(parent, "%s-dev%d",
indio_dev->name, indio_dev->id);
if (!trigger)
return -ENOMEM;
/* Basic setup. */
trigger->dev.parent = parent;
trigger->ops = &zpa2326_trigger_ops;
private->trigger = trigger;
/* Register to triggers space. */
ret = devm_iio_trigger_register(parent, trigger);
if (ret)
dev_err(parent, "failed to register hardware trigger (%d)",
ret);
return ret;
}
static int zpa2326_get_frequency(const struct iio_dev *indio_dev)
{
return ((struct zpa2326_private *)iio_priv(indio_dev))->frequency->hz;
}
static int zpa2326_set_frequency(struct iio_dev *indio_dev, int hz)
{
struct zpa2326_private *priv = iio_priv(indio_dev);
int freq;
int err;
/* Check if requested frequency is supported. */
for (freq = 0; freq < ARRAY_SIZE(zpa2326_sampling_frequencies); freq++)
if (zpa2326_sampling_frequencies[freq].hz == hz)
break;
if (freq == ARRAY_SIZE(zpa2326_sampling_frequencies))
return -EINVAL;
/* Don't allow changing frequency if buffered sampling is ongoing. */
err = iio_device_claim_direct_mode(indio_dev);
if (err)
return err;
priv->frequency = &zpa2326_sampling_frequencies[freq];
iio_device_release_direct_mode(indio_dev);
return 0;
}
/* Expose supported hardware sampling frequencies (Hz) through sysfs. */
static IIO_CONST_ATTR_SAMP_FREQ_AVAIL("1 5 11 23");
static struct attribute *zpa2326_attributes[] = {
&iio_const_attr_sampling_frequency_available.dev_attr.attr,
NULL
};
static const struct attribute_group zpa2326_attribute_group = {
.attrs = zpa2326_attributes,
};
static int zpa2326_read_raw(struct iio_dev *indio_dev,
struct iio_chan_spec const *chan,
int *val,
int *val2,
long mask)
{
switch (mask) {
case IIO_CHAN_INFO_RAW:
return zpa2326_sample_oneshot(indio_dev, chan->type, val);
case IIO_CHAN_INFO_SCALE:
switch (chan->type) {
case IIO_PRESSURE:
/*
* Pressure resolution is 1/64 Pascal. Scale to kPascal
* as required by IIO ABI.
*/
*val = 1;
*val2 = 64000;
return IIO_VAL_FRACTIONAL;
case IIO_TEMP:
/*
* Temperature follows the equation:
* Temp[degC] = Tempcode * 0.00649 - 176.83
* where:
* Tempcode is composed the raw sampled 16 bits.
*
* Hence, to produce a temperature in milli-degrees
* Celsius according to IIO ABI, we need to apply the
* following equation to raw samples:
* Temp[milli degC] = (Tempcode + Offset) * Scale
* where:
* Offset = -176.83 / 0.00649
* Scale = 0.00649 * 1000
*/
*val = 6;
*val2 = 490000;
return IIO_VAL_INT_PLUS_MICRO;
default:
return -EINVAL;
}
case IIO_CHAN_INFO_OFFSET:
switch (chan->type) {
case IIO_TEMP:
*val = -17683000;
*val2 = 649;
return IIO_VAL_FRACTIONAL;
default:
return -EINVAL;
}
case IIO_CHAN_INFO_SAMP_FREQ:
*val = zpa2326_get_frequency(indio_dev);
return IIO_VAL_INT;
default:
return -EINVAL;
}
}
static int zpa2326_write_raw(struct iio_dev *indio_dev,
const struct iio_chan_spec *chan,
int val,
int val2,
long mask)
{
if ((mask != IIO_CHAN_INFO_SAMP_FREQ) || val2)
return -EINVAL;
return zpa2326_set_frequency(indio_dev, val);
}
static const struct iio_chan_spec zpa2326_channels[] = {
[0] = {
.type = IIO_PRESSURE,
.scan_index = 0,
.scan_type = {
.sign = 'u',
.realbits = 24,
.storagebits = 32,
.endianness = IIO_LE,
},
.info_mask_separate = BIT(IIO_CHAN_INFO_RAW) |
BIT(IIO_CHAN_INFO_SCALE),
.info_mask_shared_by_all = BIT(IIO_CHAN_INFO_SAMP_FREQ),
},
[1] = {
.type = IIO_TEMP,
.scan_index = 1,
.scan_type = {
.sign = 's',
.realbits = 16,
.storagebits = 16,
.endianness = IIO_LE,
},
.info_mask_separate = BIT(IIO_CHAN_INFO_RAW) |
BIT(IIO_CHAN_INFO_SCALE) |
BIT(IIO_CHAN_INFO_OFFSET),
.info_mask_shared_by_all = BIT(IIO_CHAN_INFO_SAMP_FREQ),
},
[2] = IIO_CHAN_SOFT_TIMESTAMP(2),
};
static const struct iio_info zpa2326_info = {
.driver_module = THIS_MODULE,
.attrs = &zpa2326_attribute_group,
.read_raw = zpa2326_read_raw,
.write_raw = zpa2326_write_raw,
};
static struct iio_dev *zpa2326_create_managed_iiodev(struct device *device,
const char *name,
struct regmap *regmap)
{
struct iio_dev *indio_dev;
/* Allocate space to hold IIO device internal state. */
indio_dev = devm_iio_device_alloc(device,
sizeof(struct zpa2326_private));
if (!indio_dev)
return NULL;
/* Setup for userspace synchronous on demand sampling. */
indio_dev->modes = INDIO_DIRECT_MODE;
indio_dev->dev.parent = device;
indio_dev->channels = zpa2326_channels;
indio_dev->num_channels = ARRAY_SIZE(zpa2326_channels);
indio_dev->name = name;
indio_dev->info = &zpa2326_info;
return indio_dev;
}
int zpa2326_probe(struct device *parent,
const char *name,
int irq,
unsigned int hwid,
struct regmap *regmap)
{
struct iio_dev *indio_dev;
struct zpa2326_private *priv;
int err;
unsigned int id;
indio_dev = zpa2326_create_managed_iiodev(parent, name, regmap);
if (!indio_dev)
return -ENOMEM;
priv = iio_priv(indio_dev);
priv->vref = devm_regulator_get(parent, "vref");
if (IS_ERR(priv->vref))
return PTR_ERR(priv->vref);
priv->vdd = devm_regulator_get(parent, "vdd");
if (IS_ERR(priv->vdd))
return PTR_ERR(priv->vdd);
/* Set default hardware sampling frequency to highest rate supported. */
priv->frequency = zpa2326_highest_frequency();
/*
* Plug device's underlying bus abstraction : this MUST be set before
* registering interrupt handlers since an interrupt might happen if
* power up sequence is not properly applied.
*/
priv->regmap = regmap;
err = devm_iio_triggered_buffer_setup(parent, indio_dev, NULL,
zpa2326_trigger_handler,
&zpa2326_buffer_setup_ops);
if (err)
return err;
err = zpa2326_init_managed_trigger(parent, indio_dev, priv, irq);
if (err)
return err;
err = zpa2326_init_managed_irq(parent, indio_dev, priv, irq);
if (err)
return err;
/* Power up to check device ID and perform initial hardware setup. */
err = zpa2326_power_on(indio_dev, priv);
if (err)
return err;
/* Read id register to check we are talking to the right slave. */
err = regmap_read(regmap, ZPA2326_DEVICE_ID_REG, &id);
if (err)
goto sleep;
if (id != hwid) {
dev_err(parent, "found device with unexpected id %02x", id);
err = -ENODEV;
goto sleep;
}
err = zpa2326_config_oneshot(indio_dev, irq);
if (err)
goto sleep;
/* Setup done : go sleeping. Device will be awaken upon user request. */
err = zpa2326_sleep(indio_dev);
if (err)
goto poweroff;
dev_set_drvdata(parent, indio_dev);
zpa2326_init_runtime(parent);
err = iio_device_register(indio_dev);
if (err) {
zpa2326_fini_runtime(parent);
goto poweroff;
}
return 0;
sleep:
/* Put to sleep just in case power regulators are "dummy" ones. */
zpa2326_sleep(indio_dev);
poweroff:
zpa2326_power_off(indio_dev, priv);
return err;
}
EXPORT_SYMBOL_GPL(zpa2326_probe);
void zpa2326_remove(const struct device *parent)
{
struct iio_dev *indio_dev = dev_get_drvdata(parent);
iio_device_unregister(indio_dev);
zpa2326_fini_runtime(indio_dev->dev.parent);
zpa2326_sleep(indio_dev);
zpa2326_power_off(indio_dev, iio_priv(indio_dev));
}
EXPORT_SYMBOL_GPL(zpa2326_remove);
MODULE_AUTHOR("Gregor Boirie <gregor.boirie@parrot.com>");
MODULE_DESCRIPTION("Core driver for Murata ZPA2326 pressure sensor");
MODULE_LICENSE("GPL v2");
drivers/iio/pressure/zpa2326.h 0 → 100644
View file @ 888a87b5
/*
* Murata ZPA2326 pressure and temperature sensor IIO driver
*
* Copyright (c) 2016 Parrot S.A.
*
* Author: Gregor Boirie <gregor.boirie@parrot.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.
*/
#ifndef _ZPA2326_H
#define _ZPA2326_H
/* Register map. */
#define ZPA2326_REF_P_XL_REG (0x8)
#define ZPA2326_REF_P_L_REG (0x9)
#define ZPA2326_REF_P_H_REG (0xa)
#define ZPA2326_DEVICE_ID_REG (0xf)
#define ZPA2326_DEVICE_ID (0xb9)
#define ZPA2326_RES_CONF_REG (0x10)
#define ZPA2326_CTRL_REG0_REG (0x20)
#define ZPA2326_CTRL_REG0_ONE_SHOT BIT(0)
#define ZPA2326_CTRL_REG0_ENABLE BIT(1)
#define ZPA2326_CTRL_REG1_REG (0x21)
#define ZPA2326_CTRL_REG1_MASK_DATA_READY BIT(2)
#define ZPA2326_CTRL_REG2_REG (0x22)
#define ZPA2326_CTRL_REG2_SWRESET BIT(2)
#define ZPA2326_CTRL_REG3_REG (0x23)
#define ZPA2326_CTRL_REG3_ODR_SHIFT (4)
#define ZPA2326_CTRL_REG3_ENABLE_MEAS BIT(7)
#define ZPA2326_INT_SOURCE_REG (0x24)
#define ZPA2326_INT_SOURCE_DATA_READY BIT(2)
#define ZPA2326_THS_P_LOW_REG (0x25)
#define ZPA2326_THS_P_HIGH_REG (0x26)
#define ZPA2326_STATUS_REG (0x27)
#define ZPA2326_STATUS_P_DA BIT(1)
#define ZPA2326_STATUS_FIFO_E BIT(2)
#define ZPA2326_STATUS_P_OR BIT(5)
#define ZPA2326_PRESS_OUT_XL_REG (0x28)
#define ZPA2326_PRESS_OUT_L_REG (0x29)
#define ZPA2326_PRESS_OUT_H_REG (0x2a)
#define ZPA2326_TEMP_OUT_L_REG (0x2b)
#define ZPA2326_TEMP_OUT_H_REG (0x2c)
struct device;
struct regmap;
bool zpa2326_isreg_writeable(struct device *dev, unsigned int reg);
bool zpa2326_isreg_readable(struct device *dev, unsigned int reg);
bool zpa2326_isreg_precious(struct device *dev, unsigned int reg);
/**
* zpa2326_probe() - Instantiate and register core ZPA2326 IIO device
* @parent: Hardware sampling device the created IIO device will be a child of.
* @name: Arbitrary name to identify the device.
* @irq: Interrupt line, negative if none.
* @hwid: Expected device hardware id.
* @regmap: Registers map used to abstract underlying bus accesses.
*
* Return: Zero when successful, a negative error code otherwise.
*/
int zpa2326_probe(struct device *parent,
const char *name,
int irq,
unsigned int hwid,
struct regmap *regmap);
/**
* zpa2326_remove() - Unregister and destroy core ZPA2326 IIO device.
* @parent: Hardware sampling device the IIO device to remove is a child of.
*/
void zpa2326_remove(const struct device *parent);
#ifdef CONFIG_PM
#include <linux/pm.h>
extern const struct dev_pm_ops zpa2326_pm_ops;
#define ZPA2326_PM_OPS (&zpa2326_pm_ops)
#else
#define ZPA2326_PM_OPS (NULL)
#endif
#endif
drivers/iio/pressure/zpa2326_i2c.c 0 → 100644
View file @ 888a87b5
/*
* Murata ZPA2326 I2C pressure and temperature sensor driver
*
* Copyright (c) 2016 Parrot S.A.
*
* Author: Gregor Boirie <gregor.boirie@parrot.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.
*/
#include <linux/module.h>
#include <linux/regmap.h>
#include <linux/i2c.h>
#include <linux/of_device.h>
#include "zpa2326.h"
/*
* read_flag_mask:
* - address bit 7 must be set to request a register read operation
*/
static const struct regmap_config zpa2326_regmap_i2c_config = {
.reg_bits = 8,
.val_bits = 8,
.writeable_reg = zpa2326_isreg_writeable,
.readable_reg = zpa2326_isreg_readable,
.precious_reg = zpa2326_isreg_precious,
.max_register = ZPA2326_TEMP_OUT_H_REG,
.read_flag_mask = BIT(7),
.cache_type = REGCACHE_NONE,
};
static unsigned int zpa2326_i2c_hwid(const struct i2c_client *client)
{
#define ZPA2326_SA0(_addr) (_addr & BIT(0))
#define ZPA2326_DEVICE_ID_SA0_SHIFT (1)
/* Identification register bit 1 mirrors device address bit 0. */
return (ZPA2326_DEVICE_ID |
(ZPA2326_SA0(client->addr) << ZPA2326_DEVICE_ID_SA0_SHIFT));
}
static int zpa2326_probe_i2c(struct i2c_client *client,
const struct i2c_device_id *i2c_id)
{
struct regmap *regmap;
regmap = devm_regmap_init_i2c(client, &zpa2326_regmap_i2c_config);
if (IS_ERR(regmap)) {
dev_err(&client->dev, "failed to init registers map");
return PTR_ERR(regmap);
}
return zpa2326_probe(&client->dev, i2c_id->name, client->irq,
zpa2326_i2c_hwid(client), regmap);
}
static int zpa2326_remove_i2c(struct i2c_client *client)
{
zpa2326_remove(&client->dev);
return 0;
}
static const struct i2c_device_id zpa2326_i2c_ids[] = {
{ "zpa2326", 0 },
{ },
};
MODULE_DEVICE_TABLE(i2c, zpa2326_i2c_ids);
#if defined(CONFIG_OF)
static const struct of_device_id zpa2326_i2c_matches[] = {
{ .compatible = "murata,zpa2326" },
{ }
};
MODULE_DEVICE_TABLE(of, zpa2326_i2c_matches);
#endif
static struct i2c_driver zpa2326_i2c_driver = {
.driver = {
.name = "zpa2326-i2c",
.of_match_table = of_match_ptr(zpa2326_i2c_matches),
.pm = ZPA2326_PM_OPS,
},
.probe = zpa2326_probe_i2c,
.remove = zpa2326_remove_i2c,
.id_table = zpa2326_i2c_ids,
};
module_i2c_driver(zpa2326_i2c_driver);
MODULE_AUTHOR("Gregor Boirie <gregor.boirie@parrot.com>");
MODULE_DESCRIPTION("I2C driver for Murata ZPA2326 pressure sensor");
MODULE_LICENSE("GPL v2");
drivers/iio/pressure/zpa2326_spi.c 0 → 100644
View file @ 888a87b5
/*
* Murata ZPA2326 SPI pressure and temperature sensor driver
*
* Copyright (c) 2016 Parrot S.A.
*
* Author: Gregor Boirie <gregor.boirie@parrot.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.
*/
#include <linux/module.h>
#include <linux/regmap.h>
#include <linux/spi/spi.h>
#include <linux/of_device.h>
#include "zpa2326.h"
/*
* read_flag_mask:
* - address bit 7 must be set to request a register read operation
* - address bit 6 must be set to request register address auto increment
*/
static const struct regmap_config zpa2326_regmap_spi_config = {
.reg_bits = 8,
.val_bits = 8,
.writeable_reg = zpa2326_isreg_writeable,
.readable_reg = zpa2326_isreg_readable,
.precious_reg = zpa2326_isreg_precious,
.max_register = ZPA2326_TEMP_OUT_H_REG,
.read_flag_mask = BIT(7) | BIT(6),
.cache_type = REGCACHE_NONE,
};
static int zpa2326_probe_spi(struct spi_device *spi)
{
struct regmap *regmap;
int err;
regmap = devm_regmap_init_spi(spi, &zpa2326_regmap_spi_config);
if (IS_ERR(regmap)) {
dev_err(&spi->dev, "failed to init registers map");
return PTR_ERR(regmap);
}
/*
* Enforce SPI slave settings to prevent from DT misconfiguration.
*
* Clock is idle high. Sampling happens on trailing edge, i.e., rising
* edge. Maximum bus frequency is 1 MHz. Registers are 8 bits wide.
*/
spi->mode = SPI_MODE_3;
spi->max_speed_hz = min(spi->max_speed_hz, 1000000U);
spi->bits_per_word = 8;
err = spi_setup(spi);
if (err < 0)
return err;
return zpa2326_probe(&spi->dev, spi_get_device_id(spi)->name,
spi->irq, ZPA2326_DEVICE_ID, regmap);
}
static int zpa2326_remove_spi(struct spi_device *spi)
{
zpa2326_remove(&spi->dev);
return 0;
}
static const struct spi_device_id zpa2326_spi_ids[] = {
{ "zpa2326", 0 },
{ },
};
MODULE_DEVICE_TABLE(spi, zpa2326_spi_ids);
#if defined(CONFIG_OF)
static const struct of_device_id zpa2326_spi_matches[] = {
{ .compatible = "murata,zpa2326" },
{ }
};
MODULE_DEVICE_TABLE(of, zpa2326_spi_matches);
#endif
static struct spi_driver zpa2326_spi_driver = {
.driver = {
.name = "zpa2326-spi",
.of_match_table = of_match_ptr(zpa2326_spi_matches),
.pm = ZPA2326_PM_OPS,
},
.probe = zpa2326_probe_spi,
.remove = zpa2326_remove_spi,
.id_table = zpa2326_spi_ids,
};
module_spi_driver(zpa2326_spi_driver);
MODULE_AUTHOR("Gregor Boirie <gregor.boirie@parrot.com>");
MODULE_DESCRIPTION("SPI driver for Murata ZPA2326 pressure sensor");
MODULE_LICENSE("GPL v2");
drivers/staging/iio/accel/sca3000.h
View file @ 888a87b5
......@@ -113,6 +113,7 @@
#define SCA3000_OUT_CTRL_BUF_X_EN 0x10
#define SCA3000_OUT_CTRL_BUF_Y_EN 0x08
#define SCA3000_OUT_CTRL_BUF_Z_EN 0x04
#define SCA3000_OUT_CTRL_BUF_DIV_MASK 0x03
#define SCA3000_OUT_CTRL_BUF_DIV_4 0x02
#define SCA3000_OUT_CTRL_BUF_DIV_2 0x01
......
drivers/staging/iio/accel/sca3000_core.c
View file @ 888a87b5
......@@ -402,6 +402,7 @@ static const struct iio_event_spec sca3000_event = {
.channel2 = mod, \
.info_mask_separate = BIT(IIO_CHAN_INFO_RAW), \
.info_mask_shared_by_type = BIT(IIO_CHAN_INFO_SCALE),\
.info_mask_shared_by_all = BIT(IIO_CHAN_INFO_SAMP_FREQ),\
.address = index, \
.scan_index = index, \
.scan_type = { \
......@@ -443,6 +444,97 @@ static u8 sca3000_addresses[3][3] = {
SCA3000_MD_CTRL_OR_Z},
};
/**
* __sca3000_get_base_freq() obtain mode specific base frequency
*
* lock must be held
**/
static inline int __sca3000_get_base_freq(struct sca3000_state *st,
const struct sca3000_chip_info *info,
int *base_freq)
{
int ret;
ret = sca3000_read_data_short(st, SCA3000_REG_ADDR_MODE, 1);
if (ret)
goto error_ret;
switch (0x03 & st->rx[0]) {
case SCA3000_MEAS_MODE_NORMAL:
*base_freq = info->measurement_mode_freq;
break;
case SCA3000_MEAS_MODE_OP_1:
*base_freq = info->option_mode_1_freq;
break;
case SCA3000_MEAS_MODE_OP_2:
*base_freq = info->option_mode_2_freq;
break;
}
error_ret:
return ret;
}
/**
* read_raw handler for IIO_CHAN_INFO_SAMP_FREQ
*
* lock must be held
**/
static int read_raw_samp_freq(struct sca3000_state *st, int *val)
{
int ret;
ret = __sca3000_get_base_freq(st, st->info, val);
if (ret)
return ret;
ret = sca3000_read_ctrl_reg(st, SCA3000_REG_CTRL_SEL_OUT_CTRL);
if (ret < 0)
return ret;
if (*val > 0) {
ret &= SCA3000_OUT_CTRL_BUF_DIV_MASK;
switch (ret) {
case SCA3000_OUT_CTRL_BUF_DIV_2:
*val /= 2;
break;
case SCA3000_OUT_CTRL_BUF_DIV_4:
*val /= 4;
break;
}
}
return 0;
}
/**
* write_raw handler for IIO_CHAN_INFO_SAMP_FREQ
*
* lock must be held
**/
static int write_raw_samp_freq(struct sca3000_state *st, int val)
{
int ret, base_freq, ctrlval;
ret = __sca3000_get_base_freq(st, st->info, &base_freq);
if (ret)
return ret;
ret = sca3000_read_ctrl_reg(st, SCA3000_REG_CTRL_SEL_OUT_CTRL);
if (ret < 0)
return ret;
ctrlval = ret & ~SCA3000_OUT_CTRL_BUF_DIV_MASK;
if (val == base_freq / 2)
ctrlval |= SCA3000_OUT_CTRL_BUF_DIV_2;
if (val == base_freq / 4)
ctrlval |= SCA3000_OUT_CTRL_BUF_DIV_4;
else if (val != base_freq)
return -EINVAL;
return sca3000_write_ctrl_reg(st, SCA3000_REG_CTRL_SEL_OUT_CTRL,
ctrlval);
}
static int sca3000_read_raw(struct iio_dev *indio_dev,
struct iio_chan_spec const *chan,
int *val,
......@@ -495,11 +587,38 @@ static int sca3000_read_raw(struct iio_dev *indio_dev,
*val = -214;
*val2 = 600000;
return IIO_VAL_INT_PLUS_MICRO;
case IIO_CHAN_INFO_SAMP_FREQ:
mutex_lock(&st->lock);
ret = read_raw_samp_freq(st, val);
mutex_unlock(&st->lock);
return ret ? ret : IIO_VAL_INT;
default:
return -EINVAL;
}
}
static int sca3000_write_raw(struct iio_dev *indio_dev,
struct iio_chan_spec const *chan,
int val, int val2, long mask)
{
struct sca3000_state *st = iio_priv(indio_dev);
int ret;
switch (mask) {
case IIO_CHAN_INFO_SAMP_FREQ:
if (val2)
return -EINVAL;
mutex_lock(&st->lock);
ret = write_raw_samp_freq(st, val);
mutex_unlock(&st->lock);
return ret;
default:
return -EINVAL;
}
return ret;
}
/**
* sca3000_read_av_freq() sysfs function to get available frequencies
*
......@@ -548,133 +667,12 @@ static ssize_t sca3000_read_av_freq(struct device *dev,
return ret;
}
/**
* __sca3000_get_base_freq() obtain mode specific base frequency
*
* lock must be held
**/
static inline int __sca3000_get_base_freq(struct sca3000_state *st,
const struct sca3000_chip_info *info,
int *base_freq)
{
int ret;
ret = sca3000_read_data_short(st, SCA3000_REG_ADDR_MODE, 1);
if (ret)
goto error_ret;
switch (0x03 & st->rx[0]) {
case SCA3000_MEAS_MODE_NORMAL:
*base_freq = info->measurement_mode_freq;
break;
case SCA3000_MEAS_MODE_OP_1:
*base_freq = info->option_mode_1_freq;
break;
case SCA3000_MEAS_MODE_OP_2:
*base_freq = info->option_mode_2_freq;
break;
}
error_ret:
return ret;
}
/**
* sca3000_read_frequency() sysfs interface to get the current frequency
**/
static ssize_t sca3000_read_frequency(struct device *dev,
struct device_attribute *attr,
char *buf)
{
struct iio_dev *indio_dev = dev_to_iio_dev(dev);
struct sca3000_state *st = iio_priv(indio_dev);
int ret, len = 0, base_freq = 0, val;
mutex_lock(&st->lock);
ret = __sca3000_get_base_freq(st, st->info, &base_freq);
if (ret)
goto error_ret_mut;
ret = sca3000_read_ctrl_reg(st, SCA3000_REG_CTRL_SEL_OUT_CTRL);
mutex_unlock(&st->lock);
if (ret < 0)
goto error_ret;
val = ret;
if (base_freq > 0)
switch (val & 0x03) {
case 0x00:
case 0x03:
len = sprintf(buf, "%d\n", base_freq);
break;
case 0x01:
len = sprintf(buf, "%d\n", base_freq / 2);
break;
case 0x02:
len = sprintf(buf, "%d\n", base_freq / 4);
break;
}
return len;
error_ret_mut:
mutex_unlock(&st->lock);
error_ret:
return ret;
}
/**
* sca3000_set_frequency() sysfs interface to set the current frequency
**/
static ssize_t sca3000_set_frequency(struct device *dev,
struct device_attribute *attr,
const char *buf,
size_t len)
{
struct iio_dev *indio_dev = dev_to_iio_dev(dev);
struct sca3000_state *st = iio_priv(indio_dev);
int ret, base_freq = 0;
int ctrlval;
int val;
ret = kstrtoint(buf, 10, &val);
if (ret)
return ret;
mutex_lock(&st->lock);
/* What mode are we in? */
ret = __sca3000_get_base_freq(st, st->info, &base_freq);
if (ret)
goto error_free_lock;
ret = sca3000_read_ctrl_reg(st, SCA3000_REG_CTRL_SEL_OUT_CTRL);
if (ret < 0)
goto error_free_lock;
ctrlval = ret;
/* clear the bits */
ctrlval &= ~0x03;
if (val == base_freq / 2) {
ctrlval |= SCA3000_OUT_CTRL_BUF_DIV_2;
} else if (val == base_freq / 4) {
ctrlval |= SCA3000_OUT_CTRL_BUF_DIV_4;
} else if (val != base_freq) {
ret = -EINVAL;
goto error_free_lock;
}
ret = sca3000_write_ctrl_reg(st, SCA3000_REG_CTRL_SEL_OUT_CTRL,
ctrlval);
error_free_lock:
mutex_unlock(&st->lock);
return ret ? ret : len;
}
/*
* Should only really be registered if ring buffer support is compiled in.
* Does no harm however and doing it right would add a fair bit of complexity
*/
static IIO_DEV_ATTR_SAMP_FREQ_AVAIL(sca3000_read_av_freq);
static IIO_DEV_ATTR_SAMP_FREQ(S_IWUSR | S_IRUGO,
sca3000_read_frequency,
sca3000_set_frequency);
/**
* sca3000_read_thresh() - query of a threshold
**/
......@@ -751,7 +749,6 @@ static struct attribute *sca3000_attributes[] = {
&iio_dev_attr_measurement_mode_available.dev_attr.attr,
&iio_dev_attr_measurement_mode.dev_attr.attr,
&iio_dev_attr_sampling_frequency_available.dev_attr.attr,
&iio_dev_attr_sampling_frequency.dev_attr.attr,
NULL,
};
......@@ -1086,6 +1083,7 @@ static int sca3000_clean_setup(struct sca3000_state *st)
static const struct iio_info sca3000_info = {
.attrs = &sca3000_attribute_group,
.read_raw = &sca3000_read_raw,
.write_raw = &sca3000_write_raw,
.event_attrs = &sca3000_event_attribute_group,
.read_event_value = &sca3000_read_thresh,
.write_event_value = &sca3000_write_thresh,
......
drivers/staging/iio/impedance-analyzer/ad5933.c
View file @ 888a87b5
......@@ -156,8 +156,7 @@ static const struct iio_chan_spec ad5933_channels[] = {
},
};
static int ad5933_i2c_write(struct i2c_client *client,
u8 reg, u8 len, u8 *data)
static int ad5933_i2c_write(struct i2c_client *client, u8 reg, u8 len, u8 *data)
{
int ret;
......@@ -171,8 +170,7 @@ static int ad5933_i2c_write(struct i2c_client *client,
return 0;
}
static int ad5933_i2c_read(struct i2c_client *client,
u8 reg, u8 len, u8 *data)
static int ad5933_i2c_read(struct i2c_client *client, u8 reg, u8 len, u8 *data)
{
int ret;
......@@ -269,7 +267,8 @@ static int ad5933_setup(struct ad5933_state *st)
dat = cpu_to_be16(st->settling_cycles);
ret = ad5933_i2c_write(st->client,
AD5933_REG_SETTLING_CYCLES, 2, (u8 *)&dat);
AD5933_REG_SETTLING_CYCLES,
2, (u8 *)&dat);
if (ret < 0)
return ret;
......@@ -451,7 +450,8 @@ static ssize_t ad5933_store(struct device *dev,
dat = cpu_to_be16(val);
ret = ad5933_i2c_write(st->client,
AD5933_REG_SETTLING_CYCLES, 2, (u8 *)&dat);
AD5933_REG_SETTLING_CYCLES,
2, (u8 *)&dat);
break;
case AD5933_FREQ_POINTS:
val = clamp(val, (u16)0, (u16)511);
......@@ -545,8 +545,8 @@ static int ad5933_read_raw(struct iio_dev *indio_dev,
goto out;
ret = ad5933_i2c_read(st->client,
AD5933_REG_TEMP_DATA, 2,
(u8 *)&dat);
AD5933_REG_TEMP_DATA,
2, (u8 *)&dat);
if (ret < 0)
goto out;
mutex_unlock(&indio_dev->mlock);
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment
GitLab Nexedi Edition | About GitLab | About Nexedi | 沪ICP备2021021310号-2 | 沪ICP备2021021310号-7