Input: i8042 - add Acer Aspire 5738z to nomux list
[linux-2.6-microblaze.git] / drivers / regulator / vctrl-regulator.c
1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3  * Driver for voltage controller regulators
4  *
5  * Copyright (C) 2017 Google, Inc.
6  */
7
8 #include <linux/delay.h>
9 #include <linux/err.h>
10 #include <linux/init.h>
11 #include <linux/module.h>
12 #include <linux/of.h>
13 #include <linux/of_device.h>
14 #include <linux/regulator/driver.h>
15 #include <linux/regulator/of_regulator.h>
16 #include <linux/sort.h>
17
18 struct vctrl_voltage_range {
19         int min_uV;
20         int max_uV;
21 };
22
23 struct vctrl_voltage_ranges {
24         struct vctrl_voltage_range ctrl;
25         struct vctrl_voltage_range out;
26 };
27
28 struct vctrl_voltage_table {
29         int ctrl;
30         int out;
31         int ovp_min_sel;
32 };
33
34 struct vctrl_data {
35         struct regulator_dev *rdev;
36         struct regulator_desc desc;
37         struct regulator *ctrl_reg;
38         bool enabled;
39         unsigned int min_slew_down_rate;
40         unsigned int ovp_threshold;
41         struct vctrl_voltage_ranges vrange;
42         struct vctrl_voltage_table *vtable;
43         unsigned int sel;
44 };
45
46 static int vctrl_calc_ctrl_voltage(struct vctrl_data *vctrl, int out_uV)
47 {
48         struct vctrl_voltage_range *ctrl = &vctrl->vrange.ctrl;
49         struct vctrl_voltage_range *out = &vctrl->vrange.out;
50
51         return ctrl->min_uV +
52                 DIV_ROUND_CLOSEST_ULL((s64)(out_uV - out->min_uV) *
53                                       (ctrl->max_uV - ctrl->min_uV),
54                                       out->max_uV - out->min_uV);
55 }
56
57 static int vctrl_calc_output_voltage(struct vctrl_data *vctrl, int ctrl_uV)
58 {
59         struct vctrl_voltage_range *ctrl = &vctrl->vrange.ctrl;
60         struct vctrl_voltage_range *out = &vctrl->vrange.out;
61
62         if (ctrl_uV < 0) {
63                 pr_err("vctrl: failed to get control voltage\n");
64                 return ctrl_uV;
65         }
66
67         if (ctrl_uV < ctrl->min_uV)
68                 return out->min_uV;
69
70         if (ctrl_uV > ctrl->max_uV)
71                 return out->max_uV;
72
73         return out->min_uV +
74                 DIV_ROUND_CLOSEST_ULL((s64)(ctrl_uV - ctrl->min_uV) *
75                                       (out->max_uV - out->min_uV),
76                                       ctrl->max_uV - ctrl->min_uV);
77 }
78
79 static int vctrl_get_voltage(struct regulator_dev *rdev)
80 {
81         struct vctrl_data *vctrl = rdev_get_drvdata(rdev);
82         int ctrl_uV = regulator_get_voltage(vctrl->ctrl_reg);
83
84         return vctrl_calc_output_voltage(vctrl, ctrl_uV);
85 }
86
87 static int vctrl_set_voltage(struct regulator_dev *rdev,
88                              int req_min_uV, int req_max_uV,
89                              unsigned int *selector)
90 {
91         struct vctrl_data *vctrl = rdev_get_drvdata(rdev);
92         struct regulator *ctrl_reg = vctrl->ctrl_reg;
93         int orig_ctrl_uV = regulator_get_voltage(ctrl_reg);
94         int uV = vctrl_calc_output_voltage(vctrl, orig_ctrl_uV);
95         int ret;
96
97         if (req_min_uV >= uV || !vctrl->ovp_threshold)
98                 /* voltage rising or no OVP */
99                 return regulator_set_voltage(
100                         ctrl_reg,
101                         vctrl_calc_ctrl_voltage(vctrl, req_min_uV),
102                         vctrl_calc_ctrl_voltage(vctrl, req_max_uV));
103
104         while (uV > req_min_uV) {
105                 int max_drop_uV = (uV * vctrl->ovp_threshold) / 100;
106                 int next_uV;
107                 int next_ctrl_uV;
108                 int delay;
109
110                 /* Make sure no infinite loop even in crazy cases */
111                 if (max_drop_uV == 0)
112                         max_drop_uV = 1;
113
114                 next_uV = max_t(int, req_min_uV, uV - max_drop_uV);
115                 next_ctrl_uV = vctrl_calc_ctrl_voltage(vctrl, next_uV);
116
117                 ret = regulator_set_voltage(ctrl_reg,
118                                             next_ctrl_uV,
119                                             next_ctrl_uV);
120                 if (ret)
121                         goto err;
122
123                 delay = DIV_ROUND_UP(uV - next_uV, vctrl->min_slew_down_rate);
124                 usleep_range(delay, delay + DIV_ROUND_UP(delay, 10));
125
126                 uV = next_uV;
127         }
128
129         return 0;
130
131 err:
132         /* Try to go back to original voltage */
133         regulator_set_voltage(ctrl_reg, orig_ctrl_uV, orig_ctrl_uV);
134
135         return ret;
136 }
137
138 static int vctrl_get_voltage_sel(struct regulator_dev *rdev)
139 {
140         struct vctrl_data *vctrl = rdev_get_drvdata(rdev);
141
142         return vctrl->sel;
143 }
144
145 static int vctrl_set_voltage_sel(struct regulator_dev *rdev,
146                                  unsigned int selector)
147 {
148         struct vctrl_data *vctrl = rdev_get_drvdata(rdev);
149         struct regulator *ctrl_reg = vctrl->ctrl_reg;
150         unsigned int orig_sel = vctrl->sel;
151         int ret;
152
153         if (selector >= rdev->desc->n_voltages)
154                 return -EINVAL;
155
156         if (selector >= vctrl->sel || !vctrl->ovp_threshold) {
157                 /* voltage rising or no OVP */
158                 ret = regulator_set_voltage(ctrl_reg,
159                                             vctrl->vtable[selector].ctrl,
160                                             vctrl->vtable[selector].ctrl);
161                 if (!ret)
162                         vctrl->sel = selector;
163
164                 return ret;
165         }
166
167         while (vctrl->sel != selector) {
168                 unsigned int next_sel;
169                 int delay;
170
171                 if (selector >= vctrl->vtable[vctrl->sel].ovp_min_sel)
172                         next_sel = selector;
173                 else
174                         next_sel = vctrl->vtable[vctrl->sel].ovp_min_sel;
175
176                 ret = regulator_set_voltage(ctrl_reg,
177                                             vctrl->vtable[next_sel].ctrl,
178                                             vctrl->vtable[next_sel].ctrl);
179                 if (ret) {
180                         dev_err(&rdev->dev,
181                                 "failed to set control voltage to %duV\n",
182                                 vctrl->vtable[next_sel].ctrl);
183                         goto err;
184                 }
185                 vctrl->sel = next_sel;
186
187                 delay = DIV_ROUND_UP(vctrl->vtable[vctrl->sel].out -
188                                      vctrl->vtable[next_sel].out,
189                                      vctrl->min_slew_down_rate);
190                 usleep_range(delay, delay + DIV_ROUND_UP(delay, 10));
191         }
192
193         return 0;
194
195 err:
196         if (vctrl->sel != orig_sel) {
197                 /* Try to go back to original voltage */
198                 if (!regulator_set_voltage(ctrl_reg,
199                                            vctrl->vtable[orig_sel].ctrl,
200                                            vctrl->vtable[orig_sel].ctrl))
201                         vctrl->sel = orig_sel;
202                 else
203                         dev_warn(&rdev->dev,
204                                  "failed to restore original voltage\n");
205         }
206
207         return ret;
208 }
209
210 static int vctrl_list_voltage(struct regulator_dev *rdev,
211                               unsigned int selector)
212 {
213         struct vctrl_data *vctrl = rdev_get_drvdata(rdev);
214
215         if (selector >= rdev->desc->n_voltages)
216                 return -EINVAL;
217
218         return vctrl->vtable[selector].out;
219 }
220
221 static int vctrl_parse_dt(struct platform_device *pdev,
222                           struct vctrl_data *vctrl)
223 {
224         int ret;
225         struct device_node *np = pdev->dev.of_node;
226         u32 pval;
227         u32 vrange_ctrl[2];
228
229         vctrl->ctrl_reg = devm_regulator_get(&pdev->dev, "ctrl");
230         if (IS_ERR(vctrl->ctrl_reg))
231                 return PTR_ERR(vctrl->ctrl_reg);
232
233         ret = of_property_read_u32(np, "ovp-threshold-percent", &pval);
234         if (!ret) {
235                 vctrl->ovp_threshold = pval;
236                 if (vctrl->ovp_threshold > 100) {
237                         dev_err(&pdev->dev,
238                                 "ovp-threshold-percent (%u) > 100\n",
239                                 vctrl->ovp_threshold);
240                         return -EINVAL;
241                 }
242         }
243
244         ret = of_property_read_u32(np, "min-slew-down-rate", &pval);
245         if (!ret) {
246                 vctrl->min_slew_down_rate = pval;
247
248                 /* We use the value as int and as divider; sanity check */
249                 if (vctrl->min_slew_down_rate == 0) {
250                         dev_err(&pdev->dev,
251                                 "min-slew-down-rate must not be 0\n");
252                         return -EINVAL;
253                 } else if (vctrl->min_slew_down_rate > INT_MAX) {
254                         dev_err(&pdev->dev, "min-slew-down-rate (%u) too big\n",
255                                 vctrl->min_slew_down_rate);
256                         return -EINVAL;
257                 }
258         }
259
260         if (vctrl->ovp_threshold && !vctrl->min_slew_down_rate) {
261                 dev_err(&pdev->dev,
262                         "ovp-threshold-percent requires min-slew-down-rate\n");
263                 return -EINVAL;
264         }
265
266         ret = of_property_read_u32(np, "regulator-min-microvolt", &pval);
267         if (ret) {
268                 dev_err(&pdev->dev,
269                         "failed to read regulator-min-microvolt: %d\n", ret);
270                 return ret;
271         }
272         vctrl->vrange.out.min_uV = pval;
273
274         ret = of_property_read_u32(np, "regulator-max-microvolt", &pval);
275         if (ret) {
276                 dev_err(&pdev->dev,
277                         "failed to read regulator-max-microvolt: %d\n", ret);
278                 return ret;
279         }
280         vctrl->vrange.out.max_uV = pval;
281
282         ret = of_property_read_u32_array(np, "ctrl-voltage-range", vrange_ctrl,
283                                          2);
284         if (ret) {
285                 dev_err(&pdev->dev, "failed to read ctrl-voltage-range: %d\n",
286                         ret);
287                 return ret;
288         }
289
290         if (vrange_ctrl[0] >= vrange_ctrl[1]) {
291                 dev_err(&pdev->dev, "ctrl-voltage-range is invalid: %d-%d\n",
292                         vrange_ctrl[0], vrange_ctrl[1]);
293                 return -EINVAL;
294         }
295
296         vctrl->vrange.ctrl.min_uV = vrange_ctrl[0];
297         vctrl->vrange.ctrl.max_uV = vrange_ctrl[1];
298
299         return 0;
300 }
301
302 static int vctrl_cmp_ctrl_uV(const void *a, const void *b)
303 {
304         const struct vctrl_voltage_table *at = a;
305         const struct vctrl_voltage_table *bt = b;
306
307         return at->ctrl - bt->ctrl;
308 }
309
310 static int vctrl_init_vtable(struct platform_device *pdev)
311 {
312         struct vctrl_data *vctrl = platform_get_drvdata(pdev);
313         struct regulator_desc *rdesc = &vctrl->desc;
314         struct regulator *ctrl_reg = vctrl->ctrl_reg;
315         struct vctrl_voltage_range *vrange_ctrl = &vctrl->vrange.ctrl;
316         int n_voltages;
317         int ctrl_uV;
318         int i, idx_vt;
319
320         n_voltages = regulator_count_voltages(ctrl_reg);
321
322         rdesc->n_voltages = n_voltages;
323
324         /* determine number of steps within the range of the vctrl regulator */
325         for (i = 0; i < n_voltages; i++) {
326                 ctrl_uV = regulator_list_voltage(ctrl_reg, i);
327
328                 if (ctrl_uV < vrange_ctrl->min_uV ||
329                     ctrl_uV > vrange_ctrl->max_uV)
330                         rdesc->n_voltages--;
331         }
332
333         if (rdesc->n_voltages == 0) {
334                 dev_err(&pdev->dev, "invalid configuration\n");
335                 return -EINVAL;
336         }
337
338         vctrl->vtable = devm_kcalloc(&pdev->dev, rdesc->n_voltages,
339                                      sizeof(struct vctrl_voltage_table),
340                                      GFP_KERNEL);
341         if (!vctrl->vtable)
342                 return -ENOMEM;
343
344         /* create mapping control <=> output voltage */
345         for (i = 0, idx_vt = 0; i < n_voltages; i++) {
346                 ctrl_uV = regulator_list_voltage(ctrl_reg, i);
347
348                 if (ctrl_uV < vrange_ctrl->min_uV ||
349                     ctrl_uV > vrange_ctrl->max_uV)
350                         continue;
351
352                 vctrl->vtable[idx_vt].ctrl = ctrl_uV;
353                 vctrl->vtable[idx_vt].out =
354                         vctrl_calc_output_voltage(vctrl, ctrl_uV);
355                 idx_vt++;
356         }
357
358         /* we rely on the table to be ordered by ascending voltage */
359         sort(vctrl->vtable, rdesc->n_voltages,
360              sizeof(struct vctrl_voltage_table), vctrl_cmp_ctrl_uV,
361              NULL);
362
363         /* pre-calculate OVP-safe downward transitions */
364         for (i = rdesc->n_voltages - 1; i > 0; i--) {
365                 int j;
366                 int ovp_min_uV = (vctrl->vtable[i].out *
367                                   (100 - vctrl->ovp_threshold)) / 100;
368
369                 for (j = 0; j < i; j++) {
370                         if (vctrl->vtable[j].out >= ovp_min_uV) {
371                                 vctrl->vtable[i].ovp_min_sel = j;
372                                 break;
373                         }
374                 }
375
376                 if (j == i) {
377                         dev_warn(&pdev->dev, "switching down from %duV may cause OVP shutdown\n",
378                                 vctrl->vtable[i].out);
379                         /* use next lowest voltage */
380                         vctrl->vtable[i].ovp_min_sel = i - 1;
381                 }
382         }
383
384         return 0;
385 }
386
387 static int vctrl_enable(struct regulator_dev *rdev)
388 {
389         struct vctrl_data *vctrl = rdev_get_drvdata(rdev);
390         int ret = regulator_enable(vctrl->ctrl_reg);
391
392         if (!ret)
393                 vctrl->enabled = true;
394
395         return ret;
396 }
397
398 static int vctrl_disable(struct regulator_dev *rdev)
399 {
400         struct vctrl_data *vctrl = rdev_get_drvdata(rdev);
401         int ret = regulator_disable(vctrl->ctrl_reg);
402
403         if (!ret)
404                 vctrl->enabled = false;
405
406         return ret;
407 }
408
409 static int vctrl_is_enabled(struct regulator_dev *rdev)
410 {
411         struct vctrl_data *vctrl = rdev_get_drvdata(rdev);
412
413         return vctrl->enabled;
414 }
415
416 static const struct regulator_ops vctrl_ops_cont = {
417         .enable           = vctrl_enable,
418         .disable          = vctrl_disable,
419         .is_enabled       = vctrl_is_enabled,
420         .get_voltage      = vctrl_get_voltage,
421         .set_voltage      = vctrl_set_voltage,
422 };
423
424 static const struct regulator_ops vctrl_ops_non_cont = {
425         .enable           = vctrl_enable,
426         .disable          = vctrl_disable,
427         .is_enabled       = vctrl_is_enabled,
428         .set_voltage_sel = vctrl_set_voltage_sel,
429         .get_voltage_sel = vctrl_get_voltage_sel,
430         .list_voltage    = vctrl_list_voltage,
431         .map_voltage     = regulator_map_voltage_iterate,
432 };
433
434 static int vctrl_probe(struct platform_device *pdev)
435 {
436         struct device_node *np = pdev->dev.of_node;
437         struct vctrl_data *vctrl;
438         const struct regulator_init_data *init_data;
439         struct regulator_desc *rdesc;
440         struct regulator_config cfg = { };
441         struct vctrl_voltage_range *vrange_ctrl;
442         int ctrl_uV;
443         int ret;
444
445         vctrl = devm_kzalloc(&pdev->dev, sizeof(struct vctrl_data),
446                              GFP_KERNEL);
447         if (!vctrl)
448                 return -ENOMEM;
449
450         platform_set_drvdata(pdev, vctrl);
451
452         ret = vctrl_parse_dt(pdev, vctrl);
453         if (ret)
454                 return ret;
455
456         vrange_ctrl = &vctrl->vrange.ctrl;
457
458         rdesc = &vctrl->desc;
459         rdesc->name = "vctrl";
460         rdesc->type = REGULATOR_VOLTAGE;
461         rdesc->owner = THIS_MODULE;
462
463         if ((regulator_get_linear_step(vctrl->ctrl_reg) == 1) ||
464             (regulator_count_voltages(vctrl->ctrl_reg) == -EINVAL)) {
465                 rdesc->continuous_voltage_range = true;
466                 rdesc->ops = &vctrl_ops_cont;
467         } else {
468                 rdesc->ops = &vctrl_ops_non_cont;
469         }
470
471         init_data = of_get_regulator_init_data(&pdev->dev, np, rdesc);
472         if (!init_data)
473                 return -ENOMEM;
474
475         cfg.of_node = np;
476         cfg.dev = &pdev->dev;
477         cfg.driver_data = vctrl;
478         cfg.init_data = init_data;
479
480         if (!rdesc->continuous_voltage_range) {
481                 ret = vctrl_init_vtable(pdev);
482                 if (ret)
483                         return ret;
484
485                 ctrl_uV = regulator_get_voltage(vctrl->ctrl_reg);
486                 if (ctrl_uV < 0) {
487                         dev_err(&pdev->dev, "failed to get control voltage\n");
488                         return ctrl_uV;
489                 }
490
491                 /* determine current voltage selector from control voltage */
492                 if (ctrl_uV < vrange_ctrl->min_uV) {
493                         vctrl->sel = 0;
494                 } else if (ctrl_uV > vrange_ctrl->max_uV) {
495                         vctrl->sel = rdesc->n_voltages - 1;
496                 } else {
497                         int i;
498
499                         for (i = 0; i < rdesc->n_voltages; i++) {
500                                 if (ctrl_uV == vctrl->vtable[i].ctrl) {
501                                         vctrl->sel = i;
502                                         break;
503                                 }
504                         }
505                 }
506         }
507
508         vctrl->rdev = devm_regulator_register(&pdev->dev, rdesc, &cfg);
509         if (IS_ERR(vctrl->rdev)) {
510                 ret = PTR_ERR(vctrl->rdev);
511                 dev_err(&pdev->dev, "failed to register regulator: %d\n", ret);
512                 return ret;
513         }
514
515         return 0;
516 }
517
518 static const struct of_device_id vctrl_of_match[] = {
519         { .compatible = "vctrl-regulator", },
520         {},
521 };
522 MODULE_DEVICE_TABLE(of, vctrl_of_match);
523
524 static struct platform_driver vctrl_driver = {
525         .probe          = vctrl_probe,
526         .driver         = {
527                 .name           = "vctrl-regulator",
528                 .of_match_table = of_match_ptr(vctrl_of_match),
529         },
530 };
531
532 module_platform_driver(vctrl_driver);
533
534 MODULE_DESCRIPTION("Voltage Controlled Regulator Driver");
535 MODULE_AUTHOR("Matthias Kaehlcke <mka@chromium.org>");
536 MODULE_LICENSE("GPL v2");