1 | // SPDX-License-Identifier: GPL-2.0-only |
2 | /* |
3 | * Backlight driver for the Kinetic KTD253 |
4 | * Based on code and know-how from the Samsung GT-S7710 |
5 | * Gareth Phillips <gareth.phillips@samsung.com> |
6 | */ |
7 | #include <linux/backlight.h> |
8 | #include <linux/delay.h> |
9 | #include <linux/err.h> |
10 | #include <linux/fb.h> |
11 | #include <linux/gpio/consumer.h> |
12 | #include <linux/init.h> |
13 | #include <linux/kernel.h> |
14 | #include <linux/limits.h> |
15 | #include <linux/module.h> |
16 | #include <linux/of.h> |
17 | #include <linux/platform_device.h> |
18 | #include <linux/property.h> |
19 | #include <linux/slab.h> |
20 | |
21 | /* Current ratio is n/32 from 1/32 to 32/32 */ |
22 | #define KTD253_MIN_RATIO 1 |
23 | #define KTD253_MAX_RATIO 32 |
24 | #define KTD253_DEFAULT_RATIO 13 |
25 | |
26 | #define KTD253_T_LOW_NS (200 + 10) /* Additional 10ns as safety factor */ |
27 | #define KTD253_T_HIGH_NS (200 + 10) /* Additional 10ns as safety factor */ |
28 | #define KTD253_T_OFF_CRIT_NS 100000 /* 100 us, now it doesn't look good */ |
29 | #define KTD253_T_OFF_MS 3 |
30 | |
31 | struct ktd253_backlight { |
32 | struct device *dev; |
33 | struct backlight_device *bl; |
34 | struct gpio_desc *gpiod; |
35 | u16 ratio; |
36 | }; |
37 | |
38 | static void ktd253_backlight_set_max_ratio(struct ktd253_backlight *ktd253) |
39 | { |
40 | gpiod_set_value_cansleep(desc: ktd253->gpiod, value: 1); |
41 | ndelay(KTD253_T_HIGH_NS); |
42 | /* We always fall back to this when we power on */ |
43 | } |
44 | |
45 | static int ktd253_backlight_stepdown(struct ktd253_backlight *ktd253) |
46 | { |
47 | /* |
48 | * These GPIO operations absolutely can NOT sleep so no _cansleep |
49 | * suffixes, and no using GPIO expanders on slow buses for this! |
50 | * |
51 | * The maximum number of cycles of the loop is 32 so the time taken |
52 | * should nominally be: |
53 | * (T_LOW_NS + T_HIGH_NS + loop_time) * 32 |
54 | * |
55 | * Architectures do not always support ndelay() and we will get a few us |
56 | * instead. If we get to a critical time limit an interrupt has likely |
57 | * occured in the low part of the loop and we need to restart from the |
58 | * top so we have the backlight in a known state. |
59 | */ |
60 | u64 ns; |
61 | |
62 | ns = ktime_get_ns(); |
63 | gpiod_set_value(desc: ktd253->gpiod, value: 0); |
64 | ndelay(KTD253_T_LOW_NS); |
65 | gpiod_set_value(desc: ktd253->gpiod, value: 1); |
66 | ns = ktime_get_ns() - ns; |
67 | if (ns >= KTD253_T_OFF_CRIT_NS) { |
68 | dev_err(ktd253->dev, "PCM on backlight took too long (%llu ns)\n" , ns); |
69 | return -EAGAIN; |
70 | } |
71 | ndelay(KTD253_T_HIGH_NS); |
72 | return 0; |
73 | } |
74 | |
75 | static int ktd253_backlight_update_status(struct backlight_device *bl) |
76 | { |
77 | struct ktd253_backlight *ktd253 = bl_get_data(bl_dev: bl); |
78 | int brightness = backlight_get_brightness(bd: bl); |
79 | u16 target_ratio; |
80 | u16 current_ratio = ktd253->ratio; |
81 | int ret; |
82 | |
83 | dev_dbg(ktd253->dev, "new brightness/ratio: %d/32\n" , brightness); |
84 | |
85 | target_ratio = brightness; |
86 | |
87 | if (target_ratio == current_ratio) |
88 | /* This is already right */ |
89 | return 0; |
90 | |
91 | if (target_ratio == 0) { |
92 | gpiod_set_value_cansleep(desc: ktd253->gpiod, value: 0); |
93 | /* |
94 | * We need to keep the GPIO low for at least this long |
95 | * to actually switch the KTD253 off. |
96 | */ |
97 | msleep(KTD253_T_OFF_MS); |
98 | ktd253->ratio = 0; |
99 | return 0; |
100 | } |
101 | |
102 | if (current_ratio == 0) { |
103 | ktd253_backlight_set_max_ratio(ktd253); |
104 | current_ratio = KTD253_MAX_RATIO; |
105 | } |
106 | |
107 | while (current_ratio != target_ratio) { |
108 | /* |
109 | * These GPIO operations absolutely can NOT sleep so no |
110 | * _cansleep suffixes, and no using GPIO expanders on |
111 | * slow buses for this! |
112 | */ |
113 | ret = ktd253_backlight_stepdown(ktd253); |
114 | if (ret == -EAGAIN) { |
115 | /* |
116 | * Something disturbed the backlight setting code when |
117 | * running so we need to bring the PWM back to a known |
118 | * state. This shouldn't happen too much. |
119 | */ |
120 | gpiod_set_value_cansleep(desc: ktd253->gpiod, value: 0); |
121 | msleep(KTD253_T_OFF_MS); |
122 | ktd253_backlight_set_max_ratio(ktd253); |
123 | current_ratio = KTD253_MAX_RATIO; |
124 | } else if (current_ratio == KTD253_MIN_RATIO) { |
125 | /* After 1/32 we loop back to 32/32 */ |
126 | current_ratio = KTD253_MAX_RATIO; |
127 | } else { |
128 | current_ratio--; |
129 | } |
130 | } |
131 | ktd253->ratio = current_ratio; |
132 | |
133 | dev_dbg(ktd253->dev, "new ratio set to %d/32\n" , target_ratio); |
134 | |
135 | return 0; |
136 | } |
137 | |
138 | static const struct backlight_ops ktd253_backlight_ops = { |
139 | .options = BL_CORE_SUSPENDRESUME, |
140 | .update_status = ktd253_backlight_update_status, |
141 | }; |
142 | |
143 | static int ktd253_backlight_probe(struct platform_device *pdev) |
144 | { |
145 | struct device *dev = &pdev->dev; |
146 | struct backlight_device *bl; |
147 | struct ktd253_backlight *ktd253; |
148 | u32 max_brightness; |
149 | u32 brightness; |
150 | int ret; |
151 | |
152 | ktd253 = devm_kzalloc(dev, size: sizeof(*ktd253), GFP_KERNEL); |
153 | if (!ktd253) |
154 | return -ENOMEM; |
155 | ktd253->dev = dev; |
156 | |
157 | ret = device_property_read_u32(dev, propname: "max-brightness" , val: &max_brightness); |
158 | if (ret) |
159 | max_brightness = KTD253_MAX_RATIO; |
160 | if (max_brightness > KTD253_MAX_RATIO) { |
161 | /* Clamp brightness to hardware max */ |
162 | dev_err(dev, "illegal max brightness specified\n" ); |
163 | max_brightness = KTD253_MAX_RATIO; |
164 | } |
165 | |
166 | ret = device_property_read_u32(dev, propname: "default-brightness" , val: &brightness); |
167 | if (ret) |
168 | brightness = KTD253_DEFAULT_RATIO; |
169 | if (brightness > max_brightness) { |
170 | /* Clamp default brightness to max brightness */ |
171 | dev_err(dev, "default brightness exceeds max brightness\n" ); |
172 | brightness = max_brightness; |
173 | } |
174 | |
175 | ktd253->gpiod = devm_gpiod_get(dev, con_id: "enable" , flags: GPIOD_OUT_LOW); |
176 | if (IS_ERR(ptr: ktd253->gpiod)) |
177 | return dev_err_probe(dev, err: PTR_ERR(ptr: ktd253->gpiod), |
178 | fmt: "gpio line missing or invalid.\n" ); |
179 | gpiod_set_consumer_name(desc: ktd253->gpiod, name: dev_name(dev)); |
180 | /* Bring backlight to a known off state */ |
181 | msleep(KTD253_T_OFF_MS); |
182 | |
183 | bl = devm_backlight_device_register(dev, name: dev_name(dev), parent: dev, devdata: ktd253, |
184 | ops: &ktd253_backlight_ops, NULL); |
185 | if (IS_ERR(ptr: bl)) { |
186 | dev_err(dev, "failed to register backlight\n" ); |
187 | return PTR_ERR(ptr: bl); |
188 | } |
189 | bl->props.max_brightness = max_brightness; |
190 | /* When we just enable the GPIO line we set max brightness */ |
191 | if (brightness) { |
192 | bl->props.brightness = brightness; |
193 | bl->props.power = FB_BLANK_UNBLANK; |
194 | } else { |
195 | bl->props.brightness = 0; |
196 | bl->props.power = FB_BLANK_POWERDOWN; |
197 | } |
198 | |
199 | ktd253->bl = bl; |
200 | platform_set_drvdata(pdev, data: bl); |
201 | backlight_update_status(bd: bl); |
202 | |
203 | return 0; |
204 | } |
205 | |
206 | static const struct of_device_id ktd253_backlight_of_match[] = { |
207 | { .compatible = "kinetic,ktd253" }, |
208 | { .compatible = "kinetic,ktd259" }, |
209 | { /* sentinel */ } |
210 | }; |
211 | MODULE_DEVICE_TABLE(of, ktd253_backlight_of_match); |
212 | |
213 | static struct platform_driver ktd253_backlight_driver = { |
214 | .driver = { |
215 | .name = "ktd253-backlight" , |
216 | .of_match_table = ktd253_backlight_of_match, |
217 | }, |
218 | .probe = ktd253_backlight_probe, |
219 | }; |
220 | module_platform_driver(ktd253_backlight_driver); |
221 | |
222 | MODULE_AUTHOR("Linus Walleij <linus.walleij@linaro.org>" ); |
223 | MODULE_DESCRIPTION("Kinetic KTD253 Backlight Driver" ); |
224 | MODULE_LICENSE("GPL" ); |
225 | MODULE_ALIAS("platform:ktd253-backlight" ); |
226 | |