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_device.h>
17 #include <linux/of_gpio.h>
18 #include <linux/pm_runtime.h>
20 #include <video/exynos5433_decon.h>
22 #include "exynos_drm_drv.h"
23 #include "exynos_drm_crtc.h"
24 #include "exynos_drm_fb.h"
25 #include "exynos_drm_plane.h"
26 #include "exynos_drm_iommu.h"
29 #define MIN_FB_WIDTH_FOR_16WORD_BURST 128
31 static const char * const decon_clks_name
[] = {
47 enum decon_flag_bits
{
54 struct decon_context
{
56 struct drm_device
*drm_dev
;
57 struct exynos_drm_crtc
*crtc
;
58 struct exynos_drm_plane planes
[WINDOWS_NR
];
59 struct exynos_drm_plane_config configs
[WINDOWS_NR
];
61 struct clk
*clks
[ARRAY_SIZE(decon_clks_name
)];
64 enum decon_iftype out_type
;
68 static const uint32_t decon_formats
[] = {
75 static const enum drm_plane_type decon_win_types
[WINDOWS_NR
] = {
76 DRM_PLANE_TYPE_PRIMARY
,
77 DRM_PLANE_TYPE_OVERLAY
,
78 DRM_PLANE_TYPE_CURSOR
,
81 static inline void decon_set_bits(struct decon_context
*ctx
, u32 reg
, u32 mask
,
84 val
= (val
& mask
) | (readl(ctx
->addr
+ reg
) & ~mask
);
85 writel(val
, ctx
->addr
+ reg
);
88 static int decon_enable_vblank(struct exynos_drm_crtc
*crtc
)
90 struct decon_context
*ctx
= crtc
->ctx
;
93 if (test_bit(BIT_SUSPENDED
, &ctx
->flags
))
96 if (test_and_set_bit(BIT_IRQS_ENABLED
, &ctx
->flags
)) {
97 val
= VIDINTCON0_INTEN
;
98 if (ctx
->out_type
== IFTYPE_I80
)
99 val
|= VIDINTCON0_FRAMEDONE
;
101 val
|= VIDINTCON0_INTFRMEN
;
103 writel(val
, ctx
->addr
+ DECON_VIDINTCON0
);
109 static void decon_disable_vblank(struct exynos_drm_crtc
*crtc
)
111 struct decon_context
*ctx
= crtc
->ctx
;
113 if (test_bit(BIT_SUSPENDED
, &ctx
->flags
))
116 if (test_and_clear_bit(BIT_IRQS_ENABLED
, &ctx
->flags
))
117 writel(0, ctx
->addr
+ DECON_VIDINTCON0
);
120 static void decon_setup_trigger(struct decon_context
*ctx
)
122 u32 val
= (ctx
->out_type
!= IFTYPE_HDMI
)
123 ? TRIGCON_TRIGEN_PER_F
| TRIGCON_TRIGEN_F
|
124 TRIGCON_TE_AUTO_MASK
| TRIGCON_SWTRIGEN
125 : TRIGCON_TRIGEN_PER_F
| TRIGCON_TRIGEN_F
|
126 TRIGCON_HWTRIGMASK_I80_RGB
| TRIGCON_HWTRIGEN_I80_RGB
;
127 writel(val
, ctx
->addr
+ DECON_TRIGCON
);
130 static void decon_commit(struct exynos_drm_crtc
*crtc
)
132 struct decon_context
*ctx
= crtc
->ctx
;
133 struct drm_display_mode
*m
= &crtc
->base
.mode
;
136 if (test_bit(BIT_SUSPENDED
, &ctx
->flags
))
139 if (ctx
->out_type
== IFTYPE_HDMI
) {
140 m
->crtc_hsync_start
= m
->crtc_hdisplay
+ 10;
141 m
->crtc_hsync_end
= m
->crtc_htotal
- 92;
142 m
->crtc_vsync_start
= m
->crtc_vdisplay
+ 1;
143 m
->crtc_vsync_end
= m
->crtc_vsync_start
+ 1;
146 decon_set_bits(ctx
, DECON_VIDCON0
, VIDCON0_ENVID
, 0);
148 /* enable clock gate */
149 val
= CMU_CLKGAGE_MODE_SFR_F
| CMU_CLKGAGE_MODE_MEM_F
;
150 writel(val
, ctx
->addr
+ DECON_CMU
);
152 /* lcd on and use command if */
154 if (ctx
->out_type
== IFTYPE_I80
)
155 val
|= VIDOUT_COMMAND_IF
;
157 val
|= VIDOUT_RGB_IF
;
158 writel(val
, ctx
->addr
+ DECON_VIDOUTCON0
);
160 val
= VIDTCON2_LINEVAL(m
->vdisplay
- 1) |
161 VIDTCON2_HOZVAL(m
->hdisplay
- 1);
162 writel(val
, ctx
->addr
+ DECON_VIDTCON2
);
164 if (ctx
->out_type
!= IFTYPE_I80
) {
165 val
= VIDTCON00_VBPD_F(
166 m
->crtc_vtotal
- m
->crtc_vsync_end
- 1) |
168 m
->crtc_vsync_start
- m
->crtc_vdisplay
- 1);
169 writel(val
, ctx
->addr
+ DECON_VIDTCON00
);
171 val
= VIDTCON01_VSPW_F(
172 m
->crtc_vsync_end
- m
->crtc_vsync_start
- 1);
173 writel(val
, ctx
->addr
+ DECON_VIDTCON01
);
175 val
= VIDTCON10_HBPD_F(
176 m
->crtc_htotal
- m
->crtc_hsync_end
- 1) |
178 m
->crtc_hsync_start
- m
->crtc_hdisplay
- 1);
179 writel(val
, ctx
->addr
+ DECON_VIDTCON10
);
181 val
= VIDTCON11_HSPW_F(
182 m
->crtc_hsync_end
- m
->crtc_hsync_start
- 1);
183 writel(val
, ctx
->addr
+ DECON_VIDTCON11
);
186 decon_setup_trigger(ctx
);
188 /* enable output and display signal */
189 decon_set_bits(ctx
, DECON_VIDCON0
, VIDCON0_ENVID
| VIDCON0_ENVID_F
, ~0);
192 static void decon_win_set_pixfmt(struct decon_context
*ctx
, unsigned int win
,
193 struct drm_framebuffer
*fb
)
197 val
= readl(ctx
->addr
+ DECON_WINCONx(win
));
198 val
&= ~WINCONx_BPPMODE_MASK
;
200 switch (fb
->pixel_format
) {
201 case DRM_FORMAT_XRGB1555
:
202 val
|= WINCONx_BPPMODE_16BPP_I1555
;
203 val
|= WINCONx_HAWSWP_F
;
204 val
|= WINCONx_BURSTLEN_16WORD
;
206 case DRM_FORMAT_RGB565
:
207 val
|= WINCONx_BPPMODE_16BPP_565
;
208 val
|= WINCONx_HAWSWP_F
;
209 val
|= WINCONx_BURSTLEN_16WORD
;
211 case DRM_FORMAT_XRGB8888
:
212 val
|= WINCONx_BPPMODE_24BPP_888
;
213 val
|= WINCONx_WSWP_F
;
214 val
|= WINCONx_BURSTLEN_16WORD
;
216 case DRM_FORMAT_ARGB8888
:
217 val
|= WINCONx_BPPMODE_32BPP_A8888
;
218 val
|= WINCONx_WSWP_F
| WINCONx_BLD_PIX_F
| WINCONx_ALPHA_SEL_F
;
219 val
|= WINCONx_BURSTLEN_16WORD
;
222 DRM_ERROR("Proper pixel format is not set\n");
226 DRM_DEBUG_KMS("bpp = %u\n", fb
->bits_per_pixel
);
229 * In case of exynos, setting dma-burst to 16Word causes permanent
230 * tearing for very small buffers, e.g. cursor buffer. Burst Mode
231 * switching which is based on plane size is not recommended as
232 * plane size varies a lot towards the end of the screen and rapid
233 * movement causes unstable DMA which results into iommu crash/tear.
236 if (fb
->width
< MIN_FB_WIDTH_FOR_16WORD_BURST
) {
237 val
&= ~WINCONx_BURSTLEN_MASK
;
238 val
|= WINCONx_BURSTLEN_8WORD
;
241 writel(val
, ctx
->addr
+ DECON_WINCONx(win
));
244 static void decon_shadow_protect_win(struct decon_context
*ctx
, int win
,
247 decon_set_bits(ctx
, DECON_SHADOWCON
, SHADOWCON_Wx_PROTECT(win
),
251 static void decon_atomic_begin(struct exynos_drm_crtc
*crtc
,
252 struct exynos_drm_plane
*plane
)
254 struct decon_context
*ctx
= crtc
->ctx
;
256 if (test_bit(BIT_SUSPENDED
, &ctx
->flags
))
259 decon_shadow_protect_win(ctx
, plane
->index
, true);
262 #define BIT_VAL(x, e, s) (((x) & ((1 << ((e) - (s) + 1)) - 1)) << (s))
263 #define COORDINATE_X(x) BIT_VAL((x), 23, 12)
264 #define COORDINATE_Y(x) BIT_VAL((x), 11, 0)
266 static void decon_update_plane(struct exynos_drm_crtc
*crtc
,
267 struct exynos_drm_plane
*plane
)
269 struct exynos_drm_plane_state
*state
=
270 to_exynos_plane_state(plane
->base
.state
);
271 struct decon_context
*ctx
= crtc
->ctx
;
272 struct drm_framebuffer
*fb
= state
->base
.fb
;
273 unsigned int win
= plane
->index
;
274 unsigned int bpp
= fb
->bits_per_pixel
>> 3;
275 unsigned int pitch
= fb
->pitches
[0];
276 dma_addr_t dma_addr
= exynos_drm_fb_dma_addr(fb
, 0);
279 if (test_bit(BIT_SUSPENDED
, &ctx
->flags
))
282 val
= COORDINATE_X(state
->crtc
.x
) | COORDINATE_Y(state
->crtc
.y
);
283 writel(val
, ctx
->addr
+ DECON_VIDOSDxA(win
));
285 val
= COORDINATE_X(state
->crtc
.x
+ state
->crtc
.w
- 1) |
286 COORDINATE_Y(state
->crtc
.y
+ state
->crtc
.h
- 1);
287 writel(val
, ctx
->addr
+ DECON_VIDOSDxB(win
));
289 val
= VIDOSD_Wx_ALPHA_R_F(0x0) | VIDOSD_Wx_ALPHA_G_F(0x0) |
290 VIDOSD_Wx_ALPHA_B_F(0x0);
291 writel(val
, ctx
->addr
+ DECON_VIDOSDxC(win
));
293 val
= VIDOSD_Wx_ALPHA_R_F(0x0) | VIDOSD_Wx_ALPHA_G_F(0x0) |
294 VIDOSD_Wx_ALPHA_B_F(0x0);
295 writel(val
, ctx
->addr
+ DECON_VIDOSDxD(win
));
297 writel(dma_addr
, ctx
->addr
+ DECON_VIDW0xADD0B0(win
));
299 val
= dma_addr
+ pitch
* state
->src
.h
;
300 writel(val
, ctx
->addr
+ DECON_VIDW0xADD1B0(win
));
302 if (ctx
->out_type
!= IFTYPE_HDMI
)
303 val
= BIT_VAL(pitch
- state
->crtc
.w
* bpp
, 27, 14)
304 | BIT_VAL(state
->crtc
.w
* bpp
, 13, 0);
306 val
= BIT_VAL(pitch
- state
->crtc
.w
* bpp
, 29, 15)
307 | BIT_VAL(state
->crtc
.w
* bpp
, 14, 0);
308 writel(val
, ctx
->addr
+ DECON_VIDW0xADD2(win
));
310 decon_win_set_pixfmt(ctx
, win
, fb
);
313 decon_set_bits(ctx
, DECON_WINCONx(win
), WINCONx_ENWIN_F
, ~0);
315 /* standalone update */
316 decon_set_bits(ctx
, DECON_UPDATE
, STANDALONE_UPDATE_F
, ~0);
319 static void decon_disable_plane(struct exynos_drm_crtc
*crtc
,
320 struct exynos_drm_plane
*plane
)
322 struct decon_context
*ctx
= crtc
->ctx
;
323 unsigned int win
= plane
->index
;
325 if (test_bit(BIT_SUSPENDED
, &ctx
->flags
))
328 decon_shadow_protect_win(ctx
, win
, true);
331 decon_set_bits(ctx
, DECON_WINCONx(win
), WINCONx_ENWIN_F
, 0);
333 decon_shadow_protect_win(ctx
, win
, false);
335 /* standalone update */
336 decon_set_bits(ctx
, DECON_UPDATE
, STANDALONE_UPDATE_F
, ~0);
339 static void decon_atomic_flush(struct exynos_drm_crtc
*crtc
,
340 struct exynos_drm_plane
*plane
)
342 struct decon_context
*ctx
= crtc
->ctx
;
344 if (test_bit(BIT_SUSPENDED
, &ctx
->flags
))
347 decon_shadow_protect_win(ctx
, plane
->index
, false);
349 if (ctx
->out_type
== IFTYPE_I80
)
350 set_bit(BIT_WIN_UPDATED
, &ctx
->flags
);
353 static void decon_swreset(struct decon_context
*ctx
)
357 writel(0, ctx
->addr
+ DECON_VIDCON0
);
358 for (tries
= 2000; tries
; --tries
) {
359 if (~readl(ctx
->addr
+ DECON_VIDCON0
) & VIDCON0_STOP_STATUS
)
364 WARN(tries
== 0, "failed to disable DECON\n");
366 writel(VIDCON0_SWRESET
, ctx
->addr
+ DECON_VIDCON0
);
367 for (tries
= 2000; tries
; --tries
) {
368 if (~readl(ctx
->addr
+ DECON_VIDCON0
) & VIDCON0_SWRESET
)
373 WARN(tries
== 0, "failed to software reset DECON\n");
375 if (ctx
->out_type
!= IFTYPE_HDMI
)
378 writel(VIDCON0_CLKVALUP
| VIDCON0_VLCKFREE
, ctx
->addr
+ DECON_VIDCON0
);
379 decon_set_bits(ctx
, DECON_CMU
,
380 CMU_CLKGAGE_MODE_SFR_F
| CMU_CLKGAGE_MODE_MEM_F
, ~0);
381 writel(VIDCON1_VCLK_RUN_VDEN_DISABLE
, ctx
->addr
+ DECON_VIDCON1
);
382 writel(CRCCTRL_CRCEN
| CRCCTRL_CRCSTART_F
| CRCCTRL_CRCCLKEN
,
383 ctx
->addr
+ DECON_CRCCTRL
);
384 decon_setup_trigger(ctx
);
387 static void decon_enable(struct exynos_drm_crtc
*crtc
)
389 struct decon_context
*ctx
= crtc
->ctx
;
391 if (!test_and_clear_bit(BIT_SUSPENDED
, &ctx
->flags
))
394 pm_runtime_get_sync(ctx
->dev
);
396 set_bit(BIT_CLKS_ENABLED
, &ctx
->flags
);
398 /* if vblank was enabled status, enable it again. */
399 if (test_and_clear_bit(BIT_IRQS_ENABLED
, &ctx
->flags
))
400 decon_enable_vblank(ctx
->crtc
);
402 decon_commit(ctx
->crtc
);
404 set_bit(BIT_SUSPENDED
, &ctx
->flags
);
407 static void decon_disable(struct exynos_drm_crtc
*crtc
)
409 struct decon_context
*ctx
= crtc
->ctx
;
412 if (test_bit(BIT_SUSPENDED
, &ctx
->flags
))
416 * We need to make sure that all windows are disabled before we
417 * suspend that connector. Otherwise we might try to scan from
418 * a destroyed buffer later.
420 for (i
= ctx
->first_win
; i
< WINDOWS_NR
; i
++)
421 decon_disable_plane(crtc
, &ctx
->planes
[i
]);
425 clear_bit(BIT_CLKS_ENABLED
, &ctx
->flags
);
427 pm_runtime_put_sync(ctx
->dev
);
429 set_bit(BIT_SUSPENDED
, &ctx
->flags
);
432 void decon_te_irq_handler(struct exynos_drm_crtc
*crtc
)
434 struct decon_context
*ctx
= crtc
->ctx
;
436 if (!test_bit(BIT_CLKS_ENABLED
, &ctx
->flags
))
439 if (test_and_clear_bit(BIT_WIN_UPDATED
, &ctx
->flags
))
440 decon_set_bits(ctx
, DECON_TRIGCON
, TRIGCON_SWTRIGCMD
, ~0);
442 drm_crtc_handle_vblank(&ctx
->crtc
->base
);
445 static void decon_clear_channels(struct exynos_drm_crtc
*crtc
)
447 struct decon_context
*ctx
= crtc
->ctx
;
450 DRM_DEBUG_KMS("%s\n", __FILE__
);
452 for (i
= 0; i
< ARRAY_SIZE(decon_clks_name
); i
++) {
453 ret
= clk_prepare_enable(ctx
->clks
[i
]);
458 for (win
= 0; win
< WINDOWS_NR
; win
++) {
459 decon_shadow_protect_win(ctx
, win
, true);
460 decon_set_bits(ctx
, DECON_WINCONx(win
), WINCONx_ENWIN_F
, 0);
461 decon_shadow_protect_win(ctx
, win
, false);
462 decon_set_bits(ctx
, DECON_UPDATE
, STANDALONE_UPDATE_F
, ~0);
464 /* TODO: wait for possible vsync */
469 clk_disable_unprepare(ctx
->clks
[i
]);
472 static struct exynos_drm_crtc_ops decon_crtc_ops
= {
473 .enable
= decon_enable
,
474 .disable
= decon_disable
,
475 .enable_vblank
= decon_enable_vblank
,
476 .disable_vblank
= decon_disable_vblank
,
477 .atomic_begin
= decon_atomic_begin
,
478 .update_plane
= decon_update_plane
,
479 .disable_plane
= decon_disable_plane
,
480 .atomic_flush
= decon_atomic_flush
,
481 .te_handler
= decon_te_irq_handler
,
484 static int decon_bind(struct device
*dev
, struct device
*master
, void *data
)
486 struct decon_context
*ctx
= dev_get_drvdata(dev
);
487 struct drm_device
*drm_dev
= data
;
488 struct exynos_drm_private
*priv
= drm_dev
->dev_private
;
489 struct exynos_drm_plane
*exynos_plane
;
490 enum exynos_drm_output_type out_type
;
494 ctx
->drm_dev
= drm_dev
;
495 ctx
->pipe
= priv
->pipe
++;
497 for (win
= ctx
->first_win
; win
< WINDOWS_NR
; win
++) {
498 int tmp
= (win
== ctx
->first_win
) ? 0 : win
;
500 ctx
->configs
[win
].pixel_formats
= decon_formats
;
501 ctx
->configs
[win
].num_pixel_formats
= ARRAY_SIZE(decon_formats
);
502 ctx
->configs
[win
].zpos
= win
;
503 ctx
->configs
[win
].type
= decon_win_types
[tmp
];
505 ret
= exynos_plane_init(drm_dev
, &ctx
->planes
[win
], win
,
506 1 << ctx
->pipe
, &ctx
->configs
[win
]);
511 exynos_plane
= &ctx
->planes
[ctx
->first_win
];
512 out_type
= (ctx
->out_type
== IFTYPE_HDMI
) ? EXYNOS_DISPLAY_TYPE_HDMI
513 : EXYNOS_DISPLAY_TYPE_LCD
;
514 ctx
->crtc
= exynos_drm_crtc_create(drm_dev
, &exynos_plane
->base
,
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_irq_handler(int irq
, void *dev_id
)
551 struct decon_context
*ctx
= dev_id
;
555 if (!test_bit(BIT_CLKS_ENABLED
, &ctx
->flags
))
558 val
= readl(ctx
->addr
+ DECON_VIDINTCON1
);
559 val
&= VIDINTCON1_INTFRMDONEPEND
| VIDINTCON1_INTFRMPEND
;
562 for (win
= ctx
->first_win
; win
< WINDOWS_NR
; win
++) {
563 struct exynos_drm_plane
*plane
= &ctx
->planes
[win
];
565 if (!plane
->pending_fb
)
568 exynos_drm_crtc_finish_update(ctx
->crtc
, plane
);
572 writel(val
, ctx
->addr
+ DECON_VIDINTCON1
);
580 static int exynos5433_decon_suspend(struct device
*dev
)
582 struct decon_context
*ctx
= dev_get_drvdata(dev
);
585 for (i
= 0; i
< ARRAY_SIZE(decon_clks_name
); i
++)
586 clk_disable_unprepare(ctx
->clks
[i
]);
591 static int exynos5433_decon_resume(struct device
*dev
)
593 struct decon_context
*ctx
= dev_get_drvdata(dev
);
596 for (i
= 0; i
< ARRAY_SIZE(decon_clks_name
); i
++) {
597 ret
= clk_prepare_enable(ctx
->clks
[i
]);
606 clk_disable_unprepare(ctx
->clks
[i
]);
612 static const struct dev_pm_ops exynos5433_decon_pm_ops
= {
613 SET_RUNTIME_PM_OPS(exynos5433_decon_suspend
, exynos5433_decon_resume
,
617 static const struct of_device_id exynos5433_decon_driver_dt_match
[] = {
619 .compatible
= "samsung,exynos5433-decon",
620 .data
= (void *)IFTYPE_RGB
623 .compatible
= "samsung,exynos5433-decon-tv",
624 .data
= (void *)IFTYPE_HDMI
628 MODULE_DEVICE_TABLE(of
, exynos5433_decon_driver_dt_match
);
630 static int exynos5433_decon_probe(struct platform_device
*pdev
)
632 const struct of_device_id
*of_id
;
633 struct device
*dev
= &pdev
->dev
;
634 struct decon_context
*ctx
;
635 struct resource
*res
;
639 ctx
= devm_kzalloc(dev
, sizeof(*ctx
), GFP_KERNEL
);
643 __set_bit(BIT_SUSPENDED
, &ctx
->flags
);
646 of_id
= of_match_device(exynos5433_decon_driver_dt_match
, &pdev
->dev
);
647 ctx
->out_type
= (enum decon_iftype
)of_id
->data
;
649 if (ctx
->out_type
== IFTYPE_HDMI
)
651 else if (of_get_child_by_name(dev
->of_node
, "i80-if-timings"))
652 ctx
->out_type
= IFTYPE_I80
;
654 for (i
= 0; i
< ARRAY_SIZE(decon_clks_name
); i
++) {
657 clk
= devm_clk_get(ctx
->dev
, decon_clks_name
[i
]);
664 res
= platform_get_resource(pdev
, IORESOURCE_MEM
, 0);
666 dev_err(dev
, "cannot find IO resource\n");
670 ctx
->addr
= devm_ioremap_resource(dev
, res
);
671 if (IS_ERR(ctx
->addr
)) {
672 dev_err(dev
, "ioremap failed\n");
673 return PTR_ERR(ctx
->addr
);
676 res
= platform_get_resource_byname(pdev
, IORESOURCE_IRQ
,
677 (ctx
->out_type
== IFTYPE_I80
) ? "lcd_sys" : "vsync");
679 dev_err(dev
, "cannot find IRQ resource\n");
683 ret
= devm_request_irq(dev
, res
->start
, decon_irq_handler
, 0,
686 dev_err(dev
, "lcd_sys irq request failed\n");
690 platform_set_drvdata(pdev
, ctx
);
692 pm_runtime_enable(dev
);
694 ret
= component_add(dev
, &decon_component_ops
);
696 goto err_disable_pm_runtime
;
700 err_disable_pm_runtime
:
701 pm_runtime_disable(dev
);
706 static int exynos5433_decon_remove(struct platform_device
*pdev
)
708 pm_runtime_disable(&pdev
->dev
);
710 component_del(&pdev
->dev
, &decon_component_ops
);
715 struct platform_driver exynos5433_decon_driver
= {
716 .probe
= exynos5433_decon_probe
,
717 .remove
= exynos5433_decon_remove
,
719 .name
= "exynos5433-decon",
720 .pm
= &exynos5433_decon_pm_ops
,
721 .of_match_table
= exynos5433_decon_driver_dt_match
,