drivers/gpu/drm/exynos/exynos7_drm_decon.c

   1 /* drivers/gpu/drm/exynos/exynos7_drm_decon.c
   2  *
   3  * Copyright (C) 2014 Samsung Electronics Co.Ltd
   4  * Authors:
   5  *      Akshu Agarwal <akshua@gmail.com>
   6  *      Ajay Kumar <ajaykumar.rs@samsung.com>
   7  *
   8  * This program is free software; you can redistribute  it and/or modify it
   9  * under  the terms of  the GNU General  Public License as published by the
  10  * Free Software Foundation;  either version 2 of the  License, or (at your
  11  * option) any later version.
  12  *
  13  */
  14 #include <drm/drmP.h>
  15 #include <drm/exynos_drm.h>
  16
  17 #include <linux/clk.h>
  18 #include <linux/component.h>
  19 #include <linux/kernel.h>
  20 #include <linux/of.h>
  21 #include <linux/of_address.h>
  22 #include <linux/of_device.h>
  23 #include <linux/platform_device.h>
  24 #include <linux/pm_runtime.h>
  25
  26 #include <video/of_display_timing.h>
  27 #include <video/of_videomode.h>
  28 #include <video/exynos7_decon.h>
  29
  30 #include "exynos_drm_crtc.h"
  31 #include "exynos_drm_plane.h"
  32 #include "exynos_drm_drv.h"
  33 #include "exynos_drm_fbdev.h"
  34 #include "exynos_drm_iommu.h"
  35
  36 /*
  37  * DECON stands for Display and Enhancement controller.
  38  */
  39
  40 #define DECON_DEFAULT_FRAMERATE 60
  41 #define MIN_FB_WIDTH_FOR_16WORD_BURST 128
  42
  43 #define WINDOWS_NR      2
  44
  45 struct decon_context {
  46         struct device                   *dev;
  47         struct drm_device               *drm_dev;
  48         struct exynos_drm_crtc          *crtc;
  49         struct exynos_drm_plane         planes[WINDOWS_NR];
  50         struct clk                      *pclk;
  51         struct clk                      *aclk;
  52         struct clk                      *eclk;
  53         struct clk                      *vclk;
  54         void __iomem                    *regs;
  55         unsigned int                    default_win;
  56         unsigned long                   irq_flags;
  57         bool                            i80_if;
  58         bool                            suspended;
  59         int                             pipe;
  60         wait_queue_head_t               wait_vsync_queue;
  61         atomic_t                        wait_vsync_event;
  62
  63         struct exynos_drm_panel_info panel;
  64         struct exynos_drm_display *display;
  65 };
  66
  67 static const struct of_device_id decon_driver_dt_match[] = {
  68         {.compatible = "samsung,exynos7-decon"},
  69         {},
  70 };
  71 MODULE_DEVICE_TABLE(of, decon_driver_dt_match);
  72
  73 static void decon_wait_for_vblank(struct exynos_drm_crtc *crtc)
  74 {
  75         struct decon_context *ctx = crtc->ctx;
  76
  77         if (ctx->suspended)
  78                 return;
  79
  80         atomic_set(&ctx->wait_vsync_event, 1);
  81
  82         /*
  83          * wait for DECON to signal VSYNC interrupt or return after
  84          * timeout which is set to 50ms (refresh rate of 20).
  85          */
  86         if (!wait_event_timeout(ctx->wait_vsync_queue,
  87                                 !atomic_read(&ctx->wait_vsync_event),
  88                                 HZ/20))
  89                 DRM_DEBUG_KMS("vblank wait timed out.\n");
  90 }
  91
  92 static void decon_clear_channel(struct decon_context *ctx)
  93 {
  94         int win, ch_enabled = 0;
  95
  96         DRM_DEBUG_KMS("%s\n", __FILE__);
  97
  98         /* Check if any channel is enabled. */
  99         for (win = 0; win < WINDOWS_NR; win++) {
 100                 u32 val = readl(ctx->regs + WINCON(win));
 101
 102                 if (val & WINCONx_ENWIN) {
 103                         val &= ~WINCONx_ENWIN;
 104                         writel(val, ctx->regs + WINCON(win));
 105                         ch_enabled = 1;
 106                 }
 107         }
 108
 109         /* Wait for vsync, as disable channel takes effect at next vsync */
 110         if (ch_enabled) {
 111                 unsigned int state = ctx->suspended;
 112
 113                 ctx->suspended = 0;
 114                 decon_wait_for_vblank(ctx->crtc);
 115                 ctx->suspended = state;
 116         }
 117 }
 118
 119 static int decon_ctx_initialize(struct decon_context *ctx,
 120                         struct drm_device *drm_dev)
 121 {
 122         struct exynos_drm_private *priv = drm_dev->dev_private;
 123
 124         ctx->drm_dev = drm_dev;
 125         ctx->pipe = priv->pipe++;
 126
 127         /* attach this sub driver to iommu mapping if supported. */
 128         if (is_drm_iommu_supported(ctx->drm_dev)) {
 129                 int ret;
 130
 131                 /*
 132                  * If any channel is already active, iommu will throw
 133                  * a PAGE FAULT when enabled. So clear any channel if enabled.
 134                  */
 135                 decon_clear_channel(ctx);
 136                 ret = drm_iommu_attach_device(ctx->drm_dev, ctx->dev);
 137                 if (ret) {
 138                         DRM_ERROR("drm_iommu_attach failed.\n");
 139                         return ret;
 140                 }
 141         }
 142
 143         return 0;
 144 }
 145
 146 static void decon_ctx_remove(struct decon_context *ctx)
 147 {
 148         /* detach this sub driver from iommu mapping if supported. */
 149         if (is_drm_iommu_supported(ctx->drm_dev))
 150                 drm_iommu_detach_device(ctx->drm_dev, ctx->dev);
 151 }
 152
 153 static u32 decon_calc_clkdiv(struct decon_context *ctx,
 154                 const struct drm_display_mode *mode)
 155 {
 156         unsigned long ideal_clk = mode->htotal * mode->vtotal * mode->vrefresh;
 157         u32 clkdiv;
 158
 159         /* Find the clock divider value that gets us closest to ideal_clk */
 160         clkdiv = DIV_ROUND_UP(clk_get_rate(ctx->vclk), ideal_clk);
 161
 162         return (clkdiv < 0x100) ? clkdiv : 0xff;
 163 }
 164
 165 static bool decon_mode_fixup(struct exynos_drm_crtc *crtc,
 166                 const struct drm_display_mode *mode,
 167                 struct drm_display_mode *adjusted_mode)
 168 {
 169         if (adjusted_mode->vrefresh == 0)
 170                 adjusted_mode->vrefresh = DECON_DEFAULT_FRAMERATE;
 171
 172         return true;
 173 }
 174
 175 static void decon_commit(struct exynos_drm_crtc *crtc)
 176 {
 177         struct decon_context *ctx = crtc->ctx;
 178         struct drm_display_mode *mode = &crtc->base.mode;
 179         u32 val, clkdiv;
 180
 181         if (ctx->suspended)
 182                 return;
 183
 184         /* nothing to do if we haven't set the mode yet */
 185         if (mode->htotal == 0 || mode->vtotal == 0)
 186                 return;
 187
 188         if (!ctx->i80_if) {
 189                 int vsync_len, vbpd, vfpd, hsync_len, hbpd, hfpd;
 190               /* setup vertical timing values. */
 191                 vsync_len = mode->crtc_vsync_end - mode->crtc_vsync_start;
 192                 vbpd = mode->crtc_vtotal - mode->crtc_vsync_end;
 193                 vfpd = mode->crtc_vsync_start - mode->crtc_vdisplay;
 194
 195                 val = VIDTCON0_VBPD(vbpd - 1) | VIDTCON0_VFPD(vfpd - 1);
 196                 writel(val, ctx->regs + VIDTCON0);
 197
 198                 val = VIDTCON1_VSPW(vsync_len - 1);
 199                 writel(val, ctx->regs + VIDTCON1);
 200
 201                 /* setup horizontal timing values.  */
 202                 hsync_len = mode->crtc_hsync_end - mode->crtc_hsync_start;
 203                 hbpd = mode->crtc_htotal - mode->crtc_hsync_end;
 204                 hfpd = mode->crtc_hsync_start - mode->crtc_hdisplay;
 205
 206                 /* setup horizontal timing values.  */
 207                 val = VIDTCON2_HBPD(hbpd - 1) | VIDTCON2_HFPD(hfpd - 1);
 208                 writel(val, ctx->regs + VIDTCON2);
 209
 210                 val = VIDTCON3_HSPW(hsync_len - 1);
 211                 writel(val, ctx->regs + VIDTCON3);
 212         }
 213
 214         /* setup horizontal and vertical display size. */
 215         val = VIDTCON4_LINEVAL(mode->vdisplay - 1) |
 216                VIDTCON4_HOZVAL(mode->hdisplay - 1);
 217         writel(val, ctx->regs + VIDTCON4);
 218
 219         writel(mode->vdisplay - 1, ctx->regs + LINECNT_OP_THRESHOLD);
 220
 221         /*
 222          * fields of register with prefix '_F' would be updated
 223          * at vsync(same as dma start)
 224          */
 225         val = VIDCON0_ENVID | VIDCON0_ENVID_F;
 226         writel(val, ctx->regs + VIDCON0);
 227
 228         clkdiv = decon_calc_clkdiv(ctx, mode);
 229         if (clkdiv > 1) {
 230                 val = VCLKCON1_CLKVAL_NUM_VCLK(clkdiv - 1);
 231                 writel(val, ctx->regs + VCLKCON1);
 232                 writel(val, ctx->regs + VCLKCON2);
 233         }
 234
 235         val = readl(ctx->regs + DECON_UPDATE);
 236         val |= DECON_UPDATE_STANDALONE_F;
 237         writel(val, ctx->regs + DECON_UPDATE);
 238 }
 239
 240 static int decon_enable_vblank(struct exynos_drm_crtc *crtc)
 241 {
 242         struct decon_context *ctx = crtc->ctx;
 243         u32 val;
 244
 245         if (ctx->suspended)
 246                 return -EPERM;
 247
 248         if (!test_and_set_bit(0, &ctx->irq_flags)) {
 249                 val = readl(ctx->regs + VIDINTCON0);
 250
 251                 val |= VIDINTCON0_INT_ENABLE;
 252
 253                 if (!ctx->i80_if) {
 254                         val |= VIDINTCON0_INT_FRAME;
 255                         val &= ~VIDINTCON0_FRAMESEL0_MASK;
 256                         val |= VIDINTCON0_FRAMESEL0_VSYNC;
 257                 }
 258
 259                 writel(val, ctx->regs + VIDINTCON0);
 260         }
 261
 262         return 0;
 263 }
 264
 265 static void decon_disable_vblank(struct exynos_drm_crtc *crtc)
 266 {
 267         struct decon_context *ctx = crtc->ctx;
 268         u32 val;
 269
 270         if (ctx->suspended)
 271                 return;
 272
 273         if (test_and_clear_bit(0, &ctx->irq_flags)) {
 274                 val = readl(ctx->regs + VIDINTCON0);
 275
 276                 val &= ~VIDINTCON0_INT_ENABLE;
 277                 if (!ctx->i80_if)
 278                         val &= ~VIDINTCON0_INT_FRAME;
 279
 280                 writel(val, ctx->regs + VIDINTCON0);
 281         }
 282 }
 283
 284 static void decon_win_set_pixfmt(struct decon_context *ctx, unsigned int win)
 285 {
 286         struct exynos_drm_plane *plane = &ctx->planes[win];
 287         unsigned long val;
 288         int padding;
 289
 290         val = readl(ctx->regs + WINCON(win));
 291         val &= ~WINCONx_BPPMODE_MASK;
 292
 293         switch (plane->pixel_format) {
 294         case DRM_FORMAT_RGB565:
 295                 val |= WINCONx_BPPMODE_16BPP_565;
 296                 val |= WINCONx_BURSTLEN_16WORD;
 297                 break;
 298         case DRM_FORMAT_XRGB8888:
 299                 val |= WINCONx_BPPMODE_24BPP_xRGB;
 300                 val |= WINCONx_BURSTLEN_16WORD;
 301                 break;
 302         case DRM_FORMAT_XBGR8888:
 303                 val |= WINCONx_BPPMODE_24BPP_xBGR;
 304                 val |= WINCONx_BURSTLEN_16WORD;
 305                 break;
 306         case DRM_FORMAT_RGBX8888:
 307                 val |= WINCONx_BPPMODE_24BPP_RGBx;
 308                 val |= WINCONx_BURSTLEN_16WORD;
 309                 break;
 310         case DRM_FORMAT_BGRX8888:
 311                 val |= WINCONx_BPPMODE_24BPP_BGRx;
 312                 val |= WINCONx_BURSTLEN_16WORD;
 313                 break;
 314         case DRM_FORMAT_ARGB8888:
 315                 val |= WINCONx_BPPMODE_32BPP_ARGB | WINCONx_BLD_PIX |
 316                         WINCONx_ALPHA_SEL;
 317                 val |= WINCONx_BURSTLEN_16WORD;
 318                 break;
 319         case DRM_FORMAT_ABGR8888:
 320                 val |= WINCONx_BPPMODE_32BPP_ABGR | WINCONx_BLD_PIX |
 321                         WINCONx_ALPHA_SEL;
 322                 val |= WINCONx_BURSTLEN_16WORD;
 323                 break;
 324         case DRM_FORMAT_RGBA8888:
 325                 val |= WINCONx_BPPMODE_32BPP_RGBA | WINCONx_BLD_PIX |
 326                         WINCONx_ALPHA_SEL;
 327                 val |= WINCONx_BURSTLEN_16WORD;
 328                 break;
 329         case DRM_FORMAT_BGRA8888:
 330                 val |= WINCONx_BPPMODE_32BPP_BGRA | WINCONx_BLD_PIX |
 331                         WINCONx_ALPHA_SEL;
 332                 val |= WINCONx_BURSTLEN_16WORD;
 333                 break;
 334         default:
 335                 DRM_DEBUG_KMS("invalid pixel size so using unpacked 24bpp.\n");
 336
 337                 val |= WINCONx_BPPMODE_24BPP_xRGB;
 338                 val |= WINCONx_BURSTLEN_16WORD;
 339                 break;
 340         }
 341
 342         DRM_DEBUG_KMS("bpp = %d\n", plane->bpp);
 343
 344         /*
 345          * In case of exynos, setting dma-burst to 16Word causes permanent
 346          * tearing for very small buffers, e.g. cursor buffer. Burst Mode
 347          * switching which is based on plane size is not recommended as
 348          * plane size varies a lot towards the end of the screen and rapid
 349          * movement causes unstable DMA which results into iommu crash/tear.
 350          */
 351
 352         padding = (plane->pitch / (plane->bpp >> 3)) - plane->fb_width;
 353         if (plane->fb_width + padding < MIN_FB_WIDTH_FOR_16WORD_BURST) {
 354                 val &= ~WINCONx_BURSTLEN_MASK;
 355                 val |= WINCONx_BURSTLEN_8WORD;
 356         }
 357
 358         writel(val, ctx->regs + WINCON(win));
 359 }
 360
 361 static void decon_win_set_colkey(struct decon_context *ctx, unsigned int win)
 362 {
 363         unsigned int keycon0 = 0, keycon1 = 0;
 364
 365         keycon0 = ~(WxKEYCON0_KEYBL_EN | WxKEYCON0_KEYEN_F |
 366                         WxKEYCON0_DIRCON) | WxKEYCON0_COMPKEY(0);
 367
 368         keycon1 = WxKEYCON1_COLVAL(0xffffffff);
 369
 370         writel(keycon0, ctx->regs + WKEYCON0_BASE(win));
 371         writel(keycon1, ctx->regs + WKEYCON1_BASE(win));
 372 }
 373
 374 /**
 375  * shadow_protect_win() - disable updating values from shadow registers at vsync
 376  *
 377  * @win: window to protect registers for
 378  * @protect: 1 to protect (disable updates)
 379  */
 380 static void decon_shadow_protect_win(struct decon_context *ctx,
 381                                                         int win, bool protect)
 382 {
 383         u32 bits, val;
 384
 385         bits = SHADOWCON_WINx_PROTECT(win);
 386
 387         val = readl(ctx->regs + SHADOWCON);
 388         if (protect)
 389                 val |= bits;
 390         else
 391                 val &= ~bits;
 392         writel(val, ctx->regs + SHADOWCON);
 393 }
 394
 395 static void decon_win_commit(struct exynos_drm_crtc *crtc, int zpos)
 396 {
 397         struct decon_context *ctx = crtc->ctx;
 398         struct drm_display_mode *mode = &crtc->base.mode;
 399         struct exynos_drm_plane *plane;
 400         int padding, win = zpos;
 401         unsigned long val, alpha;
 402         unsigned int last_x;
 403         unsigned int last_y;
 404
 405         if (ctx->suspended)
 406                 return;
 407
 408         if (win == DEFAULT_ZPOS)
 409                 win = ctx->default_win;
 410
 411         if (win < 0 || win >= WINDOWS_NR)
 412                 return;
 413
 414         plane = &ctx->planes[win];
 415
 416         /* If suspended, enable this on resume */
 417         if (ctx->suspended) {
 418                 plane->resume = true;
 419                 return;
 420         }
 421
 422         /*
 423          * SHADOWCON/PRTCON register is used for enabling timing.
 424          *
 425          * for example, once only width value of a register is set,
 426          * if the dma is started then decon hardware could malfunction so
 427          * with protect window setting, the register fields with prefix '_F'
 428          * wouldn't be updated at vsync also but updated once unprotect window
 429          * is set.
 430          */
 431
 432         /* protect windows */
 433         decon_shadow_protect_win(ctx, win, true);
 434
 435         /* buffer start address */
 436         val = (unsigned long)plane->dma_addr[0];
 437         writel(val, ctx->regs + VIDW_BUF_START(win));
 438
 439         padding = (plane->pitch / (plane->bpp >> 3)) - plane->fb_width;
 440
 441         /* buffer size */
 442         writel(plane->fb_width + padding, ctx->regs + VIDW_WHOLE_X(win));
 443         writel(plane->fb_height, ctx->regs + VIDW_WHOLE_Y(win));
 444
 445         /* offset from the start of the buffer to read */
 446         writel(plane->fb_x, ctx->regs + VIDW_OFFSET_X(win));
 447         writel(plane->fb_y, ctx->regs + VIDW_OFFSET_Y(win));
 448
 449         DRM_DEBUG_KMS("start addr = 0x%lx\n",
 450                         (unsigned long)val);
 451         DRM_DEBUG_KMS("ovl_width = %d, ovl_height = %d\n",
 452                         plane->crtc_width, plane->crtc_height);
 453
 454         /*
 455          * OSD position.
 456          * In case the window layout goes of LCD layout, DECON fails.
 457          */
 458         if ((plane->crtc_x + plane->crtc_width) > mode->hdisplay)
 459                 plane->crtc_x = mode->hdisplay - plane->crtc_width;
 460         if ((plane->crtc_y + plane->crtc_height) > mode->vdisplay)
 461                 plane->crtc_y = mode->vdisplay - plane->crtc_height;
 462
 463         val = VIDOSDxA_TOPLEFT_X(plane->crtc_x) |
 464                 VIDOSDxA_TOPLEFT_Y(plane->crtc_y);
 465         writel(val, ctx->regs + VIDOSD_A(win));
 466
 467         last_x = plane->crtc_x + plane->crtc_width;
 468         if (last_x)
 469                 last_x--;
 470         last_y = plane->crtc_y + plane->crtc_height;
 471         if (last_y)
 472                 last_y--;
 473
 474         val = VIDOSDxB_BOTRIGHT_X(last_x) | VIDOSDxB_BOTRIGHT_Y(last_y);
 475
 476         writel(val, ctx->regs + VIDOSD_B(win));
 477
 478         DRM_DEBUG_KMS("osd pos: tx = %d, ty = %d, bx = %d, by = %d\n",
 479                         plane->crtc_x, plane->crtc_y, last_x, last_y);
 480
 481         /* OSD alpha */
 482         alpha = VIDOSDxC_ALPHA0_R_F(0x0) |
 483                         VIDOSDxC_ALPHA0_G_F(0x0) |
 484                         VIDOSDxC_ALPHA0_B_F(0x0);
 485
 486         writel(alpha, ctx->regs + VIDOSD_C(win));
 487
 488         alpha = VIDOSDxD_ALPHA1_R_F(0xff) |
 489                         VIDOSDxD_ALPHA1_G_F(0xff) |
 490                         VIDOSDxD_ALPHA1_B_F(0xff);
 491
 492         writel(alpha, ctx->regs + VIDOSD_D(win));
 493
 494         decon_win_set_pixfmt(ctx, win);
 495
 496         /* hardware window 0 doesn't support color key. */
 497         if (win != 0)
 498                 decon_win_set_colkey(ctx, win);
 499
 500         /* wincon */
 501         val = readl(ctx->regs + WINCON(win));
 502         val |= WINCONx_TRIPLE_BUF_MODE;
 503         val |= WINCONx_ENWIN;
 504         writel(val, ctx->regs + WINCON(win));
 505
 506         /* Enable DMA channel and unprotect windows */
 507         decon_shadow_protect_win(ctx, win, false);
 508
 509         val = readl(ctx->regs + DECON_UPDATE);
 510         val |= DECON_UPDATE_STANDALONE_F;
 511         writel(val, ctx->regs + DECON_UPDATE);
 512
 513         plane->enabled = true;
 514 }
 515
 516 static void decon_win_disable(struct exynos_drm_crtc *crtc, int zpos)
 517 {
 518         struct decon_context *ctx = crtc->ctx;
 519         struct exynos_drm_plane *plane;
 520         int win = zpos;
 521         u32 val;
 522
 523         if (win == DEFAULT_ZPOS)
 524                 win = ctx->default_win;
 525
 526         if (win < 0 || win >= WINDOWS_NR)
 527                 return;
 528
 529         plane = &ctx->planes[win];
 530
 531         if (ctx->suspended) {
 532                 /* do not resume this window*/
 533                 plane->resume = false;
 534                 return;
 535         }
 536
 537         /* protect windows */
 538         decon_shadow_protect_win(ctx, win, true);
 539
 540         /* wincon */
 541         val = readl(ctx->regs + WINCON(win));
 542         val &= ~WINCONx_ENWIN;
 543         writel(val, ctx->regs + WINCON(win));
 544
 545         /* unprotect windows */
 546         decon_shadow_protect_win(ctx, win, false);
 547
 548         val = readl(ctx->regs + DECON_UPDATE);
 549         val |= DECON_UPDATE_STANDALONE_F;
 550         writel(val, ctx->regs + DECON_UPDATE);
 551
 552         plane->enabled = false;
 553 }
 554
 555 static void decon_window_suspend(struct decon_context *ctx)
 556 {
 557         struct exynos_drm_plane *plane;
 558         int i;
 559
 560         for (i = 0; i < WINDOWS_NR; i++) {
 561                 plane = &ctx->planes[i];
 562                 plane->resume = plane->enabled;
 563                 if (plane->enabled)
 564                         decon_win_disable(ctx->crtc, i);
 565         }
 566 }
 567
 568 static void decon_window_resume(struct decon_context *ctx)
 569 {
 570         struct exynos_drm_plane *plane;
 571         int i;
 572
 573         for (i = 0; i < WINDOWS_NR; i++) {
 574                 plane = &ctx->planes[i];
 575                 plane->enabled = plane->resume;
 576                 plane->resume = false;
 577         }
 578 }
 579
 580 static void decon_apply(struct decon_context *ctx)
 581 {
 582         struct exynos_drm_plane *plane;
 583         int i;
 584
 585         for (i = 0; i < WINDOWS_NR; i++) {
 586                 plane = &ctx->planes[i];
 587                 if (plane->enabled)
 588                         decon_win_commit(ctx->crtc, i);
 589                 else
 590                         decon_win_disable(ctx->crtc, i);
 591         }
 592
 593         decon_commit(ctx->crtc);
 594 }
 595
 596 static void decon_init(struct decon_context *ctx)
 597 {
 598         u32 val;
 599
 600         writel(VIDCON0_SWRESET, ctx->regs + VIDCON0);
 601
 602         val = VIDOUTCON0_DISP_IF_0_ON;
 603         if (!ctx->i80_if)
 604                 val |= VIDOUTCON0_RGBIF;
 605         writel(val, ctx->regs + VIDOUTCON0);
 606
 607         writel(VCLKCON0_CLKVALUP | VCLKCON0_VCLKFREE, ctx->regs + VCLKCON0);
 608
 609         if (!ctx->i80_if)
 610                 writel(VIDCON1_VCLK_HOLD, ctx->regs + VIDCON1(0));
 611 }
 612
 613 static int decon_poweron(struct decon_context *ctx)
 614 {
 615         int ret;
 616
 617         if (!ctx->suspended)
 618                 return 0;
 619
 620         ctx->suspended = false;
 621
 622         pm_runtime_get_sync(ctx->dev);
 623
 624         ret = clk_prepare_enable(ctx->pclk);
 625         if (ret < 0) {
 626                 DRM_ERROR("Failed to prepare_enable the pclk [%d]\n", ret);
 627                 goto pclk_err;
 628         }
 629
 630         ret = clk_prepare_enable(ctx->aclk);
 631         if (ret < 0) {
 632                 DRM_ERROR("Failed to prepare_enable the aclk [%d]\n", ret);
 633                 goto aclk_err;
 634         }
 635
 636         ret = clk_prepare_enable(ctx->eclk);
 637         if  (ret < 0) {
 638                 DRM_ERROR("Failed to prepare_enable the eclk [%d]\n", ret);
 639                 goto eclk_err;
 640         }
 641
 642         ret = clk_prepare_enable(ctx->vclk);
 643         if  (ret < 0) {
 644                 DRM_ERROR("Failed to prepare_enable the vclk [%d]\n", ret);
 645                 goto vclk_err;
 646         }
 647
 648         decon_init(ctx);
 649
 650         /* if vblank was enabled status, enable it again. */
 651         if (test_and_clear_bit(0, &ctx->irq_flags)) {
 652                 ret = decon_enable_vblank(ctx->crtc);
 653                 if (ret) {
 654                         DRM_ERROR("Failed to re-enable vblank [%d]\n", ret);
 655                         goto err;
 656                 }
 657         }
 658
 659         decon_window_resume(ctx);
 660
 661         decon_apply(ctx);
 662
 663         return 0;
 664
 665 err:
 666         clk_disable_unprepare(ctx->vclk);
 667 vclk_err:
 668         clk_disable_unprepare(ctx->eclk);
 669 eclk_err:
 670         clk_disable_unprepare(ctx->aclk);
 671 aclk_err:
 672         clk_disable_unprepare(ctx->pclk);
 673 pclk_err:
 674         ctx->suspended = true;
 675         return ret;
 676 }
 677
 678 static int decon_poweroff(struct decon_context *ctx)
 679 {
 680         if (ctx->suspended)
 681                 return 0;
 682
 683         /*
 684          * We need to make sure that all windows are disabled before we
 685          * suspend that connector. Otherwise we might try to scan from
 686          * a destroyed buffer later.
 687          */
 688         decon_window_suspend(ctx);
 689
 690         clk_disable_unprepare(ctx->vclk);
 691         clk_disable_unprepare(ctx->eclk);
 692         clk_disable_unprepare(ctx->aclk);
 693         clk_disable_unprepare(ctx->pclk);
 694
 695         pm_runtime_put_sync(ctx->dev);
 696
 697         ctx->suspended = true;
 698         return 0;
 699 }
 700
 701 static void decon_dpms(struct exynos_drm_crtc *crtc, int mode)
 702 {
 703         DRM_DEBUG_KMS("%s, %d\n", __FILE__, mode);
 704
 705         switch (mode) {
 706         case DRM_MODE_DPMS_ON:
 707                 decon_poweron(crtc->ctx);
 708                 break;
 709         case DRM_MODE_DPMS_STANDBY:
 710         case DRM_MODE_DPMS_SUSPEND:
 711         case DRM_MODE_DPMS_OFF:
 712                 decon_poweroff(crtc->ctx);
 713                 break;
 714         default:
 715                 DRM_DEBUG_KMS("unspecified mode %d\n", mode);
 716                 break;
 717         }
 718 }
 719
 720 static struct exynos_drm_crtc_ops decon_crtc_ops = {
 721         .dpms = decon_dpms,
 722         .mode_fixup = decon_mode_fixup,
 723         .commit = decon_commit,
 724         .enable_vblank = decon_enable_vblank,
 725         .disable_vblank = decon_disable_vblank,
 726         .wait_for_vblank = decon_wait_for_vblank,
 727         .win_commit = decon_win_commit,
 728         .win_disable = decon_win_disable,
 729 };
 730
 731
 732 static irqreturn_t decon_irq_handler(int irq, void *dev_id)
 733 {
 734         struct decon_context *ctx = (struct decon_context *)dev_id;
 735         u32 val, clear_bit;
 736
 737         val = readl(ctx->regs + VIDINTCON1);
 738
 739         clear_bit = ctx->i80_if ? VIDINTCON1_INT_I80 : VIDINTCON1_INT_FRAME;
 740         if (val & clear_bit)
 741                 writel(clear_bit, ctx->regs + VIDINTCON1);
 742
 743         /* check the crtc is detached already from encoder */
 744         if (ctx->pipe < 0 || !ctx->drm_dev)
 745                 goto out;
 746
 747         if (!ctx->i80_if) {
 748                 drm_handle_vblank(ctx->drm_dev, ctx->pipe);
 749                 exynos_drm_crtc_finish_pageflip(ctx->drm_dev, ctx->pipe);
 750
 751                 /* set wait vsync event to zero and wake up queue. */
 752                 if (atomic_read(&ctx->wait_vsync_event)) {
 753                         atomic_set(&ctx->wait_vsync_event, 0);
 754                         wake_up(&ctx->wait_vsync_queue);
 755                 }
 756         }
 757 out:
 758         return IRQ_HANDLED;
 759 }
 760
 761 static int decon_bind(struct device *dev, struct device *master, void *data)
 762 {
 763         struct decon_context *ctx = dev_get_drvdata(dev);
 764         struct drm_device *drm_dev = data;
 765         struct exynos_drm_plane *exynos_plane;
 766         enum drm_plane_type type;
 767         int zpos, ret;
 768
 769         ret = decon_ctx_initialize(ctx, drm_dev);
 770         if (ret) {
 771                 DRM_ERROR("decon_ctx_initialize failed.\n");
 772                 return ret;
 773         }
 774
 775         for (zpos = 0; zpos < WINDOWS_NR; zpos++) {
 776                 type = (zpos == ctx->default_win) ? DRM_PLANE_TYPE_PRIMARY :
 777                                                 DRM_PLANE_TYPE_OVERLAY;
 778                 ret = exynos_plane_init(drm_dev, &ctx->planes[zpos],
 779                                         1 << ctx->pipe, type);
 780                 if (ret)
 781                         return ret;
 782         }
 783
 784         exynos_plane = &ctx->planes[ctx->default_win];
 785         ctx->crtc = exynos_drm_crtc_create(drm_dev, &exynos_plane->base,
 786                                            ctx->pipe, EXYNOS_DISPLAY_TYPE_LCD,
 787                                            &decon_crtc_ops, ctx);
 788         if (IS_ERR(ctx->crtc)) {
 789                 decon_ctx_remove(ctx);
 790                 return PTR_ERR(ctx->crtc);
 791         }
 792
 793         if (ctx->display)
 794                 exynos_drm_create_enc_conn(drm_dev, ctx->display);
 795
 796         return 0;
 797
 798 }
 799
 800 static void decon_unbind(struct device *dev, struct device *master,
 801                         void *data)
 802 {
 803         struct decon_context *ctx = dev_get_drvdata(dev);
 804
 805         decon_dpms(ctx->crtc, DRM_MODE_DPMS_OFF);
 806
 807         if (ctx->display)
 808                 exynos_dpi_remove(ctx->display);
 809
 810         decon_ctx_remove(ctx);
 811 }
 812
 813 static const struct component_ops decon_component_ops = {
 814         .bind   = decon_bind,
 815         .unbind = decon_unbind,
 816 };
 817
 818 static int decon_probe(struct platform_device *pdev)
 819 {
 820         struct device *dev = &pdev->dev;
 821         struct decon_context *ctx;
 822         struct device_node *i80_if_timings;
 823         struct resource *res;
 824         int ret;
 825
 826         if (!dev->of_node)
 827                 return -ENODEV;
 828
 829         ctx = devm_kzalloc(dev, sizeof(*ctx), GFP_KERNEL);
 830         if (!ctx)
 831                 return -ENOMEM;
 832
 833         ret = exynos_drm_component_add(dev, EXYNOS_DEVICE_TYPE_CRTC,
 834                                         EXYNOS_DISPLAY_TYPE_LCD);
 835         if (ret)
 836                 return ret;
 837
 838         ctx->dev = dev;
 839         ctx->suspended = true;
 840
 841         i80_if_timings = of_get_child_by_name(dev->of_node, "i80-if-timings");
 842         if (i80_if_timings)
 843                 ctx->i80_if = true;
 844         of_node_put(i80_if_timings);
 845
 846         ctx->regs = of_iomap(dev->of_node, 0);
 847         if (!ctx->regs) {
 848                 ret = -ENOMEM;
 849                 goto err_del_component;
 850         }
 851
 852         ctx->pclk = devm_clk_get(dev, "pclk_decon0");
 853         if (IS_ERR(ctx->pclk)) {
 854                 dev_err(dev, "failed to get bus clock pclk\n");
 855                 ret = PTR_ERR(ctx->pclk);
 856                 goto err_iounmap;
 857         }
 858
 859         ctx->aclk = devm_clk_get(dev, "aclk_decon0");
 860         if (IS_ERR(ctx->aclk)) {
 861                 dev_err(dev, "failed to get bus clock aclk\n");
 862                 ret = PTR_ERR(ctx->aclk);
 863                 goto err_iounmap;
 864         }
 865
 866         ctx->eclk = devm_clk_get(dev, "decon0_eclk");
 867         if (IS_ERR(ctx->eclk)) {
 868                 dev_err(dev, "failed to get eclock\n");
 869                 ret = PTR_ERR(ctx->eclk);
 870                 goto err_iounmap;
 871         }
 872
 873         ctx->vclk = devm_clk_get(dev, "decon0_vclk");
 874         if (IS_ERR(ctx->vclk)) {
 875                 dev_err(dev, "failed to get vclock\n");
 876                 ret = PTR_ERR(ctx->vclk);
 877                 goto err_iounmap;
 878         }
 879
 880         res = platform_get_resource_byname(pdev, IORESOURCE_IRQ,
 881                                            ctx->i80_if ? "lcd_sys" : "vsync");
 882         if (!res) {
 883                 dev_err(dev, "irq request failed.\n");
 884                 ret = -ENXIO;
 885                 goto err_iounmap;
 886         }
 887
 888         ret = devm_request_irq(dev, res->start, decon_irq_handler,
 889                                                         0, "drm_decon", ctx);
 890         if (ret) {
 891                 dev_err(dev, "irq request failed.\n");
 892                 goto err_iounmap;
 893         }
 894
 895         init_waitqueue_head(&ctx->wait_vsync_queue);
 896         atomic_set(&ctx->wait_vsync_event, 0);
 897
 898         platform_set_drvdata(pdev, ctx);
 899
 900         ctx->display = exynos_dpi_probe(dev);
 901         if (IS_ERR(ctx->display)) {
 902                 ret = PTR_ERR(ctx->display);
 903                 goto err_iounmap;
 904         }
 905
 906         pm_runtime_enable(dev);
 907
 908         ret = component_add(dev, &decon_component_ops);
 909         if (ret)
 910                 goto err_disable_pm_runtime;
 911
 912         return ret;
 913
 914 err_disable_pm_runtime:
 915         pm_runtime_disable(dev);
 916
 917 err_iounmap:
 918         iounmap(ctx->regs);
 919
 920 err_del_component:
 921         exynos_drm_component_del(dev, EXYNOS_DEVICE_TYPE_CRTC);
 922         return ret;
 923 }
 924
 925 static int decon_remove(struct platform_device *pdev)
 926 {
 927         struct decon_context *ctx = dev_get_drvdata(&pdev->dev);
 928
 929         pm_runtime_disable(&pdev->dev);
 930
 931         iounmap(ctx->regs);
 932
 933         component_del(&pdev->dev, &decon_component_ops);
 934         exynos_drm_component_del(&pdev->dev, EXYNOS_DEVICE_TYPE_CRTC);
 935
 936         return 0;
 937 }
 938
 939 struct platform_driver decon_driver = {
 940         .probe          = decon_probe,
 941         .remove         = decon_remove,
 942         .driver         = {
 943                 .name   = "exynos-decon",
 944                 .of_match_table = decon_driver_dt_match,
 945         },
 946 };