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