drivers/regulator/max77650-regulator.c - kernel/msm-5.4 - Gitiles

 // SPDX-License-Identifier: GPL-2.0
 //
 // Copyright (C) 2018 BayLibre SAS
 // Author: Bartosz Golaszewski <bgolaszewski@baylibre.com>
 //
 // Regulator driver for MAXIM 77650/77651 charger/power-supply.

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

 #define MAX77650_REGULATOR_EN_CTRL_MASK		GENMASK(3, 0)
 #define MAX77650_REGULATOR_EN_CTRL_BITS(_reg) \
 		((_reg) & MAX77650_REGULATOR_EN_CTRL_MASK)
 #define MAX77650_REGULATOR_ENABLED		GENMASK(2, 1)
 #define MAX77650_REGULATOR_DISABLED		BIT(2)

 #define MAX77650_REGULATOR_V_LDO_MASK		GENMASK(6, 0)
 #define MAX77650_REGULATOR_V_SBB_MASK		GENMASK(5, 0)

 #define MAX77650_REGULATOR_AD_MASK		BIT(3)
 #define MAX77650_REGULATOR_AD_DISABLED		0x00
 #define MAX77650_REGULATOR_AD_ENABLED		BIT(3)

 #define MAX77650_REGULATOR_CURR_LIM_MASK	GENMASK(7, 6)

 enum {
 	MAX77650_REGULATOR_ID_LDO = 0,
 	MAX77650_REGULATOR_ID_SBB0,
 	MAX77650_REGULATOR_ID_SBB1,
 	MAX77650_REGULATOR_ID_SBB2,
 	MAX77650_REGULATOR_NUM_REGULATORS,
 };

 struct max77650_regulator_desc {
 	struct regulator_desc desc;
 	unsigned int regA;
 	unsigned int regB;
 };

 static const unsigned int max77651_sbb1_regulator_volt_table[] = {
 	2400000, 3200000, 4000000, 4800000,
 	2450000, 3250000, 4050000, 4850000,
 	2500000, 3300000, 4100000, 4900000,
 	2550000, 3350000, 4150000, 4950000,
 	2600000, 3400000, 4200000, 5000000,
 	2650000, 3450000, 4250000, 5050000,
 	2700000, 3500000, 4300000, 5100000,
 	2750000, 3550000, 4350000, 5150000,
 	2800000, 3600000, 4400000, 5200000,
 	2850000, 3650000, 4450000, 5250000,
 	2900000, 3700000, 4500000,       0,
 	2950000, 3750000, 4550000,       0,
 	3000000, 3800000, 4600000,       0,
 	3050000, 3850000, 4650000,       0,
 	3100000, 3900000, 4700000,       0,
 	3150000, 3950000, 4750000,       0,
 };

 #define MAX77651_REGULATOR_SBB1_SEL_DEC(_val) \
 		(((_val & 0x3c) >> 2) | ((_val & 0x03) << 4))
 #define MAX77651_REGULATOR_SBB1_SEL_ENC(_val) \
 		(((_val & 0x30) >> 4) | ((_val & 0x0f) << 2))

 #define MAX77650_REGULATOR_SBB1_SEL_DECR(_val)				\
 	do {								\
 		_val = MAX77651_REGULATOR_SBB1_SEL_DEC(_val);		\
 		_val--;							\
 		_val = MAX77651_REGULATOR_SBB1_SEL_ENC(_val);		\
 	} while (0)

 #define MAX77650_REGULATOR_SBB1_SEL_INCR(_val)				\
 	do {								\
 		_val = MAX77651_REGULATOR_SBB1_SEL_DEC(_val);		\
 		_val++;							\
 		_val = MAX77651_REGULATOR_SBB1_SEL_ENC(_val);		\
 	} while (0)

 static const unsigned int max77650_current_limit_table[] = {
 	1000000, 866000, 707000, 500000,
 };

 static int max77650_regulator_is_enabled(struct regulator_dev *rdev)
 {
 	struct max77650_regulator_desc *rdesc;
 	struct regmap *map;
 	int val, rv, en;

 	rdesc = rdev_get_drvdata(rdev);
 	map = rdev_get_regmap(rdev);

 	rv = regmap_read(map, rdesc->regB, &val);
 	if (rv)
 		return rv;

 	en = MAX77650_REGULATOR_EN_CTRL_BITS(val);

 	return en != MAX77650_REGULATOR_DISABLED;
 }

 static int max77650_regulator_enable(struct regulator_dev *rdev)
 {
 	struct max77650_regulator_desc *rdesc;
 	struct regmap *map;

 	rdesc = rdev_get_drvdata(rdev);
 	map = rdev_get_regmap(rdev);

 	return regmap_update_bits(map, rdesc->regB,
 				  MAX77650_REGULATOR_EN_CTRL_MASK,
 				  MAX77650_REGULATOR_ENABLED);
 }

 static int max77650_regulator_disable(struct regulator_dev *rdev)
 {
 	struct max77650_regulator_desc *rdesc;
 	struct regmap *map;

 	rdesc = rdev_get_drvdata(rdev);
 	map = rdev_get_regmap(rdev);

 	return regmap_update_bits(map, rdesc->regB,
 				  MAX77650_REGULATOR_EN_CTRL_MASK,
 				  MAX77650_REGULATOR_DISABLED);
 }

 static int max77650_regulator_set_voltage_sel(struct regulator_dev *rdev,
 					      unsigned int sel)
 {
 	int rv = 0, curr, diff;
 	bool ascending;

 	/*
 	 * If the regulator is disabled, we can program the desired
 	 * voltage right away.
 	 */
 	if (!max77650_regulator_is_enabled(rdev))
 		return regulator_set_voltage_sel_regmap(rdev, sel);

 	/*
 	 * Otherwise we need to manually ramp the output voltage up/down
 	 * one step at a time.
 	 */

 	curr = regulator_get_voltage_sel_regmap(rdev);
 	if (curr < 0)
 		return curr;

 	diff = curr - sel;
 	if (diff == 0)
 		return 0; /* Already there. */
 	else if (diff > 0)
 		ascending = false;
 	else
 		ascending = true;

 	/*
 	 * Make sure we'll get to the right voltage and break the loop even if
 	 * the selector equals 0.
 	 */
 	for (ascending ? curr++ : curr--;; ascending ? curr++ : curr--) {
 		rv = regulator_set_voltage_sel_regmap(rdev, curr);
 		if (rv)
 			return rv;

 		if (curr == sel)
 			break;
 	}

 	return 0;
 }

 /*
  * Special case: non-linear voltage table for max77651 SBB1 - software
  * must ensure the voltage is ramped in 50mV increments.
  */
 static int max77651_regulator_sbb1_set_voltage_sel(struct regulator_dev *rdev,
 						   unsigned int sel)
 {
 	int rv = 0, curr, vcurr, vdest, vdiff;

 	/*
 	 * If the regulator is disabled, we can program the desired
 	 * voltage right away.
 	 */
 	if (!max77650_regulator_is_enabled(rdev))
 		return regulator_set_voltage_sel_regmap(rdev, sel);

 	curr = regulator_get_voltage_sel_regmap(rdev);
 	if (curr < 0)
 		return curr;

 	if (curr == sel)
 		return 0; /* Already there. */

 	vcurr = max77651_sbb1_regulator_volt_table[curr];
 	vdest = max77651_sbb1_regulator_volt_table[sel];
 	vdiff = vcurr - vdest;

 	for (;;) {
 		if (vdiff > 0)
 			MAX77650_REGULATOR_SBB1_SEL_DECR(curr);
 		else
 			MAX77650_REGULATOR_SBB1_SEL_INCR(curr);

 		rv = regulator_set_voltage_sel_regmap(rdev, curr);
 		if (rv)
 			return rv;

 		if (curr == sel)
 			break;
 	};

 	return 0;
 }

 static const struct regulator_ops max77650_regulator_LDO_ops = {
 	.is_enabled		= max77650_regulator_is_enabled,
 	.enable			= max77650_regulator_enable,
 	.disable		= max77650_regulator_disable,
 	.list_voltage		= regulator_list_voltage_linear,
 	.map_voltage		= regulator_map_voltage_linear,
 	.get_voltage_sel	= regulator_get_voltage_sel_regmap,
 	.set_voltage_sel	= max77650_regulator_set_voltage_sel,
 	.set_active_discharge	= regulator_set_active_discharge_regmap,
 };

 static const struct regulator_ops max77650_regulator_SBB_ops = {
 	.is_enabled		= max77650_regulator_is_enabled,
 	.enable			= max77650_regulator_enable,
 	.disable		= max77650_regulator_disable,
 	.list_voltage		= regulator_list_voltage_linear,
 	.map_voltage		= regulator_map_voltage_linear,
 	.get_voltage_sel	= regulator_get_voltage_sel_regmap,
 	.set_voltage_sel	= max77650_regulator_set_voltage_sel,
 	.get_current_limit	= regulator_get_current_limit_regmap,
 	.set_current_limit	= regulator_set_current_limit_regmap,
 	.set_active_discharge	= regulator_set_active_discharge_regmap,
 };

 /* Special case for max77651 SBB1 - non-linear voltage mapping. */
 static const struct regulator_ops max77651_SBB1_regulator_ops = {
 	.is_enabled		= max77650_regulator_is_enabled,
 	.enable			= max77650_regulator_enable,
 	.disable		= max77650_regulator_disable,
 	.list_voltage		= regulator_list_voltage_table,
 	.get_voltage_sel	= regulator_get_voltage_sel_regmap,
 	.set_voltage_sel	= max77651_regulator_sbb1_set_voltage_sel,
 	.get_current_limit	= regulator_get_current_limit_regmap,
 	.set_current_limit	= regulator_set_current_limit_regmap,
 	.set_active_discharge	= regulator_set_active_discharge_regmap,
 };

 static struct max77650_regulator_desc max77650_LDO_desc = {
 	.desc = {
 		.name			= "ldo",
 		.of_match		= of_match_ptr("ldo"),
 		.regulators_node	= of_match_ptr("regulators"),
 		.supply_name		= "in-ldo",
 		.id			= MAX77650_REGULATOR_ID_LDO,
 		.ops			= &max77650_regulator_LDO_ops,
 		.min_uV			= 1350000,
 		.uV_step		= 12500,
 		.n_voltages		= 128,
 		.vsel_mask		= MAX77650_REGULATOR_V_LDO_MASK,
 		.vsel_reg		= MAX77650_REG_CNFG_LDO_A,
 		.active_discharge_off	= MAX77650_REGULATOR_AD_DISABLED,
 		.active_discharge_on	= MAX77650_REGULATOR_AD_ENABLED,
 		.active_discharge_mask	= MAX77650_REGULATOR_AD_MASK,
 		.active_discharge_reg	= MAX77650_REG_CNFG_LDO_B,
 		.enable_time		= 100,
 		.type			= REGULATOR_VOLTAGE,
 		.owner			= THIS_MODULE,
 	},
 	.regA		= MAX77650_REG_CNFG_LDO_A,
 	.regB		= MAX77650_REG_CNFG_LDO_B,
 };

 static struct max77650_regulator_desc max77650_SBB0_desc = {
 	.desc = {
 		.name			= "sbb0",
 		.of_match		= of_match_ptr("sbb0"),
 		.regulators_node	= of_match_ptr("regulators"),
 		.supply_name		= "in-sbb0",
 		.id			= MAX77650_REGULATOR_ID_SBB0,
 		.ops			= &max77650_regulator_SBB_ops,
 		.min_uV			= 800000,
 		.uV_step		= 25000,
 		.n_voltages		= 64,
 		.vsel_mask		= MAX77650_REGULATOR_V_SBB_MASK,
 		.vsel_reg		= MAX77650_REG_CNFG_SBB0_A,
 		.active_discharge_off	= MAX77650_REGULATOR_AD_DISABLED,
 		.active_discharge_on	= MAX77650_REGULATOR_AD_ENABLED,
 		.active_discharge_mask	= MAX77650_REGULATOR_AD_MASK,
 		.active_discharge_reg	= MAX77650_REG_CNFG_SBB0_B,
 		.enable_time		= 100,
 		.type			= REGULATOR_VOLTAGE,
 		.owner			= THIS_MODULE,
 		.csel_reg		= MAX77650_REG_CNFG_SBB0_A,
 		.csel_mask		= MAX77650_REGULATOR_CURR_LIM_MASK,
 		.curr_table		= max77650_current_limit_table,
 		.n_current_limits = ARRAY_SIZE(max77650_current_limit_table),
 	},
 	.regA		= MAX77650_REG_CNFG_SBB0_A,
 	.regB		= MAX77650_REG_CNFG_SBB0_B,
 };

 static struct max77650_regulator_desc max77650_SBB1_desc = {
 	.desc = {
 		.name			= "sbb1",
 		.of_match		= of_match_ptr("sbb1"),
 		.regulators_node	= of_match_ptr("regulators"),
 		.supply_name		= "in-sbb1",
 		.id			= MAX77650_REGULATOR_ID_SBB1,
 		.ops			= &max77650_regulator_SBB_ops,
 		.min_uV			= 800000,
 		.uV_step		= 12500,
 		.n_voltages		= 64,
 		.vsel_mask		= MAX77650_REGULATOR_V_SBB_MASK,
 		.vsel_reg		= MAX77650_REG_CNFG_SBB1_A,
 		.active_discharge_off	= MAX77650_REGULATOR_AD_DISABLED,
 		.active_discharge_on	= MAX77650_REGULATOR_AD_ENABLED,
 		.active_discharge_mask	= MAX77650_REGULATOR_AD_MASK,
 		.active_discharge_reg	= MAX77650_REG_CNFG_SBB1_B,
 		.enable_time		= 100,
 		.type			= REGULATOR_VOLTAGE,
 		.owner			= THIS_MODULE,
 		.csel_reg		= MAX77650_REG_CNFG_SBB1_A,
 		.csel_mask		= MAX77650_REGULATOR_CURR_LIM_MASK,
 		.curr_table		= max77650_current_limit_table,
 		.n_current_limits = ARRAY_SIZE(max77650_current_limit_table),
 	},
 	.regA		= MAX77650_REG_CNFG_SBB1_A,
 	.regB		= MAX77650_REG_CNFG_SBB1_B,
 };

 static struct max77650_regulator_desc max77651_SBB1_desc = {
 	.desc = {
 		.name			= "sbb1",
 		.of_match		= of_match_ptr("sbb1"),
 		.regulators_node	= of_match_ptr("regulators"),
 		.supply_name		= "in-sbb1",
 		.id			= MAX77650_REGULATOR_ID_SBB1,
 		.ops			= &max77651_SBB1_regulator_ops,
 		.volt_table		= max77651_sbb1_regulator_volt_table,
 		.n_voltages = ARRAY_SIZE(max77651_sbb1_regulator_volt_table),
 		.vsel_mask		= MAX77650_REGULATOR_V_SBB_MASK,
 		.vsel_reg		= MAX77650_REG_CNFG_SBB1_A,
 		.active_discharge_off	= MAX77650_REGULATOR_AD_DISABLED,
 		.active_discharge_on	= MAX77650_REGULATOR_AD_ENABLED,
 		.active_discharge_mask	= MAX77650_REGULATOR_AD_MASK,
 		.active_discharge_reg	= MAX77650_REG_CNFG_SBB1_B,
 		.enable_time		= 100,
 		.type			= REGULATOR_VOLTAGE,
 		.owner			= THIS_MODULE,
 		.csel_reg		= MAX77650_REG_CNFG_SBB1_A,
 		.csel_mask		= MAX77650_REGULATOR_CURR_LIM_MASK,
 		.curr_table		= max77650_current_limit_table,
 		.n_current_limits = ARRAY_SIZE(max77650_current_limit_table),
 	},
 	.regA		= MAX77650_REG_CNFG_SBB1_A,
 	.regB		= MAX77650_REG_CNFG_SBB1_B,
 };

 static struct max77650_regulator_desc max77650_SBB2_desc = {
 	.desc = {
 		.name			= "sbb2",
 		.of_match		= of_match_ptr("sbb2"),
 		.regulators_node	= of_match_ptr("regulators"),
 		.supply_name		= "in-sbb0",
 		.id			= MAX77650_REGULATOR_ID_SBB2,
 		.ops			= &max77650_regulator_SBB_ops,
 		.min_uV			= 800000,
 		.uV_step		= 50000,
 		.n_voltages		= 64,
 		.vsel_mask		= MAX77650_REGULATOR_V_SBB_MASK,
 		.vsel_reg		= MAX77650_REG_CNFG_SBB2_A,
 		.active_discharge_off	= MAX77650_REGULATOR_AD_DISABLED,
 		.active_discharge_on	= MAX77650_REGULATOR_AD_ENABLED,
 		.active_discharge_mask	= MAX77650_REGULATOR_AD_MASK,
 		.active_discharge_reg	= MAX77650_REG_CNFG_SBB2_B,
 		.enable_time		= 100,
 		.type			= REGULATOR_VOLTAGE,
 		.owner			= THIS_MODULE,
 		.csel_reg		= MAX77650_REG_CNFG_SBB2_A,
 		.csel_mask		= MAX77650_REGULATOR_CURR_LIM_MASK,
 		.curr_table		= max77650_current_limit_table,
 		.n_current_limits = ARRAY_SIZE(max77650_current_limit_table),
 	},
 	.regA		= MAX77650_REG_CNFG_SBB2_A,
 	.regB		= MAX77650_REG_CNFG_SBB2_B,
 };

 static struct max77650_regulator_desc max77651_SBB2_desc = {
 	.desc = {
 		.name			= "sbb2",
 		.of_match		= of_match_ptr("sbb2"),
 		.regulators_node	= of_match_ptr("regulators"),
 		.supply_name		= "in-sbb0",
 		.id			= MAX77650_REGULATOR_ID_SBB2,
 		.ops			= &max77650_regulator_SBB_ops,
 		.min_uV			= 2400000,
 		.uV_step		= 50000,
 		.n_voltages		= 64,
 		.vsel_mask		= MAX77650_REGULATOR_V_SBB_MASK,
 		.vsel_reg		= MAX77650_REG_CNFG_SBB2_A,
 		.active_discharge_off	= MAX77650_REGULATOR_AD_DISABLED,
 		.active_discharge_on	= MAX77650_REGULATOR_AD_ENABLED,
 		.active_discharge_mask	= MAX77650_REGULATOR_AD_MASK,
 		.active_discharge_reg	= MAX77650_REG_CNFG_SBB2_B,
 		.enable_time		= 100,
 		.type			= REGULATOR_VOLTAGE,
 		.owner			= THIS_MODULE,
 		.csel_reg		= MAX77650_REG_CNFG_SBB2_A,
 		.csel_mask		= MAX77650_REGULATOR_CURR_LIM_MASK,
 		.curr_table		= max77650_current_limit_table,
 		.n_current_limits = ARRAY_SIZE(max77650_current_limit_table),
 	},
 	.regA		= MAX77650_REG_CNFG_SBB2_A,
 	.regB		= MAX77650_REG_CNFG_SBB2_B,
 };

 static int max77650_regulator_probe(struct platform_device *pdev)
 {
 	struct max77650_regulator_desc **rdescs;
 	struct max77650_regulator_desc *rdesc;
 	struct regulator_config config = { };
 	struct device *dev, *parent;
 	struct regulator_dev *rdev;
 	struct regmap *map;
 	unsigned int val;
 	int i, rv;

 	dev = &pdev->dev;
 	parent = dev->parent;

 	if (!dev->of_node)
 		dev->of_node = parent->of_node;

 	rdescs = devm_kcalloc(dev, MAX77650_REGULATOR_NUM_REGULATORS,
 			      sizeof(*rdescs), GFP_KERNEL);
 	if (!rdescs)
 		return -ENOMEM;

 	map = dev_get_regmap(parent, NULL);
 	if (!map)
 		return -ENODEV;

 	rv = regmap_read(map, MAX77650_REG_CID, &val);
 	if (rv)
 		return rv;

 	rdescs[MAX77650_REGULATOR_ID_LDO] = &max77650_LDO_desc;
 	rdescs[MAX77650_REGULATOR_ID_SBB0] = &max77650_SBB0_desc;

 	switch (MAX77650_CID_BITS(val)) {
 	case MAX77650_CID_77650A:
 	case MAX77650_CID_77650C:
 		rdescs[MAX77650_REGULATOR_ID_SBB1] = &max77650_SBB1_desc;
 		rdescs[MAX77650_REGULATOR_ID_SBB2] = &max77650_SBB2_desc;
 		break;
 	case MAX77650_CID_77651A:
 	case MAX77650_CID_77651B:
 		rdescs[MAX77650_REGULATOR_ID_SBB1] = &max77651_SBB1_desc;
 		rdescs[MAX77650_REGULATOR_ID_SBB2] = &max77651_SBB2_desc;
 		break;
 	default:
 		return -ENODEV;
 	}

 	config.dev = parent;

 	for (i = 0; i < MAX77650_REGULATOR_NUM_REGULATORS; i++) {
 		rdesc = rdescs[i];
 		config.driver_data = rdesc;

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

 	return 0;
 }

 static struct platform_driver max77650_regulator_driver = {
 	.driver = {
 		.name = "max77650-regulator",
 	},
 	.probe = max77650_regulator_probe,
 };
 module_platform_driver(max77650_regulator_driver);

 MODULE_DESCRIPTION("MAXIM 77650/77651 regulator driver");
 MODULE_AUTHOR("Bartosz Golaszewski <bgolaszewski@baylibre.com>");
 MODULE_LICENSE("GPL v2");
	// SPDX-License-Identifier: GPL-2.0
	//
	// Copyright (C) 2018 BayLibre SAS
	// Author: Bartosz Golaszewski <bgolaszewski@baylibre.com>
	//
	// Regulator driver for MAXIM 77650/77651 charger/power-supply.

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

	#define MAX77650_REGULATOR_EN_CTRL_MASK GENMASK(3, 0)
	#define MAX77650_REGULATOR_EN_CTRL_BITS(_reg) \
	((_reg) & MAX77650_REGULATOR_EN_CTRL_MASK)
	#define MAX77650_REGULATOR_ENABLED GENMASK(2, 1)
	#define MAX77650_REGULATOR_DISABLED BIT(2)

	#define MAX77650_REGULATOR_V_LDO_MASK GENMASK(6, 0)
	#define MAX77650_REGULATOR_V_SBB_MASK GENMASK(5, 0)

	#define MAX77650_REGULATOR_AD_MASK BIT(3)
	#define MAX77650_REGULATOR_AD_DISABLED 0x00
	#define MAX77650_REGULATOR_AD_ENABLED BIT(3)

	#define MAX77650_REGULATOR_CURR_LIM_MASK GENMASK(7, 6)

	enum {
	MAX77650_REGULATOR_ID_LDO = 0,
	MAX77650_REGULATOR_ID_SBB0,
	MAX77650_REGULATOR_ID_SBB1,
	MAX77650_REGULATOR_ID_SBB2,
	MAX77650_REGULATOR_NUM_REGULATORS,
	};

	struct max77650_regulator_desc {
	struct regulator_desc desc;
	unsigned int regA;
	unsigned int regB;
	};

	static const unsigned int max77651_sbb1_regulator_volt_table[] = {
	2400000, 3200000, 4000000, 4800000,
	2450000, 3250000, 4050000, 4850000,
	2500000, 3300000, 4100000, 4900000,
	2550000, 3350000, 4150000, 4950000,
	2600000, 3400000, 4200000, 5000000,
	2650000, 3450000, 4250000, 5050000,
	2700000, 3500000, 4300000, 5100000,
	2750000, 3550000, 4350000, 5150000,
	2800000, 3600000, 4400000, 5200000,
	2850000, 3650000, 4450000, 5250000,
	2900000, 3700000, 4500000, 0,
	2950000, 3750000, 4550000, 0,
	3000000, 3800000, 4600000, 0,
	3050000, 3850000, 4650000, 0,
	3100000, 3900000, 4700000, 0,
	3150000, 3950000, 4750000, 0,
	};

	#define MAX77651_REGULATOR_SBB1_SEL_DEC(_val) \
	(((_val & 0x3c) >> 2) \| ((_val & 0x03) << 4))
	#define MAX77651_REGULATOR_SBB1_SEL_ENC(_val) \
	(((_val & 0x30) >> 4) \| ((_val & 0x0f) << 2))

	#define MAX77650_REGULATOR_SBB1_SEL_DECR(_val) \
	do { \
	_val = MAX77651_REGULATOR_SBB1_SEL_DEC(_val); \
	_val--; \
	_val = MAX77651_REGULATOR_SBB1_SEL_ENC(_val); \
	} while (0)

	#define MAX77650_REGULATOR_SBB1_SEL_INCR(_val) \
	do { \
	_val = MAX77651_REGULATOR_SBB1_SEL_DEC(_val); \
	_val++; \
	_val = MAX77651_REGULATOR_SBB1_SEL_ENC(_val); \
	} while (0)

	static const unsigned int max77650_current_limit_table[] = {
	1000000, 866000, 707000, 500000,
	};

	static int max77650_regulator_is_enabled(struct regulator_dev *rdev)
	{
	struct max77650_regulator_desc *rdesc;
	struct regmap *map;
	int val, rv, en;

	rdesc = rdev_get_drvdata(rdev);
	map = rdev_get_regmap(rdev);

	rv = regmap_read(map, rdesc->regB, &val);
	if (rv)
	return rv;

	en = MAX77650_REGULATOR_EN_CTRL_BITS(val);

	return en != MAX77650_REGULATOR_DISABLED;
	}

	static int max77650_regulator_enable(struct regulator_dev *rdev)
	{
	struct max77650_regulator_desc *rdesc;
	struct regmap *map;

	rdesc = rdev_get_drvdata(rdev);
	map = rdev_get_regmap(rdev);

	return regmap_update_bits(map, rdesc->regB,
	MAX77650_REGULATOR_EN_CTRL_MASK,
	MAX77650_REGULATOR_ENABLED);
	}

	static int max77650_regulator_disable(struct regulator_dev *rdev)
	{
	struct max77650_regulator_desc *rdesc;
	struct regmap *map;

	rdesc = rdev_get_drvdata(rdev);
	map = rdev_get_regmap(rdev);

	return regmap_update_bits(map, rdesc->regB,
	MAX77650_REGULATOR_EN_CTRL_MASK,
	MAX77650_REGULATOR_DISABLED);
	}

	static int max77650_regulator_set_voltage_sel(struct regulator_dev *rdev,
	unsigned int sel)
	{
	int rv = 0, curr, diff;
	bool ascending;

	/*
	* If the regulator is disabled, we can program the desired
	* voltage right away.
	*/
	if (!max77650_regulator_is_enabled(rdev))
	return regulator_set_voltage_sel_regmap(rdev, sel);

	/*
	* Otherwise we need to manually ramp the output voltage up/down
	* one step at a time.
	*/

	curr = regulator_get_voltage_sel_regmap(rdev);
	if (curr < 0)
	return curr;

	diff = curr - sel;
	if (diff == 0)
	return 0; /* Already there. */
	else if (diff > 0)
	ascending = false;
	else
	ascending = true;

	/*
	* Make sure we'll get to the right voltage and break the loop even if
	* the selector equals 0.
	*/
	for (ascending ? curr++ : curr--;; ascending ? curr++ : curr--) {
	rv = regulator_set_voltage_sel_regmap(rdev, curr);
	if (rv)
	return rv;

	if (curr == sel)
	break;
	}

	return 0;
	}

	/*
	* Special case: non-linear voltage table for max77651 SBB1 - software
	* must ensure the voltage is ramped in 50mV increments.
	*/
	static int max77651_regulator_sbb1_set_voltage_sel(struct regulator_dev *rdev,
	unsigned int sel)
	{
	int rv = 0, curr, vcurr, vdest, vdiff;

	/*
	* If the regulator is disabled, we can program the desired
	* voltage right away.
	*/
	if (!max77650_regulator_is_enabled(rdev))
	return regulator_set_voltage_sel_regmap(rdev, sel);

	curr = regulator_get_voltage_sel_regmap(rdev);
	if (curr < 0)
	return curr;

	if (curr == sel)
	return 0; /* Already there. */

	vcurr = max77651_sbb1_regulator_volt_table[curr];
	vdest = max77651_sbb1_regulator_volt_table[sel];
	vdiff = vcurr - vdest;

	for (;;) {
	if (vdiff > 0)
	MAX77650_REGULATOR_SBB1_SEL_DECR(curr);
	else
	MAX77650_REGULATOR_SBB1_SEL_INCR(curr);

	rv = regulator_set_voltage_sel_regmap(rdev, curr);
	if (rv)
	return rv;

	if (curr == sel)
	break;
	};

	return 0;
	}

	static const struct regulator_ops max77650_regulator_LDO_ops = {
	.is_enabled = max77650_regulator_is_enabled,
	.enable = max77650_regulator_enable,
	.disable = max77650_regulator_disable,
	.list_voltage = regulator_list_voltage_linear,
	.map_voltage = regulator_map_voltage_linear,
	.get_voltage_sel = regulator_get_voltage_sel_regmap,
	.set_voltage_sel = max77650_regulator_set_voltage_sel,
	.set_active_discharge = regulator_set_active_discharge_regmap,
	};

	static const struct regulator_ops max77650_regulator_SBB_ops = {
	.is_enabled = max77650_regulator_is_enabled,
	.enable = max77650_regulator_enable,
	.disable = max77650_regulator_disable,
	.list_voltage = regulator_list_voltage_linear,
	.map_voltage = regulator_map_voltage_linear,
	.get_voltage_sel = regulator_get_voltage_sel_regmap,
	.set_voltage_sel = max77650_regulator_set_voltage_sel,
	.get_current_limit = regulator_get_current_limit_regmap,
	.set_current_limit = regulator_set_current_limit_regmap,
	.set_active_discharge = regulator_set_active_discharge_regmap,
	};

	/* Special case for max77651 SBB1 - non-linear voltage mapping. */
	static const struct regulator_ops max77651_SBB1_regulator_ops = {
	.is_enabled = max77650_regulator_is_enabled,
	.enable = max77650_regulator_enable,
	.disable = max77650_regulator_disable,
	.list_voltage = regulator_list_voltage_table,
	.get_voltage_sel = regulator_get_voltage_sel_regmap,
	.set_voltage_sel = max77651_regulator_sbb1_set_voltage_sel,
	.get_current_limit = regulator_get_current_limit_regmap,
	.set_current_limit = regulator_set_current_limit_regmap,
	.set_active_discharge = regulator_set_active_discharge_regmap,
	};

	static struct max77650_regulator_desc max77650_LDO_desc = {
	.desc = {
	.name = "ldo",
	.of_match = of_match_ptr("ldo"),
	.regulators_node = of_match_ptr("regulators"),
	.supply_name = "in-ldo",
	.id = MAX77650_REGULATOR_ID_LDO,
	.ops = &max77650_regulator_LDO_ops,
	.min_uV = 1350000,
	.uV_step = 12500,
	.n_voltages = 128,
	.vsel_mask = MAX77650_REGULATOR_V_LDO_MASK,
	.vsel_reg = MAX77650_REG_CNFG_LDO_A,
	.active_discharge_off = MAX77650_REGULATOR_AD_DISABLED,
	.active_discharge_on = MAX77650_REGULATOR_AD_ENABLED,
	.active_discharge_mask = MAX77650_REGULATOR_AD_MASK,
	.active_discharge_reg = MAX77650_REG_CNFG_LDO_B,
	.enable_time = 100,
	.type = REGULATOR_VOLTAGE,
	.owner = THIS_MODULE,
	},
	.regA = MAX77650_REG_CNFG_LDO_A,
	.regB = MAX77650_REG_CNFG_LDO_B,
	};

	static struct max77650_regulator_desc max77650_SBB0_desc = {
	.desc = {
	.name = "sbb0",
	.of_match = of_match_ptr("sbb0"),
	.regulators_node = of_match_ptr("regulators"),
	.supply_name = "in-sbb0",
	.id = MAX77650_REGULATOR_ID_SBB0,
	.ops = &max77650_regulator_SBB_ops,
	.min_uV = 800000,
	.uV_step = 25000,
	.n_voltages = 64,
	.vsel_mask = MAX77650_REGULATOR_V_SBB_MASK,
	.vsel_reg = MAX77650_REG_CNFG_SBB0_A,
	.active_discharge_off = MAX77650_REGULATOR_AD_DISABLED,
	.active_discharge_on = MAX77650_REGULATOR_AD_ENABLED,
	.active_discharge_mask = MAX77650_REGULATOR_AD_MASK,
	.active_discharge_reg = MAX77650_REG_CNFG_SBB0_B,
	.enable_time = 100,
	.type = REGULATOR_VOLTAGE,
	.owner = THIS_MODULE,
	.csel_reg = MAX77650_REG_CNFG_SBB0_A,
	.csel_mask = MAX77650_REGULATOR_CURR_LIM_MASK,
	.curr_table = max77650_current_limit_table,
	.n_current_limits = ARRAY_SIZE(max77650_current_limit_table),
	},
	.regA = MAX77650_REG_CNFG_SBB0_A,
	.regB = MAX77650_REG_CNFG_SBB0_B,
	};

	static struct max77650_regulator_desc max77650_SBB1_desc = {
	.desc = {
	.name = "sbb1",
	.of_match = of_match_ptr("sbb1"),
	.regulators_node = of_match_ptr("regulators"),
	.supply_name = "in-sbb1",
	.id = MAX77650_REGULATOR_ID_SBB1,
	.ops = &max77650_regulator_SBB_ops,
	.min_uV = 800000,
	.uV_step = 12500,
	.n_voltages = 64,
	.vsel_mask = MAX77650_REGULATOR_V_SBB_MASK,
	.vsel_reg = MAX77650_REG_CNFG_SBB1_A,
	.active_discharge_off = MAX77650_REGULATOR_AD_DISABLED,
	.active_discharge_on = MAX77650_REGULATOR_AD_ENABLED,
	.active_discharge_mask = MAX77650_REGULATOR_AD_MASK,
	.active_discharge_reg = MAX77650_REG_CNFG_SBB1_B,
	.enable_time = 100,
	.type = REGULATOR_VOLTAGE,
	.owner = THIS_MODULE,
	.csel_reg = MAX77650_REG_CNFG_SBB1_A,
	.csel_mask = MAX77650_REGULATOR_CURR_LIM_MASK,
	.curr_table = max77650_current_limit_table,
	.n_current_limits = ARRAY_SIZE(max77650_current_limit_table),
	},
	.regA = MAX77650_REG_CNFG_SBB1_A,
	.regB = MAX77650_REG_CNFG_SBB1_B,
	};

	static struct max77650_regulator_desc max77651_SBB1_desc = {
	.desc = {
	.name = "sbb1",
	.of_match = of_match_ptr("sbb1"),
	.regulators_node = of_match_ptr("regulators"),
	.supply_name = "in-sbb1",
	.id = MAX77650_REGULATOR_ID_SBB1,
	.ops = &max77651_SBB1_regulator_ops,
	.volt_table = max77651_sbb1_regulator_volt_table,
	.n_voltages = ARRAY_SIZE(max77651_sbb1_regulator_volt_table),
	.vsel_mask = MAX77650_REGULATOR_V_SBB_MASK,
	.vsel_reg = MAX77650_REG_CNFG_SBB1_A,
	.active_discharge_off = MAX77650_REGULATOR_AD_DISABLED,
	.active_discharge_on = MAX77650_REGULATOR_AD_ENABLED,
	.active_discharge_mask = MAX77650_REGULATOR_AD_MASK,
	.active_discharge_reg = MAX77650_REG_CNFG_SBB1_B,
	.enable_time = 100,
	.type = REGULATOR_VOLTAGE,
	.owner = THIS_MODULE,
	.csel_reg = MAX77650_REG_CNFG_SBB1_A,
	.csel_mask = MAX77650_REGULATOR_CURR_LIM_MASK,
	.curr_table = max77650_current_limit_table,
	.n_current_limits = ARRAY_SIZE(max77650_current_limit_table),
	},
	.regA = MAX77650_REG_CNFG_SBB1_A,
	.regB = MAX77650_REG_CNFG_SBB1_B,
	};

	static struct max77650_regulator_desc max77650_SBB2_desc = {
	.desc = {
	.name = "sbb2",
	.of_match = of_match_ptr("sbb2"),
	.regulators_node = of_match_ptr("regulators"),
	.supply_name = "in-sbb0",
	.id = MAX77650_REGULATOR_ID_SBB2,
	.ops = &max77650_regulator_SBB_ops,
	.min_uV = 800000,
	.uV_step = 50000,
	.n_voltages = 64,
	.vsel_mask = MAX77650_REGULATOR_V_SBB_MASK,
	.vsel_reg = MAX77650_REG_CNFG_SBB2_A,
	.active_discharge_off = MAX77650_REGULATOR_AD_DISABLED,
	.active_discharge_on = MAX77650_REGULATOR_AD_ENABLED,
	.active_discharge_mask = MAX77650_REGULATOR_AD_MASK,
	.active_discharge_reg = MAX77650_REG_CNFG_SBB2_B,
	.enable_time = 100,
	.type = REGULATOR_VOLTAGE,
	.owner = THIS_MODULE,
	.csel_reg = MAX77650_REG_CNFG_SBB2_A,
	.csel_mask = MAX77650_REGULATOR_CURR_LIM_MASK,
	.curr_table = max77650_current_limit_table,
	.n_current_limits = ARRAY_SIZE(max77650_current_limit_table),
	},
	.regA = MAX77650_REG_CNFG_SBB2_A,
	.regB = MAX77650_REG_CNFG_SBB2_B,
	};

	static struct max77650_regulator_desc max77651_SBB2_desc = {
	.desc = {
	.name = "sbb2",
	.of_match = of_match_ptr("sbb2"),
	.regulators_node = of_match_ptr("regulators"),
	.supply_name = "in-sbb0",
	.id = MAX77650_REGULATOR_ID_SBB2,
	.ops = &max77650_regulator_SBB_ops,
	.min_uV = 2400000,
	.uV_step = 50000,
	.n_voltages = 64,
	.vsel_mask = MAX77650_REGULATOR_V_SBB_MASK,
	.vsel_reg = MAX77650_REG_CNFG_SBB2_A,
	.active_discharge_off = MAX77650_REGULATOR_AD_DISABLED,
	.active_discharge_on = MAX77650_REGULATOR_AD_ENABLED,
	.active_discharge_mask = MAX77650_REGULATOR_AD_MASK,
	.active_discharge_reg = MAX77650_REG_CNFG_SBB2_B,
	.enable_time = 100,
	.type = REGULATOR_VOLTAGE,
	.owner = THIS_MODULE,
	.csel_reg = MAX77650_REG_CNFG_SBB2_A,
	.csel_mask = MAX77650_REGULATOR_CURR_LIM_MASK,
	.curr_table = max77650_current_limit_table,
	.n_current_limits = ARRAY_SIZE(max77650_current_limit_table),
	},
	.regA = MAX77650_REG_CNFG_SBB2_A,
	.regB = MAX77650_REG_CNFG_SBB2_B,
	};

	static int max77650_regulator_probe(struct platform_device *pdev)
	{
	struct max77650_regulator_desc **rdescs;
	struct max77650_regulator_desc *rdesc;
	struct regulator_config config = { };
	struct device dev, parent;
	struct regulator_dev *rdev;
	struct regmap *map;
	unsigned int val;
	int i, rv;

	dev = &pdev->dev;
	parent = dev->parent;

	if (!dev->of_node)
	dev->of_node = parent->of_node;

	rdescs = devm_kcalloc(dev, MAX77650_REGULATOR_NUM_REGULATORS,
	sizeof(*rdescs), GFP_KERNEL);
	if (!rdescs)
	return -ENOMEM;

	map = dev_get_regmap(parent, NULL);
	if (!map)
	return -ENODEV;

	rv = regmap_read(map, MAX77650_REG_CID, &val);
	if (rv)
	return rv;

	rdescs[MAX77650_REGULATOR_ID_LDO] = &max77650_LDO_desc;
	rdescs[MAX77650_REGULATOR_ID_SBB0] = &max77650_SBB0_desc;

	switch (MAX77650_CID_BITS(val)) {
	case MAX77650_CID_77650A:
	case MAX77650_CID_77650C:
	rdescs[MAX77650_REGULATOR_ID_SBB1] = &max77650_SBB1_desc;
	rdescs[MAX77650_REGULATOR_ID_SBB2] = &max77650_SBB2_desc;
	break;
	case MAX77650_CID_77651A:
	case MAX77650_CID_77651B:
	rdescs[MAX77650_REGULATOR_ID_SBB1] = &max77651_SBB1_desc;
	rdescs[MAX77650_REGULATOR_ID_SBB2] = &max77651_SBB2_desc;
	break;
	default:
	return -ENODEV;
	}

	config.dev = parent;

	for (i = 0; i < MAX77650_REGULATOR_NUM_REGULATORS; i++) {
	rdesc = rdescs[i];
	config.driver_data = rdesc;

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

	return 0;
	}

	static struct platform_driver max77650_regulator_driver = {
	.driver = {
	.name = "max77650-regulator",
	},
	.probe = max77650_regulator_probe,
	};
	module_platform_driver(max77650_regulator_driver);

	MODULE_DESCRIPTION("MAXIM 77650/77651 regulator driver");
	MODULE_AUTHOR("Bartosz Golaszewski <bgolaszewski@baylibre.com>");
	MODULE_LICENSE("GPL v2");