]> git.karo-electronics.de Git - karo-tx-linux.git/blob - drivers/regulator/s2mpa01.c
drivers/base: use %*pb[l] to print bitmaps including cpumasks and nodemasks
[karo-tx-linux.git] / drivers / regulator / s2mpa01.c
1 /*
2  * Copyright (c) 2013 Samsung Electronics Co., Ltd
3  *              http://www.samsung.com
4  *
5  *  This program is free software; you can redistribute  it and/or modify it
6  *  under  the terms of  the GNU General  Public License as published by the
7  *  Free Software Foundation;  either version 2 of the  License, or (at your
8  *  option) any later version.
9  *
10  */
11
12 #include <linux/bug.h>
13 #include <linux/err.h>
14 #include <linux/gpio.h>
15 #include <linux/slab.h>
16 #include <linux/module.h>
17 #include <linux/of.h>
18 #include <linux/regmap.h>
19 #include <linux/platform_device.h>
20 #include <linux/regulator/driver.h>
21 #include <linux/regulator/machine.h>
22 #include <linux/regulator/of_regulator.h>
23 #include <linux/mfd/samsung/core.h>
24 #include <linux/mfd/samsung/s2mpa01.h>
25
26 #define S2MPA01_REGULATOR_CNT ARRAY_SIZE(regulators)
27
28 struct s2mpa01_info {
29         int ramp_delay24;
30         int ramp_delay3;
31         int ramp_delay5;
32         int ramp_delay16;
33         int ramp_delay7;
34         int ramp_delay8910;
35 };
36
37 static int get_ramp_delay(int ramp_delay)
38 {
39         unsigned char cnt = 0;
40
41         ramp_delay /= 6250;
42
43         while (true) {
44                 ramp_delay = ramp_delay >> 1;
45                 if (ramp_delay == 0)
46                         break;
47                 cnt++;
48         }
49
50         if (cnt > 3)
51                 cnt = 3;
52
53         return cnt;
54 }
55
56 static int s2mpa01_regulator_set_voltage_time_sel(struct regulator_dev *rdev,
57                                    unsigned int old_selector,
58                                    unsigned int new_selector)
59 {
60         struct s2mpa01_info *s2mpa01 = rdev_get_drvdata(rdev);
61         unsigned int ramp_delay = 0;
62         int old_volt, new_volt;
63
64         switch (rdev_get_id(rdev)) {
65         case S2MPA01_BUCK2:
66         case S2MPA01_BUCK4:
67                 ramp_delay = s2mpa01->ramp_delay24;
68                 break;
69         case S2MPA01_BUCK3:
70                 ramp_delay = s2mpa01->ramp_delay3;
71                 break;
72         case S2MPA01_BUCK5:
73                 ramp_delay = s2mpa01->ramp_delay5;
74                 break;
75         case S2MPA01_BUCK1:
76         case S2MPA01_BUCK6:
77                 ramp_delay = s2mpa01->ramp_delay16;
78                 break;
79         case S2MPA01_BUCK7:
80                 ramp_delay = s2mpa01->ramp_delay7;
81                 break;
82         case S2MPA01_BUCK8:
83         case S2MPA01_BUCK9:
84         case S2MPA01_BUCK10:
85                 ramp_delay = s2mpa01->ramp_delay8910;
86                 break;
87         }
88
89         if (ramp_delay == 0)
90                 ramp_delay = rdev->desc->ramp_delay;
91
92         old_volt = rdev->desc->min_uV + (rdev->desc->uV_step * old_selector);
93         new_volt = rdev->desc->min_uV + (rdev->desc->uV_step * new_selector);
94
95         return DIV_ROUND_UP(abs(new_volt - old_volt), ramp_delay);
96 }
97
98 static int s2mpa01_set_ramp_delay(struct regulator_dev *rdev, int ramp_delay)
99 {
100         struct s2mpa01_info *s2mpa01 = rdev_get_drvdata(rdev);
101         unsigned int ramp_val, ramp_shift, ramp_reg = S2MPA01_REG_RAMP2;
102         unsigned int ramp_enable = 1, enable_shift = 0;
103         int ret;
104
105         switch (rdev_get_id(rdev)) {
106         case S2MPA01_BUCK1:
107                 enable_shift = S2MPA01_BUCK1_RAMP_EN_SHIFT;
108                 if (!ramp_delay) {
109                         ramp_enable = 0;
110                         break;
111                 }
112
113                 if (ramp_delay > s2mpa01->ramp_delay16)
114                         s2mpa01->ramp_delay16 = ramp_delay;
115                 else
116                         ramp_delay = s2mpa01->ramp_delay16;
117
118                 ramp_shift = S2MPA01_BUCK16_RAMP_SHIFT;
119                 break;
120         case S2MPA01_BUCK2:
121                 enable_shift = S2MPA01_BUCK2_RAMP_EN_SHIFT;
122                 if (!ramp_delay) {
123                         ramp_enable = 0;
124                         break;
125                 }
126
127                 if (ramp_delay > s2mpa01->ramp_delay24)
128                         s2mpa01->ramp_delay24 = ramp_delay;
129                 else
130                         ramp_delay = s2mpa01->ramp_delay24;
131
132                 ramp_shift = S2MPA01_BUCK24_RAMP_SHIFT;
133                 ramp_reg = S2MPA01_REG_RAMP1;
134                 break;
135         case S2MPA01_BUCK3:
136                 enable_shift = S2MPA01_BUCK3_RAMP_EN_SHIFT;
137                 if (!ramp_delay) {
138                         ramp_enable = 0;
139                         break;
140                 }
141
142                 s2mpa01->ramp_delay3 = ramp_delay;
143                 ramp_shift = S2MPA01_BUCK3_RAMP_SHIFT;
144                 ramp_reg = S2MPA01_REG_RAMP1;
145                 break;
146         case S2MPA01_BUCK4:
147                 enable_shift = S2MPA01_BUCK4_RAMP_EN_SHIFT;
148                 if (!ramp_delay) {
149                         ramp_enable = 0;
150                         break;
151                 }
152
153                 if (ramp_delay > s2mpa01->ramp_delay24)
154                         s2mpa01->ramp_delay24 = ramp_delay;
155                 else
156                         ramp_delay = s2mpa01->ramp_delay24;
157
158                 ramp_shift = S2MPA01_BUCK24_RAMP_SHIFT;
159                 ramp_reg = S2MPA01_REG_RAMP1;
160                 break;
161         case S2MPA01_BUCK5:
162                 s2mpa01->ramp_delay5 = ramp_delay;
163                 ramp_shift = S2MPA01_BUCK5_RAMP_SHIFT;
164                 break;
165         case S2MPA01_BUCK6:
166                 if (ramp_delay > s2mpa01->ramp_delay16)
167                         s2mpa01->ramp_delay16 = ramp_delay;
168                 else
169                         ramp_delay = s2mpa01->ramp_delay16;
170
171                 ramp_shift = S2MPA01_BUCK16_RAMP_SHIFT;
172                 break;
173         case S2MPA01_BUCK7:
174                 s2mpa01->ramp_delay7 = ramp_delay;
175                 ramp_shift = S2MPA01_BUCK7_RAMP_SHIFT;
176                 break;
177         case S2MPA01_BUCK8:
178         case S2MPA01_BUCK9:
179         case S2MPA01_BUCK10:
180                 if (ramp_delay > s2mpa01->ramp_delay8910)
181                         s2mpa01->ramp_delay8910 = ramp_delay;
182                 else
183                         ramp_delay = s2mpa01->ramp_delay8910;
184
185                 ramp_shift = S2MPA01_BUCK8910_RAMP_SHIFT;
186                 break;
187         default:
188                 return 0;
189         }
190
191         if (!ramp_enable)
192                 goto ramp_disable;
193
194         /* Ramp delay can be enabled/disabled only for buck[1234] */
195         if (rdev_get_id(rdev) >= S2MPA01_BUCK1 &&
196                         rdev_get_id(rdev) <= S2MPA01_BUCK4) {
197                 ret = regmap_update_bits(rdev->regmap, S2MPA01_REG_RAMP1,
198                                          1 << enable_shift, 1 << enable_shift);
199                 if (ret) {
200                         dev_err(&rdev->dev, "failed to enable ramp rate\n");
201                         return ret;
202                 }
203         }
204
205         ramp_val = get_ramp_delay(ramp_delay);
206
207         return regmap_update_bits(rdev->regmap, ramp_reg, 0x3 << ramp_shift,
208                                   ramp_val << ramp_shift);
209
210 ramp_disable:
211         return regmap_update_bits(rdev->regmap, S2MPA01_REG_RAMP1,
212                                   1 << enable_shift, 0);
213 }
214
215 static struct regulator_ops s2mpa01_ldo_ops = {
216         .list_voltage           = regulator_list_voltage_linear,
217         .map_voltage            = regulator_map_voltage_linear,
218         .is_enabled             = regulator_is_enabled_regmap,
219         .enable                 = regulator_enable_regmap,
220         .disable                = regulator_disable_regmap,
221         .get_voltage_sel        = regulator_get_voltage_sel_regmap,
222         .set_voltage_sel        = regulator_set_voltage_sel_regmap,
223         .set_voltage_time_sel   = regulator_set_voltage_time_sel,
224 };
225
226 static struct regulator_ops s2mpa01_buck_ops = {
227         .list_voltage           = regulator_list_voltage_linear,
228         .map_voltage            = regulator_map_voltage_linear,
229         .is_enabled             = regulator_is_enabled_regmap,
230         .enable                 = regulator_enable_regmap,
231         .disable                = regulator_disable_regmap,
232         .get_voltage_sel        = regulator_get_voltage_sel_regmap,
233         .set_voltage_sel        = regulator_set_voltage_sel_regmap,
234         .set_voltage_time_sel   = s2mpa01_regulator_set_voltage_time_sel,
235         .set_ramp_delay         = s2mpa01_set_ramp_delay,
236 };
237
238 #define regulator_desc_ldo(num, step) {                 \
239         .name           = "LDO"#num,                    \
240         .id             = S2MPA01_LDO##num,             \
241         .ops            = &s2mpa01_ldo_ops,             \
242         .type           = REGULATOR_VOLTAGE,            \
243         .owner          = THIS_MODULE,                  \
244         .min_uV         = MIN_800_MV,                   \
245         .uV_step        = step,                         \
246         .n_voltages     = S2MPA01_LDO_N_VOLTAGES,       \
247         .vsel_reg       = S2MPA01_REG_L1CTRL + num - 1, \
248         .vsel_mask      = S2MPA01_LDO_VSEL_MASK,        \
249         .enable_reg     = S2MPA01_REG_L1CTRL + num - 1, \
250         .enable_mask    = S2MPA01_ENABLE_MASK           \
251 }
252
253 #define regulator_desc_buck1_4(num)     {                       \
254         .name           = "BUCK"#num,                           \
255         .id             = S2MPA01_BUCK##num,                    \
256         .ops            = &s2mpa01_buck_ops,                    \
257         .type           = REGULATOR_VOLTAGE,                    \
258         .owner          = THIS_MODULE,                          \
259         .min_uV         = MIN_600_MV,                           \
260         .uV_step        = STEP_6_25_MV,                         \
261         .n_voltages     = S2MPA01_BUCK_N_VOLTAGES,              \
262         .ramp_delay     = S2MPA01_RAMP_DELAY,                   \
263         .vsel_reg       = S2MPA01_REG_B1CTRL2 + (num - 1) * 2,  \
264         .vsel_mask      = S2MPA01_BUCK_VSEL_MASK,               \
265         .enable_reg     = S2MPA01_REG_B1CTRL1 + (num - 1) * 2,  \
266         .enable_mask    = S2MPA01_ENABLE_MASK                   \
267 }
268
269 #define regulator_desc_buck5    {                               \
270         .name           = "BUCK5",                              \
271         .id             = S2MPA01_BUCK5,                        \
272         .ops            = &s2mpa01_buck_ops,                    \
273         .type           = REGULATOR_VOLTAGE,                    \
274         .owner          = THIS_MODULE,                          \
275         .min_uV         = MIN_800_MV,                           \
276         .uV_step        = STEP_6_25_MV,                         \
277         .n_voltages     = S2MPA01_BUCK_N_VOLTAGES,              \
278         .ramp_delay     = S2MPA01_RAMP_DELAY,                   \
279         .vsel_reg       = S2MPA01_REG_B5CTRL2,                  \
280         .vsel_mask      = S2MPA01_BUCK_VSEL_MASK,               \
281         .enable_reg     = S2MPA01_REG_B5CTRL1,                  \
282         .enable_mask    = S2MPA01_ENABLE_MASK                   \
283 }
284
285 #define regulator_desc_buck6_10(num, min, step) {                       \
286         .name           = "BUCK"#num,                           \
287         .id             = S2MPA01_BUCK##num,                    \
288         .ops            = &s2mpa01_buck_ops,                    \
289         .type           = REGULATOR_VOLTAGE,                    \
290         .owner          = THIS_MODULE,                          \
291         .min_uV         = min,                                  \
292         .uV_step        = step,                                 \
293         .n_voltages     = S2MPA01_BUCK_N_VOLTAGES,              \
294         .ramp_delay     = S2MPA01_RAMP_DELAY,                   \
295         .vsel_reg       = S2MPA01_REG_B6CTRL2 + (num - 6) * 2,  \
296         .vsel_mask      = S2MPA01_BUCK_VSEL_MASK,               \
297         .enable_reg     = S2MPA01_REG_B6CTRL1 + (num - 6) * 2,  \
298         .enable_mask    = S2MPA01_ENABLE_MASK                   \
299 }
300
301 static const struct regulator_desc regulators[] = {
302         regulator_desc_ldo(1, STEP_25_MV),
303         regulator_desc_ldo(2, STEP_50_MV),
304         regulator_desc_ldo(3, STEP_50_MV),
305         regulator_desc_ldo(4, STEP_50_MV),
306         regulator_desc_ldo(5, STEP_50_MV),
307         regulator_desc_ldo(6, STEP_25_MV),
308         regulator_desc_ldo(7, STEP_50_MV),
309         regulator_desc_ldo(8, STEP_50_MV),
310         regulator_desc_ldo(9, STEP_50_MV),
311         regulator_desc_ldo(10, STEP_50_MV),
312         regulator_desc_ldo(11, STEP_25_MV),
313         regulator_desc_ldo(12, STEP_50_MV),
314         regulator_desc_ldo(13, STEP_50_MV),
315         regulator_desc_ldo(14, STEP_50_MV),
316         regulator_desc_ldo(15, STEP_50_MV),
317         regulator_desc_ldo(16, STEP_50_MV),
318         regulator_desc_ldo(17, STEP_50_MV),
319         regulator_desc_ldo(18, STEP_50_MV),
320         regulator_desc_ldo(19, STEP_50_MV),
321         regulator_desc_ldo(20, STEP_50_MV),
322         regulator_desc_ldo(21, STEP_50_MV),
323         regulator_desc_ldo(22, STEP_25_MV),
324         regulator_desc_ldo(23, STEP_25_MV),
325         regulator_desc_ldo(24, STEP_50_MV),
326         regulator_desc_ldo(25, STEP_50_MV),
327         regulator_desc_ldo(26, STEP_50_MV),
328         regulator_desc_buck1_4(1),
329         regulator_desc_buck1_4(2),
330         regulator_desc_buck1_4(3),
331         regulator_desc_buck1_4(4),
332         regulator_desc_buck5,
333         regulator_desc_buck6_10(6, MIN_600_MV, STEP_6_25_MV),
334         regulator_desc_buck6_10(7, MIN_600_MV, STEP_6_25_MV),
335         regulator_desc_buck6_10(8, MIN_800_MV, STEP_12_5_MV),
336         regulator_desc_buck6_10(9, MIN_1500_MV, STEP_12_5_MV),
337         regulator_desc_buck6_10(10, MIN_1000_MV, STEP_12_5_MV),
338 };
339
340 static int s2mpa01_pmic_probe(struct platform_device *pdev)
341 {
342         struct sec_pmic_dev *iodev = dev_get_drvdata(pdev->dev.parent);
343         struct sec_platform_data *pdata = dev_get_platdata(iodev->dev);
344         struct of_regulator_match rdata[S2MPA01_REGULATOR_MAX] = { };
345         struct device_node *reg_np = NULL;
346         struct regulator_config config = { };
347         struct s2mpa01_info *s2mpa01;
348         int i;
349
350         s2mpa01 = devm_kzalloc(&pdev->dev, sizeof(*s2mpa01), GFP_KERNEL);
351         if (!s2mpa01)
352                 return -ENOMEM;
353
354         for (i = 0; i < S2MPA01_REGULATOR_CNT; i++)
355                 rdata[i].name = regulators[i].name;
356
357         if (iodev->dev->of_node) {
358                 reg_np = of_get_child_by_name(iodev->dev->of_node,
359                                                         "regulators");
360                         if (!reg_np) {
361                                 dev_err(&pdev->dev,
362                                         "could not find regulators sub-node\n");
363                                 return -EINVAL;
364                         }
365
366                 of_regulator_match(&pdev->dev, reg_np, rdata,
367                                                 S2MPA01_REGULATOR_MAX);
368                 of_node_put(reg_np);
369         }
370
371         platform_set_drvdata(pdev, s2mpa01);
372
373         config.dev = &pdev->dev;
374         config.regmap = iodev->regmap_pmic;
375         config.driver_data = s2mpa01;
376
377         for (i = 0; i < S2MPA01_REGULATOR_MAX; i++) {
378                 struct regulator_dev *rdev;
379                 if (pdata)
380                         config.init_data = pdata->regulators[i].initdata;
381                 else
382                         config.init_data = rdata[i].init_data;
383
384                 if (reg_np)
385                         config.of_node = rdata[i].of_node;
386
387                 rdev = devm_regulator_register(&pdev->dev,
388                                                 &regulators[i], &config);
389                 if (IS_ERR(rdev)) {
390                         dev_err(&pdev->dev, "regulator init failed for %d\n",
391                                 i);
392                         return PTR_ERR(rdev);
393                 }
394         }
395
396         return 0;
397 }
398
399 static const struct platform_device_id s2mpa01_pmic_id[] = {
400         { "s2mpa01-pmic", 0},
401         { },
402 };
403 MODULE_DEVICE_TABLE(platform, s2mpa01_pmic_id);
404
405 static struct platform_driver s2mpa01_pmic_driver = {
406         .driver = {
407                 .name = "s2mpa01-pmic",
408         },
409         .probe = s2mpa01_pmic_probe,
410         .id_table = s2mpa01_pmic_id,
411 };
412
413 module_platform_driver(s2mpa01_pmic_driver);
414
415 /* Module information */
416 MODULE_AUTHOR("Sangbeom Kim <sbkim73@samsung.com>");
417 MODULE_AUTHOR("Sachin Kamat <sachin.kamat@samsung.com>");
418 MODULE_DESCRIPTION("SAMSUNG S2MPA01 Regulator Driver");
419 MODULE_LICENSE("GPL");