blob: a4576c888cf0244ff2733c2304479e372e552034 [file] [log] [blame]
Tom Rini10e47792018-05-06 17:58:06 -04001// SPDX-License-Identifier: GPL-2.0+
Simon Glass37211bf2016-01-21 19:44:57 -07002/*
3 * Copyright (c) 2016 Google, Inc
4 * Written by Simon Glass <sjg@chromium.org>
Simon Glass37211bf2016-01-21 19:44:57 -07005 */
6
Simon Glassfe68a452018-10-01 12:22:41 -06007#define LOG_CATEGORY UCLASS_PANEL_BACKLIGHT
8
Simon Glass37211bf2016-01-21 19:44:57 -07009#include <dm.h>
10#include <backlight.h>
Simon Glass0f2af882020-05-10 11:40:05 -060011#include <log.h>
Simon Glass9bc15642020-02-03 07:36:16 -070012#include <malloc.h>
Simon Glass37211bf2016-01-21 19:44:57 -070013#include <pwm.h>
14#include <asm/gpio.h>
Simon Glassdbd79542020-05-10 11:40:11 -060015#include <linux/delay.h>
Alvaro Fernando Garcíabe732a52023-08-03 21:35:38 -030016#include <linux/math64.h>
Simon Glass37211bf2016-01-21 19:44:57 -070017#include <power/regulator.h>
18
Simon Glassfe68a452018-10-01 12:22:41 -060019/**
20 * Private information for the PWM backlight
21 *
22 * If @num_levels is 0 then the levels are simple values with the backlight
23 * value going between the minimum (default 0) and the maximum (default 255).
24 * Otherwise the levels are an index into @levels (0..n-1).
25 *
26 * @reg: Regulator to enable to turn the backlight on (NULL if none)
27 * @enable, GPIO to set to enable the backlight (can be missing)
28 * @pwm: PWM to use to change the backlight brightness
29 * @channel: PWM channel to use
30 * @period_ns: Period of the backlight in nanoseconds
31 * @levels: Levels for the backlight, or NULL if not using indexed levels
32 * @num_levels: Number of levels
33 * @cur_level: Current level for the backlight (index or value)
34 * @default_level: Default level for the backlight (index or value)
35 * @min_level: Minimum level of the backlight (full off)
Dario Binacchi4d570872020-10-11 14:28:03 +020036 * @max_level: Maximum level of the backlight (full on)
Simon Glassfe68a452018-10-01 12:22:41 -060037 * @enabled: true if backlight is enabled
38 */
Simon Glass37211bf2016-01-21 19:44:57 -070039struct pwm_backlight_priv {
40 struct udevice *reg;
41 struct gpio_desc enable;
42 struct udevice *pwm;
43 uint channel;
44 uint period_ns;
Stefan Mavrodieva7bec412019-04-12 08:56:27 +030045 /*
46 * the polarity of one PWM
47 * 0: normal polarity
48 * 1: inverted polarity
49 */
50 bool polarity;
Simon Glassfe68a452018-10-01 12:22:41 -060051 u32 *levels;
52 int num_levels;
Simon Glass37211bf2016-01-21 19:44:57 -070053 uint default_level;
Simon Glassfe68a452018-10-01 12:22:41 -060054 int cur_level;
Simon Glass37211bf2016-01-21 19:44:57 -070055 uint min_level;
56 uint max_level;
Simon Glassfe68a452018-10-01 12:22:41 -060057 bool enabled;
Simon Glass37211bf2016-01-21 19:44:57 -070058};
59
Simon Glassfe68a452018-10-01 12:22:41 -060060static int set_pwm(struct pwm_backlight_priv *priv)
Simon Glass37211bf2016-01-21 19:44:57 -070061{
Alvaro Fernando Garcíabe732a52023-08-03 21:35:38 -030062 u64 width;
Simon Glass37211bf2016-01-21 19:44:57 -070063 uint duty_cycle;
64 int ret;
65
Alper Nebi Yasak46927462020-10-22 23:49:26 +030066 if (priv->period_ns) {
Alvaro Fernando Garcíabe732a52023-08-03 21:35:38 -030067 width = priv->period_ns * (priv->cur_level - priv->min_level);
68 duty_cycle = div_u64(width,
69 (priv->max_level - priv->min_level));
Alper Nebi Yasak46927462020-10-22 23:49:26 +030070 ret = pwm_set_config(priv->pwm, priv->channel, priv->period_ns,
71 duty_cycle);
72 } else {
73 /* PWM driver will internally scale these like the above. */
74 ret = pwm_set_config(priv->pwm, priv->channel,
75 priv->max_level - priv->min_level,
76 priv->cur_level - priv->min_level);
77 }
Stefan Mavrodieva7bec412019-04-12 08:56:27 +030078 if (ret)
79 return log_ret(ret);
Simon Glassfe68a452018-10-01 12:22:41 -060080
Stefan Mavrodieva7bec412019-04-12 08:56:27 +030081 ret = pwm_set_invert(priv->pwm, priv->channel, priv->polarity);
Marc Dietrichbc59fb42019-07-02 22:08:33 +020082 if (ret == -ENOSYS && !priv->polarity)
83 ret = 0;
84
Simon Glassfe68a452018-10-01 12:22:41 -060085 return log_ret(ret);
86}
87
88static int enable_sequence(struct udevice *dev, int seq)
89{
90 struct pwm_backlight_priv *priv = dev_get_priv(dev);
91 int ret;
92
93 switch (seq) {
94 case 0:
95 if (priv->reg) {
Simon Glass71fa5b42020-12-03 16:55:18 -070096 __maybe_unused struct dm_regulator_uclass_plat
Simon Glassfe68a452018-10-01 12:22:41 -060097 *plat;
98
Simon Glass71fa5b42020-12-03 16:55:18 -070099 plat = dev_get_uclass_plat(priv->reg);
Simon Glassfe68a452018-10-01 12:22:41 -0600100 log_debug("Enable '%s', regulator '%s'/'%s'\n",
101 dev->name, priv->reg->name, plat->name);
Svyatoslav Ryhel0242ebe2023-10-03 09:25:32 +0300102 ret = regulator_set_enable_if_allowed(priv->reg, true);
103 if (ret && ret != -ENOSYS) {
Simon Glassfe68a452018-10-01 12:22:41 -0600104 log_debug("Cannot enable regulator for PWM '%s'\n",
Simon Glassa119b902018-11-23 21:29:39 -0700105 dev->name);
Simon Glassfe68a452018-10-01 12:22:41 -0600106 return log_ret(ret);
107 }
108 mdelay(120);
109 }
110 break;
111 case 1:
112 mdelay(10);
113 dm_gpio_set_value(&priv->enable, 1);
114 break;
115 }
116
117 return 0;
118}
119
120static int pwm_backlight_enable(struct udevice *dev)
121{
122 struct pwm_backlight_priv *priv = dev_get_priv(dev);
123 int ret;
124
125 ret = enable_sequence(dev, 0);
126 if (ret)
127 return log_ret(ret);
128 ret = set_pwm(priv);
Simon Glass37211bf2016-01-21 19:44:57 -0700129 if (ret)
Simon Glassfe68a452018-10-01 12:22:41 -0600130 return log_ret(ret);
Simon Glass37211bf2016-01-21 19:44:57 -0700131 ret = pwm_set_enable(priv->pwm, priv->channel, true);
132 if (ret)
Simon Glassfe68a452018-10-01 12:22:41 -0600133 return log_ret(ret);
134 ret = enable_sequence(dev, 1);
135 if (ret)
136 return log_ret(ret);
137 priv->enabled = true;
138
139 return 0;
140}
141
142static int pwm_backlight_set_brightness(struct udevice *dev, int percent)
143{
144 struct pwm_backlight_priv *priv = dev_get_priv(dev);
145 bool disable = false;
146 int level;
147 int ret;
148
149 if (!priv->enabled) {
150 ret = enable_sequence(dev, 0);
151 if (ret)
152 return log_ret(ret);
153 }
154 if (percent == BACKLIGHT_OFF) {
155 disable = true;
156 percent = 0;
157 }
158 if (percent == BACKLIGHT_DEFAULT) {
159 level = priv->default_level;
160 } else {
161 if (priv->levels) {
162 level = priv->levels[percent * (priv->num_levels - 1)
163 / 100];
164 } else {
165 level = priv->min_level +
166 (priv->max_level - priv->min_level) *
167 percent / 100;
168 }
169 }
170 priv->cur_level = level;
171
172 ret = set_pwm(priv);
173 if (ret)
174 return log_ret(ret);
175 if (!priv->enabled) {
176 ret = enable_sequence(dev, 1);
177 if (ret)
178 return log_ret(ret);
179 priv->enabled = true;
180 }
181 if (disable) {
182 dm_gpio_set_value(&priv->enable, 0);
Svyatoslav Ryhel0242ebe2023-10-03 09:25:32 +0300183 ret = regulator_set_enable_if_allowed(priv->reg, false);
184 if (ret && ret != -ENOSYS)
185 return log_ret(ret);
186
Simon Glassfe68a452018-10-01 12:22:41 -0600187 priv->enabled = false;
188 }
Simon Glass37211bf2016-01-21 19:44:57 -0700189
190 return 0;
191}
192
Simon Glassaad29ae2020-12-03 16:55:21 -0700193static int pwm_backlight_of_to_plat(struct udevice *dev)
Simon Glass37211bf2016-01-21 19:44:57 -0700194{
195 struct pwm_backlight_priv *priv = dev_get_priv(dev);
Simon Glasse247e5c2017-06-12 06:21:37 -0600196 struct ofnode_phandle_args args;
Simon Glass37211bf2016-01-21 19:44:57 -0700197 int index, ret, count, len;
198 const u32 *cell;
199
Simon Glassfe68a452018-10-01 12:22:41 -0600200 log_debug("start\n");
Simon Glass37211bf2016-01-21 19:44:57 -0700201 ret = uclass_get_device_by_phandle(UCLASS_REGULATOR, dev,
202 "power-supply", &priv->reg);
Kever Yang2dae5812018-02-09 10:45:12 +0800203 if (ret)
Simon Glassfe68a452018-10-01 12:22:41 -0600204 log_debug("Cannot get power supply: ret=%d\n", ret);
Simon Glass37211bf2016-01-21 19:44:57 -0700205 ret = gpio_request_by_name(dev, "enable-gpios", 0, &priv->enable,
206 GPIOD_IS_OUT);
207 if (ret) {
Simon Glassfe68a452018-10-01 12:22:41 -0600208 log_debug("Warning: cannot get enable GPIO: ret=%d\n", ret);
Simon Glass37211bf2016-01-21 19:44:57 -0700209 if (ret != -ENOENT)
Simon Glassfe68a452018-10-01 12:22:41 -0600210 return log_ret(ret);
Simon Glass37211bf2016-01-21 19:44:57 -0700211 }
Simon Glasse247e5c2017-06-12 06:21:37 -0600212 ret = dev_read_phandle_with_args(dev, "pwms", "#pwm-cells", 0, 0,
213 &args);
Simon Glass37211bf2016-01-21 19:44:57 -0700214 if (ret) {
Simon Glassfe68a452018-10-01 12:22:41 -0600215 log_debug("Cannot get PWM phandle: ret=%d\n", ret);
216 return log_ret(ret);
Simon Glass37211bf2016-01-21 19:44:57 -0700217 }
218
Simon Glasse247e5c2017-06-12 06:21:37 -0600219 ret = uclass_get_device_by_ofnode(UCLASS_PWM, args.node, &priv->pwm);
Simon Glass37211bf2016-01-21 19:44:57 -0700220 if (ret) {
Simon Glassfe68a452018-10-01 12:22:41 -0600221 log_debug("Cannot get PWM: ret=%d\n", ret);
222 return log_ret(ret);
Simon Glass37211bf2016-01-21 19:44:57 -0700223 }
Alper Nebi Yasak46927462020-10-22 23:49:26 +0300224 if (args.args_count < 1)
Simon Glassfe68a452018-10-01 12:22:41 -0600225 return log_msg_ret("Not enough arguments to pwm\n", -EINVAL);
Simon Glass37211bf2016-01-21 19:44:57 -0700226 priv->channel = args.args[0];
Alper Nebi Yasak46927462020-10-22 23:49:26 +0300227 if (args.args_count > 1)
228 priv->period_ns = args.args[1];
Stefan Mavrodieva7bec412019-04-12 08:56:27 +0300229 if (args.args_count > 2)
230 priv->polarity = args.args[2];
Simon Glass37211bf2016-01-21 19:44:57 -0700231
Simon Glasse247e5c2017-06-12 06:21:37 -0600232 index = dev_read_u32_default(dev, "default-brightness-level", 255);
233 cell = dev_read_prop(dev, "brightness-levels", &len);
Simon Glass37211bf2016-01-21 19:44:57 -0700234 count = len / sizeof(u32);
235 if (cell && count > index) {
Simon Glassfe68a452018-10-01 12:22:41 -0600236 priv->levels = malloc(len);
237 if (!priv->levels)
238 return log_ret(-ENOMEM);
Simon Glass5a569942021-05-13 19:39:18 -0600239 ret = dev_read_u32_array(dev, "brightness-levels", priv->levels,
240 count);
241 if (ret)
242 return log_msg_ret("levels", ret);
Simon Glassfe68a452018-10-01 12:22:41 -0600243 priv->num_levels = count;
244 priv->default_level = priv->levels[index];
245 priv->max_level = priv->levels[count - 1];
Simon Glass37211bf2016-01-21 19:44:57 -0700246 } else {
247 priv->default_level = index;
248 priv->max_level = 255;
249 }
Simon Glassfe68a452018-10-01 12:22:41 -0600250 priv->cur_level = priv->default_level;
251 log_debug("done\n");
Simon Glass37211bf2016-01-21 19:44:57 -0700252
253
254 return 0;
255}
256
257static int pwm_backlight_probe(struct udevice *dev)
258{
259 return 0;
260}
261
262static const struct backlight_ops pwm_backlight_ops = {
Simon Glassfe68a452018-10-01 12:22:41 -0600263 .enable = pwm_backlight_enable,
264 .set_brightness = pwm_backlight_set_brightness,
Simon Glass37211bf2016-01-21 19:44:57 -0700265};
266
267static const struct udevice_id pwm_backlight_ids[] = {
268 { .compatible = "pwm-backlight" },
269 { }
270};
271
272U_BOOT_DRIVER(pwm_backlight) = {
273 .name = "pwm_backlight",
274 .id = UCLASS_PANEL_BACKLIGHT,
275 .of_match = pwm_backlight_ids,
276 .ops = &pwm_backlight_ops,
Simon Glassaad29ae2020-12-03 16:55:21 -0700277 .of_to_plat = pwm_backlight_of_to_plat,
Simon Glass37211bf2016-01-21 19:44:57 -0700278 .probe = pwm_backlight_probe,
Simon Glass8a2b47f2020-12-03 16:55:17 -0700279 .priv_auto = sizeof(struct pwm_backlight_priv),
Simon Glass37211bf2016-01-21 19:44:57 -0700280};