// SPDX-License-Identifier: GPL-2.0-only
/*
 * Freescale MMA9551L Intelligent Motion-Sensing Platform driver
 * Copyright (c) 2014, Intel Corporation.
 */

#include <linux/i2c.h>
#include <linux/interrupt.h>
#include <linux/module.h>
#include <linux/slab.h>
#include <linux/delay.h>
#include <linux/gpio/consumer.h>
#include <linux/iio/iio.h>
#include <linux/iio/sysfs.h>
#include <linux/iio/events.h>
#include <linux/pm_runtime.h>
#include "mma9551_core.h"

#define MMA9551_GPIO_COUNT              4

/* Tilt application (inclination in IIO terms). */
#define MMA9551_TILT_XZ_ANG_REG         0x00
#define MMA9551_TILT_YZ_ANG_REG         0x01
#define MMA9551_TILT_XY_ANG_REG         0x02
#define MMA9551_TILT_ANGFLG             BIT(7)
#define MMA9551_TILT_QUAD_REG           0x03
#define MMA9551_TILT_XY_QUAD_SHIFT      0
#define MMA9551_TILT_YZ_QUAD_SHIFT      2
#define MMA9551_TILT_XZ_QUAD_SHIFT      4
#define MMA9551_TILT_CFG_REG            0x01
#define MMA9551_TILT_ANG_THRESH_MASK    GENMASK(3, 0)

#define MMA9551_DEFAULT_SAMPLE_RATE     122     /* Hz */

/* Tilt events are mapped to the first three GPIO pins. */
enum mma9551_tilt_axis {
        mma9551_x = 0,
        mma9551_y,
        mma9551_z,
};

struct mma9551_data {
        struct i2c_client *client;
        struct mutex mutex;
        bool event_enabled[3];
        int irqs[MMA9551_GPIO_COUNT];
};

static int mma9551_read_incli_chan(struct i2c_client *client,
                                   const struct iio_chan_spec *chan,
                                   int *val)
{
        u8 quad_shift, angle, quadrant;
        u16 reg_addr;
        int ret;

        switch (chan->channel2) {
        case IIO_MOD_X:
                reg_addr = MMA9551_TILT_YZ_ANG_REG;
                quad_shift = MMA9551_TILT_YZ_QUAD_SHIFT;
                break;
        case IIO_MOD_Y:
                reg_addr = MMA9551_TILT_XZ_ANG_REG;
                quad_shift = MMA9551_TILT_XZ_QUAD_SHIFT;
                break;
        case IIO_MOD_Z:
                reg_addr = MMA9551_TILT_XY_ANG_REG;
                quad_shift = MMA9551_TILT_XY_QUAD_SHIFT;
                break;
        default:
                return -EINVAL;
        }

        ret = mma9551_set_power_state(client, true);
        if (ret < 0)
                return ret;

        ret = mma9551_read_status_byte(client, MMA9551_APPID_TILT,
                                       reg_addr, &angle);
        if (ret < 0)
                goto out_poweroff;

        ret = mma9551_read_status_byte(client, MMA9551_APPID_TILT,
                                       MMA9551_TILT_QUAD_REG, &quadrant);
        if (ret < 0)
                goto out_poweroff;

        angle &= ~MMA9551_TILT_ANGFLG;
        quadrant = (quadrant >> quad_shift) & 0x03;

        if (quadrant == 1 || quadrant == 3)
                *val = 90 * (quadrant + 1) - angle;
        else
                *val = angle + 90 * quadrant;

        ret = IIO_VAL_INT;

out_poweroff:
        mma9551_set_power_state(client, false);
        return ret;
}

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

        switch (mask) {
        case IIO_CHAN_INFO_PROCESSED:
                switch (chan->type) {
                case IIO_INCLI:
                        mutex_lock(&data->mutex);
                        ret = mma9551_read_incli_chan(data->client, chan, val);
                        mutex_unlock(&data->mutex);
                        return ret;
                default:
                        return -EINVAL;
                }
        case IIO_CHAN_INFO_RAW:
                switch (chan->type) {
                case IIO_ACCEL:
                        mutex_lock(&data->mutex);
                        ret = mma9551_read_accel_chan(data->client,
                                                      chan, val, val2);
                        mutex_unlock(&data->mutex);
                        return ret;
                default:
                        return -EINVAL;
                }
        case IIO_CHAN_INFO_SCALE:
                switch (chan->type) {
                case IIO_ACCEL:
                        return mma9551_read_accel_scale(val, val2);
                default:
                        return -EINVAL;
                }
        default:
                return -EINVAL;
        }
}

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

        switch (chan->type) {
        case IIO_INCLI:
                /* IIO counts axes from 1, because IIO_NO_MOD is 0. */
                return data->event_enabled[chan->channel2 - 1];
        default:
                return -EINVAL;
        }
}

static int mma9551_config_incli_event(struct iio_dev *indio_dev,
                                      enum iio_modifier axis,
                                      bool state)
{
        struct mma9551_data *data = iio_priv(indio_dev);
        enum mma9551_tilt_axis mma_axis;
        int ret;

        /* IIO counts axes from 1, because IIO_NO_MOD is 0. */
        mma_axis = axis - 1;

        if (data->event_enabled[mma_axis] == state)
                return 0;

        if (!state) {
                ret = mma9551_gpio_config(data->client,
                                          (enum mma9551_gpio_pin)mma_axis,
                                          MMA9551_APPID_NONE, 0, 0);
                if (ret < 0)
                        return ret;

                ret = mma9551_set_power_state(data->client, false);
                if (ret < 0)
                        return ret;
        } else {
                int bitnum;

                /* Bit 7 of each angle register holds the angle flag. */
                switch (axis) {
                case IIO_MOD_X:
                        bitnum = 7 + 8 * MMA9551_TILT_YZ_ANG_REG;
                        break;
                case IIO_MOD_Y:
                        bitnum = 7 + 8 * MMA9551_TILT_XZ_ANG_REG;
                        break;
                case IIO_MOD_Z:
                        bitnum = 7 + 8 * MMA9551_TILT_XY_ANG_REG;
                        break;
                default:
                        return -EINVAL;
                }


                ret = mma9551_set_power_state(data->client, true);
                if (ret < 0)
                        return ret;

                ret = mma9551_gpio_config(data->client,
                                          (enum mma9551_gpio_pin)mma_axis,
                                          MMA9551_APPID_TILT, bitnum, 0);
                if (ret < 0) {
                        mma9551_set_power_state(data->client, false);
                        return ret;
                }
        }

        data->event_enabled[mma_axis] = state;

        return ret;
}

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

        switch (chan->type) {
        case IIO_INCLI:
                mutex_lock(&data->mutex);
                ret = mma9551_config_incli_event(indio_dev,
                                                 chan->channel2, state);
                mutex_unlock(&data->mutex);
                return ret;
        default:
                return -EINVAL;
        }
}

static int mma9551_write_event_value(struct iio_dev *indio_dev,
                                     const struct iio_chan_spec *chan,
                                     enum iio_event_type type,
                                     enum iio_event_direction dir,
                                     enum iio_event_info info,
                                     int val, int val2)
{
        struct mma9551_data *data = iio_priv(indio_dev);
        int ret;

        switch (chan->type) {
        case IIO_INCLI:
                if (val2 != 0 || val < 1 || val > 10)
                        return -EINVAL;
                mutex_lock(&data->mutex);
                ret = mma9551_update_config_bits(data->client,
                                                 MMA9551_APPID_TILT,
                                                 MMA9551_TILT_CFG_REG,
                                                 MMA9551_TILT_ANG_THRESH_MASK,
                                                 val);
                mutex_unlock(&data->mutex);
                return ret;
        default:
                return -EINVAL;
        }
}

static int mma9551_read_event_value(struct iio_dev *indio_dev,
                                    const struct iio_chan_spec *chan,
                                    enum iio_event_type type,
                                    enum iio_event_direction dir,
                                    enum iio_event_info info,
                                    int *val, int *val2)
{
        struct mma9551_data *data = iio_priv(indio_dev);
        int ret;
        u8 tmp;

        switch (chan->type) {
        case IIO_INCLI:
                mutex_lock(&data->mutex);
                ret = mma9551_read_config_byte(data->client,
                                               MMA9551_APPID_TILT,
                                               MMA9551_TILT_CFG_REG, &tmp);
                mutex_unlock(&data->mutex);
                if (ret < 0)
                        return ret;
                *val = tmp & MMA9551_TILT_ANG_THRESH_MASK;
                *val2 = 0;
                return IIO_VAL_INT;
        default:
                return -EINVAL;
        }
}

static const struct iio_event_spec mma9551_incli_event = {
        .type = IIO_EV_TYPE_ROC,
        .dir = IIO_EV_DIR_RISING,
        .mask_separate = BIT(IIO_EV_INFO_ENABLE),
        .mask_shared_by_type = BIT(IIO_EV_INFO_VALUE),
};

#define MMA9551_INCLI_CHANNEL(axis) {                           \
        .type = IIO_INCLI,                                      \
        .modified = 1,                                          \
        .channel2 = axis,                                       \
        .info_mask_separate = BIT(IIO_CHAN_INFO_PROCESSED),     \
        .event_spec = &mma9551_incli_event,                     \
        .num_event_specs = 1,                                   \
}

static const struct iio_chan_spec mma9551_channels[] = {
        MMA9551_ACCEL_CHANNEL(IIO_MOD_X),
        MMA9551_ACCEL_CHANNEL(IIO_MOD_Y),
        MMA9551_ACCEL_CHANNEL(IIO_MOD_Z),

        MMA9551_INCLI_CHANNEL(IIO_MOD_X),
        MMA9551_INCLI_CHANNEL(IIO_MOD_Y),
        MMA9551_INCLI_CHANNEL(IIO_MOD_Z),
};

static const struct iio_info mma9551_info = {
        .read_raw = mma9551_read_raw,
        .read_event_config = mma9551_read_event_config,
        .write_event_config = mma9551_write_event_config,
        .read_event_value = mma9551_read_event_value,
        .write_event_value = mma9551_write_event_value,
};

static irqreturn_t mma9551_event_handler(int irq, void *private)
{
        struct iio_dev *indio_dev = private;
        struct mma9551_data *data = iio_priv(indio_dev);
        int i, ret, mma_axis = -1;
        u16 reg;
        u8 val;

        mutex_lock(&data->mutex);

        for (i = 0; i < 3; i++)
                if (irq == data->irqs[i]) {
                        mma_axis = i;
                        break;
                }

        if (mma_axis == -1) {
                /* IRQ was triggered on 4th line, which we don't use. */
                dev_warn(&data->client->dev,
                         "irq triggered on unused line %d\n", data->irqs[3]);
                goto out;
        }

        switch (mma_axis) {
        case mma9551_x:
                reg = MMA9551_TILT_YZ_ANG_REG;
                break;
        case mma9551_y:
                reg = MMA9551_TILT_XZ_ANG_REG;
                break;
        case mma9551_z:
                reg = MMA9551_TILT_XY_ANG_REG;
                break;
        }

        /*
         * Read the angle even though we don't use it, otherwise we
         * won't get any further interrupts.
         */
        ret = mma9551_read_status_byte(data->client, MMA9551_APPID_TILT,
                                       reg, &val);
        if (ret < 0) {
                dev_err(&data->client->dev,
                        "error %d reading tilt register in IRQ\n", ret);
                goto out;
        }

        iio_push_event(indio_dev,
                       IIO_MOD_EVENT_CODE(IIO_INCLI, 0, (mma_axis + 1),
                                          IIO_EV_TYPE_ROC, IIO_EV_DIR_RISING),
                       iio_get_time_ns(indio_dev));

out:
        mutex_unlock(&data->mutex);

        return IRQ_HANDLED;
}

static int mma9551_init(struct mma9551_data *data)
{
        int ret;

        ret = mma9551_read_version(data->client);
        if (ret)
                return ret;

        return mma9551_set_device_state(data->client, true);
}

static int mma9551_gpio_probe(struct iio_dev *indio_dev)
{
        struct gpio_desc *gpio;
        int i, ret;
        struct mma9551_data *data = iio_priv(indio_dev);
        struct device *dev = &data->client->dev;

        for (i = 0; i < MMA9551_GPIO_COUNT; i++) {
                gpio = devm_gpiod_get_index(dev, NULL, i, GPIOD_IN);
                if (IS_ERR(gpio)) {
                        dev_err(dev, "acpi gpio get index failed\n");
                        return PTR_ERR(gpio);
                }

                ret = gpiod_to_irq(gpio);
                if (ret < 0)
                        return ret;

                data->irqs[i] = ret;
                ret = devm_request_threaded_irq(dev, data->irqs[i],
                                NULL, mma9551_event_handler,
                                IRQF_TRIGGER_RISING | IRQF_ONESHOT,
                                "mma9551_event", indio_dev);
                if (ret < 0) {
                        dev_err(dev, "request irq %d failed\n", data->irqs[i]);
                        return ret;
                }

                dev_dbg(dev, "gpio resource, no:%d irq:%d\n",
                        desc_to_gpio(gpio), data->irqs[i]);
        }

        return 0;
}

static int mma9551_probe(struct i2c_client *client)
{
        const struct i2c_device_id *id = i2c_client_get_device_id(client);
        struct mma9551_data *data;
        struct iio_dev *indio_dev;
        const char *name = NULL;
        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;

        if (id)
                name = id->name;
        else
                name = iio_get_acpi_device_name(&client->dev);

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

        mutex_init(&data->mutex);

        indio_dev->channels = mma9551_channels;
        indio_dev->num_channels = ARRAY_SIZE(mma9551_channels);
        indio_dev->name = name;
        indio_dev->modes = INDIO_DIRECT_MODE;
        indio_dev->info = &mma9551_info;

        ret = mma9551_gpio_probe(indio_dev);
        if (ret < 0)
                goto out_poweroff;

        ret = pm_runtime_set_active(&client->dev);
        if (ret < 0)
                goto out_poweroff;

        pm_runtime_enable(&client->dev);
        pm_runtime_set_autosuspend_delay(&client->dev,
                                         MMA9551_AUTO_SUSPEND_DELAY_MS);
        pm_runtime_use_autosuspend(&client->dev);

        ret = iio_device_register(indio_dev);
        if (ret < 0) {
                dev_err(&client->dev, "unable to register iio device\n");
                goto err_pm_cleanup;
        }

        return 0;

err_pm_cleanup:
        pm_runtime_dont_use_autosuspend(&client->dev);
        pm_runtime_disable(&client->dev);
out_poweroff:
        mma9551_set_device_state(client, false);

        return ret;
}

static void mma9551_remove(struct i2c_client *client)
{
        struct iio_dev *indio_dev = i2c_get_clientdata(client);
        struct mma9551_data *data = iio_priv(indio_dev);

        iio_device_unregister(indio_dev);

        pm_runtime_disable(&client->dev);
        pm_runtime_set_suspended(&client->dev);

        mutex_lock(&data->mutex);
        mma9551_set_device_state(data->client, false);
        mutex_unlock(&data->mutex);
}

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

        mutex_lock(&data->mutex);
        ret = mma9551_set_device_state(data->client, false);
        mutex_unlock(&data->mutex);
        if (ret < 0) {
                dev_err(&data->client->dev, "powering off device failed\n");
                return -EAGAIN;
        }

        return 0;
}

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

        ret = mma9551_set_device_state(data->client, true);
        if (ret < 0)
                return ret;

        mma9551_sleep(MMA9551_DEFAULT_SAMPLE_RATE);

        return 0;
}

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

        mutex_lock(&data->mutex);
        ret = mma9551_set_device_state(data->client, false);
        mutex_unlock(&data->mutex);

        return ret;
}

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

        mutex_lock(&data->mutex);
        ret = mma9551_set_device_state(data->client, true);
        mutex_unlock(&data->mutex);

        return ret;
}

static const struct dev_pm_ops mma9551_pm_ops = {
        SYSTEM_SLEEP_PM_OPS(mma9551_suspend, mma9551_resume)
        RUNTIME_PM_OPS(mma9551_runtime_suspend, mma9551_runtime_resume, NULL)
};

static const struct acpi_device_id mma9551_acpi_match[] = {
        {"MMA9551", 0},
        { }
};

MODULE_DEVICE_TABLE(acpi, mma9551_acpi_match);

static const struct i2c_device_id mma9551_id[] = {
        { .name = "mma9551" },
        { }
};

MODULE_DEVICE_TABLE(i2c, mma9551_id);

static struct i2c_driver mma9551_driver = {
        .driver = {
                   .name = "mma9551",
                   .acpi_match_table = mma9551_acpi_match,
                   .pm = pm_ptr(&mma9551_pm_ops),
        },
        .probe = mma9551_probe,
        .remove = mma9551_remove,
        .id_table = mma9551_id,
};

module_i2c_driver(mma9551_driver);

MODULE_AUTHOR("Irina Tirdea <irina.tirdea@intel.com>");
MODULE_AUTHOR("Vlad Dogaru <vlad.dogaru@intel.com>");
MODULE_LICENSE("GPL v2");
MODULE_DESCRIPTION("MMA9551L motion-sensing platform driver");
MODULE_IMPORT_NS("IIO_MMA9551");