drivers/gpu/drm/exynos/exynos_mixer.c

   1 /*
   2  * Copyright (C) 2011 Samsung Electronics Co.Ltd
   3  * Authors:
   4  * Seung-Woo Kim <sw0312.kim@samsung.com>
   5  *      Inki Dae <inki.dae@samsung.com>
   6  *      Joonyoung Shim <jy0922.shim@samsung.com>
   7  *
   8  * Based on drivers/media/video/s5p-tv/mixer_reg.c
   9  *
  10  * This program is free software; you can redistribute  it and/or modify it
  11  * under  the terms of  the GNU General  Public License as published by the
  12  * Free Software Foundation;  either version 2 of the  License, or (at your
  13  * option) any later version.
  14  *
  15  */
  16
  17 #include <drm/drmP.h>
  18
  19 #include "regs-mixer.h"
  20 #include "regs-vp.h"
  21
  22 #include <linux/kernel.h>
  23 #include <linux/spinlock.h>
  24 #include <linux/wait.h>
  25 #include <linux/i2c.h>
  26 #include <linux/platform_device.h>
  27 #include <linux/interrupt.h>
  28 #include <linux/irq.h>
  29 #include <linux/delay.h>
  30 #include <linux/pm_runtime.h>
  31 #include <linux/clk.h>
  32 #include <linux/regulator/consumer.h>
  33 #include <linux/of.h>
  34 #include <linux/of_device.h>
  35 #include <linux/component.h>
  36
  37 #include <drm/exynos_drm.h>
  38
  39 #include "exynos_drm_drv.h"
  40 #include "exynos_drm_crtc.h"
  41 #include "exynos_drm_fb.h"
  42 #include "exynos_drm_plane.h"
  43 #include "exynos_drm_iommu.h"
  44
  45 #define MIXER_WIN_NR            3
  46 #define VP_DEFAULT_WIN          2
  47
  48 /* The pixelformats that are natively supported by the mixer. */
  49 #define MXR_FORMAT_RGB565       4
  50 #define MXR_FORMAT_ARGB1555     5
  51 #define MXR_FORMAT_ARGB4444     6
  52 #define MXR_FORMAT_ARGB8888     7
  53
  54 struct mixer_resources {
  55         int                     irq;
  56         void __iomem            *mixer_regs;
  57         void __iomem            *vp_regs;
  58         spinlock_t              reg_slock;
  59         struct clk              *mixer;
  60         struct clk              *vp;
  61         struct clk              *hdmi;
  62         struct clk              *sclk_mixer;
  63         struct clk              *sclk_hdmi;
  64         struct clk              *mout_mixer;
  65 };
  66
  67 enum mixer_version_id {
  68         MXR_VER_0_0_0_16,
  69         MXR_VER_16_0_33_0,
  70         MXR_VER_128_0_0_184,
  71 };
  72
  73 enum mixer_flag_bits {
  74         MXR_BIT_POWERED,
  75         MXR_BIT_VSYNC,
  76         MXR_BIT_INTERLACE,
  77         MXR_BIT_VP_ENABLED,
  78         MXR_BIT_HAS_SCLK,
  79 };
  80
  81 static const uint32_t mixer_formats[] = {
  82         DRM_FORMAT_XRGB4444,
  83         DRM_FORMAT_ARGB4444,
  84         DRM_FORMAT_XRGB1555,
  85         DRM_FORMAT_ARGB1555,
  86         DRM_FORMAT_RGB565,
  87         DRM_FORMAT_XRGB8888,
  88         DRM_FORMAT_ARGB8888,
  89 };
  90
  91 static const uint32_t vp_formats[] = {
  92         DRM_FORMAT_NV12,
  93         DRM_FORMAT_NV21,
  94 };
  95
  96 struct mixer_context {
  97         struct platform_device *pdev;
  98         struct device           *dev;
  99         struct drm_device       *drm_dev;
 100         struct exynos_drm_crtc  *crtc;
 101         struct exynos_drm_plane planes[MIXER_WIN_NR];
 102         int                     pipe;
 103         unsigned long           flags;
 104
 105         struct mixer_resources  mixer_res;
 106         enum mixer_version_id   mxr_ver;
 107 };
 108
 109 struct mixer_drv_data {
 110         enum mixer_version_id   version;
 111         bool                                    is_vp_enabled;
 112         bool                                    has_sclk;
 113 };
 114
 115 static const struct exynos_drm_plane_config plane_configs[MIXER_WIN_NR] = {
 116         {
 117                 .zpos = 0,
 118                 .type = DRM_PLANE_TYPE_PRIMARY,
 119                 .pixel_formats = mixer_formats,
 120                 .num_pixel_formats = ARRAY_SIZE(mixer_formats),
 121                 .capabilities = EXYNOS_DRM_PLANE_CAP_DOUBLE |
 122                                 EXYNOS_DRM_PLANE_CAP_ZPOS,
 123         }, {
 124                 .zpos = 1,
 125                 .type = DRM_PLANE_TYPE_CURSOR,
 126                 .pixel_formats = mixer_formats,
 127                 .num_pixel_formats = ARRAY_SIZE(mixer_formats),
 128                 .capabilities = EXYNOS_DRM_PLANE_CAP_DOUBLE |
 129                                 EXYNOS_DRM_PLANE_CAP_ZPOS,
 130         }, {
 131                 .zpos = 2,
 132                 .type = DRM_PLANE_TYPE_OVERLAY,
 133                 .pixel_formats = vp_formats,
 134                 .num_pixel_formats = ARRAY_SIZE(vp_formats),
 135                 .capabilities = EXYNOS_DRM_PLANE_CAP_SCALE |
 136                                 EXYNOS_DRM_PLANE_CAP_ZPOS,
 137         },
 138 };
 139
 140 static const u8 filter_y_horiz_tap8[] = {
 141         0,      -1,     -1,     -1,     -1,     -1,     -1,     -1,
 142         -1,     -1,     -1,     -1,     -1,     0,      0,      0,
 143         0,      2,      4,      5,      6,      6,      6,      6,
 144         6,      5,      5,      4,      3,      2,      1,      1,
 145         0,      -6,     -12,    -16,    -18,    -20,    -21,    -20,
 146         -20,    -18,    -16,    -13,    -10,    -8,     -5,     -2,
 147         127,    126,    125,    121,    114,    107,    99,     89,
 148         79,     68,     57,     46,     35,     25,     16,     8,
 149 };
 150
 151 static const u8 filter_y_vert_tap4[] = {
 152         0,      -3,     -6,     -8,     -8,     -8,     -8,     -7,
 153         -6,     -5,     -4,     -3,     -2,     -1,     -1,     0,
 154         127,    126,    124,    118,    111,    102,    92,     81,
 155         70,     59,     48,     37,     27,     19,     11,     5,
 156         0,      5,      11,     19,     27,     37,     48,     59,
 157         70,     81,     92,     102,    111,    118,    124,    126,
 158         0,      0,      -1,     -1,     -2,     -3,     -4,     -5,
 159         -6,     -7,     -8,     -8,     -8,     -8,     -6,     -3,
 160 };
 161
 162 static const u8 filter_cr_horiz_tap4[] = {
 163         0,      -3,     -6,     -8,     -8,     -8,     -8,     -7,
 164         -6,     -5,     -4,     -3,     -2,     -1,     -1,     0,
 165         127,    126,    124,    118,    111,    102,    92,     81,
 166         70,     59,     48,     37,     27,     19,     11,     5,
 167 };
 168
 169 static inline bool is_alpha_format(unsigned int pixel_format)
 170 {
 171         switch (pixel_format) {
 172         case DRM_FORMAT_ARGB8888:
 173         case DRM_FORMAT_ARGB1555:
 174         case DRM_FORMAT_ARGB4444:
 175                 return true;
 176         default:
 177                 return false;
 178         }
 179 }
 180
 181 static inline u32 vp_reg_read(struct mixer_resources *res, u32 reg_id)
 182 {
 183         return readl(res->vp_regs + reg_id);
 184 }
 185
 186 static inline void vp_reg_write(struct mixer_resources *res, u32 reg_id,
 187                                  u32 val)
 188 {
 189         writel(val, res->vp_regs + reg_id);
 190 }
 191
 192 static inline void vp_reg_writemask(struct mixer_resources *res, u32 reg_id,
 193                                  u32 val, u32 mask)
 194 {
 195         u32 old = vp_reg_read(res, reg_id);
 196
 197         val = (val & mask) | (old & ~mask);
 198         writel(val, res->vp_regs + reg_id);
 199 }
 200
 201 static inline u32 mixer_reg_read(struct mixer_resources *res, u32 reg_id)
 202 {
 203         return readl(res->mixer_regs + reg_id);
 204 }
 205
 206 static inline void mixer_reg_write(struct mixer_resources *res, u32 reg_id,
 207                                  u32 val)
 208 {
 209         writel(val, res->mixer_regs + reg_id);
 210 }
 211
 212 static inline void mixer_reg_writemask(struct mixer_resources *res,
 213                                  u32 reg_id, u32 val, u32 mask)
 214 {
 215         u32 old = mixer_reg_read(res, reg_id);
 216
 217         val = (val & mask) | (old & ~mask);
 218         writel(val, res->mixer_regs + reg_id);
 219 }
 220
 221 static void mixer_regs_dump(struct mixer_context *ctx)
 222 {
 223 #define DUMPREG(reg_id) \
 224 do { \
 225         DRM_DEBUG_KMS(#reg_id " = %08x\n", \
 226                 (u32)readl(ctx->mixer_res.mixer_regs + reg_id)); \
 227 } while (0)
 228
 229         DUMPREG(MXR_STATUS);
 230         DUMPREG(MXR_CFG);
 231         DUMPREG(MXR_INT_EN);
 232         DUMPREG(MXR_INT_STATUS);
 233
 234         DUMPREG(MXR_LAYER_CFG);
 235         DUMPREG(MXR_VIDEO_CFG);
 236
 237         DUMPREG(MXR_GRAPHIC0_CFG);
 238         DUMPREG(MXR_GRAPHIC0_BASE);
 239         DUMPREG(MXR_GRAPHIC0_SPAN);
 240         DUMPREG(MXR_GRAPHIC0_WH);
 241         DUMPREG(MXR_GRAPHIC0_SXY);
 242         DUMPREG(MXR_GRAPHIC0_DXY);
 243
 244         DUMPREG(MXR_GRAPHIC1_CFG);
 245         DUMPREG(MXR_GRAPHIC1_BASE);
 246         DUMPREG(MXR_GRAPHIC1_SPAN);
 247         DUMPREG(MXR_GRAPHIC1_WH);
 248         DUMPREG(MXR_GRAPHIC1_SXY);
 249         DUMPREG(MXR_GRAPHIC1_DXY);
 250 #undef DUMPREG
 251 }
 252
 253 static void vp_regs_dump(struct mixer_context *ctx)
 254 {
 255 #define DUMPREG(reg_id) \
 256 do { \
 257         DRM_DEBUG_KMS(#reg_id " = %08x\n", \
 258                 (u32) readl(ctx->mixer_res.vp_regs + reg_id)); \
 259 } while (0)
 260
 261         DUMPREG(VP_ENABLE);
 262         DUMPREG(VP_SRESET);
 263         DUMPREG(VP_SHADOW_UPDATE);
 264         DUMPREG(VP_FIELD_ID);
 265         DUMPREG(VP_MODE);
 266         DUMPREG(VP_IMG_SIZE_Y);
 267         DUMPREG(VP_IMG_SIZE_C);
 268         DUMPREG(VP_PER_RATE_CTRL);
 269         DUMPREG(VP_TOP_Y_PTR);
 270         DUMPREG(VP_BOT_Y_PTR);
 271         DUMPREG(VP_TOP_C_PTR);
 272         DUMPREG(VP_BOT_C_PTR);
 273         DUMPREG(VP_ENDIAN_MODE);
 274         DUMPREG(VP_SRC_H_POSITION);
 275         DUMPREG(VP_SRC_V_POSITION);
 276         DUMPREG(VP_SRC_WIDTH);
 277         DUMPREG(VP_SRC_HEIGHT);
 278         DUMPREG(VP_DST_H_POSITION);
 279         DUMPREG(VP_DST_V_POSITION);
 280         DUMPREG(VP_DST_WIDTH);
 281         DUMPREG(VP_DST_HEIGHT);
 282         DUMPREG(VP_H_RATIO);
 283         DUMPREG(VP_V_RATIO);
 284
 285 #undef DUMPREG
 286 }
 287
 288 static inline void vp_filter_set(struct mixer_resources *res,
 289                 int reg_id, const u8 *data, unsigned int size)
 290 {
 291         /* assure 4-byte align */
 292         BUG_ON(size & 3);
 293         for (; size; size -= 4, reg_id += 4, data += 4) {
 294                 u32 val = (data[0] << 24) |  (data[1] << 16) |
 295                         (data[2] << 8) | data[3];
 296                 vp_reg_write(res, reg_id, val);
 297         }
 298 }
 299
 300 static void vp_default_filter(struct mixer_resources *res)
 301 {
 302         vp_filter_set(res, VP_POLY8_Y0_LL,
 303                 filter_y_horiz_tap8, sizeof(filter_y_horiz_tap8));
 304         vp_filter_set(res, VP_POLY4_Y0_LL,
 305                 filter_y_vert_tap4, sizeof(filter_y_vert_tap4));
 306         vp_filter_set(res, VP_POLY4_C0_LL,
 307                 filter_cr_horiz_tap4, sizeof(filter_cr_horiz_tap4));
 308 }
 309
 310 static void mixer_cfg_gfx_blend(struct mixer_context *ctx, unsigned int win,
 311                                 bool alpha)
 312 {
 313         struct mixer_resources *res = &ctx->mixer_res;
 314         u32 val;
 315
 316         val  = MXR_GRP_CFG_COLOR_KEY_DISABLE; /* no blank key */
 317         if (alpha) {
 318                 /* blending based on pixel alpha */
 319                 val |= MXR_GRP_CFG_BLEND_PRE_MUL;
 320                 val |= MXR_GRP_CFG_PIXEL_BLEND_EN;
 321         }
 322         mixer_reg_writemask(res, MXR_GRAPHIC_CFG(win),
 323                             val, MXR_GRP_CFG_MISC_MASK);
 324 }
 325
 326 static void mixer_cfg_vp_blend(struct mixer_context *ctx)
 327 {
 328         struct mixer_resources *res = &ctx->mixer_res;
 329         u32 val;
 330
 331         /*
 332          * No blending at the moment since the NV12/NV21 pixelformats don't
 333          * have an alpha channel. However the mixer supports a global alpha
 334          * value for a layer. Once this functionality is exposed, we can
 335          * support blending of the video layer through this.
 336          */
 337         val = 0;
 338         mixer_reg_write(res, MXR_VIDEO_CFG, val);
 339 }
 340
 341 static void mixer_vsync_set_update(struct mixer_context *ctx, bool enable)
 342 {
 343         struct mixer_resources *res = &ctx->mixer_res;
 344
 345         /* block update on vsync */
 346         mixer_reg_writemask(res, MXR_STATUS, enable ?
 347                         MXR_STATUS_SYNC_ENABLE : 0, MXR_STATUS_SYNC_ENABLE);
 348
 349         if (test_bit(MXR_BIT_VP_ENABLED, &ctx->flags))
 350                 vp_reg_write(res, VP_SHADOW_UPDATE, enable ?
 351                         VP_SHADOW_UPDATE_ENABLE : 0);
 352 }
 353
 354 static void mixer_cfg_scan(struct mixer_context *ctx, unsigned int height)
 355 {
 356         struct mixer_resources *res = &ctx->mixer_res;
 357         u32 val;
 358
 359         /* choosing between interlace and progressive mode */
 360         val = test_bit(MXR_BIT_INTERLACE, &ctx->flags) ?
 361                 MXR_CFG_SCAN_INTERLACE : MXR_CFG_SCAN_PROGRESSIVE;
 362
 363         if (ctx->mxr_ver != MXR_VER_128_0_0_184) {
 364                 /* choosing between proper HD and SD mode */
 365                 if (height <= 480)
 366                         val |= MXR_CFG_SCAN_NTSC | MXR_CFG_SCAN_SD;
 367                 else if (height <= 576)
 368                         val |= MXR_CFG_SCAN_PAL | MXR_CFG_SCAN_SD;
 369                 else if (height <= 720)
 370                         val |= MXR_CFG_SCAN_HD_720 | MXR_CFG_SCAN_HD;
 371                 else if (height <= 1080)
 372                         val |= MXR_CFG_SCAN_HD_1080 | MXR_CFG_SCAN_HD;
 373                 else
 374                         val |= MXR_CFG_SCAN_HD_720 | MXR_CFG_SCAN_HD;
 375         }
 376
 377         mixer_reg_writemask(res, MXR_CFG, val, MXR_CFG_SCAN_MASK);
 378 }
 379
 380 static void mixer_cfg_rgb_fmt(struct mixer_context *ctx, unsigned int height)
 381 {
 382         struct mixer_resources *res = &ctx->mixer_res;
 383         u32 val;
 384
 385         if (height == 480) {
 386                 val = MXR_CFG_RGB601_0_255;
 387         } else if (height == 576) {
 388                 val = MXR_CFG_RGB601_0_255;
 389         } else if (height == 720) {
 390                 val = MXR_CFG_RGB709_16_235;
 391                 mixer_reg_write(res, MXR_CM_COEFF_Y,
 392                                 (1 << 30) | (94 << 20) | (314 << 10) |
 393                                 (32 << 0));
 394                 mixer_reg_write(res, MXR_CM_COEFF_CB,
 395                                 (972 << 20) | (851 << 10) | (225 << 0));
 396                 mixer_reg_write(res, MXR_CM_COEFF_CR,
 397                                 (225 << 20) | (820 << 10) | (1004 << 0));
 398         } else if (height == 1080) {
 399                 val = MXR_CFG_RGB709_16_235;
 400                 mixer_reg_write(res, MXR_CM_COEFF_Y,
 401                                 (1 << 30) | (94 << 20) | (314 << 10) |
 402                                 (32 << 0));
 403                 mixer_reg_write(res, MXR_CM_COEFF_CB,
 404                                 (972 << 20) | (851 << 10) | (225 << 0));
 405                 mixer_reg_write(res, MXR_CM_COEFF_CR,
 406                                 (225 << 20) | (820 << 10) | (1004 << 0));
 407         } else {
 408                 val = MXR_CFG_RGB709_16_235;
 409                 mixer_reg_write(res, MXR_CM_COEFF_Y,
 410                                 (1 << 30) | (94 << 20) | (314 << 10) |
 411                                 (32 << 0));
 412                 mixer_reg_write(res, MXR_CM_COEFF_CB,
 413                                 (972 << 20) | (851 << 10) | (225 << 0));
 414                 mixer_reg_write(res, MXR_CM_COEFF_CR,
 415                                 (225 << 20) | (820 << 10) | (1004 << 0));
 416         }
 417
 418         mixer_reg_writemask(res, MXR_CFG, val, MXR_CFG_RGB_FMT_MASK);
 419 }
 420
 421 static void mixer_cfg_layer(struct mixer_context *ctx, unsigned int win,
 422                             unsigned int priority, bool enable)
 423 {
 424         struct mixer_resources *res = &ctx->mixer_res;
 425         u32 val = enable ? ~0 : 0;
 426
 427         switch (win) {
 428         case 0:
 429                 mixer_reg_writemask(res, MXR_CFG, val, MXR_CFG_GRP0_ENABLE);
 430                 mixer_reg_writemask(res, MXR_LAYER_CFG,
 431                                     MXR_LAYER_CFG_GRP0_VAL(priority),
 432                                     MXR_LAYER_CFG_GRP0_MASK);
 433                 break;
 434         case 1:
 435                 mixer_reg_writemask(res, MXR_CFG, val, MXR_CFG_GRP1_ENABLE);
 436                 mixer_reg_writemask(res, MXR_LAYER_CFG,
 437                                     MXR_LAYER_CFG_GRP1_VAL(priority),
 438                                     MXR_LAYER_CFG_GRP1_MASK);
 439
 440                 break;
 441         case VP_DEFAULT_WIN:
 442                 if (test_bit(MXR_BIT_VP_ENABLED, &ctx->flags)) {
 443                         vp_reg_writemask(res, VP_ENABLE, val, VP_ENABLE_ON);
 444                         mixer_reg_writemask(res, MXR_CFG, val,
 445                                 MXR_CFG_VP_ENABLE);
 446                         mixer_reg_writemask(res, MXR_LAYER_CFG,
 447                                             MXR_LAYER_CFG_VP_VAL(priority),
 448                                             MXR_LAYER_CFG_VP_MASK);
 449                 }
 450                 break;
 451         }
 452 }
 453
 454 static void mixer_run(struct mixer_context *ctx)
 455 {
 456         struct mixer_resources *res = &ctx->mixer_res;
 457
 458         mixer_reg_writemask(res, MXR_STATUS, ~0, MXR_STATUS_REG_RUN);
 459 }
 460
 461 static void mixer_stop(struct mixer_context *ctx)
 462 {
 463         struct mixer_resources *res = &ctx->mixer_res;
 464         int timeout = 20;
 465
 466         mixer_reg_writemask(res, MXR_STATUS, 0, MXR_STATUS_REG_RUN);
 467
 468         while (!(mixer_reg_read(res, MXR_STATUS) & MXR_STATUS_REG_IDLE) &&
 469                         --timeout)
 470                 usleep_range(10000, 12000);
 471 }
 472
 473 static void vp_video_buffer(struct mixer_context *ctx,
 474                             struct exynos_drm_plane *plane)
 475 {
 476         struct exynos_drm_plane_state *state =
 477                                 to_exynos_plane_state(plane->base.state);
 478         struct drm_display_mode *mode = &state->base.crtc->state->adjusted_mode;
 479         struct mixer_resources *res = &ctx->mixer_res;
 480         struct drm_framebuffer *fb = state->base.fb;
 481         unsigned int priority = state->base.normalized_zpos + 1;
 482         unsigned long flags;
 483         dma_addr_t luma_addr[2], chroma_addr[2];
 484         bool tiled_mode = false;
 485         bool crcb_mode = false;
 486         u32 val;
 487
 488         switch (fb->format->format) {
 489         case DRM_FORMAT_NV12:
 490                 crcb_mode = false;
 491                 break;
 492         case DRM_FORMAT_NV21:
 493                 crcb_mode = true;
 494                 break;
 495         default:
 496                 DRM_ERROR("pixel format for vp is wrong [%d].\n",
 497                                 fb->format->format);
 498                 return;
 499         }
 500
 501         luma_addr[0] = exynos_drm_fb_dma_addr(fb, 0);
 502         chroma_addr[0] = exynos_drm_fb_dma_addr(fb, 1);
 503
 504         if (mode->flags & DRM_MODE_FLAG_INTERLACE) {
 505                 __set_bit(MXR_BIT_INTERLACE, &ctx->flags);
 506                 if (tiled_mode) {
 507                         luma_addr[1] = luma_addr[0] + 0x40;
 508                         chroma_addr[1] = chroma_addr[0] + 0x40;
 509                 } else {
 510                         luma_addr[1] = luma_addr[0] + fb->pitches[0];
 511                         chroma_addr[1] = chroma_addr[0] + fb->pitches[0];
 512                 }
 513         } else {
 514                 __clear_bit(MXR_BIT_INTERLACE, &ctx->flags);
 515                 luma_addr[1] = 0;
 516                 chroma_addr[1] = 0;
 517         }
 518
 519         spin_lock_irqsave(&res->reg_slock, flags);
 520
 521         /* interlace or progressive scan mode */
 522         val = (test_bit(MXR_BIT_INTERLACE, &ctx->flags) ? ~0 : 0);
 523         vp_reg_writemask(res, VP_MODE, val, VP_MODE_LINE_SKIP);
 524
 525         /* setup format */
 526         val = (crcb_mode ? VP_MODE_NV21 : VP_MODE_NV12);
 527         val |= (tiled_mode ? VP_MODE_MEM_TILED : VP_MODE_MEM_LINEAR);
 528         vp_reg_writemask(res, VP_MODE, val, VP_MODE_FMT_MASK);
 529
 530         /* setting size of input image */
 531         vp_reg_write(res, VP_IMG_SIZE_Y, VP_IMG_HSIZE(fb->pitches[0]) |
 532                 VP_IMG_VSIZE(fb->height));
 533         /* chroma height has to reduced by 2 to avoid chroma distorions */
 534         vp_reg_write(res, VP_IMG_SIZE_C, VP_IMG_HSIZE(fb->pitches[0]) |
 535                 VP_IMG_VSIZE(fb->height / 2));
 536
 537         vp_reg_write(res, VP_SRC_WIDTH, state->src.w);
 538         vp_reg_write(res, VP_SRC_HEIGHT, state->src.h);
 539         vp_reg_write(res, VP_SRC_H_POSITION,
 540                         VP_SRC_H_POSITION_VAL(state->src.x));
 541         vp_reg_write(res, VP_SRC_V_POSITION, state->src.y);
 542
 543         vp_reg_write(res, VP_DST_WIDTH, state->crtc.w);
 544         vp_reg_write(res, VP_DST_H_POSITION, state->crtc.x);
 545         if (test_bit(MXR_BIT_INTERLACE, &ctx->flags)) {
 546                 vp_reg_write(res, VP_DST_HEIGHT, state->crtc.h / 2);
 547                 vp_reg_write(res, VP_DST_V_POSITION, state->crtc.y / 2);
 548         } else {
 549                 vp_reg_write(res, VP_DST_HEIGHT, state->crtc.h);
 550                 vp_reg_write(res, VP_DST_V_POSITION, state->crtc.y);
 551         }
 552
 553         vp_reg_write(res, VP_H_RATIO, state->h_ratio);
 554         vp_reg_write(res, VP_V_RATIO, state->v_ratio);
 555
 556         vp_reg_write(res, VP_ENDIAN_MODE, VP_ENDIAN_MODE_LITTLE);
 557
 558         /* set buffer address to vp */
 559         vp_reg_write(res, VP_TOP_Y_PTR, luma_addr[0]);
 560         vp_reg_write(res, VP_BOT_Y_PTR, luma_addr[1]);
 561         vp_reg_write(res, VP_TOP_C_PTR, chroma_addr[0]);
 562         vp_reg_write(res, VP_BOT_C_PTR, chroma_addr[1]);
 563
 564         mixer_cfg_scan(ctx, mode->vdisplay);
 565         mixer_cfg_rgb_fmt(ctx, mode->vdisplay);
 566         mixer_cfg_layer(ctx, plane->index, priority, true);
 567         mixer_cfg_vp_blend(ctx);
 568         mixer_run(ctx);
 569
 570         spin_unlock_irqrestore(&res->reg_slock, flags);
 571
 572         mixer_regs_dump(ctx);
 573         vp_regs_dump(ctx);
 574 }
 575
 576 static void mixer_layer_update(struct mixer_context *ctx)
 577 {
 578         struct mixer_resources *res = &ctx->mixer_res;
 579
 580         mixer_reg_writemask(res, MXR_CFG, ~0, MXR_CFG_LAYER_UPDATE);
 581 }
 582
 583 static void mixer_graph_buffer(struct mixer_context *ctx,
 584                                struct exynos_drm_plane *plane)
 585 {
 586         struct exynos_drm_plane_state *state =
 587                                 to_exynos_plane_state(plane->base.state);
 588         struct drm_display_mode *mode = &state->base.crtc->state->adjusted_mode;
 589         struct mixer_resources *res = &ctx->mixer_res;
 590         struct drm_framebuffer *fb = state->base.fb;
 591         unsigned int priority = state->base.normalized_zpos + 1;
 592         unsigned long flags;
 593         unsigned int win = plane->index;
 594         unsigned int x_ratio = 0, y_ratio = 0;
 595         unsigned int src_x_offset, src_y_offset, dst_x_offset, dst_y_offset;
 596         dma_addr_t dma_addr;
 597         unsigned int fmt;
 598         u32 val;
 599
 600         switch (fb->format->format) {
 601         case DRM_FORMAT_XRGB4444:
 602         case DRM_FORMAT_ARGB4444:
 603                 fmt = MXR_FORMAT_ARGB4444;
 604                 break;
 605
 606         case DRM_FORMAT_XRGB1555:
 607         case DRM_FORMAT_ARGB1555:
 608                 fmt = MXR_FORMAT_ARGB1555;
 609                 break;
 610
 611         case DRM_FORMAT_RGB565:
 612                 fmt = MXR_FORMAT_RGB565;
 613                 break;
 614
 615         case DRM_FORMAT_XRGB8888:
 616         case DRM_FORMAT_ARGB8888:
 617                 fmt = MXR_FORMAT_ARGB8888;
 618                 break;
 619
 620         default:
 621                 DRM_DEBUG_KMS("pixelformat unsupported by mixer\n");
 622                 return;
 623         }
 624
 625         /* ratio is already checked by common plane code */
 626         x_ratio = state->h_ratio == (1 << 15);
 627         y_ratio = state->v_ratio == (1 << 15);
 628
 629         dst_x_offset = state->crtc.x;
 630         dst_y_offset = state->crtc.y;
 631
 632         /* converting dma address base and source offset */
 633         dma_addr = exynos_drm_fb_dma_addr(fb, 0)
 634                 + (state->src.x * fb->format->cpp[0])
 635                 + (state->src.y * fb->pitches[0]);
 636         src_x_offset = 0;
 637         src_y_offset = 0;
 638
 639         if (mode->flags & DRM_MODE_FLAG_INTERLACE)
 640                 __set_bit(MXR_BIT_INTERLACE, &ctx->flags);
 641         else
 642                 __clear_bit(MXR_BIT_INTERLACE, &ctx->flags);
 643
 644         spin_lock_irqsave(&res->reg_slock, flags);
 645
 646         /* setup format */
 647         mixer_reg_writemask(res, MXR_GRAPHIC_CFG(win),
 648                 MXR_GRP_CFG_FORMAT_VAL(fmt), MXR_GRP_CFG_FORMAT_MASK);
 649
 650         /* setup geometry */
 651         mixer_reg_write(res, MXR_GRAPHIC_SPAN(win),
 652                         fb->pitches[0] / fb->format->cpp[0]);
 653
 654         /* setup display size */
 655         if (ctx->mxr_ver == MXR_VER_128_0_0_184 &&
 656                 win == DEFAULT_WIN) {
 657                 val  = MXR_MXR_RES_HEIGHT(mode->vdisplay);
 658                 val |= MXR_MXR_RES_WIDTH(mode->hdisplay);
 659                 mixer_reg_write(res, MXR_RESOLUTION, val);
 660         }
 661
 662         val  = MXR_GRP_WH_WIDTH(state->src.w);
 663         val |= MXR_GRP_WH_HEIGHT(state->src.h);
 664         val |= MXR_GRP_WH_H_SCALE(x_ratio);
 665         val |= MXR_GRP_WH_V_SCALE(y_ratio);
 666         mixer_reg_write(res, MXR_GRAPHIC_WH(win), val);
 667
 668         /* setup offsets in source image */
 669         val  = MXR_GRP_SXY_SX(src_x_offset);
 670         val |= MXR_GRP_SXY_SY(src_y_offset);
 671         mixer_reg_write(res, MXR_GRAPHIC_SXY(win), val);
 672
 673         /* setup offsets in display image */
 674         val  = MXR_GRP_DXY_DX(dst_x_offset);
 675         val |= MXR_GRP_DXY_DY(dst_y_offset);
 676         mixer_reg_write(res, MXR_GRAPHIC_DXY(win), val);
 677
 678         /* set buffer address to mixer */
 679         mixer_reg_write(res, MXR_GRAPHIC_BASE(win), dma_addr);
 680
 681         mixer_cfg_scan(ctx, mode->vdisplay);
 682         mixer_cfg_rgb_fmt(ctx, mode->vdisplay);
 683         mixer_cfg_layer(ctx, win, priority, true);
 684         mixer_cfg_gfx_blend(ctx, win, is_alpha_format(fb->format->format));
 685
 686         /* layer update mandatory for mixer 16.0.33.0 */
 687         if (ctx->mxr_ver == MXR_VER_16_0_33_0 ||
 688                 ctx->mxr_ver == MXR_VER_128_0_0_184)
 689                 mixer_layer_update(ctx);
 690
 691         mixer_run(ctx);
 692
 693         spin_unlock_irqrestore(&res->reg_slock, flags);
 694
 695         mixer_regs_dump(ctx);
 696 }
 697
 698 static void vp_win_reset(struct mixer_context *ctx)
 699 {
 700         struct mixer_resources *res = &ctx->mixer_res;
 701         unsigned int tries = 100;
 702
 703         vp_reg_write(res, VP_SRESET, VP_SRESET_PROCESSING);
 704         while (--tries) {
 705                 /* waiting until VP_SRESET_PROCESSING is 0 */
 706                 if (~vp_reg_read(res, VP_SRESET) & VP_SRESET_PROCESSING)
 707                         break;
 708                 mdelay(10);
 709         }
 710         WARN(tries == 0, "failed to reset Video Processor\n");
 711 }
 712
 713 static void mixer_win_reset(struct mixer_context *ctx)
 714 {
 715         struct mixer_resources *res = &ctx->mixer_res;
 716         unsigned long flags;
 717
 718         spin_lock_irqsave(&res->reg_slock, flags);
 719
 720         mixer_reg_writemask(res, MXR_CFG, MXR_CFG_DST_HDMI, MXR_CFG_DST_MASK);
 721
 722         /* set output in RGB888 mode */
 723         mixer_reg_writemask(res, MXR_CFG, MXR_CFG_OUT_RGB888, MXR_CFG_OUT_MASK);
 724
 725         /* 16 beat burst in DMA */
 726         mixer_reg_writemask(res, MXR_STATUS, MXR_STATUS_16_BURST,
 727                 MXR_STATUS_BURST_MASK);
 728
 729         /* reset default layer priority */
 730         mixer_reg_write(res, MXR_LAYER_CFG, 0);
 731
 732         /* setting background color */
 733         mixer_reg_write(res, MXR_BG_COLOR0, 0x008080);
 734         mixer_reg_write(res, MXR_BG_COLOR1, 0x008080);
 735         mixer_reg_write(res, MXR_BG_COLOR2, 0x008080);
 736
 737         if (test_bit(MXR_BIT_VP_ENABLED, &ctx->flags)) {
 738                 /* configuration of Video Processor Registers */
 739                 vp_win_reset(ctx);
 740                 vp_default_filter(res);
 741         }
 742
 743         /* disable all layers */
 744         mixer_reg_writemask(res, MXR_CFG, 0, MXR_CFG_GRP0_ENABLE);
 745         mixer_reg_writemask(res, MXR_CFG, 0, MXR_CFG_GRP1_ENABLE);
 746         if (test_bit(MXR_BIT_VP_ENABLED, &ctx->flags))
 747                 mixer_reg_writemask(res, MXR_CFG, 0, MXR_CFG_VP_ENABLE);
 748
 749         spin_unlock_irqrestore(&res->reg_slock, flags);
 750 }
 751
 752 static irqreturn_t mixer_irq_handler(int irq, void *arg)
 753 {
 754         struct mixer_context *ctx = arg;
 755         struct mixer_resources *res = &ctx->mixer_res;
 756         u32 val, base, shadow;
 757
 758         spin_lock(&res->reg_slock);
 759
 760         /* read interrupt status for handling and clearing flags for VSYNC */
 761         val = mixer_reg_read(res, MXR_INT_STATUS);
 762
 763         /* handling VSYNC */
 764         if (val & MXR_INT_STATUS_VSYNC) {
 765                 /* vsync interrupt use different bit for read and clear */
 766                 val |= MXR_INT_CLEAR_VSYNC;
 767                 val &= ~MXR_INT_STATUS_VSYNC;
 768
 769                 /* interlace scan need to check shadow register */
 770                 if (test_bit(MXR_BIT_INTERLACE, &ctx->flags)) {
 771                         base = mixer_reg_read(res, MXR_GRAPHIC_BASE(0));
 772                         shadow = mixer_reg_read(res, MXR_GRAPHIC_BASE_S(0));
 773                         if (base != shadow)
 774                                 goto out;
 775
 776                         base = mixer_reg_read(res, MXR_GRAPHIC_BASE(1));
 777                         shadow = mixer_reg_read(res, MXR_GRAPHIC_BASE_S(1));
 778                         if (base != shadow)
 779                                 goto out;
 780                 }
 781
 782                 drm_crtc_handle_vblank(&ctx->crtc->base);
 783         }
 784
 785 out:
 786         /* clear interrupts */
 787         mixer_reg_write(res, MXR_INT_STATUS, val);
 788
 789         spin_unlock(&res->reg_slock);
 790
 791         return IRQ_HANDLED;
 792 }
 793
 794 static int mixer_resources_init(struct mixer_context *mixer_ctx)
 795 {
 796         struct device *dev = &mixer_ctx->pdev->dev;
 797         struct mixer_resources *mixer_res = &mixer_ctx->mixer_res;
 798         struct resource *res;
 799         int ret;
 800
 801         spin_lock_init(&mixer_res->reg_slock);
 802
 803         mixer_res->mixer = devm_clk_get(dev, "mixer");
 804         if (IS_ERR(mixer_res->mixer)) {
 805                 dev_err(dev, "failed to get clock 'mixer'\n");
 806                 return -ENODEV;
 807         }
 808
 809         mixer_res->hdmi = devm_clk_get(dev, "hdmi");
 810         if (IS_ERR(mixer_res->hdmi)) {
 811                 dev_err(dev, "failed to get clock 'hdmi'\n");
 812                 return PTR_ERR(mixer_res->hdmi);
 813         }
 814
 815         mixer_res->sclk_hdmi = devm_clk_get(dev, "sclk_hdmi");
 816         if (IS_ERR(mixer_res->sclk_hdmi)) {
 817                 dev_err(dev, "failed to get clock 'sclk_hdmi'\n");
 818                 return -ENODEV;
 819         }
 820         res = platform_get_resource(mixer_ctx->pdev, IORESOURCE_MEM, 0);
 821         if (res == NULL) {
 822                 dev_err(dev, "get memory resource failed.\n");
 823                 return -ENXIO;
 824         }
 825
 826         mixer_res->mixer_regs = devm_ioremap(dev, res->start,
 827                                                         resource_size(res));
 828         if (mixer_res->mixer_regs == NULL) {
 829                 dev_err(dev, "register mapping failed.\n");
 830                 return -ENXIO;
 831         }
 832
 833         res = platform_get_resource(mixer_ctx->pdev, IORESOURCE_IRQ, 0);
 834         if (res == NULL) {
 835                 dev_err(dev, "get interrupt resource failed.\n");
 836                 return -ENXIO;
 837         }
 838
 839         ret = devm_request_irq(dev, res->start, mixer_irq_handler,
 840                                                 0, "drm_mixer", mixer_ctx);
 841         if (ret) {
 842                 dev_err(dev, "request interrupt failed.\n");
 843                 return ret;
 844         }
 845         mixer_res->irq = res->start;
 846
 847         return 0;
 848 }
 849
 850 static int vp_resources_init(struct mixer_context *mixer_ctx)
 851 {
 852         struct device *dev = &mixer_ctx->pdev->dev;
 853         struct mixer_resources *mixer_res = &mixer_ctx->mixer_res;
 854         struct resource *res;
 855
 856         mixer_res->vp = devm_clk_get(dev, "vp");
 857         if (IS_ERR(mixer_res->vp)) {
 858                 dev_err(dev, "failed to get clock 'vp'\n");
 859                 return -ENODEV;
 860         }
 861
 862         if (test_bit(MXR_BIT_HAS_SCLK, &mixer_ctx->flags)) {
 863                 mixer_res->sclk_mixer = devm_clk_get(dev, "sclk_mixer");
 864                 if (IS_ERR(mixer_res->sclk_mixer)) {
 865                         dev_err(dev, "failed to get clock 'sclk_mixer'\n");
 866                         return -ENODEV;
 867                 }
 868                 mixer_res->mout_mixer = devm_clk_get(dev, "mout_mixer");
 869                 if (IS_ERR(mixer_res->mout_mixer)) {
 870                         dev_err(dev, "failed to get clock 'mout_mixer'\n");
 871                         return -ENODEV;
 872                 }
 873
 874                 if (mixer_res->sclk_hdmi && mixer_res->mout_mixer)
 875                         clk_set_parent(mixer_res->mout_mixer,
 876                                        mixer_res->sclk_hdmi);
 877         }
 878
 879         res = platform_get_resource(mixer_ctx->pdev, IORESOURCE_MEM, 1);
 880         if (res == NULL) {
 881                 dev_err(dev, "get memory resource failed.\n");
 882                 return -ENXIO;
 883         }
 884
 885         mixer_res->vp_regs = devm_ioremap(dev, res->start,
 886                                                         resource_size(res));
 887         if (mixer_res->vp_regs == NULL) {
 888                 dev_err(dev, "register mapping failed.\n");
 889                 return -ENXIO;
 890         }
 891
 892         return 0;
 893 }
 894
 895 static int mixer_initialize(struct mixer_context *mixer_ctx,
 896                         struct drm_device *drm_dev)
 897 {
 898         int ret;
 899         struct exynos_drm_private *priv;
 900         priv = drm_dev->dev_private;
 901
 902         mixer_ctx->drm_dev = drm_dev;
 903         mixer_ctx->pipe = drm_dev->mode_config.num_crtc;
 904
 905         /* acquire resources: regs, irqs, clocks */
 906         ret = mixer_resources_init(mixer_ctx);
 907         if (ret) {
 908                 DRM_ERROR("mixer_resources_init failed ret=%d\n", ret);
 909                 return ret;
 910         }
 911
 912         if (test_bit(MXR_BIT_VP_ENABLED, &mixer_ctx->flags)) {
 913                 /* acquire vp resources: regs, irqs, clocks */
 914                 ret = vp_resources_init(mixer_ctx);
 915                 if (ret) {
 916                         DRM_ERROR("vp_resources_init failed ret=%d\n", ret);
 917                         return ret;
 918                 }
 919         }
 920
 921         return drm_iommu_attach_device(drm_dev, mixer_ctx->dev);
 922 }
 923
 924 static void mixer_ctx_remove(struct mixer_context *mixer_ctx)
 925 {
 926         drm_iommu_detach_device(mixer_ctx->drm_dev, mixer_ctx->dev);
 927 }
 928
 929 static int mixer_enable_vblank(struct exynos_drm_crtc *crtc)
 930 {
 931         struct mixer_context *mixer_ctx = crtc->ctx;
 932         struct mixer_resources *res = &mixer_ctx->mixer_res;
 933
 934         __set_bit(MXR_BIT_VSYNC, &mixer_ctx->flags);
 935         if (!test_bit(MXR_BIT_POWERED, &mixer_ctx->flags))
 936                 return 0;
 937
 938         /* enable vsync interrupt */
 939         mixer_reg_writemask(res, MXR_INT_STATUS, ~0, MXR_INT_CLEAR_VSYNC);
 940         mixer_reg_writemask(res, MXR_INT_EN, ~0, MXR_INT_EN_VSYNC);
 941
 942         return 0;
 943 }
 944
 945 static void mixer_disable_vblank(struct exynos_drm_crtc *crtc)
 946 {
 947         struct mixer_context *mixer_ctx = crtc->ctx;
 948         struct mixer_resources *res = &mixer_ctx->mixer_res;
 949
 950         __clear_bit(MXR_BIT_VSYNC, &mixer_ctx->flags);
 951
 952         if (!test_bit(MXR_BIT_POWERED, &mixer_ctx->flags))
 953                 return;
 954
 955         /* disable vsync interrupt */
 956         mixer_reg_writemask(res, MXR_INT_STATUS, ~0, MXR_INT_CLEAR_VSYNC);
 957         mixer_reg_writemask(res, MXR_INT_EN, 0, MXR_INT_EN_VSYNC);
 958 }
 959
 960 static void mixer_atomic_begin(struct exynos_drm_crtc *crtc)
 961 {
 962         struct mixer_context *mixer_ctx = crtc->ctx;
 963
 964         if (!test_bit(MXR_BIT_POWERED, &mixer_ctx->flags))
 965                 return;
 966
 967         mixer_vsync_set_update(mixer_ctx, false);
 968 }
 969
 970 static void mixer_update_plane(struct exynos_drm_crtc *crtc,
 971                                struct exynos_drm_plane *plane)
 972 {
 973         struct mixer_context *mixer_ctx = crtc->ctx;
 974
 975         DRM_DEBUG_KMS("win: %d\n", plane->index);
 976
 977         if (!test_bit(MXR_BIT_POWERED, &mixer_ctx->flags))
 978                 return;
 979
 980         if (plane->index == VP_DEFAULT_WIN)
 981                 vp_video_buffer(mixer_ctx, plane);
 982         else
 983                 mixer_graph_buffer(mixer_ctx, plane);
 984 }
 985
 986 static void mixer_disable_plane(struct exynos_drm_crtc *crtc,
 987                                 struct exynos_drm_plane *plane)
 988 {
 989         struct mixer_context *mixer_ctx = crtc->ctx;
 990         struct mixer_resources *res = &mixer_ctx->mixer_res;
 991         unsigned long flags;
 992
 993         DRM_DEBUG_KMS("win: %d\n", plane->index);
 994
 995         if (!test_bit(MXR_BIT_POWERED, &mixer_ctx->flags))
 996                 return;
 997
 998         spin_lock_irqsave(&res->reg_slock, flags);
 999         mixer_cfg_layer(mixer_ctx, plane->index, 0, false);
1000         spin_unlock_irqrestore(&res->reg_slock, flags);
1001 }
1002
1003 static void mixer_atomic_flush(struct exynos_drm_crtc *crtc)
1004 {
1005         struct mixer_context *mixer_ctx = crtc->ctx;
1006
1007         if (!test_bit(MXR_BIT_POWERED, &mixer_ctx->flags))
1008                 return;
1009
1010         mixer_vsync_set_update(mixer_ctx, true);
1011         exynos_crtc_handle_event(crtc);
1012 }
1013
1014 static void mixer_enable(struct exynos_drm_crtc *crtc)
1015 {
1016         struct mixer_context *ctx = crtc->ctx;
1017         struct mixer_resources *res = &ctx->mixer_res;
1018
1019         if (test_bit(MXR_BIT_POWERED, &ctx->flags))
1020                 return;
1021
1022         pm_runtime_get_sync(ctx->dev);
1023
1024         exynos_drm_pipe_clk_enable(crtc, true);
1025
1026         mixer_vsync_set_update(ctx, false);
1027
1028         mixer_reg_writemask(res, MXR_STATUS, ~0, MXR_STATUS_SOFT_RESET);
1029
1030         if (test_bit(MXR_BIT_VSYNC, &ctx->flags)) {
1031                 mixer_reg_writemask(res, MXR_INT_STATUS, ~0, MXR_INT_CLEAR_VSYNC);
1032                 mixer_reg_writemask(res, MXR_INT_EN, ~0, MXR_INT_EN_VSYNC);
1033         }
1034         mixer_win_reset(ctx);
1035
1036         mixer_vsync_set_update(ctx, true);
1037
1038         set_bit(MXR_BIT_POWERED, &ctx->flags);
1039 }
1040
1041 static void mixer_disable(struct exynos_drm_crtc *crtc)
1042 {
1043         struct mixer_context *ctx = crtc->ctx;
1044         int i;
1045
1046         if (!test_bit(MXR_BIT_POWERED, &ctx->flags))
1047                 return;
1048
1049         mixer_stop(ctx);
1050         mixer_regs_dump(ctx);
1051
1052         for (i = 0; i < MIXER_WIN_NR; i++)
1053                 mixer_disable_plane(crtc, &ctx->planes[i]);
1054
1055         exynos_drm_pipe_clk_enable(crtc, false);
1056
1057         pm_runtime_put(ctx->dev);
1058
1059         clear_bit(MXR_BIT_POWERED, &ctx->flags);
1060 }
1061
1062 /* Only valid for Mixer version 16.0.33.0 */
1063 static int mixer_atomic_check(struct exynos_drm_crtc *crtc,
1064                        struct drm_crtc_state *state)
1065 {
1066         struct drm_display_mode *mode = &state->adjusted_mode;
1067         u32 w, h;
1068
1069         w = mode->hdisplay;
1070         h = mode->vdisplay;
1071
1072         DRM_DEBUG_KMS("xres=%d, yres=%d, refresh=%d, intl=%d\n",
1073                 mode->hdisplay, mode->vdisplay, mode->vrefresh,
1074                 (mode->flags & DRM_MODE_FLAG_INTERLACE) ? 1 : 0);
1075
1076         if ((w >= 464 && w <= 720 && h >= 261 && h <= 576) ||
1077                 (w >= 1024 && w <= 1280 && h >= 576 && h <= 720) ||
1078                 (w >= 1664 && w <= 1920 && h >= 936 && h <= 1080))
1079                 return 0;
1080
1081         return -EINVAL;
1082 }
1083
1084 static const struct exynos_drm_crtc_ops mixer_crtc_ops = {
1085         .enable                 = mixer_enable,
1086         .disable                = mixer_disable,
1087         .enable_vblank          = mixer_enable_vblank,
1088         .disable_vblank         = mixer_disable_vblank,
1089         .atomic_begin           = mixer_atomic_begin,
1090         .update_plane           = mixer_update_plane,
1091         .disable_plane          = mixer_disable_plane,
1092         .atomic_flush           = mixer_atomic_flush,
1093         .atomic_check           = mixer_atomic_check,
1094 };
1095
1096 static struct mixer_drv_data exynos5420_mxr_drv_data = {
1097         .version = MXR_VER_128_0_0_184,
1098         .is_vp_enabled = 0,
1099 };
1100
1101 static struct mixer_drv_data exynos5250_mxr_drv_data = {
1102         .version = MXR_VER_16_0_33_0,
1103         .is_vp_enabled = 0,
1104 };
1105
1106 static struct mixer_drv_data exynos4212_mxr_drv_data = {
1107         .version = MXR_VER_0_0_0_16,
1108         .is_vp_enabled = 1,
1109 };
1110
1111 static struct mixer_drv_data exynos4210_mxr_drv_data = {
1112         .version = MXR_VER_0_0_0_16,
1113         .is_vp_enabled = 1,
1114         .has_sclk = 1,
1115 };
1116
1117 static struct of_device_id mixer_match_types[] = {
1118         {
1119                 .compatible = "samsung,exynos4210-mixer",
1120                 .data   = &exynos4210_mxr_drv_data,
1121         }, {
1122                 .compatible = "samsung,exynos4212-mixer",
1123                 .data   = &exynos4212_mxr_drv_data,
1124         }, {
1125                 .compatible = "samsung,exynos5-mixer",
1126                 .data   = &exynos5250_mxr_drv_data,
1127         }, {
1128                 .compatible = "samsung,exynos5250-mixer",
1129                 .data   = &exynos5250_mxr_drv_data,
1130         }, {
1131                 .compatible = "samsung,exynos5420-mixer",
1132                 .data   = &exynos5420_mxr_drv_data,
1133         }, {
1134                 /* end node */
1135         }
1136 };
1137 MODULE_DEVICE_TABLE(of, mixer_match_types);
1138
1139 static int mixer_bind(struct device *dev, struct device *manager, void *data)
1140 {
1141         struct mixer_context *ctx = dev_get_drvdata(dev);
1142         struct drm_device *drm_dev = data;
1143         struct exynos_drm_plane *exynos_plane;
1144         unsigned int i;
1145         int ret;
1146
1147         ret = mixer_initialize(ctx, drm_dev);
1148         if (ret)
1149                 return ret;
1150
1151         for (i = 0; i < MIXER_WIN_NR; i++) {
1152                 if (i == VP_DEFAULT_WIN && !test_bit(MXR_BIT_VP_ENABLED,
1153                                                      &ctx->flags))
1154                         continue;
1155
1156                 ret = exynos_plane_init(drm_dev, &ctx->planes[i], i,
1157                                         &plane_configs[i]);
1158                 if (ret)
1159                         return ret;
1160         }
1161
1162         exynos_plane = &ctx->planes[DEFAULT_WIN];
1163         ctx->crtc = exynos_drm_crtc_create(drm_dev, &exynos_plane->base,
1164                         EXYNOS_DISPLAY_TYPE_HDMI, &mixer_crtc_ops, ctx);
1165         if (IS_ERR(ctx->crtc)) {
1166                 mixer_ctx_remove(ctx);
1167                 ret = PTR_ERR(ctx->crtc);
1168                 goto free_ctx;
1169         }
1170
1171         return 0;
1172
1173 free_ctx:
1174         devm_kfree(dev, ctx);
1175         return ret;
1176 }
1177
1178 static void mixer_unbind(struct device *dev, struct device *master, void *data)
1179 {
1180         struct mixer_context *ctx = dev_get_drvdata(dev);
1181
1182         mixer_ctx_remove(ctx);
1183 }
1184
1185 static const struct component_ops mixer_component_ops = {
1186         .bind   = mixer_bind,
1187         .unbind = mixer_unbind,
1188 };
1189
1190 static int mixer_probe(struct platform_device *pdev)
1191 {
1192         struct device *dev = &pdev->dev;
1193         const struct mixer_drv_data *drv;
1194         struct mixer_context *ctx;
1195         int ret;
1196
1197         ctx = devm_kzalloc(&pdev->dev, sizeof(*ctx), GFP_KERNEL);
1198         if (!ctx) {
1199                 DRM_ERROR("failed to alloc mixer context.\n");
1200                 return -ENOMEM;
1201         }
1202
1203         drv = of_device_get_match_data(dev);
1204
1205         ctx->pdev = pdev;
1206         ctx->dev = dev;
1207         ctx->mxr_ver = drv->version;
1208
1209         if (drv->is_vp_enabled)
1210                 __set_bit(MXR_BIT_VP_ENABLED, &ctx->flags);
1211         if (drv->has_sclk)
1212                 __set_bit(MXR_BIT_HAS_SCLK, &ctx->flags);
1213
1214         platform_set_drvdata(pdev, ctx);
1215
1216         ret = component_add(&pdev->dev, &mixer_component_ops);
1217         if (!ret)
1218                 pm_runtime_enable(dev);
1219
1220         return ret;
1221 }
1222
1223 static int mixer_remove(struct platform_device *pdev)
1224 {
1225         pm_runtime_disable(&pdev->dev);
1226
1227         component_del(&pdev->dev, &mixer_component_ops);
1228
1229         return 0;
1230 }
1231
1232 static int __maybe_unused exynos_mixer_suspend(struct device *dev)
1233 {
1234         struct mixer_context *ctx = dev_get_drvdata(dev);
1235         struct mixer_resources *res = &ctx->mixer_res;
1236
1237         clk_disable_unprepare(res->hdmi);
1238         clk_disable_unprepare(res->mixer);
1239         if (test_bit(MXR_BIT_VP_ENABLED, &ctx->flags)) {
1240                 clk_disable_unprepare(res->vp);
1241                 if (test_bit(MXR_BIT_HAS_SCLK, &ctx->flags))
1242                         clk_disable_unprepare(res->sclk_mixer);
1243         }
1244
1245         return 0;
1246 }
1247
1248 static int __maybe_unused exynos_mixer_resume(struct device *dev)
1249 {
1250         struct mixer_context *ctx = dev_get_drvdata(dev);
1251         struct mixer_resources *res = &ctx->mixer_res;
1252         int ret;
1253
1254         ret = clk_prepare_enable(res->mixer);
1255         if (ret < 0) {
1256                 DRM_ERROR("Failed to prepare_enable the mixer clk [%d]\n", ret);
1257                 return ret;
1258         }
1259         ret = clk_prepare_enable(res->hdmi);
1260         if (ret < 0) {
1261                 DRM_ERROR("Failed to prepare_enable the hdmi clk [%d]\n", ret);
1262                 return ret;
1263         }
1264         if (test_bit(MXR_BIT_VP_ENABLED, &ctx->flags)) {
1265                 ret = clk_prepare_enable(res->vp);
1266                 if (ret < 0) {
1267                         DRM_ERROR("Failed to prepare_enable the vp clk [%d]\n",
1268                                   ret);
1269                         return ret;
1270                 }
1271                 if (test_bit(MXR_BIT_HAS_SCLK, &ctx->flags)) {
1272                         ret = clk_prepare_enable(res->sclk_mixer);
1273                         if (ret < 0) {
1274                                 DRM_ERROR("Failed to prepare_enable the " \
1275                                            "sclk_mixer clk [%d]\n",
1276                                           ret);
1277                                 return ret;
1278                         }
1279                 }
1280         }
1281
1282         return 0;
1283 }
1284
1285 static const struct dev_pm_ops exynos_mixer_pm_ops = {
1286         SET_RUNTIME_PM_OPS(exynos_mixer_suspend, exynos_mixer_resume, NULL)
1287 };
1288
1289 struct platform_driver mixer_driver = {
1290         .driver = {
1291                 .name = "exynos-mixer",
1292                 .owner = THIS_MODULE,
1293                 .pm = &exynos_mixer_pm_ops,
1294                 .of_match_table = mixer_match_types,
1295         },
1296         .probe = mixer_probe,
1297         .remove = mixer_remove,
1298 };