Merge branch 'sh/nommu' into sh-latest
[pandora-kernel.git] / drivers / gpu / drm / exynos / exynos_drm_hdmi.c
1 /*
2  * Copyright (C) 2011 Samsung Electronics Co.Ltd
3  * Authors:
4  *      Inki Dae <inki.dae@samsung.com>
5  *      Seung-Woo Kim <sw0312.kim@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
14 #include "drmP.h"
15
16 #include <linux/kernel.h>
17 #include <linux/wait.h>
18 #include <linux/module.h>
19 #include <linux/platform_device.h>
20 #include <linux/pm_runtime.h>
21
22 #include <drm/exynos_drm.h>
23
24 #include "exynos_drm_drv.h"
25 #include "exynos_drm_hdmi.h"
26
27 #define to_context(dev)         platform_get_drvdata(to_platform_device(dev))
28 #define to_subdrv(dev)          to_context(dev)
29 #define get_ctx_from_subdrv(subdrv)     container_of(subdrv,\
30                                         struct drm_hdmi_context, subdrv);
31
32 /* these callback points shoud be set by specific drivers. */
33 static struct exynos_hdmi_display_ops *hdmi_display_ops;
34 static struct exynos_hdmi_manager_ops *hdmi_manager_ops;
35 static struct exynos_hdmi_overlay_ops *hdmi_overlay_ops;
36
37 struct drm_hdmi_context {
38         struct exynos_drm_subdrv        subdrv;
39         struct exynos_drm_hdmi_context  *hdmi_ctx;
40         struct exynos_drm_hdmi_context  *mixer_ctx;
41         struct work_struct              work;
42 };
43
44 void exynos_drm_display_ops_register(struct exynos_hdmi_display_ops
45                                         *display_ops)
46 {
47         DRM_DEBUG_KMS("%s\n", __FILE__);
48
49         if (display_ops)
50                 hdmi_display_ops = display_ops;
51 }
52 EXPORT_SYMBOL(exynos_drm_display_ops_register);
53
54 void exynos_drm_manager_ops_register(struct exynos_hdmi_manager_ops
55                                         *manager_ops)
56 {
57         DRM_DEBUG_KMS("%s\n", __FILE__);
58
59         if (manager_ops)
60                 hdmi_manager_ops = manager_ops;
61 }
62 EXPORT_SYMBOL(exynos_drm_manager_ops_register);
63
64 void exynos_drm_overlay_ops_register(struct exynos_hdmi_overlay_ops
65                                         *overlay_ops)
66 {
67         DRM_DEBUG_KMS("%s\n", __FILE__);
68
69         if (overlay_ops)
70                 hdmi_overlay_ops = overlay_ops;
71 }
72 EXPORT_SYMBOL(exynos_drm_overlay_ops_register);
73
74 static bool drm_hdmi_is_connected(struct device *dev)
75 {
76         struct drm_hdmi_context *ctx = to_context(dev);
77
78         DRM_DEBUG_KMS("%s\n", __FILE__);
79
80         if (hdmi_display_ops && hdmi_display_ops->is_connected)
81                 return hdmi_display_ops->is_connected(ctx->hdmi_ctx->ctx);
82
83         return false;
84 }
85
86 static int drm_hdmi_get_edid(struct device *dev,
87                 struct drm_connector *connector, u8 *edid, int len)
88 {
89         struct drm_hdmi_context *ctx = to_context(dev);
90
91         DRM_DEBUG_KMS("%s\n", __FILE__);
92
93         if (hdmi_display_ops && hdmi_display_ops->get_edid)
94                 return hdmi_display_ops->get_edid(ctx->hdmi_ctx->ctx,
95                                 connector, edid, len);
96
97         return 0;
98 }
99
100 static int drm_hdmi_check_timing(struct device *dev, void *timing)
101 {
102         struct drm_hdmi_context *ctx = to_context(dev);
103
104         DRM_DEBUG_KMS("%s\n", __FILE__);
105
106         if (hdmi_display_ops && hdmi_display_ops->check_timing)
107                 return hdmi_display_ops->check_timing(ctx->hdmi_ctx->ctx,
108                                 timing);
109
110         return 0;
111 }
112
113 static int drm_hdmi_power_on(struct device *dev, int mode)
114 {
115         struct drm_hdmi_context *ctx = to_context(dev);
116
117         DRM_DEBUG_KMS("%s\n", __FILE__);
118
119         if (hdmi_display_ops && hdmi_display_ops->power_on)
120                 return hdmi_display_ops->power_on(ctx->hdmi_ctx->ctx, mode);
121
122         return 0;
123 }
124
125 static struct exynos_drm_display_ops drm_hdmi_display_ops = {
126         .type = EXYNOS_DISPLAY_TYPE_HDMI,
127         .is_connected = drm_hdmi_is_connected,
128         .get_edid = drm_hdmi_get_edid,
129         .check_timing = drm_hdmi_check_timing,
130         .power_on = drm_hdmi_power_on,
131 };
132
133 static int drm_hdmi_enable_vblank(struct device *subdrv_dev)
134 {
135         struct drm_hdmi_context *ctx = to_context(subdrv_dev);
136         struct exynos_drm_subdrv *subdrv = &ctx->subdrv;
137         struct exynos_drm_manager *manager = &subdrv->manager;
138
139         DRM_DEBUG_KMS("%s\n", __FILE__);
140
141         if (hdmi_overlay_ops && hdmi_overlay_ops->enable_vblank)
142                 return hdmi_overlay_ops->enable_vblank(ctx->mixer_ctx->ctx,
143                                                         manager->pipe);
144
145         return 0;
146 }
147
148 static void drm_hdmi_disable_vblank(struct device *subdrv_dev)
149 {
150         struct drm_hdmi_context *ctx = to_context(subdrv_dev);
151
152         DRM_DEBUG_KMS("%s\n", __FILE__);
153
154         if (hdmi_overlay_ops && hdmi_overlay_ops->disable_vblank)
155                 return hdmi_overlay_ops->disable_vblank(ctx->mixer_ctx->ctx);
156 }
157
158 static void drm_hdmi_mode_set(struct device *subdrv_dev, void *mode)
159 {
160         struct drm_hdmi_context *ctx = to_context(subdrv_dev);
161
162         DRM_DEBUG_KMS("%s\n", __FILE__);
163
164         if (hdmi_manager_ops && hdmi_manager_ops->mode_set)
165                 hdmi_manager_ops->mode_set(ctx->hdmi_ctx->ctx, mode);
166 }
167
168 static void drm_hdmi_commit(struct device *subdrv_dev)
169 {
170         struct drm_hdmi_context *ctx = to_context(subdrv_dev);
171
172         DRM_DEBUG_KMS("%s\n", __FILE__);
173
174         if (hdmi_manager_ops && hdmi_manager_ops->commit)
175                 hdmi_manager_ops->commit(ctx->hdmi_ctx->ctx);
176 }
177
178 static void drm_hdmi_dpms(struct device *subdrv_dev, int mode)
179 {
180         struct drm_hdmi_context *ctx = to_context(subdrv_dev);
181
182         DRM_DEBUG_KMS("%s\n", __FILE__);
183
184         switch (mode) {
185         case DRM_MODE_DPMS_ON:
186                 break;
187         case DRM_MODE_DPMS_STANDBY:
188         case DRM_MODE_DPMS_SUSPEND:
189         case DRM_MODE_DPMS_OFF:
190                 if (hdmi_manager_ops && hdmi_manager_ops->disable)
191                         hdmi_manager_ops->disable(ctx->hdmi_ctx->ctx);
192                 break;
193         default:
194                 DRM_DEBUG_KMS("unkown dps mode: %d\n", mode);
195                 break;
196         }
197 }
198
199 static struct exynos_drm_manager_ops drm_hdmi_manager_ops = {
200         .dpms = drm_hdmi_dpms,
201         .enable_vblank = drm_hdmi_enable_vblank,
202         .disable_vblank = drm_hdmi_disable_vblank,
203         .mode_set = drm_hdmi_mode_set,
204         .commit = drm_hdmi_commit,
205 };
206
207 static void drm_mixer_mode_set(struct device *subdrv_dev,
208                 struct exynos_drm_overlay *overlay)
209 {
210         struct drm_hdmi_context *ctx = to_context(subdrv_dev);
211
212         DRM_DEBUG_KMS("%s\n", __FILE__);
213
214         if (hdmi_overlay_ops && hdmi_overlay_ops->win_mode_set)
215                 hdmi_overlay_ops->win_mode_set(ctx->mixer_ctx->ctx, overlay);
216 }
217
218 static void drm_mixer_commit(struct device *subdrv_dev, int zpos)
219 {
220         struct drm_hdmi_context *ctx = to_context(subdrv_dev);
221
222         DRM_DEBUG_KMS("%s\n", __FILE__);
223
224         if (hdmi_overlay_ops && hdmi_overlay_ops->win_commit)
225                 hdmi_overlay_ops->win_commit(ctx->mixer_ctx->ctx, zpos);
226 }
227
228 static void drm_mixer_disable(struct device *subdrv_dev, int zpos)
229 {
230         struct drm_hdmi_context *ctx = to_context(subdrv_dev);
231
232         DRM_DEBUG_KMS("%s\n", __FILE__);
233
234         if (hdmi_overlay_ops && hdmi_overlay_ops->win_disable)
235                 hdmi_overlay_ops->win_disable(ctx->mixer_ctx->ctx, zpos);
236 }
237
238 static struct exynos_drm_overlay_ops drm_hdmi_overlay_ops = {
239         .mode_set = drm_mixer_mode_set,
240         .commit = drm_mixer_commit,
241         .disable = drm_mixer_disable,
242 };
243
244
245 static int hdmi_subdrv_probe(struct drm_device *drm_dev,
246                 struct device *dev)
247 {
248         struct exynos_drm_subdrv *subdrv = to_subdrv(dev);
249         struct drm_hdmi_context *ctx;
250         struct platform_device *pdev = to_platform_device(dev);
251         struct exynos_drm_common_hdmi_pd *pd;
252         int ret;
253
254         DRM_DEBUG_KMS("%s\n", __FILE__);
255
256         pd = pdev->dev.platform_data;
257
258         if (!pd) {
259                 DRM_DEBUG_KMS("platform data is null.\n");
260                 return -EFAULT;
261         }
262
263         if (!pd->hdmi_dev) {
264                 DRM_DEBUG_KMS("hdmi device is null.\n");
265                 return -EFAULT;
266         }
267
268         if (!pd->mixer_dev) {
269                 DRM_DEBUG_KMS("mixer device is null.\n");
270                 return -EFAULT;
271         }
272
273         ret = platform_driver_register(&hdmi_driver);
274         if (ret) {
275                 DRM_DEBUG_KMS("failed to register hdmi driver.\n");
276                 return ret;
277         }
278
279         ret = platform_driver_register(&mixer_driver);
280         if (ret) {
281                 DRM_DEBUG_KMS("failed to register mixer driver.\n");
282                 goto err_hdmidrv;
283         }
284
285         ctx = get_ctx_from_subdrv(subdrv);
286
287         ctx->hdmi_ctx = (struct exynos_drm_hdmi_context *)
288                                 to_context(pd->hdmi_dev);
289         if (!ctx->hdmi_ctx) {
290                 DRM_DEBUG_KMS("hdmi context is null.\n");
291                 ret = -EFAULT;
292                 goto err_mixerdrv;
293         }
294
295         ctx->hdmi_ctx->drm_dev = drm_dev;
296
297         ctx->mixer_ctx = (struct exynos_drm_hdmi_context *)
298                                 to_context(pd->mixer_dev);
299         if (!ctx->mixer_ctx) {
300                 DRM_DEBUG_KMS("mixer context is null.\n");
301                 ret = -EFAULT;
302                 goto err_mixerdrv;
303         }
304
305         ctx->mixer_ctx->drm_dev = drm_dev;
306
307         return 0;
308
309 err_mixerdrv:
310         platform_driver_unregister(&mixer_driver);
311 err_hdmidrv:
312         platform_driver_unregister(&hdmi_driver);
313         return ret;
314 }
315
316 static void hdmi_subdrv_remove(struct drm_device *drm_dev)
317 {
318         DRM_DEBUG_KMS("%s\n", __FILE__);
319
320         platform_driver_unregister(&hdmi_driver);
321         platform_driver_unregister(&mixer_driver);
322 }
323
324 static void exynos_drm_hdmi_late_probe(struct work_struct *work)
325 {
326         struct drm_hdmi_context *ctx = container_of(work,
327                                 struct drm_hdmi_context, work);
328
329         /*
330          * this function calls subdrv->probe() so this must be called
331          * after probe context.
332          *
333          * PS. subdrv->probe() will call platform_driver_register() to probe
334          * hdmi and mixer driver.
335          */
336         exynos_drm_subdrv_register(&ctx->subdrv);
337 }
338
339 static int __devinit exynos_drm_hdmi_probe(struct platform_device *pdev)
340 {
341         struct device *dev = &pdev->dev;
342         struct exynos_drm_subdrv *subdrv;
343         struct drm_hdmi_context *ctx;
344
345         DRM_DEBUG_KMS("%s\n", __FILE__);
346
347         ctx = kzalloc(sizeof(*ctx), GFP_KERNEL);
348         if (!ctx) {
349                 DRM_LOG_KMS("failed to alloc common hdmi context.\n");
350                 return -ENOMEM;
351         }
352
353         subdrv = &ctx->subdrv;
354
355         subdrv->probe = hdmi_subdrv_probe;
356         subdrv->remove = hdmi_subdrv_remove;
357         subdrv->manager.pipe = -1;
358         subdrv->manager.ops = &drm_hdmi_manager_ops;
359         subdrv->manager.overlay_ops = &drm_hdmi_overlay_ops;
360         subdrv->manager.display_ops = &drm_hdmi_display_ops;
361         subdrv->manager.dev = dev;
362
363         platform_set_drvdata(pdev, subdrv);
364
365         INIT_WORK(&ctx->work, exynos_drm_hdmi_late_probe);
366
367         schedule_work(&ctx->work);
368
369         return 0;
370 }
371
372 static int hdmi_runtime_suspend(struct device *dev)
373 {
374         DRM_DEBUG_KMS("%s\n", __FILE__);
375
376         return 0;
377 }
378
379 static int hdmi_runtime_resume(struct device *dev)
380 {
381         DRM_DEBUG_KMS("%s\n", __FILE__);
382
383         return 0;
384 }
385
386 static const struct dev_pm_ops hdmi_pm_ops = {
387         .runtime_suspend = hdmi_runtime_suspend,
388         .runtime_resume  = hdmi_runtime_resume,
389 };
390
391 static int __devexit exynos_drm_hdmi_remove(struct platform_device *pdev)
392 {
393         struct drm_hdmi_context *ctx = platform_get_drvdata(pdev);
394
395         DRM_DEBUG_KMS("%s\n", __FILE__);
396
397         exynos_drm_subdrv_unregister(&ctx->subdrv);
398         kfree(ctx);
399
400         return 0;
401 }
402
403 static struct platform_driver exynos_drm_common_hdmi_driver = {
404         .probe          = exynos_drm_hdmi_probe,
405         .remove         = __devexit_p(exynos_drm_hdmi_remove),
406         .driver         = {
407                 .name   = "exynos-drm-hdmi",
408                 .owner  = THIS_MODULE,
409                 .pm = &hdmi_pm_ops,
410         },
411 };
412
413 static int __init exynos_drm_hdmi_init(void)
414 {
415         int ret;
416
417         DRM_DEBUG_KMS("%s\n", __FILE__);
418
419         ret = platform_driver_register(&exynos_drm_common_hdmi_driver);
420         if (ret) {
421                 DRM_DEBUG_KMS("failed to register hdmi common driver.\n");
422                 return ret;
423         }
424
425         return ret;
426 }
427
428 static void __exit exynos_drm_hdmi_exit(void)
429 {
430         platform_driver_unregister(&exynos_drm_common_hdmi_driver);
431 }
432
433 module_init(exynos_drm_hdmi_init);
434 module_exit(exynos_drm_hdmi_exit);
435
436 MODULE_AUTHOR("Inki Dae <inki.dae@samsung.com>");
437 MODULE_AUTHOR("Seung-Woo Kim, <sw0312.kim@samsung.com>");
438 MODULE_DESCRIPTION("Samsung SoC DRM HDMI Driver");
439 MODULE_LICENSE("GPL");