mirror of
https://git.kernel.org/pub/scm/linux/kernel/git/stable/linux.git
synced 2024-08-22 00:40:03 +00:00
d3be83244c
This patch applies the semantic patch: @@ expression I, P, SP; @@ I = devm_iio_device_alloc(P, SP); ... - I->dev.parent = P; It updates 302 files and does 307 deletions. This semantic patch also removes some comments like '/* Establish that the iio_dev is a child of the i2c device */' But this is is only done in case where the block is left empty. The patch does not seem to cover all cases. It looks like in some cases a different variable is used in some cases to assign the parent, but it points to the same reference. In other cases, the block covered by ... may be just too big to be covered by the semantic patch. However, this looks pretty good as well, as it does cover a big bulk of the drivers that should remove the parent assignment. Signed-off-by: Alexandru Ardelean <alexandru.ardelean@analog.com> Signed-off-by: Jonathan Cameron <Jonathan.Cameron@huawei.com>
270 lines
6.2 KiB
C
270 lines
6.2 KiB
C
// SPDX-License-Identifier: GPL-2.0-only
|
|
/*
|
|
* t5403.c - Support for EPCOS T5403 pressure/temperature sensor
|
|
*
|
|
* Copyright (c) 2014 Peter Meerwald <pmeerw@pmeerw.net>
|
|
*
|
|
* (7-bit I2C slave address 0x77)
|
|
*
|
|
* TODO: end-of-conversion irq
|
|
*/
|
|
|
|
#include <linux/module.h>
|
|
#include <linux/i2c.h>
|
|
#include <linux/iio/iio.h>
|
|
#include <linux/iio/sysfs.h>
|
|
#include <linux/delay.h>
|
|
|
|
#define T5403_DATA 0xf5 /* data, LSB first, 16 bit */
|
|
#define T5403_CALIB_DATA 0x8e /* 10 calibration coeff., LSB first, 16 bit */
|
|
#define T5403_SLAVE_ADDR 0x88 /* I2C slave address, 0x77 */
|
|
#define T5403_COMMAND 0xf1
|
|
|
|
/* command bits */
|
|
#define T5403_MODE_SHIFT 3 /* conversion time: 2, 8, 16, 66 ms */
|
|
#define T5403_PT BIT(1) /* 0 .. pressure, 1 .. temperature measurement */
|
|
#define T5403_SCO BIT(0) /* start conversion */
|
|
|
|
#define T5403_MODE_LOW 0
|
|
#define T5403_MODE_STANDARD 1
|
|
#define T5403_MODE_HIGH 2
|
|
#define T5403_MODE_ULTRA_HIGH 3
|
|
|
|
#define T5403_I2C_MASK (~BIT(7))
|
|
#define T5403_I2C_ADDR 0x77
|
|
|
|
static const int t5403_pressure_conv_ms[] = {2, 8, 16, 66};
|
|
|
|
struct t5403_data {
|
|
struct i2c_client *client;
|
|
struct mutex lock;
|
|
int mode;
|
|
__le16 c[10];
|
|
};
|
|
|
|
#define T5403_C_U16(i) le16_to_cpu(data->c[(i) - 1])
|
|
#define T5403_C(i) sign_extend32(T5403_C_U16(i), 15)
|
|
|
|
static int t5403_read(struct t5403_data *data, bool pressure)
|
|
{
|
|
int wait_time = 3; /* wakeup time in ms */
|
|
|
|
int ret = i2c_smbus_write_byte_data(data->client, T5403_COMMAND,
|
|
(pressure ? (data->mode << T5403_MODE_SHIFT) : T5403_PT) |
|
|
T5403_SCO);
|
|
if (ret < 0)
|
|
return ret;
|
|
|
|
wait_time += pressure ? t5403_pressure_conv_ms[data->mode] : 2;
|
|
|
|
msleep(wait_time);
|
|
|
|
return i2c_smbus_read_word_data(data->client, T5403_DATA);
|
|
}
|
|
|
|
static int t5403_comp_pressure(struct t5403_data *data, int *val, int *val2)
|
|
{
|
|
int ret;
|
|
s16 t_r;
|
|
u16 p_r;
|
|
s32 S, O, X;
|
|
|
|
mutex_lock(&data->lock);
|
|
|
|
ret = t5403_read(data, false);
|
|
if (ret < 0)
|
|
goto done;
|
|
t_r = ret;
|
|
|
|
ret = t5403_read(data, true);
|
|
if (ret < 0)
|
|
goto done;
|
|
p_r = ret;
|
|
|
|
/* see EPCOS application note */
|
|
S = T5403_C_U16(3) + (s32) T5403_C_U16(4) * t_r / 0x20000 +
|
|
T5403_C(5) * t_r / 0x8000 * t_r / 0x80000 +
|
|
T5403_C(9) * t_r / 0x8000 * t_r / 0x8000 * t_r / 0x10000;
|
|
|
|
O = T5403_C(6) * 0x4000 + T5403_C(7) * t_r / 8 +
|
|
T5403_C(8) * t_r / 0x8000 * t_r / 16 +
|
|
T5403_C(9) * t_r / 0x8000 * t_r / 0x10000 * t_r;
|
|
|
|
X = (S * p_r + O) / 0x4000;
|
|
|
|
X += ((X - 75000) * (X - 75000) / 0x10000 - 9537) *
|
|
T5403_C(10) / 0x10000;
|
|
|
|
*val = X / 1000;
|
|
*val2 = (X % 1000) * 1000;
|
|
|
|
done:
|
|
mutex_unlock(&data->lock);
|
|
return ret;
|
|
}
|
|
|
|
static int t5403_comp_temp(struct t5403_data *data, int *val)
|
|
{
|
|
int ret;
|
|
s16 t_r;
|
|
|
|
mutex_lock(&data->lock);
|
|
ret = t5403_read(data, false);
|
|
if (ret < 0)
|
|
goto done;
|
|
t_r = ret;
|
|
|
|
/* see EPCOS application note */
|
|
*val = ((s32) T5403_C_U16(1) * t_r / 0x100 +
|
|
(s32) T5403_C_U16(2) * 0x40) * 1000 / 0x10000;
|
|
|
|
done:
|
|
mutex_unlock(&data->lock);
|
|
return ret;
|
|
}
|
|
|
|
static int t5403_read_raw(struct iio_dev *indio_dev,
|
|
struct iio_chan_spec const *chan,
|
|
int *val, int *val2, long mask)
|
|
{
|
|
struct t5403_data *data = iio_priv(indio_dev);
|
|
int ret;
|
|
|
|
switch (mask) {
|
|
case IIO_CHAN_INFO_PROCESSED:
|
|
switch (chan->type) {
|
|
case IIO_PRESSURE:
|
|
ret = t5403_comp_pressure(data, val, val2);
|
|
if (ret < 0)
|
|
return ret;
|
|
return IIO_VAL_INT_PLUS_MICRO;
|
|
case IIO_TEMP:
|
|
ret = t5403_comp_temp(data, val);
|
|
if (ret < 0)
|
|
return ret;
|
|
return IIO_VAL_INT;
|
|
default:
|
|
return -EINVAL;
|
|
}
|
|
case IIO_CHAN_INFO_INT_TIME:
|
|
*val = 0;
|
|
*val2 = t5403_pressure_conv_ms[data->mode] * 1000;
|
|
return IIO_VAL_INT_PLUS_MICRO;
|
|
default:
|
|
return -EINVAL;
|
|
}
|
|
}
|
|
|
|
static int t5403_write_raw(struct iio_dev *indio_dev,
|
|
struct iio_chan_spec const *chan,
|
|
int val, int val2, long mask)
|
|
{
|
|
struct t5403_data *data = iio_priv(indio_dev);
|
|
int i;
|
|
|
|
switch (mask) {
|
|
case IIO_CHAN_INFO_INT_TIME:
|
|
if (val != 0)
|
|
return -EINVAL;
|
|
for (i = 0; i < ARRAY_SIZE(t5403_pressure_conv_ms); i++)
|
|
if (val2 == t5403_pressure_conv_ms[i] * 1000) {
|
|
mutex_lock(&data->lock);
|
|
data->mode = i;
|
|
mutex_unlock(&data->lock);
|
|
return 0;
|
|
}
|
|
return -EINVAL;
|
|
default:
|
|
return -EINVAL;
|
|
}
|
|
}
|
|
|
|
static const struct iio_chan_spec t5403_channels[] = {
|
|
{
|
|
.type = IIO_PRESSURE,
|
|
.info_mask_separate = BIT(IIO_CHAN_INFO_PROCESSED) |
|
|
BIT(IIO_CHAN_INFO_INT_TIME),
|
|
},
|
|
{
|
|
.type = IIO_TEMP,
|
|
.info_mask_separate = BIT(IIO_CHAN_INFO_PROCESSED),
|
|
},
|
|
};
|
|
|
|
static IIO_CONST_ATTR_INT_TIME_AVAIL("0.002 0.008 0.016 0.066");
|
|
|
|
static struct attribute *t5403_attributes[] = {
|
|
&iio_const_attr_integration_time_available.dev_attr.attr,
|
|
NULL
|
|
};
|
|
|
|
static const struct attribute_group t5403_attribute_group = {
|
|
.attrs = t5403_attributes,
|
|
};
|
|
|
|
static const struct iio_info t5403_info = {
|
|
.read_raw = &t5403_read_raw,
|
|
.write_raw = &t5403_write_raw,
|
|
.attrs = &t5403_attribute_group,
|
|
};
|
|
|
|
static int t5403_probe(struct i2c_client *client,
|
|
const struct i2c_device_id *id)
|
|
{
|
|
struct t5403_data *data;
|
|
struct iio_dev *indio_dev;
|
|
int ret;
|
|
|
|
if (!i2c_check_functionality(client->adapter, I2C_FUNC_SMBUS_WORD_DATA |
|
|
I2C_FUNC_SMBUS_I2C_BLOCK))
|
|
return -EOPNOTSUPP;
|
|
|
|
ret = i2c_smbus_read_byte_data(client, T5403_SLAVE_ADDR);
|
|
if (ret < 0)
|
|
return ret;
|
|
if ((ret & T5403_I2C_MASK) != T5403_I2C_ADDR)
|
|
return -ENODEV;
|
|
|
|
indio_dev = devm_iio_device_alloc(&client->dev, sizeof(*data));
|
|
if (!indio_dev)
|
|
return -ENOMEM;
|
|
|
|
data = iio_priv(indio_dev);
|
|
data->client = client;
|
|
mutex_init(&data->lock);
|
|
|
|
i2c_set_clientdata(client, indio_dev);
|
|
indio_dev->info = &t5403_info;
|
|
indio_dev->name = id->name;
|
|
indio_dev->modes = INDIO_DIRECT_MODE;
|
|
indio_dev->channels = t5403_channels;
|
|
indio_dev->num_channels = ARRAY_SIZE(t5403_channels);
|
|
|
|
data->mode = T5403_MODE_STANDARD;
|
|
|
|
ret = i2c_smbus_read_i2c_block_data(data->client, T5403_CALIB_DATA,
|
|
sizeof(data->c), (u8 *) data->c);
|
|
if (ret < 0)
|
|
return ret;
|
|
|
|
return devm_iio_device_register(&client->dev, indio_dev);
|
|
}
|
|
|
|
static const struct i2c_device_id t5403_id[] = {
|
|
{ "t5403", 0 },
|
|
{ }
|
|
};
|
|
MODULE_DEVICE_TABLE(i2c, t5403_id);
|
|
|
|
static struct i2c_driver t5403_driver = {
|
|
.driver = {
|
|
.name = "t5403",
|
|
},
|
|
.probe = t5403_probe,
|
|
.id_table = t5403_id,
|
|
};
|
|
module_i2c_driver(t5403_driver);
|
|
|
|
MODULE_AUTHOR("Peter Meerwald <pmeerw@pmeerw.net>");
|
|
MODULE_DESCRIPTION("EPCOS T5403 pressure/temperature sensor driver");
|
|
MODULE_LICENSE("GPL");
|