1 /*
2  * max14577.c - Regulator driver for the Maxim 14577/77836
3  *
4  * Copyright (C) 2013,2014 Samsung Electronics
5  * Krzysztof Kozlowski <krzk@kernel.org>
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 
25 static int max14577_reg_is_enabled(struct regulator_dev *rdev)
26 {
27 	int rid = rdev_get_id(rdev);
28 	struct regmap *rmap = rdev->regmap;
29 	u8 reg_data;
30 
31 	switch (rid) {
32 	case MAX14577_CHARGER:
33 		max14577_read_reg(rmap, MAX14577_CHG_REG_CHG_CTRL2, &reg_data);
34 		if ((reg_data & CHGCTRL2_MBCHOSTEN_MASK) == 0)
35 			return 0;
36 		max14577_read_reg(rmap, MAX14577_CHG_REG_STATUS3, &reg_data);
37 		if ((reg_data & STATUS3_CGMBC_MASK) == 0)
38 			return 0;
39 		/* MBCHOSTEN and CGMBC are on */
40 		return 1;
41 	default:
42 		return -EINVAL;
43 	}
44 }
45 
46 static int max14577_reg_get_current_limit(struct regulator_dev *rdev)
47 {
48 	u8 reg_data;
49 	struct regmap *rmap = rdev->regmap;
50 	struct max14577 *max14577 = rdev_get_drvdata(rdev);
51 	const struct maxim_charger_current *limits =
52 		&maxim_charger_currents[max14577->dev_type];
53 
54 	if (rdev_get_id(rdev) != MAX14577_CHARGER)
55 		return -EINVAL;
56 
57 	max14577_read_reg(rmap, MAX14577_CHG_REG_CHG_CTRL4, &reg_data);
58 
59 	if ((reg_data & CHGCTRL4_MBCICHWRCL_MASK) == 0)
60 		return limits->min;
61 
62 	reg_data = ((reg_data & CHGCTRL4_MBCICHWRCH_MASK) >>
63 			CHGCTRL4_MBCICHWRCH_SHIFT);
64 	return limits->high_start + reg_data * limits->high_step;
65 }
66 
67 static int max14577_reg_set_current_limit(struct regulator_dev *rdev,
68 		int min_uA, int max_uA)
69 {
70 	u8 reg_data;
71 	int ret;
72 	struct max14577 *max14577 = rdev_get_drvdata(rdev);
73 	const struct maxim_charger_current *limits =
74 		&maxim_charger_currents[max14577->dev_type];
75 
76 	if (rdev_get_id(rdev) != MAX14577_CHARGER)
77 		return -EINVAL;
78 
79 	ret = maxim_charger_calc_reg_current(limits, min_uA, max_uA, &reg_data);
80 	if (ret)
81 		return ret;
82 
83 	return max14577_update_reg(rdev->regmap, MAX14577_CHG_REG_CHG_CTRL4,
84 			CHGCTRL4_MBCICHWRCL_MASK | CHGCTRL4_MBCICHWRCH_MASK,
85 			reg_data);
86 }
87 
88 static const struct regulator_ops max14577_safeout_ops = {
89 	.is_enabled		= regulator_is_enabled_regmap,
90 	.enable			= regulator_enable_regmap,
91 	.disable		= regulator_disable_regmap,
92 	.list_voltage		= regulator_list_voltage_linear,
93 };
94 
95 static const struct regulator_ops max14577_charger_ops = {
96 	.is_enabled		= max14577_reg_is_enabled,
97 	.enable			= regulator_enable_regmap,
98 	.disable		= regulator_disable_regmap,
99 	.get_current_limit	= max14577_reg_get_current_limit,
100 	.set_current_limit	= max14577_reg_set_current_limit,
101 };
102 
103 #define MAX14577_SAFEOUT_REG	{ \
104 	.name		= "SAFEOUT", \
105 	.of_match	= of_match_ptr("SAFEOUT"), \
106 	.regulators_node = of_match_ptr("regulators"), \
107 	.id		= MAX14577_SAFEOUT, \
108 	.ops		= &max14577_safeout_ops, \
109 	.type		= REGULATOR_VOLTAGE, \
110 	.owner		= THIS_MODULE, \
111 	.n_voltages	= 1, \
112 	.min_uV		= MAX14577_REGULATOR_SAFEOUT_VOLTAGE, \
113 	.enable_reg	= MAX14577_REG_CONTROL2, \
114 	.enable_mask	= CTRL2_SFOUTORD_MASK, \
115 }
116 #define MAX14577_CHARGER_REG	{ \
117 	.name		= "CHARGER", \
118 	.of_match	= of_match_ptr("CHARGER"), \
119 	.regulators_node = of_match_ptr("regulators"), \
120 	.id		= MAX14577_CHARGER, \
121 	.ops		= &max14577_charger_ops, \
122 	.type		= REGULATOR_CURRENT, \
123 	.owner		= THIS_MODULE, \
124 	.enable_reg	= MAX14577_CHG_REG_CHG_CTRL2, \
125 	.enable_mask	= CHGCTRL2_MBCHOSTEN_MASK, \
126 }
127 
128 static const struct regulator_desc max14577_supported_regulators[] = {
129 	[MAX14577_SAFEOUT] = MAX14577_SAFEOUT_REG,
130 	[MAX14577_CHARGER] = MAX14577_CHARGER_REG,
131 };
132 
133 static const struct regulator_ops max77836_ldo_ops = {
134 	.is_enabled		= regulator_is_enabled_regmap,
135 	.enable			= regulator_enable_regmap,
136 	.disable		= regulator_disable_regmap,
137 	.list_voltage		= regulator_list_voltage_linear,
138 	.map_voltage		= regulator_map_voltage_linear,
139 	.get_voltage_sel	= regulator_get_voltage_sel_regmap,
140 	.set_voltage_sel	= regulator_set_voltage_sel_regmap,
141 	/* TODO: add .set_suspend_mode */
142 };
143 
144 #define MAX77836_LDO_REG(num)	{ \
145 	.name		= "LDO" # num, \
146 	.of_match	= of_match_ptr("LDO" # num), \
147 	.regulators_node = of_match_ptr("regulators"), \
148 	.id		= MAX77836_LDO ## num, \
149 	.ops		= &max77836_ldo_ops, \
150 	.type		= REGULATOR_VOLTAGE, \
151 	.owner		= THIS_MODULE, \
152 	.n_voltages	= MAX77836_REGULATOR_LDO_VOLTAGE_STEPS_NUM, \
153 	.min_uV		= MAX77836_REGULATOR_LDO_VOLTAGE_MIN, \
154 	.uV_step	= MAX77836_REGULATOR_LDO_VOLTAGE_STEP, \
155 	.enable_reg	= MAX77836_LDO_REG_CNFG1_LDO ## num, \
156 	.enable_mask	= MAX77836_CNFG1_LDO_PWRMD_MASK, \
157 	.vsel_reg	= MAX77836_LDO_REG_CNFG1_LDO ## num, \
158 	.vsel_mask	= MAX77836_CNFG1_LDO_TV_MASK, \
159 }
160 
161 static const struct regulator_desc max77836_supported_regulators[] = {
162 	[MAX14577_SAFEOUT] = MAX14577_SAFEOUT_REG,
163 	[MAX14577_CHARGER] = MAX14577_CHARGER_REG,
164 	[MAX77836_LDO1] = MAX77836_LDO_REG(1),
165 	[MAX77836_LDO2] = MAX77836_LDO_REG(2),
166 };
167 
168 #ifdef CONFIG_OF
169 static struct of_regulator_match max14577_regulator_matches[] = {
170 	{ .name	= "SAFEOUT", },
171 	{ .name = "CHARGER", },
172 };
173 
174 static struct of_regulator_match max77836_regulator_matches[] = {
175 	{ .name	= "SAFEOUT", },
176 	{ .name = "CHARGER", },
177 	{ .name = "LDO1", },
178 	{ .name = "LDO2", },
179 };
180 
181 static inline struct regulator_init_data *match_init_data(int index,
182 		enum maxim_device_type dev_type)
183 {
184 	switch (dev_type) {
185 	case MAXIM_DEVICE_TYPE_MAX77836:
186 		return max77836_regulator_matches[index].init_data;
187 
188 	case MAXIM_DEVICE_TYPE_MAX14577:
189 	default:
190 		return max14577_regulator_matches[index].init_data;
191 	}
192 }
193 
194 static inline struct device_node *match_of_node(int index,
195 		enum maxim_device_type dev_type)
196 {
197 	switch (dev_type) {
198 	case MAXIM_DEVICE_TYPE_MAX77836:
199 		return max77836_regulator_matches[index].of_node;
200 
201 	case MAXIM_DEVICE_TYPE_MAX14577:
202 	default:
203 		return max14577_regulator_matches[index].of_node;
204 	}
205 }
206 #else /* CONFIG_OF */
207 static inline struct regulator_init_data *match_init_data(int index,
208 		enum maxim_device_type dev_type)
209 {
210 	return NULL;
211 }
212 
213 static inline struct device_node *match_of_node(int index,
214 		enum maxim_device_type dev_type)
215 {
216 	return NULL;
217 }
218 #endif /* CONFIG_OF */
219 
220 /**
221  * Registers for regulators of max77836 use different I2C slave addresses so
222  * different regmaps must be used for them.
223  *
224  * Returns proper regmap for accessing regulator passed by id.
225  */
226 static struct regmap *max14577_get_regmap(struct max14577 *max14577,
227 		int reg_id)
228 {
229 	switch (max14577->dev_type) {
230 	case MAXIM_DEVICE_TYPE_MAX77836:
231 		switch (reg_id) {
232 		case MAX77836_SAFEOUT ... MAX77836_CHARGER:
233 			return max14577->regmap;
234 		default:
235 			/* MAX77836_LDO1 ... MAX77836_LDO2 */
236 			return max14577->regmap_pmic;
237 		}
238 
239 	case MAXIM_DEVICE_TYPE_MAX14577:
240 	default:
241 		return max14577->regmap;
242 	}
243 }
244 
245 static int max14577_regulator_probe(struct platform_device *pdev)
246 {
247 	struct max14577 *max14577 = dev_get_drvdata(pdev->dev.parent);
248 	struct max14577_platform_data *pdata = dev_get_platdata(max14577->dev);
249 	int i, ret = 0;
250 	struct regulator_config config = {};
251 	const struct regulator_desc *supported_regulators;
252 	unsigned int supported_regulators_size;
253 	enum maxim_device_type dev_type = max14577->dev_type;
254 
255 	switch (dev_type) {
256 	case MAXIM_DEVICE_TYPE_MAX77836:
257 		supported_regulators = max77836_supported_regulators;
258 		supported_regulators_size = ARRAY_SIZE(max77836_supported_regulators);
259 		break;
260 	case MAXIM_DEVICE_TYPE_MAX14577:
261 	default:
262 		supported_regulators = max14577_supported_regulators;
263 		supported_regulators_size = ARRAY_SIZE(max14577_supported_regulators);
264 	}
265 
266 	config.dev = max14577->dev;
267 	config.driver_data = max14577;
268 
269 	for (i = 0; i < supported_regulators_size; i++) {
270 		struct regulator_dev *regulator;
271 		/*
272 		 * Index of supported_regulators[] is also the id and must
273 		 * match index of pdata->regulators[].
274 		 */
275 		if (pdata && pdata->regulators) {
276 			config.init_data = pdata->regulators[i].initdata;
277 			config.of_node = pdata->regulators[i].of_node;
278 		} else {
279 			config.init_data = match_init_data(i, dev_type);
280 			config.of_node = match_of_node(i, dev_type);
281 		}
282 		config.regmap = max14577_get_regmap(max14577,
283 				supported_regulators[i].id);
284 
285 		regulator = devm_regulator_register(&pdev->dev,
286 				&supported_regulators[i], &config);
287 		if (IS_ERR(regulator)) {
288 			ret = PTR_ERR(regulator);
289 			dev_err(&pdev->dev,
290 					"Regulator init failed for %d/%s with error: %d\n",
291 					i, supported_regulators[i].name, ret);
292 			return ret;
293 		}
294 	}
295 
296 	return ret;
297 }
298 
299 static const struct platform_device_id max14577_regulator_id[] = {
300 	{ "max14577-regulator", MAXIM_DEVICE_TYPE_MAX14577, },
301 	{ "max77836-regulator", MAXIM_DEVICE_TYPE_MAX77836, },
302 	{ }
303 };
304 MODULE_DEVICE_TABLE(platform, max14577_regulator_id);
305 
306 static struct platform_driver max14577_regulator_driver = {
307 	.driver = {
308 		   .name = "max14577-regulator",
309 		   },
310 	.probe		= max14577_regulator_probe,
311 	.id_table	= max14577_regulator_id,
312 };
313 
314 static int __init max14577_regulator_init(void)
315 {
316 	BUILD_BUG_ON(ARRAY_SIZE(max14577_supported_regulators) != MAX14577_REGULATOR_NUM);
317 	BUILD_BUG_ON(ARRAY_SIZE(max77836_supported_regulators) != MAX77836_REGULATOR_NUM);
318 
319 	BUILD_BUG_ON(MAX77836_REGULATOR_LDO_VOLTAGE_MIN +
320 			(MAX77836_REGULATOR_LDO_VOLTAGE_STEP *
321 			  (MAX77836_REGULATOR_LDO_VOLTAGE_STEPS_NUM - 1)) !=
322 			MAX77836_REGULATOR_LDO_VOLTAGE_MAX);
323 
324 	return platform_driver_register(&max14577_regulator_driver);
325 }
326 subsys_initcall(max14577_regulator_init);
327 
328 static void __exit max14577_regulator_exit(void)
329 {
330 	platform_driver_unregister(&max14577_regulator_driver);
331 }
332 module_exit(max14577_regulator_exit);
333 
334 MODULE_AUTHOR("Krzysztof Kozlowski <krzk@kernel.org>");
335 MODULE_DESCRIPTION("Maxim 14577/77836 regulator driver");
336 MODULE_LICENSE("GPL");
337 MODULE_ALIAS("platform:max14577-regulator");
338