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