iio: pressure: icp10100: add driver for InvenSense ICP-101xx
InvenSense ICP-101xx sensors are a family of barometric pressure and temperature sensor. These devices are I2C only and use a specific protocol of commands/responses. Data transfer is secured by using crc8. Driver provides processed pressure and raw temperature data. Signed-off-by: Jean-Baptiste Maneyrol <jmaneyrol@invensense.com> Signed-off-by: Jonathan Cameron <Jonathan.Cameron@huawei.com>
This commit is contained in:
Jean-Baptiste Maneyrol
Jonathan Cameron
parent
2ddc982a6c
commit
95c72b78c3
|
|
@ -101,6 +101,17 @@ config HP03
|
|||
To compile this driver as a module, choose M here: the module
|
||||
will be called hp03.
|
||||
|
||||
config ICP10100
|
||||
tristate "InvenSense ICP-101xx pressure and temperature sensor"
|
||||
depends on I2C
|
||||
select CRC8
|
||||
help
|
||||
Say yes here to build support for InvenSense ICP-101xx barometric
|
||||
pressure and temperature sensor.
|
||||
|
||||
To compile this driver as a module, choose M here: the module
|
||||
will be called icp10100.
|
||||
|
||||
config MPL115
|
||||
tristate
|
||||
|
||||
|
|
|
|||
|
|
@ -14,6 +14,7 @@ obj-$(CONFIG_DPS310) += dps310.o
|
|||
obj-$(CONFIG_IIO_CROS_EC_BARO) += cros_ec_baro.o
|
||||
obj-$(CONFIG_HID_SENSOR_PRESS) += hid-sensor-press.o
|
||||
obj-$(CONFIG_HP03) += hp03.o
|
||||
obj-$(CONFIG_ICP10100) += icp10100.o
|
||||
obj-$(CONFIG_MPL115) += mpl115.o
|
||||
obj-$(CONFIG_MPL115_I2C) += mpl115_i2c.o
|
||||
obj-$(CONFIG_MPL115_SPI) += mpl115_spi.o
|
||||
|
|
|
|||
|
|
@ -0,0 +1,658 @@
|
|||
// SPDX-License-Identifier: GPL-2.0-or-later
|
||||
/*
|
||||
* Copyright (C) 2020 InvenSense, Inc.
|
||||
*
|
||||
* Driver for InvenSense ICP-1010xx barometric pressure and temperature sensor.
|
||||
*
|
||||
* Datasheet:
|
||||
* http://www.invensense.com/wp-content/uploads/2018/01/DS-000186-ICP-101xx-v1.2.pdf
|
||||
*/
|
||||
|
||||
#include <linux/device.h>
|
||||
#include <linux/module.h>
|
||||
#include <linux/i2c.h>
|
||||
#include <linux/pm_runtime.h>
|
||||
#include <linux/crc8.h>
|
||||
#include <linux/mutex.h>
|
||||
#include <linux/delay.h>
|
||||
#include <linux/log2.h>
|
||||
#include <linux/math64.h>
|
||||
#include <linux/regulator/consumer.h>
|
||||
#include <linux/iio/iio.h>
|
||||
|
||||
#define ICP10100_ID_REG_GET(_reg) ((_reg) & 0x003F)
|
||||
#define ICP10100_ID_REG 0x08
|
||||
#define ICP10100_RESPONSE_WORD_LENGTH 3
|
||||
#define ICP10100_CRC8_WORD_LENGTH 2
|
||||
#define ICP10100_CRC8_POLYNOMIAL 0x31
|
||||
#define ICP10100_CRC8_INIT 0xFF
|
||||
|
||||
enum icp10100_mode {
|
||||
ICP10100_MODE_LP, /* Low power mode: 1x sampling */
|
||||
ICP10100_MODE_N, /* Normal mode: 2x sampling */
|
||||
ICP10100_MODE_LN, /* Low noise mode: 4x sampling */
|
||||
ICP10100_MODE_ULN, /* Ultra low noise mode: 8x sampling */
|
||||
ICP10100_MODE_NB,
|
||||
};
|
||||
|
||||
struct icp10100_state {
|
||||
struct mutex lock;
|
||||
struct i2c_client *client;
|
||||
struct regulator *vdd;
|
||||
enum icp10100_mode mode;
|
||||
int16_t cal[4];
|
||||
};
|
||||
|
||||
struct icp10100_command {
|
||||
__be16 cmd;
|
||||
unsigned long wait_us;
|
||||
unsigned long wait_max_us;
|
||||
size_t response_word_nb;
|
||||
};
|
||||
|
||||
static const struct icp10100_command icp10100_cmd_soft_reset = {
|
||||
.cmd = cpu_to_be16(0x805D),
|
||||
.wait_us = 170,
|
||||
.wait_max_us = 200,
|
||||
.response_word_nb = 0,
|
||||
};
|
||||
|
||||
static const struct icp10100_command icp10100_cmd_read_id = {
|
||||
.cmd = cpu_to_be16(0xEFC8),
|
||||
.wait_us = 0,
|
||||
.response_word_nb = 1,
|
||||
};
|
||||
|
||||
static const struct icp10100_command icp10100_cmd_read_otp = {
|
||||
.cmd = cpu_to_be16(0xC7F7),
|
||||
.wait_us = 0,
|
||||
.response_word_nb = 1,
|
||||
};
|
||||
|
||||
static const struct icp10100_command icp10100_cmd_measure[] = {
|
||||
[ICP10100_MODE_LP] = {
|
||||
.cmd = cpu_to_be16(0x401A),
|
||||
.wait_us = 1800,
|
||||
.wait_max_us = 2000,
|
||||
.response_word_nb = 3,
|
||||
},
|
||||
[ICP10100_MODE_N] = {
|
||||
.cmd = cpu_to_be16(0x48A3),
|
||||
.wait_us = 6300,
|
||||
.wait_max_us = 6500,
|
||||
.response_word_nb = 3,
|
||||
},
|
||||
[ICP10100_MODE_LN] = {
|
||||
.cmd = cpu_to_be16(0x5059),
|
||||
.wait_us = 23800,
|
||||
.wait_max_us = 24000,
|
||||
.response_word_nb = 3,
|
||||
},
|
||||
[ICP10100_MODE_ULN] = {
|
||||
.cmd = cpu_to_be16(0x58E0),
|
||||
.wait_us = 94500,
|
||||
.wait_max_us = 94700,
|
||||
.response_word_nb = 3,
|
||||
},
|
||||
};
|
||||
|
||||
static const uint8_t icp10100_switch_mode_otp[] =
|
||||
{0xC5, 0x95, 0x00, 0x66, 0x9c};
|
||||
|
||||
DECLARE_CRC8_TABLE(icp10100_crc8_table);
|
||||
|
||||
static inline int icp10100_i2c_xfer(struct i2c_adapter *adap,
|
||||
struct i2c_msg *msgs, int num)
|
||||
{
|
||||
int ret;
|
||||
|
||||
ret = i2c_transfer(adap, msgs, num);
|
||||
if (ret < 0)
|
||||
return ret;
|
||||
|
||||
if (ret != num)
|
||||
return -EIO;
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int icp10100_send_cmd(struct icp10100_state *st,
|
||||
const struct icp10100_command *cmd,
|
||||
__be16 *buf, size_t buf_len)
|
||||
{
|
||||
size_t size = cmd->response_word_nb * ICP10100_RESPONSE_WORD_LENGTH;
|
||||
uint8_t data[16];
|
||||
uint8_t *ptr;
|
||||
uint8_t *buf_ptr = (uint8_t *)buf;
|
||||
struct i2c_msg msgs[2] = {
|
||||
{
|
||||
.addr = st->client->addr,
|
||||
.flags = 0,
|
||||
.len = 2,
|
||||
.buf = (uint8_t *)&cmd->cmd,
|
||||
}, {
|
||||
.addr = st->client->addr,
|
||||
.flags = I2C_M_RD,
|
||||
.len = size,
|
||||
.buf = data,
|
||||
},
|
||||
};
|
||||
uint8_t crc;
|
||||
unsigned int i;
|
||||
int ret;
|
||||
|
||||
if (size > sizeof(data))
|
||||
return -EINVAL;
|
||||
|
||||
if (cmd->response_word_nb > 0 &&
|
||||
(buf == NULL || buf_len < (cmd->response_word_nb * 2)))
|
||||
return -EINVAL;
|
||||
|
||||
dev_dbg(&st->client->dev, "sending cmd %#x\n", be16_to_cpu(cmd->cmd));
|
||||
|
||||
if (cmd->response_word_nb > 0 && cmd->wait_us == 0) {
|
||||
/* direct command-response without waiting */
|
||||
ret = icp10100_i2c_xfer(st->client->adapter, msgs,
|
||||
ARRAY_SIZE(msgs));
|
||||
if (ret)
|
||||
return ret;
|
||||
} else {
|
||||
/* transfer command write */
|
||||
ret = icp10100_i2c_xfer(st->client->adapter, &msgs[0], 1);
|
||||
if (ret)
|
||||
return ret;
|
||||
if (cmd->wait_us > 0)
|
||||
usleep_range(cmd->wait_us, cmd->wait_max_us);
|
||||
/* transfer response read if needed */
|
||||
if (cmd->response_word_nb > 0) {
|
||||
ret = icp10100_i2c_xfer(st->client->adapter, &msgs[1], 1);
|
||||
if (ret)
|
||||
return ret;
|
||||
} else {
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
|
||||
/* process read words with crc checking */
|
||||
for (i = 0; i < cmd->response_word_nb; ++i) {
|
||||
ptr = &data[i * ICP10100_RESPONSE_WORD_LENGTH];
|
||||
crc = crc8(icp10100_crc8_table, ptr, ICP10100_CRC8_WORD_LENGTH,
|
||||
ICP10100_CRC8_INIT);
|
||||
if (crc != ptr[ICP10100_CRC8_WORD_LENGTH]) {
|
||||
dev_err(&st->client->dev, "crc error recv=%#x calc=%#x\n",
|
||||
ptr[ICP10100_CRC8_WORD_LENGTH], crc);
|
||||
return -EIO;
|
||||
}
|
||||
*buf_ptr++ = ptr[0];
|
||||
*buf_ptr++ = ptr[1];
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int icp10100_read_cal_otp(struct icp10100_state *st)
|
||||
{
|
||||
__be16 val;
|
||||
int i;
|
||||
int ret;
|
||||
|
||||
/* switch into OTP read mode */
|
||||
ret = i2c_master_send(st->client, icp10100_switch_mode_otp,
|
||||
ARRAY_SIZE(icp10100_switch_mode_otp));
|
||||
if (ret < 0)
|
||||
return ret;
|
||||
if (ret != ARRAY_SIZE(icp10100_switch_mode_otp))
|
||||
return -EIO;
|
||||
|
||||
/* read 4 calibration values */
|
||||
for (i = 0; i < 4; ++i) {
|
||||
ret = icp10100_send_cmd(st, &icp10100_cmd_read_otp,
|
||||
&val, sizeof(val));
|
||||
if (ret)
|
||||
return ret;
|
||||
st->cal[i] = be16_to_cpu(val);
|
||||
dev_dbg(&st->client->dev, "cal[%d] = %d\n", i, st->cal[i]);
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int icp10100_init_chip(struct icp10100_state *st)
|
||||
{
|
||||
__be16 val;
|
||||
uint16_t id;
|
||||
int ret;
|
||||
|
||||
/* read and check id */
|
||||
ret = icp10100_send_cmd(st, &icp10100_cmd_read_id, &val, sizeof(val));
|
||||
if (ret)
|
||||
return ret;
|
||||
id = ICP10100_ID_REG_GET(be16_to_cpu(val));
|
||||
if (id != ICP10100_ID_REG) {
|
||||
dev_err(&st->client->dev, "invalid id %#x\n", id);
|
||||
return -ENODEV;
|
||||
}
|
||||
|
||||
/* read calibration data from OTP */
|
||||
ret = icp10100_read_cal_otp(st);
|
||||
if (ret)
|
||||
return ret;
|
||||
|
||||
/* reset chip */
|
||||
return icp10100_send_cmd(st, &icp10100_cmd_soft_reset, NULL, 0);
|
||||
}
|
||||
|
||||
static int icp10100_get_measures(struct icp10100_state *st,
|
||||
uint32_t *pressure, uint16_t *temperature)
|
||||
{
|
||||
const struct icp10100_command *cmd;
|
||||
__be16 measures[3];
|
||||
int ret;
|
||||
|
||||
pm_runtime_get_sync(&st->client->dev);
|
||||
|
||||
mutex_lock(&st->lock);
|
||||
cmd = &icp10100_cmd_measure[st->mode];
|
||||
ret = icp10100_send_cmd(st, cmd, measures, sizeof(measures));
|
||||
mutex_unlock(&st->lock);
|
||||
if (ret)
|
||||
goto error_measure;
|
||||
|
||||
*pressure = (be16_to_cpu(measures[0]) << 8) |
|
||||
(be16_to_cpu(measures[1]) >> 8);
|
||||
*temperature = be16_to_cpu(measures[2]);
|
||||
|
||||
pm_runtime_mark_last_busy(&st->client->dev);
|
||||
error_measure:
|
||||
pm_runtime_put_autosuspend(&st->client->dev);
|
||||
return ret;
|
||||
}
|
||||
|
||||
static uint32_t icp10100_get_pressure(struct icp10100_state *st,
|
||||
uint32_t raw_pressure, uint16_t raw_temp)
|
||||
{
|
||||
static int32_t p_calib[] = {45000, 80000, 105000};
|
||||
static int32_t lut_lower = 3670016;
|
||||
static int32_t lut_upper = 12058624;
|
||||
static int32_t inv_quadr_factor = 16777216;
|
||||
static int32_t offset_factor = 2048;
|
||||
int64_t val1, val2;
|
||||
int32_t p_lut[3];
|
||||
int32_t t, t_square;
|
||||
int64_t a, b, c;
|
||||
uint32_t pressure_mPa;
|
||||
|
||||
dev_dbg(&st->client->dev, "raw: pressure = %u, temp = %u\n",
|
||||
raw_pressure, raw_temp);
|
||||
|
||||
/* compute p_lut values */
|
||||
t = (int32_t)raw_temp - 32768;
|
||||
t_square = t * t;
|
||||
val1 = (int64_t)st->cal[0] * (int64_t)t_square;
|
||||
p_lut[0] = lut_lower + (int32_t)div_s64(val1, inv_quadr_factor);
|
||||
val1 = (int64_t)st->cal[1] * (int64_t)t_square;
|
||||
p_lut[1] = offset_factor * st->cal[3] +
|
||||
(int32_t)div_s64(val1, inv_quadr_factor);
|
||||
val1 = (int64_t)st->cal[2] * (int64_t)t_square;
|
||||
p_lut[2] = lut_upper + (int32_t)div_s64(val1, inv_quadr_factor);
|
||||
dev_dbg(&st->client->dev, "p_lut = [%d, %d, %d]\n",
|
||||
p_lut[0], p_lut[1], p_lut[2]);
|
||||
|
||||
/* compute a, b, c factors */
|
||||
val1 = (int64_t)p_lut[0] * (int64_t)p_lut[1] *
|
||||
(int64_t)(p_calib[0] - p_calib[1]) +
|
||||
(int64_t)p_lut[1] * (int64_t)p_lut[2] *
|
||||
(int64_t)(p_calib[1] - p_calib[2]) +
|
||||
(int64_t)p_lut[2] * (int64_t)p_lut[0] *
|
||||
(int64_t)(p_calib[2] - p_calib[0]);
|
||||
val2 = (int64_t)p_lut[2] * (int64_t)(p_calib[0] - p_calib[1]) +
|
||||
(int64_t)p_lut[0] * (int64_t)(p_calib[1] - p_calib[2]) +
|
||||
(int64_t)p_lut[1] * (int64_t)(p_calib[2] - p_calib[0]);
|
||||
c = div64_s64(val1, val2);
|
||||
dev_dbg(&st->client->dev, "val1 = %lld, val2 = %lld, c = %lld\n",
|
||||
val1, val2, c);
|
||||
val1 = (int64_t)p_calib[0] * (int64_t)p_lut[0] -
|
||||
(int64_t)p_calib[1] * (int64_t)p_lut[1] -
|
||||
(int64_t)(p_calib[1] - p_calib[0]) * c;
|
||||
val2 = (int64_t)p_lut[0] - (int64_t)p_lut[1];
|
||||
a = div64_s64(val1, val2);
|
||||
dev_dbg(&st->client->dev, "val1 = %lld, val2 = %lld, a = %lld\n",
|
||||
val1, val2, a);
|
||||
b = ((int64_t)p_calib[0] - a) * ((int64_t)p_lut[0] + c);
|
||||
dev_dbg(&st->client->dev, "b = %lld\n", b);
|
||||
|
||||
/*
|
||||
* pressure_Pa = a + (b / (c + raw_pressure))
|
||||
* pressure_mPa = 1000 * pressure_Pa
|
||||
*/
|
||||
pressure_mPa = 1000LL * a + div64_s64(1000LL * b, c + raw_pressure);
|
||||
|
||||
return pressure_mPa;
|
||||
}
|
||||
|
||||
static int icp10100_read_raw_measures(struct iio_dev *indio_dev,
|
||||
struct iio_chan_spec const *chan,
|
||||
int *val, int *val2)
|
||||
{
|
||||
struct icp10100_state *st = iio_priv(indio_dev);
|
||||
uint32_t raw_pressure;
|
||||
uint16_t raw_temp;
|
||||
uint32_t pressure_mPa;
|
||||
int ret;
|
||||
|
||||
ret = iio_device_claim_direct_mode(indio_dev);
|
||||
if (ret)
|
||||
return ret;
|
||||
|
||||
ret = icp10100_get_measures(st, &raw_pressure, &raw_temp);
|
||||
if (ret)
|
||||
goto error_release;
|
||||
|
||||
switch (chan->type) {
|
||||
case IIO_PRESSURE:
|
||||
pressure_mPa = icp10100_get_pressure(st, raw_pressure,
|
||||
raw_temp);
|
||||
/* mPa to kPa */
|
||||
*val = pressure_mPa / 1000000;
|
||||
*val2 = pressure_mPa % 1000000;
|
||||
ret = IIO_VAL_INT_PLUS_MICRO;
|
||||
break;
|
||||
case IIO_TEMP:
|
||||
*val = raw_temp;
|
||||
ret = IIO_VAL_INT;
|
||||
break;
|
||||
default:
|
||||
ret = -EINVAL;
|
||||
break;
|
||||
};
|
||||
|
||||
error_release:
|
||||
iio_device_release_direct_mode(indio_dev);
|
||||
return ret;
|
||||
}
|
||||
|
||||
static int icp10100_read_raw(struct iio_dev *indio_dev,
|
||||
struct iio_chan_spec const *chan,
|
||||
int *val, int *val2, long mask)
|
||||
{
|
||||
struct icp10100_state *st = iio_priv(indio_dev);
|
||||
|
||||
switch (mask) {
|
||||
case IIO_CHAN_INFO_RAW:
|
||||
case IIO_CHAN_INFO_PROCESSED:
|
||||
return icp10100_read_raw_measures(indio_dev, chan, val, val2);
|
||||
case IIO_CHAN_INFO_SCALE:
|
||||
switch (chan->type) {
|
||||
case IIO_TEMP:
|
||||
/* 1000 * 175°C / 65536 in m°C */
|
||||
*val = 2;
|
||||
*val2 = 670288;
|
||||
return IIO_VAL_INT_PLUS_MICRO;
|
||||
default:
|
||||
return -EINVAL;
|
||||
}
|
||||
break;
|
||||
case IIO_CHAN_INFO_OFFSET:
|
||||
switch (chan->type) {
|
||||
case IIO_TEMP:
|
||||
/* 1000 * -45°C in m°C */
|
||||
*val = -45000;
|
||||
return IIO_VAL_INT;
|
||||
default:
|
||||
return -EINVAL;
|
||||
}
|
||||
break;
|
||||
case IIO_CHAN_INFO_OVERSAMPLING_RATIO:
|
||||
mutex_lock(&st->lock);
|
||||
*val = 1 << st->mode;
|
||||
mutex_unlock(&st->lock);
|
||||
return IIO_VAL_INT;
|
||||
default:
|
||||
return -EINVAL;
|
||||
}
|
||||
}
|
||||
|
||||
static int icp10100_read_avail(struct iio_dev *indio_dev,
|
||||
struct iio_chan_spec const *chan,
|
||||
const int **vals, int *type, int *length,
|
||||
long mask)
|
||||
{
|
||||
static int oversamplings[] = {1, 2, 4, 8};
|
||||
|
||||
switch (mask) {
|
||||
case IIO_CHAN_INFO_OVERSAMPLING_RATIO:
|
||||
*vals = oversamplings;
|
||||
*type = IIO_VAL_INT;
|
||||
*length = ARRAY_SIZE(oversamplings);
|
||||
return IIO_AVAIL_LIST;
|
||||
default:
|
||||
return -EINVAL;
|
||||
}
|
||||
}
|
||||
|
||||
static int icp10100_write_raw(struct iio_dev *indio_dev,
|
||||
struct iio_chan_spec const *chan,
|
||||
int val, int val2, long mask)
|
||||
{
|
||||
struct icp10100_state *st = iio_priv(indio_dev);
|
||||
unsigned int mode;
|
||||
int ret;
|
||||
|
||||
switch (mask) {
|
||||
case IIO_CHAN_INFO_OVERSAMPLING_RATIO:
|
||||
/* oversampling is always positive and a power of 2 */
|
||||
if (val <= 0 || !is_power_of_2(val))
|
||||
return -EINVAL;
|
||||
mode = ilog2(val);
|
||||
if (mode >= ICP10100_MODE_NB)
|
||||
return -EINVAL;
|
||||
ret = iio_device_claim_direct_mode(indio_dev);
|
||||
if (ret)
|
||||
return ret;
|
||||
mutex_lock(&st->lock);
|
||||
st->mode = mode;
|
||||
mutex_unlock(&st->lock);
|
||||
iio_device_release_direct_mode(indio_dev);
|
||||
return 0;
|
||||
default:
|
||||
return -EINVAL;
|
||||
}
|
||||
}
|
||||
|
||||
static int icp10100_write_raw_get_fmt(struct iio_dev *indio_dev,
|
||||
struct iio_chan_spec const *chan,
|
||||
long mask)
|
||||
{
|
||||
switch (mask) {
|
||||
case IIO_CHAN_INFO_OVERSAMPLING_RATIO:
|
||||
return IIO_VAL_INT;
|
||||
default:
|
||||
return -EINVAL;
|
||||
}
|
||||
}
|
||||
|
||||
static const struct iio_info icp10100_info = {
|
||||
.read_raw = icp10100_read_raw,
|
||||
.read_avail = icp10100_read_avail,
|
||||
.write_raw = icp10100_write_raw,
|
||||
.write_raw_get_fmt = icp10100_write_raw_get_fmt,
|
||||
};
|
||||
|
||||
static const struct iio_chan_spec icp10100_channels[] = {
|
||||
{
|
||||
.type = IIO_PRESSURE,
|
||||
.info_mask_separate = BIT(IIO_CHAN_INFO_PROCESSED),
|
||||
.info_mask_shared_by_all =
|
||||
BIT(IIO_CHAN_INFO_OVERSAMPLING_RATIO),
|
||||
.info_mask_shared_by_all_available =
|
||||
BIT(IIO_CHAN_INFO_OVERSAMPLING_RATIO),
|
||||
}, {
|
||||
.type = IIO_TEMP,
|
||||
.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_OVERSAMPLING_RATIO),
|
||||
.info_mask_shared_by_all_available =
|
||||
BIT(IIO_CHAN_INFO_OVERSAMPLING_RATIO),
|
||||
},
|
||||
};
|
||||
|
||||
static int icp10100_enable_regulator(struct icp10100_state *st)
|
||||
{
|
||||
int ret;
|
||||
|
||||
ret = regulator_enable(st->vdd);
|
||||
if (ret)
|
||||
return ret;
|
||||
msleep(100);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static void icp10100_disable_regulator_action(void *data)
|
||||
{
|
||||
struct icp10100_state *st = data;
|
||||
int ret;
|
||||
|
||||
ret = regulator_disable(st->vdd);
|
||||
if (ret)
|
||||
dev_err(&st->client->dev, "error %d disabling vdd\n", ret);
|
||||
}
|
||||
|
||||
static void icp10100_pm_disable(void *data)
|
||||
{
|
||||
struct device *dev = data;
|
||||
|
||||
pm_runtime_put_sync_suspend(dev);
|
||||
pm_runtime_disable(dev);
|
||||
}
|
||||
|
||||
static int icp10100_probe(struct i2c_client *client,
|
||||
const struct i2c_device_id *id)
|
||||
{
|
||||
struct iio_dev *indio_dev;
|
||||
struct icp10100_state *st;
|
||||
int ret;
|
||||
|
||||
if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) {
|
||||
dev_err(&client->dev, "plain i2c transactions not supported\n");
|
||||
return -ENODEV;
|
||||
}
|
||||
|
||||
indio_dev = devm_iio_device_alloc(&client->dev, sizeof(*st));
|
||||
if (!indio_dev)
|
||||
return -ENOMEM;
|
||||
|
||||
i2c_set_clientdata(client, indio_dev);
|
||||
indio_dev->dev.parent = &client->dev;
|
||||
indio_dev->name = client->name;
|
||||
indio_dev->modes = INDIO_DIRECT_MODE;
|
||||
indio_dev->channels = icp10100_channels;
|
||||
indio_dev->num_channels = ARRAY_SIZE(icp10100_channels);
|
||||
indio_dev->info = &icp10100_info;
|
||||
|
||||
st = iio_priv(indio_dev);
|
||||
mutex_init(&st->lock);
|
||||
st->client = client;
|
||||
st->mode = ICP10100_MODE_N;
|
||||
|
||||
st->vdd = devm_regulator_get(&client->dev, "vdd");
|
||||
if (IS_ERR(st->vdd))
|
||||
return PTR_ERR(st->vdd);
|
||||
|
||||
ret = icp10100_enable_regulator(st);
|
||||
if (ret)
|
||||
return ret;
|
||||
|
||||
ret = devm_add_action_or_reset(&client->dev,
|
||||
icp10100_disable_regulator_action, st);
|
||||
if (ret)
|
||||
return ret;
|
||||
|
||||
/* has to be done before the first i2c communication */
|
||||
crc8_populate_msb(icp10100_crc8_table, ICP10100_CRC8_POLYNOMIAL);
|
||||
|
||||
ret = icp10100_init_chip(st);
|
||||
if (ret) {
|
||||
dev_err(&client->dev, "init chip error %d\n", ret);
|
||||
return ret;
|
||||
}
|
||||
|
||||
/* enable runtime pm with autosuspend delay of 2s */
|
||||
pm_runtime_get_noresume(&client->dev);
|
||||
pm_runtime_set_active(&client->dev);
|
||||
pm_runtime_enable(&client->dev);
|
||||
pm_runtime_set_autosuspend_delay(&client->dev, 2000);
|
||||
pm_runtime_use_autosuspend(&client->dev);
|
||||
pm_runtime_put(&client->dev);
|
||||
ret = devm_add_action_or_reset(&client->dev, icp10100_pm_disable,
|
||||
&client->dev);
|
||||
if (ret)
|
||||
return ret;
|
||||
|
||||
return devm_iio_device_register(&client->dev, indio_dev);
|
||||
}
|
||||
|
||||
static int __maybe_unused icp10100_suspend(struct device *dev)
|
||||
{
|
||||
struct icp10100_state *st = iio_priv(dev_get_drvdata(dev));
|
||||
int ret;
|
||||
|
||||
mutex_lock(&st->lock);
|
||||
ret = regulator_disable(st->vdd);
|
||||
mutex_unlock(&st->lock);
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
static int __maybe_unused icp10100_resume(struct device *dev)
|
||||
{
|
||||
struct icp10100_state *st = iio_priv(dev_get_drvdata(dev));
|
||||
int ret;
|
||||
|
||||
mutex_lock(&st->lock);
|
||||
|
||||
ret = icp10100_enable_regulator(st);
|
||||
if (ret)
|
||||
goto out_unlock;
|
||||
|
||||
/* reset chip */
|
||||
ret = icp10100_send_cmd(st, &icp10100_cmd_soft_reset, NULL, 0);
|
||||
|
||||
out_unlock:
|
||||
mutex_unlock(&st->lock);
|
||||
return ret;
|
||||
}
|
||||
|
||||
static UNIVERSAL_DEV_PM_OPS(icp10100_pm, icp10100_suspend, icp10100_resume,
|
||||
NULL);
|
||||
|
||||
static const struct of_device_id icp10100_of_match[] = {
|
||||
{
|
||||
.compatible = "invensense,icp10100",
|
||||
},
|
||||
{ }
|
||||
};
|
||||
MODULE_DEVICE_TABLE(of, icp10100_of_match);
|
||||
|
||||
static const struct i2c_device_id icp10100_id[] = {
|
||||
{ "icp10100", 0 },
|
||||
{ }
|
||||
};
|
||||
MODULE_DEVICE_TABLE(i2c, icp10100_id);
|
||||
|
||||
static struct i2c_driver icp10100_driver = {
|
||||
.driver = {
|
||||
.name = "icp10100",
|
||||
.pm = &icp10100_pm,
|
||||
.of_match_table = of_match_ptr(icp10100_of_match),
|
||||
},
|
||||
.probe = icp10100_probe,
|
||||
.id_table = icp10100_id,
|
||||
};
|
||||
module_i2c_driver(icp10100_driver);
|
||||
|
||||
MODULE_AUTHOR("InvenSense, Inc.");
|
||||
MODULE_DESCRIPTION("InvenSense icp10100 driver");
|
||||
MODULE_LICENSE("GPL");
|
||||
Loading…
Reference in New Issue