// SPDX-License-Identifier: GPL-2.0-only
/*
 * Copyright (c) 2014 Intel Corporation
 *
 * Driver for Semtech's SX9500 capacitive proximity/button solution.
 * Datasheet available at
 * <http://www.semtech.com/images/datasheet/sx9500.pdf>.
 */

#include <linux/kernel.h>
#include <linux/slab.h>
#include <linux/module.h>
#include <linux/i2c.h>
#include <linux/irq.h>
#include <linux/acpi.h>
#include <linux/gpio/consumer.h>
#include <linux/regmap.h>
#include <linux/pm.h>
#include <linux/delay.h>

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

#define SX9500_DRIVER_NAME              "sx9500"
#define SX9500_IRQ_NAME                 "sx9500_event"

/* Register definitions. */
#define SX9500_REG_IRQ_SRC              0x00
#define SX9500_REG_STAT                 0x01
#define SX9500_REG_IRQ_MSK              0x03

#define SX9500_REG_PROX_CTRL0           0x06
#define SX9500_REG_PROX_CTRL1           0x07
#define SX9500_REG_PROX_CTRL2           0x08
#define SX9500_REG_PROX_CTRL3           0x09
#define SX9500_REG_PROX_CTRL4           0x0a
#define SX9500_REG_PROX_CTRL5           0x0b
#define SX9500_REG_PROX_CTRL6           0x0c
#define SX9500_REG_PROX_CTRL7           0x0d
#define SX9500_REG_PROX_CTRL8           0x0e

#define SX9500_REG_SENSOR_SEL           0x20
#define SX9500_REG_USE_MSB              0x21
#define SX9500_REG_USE_LSB              0x22
#define SX9500_REG_AVG_MSB              0x23
#define SX9500_REG_AVG_LSB              0x24
#define SX9500_REG_DIFF_MSB             0x25
#define SX9500_REG_DIFF_LSB             0x26
#define SX9500_REG_OFFSET_MSB           0x27
#define SX9500_REG_OFFSET_LSB           0x28

#define SX9500_REG_RESET                0x7f

/* Write this to REG_RESET to do a soft reset. */
#define SX9500_SOFT_RESET               0xde

#define SX9500_SCAN_PERIOD_MASK         GENMASK(6, 4)
#define SX9500_SCAN_PERIOD_SHIFT        4

/*
 * These serve for identifying IRQ source in the IRQ_SRC register, and
 * also for masking the IRQs in the IRQ_MSK register.
 */
#define SX9500_CLOSE_IRQ                BIT(6)
#define SX9500_FAR_IRQ                  BIT(5)
#define SX9500_CONVDONE_IRQ             BIT(3)

#define SX9500_PROXSTAT_SHIFT           4
#define SX9500_COMPSTAT_MASK            GENMASK(3, 0)

#define SX9500_NUM_CHANNELS             4
#define SX9500_CHAN_MASK                GENMASK(SX9500_NUM_CHANNELS - 1, 0)

struct sx9500_data {
        struct mutex mutex;
        struct i2c_client *client;
        struct iio_trigger *trig;
        struct regmap *regmap;
        struct gpio_desc *gpiod_rst;
        /*
         * Last reading of the proximity status for each channel.  We
         * only send an event to user space when this changes.
         */
        bool prox_stat[SX9500_NUM_CHANNELS];
        bool event_enabled[SX9500_NUM_CHANNELS];
        bool trigger_enabled;
        u16 *buffer;
        /* Remember enabled channels and sample rate during suspend. */
        unsigned int suspend_ctrl0;
        struct completion completion;
        int data_rdy_users, close_far_users;
        int channel_users[SX9500_NUM_CHANNELS];
};

static const struct iio_event_spec sx9500_events[] = {
        {
                .type = IIO_EV_TYPE_THRESH,
                .dir = IIO_EV_DIR_EITHER,
                .mask_separate = BIT(IIO_EV_INFO_ENABLE),
        },
};

#define SX9500_CHANNEL(idx)                                     \
        {                                                       \
                .type = IIO_PROXIMITY,                          \
                .info_mask_separate = BIT(IIO_CHAN_INFO_RAW),   \
                .info_mask_shared_by_all = BIT(IIO_CHAN_INFO_SAMP_FREQ), \
                .indexed = 1,                                   \
                .channel = idx,                                 \
                .event_spec = sx9500_events,                    \
                .num_event_specs = ARRAY_SIZE(sx9500_events),   \
                .scan_index = idx,                              \
                .scan_type = {                                  \
                        .sign = 'u',                            \
                        .realbits = 16,                         \
                        .storagebits = 16,                      \
                        .shift = 0,                             \
                },                                              \
        }

static const struct iio_chan_spec sx9500_channels[] = {
        SX9500_CHANNEL(0),
        SX9500_CHANNEL(1),
        SX9500_CHANNEL(2),
        SX9500_CHANNEL(3),
        IIO_CHAN_SOFT_TIMESTAMP(4),
};

static const struct {
        int val;
        int val2;
} sx9500_samp_freq_table[] = {
        {33, 333333},
        {16, 666666},
        {11, 111111},
        {8, 333333},
        {6, 666666},
        {5, 0},
        {3, 333333},
        {2, 500000},
};

static const unsigned int sx9500_scan_period_table[] = {
        30, 60, 90, 120, 150, 200, 300, 400,
};

static const struct regmap_range sx9500_writable_reg_ranges[] = {
        regmap_reg_range(SX9500_REG_IRQ_MSK, SX9500_REG_IRQ_MSK),
        regmap_reg_range(SX9500_REG_PROX_CTRL0, SX9500_REG_PROX_CTRL8),
        regmap_reg_range(SX9500_REG_SENSOR_SEL, SX9500_REG_SENSOR_SEL),
        regmap_reg_range(SX9500_REG_OFFSET_MSB, SX9500_REG_OFFSET_LSB),
        regmap_reg_range(SX9500_REG_RESET, SX9500_REG_RESET),
};

static const struct regmap_access_table sx9500_writeable_regs = {
        .yes_ranges = sx9500_writable_reg_ranges,
        .n_yes_ranges = ARRAY_SIZE(sx9500_writable_reg_ranges),
};

/*
 * All allocated registers are readable, so we just list unallocated
 * ones.
 */
static const struct regmap_range sx9500_non_readable_reg_ranges[] = {
        regmap_reg_range(SX9500_REG_STAT + 1, SX9500_REG_STAT + 1),
        regmap_reg_range(SX9500_REG_IRQ_MSK + 1, SX9500_REG_PROX_CTRL0 - 1),
        regmap_reg_range(SX9500_REG_PROX_CTRL8 + 1, SX9500_REG_SENSOR_SEL - 1),
        regmap_reg_range(SX9500_REG_OFFSET_LSB + 1, SX9500_REG_RESET - 1),
};

static const struct regmap_access_table sx9500_readable_regs = {
        .no_ranges = sx9500_non_readable_reg_ranges,
        .n_no_ranges = ARRAY_SIZE(sx9500_non_readable_reg_ranges),
};

static const struct regmap_range sx9500_volatile_reg_ranges[] = {
        regmap_reg_range(SX9500_REG_IRQ_SRC, SX9500_REG_STAT),
        regmap_reg_range(SX9500_REG_USE_MSB, SX9500_REG_OFFSET_LSB),
        regmap_reg_range(SX9500_REG_RESET, SX9500_REG_RESET),
};

static const struct regmap_access_table sx9500_volatile_regs = {
        .yes_ranges = sx9500_volatile_reg_ranges,
        .n_yes_ranges = ARRAY_SIZE(sx9500_volatile_reg_ranges),
};

static const struct regmap_config sx9500_regmap_config = {
        .reg_bits = 8,
        .val_bits = 8,

        .max_register = SX9500_REG_RESET,
        .cache_type = REGCACHE_RBTREE,

        .wr_table = &sx9500_writeable_regs,
        .rd_table = &sx9500_readable_regs,
        .volatile_table = &sx9500_volatile_regs,
};

static int sx9500_inc_users(struct sx9500_data *data, int *counter,
                            unsigned int reg, unsigned int bitmask)
{
        (*counter)++;
        if (*counter != 1)
                /* Bit is already active, nothing to do. */
                return 0;

        return regmap_update_bits(data->regmap, reg, bitmask, bitmask);
}

static int sx9500_dec_users(struct sx9500_data *data, int *counter,
                            unsigned int reg, unsigned int bitmask)
{
        (*counter)--;
        if (*counter != 0)
                /* There are more users, do not deactivate. */
                return 0;

        return regmap_update_bits(data->regmap, reg, bitmask, 0);
}

static int sx9500_inc_chan_users(struct sx9500_data *data, int chan)
{
        return sx9500_inc_users(data, &data->channel_users[chan],
                                SX9500_REG_PROX_CTRL0, BIT(chan));
}

static int sx9500_dec_chan_users(struct sx9500_data *data, int chan)
{
        return sx9500_dec_users(data, &data->channel_users[chan],
                                SX9500_REG_PROX_CTRL0, BIT(chan));
}

static int sx9500_inc_data_rdy_users(struct sx9500_data *data)
{
        return sx9500_inc_users(data, &data->data_rdy_users,
                                SX9500_REG_IRQ_MSK, SX9500_CONVDONE_IRQ);
}

static int sx9500_dec_data_rdy_users(struct sx9500_data *data)
{
        return sx9500_dec_users(data, &data->data_rdy_users,
                                SX9500_REG_IRQ_MSK, SX9500_CONVDONE_IRQ);
}

static int sx9500_inc_close_far_users(struct sx9500_data *data)
{
        return sx9500_inc_users(data, &data->close_far_users,
                                SX9500_REG_IRQ_MSK,
                                SX9500_CLOSE_IRQ | SX9500_FAR_IRQ);
}

static int sx9500_dec_close_far_users(struct sx9500_data *data)
{
        return sx9500_dec_users(data, &data->close_far_users,
                                SX9500_REG_IRQ_MSK,
                                SX9500_CLOSE_IRQ | SX9500_FAR_IRQ);
}

static int sx9500_read_prox_data(struct sx9500_data *data,
                                 const struct iio_chan_spec *chan,
                                 int *val)
{
        int ret;
        __be16 regval;

        ret = regmap_write(data->regmap, SX9500_REG_SENSOR_SEL, chan->channel);
        if (ret < 0)
                return ret;

        ret = regmap_bulk_read(data->regmap, SX9500_REG_USE_MSB, &regval, 2);
        if (ret < 0)
                return ret;

        *val = be16_to_cpu(regval);

        return IIO_VAL_INT;
}

/*
 * If we have no interrupt support, we have to wait for a scan period
 * after enabling a channel to get a result.
 */
static int sx9500_wait_for_sample(struct sx9500_data *data)
{
        int ret;
        unsigned int val;

        ret = regmap_read(data->regmap, SX9500_REG_PROX_CTRL0, &val);
        if (ret < 0)
                return ret;

        val = (val & SX9500_SCAN_PERIOD_MASK) >> SX9500_SCAN_PERIOD_SHIFT;

        msleep(sx9500_scan_period_table[val]);

        return 0;
}

static int sx9500_read_proximity(struct sx9500_data *data,
                                 const struct iio_chan_spec *chan,
                                 int *val)
{
        int ret;

        mutex_lock(&data->mutex);

        ret = sx9500_inc_chan_users(data, chan->channel);
        if (ret < 0)
                goto out;

        ret = sx9500_inc_data_rdy_users(data);
        if (ret < 0)
                goto out_dec_chan;

        mutex_unlock(&data->mutex);

        if (data->client->irq > 0)
                ret = wait_for_completion_interruptible(&data->completion);
        else
                ret = sx9500_wait_for_sample(data);

        mutex_lock(&data->mutex);

        if (ret < 0)
                goto out_dec_data_rdy;

        ret = sx9500_read_prox_data(data, chan, val);
        if (ret < 0)
                goto out_dec_data_rdy;

        ret = sx9500_dec_data_rdy_users(data);
        if (ret < 0)
                goto out_dec_chan;

        ret = sx9500_dec_chan_users(data, chan->channel);
        if (ret < 0)
                goto out;

        ret = IIO_VAL_INT;

        goto out;

out_dec_data_rdy:
        sx9500_dec_data_rdy_users(data);
out_dec_chan:
        sx9500_dec_chan_users(data, chan->channel);
out:
        mutex_unlock(&data->mutex);
        reinit_completion(&data->completion);

        return ret;
}

static int sx9500_read_samp_freq(struct sx9500_data *data,
                                 int *val, int *val2)
{
        int ret;
        unsigned int regval;

        mutex_lock(&data->mutex);
        ret = regmap_read(data->regmap, SX9500_REG_PROX_CTRL0, &regval);
        mutex_unlock(&data->mutex);

        if (ret < 0)
                return ret;

        regval = (regval & SX9500_SCAN_PERIOD_MASK) >> SX9500_SCAN_PERIOD_SHIFT;
        *val = sx9500_samp_freq_table[regval].val;
        *val2 = sx9500_samp_freq_table[regval].val2;

        return IIO_VAL_INT_PLUS_MICRO;
}

static int sx9500_read_raw(struct iio_dev *indio_dev,
                           const struct iio_chan_spec *chan,
                           int *val, int *val2, long mask)
{
        struct sx9500_data *data = iio_priv(indio_dev);
        int ret;

        switch (chan->type) {
        case IIO_PROXIMITY:
                switch (mask) {
                case IIO_CHAN_INFO_RAW:
                        ret = iio_device_claim_direct_mode(indio_dev);
                        if (ret)
                                return ret;
                        ret = sx9500_read_proximity(data, chan, val);
                        iio_device_release_direct_mode(indio_dev);
                        return ret;
                case IIO_CHAN_INFO_SAMP_FREQ:
                        return sx9500_read_samp_freq(data, val, val2);
                default:
                        return -EINVAL;
                }
        default:
                return -EINVAL;
        }
}

static int sx9500_set_samp_freq(struct sx9500_data *data,
                                int val, int val2)
{
        int i, ret;

        for (i = 0; i < ARRAY_SIZE(sx9500_samp_freq_table); i++)
                if (val == sx9500_samp_freq_table[i].val &&
                    val2 == sx9500_samp_freq_table[i].val2)
                        break;

        if (i == ARRAY_SIZE(sx9500_samp_freq_table))
                return -EINVAL;

        mutex_lock(&data->mutex);

        ret = regmap_update_bits(data->regmap, SX9500_REG_PROX_CTRL0,
                                 SX9500_SCAN_PERIOD_MASK,
                                 i << SX9500_SCAN_PERIOD_SHIFT);

        mutex_unlock(&data->mutex);

        return ret;
}

static int sx9500_write_raw(struct iio_dev *indio_dev,
                            const struct iio_chan_spec *chan,
                            int val, int val2, long mask)
{
        struct sx9500_data *data = iio_priv(indio_dev);

        switch (chan->type) {
        case IIO_PROXIMITY:
                switch (mask) {
                case IIO_CHAN_INFO_SAMP_FREQ:
                        return sx9500_set_samp_freq(data, val, val2);
                default:
                        return -EINVAL;
                }
        default:
                return -EINVAL;
        }
}

static irqreturn_t sx9500_irq_handler(int irq, void *private)
{
        struct iio_dev *indio_dev = private;
        struct sx9500_data *data = iio_priv(indio_dev);

        if (data->trigger_enabled)
                iio_trigger_poll(data->trig);

        /*
         * Even if no event is enabled, we need to wake the thread to
         * clear the interrupt state by reading SX9500_REG_IRQ_SRC.  It
         * is not possible to do that here because regmap_read takes a
         * mutex.
         */
        return IRQ_WAKE_THREAD;
}

static void sx9500_push_events(struct iio_dev *indio_dev)
{
        int ret;
        unsigned int val, chan;
        struct sx9500_data *data = iio_priv(indio_dev);

        ret = regmap_read(data->regmap, SX9500_REG_STAT, &val);
        if (ret < 0) {
                dev_err(&data->client->dev, "i2c transfer error in irq\n");
                return;
        }

        val >>= SX9500_PROXSTAT_SHIFT;
        for (chan = 0; chan < SX9500_NUM_CHANNELS; chan++) {
                int dir;
                u64 ev;
                bool new_prox = val & BIT(chan);

                if (!data->event_enabled[chan])
                        continue;
                if (new_prox == data->prox_stat[chan])
                        /* No change on this channel. */
                        continue;

                dir = new_prox ? IIO_EV_DIR_FALLING : IIO_EV_DIR_RISING;
                ev = IIO_UNMOD_EVENT_CODE(IIO_PROXIMITY, chan,
                                          IIO_EV_TYPE_THRESH, dir);
                iio_push_event(indio_dev, ev, iio_get_time_ns(indio_dev));
                data->prox_stat[chan] = new_prox;
        }
}

static irqreturn_t sx9500_irq_thread_handler(int irq, void *private)
{
        struct iio_dev *indio_dev = private;
        struct sx9500_data *data = iio_priv(indio_dev);
        int ret;
        unsigned int val;

        mutex_lock(&data->mutex);

        ret = regmap_read(data->regmap, SX9500_REG_IRQ_SRC, &val);
        if (ret < 0) {
                dev_err(&data->client->dev, "i2c transfer error in irq\n");
                goto out;
        }

        if (val & (SX9500_CLOSE_IRQ | SX9500_FAR_IRQ))
                sx9500_push_events(indio_dev);

        if (val & SX9500_CONVDONE_IRQ)
                complete(&data->completion);

out:
        mutex_unlock(&data->mutex);

        return IRQ_HANDLED;
}

static int sx9500_read_event_config(struct iio_dev *indio_dev,
                                    const struct iio_chan_spec *chan,
                                    enum iio_event_type type,
                                    enum iio_event_direction dir)
{
        struct sx9500_data *data = iio_priv(indio_dev);

        if (chan->type != IIO_PROXIMITY || type != IIO_EV_TYPE_THRESH ||
            dir != IIO_EV_DIR_EITHER)
                return -EINVAL;

        return data->event_enabled[chan->channel];
}

static int sx9500_write_event_config(struct iio_dev *indio_dev,
                                     const struct iio_chan_spec *chan,
                                     enum iio_event_type type,
                                     enum iio_event_direction dir,
                                     int state)
{
        struct sx9500_data *data = iio_priv(indio_dev);
        int ret;

        if (chan->type != IIO_PROXIMITY || type != IIO_EV_TYPE_THRESH ||
            dir != IIO_EV_DIR_EITHER)
                return -EINVAL;

        mutex_lock(&data->mutex);

        if (state == 1) {
                ret = sx9500_inc_chan_users(data, chan->channel);
                if (ret < 0)
                        goto out_unlock;
                ret = sx9500_inc_close_far_users(data);
                if (ret < 0)
                        goto out_undo_chan;
        } else {
                ret = sx9500_dec_chan_users(data, chan->channel);
                if (ret < 0)
                        goto out_unlock;
                ret = sx9500_dec_close_far_users(data);
                if (ret < 0)
                        goto out_undo_chan;
        }

        data->event_enabled[chan->channel] = state;
        goto out_unlock;

out_undo_chan:
        if (state == 1)
                sx9500_dec_chan_users(data, chan->channel);
        else
                sx9500_inc_chan_users(data, chan->channel);
out_unlock:
        mutex_unlock(&data->mutex);
        return ret;
}

static int sx9500_update_scan_mode(struct iio_dev *indio_dev,
                                   const unsigned long *scan_mask)
{
        struct sx9500_data *data = iio_priv(indio_dev);

        mutex_lock(&data->mutex);
        kfree(data->buffer);
        data->buffer = kzalloc(indio_dev->scan_bytes, GFP_KERNEL);
        mutex_unlock(&data->mutex);

        if (data->buffer == NULL)
                return -ENOMEM;

        return 0;
}

static IIO_CONST_ATTR_SAMP_FREQ_AVAIL(
        "2.500000 3.333333 5 6.666666 8.333333 11.111111 16.666666 33.333333");

static struct attribute *sx9500_attributes[] = {
        &iio_const_attr_sampling_frequency_available.dev_attr.attr,
        NULL,
};

static const struct attribute_group sx9500_attribute_group = {
        .attrs = sx9500_attributes,
};

static const struct iio_info sx9500_info = {
        .attrs = &sx9500_attribute_group,
        .read_raw = &sx9500_read_raw,
        .write_raw = &sx9500_write_raw,
        .read_event_config = &sx9500_read_event_config,
        .write_event_config = &sx9500_write_event_config,
        .update_scan_mode = &sx9500_update_scan_mode,
};

static int sx9500_set_trigger_state(struct iio_trigger *trig,
                                    bool state)
{
        struct iio_dev *indio_dev = iio_trigger_get_drvdata(trig);
        struct sx9500_data *data = iio_priv(indio_dev);
        int ret;

        mutex_lock(&data->mutex);

        if (state)
                ret = sx9500_inc_data_rdy_users(data);
        else
                ret = sx9500_dec_data_rdy_users(data);
        if (ret < 0)
                goto out;

        data->trigger_enabled = state;

out:
        mutex_unlock(&data->mutex);

        return ret;
}

static const struct iio_trigger_ops sx9500_trigger_ops = {
        .set_trigger_state = sx9500_set_trigger_state,
};

static irqreturn_t sx9500_trigger_handler(int irq, void *private)
{
        struct iio_poll_func *pf = private;
        struct iio_dev *indio_dev = pf->indio_dev;
        struct sx9500_data *data = iio_priv(indio_dev);
        int val, bit, ret, i = 0;

        mutex_lock(&data->mutex);

        for_each_set_bit(bit, indio_dev->active_scan_mask,
                         indio_dev->masklength) {
                ret = sx9500_read_prox_data(data, &indio_dev->channels[bit],
                                            &val);
                if (ret < 0)
                        goto out;

                data->buffer[i++] = val;
        }

        iio_push_to_buffers_with_timestamp(indio_dev, data->buffer,
                                           iio_get_time_ns(indio_dev));

out:
        mutex_unlock(&data->mutex);

        iio_trigger_notify_done(indio_dev->trig);

        return IRQ_HANDLED;
}

static int sx9500_buffer_preenable(struct iio_dev *indio_dev)
{
        struct sx9500_data *data = iio_priv(indio_dev);
        int ret = 0, i;

        mutex_lock(&data->mutex);

        for (i = 0; i < SX9500_NUM_CHANNELS; i++)
                if (test_bit(i, indio_dev->active_scan_mask)) {
                        ret = sx9500_inc_chan_users(data, i);
                        if (ret)
                                break;
                }

        if (ret)
                for (i = i - 1; i >= 0; i--)
                        if (test_bit(i, indio_dev->active_scan_mask))
                                sx9500_dec_chan_users(data, i);

        mutex_unlock(&data->mutex);

        return ret;
}

static int sx9500_buffer_predisable(struct iio_dev *indio_dev)
{
        struct sx9500_data *data = iio_priv(indio_dev);
        int ret = 0, i;

        iio_triggered_buffer_predisable(indio_dev);

        mutex_lock(&data->mutex);

        for (i = 0; i < SX9500_NUM_CHANNELS; i++)
                if (test_bit(i, indio_dev->active_scan_mask)) {
                        ret = sx9500_dec_chan_users(data, i);
                        if (ret)
                                break;
                }

        if (ret)
                for (i = i - 1; i >= 0; i--)
                        if (test_bit(i, indio_dev->active_scan_mask))
                                sx9500_inc_chan_users(data, i);

        mutex_unlock(&data->mutex);

        return ret;
}

static const struct iio_buffer_setup_ops sx9500_buffer_setup_ops = {
        .preenable = sx9500_buffer_preenable,
        .postenable = iio_triggered_buffer_postenable,
        .predisable = sx9500_buffer_predisable,
};

struct sx9500_reg_default {
        u8 reg;
        u8 def;
};

static const struct sx9500_reg_default sx9500_default_regs[] = {
        {
                .reg = SX9500_REG_PROX_CTRL1,
                /* Shield enabled, small range. */
                .def = 0x43,
        },
        {
                .reg = SX9500_REG_PROX_CTRL2,
                /* x8 gain, 167kHz frequency, finest resolution. */
                .def = 0x77,
        },
        {
                .reg = SX9500_REG_PROX_CTRL3,
                /* Doze enabled, 2x scan period doze, no raw filter. */
                .def = 0x40,
        },
        {
                .reg = SX9500_REG_PROX_CTRL4,
                /* Average threshold. */
                .def = 0x30,
        },
        {
                .reg = SX9500_REG_PROX_CTRL5,
                /*
                 * Debouncer off, lowest average negative filter,
                 * highest average postive filter.
                 */
                .def = 0x0f,
        },
        {
                .reg = SX9500_REG_PROX_CTRL6,
                /* Proximity detection threshold: 280 */
                .def = 0x0e,
        },
        {
                .reg = SX9500_REG_PROX_CTRL7,
                /*
                 * No automatic compensation, compensate each pin
                 * independently, proximity hysteresis: 32, close
                 * debouncer off, far debouncer off.
                 */
                .def = 0x00,
        },
        {
                .reg = SX9500_REG_PROX_CTRL8,
                /* No stuck timeout, no periodic compensation. */
                .def = 0x00,
        },
        {
                .reg = SX9500_REG_PROX_CTRL0,
                /* Scan period: 30ms, all sensors disabled. */
                .def = 0x00,
        },
};

/* Activate all channels and perform an initial compensation. */
static int sx9500_init_compensation(struct iio_dev *indio_dev)
{
        struct sx9500_data *data = iio_priv(indio_dev);
        int i, ret;
        unsigned int val;

        ret = regmap_update_bits(data->regmap, SX9500_REG_PROX_CTRL0,
                                 SX9500_CHAN_MASK, SX9500_CHAN_MASK);
        if (ret < 0)
                return ret;

        for (i = 10; i >= 0; i--) {
                usleep_range(10000, 20000);
                ret = regmap_read(data->regmap, SX9500_REG_STAT, &val);
                if (ret < 0)
                        goto out;
                if (!(val & SX9500_COMPSTAT_MASK))
                        break;
        }

        if (i < 0) {
                dev_err(&data->client->dev, "initial compensation timed out");
                ret = -ETIMEDOUT;
        }

out:
        regmap_update_bits(data->regmap, SX9500_REG_PROX_CTRL0,
                           SX9500_CHAN_MASK, 0);
        return ret;
}

static int sx9500_init_device(struct iio_dev *indio_dev)
{
        struct sx9500_data *data = iio_priv(indio_dev);
        int ret, i;
        unsigned int val;

        if (data->gpiod_rst) {
                gpiod_set_value_cansleep(data->gpiod_rst, 0);
                usleep_range(1000, 2000);
                gpiod_set_value_cansleep(data->gpiod_rst, 1);
                usleep_range(1000, 2000);
        }

        ret = regmap_write(data->regmap, SX9500_REG_IRQ_MSK, 0);
        if (ret < 0)
                return ret;

        ret = regmap_write(data->regmap, SX9500_REG_RESET,
                           SX9500_SOFT_RESET);
        if (ret < 0)
                return ret;

        ret = regmap_read(data->regmap, SX9500_REG_IRQ_SRC, &val);
        if (ret < 0)
                return ret;

        for (i = 0; i < ARRAY_SIZE(sx9500_default_regs); i++) {
                ret = regmap_write(data->regmap,
                                   sx9500_default_regs[i].reg,
                                   sx9500_default_regs[i].def);
                if (ret < 0)
                        return ret;
        }

        return sx9500_init_compensation(indio_dev);
}

static const struct acpi_gpio_params reset_gpios = { 0, 0, false };
static const struct acpi_gpio_params interrupt_gpios = { 2, 0, false };

static const struct acpi_gpio_mapping acpi_sx9500_gpios[] = {
        { "reset-gpios", &reset_gpios, 1 },
        /*
         * Some platforms have a bug in ACPI GPIO description making IRQ
         * GPIO to be output only. Ask the GPIO core to ignore this limit.
         */
        { "interrupt-gpios", &interrupt_gpios, 1, ACPI_GPIO_QUIRK_NO_IO_RESTRICTION },
        { },
};

static void sx9500_gpio_probe(struct i2c_client *client,
                              struct sx9500_data *data)
{
        struct gpio_desc *gpiod_int;
        struct device *dev;
        int ret;

        if (!client)
                return;

        dev = &client->dev;

        ret = devm_acpi_dev_add_driver_gpios(dev, acpi_sx9500_gpios);
        if (ret)
                dev_dbg(dev, "Unable to add GPIO mapping table\n");

        if (client->irq <= 0) {
                gpiod_int = devm_gpiod_get(dev, "interrupt", GPIOD_IN);
                if (IS_ERR(gpiod_int))
                        dev_err(dev, "gpio get irq failed\n");
                else
                        client->irq = gpiod_to_irq(gpiod_int);
        }

        data->gpiod_rst = devm_gpiod_get(dev, "reset", GPIOD_OUT_HIGH);
        if (IS_ERR(data->gpiod_rst)) {
                dev_warn(dev, "gpio get reset pin failed\n");
                data->gpiod_rst = NULL;
        }
}

static int sx9500_probe(struct i2c_client *client,
                        const struct i2c_device_id *id)
{
        int ret;
        struct iio_dev *indio_dev;
        struct sx9500_data *data;

        indio_dev = devm_iio_device_alloc(&client->dev, sizeof(*data));
        if (indio_dev == NULL)
                return -ENOMEM;

        data = iio_priv(indio_dev);
        data->client = client;
        mutex_init(&data->mutex);
        init_completion(&data->completion);
        data->trigger_enabled = false;

        data->regmap = devm_regmap_init_i2c(client, &sx9500_regmap_config);
        if (IS_ERR(data->regmap))
                return PTR_ERR(data->regmap);

        indio_dev->dev.parent = &client->dev;
        indio_dev->name = SX9500_DRIVER_NAME;
        indio_dev->channels = sx9500_channels;
        indio_dev->num_channels = ARRAY_SIZE(sx9500_channels);
        indio_dev->info = &sx9500_info;
        indio_dev->modes = INDIO_DIRECT_MODE;
        i2c_set_clientdata(client, indio_dev);

        sx9500_gpio_probe(client, data);

        ret = sx9500_init_device(indio_dev);
        if (ret < 0)
                return ret;

        if (client->irq <= 0)
                dev_warn(&client->dev, "no valid irq found\n");
        else {
                ret = devm_request_threaded_irq(&client->dev, client->irq,
                                sx9500_irq_handler, sx9500_irq_thread_handler,
                                IRQF_TRIGGER_FALLING | IRQF_ONESHOT,
                                SX9500_IRQ_NAME, indio_dev);
                if (ret < 0)
                        return ret;

                data->trig = devm_iio_trigger_alloc(&client->dev,
                                "%s-dev%d", indio_dev->name, indio_dev->id);
                if (!data->trig)
                        return -ENOMEM;

                data->trig->dev.parent = &client->dev;
                data->trig->ops = &sx9500_trigger_ops;
                iio_trigger_set_drvdata(data->trig, indio_dev);

                ret = iio_trigger_register(data->trig);
                if (ret)
                        return ret;
        }

        ret = iio_triggered_buffer_setup(indio_dev, NULL,
                                         sx9500_trigger_handler,
                                         &sx9500_buffer_setup_ops);
        if (ret < 0)
                goto out_trigger_unregister;

        ret = iio_device_register(indio_dev);
        if (ret < 0)
                goto out_buffer_cleanup;

        return 0;

out_buffer_cleanup:
        iio_triggered_buffer_cleanup(indio_dev);
out_trigger_unregister:
        if (client->irq > 0)
                iio_trigger_unregister(data->trig);

        return ret;
}

static int sx9500_remove(struct i2c_client *client)
{
        struct iio_dev *indio_dev = i2c_get_clientdata(client);
        struct sx9500_data *data = iio_priv(indio_dev);

        iio_device_unregister(indio_dev);
        iio_triggered_buffer_cleanup(indio_dev);
        if (client->irq > 0)
                iio_trigger_unregister(data->trig);
        kfree(data->buffer);

        return 0;
}

#ifdef CONFIG_PM_SLEEP
static int sx9500_suspend(struct device *dev)
{
        struct iio_dev *indio_dev = i2c_get_clientdata(to_i2c_client(dev));
        struct sx9500_data *data = iio_priv(indio_dev);
        int ret;

        mutex_lock(&data->mutex);
        ret = regmap_read(data->regmap, SX9500_REG_PROX_CTRL0,
                          &data->suspend_ctrl0);
        if (ret < 0)
                goto out;

        /*
         * Scan period doesn't matter because when all the sensors are
         * deactivated the device is in sleep mode.
         */
        ret = regmap_write(data->regmap, SX9500_REG_PROX_CTRL0, 0);

out:
        mutex_unlock(&data->mutex);
        return ret;
}

static int sx9500_resume(struct device *dev)
{
        struct iio_dev *indio_dev = i2c_get_clientdata(to_i2c_client(dev));
        struct sx9500_data *data = iio_priv(indio_dev);
        int ret;

        mutex_lock(&data->mutex);
        ret = regmap_write(data->regmap, SX9500_REG_PROX_CTRL0,
                           data->suspend_ctrl0);
        mutex_unlock(&data->mutex);

        return ret;
}
#endif /* CONFIG_PM_SLEEP */

static const struct dev_pm_ops sx9500_pm_ops = {
        SET_SYSTEM_SLEEP_PM_OPS(sx9500_suspend, sx9500_resume)
};

static const struct acpi_device_id sx9500_acpi_match[] = {
        {"SSX9500", 0},
        {"SASX9500", 0},
        { },
};
MODULE_DEVICE_TABLE(acpi, sx9500_acpi_match);

static const struct of_device_id sx9500_of_match[] = {
        { .compatible = "semtech,sx9500", },
        { }
};
MODULE_DEVICE_TABLE(of, sx9500_of_match);

static const struct i2c_device_id sx9500_id[] = {
        {"sx9500", 0},
        { },
};
MODULE_DEVICE_TABLE(i2c, sx9500_id);

static struct i2c_driver sx9500_driver = {
        .driver = {
                .name   = SX9500_DRIVER_NAME,
                .acpi_match_table = ACPI_PTR(sx9500_acpi_match),
                .of_match_table = of_match_ptr(sx9500_of_match),
                .pm = &sx9500_pm_ops,
        },
        .probe          = sx9500_probe,
        .remove         = sx9500_remove,
        .id_table       = sx9500_id,
};
module_i2c_driver(sx9500_driver);

MODULE_AUTHOR("Vlad Dogaru <vlad.dogaru@intel.com>");
MODULE_DESCRIPTION("Driver for Semtech SX9500 proximity sensor");
MODULE_LICENSE("GPL v2");