1 // SPDX-License-Identifier: GPL-2.0-or-later
3 * Samsung SoC DP (Display Port) interface driver.
5 * Copyright (C) 2012 Samsung Electronics Co., Ltd.
6 * Author: Jingoo Han <jg1.han@samsung.com>
9 #include <linux/module.h>
10 #include <linux/platform_device.h>
11 #include <linux/err.h>
12 #include <linux/clk.h>
13 #include <linux/of_graph.h>
14 #include <linux/component.h>
15 #include <linux/pm_runtime.h>
16 #include <video/of_display_timing.h>
17 #include <video/of_videomode.h>
18 #include <video/videomode.h>
21 #include <drm/drm_atomic_helper.h>
22 #include <drm/drm_crtc.h>
23 #include <drm/drm_of.h>
24 #include <drm/drm_panel.h>
25 #include <drm/drm_probe_helper.h>
27 #include <drm/bridge/analogix_dp.h>
28 #include <drm/exynos_drm.h>
30 #include "exynos_drm_crtc.h"
32 #define to_dp(nm) container_of(nm, struct exynos_dp_device, nm)
34 struct exynos_dp_device
{
35 struct drm_encoder encoder
;
36 struct drm_connector
*connector
;
37 struct drm_bridge
*ptn_bridge
;
38 struct drm_device
*drm_dev
;
42 struct analogix_dp_device
*adp
;
43 struct analogix_dp_plat_data plat_data
;
46 static int exynos_dp_crtc_clock_enable(struct analogix_dp_plat_data
*plat_data
,
49 struct exynos_dp_device
*dp
= to_dp(plat_data
);
50 struct drm_encoder
*encoder
= &dp
->encoder
;
55 exynos_drm_pipe_clk_enable(to_exynos_crtc(encoder
->crtc
), enable
);
60 static int exynos_dp_poweron(struct analogix_dp_plat_data
*plat_data
)
62 return exynos_dp_crtc_clock_enable(plat_data
, true);
65 static int exynos_dp_poweroff(struct analogix_dp_plat_data
*plat_data
)
67 return exynos_dp_crtc_clock_enable(plat_data
, false);
70 static int exynos_dp_get_modes(struct analogix_dp_plat_data
*plat_data
,
71 struct drm_connector
*connector
)
73 struct exynos_dp_device
*dp
= to_dp(plat_data
);
74 struct drm_display_mode
*mode
;
77 if (dp
->plat_data
.panel
)
80 mode
= drm_mode_create(connector
->dev
);
82 DRM_DEV_ERROR(dp
->dev
,
83 "failed to create a new display mode.\n");
87 drm_display_mode_from_videomode(&dp
->vm
, mode
);
88 connector
->display_info
.width_mm
= mode
->width_mm
;
89 connector
->display_info
.height_mm
= mode
->height_mm
;
91 mode
->type
= DRM_MODE_TYPE_DRIVER
| DRM_MODE_TYPE_PREFERRED
;
92 drm_mode_set_name(mode
);
93 drm_mode_probed_add(connector
, mode
);
98 static int exynos_dp_bridge_attach(struct analogix_dp_plat_data
*plat_data
,
99 struct drm_bridge
*bridge
,
100 struct drm_connector
*connector
)
102 struct exynos_dp_device
*dp
= to_dp(plat_data
);
105 dp
->connector
= connector
;
107 /* Pre-empt DP connector creation if there's a bridge */
108 if (dp
->ptn_bridge
) {
109 ret
= drm_bridge_attach(&dp
->encoder
, dp
->ptn_bridge
, bridge
);
111 DRM_DEV_ERROR(dp
->dev
,
112 "Failed to attach bridge to drm\n");
121 static void exynos_dp_mode_set(struct drm_encoder
*encoder
,
122 struct drm_display_mode
*mode
,
123 struct drm_display_mode
*adjusted_mode
)
127 static void exynos_dp_nop(struct drm_encoder
*encoder
)
132 static const struct drm_encoder_helper_funcs exynos_dp_encoder_helper_funcs
= {
133 .mode_set
= exynos_dp_mode_set
,
134 .enable
= exynos_dp_nop
,
135 .disable
= exynos_dp_nop
,
138 static const struct drm_encoder_funcs exynos_dp_encoder_funcs
= {
139 .destroy
= drm_encoder_cleanup
,
142 static int exynos_dp_dt_parse_panel(struct exynos_dp_device
*dp
)
146 ret
= of_get_videomode(dp
->dev
->of_node
, &dp
->vm
, OF_USE_NATIVE_MODE
);
148 DRM_DEV_ERROR(dp
->dev
,
149 "failed: of_get_videomode() : %d\n", ret
);
155 static int exynos_dp_bind(struct device
*dev
, struct device
*master
, void *data
)
157 struct exynos_dp_device
*dp
= dev_get_drvdata(dev
);
158 struct drm_encoder
*encoder
= &dp
->encoder
;
159 struct drm_device
*drm_dev
= data
;
163 dp
->drm_dev
= drm_dev
;
165 dp
->plat_data
.dev_type
= EXYNOS_DP
;
166 dp
->plat_data
.power_on_start
= exynos_dp_poweron
;
167 dp
->plat_data
.power_off
= exynos_dp_poweroff
;
168 dp
->plat_data
.attach
= exynos_dp_bridge_attach
;
169 dp
->plat_data
.get_modes
= exynos_dp_get_modes
;
171 if (!dp
->plat_data
.panel
&& !dp
->ptn_bridge
) {
172 ret
= exynos_dp_dt_parse_panel(dp
);
177 drm_encoder_init(drm_dev
, encoder
, &exynos_dp_encoder_funcs
,
178 DRM_MODE_ENCODER_TMDS
, NULL
);
180 drm_encoder_helper_add(encoder
, &exynos_dp_encoder_helper_funcs
);
182 ret
= exynos_drm_set_possible_crtcs(encoder
, EXYNOS_DISPLAY_TYPE_LCD
);
186 dp
->plat_data
.encoder
= encoder
;
188 dp
->adp
= analogix_dp_bind(dev
, dp
->drm_dev
, &dp
->plat_data
);
189 if (IS_ERR(dp
->adp
)) {
190 dp
->encoder
.funcs
->destroy(&dp
->encoder
);
191 return PTR_ERR(dp
->adp
);
197 static void exynos_dp_unbind(struct device
*dev
, struct device
*master
,
200 struct exynos_dp_device
*dp
= dev_get_drvdata(dev
);
202 analogix_dp_unbind(dp
->adp
);
203 dp
->encoder
.funcs
->destroy(&dp
->encoder
);
206 static const struct component_ops exynos_dp_ops
= {
207 .bind
= exynos_dp_bind
,
208 .unbind
= exynos_dp_unbind
,
211 static int exynos_dp_probe(struct platform_device
*pdev
)
213 struct device
*dev
= &pdev
->dev
;
214 struct device_node
*np
;
215 struct exynos_dp_device
*dp
;
216 struct drm_panel
*panel
;
217 struct drm_bridge
*bridge
;
220 dp
= devm_kzalloc(&pdev
->dev
, sizeof(struct exynos_dp_device
),
226 * We just use the drvdata until driver run into component
227 * add function, and then we would set drvdata to null, so
228 * that analogix dp driver would take charge of the drvdata.
230 platform_set_drvdata(pdev
, dp
);
232 /* This is for the backward compatibility. */
233 np
= of_parse_phandle(dev
->of_node
, "panel", 0);
235 dp
->plat_data
.panel
= of_drm_find_panel(np
);
238 if (IS_ERR(dp
->plat_data
.panel
))
239 return PTR_ERR(dp
->plat_data
.panel
);
244 ret
= drm_of_find_panel_or_bridge(dev
->of_node
, 0, 0, &panel
, &bridge
);
248 /* The remote port can be either a panel or a bridge */
249 dp
->plat_data
.panel
= panel
;
250 dp
->plat_data
.skip_connector
= !!bridge
;
251 dp
->ptn_bridge
= bridge
;
254 return component_add(&pdev
->dev
, &exynos_dp_ops
);
257 static int exynos_dp_remove(struct platform_device
*pdev
)
259 component_del(&pdev
->dev
, &exynos_dp_ops
);
265 static int exynos_dp_suspend(struct device
*dev
)
267 struct exynos_dp_device
*dp
= dev_get_drvdata(dev
);
269 return analogix_dp_suspend(dp
->adp
);
272 static int exynos_dp_resume(struct device
*dev
)
274 struct exynos_dp_device
*dp
= dev_get_drvdata(dev
);
276 return analogix_dp_resume(dp
->adp
);
280 static const struct dev_pm_ops exynos_dp_pm_ops
= {
281 SET_RUNTIME_PM_OPS(exynos_dp_suspend
, exynos_dp_resume
, NULL
)
282 SET_SYSTEM_SLEEP_PM_OPS(pm_runtime_force_suspend
,
283 pm_runtime_force_resume
)
286 static const struct of_device_id exynos_dp_match
[] = {
287 { .compatible
= "samsung,exynos5-dp" },
290 MODULE_DEVICE_TABLE(of
, exynos_dp_match
);
292 struct platform_driver dp_driver
= {
293 .probe
= exynos_dp_probe
,
294 .remove
= exynos_dp_remove
,
297 .owner
= THIS_MODULE
,
298 .pm
= &exynos_dp_pm_ops
,
299 .of_match_table
= exynos_dp_match
,
303 MODULE_AUTHOR("Jingoo Han <jg1.han@samsung.com>");
304 MODULE_DESCRIPTION("Samsung Specific Analogix-DP Driver Extension");
305 MODULE_LICENSE("GPL v2");