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