]>
Commit | Line | Data |
---|---|---|
1a016956 KY |
1 | /* |
2 | * Copyright (C) 2016 Rockchip Electronics Co., Ltd | |
3 | * | |
4 | * Based on kernel drivers/regulator/pwm-regulator.c | |
5 | * Copyright (C) 2014 - STMicroelectronics Inc. | |
6 | * Author: Lee Jones <lee.jones@linaro.org> | |
7 | * | |
8 | * SPDX-License-Identifier: GPL-2.0+ | |
9 | */ | |
10 | ||
11 | #include <common.h> | |
12 | #include <dm.h> | |
13 | #include <errno.h> | |
14 | #include <pwm.h> | |
15 | #include <power/regulator.h> | |
16 | #include <libfdt.h> | |
17 | #include <fdt_support.h> | |
18 | #include <fdtdec.h> | |
19 | ||
20 | DECLARE_GLOBAL_DATA_PTR; | |
21 | ||
22 | struct pwm_regulator_info { | |
23 | /* pwm id corresponding to the PWM driver */ | |
24 | int pwm_id; | |
25 | /* the period of one PWM cycle */ | |
26 | int period_ns; | |
0b60111a KY |
27 | /* |
28 | * the polarity of one PWM | |
29 | * 0: normal polarity | |
30 | * 1: inverted polarity | |
31 | */ | |
32 | bool polarity; | |
1a016956 KY |
33 | struct udevice *pwm; |
34 | /* initialize voltage of regulator */ | |
c40d48bb | 35 | int init_voltage; |
1a016956 | 36 | /* the maximum voltage of regulator */ |
c40d48bb | 37 | int max_voltage; |
1a016956 | 38 | /* the minimum voltage of regulator */ |
c40d48bb | 39 | int min_voltage; |
1a016956 | 40 | /* the current voltage of regulator */ |
c40d48bb | 41 | int volt_uV; |
1a016956 KY |
42 | }; |
43 | ||
44 | static int pwm_regulator_enable(struct udevice *dev, bool enable) | |
45 | { | |
46 | struct pwm_regulator_info *priv = dev_get_priv(dev); | |
47 | ||
48 | return pwm_set_enable(priv->pwm, priv->pwm_id, enable); | |
49 | } | |
50 | ||
51 | static int pwm_voltage_to_duty_cycle_percentage(struct udevice *dev, int req_uV) | |
52 | { | |
53 | struct pwm_regulator_info *priv = dev_get_priv(dev); | |
54 | int min_uV = priv->min_voltage; | |
55 | int max_uV = priv->max_voltage; | |
56 | int diff = max_uV - min_uV; | |
57 | ||
0b60111a | 58 | return ((req_uV * 100) - (min_uV * 100)) / diff; |
1a016956 KY |
59 | } |
60 | ||
61 | static int pwm_regulator_get_voltage(struct udevice *dev) | |
62 | { | |
63 | struct pwm_regulator_info *priv = dev_get_priv(dev); | |
64 | ||
65 | return priv->volt_uV; | |
66 | } | |
67 | ||
68 | static int pwm_regulator_set_voltage(struct udevice *dev, int uvolt) | |
69 | { | |
70 | struct pwm_regulator_info *priv = dev_get_priv(dev); | |
71 | int duty_cycle; | |
72 | int ret = 0; | |
73 | ||
74 | duty_cycle = pwm_voltage_to_duty_cycle_percentage(dev, uvolt); | |
75 | ||
0b60111a KY |
76 | ret = pwm_set_invert(priv->pwm, priv->pwm_id, priv->polarity); |
77 | if (ret) { | |
78 | dev_err(dev, "Failed to init PWM\n"); | |
79 | return ret; | |
80 | } | |
81 | ||
1a016956 | 82 | ret = pwm_set_config(priv->pwm, priv->pwm_id, |
f339bca2 | 83 | priv->period_ns, (priv->period_ns / 100) * duty_cycle); |
1a016956 KY |
84 | if (ret) { |
85 | dev_err(dev, "Failed to configure PWM\n"); | |
86 | return ret; | |
87 | } | |
88 | ||
1a016956 | 89 | priv->volt_uV = uvolt; |
3030c951 | 90 | |
1a016956 KY |
91 | return ret; |
92 | } | |
93 | ||
94 | static int pwm_regulator_ofdata_to_platdata(struct udevice *dev) | |
95 | { | |
96 | struct pwm_regulator_info *priv = dev_get_priv(dev); | |
97 | struct fdtdec_phandle_args args; | |
98 | const void *blob = gd->fdt_blob; | |
e160f7d4 | 99 | int node = dev_of_offset(dev); |
1a016956 KY |
100 | int ret; |
101 | ||
102 | ret = fdtdec_parse_phandle_with_args(blob, node, "pwms", "#pwm-cells", | |
103 | 0, 0, &args); | |
104 | if (ret) { | |
105 | debug("%s: Cannot get PWM phandle: ret=%d\n", __func__, ret); | |
106 | return ret; | |
107 | } | |
1a016956 KY |
108 | |
109 | priv->period_ns = args.args[1]; | |
0b60111a | 110 | priv->polarity = args.args[2]; |
1a016956 KY |
111 | |
112 | priv->init_voltage = fdtdec_get_int(blob, node, | |
113 | "regulator-init-microvolt", -1); | |
114 | if (priv->init_voltage < 0) { | |
115 | printf("Cannot find regulator pwm init_voltage\n"); | |
116 | return -EINVAL; | |
117 | } | |
118 | ||
119 | ret = uclass_get_device_by_of_offset(UCLASS_PWM, args.node, &priv->pwm); | |
120 | if (ret) { | |
121 | debug("%s: Cannot get PWM: ret=%d\n", __func__, ret); | |
122 | return ret; | |
123 | } | |
124 | ||
125 | return 0; | |
126 | } | |
127 | ||
128 | static int pwm_regulator_probe(struct udevice *dev) | |
129 | { | |
130 | struct pwm_regulator_info *priv = dev_get_priv(dev); | |
131 | struct dm_regulator_uclass_platdata *uc_pdata; | |
132 | ||
133 | uc_pdata = dev_get_uclass_platdata(dev); | |
134 | ||
135 | uc_pdata->type = REGULATOR_TYPE_BUCK; | |
136 | uc_pdata->mode_count = 0; | |
137 | priv->max_voltage = uc_pdata->max_uV; | |
138 | priv->min_voltage = uc_pdata->min_uV; | |
139 | ||
140 | if (priv->init_voltage) | |
141 | pwm_regulator_set_voltage(dev, priv->init_voltage); | |
142 | ||
1a016956 KY |
143 | return 0; |
144 | } | |
145 | ||
146 | static const struct dm_regulator_ops pwm_regulator_ops = { | |
147 | .get_value = pwm_regulator_get_voltage, | |
148 | .set_value = pwm_regulator_set_voltage, | |
149 | .set_enable = pwm_regulator_enable, | |
150 | }; | |
151 | ||
152 | static const struct udevice_id pwm_regulator_ids[] = { | |
153 | { .compatible = "pwm-regulator" }, | |
154 | { } | |
155 | }; | |
156 | ||
157 | U_BOOT_DRIVER(pwm_regulator) = { | |
158 | .name = "pwm_regulator", | |
159 | .id = UCLASS_REGULATOR, | |
160 | .ops = &pwm_regulator_ops, | |
161 | .probe = pwm_regulator_probe, | |
162 | .of_match = pwm_regulator_ids, | |
163 | .ofdata_to_platdata = pwm_regulator_ofdata_to_platdata, | |
164 | .priv_auto_alloc_size = sizeof(struct pwm_regulator_info), | |
165 | }; |