Commit 8f5bb9c1 authored by Mark Brown's avatar Mark Brown
Browse files

Merge remote-tracking branches 'regulator/topic/axp20x',... 

Merge remote-tracking branches 'regulator/topic/axp20x', 'regulator/topic/bd9571mwv', 'regulator/topic/da9061' and 'regulator/topic/hi6421' into regulator-next
parents fcaa3167 1dbe0ccb cb42b648 4b7f4958 a8ea49d7

drivers/regulator/Kconfig

+2 −2
Original line number Diff line number Diff line
@@ -214,11 +214,11 @@ config REGULATOR_DA9055 
	  will be called da9055-regulator.



config REGULATOR_DA9062

	tristate "Dialog Semiconductor DA9062 regulators"

	tristate "Dialog Semiconductor DA9061/62 regulators"

	depends on MFD_DA9062

	help

	  Say y here to support the BUCKs and LDOs regulators found on

	  DA9062 PMICs.

	  DA9061 and DA9062 PMICs.



	  This driver can also be built as a module. If so, the module

	  will be called da9062-regulator.

drivers/regulator/axp20x-regulator.c

+131 −22
Original line number Diff line number Diff line
@@ -244,6 +244,82 @@ static const struct regulator_desc axp22x_drivevbus_regulator = { 
	.ops		= &axp20x_ops_sw,

};



static const struct regulator_linear_range axp803_dcdc234_ranges[] = {

	REGULATOR_LINEAR_RANGE(500000, 0x0, 0x46, 10000),

	REGULATOR_LINEAR_RANGE(1220000, 0x47, 0x4b, 20000),

};



static const struct regulator_linear_range axp803_dcdc5_ranges[] = {

	REGULATOR_LINEAR_RANGE(800000, 0x0, 0x20, 10000),

	REGULATOR_LINEAR_RANGE(1140000, 0x21, 0x44, 20000),

};



static const struct regulator_linear_range axp803_dcdc6_ranges[] = {

	REGULATOR_LINEAR_RANGE(600000, 0x0, 0x32, 10000),

	REGULATOR_LINEAR_RANGE(1120000, 0x33, 0x47, 20000),

};



/* AXP806's CLDO2 and AXP809's DLDO1 shares the same range */

static const struct regulator_linear_range axp803_dldo2_ranges[] = {

	REGULATOR_LINEAR_RANGE(700000, 0x0, 0x1a, 100000),

	REGULATOR_LINEAR_RANGE(3400000, 0x1b, 0x1f, 200000),

};



static const struct regulator_desc axp803_regulators[] = {

	AXP_DESC(AXP803, DCDC1, "dcdc1", "vin1", 1600, 3400, 100,

		 AXP803_DCDC1_V_OUT, 0x1f, AXP22X_PWR_OUT_CTRL1, BIT(0)),

	AXP_DESC_RANGES(AXP803, DCDC2, "dcdc2", "vin2", axp803_dcdc234_ranges,

			76, AXP803_DCDC2_V_OUT, 0x7f, AXP22X_PWR_OUT_CTRL1,

			BIT(1)),

	AXP_DESC_RANGES(AXP803, DCDC3, "dcdc3", "vin3", axp803_dcdc234_ranges,

			76, AXP803_DCDC3_V_OUT, 0x7f, AXP22X_PWR_OUT_CTRL1,

			BIT(2)),

	AXP_DESC_RANGES(AXP803, DCDC4, "dcdc4", "vin4", axp803_dcdc234_ranges,

			76, AXP803_DCDC4_V_OUT, 0x7f, AXP22X_PWR_OUT_CTRL1,

			BIT(3)),

	AXP_DESC_RANGES(AXP803, DCDC5, "dcdc5", "vin5", axp803_dcdc5_ranges,

			68, AXP803_DCDC5_V_OUT, 0x7f, AXP22X_PWR_OUT_CTRL1,

			BIT(4)),

	AXP_DESC_RANGES(AXP803, DCDC6, "dcdc6", "vin6", axp803_dcdc6_ranges,

			72, AXP803_DCDC6_V_OUT, 0x7f, AXP22X_PWR_OUT_CTRL1,

			BIT(5)),

	/* secondary switchable output of DCDC1 */

	AXP_DESC_SW(AXP803, DC1SW, "dc1sw", NULL, AXP22X_PWR_OUT_CTRL2,

		    BIT(7)),

	AXP_DESC(AXP803, ALDO1, "aldo1", "aldoin", 700, 3300, 100,

		 AXP22X_ALDO1_V_OUT, 0x1f, AXP22X_PWR_OUT_CTRL3, BIT(5)),

	AXP_DESC(AXP803, ALDO2, "aldo2", "aldoin", 700, 3300, 100,

		 AXP22X_ALDO2_V_OUT, 0x1f, AXP22X_PWR_OUT_CTRL3, BIT(6)),

	AXP_DESC(AXP803, ALDO3, "aldo3", "aldoin", 700, 3300, 100,

		 AXP22X_ALDO3_V_OUT, 0x1f, AXP22X_PWR_OUT_CTRL3, BIT(7)),

	AXP_DESC(AXP803, DLDO1, "dldo1", "dldoin", 700, 3300, 100,

		 AXP22X_DLDO1_V_OUT, 0x1f, AXP22X_PWR_OUT_CTRL2, BIT(3)),

	AXP_DESC_RANGES(AXP803, DLDO2, "dldo2", "dldoin", axp803_dldo2_ranges,

			32, AXP22X_DLDO2_V_OUT, 0x1f, AXP22X_PWR_OUT_CTRL2,

			BIT(4)),

	AXP_DESC(AXP803, DLDO3, "dldo3", "dldoin", 700, 3300, 100,

		 AXP22X_DLDO3_V_OUT, 0x1f, AXP22X_PWR_OUT_CTRL2, BIT(5)),

	AXP_DESC(AXP803, DLDO4, "dldo4", "dldoin", 700, 3300, 100,

		 AXP22X_DLDO4_V_OUT, 0x1f, AXP22X_PWR_OUT_CTRL2, BIT(6)),

	AXP_DESC(AXP803, ELDO1, "eldo1", "eldoin", 700, 1900, 50,

		 AXP22X_ELDO1_V_OUT, 0x1f, AXP22X_PWR_OUT_CTRL2, BIT(0)),

	AXP_DESC(AXP803, ELDO2, "eldo2", "eldoin", 700, 1900, 50,

		 AXP22X_ELDO2_V_OUT, 0x1f, AXP22X_PWR_OUT_CTRL2, BIT(1)),

	AXP_DESC(AXP803, ELDO3, "eldo3", "eldoin", 700, 1900, 50,

		 AXP22X_ELDO3_V_OUT, 0x1f, AXP22X_PWR_OUT_CTRL2, BIT(2)),

	AXP_DESC(AXP803, FLDO1, "fldo1", "fldoin", 700, 1450, 50,

		 AXP803_FLDO1_V_OUT, 0x0f, AXP22X_PWR_OUT_CTRL3, BIT(2)),

	AXP_DESC(AXP803, FLDO2, "fldo2", "fldoin", 700, 1450, 50,

		 AXP803_FLDO2_V_OUT, 0x0f, AXP22X_PWR_OUT_CTRL3, BIT(3)),

	AXP_DESC_IO(AXP803, LDO_IO0, "ldo-io0", "ips", 700, 3300, 100,

		    AXP22X_LDO_IO0_V_OUT, 0x1f, AXP20X_GPIO0_CTRL, 0x07,

		    AXP22X_IO_ENABLED, AXP22X_IO_DISABLED),

	AXP_DESC_IO(AXP803, LDO_IO1, "ldo-io1", "ips", 700, 3300, 100,

		    AXP22X_LDO_IO1_V_OUT, 0x1f, AXP20X_GPIO1_CTRL, 0x07,

		    AXP22X_IO_ENABLED, AXP22X_IO_DISABLED),

	AXP_DESC_FIXED(AXP803, RTC_LDO, "rtc-ldo", "ips", 3000),

};



static const struct regulator_linear_range axp806_dcdca_ranges[] = {

	REGULATOR_LINEAR_RANGE(600000, 0x0, 0x32, 10000),

	REGULATOR_LINEAR_RANGE(1120000, 0x33, 0x47, 20000),
@@ -254,11 +330,6 @@ static const struct regulator_linear_range axp806_dcdcd_ranges[] = { 
	REGULATOR_LINEAR_RANGE(1600000, 0x2e, 0x3f, 100000),

};



static const struct regulator_linear_range axp806_cldo2_ranges[] = {

	REGULATOR_LINEAR_RANGE(700000, 0x0, 0x1a, 100000),

	REGULATOR_LINEAR_RANGE(3400000, 0x1b, 0x1f, 200000),

};



static const struct regulator_desc axp806_regulators[] = {

	AXP_DESC_RANGES(AXP806, DCDCA, "dcdca", "vina", axp806_dcdca_ranges,

			72, AXP806_DCDCA_V_CTRL, 0x7f, AXP806_PWR_OUT_CTRL1,
@@ -289,7 +360,7 @@ static const struct regulator_desc axp806_regulators[] = { 
		 AXP806_BLDO4_V_CTRL, 0x0f, AXP806_PWR_OUT_CTRL2, BIT(3)),

	AXP_DESC(AXP806, CLDO1, "cldo1", "cldoin", 700, 3300, 100,

		 AXP806_CLDO1_V_CTRL, 0x1f, AXP806_PWR_OUT_CTRL2, BIT(4)),

	AXP_DESC_RANGES(AXP806, CLDO2, "cldo2", "cldoin", axp806_cldo2_ranges,

	AXP_DESC_RANGES(AXP806, CLDO2, "cldo2", "cldoin", axp803_dldo2_ranges,

			32, AXP806_CLDO2_V_CTRL, 0x1f, AXP806_PWR_OUT_CTRL2,

			BIT(5)),

	AXP_DESC(AXP806, CLDO3, "cldo3", "cldoin", 700, 3300, 100,
@@ -326,7 +397,7 @@ static const struct regulator_desc axp809_regulators[] = { 
		 AXP22X_ALDO2_V_OUT, 0x1f, AXP22X_PWR_OUT_CTRL1, BIT(7)),

	AXP_DESC(AXP809, ALDO3, "aldo3", "aldoin", 700, 3300, 100,

		 AXP22X_ALDO3_V_OUT, 0x1f, AXP22X_PWR_OUT_CTRL2, BIT(5)),

	AXP_DESC_RANGES(AXP809, DLDO1, "dldo1", "dldoin", axp806_cldo2_ranges,

	AXP_DESC_RANGES(AXP809, DLDO1, "dldo1", "dldoin", axp803_dldo2_ranges,

			32, AXP22X_DLDO1_V_OUT, 0x1f, AXP22X_PWR_OUT_CTRL2,

			BIT(3)),

	AXP_DESC(AXP809, DLDO2, "dldo2", "dldoin", 700, 3300, 100,
@@ -369,13 +440,20 @@ static int axp20x_set_dcdc_freq(struct platform_device *pdev, u32 dcdcfreq) 
		def = 1500;

		step = 75;

		break;

	case AXP806_ID:

	case AXP803_ID:

		/*

		 * AXP806 DCDC work frequency setting has the same range and

		 * AXP803 DCDC work frequency setting has the same range and

		 * step as AXP22X, but at a different register.

		 * Fall through to the check below.

		 * (See include/linux/mfd/axp20x.h)

		 */

		reg = AXP803_DCDC_FREQ_CTRL;

	case AXP806_ID:

		/*

		 * AXP806 also have DCDC work frequency setting register at a

		 * different position.

		 */

		if (axp20x->variant == AXP806_ID)

			reg = AXP806_DCDC_FREQ_CTRL;

	case AXP221_ID:

	case AXP223_ID:
@@ -475,6 +553,14 @@ static int axp20x_set_dcdc_workmode(struct regulator_dev *rdev, int id, u32 work 
		workmode <<= id - AXP22X_DCDC1;

		break;



	case AXP803_ID:

		if (id < AXP803_DCDC1 || id > AXP803_DCDC6)

			return -EINVAL;



		mask = AXP22X_WORKMODE_DCDCX_MASK(id - AXP803_DCDC1);

		workmode <<= id - AXP803_DCDC1;

		break;



	default:

		/* should not happen */

		WARN_ON(1);
@@ -492,10 +578,23 @@ static bool axp20x_is_polyphase_slave(struct axp20x_dev *axp20x, int id) 
{

	u32 reg = 0;



	/* Only AXP806 has poly-phase outputs */

	if (axp20x->variant != AXP806_ID)

		return false;

	/*

	 * Currently in our supported AXP variants, only AXP803 and AXP806

	 * have polyphase regulators.

	 */

	switch (axp20x->variant) {

	case AXP803_ID:

		regmap_read(axp20x->regmap, AXP803_POLYPHASE_CTRL, &reg);



		switch (id) {

		case AXP803_DCDC3:

			return !!(reg & BIT(6));

		case AXP803_DCDC6:

			return !!(reg & BIT(7));

		}

		break;



	case AXP806_ID:

		regmap_read(axp20x->regmap, AXP806_DCDC_MODE_CTRL2, &reg);



		switch (id) {
@@ -507,6 +606,11 @@ static bool axp20x_is_polyphase_slave(struct axp20x_dev *axp20x, int id) 
		case AXP806_DCDCE:

			return !!(reg & BIT(5));

		}

		break;



	default:

		return false;

	}



	return false;

}
@@ -540,6 +644,10 @@ static int axp20x_regulator_probe(struct platform_device *pdev) 
		drivevbus = of_property_read_bool(pdev->dev.parent->of_node,

						  "x-powers,drive-vbus-en");

		break;

	case AXP803_ID:

		regulators = axp803_regulators;

		nregulators = AXP803_REG_ID_MAX;

		break;

	case AXP806_ID:

		regulators = axp806_regulators;

		nregulators = AXP806_REG_ID_MAX;
@@ -579,6 +687,7 @@ static int axp20x_regulator_probe(struct platform_device *pdev) 
		 * name.

		 */

		if ((regulators == axp22x_regulators && i == AXP22X_DC1SW) ||

		    (regulators == axp803_regulators && i == AXP803_DC1SW) ||

		    (regulators == axp809_regulators && i == AXP809_DC1SW)) {

			new_desc = devm_kzalloc(&pdev->dev, sizeof(*desc),

						GFP_KERNEL);

drivers/regulator/bd9571mwv-regulator.c

+6 −6
Original line number Diff line number Diff line
@@ -43,7 +43,7 @@ enum bd9571mwv_regulators { VD09, VD18, VD25, VD33, DVFS }; 
		.linear_min_sel		= _lmin,		\

	}



int bd9571mwv_avs_get_moni_state(struct regulator_dev *rdev)

static int bd9571mwv_avs_get_moni_state(struct regulator_dev *rdev)

{

	unsigned int val;

	int ret;
@@ -55,7 +55,7 @@ int bd9571mwv_avs_get_moni_state(struct regulator_dev *rdev) 
	return val & BD9571MWV_AVS_SET_MONI_MASK;

}



int bd9571mwv_avs_set_voltage_sel_regmap(struct regulator_dev *rdev,

static int bd9571mwv_avs_set_voltage_sel_regmap(struct regulator_dev *rdev,

						unsigned int sel)

{

	int ret;
@@ -68,7 +68,7 @@ int bd9571mwv_avs_set_voltage_sel_regmap(struct regulator_dev *rdev, 
				 rdev->desc->vsel_mask, sel);

}



int bd9571mwv_avs_get_voltage_sel_regmap(struct regulator_dev *rdev)

static int bd9571mwv_avs_get_voltage_sel_regmap(struct regulator_dev *rdev)

{

	unsigned int val;

	int ret;
@@ -87,7 +87,7 @@ int bd9571mwv_avs_get_voltage_sel_regmap(struct regulator_dev *rdev) 
	return val;

}



int bd9571mwv_reg_set_voltage_sel_regmap(struct regulator_dev *rdev,

static int bd9571mwv_reg_set_voltage_sel_regmap(struct regulator_dev *rdev,

						unsigned int sel)

{

	return regmap_write_bits(rdev->regmap, BD9571MWV_DVFS_SETVID,

drivers/regulator/da9062-regulator.c

+291 −12
Original line number Diff line number Diff line 
/*

 * da9062-regulator.c - REGULATOR device driver for DA9062

 * Copyright (C) 2015  Dialog Semiconductor Ltd.

 * Regulator device driver for DA9061 and DA9062.

 * Copyright (C) 2015-2017  Dialog Semiconductor

 *

 * This program is free software; you can redistribute it and/or

 * modify it under the terms of the GNU General Public License
@@ -27,6 +27,17 @@ 
#include <linux/mfd/da9062/registers.h>



/* Regulator IDs */

enum {

	DA9061_ID_BUCK1,

	DA9061_ID_BUCK2,

	DA9061_ID_BUCK3,

	DA9061_ID_LDO1,

	DA9061_ID_LDO2,

	DA9061_ID_LDO3,

	DA9061_ID_LDO4,

	DA9061_MAX_REGULATORS,

};



enum {

	DA9062_ID_BUCK1,

	DA9062_ID_BUCK2,
@@ -88,15 +99,21 @@ enum { 


/* Regulator operations */



/* Current limits array (in uA) BUCK1 and BUCK3.

   Entry indexes corresponds to register values. */

/* Current limits array (in uA)

 * - DA9061_ID_[BUCK1|BUCK3]

 * - DA9062_ID_[BUCK1|BUCK2|BUCK4]

 * Entry indexes corresponds to register values.

 */

static const int da9062_buck_a_limits[] = {

	 500000,  600000,  700000,  800000,  900000, 1000000, 1100000, 1200000,

	1300000, 1400000, 1500000, 1600000, 1700000, 1800000, 1900000, 2000000

};



/* Current limits array (in uA) for BUCK2.

   Entry indexes corresponds to register values. */

/* Current limits array (in uA)

 * - DA9061_ID_BUCK2

 * - DA9062_ID_BUCK3

 * Entry indexes corresponds to register values.

 */

static const int da9062_buck_b_limits[] = {

	1500000, 1600000, 1700000, 1800000, 1900000, 2000000, 2100000, 2200000,

	2300000, 2400000, 2500000, 2600000, 2700000, 2800000, 2900000, 3000000
@@ -405,8 +422,254 @@ static const struct regulator_ops da9062_ldo_ops = { 
	.set_suspend_mode	= da9062_ldo_set_suspend_mode,

};



/* Regulator information */

static const struct da9062_regulator_info local_regulator_info[] = {

/* DA9061 Regulator information */

static const struct da9062_regulator_info local_da9061_regulator_info[] = {

	{

		.desc.id = DA9061_ID_BUCK1,

		.desc.name = "DA9061 BUCK1",

		.desc.of_match = of_match_ptr("buck1"),

		.desc.regulators_node = of_match_ptr("regulators"),

		.desc.ops = &da9062_buck_ops,

		.desc.min_uV = (300) * 1000,

		.desc.uV_step = (10) * 1000,

		.desc.n_voltages = ((1570) - (300))/(10) + 1,

		.current_limits = da9062_buck_a_limits,

		.n_current_limits = ARRAY_SIZE(da9062_buck_a_limits),

		.desc.enable_reg = DA9062AA_BUCK1_CONT,

		.desc.enable_mask = DA9062AA_BUCK1_EN_MASK,

		.desc.vsel_reg = DA9062AA_VBUCK1_A,

		.desc.vsel_mask = DA9062AA_VBUCK1_A_MASK,

		.desc.linear_min_sel = 0,

		.sleep = REG_FIELD(DA9062AA_VBUCK1_A,

			__builtin_ffs((int)DA9062AA_BUCK1_SL_A_MASK) - 1,

			sizeof(unsigned int) * 8 -

			__builtin_clz((DA9062AA_BUCK1_SL_A_MASK)) - 1),

		.suspend_sleep = REG_FIELD(DA9062AA_VBUCK1_B,

			__builtin_ffs((int)DA9062AA_BUCK1_SL_B_MASK) - 1,

			sizeof(unsigned int) * 8 -

			__builtin_clz((DA9062AA_BUCK1_SL_B_MASK)) - 1),

		.suspend_vsel_reg = DA9062AA_VBUCK1_B,

		.mode = REG_FIELD(DA9062AA_BUCK1_CFG,

			__builtin_ffs((int)DA9062AA_BUCK1_MODE_MASK) - 1,

			sizeof(unsigned int) * 8 -

			__builtin_clz((DA9062AA_BUCK1_MODE_MASK)) - 1),

		.suspend = REG_FIELD(DA9062AA_DVC_1,

			__builtin_ffs((int)DA9062AA_VBUCK1_SEL_MASK) - 1,

			sizeof(unsigned int) * 8 -

			__builtin_clz((DA9062AA_VBUCK1_SEL_MASK)) - 1),

		.ilimit = REG_FIELD(DA9062AA_BUCK_ILIM_C,

			__builtin_ffs((int)DA9062AA_BUCK1_ILIM_MASK) - 1,

			sizeof(unsigned int) * 8 -

			__builtin_clz((DA9062AA_BUCK1_ILIM_MASK)) - 1),

	},

	{

		.desc.id = DA9061_ID_BUCK2,

		.desc.name = "DA9061 BUCK2",

		.desc.of_match = of_match_ptr("buck2"),

		.desc.regulators_node = of_match_ptr("regulators"),

		.desc.ops = &da9062_buck_ops,

		.desc.min_uV = (800) * 1000,

		.desc.uV_step = (20) * 1000,

		.desc.n_voltages = ((3340) - (800))/(20) + 1,

		.current_limits = da9062_buck_b_limits,

		.n_current_limits = ARRAY_SIZE(da9062_buck_b_limits),

		.desc.enable_reg = DA9062AA_BUCK3_CONT,

		.desc.enable_mask = DA9062AA_BUCK3_EN_MASK,

		.desc.vsel_reg = DA9062AA_VBUCK3_A,

		.desc.vsel_mask = DA9062AA_VBUCK3_A_MASK,

		.desc.linear_min_sel = 0,

		.sleep = REG_FIELD(DA9062AA_VBUCK3_A,

			__builtin_ffs((int)DA9062AA_BUCK3_SL_A_MASK) - 1,

			sizeof(unsigned int) * 8 -

			__builtin_clz((DA9062AA_BUCK3_SL_A_MASK)) - 1),

		.suspend_sleep = REG_FIELD(DA9062AA_VBUCK3_B,

			__builtin_ffs((int)DA9062AA_BUCK3_SL_B_MASK) - 1,

			sizeof(unsigned int) * 8 -

			__builtin_clz((DA9062AA_BUCK3_SL_B_MASK)) - 1),

		.suspend_vsel_reg = DA9062AA_VBUCK3_B,

		.mode = REG_FIELD(DA9062AA_BUCK3_CFG,

			__builtin_ffs((int)DA9062AA_BUCK3_MODE_MASK) - 1,

			sizeof(unsigned int) * 8 -

			__builtin_clz((DA9062AA_BUCK3_MODE_MASK)) - 1),

		.suspend = REG_FIELD(DA9062AA_DVC_1,

			__builtin_ffs((int)DA9062AA_VBUCK3_SEL_MASK) - 1,

			sizeof(unsigned int) * 8 -

			__builtin_clz((DA9062AA_VBUCK3_SEL_MASK)) - 1),

		.ilimit = REG_FIELD(DA9062AA_BUCK_ILIM_A,

			__builtin_ffs((int)DA9062AA_BUCK3_ILIM_MASK) - 1,

			sizeof(unsigned int) * 8 -

			__builtin_clz((DA9062AA_BUCK3_ILIM_MASK)) - 1),

	},

	{

		.desc.id = DA9061_ID_BUCK3,

		.desc.name = "DA9061 BUCK3",

		.desc.of_match = of_match_ptr("buck3"),

		.desc.regulators_node = of_match_ptr("regulators"),

		.desc.ops = &da9062_buck_ops,

		.desc.min_uV = (530) * 1000,

		.desc.uV_step = (10) * 1000,

		.desc.n_voltages = ((1800) - (530))/(10) + 1,

		.current_limits = da9062_buck_a_limits,

		.n_current_limits = ARRAY_SIZE(da9062_buck_a_limits),

		.desc.enable_reg = DA9062AA_BUCK4_CONT,

		.desc.enable_mask = DA9062AA_BUCK4_EN_MASK,

		.desc.vsel_reg = DA9062AA_VBUCK4_A,

		.desc.vsel_mask = DA9062AA_VBUCK4_A_MASK,

		.desc.linear_min_sel = 0,

		.sleep = REG_FIELD(DA9062AA_VBUCK4_A,

			__builtin_ffs((int)DA9062AA_BUCK4_SL_A_MASK) - 1,

			sizeof(unsigned int) * 8 -

			__builtin_clz((DA9062AA_BUCK4_SL_A_MASK)) - 1),

		.suspend_sleep = REG_FIELD(DA9062AA_VBUCK4_B,

			__builtin_ffs((int)DA9062AA_BUCK4_SL_B_MASK) - 1,

			sizeof(unsigned int) * 8 -

			__builtin_clz((DA9062AA_BUCK4_SL_B_MASK)) - 1),

		.suspend_vsel_reg = DA9062AA_VBUCK4_B,

		.mode = REG_FIELD(DA9062AA_BUCK4_CFG,

			__builtin_ffs((int)DA9062AA_BUCK4_MODE_MASK) - 1,

			sizeof(unsigned int) * 8 -

			__builtin_clz((DA9062AA_BUCK4_MODE_MASK)) - 1),

		.suspend = REG_FIELD(DA9062AA_DVC_1,

			__builtin_ffs((int)DA9062AA_VBUCK4_SEL_MASK) - 1,

			sizeof(unsigned int) * 8 -

			__builtin_clz((DA9062AA_VBUCK4_SEL_MASK)) - 1),

		.ilimit = REG_FIELD(DA9062AA_BUCK_ILIM_B,

			__builtin_ffs((int)DA9062AA_BUCK4_ILIM_MASK) - 1,

			sizeof(unsigned int) * 8 -

			__builtin_clz((DA9062AA_BUCK4_ILIM_MASK)) - 1),

	},

	{

		.desc.id = DA9061_ID_LDO1,

		.desc.name = "DA9061 LDO1",

		.desc.of_match = of_match_ptr("ldo1"),

		.desc.regulators_node = of_match_ptr("regulators"),

		.desc.ops = &da9062_ldo_ops,

		.desc.min_uV = (900) * 1000,

		.desc.uV_step = (50) * 1000,

		.desc.n_voltages = ((3600) - (900))/(50) + 1,

		.desc.enable_reg = DA9062AA_LDO1_CONT,

		.desc.enable_mask = DA9062AA_LDO1_EN_MASK,

		.desc.vsel_reg = DA9062AA_VLDO1_A,

		.desc.vsel_mask = DA9062AA_VLDO1_A_MASK,

		.desc.linear_min_sel = 0,

		.sleep = REG_FIELD(DA9062AA_VLDO1_A,

			__builtin_ffs((int)DA9062AA_LDO1_SL_A_MASK) - 1,

			sizeof(unsigned int) * 8 -

			__builtin_clz((DA9062AA_LDO1_SL_A_MASK)) - 1),

		.suspend_sleep = REG_FIELD(DA9062AA_VLDO1_B,

			__builtin_ffs((int)DA9062AA_LDO1_SL_B_MASK) - 1,

			sizeof(unsigned int) * 8 -

			__builtin_clz((DA9062AA_LDO1_SL_B_MASK)) - 1),

		.suspend_vsel_reg = DA9062AA_VLDO1_B,

		.suspend = REG_FIELD(DA9062AA_DVC_1,

			__builtin_ffs((int)DA9062AA_VLDO1_SEL_MASK) - 1,

			sizeof(unsigned int) * 8 -

			__builtin_clz((DA9062AA_VLDO1_SEL_MASK)) - 1),

		.oc_event = REG_FIELD(DA9062AA_STATUS_D,

			__builtin_ffs((int)DA9062AA_LDO1_ILIM_MASK) - 1,

			sizeof(unsigned int) * 8 -

			__builtin_clz((DA9062AA_LDO1_ILIM_MASK)) - 1),

	},

	{

		.desc.id = DA9061_ID_LDO2,

		.desc.name = "DA9061 LDO2",

		.desc.of_match = of_match_ptr("ldo2"),

		.desc.regulators_node = of_match_ptr("regulators"),

		.desc.ops = &da9062_ldo_ops,

		.desc.min_uV = (900) * 1000,

		.desc.uV_step = (50) * 1000,

		.desc.n_voltages = ((3600) - (600))/(50) + 1,

		.desc.enable_reg = DA9062AA_LDO2_CONT,

		.desc.enable_mask = DA9062AA_LDO2_EN_MASK,

		.desc.vsel_reg = DA9062AA_VLDO2_A,

		.desc.vsel_mask = DA9062AA_VLDO2_A_MASK,

		.desc.linear_min_sel = 0,

		.sleep = REG_FIELD(DA9062AA_VLDO2_A,

			__builtin_ffs((int)DA9062AA_LDO2_SL_A_MASK) - 1,

			sizeof(unsigned int) * 8 -

			__builtin_clz((DA9062AA_LDO2_SL_A_MASK)) - 1),

		.suspend_sleep = REG_FIELD(DA9062AA_VLDO2_B,

			__builtin_ffs((int)DA9062AA_LDO2_SL_B_MASK) - 1,

			sizeof(unsigned int) * 8 -

			__builtin_clz((DA9062AA_LDO2_SL_B_MASK)) - 1),

		.suspend_vsel_reg = DA9062AA_VLDO2_B,

		.suspend = REG_FIELD(DA9062AA_DVC_1,

			__builtin_ffs((int)DA9062AA_VLDO2_SEL_MASK) - 1,

			sizeof(unsigned int) * 8 -

			__builtin_clz((DA9062AA_VLDO2_SEL_MASK)) - 1),

		.oc_event = REG_FIELD(DA9062AA_STATUS_D,

			__builtin_ffs((int)DA9062AA_LDO2_ILIM_MASK) - 1,

			sizeof(unsigned int) * 8 -

			__builtin_clz((DA9062AA_LDO2_ILIM_MASK)) - 1),

	},

	{

		.desc.id = DA9061_ID_LDO3,

		.desc.name = "DA9061 LDO3",

		.desc.of_match = of_match_ptr("ldo3"),

		.desc.regulators_node = of_match_ptr("regulators"),

		.desc.ops = &da9062_ldo_ops,

		.desc.min_uV = (900) * 1000,

		.desc.uV_step = (50) * 1000,

		.desc.n_voltages = ((3600) - (900))/(50) + 1,

		.desc.enable_reg = DA9062AA_LDO3_CONT,

		.desc.enable_mask = DA9062AA_LDO3_EN_MASK,

		.desc.vsel_reg = DA9062AA_VLDO3_A,

		.desc.vsel_mask = DA9062AA_VLDO3_A_MASK,

		.desc.linear_min_sel = 0,

		.sleep = REG_FIELD(DA9062AA_VLDO3_A,

			__builtin_ffs((int)DA9062AA_LDO3_SL_A_MASK) - 1,

			sizeof(unsigned int) * 8 -

			__builtin_clz((DA9062AA_LDO3_SL_A_MASK)) - 1),

		.suspend_sleep = REG_FIELD(DA9062AA_VLDO3_B,

			__builtin_ffs((int)DA9062AA_LDO3_SL_B_MASK) - 1,

			sizeof(unsigned int) * 8 -

			__builtin_clz((DA9062AA_LDO3_SL_B_MASK)) - 1),

		.suspend_vsel_reg = DA9062AA_VLDO3_B,

		.suspend = REG_FIELD(DA9062AA_DVC_1,

			__builtin_ffs((int)DA9062AA_VLDO3_SEL_MASK) - 1,

			sizeof(unsigned int) * 8 -

			__builtin_clz((DA9062AA_VLDO3_SEL_MASK)) - 1),

		.oc_event = REG_FIELD(DA9062AA_STATUS_D,

			__builtin_ffs((int)DA9062AA_LDO3_ILIM_MASK) - 1,

			sizeof(unsigned int) * 8 -

			__builtin_clz((DA9062AA_LDO3_ILIM_MASK)) - 1),

	},

	{

		.desc.id = DA9061_ID_LDO4,

		.desc.name = "DA9061 LDO4",

		.desc.of_match = of_match_ptr("ldo4"),

		.desc.regulators_node = of_match_ptr("regulators"),

		.desc.ops = &da9062_ldo_ops,

		.desc.min_uV = (900) * 1000,

		.desc.uV_step = (50) * 1000,

		.desc.n_voltages = ((3600) - (900))/(50) + 1,

		.desc.enable_reg = DA9062AA_LDO4_CONT,

		.desc.enable_mask = DA9062AA_LDO4_EN_MASK,

		.desc.vsel_reg = DA9062AA_VLDO4_A,

		.desc.vsel_mask = DA9062AA_VLDO4_A_MASK,

		.desc.linear_min_sel = 0,

		.sleep = REG_FIELD(DA9062AA_VLDO4_A,

			__builtin_ffs((int)DA9062AA_LDO4_SL_A_MASK) - 1,

			sizeof(unsigned int) * 8 -

			__builtin_clz((DA9062AA_LDO4_SL_A_MASK)) - 1),

		.suspend_sleep = REG_FIELD(DA9062AA_VLDO4_B,

			__builtin_ffs((int)DA9062AA_LDO4_SL_B_MASK) - 1,

			sizeof(unsigned int) * 8 -

			__builtin_clz((DA9062AA_LDO4_SL_B_MASK)) - 1),

		.suspend_vsel_reg = DA9062AA_VLDO4_B,

		.suspend = REG_FIELD(DA9062AA_DVC_1,

			__builtin_ffs((int)DA9062AA_VLDO4_SEL_MASK) - 1,

			sizeof(unsigned int) * 8 -

			__builtin_clz((DA9062AA_VLDO4_SEL_MASK)) - 1),

		.oc_event = REG_FIELD(DA9062AA_STATUS_D,

			__builtin_ffs((int)DA9062AA_LDO4_ILIM_MASK) - 1,

			sizeof(unsigned int) * 8 -

			__builtin_clz((DA9062AA_LDO4_ILIM_MASK)) - 1),

	},

};



/* DA9062 Regulator information */

static const struct da9062_regulator_info local_da9062_regulator_info[] = {

	{

		.desc.id = DA9062_ID_BUCK1,

		.desc.name = "DA9062 BUCK1",
@@ -727,17 +990,33 @@ static int da9062_regulator_probe(struct platform_device *pdev) 
	struct da9062_regulators *regulators;

	struct da9062_regulator *regl;

	struct regulator_config config = { };

	const struct da9062_regulator_info *rinfo;

	int irq, n, ret;

	size_t size;

	int max_regulators;



	switch (chip->chip_type) {

	case COMPAT_TYPE_DA9061:

		max_regulators = DA9061_MAX_REGULATORS;

		rinfo = local_da9061_regulator_info;

		break;

	case COMPAT_TYPE_DA9062:

		max_regulators = DA9062_MAX_REGULATORS;

		rinfo = local_da9062_regulator_info;

		break;

	default:

		dev_err(chip->dev, "Unrecognised chip type\n");

		return -ENODEV;

	}



	/* Allocate memory required by usable regulators */

	size = sizeof(struct da9062_regulators) +

		DA9062_MAX_REGULATORS * sizeof(struct da9062_regulator);

		max_regulators * sizeof(struct da9062_regulator);

	regulators = devm_kzalloc(&pdev->dev, size, GFP_KERNEL);

	if (!regulators)

		return -ENOMEM;



	regulators->n_regulators = DA9062_MAX_REGULATORS;

	regulators->n_regulators = max_regulators;

	platform_set_drvdata(pdev, regulators);



	n = 0;
@@ -745,7 +1024,7 @@ static int da9062_regulator_probe(struct platform_device *pdev) 
		/* Initialise regulator structure */

		regl = &regulators->regulator[n];

		regl->hw = chip;

		regl->info = &local_regulator_info[n];

		regl->info = &rinfo[n];

		regl->desc = regl->info->desc;

		regl->desc.type = REGULATOR_VOLTAGE;

		regl->desc.owner = THIS_MODULE;
@@ -836,6 +1115,6 @@ module_exit(da9062_regulator_cleanup); 


/* Module information */

MODULE_AUTHOR("S Twiss <stwiss.opensource@diasemi.com>");

MODULE_DESCRIPTION("REGULATOR device driver for Dialog DA9062");

MODULE_DESCRIPTION("REGULATOR device driver for Dialog DA9062 and DA9061");

MODULE_LICENSE("GPL");

MODULE_ALIAS("platform:da9062-regulators");

drivers/regulator/hi6421-regulator.c

+7 −0
Original line number Diff line number Diff line
@@ -621,7 +621,14 @@ static int hi6421_regulator_probe(struct platform_device *pdev) 
	return 0;

}



static const struct platform_device_id hi6421_regulator_table[] = {

	{ .name = "hi6421-regulator" },

	{},

};

MODULE_DEVICE_TABLE(platform, hi6421_regulator_table);



static struct platform_driver hi6421_regulator_driver = {

	.id_table = hi6421_regulator_table,

	.driver = {

		.name	= "hi6421-regulator",

	},