// SPDX-License-Identifier: GPL-2.0
/*
 * Copyright (c) 2021 Rockchip Electronics Co., Ltd
 */
#include <common.h>
#include <dm.h>
#include <errno.h>
#include <i2c.h>
#include <syscon.h>
#include <asm/gpio.h>
#include <power/regulator.h>
#include <asm/arch/clock.h>
#include <asm/io.h>

DECLARE_GLOBAL_DATA_PTR;

/* Voltage setting */

#define RK860X_VSEL0_A		0x00
#define RK860X_VSEL1_A		0x01
#define RK860X_VSEL0_B		0x06
#define RK860X_VSEL1_B		0x07
#define RK860X_MAX_SET		0x08

/* Control register */
#define RK860X_CONTROL		0x02
/* IC Type */
#define RK860X_ID1		0x03
/* IC mask version */
#define RK860X_ID2		0x04
/* Monitor register */
#define RK860X_MONITOR		0x05

/* VSEL bit definitions */
#define VSEL_BUCK_EN		BIT(7)
#define VSEL_MODE		BIT(6)
#define VSEL_A_NSEL_MASK	0x3F
#define VSEL_B_NSEL_MASK	0xff

/* Chip ID */
#define DIE_ID			0x0F
#define DIE_REV			0x0F
/* Control bit definitions */
#define CTL_OUTPUT_DISCHG	BIT(7)
#define CTL_SLEW_MASK		(0x7 << 4)
#define CTL_SLEW_SHIFT		4
#define CTL_RESET		BIT(2)

#define RK860X_NVOLTAGES_64	64
#define RK860X_NVOLTAGES_160	160

/* IC Type */
enum {
	RK860X_CHIP_ID_00 = 0,
	RK860X_CHIP_ID_01,
	RK860X_CHIP_ID_02,
	RK860X_CHIP_ID_03,
};

struct rk860x_regulator_info {
	struct udevice *dev;
	/* IC Type and Rev */
	int chip_id;
	/* Voltage setting register */
	unsigned int vol_reg;
	unsigned int sleep_reg;
	unsigned int en_reg;
	unsigned int sleep_en_reg;
	unsigned int mode_reg;
	unsigned int vol_mask;
	unsigned int mode_mask;
	unsigned int n_voltages;
	/* Voltage range and step(linear) */
	unsigned int vsel_min;
	unsigned int vsel_step;
	struct gpio_desc vsel_gpio;
	struct gpio_desc en_gpio;
	unsigned int sleep_vsel_id;
};

static int rk860x_write(struct udevice *dev, uint reg, const uint8_t *buff,
			int len)
{
	int ret;

	ret = dm_i2c_write(dev, reg, buff, len);
	if (ret) {
		dev_err(dev, "write reg[0x%02x] failed, ret=%d\n", reg, ret);
		return ret;
	}

	return 0;
}

static int rk860x_read(struct udevice *dev, uint reg, uint8_t *buff, int len)
{
	int ret;

	ret = dm_i2c_read(dev, reg, buff, len);
	if (ret) {
		dev_err(dev, "read reg[0x%02x] failed, ret=%d\n", reg, ret);
		return ret;
	}

	return 0;
}

static int rk860x_reg_read(struct udevice *dev, uint reg, u8 *val)
{
	int ret;

	debug("%s: reg=%x", __func__, reg);
	ret = rk860x_read(dev, reg, val, 1);
	debug(", value=%x, ret=%d\n", *val, ret);

	return ret;
}

static int rk860x_reg_write(struct udevice *dev, uint reg, uint value)
{
	u8 byte = value;
	int ret;

	debug("%s: reg=%x, value=%x", __func__, reg, value);
	ret = rk860x_write(dev, reg, &byte, 1);
	debug(", ret=%d\n", ret);

	return ret;
}

static int  rk860x_clrsetbits(struct udevice *dev, uint reg, uint clr, uint set)
{
	u8 byte, val;
	int ret;

	ret = rk860x_reg_read(dev, reg, &val);
	if (ret < 0)
		return ret;

	byte = (val & ~clr) | set;

	return rk860x_reg_write(dev, reg, byte);
}

static int rk860x_regulator_set_enable(struct udevice *dev, bool enable)
{
	struct rk860x_regulator_info *priv = dev_get_priv(dev);
	int val, sleep_vsel_id;

	if (enable) {
		val = VSEL_BUCK_EN;
		sleep_vsel_id = !priv->sleep_vsel_id;
	} else {
		val = 0;
		sleep_vsel_id = priv->sleep_vsel_id;
	}

	if (dm_gpio_is_valid(&priv->vsel_gpio)) {
		dm_gpio_set_value(&priv->vsel_gpio, sleep_vsel_id);
		return 0;
	}
	rk860x_clrsetbits(dev, priv->en_reg, VSEL_BUCK_EN, val);

	return 0;
}

static int rk860x_regulator_get_enable(struct udevice *dev)
{
	struct rk860x_regulator_info *priv = dev_get_priv(dev);
	u8 val;
	int ret;

	if (dm_gpio_is_valid(&priv->vsel_gpio)) {
		if (priv->sleep_vsel_id)
			return !dm_gpio_get_value(&priv->vsel_gpio);
		else
			return dm_gpio_get_value(&priv->vsel_gpio);
	}

	ret = rk860x_reg_read(dev, priv->en_reg, &val);
	if (ret)
		return ret;

	if (val & VSEL_BUCK_EN)
		return 1;
	else
		return 0;
}

static int rk860x_regulator_set_suspend_enable(struct udevice *dev,
					       bool enable)
{
	struct rk860x_regulator_info *priv = dev_get_priv(dev);
	int val;

	if (enable)
		val = VSEL_BUCK_EN;
	else
		val = 0;

	rk860x_clrsetbits(dev, priv->sleep_en_reg, VSEL_BUCK_EN, val);

	return 0;
}

static int rk860x_regulator_get_suspend_enable(struct udevice *dev)
{
	struct rk860x_regulator_info *priv = dev_get_priv(dev);
	int ret;
	u8 val;

	ret = rk860x_reg_read(dev, priv->sleep_en_reg, &val);
	if (ret)
		return ret;

	if (val & VSEL_BUCK_EN)
		return 1;
	else
		return 0;
}

static int rk860x_regulator_get_voltage(struct udevice *dev)
{
	struct rk860x_regulator_info *priv = dev_get_priv(dev);
	int uvolt = 0, ret;
	u8 val;

	ret = rk860x_reg_read(dev, priv->vol_reg, &val);
	if (ret)
		return ret;

	val &= priv->vol_mask;
	uvolt = (val * priv->vsel_step) + priv->vsel_min;

	return uvolt;
}

static int rk860x_regulator_set_voltage(struct udevice *dev, int uvolt)
{
	struct rk860x_regulator_info *priv = dev_get_priv(dev);
	int val;

	val = ((uvolt - priv->vsel_min) / priv->vsel_step);
	rk860x_clrsetbits(dev, priv->vol_reg, priv->vol_mask, val);

	return 0;
}

static int rk860x_regulator_get_suspend_voltage(struct udevice *dev)
{
	struct rk860x_regulator_info *priv = dev_get_priv(dev);
	int uvolt = 0, ret;
	u8 val;

	ret = rk860x_reg_read(dev, priv->sleep_reg, &val);
	if (ret)
		return ret;

	val &= priv->vol_mask;
	uvolt = (val * priv->vsel_step) + priv->vsel_min;

	return uvolt;
}

static int rk860x_regulator_set_suspend_voltage(struct udevice *dev,
						int uvolt)
{
	struct rk860x_regulator_info *priv = dev_get_priv(dev);
	int val;

	val = ((uvolt - priv->vsel_min) / priv->vsel_step);
	rk860x_clrsetbits(dev, priv->sleep_reg, priv->vol_mask, val);

	return 0;
}

/* For 00,01 options:
 * VOUT = 0.7125V + NSELx * 12.5mV, from 0.7125 to 1.5V.
 * For 02,03 options:
 * VOUT = 0.5V + NSELx * 6.25mV, from 0.5 to 1.5V.
 */
static int rk860x_device_setup(struct rk860x_regulator_info *di)
{
	int ret = 0;

	switch (di->chip_id) {
	case RK860X_CHIP_ID_00:
	case RK860X_CHIP_ID_01:
		di->vsel_min = 712500;
		di->vsel_step = 12500;
		di->n_voltages = RK860X_NVOLTAGES_64;
		di->vol_mask = VSEL_A_NSEL_MASK;
		if (di->sleep_vsel_id) {
			di->sleep_reg = RK860X_VSEL1_A;
			di->vol_reg = RK860X_VSEL0_A;
			di->mode_reg = RK860X_VSEL0_A;
			di->en_reg = RK860X_VSEL0_A;
			di->sleep_en_reg = RK860X_VSEL1_A;
		} else {
			di->sleep_reg = RK860X_VSEL0_A;
			di->vol_reg = RK860X_VSEL1_A;
			di->mode_reg = RK860X_VSEL1_A;
			di->en_reg = RK860X_VSEL1_A;
			di->sleep_en_reg = RK860X_VSEL0_A;
		}
		break;
	case RK860X_CHIP_ID_02:
	case RK860X_CHIP_ID_03:
		di->vsel_min = 500000;
		di->vsel_step = 6250;
		di->n_voltages = RK860X_NVOLTAGES_160;
		di->vol_mask = VSEL_B_NSEL_MASK;
		if (di->sleep_vsel_id) {
			di->sleep_reg = RK860X_VSEL1_B;
			di->vol_reg = RK860X_VSEL0_B;
			di->mode_reg = RK860X_VSEL0_A;
			di->en_reg = RK860X_VSEL0_A;
			di->sleep_en_reg = RK860X_VSEL1_A;
		} else {
			di->sleep_reg = RK860X_VSEL0_B;
			di->vol_reg = RK860X_VSEL1_B;
			di->mode_reg = RK860X_VSEL1_A;
			di->en_reg = RK860X_VSEL1_A;
			di->sleep_en_reg = RK860X_VSEL0_A;
		}
		break;
	default:
		dev_err(di->dev,
			"Chip ID %d not supported!\n",
			di->chip_id);
		return -EINVAL;
	}

	di->mode_mask = VSEL_MODE;

	return ret;
}

static int rk860x_regulator_ofdata_to_platdata(struct udevice *dev)
{
	struct rk860x_regulator_info *priv = dev_get_priv(dev);
	int ret;

	priv->sleep_vsel_id = dev_read_u32_default(dev,
						   "rockchip,suspend-voltage-selector",
						   1);

	ret = gpio_request_by_name(dev, "vsel-gpios", 0,
				   &priv->vsel_gpio, GPIOD_IS_OUT);
	if (ret)
		dev_err(dev, "vsel-gpios- not found!\n");

	if (dm_gpio_is_valid(&priv->vsel_gpio))
		dm_gpio_set_value(&priv->vsel_gpio, !priv->sleep_vsel_id);

	ret = gpio_request_by_name(dev, "en-gpios", 0,
				   &priv->en_gpio, GPIOD_IS_OUT);
	if (ret)
		dev_err(dev, "en-gpios- not found!\n");

	if (dm_gpio_is_valid(&priv->en_gpio))
		dm_gpio_set_value(&priv->en_gpio, 1);

	return 0;
}

static int rk860x_regulator_probe(struct udevice *dev)
{
	struct rk860x_regulator_info *di = dev_get_priv(dev);
	struct dm_regulator_uclass_platdata *uc_pdata;
	u8 val;
	int ret;

	uc_pdata = dev_get_uclass_platdata(dev);
	uc_pdata->type = REGULATOR_TYPE_BUCK;
	uc_pdata->mode_count = 0;

	/* Get chip ID */
	ret = rk860x_reg_read(dev, RK860X_ID1, &val);
	if (ret) {
		dev_err(dev, "Failed to get chip ID!\n");
		return ret;
	}

	if ((val & DIE_ID) == 0x8)
		di->chip_id = RK860X_CHIP_ID_00;
	else
		di->chip_id = RK860X_CHIP_ID_02;

	debug("RK860X Option[%d] Detected!\n", val & DIE_ID);

	/* Device init */
	ret = rk860x_device_setup(di);
	if (ret < 0) {
		dev_err(dev, "Failed to setup device!\n");
		return ret;
	}

	return 0;
}

static const struct udevice_id rk860x_id[] = {
	{
		.compatible = "rockchip,rk8600",
	},
	{
		.compatible = "rockchip,rk8601",
	},
	{
		.compatible = "rockchip,rk8602",
	},
	{
		.compatible = "rockchip,rk8603",
	},
	{ },
};

static const struct dm_regulator_ops rk860x_regulator_ops = {
	.get_value  = rk860x_regulator_get_voltage,
	.set_value  = rk860x_regulator_set_voltage,
	.set_suspend_value = rk860x_regulator_set_suspend_voltage,
	.get_suspend_value = rk860x_regulator_get_suspend_voltage,
	.set_enable = rk860x_regulator_set_enable,
	.get_enable = rk860x_regulator_get_enable,
	.set_suspend_enable = rk860x_regulator_set_suspend_enable,
	.get_suspend_enable = rk860x_regulator_get_suspend_enable,
};

U_BOOT_DRIVER(rk860x_regulator) = {
	.name = "rk860x_regulator",
	.id = UCLASS_REGULATOR,
	.ops = &rk860x_regulator_ops,
	.probe = rk860x_regulator_probe,
	.of_match = rk860x_id,
	.ofdata_to_platdata = rk860x_regulator_ofdata_to_platdata,
	.priv_auto_alloc_size = sizeof(struct rk860x_regulator_info),
};