blk-mq: always free hctx after request queue is freed

[linux/fpc-iii.git] / drivers / iio / proximity / isl29501.c

// SPDX-License-Identifier: GPL-2.0
/*
 * isl29501.c: ISL29501 Time of Flight sensor driver.
 *
 * Copyright (C) 2018
 * Author: Mathieu Othacehe <m.othacehe@gmail.com>
 *
 * 7-bit I2C slave address: 0x57
 */

#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/i2c.h>
#include <linux/err.h>
#include <linux/of_device.h>
#include <linux/iio/iio.h>
#include <linux/iio/sysfs.h>

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

/* Control, setting and status registers */
#define ISL29501_DEVICE_ID                      0x00
#define ISL29501_ID                             0x0A

/* Sampling control registers */
#define ISL29501_INTEGRATION_PERIOD             0x10
#define ISL29501_SAMPLE_PERIOD                  0x11

/* Closed loop calibration registers */
#define ISL29501_CROSSTALK_I_MSB                0x24
#define ISL29501_CROSSTALK_I_LSB                0x25
#define ISL29501_CROSSTALK_I_EXPONENT           0x26
#define ISL29501_CROSSTALK_Q_MSB                0x27
#define ISL29501_CROSSTALK_Q_LSB                0x28
#define ISL29501_CROSSTALK_Q_EXPONENT           0x29
#define ISL29501_CROSSTALK_GAIN_MSB             0x2A
#define ISL29501_CROSSTALK_GAIN_LSB             0x2B
#define ISL29501_MAGNITUDE_REF_EXP              0x2C
#define ISL29501_MAGNITUDE_REF_MSB              0x2D
#define ISL29501_MAGNITUDE_REF_LSB              0x2E
#define ISL29501_PHASE_OFFSET_MSB               0x2F
#define ISL29501_PHASE_OFFSET_LSB               0x30

/* Analog control registers */
#define ISL29501_DRIVER_RANGE                   0x90
#define ISL29501_EMITTER_DAC                    0x91

#define ISL29501_COMMAND_REGISTER               0xB0

/* Commands */
#define ISL29501_EMUL_SAMPLE_START_PIN          0x49
#define ISL29501_RESET_ALL_REGISTERS            0xD7
#define ISL29501_RESET_INT_SM                   0xD1

/* Ambiant light and temperature corrections */
#define ISL29501_TEMP_REFERENCE                 0x31
#define ISL29501_PHASE_EXPONENT                 0x33
#define ISL29501_TEMP_COEFF_A                   0x34
#define ISL29501_TEMP_COEFF_B                   0x39
#define ISL29501_AMBIANT_COEFF_A                0x36
#define ISL29501_AMBIANT_COEFF_B                0x3B

/* Data output registers */
#define ISL29501_DISTANCE_MSB_DATA              0xD1
#define ISL29501_DISTANCE_LSB_DATA              0xD2
#define ISL29501_PRECISION_MSB                  0xD3
#define ISL29501_PRECISION_LSB                  0xD4
#define ISL29501_MAGNITUDE_EXPONENT             0xD5
#define ISL29501_MAGNITUDE_MSB                  0xD6
#define ISL29501_MAGNITUDE_LSB                  0xD7
#define ISL29501_PHASE_MSB                      0xD8
#define ISL29501_PHASE_LSB                      0xD9
#define ISL29501_I_RAW_EXPONENT                 0xDA
#define ISL29501_I_RAW_MSB                      0xDB
#define ISL29501_I_RAW_LSB                      0xDC
#define ISL29501_Q_RAW_EXPONENT                 0xDD
#define ISL29501_Q_RAW_MSB                      0xDE
#define ISL29501_Q_RAW_LSB                      0xDF
#define ISL29501_DIE_TEMPERATURE                0xE2
#define ISL29501_AMBIENT_LIGHT                  0xE3
#define ISL29501_GAIN_MSB                       0xE6
#define ISL29501_GAIN_LSB                       0xE7

#define ISL29501_MAX_EXP_VAL 15

#define ISL29501_INT_TIME_AVAILABLE \
        "0.00007 0.00014 0.00028 0.00057 0.00114 " \
        "0.00228 0.00455 0.00910 0.01820 0.03640 " \
        "0.07281 0.14561"

#define ISL29501_CURRENT_SCALE_AVAILABLE \
        "0.0039 0.0078 0.0118 0.0157 0.0196 " \
        "0.0235 0.0275 0.0314 0.0352 0.0392 " \
        "0.0431 0.0471 0.0510 0.0549 0.0588"

enum isl29501_correction_coeff {
        COEFF_TEMP_A,
        COEFF_TEMP_B,
        COEFF_LIGHT_A,
        COEFF_LIGHT_B,
        COEFF_MAX,
};

struct isl29501_private {
        struct i2c_client *client;
        struct mutex lock;
        /* Exact representation of correction coefficients. */
        unsigned int shadow_coeffs[COEFF_MAX];
};

enum isl29501_register_name {
        REG_DISTANCE,
        REG_PHASE,
        REG_TEMPERATURE,
        REG_AMBIENT_LIGHT,
        REG_GAIN,
        REG_GAIN_BIAS,
        REG_PHASE_EXP,
        REG_CALIB_PHASE_TEMP_A,
        REG_CALIB_PHASE_TEMP_B,
        REG_CALIB_PHASE_LIGHT_A,
        REG_CALIB_PHASE_LIGHT_B,
        REG_DISTANCE_BIAS,
        REG_TEMPERATURE_BIAS,
        REG_INT_TIME,
        REG_SAMPLE_TIME,
        REG_DRIVER_RANGE,
        REG_EMITTER_DAC,
};

struct isl29501_register_desc {
        u8 msb;
        u8 lsb;
};

static const struct isl29501_register_desc isl29501_registers[] = {
        [REG_DISTANCE] = {
                .msb = ISL29501_DISTANCE_MSB_DATA,
                .lsb = ISL29501_DISTANCE_LSB_DATA,
        },
        [REG_PHASE] = {
                .msb = ISL29501_PHASE_MSB,
                .lsb = ISL29501_PHASE_LSB,
        },
        [REG_TEMPERATURE] = {
                .lsb = ISL29501_DIE_TEMPERATURE,
        },
        [REG_AMBIENT_LIGHT] = {
                .lsb = ISL29501_AMBIENT_LIGHT,
        },
        [REG_GAIN] = {
                .msb = ISL29501_GAIN_MSB,
                .lsb = ISL29501_GAIN_LSB,
        },
        [REG_GAIN_BIAS] = {
                .msb = ISL29501_CROSSTALK_GAIN_MSB,
                .lsb = ISL29501_CROSSTALK_GAIN_LSB,
        },
        [REG_PHASE_EXP] = {
                .lsb = ISL29501_PHASE_EXPONENT,
        },
        [REG_CALIB_PHASE_TEMP_A] = {
                .lsb = ISL29501_TEMP_COEFF_A,
        },
        [REG_CALIB_PHASE_TEMP_B] = {
                .lsb = ISL29501_TEMP_COEFF_B,
        },
        [REG_CALIB_PHASE_LIGHT_A] = {
                .lsb = ISL29501_AMBIANT_COEFF_A,
        },
        [REG_CALIB_PHASE_LIGHT_B] = {
                .lsb = ISL29501_AMBIANT_COEFF_B,
        },
        [REG_DISTANCE_BIAS] = {
                .msb = ISL29501_PHASE_OFFSET_MSB,
                .lsb = ISL29501_PHASE_OFFSET_LSB,
        },
        [REG_TEMPERATURE_BIAS] = {
                .lsb = ISL29501_TEMP_REFERENCE,
        },
        [REG_INT_TIME] = {
                .lsb = ISL29501_INTEGRATION_PERIOD,
        },
        [REG_SAMPLE_TIME] = {
                .lsb = ISL29501_SAMPLE_PERIOD,
        },
        [REG_DRIVER_RANGE] = {
                .lsb = ISL29501_DRIVER_RANGE,
        },
        [REG_EMITTER_DAC] = {
                .lsb = ISL29501_EMITTER_DAC,
        },
};

static int isl29501_register_read(struct isl29501_private *isl29501,
                                  enum isl29501_register_name name,
                                  u32 *val)
{
        const struct isl29501_register_desc *reg = &isl29501_registers[name];
        u8 msb = 0, lsb = 0;
        s32 ret;

        mutex_lock(&isl29501->lock);
        if (reg->msb) {
                ret = i2c_smbus_read_byte_data(isl29501->client, reg->msb);
                if (ret < 0)
                        goto err;
                msb = ret;
        }

        if (reg->lsb) {
                ret = i2c_smbus_read_byte_data(isl29501->client, reg->lsb);
                if (ret < 0)
                        goto err;
                lsb = ret;
        }
        mutex_unlock(&isl29501->lock);

        *val = (msb << 8) + lsb;

        return 0;
err:
        mutex_unlock(&isl29501->lock);

        return ret;
}

static u32 isl29501_register_write(struct isl29501_private *isl29501,
                                   enum isl29501_register_name name,
                                   u32 value)
{
        const struct isl29501_register_desc *reg = &isl29501_registers[name];
        int ret;

        if (!reg->msb && value > U8_MAX)
                return -ERANGE;

        if (value > U16_MAX)
                return -ERANGE;

        mutex_lock(&isl29501->lock);
        if (reg->msb) {
                ret = i2c_smbus_write_byte_data(isl29501->client,
                                                reg->msb, value >> 8);
                if (ret < 0)
                        goto err;
        }

        ret = i2c_smbus_write_byte_data(isl29501->client, reg->lsb, value);

err:
        mutex_unlock(&isl29501->lock);
        return ret;
}

static ssize_t isl29501_read_ext(struct iio_dev *indio_dev,
                                 uintptr_t private,
                                 const struct iio_chan_spec *chan,
                                 char *buf)
{
        struct isl29501_private *isl29501 = iio_priv(indio_dev);
        enum isl29501_register_name reg = private;
        int ret;
        u32 value, gain, coeff, exp;

        switch (reg) {
        case REG_GAIN:
        case REG_GAIN_BIAS:
                ret = isl29501_register_read(isl29501, reg, &gain);
                if (ret < 0)
                        return ret;

                value = gain;
                break;
        case REG_CALIB_PHASE_TEMP_A:
        case REG_CALIB_PHASE_TEMP_B:
        case REG_CALIB_PHASE_LIGHT_A:
        case REG_CALIB_PHASE_LIGHT_B:
                ret = isl29501_register_read(isl29501, REG_PHASE_EXP, &exp);
                if (ret < 0)
                        return ret;

                ret = isl29501_register_read(isl29501, reg, &coeff);
                if (ret < 0)
                        return ret;

                value = coeff << exp;
                break;
        default:
                return -EINVAL;
        }

        return sprintf(buf, "%u\n", value);
}

static int isl29501_set_shadow_coeff(struct isl29501_private *isl29501,
                                     enum isl29501_register_name reg,
                                     unsigned int val)
{
        enum isl29501_correction_coeff coeff;

        switch (reg) {
        case REG_CALIB_PHASE_TEMP_A:
                coeff = COEFF_TEMP_A;
                break;
        case REG_CALIB_PHASE_TEMP_B:
                coeff = COEFF_TEMP_B;
                break;
        case REG_CALIB_PHASE_LIGHT_A:
                coeff = COEFF_LIGHT_A;
                break;
        case REG_CALIB_PHASE_LIGHT_B:
                coeff = COEFF_LIGHT_B;
                break;
        default:
                return -EINVAL;
        }
        isl29501->shadow_coeffs[coeff] = val;

        return 0;
}

static int isl29501_write_coeff(struct isl29501_private *isl29501,
                                enum isl29501_correction_coeff coeff,
                                int val)
{
        enum isl29501_register_name reg;

        switch (coeff) {
        case COEFF_TEMP_A:
                reg = REG_CALIB_PHASE_TEMP_A;
                break;
        case COEFF_TEMP_B:
                reg = REG_CALIB_PHASE_TEMP_B;
                break;
        case COEFF_LIGHT_A:
                reg = REG_CALIB_PHASE_LIGHT_A;
                break;
        case COEFF_LIGHT_B:
                reg = REG_CALIB_PHASE_LIGHT_B;
                break;
        default:
                return -EINVAL;
        }

        return isl29501_register_write(isl29501, reg, val);
}

static unsigned int isl29501_find_corr_exp(unsigned int val,
                                           unsigned int max_exp,
                                           unsigned int max_mantissa)
{
        unsigned int exp = 1;

        /*
         * Correction coefficients are represented under
         * mantissa * 2^exponent form, where mantissa and exponent
         * are stored in two separate registers of the sensor.
         *
         * Compute and return the lowest exponent such as:
         *           mantissa = value / 2^exponent
         *
         *  where mantissa < max_mantissa.
         */
        if (val <= max_mantissa)
                return 0;

        while ((val >> exp) > max_mantissa) {
                exp++;

                if (exp > max_exp)
                        return max_exp;
        }

        return exp;
}

static ssize_t isl29501_write_ext(struct iio_dev *indio_dev,
                                  uintptr_t private,
                                  const struct iio_chan_spec *chan,
                                  const char *buf, size_t len)
{
        struct isl29501_private *isl29501 = iio_priv(indio_dev);
        enum isl29501_register_name reg = private;
        unsigned int val;
        int max_exp = 0;
        int ret;
        int i;

        ret = kstrtouint(buf, 10, &val);
        if (ret)
                return ret;

        switch (reg) {
        case REG_GAIN_BIAS:
                if (val > U16_MAX)
                        return -ERANGE;

                ret = isl29501_register_write(isl29501, reg, val);
                if (ret < 0)
                        return ret;

                break;
        case REG_CALIB_PHASE_TEMP_A:
        case REG_CALIB_PHASE_TEMP_B:
        case REG_CALIB_PHASE_LIGHT_A:
        case REG_CALIB_PHASE_LIGHT_B:

                if (val > (U8_MAX << ISL29501_MAX_EXP_VAL))
                        return -ERANGE;

                /* Store the correction coefficient under its exact form. */
                ret = isl29501_set_shadow_coeff(isl29501, reg, val);
                if (ret < 0)
                        return ret;

                /*
                 * Find the highest exponent needed to represent
                 * correction coefficients.
                 */
                for (i = 0; i < COEFF_MAX; i++) {
                        int corr;
                        int corr_exp;

                        corr = isl29501->shadow_coeffs[i];
                        corr_exp = isl29501_find_corr_exp(corr,
                                                          ISL29501_MAX_EXP_VAL,
                                                          U8_MAX / 2);
                        dev_dbg(&isl29501->client->dev,
                                "found exp of corr(%d) = %d\n", corr, corr_exp);

                        max_exp = max(max_exp, corr_exp);
                }

                /*
                 * Represent every correction coefficient under
                 * mantissa * 2^max_exponent form and force the
                 * writing of those coefficients on the sensor.
                 */
                for (i = 0; i < COEFF_MAX; i++) {
                        int corr;
                        int mantissa;

                        corr = isl29501->shadow_coeffs[i];
                        if (!corr)
                                continue;

                        mantissa = corr >> max_exp;

                        ret = isl29501_write_coeff(isl29501, i, mantissa);
                        if (ret < 0)
                                return ret;
                }

                ret = isl29501_register_write(isl29501, REG_PHASE_EXP, max_exp);
                if (ret < 0)
                        return ret;

                break;
        default:
                return -EINVAL;
        }

        return len;
}

#define _ISL29501_EXT_INFO(_name, _ident) { \
        .name = _name, \
        .read = isl29501_read_ext, \
        .write = isl29501_write_ext, \
        .private = _ident, \
        .shared = IIO_SEPARATE, \
}

static const struct iio_chan_spec_ext_info isl29501_ext_info[] = {
        _ISL29501_EXT_INFO("agc_gain", REG_GAIN),
        _ISL29501_EXT_INFO("agc_gain_bias", REG_GAIN_BIAS),
        _ISL29501_EXT_INFO("calib_phase_temp_a", REG_CALIB_PHASE_TEMP_A),
        _ISL29501_EXT_INFO("calib_phase_temp_b", REG_CALIB_PHASE_TEMP_B),
        _ISL29501_EXT_INFO("calib_phase_light_a", REG_CALIB_PHASE_LIGHT_A),
        _ISL29501_EXT_INFO("calib_phase_light_b", REG_CALIB_PHASE_LIGHT_B),
        { },
};

#define ISL29501_DISTANCE_SCAN_INDEX 0
#define ISL29501_TIMESTAMP_SCAN_INDEX 1

static const struct iio_chan_spec isl29501_channels[] = {
        {
                .type = IIO_PROXIMITY,
                .scan_index = ISL29501_DISTANCE_SCAN_INDEX,
                .info_mask_separate =
                        BIT(IIO_CHAN_INFO_RAW)   |
                        BIT(IIO_CHAN_INFO_SCALE) |
                        BIT(IIO_CHAN_INFO_CALIBBIAS),
                .scan_type = {
                        .sign = 'u',
                        .realbits = 16,
                        .storagebits = 16,
                        .endianness = IIO_CPU,
                },
                .info_mask_shared_by_all = BIT(IIO_CHAN_INFO_INT_TIME) |
                                BIT(IIO_CHAN_INFO_SAMP_FREQ),
                .ext_info = isl29501_ext_info,
        },
        {
                .type = IIO_PHASE,
                .scan_index = -1,
                .info_mask_separate = BIT(IIO_CHAN_INFO_RAW) |
                                BIT(IIO_CHAN_INFO_SCALE),
        },
        {
                .type = IIO_CURRENT,
                .scan_index = -1,
                .output = 1,
                .info_mask_separate = BIT(IIO_CHAN_INFO_RAW) |
                                BIT(IIO_CHAN_INFO_SCALE),
        },
        {
                .type = IIO_TEMP,
                .scan_index = -1,
                .info_mask_separate = BIT(IIO_CHAN_INFO_RAW) |
                                BIT(IIO_CHAN_INFO_SCALE)     |
                                BIT(IIO_CHAN_INFO_CALIBBIAS),
        },
        {
                .type = IIO_INTENSITY,
                .scan_index = -1,
                .modified = 1,
                .channel2 = IIO_MOD_LIGHT_CLEAR,
                .info_mask_separate = BIT(IIO_CHAN_INFO_RAW) |
                                BIT(IIO_CHAN_INFO_SCALE),
        },
        IIO_CHAN_SOFT_TIMESTAMP(ISL29501_TIMESTAMP_SCAN_INDEX),
};

static int isl29501_reset_registers(struct isl29501_private *isl29501)
{
        int ret;

        ret = i2c_smbus_write_byte_data(isl29501->client,
                                        ISL29501_COMMAND_REGISTER,
                                        ISL29501_RESET_ALL_REGISTERS);
        if (ret < 0) {
                dev_err(&isl29501->client->dev,
                        "cannot reset registers %d\n", ret);
                return ret;
        }

        ret = i2c_smbus_write_byte_data(isl29501->client,
                                        ISL29501_COMMAND_REGISTER,
                                        ISL29501_RESET_INT_SM);
        if (ret < 0)
                dev_err(&isl29501->client->dev,
                        "cannot reset state machine %d\n", ret);

        return ret;
}

static int isl29501_begin_acquisition(struct isl29501_private *isl29501)
{
        int ret;

        ret = i2c_smbus_write_byte_data(isl29501->client,
                                        ISL29501_COMMAND_REGISTER,
                                        ISL29501_EMUL_SAMPLE_START_PIN);
        if (ret < 0)
                dev_err(&isl29501->client->dev,
                        "cannot begin acquisition %d\n", ret);

        return ret;
}

static IIO_CONST_ATTR_INT_TIME_AVAIL(ISL29501_INT_TIME_AVAILABLE);
static IIO_CONST_ATTR(out_current_scale_available,
                      ISL29501_CURRENT_SCALE_AVAILABLE);

static struct attribute *isl29501_attributes[] = {
        &iio_const_attr_integration_time_available.dev_attr.attr,
        &iio_const_attr_out_current_scale_available.dev_attr.attr,
        NULL
};

static const struct attribute_group isl29501_attribute_group = {
        .attrs = isl29501_attributes,
};

static const int isl29501_current_scale_table[][2] = {
        {0, 3900}, {0, 7800}, {0, 11800}, {0, 15700},
        {0, 19600}, {0, 23500}, {0, 27500}, {0, 31400},
        {0, 35200}, {0, 39200}, {0, 43100}, {0, 47100},
        {0, 51000}, {0, 54900}, {0, 58800},
};

static const int isl29501_int_time[][2] = {
        {0, 70},    /* 0.07 ms */
        {0, 140},   /* 0.14 ms */
        {0, 280},   /* 0.28 ms */
        {0, 570},   /* 0.57 ms */
        {0, 1140},  /* 1.14 ms */
        {0, 2280},  /* 2.28 ms */
        {0, 4550},  /* 4.55 ms */
        {0, 9100},  /* 9.11 ms */
        {0, 18200}, /* 18.2 ms */
        {0, 36400}, /* 36.4 ms */
        {0, 72810}, /* 72.81 ms */
        {0, 145610} /* 145.28 ms */
};

static int isl29501_get_raw(struct isl29501_private *isl29501,
                            const struct iio_chan_spec *chan,
                            int *raw)
{
        int ret;

        switch (chan->type) {
        case IIO_PROXIMITY:
                ret = isl29501_register_read(isl29501, REG_DISTANCE, raw);
                if (ret < 0)
                        return ret;

                return IIO_VAL_INT;
        case IIO_INTENSITY:
                ret = isl29501_register_read(isl29501,
                                             REG_AMBIENT_LIGHT,
                                             raw);
                if (ret < 0)
                        return ret;

                return IIO_VAL_INT;
        case IIO_PHASE:
                ret = isl29501_register_read(isl29501, REG_PHASE, raw);
                if (ret < 0)
                        return ret;

                return IIO_VAL_INT;
        case IIO_CURRENT:
                ret = isl29501_register_read(isl29501, REG_EMITTER_DAC, raw);
                if (ret < 0)
                        return ret;

                return IIO_VAL_INT;
        case IIO_TEMP:
                ret = isl29501_register_read(isl29501, REG_TEMPERATURE, raw);
                if (ret < 0)
                        return ret;

                return IIO_VAL_INT;
        default:
                return -EINVAL;
        }
}

static int isl29501_get_scale(struct isl29501_private *isl29501,
                              const struct iio_chan_spec *chan,
                              int *val, int *val2)
{
        int ret;
        u32 current_scale;

        switch (chan->type) {
        case IIO_PROXIMITY:
                /* distance = raw_distance * 33.31 / 65536 (m) */
                *val = 3331;
                *val2 = 6553600;

                return IIO_VAL_FRACTIONAL;
        case IIO_PHASE:
                /* phase = raw_phase * 2pi / 65536 (rad) */
                *val = 0;
                *val2 = 95874;

                return IIO_VAL_INT_PLUS_NANO;
        case IIO_INTENSITY:
                /* light = raw_light * 35 / 10000 (mA) */
                *val = 35;
                *val2 = 10000;

                return IIO_VAL_FRACTIONAL;
        case IIO_CURRENT:
                ret = isl29501_register_read(isl29501,
                                             REG_DRIVER_RANGE,
                                             &current_scale);
                if (ret < 0)
                        return ret;

                if (current_scale > ARRAY_SIZE(isl29501_current_scale_table))
                        return -EINVAL;

                if (!current_scale) {
                        *val = 0;
                        *val2 = 0;
                        return IIO_VAL_INT;
                }

                *val = isl29501_current_scale_table[current_scale - 1][0];
                *val2 = isl29501_current_scale_table[current_scale - 1][1];

                return IIO_VAL_INT_PLUS_MICRO;
        case IIO_TEMP:
                /* temperature = raw_temperature * 125 / 100000 (milli °C) */
                *val = 125;
                *val2 = 100000;

                return IIO_VAL_FRACTIONAL;
        default:
                return -EINVAL;
        }
}

static int isl29501_get_calibbias(struct isl29501_private *isl29501,
                                  const struct iio_chan_spec *chan,
                                  int *bias)
{
        switch (chan->type) {
        case IIO_PROXIMITY:
                return isl29501_register_read(isl29501,
                                              REG_DISTANCE_BIAS,
                                              bias);
        case IIO_TEMP:
                return isl29501_register_read(isl29501,
                                              REG_TEMPERATURE_BIAS,
                                              bias);
        default:
                return -EINVAL;
        }
}

static int isl29501_get_inttime(struct isl29501_private *isl29501,
                                int *val, int *val2)
{
        int ret;
        u32 inttime;

        ret = isl29501_register_read(isl29501, REG_INT_TIME, &inttime);
        if (ret < 0)
                return ret;

        if (inttime >= ARRAY_SIZE(isl29501_int_time))
                return -EINVAL;

        *val = isl29501_int_time[inttime][0];
        *val2 = isl29501_int_time[inttime][1];

        return IIO_VAL_INT_PLUS_MICRO;
}

static int isl29501_get_freq(struct isl29501_private *isl29501,
                             int *val, int *val2)
{
        int ret;
        int sample_time;
        unsigned long long freq;
        u32 temp;

        ret = isl29501_register_read(isl29501, REG_SAMPLE_TIME, &sample_time);
        if (ret < 0)
                return ret;

        /* freq = 1 / (0.000450 * (sample_time + 1) * 10^-6) */
        freq = 1000000ULL * 1000000ULL;

        do_div(freq, 450 * (sample_time + 1));

        temp = do_div(freq, 1000000);
        *val = freq;
        *val2 = temp;

        return IIO_VAL_INT_PLUS_MICRO;
}

static int isl29501_read_raw(struct iio_dev *indio_dev,
                             struct iio_chan_spec const *chan, int *val,
                             int *val2, long mask)
{
        struct isl29501_private *isl29501 = iio_priv(indio_dev);

        switch (mask) {
        case IIO_CHAN_INFO_RAW:
                return isl29501_get_raw(isl29501, chan, val);
        case IIO_CHAN_INFO_SCALE:
                return isl29501_get_scale(isl29501, chan, val, val2);
        case IIO_CHAN_INFO_INT_TIME:
                return isl29501_get_inttime(isl29501, val, val2);
        case IIO_CHAN_INFO_SAMP_FREQ:
                return isl29501_get_freq(isl29501, val, val2);
        case IIO_CHAN_INFO_CALIBBIAS:
                return isl29501_get_calibbias(isl29501, chan, val);
        default:
                return -EINVAL;
        }
}

static int isl29501_set_raw(struct isl29501_private *isl29501,
                            const struct iio_chan_spec *chan,
                            int raw)
{
        switch (chan->type) {
        case IIO_CURRENT:
                return isl29501_register_write(isl29501, REG_EMITTER_DAC, raw);
        default:
                return -EINVAL;
        }
}

static int isl29501_set_inttime(struct isl29501_private *isl29501,
                                int val, int val2)
{
        int i;

        for (i = 0; i < ARRAY_SIZE(isl29501_int_time); i++) {
                if (isl29501_int_time[i][0] == val &&
                    isl29501_int_time[i][1] == val2) {
                        return isl29501_register_write(isl29501,
                                                       REG_INT_TIME,
                                                       i);
                }
        }

        return -EINVAL;
}

static int isl29501_set_scale(struct isl29501_private *isl29501,
                              const struct iio_chan_spec *chan,
                              int val, int val2)
{
        int i;

        if (chan->type != IIO_CURRENT)
                return -EINVAL;

        for (i = 0; i < ARRAY_SIZE(isl29501_current_scale_table); i++) {
                if (isl29501_current_scale_table[i][0] == val &&
                    isl29501_current_scale_table[i][1] == val2) {
                        return isl29501_register_write(isl29501,
                                                       REG_DRIVER_RANGE,
                                                       i + 1);
                }
        }

        return -EINVAL;
}

static int isl29501_set_calibbias(struct isl29501_private *isl29501,
                                  const struct iio_chan_spec *chan,
                                  int bias)
{
        switch (chan->type) {
        case IIO_PROXIMITY:
                return isl29501_register_write(isl29501,
                                              REG_DISTANCE_BIAS,
                                              bias);
        case IIO_TEMP:
                return isl29501_register_write(isl29501,
                                               REG_TEMPERATURE_BIAS,
                                               bias);
        default:
                return -EINVAL;
        }
}

static int isl29501_set_freq(struct isl29501_private *isl29501,
                             int val, int val2)
{
        int freq;
        unsigned long long sample_time;

        /* sample_freq = 1 / (0.000450 * (sample_time + 1) * 10^-6) */
        freq = val * 1000000 + val2 % 1000000;
        sample_time = 2222ULL * 1000000ULL;
        do_div(sample_time, freq);

        sample_time -= 1;

        if (sample_time > 255)
                return -ERANGE;

        return isl29501_register_write(isl29501, REG_SAMPLE_TIME, sample_time);
}

static int isl29501_write_raw(struct iio_dev *indio_dev,
                              struct iio_chan_spec const *chan,
                              int val, int val2, long mask)
{
        struct isl29501_private *isl29501 = iio_priv(indio_dev);

        switch (mask) {
        case IIO_CHAN_INFO_RAW:
                return isl29501_set_raw(isl29501, chan, val);
        case IIO_CHAN_INFO_INT_TIME:
                return isl29501_set_inttime(isl29501, val, val2);
        case IIO_CHAN_INFO_SAMP_FREQ:
                return isl29501_set_freq(isl29501, val, val2);
        case IIO_CHAN_INFO_SCALE:
                return isl29501_set_scale(isl29501, chan, val, val2);
        case IIO_CHAN_INFO_CALIBBIAS:
                return isl29501_set_calibbias(isl29501, chan, val);
        default:
                return -EINVAL;
        }
}

static const struct iio_info isl29501_info = {
        .read_raw = &isl29501_read_raw,
        .write_raw = &isl29501_write_raw,
        .attrs = &isl29501_attribute_group,
};

static int isl29501_init_chip(struct isl29501_private *isl29501)
{
        int ret;

        ret = i2c_smbus_read_byte_data(isl29501->client, ISL29501_DEVICE_ID);
        if (ret < 0) {
                dev_err(&isl29501->client->dev, "Error reading device id\n");
                return ret;
        }

        if (ret != ISL29501_ID) {
                dev_err(&isl29501->client->dev,
                        "Wrong chip id, got %x expected %x\n",
                        ret, ISL29501_DEVICE_ID);
                return -ENODEV;
        }

        ret = isl29501_reset_registers(isl29501);
        if (ret < 0)
                return ret;

        return isl29501_begin_acquisition(isl29501);
}

static irqreturn_t isl29501_trigger_handler(int irq, void *p)
{
        struct iio_poll_func *pf = p;
        struct iio_dev *indio_dev = pf->indio_dev;
        struct isl29501_private *isl29501 = iio_priv(indio_dev);
        const unsigned long *active_mask = indio_dev->active_scan_mask;
        u32 buffer[4] = {}; /* 1x16-bit + ts */

        if (test_bit(ISL29501_DISTANCE_SCAN_INDEX, active_mask))
                isl29501_register_read(isl29501, REG_DISTANCE, buffer);

        iio_push_to_buffers_with_timestamp(indio_dev, buffer, pf->timestamp);
        iio_trigger_notify_done(indio_dev->trig);

        return IRQ_HANDLED;
}

static int isl29501_probe(struct i2c_client *client,
                          const struct i2c_device_id *id)
{
        struct iio_dev *indio_dev;
        struct isl29501_private *isl29501;
        int ret;

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

        isl29501 = iio_priv(indio_dev);

        i2c_set_clientdata(client, indio_dev);
        isl29501->client = client;

        mutex_init(&isl29501->lock);

        ret = isl29501_init_chip(isl29501);
        if (ret < 0)
                return ret;

        indio_dev->modes = INDIO_DIRECT_MODE;
        indio_dev->dev.parent = &client->dev;
        indio_dev->channels = isl29501_channels;
        indio_dev->num_channels = ARRAY_SIZE(isl29501_channels);
        indio_dev->name = client->name;
        indio_dev->info = &isl29501_info;

        ret = devm_iio_triggered_buffer_setup(&client->dev, indio_dev,
                                              iio_pollfunc_store_time,
                                              isl29501_trigger_handler,
                                              NULL);
        if (ret < 0) {
                dev_err(&client->dev, "unable to setup iio triggered buffer\n");
                return ret;
        }

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

static const struct i2c_device_id isl29501_id[] = {
        {"isl29501", 0},
        {}
};

MODULE_DEVICE_TABLE(i2c, isl29501_id);

#if defined(CONFIG_OF)
static const struct of_device_id isl29501_i2c_matches[] = {
        { .compatible = "renesas,isl29501" },
        { }
};
MODULE_DEVICE_TABLE(of, isl29501_i2c_matches);
#endif

static struct i2c_driver isl29501_driver = {
        .driver = {
                .name   = "isl29501",
        },
        .id_table       = isl29501_id,
        .probe          = isl29501_probe,
};
module_i2c_driver(isl29501_driver);

MODULE_AUTHOR("Mathieu Othacehe <m.othacehe@gmail.com>");
MODULE_DESCRIPTION("ISL29501 Time of Flight sensor driver");
MODULE_LICENSE("GPL v2");