Version:  2.0.40 2.2.26 2.4.37 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 3.15

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

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