WIP FPC-III support

[linux/fpc-iii.git] / drivers / iio / light / si1145.c

// SPDX-License-Identifier: GPL-2.0-only
/*
 * si1145.c - Support for Silabs SI1132 and SI1141/2/3/5/6/7 combined ambient
 * light, UV index and proximity sensors
 *
 * Copyright 2014-16 Peter Meerwald-Stadler <pmeerw@pmeerw.net>
 * Copyright 2016 Crestez Dan Leonard <leonard.crestez@intel.com>
 *
 * SI1132 (7-bit I2C slave address 0x60)
 * SI1141/2/3 (7-bit I2C slave address 0x5a)
 * SI1145/6/6 (7-bit I2C slave address 0x60)
 */

#include <linux/module.h>
#include <linux/i2c.h>
#include <linux/err.h>
#include <linux/slab.h>
#include <linux/delay.h>
#include <linux/irq.h>

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

#define SI1145_REG_PART_ID              0x00
#define SI1145_REG_REV_ID               0x01
#define SI1145_REG_SEQ_ID               0x02
#define SI1145_REG_INT_CFG              0x03
#define SI1145_REG_IRQ_ENABLE           0x04
#define SI1145_REG_IRQ_MODE             0x05
#define SI1145_REG_HW_KEY               0x07
#define SI1145_REG_MEAS_RATE            0x08
#define SI1145_REG_PS_LED21             0x0f
#define SI1145_REG_PS_LED3              0x10
#define SI1145_REG_UCOEF1               0x13
#define SI1145_REG_UCOEF2               0x14
#define SI1145_REG_UCOEF3               0x15
#define SI1145_REG_UCOEF4               0x16
#define SI1145_REG_PARAM_WR             0x17
#define SI1145_REG_COMMAND              0x18
#define SI1145_REG_RESPONSE             0x20
#define SI1145_REG_IRQ_STATUS           0x21
#define SI1145_REG_ALSVIS_DATA          0x22
#define SI1145_REG_ALSIR_DATA           0x24
#define SI1145_REG_PS1_DATA             0x26
#define SI1145_REG_PS2_DATA             0x28
#define SI1145_REG_PS3_DATA             0x2a
#define SI1145_REG_AUX_DATA             0x2c
#define SI1145_REG_PARAM_RD             0x2e
#define SI1145_REG_CHIP_STAT            0x30

#define SI1145_UCOEF1_DEFAULT           0x7b
#define SI1145_UCOEF2_DEFAULT           0x6b
#define SI1145_UCOEF3_DEFAULT           0x01
#define SI1145_UCOEF4_DEFAULT           0x00

/* Helper to figure out PS_LED register / shift per channel */
#define SI1145_PS_LED_REG(ch) \
        (((ch) == 2) ? SI1145_REG_PS_LED3 : SI1145_REG_PS_LED21)
#define SI1145_PS_LED_SHIFT(ch) \
        (((ch) == 1) ? 4 : 0)

/* Parameter offsets */
#define SI1145_PARAM_CHLIST             0x01
#define SI1145_PARAM_PSLED12_SELECT     0x02
#define SI1145_PARAM_PSLED3_SELECT      0x03
#define SI1145_PARAM_PS_ENCODING        0x05
#define SI1145_PARAM_ALS_ENCODING       0x06
#define SI1145_PARAM_PS1_ADC_MUX        0x07
#define SI1145_PARAM_PS2_ADC_MUX        0x08
#define SI1145_PARAM_PS3_ADC_MUX        0x09
#define SI1145_PARAM_PS_ADC_COUNTER     0x0a
#define SI1145_PARAM_PS_ADC_GAIN        0x0b
#define SI1145_PARAM_PS_ADC_MISC        0x0c
#define SI1145_PARAM_ALS_ADC_MUX        0x0d
#define SI1145_PARAM_ALSIR_ADC_MUX      0x0e
#define SI1145_PARAM_AUX_ADC_MUX        0x0f
#define SI1145_PARAM_ALSVIS_ADC_COUNTER 0x10
#define SI1145_PARAM_ALSVIS_ADC_GAIN    0x11
#define SI1145_PARAM_ALSVIS_ADC_MISC    0x12
#define SI1145_PARAM_LED_RECOVERY       0x1c
#define SI1145_PARAM_ALSIR_ADC_COUNTER  0x1d
#define SI1145_PARAM_ALSIR_ADC_GAIN     0x1e
#define SI1145_PARAM_ALSIR_ADC_MISC     0x1f
#define SI1145_PARAM_ADC_OFFSET         0x1a

/* Channel enable masks for CHLIST parameter */
#define SI1145_CHLIST_EN_PS1            BIT(0)
#define SI1145_CHLIST_EN_PS2            BIT(1)
#define SI1145_CHLIST_EN_PS3            BIT(2)
#define SI1145_CHLIST_EN_ALSVIS         BIT(4)
#define SI1145_CHLIST_EN_ALSIR          BIT(5)
#define SI1145_CHLIST_EN_AUX            BIT(6)
#define SI1145_CHLIST_EN_UV             BIT(7)

/* Proximity measurement mode for ADC_MISC parameter */
#define SI1145_PS_ADC_MODE_NORMAL       BIT(2)
/* Signal range mask for ADC_MISC parameter */
#define SI1145_ADC_MISC_RANGE           BIT(5)

/* Commands for REG_COMMAND */
#define SI1145_CMD_NOP                  0x00
#define SI1145_CMD_RESET                0x01
#define SI1145_CMD_PS_FORCE             0x05
#define SI1145_CMD_ALS_FORCE            0x06
#define SI1145_CMD_PSALS_FORCE          0x07
#define SI1145_CMD_PS_PAUSE             0x09
#define SI1145_CMD_ALS_PAUSE            0x0a
#define SI1145_CMD_PSALS_PAUSE          0x0b
#define SI1145_CMD_PS_AUTO              0x0d
#define SI1145_CMD_ALS_AUTO             0x0e
#define SI1145_CMD_PSALS_AUTO           0x0f
#define SI1145_CMD_PARAM_QUERY          0x80
#define SI1145_CMD_PARAM_SET            0xa0

#define SI1145_RSP_INVALID_SETTING      0x80
#define SI1145_RSP_COUNTER_MASK         0x0F

/* Minimum sleep after each command to ensure it's received */
#define SI1145_COMMAND_MINSLEEP_MS      5
/* Return -ETIMEDOUT after this long */
#define SI1145_COMMAND_TIMEOUT_MS       25

/* Interrupt configuration masks for INT_CFG register */
#define SI1145_INT_CFG_OE               BIT(0) /* enable interrupt */
#define SI1145_INT_CFG_MODE             BIT(1) /* auto reset interrupt pin */

/* Interrupt enable masks for IRQ_ENABLE register */
#define SI1145_MASK_ALL_IE              (BIT(4) | BIT(3) | BIT(2) | BIT(0))

#define SI1145_MUX_TEMP                 0x65
#define SI1145_MUX_VDD                  0x75

/* Proximity LED current; see Table 2 in datasheet */
#define SI1145_LED_CURRENT_45mA         0x04

enum {
        SI1132,
        SI1141,
        SI1142,
        SI1143,
        SI1145,
        SI1146,
        SI1147,
};

struct si1145_part_info {
        u8 part;
        const struct iio_info *iio_info;
        const struct iio_chan_spec *channels;
        unsigned int num_channels;
        unsigned int num_leds;
        bool uncompressed_meas_rate;
};

/**
 * struct si1145_data - si1145 chip state data
 * @client:     I2C client
 * @lock:       mutex to protect shared state.
 * @cmdlock:    Low-level mutex to protect command execution only
 * @rsp_seq:    Next expected response number or -1 if counter reset required
 * @scan_mask:  Saved scan mask to avoid duplicate set_chlist
 * @autonomous: If automatic measurements are active (for buffer support)
 * @part_info:  Part information
 * @trig:       Pointer to iio trigger
 * @meas_rate:  Value of MEAS_RATE register. Only set in HW in auto mode
 * @buffer:     Used to pack data read from sensor.
 */
struct si1145_data {
        struct i2c_client *client;
        struct mutex lock;
        struct mutex cmdlock;
        int rsp_seq;
        const struct si1145_part_info *part_info;
        unsigned long scan_mask;
        bool autonomous;
        struct iio_trigger *trig;
        int meas_rate;
        /*
         * Ensure timestamp will be naturally aligned if present.
         * Maximum buffer size (may be only partly used if not all
         * channels are enabled):
         *   6*2 bytes channels data + 4 bytes alignment +
         *   8 bytes timestamp
         */
        u8 buffer[24] __aligned(8);
};

/*
 * __si1145_command_reset() - Send CMD_NOP and wait for response 0
 *
 * Does not modify data->rsp_seq
 *
 * Return: 0 on success and -errno on error.
 */
static int __si1145_command_reset(struct si1145_data *data)
{
        struct device *dev = &data->client->dev;
        unsigned long stop_jiffies;
        int ret;

        ret = i2c_smbus_write_byte_data(data->client, SI1145_REG_COMMAND,
                                                      SI1145_CMD_NOP);
        if (ret < 0)
                return ret;
        msleep(SI1145_COMMAND_MINSLEEP_MS);

        stop_jiffies = jiffies + SI1145_COMMAND_TIMEOUT_MS * HZ / 1000;
        while (true) {
                ret = i2c_smbus_read_byte_data(data->client,
                                               SI1145_REG_RESPONSE);
                if (ret <= 0)
                        return ret;
                if (time_after(jiffies, stop_jiffies)) {
                        dev_warn(dev, "timeout on reset\n");
                        return -ETIMEDOUT;
                }
                msleep(SI1145_COMMAND_MINSLEEP_MS);
                continue;
        }
}

/*
 * si1145_command() - Execute a command and poll the response register
 *
 * All conversion overflows are reported as -EOVERFLOW
 * INVALID_SETTING is reported as -EINVAL
 * Timeouts are reported as -ETIMEDOUT
 *
 * Return: 0 on success or -errno on failure
 */
static int si1145_command(struct si1145_data *data, u8 cmd)
{
        struct device *dev = &data->client->dev;
        unsigned long stop_jiffies;
        int ret;

        mutex_lock(&data->cmdlock);

        if (data->rsp_seq < 0) {
                ret = __si1145_command_reset(data);
                if (ret < 0) {
                        dev_err(dev, "failed to reset command counter, ret=%d\n",
                                ret);
                        goto out;
                }
                data->rsp_seq = 0;
        }

        ret = i2c_smbus_write_byte_data(data->client, SI1145_REG_COMMAND, cmd);
        if (ret) {
                dev_warn(dev, "failed to write command, ret=%d\n", ret);
                goto out;
        }
        /* Sleep a little to ensure the command is received */
        msleep(SI1145_COMMAND_MINSLEEP_MS);

        stop_jiffies = jiffies + SI1145_COMMAND_TIMEOUT_MS * HZ / 1000;
        while (true) {
                ret = i2c_smbus_read_byte_data(data->client,
                                               SI1145_REG_RESPONSE);
                if (ret < 0) {
                        dev_warn(dev, "failed to read response, ret=%d\n", ret);
                        break;
                }

                if ((ret & ~SI1145_RSP_COUNTER_MASK) == 0) {
                        if (ret == data->rsp_seq) {
                                if (time_after(jiffies, stop_jiffies)) {
                                        dev_warn(dev, "timeout on command %#02hhx\n",
                                                 cmd);
                                        ret = -ETIMEDOUT;
                                        break;
                                }
                                msleep(SI1145_COMMAND_MINSLEEP_MS);
                                continue;
                        }
                        if (ret == ((data->rsp_seq + 1) &
                                SI1145_RSP_COUNTER_MASK)) {
                                data->rsp_seq = ret;
                                ret = 0;
                                break;
                        }
                        dev_warn(dev, "unexpected response counter %d instead of %d\n",
                                 ret, (data->rsp_seq + 1) &
                                        SI1145_RSP_COUNTER_MASK);
                        ret = -EIO;
                } else {
                        if (ret == SI1145_RSP_INVALID_SETTING) {
                                dev_warn(dev, "INVALID_SETTING error on command %#02hhx\n",
                                         cmd);
                                ret = -EINVAL;
                        } else {
                                /* All overflows are treated identically */
                                dev_dbg(dev, "overflow, ret=%d, cmd=%#02hhx\n",
                                        ret, cmd);
                                ret = -EOVERFLOW;
                        }
                }

                /* Force a counter reset next time */
                data->rsp_seq = -1;
                break;
        }

out:
        mutex_unlock(&data->cmdlock);

        return ret;
}

static int si1145_param_update(struct si1145_data *data, u8 op, u8 param,
                               u8 value)
{
        int ret;

        ret = i2c_smbus_write_byte_data(data->client,
                SI1145_REG_PARAM_WR, value);
        if (ret < 0)
                return ret;

        return si1145_command(data, op | (param & 0x1F));
}

static int si1145_param_set(struct si1145_data *data, u8 param, u8 value)
{
        return si1145_param_update(data, SI1145_CMD_PARAM_SET, param, value);
}

/* Set param. Returns negative errno or current value */
static int si1145_param_query(struct si1145_data *data, u8 param)
{
        int ret;

        ret = si1145_command(data, SI1145_CMD_PARAM_QUERY | (param & 0x1F));
        if (ret < 0)
                return ret;

        return i2c_smbus_read_byte_data(data->client, SI1145_REG_PARAM_RD);
}

/* Expand 8 bit compressed value to 16 bit, see Silabs AN498 */
static u16 si1145_uncompress(u8 x)
{
        u16 result = 0;
        u8 exponent = 0;

        if (x < 8)
                return 0;

        exponent = (x & 0xf0) >> 4;
        result = 0x10 | (x & 0x0f);

        if (exponent >= 4)
                return result << (exponent - 4);
        return result >> (4 - exponent);
}

/* Compress 16 bit value to 8 bit, see Silabs AN498 */
static u8 si1145_compress(u16 x)
{
        u32 exponent = 0;
        u32 significand = 0;
        u32 tmp = x;

        if (x == 0x0000)
                return 0x00;
        if (x == 0x0001)
                return 0x08;

        while (1) {
                tmp >>= 1;
                exponent += 1;
                if (tmp == 1)
                        break;
        }

        if (exponent < 5) {
                significand = x << (4 - exponent);
                return (exponent << 4) | (significand & 0xF);
        }

        significand = x >> (exponent - 5);
        if (significand & 1) {
                significand += 2;
                if (significand & 0x0040) {
                        exponent += 1;
                        significand >>= 1;
                }
        }

        return (exponent << 4) | ((significand >> 1) & 0xF);
}

/* Write meas_rate in hardware */
static int si1145_set_meas_rate(struct si1145_data *data, int interval)
{
        if (data->part_info->uncompressed_meas_rate)
                return i2c_smbus_write_word_data(data->client,
                        SI1145_REG_MEAS_RATE, interval);
        else
                return i2c_smbus_write_byte_data(data->client,
                        SI1145_REG_MEAS_RATE, interval);
}

static int si1145_read_samp_freq(struct si1145_data *data, int *val, int *val2)
{
        *val = 32000;
        if (data->part_info->uncompressed_meas_rate)
                *val2 = data->meas_rate;
        else
                *val2 = si1145_uncompress(data->meas_rate);
        return IIO_VAL_FRACTIONAL;
}

/* Set the samp freq in driver private data */
static int si1145_store_samp_freq(struct si1145_data *data, int val)
{
        int ret = 0;
        int meas_rate;

        if (val <= 0 || val > 32000)
                return -ERANGE;
        meas_rate = 32000 / val;

        mutex_lock(&data->lock);
        if (data->autonomous) {
                ret = si1145_set_meas_rate(data, meas_rate);
                if (ret)
                        goto out;
        }
        if (data->part_info->uncompressed_meas_rate)
                data->meas_rate = meas_rate;
        else
                data->meas_rate = si1145_compress(meas_rate);

out:
        mutex_unlock(&data->lock);

        return ret;
}

static irqreturn_t si1145_trigger_handler(int irq, void *private)
{
        struct iio_poll_func *pf = private;
        struct iio_dev *indio_dev = pf->indio_dev;
        struct si1145_data *data = iio_priv(indio_dev);
        int i, j = 0;
        int ret;
        u8 irq_status = 0;

        if (!data->autonomous) {
                ret = si1145_command(data, SI1145_CMD_PSALS_FORCE);
                if (ret < 0 && ret != -EOVERFLOW)
                        goto done;
        } else {
                irq_status = ret = i2c_smbus_read_byte_data(data->client,
                                SI1145_REG_IRQ_STATUS);
                if (ret < 0)
                        goto done;
                if (!(irq_status & SI1145_MASK_ALL_IE))
                        goto done;
        }

        for_each_set_bit(i, indio_dev->active_scan_mask,
                indio_dev->masklength) {
                int run = 1;

                while (i + run < indio_dev->masklength) {
                        if (!test_bit(i + run, indio_dev->active_scan_mask))
                                break;
                        if (indio_dev->channels[i + run].address !=
                                indio_dev->channels[i].address + 2 * run)
                                break;
                        run++;
                }

                ret = i2c_smbus_read_i2c_block_data_or_emulated(
                                data->client, indio_dev->channels[i].address,
                                sizeof(u16) * run, &data->buffer[j]);
                if (ret < 0)
                        goto done;
                j += run * sizeof(u16);
                i += run - 1;
        }

        if (data->autonomous) {
                ret = i2c_smbus_write_byte_data(data->client,
                                SI1145_REG_IRQ_STATUS,
                                irq_status & SI1145_MASK_ALL_IE);
                if (ret < 0)
                        goto done;
        }

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

done:
        iio_trigger_notify_done(indio_dev->trig);
        return IRQ_HANDLED;
}

static int si1145_set_chlist(struct iio_dev *indio_dev, unsigned long scan_mask)
{
        struct si1145_data *data = iio_priv(indio_dev);
        u8 reg = 0, mux;
        int ret;
        int i;

        /* channel list already set, no need to reprogram */
        if (data->scan_mask == scan_mask)
                return 0;

        for_each_set_bit(i, &scan_mask, indio_dev->masklength) {
                switch (indio_dev->channels[i].address) {
                case SI1145_REG_ALSVIS_DATA:
                        reg |= SI1145_CHLIST_EN_ALSVIS;
                        break;
                case SI1145_REG_ALSIR_DATA:
                        reg |= SI1145_CHLIST_EN_ALSIR;
                        break;
                case SI1145_REG_PS1_DATA:
                        reg |= SI1145_CHLIST_EN_PS1;
                        break;
                case SI1145_REG_PS2_DATA:
                        reg |= SI1145_CHLIST_EN_PS2;
                        break;
                case SI1145_REG_PS3_DATA:
                        reg |= SI1145_CHLIST_EN_PS3;
                        break;
                case SI1145_REG_AUX_DATA:
                        switch (indio_dev->channels[i].type) {
                        case IIO_UVINDEX:
                                reg |= SI1145_CHLIST_EN_UV;
                                break;
                        default:
                                reg |= SI1145_CHLIST_EN_AUX;
                                if (indio_dev->channels[i].type == IIO_TEMP)
                                        mux = SI1145_MUX_TEMP;
                                else
                                        mux = SI1145_MUX_VDD;
                                ret = si1145_param_set(data,
                                        SI1145_PARAM_AUX_ADC_MUX, mux);
                                if (ret < 0)
                                        return ret;

                                break;
                        }
                }
        }

        data->scan_mask = scan_mask;
        ret = si1145_param_set(data, SI1145_PARAM_CHLIST, reg);

        return ret < 0 ? ret : 0;
}

static int si1145_measure(struct iio_dev *indio_dev,
                          struct iio_chan_spec const *chan)
{
        struct si1145_data *data = iio_priv(indio_dev);
        u8 cmd;
        int ret;

        ret = si1145_set_chlist(indio_dev, BIT(chan->scan_index));
        if (ret < 0)
                return ret;

        cmd = (chan->type == IIO_PROXIMITY) ? SI1145_CMD_PS_FORCE :
                SI1145_CMD_ALS_FORCE;
        ret = si1145_command(data, cmd);
        if (ret < 0 && ret != -EOVERFLOW)
                return ret;

        return i2c_smbus_read_word_data(data->client, chan->address);
}

/*
 * Conversion between iio scale and ADC_GAIN values
 * These could be further adjusted but proximity/intensity are dimensionless
 */
static const int si1145_proximity_scale_available[] = {
        128, 64, 32, 16, 8, 4};
static const int si1145_intensity_scale_available[] = {
        128, 64, 32, 16, 8, 4, 2, 1};
static IIO_CONST_ATTR(in_proximity_scale_available,
        "128 64 32 16 8 4");
static IIO_CONST_ATTR(in_intensity_scale_available,
        "128 64 32 16 8 4 2 1");
static IIO_CONST_ATTR(in_intensity_ir_scale_available,
        "128 64 32 16 8 4 2 1");

static int si1145_scale_from_adcgain(int regval)
{
        return 128 >> regval;
}

static int si1145_proximity_adcgain_from_scale(int val, int val2)
{
        val = find_closest_descending(val, si1145_proximity_scale_available,
                                ARRAY_SIZE(si1145_proximity_scale_available));
        if (val < 0 || val > 5 || val2 != 0)
                return -EINVAL;

        return val;
}

static int si1145_intensity_adcgain_from_scale(int val, int val2)
{
        val = find_closest_descending(val, si1145_intensity_scale_available,
                                ARRAY_SIZE(si1145_intensity_scale_available));
        if (val < 0 || val > 7 || val2 != 0)
                return -EINVAL;

        return val;
}

static int si1145_read_raw(struct iio_dev *indio_dev,
                                struct iio_chan_spec const *chan,
                                int *val, int *val2, long mask)
{
        struct si1145_data *data = iio_priv(indio_dev);
        int ret;
        u8 reg;

        switch (mask) {
        case IIO_CHAN_INFO_RAW:
                switch (chan->type) {
                case IIO_INTENSITY:
                case IIO_PROXIMITY:
                case IIO_VOLTAGE:
                case IIO_TEMP:
                case IIO_UVINDEX:
                        ret = iio_device_claim_direct_mode(indio_dev);
                        if (ret)
                                return ret;
                        ret = si1145_measure(indio_dev, chan);
                        iio_device_release_direct_mode(indio_dev);

                        if (ret < 0)
                                return ret;

                        *val = ret;

                        return IIO_VAL_INT;
                case IIO_CURRENT:
                        ret = i2c_smbus_read_byte_data(data->client,
                                SI1145_PS_LED_REG(chan->channel));
                        if (ret < 0)
                                return ret;

                        *val = (ret >> SI1145_PS_LED_SHIFT(chan->channel))
                                & 0x0f;

                        return IIO_VAL_INT;
                default:
                        return -EINVAL;
                }
        case IIO_CHAN_INFO_SCALE:
                switch (chan->type) {
                case IIO_PROXIMITY:
                        reg = SI1145_PARAM_PS_ADC_GAIN;
                        break;
                case IIO_INTENSITY:
                        if (chan->channel2 == IIO_MOD_LIGHT_IR)
                                reg = SI1145_PARAM_ALSIR_ADC_GAIN;
                        else
                                reg = SI1145_PARAM_ALSVIS_ADC_GAIN;
                        break;
                case IIO_TEMP:
                        *val = 28;
                        *val2 = 571429;
                        return IIO_VAL_INT_PLUS_MICRO;
                case IIO_UVINDEX:
                        *val = 0;
                        *val2 = 10000;
                        return IIO_VAL_INT_PLUS_MICRO;
                default:
                        return -EINVAL;
                }

                ret = si1145_param_query(data, reg);
                if (ret < 0)
                        return ret;

                *val = si1145_scale_from_adcgain(ret & 0x07);

                return IIO_VAL_INT;
        case IIO_CHAN_INFO_OFFSET:
                switch (chan->type) {
                case IIO_TEMP:
                        /*
                         * -ADC offset - ADC counts @ 25°C -
                         *   35 * ADC counts / °C
                         */
                        *val = -256 - 11136 + 25 * 35;
                        return IIO_VAL_INT;
                default:
                        /*
                         * All ADC measurements have are by default offset
                         * by -256
                         * See AN498 5.6.3
                         */
                        ret = si1145_param_query(data, SI1145_PARAM_ADC_OFFSET);
                        if (ret < 0)
                                return ret;
                        *val = -si1145_uncompress(ret);
                        return IIO_VAL_INT;
                }
        case IIO_CHAN_INFO_SAMP_FREQ:
                return si1145_read_samp_freq(data, val, val2);
        default:
                return -EINVAL;
        }
}

static int si1145_write_raw(struct iio_dev *indio_dev,
                               struct iio_chan_spec const *chan,
                               int val, int val2, long mask)
{
        struct si1145_data *data = iio_priv(indio_dev);
        u8 reg1, reg2, shift;
        int ret;

        switch (mask) {
        case IIO_CHAN_INFO_SCALE:
                switch (chan->type) {
                case IIO_PROXIMITY:
                        val = si1145_proximity_adcgain_from_scale(val, val2);
                        if (val < 0)
                                return val;
                        reg1 = SI1145_PARAM_PS_ADC_GAIN;
                        reg2 = SI1145_PARAM_PS_ADC_COUNTER;
                        break;
                case IIO_INTENSITY:
                        val = si1145_intensity_adcgain_from_scale(val, val2);
                        if (val < 0)
                                return val;
                        if (chan->channel2 == IIO_MOD_LIGHT_IR) {
                                reg1 = SI1145_PARAM_ALSIR_ADC_GAIN;
                                reg2 = SI1145_PARAM_ALSIR_ADC_COUNTER;
                        } else {
                                reg1 = SI1145_PARAM_ALSVIS_ADC_GAIN;
                                reg2 = SI1145_PARAM_ALSVIS_ADC_COUNTER;
                        }
                        break;
                default:
                        return -EINVAL;
                }

                ret = iio_device_claim_direct_mode(indio_dev);
                if (ret)
                        return ret;

                ret = si1145_param_set(data, reg1, val);
                if (ret < 0) {
                        iio_device_release_direct_mode(indio_dev);
                        return ret;
                }
                /* Set recovery period to one's complement of gain */
                ret = si1145_param_set(data, reg2, (~val & 0x07) << 4);
                iio_device_release_direct_mode(indio_dev);
                return ret;
        case IIO_CHAN_INFO_RAW:
                if (chan->type != IIO_CURRENT)
                        return -EINVAL;

                if (val < 0 || val > 15 || val2 != 0)
                        return -EINVAL;

                reg1 = SI1145_PS_LED_REG(chan->channel);
                shift = SI1145_PS_LED_SHIFT(chan->channel);

                ret = iio_device_claim_direct_mode(indio_dev);
                if (ret)
                        return ret;

                ret = i2c_smbus_read_byte_data(data->client, reg1);
                if (ret < 0) {
                        iio_device_release_direct_mode(indio_dev);
                        return ret;
                }
                ret = i2c_smbus_write_byte_data(data->client, reg1,
                        (ret & ~(0x0f << shift)) |
                        ((val & 0x0f) << shift));
                iio_device_release_direct_mode(indio_dev);
                return ret;
        case IIO_CHAN_INFO_SAMP_FREQ:
                return si1145_store_samp_freq(data, val);
        default:
                return -EINVAL;
        }
}

#define SI1145_ST { \
        .sign = 'u', \
        .realbits = 16, \
        .storagebits = 16, \
        .endianness = IIO_LE, \
}

#define SI1145_INTENSITY_CHANNEL(_si) { \
        .type = IIO_INTENSITY, \
        .info_mask_separate = BIT(IIO_CHAN_INFO_RAW) | \
                              BIT(IIO_CHAN_INFO_OFFSET) | \
                              BIT(IIO_CHAN_INFO_SCALE), \
        .info_mask_shared_by_all = BIT(IIO_CHAN_INFO_SAMP_FREQ), \
        .scan_type = SI1145_ST, \
        .scan_index = _si, \
        .address = SI1145_REG_ALSVIS_DATA, \
}

#define SI1145_INTENSITY_IR_CHANNEL(_si) { \
        .type = IIO_INTENSITY, \
        .info_mask_separate = BIT(IIO_CHAN_INFO_RAW) | \
                              BIT(IIO_CHAN_INFO_OFFSET) | \
                              BIT(IIO_CHAN_INFO_SCALE), \
        .info_mask_shared_by_all = BIT(IIO_CHAN_INFO_SAMP_FREQ), \
        .modified = 1, \
        .channel2 = IIO_MOD_LIGHT_IR, \
        .scan_type = SI1145_ST, \
        .scan_index = _si, \
        .address = SI1145_REG_ALSIR_DATA, \
}

#define SI1145_TEMP_CHANNEL(_si) { \
        .type = IIO_TEMP, \
        .info_mask_separate = BIT(IIO_CHAN_INFO_RAW) | \
                              BIT(IIO_CHAN_INFO_OFFSET) | \
                              BIT(IIO_CHAN_INFO_SCALE), \
        .info_mask_shared_by_all = BIT(IIO_CHAN_INFO_SAMP_FREQ), \
        .scan_type = SI1145_ST, \
        .scan_index = _si, \
        .address = SI1145_REG_AUX_DATA, \
}

#define SI1145_UV_CHANNEL(_si) { \
        .type = IIO_UVINDEX, \
        .info_mask_separate = BIT(IIO_CHAN_INFO_RAW) | \
                              BIT(IIO_CHAN_INFO_SCALE), \
        .info_mask_shared_by_all = BIT(IIO_CHAN_INFO_SAMP_FREQ), \
        .scan_type = SI1145_ST, \
        .scan_index = _si, \
        .address = SI1145_REG_AUX_DATA, \
}

#define SI1145_PROXIMITY_CHANNEL(_si, _ch) { \
        .type = IIO_PROXIMITY, \
        .indexed = 1, \
        .channel = _ch, \
        .info_mask_separate = BIT(IIO_CHAN_INFO_RAW), \
        .info_mask_shared_by_type = BIT(IIO_CHAN_INFO_SCALE) | \
                                    BIT(IIO_CHAN_INFO_OFFSET), \
        .info_mask_shared_by_all = BIT(IIO_CHAN_INFO_SAMP_FREQ), \
        .scan_type = SI1145_ST, \
        .scan_index = _si, \
        .address = SI1145_REG_PS1_DATA + _ch * 2, \
}

#define SI1145_VOLTAGE_CHANNEL(_si) { \
        .type = IIO_VOLTAGE, \
        .info_mask_separate = BIT(IIO_CHAN_INFO_RAW), \
        .info_mask_shared_by_all = BIT(IIO_CHAN_INFO_SAMP_FREQ), \
        .scan_type = SI1145_ST, \
        .scan_index = _si, \
        .address = SI1145_REG_AUX_DATA, \
}

#define SI1145_CURRENT_CHANNEL(_ch) { \
        .type = IIO_CURRENT, \
        .indexed = 1, \
        .channel = _ch, \
        .output = 1, \
        .scan_index = -1, \
        .info_mask_separate = BIT(IIO_CHAN_INFO_RAW), \
}

static const struct iio_chan_spec si1132_channels[] = {
        SI1145_INTENSITY_CHANNEL(0),
        SI1145_INTENSITY_IR_CHANNEL(1),
        SI1145_TEMP_CHANNEL(2),
        SI1145_VOLTAGE_CHANNEL(3),
        SI1145_UV_CHANNEL(4),
        IIO_CHAN_SOFT_TIMESTAMP(6),
};

static const struct iio_chan_spec si1141_channels[] = {
        SI1145_INTENSITY_CHANNEL(0),
        SI1145_INTENSITY_IR_CHANNEL(1),
        SI1145_PROXIMITY_CHANNEL(2, 0),
        SI1145_TEMP_CHANNEL(3),
        SI1145_VOLTAGE_CHANNEL(4),
        IIO_CHAN_SOFT_TIMESTAMP(5),
        SI1145_CURRENT_CHANNEL(0),
};

static const struct iio_chan_spec si1142_channels[] = {
        SI1145_INTENSITY_CHANNEL(0),
        SI1145_INTENSITY_IR_CHANNEL(1),
        SI1145_PROXIMITY_CHANNEL(2, 0),
        SI1145_PROXIMITY_CHANNEL(3, 1),
        SI1145_TEMP_CHANNEL(4),
        SI1145_VOLTAGE_CHANNEL(5),
        IIO_CHAN_SOFT_TIMESTAMP(6),
        SI1145_CURRENT_CHANNEL(0),
        SI1145_CURRENT_CHANNEL(1),
};

static const struct iio_chan_spec si1143_channels[] = {
        SI1145_INTENSITY_CHANNEL(0),
        SI1145_INTENSITY_IR_CHANNEL(1),
        SI1145_PROXIMITY_CHANNEL(2, 0),
        SI1145_PROXIMITY_CHANNEL(3, 1),
        SI1145_PROXIMITY_CHANNEL(4, 2),
        SI1145_TEMP_CHANNEL(5),
        SI1145_VOLTAGE_CHANNEL(6),
        IIO_CHAN_SOFT_TIMESTAMP(7),
        SI1145_CURRENT_CHANNEL(0),
        SI1145_CURRENT_CHANNEL(1),
        SI1145_CURRENT_CHANNEL(2),
};

static const struct iio_chan_spec si1145_channels[] = {
        SI1145_INTENSITY_CHANNEL(0),
        SI1145_INTENSITY_IR_CHANNEL(1),
        SI1145_PROXIMITY_CHANNEL(2, 0),
        SI1145_TEMP_CHANNEL(3),
        SI1145_VOLTAGE_CHANNEL(4),
        SI1145_UV_CHANNEL(5),
        IIO_CHAN_SOFT_TIMESTAMP(6),
        SI1145_CURRENT_CHANNEL(0),
};

static const struct iio_chan_spec si1146_channels[] = {
        SI1145_INTENSITY_CHANNEL(0),
        SI1145_INTENSITY_IR_CHANNEL(1),
        SI1145_TEMP_CHANNEL(2),
        SI1145_VOLTAGE_CHANNEL(3),
        SI1145_UV_CHANNEL(4),
        SI1145_PROXIMITY_CHANNEL(5, 0),
        SI1145_PROXIMITY_CHANNEL(6, 1),
        IIO_CHAN_SOFT_TIMESTAMP(7),
        SI1145_CURRENT_CHANNEL(0),
        SI1145_CURRENT_CHANNEL(1),
};

static const struct iio_chan_spec si1147_channels[] = {
        SI1145_INTENSITY_CHANNEL(0),
        SI1145_INTENSITY_IR_CHANNEL(1),
        SI1145_PROXIMITY_CHANNEL(2, 0),
        SI1145_PROXIMITY_CHANNEL(3, 1),
        SI1145_PROXIMITY_CHANNEL(4, 2),
        SI1145_TEMP_CHANNEL(5),
        SI1145_VOLTAGE_CHANNEL(6),
        SI1145_UV_CHANNEL(7),
        IIO_CHAN_SOFT_TIMESTAMP(8),
        SI1145_CURRENT_CHANNEL(0),
        SI1145_CURRENT_CHANNEL(1),
        SI1145_CURRENT_CHANNEL(2),
};

static struct attribute *si1132_attributes[] = {
        &iio_const_attr_in_intensity_scale_available.dev_attr.attr,
        &iio_const_attr_in_intensity_ir_scale_available.dev_attr.attr,
        NULL,
};

static struct attribute *si114x_attributes[] = {
        &iio_const_attr_in_intensity_scale_available.dev_attr.attr,
        &iio_const_attr_in_intensity_ir_scale_available.dev_attr.attr,
        &iio_const_attr_in_proximity_scale_available.dev_attr.attr,
        NULL,
};

static const struct attribute_group si1132_attribute_group = {
        .attrs = si1132_attributes,
};

static const struct attribute_group si114x_attribute_group = {
        .attrs = si114x_attributes,
};


static const struct iio_info si1132_info = {
        .read_raw = si1145_read_raw,
        .write_raw = si1145_write_raw,
        .attrs = &si1132_attribute_group,
};

static const struct iio_info si114x_info = {
        .read_raw = si1145_read_raw,
        .write_raw = si1145_write_raw,
        .attrs = &si114x_attribute_group,
};

#define SI1145_PART(id, iio_info, chans, leds, uncompressed_meas_rate) \
        {id, iio_info, chans, ARRAY_SIZE(chans), leds, uncompressed_meas_rate}

static const struct si1145_part_info si1145_part_info[] = {
        [SI1132] = SI1145_PART(0x32, &si1132_info, si1132_channels, 0, true),
        [SI1141] = SI1145_PART(0x41, &si114x_info, si1141_channels, 1, false),
        [SI1142] = SI1145_PART(0x42, &si114x_info, si1142_channels, 2, false),
        [SI1143] = SI1145_PART(0x43, &si114x_info, si1143_channels, 3, false),
        [SI1145] = SI1145_PART(0x45, &si114x_info, si1145_channels, 1, true),
        [SI1146] = SI1145_PART(0x46, &si114x_info, si1146_channels, 2, true),
        [SI1147] = SI1145_PART(0x47, &si114x_info, si1147_channels, 3, true),
};

static int si1145_initialize(struct si1145_data *data)
{
        struct i2c_client *client = data->client;
        int ret;

        ret = i2c_smbus_write_byte_data(client, SI1145_REG_COMMAND,
                                        SI1145_CMD_RESET);
        if (ret < 0)
                return ret;
        msleep(SI1145_COMMAND_TIMEOUT_MS);

        /* Hardware key, magic value */
        ret = i2c_smbus_write_byte_data(client, SI1145_REG_HW_KEY, 0x17);
        if (ret < 0)
                return ret;
        msleep(SI1145_COMMAND_TIMEOUT_MS);

        /* Turn off autonomous mode */
        ret = si1145_set_meas_rate(data, 0);
        if (ret < 0)
                return ret;

        /* Initialize sampling freq to 10 Hz */
        ret = si1145_store_samp_freq(data, 10);
        if (ret < 0)
                return ret;

        /* Set LED currents to 45 mA; have 4 bits, see Table 2 in datasheet */
        switch (data->part_info->num_leds) {
        case 3:
                ret = i2c_smbus_write_byte_data(client,
                                                SI1145_REG_PS_LED3,
                                                SI1145_LED_CURRENT_45mA);
                if (ret < 0)
                        return ret;
                fallthrough;
        case 2:
                ret = i2c_smbus_write_byte_data(client,
                                                SI1145_REG_PS_LED21,
                                                (SI1145_LED_CURRENT_45mA << 4) |
                                                SI1145_LED_CURRENT_45mA);
                break;
        case 1:
                ret = i2c_smbus_write_byte_data(client,
                                                SI1145_REG_PS_LED21,
                                                SI1145_LED_CURRENT_45mA);
                break;
        default:
                ret = 0;
                break;
        }
        if (ret < 0)
                return ret;

        /* Set normal proximity measurement mode */
        ret = si1145_param_set(data, SI1145_PARAM_PS_ADC_MISC,
                               SI1145_PS_ADC_MODE_NORMAL);
        if (ret < 0)
                return ret;

        ret = si1145_param_set(data, SI1145_PARAM_PS_ADC_GAIN, 0x01);
        if (ret < 0)
                return ret;

        /* ADC_COUNTER should be one complement of ADC_GAIN */
        ret = si1145_param_set(data, SI1145_PARAM_PS_ADC_COUNTER, 0x06 << 4);
        if (ret < 0)
                return ret;

        /* Set ALS visible measurement mode */
        ret = si1145_param_set(data, SI1145_PARAM_ALSVIS_ADC_MISC,
                               SI1145_ADC_MISC_RANGE);
        if (ret < 0)
                return ret;

        ret = si1145_param_set(data, SI1145_PARAM_ALSVIS_ADC_GAIN, 0x03);
        if (ret < 0)
                return ret;

        ret = si1145_param_set(data, SI1145_PARAM_ALSVIS_ADC_COUNTER,
                               0x04 << 4);
        if (ret < 0)
                return ret;

        /* Set ALS IR measurement mode */
        ret = si1145_param_set(data, SI1145_PARAM_ALSIR_ADC_MISC,
                               SI1145_ADC_MISC_RANGE);
        if (ret < 0)
                return ret;

        ret = si1145_param_set(data, SI1145_PARAM_ALSIR_ADC_GAIN, 0x01);
        if (ret < 0)
                return ret;

        ret = si1145_param_set(data, SI1145_PARAM_ALSIR_ADC_COUNTER,
                               0x06 << 4);
        if (ret < 0)
                return ret;

        /*
         * Initialize UCOEF to default values in datasheet
         * These registers are normally zero on reset
         */
        if (data->part_info == &si1145_part_info[SI1132] ||
                data->part_info == &si1145_part_info[SI1145] ||
                data->part_info == &si1145_part_info[SI1146] ||
                data->part_info == &si1145_part_info[SI1147]) {
                ret = i2c_smbus_write_byte_data(data->client,
                                                SI1145_REG_UCOEF1,
                                                SI1145_UCOEF1_DEFAULT);
                if (ret < 0)
                        return ret;
                ret = i2c_smbus_write_byte_data(data->client,
                                SI1145_REG_UCOEF2, SI1145_UCOEF2_DEFAULT);
                if (ret < 0)
                        return ret;
                ret = i2c_smbus_write_byte_data(data->client,
                                SI1145_REG_UCOEF3, SI1145_UCOEF3_DEFAULT);
                if (ret < 0)
                        return ret;
                ret = i2c_smbus_write_byte_data(data->client,
                                SI1145_REG_UCOEF4, SI1145_UCOEF4_DEFAULT);
                if (ret < 0)
                        return ret;
        }

        return 0;
}

/*
 * Program the channels we want to measure with CMD_PSALS_AUTO. No need for
 * _postdisable as we stop with CMD_PSALS_PAUSE; single measurement (direct)
 * mode reprograms the channels list anyway...
 */
static int si1145_buffer_preenable(struct iio_dev *indio_dev)
{
        struct si1145_data *data = iio_priv(indio_dev);
        int ret;

        mutex_lock(&data->lock);
        ret = si1145_set_chlist(indio_dev, *indio_dev->active_scan_mask);
        mutex_unlock(&data->lock);

        return ret;
}

static bool si1145_validate_scan_mask(struct iio_dev *indio_dev,
                               const unsigned long *scan_mask)
{
        struct si1145_data *data = iio_priv(indio_dev);
        unsigned int count = 0;
        int i;

        /* Check that at most one AUX channel is enabled */
        for_each_set_bit(i, scan_mask, data->part_info->num_channels) {
                if (indio_dev->channels[i].address == SI1145_REG_AUX_DATA)
                        count++;
        }

        return count <= 1;
}

static const struct iio_buffer_setup_ops si1145_buffer_setup_ops = {
        .preenable = si1145_buffer_preenable,
        .validate_scan_mask = si1145_validate_scan_mask,
};

/*
 * si1145_trigger_set_state() - Set trigger state
 *
 * When not using triggers interrupts are disabled and measurement rate is
 * set to zero in order to minimize power consumption.
 */
static int si1145_trigger_set_state(struct iio_trigger *trig, bool state)
{
        struct iio_dev *indio_dev = iio_trigger_get_drvdata(trig);
        struct si1145_data *data = iio_priv(indio_dev);
        int err = 0, ret;

        mutex_lock(&data->lock);

        if (state) {
                data->autonomous = true;
                err = i2c_smbus_write_byte_data(data->client,
                                SI1145_REG_INT_CFG, SI1145_INT_CFG_OE);
                if (err < 0)
                        goto disable;
                err = i2c_smbus_write_byte_data(data->client,
                                SI1145_REG_IRQ_ENABLE, SI1145_MASK_ALL_IE);
                if (err < 0)
                        goto disable;
                err = si1145_set_meas_rate(data, data->meas_rate);
                if (err < 0)
                        goto disable;
                err = si1145_command(data, SI1145_CMD_PSALS_AUTO);
                if (err < 0)
                        goto disable;
        } else {
disable:
                /* Disable as much as possible skipping errors */
                ret = si1145_command(data, SI1145_CMD_PSALS_PAUSE);
                if (ret < 0 && !err)
                        err = ret;
                ret = si1145_set_meas_rate(data, 0);
                if (ret < 0 && !err)
                        err = ret;
                ret = i2c_smbus_write_byte_data(data->client,
                                                SI1145_REG_IRQ_ENABLE, 0);
                if (ret < 0 && !err)
                        err = ret;
                ret = i2c_smbus_write_byte_data(data->client,
                                                SI1145_REG_INT_CFG, 0);
                if (ret < 0 && !err)
                        err = ret;
                data->autonomous = false;
        }

        mutex_unlock(&data->lock);
        return err;
}

static const struct iio_trigger_ops si1145_trigger_ops = {
        .set_trigger_state = si1145_trigger_set_state,
};

static int si1145_probe_trigger(struct iio_dev *indio_dev)
{
        struct si1145_data *data = iio_priv(indio_dev);
        struct i2c_client *client = data->client;
        struct iio_trigger *trig;
        int ret;

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

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

        ret = devm_request_irq(&client->dev, client->irq,
                          iio_trigger_generic_data_rdy_poll,
                          IRQF_TRIGGER_FALLING,
                          "si1145_irq",
                          trig);
        if (ret < 0) {
                dev_err(&client->dev, "irq request failed\n");
                return ret;
        }

        ret = devm_iio_trigger_register(&client->dev, trig);
        if (ret)
                return ret;

        data->trig = trig;
        indio_dev->trig = iio_trigger_get(data->trig);

        return 0;
}

static int si1145_probe(struct i2c_client *client,
                        const struct i2c_device_id *id)
{
        struct si1145_data *data;
        struct iio_dev *indio_dev;
        u8 part_id, rev_id, seq_id;
        int ret;

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

        data = iio_priv(indio_dev);
        i2c_set_clientdata(client, indio_dev);
        data->client = client;
        data->part_info = &si1145_part_info[id->driver_data];

        part_id = ret = i2c_smbus_read_byte_data(data->client,
                                                 SI1145_REG_PART_ID);
        if (ret < 0)
                return ret;
        rev_id = ret = i2c_smbus_read_byte_data(data->client,
                                                SI1145_REG_REV_ID);
        if (ret < 0)
                return ret;
        seq_id = ret = i2c_smbus_read_byte_data(data->client,
                                                SI1145_REG_SEQ_ID);
        if (ret < 0)
                return ret;
        dev_info(&client->dev, "device ID part %#02hhx rev %#02hhx seq %#02hhx\n",
                        part_id, rev_id, seq_id);
        if (part_id != data->part_info->part) {
                dev_err(&client->dev, "part ID mismatch got %#02hhx, expected %#02x\n",
                                part_id, data->part_info->part);
                return -ENODEV;
        }

        indio_dev->name = id->name;
        indio_dev->channels = data->part_info->channels;
        indio_dev->num_channels = data->part_info->num_channels;
        indio_dev->info = data->part_info->iio_info;
        indio_dev->modes = INDIO_DIRECT_MODE;

        mutex_init(&data->lock);
        mutex_init(&data->cmdlock);

        ret = si1145_initialize(data);
        if (ret < 0)
                return ret;

        ret = devm_iio_triggered_buffer_setup(&client->dev,
                indio_dev, NULL,
                si1145_trigger_handler, &si1145_buffer_setup_ops);
        if (ret < 0)
                return ret;

        if (client->irq) {
                ret = si1145_probe_trigger(indio_dev);
                if (ret < 0)
                        return ret;
        } else {
                dev_info(&client->dev, "no irq, using polling\n");
        }

        return devm_iio_device_register(&client->dev, indio_dev);
}

static const struct i2c_device_id si1145_ids[] = {
        { "si1132", SI1132 },
        { "si1141", SI1141 },
        { "si1142", SI1142 },
        { "si1143", SI1143 },
        { "si1145", SI1145 },
        { "si1146", SI1146 },
        { "si1147", SI1147 },
        { }
};
MODULE_DEVICE_TABLE(i2c, si1145_ids);

static struct i2c_driver si1145_driver = {
        .driver = {
                .name   = "si1145",
        },
        .probe  = si1145_probe,
        .id_table = si1145_ids,
};

module_i2c_driver(si1145_driver);

MODULE_AUTHOR("Peter Meerwald-Stadler <pmeerw@pmeerw.net>");
MODULE_DESCRIPTION("Silabs SI1132 and SI1141/2/3/5/6/7 proximity, ambient light and UV index sensor driver");
MODULE_LICENSE("GPL");