/*
 * Copyright (C) 2013 Capella Microsystems Inc.
 * Author: Kevin Tsai <ktsai@capellamicro.com>
 *
 * This program is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License version 2, as published
 * by the Free Software Foundation.
 */

#include <linux/delay.h>
#include <linux/err.h>
#include <linux/i2c.h>
#include <linux/mutex.h>
#include <linux/module.h>
#include <linux/interrupt.h>
#include <linux/regulator/consumer.h>
#include <linux/iio/iio.h>
#include <linux/iio/sysfs.h>
#include <linux/iio/events.h>
#include <linux/init.h>

/* Registers Address */
#define CM32181_REG_ADDR_CMD            0x00
#define CM32181_REG_ADDR_ALS            0x04
#define CM32181_REG_ADDR_STATUS         0x06
#define CM32181_REG_ADDR_ID             0x07

/* Number of Configurable Registers */
#define CM32181_CONF_REG_NUM            0x01

/* CMD register */
#define CM32181_CMD_ALS_ENABLE          0x00
#define CM32181_CMD_ALS_DISABLE         0x01
#define CM32181_CMD_ALS_INT_EN          0x02

#define CM32181_CMD_ALS_IT_SHIFT        6
#define CM32181_CMD_ALS_IT_MASK         (0x0F << CM32181_CMD_ALS_IT_SHIFT)
#define CM32181_CMD_ALS_IT_DEFAULT      (0x00 << CM32181_CMD_ALS_IT_SHIFT)

#define CM32181_CMD_ALS_SM_SHIFT        11
#define CM32181_CMD_ALS_SM_MASK         (0x03 << CM32181_CMD_ALS_SM_SHIFT)
#define CM32181_CMD_ALS_SM_DEFAULT      (0x01 << CM32181_CMD_ALS_SM_SHIFT)

#define CM32181_MLUX_PER_BIT            5       /* ALS_SM=01 IT=800ms */
#define CM32181_MLUX_PER_BIT_BASE_IT    800000  /* Based on IT=800ms */
#define CM32181_CALIBSCALE_DEFAULT      1000
#define CM32181_CALIBSCALE_RESOLUTION   1000
#define MLUX_PER_LUX                    1000

static const u8 cm32181_reg[CM32181_CONF_REG_NUM] = {
        CM32181_REG_ADDR_CMD,
};

static const int als_it_bits[] = {12, 8, 0, 1, 2, 3};
static const int als_it_value[] = {25000, 50000, 100000, 200000, 400000,
        800000};

struct cm32181_chip {
        struct i2c_client *client;
        struct mutex lock;
        u16 conf_regs[CM32181_CONF_REG_NUM];
        int calibscale;
};

/**
 * cm32181_reg_init() - Initialize CM32181 registers
 * @cm32181:    pointer of struct cm32181.
 *
 * Initialize CM32181 ambient light sensor register to default values.
 *
 * Return: 0 for success; otherwise for error code.
 */
static int cm32181_reg_init(struct cm32181_chip *cm32181)
{
        struct i2c_client *client = cm32181->client;
        int i;
        s32 ret;

        ret = i2c_smbus_read_word_data(client, CM32181_REG_ADDR_ID);
        if (ret < 0)
                return ret;

        /* check device ID */
        if ((ret & 0xFF) != 0x81)
                return -ENODEV;

        /* Default Values */
        cm32181->conf_regs[CM32181_REG_ADDR_CMD] = CM32181_CMD_ALS_ENABLE |
                        CM32181_CMD_ALS_IT_DEFAULT | CM32181_CMD_ALS_SM_DEFAULT;
        cm32181->calibscale = CM32181_CALIBSCALE_DEFAULT;

        /* Initialize registers*/
        for (i = 0; i < CM32181_CONF_REG_NUM; i++) {
                ret = i2c_smbus_write_word_data(client, cm32181_reg[i],
                        cm32181->conf_regs[i]);
                if (ret < 0)
                        return ret;
        }

        return 0;
}

/**
 *  cm32181_read_als_it() - Get sensor integration time (ms)
 *  @cm32181:   pointer of struct cm32181
 *  @val2:      pointer of int to load the als_it value.
 *
 *  Report the current integartion time by millisecond.
 *
 *  Return: IIO_VAL_INT_PLUS_MICRO for success, otherwise -EINVAL.
 */
static int cm32181_read_als_it(struct cm32181_chip *cm32181, int *val2)
{
        u16 als_it;
        int i;

        als_it = cm32181->conf_regs[CM32181_REG_ADDR_CMD];
        als_it &= CM32181_CMD_ALS_IT_MASK;
        als_it >>= CM32181_CMD_ALS_IT_SHIFT;
        for (i = 0; i < ARRAY_SIZE(als_it_bits); i++) {
                if (als_it == als_it_bits[i]) {
                        *val2 = als_it_value[i];
                        return IIO_VAL_INT_PLUS_MICRO;
                }
        }

        return -EINVAL;
}

/**
 * cm32181_write_als_it() - Write sensor integration time
 * @cm32181:    pointer of struct cm32181.
 * @val:        integration time by millisecond.
 *
 * Convert integration time (ms) to sensor value.
 *
 * Return: i2c_smbus_write_word_data command return value.
 */
static int cm32181_write_als_it(struct cm32181_chip *cm32181, int val)
{
        struct i2c_client *client = cm32181->client;
        u16 als_it;
        int ret, i, n;

        n = ARRAY_SIZE(als_it_value);
        for (i = 0; i < n; i++)
                if (val <= als_it_value[i])
                        break;
        if (i >= n)
                i = n - 1;

        als_it = als_it_bits[i];
        als_it <<= CM32181_CMD_ALS_IT_SHIFT;

        mutex_lock(&cm32181->lock);
        cm32181->conf_regs[CM32181_REG_ADDR_CMD] &=
                ~CM32181_CMD_ALS_IT_MASK;
        cm32181->conf_regs[CM32181_REG_ADDR_CMD] |=
                als_it;
        ret = i2c_smbus_write_word_data(client, CM32181_REG_ADDR_CMD,
                        cm32181->conf_regs[CM32181_REG_ADDR_CMD]);
        mutex_unlock(&cm32181->lock);

        return ret;
}

/**
 * cm32181_get_lux() - report current lux value
 * @cm32181:    pointer of struct cm32181.
 *
 * Convert sensor raw data to lux.  It depends on integration
 * time and calibscale variable.
 *
 * Return: Positive value is lux, otherwise is error code.
 */
static int cm32181_get_lux(struct cm32181_chip *cm32181)
{
        struct i2c_client *client = cm32181->client;
        int ret;
        int als_it;
        unsigned long lux;

        ret = cm32181_read_als_it(cm32181, &als_it);
        if (ret < 0)
                return -EINVAL;

        lux = CM32181_MLUX_PER_BIT;
        lux *= CM32181_MLUX_PER_BIT_BASE_IT;
        lux /= als_it;

        ret = i2c_smbus_read_word_data(client, CM32181_REG_ADDR_ALS);
        if (ret < 0)
                return ret;

        lux *= ret;
        lux *= cm32181->calibscale;
        lux /= CM32181_CALIBSCALE_RESOLUTION;
        lux /= MLUX_PER_LUX;

        if (lux > 0xFFFF)
                lux = 0xFFFF;

        return lux;
}

static int cm32181_read_raw(struct iio_dev *indio_dev,
                            struct iio_chan_spec const *chan,
                            int *val, int *val2, long mask)
{
        struct cm32181_chip *cm32181 = iio_priv(indio_dev);
        int ret;

        switch (mask) {
        case IIO_CHAN_INFO_PROCESSED:
                ret = cm32181_get_lux(cm32181);
                if (ret < 0)
                        return ret;
                *val = ret;
                return IIO_VAL_INT;
        case IIO_CHAN_INFO_CALIBSCALE:
                *val = cm32181->calibscale;
                return IIO_VAL_INT;
        case IIO_CHAN_INFO_INT_TIME:
                *val = 0;
                ret = cm32181_read_als_it(cm32181, val2);
                return ret;
        }

        return -EINVAL;
}

static int cm32181_write_raw(struct iio_dev *indio_dev,
                             struct iio_chan_spec const *chan,
                             int val, int val2, long mask)
{
        struct cm32181_chip *cm32181 = iio_priv(indio_dev);
        int ret;

        switch (mask) {
        case IIO_CHAN_INFO_CALIBSCALE:
                cm32181->calibscale = val;
                return val;
        case IIO_CHAN_INFO_INT_TIME:
                ret = cm32181_write_als_it(cm32181, val2);
                return ret;
        }

        return -EINVAL;
}

/**
 * cm32181_get_it_available() - Get available ALS IT value
 * @dev:        pointer of struct device.
 * @attr:       pointer of struct device_attribute.
 * @buf:        pointer of return string buffer.
 *
 * Display the available integration time values by millisecond.
 *
 * Return: string length.
 */
static ssize_t cm32181_get_it_available(struct device *dev,
                        struct device_attribute *attr, char *buf)
{
        int i, n, len;

        n = ARRAY_SIZE(als_it_value);
        for (i = 0, len = 0; i < n; i++)
                len += sprintf(buf + len, "0.%06u ", als_it_value[i]);
        return len + sprintf(buf + len, "\n");
}

static const struct iio_chan_spec cm32181_channels[] = {
        {
                .type = IIO_LIGHT,
                .info_mask_separate =
                        BIT(IIO_CHAN_INFO_PROCESSED) |
                        BIT(IIO_CHAN_INFO_CALIBSCALE) |
                        BIT(IIO_CHAN_INFO_INT_TIME),
        }
};

static IIO_DEVICE_ATTR(in_illuminance_integration_time_available,
                        S_IRUGO, cm32181_get_it_available, NULL, 0);

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

static const struct attribute_group cm32181_attribute_group = {
        .attrs = cm32181_attributes
};

static const struct iio_info cm32181_info = {
        .driver_module          = THIS_MODULE,
        .read_raw               = &cm32181_read_raw,
        .write_raw              = &cm32181_write_raw,
        .attrs                  = &cm32181_attribute_group,
};

static int cm32181_probe(struct i2c_client *client,
                        const struct i2c_device_id *id)
{
        struct cm32181_chip *cm32181;
        struct iio_dev *indio_dev;
        int ret;

        indio_dev = devm_iio_device_alloc(&client->dev, sizeof(*cm32181));
        if (!indio_dev) {
                dev_err(&client->dev, "devm_iio_device_alloc failed\n");
                return -ENOMEM;
        }

        cm32181 = iio_priv(indio_dev);
        i2c_set_clientdata(client, indio_dev);
        cm32181->client = client;

        mutex_init(&cm32181->lock);
        indio_dev->dev.parent = &client->dev;
        indio_dev->channels = cm32181_channels;
        indio_dev->num_channels = ARRAY_SIZE(cm32181_channels);
        indio_dev->info = &cm32181_info;
        indio_dev->name = id->name;
        indio_dev->modes = INDIO_DIRECT_MODE;

        ret = cm32181_reg_init(cm32181);
        if (ret) {
                dev_err(&client->dev,
                        "%s: register init failed\n",
                        __func__);
                return ret;
        }

        ret = devm_iio_device_register(&client->dev, indio_dev);
        if (ret) {
                dev_err(&client->dev,
                        "%s: regist device failed\n",
                        __func__);
                return ret;
        }

        return 0;
}

static const struct i2c_device_id cm32181_id[] = {
        { "cm32181", 0 },
        { }
};

MODULE_DEVICE_TABLE(i2c, cm32181_id);

static const struct of_device_id cm32181_of_match[] = {
        { .compatible = "capella,cm32181" },
        { }
};
MODULE_DEVICE_TABLE(of, cm32181_of_match);

static struct i2c_driver cm32181_driver = {
        .driver = {
                .name   = "cm32181",
                .of_match_table = of_match_ptr(cm32181_of_match),
        },
        .id_table       = cm32181_id,
        .probe          = cm32181_probe,
};

module_i2c_driver(cm32181_driver);

MODULE_AUTHOR("Kevin Tsai <ktsai@capellamicro.com>");
MODULE_DESCRIPTION("CM32181 ambient light sensor driver");
MODULE_LICENSE("GPL");