#include <linux/array_size.h>
#include <linux/bitops.h>
#include <linux/cleanup.h>
#include <linux/crc8.h>
#include <linux/delay.h>
#include <linux/dev_printk.h>
#include <linux/device.h>
#include <linux/err.h>
#include <linux/errno.h>
#include <linux/i2c.h>
#include <linux/math.h>
#include <linux/math64.h>
#include <linux/module.h>
#include <linux/mutex.h>
#include <linux/pm.h>
#include <linux/regulator/consumer.h>
#include <linux/types.h>
#include <linux/unaligned.h>
#include <linux/units.h>
#include <linux/iio/iio.h>
#define SLF3S_CRC8_POLY 0x31
#define SLF3S_CRC8_INIT 0xff
#define SLF3S_PRODUCT_ID_LEN 18
#define SLF3S_PRODUCT_FAMILY_BYTE 1
#define SLF3S_PRODUCT_SUBTYPE_BYTE 3
#define SLF3S_PRODUCT_FAMILY_ID 0x03
#define SLF3S_POWER_UP_DELAY_US (25 * USEC_PER_MSEC)
#define SLF3S_MEAS_START_DELAY_US (60 * USEC_PER_MSEC)
static const u8 slf3s_cmd_prep_pid[] = { 0x36, 0x7c };
static const u8 slf3s_cmd_read_pid[] = { 0xe1, 0x02 };
static const u8 slf3s_cmd_start_water[] = { 0x36, 0x08 };
static const u8 slf3s_cmd_start_ipa[] = { 0x36, 0x15 };
static const u8 slf3s_cmd_stop_meas[] = { 0x3f, 0xf9 };
enum slf3s_medium {
SLF3S_MEDIUM_WATER,
SLF3S_MEDIUM_IPA,
};
static const char * const slf3s_medium_modes[] = {
[SLF3S_MEDIUM_WATER] = "water",
[SLF3S_MEDIUM_IPA] = "ipa",
};
enum slf3s_variant_id {
SLF3S_0600F,
SLF3S_1300F,
SLF3S_4000B,
};
struct slf3s_variant {
u8 sub_type;
const char *name;
struct s32_fract scale;
};
static const struct slf3s_variant slf3s_variants[] = {
[SLF3S_0600F] = {
.sub_type = 0x03,
.name = "slf3s-0600f",
.scale = { .numerator = 1, .denominator = 600 * MICRO },
},
[SLF3S_1300F] = {
.sub_type = 0x02,
.name = "slf3s-1300f",
.scale = { .numerator = 1, .denominator = 30 * MICRO },
},
[SLF3S_4000B] = {
.sub_type = 0x05,
.name = "slf3s-4000b",
.scale = { .numerator = 1, .denominator = 1920 * MILLI },
},
};
struct slf3s_data {
struct i2c_client *client;
struct regulator *vdd;
const struct slf3s_variant *variant;
enum slf3s_medium medium;
struct mutex lock;
u8 crc_table[CRC8_TABLE_SIZE];
};
static int slf3s_send_cmd(struct i2c_client *client, const u8 *cmd)
{
int ret;
ret = i2c_master_send(client, cmd, 2);
if (ret < 0)
return ret;
if (ret != 2)
return -EIO;
return 0;
}
static int slf3s_start_meas(struct slf3s_data *sf, enum slf3s_medium medium)
{
const u8 *cmd = (medium == SLF3S_MEDIUM_IPA) ? slf3s_cmd_start_ipa
: slf3s_cmd_start_water;
int ret;
ret = slf3s_send_cmd(sf->client, cmd);
if (ret)
return ret;
fsleep(SLF3S_MEAS_START_DELAY_US);
return 0;
}
static bool slf3s_crc_valid(const struct slf3s_data *sf, const u8 *block)
{
return crc8(sf->crc_table, block, 2, SLF3S_CRC8_INIT) == block[2];
}
static int slf3s_detect_variant(struct slf3s_data *sf)
{
struct i2c_client *client = sf->client;
u8 buf[SLF3S_PRODUCT_ID_LEN];
int ret;
ret = slf3s_send_cmd(client, slf3s_cmd_prep_pid);
if (ret)
return ret;
ret = slf3s_send_cmd(client, slf3s_cmd_read_pid);
if (ret)
return ret;
ret = i2c_master_recv(client, buf, sizeof(buf));
if (ret < 0)
return ret;
if (ret != sizeof(buf))
return -EIO;
for (unsigned int i = 0; i < SLF3S_PRODUCT_ID_LEN; i += 3) {
if (!slf3s_crc_valid(sf, &buf[i]))
return -EIO;
}
if (buf[SLF3S_PRODUCT_FAMILY_BYTE] != SLF3S_PRODUCT_FAMILY_ID)
dev_info(&client->dev,
"unexpected family byte 0x%02x (expected 0x%02x)\n",
buf[SLF3S_PRODUCT_FAMILY_BYTE],
SLF3S_PRODUCT_FAMILY_ID);
for (unsigned int i = 0; i < ARRAY_SIZE(slf3s_variants); i++) {
if (buf[SLF3S_PRODUCT_SUBTYPE_BYTE] !=
slf3s_variants[i].sub_type)
continue;
if (sf->variant && sf->variant != &slf3s_variants[i])
dev_info(&client->dev,
"DT compatible says %s but sensor reports %s; using the latter\n",
sf->variant->name,
slf3s_variants[i].name);
sf->variant = &slf3s_variants[i];
return 0;
}
if (sf->variant) {
dev_warn(&client->dev,
"unknown SLF3S sub-type 0x%02x, assuming %s\n",
buf[SLF3S_PRODUCT_SUBTYPE_BYTE], sf->variant->name);
return 0;
}
dev_err(&client->dev, "unknown SLF3S sub-type 0x%02x\n",
buf[SLF3S_PRODUCT_SUBTYPE_BYTE]);
return -ENODEV;
}
static int slf3s_read_sample(struct slf3s_data *sf, int *flow, int *temp)
{
u8 buf[6];
int ret;
ret = i2c_master_recv(sf->client, buf, sizeof(buf));
if (ret < 0)
return ret;
if (ret != sizeof(buf))
return -EIO;
for (unsigned int i = 0; i < sizeof(buf); i += 3) {
if (!slf3s_crc_valid(sf, &buf[i]))
return -EIO;
}
*flow = sign_extend32(get_unaligned_be16(&buf[0]), 15);
*temp = sign_extend32(get_unaligned_be16(&buf[3]), 15);
return 0;
}
static int slf3s_get_medium(struct iio_dev *indio_dev,
const struct iio_chan_spec *chan)
{
struct slf3s_data *sf = iio_priv(indio_dev);
return sf->medium;
}
static int slf3s_set_medium(struct iio_dev *indio_dev,
const struct iio_chan_spec *chan, unsigned int mode)
{
struct slf3s_data *sf = iio_priv(indio_dev);
int ret;
guard(mutex)(&sf->lock);
ret = slf3s_send_cmd(sf->client, slf3s_cmd_stop_meas);
if (ret)
return ret;
ret = slf3s_start_meas(sf, mode);
if (ret) {
if (slf3s_start_meas(sf, sf->medium))
dev_warn(&sf->client->dev,
"failed to restart measurement, reads will fail until a medium is set\n");
return ret;
}
sf->medium = mode;
return 0;
}
static const struct iio_enum slf3s_medium_enum = {
.items = slf3s_medium_modes,
.num_items = ARRAY_SIZE(slf3s_medium_modes),
.get = slf3s_get_medium,
.set = slf3s_set_medium,
};
static const struct iio_chan_spec_ext_info slf3s_ext_info[] = {
IIO_ENUM("medium", IIO_SHARED_BY_TYPE, &slf3s_medium_enum),
IIO_ENUM_AVAILABLE("medium", IIO_SHARED_BY_TYPE, &slf3s_medium_enum),
{ }
};
static const struct iio_chan_spec slf3s_channels[] = {
{
.type = IIO_VOLUMEFLOW,
.info_mask_separate = BIT(IIO_CHAN_INFO_RAW) |
BIT(IIO_CHAN_INFO_SCALE),
.ext_info = slf3s_ext_info,
},
{
.type = IIO_TEMP,
.info_mask_separate = BIT(IIO_CHAN_INFO_RAW) |
BIT(IIO_CHAN_INFO_SCALE),
},
};
static int slf3s_read_raw(struct iio_dev *indio_dev,
struct iio_chan_spec const *chan, int *val,
int *val2, long mask)
{
struct slf3s_data *sf = iio_priv(indio_dev);
int flow, temp, ret;
switch (mask) {
case IIO_CHAN_INFO_RAW:
scoped_guard(mutex, &sf->lock)
ret = slf3s_read_sample(sf, &flow, &temp);
if (ret)
return ret;
*val = (chan->type == IIO_VOLUMEFLOW) ? flow : temp;
return IIO_VAL_INT;
case IIO_CHAN_INFO_SCALE:
if (chan->type == IIO_VOLUMEFLOW) {
const struct slf3s_variant *v = sf->variant;
s64 num = (s64)v->scale.numerator * (FEMTO / MILLI);
s64 scale = DIV_S64_ROUND_CLOSEST(num,
v->scale.denominator);
iio_val_s64_decompose(scale, val, val2);
return IIO_VAL_DECIMAL64_FEMTO;
}
*val = MILLIDEGREE_PER_DEGREE / 200;
return IIO_VAL_INT;
default:
return -EINVAL;
}
}
static const struct iio_info slf3s_info = {
.read_raw = slf3s_read_raw,
};
static void slf3s_stop_meas(void *data)
{
struct slf3s_data *sf = data;
slf3s_send_cmd(sf->client, slf3s_cmd_stop_meas);
}
static void slf3s_disable_vdd(void *data)
{
struct slf3s_data *sf = data;
regulator_disable(sf->vdd);
}
static int slf3s_probe(struct i2c_client *client)
{
struct device *dev = &client->dev;
struct iio_dev *indio_dev;
struct slf3s_data *sf;
int ret;
indio_dev = devm_iio_device_alloc(dev, sizeof(*sf));
if (!indio_dev)
return -ENOMEM;
sf = iio_priv(indio_dev);
sf->client = client;
i2c_set_clientdata(client, indio_dev);
sf->variant = i2c_get_match_data(client);
sf->medium = SLF3S_MEDIUM_WATER;
crc8_populate_msb(sf->crc_table, SLF3S_CRC8_POLY);
ret = devm_mutex_init(dev, &sf->lock);
if (ret)
return ret;
sf->vdd = devm_regulator_get(dev, "vdd");
if (IS_ERR(sf->vdd))
return dev_err_probe(dev, PTR_ERR(sf->vdd),
"failed to get vdd supply\n");
ret = regulator_enable(sf->vdd);
if (ret)
return dev_err_probe(dev, ret, "failed to enable vdd supply\n");
ret = devm_add_action_or_reset(dev, slf3s_disable_vdd, sf);
if (ret)
return ret;
fsleep(SLF3S_POWER_UP_DELAY_US);
slf3s_send_cmd(client, slf3s_cmd_stop_meas);
ret = slf3s_detect_variant(sf);
if (ret)
return dev_err_probe(dev, ret, "product info read failed\n");
ret = slf3s_start_meas(sf, sf->medium);
if (ret)
return dev_err_probe(dev, ret,
"failed to start measurement\n");
ret = devm_add_action_or_reset(dev, slf3s_stop_meas, sf);
if (ret)
return ret;
indio_dev->name = sf->variant->name;
indio_dev->channels = slf3s_channels;
indio_dev->num_channels = ARRAY_SIZE(slf3s_channels);
indio_dev->info = &slf3s_info;
indio_dev->modes = INDIO_DIRECT_MODE;
return devm_iio_device_register(dev, indio_dev);
}
static int slf3s_suspend(struct device *dev)
{
struct iio_dev *indio_dev = dev_get_drvdata(dev);
struct slf3s_data *sf = iio_priv(indio_dev);
int ret;
guard(mutex)(&sf->lock);
ret = slf3s_send_cmd(sf->client, slf3s_cmd_stop_meas);
if (ret)
return ret;
return regulator_disable(sf->vdd);
}
static int slf3s_resume(struct device *dev)
{
struct iio_dev *indio_dev = dev_get_drvdata(dev);
struct slf3s_data *sf = iio_priv(indio_dev);
int ret;
guard(mutex)(&sf->lock);
ret = regulator_enable(sf->vdd);
if (ret)
return ret;
fsleep(SLF3S_POWER_UP_DELAY_US);
return slf3s_start_meas(sf, sf->medium);
}
static DEFINE_SIMPLE_DEV_PM_OPS(slf3s_pm_ops, slf3s_suspend, slf3s_resume);
static const struct i2c_device_id slf3s_id[] = {
{
.name = "slf3s-0600f",
.driver_data = (kernel_ulong_t)&slf3s_variants[SLF3S_0600F],
},
{
.name = "slf3s-1300f",
.driver_data = (kernel_ulong_t)&slf3s_variants[SLF3S_1300F],
},
{
.name = "slf3s-4000b",
.driver_data = (kernel_ulong_t)&slf3s_variants[SLF3S_4000B],
},
{ }
};
MODULE_DEVICE_TABLE(i2c, slf3s_id);
static const struct of_device_id slf3s_of_match[] = {
{
.compatible = "sensirion,slf3s-0600f",
.data = &slf3s_variants[SLF3S_0600F],
},
{
.compatible = "sensirion,slf3s-1300f",
.data = &slf3s_variants[SLF3S_1300F],
},
{
.compatible = "sensirion,slf3s-4000b",
.data = &slf3s_variants[SLF3S_4000B],
},
{ }
};
MODULE_DEVICE_TABLE(of, slf3s_of_match);
static struct i2c_driver slf3s_driver = {
.driver = {
.name = "slf3s",
.of_match_table = slf3s_of_match,
.pm = pm_sleep_ptr(&slf3s_pm_ops),
},
.probe = slf3s_probe,
.id_table = slf3s_id,
};
module_i2c_driver(slf3s_driver);
MODULE_AUTHOR("Wadim Mueller <wafgo01@gmail.com>");
MODULE_DESCRIPTION("Sensirion SLF3S liquid flow sensor driver");
MODULE_LICENSE("GPL"