1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3  * Copyright (C) ST-Ericsson SA 2010
4  *
5  * Authors: Bengt Jonsson <bengt.g.jonsson@stericsson.com>
6  *
7  * This file is based on drivers/regulator/ab8500.c
8  *
9  * AB8500 external regulators
10  *
11  * ab8500-ext supports the following regulators:
12  * - VextSupply3
13  */
14 #include <linux/init.h>
15 #include <linux/kernel.h>
16 #include <linux/err.h>
17 #include <linux/module.h>
18 #include <linux/of.h>
19 #include <linux/platform_device.h>
20 #include <linux/regulator/driver.h>
21 #include <linux/regulator/machine.h>
22 #include <linux/regulator/of_regulator.h>
23 #include <linux/mfd/abx500.h>
24 #include <linux/mfd/abx500/ab8500.h>
25 
26 /* AB8500 external regulators */
27 enum ab8500_ext_regulator_id {
28 	AB8500_EXT_SUPPLY1,
29 	AB8500_EXT_SUPPLY2,
30 	AB8500_EXT_SUPPLY3,
31 	AB8500_NUM_EXT_REGULATORS,
32 };
33 
34 struct ab8500_ext_regulator_cfg {
35 	bool hwreq; /* requires hw mode or high power mode */
36 };
37 
38 /* supply for VextSupply3 */
39 static struct regulator_consumer_supply ab8500_ext_supply3_consumers[] = {
40 	/* SIM supply for 3 V SIM cards */
41 	REGULATOR_SUPPLY("vinvsim", "sim-detect.0"),
42 };
43 
44 /*
45  * AB8500 external regulators
46  */
47 static struct regulator_init_data ab8500_ext_regulators[] = {
48 	/* fixed Vbat supplies VSMPS1_EXT_1V8 */
49 	[AB8500_EXT_SUPPLY1] = {
50 		.constraints = {
51 			.name = "ab8500-ext-supply1",
52 			.min_uV = 1800000,
53 			.max_uV = 1800000,
54 			.initial_mode = REGULATOR_MODE_IDLE,
55 			.boot_on = 1,
56 			.always_on = 1,
57 		},
58 	},
59 	/* fixed Vbat supplies VSMPS2_EXT_1V36 and VSMPS5_EXT_1V15 */
60 	[AB8500_EXT_SUPPLY2] = {
61 		.constraints = {
62 			.name = "ab8500-ext-supply2",
63 			.min_uV = 1360000,
64 			.max_uV = 1360000,
65 		},
66 	},
67 	/* fixed Vbat supplies VSMPS3_EXT_3V4 and VSMPS4_EXT_3V4 */
68 	[AB8500_EXT_SUPPLY3] = {
69 		.constraints = {
70 			.name = "ab8500-ext-supply3",
71 			.min_uV = 3400000,
72 			.max_uV = 3400000,
73 			.valid_ops_mask = REGULATOR_CHANGE_STATUS,
74 			.boot_on = 1,
75 		},
76 		.num_consumer_supplies =
77 			ARRAY_SIZE(ab8500_ext_supply3_consumers),
78 		.consumer_supplies = ab8500_ext_supply3_consumers,
79 	},
80 };
81 
82 /**
83  * struct ab8500_ext_regulator_info - ab8500 regulator information
84  * @dev: device pointer
85  * @desc: regulator description
86  * @cfg: regulator configuration (extension of regulator FW configuration)
87  * @update_bank: bank to control on/off
88  * @update_reg: register to control on/off
89  * @update_mask: mask to enable/disable and set mode of regulator
90  * @update_val: bits holding the regulator current mode
91  * @update_val_hp: bits to set EN pin active (LPn pin deactive)
92  *                 normally this means high power mode
93  * @update_val_lp: bits to set EN pin active and LPn pin active
94  *                 normally this means low power mode
95  * @update_val_hw: bits to set regulator pins in HW control
96  *                 SysClkReq pins and logic will choose mode
97  */
98 struct ab8500_ext_regulator_info {
99 	struct device *dev;
100 	struct regulator_desc desc;
101 	struct ab8500_ext_regulator_cfg *cfg;
102 	u8 update_bank;
103 	u8 update_reg;
104 	u8 update_mask;
105 	u8 update_val;
106 	u8 update_val_hp;
107 	u8 update_val_lp;
108 	u8 update_val_hw;
109 };
110 
111 static int ab8500_ext_regulator_enable(struct regulator_dev *rdev)
112 {
113 	int ret;
114 	struct ab8500_ext_regulator_info *info = rdev_get_drvdata(rdev);
115 	u8 regval;
116 
117 	if (info == NULL) {
118 		dev_err(rdev_get_dev(rdev), "regulator info null pointer\n");
119 		return -EINVAL;
120 	}
121 
122 	/*
123 	 * To satisfy both HW high power request and SW request, the regulator
124 	 * must be on in high power.
125 	 */
126 	if (info->cfg && info->cfg->hwreq)
127 		regval = info->update_val_hp;
128 	else
129 		regval = info->update_val;
130 
131 	ret = abx500_mask_and_set_register_interruptible(info->dev,
132 		info->update_bank, info->update_reg,
133 		info->update_mask, regval);
134 	if (ret < 0) {
135 		dev_err(rdev_get_dev(rdev),
136 			"couldn't set enable bits for regulator\n");
137 		return ret;
138 	}
139 
140 	dev_dbg(rdev_get_dev(rdev),
141 		"%s-enable (bank, reg, mask, value): 0x%02x, 0x%02x, 0x%02x, 0x%02x\n",
142 		info->desc.name, info->update_bank, info->update_reg,
143 		info->update_mask, regval);
144 
145 	return 0;
146 }
147 
148 static int ab8500_ext_regulator_disable(struct regulator_dev *rdev)
149 {
150 	int ret;
151 	struct ab8500_ext_regulator_info *info = rdev_get_drvdata(rdev);
152 	u8 regval;
153 
154 	if (info == NULL) {
155 		dev_err(rdev_get_dev(rdev), "regulator info null pointer\n");
156 		return -EINVAL;
157 	}
158 
159 	/*
160 	 * Set the regulator in HW request mode if configured
161 	 */
162 	if (info->cfg && info->cfg->hwreq)
163 		regval = info->update_val_hw;
164 	else
165 		regval = 0;
166 
167 	ret = abx500_mask_and_set_register_interruptible(info->dev,
168 		info->update_bank, info->update_reg,
169 		info->update_mask, regval);
170 	if (ret < 0) {
171 		dev_err(rdev_get_dev(rdev),
172 			"couldn't set disable bits for regulator\n");
173 		return ret;
174 	}
175 
176 	dev_dbg(rdev_get_dev(rdev), "%s-disable (bank, reg, mask, value):"
177 		" 0x%02x, 0x%02x, 0x%02x, 0x%02x\n",
178 		info->desc.name, info->update_bank, info->update_reg,
179 		info->update_mask, regval);
180 
181 	return 0;
182 }
183 
184 static int ab8500_ext_regulator_is_enabled(struct regulator_dev *rdev)
185 {
186 	int ret;
187 	struct ab8500_ext_regulator_info *info = rdev_get_drvdata(rdev);
188 	u8 regval;
189 
190 	if (info == NULL) {
191 		dev_err(rdev_get_dev(rdev), "regulator info null pointer\n");
192 		return -EINVAL;
193 	}
194 
195 	ret = abx500_get_register_interruptible(info->dev,
196 		info->update_bank, info->update_reg, &regval);
197 	if (ret < 0) {
198 		dev_err(rdev_get_dev(rdev),
199 			"couldn't read 0x%x register\n", info->update_reg);
200 		return ret;
201 	}
202 
203 	dev_dbg(rdev_get_dev(rdev), "%s-is_enabled (bank, reg, mask, value):"
204 		" 0x%02x, 0x%02x, 0x%02x, 0x%02x\n",
205 		info->desc.name, info->update_bank, info->update_reg,
206 		info->update_mask, regval);
207 
208 	if (((regval & info->update_mask) == info->update_val_lp) ||
209 	    ((regval & info->update_mask) == info->update_val_hp))
210 		return 1;
211 	else
212 		return 0;
213 }
214 
215 static int ab8500_ext_regulator_set_mode(struct regulator_dev *rdev,
216 					 unsigned int mode)
217 {
218 	int ret = 0;
219 	struct ab8500_ext_regulator_info *info = rdev_get_drvdata(rdev);
220 	u8 regval;
221 
222 	if (info == NULL) {
223 		dev_err(rdev_get_dev(rdev), "regulator info null pointer\n");
224 		return -EINVAL;
225 	}
226 
227 	switch (mode) {
228 	case REGULATOR_MODE_NORMAL:
229 		regval = info->update_val_hp;
230 		break;
231 	case REGULATOR_MODE_IDLE:
232 		regval = info->update_val_lp;
233 		break;
234 
235 	default:
236 		return -EINVAL;
237 	}
238 
239 	/* If regulator is enabled and info->cfg->hwreq is set, the regulator
240 	   must be on in high power, so we don't need to write the register with
241 	   the same value.
242 	 */
243 	if (ab8500_ext_regulator_is_enabled(rdev) &&
244 	    !(info->cfg && info->cfg->hwreq)) {
245 		ret = abx500_mask_and_set_register_interruptible(info->dev,
246 					info->update_bank, info->update_reg,
247 					info->update_mask, regval);
248 		if (ret < 0) {
249 			dev_err(rdev_get_dev(rdev),
250 				"Could not set regulator mode.\n");
251 			return ret;
252 		}
253 
254 		dev_dbg(rdev_get_dev(rdev),
255 			"%s-set_mode (bank, reg, mask, value): "
256 			"0x%x, 0x%x, 0x%x, 0x%x\n",
257 			info->desc.name, info->update_bank, info->update_reg,
258 			info->update_mask, regval);
259 	}
260 
261 	info->update_val = regval;
262 
263 	return 0;
264 }
265 
266 static unsigned int ab8500_ext_regulator_get_mode(struct regulator_dev *rdev)
267 {
268 	struct ab8500_ext_regulator_info *info = rdev_get_drvdata(rdev);
269 	int ret;
270 
271 	if (info == NULL) {
272 		dev_err(rdev_get_dev(rdev), "regulator info null pointer\n");
273 		return -EINVAL;
274 	}
275 
276 	if (info->update_val == info->update_val_hp)
277 		ret = REGULATOR_MODE_NORMAL;
278 	else if (info->update_val == info->update_val_lp)
279 		ret = REGULATOR_MODE_IDLE;
280 	else
281 		ret = -EINVAL;
282 
283 	return ret;
284 }
285 
286 static int ab8500_ext_set_voltage(struct regulator_dev *rdev, int min_uV,
287 				  int max_uV, unsigned *selector)
288 {
289 	struct regulation_constraints *regu_constraints = rdev->constraints;
290 
291 	if (!regu_constraints) {
292 		dev_err(rdev_get_dev(rdev), "No regulator constraints\n");
293 		return -EINVAL;
294 	}
295 
296 	if (regu_constraints->min_uV == min_uV &&
297 	    regu_constraints->max_uV == max_uV)
298 		return 0;
299 
300 	dev_err(rdev_get_dev(rdev),
301 		"Requested min %duV max %duV != constrained min %duV max %duV\n",
302 		min_uV, max_uV,
303 		regu_constraints->min_uV, regu_constraints->max_uV);
304 
305 	return -EINVAL;
306 }
307 
308 static int ab8500_ext_list_voltage(struct regulator_dev *rdev,
309 				   unsigned selector)
310 {
311 	struct regulation_constraints *regu_constraints = rdev->constraints;
312 
313 	if (regu_constraints == NULL) {
314 		dev_err(rdev_get_dev(rdev), "regulator constraints null pointer\n");
315 		return -EINVAL;
316 	}
317 	/* return the uV for the fixed regulators */
318 	if (regu_constraints->min_uV && regu_constraints->max_uV) {
319 		if (regu_constraints->min_uV == regu_constraints->max_uV)
320 			return regu_constraints->min_uV;
321 	}
322 	return -EINVAL;
323 }
324 
325 static const struct regulator_ops ab8500_ext_regulator_ops = {
326 	.enable			= ab8500_ext_regulator_enable,
327 	.disable		= ab8500_ext_regulator_disable,
328 	.is_enabled		= ab8500_ext_regulator_is_enabled,
329 	.set_mode		= ab8500_ext_regulator_set_mode,
330 	.get_mode		= ab8500_ext_regulator_get_mode,
331 	.set_voltage		= ab8500_ext_set_voltage,
332 	.list_voltage		= ab8500_ext_list_voltage,
333 };
334 
335 static struct ab8500_ext_regulator_info
336 		ab8500_ext_regulator_info[AB8500_NUM_EXT_REGULATORS] = {
337 	[AB8500_EXT_SUPPLY1] = {
338 		.desc = {
339 			.name		= "VEXTSUPPLY1",
340 			.of_match	= of_match_ptr("ab8500_ext1"),
341 			.ops		= &ab8500_ext_regulator_ops,
342 			.type		= REGULATOR_VOLTAGE,
343 			.id		= AB8500_EXT_SUPPLY1,
344 			.owner		= THIS_MODULE,
345 			.n_voltages	= 1,
346 		},
347 		.update_bank		= 0x04,
348 		.update_reg		= 0x08,
349 		.update_mask		= 0x03,
350 		.update_val		= 0x01,
351 		.update_val_hp		= 0x01,
352 		.update_val_lp		= 0x03,
353 		.update_val_hw		= 0x02,
354 	},
355 	[AB8500_EXT_SUPPLY2] = {
356 		.desc = {
357 			.name		= "VEXTSUPPLY2",
358 			.of_match	= of_match_ptr("ab8500_ext2"),
359 			.ops		= &ab8500_ext_regulator_ops,
360 			.type		= REGULATOR_VOLTAGE,
361 			.id		= AB8500_EXT_SUPPLY2,
362 			.owner		= THIS_MODULE,
363 			.n_voltages	= 1,
364 		},
365 		.update_bank		= 0x04,
366 		.update_reg		= 0x08,
367 		.update_mask		= 0x0c,
368 		.update_val		= 0x04,
369 		.update_val_hp		= 0x04,
370 		.update_val_lp		= 0x0c,
371 		.update_val_hw		= 0x08,
372 	},
373 	[AB8500_EXT_SUPPLY3] = {
374 		.desc = {
375 			.name		= "VEXTSUPPLY3",
376 			.of_match	= of_match_ptr("ab8500_ext3"),
377 			.ops		= &ab8500_ext_regulator_ops,
378 			.type		= REGULATOR_VOLTAGE,
379 			.id		= AB8500_EXT_SUPPLY3,
380 			.owner		= THIS_MODULE,
381 			.n_voltages	= 1,
382 		},
383 		.update_bank		= 0x04,
384 		.update_reg		= 0x08,
385 		.update_mask		= 0x30,
386 		.update_val		= 0x10,
387 		.update_val_hp		= 0x10,
388 		.update_val_lp		= 0x30,
389 		.update_val_hw		= 0x20,
390 	},
391 };
392 
393 static int ab8500_ext_regulator_probe(struct platform_device *pdev)
394 {
395 	struct ab8500 *ab8500 = dev_get_drvdata(pdev->dev.parent);
396 	struct regulator_config config = { };
397 	struct regulator_dev *rdev;
398 	int i;
399 
400 	if (!ab8500) {
401 		dev_err(&pdev->dev, "null mfd parent\n");
402 		return -EINVAL;
403 	}
404 
405 	/* check for AB8500 2.x */
406 	if (is_ab8500_2p0_or_earlier(ab8500)) {
407 		struct ab8500_ext_regulator_info *info;
408 
409 		/* VextSupply3LPn is inverted on AB8500 2.x */
410 		info = &ab8500_ext_regulator_info[AB8500_EXT_SUPPLY3];
411 		info->update_val = 0x30;
412 		info->update_val_hp = 0x30;
413 		info->update_val_lp = 0x10;
414 	}
415 
416 	/* register all regulators */
417 	for (i = 0; i < ARRAY_SIZE(ab8500_ext_regulator_info); i++) {
418 		struct ab8500_ext_regulator_info *info = NULL;
419 
420 		/* assign per-regulator data */
421 		info = &ab8500_ext_regulator_info[i];
422 		info->dev = &pdev->dev;
423 		info->cfg = (struct ab8500_ext_regulator_cfg *)
424 			ab8500_ext_regulators[i].driver_data;
425 
426 		config.dev = &pdev->dev;
427 		config.driver_data = info;
428 		config.init_data = &ab8500_ext_regulators[i];
429 
430 		/* register regulator with framework */
431 		rdev = devm_regulator_register(&pdev->dev, &info->desc,
432 					       &config);
433 		if (IS_ERR(rdev)) {
434 			dev_err(&pdev->dev, "failed to register regulator %s\n",
435 					info->desc.name);
436 			return PTR_ERR(rdev);
437 		}
438 
439 		dev_dbg(&pdev->dev, "%s-probed\n", info->desc.name);
440 	}
441 
442 	return 0;
443 }
444 
445 static struct platform_driver ab8500_ext_regulator_driver = {
446 	.probe = ab8500_ext_regulator_probe,
447 	.driver         = {
448 		.name   = "ab8500-ext-regulator",
449 		.probe_type = PROBE_PREFER_ASYNCHRONOUS,
450 	},
451 };
452 
453 static int __init ab8500_ext_regulator_init(void)
454 {
455 	int ret;
456 
457 	ret = platform_driver_register(&ab8500_ext_regulator_driver);
458 	if (ret)
459 		pr_err("Failed to register ab8500 ext regulator: %d\n", ret);
460 
461 	return ret;
462 }
463 subsys_initcall(ab8500_ext_regulator_init);
464 
465 static void __exit ab8500_ext_regulator_exit(void)
466 {
467 	platform_driver_unregister(&ab8500_ext_regulator_driver);
468 }
469 module_exit(ab8500_ext_regulator_exit);
470 
471 MODULE_LICENSE("GPL v2");
472 MODULE_AUTHOR("Bengt Jonsson <bengt.g.jonsson@stericsson.com>");
473 MODULE_DESCRIPTION("AB8500 external regulator driver");
474 MODULE_ALIAS("platform:ab8500-ext-regulator");
475