// SPDX-License-Identifier: GPL-2.0-or-later
/*
 * Driver for MPS MP3309C White LED driver with I2C interface
 *
 * This driver support both analog (by I2C commands) and PWM dimming control
 * modes.
 *
 * Copyright (C) 2023 ASEM Srl
 * Author: Flavio Suligoi <f.suligoi@asem.it>
 *
 * Based on pwm_bl.c
 */

#include <linux/backlight.h>
#include <linux/delay.h>
#include <linux/gpio/consumer.h>
#include <linux/i2c.h>
#include <linux/property.h>
#include <linux/pwm.h>
#include <linux/regmap.h>

#define REG_I2C_0       0x00
#define REG_I2C_1       0x01

#define REG_I2C_0_EN    0x80
#define REG_I2C_0_D0    0x40
#define REG_I2C_0_D1    0x20
#define REG_I2C_0_D2    0x10
#define REG_I2C_0_D3    0x08
#define REG_I2C_0_D4    0x04
#define REG_I2C_0_RSRV1 0x02
#define REG_I2C_0_RSRV2 0x01

#define REG_I2C_1_RSRV1 0x80
#define REG_I2C_1_DIMS  0x40
#define REG_I2C_1_SYNC  0x20
#define REG_I2C_1_OVP0  0x10
#define REG_I2C_1_OVP1  0x08
#define REG_I2C_1_VOS   0x04
#define REG_I2C_1_LEDO  0x02
#define REG_I2C_1_OTP   0x01

#define ANALOG_I2C_NUM_LEVELS   32              /* 0..31 */
#define ANALOG_I2C_REG_MASK     0x7c

#define MP3309C_PWM_DEFAULT_NUM_LEVELS  256     /* 0..255 */

enum mp3309c_status_value {
        FIRST_POWER_ON,
        BACKLIGHT_OFF,
        BACKLIGHT_ON,
};

enum mp3309c_dimming_mode_value {
        DIMMING_PWM,
        DIMMING_ANALOG_I2C,
};

struct mp3309c_platform_data {
        unsigned int max_brightness;
        unsigned int default_brightness;
        unsigned int *levels;
        u8  dimming_mode;
        u8  over_voltage_protection;
        bool sync_mode;
        u8 status;
};

struct mp3309c_chip {
        struct device *dev;
        struct mp3309c_platform_data *pdata;
        struct backlight_device *bl;
        struct gpio_desc *enable_gpio;
        struct regmap *regmap;
        struct pwm_device *pwmd;
};

static const struct regmap_config mp3309c_regmap = {
        .name = "mp3309c_regmap",
        .reg_bits = 8,
        .reg_stride = 1,
        .val_bits = 8,
        .max_register = REG_I2C_1,
};

static int mp3309c_enable_device(struct mp3309c_chip *chip)
{
        u8 reg_val;
        int ret;

        /* I2C register #0 - Device enable */
        ret = regmap_update_bits(chip->regmap, REG_I2C_0, REG_I2C_0_EN,
                                 REG_I2C_0_EN);
        if (ret)
                return ret;

        /*
         * I2C register #1 - Set working mode:
         *  - enable/disable synchronous mode
         *  - set overvoltage protection (OVP)
         */
        reg_val = 0x00;
        if (chip->pdata->sync_mode)
                reg_val |= REG_I2C_1_SYNC;
        reg_val |= chip->pdata->over_voltage_protection;
        ret = regmap_write(chip->regmap, REG_I2C_1, reg_val);
        if (ret)
                return ret;

        return 0;
}

static int mp3309c_bl_update_status(struct backlight_device *bl)
{
        struct mp3309c_chip *chip = bl_get_data(bl);
        int brightness = backlight_get_brightness(bl);
        struct pwm_state pwmstate;
        unsigned int analog_val, bits_val;
        int i, ret;

        if (chip->pdata->dimming_mode == DIMMING_PWM) {
                /*
                 * PWM control mode
                 */
                pwm_get_state(chip->pwmd, &pwmstate);
                pwm_set_relative_duty_cycle(&pwmstate,
                                            chip->pdata->levels[brightness],
                                            chip->pdata->levels[chip->pdata->max_brightness]);
                pwmstate.enabled = true;
                ret = pwm_apply_might_sleep(chip->pwmd, &pwmstate);
                if (ret)
                        return ret;

                switch (chip->pdata->status) {
                case FIRST_POWER_ON:
                case BACKLIGHT_OFF:
                        /*
                         * After 20ms of low pwm signal level, the chip turns
                         * off automatically. In this case, before enabling the
                         * chip again, we must wait about 10ms for pwm signal to
                         * stabilize.
                         */
                        if (brightness > 0) {
                                msleep(10);
                                mp3309c_enable_device(chip);
                                chip->pdata->status = BACKLIGHT_ON;
                        } else {
                                chip->pdata->status = BACKLIGHT_OFF;
                        }
                        break;
                case BACKLIGHT_ON:
                        if (brightness == 0)
                                chip->pdata->status = BACKLIGHT_OFF;
                        break;
                }
        } else {
                /*
                 * Analog (by I2C command) control mode
                 *
                 * The first time, before setting brightness, we must enable the
                 * device
                 */
                if (chip->pdata->status == FIRST_POWER_ON)
                        mp3309c_enable_device(chip);

                /*
                 * Dimming mode I2C command (fixed dimming range 0..31)
                 *
                 * The 5 bits of the dimming analog value D4..D0 is allocated
                 * in the I2C register #0, in the following way:
                 *
                 *     +--+--+--+--+--+--+--+--+
                 *     |EN|D0|D1|D2|D3|D4|XX|XX|
                 *     +--+--+--+--+--+--+--+--+
                 */
                analog_val = brightness;
                bits_val = 0;
                for (i = 0; i <= 5; i++)
                        bits_val += ((analog_val >> i) & 0x01) << (6 - i);
                ret = regmap_update_bits(chip->regmap, REG_I2C_0,
                                         ANALOG_I2C_REG_MASK, bits_val);
                if (ret)
                        return ret;

                if (brightness > 0)
                        chip->pdata->status = BACKLIGHT_ON;
                else
                        chip->pdata->status = BACKLIGHT_OFF;
        }

        return 0;
}

static const struct backlight_ops mp3309c_bl_ops = {
        .update_status = mp3309c_bl_update_status,
};

static int mp3309c_parse_fwnode(struct mp3309c_chip *chip,
                                struct mp3309c_platform_data *pdata)
{
        int ret, i;
        unsigned int tmp_value;
        struct device *dev = chip->dev;
        int num_levels;

        if (!dev_fwnode(dev))
                return dev_err_probe(dev, -ENODEV, "failed to get firmware node\n");

        /*
         * Dimming mode: the MP3309C provides two dimming control mode:
         *
         * - PWM mode
         * - Analog by I2C control mode (default)
         *
         * I2C control mode is assumed as default but, if the pwms property is
         * found in the backlight node, the mode switches to PWM mode.
         */
        pdata->dimming_mode = DIMMING_ANALOG_I2C;
        if (device_property_present(dev, "pwms")) {
                chip->pwmd = devm_pwm_get(dev, NULL);
                if (IS_ERR(chip->pwmd))
                        return dev_err_probe(dev, PTR_ERR(chip->pwmd), "error getting pwm data\n");
                pdata->dimming_mode = DIMMING_PWM;
        }

        /*
         * In I2C control mode the dimming levels (0..31) are fixed by the
         * hardware, while in PWM control mode they can be chosen by the user,
         * to allow nonlinear mappings.
         */
        if  (pdata->dimming_mode == DIMMING_ANALOG_I2C) {
                /*
                 * Analog (by I2C commands) control mode: fixed 0..31 brightness
                 * levels
                 */
                num_levels = ANALOG_I2C_NUM_LEVELS;

                /* Enable GPIO used in I2C dimming mode only */
                chip->enable_gpio = devm_gpiod_get(dev, "enable", GPIOD_OUT_HIGH);
                if (IS_ERR(chip->enable_gpio))
                        return dev_err_probe(dev, PTR_ERR(chip->enable_gpio),
                                             "error getting enable gpio\n");
        } else {
                /*
                 * PWM control mode: check for brightness level in DT
                 */
                if (device_property_present(dev, "brightness-levels")) {
                        /* Read brightness levels from DT */
                        num_levels = device_property_count_u32(dev, "brightness-levels");
                        if (num_levels < 2)
                                return -EINVAL;
                } else {
                        /* Use default brightness levels */
                        num_levels = MP3309C_PWM_DEFAULT_NUM_LEVELS;
                }
        }

        /* Fill brightness levels array */
        pdata->levels = devm_kcalloc(dev, num_levels, sizeof(*pdata->levels), GFP_KERNEL);
        if (!pdata->levels)
                return -ENOMEM;
        if (device_property_present(dev, "brightness-levels")) {
                ret = device_property_read_u32_array(dev, "brightness-levels",
                                                     pdata->levels, num_levels);
                if (ret < 0)
                        return ret;
        } else {
                for (i = 0; i < num_levels; i++)
                        pdata->levels[i] = i;
        }

        pdata->max_brightness = num_levels - 1;

        ret = device_property_read_u32(dev, "default-brightness", &pdata->default_brightness);
        if (ret)
                pdata->default_brightness = pdata->max_brightness;
        if (pdata->default_brightness > pdata->max_brightness) {
                dev_err_probe(dev, -ERANGE, "default brightness exceeds max brightness\n");
                pdata->default_brightness = pdata->max_brightness;
        }

        /*
         * Over-voltage protection (OVP)
         *
         * This (optional) property values are:
         *
         *  - 13.5V
         *  - 24V
         *  - 35.5V (hardware default setting)
         *
         * If missing, the default value for OVP is 35.5V
         */
        pdata->over_voltage_protection = REG_I2C_1_OVP1;
        ret = device_property_read_u32(dev, "mps,overvoltage-protection-microvolt", &tmp_value);
        if (!ret) {
                switch (tmp_value) {
                case 13500000:
                        pdata->over_voltage_protection = 0x00;
                        break;
                case 24000000:
                        pdata->over_voltage_protection = REG_I2C_1_OVP0;
                        break;
                case 35500000:
                        pdata->over_voltage_protection = REG_I2C_1_OVP1;
                        break;
                default:
                        return -EINVAL;
                }
        }

        /* Synchronous (default) and non-synchronous mode */
        pdata->sync_mode = !device_property_read_bool(dev, "mps,no-sync-mode");

        return 0;
}

static int mp3309c_probe(struct i2c_client *client)
{
        struct device *dev = &client->dev;
        struct mp3309c_platform_data *pdata = dev_get_platdata(dev);
        struct mp3309c_chip *chip;
        struct backlight_properties props;
        struct pwm_state pwmstate;
        int ret;

        if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C))
                return dev_err_probe(dev, -EOPNOTSUPP, "failed to check i2c functionality\n");

        chip = devm_kzalloc(dev, sizeof(*chip), GFP_KERNEL);
        if (!chip)
                return -ENOMEM;

        chip->dev = dev;

        chip->regmap = devm_regmap_init_i2c(client, &mp3309c_regmap);
        if (IS_ERR(chip->regmap))
                return dev_err_probe(dev, PTR_ERR(chip->regmap),
                                     "failed to allocate register map\n");

        i2c_set_clientdata(client, chip);

        if (!pdata) {
                pdata = devm_kzalloc(dev, sizeof(*pdata), GFP_KERNEL);
                if (!pdata)
                        return -ENOMEM;

                ret = mp3309c_parse_fwnode(chip, pdata);
                if (ret)
                        return ret;
        }
        chip->pdata = pdata;

        /* Backlight properties */
        props = (typeof(props)){
                .brightness = pdata->default_brightness,
                .max_brightness = pdata->max_brightness,
                .scale = BACKLIGHT_SCALE_LINEAR,
                .type = BACKLIGHT_RAW,
                .power = BACKLIGHT_POWER_ON,
        };
        chip->bl = devm_backlight_device_register(dev, "mp3309c", dev, chip,
                                                  &mp3309c_bl_ops, &props);
        if (IS_ERR(chip->bl))
                return dev_err_probe(dev, PTR_ERR(chip->bl),
                                     "error registering backlight device\n");

        /* In PWM dimming mode, enable pwm device */
        if (chip->pdata->dimming_mode == DIMMING_PWM) {
                pwm_init_state(chip->pwmd, &pwmstate);
                pwm_set_relative_duty_cycle(&pwmstate,
                                            chip->pdata->default_brightness,
                                            chip->pdata->max_brightness);
                pwmstate.enabled = true;
                ret = pwm_apply_might_sleep(chip->pwmd, &pwmstate);
                if (ret)
                        return dev_err_probe(dev, ret, "error setting pwm device\n");
        }

        chip->pdata->status = FIRST_POWER_ON;
        backlight_update_status(chip->bl);

        return 0;
}

static void mp3309c_remove(struct i2c_client *client)
{
        struct mp3309c_chip *chip = i2c_get_clientdata(client);
        struct backlight_device *bl = chip->bl;

        bl->props.power = BACKLIGHT_POWER_OFF;
        bl->props.brightness = 0;
        backlight_update_status(chip->bl);
}

static const struct of_device_id mp3309c_match_table[] = {
        { .compatible = "mps,mp3309c", },
        { },
};
MODULE_DEVICE_TABLE(of, mp3309c_match_table);

static const struct i2c_device_id mp3309c_id[] = {
        { .name = "mp3309c" },
        { }
};
MODULE_DEVICE_TABLE(i2c, mp3309c_id);

static struct i2c_driver mp3309c_i2c_driver = {
        .driver = {
                        .name           = KBUILD_MODNAME,
                        .of_match_table = mp3309c_match_table,
        },
        .probe          = mp3309c_probe,
        .remove         = mp3309c_remove,
        .id_table       = mp3309c_id,
};

module_i2c_driver(mp3309c_i2c_driver);

MODULE_DESCRIPTION("Backlight Driver for MPS MP3309C");
MODULE_AUTHOR("Flavio Suligoi <f.suligoi@asem.it>");
MODULE_LICENSE("GPL");