1 /*
2 * Copyright (c) 2016 Google, Inc
3 * Written by Simon Glass <sjg@chromium.org>
4 *
5 * SPDX-License-Identifier: GPL-2.0+
6 */
7
8 #include <common.h>
9 #include <dm.h>
10 #include <backlight.h>
11 #include <pwm.h>
12 #include <asm/gpio.h>
13 #include <power/regulator.h>
14
15 DECLARE_GLOBAL_DATA_PTR;
16
17 struct pwm_backlight_priv {
18 struct udevice *reg;
19 struct gpio_desc enable;
20 struct udevice *pwm;
21 uint channel;
22 uint period_ns;
23 bool polarity;
24 uint default_level;
25 uint min_level;
26 uint max_level;
27 };
28
pwm_backlight_enable(struct udevice * dev)29 static int pwm_backlight_enable(struct udevice *dev)
30 {
31 struct pwm_backlight_priv *priv = dev_get_priv(dev);
32 struct dm_regulator_uclass_platdata *plat;
33 uint duty_cycle;
34 int ret;
35
36 if (priv->reg) {
37 plat = dev_get_uclass_platdata(priv->reg);
38 debug("%s: Enable '%s', regulator '%s'/'%s'\n", __func__,
39 dev->name, priv->reg->name, plat->name);
40 ret = regulator_set_enable(priv->reg, true);
41 if (ret) {
42 debug("%s: Cannot enable regulator for PWM '%s'\n",
43 __func__, dev->name);
44 return ret;
45 }
46 mdelay(120);
47 }
48
49 ret = pwm_set_invert(priv->pwm, priv->channel, priv->polarity);
50 if (ret) {
51 dev_err(dev, "Failed to invert PWM\n");
52 return ret;
53 }
54
55 duty_cycle = priv->period_ns * (priv->default_level - priv->min_level) /
56 (priv->max_level - priv->min_level + 1);
57 ret = pwm_set_config(priv->pwm, priv->channel, priv->period_ns,
58 duty_cycle);
59 if (ret)
60 return ret;
61 ret = pwm_set_enable(priv->pwm, priv->channel, true);
62 if (ret)
63 return ret;
64 mdelay(10);
65
66 if (dm_gpio_is_valid(&priv->enable))
67 dm_gpio_set_value(&priv->enable, 1);
68
69 return 0;
70 }
71
pwm_backlight_disable(struct udevice * dev)72 static int pwm_backlight_disable(struct udevice *dev)
73 {
74 struct pwm_backlight_priv *priv = dev_get_priv(dev);
75 struct dm_regulator_uclass_platdata *plat;
76 int ret;
77
78 ret = pwm_set_config(priv->pwm, priv->channel, priv->period_ns, 0);
79 if (ret)
80 return ret;
81
82 /*
83 * Sometimes there is not "enable-gpios", we have to set pwm output
84 * 0% or 100% duty to play role like "enable-gpios", so we should not
85 * disable pwm, let's keep it enabled.
86 */
87 if (dm_gpio_is_valid(&priv->enable)) {
88 ret = pwm_set_enable(priv->pwm, priv->channel, false);
89 if (ret)
90 return ret;
91 }
92
93 mdelay(10);
94 if (dm_gpio_is_valid(&priv->enable))
95 dm_gpio_set_value(&priv->enable, 0);
96
97 if (priv->reg) {
98 plat = dev_get_uclass_platdata(priv->reg);
99 debug("%s: Disable '%s', regulator '%s'/'%s'\n", __func__,
100 dev->name, priv->reg->name, plat->name);
101 ret = regulator_set_enable(priv->reg, false);
102 if (ret) {
103 debug("%s: Cannot enable regulator for PWM '%s'\n",
104 __func__, dev->name);
105 }
106 mdelay(120);
107 }
108
109 return 0;
110 }
111
pwm_backlight_ofdata_to_platdata(struct udevice * dev)112 static int pwm_backlight_ofdata_to_platdata(struct udevice *dev)
113 {
114 struct pwm_backlight_priv *priv = dev_get_priv(dev);
115 struct ofnode_phandle_args args;
116 int index, ret, count, len;
117 const u32 *cell;
118
119 debug("%s: start\n", __func__);
120 ret = uclass_get_device_by_phandle(UCLASS_REGULATOR, dev,
121 "power-supply", &priv->reg);
122 if (ret)
123 debug("%s: Cannot get power supply: ret=%d\n", __func__, ret);
124 ret = gpio_request_by_name(dev, "enable-gpios", 0, &priv->enable,
125 GPIOD_IS_OUT);
126 if (ret) {
127 debug("%s: Warning: cannot get enable GPIO: ret=%d\n",
128 __func__, ret);
129 if (ret != -ENOENT)
130 return ret;
131 }
132 ret = dev_read_phandle_with_args(dev, "pwms", "#pwm-cells", 0, 0,
133 &args);
134 if (ret) {
135 debug("%s: Cannot get PWM phandle: ret=%d\n", __func__, ret);
136 return ret;
137 }
138
139 ret = uclass_get_device_by_ofnode(UCLASS_PWM, args.node, &priv->pwm);
140 if (ret) {
141 debug("%s: Cannot get PWM: ret=%d\n", __func__, ret);
142 return ret;
143 }
144 priv->channel = args.args[0];
145 priv->period_ns = args.args[1];
146 priv->polarity = args.args[2];
147
148 index = dev_read_u32_default(dev, "default-brightness-level", 255);
149 cell = dev_read_prop(dev, "brightness-levels", &len);
150 count = len / sizeof(u32);
151 if (cell && count > index) {
152 priv->default_level = fdt32_to_cpu(cell[index]);
153 priv->max_level = fdt32_to_cpu(cell[count - 1]);
154 /* Rockchip dts may use a invert sequence level array */
155 if(fdt32_to_cpu(cell[0]) > priv->max_level)
156 priv->max_level = fdt32_to_cpu(cell[0]);
157 } else {
158 priv->default_level = index;
159 priv->max_level = 255;
160 }
161 debug("%s: done\n", __func__);
162
163
164 return 0;
165 }
166
pwm_backlight_probe(struct udevice * dev)167 static int pwm_backlight_probe(struct udevice *dev)
168 {
169 return 0;
170 }
171
172 static const struct backlight_ops pwm_backlight_ops = {
173 .enable = pwm_backlight_enable,
174 .disable = pwm_backlight_disable,
175 };
176
177 static const struct udevice_id pwm_backlight_ids[] = {
178 { .compatible = "pwm-backlight" },
179 { }
180 };
181
182 U_BOOT_DRIVER(pwm_backlight) = {
183 .name = "pwm_backlight",
184 .id = UCLASS_PANEL_BACKLIGHT,
185 .of_match = pwm_backlight_ids,
186 .ops = &pwm_backlight_ops,
187 .ofdata_to_platdata = pwm_backlight_ofdata_to_platdata,
188 .probe = pwm_backlight_probe,
189 .priv_auto_alloc_size = sizeof(struct pwm_backlight_priv),
190 };
191