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