pwm_backlight.c 6.7 KB
Newer Older
1
// SPDX-License-Identifier: GPL-2.0+
2
3
4
5
6
/*
 * Copyright (c) 2016 Google, Inc
 * Written by Simon Glass <sjg@chromium.org>
 */

7
8
#define LOG_CATEGORY UCLASS_PANEL_BACKLIGHT

9
10
11
#include <common.h>
#include <dm.h>
#include <backlight.h>
12
#include <log.h>
13
#include <malloc.h>
14
15
#include <pwm.h>
#include <asm/gpio.h>
16
#include <linux/delay.h>
17
18
#include <power/regulator.h>

19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
/**
 * Private information for the PWM backlight
 *
 * If @num_levels is 0 then the levels are simple values with the backlight
 * value going between the minimum (default 0) and the maximum (default 255).
 * Otherwise the levels are an index into @levels (0..n-1).
 *
 * @reg: Regulator to enable to turn the backlight on (NULL if none)
 * @enable, GPIO to set to enable the backlight (can be missing)
 * @pwm: PWM to use to change the backlight brightness
 * @channel: PWM channel to use
 * @period_ns: Period of the backlight in nanoseconds
 * @levels: Levels for the backlight, or NULL if not using indexed levels
 * @num_levels: Number of levels
 * @cur_level: Current level for the backlight (index or value)
 * @default_level: Default level for the backlight (index or value)
 * @min_level: Minimum level of the backlight (full off)
36
 * @max_level: Maximum level of the backlight (full on)
37
38
 * @enabled: true if backlight is enabled
 */
39
40
41
42
43
44
struct pwm_backlight_priv {
	struct udevice *reg;
	struct gpio_desc enable;
	struct udevice *pwm;
	uint channel;
	uint period_ns;
45
46
47
48
49
50
	/*
	 * the polarity of one PWM
	 * 0: normal polarity
	 * 1: inverted polarity
	 */
	bool polarity;
51
52
	u32 *levels;
	int num_levels;
53
	uint default_level;
54
	int cur_level;
55
56
	uint min_level;
	uint max_level;
57
	bool enabled;
58
59
};

60
static int set_pwm(struct pwm_backlight_priv *priv)
61
62
63
64
{
	uint duty_cycle;
	int ret;

65
66
67
68
69
70
71
72
73
74
75
	if (priv->period_ns) {
		duty_cycle = priv->period_ns * (priv->cur_level - priv->min_level) /
			(priv->max_level - priv->min_level);
		ret = pwm_set_config(priv->pwm, priv->channel, priv->period_ns,
				     duty_cycle);
	} else {
		/* PWM driver will internally scale these like the above. */
		ret = pwm_set_config(priv->pwm, priv->channel,
				     priv->max_level - priv->min_level,
				     priv->cur_level - priv->min_level);
	}
76
77
	if (ret)
		return log_ret(ret);
78

79
	ret = pwm_set_invert(priv->pwm, priv->channel, priv->polarity);
80
81
82
	if (ret == -ENOSYS && !priv->polarity)
		ret = 0;

83
84
85
86
87
88
89
90
91
92
93
	return log_ret(ret);
}

static int enable_sequence(struct udevice *dev, int seq)
{
	struct pwm_backlight_priv *priv = dev_get_priv(dev);
	int ret;

	switch (seq) {
	case 0:
		if (priv->reg) {
94
			__maybe_unused struct dm_regulator_uclass_plat
95
96
				*plat;

97
			plat = dev_get_uclass_plat(priv->reg);
98
99
100
101
102
			log_debug("Enable '%s', regulator '%s'/'%s'\n",
				  dev->name, priv->reg->name, plat->name);
			ret = regulator_set_enable(priv->reg, true);
			if (ret) {
				log_debug("Cannot enable regulator for PWM '%s'\n",
103
					  dev->name);
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
				return log_ret(ret);
			}
			mdelay(120);
		}
		break;
	case 1:
		mdelay(10);
		dm_gpio_set_value(&priv->enable, 1);
		break;
	}

	return 0;
}

static int pwm_backlight_enable(struct udevice *dev)
{
	struct pwm_backlight_priv *priv = dev_get_priv(dev);
	int ret;

	ret = enable_sequence(dev, 0);
	if (ret)
		return log_ret(ret);
	ret = set_pwm(priv);
127
	if (ret)
128
		return log_ret(ret);
129
130
	ret = pwm_set_enable(priv->pwm, priv->channel, true);
	if (ret)
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
		return log_ret(ret);
	ret = enable_sequence(dev, 1);
	if (ret)
		return log_ret(ret);
	priv->enabled = true;

	return 0;
}

static int pwm_backlight_set_brightness(struct udevice *dev, int percent)
{
	struct pwm_backlight_priv *priv = dev_get_priv(dev);
	bool disable = false;
	int level;
	int ret;

	if (!priv->enabled) {
		ret = enable_sequence(dev, 0);
		if (ret)
			return log_ret(ret);
	}
	if (percent == BACKLIGHT_OFF) {
		disable = true;
		percent = 0;
	}
	if (percent == BACKLIGHT_DEFAULT) {
		level = priv->default_level;
	} else {
		if (priv->levels) {
			level = priv->levels[percent * (priv->num_levels - 1)
				/ 100];
		} else {
			level = priv->min_level +
				(priv->max_level - priv->min_level) *
				percent / 100;
		}
	}
	priv->cur_level = level;

	ret = set_pwm(priv);
	if (ret)
		return log_ret(ret);
	if (!priv->enabled) {
		ret = enable_sequence(dev, 1);
		if (ret)
			return log_ret(ret);
		priv->enabled = true;
	}
	if (disable) {
		dm_gpio_set_value(&priv->enable, 0);
		if (priv->reg) {
			ret = regulator_set_enable(priv->reg, false);
			if (ret)
				return log_ret(ret);
		}
		priv->enabled = false;
	}
188
189
190
191

	return 0;
}

192
static 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
197
198
	int index, ret, count, len;
	const u32 *cell;

199
	log_debug("start\n");
200
201
	ret = uclass_get_device_by_phandle(UCLASS_REGULATOR, dev,
					   "power-supply", &priv->reg);
202
	if (ret)
203
		log_debug("Cannot get power supply: ret=%d\n", ret);
204
205
206
	ret = gpio_request_by_name(dev, "enable-gpios", 0, &priv->enable,
				   GPIOD_IS_OUT);
	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
212
	ret = dev_read_phandle_with_args(dev, "pwms", "#pwm-cells", 0, 0,
					 &args);
213
	if (ret) {
214
215
		log_debug("Cannot get PWM phandle: ret=%d\n", ret);
		return log_ret(ret);
216
217
	}

218
	ret = uclass_get_device_by_ofnode(UCLASS_PWM, args.node, &priv->pwm);
219
	if (ret) {
220
221
		log_debug("Cannot get PWM: ret=%d\n", ret);
		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
227
	if (args.args_count > 1)
		priv->period_ns = args.args[1];
228
229
	if (args.args_count > 2)
		priv->polarity = args.args[2];
230

231
232
	index = dev_read_u32_default(dev, "default-brightness-level", 255);
	cell = dev_read_prop(dev, "brightness-levels", &len);
233
234
	count = len / sizeof(u32);
	if (cell && count > index) {
235
236
237
		priv->levels = malloc(len);
		if (!priv->levels)
			return log_ret(-ENOMEM);
238
239
240
241
		ret = dev_read_u32_array(dev, "brightness-levels", priv->levels,
					 count);
		if (ret)
			return log_msg_ret("levels", ret);
242
243
244
		priv->num_levels = count;
		priv->default_level = priv->levels[index];
		priv->max_level = priv->levels[count - 1];
245
246
247
248
	} else {
		priv->default_level = index;
		priv->max_level = 255;
	}
249
250
	priv->cur_level = priv->default_level;
	log_debug("done\n");
251
252
253
254
255
256
257
258
259
260
261


	return 0;
}

static int pwm_backlight_probe(struct udevice *dev)
{
	return 0;
}

static const struct backlight_ops pwm_backlight_ops = {
262
263
	.enable		= pwm_backlight_enable,
	.set_brightness	= pwm_backlight_set_brightness,
264
265
266
267
268
269
270
271
272
273
274
275
};

static const struct udevice_id pwm_backlight_ids[] = {
	{ .compatible = "pwm-backlight" },
	{ }
};

U_BOOT_DRIVER(pwm_backlight) = {
	.name	= "pwm_backlight",
	.id	= UCLASS_PANEL_BACKLIGHT,
	.of_match = pwm_backlight_ids,
	.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
};