Version:  2.6.34 2.6.35 2.6.36 2.6.37 2.6.38 2.6.39 3.0 3.1 3.2 3.3 3.4 3.5 3.6 3.7 3.8 3.9 3.10 3.11 3.12 3.13 3.14

Linux/drivers/regulator/ab3100.c

  1 /*
  2  * drivers/regulator/ab3100.c
  3  *
  4  * Copyright (C) 2008-2009 ST-Ericsson AB
  5  * License terms: GNU General Public License (GPL) version 2
  6  * Low-level control of the AB3100 IC Low Dropout (LDO)
  7  * regulators, external regulator and buck converter
  8  * Author: Mattias Wallin <mattias.wallin@stericsson.com>
  9  * Author: Linus Walleij <linus.walleij@stericsson.com>
 10  */
 11 
 12 #include <linux/module.h>
 13 #include <linux/kernel.h>
 14 #include <linux/init.h>
 15 #include <linux/err.h>
 16 #include <linux/platform_device.h>
 17 #include <linux/regulator/driver.h>
 18 #include <linux/mfd/ab3100.h>
 19 #include <linux/mfd/abx500.h>
 20 #include <linux/of.h>
 21 #include <linux/regulator/of_regulator.h>
 22 
 23 /* LDO registers and some handy masking definitions for AB3100 */
 24 #define AB3100_LDO_A            0x40
 25 #define AB3100_LDO_C            0x41
 26 #define AB3100_LDO_D            0x42
 27 #define AB3100_LDO_E            0x43
 28 #define AB3100_LDO_E_SLEEP      0x44
 29 #define AB3100_LDO_F            0x45
 30 #define AB3100_LDO_G            0x46
 31 #define AB3100_LDO_H            0x47
 32 #define AB3100_LDO_H_SLEEP_MODE 0
 33 #define AB3100_LDO_H_SLEEP_EN   2
 34 #define AB3100_LDO_ON           4
 35 #define AB3100_LDO_H_VSEL_AC    5
 36 #define AB3100_LDO_K            0x48
 37 #define AB3100_LDO_EXT          0x49
 38 #define AB3100_BUCK             0x4A
 39 #define AB3100_BUCK_SLEEP       0x4B
 40 #define AB3100_REG_ON_MASK      0x10
 41 
 42 /**
 43  * struct ab3100_regulator
 44  * A struct passed around the individual regulator functions
 45  * @platform_device: platform device holding this regulator
 46  * @dev: handle to the device
 47  * @plfdata: AB3100 platform data passed in at probe time
 48  * @regreg: regulator register number in the AB3100
 49  */
 50 struct ab3100_regulator {
 51         struct regulator_dev *rdev;
 52         struct device *dev;
 53         struct ab3100_platform_data *plfdata;
 54         u8 regreg;
 55 };
 56 
 57 /* The order in which registers are initialized */
 58 static const u8 ab3100_reg_init_order[AB3100_NUM_REGULATORS+2] = {
 59         AB3100_LDO_A,
 60         AB3100_LDO_C,
 61         AB3100_LDO_E,
 62         AB3100_LDO_E_SLEEP,
 63         AB3100_LDO_F,
 64         AB3100_LDO_G,
 65         AB3100_LDO_H,
 66         AB3100_LDO_K,
 67         AB3100_LDO_EXT,
 68         AB3100_BUCK,
 69         AB3100_BUCK_SLEEP,
 70         AB3100_LDO_D,
 71 };
 72 
 73 /* Preset (hardware defined) voltages for these regulators */
 74 #define LDO_A_VOLTAGE 2750000
 75 #define LDO_C_VOLTAGE 2650000
 76 #define LDO_D_VOLTAGE 2650000
 77 
 78 static const unsigned int ldo_e_buck_typ_voltages[] = {
 79         1800000,
 80         1400000,
 81         1300000,
 82         1200000,
 83         1100000,
 84         1050000,
 85         900000,
 86 };
 87 
 88 static const unsigned int ldo_f_typ_voltages[] = {
 89         1800000,
 90         1400000,
 91         1300000,
 92         1200000,
 93         1100000,
 94         1050000,
 95         2500000,
 96         2650000,
 97 };
 98 
 99 static const unsigned int ldo_g_typ_voltages[] = {
100         2850000,
101         2750000,
102         1800000,
103         1500000,
104 };
105 
106 static const unsigned int ldo_h_typ_voltages[] = {
107         2750000,
108         1800000,
109         1500000,
110         1200000,
111 };
112 
113 static const unsigned int ldo_k_typ_voltages[] = {
114         2750000,
115         1800000,
116 };
117 
118 
119 /* The regulator devices */
120 static struct ab3100_regulator
121 ab3100_regulators[AB3100_NUM_REGULATORS] = {
122         {
123                 .regreg = AB3100_LDO_A,
124         },
125         {
126                 .regreg = AB3100_LDO_C,
127         },
128         {
129                 .regreg = AB3100_LDO_D,
130         },
131         {
132                 .regreg = AB3100_LDO_E,
133         },
134         {
135                 .regreg = AB3100_LDO_F,
136         },
137         {
138                 .regreg = AB3100_LDO_G,
139         },
140         {
141                 .regreg = AB3100_LDO_H,
142         },
143         {
144                 .regreg = AB3100_LDO_K,
145         },
146         {
147                 .regreg = AB3100_LDO_EXT,
148                 /* No voltages for the external regulator */
149         },
150         {
151                 .regreg = AB3100_BUCK,
152         },
153 };
154 
155 /*
156  * General functions for enable, disable and is_enabled used for
157  * LDO: A,C,E,F,G,H,K,EXT and BUCK
158  */
159 static int ab3100_enable_regulator(struct regulator_dev *reg)
160 {
161         struct ab3100_regulator *abreg = rdev_get_drvdata(reg);
162         int err;
163         u8 regval;
164 
165         err = abx500_get_register_interruptible(abreg->dev, 0, abreg->regreg,
166                                                 &regval);
167         if (err) {
168                 dev_warn(&reg->dev, "failed to get regid %d value\n",
169                          abreg->regreg);
170                 return err;
171         }
172 
173         /* The regulator is already on, no reason to go further */
174         if (regval & AB3100_REG_ON_MASK)
175                 return 0;
176 
177         regval |= AB3100_REG_ON_MASK;
178 
179         err = abx500_set_register_interruptible(abreg->dev, 0, abreg->regreg,
180                                                 regval);
181         if (err) {
182                 dev_warn(&reg->dev, "failed to set regid %d value\n",
183                          abreg->regreg);
184                 return err;
185         }
186 
187         return 0;
188 }
189 
190 static int ab3100_disable_regulator(struct regulator_dev *reg)
191 {
192         struct ab3100_regulator *abreg = rdev_get_drvdata(reg);
193         int err;
194         u8 regval;
195 
196         /*
197          * LDO D is a special regulator. When it is disabled, the entire
198          * system is shut down. So this is handled specially.
199          */
200         pr_info("Called ab3100_disable_regulator\n");
201         if (abreg->regreg == AB3100_LDO_D) {
202                 dev_info(&reg->dev, "disabling LDO D - shut down system\n");
203                 /* Setting LDO D to 0x00 cuts the power to the SoC */
204                 return abx500_set_register_interruptible(abreg->dev, 0,
205                                                          AB3100_LDO_D, 0x00U);
206         }
207 
208         /*
209          * All other regulators are handled here
210          */
211         err = abx500_get_register_interruptible(abreg->dev, 0, abreg->regreg,
212                                                 &regval);
213         if (err) {
214                 dev_err(&reg->dev, "unable to get register 0x%x\n",
215                         abreg->regreg);
216                 return err;
217         }
218         regval &= ~AB3100_REG_ON_MASK;
219         return abx500_set_register_interruptible(abreg->dev, 0, abreg->regreg,
220                                                  regval);
221 }
222 
223 static int ab3100_is_enabled_regulator(struct regulator_dev *reg)
224 {
225         struct ab3100_regulator *abreg = rdev_get_drvdata(reg);
226         u8 regval;
227         int err;
228 
229         err = abx500_get_register_interruptible(abreg->dev, 0, abreg->regreg,
230                                                 &regval);
231         if (err) {
232                 dev_err(&reg->dev, "unable to get register 0x%x\n",
233                         abreg->regreg);
234                 return err;
235         }
236 
237         return regval & AB3100_REG_ON_MASK;
238 }
239 
240 static int ab3100_get_voltage_regulator(struct regulator_dev *reg)
241 {
242         struct ab3100_regulator *abreg = rdev_get_drvdata(reg);
243         u8 regval;
244         int err;
245 
246         /*
247          * For variable types, read out setting and index into
248          * supplied voltage list.
249          */
250         err = abx500_get_register_interruptible(abreg->dev, 0,
251                                                 abreg->regreg, &regval);
252         if (err) {
253                 dev_warn(&reg->dev,
254                          "failed to get regulator value in register %02x\n",
255                          abreg->regreg);
256                 return err;
257         }
258 
259         /* The 3 highest bits index voltages */
260         regval &= 0xE0;
261         regval >>= 5;
262 
263         if (regval >= reg->desc->n_voltages) {
264                 dev_err(&reg->dev,
265                         "regulator register %02x contains an illegal voltage setting\n",
266                         abreg->regreg);
267                 return -EINVAL;
268         }
269 
270         return reg->desc->volt_table[regval];
271 }
272 
273 static int ab3100_set_voltage_regulator_sel(struct regulator_dev *reg,
274                                             unsigned selector)
275 {
276         struct ab3100_regulator *abreg = rdev_get_drvdata(reg);
277         u8 regval;
278         int err;
279 
280         err = abx500_get_register_interruptible(abreg->dev, 0,
281                                                 abreg->regreg, &regval);
282         if (err) {
283                 dev_warn(&reg->dev,
284                          "failed to get regulator register %02x\n",
285                          abreg->regreg);
286                 return err;
287         }
288 
289         /* The highest three bits control the variable regulators */
290         regval &= ~0xE0;
291         regval |= (selector << 5);
292 
293         err = abx500_set_register_interruptible(abreg->dev, 0,
294                                                 abreg->regreg, regval);
295         if (err)
296                 dev_warn(&reg->dev, "failed to set regulator register %02x\n",
297                         abreg->regreg);
298 
299         return err;
300 }
301 
302 static int ab3100_set_suspend_voltage_regulator(struct regulator_dev *reg,
303                                                 int uV)
304 {
305         struct ab3100_regulator *abreg = rdev_get_drvdata(reg);
306         u8 regval;
307         int err;
308         int bestindex;
309         u8 targetreg;
310 
311         if (abreg->regreg == AB3100_LDO_E)
312                 targetreg = AB3100_LDO_E_SLEEP;
313         else if (abreg->regreg == AB3100_BUCK)
314                 targetreg = AB3100_BUCK_SLEEP;
315         else
316                 return -EINVAL;
317 
318         /* LDO E and BUCK have special suspend voltages you can set */
319         bestindex = regulator_map_voltage_iterate(reg, uV, uV);
320 
321         err = abx500_get_register_interruptible(abreg->dev, 0,
322                                                 targetreg, &regval);
323         if (err) {
324                 dev_warn(&reg->dev,
325                          "failed to get regulator register %02x\n",
326                          targetreg);
327                 return err;
328         }
329 
330         /* The highest three bits control the variable regulators */
331         regval &= ~0xE0;
332         regval |= (bestindex << 5);
333 
334         err = abx500_set_register_interruptible(abreg->dev, 0,
335                                                 targetreg, regval);
336         if (err)
337                 dev_warn(&reg->dev, "failed to set regulator register %02x\n",
338                         abreg->regreg);
339 
340         return err;
341 }
342 
343 /*
344  * The external regulator can just define a fixed voltage.
345  */
346 static int ab3100_get_voltage_regulator_external(struct regulator_dev *reg)
347 {
348         struct ab3100_regulator *abreg = rdev_get_drvdata(reg);
349 
350         if (abreg->plfdata)
351                 return abreg->plfdata->external_voltage;
352         else
353                 /* TODO: encode external voltage into device tree */
354                 return 0;
355 }
356 
357 static struct regulator_ops regulator_ops_fixed = {
358         .list_voltage = regulator_list_voltage_linear,
359         .enable      = ab3100_enable_regulator,
360         .disable     = ab3100_disable_regulator,
361         .is_enabled  = ab3100_is_enabled_regulator,
362 };
363 
364 static struct regulator_ops regulator_ops_variable = {
365         .enable      = ab3100_enable_regulator,
366         .disable     = ab3100_disable_regulator,
367         .is_enabled  = ab3100_is_enabled_regulator,
368         .get_voltage = ab3100_get_voltage_regulator,
369         .set_voltage_sel = ab3100_set_voltage_regulator_sel,
370         .list_voltage = regulator_list_voltage_table,
371 };
372 
373 static struct regulator_ops regulator_ops_variable_sleepable = {
374         .enable      = ab3100_enable_regulator,
375         .disable     = ab3100_disable_regulator,
376         .is_enabled  = ab3100_is_enabled_regulator,
377         .get_voltage = ab3100_get_voltage_regulator,
378         .set_voltage_sel = ab3100_set_voltage_regulator_sel,
379         .set_suspend_voltage = ab3100_set_suspend_voltage_regulator,
380         .list_voltage = regulator_list_voltage_table,
381 };
382 
383 /*
384  * LDO EXT is an external regulator so it is really
385  * not possible to set any voltage locally here, AB3100
386  * is an on/off switch plain an simple. The external
387  * voltage is defined in the board set-up if any.
388  */
389 static struct regulator_ops regulator_ops_external = {
390         .enable      = ab3100_enable_regulator,
391         .disable     = ab3100_disable_regulator,
392         .is_enabled  = ab3100_is_enabled_regulator,
393         .get_voltage = ab3100_get_voltage_regulator_external,
394 };
395 
396 static struct regulator_desc
397 ab3100_regulator_desc[AB3100_NUM_REGULATORS] = {
398         {
399                 .name = "LDO_A",
400                 .id   = AB3100_LDO_A,
401                 .ops  = &regulator_ops_fixed,
402                 .n_voltages = 1,
403                 .type = REGULATOR_VOLTAGE,
404                 .owner = THIS_MODULE,
405                 .min_uV = LDO_A_VOLTAGE,
406                 .enable_time = 200,
407         },
408         {
409                 .name = "LDO_C",
410                 .id   = AB3100_LDO_C,
411                 .ops  = &regulator_ops_fixed,
412                 .n_voltages = 1,
413                 .type = REGULATOR_VOLTAGE,
414                 .owner = THIS_MODULE,
415                 .min_uV = LDO_C_VOLTAGE,
416                 .enable_time = 200,
417         },
418         {
419                 .name = "LDO_D",
420                 .id   = AB3100_LDO_D,
421                 .ops  = &regulator_ops_fixed,
422                 .n_voltages = 1,
423                 .type = REGULATOR_VOLTAGE,
424                 .owner = THIS_MODULE,
425                 .min_uV = LDO_D_VOLTAGE,
426                 .enable_time = 200,
427         },
428         {
429                 .name = "LDO_E",
430                 .id   = AB3100_LDO_E,
431                 .ops  = &regulator_ops_variable_sleepable,
432                 .n_voltages = ARRAY_SIZE(ldo_e_buck_typ_voltages),
433                 .volt_table = ldo_e_buck_typ_voltages,
434                 .type = REGULATOR_VOLTAGE,
435                 .owner = THIS_MODULE,
436                 .enable_time = 200,
437         },
438         {
439                 .name = "LDO_F",
440                 .id   = AB3100_LDO_F,
441                 .ops  = &regulator_ops_variable,
442                 .n_voltages = ARRAY_SIZE(ldo_f_typ_voltages),
443                 .volt_table = ldo_f_typ_voltages,
444                 .type = REGULATOR_VOLTAGE,
445                 .owner = THIS_MODULE,
446                 .enable_time = 600,
447         },
448         {
449                 .name = "LDO_G",
450                 .id   = AB3100_LDO_G,
451                 .ops  = &regulator_ops_variable,
452                 .n_voltages = ARRAY_SIZE(ldo_g_typ_voltages),
453                 .volt_table = ldo_g_typ_voltages,
454                 .type = REGULATOR_VOLTAGE,
455                 .owner = THIS_MODULE,
456                 .enable_time = 400,
457         },
458         {
459                 .name = "LDO_H",
460                 .id   = AB3100_LDO_H,
461                 .ops  = &regulator_ops_variable,
462                 .n_voltages = ARRAY_SIZE(ldo_h_typ_voltages),
463                 .volt_table = ldo_h_typ_voltages,
464                 .type = REGULATOR_VOLTAGE,
465                 .owner = THIS_MODULE,
466                 .enable_time = 200,
467         },
468         {
469                 .name = "LDO_K",
470                 .id   = AB3100_LDO_K,
471                 .ops  = &regulator_ops_variable,
472                 .n_voltages = ARRAY_SIZE(ldo_k_typ_voltages),
473                 .volt_table = ldo_k_typ_voltages,
474                 .type = REGULATOR_VOLTAGE,
475                 .owner = THIS_MODULE,
476                 .enable_time = 200,
477         },
478         {
479                 .name = "LDO_EXT",
480                 .id   = AB3100_LDO_EXT,
481                 .ops  = &regulator_ops_external,
482                 .type = REGULATOR_VOLTAGE,
483                 .owner = THIS_MODULE,
484         },
485         {
486                 .name = "BUCK",
487                 .id   = AB3100_BUCK,
488                 .ops  = &regulator_ops_variable_sleepable,
489                 .n_voltages = ARRAY_SIZE(ldo_e_buck_typ_voltages),
490                 .volt_table = ldo_e_buck_typ_voltages,
491                 .type = REGULATOR_VOLTAGE,
492                 .owner = THIS_MODULE,
493                 .enable_time = 1000,
494         },
495 };
496 
497 static int ab3100_regulator_register(struct platform_device *pdev,
498                                      struct ab3100_platform_data *plfdata,
499                                      struct regulator_init_data *init_data,
500                                      struct device_node *np,
501                                      unsigned long id)
502 {
503         struct regulator_desc *desc;
504         struct ab3100_regulator *reg;
505         struct regulator_dev *rdev;
506         struct regulator_config config = { };
507         int err, i;
508 
509         for (i = 0; i < AB3100_NUM_REGULATORS; i++) {
510                 desc = &ab3100_regulator_desc[i];
511                 if (desc->id == id)
512                         break;
513         }
514         if (desc->id != id)
515                 return -ENODEV;
516 
517         /* Same index used for this array */
518         reg = &ab3100_regulators[i];
519 
520         /*
521          * Initialize per-regulator struct.
522          * Inherit platform data, this comes down from the
523          * i2c boarddata, from the machine. So if you want to
524          * see what it looks like for a certain machine, go
525          * into the machine I2C setup.
526          */
527         reg->dev = &pdev->dev;
528         if (plfdata) {
529                 reg->plfdata = plfdata;
530                 config.init_data = &plfdata->reg_constraints[i];
531         } else if (np) {
532                 config.of_node = np;
533                 config.init_data = init_data;
534         }
535         config.dev = &pdev->dev;
536         config.driver_data = reg;
537 
538         rdev = devm_regulator_register(&pdev->dev, desc, &config);
539         if (IS_ERR(rdev)) {
540                 err = PTR_ERR(rdev);
541                 dev_err(&pdev->dev,
542                         "%s: failed to register regulator %s err %d\n",
543                         __func__, desc->name,
544                         err);
545                 return err;
546         }
547 
548         /* Then set a pointer back to the registered regulator */
549         reg->rdev = rdev;
550         return 0;
551 }
552 
553 static struct of_regulator_match ab3100_regulator_matches[] = {
554         { .name = "ab3100_ldo_a", .driver_data = (void *) AB3100_LDO_A, },
555         { .name = "ab3100_ldo_c", .driver_data = (void *) AB3100_LDO_C, },
556         { .name = "ab3100_ldo_d", .driver_data = (void *) AB3100_LDO_D, },
557         { .name = "ab3100_ldo_e", .driver_data = (void *) AB3100_LDO_E, },
558         { .name = "ab3100_ldo_f", .driver_data = (void *) AB3100_LDO_F },
559         { .name = "ab3100_ldo_g", .driver_data = (void *) AB3100_LDO_G },
560         { .name = "ab3100_ldo_h", .driver_data = (void *) AB3100_LDO_H },
561         { .name = "ab3100_ldo_k", .driver_data = (void *) AB3100_LDO_K },
562         { .name = "ab3100_ext", .driver_data = (void *) AB3100_LDO_EXT },
563         { .name = "ab3100_buck", .driver_data = (void *) AB3100_BUCK },
564 };
565 
566 /*
567  * Initial settings of ab3100 registers.
568  * Common for below LDO regulator settings are that
569  * bit 7-5 controls voltage. Bit 4 turns regulator ON(1) or OFF(0).
570  * Bit 3-2 controls sleep enable and bit 1-0 controls sleep mode.
571  */
572 /* LDO_A 0x16: 2.75V, ON, SLEEP_A, SLEEP OFF GND */
573 #define LDO_A_SETTING           0x16
574 /* LDO_C 0x10: 2.65V, ON, SLEEP_A or B, SLEEP full power */
575 #define LDO_C_SETTING           0x10
576 /* LDO_D 0x10: 2.65V, ON, sleep mode not used */
577 #define LDO_D_SETTING           0x10
578 /* LDO_E 0x10: 1.8V, ON, SLEEP_A or B, SLEEP full power */
579 #define LDO_E_SETTING           0x10
580 /* LDO_E SLEEP 0x00: 1.8V, not used, SLEEP_A or B, not used */
581 #define LDO_E_SLEEP_SETTING     0x00
582 /* LDO_F 0xD0: 2.5V, ON, SLEEP_A or B, SLEEP full power */
583 #define LDO_F_SETTING           0xD0
584 /* LDO_G 0x00: 2.85V, OFF, SLEEP_A or B, SLEEP full power */
585 #define LDO_G_SETTING           0x00
586 /* LDO_H 0x18: 2.75V, ON, SLEEP_B, SLEEP full power */
587 #define LDO_H_SETTING           0x18
588 /* LDO_K 0x00: 2.75V, OFF, SLEEP_A or B, SLEEP full power */
589 #define LDO_K_SETTING           0x00
590 /* LDO_EXT 0x00: Voltage not set, OFF, not used, not used */
591 #define LDO_EXT_SETTING         0x00
592 /* BUCK 0x7D: 1.2V, ON, SLEEP_A and B, SLEEP low power */
593 #define BUCK_SETTING    0x7D
594 /* BUCK SLEEP 0xAC: 1.05V, Not used, SLEEP_A and B, Not used */
595 #define BUCK_SLEEP_SETTING      0xAC
596 
597 static const u8 ab3100_reg_initvals[] = {
598         LDO_A_SETTING,
599         LDO_C_SETTING,
600         LDO_E_SETTING,
601         LDO_E_SLEEP_SETTING,
602         LDO_F_SETTING,
603         LDO_G_SETTING,
604         LDO_H_SETTING,
605         LDO_K_SETTING,
606         LDO_EXT_SETTING,
607         BUCK_SETTING,
608         BUCK_SLEEP_SETTING,
609         LDO_D_SETTING,
610 };
611 
612 static int ab3100_regulators_remove(struct platform_device *pdev)
613 {
614         int i;
615 
616         for (i = 0; i < AB3100_NUM_REGULATORS; i++) {
617                 struct ab3100_regulator *reg = &ab3100_regulators[i];
618 
619                 reg->rdev = NULL;
620         }
621         return 0;
622 }
623 
624 static int
625 ab3100_regulator_of_probe(struct platform_device *pdev, struct device_node *np)
626 {
627         int err, i;
628 
629         /*
630          * Set up the regulator registers, as was previously done with
631          * platform data.
632          */
633         /* Set up regulators */
634         for (i = 0; i < ARRAY_SIZE(ab3100_reg_init_order); i++) {
635                 err = abx500_set_register_interruptible(&pdev->dev, 0,
636                                         ab3100_reg_init_order[i],
637                                         ab3100_reg_initvals[i]);
638                 if (err) {
639                         dev_err(&pdev->dev, "regulator initialization failed with error %d\n",
640                                 err);
641                         return err;
642                 }
643         }
644 
645         for (i = 0; i < ARRAY_SIZE(ab3100_regulator_matches); i++) {
646                 err = ab3100_regulator_register(
647                         pdev, NULL, ab3100_regulator_matches[i].init_data,
648                         ab3100_regulator_matches[i].of_node,
649                         (unsigned long)ab3100_regulator_matches[i].driver_data);
650                 if (err) {
651                         ab3100_regulators_remove(pdev);
652                         return err;
653                 }
654         }
655 
656         return 0;
657 }
658 
659 
660 static int ab3100_regulators_probe(struct platform_device *pdev)
661 {
662         struct ab3100_platform_data *plfdata = dev_get_platdata(&pdev->dev);
663         struct device_node *np = pdev->dev.of_node;
664         int err = 0;
665         u8 data;
666         int i;
667 
668         /* Check chip state */
669         err = abx500_get_register_interruptible(&pdev->dev, 0,
670                                                 AB3100_LDO_D, &data);
671         if (err) {
672                 dev_err(&pdev->dev, "could not read initial status of LDO_D\n");
673                 return err;
674         }
675         if (data & 0x10)
676                 dev_notice(&pdev->dev,
677                            "chip is already in active mode (Warm start)\n");
678         else
679                 dev_notice(&pdev->dev,
680                            "chip is in inactive mode (Cold start)\n");
681 
682         if (np) {
683                 err = of_regulator_match(&pdev->dev, np,
684                                          ab3100_regulator_matches,
685                                          ARRAY_SIZE(ab3100_regulator_matches));
686                 if (err < 0) {
687                         dev_err(&pdev->dev,
688                                 "Error parsing regulator init data: %d\n", err);
689                         return err;
690                 }
691                 return ab3100_regulator_of_probe(pdev, np);
692         }
693 
694         /* Set up regulators */
695         for (i = 0; i < ARRAY_SIZE(ab3100_reg_init_order); i++) {
696                 err = abx500_set_register_interruptible(&pdev->dev, 0,
697                                         ab3100_reg_init_order[i],
698                                         plfdata->reg_initvals[i]);
699                 if (err) {
700                         dev_err(&pdev->dev, "regulator initialization failed with error %d\n",
701                                 err);
702                         return err;
703                 }
704         }
705 
706         /* Register the regulators */
707         for (i = 0; i < AB3100_NUM_REGULATORS; i++) {
708                 struct regulator_desc *desc = &ab3100_regulator_desc[i];
709 
710                 err = ab3100_regulator_register(pdev, plfdata, NULL, NULL,
711                                                 desc->id);
712                 if (err) {
713                         ab3100_regulators_remove(pdev);
714                         return err;
715                 }
716         }
717 
718         return 0;
719 }
720 
721 static struct platform_driver ab3100_regulators_driver = {
722         .driver = {
723                 .name  = "ab3100-regulators",
724                 .owner = THIS_MODULE,
725         },
726         .probe = ab3100_regulators_probe,
727         .remove = ab3100_regulators_remove,
728 };
729 
730 static __init int ab3100_regulators_init(void)
731 {
732         return platform_driver_register(&ab3100_regulators_driver);
733 }
734 
735 static __exit void ab3100_regulators_exit(void)
736 {
737         platform_driver_unregister(&ab3100_regulators_driver);
738 }
739 
740 subsys_initcall(ab3100_regulators_init);
741 module_exit(ab3100_regulators_exit);
742 
743 MODULE_AUTHOR("Mattias Wallin <mattias.wallin@stericsson.com>");
744 MODULE_DESCRIPTION("AB3100 Regulator driver");
745 MODULE_LICENSE("GPL");
746 MODULE_ALIAS("platform:ab3100-regulators");
747 

This page was automatically generated by LXR 0.3.1 (source).  •  Linux is a registered trademark of Linus Torvalds  •  Contact us