xref: /linux/drivers/regulator/ab8500.c (revision f2ee442115c9b6219083c019939a9cc0c9abb2f8)
1 /*
2  * Copyright (C) ST-Ericsson SA 2010
3  *
4  * License Terms: GNU General Public License v2
5  *
6  * Authors: Sundar Iyer <sundar.iyer@stericsson.com> for ST-Ericsson
7  *          Bengt Jonsson <bengt.g.jonsson@stericsson.com> for ST-Ericsson
8  *
9  * AB8500 peripheral regulators
10  *
11  * AB8500 supports the following regulators:
12  *   VAUX1/2/3, VINTCORE, VTVOUT, VUSB, VAUDIO, VAMIC1/2, VDMIC, VANA
13  */
14 #include <linux/init.h>
15 #include <linux/kernel.h>
16 #include <linux/module.h>
17 #include <linux/err.h>
18 #include <linux/platform_device.h>
19 #include <linux/mfd/ab8500.h>
20 #include <linux/mfd/abx500.h>
21 #include <linux/regulator/driver.h>
22 #include <linux/regulator/machine.h>
23 #include <linux/regulator/ab8500.h>
24 
25 /**
26  * struct ab8500_regulator_info - ab8500 regulator information
27  * @dev: device pointer
28  * @desc: regulator description
29  * @regulator_dev: regulator device
30  * @max_uV: maximum voltage (for variable voltage supplies)
31  * @min_uV: minimum voltage (for variable voltage supplies)
32  * @fixed_uV: typical voltage (for fixed voltage supplies)
33  * @update_bank: bank to control on/off
34  * @update_reg: register to control on/off
35  * @update_mask: mask to enable/disable regulator
36  * @update_val_enable: bits to enable the regulator in normal (high power) mode
37  * @voltage_bank: bank to control regulator voltage
38  * @voltage_reg: register to control regulator voltage
39  * @voltage_mask: mask to control regulator voltage
40  * @voltages: supported voltage table
41  * @voltages_len: number of supported voltages for the regulator
42  * @delay: startup/set voltage delay in us
43  */
44 struct ab8500_regulator_info {
45 	struct device		*dev;
46 	struct regulator_desc	desc;
47 	struct regulator_dev	*regulator;
48 	int max_uV;
49 	int min_uV;
50 	int fixed_uV;
51 	u8 update_bank;
52 	u8 update_reg;
53 	u8 update_mask;
54 	u8 update_val_enable;
55 	u8 voltage_bank;
56 	u8 voltage_reg;
57 	u8 voltage_mask;
58 	int const *voltages;
59 	int voltages_len;
60 	unsigned int delay;
61 };
62 
63 /* voltage tables for the vauxn/vintcore supplies */
64 static const int ldo_vauxn_voltages[] = {
65 	1100000,
66 	1200000,
67 	1300000,
68 	1400000,
69 	1500000,
70 	1800000,
71 	1850000,
72 	1900000,
73 	2500000,
74 	2650000,
75 	2700000,
76 	2750000,
77 	2800000,
78 	2900000,
79 	3000000,
80 	3300000,
81 };
82 
83 static const int ldo_vaux3_voltages[] = {
84 	1200000,
85 	1500000,
86 	1800000,
87 	2100000,
88 	2500000,
89 	2750000,
90 	2790000,
91 	2910000,
92 };
93 
94 static const int ldo_vintcore_voltages[] = {
95 	1200000,
96 	1225000,
97 	1250000,
98 	1275000,
99 	1300000,
100 	1325000,
101 	1350000,
102 };
103 
104 static int ab8500_regulator_enable(struct regulator_dev *rdev)
105 {
106 	int ret;
107 	struct ab8500_regulator_info *info = rdev_get_drvdata(rdev);
108 
109 	if (info == NULL) {
110 		dev_err(rdev_get_dev(rdev), "regulator info null pointer\n");
111 		return -EINVAL;
112 	}
113 
114 	ret = abx500_mask_and_set_register_interruptible(info->dev,
115 		info->update_bank, info->update_reg,
116 		info->update_mask, info->update_val_enable);
117 	if (ret < 0)
118 		dev_err(rdev_get_dev(rdev),
119 			"couldn't set enable bits for regulator\n");
120 
121 	dev_vdbg(rdev_get_dev(rdev),
122 		"%s-enable (bank, reg, mask, value): 0x%x, 0x%x, 0x%x, 0x%x\n",
123 		info->desc.name, info->update_bank, info->update_reg,
124 		info->update_mask, info->update_val_enable);
125 
126 	return ret;
127 }
128 
129 static int ab8500_regulator_disable(struct regulator_dev *rdev)
130 {
131 	int ret;
132 	struct ab8500_regulator_info *info = rdev_get_drvdata(rdev);
133 
134 	if (info == NULL) {
135 		dev_err(rdev_get_dev(rdev), "regulator info null pointer\n");
136 		return -EINVAL;
137 	}
138 
139 	ret = abx500_mask_and_set_register_interruptible(info->dev,
140 		info->update_bank, info->update_reg,
141 		info->update_mask, 0x0);
142 	if (ret < 0)
143 		dev_err(rdev_get_dev(rdev),
144 			"couldn't set disable bits for regulator\n");
145 
146 	dev_vdbg(rdev_get_dev(rdev),
147 		"%s-disable (bank, reg, mask, value): 0x%x, 0x%x, 0x%x, 0x%x\n",
148 		info->desc.name, info->update_bank, info->update_reg,
149 		info->update_mask, 0x0);
150 
151 	return ret;
152 }
153 
154 static int ab8500_regulator_is_enabled(struct regulator_dev *rdev)
155 {
156 	int ret;
157 	struct ab8500_regulator_info *info = rdev_get_drvdata(rdev);
158 	u8 regval;
159 
160 	if (info == NULL) {
161 		dev_err(rdev_get_dev(rdev), "regulator info null pointer\n");
162 		return -EINVAL;
163 	}
164 
165 	ret = abx500_get_register_interruptible(info->dev,
166 		info->update_bank, info->update_reg, &regval);
167 	if (ret < 0) {
168 		dev_err(rdev_get_dev(rdev),
169 			"couldn't read 0x%x register\n", info->update_reg);
170 		return ret;
171 	}
172 
173 	dev_vdbg(rdev_get_dev(rdev),
174 		"%s-is_enabled (bank, reg, mask, value): 0x%x, 0x%x, 0x%x,"
175 		" 0x%x\n",
176 		info->desc.name, info->update_bank, info->update_reg,
177 		info->update_mask, regval);
178 
179 	if (regval & info->update_mask)
180 		return true;
181 	else
182 		return false;
183 }
184 
185 static int ab8500_list_voltage(struct regulator_dev *rdev, unsigned selector)
186 {
187 	struct ab8500_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 	/* return the uV for the fixed regulators */
195 	if (info->fixed_uV)
196 		return info->fixed_uV;
197 
198 	if (selector >= info->voltages_len)
199 		return -EINVAL;
200 
201 	return info->voltages[selector];
202 }
203 
204 static int ab8500_regulator_get_voltage(struct regulator_dev *rdev)
205 {
206 	int ret, val;
207 	struct ab8500_regulator_info *info = rdev_get_drvdata(rdev);
208 	u8 regval;
209 
210 	if (info == NULL) {
211 		dev_err(rdev_get_dev(rdev), "regulator info null pointer\n");
212 		return -EINVAL;
213 	}
214 
215 	ret = abx500_get_register_interruptible(info->dev,
216 			info->voltage_bank, info->voltage_reg, &regval);
217 	if (ret < 0) {
218 		dev_err(rdev_get_dev(rdev),
219 			"couldn't read voltage reg for regulator\n");
220 		return ret;
221 	}
222 
223 	dev_vdbg(rdev_get_dev(rdev),
224 		"%s-get_voltage (bank, reg, mask, value): 0x%x, 0x%x, 0x%x,"
225 		" 0x%x\n",
226 		info->desc.name, info->voltage_bank, info->voltage_reg,
227 		info->voltage_mask, regval);
228 
229 	/* vintcore has a different layout */
230 	val = regval & info->voltage_mask;
231 	if (info->desc.id == AB8500_LDO_INTCORE)
232 		ret = info->voltages[val >> 0x3];
233 	else
234 		ret = info->voltages[val];
235 
236 	return ret;
237 }
238 
239 static int ab8500_get_best_voltage_index(struct regulator_dev *rdev,
240 		int min_uV, int max_uV)
241 {
242 	struct ab8500_regulator_info *info = rdev_get_drvdata(rdev);
243 	int i;
244 
245 	/* check the supported voltage */
246 	for (i = 0; i < info->voltages_len; i++) {
247 		if ((info->voltages[i] >= min_uV) &&
248 		    (info->voltages[i] <= max_uV))
249 			return i;
250 	}
251 
252 	return -EINVAL;
253 }
254 
255 static int ab8500_regulator_set_voltage(struct regulator_dev *rdev,
256 					int min_uV, int max_uV,
257 					unsigned *selector)
258 {
259 	int ret;
260 	struct ab8500_regulator_info *info = rdev_get_drvdata(rdev);
261 	u8 regval;
262 
263 	if (info == NULL) {
264 		dev_err(rdev_get_dev(rdev), "regulator info null pointer\n");
265 		return -EINVAL;
266 	}
267 
268 	/* get the appropriate voltages within the range */
269 	ret = ab8500_get_best_voltage_index(rdev, min_uV, max_uV);
270 	if (ret < 0) {
271 		dev_err(rdev_get_dev(rdev),
272 				"couldn't get best voltage for regulator\n");
273 		return ret;
274 	}
275 
276 	*selector = ret;
277 
278 	/* set the registers for the request */
279 	regval = (u8)ret;
280 	ret = abx500_mask_and_set_register_interruptible(info->dev,
281 			info->voltage_bank, info->voltage_reg,
282 			info->voltage_mask, regval);
283 	if (ret < 0)
284 		dev_err(rdev_get_dev(rdev),
285 		"couldn't set voltage reg for regulator\n");
286 
287 	dev_vdbg(rdev_get_dev(rdev),
288 		"%s-set_voltage (bank, reg, mask, value): 0x%x, 0x%x, 0x%x,"
289 		" 0x%x\n",
290 		info->desc.name, info->voltage_bank, info->voltage_reg,
291 		info->voltage_mask, regval);
292 
293 	return ret;
294 }
295 
296 static int ab8500_regulator_enable_time(struct regulator_dev *rdev)
297 {
298 	struct ab8500_regulator_info *info = rdev_get_drvdata(rdev);
299 
300 	return info->delay;
301 }
302 
303 static int ab8500_regulator_set_voltage_time_sel(struct regulator_dev *rdev,
304 					     unsigned int old_sel,
305 					     unsigned int new_sel)
306 {
307 	struct ab8500_regulator_info *info = rdev_get_drvdata(rdev);
308 	int ret;
309 
310 	/* If the regulator isn't on, it won't take time here */
311 	ret = ab8500_regulator_is_enabled(rdev);
312 	if (ret < 0)
313 		return ret;
314 	if (!ret)
315 		return 0;
316 	return info->delay;
317 }
318 
319 static struct regulator_ops ab8500_regulator_ops = {
320 	.enable		= ab8500_regulator_enable,
321 	.disable	= ab8500_regulator_disable,
322 	.is_enabled	= ab8500_regulator_is_enabled,
323 	.get_voltage	= ab8500_regulator_get_voltage,
324 	.set_voltage	= ab8500_regulator_set_voltage,
325 	.list_voltage	= ab8500_list_voltage,
326 	.enable_time	= ab8500_regulator_enable_time,
327 	.set_voltage_time_sel = ab8500_regulator_set_voltage_time_sel,
328 };
329 
330 static int ab8500_fixed_get_voltage(struct regulator_dev *rdev)
331 {
332 	struct ab8500_regulator_info *info = rdev_get_drvdata(rdev);
333 
334 	if (info == NULL) {
335 		dev_err(rdev_get_dev(rdev), "regulator info null pointer\n");
336 		return -EINVAL;
337 	}
338 
339 	return info->fixed_uV;
340 }
341 
342 static struct regulator_ops ab8500_regulator_fixed_ops = {
343 	.enable		= ab8500_regulator_enable,
344 	.disable	= ab8500_regulator_disable,
345 	.is_enabled	= ab8500_regulator_is_enabled,
346 	.get_voltage	= ab8500_fixed_get_voltage,
347 	.list_voltage	= ab8500_list_voltage,
348 	.enable_time	= ab8500_regulator_enable_time,
349 	.set_voltage_time_sel = ab8500_regulator_set_voltage_time_sel,
350 };
351 
352 static struct ab8500_regulator_info
353 		ab8500_regulator_info[AB8500_NUM_REGULATORS] = {
354 	/*
355 	 * Variable Voltage Regulators
356 	 *   name, min mV, max mV,
357 	 *   update bank, reg, mask, enable val
358 	 *   volt bank, reg, mask, table, table length
359 	 */
360 	[AB8500_LDO_AUX1] = {
361 		.desc = {
362 			.name		= "LDO-AUX1",
363 			.ops		= &ab8500_regulator_ops,
364 			.type		= REGULATOR_VOLTAGE,
365 			.id		= AB8500_LDO_AUX1,
366 			.owner		= THIS_MODULE,
367 			.n_voltages	= ARRAY_SIZE(ldo_vauxn_voltages),
368 		},
369 		.min_uV			= 1100000,
370 		.max_uV			= 3300000,
371 		.update_bank		= 0x04,
372 		.update_reg		= 0x09,
373 		.update_mask		= 0x03,
374 		.update_val_enable	= 0x01,
375 		.voltage_bank		= 0x04,
376 		.voltage_reg		= 0x1f,
377 		.voltage_mask		= 0x0f,
378 		.voltages		= ldo_vauxn_voltages,
379 		.voltages_len		= ARRAY_SIZE(ldo_vauxn_voltages),
380 	},
381 	[AB8500_LDO_AUX2] = {
382 		.desc = {
383 			.name		= "LDO-AUX2",
384 			.ops		= &ab8500_regulator_ops,
385 			.type		= REGULATOR_VOLTAGE,
386 			.id		= AB8500_LDO_AUX2,
387 			.owner		= THIS_MODULE,
388 			.n_voltages	= ARRAY_SIZE(ldo_vauxn_voltages),
389 		},
390 		.min_uV			= 1100000,
391 		.max_uV			= 3300000,
392 		.update_bank		= 0x04,
393 		.update_reg		= 0x09,
394 		.update_mask		= 0x0c,
395 		.update_val_enable	= 0x04,
396 		.voltage_bank		= 0x04,
397 		.voltage_reg		= 0x20,
398 		.voltage_mask		= 0x0f,
399 		.voltages		= ldo_vauxn_voltages,
400 		.voltages_len		= ARRAY_SIZE(ldo_vauxn_voltages),
401 	},
402 	[AB8500_LDO_AUX3] = {
403 		.desc = {
404 			.name		= "LDO-AUX3",
405 			.ops		= &ab8500_regulator_ops,
406 			.type		= REGULATOR_VOLTAGE,
407 			.id		= AB8500_LDO_AUX3,
408 			.owner		= THIS_MODULE,
409 			.n_voltages	= ARRAY_SIZE(ldo_vaux3_voltages),
410 		},
411 		.min_uV			= 1100000,
412 		.max_uV			= 3300000,
413 		.update_bank		= 0x04,
414 		.update_reg		= 0x0a,
415 		.update_mask		= 0x03,
416 		.update_val_enable	= 0x01,
417 		.voltage_bank		= 0x04,
418 		.voltage_reg		= 0x21,
419 		.voltage_mask		= 0x07,
420 		.voltages		= ldo_vaux3_voltages,
421 		.voltages_len		= ARRAY_SIZE(ldo_vaux3_voltages),
422 	},
423 	[AB8500_LDO_INTCORE] = {
424 		.desc = {
425 			.name		= "LDO-INTCORE",
426 			.ops		= &ab8500_regulator_ops,
427 			.type		= REGULATOR_VOLTAGE,
428 			.id		= AB8500_LDO_INTCORE,
429 			.owner		= THIS_MODULE,
430 			.n_voltages	= ARRAY_SIZE(ldo_vintcore_voltages),
431 		},
432 		.min_uV			= 1100000,
433 		.max_uV			= 3300000,
434 		.update_bank		= 0x03,
435 		.update_reg		= 0x80,
436 		.update_mask		= 0x44,
437 		.update_val_enable	= 0x04,
438 		.voltage_bank		= 0x03,
439 		.voltage_reg		= 0x80,
440 		.voltage_mask		= 0x38,
441 		.voltages		= ldo_vintcore_voltages,
442 		.voltages_len		= ARRAY_SIZE(ldo_vintcore_voltages),
443 	},
444 
445 	/*
446 	 * Fixed Voltage Regulators
447 	 *   name, fixed mV,
448 	 *   update bank, reg, mask, enable val
449 	 */
450 	[AB8500_LDO_TVOUT] = {
451 		.desc = {
452 			.name		= "LDO-TVOUT",
453 			.ops		= &ab8500_regulator_fixed_ops,
454 			.type		= REGULATOR_VOLTAGE,
455 			.id		= AB8500_LDO_TVOUT,
456 			.owner		= THIS_MODULE,
457 			.n_voltages	= 1,
458 		},
459 		.delay			= 10000,
460 		.fixed_uV		= 2000000,
461 		.update_bank		= 0x03,
462 		.update_reg		= 0x80,
463 		.update_mask		= 0x82,
464 		.update_val_enable	= 0x02,
465 	},
466 	[AB8500_LDO_USB] = {
467 		.desc = {
468 			.name           = "LDO-USB",
469 			.ops            = &ab8500_regulator_fixed_ops,
470 			.type           = REGULATOR_VOLTAGE,
471 			.id             = AB8500_LDO_USB,
472 			.owner          = THIS_MODULE,
473 			.n_voltages     = 1,
474 		},
475 		.fixed_uV               = 3300000,
476 		.update_bank            = 0x03,
477 		.update_reg             = 0x82,
478 		.update_mask            = 0x03,
479 		.update_val_enable      = 0x01,
480 	},
481 	[AB8500_LDO_AUDIO] = {
482 		.desc = {
483 			.name		= "LDO-AUDIO",
484 			.ops		= &ab8500_regulator_fixed_ops,
485 			.type		= REGULATOR_VOLTAGE,
486 			.id		= AB8500_LDO_AUDIO,
487 			.owner		= THIS_MODULE,
488 			.n_voltages	= 1,
489 		},
490 		.fixed_uV		= 2000000,
491 		.update_bank		= 0x03,
492 		.update_reg		= 0x83,
493 		.update_mask		= 0x02,
494 		.update_val_enable	= 0x02,
495 	},
496 	[AB8500_LDO_ANAMIC1] = {
497 		.desc = {
498 			.name		= "LDO-ANAMIC1",
499 			.ops		= &ab8500_regulator_fixed_ops,
500 			.type		= REGULATOR_VOLTAGE,
501 			.id		= AB8500_LDO_ANAMIC1,
502 			.owner		= THIS_MODULE,
503 			.n_voltages	= 1,
504 		},
505 		.fixed_uV		= 2050000,
506 		.update_bank		= 0x03,
507 		.update_reg		= 0x83,
508 		.update_mask		= 0x08,
509 		.update_val_enable	= 0x08,
510 	},
511 	[AB8500_LDO_ANAMIC2] = {
512 		.desc = {
513 			.name		= "LDO-ANAMIC2",
514 			.ops		= &ab8500_regulator_fixed_ops,
515 			.type		= REGULATOR_VOLTAGE,
516 			.id		= AB8500_LDO_ANAMIC2,
517 			.owner		= THIS_MODULE,
518 			.n_voltages	= 1,
519 		},
520 		.fixed_uV		= 2050000,
521 		.update_bank		= 0x03,
522 		.update_reg		= 0x83,
523 		.update_mask		= 0x10,
524 		.update_val_enable	= 0x10,
525 	},
526 	[AB8500_LDO_DMIC] = {
527 		.desc = {
528 			.name		= "LDO-DMIC",
529 			.ops		= &ab8500_regulator_fixed_ops,
530 			.type		= REGULATOR_VOLTAGE,
531 			.id		= AB8500_LDO_DMIC,
532 			.owner		= THIS_MODULE,
533 			.n_voltages	= 1,
534 		},
535 		.fixed_uV		= 1800000,
536 		.update_bank		= 0x03,
537 		.update_reg		= 0x83,
538 		.update_mask		= 0x04,
539 		.update_val_enable	= 0x04,
540 	},
541 	[AB8500_LDO_ANA] = {
542 		.desc = {
543 			.name		= "LDO-ANA",
544 			.ops		= &ab8500_regulator_fixed_ops,
545 			.type		= REGULATOR_VOLTAGE,
546 			.id		= AB8500_LDO_ANA,
547 			.owner		= THIS_MODULE,
548 			.n_voltages	= 1,
549 		},
550 		.fixed_uV		= 1200000,
551 		.update_bank		= 0x04,
552 		.update_reg		= 0x06,
553 		.update_mask		= 0x0c,
554 		.update_val_enable	= 0x04,
555 	},
556 
557 
558 };
559 
560 struct ab8500_reg_init {
561 	u8 bank;
562 	u8 addr;
563 	u8 mask;
564 };
565 
566 #define REG_INIT(_id, _bank, _addr, _mask)	\
567 	[_id] = {				\
568 		.bank = _bank,			\
569 		.addr = _addr,			\
570 		.mask = _mask,			\
571 	}
572 
573 static struct ab8500_reg_init ab8500_reg_init[] = {
574 	/*
575 	 * 0x30, VanaRequestCtrl
576 	 * 0x0C, VpllRequestCtrl
577 	 * 0xc0, VextSupply1RequestCtrl
578 	 */
579 	REG_INIT(AB8500_REGUREQUESTCTRL2,	0x03, 0x04, 0xfc),
580 	/*
581 	 * 0x03, VextSupply2RequestCtrl
582 	 * 0x0c, VextSupply3RequestCtrl
583 	 * 0x30, Vaux1RequestCtrl
584 	 * 0xc0, Vaux2RequestCtrl
585 	 */
586 	REG_INIT(AB8500_REGUREQUESTCTRL3,	0x03, 0x05, 0xff),
587 	/*
588 	 * 0x03, Vaux3RequestCtrl
589 	 * 0x04, SwHPReq
590 	 */
591 	REG_INIT(AB8500_REGUREQUESTCTRL4,	0x03, 0x06, 0x07),
592 	/*
593 	 * 0x08, VanaSysClkReq1HPValid
594 	 * 0x20, Vaux1SysClkReq1HPValid
595 	 * 0x40, Vaux2SysClkReq1HPValid
596 	 * 0x80, Vaux3SysClkReq1HPValid
597 	 */
598 	REG_INIT(AB8500_REGUSYSCLKREQ1HPVALID1,	0x03, 0x07, 0xe8),
599 	/*
600 	 * 0x10, VextSupply1SysClkReq1HPValid
601 	 * 0x20, VextSupply2SysClkReq1HPValid
602 	 * 0x40, VextSupply3SysClkReq1HPValid
603 	 */
604 	REG_INIT(AB8500_REGUSYSCLKREQ1HPVALID2,	0x03, 0x08, 0x70),
605 	/*
606 	 * 0x08, VanaHwHPReq1Valid
607 	 * 0x20, Vaux1HwHPReq1Valid
608 	 * 0x40, Vaux2HwHPReq1Valid
609 	 * 0x80, Vaux3HwHPReq1Valid
610 	 */
611 	REG_INIT(AB8500_REGUHWHPREQ1VALID1,	0x03, 0x09, 0xe8),
612 	/*
613 	 * 0x01, VextSupply1HwHPReq1Valid
614 	 * 0x02, VextSupply2HwHPReq1Valid
615 	 * 0x04, VextSupply3HwHPReq1Valid
616 	 */
617 	REG_INIT(AB8500_REGUHWHPREQ1VALID2,	0x03, 0x0a, 0x07),
618 	/*
619 	 * 0x08, VanaHwHPReq2Valid
620 	 * 0x20, Vaux1HwHPReq2Valid
621 	 * 0x40, Vaux2HwHPReq2Valid
622 	 * 0x80, Vaux3HwHPReq2Valid
623 	 */
624 	REG_INIT(AB8500_REGUHWHPREQ2VALID1,	0x03, 0x0b, 0xe8),
625 	/*
626 	 * 0x01, VextSupply1HwHPReq2Valid
627 	 * 0x02, VextSupply2HwHPReq2Valid
628 	 * 0x04, VextSupply3HwHPReq2Valid
629 	 */
630 	REG_INIT(AB8500_REGUHWHPREQ2VALID2,	0x03, 0x0c, 0x07),
631 	/*
632 	 * 0x20, VanaSwHPReqValid
633 	 * 0x80, Vaux1SwHPReqValid
634 	 */
635 	REG_INIT(AB8500_REGUSWHPREQVALID1,	0x03, 0x0d, 0xa0),
636 	/*
637 	 * 0x01, Vaux2SwHPReqValid
638 	 * 0x02, Vaux3SwHPReqValid
639 	 * 0x04, VextSupply1SwHPReqValid
640 	 * 0x08, VextSupply2SwHPReqValid
641 	 * 0x10, VextSupply3SwHPReqValid
642 	 */
643 	REG_INIT(AB8500_REGUSWHPREQVALID2,	0x03, 0x0e, 0x1f),
644 	/*
645 	 * 0x02, SysClkReq2Valid1
646 	 * ...
647 	 * 0x80, SysClkReq8Valid1
648 	 */
649 	REG_INIT(AB8500_REGUSYSCLKREQVALID1,	0x03, 0x0f, 0xfe),
650 	/*
651 	 * 0x02, SysClkReq2Valid2
652 	 * ...
653 	 * 0x80, SysClkReq8Valid2
654 	 */
655 	REG_INIT(AB8500_REGUSYSCLKREQVALID2,	0x03, 0x10, 0xfe),
656 	/*
657 	 * 0x02, VTVoutEna
658 	 * 0x04, Vintcore12Ena
659 	 * 0x38, Vintcore12Sel
660 	 * 0x40, Vintcore12LP
661 	 * 0x80, VTVoutLP
662 	 */
663 	REG_INIT(AB8500_REGUMISC1,		0x03, 0x80, 0xfe),
664 	/*
665 	 * 0x02, VaudioEna
666 	 * 0x04, VdmicEna
667 	 * 0x08, Vamic1Ena
668 	 * 0x10, Vamic2Ena
669 	 */
670 	REG_INIT(AB8500_VAUDIOSUPPLY,		0x03, 0x83, 0x1e),
671 	/*
672 	 * 0x01, Vamic1_dzout
673 	 * 0x02, Vamic2_dzout
674 	 */
675 	REG_INIT(AB8500_REGUCTRL1VAMIC,		0x03, 0x84, 0x03),
676 	/*
677 	 * 0x0c, VanaRegu
678 	 * 0x03, VpllRegu
679 	 */
680 	REG_INIT(AB8500_VPLLVANAREGU,		0x04, 0x06, 0x0f),
681 	/*
682 	 * 0x01, VrefDDREna
683 	 * 0x02, VrefDDRSleepMode
684 	 */
685 	REG_INIT(AB8500_VREFDDR,		0x04, 0x07, 0x03),
686 	/*
687 	 * 0x03, VextSupply1Regu
688 	 * 0x0c, VextSupply2Regu
689 	 * 0x30, VextSupply3Regu
690 	 * 0x40, ExtSupply2Bypass
691 	 * 0x80, ExtSupply3Bypass
692 	 */
693 	REG_INIT(AB8500_EXTSUPPLYREGU,		0x04, 0x08, 0xff),
694 	/*
695 	 * 0x03, Vaux1Regu
696 	 * 0x0c, Vaux2Regu
697 	 */
698 	REG_INIT(AB8500_VAUX12REGU,		0x04, 0x09, 0x0f),
699 	/*
700 	 * 0x03, Vaux3Regu
701 	 */
702 	REG_INIT(AB8500_VRF1VAUX3REGU,		0x04, 0x0a, 0x03),
703 	/*
704 	 * 0x3f, Vsmps1Sel1
705 	 */
706 	REG_INIT(AB8500_VSMPS1SEL1,		0x04, 0x13, 0x3f),
707 	/*
708 	 * 0x0f, Vaux1Sel
709 	 */
710 	REG_INIT(AB8500_VAUX1SEL,		0x04, 0x1f, 0x0f),
711 	/*
712 	 * 0x0f, Vaux2Sel
713 	 */
714 	REG_INIT(AB8500_VAUX2SEL,		0x04, 0x20, 0x0f),
715 	/*
716 	 * 0x07, Vaux3Sel
717 	 */
718 	REG_INIT(AB8500_VRF1VAUX3SEL,		0x04, 0x21, 0x07),
719 	/*
720 	 * 0x01, VextSupply12LP
721 	 */
722 	REG_INIT(AB8500_REGUCTRL2SPARE,		0x04, 0x22, 0x01),
723 	/*
724 	 * 0x04, Vaux1Disch
725 	 * 0x08, Vaux2Disch
726 	 * 0x10, Vaux3Disch
727 	 * 0x20, Vintcore12Disch
728 	 * 0x40, VTVoutDisch
729 	 * 0x80, VaudioDisch
730 	 */
731 	REG_INIT(AB8500_REGUCTRLDISCH,		0x04, 0x43, 0xfc),
732 	/*
733 	 * 0x02, VanaDisch
734 	 * 0x04, VdmicPullDownEna
735 	 * 0x10, VdmicDisch
736 	 */
737 	REG_INIT(AB8500_REGUCTRLDISCH2,		0x04, 0x44, 0x16),
738 };
739 
740 static __devinit int ab8500_regulator_probe(struct platform_device *pdev)
741 {
742 	struct ab8500 *ab8500 = dev_get_drvdata(pdev->dev.parent);
743 	struct ab8500_platform_data *pdata;
744 	int i, err;
745 
746 	if (!ab8500) {
747 		dev_err(&pdev->dev, "null mfd parent\n");
748 		return -EINVAL;
749 	}
750 	pdata = dev_get_platdata(ab8500->dev);
751 	if (!pdata) {
752 		dev_err(&pdev->dev, "null pdata\n");
753 		return -EINVAL;
754 	}
755 
756 	/* make sure the platform data has the correct size */
757 	if (pdata->num_regulator != ARRAY_SIZE(ab8500_regulator_info)) {
758 		dev_err(&pdev->dev, "Configuration error: size mismatch.\n");
759 		return -EINVAL;
760 	}
761 
762 	/* initialize registers */
763 	for (i = 0; i < pdata->num_regulator_reg_init; i++) {
764 		int id;
765 		u8 value;
766 
767 		id = pdata->regulator_reg_init[i].id;
768 		value = pdata->regulator_reg_init[i].value;
769 
770 		/* check for configuration errors */
771 		if (id >= AB8500_NUM_REGULATOR_REGISTERS) {
772 			dev_err(&pdev->dev,
773 				"Configuration error: id outside range.\n");
774 			return -EINVAL;
775 		}
776 		if (value & ~ab8500_reg_init[id].mask) {
777 			dev_err(&pdev->dev,
778 				"Configuration error: value outside mask.\n");
779 			return -EINVAL;
780 		}
781 
782 		/* initialize register */
783 		err = abx500_mask_and_set_register_interruptible(&pdev->dev,
784 			ab8500_reg_init[id].bank,
785 			ab8500_reg_init[id].addr,
786 			ab8500_reg_init[id].mask,
787 			value);
788 		if (err < 0) {
789 			dev_err(&pdev->dev,
790 				"Failed to initialize 0x%02x, 0x%02x.\n",
791 				ab8500_reg_init[id].bank,
792 				ab8500_reg_init[id].addr);
793 			return err;
794 		}
795 		dev_vdbg(&pdev->dev,
796 			"  init: 0x%02x, 0x%02x, 0x%02x, 0x%02x\n",
797 			ab8500_reg_init[id].bank,
798 			ab8500_reg_init[id].addr,
799 			ab8500_reg_init[id].mask,
800 			value);
801 	}
802 
803 	/* register all regulators */
804 	for (i = 0; i < ARRAY_SIZE(ab8500_regulator_info); i++) {
805 		struct ab8500_regulator_info *info = NULL;
806 
807 		/* assign per-regulator data */
808 		info = &ab8500_regulator_info[i];
809 		info->dev = &pdev->dev;
810 
811 		/* fix for hardware before ab8500v2.0 */
812 		if (abx500_get_chip_id(info->dev) < 0x20) {
813 			if (info->desc.id == AB8500_LDO_AUX3) {
814 				info->desc.n_voltages =
815 					ARRAY_SIZE(ldo_vauxn_voltages);
816 				info->voltages = ldo_vauxn_voltages;
817 				info->voltages_len =
818 					ARRAY_SIZE(ldo_vauxn_voltages);
819 				info->voltage_mask = 0xf;
820 			}
821 		}
822 
823 		/* register regulator with framework */
824 		info->regulator = regulator_register(&info->desc, &pdev->dev,
825 				&pdata->regulator[i], info);
826 		if (IS_ERR(info->regulator)) {
827 			err = PTR_ERR(info->regulator);
828 			dev_err(&pdev->dev, "failed to register regulator %s\n",
829 					info->desc.name);
830 			/* when we fail, un-register all earlier regulators */
831 			while (--i >= 0) {
832 				info = &ab8500_regulator_info[i];
833 				regulator_unregister(info->regulator);
834 			}
835 			return err;
836 		}
837 
838 		dev_vdbg(rdev_get_dev(info->regulator),
839 			"%s-probed\n", info->desc.name);
840 	}
841 
842 	return 0;
843 }
844 
845 static __devexit int ab8500_regulator_remove(struct platform_device *pdev)
846 {
847 	int i;
848 
849 	for (i = 0; i < ARRAY_SIZE(ab8500_regulator_info); i++) {
850 		struct ab8500_regulator_info *info = NULL;
851 		info = &ab8500_regulator_info[i];
852 
853 		dev_vdbg(rdev_get_dev(info->regulator),
854 			"%s-remove\n", info->desc.name);
855 
856 		regulator_unregister(info->regulator);
857 	}
858 
859 	return 0;
860 }
861 
862 static struct platform_driver ab8500_regulator_driver = {
863 	.probe = ab8500_regulator_probe,
864 	.remove = __devexit_p(ab8500_regulator_remove),
865 	.driver         = {
866 		.name   = "ab8500-regulator",
867 		.owner  = THIS_MODULE,
868 	},
869 };
870 
871 static int __init ab8500_regulator_init(void)
872 {
873 	int ret;
874 
875 	ret = platform_driver_register(&ab8500_regulator_driver);
876 	if (ret != 0)
877 		pr_err("Failed to register ab8500 regulator: %d\n", ret);
878 
879 	return ret;
880 }
881 subsys_initcall(ab8500_regulator_init);
882 
883 static void __exit ab8500_regulator_exit(void)
884 {
885 	platform_driver_unregister(&ab8500_regulator_driver);
886 }
887 module_exit(ab8500_regulator_exit);
888 
889 MODULE_LICENSE("GPL v2");
890 MODULE_AUTHOR("Sundar Iyer <sundar.iyer@stericsson.com>");
891 MODULE_DESCRIPTION("Regulator Driver for ST-Ericsson AB8500 Mixed-Sig PMIC");
892 MODULE_ALIAS("platform:ab8500-regulator");
893