1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
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
25static 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, ®_data);
34 if ((reg_data & CHGCTRL2_MBCHOSTEN_MASK) == 0)
35 return 0;
36 max14577_read_reg(rmap, MAX14577_CHG_REG_STATUS3, ®_data);
37 if ((reg_data & STATUS3_CGMBC_MASK) == 0)
38 return 0;
39
40 return 1;
41 default:
42 return -EINVAL;
43 }
44}
45
46static 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, ®_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
67static 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, ®_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
88static 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
95static 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
103static const struct regulator_desc max14577_supported_regulators[] = {
104 [MAX14577_SAFEOUT] = {
105 .name = "SAFEOUT",
106 .of_match = of_match_ptr("SAFEOUT"),
107 .regulators_node = of_match_ptr("regulators"),
108 .id = MAX14577_SAFEOUT,
109 .ops = &max14577_safeout_ops,
110 .type = REGULATOR_VOLTAGE,
111 .owner = THIS_MODULE,
112 .n_voltages = 1,
113 .min_uV = MAX14577_REGULATOR_SAFEOUT_VOLTAGE,
114 .enable_reg = MAX14577_REG_CONTROL2,
115 .enable_mask = CTRL2_SFOUTORD_MASK,
116 },
117 [MAX14577_CHARGER] = {
118 .name = "CHARGER",
119 .of_match = of_match_ptr("CHARGER"),
120 .regulators_node = of_match_ptr("regulators"),
121 .id = MAX14577_CHARGER,
122 .ops = &max14577_charger_ops,
123 .type = REGULATOR_CURRENT,
124 .owner = THIS_MODULE,
125 .enable_reg = MAX14577_CHG_REG_CHG_CTRL2,
126 .enable_mask = CHGCTRL2_MBCHOSTEN_MASK,
127 },
128};
129
130static struct regulator_ops max77836_ldo_ops = {
131 .is_enabled = regulator_is_enabled_regmap,
132 .enable = regulator_enable_regmap,
133 .disable = regulator_disable_regmap,
134 .list_voltage = regulator_list_voltage_linear,
135 .map_voltage = regulator_map_voltage_linear,
136 .get_voltage_sel = regulator_get_voltage_sel_regmap,
137 .set_voltage_sel = regulator_set_voltage_sel_regmap,
138
139};
140
141static const struct regulator_desc max77836_supported_regulators[] = {
142 [MAX14577_SAFEOUT] = {
143 .name = "SAFEOUT",
144 .of_match = of_match_ptr("SAFEOUT"),
145 .regulators_node = of_match_ptr("regulators"),
146 .id = MAX14577_SAFEOUT,
147 .ops = &max14577_safeout_ops,
148 .type = REGULATOR_VOLTAGE,
149 .owner = THIS_MODULE,
150 .n_voltages = 1,
151 .min_uV = MAX14577_REGULATOR_SAFEOUT_VOLTAGE,
152 .enable_reg = MAX14577_REG_CONTROL2,
153 .enable_mask = CTRL2_SFOUTORD_MASK,
154 },
155 [MAX14577_CHARGER] = {
156 .name = "CHARGER",
157 .of_match = of_match_ptr("CHARGER"),
158 .regulators_node = of_match_ptr("regulators"),
159 .id = MAX14577_CHARGER,
160 .ops = &max14577_charger_ops,
161 .type = REGULATOR_CURRENT,
162 .owner = THIS_MODULE,
163 .enable_reg = MAX14577_CHG_REG_CHG_CTRL2,
164 .enable_mask = CHGCTRL2_MBCHOSTEN_MASK,
165 },
166 [MAX77836_LDO1] = {
167 .name = "LDO1",
168 .of_match = of_match_ptr("LDO1"),
169 .regulators_node = of_match_ptr("regulators"),
170 .id = MAX77836_LDO1,
171 .ops = &max77836_ldo_ops,
172 .type = REGULATOR_VOLTAGE,
173 .owner = THIS_MODULE,
174 .n_voltages = MAX77836_REGULATOR_LDO_VOLTAGE_STEPS_NUM,
175 .min_uV = MAX77836_REGULATOR_LDO_VOLTAGE_MIN,
176 .uV_step = MAX77836_REGULATOR_LDO_VOLTAGE_STEP,
177 .enable_reg = MAX77836_LDO_REG_CNFG1_LDO1,
178 .enable_mask = MAX77836_CNFG1_LDO_PWRMD_MASK,
179 .vsel_reg = MAX77836_LDO_REG_CNFG1_LDO1,
180 .vsel_mask = MAX77836_CNFG1_LDO_TV_MASK,
181 },
182 [MAX77836_LDO2] = {
183 .name = "LDO2",
184 .of_match = of_match_ptr("LDO2"),
185 .regulators_node = of_match_ptr("regulators"),
186 .id = MAX77836_LDO2,
187 .ops = &max77836_ldo_ops,
188 .type = REGULATOR_VOLTAGE,
189 .owner = THIS_MODULE,
190 .n_voltages = MAX77836_REGULATOR_LDO_VOLTAGE_STEPS_NUM,
191 .min_uV = MAX77836_REGULATOR_LDO_VOLTAGE_MIN,
192 .uV_step = MAX77836_REGULATOR_LDO_VOLTAGE_STEP,
193 .enable_reg = MAX77836_LDO_REG_CNFG1_LDO2,
194 .enable_mask = MAX77836_CNFG1_LDO_PWRMD_MASK,
195 .vsel_reg = MAX77836_LDO_REG_CNFG1_LDO2,
196 .vsel_mask = MAX77836_CNFG1_LDO_TV_MASK,
197 },
198};
199
200#ifdef CONFIG_OF
201static struct of_regulator_match max14577_regulator_matches[] = {
202 { .name = "SAFEOUT", },
203 { .name = "CHARGER", },
204};
205
206static struct of_regulator_match max77836_regulator_matches[] = {
207 { .name = "SAFEOUT", },
208 { .name = "CHARGER", },
209 { .name = "LDO1", },
210 { .name = "LDO2", },
211};
212
213static inline struct regulator_init_data *match_init_data(int index,
214 enum maxim_device_type dev_type)
215{
216 switch (dev_type) {
217 case MAXIM_DEVICE_TYPE_MAX77836:
218 return max77836_regulator_matches[index].init_data;
219
220 case MAXIM_DEVICE_TYPE_MAX14577:
221 default:
222 return max14577_regulator_matches[index].init_data;
223 }
224}
225
226static inline struct device_node *match_of_node(int index,
227 enum maxim_device_type dev_type)
228{
229 switch (dev_type) {
230 case MAXIM_DEVICE_TYPE_MAX77836:
231 return max77836_regulator_matches[index].of_node;
232
233 case MAXIM_DEVICE_TYPE_MAX14577:
234 default:
235 return max14577_regulator_matches[index].of_node;
236 }
237}
238#else
239static inline struct regulator_init_data *match_init_data(int index,
240 enum maxim_device_type dev_type)
241{
242 return NULL;
243}
244
245static inline struct device_node *match_of_node(int index,
246 enum maxim_device_type dev_type)
247{
248 return NULL;
249}
250#endif
251
252
253
254
255
256
257
258static struct regmap *max14577_get_regmap(struct max14577 *max14577,
259 int reg_id)
260{
261 switch (max14577->dev_type) {
262 case MAXIM_DEVICE_TYPE_MAX77836:
263 switch (reg_id) {
264 case MAX77836_SAFEOUT ... MAX77836_CHARGER:
265 return max14577->regmap;
266 default:
267
268 return max14577->regmap_pmic;
269 }
270
271 case MAXIM_DEVICE_TYPE_MAX14577:
272 default:
273 return max14577->regmap;
274 }
275}
276
277static int max14577_regulator_probe(struct platform_device *pdev)
278{
279 struct max14577 *max14577 = dev_get_drvdata(pdev->dev.parent);
280 struct max14577_platform_data *pdata = dev_get_platdata(max14577->dev);
281 int i, ret = 0;
282 struct regulator_config config = {};
283 const struct regulator_desc *supported_regulators;
284 unsigned int supported_regulators_size;
285 enum maxim_device_type dev_type = max14577->dev_type;
286
287 switch (dev_type) {
288 case MAXIM_DEVICE_TYPE_MAX77836:
289 supported_regulators = max77836_supported_regulators;
290 supported_regulators_size = ARRAY_SIZE(max77836_supported_regulators);
291 break;
292 case MAXIM_DEVICE_TYPE_MAX14577:
293 default:
294 supported_regulators = max14577_supported_regulators;
295 supported_regulators_size = ARRAY_SIZE(max14577_supported_regulators);
296 }
297
298 config.dev = max14577->dev;
299 config.driver_data = max14577;
300
301 for (i = 0; i < supported_regulators_size; i++) {
302 struct regulator_dev *regulator;
303
304
305
306
307 if (pdata && pdata->regulators) {
308 config.init_data = pdata->regulators[i].initdata;
309 config.of_node = pdata->regulators[i].of_node;
310 } else {
311 config.init_data = match_init_data(i, dev_type);
312 config.of_node = match_of_node(i, dev_type);
313 }
314 config.regmap = max14577_get_regmap(max14577,
315 supported_regulators[i].id);
316
317 regulator = devm_regulator_register(&pdev->dev,
318 &supported_regulators[i], &config);
319 if (IS_ERR(regulator)) {
320 ret = PTR_ERR(regulator);
321 dev_err(&pdev->dev,
322 "Regulator init failed for %d/%s with error: %d\n",
323 i, supported_regulators[i].name, ret);
324 return ret;
325 }
326 }
327
328 return ret;
329}
330
331static const struct platform_device_id max14577_regulator_id[] = {
332 { "max14577-regulator", MAXIM_DEVICE_TYPE_MAX14577, },
333 { "max77836-regulator", MAXIM_DEVICE_TYPE_MAX77836, },
334 { }
335};
336MODULE_DEVICE_TABLE(platform, max14577_regulator_id);
337
338static struct platform_driver max14577_regulator_driver = {
339 .driver = {
340 .name = "max14577-regulator",
341 },
342 .probe = max14577_regulator_probe,
343 .id_table = max14577_regulator_id,
344};
345
346static int __init max14577_regulator_init(void)
347{
348 BUILD_BUG_ON(ARRAY_SIZE(max14577_supported_regulators) != MAX14577_REGULATOR_NUM);
349 BUILD_BUG_ON(ARRAY_SIZE(max77836_supported_regulators) != MAX77836_REGULATOR_NUM);
350
351 BUILD_BUG_ON(MAX77836_REGULATOR_LDO_VOLTAGE_MIN +
352 (MAX77836_REGULATOR_LDO_VOLTAGE_STEP *
353 (MAX77836_REGULATOR_LDO_VOLTAGE_STEPS_NUM - 1)) !=
354 MAX77836_REGULATOR_LDO_VOLTAGE_MAX);
355
356 return platform_driver_register(&max14577_regulator_driver);
357}
358subsys_initcall(max14577_regulator_init);
359
360static void __exit max14577_regulator_exit(void)
361{
362 platform_driver_unregister(&max14577_regulator_driver);
363}
364module_exit(max14577_regulator_exit);
365
366MODULE_AUTHOR("Krzysztof Kozlowski <k.kozlowski@samsung.com>");
367MODULE_DESCRIPTION("Maxim 14577/77836 regulator driver");
368MODULE_LICENSE("GPL");
369MODULE_ALIAS("platform:max14577-regulator");
370
