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