1 // SPDX-License-Identifier: GPL-2.0
2 /*
3 * Copyright 2021 Google Inc.
4 *
5 * Panel driver for the Samsung ATNA33XC20 panel. This panel can't be handled
6 * by the DRM_PANEL_SIMPLE driver because its power sequencing is non-standard.
7 */
8
9 #include <linux/backlight.h>
10 #include <linux/delay.h>
11 #include <linux/gpio/consumer.h>
12 #include <linux/iopoll.h>
13 #include <linux/module.h>
14 #include <linux/pm_runtime.h>
15 #include <linux/regulator/consumer.h>
16
17 #include <drm/drm_dp_aux_bus.h>
18 #include <drm/drm_dp_helper.h>
19 #include <drm/drm_edid.h>
20 #include <drm/drm_panel.h>
21
22 struct atana33xc20_panel {
23 struct drm_panel base;
24 bool prepared;
25 bool enabled;
26 bool el3_was_on;
27
28 bool no_hpd;
29 struct gpio_desc *hpd_gpio;
30
31 struct regulator *supply;
32 struct gpio_desc *el_on3_gpio;
33
34 struct edid *edid;
35
36 ktime_t powered_off_time;
37 ktime_t powered_on_time;
38 ktime_t el_on3_off_time;
39 };
40
to_atana33xc20(struct drm_panel * panel)41 static inline struct atana33xc20_panel *to_atana33xc20(struct drm_panel *panel)
42 {
43 return container_of(panel, struct atana33xc20_panel, base);
44 }
45
atana33xc20_wait(ktime_t start_ktime,unsigned int min_ms)46 static void atana33xc20_wait(ktime_t start_ktime, unsigned int min_ms)
47 {
48 ktime_t now_ktime, min_ktime;
49
50 min_ktime = ktime_add(start_ktime, ms_to_ktime(min_ms));
51 now_ktime = ktime_get();
52
53 if (ktime_before(now_ktime, min_ktime))
54 msleep(ktime_to_ms(ktime_sub(min_ktime, now_ktime)) + 1);
55 }
56
atana33xc20_suspend(struct device * dev)57 static int atana33xc20_suspend(struct device *dev)
58 {
59 struct atana33xc20_panel *p = dev_get_drvdata(dev);
60 int ret;
61
62 /*
63 * Note 3 (Example of power off sequence in detail) in spec
64 * specifies to wait 150 ms after deasserting EL3_ON before
65 * powering off.
66 */
67 if (p->el3_was_on)
68 atana33xc20_wait(p->el_on3_off_time, 150);
69
70 ret = regulator_disable(p->supply);
71 if (ret)
72 return ret;
73 p->powered_off_time = ktime_get();
74 p->el3_was_on = false;
75
76 return 0;
77 }
78
atana33xc20_resume(struct device * dev)79 static int atana33xc20_resume(struct device *dev)
80 {
81 struct atana33xc20_panel *p = dev_get_drvdata(dev);
82 bool hpd_asserted = false;
83 int ret;
84
85 /* T12 (Power off time) is min 500 ms */
86 atana33xc20_wait(p->powered_off_time, 500);
87
88 ret = regulator_enable(p->supply);
89 if (ret)
90 return ret;
91 p->powered_on_time = ktime_get();
92
93 /*
94 * Handle HPD. Note: if HPD is hooked up to a dedicated pin on the
95 * eDP controller then "no_hpd" will be false _and_ "hpd_gpio" will be
96 * NULL. It's up to the controller driver to wait for HPD after
97 * preparing the panel in that case.
98 */
99 if (p->no_hpd) {
100 /* T3 VCC to HPD high is max 200 ms */
101 msleep(200);
102 } else if (p->hpd_gpio) {
103 ret = readx_poll_timeout(gpiod_get_value_cansleep, p->hpd_gpio,
104 hpd_asserted, hpd_asserted,
105 1000, 200000);
106 if (!hpd_asserted)
107 dev_warn(dev, "Timeout waiting for HPD\n");
108 }
109
110 return 0;
111 }
112
atana33xc20_disable(struct drm_panel * panel)113 static int atana33xc20_disable(struct drm_panel *panel)
114 {
115 struct atana33xc20_panel *p = to_atana33xc20(panel);
116
117 /* Disabling when already disabled is a no-op */
118 if (!p->enabled)
119 return 0;
120
121 gpiod_set_value_cansleep(p->el_on3_gpio, 0);
122 p->el_on3_off_time = ktime_get();
123 p->enabled = false;
124
125 /*
126 * Keep track of the fact that EL_ON3 was on but we haven't power
127 * cycled yet. This lets us know that "el_on3_off_time" is recent (we
128 * don't need to worry about ktime wraparounds) and also makes it
129 * obvious if we try to enable again without a power cycle (see the
130 * warning in atana33xc20_enable()).
131 */
132 p->el3_was_on = true;
133
134 /*
135 * Sleeping 20 ms here (after setting the GPIO) avoids a glitch when
136 * powering off.
137 */
138 msleep(20);
139
140 return 0;
141 }
142
atana33xc20_enable(struct drm_panel * panel)143 static int atana33xc20_enable(struct drm_panel *panel)
144 {
145 struct atana33xc20_panel *p = to_atana33xc20(panel);
146
147 /* Enabling when already enabled is a no-op */
148 if (p->enabled)
149 return 0;
150
151 /*
152 * Once EL_ON3 drops we absolutely need a power cycle before the next
153 * enable or the backlight will never come on again. The code ensures
154 * this because disable() is _always_ followed by unprepare() and
155 * unprepare() forces a suspend with pm_runtime_put_sync_suspend(),
156 * but let's track just to make sure since the requirement is so
157 * non-obvious.
158 */
159 if (WARN_ON(p->el3_was_on))
160 return -EIO;
161
162 /*
163 * Note 2 (Example of power on sequence in detail) in spec specifies
164 * to wait 400 ms after powering on before asserting EL3_on.
165 */
166 atana33xc20_wait(p->powered_on_time, 400);
167
168 gpiod_set_value_cansleep(p->el_on3_gpio, 1);
169 p->enabled = true;
170
171 return 0;
172 }
173
atana33xc20_unprepare(struct drm_panel * panel)174 static int atana33xc20_unprepare(struct drm_panel *panel)
175 {
176 struct atana33xc20_panel *p = to_atana33xc20(panel);
177 int ret;
178
179 /* Unpreparing when already unprepared is a no-op */
180 if (!p->prepared)
181 return 0;
182
183 /*
184 * Purposely do a put_sync, don't use autosuspend. The panel's tcon
185 * seems to sometimes crash when you stop giving it data and this is
186 * the best way to ensure it will come back.
187 *
188 * NOTE: we still want autosuspend for cases where we only turn on
189 * to get the EDID or otherwise send DP AUX commands to the panel.
190 */
191 ret = pm_runtime_put_sync_suspend(panel->dev);
192 if (ret < 0)
193 return ret;
194 p->prepared = false;
195
196 return 0;
197 }
198
atana33xc20_prepare(struct drm_panel * panel)199 static int atana33xc20_prepare(struct drm_panel *panel)
200 {
201 struct atana33xc20_panel *p = to_atana33xc20(panel);
202 int ret;
203
204 /* Preparing when already prepared is a no-op */
205 if (p->prepared)
206 return 0;
207
208 ret = pm_runtime_get_sync(panel->dev);
209 if (ret < 0) {
210 pm_runtime_put_autosuspend(panel->dev);
211 return ret;
212 }
213 p->prepared = true;
214
215 return 0;
216 }
217
atana33xc20_get_modes(struct drm_panel * panel,struct drm_connector * connector)218 static int atana33xc20_get_modes(struct drm_panel *panel,
219 struct drm_connector *connector)
220 {
221 struct atana33xc20_panel *p = to_atana33xc20(panel);
222 struct dp_aux_ep_device *aux_ep = to_dp_aux_ep_dev(panel->dev);
223 int num = 0;
224
225 pm_runtime_get_sync(panel->dev);
226
227 if (!p->edid)
228 p->edid = drm_get_edid(connector, &aux_ep->aux->ddc);
229 num = drm_add_edid_modes(connector, p->edid);
230
231 pm_runtime_mark_last_busy(panel->dev);
232 pm_runtime_put_autosuspend(panel->dev);
233
234 return num;
235 }
236
237 static const struct drm_panel_funcs atana33xc20_funcs = {
238 .disable = atana33xc20_disable,
239 .enable = atana33xc20_enable,
240 .unprepare = atana33xc20_unprepare,
241 .prepare = atana33xc20_prepare,
242 .get_modes = atana33xc20_get_modes,
243 };
244
atana33xc20_runtime_disable(void * data)245 static void atana33xc20_runtime_disable(void *data)
246 {
247 pm_runtime_disable(data);
248 }
249
atana33xc20_dont_use_autosuspend(void * data)250 static void atana33xc20_dont_use_autosuspend(void *data)
251 {
252 pm_runtime_dont_use_autosuspend(data);
253 }
254
atana33xc20_probe(struct dp_aux_ep_device * aux_ep)255 static int atana33xc20_probe(struct dp_aux_ep_device *aux_ep)
256 {
257 struct atana33xc20_panel *panel;
258 struct device *dev = &aux_ep->dev;
259 int ret;
260
261 panel = devm_kzalloc(dev, sizeof(*panel), GFP_KERNEL);
262 if (!panel)
263 return -ENOMEM;
264 dev_set_drvdata(dev, panel);
265
266 panel->supply = devm_regulator_get(dev, "power");
267 if (IS_ERR(panel->supply))
268 return dev_err_probe(dev, PTR_ERR(panel->supply),
269 "Failed to get power supply\n");
270
271 panel->el_on3_gpio = devm_gpiod_get(dev, "enable", GPIOD_OUT_LOW);
272 if (IS_ERR(panel->el_on3_gpio))
273 return dev_err_probe(dev, PTR_ERR(panel->el_on3_gpio),
274 "Failed to get enable GPIO\n");
275
276 panel->no_hpd = of_property_read_bool(dev->of_node, "no-hpd");
277 if (!panel->no_hpd) {
278 panel->hpd_gpio = devm_gpiod_get_optional(dev, "hpd", GPIOD_IN);
279 if (IS_ERR(panel->hpd_gpio))
280 return dev_err_probe(dev, PTR_ERR(panel->hpd_gpio),
281 "Failed to get HPD GPIO\n");
282 }
283
284 pm_runtime_enable(dev);
285 ret = devm_add_action_or_reset(dev, atana33xc20_runtime_disable, dev);
286 if (ret)
287 return ret;
288 pm_runtime_set_autosuspend_delay(dev, 1000);
289 pm_runtime_use_autosuspend(dev);
290 ret = devm_add_action_or_reset(dev, atana33xc20_dont_use_autosuspend, dev);
291 if (ret)
292 return ret;
293
294 drm_panel_init(&panel->base, dev, &atana33xc20_funcs, DRM_MODE_CONNECTOR_eDP);
295
296 pm_runtime_get_sync(dev);
297 ret = drm_panel_dp_aux_backlight(&panel->base, aux_ep->aux);
298 pm_runtime_mark_last_busy(dev);
299 pm_runtime_put_autosuspend(dev);
300 if (ret)
301 return dev_err_probe(dev, ret,
302 "failed to register dp aux backlight\n");
303
304 drm_panel_add(&panel->base);
305
306 return 0;
307 }
308
atana33xc20_remove(struct dp_aux_ep_device * aux_ep)309 static void atana33xc20_remove(struct dp_aux_ep_device *aux_ep)
310 {
311 struct device *dev = &aux_ep->dev;
312 struct atana33xc20_panel *panel = dev_get_drvdata(dev);
313
314 drm_panel_remove(&panel->base);
315 drm_panel_disable(&panel->base);
316 drm_panel_unprepare(&panel->base);
317
318 kfree(panel->edid);
319 }
320
atana33xc20_shutdown(struct dp_aux_ep_device * aux_ep)321 static void atana33xc20_shutdown(struct dp_aux_ep_device *aux_ep)
322 {
323 struct device *dev = &aux_ep->dev;
324 struct atana33xc20_panel *panel = dev_get_drvdata(dev);
325
326 drm_panel_disable(&panel->base);
327 drm_panel_unprepare(&panel->base);
328 }
329
330 static const struct of_device_id atana33xc20_dt_match[] = {
331 { .compatible = "samsung,atna33xc20", },
332 { /* sentinal */ }
333 };
334 MODULE_DEVICE_TABLE(of, atana33xc20_dt_match);
335
336 static const struct dev_pm_ops atana33xc20_pm_ops = {
337 SET_RUNTIME_PM_OPS(atana33xc20_suspend, atana33xc20_resume, NULL)
338 SET_SYSTEM_SLEEP_PM_OPS(pm_runtime_force_suspend,
339 pm_runtime_force_resume)
340 };
341
342 static struct dp_aux_ep_driver atana33xc20_driver = {
343 .driver = {
344 .name = "samsung_atana33xc20",
345 .of_match_table = atana33xc20_dt_match,
346 .pm = &atana33xc20_pm_ops,
347 },
348 .probe = atana33xc20_probe,
349 .remove = atana33xc20_remove,
350 .shutdown = atana33xc20_shutdown,
351 };
352
atana33xc20_init(void)353 static int __init atana33xc20_init(void)
354 {
355 return dp_aux_dp_driver_register(&atana33xc20_driver);
356 }
357 module_init(atana33xc20_init);
358
atana33xc20_exit(void)359 static void __exit atana33xc20_exit(void)
360 {
361 dp_aux_dp_driver_unregister(&atana33xc20_driver);
362 }
363 module_exit(atana33xc20_exit);
364
365 MODULE_DESCRIPTION("Samsung ATANA33XC20 Panel Driver");
366 MODULE_LICENSE("GPL v2");
367