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