Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit b43bd925 authored by Dave Airlie's avatar Dave Airlie
Browse files

Merge branch 'drm/next/du' of git://linuxtv.org/pinchartl/fbdev into drm-rcar-stable 



Create topic branch for rcar for shmobile tree to pull as well, arm-soc should
probably merge after drm merges if possible.

Signed-off-by: default avatarDave Airlie <airlied@redhat.com>
* 'drm/next/du' of git://linuxtv.org/pinchartl/fbdev: (23 commits)
  drm/rcar-du: Add FBDEV emulation support
  drm/rcar-du: Add internal LVDS encoder support
  drm/rcar-du: Configure RGB output routing to DPAD0
  drm/rcar-du: Rework output routing support
  drm/rcar-du: Add support for DEFR8 register
  drm/rcar-du: Add support for multiple groups
  drm/rcar-du: Fix buffer pitch alignment for R8A7790 DU
  drm/rcar-du: Add support for the R8A7790 DU
  drm/rcar-du: Move output routing configuration to group
  drm/rcar-du: Remove register definitions for the second channel
  drm/rcar-du: Use dynamic number of CRTCs instead of CRTCs array size
  drm/rcar-du: Introduce CRTCs groups
  drm/rcar-du: Rename rcar_du_plane_(init|register) to rcar_du_planes_*
  drm/rcar-du: Create rcar_du_planes structure
  drm/rcar-du: Rename platform data fields to match what they describe
  drm/rcar-du: Merge LVDS and VGA encoder code
  drm/rcar-du: Split VGA encoder and connector
  drm/rcar-du: Split LVDS encoder and connector
  drm/rcar-du: Clarify comment regarding plane Y source coordinate
  drm/rcar-du: Support per-CRTC clock and IRQ
  ...
parents 5ae90d8e 3864c6f4

drivers/gpu/drm/rcar-du/Kconfig

+7 −0
Original line number Diff line number Diff line
@@ -7,3 +7,10 @@ config DRM_RCAR_DU 
	help

	  Choose this option if you have an R-Car chipset.

	  If M is selected the module will be called rcar-du-drm.



config DRM_RCAR_LVDS

	bool "R-Car DU LVDS Encoder Support"

	depends on DRM_RCAR_DU

	help

	  Enable support the R-Car Display Unit embedded LVDS encoders

	  (currently only on R8A7790).

drivers/gpu/drm/rcar-du/Makefile

+7 −3
Original line number Diff line number Diff line 
rcar-du-drm-y := rcar_du_crtc.o \

		 rcar_du_drv.o \

		 rcar_du_encoder.o \

		 rcar_du_group.o \

		 rcar_du_kms.o \

		 rcar_du_lvds.o \

		 rcar_du_lvdscon.o \

		 rcar_du_plane.o \

		 rcar_du_vga.o

		 rcar_du_vgacon.o



rcar-du-drm-$(CONFIG_DRM_RCAR_LVDS)	+= rcar_du_lvdsenc.o



obj-$(CONFIG_DRM_RCAR_DU)		+= rcar-du-drm.o

drivers/gpu/drm/rcar-du/rcar_du_crtc.c

+135 −120
Original line number Diff line number Diff line
@@ -23,30 +23,26 @@ 
#include "rcar_du_crtc.h"

#include "rcar_du_drv.h"

#include "rcar_du_kms.h"

#include "rcar_du_lvds.h"

#include "rcar_du_plane.h"

#include "rcar_du_regs.h"

#include "rcar_du_vga.h"



#define to_rcar_crtc(c)	container_of(c, struct rcar_du_crtc, crtc)



static u32 rcar_du_crtc_read(struct rcar_du_crtc *rcrtc, u32 reg)

{

	struct rcar_du_device *rcdu = rcrtc->crtc.dev->dev_private;

	struct rcar_du_device *rcdu = rcrtc->group->dev;



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

}



static void rcar_du_crtc_write(struct rcar_du_crtc *rcrtc, u32 reg, u32 data)

{

	struct rcar_du_device *rcdu = rcrtc->crtc.dev->dev_private;

	struct rcar_du_device *rcdu = rcrtc->group->dev;



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

}



static void rcar_du_crtc_clr(struct rcar_du_crtc *rcrtc, u32 reg, u32 clr)

{

	struct rcar_du_device *rcdu = rcrtc->crtc.dev->dev_private;

	struct rcar_du_device *rcdu = rcrtc->group->dev;



	rcar_du_write(rcdu, rcrtc->mmio_offset + reg,

		      rcar_du_read(rcdu, rcrtc->mmio_offset + reg) & ~clr);
@@ -54,7 +50,7 @@ static void rcar_du_crtc_clr(struct rcar_du_crtc *rcrtc, u32 reg, u32 clr) 


static void rcar_du_crtc_set(struct rcar_du_crtc *rcrtc, u32 reg, u32 set)

{

	struct rcar_du_device *rcdu = rcrtc->crtc.dev->dev_private;

	struct rcar_du_device *rcdu = rcrtc->group->dev;



	rcar_du_write(rcdu, rcrtc->mmio_offset + reg,

		      rcar_du_read(rcdu, rcrtc->mmio_offset + reg) | set);
@@ -63,29 +59,48 @@ static void rcar_du_crtc_set(struct rcar_du_crtc *rcrtc, u32 reg, u32 set) 
static void rcar_du_crtc_clr_set(struct rcar_du_crtc *rcrtc, u32 reg,

				 u32 clr, u32 set)

{

	struct rcar_du_device *rcdu = rcrtc->crtc.dev->dev_private;

	struct rcar_du_device *rcdu = rcrtc->group->dev;

	u32 value = rcar_du_read(rcdu, rcrtc->mmio_offset + reg);



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

}



static int rcar_du_crtc_get(struct rcar_du_crtc *rcrtc)

{

	int ret;



	ret = clk_prepare_enable(rcrtc->clock);

	if (ret < 0)

		return ret;



	ret = rcar_du_group_get(rcrtc->group);

	if (ret < 0)

		clk_disable_unprepare(rcrtc->clock);



	return ret;

}



static void rcar_du_crtc_put(struct rcar_du_crtc *rcrtc)

{

	rcar_du_group_put(rcrtc->group);

	clk_disable_unprepare(rcrtc->clock);

}



static void rcar_du_crtc_set_display_timing(struct rcar_du_crtc *rcrtc)

{

	struct drm_crtc *crtc = &rcrtc->crtc;

	struct rcar_du_device *rcdu = crtc->dev->dev_private;

	const struct drm_display_mode *mode = &crtc->mode;

	const struct drm_display_mode *mode = &rcrtc->crtc.mode;

	unsigned long clk;

	u32 value;

	u32 div;



	/* Dot clock */

	clk = clk_get_rate(rcdu->clock);

	clk = clk_get_rate(rcrtc->clock);

	div = DIV_ROUND_CLOSEST(clk, mode->clock * 1000);

	div = clamp(div, 1U, 64U) - 1;



	rcar_du_write(rcdu, rcrtc->index ? ESCR2 : ESCR,

	rcar_du_group_write(rcrtc->group, rcrtc->index % 2 ? ESCR2 : ESCR,

			    ESCR_DCLKSEL_CLKS | div);

	rcar_du_write(rcdu, rcrtc->index ? OTAR2 : OTAR, 0);

	rcar_du_group_write(rcrtc->group, rcrtc->index % 2 ? OTAR2 : OTAR, 0);



	/* Signal polarities */

	value = ((mode->flags & DRM_MODE_FLAG_PVSYNC) ? 0 : DSMR_VSL)
@@ -112,68 +127,25 @@ static void rcar_du_crtc_set_display_timing(struct rcar_du_crtc *rcrtc) 
	rcar_du_crtc_write(rcrtc, DEWR,  mode->hdisplay);

}



static void rcar_du_crtc_set_routing(struct rcar_du_crtc *rcrtc)

{

	struct rcar_du_device *rcdu = rcrtc->crtc.dev->dev_private;

	u32 dorcr = rcar_du_read(rcdu, DORCR);



	dorcr &= ~(DORCR_PG2T | DORCR_DK2S | DORCR_PG2D_MASK);



	/* Set the DU1 pins sources. Select CRTC 0 if explicitly requested and

	 * CRTC 1 in all other cases to avoid cloning CRTC 0 to DU0 and DU1 by

	 * default.

	 */

	if (rcrtc->outputs & (1 << 1) && rcrtc->index == 0)

		dorcr |= DORCR_PG2D_DS1;

	else

		dorcr |= DORCR_PG2T | DORCR_DK2S | DORCR_PG2D_DS2;



	rcar_du_write(rcdu, DORCR, dorcr);

}



static void __rcar_du_start_stop(struct rcar_du_device *rcdu, bool start)

{

	rcar_du_write(rcdu, DSYSR,

		      (rcar_du_read(rcdu, DSYSR) & ~(DSYSR_DRES | DSYSR_DEN)) |

		      (start ? DSYSR_DEN : DSYSR_DRES));

}



static void rcar_du_start_stop(struct rcar_du_device *rcdu, bool start)

{

	/* Many of the configuration bits are only updated when the display

	 * reset (DRES) bit in DSYSR is set to 1, disabling *both* CRTCs. Some

	 * of those bits could be pre-configured, but others (especially the

	 * bits related to plane assignment to display timing controllers) need

	 * to be modified at runtime.

	 *

	 * Restart the display controller if a start is requested. Sorry for the

	 * flicker. It should be possible to move most of the "DRES-update" bits

	 * setup to driver initialization time and minimize the number of cases

	 * when the display controller will have to be restarted.

	 */

	if (start) {

		if (rcdu->used_crtcs++ != 0)

			__rcar_du_start_stop(rcdu, false);

		__rcar_du_start_stop(rcdu, true);

	} else {

		if (--rcdu->used_crtcs == 0)

			__rcar_du_start_stop(rcdu, false);

	}

}



void rcar_du_crtc_route_output(struct drm_crtc *crtc, unsigned int output)

void rcar_du_crtc_route_output(struct drm_crtc *crtc,

			       enum rcar_du_output output)

{

	struct rcar_du_crtc *rcrtc = to_rcar_crtc(crtc);

	struct rcar_du_device *rcdu = rcrtc->group->dev;



	/* Store the route from the CRTC output to the DU output. The DU will be

	 * configured when starting the CRTC.

	 */

	rcrtc->outputs |= 1 << output;

	rcrtc->outputs |= BIT(output);



	/* Store RGB routing to DPAD0 for R8A7790. */

	if (rcar_du_has(rcdu, RCAR_DU_FEATURE_DEFR8) &&

	    output == RCAR_DU_OUTPUT_DPAD0)

		rcdu->dpad0_source = rcrtc->index;

}



void rcar_du_crtc_update_planes(struct drm_crtc *crtc)

{

	struct rcar_du_device *rcdu = crtc->dev->dev_private;

	struct rcar_du_crtc *rcrtc = to_rcar_crtc(crtc);

	struct rcar_du_plane *planes[RCAR_DU_NUM_HW_PLANES];

	unsigned int num_planes = 0;
@@ -182,8 +154,8 @@ void rcar_du_crtc_update_planes(struct drm_crtc *crtc) 
	u32 dptsr = 0;

	u32 dspr = 0;



	for (i = 0; i < ARRAY_SIZE(rcdu->planes.planes); ++i) {

		struct rcar_du_plane *plane = &rcdu->planes.planes[i];

	for (i = 0; i < ARRAY_SIZE(rcrtc->group->planes.planes); ++i) {

		struct rcar_du_plane *plane = &rcrtc->group->planes.planes[i];

		unsigned int j;



		if (plane->crtc != &rcrtc->crtc || !plane->enabled)
@@ -220,8 +192,8 @@ void rcar_du_crtc_update_planes(struct drm_crtc *crtc) 
	/* Select display timing and dot clock generator 2 for planes associated

	 * with superposition controller 2.

	 */

	if (rcrtc->index) {

		u32 value = rcar_du_read(rcdu, DPTSR);

	if (rcrtc->index % 2) {

		u32 value = rcar_du_group_read(rcrtc->group, DPTSR);



		/* The DPTSR register is updated when the display controller is

		 * stopped. We thus need to restart the DU. Once again, sorry
@@ -231,21 +203,19 @@ void rcar_du_crtc_update_planes(struct drm_crtc *crtc) 
		 * occur only if we need to break the pre-association.

		 */

		if (value != dptsr) {

			rcar_du_write(rcdu, DPTSR, dptsr);

			if (rcdu->used_crtcs) {

				__rcar_du_start_stop(rcdu, false);

				__rcar_du_start_stop(rcdu, true);

			}

			rcar_du_group_write(rcrtc->group, DPTSR, dptsr);

			if (rcrtc->group->used_crtcs)

				rcar_du_group_restart(rcrtc->group);

		}

	}



	rcar_du_write(rcdu, rcrtc->index ? DS2PR : DS1PR, dspr);

	rcar_du_group_write(rcrtc->group, rcrtc->index % 2 ? DS2PR : DS1PR,

			    dspr);

}



static void rcar_du_crtc_start(struct rcar_du_crtc *rcrtc)

{

	struct drm_crtc *crtc = &rcrtc->crtc;

	struct rcar_du_device *rcdu = crtc->dev->dev_private;

	unsigned int i;



	if (rcrtc->started)
@@ -260,16 +230,16 @@ static void rcar_du_crtc_start(struct rcar_du_crtc *rcrtc) 


	/* Configure display timings and output routing */

	rcar_du_crtc_set_display_timing(rcrtc);

	rcar_du_crtc_set_routing(rcrtc);

	rcar_du_group_set_routing(rcrtc->group);



	mutex_lock(&rcdu->planes.lock);

	mutex_lock(&rcrtc->group->planes.lock);

	rcrtc->plane->enabled = true;

	rcar_du_crtc_update_planes(crtc);

	mutex_unlock(&rcdu->planes.lock);

	mutex_unlock(&rcrtc->group->planes.lock);



	/* Setup planes. */

	for (i = 0; i < ARRAY_SIZE(rcdu->planes.planes); ++i) {

		struct rcar_du_plane *plane = &rcdu->planes.planes[i];

	for (i = 0; i < ARRAY_SIZE(rcrtc->group->planes.planes); ++i) {

		struct rcar_du_plane *plane = &rcrtc->group->planes.planes[i];



		if (plane->crtc != crtc || !plane->enabled)

			continue;
@@ -283,7 +253,7 @@ static void rcar_du_crtc_start(struct rcar_du_crtc *rcrtc) 
	 */

	rcar_du_crtc_clr_set(rcrtc, DSYSR, DSYSR_TVM_MASK, DSYSR_TVM_MASTER);



	rcar_du_start_stop(rcdu, true);

	rcar_du_group_start_stop(rcrtc->group, true);



	rcrtc->started = true;

}
@@ -291,42 +261,37 @@ static void rcar_du_crtc_start(struct rcar_du_crtc *rcrtc) 
static void rcar_du_crtc_stop(struct rcar_du_crtc *rcrtc)

{

	struct drm_crtc *crtc = &rcrtc->crtc;

	struct rcar_du_device *rcdu = crtc->dev->dev_private;



	if (!rcrtc->started)

		return;



	mutex_lock(&rcdu->planes.lock);

	mutex_lock(&rcrtc->group->planes.lock);

	rcrtc->plane->enabled = false;

	rcar_du_crtc_update_planes(crtc);

	mutex_unlock(&rcdu->planes.lock);

	mutex_unlock(&rcrtc->group->planes.lock);



	/* Select switch sync mode. This stops display operation and configures

	 * the HSYNC and VSYNC signals as inputs.

	 */

	rcar_du_crtc_clr_set(rcrtc, DSYSR, DSYSR_TVM_MASK, DSYSR_TVM_SWITCH);



	rcar_du_start_stop(rcdu, false);

	rcar_du_group_start_stop(rcrtc->group, false);



	rcrtc->started = false;

}



void rcar_du_crtc_suspend(struct rcar_du_crtc *rcrtc)

{

	struct rcar_du_device *rcdu = rcrtc->crtc.dev->dev_private;



	rcar_du_crtc_stop(rcrtc);

	rcar_du_put(rcdu);

	rcar_du_crtc_put(rcrtc);

}



void rcar_du_crtc_resume(struct rcar_du_crtc *rcrtc)

{

	struct rcar_du_device *rcdu = rcrtc->crtc.dev->dev_private;



	if (rcrtc->dpms != DRM_MODE_DPMS_ON)

		return;



	rcar_du_get(rcdu);

	rcar_du_crtc_get(rcrtc);

	rcar_du_crtc_start(rcrtc);

}
@@ -340,18 +305,17 @@ static void rcar_du_crtc_update_base(struct rcar_du_crtc *rcrtc) 


static void rcar_du_crtc_dpms(struct drm_crtc *crtc, int mode)

{

	struct rcar_du_device *rcdu = crtc->dev->dev_private;

	struct rcar_du_crtc *rcrtc = to_rcar_crtc(crtc);



	if (rcrtc->dpms == mode)

		return;



	if (mode == DRM_MODE_DPMS_ON) {

		rcar_du_get(rcdu);

		rcar_du_crtc_get(rcrtc);

		rcar_du_crtc_start(rcrtc);

	} else {

		rcar_du_crtc_stop(rcrtc);

		rcar_du_put(rcdu);

		rcar_du_crtc_put(rcrtc);

	}



	rcrtc->dpms = mode;
@@ -367,13 +331,12 @@ static bool rcar_du_crtc_mode_fixup(struct drm_crtc *crtc, 


static void rcar_du_crtc_mode_prepare(struct drm_crtc *crtc)

{

	struct rcar_du_device *rcdu = crtc->dev->dev_private;

	struct rcar_du_crtc *rcrtc = to_rcar_crtc(crtc);



	/* We need to access the hardware during mode set, acquire a reference

	 * to the DU.

	 * to the CRTC.

	 */

	rcar_du_get(rcdu);

	rcar_du_crtc_get(rcrtc);



	/* Stop the CRTC and release the plane. Force the DPMS mode to off as a

	 * result.
@@ -390,8 +353,8 @@ static int rcar_du_crtc_mode_set(struct drm_crtc *crtc, 
				 int x, int y,

				 struct drm_framebuffer *old_fb)

{

	struct rcar_du_device *rcdu = crtc->dev->dev_private;

	struct rcar_du_crtc *rcrtc = to_rcar_crtc(crtc);

	struct rcar_du_device *rcdu = rcrtc->group->dev;

	const struct rcar_du_format_info *format;

	int ret;
@@ -423,10 +386,10 @@ static int rcar_du_crtc_mode_set(struct drm_crtc *crtc, 


error:

	/* There's no rollback/abort operation to clean up in case of error. We

	 * thus need to release the reference to the DU acquired in prepare()

	 * thus need to release the reference to the CRTC acquired in prepare()

	 * here.

	 */

	rcar_du_put(rcdu);

	rcar_du_crtc_put(rcrtc);

	return ret;

}
@@ -514,6 +477,24 @@ static void rcar_du_crtc_finish_page_flip(struct rcar_du_crtc *rcrtc) 
	drm_vblank_put(dev, rcrtc->index);

}



static irqreturn_t rcar_du_crtc_irq(int irq, void *arg)

{

	struct rcar_du_crtc *rcrtc = arg;

	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_VBK) {

		drm_handle_vblank(rcrtc->crtc.dev, rcrtc->index);

		rcar_du_crtc_finish_page_flip(rcrtc);

		ret = IRQ_HANDLED;

	}



	return ret;

}



static int rcar_du_crtc_page_flip(struct drm_crtc *crtc,

				  struct drm_framebuffer *fb,

				  struct drm_pending_vblank_event *event)
@@ -549,16 +530,41 @@ static const struct drm_crtc_funcs crtc_funcs = { 
	.page_flip = rcar_du_crtc_page_flip,

};



int rcar_du_crtc_create(struct rcar_du_device *rcdu, unsigned int index)

int rcar_du_crtc_create(struct rcar_du_group *rgrp, unsigned int index)

{

	static const unsigned int mmio_offsets[] = {

		DU0_REG_OFFSET, DU1_REG_OFFSET, DU2_REG_OFFSET

	};



	struct rcar_du_device *rcdu = rgrp->dev;

	struct platform_device *pdev = to_platform_device(rcdu->dev);

	struct rcar_du_crtc *rcrtc = &rcdu->crtcs[index];

	struct drm_crtc *crtc = &rcrtc->crtc;

	unsigned int irqflags;

	char clk_name[5];

	char *name;

	int irq;

	int ret;



	rcrtc->mmio_offset = index ? DISP2_REG_OFFSET : 0;

	/* Get the CRTC clock. */

	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);

	}



	rcrtc->group = rgrp;

	rcrtc->mmio_offset = mmio_offsets[index];

	rcrtc->index = index;

	rcrtc->dpms = DRM_MODE_DPMS_OFF;

	rcrtc->plane = &rcdu->planes.planes[index];

	rcrtc->plane = &rgrp->planes.planes[index % 2];



	rcrtc->plane->crtc = crtc;
@@ -568,6 +574,28 @@ int rcar_du_crtc_create(struct rcar_du_device *rcdu, unsigned int index) 


	drm_crtc_helper_add(crtc, &crtc_helper_funcs);



	/* 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);

		return ret;

	}



	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;

	}



	return 0;

}
@@ -580,16 +608,3 @@ void rcar_du_crtc_enable_vblank(struct rcar_du_crtc *rcrtc, bool enable) 
		rcar_du_crtc_clr(rcrtc, DIER, DIER_VBE);

	}

}
 


void rcar_du_crtc_irq(struct rcar_du_crtc *rcrtc)

{

	u32 status;



	status = rcar_du_crtc_read(rcrtc, DSSR);

	rcar_du_crtc_write(rcrtc, DSRCR, status & DSRCR_MASK);



	if (status & DSSR_VBK) {

		drm_handle_vblank(rcrtc->crtc.dev, rcrtc->index);

		rcar_du_crtc_finish_page_flip(rcrtc);

	}

}

drivers/gpu/drm/rcar-du/rcar_du_crtc.h

+9 −4
Original line number Diff line number Diff line
@@ -15,16 +15,18 @@ 
#define __RCAR_DU_CRTC_H__



#include <linux/mutex.h>

#include <linux/platform_data/rcar-du.h>



#include <drm/drmP.h>

#include <drm/drm_crtc.h>



struct rcar_du_device;

struct rcar_du_group;

struct rcar_du_plane;



struct rcar_du_crtc {

	struct drm_crtc crtc;



	struct clk *clock;

	unsigned int mmio_offset;

	unsigned int index;

	bool started;
@@ -33,18 +35,21 @@ struct rcar_du_crtc { 
	unsigned int outputs;

	int dpms;



	struct rcar_du_group *group;

	struct rcar_du_plane *plane;

};



int rcar_du_crtc_create(struct rcar_du_device *rcdu, unsigned int index);

#define to_rcar_crtc(c)	container_of(c, struct rcar_du_crtc, crtc)



int rcar_du_crtc_create(struct rcar_du_group *rgrp, unsigned int index);

void rcar_du_crtc_enable_vblank(struct rcar_du_crtc *rcrtc, bool enable);

void rcar_du_crtc_irq(struct rcar_du_crtc *rcrtc);

void rcar_du_crtc_cancel_page_flip(struct rcar_du_crtc *rcrtc,

				   struct drm_file *file);

void rcar_du_crtc_suspend(struct rcar_du_crtc *rcrtc);

void rcar_du_crtc_resume(struct rcar_du_crtc *rcrtc);



void rcar_du_crtc_route_output(struct drm_crtc *crtc, unsigned int output);

void rcar_du_crtc_route_output(struct drm_crtc *crtc,

			       enum rcar_du_output output);

void rcar_du_crtc_update_planes(struct drm_crtc *crtc);



#endif /* __RCAR_DU_CRTC_H__ */

drivers/gpu/drm/rcar-du/rcar_du_drv.c

+71 −102
Original line number Diff line number Diff line
@@ -21,6 +21,7 @@ 


#include <drm/drmP.h>

#include <drm/drm_crtc_helper.h>

#include <drm/drm_fb_cma_helper.h>

#include <drm/drm_gem_cma_helper.h>



#include "rcar_du_crtc.h"
@@ -28,75 +29,22 @@ 
#include "rcar_du_kms.h"

#include "rcar_du_regs.h"



/* -----------------------------------------------------------------------------

 * Core device operations

 */



/*

 * rcar_du_get - Acquire a reference to the DU

 *

 * Acquiring a reference enables the device clock and setup core registers. A

 * reference must be held before accessing any hardware registers.

 *

 * This function must be called with the DRM mode_config lock held.

 *

 * Return 0 in case of success or a negative error code otherwise.

 */

int rcar_du_get(struct rcar_du_device *rcdu)

{

	int ret;



	if (rcdu->use_count)

		goto done;



	/* Enable clocks before accessing the hardware. */

	ret = clk_prepare_enable(rcdu->clock);

	if (ret < 0)

		return ret;



	/* Enable extended features */

	rcar_du_write(rcdu, DEFR, DEFR_CODE | DEFR_DEFE);

	rcar_du_write(rcdu, DEFR2, DEFR2_CODE | DEFR2_DEFE2G);

	rcar_du_write(rcdu, DEFR3, DEFR3_CODE | DEFR3_DEFE3);

	rcar_du_write(rcdu, DEFR4, DEFR4_CODE);

	rcar_du_write(rcdu, DEFR5, DEFR5_CODE | DEFR5_DEFE5);



	/* Use DS1PR and DS2PR to configure planes priorities and connects the

	 * superposition 0 to DU0 pins. DU1 pins will be configured dynamically.

	 */

	rcar_du_write(rcdu, DORCR, DORCR_PG1D_DS1 | DORCR_DPRS);



done:

	rcdu->use_count++;

	return 0;

}



/*

 * rcar_du_put - Release a reference to the DU

 *

 * Releasing the last reference disables the device clock.

 *

 * This function must be called with the DRM mode_config lock held.

 */

void rcar_du_put(struct rcar_du_device *rcdu)

{

	if (--rcdu->use_count)

		return;



	clk_disable_unprepare(rcdu->clock);

}



/* -----------------------------------------------------------------------------

 * DRM operations

 */



static int rcar_du_unload(struct drm_device *dev)

{

	struct rcar_du_device *rcdu = dev->dev_private;



	if (rcdu->fbdev)

		drm_fbdev_cma_fini(rcdu->fbdev);



	drm_kms_helper_poll_fini(dev);

	drm_mode_config_cleanup(dev);

	drm_vblank_cleanup(dev);

	drm_irq_uninstall(dev);



	dev->irq_enabled = 0;

	dev->dev_private = NULL;



	return 0;
@@ -107,7 +55,6 @@ static int rcar_du_load(struct drm_device *dev, unsigned long flags) 
	struct platform_device *pdev = dev->platformdev;

	struct rcar_du_platform_data *pdata = pdev->dev.platform_data;

	struct rcar_du_device *rcdu;

	struct resource *ioarea;

	struct resource *mem;

	int ret;
@@ -124,35 +71,15 @@ static int rcar_du_load(struct drm_device *dev, unsigned long flags) 


	rcdu->dev = &pdev->dev;

	rcdu->pdata = pdata;

	rcdu->info = (struct rcar_du_device_info *)pdev->id_entry->driver_data;

	rcdu->ddev = dev;

	dev->dev_private = rcdu;



	/* I/O resources and clocks */

	/* I/O resources */

	mem = platform_get_resource(pdev, IORESOURCE_MEM, 0);

	if (mem == NULL) {

		dev_err(&pdev->dev, "failed to get memory resource\n");

		return -EINVAL;

	}



	ioarea = devm_request_mem_region(&pdev->dev, mem->start,

					 resource_size(mem), pdev->name);

	if (ioarea == NULL) {

		dev_err(&pdev->dev, "failed to request memory region\n");

		return -EBUSY;

	}



	rcdu->mmio = devm_ioremap_nocache(&pdev->dev, ioarea->start,

					  resource_size(ioarea));

	if (rcdu->mmio == NULL) {

		dev_err(&pdev->dev, "failed to remap memory resource\n");

		return -ENOMEM;

	}



	rcdu->clock = devm_clk_get(&pdev->dev, NULL);

	if (IS_ERR(rcdu->clock)) {

		dev_err(&pdev->dev, "failed to get clock\n");

		return -ENOENT;

	}

	rcdu->mmio = devm_ioremap_resource(&pdev->dev, mem);

	if (IS_ERR(rcdu->mmio))

		return PTR_ERR(rcdu->mmio);



	/* DRM/KMS objects */

	ret = rcar_du_modeset_init(rcdu);
@@ -161,18 +88,14 @@ static int rcar_du_load(struct drm_device *dev, unsigned long flags) 
		goto done;

	}



	/* IRQ and vblank handling */

	/* vblank handling */

	ret = drm_vblank_init(dev, (1 << rcdu->num_crtcs) - 1);

	if (ret < 0) {

		dev_err(&pdev->dev, "failed to initialize vblank\n");

		goto done;

	}



	ret = drm_irq_install(dev);

	if (ret < 0) {

		dev_err(&pdev->dev, "failed to install IRQ handler\n");

		goto done;

	}

	dev->irq_enabled = 1;



	platform_set_drvdata(pdev, rcdu);
@@ -188,20 +111,15 @@ static void rcar_du_preclose(struct drm_device *dev, struct drm_file *file) 
	struct rcar_du_device *rcdu = dev->dev_private;

	unsigned int i;



	for (i = 0; i < ARRAY_SIZE(rcdu->crtcs); ++i)

	for (i = 0; i < rcdu->num_crtcs; ++i)

		rcar_du_crtc_cancel_page_flip(&rcdu->crtcs[i], file);

}



static irqreturn_t rcar_du_irq(int irq, void *arg)

static void rcar_du_lastclose(struct drm_device *dev)

{

	struct drm_device *dev = arg;

	struct rcar_du_device *rcdu = dev->dev_private;

	unsigned int i;



	for (i = 0; i < ARRAY_SIZE(rcdu->crtcs); ++i)

		rcar_du_crtc_irq(&rcdu->crtcs[i]);



	return IRQ_HANDLED;

	drm_fbdev_cma_restore_mode(rcdu->fbdev);

}



static int rcar_du_enable_vblank(struct drm_device *dev, int crtc)
@@ -236,12 +154,11 @@ static const struct file_operations rcar_du_fops = { 
};



static struct drm_driver rcar_du_driver = {

	.driver_features	= DRIVER_HAVE_IRQ | DRIVER_GEM | DRIVER_MODESET

				| DRIVER_PRIME,

	.driver_features	= DRIVER_GEM | DRIVER_MODESET | DRIVER_PRIME,

	.load			= rcar_du_load,

	.unload			= rcar_du_unload,

	.preclose		= rcar_du_preclose,

	.irq_handler		= rcar_du_irq,

	.lastclose		= rcar_du_lastclose,

	.get_vblank_counter	= drm_vblank_count,

	.enable_vblank		= rcar_du_enable_vblank,

	.disable_vblank		= rcar_du_disable_vblank,
@@ -313,6 +230,57 @@ static int rcar_du_remove(struct platform_device *pdev) 
	return 0;

}



static const struct rcar_du_device_info rcar_du_r8a7779_info = {

	.features = 0,

	.num_crtcs = 2,

	.routes = {

		/* R8A7779 has two RGB outputs and one (currently unsupported)

		 * TCON output.

		 */

		[RCAR_DU_OUTPUT_DPAD0] = {

			.possible_crtcs = BIT(0),

			.encoder_type = DRM_MODE_ENCODER_NONE,

		},

		[RCAR_DU_OUTPUT_DPAD1] = {

			.possible_crtcs = BIT(1) | BIT(0),

			.encoder_type = DRM_MODE_ENCODER_NONE,

		},

	},

	.num_lvds = 0,

};



static const struct rcar_du_device_info rcar_du_r8a7790_info = {

	.features = RCAR_DU_FEATURE_CRTC_IRQ_CLOCK | RCAR_DU_FEATURE_ALIGN_128B

		  | RCAR_DU_FEATURE_DEFR8,

	.num_crtcs = 3,

	.routes = {

		/* R8A7790 has one RGB output, two LVDS outputs and one

		 * (currently unsupported) TCON output.

		 */

		[RCAR_DU_OUTPUT_DPAD0] = {

			.possible_crtcs = BIT(2) | BIT(1) | BIT(0),

			.encoder_type = DRM_MODE_ENCODER_NONE,

		},

		[RCAR_DU_OUTPUT_LVDS0] = {

			.possible_crtcs = BIT(0),

			.encoder_type = DRM_MODE_ENCODER_LVDS,

		},

		[RCAR_DU_OUTPUT_LVDS1] = {

			.possible_crtcs = BIT(2) | BIT(1),

			.encoder_type = DRM_MODE_ENCODER_LVDS,

		},

	},

	.num_lvds = 2,

};



static const struct platform_device_id rcar_du_id_table[] = {

	{ "rcar-du-r8a7779", (kernel_ulong_t)&rcar_du_r8a7779_info },

	{ "rcar-du-r8a7790", (kernel_ulong_t)&rcar_du_r8a7790_info },

	{ }

};



MODULE_DEVICE_TABLE(platform, rcar_du_id_table);



static struct platform_driver rcar_du_platform_driver = {

	.probe		= rcar_du_probe,

	.remove		= rcar_du_remove,
@@ -321,6 +289,7 @@ static struct platform_driver rcar_du_platform_driver = { 
		.name	= "rcar-du",

		.pm	= &rcar_du_pm_ops,

	},

	.id_table	= rcar_du_id_table,

};



module_platform_driver(rcar_du_platform_driver);