2 * Samsung SoC DP (Display Port) interface driver.
4 * Copyright (C) 2012 Samsung Electronics Co., Ltd.
5 * Author: Jingoo Han <jg1.han@samsung.com>
7 * This program is free software; you can redistribute it and/or modify it
8 * under the terms of the GNU General Public License as published by the
9 * Free Software Foundation; either version 2 of the License, or (at your
10 * option) any later version.
13 #include <linux/module.h>
14 #include <linux/platform_device.h>
15 #include <linux/err.h>
16 #include <linux/clk.h>
17 #include <linux/of_graph.h>
18 #include <linux/component.h>
19 #include <video/of_display_timing.h>
20 #include <video/of_videomode.h>
21 #include <video/videomode.h>
24 #include <drm/drm_crtc.h>
25 #include <drm/drm_crtc_helper.h>
26 #include <drm/drm_panel.h>
28 #include <drm/bridge/analogix_dp.h>
29 #include <drm/exynos_drm.h>
31 #include "exynos_drm_crtc.h"
33 #define to_dp(nm) container_of(nm, struct exynos_dp_device, nm)
35 struct exynos_dp_device
{
36 struct drm_encoder encoder
;
37 struct drm_connector connector
;
38 struct drm_bridge
*ptn_bridge
;
39 struct drm_device
*drm_dev
;
43 struct analogix_dp_plat_data plat_data
;
46 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
)
72 struct exynos_dp_device
*dp
= to_dp(plat_data
);
73 struct drm_connector
*connector
= &dp
->connector
;
74 struct drm_display_mode
*mode
;
77 if (dp
->plat_data
.panel
)
80 mode
= drm_mode_create(connector
->dev
);
82 DRM_ERROR("failed to create a new display mode.\n");
86 drm_display_mode_from_videomode(&dp
->vm
, mode
);
87 connector
->display_info
.width_mm
= mode
->width_mm
;
88 connector
->display_info
.height_mm
= mode
->height_mm
;
90 mode
->type
= DRM_MODE_TYPE_DRIVER
| DRM_MODE_TYPE_PREFERRED
;
91 drm_mode_set_name(mode
);
92 drm_mode_probed_add(connector
, mode
);
97 static int exynos_dp_bridge_attach(struct analogix_dp_plat_data
*plat_data
,
98 struct drm_bridge
*bridge
,
99 struct drm_connector
*connector
)
101 struct exynos_dp_device
*dp
= to_dp(plat_data
);
102 struct drm_encoder
*encoder
= &dp
->encoder
;
105 drm_connector_register(connector
);
107 /* Pre-empt DP connector creation if there's a bridge */
108 if (dp
->ptn_bridge
) {
109 bridge
->next
= dp
->ptn_bridge
;
110 dp
->ptn_bridge
->encoder
= encoder
;
111 ret
= drm_bridge_attach(encoder
->dev
, dp
->ptn_bridge
);
113 DRM_ERROR("Failed to attach bridge to drm\n");
122 static void exynos_dp_mode_set(struct drm_encoder
*encoder
,
123 struct drm_display_mode
*mode
,
124 struct drm_display_mode
*adjusted_mode
)
128 static void exynos_dp_nop(struct drm_encoder
*encoder
)
133 static const struct drm_encoder_helper_funcs exynos_dp_encoder_helper_funcs
= {
134 .mode_set
= exynos_dp_mode_set
,
135 .enable
= exynos_dp_nop
,
136 .disable
= exynos_dp_nop
,
139 static const struct drm_encoder_funcs exynos_dp_encoder_funcs
= {
140 .destroy
= drm_encoder_cleanup
,
143 static int exynos_dp_dt_parse_panel(struct exynos_dp_device
*dp
)
147 ret
= of_get_videomode(dp
->dev
->of_node
, &dp
->vm
, OF_USE_NATIVE_MODE
);
149 DRM_ERROR("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 * Just like the probe function said, we don't need the
164 * device drvrate anymore, we should leave the charge to
165 * analogix dp driver, set the device drvdata to NULL.
167 dev_set_drvdata(dev
, NULL
);
170 dp
->drm_dev
= drm_dev
;
172 dp
->plat_data
.dev_type
= EXYNOS_DP
;
173 dp
->plat_data
.power_on
= exynos_dp_poweron
;
174 dp
->plat_data
.power_off
= exynos_dp_poweroff
;
175 dp
->plat_data
.attach
= exynos_dp_bridge_attach
;
176 dp
->plat_data
.get_modes
= exynos_dp_get_modes
;
178 if (!dp
->plat_data
.panel
&& !dp
->ptn_bridge
) {
179 ret
= exynos_dp_dt_parse_panel(dp
);
184 pipe
= exynos_drm_crtc_get_pipe_from_type(drm_dev
,
185 EXYNOS_DISPLAY_TYPE_LCD
);
189 encoder
->possible_crtcs
= 1 << pipe
;
191 DRM_DEBUG_KMS("possible_crtcs = 0x%x\n", encoder
->possible_crtcs
);
193 drm_encoder_init(drm_dev
, encoder
, &exynos_dp_encoder_funcs
,
194 DRM_MODE_ENCODER_TMDS
, NULL
);
196 drm_encoder_helper_add(encoder
, &exynos_dp_encoder_helper_funcs
);
198 dp
->plat_data
.encoder
= encoder
;
200 return analogix_dp_bind(dev
, dp
->drm_dev
, &dp
->plat_data
);
203 static void exynos_dp_unbind(struct device
*dev
, struct device
*master
,
206 return analogix_dp_unbind(dev
, master
, data
);
209 static const struct component_ops exynos_dp_ops
= {
210 .bind
= exynos_dp_bind
,
211 .unbind
= exynos_dp_unbind
,
214 static int exynos_dp_probe(struct platform_device
*pdev
)
216 struct device
*dev
= &pdev
->dev
;
217 struct device_node
*np
= NULL
, *endpoint
= NULL
;
218 struct exynos_dp_device
*dp
;
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
);
237 if (!dp
->plat_data
.panel
)
238 return -EPROBE_DEFER
;
242 endpoint
= of_graph_get_next_endpoint(dev
->of_node
, NULL
);
244 np
= of_graph_get_remote_port_parent(endpoint
);
246 /* The remote port can be either a panel or a bridge */
247 dp
->plat_data
.panel
= of_drm_find_panel(np
);
248 if (!dp
->plat_data
.panel
) {
249 dp
->ptn_bridge
= of_drm_find_bridge(np
);
250 if (!dp
->ptn_bridge
) {
252 return -EPROBE_DEFER
;
257 DRM_ERROR("no remote endpoint device node found.\n");
261 DRM_ERROR("no port endpoint subnode found.\n");
266 return component_add(&pdev
->dev
, &exynos_dp_ops
);
269 static int exynos_dp_remove(struct platform_device
*pdev
)
271 component_del(&pdev
->dev
, &exynos_dp_ops
);
277 static int exynos_dp_suspend(struct device
*dev
)
279 return analogix_dp_suspend(dev
);
282 static int exynos_dp_resume(struct device
*dev
)
284 return analogix_dp_resume(dev
);
288 static const struct dev_pm_ops exynos_dp_pm_ops
= {
289 SET_RUNTIME_PM_OPS(exynos_dp_suspend
, exynos_dp_resume
, NULL
)
292 static const struct of_device_id exynos_dp_match
[] = {
293 { .compatible
= "samsung,exynos5-dp" },
296 MODULE_DEVICE_TABLE(of
, exynos_dp_match
);
298 struct platform_driver dp_driver
= {
299 .probe
= exynos_dp_probe
,
300 .remove
= exynos_dp_remove
,
303 .owner
= THIS_MODULE
,
304 .pm
= &exynos_dp_pm_ops
,
305 .of_match_table
= exynos_dp_match
,
309 MODULE_AUTHOR("Jingoo Han <jg1.han@samsung.com>");
310 MODULE_DESCRIPTION("Samsung Specific Analogix-DP Driver Extension");
311 MODULE_LICENSE("GPL v2");