rcar_du_crtc.c 20.1 KB
Newer Older
1 2 3
/*
 * rcar_du_crtc.c  --  R-Car Display Unit CRTCs
 *
4
 * Copyright (C) 2013-2015 Renesas Electronics Corporation
5 6 7 8 9 10 11 12 13 14 15 16 17
 *
 * Contact: Laurent Pinchart (laurent.pinchart@ideasonboard.com)
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 */

#include <linux/clk.h>
#include <linux/mutex.h>

#include <drm/drmP.h>
18 19
#include <drm/drm_atomic.h>
#include <drm/drm_atomic_helper.h>
20 21 22 23
#include <drm/drm_crtc.h>
#include <drm/drm_crtc_helper.h>
#include <drm/drm_fb_cma_helper.h>
#include <drm/drm_gem_cma_helper.h>
24
#include <drm/drm_plane_helper.h>
25 26 27 28 29 30

#include "rcar_du_crtc.h"
#include "rcar_du_drv.h"
#include "rcar_du_kms.h"
#include "rcar_du_plane.h"
#include "rcar_du_regs.h"
31
#include "rcar_du_vsp.h"
32 33 34

static u32 rcar_du_crtc_read(struct rcar_du_crtc *rcrtc, u32 reg)
{
35
	struct rcar_du_device *rcdu = rcrtc->group->dev;
36 37 38 39 40 41

	return rcar_du_read(rcdu, rcrtc->mmio_offset + reg);
}

static void rcar_du_crtc_write(struct rcar_du_crtc *rcrtc, u32 reg, u32 data)
{
42
	struct rcar_du_device *rcdu = rcrtc->group->dev;
43 44 45 46 47 48

	rcar_du_write(rcdu, rcrtc->mmio_offset + reg, data);
}

static void rcar_du_crtc_clr(struct rcar_du_crtc *rcrtc, u32 reg, u32 clr)
{
49
	struct rcar_du_device *rcdu = rcrtc->group->dev;
50 51 52 53 54 55 56

	rcar_du_write(rcdu, rcrtc->mmio_offset + reg,
		      rcar_du_read(rcdu, rcrtc->mmio_offset + reg) & ~clr);
}

static void rcar_du_crtc_set(struct rcar_du_crtc *rcrtc, u32 reg, u32 set)
{
57
	struct rcar_du_device *rcdu = rcrtc->group->dev;
58 59 60 61 62 63 64 65

	rcar_du_write(rcdu, rcrtc->mmio_offset + reg,
		      rcar_du_read(rcdu, rcrtc->mmio_offset + reg) | set);
}

static void rcar_du_crtc_clr_set(struct rcar_du_crtc *rcrtc, u32 reg,
				 u32 clr, u32 set)
{
66
	struct rcar_du_device *rcdu = rcrtc->group->dev;
67 68 69 70 71
	u32 value = rcar_du_read(rcdu, rcrtc->mmio_offset + reg);

	rcar_du_write(rcdu, rcrtc->mmio_offset + reg, (value & ~clr) | set);
}

72 73 74 75 76 77 78 79
static int rcar_du_crtc_get(struct rcar_du_crtc *rcrtc)
{
	int ret;

	ret = clk_prepare_enable(rcrtc->clock);
	if (ret < 0)
		return ret;

80 81 82 83
	ret = clk_prepare_enable(rcrtc->extclock);
	if (ret < 0)
		goto error_clock;

84
	ret = rcar_du_group_get(rcrtc->group);
85
	if (ret < 0)
86 87 88
		goto error_group;

	return 0;
89

90 91 92 93
error_group:
	clk_disable_unprepare(rcrtc->extclock);
error_clock:
	clk_disable_unprepare(rcrtc->clock);
94 95 96 97 98
	return ret;
}

static void rcar_du_crtc_put(struct rcar_du_crtc *rcrtc)
{
99
	rcar_du_group_put(rcrtc->group);
100 101

	clk_disable_unprepare(rcrtc->extclock);
102 103 104
	clk_disable_unprepare(rcrtc->clock);
}

105 106 107 108
/* -----------------------------------------------------------------------------
 * Hardware Setup
 */

Koji Matsuoka's avatar
Koji Matsuoka committed
109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160
struct dpll_info {
	unsigned int output;
	unsigned int fdpll;
	unsigned int n;
	unsigned int m;
};

static void rcar_du_dpll_divider(struct rcar_du_crtc *rcrtc,
				 struct dpll_info *dpll,
				 unsigned long input,
				 unsigned long target)
{
	unsigned long best_diff = (unsigned long)-1;
	unsigned long diff;
	unsigned int fdpll;
	unsigned int m;
	unsigned int n;

	for (n = 39; n < 120; n++) {
		for (m = 0; m < 4; m++) {
			for (fdpll = 1; fdpll < 32; fdpll++) {
				unsigned long output;

				/* 1/2 (FRQSEL=1) for duty rate 50% */
				output = input * (n + 1) / (m + 1)
				       / (fdpll + 1) / 2;

				if (output >= 400000000)
					continue;

				diff = abs((long)output - (long)target);
				if (best_diff > diff) {
					best_diff = diff;
					dpll->n = n;
					dpll->m = m;
					dpll->fdpll = fdpll;
					dpll->output = output;
				}

				if (diff == 0)
					goto done;
			}
		}
	}

done:
	dev_dbg(rcrtc->group->dev->dev,
		"output:%u, fdpll:%u, n:%u, m:%u, diff:%lu\n",
		 dpll->output, dpll->fdpll, dpll->n, dpll->m,
		 best_diff);
}

161 162
static void rcar_du_crtc_set_display_timing(struct rcar_du_crtc *rcrtc)
{
163
	const struct drm_display_mode *mode = &rcrtc->crtc.state->adjusted_mode;
Koji Matsuoka's avatar
Koji Matsuoka committed
164
	struct rcar_du_device *rcdu = rcrtc->group->dev;
165
	unsigned long mode_clock = mode->clock * 1000;
166 167
	unsigned long clk;
	u32 value;
168
	u32 escr;
169 170
	u32 div;

171 172
	/*
	 * Compute the clock divisor and select the internal or external dot
173 174
	 * clock based on the requested frequency.
	 */
175
	clk = clk_get_rate(rcrtc->clock);
176
	div = DIV_ROUND_CLOSEST(clk, mode_clock);
177
	div = clamp(div, 1U, 64U) - 1;
178 179 180
	escr = div | ESCR_DCLKSEL_CLKS;

	if (rcrtc->extclock) {
Koji Matsuoka's avatar
Koji Matsuoka committed
181
		struct dpll_info dpll = { 0 };
182 183 184 185 186 187
		unsigned long extclk;
		unsigned long extrate;
		unsigned long rate;
		u32 extdiv;

		extclk = clk_get_rate(rcrtc->extclock);
Koji Matsuoka's avatar
Koji Matsuoka committed
188 189 190 191 192
		if (rcdu->info->dpll_ch & (1 << rcrtc->index)) {
			rcar_du_dpll_divider(rcrtc, &dpll, extclk, mode_clock);
			extclk = dpll.output;
		}

193 194 195 196 197 198 199 200 201 202
		extdiv = DIV_ROUND_CLOSEST(extclk, mode_clock);
		extdiv = clamp(extdiv, 1U, 64U) - 1;

		rate = clk / (div + 1);
		extrate = extclk / (extdiv + 1);

		if (abs((long)extrate - (long)mode_clock) <
		    abs((long)rate - (long)mode_clock)) {
			dev_dbg(rcrtc->group->dev->dev,
				"crtc%u: using external clock\n", rcrtc->index);
Koji Matsuoka's avatar
Koji Matsuoka committed
203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223

			if (rcdu->info->dpll_ch & (1 << rcrtc->index)) {
				u32 dpllcr = DPLLCR_CODE | DPLLCR_CLKE
					   | DPLLCR_FDPLL(dpll.fdpll)
					   | DPLLCR_N(dpll.n) | DPLLCR_M(dpll.m)
					   | DPLLCR_STBY;

				if (rcrtc->index == 1)
					dpllcr |= DPLLCR_PLCS1
					       |  DPLLCR_INCS_DOTCLKIN1;
				else
					dpllcr |= DPLLCR_PLCS0
					       |  DPLLCR_INCS_DOTCLKIN0;

				rcar_du_group_write(rcrtc->group, DPLLCR,
						    dpllcr);

				escr = ESCR_DCLKSEL_DCLKIN | 1;
			} else {
				escr = ESCR_DCLKSEL_DCLKIN | extdiv;
			}
224 225
		}
	}
226

227
	rcar_du_group_write(rcrtc->group, rcrtc->index % 2 ? ESCR2 : ESCR,
228
			    escr);
229
	rcar_du_group_write(rcrtc->group, rcrtc->index % 2 ? OTAR2 : OTAR, 0);
230 231

	/* Signal polarities */
232 233
	value = ((mode->flags & DRM_MODE_FLAG_PVSYNC) ? DSMR_VSL : 0)
	      | ((mode->flags & DRM_MODE_FLAG_PHSYNC) ? DSMR_HSL : 0)
234
	      | DSMR_DIPM_DISP | DSMR_CSPM;
235 236 237 238 239 240 241 242 243 244
	rcar_du_crtc_write(rcrtc, DSMR, value);

	/* Display timings */
	rcar_du_crtc_write(rcrtc, HDSR, mode->htotal - mode->hsync_start - 19);
	rcar_du_crtc_write(rcrtc, HDER, mode->htotal - mode->hsync_start +
					mode->hdisplay - 19);
	rcar_du_crtc_write(rcrtc, HSWR, mode->hsync_end -
					mode->hsync_start - 1);
	rcar_du_crtc_write(rcrtc, HCR,  mode->htotal - 1);

245 246 247 248 249 250 251 252 253
	rcar_du_crtc_write(rcrtc, VDSR, mode->crtc_vtotal -
					mode->crtc_vsync_end - 2);
	rcar_du_crtc_write(rcrtc, VDER, mode->crtc_vtotal -
					mode->crtc_vsync_end +
					mode->crtc_vdisplay - 2);
	rcar_du_crtc_write(rcrtc, VSPR, mode->crtc_vtotal -
					mode->crtc_vsync_end +
					mode->crtc_vsync_start - 1);
	rcar_du_crtc_write(rcrtc, VCR,  mode->crtc_vtotal - 1);
254

255
	rcar_du_crtc_write(rcrtc, DESR,  mode->htotal - mode->hsync_start - 1);
256 257 258
	rcar_du_crtc_write(rcrtc, DEWR,  mode->hdisplay);
}

259 260
void rcar_du_crtc_route_output(struct drm_crtc *crtc,
			       enum rcar_du_output output)
261 262
{
	struct rcar_du_crtc *rcrtc = to_rcar_crtc(crtc);
263
	struct rcar_du_device *rcdu = rcrtc->group->dev;
264

265 266
	/*
	 * Store the route from the CRTC output to the DU output. The DU will be
267 268
	 * configured when starting the CRTC.
	 */
269
	rcrtc->outputs |= BIT(output);
270

271 272
	/*
	 * Store RGB routing to DPAD0, the hardware will be configured when
273 274 275
	 * starting the CRTC.
	 */
	if (output == RCAR_DU_OUTPUT_DPAD0)
276
		rcdu->dpad0_source = rcrtc->index;
277 278
}

279 280
static unsigned int plane_zpos(struct rcar_du_plane *plane)
{
281
	return plane->plane.state->normalized_zpos;
282 283
}

284 285 286
static const struct rcar_du_format_info *
plane_format(struct rcar_du_plane *plane)
{
287
	return to_rcar_plane_state(plane->plane.state)->format;
288 289
}

290
static void rcar_du_crtc_update_planes(struct rcar_du_crtc *rcrtc)
291 292
{
	struct rcar_du_plane *planes[RCAR_DU_NUM_HW_PLANES];
293
	struct rcar_du_device *rcdu = rcrtc->group->dev;
294
	unsigned int num_planes = 0;
295 296
	unsigned int dptsr_planes;
	unsigned int hwplanes = 0;
297 298 299 300
	unsigned int prio = 0;
	unsigned int i;
	u32 dspr = 0;

301
	for (i = 0; i < rcrtc->group->num_planes; ++i) {
302
		struct rcar_du_plane *plane = &rcrtc->group->planes[i];
303 304
		unsigned int j;

305
		if (plane->plane.state->crtc != &rcrtc->crtc)
306 307 308 309
			continue;

		/* Insert the plane in the sorted planes array. */
		for (j = num_planes++; j > 0; --j) {
310
			if (plane_zpos(planes[j-1]) <= plane_zpos(plane))
311 312 313 314 315
				break;
			planes[j] = planes[j-1];
		}

		planes[j] = plane;
316
		prio += plane_format(plane)->planes * 4;
317 318 319 320
	}

	for (i = 0; i < num_planes; ++i) {
		struct rcar_du_plane *plane = planes[i];
321
		struct drm_plane_state *state = plane->plane.state;
322
		unsigned int index = to_rcar_plane_state(state)->hwindex;
323 324 325

		prio -= 4;
		dspr |= (index + 1) << prio;
326
		hwplanes |= 1 << index;
327

328
		if (plane_format(plane)->planes == 2) {
329 330 331 332
			index = (index + 1) % 8;

			prio -= 4;
			dspr |= (index + 1) << prio;
333
			hwplanes |= 1 << index;
334 335 336
		}
	}

337 338
	/* If VSP+DU integration is enabled the plane assignment is fixed. */
	if (rcar_du_has(rcdu, RCAR_DU_FEATURE_VSP1_SOURCE)) {
339 340 341 342 343 344 345
		if (rcdu->info->gen < 3) {
			dspr = (rcrtc->index % 2) + 1;
			hwplanes = 1 << (rcrtc->index % 2);
		} else {
			dspr = (rcrtc->index % 2) ? 3 : 1;
			hwplanes = 1 << ((rcrtc->index % 2) ? 2 : 0);
		}
346 347
	}

348 349
	/*
	 * Update the planes to display timing and dot clock generator
350 351 352 353 354 355
	 * associations.
	 *
	 * Updating the DPTSR register requires restarting the CRTC group,
	 * resulting in visible flicker. To mitigate the issue only update the
	 * association if needed by enabled planes. Planes being disabled will
	 * keep their current association.
356
	 */
357 358 359 360 361 362 363 364 365 366 367 368
	mutex_lock(&rcrtc->group->lock);

	dptsr_planes = rcrtc->index % 2 ? rcrtc->group->dptsr_planes | hwplanes
		     : rcrtc->group->dptsr_planes & ~hwplanes;

	if (dptsr_planes != rcrtc->group->dptsr_planes) {
		rcar_du_group_write(rcrtc->group, DPTSR,
				    (dptsr_planes << 16) | dptsr_planes);
		rcrtc->group->dptsr_planes = dptsr_planes;

		if (rcrtc->group->used_crtcs)
			rcar_du_group_restart(rcrtc->group);
369 370
	}

371 372 373 374
	/* Restart the group if plane sources have changed. */
	if (rcrtc->group->need_restart)
		rcar_du_group_restart(rcrtc->group);

375 376
	mutex_unlock(&rcrtc->group->lock);

377 378
	rcar_du_group_write(rcrtc->group, rcrtc->index % 2 ? DS2PR : DS1PR,
			    dspr);
379 380
}

381 382 383 384
/* -----------------------------------------------------------------------------
 * Page Flip
 */

385
void rcar_du_crtc_finish_page_flip(struct rcar_du_crtc *rcrtc)
386 387 388 389 390 391 392 393 394 395 396 397 398 399
{
	struct drm_pending_vblank_event *event;
	struct drm_device *dev = rcrtc->crtc.dev;
	unsigned long flags;

	spin_lock_irqsave(&dev->event_lock, flags);
	event = rcrtc->event;
	rcrtc->event = NULL;
	spin_unlock_irqrestore(&dev->event_lock, flags);

	if (event == NULL)
		return;

	spin_lock_irqsave(&dev->event_lock, flags);
400
	drm_crtc_send_vblank_event(&rcrtc->crtc, event);
401
	wake_up(&rcrtc->flip_wait);
402 403
	spin_unlock_irqrestore(&dev->event_lock, flags);

404
	drm_crtc_vblank_put(&rcrtc->crtc);
405 406
}

407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433
static bool rcar_du_crtc_page_flip_pending(struct rcar_du_crtc *rcrtc)
{
	struct drm_device *dev = rcrtc->crtc.dev;
	unsigned long flags;
	bool pending;

	spin_lock_irqsave(&dev->event_lock, flags);
	pending = rcrtc->event != NULL;
	spin_unlock_irqrestore(&dev->event_lock, flags);

	return pending;
}

static void rcar_du_crtc_wait_page_flip(struct rcar_du_crtc *rcrtc)
{
	struct rcar_du_device *rcdu = rcrtc->group->dev;

	if (wait_event_timeout(rcrtc->flip_wait,
			       !rcar_du_crtc_page_flip_pending(rcrtc),
			       msecs_to_jiffies(50)))
		return;

	dev_warn(rcdu->dev, "page flip timeout\n");

	rcar_du_crtc_finish_page_flip(rcrtc);
}

434 435 436 437
/* -----------------------------------------------------------------------------
 * Start/Stop and Suspend/Resume
 */

438 439 440
static void rcar_du_crtc_start(struct rcar_du_crtc *rcrtc)
{
	struct drm_crtc *crtc = &rcrtc->crtc;
441
	bool interlaced;
442 443 444 445 446 447 448 449 450 451

	if (rcrtc->started)
		return;

	/* Set display off and background to black */
	rcar_du_crtc_write(rcrtc, DOOR, DOOR_RGB(0, 0, 0));
	rcar_du_crtc_write(rcrtc, BPOR, BPOR_RGB(0, 0, 0));

	/* Configure display timings and output routing */
	rcar_du_crtc_set_display_timing(rcrtc);
452
	rcar_du_group_set_routing(rcrtc->group);
453

454 455
	/* Start with all planes disabled. */
	rcar_du_group_write(rcrtc->group, rcrtc->index % 2 ? DS2PR : DS1PR, 0);
456

457 458
	/*
	 * Select master sync mode. This enables display operation in master
459 460 461
	 * sync mode (with the HSYNC and VSYNC signals configured as outputs and
	 * actively driven).
	 */
462 463 464 465
	interlaced = rcrtc->crtc.mode.flags & DRM_MODE_FLAG_INTERLACE;
	rcar_du_crtc_clr_set(rcrtc, DSYSR, DSYSR_TVM_MASK | DSYSR_SCM_MASK,
			     (interlaced ? DSYSR_SCM_INT_VIDEO : 0) |
			     DSYSR_TVM_MASTER);
466

467
	rcar_du_group_start_stop(rcrtc->group, true);
468

469 470 471 472
	/* Enable the VSP compositor. */
	if (rcar_du_has(rcrtc->group->dev, RCAR_DU_FEATURE_VSP1_SOURCE))
		rcar_du_vsp_enable(rcrtc);

473 474 475
	/* Turn vertical blanking interrupt reporting back on. */
	drm_crtc_vblank_on(crtc);

476 477 478 479 480 481 482 483 484 485
	rcrtc->started = true;
}

static void rcar_du_crtc_stop(struct rcar_du_crtc *rcrtc)
{
	struct drm_crtc *crtc = &rcrtc->crtc;

	if (!rcrtc->started)
		return;

486 487
	/*
	 * Disable all planes and wait for the change to take effect. This is
488 489 490 491 492 493 494 495 496 497 498 499
	 * required as the DSnPR registers are updated on vblank, and no vblank
	 * will occur once the CRTC is stopped. Disabling planes when starting
	 * the CRTC thus wouldn't be enough as it would start scanning out
	 * immediately from old frame buffers until the next vblank.
	 *
	 * This increases the CRTC stop delay, especially when multiple CRTCs
	 * are stopped in one operation as we now wait for one vblank per CRTC.
	 * Whether this can be improved needs to be researched.
	 */
	rcar_du_group_write(rcrtc->group, rcrtc->index % 2 ? DS2PR : DS1PR, 0);
	drm_crtc_wait_one_vblank(crtc);

500 501
	/*
	 * Disable vertical blanking interrupt reporting. We first need to wait
502 503
	 * for page flip completion before stopping the CRTC as userspace
	 * expects page flips to eventually complete.
504 505
	 */
	rcar_du_crtc_wait_page_flip(rcrtc);
506
	drm_crtc_vblank_off(crtc);
507

508 509 510 511
	/* Disable the VSP compositor. */
	if (rcar_du_has(rcrtc->group->dev, RCAR_DU_FEATURE_VSP1_SOURCE))
		rcar_du_vsp_disable(rcrtc);

512 513
	/*
	 * Select switch sync mode. This stops display operation and configures
514 515 516 517
	 * the HSYNC and VSYNC signals as inputs.
	 */
	rcar_du_crtc_clr_set(rcrtc, DSYSR, DSYSR_TVM_MASK, DSYSR_TVM_SWITCH);

518
	rcar_du_group_start_stop(rcrtc->group, false);
519 520 521 522 523 524

	rcrtc->started = false;
}

void rcar_du_crtc_suspend(struct rcar_du_crtc *rcrtc)
{
525 526 527
	if (rcar_du_has(rcrtc->group->dev, RCAR_DU_FEATURE_VSP1_SOURCE))
		rcar_du_vsp_disable(rcrtc);

528
	rcar_du_crtc_stop(rcrtc);
529
	rcar_du_crtc_put(rcrtc);
530 531 532 533
}

void rcar_du_crtc_resume(struct rcar_du_crtc *rcrtc)
{
534 535
	unsigned int i;

536
	if (!rcrtc->crtc.state->active)
537 538
		return;

539
	rcar_du_crtc_get(rcrtc);
540
	rcar_du_crtc_start(rcrtc);
541 542

	/* Commit the planes state. */
543 544 545 546 547
	if (rcar_du_has(rcrtc->group->dev, RCAR_DU_FEATURE_VSP1_SOURCE)) {
		rcar_du_vsp_enable(rcrtc);
	} else {
		for (i = 0; i < rcrtc->group->num_planes; ++i) {
			struct rcar_du_plane *plane = &rcrtc->group->planes[i];
548

549 550
			if (plane->plane.state->crtc != &rcrtc->crtc)
				continue;
551

552 553
			rcar_du_plane_setup(plane);
		}
554 555 556
	}

	rcar_du_crtc_update_planes(rcrtc);
557 558
}

559 560 561 562
/* -----------------------------------------------------------------------------
 * CRTC Functions
 */

563 564
static void rcar_du_crtc_atomic_enable(struct drm_crtc *crtc,
				       struct drm_crtc_state *old_state)
565 566 567
{
	struct rcar_du_crtc *rcrtc = to_rcar_crtc(crtc);

568 569 570 571
	rcar_du_crtc_get(rcrtc);
	rcar_du_crtc_start(rcrtc);
}

572 573
static void rcar_du_crtc_atomic_disable(struct drm_crtc *crtc,
					struct drm_crtc_state *old_state)
574 575
{
	struct rcar_du_crtc *rcrtc = to_rcar_crtc(crtc);
576

577 578
	rcar_du_crtc_stop(rcrtc);
	rcar_du_crtc_put(rcrtc);
579

580 581 582 583 584 585 586
	spin_lock_irq(&crtc->dev->event_lock);
	if (crtc->state->event) {
		drm_crtc_send_vblank_event(crtc, crtc->state->event);
		crtc->state->event = NULL;
	}
	spin_unlock_irq(&crtc->dev->event_lock);

587
	rcrtc->outputs = 0;
588 589
}

590 591
static void rcar_du_crtc_atomic_begin(struct drm_crtc *crtc,
				      struct drm_crtc_state *old_crtc_state)
592 593
{
	struct rcar_du_crtc *rcrtc = to_rcar_crtc(crtc);
594 595 596

	if (rcar_du_has(rcrtc->group->dev, RCAR_DU_FEATURE_VSP1_SOURCE))
		rcar_du_vsp_atomic_begin(rcrtc);
597 598
}

599 600
static void rcar_du_crtc_atomic_flush(struct drm_crtc *crtc,
				      struct drm_crtc_state *old_crtc_state)
601 602
{
	struct rcar_du_crtc *rcrtc = to_rcar_crtc(crtc);
603 604
	struct drm_device *dev = rcrtc->crtc.dev;
	unsigned long flags;
605

606
	rcar_du_crtc_update_planes(rcrtc);
607

608 609 610 611 612 613 614 615 616
	if (crtc->state->event) {
		WARN_ON(drm_crtc_vblank_get(crtc) != 0);

		spin_lock_irqsave(&dev->event_lock, flags);
		rcrtc->event = crtc->state->event;
		crtc->state->event = NULL;
		spin_unlock_irqrestore(&dev->event_lock, flags);
	}

617 618
	if (rcar_du_has(rcrtc->group->dev, RCAR_DU_FEATURE_VSP1_SOURCE))
		rcar_du_vsp_atomic_flush(rcrtc);
619 620
}

621
static const struct drm_crtc_helper_funcs crtc_helper_funcs = {
622 623
	.atomic_begin = rcar_du_crtc_atomic_begin,
	.atomic_flush = rcar_du_crtc_atomic_flush,
624
	.atomic_enable = rcar_du_crtc_atomic_enable,
625
	.atomic_disable = rcar_du_crtc_atomic_disable,
626 627
};

628 629 630 631 632 633 634 635 636 637 638 639 640 641 642 643 644
static int rcar_du_crtc_enable_vblank(struct drm_crtc *crtc)
{
	struct rcar_du_crtc *rcrtc = to_rcar_crtc(crtc);

	rcar_du_crtc_write(rcrtc, DSRCR, DSRCR_VBCL);
	rcar_du_crtc_set(rcrtc, DIER, DIER_VBE);

	return 0;
}

static void rcar_du_crtc_disable_vblank(struct drm_crtc *crtc)
{
	struct rcar_du_crtc *rcrtc = to_rcar_crtc(crtc);

	rcar_du_crtc_clr(rcrtc, DIER, DIER_VBE);
}

645
static const struct drm_crtc_funcs crtc_funcs = {
646
	.reset = drm_atomic_helper_crtc_reset,
647
	.destroy = drm_crtc_cleanup,
648
	.set_config = drm_atomic_helper_set_config,
649
	.page_flip = drm_atomic_helper_page_flip,
650 651
	.atomic_duplicate_state = drm_atomic_helper_crtc_duplicate_state,
	.atomic_destroy_state = drm_atomic_helper_crtc_destroy_state,
652 653
	.enable_vblank = rcar_du_crtc_enable_vblank,
	.disable_vblank = rcar_du_crtc_disable_vblank,
654 655
};

656 657 658 659 660 661 662
/* -----------------------------------------------------------------------------
 * Interrupt Handling
 */

static irqreturn_t rcar_du_crtc_irq(int irq, void *arg)
{
	struct rcar_du_crtc *rcrtc = arg;
663
	struct rcar_du_device *rcdu = rcrtc->group->dev;
664 665 666 667 668 669 670
	irqreturn_t ret = IRQ_NONE;
	u32 status;

	status = rcar_du_crtc_read(rcrtc, DSSR);
	rcar_du_crtc_write(rcrtc, DSRCR, status & DSRCR_MASK);

	if (status & DSSR_FRM) {
671
		drm_crtc_handle_vblank(&rcrtc->crtc);
672 673 674 675

		if (rcdu->info->gen < 3)
			rcar_du_crtc_finish_page_flip(rcrtc);

676 677 678 679 680 681 682 683 684 685
		ret = IRQ_HANDLED;
	}

	return ret;
}

/* -----------------------------------------------------------------------------
 * Initialization
 */

686
int rcar_du_crtc_create(struct rcar_du_group *rgrp, unsigned int index)
687
{
688
	static const unsigned int mmio_offsets[] = {
689
		DU0_REG_OFFSET, DU1_REG_OFFSET, DU2_REG_OFFSET, DU3_REG_OFFSET
690 691
	};

692
	struct rcar_du_device *rcdu = rgrp->dev;
693
	struct platform_device *pdev = to_platform_device(rcdu->dev);
694 695
	struct rcar_du_crtc *rcrtc = &rcdu->crtcs[index];
	struct drm_crtc *crtc = &rcrtc->crtc;
696
	struct drm_plane *primary;
697
	unsigned int irqflags;
698 699
	struct clk *clk;
	char clk_name[9];
700 701
	char *name;
	int irq;
702 703
	int ret;

704
	/* Get the CRTC clock and the optional external clock. */
705 706 707 708 709 710 711 712 713 714 715 716 717
	if (rcar_du_has(rcdu, RCAR_DU_FEATURE_CRTC_IRQ_CLOCK)) {
		sprintf(clk_name, "du.%u", index);
		name = clk_name;
	} else {
		name = NULL;
	}

	rcrtc->clock = devm_clk_get(rcdu->dev, name);
	if (IS_ERR(rcrtc->clock)) {
		dev_err(rcdu->dev, "no clock for CRTC %u\n", index);
		return PTR_ERR(rcrtc->clock);
	}

718 719 720 721 722 723 724 725 726
	sprintf(clk_name, "dclkin.%u", index);
	clk = devm_clk_get(rcdu->dev, clk_name);
	if (!IS_ERR(clk)) {
		rcrtc->extclock = clk;
	} else if (PTR_ERR(rcrtc->clock) == -EPROBE_DEFER) {
		dev_info(rcdu->dev, "can't get external clock %u\n", index);
		return -EPROBE_DEFER;
	}

727 728
	init_waitqueue_head(&rcrtc->flip_wait);

729
	rcrtc->group = rgrp;
730
	rcrtc->mmio_offset = mmio_offsets[index];
731 732
	rcrtc->index = index;

733 734 735 736 737 738
	if (rcar_du_has(rcdu, RCAR_DU_FEATURE_VSP1_SOURCE))
		primary = &rcrtc->vsp->planes[0].plane;
	else
		primary = &rgrp->planes[index % 2].plane;

	ret = drm_crtc_init_with_planes(rcdu->ddev, crtc, primary,
739
					NULL, &crtc_funcs, NULL);
740 741 742 743 744
	if (ret < 0)
		return ret;

	drm_crtc_helper_add(crtc, &crtc_helper_funcs);

745 746 747
	/* Start with vertical blanking interrupt reporting disabled. */
	drm_crtc_vblank_off(crtc);

748 749 750 751 752 753 754 755 756 757 758
	/* Register the interrupt handler. */
	if (rcar_du_has(rcdu, RCAR_DU_FEATURE_CRTC_IRQ_CLOCK)) {
		irq = platform_get_irq(pdev, index);
		irqflags = 0;
	} else {
		irq = platform_get_irq(pdev, 0);
		irqflags = IRQF_SHARED;
	}

	if (irq < 0) {
		dev_err(rcdu->dev, "no IRQ for CRTC %u\n", index);
759
		return irq;
760 761 762 763 764 765 766 767 768 769
	}

	ret = devm_request_irq(rcdu->dev, irq, rcar_du_crtc_irq, irqflags,
			       dev_name(rcdu->dev), rcrtc);
	if (ret < 0) {
		dev_err(rcdu->dev,
			"failed to register IRQ for CRTC %u\n", index);
		return ret;
	}

770 771
	return 0;
}