1 /* drivers/gpu/drm/exynos5433_drm_decon.c
3 * Copyright (C) 2015 Samsung Electronics Co.Ltd
5 * Joonyoung Shim <jy0922.shim@samsung.com>
6 * Hyungwon Hwang <human.hwang@samsung.com>
8 * This program is free software; you can redistribute it and/or modify
9 * it under the terms of the GNU General Public License version 2 as
10 * published by the Free Software Foundationr
13 #include <linux/platform_device.h>
14 #include <linux/clk.h>
15 #include <linux/component.h>
16 #include <linux/of_gpio.h>
17 #include <linux/pm_runtime.h>
19 #include <video/exynos5433_decon.h>
21 #include "exynos_drm_drv.h"
22 #include "exynos_drm_crtc.h"
23 #include "exynos_drm_plane.h"
24 #include "exynos_drm_iommu.h"
28 #define MIN_FB_WIDTH_FOR_16WORD_BURST 128
30 static const char * const decon_clks_name
[] = {
40 struct decon_context
{
42 struct drm_device
*drm_dev
;
43 struct exynos_drm_crtc
*crtc
;
44 struct exynos_drm_plane planes
[WINDOWS_NR
];
46 struct clk
*clks
[ARRAY_SIZE(decon_clks_name
)];
47 unsigned long irq_flags
;
51 #define BIT_CLKS_ENABLED 0
52 #define BIT_IRQS_ENABLED 1
53 unsigned long enabled
;
58 static const uint32_t decon_formats
[] = {
65 static int decon_enable_vblank(struct exynos_drm_crtc
*crtc
)
67 struct decon_context
*ctx
= crtc
->ctx
;
73 if (test_and_set_bit(0, &ctx
->irq_flags
)) {
74 val
= VIDINTCON0_INTEN
;
76 val
|= VIDINTCON0_FRAMEDONE
;
78 val
|= VIDINTCON0_INTFRMEN
;
80 writel(val
, ctx
->addr
+ DECON_VIDINTCON0
);
86 static void decon_disable_vblank(struct exynos_drm_crtc
*crtc
)
88 struct decon_context
*ctx
= crtc
->ctx
;
93 if (test_and_clear_bit(0, &ctx
->irq_flags
))
94 writel(0, ctx
->addr
+ DECON_VIDINTCON0
);
97 static void decon_setup_trigger(struct decon_context
*ctx
)
99 u32 val
= TRIGCON_TRIGEN_PER_F
| TRIGCON_TRIGEN_F
|
100 TRIGCON_TE_AUTO_MASK
| TRIGCON_SWTRIGEN
;
101 writel(val
, ctx
->addr
+ DECON_TRIGCON
);
104 static void decon_commit(struct exynos_drm_crtc
*crtc
)
106 struct decon_context
*ctx
= crtc
->ctx
;
107 struct drm_display_mode
*mode
= &crtc
->base
.mode
;
113 /* enable clock gate */
114 val
= CMU_CLKGAGE_MODE_SFR_F
| CMU_CLKGAGE_MODE_MEM_F
;
115 writel(val
, ctx
->addr
+ DECON_CMU
);
117 /* lcd on and use command if */
120 val
|= VIDOUT_COMMAND_IF
;
122 val
|= VIDOUT_RGB_IF
;
123 writel(val
, ctx
->addr
+ DECON_VIDOUTCON0
);
125 val
= VIDTCON2_LINEVAL(mode
->vdisplay
- 1) |
126 VIDTCON2_HOZVAL(mode
->hdisplay
- 1);
127 writel(val
, ctx
->addr
+ DECON_VIDTCON2
);
130 val
= VIDTCON00_VBPD_F(
131 mode
->crtc_vtotal
- mode
->crtc_vsync_end
) |
133 mode
->crtc_vsync_start
- mode
->crtc_vdisplay
);
134 writel(val
, ctx
->addr
+ DECON_VIDTCON00
);
136 val
= VIDTCON01_VSPW_F(
137 mode
->crtc_vsync_end
- mode
->crtc_vsync_start
);
138 writel(val
, ctx
->addr
+ DECON_VIDTCON01
);
140 val
= VIDTCON10_HBPD_F(
141 mode
->crtc_htotal
- mode
->crtc_hsync_end
) |
143 mode
->crtc_hsync_start
- mode
->crtc_hdisplay
);
144 writel(val
, ctx
->addr
+ DECON_VIDTCON10
);
146 val
= VIDTCON11_HSPW_F(
147 mode
->crtc_hsync_end
- mode
->crtc_hsync_start
);
148 writel(val
, ctx
->addr
+ DECON_VIDTCON11
);
151 decon_setup_trigger(ctx
);
153 /* enable output and display signal */
154 val
= VIDCON0_ENVID
| VIDCON0_ENVID_F
;
155 writel(val
, ctx
->addr
+ DECON_VIDCON0
);
158 #define COORDINATE_X(x) (((x) & 0xfff) << 12)
159 #define COORDINATE_Y(x) ((x) & 0xfff)
160 #define OFFSIZE(x) (((x) & 0x3fff) << 14)
161 #define PAGEWIDTH(x) ((x) & 0x3fff)
163 static void decon_win_set_pixfmt(struct decon_context
*ctx
, unsigned int win
,
164 struct drm_framebuffer
*fb
)
168 val
= readl(ctx
->addr
+ DECON_WINCONx(win
));
169 val
&= ~WINCONx_BPPMODE_MASK
;
171 switch (fb
->pixel_format
) {
172 case DRM_FORMAT_XRGB1555
:
173 val
|= WINCONx_BPPMODE_16BPP_I1555
;
174 val
|= WINCONx_HAWSWP_F
;
175 val
|= WINCONx_BURSTLEN_16WORD
;
177 case DRM_FORMAT_RGB565
:
178 val
|= WINCONx_BPPMODE_16BPP_565
;
179 val
|= WINCONx_HAWSWP_F
;
180 val
|= WINCONx_BURSTLEN_16WORD
;
182 case DRM_FORMAT_XRGB8888
:
183 val
|= WINCONx_BPPMODE_24BPP_888
;
184 val
|= WINCONx_WSWP_F
;
185 val
|= WINCONx_BURSTLEN_16WORD
;
187 case DRM_FORMAT_ARGB8888
:
188 val
|= WINCONx_BPPMODE_32BPP_A8888
;
189 val
|= WINCONx_WSWP_F
| WINCONx_BLD_PIX_F
| WINCONx_ALPHA_SEL_F
;
190 val
|= WINCONx_BURSTLEN_16WORD
;
193 DRM_ERROR("Proper pixel format is not set\n");
197 DRM_DEBUG_KMS("bpp = %u\n", fb
->bits_per_pixel
);
200 * In case of exynos, setting dma-burst to 16Word causes permanent
201 * tearing for very small buffers, e.g. cursor buffer. Burst Mode
202 * switching which is based on plane size is not recommended as
203 * plane size varies a lot towards the end of the screen and rapid
204 * movement causes unstable DMA which results into iommu crash/tear.
207 if (fb
->width
< MIN_FB_WIDTH_FOR_16WORD_BURST
) {
208 val
&= ~WINCONx_BURSTLEN_MASK
;
209 val
|= WINCONx_BURSTLEN_8WORD
;
212 writel(val
, ctx
->addr
+ DECON_WINCONx(win
));
215 static void decon_shadow_protect_win(struct decon_context
*ctx
, int win
,
220 val
= readl(ctx
->addr
+ DECON_SHADOWCON
);
223 val
|= SHADOWCON_Wx_PROTECT(win
);
225 val
&= ~SHADOWCON_Wx_PROTECT(win
);
227 writel(val
, ctx
->addr
+ DECON_SHADOWCON
);
230 static void decon_atomic_begin(struct exynos_drm_crtc
*crtc
,
231 struct exynos_drm_plane
*plane
)
233 struct decon_context
*ctx
= crtc
->ctx
;
238 decon_shadow_protect_win(ctx
, plane
->zpos
, true);
241 static void decon_update_plane(struct exynos_drm_crtc
*crtc
,
242 struct exynos_drm_plane
*plane
)
244 struct decon_context
*ctx
= crtc
->ctx
;
245 struct drm_plane_state
*state
= plane
->base
.state
;
246 unsigned int win
= plane
->zpos
;
247 unsigned int bpp
= state
->fb
->bits_per_pixel
>> 3;
248 unsigned int pitch
= state
->fb
->pitches
[0];
254 val
= COORDINATE_X(plane
->crtc_x
) | COORDINATE_Y(plane
->crtc_y
);
255 writel(val
, ctx
->addr
+ DECON_VIDOSDxA(win
));
257 val
= COORDINATE_X(plane
->crtc_x
+ plane
->crtc_w
- 1) |
258 COORDINATE_Y(plane
->crtc_y
+ plane
->crtc_h
- 1);
259 writel(val
, ctx
->addr
+ DECON_VIDOSDxB(win
));
261 val
= VIDOSD_Wx_ALPHA_R_F(0x0) | VIDOSD_Wx_ALPHA_G_F(0x0) |
262 VIDOSD_Wx_ALPHA_B_F(0x0);
263 writel(val
, ctx
->addr
+ DECON_VIDOSDxC(win
));
265 val
= VIDOSD_Wx_ALPHA_R_F(0x0) | VIDOSD_Wx_ALPHA_G_F(0x0) |
266 VIDOSD_Wx_ALPHA_B_F(0x0);
267 writel(val
, ctx
->addr
+ DECON_VIDOSDxD(win
));
269 writel(plane
->dma_addr
[0], ctx
->addr
+ DECON_VIDW0xADD0B0(win
));
271 val
= plane
->dma_addr
[0] + pitch
* plane
->crtc_h
;
272 writel(val
, ctx
->addr
+ DECON_VIDW0xADD1B0(win
));
274 val
= OFFSIZE(pitch
- plane
->crtc_w
* bpp
)
275 | PAGEWIDTH(plane
->crtc_w
* bpp
);
276 writel(val
, ctx
->addr
+ DECON_VIDW0xADD2(win
));
278 decon_win_set_pixfmt(ctx
, win
, state
->fb
);
281 val
= readl(ctx
->addr
+ DECON_WINCONx(win
));
282 val
|= WINCONx_ENWIN_F
;
283 writel(val
, ctx
->addr
+ DECON_WINCONx(win
));
285 /* standalone update */
286 val
= readl(ctx
->addr
+ DECON_UPDATE
);
287 val
|= STANDALONE_UPDATE_F
;
288 writel(val
, ctx
->addr
+ DECON_UPDATE
);
291 static void decon_disable_plane(struct exynos_drm_crtc
*crtc
,
292 struct exynos_drm_plane
*plane
)
294 struct decon_context
*ctx
= crtc
->ctx
;
295 unsigned int win
= plane
->zpos
;
301 decon_shadow_protect_win(ctx
, win
, true);
304 val
= readl(ctx
->addr
+ DECON_WINCONx(win
));
305 val
&= ~WINCONx_ENWIN_F
;
306 writel(val
, ctx
->addr
+ DECON_WINCONx(win
));
308 decon_shadow_protect_win(ctx
, win
, false);
310 /* standalone update */
311 val
= readl(ctx
->addr
+ DECON_UPDATE
);
312 val
|= STANDALONE_UPDATE_F
;
313 writel(val
, ctx
->addr
+ DECON_UPDATE
);
316 static void decon_atomic_flush(struct exynos_drm_crtc
*crtc
,
317 struct exynos_drm_plane
*plane
)
319 struct decon_context
*ctx
= crtc
->ctx
;
324 decon_shadow_protect_win(ctx
, plane
->zpos
, false);
327 atomic_set(&ctx
->win_updated
, 1);
330 static void decon_swreset(struct decon_context
*ctx
)
334 writel(0, ctx
->addr
+ DECON_VIDCON0
);
335 for (tries
= 2000; tries
; --tries
) {
336 if (~readl(ctx
->addr
+ DECON_VIDCON0
) & VIDCON0_STOP_STATUS
)
341 WARN(tries
== 0, "failed to disable DECON\n");
343 writel(VIDCON0_SWRESET
, ctx
->addr
+ DECON_VIDCON0
);
344 for (tries
= 2000; tries
; --tries
) {
345 if (~readl(ctx
->addr
+ DECON_VIDCON0
) & VIDCON0_SWRESET
)
350 WARN(tries
== 0, "failed to software reset DECON\n");
353 static void decon_enable(struct exynos_drm_crtc
*crtc
)
355 struct decon_context
*ctx
= crtc
->ctx
;
362 ctx
->suspended
= false;
364 pm_runtime_get_sync(ctx
->dev
);
366 for (i
= 0; i
< ARRAY_SIZE(decon_clks_name
); i
++) {
367 ret
= clk_prepare_enable(ctx
->clks
[i
]);
372 set_bit(BIT_CLKS_ENABLED
, &ctx
->enabled
);
374 /* if vblank was enabled status, enable it again. */
375 if (test_and_clear_bit(0, &ctx
->irq_flags
))
376 decon_enable_vblank(ctx
->crtc
);
378 decon_commit(ctx
->crtc
);
383 clk_disable_unprepare(ctx
->clks
[i
]);
385 ctx
->suspended
= true;
388 static void decon_disable(struct exynos_drm_crtc
*crtc
)
390 struct decon_context
*ctx
= crtc
->ctx
;
397 * We need to make sure that all windows are disabled before we
398 * suspend that connector. Otherwise we might try to scan from
399 * a destroyed buffer later.
401 for (i
= 0; i
< WINDOWS_NR
; i
++)
402 decon_disable_plane(crtc
, &ctx
->planes
[i
]);
406 for (i
= 0; i
< ARRAY_SIZE(decon_clks_name
); i
++)
407 clk_disable_unprepare(ctx
->clks
[i
]);
409 clear_bit(BIT_CLKS_ENABLED
, &ctx
->enabled
);
411 pm_runtime_put_sync(ctx
->dev
);
413 ctx
->suspended
= true;
416 void decon_te_irq_handler(struct exynos_drm_crtc
*crtc
)
418 struct decon_context
*ctx
= crtc
->ctx
;
421 if (!test_bit(BIT_CLKS_ENABLED
, &ctx
->enabled
))
424 if (atomic_add_unless(&ctx
->win_updated
, -1, 0)) {
426 val
= readl(ctx
->addr
+ DECON_TRIGCON
);
427 val
|= TRIGCON_SWTRIGCMD
;
428 writel(val
, ctx
->addr
+ DECON_TRIGCON
);
431 drm_crtc_handle_vblank(&ctx
->crtc
->base
);
434 static void decon_clear_channels(struct exynos_drm_crtc
*crtc
)
436 struct decon_context
*ctx
= crtc
->ctx
;
440 DRM_DEBUG_KMS("%s\n", __FILE__
);
442 for (i
= 0; i
< ARRAY_SIZE(decon_clks_name
); i
++) {
443 ret
= clk_prepare_enable(ctx
->clks
[i
]);
448 for (win
= 0; win
< WINDOWS_NR
; win
++) {
449 /* shadow update disable */
450 val
= readl(ctx
->addr
+ DECON_SHADOWCON
);
451 val
|= SHADOWCON_Wx_PROTECT(win
);
452 writel(val
, ctx
->addr
+ DECON_SHADOWCON
);
455 val
= readl(ctx
->addr
+ DECON_WINCONx(win
));
456 val
&= ~WINCONx_ENWIN_F
;
457 writel(val
, ctx
->addr
+ DECON_WINCONx(win
));
459 /* shadow update enable */
460 val
= readl(ctx
->addr
+ DECON_SHADOWCON
);
461 val
&= ~SHADOWCON_Wx_PROTECT(win
);
462 writel(val
, ctx
->addr
+ DECON_SHADOWCON
);
464 /* standalone update */
465 val
= readl(ctx
->addr
+ DECON_UPDATE
);
466 val
|= STANDALONE_UPDATE_F
;
467 writel(val
, ctx
->addr
+ DECON_UPDATE
);
469 /* TODO: wait for possible vsync */
474 clk_disable_unprepare(ctx
->clks
[i
]);
477 static struct exynos_drm_crtc_ops decon_crtc_ops
= {
478 .enable
= decon_enable
,
479 .disable
= decon_disable
,
480 .commit
= decon_commit
,
481 .enable_vblank
= decon_enable_vblank
,
482 .disable_vblank
= decon_disable_vblank
,
483 .commit
= decon_commit
,
484 .atomic_begin
= decon_atomic_begin
,
485 .update_plane
= decon_update_plane
,
486 .disable_plane
= decon_disable_plane
,
487 .atomic_flush
= decon_atomic_flush
,
488 .te_handler
= decon_te_irq_handler
,
491 static int decon_bind(struct device
*dev
, struct device
*master
, void *data
)
493 struct decon_context
*ctx
= dev_get_drvdata(dev
);
494 struct drm_device
*drm_dev
= data
;
495 struct exynos_drm_private
*priv
= drm_dev
->dev_private
;
496 struct exynos_drm_plane
*exynos_plane
;
497 enum drm_plane_type type
;
501 ctx
->drm_dev
= drm_dev
;
502 ctx
->pipe
= priv
->pipe
++;
504 for (zpos
= 0; zpos
< WINDOWS_NR
; zpos
++) {
505 type
= exynos_plane_get_type(zpos
, CURSOR_WIN
);
506 ret
= exynos_plane_init(drm_dev
, &ctx
->planes
[zpos
],
507 1 << ctx
->pipe
, type
, decon_formats
,
508 ARRAY_SIZE(decon_formats
), zpos
);
513 exynos_plane
= &ctx
->planes
[DEFAULT_WIN
];
514 ctx
->crtc
= exynos_drm_crtc_create(drm_dev
, &exynos_plane
->base
,
515 ctx
->pipe
, EXYNOS_DISPLAY_TYPE_LCD
,
516 &decon_crtc_ops
, ctx
);
517 if (IS_ERR(ctx
->crtc
)) {
518 ret
= PTR_ERR(ctx
->crtc
);
522 decon_clear_channels(ctx
->crtc
);
524 ret
= drm_iommu_attach_device(drm_dev
, dev
);
534 static void decon_unbind(struct device
*dev
, struct device
*master
, void *data
)
536 struct decon_context
*ctx
= dev_get_drvdata(dev
);
538 decon_disable(ctx
->crtc
);
540 /* detach this sub driver from iommu mapping if supported. */
541 drm_iommu_detach_device(ctx
->drm_dev
, ctx
->dev
);
544 static const struct component_ops decon_component_ops
= {
546 .unbind
= decon_unbind
,
549 static irqreturn_t
decon_vsync_irq_handler(int irq
, void *dev_id
)
551 struct decon_context
*ctx
= dev_id
;
554 if (!test_bit(BIT_CLKS_ENABLED
, &ctx
->enabled
))
557 val
= readl(ctx
->addr
+ DECON_VIDINTCON1
);
558 if (val
& VIDINTCON1_INTFRMPEND
) {
559 drm_crtc_handle_vblank(&ctx
->crtc
->base
);
562 writel(VIDINTCON1_INTFRMPEND
, ctx
->addr
+ DECON_VIDINTCON1
);
569 static irqreturn_t
decon_lcd_sys_irq_handler(int irq
, void *dev_id
)
571 struct decon_context
*ctx
= dev_id
;
575 if (!test_bit(BIT_CLKS_ENABLED
, &ctx
->enabled
))
578 val
= readl(ctx
->addr
+ DECON_VIDINTCON1
);
579 if (val
& VIDINTCON1_INTFRMDONEPEND
) {
580 for (win
= 0 ; win
< WINDOWS_NR
; win
++) {
581 struct exynos_drm_plane
*plane
= &ctx
->planes
[win
];
583 if (!plane
->pending_fb
)
586 exynos_drm_crtc_finish_update(ctx
->crtc
, plane
);
590 writel(VIDINTCON1_INTFRMDONEPEND
,
591 ctx
->addr
+ DECON_VIDINTCON1
);
598 static int exynos5433_decon_probe(struct platform_device
*pdev
)
600 struct device
*dev
= &pdev
->dev
;
601 struct decon_context
*ctx
;
602 struct resource
*res
;
606 ctx
= devm_kzalloc(dev
, sizeof(*ctx
), GFP_KERNEL
);
610 ctx
->suspended
= true;
612 if (of_get_child_by_name(dev
->of_node
, "i80-if-timings"))
615 for (i
= 0; i
< ARRAY_SIZE(decon_clks_name
); i
++) {
618 clk
= devm_clk_get(ctx
->dev
, decon_clks_name
[i
]);
625 res
= platform_get_resource(pdev
, IORESOURCE_MEM
, 0);
627 dev_err(dev
, "cannot find IO resource\n");
631 ctx
->addr
= devm_ioremap_resource(dev
, res
);
632 if (IS_ERR(ctx
->addr
)) {
633 dev_err(dev
, "ioremap failed\n");
634 return PTR_ERR(ctx
->addr
);
637 res
= platform_get_resource_byname(pdev
, IORESOURCE_IRQ
,
638 ctx
->i80_if
? "lcd_sys" : "vsync");
640 dev_err(dev
, "cannot find IRQ resource\n");
644 ret
= devm_request_irq(dev
, res
->start
, ctx
->i80_if
?
645 decon_lcd_sys_irq_handler
: decon_vsync_irq_handler
, 0,
648 dev_err(dev
, "lcd_sys irq request failed\n");
652 platform_set_drvdata(pdev
, ctx
);
654 pm_runtime_enable(dev
);
656 ret
= component_add(dev
, &decon_component_ops
);
658 goto err_disable_pm_runtime
;
662 err_disable_pm_runtime
:
663 pm_runtime_disable(dev
);
668 static int exynos5433_decon_remove(struct platform_device
*pdev
)
670 pm_runtime_disable(&pdev
->dev
);
672 component_del(&pdev
->dev
, &decon_component_ops
);
677 static const struct of_device_id exynos5433_decon_driver_dt_match
[] = {
678 { .compatible
= "samsung,exynos5433-decon" },
681 MODULE_DEVICE_TABLE(of
, exynos5433_decon_driver_dt_match
);
683 struct platform_driver exynos5433_decon_driver
= {
684 .probe
= exynos5433_decon_probe
,
685 .remove
= exynos5433_decon_remove
,
687 .name
= "exynos5433-decon",
688 .of_match_table
= exynos5433_decon_driver_dt_match
,