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/s2mps11.c

  1 /*
  2  * s2mps11.c
  3  *
  4  * Copyright (c) 2012-2014 Samsung Electronics Co., Ltd
  5  *              http://www.samsung.com
  6  *
  7  * This program is free software; you can redistribute  it and/or modify it
  8  * under  the terms of  the GNU General  Public License as published by the
  9  * Free Software Foundation;  either version 2 of the  License, or (at your
 10  * option) any later version.
 11  *
 12  * This program is distributed in the hope that it will be useful,
 13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
 14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 15  * GNU General Public License for more details.
 16  *
 17  */
 18 
 19 #include <linux/bug.h>
 20 #include <linux/err.h>
 21 #include <linux/gpio.h>
 22 #include <linux/slab.h>
 23 #include <linux/module.h>
 24 #include <linux/of.h>
 25 #include <linux/regmap.h>
 26 #include <linux/platform_device.h>
 27 #include <linux/regulator/driver.h>
 28 #include <linux/regulator/machine.h>
 29 #include <linux/regulator/of_regulator.h>
 30 #include <linux/of_gpio.h>
 31 #include <linux/mfd/samsung/core.h>
 32 #include <linux/mfd/samsung/s2mps11.h>
 33 #include <linux/mfd/samsung/s2mps14.h>
 34 
 35 struct s2mps11_info {
 36         unsigned int rdev_num;
 37         int ramp_delay2;
 38         int ramp_delay34;
 39         int ramp_delay5;
 40         int ramp_delay16;
 41         int ramp_delay7810;
 42         int ramp_delay9;
 43         /*
 44          * One bit for each S2MPS14 regulator whether the suspend mode
 45          * was enabled.
 46          */
 47         unsigned int s2mps14_suspend_state:30;
 48         /* Array of size rdev_num with GPIO-s for external sleep control */
 49         int *ext_control_gpio;
 50 };
 51 
 52 static int get_ramp_delay(int ramp_delay)
 53 {
 54         unsigned char cnt = 0;
 55 
 56         ramp_delay /= 6250;
 57 
 58         while (true) {
 59                 ramp_delay = ramp_delay >> 1;
 60                 if (ramp_delay == 0)
 61                         break;
 62                 cnt++;
 63         }
 64 
 65         if (cnt > 3)
 66                 cnt = 3;
 67 
 68         return cnt;
 69 }
 70 
 71 static int s2mps11_regulator_set_voltage_time_sel(struct regulator_dev *rdev,
 72                                    unsigned int old_selector,
 73                                    unsigned int new_selector)
 74 {
 75         struct s2mps11_info *s2mps11 = rdev_get_drvdata(rdev);
 76         unsigned int ramp_delay = 0;
 77         int old_volt, new_volt;
 78 
 79         switch (rdev_get_id(rdev)) {
 80         case S2MPS11_BUCK2:
 81                 ramp_delay = s2mps11->ramp_delay2;
 82                 break;
 83         case S2MPS11_BUCK3:
 84         case S2MPS11_BUCK4:
 85                 ramp_delay = s2mps11->ramp_delay34;
 86                 break;
 87         case S2MPS11_BUCK5:
 88                 ramp_delay = s2mps11->ramp_delay5;
 89                 break;
 90         case S2MPS11_BUCK6:
 91         case S2MPS11_BUCK1:
 92                 ramp_delay = s2mps11->ramp_delay16;
 93                 break;
 94         case S2MPS11_BUCK7:
 95         case S2MPS11_BUCK8:
 96         case S2MPS11_BUCK10:
 97                 ramp_delay = s2mps11->ramp_delay7810;
 98                 break;
 99         case S2MPS11_BUCK9:
100                 ramp_delay = s2mps11->ramp_delay9;
101         }
102 
103         if (ramp_delay == 0)
104                 ramp_delay = rdev->desc->ramp_delay;
105 
106         old_volt = rdev->desc->min_uV + (rdev->desc->uV_step * old_selector);
107         new_volt = rdev->desc->min_uV + (rdev->desc->uV_step * new_selector);
108 
109         return DIV_ROUND_UP(abs(new_volt - old_volt), ramp_delay);
110 }
111 
112 static int s2mps11_set_ramp_delay(struct regulator_dev *rdev, int ramp_delay)
113 {
114         struct s2mps11_info *s2mps11 = rdev_get_drvdata(rdev);
115         unsigned int ramp_val, ramp_shift, ramp_reg = S2MPS11_REG_RAMP_BUCK;
116         unsigned int ramp_enable = 1, enable_shift = 0;
117         int ret;
118 
119         switch (rdev_get_id(rdev)) {
120         case S2MPS11_BUCK1:
121                 if (ramp_delay > s2mps11->ramp_delay16)
122                         s2mps11->ramp_delay16 = ramp_delay;
123                 else
124                         ramp_delay = s2mps11->ramp_delay16;
125 
126                 ramp_shift = S2MPS11_BUCK16_RAMP_SHIFT;
127                 break;
128         case S2MPS11_BUCK2:
129                 enable_shift = S2MPS11_BUCK2_RAMP_EN_SHIFT;
130                 if (!ramp_delay) {
131                         ramp_enable = 0;
132                         break;
133                 }
134 
135                 s2mps11->ramp_delay2 = ramp_delay;
136                 ramp_shift = S2MPS11_BUCK2_RAMP_SHIFT;
137                 ramp_reg = S2MPS11_REG_RAMP;
138                 break;
139         case S2MPS11_BUCK3:
140                 enable_shift = S2MPS11_BUCK3_RAMP_EN_SHIFT;
141                 if (!ramp_delay) {
142                         ramp_enable = 0;
143                         break;
144                 }
145 
146                 if (ramp_delay > s2mps11->ramp_delay34)
147                         s2mps11->ramp_delay34 = ramp_delay;
148                 else
149                         ramp_delay = s2mps11->ramp_delay34;
150 
151                 ramp_shift = S2MPS11_BUCK34_RAMP_SHIFT;
152                 ramp_reg = S2MPS11_REG_RAMP;
153                 break;
154         case S2MPS11_BUCK4:
155                 enable_shift = S2MPS11_BUCK4_RAMP_EN_SHIFT;
156                 if (!ramp_delay) {
157                         ramp_enable = 0;
158                         break;
159                 }
160 
161                 if (ramp_delay > s2mps11->ramp_delay34)
162                         s2mps11->ramp_delay34 = ramp_delay;
163                 else
164                         ramp_delay = s2mps11->ramp_delay34;
165 
166                 ramp_shift = S2MPS11_BUCK34_RAMP_SHIFT;
167                 ramp_reg = S2MPS11_REG_RAMP;
168                 break;
169         case S2MPS11_BUCK5:
170                 s2mps11->ramp_delay5 = ramp_delay;
171                 ramp_shift = S2MPS11_BUCK5_RAMP_SHIFT;
172                 break;
173         case S2MPS11_BUCK6:
174                 enable_shift = S2MPS11_BUCK6_RAMP_EN_SHIFT;
175                 if (!ramp_delay) {
176                         ramp_enable = 0;
177                         break;
178                 }
179 
180                 if (ramp_delay > s2mps11->ramp_delay16)
181                         s2mps11->ramp_delay16 = ramp_delay;
182                 else
183                         ramp_delay = s2mps11->ramp_delay16;
184 
185                 ramp_shift = S2MPS11_BUCK16_RAMP_SHIFT;
186                 break;
187         case S2MPS11_BUCK7:
188         case S2MPS11_BUCK8:
189         case S2MPS11_BUCK10:
190                 if (ramp_delay > s2mps11->ramp_delay7810)
191                         s2mps11->ramp_delay7810 = ramp_delay;
192                 else
193                         ramp_delay = s2mps11->ramp_delay7810;
194 
195                 ramp_shift = S2MPS11_BUCK7810_RAMP_SHIFT;
196                 break;
197         case S2MPS11_BUCK9:
198                 s2mps11->ramp_delay9 = ramp_delay;
199                 ramp_shift = S2MPS11_BUCK9_RAMP_SHIFT;
200                 break;
201         default:
202                 return 0;
203         }
204 
205         if (!ramp_enable)
206                 goto ramp_disable;
207 
208         /* Ramp delay can be enabled/disabled only for buck[2346] */
209         if ((rdev_get_id(rdev) >= S2MPS11_BUCK2 &&
210                         rdev_get_id(rdev) <= S2MPS11_BUCK4) ||
211                         rdev_get_id(rdev) == S2MPS11_BUCK6)  {
212                 ret = regmap_update_bits(rdev->regmap, S2MPS11_REG_RAMP,
213                                          1 << enable_shift, 1 << enable_shift);
214                 if (ret) {
215                         dev_err(&rdev->dev, "failed to enable ramp rate\n");
216                         return ret;
217                 }
218         }
219 
220         ramp_val = get_ramp_delay(ramp_delay);
221 
222         return regmap_update_bits(rdev->regmap, ramp_reg, 0x3 << ramp_shift,
223                                   ramp_val << ramp_shift);
224 
225 ramp_disable:
226         return regmap_update_bits(rdev->regmap, S2MPS11_REG_RAMP,
227                                   1 << enable_shift, 0);
228 }
229 
230 static struct regulator_ops s2mps11_ldo_ops = {
231         .list_voltage           = regulator_list_voltage_linear,
232         .map_voltage            = regulator_map_voltage_linear,
233         .is_enabled             = regulator_is_enabled_regmap,
234         .enable                 = regulator_enable_regmap,
235         .disable                = regulator_disable_regmap,
236         .get_voltage_sel        = regulator_get_voltage_sel_regmap,
237         .set_voltage_sel        = regulator_set_voltage_sel_regmap,
238         .set_voltage_time_sel   = regulator_set_voltage_time_sel,
239 };
240 
241 static struct regulator_ops s2mps11_buck_ops = {
242         .list_voltage           = regulator_list_voltage_linear,
243         .map_voltage            = regulator_map_voltage_linear,
244         .is_enabled             = regulator_is_enabled_regmap,
245         .enable                 = regulator_enable_regmap,
246         .disable                = regulator_disable_regmap,
247         .get_voltage_sel        = regulator_get_voltage_sel_regmap,
248         .set_voltage_sel        = regulator_set_voltage_sel_regmap,
249         .set_voltage_time_sel   = s2mps11_regulator_set_voltage_time_sel,
250         .set_ramp_delay         = s2mps11_set_ramp_delay,
251 };
252 
253 #define regulator_desc_s2mps11_ldo1(num)        {               \
254         .name           = "LDO"#num,                    \
255         .id             = S2MPS11_LDO##num,             \
256         .ops            = &s2mps11_ldo_ops,             \
257         .type           = REGULATOR_VOLTAGE,            \
258         .owner          = THIS_MODULE,                  \
259         .min_uV         = S2MPS11_LDO_MIN,              \
260         .uV_step        = S2MPS11_LDO_STEP1,            \
261         .n_voltages     = S2MPS11_LDO_N_VOLTAGES,       \
262         .vsel_reg       = S2MPS11_REG_L1CTRL + num - 1, \
263         .vsel_mask      = S2MPS11_LDO_VSEL_MASK,        \
264         .enable_reg     = S2MPS11_REG_L1CTRL + num - 1, \
265         .enable_mask    = S2MPS11_ENABLE_MASK           \
266 }
267 #define regulator_desc_s2mps11_ldo2(num) {              \
268         .name           = "LDO"#num,                    \
269         .id             = S2MPS11_LDO##num,             \
270         .ops            = &s2mps11_ldo_ops,             \
271         .type           = REGULATOR_VOLTAGE,            \
272         .owner          = THIS_MODULE,                  \
273         .min_uV         = S2MPS11_LDO_MIN,              \
274         .uV_step        = S2MPS11_LDO_STEP2,            \
275         .n_voltages     = S2MPS11_LDO_N_VOLTAGES,       \
276         .vsel_reg       = S2MPS11_REG_L1CTRL + num - 1, \
277         .vsel_mask      = S2MPS11_LDO_VSEL_MASK,        \
278         .enable_reg     = S2MPS11_REG_L1CTRL + num - 1, \
279         .enable_mask    = S2MPS11_ENABLE_MASK           \
280 }
281 
282 #define regulator_desc_s2mps11_buck1_4(num) {                   \
283         .name           = "BUCK"#num,                           \
284         .id             = S2MPS11_BUCK##num,                    \
285         .ops            = &s2mps11_buck_ops,                    \
286         .type           = REGULATOR_VOLTAGE,                    \
287         .owner          = THIS_MODULE,                          \
288         .min_uV         = S2MPS11_BUCK_MIN1,                    \
289         .uV_step        = S2MPS11_BUCK_STEP1,                   \
290         .n_voltages     = S2MPS11_BUCK_N_VOLTAGES,              \
291         .ramp_delay     = S2MPS11_RAMP_DELAY,                   \
292         .vsel_reg       = S2MPS11_REG_B1CTRL2 + (num - 1) * 2,  \
293         .vsel_mask      = S2MPS11_BUCK_VSEL_MASK,               \
294         .enable_reg     = S2MPS11_REG_B1CTRL1 + (num - 1) * 2,  \
295         .enable_mask    = S2MPS11_ENABLE_MASK                   \
296 }
297 
298 #define regulator_desc_s2mps11_buck5 {                          \
299         .name           = "BUCK5",                              \
300         .id             = S2MPS11_BUCK5,                        \
301         .ops            = &s2mps11_buck_ops,                    \
302         .type           = REGULATOR_VOLTAGE,                    \
303         .owner          = THIS_MODULE,                          \
304         .min_uV         = S2MPS11_BUCK_MIN1,                    \
305         .uV_step        = S2MPS11_BUCK_STEP1,                   \
306         .n_voltages     = S2MPS11_BUCK_N_VOLTAGES,              \
307         .ramp_delay     = S2MPS11_RAMP_DELAY,                   \
308         .vsel_reg       = S2MPS11_REG_B5CTRL2,                  \
309         .vsel_mask      = S2MPS11_BUCK_VSEL_MASK,               \
310         .enable_reg     = S2MPS11_REG_B5CTRL1,                  \
311         .enable_mask    = S2MPS11_ENABLE_MASK                   \
312 }
313 
314 #define regulator_desc_s2mps11_buck6_8(num) {                   \
315         .name           = "BUCK"#num,                           \
316         .id             = S2MPS11_BUCK##num,                    \
317         .ops            = &s2mps11_buck_ops,                    \
318         .type           = REGULATOR_VOLTAGE,                    \
319         .owner          = THIS_MODULE,                          \
320         .min_uV         = S2MPS11_BUCK_MIN1,                    \
321         .uV_step        = S2MPS11_BUCK_STEP1,                   \
322         .n_voltages     = S2MPS11_BUCK_N_VOLTAGES,              \
323         .ramp_delay     = S2MPS11_RAMP_DELAY,                   \
324         .vsel_reg       = S2MPS11_REG_B6CTRL2 + (num - 6) * 2,  \
325         .vsel_mask      = S2MPS11_BUCK_VSEL_MASK,               \
326         .enable_reg     = S2MPS11_REG_B6CTRL1 + (num - 6) * 2,  \
327         .enable_mask    = S2MPS11_ENABLE_MASK                   \
328 }
329 
330 #define regulator_desc_s2mps11_buck9 {                          \
331         .name           = "BUCK9",                              \
332         .id             = S2MPS11_BUCK9,                        \
333         .ops            = &s2mps11_buck_ops,                    \
334         .type           = REGULATOR_VOLTAGE,                    \
335         .owner          = THIS_MODULE,                          \
336         .min_uV         = S2MPS11_BUCK_MIN3,                    \
337         .uV_step        = S2MPS11_BUCK_STEP3,                   \
338         .n_voltages     = S2MPS11_BUCK_N_VOLTAGES,              \
339         .ramp_delay     = S2MPS11_RAMP_DELAY,                   \
340         .vsel_reg       = S2MPS11_REG_B9CTRL2,                  \
341         .vsel_mask      = S2MPS11_BUCK_VSEL_MASK,               \
342         .enable_reg     = S2MPS11_REG_B9CTRL1,                  \
343         .enable_mask    = S2MPS11_ENABLE_MASK                   \
344 }
345 
346 #define regulator_desc_s2mps11_buck10 {                         \
347         .name           = "BUCK10",                             \
348         .id             = S2MPS11_BUCK10,                       \
349         .ops            = &s2mps11_buck_ops,                    \
350         .type           = REGULATOR_VOLTAGE,                    \
351         .owner          = THIS_MODULE,                          \
352         .min_uV         = S2MPS11_BUCK_MIN2,                    \
353         .uV_step        = S2MPS11_BUCK_STEP2,                   \
354         .n_voltages     = S2MPS11_BUCK_N_VOLTAGES,              \
355         .ramp_delay     = S2MPS11_RAMP_DELAY,                   \
356         .vsel_reg       = S2MPS11_REG_B10CTRL2,                 \
357         .vsel_mask      = S2MPS11_BUCK_VSEL_MASK,               \
358         .enable_reg     = S2MPS11_REG_B10CTRL1,                 \
359         .enable_mask    = S2MPS11_ENABLE_MASK                   \
360 }
361 
362 static const struct regulator_desc s2mps11_regulators[] = {
363         regulator_desc_s2mps11_ldo2(1),
364         regulator_desc_s2mps11_ldo1(2),
365         regulator_desc_s2mps11_ldo1(3),
366         regulator_desc_s2mps11_ldo1(4),
367         regulator_desc_s2mps11_ldo1(5),
368         regulator_desc_s2mps11_ldo2(6),
369         regulator_desc_s2mps11_ldo1(7),
370         regulator_desc_s2mps11_ldo1(8),
371         regulator_desc_s2mps11_ldo1(9),
372         regulator_desc_s2mps11_ldo1(10),
373         regulator_desc_s2mps11_ldo2(11),
374         regulator_desc_s2mps11_ldo1(12),
375         regulator_desc_s2mps11_ldo1(13),
376         regulator_desc_s2mps11_ldo1(14),
377         regulator_desc_s2mps11_ldo1(15),
378         regulator_desc_s2mps11_ldo1(16),
379         regulator_desc_s2mps11_ldo1(17),
380         regulator_desc_s2mps11_ldo1(18),
381         regulator_desc_s2mps11_ldo1(19),
382         regulator_desc_s2mps11_ldo1(20),
383         regulator_desc_s2mps11_ldo1(21),
384         regulator_desc_s2mps11_ldo2(22),
385         regulator_desc_s2mps11_ldo2(23),
386         regulator_desc_s2mps11_ldo1(24),
387         regulator_desc_s2mps11_ldo1(25),
388         regulator_desc_s2mps11_ldo1(26),
389         regulator_desc_s2mps11_ldo2(27),
390         regulator_desc_s2mps11_ldo1(28),
391         regulator_desc_s2mps11_ldo1(29),
392         regulator_desc_s2mps11_ldo1(30),
393         regulator_desc_s2mps11_ldo1(31),
394         regulator_desc_s2mps11_ldo1(32),
395         regulator_desc_s2mps11_ldo1(33),
396         regulator_desc_s2mps11_ldo1(34),
397         regulator_desc_s2mps11_ldo1(35),
398         regulator_desc_s2mps11_ldo1(36),
399         regulator_desc_s2mps11_ldo1(37),
400         regulator_desc_s2mps11_ldo1(38),
401         regulator_desc_s2mps11_buck1_4(1),
402         regulator_desc_s2mps11_buck1_4(2),
403         regulator_desc_s2mps11_buck1_4(3),
404         regulator_desc_s2mps11_buck1_4(4),
405         regulator_desc_s2mps11_buck5,
406         regulator_desc_s2mps11_buck6_8(6),
407         regulator_desc_s2mps11_buck6_8(7),
408         regulator_desc_s2mps11_buck6_8(8),
409         regulator_desc_s2mps11_buck9,
410         regulator_desc_s2mps11_buck10,
411 };
412 
413 static int s2mps14_regulator_enable(struct regulator_dev *rdev)
414 {
415         struct s2mps11_info *s2mps11 = rdev_get_drvdata(rdev);
416         unsigned int val;
417 
418         if (s2mps11->s2mps14_suspend_state & (1 << rdev_get_id(rdev)))
419                 val = S2MPS14_ENABLE_SUSPEND;
420         else if (gpio_is_valid(s2mps11->ext_control_gpio[rdev_get_id(rdev)]))
421                 val = S2MPS14_ENABLE_EXT_CONTROL;
422         else
423                 val = rdev->desc->enable_mask;
424 
425         return regmap_update_bits(rdev->regmap, rdev->desc->enable_reg,
426                         rdev->desc->enable_mask, val);
427 }
428 
429 static int s2mps14_regulator_set_suspend_disable(struct regulator_dev *rdev)
430 {
431         int ret;
432         unsigned int val;
433         struct s2mps11_info *s2mps11 = rdev_get_drvdata(rdev);
434 
435         /* LDO3 should be always on and does not support suspend mode */
436         if (rdev_get_id(rdev) == S2MPS14_LDO3)
437                 return 0;
438 
439         ret = regmap_read(rdev->regmap, rdev->desc->enable_reg, &val);
440         if (ret < 0)
441                 return ret;
442 
443         s2mps11->s2mps14_suspend_state |= (1 << rdev_get_id(rdev));
444         /*
445          * Don't enable suspend mode if regulator is already disabled because
446          * this would effectively for a short time turn on the regulator after
447          * resuming.
448          * However we still want to toggle the suspend_state bit for regulator
449          * in case if it got enabled before suspending the system.
450          */
451         if (!(val & rdev->desc->enable_mask))
452                 return 0;
453 
454         return regmap_update_bits(rdev->regmap, rdev->desc->enable_reg,
455                         rdev->desc->enable_mask, S2MPS14_ENABLE_SUSPEND);
456 }
457 
458 static struct regulator_ops s2mps14_reg_ops = {
459         .list_voltage           = regulator_list_voltage_linear,
460         .map_voltage            = regulator_map_voltage_linear,
461         .is_enabled             = regulator_is_enabled_regmap,
462         .enable                 = s2mps14_regulator_enable,
463         .disable                = regulator_disable_regmap,
464         .get_voltage_sel        = regulator_get_voltage_sel_regmap,
465         .set_voltage_sel        = regulator_set_voltage_sel_regmap,
466         .set_voltage_time_sel   = regulator_set_voltage_time_sel,
467         .set_suspend_disable    = s2mps14_regulator_set_suspend_disable,
468 };
469 
470 #define regulator_desc_s2mps14_ldo1(num) {              \
471         .name           = "LDO"#num,                    \
472         .id             = S2MPS14_LDO##num,             \
473         .ops            = &s2mps14_reg_ops,             \
474         .type           = REGULATOR_VOLTAGE,            \
475         .owner          = THIS_MODULE,                  \
476         .min_uV         = S2MPS14_LDO_MIN_800MV,        \
477         .uV_step        = S2MPS14_LDO_STEP_25MV,        \
478         .n_voltages     = S2MPS14_LDO_N_VOLTAGES,       \
479         .vsel_reg       = S2MPS14_REG_L1CTRL + num - 1, \
480         .vsel_mask      = S2MPS14_LDO_VSEL_MASK,        \
481         .enable_reg     = S2MPS14_REG_L1CTRL + num - 1, \
482         .enable_mask    = S2MPS14_ENABLE_MASK           \
483 }
484 #define regulator_desc_s2mps14_ldo2(num) {              \
485         .name           = "LDO"#num,                    \
486         .id             = S2MPS14_LDO##num,             \
487         .ops            = &s2mps14_reg_ops,             \
488         .type           = REGULATOR_VOLTAGE,            \
489         .owner          = THIS_MODULE,                  \
490         .min_uV         = S2MPS14_LDO_MIN_1800MV,       \
491         .uV_step        = S2MPS14_LDO_STEP_25MV,        \
492         .n_voltages     = S2MPS14_LDO_N_VOLTAGES,       \
493         .vsel_reg       = S2MPS14_REG_L1CTRL + num - 1, \
494         .vsel_mask      = S2MPS14_LDO_VSEL_MASK,        \
495         .enable_reg     = S2MPS14_REG_L1CTRL + num - 1, \
496         .enable_mask    = S2MPS14_ENABLE_MASK           \
497 }
498 #define regulator_desc_s2mps14_ldo3(num) {              \
499         .name           = "LDO"#num,                    \
500         .id             = S2MPS14_LDO##num,             \
501         .ops            = &s2mps14_reg_ops,             \
502         .type           = REGULATOR_VOLTAGE,            \
503         .owner          = THIS_MODULE,                  \
504         .min_uV         = S2MPS14_LDO_MIN_800MV,        \
505         .uV_step        = S2MPS14_LDO_STEP_12_5MV,      \
506         .n_voltages     = S2MPS14_LDO_N_VOLTAGES,       \
507         .vsel_reg       = S2MPS14_REG_L1CTRL + num - 1, \
508         .vsel_mask      = S2MPS14_LDO_VSEL_MASK,        \
509         .enable_reg     = S2MPS14_REG_L1CTRL + num - 1, \
510         .enable_mask    = S2MPS14_ENABLE_MASK           \
511 }
512 #define regulator_desc_s2mps14_buck1235(num) {                  \
513         .name           = "BUCK"#num,                           \
514         .id             = S2MPS14_BUCK##num,                    \
515         .ops            = &s2mps14_reg_ops,                     \
516         .type           = REGULATOR_VOLTAGE,                    \
517         .owner          = THIS_MODULE,                          \
518         .min_uV         = S2MPS14_BUCK1235_MIN_600MV,           \
519         .uV_step        = S2MPS14_BUCK1235_STEP_6_25MV,         \
520         .n_voltages     = S2MPS14_BUCK_N_VOLTAGES,              \
521         .linear_min_sel = S2MPS14_BUCK1235_START_SEL,           \
522         .ramp_delay     = S2MPS14_BUCK_RAMP_DELAY,              \
523         .vsel_reg       = S2MPS14_REG_B1CTRL2 + (num - 1) * 2,  \
524         .vsel_mask      = S2MPS14_BUCK_VSEL_MASK,               \
525         .enable_reg     = S2MPS14_REG_B1CTRL1 + (num - 1) * 2,  \
526         .enable_mask    = S2MPS14_ENABLE_MASK                   \
527 }
528 #define regulator_desc_s2mps14_buck4(num) {                     \
529         .name           = "BUCK"#num,                           \
530         .id             = S2MPS14_BUCK##num,                    \
531         .ops            = &s2mps14_reg_ops,                     \
532         .type           = REGULATOR_VOLTAGE,                    \
533         .owner          = THIS_MODULE,                          \
534         .min_uV         = S2MPS14_BUCK4_MIN_1400MV,             \
535         .uV_step        = S2MPS14_BUCK4_STEP_12_5MV,            \
536         .n_voltages     = S2MPS14_BUCK_N_VOLTAGES,              \
537         .linear_min_sel = S2MPS14_BUCK4_START_SEL,              \
538         .ramp_delay     = S2MPS14_BUCK_RAMP_DELAY,              \
539         .vsel_reg       = S2MPS14_REG_B1CTRL2 + (num - 1) * 2,  \
540         .vsel_mask      = S2MPS14_BUCK_VSEL_MASK,               \
541         .enable_reg     = S2MPS14_REG_B1CTRL1 + (num - 1) * 2,  \
542         .enable_mask    = S2MPS14_ENABLE_MASK                   \
543 }
544 
545 static const struct regulator_desc s2mps14_regulators[] = {
546         regulator_desc_s2mps14_ldo3(1),
547         regulator_desc_s2mps14_ldo3(2),
548         regulator_desc_s2mps14_ldo1(3),
549         regulator_desc_s2mps14_ldo1(4),
550         regulator_desc_s2mps14_ldo3(5),
551         regulator_desc_s2mps14_ldo3(6),
552         regulator_desc_s2mps14_ldo1(7),
553         regulator_desc_s2mps14_ldo2(8),
554         regulator_desc_s2mps14_ldo3(9),
555         regulator_desc_s2mps14_ldo3(10),
556         regulator_desc_s2mps14_ldo1(11),
557         regulator_desc_s2mps14_ldo2(12),
558         regulator_desc_s2mps14_ldo2(13),
559         regulator_desc_s2mps14_ldo2(14),
560         regulator_desc_s2mps14_ldo2(15),
561         regulator_desc_s2mps14_ldo2(16),
562         regulator_desc_s2mps14_ldo2(17),
563         regulator_desc_s2mps14_ldo2(18),
564         regulator_desc_s2mps14_ldo1(19),
565         regulator_desc_s2mps14_ldo1(20),
566         regulator_desc_s2mps14_ldo1(21),
567         regulator_desc_s2mps14_ldo3(22),
568         regulator_desc_s2mps14_ldo1(23),
569         regulator_desc_s2mps14_ldo2(24),
570         regulator_desc_s2mps14_ldo2(25),
571         regulator_desc_s2mps14_buck1235(1),
572         regulator_desc_s2mps14_buck1235(2),
573         regulator_desc_s2mps14_buck1235(3),
574         regulator_desc_s2mps14_buck4(4),
575         regulator_desc_s2mps14_buck1235(5),
576 };
577 
578 static int s2mps14_pmic_enable_ext_control(struct s2mps11_info *s2mps11,
579                 struct regulator_dev *rdev)
580 {
581         return regmap_update_bits(rdev->regmap, rdev->desc->enable_reg,
582                         rdev->desc->enable_mask, S2MPS14_ENABLE_EXT_CONTROL);
583 }
584 
585 static void s2mps14_pmic_dt_parse_ext_control_gpio(struct platform_device *pdev,
586                 struct of_regulator_match *rdata, struct s2mps11_info *s2mps11)
587 {
588         int *gpio = s2mps11->ext_control_gpio;
589         unsigned int i;
590         unsigned int valid_regulators[3] = { S2MPS14_LDO10, S2MPS14_LDO11,
591                 S2MPS14_LDO12 };
592 
593         for (i = 0; i < ARRAY_SIZE(valid_regulators); i++) {
594                 unsigned int reg = valid_regulators[i];
595 
596                 if (!rdata[reg].init_data || !rdata[reg].of_node)
597                         continue;
598 
599                 gpio[reg] = of_get_named_gpio(rdata[reg].of_node,
600                                 "samsung,ext-control-gpios", 0);
601                 if (gpio_is_valid(gpio[reg]))
602                         dev_dbg(&pdev->dev, "Using GPIO %d for ext-control over %d/%s\n",
603                                         gpio[reg], reg, rdata[reg].name);
604         }
605 }
606 
607 static int s2mps11_pmic_dt_parse(struct platform_device *pdev,
608                 struct of_regulator_match *rdata, struct s2mps11_info *s2mps11,
609                 enum sec_device_type dev_type)
610 {
611         struct device_node *reg_np;
612 
613         reg_np = of_get_child_by_name(pdev->dev.parent->of_node, "regulators");
614         if (!reg_np) {
615                 dev_err(&pdev->dev, "could not find regulators sub-node\n");
616                 return -EINVAL;
617         }
618 
619         of_regulator_match(&pdev->dev, reg_np, rdata, s2mps11->rdev_num);
620         if (dev_type == S2MPS14X)
621                 s2mps14_pmic_dt_parse_ext_control_gpio(pdev, rdata, s2mps11);
622 
623         of_node_put(reg_np);
624 
625         return 0;
626 }
627 
628 static int s2mps11_pmic_probe(struct platform_device *pdev)
629 {
630         struct sec_pmic_dev *iodev = dev_get_drvdata(pdev->dev.parent);
631         struct sec_platform_data *pdata = NULL;
632         struct of_regulator_match *rdata = NULL;
633         struct regulator_config config = { };
634         struct s2mps11_info *s2mps11;
635         int i, ret = 0;
636         const struct regulator_desc *regulators;
637         enum sec_device_type dev_type;
638 
639         s2mps11 = devm_kzalloc(&pdev->dev, sizeof(struct s2mps11_info),
640                                 GFP_KERNEL);
641         if (!s2mps11)
642                 return -ENOMEM;
643 
644         dev_type = platform_get_device_id(pdev)->driver_data;
645         switch (dev_type) {
646         case S2MPS11X:
647                 s2mps11->rdev_num = ARRAY_SIZE(s2mps11_regulators);
648                 regulators = s2mps11_regulators;
649                 break;
650         case S2MPS14X:
651                 s2mps11->rdev_num = ARRAY_SIZE(s2mps14_regulators);
652                 regulators = s2mps14_regulators;
653                 break;
654         default:
655                 dev_err(&pdev->dev, "Invalid device type: %u\n", dev_type);
656                 return -EINVAL;
657         };
658 
659         s2mps11->ext_control_gpio = devm_kzalloc(&pdev->dev,
660                         sizeof(*s2mps11->ext_control_gpio) * s2mps11->rdev_num,
661                         GFP_KERNEL);
662         if (!s2mps11->ext_control_gpio)
663                 return -ENOMEM;
664         /*
665          * 0 is a valid GPIO so initialize all GPIO-s to negative value
666          * to indicate that external control won't be used for this regulator.
667          */
668         for (i = 0; i < s2mps11->rdev_num; i++)
669                 s2mps11->ext_control_gpio[i] = -EINVAL;
670 
671         if (!iodev->dev->of_node) {
672                 if (iodev->pdata) {
673                         pdata = iodev->pdata;
674                         goto common_reg;
675                 } else {
676                         dev_err(pdev->dev.parent,
677                                 "Platform data or DT node not supplied\n");
678                         return -ENODEV;
679                 }
680         }
681 
682         rdata = kzalloc(sizeof(*rdata) * s2mps11->rdev_num, GFP_KERNEL);
683         if (!rdata)
684                 return -ENOMEM;
685 
686         for (i = 0; i < s2mps11->rdev_num; i++)
687                 rdata[i].name = regulators[i].name;
688 
689         ret = s2mps11_pmic_dt_parse(pdev, rdata, s2mps11, dev_type);
690         if (ret)
691                 goto out;
692 
693 common_reg:
694         platform_set_drvdata(pdev, s2mps11);
695 
696         config.dev = &pdev->dev;
697         config.regmap = iodev->regmap_pmic;
698         config.driver_data = s2mps11;
699         config.ena_gpio_flags = GPIOF_OUT_INIT_HIGH;
700         for (i = 0; i < s2mps11->rdev_num; i++) {
701                 struct regulator_dev *regulator;
702 
703                 if (pdata) {
704                         config.init_data = pdata->regulators[i].initdata;
705                         config.of_node = pdata->regulators[i].reg_node;
706                 } else {
707                         config.init_data = rdata[i].init_data;
708                         config.of_node = rdata[i].of_node;
709                 }
710                 config.ena_gpio = s2mps11->ext_control_gpio[i];
711 
712                 regulator = devm_regulator_register(&pdev->dev,
713                                                 &regulators[i], &config);
714                 if (IS_ERR(regulator)) {
715                         ret = PTR_ERR(regulator);
716                         dev_err(&pdev->dev, "regulator init failed for %d\n",
717                                 i);
718                         goto out;
719                 }
720 
721                 if (gpio_is_valid(s2mps11->ext_control_gpio[i])) {
722                         ret = s2mps14_pmic_enable_ext_control(s2mps11,
723                                         regulator);
724                         if (ret < 0) {
725                                 dev_err(&pdev->dev,
726                                                 "failed to enable GPIO control over %s: %d\n",
727                                                 regulator->desc->name, ret);
728                                 goto out;
729                         }
730                 }
731         }
732 
733 out:
734         kfree(rdata);
735 
736         return ret;
737 }
738 
739 static const struct platform_device_id s2mps11_pmic_id[] = {
740         { "s2mps11-pmic", S2MPS11X},
741         { "s2mps14-pmic", S2MPS14X},
742         { },
743 };
744 MODULE_DEVICE_TABLE(platform, s2mps11_pmic_id);
745 
746 static struct platform_driver s2mps11_pmic_driver = {
747         .driver = {
748                 .name = "s2mps11-pmic",
749                 .owner = THIS_MODULE,
750         },
751         .probe = s2mps11_pmic_probe,
752         .id_table = s2mps11_pmic_id,
753 };
754 
755 static int __init s2mps11_pmic_init(void)
756 {
757         return platform_driver_register(&s2mps11_pmic_driver);
758 }
759 subsys_initcall(s2mps11_pmic_init);
760 
761 static void __exit s2mps11_pmic_exit(void)
762 {
763         platform_driver_unregister(&s2mps11_pmic_driver);
764 }
765 module_exit(s2mps11_pmic_exit);
766 
767 /* Module information */
768 MODULE_AUTHOR("Sangbeom Kim <sbkim73@samsung.com>");
769 MODULE_DESCRIPTION("SAMSUNG S2MPS11/S2MPS14 Regulator Driver");
770 MODULE_LICENSE("GPL");
771 

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