linux/drivers/iio/pressure/rohm-bm1390.c

// SPDX-License-Identifier: GPL-2.0-only
/*
 * BM1390 ROHM pressure sensor
 *
 * Copyright (c) 2023, ROHM Semiconductor.
 * https://fscdn.rohm.com/en/products/databook/datasheet/ic/sensor/pressure/bm1390glv-z-e.pdf
 */

#include <linux/bitfield.h>
#include <linux/bits.h>
#include <linux/device.h>
#include <linux/i2c.h>
#include <linux/module.h>
#include <linux/regmap.h>
#include <linux/regulator/consumer.h>

#include <linux/iio/iio.h>
#include <linux/iio/trigger.h>
#include <linux/iio/trigger_consumer.h>
#include <linux/iio/triggered_buffer.h>

#define BM1390_REG_MANUFACT_ID		0x0f
#define BM1390_REG_PART_ID		0x10
#define BM1390_REG_POWER		0x12
#define BM1390_MASK_POWER		BIT(0)
#define BM1390_POWER_ON			BM1390_MASK_POWER
#define BM1390_POWER_OFF		0x00
#define BM1390_REG_RESET		0x13
#define BM1390_MASK_RESET		BIT(0)
#define BM1390_RESET_RELEASE		BM1390_MASK_RESET
#define BM1390_RESET			0x00
#define BM1390_REG_MODE_CTRL		0x14
#define BM1390_MASK_MEAS_MODE		GENMASK(1, 0)
#define BM1390_MASK_DRDY_EN		BIT(4)
#define BM1390_MASK_WMI_EN		BIT(2)
#define BM1390_MASK_AVE_NUM		GENMASK(7, 5)

/*
 * Data-sheet states that when the IIR is used, the AVE_NUM must be set to
 * value 110b
 */
#define BM1390_IIR_AVE_NUM		0x06
#define BM1390_REG_FIFO_CTRL		0x15
#define BM1390_MASK_IIR_MODE		GENMASK(1, 0)
#define BM1390_IIR_MODE_OFF		0x0
#define BM1390_IIR_MODE_WEAK		0x1
#define BM1390_IIR_MODE_MID		0x2
#define BM1390_IIR_MODE_STRONG		0x3

#define BM1390_MASK_FIFO_LEN		BIT(6)
#define BM1390_MASK_FIFO_EN		BIT(7)
#define BM1390_WMI_MIN			2
#define BM1390_WMI_MAX			3

#define BM1390_REG_FIFO_LVL		0x18
#define BM1390_MASK_FIFO_LVL		GENMASK(2, 0)
#define BM1390_REG_STATUS		0x19
#define BM1390_REG_PRESSURE_BASE	0x1a
#define BM1390_REG_TEMP_HI		0x1d
#define BM1390_REG_TEMP_LO		0x1e
#define BM1390_MAX_REGISTER		BM1390_REG_TEMP_LO

#define BM1390_ID			0x34

/* Regmap configs */
static const struct regmap_range bm1390_volatile_ranges[] = {
	{
		.range_min = BM1390_REG_STATUS,
		.range_max = BM1390_REG_STATUS,
	},
	{
		.range_min = BM1390_REG_FIFO_LVL,
		.range_max = BM1390_REG_TEMP_LO,
	},
};

static const struct regmap_access_table bm1390_volatile_regs = {
	.yes_ranges = &bm1390_volatile_ranges[0],
	.n_yes_ranges = ARRAY_SIZE(bm1390_volatile_ranges),
};

static const struct regmap_range bm1390_precious_ranges[] = {
	{
		.range_min = BM1390_REG_STATUS,
		.range_max = BM1390_REG_STATUS,
	},
};

static const struct regmap_access_table bm1390_precious_regs = {
	.yes_ranges = &bm1390_precious_ranges[0],
	.n_yes_ranges = ARRAY_SIZE(bm1390_precious_ranges),
};

static const struct regmap_range bm1390_read_only_ranges[] = {
	{
		.range_min = BM1390_REG_MANUFACT_ID,
		.range_max = BM1390_REG_PART_ID,
	}, {
		.range_min = BM1390_REG_FIFO_LVL,
		.range_max = BM1390_REG_TEMP_LO,
	},
};

static const struct regmap_access_table bm1390_ro_regs = {
	.no_ranges = &bm1390_read_only_ranges[0],
	.n_no_ranges = ARRAY_SIZE(bm1390_read_only_ranges),
};

static const struct regmap_range bm1390_noinc_read_ranges[] = {
	{
		.range_min = BM1390_REG_PRESSURE_BASE,
		.range_max = BM1390_REG_TEMP_LO,
	},
};

static const struct regmap_access_table bm1390_nir_regs = {
	.yes_ranges = &bm1390_noinc_read_ranges[0],
	.n_yes_ranges = ARRAY_SIZE(bm1390_noinc_read_ranges),
};

static const struct regmap_config bm1390_regmap = {
	.reg_bits = 8,
	.val_bits = 8,
	.volatile_table = &bm1390_volatile_regs,
	.wr_table = &bm1390_ro_regs,
	.rd_noinc_table = &bm1390_nir_regs,
	.precious_table = &bm1390_precious_regs,
	.max_register = BM1390_MAX_REGISTER,
	.cache_type = REGCACHE_RBTREE,
	.disable_locking = true,
};

enum {
	BM1390_STATE_SAMPLE,
	BM1390_STATE_FIFO,
};

struct bm1390_data_buf {
	u32 pressure;
	__be16 temp;
	s64 ts __aligned(8);
};

/* BM1390 has FIFO for 4 pressure samples */
#define BM1390_FIFO_LENGTH	4

struct bm1390_data {
	s64 timestamp, old_timestamp;
	struct iio_trigger *trig;
	struct regmap *regmap;
	struct device *dev;
	struct bm1390_data_buf buf;
	int irq;
	unsigned int state;
	bool trigger_enabled;
	u8 watermark;

	/* Prevent accessing sensor during FIFO read sequence */
	struct mutex mutex;
};

enum {
	BM1390_CHAN_PRESSURE,
	BM1390_CHAN_TEMP,
};

static const struct iio_chan_spec bm1390_channels[] = {
	{
		.type = IIO_PRESSURE,
		.info_mask_separate = BIT(IIO_CHAN_INFO_RAW),
		/*
		 * When IIR is used, we must fix amount of averaged samples.
		 * Thus we don't allow setting oversampling ratio.
		 */
		.info_mask_shared_by_type = BIT(IIO_CHAN_INFO_SCALE),
		.scan_index = BM1390_CHAN_PRESSURE,
		.scan_type = {
			.sign = 'u',
			.realbits = 22,
			.storagebits = 32,
			.endianness = IIO_LE,
		},
	},
	{
		.type = IIO_TEMP,
		.info_mask_separate = BIT(IIO_CHAN_INFO_RAW),
		.info_mask_shared_by_type = BIT(IIO_CHAN_INFO_SCALE),
		.scan_index = BM1390_CHAN_TEMP,
		.scan_type = {
			.sign = 's',
			.realbits = 16,
			.storagebits = 16,
			.endianness = IIO_BE,
		},
	},
	IIO_CHAN_SOFT_TIMESTAMP(2),
};

/*
 * We can't skip reading the pressure because the watermark IRQ is acked
 * only when the pressure data is read from the FIFO.
 */
static const unsigned long bm1390_scan_masks[] = {
	BIT(BM1390_CHAN_PRESSURE),
	BIT(BM1390_CHAN_PRESSURE) | BIT(BM1390_CHAN_TEMP),
	0
};

static int bm1390_read_temp(struct bm1390_data *data, int *temp)
{
	__be16 temp_raw;
	int ret;

	ret = regmap_bulk_read(data->regmap, BM1390_REG_TEMP_HI, &temp_raw,
			       sizeof(temp_raw));
	if (ret)
		return ret;

	*temp = be16_to_cpu(temp_raw);

	return 0;
}

static int bm1390_pressure_read(struct bm1390_data *data, u32 *pressure)
{
	/* Pressure data is in 3 8-bit registers */
	u8 raw[3];
	int ret;

	ret = regmap_bulk_read(data->regmap, BM1390_REG_PRESSURE_BASE,
			       raw, sizeof(raw));
	if (ret < 0)
		return ret;

	*pressure = (u32)(raw[2] >> 2 | raw[1] << 6 | raw[0] << 14);

	return 0;
}

 /* The enum values map directly to register bits */
enum bm1390_meas_mode {
	BM1390_MEAS_MODE_STOP = 0x0,
	BM1390_MEAS_MODE_1SHOT = 0x1,
	BM1390_MEAS_MODE_CONTINUOUS = 0x2,
};

static int bm1390_meas_set(struct bm1390_data *data, enum bm1390_meas_mode mode)
{
	return regmap_update_bits(data->regmap, BM1390_REG_MODE_CTRL,
				  BM1390_MASK_MEAS_MODE, mode);
}

/*
 * If the trigger is not used we just wait until the measurement has
 * completed. The data-sheet says maximum measurement cycle (regardless
 * the AVE_NUM) is 200 mS so let's just sleep at least that long. If speed
 * is needed the trigger should be used.
 */
#define BM1390_MAX_MEAS_TIME_MS 205

static int bm1390_read_data(struct bm1390_data *data,
			struct iio_chan_spec const *chan, int *val, int *val2)
{
	int ret, warn;

	mutex_lock(&data->mutex);
	/*
	 * We use 'continuous mode' even for raw read because according to the
	 * data-sheet an one-shot mode can't be used with IIR filter.
	 */
	ret = bm1390_meas_set(data, BM1390_MEAS_MODE_CONTINUOUS);
	if (ret)
		goto unlock_out;

	switch (chan->type) {
	case IIO_PRESSURE:
		msleep(BM1390_MAX_MEAS_TIME_MS);
		ret = bm1390_pressure_read(data, val);
		break;
	case IIO_TEMP:
		msleep(BM1390_MAX_MEAS_TIME_MS);
		ret = bm1390_read_temp(data, val);
		break;
	default:
		ret = -EINVAL;
	}
	warn = bm1390_meas_set(data, BM1390_MEAS_MODE_STOP);
	if (warn)
		dev_warn(data->dev, "Failed to stop measurement (%d)\n", warn);
unlock_out:
	mutex_unlock(&data->mutex);

	return ret;
}

static int bm1390_read_raw(struct iio_dev *idev,
			   struct iio_chan_spec const *chan,
			   int *val, int *val2, long mask)
{
	struct bm1390_data *data = iio_priv(idev);
	int ret;

	switch (mask) {
	case IIO_CHAN_INFO_SCALE:
		if (chan->type == IIO_TEMP) {
			*val = 31;
			*val2 = 250000;

			return IIO_VAL_INT_PLUS_MICRO;
		} else if (chan->type == IIO_PRESSURE) {
			/*
			 * pressure in hPa is register value divided by 2048.
			 * This means kPa is 1/20480 times the register value,
			 */
			*val = 1;
			*val2 = 2048;

			return IIO_VAL_FRACTIONAL;
		}

		return -EINVAL;
	case IIO_CHAN_INFO_RAW:
		ret = iio_device_claim_direct_mode(idev);
		if (ret)
			return ret;

		ret = bm1390_read_data(data, chan, val, val2);
		iio_device_release_direct_mode(idev);
		if (ret)
			return ret;

		return IIO_VAL_INT;
	default:
		return -EINVAL;
	}
}

static int __bm1390_fifo_flush(struct iio_dev *idev, unsigned int samples,
			       s64 timestamp)
{
	/* BM1390_FIFO_LENGTH is small so we shouldn't run out of stack */
	struct bm1390_data_buf buffer[BM1390_FIFO_LENGTH];
	struct bm1390_data *data = iio_priv(idev);
	int smp_lvl, ret, i, warn, dummy;
	u64 sample_period;
	__be16 temp = 0;

	ret = regmap_read(data->regmap, BM1390_REG_FIFO_LVL, &smp_lvl);
	if (ret)
		return ret;

	smp_lvl = FIELD_GET(BM1390_MASK_FIFO_LVL, smp_lvl);
	if (!smp_lvl)
		return 0;

	if (smp_lvl > BM1390_FIFO_LENGTH) {
		/*
		 * The fifo holds maximum of 4 samples so valid values
		 * should be 0, 1, 2, 3, 4 - rest are probably bit errors
		 * in I2C line. Don't overflow if this happens.
		 */
		dev_err(data->dev, "bad FIFO level %d\n", smp_lvl);
		smp_lvl = BM1390_FIFO_LENGTH;
	}

	sample_period = timestamp - data->old_timestamp;
	do_div(sample_period, smp_lvl);

	if (samples && smp_lvl > samples)
		smp_lvl = samples;


	/*
	 * After some testing it appears that the temperature is not readable
	 * until the FIFO access has been done after the WMI. Thus, we need
	 * to read the all pressure values to memory and read the temperature
	 * only after that.
	 */
	for (i = 0; i < smp_lvl; i++) {
		/*
		 * When we start reading data from the FIFO the sensor goes to
		 * special FIFO reading mode. If any other register is accessed
		 * during the FIFO read, samples can be dropped. Prevent access
		 * until FIFO_LVL is read. We have mutex locked and we do also
		 * go performing reading of FIFO_LVL even if this read fails.
		 */
		if (test_bit(BM1390_CHAN_PRESSURE, idev->active_scan_mask)) {
			ret = bm1390_pressure_read(data, &buffer[i].pressure);
			if (ret)
				break;
		}

		/*
		 * Old timestamp is either the previous sample IRQ time,
		 * previous flush-time or, if this was first sample, the enable
		 * time. When we add a sample period to that we should get the
		 * best approximation of the time-stamp we are handling.
		 *
		 * Idea is to always keep the "old_timestamp" matching the
		 * timestamp which we are currently handling.
		 */
		data->old_timestamp += sample_period;
		buffer[i].ts = data->old_timestamp;
	}
	/* Reading the FIFO_LVL closes the FIFO access sequence */
	warn = regmap_read(data->regmap, BM1390_REG_FIFO_LVL, &dummy);
	if (warn)
		dev_warn(data->dev, "Closing FIFO sequence failed\n");

	if (ret)
		return ret;

	if (test_bit(BM1390_CHAN_TEMP, idev->active_scan_mask)) {
		ret = regmap_bulk_read(data->regmap, BM1390_REG_TEMP_HI, &temp,
				       sizeof(temp));
		if (ret)
			return ret;
	}

	if (ret)
		return ret;

	for (i = 0; i < smp_lvl; i++) {
		buffer[i].temp = temp;
		iio_push_to_buffers(idev, &buffer[i]);
	}

	return smp_lvl;
}

static int bm1390_fifo_flush(struct iio_dev *idev, unsigned int samples)
{
	struct bm1390_data *data = iio_priv(idev);
	s64 timestamp;
	int ret;

	/*
	 * If fifo_flush is being called from IRQ handler we know the stored
	 * timestamp is fairly accurate for the last stored sample. If we are
	 * called as a result of a read operation from userspace and hence
	 * before the watermark interrupt was triggered, take a timestamp
	 * now. We can fall anywhere in between two samples so the error in this
	 * case is at most one sample period.
	 * We need to have the IRQ disabled or we risk of messing-up
	 * the timestamps. If we are ran from IRQ, then the
	 * IRQF_ONESHOT has us covered - but if we are ran by the
	 * user-space read we need to disable the IRQ to be on a safe
	 * side. We do this usng synchronous disable so that if the
	 * IRQ thread is being ran on other CPU we wait for it to be
	 * finished.
	 */

	timestamp = iio_get_time_ns(idev);
	mutex_lock(&data->mutex);
	ret = __bm1390_fifo_flush(idev, samples, timestamp);
	mutex_unlock(&data->mutex);

	return ret;
}

static int bm1390_set_watermark(struct iio_dev *idev, unsigned int val)
{
	struct bm1390_data *data = iio_priv(idev);

	if (val < BM1390_WMI_MIN || val > BM1390_WMI_MAX)
		return -EINVAL;

	mutex_lock(&data->mutex);
	data->watermark = val;
	mutex_unlock(&data->mutex);

	return 0;
}

static const struct iio_info bm1390_noirq_info = {
	.read_raw = &bm1390_read_raw,
};

static const struct iio_info bm1390_info = {
	.read_raw = &bm1390_read_raw,
	.hwfifo_set_watermark = bm1390_set_watermark,
	.hwfifo_flush_to_buffer = bm1390_fifo_flush,
};

static int bm1390_chip_init(struct bm1390_data *data)
{
	int ret;

	ret = regmap_write_bits(data->regmap, BM1390_REG_POWER,
				BM1390_MASK_POWER, BM1390_POWER_ON);
	if (ret)
		return ret;

	msleep(1);

	ret = regmap_write_bits(data->regmap, BM1390_REG_RESET,
				BM1390_MASK_RESET, BM1390_RESET);
	if (ret)
		return ret;

	msleep(1);

	ret = regmap_write_bits(data->regmap, BM1390_REG_RESET,
				BM1390_MASK_RESET, BM1390_RESET_RELEASE);
	if (ret)
		return ret;

	msleep(1);

	ret = regmap_reinit_cache(data->regmap, &bm1390_regmap);
	if (ret) {
		dev_err(data->dev, "Failed to reinit reg cache\n");
		return ret;
	}

	/*
	 * Default to use IIR filter in "middle" mode. Also the AVE_NUM must
	 * be fixed when IIR is in use.
	 */
	ret = regmap_update_bits(data->regmap, BM1390_REG_MODE_CTRL,
				 BM1390_MASK_AVE_NUM, BM1390_IIR_AVE_NUM);
	if (ret)
		return ret;

	return regmap_update_bits(data->regmap, BM1390_REG_FIFO_CTRL,
				  BM1390_MASK_IIR_MODE, BM1390_IIR_MODE_MID);
}

static int bm1390_fifo_set_wmi(struct bm1390_data *data)
{
	u8 regval;

	regval = FIELD_PREP(BM1390_MASK_FIFO_LEN,
			    data->watermark - BM1390_WMI_MIN);

	return regmap_update_bits(data->regmap, BM1390_REG_FIFO_CTRL,
				  BM1390_MASK_FIFO_LEN, regval);
}

static int bm1390_fifo_enable(struct iio_dev *idev)
{
	struct bm1390_data *data = iio_priv(idev);
	int ret;

	/* We can't do buffered stuff without IRQ as we never get WMI */
	if (data->irq <= 0)
		return -EINVAL;

	mutex_lock(&data->mutex);
	if (data->trigger_enabled) {
		ret = -EBUSY;
		goto unlock_out;
	}

	/* Update watermark to HW */
	ret = bm1390_fifo_set_wmi(data);
	if (ret)
		goto unlock_out;

	/* Enable WMI_IRQ */
	ret = regmap_set_bits(data->regmap, BM1390_REG_MODE_CTRL,
			      BM1390_MASK_WMI_EN);
	if (ret)
		goto unlock_out;

	/* Enable FIFO */
	ret = regmap_set_bits(data->regmap, BM1390_REG_FIFO_CTRL,
			      BM1390_MASK_FIFO_EN);
	if (ret)
		goto unlock_out;

	data->state = BM1390_STATE_FIFO;

	data->old_timestamp = iio_get_time_ns(idev);
	ret = bm1390_meas_set(data, BM1390_MEAS_MODE_CONTINUOUS);

unlock_out:
	mutex_unlock(&data->mutex);

	return ret;
}

static int bm1390_fifo_disable(struct iio_dev *idev)
{
	struct bm1390_data *data = iio_priv(idev);
	int ret;

	msleep(1);

	mutex_lock(&data->mutex);
	ret = bm1390_meas_set(data, BM1390_MEAS_MODE_STOP);
	if (ret)
		goto unlock_out;

	/* Disable FIFO */
	ret = regmap_clear_bits(data->regmap, BM1390_REG_FIFO_CTRL,
				BM1390_MASK_FIFO_EN);
	if (ret)
		goto unlock_out;

	data->state = BM1390_STATE_SAMPLE;

	/* Disable WMI_IRQ */
	ret = regmap_clear_bits(data->regmap, BM1390_REG_MODE_CTRL,
				 BM1390_MASK_WMI_EN);

unlock_out:
	mutex_unlock(&data->mutex);

	return ret;
}

static int bm1390_buffer_postenable(struct iio_dev *idev)
{
	/*
	 * If we use data-ready trigger, then the IRQ masks should be handled by
	 * trigger enable and the hardware buffer is not used but we just update
	 * results to the IIO FIFO when data-ready triggers.
	 */
	if (iio_device_get_current_mode(idev) == INDIO_BUFFER_TRIGGERED)
		return 0;

	return bm1390_fifo_enable(idev);
}

static int bm1390_buffer_predisable(struct iio_dev *idev)
{
	if (iio_device_get_current_mode(idev) == INDIO_BUFFER_TRIGGERED)
		return 0;

	return bm1390_fifo_disable(idev);
}

static const struct iio_buffer_setup_ops bm1390_buffer_ops = {
	.postenable = bm1390_buffer_postenable,
	.predisable = bm1390_buffer_predisable,
};

static irqreturn_t bm1390_trigger_handler(int irq, void *p)
{
	struct iio_poll_func *pf = p;
	struct iio_dev *idev = pf->indio_dev;
	struct bm1390_data *data = iio_priv(idev);
	int ret, status;

	/* DRDY is acked by reading status reg */
	ret = regmap_read(data->regmap, BM1390_REG_STATUS, &status);
	if (ret || !status)
		return IRQ_NONE;

	dev_dbg(data->dev, "DRDY trig status 0x%x\n", status);

	if (test_bit(BM1390_CHAN_PRESSURE, idev->active_scan_mask)) {
		ret = bm1390_pressure_read(data, &data->buf.pressure);
		if (ret) {
			dev_warn(data->dev, "sample read failed %d\n", ret);
			return IRQ_NONE;
		}
	}

	if (test_bit(BM1390_CHAN_TEMP, idev->active_scan_mask)) {
		ret = regmap_bulk_read(data->regmap, BM1390_REG_TEMP_HI,
				       &data->buf.temp, sizeof(data->buf.temp));
		if (ret) {
			dev_warn(data->dev, "temp read failed %d\n", ret);
			return IRQ_HANDLED;
		}
	}

	iio_push_to_buffers_with_timestamp(idev, &data->buf, data->timestamp);
	iio_trigger_notify_done(idev->trig);

	return IRQ_HANDLED;
}

/* Get timestamps and wake the thread if we need to read data */
static irqreturn_t bm1390_irq_handler(int irq, void *private)
{
	struct iio_dev *idev = private;
	struct bm1390_data *data = iio_priv(idev);

	data->timestamp = iio_get_time_ns(idev);

	if (data->state == BM1390_STATE_FIFO || data->trigger_enabled)
		return IRQ_WAKE_THREAD;

	return IRQ_NONE;
}

static irqreturn_t bm1390_irq_thread_handler(int irq, void *private)
{
	struct iio_dev *idev = private;
	struct bm1390_data *data = iio_priv(idev);
	int ret = IRQ_NONE;

	mutex_lock(&data->mutex);

	if (data->trigger_enabled) {
		iio_trigger_poll_nested(data->trig);
		ret = IRQ_HANDLED;
	} else if (data->state == BM1390_STATE_FIFO) {
		int ok;

		ok = __bm1390_fifo_flush(idev, BM1390_FIFO_LENGTH,
					 data->timestamp);
		if (ok > 0)
			ret = IRQ_HANDLED;
	}

	mutex_unlock(&data->mutex);

	return ret;
}

static int bm1390_set_drdy_irq(struct bm1390_data *data, bool en)
{
	if (en)
		return regmap_set_bits(data->regmap, BM1390_REG_MODE_CTRL,
				       BM1390_MASK_DRDY_EN);
	return regmap_clear_bits(data->regmap, BM1390_REG_MODE_CTRL,
				 BM1390_MASK_DRDY_EN);
}

static int bm1390_trigger_set_state(struct iio_trigger *trig,
				    bool state)
{
	struct bm1390_data *data = iio_trigger_get_drvdata(trig);
	int ret = 0;

	mutex_lock(&data->mutex);

	if (data->trigger_enabled == state)
		goto unlock_out;

	if (data->state == BM1390_STATE_FIFO) {
		dev_warn(data->dev, "Can't set trigger when FIFO enabled\n");
		ret = -EBUSY;
		goto unlock_out;
	}

	data->trigger_enabled = state;

	if (state) {
		ret = bm1390_meas_set(data, BM1390_MEAS_MODE_CONTINUOUS);
		if (ret)
			goto unlock_out;
	} else {
		int dummy;

		ret = bm1390_meas_set(data, BM1390_MEAS_MODE_STOP);
		if (ret)
			goto unlock_out;

		/*
		 * We need to read the status register in order to ACK the
		 * data-ready which may have been generated just before we
		 * disabled the measurement.
		 */
		ret = regmap_read(data->regmap, BM1390_REG_STATUS, &dummy);
		if (ret)
			dev_warn(data->dev, "status read failed\n");
	}

	ret = bm1390_set_drdy_irq(data, state);

unlock_out:
	mutex_unlock(&data->mutex);

	return ret;
}

static const struct iio_trigger_ops bm1390_trigger_ops = {
	.set_trigger_state = bm1390_trigger_set_state,
};

static int bm1390_setup_buffer(struct bm1390_data *data, struct iio_dev *idev)
{
	int ret;

	ret = devm_iio_triggered_buffer_setup(data->dev, idev,
					      &iio_pollfunc_store_time,
					      &bm1390_trigger_handler,
					      &bm1390_buffer_ops);

	if (ret)
		return dev_err_probe(data->dev, ret,
				     "iio_triggered_buffer_setup FAIL\n");

	idev->available_scan_masks = bm1390_scan_masks;

	return 0;
}

static int bm1390_setup_trigger(struct bm1390_data *data, struct iio_dev *idev,
				int irq)
{
	struct iio_trigger *itrig;
	char *name;
	int ret;

	itrig = devm_iio_trigger_alloc(data->dev, "%sdata-rdy-dev%d", idev->name,
					    iio_device_id(idev));
	if (!itrig)
		return -ENOMEM;

	data->trig = itrig;

	itrig->ops = &bm1390_trigger_ops;
	iio_trigger_set_drvdata(itrig, data);

	name = devm_kasprintf(data->dev, GFP_KERNEL, "%s-bm1390",
			      dev_name(data->dev));
	if (name == NULL)
		return -ENOMEM;

	ret = devm_request_threaded_irq(data->dev, irq, bm1390_irq_handler,
					&bm1390_irq_thread_handler,
					IRQF_ONESHOT, name, idev);
	if (ret)
		return dev_err_probe(data->dev, ret, "Could not request IRQ\n");


	ret = devm_iio_trigger_register(data->dev, itrig);
	if (ret)
		return dev_err_probe(data->dev, ret,
				     "Trigger registration failed\n");

	return 0;
}

static int bm1390_probe(struct i2c_client *i2c)
{
	struct bm1390_data *data;
	struct regmap *regmap;
	struct iio_dev *idev;
	struct device *dev;
	unsigned int part_id;
	int ret;

	dev = &i2c->dev;

	regmap = devm_regmap_init_i2c(i2c, &bm1390_regmap);
	if (IS_ERR(regmap))
		return dev_err_probe(dev, PTR_ERR(regmap),
				     "Failed to initialize Regmap\n");

	ret = devm_regulator_get_enable(dev, "vdd");
	if (ret)
		return dev_err_probe(dev, ret, "Failed to get regulator\n");

	ret = regmap_read(regmap, BM1390_REG_PART_ID, &part_id);
	if (ret)
		return dev_err_probe(dev, ret, "Failed to access sensor\n");

	if (part_id != BM1390_ID)
		dev_warn(dev, "unknown device 0x%x\n", part_id);

	idev = devm_iio_device_alloc(dev, sizeof(*data));
	if (!idev)
		return -ENOMEM;

	data = iio_priv(idev);
	data->regmap = regmap;
	data->dev = dev;
	data->irq = i2c->irq;
	/*
	 * For now we just allow BM1390_WMI_MIN to BM1390_WMI_MAX and
	 * discard every other configuration when triggered mode is not used.
	 */
	data->watermark = BM1390_WMI_MAX;
	mutex_init(&data->mutex);

	idev->channels = bm1390_channels;
	idev->num_channels = ARRAY_SIZE(bm1390_channels);
	idev->name = "bm1390";
	idev->modes = INDIO_DIRECT_MODE;

	ret = bm1390_chip_init(data);
	if (ret)
		return dev_err_probe(dev, ret, "sensor init failed\n");

	ret = bm1390_setup_buffer(data, idev);
	if (ret)
		return ret;

	/* No trigger if we don't have IRQ for data-ready and WMI */
	if (i2c->irq > 0) {
		idev->info = &bm1390_info;
		idev->modes |= INDIO_BUFFER_SOFTWARE;
		ret = bm1390_setup_trigger(data, idev, i2c->irq);
		if (ret)
			return ret;
	} else {
		idev->info = &bm1390_noirq_info;
	}

	ret = devm_iio_device_register(dev, idev);
	if (ret < 0)
		return dev_err_probe(dev, ret,
				     "Unable to register iio device\n");

	return 0;
}

static const struct of_device_id bm1390_of_match[] = {
	{ .compatible = "rohm,bm1390glv-z" },
	{}
};
MODULE_DEVICE_TABLE(of, bm1390_of_match);

static const struct i2c_device_id bm1390_id[] = {
	{ "bm1390glv-z", },
	{}
};
MODULE_DEVICE_TABLE(i2c, bm1390_id);

static struct i2c_driver bm1390_driver = {
	.driver = {
		.name = "bm1390",
		.of_match_table = bm1390_of_match,
		/*
		 * Probing explicitly requires a few millisecond of sleep.
		 * Enabling the VDD regulator may include ramp up rates.
		 */
		.probe_type = PROBE_PREFER_ASYNCHRONOUS,
	},
	.probe = bm1390_probe,
	.id_table = bm1390_id,
};
module_i2c_driver(bm1390_driver);

MODULE_AUTHOR("Matti Vaittinen <mazziesaccount@gmail.com>");
MODULE_DESCRIPTION("Driver for ROHM BM1390 pressure sensor");
MODULE_LICENSE("GPL");