1
2
3
4
5
6
7#define LOG_CATEGORY UCLASS_PANEL_BACKLIGHT
8
9#include <common.h>
10#include <dm.h>
11#include <backlight.h>
12#include <log.h>
13#include <malloc.h>
14#include <pwm.h>
15#include <asm/gpio.h>
16#include <linux/delay.h>
17#include <power/regulator.h>
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39struct pwm_backlight_priv {
40 struct udevice *reg;
41 struct gpio_desc enable;
42 struct udevice *pwm;
43 uint channel;
44 uint period_ns;
45
46
47
48
49
50 bool polarity;
51 u32 *levels;
52 int num_levels;
53 uint default_level;
54 int cur_level;
55 uint min_level;
56 uint max_level;
57 bool enabled;
58};
59
60static int set_pwm(struct pwm_backlight_priv *priv)
61{
62 uint duty_cycle;
63 int ret;
64
65 if (priv->period_ns) {
66 duty_cycle = priv->period_ns * (priv->cur_level - priv->min_level) /
67 (priv->max_level - priv->min_level);
68 ret = pwm_set_config(priv->pwm, priv->channel, priv->period_ns,
69 duty_cycle);
70 } else {
71
72 ret = pwm_set_config(priv->pwm, priv->channel,
73 priv->max_level - priv->min_level,
74 priv->cur_level - priv->min_level);
75 }
76 if (ret)
77 return log_ret(ret);
78
79 ret = pwm_set_invert(priv->pwm, priv->channel, priv->polarity);
80 if (ret == -ENOSYS && !priv->polarity)
81 ret = 0;
82
83 return log_ret(ret);
84}
85
86static int enable_sequence(struct udevice *dev, int seq)
87{
88 struct pwm_backlight_priv *priv = dev_get_priv(dev);
89 int ret;
90
91 switch (seq) {
92 case 0:
93 if (priv->reg) {
94 __maybe_unused struct dm_regulator_uclass_plat
95 *plat;
96
97 plat = dev_get_uclass_plat(priv->reg);
98 log_debug("Enable '%s', regulator '%s'/'%s'\n",
99 dev->name, priv->reg->name, plat->name);
100 ret = regulator_set_enable(priv->reg, true);
101 if (ret) {
102 log_debug("Cannot enable regulator for PWM '%s'\n",
103 dev->name);
104 return log_ret(ret);
105 }
106 mdelay(120);
107 }
108 break;
109 case 1:
110 mdelay(10);
111 dm_gpio_set_value(&priv->enable, 1);
112 break;
113 }
114
115 return 0;
116}
117
118static int pwm_backlight_enable(struct udevice *dev)
119{
120 struct pwm_backlight_priv *priv = dev_get_priv(dev);
121 int ret;
122
123 ret = enable_sequence(dev, 0);
124 if (ret)
125 return log_ret(ret);
126 ret = set_pwm(priv);
127 if (ret)
128 return log_ret(ret);
129 ret = pwm_set_enable(priv->pwm, priv->channel, true);
130 if (ret)
131 return log_ret(ret);
132 ret = enable_sequence(dev, 1);
133 if (ret)
134 return log_ret(ret);
135 priv->enabled = true;
136
137 return 0;
138}
139
140static int pwm_backlight_set_brightness(struct udevice *dev, int percent)
141{
142 struct pwm_backlight_priv *priv = dev_get_priv(dev);
143 bool disable = false;
144 int level;
145 int ret;
146
147 if (!priv->enabled) {
148 ret = enable_sequence(dev, 0);
149 if (ret)
150 return log_ret(ret);
151 }
152 if (percent == BACKLIGHT_OFF) {
153 disable = true;
154 percent = 0;
155 }
156 if (percent == BACKLIGHT_DEFAULT) {
157 level = priv->default_level;
158 } else {
159 if (priv->levels) {
160 level = priv->levels[percent * (priv->num_levels - 1)
161 / 100];
162 } else {
163 level = priv->min_level +
164 (priv->max_level - priv->min_level) *
165 percent / 100;
166 }
167 }
168 priv->cur_level = level;
169
170 ret = set_pwm(priv);
171 if (ret)
172 return log_ret(ret);
173 if (!priv->enabled) {
174 ret = enable_sequence(dev, 1);
175 if (ret)
176 return log_ret(ret);
177 priv->enabled = true;
178 }
179 if (disable) {
180 dm_gpio_set_value(&priv->enable, 0);
181 if (priv->reg) {
182 ret = regulator_set_enable(priv->reg, false);
183 if (ret)
184 return log_ret(ret);
185 }
186 priv->enabled = false;
187 }
188
189 return 0;
190}
191
192static int pwm_backlight_of_to_plat(struct udevice *dev)
193{
194 struct pwm_backlight_priv *priv = dev_get_priv(dev);
195 struct ofnode_phandle_args args;
196 int index, ret, count, len;
197 const u32 *cell;
198
199 log_debug("start\n");
200 ret = uclass_get_device_by_phandle(UCLASS_REGULATOR, dev,
201 "power-supply", &priv->reg);
202 if (ret)
203 log_debug("Cannot get power supply: ret=%d\n", ret);
204 ret = gpio_request_by_name(dev, "enable-gpios", 0, &priv->enable,
205 GPIOD_IS_OUT);
206 if (ret) {
207 log_debug("Warning: cannot get enable GPIO: ret=%d\n", ret);
208 if (ret != -ENOENT)
209 return log_ret(ret);
210 }
211 ret = dev_read_phandle_with_args(dev, "pwms", "#pwm-cells", 0, 0,
212 &args);
213 if (ret) {
214 log_debug("Cannot get PWM phandle: ret=%d\n", ret);
215 return log_ret(ret);
216 }
217
218 ret = uclass_get_device_by_ofnode(UCLASS_PWM, args.node, &priv->pwm);
219 if (ret) {
220 log_debug("Cannot get PWM: ret=%d\n", ret);
221 return log_ret(ret);
222 }
223 if (args.args_count < 1)
224 return log_msg_ret("Not enough arguments to pwm\n", -EINVAL);
225 priv->channel = args.args[0];
226 if (args.args_count > 1)
227 priv->period_ns = args.args[1];
228 if (args.args_count > 2)
229 priv->polarity = args.args[2];
230
231 index = dev_read_u32_default(dev, "default-brightness-level", 255);
232 cell = dev_read_prop(dev, "brightness-levels", &len);
233 count = len / sizeof(u32);
234 if (cell && count > index) {
235 priv->levels = malloc(len);
236 if (!priv->levels)
237 return log_ret(-ENOMEM);
238 ret = dev_read_u32_array(dev, "brightness-levels", priv->levels,
239 count);
240 if (ret)
241 return log_msg_ret("levels", ret);
242 priv->num_levels = count;
243 priv->default_level = priv->levels[index];
244 priv->max_level = priv->levels[count - 1];
245 } else {
246 priv->default_level = index;
247 priv->max_level = 255;
248 }
249 priv->cur_level = priv->default_level;
250 log_debug("done\n");
251
252
253 return 0;
254}
255
256static int pwm_backlight_probe(struct udevice *dev)
257{
258 return 0;
259}
260
261static const struct backlight_ops pwm_backlight_ops = {
262 .enable = pwm_backlight_enable,
263 .set_brightness = pwm_backlight_set_brightness,
264};
265
266static const struct udevice_id pwm_backlight_ids[] = {
267 { .compatible = "pwm-backlight" },
268 { }
269};
270
271U_BOOT_DRIVER(pwm_backlight) = {
272 .name = "pwm_backlight",
273 .id = UCLASS_PANEL_BACKLIGHT,
274 .of_match = pwm_backlight_ids,
275 .ops = &pwm_backlight_ops,
276 .of_to_plat = pwm_backlight_of_to_plat,
277 .probe = pwm_backlight_probe,
278 .priv_auto = sizeof(struct pwm_backlight_priv),
279};
280
