drivers/gpu/drm/exynos/exynos5433_drm_decon.c

   1 /* drivers/gpu/drm/exynos5433_drm_decon.c
   2  *
   3  * Copyright (C) 2015 Samsung Electronics Co.Ltd
   4  * Authors:
   5  *      Joonyoung Shim <jy0922.shim@samsung.com>
   6  *      Hyungwon Hwang <human.hwang@samsung.com>
   7  *
   8  * This program is free software; you can redistribute it and/or modify
   9  * it under the terms of the GNU General Public License version 2 as
  10  * published by the Free Software Foundationr
  11  */
  12
  13 #include <linux/platform_device.h>
  14 #include <linux/clk.h>
  15 #include <linux/component.h>
  16 #include <linux/of_device.h>
  17 #include <linux/of_gpio.h>
  18 #include <linux/pm_runtime.h>
  19
  20 #include <video/exynos5433_decon.h>
  21
  22 #include "exynos_drm_drv.h"
  23 #include "exynos_drm_crtc.h"
  24 #include "exynos_drm_plane.h"
  25 #include "exynos_drm_iommu.h"
  26
  27 #define WINDOWS_NR      3
  28 #define CURSOR_WIN      2
  29 #define MIN_FB_WIDTH_FOR_16WORD_BURST   128
  30
  31 static const char * const decon_clks_name[] = {
  32         "pclk",
  33         "aclk_decon",
  34         "aclk_smmu_decon0x",
  35         "aclk_xiu_decon0x",
  36         "pclk_smmu_decon0x",
  37         "sclk_decon_vclk",
  38         "sclk_decon_eclk",
  39 };
  40
  41 enum decon_iftype {
  42         IFTYPE_RGB,
  43         IFTYPE_I80,
  44         IFTYPE_HDMI
  45 };
  46
  47 enum decon_flag_bits {
  48         BIT_CLKS_ENABLED,
  49         BIT_IRQS_ENABLED,
  50         BIT_WIN_UPDATED,
  51         BIT_SUSPENDED
  52 };
  53
  54 struct decon_context {
  55         struct device                   *dev;
  56         struct drm_device               *drm_dev;
  57         struct exynos_drm_crtc          *crtc;
  58         struct exynos_drm_plane         planes[WINDOWS_NR];
  59         void __iomem                    *addr;
  60         struct clk                      *clks[ARRAY_SIZE(decon_clks_name)];
  61         int                             pipe;
  62         unsigned long                   flags;
  63         enum decon_iftype               out_type;
  64         int                             first_win;
  65 };
  66
  67 static const uint32_t decon_formats[] = {
  68         DRM_FORMAT_XRGB1555,
  69         DRM_FORMAT_RGB565,
  70         DRM_FORMAT_XRGB8888,
  71         DRM_FORMAT_ARGB8888,
  72 };
  73
  74 static inline void decon_set_bits(struct decon_context *ctx, u32 reg, u32 mask,
  75                                   u32 val)
  76 {
  77         val = (val & mask) | (readl(ctx->addr + reg) & ~mask);
  78         writel(val, ctx->addr + reg);
  79 }
  80
  81 static int decon_enable_vblank(struct exynos_drm_crtc *crtc)
  82 {
  83         struct decon_context *ctx = crtc->ctx;
  84         u32 val;
  85
  86         if (test_bit(BIT_SUSPENDED, &ctx->flags))
  87                 return -EPERM;
  88
  89         if (test_and_set_bit(BIT_IRQS_ENABLED, &ctx->flags)) {
  90                 val = VIDINTCON0_INTEN;
  91                 if (ctx->out_type == IFTYPE_I80)
  92                         val |= VIDINTCON0_FRAMEDONE;
  93                 else
  94                         val |= VIDINTCON0_INTFRMEN;
  95
  96                 writel(val, ctx->addr + DECON_VIDINTCON0);
  97         }
  98
  99         return 0;
 100 }
 101
 102 static void decon_disable_vblank(struct exynos_drm_crtc *crtc)
 103 {
 104         struct decon_context *ctx = crtc->ctx;
 105
 106         if (test_bit(BIT_SUSPENDED, &ctx->flags))
 107                 return;
 108
 109         if (test_and_clear_bit(BIT_IRQS_ENABLED, &ctx->flags))
 110                 writel(0, ctx->addr + DECON_VIDINTCON0);
 111 }
 112
 113 static void decon_setup_trigger(struct decon_context *ctx)
 114 {
 115         u32 val = (ctx->out_type != IFTYPE_HDMI)
 116                 ? TRIGCON_TRIGEN_PER_F | TRIGCON_TRIGEN_F |
 117                   TRIGCON_TE_AUTO_MASK | TRIGCON_SWTRIGEN
 118                 : TRIGCON_TRIGEN_PER_F | TRIGCON_TRIGEN_F |
 119                   TRIGCON_HWTRIGMASK_I80_RGB | TRIGCON_HWTRIGEN_I80_RGB;
 120         writel(val, ctx->addr + DECON_TRIGCON);
 121 }
 122
 123 static void decon_commit(struct exynos_drm_crtc *crtc)
 124 {
 125         struct decon_context *ctx = crtc->ctx;
 126         struct drm_display_mode *m = &crtc->base.mode;
 127         u32 val;
 128
 129         if (test_bit(BIT_SUSPENDED, &ctx->flags))
 130                 return;
 131
 132         if (ctx->out_type == IFTYPE_HDMI) {
 133                 m->crtc_hsync_start = m->crtc_hdisplay + 10;
 134                 m->crtc_hsync_end = m->crtc_htotal - 92;
 135                 m->crtc_vsync_start = m->crtc_vdisplay + 1;
 136                 m->crtc_vsync_end = m->crtc_vsync_start + 1;
 137         }
 138
 139         decon_set_bits(ctx, DECON_VIDCON0, VIDCON0_ENVID, 0);
 140
 141         /* enable clock gate */
 142         val = CMU_CLKGAGE_MODE_SFR_F | CMU_CLKGAGE_MODE_MEM_F;
 143         writel(val, ctx->addr + DECON_CMU);
 144
 145         /* lcd on and use command if */
 146         val = VIDOUT_LCD_ON;
 147         if (ctx->out_type == IFTYPE_I80)
 148                 val |= VIDOUT_COMMAND_IF;
 149         else
 150                 val |= VIDOUT_RGB_IF;
 151         writel(val, ctx->addr + DECON_VIDOUTCON0);
 152
 153         val = VIDTCON2_LINEVAL(m->vdisplay - 1) |
 154                 VIDTCON2_HOZVAL(m->hdisplay - 1);
 155         writel(val, ctx->addr + DECON_VIDTCON2);
 156
 157         if (ctx->out_type != IFTYPE_I80) {
 158                 val = VIDTCON00_VBPD_F(
 159                                 m->crtc_vtotal - m->crtc_vsync_end - 1) |
 160                         VIDTCON00_VFPD_F(
 161                                 m->crtc_vsync_start - m->crtc_vdisplay - 1);
 162                 writel(val, ctx->addr + DECON_VIDTCON00);
 163
 164                 val = VIDTCON01_VSPW_F(
 165                                 m->crtc_vsync_end - m->crtc_vsync_start - 1);
 166                 writel(val, ctx->addr + DECON_VIDTCON01);
 167
 168                 val = VIDTCON10_HBPD_F(
 169                                 m->crtc_htotal - m->crtc_hsync_end - 1) |
 170                         VIDTCON10_HFPD_F(
 171                                 m->crtc_hsync_start - m->crtc_hdisplay - 1);
 172                 writel(val, ctx->addr + DECON_VIDTCON10);
 173
 174                 val = VIDTCON11_HSPW_F(
 175                                 m->crtc_hsync_end - m->crtc_hsync_start - 1);
 176                 writel(val, ctx->addr + DECON_VIDTCON11);
 177         }
 178
 179         decon_setup_trigger(ctx);
 180
 181         /* enable output and display signal */
 182         decon_set_bits(ctx, DECON_VIDCON0, VIDCON0_ENVID | VIDCON0_ENVID_F, ~0);
 183 }
 184
 185 static void decon_win_set_pixfmt(struct decon_context *ctx, unsigned int win,
 186                                  struct drm_framebuffer *fb)
 187 {
 188         unsigned long val;
 189
 190         val = readl(ctx->addr + DECON_WINCONx(win));
 191         val &= ~WINCONx_BPPMODE_MASK;
 192
 193         switch (fb->pixel_format) {
 194         case DRM_FORMAT_XRGB1555:
 195                 val |= WINCONx_BPPMODE_16BPP_I1555;
 196                 val |= WINCONx_HAWSWP_F;
 197                 val |= WINCONx_BURSTLEN_16WORD;
 198                 break;
 199         case DRM_FORMAT_RGB565:
 200                 val |= WINCONx_BPPMODE_16BPP_565;
 201                 val |= WINCONx_HAWSWP_F;
 202                 val |= WINCONx_BURSTLEN_16WORD;
 203                 break;
 204         case DRM_FORMAT_XRGB8888:
 205                 val |= WINCONx_BPPMODE_24BPP_888;
 206                 val |= WINCONx_WSWP_F;
 207                 val |= WINCONx_BURSTLEN_16WORD;
 208                 break;
 209         case DRM_FORMAT_ARGB8888:
 210                 val |= WINCONx_BPPMODE_32BPP_A8888;
 211                 val |= WINCONx_WSWP_F | WINCONx_BLD_PIX_F | WINCONx_ALPHA_SEL_F;
 212                 val |= WINCONx_BURSTLEN_16WORD;
 213                 break;
 214         default:
 215                 DRM_ERROR("Proper pixel format is not set\n");
 216                 return;
 217         }
 218
 219         DRM_DEBUG_KMS("bpp = %u\n", fb->bits_per_pixel);
 220
 221         /*
 222          * In case of exynos, setting dma-burst to 16Word causes permanent
 223          * tearing for very small buffers, e.g. cursor buffer. Burst Mode
 224          * switching which is based on plane size is not recommended as
 225          * plane size varies a lot towards the end of the screen and rapid
 226          * movement causes unstable DMA which results into iommu crash/tear.
 227          */
 228
 229         if (fb->width < MIN_FB_WIDTH_FOR_16WORD_BURST) {
 230                 val &= ~WINCONx_BURSTLEN_MASK;
 231                 val |= WINCONx_BURSTLEN_8WORD;
 232         }
 233
 234         writel(val, ctx->addr + DECON_WINCONx(win));
 235 }
 236
 237 static void decon_shadow_protect_win(struct decon_context *ctx, int win,
 238                                         bool protect)
 239 {
 240         decon_set_bits(ctx, DECON_SHADOWCON, SHADOWCON_Wx_PROTECT(win),
 241                        protect ? ~0 : 0);
 242 }
 243
 244 static void decon_atomic_begin(struct exynos_drm_crtc *crtc,
 245                                         struct exynos_drm_plane *plane)
 246 {
 247         struct decon_context *ctx = crtc->ctx;
 248
 249         if (test_bit(BIT_SUSPENDED, &ctx->flags))
 250                 return;
 251
 252         decon_shadow_protect_win(ctx, plane->zpos, true);
 253 }
 254
 255 #define BIT_VAL(x, e, s) (((x) & ((1 << ((e) - (s) + 1)) - 1)) << (s))
 256 #define COORDINATE_X(x) BIT_VAL((x), 23, 12)
 257 #define COORDINATE_Y(x) BIT_VAL((x), 11, 0)
 258
 259 static void decon_update_plane(struct exynos_drm_crtc *crtc,
 260                                struct exynos_drm_plane *plane)
 261 {
 262         struct decon_context *ctx = crtc->ctx;
 263         struct drm_plane_state *state = plane->base.state;
 264         unsigned int win = plane->zpos;
 265         unsigned int bpp = state->fb->bits_per_pixel >> 3;
 266         unsigned int pitch = state->fb->pitches[0];
 267         u32 val;
 268
 269         if (test_bit(BIT_SUSPENDED, &ctx->flags))
 270                 return;
 271
 272         val = COORDINATE_X(plane->crtc_x) | COORDINATE_Y(plane->crtc_y);
 273         writel(val, ctx->addr + DECON_VIDOSDxA(win));
 274
 275         val = COORDINATE_X(plane->crtc_x + plane->crtc_w - 1) |
 276                 COORDINATE_Y(plane->crtc_y + plane->crtc_h - 1);
 277         writel(val, ctx->addr + DECON_VIDOSDxB(win));
 278
 279         val = VIDOSD_Wx_ALPHA_R_F(0x0) | VIDOSD_Wx_ALPHA_G_F(0x0) |
 280                 VIDOSD_Wx_ALPHA_B_F(0x0);
 281         writel(val, ctx->addr + DECON_VIDOSDxC(win));
 282
 283         val = VIDOSD_Wx_ALPHA_R_F(0x0) | VIDOSD_Wx_ALPHA_G_F(0x0) |
 284                 VIDOSD_Wx_ALPHA_B_F(0x0);
 285         writel(val, ctx->addr + DECON_VIDOSDxD(win));
 286
 287         writel(plane->dma_addr[0], ctx->addr + DECON_VIDW0xADD0B0(win));
 288
 289         val = plane->dma_addr[0] + pitch * plane->crtc_h;
 290         writel(val, ctx->addr + DECON_VIDW0xADD1B0(win));
 291
 292         if (ctx->out_type != IFTYPE_HDMI)
 293                 val = BIT_VAL(pitch - plane->crtc_w * bpp, 27, 14)
 294                         | BIT_VAL(plane->crtc_w * bpp, 13, 0);
 295         else
 296                 val = BIT_VAL(pitch - plane->crtc_w * bpp, 29, 15)
 297                         | BIT_VAL(plane->crtc_w * bpp, 14, 0);
 298         writel(val, ctx->addr + DECON_VIDW0xADD2(win));
 299
 300         decon_win_set_pixfmt(ctx, win, state->fb);
 301
 302         /* window enable */
 303         decon_set_bits(ctx, DECON_WINCONx(win), WINCONx_ENWIN_F, ~0);
 304
 305         /* standalone update */
 306         decon_set_bits(ctx, DECON_UPDATE, STANDALONE_UPDATE_F, ~0);
 307 }
 308
 309 static void decon_disable_plane(struct exynos_drm_crtc *crtc,
 310                                 struct exynos_drm_plane *plane)
 311 {
 312         struct decon_context *ctx = crtc->ctx;
 313         unsigned int win = plane->zpos;
 314
 315         if (test_bit(BIT_SUSPENDED, &ctx->flags))
 316                 return;
 317
 318         decon_shadow_protect_win(ctx, win, true);
 319
 320         /* window disable */
 321         decon_set_bits(ctx, DECON_WINCONx(win), WINCONx_ENWIN_F, 0);
 322
 323         decon_shadow_protect_win(ctx, win, false);
 324
 325         /* standalone update */
 326         decon_set_bits(ctx, DECON_UPDATE, STANDALONE_UPDATE_F, ~0);
 327 }
 328
 329 static void decon_atomic_flush(struct exynos_drm_crtc *crtc,
 330                                 struct exynos_drm_plane *plane)
 331 {
 332         struct decon_context *ctx = crtc->ctx;
 333
 334         if (test_bit(BIT_SUSPENDED, &ctx->flags))
 335                 return;
 336
 337         decon_shadow_protect_win(ctx, plane->zpos, false);
 338
 339         if (ctx->out_type == IFTYPE_I80)
 340                 set_bit(BIT_WIN_UPDATED, &ctx->flags);
 341 }
 342
 343 static void decon_swreset(struct decon_context *ctx)
 344 {
 345         unsigned int tries;
 346
 347         writel(0, ctx->addr + DECON_VIDCON0);
 348         for (tries = 2000; tries; --tries) {
 349                 if (~readl(ctx->addr + DECON_VIDCON0) & VIDCON0_STOP_STATUS)
 350                         break;
 351                 udelay(10);
 352         }
 353
 354         WARN(tries == 0, "failed to disable DECON\n");
 355
 356         writel(VIDCON0_SWRESET, ctx->addr + DECON_VIDCON0);
 357         for (tries = 2000; tries; --tries) {
 358                 if (~readl(ctx->addr + DECON_VIDCON0) & VIDCON0_SWRESET)
 359                         break;
 360                 udelay(10);
 361         }
 362
 363         WARN(tries == 0, "failed to software reset DECON\n");
 364
 365         if (ctx->out_type != IFTYPE_HDMI)
 366                 return;
 367
 368         writel(VIDCON0_CLKVALUP | VIDCON0_VLCKFREE, ctx->addr + DECON_VIDCON0);
 369         decon_set_bits(ctx, DECON_CMU,
 370                        CMU_CLKGAGE_MODE_SFR_F | CMU_CLKGAGE_MODE_MEM_F, ~0);
 371         writel(VIDCON1_VCLK_RUN_VDEN_DISABLE, ctx->addr + DECON_VIDCON1);
 372         writel(CRCCTRL_CRCEN | CRCCTRL_CRCSTART_F | CRCCTRL_CRCCLKEN,
 373                ctx->addr + DECON_CRCCTRL);
 374         decon_setup_trigger(ctx);
 375 }
 376
 377 static void decon_enable(struct exynos_drm_crtc *crtc)
 378 {
 379         struct decon_context *ctx = crtc->ctx;
 380         int ret;
 381         int i;
 382
 383         if (!test_and_clear_bit(BIT_SUSPENDED, &ctx->flags))
 384                 return;
 385
 386         pm_runtime_get_sync(ctx->dev);
 387
 388         set_bit(BIT_CLKS_ENABLED, &ctx->flags);
 389
 390         /* if vblank was enabled status, enable it again. */
 391         if (test_and_clear_bit(BIT_IRQS_ENABLED, &ctx->flags))
 392                 decon_enable_vblank(ctx->crtc);
 393
 394         decon_commit(ctx->crtc);
 395
 396         set_bit(BIT_SUSPENDED, &ctx->flags);
 397 }
 398
 399 static void decon_disable(struct exynos_drm_crtc *crtc)
 400 {
 401         struct decon_context *ctx = crtc->ctx;
 402         int i;
 403
 404         if (test_bit(BIT_SUSPENDED, &ctx->flags))
 405                 return;
 406
 407         /*
 408          * We need to make sure that all windows are disabled before we
 409          * suspend that connector. Otherwise we might try to scan from
 410          * a destroyed buffer later.
 411          */
 412         for (i = ctx->first_win; i < WINDOWS_NR; i++)
 413                 decon_disable_plane(crtc, &ctx->planes[i]);
 414
 415         decon_swreset(ctx);
 416
 417         clear_bit(BIT_CLKS_ENABLED, &ctx->flags);
 418
 419         pm_runtime_put_sync(ctx->dev);
 420
 421         set_bit(BIT_SUSPENDED, &ctx->flags);
 422 }
 423
 424 void decon_te_irq_handler(struct exynos_drm_crtc *crtc)
 425 {
 426         struct decon_context *ctx = crtc->ctx;
 427
 428         if (!test_bit(BIT_CLKS_ENABLED, &ctx->flags))
 429                 return;
 430
 431         if (test_and_clear_bit(BIT_WIN_UPDATED, &ctx->flags))
 432                 decon_set_bits(ctx, DECON_TRIGCON, TRIGCON_SWTRIGCMD, ~0);
 433
 434         drm_crtc_handle_vblank(&ctx->crtc->base);
 435 }
 436
 437 static void decon_clear_channels(struct exynos_drm_crtc *crtc)
 438 {
 439         struct decon_context *ctx = crtc->ctx;
 440         int win, i, ret;
 441
 442         DRM_DEBUG_KMS("%s\n", __FILE__);
 443
 444         for (i = 0; i < ARRAY_SIZE(decon_clks_name); i++) {
 445                 ret = clk_prepare_enable(ctx->clks[i]);
 446                 if (ret < 0)
 447                         goto err;
 448         }
 449
 450         for (win = 0; win < WINDOWS_NR; win++) {
 451                 decon_shadow_protect_win(ctx, win, true);
 452                 decon_set_bits(ctx, DECON_WINCONx(win), WINCONx_ENWIN_F, 0);
 453                 decon_shadow_protect_win(ctx, win, false);
 454                 decon_set_bits(ctx, DECON_UPDATE, STANDALONE_UPDATE_F, ~0);
 455         }
 456         /* TODO: wait for possible vsync */
 457         msleep(50);
 458
 459 err:
 460         while (--i >= 0)
 461                 clk_disable_unprepare(ctx->clks[i]);
 462 }
 463
 464 static struct exynos_drm_crtc_ops decon_crtc_ops = {
 465         .enable                 = decon_enable,
 466         .disable                = decon_disable,
 467         .enable_vblank          = decon_enable_vblank,
 468         .disable_vblank         = decon_disable_vblank,
 469         .atomic_begin           = decon_atomic_begin,
 470         .update_plane           = decon_update_plane,
 471         .disable_plane          = decon_disable_plane,
 472         .atomic_flush           = decon_atomic_flush,
 473         .te_handler             = decon_te_irq_handler,
 474 };
 475
 476 static int decon_bind(struct device *dev, struct device *master, void *data)
 477 {
 478         struct decon_context *ctx = dev_get_drvdata(dev);
 479         struct drm_device *drm_dev = data;
 480         struct exynos_drm_private *priv = drm_dev->dev_private;
 481         struct exynos_drm_plane *exynos_plane;
 482         enum exynos_drm_output_type out_type;
 483         enum drm_plane_type type;
 484         unsigned int win;
 485         int ret;
 486
 487         ctx->drm_dev = drm_dev;
 488         ctx->pipe = priv->pipe++;
 489
 490         for (win = ctx->first_win; win < WINDOWS_NR; win++) {
 491                 int tmp = (win == ctx->first_win) ? 0 : win;
 492
 493                 type = exynos_plane_get_type(tmp, CURSOR_WIN);
 494                 ret = exynos_plane_init(drm_dev, &ctx->planes[win],
 495                                 1 << ctx->pipe, type, decon_formats,
 496                                 ARRAY_SIZE(decon_formats), win);
 497                 if (ret)
 498                         return ret;
 499         }
 500
 501         exynos_plane = &ctx->planes[ctx->first_win];
 502         out_type = (ctx->out_type == IFTYPE_HDMI) ? EXYNOS_DISPLAY_TYPE_HDMI
 503                                                   : EXYNOS_DISPLAY_TYPE_LCD;
 504         ctx->crtc = exynos_drm_crtc_create(drm_dev, &exynos_plane->base,
 505                                         ctx->pipe, out_type,
 506                                         &decon_crtc_ops, ctx);
 507         if (IS_ERR(ctx->crtc)) {
 508                 ret = PTR_ERR(ctx->crtc);
 509                 goto err;
 510         }
 511
 512         decon_clear_channels(ctx->crtc);
 513
 514         ret = drm_iommu_attach_device(drm_dev, dev);
 515         if (ret)
 516                 goto err;
 517
 518         return ret;
 519 err:
 520         priv->pipe--;
 521         return ret;
 522 }
 523
 524 static void decon_unbind(struct device *dev, struct device *master, void *data)
 525 {
 526         struct decon_context *ctx = dev_get_drvdata(dev);
 527
 528         decon_disable(ctx->crtc);
 529
 530         /* detach this sub driver from iommu mapping if supported. */
 531         drm_iommu_detach_device(ctx->drm_dev, ctx->dev);
 532 }
 533
 534 static const struct component_ops decon_component_ops = {
 535         .bind   = decon_bind,
 536         .unbind = decon_unbind,
 537 };
 538
 539 static irqreturn_t decon_irq_handler(int irq, void *dev_id)
 540 {
 541         struct decon_context *ctx = dev_id;
 542         u32 val;
 543         int win;
 544
 545         if (!test_bit(BIT_CLKS_ENABLED, &ctx->flags))
 546                 goto out;
 547
 548         val = readl(ctx->addr + DECON_VIDINTCON1);
 549         val &= VIDINTCON1_INTFRMDONEPEND | VIDINTCON1_INTFRMPEND;
 550
 551         if (val) {
 552                 for (win = ctx->first_win; win < WINDOWS_NR ; win++) {
 553                         struct exynos_drm_plane *plane = &ctx->planes[win];
 554
 555                         if (!plane->pending_fb)
 556                                 continue;
 557
 558                         exynos_drm_crtc_finish_update(ctx->crtc, plane);
 559                 }
 560
 561                 /* clear */
 562                 writel(val, ctx->addr + DECON_VIDINTCON1);
 563         }
 564
 565 out:
 566         return IRQ_HANDLED;
 567 }
 568
 569 #ifdef CONFIG_PM
 570 static int exynos5433_decon_suspend(struct device *dev)
 571 {
 572         struct decon_context *ctx = dev_get_drvdata(dev);
 573         int i;
 574
 575         for (i = 0; i < ARRAY_SIZE(decon_clks_name); i++)
 576                 clk_disable_unprepare(ctx->clks[i]);
 577
 578         return 0;
 579 }
 580
 581 static int exynos5433_decon_resume(struct device *dev)
 582 {
 583         struct decon_context *ctx = dev_get_drvdata(dev);
 584         int i, ret;
 585
 586         for (i = 0; i < ARRAY_SIZE(decon_clks_name); i++) {
 587                 ret = clk_prepare_enable(ctx->clks[i]);
 588                 if (ret < 0)
 589                         goto err;
 590         }
 591
 592         return 0;
 593
 594 err:
 595         while (--i >= 0)
 596                 clk_disable_unprepare(ctx->clks[i]);
 597
 598         return ret;
 599 }
 600 #endif
 601
 602 static const struct dev_pm_ops exynos5433_decon_pm_ops = {
 603         SET_RUNTIME_PM_OPS(exynos5433_decon_suspend, exynos5433_decon_resume,
 604                            NULL)
 605 };
 606
 607 static const struct of_device_id exynos5433_decon_driver_dt_match[] = {
 608         {
 609                 .compatible = "samsung,exynos5433-decon",
 610                 .data = (void *)IFTYPE_RGB
 611         },
 612         {
 613                 .compatible = "samsung,exynos5433-decon-tv",
 614                 .data = (void *)IFTYPE_HDMI
 615         },
 616         {},
 617 };
 618 MODULE_DEVICE_TABLE(of, exynos5433_decon_driver_dt_match);
 619
 620 static int exynos5433_decon_probe(struct platform_device *pdev)
 621 {
 622         const struct of_device_id *of_id;
 623         struct device *dev = &pdev->dev;
 624         struct decon_context *ctx;
 625         struct resource *res;
 626         int ret;
 627         int i;
 628
 629         ctx = devm_kzalloc(dev, sizeof(*ctx), GFP_KERNEL);
 630         if (!ctx)
 631                 return -ENOMEM;
 632
 633         __set_bit(BIT_SUSPENDED, &ctx->flags);
 634         ctx->dev = dev;
 635
 636         of_id = of_match_device(exynos5433_decon_driver_dt_match, &pdev->dev);
 637         ctx->out_type = (enum decon_iftype)of_id->data;
 638
 639         if (ctx->out_type == IFTYPE_HDMI)
 640                 ctx->first_win = 1;
 641         else if (of_get_child_by_name(dev->of_node, "i80-if-timings"))
 642                 ctx->out_type = IFTYPE_I80;
 643
 644         for (i = 0; i < ARRAY_SIZE(decon_clks_name); i++) {
 645                 struct clk *clk;
 646
 647                 clk = devm_clk_get(ctx->dev, decon_clks_name[i]);
 648                 if (IS_ERR(clk))
 649                         return PTR_ERR(clk);
 650
 651                 ctx->clks[i] = clk;
 652         }
 653
 654         res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
 655         if (!res) {
 656                 dev_err(dev, "cannot find IO resource\n");
 657                 return -ENXIO;
 658         }
 659
 660         ctx->addr = devm_ioremap_resource(dev, res);
 661         if (IS_ERR(ctx->addr)) {
 662                 dev_err(dev, "ioremap failed\n");
 663                 return PTR_ERR(ctx->addr);
 664         }
 665
 666         res = platform_get_resource_byname(pdev, IORESOURCE_IRQ,
 667                         (ctx->out_type == IFTYPE_I80) ? "lcd_sys" : "vsync");
 668         if (!res) {
 669                 dev_err(dev, "cannot find IRQ resource\n");
 670                 return -ENXIO;
 671         }
 672
 673         ret = devm_request_irq(dev, res->start, decon_irq_handler, 0,
 674                                "drm_decon", ctx);
 675         if (ret < 0) {
 676                 dev_err(dev, "lcd_sys irq request failed\n");
 677                 return ret;
 678         }
 679
 680         platform_set_drvdata(pdev, ctx);
 681
 682         pm_runtime_enable(dev);
 683
 684         ret = component_add(dev, &decon_component_ops);
 685         if (ret)
 686                 goto err_disable_pm_runtime;
 687
 688         return 0;
 689
 690 err_disable_pm_runtime:
 691         pm_runtime_disable(dev);
 692
 693         return ret;
 694 }
 695
 696 static int exynos5433_decon_remove(struct platform_device *pdev)
 697 {
 698         pm_runtime_disable(&pdev->dev);
 699
 700         component_del(&pdev->dev, &decon_component_ops);
 701
 702         return 0;
 703 }
 704
 705 struct platform_driver exynos5433_decon_driver = {
 706         .probe          = exynos5433_decon_probe,
 707         .remove         = exynos5433_decon_remove,
 708         .driver         = {
 709                 .name   = "exynos5433-decon",
 710                 .pm     = &exynos5433_decon_pm_ops,
 711                 .of_match_table = exynos5433_decon_driver_dt_match,
 712         },
 713 };