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