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