This source file includes following definitions.
- exynos_dp_crtc_clock_enable
- exynos_dp_poweron
- exynos_dp_poweroff
- exynos_dp_get_modes
- exynos_dp_bridge_attach
- exynos_dp_mode_set
- exynos_dp_nop
- exynos_dp_dt_parse_panel
- exynos_dp_bind
- exynos_dp_unbind
- exynos_dp_probe
- exynos_dp_remove
- exynos_dp_suspend
- exynos_dp_resume
1
2
3
4
5
6
7
8
9 #include <linux/clk.h>
10 #include <linux/component.h>
11 #include <linux/err.h>
12 #include <linux/module.h>
13 #include <linux/of_graph.h>
14 #include <linux/platform_device.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>
19
20 #include <drm/bridge/analogix_dp.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_print.h>
26 #include <drm/drm_probe_helper.h>
27 #include <drm/exynos_drm.h>
28
29 #include "exynos_drm_crtc.h"
30
31 #define to_dp(nm) container_of(nm, struct exynos_dp_device, nm)
32
33 struct exynos_dp_device {
34 struct drm_encoder encoder;
35 struct drm_connector *connector;
36 struct drm_bridge *ptn_bridge;
37 struct drm_device *drm_dev;
38 struct device *dev;
39
40 struct videomode vm;
41 struct analogix_dp_device *adp;
42 struct analogix_dp_plat_data plat_data;
43 };
44
45 static int exynos_dp_crtc_clock_enable(struct analogix_dp_plat_data *plat_data,
46 bool enable)
47 {
48 struct exynos_dp_device *dp = to_dp(plat_data);
49 struct drm_encoder *encoder = &dp->encoder;
50
51 if (!encoder->crtc)
52 return -EPERM;
53
54 exynos_drm_pipe_clk_enable(to_exynos_crtc(encoder->crtc), enable);
55
56 return 0;
57 }
58
59 static int exynos_dp_poweron(struct analogix_dp_plat_data *plat_data)
60 {
61 return exynos_dp_crtc_clock_enable(plat_data, true);
62 }
63
64 static int exynos_dp_poweroff(struct analogix_dp_plat_data *plat_data)
65 {
66 return exynos_dp_crtc_clock_enable(plat_data, false);
67 }
68
69 static int exynos_dp_get_modes(struct analogix_dp_plat_data *plat_data,
70 struct drm_connector *connector)
71 {
72 struct exynos_dp_device *dp = to_dp(plat_data);
73 struct drm_display_mode *mode;
74 int num_modes = 0;
75
76 if (dp->plat_data.panel)
77 return num_modes;
78
79 mode = drm_mode_create(connector->dev);
80 if (!mode) {
81 DRM_DEV_ERROR(dp->dev,
82 "failed to create a new display mode.\n");
83 return num_modes;
84 }
85
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;
89
90 mode->type = DRM_MODE_TYPE_DRIVER | DRM_MODE_TYPE_PREFERRED;
91 drm_mode_set_name(mode);
92 drm_mode_probed_add(connector, mode);
93
94 return num_modes + 1;
95 }
96
97 static int exynos_dp_bridge_attach(struct analogix_dp_plat_data *plat_data,
98 struct drm_bridge *bridge,
99 struct drm_connector *connector)
100 {
101 struct exynos_dp_device *dp = to_dp(plat_data);
102 int ret;
103
104 dp->connector = connector;
105
106
107 if (dp->ptn_bridge) {
108 ret = drm_bridge_attach(&dp->encoder, dp->ptn_bridge, bridge);
109 if (ret) {
110 DRM_DEV_ERROR(dp->dev,
111 "Failed to attach bridge to drm\n");
112 bridge->next = NULL;
113 return ret;
114 }
115 }
116
117 return 0;
118 }
119
120 static void exynos_dp_mode_set(struct drm_encoder *encoder,
121 struct drm_display_mode *mode,
122 struct drm_display_mode *adjusted_mode)
123 {
124 }
125
126 static void exynos_dp_nop(struct drm_encoder *encoder)
127 {
128
129 }
130
131 static const struct drm_encoder_helper_funcs exynos_dp_encoder_helper_funcs = {
132 .mode_set = exynos_dp_mode_set,
133 .enable = exynos_dp_nop,
134 .disable = exynos_dp_nop,
135 };
136
137 static const struct drm_encoder_funcs exynos_dp_encoder_funcs = {
138 .destroy = drm_encoder_cleanup,
139 };
140
141 static int exynos_dp_dt_parse_panel(struct exynos_dp_device *dp)
142 {
143 int ret;
144
145 ret = of_get_videomode(dp->dev->of_node, &dp->vm, OF_USE_NATIVE_MODE);
146 if (ret) {
147 DRM_DEV_ERROR(dp->dev,
148 "failed: of_get_videomode() : %d\n", ret);
149 return ret;
150 }
151 return 0;
152 }
153
154 static int exynos_dp_bind(struct device *dev, struct device *master, void *data)
155 {
156 struct exynos_dp_device *dp = dev_get_drvdata(dev);
157 struct drm_encoder *encoder = &dp->encoder;
158 struct drm_device *drm_dev = data;
159 int ret;
160
161 dp->drm_dev = drm_dev;
162
163 if (!dp->plat_data.panel && !dp->ptn_bridge) {
164 ret = exynos_dp_dt_parse_panel(dp);
165 if (ret)
166 return ret;
167 }
168
169 drm_encoder_init(drm_dev, encoder, &exynos_dp_encoder_funcs,
170 DRM_MODE_ENCODER_TMDS, NULL);
171
172 drm_encoder_helper_add(encoder, &exynos_dp_encoder_helper_funcs);
173
174 ret = exynos_drm_set_possible_crtcs(encoder, EXYNOS_DISPLAY_TYPE_LCD);
175 if (ret < 0)
176 return ret;
177
178 dp->plat_data.encoder = encoder;
179
180 ret = analogix_dp_bind(dp->adp, dp->drm_dev);
181 if (ret)
182 dp->encoder.funcs->destroy(&dp->encoder);
183
184 return ret;
185 }
186
187 static void exynos_dp_unbind(struct device *dev, struct device *master,
188 void *data)
189 {
190 struct exynos_dp_device *dp = dev_get_drvdata(dev);
191
192 analogix_dp_unbind(dp->adp);
193 dp->encoder.funcs->destroy(&dp->encoder);
194 }
195
196 static const struct component_ops exynos_dp_ops = {
197 .bind = exynos_dp_bind,
198 .unbind = exynos_dp_unbind,
199 };
200
201 static int exynos_dp_probe(struct platform_device *pdev)
202 {
203 struct device *dev = &pdev->dev;
204 struct device_node *np;
205 struct exynos_dp_device *dp;
206 struct drm_panel *panel;
207 struct drm_bridge *bridge;
208 int ret;
209
210 dp = devm_kzalloc(&pdev->dev, sizeof(struct exynos_dp_device),
211 GFP_KERNEL);
212 if (!dp)
213 return -ENOMEM;
214
215 dp->dev = dev;
216
217
218
219
220
221 platform_set_drvdata(pdev, dp);
222
223
224 np = of_parse_phandle(dev->of_node, "panel", 0);
225 if (np) {
226 dp->plat_data.panel = of_drm_find_panel(np);
227
228 of_node_put(np);
229 if (IS_ERR(dp->plat_data.panel))
230 return PTR_ERR(dp->plat_data.panel);
231
232 goto out;
233 }
234
235 ret = drm_of_find_panel_or_bridge(dev->of_node, 0, 0, &panel, &bridge);
236 if (ret)
237 return ret;
238
239
240 dp->plat_data.panel = panel;
241 dp->plat_data.dev_type = EXYNOS_DP;
242 dp->plat_data.power_on_start = exynos_dp_poweron;
243 dp->plat_data.power_off = exynos_dp_poweroff;
244 dp->plat_data.attach = exynos_dp_bridge_attach;
245 dp->plat_data.get_modes = exynos_dp_get_modes;
246 dp->plat_data.skip_connector = !!bridge;
247
248 dp->ptn_bridge = bridge;
249
250 out:
251 dp->adp = analogix_dp_probe(dev, &dp->plat_data);
252 if (IS_ERR(dp->adp))
253 return PTR_ERR(dp->adp);
254
255 return component_add(&pdev->dev, &exynos_dp_ops);
256 }
257
258 static int exynos_dp_remove(struct platform_device *pdev)
259 {
260 struct exynos_dp_device *dp = platform_get_drvdata(pdev);
261
262 component_del(&pdev->dev, &exynos_dp_ops);
263 analogix_dp_remove(dp->adp);
264
265 return 0;
266 }
267
268 #ifdef CONFIG_PM
269 static int exynos_dp_suspend(struct device *dev)
270 {
271 struct exynos_dp_device *dp = dev_get_drvdata(dev);
272
273 return analogix_dp_suspend(dp->adp);
274 }
275
276 static int exynos_dp_resume(struct device *dev)
277 {
278 struct exynos_dp_device *dp = dev_get_drvdata(dev);
279
280 return analogix_dp_resume(dp->adp);
281 }
282 #endif
283
284 static const struct dev_pm_ops exynos_dp_pm_ops = {
285 SET_RUNTIME_PM_OPS(exynos_dp_suspend, exynos_dp_resume, NULL)
286 SET_SYSTEM_SLEEP_PM_OPS(pm_runtime_force_suspend,
287 pm_runtime_force_resume)
288 };
289
290 static const struct of_device_id exynos_dp_match[] = {
291 { .compatible = "samsung,exynos5-dp" },
292 {},
293 };
294 MODULE_DEVICE_TABLE(of, exynos_dp_match);
295
296 struct platform_driver dp_driver = {
297 .probe = exynos_dp_probe,
298 .remove = exynos_dp_remove,
299 .driver = {
300 .name = "exynos-dp",
301 .owner = THIS_MODULE,
302 .pm = &exynos_dp_pm_ops,
303 .of_match_table = exynos_dp_match,
304 },
305 };
306
307 MODULE_AUTHOR("Jingoo Han <jg1.han@samsung.com>");
308 MODULE_DESCRIPTION("Samsung Specific Analogix-DP Driver Extension");
309 MODULE_LICENSE("GPL v2");