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