virtio-mem: don't read big block size in Sub Block Mode
[linux-2.6-microblaze.git] / drivers / regulator / bd71828-regulator.c
1 // SPDX-License-Identifier: GPL-2.0-only
2 // Copyright (C) 2019 ROHM Semiconductors
3 // bd71828-regulator.c ROHM BD71828GW-DS1 regulator driver
4 //
5
6 #include <linux/delay.h>
7 #include <linux/err.h>
8 #include <linux/gpio.h>
9 #include <linux/interrupt.h>
10 #include <linux/kernel.h>
11 #include <linux/mfd/rohm-bd71828.h>
12 #include <linux/module.h>
13 #include <linux/of.h>
14 #include <linux/platform_device.h>
15 #include <linux/regmap.h>
16 #include <linux/regulator/driver.h>
17 #include <linux/regulator/machine.h>
18 #include <linux/regulator/of_regulator.h>
19
20 struct reg_init {
21         unsigned int reg;
22         unsigned int mask;
23         unsigned int val;
24 };
25 struct bd71828_regulator_data {
26         struct regulator_desc desc;
27         const struct rohm_dvs_config dvs;
28         const struct reg_init *reg_inits;
29         int reg_init_amnt;
30 };
31
32 static const struct reg_init buck1_inits[] = {
33         /*
34          * DVS Buck voltages can be changed by register values or via GPIO.
35          * Use register accesses by default.
36          */
37         {
38                 .reg = BD71828_REG_PS_CTRL_1,
39                 .mask = BD71828_MASK_DVS_BUCK1_CTRL,
40                 .val = BD71828_DVS_BUCK1_CTRL_I2C,
41         },
42 };
43
44 static const struct reg_init buck2_inits[] = {
45         {
46                 .reg = BD71828_REG_PS_CTRL_1,
47                 .mask = BD71828_MASK_DVS_BUCK2_CTRL,
48                 .val = BD71828_DVS_BUCK2_CTRL_I2C,
49         },
50 };
51
52 static const struct reg_init buck6_inits[] = {
53         {
54                 .reg = BD71828_REG_PS_CTRL_1,
55                 .mask = BD71828_MASK_DVS_BUCK6_CTRL,
56                 .val = BD71828_DVS_BUCK6_CTRL_I2C,
57         },
58 };
59
60 static const struct reg_init buck7_inits[] = {
61         {
62                 .reg = BD71828_REG_PS_CTRL_1,
63                 .mask = BD71828_MASK_DVS_BUCK7_CTRL,
64                 .val = BD71828_DVS_BUCK7_CTRL_I2C,
65         },
66 };
67
68 static const struct linear_range bd71828_buck1267_volts[] = {
69         REGULATOR_LINEAR_RANGE(500000, 0x00, 0xef, 6250),
70         REGULATOR_LINEAR_RANGE(2000000, 0xf0, 0xff, 0),
71 };
72
73 static const struct linear_range bd71828_buck3_volts[] = {
74         REGULATOR_LINEAR_RANGE(1200000, 0x00, 0x0f, 50000),
75         REGULATOR_LINEAR_RANGE(2000000, 0x10, 0x1f, 0),
76 };
77
78 static const struct linear_range bd71828_buck4_volts[] = {
79         REGULATOR_LINEAR_RANGE(1000000, 0x00, 0x1f, 25000),
80         REGULATOR_LINEAR_RANGE(1800000, 0x20, 0x3f, 0),
81 };
82
83 static const struct linear_range bd71828_buck5_volts[] = {
84         REGULATOR_LINEAR_RANGE(2500000, 0x00, 0x0f, 50000),
85         REGULATOR_LINEAR_RANGE(3300000, 0x10, 0x1f, 0),
86 };
87
88 static const struct linear_range bd71828_ldo_volts[] = {
89         REGULATOR_LINEAR_RANGE(800000, 0x00, 0x31, 50000),
90         REGULATOR_LINEAR_RANGE(3300000, 0x32, 0x3f, 0),
91 };
92
93 static const unsigned int bd71828_ramp_delay[] = { 2500, 5000, 10000, 20000 };
94
95 static int buck_set_hw_dvs_levels(struct device_node *np,
96                                   const struct regulator_desc *desc,
97                                   struct regulator_config *cfg)
98 {
99         struct bd71828_regulator_data *data;
100
101         data = container_of(desc, struct bd71828_regulator_data, desc);
102
103         return rohm_regulator_set_dvs_levels(&data->dvs, np, desc, cfg->regmap);
104 }
105
106 static int ldo6_parse_dt(struct device_node *np,
107                          const struct regulator_desc *desc,
108                          struct regulator_config *cfg)
109 {
110         int ret, i;
111         uint32_t uv = 0;
112         unsigned int en;
113         struct regmap *regmap = cfg->regmap;
114         static const char * const props[] = { "rohm,dvs-run-voltage",
115                                               "rohm,dvs-idle-voltage",
116                                               "rohm,dvs-suspend-voltage",
117                                               "rohm,dvs-lpsr-voltage" };
118         unsigned int mask[] = { BD71828_MASK_RUN_EN, BD71828_MASK_IDLE_EN,
119                                BD71828_MASK_SUSP_EN, BD71828_MASK_LPSR_EN };
120
121         for (i = 0; i < ARRAY_SIZE(props); i++) {
122                 ret = of_property_read_u32(np, props[i], &uv);
123                 if (ret) {
124                         if (ret != -EINVAL)
125                                 return ret;
126                         continue;
127                 }
128                 if (uv)
129                         en = 0xffffffff;
130                 else
131                         en = 0;
132
133                 ret = regmap_update_bits(regmap, desc->enable_reg, mask[i], en);
134                 if (ret)
135                         return ret;
136         }
137         return 0;
138 }
139
140 static const struct regulator_ops bd71828_buck_ops = {
141         .enable = regulator_enable_regmap,
142         .disable = regulator_disable_regmap,
143         .is_enabled = regulator_is_enabled_regmap,
144         .list_voltage = regulator_list_voltage_linear_range,
145         .set_voltage_sel = regulator_set_voltage_sel_regmap,
146         .get_voltage_sel = regulator_get_voltage_sel_regmap,
147 };
148
149 static const struct regulator_ops bd71828_dvs_buck_ops = {
150         .enable = regulator_enable_regmap,
151         .disable = regulator_disable_regmap,
152         .is_enabled = regulator_is_enabled_regmap,
153         .list_voltage = regulator_list_voltage_linear_range,
154         .set_voltage_sel = regulator_set_voltage_sel_regmap,
155         .get_voltage_sel = regulator_get_voltage_sel_regmap,
156         .set_voltage_time_sel = regulator_set_voltage_time_sel,
157         .set_ramp_delay = regulator_set_ramp_delay_regmap,
158 };
159
160 static const struct regulator_ops bd71828_ldo_ops = {
161         .enable = regulator_enable_regmap,
162         .disable = regulator_disable_regmap,
163         .is_enabled = regulator_is_enabled_regmap,
164         .list_voltage = regulator_list_voltage_linear_range,
165         .set_voltage_sel = regulator_set_voltage_sel_regmap,
166         .get_voltage_sel = regulator_get_voltage_sel_regmap,
167 };
168
169 static const struct regulator_ops bd71828_ldo6_ops = {
170         .enable = regulator_enable_regmap,
171         .disable = regulator_disable_regmap,
172         .is_enabled = regulator_is_enabled_regmap,
173 };
174
175 static const struct bd71828_regulator_data bd71828_rdata[] = {
176         {
177                 .desc = {
178                         .name = "buck1",
179                         .of_match = of_match_ptr("BUCK1"),
180                         .regulators_node = of_match_ptr("regulators"),
181                         .id = BD71828_BUCK1,
182                         .ops = &bd71828_dvs_buck_ops,
183                         .type = REGULATOR_VOLTAGE,
184                         .linear_ranges = bd71828_buck1267_volts,
185                         .n_linear_ranges = ARRAY_SIZE(bd71828_buck1267_volts),
186                         .n_voltages = BD71828_BUCK1267_VOLTS,
187                         .enable_reg = BD71828_REG_BUCK1_EN,
188                         .enable_mask = BD71828_MASK_RUN_EN,
189                         .vsel_reg = BD71828_REG_BUCK1_VOLT,
190                         .vsel_mask = BD71828_MASK_BUCK1267_VOLT,
191                         .ramp_delay_table = bd71828_ramp_delay,
192                         .n_ramp_values = ARRAY_SIZE(bd71828_ramp_delay),
193                         .ramp_reg = BD71828_REG_BUCK1_MODE,
194                         .ramp_mask = BD71828_MASK_RAMP_DELAY,
195                         .owner = THIS_MODULE,
196                         .of_parse_cb = buck_set_hw_dvs_levels,
197                 },
198                 .dvs = {
199                         .level_map = ROHM_DVS_LEVEL_RUN | ROHM_DVS_LEVEL_IDLE |
200                                      ROHM_DVS_LEVEL_SUSPEND |
201                                      ROHM_DVS_LEVEL_LPSR,
202                         .run_reg = BD71828_REG_BUCK1_VOLT,
203                         .run_mask = BD71828_MASK_BUCK1267_VOLT,
204                         .idle_reg = BD71828_REG_BUCK1_IDLE_VOLT,
205                         .idle_mask = BD71828_MASK_BUCK1267_VOLT,
206                         .idle_on_mask = BD71828_MASK_IDLE_EN,
207                         .suspend_reg = BD71828_REG_BUCK1_SUSP_VOLT,
208                         .suspend_mask = BD71828_MASK_BUCK1267_VOLT,
209                         .suspend_on_mask = BD71828_MASK_SUSP_EN,
210                         .lpsr_on_mask = BD71828_MASK_LPSR_EN,
211                         /*
212                          * LPSR voltage is same as SUSPEND voltage. Allow
213                          * setting it so that regulator can be set enabled at
214                          * LPSR state
215                          */
216                         .lpsr_reg = BD71828_REG_BUCK1_SUSP_VOLT,
217                         .lpsr_mask = BD71828_MASK_BUCK1267_VOLT,
218                 },
219                 .reg_inits = buck1_inits,
220                 .reg_init_amnt = ARRAY_SIZE(buck1_inits),
221         },
222         {
223                 .desc = {
224                         .name = "buck2",
225                         .of_match = of_match_ptr("BUCK2"),
226                         .regulators_node = of_match_ptr("regulators"),
227                         .id = BD71828_BUCK2,
228                         .ops = &bd71828_dvs_buck_ops,
229                         .type = REGULATOR_VOLTAGE,
230                         .linear_ranges = bd71828_buck1267_volts,
231                         .n_linear_ranges = ARRAY_SIZE(bd71828_buck1267_volts),
232                         .n_voltages = BD71828_BUCK1267_VOLTS,
233                         .enable_reg = BD71828_REG_BUCK2_EN,
234                         .enable_mask = BD71828_MASK_RUN_EN,
235                         .vsel_reg = BD71828_REG_BUCK2_VOLT,
236                         .vsel_mask = BD71828_MASK_BUCK1267_VOLT,
237                         .ramp_delay_table = bd71828_ramp_delay,
238                         .n_ramp_values = ARRAY_SIZE(bd71828_ramp_delay),
239                         .ramp_reg = BD71828_REG_BUCK2_MODE,
240                         .ramp_mask = BD71828_MASK_RAMP_DELAY,
241                         .owner = THIS_MODULE,
242                         .of_parse_cb = buck_set_hw_dvs_levels,
243                 },
244                 .dvs = {
245                         .level_map = ROHM_DVS_LEVEL_RUN | ROHM_DVS_LEVEL_IDLE |
246                                      ROHM_DVS_LEVEL_SUSPEND |
247                                      ROHM_DVS_LEVEL_LPSR,
248                         .run_reg = BD71828_REG_BUCK2_VOLT,
249                         .run_mask = BD71828_MASK_BUCK1267_VOLT,
250                         .idle_reg = BD71828_REG_BUCK2_IDLE_VOLT,
251                         .idle_mask = BD71828_MASK_BUCK1267_VOLT,
252                         .idle_on_mask = BD71828_MASK_IDLE_EN,
253                         .suspend_reg = BD71828_REG_BUCK2_SUSP_VOLT,
254                         .suspend_mask = BD71828_MASK_BUCK1267_VOLT,
255                         .suspend_on_mask = BD71828_MASK_SUSP_EN,
256                         .lpsr_on_mask = BD71828_MASK_LPSR_EN,
257                         .lpsr_reg = BD71828_REG_BUCK2_SUSP_VOLT,
258                         .lpsr_mask = BD71828_MASK_BUCK1267_VOLT,
259                 },
260                 .reg_inits = buck2_inits,
261                 .reg_init_amnt = ARRAY_SIZE(buck2_inits),
262         },
263         {
264                 .desc = {
265                         .name = "buck3",
266                         .of_match = of_match_ptr("BUCK3"),
267                         .regulators_node = of_match_ptr("regulators"),
268                         .id = BD71828_BUCK3,
269                         .ops = &bd71828_buck_ops,
270                         .type = REGULATOR_VOLTAGE,
271                         .linear_ranges = bd71828_buck3_volts,
272                         .n_linear_ranges = ARRAY_SIZE(bd71828_buck3_volts),
273                         .n_voltages = BD71828_BUCK3_VOLTS,
274                         .enable_reg = BD71828_REG_BUCK3_EN,
275                         .enable_mask = BD71828_MASK_RUN_EN,
276                         .vsel_reg = BD71828_REG_BUCK3_VOLT,
277                         .vsel_mask = BD71828_MASK_BUCK3_VOLT,
278                         .owner = THIS_MODULE,
279                         .of_parse_cb = buck_set_hw_dvs_levels,
280                 },
281                 .dvs = {
282                         /*
283                          * BUCK3 only supports single voltage for all states.
284                          * voltage can be individually enabled for each state
285                          * though => allow setting all states to support
286                          * enabling power rail on different states.
287                          */
288                         .level_map = ROHM_DVS_LEVEL_RUN | ROHM_DVS_LEVEL_IDLE |
289                                      ROHM_DVS_LEVEL_SUSPEND |
290                                      ROHM_DVS_LEVEL_LPSR,
291                         .run_reg = BD71828_REG_BUCK3_VOLT,
292                         .idle_reg = BD71828_REG_BUCK3_VOLT,
293                         .suspend_reg = BD71828_REG_BUCK3_VOLT,
294                         .lpsr_reg = BD71828_REG_BUCK3_VOLT,
295                         .run_mask = BD71828_MASK_BUCK3_VOLT,
296                         .idle_mask = BD71828_MASK_BUCK3_VOLT,
297                         .suspend_mask = BD71828_MASK_BUCK3_VOLT,
298                         .lpsr_mask = BD71828_MASK_BUCK3_VOLT,
299                         .idle_on_mask = BD71828_MASK_IDLE_EN,
300                         .suspend_on_mask = BD71828_MASK_SUSP_EN,
301                         .lpsr_on_mask = BD71828_MASK_LPSR_EN,
302                 },
303         },
304         {
305                 .desc = {
306                         .name = "buck4",
307                         .of_match = of_match_ptr("BUCK4"),
308                         .regulators_node = of_match_ptr("regulators"),
309                         .id = BD71828_BUCK4,
310                         .ops = &bd71828_buck_ops,
311                         .type = REGULATOR_VOLTAGE,
312                         .linear_ranges = bd71828_buck4_volts,
313                         .n_linear_ranges = ARRAY_SIZE(bd71828_buck4_volts),
314                         .n_voltages = BD71828_BUCK4_VOLTS,
315                         .enable_reg = BD71828_REG_BUCK4_EN,
316                         .enable_mask = BD71828_MASK_RUN_EN,
317                         .vsel_reg = BD71828_REG_BUCK4_VOLT,
318                         .vsel_mask = BD71828_MASK_BUCK4_VOLT,
319                         .owner = THIS_MODULE,
320                         .of_parse_cb = buck_set_hw_dvs_levels,
321                 },
322                 .dvs = {
323                         /*
324                          * BUCK4 only supports single voltage for all states.
325                          * voltage can be individually enabled for each state
326                          * though => allow setting all states to support
327                          * enabling power rail on different states.
328                          */
329                         .level_map = ROHM_DVS_LEVEL_RUN | ROHM_DVS_LEVEL_IDLE |
330                                      ROHM_DVS_LEVEL_SUSPEND |
331                                      ROHM_DVS_LEVEL_LPSR,
332                         .run_reg = BD71828_REG_BUCK4_VOLT,
333                         .idle_reg = BD71828_REG_BUCK4_VOLT,
334                         .suspend_reg = BD71828_REG_BUCK4_VOLT,
335                         .lpsr_reg = BD71828_REG_BUCK4_VOLT,
336                         .run_mask = BD71828_MASK_BUCK4_VOLT,
337                         .idle_mask = BD71828_MASK_BUCK4_VOLT,
338                         .suspend_mask = BD71828_MASK_BUCK4_VOLT,
339                         .lpsr_mask = BD71828_MASK_BUCK4_VOLT,
340                         .idle_on_mask = BD71828_MASK_IDLE_EN,
341                         .suspend_on_mask = BD71828_MASK_SUSP_EN,
342                         .lpsr_on_mask = BD71828_MASK_LPSR_EN,
343                 },
344         },
345         {
346                 .desc = {
347                         .name = "buck5",
348                         .of_match = of_match_ptr("BUCK5"),
349                         .regulators_node = of_match_ptr("regulators"),
350                         .id = BD71828_BUCK5,
351                         .ops = &bd71828_buck_ops,
352                         .type = REGULATOR_VOLTAGE,
353                         .linear_ranges = bd71828_buck5_volts,
354                         .n_linear_ranges = ARRAY_SIZE(bd71828_buck5_volts),
355                         .n_voltages = BD71828_BUCK5_VOLTS,
356                         .enable_reg = BD71828_REG_BUCK5_EN,
357                         .enable_mask = BD71828_MASK_RUN_EN,
358                         .vsel_reg = BD71828_REG_BUCK5_VOLT,
359                         .vsel_mask = BD71828_MASK_BUCK5_VOLT,
360                         .owner = THIS_MODULE,
361                         .of_parse_cb = buck_set_hw_dvs_levels,
362                 },
363                 .dvs = {
364                         /*
365                          * BUCK5 only supports single voltage for all states.
366                          * voltage can be individually enabled for each state
367                          * though => allow setting all states to support
368                          * enabling power rail on different states.
369                          */
370                         .level_map = ROHM_DVS_LEVEL_RUN | ROHM_DVS_LEVEL_IDLE |
371                                      ROHM_DVS_LEVEL_SUSPEND |
372                                      ROHM_DVS_LEVEL_LPSR,
373                         .run_reg = BD71828_REG_BUCK5_VOLT,
374                         .idle_reg = BD71828_REG_BUCK5_VOLT,
375                         .suspend_reg = BD71828_REG_BUCK5_VOLT,
376                         .lpsr_reg = BD71828_REG_BUCK5_VOLT,
377                         .run_mask = BD71828_MASK_BUCK5_VOLT,
378                         .idle_mask = BD71828_MASK_BUCK5_VOLT,
379                         .suspend_mask = BD71828_MASK_BUCK5_VOLT,
380                         .lpsr_mask = BD71828_MASK_BUCK5_VOLT,
381                         .idle_on_mask = BD71828_MASK_IDLE_EN,
382                         .suspend_on_mask = BD71828_MASK_SUSP_EN,
383                         .lpsr_on_mask = BD71828_MASK_LPSR_EN,
384                 },
385         },
386         {
387                 .desc = {
388                         .name = "buck6",
389                         .of_match = of_match_ptr("BUCK6"),
390                         .regulators_node = of_match_ptr("regulators"),
391                         .id = BD71828_BUCK6,
392                         .ops = &bd71828_dvs_buck_ops,
393                         .type = REGULATOR_VOLTAGE,
394                         .linear_ranges = bd71828_buck1267_volts,
395                         .n_linear_ranges = ARRAY_SIZE(bd71828_buck1267_volts),
396                         .n_voltages = BD71828_BUCK1267_VOLTS,
397                         .enable_reg = BD71828_REG_BUCK6_EN,
398                         .enable_mask = BD71828_MASK_RUN_EN,
399                         .vsel_reg = BD71828_REG_BUCK6_VOLT,
400                         .vsel_mask = BD71828_MASK_BUCK1267_VOLT,
401                         .ramp_delay_table = bd71828_ramp_delay,
402                         .n_ramp_values = ARRAY_SIZE(bd71828_ramp_delay),
403                         .ramp_reg = BD71828_REG_BUCK6_MODE,
404                         .ramp_mask = BD71828_MASK_RAMP_DELAY,
405                         .owner = THIS_MODULE,
406                         .of_parse_cb = buck_set_hw_dvs_levels,
407                 },
408                 .dvs = {
409                         .level_map = ROHM_DVS_LEVEL_RUN | ROHM_DVS_LEVEL_IDLE |
410                                      ROHM_DVS_LEVEL_SUSPEND |
411                                      ROHM_DVS_LEVEL_LPSR,
412                         .run_reg = BD71828_REG_BUCK6_VOLT,
413                         .run_mask = BD71828_MASK_BUCK1267_VOLT,
414                         .idle_reg = BD71828_REG_BUCK6_IDLE_VOLT,
415                         .idle_mask = BD71828_MASK_BUCK1267_VOLT,
416                         .idle_on_mask = BD71828_MASK_IDLE_EN,
417                         .suspend_reg = BD71828_REG_BUCK6_SUSP_VOLT,
418                         .suspend_mask = BD71828_MASK_BUCK1267_VOLT,
419                         .suspend_on_mask = BD71828_MASK_SUSP_EN,
420                         .lpsr_on_mask = BD71828_MASK_LPSR_EN,
421                         .lpsr_reg = BD71828_REG_BUCK6_SUSP_VOLT,
422                         .lpsr_mask = BD71828_MASK_BUCK1267_VOLT,
423                 },
424                 .reg_inits = buck6_inits,
425                 .reg_init_amnt = ARRAY_SIZE(buck6_inits),
426         },
427         {
428                 .desc = {
429                         .name = "buck7",
430                         .of_match = of_match_ptr("BUCK7"),
431                         .regulators_node = of_match_ptr("regulators"),
432                         .id = BD71828_BUCK7,
433                         .ops = &bd71828_dvs_buck_ops,
434                         .type = REGULATOR_VOLTAGE,
435                         .linear_ranges = bd71828_buck1267_volts,
436                         .n_linear_ranges = ARRAY_SIZE(bd71828_buck1267_volts),
437                         .n_voltages = BD71828_BUCK1267_VOLTS,
438                         .enable_reg = BD71828_REG_BUCK7_EN,
439                         .enable_mask = BD71828_MASK_RUN_EN,
440                         .vsel_reg = BD71828_REG_BUCK7_VOLT,
441                         .vsel_mask = BD71828_MASK_BUCK1267_VOLT,
442                         .ramp_delay_table = bd71828_ramp_delay,
443                         .n_ramp_values = ARRAY_SIZE(bd71828_ramp_delay),
444                         .ramp_reg = BD71828_REG_BUCK7_MODE,
445                         .ramp_mask = BD71828_MASK_RAMP_DELAY,
446                         .owner = THIS_MODULE,
447                         .of_parse_cb = buck_set_hw_dvs_levels,
448                 },
449                 .dvs = {
450                         .level_map = ROHM_DVS_LEVEL_RUN | ROHM_DVS_LEVEL_IDLE |
451                                      ROHM_DVS_LEVEL_SUSPEND |
452                                      ROHM_DVS_LEVEL_LPSR,
453                         .run_reg = BD71828_REG_BUCK7_VOLT,
454                         .run_mask = BD71828_MASK_BUCK1267_VOLT,
455                         .idle_reg = BD71828_REG_BUCK7_IDLE_VOLT,
456                         .idle_mask = BD71828_MASK_BUCK1267_VOLT,
457                         .idle_on_mask = BD71828_MASK_IDLE_EN,
458                         .suspend_reg = BD71828_REG_BUCK7_SUSP_VOLT,
459                         .suspend_mask = BD71828_MASK_BUCK1267_VOLT,
460                         .suspend_on_mask = BD71828_MASK_SUSP_EN,
461                         .lpsr_on_mask = BD71828_MASK_LPSR_EN,
462                         .lpsr_reg = BD71828_REG_BUCK7_SUSP_VOLT,
463                         .lpsr_mask = BD71828_MASK_BUCK1267_VOLT,
464                 },
465                 .reg_inits = buck7_inits,
466                 .reg_init_amnt = ARRAY_SIZE(buck7_inits),
467         },
468         {
469                 .desc = {
470                         .name = "ldo1",
471                         .of_match = of_match_ptr("LDO1"),
472                         .regulators_node = of_match_ptr("regulators"),
473                         .id = BD71828_LDO1,
474                         .ops = &bd71828_ldo_ops,
475                         .type = REGULATOR_VOLTAGE,
476                         .linear_ranges = bd71828_ldo_volts,
477                         .n_linear_ranges = ARRAY_SIZE(bd71828_ldo_volts),
478                         .n_voltages = BD71828_LDO_VOLTS,
479                         .enable_reg = BD71828_REG_LDO1_EN,
480                         .enable_mask = BD71828_MASK_RUN_EN,
481                         .vsel_reg = BD71828_REG_LDO1_VOLT,
482                         .vsel_mask = BD71828_MASK_LDO_VOLT,
483                         .owner = THIS_MODULE,
484                         .of_parse_cb = buck_set_hw_dvs_levels,
485                 },
486                 .dvs = {
487                         /*
488                          * LDO1 only supports single voltage for all states.
489                          * voltage can be individually enabled for each state
490                          * though => allow setting all states to support
491                          * enabling power rail on different states.
492                          */
493                         .level_map = ROHM_DVS_LEVEL_RUN | ROHM_DVS_LEVEL_IDLE |
494                                      ROHM_DVS_LEVEL_SUSPEND |
495                                      ROHM_DVS_LEVEL_LPSR,
496                         .run_reg = BD71828_REG_LDO1_VOLT,
497                         .idle_reg = BD71828_REG_LDO1_VOLT,
498                         .suspend_reg = BD71828_REG_LDO1_VOLT,
499                         .lpsr_reg = BD71828_REG_LDO1_VOLT,
500                         .run_mask = BD71828_MASK_LDO_VOLT,
501                         .idle_mask = BD71828_MASK_LDO_VOLT,
502                         .suspend_mask = BD71828_MASK_LDO_VOLT,
503                         .lpsr_mask = BD71828_MASK_LDO_VOLT,
504                         .idle_on_mask = BD71828_MASK_IDLE_EN,
505                         .suspend_on_mask = BD71828_MASK_SUSP_EN,
506                         .lpsr_on_mask = BD71828_MASK_LPSR_EN,
507                 },
508         }, {
509                 .desc = {
510                         .name = "ldo2",
511                         .of_match = of_match_ptr("LDO2"),
512                         .regulators_node = of_match_ptr("regulators"),
513                         .id = BD71828_LDO2,
514                         .ops = &bd71828_ldo_ops,
515                         .type = REGULATOR_VOLTAGE,
516                         .linear_ranges = bd71828_ldo_volts,
517                         .n_linear_ranges = ARRAY_SIZE(bd71828_ldo_volts),
518                         .n_voltages = BD71828_LDO_VOLTS,
519                         .enable_reg = BD71828_REG_LDO2_EN,
520                         .enable_mask = BD71828_MASK_RUN_EN,
521                         .vsel_reg = BD71828_REG_LDO2_VOLT,
522                         .vsel_mask = BD71828_MASK_LDO_VOLT,
523                         .owner = THIS_MODULE,
524                         .of_parse_cb = buck_set_hw_dvs_levels,
525                 },
526                 .dvs = {
527                         /*
528                          * LDO2 only supports single voltage for all states.
529                          * voltage can be individually enabled for each state
530                          * though => allow setting all states to support
531                          * enabling power rail on different states.
532                          */
533                         .level_map = ROHM_DVS_LEVEL_RUN | ROHM_DVS_LEVEL_IDLE |
534                                      ROHM_DVS_LEVEL_SUSPEND |
535                                      ROHM_DVS_LEVEL_LPSR,
536                         .run_reg = BD71828_REG_LDO2_VOLT,
537                         .idle_reg = BD71828_REG_LDO2_VOLT,
538                         .suspend_reg = BD71828_REG_LDO2_VOLT,
539                         .lpsr_reg = BD71828_REG_LDO2_VOLT,
540                         .run_mask = BD71828_MASK_LDO_VOLT,
541                         .idle_mask = BD71828_MASK_LDO_VOLT,
542                         .suspend_mask = BD71828_MASK_LDO_VOLT,
543                         .lpsr_mask = BD71828_MASK_LDO_VOLT,
544                         .idle_on_mask = BD71828_MASK_IDLE_EN,
545                         .suspend_on_mask = BD71828_MASK_SUSP_EN,
546                         .lpsr_on_mask = BD71828_MASK_LPSR_EN,
547                 },
548         }, {
549                 .desc = {
550                         .name = "ldo3",
551                         .of_match = of_match_ptr("LDO3"),
552                         .regulators_node = of_match_ptr("regulators"),
553                         .id = BD71828_LDO3,
554                         .ops = &bd71828_ldo_ops,
555                         .type = REGULATOR_VOLTAGE,
556                         .linear_ranges = bd71828_ldo_volts,
557                         .n_linear_ranges = ARRAY_SIZE(bd71828_ldo_volts),
558                         .n_voltages = BD71828_LDO_VOLTS,
559                         .enable_reg = BD71828_REG_LDO3_EN,
560                         .enable_mask = BD71828_MASK_RUN_EN,
561                         .vsel_reg = BD71828_REG_LDO3_VOLT,
562                         .vsel_mask = BD71828_MASK_LDO_VOLT,
563                         .owner = THIS_MODULE,
564                         .of_parse_cb = buck_set_hw_dvs_levels,
565                 },
566                 .dvs = {
567                         /*
568                          * LDO3 only supports single voltage for all states.
569                          * voltage can be individually enabled for each state
570                          * though => allow setting all states to support
571                          * enabling power rail on different states.
572                          */
573                         .level_map = ROHM_DVS_LEVEL_RUN | ROHM_DVS_LEVEL_IDLE |
574                                      ROHM_DVS_LEVEL_SUSPEND |
575                                      ROHM_DVS_LEVEL_LPSR,
576                         .run_reg = BD71828_REG_LDO3_VOLT,
577                         .idle_reg = BD71828_REG_LDO3_VOLT,
578                         .suspend_reg = BD71828_REG_LDO3_VOLT,
579                         .lpsr_reg = BD71828_REG_LDO3_VOLT,
580                         .run_mask = BD71828_MASK_LDO_VOLT,
581                         .idle_mask = BD71828_MASK_LDO_VOLT,
582                         .suspend_mask = BD71828_MASK_LDO_VOLT,
583                         .lpsr_mask = BD71828_MASK_LDO_VOLT,
584                         .idle_on_mask = BD71828_MASK_IDLE_EN,
585                         .suspend_on_mask = BD71828_MASK_SUSP_EN,
586                         .lpsr_on_mask = BD71828_MASK_LPSR_EN,
587                 },
588
589         }, {
590                 .desc = {
591                         .name = "ldo4",
592                         .of_match = of_match_ptr("LDO4"),
593                         .regulators_node = of_match_ptr("regulators"),
594                         .id = BD71828_LDO4,
595                         .ops = &bd71828_ldo_ops,
596                         .type = REGULATOR_VOLTAGE,
597                         .linear_ranges = bd71828_ldo_volts,
598                         .n_linear_ranges = ARRAY_SIZE(bd71828_ldo_volts),
599                         .n_voltages = BD71828_LDO_VOLTS,
600                         .enable_reg = BD71828_REG_LDO4_EN,
601                         .enable_mask = BD71828_MASK_RUN_EN,
602                         .vsel_reg = BD71828_REG_LDO4_VOLT,
603                         .vsel_mask = BD71828_MASK_LDO_VOLT,
604                         .owner = THIS_MODULE,
605                         .of_parse_cb = buck_set_hw_dvs_levels,
606                 },
607                 .dvs = {
608                         /*
609                          * LDO1 only supports single voltage for all states.
610                          * voltage can be individually enabled for each state
611                          * though => allow setting all states to support
612                          * enabling power rail on different states.
613                          */
614                         .level_map = ROHM_DVS_LEVEL_RUN | ROHM_DVS_LEVEL_IDLE |
615                                      ROHM_DVS_LEVEL_SUSPEND |
616                                      ROHM_DVS_LEVEL_LPSR,
617                         .run_reg = BD71828_REG_LDO4_VOLT,
618                         .idle_reg = BD71828_REG_LDO4_VOLT,
619                         .suspend_reg = BD71828_REG_LDO4_VOLT,
620                         .lpsr_reg = BD71828_REG_LDO4_VOLT,
621                         .run_mask = BD71828_MASK_LDO_VOLT,
622                         .idle_mask = BD71828_MASK_LDO_VOLT,
623                         .suspend_mask = BD71828_MASK_LDO_VOLT,
624                         .lpsr_mask = BD71828_MASK_LDO_VOLT,
625                         .idle_on_mask = BD71828_MASK_IDLE_EN,
626                         .suspend_on_mask = BD71828_MASK_SUSP_EN,
627                         .lpsr_on_mask = BD71828_MASK_LPSR_EN,
628                 },
629         }, {
630                 .desc = {
631                         .name = "ldo5",
632                         .of_match = of_match_ptr("LDO5"),
633                         .regulators_node = of_match_ptr("regulators"),
634                         .id = BD71828_LDO5,
635                         .ops = &bd71828_ldo_ops,
636                         .type = REGULATOR_VOLTAGE,
637                         .linear_ranges = bd71828_ldo_volts,
638                         .n_linear_ranges = ARRAY_SIZE(bd71828_ldo_volts),
639                         .n_voltages = BD71828_LDO_VOLTS,
640                         .enable_reg = BD71828_REG_LDO5_EN,
641                         .enable_mask = BD71828_MASK_RUN_EN,
642                         .vsel_reg = BD71828_REG_LDO5_VOLT,
643                         .vsel_mask = BD71828_MASK_LDO_VOLT,
644                         .of_parse_cb = buck_set_hw_dvs_levels,
645                         .owner = THIS_MODULE,
646                 },
647                 /*
648                  * LDO5 is special. It can choose vsel settings to be configured
649                  * from 2 different registers (by GPIO).
650                  *
651                  * This driver supports only configuration where
652                  * BD71828_REG_LDO5_VOLT_L is used.
653                  */
654                 .dvs = {
655                         .level_map = ROHM_DVS_LEVEL_RUN | ROHM_DVS_LEVEL_IDLE |
656                                      ROHM_DVS_LEVEL_SUSPEND |
657                                      ROHM_DVS_LEVEL_LPSR,
658                         .run_reg = BD71828_REG_LDO5_VOLT,
659                         .idle_reg = BD71828_REG_LDO5_VOLT,
660                         .suspend_reg = BD71828_REG_LDO5_VOLT,
661                         .lpsr_reg = BD71828_REG_LDO5_VOLT,
662                         .run_mask = BD71828_MASK_LDO_VOLT,
663                         .idle_mask = BD71828_MASK_LDO_VOLT,
664                         .suspend_mask = BD71828_MASK_LDO_VOLT,
665                         .lpsr_mask = BD71828_MASK_LDO_VOLT,
666                         .idle_on_mask = BD71828_MASK_IDLE_EN,
667                         .suspend_on_mask = BD71828_MASK_SUSP_EN,
668                         .lpsr_on_mask = BD71828_MASK_LPSR_EN,
669                 },
670
671         }, {
672                 .desc = {
673                         .name = "ldo6",
674                         .of_match = of_match_ptr("LDO6"),
675                         .regulators_node = of_match_ptr("regulators"),
676                         .id = BD71828_LDO6,
677                         .ops = &bd71828_ldo6_ops,
678                         .type = REGULATOR_VOLTAGE,
679                         .fixed_uV = BD71828_LDO_6_VOLTAGE,
680                         .n_voltages = 1,
681                         .enable_reg = BD71828_REG_LDO6_EN,
682                         .enable_mask = BD71828_MASK_RUN_EN,
683                         .owner = THIS_MODULE,
684                         /*
685                          * LDO6 only supports enable/disable for all states.
686                          * Voltage for LDO6 is fixed.
687                          */
688                         .of_parse_cb = ldo6_parse_dt,
689                 },
690         }, {
691                 .desc = {
692                         /* SNVS LDO in data-sheet */
693                         .name = "ldo7",
694                         .of_match = of_match_ptr("LDO7"),
695                         .regulators_node = of_match_ptr("regulators"),
696                         .id = BD71828_LDO_SNVS,
697                         .ops = &bd71828_ldo_ops,
698                         .type = REGULATOR_VOLTAGE,
699                         .linear_ranges = bd71828_ldo_volts,
700                         .n_linear_ranges = ARRAY_SIZE(bd71828_ldo_volts),
701                         .n_voltages = BD71828_LDO_VOLTS,
702                         .enable_reg = BD71828_REG_LDO7_EN,
703                         .enable_mask = BD71828_MASK_RUN_EN,
704                         .vsel_reg = BD71828_REG_LDO7_VOLT,
705                         .vsel_mask = BD71828_MASK_LDO_VOLT,
706                         .owner = THIS_MODULE,
707                         .of_parse_cb = buck_set_hw_dvs_levels,
708                 },
709                 .dvs = {
710                         /*
711                          * LDO7 only supports single voltage for all states.
712                          * voltage can be individually enabled for each state
713                          * though => allow setting all states to support
714                          * enabling power rail on different states.
715                          */
716                         .level_map = ROHM_DVS_LEVEL_RUN | ROHM_DVS_LEVEL_IDLE |
717                                      ROHM_DVS_LEVEL_SUSPEND |
718                                      ROHM_DVS_LEVEL_LPSR,
719                         .run_reg = BD71828_REG_LDO7_VOLT,
720                         .idle_reg = BD71828_REG_LDO7_VOLT,
721                         .suspend_reg = BD71828_REG_LDO7_VOLT,
722                         .lpsr_reg = BD71828_REG_LDO7_VOLT,
723                         .run_mask = BD71828_MASK_LDO_VOLT,
724                         .idle_mask = BD71828_MASK_LDO_VOLT,
725                         .suspend_mask = BD71828_MASK_LDO_VOLT,
726                         .lpsr_mask = BD71828_MASK_LDO_VOLT,
727                         .idle_on_mask = BD71828_MASK_IDLE_EN,
728                         .suspend_on_mask = BD71828_MASK_SUSP_EN,
729                         .lpsr_on_mask = BD71828_MASK_LPSR_EN,
730                 },
731
732         },
733 };
734
735 static int bd71828_probe(struct platform_device *pdev)
736 {
737         int i, j, ret;
738         struct regulator_config config = {
739                 .dev = pdev->dev.parent,
740         };
741
742         config.regmap = dev_get_regmap(pdev->dev.parent, NULL);
743         if (!config.regmap)
744                 return -ENODEV;
745
746         for (i = 0; i < ARRAY_SIZE(bd71828_rdata); i++) {
747                 struct regulator_dev *rdev;
748                 const struct bd71828_regulator_data *rd;
749
750                 rd = &bd71828_rdata[i];
751                 rdev = devm_regulator_register(&pdev->dev,
752                                                &rd->desc, &config);
753                 if (IS_ERR(rdev)) {
754                         dev_err(&pdev->dev,
755                                 "failed to register %s regulator\n",
756                                 rd->desc.name);
757                         return PTR_ERR(rdev);
758                 }
759                 for (j = 0; j < rd->reg_init_amnt; j++) {
760                         ret = regmap_update_bits(config.regmap,
761                                                  rd->reg_inits[j].reg,
762                                                  rd->reg_inits[j].mask,
763                                                  rd->reg_inits[j].val);
764                         if (ret) {
765                                 dev_err(&pdev->dev,
766                                         "regulator %s init failed\n",
767                                         rd->desc.name);
768                                 return ret;
769                         }
770                 }
771         }
772         return 0;
773 }
774
775 static struct platform_driver bd71828_regulator = {
776         .driver = {
777                 .name = "bd71828-pmic"
778         },
779         .probe = bd71828_probe,
780 };
781
782 module_platform_driver(bd71828_regulator);
783
784 MODULE_AUTHOR("Matti Vaittinen <matti.vaittinen@fi.rohmeurope.com>");
785 MODULE_DESCRIPTION("BD71828 voltage regulator driver");
786 MODULE_LICENSE("GPL");
787 MODULE_ALIAS("platform:bd71828-pmic");