2 * Regulator driver for tps65090 power management chip.
4 * Copyright (c) 2012, NVIDIA CORPORATION. All rights reserved.
6 * This program is free software; you can redistribute it and/or modify it
7 * under the terms and conditions of the GNU General Public License,
8 * version 2, as published by the Free Software Foundation.
10 * This program is distributed in the hope it will be useful, but WITHOUT
11 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
12 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
15 * You should have received a copy of the GNU General Public License
16 * along with this program. If not, see <http://www.gnu.org/licenses/>
19 #include <linux/module.h>
20 #include <linux/init.h>
21 #include <linux/gpio.h>
22 #include <linux/of_gpio.h>
23 #include <linux/slab.h>
24 #include <linux/err.h>
25 #include <linux/platform_device.h>
26 #include <linux/regulator/driver.h>
27 #include <linux/regulator/machine.h>
28 #include <linux/regulator/of_regulator.h>
29 #include <linux/mfd/tps65090.h>
31 struct tps65090_regulator
{
33 struct regulator_desc
*desc
;
34 struct regulator_dev
*rdev
;
37 static struct regulator_ops tps65090_ext_control_ops
= {
40 static struct regulator_ops tps65090_reg_contol_ops
= {
41 .enable
= regulator_enable_regmap
,
42 .disable
= regulator_disable_regmap
,
43 .is_enabled
= regulator_is_enabled_regmap
,
46 static struct regulator_ops tps65090_ldo_ops
= {
49 #define tps65090_REG_DESC(_id, _sname, _en_reg, _ops) \
51 .name = "TPS65090_RAILS"#_id, \
52 .supply_name = _sname, \
53 .id = TPS65090_REGULATOR_##_id, \
55 .enable_reg = _en_reg, \
56 .enable_mask = BIT(0), \
57 .type = REGULATOR_VOLTAGE, \
58 .owner = THIS_MODULE, \
61 static struct regulator_desc tps65090_regulator_desc
[] = {
62 tps65090_REG_DESC(DCDC1
, "vsys1", 0x0C, tps65090_reg_contol_ops
),
63 tps65090_REG_DESC(DCDC2
, "vsys2", 0x0D, tps65090_reg_contol_ops
),
64 tps65090_REG_DESC(DCDC3
, "vsys3", 0x0E, tps65090_reg_contol_ops
),
65 tps65090_REG_DESC(FET1
, "infet1", 0x0F, tps65090_reg_contol_ops
),
66 tps65090_REG_DESC(FET2
, "infet2", 0x10, tps65090_reg_contol_ops
),
67 tps65090_REG_DESC(FET3
, "infet3", 0x11, tps65090_reg_contol_ops
),
68 tps65090_REG_DESC(FET4
, "infet4", 0x12, tps65090_reg_contol_ops
),
69 tps65090_REG_DESC(FET5
, "infet5", 0x13, tps65090_reg_contol_ops
),
70 tps65090_REG_DESC(FET6
, "infet6", 0x14, tps65090_reg_contol_ops
),
71 tps65090_REG_DESC(FET7
, "infet7", 0x15, tps65090_reg_contol_ops
),
72 tps65090_REG_DESC(LDO1
, "vsys-l1", 0, tps65090_ldo_ops
),
73 tps65090_REG_DESC(LDO2
, "vsys-l2", 0, tps65090_ldo_ops
),
76 static inline bool is_dcdc(int id
)
79 case TPS65090_REGULATOR_DCDC1
:
80 case TPS65090_REGULATOR_DCDC2
:
81 case TPS65090_REGULATOR_DCDC3
:
88 static int tps65090_config_ext_control(
89 struct tps65090_regulator
*ri
, bool enable
)
92 struct device
*parent
= ri
->dev
->parent
;
93 unsigned int reg_en_reg
= ri
->desc
->enable_reg
;
96 ret
= tps65090_set_bits(parent
, reg_en_reg
, 1);
98 ret
= tps65090_clr_bits(parent
, reg_en_reg
, 1);
100 dev_err(ri
->dev
, "Error in updating reg 0x%x\n", reg_en_reg
);
104 static int tps65090_regulator_disable_ext_control(
105 struct tps65090_regulator
*ri
,
106 struct tps65090_regulator_plat_data
*tps_pdata
)
109 struct device
*parent
= ri
->dev
->parent
;
110 unsigned int reg_en_reg
= ri
->desc
->enable_reg
;
113 * First enable output for internal control if require.
114 * And then disable external control.
116 if (tps_pdata
->reg_init_data
->constraints
.always_on
||
117 tps_pdata
->reg_init_data
->constraints
.boot_on
) {
118 ret
= tps65090_set_bits(parent
, reg_en_reg
, 0);
120 dev_err(ri
->dev
, "Error in set reg 0x%x\n", reg_en_reg
);
124 return tps65090_config_ext_control(ri
, false);
127 static void tps65090_configure_regulator_config(
128 struct tps65090_regulator_plat_data
*tps_pdata
,
129 struct regulator_config
*config
)
131 if (gpio_is_valid(tps_pdata
->gpio
)) {
132 int gpio_flag
= GPIOF_OUT_INIT_LOW
;
134 if (tps_pdata
->reg_init_data
->constraints
.always_on
||
135 tps_pdata
->reg_init_data
->constraints
.boot_on
)
136 gpio_flag
= GPIOF_OUT_INIT_HIGH
;
138 config
->ena_gpio
= tps_pdata
->gpio
;
139 config
->ena_gpio_flags
= gpio_flag
;
144 static struct of_regulator_match tps65090_matches
[] = {
145 { .name
= "dcdc1", },
146 { .name
= "dcdc2", },
147 { .name
= "dcdc3", },
159 static struct tps65090_platform_data
*tps65090_parse_dt_reg_data(
160 struct platform_device
*pdev
,
161 struct of_regulator_match
**tps65090_reg_matches
)
163 struct tps65090_platform_data
*tps65090_pdata
;
164 struct device_node
*np
= pdev
->dev
.parent
->of_node
;
165 struct device_node
*regulators
;
167 struct tps65090_regulator_plat_data
*reg_pdata
;
169 tps65090_pdata
= devm_kzalloc(&pdev
->dev
, sizeof(*tps65090_pdata
),
172 return ERR_PTR(-ENOMEM
);
174 reg_pdata
= devm_kzalloc(&pdev
->dev
, TPS65090_REGULATOR_MAX
*
175 sizeof(*reg_pdata
), GFP_KERNEL
);
177 return ERR_PTR(-ENOMEM
);
179 regulators
= of_get_child_by_name(np
, "regulators");
181 dev_err(&pdev
->dev
, "regulator node not found\n");
182 return ERR_PTR(-ENODEV
);
185 ret
= of_regulator_match(&pdev
->dev
, regulators
, tps65090_matches
,
186 ARRAY_SIZE(tps65090_matches
));
187 of_node_put(regulators
);
190 "Error parsing regulator init data: %d\n", ret
);
194 *tps65090_reg_matches
= tps65090_matches
;
195 for (idx
= 0; idx
< ARRAY_SIZE(tps65090_matches
); idx
++) {
196 struct regulator_init_data
*ri_data
;
197 struct tps65090_regulator_plat_data
*rpdata
;
199 rpdata
= ®_pdata
[idx
];
200 ri_data
= tps65090_matches
[idx
].init_data
;
201 if (!ri_data
|| !tps65090_matches
[idx
].of_node
)
204 rpdata
->reg_init_data
= ri_data
;
205 rpdata
->enable_ext_control
= of_property_read_bool(
206 tps65090_matches
[idx
].of_node
,
207 "ti,enable-ext-control");
208 if (rpdata
->enable_ext_control
)
209 rpdata
->gpio
= of_get_named_gpio(np
,
210 "dcdc-ext-control-gpios", 0);
212 tps65090_pdata
->reg_pdata
[idx
] = rpdata
;
214 return tps65090_pdata
;
217 static inline struct tps65090_platform_data
*tps65090_parse_dt_reg_data(
218 struct platform_device
*pdev
,
219 struct of_regulator_match
**tps65090_reg_matches
)
221 *tps65090_reg_matches
= NULL
;
226 static int tps65090_regulator_probe(struct platform_device
*pdev
)
228 struct tps65090
*tps65090_mfd
= dev_get_drvdata(pdev
->dev
.parent
);
229 struct tps65090_regulator
*ri
= NULL
;
230 struct regulator_config config
= { };
231 struct regulator_dev
*rdev
;
232 struct tps65090_regulator_plat_data
*tps_pdata
;
233 struct tps65090_regulator
*pmic
;
234 struct tps65090_platform_data
*tps65090_pdata
;
235 struct of_regulator_match
*tps65090_reg_matches
= NULL
;
239 dev_dbg(&pdev
->dev
, "Probing regulator\n");
241 tps65090_pdata
= dev_get_platdata(pdev
->dev
.parent
);
242 if (!tps65090_pdata
&& tps65090_mfd
->dev
->of_node
)
243 tps65090_pdata
= tps65090_parse_dt_reg_data(pdev
,
244 &tps65090_reg_matches
);
245 if (IS_ERR_OR_NULL(tps65090_pdata
)) {
246 dev_err(&pdev
->dev
, "Platform data missing\n");
247 return tps65090_pdata
? PTR_ERR(tps65090_pdata
) : -EINVAL
;
250 pmic
= devm_kzalloc(&pdev
->dev
, TPS65090_REGULATOR_MAX
* sizeof(*pmic
),
255 for (num
= 0; num
< TPS65090_REGULATOR_MAX
; num
++) {
256 tps_pdata
= tps65090_pdata
->reg_pdata
[num
];
259 ri
->dev
= &pdev
->dev
;
260 ri
->desc
= &tps65090_regulator_desc
[num
];
263 * TPS5090 DCDC support the control from external digital input.
264 * Configure it as per platform data.
266 if (tps_pdata
&& is_dcdc(num
) && tps_pdata
->reg_init_data
) {
267 if (tps_pdata
->enable_ext_control
) {
268 tps65090_configure_regulator_config(
270 ri
->desc
->ops
= &tps65090_ext_control_ops
;
272 ret
= tps65090_regulator_disable_ext_control(
276 "failed disable ext control\n");
282 config
.dev
= pdev
->dev
.parent
;
283 config
.driver_data
= ri
;
284 config
.regmap
= tps65090_mfd
->rmap
;
286 config
.init_data
= tps_pdata
->reg_init_data
;
288 config
.init_data
= NULL
;
289 if (tps65090_reg_matches
)
290 config
.of_node
= tps65090_reg_matches
[num
].of_node
;
292 config
.of_node
= NULL
;
294 rdev
= devm_regulator_register(&pdev
->dev
, ri
->desc
, &config
);
296 dev_err(&pdev
->dev
, "failed to register regulator %s\n",
298 return PTR_ERR(rdev
);
302 /* Enable external control if it is require */
303 if (tps_pdata
&& is_dcdc(num
) && tps_pdata
->reg_init_data
&&
304 tps_pdata
->enable_ext_control
) {
305 ret
= tps65090_config_ext_control(ri
, true);
311 platform_set_drvdata(pdev
, pmic
);
315 static struct platform_driver tps65090_regulator_driver
= {
317 .name
= "tps65090-pmic",
318 .owner
= THIS_MODULE
,
320 .probe
= tps65090_regulator_probe
,
323 static int __init
tps65090_regulator_init(void)
325 return platform_driver_register(&tps65090_regulator_driver
);
327 subsys_initcall(tps65090_regulator_init
);
329 static void __exit
tps65090_regulator_exit(void)
331 platform_driver_unregister(&tps65090_regulator_driver
);
333 module_exit(tps65090_regulator_exit
);
335 MODULE_DESCRIPTION("tps65090 regulator driver");
336 MODULE_AUTHOR("Venu Byravarasu <vbyravarasu@nvidia.com>");
337 MODULE_LICENSE("GPL v2");
338 MODULE_ALIAS("platform:tps65090-pmic");