2 * Copyright (C) 2012 Samsung Electronics Co.Ltd
4 * Eunchul Kim <chulspro.kim@samsung.com>
5 * Jinyoung Jeon <jy0.jeon@samsung.com>
6 * Sangmin Lee <lsmin.lee@samsung.com>
8 * This program is free software; you can redistribute it and/or modify it
9 * under the terms of the GNU General Public License as published by the
10 * Free Software Foundation; either version 2 of the License, or (at your
11 * option) any later version.
14 #include <linux/kernel.h>
15 #include <linux/module.h>
16 #include <linux/platform_device.h>
17 #include <linux/mfd/syscon.h>
18 #include <linux/regmap.h>
19 #include <linux/clk.h>
20 #include <linux/pm_runtime.h>
23 #include <drm/exynos_drm.h>
24 #include "regs-fimc.h"
25 #include "exynos_drm_ipp.h"
26 #include "exynos_drm_fimc.h"
29 * FIMC stands for Fully Interactive Mobile Camera and
30 * supports image scaler/rotator and input/output DMA operations.
31 * input DMA reads image data from the memory.
32 * output DMA writes image data to memory.
33 * FIMC supports image rotation and image effect functions.
35 * M2M operation : supports crop/scale/rotation/csc so on.
36 * Memory ----> FIMC H/W ----> Memory.
37 * Writeback operation : supports cloned screen with FIMD.
38 * FIMD ----> FIMC H/W ----> Memory.
39 * Output operation : supports direct display using local path.
40 * Memory ----> FIMC H/W ----> FIMD.
45 * 1. check suspend/resume api if needed.
46 * 2. need to check use case platform_device_id.
47 * 3. check src/dst size with, height.
48 * 4. added check_prepare api for right register.
49 * 5. need to add supported list in prop_list.
50 * 6. check prescaler/scaler optimization.
53 #define FIMC_MAX_DEVS 4
54 #define FIMC_MAX_SRC 2
55 #define FIMC_MAX_DST 32
56 #define FIMC_SHFACTOR 10
57 #define FIMC_BUF_STOP 1
58 #define FIMC_BUF_START 2
59 #define FIMC_REG_SZ 32
60 #define FIMC_WIDTH_ITU_709 1280
61 #define FIMC_REFRESH_MAX 60
62 #define FIMC_REFRESH_MIN 12
63 #define FIMC_CROP_MAX 8192
64 #define FIMC_CROP_MIN 32
65 #define FIMC_SCALE_MAX 4224
66 #define FIMC_SCALE_MIN 32
68 #define get_fimc_context(dev) platform_get_drvdata(to_platform_device(dev))
69 #define get_ctx_from_ippdrv(ippdrv) container_of(ippdrv,\
70 struct fimc_context, ippdrv);
71 #define fimc_read(offset) readl(ctx->regs + (offset))
72 #define fimc_write(cfg, offset) writel(cfg, ctx->regs + (offset))
90 static const char * const fimc_clock_names
[] = {
91 [FIMC_CLK_LCLK
] = "sclk_fimc",
92 [FIMC_CLK_GATE
] = "fimc",
93 [FIMC_CLK_WB_A
] = "pxl_async0",
94 [FIMC_CLK_WB_B
] = "pxl_async1",
95 [FIMC_CLK_MUX
] = "mux",
96 [FIMC_CLK_PARENT
] = "parent",
99 #define FIMC_DEFAULT_LCLK_FREQUENCY 133000000UL
102 * A structure of scaler.
104 * @range: narrow, wide.
105 * @bypass: unused scaler path.
106 * @up_h: horizontal scale up.
107 * @up_v: vertical scale up.
108 * @hratio: horizontal ratio.
109 * @vratio: vertical ratio.
121 * A structure of scaler capability.
123 * find user manual table 43-1.
124 * @in_hori: scaler input horizontal size.
125 * @bypass: scaler bypass mode.
126 * @dst_h_wo_rot: target horizontal size without output rotation.
127 * @dst_h_rot: target horizontal size with output rotation.
128 * @rl_w_wo_rot: real width without input rotation.
129 * @rl_h_rot: real height without output rotation.
131 struct fimc_capability
{
144 * A structure of fimc context.
146 * @ippdrv: prepare initialization using ippdrv.
147 * @regs_res: register resources.
148 * @regs: memory mapped io registers.
149 * @lock: locking of operations.
150 * @clocks: fimc clocks.
151 * @clk_frequency: LCLK clock frequency.
152 * @sysreg: handle to SYSREG block regmap.
153 * @sc: scaler infomations.
154 * @pol: porarity of writeback.
157 * @suspended: qos operations.
159 struct fimc_context
{
160 struct exynos_drm_ippdrv ippdrv
;
161 struct resource
*regs_res
;
164 struct clk
*clocks
[FIMC_CLKS_MAX
];
166 struct regmap
*sysreg
;
167 struct fimc_scaler sc
;
168 struct exynos_drm_ipp_pol pol
;
174 static void fimc_sw_reset(struct fimc_context
*ctx
)
178 /* stop dma operation */
179 cfg
= fimc_read(EXYNOS_CISTATUS
);
180 if (EXYNOS_CISTATUS_GET_ENVID_STATUS(cfg
)) {
181 cfg
= fimc_read(EXYNOS_MSCTRL
);
182 cfg
&= ~EXYNOS_MSCTRL_ENVID
;
183 fimc_write(cfg
, EXYNOS_MSCTRL
);
186 cfg
= fimc_read(EXYNOS_CISRCFMT
);
187 cfg
|= EXYNOS_CISRCFMT_ITU601_8BIT
;
188 fimc_write(cfg
, EXYNOS_CISRCFMT
);
190 /* disable image capture */
191 cfg
= fimc_read(EXYNOS_CIIMGCPT
);
192 cfg
&= ~(EXYNOS_CIIMGCPT_IMGCPTEN_SC
| EXYNOS_CIIMGCPT_IMGCPTEN
);
193 fimc_write(cfg
, EXYNOS_CIIMGCPT
);
196 cfg
= fimc_read(EXYNOS_CIGCTRL
);
197 cfg
|= (EXYNOS_CIGCTRL_SWRST
);
198 fimc_write(cfg
, EXYNOS_CIGCTRL
);
200 /* s/w reset complete */
201 cfg
= fimc_read(EXYNOS_CIGCTRL
);
202 cfg
&= ~EXYNOS_CIGCTRL_SWRST
;
203 fimc_write(cfg
, EXYNOS_CIGCTRL
);
206 fimc_write(0x0, EXYNOS_CIFCNTSEQ
);
209 static int fimc_set_camblk_fimd0_wb(struct fimc_context
*ctx
)
211 return regmap_update_bits(ctx
->sysreg
, SYSREG_CAMERA_BLK
,
212 SYSREG_FIMD0WB_DEST_MASK
,
213 ctx
->id
<< SYSREG_FIMD0WB_DEST_SHIFT
);
216 static void fimc_set_type_ctrl(struct fimc_context
*ctx
, enum fimc_wb wb
)
220 DRM_DEBUG_KMS("%s:wb[%d]\n", __func__
, wb
);
222 cfg
= fimc_read(EXYNOS_CIGCTRL
);
223 cfg
&= ~(EXYNOS_CIGCTRL_TESTPATTERN_MASK
|
224 EXYNOS_CIGCTRL_SELCAM_ITU_MASK
|
225 EXYNOS_CIGCTRL_SELCAM_MIPI_MASK
|
226 EXYNOS_CIGCTRL_SELCAM_FIMC_MASK
|
227 EXYNOS_CIGCTRL_SELWB_CAMIF_MASK
|
228 EXYNOS_CIGCTRL_SELWRITEBACK_MASK
);
232 cfg
|= (EXYNOS_CIGCTRL_SELWRITEBACK_A
|
233 EXYNOS_CIGCTRL_SELWB_CAMIF_WRITEBACK
);
236 cfg
|= (EXYNOS_CIGCTRL_SELWRITEBACK_B
|
237 EXYNOS_CIGCTRL_SELWB_CAMIF_WRITEBACK
);
241 cfg
|= (EXYNOS_CIGCTRL_SELCAM_ITU_A
|
242 EXYNOS_CIGCTRL_SELWRITEBACK_A
|
243 EXYNOS_CIGCTRL_SELCAM_MIPI_A
|
244 EXYNOS_CIGCTRL_SELCAM_FIMC_ITU
);
248 fimc_write(cfg
, EXYNOS_CIGCTRL
);
251 static void fimc_set_polarity(struct fimc_context
*ctx
,
252 struct exynos_drm_ipp_pol
*pol
)
256 DRM_DEBUG_KMS("%s:inv_pclk[%d]inv_vsync[%d]\n",
257 __func__
, pol
->inv_pclk
, pol
->inv_vsync
);
258 DRM_DEBUG_KMS("%s:inv_href[%d]inv_hsync[%d]\n",
259 __func__
, pol
->inv_href
, pol
->inv_hsync
);
261 cfg
= fimc_read(EXYNOS_CIGCTRL
);
262 cfg
&= ~(EXYNOS_CIGCTRL_INVPOLPCLK
| EXYNOS_CIGCTRL_INVPOLVSYNC
|
263 EXYNOS_CIGCTRL_INVPOLHREF
| EXYNOS_CIGCTRL_INVPOLHSYNC
);
266 cfg
|= EXYNOS_CIGCTRL_INVPOLPCLK
;
268 cfg
|= EXYNOS_CIGCTRL_INVPOLVSYNC
;
270 cfg
|= EXYNOS_CIGCTRL_INVPOLHREF
;
272 cfg
|= EXYNOS_CIGCTRL_INVPOLHSYNC
;
274 fimc_write(cfg
, EXYNOS_CIGCTRL
);
277 static void fimc_handle_jpeg(struct fimc_context
*ctx
, bool enable
)
281 DRM_DEBUG_KMS("%s:enable[%d]\n", __func__
, enable
);
283 cfg
= fimc_read(EXYNOS_CIGCTRL
);
285 cfg
|= EXYNOS_CIGCTRL_CAM_JPEG
;
287 cfg
&= ~EXYNOS_CIGCTRL_CAM_JPEG
;
289 fimc_write(cfg
, EXYNOS_CIGCTRL
);
292 static void fimc_handle_irq(struct fimc_context
*ctx
, bool enable
,
293 bool overflow
, bool level
)
297 DRM_DEBUG_KMS("%s:enable[%d]overflow[%d]level[%d]\n", __func__
,
298 enable
, overflow
, level
);
300 cfg
= fimc_read(EXYNOS_CIGCTRL
);
302 cfg
&= ~(EXYNOS_CIGCTRL_IRQ_OVFEN
| EXYNOS_CIGCTRL_IRQ_LEVEL
);
303 cfg
|= EXYNOS_CIGCTRL_IRQ_ENABLE
;
305 cfg
|= EXYNOS_CIGCTRL_IRQ_OVFEN
;
307 cfg
|= EXYNOS_CIGCTRL_IRQ_LEVEL
;
309 cfg
&= ~(EXYNOS_CIGCTRL_IRQ_OVFEN
| EXYNOS_CIGCTRL_IRQ_ENABLE
);
311 fimc_write(cfg
, EXYNOS_CIGCTRL
);
314 static void fimc_clear_irq(struct fimc_context
*ctx
)
318 cfg
= fimc_read(EXYNOS_CIGCTRL
);
319 cfg
|= EXYNOS_CIGCTRL_IRQ_CLR
;
320 fimc_write(cfg
, EXYNOS_CIGCTRL
);
323 static bool fimc_check_ovf(struct fimc_context
*ctx
)
325 struct exynos_drm_ippdrv
*ippdrv
= &ctx
->ippdrv
;
326 u32 cfg
, status
, flag
;
328 status
= fimc_read(EXYNOS_CISTATUS
);
329 flag
= EXYNOS_CISTATUS_OVFIY
| EXYNOS_CISTATUS_OVFICB
|
330 EXYNOS_CISTATUS_OVFICR
;
332 DRM_DEBUG_KMS("%s:flag[0x%x]\n", __func__
, flag
);
335 cfg
= fimc_read(EXYNOS_CIWDOFST
);
336 cfg
|= (EXYNOS_CIWDOFST_CLROVFIY
| EXYNOS_CIWDOFST_CLROVFICB
|
337 EXYNOS_CIWDOFST_CLROVFICR
);
339 fimc_write(cfg
, EXYNOS_CIWDOFST
);
341 cfg
= fimc_read(EXYNOS_CIWDOFST
);
342 cfg
&= ~(EXYNOS_CIWDOFST_CLROVFIY
| EXYNOS_CIWDOFST_CLROVFICB
|
343 EXYNOS_CIWDOFST_CLROVFICR
);
345 fimc_write(cfg
, EXYNOS_CIWDOFST
);
347 dev_err(ippdrv
->dev
, "occured overflow at %d, status 0x%x.\n",
355 static bool fimc_check_frame_end(struct fimc_context
*ctx
)
359 cfg
= fimc_read(EXYNOS_CISTATUS
);
361 DRM_DEBUG_KMS("%s:cfg[0x%x]\n", __func__
, cfg
);
363 if (!(cfg
& EXYNOS_CISTATUS_FRAMEEND
))
366 cfg
&= ~(EXYNOS_CISTATUS_FRAMEEND
);
367 fimc_write(cfg
, EXYNOS_CISTATUS
);
372 static int fimc_get_buf_id(struct fimc_context
*ctx
)
375 int frame_cnt
, buf_id
;
377 cfg
= fimc_read(EXYNOS_CISTATUS2
);
378 frame_cnt
= EXYNOS_CISTATUS2_GET_FRAMECOUNT_BEFORE(cfg
);
381 frame_cnt
= EXYNOS_CISTATUS2_GET_FRAMECOUNT_PRESENT(cfg
);
383 DRM_DEBUG_KMS("%s:present[%d]before[%d]\n", __func__
,
384 EXYNOS_CISTATUS2_GET_FRAMECOUNT_PRESENT(cfg
),
385 EXYNOS_CISTATUS2_GET_FRAMECOUNT_BEFORE(cfg
));
387 if (frame_cnt
== 0) {
388 DRM_ERROR("failed to get frame count.\n");
392 buf_id
= frame_cnt
- 1;
393 DRM_DEBUG_KMS("%s:buf_id[%d]\n", __func__
, buf_id
);
398 static void fimc_handle_lastend(struct fimc_context
*ctx
, bool enable
)
402 DRM_DEBUG_KMS("%s:enable[%d]\n", __func__
, enable
);
404 cfg
= fimc_read(EXYNOS_CIOCTRL
);
406 cfg
|= EXYNOS_CIOCTRL_LASTENDEN
;
408 cfg
&= ~EXYNOS_CIOCTRL_LASTENDEN
;
410 fimc_write(cfg
, EXYNOS_CIOCTRL
);
414 static int fimc_src_set_fmt_order(struct fimc_context
*ctx
, u32 fmt
)
416 struct exynos_drm_ippdrv
*ippdrv
= &ctx
->ippdrv
;
419 DRM_DEBUG_KMS("%s:fmt[0x%x]\n", __func__
, fmt
);
422 cfg
= fimc_read(EXYNOS_CISCCTRL
);
423 cfg
&= ~EXYNOS_CISCCTRL_INRGB_FMT_RGB_MASK
;
426 case DRM_FORMAT_RGB565
:
427 cfg
|= EXYNOS_CISCCTRL_INRGB_FMT_RGB565
;
428 fimc_write(cfg
, EXYNOS_CISCCTRL
);
430 case DRM_FORMAT_RGB888
:
431 case DRM_FORMAT_XRGB8888
:
432 cfg
|= EXYNOS_CISCCTRL_INRGB_FMT_RGB888
;
433 fimc_write(cfg
, EXYNOS_CISCCTRL
);
441 cfg
= fimc_read(EXYNOS_MSCTRL
);
442 cfg
&= ~(EXYNOS_MSCTRL_ORDER2P_SHIFT_MASK
|
443 EXYNOS_MSCTRL_C_INT_IN_2PLANE
|
444 EXYNOS_MSCTRL_ORDER422_YCBYCR
);
447 case DRM_FORMAT_YUYV
:
448 cfg
|= EXYNOS_MSCTRL_ORDER422_YCBYCR
;
450 case DRM_FORMAT_YVYU
:
451 cfg
|= EXYNOS_MSCTRL_ORDER422_YCRYCB
;
453 case DRM_FORMAT_UYVY
:
454 cfg
|= EXYNOS_MSCTRL_ORDER422_CBYCRY
;
456 case DRM_FORMAT_VYUY
:
457 case DRM_FORMAT_YUV444
:
458 cfg
|= EXYNOS_MSCTRL_ORDER422_CRYCBY
;
460 case DRM_FORMAT_NV21
:
461 case DRM_FORMAT_NV61
:
462 cfg
|= (EXYNOS_MSCTRL_ORDER2P_LSB_CRCB
|
463 EXYNOS_MSCTRL_C_INT_IN_2PLANE
);
465 case DRM_FORMAT_YUV422
:
466 case DRM_FORMAT_YUV420
:
467 case DRM_FORMAT_YVU420
:
468 cfg
|= EXYNOS_MSCTRL_C_INT_IN_3PLANE
;
470 case DRM_FORMAT_NV12
:
471 case DRM_FORMAT_NV12MT
:
472 case DRM_FORMAT_NV16
:
473 cfg
|= (EXYNOS_MSCTRL_ORDER2P_LSB_CBCR
|
474 EXYNOS_MSCTRL_C_INT_IN_2PLANE
);
477 dev_err(ippdrv
->dev
, "inavlid source yuv order 0x%x.\n", fmt
);
481 fimc_write(cfg
, EXYNOS_MSCTRL
);
486 static int fimc_src_set_fmt(struct device
*dev
, u32 fmt
)
488 struct fimc_context
*ctx
= get_fimc_context(dev
);
489 struct exynos_drm_ippdrv
*ippdrv
= &ctx
->ippdrv
;
492 DRM_DEBUG_KMS("%s:fmt[0x%x]\n", __func__
, fmt
);
494 cfg
= fimc_read(EXYNOS_MSCTRL
);
495 cfg
&= ~EXYNOS_MSCTRL_INFORMAT_RGB
;
498 case DRM_FORMAT_RGB565
:
499 case DRM_FORMAT_RGB888
:
500 case DRM_FORMAT_XRGB8888
:
501 cfg
|= EXYNOS_MSCTRL_INFORMAT_RGB
;
503 case DRM_FORMAT_YUV444
:
504 cfg
|= EXYNOS_MSCTRL_INFORMAT_YCBCR420
;
506 case DRM_FORMAT_YUYV
:
507 case DRM_FORMAT_YVYU
:
508 case DRM_FORMAT_UYVY
:
509 case DRM_FORMAT_VYUY
:
510 cfg
|= EXYNOS_MSCTRL_INFORMAT_YCBCR422_1PLANE
;
512 case DRM_FORMAT_NV16
:
513 case DRM_FORMAT_NV61
:
514 case DRM_FORMAT_YUV422
:
515 cfg
|= EXYNOS_MSCTRL_INFORMAT_YCBCR422
;
517 case DRM_FORMAT_YUV420
:
518 case DRM_FORMAT_YVU420
:
519 case DRM_FORMAT_NV12
:
520 case DRM_FORMAT_NV21
:
521 case DRM_FORMAT_NV12MT
:
522 cfg
|= EXYNOS_MSCTRL_INFORMAT_YCBCR420
;
525 dev_err(ippdrv
->dev
, "inavlid source format 0x%x.\n", fmt
);
529 fimc_write(cfg
, EXYNOS_MSCTRL
);
531 cfg
= fimc_read(EXYNOS_CIDMAPARAM
);
532 cfg
&= ~EXYNOS_CIDMAPARAM_R_MODE_MASK
;
534 if (fmt
== DRM_FORMAT_NV12MT
)
535 cfg
|= EXYNOS_CIDMAPARAM_R_MODE_64X32
;
537 cfg
|= EXYNOS_CIDMAPARAM_R_MODE_LINEAR
;
539 fimc_write(cfg
, EXYNOS_CIDMAPARAM
);
541 return fimc_src_set_fmt_order(ctx
, fmt
);
544 static int fimc_src_set_transf(struct device
*dev
,
545 enum drm_exynos_degree degree
,
546 enum drm_exynos_flip flip
, bool *swap
)
548 struct fimc_context
*ctx
= get_fimc_context(dev
);
549 struct exynos_drm_ippdrv
*ippdrv
= &ctx
->ippdrv
;
552 DRM_DEBUG_KMS("%s:degree[%d]flip[0x%x]\n", __func__
,
555 cfg1
= fimc_read(EXYNOS_MSCTRL
);
556 cfg1
&= ~(EXYNOS_MSCTRL_FLIP_X_MIRROR
|
557 EXYNOS_MSCTRL_FLIP_Y_MIRROR
);
559 cfg2
= fimc_read(EXYNOS_CITRGFMT
);
560 cfg2
&= ~EXYNOS_CITRGFMT_INROT90_CLOCKWISE
;
563 case EXYNOS_DRM_DEGREE_0
:
564 if (flip
& EXYNOS_DRM_FLIP_VERTICAL
)
565 cfg1
|= EXYNOS_MSCTRL_FLIP_X_MIRROR
;
566 if (flip
& EXYNOS_DRM_FLIP_HORIZONTAL
)
567 cfg1
|= EXYNOS_MSCTRL_FLIP_Y_MIRROR
;
569 case EXYNOS_DRM_DEGREE_90
:
570 cfg2
|= EXYNOS_CITRGFMT_INROT90_CLOCKWISE
;
571 if (flip
& EXYNOS_DRM_FLIP_VERTICAL
)
572 cfg1
|= EXYNOS_MSCTRL_FLIP_X_MIRROR
;
573 if (flip
& EXYNOS_DRM_FLIP_HORIZONTAL
)
574 cfg1
|= EXYNOS_MSCTRL_FLIP_Y_MIRROR
;
576 case EXYNOS_DRM_DEGREE_180
:
577 cfg1
|= (EXYNOS_MSCTRL_FLIP_X_MIRROR
|
578 EXYNOS_MSCTRL_FLIP_Y_MIRROR
);
579 if (flip
& EXYNOS_DRM_FLIP_VERTICAL
)
580 cfg1
&= ~EXYNOS_MSCTRL_FLIP_X_MIRROR
;
581 if (flip
& EXYNOS_DRM_FLIP_HORIZONTAL
)
582 cfg1
&= ~EXYNOS_MSCTRL_FLIP_Y_MIRROR
;
584 case EXYNOS_DRM_DEGREE_270
:
585 cfg1
|= (EXYNOS_MSCTRL_FLIP_X_MIRROR
|
586 EXYNOS_MSCTRL_FLIP_Y_MIRROR
);
587 cfg2
|= EXYNOS_CITRGFMT_INROT90_CLOCKWISE
;
588 if (flip
& EXYNOS_DRM_FLIP_VERTICAL
)
589 cfg1
&= ~EXYNOS_MSCTRL_FLIP_X_MIRROR
;
590 if (flip
& EXYNOS_DRM_FLIP_HORIZONTAL
)
591 cfg1
&= ~EXYNOS_MSCTRL_FLIP_Y_MIRROR
;
594 dev_err(ippdrv
->dev
, "inavlid degree value %d.\n", degree
);
598 fimc_write(cfg1
, EXYNOS_MSCTRL
);
599 fimc_write(cfg2
, EXYNOS_CITRGFMT
);
600 *swap
= (cfg2
& EXYNOS_CITRGFMT_INROT90_CLOCKWISE
) ? 1 : 0;
605 static int fimc_set_window(struct fimc_context
*ctx
,
606 struct drm_exynos_pos
*pos
, struct drm_exynos_sz
*sz
)
608 u32 cfg
, h1
, h2
, v1
, v2
;
612 h2
= sz
->hsize
- pos
->w
- pos
->x
;
614 v2
= sz
->vsize
- pos
->h
- pos
->y
;
616 DRM_DEBUG_KMS("%s:x[%d]y[%d]w[%d]h[%d]hsize[%d]vsize[%d]\n",
617 __func__
, pos
->x
, pos
->y
, pos
->w
, pos
->h
, sz
->hsize
, sz
->vsize
);
618 DRM_DEBUG_KMS("%s:h1[%d]h2[%d]v1[%d]v2[%d]\n", __func__
,
622 * set window offset 1, 2 size
623 * check figure 43-21 in user manual
625 cfg
= fimc_read(EXYNOS_CIWDOFST
);
626 cfg
&= ~(EXYNOS_CIWDOFST_WINHOROFST_MASK
|
627 EXYNOS_CIWDOFST_WINVEROFST_MASK
);
628 cfg
|= (EXYNOS_CIWDOFST_WINHOROFST(h1
) |
629 EXYNOS_CIWDOFST_WINVEROFST(v1
));
630 cfg
|= EXYNOS_CIWDOFST_WINOFSEN
;
631 fimc_write(cfg
, EXYNOS_CIWDOFST
);
633 cfg
= (EXYNOS_CIWDOFST2_WINHOROFST2(h2
) |
634 EXYNOS_CIWDOFST2_WINVEROFST2(v2
));
635 fimc_write(cfg
, EXYNOS_CIWDOFST2
);
640 static int fimc_src_set_size(struct device
*dev
, int swap
,
641 struct drm_exynos_pos
*pos
, struct drm_exynos_sz
*sz
)
643 struct fimc_context
*ctx
= get_fimc_context(dev
);
644 struct drm_exynos_pos img_pos
= *pos
;
645 struct drm_exynos_sz img_sz
= *sz
;
648 DRM_DEBUG_KMS("%s:swap[%d]hsize[%d]vsize[%d]\n",
649 __func__
, swap
, sz
->hsize
, sz
->vsize
);
652 cfg
= (EXYNOS_ORGISIZE_HORIZONTAL(img_sz
.hsize
) |
653 EXYNOS_ORGISIZE_VERTICAL(img_sz
.vsize
));
655 fimc_write(cfg
, EXYNOS_ORGISIZE
);
657 DRM_DEBUG_KMS("%s:x[%d]y[%d]w[%d]h[%d]\n", __func__
,
658 pos
->x
, pos
->y
, pos
->w
, pos
->h
);
663 img_sz
.hsize
= sz
->vsize
;
664 img_sz
.vsize
= sz
->hsize
;
667 /* set input DMA image size */
668 cfg
= fimc_read(EXYNOS_CIREAL_ISIZE
);
669 cfg
&= ~(EXYNOS_CIREAL_ISIZE_HEIGHT_MASK
|
670 EXYNOS_CIREAL_ISIZE_WIDTH_MASK
);
671 cfg
|= (EXYNOS_CIREAL_ISIZE_WIDTH(img_pos
.w
) |
672 EXYNOS_CIREAL_ISIZE_HEIGHT(img_pos
.h
));
673 fimc_write(cfg
, EXYNOS_CIREAL_ISIZE
);
676 * set input FIFO image size
677 * for now, we support only ITU601 8 bit mode
679 cfg
= (EXYNOS_CISRCFMT_ITU601_8BIT
|
680 EXYNOS_CISRCFMT_SOURCEHSIZE(img_sz
.hsize
) |
681 EXYNOS_CISRCFMT_SOURCEVSIZE(img_sz
.vsize
));
682 fimc_write(cfg
, EXYNOS_CISRCFMT
);
684 /* offset Y(RGB), Cb, Cr */
685 cfg
= (EXYNOS_CIIYOFF_HORIZONTAL(img_pos
.x
) |
686 EXYNOS_CIIYOFF_VERTICAL(img_pos
.y
));
687 fimc_write(cfg
, EXYNOS_CIIYOFF
);
688 cfg
= (EXYNOS_CIICBOFF_HORIZONTAL(img_pos
.x
) |
689 EXYNOS_CIICBOFF_VERTICAL(img_pos
.y
));
690 fimc_write(cfg
, EXYNOS_CIICBOFF
);
691 cfg
= (EXYNOS_CIICROFF_HORIZONTAL(img_pos
.x
) |
692 EXYNOS_CIICROFF_VERTICAL(img_pos
.y
));
693 fimc_write(cfg
, EXYNOS_CIICROFF
);
695 return fimc_set_window(ctx
, &img_pos
, &img_sz
);
698 static int fimc_src_set_addr(struct device
*dev
,
699 struct drm_exynos_ipp_buf_info
*buf_info
, u32 buf_id
,
700 enum drm_exynos_ipp_buf_type buf_type
)
702 struct fimc_context
*ctx
= get_fimc_context(dev
);
703 struct exynos_drm_ippdrv
*ippdrv
= &ctx
->ippdrv
;
704 struct drm_exynos_ipp_cmd_node
*c_node
= ippdrv
->c_node
;
705 struct drm_exynos_ipp_property
*property
;
706 struct drm_exynos_ipp_config
*config
;
709 DRM_ERROR("failed to get c_node.\n");
713 property
= &c_node
->property
;
715 DRM_DEBUG_KMS("%s:prop_id[%d]buf_id[%d]buf_type[%d]\n", __func__
,
716 property
->prop_id
, buf_id
, buf_type
);
718 if (buf_id
> FIMC_MAX_SRC
) {
719 dev_info(ippdrv
->dev
, "inavlid buf_id %d.\n", buf_id
);
723 /* address register set */
725 case IPP_BUF_ENQUEUE
:
726 config
= &property
->config
[EXYNOS_DRM_OPS_SRC
];
727 fimc_write(buf_info
->base
[EXYNOS_DRM_PLANAR_Y
],
728 EXYNOS_CIIYSA(buf_id
));
730 if (config
->fmt
== DRM_FORMAT_YVU420
) {
731 fimc_write(buf_info
->base
[EXYNOS_DRM_PLANAR_CR
],
732 EXYNOS_CIICBSA(buf_id
));
733 fimc_write(buf_info
->base
[EXYNOS_DRM_PLANAR_CB
],
734 EXYNOS_CIICRSA(buf_id
));
736 fimc_write(buf_info
->base
[EXYNOS_DRM_PLANAR_CB
],
737 EXYNOS_CIICBSA(buf_id
));
738 fimc_write(buf_info
->base
[EXYNOS_DRM_PLANAR_CR
],
739 EXYNOS_CIICRSA(buf_id
));
742 case IPP_BUF_DEQUEUE
:
743 fimc_write(0x0, EXYNOS_CIIYSA(buf_id
));
744 fimc_write(0x0, EXYNOS_CIICBSA(buf_id
));
745 fimc_write(0x0, EXYNOS_CIICRSA(buf_id
));
755 static struct exynos_drm_ipp_ops fimc_src_ops
= {
756 .set_fmt
= fimc_src_set_fmt
,
757 .set_transf
= fimc_src_set_transf
,
758 .set_size
= fimc_src_set_size
,
759 .set_addr
= fimc_src_set_addr
,
762 static int fimc_dst_set_fmt_order(struct fimc_context
*ctx
, u32 fmt
)
764 struct exynos_drm_ippdrv
*ippdrv
= &ctx
->ippdrv
;
767 DRM_DEBUG_KMS("%s:fmt[0x%x]\n", __func__
, fmt
);
770 cfg
= fimc_read(EXYNOS_CISCCTRL
);
771 cfg
&= ~EXYNOS_CISCCTRL_OUTRGB_FMT_RGB_MASK
;
774 case DRM_FORMAT_RGB565
:
775 cfg
|= EXYNOS_CISCCTRL_OUTRGB_FMT_RGB565
;
776 fimc_write(cfg
, EXYNOS_CISCCTRL
);
778 case DRM_FORMAT_RGB888
:
779 cfg
|= EXYNOS_CISCCTRL_OUTRGB_FMT_RGB888
;
780 fimc_write(cfg
, EXYNOS_CISCCTRL
);
782 case DRM_FORMAT_XRGB8888
:
783 cfg
|= (EXYNOS_CISCCTRL_OUTRGB_FMT_RGB888
|
784 EXYNOS_CISCCTRL_EXTRGB_EXTENSION
);
785 fimc_write(cfg
, EXYNOS_CISCCTRL
);
793 cfg
= fimc_read(EXYNOS_CIOCTRL
);
794 cfg
&= ~(EXYNOS_CIOCTRL_ORDER2P_MASK
|
795 EXYNOS_CIOCTRL_ORDER422_MASK
|
796 EXYNOS_CIOCTRL_YCBCR_PLANE_MASK
);
799 case DRM_FORMAT_XRGB8888
:
800 cfg
|= EXYNOS_CIOCTRL_ALPHA_OUT
;
802 case DRM_FORMAT_YUYV
:
803 cfg
|= EXYNOS_CIOCTRL_ORDER422_YCBYCR
;
805 case DRM_FORMAT_YVYU
:
806 cfg
|= EXYNOS_CIOCTRL_ORDER422_YCRYCB
;
808 case DRM_FORMAT_UYVY
:
809 cfg
|= EXYNOS_CIOCTRL_ORDER422_CBYCRY
;
811 case DRM_FORMAT_VYUY
:
812 cfg
|= EXYNOS_CIOCTRL_ORDER422_CRYCBY
;
814 case DRM_FORMAT_NV21
:
815 case DRM_FORMAT_NV61
:
816 cfg
|= EXYNOS_CIOCTRL_ORDER2P_LSB_CRCB
;
817 cfg
|= EXYNOS_CIOCTRL_YCBCR_2PLANE
;
819 case DRM_FORMAT_YUV422
:
820 case DRM_FORMAT_YUV420
:
821 case DRM_FORMAT_YVU420
:
822 cfg
|= EXYNOS_CIOCTRL_YCBCR_3PLANE
;
824 case DRM_FORMAT_NV12
:
825 case DRM_FORMAT_NV12MT
:
826 case DRM_FORMAT_NV16
:
827 cfg
|= EXYNOS_CIOCTRL_ORDER2P_LSB_CBCR
;
828 cfg
|= EXYNOS_CIOCTRL_YCBCR_2PLANE
;
831 dev_err(ippdrv
->dev
, "inavlid target yuv order 0x%x.\n", fmt
);
835 fimc_write(cfg
, EXYNOS_CIOCTRL
);
840 static int fimc_dst_set_fmt(struct device
*dev
, u32 fmt
)
842 struct fimc_context
*ctx
= get_fimc_context(dev
);
843 struct exynos_drm_ippdrv
*ippdrv
= &ctx
->ippdrv
;
846 DRM_DEBUG_KMS("%s:fmt[0x%x]\n", __func__
, fmt
);
848 cfg
= fimc_read(EXYNOS_CIEXTEN
);
850 if (fmt
== DRM_FORMAT_AYUV
) {
851 cfg
|= EXYNOS_CIEXTEN_YUV444_OUT
;
852 fimc_write(cfg
, EXYNOS_CIEXTEN
);
854 cfg
&= ~EXYNOS_CIEXTEN_YUV444_OUT
;
855 fimc_write(cfg
, EXYNOS_CIEXTEN
);
857 cfg
= fimc_read(EXYNOS_CITRGFMT
);
858 cfg
&= ~EXYNOS_CITRGFMT_OUTFORMAT_MASK
;
861 case DRM_FORMAT_RGB565
:
862 case DRM_FORMAT_RGB888
:
863 case DRM_FORMAT_XRGB8888
:
864 cfg
|= EXYNOS_CITRGFMT_OUTFORMAT_RGB
;
866 case DRM_FORMAT_YUYV
:
867 case DRM_FORMAT_YVYU
:
868 case DRM_FORMAT_UYVY
:
869 case DRM_FORMAT_VYUY
:
870 cfg
|= EXYNOS_CITRGFMT_OUTFORMAT_YCBCR422_1PLANE
;
872 case DRM_FORMAT_NV16
:
873 case DRM_FORMAT_NV61
:
874 case DRM_FORMAT_YUV422
:
875 cfg
|= EXYNOS_CITRGFMT_OUTFORMAT_YCBCR422
;
877 case DRM_FORMAT_YUV420
:
878 case DRM_FORMAT_YVU420
:
879 case DRM_FORMAT_NV12
:
880 case DRM_FORMAT_NV12MT
:
881 case DRM_FORMAT_NV21
:
882 cfg
|= EXYNOS_CITRGFMT_OUTFORMAT_YCBCR420
;
885 dev_err(ippdrv
->dev
, "inavlid target format 0x%x.\n",
890 fimc_write(cfg
, EXYNOS_CITRGFMT
);
893 cfg
= fimc_read(EXYNOS_CIDMAPARAM
);
894 cfg
&= ~EXYNOS_CIDMAPARAM_W_MODE_MASK
;
896 if (fmt
== DRM_FORMAT_NV12MT
)
897 cfg
|= EXYNOS_CIDMAPARAM_W_MODE_64X32
;
899 cfg
|= EXYNOS_CIDMAPARAM_W_MODE_LINEAR
;
901 fimc_write(cfg
, EXYNOS_CIDMAPARAM
);
903 return fimc_dst_set_fmt_order(ctx
, fmt
);
906 static int fimc_dst_set_transf(struct device
*dev
,
907 enum drm_exynos_degree degree
,
908 enum drm_exynos_flip flip
, bool *swap
)
910 struct fimc_context
*ctx
= get_fimc_context(dev
);
911 struct exynos_drm_ippdrv
*ippdrv
= &ctx
->ippdrv
;
914 DRM_DEBUG_KMS("%s:degree[%d]flip[0x%x]\n", __func__
,
917 cfg
= fimc_read(EXYNOS_CITRGFMT
);
918 cfg
&= ~EXYNOS_CITRGFMT_FLIP_MASK
;
919 cfg
&= ~EXYNOS_CITRGFMT_OUTROT90_CLOCKWISE
;
922 case EXYNOS_DRM_DEGREE_0
:
923 if (flip
& EXYNOS_DRM_FLIP_VERTICAL
)
924 cfg
|= EXYNOS_CITRGFMT_FLIP_X_MIRROR
;
925 if (flip
& EXYNOS_DRM_FLIP_HORIZONTAL
)
926 cfg
|= EXYNOS_CITRGFMT_FLIP_Y_MIRROR
;
928 case EXYNOS_DRM_DEGREE_90
:
929 cfg
|= EXYNOS_CITRGFMT_OUTROT90_CLOCKWISE
;
930 if (flip
& EXYNOS_DRM_FLIP_VERTICAL
)
931 cfg
|= EXYNOS_CITRGFMT_FLIP_X_MIRROR
;
932 if (flip
& EXYNOS_DRM_FLIP_HORIZONTAL
)
933 cfg
|= EXYNOS_CITRGFMT_FLIP_Y_MIRROR
;
935 case EXYNOS_DRM_DEGREE_180
:
936 cfg
|= (EXYNOS_CITRGFMT_FLIP_X_MIRROR
|
937 EXYNOS_CITRGFMT_FLIP_Y_MIRROR
);
938 if (flip
& EXYNOS_DRM_FLIP_VERTICAL
)
939 cfg
&= ~EXYNOS_CITRGFMT_FLIP_X_MIRROR
;
940 if (flip
& EXYNOS_DRM_FLIP_HORIZONTAL
)
941 cfg
&= ~EXYNOS_CITRGFMT_FLIP_Y_MIRROR
;
943 case EXYNOS_DRM_DEGREE_270
:
944 cfg
|= (EXYNOS_CITRGFMT_OUTROT90_CLOCKWISE
|
945 EXYNOS_CITRGFMT_FLIP_X_MIRROR
|
946 EXYNOS_CITRGFMT_FLIP_Y_MIRROR
);
947 if (flip
& EXYNOS_DRM_FLIP_VERTICAL
)
948 cfg
&= ~EXYNOS_CITRGFMT_FLIP_X_MIRROR
;
949 if (flip
& EXYNOS_DRM_FLIP_HORIZONTAL
)
950 cfg
&= ~EXYNOS_CITRGFMT_FLIP_Y_MIRROR
;
953 dev_err(ippdrv
->dev
, "inavlid degree value %d.\n", degree
);
957 fimc_write(cfg
, EXYNOS_CITRGFMT
);
958 *swap
= (cfg
& EXYNOS_CITRGFMT_OUTROT90_CLOCKWISE
) ? 1 : 0;
963 static int fimc_get_ratio_shift(u32 src
, u32 dst
, u32
*ratio
, u32
*shift
)
965 DRM_DEBUG_KMS("%s:src[%d]dst[%d]\n", __func__
, src
, dst
);
967 if (src
>= dst
* 64) {
968 DRM_ERROR("failed to make ratio and shift.\n");
970 } else if (src
>= dst
* 32) {
973 } else if (src
>= dst
* 16) {
976 } else if (src
>= dst
* 8) {
979 } else if (src
>= dst
* 4) {
982 } else if (src
>= dst
* 2) {
993 static int fimc_set_prescaler(struct fimc_context
*ctx
, struct fimc_scaler
*sc
,
994 struct drm_exynos_pos
*src
, struct drm_exynos_pos
*dst
)
996 struct exynos_drm_ippdrv
*ippdrv
= &ctx
->ippdrv
;
997 u32 cfg
, cfg_ext
, shfactor
;
998 u32 pre_dst_width
, pre_dst_height
;
999 u32 pre_hratio
, hfactor
, pre_vratio
, vfactor
;
1001 u32 src_w
, src_h
, dst_w
, dst_h
;
1003 cfg_ext
= fimc_read(EXYNOS_CITRGFMT
);
1004 if (cfg_ext
& EXYNOS_CITRGFMT_INROT90_CLOCKWISE
) {
1012 if (cfg_ext
& EXYNOS_CITRGFMT_OUTROT90_CLOCKWISE
) {
1020 ret
= fimc_get_ratio_shift(src_w
, dst_w
, &pre_hratio
, &hfactor
);
1022 dev_err(ippdrv
->dev
, "failed to get ratio horizontal.\n");
1026 ret
= fimc_get_ratio_shift(src_h
, dst_h
, &pre_vratio
, &vfactor
);
1028 dev_err(ippdrv
->dev
, "failed to get ratio vertical.\n");
1032 pre_dst_width
= src_w
/ pre_hratio
;
1033 pre_dst_height
= src_h
/ pre_vratio
;
1034 DRM_DEBUG_KMS("%s:pre_dst_width[%d]pre_dst_height[%d]\n", __func__
,
1035 pre_dst_width
, pre_dst_height
);
1036 DRM_DEBUG_KMS("%s:pre_hratio[%d]hfactor[%d]pre_vratio[%d]vfactor[%d]\n",
1037 __func__
, pre_hratio
, hfactor
, pre_vratio
, vfactor
);
1039 sc
->hratio
= (src_w
<< 14) / (dst_w
<< hfactor
);
1040 sc
->vratio
= (src_h
<< 14) / (dst_h
<< vfactor
);
1041 sc
->up_h
= (dst_w
>= src_w
) ? true : false;
1042 sc
->up_v
= (dst_h
>= src_h
) ? true : false;
1043 DRM_DEBUG_KMS("%s:hratio[%d]vratio[%d]up_h[%d]up_v[%d]\n",
1044 __func__
, sc
->hratio
, sc
->vratio
, sc
->up_h
, sc
->up_v
);
1046 shfactor
= FIMC_SHFACTOR
- (hfactor
+ vfactor
);
1047 DRM_DEBUG_KMS("%s:shfactor[%d]\n", __func__
, shfactor
);
1049 cfg
= (EXYNOS_CISCPRERATIO_SHFACTOR(shfactor
) |
1050 EXYNOS_CISCPRERATIO_PREHORRATIO(pre_hratio
) |
1051 EXYNOS_CISCPRERATIO_PREVERRATIO(pre_vratio
));
1052 fimc_write(cfg
, EXYNOS_CISCPRERATIO
);
1054 cfg
= (EXYNOS_CISCPREDST_PREDSTWIDTH(pre_dst_width
) |
1055 EXYNOS_CISCPREDST_PREDSTHEIGHT(pre_dst_height
));
1056 fimc_write(cfg
, EXYNOS_CISCPREDST
);
1061 static void fimc_set_scaler(struct fimc_context
*ctx
, struct fimc_scaler
*sc
)
1065 DRM_DEBUG_KMS("%s:range[%d]bypass[%d]up_h[%d]up_v[%d]\n",
1066 __func__
, sc
->range
, sc
->bypass
, sc
->up_h
, sc
->up_v
);
1067 DRM_DEBUG_KMS("%s:hratio[%d]vratio[%d]\n",
1068 __func__
, sc
->hratio
, sc
->vratio
);
1070 cfg
= fimc_read(EXYNOS_CISCCTRL
);
1071 cfg
&= ~(EXYNOS_CISCCTRL_SCALERBYPASS
|
1072 EXYNOS_CISCCTRL_SCALEUP_H
| EXYNOS_CISCCTRL_SCALEUP_V
|
1073 EXYNOS_CISCCTRL_MAIN_V_RATIO_MASK
|
1074 EXYNOS_CISCCTRL_MAIN_H_RATIO_MASK
|
1075 EXYNOS_CISCCTRL_CSCR2Y_WIDE
|
1076 EXYNOS_CISCCTRL_CSCY2R_WIDE
);
1079 cfg
|= (EXYNOS_CISCCTRL_CSCR2Y_WIDE
|
1080 EXYNOS_CISCCTRL_CSCY2R_WIDE
);
1082 cfg
|= EXYNOS_CISCCTRL_SCALERBYPASS
;
1084 cfg
|= EXYNOS_CISCCTRL_SCALEUP_H
;
1086 cfg
|= EXYNOS_CISCCTRL_SCALEUP_V
;
1088 cfg
|= (EXYNOS_CISCCTRL_MAINHORRATIO((sc
->hratio
>> 6)) |
1089 EXYNOS_CISCCTRL_MAINVERRATIO((sc
->vratio
>> 6)));
1090 fimc_write(cfg
, EXYNOS_CISCCTRL
);
1092 cfg_ext
= fimc_read(EXYNOS_CIEXTEN
);
1093 cfg_ext
&= ~EXYNOS_CIEXTEN_MAINHORRATIO_EXT_MASK
;
1094 cfg_ext
&= ~EXYNOS_CIEXTEN_MAINVERRATIO_EXT_MASK
;
1095 cfg_ext
|= (EXYNOS_CIEXTEN_MAINHORRATIO_EXT(sc
->hratio
) |
1096 EXYNOS_CIEXTEN_MAINVERRATIO_EXT(sc
->vratio
));
1097 fimc_write(cfg_ext
, EXYNOS_CIEXTEN
);
1100 static int fimc_dst_set_size(struct device
*dev
, int swap
,
1101 struct drm_exynos_pos
*pos
, struct drm_exynos_sz
*sz
)
1103 struct fimc_context
*ctx
= get_fimc_context(dev
);
1104 struct drm_exynos_pos img_pos
= *pos
;
1105 struct drm_exynos_sz img_sz
= *sz
;
1108 DRM_DEBUG_KMS("%s:swap[%d]hsize[%d]vsize[%d]\n",
1109 __func__
, swap
, sz
->hsize
, sz
->vsize
);
1112 cfg
= (EXYNOS_ORGOSIZE_HORIZONTAL(img_sz
.hsize
) |
1113 EXYNOS_ORGOSIZE_VERTICAL(img_sz
.vsize
));
1115 fimc_write(cfg
, EXYNOS_ORGOSIZE
);
1117 DRM_DEBUG_KMS("%s:x[%d]y[%d]w[%d]h[%d]\n",
1118 __func__
, pos
->x
, pos
->y
, pos
->w
, pos
->h
);
1121 cfg
= fimc_read(EXYNOS_CIGCTRL
);
1122 cfg
&= ~EXYNOS_CIGCTRL_CSC_MASK
;
1124 if (sz
->hsize
>= FIMC_WIDTH_ITU_709
)
1125 cfg
|= EXYNOS_CIGCTRL_CSC_ITU709
;
1127 cfg
|= EXYNOS_CIGCTRL_CSC_ITU601
;
1129 fimc_write(cfg
, EXYNOS_CIGCTRL
);
1134 img_sz
.hsize
= sz
->vsize
;
1135 img_sz
.vsize
= sz
->hsize
;
1138 /* target image size */
1139 cfg
= fimc_read(EXYNOS_CITRGFMT
);
1140 cfg
&= ~(EXYNOS_CITRGFMT_TARGETH_MASK
|
1141 EXYNOS_CITRGFMT_TARGETV_MASK
);
1142 cfg
|= (EXYNOS_CITRGFMT_TARGETHSIZE(img_pos
.w
) |
1143 EXYNOS_CITRGFMT_TARGETVSIZE(img_pos
.h
));
1144 fimc_write(cfg
, EXYNOS_CITRGFMT
);
1147 cfg
= EXYNOS_CITAREA_TARGET_AREA(img_pos
.w
* img_pos
.h
);
1148 fimc_write(cfg
, EXYNOS_CITAREA
);
1150 /* offset Y(RGB), Cb, Cr */
1151 cfg
= (EXYNOS_CIOYOFF_HORIZONTAL(img_pos
.x
) |
1152 EXYNOS_CIOYOFF_VERTICAL(img_pos
.y
));
1153 fimc_write(cfg
, EXYNOS_CIOYOFF
);
1154 cfg
= (EXYNOS_CIOCBOFF_HORIZONTAL(img_pos
.x
) |
1155 EXYNOS_CIOCBOFF_VERTICAL(img_pos
.y
));
1156 fimc_write(cfg
, EXYNOS_CIOCBOFF
);
1157 cfg
= (EXYNOS_CIOCROFF_HORIZONTAL(img_pos
.x
) |
1158 EXYNOS_CIOCROFF_VERTICAL(img_pos
.y
));
1159 fimc_write(cfg
, EXYNOS_CIOCROFF
);
1164 static int fimc_dst_get_buf_seq(struct fimc_context
*ctx
)
1166 u32 cfg
, i
, buf_num
= 0;
1167 u32 mask
= 0x00000001;
1169 cfg
= fimc_read(EXYNOS_CIFCNTSEQ
);
1171 for (i
= 0; i
< FIMC_REG_SZ
; i
++)
1172 if (cfg
& (mask
<< i
))
1175 DRM_DEBUG_KMS("%s:buf_num[%d]\n", __func__
, buf_num
);
1180 static int fimc_dst_set_buf_seq(struct fimc_context
*ctx
, u32 buf_id
,
1181 enum drm_exynos_ipp_buf_type buf_type
)
1183 struct exynos_drm_ippdrv
*ippdrv
= &ctx
->ippdrv
;
1186 u32 mask
= 0x00000001 << buf_id
;
1189 DRM_DEBUG_KMS("%s:buf_id[%d]buf_type[%d]\n", __func__
,
1192 mutex_lock(&ctx
->lock
);
1194 /* mask register set */
1195 cfg
= fimc_read(EXYNOS_CIFCNTSEQ
);
1198 case IPP_BUF_ENQUEUE
:
1201 case IPP_BUF_DEQUEUE
:
1205 dev_err(ippdrv
->dev
, "invalid buf ctrl parameter.\n");
1212 cfg
|= (enable
<< buf_id
);
1213 fimc_write(cfg
, EXYNOS_CIFCNTSEQ
);
1215 /* interrupt enable */
1216 if (buf_type
== IPP_BUF_ENQUEUE
&&
1217 fimc_dst_get_buf_seq(ctx
) >= FIMC_BUF_START
)
1218 fimc_handle_irq(ctx
, true, false, true);
1220 /* interrupt disable */
1221 if (buf_type
== IPP_BUF_DEQUEUE
&&
1222 fimc_dst_get_buf_seq(ctx
) <= FIMC_BUF_STOP
)
1223 fimc_handle_irq(ctx
, false, false, true);
1226 mutex_unlock(&ctx
->lock
);
1230 static int fimc_dst_set_addr(struct device
*dev
,
1231 struct drm_exynos_ipp_buf_info
*buf_info
, u32 buf_id
,
1232 enum drm_exynos_ipp_buf_type buf_type
)
1234 struct fimc_context
*ctx
= get_fimc_context(dev
);
1235 struct exynos_drm_ippdrv
*ippdrv
= &ctx
->ippdrv
;
1236 struct drm_exynos_ipp_cmd_node
*c_node
= ippdrv
->c_node
;
1237 struct drm_exynos_ipp_property
*property
;
1238 struct drm_exynos_ipp_config
*config
;
1241 DRM_ERROR("failed to get c_node.\n");
1245 property
= &c_node
->property
;
1247 DRM_DEBUG_KMS("%s:prop_id[%d]buf_id[%d]buf_type[%d]\n", __func__
,
1248 property
->prop_id
, buf_id
, buf_type
);
1250 if (buf_id
> FIMC_MAX_DST
) {
1251 dev_info(ippdrv
->dev
, "inavlid buf_id %d.\n", buf_id
);
1255 /* address register set */
1257 case IPP_BUF_ENQUEUE
:
1258 config
= &property
->config
[EXYNOS_DRM_OPS_DST
];
1260 fimc_write(buf_info
->base
[EXYNOS_DRM_PLANAR_Y
],
1261 EXYNOS_CIOYSA(buf_id
));
1263 if (config
->fmt
== DRM_FORMAT_YVU420
) {
1264 fimc_write(buf_info
->base
[EXYNOS_DRM_PLANAR_CR
],
1265 EXYNOS_CIOCBSA(buf_id
));
1266 fimc_write(buf_info
->base
[EXYNOS_DRM_PLANAR_CB
],
1267 EXYNOS_CIOCRSA(buf_id
));
1269 fimc_write(buf_info
->base
[EXYNOS_DRM_PLANAR_CB
],
1270 EXYNOS_CIOCBSA(buf_id
));
1271 fimc_write(buf_info
->base
[EXYNOS_DRM_PLANAR_CR
],
1272 EXYNOS_CIOCRSA(buf_id
));
1275 case IPP_BUF_DEQUEUE
:
1276 fimc_write(0x0, EXYNOS_CIOYSA(buf_id
));
1277 fimc_write(0x0, EXYNOS_CIOCBSA(buf_id
));
1278 fimc_write(0x0, EXYNOS_CIOCRSA(buf_id
));
1285 return fimc_dst_set_buf_seq(ctx
, buf_id
, buf_type
);
1288 static struct exynos_drm_ipp_ops fimc_dst_ops
= {
1289 .set_fmt
= fimc_dst_set_fmt
,
1290 .set_transf
= fimc_dst_set_transf
,
1291 .set_size
= fimc_dst_set_size
,
1292 .set_addr
= fimc_dst_set_addr
,
1295 static int fimc_clk_ctrl(struct fimc_context
*ctx
, bool enable
)
1297 DRM_DEBUG_KMS("%s:enable[%d]\n", __func__
, enable
);
1300 clk_prepare_enable(ctx
->clocks
[FIMC_CLK_GATE
]);
1301 clk_prepare_enable(ctx
->clocks
[FIMC_CLK_WB_A
]);
1302 ctx
->suspended
= false;
1304 clk_disable_unprepare(ctx
->clocks
[FIMC_CLK_GATE
]);
1305 clk_disable_unprepare(ctx
->clocks
[FIMC_CLK_WB_A
]);
1306 ctx
->suspended
= true;
1312 static irqreturn_t
fimc_irq_handler(int irq
, void *dev_id
)
1314 struct fimc_context
*ctx
= dev_id
;
1315 struct exynos_drm_ippdrv
*ippdrv
= &ctx
->ippdrv
;
1316 struct drm_exynos_ipp_cmd_node
*c_node
= ippdrv
->c_node
;
1317 struct drm_exynos_ipp_event_work
*event_work
=
1321 DRM_DEBUG_KMS("%s:fimc id[%d]\n", __func__
, ctx
->id
);
1323 fimc_clear_irq(ctx
);
1324 if (fimc_check_ovf(ctx
))
1327 if (!fimc_check_frame_end(ctx
))
1330 buf_id
= fimc_get_buf_id(ctx
);
1334 DRM_DEBUG_KMS("%s:buf_id[%d]\n", __func__
, buf_id
);
1336 if (fimc_dst_set_buf_seq(ctx
, buf_id
, IPP_BUF_DEQUEUE
) < 0) {
1337 DRM_ERROR("failed to dequeue.\n");
1341 event_work
->ippdrv
= ippdrv
;
1342 event_work
->buf_id
[EXYNOS_DRM_OPS_DST
] = buf_id
;
1343 queue_work(ippdrv
->event_workq
, (struct work_struct
*)event_work
);
1348 static int fimc_init_prop_list(struct exynos_drm_ippdrv
*ippdrv
)
1350 struct drm_exynos_ipp_prop_list
*prop_list
;
1352 prop_list
= devm_kzalloc(ippdrv
->dev
, sizeof(*prop_list
), GFP_KERNEL
);
1354 DRM_ERROR("failed to alloc property list.\n");
1358 prop_list
->version
= 1;
1359 prop_list
->writeback
= 1;
1360 prop_list
->refresh_min
= FIMC_REFRESH_MIN
;
1361 prop_list
->refresh_max
= FIMC_REFRESH_MAX
;
1362 prop_list
->flip
= (1 << EXYNOS_DRM_FLIP_NONE
) |
1363 (1 << EXYNOS_DRM_FLIP_VERTICAL
) |
1364 (1 << EXYNOS_DRM_FLIP_HORIZONTAL
);
1365 prop_list
->degree
= (1 << EXYNOS_DRM_DEGREE_0
) |
1366 (1 << EXYNOS_DRM_DEGREE_90
) |
1367 (1 << EXYNOS_DRM_DEGREE_180
) |
1368 (1 << EXYNOS_DRM_DEGREE_270
);
1370 prop_list
->crop
= 1;
1371 prop_list
->crop_max
.hsize
= FIMC_CROP_MAX
;
1372 prop_list
->crop_max
.vsize
= FIMC_CROP_MAX
;
1373 prop_list
->crop_min
.hsize
= FIMC_CROP_MIN
;
1374 prop_list
->crop_min
.vsize
= FIMC_CROP_MIN
;
1375 prop_list
->scale
= 1;
1376 prop_list
->scale_max
.hsize
= FIMC_SCALE_MAX
;
1377 prop_list
->scale_max
.vsize
= FIMC_SCALE_MAX
;
1378 prop_list
->scale_min
.hsize
= FIMC_SCALE_MIN
;
1379 prop_list
->scale_min
.vsize
= FIMC_SCALE_MIN
;
1381 ippdrv
->prop_list
= prop_list
;
1386 static inline bool fimc_check_drm_flip(enum drm_exynos_flip flip
)
1389 case EXYNOS_DRM_FLIP_NONE
:
1390 case EXYNOS_DRM_FLIP_VERTICAL
:
1391 case EXYNOS_DRM_FLIP_HORIZONTAL
:
1392 case EXYNOS_DRM_FLIP_BOTH
:
1395 DRM_DEBUG_KMS("%s:invalid flip\n", __func__
);
1400 static int fimc_ippdrv_check_property(struct device
*dev
,
1401 struct drm_exynos_ipp_property
*property
)
1403 struct fimc_context
*ctx
= get_fimc_context(dev
);
1404 struct exynos_drm_ippdrv
*ippdrv
= &ctx
->ippdrv
;
1405 struct drm_exynos_ipp_prop_list
*pp
= ippdrv
->prop_list
;
1406 struct drm_exynos_ipp_config
*config
;
1407 struct drm_exynos_pos
*pos
;
1408 struct drm_exynos_sz
*sz
;
1412 for_each_ipp_ops(i
) {
1413 if ((i
== EXYNOS_DRM_OPS_SRC
) &&
1414 (property
->cmd
== IPP_CMD_WB
))
1417 config
= &property
->config
[i
];
1421 /* check for flip */
1422 if (!fimc_check_drm_flip(config
->flip
)) {
1423 DRM_ERROR("invalid flip.\n");
1427 /* check for degree */
1428 switch (config
->degree
) {
1429 case EXYNOS_DRM_DEGREE_90
:
1430 case EXYNOS_DRM_DEGREE_270
:
1433 case EXYNOS_DRM_DEGREE_0
:
1434 case EXYNOS_DRM_DEGREE_180
:
1438 DRM_ERROR("invalid degree.\n");
1442 /* check for buffer bound */
1443 if ((pos
->x
+ pos
->w
> sz
->hsize
) ||
1444 (pos
->y
+ pos
->h
> sz
->vsize
)) {
1445 DRM_ERROR("out of buf bound.\n");
1449 /* check for crop */
1450 if ((i
== EXYNOS_DRM_OPS_SRC
) && (pp
->crop
)) {
1452 if ((pos
->h
< pp
->crop_min
.hsize
) ||
1453 (sz
->vsize
> pp
->crop_max
.hsize
) ||
1454 (pos
->w
< pp
->crop_min
.vsize
) ||
1455 (sz
->hsize
> pp
->crop_max
.vsize
)) {
1456 DRM_ERROR("out of crop size.\n");
1460 if ((pos
->w
< pp
->crop_min
.hsize
) ||
1461 (sz
->hsize
> pp
->crop_max
.hsize
) ||
1462 (pos
->h
< pp
->crop_min
.vsize
) ||
1463 (sz
->vsize
> pp
->crop_max
.vsize
)) {
1464 DRM_ERROR("out of crop size.\n");
1470 /* check for scale */
1471 if ((i
== EXYNOS_DRM_OPS_DST
) && (pp
->scale
)) {
1473 if ((pos
->h
< pp
->scale_min
.hsize
) ||
1474 (sz
->vsize
> pp
->scale_max
.hsize
) ||
1475 (pos
->w
< pp
->scale_min
.vsize
) ||
1476 (sz
->hsize
> pp
->scale_max
.vsize
)) {
1477 DRM_ERROR("out of scale size.\n");
1481 if ((pos
->w
< pp
->scale_min
.hsize
) ||
1482 (sz
->hsize
> pp
->scale_max
.hsize
) ||
1483 (pos
->h
< pp
->scale_min
.vsize
) ||
1484 (sz
->vsize
> pp
->scale_max
.vsize
)) {
1485 DRM_ERROR("out of scale size.\n");
1495 for_each_ipp_ops(i
) {
1496 if ((i
== EXYNOS_DRM_OPS_SRC
) &&
1497 (property
->cmd
== IPP_CMD_WB
))
1500 config
= &property
->config
[i
];
1504 DRM_ERROR("[%s]f[%d]r[%d]pos[%d %d %d %d]sz[%d %d]\n",
1505 i
? "dst" : "src", config
->flip
, config
->degree
,
1506 pos
->x
, pos
->y
, pos
->w
, pos
->h
,
1507 sz
->hsize
, sz
->vsize
);
1513 static void fimc_clear_addr(struct fimc_context
*ctx
)
1517 for (i
= 0; i
< FIMC_MAX_SRC
; i
++) {
1518 fimc_write(0, EXYNOS_CIIYSA(i
));
1519 fimc_write(0, EXYNOS_CIICBSA(i
));
1520 fimc_write(0, EXYNOS_CIICRSA(i
));
1523 for (i
= 0; i
< FIMC_MAX_DST
; i
++) {
1524 fimc_write(0, EXYNOS_CIOYSA(i
));
1525 fimc_write(0, EXYNOS_CIOCBSA(i
));
1526 fimc_write(0, EXYNOS_CIOCRSA(i
));
1530 static int fimc_ippdrv_reset(struct device
*dev
)
1532 struct fimc_context
*ctx
= get_fimc_context(dev
);
1534 /* reset h/w block */
1537 /* reset scaler capability */
1538 memset(&ctx
->sc
, 0x0, sizeof(ctx
->sc
));
1540 fimc_clear_addr(ctx
);
1545 static int fimc_ippdrv_start(struct device
*dev
, enum drm_exynos_ipp_cmd cmd
)
1547 struct fimc_context
*ctx
= get_fimc_context(dev
);
1548 struct exynos_drm_ippdrv
*ippdrv
= &ctx
->ippdrv
;
1549 struct drm_exynos_ipp_cmd_node
*c_node
= ippdrv
->c_node
;
1550 struct drm_exynos_ipp_property
*property
;
1551 struct drm_exynos_ipp_config
*config
;
1552 struct drm_exynos_pos img_pos
[EXYNOS_DRM_OPS_MAX
];
1553 struct drm_exynos_ipp_set_wb set_wb
;
1557 DRM_DEBUG_KMS("%s:cmd[%d]\n", __func__
, cmd
);
1560 DRM_ERROR("failed to get c_node.\n");
1564 property
= &c_node
->property
;
1566 fimc_handle_irq(ctx
, true, false, true);
1568 for_each_ipp_ops(i
) {
1569 config
= &property
->config
[i
];
1570 img_pos
[i
] = config
->pos
;
1573 ret
= fimc_set_prescaler(ctx
, &ctx
->sc
,
1574 &img_pos
[EXYNOS_DRM_OPS_SRC
],
1575 &img_pos
[EXYNOS_DRM_OPS_DST
]);
1577 dev_err(dev
, "failed to set precalser.\n");
1581 /* If set ture, we can save jpeg about screen */
1582 fimc_handle_jpeg(ctx
, false);
1583 fimc_set_scaler(ctx
, &ctx
->sc
);
1584 fimc_set_polarity(ctx
, &ctx
->pol
);
1588 fimc_set_type_ctrl(ctx
, FIMC_WB_NONE
);
1589 fimc_handle_lastend(ctx
, false);
1592 cfg0
= fimc_read(EXYNOS_MSCTRL
);
1593 cfg0
&= ~EXYNOS_MSCTRL_INPUT_MASK
;
1594 cfg0
|= EXYNOS_MSCTRL_INPUT_MEMORY
;
1595 fimc_write(cfg0
, EXYNOS_MSCTRL
);
1598 fimc_set_type_ctrl(ctx
, FIMC_WB_A
);
1599 fimc_handle_lastend(ctx
, true);
1602 ret
= fimc_set_camblk_fimd0_wb(ctx
);
1604 dev_err(dev
, "camblk setup failed.\n");
1609 set_wb
.refresh
= property
->refresh_rate
;
1610 exynos_drm_ippnb_send_event(IPP_SET_WRITEBACK
, (void *)&set_wb
);
1612 case IPP_CMD_OUTPUT
:
1615 dev_err(dev
, "invalid operations.\n");
1620 fimc_write(0x0, EXYNOS_CISTATUS
);
1622 cfg0
= fimc_read(EXYNOS_CIIMGCPT
);
1623 cfg0
&= ~EXYNOS_CIIMGCPT_IMGCPTEN_SC
;
1624 cfg0
|= EXYNOS_CIIMGCPT_IMGCPTEN_SC
;
1627 cfg1
= fimc_read(EXYNOS_CISCCTRL
);
1628 cfg1
&= ~EXYNOS_CISCCTRL_SCAN_MASK
;
1629 cfg1
|= (EXYNOS_CISCCTRL_PROGRESSIVE
|
1630 EXYNOS_CISCCTRL_SCALERSTART
);
1632 fimc_write(cfg1
, EXYNOS_CISCCTRL
);
1634 /* Enable image capture*/
1635 cfg0
|= EXYNOS_CIIMGCPT_IMGCPTEN
;
1636 fimc_write(cfg0
, EXYNOS_CIIMGCPT
);
1638 /* Disable frame end irq */
1639 cfg0
= fimc_read(EXYNOS_CIGCTRL
);
1640 cfg0
&= ~EXYNOS_CIGCTRL_IRQ_END_DISABLE
;
1641 fimc_write(cfg0
, EXYNOS_CIGCTRL
);
1643 cfg0
= fimc_read(EXYNOS_CIOCTRL
);
1644 cfg0
&= ~EXYNOS_CIOCTRL_WEAVE_MASK
;
1645 fimc_write(cfg0
, EXYNOS_CIOCTRL
);
1647 if (cmd
== IPP_CMD_M2M
) {
1648 cfg0
= fimc_read(EXYNOS_MSCTRL
);
1649 cfg0
|= EXYNOS_MSCTRL_ENVID
;
1650 fimc_write(cfg0
, EXYNOS_MSCTRL
);
1652 cfg0
= fimc_read(EXYNOS_MSCTRL
);
1653 cfg0
|= EXYNOS_MSCTRL_ENVID
;
1654 fimc_write(cfg0
, EXYNOS_MSCTRL
);
1660 static void fimc_ippdrv_stop(struct device
*dev
, enum drm_exynos_ipp_cmd cmd
)
1662 struct fimc_context
*ctx
= get_fimc_context(dev
);
1663 struct drm_exynos_ipp_set_wb set_wb
= {0, 0};
1666 DRM_DEBUG_KMS("%s:cmd[%d]\n", __func__
, cmd
);
1671 cfg
= fimc_read(EXYNOS_MSCTRL
);
1672 cfg
&= ~EXYNOS_MSCTRL_INPUT_MASK
;
1673 cfg
&= ~EXYNOS_MSCTRL_ENVID
;
1674 fimc_write(cfg
, EXYNOS_MSCTRL
);
1677 exynos_drm_ippnb_send_event(IPP_SET_WRITEBACK
, (void *)&set_wb
);
1679 case IPP_CMD_OUTPUT
:
1681 dev_err(dev
, "invalid operations.\n");
1685 fimc_handle_irq(ctx
, false, false, true);
1687 /* reset sequence */
1688 fimc_write(0x0, EXYNOS_CIFCNTSEQ
);
1690 /* Scaler disable */
1691 cfg
= fimc_read(EXYNOS_CISCCTRL
);
1692 cfg
&= ~EXYNOS_CISCCTRL_SCALERSTART
;
1693 fimc_write(cfg
, EXYNOS_CISCCTRL
);
1695 /* Disable image capture */
1696 cfg
= fimc_read(EXYNOS_CIIMGCPT
);
1697 cfg
&= ~(EXYNOS_CIIMGCPT_IMGCPTEN_SC
| EXYNOS_CIIMGCPT_IMGCPTEN
);
1698 fimc_write(cfg
, EXYNOS_CIIMGCPT
);
1700 /* Enable frame end irq */
1701 cfg
= fimc_read(EXYNOS_CIGCTRL
);
1702 cfg
|= EXYNOS_CIGCTRL_IRQ_END_DISABLE
;
1703 fimc_write(cfg
, EXYNOS_CIGCTRL
);
1706 static void fimc_put_clocks(struct fimc_context
*ctx
)
1710 for (i
= 0; i
< FIMC_CLKS_MAX
; i
++) {
1711 if (IS_ERR(ctx
->clocks
[i
]))
1713 clk_put(ctx
->clocks
[i
]);
1714 ctx
->clocks
[i
] = ERR_PTR(-EINVAL
);
1718 static int fimc_setup_clocks(struct fimc_context
*ctx
)
1720 struct device
*fimc_dev
= ctx
->ippdrv
.dev
;
1724 for (i
= 0; i
< FIMC_CLKS_MAX
; i
++)
1725 ctx
->clocks
[i
] = ERR_PTR(-EINVAL
);
1727 for (i
= 0; i
< FIMC_CLKS_MAX
; i
++) {
1728 if (i
== FIMC_CLK_WB_A
|| i
== FIMC_CLK_WB_B
)
1729 dev
= fimc_dev
->parent
;
1733 ctx
->clocks
[i
] = clk_get(dev
, fimc_clock_names
[i
]);
1734 if (IS_ERR(ctx
->clocks
[i
])) {
1735 if (i
>= FIMC_CLK_MUX
)
1737 ret
= PTR_ERR(ctx
->clocks
[i
]);
1738 dev_err(fimc_dev
, "failed to get clock: %s\n",
1739 fimc_clock_names
[i
]);
1744 /* Optional FIMC LCLK parent clock setting */
1745 if (!IS_ERR(ctx
->clocks
[FIMC_CLK_PARENT
])) {
1746 ret
= clk_set_parent(ctx
->clocks
[FIMC_CLK_MUX
],
1747 ctx
->clocks
[FIMC_CLK_PARENT
]);
1749 dev_err(fimc_dev
, "failed to set parent.\n");
1754 ret
= clk_set_rate(ctx
->clocks
[FIMC_CLK_LCLK
], ctx
->clk_frequency
);
1758 ret
= clk_prepare_enable(ctx
->clocks
[FIMC_CLK_LCLK
]);
1762 fimc_put_clocks(ctx
);
1766 static int fimc_parse_dt(struct fimc_context
*ctx
)
1768 struct device_node
*node
= ctx
->ippdrv
.dev
->of_node
;
1770 /* Handle only devices that support the LCD Writeback data path */
1771 if (!of_property_read_bool(node
, "samsung,lcd-wb"))
1774 if (of_property_read_u32(node
, "clock-frequency",
1775 &ctx
->clk_frequency
))
1776 ctx
->clk_frequency
= FIMC_DEFAULT_LCLK_FREQUENCY
;
1778 ctx
->id
= of_alias_get_id(node
, "fimc");
1781 dev_err(ctx
->ippdrv
.dev
, "failed to get node alias id.\n");
1788 static int fimc_probe(struct platform_device
*pdev
)
1790 struct device
*dev
= &pdev
->dev
;
1791 struct fimc_context
*ctx
;
1792 struct resource
*res
;
1793 struct exynos_drm_ippdrv
*ippdrv
;
1796 if (!dev
->of_node
) {
1797 dev_err(dev
, "device tree node not found.\n");
1801 ctx
= devm_kzalloc(dev
, sizeof(*ctx
), GFP_KERNEL
);
1805 ctx
->ippdrv
.dev
= dev
;
1807 ret
= fimc_parse_dt(ctx
);
1811 ctx
->sysreg
= syscon_regmap_lookup_by_phandle(dev
->of_node
,
1813 if (IS_ERR(ctx
->sysreg
)) {
1814 dev_err(dev
, "syscon regmap lookup failed.\n");
1815 return PTR_ERR(ctx
->sysreg
);
1818 /* resource memory */
1819 ctx
->regs_res
= platform_get_resource(pdev
, IORESOURCE_MEM
, 0);
1820 ctx
->regs
= devm_ioremap_resource(dev
, ctx
->regs_res
);
1821 if (IS_ERR(ctx
->regs
))
1822 return PTR_ERR(ctx
->regs
);
1825 res
= platform_get_resource(pdev
, IORESOURCE_IRQ
, 0);
1827 dev_err(dev
, "failed to request irq resource.\n");
1831 ctx
->irq
= res
->start
;
1832 ret
= devm_request_threaded_irq(dev
, ctx
->irq
, NULL
, fimc_irq_handler
,
1833 IRQF_ONESHOT
, "drm_fimc", ctx
);
1835 dev_err(dev
, "failed to request irq.\n");
1839 ret
= fimc_setup_clocks(ctx
);
1843 ippdrv
= &ctx
->ippdrv
;
1844 ippdrv
->ops
[EXYNOS_DRM_OPS_SRC
] = &fimc_src_ops
;
1845 ippdrv
->ops
[EXYNOS_DRM_OPS_DST
] = &fimc_dst_ops
;
1846 ippdrv
->check_property
= fimc_ippdrv_check_property
;
1847 ippdrv
->reset
= fimc_ippdrv_reset
;
1848 ippdrv
->start
= fimc_ippdrv_start
;
1849 ippdrv
->stop
= fimc_ippdrv_stop
;
1850 ret
= fimc_init_prop_list(ippdrv
);
1852 dev_err(dev
, "failed to init property list.\n");
1856 DRM_DEBUG_KMS("%s:id[%d]ippdrv[0x%x]\n", __func__
, ctx
->id
,
1859 mutex_init(&ctx
->lock
);
1860 platform_set_drvdata(pdev
, ctx
);
1862 pm_runtime_set_active(dev
);
1863 pm_runtime_enable(dev
);
1865 ret
= exynos_drm_ippdrv_register(ippdrv
);
1867 dev_err(dev
, "failed to register drm fimc device.\n");
1871 dev_info(dev
, "drm fimc registered successfully.\n");
1876 pm_runtime_disable(dev
);
1878 fimc_put_clocks(ctx
);
1883 static int fimc_remove(struct platform_device
*pdev
)
1885 struct device
*dev
= &pdev
->dev
;
1886 struct fimc_context
*ctx
= get_fimc_context(dev
);
1887 struct exynos_drm_ippdrv
*ippdrv
= &ctx
->ippdrv
;
1889 exynos_drm_ippdrv_unregister(ippdrv
);
1890 mutex_destroy(&ctx
->lock
);
1892 fimc_put_clocks(ctx
);
1893 pm_runtime_set_suspended(dev
);
1894 pm_runtime_disable(dev
);
1899 #ifdef CONFIG_PM_SLEEP
1900 static int fimc_suspend(struct device
*dev
)
1902 struct fimc_context
*ctx
= get_fimc_context(dev
);
1904 DRM_DEBUG_KMS("%s:id[%d]\n", __func__
, ctx
->id
);
1906 if (pm_runtime_suspended(dev
))
1909 return fimc_clk_ctrl(ctx
, false);
1912 static int fimc_resume(struct device
*dev
)
1914 struct fimc_context
*ctx
= get_fimc_context(dev
);
1916 DRM_DEBUG_KMS("%s:id[%d]\n", __func__
, ctx
->id
);
1918 if (!pm_runtime_suspended(dev
))
1919 return fimc_clk_ctrl(ctx
, true);
1925 #ifdef CONFIG_PM_RUNTIME
1926 static int fimc_runtime_suspend(struct device
*dev
)
1928 struct fimc_context
*ctx
= get_fimc_context(dev
);
1930 DRM_DEBUG_KMS("%s:id[%d]\n", __func__
, ctx
->id
);
1932 return fimc_clk_ctrl(ctx
, false);
1935 static int fimc_runtime_resume(struct device
*dev
)
1937 struct fimc_context
*ctx
= get_fimc_context(dev
);
1939 DRM_DEBUG_KMS("%s:id[%d]\n", __func__
, ctx
->id
);
1941 return fimc_clk_ctrl(ctx
, true);
1945 static const struct dev_pm_ops fimc_pm_ops
= {
1946 SET_SYSTEM_SLEEP_PM_OPS(fimc_suspend
, fimc_resume
)
1947 SET_RUNTIME_PM_OPS(fimc_runtime_suspend
, fimc_runtime_resume
, NULL
)
1950 static const struct of_device_id fimc_of_match
[] = {
1951 { .compatible
= "samsung,exynos4210-fimc" },
1952 { .compatible
= "samsung,exynos4212-fimc" },
1956 struct platform_driver fimc_driver
= {
1957 .probe
= fimc_probe
,
1958 .remove
= fimc_remove
,
1960 .of_match_table
= fimc_of_match
,
1961 .name
= "exynos-drm-fimc",
1962 .owner
= THIS_MODULE
,