2 * rcar_du_crtc.c -- R-Car Display Unit CRTCs
4 * Copyright (C) 2013-2014 Renesas Electronics Corporation
6 * Contact: Laurent Pinchart (laurent.pinchart@ideasonboard.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 as published by
10 * the Free Software Foundation; either version 2 of the License, or
11 * (at your option) any later version.
14 #include <linux/clk.h>
15 #include <linux/mutex.h>
18 #include <drm/drm_atomic.h>
19 #include <drm/drm_atomic_helper.h>
20 #include <drm/drm_crtc.h>
21 #include <drm/drm_crtc_helper.h>
22 #include <drm/drm_fb_cma_helper.h>
23 #include <drm/drm_gem_cma_helper.h>
24 #include <drm/drm_plane_helper.h>
26 #include "rcar_du_crtc.h"
27 #include "rcar_du_drv.h"
28 #include "rcar_du_kms.h"
29 #include "rcar_du_plane.h"
30 #include "rcar_du_regs.h"
32 static u32
rcar_du_crtc_read(struct rcar_du_crtc
*rcrtc
, u32 reg
)
34 struct rcar_du_device
*rcdu
= rcrtc
->group
->dev
;
36 return rcar_du_read(rcdu
, rcrtc
->mmio_offset
+ reg
);
39 static void rcar_du_crtc_write(struct rcar_du_crtc
*rcrtc
, u32 reg
, u32 data
)
41 struct rcar_du_device
*rcdu
= rcrtc
->group
->dev
;
43 rcar_du_write(rcdu
, rcrtc
->mmio_offset
+ reg
, data
);
46 static void rcar_du_crtc_clr(struct rcar_du_crtc
*rcrtc
, u32 reg
, u32 clr
)
48 struct rcar_du_device
*rcdu
= rcrtc
->group
->dev
;
50 rcar_du_write(rcdu
, rcrtc
->mmio_offset
+ reg
,
51 rcar_du_read(rcdu
, rcrtc
->mmio_offset
+ reg
) & ~clr
);
54 static void rcar_du_crtc_set(struct rcar_du_crtc
*rcrtc
, u32 reg
, u32 set
)
56 struct rcar_du_device
*rcdu
= rcrtc
->group
->dev
;
58 rcar_du_write(rcdu
, rcrtc
->mmio_offset
+ reg
,
59 rcar_du_read(rcdu
, rcrtc
->mmio_offset
+ reg
) | set
);
62 static void rcar_du_crtc_clr_set(struct rcar_du_crtc
*rcrtc
, u32 reg
,
65 struct rcar_du_device
*rcdu
= rcrtc
->group
->dev
;
66 u32 value
= rcar_du_read(rcdu
, rcrtc
->mmio_offset
+ reg
);
68 rcar_du_write(rcdu
, rcrtc
->mmio_offset
+ reg
, (value
& ~clr
) | set
);
71 static int rcar_du_crtc_get(struct rcar_du_crtc
*rcrtc
)
75 ret
= clk_prepare_enable(rcrtc
->clock
);
79 ret
= clk_prepare_enable(rcrtc
->extclock
);
83 ret
= rcar_du_group_get(rcrtc
->group
);
90 clk_disable_unprepare(rcrtc
->extclock
);
92 clk_disable_unprepare(rcrtc
->clock
);
96 static void rcar_du_crtc_put(struct rcar_du_crtc
*rcrtc
)
98 rcar_du_group_put(rcrtc
->group
);
100 clk_disable_unprepare(rcrtc
->extclock
);
101 clk_disable_unprepare(rcrtc
->clock
);
104 /* -----------------------------------------------------------------------------
108 static void rcar_du_crtc_set_display_timing(struct rcar_du_crtc
*rcrtc
)
110 const struct drm_display_mode
*mode
= &rcrtc
->crtc
.state
->adjusted_mode
;
111 unsigned long mode_clock
= mode
->clock
* 1000;
117 /* Compute the clock divisor and select the internal or external dot
118 * clock based on the requested frequency.
120 clk
= clk_get_rate(rcrtc
->clock
);
121 div
= DIV_ROUND_CLOSEST(clk
, mode_clock
);
122 div
= clamp(div
, 1U, 64U) - 1;
123 escr
= div
| ESCR_DCLKSEL_CLKS
;
125 if (rcrtc
->extclock
) {
126 unsigned long extclk
;
127 unsigned long extrate
;
131 extclk
= clk_get_rate(rcrtc
->extclock
);
132 extdiv
= DIV_ROUND_CLOSEST(extclk
, mode_clock
);
133 extdiv
= clamp(extdiv
, 1U, 64U) - 1;
135 rate
= clk
/ (div
+ 1);
136 extrate
= extclk
/ (extdiv
+ 1);
138 if (abs((long)extrate
- (long)mode_clock
) <
139 abs((long)rate
- (long)mode_clock
)) {
140 dev_dbg(rcrtc
->group
->dev
->dev
,
141 "crtc%u: using external clock\n", rcrtc
->index
);
142 escr
= extdiv
| ESCR_DCLKSEL_DCLKIN
;
146 rcar_du_group_write(rcrtc
->group
, rcrtc
->index
% 2 ? ESCR2
: ESCR
,
148 rcar_du_group_write(rcrtc
->group
, rcrtc
->index
% 2 ? OTAR2
: OTAR
, 0);
150 /* Signal polarities */
151 value
= ((mode
->flags
& DRM_MODE_FLAG_PVSYNC
) ? 0 : DSMR_VSL
)
152 | ((mode
->flags
& DRM_MODE_FLAG_PHSYNC
) ? 0 : DSMR_HSL
)
153 | DSMR_DIPM_DE
| DSMR_CSPM
;
154 rcar_du_crtc_write(rcrtc
, DSMR
, value
);
156 /* Display timings */
157 rcar_du_crtc_write(rcrtc
, HDSR
, mode
->htotal
- mode
->hsync_start
- 19);
158 rcar_du_crtc_write(rcrtc
, HDER
, mode
->htotal
- mode
->hsync_start
+
159 mode
->hdisplay
- 19);
160 rcar_du_crtc_write(rcrtc
, HSWR
, mode
->hsync_end
-
161 mode
->hsync_start
- 1);
162 rcar_du_crtc_write(rcrtc
, HCR
, mode
->htotal
- 1);
164 rcar_du_crtc_write(rcrtc
, VDSR
, mode
->crtc_vtotal
-
165 mode
->crtc_vsync_end
- 2);
166 rcar_du_crtc_write(rcrtc
, VDER
, mode
->crtc_vtotal
-
167 mode
->crtc_vsync_end
+
168 mode
->crtc_vdisplay
- 2);
169 rcar_du_crtc_write(rcrtc
, VSPR
, mode
->crtc_vtotal
-
170 mode
->crtc_vsync_end
+
171 mode
->crtc_vsync_start
- 1);
172 rcar_du_crtc_write(rcrtc
, VCR
, mode
->crtc_vtotal
- 1);
174 rcar_du_crtc_write(rcrtc
, DESR
, mode
->htotal
- mode
->hsync_start
);
175 rcar_du_crtc_write(rcrtc
, DEWR
, mode
->hdisplay
);
178 void rcar_du_crtc_route_output(struct drm_crtc
*crtc
,
179 enum rcar_du_output output
)
181 struct rcar_du_crtc
*rcrtc
= to_rcar_crtc(crtc
);
182 struct rcar_du_device
*rcdu
= rcrtc
->group
->dev
;
184 /* Store the route from the CRTC output to the DU output. The DU will be
185 * configured when starting the CRTC.
187 rcrtc
->outputs
|= BIT(output
);
189 /* Store RGB routing to DPAD0, the hardware will be configured when
192 if (output
== RCAR_DU_OUTPUT_DPAD0
)
193 rcdu
->dpad0_source
= rcrtc
->index
;
196 static unsigned int plane_zpos(struct rcar_du_plane
*plane
)
198 return to_rcar_plane_state(plane
->plane
.state
)->zpos
;
201 static const struct rcar_du_format_info
*
202 plane_format(struct rcar_du_plane
*plane
)
204 return to_rcar_plane_state(plane
->plane
.state
)->format
;
207 static void rcar_du_crtc_update_planes(struct rcar_du_crtc
*rcrtc
)
209 struct rcar_du_plane
*planes
[RCAR_DU_NUM_HW_PLANES
];
210 unsigned int num_planes
= 0;
211 unsigned int dptsr_planes
;
212 unsigned int hwplanes
= 0;
213 unsigned int prio
= 0;
217 for (i
= 0; i
< rcrtc
->group
->num_planes
; ++i
) {
218 struct rcar_du_plane
*plane
= &rcrtc
->group
->planes
[i
];
221 if (plane
->plane
.state
->crtc
!= &rcrtc
->crtc
)
224 /* Insert the plane in the sorted planes array. */
225 for (j
= num_planes
++; j
> 0; --j
) {
226 if (plane_zpos(planes
[j
-1]) <= plane_zpos(plane
))
228 planes
[j
] = planes
[j
-1];
232 prio
+= plane_format(plane
)->planes
* 4;
235 for (i
= 0; i
< num_planes
; ++i
) {
236 struct rcar_du_plane
*plane
= planes
[i
];
237 struct drm_plane_state
*state
= plane
->plane
.state
;
238 unsigned int index
= to_rcar_plane_state(state
)->hwindex
;
241 dspr
|= (index
+ 1) << prio
;
242 hwplanes
|= 1 << index
;
244 if (plane_format(plane
)->planes
== 2) {
245 index
= (index
+ 1) % 8;
248 dspr
|= (index
+ 1) << prio
;
249 hwplanes
|= 1 << index
;
253 /* Update the planes to display timing and dot clock generator
256 * Updating the DPTSR register requires restarting the CRTC group,
257 * resulting in visible flicker. To mitigate the issue only update the
258 * association if needed by enabled planes. Planes being disabled will
259 * keep their current association.
261 mutex_lock(&rcrtc
->group
->lock
);
263 dptsr_planes
= rcrtc
->index
% 2 ? rcrtc
->group
->dptsr_planes
| hwplanes
264 : rcrtc
->group
->dptsr_planes
& ~hwplanes
;
266 if (dptsr_planes
!= rcrtc
->group
->dptsr_planes
) {
267 rcar_du_group_write(rcrtc
->group
, DPTSR
,
268 (dptsr_planes
<< 16) | dptsr_planes
);
269 rcrtc
->group
->dptsr_planes
= dptsr_planes
;
271 if (rcrtc
->group
->used_crtcs
)
272 rcar_du_group_restart(rcrtc
->group
);
275 /* Restart the group if plane sources have changed. */
276 if (rcrtc
->group
->need_restart
)
277 rcar_du_group_restart(rcrtc
->group
);
279 mutex_unlock(&rcrtc
->group
->lock
);
281 rcar_du_group_write(rcrtc
->group
, rcrtc
->index
% 2 ? DS2PR
: DS1PR
,
285 /* -----------------------------------------------------------------------------
289 static void rcar_du_crtc_finish_page_flip(struct rcar_du_crtc
*rcrtc
)
291 struct drm_pending_vblank_event
*event
;
292 struct drm_device
*dev
= rcrtc
->crtc
.dev
;
295 spin_lock_irqsave(&dev
->event_lock
, flags
);
296 event
= rcrtc
->event
;
298 spin_unlock_irqrestore(&dev
->event_lock
, flags
);
303 spin_lock_irqsave(&dev
->event_lock
, flags
);
304 drm_send_vblank_event(dev
, rcrtc
->index
, event
);
305 wake_up(&rcrtc
->flip_wait
);
306 spin_unlock_irqrestore(&dev
->event_lock
, flags
);
308 drm_crtc_vblank_put(&rcrtc
->crtc
);
311 static bool rcar_du_crtc_page_flip_pending(struct rcar_du_crtc
*rcrtc
)
313 struct drm_device
*dev
= rcrtc
->crtc
.dev
;
317 spin_lock_irqsave(&dev
->event_lock
, flags
);
318 pending
= rcrtc
->event
!= NULL
;
319 spin_unlock_irqrestore(&dev
->event_lock
, flags
);
324 static void rcar_du_crtc_wait_page_flip(struct rcar_du_crtc
*rcrtc
)
326 struct rcar_du_device
*rcdu
= rcrtc
->group
->dev
;
328 if (wait_event_timeout(rcrtc
->flip_wait
,
329 !rcar_du_crtc_page_flip_pending(rcrtc
),
330 msecs_to_jiffies(50)))
333 dev_warn(rcdu
->dev
, "page flip timeout\n");
335 rcar_du_crtc_finish_page_flip(rcrtc
);
338 /* -----------------------------------------------------------------------------
339 * Start/Stop and Suspend/Resume
342 static void rcar_du_crtc_start(struct rcar_du_crtc
*rcrtc
)
344 struct drm_crtc
*crtc
= &rcrtc
->crtc
;
350 /* Set display off and background to black */
351 rcar_du_crtc_write(rcrtc
, DOOR
, DOOR_RGB(0, 0, 0));
352 rcar_du_crtc_write(rcrtc
, BPOR
, BPOR_RGB(0, 0, 0));
354 /* Configure display timings and output routing */
355 rcar_du_crtc_set_display_timing(rcrtc
);
356 rcar_du_group_set_routing(rcrtc
->group
);
358 /* Start with all planes disabled. */
359 rcar_du_group_write(rcrtc
->group
, rcrtc
->index
% 2 ? DS2PR
: DS1PR
, 0);
361 /* Select master sync mode. This enables display operation in master
362 * sync mode (with the HSYNC and VSYNC signals configured as outputs and
365 interlaced
= rcrtc
->crtc
.mode
.flags
& DRM_MODE_FLAG_INTERLACE
;
366 rcar_du_crtc_clr_set(rcrtc
, DSYSR
, DSYSR_TVM_MASK
| DSYSR_SCM_MASK
,
367 (interlaced
? DSYSR_SCM_INT_VIDEO
: 0) |
370 rcar_du_group_start_stop(rcrtc
->group
, true);
372 /* Turn vertical blanking interrupt reporting back on. */
373 drm_crtc_vblank_on(crtc
);
375 rcrtc
->started
= true;
378 static void rcar_du_crtc_stop(struct rcar_du_crtc
*rcrtc
)
380 struct drm_crtc
*crtc
= &rcrtc
->crtc
;
385 /* Disable all planes and wait for the change to take effect. This is
386 * required as the DSnPR registers are updated on vblank, and no vblank
387 * will occur once the CRTC is stopped. Disabling planes when starting
388 * the CRTC thus wouldn't be enough as it would start scanning out
389 * immediately from old frame buffers until the next vblank.
391 * This increases the CRTC stop delay, especially when multiple CRTCs
392 * are stopped in one operation as we now wait for one vblank per CRTC.
393 * Whether this can be improved needs to be researched.
395 rcar_du_group_write(rcrtc
->group
, rcrtc
->index
% 2 ? DS2PR
: DS1PR
, 0);
396 drm_crtc_wait_one_vblank(crtc
);
398 /* Disable vertical blanking interrupt reporting. We first need to wait
399 * for page flip completion before stopping the CRTC as userspace
400 * expects page flips to eventually complete.
402 rcar_du_crtc_wait_page_flip(rcrtc
);
403 drm_crtc_vblank_off(crtc
);
405 /* Select switch sync mode. This stops display operation and configures
406 * the HSYNC and VSYNC signals as inputs.
408 rcar_du_crtc_clr_set(rcrtc
, DSYSR
, DSYSR_TVM_MASK
, DSYSR_TVM_SWITCH
);
410 rcar_du_group_start_stop(rcrtc
->group
, false);
412 rcrtc
->started
= false;
415 void rcar_du_crtc_suspend(struct rcar_du_crtc
*rcrtc
)
417 rcar_du_crtc_stop(rcrtc
);
418 rcar_du_crtc_put(rcrtc
);
421 void rcar_du_crtc_resume(struct rcar_du_crtc
*rcrtc
)
425 if (!rcrtc
->crtc
.state
->active
)
428 rcar_du_crtc_get(rcrtc
);
429 rcar_du_crtc_start(rcrtc
);
431 /* Commit the planes state. */
432 for (i
= 0; i
< rcrtc
->group
->num_planes
; ++i
) {
433 struct rcar_du_plane
*plane
= &rcrtc
->group
->planes
[i
];
435 if (plane
->plane
.state
->crtc
!= &rcrtc
->crtc
)
438 rcar_du_plane_setup(plane
);
441 rcar_du_crtc_update_planes(rcrtc
);
444 /* -----------------------------------------------------------------------------
448 static void rcar_du_crtc_enable(struct drm_crtc
*crtc
)
450 struct rcar_du_crtc
*rcrtc
= to_rcar_crtc(crtc
);
452 rcar_du_crtc_get(rcrtc
);
453 rcar_du_crtc_start(rcrtc
);
456 static void rcar_du_crtc_disable(struct drm_crtc
*crtc
)
458 struct rcar_du_crtc
*rcrtc
= to_rcar_crtc(crtc
);
460 rcar_du_crtc_stop(rcrtc
);
461 rcar_du_crtc_put(rcrtc
);
466 static bool rcar_du_crtc_mode_fixup(struct drm_crtc
*crtc
,
467 const struct drm_display_mode
*mode
,
468 struct drm_display_mode
*adjusted_mode
)
470 /* TODO Fixup modes */
474 static void rcar_du_crtc_atomic_begin(struct drm_crtc
*crtc
,
475 struct drm_crtc_state
*old_crtc_state
)
477 struct drm_pending_vblank_event
*event
= crtc
->state
->event
;
478 struct rcar_du_crtc
*rcrtc
= to_rcar_crtc(crtc
);
479 struct drm_device
*dev
= rcrtc
->crtc
.dev
;
483 WARN_ON(drm_crtc_vblank_get(crtc
) != 0);
485 spin_lock_irqsave(&dev
->event_lock
, flags
);
486 rcrtc
->event
= event
;
487 spin_unlock_irqrestore(&dev
->event_lock
, flags
);
491 static void rcar_du_crtc_atomic_flush(struct drm_crtc
*crtc
,
492 struct drm_crtc_state
*old_crtc_state
)
494 struct rcar_du_crtc
*rcrtc
= to_rcar_crtc(crtc
);
496 rcar_du_crtc_update_planes(rcrtc
);
499 static const struct drm_crtc_helper_funcs crtc_helper_funcs
= {
500 .mode_fixup
= rcar_du_crtc_mode_fixup
,
501 .disable
= rcar_du_crtc_disable
,
502 .enable
= rcar_du_crtc_enable
,
503 .atomic_begin
= rcar_du_crtc_atomic_begin
,
504 .atomic_flush
= rcar_du_crtc_atomic_flush
,
507 static const struct drm_crtc_funcs crtc_funcs
= {
508 .reset
= drm_atomic_helper_crtc_reset
,
509 .destroy
= drm_crtc_cleanup
,
510 .set_config
= drm_atomic_helper_set_config
,
511 .page_flip
= drm_atomic_helper_page_flip
,
512 .atomic_duplicate_state
= drm_atomic_helper_crtc_duplicate_state
,
513 .atomic_destroy_state
= drm_atomic_helper_crtc_destroy_state
,
516 /* -----------------------------------------------------------------------------
520 static irqreturn_t
rcar_du_crtc_irq(int irq
, void *arg
)
522 struct rcar_du_crtc
*rcrtc
= arg
;
523 irqreturn_t ret
= IRQ_NONE
;
526 status
= rcar_du_crtc_read(rcrtc
, DSSR
);
527 rcar_du_crtc_write(rcrtc
, DSRCR
, status
& DSRCR_MASK
);
529 if (status
& DSSR_FRM
) {
530 drm_handle_vblank(rcrtc
->crtc
.dev
, rcrtc
->index
);
531 rcar_du_crtc_finish_page_flip(rcrtc
);
538 /* -----------------------------------------------------------------------------
542 int rcar_du_crtc_create(struct rcar_du_group
*rgrp
, unsigned int index
)
544 static const unsigned int mmio_offsets
[] = {
545 DU0_REG_OFFSET
, DU1_REG_OFFSET
, DU2_REG_OFFSET
548 struct rcar_du_device
*rcdu
= rgrp
->dev
;
549 struct platform_device
*pdev
= to_platform_device(rcdu
->dev
);
550 struct rcar_du_crtc
*rcrtc
= &rcdu
->crtcs
[index
];
551 struct drm_crtc
*crtc
= &rcrtc
->crtc
;
552 unsigned int irqflags
;
559 /* Get the CRTC clock and the optional external clock. */
560 if (rcar_du_has(rcdu
, RCAR_DU_FEATURE_CRTC_IRQ_CLOCK
)) {
561 sprintf(clk_name
, "du.%u", index
);
567 rcrtc
->clock
= devm_clk_get(rcdu
->dev
, name
);
568 if (IS_ERR(rcrtc
->clock
)) {
569 dev_err(rcdu
->dev
, "no clock for CRTC %u\n", index
);
570 return PTR_ERR(rcrtc
->clock
);
573 sprintf(clk_name
, "dclkin.%u", index
);
574 clk
= devm_clk_get(rcdu
->dev
, clk_name
);
576 rcrtc
->extclock
= clk
;
577 } else if (PTR_ERR(rcrtc
->clock
) == -EPROBE_DEFER
) {
578 dev_info(rcdu
->dev
, "can't get external clock %u\n", index
);
579 return -EPROBE_DEFER
;
582 init_waitqueue_head(&rcrtc
->flip_wait
);
585 rcrtc
->mmio_offset
= mmio_offsets
[index
];
586 rcrtc
->index
= index
;
588 ret
= drm_crtc_init_with_planes(rcdu
->ddev
, crtc
,
589 &rgrp
->planes
[index
% 2].plane
,
590 NULL
, &crtc_funcs
, NULL
);
594 drm_crtc_helper_add(crtc
, &crtc_helper_funcs
);
596 /* Start with vertical blanking interrupt reporting disabled. */
597 drm_crtc_vblank_off(crtc
);
599 /* Register the interrupt handler. */
600 if (rcar_du_has(rcdu
, RCAR_DU_FEATURE_CRTC_IRQ_CLOCK
)) {
601 irq
= platform_get_irq(pdev
, index
);
604 irq
= platform_get_irq(pdev
, 0);
605 irqflags
= IRQF_SHARED
;
609 dev_err(rcdu
->dev
, "no IRQ for CRTC %u\n", index
);
613 ret
= devm_request_irq(rcdu
->dev
, irq
, rcar_du_crtc_irq
, irqflags
,
614 dev_name(rcdu
->dev
), rcrtc
);
617 "failed to register IRQ for CRTC %u\n", index
);
624 void rcar_du_crtc_enable_vblank(struct rcar_du_crtc
*rcrtc
, bool enable
)
627 rcar_du_crtc_write(rcrtc
, DSRCR
, DSRCR_VBCL
);
628 rcar_du_crtc_set(rcrtc
, DIER
, DIER_VBE
);
630 rcar_du_crtc_clr(rcrtc
, DIER
, DIER_VBE
);