lael-labs/linux

Documentation/devicetree/bindings/regulator/gpio-regulator.txt+22−8

 - compatible		: Must be "regulator-gpio".
 - regulator-name	: Defined in regulator.txt as optional, but required
 			  here.
-- states		: Selection of available voltages and GPIO configs.
+- gpios			: Array of one or more GPIO pins used to select the
-                          if there are no states, then use a fixed regulator
+			  regulator voltage/current listed in "states".
+- states		: Selection of available voltages/currents provided by
+			  this regulator and matching GPIO configurations to
+			  achieve them. If there are no states in the "states"
+			  array, use a fixed regulator instead.
 Optional properties:
-- enable-gpio		: GPIO to use to enable/disable the regulator.
+- enable-gpios		: GPIO used to enable/disable the regulator.
-- gpios			: GPIO group used to control voltage.
+			  Warning, the GPIO phandle flags are ignored and the
-- gpios-states		: gpios pin's initial states array. 0: LOW, 1: HIGH.
+			  GPIO polarity is controlled solely by the presence
-			  defualt is LOW if nothing is specified.
+			  of "enable-active-high" DT property. This is due to
+			  compatibility with old DTs.
+- enable-active-high	: Polarity of "enable-gpio" GPIO is active HIGH.
+			  Default is active LOW.
+- gpios-states		: On operating systems, that don't support reading back
+			  gpio values in output mode (most notably linux), this
+			  array provides the state of GPIO pins set when
+			  requesting them from the gpio controller. Systems,
+			  that are capable of preserving state when requesting
+			  the lines, are free to ignore this property.
+			  0: LOW, 1: HIGH. Default is LOW if nothing else
+			  is specified.
 - startup-delay-us	: Startup time in microseconds.
-- enable-active-high	: Polarity of GPIO is active high (default is low).
 - regulator-type	: Specifies what is being regulated, must be either
 			  "voltage" or "current", defaults to voltage.
 		regulator-max-microvolt = <2600000>;
 		regulator-boot-on;
-		enable-gpio = <&gpio0 23 0x4>;
+		enable-gpios = <&gpio0 23 0x4>;
 		gpios = <&gpio0 24 0x4
 			 &gpio0 25 0x4>;
 		states = <1800000 0x3

Documentation/devicetree/bindings/regulator/st,stm32mp1-pwr-reg.txt+43−0

@@ -0,0 +1,43 @@
	1	STM32MP1 PWR Regulators
	2	-----------------------
	3
	4	Available Regulators in STM32MP1 PWR block are:
	5	- reg11 for regulator 1V1
	6	- reg18 for regulator 1V8
	7	- usb33 for the swtich USB3V3
	8
	9	Required properties:
	10	- compatible: Must be "st,stm32mp1,pwr-reg"
	11	- list of child nodes that specify the regulator reg11, reg18 or usb33
	12	initialization data for defined regulators. The definition for each of
	13	these nodes is defined using the standard binding for regulators found at
	14	Documentation/devicetree/bindings/regulator/regulator.txt.
	15	- vdd-supply: phandle to the parent supply/regulator node for vdd input
	16	- vdd_3v3_usbfs-supply: phandle to the parent supply/regulator node for usb33
	17
	18	Example:
	19
	20	pwr_regulators: pwr@50001000 {
	21	compatible = "st,stm32mp1,pwr-reg";
	22	reg = <0x50001000 0x10>;
	23	vdd-supply = <&vdd>;
	24	vdd_3v3_usbfs-supply = <&vdd_usb>;
	25
	26	reg11: reg11 {
	27	regulator-name = "reg11";
	28	regulator-min-microvolt = <1100000>;
	29	regulator-max-microvolt = <1100000>;
	30	};
	31
	32	reg18: reg18 {
	33	regulator-name = "reg18";
	34	regulator-min-microvolt = <1800000>;
	35	regulator-max-microvolt = <1800000>;
	36	};
	37
	38	usb33: usb33 {
	39	regulator-name = "usb33";
	40	regulator-min-microvolt = <3300000>;
	41	regulator-max-microvolt = <3300000>;
	42	};
	43	};

drivers/mfd/wm831x-core.c+1−1

@@ -34,7 +34,7 @@ · 33 unmodified lines
34	/* Current settings - values are 2*2^(reg_val/4) microamps. These are	34	/* Current settings - values are 2*2^(reg_val/4) microamps. These are
35	* exported since they are used by multiple drivers.	35	* exported since they are used by multiple drivers.
36	*/	36	*/
37	int wm831x_isinkv_values[WM831X_ISINK_MAX_ISEL + 1] = {	37	const unsigned int wm831x_isinkv_values[WM831X_ISINK_MAX_ISEL + 1] = {
38	2,	38	2,
39	2,	39	2,
40	3,	40	3,

drivers/mfd/wm8400-core.c+0−6

 	}
 }
-int wm8400_block_read(struct wm8400 *wm8400, u8 reg, int count, u16 *data)
-{
-	return regmap_bulk_read(wm8400->regmap, reg, data, count);
-}
-EXPORT_SYMBOL_GPL(wm8400_block_read);
 static int wm8400_register_codec(struct wm8400 *wm8400)
 {
 	const struct mfd_cell cell = {

drivers/regulator/88pm800.c+1−17

 	int max_ua;
 };
-struct pm800_regulators {
-	struct pm80x_chip *chip;
-	struct regmap *map;
-};
 /*
  * vreg - the buck regs string.
  * ereg - the string for the enable register.
 {
 	struct pm80x_chip *chip = dev_get_drvdata(pdev->dev.parent);
 	struct pm80x_platform_data *pdata = dev_get_platdata(pdev->dev.parent);
-	struct pm800_regulators *pm800_data;
 	struct regulator_config config = { };
 	struct regulator_init_data *init_data;
 	int i, ret;
 			return -EINVAL;
 	}
-	pm800_data = devm_kzalloc(&pdev->dev, sizeof(*pm800_data),
-					GFP_KERNEL);
-	if (!pm800_data)
-		return -ENOMEM;
-	pm800_data->map = chip->subchip->regmap_power;
-	pm800_data->chip = chip;
-	platform_set_drvdata(pdev, pm800_data);
 	config.dev = chip->dev;
-	config.regmap = pm800_data->map;
+	config.regmap = chip->subchip->regmap_power;
 	for (i = 0; i < PM800_ID_RG_MAX; i++) {
 		struct regulator_dev *regulator;

drivers/regulator/88pm8607.c+9−34

 {									\
 	.desc	= {							\
 		.name	= "PREG",					\
+		.of_match = of_match_ptr("PREG"),			\
+		.regulators_node = of_match_ptr("regulators"),		\
 		.ops	= &pm8606_preg_ops,				\
 		.type	= REGULATOR_CURRENT,				\
 		.id	= PM8606_ID_PREG,				\
 {									\
 	.desc	= {							\
 		.name	= #vreg,					\
+		.of_match = of_match_ptr(#vreg),			\
+		.regulators_node = of_match_ptr("regulators"),		\
 		.ops	= &pm8607_regulator_ops,			\
 		.type	= REGULATOR_VOLTAGE,				\
 		.id	= PM8607_ID_##vreg,				\
 {									\
 	.desc	= {							\
 		.name	= "LDO" #_id,					\
+		.of_match = of_match_ptr("LDO" #_id),			\
+		.regulators_node = of_match_ptr("regulators"),		\
 		.ops	= &pm8607_regulator_ops,			\
 		.type	= REGULATOR_VOLTAGE,				\
 		.id	= PM8607_ID_LDO##_id,				\
 	PM8606_PREG(PREREGULATORB, 5),
 };
-#ifdef CONFIG_OF
-static int pm8607_regulator_dt_init(struct platform_device *pdev,
-				    struct pm8607_regulator_info *info,
-				    struct regulator_config *config)
-{
-	struct device_node *nproot, *np;
-	nproot = pdev->dev.parent->of_node;
-	if (!nproot)
-		return -ENODEV;
-	nproot = of_get_child_by_name(nproot, "regulators");
-	if (!nproot) {
-		dev_err(&pdev->dev, "failed to find regulators node\n");
-		return -ENODEV;
-	}
-	for_each_child_of_node(nproot, np) {
-		if (of_node_name_eq(np, info->desc.name)) {
-			config->init_data =
-				of_get_regulator_init_data(&pdev->dev, np,
-							   &info->desc);
-			config->of_node = np;
-			break;
-		}
-	}
-	of_node_put(nproot);
-	return 0;
-}
-#else
-#define pm8607_regulator_dt_init(x, y, z)	(-1)
-#endif
 static int pm8607_regulator_probe(struct platform_device *pdev)
 {
 	struct pm860x_chip *chip = dev_get_drvdata(pdev->dev.parent);
 	if ((i == PM8607_ID_BUCK3) && chip->buck3_double)
 		info->slope_double = 1;
-	config.dev = &pdev->dev;
+	config.dev = chip->dev;
 	config.driver_data = info;
-	if (pm8607_regulator_dt_init(pdev, info, &config))
+	if (pdata)
-		if (pdata)
+		config.init_data = pdata;
-			config.init_data = pdata;
 	if (chip->id == CHIP_PM8607)
 		config.regmap = chip->regmap;

drivers/regulator/Kconfig+10−1

 config REGULATOR_DA903X
 	tristate "Dialog Semiconductor DA9030/DA9034 regulators"
 	depends on PMIC_DA903X
+	depends on !CC_IS_CLANG # https://bugs.llvm.org/show_bug.cgi?id=38789
 	help
 	  Say y here to support the BUCKs and LDOs regulators found on
 	  Dialog Semiconductor DA9030/DA9034 PMIC.
 	  This driver can also be built as a module. If so, the module
 	  will be called stm32-vrefbuf.
+config REGULATOR_STM32_PWR
+	bool "STMicroelectronics STM32 PWR"
+	depends on ARCH_STM32 || COMPILE_TEST
+	help
+	  This driver supports internal regulators (1V1, 1V8, 3V3) in the
+	  STMicroelectronics STM32 chips.
 config REGULATOR_STPMIC1
 	tristate "STMicroelectronics STPMIC1 PMIC Regulators"
 	depends on MFD_STPMIC1
 config REGULATOR_UNIPHIER
 	tristate "UniPhier regulator driver"
 	depends on ARCH_UNIPHIER || COMPILE_TEST
-	depends on OF && MFD_SYSCON
+	depends on OF
+	select REGMAP_MMIO
 	default ARCH_UNIPHIER
 	help
 	  Support for regulators implemented on Socionext UniPhier SoCs.

drivers/regulator/Makefile+1−0

@@ -105,6 +105,7 @@ obj-$(CONFIG_REGULATOR_S5M8767) += s5m8767.o · 104 unmodified lines
105	obj-$(CONFIG_REGULATOR_SC2731) += sc2731-regulator.o	105	obj-$(CONFIG_REGULATOR_SC2731) += sc2731-regulator.o
106	obj-$(CONFIG_REGULATOR_SKY81452) += sky81452-regulator.o	106	obj-$(CONFIG_REGULATOR_SKY81452) += sky81452-regulator.o
107	obj-$(CONFIG_REGULATOR_STM32_VREFBUF) += stm32-vrefbuf.o	107	obj-$(CONFIG_REGULATOR_STM32_VREFBUF) += stm32-vrefbuf.o
		108	obj-$(CONFIG_REGULATOR_STM32_PWR) += stm32-pwr.o
108	obj-$(CONFIG_REGULATOR_STPMIC1) += stpmic1_regulator.o	109	obj-$(CONFIG_REGULATOR_STPMIC1) += stpmic1_regulator.o
109	obj-$(CONFIG_REGULATOR_STW481X_VMMC) += stw481x-vmmc.o	110	obj-$(CONFIG_REGULATOR_STW481X_VMMC) += stw481x-vmmc.o
110	obj-$(CONFIG_REGULATOR_SY8106A) += sy8106a-regulator.o	111	obj-$(CONFIG_REGULATOR_SY8106A) += sy8106a-regulator.o

drivers/regulator/ab3100.c+12−33

  * @regreg: regulator register number in the AB3100
  */
 struct ab3100_regulator {
-	struct regulator_dev *rdev;
 	struct device *dev;
 	struct ab3100_platform_data *plfdata;
 	u8 regreg;
 		return 0;
 }
-static struct regulator_ops regulator_ops_fixed = {
+static const struct regulator_ops regulator_ops_fixed = {
-	.list_voltage = regulator_list_voltage_linear,
 	.enable      = ab3100_enable_regulator,
 	.disable     = ab3100_disable_regulator,
 	.is_enabled  = ab3100_is_enabled_regulator,
 };
-static struct regulator_ops regulator_ops_variable = {
+static const struct regulator_ops regulator_ops_variable = {
 	.enable      = ab3100_enable_regulator,
 	.disable     = ab3100_disable_regulator,
 	.is_enabled  = ab3100_is_enabled_regulator,
 	.list_voltage = regulator_list_voltage_table,
 };
-static struct regulator_ops regulator_ops_variable_sleepable = {
+static const struct regulator_ops regulator_ops_variable_sleepable = {
 	.enable      = ab3100_enable_regulator,
 	.disable     = ab3100_disable_regulator,
 	.is_enabled  = ab3100_is_enabled_regulator,
  * is an on/off switch plain an simple. The external
  * voltage is defined in the board set-up if any.
  */
-static struct regulator_ops regulator_ops_external = {
+static const struct regulator_ops regulator_ops_external = {
 	.enable      = ab3100_enable_regulator,
 	.disable     = ab3100_disable_regulator,
 	.is_enabled  = ab3100_is_enabled_regulator,
 	.get_voltage = ab3100_get_voltage_regulator_external,
 };
-static struct regulator_desc
+static const struct regulator_desc
 ab3100_regulator_desc[AB3100_NUM_REGULATORS] = {
 	{
 		.name = "LDO_A",
 		.n_voltages = 1,
 		.type = REGULATOR_VOLTAGE,
 		.owner = THIS_MODULE,
-		.min_uV = LDO_A_VOLTAGE,
+		.fixed_uV = LDO_A_VOLTAGE,
 		.enable_time = 200,
 	},
 	{
 		.n_voltages = 1,
 		.type = REGULATOR_VOLTAGE,
 		.owner = THIS_MODULE,
-		.min_uV = LDO_C_VOLTAGE,
+		.fixed_uV = LDO_C_VOLTAGE,
 		.enable_time = 200,
 	},
 	{
 		.n_voltages = 1,
 		.type = REGULATOR_VOLTAGE,
 		.owner = THIS_MODULE,
-		.min_uV = LDO_D_VOLTAGE,
+		.fixed_uV = LDO_D_VOLTAGE,
 		.enable_time = 200,
 	},
 	{
 				     struct device_node *np,
 				     unsigned long id)
 {
-	struct regulator_desc *desc;
+	const struct regulator_desc *desc;
 	struct ab3100_regulator *reg;
 	struct regulator_dev *rdev;
 	struct regulator_config config = { };
 		return err;
 	}
-	/* Then set a pointer back to the registered regulator */
-	reg->rdev = rdev;
 	return 0;
 }
 	LDO_D_SETTING,
 };
-static int ab3100_regulators_remove(struct platform_device *pdev)
-{
-	int i;
-	for (i = 0; i < AB3100_NUM_REGULATORS; i++) {
-		struct ab3100_regulator *reg = &ab3100_regulators[i];
-		reg->rdev = NULL;
-	}
-	return 0;
-}
 static int
 ab3100_regulator_of_probe(struct platform_device *pdev, struct device_node *np)
 {
 			pdev, NULL, ab3100_regulator_matches[i].init_data,
 			ab3100_regulator_matches[i].of_node,
 			(unsigned long)ab3100_regulator_matches[i].driver_data);
-		if (err) {
+		if (err)
-			ab3100_regulators_remove(pdev);
 			return err;
-		}
 	}
 	return 0;
 	/* Register the regulators */
 	for (i = 0; i < AB3100_NUM_REGULATORS; i++) {
-		struct regulator_desc *desc = &ab3100_regulator_desc[i];
+		const struct regulator_desc *desc = &ab3100_regulator_desc[i];
 		err = ab3100_regulator_register(pdev, plfdata, NULL, NULL,
 						desc->id);
-		if (err) {
+		if (err)
-			ab3100_regulators_remove(pdev);
 			return err;
-		}
 	}
 	return 0;
 		.name  = "ab3100-regulators",
 	},
 	.probe = ab3100_regulators_probe,
-	.remove = ab3100_regulators_remove,
 };
 static __init int ab3100_regulators_init(void)

drivers/regulator/ab8500-ext.c+14−35

@@ -479,7 +479,6 @@ static struct ab8500_regulator_platform_data ab8500_regulator_plat_data = { · 478 unmodified lines
479	* struct ab8500_ext_regulator_info - ab8500 regulator information	479	* struct ab8500_ext_regulator_info - ab8500 regulator information
480	* @dev: device pointer	480	* @dev: device pointer
481	* @desc: regulator description	481	* @desc: regulator description
482	* @rdev: regulator device
483	* @cfg: regulator configuration (extension of regulator FW configuration)	482	* @cfg: regulator configuration (extension of regulator FW configuration)
484	* @update_bank: bank to control on/off	483	* @update_bank: bank to control on/off
485	* @update_reg: register to control on/off	484	* @update_reg: register to control on/off
@@ -495,7 +494,6 @@ static struct ab8500_regulator_platform_data ab8500_regulator_plat_data = { · 9 unmodified lines
495	struct ab8500_ext_regulator_info {	494	struct ab8500_ext_regulator_info {
496	struct device *dev;	495	struct device *dev;
497	struct regulator_desc desc;	496	struct regulator_desc desc;
498	struct regulator_dev *rdev;
499	struct ab8500_ext_regulator_cfg *cfg;	497	struct ab8500_ext_regulator_cfg *cfg;
500	u8 update_bank;	498	u8 update_bank;
501	u8 update_reg;	499	u8 update_reg;
@@ -530,7 +528,7 @@ static int ab8500_ext_regulator_enable(struct regulator_dev *rdev) · 28 unmodified lines
530	info->update_bank, info->update_reg,	528	info->update_bank, info->update_reg,
531	info->update_mask, regval);	529	info->update_mask, regval);
532	if (ret < 0) {	530	if (ret < 0) {
533	dev_err(rdev_get_dev(info->rdev),	531	dev_err(rdev_get_dev(rdev),
534	"couldn't set enable bits for regulator\n");	532	"couldn't set enable bits for regulator\n");
535	return ret;	533	return ret;
536	}	534	}
@@ -566,7 +564,7 @@ static int ab8500_ext_regulator_disable(struct regulator_dev *rdev) · 29 unmodified lines
566	info->update_bank, info->update_reg,	564	info->update_bank, info->update_reg,
567	info->update_mask, regval);	565	info->update_mask, regval);
568	if (ret < 0) {	566	if (ret < 0) {
569	dev_err(rdev_get_dev(info->rdev),	567	dev_err(rdev_get_dev(rdev),
570	"couldn't set disable bits for regulator\n");	568	"couldn't set disable bits for regulator\n");
571	return ret;	569	return ret;
572	}	570	}
@@ -720,7 +718,7 @@ static int ab8500_ext_list_voltage(struct regulator_dev *rdev, · 147 unmodified lines
720	return -EINVAL;	718	return -EINVAL;
721	}	719	}
722		720
723	static struct regulator_ops ab8500_ext_regulator_ops = {	721	static const struct regulator_ops ab8500_ext_regulator_ops = {
724	.enable = ab8500_ext_regulator_enable,	722	.enable = ab8500_ext_regulator_enable,
725	.disable = ab8500_ext_regulator_disable,	723	.disable = ab8500_ext_regulator_disable,
726	.is_enabled = ab8500_ext_regulator_is_enabled,	724	.is_enabled = ab8500_ext_regulator_is_enabled,
@@ -735,6 +733,7 @@ static struct ab8500_ext_regulator_info · 8 unmodified lines
735	[AB8500_EXT_SUPPLY1] = {	733	[AB8500_EXT_SUPPLY1] = {
736	.desc = {	734	.desc = {
737	.name = "VEXTSUPPLY1",	735	.name = "VEXTSUPPLY1",
		736	.of_match = of_match_ptr("ab8500_ext1"),
738	.ops = &ab8500_ext_regulator_ops,	737	.ops = &ab8500_ext_regulator_ops,
739	.type = REGULATOR_VOLTAGE,	738	.type = REGULATOR_VOLTAGE,
740	.id = AB8500_EXT_SUPPLY1,	739	.id = AB8500_EXT_SUPPLY1,
@@ -752,6 +751,7 @@ static struct ab8500_ext_regulator_info · 11 unmodified lines
752	[AB8500_EXT_SUPPLY2] = {	751	[AB8500_EXT_SUPPLY2] = {
753	.desc = {	752	.desc = {
754	.name = "VEXTSUPPLY2",	753	.name = "VEXTSUPPLY2",
		754	.of_match = of_match_ptr("ab8500_ext2"),
755	.ops = &ab8500_ext_regulator_ops,	755	.ops = &ab8500_ext_regulator_ops,
756	.type = REGULATOR_VOLTAGE,	756	.type = REGULATOR_VOLTAGE,
757	.id = AB8500_EXT_SUPPLY2,	757	.id = AB8500_EXT_SUPPLY2,
@@ -769,6 +769,7 @@ static struct ab8500_ext_regulator_info · 11 unmodified lines
769	[AB8500_EXT_SUPPLY3] = {	769	[AB8500_EXT_SUPPLY3] = {
770	.desc = {	770	.desc = {
771	.name = "VEXTSUPPLY3",	771	.name = "VEXTSUPPLY3",
		772	.of_match = of_match_ptr("ab8500_ext3"),
772	.ops = &ab8500_ext_regulator_ops,	773	.ops = &ab8500_ext_regulator_ops,
773	.type = REGULATOR_VOLTAGE,	774	.type = REGULATOR_VOLTAGE,
774	.id = AB8500_EXT_SUPPLY3,	775	.id = AB8500_EXT_SUPPLY3,
@@ -785,30 +786,13 @@ static struct ab8500_ext_regulator_info · 10 unmodified lines
785	},	786	},
786	};	787	};
787		788
788	static struct of_regulator_match ab8500_ext_regulator_match[] = {
789	{ .name = "ab8500_ext1", .driver_data = (void *) AB8500_EXT_SUPPLY1, },
790	{ .name = "ab8500_ext2", .driver_data = (void *) AB8500_EXT_SUPPLY2, },
791	{ .name = "ab8500_ext3", .driver_data = (void *) AB8500_EXT_SUPPLY3, },
792	};
793
794	static int ab8500_ext_regulator_probe(struct platform_device *pdev)	789	static int ab8500_ext_regulator_probe(struct platform_device *pdev)
795	{	790	{
796	struct ab8500 *ab8500 = dev_get_drvdata(pdev->dev.parent);	791	struct ab8500 *ab8500 = dev_get_drvdata(pdev->dev.parent);
797	struct ab8500_regulator_platform_data *pdata = &ab8500_regulator_plat_data;	792	struct ab8500_regulator_platform_data *pdata = &ab8500_regulator_plat_data;
798	struct device_node *np = pdev->dev.of_node;
799	struct regulator_config config = { };	793	struct regulator_config config = { };
800	int i, err;	794	struct regulator_dev *rdev;
801		795	int i;
802	if (np) {
803	err = of_regulator_match(&pdev->dev, np,
804	ab8500_ext_regulator_match,
805	ARRAY_SIZE(ab8500_ext_regulator_match));
806	if (err < 0) {
807	dev_err(&pdev->dev,
808	"Error parsing regulator init data: %d\n", err);
809	return err;
810	}
811	}
812		796
813	if (!ab8500) {	797	if (!ab8500) {
814	dev_err(&pdev->dev, "null mfd parent\n");	798	dev_err(&pdev->dev, "null mfd parent\n");
@@ -844,23 +828,18 @@ static int ab8500_ext_regulator_probe(struct platform_device *pdev) · 29 unmodified lines
844		828
845	config.dev = &pdev->dev;	829	config.dev = &pdev->dev;
846	config.driver_data = info;	830	config.driver_data = info;
847	config.of_node = ab8500_ext_regulator_match[i].of_node;	831	config.init_data = &pdata->ext_regulator[i];
848	config.init_data = (np) ?
849	ab8500_ext_regulator_match[i].init_data :
850	&pdata->ext_regulator[i];
851		832
852	/* register regulator with framework */	833	/* register regulator with framework */
853	info->rdev = devm_regulator_register(&pdev->dev, &info->desc,	834	rdev = devm_regulator_register(&pdev->dev, &info->desc,
854	&config);	835	&config);
855	if (IS_ERR(info->rdev)) {	836	if (IS_ERR(rdev)) {
856	err = PTR_ERR(info->rdev);
857	dev_err(&pdev->dev, "failed to register regulator %s\n",	837	dev_err(&pdev->dev, "failed to register regulator %s\n",
858	info->desc.name);	838	info->desc.name);
859	return err;	839	return PTR_ERR(rdev);
860	}	840	}
861		841
862	dev_dbg(rdev_get_dev(info->rdev),	842	dev_dbg(&pdev->dev, "%s-probed\n", info->desc.name);
863	"%s-probed\n", info->desc.name);
864	}	843	}
865		844
866	return 0;	845	return 0;

drivers/regulator/ab8500.c+9−11

  * struct ab8500_regulator_info - ab8500 regulator information
  * @dev: device pointer
  * @desc: regulator description
- * @regulator_dev: regulator device
  * @shared_mode: used when mode is shared between two regulators
  * @load_lp_uA: maximum load in idle (low power) mode
  * @update_bank: bank to control on/off
 struct ab8500_regulator_info {
 	struct device		*dev;
 	struct regulator_desc	desc;
-	struct regulator_dev	*regulator;
 	struct ab8500_shared_mode *shared_mode;
 	int load_lp_uA;
 	u8 update_bank;
 	return ret;
 }
-static struct regulator_ops ab8500_regulator_volt_mode_ops = {
+static const struct regulator_ops ab8500_regulator_volt_mode_ops = {
 	.enable			= ab8500_regulator_enable,
 	.disable		= ab8500_regulator_disable,
 	.is_enabled		= ab8500_regulator_is_enabled,
 	.list_voltage		= regulator_list_voltage_table,
 };
-static struct regulator_ops ab8500_regulator_volt_ops = {
+static const struct regulator_ops ab8500_regulator_volt_ops = {
 	.enable		= ab8500_regulator_enable,
 	.disable	= ab8500_regulator_disable,
 	.is_enabled	= ab8500_regulator_is_enabled,
 	.list_voltage	= regulator_list_voltage_table,
 };
-static struct regulator_ops ab8500_regulator_mode_ops = {
+static const struct regulator_ops ab8500_regulator_mode_ops = {
 	.enable			= ab8500_regulator_enable,
 	.disable		= ab8500_regulator_disable,
 	.is_enabled		= ab8500_regulator_is_enabled,
 	.list_voltage		= regulator_list_voltage_table,
 };
-static struct regulator_ops ab8500_regulator_ops = {
+static const struct regulator_ops ab8500_regulator_ops = {
 	.enable			= ab8500_regulator_enable,
 	.disable		= ab8500_regulator_disable,
 	.is_enabled		= ab8500_regulator_is_enabled,
 	.list_voltage		= regulator_list_voltage_table,
 };
-static struct regulator_ops ab8500_regulator_anamic_mode_ops = {
+static const struct regulator_ops ab8500_regulator_anamic_mode_ops = {
 	.enable		= ab8500_regulator_enable,
 	.disable	= ab8500_regulator_disable,
 	.is_enabled	= ab8500_regulator_is_enabled,
 	struct ab8500 *ab8500 = dev_get_drvdata(pdev->dev.parent);
 	struct ab8500_regulator_info *info = NULL;
 	struct regulator_config config = { };
+	struct regulator_dev *rdev;
 	/* assign per-regulator data */
 	info = &abx500_regulator.info[id];
 	}
 	/* register regulator with framework */
-	info->regulator = devm_regulator_register(&pdev->dev, &info->desc,
+	rdev = devm_regulator_register(&pdev->dev, &info->desc, &config);
-						&config);
+	if (IS_ERR(rdev)) {
-	if (IS_ERR(info->regulator)) {
 		dev_err(&pdev->dev, "failed to register regulator %s\n",
 			info->desc.name);
-		return PTR_ERR(info->regulator);
+		return PTR_ERR(rdev);
 	}
 	return 0;

drivers/regulator/act8865-regulator.c+21−126

@@ -226,7 +226,7 @@ static const struct regulator_linear_range act8600_sudcdc_voltage_ranges[] = { · 225 unmodified lines
226	REGULATOR_LINEAR_RANGE(41400000, 248, 255, 0),	226	REGULATOR_LINEAR_RANGE(41400000, 248, 255, 0),
227	};	227	};
228		228
229	static struct regulator_ops act8865_ops = {	229	static const struct regulator_ops act8865_ops = {
230	.list_voltage = regulator_list_voltage_linear_range,	230	.list_voltage = regulator_list_voltage_linear_range,
231	.map_voltage = regulator_map_voltage_linear_range,	231	.map_voltage = regulator_map_voltage_linear_range,
232	.get_voltage_sel = regulator_get_voltage_sel_regmap,	232	.get_voltage_sel = regulator_get_voltage_sel_regmap,
@@ -236,7 +236,7 @@ static struct regulator_ops act8865_ops = { · 3 unmodified lines
236	.is_enabled = regulator_is_enabled_regmap,	236	.is_enabled = regulator_is_enabled_regmap,
237	};	237	};
238		238
239	static struct regulator_ops act8865_ldo_ops = {	239	static const struct regulator_ops act8865_ldo_ops = {
240	.enable = regulator_enable_regmap,	240	.enable = regulator_enable_regmap,
241	.disable = regulator_disable_regmap,	241	.disable = regulator_disable_regmap,
242	.is_enabled = regulator_is_enabled_regmap,	242	.is_enabled = regulator_is_enabled_regmap,
@@ -245,6 +245,8 @@ static struct regulator_ops act8865_ldo_ops = { · 2 unmodified lines
245	#define ACT88xx_REG(_name, _family, _id, _vsel_reg, _supply) \	245	#define ACT88xx_REG(_name, _family, _id, _vsel_reg, _supply) \
246	[_family##_ID_##_id] = { \	246	[_family##_ID_##_id] = { \
247	.name = _name, \	247	.name = _name, \
		248	.of_match = of_match_ptr(_name), \
		249	.regulators_node = of_match_ptr("regulators"), \
248	.supply_name = _supply, \	250	.supply_name = _supply, \
249	.id = _family##_ID_##_id, \	251	.id = _family##_ID_##_id, \
250	.type = REGULATOR_VOLTAGE, \	252	.type = REGULATOR_VOLTAGE, \
@@ -265,6 +267,8 @@ static const struct regulator_desc act8600_regulators[] = { · 14 unmodified lines
265	ACT88xx_REG("DCDC3", ACT8600, DCDC3, VSET, "vp3"),	267	ACT88xx_REG("DCDC3", ACT8600, DCDC3, VSET, "vp3"),
266	{	268	{
267	.name = "SUDCDC_REG4",	269	.name = "SUDCDC_REG4",
		270	.of_match = of_match_ptr("SUDCDC_REG4"),
		271	.regulators_node = of_match_ptr("regulators"),
268	.id = ACT8600_ID_SUDCDC4,	272	.id = ACT8600_ID_SUDCDC4,
269	.ops = &act8865_ops,	273	.ops = &act8865_ops,
270	.type = REGULATOR_VOLTAGE,	274	.type = REGULATOR_VOLTAGE,
@@ -283,6 +287,8 @@ static const struct regulator_desc act8600_regulators[] = { · 12 unmodified lines
283	ACT88xx_REG("LDO8", ACT8600, LDO8, VSET, "inl"),	287	ACT88xx_REG("LDO8", ACT8600, LDO8, VSET, "inl"),
284	{	288	{
285	.name = "LDO_REG9",	289	.name = "LDO_REG9",
		290	.of_match = of_match_ptr("LDO_REG9"),
		291	.regulators_node = of_match_ptr("regulators"),
286	.id = ACT8600_ID_LDO9,	292	.id = ACT8600_ID_LDO9,
287	.ops = &act8865_ldo_ops,	293	.ops = &act8865_ldo_ops,
288	.type = REGULATOR_VOLTAGE,	294	.type = REGULATOR_VOLTAGE,
@@ -294,6 +300,8 @@ static const struct regulator_desc act8600_regulators[] = { · 5 unmodified lines
294	},	300	},
295	{	301	{
296	.name = "LDO_REG10",	302	.name = "LDO_REG10",
		303	.of_match = of_match_ptr("LDO_REG10"),
		304	.regulators_node = of_match_ptr("regulators"),
297	.id = ACT8600_ID_LDO10,	305	.id = ACT8600_ID_LDO10,
298	.ops = &act8865_ldo_ops,	306	.ops = &act8865_ldo_ops,
299	.type = REGULATOR_VOLTAGE,	307	.type = REGULATOR_VOLTAGE,
@@ -348,110 +356,6 @@ static const struct of_device_id act8865_dt_ids[] = { · 48 unmodified lines
348	{ }	356	{ }
349	};	357	};
350	MODULE_DEVICE_TABLE(of, act8865_dt_ids);	358	MODULE_DEVICE_TABLE(of, act8865_dt_ids);
351
352	static struct of_regulator_match act8846_matches[] = {
353	[ACT8846_ID_REG1] = { .name = "REG1" },
354	[ACT8846_ID_REG2] = { .name = "REG2" },
355	[ACT8846_ID_REG3] = { .name = "REG3" },
356	[ACT8846_ID_REG4] = { .name = "REG4" },
357	[ACT8846_ID_REG5] = { .name = "REG5" },
358	[ACT8846_ID_REG6] = { .name = "REG6" },
359	[ACT8846_ID_REG7] = { .name = "REG7" },
360	[ACT8846_ID_REG8] = { .name = "REG8" },
361	[ACT8846_ID_REG9] = { .name = "REG9" },
362	[ACT8846_ID_REG10] = { .name = "REG10" },
363	[ACT8846_ID_REG11] = { .name = "REG11" },
364	[ACT8846_ID_REG12] = { .name = "REG12" },
365	};
366
367	static struct of_regulator_match act8865_matches[] = {
368	[ACT8865_ID_DCDC1] = { .name = "DCDC_REG1"},
369	[ACT8865_ID_DCDC2] = { .name = "DCDC_REG2"},
370	[ACT8865_ID_DCDC3] = { .name = "DCDC_REG3"},
371	[ACT8865_ID_LDO1] = { .name = "LDO_REG1"},
372	[ACT8865_ID_LDO2] = { .name = "LDO_REG2"},
373	[ACT8865_ID_LDO3] = { .name = "LDO_REG3"},
374	[ACT8865_ID_LDO4] = { .name = "LDO_REG4"},
375	};
376
377	static struct of_regulator_match act8600_matches[] = {
378	[ACT8600_ID_DCDC1] = { .name = "DCDC_REG1"},
379	[ACT8600_ID_DCDC2] = { .name = "DCDC_REG2"},
380	[ACT8600_ID_DCDC3] = { .name = "DCDC_REG3"},
381	[ACT8600_ID_SUDCDC4] = { .name = "SUDCDC_REG4"},
382	[ACT8600_ID_LDO5] = { .name = "LDO_REG5"},
383	[ACT8600_ID_LDO6] = { .name = "LDO_REG6"},
384	[ACT8600_ID_LDO7] = { .name = "LDO_REG7"},
385	[ACT8600_ID_LDO8] = { .name = "LDO_REG8"},
386	[ACT8600_ID_LDO9] = { .name = "LDO_REG9"},
387	[ACT8600_ID_LDO10] = { .name = "LDO_REG10"},
388	};
389
390	static int act8865_pdata_from_dt(struct device *dev,
391	struct act8865_platform_data *pdata,
392	unsigned long type)
393	{
394	int matched, i, num_matches;
395	struct device_node *np;
396	struct act8865_regulator_data *regulator;
397	struct of_regulator_match *matches;
398
399	switch (type) {
400	case ACT8600:
401	matches = act8600_matches;
402	num_matches = ARRAY_SIZE(act8600_matches);
403	break;
404	case ACT8846:
405	matches = act8846_matches;
406	num_matches = ARRAY_SIZE(act8846_matches);
407	break;
408	case ACT8865:
409	matches = act8865_matches;
410	num_matches = ARRAY_SIZE(act8865_matches);
411	break;
412	default:
413	dev_err(dev, "invalid device id %lu\n", type);
414	return -EINVAL;
415	}
416
417	np = of_get_child_by_name(dev->of_node, "regulators");
418	if (!np) {
419	dev_err(dev, "missing 'regulators' subnode in DT\n");
420	return -EINVAL;
421	}
422
423	matched = of_regulator_match(dev, np, matches, num_matches);
424	of_node_put(np);
425	if (matched <= 0)
426	return matched;
427
428	pdata->regulators = devm_kcalloc(dev,
429	num_matches,
430	sizeof(struct act8865_regulator_data),
431	GFP_KERNEL);
432	if (!pdata->regulators)
433	return -ENOMEM;
434
435	pdata->num_regulators = num_matches;
436	regulator = pdata->regulators;
437
438	for (i = 0; i < num_matches; i++) {
439	regulator->id = i;
440	regulator->name = matches[i].name;
441	regulator->init_data = matches[i].init_data;
442	regulator->of_node = matches[i].of_node;
443	regulator++;
444	}
445
446	return 0;
447	}
448	#else
449	static inline int act8865_pdata_from_dt(struct device *dev,
450	struct act8865_platform_data *pdata,
451	unsigned long type)
452	{
453	return 0;
454	}
455	#endif	359	#endif
456		360
457	static struct act8865_regulator_data *act8865_get_regulator_data(	361	static struct act8865_regulator_data *act8865_get_regulator_data(
@@ -459,9 +363,6 @@ static struct act8865_regulator_data *act8865_get_regulator_data( · 1 unmodified line
459	{	363	{
460	int i;	364	int i;
461		365
462	if (!pdata)
463	return NULL;
464
465	for (i = 0; i < pdata->num_regulators; i++) {	366	for (i = 0; i < pdata->num_regulators; i++) {
466	if (pdata->regulators[i].id == id)	367	if (pdata->regulators[i].id == id)
467	return &pdata->regulators[i];	368	return &pdata->regulators[i];
@@ -484,7 +385,7 @@ static int act8865_pmic_probe(struct i2c_client *client, · 16 unmodified lines
484	const struct i2c_device_id *i2c_id)	385	const struct i2c_device_id *i2c_id)
485	{	386	{
486	const struct regulator_desc *regulators;	387	const struct regulator_desc *regulators;
487	struct act8865_platform_data pdata_of, *pdata;	388	struct act8865_platform_data *pdata = NULL;
488	struct device *dev = &client->dev;	389	struct device *dev = &client->dev;
489	int i, ret, num_regulators;	390	int i, ret, num_regulators;
490	struct act8865 *act8865;	391	struct act8865 *act8865;
@@ -493,9 +394,7 @@ static int act8865_pmic_probe(struct i2c_client *client, · 2 unmodified lines
493	int off_reg, off_mask;	394	int off_reg, off_mask;
494	int voltage_select = 0;	395	int voltage_select = 0;
495		396
496	pdata = dev_get_platdata(dev);	397	if (dev->of_node) {
497
498	if (dev->of_node && !pdata) {
499	const struct of_device_id *id;	398	const struct of_device_id *id;
500		399
501	id = of_match_device(of_match_ptr(act8865_dt_ids), dev);	400	id = of_match_device(of_match_ptr(act8865_dt_ids), dev);
@@ -509,6 +408,7 @@ static int act8865_pmic_probe(struct i2c_client *client, · 7 unmodified lines
509	NULL);	408	NULL);
510	} else {	409	} else {
511	type = i2c_id->driver_data;	410	type = i2c_id->driver_data;
		411	pdata = dev_get_platdata(dev);
512	}	412	}
513		413
514	switch (type) {	414	switch (type) {
@@ -543,14 +443,6 @@ static int act8865_pmic_probe(struct i2c_client *client, · 28 unmodified lines
543	return -EINVAL;	443	return -EINVAL;
544	}	444	}
545		445
546	if (dev->of_node && !pdata) {
547	ret = act8865_pdata_from_dt(dev, &pdata_of, type);
548	if (ret < 0)
549	return ret;
550
551	pdata = &pdata_of;
552	}
553
554	act8865 = devm_kzalloc(dev, sizeof(struct act8865), GFP_KERNEL);	446	act8865 = devm_kzalloc(dev, sizeof(struct act8865), GFP_KERNEL);
555	if (!act8865)	447	if (!act8865)
556	return -ENOMEM;	448	return -ENOMEM;
@@ -577,17 +469,20 @@ static int act8865_pmic_probe(struct i2c_client *client, · 20 unmodified lines
577	for (i = 0; i < num_regulators; i++) {	469	for (i = 0; i < num_regulators; i++) {
578	const struct regulator_desc *desc = &regulators[i];	470	const struct regulator_desc *desc = &regulators[i];
579	struct regulator_config config = { };	471	struct regulator_config config = { };
580	struct act8865_regulator_data *rdata;
581	struct regulator_dev *rdev;	472	struct regulator_dev *rdev;
582		473
583	config.dev = dev;	474	config.dev = dev;
584	config.driver_data = act8865;	475	config.driver_data = act8865;
585	config.regmap = act8865->regmap;	476	config.regmap = act8865->regmap;
586		477
587	rdata = act8865_get_regulator_data(desc->id, pdata);	478	if (pdata) {
588	if (rdata) {	479	struct act8865_regulator_data *rdata;
589	config.init_data = rdata->init_data;	480
590	config.of_node = rdata->of_node;	481	rdata = act8865_get_regulator_data(desc->id, pdata);
		482	if (rdata) {
		483	config.init_data = rdata->init_data;
		484	config.of_node = rdata->of_node;
		485	}
591	}	486	}
592		487
593	rdev = devm_regulator_register(dev, desc, &config);	488	rdev = devm_regulator_register(dev, desc, &config);

drivers/regulator/anatop-regulator.c+27−36

 #define LDO_FET_FULL_ON			0x1f
 struct anatop_regulator {
-	u32 control_reg;
-	struct regmap *anatop;
-	int vol_bit_shift;
-	int vol_bit_width;
 	u32 delay_reg;
 	int delay_bit_shift;
 	int delay_bit_width;
-	int min_bit_val;
-	int min_voltage;
-	int max_voltage;
 	struct regulator_desc rdesc;
-	struct regulator_init_data *initdata;
 	bool bypass;
 	int sel;
 };
 		 * to calculate how many steps LDO need to
 		 * ramp up, and how much delay needed. (us)
 		 */
-		regmap_read(anatop_reg->anatop, anatop_reg->delay_reg, &val);
+		regmap_read(reg->regmap, anatop_reg->delay_reg, &val);
 		val = (val >> anatop_reg->delay_bit_shift) &
 			((1 << anatop_reg->delay_bit_width) - 1);
 		ret = (new_sel - old_sel) * (LDO_RAMP_UP_UNIT_IN_CYCLES <<
 	struct anatop_regulator *sreg;
 	struct regulator_init_data *initdata;
 	struct regulator_config config = { };
+	struct regmap *regmap;
+	u32 control_reg;
+	u32 vol_bit_shift;
+	u32 vol_bit_width;
+	u32 min_bit_val;
+	u32 min_voltage;
+	u32 max_voltage;
 	int ret = 0;
 	u32 val;
 		return -ENOMEM;
 	initdata->supply_regulator = "vin";
-	sreg->initdata = initdata;
 	anatop_np = of_get_parent(np);
 	if (!anatop_np)
 		return -ENODEV;
-	sreg->anatop = syscon_node_to_regmap(anatop_np);
+	regmap = syscon_node_to_regmap(anatop_np);
 	of_node_put(anatop_np);
-	if (IS_ERR(sreg->anatop))
+	if (IS_ERR(regmap))
-		return PTR_ERR(sreg->anatop);
+		return PTR_ERR(regmap);
-	ret = of_property_read_u32(np, "anatop-reg-offset",
+	ret = of_property_read_u32(np, "anatop-reg-offset", &control_reg);
-				   &sreg->control_reg);
 	if (ret) {
 		dev_err(dev, "no anatop-reg-offset property set\n");
 		return ret;
 	}
-	ret = of_property_read_u32(np, "anatop-vol-bit-width",
+	ret = of_property_read_u32(np, "anatop-vol-bit-width", &vol_bit_width);
-				   &sreg->vol_bit_width);
 	if (ret) {
 		dev_err(dev, "no anatop-vol-bit-width property set\n");
 		return ret;
 	}
-	ret = of_property_read_u32(np, "anatop-vol-bit-shift",
+	ret = of_property_read_u32(np, "anatop-vol-bit-shift", &vol_bit_shift);
-				   &sreg->vol_bit_shift);
 	if (ret) {
 		dev_err(dev, "no anatop-vol-bit-shift property set\n");
 		return ret;
 	}
-	ret = of_property_read_u32(np, "anatop-min-bit-val",
+	ret = of_property_read_u32(np, "anatop-min-bit-val", &min_bit_val);
-				   &sreg->min_bit_val);
 	if (ret) {
 		dev_err(dev, "no anatop-min-bit-val property set\n");
 		return ret;
 	}
-	ret = of_property_read_u32(np, "anatop-min-voltage",
+	ret = of_property_read_u32(np, "anatop-min-voltage", &min_voltage);
-				   &sreg->min_voltage);
 	if (ret) {
 		dev_err(dev, "no anatop-min-voltage property set\n");
 		return ret;
 	}
-	ret = of_property_read_u32(np, "anatop-max-voltage",
+	ret = of_property_read_u32(np, "anatop-max-voltage", &max_voltage);
-				   &sreg->max_voltage);
 	if (ret) {
 		dev_err(dev, "no anatop-max-voltage property set\n");
 		return ret;
 	of_property_read_u32(np, "anatop-delay-bit-shift",
 			     &sreg->delay_bit_shift);
-	rdesc->n_voltages = (sreg->max_voltage - sreg->min_voltage) / 25000 + 1
+	rdesc->n_voltages = (max_voltage - min_voltage) / 25000 + 1
-			    + sreg->min_bit_val;
+			    + min_bit_val;
-	rdesc->min_uV = sreg->min_voltage;
+	rdesc->min_uV = min_voltage;
 	rdesc->uV_step = 25000;
-	rdesc->linear_min_sel = sreg->min_bit_val;
+	rdesc->linear_min_sel = min_bit_val;
-	rdesc->vsel_reg = sreg->control_reg;
+	rdesc->vsel_reg = control_reg;
-	rdesc->vsel_mask = ((1 << sreg->vol_bit_width) - 1) <<
+	rdesc->vsel_mask = ((1 << vol_bit_width) - 1) << vol_bit_shift;
-			   sreg->vol_bit_shift;
 	rdesc->min_dropout_uV = 125000;
 	config.dev = &pdev->dev;
 	config.init_data = initdata;
 	config.driver_data = sreg;
 	config.of_node = pdev->dev.of_node;
-	config.regmap = sreg->anatop;
+	config.regmap = regmap;
 	/* Only core regulators have the ramp up delay configuration. */
-	if (sreg->control_reg && sreg->delay_bit_width) {
+	if (control_reg && sreg->delay_bit_width) {
 		rdesc->ops = &anatop_core_rops;
 		ret = regmap_read(config.regmap, rdesc->vsel_reg, &val);
 			return ret;
 		}
-		sreg->sel = (val & rdesc->vsel_mask) >> sreg->vol_bit_shift;
+		sreg->sel = (val & rdesc->vsel_mask) >> vol_bit_shift;
 		if (sreg->sel == LDO_FET_FULL_ON) {
 			sreg->sel = 0;
 			sreg->bypass = true;
 			anatop_rops.disable = regulator_disable_regmap;
 			anatop_rops.is_enabled = regulator_is_enabled_regmap;
-			rdesc->enable_reg = sreg->control_reg;
+			rdesc->enable_reg = control_reg;
 			rdesc->enable_mask = BIT(enable_bit);
 		}
 	}

drivers/regulator/arizona-ldo1.c+7−12

@@ -1,15 +1,10 @@
1	/*	1	// SPDX-License-Identifier: GPL-2.0+
2	* arizona-ldo1.c -- LDO1 supply for Arizona devices	2	//
3	*	3	// arizona-ldo1.c -- LDO1 supply for Arizona devices
4	* Copyright 2012 Wolfson Microelectronics PLC.	4	//
5	*	5	// Copyright 2012 Wolfson Microelectronics PLC.
6	* Author: Mark Brown <broonie@opensource.wolfsonmicro.com>	6	//
7	*	7	// Author: Mark Brown <broonie@opensource.wolfsonmicro.com>
8	* This program is free software; you can redistribute it and/or modify it
9	* under the terms of the GNU General Public License as published by the
10	* Free Software Foundation; either version 2 of the License, or (at your
11	* option) any later version.
12	*/
13		8
14	#include <linux/module.h>	9	#include <linux/module.h>
15	#include <linux/moduleparam.h>	10	#include <linux/moduleparam.h>

drivers/regulator/arizona-micsupp.c+7−12

@@ -1,15 +1,10 @@
1	/*	1	// SPDX-License-Identifier: GPL-2.0+
2	* arizona-micsupp.c -- Microphone supply for Arizona devices	2	//
3	*	3	// arizona-micsupp.c -- Microphone supply for Arizona devices
4	* Copyright 2012 Wolfson Microelectronics PLC.	4	//
5	*	5	// Copyright 2012 Wolfson Microelectronics PLC.
6	* Author: Mark Brown <broonie@opensource.wolfsonmicro.com>	6	//
7	*	7	// Author: Mark Brown <broonie@opensource.wolfsonmicro.com>
8	* This program is free software; you can redistribute it and/or modify it
9	* under the terms of the GNU General Public License as published by the
10	* Free Software Foundation; either version 2 of the License, or (at your
11	* option) any later version.
12	*/
13		8
14	#include <linux/module.h>	9	#include <linux/module.h>
15	#include <linux/moduleparam.h>	10	#include <linux/moduleparam.h>

drivers/regulator/as3711-regulator.c+7−30

@@ -17,14 +17,6 @@ · 16 unmodified lines
17	#include <linux/regulator/of_regulator.h>	17	#include <linux/regulator/of_regulator.h>
18	#include <linux/slab.h>	18	#include <linux/slab.h>
19		19
20	struct as3711_regulator_info {
21	struct regulator_desc desc;
22	};
23
24	struct as3711_regulator {
25	struct as3711_regulator_info *reg_info;
26	};
27
28	/*	20	/*
29	* The regulator API supports 4 modes of operataion: FAST, NORMAL, IDLE and	21	* The regulator API supports 4 modes of operataion: FAST, NORMAL, IDLE and
30	* STANDBY. We map them in the following way to AS3711 SD1-4 DCDC modes:	22	* STANDBY. We map them in the following way to AS3711 SD1-4 DCDC modes:
@@ -129,7 +121,6 @@ static const struct regulator_linear_range as3711_dldo_ranges[] = { · 98 unmodified lines
129		121
130	#define AS3711_REG(_id, _en_reg, _en_bit, _vmask, _sfx) \	122	#define AS3711_REG(_id, _en_reg, _en_bit, _vmask, _sfx) \
131	[AS3711_REGULATOR_ ## _id] = { \	123	[AS3711_REGULATOR_ ## _id] = { \
132	.desc = { \
133	.name = "as3711-regulator-" # _id, \	124	.name = "as3711-regulator-" # _id, \
134	.id = AS3711_REGULATOR_ ## _id, \	125	.id = AS3711_REGULATOR_ ## _id, \
135	.n_voltages = (_vmask + 1), \	126	.n_voltages = (_vmask + 1), \
@@ -142,10 +133,9 @@ static const struct regulator_linear_range as3711_dldo_ranges[] = { · 6 unmodified lines
142	.enable_mask = BIT(_en_bit), \	133	.enable_mask = BIT(_en_bit), \
143	.linear_ranges = as3711_ ## _sfx ## _ranges, \	134	.linear_ranges = as3711_ ## _sfx ## _ranges, \
144	.n_linear_ranges = ARRAY_SIZE(as3711_ ## _sfx ## _ranges), \	135	.n_linear_ranges = ARRAY_SIZE(as3711_ ## _sfx ## _ranges), \
145	}, \
146	}	136	}
147		137
148	static struct as3711_regulator_info as3711_reg_info[] = {	138	static const struct regulator_desc as3711_reg_desc[] = {
149	AS3711_REG(SD_1, SD_CONTROL, 0, 0x7f, sd),	139	AS3711_REG(SD_1, SD_CONTROL, 0, 0x7f, sd),
150	AS3711_REG(SD_2, SD_CONTROL, 1, 0x7f, sd),	140	AS3711_REG(SD_2, SD_CONTROL, 1, 0x7f, sd),
151	AS3711_REG(SD_3, SD_CONTROL, 2, 0x7f, sd),	141	AS3711_REG(SD_3, SD_CONTROL, 2, 0x7f, sd),
@@ -161,7 +151,7 @@ static struct as3711_regulator_info as3711_reg_info[] = { · 9 unmodified lines
161	/* StepUp output voltage depends on supplying regulator */	151	/* StepUp output voltage depends on supplying regulator */
162	};	152	};
163		153
164	#define AS3711_REGULATOR_NUM ARRAY_SIZE(as3711_reg_info)	154	#define AS3711_REGULATOR_NUM ARRAY_SIZE(as3711_reg_desc)
165		155
166	static struct of_regulator_match	156	static struct of_regulator_match
167	as3711_regulator_matches[AS3711_REGULATOR_NUM] = {	157	as3711_regulator_matches[AS3711_REGULATOR_NUM] = {
@@ -215,11 +205,8 @@ static int as3711_regulator_probe(struct platform_device *pdev) · 47 unmodified lines
215	struct as3711_regulator_pdata *pdata = dev_get_platdata(&pdev->dev);	205	struct as3711_regulator_pdata *pdata = dev_get_platdata(&pdev->dev);
216	struct as3711 *as3711 = dev_get_drvdata(pdev->dev.parent);	206	struct as3711 *as3711 = dev_get_drvdata(pdev->dev.parent);
217	struct regulator_config config = {.dev = &pdev->dev,};	207	struct regulator_config config = {.dev = &pdev->dev,};
218	struct as3711_regulator *reg = NULL;
219	struct as3711_regulator *regs;
220	struct device_node *of_node[AS3711_REGULATOR_NUM] = {};	208	struct device_node *of_node[AS3711_REGULATOR_NUM] = {};
221	struct regulator_dev *rdev;	209	struct regulator_dev *rdev;
222	struct as3711_regulator_info *ri;
223	int ret;	210	int ret;
224	int id;	211	int id;
225		212
@@ -236,30 +223,20 @@ static int as3711_regulator_probe(struct platform_device *pdev) · 10 unmodified lines
236	}	223	}
237	}	224	}
238		225
239	regs = devm_kcalloc(&pdev->dev,	226	for (id = 0; id < AS3711_REGULATOR_NUM; id++) {
240	AS3711_REGULATOR_NUM,
241	sizeof(struct as3711_regulator),
242	GFP_KERNEL);
243	if (!regs)
244	return -ENOMEM;
245
246	for (id = 0, ri = as3711_reg_info; id < AS3711_REGULATOR_NUM; ++id, ri++) {
247	reg = &regs[id];
248	reg->reg_info = ri;
249
250	config.init_data = pdata->init_data[id];	227	config.init_data = pdata->init_data[id];
251	config.driver_data = reg;
252	config.regmap = as3711->regmap;	228	config.regmap = as3711->regmap;
253	config.of_node = of_node[id];	229	config.of_node = of_node[id];
254		230
255	rdev = devm_regulator_register(&pdev->dev, &ri->desc, &config);	231	rdev = devm_regulator_register(&pdev->dev, &as3711_reg_desc[id],
		232	&config);
256	if (IS_ERR(rdev)) {	233	if (IS_ERR(rdev)) {
257	dev_err(&pdev->dev, "Failed to register regulator %s\n",	234	dev_err(&pdev->dev, "Failed to register regulator %s\n",
258	ri->desc.name);	235	as3711_reg_desc[id].name);
259	return PTR_ERR(rdev);	236	return PTR_ERR(rdev);
260	}	237	}
261	}	238	}
262	platform_set_drvdata(pdev, regs);	239
263	return 0;	240	return 0;
264	}	241	}
265		242

drivers/regulator/as3722-regulator.c+86−201

@@ -81,7 +81,6 @@ struct as3722_regulator_config_data { · 80 unmodified lines
81	struct as3722_regulators {	81	struct as3722_regulators {
82	struct device *dev;	82	struct device *dev;
83	struct as3722 *as3722;	83	struct as3722 *as3722;
84	struct regulator_dev *rdevs[AS3722_REGULATOR_ID_MAX];
85	struct regulator_desc desc[AS3722_REGULATOR_ID_MAX];	84	struct regulator_desc desc[AS3722_REGULATOR_ID_MAX];
86	struct as3722_regulator_config_data	85	struct as3722_regulator_config_data
87	reg_config_data[AS3722_REGULATOR_ID_MAX];	86	reg_config_data[AS3722_REGULATOR_ID_MAX];
@@ -314,63 +313,10 @@ static const struct as3722_register_mapping as3722_reg_lookup[] = { · 226 unmodified lines
314	},	313	},
315	};	314	};
316		315
317		316	static const unsigned int as3722_ldo_current[] = { 150000, 300000 };
318	static const int as3722_ldo_current[] = { 150000, 300000 };	317	static const unsigned int as3722_sd016_current[] = {
319	static const int as3722_sd016_current[] = { 2500000, 3000000, 3500000 };	318	2500000, 3000000, 3500000
320		319	};
321	static int as3722_current_to_index(int min_uA, int max_uA,
322	const int *curr_table, int n_currents)
323	{
324	int i;
325
326	for (i = n_currents - 1; i >= 0; i--) {
327	if ((min_uA <= curr_table[i]) && (curr_table[i] <= max_uA))
328	return i;
329	}
330	return -EINVAL;
331	}
332
333	static int as3722_ldo_get_current_limit(struct regulator_dev *rdev)
334	{
335	struct as3722_regulators *as3722_regs = rdev_get_drvdata(rdev);
336	struct as3722 *as3722 = as3722_regs->as3722;
337	int id = rdev_get_id(rdev);
338	u32 val;
339	int ret;
340
341	ret = as3722_read(as3722, as3722_reg_lookup[id].vsel_reg, &val);
342	if (ret < 0) {
343	dev_err(as3722_regs->dev, "Reg 0x%02x read failed: %d\n",
344	as3722_reg_lookup[id].vsel_reg, ret);
345	return ret;
346	}
347	if (val & AS3722_LDO_ILIMIT_MASK)
348	return 300000;
349	return 150000;
350	}
351
352	static int as3722_ldo_set_current_limit(struct regulator_dev *rdev,
353	int min_uA, int max_uA)
354	{
355	struct as3722_regulators *as3722_regs = rdev_get_drvdata(rdev);
356	struct as3722 *as3722 = as3722_regs->as3722;
357	int id = rdev_get_id(rdev);
358	int ret;
359	u32 reg = 0;
360
361	ret = as3722_current_to_index(min_uA, max_uA, as3722_ldo_current,
362	ARRAY_SIZE(as3722_ldo_current));
363	if (ret < 0) {
364	dev_err(as3722_regs->dev,
365	"Current range min:max = %d:%d does not support\n",
366	min_uA, max_uA);
367	return ret;
368	}
369	if (ret)
370	reg = AS3722_LDO_ILIMIT_BIT;
371	return as3722_update_bits(as3722, as3722_reg_lookup[id].vsel_reg,
372	AS3722_LDO_ILIMIT_MASK, reg);
373	}
374		320
375	static const struct regulator_ops as3722_ldo0_ops = {	321	static const struct regulator_ops as3722_ldo0_ops = {
376	.is_enabled = regulator_is_enabled_regmap,	322	.is_enabled = regulator_is_enabled_regmap,
@@ -379,16 +325,16 @@ static const struct regulator_ops as3722_ldo0_ops = { · 2 unmodified lines
379	.list_voltage = regulator_list_voltage_linear,	325	.list_voltage = regulator_list_voltage_linear,
380	.get_voltage_sel = regulator_get_voltage_sel_regmap,	326	.get_voltage_sel = regulator_get_voltage_sel_regmap,
381	.set_voltage_sel = regulator_set_voltage_sel_regmap,	327	.set_voltage_sel = regulator_set_voltage_sel_regmap,
382	.get_current_limit = as3722_ldo_get_current_limit,	328	.get_current_limit = regulator_get_current_limit_regmap,
383	.set_current_limit = as3722_ldo_set_current_limit,	329	.set_current_limit = regulator_set_current_limit_regmap,
384	};	330	};
385		331
386	static const struct regulator_ops as3722_ldo0_extcntrl_ops = {	332	static const struct regulator_ops as3722_ldo0_extcntrl_ops = {
387	.list_voltage = regulator_list_voltage_linear,	333	.list_voltage = regulator_list_voltage_linear,
388	.get_voltage_sel = regulator_get_voltage_sel_regmap,	334	.get_voltage_sel = regulator_get_voltage_sel_regmap,
389	.set_voltage_sel = regulator_set_voltage_sel_regmap,	335	.set_voltage_sel = regulator_set_voltage_sel_regmap,
390	.get_current_limit = as3722_ldo_get_current_limit,	336	.get_current_limit = regulator_get_current_limit_regmap,
391	.set_current_limit = as3722_ldo_set_current_limit,	337	.set_current_limit = regulator_set_current_limit_regmap,
392	};	338	};
393		339
394	static int as3722_ldo3_set_tracking_mode(struct as3722_regulators *as3722_reg,	340	static int as3722_ldo3_set_tracking_mode(struct as3722_regulators *as3722_reg,
@@ -440,8 +386,8 @@ static const struct regulator_ops as3722_ldo6_ops = { · 45 unmodified lines
440	.set_voltage_sel = regulator_set_voltage_sel_regmap,	386	.set_voltage_sel = regulator_set_voltage_sel_regmap,
441	.get_voltage_sel = regulator_get_voltage_sel_regmap,	387	.get_voltage_sel = regulator_get_voltage_sel_regmap,
442	.list_voltage = regulator_list_voltage_linear_range,	388	.list_voltage = regulator_list_voltage_linear_range,
443	.get_current_limit = as3722_ldo_get_current_limit,	389	.get_current_limit = regulator_get_current_limit_regmap,
444	.set_current_limit = as3722_ldo_set_current_limit,	390	.set_current_limit = regulator_set_current_limit_regmap,
445	.get_bypass = regulator_get_bypass_regmap,	391	.get_bypass = regulator_get_bypass_regmap,
446	.set_bypass = regulator_set_bypass_regmap,	392	.set_bypass = regulator_set_bypass_regmap,
447	};	393	};
@@ -451,8 +397,8 @@ static const struct regulator_ops as3722_ldo6_extcntrl_ops = { · 3 unmodified lines
451	.set_voltage_sel = regulator_set_voltage_sel_regmap,	397	.set_voltage_sel = regulator_set_voltage_sel_regmap,
452	.get_voltage_sel = regulator_get_voltage_sel_regmap,	398	.get_voltage_sel = regulator_get_voltage_sel_regmap,
453	.list_voltage = regulator_list_voltage_linear_range,	399	.list_voltage = regulator_list_voltage_linear_range,
454	.get_current_limit = as3722_ldo_get_current_limit,	400	.get_current_limit = regulator_get_current_limit_regmap,
455	.set_current_limit = as3722_ldo_set_current_limit,	401	.set_current_limit = regulator_set_current_limit_regmap,
456	.get_bypass = regulator_get_bypass_regmap,	402	.get_bypass = regulator_get_bypass_regmap,
457	.set_bypass = regulator_set_bypass_regmap,	403	.set_bypass = regulator_set_bypass_regmap,
458	};	404	};
@@ -471,8 +417,8 @@ static const struct regulator_ops as3722_ldo_ops = { · 12 unmodified lines
471	.set_voltage_sel = regulator_set_voltage_sel_regmap,	417	.set_voltage_sel = regulator_set_voltage_sel_regmap,
472	.get_voltage_sel = regulator_get_voltage_sel_regmap,	418	.get_voltage_sel = regulator_get_voltage_sel_regmap,
473	.list_voltage = regulator_list_voltage_linear_range,	419	.list_voltage = regulator_list_voltage_linear_range,
474	.get_current_limit = as3722_ldo_get_current_limit,	420	.get_current_limit = regulator_get_current_limit_regmap,
475	.set_current_limit = as3722_ldo_set_current_limit,	421	.set_current_limit = regulator_set_current_limit_regmap,
476	};	422	};
477		423
478	static const struct regulator_ops as3722_ldo_extcntrl_ops = {	424	static const struct regulator_ops as3722_ldo_extcntrl_ops = {
@@ -480,8 +426,8 @@ static const struct regulator_ops as3722_ldo_extcntrl_ops = { · 1 unmodified line
480	.set_voltage_sel = regulator_set_voltage_sel_regmap,	426	.set_voltage_sel = regulator_set_voltage_sel_regmap,
481	.get_voltage_sel = regulator_get_voltage_sel_regmap,	427	.get_voltage_sel = regulator_get_voltage_sel_regmap,
482	.list_voltage = regulator_list_voltage_linear_range,	428	.list_voltage = regulator_list_voltage_linear_range,
483	.get_current_limit = as3722_ldo_get_current_limit,	429	.get_current_limit = regulator_get_current_limit_regmap,
484	.set_current_limit = as3722_ldo_set_current_limit,	430	.set_current_limit = regulator_set_current_limit_regmap,
485	};	431	};
486		432
487	static unsigned int as3722_sd_get_mode(struct regulator_dev *rdev)	433	static unsigned int as3722_sd_get_mode(struct regulator_dev *rdev)
@@ -539,85 +485,6 @@ static int as3722_sd_set_mode(struct regulator_dev *rdev, · 51 unmodified lines
539	return ret;	485	return ret;
540	}	486	}
541		487
542	static int as3722_sd016_get_current_limit(struct regulator_dev *rdev)
543	{
544	struct as3722_regulators *as3722_regs = rdev_get_drvdata(rdev);
545	struct as3722 *as3722 = as3722_regs->as3722;
546	int id = rdev_get_id(rdev);
547	u32 val, reg;
548	int mask;
549	int ret;
550
551	switch (id) {
552	case AS3722_REGULATOR_ID_SD0:
553	reg = AS3722_OVCURRENT_REG;
554	mask = AS3722_OVCURRENT_SD0_TRIP_MASK;
555	break;
556	case AS3722_REGULATOR_ID_SD1:
557	reg = AS3722_OVCURRENT_REG;
558	mask = AS3722_OVCURRENT_SD1_TRIP_MASK;
559	break;
560	case AS3722_REGULATOR_ID_SD6:
561	reg = AS3722_OVCURRENT_DEB_REG;
562	mask = AS3722_OVCURRENT_SD6_TRIP_MASK;
563	break;
564	default:
565	return -EINVAL;
566	}
567	ret = as3722_read(as3722, reg, &val);
568	if (ret < 0) {
569	dev_err(as3722_regs->dev, "Reg 0x%02x read failed: %d\n",
570	reg, ret);
571	return ret;
572	}
573	val &= mask;
574	val >>= ffs(mask) - 1;
575	if (val == 3)
576	return -EINVAL;
577	return as3722_sd016_current[val];
578	}
579
580	static int as3722_sd016_set_current_limit(struct regulator_dev *rdev,
581	int min_uA, int max_uA)
582	{
583	struct as3722_regulators *as3722_regs = rdev_get_drvdata(rdev);
584	struct as3722 *as3722 = as3722_regs->as3722;
585	int id = rdev_get_id(rdev);
586	int ret;
587	int val;
588	int mask;
589	u32 reg;
590
591	ret = as3722_current_to_index(min_uA, max_uA, as3722_sd016_current,
592	ARRAY_SIZE(as3722_sd016_current));
593	if (ret < 0) {
594	dev_err(as3722_regs->dev,
595	"Current range min:max = %d:%d does not support\n",
596	min_uA, max_uA);
597	return ret;
598	}
599
600	switch (id) {
601	case AS3722_REGULATOR_ID_SD0:
602	reg = AS3722_OVCURRENT_REG;
603	mask = AS3722_OVCURRENT_SD0_TRIP_MASK;
604	break;
605	case AS3722_REGULATOR_ID_SD1:
606	reg = AS3722_OVCURRENT_REG;
607	mask = AS3722_OVCURRENT_SD1_TRIP_MASK;
608	break;
609	case AS3722_REGULATOR_ID_SD6:
610	reg = AS3722_OVCURRENT_DEB_REG;
611	mask = AS3722_OVCURRENT_SD6_TRIP_MASK;
612	break;
613	default:
614	return -EINVAL;
615	}
616	ret <<= ffs(mask) - 1;
617	val = ret & mask;
618	return as3722_update_bits(as3722, reg, mask, val);
619	}
620
621	static bool as3722_sd0_is_low_voltage(struct as3722_regulators *as3722_regs)	488	static bool as3722_sd0_is_low_voltage(struct as3722_regulators *as3722_regs)
622	{	489	{
623	int err;	490	int err;
@@ -649,8 +516,8 @@ static const struct regulator_ops as3722_sd016_ops = { · 25 unmodified lines
649	.map_voltage = regulator_map_voltage_linear,	516	.map_voltage = regulator_map_voltage_linear,
650	.get_voltage_sel = regulator_get_voltage_sel_regmap,	517	.get_voltage_sel = regulator_get_voltage_sel_regmap,
651	.set_voltage_sel = regulator_set_voltage_sel_regmap,	518	.set_voltage_sel = regulator_set_voltage_sel_regmap,
652	.get_current_limit = as3722_sd016_get_current_limit,	519	.get_current_limit = regulator_get_current_limit_regmap,
653	.set_current_limit = as3722_sd016_set_current_limit,	520	.set_current_limit = regulator_set_current_limit_regmap,
654	.get_mode = as3722_sd_get_mode,	521	.get_mode = as3722_sd_get_mode,
655	.set_mode = as3722_sd_set_mode,	522	.set_mode = as3722_sd_set_mode,
656	};	523	};
@@ -660,8 +527,8 @@ static const struct regulator_ops as3722_sd016_extcntrl_ops = { · 3 unmodified lines
660	.map_voltage = regulator_map_voltage_linear,	527	.map_voltage = regulator_map_voltage_linear,
661	.get_voltage_sel = regulator_get_voltage_sel_regmap,	528	.get_voltage_sel = regulator_get_voltage_sel_regmap,
662	.set_voltage_sel = regulator_set_voltage_sel_regmap,	529	.set_voltage_sel = regulator_set_voltage_sel_regmap,
663	.get_current_limit = as3722_sd016_get_current_limit,	530	.get_current_limit = regulator_get_current_limit_regmap,
664	.set_current_limit = as3722_sd016_set_current_limit,	531	.set_current_limit = regulator_set_current_limit_regmap,
665	.get_mode = as3722_sd_get_mode,	532	.get_mode = as3722_sd_get_mode,
666	.set_mode = as3722_sd_set_mode,	533	.set_mode = as3722_sd_set_mode,
667	};	534	};
@@ -807,42 +674,45 @@ static int as3722_regulator_probe(struct platform_device *pdev) · 139 unmodified lines
807	config.regmap = as3722->regmap;	674	config.regmap = as3722->regmap;
808		675
809	for (id = 0; id < AS3722_REGULATOR_ID_MAX; id++) {	676	for (id = 0; id < AS3722_REGULATOR_ID_MAX; id++) {
		677	struct regulator_desc *desc;
		678
		679	desc = &as3722_regs->desc[id];
810	reg_config = &as3722_regs->reg_config_data[id];	680	reg_config = &as3722_regs->reg_config_data[id];
811		681
812	as3722_regs->desc[id].name = as3722_reg_lookup[id].name;	682	desc->name = as3722_reg_lookup[id].name;
813	as3722_regs->desc[id].supply_name = as3722_reg_lookup[id].sname;	683	desc->supply_name = as3722_reg_lookup[id].sname;
814	as3722_regs->desc[id].id = as3722_reg_lookup[id].regulator_id;	684	desc->id = as3722_reg_lookup[id].regulator_id;
815	as3722_regs->desc[id].n_voltages =	685	desc->n_voltages = as3722_reg_lookup[id].n_voltages;
816	as3722_reg_lookup[id].n_voltages;	686	desc->type = REGULATOR_VOLTAGE;
817	as3722_regs->desc[id].type = REGULATOR_VOLTAGE;	687	desc->owner = THIS_MODULE;
818	as3722_regs->desc[id].owner = THIS_MODULE;	688	desc->enable_reg = as3722_reg_lookup[id].enable_reg;
819	as3722_regs->desc[id].enable_reg =	689	desc->enable_mask = as3722_reg_lookup[id].enable_mask;
820	as3722_reg_lookup[id].enable_reg;	690	desc->vsel_reg = as3722_reg_lookup[id].vsel_reg;
821	as3722_regs->desc[id].enable_mask =	691	desc->vsel_mask = as3722_reg_lookup[id].vsel_mask;
822	as3722_reg_lookup[id].enable_mask;
823	as3722_regs->desc[id].vsel_reg = as3722_reg_lookup[id].vsel_reg;
824	as3722_regs->desc[id].vsel_mask =
825	as3722_reg_lookup[id].vsel_mask;
826	switch (id) {	692	switch (id) {
827	case AS3722_REGULATOR_ID_LDO0:	693	case AS3722_REGULATOR_ID_LDO0:
828	if (reg_config->ext_control)	694	if (reg_config->ext_control)
829	ops = &as3722_ldo0_extcntrl_ops;	695	ops = &as3722_ldo0_extcntrl_ops;
830	else	696	else
831	ops = &as3722_ldo0_ops;	697	ops = &as3722_ldo0_ops;
832	as3722_regs->desc[id].min_uV = 825000;	698	desc->min_uV = 825000;
833	as3722_regs->desc[id].uV_step = 25000;	699	desc->uV_step = 25000;
834	as3722_regs->desc[id].linear_min_sel = 1;	700	desc->linear_min_sel = 1;
835	as3722_regs->desc[id].enable_time = 500;	701	desc->enable_time = 500;
		702	desc->curr_table = as3722_ldo_current;
		703	desc->n_current_limits = ARRAY_SIZE(as3722_ldo_current);
		704	desc->csel_reg = as3722_reg_lookup[id].vsel_reg;
		705	desc->csel_mask = AS3722_LDO_ILIMIT_MASK;
836	break;	706	break;
837	case AS3722_REGULATOR_ID_LDO3:	707	case AS3722_REGULATOR_ID_LDO3:
838	if (reg_config->ext_control)	708	if (reg_config->ext_control)
839	ops = &as3722_ldo3_extcntrl_ops;	709	ops = &as3722_ldo3_extcntrl_ops;
840	else	710	else
841	ops = &as3722_ldo3_ops;	711	ops = &as3722_ldo3_ops;
842	as3722_regs->desc[id].min_uV = 620000;	712	desc->min_uV = 620000;
843	as3722_regs->desc[id].uV_step = 20000;	713	desc->uV_step = 20000;
844	as3722_regs->desc[id].linear_min_sel = 1;	714	desc->linear_min_sel = 1;
845	as3722_regs->desc[id].enable_time = 500;	715	desc->enable_time = 500;
846	if (reg_config->enable_tracking) {	716	if (reg_config->enable_tracking) {
847	ret = as3722_ldo3_set_tracking_mode(as3722_regs,	717	ret = as3722_ldo3_set_tracking_mode(as3722_regs,
848	id, AS3722_LDO3_MODE_PMOS_TRACKING);	718	id, AS3722_LDO3_MODE_PMOS_TRACKING);
@@ -859,18 +729,17 @@ static int as3722_regulator_probe(struct platform_device *pdev) · 10 unmodified lines
859	ops = &as3722_ldo6_extcntrl_ops;	729	ops = &as3722_ldo6_extcntrl_ops;
860	else	730	else
861	ops = &as3722_ldo6_ops;	731	ops = &as3722_ldo6_ops;
862	as3722_regs->desc[id].enable_time = 500;	732	desc->enable_time = 500;
863	as3722_regs->desc[id].bypass_reg =	733	desc->bypass_reg = AS3722_LDO6_VOLTAGE_REG;
864	AS3722_LDO6_VOLTAGE_REG;	734	desc->bypass_mask = AS3722_LDO_VSEL_MASK;
865	as3722_regs->desc[id].bypass_mask =	735	desc->bypass_val_on = AS3722_LDO6_VSEL_BYPASS;
866	AS3722_LDO_VSEL_MASK;	736	desc->bypass_val_off = AS3722_LDO6_VSEL_BYPASS;
867	as3722_regs->desc[id].bypass_val_on =	737	desc->linear_ranges = as3722_ldo_ranges;
868	AS3722_LDO6_VSEL_BYPASS;	738	desc->n_linear_ranges = ARRAY_SIZE(as3722_ldo_ranges);
869	as3722_regs->desc[id].bypass_val_off =	739	desc->curr_table = as3722_ldo_current;
870	AS3722_LDO6_VSEL_BYPASS;	740	desc->n_current_limits = ARRAY_SIZE(as3722_ldo_current);
871	as3722_regs->desc[id].linear_ranges = as3722_ldo_ranges;	741	desc->csel_reg = as3722_reg_lookup[id].vsel_reg;
872	as3722_regs->desc[id].n_linear_ranges =	742	desc->csel_mask = AS3722_LDO_ILIMIT_MASK;
873	ARRAY_SIZE(as3722_ldo_ranges);
874	break;	743	break;
875	case AS3722_REGULATOR_ID_SD0:	744	case AS3722_REGULATOR_ID_SD0:
876	case AS3722_REGULATOR_ID_SD1:	745	case AS3722_REGULATOR_ID_SD1:
@@ -889,9 +758,25 @@ static int as3722_regulator_probe(struct platform_device *pdev) · 12 unmodified lines
889	AS3722_SD0_VSEL_MAX + 1;	758	AS3722_SD0_VSEL_MAX + 1;
890	as3722_regs->desc[id].min_uV = 610000;	759	as3722_regs->desc[id].min_uV = 610000;
891	}	760	}
892	as3722_regs->desc[id].uV_step = 10000;	761	desc->uV_step = 10000;
893	as3722_regs->desc[id].linear_min_sel = 1;	762	desc->linear_min_sel = 1;
894	as3722_regs->desc[id].enable_time = 600;	763	desc->enable_time = 600;
		764	desc->curr_table = as3722_sd016_current;
		765	desc->n_current_limits =
		766	ARRAY_SIZE(as3722_sd016_current);
		767	if (id == AS3722_REGULATOR_ID_SD0) {
		768	desc->csel_reg = AS3722_OVCURRENT_REG;
		769	desc->csel_mask =
		770	AS3722_OVCURRENT_SD0_TRIP_MASK;
		771	} else if (id == AS3722_REGULATOR_ID_SD1) {
		772	desc->csel_reg = AS3722_OVCURRENT_REG;
		773	desc->csel_mask =
		774	AS3722_OVCURRENT_SD1_TRIP_MASK;
		775	} else if (id == AS3722_REGULATOR_ID_SD6) {
		776	desc->csel_reg = AS3722_OVCURRENT_DEB_REG;
		777	desc->csel_mask =
		778	AS3722_OVCURRENT_SD6_TRIP_MASK;
		779	}
895	break;	780	break;
896	case AS3722_REGULATOR_ID_SD2:	781	case AS3722_REGULATOR_ID_SD2:
897	case AS3722_REGULATOR_ID_SD3:	782	case AS3722_REGULATOR_ID_SD3:
@@ -901,9 +786,8 @@ static int as3722_regulator_probe(struct platform_device *pdev) · 3 unmodified lines
901	ops = &as3722_sd2345_extcntrl_ops;	786	ops = &as3722_sd2345_extcntrl_ops;
902	else	787	else
903	ops = &as3722_sd2345_ops;	788	ops = &as3722_sd2345_ops;
904	as3722_regs->desc[id].linear_ranges =	789	desc->linear_ranges = as3722_sd2345_ranges;
905	as3722_sd2345_ranges;	790	desc->n_linear_ranges =
906	as3722_regs->desc[id].n_linear_ranges =
907	ARRAY_SIZE(as3722_sd2345_ranges);	791	ARRAY_SIZE(as3722_sd2345_ranges);
908	break;	792	break;
909	default:	793	default:
@@ -911,17 +795,19 @@ static int as3722_regulator_probe(struct platform_device *pdev) · 1 unmodified line
911	ops = &as3722_ldo_extcntrl_ops;	795	ops = &as3722_ldo_extcntrl_ops;
912	else	796	else
913	ops = &as3722_ldo_ops;	797	ops = &as3722_ldo_ops;
914	as3722_regs->desc[id].enable_time = 500;	798	desc->enable_time = 500;
915	as3722_regs->desc[id].linear_ranges = as3722_ldo_ranges;	799	desc->linear_ranges = as3722_ldo_ranges;
916	as3722_regs->desc[id].n_linear_ranges =	800	desc->n_linear_ranges = ARRAY_SIZE(as3722_ldo_ranges);
917	ARRAY_SIZE(as3722_ldo_ranges);	801	desc->curr_table = as3722_ldo_current;
		802	desc->n_current_limits = ARRAY_SIZE(as3722_ldo_current);
		803	desc->csel_reg = as3722_reg_lookup[id].vsel_reg;
		804	desc->csel_mask = AS3722_LDO_ILIMIT_MASK;
918	break;	805	break;
919	}	806	}
920	as3722_regs->desc[id].ops = ops;	807	desc->ops = ops;
921	config.init_data = reg_config->reg_init;	808	config.init_data = reg_config->reg_init;
922	config.of_node = as3722_regulator_matches[id].of_node;	809	config.of_node = as3722_regulator_matches[id].of_node;
923	rdev = devm_regulator_register(&pdev->dev,	810	rdev = devm_regulator_register(&pdev->dev, desc, &config);
924	&as3722_regs->desc[id], &config);
925	if (IS_ERR(rdev)) {	811	if (IS_ERR(rdev)) {
926	ret = PTR_ERR(rdev);	812	ret = PTR_ERR(rdev);
927	dev_err(&pdev->dev, "regulator %d register failed %d\n",	813	dev_err(&pdev->dev, "regulator %d register failed %d\n",
@@ -929,7 +815,6 @@ static int as3722_regulator_probe(struct platform_device *pdev) · 1 unmodified line
929	return ret;	815	return ret;
930	}	816	}
931		817
932	as3722_regs->rdevs[id] = rdev;
933	if (reg_config->ext_control) {	818	if (reg_config->ext_control) {
934	ret = regulator_enable_regmap(rdev);	819	ret = regulator_enable_regmap(rdev);
935	if (ret < 0) {	820	if (ret < 0) {

drivers/regulator/axp20x-regulator.c+8−15

 static int axp20x_set_ramp_delay(struct regulator_dev *rdev, int ramp)
 {
 	struct axp20x_dev *axp20x = rdev_get_drvdata(rdev);
-	const struct regulator_desc *desc;
+	int id = rdev_get_id(rdev);
 	u8 reg, mask, enable, cfg = 0xff;
 	const int *slew_rates;
 	int rate_count = 0;
-	desc = rdev->desc;
 	switch (axp20x->variant) {
 	case AXP209_ID:
-		if (desc->id == AXP20X_DCDC2) {
+		if (id == AXP20X_DCDC2) {
 			slew_rates = axp209_dcdc2_ldo3_slew_rates;
 			rate_count = ARRAY_SIZE(axp209_dcdc2_ldo3_slew_rates);
 			reg = AXP20X_DCDC2_LDO3_V_RAMP;
 			break;
 		}
-		if (desc->id == AXP20X_LDO3) {
+		if (id == AXP20X_LDO3) {
 			slew_rates = axp209_dcdc2_ldo3_slew_rates;
 			rate_count = ARRAY_SIZE(axp209_dcdc2_ldo3_slew_rates);
 			reg = AXP20X_DCDC2_LDO3_V_RAMP;
 static int axp20x_regulator_enable_regmap(struct regulator_dev *rdev)
 {
 	struct axp20x_dev *axp20x = rdev_get_drvdata(rdev);
-	const struct regulator_desc *desc;
+	int id = rdev_get_id(rdev);
-	if (!rdev)
-		return -EINVAL;
-	desc = rdev->desc;
 	switch (axp20x->variant) {
 	case AXP209_ID:
-		if ((desc->id == AXP20X_LDO3) &&
+		if ((id == AXP20X_LDO3) &&
 		    rdev->constraints && rdev->constraints->soft_start) {
 			int v_out;
 			int ret;
 		 * (See include/linux/mfd/axp20x.h)
 		 */
 		reg = AXP803_DCDC_FREQ_CTRL;
-		/* Fall through to the check below.*/
+		/* Fall through - to the check below.*/
 	case AXP806_ID:
 		/*
 		 * AXP806 also have DCDC work frequency setting register at a
 		break;
 	case AXP806_ID:
-		reg = AXP806_DCDC_MODE_CTRL2;
 		/*
 		 * AXP806 DCDC regulator IDs have the same range as AXP22X.
-		 * Fall through to the check below.
 		 * (See include/linux/mfd/axp20x.h)
 		 */
+		reg = AXP806_DCDC_MODE_CTRL2;
+		 /* Fall through - to the check below. */
 	case AXP221_ID:
 	case AXP223_ID:
 	case AXP809_ID:

drivers/regulator/bcm590xx-regulator.c+2−103

@@ -103,10 +103,6 @@ · 102 unmodified lines
103	((n > BCM590XX_REG_VSR) && (n < BCM590XX_REG_VBUS))	103	((n > BCM590XX_REG_VSR) && (n < BCM590XX_REG_VBUS))
104	#define BCM590XX_REG_IS_VBUS(n) (n == BCM590XX_REG_VBUS)	104	#define BCM590XX_REG_IS_VBUS(n) (n == BCM590XX_REG_VBUS)
105		105
106	struct bcm590xx_board {
107	struct regulator_init_data *bcm590xx_pmu_init_data[BCM590XX_NUM_REGS];
108	};
109
110	/* LDO group A: supported voltages in microvolts */	106	/* LDO group A: supported voltages in microvolts */
111	static const unsigned int ldo_a_table[] = {	107	static const unsigned int ldo_a_table[] = {
112	1200000, 1800000, 2500000, 2700000, 2800000,	108	1200000, 1800000, 2500000, 2700000, 2800000,
@@ -280,105 +276,15 @@ static const struct regulator_ops bcm590xx_ops_vbus = { · 167 unmodified lines
280	.disable = regulator_disable_regmap,	276	.disable = regulator_disable_regmap,
281	};	277	};
282		278
283	#define BCM590XX_MATCH(_name, _id) \
284	{ \
285	.name = #_name, \
286	.driver_data = (void *)&bcm590xx_regs[BCM590XX_REG_##_id], \
287	}
288
289	static struct of_regulator_match bcm590xx_matches[] = {
290	BCM590XX_MATCH(rfldo, RFLDO),
291	BCM590XX_MATCH(camldo1, CAMLDO1),
292	BCM590XX_MATCH(camldo2, CAMLDO2),
293	BCM590XX_MATCH(simldo1, SIMLDO1),
294	BCM590XX_MATCH(simldo2, SIMLDO2),
295	BCM590XX_MATCH(sdldo, SDLDO),
296	BCM590XX_MATCH(sdxldo, SDXLDO),
297	BCM590XX_MATCH(mmcldo1, MMCLDO1),
298	BCM590XX_MATCH(mmcldo2, MMCLDO2),
299	BCM590XX_MATCH(audldo, AUDLDO),
300	BCM590XX_MATCH(micldo, MICLDO),
301	BCM590XX_MATCH(usbldo, USBLDO),
302	BCM590XX_MATCH(vibldo, VIBLDO),
303	BCM590XX_MATCH(csr, CSR),
304	BCM590XX_MATCH(iosr1, IOSR1),
305	BCM590XX_MATCH(iosr2, IOSR2),
306	BCM590XX_MATCH(msr, MSR),
307	BCM590XX_MATCH(sdsr1, SDSR1),
308	BCM590XX_MATCH(sdsr2, SDSR2),
309	BCM590XX_MATCH(vsr, VSR),
310	BCM590XX_MATCH(gpldo1, GPLDO1),
311	BCM590XX_MATCH(gpldo2, GPLDO2),
312	BCM590XX_MATCH(gpldo3, GPLDO3),
313	BCM590XX_MATCH(gpldo4, GPLDO4),
314	BCM590XX_MATCH(gpldo5, GPLDO5),
315	BCM590XX_MATCH(gpldo6, GPLDO6),
316	BCM590XX_MATCH(vbus, VBUS),
317	};
318
319	static struct bcm590xx_board *bcm590xx_parse_dt_reg_data(
320	struct platform_device *pdev,
321	struct of_regulator_match **bcm590xx_reg_matches)
322	{
323	struct bcm590xx_board *data;
324	struct device_node *np = pdev->dev.parent->of_node;
325	struct device_node *regulators;
326	struct of_regulator_match *matches = bcm590xx_matches;
327	int count = ARRAY_SIZE(bcm590xx_matches);
328	int idx = 0;
329	int ret;
330
331	if (!np) {
332	dev_err(&pdev->dev, "of node not found\n");
333	return NULL;
334	}
335
336	data = devm_kzalloc(&pdev->dev, sizeof(*data), GFP_KERNEL);
337	if (!data)
338	return NULL;
339
340	np = of_node_get(np);
341	regulators = of_get_child_by_name(np, "regulators");
342	if (!regulators) {
343	dev_warn(&pdev->dev, "regulator node not found\n");
344	return NULL;
345	}
346
347	ret = of_regulator_match(&pdev->dev, regulators, matches, count);
348	of_node_put(regulators);
349	if (ret < 0) {
350	dev_err(&pdev->dev, "Error parsing regulator init data: %d\n",
351	ret);
352	return NULL;
353	}
354
355	*bcm590xx_reg_matches = matches;
356
357	for (idx = 0; idx < count; idx++) {
358	if (!matches[idx].init_data \|\| !matches[idx].of_node)
359	continue;
360
361	data->bcm590xx_pmu_init_data[idx] = matches[idx].init_data;
362	}
363
364	return data;
365	}
366
367	static int bcm590xx_probe(struct platform_device *pdev)	279	static int bcm590xx_probe(struct platform_device *pdev)
368	{	280	{
369	struct bcm590xx *bcm590xx = dev_get_drvdata(pdev->dev.parent);	281	struct bcm590xx *bcm590xx = dev_get_drvdata(pdev->dev.parent);
370	struct bcm590xx_board *pmu_data = NULL;
371	struct bcm590xx_reg *pmu;	282	struct bcm590xx_reg *pmu;
372	struct regulator_config config = { };	283	struct regulator_config config = { };
373	struct bcm590xx_info *info;	284	struct bcm590xx_info *info;
374	struct regulator_init_data *reg_data;
375	struct regulator_dev *rdev;	285	struct regulator_dev *rdev;
376	struct of_regulator_match *bcm590xx_reg_matches = NULL;
377	int i;	286	int i;
378		287
379	pmu_data = bcm590xx_parse_dt_reg_data(pdev,
380	&bcm590xx_reg_matches);
381
382	pmu = devm_kzalloc(&pdev->dev, sizeof(*pmu), GFP_KERNEL);	288	pmu = devm_kzalloc(&pdev->dev, sizeof(*pmu), GFP_KERNEL);
383	if (!pmu)	289	if (!pmu)
384	return -ENOMEM;	290	return -ENOMEM;
@@ -397,13 +303,10 @@ static int bcm590xx_probe(struct platform_device *pdev) · 12 unmodified lines
397	info = bcm590xx_regs;	303	info = bcm590xx_regs;
398		304
399	for (i = 0; i < BCM590XX_NUM_REGS; i++, info++) {	305	for (i = 0; i < BCM590XX_NUM_REGS; i++, info++) {
400	if (pmu_data)
401	reg_data = pmu_data->bcm590xx_pmu_init_data[i];
402	else
403	reg_data = NULL;
404
405	/* Register the regulators */	306	/* Register the regulators */
406	pmu->desc[i].name = info->name;	307	pmu->desc[i].name = info->name;
		308	pmu->desc[i].of_match = of_match_ptr(info->name);
		309	pmu->desc[i].regulators_node = of_match_ptr("regulators");
407	pmu->desc[i].supply_name = info->vin_name;	310	pmu->desc[i].supply_name = info->vin_name;
408	pmu->desc[i].id = i;	311	pmu->desc[i].id = i;
409	pmu->desc[i].volt_table = info->volt_table;	312	pmu->desc[i].volt_table = info->volt_table;
@@ -433,16 +336,12 @@ static int bcm590xx_probe(struct platform_device *pdev) · 23 unmodified lines
433	pmu->desc[i].owner = THIS_MODULE;	336	pmu->desc[i].owner = THIS_MODULE;
434		337
435	config.dev = bcm590xx->dev;	338	config.dev = bcm590xx->dev;
436	config.init_data = reg_data;
437	config.driver_data = pmu;	339	config.driver_data = pmu;
438	if (BCM590XX_REG_IS_GPLDO(i) \|\| BCM590XX_REG_IS_VBUS(i))	340	if (BCM590XX_REG_IS_GPLDO(i) \|\| BCM590XX_REG_IS_VBUS(i))
439	config.regmap = bcm590xx->regmap_sec;	341	config.regmap = bcm590xx->regmap_sec;
440	else	342	else
441	config.regmap = bcm590xx->regmap_pri;	343	config.regmap = bcm590xx->regmap_pri;
442		344
443	if (bcm590xx_reg_matches)
444	config.of_node = bcm590xx_reg_matches[i].of_node;
445
446	rdev = devm_regulator_register(&pdev->dev, &pmu->desc[i],	345	rdev = devm_regulator_register(&pdev->dev, &pmu->desc[i],
447	&config);	346	&config);
448	if (IS_ERR(rdev)) {	347	if (IS_ERR(rdev)) {

drivers/regulator/bd718x7-regulator.c+2−2

@@ -27,8 +27,8 @@ · 26 unmodified lines
27	static int bd718xx_buck1234_set_ramp_delay(struct regulator_dev *rdev,	27	static int bd718xx_buck1234_set_ramp_delay(struct regulator_dev *rdev,
28	int ramp_delay)	28	int ramp_delay)
29	{	29	{
30	int id = rdev->desc->id;	30	int id = rdev_get_id(rdev);
31	unsigned int ramp_value = BUCK_RAMPRATE_10P00MV;	31	unsigned int ramp_value;
32		32
33	dev_dbg(&rdev->dev, "Buck[%d] Set Ramp = %d\n", id + 1,	33	dev_dbg(&rdev->dev, "Buck[%d] Set Ramp = %d\n", id + 1,
34	ramp_delay);	34	ramp_delay);

drivers/regulator/core.c+9−6

 		 * We'll only apply the initial system load if an
 		 * initial mode wasn't specified.
 		 */
-		regulator_lock(rdev);
 		drms_uA_update(rdev);
-		regulator_unlock(rdev);
 	}
 	if ((rdev->constraints->ramp_delay || rdev->constraints->ramp_disable)
  * @min_uV: Minimum required voltage in uV.
  * @max_uV: Maximum required voltage in uV.
  *
- * Returns a boolean or a negative error code.
+ * Returns a boolean.
  */
 int regulator_is_supported_voltage(struct regulator *regulator,
 				   int min_uV, int max_uV)
 	ret = regulator_count_voltages(regulator);
 	if (ret < 0)
-		return ret;
+		return 0;
 	voltages = ret;
 	for (i = 0; i < voltages; i++) {
 						      consumers[i].supply);
 		if (IS_ERR(consumers[i].consumer)) {
 			ret = PTR_ERR(consumers[i].consumer);
-			dev_err(dev, "Failed to get supply '%s': %d\n",
-				consumers[i].supply, ret);
 			consumers[i].consumer = NULL;
 			goto err;
 		}
 	return 0;
 err:
+	if (ret != -EPROBE_DEFER)
+		dev_err(dev, "Failed to get supply '%s': %d\n",
+			consumers[i].supply, ret);
+	else
+		dev_dbg(dev, "Failed to get supply '%s', deferring\n",
+			consumers[i].supply);
 	while (--i >= 0)
 		regulator_put(consumers[i].consumer);

drivers/regulator/cpcap-regulator.c+4−11

 static int cpcap_regulator_probe(struct platform_device *pdev)
 {
 	struct cpcap_ddata *ddata;
-	const struct of_device_id *match;
+	const struct cpcap_regulator *match_data;
 	struct regulator_config config;
-	struct regulator_init_data init_data;
 	int i;
-	match = of_match_device(of_match_ptr(cpcap_regulator_id_table),
+	match_data = of_device_get_match_data(&pdev->dev);
-				&pdev->dev);
+	if (!match_data) {
-	if (!match)
-		return -EINVAL;
-	if (!match->data) {
 		dev_err(&pdev->dev, "no configuration data found\n");
 		return -ENODEV;
 		return -ENODEV;
 	ddata->dev = &pdev->dev;
-	ddata->soc = match->data;
+	ddata->soc = match_data;
 	platform_set_drvdata(pdev, ddata);
 	memset(&config, 0, sizeof(config));
-	memset(&init_data, 0, sizeof(init_data));
 	config.dev = &pdev->dev;
 	config.regmap = ddata->reg;
-	config.init_data = &init_data;
 	for (i = 0; i < CPCAP_NR_REGULATORS; i++) {
 		const struct cpcap_regulator *regulator = &ddata->soc[i];

drivers/regulator/da903x.c+6−10

@@ -1,13 +1,9 @@
1	/*	1	// SPDX-License-Identifier: GPL-2.0
2	* Regulators driver for Dialog Semiconductor DA903x	2	//
3	*	3	// Regulators driver for Dialog Semiconductor DA903x
4	* Copyright (C) 2006-2008 Marvell International Ltd.	4	//
5	* Copyright (C) 2008 Compulab Ltd.	5	// Copyright (C) 2006-2008 Marvell International Ltd.
6	*	6	// Copyright (C) 2008 Compulab Ltd.
7	* This program is free software; you can redistribute it and/or modify
8	* it under the terms of the GNU General Public License version 2 as
9	* published by the Free Software Foundation.
10	*/
11		7
12	#include <linux/kernel.h>	8	#include <linux/kernel.h>
13	#include <linux/init.h>	9	#include <linux/init.h>

drivers/regulator/da9052-regulator.c+13−42

-/*
+// SPDX-License-Identifier: GPL-2.0+
-* da9052-regulator.c: Regulator driver for DA9052
+//
-*
+// da9052-regulator.c: Regulator driver for DA9052
-* Copyright(c) 2011 Dialog Semiconductor Ltd.
+//
-*
+// Copyright(c) 2011 Dialog Semiconductor Ltd.
-* Author: David Dajun Chen <dchen@diasemi.com>
+//
-*
+// Author: David Dajun Chen <dchen@diasemi.com>
-* This program is free software; you can redistribute it and/or modify
-* it under the terms of the GNU General Public License as published by
-* the Free Software Foundation; either version 2 of the License, or
-* (at your option) any later version.
-*
-*/
 #include <linux/module.h>
 #include <linux/moduleparam.h>
 #include <linux/platform_device.h>
 #include <linux/regulator/driver.h>
 #include <linux/regulator/machine.h>
-#ifdef CONFIG_OF
 #include <linux/of.h>
 #include <linux/regulator/of_regulator.h>
-#endif
 #include <linux/mfd/da9052/da9052.h>
 #include <linux/mfd/da9052/reg.h>
 {\
 	.reg_desc = {\
 		.name = #_name,\
+		.of_match = of_match_ptr(#_name),\
+		.regulators_node = of_match_ptr("regulators"),\
 		.ops = &da9052_ldo_ops,\
 		.type = REGULATOR_VOLTAGE,\
 		.id = DA9052_ID_##_id,\
 {\
 	.reg_desc = {\
 		.name = #_name,\
+		.of_match = of_match_ptr(#_name),\
+		.regulators_node = of_match_ptr("regulators"),\
 		.ops = &da9052_dcdc_ops,\
 		.type = REGULATOR_VOLTAGE,\
 		.id = DA9052_ID_##_id,\
 		return -EINVAL;
 	}
-	config.dev = &pdev->dev;
+	config.dev = da9052->dev;
 	config.driver_data = regulator;
 	config.regmap = da9052->regmap;
-	if (pdata) {
+	if (pdata)
 		config.init_data = pdata->regulators[cell->id];
-	} else {
-#ifdef CONFIG_OF
-		struct device_node *nproot = da9052->dev->of_node;
-		struct device_node *np;
-		if (!nproot)
-			return -ENODEV;
-		nproot = of_get_child_by_name(nproot, "regulators");
-		if (!nproot)
-			return -ENODEV;
-		for_each_child_of_node(nproot, np) {
-			if (of_node_name_eq(np,
-					 regulator->info->reg_desc.name)) {
-				config.init_data = of_get_regulator_init_data(
-					&pdev->dev, np,
-					&regulator->info->reg_desc);
-				config.of_node = np;
-				break;
-			}
-		}
-		of_node_put(nproot);
-#endif
-	}
 	regulator->rdev = devm_regulator_register(&pdev->dev,
 						  &regulator->info->reg_desc,

drivers/regulator/da9055-regulator.c+15−74

@@ -1,16 +1,10 @@
1	/*	1	// SPDX-License-Identifier: GPL-2.0+
2	* Regulator driver for DA9055 PMIC	2	//
3	*	3	// Regulator driver for DA9055 PMIC
4	* Copyright(c) 2012 Dialog Semiconductor Ltd.	4	//
5	*	5	// Copyright(c) 2012 Dialog Semiconductor Ltd.
6	* Author: David Dajun Chen <dchen@diasemi.com>	6	//
7	*	7	// Author: David Dajun Chen <dchen@diasemi.com>
8	* This program is free software; you can redistribute it and/or modify
9	* it under the terms of the GNU General Public License as published by
10	* the Free Software Foundation; either version 2 of the License, or
11	* (at your option) any later version.
12	*
13	*/
14		8
15	#include <linux/module.h>	9	#include <linux/module.h>
16	#include <linux/init.h>	10	#include <linux/init.h>
@@ -338,6 +332,8 @@ static const struct regulator_ops da9055_ldo_ops = { · 321 unmodified lines
338	{\	332	{\
339	.reg_desc = {\	333	.reg_desc = {\
340	.name = #_id,\	334	.name = #_id,\
		335	.of_match = of_match_ptr(#_id),\
		336	.regulators_node = of_match_ptr("regulators"),\
341	.ops = &da9055_ldo_ops,\	337	.ops = &da9055_ldo_ops,\
342	.type = REGULATOR_VOLTAGE,\	338	.type = REGULATOR_VOLTAGE,\
343	.id = DA9055_ID_##_id,\	339	.id = DA9055_ID_##_id,\
@@ -366,6 +362,8 @@ static const struct regulator_ops da9055_ldo_ops = { · 22 unmodified lines
366	{\	362	{\
367	.reg_desc = {\	363	.reg_desc = {\
368	.name = #_id,\	364	.name = #_id,\
		365	.of_match = of_match_ptr(#_id),\
		366	.regulators_node = of_match_ptr("regulators"),\
369	.ops = &da9055_buck_ops,\	367	.ops = &da9055_buck_ops,\
370	.type = REGULATOR_VOLTAGE,\	368	.type = REGULATOR_VOLTAGE,\
371	.id = DA9055_ID_##_id,\	369	.id = DA9055_ID_##_id,\
@@ -487,8 +485,10 @@ static irqreturn_t da9055_ldo5_6_oc_irq(int irq, void *data) · 115 unmodified lines
487	{	485	{
488	struct da9055_regulator *regulator = data;	486	struct da9055_regulator *regulator = data;
489		487
		488	regulator_lock(regulator->rdev);
490	regulator_notifier_call_chain(regulator->rdev,	489	regulator_notifier_call_chain(regulator->rdev,
491	REGULATOR_EVENT_OVER_CURRENT, NULL);	490	REGULATOR_EVENT_OVER_CURRENT, NULL);
		491	regulator_unlock(regulator->rdev);
492		492
493	return IRQ_HANDLED;	493	return IRQ_HANDLED;
494	}	494	}
@@ -507,59 +507,6 @@ static inline struct da9055_regulator_info *find_regulator_info(int id) · 12 unmodified lines
507	return NULL;	507	return NULL;
508	}	508	}
509		509
510	#ifdef CONFIG_OF
511	static struct of_regulator_match da9055_reg_matches[] = {
512	{ .name = "BUCK1", },
513	{ .name = "BUCK2", },
514	{ .name = "LDO1", },
515	{ .name = "LDO2", },
516	{ .name = "LDO3", },
517	{ .name = "LDO4", },
518	{ .name = "LDO5", },
519	{ .name = "LDO6", },
520	};
521
522	static int da9055_regulator_dt_init(struct platform_device *pdev,
523	struct da9055_regulator *regulator,
524	struct regulator_config *config,
525	int regid)
526	{
527	struct device_node nproot, np;
528	int ret;
529
530	nproot = of_node_get(pdev->dev.parent->of_node);
531	if (!nproot)
532	return -ENODEV;
533
534	np = of_get_child_by_name(nproot, "regulators");
535	if (!np)
536	return -ENODEV;
537
538	ret = of_regulator_match(&pdev->dev, np, &da9055_reg_matches[regid], 1);
539	of_node_put(nproot);
540	if (ret < 0) {
541	dev_err(&pdev->dev, "Error matching regulator: %d\n", ret);
542	return ret;
543	}
544
545	config->init_data = da9055_reg_matches[regid].init_data;
546	config->of_node = da9055_reg_matches[regid].of_node;
547
548	if (!config->of_node)
549	return -ENODEV;
550
551	return 0;
552	}
553	#else
554	static inline int da9055_regulator_dt_init(struct platform_device *pdev,
555	struct da9055_regulator *regulator,
556	struct regulator_config *config,
557	int regid)
558	{
559	return -ENODEV;
560	}
561	#endif /* CONFIG_OF */
562
563	static int da9055_regulator_probe(struct platform_device *pdev)	510	static int da9055_regulator_probe(struct platform_device *pdev)
564	{	511	{
565	struct regulator_config config = { };	512	struct regulator_config config = { };
@@ -580,18 +527,12 @@ static int da9055_regulator_probe(struct platform_device *pdev) · 14 unmodified lines
580	}	527	}
581		528
582	regulator->da9055 = da9055;	529	regulator->da9055 = da9055;
583	config.dev = &pdev->dev;	530	config.dev = da9055->dev;
584	config.driver_data = regulator;	531	config.driver_data = regulator;
585	config.regmap = da9055->regmap;	532	config.regmap = da9055->regmap;
586		533
587	if (pdata) {	534	if (pdata)
588	config.init_data = pdata->regulators[pdev->id];	535	config.init_data = pdata->regulators[pdev->id];
589	} else {
590	ret = da9055_regulator_dt_init(pdev, regulator, &config,
591	pdev->id);
592	if (ret < 0)
593	return ret;
594	}
595		536
596	ret = da9055_gpio_init(regulator, &config, pdata, pdev->id);	537	ret = da9055_gpio_init(regulator, &config, pdata, pdev->id);
597	if (ret < 0)	538	if (ret < 0)

drivers/regulator/da9062-regulator.c+39−107

@@ -1,17 +1,8 @@
1	/*	1	// SPDX-License-Identifier: GPL-2.0+
2	* Regulator device driver for DA9061 and DA9062.	2	//
3	* Copyright (C) 2015-2017 Dialog Semiconductor	3	// Regulator device driver for DA9061 and DA9062.
4	*	4	// Copyright (C) 2015-2017 Dialog Semiconductor
5	* This program is free software; you can redistribute it and/or	5
6	* modify it under the terms of the GNU General Public License
7	* as published by the Free Software Foundation; either version 2
8	* of the License, or (at your option) any later version.
9	*
10	* This program is distributed in the hope that it will be useful,
11	* but WITHOUT ANY WARRANTY; without even the implied warranty of
12	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13	* GNU General Public License for more details.
14	*/
15	#include <linux/kernel.h>	6	#include <linux/kernel.h>
16	#include <linux/module.h>	7	#include <linux/module.h>
17	#include <linux/init.h>	8	#include <linux/init.h>
@@ -53,16 +44,12 @@ enum { · 35 unmodified lines
53	/* Regulator capabilities and registers description */	44	/* Regulator capabilities and registers description */
54	struct da9062_regulator_info {	45	struct da9062_regulator_info {
55	struct regulator_desc desc;	46	struct regulator_desc desc;
56	/* Current limiting */
57	unsigned int n_current_limits;
58	const int *current_limits;
59	/* Main register fields */	47	/* Main register fields */
60	struct reg_field mode;	48	struct reg_field mode;
61	struct reg_field suspend;	49	struct reg_field suspend;
62	struct reg_field sleep;	50	struct reg_field sleep;
63	struct reg_field suspend_sleep;	51	struct reg_field suspend_sleep;
64	unsigned int suspend_vsel_reg;	52	unsigned int suspend_vsel_reg;
65	struct reg_field ilimit;
66	/* Event detection bit */	53	/* Event detection bit */
67	struct reg_field oc_event;	54	struct reg_field oc_event;
68	};	55	};
@@ -78,7 +65,6 @@ struct da9062_regulator { · 9 unmodified lines
78	struct regmap_field *suspend;	65	struct regmap_field *suspend;
79	struct regmap_field *sleep;	66	struct regmap_field *sleep;
80	struct regmap_field *suspend_sleep;	67	struct regmap_field *suspend_sleep;
81	struct regmap_field *ilimit;
82	};	68	};
83		69
84	/* Encapsulates all information for the regulators driver */	70	/* Encapsulates all information for the regulators driver */
@@ -104,7 +90,7 @@ enum { · 19 unmodified lines
104	* - DA9062_ID_[BUCK1\|BUCK2\|BUCK4]	90	* - DA9062_ID_[BUCK1\|BUCK2\|BUCK4]
105	* Entry indexes corresponds to register values.	91	* Entry indexes corresponds to register values.
106	*/	92	*/
107	static const int da9062_buck_a_limits[] = {	93	static const unsigned int da9062_buck_a_limits[] = {
108	500000, 600000, 700000, 800000, 900000, 1000000, 1100000, 1200000,	94	500000, 600000, 700000, 800000, 900000, 1000000, 1100000, 1200000,
109	1300000, 1400000, 1500000, 1600000, 1700000, 1800000, 1900000, 2000000	95	1300000, 1400000, 1500000, 1600000, 1700000, 1800000, 1900000, 2000000
110	};	96	};
@@ -114,44 +100,11 @@ static const int da9062_buck_a_limits[] = { · 3 unmodified lines
114	* - DA9062_ID_BUCK3	100	* - DA9062_ID_BUCK3
115	* Entry indexes corresponds to register values.	101	* Entry indexes corresponds to register values.
116	*/	102	*/
117	static const int da9062_buck_b_limits[] = {	103	static const unsigned int da9062_buck_b_limits[] = {
118	1500000, 1600000, 1700000, 1800000, 1900000, 2000000, 2100000, 2200000,	104	1500000, 1600000, 1700000, 1800000, 1900000, 2000000, 2100000, 2200000,
119	2300000, 2400000, 2500000, 2600000, 2700000, 2800000, 2900000, 3000000	105	2300000, 2400000, 2500000, 2600000, 2700000, 2800000, 2900000, 3000000
120	};	106	};
121		107
122	static int da9062_set_current_limit(struct regulator_dev *rdev,
123	int min_ua, int max_ua)
124	{
125	struct da9062_regulator *regl = rdev_get_drvdata(rdev);
126	const struct da9062_regulator_info *rinfo = regl->info;
127	int n, tval;
128
129	for (n = rinfo->n_current_limits - 1; n >= 0; n--) {
130	tval = rinfo->current_limits[n];
131	if (tval >= min_ua && tval <= max_ua)
132	return regmap_field_write(regl->ilimit, n);
133	}
134
135	return -EINVAL;
136	}
137
138	static int da9062_get_current_limit(struct regulator_dev *rdev)
139	{
140	struct da9062_regulator *regl = rdev_get_drvdata(rdev);
141	const struct da9062_regulator_info *rinfo = regl->info;
142	unsigned int sel;
143	int ret;
144
145	ret = regmap_field_read(regl->ilimit, &sel);
146	if (ret < 0)
147	return ret;
148
149	if (sel >= rinfo->n_current_limits)
150	sel = rinfo->n_current_limits - 1;
151
152	return rinfo->current_limits[sel];
153	}
154
155	static int da9062_buck_set_mode(struct regulator_dev *rdev, unsigned mode)	108	static int da9062_buck_set_mode(struct regulator_dev *rdev, unsigned mode)
156	{	109	{
157	struct da9062_regulator *regl = rdev_get_drvdata(rdev);	110	struct da9062_regulator *regl = rdev_get_drvdata(rdev);
@@ -395,8 +348,8 @@ static const struct regulator_ops da9062_buck_ops = { · 237 unmodified lines
395	.get_voltage_sel = regulator_get_voltage_sel_regmap,	348	.get_voltage_sel = regulator_get_voltage_sel_regmap,
396	.set_voltage_sel = regulator_set_voltage_sel_regmap,	349	.set_voltage_sel = regulator_set_voltage_sel_regmap,
397	.list_voltage = regulator_list_voltage_linear,	350	.list_voltage = regulator_list_voltage_linear,
398	.set_current_limit = da9062_set_current_limit,	351	.set_current_limit = regulator_set_current_limit_regmap,
399	.get_current_limit = da9062_get_current_limit,	352	.get_current_limit = regulator_get_current_limit_regmap,
400	.set_mode = da9062_buck_set_mode,	353	.set_mode = da9062_buck_set_mode,
401	.get_mode = da9062_buck_get_mode,	354	.get_mode = da9062_buck_get_mode,
402	.get_status = da9062_buck_get_status,	355	.get_status = da9062_buck_get_status,
@@ -433,8 +386,10 @@ static const struct da9062_regulator_info local_da9061_regulator_info[] = { · 30 unmodified lines
433	.desc.min_uV = (300) * 1000,	386	.desc.min_uV = (300) * 1000,
434	.desc.uV_step = (10) * 1000,	387	.desc.uV_step = (10) * 1000,
435	.desc.n_voltages = ((1570) - (300))/(10) + 1,	388	.desc.n_voltages = ((1570) - (300))/(10) + 1,
436	.current_limits = da9062_buck_a_limits,	389	.desc.curr_table = da9062_buck_a_limits,
437	.n_current_limits = ARRAY_SIZE(da9062_buck_a_limits),	390	.desc.n_current_limits = ARRAY_SIZE(da9062_buck_a_limits),
		391	.desc.csel_reg = DA9062AA_BUCK_ILIM_C,
		392	.desc.csel_mask = DA9062AA_BUCK1_ILIM_MASK,
438	.desc.enable_reg = DA9062AA_BUCK1_CONT,	393	.desc.enable_reg = DA9062AA_BUCK1_CONT,
439	.desc.enable_mask = DA9062AA_BUCK1_EN_MASK,	394	.desc.enable_mask = DA9062AA_BUCK1_EN_MASK,
440	.desc.vsel_reg = DA9062AA_VBUCK1_A,	395	.desc.vsel_reg = DA9062AA_VBUCK1_A,
@@ -457,10 +412,6 @@ static const struct da9062_regulator_info local_da9061_regulator_info[] = { · 16 unmodified lines
457	__builtin_ffs((int)DA9062AA_VBUCK1_SEL_MASK) - 1,	412	__builtin_ffs((int)DA9062AA_VBUCK1_SEL_MASK) - 1,
458	sizeof(unsigned int) * 8 -	413	sizeof(unsigned int) * 8 -
459	__builtin_clz((DA9062AA_VBUCK1_SEL_MASK)) - 1),	414	__builtin_clz((DA9062AA_VBUCK1_SEL_MASK)) - 1),
460	.ilimit = REG_FIELD(DA9062AA_BUCK_ILIM_C,
461	__builtin_ffs((int)DA9062AA_BUCK1_ILIM_MASK) - 1,
462	sizeof(unsigned int) * 8 -
463	__builtin_clz((DA9062AA_BUCK1_ILIM_MASK)) - 1),
464	},	415	},
465	{	416	{
466	.desc.id = DA9061_ID_BUCK2,	417	.desc.id = DA9061_ID_BUCK2,
@@ -471,8 +422,10 @@ static const struct da9062_regulator_info local_da9061_regulator_info[] = { · 4 unmodified lines
471	.desc.min_uV = (800) * 1000,	422	.desc.min_uV = (800) * 1000,
472	.desc.uV_step = (20) * 1000,	423	.desc.uV_step = (20) * 1000,
473	.desc.n_voltages = ((3340) - (800))/(20) + 1,	424	.desc.n_voltages = ((3340) - (800))/(20) + 1,
474	.current_limits = da9062_buck_b_limits,	425	.desc.curr_table = da9062_buck_b_limits,
475	.n_current_limits = ARRAY_SIZE(da9062_buck_b_limits),	426	.desc.n_current_limits = ARRAY_SIZE(da9062_buck_b_limits),
		427	.desc.csel_reg = DA9062AA_BUCK_ILIM_A,
		428	.desc.csel_mask = DA9062AA_BUCK3_ILIM_MASK,
476	.desc.enable_reg = DA9062AA_BUCK3_CONT,	429	.desc.enable_reg = DA9062AA_BUCK3_CONT,
477	.desc.enable_mask = DA9062AA_BUCK3_EN_MASK,	430	.desc.enable_mask = DA9062AA_BUCK3_EN_MASK,
478	.desc.vsel_reg = DA9062AA_VBUCK3_A,	431	.desc.vsel_reg = DA9062AA_VBUCK3_A,
@@ -495,10 +448,6 @@ static const struct da9062_regulator_info local_da9061_regulator_info[] = { · 16 unmodified lines
495	__builtin_ffs((int)DA9062AA_VBUCK3_SEL_MASK) - 1,	448	__builtin_ffs((int)DA9062AA_VBUCK3_SEL_MASK) - 1,
496	sizeof(unsigned int) * 8 -	449	sizeof(unsigned int) * 8 -
497	__builtin_clz((DA9062AA_VBUCK3_SEL_MASK)) - 1),	450	__builtin_clz((DA9062AA_VBUCK3_SEL_MASK)) - 1),
498	.ilimit = REG_FIELD(DA9062AA_BUCK_ILIM_A,
499	__builtin_ffs((int)DA9062AA_BUCK3_ILIM_MASK) - 1,
500	sizeof(unsigned int) * 8 -
501	__builtin_clz((DA9062AA_BUCK3_ILIM_MASK)) - 1),
502	},	451	},
503	{	452	{
504	.desc.id = DA9061_ID_BUCK3,	453	.desc.id = DA9061_ID_BUCK3,
@@ -509,8 +458,10 @@ static const struct da9062_regulator_info local_da9061_regulator_info[] = { · 4 unmodified lines
509	.desc.min_uV = (530) * 1000,	458	.desc.min_uV = (530) * 1000,
510	.desc.uV_step = (10) * 1000,	459	.desc.uV_step = (10) * 1000,
511	.desc.n_voltages = ((1800) - (530))/(10) + 1,	460	.desc.n_voltages = ((1800) - (530))/(10) + 1,
512	.current_limits = da9062_buck_a_limits,	461	.desc.curr_table = da9062_buck_a_limits,
513	.n_current_limits = ARRAY_SIZE(da9062_buck_a_limits),	462	.desc.n_current_limits = ARRAY_SIZE(da9062_buck_a_limits),
		463	.desc.csel_reg = DA9062AA_BUCK_ILIM_B,
		464	.desc.csel_mask = DA9062AA_BUCK4_ILIM_MASK,
514	.desc.enable_reg = DA9062AA_BUCK4_CONT,	465	.desc.enable_reg = DA9062AA_BUCK4_CONT,
515	.desc.enable_mask = DA9062AA_BUCK4_EN_MASK,	466	.desc.enable_mask = DA9062AA_BUCK4_EN_MASK,
516	.desc.vsel_reg = DA9062AA_VBUCK4_A,	467	.desc.vsel_reg = DA9062AA_VBUCK4_A,
@@ -533,10 +484,6 @@ static const struct da9062_regulator_info local_da9061_regulator_info[] = { · 16 unmodified lines
533	__builtin_ffs((int)DA9062AA_VBUCK4_SEL_MASK) - 1,	484	__builtin_ffs((int)DA9062AA_VBUCK4_SEL_MASK) - 1,
534	sizeof(unsigned int) * 8 -	485	sizeof(unsigned int) * 8 -
535	__builtin_clz((DA9062AA_VBUCK4_SEL_MASK)) - 1),	486	__builtin_clz((DA9062AA_VBUCK4_SEL_MASK)) - 1),
536	.ilimit = REG_FIELD(DA9062AA_BUCK_ILIM_B,
537	__builtin_ffs((int)DA9062AA_BUCK4_ILIM_MASK) - 1,
538	sizeof(unsigned int) * 8 -
539	__builtin_clz((DA9062AA_BUCK4_ILIM_MASK)) - 1),
540	},	487	},
541	{	488	{
542	.desc.id = DA9061_ID_LDO1,	489	.desc.id = DA9061_ID_LDO1,
@@ -679,8 +626,10 @@ static const struct da9062_regulator_info local_da9062_regulator_info[] = { · 136 unmodified lines
679	.desc.min_uV = (300) * 1000,	626	.desc.min_uV = (300) * 1000,
680	.desc.uV_step = (10) * 1000,	627	.desc.uV_step = (10) * 1000,
681	.desc.n_voltages = ((1570) - (300))/(10) + 1,	628	.desc.n_voltages = ((1570) - (300))/(10) + 1,
682	.current_limits = da9062_buck_a_limits,	629	.desc.curr_table = da9062_buck_a_limits,
683	.n_current_limits = ARRAY_SIZE(da9062_buck_a_limits),	630	.desc.n_current_limits = ARRAY_SIZE(da9062_buck_a_limits),
		631	.desc.csel_reg = DA9062AA_BUCK_ILIM_C,
		632	.desc.csel_mask = DA9062AA_BUCK1_ILIM_MASK,
684	.desc.enable_reg = DA9062AA_BUCK1_CONT,	633	.desc.enable_reg = DA9062AA_BUCK1_CONT,
685	.desc.enable_mask = DA9062AA_BUCK1_EN_MASK,	634	.desc.enable_mask = DA9062AA_BUCK1_EN_MASK,
686	.desc.vsel_reg = DA9062AA_VBUCK1_A,	635	.desc.vsel_reg = DA9062AA_VBUCK1_A,
@@ -703,10 +652,6 @@ static const struct da9062_regulator_info local_da9062_regulator_info[] = { · 16 unmodified lines
703	__builtin_ffs((int)DA9062AA_VBUCK1_SEL_MASK) - 1,	652	__builtin_ffs((int)DA9062AA_VBUCK1_SEL_MASK) - 1,
704	sizeof(unsigned int) * 8 -	653	sizeof(unsigned int) * 8 -
705	__builtin_clz((DA9062AA_VBUCK1_SEL_MASK)) - 1),	654	__builtin_clz((DA9062AA_VBUCK1_SEL_MASK)) - 1),
706	.ilimit = REG_FIELD(DA9062AA_BUCK_ILIM_C,
707	__builtin_ffs((int)DA9062AA_BUCK1_ILIM_MASK) - 1,
708	sizeof(unsigned int) * 8 -
709	__builtin_clz((DA9062AA_BUCK1_ILIM_MASK)) - 1),
710	},	655	},
711	{	656	{
712	.desc.id = DA9062_ID_BUCK2,	657	.desc.id = DA9062_ID_BUCK2,
@@ -717,8 +662,10 @@ static const struct da9062_regulator_info local_da9062_regulator_info[] = { · 4 unmodified lines
717	.desc.min_uV = (300) * 1000,	662	.desc.min_uV = (300) * 1000,
718	.desc.uV_step = (10) * 1000,	663	.desc.uV_step = (10) * 1000,
719	.desc.n_voltages = ((1570) - (300))/(10) + 1,	664	.desc.n_voltages = ((1570) - (300))/(10) + 1,
720	.current_limits = da9062_buck_a_limits,	665	.desc.curr_table = da9062_buck_a_limits,
721	.n_current_limits = ARRAY_SIZE(da9062_buck_a_limits),	666	.desc.n_current_limits = ARRAY_SIZE(da9062_buck_a_limits),
		667	.desc.csel_reg = DA9062AA_BUCK_ILIM_C,
		668	.desc.csel_mask = DA9062AA_BUCK2_ILIM_MASK,
722	.desc.enable_reg = DA9062AA_BUCK2_CONT,	669	.desc.enable_reg = DA9062AA_BUCK2_CONT,
723	.desc.enable_mask = DA9062AA_BUCK2_EN_MASK,	670	.desc.enable_mask = DA9062AA_BUCK2_EN_MASK,
724	.desc.vsel_reg = DA9062AA_VBUCK2_A,	671	.desc.vsel_reg = DA9062AA_VBUCK2_A,
@@ -741,10 +688,6 @@ static const struct da9062_regulator_info local_da9062_regulator_info[] = { · 16 unmodified lines
741	__builtin_ffs((int)DA9062AA_VBUCK2_SEL_MASK) - 1,	688	__builtin_ffs((int)DA9062AA_VBUCK2_SEL_MASK) - 1,
742	sizeof(unsigned int) * 8 -	689	sizeof(unsigned int) * 8 -
743	__builtin_clz((DA9062AA_VBUCK2_SEL_MASK)) - 1),	690	__builtin_clz((DA9062AA_VBUCK2_SEL_MASK)) - 1),
744	.ilimit = REG_FIELD(DA9062AA_BUCK_ILIM_C,
745	__builtin_ffs((int)DA9062AA_BUCK2_ILIM_MASK) - 1,
746	sizeof(unsigned int) * 8 -
747	__builtin_clz((DA9062AA_BUCK2_ILIM_MASK)) - 1),
748	},	691	},
749	{	692	{
750	.desc.id = DA9062_ID_BUCK3,	693	.desc.id = DA9062_ID_BUCK3,
@@ -755,8 +698,10 @@ static const struct da9062_regulator_info local_da9062_regulator_info[] = { · 4 unmodified lines
755	.desc.min_uV = (800) * 1000,	698	.desc.min_uV = (800) * 1000,
756	.desc.uV_step = (20) * 1000,	699	.desc.uV_step = (20) * 1000,
757	.desc.n_voltages = ((3340) - (800))/(20) + 1,	700	.desc.n_voltages = ((3340) - (800))/(20) + 1,
758	.current_limits = da9062_buck_b_limits,	701	.desc.curr_table = da9062_buck_b_limits,
759	.n_current_limits = ARRAY_SIZE(da9062_buck_b_limits),	702	.desc.n_current_limits = ARRAY_SIZE(da9062_buck_b_limits),
		703	.desc.csel_reg = DA9062AA_BUCK_ILIM_A,
		704	.desc.csel_mask = DA9062AA_BUCK3_ILIM_MASK,
760	.desc.enable_reg = DA9062AA_BUCK3_CONT,	705	.desc.enable_reg = DA9062AA_BUCK3_CONT,
761	.desc.enable_mask = DA9062AA_BUCK3_EN_MASK,	706	.desc.enable_mask = DA9062AA_BUCK3_EN_MASK,
762	.desc.vsel_reg = DA9062AA_VBUCK3_A,	707	.desc.vsel_reg = DA9062AA_VBUCK3_A,
@@ -779,10 +724,6 @@ static const struct da9062_regulator_info local_da9062_regulator_info[] = { · 16 unmodified lines
779	__builtin_ffs((int)DA9062AA_VBUCK3_SEL_MASK) - 1,	724	__builtin_ffs((int)DA9062AA_VBUCK3_SEL_MASK) - 1,
780	sizeof(unsigned int) * 8 -	725	sizeof(unsigned int) * 8 -
781	__builtin_clz((DA9062AA_VBUCK3_SEL_MASK)) - 1),	726	__builtin_clz((DA9062AA_VBUCK3_SEL_MASK)) - 1),
782	.ilimit = REG_FIELD(DA9062AA_BUCK_ILIM_A,
783	__builtin_ffs((int)DA9062AA_BUCK3_ILIM_MASK) - 1,
784	sizeof(unsigned int) * 8 -
785	__builtin_clz((DA9062AA_BUCK3_ILIM_MASK)) - 1),
786	},	727	},
787	{	728	{
788	.desc.id = DA9062_ID_BUCK4,	729	.desc.id = DA9062_ID_BUCK4,
@@ -793,8 +734,10 @@ static const struct da9062_regulator_info local_da9062_regulator_info[] = { · 4 unmodified lines
793	.desc.min_uV = (530) * 1000,	734	.desc.min_uV = (530) * 1000,
794	.desc.uV_step = (10) * 1000,	735	.desc.uV_step = (10) * 1000,
795	.desc.n_voltages = ((1800) - (530))/(10) + 1,	736	.desc.n_voltages = ((1800) - (530))/(10) + 1,
796	.current_limits = da9062_buck_a_limits,	737	.desc.curr_table = da9062_buck_a_limits,
797	.n_current_limits = ARRAY_SIZE(da9062_buck_a_limits),	738	.desc.n_current_limits = ARRAY_SIZE(da9062_buck_a_limits),
		739	.desc.csel_reg = DA9062AA_BUCK_ILIM_B,
		740	.desc.csel_mask = DA9062AA_BUCK4_ILIM_MASK,
798	.desc.enable_reg = DA9062AA_BUCK4_CONT,	741	.desc.enable_reg = DA9062AA_BUCK4_CONT,
799	.desc.enable_mask = DA9062AA_BUCK4_EN_MASK,	742	.desc.enable_mask = DA9062AA_BUCK4_EN_MASK,
800	.desc.vsel_reg = DA9062AA_VBUCK4_A,	743	.desc.vsel_reg = DA9062AA_VBUCK4_A,
@@ -817,10 +760,6 @@ static const struct da9062_regulator_info local_da9062_regulator_info[] = { · 16 unmodified lines
817	__builtin_ffs((int)DA9062AA_VBUCK4_SEL_MASK) - 1,	760	__builtin_ffs((int)DA9062AA_VBUCK4_SEL_MASK) - 1,
818	sizeof(unsigned int) * 8 -	761	sizeof(unsigned int) * 8 -
819	__builtin_clz((DA9062AA_VBUCK4_SEL_MASK)) - 1),	762	__builtin_clz((DA9062AA_VBUCK4_SEL_MASK)) - 1),
820	.ilimit = REG_FIELD(DA9062AA_BUCK_ILIM_B,
821	__builtin_ffs((int)DA9062AA_BUCK4_ILIM_MASK) - 1,
822	sizeof(unsigned int) * 8 -
823	__builtin_clz((DA9062AA_BUCK4_ILIM_MASK)) - 1),
824	},	763	},
825	{	764	{
826	.desc.id = DA9062_ID_LDO1,	765	.desc.id = DA9062_ID_LDO1,
@@ -974,8 +913,10 @@ static irqreturn_t da9062_ldo_lim_event(int irq, void *data) · 147 unmodified lines
974	continue;	913	continue;
975		914
976	if (BIT(regl->info->oc_event.lsb) & bits) {	915	if (BIT(regl->info->oc_event.lsb) & bits) {
		916	regulator_lock(regl->rdev);
977	regulator_notifier_call_chain(regl->rdev,	917	regulator_notifier_call_chain(regl->rdev,
978	REGULATOR_EVENT_OVER_CURRENT, NULL);	918	REGULATOR_EVENT_OVER_CURRENT, NULL);
		919	regulator_unlock(regl->rdev);
979	handled = IRQ_HANDLED;	920	handled = IRQ_HANDLED;
980	}	921	}
981	}	922	}
@@ -1063,15 +1004,6 @@ static int da9062_regulator_probe(struct platform_device *pdev) · 81 unmodified lines
1063	return PTR_ERR(regl->suspend_sleep);	1004	return PTR_ERR(regl->suspend_sleep);
1064	}	1005	}
1065		1006
1066	if (regl->info->ilimit.reg) {
1067	regl->ilimit = devm_regmap_field_alloc(
1068	&pdev->dev,
1069	chip->regmap,
1070	regl->info->ilimit);
1071	if (IS_ERR(regl->ilimit))
1072	return PTR_ERR(regl->ilimit);
1073	}
1074
1075	/* Register regulator */	1007	/* Register regulator */
1076	memset(&config, 0, sizeof(config));	1008	memset(&config, 0, sizeof(config));
1077	config.dev = chip->dev;	1009	config.dev = chip->dev;

drivers/regulator/da9063-regulator.c+40−94

+// SPDX-License-Identifier: GPL-2.0+
+//
+// Regulator driver for DA9063 PMIC series
+//
+// Copyright 2012 Dialog Semiconductors Ltd.
+// Copyright 2013 Philipp Zabel, Pengutronix
+//
+// Author: Krystian Garbaciak <krystian.garbaciak@diasemi.com>
-/*
- * Regulator driver for DA9063 PMIC series
- *
- * Copyright 2012 Dialog Semiconductors Ltd.
- * Copyright 2013 Philipp Zabel, Pengutronix
- *
- * Author: Krystian Garbaciak <krystian.garbaciak@diasemi.com>
- *
- *  This program is free software; you can redistribute  it and/or modify it
- *  under  the terms of  the GNU General  Public License as published by the
- *  Free Software Foundation;  either version 2 of the  License, or (at your
- *  option) any later version.
- *
- */
 #include <linux/kernel.h>
 #include <linux/module.h>
 #include <linux/init.h>
 struct da9063_regulator_info {
 	struct regulator_desc desc;
-	/* Current limiting */
-	unsigned	n_current_limits;
-	const int	*current_limits;
 	/* DA9063 main register fields */
 	struct reg_field mode;		/* buck mode of operation */
 	struct reg_field suspend;
 	struct reg_field sleep;
 	struct reg_field suspend_sleep;
 	unsigned int suspend_vsel_reg;
-	struct reg_field ilimit;
 	/* DA9063 event detection bit */
 	struct reg_field oc_event;
 	.suspend_vsel_reg = DA9063_REG_V##regl_name##_B
 /* Macros for voltage DC/DC converters (BUCKs) */
-#define DA9063_BUCK(chip, regl_name, min_mV, step_mV, max_mV, limits_array) \
+#define DA9063_BUCK(chip, regl_name, min_mV, step_mV, max_mV, limits_array, \
+		    creg, cmask) \
 	.desc.id = chip##_ID_##regl_name, \
 	.desc.name = __stringify(chip##_##regl_name), \
 	.desc.ops = &da9063_buck_ops, \
 	.desc.min_uV = (min_mV) * 1000, \
 	.desc.uV_step = (step_mV) * 1000, \
 	.desc.n_voltages = ((max_mV) - (min_mV))/(step_mV) + 1, \
-	.current_limits = limits_array, \
+	.desc.csel_reg = (creg), \
-	.n_current_limits = ARRAY_SIZE(limits_array)
+	.desc.csel_mask = (cmask), \
+	.desc.curr_table = limits_array, \
+	.desc.n_current_limits = ARRAY_SIZE(limits_array)
 #define DA9063_BUCK_COMMON_FIELDS(regl_name) \
 	.desc.enable_reg = DA9063_REG_##regl_name##_CONT, \
 	struct regmap_field			*suspend;
 	struct regmap_field			*sleep;
 	struct regmap_field			*suspend_sleep;
-	struct regmap_field			*ilimit;
 };
 /* Encapsulates all information for the regulators driver */
 /* Current limits array (in uA) for BCORE1, BCORE2, BPRO.
    Entry indexes corresponds to register values. */
-static const int da9063_buck_a_limits[] = {
+static const unsigned int da9063_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 BMEM, BIO, BPERI.
    Entry indexes corresponds to register values. */
-static const int da9063_buck_b_limits[] = {
+static const unsigned int da9063_buck_b_limits[] = {
 	1500000, 1600000, 1700000, 1800000, 1900000, 2000000, 2100000, 2200000,
 	2300000, 2400000, 2500000, 2600000, 2700000, 2800000, 2900000, 3000000
 };
 /* Current limits array (in uA) for merged BCORE1 and BCORE2.
    Entry indexes corresponds to register values. */
-static const int da9063_bcores_merged_limits[] = {
+static const unsigned int da9063_bcores_merged_limits[] = {
 	1000000, 1200000, 1400000, 1600000, 1800000, 2000000, 2200000, 2400000,
 	2600000, 2800000, 3000000, 3200000, 3400000, 3600000, 3800000, 4000000
 };
 /* Current limits array (in uA) for merged BMEM and BIO.
    Entry indexes corresponds to register values. */
-static const int da9063_bmem_bio_merged_limits[] = {
+static const unsigned int da9063_bmem_bio_merged_limits[] = {
 	3000000, 3200000, 3400000, 3600000, 3800000, 4000000, 4200000, 4400000,
 	4600000, 4800000, 5000000, 5200000, 5400000, 5600000, 5800000, 6000000
 };
-static int da9063_set_current_limit(struct regulator_dev *rdev,
-							int min_uA, int max_uA)
-{
-	struct da9063_regulator *regl = rdev_get_drvdata(rdev);
-	const struct da9063_regulator_info *rinfo = regl->info;
-	int n, tval;
-	for (n = rinfo->n_current_limits - 1; n >= 0; n--) {
-		tval = rinfo->current_limits[n];
-		if (tval >= min_uA && tval <= max_uA)
-			return regmap_field_write(regl->ilimit, n);
-	}
-	return -EINVAL;
-}
-static int da9063_get_current_limit(struct regulator_dev *rdev)
-{
-	struct da9063_regulator *regl = rdev_get_drvdata(rdev);
-	const struct da9063_regulator_info *rinfo = regl->info;
-	unsigned int sel;
-	int ret;
-	ret = regmap_field_read(regl->ilimit, &sel);
-	if (ret < 0)
-		return ret;
-	if (sel >= rinfo->n_current_limits)
-		sel = rinfo->n_current_limits - 1;
-	return rinfo->current_limits[sel];
-}
 static int da9063_buck_set_mode(struct regulator_dev *rdev, unsigned mode)
 {
 	struct da9063_regulator *regl = rdev_get_drvdata(rdev);
 	.get_voltage_sel	= regulator_get_voltage_sel_regmap,
 	.set_voltage_sel	= regulator_set_voltage_sel_regmap,
 	.list_voltage		= regulator_list_voltage_linear,
-	.set_current_limit	= da9063_set_current_limit,
+	.set_current_limit	= regulator_set_current_limit_regmap,
-	.get_current_limit	= da9063_get_current_limit,
+	.get_current_limit	= regulator_get_current_limit_regmap,
 	.set_mode		= da9063_buck_set_mode,
 	.get_mode		= da9063_buck_get_mode,
 	.get_status		= da9063_buck_get_status,
 static const struct da9063_regulator_info da9063_regulator_info[] = {
 	{
 		DA9063_BUCK(DA9063, BCORE1, 300, 10, 1570,
-			    da9063_buck_a_limits),
+			    da9063_buck_a_limits,
+			    DA9063_REG_BUCK_ILIM_C, DA9063_BCORE1_ILIM_MASK),
 		DA9063_BUCK_COMMON_FIELDS(BCORE1),
 		.suspend = BFIELD(DA9063_REG_DVC_1, DA9063_VBCORE1_SEL),
-		.ilimit = BFIELD(DA9063_REG_BUCK_ILIM_C,
-				 DA9063_BCORE1_ILIM_MASK),
 	},
 	{
 		DA9063_BUCK(DA9063, BCORE2, 300, 10, 1570,
-			    da9063_buck_a_limits),
+			    da9063_buck_a_limits,
+			    DA9063_REG_BUCK_ILIM_C, DA9063_BCORE2_ILIM_MASK),
 		DA9063_BUCK_COMMON_FIELDS(BCORE2),
 		.suspend = BFIELD(DA9063_REG_DVC_1, DA9063_VBCORE2_SEL),
-		.ilimit = BFIELD(DA9063_REG_BUCK_ILIM_C,
-				 DA9063_BCORE2_ILIM_MASK),
 	},
 	{
 		DA9063_BUCK(DA9063, BPRO, 530, 10, 1800,
-			    da9063_buck_a_limits),
+			    da9063_buck_a_limits,
+			    DA9063_REG_BUCK_ILIM_B, DA9063_BPRO_ILIM_MASK),
 		DA9063_BUCK_COMMON_FIELDS(BPRO),
 		.suspend = BFIELD(DA9063_REG_DVC_1, DA9063_VBPRO_SEL),
-		.ilimit = BFIELD(DA9063_REG_BUCK_ILIM_B,
-				 DA9063_BPRO_ILIM_MASK),
 	},
 	{
 		DA9063_BUCK(DA9063, BMEM, 800, 20, 3340,
-			    da9063_buck_b_limits),
+			    da9063_buck_b_limits,
+			    DA9063_REG_BUCK_ILIM_A, DA9063_BMEM_ILIM_MASK),
 		DA9063_BUCK_COMMON_FIELDS(BMEM),
 		.suspend = BFIELD(DA9063_REG_DVC_1, DA9063_VBMEM_SEL),
-		.ilimit = BFIELD(DA9063_REG_BUCK_ILIM_A,
-				 DA9063_BMEM_ILIM_MASK),
 	},
 	{
 		DA9063_BUCK(DA9063, BIO, 800, 20, 3340,
-			    da9063_buck_b_limits),
+			    da9063_buck_b_limits,
+			    DA9063_REG_BUCK_ILIM_A, DA9063_BIO_ILIM_MASK),
 		DA9063_BUCK_COMMON_FIELDS(BIO),
 		.suspend = BFIELD(DA9063_REG_DVC_2, DA9063_VBIO_SEL),
-		.ilimit = BFIELD(DA9063_REG_BUCK_ILIM_A,
-				 DA9063_BIO_ILIM_MASK),
 	},
 	{
 		DA9063_BUCK(DA9063, BPERI, 800, 20, 3340,
-			    da9063_buck_b_limits),
+			    da9063_buck_b_limits,
+			    DA9063_REG_BUCK_ILIM_B, DA9063_BPERI_ILIM_MASK),
 		DA9063_BUCK_COMMON_FIELDS(BPERI),
 		.suspend = BFIELD(DA9063_REG_DVC_1, DA9063_VBPERI_SEL),
-		.ilimit = BFIELD(DA9063_REG_BUCK_ILIM_B,
-				 DA9063_BPERI_ILIM_MASK),
 	},
 	{
 		DA9063_BUCK(DA9063, BCORES_MERGED, 300, 10, 1570,
-			    da9063_bcores_merged_limits),
+			    da9063_bcores_merged_limits,
+			    DA9063_REG_BUCK_ILIM_C, DA9063_BCORE1_ILIM_MASK),
 		/* BCORES_MERGED uses the same register fields as BCORE1 */
 		DA9063_BUCK_COMMON_FIELDS(BCORE1),
 		.suspend = BFIELD(DA9063_REG_DVC_1, DA9063_VBCORE1_SEL),
-		.ilimit = BFIELD(DA9063_REG_BUCK_ILIM_C,
-				 DA9063_BCORE1_ILIM_MASK),
 	},
 	{
 		DA9063_BUCK(DA9063, BMEM_BIO_MERGED, 800, 20, 3340,
-			    da9063_bmem_bio_merged_limits),
+			    da9063_bmem_bio_merged_limits,
+			    DA9063_REG_BUCK_ILIM_A, DA9063_BMEM_ILIM_MASK),
 		/* BMEM_BIO_MERGED uses the same register fields as BMEM */
 		DA9063_BUCK_COMMON_FIELDS(BMEM),
 		.suspend = BFIELD(DA9063_REG_DVC_1, DA9063_VBMEM_SEL),
-		.ilimit = BFIELD(DA9063_REG_BUCK_ILIM_A,
-				 DA9063_BMEM_ILIM_MASK),
 	},
 	{
 		DA9063_LDO(DA9063, LDO3, 900, 20, 3440),
 		if (regl->info->oc_event.reg != DA9063_REG_STATUS_D)
 			continue;
-		if (BIT(regl->info->oc_event.lsb) & bits)
+		if (BIT(regl->info->oc_event.lsb) & bits) {
+		        regulator_lock(regl->rdev);
 			regulator_notifier_call_chain(regl->rdev,
 					REGULATOR_EVENT_OVER_CURRENT, NULL);
+		        regulator_unlock(regl->rdev);
+		}
 	}
 	return IRQ_HANDLED;
 				return PTR_ERR(regl->suspend_sleep);
 		}
-		if (regl->info->ilimit.reg) {
-			regl->ilimit = devm_regmap_field_alloc(&pdev->dev,
-					da9063->regmap, regl->info->ilimit);
-			if (IS_ERR(regl->ilimit))
-				return PTR_ERR(regl->ilimit);
-		}
 		/* Register regulator */
 		memset(&config, 0, sizeof(config));
 		config.dev = &pdev->dev;

drivers/regulator/da9210-regulator.c+4−19

@@ -1,22 +1,7 @@
1	/*	1	// SPDX-License-Identifier: GPL-2.0+
2	* da9210-regulator.c - Regulator device driver for DA9210	2	//
3	* Copyright (C) 2013 Dialog Semiconductor Ltd.	3	// da9210-regulator.c - Regulator device driver for DA9210
4	*	4	// Copyright (C) 2013 Dialog Semiconductor Ltd.
5	* This library is free software; you can redistribute it and/or
6	* modify it under the terms of the GNU Library General Public
7	* License as published by the Free Software Foundation; either
8	* version 2 of the License, or (at your option) any later version.
9	*
10	* This library is distributed in the hope that it will be useful,
11	* but WITHOUT ANY WARRANTY; without even the implied warranty of
12	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13	* Library General Public License for more details.
14	*
15	* You should have received a copy of the GNU Library General Public
16	* License along with this library; if not, write to the
17	* Free Software Foundation, Inc., 51 Franklin St, Fifth Floor,
18	* Boston, MA 02110-1301, USA.
19	*/
20		5
21	#include <linux/err.h>	6	#include <linux/err.h>
22	#include <linux/i2c.h>	7	#include <linux/i2c.h>

drivers/regulator/da9210-regulator.h+1−16

@@ -1,22 +1,7 @@
1		1	/* SPDX-License-Identifier: GPL-2.0+ */
2	/*	2	/*
3	* da9210-regulator.h - Regulator definitions for DA9210	3	* da9210-regulator.h - Regulator definitions for DA9210
4	* Copyright (C) 2013 Dialog Semiconductor Ltd.	4	* Copyright (C) 2013 Dialog Semiconductor Ltd.
5	*
6	* This library is free software; you can redistribute it and/or
7	* modify it under the terms of the GNU Library General Public
8	* License as published by the Free Software Foundation; either
9	* version 2 of the License, or (at your option) any later version.
10	*
11	* This library is distributed in the hope that it will be useful,
12	* but WITHOUT ANY WARRANTY; without even the implied warranty of
13	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14	* Library General Public License for more details.
15	*
16	* You should have received a copy of the GNU Library General Public
17	* License along with this library; if not, write to the
18	* Free Software Foundation, Inc., 51 Franklin St, Fifth Floor,
19	* Boston, MA 02110-1301, USA.
20	*/	5	*/
21		6
22	#ifndef __DA9210_REGISTERS_H__	7	#ifndef __DA9210_REGISTERS_H__

drivers/regulator/da9211-regulator.c+9−15

-/*
+// SPDX-License-Identifier: GPL-2.0+
- * da9211-regulator.c - Regulator device driver for DA9211/DA9212
+//
- * /DA9213/DA9223/DA9214/DA9224/DA9215/DA9225
+// da9211-regulator.c - Regulator device driver for DA9211/DA9212
- * Copyright (C) 2015  Dialog Semiconductor Ltd.
+// /DA9213/DA9223/DA9214/DA9224/DA9215/DA9225
- *
+// Copyright (C) 2015  Dialog Semiconductor Ltd.
- * This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Library General Public
- * License as published by the Free Software Foundation; either
- * version 2 of the License, or (at your option) any later version.
- *
- * This library is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * Library General Public License for more details.
- */
 #include <linux/err.h>
 #include <linux/i2c.h>
 		goto error_i2c;
 	if (reg_val & DA9211_E_OV_CURR_A) {
+	        regulator_lock(chip->rdev[0]);
 		regulator_notifier_call_chain(chip->rdev[0],
 			REGULATOR_EVENT_OVER_CURRENT, NULL);
+	        regulator_unlock(chip->rdev[0]);
 		err = regmap_write(chip->regmap, DA9211_REG_EVENT_B,
 			DA9211_E_OV_CURR_A);
 	}
 	if (reg_val & DA9211_E_OV_CURR_B) {
+	        regulator_lock(chip->rdev[1]);
 		regulator_notifier_call_chain(chip->rdev[1],
 			REGULATOR_EVENT_OVER_CURRENT, NULL);
+	        regulator_unlock(chip->rdev[1]);
 		err = regmap_write(chip->regmap, DA9211_REG_EVENT_B,
 			DA9211_E_OV_CURR_B);

drivers/regulator/da9211-regulator.h+1−10

@@ -1,17 +1,8 @@
		1	/* SPDX-License-Identifier: GPL-2.0+ */
1	/*	2	/*
2	* da9211-regulator.h - Regulator definitions for DA9211/DA9212	3	* da9211-regulator.h - Regulator definitions for DA9211/DA9212
3	* /DA9213/DA9223/DA9214/DA9224/DA9215/DA9225	4	* /DA9213/DA9223/DA9214/DA9224/DA9215/DA9225
4	* Copyright (C) 2015 Dialog Semiconductor Ltd.	5	* Copyright (C) 2015 Dialog Semiconductor Ltd.
5	*
6	* This program is free software; you can redistribute it and/or
7	* modify it under the terms of the GNU General Public License
8	* as published by the Free Software Foundation; either version 2
9	* of the License, or (at your option) any later version.
10	*
11	* This program is distributed in the hope that it will be useful,
12	* but WITHOUT ANY WARRANTY; without even the implied warranty of
13	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14	* GNU General Public License for more details.
15	*/	6	*/
16		7
17	#ifndef __DA9211_REGISTERS_H__	8	#ifndef __DA9211_REGISTERS_H__

drivers/regulator/db8500-prcmu.c+44−99

@@ -75,7 +75,7 @@ static int db8500_regulator_is_enabled(struct regulator_dev *rdev) · 74 unmodified lines
75	}	75	}
76		76
77	/* db8500 regulator operations */	77	/* db8500 regulator operations */
78	static struct regulator_ops db8500_regulator_ops = {	78	static const struct regulator_ops db8500_regulator_ops = {
79	.enable = db8500_regulator_enable,	79	.enable = db8500_regulator_enable,
80	.disable = db8500_regulator_disable,	80	.disable = db8500_regulator_disable,
81	.is_enabled = db8500_regulator_is_enabled,	81	.is_enabled = db8500_regulator_is_enabled,
@@ -200,7 +200,7 @@ static int db8500_regulator_switch_is_enabled(struct regulator_dev *rdev) · 118 unmodified lines
200	return info->is_enabled;	200	return info->is_enabled;
201	}	201	}
202		202
203	static struct regulator_ops db8500_regulator_switch_ops = {	203	static const struct regulator_ops db8500_regulator_switch_ops = {
204	.enable = db8500_regulator_switch_enable,	204	.enable = db8500_regulator_switch_enable,
205	.disable = db8500_regulator_switch_disable,	205	.disable = db8500_regulator_switch_disable,
206	.is_enabled = db8500_regulator_switch_is_enabled,	206	.is_enabled = db8500_regulator_switch_is_enabled,
@@ -214,6 +214,7 @@ dbx500_regulator_info[DB8500_NUM_REGULATORS] = { · 7 unmodified lines
214	[DB8500_REGULATOR_VAPE] = {	214	[DB8500_REGULATOR_VAPE] = {
215	.desc = {	215	.desc = {
216	.name = "db8500-vape",	216	.name = "db8500-vape",
		217	.of_match = of_match_ptr("db8500_vape"),
217	.id = DB8500_REGULATOR_VAPE,	218	.id = DB8500_REGULATOR_VAPE,
218	.ops = &db8500_regulator_ops,	219	.ops = &db8500_regulator_ops,
219	.type = REGULATOR_VOLTAGE,	220	.type = REGULATOR_VOLTAGE,
@@ -223,6 +224,7 @@ dbx500_regulator_info[DB8500_NUM_REGULATORS] = { · 3 unmodified lines
223	[DB8500_REGULATOR_VARM] = {	224	[DB8500_REGULATOR_VARM] = {
224	.desc = {	225	.desc = {
225	.name = "db8500-varm",	226	.name = "db8500-varm",
		227	.of_match = of_match_ptr("db8500_varm"),
226	.id = DB8500_REGULATOR_VARM,	228	.id = DB8500_REGULATOR_VARM,
227	.ops = &db8500_regulator_ops,	229	.ops = &db8500_regulator_ops,
228	.type = REGULATOR_VOLTAGE,	230	.type = REGULATOR_VOLTAGE,
@@ -232,6 +234,7 @@ dbx500_regulator_info[DB8500_NUM_REGULATORS] = { · 3 unmodified lines
232	[DB8500_REGULATOR_VMODEM] = {	234	[DB8500_REGULATOR_VMODEM] = {
233	.desc = {	235	.desc = {
234	.name = "db8500-vmodem",	236	.name = "db8500-vmodem",
		237	.of_match = of_match_ptr("db8500_vmodem"),
235	.id = DB8500_REGULATOR_VMODEM,	238	.id = DB8500_REGULATOR_VMODEM,
236	.ops = &db8500_regulator_ops,	239	.ops = &db8500_regulator_ops,
237	.type = REGULATOR_VOLTAGE,	240	.type = REGULATOR_VOLTAGE,
@@ -241,6 +244,7 @@ dbx500_regulator_info[DB8500_NUM_REGULATORS] = { · 3 unmodified lines
241	[DB8500_REGULATOR_VPLL] = {	244	[DB8500_REGULATOR_VPLL] = {
242	.desc = {	245	.desc = {
243	.name = "db8500-vpll",	246	.name = "db8500-vpll",
		247	.of_match = of_match_ptr("db8500_vpll"),
244	.id = DB8500_REGULATOR_VPLL,	248	.id = DB8500_REGULATOR_VPLL,
245	.ops = &db8500_regulator_ops,	249	.ops = &db8500_regulator_ops,
246	.type = REGULATOR_VOLTAGE,	250	.type = REGULATOR_VOLTAGE,
@@ -250,6 +254,7 @@ dbx500_regulator_info[DB8500_NUM_REGULATORS] = { · 3 unmodified lines
250	[DB8500_REGULATOR_VSMPS1] = {	254	[DB8500_REGULATOR_VSMPS1] = {
251	.desc = {	255	.desc = {
252	.name = "db8500-vsmps1",	256	.name = "db8500-vsmps1",
		257	.of_match = of_match_ptr("db8500_vsmps1"),
253	.id = DB8500_REGULATOR_VSMPS1,	258	.id = DB8500_REGULATOR_VSMPS1,
254	.ops = &db8500_regulator_ops,	259	.ops = &db8500_regulator_ops,
255	.type = REGULATOR_VOLTAGE,	260	.type = REGULATOR_VOLTAGE,
@@ -259,6 +264,7 @@ dbx500_regulator_info[DB8500_NUM_REGULATORS] = { · 3 unmodified lines
259	[DB8500_REGULATOR_VSMPS2] = {	264	[DB8500_REGULATOR_VSMPS2] = {
260	.desc = {	265	.desc = {
261	.name = "db8500-vsmps2",	266	.name = "db8500-vsmps2",
		267	.of_match = of_match_ptr("db8500_vsmps2"),
262	.id = DB8500_REGULATOR_VSMPS2,	268	.id = DB8500_REGULATOR_VSMPS2,
263	.ops = &db8500_regulator_ops,	269	.ops = &db8500_regulator_ops,
264	.type = REGULATOR_VOLTAGE,	270	.type = REGULATOR_VOLTAGE,
@@ -271,6 +277,7 @@ dbx500_regulator_info[DB8500_NUM_REGULATORS] = { · 6 unmodified lines
271	[DB8500_REGULATOR_VSMPS3] = {	277	[DB8500_REGULATOR_VSMPS3] = {
272	.desc = {	278	.desc = {
273	.name = "db8500-vsmps3",	279	.name = "db8500-vsmps3",
		280	.of_match = of_match_ptr("db8500_vsmps3"),
274	.id = DB8500_REGULATOR_VSMPS3,	281	.id = DB8500_REGULATOR_VSMPS3,
275	.ops = &db8500_regulator_ops,	282	.ops = &db8500_regulator_ops,
276	.type = REGULATOR_VOLTAGE,	283	.type = REGULATOR_VOLTAGE,
@@ -280,6 +287,7 @@ dbx500_regulator_info[DB8500_NUM_REGULATORS] = { · 3 unmodified lines
280	[DB8500_REGULATOR_VRF1] = {	287	[DB8500_REGULATOR_VRF1] = {
281	.desc = {	288	.desc = {
282	.name = "db8500-vrf1",	289	.name = "db8500-vrf1",
		290	.of_match = of_match_ptr("db8500_vrf1"),
283	.id = DB8500_REGULATOR_VRF1,	291	.id = DB8500_REGULATOR_VRF1,
284	.ops = &db8500_regulator_ops,	292	.ops = &db8500_regulator_ops,
285	.type = REGULATOR_VOLTAGE,	293	.type = REGULATOR_VOLTAGE,
@@ -289,6 +297,7 @@ dbx500_regulator_info[DB8500_NUM_REGULATORS] = { · 3 unmodified lines
289	[DB8500_REGULATOR_SWITCH_SVAMMDSP] = {	297	[DB8500_REGULATOR_SWITCH_SVAMMDSP] = {
290	.desc = {	298	.desc = {
291	.name = "db8500-sva-mmdsp",	299	.name = "db8500-sva-mmdsp",
		300	.of_match = of_match_ptr("db8500_sva_mmdsp"),
292	.id = DB8500_REGULATOR_SWITCH_SVAMMDSP,	301	.id = DB8500_REGULATOR_SWITCH_SVAMMDSP,
293	.ops = &db8500_regulator_switch_ops,	302	.ops = &db8500_regulator_switch_ops,
294	.type = REGULATOR_VOLTAGE,	303	.type = REGULATOR_VOLTAGE,
@@ -299,6 +308,7 @@ dbx500_regulator_info[DB8500_NUM_REGULATORS] = { · 4 unmodified lines
299	[DB8500_REGULATOR_SWITCH_SVAMMDSPRET] = {	308	[DB8500_REGULATOR_SWITCH_SVAMMDSPRET] = {
300	.desc = {	309	.desc = {
301	.name = "db8500-sva-mmdsp-ret",	310	.name = "db8500-sva-mmdsp-ret",
		311	.of_match = of_match_ptr("db8500_sva_mmdsp_ret"),
302	.id = DB8500_REGULATOR_SWITCH_SVAMMDSPRET,	312	.id = DB8500_REGULATOR_SWITCH_SVAMMDSPRET,
303	.ops = &db8500_regulator_switch_ops,	313	.ops = &db8500_regulator_switch_ops,
304	.type = REGULATOR_VOLTAGE,	314	.type = REGULATOR_VOLTAGE,
@@ -310,6 +320,7 @@ dbx500_regulator_info[DB8500_NUM_REGULATORS] = { · 5 unmodified lines
310	[DB8500_REGULATOR_SWITCH_SVAPIPE] = {	320	[DB8500_REGULATOR_SWITCH_SVAPIPE] = {
311	.desc = {	321	.desc = {
312	.name = "db8500-sva-pipe",	322	.name = "db8500-sva-pipe",
		323	.of_match = of_match_ptr("db8500_sva_pipe"),
313	.id = DB8500_REGULATOR_SWITCH_SVAPIPE,	324	.id = DB8500_REGULATOR_SWITCH_SVAPIPE,
314	.ops = &db8500_regulator_switch_ops,	325	.ops = &db8500_regulator_switch_ops,
315	.type = REGULATOR_VOLTAGE,	326	.type = REGULATOR_VOLTAGE,
@@ -320,6 +331,7 @@ dbx500_regulator_info[DB8500_NUM_REGULATORS] = { · 4 unmodified lines
320	[DB8500_REGULATOR_SWITCH_SIAMMDSP] = {	331	[DB8500_REGULATOR_SWITCH_SIAMMDSP] = {
321	.desc = {	332	.desc = {
322	.name = "db8500-sia-mmdsp",	333	.name = "db8500-sia-mmdsp",
		334	.of_match = of_match_ptr("db8500_sia_mmdsp"),
323	.id = DB8500_REGULATOR_SWITCH_SIAMMDSP,	335	.id = DB8500_REGULATOR_SWITCH_SIAMMDSP,
324	.ops = &db8500_regulator_switch_ops,	336	.ops = &db8500_regulator_switch_ops,
325	.type = REGULATOR_VOLTAGE,	337	.type = REGULATOR_VOLTAGE,
@@ -330,6 +342,7 @@ dbx500_regulator_info[DB8500_NUM_REGULATORS] = { · 4 unmodified lines
330	[DB8500_REGULATOR_SWITCH_SIAMMDSPRET] = {	342	[DB8500_REGULATOR_SWITCH_SIAMMDSPRET] = {
331	.desc = {	343	.desc = {
332	.name = "db8500-sia-mmdsp-ret",	344	.name = "db8500-sia-mmdsp-ret",
		345	.of_match = of_match_ptr("db8500_sia_mmdsp_ret"),
333	.id = DB8500_REGULATOR_SWITCH_SIAMMDSPRET,	346	.id = DB8500_REGULATOR_SWITCH_SIAMMDSPRET,
334	.ops = &db8500_regulator_switch_ops,	347	.ops = &db8500_regulator_switch_ops,
335	.type = REGULATOR_VOLTAGE,	348	.type = REGULATOR_VOLTAGE,
@@ -341,6 +354,7 @@ dbx500_regulator_info[DB8500_NUM_REGULATORS] = { · 5 unmodified lines
341	[DB8500_REGULATOR_SWITCH_SIAPIPE] = {	354	[DB8500_REGULATOR_SWITCH_SIAPIPE] = {
342	.desc = {	355	.desc = {
343	.name = "db8500-sia-pipe",	356	.name = "db8500-sia-pipe",
		357	.of_match = of_match_ptr("db8500_sia_pipe"),
344	.id = DB8500_REGULATOR_SWITCH_SIAPIPE,	358	.id = DB8500_REGULATOR_SWITCH_SIAPIPE,
345	.ops = &db8500_regulator_switch_ops,	359	.ops = &db8500_regulator_switch_ops,
346	.type = REGULATOR_VOLTAGE,	360	.type = REGULATOR_VOLTAGE,
@@ -351,6 +365,7 @@ dbx500_regulator_info[DB8500_NUM_REGULATORS] = { · 4 unmodified lines
351	[DB8500_REGULATOR_SWITCH_SGA] = {	365	[DB8500_REGULATOR_SWITCH_SGA] = {
352	.desc = {	366	.desc = {
353	.name = "db8500-sga",	367	.name = "db8500-sga",
		368	.of_match = of_match_ptr("db8500_sga"),
354	.id = DB8500_REGULATOR_SWITCH_SGA,	369	.id = DB8500_REGULATOR_SWITCH_SGA,
355	.ops = &db8500_regulator_switch_ops,	370	.ops = &db8500_regulator_switch_ops,
356	.type = REGULATOR_VOLTAGE,	371	.type = REGULATOR_VOLTAGE,
@@ -361,6 +376,7 @@ dbx500_regulator_info[DB8500_NUM_REGULATORS] = { · 4 unmodified lines
361	[DB8500_REGULATOR_SWITCH_B2R2_MCDE] = {	376	[DB8500_REGULATOR_SWITCH_B2R2_MCDE] = {
362	.desc = {	377	.desc = {
363	.name = "db8500-b2r2-mcde",	378	.name = "db8500-b2r2-mcde",
		379	.of_match = of_match_ptr("db8500_b2r2_mcde"),
364	.id = DB8500_REGULATOR_SWITCH_B2R2_MCDE,	380	.id = DB8500_REGULATOR_SWITCH_B2R2_MCDE,
365	.ops = &db8500_regulator_switch_ops,	381	.ops = &db8500_regulator_switch_ops,
366	.type = REGULATOR_VOLTAGE,	382	.type = REGULATOR_VOLTAGE,
@@ -371,6 +387,7 @@ dbx500_regulator_info[DB8500_NUM_REGULATORS] = { · 4 unmodified lines
371	[DB8500_REGULATOR_SWITCH_ESRAM12] = {	387	[DB8500_REGULATOR_SWITCH_ESRAM12] = {
372	.desc = {	388	.desc = {
373	.name = "db8500-esram12",	389	.name = "db8500-esram12",
		390	.of_match = of_match_ptr("db8500_esram12"),
374	.id = DB8500_REGULATOR_SWITCH_ESRAM12,	391	.id = DB8500_REGULATOR_SWITCH_ESRAM12,
375	.ops = &db8500_regulator_switch_ops,	392	.ops = &db8500_regulator_switch_ops,
376	.type = REGULATOR_VOLTAGE,	393	.type = REGULATOR_VOLTAGE,
@@ -382,6 +399,7 @@ dbx500_regulator_info[DB8500_NUM_REGULATORS] = { · 5 unmodified lines
382	[DB8500_REGULATOR_SWITCH_ESRAM12RET] = {	399	[DB8500_REGULATOR_SWITCH_ESRAM12RET] = {
383	.desc = {	400	.desc = {
384	.name = "db8500-esram12-ret",	401	.name = "db8500-esram12-ret",
		402	.of_match = of_match_ptr("db8500_esram12_ret"),
385	.id = DB8500_REGULATOR_SWITCH_ESRAM12RET,	403	.id = DB8500_REGULATOR_SWITCH_ESRAM12RET,
386	.ops = &db8500_regulator_switch_ops,	404	.ops = &db8500_regulator_switch_ops,
387	.type = REGULATOR_VOLTAGE,	405	.type = REGULATOR_VOLTAGE,
@@ -393,6 +411,7 @@ dbx500_regulator_info[DB8500_NUM_REGULATORS] = { · 5 unmodified lines
393	[DB8500_REGULATOR_SWITCH_ESRAM34] = {	411	[DB8500_REGULATOR_SWITCH_ESRAM34] = {
394	.desc = {	412	.desc = {
395	.name = "db8500-esram34",	413	.name = "db8500-esram34",
		414	.of_match = of_match_ptr("db8500_esram34"),
396	.id = DB8500_REGULATOR_SWITCH_ESRAM34,	415	.id = DB8500_REGULATOR_SWITCH_ESRAM34,
397	.ops = &db8500_regulator_switch_ops,	416	.ops = &db8500_regulator_switch_ops,
398	.type = REGULATOR_VOLTAGE,	417	.type = REGULATOR_VOLTAGE,
@@ -404,6 +423,7 @@ dbx500_regulator_info[DB8500_NUM_REGULATORS] = { · 5 unmodified lines
404	[DB8500_REGULATOR_SWITCH_ESRAM34RET] = {	423	[DB8500_REGULATOR_SWITCH_ESRAM34RET] = {
405	.desc = {	424	.desc = {
406	.name = "db8500-esram34-ret",	425	.name = "db8500-esram34-ret",
		426	.of_match = of_match_ptr("db8500_esram34_ret"),
407	.id = DB8500_REGULATOR_SWITCH_ESRAM34RET,	427	.id = DB8500_REGULATOR_SWITCH_ESRAM34RET,
408	.ops = &db8500_regulator_switch_ops,	428	.ops = &db8500_regulator_switch_ops,
409	.type = REGULATOR_VOLTAGE,	429	.type = REGULATOR_VOLTAGE,
@@ -414,113 +434,38 @@ dbx500_regulator_info[DB8500_NUM_REGULATORS] = { · 4 unmodified lines
414	},	434	},
415	};	435	};
416		436
417	static int db8500_regulator_register(struct platform_device *pdev,	437	static int db8500_regulator_probe(struct platform_device *pdev)
418	struct regulator_init_data *init_data,
419	int id,
420	struct device_node *np)
421	{	438	{
		439	struct regulator_init_data *db8500_init_data;
422	struct dbx500_regulator_info *info;	440	struct dbx500_regulator_info *info;
423	struct regulator_config config = { };	441	struct regulator_config config = { };
424	int err;	442	struct regulator_dev *rdev;
425		443	int err, i;
426	/* assign per-regulator data */
427	info = &dbx500_regulator_info[id];
428	info->dev = &pdev->dev;
429
430	config.dev = &pdev->dev;
431	config.init_data = init_data;
432	config.driver_data = info;
433	config.of_node = np;
434
435	/* register with the regulator framework */
436	info->rdev = devm_regulator_register(&pdev->dev, &info->desc, &config);
437	if (IS_ERR(info->rdev)) {
438	err = PTR_ERR(info->rdev);
439	dev_err(&pdev->dev, "failed to register %s: err %i\n",
440	info->desc.name, err);
441	return err;
442	}
443
444	dev_dbg(rdev_get_dev(info->rdev),
445	"regulator-%s-probed\n", info->desc.name);
446		444
447	return 0;	445	db8500_init_data = dev_get_platdata(&pdev->dev);
448	}
449
450	static struct of_regulator_match db8500_regulator_matches[] = {
451	{ .name = "db8500_vape", .driver_data = (void *) DB8500_REGULATOR_VAPE, },
452	{ .name = "db8500_varm", .driver_data = (void *) DB8500_REGULATOR_VARM, },
453	{ .name = "db8500_vmodem", .driver_data = (void *) DB8500_REGULATOR_VMODEM, },
454	{ .name = "db8500_vpll", .driver_data = (void *) DB8500_REGULATOR_VPLL, },
455	{ .name = "db8500_vsmps1", .driver_data = (void *) DB8500_REGULATOR_VSMPS1, },
456	{ .name = "db8500_vsmps2", .driver_data = (void *) DB8500_REGULATOR_VSMPS2, },
457	{ .name = "db8500_vsmps3", .driver_data = (void *) DB8500_REGULATOR_VSMPS3, },
458	{ .name = "db8500_vrf1", .driver_data = (void *) DB8500_REGULATOR_VRF1, },
459	{ .name = "db8500_sva_mmdsp", .driver_data = (void *) DB8500_REGULATOR_SWITCH_SVAMMDSP, },
460	{ .name = "db8500_sva_mmdsp_ret", .driver_data = (void *) DB8500_REGULATOR_SWITCH_SVAMMDSPRET, },
461	{ .name = "db8500_sva_pipe", .driver_data = (void *) DB8500_REGULATOR_SWITCH_SVAPIPE, },
462	{ .name = "db8500_sia_mmdsp", .driver_data = (void *) DB8500_REGULATOR_SWITCH_SIAMMDSP, },
463	{ .name = "db8500_sia_mmdsp_ret", .driver_data = (void *) DB8500_REGULATOR_SWITCH_SIAMMDSPRET, },
464	{ .name = "db8500_sia_pipe", .driver_data = (void *) DB8500_REGULATOR_SWITCH_SIAPIPE, },
465	{ .name = "db8500_sga", .driver_data = (void *) DB8500_REGULATOR_SWITCH_SGA, },
466	{ .name = "db8500_b2r2_mcde", .driver_data = (void *) DB8500_REGULATOR_SWITCH_B2R2_MCDE, },
467	{ .name = "db8500_esram12", .driver_data = (void *) DB8500_REGULATOR_SWITCH_ESRAM12, },
468	{ .name = "db8500_esram12_ret", .driver_data = (void *) DB8500_REGULATOR_SWITCH_ESRAM12RET, },
469	{ .name = "db8500_esram34", .driver_data = (void *) DB8500_REGULATOR_SWITCH_ESRAM34, },
470	{ .name = "db8500_esram34_ret", .driver_data = (void *) DB8500_REGULATOR_SWITCH_ESRAM34RET, },
471	};
472
473	static int
474	db8500_regulator_of_probe(struct platform_device *pdev,
475	struct device_node *np)
476	{
477	int i, err;
478		446
479	for (i = 0; i < ARRAY_SIZE(dbx500_regulator_info); i++) {	447	for (i = 0; i < ARRAY_SIZE(dbx500_regulator_info); i++) {
480	err = db8500_regulator_register(	448	/* assign per-regulator data */
481	pdev, db8500_regulator_matches[i].init_data,	449	info = &dbx500_regulator_info[i];
482	i, db8500_regulator_matches[i].of_node);	450
483	if (err)	451	config.driver_data = info;
		452	config.dev = &pdev->dev;
		453	if (db8500_init_data)
		454	config.init_data = &db8500_init_data[i];
		455
		456	rdev = devm_regulator_register(&pdev->dev, &info->desc,
		457	&config);
		458	if (IS_ERR(rdev)) {
		459	err = PTR_ERR(rdev);
		460	dev_err(&pdev->dev, "failed to register %s: err %i\n",
		461	info->desc.name, err);
484	return err;	462	return err;
485	}
486
487	return 0;
488	}
489
490	static int db8500_regulator_probe(struct platform_device *pdev)
491	{
492	struct regulator_init_data *db8500_init_data =
493	dev_get_platdata(&pdev->dev);
494	struct device_node *np = pdev->dev.of_node;
495	int i, err;
496
497	/* register all regulators */
498	if (np) {
499	err = of_regulator_match(&pdev->dev, np,
500	db8500_regulator_matches,
501	ARRAY_SIZE(db8500_regulator_matches));
502	if (err < 0) {
503	dev_err(&pdev->dev,
504	"Error parsing regulator init data: %d\n", err);
505	return err;
506	}
507
508	err = db8500_regulator_of_probe(pdev, np);
509	if (err)
510	return err;
511	} else {
512	for (i = 0; i < ARRAY_SIZE(dbx500_regulator_info); i++) {
513	err = db8500_regulator_register(pdev,
514	&db8500_init_data[i],
515	i, NULL);
516	if (err)
517	return err;
518	}	463	}
		464	dev_dbg(&pdev->dev, "regulator-%s-probed\n", info->desc.name);
519	}	465	}
520		466
521	err = ux500_regulator_debug_init(pdev,	467	ux500_regulator_debug_init(pdev, dbx500_regulator_info,
522	dbx500_regulator_info,	468	ARRAY_SIZE(dbx500_regulator_info));
523	ARRAY_SIZE(dbx500_regulator_info));
524	return 0;	469	return 0;
525	}	470	}
526		471

drivers/regulator/dbx500-prcmu.h+0−4

 /**
  * struct dbx500_regulator_info - dbx500 regulator information
- * @dev: device pointer
  * @desc: regulator description
- * @rdev: regulator device pointer
  * @is_enabled: status of the regulator
  * @epod_id: id for EPOD (power domain)
  * @is_ramret: RAM retention switch for EPOD (power domain)
  *
  */
 struct dbx500_regulator_info {
-	struct device *dev;
 	struct regulator_desc desc;
-	struct regulator_dev *rdev;
 	bool is_enabled;
 	u16 epod_id;
 	bool is_ramret;

drivers/regulator/fan53555.c+27−33

@@ -1,17 +1,13 @@
1	/*	1	// SPDX-License-Identifier: GPL-2.0
2	* FAN53555 Fairchild Digitally Programmable TinyBuck Regulator Driver.	2	//
3	*	3	// FAN53555 Fairchild Digitally Programmable TinyBuck Regulator Driver.
4	* Supported Part Numbers:	4	//
5	* FAN53555UC00X/01X/03X/04X/05X	5	// Supported Part Numbers:
6	*	6	// FAN53555UC00X/01X/03X/04X/05X
7	* Copyright (c) 2012 Marvell Technology Ltd.	7	//
8	* Yunfan Zhang <yfzhang@marvell.com>	8	// Copyright (c) 2012 Marvell Technology Ltd.
9	*	9	// Yunfan Zhang <yfzhang@marvell.com>
10	* This package is free software; you can redistribute it and/or modify	10
11	* it under the terms of the GNU General Public License version 2 as
12	* published by the Free Software Foundation.
13	*
14	*/
15	#include <linux/module.h>	11	#include <linux/module.h>
16	#include <linux/param.h>	12	#include <linux/param.h>
17	#include <linux/err.h>	13	#include <linux/err.h>
@@ -91,10 +87,8 @@ enum { · 73 unmodified lines
91		87
92	struct fan53555_device_info {	88	struct fan53555_device_info {
93	enum fan53555_vendor vendor;	89	enum fan53555_vendor vendor;
94	struct regmap *regmap;
95	struct device *dev;	90	struct device *dev;
96	struct regulator_desc desc;	91	struct regulator_desc desc;
97	struct regulator_dev *rdev;
98	struct regulator_init_data *regulator;	92	struct regulator_init_data *regulator;
99	/* IC Type and Rev */	93	/* IC Type and Rev */
100	int chip_id;	94	int chip_id;
@@ -106,8 +100,6 @@ struct fan53555_device_info { · 5 unmodified lines
106	unsigned int vsel_min;	100	unsigned int vsel_min;
107	unsigned int vsel_step;	101	unsigned int vsel_step;
108	unsigned int vsel_count;	102	unsigned int vsel_count;
109	/* Voltage slew rate limiting */
110	unsigned int slew_rate;
111	/* Mode */	103	/* Mode */
112	unsigned int mode_reg;	104	unsigned int mode_reg;
113	unsigned int mode_mask;	105	unsigned int mode_mask;
@@ -125,7 +117,7 @@ static int fan53555_set_suspend_voltage(struct regulator_dev *rdev, int uV) · 11 unmodified lines
125	ret = regulator_map_voltage_linear(rdev, uV, uV);	117	ret = regulator_map_voltage_linear(rdev, uV, uV);
126	if (ret < 0)	118	if (ret < 0)
127	return ret;	119	return ret;
128	ret = regmap_update_bits(di->regmap, di->sleep_reg,	120	ret = regmap_update_bits(rdev->regmap, di->sleep_reg,
129	di->desc.vsel_mask, ret);	121	di->desc.vsel_mask, ret);
130	if (ret < 0)	122	if (ret < 0)
131	return ret;	123	return ret;
@@ -140,7 +132,7 @@ static int fan53555_set_suspend_enable(struct regulator_dev *rdev) · 8 unmodified lines
140	{	132	{
141	struct fan53555_device_info *di = rdev_get_drvdata(rdev);	133	struct fan53555_device_info *di = rdev_get_drvdata(rdev);
142		134
143	return regmap_update_bits(di->regmap, di->sleep_reg,	135	return regmap_update_bits(rdev->regmap, di->sleep_reg,
144	VSEL_BUCK_EN, VSEL_BUCK_EN);	136	VSEL_BUCK_EN, VSEL_BUCK_EN);
145	}	137	}
146		138
@@ -148,7 +140,7 @@ static int fan53555_set_suspend_disable(struct regulator_dev *rdev) · 1 unmodified line
148	{	140	{
149	struct fan53555_device_info *di = rdev_get_drvdata(rdev);	141	struct fan53555_device_info *di = rdev_get_drvdata(rdev);
150		142
151	return regmap_update_bits(di->regmap, di->sleep_reg,	143	return regmap_update_bits(rdev->regmap, di->sleep_reg,
152	VSEL_BUCK_EN, 0);	144	VSEL_BUCK_EN, 0);
153	}	145	}
154		146
@@ -158,11 +150,11 @@ static int fan53555_set_mode(struct regulator_dev *rdev, unsigned int mode) · 3 unmodified lines
158		150
159	switch (mode) {	151	switch (mode) {
160	case REGULATOR_MODE_FAST:	152	case REGULATOR_MODE_FAST:
161	regmap_update_bits(di->regmap, di->mode_reg,	153	regmap_update_bits(rdev->regmap, di->mode_reg,
162	di->mode_mask, di->mode_mask);	154	di->mode_mask, di->mode_mask);
163	break;	155	break;
164	case REGULATOR_MODE_NORMAL:	156	case REGULATOR_MODE_NORMAL:
165	regmap_update_bits(di->regmap, di->vol_reg, di->mode_mask, 0);	157	regmap_update_bits(rdev->regmap, di->vol_reg, di->mode_mask, 0);
166	break;	158	break;
167	default:	159	default:
168	return -EINVAL;	160	return -EINVAL;
@@ -176,7 +168,7 @@ static unsigned int fan53555_get_mode(struct regulator_dev *rdev) · 7 unmodified lines
176	unsigned int val;	168	unsigned int val;
177	int ret = 0;	169	int ret = 0;
178		170
179	ret = regmap_read(di->regmap, di->mode_reg, &val);	171	ret = regmap_read(rdev->regmap, di->mode_reg, &val);
180	if (ret < 0)	172	if (ret < 0)
181	return ret;	173	return ret;
182	if (val & di->mode_mask)	174	if (val & di->mode_mask)
@@ -213,7 +205,7 @@ static int fan53555_set_ramp(struct regulator_dev *rdev, int ramp) · 30 unmodified lines
213	return -EINVAL;	205	return -EINVAL;
214	}	206	}
215		207
216	return regmap_update_bits(di->regmap, FAN53555_CONTROL,	208	return regmap_update_bits(rdev->regmap, FAN53555_CONTROL,
217	CTL_SLEW_MASK, regval << CTL_SLEW_SHIFT);	209	CTL_SLEW_MASK, regval << CTL_SLEW_SHIFT);
218	}	210	}
219		211
@@ -396,6 +388,7 @@ static int fan53555_regulator_register(struct fan53555_device_info *di, · 176 unmodified lines
396	struct regulator_config *config)	388	struct regulator_config *config)
397	{	389	{
398	struct regulator_desc *rdesc = &di->desc;	390	struct regulator_desc *rdesc = &di->desc;
		391	struct regulator_dev *rdev;
399		392
400	rdesc->name = "fan53555-reg";	393	rdesc->name = "fan53555-reg";
401	rdesc->supply_name = "vin";	394	rdesc->supply_name = "vin";
@@ -410,8 +403,8 @@ static int fan53555_regulator_register(struct fan53555_device_info *di, · 8 unmodified lines
410	rdesc->vsel_mask = di->vsel_count - 1;	403	rdesc->vsel_mask = di->vsel_count - 1;
411	rdesc->owner = THIS_MODULE;	404	rdesc->owner = THIS_MODULE;
412		405
413	di->rdev = devm_regulator_register(di->dev, &di->desc, config);	406	rdev = devm_regulator_register(di->dev, &di->desc, config);
414	return PTR_ERR_OR_ZERO(di->rdev);	407	return PTR_ERR_OR_ZERO(rdev);
415	}	408	}
416		409
417	static const struct regmap_config fan53555_regmap_config = {	410	static const struct regmap_config fan53555_regmap_config = {
@@ -466,6 +459,7 @@ static int fan53555_regulator_probe(struct i2c_client *client, · 48 unmodified lines
466	struct fan53555_device_info *di;	459	struct fan53555_device_info *di;
467	struct fan53555_platform_data *pdata;	460	struct fan53555_platform_data *pdata;
468	struct regulator_config config = { };	461	struct regulator_config config = { };
		462	struct regmap *regmap;
469	unsigned int val;	463	unsigned int val;
470	int ret;	464	int ret;
471		465
@@ -502,22 +496,22 @@ static int fan53555_regulator_probe(struct i2c_client *client, · 30 unmodified lines
502	di->vendor = id->driver_data;	496	di->vendor = id->driver_data;
503	}	497	}
504		498
505	di->regmap = devm_regmap_init_i2c(client, &fan53555_regmap_config);	499	regmap = devm_regmap_init_i2c(client, &fan53555_regmap_config);
506	if (IS_ERR(di->regmap)) {	500	if (IS_ERR(regmap)) {
507	dev_err(&client->dev, "Failed to allocate regmap!\n");	501	dev_err(&client->dev, "Failed to allocate regmap!\n");
508	return PTR_ERR(di->regmap);	502	return PTR_ERR(regmap);
509	}	503	}
510	di->dev = &client->dev;	504	di->dev = &client->dev;
511	i2c_set_clientdata(client, di);	505	i2c_set_clientdata(client, di);
512	/* Get chip ID */	506	/* Get chip ID */
513	ret = regmap_read(di->regmap, FAN53555_ID1, &val);	507	ret = regmap_read(regmap, FAN53555_ID1, &val);
514	if (ret < 0) {	508	if (ret < 0) {
515	dev_err(&client->dev, "Failed to get chip ID!\n");	509	dev_err(&client->dev, "Failed to get chip ID!\n");
516	return ret;	510	return ret;
517	}	511	}
518	di->chip_id = val & DIE_ID;	512	di->chip_id = val & DIE_ID;
519	/* Get chip revision */	513	/* Get chip revision */
520	ret = regmap_read(di->regmap, FAN53555_ID2, &val);	514	ret = regmap_read(regmap, FAN53555_ID2, &val);
521	if (ret < 0) {	515	if (ret < 0) {
522	dev_err(&client->dev, "Failed to get chip Rev!\n");	516	dev_err(&client->dev, "Failed to get chip Rev!\n");
523	return ret;	517	return ret;
@@ -534,7 +528,7 @@ static int fan53555_regulator_probe(struct i2c_client *client, · 10 unmodified lines
534	/* Register regulator */	528	/* Register regulator */
535	config.dev = di->dev;	529	config.dev = di->dev;
536	config.init_data = di->regulator;	530	config.init_data = di->regulator;
537	config.regmap = di->regmap;	531	config.regmap = regmap;
538	config.driver_data = di;	532	config.driver_data = di;
539	config.of_node = np;	533	config.of_node = np;
540		534

drivers/regulator/gpio-regulator.c+6−16

 struct gpio_regulator_data {
 	struct regulator_desc desc;
-	struct regulator_dev *dev;
 	struct gpio_desc **gpiods;
 	int nr_gpios;
 	return 0;
 }
-static struct regulator_ops gpio_regulator_voltage_ops = {
+static const struct regulator_ops gpio_regulator_voltage_ops = {
 	.get_voltage = gpio_regulator_get_value,
 	.set_voltage = gpio_regulator_set_voltage,
 	.list_voltage = gpio_regulator_list_voltage,
 	return config;
 }
-static struct regulator_ops gpio_regulator_current_ops = {
+static const struct regulator_ops gpio_regulator_current_ops = {
 	.get_current_limit = gpio_regulator_get_value,
 	.set_current_limit = gpio_regulator_set_current_limit,
 };
 	struct device_node *np = dev->of_node;
 	struct gpio_regulator_data *drvdata;
 	struct regulator_config cfg = { };
+	struct regulator_dev *rdev;
 	enum gpiod_flags gflags;
 	int ptr, ret, state, i;
 	if (IS_ERR(cfg.ena_gpiod))
 		return PTR_ERR(cfg.ena_gpiod);
-	drvdata->dev = regulator_register(&drvdata->desc, &cfg);
+	rdev = devm_regulator_register(dev, &drvdata->desc, &cfg);
-	if (IS_ERR(drvdata->dev)) {
+	if (IS_ERR(rdev)) {
-		ret = PTR_ERR(drvdata->dev);
+		ret = PTR_ERR(rdev);
 		dev_err(dev, "Failed to register regulator: %d\n", ret);
 		return ret;
 	}
 	return 0;
 }
-static int gpio_regulator_remove(struct platform_device *pdev)
-{
-	struct gpio_regulator_data *drvdata = platform_get_drvdata(pdev);
-	regulator_unregister(drvdata->dev);
-	return 0;
-}
 #if defined(CONFIG_OF)
 static const struct of_device_id regulator_gpio_of_match[] = {
 	{ .compatible = "regulator-gpio", },
 static struct platform_driver gpio_regulator_driver = {
 	.probe		= gpio_regulator_probe,
-	.remove		= gpio_regulator_remove,
 	.driver		= {
 		.name		= "gpio-regulator",
 		.of_match_table = of_match_ptr(regulator_gpio_of_match),

drivers/regulator/hi6421-regulator.c+88−144

@@ -1,17 +1,13 @@
1	/*	1	// SPDX-License-Identifier: GPL-2.0
2	* Device driver for regulators in Hi6421 IC	2	//
3	*	3	// Device driver for regulators in Hi6421 IC
4	* Copyright (c) <2011-2014> HiSilicon Technologies Co., Ltd.	4	//
5	* http://www.hisilicon.com	5	// Copyright (c) <2011-2014> HiSilicon Technologies Co., Ltd.
6	* Copyright (c) <2013-2014> Linaro Ltd.	6	// http://www.hisilicon.com
7	* http://www.linaro.org	7	// Copyright (c) <2013-2014> Linaro Ltd.
8	*	8	// http://www.linaro.org
9	* Author: Guodong Xu <guodong.xu@linaro.org>	9	//
10	*	10	// Author: Guodong Xu <guodong.xu@linaro.org>
11	* This program is free software; you can redistribute it and/or modify
12	* it under the terms of the GNU General Public License version 2 as
13	* published by the Free Software Foundation.
14	*/
15		11
16	#include <linux/slab.h>	12	#include <linux/slab.h>
17	#include <linux/device.h>	13	#include <linux/device.h>
@@ -78,43 +74,6 @@ enum hi6421_regulator_id { · 60 unmodified lines
78	HI6421_NUM_REGULATORS,	74	HI6421_NUM_REGULATORS,
79	};	75	};
80		76
81	#define HI6421_REGULATOR_OF_MATCH(_name, id) \
82	{ \
83	.name = #_name, \
84	.driver_data = (void *) HI6421_##id, \
85	}
86
87	static struct of_regulator_match hi6421_regulator_match[] = {
88	HI6421_REGULATOR_OF_MATCH(hi6421_vout0, LDO0),
89	HI6421_REGULATOR_OF_MATCH(hi6421_vout1, LDO1),
90	HI6421_REGULATOR_OF_MATCH(hi6421_vout2, LDO2),
91	HI6421_REGULATOR_OF_MATCH(hi6421_vout3, LDO3),
92	HI6421_REGULATOR_OF_MATCH(hi6421_vout4, LDO4),
93	HI6421_REGULATOR_OF_MATCH(hi6421_vout5, LDO5),
94	HI6421_REGULATOR_OF_MATCH(hi6421_vout6, LDO6),
95	HI6421_REGULATOR_OF_MATCH(hi6421_vout7, LDO7),
96	HI6421_REGULATOR_OF_MATCH(hi6421_vout8, LDO8),
97	HI6421_REGULATOR_OF_MATCH(hi6421_vout9, LDO9),
98	HI6421_REGULATOR_OF_MATCH(hi6421_vout10, LDO10),
99	HI6421_REGULATOR_OF_MATCH(hi6421_vout11, LDO11),
100	HI6421_REGULATOR_OF_MATCH(hi6421_vout12, LDO12),
101	HI6421_REGULATOR_OF_MATCH(hi6421_vout13, LDO13),
102	HI6421_REGULATOR_OF_MATCH(hi6421_vout14, LDO14),
103	HI6421_REGULATOR_OF_MATCH(hi6421_vout15, LDO15),
104	HI6421_REGULATOR_OF_MATCH(hi6421_vout16, LDO16),
105	HI6421_REGULATOR_OF_MATCH(hi6421_vout17, LDO17),
106	HI6421_REGULATOR_OF_MATCH(hi6421_vout18, LDO18),
107	HI6421_REGULATOR_OF_MATCH(hi6421_vout19, LDO19),
108	HI6421_REGULATOR_OF_MATCH(hi6421_vout20, LDO20),
109	HI6421_REGULATOR_OF_MATCH(hi6421_vout_audio, LDOAUDIO),
110	HI6421_REGULATOR_OF_MATCH(hi6421_buck0, BUCK0),
111	HI6421_REGULATOR_OF_MATCH(hi6421_buck1, BUCK1),
112	HI6421_REGULATOR_OF_MATCH(hi6421_buck2, BUCK2),
113	HI6421_REGULATOR_OF_MATCH(hi6421_buck3, BUCK3),
114	HI6421_REGULATOR_OF_MATCH(hi6421_buck4, BUCK4),
115	HI6421_REGULATOR_OF_MATCH(hi6421_buck5, BUCK5),
116	};
117
118	/* LDO 0, 4~7, 9~14, 16~20 have same voltage table. */	77	/* LDO 0, 4~7, 9~14, 16~20 have same voltage table. */
119	static const unsigned int ldo_0_voltages[] = {	78	static const unsigned int ldo_0_voltages[] = {
120	1500000, 1800000, 2400000, 2500000,	79	1500000, 1800000, 2400000, 2500000,
@@ -157,6 +116,7 @@ static const struct regulator_ops hi6421_buck345_ops; · 36 unmodified lines
157	#define HI6421_LDO_ENABLE_TIME (350)	116	#define HI6421_LDO_ENABLE_TIME (350)
158	/*	117	/*
159	* _id - LDO id name string	118	* _id - LDO id name string
		119	* _match - of match name string
160	* v_table - voltage table	120	* v_table - voltage table
161	* vreg - voltage select register	121	* vreg - voltage select register
162	* vmask - voltage select mask	122	* vmask - voltage select mask
@@ -166,11 +126,13 @@ static const struct regulator_ops hi6421_buck345_ops; · 3 unmodified lines
166	* ecomask - eco mode mask	126	* ecomask - eco mode mask
167	* ecoamp - eco mode load uppler limit in uA	127	* ecoamp - eco mode load uppler limit in uA
168	*/	128	*/
169	#define HI6421_LDO(_id, v_table, vreg, vmask, ereg, emask, \	129	#define HI6421_LDO(_id, _match, v_table, vreg, vmask, ereg, emask, \
170	odelay, ecomask, ecoamp) \	130	odelay, ecomask, ecoamp) \
171	[HI6421_##_id] = { \	131	[HI6421_##_id] = { \
172	.desc = { \	132	.desc = { \
173	.name = #_id, \	133	.name = #_id, \
		134	.of_match = of_match_ptr(#_match), \
		135	.regulators_node = of_match_ptr("regulators"), \
174	.ops = &hi6421_ldo_ops, \	136	.ops = &hi6421_ldo_ops, \
175	.type = REGULATOR_VOLTAGE, \	137	.type = REGULATOR_VOLTAGE, \
176	.id = HI6421_##_id, \	138	.id = HI6421_##_id, \
@@ -191,6 +153,7 @@ static const struct regulator_ops hi6421_buck345_ops; · 14 unmodified lines
191	/* HI6421 LDO1~3 are linear voltage regulators at fixed uV_step	153	/* HI6421 LDO1~3 are linear voltage regulators at fixed uV_step
192	*	154	*
193	* _id - LDO id name string	155	* _id - LDO id name string
		156	* _match - of match name string
194	* _min_uV - minimum voltage supported in uV	157	* _min_uV - minimum voltage supported in uV
195	* n_volt - number of votages available	158	* n_volt - number of votages available
196	* vstep - voltage increase in each linear step in uV	159	* vstep - voltage increase in each linear step in uV
@@ -202,11 +165,13 @@ static const struct regulator_ops hi6421_buck345_ops; · 5 unmodified lines
202	* ecomask - eco mode mask	165	* ecomask - eco mode mask
203	* ecoamp - eco mode load uppler limit in uA	166	* ecoamp - eco mode load uppler limit in uA
204	*/	167	*/
205	#define HI6421_LDO_LINEAR(_id, _min_uV, n_volt, vstep, vreg, vmask, \	168	#define HI6421_LDO_LINEAR(_id, _match, _min_uV, n_volt, vstep, vreg, vmask,\
206	ereg, emask, odelay, ecomask, ecoamp) \	169	ereg, emask, odelay, ecomask, ecoamp) \
207	[HI6421_##_id] = { \	170	[HI6421_##_id] = { \
208	.desc = { \	171	.desc = { \
209	.name = #_id, \	172	.name = #_id, \
		173	.of_match = of_match_ptr(#_match), \
		174	.regulators_node = of_match_ptr("regulators"), \
210	.ops = &hi6421_ldo_linear_ops, \	175	.ops = &hi6421_ldo_linear_ops, \
211	.type = REGULATOR_VOLTAGE, \	176	.type = REGULATOR_VOLTAGE, \
212	.id = HI6421_##_id, \	177	.id = HI6421_##_id, \
@@ -228,6 +193,7 @@ static const struct regulator_ops hi6421_buck345_ops; · 15 unmodified lines
228	/* HI6421 LDOAUDIO is a linear voltage regulator with two 4-step ranges	193	/* HI6421 LDOAUDIO is a linear voltage regulator with two 4-step ranges
229	*	194	*
230	* _id - LDO id name string	195	* _id - LDO id name string
		196	* _match - of match name string
231	* n_volt - number of votages available	197	* n_volt - number of votages available
232	* volt_ranges - array of regulator_linear_range	198	* volt_ranges - array of regulator_linear_range
233	* vstep - voltage increase in each linear step in uV	199	* vstep - voltage increase in each linear step in uV
@@ -239,11 +205,13 @@ static const struct regulator_ops hi6421_buck345_ops; · 5 unmodified lines
239	* ecomask - eco mode mask	205	* ecomask - eco mode mask
240	* ecoamp - eco mode load uppler limit in uA	206	* ecoamp - eco mode load uppler limit in uA
241	*/	207	*/
242	#define HI6421_LDO_LINEAR_RANGE(_id, n_volt, volt_ranges, vreg, vmask, \	208	#define HI6421_LDO_LINEAR_RANGE(_id, _match, n_volt, volt_ranges, vreg, vmask,\
243	ereg, emask, odelay, ecomask, ecoamp) \	209	ereg, emask, odelay, ecomask, ecoamp) \
244	[HI6421_##_id] = { \	210	[HI6421_##_id] = { \
245	.desc = { \	211	.desc = { \
246	.name = #_id, \	212	.name = #_id, \
		213	.of_match = of_match_ptr(#_match), \
		214	.regulators_node = of_match_ptr("regulators"), \
247	.ops = &hi6421_ldo_linear_range_ops, \	215	.ops = &hi6421_ldo_linear_range_ops, \
248	.type = REGULATOR_VOLTAGE, \	216	.type = REGULATOR_VOLTAGE, \
249	.id = HI6421_##_id, \	217	.id = HI6421_##_id, \
@@ -265,6 +233,7 @@ static const struct regulator_ops hi6421_buck345_ops; · 15 unmodified lines
265	/* HI6421 BUCK0/1/2 are linear voltage regulators at fixed uV_step	233	/* HI6421 BUCK0/1/2 are linear voltage regulators at fixed uV_step
266	*	234	*
267	* _id - BUCK0/1/2 id name string	235	* _id - BUCK0/1/2 id name string
		236	* _match - of match name string
268	* vreg - voltage select register	237	* vreg - voltage select register
269	* vmask - voltage select mask	238	* vmask - voltage select mask
270	* ereg - enable register	239	* ereg - enable register
@@ -273,11 +242,13 @@ static const struct regulator_ops hi6421_buck345_ops; · 2 unmodified lines
273	* etime - enable time	242	* etime - enable time
274	* odelay - off/on delay time in uS	243	* odelay - off/on delay time in uS
275	*/	244	*/
276	#define HI6421_BUCK012(_id, vreg, vmask, ereg, emask, sleepmask, \	245	#define HI6421_BUCK012(_id, _match, vreg, vmask, ereg, emask, sleepmask,\
277	etime, odelay) \	246	etime, odelay) \
278	[HI6421_##_id] = { \	247	[HI6421_##_id] = { \
279	.desc = { \	248	.desc = { \
280	.name = #_id, \	249	.name = #_id, \
		250	.of_match = of_match_ptr(#_match), \
		251	.regulators_node = of_match_ptr("regulators"), \
281	.ops = &hi6421_buck012_ops, \	252	.ops = &hi6421_buck012_ops, \
282	.type = REGULATOR_VOLTAGE, \	253	.type = REGULATOR_VOLTAGE, \
283	.id = HI6421_##_id, \	254	.id = HI6421_##_id, \
@@ -299,6 +270,7 @@ static const struct regulator_ops hi6421_buck345_ops; · 15 unmodified lines
299	* that it supports SLEEP mode, so has different .ops.	270	* that it supports SLEEP mode, so has different .ops.
300	*	271	*
301	* _id - LDO id name string	272	* _id - LDO id name string
		273	* _match - of match name string
302	* v_table - voltage table	274	* v_table - voltage table
303	* vreg - voltage select register	275	* vreg - voltage select register
304	* vmask - voltage select mask	276	* vmask - voltage select mask
@@ -307,11 +279,13 @@ static const struct regulator_ops hi6421_buck345_ops; · 2 unmodified lines
307	* odelay - off/on delay time in uS	279	* odelay - off/on delay time in uS
308	* sleepmask - mask of sleep mode	280	* sleepmask - mask of sleep mode
309	*/	281	*/
310	#define HI6421_BUCK345(_id, v_table, vreg, vmask, ereg, emask, \	282	#define HI6421_BUCK345(_id, _match, v_table, vreg, vmask, ereg, emask, \
311	odelay, sleepmask) \	283	odelay, sleepmask) \
312	[HI6421_##_id] = { \	284	[HI6421_##_id] = { \
313	.desc = { \	285	.desc = { \
314	.name = #_id, \	286	.name = #_id, \
		287	.of_match = of_match_ptr(#_match), \
		288	.regulators_node = of_match_ptr("regulators"), \
315	.ops = &hi6421_buck345_ops, \	289	.ops = &hi6421_buck345_ops, \
316	.type = REGULATOR_VOLTAGE, \	290	.type = REGULATOR_VOLTAGE, \
317	.id = HI6421_##_id, \	291	.id = HI6421_##_id, \
@@ -331,59 +305,63 @@ static const struct regulator_ops hi6421_buck345_ops; · 13 unmodified lines
331	/* HI6421 regulator information */	305	/* HI6421 regulator information */
332	static struct hi6421_regulator_info	306	static struct hi6421_regulator_info
333	hi6421_regulator_info[HI6421_NUM_REGULATORS] = {	307	hi6421_regulator_info[HI6421_NUM_REGULATORS] = {
334	HI6421_LDO(LDO0, ldo_0_voltages, 0x20, 0x07, 0x20, 0x10,	308	HI6421_LDO(LDO0, hi6421_vout0, ldo_0_voltages, 0x20, 0x07, 0x20, 0x10,
335	10000, 0x20, 8000),	309	10000, 0x20, 8000),
336	HI6421_LDO_LINEAR(LDO1, 1700000, 4, 100000, 0x21, 0x03, 0x21, 0x10,	310	HI6421_LDO_LINEAR(LDO1, hi6421_vout1, 1700000, 4, 100000, 0x21, 0x03,
337	10000, 0x20, 5000),	311	0x21, 0x10, 10000, 0x20, 5000),
338	HI6421_LDO_LINEAR(LDO2, 1050000, 8, 50000, 0x22, 0x07, 0x22, 0x10,	312	HI6421_LDO_LINEAR(LDO2, hi6421_vout2, 1050000, 8, 50000, 0x22, 0x07,
339	20000, 0x20, 8000),	313	0x22, 0x10, 20000, 0x20, 8000),
340	HI6421_LDO_LINEAR(LDO3, 1050000, 8, 50000, 0x23, 0x07, 0x23, 0x10,	314	HI6421_LDO_LINEAR(LDO3, hi6421_vout3, 1050000, 8, 50000, 0x23, 0x07,
341	20000, 0x20, 8000),	315	0x23, 0x10, 20000, 0x20, 8000),
342	HI6421_LDO(LDO4, ldo_0_voltages, 0x24, 0x07, 0x24, 0x10,	316	HI6421_LDO(LDO4, hi6421_vout4, ldo_0_voltages, 0x24, 0x07, 0x24, 0x10,
343	20000, 0x20, 8000),	317	20000, 0x20, 8000),
344	HI6421_LDO(LDO5, ldo_0_voltages, 0x25, 0x07, 0x25, 0x10,	318	HI6421_LDO(LDO5, hi6421_vout5, ldo_0_voltages, 0x25, 0x07, 0x25, 0x10,
345	20000, 0x20, 8000),	319	20000, 0x20, 8000),
346	HI6421_LDO(LDO6, ldo_0_voltages, 0x26, 0x07, 0x26, 0x10,	320	HI6421_LDO(LDO6, hi6421_vout6, ldo_0_voltages, 0x26, 0x07, 0x26, 0x10,
347	20000, 0x20, 8000),	321	20000, 0x20, 8000),
348	HI6421_LDO(LDO7, ldo_0_voltages, 0x27, 0x07, 0x27, 0x10,	322	HI6421_LDO(LDO7, hi6421_vout7, ldo_0_voltages, 0x27, 0x07, 0x27, 0x10,
349	20000, 0x20, 5000),	323	20000, 0x20, 5000),
350	HI6421_LDO(LDO8, ldo_8_voltages, 0x28, 0x07, 0x28, 0x10,	324	HI6421_LDO(LDO8, hi6421_vout8, ldo_8_voltages, 0x28, 0x07, 0x28, 0x10,
351	20000, 0x20, 8000),	325	20000, 0x20, 8000),
352	HI6421_LDO(LDO9, ldo_0_voltages, 0x29, 0x07, 0x29, 0x10,	326	HI6421_LDO(LDO9, hi6421_vout9, ldo_0_voltages, 0x29, 0x07, 0x29, 0x10,
353	40000, 0x20, 8000),	327	40000, 0x20, 8000),
354	HI6421_LDO(LDO10, ldo_0_voltages, 0x2a, 0x07, 0x2a, 0x10,	328	HI6421_LDO(LDO10, hi6421_vout10, ldo_0_voltages, 0x2a, 0x07, 0x2a, 0x10,
355	40000, 0x20, 8000),	329	40000, 0x20, 8000),
356	HI6421_LDO(LDO11, ldo_0_voltages, 0x2b, 0x07, 0x2b, 0x10,	330	HI6421_LDO(LDO11, hi6421_vout11, ldo_0_voltages, 0x2b, 0x07, 0x2b, 0x10,
357	40000, 0x20, 8000),	331	40000, 0x20, 8000),
358	HI6421_LDO(LDO12, ldo_0_voltages, 0x2c, 0x07, 0x2c, 0x10,	332	HI6421_LDO(LDO12, hi6421_vout12, ldo_0_voltages, 0x2c, 0x07, 0x2c, 0x10,
359	40000, 0x20, 8000),	333	40000, 0x20, 8000),
360	HI6421_LDO(LDO13, ldo_0_voltages, 0x2d, 0x07, 0x2d, 0x10,	334	HI6421_LDO(LDO13, hi6421_vout13, ldo_0_voltages, 0x2d, 0x07, 0x2d, 0x10,
361	40000, 0x20, 8000),	335	40000, 0x20, 8000),
362	HI6421_LDO(LDO14, ldo_0_voltages, 0x2e, 0x07, 0x2e, 0x10,	336	HI6421_LDO(LDO14, hi6421_vout14, ldo_0_voltages, 0x2e, 0x07, 0x2e, 0x10,
363	40000, 0x20, 8000),	337	40000, 0x20, 8000),
364	HI6421_LDO(LDO15, ldo_8_voltages, 0x2f, 0x07, 0x2f, 0x10,	338	HI6421_LDO(LDO15, hi6421_vout15, ldo_8_voltages, 0x2f, 0x07, 0x2f, 0x10,
365	40000, 0x20, 8000),	339	40000, 0x20, 8000),
366	HI6421_LDO(LDO16, ldo_0_voltages, 0x30, 0x07, 0x30, 0x10,	340	HI6421_LDO(LDO16, hi6421_vout16, ldo_0_voltages, 0x30, 0x07, 0x30, 0x10,
367	40000, 0x20, 8000),	341	40000, 0x20, 8000),
368	HI6421_LDO(LDO17, ldo_0_voltages, 0x31, 0x07, 0x31, 0x10,	342	HI6421_LDO(LDO17, hi6421_vout17, ldo_0_voltages, 0x31, 0x07, 0x31, 0x10,
369	40000, 0x20, 8000),	343	40000, 0x20, 8000),
370	HI6421_LDO(LDO18, ldo_0_voltages, 0x32, 0x07, 0x32, 0x10,	344	HI6421_LDO(LDO18, hi6421_vout18, ldo_0_voltages, 0x32, 0x07, 0x32, 0x10,
371	40000, 0x20, 8000),	345	40000, 0x20, 8000),
372	HI6421_LDO(LDO19, ldo_0_voltages, 0x33, 0x07, 0x33, 0x10,	346	HI6421_LDO(LDO19, hi6421_vout19, ldo_0_voltages, 0x33, 0x07, 0x33, 0x10,
373	40000, 0x20, 8000),	347	40000, 0x20, 8000),
374	HI6421_LDO(LDO20, ldo_0_voltages, 0x34, 0x07, 0x34, 0x10,	348	HI6421_LDO(LDO20, hi6421_vout20, ldo_0_voltages, 0x34, 0x07, 0x34, 0x10,
375	40000, 0x20, 8000),	349	40000, 0x20, 8000),
376	HI6421_LDO_LINEAR_RANGE(LDOAUDIO, 8, ldo_audio_volt_range, 0x36,	350	HI6421_LDO_LINEAR_RANGE(LDOAUDIO, hi6421_vout_audio, 8,
377	0x70, 0x36, 0x01, 40000, 0x02, 5000),	351	ldo_audio_volt_range, 0x36, 0x70, 0x36, 0x01,
378	HI6421_BUCK012(BUCK0, 0x0d, 0x7f, 0x0c, 0x01, 0x10, 400, 20000),	352	40000, 0x02, 5000),
379	HI6421_BUCK012(BUCK1, 0x0f, 0x7f, 0x0e, 0x01, 0x10, 400, 20000),	353	HI6421_BUCK012(BUCK0, hi6421_buck0, 0x0d, 0x7f, 0x0c, 0x01, 0x10, 400,
380	HI6421_BUCK012(BUCK2, 0x11, 0x7f, 0x10, 0x01, 0x10, 350, 100),	354	20000),
381	HI6421_BUCK345(BUCK3, buck_3_voltages, 0x13, 0x07, 0x12, 0x01,	355	HI6421_BUCK012(BUCK1, hi6421_buck1, 0x0f, 0x7f, 0x0e, 0x01, 0x10, 400,
382	20000, 0x10),	356	20000),
383	HI6421_BUCK345(BUCK4, buck_4_voltages, 0x15, 0x07, 0x14, 0x01,	357	HI6421_BUCK012(BUCK2, hi6421_buck2, 0x11, 0x7f, 0x10, 0x01, 0x10, 350,
384	20000, 0x10),	358	100),
385	HI6421_BUCK345(BUCK5, buck_5_voltages, 0x17, 0x07, 0x16, 0x01,	359	HI6421_BUCK345(BUCK3, hi6421_buck3, buck_3_voltages, 0x13, 0x07, 0x12,
386	20000, 0x10),	360	0x01, 20000, 0x10),
		361	HI6421_BUCK345(BUCK4, hi6421_buck4, buck_4_voltages, 0x15, 0x07, 0x14,
		362	0x01, 20000, 0x10),
		363	HI6421_BUCK345(BUCK5, hi6421_buck5, buck_5_voltages, 0x17, 0x07, 0x16,
		364	0x01, 20000, 0x10),
387	};	365	};
388		366
389	static int hi6421_regulator_enable(struct regulator_dev *rdev)	367	static int hi6421_regulator_enable(struct regulator_dev *rdev)
@@ -552,42 +530,14 @@ static const struct regulator_ops hi6421_buck345_ops = { · 162 unmodified lines
552	.set_mode = hi6421_regulator_buck_set_mode,	530	.set_mode = hi6421_regulator_buck_set_mode,
553	};	531	};
554		532
555	static int hi6421_regulator_register(struct platform_device *pdev,
556	struct regmap *rmap,
557	struct regulator_init_data *init_data,
558	int id, struct device_node *np)
559	{
560	struct hi6421_regulator_info *info = NULL;
561	struct regulator_config config = { };
562	struct regulator_dev *rdev;
563
564	/* assign per-regulator data */
565	info = &hi6421_regulator_info[id];
566
567	config.dev = &pdev->dev;
568	config.init_data = init_data;
569	config.driver_data = info;
570	config.regmap = rmap;
571	config.of_node = np;
572
573	/* register regulator with framework */
574	rdev = devm_regulator_register(&pdev->dev, &info->desc, &config);
575	if (IS_ERR(rdev)) {
576	dev_err(&pdev->dev, "failed to register regulator %s\n",
577	info->desc.name);
578	return PTR_ERR(rdev);
579	}
580
581	return 0;
582	}
583
584	static int hi6421_regulator_probe(struct platform_device *pdev)	533	static int hi6421_regulator_probe(struct platform_device *pdev)
585	{	534	{
586	struct device *dev = &pdev->dev;	535	struct hi6421_pmic *pmic = dev_get_drvdata(pdev->dev.parent);
587	struct device_node *np;
588	struct hi6421_pmic *pmic;
589	struct hi6421_regulator_pdata *pdata;	536	struct hi6421_regulator_pdata *pdata;
590	int i, ret = 0;	537	struct hi6421_regulator_info *info;
		538	struct regulator_config config = { };
		539	struct regulator_dev *rdev;
		540	int i;
591		541
592	pdata = devm_kzalloc(&pdev->dev, sizeof(*pdata), GFP_KERNEL);	542	pdata = devm_kzalloc(&pdev->dev, sizeof(*pdata), GFP_KERNEL);
593	if (!pdata)	543	if (!pdata)
@@ -595,27 +545,21 @@ static int hi6421_regulator_probe(struct platform_device *pdev) · 1 unmodified line
595	mutex_init(&pdata->lock);	545	mutex_init(&pdata->lock);
596	platform_set_drvdata(pdev, pdata);	546	platform_set_drvdata(pdev, pdata);
597		547
598	np = of_get_child_by_name(dev->parent->of_node, "regulators");
599	if (!np)
600	return -ENODEV;
601
602	ret = of_regulator_match(dev, np,
603	hi6421_regulator_match,
604	ARRAY_SIZE(hi6421_regulator_match));
605	of_node_put(np);
606	if (ret < 0) {
607	dev_err(dev, "Error parsing regulator init data: %d\n", ret);
608	return ret;
609	}
610
611	pmic = dev_get_drvdata(dev->parent);
612
613	for (i = 0; i < ARRAY_SIZE(hi6421_regulator_info); i++) {	548	for (i = 0; i < ARRAY_SIZE(hi6421_regulator_info); i++) {
614	ret = hi6421_regulator_register(pdev, pmic->regmap,	549	/* assign per-regulator data */
615	hi6421_regulator_match[i].init_data, i,	550	info = &hi6421_regulator_info[i];
616	hi6421_regulator_match[i].of_node);	551
617	if (ret)	552	config.dev = pdev->dev.parent;
618	return ret;	553	config.driver_data = info;
		554	config.regmap = pmic->regmap;
		555
		556	rdev = devm_regulator_register(&pdev->dev, &info->desc,
		557	&config);
		558	if (IS_ERR(rdev)) {
		559	dev_err(&pdev->dev, "failed to register regulator %s\n",
		560	info->desc.name);
		561	return PTR_ERR(rdev);
		562	}
619	}	563	}
620		564
621	return 0;	565	return 0;

drivers/regulator/hi6421v530-regulator.c+11−15

@@ -1,18 +1,14 @@
1	/*	1	// SPDX-License-Identifier: GPL-2.0
2	* Device driver for regulators in Hi6421V530 IC	2	//
3	*	3	// Device driver for regulators in Hi6421V530 IC
4	* Copyright (c) <2017> HiSilicon Technologies Co., Ltd.	4	//
5	* http://www.hisilicon.com	5	// Copyright (c) <2017> HiSilicon Technologies Co., Ltd.
6	* Copyright (c) <2017> Linaro Ltd.	6	// http://www.hisilicon.com
7	* http://www.linaro.org	7	// Copyright (c) <2017> Linaro Ltd.
8	*	8	// http://www.linaro.org
9	* Author: Wang Xiaoyin <hw.wangxiaoyin@hisilicon.com>	9	//
10	* Guodong Xu <guodong.xu@linaro.org>	10	// Author: Wang Xiaoyin <hw.wangxiaoyin@hisilicon.com>
11	*	11	// Guodong Xu <guodong.xu@linaro.org>
12	* This program is free software; you can redistribute it and/or modify
13	* it under the terms of the GNU General Public License version 2 as
14	* published by the Free Software Foundation.
15	*/
16		12
17	#include <linux/mfd/hi6421-pmic.h>	13	#include <linux/mfd/hi6421-pmic.h>
18	#include <linux/module.h>	14	#include <linux/module.h>

drivers/regulator/hi655x-regulator.c+13−24

-/*
+// SPDX-License-Identifier: GPL-2.0
- * Device driver for regulators in Hi655x IC
+//
- *
+// Device driver for regulators in Hi655x IC
- * Copyright (c) 2016 Hisilicon.
+//
- *
+// Copyright (c) 2016 Hisilicon.
- * Authors:
+//
- * Chen Feng <puck.chen@hisilicon.com>
+// Authors:
- * Fei  Wang <w.f@huawei.com>
+// Chen Feng <puck.chen@hisilicon.com>
- *
+// Fei  Wang <w.f@huawei.com>
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License version 2 as
- * published by the Free Software Foundation.
- */
 #include <linux/bitops.h>
 #include <linux/device.h>
 struct hi655x_regulator {
 	unsigned int disable_reg;
 	unsigned int status_reg;
-	unsigned int ctrl_mask;
 	struct regulator_desc rdesc;
 };
 static int hi655x_is_enabled(struct regulator_dev *rdev)
 {
 	unsigned int value = 0;
 	struct hi655x_regulator *regulator = rdev_get_drvdata(rdev);
 	regmap_read(rdev->regmap, regulator->status_reg, &value);
-	return (value & BIT(regulator->ctrl_mask));
+	return (value & rdev->desc->enable_mask);
 }
 static int hi655x_disable(struct regulator_dev *rdev)
 {
-	int ret = 0;
 	struct hi655x_regulator *regulator = rdev_get_drvdata(rdev);
-	ret = regmap_write(rdev->regmap, regulator->disable_reg,
+	return regmap_write(rdev->regmap, regulator->disable_reg,
-			   BIT(regulator->ctrl_mask));
+			    rdev->desc->enable_mask);
-	return ret;
 }
 static const struct regulator_ops hi655x_regulator_ops = {
 	},                                                       \
 	.disable_reg = HI655X_BUS_ADDR(dreg),                    \
 	.status_reg = HI655X_BUS_ADDR(sreg),                     \
-	.ctrl_mask = cmask,                                      \
 }
 #define HI655X_LDO_LINEAR(_ID, vreg, vmask, ereg, dreg,          \
 	},                                                       \
 	.disable_reg = HI655X_BUS_ADDR(dreg),                    \
 	.status_reg = HI655X_BUS_ADDR(sreg),                     \
-	.ctrl_mask = cmask,                                      \
 }
-static struct hi655x_regulator regulators[] = {
+static const struct hi655x_regulator regulators[] = {
 	HI655X_LDO_LINEAR(LDO2, 0x72, 0x07, 0x29, 0x2a, 0x2b, 0x01,
 			  2500000, 8, 100000),
 	HI655X_LDO(LDO7, 0x78, 0x07, 0x29, 0x2a, 0x2b, 0x06, ldo7_voltages),

drivers/regulator/lm363x-regulator.c+4−4

@@ -48,7 +48,7 @@ static const int ldo_cont_enable_time[] = { · 47 unmodified lines
48	static int lm363x_regulator_enable_time(struct regulator_dev *rdev)	48	static int lm363x_regulator_enable_time(struct regulator_dev *rdev)
49	{	49	{
50	enum lm363x_regulator_id id = rdev_get_id(rdev);	50	enum lm363x_regulator_id id = rdev_get_id(rdev);
51	u8 val, addr, mask;	51	unsigned int val, addr, mask;
52		52
53	switch (id) {	53	switch (id) {
54	case LM3631_LDO_CONT:	54	case LM3631_LDO_CONT:
@@ -71,7 +71,7 @@ static int lm363x_regulator_enable_time(struct regulator_dev *rdev) · 16 unmodified lines
71	return 0;	71	return 0;
72	}	72	}
73		73
74	if (regmap_read(rdev->regmap, addr, (unsigned int *)&val))	74	if (regmap_read(rdev->regmap, addr, &val))
75	return -EINVAL;	75	return -EINVAL;
76		76
77	val = (val & mask) >> LM3631_ENTIME_SHIFT;	77	val = (val & mask) >> LM3631_ENTIME_SHIFT;
@@ -82,13 +82,13 @@ static int lm363x_regulator_enable_time(struct regulator_dev *rdev) · 4 unmodified lines
82	return ENABLE_TIME_USEC * val;	82	return ENABLE_TIME_USEC * val;
83	}	83	}
84		84
85	static struct regulator_ops lm363x_boost_voltage_table_ops = {	85	static const struct regulator_ops lm363x_boost_voltage_table_ops = {
86	.list_voltage = regulator_list_voltage_linear,	86	.list_voltage = regulator_list_voltage_linear,
87	.set_voltage_sel = regulator_set_voltage_sel_regmap,	87	.set_voltage_sel = regulator_set_voltage_sel_regmap,
88	.get_voltage_sel = regulator_get_voltage_sel_regmap,	88	.get_voltage_sel = regulator_get_voltage_sel_regmap,
89	};	89	};
90		90
91	static struct regulator_ops lm363x_regulator_voltage_table_ops = {	91	static const struct regulator_ops lm363x_regulator_voltage_table_ops = {
92	.list_voltage = regulator_list_voltage_linear,	92	.list_voltage = regulator_list_voltage_linear,
93	.set_voltage_sel = regulator_set_voltage_sel_regmap,	93	.set_voltage_sel = regulator_set_voltage_sel_regmap,
94	.get_voltage_sel = regulator_get_voltage_sel_regmap,	94	.get_voltage_sel = regulator_get_voltage_sel_regmap,

drivers/regulator/lp8755.c+12−3

 	for (icnt = 0; icnt < LP8755_BUCK_MAX; icnt++)
 		if ((flag0 & (0x4 << icnt))
 		    && (pchip->irqmask & (0x04 << icnt))
-		    && (pchip->rdev[icnt] != NULL))
+		    && (pchip->rdev[icnt] != NULL)) {
+			regulator_lock(pchip->rdev[icnt]);
 			regulator_notifier_call_chain(pchip->rdev[icnt],
 						      LP8755_EVENT_PWR_FAULT,
 						      NULL);
+			regulator_unlock(pchip->rdev[icnt]);
+		}
 	/* read flag1 register */
 	ret = lp8755_read(pchip, 0x0E, &flag1);
 	/* send OCP event to all regulator devices */
 	if ((flag1 & 0x01) && (pchip->irqmask & 0x01))
 		for (icnt = 0; icnt < LP8755_BUCK_MAX; icnt++)
-			if (pchip->rdev[icnt] != NULL)
+			if (pchip->rdev[icnt] != NULL) {
+				regulator_lock(pchip->rdev[icnt]);
 				regulator_notifier_call_chain(pchip->rdev[icnt],
 							      LP8755_EVENT_OCP,
 							      NULL);
+				regulator_unlock(pchip->rdev[icnt]);
+			}
 	/* send OVP event to all regulator devices */
 	if ((flag1 & 0x02) && (pchip->irqmask & 0x02))
 		for (icnt = 0; icnt < LP8755_BUCK_MAX; icnt++)
-			if (pchip->rdev[icnt] != NULL)
+			if (pchip->rdev[icnt] != NULL) {
+				regulator_lock(pchip->rdev[icnt]);
 				regulator_notifier_call_chain(pchip->rdev[icnt],
 							      LP8755_EVENT_OVP,
 							      NULL);
+				regulator_unlock(pchip->rdev[icnt]);
+			}
 	return IRQ_HANDLED;
 err_i2c:

drivers/regulator/lp87565-regulator.c+8−41

@@ -34,6 +34,10 @@ · 33 unmodified lines
34	.ramp_delay = _delay, \	34	.ramp_delay = _delay, \
35	.linear_ranges = _lr, \	35	.linear_ranges = _lr, \
36	.n_linear_ranges = ARRAY_SIZE(_lr), \	36	.n_linear_ranges = ARRAY_SIZE(_lr), \
		37	.curr_table = lp87565_buck_uA, \
		38	.n_current_limits = ARRAY_SIZE(lp87565_buck_uA),\
		39	.csel_reg = (_cr), \
		40	.csel_mask = LP87565_BUCK_CTRL_2_ILIM, \
37	}, \	41	}, \
38	.ctrl2_reg = _cr, \	42	.ctrl2_reg = _cr, \
39	}	43	}
@@ -102,44 +106,7 @@ static int lp87565_buck_set_ramp_delay(struct regulator_dev *rdev, · 62 unmodified lines
102	return 0;	106	return 0;
103	}	107	}
104		108
105	static int lp87565_buck_set_current_limit(struct regulator_dev *rdev,	109	/* Operations permitted on BUCKs */
106	int min_uA, int max_uA)
107	{
108	int id = rdev_get_id(rdev);
109	struct lp87565 *lp87565 = rdev_get_drvdata(rdev);
110	int i;
111
112	for (i = ARRAY_SIZE(lp87565_buck_uA) - 1; i >= 0; i--) {
113	if (lp87565_buck_uA[i] >= min_uA &&
114	lp87565_buck_uA[i] <= max_uA)
115	return regmap_update_bits(lp87565->regmap,
116	regulators[id].ctrl2_reg,
117	LP87565_BUCK_CTRL_2_ILIM,
118	i << __ffs(LP87565_BUCK_CTRL_2_ILIM));
119	}
120
121	return -EINVAL;
122	}
123
124	static int lp87565_buck_get_current_limit(struct regulator_dev *rdev)
125	{
126	int id = rdev_get_id(rdev);
127	struct lp87565 *lp87565 = rdev_get_drvdata(rdev);
128	int ret;
129	unsigned int val;
130
131	ret = regmap_read(lp87565->regmap, regulators[id].ctrl2_reg, &val);
132	if (ret)
133	return ret;
134
135	val = (val & LP87565_BUCK_CTRL_2_ILIM) >>
136	__ffs(LP87565_BUCK_CTRL_2_ILIM);
137
138	return (val < ARRAY_SIZE(lp87565_buck_uA)) ?
139	lp87565_buck_uA[val] : -EINVAL;
140	}
141
142	/* Operations permitted on BUCK0, BUCK1 */
143	static const struct regulator_ops lp87565_buck_ops = {	110	static const struct regulator_ops lp87565_buck_ops = {
144	.is_enabled = regulator_is_enabled_regmap,	111	.is_enabled = regulator_is_enabled_regmap,
145	.enable = regulator_enable_regmap,	112	.enable = regulator_enable_regmap,
@@ -150,8 +117,8 @@ static const struct regulator_ops lp87565_buck_ops = { · 4 unmodified lines
150	.map_voltage = regulator_map_voltage_linear_range,	117	.map_voltage = regulator_map_voltage_linear_range,
151	.set_voltage_time_sel = regulator_set_voltage_time_sel,	118	.set_voltage_time_sel = regulator_set_voltage_time_sel,
152	.set_ramp_delay = lp87565_buck_set_ramp_delay,	119	.set_ramp_delay = lp87565_buck_set_ramp_delay,
153	.set_current_limit = lp87565_buck_set_current_limit,	120	.set_current_limit = regulator_set_current_limit_regmap,
154	.get_current_limit = lp87565_buck_get_current_limit,	121	.get_current_limit = regulator_get_current_limit_regmap,
155	};	122	};
156		123
157	static const struct lp87565_regulator regulators[] = {	124	static const struct lp87565_regulator regulators[] = {
@@ -193,7 +160,7 @@ static int lp87565_regulator_probe(struct platform_device *pdev) · 35 unmodified lines
193	struct lp87565 *lp87565 = dev_get_drvdata(pdev->dev.parent);	160	struct lp87565 *lp87565 = dev_get_drvdata(pdev->dev.parent);
194	struct regulator_config config = { };	161	struct regulator_config config = { };
195	struct regulator_dev *rdev;	162	struct regulator_dev *rdev;
196	int i, min_idx = LP87565_BUCK_1, max_idx = LP87565_BUCK_3;	163	int i, min_idx = LP87565_BUCK_0, max_idx = LP87565_BUCK_3;
197		164
198	platform_set_drvdata(pdev, lp87565);	165	platform_set_drvdata(pdev, lp87565);
199		166

drivers/regulator/ltc3589.c+89−180

@@ -1,21 +1,9 @@
1	/*	1	// SPDX-License-Identifier: GPL-2.0
2	* Linear Technology LTC3589,LTC3589-1 regulator support	2	//
3	*	3	// Linear Technology LTC3589,LTC3589-1 regulator support
4	* Copyright (c) 2014 Philipp Zabel <p.zabel@pengutronix.de>, Pengutronix	4	//
5	*	5	// Copyright (c) 2014 Philipp Zabel <p.zabel@pengutronix.de>, Pengutronix
6	* See file CREDITS for list of people who contributed to this	6
7	* project.
8	*
9	* This program is free software; you can redistribute it and/or modify
10	* it under the terms of the GNU General Public License version 2
11	* as published by the Free Software Foundation.
12	*
13	* This program is distributed in the hope that it will be useful,
14	* but WITHOUT ANY WARRANTY; without even the implied warranty of
15	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16	* GNU General Public License for more details.
17	*
18	*/
19	#include <linux/i2c.h>	7	#include <linux/i2c.h>
20	#include <linux/init.h>	8	#include <linux/init.h>
21	#include <linux/interrupt.h>	9	#include <linux/interrupt.h>
@@ -84,19 +72,11 @@ enum ltc3589_reg { · 62 unmodified lines
84	LTC3589_NUM_REGULATORS,	72	LTC3589_NUM_REGULATORS,
85	};	73	};
86		74
87	struct ltc3589_regulator {
88	struct regulator_desc desc;
89
90	/* External feedback voltage divider */
91	unsigned int r1;
92	unsigned int r2;
93	};
94
95	struct ltc3589 {	75	struct ltc3589 {
96	struct regmap *regmap;	76	struct regmap *regmap;
97	struct device *dev;	77	struct device *dev;
98	enum ltc3589_variant variant;	78	enum ltc3589_variant variant;
99	struct ltc3589_regulator regulator_descs[LTC3589_NUM_REGULATORS];	79	struct regulator_desc regulator_descs[LTC3589_NUM_REGULATORS];
100	struct regulator_dev *regulators[LTC3589_NUM_REGULATORS];	80	struct regulator_dev *regulators[LTC3589_NUM_REGULATORS];
101	};	81	};
102		82
@@ -196,131 +176,90 @@ static const struct regulator_ops ltc3589_table_regulator_ops = { · 93 unmodified lines
196	.get_voltage_sel = regulator_get_voltage_sel_regmap,	176	.get_voltage_sel = regulator_get_voltage_sel_regmap,
197	};	177	};
198		178
		179	static inline unsigned int ltc3589_scale(unsigned int uV, u32 r1, u32 r2)
		180	{
		181	uint64_t tmp;
199		182
200	#define LTC3589_REG(_name, _ops, en_bit, dtv1_reg, dtv_mask, go_bit) \	183	if (uV == 0)
201	[LTC3589_ ## _name] = { \	184	return 0;
202	.desc = { \
203	.name = #_name, \
204	.n_voltages = (dtv_mask) + 1, \
205	.min_uV = (go_bit) ? 362500 : 0, \
206	.uV_step = (go_bit) ? 12500 : 0, \
207	.ramp_delay = (go_bit) ? 1750 : 0, \
208	.fixed_uV = (dtv_mask) ? 0 : 800000, \
209	.ops = &ltc3589_ ## _ops ## _regulator_ops, \
210	.type = REGULATOR_VOLTAGE, \
211	.id = LTC3589_ ## _name, \
212	.owner = THIS_MODULE, \
213	.vsel_reg = (dtv1_reg), \
214	.vsel_mask = (dtv_mask), \
215	.apply_reg = (go_bit) ? LTC3589_VCCR : 0, \
216	.apply_bit = (go_bit), \
217	.enable_reg = (en_bit) ? LTC3589_OVEN : 0, \
218	.enable_mask = (en_bit), \
219	}, \
220	}
221
222	#define LTC3589_LINEAR_REG(_name, _dtv1) \
223	LTC3589_REG(_name, linear, LTC3589_OVEN_ ## _name, \
224	LTC3589_ ## _dtv1, 0x1f, \
225	LTC3589_VCCR_ ## _name ## _GO)
226
227	#define LTC3589_FIXED_REG(_name) \
228	LTC3589_REG(_name, fixed, LTC3589_OVEN_ ## _name, 0, 0, 0)
229
230	static struct ltc3589_regulator ltc3589_regulators[LTC3589_NUM_REGULATORS] = {
231	LTC3589_LINEAR_REG(SW1, B1DTV1),
232	LTC3589_LINEAR_REG(SW2, B2DTV1),
233	LTC3589_LINEAR_REG(SW3, B3DTV1),
234	LTC3589_FIXED_REG(BB_OUT),
235	LTC3589_REG(LDO1, fixed_standby, 0, 0, 0, 0),
236	LTC3589_LINEAR_REG(LDO2, L2DTV1),
237	LTC3589_FIXED_REG(LDO3),
238	LTC3589_REG(LDO4, table, LTC3589_OVEN_LDO4, LTC3589_L2DTV2, 0x60, 0),
239	};
240		185
241	#ifdef CONFIG_OF	186	tmp = (uint64_t)uV * r1;
242	static struct of_regulator_match ltc3589_matches[LTC3589_NUM_REGULATORS] = {	187	do_div(tmp, r2);
243	{ .name = "sw1", },	188	return uV + (unsigned int)tmp;
244	{ .name = "sw2", },	189	}
245	{ .name = "sw3", },
246	{ .name = "bb-out", },
247	{ .name = "ldo1", }, /* standby */
248	{ .name = "ldo2", },
249	{ .name = "ldo3", },
250	{ .name = "ldo4", },
251	};
252		190
253	static int ltc3589_parse_regulators_dt(struct ltc3589 *ltc3589)	191	static int ltc3589_of_parse_cb(struct device_node *np,
		192	const struct regulator_desc *desc,
		193	struct regulator_config *config)
254	{	194	{
255	struct device *dev = ltc3589->dev;	195	struct ltc3589 *ltc3589 = config->driver_data;
256	struct device_node *node;	196	struct regulator_desc *rdesc = &ltc3589->regulator_descs[desc->id];
257	int i, ret;	197	u32 r[2];
		198	int ret;
258		199
259	node = of_get_child_by_name(dev->of_node, "regulators");	200	/* Parse feedback voltage dividers. LDO3 and LDO4 don't have them */
260	if (!node) {	201	if (desc->id >= LTC3589_LDO3)
261	dev_err(dev, "regulators node not found\n");	202	return 0;
262	return -EINVAL;
263	}
264		203
265	ret = of_regulator_match(dev, node, ltc3589_matches,	204	ret = of_property_read_u32_array(np, "lltc,fb-voltage-divider", r, 2);
266	ARRAY_SIZE(ltc3589_matches));	205	if (ret) {
267	of_node_put(node);	206	dev_err(ltc3589->dev, "Failed to parse voltage divider: %d\n",
268	if (ret < 0) {
269	dev_err(dev, "Error parsing regulator init data: %d\n", ret);
270	return ret;
271	}
272	if (ret != LTC3589_NUM_REGULATORS) {
273	dev_err(dev, "Only %d regulators described in device tree\n",
274	ret);	207	ret);
275	return -EINVAL;	208	return ret;
276	}	209	}
277		210
278	/* Parse feedback voltage dividers. LDO3 and LDO4 don't have them */	211	if (!r[0] \|\| !r[1])
279	for (i = 0; i < LTC3589_LDO3; i++) {	212	return 0;
280	struct ltc3589_regulator *desc = &ltc3589->regulator_descs[i];
281	struct device_node *np = ltc3589_matches[i].of_node;
282	u32 vdiv[2];
283
284	ret = of_property_read_u32_array(np, "lltc,fb-voltage-divider",
285	vdiv, 2);
286	if (ret) {
287	dev_err(dev, "Failed to parse voltage divider: %d\n",
288	ret);
289	return ret;
290	}
291		213
292	desc->r1 = vdiv[0];	214	rdesc->min_uV = ltc3589_scale(desc->min_uV, r[0], r[1]);
293	desc->r2 = vdiv[1];	215	rdesc->uV_step = ltc3589_scale(desc->uV_step, r[0], r[1]);
294	}	216	rdesc->fixed_uV = ltc3589_scale(desc->fixed_uV, r[0], r[1]);
295		217
296	return 0;	218	return 0;
297	}	219	}
298		220
299	static inline struct regulator_init_data *match_init_data(int index)	221	#define LTC3589_REG(_name, _of_name, _ops, en_bit, dtv1_reg, dtv_mask, go_bit)\
300	{	222	[LTC3589_ ## _name] = { \
301	return ltc3589_matches[index].init_data;	223	.name = #_name, \
302	}	224	.of_match = of_match_ptr(#_of_name), \
303		225	.regulators_node = of_match_ptr("regulators"), \
304	static inline struct device_node *match_of_node(int index)	226	.of_parse_cb = ltc3589_of_parse_cb, \
305	{	227	.n_voltages = (dtv_mask) + 1, \
306	return ltc3589_matches[index].of_node;	228	.min_uV = (go_bit) ? 362500 : 0, \
307	}	229	.uV_step = (go_bit) ? 12500 : 0, \
308	#else	230	.ramp_delay = (go_bit) ? 1750 : 0, \
309	static inline int ltc3589_parse_regulators_dt(struct ltc3589 *ltc3589)	231	.fixed_uV = (dtv_mask) ? 0 : 800000, \
310	{	232	.ops = &ltc3589_ ## _ops ## _regulator_ops, \
311	return 0;	233	.type = REGULATOR_VOLTAGE, \
312	}	234	.id = LTC3589_ ## _name, \
		235	.owner = THIS_MODULE, \
		236	.vsel_reg = (dtv1_reg), \
		237	.vsel_mask = (dtv_mask), \
		238	.apply_reg = (go_bit) ? LTC3589_VCCR : 0, \
		239	.apply_bit = (go_bit), \
		240	.enable_reg = (en_bit) ? LTC3589_OVEN : 0, \
		241	.enable_mask = (en_bit), \
		242	}
313		243
314	static inline struct regulator_init_data *match_init_data(int index)	244	#define LTC3589_LINEAR_REG(_name, _of_name, _dtv1) \
315	{	245	LTC3589_REG(_name, _of_name, linear, LTC3589_OVEN_ ## _name, \
316	return NULL;	246	LTC3589_ ## _dtv1, 0x1f, \
317	}	247	LTC3589_VCCR_ ## _name ## _GO)
318		248
319	static inline struct device_node *match_of_node(int index)	249	#define LTC3589_FIXED_REG(_name, _of_name) \
320	{	250	LTC3589_REG(_name, _of_name, fixed, LTC3589_OVEN_ ## _name, 0, 0, 0)
321	return NULL;	251
322	}	252	static const struct regulator_desc ltc3589_regulators[] = {
323	#endif	253	LTC3589_LINEAR_REG(SW1, sw1, B1DTV1),
		254	LTC3589_LINEAR_REG(SW2, sw2, B2DTV1),
		255	LTC3589_LINEAR_REG(SW3, sw3, B3DTV1),
		256	LTC3589_FIXED_REG(BB_OUT, bb-out),
		257	LTC3589_REG(LDO1, ldo1, fixed_standby, 0, 0, 0, 0),
		258	LTC3589_LINEAR_REG(LDO2, ldo2, L2DTV1),
		259	LTC3589_FIXED_REG(LDO3, ldo3),
		260	LTC3589_REG(LDO4, ldo4, table, LTC3589_OVEN_LDO4, LTC3589_L2DTV2,
		261	0x60, 0),
		262	};
324		263
325	static bool ltc3589_writeable_reg(struct device *dev, unsigned int reg)	264	static bool ltc3589_writeable_reg(struct device *dev, unsigned int reg)
326	{	265	{
@@ -409,7 +348,6 @@ static const struct regmap_config ltc3589_regmap_config = { · 82 unmodified lines
409	.cache_type = REGCACHE_RBTREE,	348	.cache_type = REGCACHE_RBTREE,
410	};	349	};
411		350
412
413	static irqreturn_t ltc3589_isr(int irq, void *dev_id)	351	static irqreturn_t ltc3589_isr(int irq, void *dev_id)
414	{	352	{
415	struct ltc3589 *ltc3589 = dev_id;	353	struct ltc3589 *ltc3589 = dev_id;
@@ -419,16 +357,22 @@ static irqreturn_t ltc3589_isr(int irq, void *dev_id) · 3 unmodified lines
419		357
420	if (irqstat & LTC3589_IRQSTAT_THERMAL_WARN) {	358	if (irqstat & LTC3589_IRQSTAT_THERMAL_WARN) {
421	event = REGULATOR_EVENT_OVER_TEMP;	359	event = REGULATOR_EVENT_OVER_TEMP;
422	for (i = 0; i < LTC3589_NUM_REGULATORS; i++)	360	for (i = 0; i < LTC3589_NUM_REGULATORS; i++) {
		361	regulator_lock(ltc3589->regulators[i]);
423	regulator_notifier_call_chain(ltc3589->regulators[i],	362	regulator_notifier_call_chain(ltc3589->regulators[i],
424	event, NULL);	363	event, NULL);
		364	regulator_unlock(ltc3589->regulators[i]);
		365	}
425	}	366	}
426		367
427	if (irqstat & LTC3589_IRQSTAT_UNDERVOLT_WARN) {	368	if (irqstat & LTC3589_IRQSTAT_UNDERVOLT_WARN) {
428	event = REGULATOR_EVENT_UNDER_VOLTAGE;	369	event = REGULATOR_EVENT_UNDER_VOLTAGE;
429	for (i = 0; i < LTC3589_NUM_REGULATORS; i++)	370	for (i = 0; i < LTC3589_NUM_REGULATORS; i++) {
		371	regulator_lock(ltc3589->regulators[i]);
430	regulator_notifier_call_chain(ltc3589->regulators[i],	372	regulator_notifier_call_chain(ltc3589->regulators[i],
431	event, NULL);	373	event, NULL);
		374	regulator_unlock(ltc3589->regulators[i]);
		375	}
432	}	376	}
433		377
434	/* Clear warning condition */	378	/* Clear warning condition */
@@ -437,33 +381,11 @@ static irqreturn_t ltc3589_isr(int irq, void *dev_id) · 2 unmodified lines
437	return IRQ_HANDLED;	381	return IRQ_HANDLED;
438	}	382	}
439		383
440	static inline unsigned int ltc3589_scale(unsigned int uV, u32 r1, u32 r2)
441	{
442	uint64_t tmp;
443	if (uV == 0)
444	return 0;
445	tmp = (uint64_t)uV * r1;
446	do_div(tmp, r2);
447	return uV + (unsigned int)tmp;
448	}
449
450	static void ltc3589_apply_fb_voltage_divider(struct ltc3589_regulator *rdesc)
451	{
452	struct regulator_desc *desc = &rdesc->desc;
453
454	if (!rdesc->r1 \|\| !rdesc->r2)
455	return;
456
457	desc->min_uV = ltc3589_scale(desc->min_uV, rdesc->r1, rdesc->r2);
458	desc->uV_step = ltc3589_scale(desc->uV_step, rdesc->r1, rdesc->r2);
459	desc->fixed_uV = ltc3589_scale(desc->fixed_uV, rdesc->r1, rdesc->r2);
460	}
461
462	static int ltc3589_probe(struct i2c_client *client,	384	static int ltc3589_probe(struct i2c_client *client,
463	const struct i2c_device_id *id)	385	const struct i2c_device_id *id)
464	{	386	{
465	struct device *dev = &client->dev;	387	struct device *dev = &client->dev;
466	struct ltc3589_regulator *descs;	388	struct regulator_desc *descs;
467	struct ltc3589 *ltc3589;	389	struct ltc3589 *ltc3589;
468	int i, ret;	390	int i, ret;
469		391
@@ -482,11 +404,11 @@ static int ltc3589_probe(struct i2c_client *client, · 12 unmodified lines
482	descs = ltc3589->regulator_descs;	404	descs = ltc3589->regulator_descs;
483	memcpy(descs, ltc3589_regulators, sizeof(ltc3589_regulators));	405	memcpy(descs, ltc3589_regulators, sizeof(ltc3589_regulators));
484	if (ltc3589->variant == LTC3589) {	406	if (ltc3589->variant == LTC3589) {
485	descs[LTC3589_LDO3].desc.fixed_uV = 1800000;	407	descs[LTC3589_LDO3].fixed_uV = 1800000;
486	descs[LTC3589_LDO4].desc.volt_table = ltc3589_ldo4;	408	descs[LTC3589_LDO4].volt_table = ltc3589_ldo4;
487	} else {	409	} else {
488	descs[LTC3589_LDO3].desc.fixed_uV = 2800000;	410	descs[LTC3589_LDO3].fixed_uV = 2800000;
489	descs[LTC3589_LDO4].desc.volt_table = ltc3589_12_ldo4;	411	descs[LTC3589_LDO4].volt_table = ltc3589_12_ldo4;
490	}	412	}
491		413
492	ltc3589->regmap = devm_regmap_init_i2c(client, &ltc3589_regmap_config);	414	ltc3589->regmap = devm_regmap_init_i2c(client, &ltc3589_regmap_config);
@@ -496,25 +418,12 @@ static int ltc3589_probe(struct i2c_client *client, · 3 unmodified lines
496	return ret;	418	return ret;
497	}	419	}
498		420
499	ret = ltc3589_parse_regulators_dt(ltc3589);
500	if (ret)
501	return ret;
502
503	for (i = 0; i < LTC3589_NUM_REGULATORS; i++) {	421	for (i = 0; i < LTC3589_NUM_REGULATORS; i++) {
504	struct ltc3589_regulator *rdesc = &ltc3589->regulator_descs[i];	422	struct regulator_desc *desc = &ltc3589->regulator_descs[i];
505	struct regulator_desc *desc = &rdesc->desc;
506	struct regulator_init_data *init_data;
507	struct regulator_config config = { };	423	struct regulator_config config = { };
508		424
509	init_data = match_init_data(i);
510
511	if (i < LTC3589_LDO3)
512	ltc3589_apply_fb_voltage_divider(rdesc);
513
514	config.dev = dev;	425	config.dev = dev;
515	config.init_data = init_data;
516	config.driver_data = ltc3589;	426	config.driver_data = ltc3589;
517	config.of_node = match_of_node(i);
518		427
519	ltc3589->regulators[i] = devm_regulator_register(dev, desc,	428	ltc3589->regulators[i] = devm_regulator_register(dev, desc,
520	&config);	429	&config);

drivers/regulator/ltc3676.c+8−2

 	if (irqstat & LTC3676_IRQSTAT_THERMAL_WARN) {
 		dev_warn(dev, "Over-temperature Warning\n");
 		event = REGULATOR_EVENT_OVER_TEMP;
-		for (i = 0; i < LTC3676_NUM_REGULATORS; i++)
+		for (i = 0; i < LTC3676_NUM_REGULATORS; i++) {
+			regulator_lock(ltc3676->regulators[i]);
 			regulator_notifier_call_chain(ltc3676->regulators[i],
 						      event, NULL);
+			regulator_unlock(ltc3676->regulators[i]);
+		}
 	}
 	if (irqstat & LTC3676_IRQSTAT_UNDERVOLT_WARN) {
 		dev_info(dev, "Undervoltage Warning\n");
 		event = REGULATOR_EVENT_UNDER_VOLTAGE;
-		for (i = 0; i < LTC3676_NUM_REGULATORS; i++)
+		for (i = 0; i < LTC3676_NUM_REGULATORS; i++) {
+			regulator_lock(ltc3676->regulators[i]);
 			regulator_notifier_call_chain(ltc3676->regulators[i],
 						      event, NULL);
+			regulator_unlock(ltc3676->regulators[i]);
+		}
 	}
 	/* Clear warning condition */

drivers/regulator/max14577-regulator.c+0−55

@@ -155,58 +155,6 @@ static const struct regulator_desc max77836_supported_regulators[] = { · 154 unmodified lines
155	[MAX77836_LDO2] = MAX77836_LDO_REG(2),	155	[MAX77836_LDO2] = MAX77836_LDO_REG(2),
156	};	156	};
157		157
158	#ifdef CONFIG_OF
159	static struct of_regulator_match max14577_regulator_matches[] = {
160	{ .name = "SAFEOUT", },
161	{ .name = "CHARGER", },
162	};
163
164	static struct of_regulator_match max77836_regulator_matches[] = {
165	{ .name = "SAFEOUT", },
166	{ .name = "CHARGER", },
167	{ .name = "LDO1", },
168	{ .name = "LDO2", },
169	};
170
171	static inline struct regulator_init_data *match_init_data(int index,
172	enum maxim_device_type dev_type)
173	{
174	switch (dev_type) {
175	case MAXIM_DEVICE_TYPE_MAX77836:
176	return max77836_regulator_matches[index].init_data;
177
178	case MAXIM_DEVICE_TYPE_MAX14577:
179	default:
180	return max14577_regulator_matches[index].init_data;
181	}
182	}
183
184	static inline struct device_node *match_of_node(int index,
185	enum maxim_device_type dev_type)
186	{
187	switch (dev_type) {
188	case MAXIM_DEVICE_TYPE_MAX77836:
189	return max77836_regulator_matches[index].of_node;
190
191	case MAXIM_DEVICE_TYPE_MAX14577:
192	default:
193	return max14577_regulator_matches[index].of_node;
194	}
195	}
196	#else /* CONFIG_OF */
197	static inline struct regulator_init_data *match_init_data(int index,
198	enum maxim_device_type dev_type)
199	{
200	return NULL;
201	}
202
203	static inline struct device_node *match_of_node(int index,
204	enum maxim_device_type dev_type)
205	{
206	return NULL;
207	}
208	#endif /* CONFIG_OF */
209
210	/**	158	/**
211	* Registers for regulators of max77836 use different I2C slave addresses so	159	* Registers for regulators of max77836 use different I2C slave addresses so
212	* different regmaps must be used for them.	160	* different regmaps must be used for them.
@@ -265,9 +213,6 @@ static int max14577_regulator_probe(struct platform_device *pdev) · 52 unmodified lines
265	if (pdata && pdata->regulators) {	213	if (pdata && pdata->regulators) {
266	config.init_data = pdata->regulators[i].initdata;	214	config.init_data = pdata->regulators[i].initdata;
267	config.of_node = pdata->regulators[i].of_node;	215	config.of_node = pdata->regulators[i].of_node;
268	} else {
269	config.init_data = match_init_data(i, dev_type);
270	config.of_node = match_of_node(i, dev_type);
271	}	216	}
272	config.regmap = max14577_get_regmap(max14577,	217	config.regmap = max14577_get_regmap(max14577,
273	supported_regulators[i].id);	218	supported_regulators[i].id);

drivers/regulator/max77650-regulator.c+1−1

@@ -41,7 +41,7 @@ struct max77650_regulator_desc { · 40 unmodified lines
41	unsigned int regB;	41	unsigned int regB;
42	};	42	};
43		43
44	static const u32 max77651_sbb1_regulator_volt_table[] = {	44	static const unsigned int max77651_sbb1_regulator_volt_table[] = {
45	2400000, 3200000, 4000000, 4800000,	45	2400000, 3200000, 4000000, 4800000,
46	2450000, 3250000, 4050000, 4850000,	46	2450000, 3250000, 4050000, 4850000,
47	2500000, 3300000, 4100000, 4900000,	47	2500000, 3300000, 4100000, 4900000,

drivers/regulator/max8925-regulator.c+9−67

@@ -159,6 +159,8 @@ static const struct regulator_ops max8925_regulator_ldo_ops = { · 158 unmodified lines
159	{ \	159	{ \
160	.desc = { \	160	.desc = { \
161	.name = "SDV" #_id, \	161	.name = "SDV" #_id, \
		162	.of_match = of_match_ptr("SDV" #_id), \
		163	.regulators_node = of_match_ptr("regulators"), \
162	.ops = &max8925_regulator_sdv_ops, \	164	.ops = &max8925_regulator_sdv_ops, \
163	.type = REGULATOR_VOLTAGE, \	165	.type = REGULATOR_VOLTAGE, \
164	.id = MAX8925_ID_SD##_id, \	166	.id = MAX8925_ID_SD##_id, \
@@ -175,6 +177,8 @@ static const struct regulator_ops max8925_regulator_ldo_ops = { · 10 unmodified lines
175	{ \	177	{ \
176	.desc = { \	178	.desc = { \
177	.name = "LDO" #_id, \	179	.name = "LDO" #_id, \
		180	.of_match = of_match_ptr("LDO" #_id), \
		181	.regulators_node = of_match_ptr("regulators"), \
178	.ops = &max8925_regulator_ldo_ops, \	182	.ops = &max8925_regulator_ldo_ops, \
179	.type = REGULATOR_VOLTAGE, \	183	.type = REGULATOR_VOLTAGE, \
180	.id = MAX8925_ID_LDO##_id, \	184	.id = MAX8925_ID_LDO##_id, \
@@ -187,34 +191,6 @@ static const struct regulator_ops max8925_regulator_ldo_ops = { · 6 unmodified lines
187	.enable_reg = MAX8925_LDOCTL##_id, \	191	.enable_reg = MAX8925_LDOCTL##_id, \
188	}	192	}
189		193
190	#ifdef CONFIG_OF
191	static struct of_regulator_match max8925_regulator_matches[] = {
192	{ .name = "SDV1",},
193	{ .name = "SDV2",},
194	{ .name = "SDV3",},
195	{ .name = "LDO1",},
196	{ .name = "LDO2",},
197	{ .name = "LDO3",},
198	{ .name = "LDO4",},
199	{ .name = "LDO5",},
200	{ .name = "LDO6",},
201	{ .name = "LDO7",},
202	{ .name = "LDO8",},
203	{ .name = "LDO9",},
204	{ .name = "LDO10",},
205	{ .name = "LDO11",},
206	{ .name = "LDO12",},
207	{ .name = "LDO13",},
208	{ .name = "LDO14",},
209	{ .name = "LDO15",},
210	{ .name = "LDO16",},
211	{ .name = "LDO17",},
212	{ .name = "LDO18",},
213	{ .name = "LDO19",},
214	{ .name = "LDO20",},
215	};
216	#endif
217
218	static struct max8925_regulator_info max8925_regulator_info[] = {	194	static struct max8925_regulator_info max8925_regulator_info[] = {
219	MAX8925_SDV(1, 637.5, 1425, 12.5),	195	MAX8925_SDV(1, 637.5, 1425, 12.5),
220	MAX8925_SDV(2, 650, 2225, 25),	196	MAX8925_SDV(2, 650, 2225, 25),
@@ -242,37 +218,6 @@ static struct max8925_regulator_info max8925_regulator_info[] = { · 21 unmodified lines
242	MAX8925_LDO(20, 750, 3900, 50),	218	MAX8925_LDO(20, 750, 3900, 50),
243	};	219	};
244		220
245	#ifdef CONFIG_OF
246	static int max8925_regulator_dt_init(struct platform_device *pdev,
247	struct regulator_config *config,
248	int ridx)
249	{
250	struct device_node nproot, np;
251	int rcount;
252
253	nproot = pdev->dev.parent->of_node;
254	if (!nproot)
255	return -ENODEV;
256	np = of_get_child_by_name(nproot, "regulators");
257	if (!np) {
258	dev_err(&pdev->dev, "failed to find regulators node\n");
259	return -ENODEV;
260	}
261
262	rcount = of_regulator_match(&pdev->dev, np,
263	&max8925_regulator_matches[ridx], 1);
264	of_node_put(np);
265	if (rcount < 0)
266	return rcount;
267	config->init_data = max8925_regulator_matches[ridx].init_data;
268	config->of_node = max8925_regulator_matches[ridx].of_node;
269
270	return 0;
271	}
272	#else
273	#define max8925_regulator_dt_init(x, y, z) (-1)
274	#endif
275
276	static int max8925_regulator_probe(struct platform_device *pdev)	221	static int max8925_regulator_probe(struct platform_device *pdev)
277	{	222	{
278	struct max8925_chip *chip = dev_get_drvdata(pdev->dev.parent);	223	struct max8925_chip *chip = dev_get_drvdata(pdev->dev.parent);
@@ -281,7 +226,7 @@ static int max8925_regulator_probe(struct platform_device *pdev) · 2 unmodified lines
281	struct max8925_regulator_info *ri;	226	struct max8925_regulator_info *ri;
282	struct resource *res;	227	struct resource *res;
283	struct regulator_dev *rdev;	228	struct regulator_dev *rdev;
284	int i, regulator_idx;	229	int i;
285		230
286	res = platform_get_resource(pdev, IORESOURCE_REG, 0);	231	res = platform_get_resource(pdev, IORESOURCE_REG, 0);
287	if (!res) {	232	if (!res) {
@@ -290,10 +235,8 @@ static int max8925_regulator_probe(struct platform_device *pdev) · 2 unmodified lines
290	}	235	}
291	for (i = 0; i < ARRAY_SIZE(max8925_regulator_info); i++) {	236	for (i = 0; i < ARRAY_SIZE(max8925_regulator_info); i++) {
292	ri = &max8925_regulator_info[i];	237	ri = &max8925_regulator_info[i];
293	if (ri->vol_reg == res->start) {	238	if (ri->vol_reg == res->start)
294	regulator_idx = i;
295	break;	239	break;
296	}
297	}	240	}
298		241
299	if (i == ARRAY_SIZE(max8925_regulator_info)) {	242	if (i == ARRAY_SIZE(max8925_regulator_info)) {
@@ -303,12 +246,11 @@ static int max8925_regulator_probe(struct platform_device *pdev) · 3 unmodified lines
303	}	246	}
304	ri->i2c = chip->i2c;	247	ri->i2c = chip->i2c;
305		248
306	config.dev = &pdev->dev;	249	config.dev = chip->dev;
307	config.driver_data = ri;	250	config.driver_data = ri;
308		251
309	if (max8925_regulator_dt_init(pdev, &config, regulator_idx))	252	if (pdata)
310	if (pdata)	253	config.init_data = pdata;
311	config.init_data = pdata;
312		254
313	rdev = devm_regulator_register(&pdev->dev, &ri->desc, &config);	255	rdev = devm_regulator_register(&pdev->dev, &ri->desc, &config);
314	if (IS_ERR(rdev)) {	256	if (IS_ERR(rdev)) {

drivers/regulator/max8998.c+59−241

@@ -33,72 +33,6 @@ struct max8998_data { · 32 unmodified lines
33	unsigned int buck2_idx;	33	unsigned int buck2_idx;
34	};	34	};
35		35
36	struct voltage_map_desc {
37	int min;
38	int max;
39	int step;
40	};
41
42	/* Voltage maps in uV*/
43	static const struct voltage_map_desc ldo23_voltage_map_desc = {
44	.min = 800000, .step = 50000, .max = 1300000,
45	};
46	static const struct voltage_map_desc ldo456711_voltage_map_desc = {
47	.min = 1600000, .step = 100000, .max = 3600000,
48	};
49	static const struct voltage_map_desc ldo8_voltage_map_desc = {
50	.min = 3000000, .step = 100000, .max = 3600000,
51	};
52	static const struct voltage_map_desc ldo9_voltage_map_desc = {
53	.min = 2800000, .step = 100000, .max = 3100000,
54	};
55	static const struct voltage_map_desc ldo10_voltage_map_desc = {
56	.min = 950000, .step = 50000, .max = 1300000,
57	};
58	static const struct voltage_map_desc ldo1213_voltage_map_desc = {
59	.min = 800000, .step = 100000, .max = 3300000,
60	};
61	static const struct voltage_map_desc ldo1415_voltage_map_desc = {
62	.min = 1200000, .step = 100000, .max = 3300000,
63	};
64	static const struct voltage_map_desc ldo1617_voltage_map_desc = {
65	.min = 1600000, .step = 100000, .max = 3600000,
66	};
67	static const struct voltage_map_desc buck12_voltage_map_desc = {
68	.min = 750000, .step = 25000, .max = 1525000,
69	};
70	static const struct voltage_map_desc buck3_voltage_map_desc = {
71	.min = 1600000, .step = 100000, .max = 3600000,
72	};
73	static const struct voltage_map_desc buck4_voltage_map_desc = {
74	.min = 800000, .step = 100000, .max = 2300000,
75	};
76
77	static const struct voltage_map_desc *ldo_voltage_map[] = {
78	NULL,
79	NULL,
80	&ldo23_voltage_map_desc, /* LDO2 */
81	&ldo23_voltage_map_desc, /* LDO3 */
82	&ldo456711_voltage_map_desc, /* LDO4 */
83	&ldo456711_voltage_map_desc, /* LDO5 */
84	&ldo456711_voltage_map_desc, /* LDO6 */
85	&ldo456711_voltage_map_desc, /* LDO7 */
86	&ldo8_voltage_map_desc, /* LDO8 */
87	&ldo9_voltage_map_desc, /* LDO9 */
88	&ldo10_voltage_map_desc, /* LDO10 */
89	&ldo456711_voltage_map_desc, /* LDO11 */
90	&ldo1213_voltage_map_desc, /* LDO12 */
91	&ldo1213_voltage_map_desc, /* LDO13 */
92	&ldo1415_voltage_map_desc, /* LDO14 */
93	&ldo1415_voltage_map_desc, /* LDO15 */
94	&ldo1617_voltage_map_desc, /* LDO16 */
95	&ldo1617_voltage_map_desc, /* LDO17 */
96	&buck12_voltage_map_desc, /* BUCK1 */
97	&buck12_voltage_map_desc, /* BUCK2 */
98	&buck3_voltage_map_desc, /* BUCK3 */
99	&buck4_voltage_map_desc, /* BUCK4 */
100	};
101
102	static int max8998_get_enable_register(struct regulator_dev *rdev,	36	static int max8998_get_enable_register(struct regulator_dev *rdev,
103	int reg, int shift)	37	int reg, int shift)
104	{	38	{
@@ -400,7 +334,6 @@ static int max8998_set_voltage_buck_time_sel(struct regulator_dev *rdev, · 295 unmodified lines
400	{	334	{
401	struct max8998_data *max8998 = rdev_get_drvdata(rdev);	335	struct max8998_data *max8998 = rdev_get_drvdata(rdev);
402	struct i2c_client *i2c = max8998->iodev->i2c;	336	struct i2c_client *i2c = max8998->iodev->i2c;
403	const struct voltage_map_desc *desc;
404	int buck = rdev_get_id(rdev);	337	int buck = rdev_get_id(rdev);
405	u8 val = 0;	338	u8 val = 0;
406	int difference, ret;	339	int difference, ret;
@@ -408,8 +341,6 @@ static int max8998_set_voltage_buck_time_sel(struct regulator_dev *rdev, · 1 unmodified line
408	if (buck < MAX8998_BUCK1 \|\| buck > MAX8998_BUCK4)	341	if (buck < MAX8998_BUCK1 \|\| buck > MAX8998_BUCK4)
409	return -EINVAL;	342	return -EINVAL;
410		343
411	desc = ldo_voltage_map[buck];
412
413	/* Voltage stabilization */	344	/* Voltage stabilization */
414	ret = max8998_read_reg(i2c, MAX8998_REG_ONOFF4, &val);	345	ret = max8998_read_reg(i2c, MAX8998_REG_ONOFF4, &val);
415	if (ret)	346	if (ret)
@@ -420,14 +351,14 @@ static int max8998_set_voltage_buck_time_sel(struct regulator_dev *rdev, · 4 unmodified lines
420	if (max8998->iodev->type == TYPE_MAX8998 && !(val & MAX8998_ENRAMP))	351	if (max8998->iodev->type == TYPE_MAX8998 && !(val & MAX8998_ENRAMP))
421	return 0;	352	return 0;
422		353
423	difference = (new_selector - old_selector) * desc->step / 1000;	354	difference = (new_selector - old_selector) * rdev->desc->uV_step / 1000;
424	if (difference > 0)	355	if (difference > 0)
425	return DIV_ROUND_UP(difference, (val & 0x0f) + 1);	356	return DIV_ROUND_UP(difference, (val & 0x0f) + 1);
426		357
427	return 0;	358	return 0;
428	}	359	}
429		360
430	static struct regulator_ops max8998_ldo_ops = {	361	static const struct regulator_ops max8998_ldo_ops = {
431	.list_voltage = regulator_list_voltage_linear,	362	.list_voltage = regulator_list_voltage_linear,
432	.map_voltage = regulator_map_voltage_linear,	363	.map_voltage = regulator_map_voltage_linear,
433	.is_enabled = max8998_ldo_is_enabled,	364	.is_enabled = max8998_ldo_is_enabled,
@@ -437,7 +368,7 @@ static struct regulator_ops max8998_ldo_ops = { · 3 unmodified lines
437	.set_voltage_sel = max8998_set_voltage_ldo_sel,	368	.set_voltage_sel = max8998_set_voltage_ldo_sel,
438	};	369	};
439		370
440	static struct regulator_ops max8998_buck_ops = {	371	static const struct regulator_ops max8998_buck_ops = {
441	.list_voltage = regulator_list_voltage_linear,	372	.list_voltage = regulator_list_voltage_linear,
442	.map_voltage = regulator_map_voltage_linear,	373	.map_voltage = regulator_map_voltage_linear,
443	.is_enabled = max8998_ldo_is_enabled,	374	.is_enabled = max8998_ldo_is_enabled,
@@ -448,164 +379,59 @@ static struct regulator_ops max8998_buck_ops = { · 4 unmodified lines
448	.set_voltage_time_sel = max8998_set_voltage_buck_time_sel,	379	.set_voltage_time_sel = max8998_set_voltage_buck_time_sel,
449	};	380	};
450		381
451	static struct regulator_ops max8998_others_ops = {	382	static const struct regulator_ops max8998_others_ops = {
452	.is_enabled = max8998_ldo_is_enabled,	383	.is_enabled = max8998_ldo_is_enabled,
453	.enable = max8998_ldo_enable,	384	.enable = max8998_ldo_enable,
454	.disable = max8998_ldo_disable,	385	.disable = max8998_ldo_disable,
455	};	386	};
456		387
457	static struct regulator_desc regulators[] = {	388	#define MAX8998_LINEAR_REG(_name, _ops, _min, _step, _max) \
458	{	389	{ \
459	.name = "LDO2",	390	.name = #_name, \
460	.id = MAX8998_LDO2,	391	.id = MAX8998_##_name, \
461	.ops = &max8998_ldo_ops,	392	.ops = _ops, \
462	.type = REGULATOR_VOLTAGE,	393	.min_uV = (_min), \
463	.owner = THIS_MODULE,	394	.uV_step = (_step), \
464	}, {	395	.n_voltages = ((_max) - (_min)) / (_step) + 1, \
465	.name = "LDO3",	396	.type = REGULATOR_VOLTAGE, \
466	.id = MAX8998_LDO3,	397	.owner = THIS_MODULE, \
467	.ops = &max8998_ldo_ops,
468	.type = REGULATOR_VOLTAGE,
469	.owner = THIS_MODULE,
470	}, {
471	.name = "LDO4",
472	.id = MAX8998_LDO4,
473	.ops = &max8998_ldo_ops,
474	.type = REGULATOR_VOLTAGE,
475	.owner = THIS_MODULE,
476	}, {
477	.name = "LDO5",
478	.id = MAX8998_LDO5,
479	.ops = &max8998_ldo_ops,
480	.type = REGULATOR_VOLTAGE,
481	.owner = THIS_MODULE,
482	}, {
483	.name = "LDO6",
484	.id = MAX8998_LDO6,
485	.ops = &max8998_ldo_ops,
486	.type = REGULATOR_VOLTAGE,
487	.owner = THIS_MODULE,
488	}, {
489	.name = "LDO7",
490	.id = MAX8998_LDO7,
491	.ops = &max8998_ldo_ops,
492	.type = REGULATOR_VOLTAGE,
493	.owner = THIS_MODULE,
494	}, {
495	.name = "LDO8",
496	.id = MAX8998_LDO8,
497	.ops = &max8998_ldo_ops,
498	.type = REGULATOR_VOLTAGE,
499	.owner = THIS_MODULE,
500	}, {
501	.name = "LDO9",
502	.id = MAX8998_LDO9,
503	.ops = &max8998_ldo_ops,
504	.type = REGULATOR_VOLTAGE,
505	.owner = THIS_MODULE,
506	}, {
507	.name = "LDO10",
508	.id = MAX8998_LDO10,
509	.ops = &max8998_ldo_ops,
510	.type = REGULATOR_VOLTAGE,
511	.owner = THIS_MODULE,
512	}, {
513	.name = "LDO11",
514	.id = MAX8998_LDO11,
515	.ops = &max8998_ldo_ops,
516	.type = REGULATOR_VOLTAGE,
517	.owner = THIS_MODULE,
518	}, {
519	.name = "LDO12",
520	.id = MAX8998_LDO12,
521	.ops = &max8998_ldo_ops,
522	.type = REGULATOR_VOLTAGE,
523	.owner = THIS_MODULE,
524	}, {
525	.name = "LDO13",
526	.id = MAX8998_LDO13,
527	.ops = &max8998_ldo_ops,
528	.type = REGULATOR_VOLTAGE,
529	.owner = THIS_MODULE,
530	}, {
531	.name = "LDO14",
532	.id = MAX8998_LDO14,
533	.ops = &max8998_ldo_ops,
534	.type = REGULATOR_VOLTAGE,
535	.owner = THIS_MODULE,
536	}, {
537	.name = "LDO15",
538	.id = MAX8998_LDO15,
539	.ops = &max8998_ldo_ops,
540	.type = REGULATOR_VOLTAGE,
541	.owner = THIS_MODULE,
542	}, {
543	.name = "LDO16",
544	.id = MAX8998_LDO16,
545	.ops = &max8998_ldo_ops,
546	.type = REGULATOR_VOLTAGE,
547	.owner = THIS_MODULE,
548	}, {
549	.name = "LDO17",
550	.id = MAX8998_LDO17,
551	.ops = &max8998_ldo_ops,
552	.type = REGULATOR_VOLTAGE,
553	.owner = THIS_MODULE,
554	}, {
555	.name = "BUCK1",
556	.id = MAX8998_BUCK1,
557	.ops = &max8998_buck_ops,
558	.type = REGULATOR_VOLTAGE,
559	.owner = THIS_MODULE,
560	}, {
561	.name = "BUCK2",
562	.id = MAX8998_BUCK2,
563	.ops = &max8998_buck_ops,
564	.type = REGULATOR_VOLTAGE,
565	.owner = THIS_MODULE,
566	}, {
567	.name = "BUCK3",
568	.id = MAX8998_BUCK3,
569	.ops = &max8998_buck_ops,
570	.type = REGULATOR_VOLTAGE,
571	.owner = THIS_MODULE,
572	}, {
573	.name = "BUCK4",
574	.id = MAX8998_BUCK4,
575	.ops = &max8998_buck_ops,
576	.type = REGULATOR_VOLTAGE,
577	.owner = THIS_MODULE,
578	}, {
579	.name = "EN32KHz-AP",
580	.id = MAX8998_EN32KHZ_AP,
581	.ops = &max8998_others_ops,
582	.type = REGULATOR_VOLTAGE,
583	.owner = THIS_MODULE,
584	}, {
585	.name = "EN32KHz-CP",
586	.id = MAX8998_EN32KHZ_CP,
587	.ops = &max8998_others_ops,
588	.type = REGULATOR_VOLTAGE,
589	.owner = THIS_MODULE,
590	}, {
591	.name = "ENVICHG",
592	.id = MAX8998_ENVICHG,
593	.ops = &max8998_others_ops,
594	.type = REGULATOR_VOLTAGE,
595	.owner = THIS_MODULE,
596	}, {
597	.name = "ESAFEOUT1",
598	.id = MAX8998_ESAFEOUT1,
599	.ops = &max8998_others_ops,
600	.type = REGULATOR_VOLTAGE,
601	.owner = THIS_MODULE,
602	}, {
603	.name = "ESAFEOUT2",
604	.id = MAX8998_ESAFEOUT2,
605	.ops = &max8998_others_ops,
606	.type = REGULATOR_VOLTAGE,
607	.owner = THIS_MODULE,
608	}	398	}
		399
		400	#define MAX8998_OTHERS_REG(_name, _id) \
		401	{ \
		402	.name = #_name, \
		403	.id = _id, \
		404	.ops = &max8998_others_ops, \
		405	.type = REGULATOR_VOLTAGE, \
		406	.owner = THIS_MODULE, \
		407	}
		408
		409	static const struct regulator_desc regulators[] = {
		410	MAX8998_LINEAR_REG(LDO2, &max8998_ldo_ops, 800000, 50000, 1300000),
		411	MAX8998_LINEAR_REG(LDO3, &max8998_ldo_ops, 800000, 50000, 1300000),
		412	MAX8998_LINEAR_REG(LDO4, &max8998_ldo_ops, 1600000, 100000, 3600000),
		413	MAX8998_LINEAR_REG(LDO5, &max8998_ldo_ops, 1600000, 100000, 3600000),
		414	MAX8998_LINEAR_REG(LDO6, &max8998_ldo_ops, 1600000, 100000, 3600000),
		415	MAX8998_LINEAR_REG(LDO7, &max8998_ldo_ops, 1600000, 100000, 3600000),
		416	MAX8998_LINEAR_REG(LDO8, &max8998_ldo_ops, 3000000, 100000, 3600000),
		417	MAX8998_LINEAR_REG(LDO9, &max8998_ldo_ops, 2800000, 100000, 3100000),
		418	MAX8998_LINEAR_REG(LDO10, &max8998_ldo_ops, 950000, 50000, 1300000),
		419	MAX8998_LINEAR_REG(LDO11, &max8998_ldo_ops, 1600000, 100000, 3600000),
		420	MAX8998_LINEAR_REG(LDO12, &max8998_ldo_ops, 800000, 100000, 3300000),
		421	MAX8998_LINEAR_REG(LDO13, &max8998_ldo_ops, 800000, 100000, 3300000),
		422	MAX8998_LINEAR_REG(LDO14, &max8998_ldo_ops, 1200000, 100000, 3300000),
		423	MAX8998_LINEAR_REG(LDO15, &max8998_ldo_ops, 1200000, 100000, 3300000),
		424	MAX8998_LINEAR_REG(LDO16, &max8998_ldo_ops, 1600000, 100000, 3600000),
		425	MAX8998_LINEAR_REG(LDO17, &max8998_ldo_ops, 1600000, 100000, 3600000),
		426	MAX8998_LINEAR_REG(BUCK1, &max8998_buck_ops, 750000, 25000, 1525000),
		427	MAX8998_LINEAR_REG(BUCK2, &max8998_buck_ops, 750000, 25000, 1525000),
		428	MAX8998_LINEAR_REG(BUCK3, &max8998_buck_ops, 1600000, 100000, 3600000),
		429	MAX8998_LINEAR_REG(BUCK4, &max8998_buck_ops, 800000, 100000, 2300000),
		430	MAX8998_OTHERS_REG(EN32KHz-AP, MAX8998_EN32KHZ_AP),
		431	MAX8998_OTHERS_REG(EN32KHz-CP, MAX8998_EN32KHZ_CP),
		432	MAX8998_OTHERS_REG(ENVICHG, MAX8998_ENVICHG),
		433	MAX8998_OTHERS_REG(ESAFEOUT1, MAX8998_ESAFEOUT1),
		434	MAX8998_OTHERS_REG(ESAFEOUT2, MAX8998_ESAFEOUT2),
609	};	435	};
610		436
611	static int max8998_pmic_dt_parse_dvs_gpio(struct max8998_dev *iodev,	437	static int max8998_pmic_dt_parse_dvs_gpio(struct max8998_dev *iodev,
@@ -796,9 +622,11 @@ static int max8998_pmic_probe(struct platform_device *pdev) · 184 unmodified lines
796		622
797	/* Set predefined values for BUCK1 registers */	623	/* Set predefined values for BUCK1 registers */
798	for (v = 0; v < ARRAY_SIZE(pdata->buck1_voltage); ++v) {	624	for (v = 0; v < ARRAY_SIZE(pdata->buck1_voltage); ++v) {
		625	int index = MAX8998_BUCK1 - MAX8998_LDO2;
		626
799	i = 0;	627	i = 0;
800	while (buck12_voltage_map_desc.min +	628	while (regulators[index].min_uV +
801	buck12_voltage_map_desc.step*i	629	regulators[index].uV_step * i
802	< pdata->buck1_voltage[v])	630	< pdata->buck1_voltage[v])
803	i++;	631	i++;
804		632
@@ -824,9 +652,11 @@ static int max8998_pmic_probe(struct platform_device *pdev) · 19 unmodified lines
824		652
825	/* Set predefined values for BUCK2 registers */	653	/* Set predefined values for BUCK2 registers */
826	for (v = 0; v < ARRAY_SIZE(pdata->buck2_voltage); ++v) {	654	for (v = 0; v < ARRAY_SIZE(pdata->buck2_voltage); ++v) {
		655	int index = MAX8998_BUCK2 - MAX8998_LDO2;
		656
827	i = 0;	657	i = 0;
828	while (buck12_voltage_map_desc.min +	658	while (regulators[index].min_uV +
829	buck12_voltage_map_desc.step*i	659	regulators[index].uV_step * i
830	< pdata->buck2_voltage[v])	660	< pdata->buck2_voltage[v])
831	i++;	661	i++;
832		662
@@ -839,18 +669,7 @@ static int max8998_pmic_probe(struct platform_device *pdev) · 6 unmodified lines
839	}	669	}
840		670
841	for (i = 0; i < pdata->num_regulators; i++) {	671	for (i = 0; i < pdata->num_regulators; i++) {
842	const struct voltage_map_desc *desc;	672	int index = pdata->regulators[i].id - MAX8998_LDO2;
843	int id = pdata->regulators[i].id;
844	int index = id - MAX8998_LDO2;
845
846	desc = ldo_voltage_map[id];
847	if (desc && regulators[index].ops != &max8998_others_ops) {
848	int count = (desc->max - desc->min) / desc->step + 1;
849
850	regulators[index].n_voltages = count;
851	regulators[index].min_uV = desc->min;
852	regulators[index].uV_step = desc->step;
853	}
854		673
855	config.dev = max8998->dev;	674	config.dev = max8998->dev;
856	config.of_node = pdata->regulators[i].reg_node;	675	config.of_node = pdata->regulators[i].reg_node;
@@ -867,7 +686,6 @@ static int max8998_pmic_probe(struct platform_device *pdev) · 10 unmodified lines
867	}	686	}
868	}	687	}
869		688
870
871	return 0;	689	return 0;
872	}	690	}
873		691

drivers/regulator/mcp16502.c+22−45

  * @lpm: LPM GPIO descriptor
  */
 struct mcp16502 {
-	struct regulator_dev *rdev[NUM_REGULATORS];
-	struct regmap *rmap;
 	struct gpio_desc *lpm;
 };
 {
 	unsigned int val;
 	int ret, reg;
-	struct mcp16502 *mcp = rdev_get_drvdata(rdev);
 	reg = mcp16502_get_reg(rdev, MCP16502_OPMODE_ACTIVE);
 	if (reg < 0)
 		return reg;
-	ret = regmap_read(mcp->rmap, reg, &val);
+	ret = regmap_read(rdev->regmap, reg, &val);
 	if (ret)
 		return ret;
 {
 	int val;
 	int reg;
-	struct mcp16502 *mcp = rdev_get_drvdata(rdev);
 	reg = mcp16502_get_reg(rdev, op_mode);
 	if (reg < 0)
 		return -EINVAL;
 	}
-	reg = regmap_update_bits(mcp->rmap, reg, MCP16502_MODE, val);
+	reg = regmap_update_bits(rdev->regmap, reg, MCP16502_MODE, val);
 	return reg;
 }
 {
 	int ret;
 	unsigned int val;
-	struct mcp16502 *mcp = rdev_get_drvdata(rdev);
-	ret = regmap_read(mcp->rmap, MCP16502_STAT_BASE(rdev_get_id(rdev)),
+	ret = regmap_read(rdev->regmap, MCP16502_STAT_BASE(rdev_get_id(rdev)),
 			  &val);
 	if (ret)
 		return ret;
  */
 static int mcp16502_set_suspend_voltage(struct regulator_dev *rdev, int uV)
 {
-	struct mcp16502 *mcp = rdev_get_drvdata(rdev);
 	int sel = regulator_map_voltage_linear_range(rdev, uV, uV);
 	int reg = mcp16502_suspend_get_target_reg(rdev);
 	if (reg < 0)
 		return reg;
-	return regmap_update_bits(mcp->rmap, reg, MCP16502_VSEL, sel);
+	return regmap_update_bits(rdev->regmap, reg, MCP16502_VSEL, sel);
 }
 /*
  */
 static int mcp16502_set_suspend_enable(struct regulator_dev *rdev)
 {
-	struct mcp16502 *mcp = rdev_get_drvdata(rdev);
 	int reg = mcp16502_suspend_get_target_reg(rdev);
 	if (reg < 0)
 		return reg;
-	return regmap_update_bits(mcp->rmap, reg, MCP16502_EN, MCP16502_EN);
+	return regmap_update_bits(rdev->regmap, reg, MCP16502_EN, MCP16502_EN);
 }
 /*
  */
 static int mcp16502_set_suspend_disable(struct regulator_dev *rdev)
 {
-	struct mcp16502 *mcp = rdev_get_drvdata(rdev);
 	int reg = mcp16502_suspend_get_target_reg(rdev);
 	if (reg < 0)
 		return reg;
-	return regmap_update_bits(mcp->rmap, reg, MCP16502_EN, 0);
+	return regmap_update_bits(rdev->regmap, reg, MCP16502_EN, 0);
 }
 #endif /* CONFIG_SUSPEND */
 	.wr_table	= &mcp16502_yes_reg_table,
 };
-/*
- * set_up_regulators() - initialize all regulators
- */
-static int setup_regulators(struct mcp16502 *mcp, struct device *dev,
-			    struct regulator_config config)
-{
-	int i;
-	for (i = 0; i < NUM_REGULATORS; i++) {
-		mcp->rdev[i] = devm_regulator_register(dev,
-						       &mcp16502_desc[i],
-						       &config);
-		if (IS_ERR(mcp->rdev[i])) {
-			dev_err(dev,
-				"failed to register %s regulator %ld\n",
-				mcp16502_desc[i].name, PTR_ERR(mcp->rdev[i]));
-			return PTR_ERR(mcp->rdev[i]);
-		}
-	}
-	return 0;
-}
 static int mcp16502_probe(struct i2c_client *client,
 			  const struct i2c_device_id *id)
 {
 	struct regulator_config config = { };
+	struct regulator_dev *rdev;
 	struct device *dev;
 	struct mcp16502 *mcp;
-	int ret = 0;
+	struct regmap *rmap;
+	int i, ret;
 	dev = &client->dev;
 	config.dev = dev;
 	if (!mcp)
 		return -ENOMEM;
-	mcp->rmap = devm_regmap_init_i2c(client, &mcp16502_regmap_config);
+	rmap = devm_regmap_init_i2c(client, &mcp16502_regmap_config);
-	if (IS_ERR(mcp->rmap)) {
+	if (IS_ERR(rmap)) {
-		ret = PTR_ERR(mcp->rmap);
+		ret = PTR_ERR(rmap);
 		dev_err(dev, "regmap init failed: %d\n", ret);
 		return ret;
 	}
 	i2c_set_clientdata(client, mcp);
-	config.regmap = mcp->rmap;
+	config.regmap = rmap;
 	config.driver_data = mcp;
 	mcp->lpm = devm_gpiod_get(dev, "lpm", GPIOD_OUT_LOW);
 		return PTR_ERR(mcp->lpm);
 	}
-	ret = setup_regulators(mcp, dev, config);
+	for (i = 0; i < NUM_REGULATORS; i++) {
-	if (ret != 0)
+		rdev = devm_regulator_register(dev, &mcp16502_desc[i], &config);
-		return ret;
+		if (IS_ERR(rdev)) {
+			dev_err(dev,
+				"failed to register %s regulator %ld\n",
+				mcp16502_desc[i].name, PTR_ERR(rdev));
+			return PTR_ERR(rdev);
+		}
+	}
 	mcp16502_gpio_set_mode(mcp, MCP16502_OPMODE_ACTIVE);

drivers/regulator/mt6311-regulator.c+4−13

@@ -1,16 +1,7 @@
1	/*	1	// SPDX-License-Identifier: GPL-2.0
2	* Copyright (c) 2015 MediaTek Inc.	2	//
3	* Author: Henry Chen <henryc.chen@mediatek.com>	3	// Copyright (c) 2015 MediaTek Inc.
4	*	4	// Author: Henry Chen <henryc.chen@mediatek.com>
5	* This program is free software; you can redistribute it and/or modify
6	* it under the terms of the GNU General Public License version 2 as
7	* published by the Free Software Foundation.
8	*
9	* This program is distributed in the hope that it will be useful,
10	* but WITHOUT ANY WARRANTY; without even the implied warranty of
11	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12	* GNU General Public License for more details.
13	*/
14		5
15	#include <linux/err.h>	6	#include <linux/err.h>
16	#include <linux/gpio.h>	7	#include <linux/gpio.h>

drivers/regulator/mt6311-regulator.h+1−9

@@ -1,15 +1,7 @@
		1	/* SPDX-License-Identifier: GPL-2.0 */
1	/*	2	/*
2	* Copyright (c) 2015 MediaTek Inc.	3	* Copyright (c) 2015 MediaTek Inc.
3	* Author: Henry Chen <henryc.chen@mediatek.com>	4	* Author: Henry Chen <henryc.chen@mediatek.com>
4	*
5	* This program is free software; you can redistribute it and/or modify
6	* it under the terms of the GNU General Public License version 2 as
7	* published by the Free Software Foundation.
8	*
9	* This program is distributed in the hope that it will be useful,
10	* but WITHOUT ANY WARRANTY; without even the implied warranty of
11	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12	* GNU General Public License for more details.
13	*/	5	*/
14		6
15	#ifndef __MT6311_REGULATOR_H__	7	#ifndef __MT6311_REGULATOR_H__

drivers/regulator/mt6323-regulator.c+14−18

-/*
+// SPDX-License-Identifier: GPL-2.0
- * Copyright (c) 2016 MediaTek Inc.
+//
- * Author: Chen Zhong <chen.zhong@mediatek.com>
+// Copyright (c) 2016 MediaTek Inc.
- *
+// Author: Chen Zhong <chen.zhong@mediatek.com>
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License version 2 as
- * published by the Free Software Foundation.
- */
 #include <linux/module.h>
 #include <linux/of.h>
 	REGULATOR_LINEAR_RANGE(500000, 0, 0x3f, 50000),
 };
-static const u32 ldo_volt_table1[] = {
+static const unsigned int ldo_volt_table1[] = {
 	3300000, 3400000, 3500000, 3600000,
 };
-static const u32 ldo_volt_table2[] = {
+static const unsigned int ldo_volt_table2[] = {
 	1500000, 1800000, 2500000, 2800000,
 };
-static const u32 ldo_volt_table3[] = {
+static const unsigned int ldo_volt_table3[] = {
 	1800000, 3300000,
 };
-static const u32 ldo_volt_table4[] = {
+static const unsigned int ldo_volt_table4[] = {
 	3000000, 3300000,
 };
-static const u32 ldo_volt_table5[] = {
+static const unsigned int ldo_volt_table5[] = {
 	1200000, 1300000, 1500000, 1800000, 2000000, 2800000, 3000000, 3300000,
 };
-static const u32 ldo_volt_table6[] = {
+static const unsigned int ldo_volt_table6[] = {
 	1200000, 1300000, 1500000, 1800000, 2500000, 2800000, 3000000, 2000000,
 };
-static const u32 ldo_volt_table7[] = {
+static const unsigned int ldo_volt_table7[] = {
 	1200000, 1300000, 1500000, 1800000,
 };
-static const u32 ldo_volt_table8[] = {
+static const unsigned int ldo_volt_table8[] = {
 	1800000, 3000000,
 };
-static const u32 ldo_volt_table9[] = {
+static const unsigned int ldo_volt_table9[] = {
 	1200000, 1350000, 1500000, 1800000,
 };
-static const u32 ldo_volt_table10[] = {
+static const unsigned int ldo_volt_table10[] = {
 	1200000, 1300000, 1500000, 1800000,
 };

drivers/regulator/mt6380-regulator.c+8−17

-/*
+// SPDX-License-Identifier: GPL-2.0
- * Copyright (c) 2017 MediaTek Inc.
+//
- * Author: Chenglin Xu <chenglin.xu@mediatek.com>
+// Copyright (c) 2017 MediaTek Inc.
- *
+// Author: Chenglin Xu <chenglin.xu@mediatek.com>
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License version 2 as
- * published by the Free Software Foundation.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- */
 #include <linux/module.h>
 #include <linux/of.h>
 	REGULATOR_LINEAR_RANGE(1200000, 0, 0x3c, 25000),
 };
-static const u32 ldo_volt_table1[] = {
+static const unsigned int ldo_volt_table1[] = {
 	1400000, 1350000, 1300000, 1250000, 1200000, 1150000, 1100000, 1050000,
 };
-static const u32 ldo_volt_table2[] = {
+static const unsigned int ldo_volt_table2[] = {
 	2200000, 3300000,
 };
-static const u32 ldo_volt_table3[] = {
+static const unsigned int ldo_volt_table3[] = {
 	1240000, 1390000, 1540000, 1840000,
 };
-static const u32 ldo_volt_table4[] = {
+static const unsigned int ldo_volt_table4[] = {
 	2200000, 3300000,
 };

drivers/regulator/mt6397-regulator.c+12−21

-/*
+// SPDX-License-Identifier: GPL-2.0
- * Copyright (c) 2014 MediaTek Inc.
+//
- * Author: Flora Fu <flora.fu@mediatek.com>
+// Copyright (c) 2014 MediaTek Inc.
- *
+// Author: Flora Fu <flora.fu@mediatek.com>
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License version 2 as
- * published by the Free Software Foundation.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- */
 #include <linux/module.h>
 #include <linux/of.h>
 	REGULATOR_LINEAR_RANGE(1500000, 0, 0x1f, 20000),
 };
-static const u32 ldo_volt_table1[] = {
+static const unsigned int ldo_volt_table1[] = {
 	1500000, 1800000, 2500000, 2800000,
 };
-static const u32 ldo_volt_table2[] = {
+static const unsigned int ldo_volt_table2[] = {
 	1800000, 3300000,
 };
-static const u32 ldo_volt_table3[] = {
+static const unsigned int ldo_volt_table3[] = {
 	3000000, 3300000,
 };
-static const u32 ldo_volt_table4[] = {
+static const unsigned int ldo_volt_table4[] = {
 	1220000, 1300000, 1500000, 1800000, 2500000, 2800000, 3000000, 3300000,
 };
-static const u32 ldo_volt_table5[] = {
+static const unsigned int ldo_volt_table5[] = {
 	1200000, 1300000, 1500000, 1800000, 2500000, 2800000, 3000000, 3300000,
 };
-static const u32 ldo_volt_table5_v2[] = {
+static const unsigned int ldo_volt_table5_v2[] = {
 	1200000, 1000000, 1500000, 1800000, 2500000, 2800000, 3000000, 3300000,
 };
-static const u32 ldo_volt_table6[] = {
+static const unsigned int ldo_volt_table6[] = {
 	1200000, 1300000, 1500000, 1800000, 2500000, 2800000, 3000000, 2000000,
 };
-static const u32 ldo_volt_table7[] = {
+static const unsigned int ldo_volt_table7[] = {
 	1300000, 1500000, 1800000, 2000000, 2500000, 2800000, 3000000, 3300000,
 };

drivers/regulator/of_regulator.c+3−2

 }
 EXPORT_SYMBOL_GPL(of_regulator_match);
-struct device_node *regulator_of_get_init_node(struct device *dev,
+static struct
-					       const struct regulator_desc *desc)
+device_node *regulator_of_get_init_node(struct device *dev,
+					const struct regulator_desc *desc)
 {
 	struct device_node *search, *child;
 	const char *name;

drivers/regulator/palmas-regulator.c+0−12

 			return PTR_ERR(rdev);
 		}
-		/* Save regulator for cleanup */
-		pmic->rdev[id] = rdev;
 		/* Initialise sleep/init values from platform data */
 		if (pdata) {
 			reg_init = pdata->reg_init[id];
 			return PTR_ERR(rdev);
 		}
-		/* Save regulator for cleanup */
-		pmic->rdev[id] = rdev;
 		/* Initialise sleep/init values from platform data */
 		if (pdata) {
 			reg_init = pdata->reg_init[id];
 				pdev_name);
 			return PTR_ERR(rdev);
 		}
-		/* Save regulator for cleanup */
-		pmic->rdev[id] = rdev;
 	}
 	return 0;
 				pdev_name);
 			return PTR_ERR(rdev);
 		}
-		/* Save regulator for cleanup */
-		pmic->rdev[id] = rdev;
 	}
 	return 0;

drivers/regulator/pv88060-regulator.c+8−14

-/*
+// SPDX-License-Identifier: GPL-2.0+
- * pv88060-regulator.c - Regulator device driver for PV88060
+//
- * Copyright (C) 2015  Powerventure Semiconductor Ltd.
+// pv88060-regulator.c - Regulator device driver for PV88060
- *
+// Copyright (C) 2015  Powerventure Semiconductor Ltd.
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU General Public License
- * as published by the Free Software Foundation; either version 2
- * of the License, or (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- */
 #include <linux/err.h>
 #include <linux/i2c.h>
 	if (reg_val & PV88060_E_VDD_FLT) {
 		for (i = 0; i < PV88060_MAX_REGULATORS; i++) {
 			if (chip->rdev[i] != NULL) {
+				regulator_lock(chip->rdev[i]);
 				regulator_notifier_call_chain(chip->rdev[i],
 					REGULATOR_EVENT_UNDER_VOLTAGE,
 					NULL);
+				regulator_unlock(chip->rdev[i]);
 			}
 		}
 	if (reg_val & PV88060_E_OVER_TEMP) {
 		for (i = 0; i < PV88060_MAX_REGULATORS; i++) {
 			if (chip->rdev[i] != NULL) {
+				regulator_lock(chip->rdev[i]);
 				regulator_notifier_call_chain(chip->rdev[i],
 					REGULATOR_EVENT_OVER_TEMP,
 					NULL);
+				regulator_unlock(chip->rdev[i]);
 			}
 		}

drivers/regulator/pv88060-regulator.h+1−10

@@ -1,16 +1,7 @@
		1	/* SPDX-License-Identifier: GPL-2.0+ */
1	/*	2	/*
2	* pv88060-regulator.h - Regulator definitions for PV88060	3	* pv88060-regulator.h - Regulator definitions for PV88060
3	* Copyright (C) 2015 Powerventure Semiconductor Ltd.	4	* Copyright (C) 2015 Powerventure Semiconductor Ltd.
4	*
5	* This program is free software; you can redistribute it and/or
6	* modify it under the terms of the GNU General Public License
7	* as published by the Free Software Foundation; either version 2
8	* of the License, or (at your option) any later version.
9	*
10	* This program is distributed in the hope that it will be useful,
11	* but WITHOUT ANY WARRANTY; without even the implied warranty of
12	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13	* GNU General Public License for more details.
14	*/	5	*/
15		6
16	#ifndef __PV88060_REGISTERS_H__	7	#ifndef __PV88060_REGISTERS_H__

drivers/regulator/pv88080-regulator.c+8−14

-/*
+// SPDX-License-Identifier: GPL-2.0+
- * pv88080-regulator.c - Regulator device driver for PV88080
+//
- * Copyright (C) 2016  Powerventure Semiconductor Ltd.
+// pv88080-regulator.c - Regulator device driver for PV88080
- *
+// Copyright (C) 2016  Powerventure Semiconductor Ltd.
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU General Public License
- * as published by the Free Software Foundation; either version 2
- * of the License, or (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- */
 #include <linux/err.h>
 #include <linux/i2c.h>
 	if (reg_val & PV88080_E_VDD_FLT) {
 		for (i = 0; i < PV88080_MAX_REGULATORS; i++) {
 			if (chip->rdev[i] != NULL) {
+			        regulator_lock(chip->rdev[i]);
 				regulator_notifier_call_chain(chip->rdev[i],
 					REGULATOR_EVENT_UNDER_VOLTAGE,
 					NULL);
+			        regulator_unlock(chip->rdev[i]);
 			}
 		}
 	if (reg_val & PV88080_E_OVER_TEMP) {
 		for (i = 0; i < PV88080_MAX_REGULATORS; i++) {
 			if (chip->rdev[i] != NULL) {
+			        regulator_lock(chip->rdev[i]);
 				regulator_notifier_call_chain(chip->rdev[i],
 					REGULATOR_EVENT_OVER_TEMP,
 					NULL);
+			        regulator_unlock(chip->rdev[i]);
 			}
 		}

drivers/regulator/pv88080-regulator.h+1−10

@@ -1,16 +1,7 @@
		1	/* SPDX-License-Identifier: GPL-2.0+ */
1	/*	2	/*
2	* pv88080-regulator.h - Regulator definitions for PV88080	3	* pv88080-regulator.h - Regulator definitions for PV88080
3	* Copyright (C) 2016 Powerventure Semiconductor Ltd.	4	* Copyright (C) 2016 Powerventure Semiconductor Ltd.
4	*
5	* This program is free software; you can redistribute it and/or
6	* modify it under the terms of the GNU General Public License
7	* as published by the Free Software Foundation; either version 2
8	* of the License, or (at your option) any later version.
9	*
10	* This program is distributed in the hope that it will be useful,
11	* but WITHOUT ANY WARRANTY; without even the implied warranty of
12	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13	* GNU General Public License for more details.
14	*/	5	*/
15		6
16	#ifndef __PV88080_REGISTERS_H__	7	#ifndef __PV88080_REGISTERS_H__

drivers/regulator/pv88090-regulator.c+8−14

-/*
+// SPDX-License-Identifier: GPL-2.0+
- * pv88090-regulator.c - Regulator device driver for PV88090
+//
- * Copyright (C) 2015  Powerventure Semiconductor Ltd.
+// pv88090-regulator.c - Regulator device driver for PV88090
- *
+// Copyright (C) 2015  Powerventure Semiconductor Ltd.
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU General Public License
- * as published by the Free Software Foundation; either version 2
- * of the License, or (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- */
 #include <linux/err.h>
 #include <linux/i2c.h>
 	if (reg_val & PV88090_E_VDD_FLT) {
 		for (i = 0; i < PV88090_MAX_REGULATORS; i++) {
 			if (chip->rdev[i] != NULL) {
+			        regulator_lock(chip->rdev[i]);
 				regulator_notifier_call_chain(chip->rdev[i],
 					REGULATOR_EVENT_UNDER_VOLTAGE,
 					NULL);
+			        regulator_unlock(chip->rdev[i]);
 			}
 		}
 	if (reg_val & PV88090_E_OVER_TEMP) {
 		for (i = 0; i < PV88090_MAX_REGULATORS; i++) {
 			if (chip->rdev[i] != NULL) {
+			        regulator_lock(chip->rdev[i]);
 				regulator_notifier_call_chain(chip->rdev[i],
 					REGULATOR_EVENT_OVER_TEMP,
 					NULL);
+			        regulator_unlock(chip->rdev[i]);
 			}
 		}

drivers/regulator/pv88090-regulator.h+1−10

@@ -1,16 +1,7 @@
		1	/* SPDX-License-Identifier: GPL-2.0+ */
1	/*	2	/*
2	* pv88090-regulator.h - Regulator definitions for PV88090	3	* pv88090-regulator.h - Regulator definitions for PV88090
3	* Copyright (C) 2015 Powerventure Semiconductor Ltd.	4	* Copyright (C) 2015 Powerventure Semiconductor Ltd.
4	*
5	* This program is free software; you can redistribute it and/or
6	* modify it under the terms of the GNU General Public License
7	* as published by the Free Software Foundation; either version 2
8	* of the License, or (at your option) any later version.
9	*
10	* This program is distributed in the hope that it will be useful,
11	* but WITHOUT ANY WARRANTY; without even the implied warranty of
12	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13	* GNU General Public License for more details.
14	*/	5	*/
15		6
16	#ifndef __PV88090_REGISTERS_H__	7	#ifndef __PV88090_REGISTERS_H__

drivers/regulator/rc5t583-regulator.c+3−22

 	struct regulator_desc	desc;
 };
-struct rc5t583_regulator {
-	struct rc5t583_regulator_info *reg_info;
-	struct regulator_dev	*rdev;
-};
 static int rc5t583_regulator_enable_time(struct regulator_dev *rdev)
 {
-	struct rc5t583_regulator *reg = rdev_get_drvdata(rdev);
+	struct rc5t583_regulator_info *reg_info = rdev_get_drvdata(rdev);
 	int vsel = regulator_get_voltage_sel_regmap(rdev);
 	int curr_uV = regulator_list_voltage_linear(rdev, vsel);
-	return DIV_ROUND_UP(curr_uV, reg->reg_info->enable_uv_per_us);
+	return DIV_ROUND_UP(curr_uV, reg_info->enable_uv_per_us);
 }
 static const struct regulator_ops rc5t583_ops = {
 	struct rc5t583 *rc5t583 = dev_get_drvdata(pdev->dev.parent);
 	struct rc5t583_platform_data *pdata = dev_get_platdata(rc5t583->dev);
 	struct regulator_config config = { };
-	struct rc5t583_regulator *reg = NULL;
-	struct rc5t583_regulator *regs;
 	struct regulator_dev *rdev;
 	struct rc5t583_regulator_info *ri;
 	int ret;
 		return -ENODEV;
 	}
-	regs = devm_kcalloc(&pdev->dev,
-			    RC5T583_REGULATOR_MAX,
-			    sizeof(struct rc5t583_regulator),
-			    GFP_KERNEL);
-	if (!regs)
-		return -ENOMEM;
 	for (id = 0; id < RC5T583_REGULATOR_MAX; ++id) {
-		reg = &regs[id];
 		ri = &rc5t583_reg_info[id];
-		reg->reg_info = ri;
 		if (ri->deepsleep_id == RC5T583_DS_NONE)
 			goto skip_ext_pwr_config;
 skip_ext_pwr_config:
 		config.dev = &pdev->dev;
 		config.init_data = pdata->reg_init_data[id];
-		config.driver_data = reg;
+		config.driver_data = ri;
 		config.regmap = rc5t583->regmap;
 		rdev = devm_regulator_register(&pdev->dev, &ri->desc, &config);
 						ri->desc.name);
 			return PTR_ERR(rdev);
 		}
-		reg->rdev = rdev;
 	}
-	platform_set_drvdata(pdev, regs);
 	return 0;
 }

drivers/regulator/rn5t618-regulator.c+4−4

@@ -46,7 +46,7 @@ static const struct regulator_ops rn5t618_reg_ops = { · 45 unmodified lines
46	.vsel_mask = (vmask), \	46	.vsel_mask = (vmask), \
47	}	47	}
48		48
49	static struct regulator_desc rn5t567_regulators[] = {	49	static const struct regulator_desc rn5t567_regulators[] = {
50	/* DCDC */	50	/* DCDC */
51	REG(DCDC1, DC1CTL, BIT(0), DC1DAC, 0xff, 600000, 3500000, 12500),	51	REG(DCDC1, DC1CTL, BIT(0), DC1DAC, 0xff, 600000, 3500000, 12500),
52	REG(DCDC2, DC2CTL, BIT(0), DC2DAC, 0xff, 600000, 3500000, 12500),	52	REG(DCDC2, DC2CTL, BIT(0), DC2DAC, 0xff, 600000, 3500000, 12500),
@@ -63,7 +63,7 @@ static struct regulator_desc rn5t567_regulators[] = { · 10 unmodified lines
63	REG(LDORTC2, LDOEN2, BIT(5), LDORTC2DAC, 0x7f, 900000, 3500000, 25000),	63	REG(LDORTC2, LDOEN2, BIT(5), LDORTC2DAC, 0x7f, 900000, 3500000, 25000),
64	};	64	};
65		65
66	static struct regulator_desc rn5t618_regulators[] = {	66	static const struct regulator_desc rn5t618_regulators[] = {
67	/* DCDC */	67	/* DCDC */
68	REG(DCDC1, DC1CTL, BIT(0), DC1DAC, 0xff, 600000, 3500000, 12500),	68	REG(DCDC1, DC1CTL, BIT(0), DC1DAC, 0xff, 600000, 3500000, 12500),
69	REG(DCDC2, DC2CTL, BIT(0), DC2DAC, 0xff, 600000, 3500000, 12500),	69	REG(DCDC2, DC2CTL, BIT(0), DC2DAC, 0xff, 600000, 3500000, 12500),
@@ -79,7 +79,7 @@ static struct regulator_desc rn5t618_regulators[] = { · 9 unmodified lines
79	REG(LDORTC2, LDOEN2, BIT(5), LDORTC2DAC, 0x7f, 900000, 3500000, 25000),	79	REG(LDORTC2, LDOEN2, BIT(5), LDORTC2DAC, 0x7f, 900000, 3500000, 25000),
80	};	80	};
81		81
82	static struct regulator_desc rc5t619_regulators[] = {	82	static const struct regulator_desc rc5t619_regulators[] = {
83	/* DCDC */	83	/* DCDC */
84	REG(DCDC1, DC1CTL, BIT(0), DC1DAC, 0xff, 600000, 3500000, 12500),	84	REG(DCDC1, DC1CTL, BIT(0), DC1DAC, 0xff, 600000, 3500000, 12500),
85	REG(DCDC2, DC2CTL, BIT(0), DC2DAC, 0xff, 600000, 3500000, 12500),	85	REG(DCDC2, DC2CTL, BIT(0), DC2DAC, 0xff, 600000, 3500000, 12500),
@@ -107,7 +107,7 @@ static int rn5t618_regulator_probe(struct platform_device *pdev) · 21 unmodified lines
107	struct rn5t618 *rn5t618 = dev_get_drvdata(pdev->dev.parent);	107	struct rn5t618 *rn5t618 = dev_get_drvdata(pdev->dev.parent);
108	struct regulator_config config = { };	108	struct regulator_config config = { };
109	struct regulator_dev *rdev;	109	struct regulator_dev *rdev;
110	struct regulator_desc *regulators;	110	const struct regulator_desc *regulators;
111	int i;	111	int i;
112	int num_regulators = 0;	112	int num_regulators = 0;
113		113

drivers/regulator/s2mpa01.c+10−31

 #include <linux/mfd/samsung/core.h>
 #include <linux/mfd/samsung/s2mpa01.h>
-#define S2MPA01_REGULATOR_CNT ARRAY_SIZE(regulators)
 struct s2mpa01_info {
-	struct of_regulator_match rdata[S2MPA01_REGULATOR_MAX];
 	int ramp_delay24;
 	int ramp_delay3;
 	int ramp_delay5;
 #define regulator_desc_ldo(num, step) {			\
 	.name		= "LDO"#num,			\
+	.of_match	= of_match_ptr("LDO"#num),	\
+	.regulators_node = of_match_ptr("regulators"),	\
 	.id		= S2MPA01_LDO##num,		\
 	.ops		= &s2mpa01_ldo_ops,		\
 	.type		= REGULATOR_VOLTAGE,		\
 #define regulator_desc_buck1_4(num)	{			\
 	.name		= "BUCK"#num,				\
+	.of_match	= of_match_ptr("BUCK"#num),		\
+	.regulators_node = of_match_ptr("regulators"),		\
 	.id		= S2MPA01_BUCK##num,			\
 	.ops		= &s2mpa01_buck_ops,			\
 	.type		= REGULATOR_VOLTAGE,			\
 #define regulator_desc_buck5	{				\
 	.name		= "BUCK5",				\
+	.of_match	= of_match_ptr("BUCK5"),		\
+	.regulators_node = of_match_ptr("regulators"),		\
 	.id		= S2MPA01_BUCK5,			\
 	.ops		= &s2mpa01_buck_ops,			\
 	.type		= REGULATOR_VOLTAGE,			\
 #define regulator_desc_buck6_10(num, min, step) {			\
 	.name		= "BUCK"#num,				\
+	.of_match	= of_match_ptr("BUCK"#num),		\
+	.regulators_node = of_match_ptr("regulators"),		\
 	.id		= S2MPA01_BUCK##num,			\
 	.ops		= &s2mpa01_buck_ops,			\
 	.type		= REGULATOR_VOLTAGE,			\
 {
 	struct sec_pmic_dev *iodev = dev_get_drvdata(pdev->dev.parent);
 	struct sec_platform_data *pdata = dev_get_platdata(iodev->dev);
-	struct device_node *reg_np = NULL;
 	struct regulator_config config = { };
-	struct of_regulator_match *rdata;
 	struct s2mpa01_info *s2mpa01;
 	int i;
 	if (!s2mpa01)
 		return -ENOMEM;
-	rdata = s2mpa01->rdata;
+	config.dev = iodev->dev;
-	for (i = 0; i < S2MPA01_REGULATOR_CNT; i++)
-		rdata[i].name = regulators[i].name;
-	if (iodev->dev->of_node) {
-		reg_np = of_get_child_by_name(iodev->dev->of_node,
-							"regulators");
-		if (!reg_np) {
-			dev_err(&pdev->dev,
-				"could not find regulators sub-node\n");
-			return -EINVAL;
-		}
-		of_regulator_match(&pdev->dev, reg_np, rdata,
-						S2MPA01_REGULATOR_MAX);
-		of_node_put(reg_np);
-	}
-	platform_set_drvdata(pdev, s2mpa01);
-	config.dev = &pdev->dev;
 	config.regmap = iodev->regmap_pmic;
 	config.driver_data = s2mpa01;
 	for (i = 0; i < S2MPA01_REGULATOR_MAX; i++) {
 		struct regulator_dev *rdev;
 		if (pdata)
 			config.init_data = pdata->regulators[i].initdata;
-		else
-			config.init_data = rdata[i].init_data;
-		if (reg_np)
-			config.of_node = rdata[i].of_node;
 		rdev = devm_regulator_register(&pdev->dev,
 						&regulators[i], &config);

drivers/regulator/sc2731-regulator.c+1−1

@@ -146,7 +146,7 @@ static const struct regulator_ops sc2731_regu_linear_ops = { · 145 unmodified lines
146	.vsel_mask = vmask, \	146	.vsel_mask = vmask, \
147	}	147	}
148		148
149	static struct regulator_desc regulators[] = {	149	static const struct regulator_desc regulators[] = {
150	SC2731_REGU_LINEAR(BUCK_CPU0, SC2731_POWER_PD_SW,	150	SC2731_REGU_LINEAR(BUCK_CPU0, SC2731_POWER_PD_SW,
151	SC2731_DCDC_CPU0_PD_MASK, SC2731_DCDC_CPU0_VOL,	151	SC2731_DCDC_CPU0_PD_MASK, SC2731_DCDC_CPU0_VOL,
152	SC2731_DCDC_CPU0_VOL_MASK, 3125, 400000, 1996875),	152	SC2731_DCDC_CPU0_VOL_MASK, 3125, 400000, 1996875),

drivers/regulator/sky81452-regulator.c+7−19

-/*
+// SPDX-License-Identifier: GPL-2.0
- * sky81452-regulator.c	SKY81452 regulator driver
+//
- *
+// sky81452-regulator.c	SKY81452 regulator driver
- * Copyright 2014 Skyworks Solutions Inc.
+//
- * Author : Gyungoh Yoo <jack.yoo@skyworksinc.com>
+// Copyright 2014 Skyworks Solutions Inc.
- *
+// Author : Gyungoh Yoo <jack.yoo@skyworksinc.com>
- * This program is free software; you can redistribute it and/or modify it
- * under the terms of the GNU General Public License version 2
- * as published by the Free Software Foundation.
- *
- * This program is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License along
- * with this program; if not, see <http://www.gnu.org/licenses/>.
- */
 #include <linux/module.h>
 #include <linux/kernel.h>
 #define SKY81452_LEN	0x40
 #define SKY81452_LOUT	0x1F
-static struct regulator_ops sky81452_reg_ops = {
+static const struct regulator_ops sky81452_reg_ops = {
 	.list_voltage = regulator_list_voltage_linear_range,
 	.map_voltage = regulator_map_voltage_linear_range,
 	.get_voltage_sel = regulator_get_voltage_sel_regmap,

drivers/regulator/stm32-pwr.c+186−0

@@ -0,0 +1,186 @@
	1	// SPDX-License-Identifier: GPL-2.0
	2	// Copyright (C) STMicroelectronics 2019
	3	// Authors: Gabriel Fernandez <gabriel.fernandez@st.com>
	4	// Pascal Paillet <p.paillet@st.com>.
	5
	6	#include <linux/io.h>
	7	#include <linux/iopoll.h>
	8	#include <linux/module.h>
	9	#include <linux/of_address.h>
	10	#include <linux/of_device.h>
	11	#include <linux/platform_device.h>
	12	#include <linux/regulator/driver.h>
	13	#include <linux/regulator/of_regulator.h>
	14
	15	/*
	16	* Registers description
	17	*/
	18	#define REG_PWR_CR3 0x0C
	19
	20	#define USB_3_3_EN BIT(24)
	21	#define USB_3_3_RDY BIT(26)
	22	#define REG_1_8_EN BIT(28)
	23	#define REG_1_8_RDY BIT(29)
	24	#define REG_1_1_EN BIT(30)
	25	#define REG_1_1_RDY BIT(31)
	26
	27	/* list of supported regulators */
	28	enum {
	29	PWR_REG11,
	30	PWR_REG18,
	31	PWR_USB33,
	32	STM32PWR_REG_NUM_REGS
	33	};
	34
	35	static u32 ready_mask_table[STM32PWR_REG_NUM_REGS] = {
	36	[PWR_REG11] = REG_1_1_RDY,
	37	[PWR_REG18] = REG_1_8_RDY,
	38	[PWR_USB33] = USB_3_3_RDY,
	39	};
	40
	41	struct stm32_pwr_reg {
	42	void __iomem *base;
	43	u32 ready_mask;
	44	};
	45
	46	static int stm32_pwr_reg_is_ready(struct regulator_dev *rdev)
	47	{
	48	struct stm32_pwr_reg *priv = rdev_get_drvdata(rdev);
	49	u32 val;
	50
	51	val = readl_relaxed(priv->base + REG_PWR_CR3);
	52
	53	return (val & priv->ready_mask);
	54	}
	55
	56	static int stm32_pwr_reg_is_enabled(struct regulator_dev *rdev)
	57	{
	58	struct stm32_pwr_reg *priv = rdev_get_drvdata(rdev);
	59	u32 val;
	60
	61	val = readl_relaxed(priv->base + REG_PWR_CR3);
	62
	63	return (val & rdev->desc->enable_mask);
	64	}
	65
	66	static int stm32_pwr_reg_enable(struct regulator_dev *rdev)
	67	{
	68	struct stm32_pwr_reg *priv = rdev_get_drvdata(rdev);
	69	int ret;
	70	u32 val;
	71
	72	val = readl_relaxed(priv->base + REG_PWR_CR3);
	73	val \|= rdev->desc->enable_mask;
	74	writel_relaxed(val, priv->base + REG_PWR_CR3);
	75
	76	/* use an arbitrary timeout of 20ms */
	77	ret = readx_poll_timeout(stm32_pwr_reg_is_ready, rdev, val, val,
	78	100, 20 * 1000);
	79	if (ret)
	80	dev_err(&rdev->dev, "regulator enable timed out!\n");
	81
	82	return ret;
	83	}
	84
	85	static int stm32_pwr_reg_disable(struct regulator_dev *rdev)
	86	{
	87	struct stm32_pwr_reg *priv = rdev_get_drvdata(rdev);
	88	int ret;
	89	u32 val;
	90
	91	val = readl_relaxed(priv->base + REG_PWR_CR3);
	92	val &= ~rdev->desc->enable_mask;
	93	writel_relaxed(val, priv->base + REG_PWR_CR3);
	94
	95	/* use an arbitrary timeout of 20ms */
	96	ret = readx_poll_timeout(stm32_pwr_reg_is_ready, rdev, val, !val,
	97	100, 20 * 1000);
	98	if (ret)
	99	dev_err(&rdev->dev, "regulator disable timed out!\n");
	100
	101	return ret;
	102	}
	103
	104	static const struct regulator_ops stm32_pwr_reg_ops = {
	105	.enable = stm32_pwr_reg_enable,
	106	.disable = stm32_pwr_reg_disable,
	107	.is_enabled = stm32_pwr_reg_is_enabled,
	108	};
	109
	110	#define PWR_REG(_id, _name, _volt, _en, _supply) \
	111	[_id] = { \
	112	.id = _id, \
	113	.name = _name, \
	114	.of_match = of_match_ptr(_name), \
	115	.n_voltages = 1, \
	116	.type = REGULATOR_VOLTAGE, \
	117	.fixed_uV = _volt, \
	118	.ops = &stm32_pwr_reg_ops, \
	119	.enable_mask = _en, \
	120	.owner = THIS_MODULE, \
	121	.supply_name = _supply, \
	122	} \
	123
	124	static const struct regulator_desc stm32_pwr_desc[] = {
	125	PWR_REG(PWR_REG11, "reg11", 1100000, REG_1_1_EN, "vdd"),
	126	PWR_REG(PWR_REG18, "reg18", 1800000, REG_1_8_EN, "vdd"),
	127	PWR_REG(PWR_USB33, "usb33", 3300000, USB_3_3_EN, "vdd_3v3_usbfs"),
	128	};
	129
	130	static int stm32_pwr_regulator_probe(struct platform_device *pdev)
	131	{
	132	struct device_node *np = pdev->dev.of_node;
	133	struct stm32_pwr_reg *priv;
	134	void __iomem *base;
	135	struct regulator_dev *rdev;
	136	struct regulator_config config = { };
	137	int i, ret = 0;
	138
	139	base = of_iomap(np, 0);
	140	if (!base) {
	141	dev_err(&pdev->dev, "Unable to map IO memory\n");
	142	return -ENOMEM;
	143	}
	144
	145	config.dev = &pdev->dev;
	146
	147	for (i = 0; i < STM32PWR_REG_NUM_REGS; i++) {
	148	priv = devm_kzalloc(&pdev->dev, sizeof(struct stm32_pwr_reg),
	149	GFP_KERNEL);
	150	if (!priv)
	151	return -ENOMEM;
	152	priv->base = base;
	153	priv->ready_mask = ready_mask_table[i];
	154	config.driver_data = priv;
	155
	156	rdev = devm_regulator_register(&pdev->dev,
	157	&stm32_pwr_desc[i],
	158	&config);
	159	if (IS_ERR(rdev)) {
	160	ret = PTR_ERR(rdev);
	161	dev_err(&pdev->dev,
	162	"Failed to register regulator: %d\n", ret);
	163	break;
	164	}
	165	}
	166	return ret;
	167	}
	168
	169	static const struct of_device_id stm32_pwr_of_match[] = {
	170	{ .compatible = "st,stm32mp1,pwr-reg", },
	171	{},
	172	};
	173	MODULE_DEVICE_TABLE(of, stm32_pwr_of_match);
	174
	175	static struct platform_driver stm32_pwr_driver = {
	176	.probe = stm32_pwr_regulator_probe,
	177	.driver = {
	178	.name = "stm32-pwr-regulator",
	179	.of_match_table = of_match_ptr(stm32_pwr_of_match),
	180	},
	181	};
	182	module_platform_driver(stm32_pwr_driver);
	183
	184	MODULE_DESCRIPTION("STM32MP1 PWR voltage regulator driver");
	185	MODULE_AUTHOR("Pascal Paillet <p.paillet@st.com>");
	186	MODULE_LICENSE("GPL v2");

drivers/regulator/sy8106a-regulator.c+13−27

  */
 #define SY8106A_GO_BIT			BIT(7)
-struct sy8106a {
-	struct regulator_dev *rdev;
-	struct regmap *regmap;
-	u32 fixed_voltage;
-};
 static const struct regmap_config sy8106a_regmap_config = {
 	.reg_bits = 8,
 	.val_bits = 8,
 static int sy8106a_i2c_probe(struct i2c_client *i2c,
 			    const struct i2c_device_id *id)
 {
-	struct sy8106a *chip;
 	struct device *dev = &i2c->dev;
-	struct regulator_dev *rdev = NULL;
+	struct regulator_dev *rdev;
 	struct regulator_config config = { };
+	struct regmap *regmap;
 	unsigned int reg, vsel;
+	u32 fixed_voltage;
 	int error;
-	chip = devm_kzalloc(&i2c->dev, sizeof(struct sy8106a), GFP_KERNEL);
-	if (!chip)
-		return -ENOMEM;
 	error = of_property_read_u32(dev->of_node, "silergy,fixed-microvolt",
-				     &chip->fixed_voltage);
+				     &fixed_voltage);
 	if (error)
 		return error;
-	if (chip->fixed_voltage < SY8106A_MIN_MV * 1000 ||
+	if (fixed_voltage < SY8106A_MIN_MV * 1000 ||
-	    chip->fixed_voltage > SY8106A_MAX_MV * 1000)
+	    fixed_voltage > SY8106A_MAX_MV * 1000)
 		return -EINVAL;
-	chip->regmap = devm_regmap_init_i2c(i2c, &sy8106a_regmap_config);
+	regmap = devm_regmap_init_i2c(i2c, &sy8106a_regmap_config);
-	if (IS_ERR(chip->regmap)) {
+	if (IS_ERR(regmap)) {
-		error = PTR_ERR(chip->regmap);
+		error = PTR_ERR(regmap);
 		dev_err(dev, "Failed to allocate register map: %d\n", error);
 		return error;
 	}
 	config.dev = &i2c->dev;
-	config.regmap = chip->regmap;
+	config.regmap = regmap;
-	config.driver_data = chip;
 	config.of_node = dev->of_node;
 	config.init_data = of_get_regulator_init_data(dev, dev->of_node,
 		return -ENOMEM;
 	/* Ensure GO_BIT is enabled when probing */
-	error = regmap_read(chip->regmap, SY8106A_REG_VOUT1_SEL, &reg);
+	error = regmap_read(regmap, SY8106A_REG_VOUT1_SEL, &reg);
 	if (error)
 		return error;
 	if (!(reg & SY8106A_GO_BIT)) {
-		vsel = (chip->fixed_voltage / 1000 - SY8106A_MIN_MV) /
+		vsel = (fixed_voltage / 1000 - SY8106A_MIN_MV) /
 		       SY8106A_STEP_MV;
-		error = regmap_write(chip->regmap, SY8106A_REG_VOUT1_SEL,
+		error = regmap_write(regmap, SY8106A_REG_VOUT1_SEL,
 				     vsel | SY8106A_GO_BIT);
 		if (error)
 			return error;
 		return error;
 	}
-	chip->rdev = rdev;
-	i2c_set_clientdata(i2c, chip);
 	return 0;
 }

drivers/regulator/tps6507x-regulator.c+20−93

@@ -115,7 +115,6 @@ static struct tps_info tps6507x_pmic_regs[] = { · 114 unmodified lines
115	struct tps6507x_pmic {	115	struct tps6507x_pmic {
116	struct regulator_desc desc[TPS6507X_NUM_REGULATOR];	116	struct regulator_desc desc[TPS6507X_NUM_REGULATOR];
117	struct tps6507x_dev *mfd;	117	struct tps6507x_dev *mfd;
118	struct regulator_dev *rdev[TPS6507X_NUM_REGULATOR];
119	struct tps_info *info[TPS6507X_NUM_REGULATOR];	118	struct tps_info *info[TPS6507X_NUM_REGULATOR];
120	struct mutex io_lock;	119	struct mutex io_lock;
121	};	120	};
@@ -349,7 +348,7 @@ static int tps6507x_pmic_set_voltage_sel(struct regulator_dev *dev, · 227 unmodified lines
349	return tps6507x_pmic_reg_write(tps, reg, data);	348	return tps6507x_pmic_reg_write(tps, reg, data);
350	}	349	}
351		350
352	static struct regulator_ops tps6507x_pmic_ops = {	351	static const struct regulator_ops tps6507x_pmic_ops = {
353	.is_enabled = tps6507x_pmic_is_enabled,	352	.is_enabled = tps6507x_pmic_is_enabled,
354	.enable = tps6507x_pmic_enable,	353	.enable = tps6507x_pmic_enable,
355	.disable = tps6507x_pmic_disable,	354	.disable = tps6507x_pmic_disable,
@@ -359,66 +358,20 @@ static struct regulator_ops tps6507x_pmic_ops = { · 3 unmodified lines
359	.map_voltage = regulator_map_voltage_ascend,	358	.map_voltage = regulator_map_voltage_ascend,
360	};	359	};
361		360
362	static struct of_regulator_match tps6507x_matches[] = {	361	static int tps6507x_pmic_of_parse_cb(struct device_node *np,
363	{ .name = "VDCDC1"},	362	const struct regulator_desc *desc,
364	{ .name = "VDCDC2"},	363	struct regulator_config *config)
365	{ .name = "VDCDC3"},
366	{ .name = "LDO1"},
367	{ .name = "LDO2"},
368	};
369
370	static struct tps6507x_board *tps6507x_parse_dt_reg_data(
371	struct platform_device *pdev,
372	struct of_regulator_match **tps6507x_reg_matches)
373	{	364	{
374	struct tps6507x_board *tps_board;	365	struct tps6507x_pmic *tps = config->driver_data;
375	struct device_node *np = pdev->dev.parent->of_node;	366	struct tps_info *info = tps->info[desc->id];
376	struct device_node *regulators;	367	u32 prop;
377	struct of_regulator_match *matches;	368	int ret;
378	struct regulator_init_data *reg_data;
379	int idx = 0, count, ret;
380
381	tps_board = devm_kzalloc(&pdev->dev, sizeof(*tps_board),
382	GFP_KERNEL);
383	if (!tps_board)
384	return NULL;
385
386	regulators = of_get_child_by_name(np, "regulators");
387	if (!regulators) {
388	dev_err(&pdev->dev, "regulator node not found\n");
389	return NULL;
390	}
391
392	count = ARRAY_SIZE(tps6507x_matches);
393	matches = tps6507x_matches;
394
395	ret = of_regulator_match(&pdev->dev, regulators, matches, count);
396	of_node_put(regulators);
397	if (ret < 0) {
398	dev_err(&pdev->dev, "Error parsing regulator init data: %d\n",
399	ret);
400	return NULL;
401	}
402		369
403	*tps6507x_reg_matches = matches;	370	ret = of_property_read_u32(np, "ti,defdcdc_default", &prop);
404		371	if (!ret)
405	reg_data = devm_kzalloc(&pdev->dev, (sizeof(struct regulator_init_data)	372	info->defdcdc_default = prop;
406	* TPS6507X_NUM_REGULATOR), GFP_KERNEL);
407	if (!reg_data)
408	return NULL;
409
410	tps_board->tps6507x_pmic_init_data = reg_data;
411
412	for (idx = 0; idx < count; idx++) {
413	if (!matches[idx].init_data \|\| !matches[idx].of_node)
414	continue;
415
416	memcpy(&reg_data[idx], matches[idx].init_data,
417	sizeof(struct regulator_init_data));
418
419	}
420		373
421	return tps_board;	374	return 0;
422	}	375	}
423		376
424	static int tps6507x_pmic_probe(struct platform_device *pdev)	377	static int tps6507x_pmic_probe(struct platform_device *pdev)
@@ -426,14 +379,11 @@ static int tps6507x_pmic_probe(struct platform_device *pdev) · 1 unmodified line
426	struct tps6507x_dev *tps6507x_dev = dev_get_drvdata(pdev->dev.parent);	379	struct tps6507x_dev *tps6507x_dev = dev_get_drvdata(pdev->dev.parent);
427	struct tps_info *info = &tps6507x_pmic_regs[0];	380	struct tps_info *info = &tps6507x_pmic_regs[0];
428	struct regulator_config config = { };	381	struct regulator_config config = { };
429	struct regulator_init_data *init_data;	382	struct regulator_init_data *init_data = NULL;
430	struct regulator_dev *rdev;	383	struct regulator_dev *rdev;
431	struct tps6507x_pmic *tps;	384	struct tps6507x_pmic *tps;
432	struct tps6507x_board *tps_board;	385	struct tps6507x_board *tps_board;
433	struct of_regulator_match *tps6507x_reg_matches = NULL;
434	int i;	386	int i;
435	int error;
436	unsigned int prop;
437		387
438	/**	388	/**
439	* tps_board points to pmic related constants	389	* tps_board points to pmic related constants
@@ -441,20 +391,8 @@ static int tps6507x_pmic_probe(struct platform_device *pdev) · 1 unmodified line
441	*/	391	*/
442		392
443	tps_board = dev_get_platdata(tps6507x_dev->dev);	393	tps_board = dev_get_platdata(tps6507x_dev->dev);
444	if (IS_ENABLED(CONFIG_OF) && !tps_board &&	394	if (tps_board)
445	tps6507x_dev->dev->of_node)	395	init_data = tps_board->tps6507x_pmic_init_data;
446	tps_board = tps6507x_parse_dt_reg_data(pdev,
447	&tps6507x_reg_matches);
448	if (!tps_board)
449	return -EINVAL;
450
451	/**
452	* init_data points to array of regulator_init structures
453	* coming from the board-evm file.
454	*/
455	init_data = tps_board->tps6507x_pmic_init_data;
456	if (!init_data)
457	return -EINVAL;
458		396
459	tps = devm_kzalloc(&pdev->dev, sizeof(*tps), GFP_KERNEL);	397	tps = devm_kzalloc(&pdev->dev, sizeof(*tps), GFP_KERNEL);
460	if (!tps)	398	if (!tps)
@@ -468,13 +406,16 @@ static int tps6507x_pmic_probe(struct platform_device *pdev) · 7 unmodified lines
468	for (i = 0; i < TPS6507X_NUM_REGULATOR; i++, info++, init_data++) {	406	for (i = 0; i < TPS6507X_NUM_REGULATOR; i++, info++, init_data++) {
469	/* Register the regulators */	407	/* Register the regulators */
470	tps->info[i] = info;	408	tps->info[i] = info;
471	if (init_data->driver_data) {	409	if (init_data && init_data->driver_data) {
472	struct tps6507x_reg_platform_data *data =	410	struct tps6507x_reg_platform_data *data =
473	init_data->driver_data;	411	init_data->driver_data;
474	tps->info[i]->defdcdc_default = data->defdcdc_default;	412	info->defdcdc_default = data->defdcdc_default;
475	}	413	}
476		414
477	tps->desc[i].name = info->name;	415	tps->desc[i].name = info->name;
		416	tps->desc[i].of_match = of_match_ptr(info->name);
		417	tps->desc[i].regulators_node = of_match_ptr("regulators");
		418	tps->desc[i].of_parse_cb = tps6507x_pmic_of_parse_cb;
478	tps->desc[i].id = i;	419	tps->desc[i].id = i;
479	tps->desc[i].n_voltages = info->table_len;	420	tps->desc[i].n_voltages = info->table_len;
480	tps->desc[i].volt_table = info->table;	421	tps->desc[i].volt_table = info->table;
@@ -486,17 +427,6 @@ static int tps6507x_pmic_probe(struct platform_device *pdev) · 5 unmodified lines
486	config.init_data = init_data;	427	config.init_data = init_data;
487	config.driver_data = tps;	428	config.driver_data = tps;
488		429
489	if (tps6507x_reg_matches) {
490	error = of_property_read_u32(
491	tps6507x_reg_matches[i].of_node,
492	"ti,defdcdc_default", &prop);
493
494	if (!error)
495	tps->info[i]->defdcdc_default = prop;
496
497	config.of_node = tps6507x_reg_matches[i].of_node;
498	}
499
500	rdev = devm_regulator_register(&pdev->dev, &tps->desc[i],	430	rdev = devm_regulator_register(&pdev->dev, &tps->desc[i],
501	&config);	431	&config);
502	if (IS_ERR(rdev)) {	432	if (IS_ERR(rdev)) {
@@ -505,9 +435,6 @@ static int tps6507x_pmic_probe(struct platform_device *pdev) · 2 unmodified lines
505	pdev->name);	435	pdev->name);
506	return PTR_ERR(rdev);	436	return PTR_ERR(rdev);
507	}	437	}
508
509	/* Save regulator for cleanup */
510	tps->rdev[i] = rdev;
511	}	438	}
512		439
513	tps6507x_dev->pmic = tps;	440	tps6507x_dev->pmic = tps;

drivers/regulator/tps65086-regulator.c+2−2

@@ -90,8 +90,8 @@ static const struct regulator_linear_range tps65086_buck345_25mv_ranges[] = { · 89 unmodified lines
90	static const struct regulator_linear_range tps65086_ldoa1_ranges[] = {	90	static const struct regulator_linear_range tps65086_ldoa1_ranges[] = {
91	REGULATOR_LINEAR_RANGE(1350000, 0x0, 0x0, 0),	91	REGULATOR_LINEAR_RANGE(1350000, 0x0, 0x0, 0),
92	REGULATOR_LINEAR_RANGE(1500000, 0x1, 0x7, 100000),	92	REGULATOR_LINEAR_RANGE(1500000, 0x1, 0x7, 100000),
93	REGULATOR_LINEAR_RANGE(2300000, 0x8, 0xA, 100000),	93	REGULATOR_LINEAR_RANGE(2300000, 0x8, 0xB, 100000),
94	REGULATOR_LINEAR_RANGE(2700000, 0xB, 0xD, 150000),	94	REGULATOR_LINEAR_RANGE(2850000, 0xC, 0xD, 150000),
95	REGULATOR_LINEAR_RANGE(3300000, 0xE, 0xE, 0),	95	REGULATOR_LINEAR_RANGE(3300000, 0xE, 0xE, 0),
96	};	96	};
97		97

drivers/regulator/tps65132-regulator.c+13−16

 struct tps65132_regulator {
 	struct device *dev;
-	struct regmap *rmap;
-	struct regulator_desc *rdesc[TPS65132_MAX_REGULATORS];
 	struct tps65132_reg_pdata reg_pdata[TPS65132_MAX_REGULATORS];
-	struct regulator_dev *rdev[TPS65132_MAX_REGULATORS];
 };
 static int tps65132_regulator_enable(struct regulator_dev *rdev)
 	return 1;
 }
-static struct regulator_ops tps65132_regulator_ops = {
+static const struct regulator_ops tps65132_regulator_ops = {
 	.enable = tps65132_regulator_enable,
 	.disable = tps65132_regulator_disable,
 	.is_enabled = tps65132_regulator_is_enabled,
 		.owner = THIS_MODULE,			\
 	}
-static struct regulator_desc tps_regs_desc[TPS65132_MAX_REGULATORS] = {
+static const struct regulator_desc tps_regs_desc[TPS65132_MAX_REGULATORS] = {
 	TPS65132_REGULATOR_DESC(VPOS, outp),
 	TPS65132_REGULATOR_DESC(VNEG, outn),
 };
 {
 	struct device *dev = &client->dev;
 	struct tps65132_regulator *tps;
+	struct regulator_dev *rdev;
+	struct regmap *rmap;
 	struct regulator_config config = { };
 	int id;
 	int ret;
 	if (!tps)
 		return -ENOMEM;
-	tps->rmap = devm_regmap_init_i2c(client, &tps65132_regmap_config);
+	rmap = devm_regmap_init_i2c(client, &tps65132_regmap_config);
-	if (IS_ERR(tps->rmap)) {
+	if (IS_ERR(rmap)) {
-		ret = PTR_ERR(tps->rmap);
+		ret = PTR_ERR(rmap);
 		dev_err(dev, "regmap init failed: %d\n", ret);
 		return ret;
 	}
 	tps->dev = dev;
 	for (id = 0; id < TPS65132_MAX_REGULATORS; ++id) {
-		tps->rdesc[id] = &tps_regs_desc[id];
+		config.regmap = rmap;
-		config.regmap = tps->rmap;
 		config.dev = dev;
 		config.driver_data = tps;
-		tps->rdev[id] = devm_regulator_register(dev,
+		rdev = devm_regulator_register(dev, &tps_regs_desc[id],
-					tps->rdesc[id], &config);
+					       &config);
-		if (IS_ERR(tps->rdev[id])) {
+		if (IS_ERR(rdev)) {
-			ret = PTR_ERR(tps->rdev[id]);
+			ret = PTR_ERR(rdev);
 			dev_err(dev, "regulator %s register failed: %d\n",
-				tps->rdesc[id]->name, ret);
+				tps_regs_desc[id].name, ret);
 			return ret;
 		}
 	}

drivers/regulator/tps65217-regulator.c+3−4

 static const struct regulator_linear_range tps65217_uv1_ranges[] = {
 	REGULATOR_LINEAR_RANGE(900000, 0, 24, 25000),
-	REGULATOR_LINEAR_RANGE(1550000, 25, 30, 50000),
+	REGULATOR_LINEAR_RANGE(1550000, 25, 52, 50000),
-	REGULATOR_LINEAR_RANGE(1850000, 31, 52, 50000),
 	REGULATOR_LINEAR_RANGE(3000000, 53, 55, 100000),
 	REGULATOR_LINEAR_RANGE(3300000, 56, 63, 0),
 };
 }
 /* Operations permitted on DCDCx, LDO2, LDO3 and LDO4 */
-static struct regulator_ops tps65217_pmic_ops = {
+static const struct regulator_ops tps65217_pmic_ops = {
 	.is_enabled		= regulator_is_enabled_regmap,
 	.enable			= tps65217_pmic_enable,
 	.disable		= tps65217_pmic_disable,
 };
 /* Operations permitted on LDO1 */
-static struct regulator_ops tps65217_pmic_ldo1_ops = {
+static const struct regulator_ops tps65217_pmic_ldo1_ops = {
 	.is_enabled		= regulator_is_enabled_regmap,
 	.enable			= tps65217_pmic_enable,
 	.disable		= tps65217_pmic_disable,

drivers/regulator/tps65218-regulator.c+23−33

 #include <linux/mfd/tps65218.h>
 #define TPS65218_REGULATOR(_name, _of, _id, _type, _ops, _n, _vr, _vm, _er, \
-			   _em, _cr, _cm, _lr, _nlr, _delay, _fuv, _sr, _sm) \
+			   _em, _cr, _cm, _lr, _nlr, _delay, _fuv, _sr, _sm, \
+			   _ct, _ncl) \
 	{							\
 		.name			= _name,		\
 		.of_match		= _of,			\
 		.vsel_mask		= _vm,			\
 		.csel_reg		= _cr,			\
 		.csel_mask		= _cm,			\
+		.curr_table		= _ct,			\
+		.n_current_limits	= _ncl,			\
 		.enable_reg		= _er,			\
 		.enable_mask		= _em,			\
 		.volt_table		= NULL,			\
 }
 /* Operations permitted on DCDC1, DCDC2 */
-static struct regulator_ops tps65218_dcdc12_ops = {
+static const struct regulator_ops tps65218_dcdc12_ops = {
 	.is_enabled		= regulator_is_enabled_regmap,
 	.enable			= tps65218_pmic_enable,
 	.disable		= tps65218_pmic_disable,
 };
 /* Operations permitted on DCDC3, DCDC4 and LDO1 */
-static struct regulator_ops tps65218_ldo1_dcdc34_ops = {
+static const struct regulator_ops tps65218_ldo1_dcdc34_ops = {
 	.is_enabled		= regulator_is_enabled_regmap,
 	.enable			= tps65218_pmic_enable,
 	.disable		= tps65218_pmic_disable,
 	.set_suspend_disable	= tps65218_pmic_set_suspend_disable,
 };
-static const int ls3_currents[] = { 100000, 200000, 500000, 1000000 };
+static const unsigned int ls3_currents[] = { 100000, 200000, 500000, 1000000 };
 static int tps65218_pmic_set_input_current_lim(struct regulator_dev *dev,
 					       int lim_uA)
 				 TPS65218_PROTECT_L1);
 }
-static int tps65218_pmic_get_current_limit(struct regulator_dev *dev)
+static const struct regulator_ops tps65218_ls23_ops = {
-{
-	int retval;
-	unsigned int index;
-	struct tps65218 *tps = rdev_get_drvdata(dev);
-	retval = regmap_read(tps->regmap, dev->desc->csel_reg, &index);
-	if (retval < 0)
-		return retval;
-	index = (index & dev->desc->csel_mask) >>
-					 __builtin_ctz(dev->desc->csel_mask);
-	return ls3_currents[index];
-}
-static struct regulator_ops tps65218_ls23_ops = {
 	.is_enabled		= regulator_is_enabled_regmap,
 	.enable			= tps65218_pmic_enable,
 	.disable		= tps65218_pmic_disable,
 	.set_input_current_limit = tps65218_pmic_set_input_current_lim,
 	.set_current_limit	= tps65218_pmic_set_current_limit,
-	.get_current_limit	= tps65218_pmic_get_current_limit,
+	.get_current_limit	= regulator_get_current_limit_regmap,
 };
 /* Operations permitted on DCDC5, DCDC6 */
-static struct regulator_ops tps65218_dcdc56_pmic_ops = {
+static const struct regulator_ops tps65218_dcdc56_pmic_ops = {
 	.is_enabled		= regulator_is_enabled_regmap,
 	.enable			= tps65218_pmic_enable,
 	.disable		= tps65218_pmic_disable,
 			   TPS65218_CONTROL_DCDC1_MASK, TPS65218_REG_ENABLE1,
 			   TPS65218_ENABLE1_DC1_EN, 0, 0, dcdc1_dcdc2_ranges,
 			   2, 4000, 0, TPS65218_REG_SEQ3,
-			   TPS65218_SEQ3_DC1_SEQ_MASK),
+			   TPS65218_SEQ3_DC1_SEQ_MASK, NULL, 0),
 	TPS65218_REGULATOR("DCDC2", "regulator-dcdc2", TPS65218_DCDC_2,
 			   REGULATOR_VOLTAGE, tps65218_dcdc12_ops, 64,
 			   TPS65218_REG_CONTROL_DCDC2,
 			   TPS65218_CONTROL_DCDC2_MASK, TPS65218_REG_ENABLE1,
 			   TPS65218_ENABLE1_DC2_EN, 0, 0, dcdc1_dcdc2_ranges,
 			   2, 4000, 0, TPS65218_REG_SEQ3,
-			   TPS65218_SEQ3_DC2_SEQ_MASK),
+			   TPS65218_SEQ3_DC2_SEQ_MASK, NULL, 0),
 	TPS65218_REGULATOR("DCDC3", "regulator-dcdc3", TPS65218_DCDC_3,
 			   REGULATOR_VOLTAGE, tps65218_ldo1_dcdc34_ops, 64,
 			   TPS65218_REG_CONTROL_DCDC3,
 			   TPS65218_CONTROL_DCDC3_MASK, TPS65218_REG_ENABLE1,
 			   TPS65218_ENABLE1_DC3_EN, 0, 0, ldo1_dcdc3_ranges, 2,
-			   0, 0, TPS65218_REG_SEQ4, TPS65218_SEQ4_DC3_SEQ_MASK),
+			   0, 0, TPS65218_REG_SEQ4, TPS65218_SEQ4_DC3_SEQ_MASK,
+			   NULL, 0),
 	TPS65218_REGULATOR("DCDC4", "regulator-dcdc4", TPS65218_DCDC_4,
 			   REGULATOR_VOLTAGE, tps65218_ldo1_dcdc34_ops, 53,
 			   TPS65218_REG_CONTROL_DCDC4,
 			   TPS65218_CONTROL_DCDC4_MASK, TPS65218_REG_ENABLE1,
 			   TPS65218_ENABLE1_DC4_EN, 0, 0, dcdc4_ranges, 2,
-			   0, 0, TPS65218_REG_SEQ4, TPS65218_SEQ4_DC4_SEQ_MASK),
+			   0, 0, TPS65218_REG_SEQ4, TPS65218_SEQ4_DC4_SEQ_MASK,
+			   NULL, 0),
 	TPS65218_REGULATOR("DCDC5", "regulator-dcdc5", TPS65218_DCDC_5,
 			   REGULATOR_VOLTAGE, tps65218_dcdc56_pmic_ops, 1, -1,
 			   -1, TPS65218_REG_ENABLE1, TPS65218_ENABLE1_DC5_EN, 0,
 			   0, NULL, 0, 0, 1000000, TPS65218_REG_SEQ5,
-			   TPS65218_SEQ5_DC5_SEQ_MASK),
+			   TPS65218_SEQ5_DC5_SEQ_MASK, NULL, 0),
 	TPS65218_REGULATOR("DCDC6", "regulator-dcdc6", TPS65218_DCDC_6,
 			   REGULATOR_VOLTAGE, tps65218_dcdc56_pmic_ops, 1, -1,
 			   -1, TPS65218_REG_ENABLE1, TPS65218_ENABLE1_DC6_EN, 0,
 			   0, NULL, 0, 0, 1800000, TPS65218_REG_SEQ5,
-			   TPS65218_SEQ5_DC6_SEQ_MASK),
+			   TPS65218_SEQ5_DC6_SEQ_MASK, NULL, 0),
 	TPS65218_REGULATOR("LDO1", "regulator-ldo1", TPS65218_LDO_1,
 			   REGULATOR_VOLTAGE, tps65218_ldo1_dcdc34_ops, 64,
 			   TPS65218_REG_CONTROL_LDO1,
 			   TPS65218_CONTROL_LDO1_MASK, TPS65218_REG_ENABLE2,
 			   TPS65218_ENABLE2_LDO1_EN, 0, 0, ldo1_dcdc3_ranges,
 			   2, 0, 0, TPS65218_REG_SEQ6,
-			   TPS65218_SEQ6_LDO1_SEQ_MASK),
+			   TPS65218_SEQ6_LDO1_SEQ_MASK, NULL, 0),
 	TPS65218_REGULATOR("LS2", "regulator-ls2", TPS65218_LS_2,
 			   REGULATOR_CURRENT, tps65218_ls23_ops, 0, 0, 0,
 			   TPS65218_REG_ENABLE2, TPS65218_ENABLE2_LS2_EN,
 			   TPS65218_REG_CONFIG2, TPS65218_CONFIG2_LS2ILIM_MASK,
-			   NULL, 0, 0, 0, 0, 0),
+			   NULL, 0, 0, 0, 0, 0, ls3_currents,
+			   ARRAY_SIZE(ls3_currents)),
 	TPS65218_REGULATOR("LS3", "regulator-ls3", TPS65218_LS_3,
 			   REGULATOR_CURRENT, tps65218_ls23_ops, 0, 0, 0,
 			   TPS65218_REG_ENABLE2, TPS65218_ENABLE2_LS3_EN,
 			   TPS65218_REG_CONFIG2, TPS65218_CONFIG2_LS3ILIM_MASK,
-			   NULL, 0, 0, 0, 0, 0),
+			   NULL, 0, 0, 0, 0, 0, ls3_currents,
+			   ARRAY_SIZE(ls3_currents)),
 };
 static int tps65218_regulator_probe(struct platform_device *pdev)

drivers/regulator/tps6524x-regulator.c+5−6

 	struct spi_device	*spi;
 	struct mutex		lock;
 	struct regulator_desc	desc[N_REGULATORS];
-	struct regulator_dev	*rdev[N_REGULATORS];
 };
 static int __read_reg(struct tps6524x *hw, int reg)
 	return read_field(hw, &info->enable);
 }
-static struct regulator_ops regulator_ops = {
+static const struct regulator_ops regulator_ops = {
 	.is_enabled		= is_supply_enabled,
 	.enable			= enable_supply,
 	.disable		= disable_supply,
 	const struct supply_info *info = supply_info;
 	struct regulator_init_data *init_data;
 	struct regulator_config config = { };
+	struct regulator_dev *rdev;
 	int i;
 	init_data = dev_get_platdata(dev);
 		config.init_data = init_data;
 		config.driver_data = hw;
-		hw->rdev[i] = devm_regulator_register(dev, &hw->desc[i],
+		rdev = devm_regulator_register(dev, &hw->desc[i], &config);
-						      &config);
+		if (IS_ERR(rdev))
-		if (IS_ERR(hw->rdev[i]))
+			return PTR_ERR(rdev);
-			return PTR_ERR(hw->rdev[i]);
 	}
 	return 0;

drivers/regulator/tps80031-regulator.c+16−32

-/*
+// SPDX-License-Identifier: GPL-2.0
- * tps80031-regulator.c -- TI TPS80031 regulator driver.
+//
- *
+// tps80031-regulator.c -- TI TPS80031 regulator driver.
- * Regulator driver for TI TPS80031/TPS80032 Fully Integrated Power
+//
- * Management with Power Path and Battery Charger.
+// Regulator driver for TI TPS80031/TPS80032 Fully Integrated Power
- *
+// Management with Power Path and Battery Charger.
- * Copyright (c) 2012, NVIDIA Corporation.
+//
- *
+// Copyright (c) 2012, NVIDIA Corporation.
- * Author: Laxman Dewangan <ldewangan@nvidia.com>
+//
- *
+// Author: Laxman Dewangan <ldewangan@nvidia.com>
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU General Public License as
- * published by the Free Software Foundation version 2.
- *
- * This program is distributed "as is" WITHOUT ANY WARRANTY of any kind,
- * whether express or implied; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
- * 02111-1307, USA
- */
 #include <linux/delay.h>
 #include <linux/err.h>
 struct tps80031_regulator {
 	struct device			*dev;
-	struct regulator_dev		*rdev;
 	struct tps80031_regulator_info	*rinfo;
 	u8				device_flags;
 }
 /* DCDC voltages for the selector of 58 to 63 */
-static int tps80031_dcdc_voltages[4][5] = {
+static const int tps80031_dcdc_voltages[4][5] = {
 	{ 1350, 1500, 1800, 1900, 2100},
 	{ 1350, 1500, 1800, 1900, 2100},
 	{ 2084, 2315, 2778, 2932, 3241},
 	return ret;
 }
-static struct regulator_ops tps80031_dcdc_ops = {
+static const struct regulator_ops tps80031_dcdc_ops = {
 	.list_voltage		= tps80031_dcdc_list_voltage,
 	.set_voltage_sel	= tps80031_dcdc_set_voltage_sel,
 	.get_voltage_sel	= tps80031_dcdc_get_voltage_sel,
 	.is_enabled	= tps80031_reg_is_enabled,
 };
-static struct regulator_ops tps80031_ldo_ops = {
+static const struct regulator_ops tps80031_ldo_ops = {
 	.list_voltage		= tps80031_ldo_list_voltage,
 	.map_voltage		= tps80031_ldo_map_voltage,
 	.set_voltage_sel	= regulator_set_voltage_sel_regmap,
 	.is_enabled		= tps80031_reg_is_enabled,
 };
-static struct regulator_ops tps80031_vbus_sw_ops = {
+static const struct regulator_ops tps80031_vbus_sw_ops = {
 	.list_voltage	= regulator_list_voltage_linear,
 	.enable		= tps80031_vbus_enable,
 	.disable	= tps80031_vbus_disable,
 	.is_enabled	= tps80031_vbus_is_enabled,
 };
-static struct regulator_ops tps80031_vbus_hw_ops = {
+static const struct regulator_ops tps80031_vbus_hw_ops = {
 	.list_voltage	= regulator_list_voltage_linear,
 };
-static struct regulator_ops tps80031_ext_reg_ops = {
+static const struct regulator_ops tps80031_ext_reg_ops = {
 	.list_voltage	= regulator_list_voltage_linear,
 	.enable		= tps80031_reg_enable,
 	.disable	= tps80031_reg_disable,
 					ri->rinfo->desc.name);
 			return PTR_ERR(rdev);
 		}
-		ri->rdev = rdev;
 	}
 	platform_set_drvdata(pdev, pmic);

drivers/regulator/twl-regulator.c+3−3

@@ -392,7 +392,7 @@ static int twl4030ldo_get_voltage_sel(struct regulator_dev *rdev) · 391 unmodified lines
392	return vsel;	392	return vsel;
393	}	393	}
394		394
395	static struct regulator_ops twl4030ldo_ops = {	395	static const struct regulator_ops twl4030ldo_ops = {
396	.list_voltage = twl4030ldo_list_voltage,	396	.list_voltage = twl4030ldo_list_voltage,
397		397
398	.set_voltage_sel = twl4030ldo_set_voltage_sel,	398	.set_voltage_sel = twl4030ldo_set_voltage_sel,
@@ -430,14 +430,14 @@ static int twl4030smps_get_voltage(struct regulator_dev *rdev) · 31 unmodified lines
430	return vsel * 12500 + 600000;	430	return vsel * 12500 + 600000;
431	}	431	}
432		432
433	static struct regulator_ops twl4030smps_ops = {	433	static const struct regulator_ops twl4030smps_ops = {
434	.set_voltage = twl4030smps_set_voltage,	434	.set_voltage = twl4030smps_set_voltage,
435	.get_voltage = twl4030smps_get_voltage,	435	.get_voltage = twl4030smps_get_voltage,
436	};	436	};
437		437
438	/----------------------------------------------------------------------/	438	/----------------------------------------------------------------------/
439		439
440	static struct regulator_ops twl4030fixed_ops = {	440	static const struct regulator_ops twl4030fixed_ops = {
441	.list_voltage = regulator_list_voltage_linear,	441	.list_voltage = regulator_list_voltage_linear,
442		442
443	.enable = twl4030reg_enable,	443	.enable = twl4030reg_enable,

drivers/regulator/vctrl-regulator.c+1−3

 		ctrl_uV = regulator_list_voltage(ctrl_reg, i);
 		if (ctrl_uV < vrange_ctrl->min_uV ||
-		    ctrl_uV > vrange_ctrl->max_uV) {
+		    ctrl_uV > vrange_ctrl->max_uV)
 			rdesc->n_voltages--;
-			continue;
-		}
 	}
 	if (rdesc->n_voltages == 0) {

drivers/regulator/vexpress-regulator.c+27−45

-/*
+// SPDX-License-Identifier: GPL-2.0
- * This program is free software; you can redistribute it and/or modify
+//
- * it under the terms of the GNU General Public License version 2 as
+// Copyright (C) 2012 ARM Limited
- * published by the Free Software Foundation.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * Copyright (C) 2012 ARM Limited
- */
 #define DRVNAME "vexpress-regulator"
 #define pr_fmt(fmt) DRVNAME ": " fmt
 #include <linux/regulator/of_regulator.h>
 #include <linux/vexpress.h>
-struct vexpress_regulator {
-	struct regulator_desc desc;
-	struct regulator_dev *regdev;
-	struct regmap *regmap;
-};
 static int vexpress_regulator_get_voltage(struct regulator_dev *regdev)
 {
-	struct vexpress_regulator *reg = rdev_get_drvdata(regdev);
+	unsigned int uV;
-	u32 uV;
+	int err = regmap_read(regdev->regmap, 0, &uV);
-	int err = regmap_read(reg->regmap, 0, &uV);
 	return err ? err : uV;
 }
 static int vexpress_regulator_set_voltage(struct regulator_dev *regdev,
 		int min_uV, int max_uV, unsigned *selector)
 {
-	struct vexpress_regulator *reg = rdev_get_drvdata(regdev);
+	return regmap_write(regdev->regmap, 0, min_uV);
-	return regmap_write(reg->regmap, 0, min_uV);
 }
-static struct regulator_ops vexpress_regulator_ops_ro = {
+static const struct regulator_ops vexpress_regulator_ops_ro = {
 	.get_voltage = vexpress_regulator_get_voltage,
 };
-static struct regulator_ops vexpress_regulator_ops = {
+static const struct regulator_ops vexpress_regulator_ops = {
 	.get_voltage = vexpress_regulator_get_voltage,
 	.set_voltage = vexpress_regulator_set_voltage,
 };
 static int vexpress_regulator_probe(struct platform_device *pdev)
 {
-	struct vexpress_regulator *reg;
+	struct regulator_desc *desc;
 	struct regulator_init_data *init_data;
 	struct regulator_config config = { };
+	struct regulator_dev *rdev;
+	struct regmap *regmap;
-	reg = devm_kzalloc(&pdev->dev, sizeof(*reg), GFP_KERNEL);
+	desc = devm_kzalloc(&pdev->dev, sizeof(*desc), GFP_KERNEL);
-	if (!reg)
+	if (!desc)
 		return -ENOMEM;
-	reg->regmap = devm_regmap_init_vexpress_config(&pdev->dev);
+	regmap = devm_regmap_init_vexpress_config(&pdev->dev);
-	if (IS_ERR(reg->regmap))
+	if (IS_ERR(regmap))
-		return PTR_ERR(reg->regmap);
+		return PTR_ERR(regmap);
-	reg->desc.name = dev_name(&pdev->dev);
+	desc->name = dev_name(&pdev->dev);
-	reg->desc.type = REGULATOR_VOLTAGE;
+	desc->type = REGULATOR_VOLTAGE;
-	reg->desc.owner = THIS_MODULE;
+	desc->owner = THIS_MODULE;
-	reg->desc.continuous_voltage_range = true;
+	desc->continuous_voltage_range = true;
 	init_data = of_get_regulator_init_data(&pdev->dev, pdev->dev.of_node,
-					       &reg->desc);
+					       desc);
 	if (!init_data)
 		return -EINVAL;
 	init_data->constraints.apply_uV = 0;
 	if (init_data->constraints.min_uV && init_data->constraints.max_uV)
-		reg->desc.ops = &vexpress_regulator_ops;
+		desc->ops = &vexpress_regulator_ops;
 	else
-		reg->desc.ops = &vexpress_regulator_ops_ro;
+		desc->ops = &vexpress_regulator_ops_ro;
+	config.regmap = regmap;
 	config.dev = &pdev->dev;
 	config.init_data = init_data;
-	config.driver_data = reg;
 	config.of_node = pdev->dev.of_node;
-	reg->regdev = devm_regulator_register(&pdev->dev, &reg->desc, &config);
+	rdev = devm_regulator_register(&pdev->dev, desc, &config);
-	if (IS_ERR(reg->regdev))
+	if (IS_ERR(rdev))
-		return PTR_ERR(reg->regdev);
+		return PTR_ERR(rdev);
-	platform_set_drvdata(pdev, reg);
 	return 0;
 }

drivers/regulator/wm831x-dcdc.c+11−12

-/*
+// SPDX-License-Identifier: GPL-2.0+
- * wm831x-dcdc.c  --  DC-DC buck convertor driver for the WM831x series
+//
- *
+// wm831x-dcdc.c  --  DC-DC buck converter driver for the WM831x series
- * Copyright 2009 Wolfson Microelectronics PLC.
+//
- *
+// Copyright 2009 Wolfson Microelectronics PLC.
- * Author: Mark Brown <broonie@opensource.wolfsonmicro.com>
+//
- *
+// Author: Mark Brown <broonie@opensource.wolfsonmicro.com>
- *  This program is free software; you can redistribute  it and/or modify it
- *  under  the terms of  the GNU General  Public License as published by the
- *  Free Software Foundation;  either version 2 of the  License, or (at your
- *  option) any later version.
- */
 #include <linux/module.h>
 #include <linux/moduleparam.h>
 {
 	struct wm831x_dcdc *dcdc = data;
+	regulator_lock(dcdc->regulator);
 	regulator_notifier_call_chain(dcdc->regulator,
 				      REGULATOR_EVENT_UNDER_VOLTAGE,
 				      NULL);
+	regulator_unlock(dcdc->regulator);
 	return IRQ_HANDLED;
 }
 {
 	struct wm831x_dcdc *dcdc = data;
+	regulator_lock(dcdc->regulator);
 	regulator_notifier_call_chain(dcdc->regulator,
 				      REGULATOR_EVENT_OVER_CURRENT,
 				      NULL);
+	regulator_unlock(dcdc->regulator);
 	return IRQ_HANDLED;
 }

drivers/regulator/wm831x-isink.c+16−50

-/*
+// SPDX-License-Identifier: GPL-2.0+
- * wm831x-isink.c  --  Current sink driver for the WM831x series
+//
- *
+// wm831x-isink.c  --  Current sink driver for the WM831x series
- * Copyright 2009 Wolfson Microelectronics PLC.
+//
- *
+// Copyright 2009 Wolfson Microelectronics PLC.
- * Author: Mark Brown <broonie@opensource.wolfsonmicro.com>
+//
- *
+// Author: Mark Brown <broonie@opensource.wolfsonmicro.com>
- *  This program is free software; you can redistribute  it and/or modify it
- *  under  the terms of  the GNU General  Public License as published by the
- *  Free Software Foundation;  either version 2 of the  License, or (at your
- *  option) any later version.
- */
 #include <linux/module.h>
 #include <linux/moduleparam.h>
 		return 0;
 }
-static int wm831x_isink_set_current(struct regulator_dev *rdev,
-				    int min_uA, int max_uA)
-{
-	struct wm831x_isink *isink = rdev_get_drvdata(rdev);
-	struct wm831x *wm831x = isink->wm831x;
-	int ret, i;
-	for (i = 0; i < ARRAY_SIZE(wm831x_isinkv_values); i++) {
-		int val = wm831x_isinkv_values[i];
-		if (min_uA <= val && val <= max_uA) {
-			ret = wm831x_set_bits(wm831x, isink->reg,
-					      WM831X_CS1_ISEL_MASK, i);
-			return ret;
-		}
-	}
-	return -EINVAL;
-}
-static int wm831x_isink_get_current(struct regulator_dev *rdev)
-{
-	struct wm831x_isink *isink = rdev_get_drvdata(rdev);
-	struct wm831x *wm831x = isink->wm831x;
-	int ret;
-	ret = wm831x_reg_read(wm831x, isink->reg);
-	if (ret < 0)
-		return ret;
-	ret &= WM831X_CS1_ISEL_MASK;
-	if (ret > WM831X_ISINK_MAX_ISEL)
-		ret = WM831X_ISINK_MAX_ISEL;
-	return wm831x_isinkv_values[ret];
-}
 static const struct regulator_ops wm831x_isink_ops = {
 	.is_enabled = wm831x_isink_is_enabled,
 	.enable = wm831x_isink_enable,
 	.disable = wm831x_isink_disable,
-	.set_current_limit = wm831x_isink_set_current,
+	.set_current_limit = regulator_set_current_limit_regmap,
-	.get_current_limit = wm831x_isink_get_current,
+	.get_current_limit = regulator_get_current_limit_regmap,
 };
 static irqreturn_t wm831x_isink_irq(int irq, void *data)
 {
 	struct wm831x_isink *isink = data;
+	regulator_lock(isink->regulator);
 	regulator_notifier_call_chain(isink->regulator,
 				      REGULATOR_EVENT_OVER_CURRENT,
 				      NULL);
+	regulator_unlock(isink->regulator);
 	return IRQ_HANDLED;
 }
 	isink->desc.ops = &wm831x_isink_ops;
 	isink->desc.type = REGULATOR_CURRENT;
 	isink->desc.owner = THIS_MODULE;
+	isink->desc.curr_table = wm831x_isinkv_values,
+	isink->desc.n_current_limits = ARRAY_SIZE(wm831x_isinkv_values),
+	isink->desc.csel_reg = isink->reg,
+	isink->desc.csel_mask = WM831X_CS1_ISEL_MASK,
 	config.dev = pdev->dev.parent;
 	config.init_data = pdata->isink[id];
 	config.driver_data = isink;
+	config.regmap = wm831x->regmap;
 	isink->regulator = devm_regulator_register(&pdev->dev, &isink->desc,
 						   &config);

drivers/regulator/wm831x-ldo.c+9−12

-/*
+// SPDX-License-Identifier: GPL-2.0+
- * wm831x-ldo.c  --  LDO driver for the WM831x series
+//
- *
+// wm831x-ldo.c  --  LDO driver for the WM831x series
- * Copyright 2009 Wolfson Microelectronics PLC.
+//
- *
+// Copyright 2009 Wolfson Microelectronics PLC.
- * Author: Mark Brown <broonie@opensource.wolfsonmicro.com>
+//
- *
+// Author: Mark Brown <broonie@opensource.wolfsonmicro.com>
- *  This program is free software; you can redistribute  it and/or modify it
- *  under  the terms of  the GNU General  Public License as published by the
- *  Free Software Foundation;  either version 2 of the  License, or (at your
- *  option) any later version.
- */
 #include <linux/module.h>
 #include <linux/moduleparam.h>
 {
 	struct wm831x_ldo *ldo = data;
+	regulator_lock(ldo->regulator);
 	regulator_notifier_call_chain(ldo->regulator,
 				      REGULATOR_EVENT_UNDER_VOLTAGE,
 				      NULL);
+	regulator_unlock(ldo->regulator);
 	return IRQ_HANDLED;
 }

drivers/regulator/wm8350-regulator.c+19−83

@@ -1,16 +1,11 @@
1	/*	1	// SPDX-License-Identifier: GPL-2.0+
2	* wm8350.c -- Voltage and current regulation for the Wolfson WM8350 PMIC	2	//
3	*	3	// wm8350.c -- Voltage and current regulation for the Wolfson WM8350 PMIC
4	* Copyright 2007, 2008 Wolfson Microelectronics PLC.	4	//
5	*	5	// Copyright 2007, 2008 Wolfson Microelectronics PLC.
6	* Author: Liam Girdwood	6	//
7	* linux@wolfsonmicro.com	7	// Author: Liam Girdwood
8	*	8	// linux@wolfsonmicro.com
9	* This program is free software; you can redistribute it and/or modify it
10	* under the terms of the GNU General Public License as published by the
11	* Free Software Foundation; either version 2 of the License, or (at your
12	* option) any later version.
13	*/
14		9
15	#include <linux/module.h>	10	#include <linux/module.h>
16	#include <linux/moduleparam.h>	11	#include <linux/moduleparam.h>
@@ -28,7 +23,7 @@ · 11 unmodified lines
28	#define WM8350_DCDC_MAX_VSEL 0x66	23	#define WM8350_DCDC_MAX_VSEL 0x66
29		24
30	/* Microamps */	25	/* Microamps */
31	static const int isink_cur[] = {	26	static const unsigned int isink_cur[] = {
32	4,	27	4,
33	5,	28	5,
34	6,	29	6,
@@ -95,73 +90,6 @@ static const int isink_cur[] = { · 60 unmodified lines
95	223191	90	223191
96	};	91	};
97		92
98	static int get_isink_val(int min_uA, int max_uA, u16 *setting)
99	{
100	int i;
101
102	for (i = 0; i < ARRAY_SIZE(isink_cur); i++) {
103	if (min_uA <= isink_cur[i] && max_uA >= isink_cur[i]) {
104	*setting = i;
105	return 0;
106	}
107	}
108	return -EINVAL;
109	}
110
111	static int wm8350_isink_set_current(struct regulator_dev *rdev, int min_uA,
112	int max_uA)
113	{
114	struct wm8350 *wm8350 = rdev_get_drvdata(rdev);
115	int isink = rdev_get_id(rdev);
116	u16 val, setting;
117	int ret;
118
119	ret = get_isink_val(min_uA, max_uA, &setting);
120	if (ret != 0)
121	return ret;
122
123	switch (isink) {
124	case WM8350_ISINK_A:
125	val = wm8350_reg_read(wm8350, WM8350_CURRENT_SINK_DRIVER_A) &
126	~WM8350_CS1_ISEL_MASK;
127	wm8350_reg_write(wm8350, WM8350_CURRENT_SINK_DRIVER_A,
128	val \| setting);
129	break;
130	case WM8350_ISINK_B:
131	val = wm8350_reg_read(wm8350, WM8350_CURRENT_SINK_DRIVER_B) &
132	~WM8350_CS1_ISEL_MASK;
133	wm8350_reg_write(wm8350, WM8350_CURRENT_SINK_DRIVER_B,
134	val \| setting);
135	break;
136	default:
137	return -EINVAL;
138	}
139
140	return 0;
141	}
142
143	static int wm8350_isink_get_current(struct regulator_dev *rdev)
144	{
145	struct wm8350 *wm8350 = rdev_get_drvdata(rdev);
146	int isink = rdev_get_id(rdev);
147	u16 val;
148
149	switch (isink) {
150	case WM8350_ISINK_A:
151	val = wm8350_reg_read(wm8350, WM8350_CURRENT_SINK_DRIVER_A) &
152	WM8350_CS1_ISEL_MASK;
153	break;
154	case WM8350_ISINK_B:
155	val = wm8350_reg_read(wm8350, WM8350_CURRENT_SINK_DRIVER_B) &
156	WM8350_CS1_ISEL_MASK;
157	break;
158	default:
159	return 0;
160	}
161
162	return isink_cur[val];
163	}
164
165	/* turn on ISINK followed by DCDC */	93	/* turn on ISINK followed by DCDC */
166	static int wm8350_isink_enable(struct regulator_dev *rdev)	94	static int wm8350_isink_enable(struct regulator_dev *rdev)
167	{	95	{
@@ -982,8 +910,8 @@ static const struct regulator_ops wm8350_ldo_ops = { · 814 unmodified lines
982	};	910	};
983		911
984	static const struct regulator_ops wm8350_isink_ops = {	912	static const struct regulator_ops wm8350_isink_ops = {
985	.set_current_limit = wm8350_isink_set_current,	913	.set_current_limit = regulator_set_current_limit_regmap,
986	.get_current_limit = wm8350_isink_get_current,	914	.get_current_limit = regulator_get_current_limit_regmap,
987	.enable = wm8350_isink_enable,	915	.enable = wm8350_isink_enable,
988	.disable = wm8350_isink_disable,	916	.disable = wm8350_isink_disable,
989	.is_enabled = wm8350_isink_is_enabled,	917	.is_enabled = wm8350_isink_is_enabled,
@@ -1138,6 +1066,10 @@ static const struct regulator_desc wm8350_reg[NUM_WM8350_REGULATORS] = { · 148 unmodified lines
1138	.irq = WM8350_IRQ_CS1,	1066	.irq = WM8350_IRQ_CS1,
1139	.type = REGULATOR_CURRENT,	1067	.type = REGULATOR_CURRENT,
1140	.owner = THIS_MODULE,	1068	.owner = THIS_MODULE,
		1069	.curr_table = isink_cur,
		1070	.n_current_limits = ARRAY_SIZE(isink_cur),
		1071	.csel_reg = WM8350_CURRENT_SINK_DRIVER_A,
		1072	.csel_mask = WM8350_CS1_ISEL_MASK,
1141	},	1073	},
1142	{	1074	{
1143	.name = "ISINKB",	1075	.name = "ISINKB",
@@ -1146,6 +1078,10 @@ static const struct regulator_desc wm8350_reg[NUM_WM8350_REGULATORS] = { · 2 unmodified lines
1146	.irq = WM8350_IRQ_CS2,	1078	.irq = WM8350_IRQ_CS2,
1147	.type = REGULATOR_CURRENT,	1079	.type = REGULATOR_CURRENT,
1148	.owner = THIS_MODULE,	1080	.owner = THIS_MODULE,
		1081	.curr_table = isink_cur,
		1082	.n_current_limits = ARRAY_SIZE(isink_cur),
		1083	.csel_reg = WM8350_CURRENT_SINK_DRIVER_B,
		1084	.csel_mask = WM8350_CS2_ISEL_MASK,
1149	},	1085	},
1150	};	1086	};
1151		1087

drivers/regulator/wm8400-regulator.c+16−23

-/*
+// SPDX-License-Identifier: GPL-2.0+
- * Regulator support for WM8400
+//
- *
+// Regulator support for WM8400
- * Copyright 2008 Wolfson Microelectronics PLC.
+//
- *
+// Copyright 2008 Wolfson Microelectronics PLC.
- * Author: Mark Brown <broonie@opensource.wolfsonmicro.com>
+//
- *
+// Author: Mark Brown <broonie@opensource.wolfsonmicro.com>
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU General Public License as
- * published by the Free Software Foundation; either version 2 of the
- * License, or (at your option) any later version.
- *
- */
 #include <linux/bug.h>
 #include <linux/err.h>
 static unsigned int wm8400_dcdc_get_mode(struct regulator_dev *dev)
 {
-	struct wm8400 *wm8400 = rdev_get_drvdata(dev);
+	struct regmap *rmap = rdev_get_regmap(dev);
 	int offset = (rdev_get_id(dev) - WM8400_DCDC1) * 2;
 	u16 data[2];
 	int ret;
-	ret = wm8400_block_read(wm8400, WM8400_DCDC1_CONTROL_1 + offset, 2,
+	ret = regmap_bulk_read(rmap, WM8400_DCDC1_CONTROL_1 + offset, data, 2);
-				data);
 	if (ret != 0)
 		return 0;
 static int wm8400_dcdc_set_mode(struct regulator_dev *dev, unsigned int mode)
 {
-	struct wm8400 *wm8400 = rdev_get_drvdata(dev);
+	struct regmap *rmap = rdev_get_regmap(dev);
 	int offset = (rdev_get_id(dev) - WM8400_DCDC1) * 2;
 	int ret;
 	switch (mode) {
 	case REGULATOR_MODE_FAST:
 		/* Datasheet: active with force PWM */
-		ret = wm8400_set_bits(wm8400, WM8400_DCDC1_CONTROL_2 + offset,
+		ret = regmap_update_bits(rmap, WM8400_DCDC1_CONTROL_2 + offset,
 				      WM8400_DC1_FRC_PWM, WM8400_DC1_FRC_PWM);
 		if (ret != 0)
 			return ret;
-		return wm8400_set_bits(wm8400, WM8400_DCDC1_CONTROL_1 + offset,
+		return regmap_update_bits(rmap, WM8400_DCDC1_CONTROL_1 + offset,
 				       WM8400_DC1_ACTIVE | WM8400_DC1_SLEEP,
 				       WM8400_DC1_ACTIVE);
 	case REGULATOR_MODE_NORMAL:
 		/* Datasheet: active */
-		ret = wm8400_set_bits(wm8400, WM8400_DCDC1_CONTROL_2 + offset,
+		ret = regmap_update_bits(rmap, WM8400_DCDC1_CONTROL_2 + offset,
 				      WM8400_DC1_FRC_PWM, 0);
 		if (ret != 0)
 			return ret;
-		return wm8400_set_bits(wm8400, WM8400_DCDC1_CONTROL_1 + offset,
+		return regmap_update_bits(rmap, WM8400_DCDC1_CONTROL_1 + offset,
 				       WM8400_DC1_ACTIVE | WM8400_DC1_SLEEP,
 				       WM8400_DC1_ACTIVE);
 	case REGULATOR_MODE_IDLE:
 		/* Datasheet: standby */
-		return wm8400_set_bits(wm8400, WM8400_DCDC1_CONTROL_1 + offset,
+		return regmap_update_bits(rmap, WM8400_DCDC1_CONTROL_1 + offset,
 				       WM8400_DC1_ACTIVE | WM8400_DC1_SLEEP, 0);
 	default:
 		return -EINVAL;
 		.id = WM8400_DCDC2,
 		.ops = &wm8400_dcdc_ops,
 		.enable_reg = WM8400_DCDC2_CONTROL_1,
-		.enable_mask = WM8400_DC1_ENA_MASK,
+		.enable_mask = WM8400_DC2_ENA_MASK,
 		.n_voltages = WM8400_DC2_VSEL_MASK + 1,
 		.vsel_reg = WM8400_DCDC2_CONTROL_1,
 		.vsel_mask = WM8400_DC2_VSEL_MASK,

drivers/regulator/wm8994-regulator.c+7−12

@@ -1,15 +1,10 @@
1	/*	1	// SPDX-License-Identifier: GPL-2.0+
2	* wm8994-regulator.c -- Regulator driver for the WM8994	2	//
3	*	3	// wm8994-regulator.c -- Regulator driver for the WM8994
4	* Copyright 2009 Wolfson Microelectronics PLC.	4	//
5	*	5	// Copyright 2009 Wolfson Microelectronics PLC.
6	* Author: Mark Brown <broonie@opensource.wolfsonmicro.com>	6	//
7	*	7	// Author: Mark Brown <broonie@opensource.wolfsonmicro.com>
8	* This program is free software; you can redistribute it and/or modify it
9	* under the terms of the GNU General Public License as published by the
10	* Free Software Foundation; either version 2 of the License, or (at your
11	* option) any later version.
12	*/
13		8
14	#include <linux/module.h>	9	#include <linux/module.h>
15	#include <linux/moduleparam.h>	10	#include <linux/moduleparam.h>

include/linux/mfd/palmas.h+0−1

@@ -553,7 +553,6 @@ struct palmas_pmic { · 552 unmodified lines
553	struct palmas *palmas;	553	struct palmas *palmas;
554	struct device *dev;	554	struct device *dev;
555	struct regulator_desc desc[PALMAS_NUM_REGS];	555	struct regulator_desc desc[PALMAS_NUM_REGS];
556	struct regulator_dev *rdev[PALMAS_NUM_REGS];
557	struct mutex mutex;	556	struct mutex mutex;
558		557
559	int smps123;	558	int smps123;

include/linux/mfd/wm831x/regulator.h+1−1

@@ -1213,6 +1213,6 @@ · 1212 unmodified lines
1213	#define WM831X_LDO1_OK_WIDTH 1 /* LDO1_OK */	1213	#define WM831X_LDO1_OK_WIDTH 1 /* LDO1_OK */
1214		1214
1215	#define WM831X_ISINK_MAX_ISEL 55	1215	#define WM831X_ISINK_MAX_ISEL 55
1216	extern int wm831x_isinkv_values[WM831X_ISINK_MAX_ISEL + 1];	1216	extern const unsigned int wm831x_isinkv_values[WM831X_ISINK_MAX_ISEL + 1];
1217		1217
1218	#endif	1218	#endif

include/linux/mfd/wm8400-private.h+0−8

@@ -923,12 +923,4 @@ struct wm8400 { · 922 unmodified lines
923	#define WM8400_LINE_CMP_VTHD_SHIFT 0 /* LINE_CMP_VTHD - [3:0] */	923	#define WM8400_LINE_CMP_VTHD_SHIFT 0 /* LINE_CMP_VTHD - [3:0] */
924	#define WM8400_LINE_CMP_VTHD_WIDTH 4 /* LINE_CMP_VTHD - [3:0] */	924	#define WM8400_LINE_CMP_VTHD_WIDTH 4 /* LINE_CMP_VTHD - [3:0] */
925		925
926	int wm8400_block_read(struct wm8400 wm8400, u8 reg, int count, u16 data);
927
928	static inline int wm8400_set_bits(struct wm8400 *wm8400, u8 reg,
929	u16 mask, u16 val)
930	{
931	return regmap_update_bits(wm8400->regmap, reg, mask, val);
932	}
933
934	#endif	926	#endif

include/linux/regulator/consumer.h+5−0

 	return 0;
 }
+static inline unsigned int regulator_get_linear_step(struct regulator *regulator)
+{
+	return 0;
+}
 static inline int regulator_set_current_limit(struct regulator *regulator,
 					     int min_uA, int max_uA)
 {

sound/soc/codecs/ab8500-codec.c+2−2

@@ -1062,10 +1062,10 @@ static void anc_iir(struct snd_soc_component *component, unsigned int bnk, · 1061 unmodified lines
1062	snd_soc_component_update_bits(component, AB8500_ANCCONF1,	1062	snd_soc_component_update_bits(component, AB8500_ANCCONF1,
1063	BIT(AB8500_ANCCONF1_ANCIIRINIT),	1063	BIT(AB8500_ANCCONF1_ANCIIRINIT),
1064	BIT(AB8500_ANCCONF1_ANCIIRINIT));	1064	BIT(AB8500_ANCCONF1_ANCIIRINIT));
1065	usleep_range(AB8500_ANC_SM_DELAY, AB8500_ANC_SM_DELAY);	1065	usleep_range(AB8500_ANC_SM_DELAY, AB8500_ANC_SM_DELAY*2);
1066	snd_soc_component_update_bits(component, AB8500_ANCCONF1,	1066	snd_soc_component_update_bits(component, AB8500_ANCCONF1,
1067	BIT(AB8500_ANCCONF1_ANCIIRINIT), 0);	1067	BIT(AB8500_ANCCONF1_ANCIIRINIT), 0);
1068	usleep_range(AB8500_ANC_SM_DELAY, AB8500_ANC_SM_DELAY);	1068	usleep_range(AB8500_ANC_SM_DELAY, AB8500_ANC_SM_DELAY*2);
1069	} else {	1069	} else {
1070	snd_soc_component_update_bits(component, AB8500_ANCCONF1,	1070	snd_soc_component_update_bits(component, AB8500_ANCCONF1,
1071	BIT(AB8500_ANCCONF1_ANCIIRUPDATE),	1071	BIT(AB8500_ANCCONF1_ANCIIRUPDATE),

Merge branch 'regulator-5.2' into regulator-next

Keyboard shortcuts

General

Issues and pull requests

Issues, pull requests and Inbox

Repository code