panel-samsung-atna33xc20.c

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