xref: /openbmc/linux/drivers/gpu/drm/exynos/exynos_dp.c (revision da2ef666)
1 /*
2  * Samsung SoC DP (Display Port) interface driver.
3  *
4  * Copyright (C) 2012 Samsung Electronics Co., Ltd.
5  * Author: Jingoo Han <jg1.han@samsung.com>
6  *
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.
11  */
12 
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 <linux/pm_runtime.h>
20 #include <video/of_display_timing.h>
21 #include <video/of_videomode.h>
22 #include <video/videomode.h>
23 
24 #include <drm/drmP.h>
25 #include <drm/drm_crtc.h>
26 #include <drm/drm_crtc_helper.h>
27 #include <drm/drm_of.h>
28 #include <drm/drm_panel.h>
29 
30 #include <drm/bridge/analogix_dp.h>
31 #include <drm/exynos_drm.h>
32 
33 #include "exynos_drm_crtc.h"
34 
35 #define to_dp(nm)	container_of(nm, struct exynos_dp_device, nm)
36 
37 struct exynos_dp_device {
38 	struct drm_encoder         encoder;
39 	struct drm_connector       *connector;
40 	struct drm_bridge          *ptn_bridge;
41 	struct drm_device          *drm_dev;
42 	struct device              *dev;
43 
44 	struct videomode           vm;
45 	struct analogix_dp_device *adp;
46 	struct analogix_dp_plat_data plat_data;
47 };
48 
49 static int exynos_dp_crtc_clock_enable(struct analogix_dp_plat_data *plat_data,
50 				bool enable)
51 {
52 	struct exynos_dp_device *dp = to_dp(plat_data);
53 	struct drm_encoder *encoder = &dp->encoder;
54 
55 	if (!encoder->crtc)
56 		return -EPERM;
57 
58 	exynos_drm_pipe_clk_enable(to_exynos_crtc(encoder->crtc), enable);
59 
60 	return 0;
61 }
62 
63 static int exynos_dp_poweron(struct analogix_dp_plat_data *plat_data)
64 {
65 	return exynos_dp_crtc_clock_enable(plat_data, true);
66 }
67 
68 static int exynos_dp_poweroff(struct analogix_dp_plat_data *plat_data)
69 {
70 	return exynos_dp_crtc_clock_enable(plat_data, false);
71 }
72 
73 static int exynos_dp_get_modes(struct analogix_dp_plat_data *plat_data,
74 			       struct drm_connector *connector)
75 {
76 	struct exynos_dp_device *dp = to_dp(plat_data);
77 	struct drm_display_mode *mode;
78 	int num_modes = 0;
79 
80 	if (dp->plat_data.panel)
81 		return num_modes;
82 
83 	mode = drm_mode_create(connector->dev);
84 	if (!mode) {
85 		DRM_ERROR("failed to create a new display mode.\n");
86 		return num_modes;
87 	}
88 
89 	drm_display_mode_from_videomode(&dp->vm, mode);
90 	connector->display_info.width_mm = mode->width_mm;
91 	connector->display_info.height_mm = mode->height_mm;
92 
93 	mode->type = DRM_MODE_TYPE_DRIVER | DRM_MODE_TYPE_PREFERRED;
94 	drm_mode_set_name(mode);
95 	drm_mode_probed_add(connector, mode);
96 
97 	return num_modes + 1;
98 }
99 
100 static int exynos_dp_bridge_attach(struct analogix_dp_plat_data *plat_data,
101 				   struct drm_bridge *bridge,
102 				   struct drm_connector *connector)
103 {
104 	struct exynos_dp_device *dp = to_dp(plat_data);
105 	int ret;
106 
107 	dp->connector = connector;
108 
109 	/* Pre-empt DP connector creation if there's a bridge */
110 	if (dp->ptn_bridge) {
111 		ret = drm_bridge_attach(&dp->encoder, dp->ptn_bridge, bridge);
112 		if (ret) {
113 			DRM_ERROR("Failed to attach bridge to drm\n");
114 			bridge->next = NULL;
115 			return ret;
116 		}
117 	}
118 
119 	return 0;
120 }
121 
122 static void exynos_dp_mode_set(struct drm_encoder *encoder,
123 			       struct drm_display_mode *mode,
124 			       struct drm_display_mode *adjusted_mode)
125 {
126 }
127 
128 static void exynos_dp_nop(struct drm_encoder *encoder)
129 {
130 	/* do nothing */
131 }
132 
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,
137 };
138 
139 static const struct drm_encoder_funcs exynos_dp_encoder_funcs = {
140 	.destroy = drm_encoder_cleanup,
141 };
142 
143 static int exynos_dp_dt_parse_panel(struct exynos_dp_device *dp)
144 {
145 	int ret;
146 
147 	ret = of_get_videomode(dp->dev->of_node, &dp->vm, OF_USE_NATIVE_MODE);
148 	if (ret) {
149 		DRM_ERROR("failed: of_get_videomode() : %d\n", ret);
150 		return ret;
151 	}
152 	return 0;
153 }
154 
155 static int exynos_dp_bind(struct device *dev, struct device *master, void *data)
156 {
157 	struct exynos_dp_device *dp = dev_get_drvdata(dev);
158 	struct drm_encoder *encoder = &dp->encoder;
159 	struct drm_device *drm_dev = data;
160 	int ret;
161 
162 	dp->dev = dev;
163 	dp->drm_dev = drm_dev;
164 
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;
170 
171 	if (!dp->plat_data.panel && !dp->ptn_bridge) {
172 		ret = exynos_dp_dt_parse_panel(dp);
173 		if (ret)
174 			return ret;
175 	}
176 
177 	drm_encoder_init(drm_dev, encoder, &exynos_dp_encoder_funcs,
178 			 DRM_MODE_ENCODER_TMDS, NULL);
179 
180 	drm_encoder_helper_add(encoder, &exynos_dp_encoder_helper_funcs);
181 
182 	ret = exynos_drm_set_possible_crtcs(encoder, EXYNOS_DISPLAY_TYPE_LCD);
183 	if (ret < 0)
184 		return ret;
185 
186 	dp->plat_data.encoder = encoder;
187 
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);
192 	}
193 
194 	return 0;
195 }
196 
197 static void exynos_dp_unbind(struct device *dev, struct device *master,
198 			     void *data)
199 {
200 	struct exynos_dp_device *dp = dev_get_drvdata(dev);
201 
202 	analogix_dp_unbind(dp->adp);
203 	dp->encoder.funcs->destroy(&dp->encoder);
204 }
205 
206 static const struct component_ops exynos_dp_ops = {
207 	.bind	= exynos_dp_bind,
208 	.unbind	= exynos_dp_unbind,
209 };
210 
211 static int exynos_dp_probe(struct platform_device *pdev)
212 {
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;
218 	int ret;
219 
220 	dp = devm_kzalloc(&pdev->dev, sizeof(struct exynos_dp_device),
221 			  GFP_KERNEL);
222 	if (!dp)
223 		return -ENOMEM;
224 
225 	/*
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.
229 	 */
230 	platform_set_drvdata(pdev, dp);
231 
232 	/* This is for the backward compatibility. */
233 	np = of_parse_phandle(dev->of_node, "panel", 0);
234 	if (np) {
235 		dp->plat_data.panel = of_drm_find_panel(np);
236 
237 		of_node_put(np);
238 		if (IS_ERR(dp->plat_data.panel))
239 			return PTR_ERR(dp->plat_data.panel);
240 
241 		goto out;
242 	}
243 
244 	ret = drm_of_find_panel_or_bridge(dev->of_node, 0, 0, &panel, &bridge);
245 	if (ret)
246 		return ret;
247 
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;
252 
253 out:
254 	return component_add(&pdev->dev, &exynos_dp_ops);
255 }
256 
257 static int exynos_dp_remove(struct platform_device *pdev)
258 {
259 	component_del(&pdev->dev, &exynos_dp_ops);
260 
261 	return 0;
262 }
263 
264 #ifdef CONFIG_PM
265 static int exynos_dp_suspend(struct device *dev)
266 {
267 	struct exynos_dp_device *dp = dev_get_drvdata(dev);
268 
269 	return analogix_dp_suspend(dp->adp);
270 }
271 
272 static int exynos_dp_resume(struct device *dev)
273 {
274 	struct exynos_dp_device *dp = dev_get_drvdata(dev);
275 
276 	return analogix_dp_resume(dp->adp);
277 }
278 #endif
279 
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)
284 };
285 
286 static const struct of_device_id exynos_dp_match[] = {
287 	{ .compatible = "samsung,exynos5-dp" },
288 	{},
289 };
290 MODULE_DEVICE_TABLE(of, exynos_dp_match);
291 
292 struct platform_driver dp_driver = {
293 	.probe		= exynos_dp_probe,
294 	.remove		= exynos_dp_remove,
295 	.driver		= {
296 		.name	= "exynos-dp",
297 		.owner	= THIS_MODULE,
298 		.pm	= &exynos_dp_pm_ops,
299 		.of_match_table = exynos_dp_match,
300 	},
301 };
302 
303 MODULE_AUTHOR("Jingoo Han <jg1.han@samsung.com>");
304 MODULE_DESCRIPTION("Samsung Specific Analogix-DP Driver Extension");
305 MODULE_LICENSE("GPL v2");
306