Version:  2.0.40 2.2.26 2.4.37 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 3.15 3.16

Linux/drivers/regulator/palmas-regulator.c

  1 /*
  2  * Driver for Regulator part of Palmas PMIC Chips
  3  *
  4  * Copyright 2011-2013 Texas Instruments Inc.
  5  *
  6  * Author: Graeme Gregory <gg@slimlogic.co.uk>
  7  * Author: Ian Lartey <ian@slimlogic.co.uk>
  8  *
  9  *  This program is free software; you can redistribute it and/or modify it
 10  *  under  the terms of the GNU General  Public License as published by the
 11  *  Free Software Foundation;  either version 2 of the License, or (at your
 12  *  option) any later version.
 13  *
 14  */
 15 
 16 #include <linux/kernel.h>
 17 #include <linux/module.h>
 18 #include <linux/init.h>
 19 #include <linux/err.h>
 20 #include <linux/platform_device.h>
 21 #include <linux/regulator/driver.h>
 22 #include <linux/regulator/machine.h>
 23 #include <linux/slab.h>
 24 #include <linux/regmap.h>
 25 #include <linux/mfd/palmas.h>
 26 #include <linux/of.h>
 27 #include <linux/of_platform.h>
 28 #include <linux/regulator/of_regulator.h>
 29 
 30 struct regs_info {
 31         char    *name;
 32         char    *sname;
 33         u8      vsel_addr;
 34         u8      ctrl_addr;
 35         u8      tstep_addr;
 36         int     sleep_id;
 37 };
 38 
 39 static const struct regulator_linear_range smps_low_ranges[] = {
 40         REGULATOR_LINEAR_RANGE(0, 0x0, 0x0, 0),
 41         REGULATOR_LINEAR_RANGE(500000, 0x1, 0x6, 0),
 42         REGULATOR_LINEAR_RANGE(510000, 0x7, 0x79, 10000),
 43         REGULATOR_LINEAR_RANGE(1650000, 0x7A, 0x7f, 0),
 44 };
 45 
 46 static const struct regulator_linear_range smps_high_ranges[] = {
 47         REGULATOR_LINEAR_RANGE(0, 0x0, 0x0, 0),
 48         REGULATOR_LINEAR_RANGE(1000000, 0x1, 0x6, 0),
 49         REGULATOR_LINEAR_RANGE(1020000, 0x7, 0x79, 20000),
 50         REGULATOR_LINEAR_RANGE(3300000, 0x7A, 0x7f, 0),
 51 };
 52 
 53 static const struct regs_info palmas_regs_info[] = {
 54         {
 55                 .name           = "SMPS12",
 56                 .sname          = "smps1-in",
 57                 .vsel_addr      = PALMAS_SMPS12_VOLTAGE,
 58                 .ctrl_addr      = PALMAS_SMPS12_CTRL,
 59                 .tstep_addr     = PALMAS_SMPS12_TSTEP,
 60                 .sleep_id       = PALMAS_EXTERNAL_REQSTR_ID_SMPS12,
 61         },
 62         {
 63                 .name           = "SMPS123",
 64                 .sname          = "smps1-in",
 65                 .vsel_addr      = PALMAS_SMPS12_VOLTAGE,
 66                 .ctrl_addr      = PALMAS_SMPS12_CTRL,
 67                 .tstep_addr     = PALMAS_SMPS12_TSTEP,
 68                 .sleep_id       = PALMAS_EXTERNAL_REQSTR_ID_SMPS12,
 69         },
 70         {
 71                 .name           = "SMPS3",
 72                 .sname          = "smps3-in",
 73                 .vsel_addr      = PALMAS_SMPS3_VOLTAGE,
 74                 .ctrl_addr      = PALMAS_SMPS3_CTRL,
 75                 .sleep_id       = PALMAS_EXTERNAL_REQSTR_ID_SMPS3,
 76         },
 77         {
 78                 .name           = "SMPS45",
 79                 .sname          = "smps4-in",
 80                 .vsel_addr      = PALMAS_SMPS45_VOLTAGE,
 81                 .ctrl_addr      = PALMAS_SMPS45_CTRL,
 82                 .tstep_addr     = PALMAS_SMPS45_TSTEP,
 83                 .sleep_id       = PALMAS_EXTERNAL_REQSTR_ID_SMPS45,
 84         },
 85         {
 86                 .name           = "SMPS457",
 87                 .sname          = "smps4-in",
 88                 .vsel_addr      = PALMAS_SMPS45_VOLTAGE,
 89                 .ctrl_addr      = PALMAS_SMPS45_CTRL,
 90                 .tstep_addr     = PALMAS_SMPS45_TSTEP,
 91                 .sleep_id       = PALMAS_EXTERNAL_REQSTR_ID_SMPS45,
 92         },
 93         {
 94                 .name           = "SMPS6",
 95                 .sname          = "smps6-in",
 96                 .vsel_addr      = PALMAS_SMPS6_VOLTAGE,
 97                 .ctrl_addr      = PALMAS_SMPS6_CTRL,
 98                 .tstep_addr     = PALMAS_SMPS6_TSTEP,
 99                 .sleep_id       = PALMAS_EXTERNAL_REQSTR_ID_SMPS6,
100         },
101         {
102                 .name           = "SMPS7",
103                 .sname          = "smps7-in",
104                 .vsel_addr      = PALMAS_SMPS7_VOLTAGE,
105                 .ctrl_addr      = PALMAS_SMPS7_CTRL,
106                 .sleep_id       = PALMAS_EXTERNAL_REQSTR_ID_SMPS7,
107         },
108         {
109                 .name           = "SMPS8",
110                 .sname          = "smps8-in",
111                 .vsel_addr      = PALMAS_SMPS8_VOLTAGE,
112                 .ctrl_addr      = PALMAS_SMPS8_CTRL,
113                 .tstep_addr     = PALMAS_SMPS8_TSTEP,
114                 .sleep_id       = PALMAS_EXTERNAL_REQSTR_ID_SMPS8,
115         },
116         {
117                 .name           = "SMPS9",
118                 .sname          = "smps9-in",
119                 .vsel_addr      = PALMAS_SMPS9_VOLTAGE,
120                 .ctrl_addr      = PALMAS_SMPS9_CTRL,
121                 .sleep_id       = PALMAS_EXTERNAL_REQSTR_ID_SMPS9,
122         },
123         {
124                 .name           = "SMPS10_OUT2",
125                 .sname          = "smps10-in",
126                 .ctrl_addr      = PALMAS_SMPS10_CTRL,
127                 .sleep_id       = PALMAS_EXTERNAL_REQSTR_ID_SMPS10,
128         },
129         {
130                 .name           = "SMPS10_OUT1",
131                 .sname          = "smps10-out2",
132                 .ctrl_addr      = PALMAS_SMPS10_CTRL,
133                 .sleep_id       = PALMAS_EXTERNAL_REQSTR_ID_SMPS10,
134         },
135         {
136                 .name           = "LDO1",
137                 .sname          = "ldo1-in",
138                 .vsel_addr      = PALMAS_LDO1_VOLTAGE,
139                 .ctrl_addr      = PALMAS_LDO1_CTRL,
140                 .sleep_id       = PALMAS_EXTERNAL_REQSTR_ID_LDO1,
141         },
142         {
143                 .name           = "LDO2",
144                 .sname          = "ldo2-in",
145                 .vsel_addr      = PALMAS_LDO2_VOLTAGE,
146                 .ctrl_addr      = PALMAS_LDO2_CTRL,
147                 .sleep_id       = PALMAS_EXTERNAL_REQSTR_ID_LDO2,
148         },
149         {
150                 .name           = "LDO3",
151                 .sname          = "ldo3-in",
152                 .vsel_addr      = PALMAS_LDO3_VOLTAGE,
153                 .ctrl_addr      = PALMAS_LDO3_CTRL,
154                 .sleep_id       = PALMAS_EXTERNAL_REQSTR_ID_LDO3,
155         },
156         {
157                 .name           = "LDO4",
158                 .sname          = "ldo4-in",
159                 .vsel_addr      = PALMAS_LDO4_VOLTAGE,
160                 .ctrl_addr      = PALMAS_LDO4_CTRL,
161                 .sleep_id       = PALMAS_EXTERNAL_REQSTR_ID_LDO4,
162         },
163         {
164                 .name           = "LDO5",
165                 .sname          = "ldo5-in",
166                 .vsel_addr      = PALMAS_LDO5_VOLTAGE,
167                 .ctrl_addr      = PALMAS_LDO5_CTRL,
168                 .sleep_id       = PALMAS_EXTERNAL_REQSTR_ID_LDO5,
169         },
170         {
171                 .name           = "LDO6",
172                 .sname          = "ldo6-in",
173                 .vsel_addr      = PALMAS_LDO6_VOLTAGE,
174                 .ctrl_addr      = PALMAS_LDO6_CTRL,
175                 .sleep_id       = PALMAS_EXTERNAL_REQSTR_ID_LDO6,
176         },
177         {
178                 .name           = "LDO7",
179                 .sname          = "ldo7-in",
180                 .vsel_addr      = PALMAS_LDO7_VOLTAGE,
181                 .ctrl_addr      = PALMAS_LDO7_CTRL,
182                 .sleep_id       = PALMAS_EXTERNAL_REQSTR_ID_LDO7,
183         },
184         {
185                 .name           = "LDO8",
186                 .sname          = "ldo8-in",
187                 .vsel_addr      = PALMAS_LDO8_VOLTAGE,
188                 .ctrl_addr      = PALMAS_LDO8_CTRL,
189                 .sleep_id       = PALMAS_EXTERNAL_REQSTR_ID_LDO8,
190         },
191         {
192                 .name           = "LDO9",
193                 .sname          = "ldo9-in",
194                 .vsel_addr      = PALMAS_LDO9_VOLTAGE,
195                 .ctrl_addr      = PALMAS_LDO9_CTRL,
196                 .sleep_id       = PALMAS_EXTERNAL_REQSTR_ID_LDO9,
197         },
198         {
199                 .name           = "LDOLN",
200                 .sname          = "ldoln-in",
201                 .vsel_addr      = PALMAS_LDOLN_VOLTAGE,
202                 .ctrl_addr      = PALMAS_LDOLN_CTRL,
203                 .sleep_id       = PALMAS_EXTERNAL_REQSTR_ID_LDOLN,
204         },
205         {
206                 .name           = "LDOUSB",
207                 .sname          = "ldousb-in",
208                 .vsel_addr      = PALMAS_LDOUSB_VOLTAGE,
209                 .ctrl_addr      = PALMAS_LDOUSB_CTRL,
210                 .sleep_id       = PALMAS_EXTERNAL_REQSTR_ID_LDOUSB,
211         },
212         {
213                 .name           = "REGEN1",
214                 .ctrl_addr      = PALMAS_REGEN1_CTRL,
215                 .sleep_id       = PALMAS_EXTERNAL_REQSTR_ID_REGEN1,
216         },
217         {
218                 .name           = "REGEN2",
219                 .ctrl_addr      = PALMAS_REGEN2_CTRL,
220                 .sleep_id       = PALMAS_EXTERNAL_REQSTR_ID_REGEN2,
221         },
222         {
223                 .name           = "REGEN3",
224                 .ctrl_addr      = PALMAS_REGEN3_CTRL,
225                 .sleep_id       = PALMAS_EXTERNAL_REQSTR_ID_REGEN3,
226         },
227         {
228                 .name           = "SYSEN1",
229                 .ctrl_addr      = PALMAS_SYSEN1_CTRL,
230                 .sleep_id       = PALMAS_EXTERNAL_REQSTR_ID_SYSEN1,
231         },
232         {
233                 .name           = "SYSEN2",
234                 .ctrl_addr      = PALMAS_SYSEN2_CTRL,
235                 .sleep_id       = PALMAS_EXTERNAL_REQSTR_ID_SYSEN2,
236         },
237 };
238 
239 static unsigned int palmas_smps_ramp_delay[4] = {0, 10000, 5000, 2500};
240 
241 #define SMPS_CTRL_MODE_OFF              0x00
242 #define SMPS_CTRL_MODE_ON               0x01
243 #define SMPS_CTRL_MODE_ECO              0x02
244 #define SMPS_CTRL_MODE_PWM              0x03
245 
246 #define PALMAS_SMPS_NUM_VOLTAGES        122
247 #define PALMAS_SMPS10_NUM_VOLTAGES      2
248 #define PALMAS_LDO_NUM_VOLTAGES         50
249 
250 #define SMPS10_VSEL                     (1<<3)
251 #define SMPS10_BOOST_EN                 (1<<2)
252 #define SMPS10_BYPASS_EN                (1<<1)
253 #define SMPS10_SWITCH_EN                (1<<0)
254 
255 #define REGULATOR_SLAVE                 0
256 
257 static int palmas_smps_read(struct palmas *palmas, unsigned int reg,
258                 unsigned int *dest)
259 {
260         unsigned int addr;
261 
262         addr = PALMAS_BASE_TO_REG(PALMAS_SMPS_BASE, reg);
263 
264         return regmap_read(palmas->regmap[REGULATOR_SLAVE], addr, dest);
265 }
266 
267 static int palmas_smps_write(struct palmas *palmas, unsigned int reg,
268                 unsigned int value)
269 {
270         unsigned int addr;
271 
272         addr = PALMAS_BASE_TO_REG(PALMAS_SMPS_BASE, reg);
273 
274         return regmap_write(palmas->regmap[REGULATOR_SLAVE], addr, value);
275 }
276 
277 static int palmas_ldo_read(struct palmas *palmas, unsigned int reg,
278                 unsigned int *dest)
279 {
280         unsigned int addr;
281 
282         addr = PALMAS_BASE_TO_REG(PALMAS_LDO_BASE, reg);
283 
284         return regmap_read(palmas->regmap[REGULATOR_SLAVE], addr, dest);
285 }
286 
287 static int palmas_ldo_write(struct palmas *palmas, unsigned int reg,
288                 unsigned int value)
289 {
290         unsigned int addr;
291 
292         addr = PALMAS_BASE_TO_REG(PALMAS_LDO_BASE, reg);
293 
294         return regmap_write(palmas->regmap[REGULATOR_SLAVE], addr, value);
295 }
296 
297 static int palmas_set_mode_smps(struct regulator_dev *dev, unsigned int mode)
298 {
299         struct palmas_pmic *pmic = rdev_get_drvdata(dev);
300         int id = rdev_get_id(dev);
301         unsigned int reg;
302         bool rail_enable = true;
303 
304         palmas_smps_read(pmic->palmas, palmas_regs_info[id].ctrl_addr, &reg);
305         reg &= ~PALMAS_SMPS12_CTRL_MODE_ACTIVE_MASK;
306 
307         if (reg == SMPS_CTRL_MODE_OFF)
308                 rail_enable = false;
309 
310         switch (mode) {
311         case REGULATOR_MODE_NORMAL:
312                 reg |= SMPS_CTRL_MODE_ON;
313                 break;
314         case REGULATOR_MODE_IDLE:
315                 reg |= SMPS_CTRL_MODE_ECO;
316                 break;
317         case REGULATOR_MODE_FAST:
318                 reg |= SMPS_CTRL_MODE_PWM;
319                 break;
320         default:
321                 return -EINVAL;
322         }
323 
324         pmic->current_reg_mode[id] = reg & PALMAS_SMPS12_CTRL_MODE_ACTIVE_MASK;
325         if (rail_enable)
326                 palmas_smps_write(pmic->palmas,
327                         palmas_regs_info[id].ctrl_addr, reg);
328 
329         /* Switch the enable value to ensure this is used for enable */
330         pmic->desc[id].enable_val = pmic->current_reg_mode[id];
331 
332         return 0;
333 }
334 
335 static unsigned int palmas_get_mode_smps(struct regulator_dev *dev)
336 {
337         struct palmas_pmic *pmic = rdev_get_drvdata(dev);
338         int id = rdev_get_id(dev);
339         unsigned int reg;
340 
341         reg = pmic->current_reg_mode[id] & PALMAS_SMPS12_CTRL_MODE_ACTIVE_MASK;
342 
343         switch (reg) {
344         case SMPS_CTRL_MODE_ON:
345                 return REGULATOR_MODE_NORMAL;
346         case SMPS_CTRL_MODE_ECO:
347                 return REGULATOR_MODE_IDLE;
348         case SMPS_CTRL_MODE_PWM:
349                 return REGULATOR_MODE_FAST;
350         }
351 
352         return 0;
353 }
354 
355 static int palmas_smps_set_ramp_delay(struct regulator_dev *rdev,
356                  int ramp_delay)
357 {
358         struct palmas_pmic *pmic = rdev_get_drvdata(rdev);
359         int id = rdev_get_id(rdev);
360         unsigned int reg = 0;
361         unsigned int addr = palmas_regs_info[id].tstep_addr;
362         int ret;
363 
364         /* SMPS3 and SMPS7 do not have tstep_addr setting */
365         switch (id) {
366         case PALMAS_REG_SMPS3:
367         case PALMAS_REG_SMPS7:
368                 return 0;
369         }
370 
371         if (ramp_delay <= 0)
372                 reg = 0;
373         else if (ramp_delay <= 2500)
374                 reg = 3;
375         else if (ramp_delay <= 5000)
376                 reg = 2;
377         else
378                 reg = 1;
379 
380         ret = palmas_smps_write(pmic->palmas, addr, reg);
381         if (ret < 0) {
382                 dev_err(pmic->palmas->dev, "TSTEP write failed: %d\n", ret);
383                 return ret;
384         }
385 
386         pmic->ramp_delay[id] = palmas_smps_ramp_delay[reg];
387         return ret;
388 }
389 
390 static struct regulator_ops palmas_ops_smps = {
391         .is_enabled             = regulator_is_enabled_regmap,
392         .enable                 = regulator_enable_regmap,
393         .disable                = regulator_disable_regmap,
394         .set_mode               = palmas_set_mode_smps,
395         .get_mode               = palmas_get_mode_smps,
396         .get_voltage_sel        = regulator_get_voltage_sel_regmap,
397         .set_voltage_sel        = regulator_set_voltage_sel_regmap,
398         .list_voltage           = regulator_list_voltage_linear_range,
399         .map_voltage            = regulator_map_voltage_linear_range,
400         .set_voltage_time_sel   = regulator_set_voltage_time_sel,
401         .set_ramp_delay         = palmas_smps_set_ramp_delay,
402 };
403 
404 static struct regulator_ops palmas_ops_ext_control_smps = {
405         .set_mode               = palmas_set_mode_smps,
406         .get_mode               = palmas_get_mode_smps,
407         .get_voltage_sel        = regulator_get_voltage_sel_regmap,
408         .set_voltage_sel        = regulator_set_voltage_sel_regmap,
409         .list_voltage           = regulator_list_voltage_linear_range,
410         .map_voltage            = regulator_map_voltage_linear_range,
411         .set_voltage_time_sel   = regulator_set_voltage_time_sel,
412         .set_ramp_delay         = palmas_smps_set_ramp_delay,
413 };
414 
415 static struct regulator_ops palmas_ops_smps10 = {
416         .is_enabled             = regulator_is_enabled_regmap,
417         .enable                 = regulator_enable_regmap,
418         .disable                = regulator_disable_regmap,
419         .get_voltage_sel        = regulator_get_voltage_sel_regmap,
420         .set_voltage_sel        = regulator_set_voltage_sel_regmap,
421         .list_voltage           = regulator_list_voltage_linear,
422         .map_voltage            = regulator_map_voltage_linear,
423         .set_bypass             = regulator_set_bypass_regmap,
424         .get_bypass             = regulator_get_bypass_regmap,
425 };
426 
427 static int palmas_is_enabled_ldo(struct regulator_dev *dev)
428 {
429         struct palmas_pmic *pmic = rdev_get_drvdata(dev);
430         int id = rdev_get_id(dev);
431         unsigned int reg;
432 
433         palmas_ldo_read(pmic->palmas, palmas_regs_info[id].ctrl_addr, &reg);
434 
435         reg &= PALMAS_LDO1_CTRL_STATUS;
436 
437         return !!(reg);
438 }
439 
440 static struct regulator_ops palmas_ops_ldo = {
441         .is_enabled             = palmas_is_enabled_ldo,
442         .enable                 = regulator_enable_regmap,
443         .disable                = regulator_disable_regmap,
444         .get_voltage_sel        = regulator_get_voltage_sel_regmap,
445         .set_voltage_sel        = regulator_set_voltage_sel_regmap,
446         .list_voltage           = regulator_list_voltage_linear,
447         .map_voltage            = regulator_map_voltage_linear,
448 };
449 
450 static struct regulator_ops palmas_ops_ext_control_ldo = {
451         .get_voltage_sel        = regulator_get_voltage_sel_regmap,
452         .set_voltage_sel        = regulator_set_voltage_sel_regmap,
453         .list_voltage           = regulator_list_voltage_linear,
454         .map_voltage            = regulator_map_voltage_linear,
455 };
456 
457 static struct regulator_ops palmas_ops_extreg = {
458         .is_enabled             = regulator_is_enabled_regmap,
459         .enable                 = regulator_enable_regmap,
460         .disable                = regulator_disable_regmap,
461 };
462 
463 static struct regulator_ops palmas_ops_ext_control_extreg = {
464 };
465 
466 static int palmas_regulator_config_external(struct palmas *palmas, int id,
467                 struct palmas_reg_init *reg_init)
468 {
469         int sleep_id = palmas_regs_info[id].sleep_id;
470         int ret;
471 
472         ret = palmas_ext_control_req_config(palmas, sleep_id,
473                                         reg_init->roof_floor, true);
474         if (ret < 0)
475                 dev_err(palmas->dev,
476                         "Ext control config for regulator %d failed %d\n",
477                         id, ret);
478         return ret;
479 }
480 
481 /*
482  * setup the hardware based sleep configuration of the SMPS/LDO regulators
483  * from the platform data. This is different to the software based control
484  * supported by the regulator framework as it is controlled by toggling
485  * pins on the PMIC such as PREQ, SYSEN, ...
486  */
487 static int palmas_smps_init(struct palmas *palmas, int id,
488                 struct palmas_reg_init *reg_init)
489 {
490         unsigned int reg;
491         unsigned int addr;
492         int ret;
493 
494         addr = palmas_regs_info[id].ctrl_addr;
495 
496         ret = palmas_smps_read(palmas, addr, &reg);
497         if (ret)
498                 return ret;
499 
500         switch (id) {
501         case PALMAS_REG_SMPS10_OUT1:
502         case PALMAS_REG_SMPS10_OUT2:
503                 reg &= ~PALMAS_SMPS10_CTRL_MODE_SLEEP_MASK;
504                 if (reg_init->mode_sleep)
505                         reg |= reg_init->mode_sleep <<
506                                         PALMAS_SMPS10_CTRL_MODE_SLEEP_SHIFT;
507                 break;
508         default:
509                 if (reg_init->warm_reset)
510                         reg |= PALMAS_SMPS12_CTRL_WR_S;
511                 else
512                         reg &= ~PALMAS_SMPS12_CTRL_WR_S;
513 
514                 if (reg_init->roof_floor)
515                         reg |= PALMAS_SMPS12_CTRL_ROOF_FLOOR_EN;
516                 else
517                         reg &= ~PALMAS_SMPS12_CTRL_ROOF_FLOOR_EN;
518 
519                 reg &= ~PALMAS_SMPS12_CTRL_MODE_SLEEP_MASK;
520                 if (reg_init->mode_sleep)
521                         reg |= reg_init->mode_sleep <<
522                                         PALMAS_SMPS12_CTRL_MODE_SLEEP_SHIFT;
523         }
524 
525         ret = palmas_smps_write(palmas, addr, reg);
526         if (ret)
527                 return ret;
528 
529         if (palmas_regs_info[id].vsel_addr && reg_init->vsel) {
530                 addr = palmas_regs_info[id].vsel_addr;
531 
532                 reg = reg_init->vsel;
533 
534                 ret = palmas_smps_write(palmas, addr, reg);
535                 if (ret)
536                         return ret;
537         }
538 
539         if (reg_init->roof_floor && (id != PALMAS_REG_SMPS10_OUT1) &&
540                         (id != PALMAS_REG_SMPS10_OUT2)) {
541                 /* Enable externally controlled regulator */
542                 addr = palmas_regs_info[id].ctrl_addr;
543                 ret = palmas_smps_read(palmas, addr, &reg);
544                 if (ret < 0)
545                         return ret;
546 
547                 if (!(reg & PALMAS_SMPS12_CTRL_MODE_ACTIVE_MASK)) {
548                         reg |= SMPS_CTRL_MODE_ON;
549                         ret = palmas_smps_write(palmas, addr, reg);
550                         if (ret < 0)
551                                 return ret;
552                 }
553                 return palmas_regulator_config_external(palmas, id, reg_init);
554         }
555         return 0;
556 }
557 
558 static int palmas_ldo_init(struct palmas *palmas, int id,
559                 struct palmas_reg_init *reg_init)
560 {
561         unsigned int reg;
562         unsigned int addr;
563         int ret;
564 
565         addr = palmas_regs_info[id].ctrl_addr;
566 
567         ret = palmas_ldo_read(palmas, addr, &reg);
568         if (ret)
569                 return ret;
570 
571         if (reg_init->warm_reset)
572                 reg |= PALMAS_LDO1_CTRL_WR_S;
573         else
574                 reg &= ~PALMAS_LDO1_CTRL_WR_S;
575 
576         if (reg_init->mode_sleep)
577                 reg |= PALMAS_LDO1_CTRL_MODE_SLEEP;
578         else
579                 reg &= ~PALMAS_LDO1_CTRL_MODE_SLEEP;
580 
581         ret = palmas_ldo_write(palmas, addr, reg);
582         if (ret)
583                 return ret;
584 
585         if (reg_init->roof_floor) {
586                 /* Enable externally controlled regulator */
587                 addr = palmas_regs_info[id].ctrl_addr;
588                 ret = palmas_update_bits(palmas, PALMAS_LDO_BASE,
589                                 addr, PALMAS_LDO1_CTRL_MODE_ACTIVE,
590                                 PALMAS_LDO1_CTRL_MODE_ACTIVE);
591                 if (ret < 0) {
592                         dev_err(palmas->dev,
593                                 "LDO Register 0x%02x update failed %d\n",
594                                 addr, ret);
595                         return ret;
596                 }
597                 return palmas_regulator_config_external(palmas, id, reg_init);
598         }
599         return 0;
600 }
601 
602 static int palmas_extreg_init(struct palmas *palmas, int id,
603                 struct palmas_reg_init *reg_init)
604 {
605         unsigned int addr;
606         int ret;
607         unsigned int val = 0;
608 
609         addr = palmas_regs_info[id].ctrl_addr;
610 
611         if (reg_init->mode_sleep)
612                 val = PALMAS_REGEN1_CTRL_MODE_SLEEP;
613 
614         ret = palmas_update_bits(palmas, PALMAS_RESOURCE_BASE,
615                         addr, PALMAS_REGEN1_CTRL_MODE_SLEEP, val);
616         if (ret < 0) {
617                 dev_err(palmas->dev, "Resource reg 0x%02x update failed %d\n",
618                         addr, ret);
619                 return ret;
620         }
621 
622         if (reg_init->roof_floor) {
623                 /* Enable externally controlled regulator */
624                 addr = palmas_regs_info[id].ctrl_addr;
625                 ret = palmas_update_bits(palmas, PALMAS_RESOURCE_BASE,
626                                 addr, PALMAS_REGEN1_CTRL_MODE_ACTIVE,
627                                 PALMAS_REGEN1_CTRL_MODE_ACTIVE);
628                 if (ret < 0) {
629                         dev_err(palmas->dev,
630                                 "Resource Register 0x%02x update failed %d\n",
631                                 addr, ret);
632                         return ret;
633                 }
634                 return palmas_regulator_config_external(palmas, id, reg_init);
635         }
636         return 0;
637 }
638 
639 static void palmas_enable_ldo8_track(struct palmas *palmas)
640 {
641         unsigned int reg;
642         unsigned int addr;
643         int ret;
644 
645         addr = palmas_regs_info[PALMAS_REG_LDO8].ctrl_addr;
646 
647         ret = palmas_ldo_read(palmas, addr, &reg);
648         if (ret) {
649                 dev_err(palmas->dev, "Error in reading ldo8 control reg\n");
650                 return;
651         }
652 
653         reg |= PALMAS_LDO8_CTRL_LDO_TRACKING_EN;
654         ret = palmas_ldo_write(palmas, addr, reg);
655         if (ret < 0) {
656                 dev_err(palmas->dev, "Error in enabling tracking mode\n");
657                 return;
658         }
659         /*
660          * When SMPS45 is set to off and LDO8 tracking is enabled, the LDO8
661          * output is defined by the LDO8_VOLTAGE.VSEL register divided by two,
662          * and can be set from 0.45 to 1.65 V.
663          */
664         addr = palmas_regs_info[PALMAS_REG_LDO8].vsel_addr;
665         ret = palmas_ldo_read(palmas, addr, &reg);
666         if (ret) {
667                 dev_err(palmas->dev, "Error in reading ldo8 voltage reg\n");
668                 return;
669         }
670 
671         reg = (reg << 1) & PALMAS_LDO8_VOLTAGE_VSEL_MASK;
672         ret = palmas_ldo_write(palmas, addr, reg);
673         if (ret < 0)
674                 dev_err(palmas->dev, "Error in setting ldo8 voltage reg\n");
675 
676         return;
677 }
678 
679 static struct of_regulator_match palmas_matches[] = {
680         { .name = "smps12", },
681         { .name = "smps123", },
682         { .name = "smps3", },
683         { .name = "smps45", },
684         { .name = "smps457", },
685         { .name = "smps6", },
686         { .name = "smps7", },
687         { .name = "smps8", },
688         { .name = "smps9", },
689         { .name = "smps10_out2", },
690         { .name = "smps10_out1", },
691         { .name = "ldo1", },
692         { .name = "ldo2", },
693         { .name = "ldo3", },
694         { .name = "ldo4", },
695         { .name = "ldo5", },
696         { .name = "ldo6", },
697         { .name = "ldo7", },
698         { .name = "ldo8", },
699         { .name = "ldo9", },
700         { .name = "ldoln", },
701         { .name = "ldousb", },
702         { .name = "regen1", },
703         { .name = "regen2", },
704         { .name = "regen3", },
705         { .name = "sysen1", },
706         { .name = "sysen2", },
707 };
708 
709 static void palmas_dt_to_pdata(struct device *dev,
710                 struct device_node *node,
711                 struct palmas_pmic_platform_data *pdata)
712 {
713         struct device_node *regulators;
714         u32 prop;
715         int idx, ret;
716 
717         node = of_node_get(node);
718         regulators = of_get_child_by_name(node, "regulators");
719         if (!regulators) {
720                 dev_info(dev, "regulator node not found\n");
721                 return;
722         }
723 
724         ret = of_regulator_match(dev, regulators, palmas_matches,
725                         PALMAS_NUM_REGS);
726         of_node_put(regulators);
727         if (ret < 0) {
728                 dev_err(dev, "Error parsing regulator init data: %d\n", ret);
729                 return;
730         }
731 
732         for (idx = 0; idx < PALMAS_NUM_REGS; idx++) {
733                 if (!palmas_matches[idx].init_data ||
734                                 !palmas_matches[idx].of_node)
735                         continue;
736 
737                 pdata->reg_data[idx] = palmas_matches[idx].init_data;
738 
739                 pdata->reg_init[idx] = devm_kzalloc(dev,
740                                 sizeof(struct palmas_reg_init), GFP_KERNEL);
741 
742                 pdata->reg_init[idx]->warm_reset =
743                         of_property_read_bool(palmas_matches[idx].of_node,
744                                              "ti,warm-reset");
745 
746                 ret = of_property_read_u32(palmas_matches[idx].of_node,
747                                               "ti,roof-floor", &prop);
748                 /* EINVAL: Property not found */
749                 if (ret != -EINVAL) {
750                         int econtrol;
751 
752                         /* use default value, when no value is specified */
753                         econtrol = PALMAS_EXT_CONTROL_NSLEEP;
754                         if (!ret) {
755                                 switch (prop) {
756                                 case 1:
757                                         econtrol = PALMAS_EXT_CONTROL_ENABLE1;
758                                         break;
759                                 case 2:
760                                         econtrol = PALMAS_EXT_CONTROL_ENABLE2;
761                                         break;
762                                 case 3:
763                                         econtrol = PALMAS_EXT_CONTROL_NSLEEP;
764                                         break;
765                                 default:
766                                         WARN_ON(1);
767                                         dev_warn(dev,
768                                         "%s: Invalid roof-floor option: %u\n",
769                                              palmas_matches[idx].name, prop);
770                                         break;
771                                 }
772                         }
773                         pdata->reg_init[idx]->roof_floor = econtrol;
774                 }
775 
776                 ret = of_property_read_u32(palmas_matches[idx].of_node,
777                                 "ti,mode-sleep", &prop);
778                 if (!ret)
779                         pdata->reg_init[idx]->mode_sleep = prop;
780 
781                 ret = of_property_read_bool(palmas_matches[idx].of_node,
782                                             "ti,smps-range");
783                 if (ret)
784                         pdata->reg_init[idx]->vsel =
785                                 PALMAS_SMPS12_VOLTAGE_RANGE;
786 
787                 if (idx == PALMAS_REG_LDO8)
788                         pdata->enable_ldo8_tracking = of_property_read_bool(
789                                                 palmas_matches[idx].of_node,
790                                                 "ti,enable-ldo8-tracking");
791         }
792 
793         pdata->ldo6_vibrator = of_property_read_bool(node, "ti,ldo6-vibrator");
794 }
795 
796 
797 static int palmas_regulators_probe(struct platform_device *pdev)
798 {
799         struct palmas *palmas = dev_get_drvdata(pdev->dev.parent);
800         struct palmas_pmic_platform_data *pdata = dev_get_platdata(&pdev->dev);
801         struct device_node *node = pdev->dev.of_node;
802         struct regulator_dev *rdev;
803         struct regulator_config config = { };
804         struct palmas_pmic *pmic;
805         struct palmas_reg_init *reg_init;
806         int id = 0, ret;
807         unsigned int addr, reg;
808 
809         if (node && !pdata) {
810                 pdata = devm_kzalloc(&pdev->dev, sizeof(*pdata), GFP_KERNEL);
811 
812                 if (!pdata)
813                         return -ENOMEM;
814 
815                 palmas_dt_to_pdata(&pdev->dev, node, pdata);
816         }
817 
818         pmic = devm_kzalloc(&pdev->dev, sizeof(*pmic), GFP_KERNEL);
819         if (!pmic)
820                 return -ENOMEM;
821 
822         pmic->dev = &pdev->dev;
823         pmic->palmas = palmas;
824         palmas->pmic = pmic;
825         platform_set_drvdata(pdev, pmic);
826 
827         ret = palmas_smps_read(palmas, PALMAS_SMPS_CTRL, &reg);
828         if (ret)
829                 return ret;
830 
831         if (reg & PALMAS_SMPS_CTRL_SMPS12_SMPS123_EN)
832                 pmic->smps123 = 1;
833 
834         if (reg & PALMAS_SMPS_CTRL_SMPS45_SMPS457_EN)
835                 pmic->smps457 = 1;
836 
837         config.regmap = palmas->regmap[REGULATOR_SLAVE];
838         config.dev = &pdev->dev;
839         config.driver_data = pmic;
840 
841         for (id = 0; id < PALMAS_REG_LDO1; id++) {
842                 bool ramp_delay_support = false;
843 
844                 /*
845                  * Miss out regulators which are not available due
846                  * to slaving configurations.
847                  */
848                 switch (id) {
849                 case PALMAS_REG_SMPS12:
850                 case PALMAS_REG_SMPS3:
851                         if (pmic->smps123)
852                                 continue;
853                         if (id == PALMAS_REG_SMPS12)
854                                 ramp_delay_support = true;
855                         break;
856                 case PALMAS_REG_SMPS123:
857                         if (!pmic->smps123)
858                                 continue;
859                         ramp_delay_support = true;
860                         break;
861                 case PALMAS_REG_SMPS45:
862                 case PALMAS_REG_SMPS7:
863                         if (pmic->smps457)
864                                 continue;
865                         if (id == PALMAS_REG_SMPS45)
866                                 ramp_delay_support = true;
867                         break;
868                 case PALMAS_REG_SMPS457:
869                         if (!pmic->smps457)
870                                 continue;
871                         ramp_delay_support = true;
872                         break;
873                 case PALMAS_REG_SMPS10_OUT1:
874                 case PALMAS_REG_SMPS10_OUT2:
875                         if (!PALMAS_PMIC_HAS(palmas, SMPS10_BOOST))
876                                 continue;
877                 }
878 
879                 if ((id == PALMAS_REG_SMPS6) || (id == PALMAS_REG_SMPS8))
880                         ramp_delay_support = true;
881 
882                 if (ramp_delay_support) {
883                         addr = palmas_regs_info[id].tstep_addr;
884                         ret = palmas_smps_read(pmic->palmas, addr, &reg);
885                         if (ret < 0) {
886                                 dev_err(&pdev->dev,
887                                         "reading TSTEP reg failed: %d\n", ret);
888                                 return ret;
889                         }
890                         pmic->desc[id].ramp_delay =
891                                         palmas_smps_ramp_delay[reg & 0x3];
892                         pmic->ramp_delay[id] = pmic->desc[id].ramp_delay;
893                 }
894 
895                 /* Initialise sleep/init values from platform data */
896                 if (pdata && pdata->reg_init[id]) {
897                         reg_init = pdata->reg_init[id];
898                         ret = palmas_smps_init(palmas, id, reg_init);
899                         if (ret)
900                                 return ret;
901                 } else {
902                         reg_init = NULL;
903                 }
904 
905                 /* Register the regulators */
906                 pmic->desc[id].name = palmas_regs_info[id].name;
907                 pmic->desc[id].id = id;
908 
909                 switch (id) {
910                 case PALMAS_REG_SMPS10_OUT1:
911                 case PALMAS_REG_SMPS10_OUT2:
912                         pmic->desc[id].n_voltages = PALMAS_SMPS10_NUM_VOLTAGES;
913                         pmic->desc[id].ops = &palmas_ops_smps10;
914                         pmic->desc[id].vsel_reg =
915                                         PALMAS_BASE_TO_REG(PALMAS_SMPS_BASE,
916                                                         PALMAS_SMPS10_CTRL);
917                         pmic->desc[id].vsel_mask = SMPS10_VSEL;
918                         pmic->desc[id].enable_reg =
919                                         PALMAS_BASE_TO_REG(PALMAS_SMPS_BASE,
920                                                         PALMAS_SMPS10_CTRL);
921                         if (id == PALMAS_REG_SMPS10_OUT1)
922                                 pmic->desc[id].enable_mask = SMPS10_SWITCH_EN;
923                         else
924                                 pmic->desc[id].enable_mask = SMPS10_BOOST_EN;
925                         pmic->desc[id].bypass_reg =
926                                         PALMAS_BASE_TO_REG(PALMAS_SMPS_BASE,
927                                                         PALMAS_SMPS10_CTRL);
928                         pmic->desc[id].bypass_mask = SMPS10_BYPASS_EN;
929                         pmic->desc[id].min_uV = 3750000;
930                         pmic->desc[id].uV_step = 1250000;
931                         break;
932                 default:
933                         /*
934                          * Read and store the RANGE bit for later use
935                          * This must be done before regulator is probed,
936                          * otherwise we error in probe with unsupportable
937                          * ranges. Read the current smps mode for later use.
938                          */
939                         addr = palmas_regs_info[id].vsel_addr;
940                         pmic->desc[id].n_linear_ranges = 3;
941 
942                         ret = palmas_smps_read(pmic->palmas, addr, &reg);
943                         if (ret)
944                                 return ret;
945                         if (reg & PALMAS_SMPS12_VOLTAGE_RANGE)
946                                 pmic->range[id] = 1;
947                         if (pmic->range[id])
948                                 pmic->desc[id].linear_ranges = smps_high_ranges;
949                         else
950                                 pmic->desc[id].linear_ranges = smps_low_ranges;
951 
952                         if (reg_init && reg_init->roof_floor)
953                                 pmic->desc[id].ops =
954                                                 &palmas_ops_ext_control_smps;
955                         else
956                                 pmic->desc[id].ops = &palmas_ops_smps;
957                         pmic->desc[id].n_voltages = PALMAS_SMPS_NUM_VOLTAGES;
958                         pmic->desc[id].vsel_reg =
959                                         PALMAS_BASE_TO_REG(PALMAS_SMPS_BASE,
960                                                 palmas_regs_info[id].vsel_addr);
961                         pmic->desc[id].vsel_mask =
962                                         PALMAS_SMPS12_VOLTAGE_VSEL_MASK;
963 
964                         /* Read the smps mode for later use. */
965                         addr = palmas_regs_info[id].ctrl_addr;
966                         ret = palmas_smps_read(pmic->palmas, addr, &reg);
967                         if (ret)
968                                 return ret;
969                         pmic->current_reg_mode[id] = reg &
970                                         PALMAS_SMPS12_CTRL_MODE_ACTIVE_MASK;
971 
972                         pmic->desc[id].enable_reg =
973                                         PALMAS_BASE_TO_REG(PALMAS_SMPS_BASE,
974                                                 palmas_regs_info[id].ctrl_addr);
975                         pmic->desc[id].enable_mask =
976                                         PALMAS_SMPS12_CTRL_MODE_ACTIVE_MASK;
977                         /* set_mode overrides this value */
978                         pmic->desc[id].enable_val = SMPS_CTRL_MODE_ON;
979                 }
980 
981                 pmic->desc[id].type = REGULATOR_VOLTAGE;
982                 pmic->desc[id].owner = THIS_MODULE;
983 
984                 if (pdata)
985                         config.init_data = pdata->reg_data[id];
986                 else
987                         config.init_data = NULL;
988 
989                 pmic->desc[id].supply_name = palmas_regs_info[id].sname;
990                 config.of_node = palmas_matches[id].of_node;
991 
992                 rdev = devm_regulator_register(&pdev->dev, &pmic->desc[id],
993                                                &config);
994                 if (IS_ERR(rdev)) {
995                         dev_err(&pdev->dev,
996                                 "failed to register %s regulator\n",
997                                 pdev->name);
998                         return PTR_ERR(rdev);
999                 }
1000 
1001                 /* Save regulator for cleanup */
1002                 pmic->rdev[id] = rdev;
1003         }
1004 
1005         /* Start this loop from the id left from previous loop */
1006         for (; id < PALMAS_NUM_REGS; id++) {
1007                 if (pdata && pdata->reg_init[id])
1008                         reg_init = pdata->reg_init[id];
1009                 else
1010                         reg_init = NULL;
1011 
1012                 /* Miss out regulators which are not available due
1013                  * to alternate functions.
1014                  */
1015 
1016                 /* Register the regulators */
1017                 pmic->desc[id].name = palmas_regs_info[id].name;
1018                 pmic->desc[id].id = id;
1019                 pmic->desc[id].type = REGULATOR_VOLTAGE;
1020                 pmic->desc[id].owner = THIS_MODULE;
1021 
1022                 if (id < PALMAS_REG_REGEN1) {
1023                         pmic->desc[id].n_voltages = PALMAS_LDO_NUM_VOLTAGES;
1024                         if (reg_init && reg_init->roof_floor)
1025                                 pmic->desc[id].ops =
1026                                         &palmas_ops_ext_control_ldo;
1027                         else
1028                                 pmic->desc[id].ops = &palmas_ops_ldo;
1029                         pmic->desc[id].min_uV = 900000;
1030                         pmic->desc[id].uV_step = 50000;
1031                         pmic->desc[id].linear_min_sel = 1;
1032                         pmic->desc[id].enable_time = 500;
1033                         pmic->desc[id].vsel_reg =
1034                                         PALMAS_BASE_TO_REG(PALMAS_LDO_BASE,
1035                                                 palmas_regs_info[id].vsel_addr);
1036                         pmic->desc[id].vsel_mask =
1037                                         PALMAS_LDO1_VOLTAGE_VSEL_MASK;
1038                         pmic->desc[id].enable_reg =
1039                                         PALMAS_BASE_TO_REG(PALMAS_LDO_BASE,
1040                                                 palmas_regs_info[id].ctrl_addr);
1041                         pmic->desc[id].enable_mask =
1042                                         PALMAS_LDO1_CTRL_MODE_ACTIVE;
1043 
1044                         /* Check if LDO8 is in tracking mode or not */
1045                         if (pdata && (id == PALMAS_REG_LDO8) &&
1046                                         pdata->enable_ldo8_tracking) {
1047                                 palmas_enable_ldo8_track(palmas);
1048                                 pmic->desc[id].min_uV = 450000;
1049                                 pmic->desc[id].uV_step = 25000;
1050                         }
1051 
1052                         /* LOD6 in vibrator mode will have enable time 2000us */
1053                         if (pdata && pdata->ldo6_vibrator &&
1054                                 (id == PALMAS_REG_LDO6))
1055                                 pmic->desc[id].enable_time = 2000;
1056                 } else {
1057                         pmic->desc[id].n_voltages = 1;
1058                         if (reg_init && reg_init->roof_floor)
1059                                 pmic->desc[id].ops =
1060                                         &palmas_ops_ext_control_extreg;
1061                         else
1062                                 pmic->desc[id].ops = &palmas_ops_extreg;
1063                         pmic->desc[id].enable_reg =
1064                                         PALMAS_BASE_TO_REG(PALMAS_RESOURCE_BASE,
1065                                                 palmas_regs_info[id].ctrl_addr);
1066                         pmic->desc[id].enable_mask =
1067                                         PALMAS_REGEN1_CTRL_MODE_ACTIVE;
1068                 }
1069 
1070                 if (pdata)
1071                         config.init_data = pdata->reg_data[id];
1072                 else
1073                         config.init_data = NULL;
1074 
1075                 pmic->desc[id].supply_name = palmas_regs_info[id].sname;
1076                 config.of_node = palmas_matches[id].of_node;
1077 
1078                 rdev = devm_regulator_register(&pdev->dev, &pmic->desc[id],
1079                                                &config);
1080                 if (IS_ERR(rdev)) {
1081                         dev_err(&pdev->dev,
1082                                 "failed to register %s regulator\n",
1083                                 pdev->name);
1084                         return PTR_ERR(rdev);
1085                 }
1086 
1087                 /* Save regulator for cleanup */
1088                 pmic->rdev[id] = rdev;
1089 
1090                 /* Initialise sleep/init values from platform data */
1091                 if (pdata) {
1092                         reg_init = pdata->reg_init[id];
1093                         if (reg_init) {
1094                                 if (id < PALMAS_REG_REGEN1)
1095                                         ret = palmas_ldo_init(palmas,
1096                                                         id, reg_init);
1097                                 else
1098                                         ret = palmas_extreg_init(palmas,
1099                                                         id, reg_init);
1100                                 if (ret)
1101                                         return ret;
1102                         }
1103                 }
1104         }
1105 
1106 
1107         return 0;
1108 }
1109 
1110 static const struct of_device_id of_palmas_match_tbl[] = {
1111         { .compatible = "ti,palmas-pmic", },
1112         { .compatible = "ti,twl6035-pmic", },
1113         { .compatible = "ti,twl6036-pmic", },
1114         { .compatible = "ti,twl6037-pmic", },
1115         { .compatible = "ti,tps65913-pmic", },
1116         { .compatible = "ti,tps65914-pmic", },
1117         { .compatible = "ti,tps80036-pmic", },
1118         { .compatible = "ti,tps659038-pmic", },
1119         { /* end */ }
1120 };
1121 
1122 static struct platform_driver palmas_driver = {
1123         .driver = {
1124                 .name = "palmas-pmic",
1125                 .of_match_table = of_palmas_match_tbl,
1126                 .owner = THIS_MODULE,
1127         },
1128         .probe = palmas_regulators_probe,
1129 };
1130 
1131 static int __init palmas_init(void)
1132 {
1133         return platform_driver_register(&palmas_driver);
1134 }
1135 subsys_initcall(palmas_init);
1136 
1137 static void __exit palmas_exit(void)
1138 {
1139         platform_driver_unregister(&palmas_driver);
1140 }
1141 module_exit(palmas_exit);
1142 
1143 MODULE_AUTHOR("Graeme Gregory <gg@slimlogic.co.uk>");
1144 MODULE_DESCRIPTION("Palmas voltage regulator driver");
1145 MODULE_LICENSE("GPL");
1146 MODULE_ALIAS("platform:palmas-pmic");
1147 MODULE_DEVICE_TABLE(of, of_palmas_match_tbl);
1148 

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