// 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/cleanup.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;
        aligned_s64 ts;
};

/* 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;

        guard(mutex)(&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)
                return ret;

        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);

        return 0;
}

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:
                if (!iio_device_claim_direct(idev))
                        return -EBUSY;

                ret = bm1390_read_data(data, chan, val, val2);
                iio_device_release_direct(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;
        }

        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;

        guard(mutex)(&data->mutex);

        if (data->trigger_enabled)
                return -EBUSY;

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

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

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

        data->state = BM1390_STATE_FIFO;

        data->old_timestamp = iio_get_time_ns(idev);

        return bm1390_meas_set(data, BM1390_MEAS_MODE_CONTINUOUS);
}

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

        msleep(1);

        guard(mutex)(&data->mutex);
        ret = bm1390_meas_set(data, BM1390_MEAS_MODE_STOP);
        if (ret)
                return ret;

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

        data->state = BM1390_STATE_SAMPLE;

        /* Disable WMI_IRQ */
        return regmap_clear_bits(data->regmap, BM1390_REG_MODE_CTRL,
                                 BM1390_MASK_WMI_EN);
}

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_ts(idev, &data->buf, sizeof(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);

        guard(mutex)(&data->mutex);

        if (data->trigger_enabled) {
                iio_trigger_poll_nested(data->trig);
                return IRQ_HANDLED;
        }

        if (data->state == BM1390_STATE_FIFO) {
                int ok;

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

        return IRQ_NONE;
}

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;

        guard(mutex)(&data->mutex);

        if (data->trigger_enabled == state)
                return 0;

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

        data->trigger_enabled = state;

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

                ret = bm1390_meas_set(data, BM1390_MEAS_MODE_STOP);
                if (ret)
                        return ret;

                /*
                 * 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");
        }

        return bm1390_set_drdy_irq(data, state);
}

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");