Version:  2.6.34 2.6.35 2.6.36 2.6.37 2.6.38 2.6.39 3.0 3.1 3.2 3.3 3.4 3.5 3.6 3.7 3.8 3.9 3.10 3.11 3.12 3.13 3.14

Linux/drivers/gpu/drm/exynos/exynos_drm_vidi.c

  1 /* exynos_drm_vidi.c
  2  *
  3  * Copyright (C) 2012 Samsung Electronics Co.Ltd
  4  * Authors:
  5  *      Inki Dae <inki.dae@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 <drm/drmP.h>
 14 
 15 #include <linux/kernel.h>
 16 #include <linux/platform_device.h>
 17 
 18 #include <drm/exynos_drm.h>
 19 
 20 #include <drm/drm_edid.h>
 21 #include <drm/drm_crtc_helper.h>
 22 
 23 #include "exynos_drm_drv.h"
 24 #include "exynos_drm_crtc.h"
 25 #include "exynos_drm_encoder.h"
 26 #include "exynos_drm_vidi.h"
 27 
 28 /* vidi has totally three virtual windows. */
 29 #define WINDOWS_NR              3
 30 
 31 #define get_vidi_context(dev)   platform_get_drvdata(to_platform_device(dev))
 32 
 33 struct vidi_win_data {
 34         unsigned int            offset_x;
 35         unsigned int            offset_y;
 36         unsigned int            ovl_width;
 37         unsigned int            ovl_height;
 38         unsigned int            fb_width;
 39         unsigned int            fb_height;
 40         unsigned int            bpp;
 41         dma_addr_t              dma_addr;
 42         unsigned int            buf_offsize;
 43         unsigned int            line_size;      /* bytes */
 44         bool                    enabled;
 45 };
 46 
 47 struct vidi_context {
 48         struct exynos_drm_subdrv        subdrv;
 49         struct drm_crtc                 *crtc;
 50         struct vidi_win_data            win_data[WINDOWS_NR];
 51         struct edid                     *raw_edid;
 52         unsigned int                    clkdiv;
 53         unsigned int                    default_win;
 54         unsigned long                   irq_flags;
 55         unsigned int                    connected;
 56         bool                            vblank_on;
 57         bool                            suspended;
 58         bool                            direct_vblank;
 59         struct work_struct              work;
 60         struct mutex                    lock;
 61 };
 62 
 63 static const char fake_edid_info[] = {
 64         0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x4c, 0x2d, 0x05, 0x05,
 65         0x00, 0x00, 0x00, 0x00, 0x30, 0x12, 0x01, 0x03, 0x80, 0x10, 0x09, 0x78,
 66         0x0a, 0xee, 0x91, 0xa3, 0x54, 0x4c, 0x99, 0x26, 0x0f, 0x50, 0x54, 0xbd,
 67         0xee, 0x00, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
 68         0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x66, 0x21, 0x50, 0xb0, 0x51, 0x00,
 69         0x1b, 0x30, 0x40, 0x70, 0x36, 0x00, 0xa0, 0x5a, 0x00, 0x00, 0x00, 0x1e,
 70         0x01, 0x1d, 0x00, 0x72, 0x51, 0xd0, 0x1e, 0x20, 0x6e, 0x28, 0x55, 0x00,
 71         0xa0, 0x5a, 0x00, 0x00, 0x00, 0x1e, 0x00, 0x00, 0x00, 0xfd, 0x00, 0x18,
 72         0x4b, 0x1a, 0x44, 0x17, 0x00, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
 73         0x00, 0x00, 0x00, 0xfc, 0x00, 0x53, 0x41, 0x4d, 0x53, 0x55, 0x4e, 0x47,
 74         0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x01, 0xbc, 0x02, 0x03, 0x1e, 0xf1,
 75         0x46, 0x84, 0x05, 0x03, 0x10, 0x20, 0x22, 0x23, 0x09, 0x07, 0x07, 0x83,
 76         0x01, 0x00, 0x00, 0xe2, 0x00, 0x0f, 0x67, 0x03, 0x0c, 0x00, 0x10, 0x00,
 77         0xb8, 0x2d, 0x01, 0x1d, 0x80, 0x18, 0x71, 0x1c, 0x16, 0x20, 0x58, 0x2c,
 78         0x25, 0x00, 0xa0, 0x5a, 0x00, 0x00, 0x00, 0x9e, 0x8c, 0x0a, 0xd0, 0x8a,
 79         0x20, 0xe0, 0x2d, 0x10, 0x10, 0x3e, 0x96, 0x00, 0xa0, 0x5a, 0x00, 0x00,
 80         0x00, 0x18, 0x02, 0x3a, 0x80, 0x18, 0x71, 0x38, 0x2d, 0x40, 0x58, 0x2c,
 81         0x45, 0x00, 0xa0, 0x5a, 0x00, 0x00, 0x00, 0x1e, 0x00, 0x00, 0x00, 0x00,
 82         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 83         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 84         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 85         0x00, 0x00, 0x00, 0x06
 86 };
 87 
 88 static bool vidi_display_is_connected(struct device *dev)
 89 {
 90         struct vidi_context *ctx = get_vidi_context(dev);
 91 
 92         /*
 93          * connection request would come from user side
 94          * to do hotplug through specific ioctl.
 95          */
 96         return ctx->connected ? true : false;
 97 }
 98 
 99 static struct edid *vidi_get_edid(struct device *dev,
100                         struct drm_connector *connector)
101 {
102         struct vidi_context *ctx = get_vidi_context(dev);
103         struct edid *edid;
104 
105         /*
106          * the edid data comes from user side and it would be set
107          * to ctx->raw_edid through specific ioctl.
108          */
109         if (!ctx->raw_edid) {
110                 DRM_DEBUG_KMS("raw_edid is null.\n");
111                 return ERR_PTR(-EFAULT);
112         }
113 
114         edid = drm_edid_duplicate(ctx->raw_edid);
115         if (!edid) {
116                 DRM_DEBUG_KMS("failed to allocate edid\n");
117                 return ERR_PTR(-ENOMEM);
118         }
119 
120         return edid;
121 }
122 
123 static void *vidi_get_panel(struct device *dev)
124 {
125         /* TODO. */
126 
127         return NULL;
128 }
129 
130 static int vidi_check_mode(struct device *dev, struct drm_display_mode *mode)
131 {
132         /* TODO. */
133 
134         return 0;
135 }
136 
137 static int vidi_display_power_on(struct device *dev, int mode)
138 {
139         /* TODO */
140 
141         return 0;
142 }
143 
144 static struct exynos_drm_display_ops vidi_display_ops = {
145         .type = EXYNOS_DISPLAY_TYPE_VIDI,
146         .is_connected = vidi_display_is_connected,
147         .get_edid = vidi_get_edid,
148         .get_panel = vidi_get_panel,
149         .check_mode = vidi_check_mode,
150         .power_on = vidi_display_power_on,
151 };
152 
153 static void vidi_dpms(struct device *subdrv_dev, int mode)
154 {
155         struct vidi_context *ctx = get_vidi_context(subdrv_dev);
156 
157         DRM_DEBUG_KMS("%d\n", mode);
158 
159         mutex_lock(&ctx->lock);
160 
161         switch (mode) {
162         case DRM_MODE_DPMS_ON:
163                 /* TODO. */
164                 break;
165         case DRM_MODE_DPMS_STANDBY:
166         case DRM_MODE_DPMS_SUSPEND:
167         case DRM_MODE_DPMS_OFF:
168                 /* TODO. */
169                 break;
170         default:
171                 DRM_DEBUG_KMS("unspecified mode %d\n", mode);
172                 break;
173         }
174 
175         mutex_unlock(&ctx->lock);
176 }
177 
178 static void vidi_apply(struct device *subdrv_dev)
179 {
180         struct vidi_context *ctx = get_vidi_context(subdrv_dev);
181         struct exynos_drm_manager *mgr = ctx->subdrv.manager;
182         struct exynos_drm_manager_ops *mgr_ops = mgr->ops;
183         struct exynos_drm_overlay_ops *ovl_ops = mgr->overlay_ops;
184         struct vidi_win_data *win_data;
185         int i;
186 
187         for (i = 0; i < WINDOWS_NR; i++) {
188                 win_data = &ctx->win_data[i];
189                 if (win_data->enabled && (ovl_ops && ovl_ops->commit))
190                         ovl_ops->commit(subdrv_dev, i);
191         }
192 
193         if (mgr_ops && mgr_ops->commit)
194                 mgr_ops->commit(subdrv_dev);
195 }
196 
197 static void vidi_commit(struct device *dev)
198 {
199         struct vidi_context *ctx = get_vidi_context(dev);
200 
201         if (ctx->suspended)
202                 return;
203 }
204 
205 static int vidi_enable_vblank(struct device *dev)
206 {
207         struct vidi_context *ctx = get_vidi_context(dev);
208 
209         if (ctx->suspended)
210                 return -EPERM;
211 
212         if (!test_and_set_bit(0, &ctx->irq_flags))
213                 ctx->vblank_on = true;
214 
215         ctx->direct_vblank = true;
216 
217         /*
218          * in case of page flip request, vidi_finish_pageflip function
219          * will not be called because direct_vblank is true and then
220          * that function will be called by overlay_ops->commit callback
221          */
222         schedule_work(&ctx->work);
223 
224         return 0;
225 }
226 
227 static void vidi_disable_vblank(struct device *dev)
228 {
229         struct vidi_context *ctx = get_vidi_context(dev);
230 
231         if (ctx->suspended)
232                 return;
233 
234         if (test_and_clear_bit(0, &ctx->irq_flags))
235                 ctx->vblank_on = false;
236 }
237 
238 static struct exynos_drm_manager_ops vidi_manager_ops = {
239         .dpms = vidi_dpms,
240         .apply = vidi_apply,
241         .commit = vidi_commit,
242         .enable_vblank = vidi_enable_vblank,
243         .disable_vblank = vidi_disable_vblank,
244 };
245 
246 static void vidi_win_mode_set(struct device *dev,
247                               struct exynos_drm_overlay *overlay)
248 {
249         struct vidi_context *ctx = get_vidi_context(dev);
250         struct vidi_win_data *win_data;
251         int win;
252         unsigned long offset;
253 
254         if (!overlay) {
255                 dev_err(dev, "overlay is NULL\n");
256                 return;
257         }
258 
259         win = overlay->zpos;
260         if (win == DEFAULT_ZPOS)
261                 win = ctx->default_win;
262 
263         if (win < 0 || win >= WINDOWS_NR)
264                 return;
265 
266         offset = overlay->fb_x * (overlay->bpp >> 3);
267         offset += overlay->fb_y * overlay->pitch;
268 
269         DRM_DEBUG_KMS("offset = 0x%lx, pitch = %x\n", offset, overlay->pitch);
270 
271         win_data = &ctx->win_data[win];
272 
273         win_data->offset_x = overlay->crtc_x;
274         win_data->offset_y = overlay->crtc_y;
275         win_data->ovl_width = overlay->crtc_width;
276         win_data->ovl_height = overlay->crtc_height;
277         win_data->fb_width = overlay->fb_width;
278         win_data->fb_height = overlay->fb_height;
279         win_data->dma_addr = overlay->dma_addr[0] + offset;
280         win_data->bpp = overlay->bpp;
281         win_data->buf_offsize = (overlay->fb_width - overlay->crtc_width) *
282                                 (overlay->bpp >> 3);
283         win_data->line_size = overlay->crtc_width * (overlay->bpp >> 3);
284 
285         /*
286          * some parts of win_data should be transferred to user side
287          * through specific ioctl.
288          */
289 
290         DRM_DEBUG_KMS("offset_x = %d, offset_y = %d\n",
291                         win_data->offset_x, win_data->offset_y);
292         DRM_DEBUG_KMS("ovl_width = %d, ovl_height = %d\n",
293                         win_data->ovl_width, win_data->ovl_height);
294         DRM_DEBUG_KMS("paddr = 0x%lx\n", (unsigned long)win_data->dma_addr);
295         DRM_DEBUG_KMS("fb_width = %d, crtc_width = %d\n",
296                         overlay->fb_width, overlay->crtc_width);
297 }
298 
299 static void vidi_win_commit(struct device *dev, int zpos)
300 {
301         struct vidi_context *ctx = get_vidi_context(dev);
302         struct vidi_win_data *win_data;
303         int win = zpos;
304 
305         if (ctx->suspended)
306                 return;
307 
308         if (win == DEFAULT_ZPOS)
309                 win = ctx->default_win;
310 
311         if (win < 0 || win >= WINDOWS_NR)
312                 return;
313 
314         win_data = &ctx->win_data[win];
315 
316         win_data->enabled = true;
317 
318         DRM_DEBUG_KMS("dma_addr = 0x%x\n", win_data->dma_addr);
319 
320         if (ctx->vblank_on)
321                 schedule_work(&ctx->work);
322 }
323 
324 static void vidi_win_disable(struct device *dev, int zpos)
325 {
326         struct vidi_context *ctx = get_vidi_context(dev);
327         struct vidi_win_data *win_data;
328         int win = zpos;
329 
330         if (win == DEFAULT_ZPOS)
331                 win = ctx->default_win;
332 
333         if (win < 0 || win >= WINDOWS_NR)
334                 return;
335 
336         win_data = &ctx->win_data[win];
337         win_data->enabled = false;
338 
339         /* TODO. */
340 }
341 
342 static struct exynos_drm_overlay_ops vidi_overlay_ops = {
343         .mode_set = vidi_win_mode_set,
344         .commit = vidi_win_commit,
345         .disable = vidi_win_disable,
346 };
347 
348 static struct exynos_drm_manager vidi_manager = {
349         .pipe           = -1,
350         .ops            = &vidi_manager_ops,
351         .overlay_ops    = &vidi_overlay_ops,
352         .display_ops    = &vidi_display_ops,
353 };
354 
355 static void vidi_fake_vblank_handler(struct work_struct *work)
356 {
357         struct vidi_context *ctx = container_of(work, struct vidi_context,
358                                         work);
359         struct exynos_drm_subdrv *subdrv = &ctx->subdrv;
360         struct exynos_drm_manager *manager = subdrv->manager;
361 
362         if (manager->pipe < 0)
363                 return;
364 
365         /* refresh rate is about 50Hz. */
366         usleep_range(16000, 20000);
367 
368         mutex_lock(&ctx->lock);
369 
370         if (ctx->direct_vblank) {
371                 drm_handle_vblank(subdrv->drm_dev, manager->pipe);
372                 ctx->direct_vblank = false;
373                 mutex_unlock(&ctx->lock);
374                 return;
375         }
376 
377         mutex_unlock(&ctx->lock);
378 
379         exynos_drm_crtc_finish_pageflip(subdrv->drm_dev, manager->pipe);
380 }
381 
382 static int vidi_subdrv_probe(struct drm_device *drm_dev, struct device *dev)
383 {
384         /*
385          * enable drm irq mode.
386          * - with irq_enabled = true, we can use the vblank feature.
387          *
388          * P.S. note that we wouldn't use drm irq handler but
389          *      just specific driver own one instead because
390          *      drm framework supports only one irq handler.
391          */
392         drm_dev->irq_enabled = true;
393 
394         /*
395          * with vblank_disable_allowed = true, vblank interrupt will be disabled
396          * by drm timer once a current process gives up ownership of
397          * vblank event.(after drm_vblank_put function is called)
398          */
399         drm_dev->vblank_disable_allowed = true;
400 
401         return 0;
402 }
403 
404 static void vidi_subdrv_remove(struct drm_device *drm_dev, struct device *dev)
405 {
406         /* TODO. */
407 }
408 
409 static int vidi_power_on(struct vidi_context *ctx, bool enable)
410 {
411         struct exynos_drm_subdrv *subdrv = &ctx->subdrv;
412         struct device *dev = subdrv->dev;
413 
414         if (enable) {
415                 ctx->suspended = false;
416 
417                 /* if vblank was enabled status, enable it again. */
418                 if (test_and_clear_bit(0, &ctx->irq_flags))
419                         vidi_enable_vblank(dev);
420 
421                 vidi_apply(dev);
422         } else {
423                 ctx->suspended = true;
424         }
425 
426         return 0;
427 }
428 
429 static int vidi_show_connection(struct device *dev,
430                                 struct device_attribute *attr, char *buf)
431 {
432         int rc;
433         struct vidi_context *ctx = get_vidi_context(dev);
434 
435         mutex_lock(&ctx->lock);
436 
437         rc = sprintf(buf, "%d\n", ctx->connected);
438 
439         mutex_unlock(&ctx->lock);
440 
441         return rc;
442 }
443 
444 static int vidi_store_connection(struct device *dev,
445                                 struct device_attribute *attr,
446                                 const char *buf, size_t len)
447 {
448         struct vidi_context *ctx = get_vidi_context(dev);
449         int ret;
450 
451         ret = kstrtoint(buf, 0, &ctx->connected);
452         if (ret)
453                 return ret;
454 
455         if (ctx->connected > 1)
456                 return -EINVAL;
457 
458         /* use fake edid data for test. */
459         if (!ctx->raw_edid)
460                 ctx->raw_edid = (struct edid *)fake_edid_info;
461 
462         /* if raw_edid isn't same as fake data then it can't be tested. */
463         if (ctx->raw_edid != (struct edid *)fake_edid_info) {
464                 DRM_DEBUG_KMS("edid data is not fake data.\n");
465                 return -EINVAL;
466         }
467 
468         DRM_DEBUG_KMS("requested connection.\n");
469 
470         drm_helper_hpd_irq_event(ctx->subdrv.drm_dev);
471 
472         return len;
473 }
474 
475 static DEVICE_ATTR(connection, 0644, vidi_show_connection,
476                         vidi_store_connection);
477 
478 int vidi_connection_ioctl(struct drm_device *drm_dev, void *data,
479                                 struct drm_file *file_priv)
480 {
481         struct vidi_context *ctx = NULL;
482         struct drm_encoder *encoder;
483         struct exynos_drm_manager *manager;
484         struct exynos_drm_display_ops *display_ops;
485         struct drm_exynos_vidi_connection *vidi = data;
486 
487         if (!vidi) {
488                 DRM_DEBUG_KMS("user data for vidi is null.\n");
489                 return -EINVAL;
490         }
491 
492         if (vidi->connection > 1) {
493                 DRM_DEBUG_KMS("connection should be 0 or 1.\n");
494                 return -EINVAL;
495         }
496 
497         list_for_each_entry(encoder, &drm_dev->mode_config.encoder_list,
498                                                                 head) {
499                 manager = exynos_drm_get_manager(encoder);
500                 display_ops = manager->display_ops;
501 
502                 if (display_ops->type == EXYNOS_DISPLAY_TYPE_VIDI) {
503                         ctx = get_vidi_context(manager->dev);
504                         break;
505                 }
506         }
507 
508         if (!ctx) {
509                 DRM_DEBUG_KMS("not found virtual device type encoder.\n");
510                 return -EINVAL;
511         }
512 
513         if (ctx->connected == vidi->connection) {
514                 DRM_DEBUG_KMS("same connection request.\n");
515                 return -EINVAL;
516         }
517 
518         if (vidi->connection) {
519                 struct edid *raw_edid  = (struct edid *)(uint32_t)vidi->edid;
520                 if (!drm_edid_is_valid(raw_edid)) {
521                         DRM_DEBUG_KMS("edid data is invalid.\n");
522                         return -EINVAL;
523                 }
524                 ctx->raw_edid = drm_edid_duplicate(raw_edid);
525                 if (!ctx->raw_edid) {
526                         DRM_DEBUG_KMS("failed to allocate raw_edid.\n");
527                         return -ENOMEM;
528                 }
529         } else {
530                 /*
531                  * with connection = 0, free raw_edid
532                  * only if raw edid data isn't same as fake data.
533                  */
534                 if (ctx->raw_edid && ctx->raw_edid !=
535                                 (struct edid *)fake_edid_info) {
536                         kfree(ctx->raw_edid);
537                         ctx->raw_edid = NULL;
538                 }
539         }
540 
541         ctx->connected = vidi->connection;
542         drm_helper_hpd_irq_event(ctx->subdrv.drm_dev);
543 
544         return 0;
545 }
546 
547 static int vidi_probe(struct platform_device *pdev)
548 {
549         struct device *dev = &pdev->dev;
550         struct vidi_context *ctx;
551         struct exynos_drm_subdrv *subdrv;
552         int ret;
553 
554         ctx = devm_kzalloc(dev, sizeof(*ctx), GFP_KERNEL);
555         if (!ctx)
556                 return -ENOMEM;
557 
558         ctx->default_win = 0;
559 
560         INIT_WORK(&ctx->work, vidi_fake_vblank_handler);
561 
562         subdrv = &ctx->subdrv;
563         subdrv->dev = dev;
564         subdrv->manager = &vidi_manager;
565         subdrv->probe = vidi_subdrv_probe;
566         subdrv->remove = vidi_subdrv_remove;
567 
568         mutex_init(&ctx->lock);
569 
570         platform_set_drvdata(pdev, ctx);
571 
572         ret = device_create_file(dev, &dev_attr_connection);
573         if (ret < 0)
574                 DRM_INFO("failed to create connection sysfs.\n");
575 
576         exynos_drm_subdrv_register(subdrv);
577 
578         return 0;
579 }
580 
581 static int vidi_remove(struct platform_device *pdev)
582 {
583         struct vidi_context *ctx = platform_get_drvdata(pdev);
584 
585         exynos_drm_subdrv_unregister(&ctx->subdrv);
586 
587         if (ctx->raw_edid != (struct edid *)fake_edid_info) {
588                 kfree(ctx->raw_edid);
589                 ctx->raw_edid = NULL;
590         }
591 
592         return 0;
593 }
594 
595 #ifdef CONFIG_PM_SLEEP
596 static int vidi_suspend(struct device *dev)
597 {
598         struct vidi_context *ctx = get_vidi_context(dev);
599 
600         return vidi_power_on(ctx, false);
601 }
602 
603 static int vidi_resume(struct device *dev)
604 {
605         struct vidi_context *ctx = get_vidi_context(dev);
606 
607         return vidi_power_on(ctx, true);
608 }
609 #endif
610 
611 static const struct dev_pm_ops vidi_pm_ops = {
612         SET_SYSTEM_SLEEP_PM_OPS(vidi_suspend, vidi_resume)
613 };
614 
615 struct platform_driver vidi_driver = {
616         .probe          = vidi_probe,
617         .remove         = vidi_remove,
618         .driver         = {
619                 .name   = "exynos-drm-vidi",
620                 .owner  = THIS_MODULE,
621                 .pm     = &vidi_pm_ops,
622         },
623 };
624 

This page was automatically generated by LXR 0.3.1 (source).  •  Linux is a registered trademark of Linus Torvalds  •  Contact us