regulator: Convert virtual and userspace regulator consumer drivers to use module_pla...
[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/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, NULL);
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");