aboutsummaryrefslogtreecommitdiffstats
path: root/drivers/regulator
diff options
context:
space:
mode:
authorJiri Kosina <jkosina@suse.cz>2014-02-20 08:54:28 -0500
committerJiri Kosina <jkosina@suse.cz>2014-02-20 08:54:28 -0500
commitd4263348f796f29546f90802177865dd4379dd0a (patch)
treeadcbdaebae584eee2f32fab95e826e8e49eef385 /drivers/regulator
parentbe873ac782f5ff5ee6675f83929f4fe6737eead2 (diff)
parent6d0abeca3242a88cab8232e4acd7e2bf088f3bc2 (diff)
Merge branch 'master' into for-next
Diffstat (limited to 'drivers/regulator')
-rw-r--r--drivers/regulator/Kconfig19
-rw-r--r--drivers/regulator/Makefile2
-rw-r--r--drivers/regulator/ab3100.c4
-rw-r--r--drivers/regulator/ab8500.c126
-rw-r--r--drivers/regulator/act8865-regulator.c349
-rw-r--r--drivers/regulator/anatop-regulator.c36
-rw-r--r--drivers/regulator/arizona-micsupp.c52
-rw-r--r--drivers/regulator/as3722-regulator.c34
-rw-r--r--drivers/regulator/core.c24
-rw-r--r--drivers/regulator/da9055-regulator.c4
-rw-r--r--drivers/regulator/db8500-prcmu.c20
-rw-r--r--drivers/regulator/gpio-regulator.c17
-rw-r--r--drivers/regulator/lp3971.c43
-rw-r--r--drivers/regulator/lp3972.c41
-rw-r--r--drivers/regulator/max14577.c274
-rw-r--r--drivers/regulator/max77693.c1
-rw-r--r--drivers/regulator/mc13892-regulator.c24
-rw-r--r--drivers/regulator/pcf50633-regulator.c2
-rw-r--r--drivers/regulator/pfuze100-regulator.c41
-rw-r--r--drivers/regulator/s2mps11.c5
-rw-r--r--drivers/regulator/s5m8767.c99
-rw-r--r--drivers/regulator/stw481x-vmmc.c12
-rw-r--r--drivers/regulator/tps51632-regulator.c30
-rw-r--r--drivers/regulator/tps62360-regulator.c2
-rw-r--r--drivers/regulator/tps6586x-regulator.c93
-rw-r--r--drivers/regulator/tps65910-regulator.c40
-rw-r--r--drivers/regulator/twl-regulator.c4
-rw-r--r--drivers/regulator/wm831x-dcdc.c10
28 files changed, 967 insertions, 441 deletions
diff --git a/drivers/regulator/Kconfig b/drivers/regulator/Kconfig
index ce785f481281..6a7932822e37 100644
--- a/drivers/regulator/Kconfig
+++ b/drivers/regulator/Kconfig
@@ -70,6 +70,14 @@ config REGULATOR_88PM8607
70 help 70 help
71 This driver supports 88PM8607 voltage regulator chips. 71 This driver supports 88PM8607 voltage regulator chips.
72 72
73config REGULATOR_ACT8865
74 tristate "Active-semi act8865 voltage regulator"
75 depends on I2C
76 select REGMAP_I2C
77 help
78 This driver controls a active-semi act8865 voltage output
79 regulator via I2C bus.
80
73config REGULATOR_AD5398 81config REGULATOR_AD5398
74 tristate "Analog Devices AD5398/AD5821 regulators" 82 tristate "Analog Devices AD5398/AD5821 regulators"
75 depends on I2C 83 depends on I2C
@@ -249,6 +257,13 @@ config REGULATOR_LP8788
249 help 257 help
250 This driver supports LP8788 voltage regulator chip. 258 This driver supports LP8788 voltage regulator chip.
251 259
260config REGULATOR_MAX14577
261 tristate "Maxim 14577 regulator"
262 depends on MFD_MAX14577
263 help
264 This driver controls a Maxim 14577 regulator via I2C bus.
265 The regulators include safeout LDO and current regulator 'CHARGER'.
266
252config REGULATOR_MAX1586 267config REGULATOR_MAX1586
253 tristate "Maxim 1586/1587 voltage regulator" 268 tristate "Maxim 1586/1587 voltage regulator"
254 depends on I2C 269 depends on I2C
@@ -343,7 +358,7 @@ config REGULATOR_MC13XXX_CORE
343 358
344config REGULATOR_MC13783 359config REGULATOR_MC13783
345 tristate "Freescale MC13783 regulator driver" 360 tristate "Freescale MC13783 regulator driver"
346 depends on MFD_MC13783 361 depends on MFD_MC13XXX
347 select REGULATOR_MC13XXX_CORE 362 select REGULATOR_MC13XXX_CORE
348 help 363 help
349 Say y here to support the regulators found on the Freescale MC13783 364 Say y here to support the regulators found on the Freescale MC13783
@@ -384,7 +399,7 @@ config REGULATOR_PCF50633
384 on PCF50633 399 on PCF50633
385 400
386config REGULATOR_PFUZE100 401config REGULATOR_PFUZE100
387 tristate "Support regulators on Freescale PFUZE100 PMIC" 402 tristate "Freescale PFUZE100 regulator driver"
388 depends on I2C 403 depends on I2C
389 select REGMAP_I2C 404 select REGMAP_I2C
390 help 405 help
diff --git a/drivers/regulator/Makefile b/drivers/regulator/Makefile
index 01c597ea1744..979f9ddcf259 100644
--- a/drivers/regulator/Makefile
+++ b/drivers/regulator/Makefile
@@ -14,6 +14,7 @@ obj-$(CONFIG_REGULATOR_88PM8607) += 88pm8607.o
14obj-$(CONFIG_REGULATOR_AAT2870) += aat2870-regulator.o 14obj-$(CONFIG_REGULATOR_AAT2870) += aat2870-regulator.o
15obj-$(CONFIG_REGULATOR_AB3100) += ab3100.o 15obj-$(CONFIG_REGULATOR_AB3100) += ab3100.o
16obj-$(CONFIG_REGULATOR_AB8500) += ab8500-ext.o ab8500.o 16obj-$(CONFIG_REGULATOR_AB8500) += ab8500-ext.o ab8500.o
17obj-$(CONFIG_REGULATOR_ACT8865) += act8865-regulator.o
17obj-$(CONFIG_REGULATOR_AD5398) += ad5398.o 18obj-$(CONFIG_REGULATOR_AD5398) += ad5398.o
18obj-$(CONFIG_REGULATOR_ANATOP) += anatop-regulator.o 19obj-$(CONFIG_REGULATOR_ANATOP) += anatop-regulator.o
19obj-$(CONFIG_REGULATOR_ARIZONA) += arizona-micsupp.o arizona-ldo1.o 20obj-$(CONFIG_REGULATOR_ARIZONA) += arizona-micsupp.o arizona-ldo1.o
@@ -35,6 +36,7 @@ obj-$(CONFIG_REGULATOR_LP872X) += lp872x.o
35obj-$(CONFIG_REGULATOR_LP8788) += lp8788-buck.o 36obj-$(CONFIG_REGULATOR_LP8788) += lp8788-buck.o
36obj-$(CONFIG_REGULATOR_LP8788) += lp8788-ldo.o 37obj-$(CONFIG_REGULATOR_LP8788) += lp8788-ldo.o
37obj-$(CONFIG_REGULATOR_LP8755) += lp8755.o 38obj-$(CONFIG_REGULATOR_LP8755) += lp8755.o
39obj-$(CONFIG_REGULATOR_MAX14577) += max14577.o
38obj-$(CONFIG_REGULATOR_MAX1586) += max1586.o 40obj-$(CONFIG_REGULATOR_MAX1586) += max1586.o
39obj-$(CONFIG_REGULATOR_MAX8649) += max8649.o 41obj-$(CONFIG_REGULATOR_MAX8649) += max8649.o
40obj-$(CONFIG_REGULATOR_MAX8660) += max8660.o 42obj-$(CONFIG_REGULATOR_MAX8660) += max8660.o
diff --git a/drivers/regulator/ab3100.c b/drivers/regulator/ab3100.c
index 77b46d0b37a6..e10febe9ec34 100644
--- a/drivers/regulator/ab3100.c
+++ b/drivers/regulator/ab3100.c
@@ -498,7 +498,7 @@ static int ab3100_regulator_register(struct platform_device *pdev,
498 struct ab3100_platform_data *plfdata, 498 struct ab3100_platform_data *plfdata,
499 struct regulator_init_data *init_data, 499 struct regulator_init_data *init_data,
500 struct device_node *np, 500 struct device_node *np,
501 int id) 501 unsigned long id)
502{ 502{
503 struct regulator_desc *desc; 503 struct regulator_desc *desc;
504 struct ab3100_regulator *reg; 504 struct ab3100_regulator *reg;
@@ -646,7 +646,7 @@ ab3100_regulator_of_probe(struct platform_device *pdev, struct device_node *np)
646 err = ab3100_regulator_register( 646 err = ab3100_regulator_register(
647 pdev, NULL, ab3100_regulator_matches[i].init_data, 647 pdev, NULL, ab3100_regulator_matches[i].init_data,
648 ab3100_regulator_matches[i].of_node, 648 ab3100_regulator_matches[i].of_node,
649 (int) ab3100_regulator_matches[i].driver_data); 649 (unsigned long)ab3100_regulator_matches[i].driver_data);
650 if (err) { 650 if (err) {
651 ab3100_regulators_remove(pdev); 651 ab3100_regulators_remove(pdev);
652 return err; 652 return err;
diff --git a/drivers/regulator/ab8500.c b/drivers/regulator/ab8500.c
index 603f192e84f1..c625468c7f2c 100644
--- a/drivers/regulator/ab8500.c
+++ b/drivers/regulator/ab8500.c
@@ -2998,37 +2998,6 @@ static void abx500_get_regulator_info(struct ab8500 *ab8500)
2998 } 2998 }
2999} 2999}
3000 3000
3001static int ab8500_regulator_init_registers(struct platform_device *pdev,
3002 int id, int mask, int value)
3003{
3004 struct ab8500_reg_init *reg_init = abx500_regulator.init;
3005 int err;
3006
3007 BUG_ON(value & ~mask);
3008 BUG_ON(mask & ~reg_init[id].mask);
3009
3010 /* initialize register */
3011 err = abx500_mask_and_set_register_interruptible(
3012 &pdev->dev,
3013 reg_init[id].bank,
3014 reg_init[id].addr,
3015 mask, value);
3016 if (err < 0) {
3017 dev_err(&pdev->dev,
3018 "Failed to initialize 0x%02x, 0x%02x.\n",
3019 reg_init[id].bank,
3020 reg_init[id].addr);
3021 return err;
3022 }
3023 dev_vdbg(&pdev->dev,
3024 " init: 0x%02x, 0x%02x, 0x%02x, 0x%02x\n",
3025 reg_init[id].bank,
3026 reg_init[id].addr,
3027 mask, value);
3028
3029 return 0;
3030}
3031
3032static int ab8500_regulator_register(struct platform_device *pdev, 3001static int ab8500_regulator_register(struct platform_device *pdev,
3033 struct regulator_init_data *init_data, 3002 struct regulator_init_data *init_data,
3034 int id, struct device_node *np) 3003 int id, struct device_node *np)
@@ -3036,7 +3005,6 @@ static int ab8500_regulator_register(struct platform_device *pdev,
3036 struct ab8500 *ab8500 = dev_get_drvdata(pdev->dev.parent); 3005 struct ab8500 *ab8500 = dev_get_drvdata(pdev->dev.parent);
3037 struct ab8500_regulator_info *info = NULL; 3006 struct ab8500_regulator_info *info = NULL;
3038 struct regulator_config config = { }; 3007 struct regulator_config config = { };
3039 int err;
3040 3008
3041 /* assign per-regulator data */ 3009 /* assign per-regulator data */
3042 info = &abx500_regulator.info[id]; 3010 info = &abx500_regulator.info[id];
@@ -3058,17 +3026,12 @@ static int ab8500_regulator_register(struct platform_device *pdev,
3058 } 3026 }
3059 3027
3060 /* register regulator with framework */ 3028 /* register regulator with framework */
3061 info->regulator = regulator_register(&info->desc, &config); 3029 info->regulator = devm_regulator_register(&pdev->dev, &info->desc,
3030 &config);
3062 if (IS_ERR(info->regulator)) { 3031 if (IS_ERR(info->regulator)) {
3063 err = PTR_ERR(info->regulator);
3064 dev_err(&pdev->dev, "failed to register regulator %s\n", 3032 dev_err(&pdev->dev, "failed to register regulator %s\n",
3065 info->desc.name); 3033 info->desc.name);
3066 /* when we fail, un-register all earlier regulators */ 3034 return PTR_ERR(info->regulator);
3067 while (--id >= 0) {
3068 info = &abx500_regulator.info[id];
3069 regulator_unregister(info->regulator);
3070 }
3071 return err;
3072 } 3035 }
3073 3036
3074 return 0; 3037 return 0;
@@ -3095,9 +3058,7 @@ static int ab8500_regulator_probe(struct platform_device *pdev)
3095{ 3058{
3096 struct ab8500 *ab8500 = dev_get_drvdata(pdev->dev.parent); 3059 struct ab8500 *ab8500 = dev_get_drvdata(pdev->dev.parent);
3097 struct device_node *np = pdev->dev.of_node; 3060 struct device_node *np = pdev->dev.of_node;
3098 struct ab8500_platform_data *ppdata; 3061 int err;
3099 struct ab8500_regulator_platform_data *pdata;
3100 int i, err;
3101 3062
3102 if (!ab8500) { 3063 if (!ab8500) {
3103 dev_err(&pdev->dev, "null mfd parent\n"); 3064 dev_err(&pdev->dev, "null mfd parent\n");
@@ -3106,83 +3067,20 @@ static int ab8500_regulator_probe(struct platform_device *pdev)
3106 3067
3107 abx500_get_regulator_info(ab8500); 3068 abx500_get_regulator_info(ab8500);
3108 3069
3109 if (np) { 3070 err = of_regulator_match(&pdev->dev, np,
3110 err = of_regulator_match(&pdev->dev, np, 3071 abx500_regulator.match,
3111 abx500_regulator.match, 3072 abx500_regulator.match_size);
3112 abx500_regulator.match_size); 3073 if (err < 0) {
3113 if (err < 0) { 3074 dev_err(&pdev->dev,
3114 dev_err(&pdev->dev, 3075 "Error parsing regulator init data: %d\n", err);
3115 "Error parsing regulator init data: %d\n", err);
3116 return err;
3117 }
3118
3119 err = ab8500_regulator_of_probe(pdev, np);
3120 return err;
3121 }
3122
3123 ppdata = dev_get_platdata(ab8500->dev);
3124 if (!ppdata) {
3125 dev_err(&pdev->dev, "null parent pdata\n");
3126 return -EINVAL;
3127 }
3128
3129 pdata = ppdata->regulator;
3130 if (!pdata) {
3131 dev_err(&pdev->dev, "null pdata\n");
3132 return -EINVAL;
3133 }
3134
3135 /* make sure the platform data has the correct size */
3136 if (pdata->num_regulator != abx500_regulator.info_size) {
3137 dev_err(&pdev->dev, "Configuration error: size mismatch.\n");
3138 return -EINVAL;
3139 }
3140
3141 /* initialize debug (initial state is recorded with this call) */
3142 err = ab8500_regulator_debug_init(pdev);
3143 if (err)
3144 return err; 3076 return err;
3145
3146 /* initialize registers */
3147 for (i = 0; i < pdata->num_reg_init; i++) {
3148 int id, mask, value;
3149
3150 id = pdata->reg_init[i].id;
3151 mask = pdata->reg_init[i].mask;
3152 value = pdata->reg_init[i].value;
3153
3154 /* check for configuration errors */
3155 BUG_ON(id >= abx500_regulator.init_size);
3156
3157 err = ab8500_regulator_init_registers(pdev, id, mask, value);
3158 if (err < 0)
3159 return err;
3160 } 3077 }
3161 3078 return ab8500_regulator_of_probe(pdev, np);
3162 /* register all regulators */
3163 for (i = 0; i < abx500_regulator.info_size; i++) {
3164 err = ab8500_regulator_register(pdev, &pdata->regulator[i],
3165 i, NULL);
3166 if (err < 0)
3167 return err;
3168 }
3169
3170 return 0;
3171} 3079}
3172 3080
3173static int ab8500_regulator_remove(struct platform_device *pdev) 3081static int ab8500_regulator_remove(struct platform_device *pdev)
3174{ 3082{
3175 int i, err; 3083 int err;
3176
3177 for (i = 0; i < abx500_regulator.info_size; i++) {
3178 struct ab8500_regulator_info *info = NULL;
3179 info = &abx500_regulator.info[i];
3180
3181 dev_vdbg(rdev_get_dev(info->regulator),
3182 "%s-remove\n", info->desc.name);
3183
3184 regulator_unregister(info->regulator);
3185 }
3186 3084
3187 /* remove regulator debug */ 3085 /* remove regulator debug */
3188 err = ab8500_regulator_debug_exit(pdev); 3086 err = ab8500_regulator_debug_exit(pdev);
diff --git a/drivers/regulator/act8865-regulator.c b/drivers/regulator/act8865-regulator.c
new file mode 100644
index 000000000000..084cc0819a52
--- /dev/null
+++ b/drivers/regulator/act8865-regulator.c
@@ -0,0 +1,349 @@
1/*
2 * act8865-regulator.c - Voltage regulation for the active-semi ACT8865
3 * http://www.active-semi.com/sheets/ACT8865_Datasheet.pdf
4 *
5 * Copyright (C) 2013 Atmel Corporation
6 *
7 * This program is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License as published by
9 * the Free Software Foundation; either version 2 of the License, or
10 * (at your option) any later version.
11 *
12 * This program is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 * GNU General Public License for more details.
16 */
17
18#include <linux/module.h>
19#include <linux/init.h>
20#include <linux/i2c.h>
21#include <linux/err.h>
22#include <linux/platform_device.h>
23#include <linux/regulator/driver.h>
24#include <linux/regulator/act8865.h>
25#include <linux/of.h>
26#include <linux/of_device.h>
27#include <linux/regulator/of_regulator.h>
28#include <linux/regmap.h>
29
30/*
31 * ACT8865 Global Register Map.
32 */
33#define ACT8865_SYS_MODE 0x00
34#define ACT8865_SYS_CTRL 0x01
35#define ACT8865_DCDC1_VSET1 0x20
36#define ACT8865_DCDC1_VSET2 0x21
37#define ACT8865_DCDC1_CTRL 0x22
38#define ACT8865_DCDC2_VSET1 0x30
39#define ACT8865_DCDC2_VSET2 0x31
40#define ACT8865_DCDC2_CTRL 0x32
41#define ACT8865_DCDC3_VSET1 0x40
42#define ACT8865_DCDC3_VSET2 0x41
43#define ACT8865_DCDC3_CTRL 0x42
44#define ACT8865_LDO1_VSET 0x50
45#define ACT8865_LDO1_CTRL 0x51
46#define ACT8865_LDO2_VSET 0x54
47#define ACT8865_LDO2_CTRL 0x55
48#define ACT8865_LDO3_VSET 0x60
49#define ACT8865_LDO3_CTRL 0x61
50#define ACT8865_LDO4_VSET 0x64
51#define ACT8865_LDO4_CTRL 0x65
52
53/*
54 * Field Definitions.
55 */
56#define ACT8865_ENA 0x80 /* ON - [7] */
57#define ACT8865_VSEL_MASK 0x3F /* VSET - [5:0] */
58
59/*
60 * ACT8865 voltage number
61 */
62#define ACT8865_VOLTAGE_NUM 64
63
64struct act8865 {
65 struct regulator_dev *rdev[ACT8865_REG_NUM];
66 struct regmap *regmap;
67};
68
69static const struct regmap_config act8865_regmap_config = {
70 .reg_bits = 8,
71 .val_bits = 8,
72};
73
74static const struct regulator_linear_range act8865_volatge_ranges[] = {
75 REGULATOR_LINEAR_RANGE(600000, 0, 23, 25000),
76 REGULATOR_LINEAR_RANGE(1200000, 24, 47, 50000),
77 REGULATOR_LINEAR_RANGE(2400000, 48, 63, 100000),
78};
79
80static struct regulator_ops act8865_ops = {
81 .list_voltage = regulator_list_voltage_linear_range,
82 .map_voltage = regulator_map_voltage_linear_range,
83 .get_voltage_sel = regulator_get_voltage_sel_regmap,
84 .set_voltage_sel = regulator_set_voltage_sel_regmap,
85 .enable = regulator_enable_regmap,
86 .disable = regulator_disable_regmap,
87 .is_enabled = regulator_is_enabled_regmap,
88};
89
90static const struct regulator_desc act8865_reg[] = {
91 {
92 .name = "DCDC_REG1",
93 .id = ACT8865_ID_DCDC1,
94 .ops = &act8865_ops,
95 .type = REGULATOR_VOLTAGE,
96 .n_voltages = ACT8865_VOLTAGE_NUM,
97 .linear_ranges = act8865_volatge_ranges,
98 .n_linear_ranges = ARRAY_SIZE(act8865_volatge_ranges),
99 .vsel_reg = ACT8865_DCDC1_VSET1,
100 .vsel_mask = ACT8865_VSEL_MASK,
101 .enable_reg = ACT8865_DCDC1_CTRL,
102 .enable_mask = ACT8865_ENA,
103 .owner = THIS_MODULE,
104 },
105 {
106 .name = "DCDC_REG2",
107 .id = ACT8865_ID_DCDC2,
108 .ops = &act8865_ops,
109 .type = REGULATOR_VOLTAGE,
110 .n_voltages = ACT8865_VOLTAGE_NUM,
111 .linear_ranges = act8865_volatge_ranges,
112 .n_linear_ranges = ARRAY_SIZE(act8865_volatge_ranges),
113 .vsel_reg = ACT8865_DCDC2_VSET1,
114 .vsel_mask = ACT8865_VSEL_MASK,
115 .enable_reg = ACT8865_DCDC2_CTRL,
116 .enable_mask = ACT8865_ENA,
117 .owner = THIS_MODULE,
118 },
119 {
120 .name = "DCDC_REG3",
121 .id = ACT8865_ID_DCDC3,
122 .ops = &act8865_ops,
123 .type = REGULATOR_VOLTAGE,
124 .n_voltages = ACT8865_VOLTAGE_NUM,
125 .linear_ranges = act8865_volatge_ranges,
126 .n_linear_ranges = ARRAY_SIZE(act8865_volatge_ranges),
127 .vsel_reg = ACT8865_DCDC3_VSET1,
128 .vsel_mask = ACT8865_VSEL_MASK,
129 .enable_reg = ACT8865_DCDC3_CTRL,
130 .enable_mask = ACT8865_ENA,
131 .owner = THIS_MODULE,
132 },
133 {
134 .name = "LDO_REG1",
135 .id = ACT8865_ID_LDO1,
136 .ops = &act8865_ops,
137 .type = REGULATOR_VOLTAGE,
138 .n_voltages = ACT8865_VOLTAGE_NUM,
139 .linear_ranges = act8865_volatge_ranges,
140 .n_linear_ranges = ARRAY_SIZE(act8865_volatge_ranges),
141 .vsel_reg = ACT8865_LDO1_VSET,
142 .vsel_mask = ACT8865_VSEL_MASK,
143 .enable_reg = ACT8865_LDO1_CTRL,
144 .enable_mask = ACT8865_ENA,
145 .owner = THIS_MODULE,
146 },
147 {
148 .name = "LDO_REG2",
149 .id = ACT8865_ID_LDO2,
150 .ops = &act8865_ops,
151 .type = REGULATOR_VOLTAGE,
152 .n_voltages = ACT8865_VOLTAGE_NUM,
153 .linear_ranges = act8865_volatge_ranges,
154 .n_linear_ranges = ARRAY_SIZE(act8865_volatge_ranges),
155 .vsel_reg = ACT8865_LDO2_VSET,
156 .vsel_mask = ACT8865_VSEL_MASK,
157 .enable_reg = ACT8865_LDO2_CTRL,
158 .enable_mask = ACT8865_ENA,
159 .owner = THIS_MODULE,
160 },
161 {
162 .name = "LDO_REG3",
163 .id = ACT8865_ID_LDO3,
164 .ops = &act8865_ops,
165 .type = REGULATOR_VOLTAGE,
166 .n_voltages = ACT8865_VOLTAGE_NUM,
167 .linear_ranges = act8865_volatge_ranges,
168 .n_linear_ranges = ARRAY_SIZE(act8865_volatge_ranges),
169 .vsel_reg = ACT8865_LDO3_VSET,
170 .vsel_mask = ACT8865_VSEL_MASK,
171 .enable_reg = ACT8865_LDO3_CTRL,
172 .enable_mask = ACT8865_ENA,
173 .owner = THIS_MODULE,
174 },
175 {
176 .name = "LDO_REG4",
177 .id = ACT8865_ID_LDO4,
178 .ops = &act8865_ops,
179 .type = REGULATOR_VOLTAGE,
180 .n_voltages = ACT8865_VOLTAGE_NUM,
181 .linear_ranges = act8865_volatge_ranges,
182 .n_linear_ranges = ARRAY_SIZE(act8865_volatge_ranges),
183 .vsel_reg = ACT8865_LDO4_VSET,
184 .vsel_mask = ACT8865_VSEL_MASK,
185 .enable_reg = ACT8865_LDO4_CTRL,
186 .enable_mask = ACT8865_ENA,
187 .owner = THIS_MODULE,
188 },
189};
190
191#ifdef CONFIG_OF
192static const struct of_device_id act8865_dt_ids[] = {
193 { .compatible = "active-semi,act8865" },
194 { }
195};
196MODULE_DEVICE_TABLE(of, act8865_dt_ids);
197
198static struct of_regulator_match act8865_matches[] = {
199 [ACT8865_ID_DCDC1] = { .name = "DCDC_REG1"},
200 [ACT8865_ID_DCDC2] = { .name = "DCDC_REG2"},
201 [ACT8865_ID_DCDC3] = { .name = "DCDC_REG3"},
202 [ACT8865_ID_LDO1] = { .name = "LDO_REG1"},
203 [ACT8865_ID_LDO2] = { .name = "LDO_REG2"},
204 [ACT8865_ID_LDO3] = { .name = "LDO_REG3"},
205 [ACT8865_ID_LDO4] = { .name = "LDO_REG4"},
206};
207
208static int act8865_pdata_from_dt(struct device *dev,
209 struct device_node **of_node,
210 struct act8865_platform_data *pdata)
211{
212 int matched, i;
213 struct device_node *np;
214 struct act8865_regulator_data *regulator;
215
216 np = of_find_node_by_name(dev->of_node, "regulators");
217 if (!np) {
218 dev_err(dev, "missing 'regulators' subnode in DT\n");
219 return -EINVAL;
220 }
221
222 matched = of_regulator_match(dev, np,
223 act8865_matches, ARRAY_SIZE(act8865_matches));
224 if (matched <= 0)
225 return matched;
226
227 pdata->regulators = devm_kzalloc(dev,
228 sizeof(struct act8865_regulator_data) *
229 ARRAY_SIZE(act8865_matches), GFP_KERNEL);
230 if (!pdata->regulators) {
231 dev_err(dev, "%s: failed to allocate act8865 registor\n",
232 __func__);
233 return -ENOMEM;
234 }
235
236 pdata->num_regulators = matched;
237 regulator = pdata->regulators;
238
239 for (i = 0; i < ARRAY_SIZE(act8865_matches); i++) {
240 regulator->id = i;
241 regulator->name = act8865_matches[i].name;
242 regulator->platform_data = act8865_matches[i].init_data;
243 of_node[i] = act8865_matches[i].of_node;
244 regulator++;
245 }
246
247 return 0;
248}
249#else
250static inline int act8865_pdata_from_dt(struct device *dev,
251 struct device_node **of_node,
252 struct act8865_platform_data *pdata)
253{
254 return 0;
255}
256#endif
257
258static int act8865_pmic_probe(struct i2c_client *client,
259 const struct i2c_device_id *i2c_id)
260{
261 struct regulator_dev **rdev;
262 struct device *dev = &client->dev;
263 struct act8865_platform_data *pdata = dev_get_platdata(dev);
264 struct regulator_config config = { };
265 struct act8865 *act8865;
266 struct device_node *of_node[ACT8865_REG_NUM];
267 int i, id;
268 int ret = -EINVAL;
269 int error;
270
271 if (dev->of_node && !pdata) {
272 const struct of_device_id *id;
273 struct act8865_platform_data pdata_of;
274
275 id = of_match_device(of_match_ptr(act8865_dt_ids), dev);
276 if (!id)
277 return -ENODEV;
278
279 ret = act8865_pdata_from_dt(dev, of_node, &pdata_of);
280 if (ret < 0)
281 return ret;
282
283 pdata = &pdata_of;
284 }
285
286 if (pdata->num_regulators > ACT8865_REG_NUM) {
287 dev_err(dev, "Too many regulators found!\n");
288 return -EINVAL;
289 }
290
291 act8865 = devm_kzalloc(dev, sizeof(struct act8865), GFP_KERNEL);
292 if (!act8865)
293 return -ENOMEM;
294
295 rdev = act8865->rdev;
296
297 act8865->regmap = devm_regmap_init_i2c(client, &act8865_regmap_config);
298 if (IS_ERR(act8865->regmap)) {
299 error = PTR_ERR(act8865->regmap);
300 dev_err(&client->dev, "Failed to allocate register map: %d\n",
301 error);
302 return error;
303 }
304
305 /* Finally register devices */
306 for (i = 0; i < ACT8865_REG_NUM; i++) {
307
308 id = pdata->regulators[i].id;
309
310 config.dev = dev;
311 config.init_data = pdata->regulators[i].platform_data;
312 config.of_node = of_node[i];
313 config.driver_data = act8865;
314 config.regmap = act8865->regmap;
315
316 rdev[i] = devm_regulator_register(&client->dev,
317 &act8865_reg[i], &config);
318 if (IS_ERR(rdev[i])) {
319 dev_err(dev, "failed to register %s\n",
320 act8865_reg[id].name);
321 return PTR_ERR(rdev[i]);
322 }
323 }
324
325 i2c_set_clientdata(client, act8865);
326
327 return 0;
328}
329
330static const struct i2c_device_id act8865_ids[] = {
331 { "act8865", 0 },
332 { },
333};
334MODULE_DEVICE_TABLE(i2c, act8865_ids);
335
336static struct i2c_driver act8865_pmic_driver = {
337 .driver = {
338 .name = "act8865",
339 .owner = THIS_MODULE,
340 },
341 .probe = act8865_pmic_probe,
342 .id_table = act8865_ids,
343};
344
345module_i2c_driver(act8865_pmic_driver);
346
347MODULE_DESCRIPTION("active-semi act8865 voltage regulator driver");
348MODULE_AUTHOR("Wenyou Yang <wenyou.yang@atmel.com>");
349MODULE_LICENSE("GPL v2");
diff --git a/drivers/regulator/anatop-regulator.c b/drivers/regulator/anatop-regulator.c
index c734d0980826..862e63e451d0 100644
--- a/drivers/regulator/anatop-regulator.c
+++ b/drivers/regulator/anatop-regulator.c
@@ -122,10 +122,8 @@ static int anatop_regulator_probe(struct platform_device *pdev)
122 if (!sreg) 122 if (!sreg)
123 return -ENOMEM; 123 return -ENOMEM;
124 sreg->initdata = initdata; 124 sreg->initdata = initdata;
125 sreg->name = kstrdup(of_get_property(np, "regulator-name", NULL), 125 sreg->name = of_get_property(np, "regulator-name", NULL);
126 GFP_KERNEL);
127 rdesc = &sreg->rdesc; 126 rdesc = &sreg->rdesc;
128 memset(rdesc, 0, sizeof(*rdesc));
129 rdesc->name = sreg->name; 127 rdesc->name = sreg->name;
130 rdesc->ops = &anatop_rops; 128 rdesc->ops = &anatop_rops;
131 rdesc->type = REGULATOR_VOLTAGE; 129 rdesc->type = REGULATOR_VOLTAGE;
@@ -143,37 +141,37 @@ static int anatop_regulator_probe(struct platform_device *pdev)
143 &sreg->control_reg); 141 &sreg->control_reg);
144 if (ret) { 142 if (ret) {
145 dev_err(dev, "no anatop-reg-offset property set\n"); 143 dev_err(dev, "no anatop-reg-offset property set\n");
146 goto anatop_probe_end; 144 return ret;
147 } 145 }
148 ret = of_property_read_u32(np, "anatop-vol-bit-width", 146 ret = of_property_read_u32(np, "anatop-vol-bit-width",
149 &sreg->vol_bit_width); 147 &sreg->vol_bit_width);
150 if (ret) { 148 if (ret) {
151 dev_err(dev, "no anatop-vol-bit-width property set\n"); 149 dev_err(dev, "no anatop-vol-bit-width property set\n");
152 goto anatop_probe_end; 150 return ret;
153 } 151 }
154 ret = of_property_read_u32(np, "anatop-vol-bit-shift", 152 ret = of_property_read_u32(np, "anatop-vol-bit-shift",
155 &sreg->vol_bit_shift); 153 &sreg->vol_bit_shift);
156 if (ret) { 154 if (ret) {
157 dev_err(dev, "no anatop-vol-bit-shift property set\n"); 155 dev_err(dev, "no anatop-vol-bit-shift property set\n");
158 goto anatop_probe_end; 156 return ret;
159 } 157 }
160 ret = of_property_read_u32(np, "anatop-min-bit-val", 158 ret = of_property_read_u32(np, "anatop-min-bit-val",
161 &sreg->min_bit_val); 159 &sreg->min_bit_val);
162 if (ret) { 160 if (ret) {
163 dev_err(dev, "no anatop-min-bit-val property set\n"); 161 dev_err(dev, "no anatop-min-bit-val property set\n");
164 goto anatop_probe_end; 162 return ret;
165 } 163 }
166 ret = of_property_read_u32(np, "anatop-min-voltage", 164 ret = of_property_read_u32(np, "anatop-min-voltage",
167 &sreg->min_voltage); 165 &sreg->min_voltage);
168 if (ret) { 166 if (ret) {
169 dev_err(dev, "no anatop-min-voltage property set\n"); 167 dev_err(dev, "no anatop-min-voltage property set\n");
170 goto anatop_probe_end; 168 return ret;
171 } 169 }
172 ret = of_property_read_u32(np, "anatop-max-voltage", 170 ret = of_property_read_u32(np, "anatop-max-voltage",
173 &sreg->max_voltage); 171 &sreg->max_voltage);
174 if (ret) { 172 if (ret) {
175 dev_err(dev, "no anatop-max-voltage property set\n"); 173 dev_err(dev, "no anatop-max-voltage property set\n");
176 goto anatop_probe_end; 174 return ret;
177 } 175 }
178 176
179 /* read LDO ramp up setting, only for core reg */ 177 /* read LDO ramp up setting, only for core reg */
@@ -204,27 +202,11 @@ static int anatop_regulator_probe(struct platform_device *pdev)
204 if (IS_ERR(rdev)) { 202 if (IS_ERR(rdev)) {
205 dev_err(dev, "failed to register %s\n", 203 dev_err(dev, "failed to register %s\n",
206 rdesc->name); 204 rdesc->name);
207 ret = PTR_ERR(rdev); 205 return PTR_ERR(rdev);
208 goto anatop_probe_end;
209 } 206 }
210 207
211 platform_set_drvdata(pdev, rdev); 208 platform_set_drvdata(pdev, rdev);
212 209
213anatop_probe_end:
214 if (ret)
215 kfree(sreg->name);
216
217 return ret;
218}
219
220static int anatop_regulator_remove(struct platform_device *pdev)
221{
222 struct regulator_dev *rdev = platform_get_drvdata(pdev);
223 struct anatop_regulator *sreg = rdev_get_drvdata(rdev);
224 const char *name = sreg->name;
225
226 kfree(name);
227
228 return 0; 210 return 0;
229} 211}
230 212
@@ -240,7 +222,6 @@ static struct platform_driver anatop_regulator_driver = {
240 .of_match_table = of_anatop_regulator_match_tbl, 222 .of_match_table = of_anatop_regulator_match_tbl,
241 }, 223 },
242 .probe = anatop_regulator_probe, 224 .probe = anatop_regulator_probe,
243 .remove = anatop_regulator_remove,
244}; 225};
245 226
246static int __init anatop_regulator_init(void) 227static int __init anatop_regulator_init(void)
@@ -259,3 +240,4 @@ MODULE_AUTHOR("Nancy Chen <Nancy.Chen@freescale.com>");
259MODULE_AUTHOR("Ying-Chun Liu (PaulLiu) <paul.liu@linaro.org>"); 240MODULE_AUTHOR("Ying-Chun Liu (PaulLiu) <paul.liu@linaro.org>");
260MODULE_DESCRIPTION("ANATOP Regulator driver"); 241MODULE_DESCRIPTION("ANATOP Regulator driver");
261MODULE_LICENSE("GPL v2"); 242MODULE_LICENSE("GPL v2");
243MODULE_ALIAS("platform:anatop_regulator");
diff --git a/drivers/regulator/arizona-micsupp.c b/drivers/regulator/arizona-micsupp.c
index fd3154d86901..034ece707083 100644
--- a/drivers/regulator/arizona-micsupp.c
+++ b/drivers/regulator/arizona-micsupp.c
@@ -28,8 +28,6 @@
28#include <linux/mfd/arizona/pdata.h> 28#include <linux/mfd/arizona/pdata.h>
29#include <linux/mfd/arizona/registers.h> 29#include <linux/mfd/arizona/registers.h>
30 30
31#define ARIZONA_MICSUPP_MAX_SELECTOR 0x1f
32
33struct arizona_micsupp { 31struct arizona_micsupp {
34 struct regulator_dev *regulator; 32 struct regulator_dev *regulator;
35 struct arizona *arizona; 33 struct arizona *arizona;
@@ -40,42 +38,6 @@ struct arizona_micsupp {
40 struct work_struct check_cp_work; 38 struct work_struct check_cp_work;
41}; 39};
42 40
43static int arizona_micsupp_list_voltage(struct regulator_dev *rdev,
44 unsigned int selector)
45{
46 if (selector > ARIZONA_MICSUPP_MAX_SELECTOR)
47 return -EINVAL;
48
49 if (selector == ARIZONA_MICSUPP_MAX_SELECTOR)
50 return 3300000;
51 else
52 return (selector * 50000) + 1700000;
53}
54
55static int arizona_micsupp_map_voltage(struct regulator_dev *rdev,
56 int min_uV, int max_uV)
57{
58 unsigned int voltage;
59 int selector;
60
61 if (min_uV < 1700000)
62 min_uV = 1700000;
63
64 if (min_uV > 3200000)
65 selector = ARIZONA_MICSUPP_MAX_SELECTOR;
66 else
67 selector = DIV_ROUND_UP(min_uV - 1700000, 50000);
68
69 if (selector < 0)
70 return -EINVAL;
71
72 voltage = arizona_micsupp_list_voltage(rdev, selector);
73 if (voltage < min_uV || voltage > max_uV)
74 return -EINVAL;
75
76 return selector;
77}
78
79static void arizona_micsupp_check_cp(struct work_struct *work) 41static void arizona_micsupp_check_cp(struct work_struct *work)
80{ 42{
81 struct arizona_micsupp *micsupp = 43 struct arizona_micsupp *micsupp =
@@ -145,8 +107,8 @@ static struct regulator_ops arizona_micsupp_ops = {
145 .disable = arizona_micsupp_disable, 107 .disable = arizona_micsupp_disable,
146 .is_enabled = regulator_is_enabled_regmap, 108 .is_enabled = regulator_is_enabled_regmap,
147 109
148 .list_voltage = arizona_micsupp_list_voltage, 110 .list_voltage = regulator_list_voltage_linear_range,
149 .map_voltage = arizona_micsupp_map_voltage, 111 .map_voltage = regulator_map_voltage_linear_range,
150 112
151 .get_voltage_sel = regulator_get_voltage_sel_regmap, 113 .get_voltage_sel = regulator_get_voltage_sel_regmap,
152 .set_voltage_sel = regulator_set_voltage_sel_regmap, 114 .set_voltage_sel = regulator_set_voltage_sel_regmap,
@@ -155,11 +117,16 @@ static struct regulator_ops arizona_micsupp_ops = {
155 .set_bypass = arizona_micsupp_set_bypass, 117 .set_bypass = arizona_micsupp_set_bypass,
156}; 118};
157 119
120static const struct regulator_linear_range arizona_micsupp_ranges[] = {
121 REGULATOR_LINEAR_RANGE(1700000, 0, 0x1e, 50000),
122 REGULATOR_LINEAR_RANGE(3300000, 0x1f, 0x1f, 0),
123};
124
158static const struct regulator_desc arizona_micsupp = { 125static const struct regulator_desc arizona_micsupp = {
159 .name = "MICVDD", 126 .name = "MICVDD",
160 .supply_name = "CPVDD", 127 .supply_name = "CPVDD",
161 .type = REGULATOR_VOLTAGE, 128 .type = REGULATOR_VOLTAGE,
162 .n_voltages = ARIZONA_MICSUPP_MAX_SELECTOR + 1, 129 .n_voltages = 32,
163 .ops = &arizona_micsupp_ops, 130 .ops = &arizona_micsupp_ops,
164 131
165 .vsel_reg = ARIZONA_LDO2_CONTROL_1, 132 .vsel_reg = ARIZONA_LDO2_CONTROL_1,
@@ -169,6 +136,9 @@ static const struct regulator_desc arizona_micsupp = {
169 .bypass_reg = ARIZONA_MIC_CHARGE_PUMP_1, 136 .bypass_reg = ARIZONA_MIC_CHARGE_PUMP_1,
170 .bypass_mask = ARIZONA_CPMIC_BYPASS, 137 .bypass_mask = ARIZONA_CPMIC_BYPASS,
171 138
139 .linear_ranges = arizona_micsupp_ranges,
140 .n_linear_ranges = ARRAY_SIZE(arizona_micsupp_ranges),
141
172 .enable_time = 3000, 142 .enable_time = 3000,
173 143
174 .owner = THIS_MODULE, 144 .owner = THIS_MODULE,
diff --git a/drivers/regulator/as3722-regulator.c b/drivers/regulator/as3722-regulator.c
index b9f1d24c6812..8b17d786cb71 100644
--- a/drivers/regulator/as3722-regulator.c
+++ b/drivers/regulator/as3722-regulator.c
@@ -99,7 +99,6 @@ static const struct as3722_register_mapping as3722_reg_lookup[] = {
99 .sleep_ctrl_mask = AS3722_SD0_EXT_ENABLE_MASK, 99 .sleep_ctrl_mask = AS3722_SD0_EXT_ENABLE_MASK,
100 .control_reg = AS3722_SD0_CONTROL_REG, 100 .control_reg = AS3722_SD0_CONTROL_REG,
101 .mode_mask = AS3722_SD0_MODE_FAST, 101 .mode_mask = AS3722_SD0_MODE_FAST,
102 .n_voltages = AS3722_SD0_VSEL_MAX + 1,
103 }, 102 },
104 { 103 {
105 .regulator_id = AS3722_REGULATOR_ID_SD1, 104 .regulator_id = AS3722_REGULATOR_ID_SD1,
@@ -112,7 +111,6 @@ static const struct as3722_register_mapping as3722_reg_lookup[] = {
112 .sleep_ctrl_mask = AS3722_SD1_EXT_ENABLE_MASK, 111 .sleep_ctrl_mask = AS3722_SD1_EXT_ENABLE_MASK,
113 .control_reg = AS3722_SD1_CONTROL_REG, 112 .control_reg = AS3722_SD1_CONTROL_REG,
114 .mode_mask = AS3722_SD1_MODE_FAST, 113 .mode_mask = AS3722_SD1_MODE_FAST,
115 .n_voltages = AS3722_SD0_VSEL_MAX + 1,
116 }, 114 },
117 { 115 {
118 .regulator_id = AS3722_REGULATOR_ID_SD2, 116 .regulator_id = AS3722_REGULATOR_ID_SD2,
@@ -181,7 +179,6 @@ static const struct as3722_register_mapping as3722_reg_lookup[] = {
181 .sleep_ctrl_mask = AS3722_SD6_EXT_ENABLE_MASK, 179 .sleep_ctrl_mask = AS3722_SD6_EXT_ENABLE_MASK,
182 .control_reg = AS3722_SD6_CONTROL_REG, 180 .control_reg = AS3722_SD6_CONTROL_REG,
183 .mode_mask = AS3722_SD6_MODE_FAST, 181 .mode_mask = AS3722_SD6_MODE_FAST,
184 .n_voltages = AS3722_SD0_VSEL_MAX + 1,
185 }, 182 },
186 { 183 {
187 .regulator_id = AS3722_REGULATOR_ID_LDO0, 184 .regulator_id = AS3722_REGULATOR_ID_LDO0,
@@ -595,6 +592,22 @@ static int as3722_sd016_set_current_limit(struct regulator_dev *rdev,
595 return as3722_update_bits(as3722, reg, mask, val); 592 return as3722_update_bits(as3722, reg, mask, val);
596} 593}
597 594
595static bool as3722_sd0_is_low_voltage(struct as3722_regulators *as3722_regs)
596{
597 int err;
598 unsigned val;
599
600 err = as3722_read(as3722_regs->as3722, AS3722_FUSE7_REG, &val);
601 if (err < 0) {
602 dev_err(as3722_regs->dev, "Reg 0x%02x read failed: %d\n",
603 AS3722_FUSE7_REG, err);
604 return false;
605 }
606 if (val & AS3722_FUSE7_SD0_LOW_VOLTAGE)
607 return true;
608 return false;
609}
610
598static const struct regulator_linear_range as3722_sd2345_ranges[] = { 611static const struct regulator_linear_range as3722_sd2345_ranges[] = {
599 REGULATOR_LINEAR_RANGE(612500, 0x01, 0x40, 12500), 612 REGULATOR_LINEAR_RANGE(612500, 0x01, 0x40, 12500),
600 REGULATOR_LINEAR_RANGE(1425000, 0x41, 0x70, 25000), 613 REGULATOR_LINEAR_RANGE(1425000, 0x41, 0x70, 25000),
@@ -820,9 +833,19 @@ static int as3722_regulator_probe(struct platform_device *pdev)
820 ops = &as3722_sd016_extcntrl_ops; 833 ops = &as3722_sd016_extcntrl_ops;
821 else 834 else
822 ops = &as3722_sd016_ops; 835 ops = &as3722_sd016_ops;
823 as3722_regs->desc[id].min_uV = 610000; 836 if (id == AS3722_REGULATOR_ID_SD0 &&
837 as3722_sd0_is_low_voltage(as3722_regs)) {
838 as3722_regs->desc[id].n_voltages =
839 AS3722_SD0_VSEL_LOW_VOL_MAX + 1;
840 as3722_regs->desc[id].min_uV = 410000;
841 } else {
842 as3722_regs->desc[id].n_voltages =
843 AS3722_SD0_VSEL_MAX + 1,
844 as3722_regs->desc[id].min_uV = 610000;
845 }
824 as3722_regs->desc[id].uV_step = 10000; 846 as3722_regs->desc[id].uV_step = 10000;
825 as3722_regs->desc[id].linear_min_sel = 1; 847 as3722_regs->desc[id].linear_min_sel = 1;
848 as3722_regs->desc[id].enable_time = 600;
826 break; 849 break;
827 case AS3722_REGULATOR_ID_SD2: 850 case AS3722_REGULATOR_ID_SD2:
828 case AS3722_REGULATOR_ID_SD3: 851 case AS3722_REGULATOR_ID_SD3:
@@ -842,9 +865,6 @@ static int as3722_regulator_probe(struct platform_device *pdev)
842 ops = &as3722_ldo_extcntrl_ops; 865 ops = &as3722_ldo_extcntrl_ops;
843 else 866 else
844 ops = &as3722_ldo_ops; 867 ops = &as3722_ldo_ops;
845 as3722_regs->desc[id].min_uV = 825000;
846 as3722_regs->desc[id].uV_step = 25000;
847 as3722_regs->desc[id].linear_min_sel = 1;
848 as3722_regs->desc[id].enable_time = 500; 868 as3722_regs->desc[id].enable_time = 500;
849 as3722_regs->desc[id].linear_ranges = as3722_ldo_ranges; 869 as3722_regs->desc[id].linear_ranges = as3722_ldo_ranges;
850 as3722_regs->desc[id].n_linear_ranges = 870 as3722_regs->desc[id].n_linear_ranges =
diff --git a/drivers/regulator/core.c b/drivers/regulator/core.c
index d59aa96a4dc4..8bd5cbf3aafb 100644
--- a/drivers/regulator/core.c
+++ b/drivers/regulator/core.c
@@ -1272,6 +1272,8 @@ static struct regulator_dev *regulator_dev_lookup(struct device *dev,
1272 if (r->dev.parent && 1272 if (r->dev.parent &&
1273 node == r->dev.of_node) 1273 node == r->dev.of_node)
1274 return r; 1274 return r;
1275 *ret = -EPROBE_DEFER;
1276 return NULL;
1275 } else { 1277 } else {
1276 /* 1278 /*
1277 * If we couldn't even get the node then it's 1279 * If we couldn't even get the node then it's
@@ -1312,7 +1314,7 @@ static struct regulator *_regulator_get(struct device *dev, const char *id,
1312 struct regulator_dev *rdev; 1314 struct regulator_dev *rdev;
1313 struct regulator *regulator = ERR_PTR(-EPROBE_DEFER); 1315 struct regulator *regulator = ERR_PTR(-EPROBE_DEFER);
1314 const char *devname = NULL; 1316 const char *devname = NULL;
1315 int ret = -EPROBE_DEFER; 1317 int ret;
1316 1318
1317 if (id == NULL) { 1319 if (id == NULL) {
1318 pr_err("get() with no identifier\n"); 1320 pr_err("get() with no identifier\n");
@@ -1322,6 +1324,11 @@ static struct regulator *_regulator_get(struct device *dev, const char *id,
1322 if (dev) 1324 if (dev)
1323 devname = dev_name(dev); 1325 devname = dev_name(dev);
1324 1326
1327 if (have_full_constraints())
1328 ret = -ENODEV;
1329 else
1330 ret = -EPROBE_DEFER;
1331
1325 mutex_lock(&regulator_list_mutex); 1332 mutex_lock(&regulator_list_mutex);
1326 1333
1327 rdev = regulator_dev_lookup(dev, id, &ret); 1334 rdev = regulator_dev_lookup(dev, id, &ret);
@@ -1334,9 +1341,8 @@ static struct regulator *_regulator_get(struct device *dev, const char *id,
1334 * If we have return value from dev_lookup fail, we do not expect to 1341 * If we have return value from dev_lookup fail, we do not expect to
1335 * succeed, so, quit with appropriate error value 1342 * succeed, so, quit with appropriate error value
1336 */ 1343 */
1337 if (ret && ret != -ENODEV) { 1344 if (ret && ret != -ENODEV)
1338 goto out; 1345 goto out;
1339 }
1340 1346
1341 if (!devname) 1347 if (!devname)
1342 devname = "deviceless"; 1348 devname = "deviceless";
@@ -1351,7 +1357,8 @@ static struct regulator *_regulator_get(struct device *dev, const char *id,
1351 1357
1352 rdev = dummy_regulator_rdev; 1358 rdev = dummy_regulator_rdev;
1353 goto found; 1359 goto found;
1354 } else { 1360 /* Don't log an error when called from regulator_get_optional() */
1361 } else if (!have_full_constraints() || exclusive) {
1355 dev_err(dev, "dummy supplies not allowed\n"); 1362 dev_err(dev, "dummy supplies not allowed\n");
1356 } 1363 }
1357 1364
@@ -2244,7 +2251,7 @@ int regulator_is_supported_voltage(struct regulator *regulator,
2244 if (!(rdev->constraints->valid_ops_mask & REGULATOR_CHANGE_VOLTAGE)) { 2251 if (!(rdev->constraints->valid_ops_mask & REGULATOR_CHANGE_VOLTAGE)) {
2245 ret = regulator_get_voltage(regulator); 2252 ret = regulator_get_voltage(regulator);
2246 if (ret >= 0) 2253 if (ret >= 0)
2247 return (min_uV <= ret && ret <= max_uV); 2254 return min_uV <= ret && ret <= max_uV;
2248 else 2255 else
2249 return ret; 2256 return ret;
2250 } 2257 }
@@ -2416,7 +2423,7 @@ int regulator_set_voltage(struct regulator *regulator, int min_uV, int max_uV)
2416 ret = regulator_check_voltage(rdev, &min_uV, &max_uV); 2423 ret = regulator_check_voltage(rdev, &min_uV, &max_uV);
2417 if (ret < 0) 2424 if (ret < 0)
2418 goto out; 2425 goto out;
2419 2426
2420 /* restore original values in case of error */ 2427 /* restore original values in case of error */
2421 old_min_uV = regulator->min_uV; 2428 old_min_uV = regulator->min_uV;
2422 old_max_uV = regulator->max_uV; 2429 old_max_uV = regulator->max_uV;
@@ -2430,7 +2437,7 @@ int regulator_set_voltage(struct regulator *regulator, int min_uV, int max_uV)
2430 ret = _regulator_do_set_voltage(rdev, min_uV, max_uV); 2437 ret = _regulator_do_set_voltage(rdev, min_uV, max_uV);
2431 if (ret < 0) 2438 if (ret < 0)
2432 goto out2; 2439 goto out2;
2433 2440
2434out: 2441out:
2435 mutex_unlock(&rdev->mutex); 2442 mutex_unlock(&rdev->mutex);
2436 return ret; 2443 return ret;
@@ -3835,9 +3842,8 @@ static int __init regulator_init_complete(void)
3835 * goes wrong. */ 3842 * goes wrong. */
3836 rdev_info(rdev, "disabling\n"); 3843 rdev_info(rdev, "disabling\n");
3837 ret = ops->disable(rdev); 3844 ret = ops->disable(rdev);
3838 if (ret != 0) { 3845 if (ret != 0)
3839 rdev_err(rdev, "couldn't disable: %d\n", ret); 3846 rdev_err(rdev, "couldn't disable: %d\n", ret);
3840 }
3841 } else { 3847 } else {
3842 /* The intention is that in future we will 3848 /* The intention is that in future we will
3843 * assume that full constraints are provided 3849 * assume that full constraints are provided
diff --git a/drivers/regulator/da9055-regulator.c b/drivers/regulator/da9055-regulator.c
index 7f340206d329..b14ebdad5dd2 100644
--- a/drivers/regulator/da9055-regulator.c
+++ b/drivers/regulator/da9055-regulator.c
@@ -576,7 +576,9 @@ static int da9055_regulator_probe(struct platform_device *pdev)
576 /* Only LDO 5 and 6 has got the over current interrupt */ 576 /* Only LDO 5 and 6 has got the over current interrupt */
577 if (pdev->id == DA9055_ID_LDO5 || pdev->id == DA9055_ID_LDO6) { 577 if (pdev->id == DA9055_ID_LDO5 || pdev->id == DA9055_ID_LDO6) {
578 irq = platform_get_irq_byname(pdev, "REGULATOR"); 578 irq = platform_get_irq_byname(pdev, "REGULATOR");
579 irq = regmap_irq_get_virq(da9055->irq_data, irq); 579 if (irq < 0)
580 return irq;
581
580 ret = devm_request_threaded_irq(&pdev->dev, irq, NULL, 582 ret = devm_request_threaded_irq(&pdev->dev, irq, NULL,
581 da9055_ldo5_6_oc_irq, 583 da9055_ldo5_6_oc_irq,
582 IRQF_TRIGGER_HIGH | 584 IRQF_TRIGGER_HIGH |
diff --git a/drivers/regulator/db8500-prcmu.c b/drivers/regulator/db8500-prcmu.c
index a53c11a529d5..846acf240e48 100644
--- a/drivers/regulator/db8500-prcmu.c
+++ b/drivers/regulator/db8500-prcmu.c
@@ -431,17 +431,11 @@ static int db8500_regulator_register(struct platform_device *pdev,
431 config.of_node = np; 431 config.of_node = np;
432 432
433 /* register with the regulator framework */ 433 /* register with the regulator framework */
434 info->rdev = regulator_register(&info->desc, &config); 434 info->rdev = devm_regulator_register(&pdev->dev, &info->desc, &config);
435 if (IS_ERR(info->rdev)) { 435 if (IS_ERR(info->rdev)) {
436 err = PTR_ERR(info->rdev); 436 err = PTR_ERR(info->rdev);
437 dev_err(&pdev->dev, "failed to register %s: err %i\n", 437 dev_err(&pdev->dev, "failed to register %s: err %i\n",
438 info->desc.name, err); 438 info->desc.name, err);
439
440 /* if failing, unregister all earlier regulators */
441 while (--id >= 0) {
442 info = &dbx500_regulator_info[id];
443 regulator_unregister(info->rdev);
444 }
445 return err; 439 return err;
446 } 440 }
447 441
@@ -530,20 +524,8 @@ static int db8500_regulator_probe(struct platform_device *pdev)
530 524
531static int db8500_regulator_remove(struct platform_device *pdev) 525static int db8500_regulator_remove(struct platform_device *pdev)
532{ 526{
533 int i;
534
535 ux500_regulator_debug_exit(); 527 ux500_regulator_debug_exit();
536 528
537 for (i = 0; i < ARRAY_SIZE(dbx500_regulator_info); i++) {
538 struct dbx500_regulator_info *info;
539 info = &dbx500_regulator_info[i];
540
541 dev_vdbg(rdev_get_dev(info->rdev),
542 "regulator-%s-remove\n", info->desc.name);
543
544 regulator_unregister(info->rdev);
545 }
546
547 return 0; 529 return 0;
548} 530}
549 531
diff --git a/drivers/regulator/gpio-regulator.c b/drivers/regulator/gpio-regulator.c
index 234960dc9607..c0a1d00b78c9 100644
--- a/drivers/regulator/gpio-regulator.c
+++ b/drivers/regulator/gpio-regulator.c
@@ -203,17 +203,18 @@ of_get_gpio_regulator_config(struct device *dev, struct device_node *np)
203 } 203 }
204 config->nr_states = i; 204 config->nr_states = i;
205 205
206 config->type = REGULATOR_VOLTAGE;
206 ret = of_property_read_string(np, "regulator-type", &regtype); 207 ret = of_property_read_string(np, "regulator-type", &regtype);
207 if (ret < 0) { 208 if (ret >= 0) {
208 dev_err(dev, "Missing 'regulator-type' property\n"); 209 if (!strncmp("voltage", regtype, 7))
209 return ERR_PTR(-EINVAL); 210 config->type = REGULATOR_VOLTAGE;
211 else if (!strncmp("current", regtype, 7))
212 config->type = REGULATOR_CURRENT;
213 else
214 dev_warn(dev, "Unknown regulator-type '%s'\n",
215 regtype);
210 } 216 }
211 217
212 if (!strncmp("voltage", regtype, 7))
213 config->type = REGULATOR_VOLTAGE;
214 else if (!strncmp("current", regtype, 7))
215 config->type = REGULATOR_CURRENT;
216
217 return config; 218 return config;
218} 219}
219 220
diff --git a/drivers/regulator/lp3971.c b/drivers/regulator/lp3971.c
index 947c05ffe0ab..3b1102b75071 100644
--- a/drivers/regulator/lp3971.c
+++ b/drivers/regulator/lp3971.c
@@ -25,8 +25,6 @@ struct lp3971 {
25 struct device *dev; 25 struct device *dev;
26 struct mutex io_lock; 26 struct mutex io_lock;
27 struct i2c_client *i2c; 27 struct i2c_client *i2c;
28 int num_regulators;
29 struct regulator_dev **rdev;
30}; 28};
31 29
32static u8 lp3971_reg_read(struct lp3971 *lp3971, u8 reg); 30static u8 lp3971_reg_read(struct lp3971 *lp3971, u8 reg);
@@ -383,42 +381,27 @@ static int setup_regulators(struct lp3971 *lp3971,
383{ 381{
384 int i, err; 382 int i, err;
385 383
386 lp3971->num_regulators = pdata->num_regulators;
387 lp3971->rdev = kcalloc(pdata->num_regulators,
388 sizeof(struct regulator_dev *), GFP_KERNEL);
389 if (!lp3971->rdev) {
390 err = -ENOMEM;
391 goto err_nomem;
392 }
393
394 /* Instantiate the regulators */ 384 /* Instantiate the regulators */
395 for (i = 0; i < pdata->num_regulators; i++) { 385 for (i = 0; i < pdata->num_regulators; i++) {
396 struct regulator_config config = { }; 386 struct regulator_config config = { };
397 struct lp3971_regulator_subdev *reg = &pdata->regulators[i]; 387 struct lp3971_regulator_subdev *reg = &pdata->regulators[i];
388 struct regulator_dev *rdev;
398 389
399 config.dev = lp3971->dev; 390 config.dev = lp3971->dev;
400 config.init_data = reg->initdata; 391 config.init_data = reg->initdata;
401 config.driver_data = lp3971; 392 config.driver_data = lp3971;
402 393
403 lp3971->rdev[i] = regulator_register(&regulators[reg->id], 394 rdev = devm_regulator_register(lp3971->dev,
404 &config); 395 &regulators[reg->id], &config);
405 if (IS_ERR(lp3971->rdev[i])) { 396 if (IS_ERR(rdev)) {
406 err = PTR_ERR(lp3971->rdev[i]); 397 err = PTR_ERR(rdev);
407 dev_err(lp3971->dev, "regulator init failed: %d\n", 398 dev_err(lp3971->dev, "regulator init failed: %d\n",
408 err); 399 err);
409 goto error; 400 return err;
410 } 401 }
411 } 402 }
412 403
413 return 0; 404 return 0;
414
415error:
416 while (--i >= 0)
417 regulator_unregister(lp3971->rdev[i]);
418 kfree(lp3971->rdev);
419 lp3971->rdev = NULL;
420err_nomem:
421 return err;
422} 405}
423 406
424static int lp3971_i2c_probe(struct i2c_client *i2c, 407static int lp3971_i2c_probe(struct i2c_client *i2c,
@@ -460,19 +443,6 @@ static int lp3971_i2c_probe(struct i2c_client *i2c,
460 return 0; 443 return 0;
461} 444}
462 445
463static int lp3971_i2c_remove(struct i2c_client *i2c)
464{
465 struct lp3971 *lp3971 = i2c_get_clientdata(i2c);
466 int i;
467
468 for (i = 0; i < lp3971->num_regulators; i++)
469 regulator_unregister(lp3971->rdev[i]);
470
471 kfree(lp3971->rdev);
472
473 return 0;
474}
475
476static const struct i2c_device_id lp3971_i2c_id[] = { 446static const struct i2c_device_id lp3971_i2c_id[] = {
477 { "lp3971", 0 }, 447 { "lp3971", 0 },
478 { } 448 { }
@@ -485,7 +455,6 @@ static struct i2c_driver lp3971_i2c_driver = {
485 .owner = THIS_MODULE, 455 .owner = THIS_MODULE,
486 }, 456 },
487 .probe = lp3971_i2c_probe, 457 .probe = lp3971_i2c_probe,
488 .remove = lp3971_i2c_remove,
489 .id_table = lp3971_i2c_id, 458 .id_table = lp3971_i2c_id,
490}; 459};
491 460
diff --git a/drivers/regulator/lp3972.c b/drivers/regulator/lp3972.c
index 093e6f44ff8a..aea485afcc1a 100644
--- a/drivers/regulator/lp3972.c
+++ b/drivers/regulator/lp3972.c
@@ -22,8 +22,6 @@ struct lp3972 {
22 struct device *dev; 22 struct device *dev;
23 struct mutex io_lock; 23 struct mutex io_lock;
24 struct i2c_client *i2c; 24 struct i2c_client *i2c;
25 int num_regulators;
26 struct regulator_dev **rdev;
27}; 25};
28 26
29/* LP3972 Control Registers */ 27/* LP3972 Control Registers */
@@ -478,41 +476,27 @@ static int setup_regulators(struct lp3972 *lp3972,
478{ 476{
479 int i, err; 477 int i, err;
480 478
481 lp3972->num_regulators = pdata->num_regulators;
482 lp3972->rdev = kcalloc(pdata->num_regulators,
483 sizeof(struct regulator_dev *), GFP_KERNEL);
484 if (!lp3972->rdev) {
485 err = -ENOMEM;
486 goto err_nomem;
487 }
488
489 /* Instantiate the regulators */ 479 /* Instantiate the regulators */
490 for (i = 0; i < pdata->num_regulators; i++) { 480 for (i = 0; i < pdata->num_regulators; i++) {
491 struct lp3972_regulator_subdev *reg = &pdata->regulators[i]; 481 struct lp3972_regulator_subdev *reg = &pdata->regulators[i];
492 struct regulator_config config = { }; 482 struct regulator_config config = { };
483 struct regulator_dev *rdev;
493 484
494 config.dev = lp3972->dev; 485 config.dev = lp3972->dev;
495 config.init_data = reg->initdata; 486 config.init_data = reg->initdata;
496 config.driver_data = lp3972; 487 config.driver_data = lp3972;
497 488
498 lp3972->rdev[i] = regulator_register(&regulators[reg->id], 489 rdev = devm_regulator_register(lp3972->dev,
499 &config); 490 &regulators[reg->id], &config);
500 if (IS_ERR(lp3972->rdev[i])) { 491 if (IS_ERR(rdev)) {
501 err = PTR_ERR(lp3972->rdev[i]); 492 err = PTR_ERR(rdev);
502 dev_err(lp3972->dev, "regulator init failed: %d\n", 493 dev_err(lp3972->dev, "regulator init failed: %d\n",
503 err); 494 err);
504 goto error; 495 return err;
505 } 496 }
506 } 497 }
507 498
508 return 0; 499 return 0;
509error:
510 while (--i >= 0)
511 regulator_unregister(lp3972->rdev[i]);
512 kfree(lp3972->rdev);
513 lp3972->rdev = NULL;
514err_nomem:
515 return err;
516} 500}
517 501
518static int lp3972_i2c_probe(struct i2c_client *i2c, 502static int lp3972_i2c_probe(struct i2c_client *i2c,
@@ -557,18 +541,6 @@ static int lp3972_i2c_probe(struct i2c_client *i2c,
557 return 0; 541 return 0;
558} 542}
559 543
560static int lp3972_i2c_remove(struct i2c_client *i2c)
561{
562 struct lp3972 *lp3972 = i2c_get_clientdata(i2c);
563 int i;
564
565 for (i = 0; i < lp3972->num_regulators; i++)
566 regulator_unregister(lp3972->rdev[i]);
567 kfree(lp3972->rdev);
568
569 return 0;
570}
571
572static const struct i2c_device_id lp3972_i2c_id[] = { 544static const struct i2c_device_id lp3972_i2c_id[] = {
573 { "lp3972", 0 }, 545 { "lp3972", 0 },
574 { } 546 { }
@@ -581,7 +553,6 @@ static struct i2c_driver lp3972_i2c_driver = {
581 .owner = THIS_MODULE, 553 .owner = THIS_MODULE,
582 }, 554 },
583 .probe = lp3972_i2c_probe, 555 .probe = lp3972_i2c_probe,
584 .remove = lp3972_i2c_remove,
585 .id_table = lp3972_i2c_id, 556 .id_table = lp3972_i2c_id,
586}; 557};
587 558
diff --git a/drivers/regulator/max14577.c b/drivers/regulator/max14577.c
new file mode 100644
index 000000000000..186df8785a91
--- /dev/null
+++ b/drivers/regulator/max14577.c
@@ -0,0 +1,274 @@
1/*
2 * max14577.c - Regulator driver for the Maxim 14577
3 *
4 * Copyright (C) 2013 Samsung Electronics
5 * Krzysztof Kozlowski <k.kozlowski@samsung.com>
6 *
7 * This program is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License as published by
9 * the Free Software Foundation; either version 2 of the License, or
10 * (at your option) any later version.
11 *
12 * This program is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 * GNU General Public License for more details.
16 */
17
18#include <linux/module.h>
19#include <linux/platform_device.h>
20#include <linux/regulator/driver.h>
21#include <linux/mfd/max14577.h>
22#include <linux/mfd/max14577-private.h>
23#include <linux/regulator/of_regulator.h>
24
25struct max14577_regulator {
26 struct device *dev;
27 struct max14577 *max14577;
28 struct regulator_dev **regulators;
29};
30
31static int max14577_reg_is_enabled(struct regulator_dev *rdev)
32{
33 int rid = rdev_get_id(rdev);
34 struct regmap *rmap = rdev->regmap;
35 u8 reg_data;
36
37 switch (rid) {
38 case MAX14577_CHARGER:
39 max14577_read_reg(rmap, MAX14577_CHG_REG_CHG_CTRL2, &reg_data);
40 if ((reg_data & CHGCTRL2_MBCHOSTEN_MASK) == 0)
41 return 0;
42 max14577_read_reg(rmap, MAX14577_CHG_REG_STATUS3, &reg_data);
43 if ((reg_data & STATUS3_CGMBC_MASK) == 0)
44 return 0;
45 /* MBCHOSTEN and CGMBC are on */
46 return 1;
47 default:
48 return -EINVAL;
49 }
50}
51
52static int max14577_reg_get_current_limit(struct regulator_dev *rdev)
53{
54 u8 reg_data;
55 struct regmap *rmap = rdev->regmap;
56
57 if (rdev_get_id(rdev) != MAX14577_CHARGER)
58 return -EINVAL;
59
60 max14577_read_reg(rmap, MAX14577_CHG_REG_CHG_CTRL4, &reg_data);
61
62 if ((reg_data & CHGCTRL4_MBCICHWRCL_MASK) == 0)
63 return MAX14577_REGULATOR_CURRENT_LIMIT_MIN;
64
65 reg_data = ((reg_data & CHGCTRL4_MBCICHWRCH_MASK) >>
66 CHGCTRL4_MBCICHWRCH_SHIFT);
67 return MAX14577_REGULATOR_CURRENT_LIMIT_HIGH_START +
68 reg_data * MAX14577_REGULATOR_CURRENT_LIMIT_HIGH_STEP;
69}
70
71static int max14577_reg_set_current_limit(struct regulator_dev *rdev,
72 int min_uA, int max_uA)
73{
74 int i, current_bits = 0xf;
75 u8 reg_data;
76
77 if (rdev_get_id(rdev) != MAX14577_CHARGER)
78 return -EINVAL;
79
80 if (min_uA > MAX14577_REGULATOR_CURRENT_LIMIT_MAX ||
81 max_uA < MAX14577_REGULATOR_CURRENT_LIMIT_MIN)
82 return -EINVAL;
83
84 if (max_uA < MAX14577_REGULATOR_CURRENT_LIMIT_HIGH_START) {
85 /* Less than 200 mA, so set 90mA (turn only Low Bit off) */
86 u8 reg_data = 0x0 << CHGCTRL4_MBCICHWRCL_SHIFT;
87 return max14577_update_reg(rdev->regmap,
88 MAX14577_CHG_REG_CHG_CTRL4,
89 CHGCTRL4_MBCICHWRCL_MASK, reg_data);
90 }
91
92 /* max_uA is in range: <LIMIT_HIGH_START, inifinite>, so search for
93 * valid current starting from LIMIT_MAX. */
94 for (i = MAX14577_REGULATOR_CURRENT_LIMIT_MAX;
95 i >= MAX14577_REGULATOR_CURRENT_LIMIT_HIGH_START;
96 i -= MAX14577_REGULATOR_CURRENT_LIMIT_HIGH_STEP) {
97 if (i <= max_uA)
98 break;
99 current_bits--;
100 }
101 BUG_ON(current_bits < 0); /* Cannot happen */
102 /* Turn Low Bit on (use range 200mA-950 mA) */
103 reg_data = 0x1 << CHGCTRL4_MBCICHWRCL_SHIFT;
104 /* and set proper High Bits */
105 reg_data |= current_bits << CHGCTRL4_MBCICHWRCH_SHIFT;
106
107 return max14577_update_reg(rdev->regmap, MAX14577_CHG_REG_CHG_CTRL4,
108 CHGCTRL4_MBCICHWRCL_MASK | CHGCTRL4_MBCICHWRCH_MASK,
109 reg_data);
110}
111
112static struct regulator_ops max14577_safeout_ops = {
113 .is_enabled = regulator_is_enabled_regmap,
114 .enable = regulator_enable_regmap,
115 .disable = regulator_disable_regmap,
116 .list_voltage = regulator_list_voltage_linear,
117};
118
119static struct regulator_ops max14577_charger_ops = {
120 .is_enabled = max14577_reg_is_enabled,
121 .enable = regulator_enable_regmap,
122 .disable = regulator_disable_regmap,
123 .get_current_limit = max14577_reg_get_current_limit,
124 .set_current_limit = max14577_reg_set_current_limit,
125};
126
127static const struct regulator_desc supported_regulators[] = {
128 [MAX14577_SAFEOUT] = {
129 .name = "SAFEOUT",
130 .id = MAX14577_SAFEOUT,
131 .ops = &max14577_safeout_ops,
132 .type = REGULATOR_VOLTAGE,
133 .owner = THIS_MODULE,
134 .n_voltages = 1,
135 .min_uV = MAX14577_REGULATOR_SAFEOUT_VOLTAGE,
136 .enable_reg = MAX14577_REG_CONTROL2,
137 .enable_mask = CTRL2_SFOUTORD_MASK,
138 },
139 [MAX14577_CHARGER] = {
140 .name = "CHARGER",
141 .id = MAX14577_CHARGER,
142 .ops = &max14577_charger_ops,
143 .type = REGULATOR_CURRENT,
144 .owner = THIS_MODULE,
145 .enable_reg = MAX14577_CHG_REG_CHG_CTRL2,
146 .enable_mask = CHGCTRL2_MBCHOSTEN_MASK,
147 },
148};
149
150#ifdef CONFIG_OF
151static struct of_regulator_match max14577_regulator_matches[] = {
152 { .name = "SAFEOUT", },
153 { .name = "CHARGER", },
154};
155
156static int max14577_regulator_dt_parse_pdata(struct platform_device *pdev)
157{
158 int ret;
159 struct device_node *np;
160
161 np = of_get_child_by_name(pdev->dev.parent->of_node, "regulators");
162 if (!np) {
163 dev_err(&pdev->dev, "Failed to get child OF node for regulators\n");
164 return -EINVAL;
165 }
166
167 ret = of_regulator_match(&pdev->dev, np, max14577_regulator_matches,
168 MAX14577_REG_MAX);
169 if (ret < 0) {
170 dev_err(&pdev->dev, "Error parsing regulator init data: %d\n", ret);
171 }
172
173 of_node_put(np);
174
175 return ret;
176}
177
178static inline struct regulator_init_data *match_init_data(int index)
179{
180 return max14577_regulator_matches[index].init_data;
181}
182
183static inline struct device_node *match_of_node(int index)
184{
185 return max14577_regulator_matches[index].of_node;
186}
187#else /* CONFIG_OF */
188static int max14577_regulator_dt_parse_pdata(struct platform_device *pdev)
189{
190 return 0;
191}
192static inline struct regulator_init_data *match_init_data(int index)
193{
194 return NULL;
195}
196
197static inline struct device_node *match_of_node(int index)
198{
199 return NULL;
200}
201#endif /* CONFIG_OF */
202
203
204static int max14577_regulator_probe(struct platform_device *pdev)
205{
206 struct max14577 *max14577 = dev_get_drvdata(pdev->dev.parent);
207 struct max14577_platform_data *pdata = dev_get_platdata(max14577->dev);
208 int i, ret;
209 struct regulator_config config = {};
210
211 ret = max14577_regulator_dt_parse_pdata(pdev);
212 if (ret)
213 return ret;
214
215 config.dev = &pdev->dev;
216 config.regmap = max14577->regmap;
217
218 for (i = 0; i < ARRAY_SIZE(supported_regulators); i++) {
219 struct regulator_dev *regulator;
220 /*
221 * Index of supported_regulators[] is also the id and must
222 * match index of pdata->regulators[].
223 */
224 if (pdata && pdata->regulators) {
225 config.init_data = pdata->regulators[i].initdata;
226 config.of_node = pdata->regulators[i].of_node;
227 } else {
228 config.init_data = match_init_data(i);
229 config.of_node = match_of_node(i);
230 }
231
232 regulator = devm_regulator_register(&pdev->dev,
233 &supported_regulators[i], &config);
234 if (IS_ERR(regulator)) {
235 ret = PTR_ERR(regulator);
236 dev_err(&pdev->dev,
237 "Regulator init failed for ID %d with error: %d\n",
238 i, ret);
239 return ret;
240 }
241 }
242
243 return ret;
244}
245
246static struct platform_driver max14577_regulator_driver = {
247 .driver = {
248 .owner = THIS_MODULE,
249 .name = "max14577-regulator",
250 },
251 .probe = max14577_regulator_probe,
252};
253
254static int __init max14577_regulator_init(void)
255{
256 BUILD_BUG_ON(MAX14577_REGULATOR_CURRENT_LIMIT_HIGH_START +
257 MAX14577_REGULATOR_CURRENT_LIMIT_HIGH_STEP * 0xf !=
258 MAX14577_REGULATOR_CURRENT_LIMIT_MAX);
259 BUILD_BUG_ON(ARRAY_SIZE(supported_regulators) != MAX14577_REG_MAX);
260
261 return platform_driver_register(&max14577_regulator_driver);
262}
263subsys_initcall(max14577_regulator_init);
264
265static void __exit max14577_regulator_exit(void)
266{
267 platform_driver_unregister(&max14577_regulator_driver);
268}
269module_exit(max14577_regulator_exit);
270
271MODULE_AUTHOR("Krzysztof Kozlowski <k.kozlowski@samsung.com>");
272MODULE_DESCRIPTION("MAXIM 14577 regulator driver");
273MODULE_LICENSE("GPL");
274MODULE_ALIAS("platform:max14577-regulator");
diff --git a/drivers/regulator/max77693.c b/drivers/regulator/max77693.c
index feb20bf4ccab..5fb899f461d0 100644
--- a/drivers/regulator/max77693.c
+++ b/drivers/regulator/max77693.c
@@ -138,6 +138,7 @@ static struct regulator_ops max77693_charger_ops = {
138 .n_voltages = 4, \ 138 .n_voltages = 4, \
139 .ops = &max77693_safeout_ops, \ 139 .ops = &max77693_safeout_ops, \
140 .type = REGULATOR_VOLTAGE, \ 140 .type = REGULATOR_VOLTAGE, \
141 .owner = THIS_MODULE, \
141 .volt_table = max77693_safeout_table, \ 142 .volt_table = max77693_safeout_table, \
142 .vsel_reg = MAX77693_CHG_REG_SAFEOUT_CTRL, \ 143 .vsel_reg = MAX77693_CHG_REG_SAFEOUT_CTRL, \
143 .vsel_mask = SAFEOUT_CTRL_SAFEOUT##_num##_MASK, \ 144 .vsel_mask = SAFEOUT_CTRL_SAFEOUT##_num##_MASK, \
diff --git a/drivers/regulator/mc13892-regulator.c b/drivers/regulator/mc13892-regulator.c
index 96c9f80d9550..f374fa57220f 100644
--- a/drivers/regulator/mc13892-regulator.c
+++ b/drivers/regulator/mc13892-regulator.c
@@ -274,25 +274,25 @@ static struct mc13xxx_regulator mc13892_regulators[] = {
274 MC13892_SW_DEFINE(SW4, SWITCHERS3, SWITCHERS3, mc13892_sw), 274 MC13892_SW_DEFINE(SW4, SWITCHERS3, SWITCHERS3, mc13892_sw),
275 MC13892_FIXED_DEFINE(SWBST, SWITCHERS5, mc13892_swbst), 275 MC13892_FIXED_DEFINE(SWBST, SWITCHERS5, mc13892_swbst),
276 MC13892_FIXED_DEFINE(VIOHI, REGULATORMODE0, mc13892_viohi), 276 MC13892_FIXED_DEFINE(VIOHI, REGULATORMODE0, mc13892_viohi),
277 MC13892_DEFINE_REGU(VPLL, REGULATORMODE0, REGULATORSETTING0, \ 277 MC13892_DEFINE_REGU(VPLL, REGULATORMODE0, REGULATORSETTING0,
278 mc13892_vpll), 278 mc13892_vpll),
279 MC13892_DEFINE_REGU(VDIG, REGULATORMODE0, REGULATORSETTING0, \ 279 MC13892_DEFINE_REGU(VDIG, REGULATORMODE0, REGULATORSETTING0,
280 mc13892_vdig), 280 mc13892_vdig),
281 MC13892_DEFINE_REGU(VSD, REGULATORMODE1, REGULATORSETTING1, \ 281 MC13892_DEFINE_REGU(VSD, REGULATORMODE1, REGULATORSETTING1,
282 mc13892_vsd), 282 mc13892_vsd),
283 MC13892_DEFINE_REGU(VUSB2, REGULATORMODE0, REGULATORSETTING0, \ 283 MC13892_DEFINE_REGU(VUSB2, REGULATORMODE0, REGULATORSETTING0,
284 mc13892_vusb2), 284 mc13892_vusb2),
285 MC13892_DEFINE_REGU(VVIDEO, REGULATORMODE1, REGULATORSETTING1, \ 285 MC13892_DEFINE_REGU(VVIDEO, REGULATORMODE1, REGULATORSETTING1,
286 mc13892_vvideo), 286 mc13892_vvideo),
287 MC13892_DEFINE_REGU(VAUDIO, REGULATORMODE1, REGULATORSETTING1, \ 287 MC13892_DEFINE_REGU(VAUDIO, REGULATORMODE1, REGULATORSETTING1,
288 mc13892_vaudio), 288 mc13892_vaudio),
289 MC13892_DEFINE_REGU(VCAM, REGULATORMODE1, REGULATORSETTING0, \ 289 MC13892_DEFINE_REGU(VCAM, REGULATORMODE1, REGULATORSETTING0,
290 mc13892_vcam), 290 mc13892_vcam),
291 MC13892_DEFINE_REGU(VGEN1, REGULATORMODE0, REGULATORSETTING0, \ 291 MC13892_DEFINE_REGU(VGEN1, REGULATORMODE0, REGULATORSETTING0,
292 mc13892_vgen1), 292 mc13892_vgen1),
293 MC13892_DEFINE_REGU(VGEN2, REGULATORMODE0, REGULATORSETTING0, \ 293 MC13892_DEFINE_REGU(VGEN2, REGULATORMODE0, REGULATORSETTING0,
294 mc13892_vgen2), 294 mc13892_vgen2),
295 MC13892_DEFINE_REGU(VGEN3, REGULATORMODE1, REGULATORSETTING0, \ 295 MC13892_DEFINE_REGU(VGEN3, REGULATORMODE1, REGULATORSETTING0,
296 mc13892_vgen3), 296 mc13892_vgen3),
297 MC13892_FIXED_DEFINE(VUSB, USB1, mc13892_vusb), 297 MC13892_FIXED_DEFINE(VUSB, USB1, mc13892_vusb),
298 MC13892_GPO_DEFINE(GPO1, POWERMISC, mc13892_gpo), 298 MC13892_GPO_DEFINE(GPO1, POWERMISC, mc13892_gpo),
@@ -476,8 +476,8 @@ static int mc13892_sw_regulator_set_voltage_sel(struct regulator_dev *rdev,
476 } 476 }
477 477
478 mc13xxx_lock(priv->mc13xxx); 478 mc13xxx_lock(priv->mc13xxx);
479 ret = mc13xxx_reg_rmw(priv->mc13xxx, mc13892_regulators[id].vsel_reg, mask, 479 ret = mc13xxx_reg_rmw(priv->mc13xxx, mc13892_regulators[id].vsel_reg,
480 reg_value); 480 mask, reg_value);
481 mc13xxx_unlock(priv->mc13xxx); 481 mc13xxx_unlock(priv->mc13xxx);
482 482
483 return ret; 483 return ret;
diff --git a/drivers/regulator/pcf50633-regulator.c b/drivers/regulator/pcf50633-regulator.c
index d7da1c15a6da..134f90ec9ca1 100644
--- a/drivers/regulator/pcf50633-regulator.c
+++ b/drivers/regulator/pcf50633-regulator.c
@@ -105,7 +105,7 @@ static int pcf50633_regulator_probe(struct platform_device *pdev)
105 105
106static struct platform_driver pcf50633_regulator_driver = { 106static struct platform_driver pcf50633_regulator_driver = {
107 .driver = { 107 .driver = {
108 .name = "pcf50633-regltr", 108 .name = "pcf50633-regulator",
109 }, 109 },
110 .probe = pcf50633_regulator_probe, 110 .probe = pcf50633_regulator_probe,
111}; 111};
diff --git a/drivers/regulator/pfuze100-regulator.c b/drivers/regulator/pfuze100-regulator.c
index 8b5e4c712a01..ab174f20ca11 100644
--- a/drivers/regulator/pfuze100-regulator.c
+++ b/drivers/regulator/pfuze100-regulator.c
@@ -309,21 +309,24 @@ static int pfuze_identify(struct pfuze_chip *pfuze_chip)
309 return ret; 309 return ret;
310 310
311 switch (value & 0x0f) { 311 switch (value & 0x0f) {
312 /* Freescale misprogrammed 1-3% of parts prior to week 8 of 2013 as ID=8 */ 312 /*
313 case 0x8: 313 * Freescale misprogrammed 1-3% of parts prior to week 8 of 2013
314 dev_info(pfuze_chip->dev, "Assuming misprogrammed ID=0x8"); 314 * as ID=8
315 case 0x0: 315 */
316 break; 316 case 0x8:
317 default: 317 dev_info(pfuze_chip->dev, "Assuming misprogrammed ID=0x8");
318 dev_warn(pfuze_chip->dev, "Illegal ID: %x\n", value); 318 case 0x0:
319 return -ENODEV; 319 break;
320 default:
321 dev_warn(pfuze_chip->dev, "Illegal ID: %x\n", value);
322 return -ENODEV;
320 } 323 }
321 324
322 ret = regmap_read(pfuze_chip->regmap, PFUZE100_REVID, &value); 325 ret = regmap_read(pfuze_chip->regmap, PFUZE100_REVID, &value);
323 if (ret) 326 if (ret)
324 return ret; 327 return ret;
325 dev_info(pfuze_chip->dev, 328 dev_info(pfuze_chip->dev,
326 "Full lay: %x, Metal lay: %x\n", 329 "Full layer: %x, Metal layer: %x\n",
327 (value & 0xf0) >> 4, value & 0x0f); 330 (value & 0xf0) >> 4, value & 0x0f);
328 331
329 ret = regmap_read(pfuze_chip->regmap, PFUZE100_FABID, &value); 332 ret = regmap_read(pfuze_chip->regmap, PFUZE100_FABID, &value);
@@ -408,31 +411,18 @@ static int pfuze100_regulator_probe(struct i2c_client *client,
408 config.driver_data = pfuze_chip; 411 config.driver_data = pfuze_chip;
409 config.of_node = match_of_node(i); 412 config.of_node = match_of_node(i);
410 413
411 pfuze_chip->regulators[i] = regulator_register(desc, &config); 414 pfuze_chip->regulators[i] =
415 devm_regulator_register(&client->dev, desc, &config);
412 if (IS_ERR(pfuze_chip->regulators[i])) { 416 if (IS_ERR(pfuze_chip->regulators[i])) {
413 dev_err(&client->dev, "register regulator%s failed\n", 417 dev_err(&client->dev, "register regulator%s failed\n",
414 pfuze100_regulators[i].desc.name); 418 pfuze100_regulators[i].desc.name);
415 ret = PTR_ERR(pfuze_chip->regulators[i]); 419 return PTR_ERR(pfuze_chip->regulators[i]);
416 while (--i >= 0)
417 regulator_unregister(pfuze_chip->regulators[i]);
418 return ret;
419 } 420 }
420 } 421 }
421 422
422 return 0; 423 return 0;
423} 424}
424 425
425static int pfuze100_regulator_remove(struct i2c_client *client)
426{
427 int i;
428 struct pfuze_chip *pfuze_chip = i2c_get_clientdata(client);
429
430 for (i = 0; i < PFUZE100_MAX_REGULATOR; i++)
431 regulator_unregister(pfuze_chip->regulators[i]);
432
433 return 0;
434}
435
436static struct i2c_driver pfuze_driver = { 426static struct i2c_driver pfuze_driver = {
437 .id_table = pfuze_device_id, 427 .id_table = pfuze_device_id,
438 .driver = { 428 .driver = {
@@ -441,7 +431,6 @@ static struct i2c_driver pfuze_driver = {
441 .of_match_table = pfuze_dt_ids, 431 .of_match_table = pfuze_dt_ids,
442 }, 432 },
443 .probe = pfuze100_regulator_probe, 433 .probe = pfuze100_regulator_probe,
444 .remove = pfuze100_regulator_remove,
445}; 434};
446module_i2c_driver(pfuze_driver); 435module_i2c_driver(pfuze_driver);
447 436
diff --git a/drivers/regulator/s2mps11.c b/drivers/regulator/s2mps11.c
index 333677d68d0e..cd0b9e35a56d 100644
--- a/drivers/regulator/s2mps11.c
+++ b/drivers/regulator/s2mps11.c
@@ -70,8 +70,6 @@ static int s2mps11_regulator_set_voltage_time_sel(struct regulator_dev *rdev,
70 ramp_delay = s2mps11->ramp_delay2; 70 ramp_delay = s2mps11->ramp_delay2;
71 break; 71 break;
72 case S2MPS11_BUCK3: 72 case S2MPS11_BUCK3:
73 ramp_delay = s2mps11->ramp_delay34;
74 break;
75 case S2MPS11_BUCK4: 73 case S2MPS11_BUCK4:
76 ramp_delay = s2mps11->ramp_delay34; 74 ramp_delay = s2mps11->ramp_delay34;
77 break; 75 break;
@@ -438,11 +436,12 @@ common_reg:
438 platform_set_drvdata(pdev, s2mps11); 436 platform_set_drvdata(pdev, s2mps11);
439 437
440 config.dev = &pdev->dev; 438 config.dev = &pdev->dev;
441 config.regmap = iodev->regmap; 439 config.regmap = iodev->regmap_pmic;
442 config.driver_data = s2mps11; 440 config.driver_data = s2mps11;
443 for (i = 0; i < S2MPS11_REGULATOR_MAX; i++) { 441 for (i = 0; i < S2MPS11_REGULATOR_MAX; i++) {
444 if (!reg_np) { 442 if (!reg_np) {
445 config.init_data = pdata->regulators[i].initdata; 443 config.init_data = pdata->regulators[i].initdata;
444 config.of_node = pdata->regulators[i].reg_node;
446 } else { 445 } else {
447 config.init_data = rdata[i].init_data; 446 config.init_data = rdata[i].init_data;
448 config.of_node = rdata[i].of_node; 447 config.of_node = rdata[i].of_node;
diff --git a/drivers/regulator/s5m8767.c b/drivers/regulator/s5m8767.c
index aeb40aad0ae7..d7164bb75d3e 100644
--- a/drivers/regulator/s5m8767.c
+++ b/drivers/regulator/s5m8767.c
@@ -23,6 +23,7 @@
23#include <linux/mfd/samsung/core.h> 23#include <linux/mfd/samsung/core.h>
24#include <linux/mfd/samsung/s5m8767.h> 24#include <linux/mfd/samsung/s5m8767.h>
25#include <linux/regulator/of_regulator.h> 25#include <linux/regulator/of_regulator.h>
26#include <linux/regmap.h>
26 27
27#define S5M8767_OPMODE_NORMAL_MODE 0x1 28#define S5M8767_OPMODE_NORMAL_MODE 0x1
28 29
@@ -120,8 +121,8 @@ static const struct sec_voltage_desc *reg_voltage_map[] = {
120 [S5M8767_BUCK4] = &buck_voltage_val2, 121 [S5M8767_BUCK4] = &buck_voltage_val2,
121 [S5M8767_BUCK5] = &buck_voltage_val1, 122 [S5M8767_BUCK5] = &buck_voltage_val1,
122 [S5M8767_BUCK6] = &buck_voltage_val1, 123 [S5M8767_BUCK6] = &buck_voltage_val1,
123 [S5M8767_BUCK7] = NULL, 124 [S5M8767_BUCK7] = &buck_voltage_val3,
124 [S5M8767_BUCK8] = NULL, 125 [S5M8767_BUCK8] = &buck_voltage_val3,
125 [S5M8767_BUCK9] = &buck_voltage_val3, 126 [S5M8767_BUCK9] = &buck_voltage_val3,
126}; 127};
127 128
@@ -217,7 +218,7 @@ static int s5m8767_reg_is_enabled(struct regulator_dev *rdev)
217{ 218{
218 struct s5m8767_info *s5m8767 = rdev_get_drvdata(rdev); 219 struct s5m8767_info *s5m8767 = rdev_get_drvdata(rdev);
219 int ret, reg; 220 int ret, reg;
220 int mask = 0xc0, enable_ctrl; 221 int enable_ctrl;
221 unsigned int val; 222 unsigned int val;
222 223
223 ret = s5m8767_get_register(rdev, &reg, &enable_ctrl); 224 ret = s5m8767_get_register(rdev, &reg, &enable_ctrl);
@@ -226,37 +227,38 @@ static int s5m8767_reg_is_enabled(struct regulator_dev *rdev)
226 else if (ret) 227 else if (ret)
227 return ret; 228 return ret;
228 229
229 ret = sec_reg_read(s5m8767->iodev, reg, &val); 230 ret = regmap_read(s5m8767->iodev->regmap_pmic, reg, &val);
230 if (ret) 231 if (ret)
231 return ret; 232 return ret;
232 233
233 return (val & mask) == enable_ctrl; 234 return (val & S5M8767_ENCTRL_MASK) == enable_ctrl;
234} 235}
235 236
236static int s5m8767_reg_enable(struct regulator_dev *rdev) 237static int s5m8767_reg_enable(struct regulator_dev *rdev)
237{ 238{
238 struct s5m8767_info *s5m8767 = rdev_get_drvdata(rdev); 239 struct s5m8767_info *s5m8767 = rdev_get_drvdata(rdev);
239 int ret, reg; 240 int ret, reg;
240 int mask = 0xc0, enable_ctrl; 241 int enable_ctrl;
241 242
242 ret = s5m8767_get_register(rdev, &reg, &enable_ctrl); 243 ret = s5m8767_get_register(rdev, &reg, &enable_ctrl);
243 if (ret) 244 if (ret)
244 return ret; 245 return ret;
245 246
246 return sec_reg_update(s5m8767->iodev, reg, enable_ctrl, mask); 247 return regmap_update_bits(s5m8767->iodev->regmap_pmic, reg,
248 S5M8767_ENCTRL_MASK, enable_ctrl);
247} 249}
248 250
249static int s5m8767_reg_disable(struct regulator_dev *rdev) 251static int s5m8767_reg_disable(struct regulator_dev *rdev)
250{ 252{
251 struct s5m8767_info *s5m8767 = rdev_get_drvdata(rdev); 253 struct s5m8767_info *s5m8767 = rdev_get_drvdata(rdev);
252 int ret, reg; 254 int ret, reg, enable_ctrl;
253 int mask = 0xc0, enable_ctrl;
254 255
255 ret = s5m8767_get_register(rdev, &reg, &enable_ctrl); 256 ret = s5m8767_get_register(rdev, &reg, &enable_ctrl);
256 if (ret) 257 if (ret)
257 return ret; 258 return ret;
258 259
259 return sec_reg_update(s5m8767->iodev, reg, ~mask, mask); 260 return regmap_update_bits(s5m8767->iodev->regmap_pmic, reg,
261 S5M8767_ENCTRL_MASK, ~S5M8767_ENCTRL_MASK);
260} 262}
261 263
262static int s5m8767_get_vsel_reg(int reg_id, struct s5m8767_info *s5m8767) 264static int s5m8767_get_vsel_reg(int reg_id, struct s5m8767_info *s5m8767)
@@ -417,9 +419,12 @@ static struct regulator_ops s5m8767_ops = {
417}; 419};
418 420
419static struct regulator_ops s5m8767_buck78_ops = { 421static struct regulator_ops s5m8767_buck78_ops = {
422 .list_voltage = regulator_list_voltage_linear,
420 .is_enabled = s5m8767_reg_is_enabled, 423 .is_enabled = s5m8767_reg_is_enabled,
421 .enable = s5m8767_reg_enable, 424 .enable = s5m8767_reg_enable,
422 .disable = s5m8767_reg_disable, 425 .disable = s5m8767_reg_disable,
426 .get_voltage_sel = regulator_get_voltage_sel_regmap,
427 .set_voltage_sel = regulator_set_voltage_sel_regmap,
423}; 428};
424 429
425#define s5m8767_regulator_desc(_name) { \ 430#define s5m8767_regulator_desc(_name) { \
@@ -745,17 +750,20 @@ static int s5m8767_pmic_probe(struct platform_device *pdev)
745 buck_init = s5m8767_convert_voltage_to_sel(&buck_voltage_val2, 750 buck_init = s5m8767_convert_voltage_to_sel(&buck_voltage_val2,
746 pdata->buck2_init); 751 pdata->buck2_init);
747 752
748 sec_reg_write(s5m8767->iodev, S5M8767_REG_BUCK2DVS2, buck_init); 753 regmap_write(s5m8767->iodev->regmap_pmic, S5M8767_REG_BUCK2DVS2,
754 buck_init);
749 755
750 buck_init = s5m8767_convert_voltage_to_sel(&buck_voltage_val2, 756 buck_init = s5m8767_convert_voltage_to_sel(&buck_voltage_val2,
751 pdata->buck3_init); 757 pdata->buck3_init);
752 758
753 sec_reg_write(s5m8767->iodev, S5M8767_REG_BUCK3DVS2, buck_init); 759 regmap_write(s5m8767->iodev->regmap_pmic, S5M8767_REG_BUCK3DVS2,
760 buck_init);
754 761
755 buck_init = s5m8767_convert_voltage_to_sel(&buck_voltage_val2, 762 buck_init = s5m8767_convert_voltage_to_sel(&buck_voltage_val2,
756 pdata->buck4_init); 763 pdata->buck4_init);
757 764
758 sec_reg_write(s5m8767->iodev, S5M8767_REG_BUCK4DVS2, buck_init); 765 regmap_write(s5m8767->iodev->regmap_pmic, S5M8767_REG_BUCK4DVS2,
766 buck_init);
759 767
760 for (i = 0; i < 8; i++) { 768 for (i = 0; i < 8; i++) {
761 if (s5m8767->buck2_gpiodvs) { 769 if (s5m8767->buck2_gpiodvs) {
@@ -837,71 +845,76 @@ static int s5m8767_pmic_probe(struct platform_device *pdev)
837 845
838 if (pdata->buck2_gpiodvs || pdata->buck3_gpiodvs || 846 if (pdata->buck2_gpiodvs || pdata->buck3_gpiodvs ||
839 pdata->buck4_gpiodvs) { 847 pdata->buck4_gpiodvs) {
840 sec_reg_update(s5m8767->iodev, S5M8767_REG_BUCK2CTRL, 848 regmap_update_bits(s5m8767->iodev->regmap_pmic,
841 (pdata->buck2_gpiodvs) ? (1 << 1) : (0 << 1), 849 S5M8767_REG_BUCK2CTRL, 1 << 1,
842 1 << 1); 850 (pdata->buck2_gpiodvs) ? (1 << 1) : (0 << 1));
843 sec_reg_update(s5m8767->iodev, S5M8767_REG_BUCK3CTRL, 851 regmap_update_bits(s5m8767->iodev->regmap_pmic,
844 (pdata->buck3_gpiodvs) ? (1 << 1) : (0 << 1), 852 S5M8767_REG_BUCK3CTRL, 1 << 1,
845 1 << 1); 853 (pdata->buck3_gpiodvs) ? (1 << 1) : (0 << 1));
846 sec_reg_update(s5m8767->iodev, S5M8767_REG_BUCK4CTRL, 854 regmap_update_bits(s5m8767->iodev->regmap_pmic,
847 (pdata->buck4_gpiodvs) ? (1 << 1) : (0 << 1), 855 S5M8767_REG_BUCK4CTRL, 1 << 1,
848 1 << 1); 856 (pdata->buck4_gpiodvs) ? (1 << 1) : (0 << 1));
849 } 857 }
850 858
851 /* Initialize GPIO DVS registers */ 859 /* Initialize GPIO DVS registers */
852 for (i = 0; i < 8; i++) { 860 for (i = 0; i < 8; i++) {
853 if (s5m8767->buck2_gpiodvs) { 861 if (s5m8767->buck2_gpiodvs) {
854 sec_reg_write(s5m8767->iodev, S5M8767_REG_BUCK2DVS1 + i, 862 regmap_write(s5m8767->iodev->regmap_pmic,
855 s5m8767->buck2_vol[i]); 863 S5M8767_REG_BUCK2DVS1 + i,
864 s5m8767->buck2_vol[i]);
856 } 865 }
857 866
858 if (s5m8767->buck3_gpiodvs) { 867 if (s5m8767->buck3_gpiodvs) {
859 sec_reg_write(s5m8767->iodev, S5M8767_REG_BUCK3DVS1 + i, 868 regmap_write(s5m8767->iodev->regmap_pmic,
860 s5m8767->buck3_vol[i]); 869 S5M8767_REG_BUCK3DVS1 + i,
870 s5m8767->buck3_vol[i]);
861 } 871 }
862 872
863 if (s5m8767->buck4_gpiodvs) { 873 if (s5m8767->buck4_gpiodvs) {
864 sec_reg_write(s5m8767->iodev, S5M8767_REG_BUCK4DVS1 + i, 874 regmap_write(s5m8767->iodev->regmap_pmic,
865 s5m8767->buck4_vol[i]); 875 S5M8767_REG_BUCK4DVS1 + i,
876 s5m8767->buck4_vol[i]);
866 } 877 }
867 } 878 }
868 879
869 if (s5m8767->buck2_ramp) 880 if (s5m8767->buck2_ramp)
870 sec_reg_update(s5m8767->iodev, S5M8767_REG_DVSRAMP, 0x08, 0x08); 881 regmap_update_bits(s5m8767->iodev->regmap_pmic,
882 S5M8767_REG_DVSRAMP, 0x08, 0x08);
871 883
872 if (s5m8767->buck3_ramp) 884 if (s5m8767->buck3_ramp)
873 sec_reg_update(s5m8767->iodev, S5M8767_REG_DVSRAMP, 0x04, 0x04); 885 regmap_update_bits(s5m8767->iodev->regmap_pmic,
886 S5M8767_REG_DVSRAMP, 0x04, 0x04);
874 887
875 if (s5m8767->buck4_ramp) 888 if (s5m8767->buck4_ramp)
876 sec_reg_update(s5m8767->iodev, S5M8767_REG_DVSRAMP, 0x02, 0x02); 889 regmap_update_bits(s5m8767->iodev->regmap_pmic,
890 S5M8767_REG_DVSRAMP, 0x02, 0x02);
877 891
878 if (s5m8767->buck2_ramp || s5m8767->buck3_ramp 892 if (s5m8767->buck2_ramp || s5m8767->buck3_ramp
879 || s5m8767->buck4_ramp) { 893 || s5m8767->buck4_ramp) {
894 unsigned int val;
880 switch (s5m8767->ramp_delay) { 895 switch (s5m8767->ramp_delay) {
881 case 5: 896 case 5:
882 sec_reg_update(s5m8767->iodev, S5M8767_REG_DVSRAMP, 897 val = S5M8767_DVS_BUCK_RAMP_5;
883 0x40, 0xf0);
884 break; 898 break;
885 case 10: 899 case 10:
886 sec_reg_update(s5m8767->iodev, S5M8767_REG_DVSRAMP, 900 val = S5M8767_DVS_BUCK_RAMP_10;
887 0x90, 0xf0);
888 break; 901 break;
889 case 25: 902 case 25:
890 sec_reg_update(s5m8767->iodev, S5M8767_REG_DVSRAMP, 903 val = S5M8767_DVS_BUCK_RAMP_25;
891 0xd0, 0xf0);
892 break; 904 break;
893 case 50: 905 case 50:
894 sec_reg_update(s5m8767->iodev, S5M8767_REG_DVSRAMP, 906 val = S5M8767_DVS_BUCK_RAMP_50;
895 0xe0, 0xf0);
896 break; 907 break;
897 case 100: 908 case 100:
898 sec_reg_update(s5m8767->iodev, S5M8767_REG_DVSRAMP, 909 val = S5M8767_DVS_BUCK_RAMP_100;
899 0xf0, 0xf0);
900 break; 910 break;
901 default: 911 default:
902 sec_reg_update(s5m8767->iodev, S5M8767_REG_DVSRAMP, 912 val = S5M8767_DVS_BUCK_RAMP_10;
903 0x90, 0xf0);
904 } 913 }
914 regmap_update_bits(s5m8767->iodev->regmap_pmic,
915 S5M8767_REG_DVSRAMP,
916 S5M8767_DVS_BUCK_RAMP_MASK,
917 val << S5M8767_DVS_BUCK_RAMP_SHIFT);
905 } 918 }
906 919
907 for (i = 0; i < pdata->num_regulators; i++) { 920 for (i = 0; i < pdata->num_regulators; i++) {
diff --git a/drivers/regulator/stw481x-vmmc.c b/drivers/regulator/stw481x-vmmc.c
index f78857bd6a15..a7e152696a02 100644
--- a/drivers/regulator/stw481x-vmmc.c
+++ b/drivers/regulator/stw481x-vmmc.c
@@ -74,7 +74,8 @@ static int stw481x_vmmc_regulator_probe(struct platform_device *pdev)
74 config.init_data = of_get_regulator_init_data(&pdev->dev, 74 config.init_data = of_get_regulator_init_data(&pdev->dev,
75 pdev->dev.of_node); 75 pdev->dev.of_node);
76 76
77 stw481x->vmmc_regulator = regulator_register(&vmmc_regulator, &config); 77 stw481x->vmmc_regulator = devm_regulator_register(&pdev->dev,
78 &vmmc_regulator, &config);
78 if (IS_ERR(stw481x->vmmc_regulator)) { 79 if (IS_ERR(stw481x->vmmc_regulator)) {
79 dev_err(&pdev->dev, 80 dev_err(&pdev->dev,
80 "error initializing STw481x VMMC regulator\n"); 81 "error initializing STw481x VMMC regulator\n");
@@ -85,14 +86,6 @@ static int stw481x_vmmc_regulator_probe(struct platform_device *pdev)
85 return 0; 86 return 0;
86} 87}
87 88
88static int stw481x_vmmc_regulator_remove(struct platform_device *pdev)
89{
90 struct stw481x *stw481x = dev_get_platdata(&pdev->dev);
91
92 regulator_unregister(stw481x->vmmc_regulator);
93 return 0;
94}
95
96static const struct of_device_id stw481x_vmmc_match[] = { 89static const struct of_device_id stw481x_vmmc_match[] = {
97 { .compatible = "st,stw481x-vmmc", }, 90 { .compatible = "st,stw481x-vmmc", },
98 {}, 91 {},
@@ -105,7 +98,6 @@ static struct platform_driver stw481x_vmmc_regulator_driver = {
105 .of_match_table = stw481x_vmmc_match, 98 .of_match_table = stw481x_vmmc_match,
106 }, 99 },
107 .probe = stw481x_vmmc_regulator_probe, 100 .probe = stw481x_vmmc_regulator_probe,
108 .remove = stw481x_vmmc_regulator_remove,
109}; 101};
110 102
111module_platform_driver(stw481x_vmmc_regulator_driver); 103module_platform_driver(stw481x_vmmc_regulator_driver);
diff --git a/drivers/regulator/tps51632-regulator.c b/drivers/regulator/tps51632-regulator.c
index b0a3f0917a27..b3764f594ee9 100644
--- a/drivers/regulator/tps51632-regulator.c
+++ b/drivers/regulator/tps51632-regulator.c
@@ -70,16 +70,16 @@
70#define TPS51632_POWER_STATE_SINGLE_PHASE_CCM 0x1 70#define TPS51632_POWER_STATE_SINGLE_PHASE_CCM 0x1
71#define TPS51632_POWER_STATE_SINGLE_PHASE_DCM 0x2 71#define TPS51632_POWER_STATE_SINGLE_PHASE_DCM 0x2
72 72
73#define TPS51632_MIN_VOLATGE 500000 73#define TPS51632_MIN_VOLTAGE 500000
74#define TPS51632_MAX_VOLATGE 1520000 74#define TPS51632_MAX_VOLTAGE 1520000
75#define TPS51632_VOLATGE_STEP_10mV 10000 75#define TPS51632_VOLTAGE_STEP_10mV 10000
76#define TPS51632_VOLATGE_STEP_20mV 20000 76#define TPS51632_VOLTAGE_STEP_20mV 20000
77#define TPS51632_MAX_VSEL 0x7F 77#define TPS51632_MAX_VSEL 0x7F
78#define TPS51632_MIN_VSEL 0x19 78#define TPS51632_MIN_VSEL 0x19
79#define TPS51632_DEFAULT_RAMP_DELAY 6000 79#define TPS51632_DEFAULT_RAMP_DELAY 6000
80#define TPS51632_VOLT_VSEL(uV) \ 80#define TPS51632_VOLT_VSEL(uV) \
81 (DIV_ROUND_UP(uV - TPS51632_MIN_VOLATGE, \ 81 (DIV_ROUND_UP(uV - TPS51632_MIN_VOLTAGE, \
82 TPS51632_VOLATGE_STEP_10mV) + \ 82 TPS51632_VOLTAGE_STEP_10mV) + \
83 TPS51632_MIN_VSEL) 83 TPS51632_MIN_VSEL)
84 84
85/* TPS51632 chip information */ 85/* TPS51632 chip information */
@@ -243,9 +243,9 @@ static struct tps51632_regulator_platform_data *
243 pdata->dvfs_step_20mV = of_property_read_bool(np, "ti,dvfs-step-20mV"); 243 pdata->dvfs_step_20mV = of_property_read_bool(np, "ti,dvfs-step-20mV");
244 244
245 pdata->base_voltage_uV = pdata->reg_init_data->constraints.min_uV ? : 245 pdata->base_voltage_uV = pdata->reg_init_data->constraints.min_uV ? :
246 TPS51632_MIN_VOLATGE; 246 TPS51632_MIN_VOLTAGE;
247 pdata->max_voltage_uV = pdata->reg_init_data->constraints.max_uV ? : 247 pdata->max_voltage_uV = pdata->reg_init_data->constraints.max_uV ? :
248 TPS51632_MAX_VOLATGE; 248 TPS51632_MAX_VOLTAGE;
249 return pdata; 249 return pdata;
250} 250}
251#else 251#else
@@ -284,15 +284,15 @@ static int tps51632_probe(struct i2c_client *client,
284 } 284 }
285 285
286 if (pdata->enable_pwm_dvfs) { 286 if (pdata->enable_pwm_dvfs) {
287 if ((pdata->base_voltage_uV < TPS51632_MIN_VOLATGE) || 287 if ((pdata->base_voltage_uV < TPS51632_MIN_VOLTAGE) ||
288 (pdata->base_voltage_uV > TPS51632_MAX_VOLATGE)) { 288 (pdata->base_voltage_uV > TPS51632_MAX_VOLTAGE)) {
289 dev_err(&client->dev, "Invalid base_voltage_uV setting\n"); 289 dev_err(&client->dev, "Invalid base_voltage_uV setting\n");
290 return -EINVAL; 290 return -EINVAL;
291 } 291 }
292 292
293 if ((pdata->max_voltage_uV) && 293 if ((pdata->max_voltage_uV) &&
294 ((pdata->max_voltage_uV < TPS51632_MIN_VOLATGE) || 294 ((pdata->max_voltage_uV < TPS51632_MIN_VOLTAGE) ||
295 (pdata->max_voltage_uV > TPS51632_MAX_VOLATGE))) { 295 (pdata->max_voltage_uV > TPS51632_MAX_VOLTAGE))) {
296 dev_err(&client->dev, "Invalid max_voltage_uV setting\n"); 296 dev_err(&client->dev, "Invalid max_voltage_uV setting\n");
297 return -EINVAL; 297 return -EINVAL;
298 } 298 }
@@ -305,11 +305,11 @@ static int tps51632_probe(struct i2c_client *client,
305 } 305 }
306 306
307 tps->dev = &client->dev; 307 tps->dev = &client->dev;
308 tps->desc.name = id->name; 308 tps->desc.name = client->name;
309 tps->desc.id = 0; 309 tps->desc.id = 0;
310 tps->desc.ramp_delay = TPS51632_DEFAULT_RAMP_DELAY; 310 tps->desc.ramp_delay = TPS51632_DEFAULT_RAMP_DELAY;
311 tps->desc.min_uV = TPS51632_MIN_VOLATGE; 311 tps->desc.min_uV = TPS51632_MIN_VOLTAGE;
312 tps->desc.uV_step = TPS51632_VOLATGE_STEP_10mV; 312 tps->desc.uV_step = TPS51632_VOLTAGE_STEP_10mV;
313 tps->desc.linear_min_sel = TPS51632_MIN_VSEL; 313 tps->desc.linear_min_sel = TPS51632_MIN_VSEL;
314 tps->desc.n_voltages = TPS51632_MAX_VSEL + 1; 314 tps->desc.n_voltages = TPS51632_MAX_VSEL + 1;
315 tps->desc.ops = &tps51632_dcdc_ops; 315 tps->desc.ops = &tps51632_dcdc_ops;
diff --git a/drivers/regulator/tps62360-regulator.c b/drivers/regulator/tps62360-regulator.c
index c2c0185a2dcd..c3fa15a299b1 100644
--- a/drivers/regulator/tps62360-regulator.c
+++ b/drivers/regulator/tps62360-regulator.c
@@ -360,7 +360,7 @@ static int tps62360_probe(struct i2c_client *client,
360 dev_err(&client->dev, "Error: No device match found\n"); 360 dev_err(&client->dev, "Error: No device match found\n");
361 return -ENODEV; 361 return -ENODEV;
362 } 362 }
363 chip_id = (int)match->data; 363 chip_id = (int)(long)match->data;
364 if (!pdata) 364 if (!pdata)
365 pdata = of_get_tps62360_platform_data(&client->dev); 365 pdata = of_get_tps62360_platform_data(&client->dev);
366 } else if (id) { 366 } else if (id) {
diff --git a/drivers/regulator/tps6586x-regulator.c b/drivers/regulator/tps6586x-regulator.c
index e8e3a8afd3e2..0485d47f0d8a 100644
--- a/drivers/regulator/tps6586x-regulator.c
+++ b/drivers/regulator/tps6586x-regulator.c
@@ -93,6 +93,8 @@ static const unsigned int tps6586x_ldo4_voltages[] = {
93 2300000, 2325000, 2350000, 2375000, 2400000, 2425000, 2450000, 2475000, 93 2300000, 2325000, 2350000, 2375000, 2400000, 2425000, 2450000, 2475000,
94}; 94};
95 95
96#define tps658623_sm2_voltages tps6586x_ldo4_voltages
97
96static const unsigned int tps6586x_ldo_voltages[] = { 98static const unsigned int tps6586x_ldo_voltages[] = {
97 1250000, 1500000, 1800000, 2500000, 2700000, 2850000, 3100000, 3300000, 99 1250000, 1500000, 1800000, 2500000, 2700000, 2850000, 3100000, 3300000,
98}; 100};
@@ -104,6 +106,13 @@ static const unsigned int tps6586x_sm2_voltages[] = {
104 4200000, 4250000, 4300000, 4350000, 4400000, 4450000, 4500000, 4550000, 106 4200000, 4250000, 4300000, 4350000, 4400000, 4450000, 4500000, 4550000,
105}; 107};
106 108
109static const unsigned int tps658643_sm2_voltages[] = {
110 1025000, 1050000, 1075000, 1100000, 1125000, 1150000, 1175000, 1200000,
111 1225000, 1250000, 1275000, 1300000, 1325000, 1350000, 1375000, 1400000,
112 1425000, 1450000, 1475000, 1500000, 1525000, 1550000, 1575000, 1600000,
113 1625000, 1650000, 1675000, 1700000, 1725000, 1750000, 1775000, 1800000,
114};
115
107static const unsigned int tps6586x_dvm_voltages[] = { 116static const unsigned int tps6586x_dvm_voltages[] = {
108 725000, 750000, 775000, 800000, 825000, 850000, 875000, 900000, 117 725000, 750000, 775000, 800000, 825000, 850000, 875000, 900000,
109 925000, 950000, 975000, 1000000, 1025000, 1050000, 1075000, 1100000, 118 925000, 950000, 975000, 1000000, 1025000, 1050000, 1075000, 1100000,
@@ -119,8 +128,8 @@ static const unsigned int tps6586x_dvm_voltages[] = {
119 .ops = &tps6586x_regulator_ops, \ 128 .ops = &tps6586x_regulator_ops, \
120 .type = REGULATOR_VOLTAGE, \ 129 .type = REGULATOR_VOLTAGE, \
121 .id = TPS6586X_ID_##_id, \ 130 .id = TPS6586X_ID_##_id, \
122 .n_voltages = ARRAY_SIZE(tps6586x_##vdata##_voltages), \ 131 .n_voltages = ARRAY_SIZE(vdata##_voltages), \
123 .volt_table = tps6586x_##vdata##_voltages, \ 132 .volt_table = vdata##_voltages, \
124 .owner = THIS_MODULE, \ 133 .owner = THIS_MODULE, \
125 .enable_reg = TPS6586X_SUPPLY##ereg0, \ 134 .enable_reg = TPS6586X_SUPPLY##ereg0, \
126 .enable_mask = 1 << (ebit0), \ 135 .enable_mask = 1 << (ebit0), \
@@ -162,27 +171,47 @@ static const unsigned int tps6586x_dvm_voltages[] = {
162 171
163static struct tps6586x_regulator tps6586x_regulator[] = { 172static struct tps6586x_regulator tps6586x_regulator[] = {
164 TPS6586X_SYS_REGULATOR(), 173 TPS6586X_SYS_REGULATOR(),
165 TPS6586X_LDO(LDO_0, "vinldo01", ldo0, SUPPLYV1, 5, 3, ENC, 0, END, 0), 174 TPS6586X_LDO(LDO_0, "vinldo01", tps6586x_ldo0, SUPPLYV1, 5, 3, ENC, 0,
166 TPS6586X_LDO(LDO_3, "vinldo23", ldo, SUPPLYV4, 0, 3, ENC, 2, END, 2), 175 END, 0),
167 TPS6586X_LDO(LDO_5, "REG-SYS", ldo, SUPPLYV6, 0, 3, ENE, 6, ENE, 6), 176 TPS6586X_LDO(LDO_3, "vinldo23", tps6586x_ldo, SUPPLYV4, 0, 3, ENC, 2,
168 TPS6586X_LDO(LDO_6, "vinldo678", ldo, SUPPLYV3, 0, 3, ENC, 4, END, 4), 177 END, 2),
169 TPS6586X_LDO(LDO_7, "vinldo678", ldo, SUPPLYV3, 3, 3, ENC, 5, END, 5), 178 TPS6586X_LDO(LDO_5, "REG-SYS", tps6586x_ldo, SUPPLYV6, 0, 3, ENE, 6,
170 TPS6586X_LDO(LDO_8, "vinldo678", ldo, SUPPLYV2, 5, 3, ENC, 6, END, 6), 179 ENE, 6),
171 TPS6586X_LDO(LDO_9, "vinldo9", ldo, SUPPLYV6, 3, 3, ENE, 7, ENE, 7), 180 TPS6586X_LDO(LDO_6, "vinldo678", tps6586x_ldo, SUPPLYV3, 0, 3, ENC, 4,
172 TPS6586X_LDO(LDO_RTC, "REG-SYS", ldo, SUPPLYV4, 3, 3, V4, 7, V4, 7), 181 END, 4),
173 TPS6586X_LDO(LDO_1, "vinldo01", dvm, SUPPLYV1, 0, 5, ENC, 1, END, 1), 182 TPS6586X_LDO(LDO_7, "vinldo678", tps6586x_ldo, SUPPLYV3, 3, 3, ENC, 5,
174 TPS6586X_LDO(SM_2, "vin-sm2", sm2, SUPPLYV2, 0, 5, ENC, 7, END, 7), 183 END, 5),
175 184 TPS6586X_LDO(LDO_8, "vinldo678", tps6586x_ldo, SUPPLYV2, 5, 3, ENC, 6,
176 TPS6586X_DVM(LDO_2, "vinldo23", dvm, LDO2BV1, 0, 5, ENA, 3, 185 END, 6),
186 TPS6586X_LDO(LDO_9, "vinldo9", tps6586x_ldo, SUPPLYV6, 3, 3, ENE, 7,
187 ENE, 7),
188 TPS6586X_LDO(LDO_RTC, "REG-SYS", tps6586x_ldo, SUPPLYV4, 3, 3, V4, 7,
189 V4, 7),
190 TPS6586X_LDO(LDO_1, "vinldo01", tps6586x_dvm, SUPPLYV1, 0, 5, ENC, 1,
191 END, 1),
192 TPS6586X_LDO(SM_2, "vin-sm2", tps6586x_sm2, SUPPLYV2, 0, 5, ENC, 7,
193 END, 7),
194
195 TPS6586X_DVM(LDO_2, "vinldo23", tps6586x_dvm, LDO2BV1, 0, 5, ENA, 3,
177 ENB, 3, TPS6586X_VCC2, BIT(6)), 196 ENB, 3, TPS6586X_VCC2, BIT(6)),
178 TPS6586X_DVM(LDO_4, "vinldo4", ldo4, LDO4V1, 0, 5, ENC, 3, 197 TPS6586X_DVM(LDO_4, "vinldo4", tps6586x_ldo4, LDO4V1, 0, 5, ENC, 3,
179 END, 3, TPS6586X_VCC1, BIT(6)), 198 END, 3, TPS6586X_VCC1, BIT(6)),
180 TPS6586X_DVM(SM_0, "vin-sm0", dvm, SM0V1, 0, 5, ENA, 1, 199 TPS6586X_DVM(SM_0, "vin-sm0", tps6586x_dvm, SM0V1, 0, 5, ENA, 1,
181 ENB, 1, TPS6586X_VCC1, BIT(2)), 200 ENB, 1, TPS6586X_VCC1, BIT(2)),
182 TPS6586X_DVM(SM_1, "vin-sm1", dvm, SM1V1, 0, 5, ENA, 0, 201 TPS6586X_DVM(SM_1, "vin-sm1", tps6586x_dvm, SM1V1, 0, 5, ENA, 0,
183 ENB, 0, TPS6586X_VCC1, BIT(0)), 202 ENB, 0, TPS6586X_VCC1, BIT(0)),
184}; 203};
185 204
205static struct tps6586x_regulator tps658623_regulator[] = {
206 TPS6586X_LDO(SM_2, "vin-sm2", tps658623_sm2, SUPPLYV2, 0, 5, ENC, 7,
207 END, 7),
208};
209
210static struct tps6586x_regulator tps658643_regulator[] = {
211 TPS6586X_LDO(SM_2, "vin-sm2", tps658643_sm2, SUPPLYV2, 0, 5, ENC, 7,
212 END, 7),
213};
214
186/* 215/*
187 * TPS6586X has 2 enable bits that are OR'ed to determine the actual 216 * TPS6586X has 2 enable bits that are OR'ed to determine the actual
188 * regulator state. Clearing one of this bits allows switching 217 * regulator state. Clearing one of this bits allows switching
@@ -254,11 +283,33 @@ static int tps6586x_regulator_set_slew_rate(struct platform_device *pdev,
254 setting->slew_rate & TPS6586X_SLEW_RATE_MASK); 283 setting->slew_rate & TPS6586X_SLEW_RATE_MASK);
255} 284}
256 285
257static inline struct tps6586x_regulator *find_regulator_info(int id) 286static struct tps6586x_regulator *find_regulator_info(int id, int version)
258{ 287{
259 struct tps6586x_regulator *ri; 288 struct tps6586x_regulator *ri;
289 struct tps6586x_regulator *table = NULL;
290 int num;
260 int i; 291 int i;
261 292
293 switch (version) {
294 case TPS658623:
295 table = tps658623_regulator;
296 num = ARRAY_SIZE(tps658623_regulator);
297 break;
298 case TPS658643:
299 table = tps658643_regulator;
300 num = ARRAY_SIZE(tps658643_regulator);
301 break;
302 }
303
304 /* Search version specific table first */
305 if (table) {
306 for (i = 0; i < num; i++) {
307 ri = &table[i];
308 if (ri->desc.id == id)
309 return ri;
310 }
311 }
312
262 for (i = 0; i < ARRAY_SIZE(tps6586x_regulator); i++) { 313 for (i = 0; i < ARRAY_SIZE(tps6586x_regulator); i++) {
263 ri = &tps6586x_regulator[i]; 314 ri = &tps6586x_regulator[i];
264 if (ri->desc.id == id) 315 if (ri->desc.id == id)
@@ -351,6 +402,7 @@ static int tps6586x_regulator_probe(struct platform_device *pdev)
351 struct regulator_init_data *reg_data; 402 struct regulator_init_data *reg_data;
352 struct tps6586x_platform_data *pdata; 403 struct tps6586x_platform_data *pdata;
353 struct of_regulator_match *tps6586x_reg_matches = NULL; 404 struct of_regulator_match *tps6586x_reg_matches = NULL;
405 int version;
354 int id; 406 int id;
355 int err; 407 int err;
356 408
@@ -373,10 +425,13 @@ static int tps6586x_regulator_probe(struct platform_device *pdev)
373 return -ENOMEM; 425 return -ENOMEM;
374 } 426 }
375 427
428 version = tps6586x_get_version(pdev->dev.parent);
429
376 for (id = 0; id < TPS6586X_ID_MAX_REGULATOR; ++id) { 430 for (id = 0; id < TPS6586X_ID_MAX_REGULATOR; ++id) {
377 reg_data = pdata->reg_init_data[id]; 431 reg_data = pdata->reg_init_data[id];
378 432
379 ri = find_regulator_info(id); 433 ri = find_regulator_info(id, version);
434
380 if (!ri) { 435 if (!ri) {
381 dev_err(&pdev->dev, "invalid regulator ID specified\n"); 436 dev_err(&pdev->dev, "invalid regulator ID specified\n");
382 return -EINVAL; 437 return -EINVAL;
diff --git a/drivers/regulator/tps65910-regulator.c b/drivers/regulator/tps65910-regulator.c
index a00132e31ec7..f50dd847eebc 100644
--- a/drivers/regulator/tps65910-regulator.c
+++ b/drivers/regulator/tps65910-regulator.c
@@ -88,6 +88,11 @@ static const unsigned int VMMC_VSEL_table[] = {
88 1800000, 2800000, 3000000, 3300000, 88 1800000, 2800000, 3000000, 3300000,
89}; 89};
90 90
91/* supported BBCH voltages in microvolts */
92static const unsigned int VBB_VSEL_table[] = {
93 3000000, 2520000, 3150000, 5000000,
94};
95
91struct tps_info { 96struct tps_info {
92 const char *name; 97 const char *name;
93 const char *vin_name; 98 const char *vin_name;
@@ -183,6 +188,12 @@ static struct tps_info tps65910_regs[] = {
183 .voltage_table = VMMC_VSEL_table, 188 .voltage_table = VMMC_VSEL_table,
184 .enable_time_us = 100, 189 .enable_time_us = 100,
185 }, 190 },
191 {
192 .name = "vbb",
193 .vin_name = "vcc7",
194 .n_voltages = ARRAY_SIZE(VBB_VSEL_table),
195 .voltage_table = VBB_VSEL_table,
196 },
186}; 197};
187 198
188static struct tps_info tps65911_regs[] = { 199static struct tps_info tps65911_regs[] = {
@@ -339,6 +350,8 @@ static int tps65910_get_ctrl_register(int id)
339 return TPS65910_VAUX33; 350 return TPS65910_VAUX33;
340 case TPS65910_REG_VMMC: 351 case TPS65910_REG_VMMC:
341 return TPS65910_VMMC; 352 return TPS65910_VMMC;
353 case TPS65910_REG_VBB:
354 return TPS65910_BBCH;
342 default: 355 default:
343 return -EINVAL; 356 return -EINVAL;
344 } 357 }
@@ -528,6 +541,10 @@ static int tps65910_get_voltage_sel(struct regulator_dev *dev)
528 value &= LDO_SEL_MASK; 541 value &= LDO_SEL_MASK;
529 value >>= LDO_SEL_SHIFT; 542 value >>= LDO_SEL_SHIFT;
530 break; 543 break;
544 case TPS65910_REG_VBB:
545 value &= BBCH_BBSEL_MASK;
546 value >>= BBCH_BBSEL_SHIFT;
547 break;
531 default: 548 default:
532 return -EINVAL; 549 return -EINVAL;
533 } 550 }
@@ -638,6 +655,9 @@ static int tps65910_set_voltage_sel(struct regulator_dev *dev,
638 case TPS65910_REG_VMMC: 655 case TPS65910_REG_VMMC:
639 return tps65910_reg_update_bits(pmic->mfd, reg, LDO_SEL_MASK, 656 return tps65910_reg_update_bits(pmic->mfd, reg, LDO_SEL_MASK,
640 selector << LDO_SEL_SHIFT); 657 selector << LDO_SEL_SHIFT);
658 case TPS65910_REG_VBB:
659 return tps65910_reg_update_bits(pmic->mfd, reg, BBCH_BBSEL_MASK,
660 selector << BBCH_BBSEL_SHIFT);
641 } 661 }
642 662
643 return -EINVAL; 663 return -EINVAL;
@@ -669,6 +689,9 @@ static int tps65911_set_voltage_sel(struct regulator_dev *dev,
669 case TPS65910_REG_VIO: 689 case TPS65910_REG_VIO:
670 return tps65910_reg_update_bits(pmic->mfd, reg, LDO_SEL_MASK, 690 return tps65910_reg_update_bits(pmic->mfd, reg, LDO_SEL_MASK,
671 selector << LDO_SEL_SHIFT); 691 selector << LDO_SEL_SHIFT);
692 case TPS65910_REG_VBB:
693 return tps65910_reg_update_bits(pmic->mfd, reg, BBCH_BBSEL_MASK,
694 selector << BBCH_BBSEL_SHIFT);
672 } 695 }
673 696
674 return -EINVAL; 697 return -EINVAL;
@@ -762,6 +785,18 @@ static struct regulator_ops tps65910_ops_vdd3 = {
762 .map_voltage = regulator_map_voltage_ascend, 785 .map_voltage = regulator_map_voltage_ascend,
763}; 786};
764 787
788static struct regulator_ops tps65910_ops_vbb = {
789 .is_enabled = regulator_is_enabled_regmap,
790 .enable = regulator_enable_regmap,
791 .disable = regulator_disable_regmap,
792 .set_mode = tps65910_set_mode,
793 .get_mode = tps65910_get_mode,
794 .get_voltage_sel = tps65910_get_voltage_sel,
795 .set_voltage_sel = tps65910_set_voltage_sel,
796 .list_voltage = regulator_list_voltage_table,
797 .map_voltage = regulator_map_voltage_iterate,
798};
799
765static struct regulator_ops tps65910_ops = { 800static struct regulator_ops tps65910_ops = {
766 .is_enabled = regulator_is_enabled_regmap, 801 .is_enabled = regulator_is_enabled_regmap,
767 .enable = regulator_enable_regmap, 802 .enable = regulator_enable_regmap,
@@ -944,6 +979,7 @@ static struct of_regulator_match tps65910_matches[] = {
944 { .name = "vaux2", .driver_data = (void *) &tps65910_regs[10] }, 979 { .name = "vaux2", .driver_data = (void *) &tps65910_regs[10] },
945 { .name = "vaux33", .driver_data = (void *) &tps65910_regs[11] }, 980 { .name = "vaux33", .driver_data = (void *) &tps65910_regs[11] },
946 { .name = "vmmc", .driver_data = (void *) &tps65910_regs[12] }, 981 { .name = "vmmc", .driver_data = (void *) &tps65910_regs[12] },
982 { .name = "vbb", .driver_data = (void *) &tps65910_regs[13] },
947}; 983};
948 984
949static struct of_regulator_match tps65911_matches[] = { 985static struct of_regulator_match tps65911_matches[] = {
@@ -1145,6 +1181,10 @@ static int tps65910_probe(struct platform_device *pdev)
1145 pmic->desc[i].ops = &tps65910_ops_dcdc; 1181 pmic->desc[i].ops = &tps65910_ops_dcdc;
1146 pmic->desc[i].ramp_delay = 5000; 1182 pmic->desc[i].ramp_delay = 5000;
1147 } 1183 }
1184 } else if (i == TPS65910_REG_VBB &&
1185 tps65910_chip_id(tps65910) == TPS65910) {
1186 pmic->desc[i].ops = &tps65910_ops_vbb;
1187 pmic->desc[i].volt_table = info->voltage_table;
1148 } else { 1188 } else {
1149 if (tps65910_chip_id(tps65910) == TPS65910) { 1189 if (tps65910_chip_id(tps65910) == TPS65910) {
1150 pmic->desc[i].ops = &tps65910_ops; 1190 pmic->desc[i].ops = &tps65910_ops;
diff --git a/drivers/regulator/twl-regulator.c b/drivers/regulator/twl-regulator.c
index 8ebd785485c7..fed28abef419 100644
--- a/drivers/regulator/twl-regulator.c
+++ b/drivers/regulator/twl-regulator.c
@@ -58,7 +58,7 @@ struct twlreg_info {
58 struct regulator_desc desc; 58 struct regulator_desc desc;
59 59
60 /* chip specific features */ 60 /* chip specific features */
61 unsigned long features; 61 unsigned long features;
62 62
63 /* 63 /*
64 * optional override functions for voltage set/get 64 * optional override functions for voltage set/get
@@ -1128,7 +1128,7 @@ static int twlreg_probe(struct platform_device *pdev)
1128 if (!initdata) 1128 if (!initdata)
1129 return -EINVAL; 1129 return -EINVAL;
1130 1130
1131 info = kmemdup(template, sizeof (*info), GFP_KERNEL); 1131 info = kmemdup(template, sizeof(*info), GFP_KERNEL);
1132 if (!info) 1132 if (!info)
1133 return -ENOMEM; 1133 return -ENOMEM;
1134 1134
diff --git a/drivers/regulator/wm831x-dcdc.c b/drivers/regulator/wm831x-dcdc.c
index 6823e6f2b88a..04cf9c16ef23 100644
--- a/drivers/regulator/wm831x-dcdc.c
+++ b/drivers/regulator/wm831x-dcdc.c
@@ -762,8 +762,7 @@ static int wm831x_boostp_probe(struct platform_device *pdev)
762 res = platform_get_resource(pdev, IORESOURCE_REG, 0); 762 res = platform_get_resource(pdev, IORESOURCE_REG, 0);
763 if (res == NULL) { 763 if (res == NULL) {
764 dev_err(&pdev->dev, "No REG resource\n"); 764 dev_err(&pdev->dev, "No REG resource\n");
765 ret = -EINVAL; 765 return -EINVAL;
766 goto err;
767 } 766 }
768 dcdc->base = res->start; 767 dcdc->base = res->start;
769 768
@@ -788,7 +787,7 @@ static int wm831x_boostp_probe(struct platform_device *pdev)
788 ret = PTR_ERR(dcdc->regulator); 787 ret = PTR_ERR(dcdc->regulator);
789 dev_err(wm831x->dev, "Failed to register DCDC%d: %d\n", 788 dev_err(wm831x->dev, "Failed to register DCDC%d: %d\n",
790 id + 1, ret); 789 id + 1, ret);
791 goto err; 790 return ret;
792 } 791 }
793 792
794 irq = wm831x_irq(wm831x, platform_get_irq_byname(pdev, "UV")); 793 irq = wm831x_irq(wm831x, platform_get_irq_byname(pdev, "UV"));
@@ -799,15 +798,12 @@ static int wm831x_boostp_probe(struct platform_device *pdev)
799 if (ret != 0) { 798 if (ret != 0) {
800 dev_err(&pdev->dev, "Failed to request UV IRQ %d: %d\n", 799 dev_err(&pdev->dev, "Failed to request UV IRQ %d: %d\n",
801 irq, ret); 800 irq, ret);
802 goto err; 801 return ret;
803 } 802 }
804 803
805 platform_set_drvdata(pdev, dcdc); 804 platform_set_drvdata(pdev, dcdc);
806 805
807 return 0; 806 return 0;
808
809err:
810 return ret;
811} 807}
812 808
813static struct platform_driver wm831x_boostp_driver = { 809static struct platform_driver wm831x_boostp_driver = {
generated by cgit v1.2.2 (git 2.25.0) at 2026-05-27 05:04:44 -0400