// SPDX-License-Identifier: GPL-2.0-only
//
// Copyright (c) 2021-2022 Samuel Holland <samuel@sholland.org>
//

#include <linux/mfd/syscon.h>
#include <linux/module.h>
#include <linux/of.h>
#include <linux/of_device.h>
#include <linux/platform_device.h>
#include <linux/regmap.h>
#include <linux/regulator/driver.h>

#define SUN20I_SYS_LDO_CTRL_REG		0x150

struct sun20i_regulator_data {
	const struct regulator_desc	*descs;
	unsigned int			ndescs;
};

/* regulator_list_voltage_linear() modified for the non-integral uV_step. */
static int sun20i_d1_system_ldo_list_voltage(struct regulator_dev *rdev,
					     unsigned int selector)
{
	const struct regulator_desc *desc = rdev->desc;
	unsigned int fraction, uV;

	if (selector >= desc->n_voltages)
		return -EINVAL;

	uV = desc->min_uV + (desc->uV_step * selector);
	fraction = selector + (desc->min_uV % 4);

	if (uV > 1606667)
		uV += 6667;
	else
		fraction++;

	/* Produce correctly-rounded absolute voltages. */
	return uV + (fraction / 3);
}

static const struct regulator_ops sun20i_d1_system_ldo_ops = {
	.list_voltage		= sun20i_d1_system_ldo_list_voltage,
	.map_voltage		= regulator_map_voltage_ascend,
	.set_voltage_sel	= regulator_set_voltage_sel_regmap,
	.get_voltage_sel	= regulator_get_voltage_sel_regmap,
};

static const struct regulator_desc sun20i_d1_system_ldo_descs[] = {
	{
		.name		= "ldoa",
		.supply_name	= "ldo-in",
		.of_match	= "ldoa",
		.ops		= &sun20i_d1_system_ldo_ops,
		.type		= REGULATOR_VOLTAGE,
		.owner		= THIS_MODULE,
		.n_voltages	= 32,
		.min_uV		= 1593333,
		.uV_step	= 13333, /* repeating */
		.vsel_reg	= SUN20I_SYS_LDO_CTRL_REG,
		.vsel_mask	= GENMASK(7, 0),
	},
	{
		.name		= "ldob",
		.supply_name	= "ldo-in",
		.of_match	= "ldob",
		.ops		= &sun20i_d1_system_ldo_ops,
		.type		= REGULATOR_VOLTAGE,
		.owner		= THIS_MODULE,
		.n_voltages	= 64,
		.min_uV		= 1166666,
		.uV_step	= 13333, /* repeating */
		.vsel_reg	= SUN20I_SYS_LDO_CTRL_REG,
		.vsel_mask	= GENMASK(15, 8),
	},
};

static const struct sun20i_regulator_data sun20i_d1_system_ldos = {
	.descs	= sun20i_d1_system_ldo_descs,
	.ndescs	= ARRAY_SIZE(sun20i_d1_system_ldo_descs),
};

static struct regmap *sun20i_regulator_get_regmap(struct device *dev)
{
	struct regmap *regmap;

	/*
	 * First try the syscon interface. The system control device is not
	 * compatible with "syscon", so fall back to getting the regmap from
	 * its platform device. This is ugly, but required for devicetree
	 * backward compatibility.
	 */
	regmap = syscon_node_to_regmap(dev->parent->of_node);
	if (!IS_ERR(regmap))
		return regmap;

	regmap = dev_get_regmap(dev->parent, NULL);
	if (regmap)
		return regmap;

	return ERR_PTR(-EPROBE_DEFER);
}

static int sun20i_regulator_probe(struct platform_device *pdev)
{
	const struct sun20i_regulator_data *data;
	struct device *dev = &pdev->dev;
	struct regulator_config config;
	struct regmap *regmap;

	data = of_device_get_match_data(dev);
	if (!data)
		return -EINVAL;

	regmap = sun20i_regulator_get_regmap(dev);
	if (IS_ERR(regmap))
		return dev_err_probe(dev, PTR_ERR(regmap), "Failed to get regmap\n");

	config = (struct regulator_config) {
		.dev	= dev,
		.regmap	= regmap,
	};

	for (unsigned int i = 0; i < data->ndescs; ++i) {
		const struct regulator_desc *desc = &data->descs[i];
		struct regulator_dev *rdev;

		rdev = devm_regulator_register(dev, desc, &config);
		if (IS_ERR(rdev))
			return PTR_ERR(rdev);
	}

	return 0;
}

static const struct of_device_id sun20i_regulator_of_match[] = {
	{
		.compatible = "allwinner,sun20i-d1-system-ldos",
		.data = &sun20i_d1_system_ldos,
	},
	{ },
};
MODULE_DEVICE_TABLE(of, sun20i_regulator_of_match);

static struct platform_driver sun20i_regulator_driver = {
	.probe	= sun20i_regulator_probe,
	.driver	= {
		.name		= "sun20i-regulator",
		.of_match_table	= sun20i_regulator_of_match,
	},
};
module_platform_driver(sun20i_regulator_driver);

MODULE_AUTHOR("Samuel Holland <samuel@sholland.org>");
MODULE_DESCRIPTION("Allwinner D1 internal LDO driver");
MODULE_LICENSE("GPL");