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

DECLARE_GLOBAL_DATA_PTR;

/* Voltage setting */
#define FAN53555_VSEL0		0x00
#define FAN53555_VSEL1		0x01

#define TCS452X_VSEL0		0x11
#define TCS452X_VSEL1		0x10
#define TCS452X_TIME		0x13
#define TCS452X_COMMAND		0x14

/* Control register */
#define FAN53555_CONTROL	0x02
/* IC Type */
#define FAN53555_ID1		0x03
/* IC mask version */
#define FAN53555_ID2		0x04
/* Monitor register */
#define FAN53555_MONITOR	0x05

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

/* Chip ID and Version */
#define DIE_ID			0x0F/* ID1 */
#define DIE_REV			0x0F/* ID2 */
/* 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 TCS_VSEL_NSEL_MASK	0x7f
#define TCS_VSEL0_MODE		BIT(7)
#define TCS_VSEL1_MODE		BIT(6)

#define TCS_SLEW_SHIFT		3
#define TCS_SLEW_MASK		(0x3 < 3)

#define FAN53555_NVOLTAGES_64	64/* Numbers of voltages */
#define FAN53555_NVOLTAGES_127	127/* Numbers of voltages */

enum fan53555_vendor {
	FAN53555_VENDOR_FAIRCHILD = 0,
	FAN53555_VENDOR_SILERGY,
	FAN53555_VENDOR_TCS,
};

/* IC Type */
enum {
	FAN53555_CHIP_ID_00 = 0,
	FAN53555_CHIP_ID_01,
	FAN53555_CHIP_ID_02,
	FAN53555_CHIP_ID_03,
	FAN53555_CHIP_ID_04,
	FAN53555_CHIP_ID_05,
	FAN53555_CHIP_ID_08 = 8,
};

/* IC mask revision */
enum {
	FAN53555_CHIP_REV_00 = 0x3,
	FAN53555_CHIP_REV_13 = 0xf,
};

enum {
	SILERGY_SYR82X = 8,
};

enum {
	FAN53555_VSEL_ID_0 = 0,
	FAN53555_VSEL_ID_1,
};

struct fan53555_regulator_info {
	enum fan53555_vendor vendor;
	struct udevice *dev;
	/* IC Type and Rev */
	int chip_id;
	int chip_rev;
	/* Voltage setting register */
	unsigned int vol_reg;
	unsigned int sleep_reg;
	unsigned int mode_reg;
	unsigned int vol_mask;
	unsigned int mode_mask;
	/* Voltage range and step(linear) */
	unsigned int vsel_min;
	unsigned int vsel_step;
	struct gpio_desc vsel_gpio;
	unsigned int sleep_vsel_id;
};

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

	ret = dm_i2c_write(dev, reg, buff, len);
	if (ret) {
		debug("%s: write reg 0x%02x failed, ret=%d\n",
		      __func__, reg, ret);
		return ret;
	}

	return 0;
}

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

	ret = dm_i2c_read(dev, reg, buff, len);
	if (ret) {
		debug("%s: read reg 0x%02x failed, ret=%d\n",
		      __func__, reg, ret);
		return ret;
	}

	return 0;
}

int fan53555_reg_read(struct udevice *dev, uint reg)
{
	u8 byte;
	int ret;

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

	return ret ? ret : byte;
}

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

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

	return ret;
}

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

	ret = fan53555_reg_read(dev, reg);
	if (ret < 0)
		return ret;
	byte = (ret & ~clr) | set;

	return fan53555_reg_write(dev, reg, byte);
}

static int fan53555_regulator_set_enable(struct udevice *dev, bool enable)
{
	struct fan53555_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;
	}
	fan53555_clrsetbits(dev, priv->vol_reg, VSEL_BUCK_EN, val);

	return 0;
}

static int fan53555_regulator_get_enable(struct udevice *dev)
{
	struct fan53555_regulator_info *priv = dev_get_priv(dev);
	int val;

	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);
	}

	val = fan53555_reg_read(dev, priv->vol_reg);
	if (val & VSEL_BUCK_EN)
		return 1;
	else
		return 0;
}

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

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

	fan53555_clrsetbits(dev, priv->sleep_reg, VSEL_BUCK_EN, val);

	return 0;
}

static int fan53555_regulator_get_suspend_enable(struct udevice *dev)
{
	struct fan53555_regulator_info *priv = dev_get_priv(dev);
	int val;

	val = fan53555_reg_read(dev, priv->sleep_reg);
	if (val & VSEL_BUCK_EN)
		return 1;
	else
		return 0;
}

static int fan53555_regulator_get_voltage(struct udevice *dev)
{
	struct fan53555_regulator_info *priv = dev_get_priv(dev);
	int uvolt = 0, val;

	val = fan53555_reg_read(dev, priv->vol_reg);
	val &= priv->vol_mask;
	uvolt = (val * priv->vsel_step) + priv->vsel_min;

	return uvolt;
}

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

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

	return 0;
}

static int fan53555_regulator_get_suspend_voltage(struct udevice *dev)
{
	struct fan53555_regulator_info *priv = dev_get_priv(dev);
	int uvolt = 0, val;

	val = fan53555_reg_read(dev, priv->sleep_reg);
	val &= priv->vol_mask;
	uvolt = (val * priv->vsel_step) + priv->vsel_min;

	return uvolt;
}

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

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

	return 0;
}

static int fan53555_voltages_setup_fairchild(struct fan53555_regulator_info *di)
{
	/* Init voltage range and step */
	switch (di->chip_id) {
	case FAN53555_CHIP_ID_00:
		switch (di->chip_rev) {
		case FAN53555_CHIP_REV_00:
			di->vsel_min = 600000;
			di->vsel_step = 10000;
			break;
		case FAN53555_CHIP_REV_13:
			di->vsel_min = 800000;
			di->vsel_step = 10000;
			break;
		default:
			dev_err(di->dev,
				"Chip ID %d with rev %d not supported!\n",
				di->chip_id, di->chip_rev);
			return -EINVAL;
		}
		break;
	case FAN53555_CHIP_ID_01:
	case FAN53555_CHIP_ID_03:
	case FAN53555_CHIP_ID_05:
	case FAN53555_CHIP_ID_08:
		di->vsel_min = 600000;
		di->vsel_step = 10000;
		break;
	case FAN53555_CHIP_ID_04:
		di->vsel_min = 603000;
		di->vsel_step = 12826;
		break;
	default:
		dev_err(di->dev,
			"Chip ID %d not supported!\n", di->chip_id);
		return -EINVAL;
	}
	di->vol_mask = VSEL_NSEL_MASK;

	return 0;
}

static int fan53555_voltages_setup_silergy(struct fan53555_regulator_info *di)
{
	/* Init voltage range and step */
	di->vsel_min = 712500;
	di->vsel_step = 12500;
	di->vol_mask = VSEL_NSEL_MASK;

	return 0;
}

static int fan53555_voltages_setup_tcs(struct fan53555_regulator_info *di)
{
	if (di->sleep_vsel_id) {
		di->sleep_reg = TCS452X_VSEL1;
		di->vol_reg = TCS452X_VSEL0;
	} else {
		di->sleep_reg = TCS452X_VSEL0;
		di->vol_reg = TCS452X_VSEL1;
	}

	di->vol_mask = TCS_VSEL_NSEL_MASK;

	/* Init voltage range and step */
	di->vsel_min = 600000;
	di->vsel_step = 6250;

	return 0;
}

/* For 00,01,03,05 options:
 * VOUT = 0.60V + NSELx * 10mV, from 0.60 to 1.23V.
 * For 04 option:
 * VOUT = 0.603V + NSELx * 12.826mV, from 0.603 to 1.411V.
 *
 */

static int fan53555_device_setup(struct fan53555_regulator_info *di)
{
	int ret = 0;

	/* Setup voltage control register */
	switch (di->sleep_vsel_id) {
	case FAN53555_VSEL_ID_0:
		di->sleep_reg = FAN53555_VSEL0;
		di->vol_reg = FAN53555_VSEL1;
		break;
	case FAN53555_VSEL_ID_1:
		di->sleep_reg = FAN53555_VSEL1;
		di->vol_reg = FAN53555_VSEL0;
		break;
	default:
		dev_err(di->dev, "Invalid VSEL ID!\n");
		return -EINVAL;
	}

	switch (di->vendor) {
	case FAN53555_VENDOR_FAIRCHILD:
		ret = fan53555_voltages_setup_fairchild(di);
		break;
	case FAN53555_VENDOR_SILERGY:
		ret = fan53555_voltages_setup_silergy(di);
		break;
	case FAN53555_VENDOR_TCS:
		ret = fan53555_voltages_setup_tcs(di);
		break;
	default:
		dev_err(di->dev, "vendor %d not supported!\n", di->vendor);
		return -EINVAL;
	}

	return ret;
}

static int fan53555_regulator_ofdata_to_platdata(struct udevice *dev)
{
	struct fan53555_regulator_info *priv = dev_get_priv(dev);
	int ret;

	priv->sleep_vsel_id = dev_read_u32_default(dev,
						   "fcs,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! Error: %d\n", ret);

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

	priv->vendor = dev_get_driver_data(dev);

	return 0;
}

static int fan53555_regulator_probe(struct udevice *dev)
{
	struct fan53555_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 */
	val = fan53555_reg_read(dev, FAN53555_ID1);
	if (val < 0) {
		dev_err(dev, "Failed to get chip ID!\n");
		return val;
	}
	di->chip_id = val & DIE_ID;

	/* Get chip revision */
	val = fan53555_reg_read(dev, FAN53555_ID2);
	if (val < 0) {
		dev_err(dev, "Failed to get chip Rev!\n");
		return val;
	}
	di->chip_rev = val & DIE_REV;

	debug("FAN53555 Option[%d] Rev[%d] Detected!\n",
	      di->chip_id, di->chip_rev);

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

	return 0;
}

static const struct udevice_id fan53555_id[] = {
	{
		.compatible = "fan53555",
		.data = FAN53555_VENDOR_FAIRCHILD,
	}, {
		.compatible = "silergy,syr827",
		.data = FAN53555_VENDOR_SILERGY,
	}, {
		.compatible = "silergy,syr828",
		.data = FAN53555_VENDOR_SILERGY,
	}, {
		.compatible = "tcs,tcs452x", /* tcs4525/4526 */
		.data = FAN53555_VENDOR_TCS,
	},
	{ },
};

static const struct dm_regulator_ops fan53555_regulator_ops = {
	.get_value  = fan53555_regulator_get_voltage,
	.set_value  = fan53555_regulator_set_voltage,
	.set_suspend_value = fan53555_regulator_set_suspend_voltage,
	.get_suspend_value = fan53555_regulator_get_suspend_voltage,
	.set_enable = fan53555_regulator_set_enable,
	.get_enable = fan53555_regulator_get_enable,
	.set_suspend_enable = fan53555_regulator_set_suspend_enable,
	.get_suspend_enable = fan53555_regulator_get_suspend_enable,
};

U_BOOT_DRIVER(fan53555_regulator) = {
	.name = "fan53555_regulator",
	.id = UCLASS_REGULATOR,
	.ops = &fan53555_regulator_ops,
	.probe = fan53555_regulator_probe,
	.of_match = fan53555_id,
	.ofdata_to_platdata = fan53555_regulator_ofdata_to_platdata,
	.priv_auto_alloc_size = sizeof(struct fan53555_regulator_info),
};