[linux-2.6-block.git] / drivers / regulator / max77686-regulator.c

// SPDX-License-Identifier: GPL-2.0+
//
// max77686.c - Regulator driver for the Maxim 77686
//
// Copyright (C) 2012 Samsung Electronics
// Chiwoong Byun <woong.byun@samsung.com>
// Jonghwa Lee <jonghwa3.lee@samsung.com>
//
// This driver is based on max8997.c

#include <linux/kernel.h>
#include <linux/bug.h>
#include <linux/err.h>
#include <linux/gpio/consumer.h>
#include <linux/slab.h>
#include <linux/platform_device.h>
#include <linux/regulator/driver.h>
#include <linux/regulator/machine.h>
#include <linux/regulator/of_regulator.h>
#include <linux/mfd/max77686.h>
#include <linux/mfd/max77686-private.h>

#define MAX77686_LDO_MINUV	800000
#define MAX77686_LDO_UVSTEP	50000
#define MAX77686_LDO_LOW_MINUV	800000
#define MAX77686_LDO_LOW_UVSTEP	25000
#define MAX77686_BUCK_MINUV	750000
#define MAX77686_BUCK_UVSTEP	50000
#define MAX77686_BUCK_ENABLE_TIME	40		/* us */
#define MAX77686_DVS_ENABLE_TIME	22		/* us */
#define MAX77686_RAMP_DELAY	100000			/* uV/us */
#define MAX77686_DVS_RAMP_DELAY	27500			/* uV/us */
#define MAX77686_DVS_MINUV	600000
#define MAX77686_DVS_UVSTEP	12500

/*
 * Value for configuring buck[89] and LDO{20,21,22} as GPIO control.
 * It is the same as 'off' for other regulators.
 */
#define MAX77686_GPIO_CONTROL		0x0
/*
 * Values used for configuring LDOs and bucks.
 * Forcing low power mode: LDO1, 3-5, 9, 13, 17-26
 */
#define MAX77686_LDO_LOWPOWER		0x1
/*
 * On/off controlled by PWRREQ:
 *  - LDO2, 6-8, 10-12, 14-16
 *  - buck[1234]
 */
#define MAX77686_OFF_PWRREQ		0x1
/* Low power mode controlled by PWRREQ: All LDOs */
#define MAX77686_LDO_LOWPOWER_PWRREQ	0x2
/* Forcing low power mode: buck[234] */
#define MAX77686_BUCK_LOWPOWER		0x2
#define MAX77686_NORMAL			0x3

#define MAX77686_OPMODE_SHIFT	6
#define MAX77686_OPMODE_BUCK234_SHIFT	4
#define MAX77686_OPMODE_MASK	0x3

#define MAX77686_VSEL_MASK	0x3F
#define MAX77686_DVS_VSEL_MASK	0xFF

#define MAX77686_RAMP_RATE_MASK	0xC0

#define MAX77686_REGULATORS	MAX77686_REG_MAX
#define MAX77686_LDOS		26

enum max77686_ramp_rate {
	RAMP_RATE_13P75MV,
	RAMP_RATE_27P5MV,
	RAMP_RATE_55MV,
	RAMP_RATE_NO_CTRL,	/* 100mV/us */
};

struct max77686_data {
	struct device *dev;
	DECLARE_BITMAP(gpio_enabled, MAX77686_REGULATORS);

	/* Array indexed by regulator id */
	unsigned int opmode[MAX77686_REGULATORS];
};

static unsigned int max77686_get_opmode_shift(int id)
{
	switch (id) {
	case MAX77686_BUCK1:
	case MAX77686_BUCK5 ... MAX77686_BUCK9:
		return 0;
	case MAX77686_BUCK2 ... MAX77686_BUCK4:
		return MAX77686_OPMODE_BUCK234_SHIFT;
	default:
		/* all LDOs */
		return MAX77686_OPMODE_SHIFT;
	}
}

/*
 * When regulator is configured for GPIO control then it
 * replaces "normal" mode. Any change from low power mode to normal
 * should actually change to GPIO control.
 * Map normal mode to proper value for such regulators.
 */
static unsigned int max77686_map_normal_mode(struct max77686_data *max77686,
					     int id)
{
	switch (id) {
	case MAX77686_BUCK8:
	case MAX77686_BUCK9:
	case MAX77686_LDO20 ... MAX77686_LDO22:
		if (test_bit(id, max77686->gpio_enabled))
			return MAX77686_GPIO_CONTROL;
	}

	return MAX77686_NORMAL;
}

/* Some BUCKs and LDOs supports Normal[ON/OFF] mode during suspend */
static int max77686_set_suspend_disable(struct regulator_dev *rdev)
{
	unsigned int val, shift;
	struct max77686_data *max77686 = rdev_get_drvdata(rdev);
	int ret, id = rdev_get_id(rdev);

	shift = max77686_get_opmode_shift(id);
	val = MAX77686_OFF_PWRREQ;

	ret = regmap_update_bits(rdev->regmap, rdev->desc->enable_reg,
				 rdev->desc->enable_mask, val << shift);
	if (ret)
		return ret;

	max77686->opmode[id] = val;
	return 0;
}

/* Some LDOs supports [LPM/Normal]ON mode during suspend state */
static int max77686_set_suspend_mode(struct regulator_dev *rdev,
				     unsigned int mode)
{
	struct max77686_data *max77686 = rdev_get_drvdata(rdev);
	unsigned int val;
	int ret, id = rdev_get_id(rdev);

	/* BUCK[5-9] doesn't support this feature */
	if (id >= MAX77686_BUCK5)
		return 0;

	switch (mode) {
	case REGULATOR_MODE_IDLE:			/* ON in LP Mode */
		val = MAX77686_LDO_LOWPOWER_PWRREQ;
		break;
	case REGULATOR_MODE_NORMAL:			/* ON in Normal Mode */
		val = max77686_map_normal_mode(max77686, id);
		break;
	default:
		pr_warn("%s: regulator_suspend_mode : 0x%x not supported\n",
			rdev->desc->name, mode);
		return -EINVAL;
	}

	ret = regmap_update_bits(rdev->regmap, rdev->desc->enable_reg,
				  rdev->desc->enable_mask,
				  val << MAX77686_OPMODE_SHIFT);
	if (ret)
		return ret;

	max77686->opmode[id] = val;
	return 0;
}

/* Some LDOs supports LPM-ON/OFF/Normal-ON mode during suspend state */
static int max77686_ldo_set_suspend_mode(struct regulator_dev *rdev,
				     unsigned int mode)
{
	unsigned int val;
	struct max77686_data *max77686 = rdev_get_drvdata(rdev);
	int ret, id = rdev_get_id(rdev);

	switch (mode) {
	case REGULATOR_MODE_STANDBY:			/* switch off */
		val = MAX77686_OFF_PWRREQ;
		break;
	case REGULATOR_MODE_IDLE:			/* ON in LP Mode */
		val = MAX77686_LDO_LOWPOWER_PWRREQ;
		break;
	case REGULATOR_MODE_NORMAL:			/* ON in Normal Mode */
		val = max77686_map_normal_mode(max77686, id);
		break;
	default:
		pr_warn("%s: regulator_suspend_mode : 0x%x not supported\n",
			rdev->desc->name, mode);
		return -EINVAL;
	}

	ret = regmap_update_bits(rdev->regmap, rdev->desc->enable_reg,
				 rdev->desc->enable_mask,
				 val << MAX77686_OPMODE_SHIFT);
	if (ret)
		return ret;

	max77686->opmode[id] = val;
	return 0;
}

static int max77686_enable(struct regulator_dev *rdev)
{
	struct max77686_data *max77686 = rdev_get_drvdata(rdev);
	unsigned int shift;
	int id = rdev_get_id(rdev);

	shift = max77686_get_opmode_shift(id);

	if (max77686->opmode[id] == MAX77686_OFF_PWRREQ)
		max77686->opmode[id] = max77686_map_normal_mode(max77686, id);

	return regmap_update_bits(rdev->regmap, rdev->desc->enable_reg,
				  rdev->desc->enable_mask,
				  max77686->opmode[id] << shift);
}

static int max77686_set_ramp_delay(struct regulator_dev *rdev, int ramp_delay)
{
	unsigned int ramp_value = RAMP_RATE_NO_CTRL;

	switch (ramp_delay) {
	case 1 ... 13750:
		ramp_value = RAMP_RATE_13P75MV;
		break;
	case 13751 ... 27500:
		ramp_value = RAMP_RATE_27P5MV;
		break;
	case 27501 ... 55000:
		ramp_value = RAMP_RATE_55MV;
		break;
	case 55001 ... 100000:
		break;
	default:
		pr_warn("%s: ramp_delay: %d not supported, setting 100000\n",
			rdev->desc->name, ramp_delay);
	}

	return regmap_update_bits(rdev->regmap, rdev->desc->enable_reg,
				  MAX77686_RAMP_RATE_MASK, ramp_value << 6);
}

static int max77686_of_parse_cb(struct device_node *np,
		const struct regulator_desc *desc,
		struct regulator_config *config)
{
	struct max77686_data *max77686 = config->driver_data;
	int ret;

	switch (desc->id) {
	case MAX77686_BUCK8:
	case MAX77686_BUCK9:
	case MAX77686_LDO20 ... MAX77686_LDO22:
		config->ena_gpiod = gpiod_get_from_of_node(np,
				"maxim,ena",
				0,
				GPIOD_OUT_HIGH | GPIOD_FLAGS_BIT_NONEXCLUSIVE,
				"max77686-regulator");
		if (IS_ERR(config->ena_gpiod))
			config->ena_gpiod = NULL;
		break;
	default:
		return 0;
	}

	if (config->ena_gpiod) {
		set_bit(desc->id, max77686->gpio_enabled);

		ret = regmap_update_bits(config->regmap, desc->enable_reg,
					 desc->enable_mask,
					 MAX77686_GPIO_CONTROL);
		if (ret) {
			gpiod_put(config->ena_gpiod);
			config->ena_gpiod = NULL;
		}
	}

	return 0;
}

static const struct regulator_ops max77686_ops = {
	.list_voltage		= regulator_list_voltage_linear,
	.map_voltage		= regulator_map_voltage_linear,
	.is_enabled		= regulator_is_enabled_regmap,
	.enable			= max77686_enable,
	.disable		= regulator_disable_regmap,
	.get_voltage_sel	= regulator_get_voltage_sel_regmap,
	.set_voltage_sel	= regulator_set_voltage_sel_regmap,
	.set_voltage_time_sel	= regulator_set_voltage_time_sel,
	.set_suspend_mode	= max77686_set_suspend_mode,
};

static const struct regulator_ops max77686_ldo_ops = {
	.list_voltage		= regulator_list_voltage_linear,
	.map_voltage		= regulator_map_voltage_linear,
	.is_enabled		= regulator_is_enabled_regmap,
	.enable			= max77686_enable,
	.disable		= regulator_disable_regmap,
	.get_voltage_sel	= regulator_get_voltage_sel_regmap,
	.set_voltage_sel	= regulator_set_voltage_sel_regmap,
	.set_voltage_time_sel	= regulator_set_voltage_time_sel,
	.set_suspend_mode	= max77686_ldo_set_suspend_mode,
	.set_suspend_disable	= max77686_set_suspend_disable,
};

static const struct regulator_ops max77686_buck1_ops = {
	.list_voltage		= regulator_list_voltage_linear,
	.map_voltage		= regulator_map_voltage_linear,
	.is_enabled		= regulator_is_enabled_regmap,
	.enable			= max77686_enable,
	.disable		= regulator_disable_regmap,
	.get_voltage_sel	= regulator_get_voltage_sel_regmap,
	.set_voltage_sel	= regulator_set_voltage_sel_regmap,
	.set_voltage_time_sel	= regulator_set_voltage_time_sel,
	.set_suspend_disable	= max77686_set_suspend_disable,
};

static const struct regulator_ops max77686_buck_dvs_ops = {
	.list_voltage		= regulator_list_voltage_linear,
	.map_voltage		= regulator_map_voltage_linear,
	.is_enabled		= regulator_is_enabled_regmap,
	.enable			= max77686_enable,
	.disable		= regulator_disable_regmap,
	.get_voltage_sel	= regulator_get_voltage_sel_regmap,
	.set_voltage_sel	= regulator_set_voltage_sel_regmap,
	.set_voltage_time_sel	= regulator_set_voltage_time_sel,
	.set_ramp_delay		= max77686_set_ramp_delay,
	.set_suspend_disable	= max77686_set_suspend_disable,
};

#define regulator_desc_ldo(num)		{				\
	.name		= "LDO"#num,					\
	.of_match	= of_match_ptr("LDO"#num),			\
	.regulators_node	= of_match_ptr("voltage-regulators"),	\
	.of_parse_cb	= max77686_of_parse_cb,				\
	.id		= MAX77686_LDO##num,				\
	.ops		= &max77686_ops,				\
	.type		= REGULATOR_VOLTAGE,				\
	.owner		= THIS_MODULE,					\
	.min_uV		= MAX77686_LDO_MINUV,				\
	.uV_step	= MAX77686_LDO_UVSTEP,				\
	.ramp_delay	= MAX77686_RAMP_DELAY,				\
	.n_voltages	= MAX77686_VSEL_MASK + 1,			\
	.vsel_reg	= MAX77686_REG_LDO1CTRL1 + num - 1,		\
	.vsel_mask	= MAX77686_VSEL_MASK,				\
	.enable_reg	= MAX77686_REG_LDO1CTRL1 + num - 1,		\
	.enable_mask	= MAX77686_OPMODE_MASK				\
			<< MAX77686_OPMODE_SHIFT,			\
}
#define regulator_desc_lpm_ldo(num)	{				\
	.name		= "LDO"#num,					\
	.of_match	= of_match_ptr("LDO"#num),			\
	.regulators_node	= of_match_ptr("voltage-regulators"),	\
	.id		= MAX77686_LDO##num,				\
	.ops		= &max77686_ldo_ops,				\
	.type		= REGULATOR_VOLTAGE,				\
	.owner		= THIS_MODULE,					\
	.min_uV		= MAX77686_LDO_MINUV,				\
	.uV_step	= MAX77686_LDO_UVSTEP,				\
	.ramp_delay	= MAX77686_RAMP_DELAY,				\
	.n_voltages	= MAX77686_VSEL_MASK + 1,			\
	.vsel_reg	= MAX77686_REG_LDO1CTRL1 + num - 1,		\
	.vsel_mask	= MAX77686_VSEL_MASK,				\
	.enable_reg	= MAX77686_REG_LDO1CTRL1 + num - 1,		\
	.enable_mask	= MAX77686_OPMODE_MASK				\
			<< MAX77686_OPMODE_SHIFT,			\
}
#define regulator_desc_ldo_low(num)		{			\
	.name		= "LDO"#num,					\
	.of_match	= of_match_ptr("LDO"#num),			\
	.regulators_node	= of_match_ptr("voltage-regulators"),	\
	.id		= MAX77686_LDO##num,				\
	.ops		= &max77686_ldo_ops,				\
	.type		= REGULATOR_VOLTAGE,				\
	.owner		= THIS_MODULE,					\
	.min_uV		= MAX77686_LDO_LOW_MINUV,			\
	.uV_step	= MAX77686_LDO_LOW_UVSTEP,			\
	.ramp_delay	= MAX77686_RAMP_DELAY,				\
	.n_voltages	= MAX77686_VSEL_MASK + 1,			\
	.vsel_reg	= MAX77686_REG_LDO1CTRL1 + num - 1,		\
	.vsel_mask	= MAX77686_VSEL_MASK,				\
	.enable_reg	= MAX77686_REG_LDO1CTRL1 + num - 1,		\
	.enable_mask	= MAX77686_OPMODE_MASK				\
			<< MAX77686_OPMODE_SHIFT,			\
}
#define regulator_desc_ldo1_low(num)		{			\
	.name		= "LDO"#num,					\
	.of_match	= of_match_ptr("LDO"#num),			\
	.regulators_node	= of_match_ptr("voltage-regulators"),	\
	.id		= MAX77686_LDO##num,				\
	.ops		= &max77686_ops,				\
	.type		= REGULATOR_VOLTAGE,				\
	.owner		= THIS_MODULE,					\
	.min_uV		= MAX77686_LDO_LOW_MINUV,			\
	.uV_step	= MAX77686_LDO_LOW_UVSTEP,			\
	.ramp_delay	= MAX77686_RAMP_DELAY,				\
	.n_voltages	= MAX77686_VSEL_MASK + 1,			\
	.vsel_reg	= MAX77686_REG_LDO1CTRL1 + num - 1,		\
	.vsel_mask	= MAX77686_VSEL_MASK,				\
	.enable_reg	= MAX77686_REG_LDO1CTRL1 + num - 1,		\
	.enable_mask	= MAX77686_OPMODE_MASK				\
			<< MAX77686_OPMODE_SHIFT,			\
}
#define regulator_desc_buck(num)		{			\
	.name		= "BUCK"#num,					\
	.of_match	= of_match_ptr("BUCK"#num),			\
	.regulators_node	= of_match_ptr("voltage-regulators"),	\
	.of_parse_cb	= max77686_of_parse_cb,				\
	.id		= MAX77686_BUCK##num,				\
	.ops		= &max77686_ops,				\
	.type		= REGULATOR_VOLTAGE,				\
	.owner		= THIS_MODULE,					\
	.min_uV		= MAX77686_BUCK_MINUV,				\
	.uV_step	= MAX77686_BUCK_UVSTEP,				\
	.ramp_delay	= MAX77686_RAMP_DELAY,				\
	.enable_time	= MAX77686_BUCK_ENABLE_TIME,			\
	.n_voltages	= MAX77686_VSEL_MASK + 1,			\
	.vsel_reg	= MAX77686_REG_BUCK5OUT + (num - 5) * 2,	\
	.vsel_mask	= MAX77686_VSEL_MASK,				\
	.enable_reg	= MAX77686_REG_BUCK5CTRL + (num - 5) * 2,	\
	.enable_mask	= MAX77686_OPMODE_MASK,				\
}
#define regulator_desc_buck1(num)		{			\
	.name		= "BUCK"#num,					\
	.of_match	= of_match_ptr("BUCK"#num),			\
	.regulators_node	= of_match_ptr("voltage-regulators"),	\
	.id		= MAX77686_BUCK##num,				\
	.ops		= &max77686_buck1_ops,				\
	.type		= REGULATOR_VOLTAGE,				\
	.owner		= THIS_MODULE,					\
	.min_uV		= MAX77686_BUCK_MINUV,				\
	.uV_step	= MAX77686_BUCK_UVSTEP,				\
	.ramp_delay	= MAX77686_RAMP_DELAY,				\
	.enable_time	= MAX77686_BUCK_ENABLE_TIME,			\
	.n_voltages	= MAX77686_VSEL_MASK + 1,			\
	.vsel_reg	= MAX77686_REG_BUCK1OUT,			\
	.vsel_mask	= MAX77686_VSEL_MASK,				\
	.enable_reg	= MAX77686_REG_BUCK1CTRL,			\
	.enable_mask	= MAX77686_OPMODE_MASK,				\
}
#define regulator_desc_buck_dvs(num)		{			\
	.name		= "BUCK"#num,					\
	.of_match	= of_match_ptr("BUCK"#num),			\
	.regulators_node	= of_match_ptr("voltage-regulators"),	\
	.id		= MAX77686_BUCK##num,				\
	.ops		= &max77686_buck_dvs_ops,			\
	.type		= REGULATOR_VOLTAGE,				\
	.owner		= THIS_MODULE,					\
	.min_uV		= MAX77686_DVS_MINUV,				\
	.uV_step	= MAX77686_DVS_UVSTEP,				\
	.ramp_delay	= MAX77686_DVS_RAMP_DELAY,			\
	.enable_time	= MAX77686_DVS_ENABLE_TIME,			\
	.n_voltages	= MAX77686_DVS_VSEL_MASK + 1,			\
	.vsel_reg	= MAX77686_REG_BUCK2DVS1 + (num - 2) * 10,	\
	.vsel_mask	= MAX77686_DVS_VSEL_MASK,			\
	.enable_reg	= MAX77686_REG_BUCK2CTRL1 + (num - 2) * 10,	\
	.enable_mask	= MAX77686_OPMODE_MASK				\
			<< MAX77686_OPMODE_BUCK234_SHIFT,		\
}

static const struct regulator_desc regulators[] = {
	regulator_desc_ldo1_low(1),
	regulator_desc_ldo_low(2),
	regulator_desc_ldo(3),
	regulator_desc_ldo(4),
	regulator_desc_ldo(5),
	regulator_desc_ldo_low(6),
	regulator_desc_ldo_low(7),
	regulator_desc_ldo_low(8),
	regulator_desc_ldo(9),
	regulator_desc_lpm_ldo(10),
	regulator_desc_lpm_ldo(11),
	regulator_desc_lpm_ldo(12),
	regulator_desc_ldo(13),
	regulator_desc_lpm_ldo(14),
	regulator_desc_ldo_low(15),
	regulator_desc_lpm_ldo(16),
	regulator_desc_ldo(17),
	regulator_desc_ldo(18),
	regulator_desc_ldo(19),
	regulator_desc_ldo(20),
	regulator_desc_ldo(21),
	regulator_desc_ldo(22),
	regulator_desc_ldo(23),
	regulator_desc_ldo(24),
	regulator_desc_ldo(25),
	regulator_desc_ldo(26),
	regulator_desc_buck1(1),
	regulator_desc_buck_dvs(2),
	regulator_desc_buck_dvs(3),
	regulator_desc_buck_dvs(4),
	regulator_desc_buck(5),
	regulator_desc_buck(6),
	regulator_desc_buck(7),
	regulator_desc_buck(8),
	regulator_desc_buck(9),
};

static int max77686_pmic_probe(struct platform_device *pdev)
{
	struct max77686_dev *iodev = dev_get_drvdata(pdev->dev.parent);
	struct max77686_data *max77686;
	int i;
	struct regulator_config config = { };

	dev_dbg(&pdev->dev, "%s\n", __func__);

	max77686 = devm_kzalloc(&pdev->dev, sizeof(struct max77686_data),
				GFP_KERNEL);
	if (!max77686)
		return -ENOMEM;

	max77686->dev = &pdev->dev;
	config.dev = iodev->dev;
	config.regmap = iodev->regmap;
	config.driver_data = max77686;
	platform_set_drvdata(pdev, max77686);

	for (i = 0; i < MAX77686_REGULATORS; i++) {
		struct regulator_dev *rdev;
		int id = regulators[i].id;

		max77686->opmode[id] = MAX77686_NORMAL;
		rdev = devm_regulator_register(&pdev->dev,
						&regulators[i], &config);
		if (IS_ERR(rdev)) {
			int ret = PTR_ERR(rdev);
			dev_err(&pdev->dev,
				"regulator init failed for %d: %d\n", i, ret);
			return ret;
		}
	}

	return 0;
}

static const struct platform_device_id max77686_pmic_id[] = {
	{"max77686-pmic", 0},
	{ },
};
MODULE_DEVICE_TABLE(platform, max77686_pmic_id);

static struct platform_driver max77686_pmic_driver = {
	.driver = {
		.name = "max77686-pmic",
	},
	.probe = max77686_pmic_probe,
	.id_table = max77686_pmic_id,
};

module_platform_driver(max77686_pmic_driver);

MODULE_DESCRIPTION("MAXIM 77686 Regulator Driver");
MODULE_AUTHOR("Chiwoong Byun <woong.byun@samsung.com>");
MODULE_LICENSE("GPL");
Commit	Line	Data
5e9384c7 KK	1	// SPDX-License-Identifier: GPL-2.0+
	2	//
	3	// max77686.c - Regulator driver for the Maxim 77686
	4	//
	5	// Copyright (C) 2012 Samsung Electronics
	6	// Chiwoong Byun <woong.byun@samsung.com>
	7	// Jonghwa Lee <jonghwa3.lee@samsung.com>
	8	//
	9	// This driver is based on max8997.c
133d4016 JL	10
	11	#include <linux/kernel.h>
	12	#include <linux/bug.h>
133d4016	13	#include <linux/err.h>
96392c3d	14	#include <linux/gpio/consumer.h>
133d4016 JL	15	#include <linux/slab.h>
	16	#include <linux/platform_device.h>
	17	#include <linux/regulator/driver.h>
	18	#include <linux/regulator/machine.h>
4706fcab	19	#include <linux/regulator/of_regulator.h>
133d4016 JL	20	#include <linux/mfd/max77686.h>
	21	#include <linux/mfd/max77686-private.h>
	22
	23	#define MAX77686_LDO_MINUV 800000
	24	#define MAX77686_LDO_UVSTEP 50000
	25	#define MAX77686_LDO_LOW_MINUV 800000
	26	#define MAX77686_LDO_LOW_UVSTEP 25000
	27	#define MAX77686_BUCK_MINUV 750000
	28	#define MAX77686_BUCK_UVSTEP 50000
a9597305 KK	29	#define MAX77686_BUCK_ENABLE_TIME 40 /* us */
a9597305 KK	30	#define MAX77686_DVS_ENABLE_TIME 22 /* us */
852abad2 YSB	31	#define MAX77686_RAMP_DELAY 100000 /* uV/us */
852abad2 YSB	32	#define MAX77686_DVS_RAMP_DELAY 27500 /* uV/us */
133d4016 JL	33	#define MAX77686_DVS_MINUV 600000
	34	#define MAX77686_DVS_UVSTEP 12500
	35
3307e902 KK	36	/*
	37	* Value for configuring buck[89] and LDO{20,21,22} as GPIO control.
	38	* It is the same as 'off' for other regulators.
	39	*/
	40	#define MAX77686_GPIO_CONTROL 0x0
7636f19c KK	41	/*
	42	* Values used for configuring LDOs and bucks.
	43	* Forcing low power mode: LDO1, 3-5, 9, 13, 17-26
	44	*/
	45	#define MAX77686_LDO_LOWPOWER 0x1
	46	/*
	47	* On/off controlled by PWRREQ:
	48	* - LDO2, 6-8, 10-12, 14-16
	49	* - buck[1234]
	50	*/
	51	#define MAX77686_OFF_PWRREQ 0x1
	52	/* Low power mode controlled by PWRREQ: All LDOs */
	53	#define MAX77686_LDO_LOWPOWER_PWRREQ 0x2
	54	/* Forcing low power mode: buck[234] */
	55	#define MAX77686_BUCK_LOWPOWER 0x2
	56	#define MAX77686_NORMAL 0x3
	57
133d4016 JL	58	#define MAX77686_OPMODE_SHIFT 6
	59	#define MAX77686_OPMODE_BUCK234_SHIFT 4
	60	#define MAX77686_OPMODE_MASK 0x3
	61
	62	#define MAX77686_VSEL_MASK 0x3F
	63	#define MAX77686_DVS_VSEL_MASK 0xFF
	64
	65	#define MAX77686_RAMP_RATE_MASK 0xC0
	66
	67	#define MAX77686_REGULATORS MAX77686_REG_MAX
	68	#define MAX77686_LDOS 26
	69
	70	enum max77686_ramp_rate {
	71	RAMP_RATE_13P75MV,
	72	RAMP_RATE_27P5MV,
	73	RAMP_RATE_55MV,
	74	RAMP_RATE_NO_CTRL, /* 100mV/us */
	75	};
	76
	77	struct max77686_data {
96392c3d	78	struct device *dev;
c53403a3	79	DECLARE_BITMAP(gpio_enabled, MAX77686_REGULATORS);
3307e902	80
eca29da9	81	/* Array indexed by regulator id */
6d2c896b	82	unsigned int opmode[MAX77686_REGULATORS];
133d4016 JL	83	};
133d4016 JL	84
68c5d186 KK	85	static unsigned int max77686_get_opmode_shift(int id)
	86	{
	87	switch (id) {
	88	case MAX77686_BUCK1:
	89	case MAX77686_BUCK5 ... MAX77686_BUCK9:
	90	return 0;
	91	case MAX77686_BUCK2 ... MAX77686_BUCK4:
	92	return MAX77686_OPMODE_BUCK234_SHIFT;
	93	default:
	94	/* all LDOs */
	95	return MAX77686_OPMODE_SHIFT;
	96	}
	97	}
	98
3307e902 KK	99	/*
	100	* When regulator is configured for GPIO control then it
	101	* replaces "normal" mode. Any change from low power mode to normal
	102	* should actually change to GPIO control.
	103	* Map normal mode to proper value for such regulators.
	104	*/
	105	static unsigned int max77686_map_normal_mode(struct max77686_data *max77686,
	106	int id)
	107	{
	108	switch (id) {
	109	case MAX77686_BUCK8:
	110	case MAX77686_BUCK9:
	111	case MAX77686_LDO20 ... MAX77686_LDO22:
c53403a3	112	if (test_bit(id, max77686->gpio_enabled))
3307e902 KK	113	return MAX77686_GPIO_CONTROL;
	114	}
	115
	116	return MAX77686_NORMAL;
	117	}
	118
78ce6128 KK	119	/* Some BUCKs and LDOs supports Normal[ON/OFF] mode during suspend */
78ce6128 KK	120	static int max77686_set_suspend_disable(struct regulator_dev *rdev)
15282ba9	121	{
68c5d186	122	unsigned int val, shift;
15282ba9	123	struct max77686_data *max77686 = rdev_get_drvdata(rdev);
3ecf198e	124	int ret, id = rdev_get_id(rdev);
15282ba9	125
68c5d186 KK	126	shift = max77686_get_opmode_shift(id);
68c5d186 KK	127	val = MAX77686_OFF_PWRREQ;
15282ba9	128
3ecf198e	129	ret = regmap_update_bits(rdev->regmap, rdev->desc->enable_reg,
68c5d186	130	rdev->desc->enable_mask, val << shift);
3ecf198e AL	131	if (ret)
	132	return ret;
	133
40e72149	134	max77686->opmode[id] = val;
3ecf198e	135	return 0;
15282ba9 YSB	136	}
	137
	138	/* Some LDOs supports [LPM/Normal]ON mode during suspend state */
	139	static int max77686_set_suspend_mode(struct regulator_dev *rdev,
	140	unsigned int mode)
	141	{
	142	struct max77686_data *max77686 = rdev_get_drvdata(rdev);
	143	unsigned int val;
3ecf198e	144	int ret, id = rdev_get_id(rdev);
15282ba9 YSB	145
15282ba9 YSB	146	/* BUCK[5-9] doesn't support this feature */
40e72149	147	if (id >= MAX77686_BUCK5)
15282ba9 YSB	148	return 0;
	149
	150	switch (mode) {
	151	case REGULATOR_MODE_IDLE: /* ON in LP Mode */
68c5d186	152	val = MAX77686_LDO_LOWPOWER_PWRREQ;
15282ba9 YSB	153	break;
15282ba9 YSB	154	case REGULATOR_MODE_NORMAL: /* ON in Normal Mode */
3307e902	155	val = max77686_map_normal_mode(max77686, id);
15282ba9 YSB	156	break;
	157	default:
	158	pr_warn("%s: regulator_suspend_mode : 0x%x not supported\n",
	159	rdev->desc->name, mode);
	160	return -EINVAL;
	161	}
	162
3ecf198e	163	ret = regmap_update_bits(rdev->regmap, rdev->desc->enable_reg,
68c5d186 KK	164	rdev->desc->enable_mask,
68c5d186 KK	165	val << MAX77686_OPMODE_SHIFT);
3ecf198e AL	166	if (ret)
	167	return ret;
	168
40e72149	169	max77686->opmode[id] = val;
3ecf198e	170	return 0;
15282ba9 YSB	171	}
	172
	173	/* Some LDOs supports LPM-ON/OFF/Normal-ON mode during suspend state */
	174	static int max77686_ldo_set_suspend_mode(struct regulator_dev *rdev,
	175	unsigned int mode)
	176	{
	177	unsigned int val;
	178	struct max77686_data *max77686 = rdev_get_drvdata(rdev);
3307e902	179	int ret, id = rdev_get_id(rdev);
15282ba9 YSB	180
	181	switch (mode) {
	182	case REGULATOR_MODE_STANDBY: /* switch off */
68c5d186	183	val = MAX77686_OFF_PWRREQ;
15282ba9 YSB	184	break;
15282ba9 YSB	185	case REGULATOR_MODE_IDLE: /* ON in LP Mode */
68c5d186	186	val = MAX77686_LDO_LOWPOWER_PWRREQ;
15282ba9 YSB	187	break;
15282ba9 YSB	188	case REGULATOR_MODE_NORMAL: /* ON in Normal Mode */
3307e902	189	val = max77686_map_normal_mode(max77686, id);
15282ba9 YSB	190	break;
	191	default:
	192	pr_warn("%s: regulator_suspend_mode : 0x%x not supported\n",
	193	rdev->desc->name, mode);
	194	return -EINVAL;
	195	}
	196
3ecf198e	197	ret = regmap_update_bits(rdev->regmap, rdev->desc->enable_reg,
68c5d186 KK	198	rdev->desc->enable_mask,
68c5d186 KK	199	val << MAX77686_OPMODE_SHIFT);
3ecf198e AL	200	if (ret)
	201	return ret;
	202
3307e902	203	max77686->opmode[id] = val;
3ecf198e	204	return 0;
15282ba9 YSB	205	}
15282ba9 YSB	206
38d34035	207	static int max77686_enable(struct regulator_dev *rdev)
6d2c896b YSB	208	{
6d2c896b YSB	209	struct max77686_data *max77686 = rdev_get_drvdata(rdev);
68c5d186 KK	210	unsigned int shift;
	211	int id = rdev_get_id(rdev);
	212
	213	shift = max77686_get_opmode_shift(id);
6d2c896b	214
78ce6128	215	if (max77686->opmode[id] == MAX77686_OFF_PWRREQ)
3307e902	216	max77686->opmode[id] = max77686_map_normal_mode(max77686, id);
78ce6128	217
6d2c896b YSB	218	return regmap_update_bits(rdev->regmap, rdev->desc->enable_reg,
6d2c896b YSB	219	rdev->desc->enable_mask,
68c5d186	220	max77686->opmode[id] << shift);
6d2c896b YSB	221	}
6d2c896b YSB	222
f503071b YSB	223	static int max77686_set_ramp_delay(struct regulator_dev *rdev, int ramp_delay)
	224	{
	225	unsigned int ramp_value = RAMP_RATE_NO_CTRL;
	226
	227	switch (ramp_delay) {
	228	case 1 ... 13750:
	229	ramp_value = RAMP_RATE_13P75MV;
	230	break;
	231	case 13751 ... 27500:
	232	ramp_value = RAMP_RATE_27P5MV;
	233	break;
	234	case 27501 ... 55000:
	235	ramp_value = RAMP_RATE_55MV;
	236	break;
	237	case 55001 ... 100000:
	238	break;
	239	default:
	240	pr_warn("%s: ramp_delay: %d not supported, setting 100000\n",
	241	rdev->desc->name, ramp_delay);
	242	}
	243
	244	return regmap_update_bits(rdev->regmap, rdev->desc->enable_reg,
	245	MAX77686_RAMP_RATE_MASK, ramp_value << 6);
	246	}
	247
3307e902 KK	248	static int max77686_of_parse_cb(struct device_node *np,
	249	const struct regulator_desc *desc,
	250	struct regulator_config *config)
	251	{
	252	struct max77686_data *max77686 = config->driver_data;
d03c63db	253	int ret;
3307e902 KK	254
	255	switch (desc->id) {
	256	case MAX77686_BUCK8:
	257	case MAX77686_BUCK9:
	258	case MAX77686_LDO20 ... MAX77686_LDO22:
d03c63db	259	config->ena_gpiod = gpiod_get_from_of_node(np,
96392c3d LW	260	"maxim,ena",
	261	0,
	262	GPIOD_OUT_HIGH \| GPIOD_FLAGS_BIT_NONEXCLUSIVE,
	263	"max77686-regulator");
	264	if (IS_ERR(config->ena_gpiod))
	265	config->ena_gpiod = NULL;
3307e902 KK	266	break;
	267	default:
	268	return 0;
	269	}
	270
96392c3d	271	if (config->ena_gpiod) {
c53403a3	272	set_bit(desc->id, max77686->gpio_enabled);
3307e902	273
d03c63db LW	274	ret = regmap_update_bits(config->regmap, desc->enable_reg,
	275	desc->enable_mask,
	276	MAX77686_GPIO_CONTROL);
	277	if (ret) {
	278	gpiod_put(config->ena_gpiod);
	279	config->ena_gpiod = NULL;
	280	}
3307e902 KK	281	}
	282
	283	return 0;
	284	}
	285
404826cb	286	static const struct regulator_ops max77686_ops = {
133d4016	287	.list_voltage = regulator_list_voltage_linear,
2e3f7f26	288	.map_voltage = regulator_map_voltage_linear,
133d4016	289	.is_enabled = regulator_is_enabled_regmap,
6d2c896b	290	.enable = max77686_enable,
133d4016 JL	291	.disable = regulator_disable_regmap,
	292	.get_voltage_sel = regulator_get_voltage_sel_regmap,
	293	.set_voltage_sel = regulator_set_voltage_sel_regmap,
852abad2	294	.set_voltage_time_sel = regulator_set_voltage_time_sel,
15282ba9 YSB	295	.set_suspend_mode = max77686_set_suspend_mode,
	296	};
	297
404826cb	298	static const struct regulator_ops max77686_ldo_ops = {
15282ba9 YSB	299	.list_voltage = regulator_list_voltage_linear,
	300	.map_voltage = regulator_map_voltage_linear,
	301	.is_enabled = regulator_is_enabled_regmap,
	302	.enable = max77686_enable,
133d4016 JL	303	.disable = regulator_disable_regmap,
	304	.get_voltage_sel = regulator_get_voltage_sel_regmap,
	305	.set_voltage_sel = regulator_set_voltage_sel_regmap,
852abad2	306	.set_voltage_time_sel = regulator_set_voltage_time_sel,
15282ba9	307	.set_suspend_mode = max77686_ldo_set_suspend_mode,
78ce6128	308	.set_suspend_disable = max77686_set_suspend_disable,
15282ba9 YSB	309	};
15282ba9 YSB	310
404826cb	311	static const struct regulator_ops max77686_buck1_ops = {
15282ba9 YSB	312	.list_voltage = regulator_list_voltage_linear,
	313	.map_voltage = regulator_map_voltage_linear,
	314	.is_enabled = regulator_is_enabled_regmap,
	315	.enable = max77686_enable,
	316	.disable = regulator_disable_regmap,
	317	.get_voltage_sel = regulator_get_voltage_sel_regmap,
	318	.set_voltage_sel = regulator_set_voltage_sel_regmap,
	319	.set_voltage_time_sel = regulator_set_voltage_time_sel,
78ce6128	320	.set_suspend_disable = max77686_set_suspend_disable,
133d4016 JL	321	};
133d4016 JL	322
404826cb	323	static const struct regulator_ops max77686_buck_dvs_ops = {
133d4016	324	.list_voltage = regulator_list_voltage_linear,
2e3f7f26	325	.map_voltage = regulator_map_voltage_linear,
133d4016	326	.is_enabled = regulator_is_enabled_regmap,
6d2c896b	327	.enable = max77686_enable,
133d4016 JL	328	.disable = regulator_disable_regmap,
	329	.get_voltage_sel = regulator_get_voltage_sel_regmap,
	330	.set_voltage_sel = regulator_set_voltage_sel_regmap,
852abad2	331	.set_voltage_time_sel = regulator_set_voltage_time_sel,
f503071b	332	.set_ramp_delay = max77686_set_ramp_delay,
78ce6128	333	.set_suspend_disable = max77686_set_suspend_disable,
133d4016 JL	334	};
	335
	336	#define regulator_desc_ldo(num) { \
	337	.name = "LDO"#num, \
04803952 KK	338	.of_match = of_match_ptr("LDO"#num), \
04803952 KK	339	.regulators_node = of_match_ptr("voltage-regulators"), \
3307e902	340	.of_parse_cb = max77686_of_parse_cb, \
133d4016 JL	341	.id = MAX77686_LDO##num, \
	342	.ops = &max77686_ops, \
	343	.type = REGULATOR_VOLTAGE, \
	344	.owner = THIS_MODULE, \
	345	.min_uV = MAX77686_LDO_MINUV, \
	346	.uV_step = MAX77686_LDO_UVSTEP, \
852abad2	347	.ramp_delay = MAX77686_RAMP_DELAY, \
133d4016 JL	348	.n_voltages = MAX77686_VSEL_MASK + 1, \
	349	.vsel_reg = MAX77686_REG_LDO1CTRL1 + num - 1, \
	350	.vsel_mask = MAX77686_VSEL_MASK, \
	351	.enable_reg = MAX77686_REG_LDO1CTRL1 + num - 1, \
	352	.enable_mask = MAX77686_OPMODE_MASK \
	353	<< MAX77686_OPMODE_SHIFT, \
	354	}
15282ba9 YSB	355	#define regulator_desc_lpm_ldo(num) { \
15282ba9 YSB	356	.name = "LDO"#num, \
04803952 KK	357	.of_match = of_match_ptr("LDO"#num), \
04803952 KK	358	.regulators_node = of_match_ptr("voltage-regulators"), \
15282ba9 YSB	359	.id = MAX77686_LDO##num, \
	360	.ops = &max77686_ldo_ops, \
	361	.type = REGULATOR_VOLTAGE, \
	362	.owner = THIS_MODULE, \
	363	.min_uV = MAX77686_LDO_MINUV, \
	364	.uV_step = MAX77686_LDO_UVSTEP, \
	365	.ramp_delay = MAX77686_RAMP_DELAY, \
	366	.n_voltages = MAX77686_VSEL_MASK + 1, \
	367	.vsel_reg = MAX77686_REG_LDO1CTRL1 + num - 1, \
	368	.vsel_mask = MAX77686_VSEL_MASK, \
	369	.enable_reg = MAX77686_REG_LDO1CTRL1 + num - 1, \
	370	.enable_mask = MAX77686_OPMODE_MASK \
	371	<< MAX77686_OPMODE_SHIFT, \
	372	}
133d4016	373	#define regulator_desc_ldo_low(num) { \
15282ba9	374	.name = "LDO"#num, \
04803952 KK	375	.of_match = of_match_ptr("LDO"#num), \
04803952 KK	376	.regulators_node = of_match_ptr("voltage-regulators"), \
15282ba9 YSB	377	.id = MAX77686_LDO##num, \
	378	.ops = &max77686_ldo_ops, \
	379	.type = REGULATOR_VOLTAGE, \
	380	.owner = THIS_MODULE, \
	381	.min_uV = MAX77686_LDO_LOW_MINUV, \
	382	.uV_step = MAX77686_LDO_LOW_UVSTEP, \
	383	.ramp_delay = MAX77686_RAMP_DELAY, \
	384	.n_voltages = MAX77686_VSEL_MASK + 1, \
	385	.vsel_reg = MAX77686_REG_LDO1CTRL1 + num - 1, \
	386	.vsel_mask = MAX77686_VSEL_MASK, \
	387	.enable_reg = MAX77686_REG_LDO1CTRL1 + num - 1, \
	388	.enable_mask = MAX77686_OPMODE_MASK \
	389	<< MAX77686_OPMODE_SHIFT, \
	390	}
	391	#define regulator_desc_ldo1_low(num) { \
133d4016	392	.name = "LDO"#num, \
04803952 KK	393	.of_match = of_match_ptr("LDO"#num), \
04803952 KK	394	.regulators_node = of_match_ptr("voltage-regulators"), \
133d4016 JL	395	.id = MAX77686_LDO##num, \
	396	.ops = &max77686_ops, \
	397	.type = REGULATOR_VOLTAGE, \
	398	.owner = THIS_MODULE, \
	399	.min_uV = MAX77686_LDO_LOW_MINUV, \
	400	.uV_step = MAX77686_LDO_LOW_UVSTEP, \
852abad2	401	.ramp_delay = MAX77686_RAMP_DELAY, \
133d4016 JL	402	.n_voltages = MAX77686_VSEL_MASK + 1, \
	403	.vsel_reg = MAX77686_REG_LDO1CTRL1 + num - 1, \
	404	.vsel_mask = MAX77686_VSEL_MASK, \
	405	.enable_reg = MAX77686_REG_LDO1CTRL1 + num - 1, \
	406	.enable_mask = MAX77686_OPMODE_MASK \
	407	<< MAX77686_OPMODE_SHIFT, \
	408	}
	409	#define regulator_desc_buck(num) { \
	410	.name = "BUCK"#num, \
04803952 KK	411	.of_match = of_match_ptr("BUCK"#num), \
04803952 KK	412	.regulators_node = of_match_ptr("voltage-regulators"), \
3307e902	413	.of_parse_cb = max77686_of_parse_cb, \
133d4016 JL	414	.id = MAX77686_BUCK##num, \
	415	.ops = &max77686_ops, \
	416	.type = REGULATOR_VOLTAGE, \
	417	.owner = THIS_MODULE, \
	418	.min_uV = MAX77686_BUCK_MINUV, \
	419	.uV_step = MAX77686_BUCK_UVSTEP, \
852abad2	420	.ramp_delay = MAX77686_RAMP_DELAY, \
a9597305	421	.enable_time = MAX77686_BUCK_ENABLE_TIME, \
133d4016 JL	422	.n_voltages = MAX77686_VSEL_MASK + 1, \
	423	.vsel_reg = MAX77686_REG_BUCK5OUT + (num - 5) * 2, \
	424	.vsel_mask = MAX77686_VSEL_MASK, \
	425	.enable_reg = MAX77686_REG_BUCK5CTRL + (num - 5) * 2, \
	426	.enable_mask = MAX77686_OPMODE_MASK, \
	427	}
	428	#define regulator_desc_buck1(num) { \
	429	.name = "BUCK"#num, \
04803952 KK	430	.of_match = of_match_ptr("BUCK"#num), \
04803952 KK	431	.regulators_node = of_match_ptr("voltage-regulators"), \
133d4016	432	.id = MAX77686_BUCK##num, \
15282ba9	433	.ops = &max77686_buck1_ops, \
133d4016 JL	434	.type = REGULATOR_VOLTAGE, \
	435	.owner = THIS_MODULE, \
	436	.min_uV = MAX77686_BUCK_MINUV, \
	437	.uV_step = MAX77686_BUCK_UVSTEP, \
852abad2	438	.ramp_delay = MAX77686_RAMP_DELAY, \
a9597305	439	.enable_time = MAX77686_BUCK_ENABLE_TIME, \
133d4016 JL	440	.n_voltages = MAX77686_VSEL_MASK + 1, \
	441	.vsel_reg = MAX77686_REG_BUCK1OUT, \
	442	.vsel_mask = MAX77686_VSEL_MASK, \
	443	.enable_reg = MAX77686_REG_BUCK1CTRL, \
	444	.enable_mask = MAX77686_OPMODE_MASK, \
	445	}
	446	#define regulator_desc_buck_dvs(num) { \
	447	.name = "BUCK"#num, \
04803952 KK	448	.of_match = of_match_ptr("BUCK"#num), \
04803952 KK	449	.regulators_node = of_match_ptr("voltage-regulators"), \
133d4016	450	.id = MAX77686_BUCK##num, \
74adfee5	451	.ops = &max77686_buck_dvs_ops, \
133d4016 JL	452	.type = REGULATOR_VOLTAGE, \
	453	.owner = THIS_MODULE, \
	454	.min_uV = MAX77686_DVS_MINUV, \
	455	.uV_step = MAX77686_DVS_UVSTEP, \
852abad2	456	.ramp_delay = MAX77686_DVS_RAMP_DELAY, \
a9597305	457	.enable_time = MAX77686_DVS_ENABLE_TIME, \
133d4016 JL	458	.n_voltages = MAX77686_DVS_VSEL_MASK + 1, \
	459	.vsel_reg = MAX77686_REG_BUCK2DVS1 + (num - 2) * 10, \
	460	.vsel_mask = MAX77686_DVS_VSEL_MASK, \
	461	.enable_reg = MAX77686_REG_BUCK2CTRL1 + (num - 2) * 10, \
	462	.enable_mask = MAX77686_OPMODE_MASK \
	463	<< MAX77686_OPMODE_BUCK234_SHIFT, \
	464	}
	465
73dbdf8f	466	static const struct regulator_desc regulators[] = {
15282ba9	467	regulator_desc_ldo1_low(1),
133d4016 JL	468	regulator_desc_ldo_low(2),
	469	regulator_desc_ldo(3),
	470	regulator_desc_ldo(4),
	471	regulator_desc_ldo(5),
	472	regulator_desc_ldo_low(6),
	473	regulator_desc_ldo_low(7),
	474	regulator_desc_ldo_low(8),
	475	regulator_desc_ldo(9),
15282ba9 YSB	476	regulator_desc_lpm_ldo(10),
	477	regulator_desc_lpm_ldo(11),
	478	regulator_desc_lpm_ldo(12),
133d4016	479	regulator_desc_ldo(13),
15282ba9	480	regulator_desc_lpm_ldo(14),
133d4016	481	regulator_desc_ldo_low(15),
15282ba9	482	regulator_desc_lpm_ldo(16),
133d4016 JL	483	regulator_desc_ldo(17),
	484	regulator_desc_ldo(18),
	485	regulator_desc_ldo(19),
	486	regulator_desc_ldo(20),
	487	regulator_desc_ldo(21),
	488	regulator_desc_ldo(22),
	489	regulator_desc_ldo(23),
	490	regulator_desc_ldo(24),
	491	regulator_desc_ldo(25),
	492	regulator_desc_ldo(26),
	493	regulator_desc_buck1(1),
	494	regulator_desc_buck_dvs(2),
	495	regulator_desc_buck_dvs(3),
	496	regulator_desc_buck_dvs(4),
	497	regulator_desc_buck(5),
	498	regulator_desc_buck(6),
	499	regulator_desc_buck(7),
	500	regulator_desc_buck(8),
	501	regulator_desc_buck(9),
	502	};
	503
a5023574	504	static int max77686_pmic_probe(struct platform_device *pdev)
133d4016 JL	505	{
133d4016 JL	506	struct max77686_dev *iodev = dev_get_drvdata(pdev->dev.parent);
133d4016	507	struct max77686_data *max77686;
04803952	508	int i;
c59d2a6b	509	struct regulator_config config = { };
133d4016 JL	510
	511	dev_dbg(&pdev->dev, "%s\n", __func__);
	512
	513	max77686 = devm_kzalloc(&pdev->dev, sizeof(struct max77686_data),
	514	GFP_KERNEL);
	515	if (!max77686)
	516	return -ENOMEM;
	517
96392c3d	518	max77686->dev = &pdev->dev;
04803952	519	config.dev = iodev->dev;
f503071b	520	config.regmap = iodev->regmap;
6d2c896b	521	config.driver_data = max77686;
133d4016 JL	522	platform_set_drvdata(pdev, max77686);
133d4016 JL	523
ab0d1cbe	524	for (i = 0; i < MAX77686_REGULATORS; i++) {
b0c13e80	525	struct regulator_dev *rdev;
eca29da9	526	int id = regulators[i].id;
b0c13e80	527
4524df83	528	max77686->opmode[id] = MAX77686_NORMAL;
b0c13e80	529	rdev = devm_regulator_register(&pdev->dev,
44815b4a	530	&regulators[i], &config);
b0c13e80	531	if (IS_ERR(rdev)) {
04803952	532	int ret = PTR_ERR(rdev);
f503071b	533	dev_err(&pdev->dev,
04803952 KK	534	"regulator init failed for %d: %d\n", i, ret);
04803952 KK	535	return ret;
133d4016	536	}
133d4016	537	}
ab0d1cbe	538
133d4016 JL	539	return 0;
	540	}
	541
	542	static const struct platform_device_id max77686_pmic_id[] = {
	543	{"max77686-pmic", 0},
	544	{ },
	545	};
	546	MODULE_DEVICE_TABLE(platform, max77686_pmic_id);
	547
	548	static struct platform_driver max77686_pmic_driver = {
	549	.driver = {
	550	.name = "max77686-pmic",
133d4016 JL	551	},
133d4016 JL	552	.probe = max77686_pmic_probe,
133d4016 JL	553	.id_table = max77686_pmic_id,
	554	};
	555
314a8203	556	module_platform_driver(max77686_pmic_driver);
133d4016 JL	557
	558	MODULE_DESCRIPTION("MAXIM 77686 Regulator Driver");
	559	MODULE_AUTHOR("Chiwoong Byun <woong.byun@samsung.com>");
	560	MODULE_LICENSE("GPL");