From mboxrd@z Thu Jan  1 00:00:00 1970
Return-Path: <linux-kernel-owner@vger.kernel.org>
Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand
	id S1753416AbcFOQSG (ORCPT <rfc822;w@1wt.eu>);
	Wed, 15 Jun 2016 12:18:06 -0400
Received: from foss.arm.com ([217.140.101.70]:38764 "EHLO foss.arm.com"
	rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP
	id S1753247AbcFOQSC (ORCPT <rfc822;linux-kernel@vger.kernel.org>);
	Wed, 15 Jun 2016 12:18:02 -0400
Date: Wed, 15 Jun 2016 17:17:58 +0100
From: Liviu Dudau <Liviu.Dudau@arm.com>
To: David Airlie <airlied@linux.ie>, Rob Herring <robh+dt@kernel.org>,
        Brian Starkey <brian.starkey@arm.com>,
        Emil Velikov <emil.l.velikov@gmail.com>,
        devicetree <devicetree@vger.kernel.org>,
        DRI devel <dri-devel@lists.freedesktop.org>,
        LKML <linux-kernel@vger.kernel.org>, David Brown <David.Brown@arm.com>,
        LAKML <linux-arm-kernel@lists.infradead.org>
Subject: Re: [PATCH v5 2/3] drm/arm: Add support for Mali Display Processors
Message-ID: <20160615161758.GF9711@e106497-lin.cambridge.arm.com>
References: <1466002295-24813-1-git-send-email-Liviu.Dudau@arm.com>
 <1466002295-24813-3-git-send-email-Liviu.Dudau@arm.com>
 <20160615152309.GI1338@phenom.ffwll.local>
MIME-Version: 1.0
Content-Type: text/plain; charset=utf-8
Content-Disposition: inline
Content-Transfer-Encoding: 8bit
In-Reply-To: <20160615152309.GI1338@phenom.ffwll.local>
User-Agent: Mutt/1.5.24 (2015-08-30)
Sender: linux-kernel-owner@vger.kernel.org
List-ID: <linux-kernel.vger.kernel.org>
X-Mailing-List: linux-kernel@vger.kernel.org

On Wed, Jun 15, 2016 at 05:23:10PM +0200, Daniel Vetter wrote:
> On Wed, Jun 15, 2016 at 03:51:34PM +0100, Liviu Dudau wrote:
> > Add support for the new family of Display Processors from ARM Ltd.
> > This commit adds basic support for Mali DP500, DP550 and DP650
> > parts, with only the display engine being supported at the moment.
> > 
> > Cc: David Brown <David.Brown@arm.com>
> > Cc: Brian Starkey <Brian.Starkey@arm.com>
> > 
> > Signed-off-by: Liviu Dudau <Liviu.Dudau@arm.com>
> 
> Small thing I noticed: drm_dev_register/connector_register_all should be
> the last step in your init code, and unregister the first. Atm it's
> somewhere in the middle. But perfectly fine to do that as a follow-up.

I've tried that, but the connector and encoder that gets registered as part
of the component_bind_all() fails if there is no drm dev registered. You did
comment on the v4 version about that and I did test your idea, sorry for
forgeting to update you on that.

> 
> Quickly scrolled through the driver, looks all nice.
> 
> Acked-by: Daniel Vetter <daniel.vetter@ffwll.ch>

And thanks for the Acked-by.

Best regards,
Liviu

> > ---
> >  drivers/gpu/drm/arm/Kconfig         |  16 +
> >  drivers/gpu/drm/arm/Makefile        |   2 +
> >  drivers/gpu/drm/arm/malidp_crtc.c   | 216 +++++++++++
> >  drivers/gpu/drm/arm/malidp_drv.c    | 512 ++++++++++++++++++++++++++
> >  drivers/gpu/drm/arm/malidp_drv.h    |  54 +++
> >  drivers/gpu/drm/arm/malidp_hw.c     | 691 ++++++++++++++++++++++++++++++++++++
> >  drivers/gpu/drm/arm/malidp_hw.h     | 241 +++++++++++++
> >  drivers/gpu/drm/arm/malidp_planes.c | 298 ++++++++++++++++
> >  drivers/gpu/drm/arm/malidp_regs.h   | 172 +++++++++
> >  9 files changed, 2202 insertions(+)
> >  create mode 100644 drivers/gpu/drm/arm/malidp_crtc.c
> >  create mode 100644 drivers/gpu/drm/arm/malidp_drv.c
> >  create mode 100644 drivers/gpu/drm/arm/malidp_drv.h
> >  create mode 100644 drivers/gpu/drm/arm/malidp_hw.c
> >  create mode 100644 drivers/gpu/drm/arm/malidp_hw.h
> >  create mode 100644 drivers/gpu/drm/arm/malidp_planes.c
> >  create mode 100644 drivers/gpu/drm/arm/malidp_regs.h
> > 
> > diff --git a/drivers/gpu/drm/arm/Kconfig b/drivers/gpu/drm/arm/Kconfig
> > index eaed454..1b29065 100644
> > --- a/drivers/gpu/drm/arm/Kconfig
> > +++ b/drivers/gpu/drm/arm/Kconfig
> > @@ -25,3 +25,19 @@ config DRM_HDLCD_SHOW_UNDERRUN
> >  	  Enable this option to show in red colour the pixels that the
> >  	  HDLCD device did not fetch from framebuffer due to underrun
> >  	  conditions.
> > +
> > +config DRM_MALI_DISPLAY
> > +	tristate "ARM Mali Display Processor"
> > +	depends on DRM && OF && (ARM || ARM64)
> > +	depends on COMMON_CLK
> > +	select DRM_ARM
> > +	select DRM_KMS_HELPER
> > +	select DRM_KMS_CMA_HELPER
> > +	select DRM_GEM_CMA_HELPER
> > +	select VIDEOMODE_HELPERS
> > +	help
> > +	  Choose this option if you want to compile the ARM Mali Display
> > +	  Processor driver. It supports the DP500, DP550 and DP650 variants
> > +	  of the hardware.
> > +
> > +	  If compiled as a module it will be called mali-dp.
> > diff --git a/drivers/gpu/drm/arm/Makefile b/drivers/gpu/drm/arm/Makefile
> > index 89dcb7b..bb8b158 100644
> > --- a/drivers/gpu/drm/arm/Makefile
> > +++ b/drivers/gpu/drm/arm/Makefile
> > @@ -1,2 +1,4 @@
> >  hdlcd-y := hdlcd_drv.o hdlcd_crtc.o
> >  obj-$(CONFIG_DRM_HDLCD)	+= hdlcd.o
> > +mali-dp-y := malidp_drv.o malidp_hw.o malidp_planes.o malidp_crtc.o
> > +obj-$(CONFIG_DRM_MALI_DISPLAY)	+= mali-dp.o
> > diff --git a/drivers/gpu/drm/arm/malidp_crtc.c b/drivers/gpu/drm/arm/malidp_crtc.c
> > new file mode 100644
> > index 0000000..08e6a71
> > --- /dev/null
> > +++ b/drivers/gpu/drm/arm/malidp_crtc.c
> > @@ -0,0 +1,216 @@
> > +/*
> > + * (C) COPYRIGHT 2016 ARM Limited. All rights reserved.
> > + * Author: Liviu Dudau <Liviu.Dudau@arm.com>
> > + *
> > + * This program is free software and is provided to you under the terms of the
> > + * GNU General Public License version 2 as published by the Free Software
> > + * Foundation, and any use by you of this program is subject to the terms
> > + * of such GNU licence.
> > + *
> > + * ARM Mali DP500/DP550/DP650 driver (crtc operations)
> > + */
> > +
> > +#include <drm/drmP.h>
> > +#include <drm/drm_atomic.h>
> > +#include <drm/drm_atomic_helper.h>
> > +#include <drm/drm_crtc.h>
> > +#include <drm/drm_crtc_helper.h>
> > +#include <linux/clk.h>
> > +#include <video/videomode.h>
> > +
> > +#include "malidp_drv.h"
> > +#include "malidp_hw.h"
> > +
> > +static bool malidp_crtc_mode_fixup(struct drm_crtc *crtc,
> > +				   const struct drm_display_mode *mode,
> > +				   struct drm_display_mode *adjusted_mode)
> > +{
> > +	struct malidp_drm *malidp = crtc_to_malidp_device(crtc);
> > +	struct malidp_hw_device *hwdev = malidp->dev;
> > +
> > +	/*
> > +	 * check that the hardware can drive the required clock rate,
> > +	 * but skip the check if the clock is meant to be disabled (req_rate = 0)
> > +	 */
> > +	long rate, req_rate = mode->crtc_clock * 1000;
> > +
> > +	if (req_rate) {
> > +		rate = clk_round_rate(hwdev->mclk, req_rate);
> > +		if (rate < req_rate) {
> > +			DRM_DEBUG_DRIVER("mclk clock unable to reach %d kHz\n",
> > +					 mode->crtc_clock);
> > +			return false;
> > +		}
> > +
> > +		rate = clk_round_rate(hwdev->pxlclk, req_rate);
> > +		if (rate != req_rate) {
> > +			DRM_DEBUG_DRIVER("pxlclk doesn't support %ld Hz\n",
> > +					 req_rate);
> > +			return false;
> > +		}
> > +	}
> > +
> > +	return true;
> > +}
> > +
> > +static void malidp_crtc_enable(struct drm_crtc *crtc)
> > +{
> > +	struct malidp_drm *malidp = crtc_to_malidp_device(crtc);
> > +	struct malidp_hw_device *hwdev = malidp->dev;
> > +	struct videomode vm;
> > +
> > +	drm_display_mode_to_videomode(&crtc->state->adjusted_mode, &vm);
> > +
> > +	clk_prepare_enable(hwdev->pxlclk);
> > +
> > +	/* mclk needs to be set to the same or higher rate than pxlclk */
> > +	clk_set_rate(hwdev->mclk, crtc->state->adjusted_mode.crtc_clock * 1000);
> > +	clk_set_rate(hwdev->pxlclk, crtc->state->adjusted_mode.crtc_clock * 1000);
> > +
> > +	hwdev->modeset(hwdev, &vm);
> > +	hwdev->leave_config_mode(hwdev);
> > +	drm_crtc_vblank_on(crtc);
> > +}
> > +
> > +static void malidp_crtc_disable(struct drm_crtc *crtc)
> > +{
> > +	struct malidp_drm *malidp = crtc_to_malidp_device(crtc);
> > +	struct malidp_hw_device *hwdev = malidp->dev;
> > +
> > +	drm_crtc_vblank_off(crtc);
> > +	hwdev->enter_config_mode(hwdev);
> > +	clk_disable_unprepare(hwdev->pxlclk);
> > +}
> > +
> > +static int malidp_crtc_atomic_check(struct drm_crtc *crtc,
> > +				    struct drm_crtc_state *state)
> > +{
> > +	struct malidp_drm *malidp = crtc_to_malidp_device(crtc);
> > +	struct malidp_hw_device *hwdev = malidp->dev;
> > +	struct drm_plane *plane;
> > +	const struct drm_plane_state *pstate;
> > +	u32 rot_mem_free, rot_mem_usable;
> > +	int rotated_planes = 0;
> > +
> > +	/*
> > +	 * check if there is enough rotation memory available for planes
> > +	 * that need 90° and 270° rotation. Each plane has set its required
> > +	 * memory size in the ->plane_check() callback, here we only make
> > +	 * sure that the sums are less that the total usable memory.
> > +	 *
> > +	 * The rotation memory allocation algorithm (for each plane):
> > +	 *  a. If no more rotated planes exist, all remaining rotate
> > +	 *     memory in the bank is available for use by the plane.
> > +	 *  b. If other rotated planes exist, and plane's layer ID is
> > +	 *     DE_VIDEO1, it can use all the memory from first bank if
> > +	 *     secondary rotation memory bank is available, otherwise it can
> > +	 *     use up to half the bank's memory.
> > +	 *  c. If other rotated planes exist, and plane's layer ID is not
> > +	 *     DE_VIDEO1, it can use half of the available memory
> > +	 *
> > +	 * Note: this algorithm assumes that the order in which the planes are
> > +	 * checked always has DE_VIDEO1 plane first in the list if it is
> > +	 * rotated. Because that is how we create the planes in the first
> > +	 * place, under current DRM version things work, but if ever the order
> > +	 * in which drm_atomic_crtc_state_for_each_plane() iterates over planes
> > +	 * changes, we need to pre-sort the planes before validation.
> > +	 */
> > +
> > +	/* first count the number of rotated planes */
> > +	drm_atomic_crtc_state_for_each_plane_state(plane, pstate, state) {
> > +		if (pstate->rotation & MALIDP_ROTATED_MASK)
> > +			rotated_planes++;
> > +	}
> > +
> > +	rot_mem_free = hwdev->rotation_memory[0];
> > +	/*
> > +	 * if we have more than 1 plane using rotation memory, use the second
> > +	 * block of rotation memory as well
> > +	 */
> > +	if (rotated_planes > 1)
> > +		rot_mem_free += hwdev->rotation_memory[1];
> > +
> > +	/* now validate the rotation memory requirements */
> > +	drm_atomic_crtc_state_for_each_plane_state(plane, pstate, state) {
> > +		struct malidp_plane *mp = to_malidp_plane(plane);
> > +		struct malidp_plane_state *ms = to_malidp_plane_state(pstate);
> > +
> > +		if (pstate->rotation & MALIDP_ROTATED_MASK) {
> > +			/* process current plane */
> > +			rotated_planes--;
> > +
> > +			if (!rotated_planes) {
> > +				/* no more rotated planes, we can use what's left */
> > +				rot_mem_usable = rot_mem_free;
> > +			} else {
> > +				if ((mp->layer->id != DE_VIDEO1) ||
> > +				    (hwdev->rotation_memory[1] == 0))
> > +					rot_mem_usable = rot_mem_free / 2;
> > +				else
> > +					rot_mem_usable = hwdev->rotation_memory[0];
> > +			}
> > +
> > +			rot_mem_free -= rot_mem_usable;
> > +
> > +			if (ms->rotmem_size > rot_mem_usable)
> > +				return -EINVAL;
> > +		}
> > +	}
> > +
> > +	return 0;
> > +}
> > +
> > +static const struct drm_crtc_helper_funcs malidp_crtc_helper_funcs = {
> > +	.mode_fixup = malidp_crtc_mode_fixup,
> > +	.enable = malidp_crtc_enable,
> > +	.disable = malidp_crtc_disable,
> > +	.atomic_check = malidp_crtc_atomic_check,
> > +};
> > +
> > +static const struct drm_crtc_funcs malidp_crtc_funcs = {
> > +	.destroy = drm_crtc_cleanup,
> > +	.set_config = drm_atomic_helper_set_config,
> > +	.page_flip = drm_atomic_helper_page_flip,
> > +	.reset = drm_atomic_helper_crtc_reset,
> > +	.atomic_duplicate_state = drm_atomic_helper_crtc_duplicate_state,
> > +	.atomic_destroy_state = drm_atomic_helper_crtc_destroy_state,
> > +};
> > +
> > +int malidp_crtc_init(struct drm_device *drm)
> > +{
> > +	struct malidp_drm *malidp = drm->dev_private;
> > +	struct drm_plane *primary = NULL, *plane;
> > +	int ret;
> > +
> > +	ret = malidp_de_planes_init(drm);
> > +	if (ret < 0) {
> > +		DRM_ERROR("Failed to initialise planes\n");
> > +		return ret;
> > +	}
> > +
> > +	drm_for_each_plane(plane, drm) {
> > +		if (plane->type == DRM_PLANE_TYPE_PRIMARY) {
> > +			primary = plane;
> > +			break;
> > +		}
> > +	}
> > +
> > +	if (!primary) {
> > +		DRM_ERROR("no primary plane found\n");
> > +		ret = -EINVAL;
> > +		goto crtc_cleanup_planes;
> > +	}
> > +
> > +	ret = drm_crtc_init_with_planes(drm, &malidp->crtc, primary, NULL,
> > +					&malidp_crtc_funcs, NULL);
> > +
> > +	if (!ret) {
> > +		drm_crtc_helper_add(&malidp->crtc, &malidp_crtc_helper_funcs);
> > +		return 0;
> > +	}
> > +
> > +crtc_cleanup_planes:
> > +	malidp_de_planes_destroy(drm);
> > +
> > +	return ret;
> > +}
> > diff --git a/drivers/gpu/drm/arm/malidp_drv.c b/drivers/gpu/drm/arm/malidp_drv.c
> > new file mode 100644
> > index 0000000..e5b44e9
> > --- /dev/null
> > +++ b/drivers/gpu/drm/arm/malidp_drv.c
> > @@ -0,0 +1,512 @@
> > +/*
> > + * (C) COPYRIGHT 2016 ARM Limited. All rights reserved.
> > + * Author: Liviu Dudau <Liviu.Dudau@arm.com>
> > + *
> > + * This program is free software and is provided to you under the terms of the
> > + * GNU General Public License version 2 as published by the Free Software
> > + * Foundation, and any use by you of this program is subject to the terms
> > + * of such GNU licence.
> > + *
> > + * ARM Mali DP500/DP550/DP650 KMS/DRM driver
> > + */
> > +
> > +#include <linux/module.h>
> > +#include <linux/clk.h>
> > +#include <linux/component.h>
> > +#include <linux/of_device.h>
> > +#include <linux/of_graph.h>
> > +#include <linux/of_reserved_mem.h>
> > +
> > +#include <drm/drmP.h>
> > +#include <drm/drm_atomic.h>
> > +#include <drm/drm_atomic_helper.h>
> > +#include <drm/drm_crtc.h>
> > +#include <drm/drm_crtc_helper.h>
> > +#include <drm/drm_fb_helper.h>
> > +#include <drm/drm_fb_cma_helper.h>
> > +#include <drm/drm_gem_cma_helper.h>
> > +#include <drm/drm_of.h>
> > +
> > +#include "malidp_drv.h"
> > +#include "malidp_regs.h"
> > +#include "malidp_hw.h"
> > +
> > +#define MALIDP_CONF_VALID_TIMEOUT	250
> > +
> > +/*
> > + * set the "config valid" bit and wait until the hardware acts on it
> > + */
> > +static int malidp_set_and_wait_config_valid(struct drm_device *drm)
> > +{
> > +	struct malidp_drm *malidp = drm->dev_private;
> > +	struct malidp_hw_device *hwdev = malidp->dev;
> > +	int ret;
> > +
> > +	hwdev->set_config_valid(hwdev);
> > +	/* don't wait for config_valid flag if we are in config mode */
> > +	if (hwdev->in_config_mode(hwdev))
> > +		return 0;
> > +
> > +	ret = wait_event_interruptible_timeout(malidp->wq,
> > +			atomic_read(&malidp->config_valid) == 1,
> > +			msecs_to_jiffies(MALIDP_CONF_VALID_TIMEOUT));
> > +
> > +	return (ret > 0) ? 0 : -ETIMEDOUT;
> > +}
> > +
> > +static void malidp_output_poll_changed(struct drm_device *drm)
> > +{
> > +	struct malidp_drm *malidp = drm->dev_private;
> > +
> > +	drm_fbdev_cma_hotplug_event(malidp->fbdev);
> > +}
> > +
> > +static void malidp_atomic_commit_hw_done(struct drm_atomic_state *state)
> > +{
> > +	struct drm_pending_vblank_event *event;
> > +	struct drm_device *drm = state->dev;
> > +	struct malidp_drm *malidp = drm->dev_private;
> > +	int ret = malidp_set_and_wait_config_valid(drm);
> > +
> > +	if (ret)
> > +		DRM_DEBUG_DRIVER("timed out waiting for updated configuration\n");
> > +
> > +	event = malidp->crtc.state->event;
> > +	if (event) {
> > +		malidp->crtc.state->event = NULL;
> > +
> > +		spin_lock_irq(&drm->event_lock);
> > +		if (drm_crtc_vblank_get(&malidp->crtc) == 0)
> > +			drm_crtc_arm_vblank_event(&malidp->crtc, event);
> > +		else
> > +			drm_crtc_send_vblank_event(&malidp->crtc, event);
> > +		spin_unlock_irq(&drm->event_lock);
> > +	}
> > +	drm_atomic_helper_commit_hw_done(state);
> > +}
> > +
> > +static void malidp_atomic_commit_tail(struct drm_atomic_state *state)
> > +{
> > +	struct drm_device *drm = state->dev;
> > +
> > +	drm_atomic_helper_commit_modeset_disables(drm, state);
> > +	drm_atomic_helper_commit_modeset_enables(drm, state);
> > +	drm_atomic_helper_commit_planes(drm, state, true);
> > +
> > +	malidp_atomic_commit_hw_done(state);
> > +
> > +	drm_atomic_helper_wait_for_vblanks(drm, state);
> > +
> > +	drm_atomic_helper_cleanup_planes(drm, state);
> > +}
> > +
> > +static struct drm_mode_config_helper_funcs malidp_mode_config_helpers = {
> > +	.atomic_commit_tail = malidp_atomic_commit_tail,
> > +};
> > +
> > +static const struct drm_mode_config_funcs malidp_mode_config_funcs = {
> > +	.fb_create = drm_fb_cma_create,
> > +	.output_poll_changed = malidp_output_poll_changed,
> > +	.atomic_check = drm_atomic_helper_check,
> > +	.atomic_commit = drm_atomic_helper_commit,
> > +};
> > +
> > +static int malidp_enable_vblank(struct drm_device *drm, unsigned int crtc)
> > +{
> > +	struct malidp_drm *malidp = drm->dev_private;
> > +	struct malidp_hw_device *hwdev = malidp->dev;
> > +
> > +	malidp_hw_enable_irq(hwdev, MALIDP_DE_BLOCK,
> > +			     hwdev->map.de_irq_map.vsync_irq);
> > +	return 0;
> > +}
> > +
> > +static void malidp_disable_vblank(struct drm_device *drm, unsigned int pipe)
> > +{
> > +	struct malidp_drm *malidp = drm->dev_private;
> > +	struct malidp_hw_device *hwdev = malidp->dev;
> > +
> > +	malidp_hw_disable_irq(hwdev, MALIDP_DE_BLOCK,
> > +			      hwdev->map.de_irq_map.vsync_irq);
> > +}
> > +
> > +static int malidp_init(struct drm_device *drm)
> > +{
> > +	int ret;
> > +	struct malidp_drm *malidp = drm->dev_private;
> > +	struct malidp_hw_device *hwdev = malidp->dev;
> > +
> > +	drm_mode_config_init(drm);
> > +
> > +	drm->mode_config.min_width = hwdev->min_line_size;
> > +	drm->mode_config.min_height = hwdev->min_line_size;
> > +	drm->mode_config.max_width = hwdev->max_line_size;
> > +	drm->mode_config.max_height = hwdev->max_line_size;
> > +	drm->mode_config.funcs = &malidp_mode_config_funcs;
> > +	drm->mode_config.helper_private = &malidp_mode_config_helpers;
> > +
> > +	ret = malidp_crtc_init(drm);
> > +	if (ret) {
> > +		drm_mode_config_cleanup(drm);
> > +		return ret;
> > +	}
> > +
> > +	return 0;
> > +}
> > +
> > +static int malidp_irq_init(struct platform_device *pdev)
> > +{
> > +	int irq_de, irq_se, ret = 0;
> > +	struct drm_device *drm = dev_get_drvdata(&pdev->dev);
> > +
> > +	/* fetch the interrupts from DT */
> > +	irq_de = platform_get_irq_byname(pdev, "DE");
> > +	if (irq_de < 0) {
> > +		DRM_ERROR("no 'DE' IRQ specified!\n");
> > +		return irq_de;
> > +	}
> > +	irq_se = platform_get_irq_byname(pdev, "SE");
> > +	if (irq_se < 0) {
> > +		DRM_ERROR("no 'SE' IRQ specified!\n");
> > +		return irq_se;
> > +	}
> > +
> > +	ret = malidp_de_irq_init(drm, irq_de);
> > +	if (ret)
> > +		return ret;
> > +
> > +	ret = malidp_se_irq_init(drm, irq_se);
> > +	if (ret) {
> > +		malidp_de_irq_fini(drm);
> > +		return ret;
> > +	}
> > +
> > +	return 0;
> > +}
> > +
> > +static void malidp_lastclose(struct drm_device *drm)
> > +{
> > +	struct malidp_drm *malidp = drm->dev_private;
> > +
> > +	drm_fbdev_cma_restore_mode(malidp->fbdev);
> > +}
> > +
> > +static const struct file_operations fops = {
> > +	.owner = THIS_MODULE,
> > +	.open = drm_open,
> > +	.release = drm_release,
> > +	.unlocked_ioctl = drm_ioctl,
> > +#ifdef CONFIG_COMPAT
> > +	.compat_ioctl = drm_compat_ioctl,
> > +#endif
> > +	.poll = drm_poll,
> > +	.read = drm_read,
> > +	.llseek = noop_llseek,
> > +	.mmap = drm_gem_cma_mmap,
> > +};
> > +
> > +static struct drm_driver malidp_driver = {
> > +	.driver_features = DRIVER_GEM | DRIVER_MODESET | DRIVER_ATOMIC |
> > +			   DRIVER_PRIME,
> > +	.lastclose = malidp_lastclose,
> > +	.get_vblank_counter = drm_vblank_no_hw_counter,
> > +	.enable_vblank = malidp_enable_vblank,
> > +	.disable_vblank = malidp_disable_vblank,
> > +	.gem_free_object_unlocked = drm_gem_cma_free_object,
> > +	.gem_vm_ops = &drm_gem_cma_vm_ops,
> > +	.dumb_create = drm_gem_cma_dumb_create,
> > +	.dumb_map_offset = drm_gem_cma_dumb_map_offset,
> > +	.dumb_destroy = drm_gem_dumb_destroy,
> > +	.prime_handle_to_fd = drm_gem_prime_handle_to_fd,
> > +	.prime_fd_to_handle = drm_gem_prime_fd_to_handle,
> > +	.gem_prime_export = drm_gem_prime_export,
> > +	.gem_prime_import = drm_gem_prime_import,
> > +	.gem_prime_get_sg_table = drm_gem_cma_prime_get_sg_table,
> > +	.gem_prime_import_sg_table = drm_gem_cma_prime_import_sg_table,
> > +	.gem_prime_vmap = drm_gem_cma_prime_vmap,
> > +	.gem_prime_vunmap = drm_gem_cma_prime_vunmap,
> > +	.gem_prime_mmap = drm_gem_cma_prime_mmap,
> > +	.fops = &fops,
> > +	.name = "mali-dp",
> > +	.desc = "ARM Mali Display Processor driver",
> > +	.date = "20160106",
> > +	.major = 1,
> > +	.minor = 0,
> > +};
> > +
> > +static const struct of_device_id  malidp_drm_of_match[] = {
> > +	{
> > +		.compatible = "arm,mali-dp500",
> > +		.data = &malidp_device[MALIDP_500]
> > +	},
> > +	{
> > +		.compatible = "arm,mali-dp550",
> > +		.data = &malidp_device[MALIDP_550]
> > +	},
> > +	{
> > +		.compatible = "arm,mali-dp650",
> > +		.data = &malidp_device[MALIDP_650]
> > +	},
> > +	{},
> > +};
> > +MODULE_DEVICE_TABLE(of, malidp_drm_of_match);
> > +
> > +#define MAX_OUTPUT_CHANNELS	3
> > +
> > +static int malidp_bind(struct device *dev)
> > +{
> > +	struct resource *res;
> > +	struct drm_device *drm;
> > +	struct malidp_drm *malidp;
> > +	struct malidp_hw_device *hwdev;
> > +	struct platform_device *pdev = to_platform_device(dev);
> > +	/* number of lines for the R, G and B output */
> > +	u8 output_width[MAX_OUTPUT_CHANNELS];
> > +	int ret = 0, i;
> > +	u32 version, out_depth = 0;
> > +
> > +	malidp = devm_kzalloc(dev, sizeof(*malidp), GFP_KERNEL);
> > +	if (!malidp)
> > +		return -ENOMEM;
> > +
> > +	hwdev = devm_kzalloc(dev, sizeof(*hwdev), GFP_KERNEL);
> > +	if (!hwdev)
> > +		return -ENOMEM;
> > +
> > +	/*
> > +	 * copy the associated data from malidp_drm_of_match to avoid
> > +	 * having to keep a reference to the OF node after binding
> > +	 */
> > +	memcpy(hwdev, of_device_get_match_data(dev), sizeof(*hwdev));
> > +	malidp->dev = hwdev;
> > +
> > +	INIT_LIST_HEAD(&malidp->event_list);
> > +
> > +	res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
> > +	hwdev->regs = devm_ioremap_resource(dev, res);
> > +	if (IS_ERR(hwdev->regs)) {
> > +		DRM_ERROR("Failed to map control registers area\n");
> > +		return PTR_ERR(hwdev->regs);
> > +	}
> > +
> > +	hwdev->pclk = devm_clk_get(dev, "pclk");
> > +	if (IS_ERR(hwdev->pclk))
> > +		return PTR_ERR(hwdev->pclk);
> > +
> > +	hwdev->aclk = devm_clk_get(dev, "aclk");
> > +	if (IS_ERR(hwdev->aclk))
> > +		return PTR_ERR(hwdev->aclk);
> > +
> > +	hwdev->mclk = devm_clk_get(dev, "mclk");
> > +	if (IS_ERR(hwdev->mclk))
> > +		return PTR_ERR(hwdev->mclk);
> > +
> > +	hwdev->pxlclk = devm_clk_get(dev, "pxlclk");
> > +	if (IS_ERR(hwdev->pxlclk))
> > +		return PTR_ERR(hwdev->pxlclk);
> > +
> > +	/* Get the optional framebuffer memory resource */
> > +	ret = of_reserved_mem_device_init(dev);
> > +	if (ret && ret != -ENODEV)
> > +		return ret;
> > +
> > +	drm = drm_dev_alloc(&malidp_driver, dev);
> > +	if (!drm) {
> > +		ret = -ENOMEM;
> > +		goto alloc_fail;
> > +	}
> > +
> > +	/* Enable APB clock in order to get access to the registers */
> > +	clk_prepare_enable(hwdev->pclk);
> > +	/*
> > +	 * Enable AXI clock and main clock so that prefetch can start once
> > +	 * the registers are set
> > +	 */
> > +	clk_prepare_enable(hwdev->aclk);
> > +	clk_prepare_enable(hwdev->mclk);
> > +
> > +	ret = hwdev->query_hw(hwdev);
> > +	if (ret) {
> > +		DRM_ERROR("Invalid HW configuration\n");
> > +		goto query_hw_fail;
> > +	}
> > +
> > +	version = malidp_hw_read(hwdev, hwdev->map.dc_base + MALIDP_DE_CORE_ID);
> > +	DRM_INFO("found ARM Mali-DP%3x version r%dp%d\n", version >> 16,
> > +		 (version >> 12) & 0xf, (version >> 8) & 0xf);
> > +
> > +	/* set the number of lines used for output of RGB data */
> > +	ret = of_property_read_u8_array(dev->of_node,
> > +					"arm,malidp-output-port-lines",
> > +					output_width, MAX_OUTPUT_CHANNELS);
> > +	if (ret)
> > +		goto query_hw_fail;
> > +
> > +	for (i = 0; i < MAX_OUTPUT_CHANNELS; i++)
> > +		out_depth = (out_depth << 8) | (output_width[i] & 0xf);
> > +	malidp_hw_write(hwdev, out_depth, hwdev->map.out_depth_base);
> > +
> > +	drm->dev_private = malidp;
> > +	dev_set_drvdata(dev, drm);
> > +	atomic_set(&malidp->config_valid, 0);
> > +	init_waitqueue_head(&malidp->wq);
> > +
> > +	ret = malidp_init(drm);
> > +	if (ret < 0)
> > +		goto init_fail;
> > +
> > +	ret = drm_dev_register(drm, 0);
> > +	if (ret)
> > +		goto register_fail;
> > +
> > +	/* Set the CRTC's port so that the encoder component can find it */
> > +	malidp->crtc.port = of_graph_get_next_endpoint(dev->of_node, NULL);
> > +
> > +	ret = component_bind_all(dev, drm);
> > +	of_node_put(malidp->crtc.port);
> > +
> > +	if (ret) {
> > +		DRM_ERROR("Failed to bind all components\n");
> > +		goto bind_fail;
> > +	}
> > +
> > +	ret = malidp_irq_init(pdev);
> > +	if (ret < 0)
> > +		goto irq_init_fail;
> > +
> > +	ret = drm_vblank_init(drm, drm->mode_config.num_crtc);
> > +	if (ret < 0) {
> > +		DRM_ERROR("failed to initialise vblank\n");
> > +		goto vblank_fail;
> > +	}
> > +
> > +	drm_mode_config_reset(drm);
> > +
> > +	malidp->fbdev = drm_fbdev_cma_init(drm, 32, drm->mode_config.num_crtc,
> > +					   drm->mode_config.num_connector);
> > +
> > +	if (IS_ERR(malidp->fbdev)) {
> > +		ret = PTR_ERR(malidp->fbdev);
> > +		malidp->fbdev = NULL;
> > +		goto fbdev_fail;
> > +	}
> > +
> > +	drm_kms_helper_poll_init(drm);
> > +	return 0;
> > +
> > +fbdev_fail:
> > +	drm_vblank_cleanup(drm);
> > +vblank_fail:
> > +	malidp_se_irq_fini(drm);
> > +	malidp_de_irq_fini(drm);
> > +irq_init_fail:
> > +	component_unbind_all(dev, drm);
> > +bind_fail:
> > +	drm_dev_unregister(drm);
> > +register_fail:
> > +	malidp_de_planes_destroy(drm);
> > +	drm_mode_config_cleanup(drm);
> > +init_fail:
> > +	drm->dev_private = NULL;
> > +	dev_set_drvdata(dev, NULL);
> > +query_hw_fail:
> > +	clk_disable_unprepare(hwdev->mclk);
> > +	clk_disable_unprepare(hwdev->aclk);
> > +	clk_disable_unprepare(hwdev->pclk);
> > +	drm_dev_unref(drm);
> > +alloc_fail:
> > +	of_reserved_mem_device_release(dev);
> > +
> > +	return ret;
> > +}
> > +
> > +static void malidp_unbind(struct device *dev)
> > +{
> > +	struct drm_device *drm = dev_get_drvdata(dev);
> > +	struct malidp_drm *malidp = drm->dev_private;
> > +	struct malidp_hw_device *hwdev = malidp->dev;
> > +
> > +	if (malidp->fbdev) {
> > +		drm_fbdev_cma_fini(malidp->fbdev);
> > +		malidp->fbdev = NULL;
> > +	}
> > +	drm_kms_helper_poll_fini(drm);
> > +	malidp_se_irq_fini(drm);
> > +	malidp_de_irq_fini(drm);
> > +	drm_vblank_cleanup(drm);
> > +	component_unbind_all(dev, drm);
> > +	drm_dev_unregister(drm);
> > +	malidp_de_planes_destroy(drm);
> > +	drm_mode_config_cleanup(drm);
> > +	drm->dev_private = NULL;
> > +	dev_set_drvdata(dev, NULL);
> > +	clk_disable_unprepare(hwdev->mclk);
> > +	clk_disable_unprepare(hwdev->aclk);
> > +	clk_disable_unprepare(hwdev->pclk);
> > +	drm_dev_unref(drm);
> > +	of_reserved_mem_device_release(dev);
> > +}
> > +
> > +static const struct component_master_ops malidp_master_ops = {
> > +	.bind = malidp_bind,
> > +	.unbind = malidp_unbind,
> > +};
> > +
> > +static int malidp_compare_dev(struct device *dev, void *data)
> > +{
> > +	struct device_node *np = data;
> > +
> > +	return dev->of_node == np;
> > +}
> > +
> > +static int malidp_platform_probe(struct platform_device *pdev)
> > +{
> > +	struct device_node *port, *ep;
> > +	struct component_match *match = NULL;
> > +
> > +	if (!pdev->dev.of_node)
> > +		return -ENODEV;
> > +
> > +	/* there is only one output port inside each device, find it */
> > +	ep = of_graph_get_next_endpoint(pdev->dev.of_node, NULL);
> > +	if (!ep)
> > +		return -ENODEV;
> > +
> > +	if (!of_device_is_available(ep)) {
> > +		of_node_put(ep);
> > +		return -ENODEV;
> > +	}
> > +
> > +	/* add the remote encoder port as component */
> > +	port = of_graph_get_remote_port_parent(ep);
> > +	of_node_put(ep);
> > +	if (!port || !of_device_is_available(port)) {
> > +		of_node_put(port);
> > +		return -EAGAIN;
> > +	}
> > +
> > +	component_match_add(&pdev->dev, &match, malidp_compare_dev, port);
> > +	return component_master_add_with_match(&pdev->dev, &malidp_master_ops,
> > +					       match);
> > +}
> > +
> > +static int malidp_platform_remove(struct platform_device *pdev)
> > +{
> > +	component_master_del(&pdev->dev, &malidp_master_ops);
> > +	return 0;
> > +}
> > +
> > +static struct platform_driver malidp_platform_driver = {
> > +	.probe		= malidp_platform_probe,
> > +	.remove		= malidp_platform_remove,
> > +	.driver	= {
> > +		.name = "mali-dp",
> > +		.of_match_table	= malidp_drm_of_match,
> > +	},
> > +};
> > +
> > +module_platform_driver(malidp_platform_driver);
> > +
> > +MODULE_AUTHOR("Liviu Dudau <Liviu.Dudau@arm.com>");
> > +MODULE_DESCRIPTION("ARM Mali DP DRM driver");
> > +MODULE_LICENSE("GPL v2");
> > diff --git a/drivers/gpu/drm/arm/malidp_drv.h b/drivers/gpu/drm/arm/malidp_drv.h
> > new file mode 100644
> > index 0000000..95558fd
> > --- /dev/null
> > +++ b/drivers/gpu/drm/arm/malidp_drv.h
> > @@ -0,0 +1,54 @@
> > +/*
> > + * (C) COPYRIGHT 2016 ARM Limited. All rights reserved.
> > + * Author: Liviu Dudau <Liviu.Dudau@arm.com>
> > + *
> > + * This program is free software and is provided to you under the terms of the
> > + * GNU General Public License version 2 as published by the Free Software
> > + * Foundation, and any use by you of this program is subject to the terms
> > + * of such GNU licence.
> > + *
> > + * ARM Mali DP500/DP550/DP650 KMS/DRM driver structures
> > + */
> > +
> > +#ifndef __MALIDP_DRV_H__
> > +#define __MALIDP_DRV_H__
> > +
> > +#include <linux/mutex.h>
> > +#include <linux/wait.h>
> > +#include "malidp_hw.h"
> > +
> > +struct malidp_drm {
> > +	struct malidp_hw_device *dev;
> > +	struct drm_fbdev_cma *fbdev;
> > +	struct list_head event_list;
> > +	struct drm_crtc crtc;
> > +	wait_queue_head_t wq;
> > +	atomic_t config_valid;
> > +};
> > +
> > +#define crtc_to_malidp_device(x) container_of(x, struct malidp_drm, crtc)
> > +
> > +struct malidp_plane {
> > +	struct drm_plane base;
> > +	struct malidp_hw_device *hwdev;
> > +	const struct malidp_layer *layer;
> > +};
> > +
> > +struct malidp_plane_state {
> > +	struct drm_plane_state base;
> > +
> > +	/* size of the required rotation memory if plane is rotated */
> > +	u32 rotmem_size;
> > +};
> > +
> > +#define to_malidp_plane(x) container_of(x, struct malidp_plane, base)
> > +#define to_malidp_plane_state(x) container_of(x, struct malidp_plane_state, base)
> > +
> > +int malidp_de_planes_init(struct drm_device *drm);
> > +void malidp_de_planes_destroy(struct drm_device *drm);
> > +int malidp_crtc_init(struct drm_device *drm);
> > +
> > +/* often used combination of rotational bits */
> > +#define MALIDP_ROTATED_MASK	(BIT(DRM_ROTATE_90) | BIT(DRM_ROTATE_270))
> > +
> > +#endif  /* __MALIDP_DRV_H__ */
> > diff --git a/drivers/gpu/drm/arm/malidp_hw.c b/drivers/gpu/drm/arm/malidp_hw.c
> > new file mode 100644
> > index 0000000..a6132f1
> > --- /dev/null
> > +++ b/drivers/gpu/drm/arm/malidp_hw.c
> > @@ -0,0 +1,691 @@
> > +/*
> > + * (C) COPYRIGHT 2016 ARM Limited. All rights reserved.
> > + * Author: Liviu Dudau <Liviu.Dudau@arm.com>
> > + *
> > + * This program is free software and is provided to you under the terms of the
> > + * GNU General Public License version 2 as published by the Free Software
> > + * Foundation, and any use by you of this program is subject to the terms
> > + * of such GNU licence.
> > + *
> > + * ARM Mali DP500/DP550/DP650 hardware manipulation routines. This is where
> > + * the difference between various versions of the hardware is being dealt with
> > + * in an attempt to provide to the rest of the driver code a unified view
> > + */
> > +
> > +#include <linux/types.h>
> > +#include <linux/io.h>
> > +#include <drm/drmP.h>
> > +#include <video/videomode.h>
> > +#include <video/display_timing.h>
> > +
> > +#include "malidp_drv.h"
> > +#include "malidp_hw.h"
> > +
> > +static const struct malidp_input_format malidp500_de_formats[] = {
> > +	/*    fourcc,   layers supporting the format,     internal id  */
> > +	{ DRM_FORMAT_ARGB2101010, DE_VIDEO1 | DE_GRAPHICS1 | DE_GRAPHICS2,  0 },
> > +	{ DRM_FORMAT_ABGR2101010, DE_VIDEO1 | DE_GRAPHICS1 | DE_GRAPHICS2,  1 },
> > +	{ DRM_FORMAT_ARGB8888, DE_VIDEO1 | DE_GRAPHICS1 | DE_GRAPHICS2,  2 },
> > +	{ DRM_FORMAT_ABGR8888, DE_VIDEO1 | DE_GRAPHICS1 | DE_GRAPHICS2,  3 },
> > +	{ DRM_FORMAT_XRGB8888, DE_VIDEO1 | DE_GRAPHICS1 | DE_GRAPHICS2,  4 },
> > +	{ DRM_FORMAT_XBGR8888, DE_VIDEO1 | DE_GRAPHICS1 | DE_GRAPHICS2,  5 },
> > +	{ DRM_FORMAT_RGB888, DE_VIDEO1 | DE_GRAPHICS1 | DE_GRAPHICS2,  6 },
> > +	{ DRM_FORMAT_BGR888, DE_VIDEO1 | DE_GRAPHICS1 | DE_GRAPHICS2,  7 },
> > +	{ DRM_FORMAT_RGBA5551, DE_VIDEO1 | DE_GRAPHICS1 | DE_GRAPHICS2,  8 },
> > +	{ DRM_FORMAT_ABGR1555, DE_VIDEO1 | DE_GRAPHICS1 | DE_GRAPHICS2,  9 },
> > +	{ DRM_FORMAT_RGB565, DE_VIDEO1 | DE_GRAPHICS1 | DE_GRAPHICS2, 10 },
> > +	{ DRM_FORMAT_BGR565, DE_VIDEO1 | DE_GRAPHICS1 | DE_GRAPHICS2, 11 },
> > +	{ DRM_FORMAT_UYVY, DE_VIDEO1, 12 },
> > +	{ DRM_FORMAT_YUYV, DE_VIDEO1, 13 },
> > +	{ DRM_FORMAT_NV12, DE_VIDEO1, 14 },
> > +	{ DRM_FORMAT_YUV420, DE_VIDEO1, 15 },
> > +};
> > +
> > +#define MALIDP_ID(__group, __format) \
> > +	((((__group) & 0x7) << 3) | ((__format) & 0x7))
> > +
> > +#define MALIDP_COMMON_FORMATS \
> > +	/*    fourcc,   layers supporting the format,      internal id   */ \
> > +	{ DRM_FORMAT_ARGB2101010, DE_VIDEO1 | DE_GRAPHICS1 | DE_VIDEO2, MALIDP_ID(0, 0) }, \
> > +	{ DRM_FORMAT_ABGR2101010, DE_VIDEO1 | DE_GRAPHICS1 | DE_VIDEO2, MALIDP_ID(0, 1) }, \
> > +	{ DRM_FORMAT_RGBA1010102, DE_VIDEO1 | DE_GRAPHICS1 | DE_VIDEO2, MALIDP_ID(0, 2) }, \
> > +	{ DRM_FORMAT_BGRA1010102, DE_VIDEO1 | DE_GRAPHICS1 | DE_VIDEO2, MALIDP_ID(0, 3) }, \
> > +	{ DRM_FORMAT_ARGB8888, DE_VIDEO1 | DE_GRAPHICS1 | DE_VIDEO2 | DE_SMART, MALIDP_ID(1, 0) }, \
> > +	{ DRM_FORMAT_ABGR8888, DE_VIDEO1 | DE_GRAPHICS1 | DE_VIDEO2 | DE_SMART, MALIDP_ID(1, 1) }, \
> > +	{ DRM_FORMAT_RGBA8888, DE_VIDEO1 | DE_GRAPHICS1 | DE_VIDEO2 | DE_SMART, MALIDP_ID(1, 2) }, \
> > +	{ DRM_FORMAT_BGRA8888, DE_VIDEO1 | DE_GRAPHICS1 | DE_VIDEO2 | DE_SMART, MALIDP_ID(1, 3) }, \
> > +	{ DRM_FORMAT_XRGB8888, DE_VIDEO1 | DE_GRAPHICS1 | DE_VIDEO2 | DE_SMART, MALIDP_ID(2, 0) }, \
> > +	{ DRM_FORMAT_XBGR8888, DE_VIDEO1 | DE_GRAPHICS1 | DE_VIDEO2 | DE_SMART, MALIDP_ID(2, 1) }, \
> > +	{ DRM_FORMAT_RGBX8888, DE_VIDEO1 | DE_GRAPHICS1 | DE_VIDEO2 | DE_SMART, MALIDP_ID(2, 2) }, \
> > +	{ DRM_FORMAT_BGRX8888, DE_VIDEO1 | DE_GRAPHICS1 | DE_VIDEO2 | DE_SMART, MALIDP_ID(2, 3) }, \
> > +	{ DRM_FORMAT_RGB888, DE_VIDEO1 | DE_GRAPHICS1 | DE_VIDEO2, MALIDP_ID(3, 0) }, \
> > +	{ DRM_FORMAT_BGR888, DE_VIDEO1 | DE_GRAPHICS1 | DE_VIDEO2, MALIDP_ID(3, 1) }, \
> > +	{ DRM_FORMAT_RGBA5551, DE_VIDEO1 | DE_GRAPHICS1 | DE_VIDEO2, MALIDP_ID(4, 0) }, \
> > +	{ DRM_FORMAT_ABGR1555, DE_VIDEO1 | DE_GRAPHICS1 | DE_VIDEO2, MALIDP_ID(4, 1) }, \
> > +	{ DRM_FORMAT_RGB565, DE_VIDEO1 | DE_GRAPHICS1 | DE_VIDEO2, MALIDP_ID(4, 2) }, \
> > +	{ DRM_FORMAT_BGR565, DE_VIDEO1 | DE_GRAPHICS1 | DE_VIDEO2, MALIDP_ID(4, 3) }, \
> > +	{ DRM_FORMAT_YUYV, DE_VIDEO1 | DE_VIDEO2, MALIDP_ID(5, 2) },	\
> > +	{ DRM_FORMAT_UYVY, DE_VIDEO1 | DE_VIDEO2, MALIDP_ID(5, 3) },	\
> > +	{ DRM_FORMAT_NV12, DE_VIDEO1 | DE_VIDEO2, MALIDP_ID(5, 6) },	\
> > +	{ DRM_FORMAT_YUV420, DE_VIDEO1 | DE_VIDEO2, MALIDP_ID(5, 7) }
> > +
> > +static const struct malidp_input_format malidp550_de_formats[] = {
> > +	MALIDP_COMMON_FORMATS,
> > +};
> > +
> > +static const struct malidp_layer malidp500_layers[] = {
> > +	{ DE_VIDEO1, MALIDP500_DE_LV_BASE, MALIDP500_DE_LV_PTR_BASE },
> > +	{ DE_GRAPHICS1, MALIDP500_DE_LG1_BASE, MALIDP500_DE_LG1_PTR_BASE },
> > +	{ DE_GRAPHICS2, MALIDP500_DE_LG2_BASE, MALIDP500_DE_LG2_PTR_BASE },
> > +};
> > +
> > +static const struct malidp_layer malidp550_layers[] = {
> > +	{ DE_VIDEO1, MALIDP550_DE_LV1_BASE, MALIDP550_DE_LV1_PTR_BASE },
> > +	{ DE_GRAPHICS1, MALIDP550_DE_LG_BASE, MALIDP550_DE_LG_PTR_BASE },
> > +	{ DE_VIDEO2, MALIDP550_DE_LV2_BASE, MALIDP550_DE_LV2_PTR_BASE },
> > +	{ DE_SMART, MALIDP550_DE_LS_BASE, MALIDP550_DE_LS_PTR_BASE },
> > +};
> > +
> > +#define MALIDP_DE_DEFAULT_PREFETCH_START	5
> > +
> > +static int malidp500_query_hw(struct malidp_hw_device *hwdev)
> > +{
> > +	u32 conf = malidp_hw_read(hwdev, MALIDP500_CONFIG_ID);
> > +	/* bit 4 of the CONFIG_ID register holds the line size multiplier */
> > +	u8 ln_size_mult = conf & 0x10 ? 2 : 1;
> > +
> > +	hwdev->min_line_size = 2;
> > +	hwdev->max_line_size = SZ_2K * ln_size_mult;
> > +	hwdev->rotation_memory[0] = SZ_1K * 64 * ln_size_mult;
> > +	hwdev->rotation_memory[1] = 0; /* no second rotation memory bank */
> > +
> > +	return 0;
> > +}
> > +
> > +static void malidp500_enter_config_mode(struct malidp_hw_device *hwdev)
> > +{
> > +	u32 status, count = 100;
> > +
> > +	malidp_hw_setbits(hwdev, MALIDP500_DC_CONFIG_REQ, MALIDP500_DC_CONTROL);
> > +	while (count) {
> > +		status = malidp_hw_read(hwdev, hwdev->map.dc_base + MALIDP_REG_STATUS);
> > +		if ((status & MALIDP500_DC_CONFIG_REQ) == MALIDP500_DC_CONFIG_REQ)
> > +			break;
> > +		/*
> > +		 * entering config mode can take as long as the rendering
> > +		 * of a full frame, hence the long sleep here
> > +		 */
> > +		usleep_range(1000, 10000);
> > +		count--;
> > +	}
> > +	WARN(count == 0, "timeout while entering config mode");
> > +}
> > +
> > +static void malidp500_leave_config_mode(struct malidp_hw_device *hwdev)
> > +{
> > +	u32 status, count = 100;
> > +
> > +	malidp_hw_clearbits(hwdev, MALIDP500_DC_CONFIG_REQ, MALIDP500_DC_CONTROL);
> > +	while (count) {
> > +		status = malidp_hw_read(hwdev, hwdev->map.dc_base + MALIDP_REG_STATUS);
> > +		if ((status & MALIDP500_DC_CONFIG_REQ) == 0)
> > +			break;
> > +		usleep_range(100, 1000);
> > +		count--;
> > +	}
> > +	WARN(count == 0, "timeout while leaving config mode");
> > +}
> > +
> > +static bool malidp500_in_config_mode(struct malidp_hw_device *hwdev)
> > +{
> > +	u32 status;
> > +
> > +	status = malidp_hw_read(hwdev, hwdev->map.dc_base + MALIDP_REG_STATUS);
> > +	if ((status & MALIDP500_DC_CONFIG_REQ) == MALIDP500_DC_CONFIG_REQ)
> > +		return true;
> > +
> > +	return false;
> > +}
> > +
> > +static void malidp500_set_config_valid(struct malidp_hw_device *hwdev)
> > +{
> > +	malidp_hw_setbits(hwdev, MALIDP_CFG_VALID, MALIDP500_CONFIG_VALID);
> > +}
> > +
> > +static void malidp500_modeset(struct malidp_hw_device *hwdev, struct videomode *mode)
> > +{
> > +	u32 val = 0;
> > +
> > +	malidp_hw_clearbits(hwdev, MALIDP500_DC_CLEAR_MASK, MALIDP500_DC_CONTROL);
> > +	if (mode->flags & DISPLAY_FLAGS_HSYNC_HIGH)
> > +		val |= MALIDP500_HSYNCPOL;
> > +	if (mode->flags & DISPLAY_FLAGS_VSYNC_HIGH)
> > +		val |= MALIDP500_VSYNCPOL;
> > +	val |= MALIDP_DE_DEFAULT_PREFETCH_START;
> > +	malidp_hw_setbits(hwdev, val, MALIDP500_DC_CONTROL);
> > +
> > +	/*
> > +	 * Mali-DP500 encodes the background color like this:
> > +	 *    - red   @ MALIDP500_BGND_COLOR[12:0]
> > +	 *    - green @ MALIDP500_BGND_COLOR[27:16]
> > +	 *    - blue  @ (MALIDP500_BGND_COLOR + 4)[12:0]
> > +	 */
> > +	val = ((MALIDP_BGND_COLOR_G & 0xfff) << 16) |
> > +	      (MALIDP_BGND_COLOR_R & 0xfff);
> > +	malidp_hw_write(hwdev, val, MALIDP500_BGND_COLOR);
> > +	malidp_hw_write(hwdev, MALIDP_BGND_COLOR_B, MALIDP500_BGND_COLOR + 4);
> > +
> > +	val = MALIDP_DE_H_FRONTPORCH(mode->hfront_porch) |
> > +		MALIDP_DE_H_BACKPORCH(mode->hback_porch);
> > +	malidp_hw_write(hwdev, val, MALIDP500_TIMINGS_BASE + MALIDP_DE_H_TIMINGS);
> > +
> > +	val = MALIDP500_DE_V_FRONTPORCH(mode->vfront_porch) |
> > +		MALIDP_DE_V_BACKPORCH(mode->vback_porch);
> > +	malidp_hw_write(hwdev, val, MALIDP500_TIMINGS_BASE + MALIDP_DE_V_TIMINGS);
> > +
> > +	val = MALIDP_DE_H_SYNCWIDTH(mode->hsync_len) |
> > +		MALIDP_DE_V_SYNCWIDTH(mode->vsync_len);
> > +	malidp_hw_write(hwdev, val, MALIDP500_TIMINGS_BASE + MALIDP_DE_SYNC_WIDTH);
> > +
> > +	val = MALIDP_DE_H_ACTIVE(mode->hactive) | MALIDP_DE_V_ACTIVE(mode->vactive);
> > +	malidp_hw_write(hwdev, val, MALIDP500_TIMINGS_BASE + MALIDP_DE_HV_ACTIVE);
> > +
> > +	if (mode->flags & DISPLAY_FLAGS_INTERLACED)
> > +		malidp_hw_setbits(hwdev, MALIDP_DISP_FUNC_ILACED, MALIDP_DE_DISPLAY_FUNC);
> > +	else
> > +		malidp_hw_clearbits(hwdev, MALIDP_DISP_FUNC_ILACED, MALIDP_DE_DISPLAY_FUNC);
> > +}
> > +
> > +static int malidp500_rotmem_required(struct malidp_hw_device *hwdev, u16 w, u16 h, u32 fmt)
> > +{
> > +	unsigned int depth;
> > +	int bpp;
> > +
> > +	/* RGB888 or BGR888 can't be rotated */
> > +	if ((fmt == DRM_FORMAT_RGB888) || (fmt == DRM_FORMAT_BGR888))
> > +		return -EINVAL;
> > +
> > +	/*
> > +	 * Each layer needs enough rotation memory to fit 8 lines
> > +	 * worth of pixel data. Required size is then:
> > +	 *    size = rotated_width * (bpp / 8) * 8;
> > +	 */
> > +	drm_fb_get_bpp_depth(fmt, &depth, &bpp);
> > +
> > +	return w * bpp;
> > +}
> > +
> > +static int malidp550_query_hw(struct malidp_hw_device *hwdev)
> > +{
> > +	u32 conf = malidp_hw_read(hwdev, MALIDP550_CONFIG_ID);
> > +	u8 ln_size = (conf >> 4) & 0x3, rsize;
> > +
> > +	hwdev->min_line_size = 2;
> > +
> > +	switch (ln_size) {
> > +	case 0:
> > +		hwdev->max_line_size = SZ_2K;
> > +		/* two banks of 64KB for rotation memory */
> > +		rsize = 64;
> > +		break;
> > +	case 1:
> > +		hwdev->max_line_size = SZ_4K;
> > +		/* two banks of 128KB for rotation memory */
> > +		rsize = 128;
> > +		break;
> > +	case 2:
> > +		hwdev->max_line_size = 1280;
> > +		/* two banks of 40KB for rotation memory */
> > +		rsize = 40;
> > +		break;
> > +	case 3:
> > +		/* reserved value */
> > +		hwdev->max_line_size = 0;
> > +		return -EINVAL;
> > +	}
> > +
> > +	hwdev->rotation_memory[0] = hwdev->rotation_memory[1] = rsize * SZ_1K;
> > +	return 0;
> > +}
> > +
> > +static void malidp550_enter_config_mode(struct malidp_hw_device *hwdev)
> > +{
> > +	u32 status, count = 100;
> > +
> > +	malidp_hw_setbits(hwdev, MALIDP550_DC_CONFIG_REQ, MALIDP550_DC_CONTROL);
> > +	while (count) {
> > +		status = malidp_hw_read(hwdev, hwdev->map.dc_base + MALIDP_REG_STATUS);
> > +		if ((status & MALIDP550_DC_CONFIG_REQ) == MALIDP550_DC_CONFIG_REQ)
> > +			break;
> > +		/*
> > +		 * entering config mode can take as long as the rendering
> > +		 * of a full frame, hence the long sleep here
> > +		 */
> > +		usleep_range(1000, 10000);
> > +		count--;
> > +	}
> > +	WARN(count == 0, "timeout while entering config mode");
> > +}
> > +
> > +static void malidp550_leave_config_mode(struct malidp_hw_device *hwdev)
> > +{
> > +	u32 status, count = 100;
> > +
> > +	malidp_hw_clearbits(hwdev, MALIDP550_DC_CONFIG_REQ, MALIDP550_DC_CONTROL);
> > +	while (count) {
> > +		status = malidp_hw_read(hwdev, hwdev->map.dc_base + MALIDP_REG_STATUS);
> > +		if ((status & MALIDP550_DC_CONFIG_REQ) == 0)
> > +			break;
> > +		usleep_range(100, 1000);
> > +		count--;
> > +	}
> > +	WARN(count == 0, "timeout while leaving config mode");
> > +}
> > +
> > +static bool malidp550_in_config_mode(struct malidp_hw_device *hwdev)
> > +{
> > +	u32 status;
> > +
> > +	status = malidp_hw_read(hwdev, hwdev->map.dc_base + MALIDP_REG_STATUS);
> > +	if ((status & MALIDP550_DC_CONFIG_REQ) == MALIDP550_DC_CONFIG_REQ)
> > +		return true;
> > +
> > +	return false;
> > +}
> > +
> > +static void malidp550_set_config_valid(struct malidp_hw_device *hwdev)
> > +{
> > +	malidp_hw_setbits(hwdev, MALIDP_CFG_VALID, MALIDP550_CONFIG_VALID);
> > +}
> > +
> > +static void malidp550_modeset(struct malidp_hw_device *hwdev, struct videomode *mode)
> > +{
> > +	u32 val = MALIDP_DE_DEFAULT_PREFETCH_START;
> > +
> > +	malidp_hw_write(hwdev, val, MALIDP550_DE_CONTROL);
> > +	/*
> > +	 * Mali-DP550 and Mali-DP650 encode the background color like this:
> > +	 *   - red   @ MALIDP550_DE_BGND_COLOR[23:16]
> > +	 *   - green @ MALIDP550_DE_BGND_COLOR[15:8]
> > +	 *   - blue  @ MALIDP550_DE_BGND_COLOR[7:0]
> > +	 *
> > +	 * We need to truncate the least significant 4 bits from the default
> > +	 * MALIDP_BGND_COLOR_x values
> > +	 */
> > +	val = (((MALIDP_BGND_COLOR_R >> 4) & 0xff) << 16) |
> > +	      (((MALIDP_BGND_COLOR_G >> 4) & 0xff) << 8) |
> > +	      ((MALIDP_BGND_COLOR_B >> 4) & 0xff);
> > +	malidp_hw_write(hwdev, val, MALIDP550_DE_BGND_COLOR);
> > +
> > +	val = MALIDP_DE_H_FRONTPORCH(mode->hfront_porch) |
> > +		MALIDP_DE_H_BACKPORCH(mode->hback_porch);
> > +	malidp_hw_write(hwdev, val, MALIDP550_TIMINGS_BASE + MALIDP_DE_H_TIMINGS);
> > +
> > +	val = MALIDP550_DE_V_FRONTPORCH(mode->vfront_porch) |
> > +		MALIDP_DE_V_BACKPORCH(mode->vback_porch);
> > +	malidp_hw_write(hwdev, val, MALIDP550_TIMINGS_BASE + MALIDP_DE_V_TIMINGS);
> > +
> > +	val = MALIDP_DE_H_SYNCWIDTH(mode->hsync_len) |
> > +		MALIDP_DE_V_SYNCWIDTH(mode->vsync_len);
> > +	if (mode->flags & DISPLAY_FLAGS_HSYNC_HIGH)
> > +		val |= MALIDP550_HSYNCPOL;
> > +	if (mode->flags & DISPLAY_FLAGS_VSYNC_HIGH)
> > +		val |= MALIDP550_VSYNCPOL;
> > +	malidp_hw_write(hwdev, val, MALIDP550_TIMINGS_BASE + MALIDP_DE_SYNC_WIDTH);
> > +
> > +	val = MALIDP_DE_H_ACTIVE(mode->hactive) | MALIDP_DE_V_ACTIVE(mode->vactive);
> > +	malidp_hw_write(hwdev, val, MALIDP550_TIMINGS_BASE + MALIDP_DE_HV_ACTIVE);
> > +
> > +	if (mode->flags & DISPLAY_FLAGS_INTERLACED)
> > +		malidp_hw_setbits(hwdev, MALIDP_DISP_FUNC_ILACED, MALIDP_DE_DISPLAY_FUNC);
> > +	else
> > +		malidp_hw_clearbits(hwdev, MALIDP_DISP_FUNC_ILACED, MALIDP_DE_DISPLAY_FUNC);
> > +}
> > +
> > +static int malidp550_rotmem_required(struct malidp_hw_device *hwdev, u16 w, u16 h, u32 fmt)
> > +{
> > +	u32 bytes_per_col;
> > +
> > +	/* raw RGB888 or BGR888 can't be rotated */
> > +	if ((fmt == DRM_FORMAT_RGB888) || (fmt == DRM_FORMAT_BGR888))
> > +		return -EINVAL;
> > +
> > +	switch (fmt) {
> > +	/* 8 lines at 4 bytes per pixel */
> > +	case DRM_FORMAT_ARGB2101010:
> > +	case DRM_FORMAT_ABGR2101010:
> > +	case DRM_FORMAT_RGBA1010102:
> > +	case DRM_FORMAT_BGRA1010102:
> > +	case DRM_FORMAT_ARGB8888:
> > +	case DRM_FORMAT_ABGR8888:
> > +	case DRM_FORMAT_RGBA8888:
> > +	case DRM_FORMAT_BGRA8888:
> > +	case DRM_FORMAT_XRGB8888:
> > +	case DRM_FORMAT_XBGR8888:
> > +	case DRM_FORMAT_RGBX8888:
> > +	case DRM_FORMAT_BGRX8888:
> > +	case DRM_FORMAT_RGB888:
> > +	case DRM_FORMAT_BGR888:
> > +	/* 16 lines at 2 bytes per pixel */
> > +	case DRM_FORMAT_RGBA5551:
> > +	case DRM_FORMAT_ABGR1555:
> > +	case DRM_FORMAT_RGB565:
> > +	case DRM_FORMAT_BGR565:
> > +	case DRM_FORMAT_UYVY:
> > +	case DRM_FORMAT_YUYV:
> > +		bytes_per_col = 32;
> > +		break;
> > +	/* 16 lines at 1.5 bytes per pixel */
> > +	case DRM_FORMAT_NV12:
> > +	case DRM_FORMAT_YUV420:
> > +		bytes_per_col = 24;
> > +		break;
> > +	default:
> > +		return -EINVAL;
> > +	}
> > +
> > +	return w * bytes_per_col;
> > +}
> > +
> > +static int malidp650_query_hw(struct malidp_hw_device *hwdev)
> > +{
> > +	u32 conf = malidp_hw_read(hwdev, MALIDP550_CONFIG_ID);
> > +	u8 ln_size = (conf >> 4) & 0x3, rsize;
> > +
> > +	hwdev->min_line_size = 4;
> > +
> > +	switch (ln_size) {
> > +	case 0:
> > +	case 2:
> > +		/* reserved values */
> > +		hwdev->max_line_size = 0;
> > +		return -EINVAL;
> > +	case 1:
> > +		hwdev->max_line_size = SZ_4K;
> > +		/* two banks of 128KB for rotation memory */
> > +		rsize = 128;
> > +		break;
> > +	case 3:
> > +		hwdev->max_line_size = 2560;
> > +		/* two banks of 80KB for rotation memory */
> > +		rsize = 80;
> > +	}
> > +
> > +	hwdev->rotation_memory[0] = hwdev->rotation_memory[1] = rsize * SZ_1K;
> > +	return 0;
> > +}
> > +
> > +const struct malidp_hw_device malidp_device[MALIDP_MAX_DEVICES] = {
> > +	[MALIDP_500] = {
> > +		.map = {
> > +			.se_base = MALIDP500_SE_BASE,
> > +			.dc_base = MALIDP500_DC_BASE,
> > +			.out_depth_base = MALIDP500_OUTPUT_DEPTH,
> > +			.features = 0,	/* no CLEARIRQ register */
> > +			.n_layers = ARRAY_SIZE(malidp500_layers),
> > +			.layers = malidp500_layers,
> > +			.de_irq_map = {
> > +				.irq_mask = MALIDP_DE_IRQ_UNDERRUN |
> > +					    MALIDP500_DE_IRQ_AXI_ERR |
> > +					    MALIDP500_DE_IRQ_VSYNC |
> > +					    MALIDP500_DE_IRQ_GLOBAL,
> > +				.vsync_irq = MALIDP500_DE_IRQ_VSYNC,
> > +			},
> > +			.se_irq_map = {
> > +				.irq_mask = MALIDP500_SE_IRQ_CONF_MODE,
> > +				.vsync_irq = 0,
> > +			},
> > +			.dc_irq_map = {
> > +				.irq_mask = MALIDP500_DE_IRQ_CONF_VALID,
> > +				.vsync_irq = MALIDP500_DE_IRQ_CONF_VALID,
> > +			},
> > +			.input_formats = malidp500_de_formats,
> > +			.n_input_formats = ARRAY_SIZE(malidp500_de_formats),
> > +		},
> > +		.query_hw = malidp500_query_hw,
> > +		.enter_config_mode = malidp500_enter_config_mode,
> > +		.leave_config_mode = malidp500_leave_config_mode,
> > +		.in_config_mode = malidp500_in_config_mode,
> > +		.set_config_valid = malidp500_set_config_valid,
> > +		.modeset = malidp500_modeset,
> > +		.rotmem_required = malidp500_rotmem_required,
> > +	},
> > +	[MALIDP_550] = {
> > +		.map = {
> > +			.se_base = MALIDP550_SE_BASE,
> > +			.dc_base = MALIDP550_DC_BASE,
> > +			.out_depth_base = MALIDP550_DE_OUTPUT_DEPTH,
> > +			.features = MALIDP_REGMAP_HAS_CLEARIRQ,
> > +			.n_layers = ARRAY_SIZE(malidp550_layers),
> > +			.layers = malidp550_layers,
> > +			.de_irq_map = {
> > +				.irq_mask = MALIDP_DE_IRQ_UNDERRUN |
> > +					    MALIDP550_DE_IRQ_VSYNC,
> > +				.vsync_irq = MALIDP550_DE_IRQ_VSYNC,
> > +			},
> > +			.se_irq_map = {
> > +				.irq_mask = MALIDP550_SE_IRQ_EOW |
> > +					    MALIDP550_SE_IRQ_AXI_ERR,
> > +			},
> > +			.dc_irq_map = {
> > +				.irq_mask = MALIDP550_DC_IRQ_CONF_VALID,
> > +				.vsync_irq = MALIDP550_DC_IRQ_CONF_VALID,
> > +			},
> > +			.input_formats = malidp550_de_formats,
> > +			.n_input_formats = ARRAY_SIZE(malidp550_de_formats),
> > +		},
> > +		.query_hw = malidp550_query_hw,
> > +		.enter_config_mode = malidp550_enter_config_mode,
> > +		.leave_config_mode = malidp550_leave_config_mode,
> > +		.in_config_mode = malidp550_in_config_mode,
> > +		.set_config_valid = malidp550_set_config_valid,
> > +		.modeset = malidp550_modeset,
> > +		.rotmem_required = malidp550_rotmem_required,
> > +	},
> > +	[MALIDP_650] = {
> > +		.map = {
> > +			.se_base = MALIDP550_SE_BASE,
> > +			.dc_base = MALIDP550_DC_BASE,
> > +			.out_depth_base = MALIDP550_DE_OUTPUT_DEPTH,
> > +			.features = MALIDP_REGMAP_HAS_CLEARIRQ,
> > +			.n_layers = ARRAY_SIZE(malidp550_layers),
> > +			.layers = malidp550_layers,
> > +			.de_irq_map = {
> > +				.irq_mask = MALIDP_DE_IRQ_UNDERRUN |
> > +					    MALIDP650_DE_IRQ_DRIFT |
> > +					    MALIDP550_DE_IRQ_VSYNC,
> > +				.vsync_irq = MALIDP550_DE_IRQ_VSYNC,
> > +			},
> > +			.se_irq_map = {
> > +				.irq_mask = MALIDP550_SE_IRQ_EOW |
> > +					    MALIDP550_SE_IRQ_AXI_ERR,
> > +			},
> > +			.dc_irq_map = {
> > +				.irq_mask = MALIDP550_DC_IRQ_CONF_VALID,
> > +				.vsync_irq = MALIDP550_DC_IRQ_CONF_VALID,
> > +			},
> > +			.input_formats = malidp550_de_formats,
> > +			.n_input_formats = ARRAY_SIZE(malidp550_de_formats),
> > +		},
> > +		.query_hw = malidp650_query_hw,
> > +		.enter_config_mode = malidp550_enter_config_mode,
> > +		.leave_config_mode = malidp550_leave_config_mode,
> > +		.in_config_mode = malidp550_in_config_mode,
> > +		.set_config_valid = malidp550_set_config_valid,
> > +		.modeset = malidp550_modeset,
> > +		.rotmem_required = malidp550_rotmem_required,
> > +	},
> > +};
> > +
> > +u8 malidp_hw_get_format_id(const struct malidp_hw_regmap *map,
> > +			   u8 layer_id, u32 format)
> > +{
> > +	unsigned int i;
> > +
> > +	for (i = 0; i < map->n_input_formats; i++) {
> > +		if (((map->input_formats[i].layer & layer_id) == layer_id) &&
> > +		    (map->input_formats[i].format == format))
> > +			return map->input_formats[i].id;
> > +	}
> > +
> > +	return MALIDP_INVALID_FORMAT_ID;
> > +}
> > +
> > +static void malidp_hw_clear_irq(struct malidp_hw_device *hwdev, u8 block, u32 irq)
> > +{
> > +	u32 base = malidp_get_block_base(hwdev, block);
> > +
> > +	if (hwdev->map.features & MALIDP_REGMAP_HAS_CLEARIRQ)
> > +		malidp_hw_write(hwdev, irq, base + MALIDP_REG_CLEARIRQ);
> > +	else
> > +		malidp_hw_write(hwdev, irq, base + MALIDP_REG_STATUS);
> > +}
> > +
> > +static irqreturn_t malidp_de_irq(int irq, void *arg)
> > +{
> > +	struct drm_device *drm = arg;
> > +	struct malidp_drm *malidp = drm->dev_private;
> > +	struct malidp_hw_device *hwdev;
> > +	const struct malidp_irq_map *de;
> > +	u32 status, mask, dc_status;
> > +	irqreturn_t ret = IRQ_NONE;
> > +
> > +	if (!drm->dev_private)
> > +		return IRQ_HANDLED;
> > +
> > +	hwdev = malidp->dev;
> > +	de = &hwdev->map.de_irq_map;
> > +
> > +	/* first handle the config valid IRQ */
> > +	dc_status = malidp_hw_read(hwdev, hwdev->map.dc_base + MALIDP_REG_STATUS);
> > +	if (dc_status & hwdev->map.dc_irq_map.vsync_irq) {
> > +		/* we have a page flip event */
> > +		atomic_set(&malidp->config_valid, 1);
> > +		malidp_hw_clear_irq(hwdev, MALIDP_DC_BLOCK, dc_status);
> > +		ret = IRQ_WAKE_THREAD;
> > +	}
> > +
> > +	status = malidp_hw_read(hwdev, MALIDP_REG_STATUS);
> > +	if (!(status & de->irq_mask))
> > +		return ret;
> > +
> > +	mask = malidp_hw_read(hwdev, MALIDP_REG_MASKIRQ);
> > +	status &= mask;
> > +	if (status & de->vsync_irq)
> > +		drm_crtc_handle_vblank(&malidp->crtc);
> > +
> > +	malidp_hw_clear_irq(hwdev, MALIDP_DE_BLOCK, status);
> > +
> > +	return (ret == IRQ_NONE) ? IRQ_HANDLED : ret;
> > +}
> > +
> > +static irqreturn_t malidp_de_irq_thread_handler(int irq, void *arg)
> > +{
> > +	struct drm_device *drm = arg;
> > +	struct malidp_drm *malidp = drm->dev_private;
> > +
> > +	wake_up(&malidp->wq);
> > +
> > +	return IRQ_HANDLED;
> > +}
> > +
> > +int malidp_de_irq_init(struct drm_device *drm, int irq)
> > +{
> > +	struct malidp_drm *malidp = drm->dev_private;
> > +	struct malidp_hw_device *hwdev = malidp->dev;
> > +	int ret;
> > +
> > +	/* ensure interrupts are disabled */
> > +	malidp_hw_disable_irq(hwdev, MALIDP_DE_BLOCK, 0xffffffff);
> > +	malidp_hw_clear_irq(hwdev, MALIDP_DE_BLOCK, 0xffffffff);
> > +	malidp_hw_disable_irq(hwdev, MALIDP_DC_BLOCK, 0xffffffff);
> > +	malidp_hw_clear_irq(hwdev, MALIDP_DC_BLOCK, 0xffffffff);
> > +
> > +	ret = devm_request_threaded_irq(drm->dev, irq, malidp_de_irq,
> > +					malidp_de_irq_thread_handler,
> > +					IRQF_SHARED, "malidp-de", drm);
> > +	if (ret < 0) {
> > +		DRM_ERROR("failed to install DE IRQ handler\n");
> > +		return ret;
> > +	}
> > +
> > +	/* first enable the DC block IRQs */
> > +	malidp_hw_enable_irq(hwdev, MALIDP_DC_BLOCK,
> > +			     hwdev->map.dc_irq_map.irq_mask);
> > +
> > +	/* now enable the DE block IRQs */
> > +	malidp_hw_enable_irq(hwdev, MALIDP_DE_BLOCK,
> > +			     hwdev->map.de_irq_map.irq_mask);
> > +
> > +	return 0;
> > +}
> > +
> > +void malidp_de_irq_fini(struct drm_device *drm)
> > +{
> > +	struct malidp_drm *malidp = drm->dev_private;
> > +	struct malidp_hw_device *hwdev = malidp->dev;
> > +
> > +	malidp_hw_disable_irq(hwdev, MALIDP_DE_BLOCK,
> > +			      hwdev->map.de_irq_map.irq_mask);
> > +	malidp_hw_disable_irq(hwdev, MALIDP_DC_BLOCK,
> > +			      hwdev->map.dc_irq_map.irq_mask);
> > +}
> > +
> > +static irqreturn_t malidp_se_irq(int irq, void *arg)
> > +{
> > +	struct drm_device *drm = arg;
> > +	struct malidp_drm *malidp = drm->dev_private;
> > +	struct malidp_hw_device *hwdev = malidp->dev;
> > +	u32 status, mask;
> > +
> > +	status = malidp_hw_read(hwdev, hwdev->map.se_base + MALIDP_REG_STATUS);
> > +	if (!(status & hwdev->map.se_irq_map.irq_mask))
> > +		return IRQ_NONE;
> > +
> > +	mask = malidp_hw_read(hwdev, hwdev->map.se_base + MALIDP_REG_MASKIRQ);
> > +	status = malidp_hw_read(hwdev, hwdev->map.se_base + MALIDP_REG_STATUS);
> > +	status &= mask;
> > +	/* ToDo: status decoding and firing up of VSYNC and page flip events */
> > +
> > +	malidp_hw_clear_irq(hwdev, MALIDP_SE_BLOCK, status);
> > +
> > +	return IRQ_HANDLED;
> > +}
> > +
> > +static irqreturn_t malidp_se_irq_thread_handler(int irq, void *arg)
> > +{
> > +	return IRQ_HANDLED;
> > +}
> > +
> > +int malidp_se_irq_init(struct drm_device *drm, int irq)
> > +{
> > +	struct malidp_drm *malidp = drm->dev_private;
> > +	struct malidp_hw_device *hwdev = malidp->dev;
> > +	int ret;
> > +
> > +	/* ensure interrupts are disabled */
> > +	malidp_hw_disable_irq(hwdev, MALIDP_SE_BLOCK, 0xffffffff);
> > +	malidp_hw_clear_irq(hwdev, MALIDP_SE_BLOCK, 0xffffffff);
> > +
> > +	ret = devm_request_threaded_irq(drm->dev, irq, malidp_se_irq,
> > +					malidp_se_irq_thread_handler,
> > +					IRQF_SHARED, "malidp-se", drm);
> > +	if (ret < 0) {
> > +		DRM_ERROR("failed to install SE IRQ handler\n");
> > +		return ret;
> > +	}
> > +
> > +	malidp_hw_enable_irq(hwdev, MALIDP_SE_BLOCK,
> > +			     hwdev->map.se_irq_map.irq_mask);
> > +
> > +	return 0;
> > +}
> > +
> > +void malidp_se_irq_fini(struct drm_device *drm)
> > +{
> > +	struct malidp_drm *malidp = drm->dev_private;
> > +	struct malidp_hw_device *hwdev = malidp->dev;
> > +
> > +	malidp_hw_disable_irq(hwdev, MALIDP_SE_BLOCK,
> > +			      hwdev->map.se_irq_map.irq_mask);
> > +}
> > diff --git a/drivers/gpu/drm/arm/malidp_hw.h b/drivers/gpu/drm/arm/malidp_hw.h
> > new file mode 100644
> > index 0000000..141743e
> > --- /dev/null
> > +++ b/drivers/gpu/drm/arm/malidp_hw.h
> > @@ -0,0 +1,241 @@
> > +/*
> > + *
> > + * (C) COPYRIGHT 2013-2016 ARM Limited. All rights reserved.
> > + *
> > + * This program is free software and is provided to you under the terms of the
> > + * GNU General Public License version 2 as published by the Free Software
> > + * Foundation, and any use by you of this program is subject to the terms
> > + * of such GNU licence.
> > + *
> > + * ARM Mali DP hardware manipulation routines.
> > + */
> > +
> > +#ifndef __MALIDP_HW_H__
> > +#define __MALIDP_HW_H__
> > +
> > +#include <linux/bitops.h>
> > +#include "malidp_regs.h"
> > +
> > +struct videomode;
> > +struct clk;
> > +
> > +/* Mali DP IP blocks */
> > +enum {
> > +	MALIDP_DE_BLOCK = 0,
> > +	MALIDP_SE_BLOCK,
> > +	MALIDP_DC_BLOCK
> > +};
> > +
> > +/* Mali DP layer IDs */
> > +enum {
> > +	DE_VIDEO1 = BIT(0),
> > +	DE_GRAPHICS1 = BIT(1),
> > +	DE_GRAPHICS2 = BIT(2), /* used only in DP500 */
> > +	DE_VIDEO2 = BIT(3),
> > +	DE_SMART = BIT(4),
> > +};
> > +
> > +struct malidp_input_format {
> > +	u32 format;		/* DRM fourcc */
> > +	u8 layer;		/* bitmask of layers supporting it */
> > +	u8 id;			/* used internally */
> > +};
> > +
> > +#define MALIDP_INVALID_FORMAT_ID	0xff
> > +
> > +/*
> > + * hide the differences between register maps
> > + * by using a common structure to hold the
> > + * base register offsets
> > + */
> > +
> > +struct malidp_irq_map {
> > +	u32 irq_mask;		/* mask of IRQs that can be enabled in the block */
> > +	u32 vsync_irq;		/* IRQ bit used for signaling during VSYNC */
> > +};
> > +
> > +struct malidp_layer {
> > +	u16 id;			/* layer ID */
> > +	u16 base;		/* address offset for the register bank */
> > +	u16 ptr;		/* address offset for the pointer register */
> > +};
> > +
> > +/* regmap features */
> > +#define MALIDP_REGMAP_HAS_CLEARIRQ	(1 << 0)
> > +
> > +struct malidp_hw_regmap {
> > +	/* address offset of the DE register bank */
> > +	/* is always 0x0000 */
> > +	/* address offset of the SE registers bank */
> > +	const u16 se_base;
> > +	/* address offset of the DC registers bank */
> > +	const u16 dc_base;
> > +
> > +	/* address offset for the output depth register */
> > +	const u16 out_depth_base;
> > +
> > +	/* bitmap with register map features */
> > +	const u8 features;
> > +
> > +	/* list of supported layers */
> > +	const u8 n_layers;
> > +	const struct malidp_layer *layers;
> > +
> > +	const struct malidp_irq_map de_irq_map;
> > +	const struct malidp_irq_map se_irq_map;
> > +	const struct malidp_irq_map dc_irq_map;
> > +
> > +	/* list of supported input formats for each layer */
> > +	const struct malidp_input_format *input_formats;
> > +	const u8 n_input_formats;
> > +};
> > +
> > +struct malidp_hw_device {
> > +	const struct malidp_hw_regmap map;
> > +	void __iomem *regs;
> > +
> > +	/* APB clock */
> > +	struct clk *pclk;
> > +	/* AXI clock */
> > +	struct clk *aclk;
> > +	/* main clock for display core */
> > +	struct clk *mclk;
> > +	/* pixel clock for display core */
> > +	struct clk *pxlclk;
> > +
> > +	/*
> > +	 * Validate the driver instance against the hardware bits
> > +	 */
> > +	int (*query_hw)(struct malidp_hw_device *hwdev);
> > +
> > +	/*
> > +	 * Set the hardware into config mode, ready to accept mode changes
> > +	 */
> > +	void (*enter_config_mode)(struct malidp_hw_device *hwdev);
> > +
> > +	/*
> > +	 * Tell hardware to exit configuration mode
> > +	 */
> > +	void (*leave_config_mode)(struct malidp_hw_device *hwdev);
> > +
> > +	/*
> > +	 * Query if hardware is in configuration mode
> > +	 */
> > +	bool (*in_config_mode)(struct malidp_hw_device *hwdev);
> > +
> > +	/*
> > +	 * Set configuration valid flag for hardware parameters that can
> > +	 * be changed outside the configuration mode. Hardware will use
> > +	 * the new settings when config valid is set after the end of the
> > +	 * current buffer scanout
> > +	 */
> > +	void (*set_config_valid)(struct malidp_hw_device *hwdev);
> > +
> > +	/*
> > +	 * Set a new mode in hardware. Requires the hardware to be in
> > +	 * configuration mode before this function is called.
> > +	 */
> > +	void (*modeset)(struct malidp_hw_device *hwdev, struct videomode *m);
> > +
> > +	/*
> > +	 * Calculate the required rotation memory given the active area
> > +	 * and the buffer format.
> > +	 */
> > +	int (*rotmem_required)(struct malidp_hw_device *hwdev, u16 w, u16 h, u32 fmt);
> > +
> > +	u8 features;
> > +
> > +	u8 min_line_size;
> > +	u16 max_line_size;
> > +
> > +	/* size of memory used for rotating layers, up to two banks available */
> > +	u32 rotation_memory[2];
> > +};
> > +
> > +/* Supported variants of the hardware */
> > +enum {
> > +	MALIDP_500 = 0,
> > +	MALIDP_550,
> > +	MALIDP_650,
> > +	/* keep the next entry last */
> > +	MALIDP_MAX_DEVICES
> > +};
> > +
> > +extern const struct malidp_hw_device malidp_device[MALIDP_MAX_DEVICES];
> > +
> > +static inline u32 malidp_hw_read(struct malidp_hw_device *hwdev, u32 reg)
> > +{
> > +	return readl(hwdev->regs + reg);
> > +}
> > +
> > +static inline void malidp_hw_write(struct malidp_hw_device *hwdev,
> > +				   u32 value, u32 reg)
> > +{
> > +	writel(value, hwdev->regs + reg);
> > +}
> > +
> > +static inline void malidp_hw_setbits(struct malidp_hw_device *hwdev,
> > +				     u32 mask, u32 reg)
> > +{
> > +	u32 data = malidp_hw_read(hwdev, reg);
> > +
> > +	data |= mask;
> > +	malidp_hw_write(hwdev, data, reg);
> > +}
> > +
> > +static inline void malidp_hw_clearbits(struct malidp_hw_device *hwdev,
> > +				       u32 mask, u32 reg)
> > +{
> > +	u32 data = malidp_hw_read(hwdev, reg);
> > +
> > +	data &= ~mask;
> > +	malidp_hw_write(hwdev, data, reg);
> > +}
> > +
> > +static inline u32 malidp_get_block_base(struct malidp_hw_device *hwdev,
> > +					u8 block)
> > +{
> > +	switch (block) {
> > +	case MALIDP_SE_BLOCK:
> > +		return hwdev->map.se_base;
> > +	case MALIDP_DC_BLOCK:
> > +		return hwdev->map.dc_base;
> > +	}
> > +
> > +	return 0;
> > +}
> > +
> > +static inline void malidp_hw_disable_irq(struct malidp_hw_device *hwdev,
> > +					 u8 block, u32 irq)
> > +{
> > +	u32 base = malidp_get_block_base(hwdev, block);
> > +
> > +	malidp_hw_clearbits(hwdev, irq, base + MALIDP_REG_MASKIRQ);
> > +}
> > +
> > +static inline void malidp_hw_enable_irq(struct malidp_hw_device *hwdev,
> > +					u8 block, u32 irq)
> > +{
> > +	u32 base = malidp_get_block_base(hwdev, block);
> > +
> > +	malidp_hw_setbits(hwdev, irq, base + MALIDP_REG_MASKIRQ);
> > +}
> > +
> > +int malidp_de_irq_init(struct drm_device *drm, int irq);
> > +void malidp_de_irq_fini(struct drm_device *drm);
> > +int malidp_se_irq_init(struct drm_device *drm, int irq);
> > +void malidp_se_irq_fini(struct drm_device *drm);
> > +
> > +u8 malidp_hw_get_format_id(const struct malidp_hw_regmap *map,
> > +			   u8 layer_id, u32 format);
> > +
> > +/*
> > + * background color components are defined as 12bits values,
> > + * they will be shifted right when stored on hardware that
> > + * supports only 8bits per channel
> > + */
> > +#define MALIDP_BGND_COLOR_R		0x000
> > +#define MALIDP_BGND_COLOR_G		0x000
> > +#define MALIDP_BGND_COLOR_B		0x000
> > +
> > +#endif  /* __MALIDP_HW_H__ */
> > diff --git a/drivers/gpu/drm/arm/malidp_planes.c b/drivers/gpu/drm/arm/malidp_planes.c
> > new file mode 100644
> > index 0000000..725098d
> > --- /dev/null
> > +++ b/drivers/gpu/drm/arm/malidp_planes.c
> > @@ -0,0 +1,298 @@
> > +/*
> > + * (C) COPYRIGHT 2016 ARM Limited. All rights reserved.
> > + * Author: Liviu Dudau <Liviu.Dudau@arm.com>
> > + *
> > + * This program is free software and is provided to you under the terms of the
> > + * GNU General Public License version 2 as published by the Free Software
> > + * Foundation, and any use by you of this program is subject to the terms
> > + * of such GNU licence.
> > + *
> > + * ARM Mali DP plane manipulation routines.
> > + */
> > +
> > +#include <drm/drmP.h>
> > +#include <drm/drm_atomic_helper.h>
> > +#include <drm/drm_fb_cma_helper.h>
> > +#include <drm/drm_gem_cma_helper.h>
> > +#include <drm/drm_plane_helper.h>
> > +
> > +#include "malidp_hw.h"
> > +#include "malidp_drv.h"
> > +
> > +/* Layer specific register offsets */
> > +#define MALIDP_LAYER_FORMAT		0x000
> > +#define MALIDP_LAYER_CONTROL		0x004
> > +#define   LAYER_ENABLE			(1 << 0)
> > +#define   LAYER_ROT_OFFSET		8
> > +#define   LAYER_H_FLIP			(1 << 10)
> > +#define   LAYER_V_FLIP			(1 << 11)
> > +#define   LAYER_ROT_MASK		(0xf << 8)
> > +#define MALIDP_LAYER_SIZE		0x00c
> > +#define   LAYER_H_VAL(x)		(((x) & 0x1fff) << 0)
> > +#define   LAYER_V_VAL(x)		(((x) & 0x1fff) << 16)
> > +#define MALIDP_LAYER_COMP_SIZE		0x010
> > +#define MALIDP_LAYER_OFFSET		0x014
> > +#define MALIDP_LAYER_STRIDE		0x018
> > +
> > +static void malidp_de_plane_destroy(struct drm_plane *plane)
> > +{
> > +	struct malidp_plane *mp = to_malidp_plane(plane);
> > +
> > +	if (mp->base.fb)
> > +		drm_framebuffer_unreference(mp->base.fb);
> > +
> > +	drm_plane_helper_disable(plane);
> > +	drm_plane_cleanup(plane);
> > +	devm_kfree(plane->dev->dev, mp);
> > +}
> > +
> > +struct drm_plane_state *malidp_duplicate_plane_state(struct drm_plane *plane)
> > +{
> > +	struct malidp_plane_state *state, *m_state;
> > +
> > +	if (!plane->state)
> > +		return NULL;
> > +
> > +	state = kmalloc(sizeof(*state), GFP_KERNEL);
> > +	if (state) {
> > +		m_state = to_malidp_plane_state(plane->state);
> > +		__drm_atomic_helper_plane_duplicate_state(plane, &state->base);
> > +		state->rotmem_size = m_state->rotmem_size;
> > +	}
> > +
> > +	return &state->base;
> > +}
> > +
> > +void malidp_destroy_plane_state(struct drm_plane *plane,
> > +				struct drm_plane_state *state)
> > +{
> > +	struct malidp_plane_state *m_state = to_malidp_plane_state(state);
> > +
> > +	__drm_atomic_helper_plane_destroy_state(state);
> > +	kfree(m_state);
> > +}
> > +
> > +static const struct drm_plane_funcs malidp_de_plane_funcs = {
> > +	.update_plane = drm_atomic_helper_update_plane,
> > +	.disable_plane = drm_atomic_helper_disable_plane,
> > +	.destroy = malidp_de_plane_destroy,
> > +	.reset = drm_atomic_helper_plane_reset,
> > +	.atomic_duplicate_state = malidp_duplicate_plane_state,
> > +	.atomic_destroy_state = malidp_destroy_plane_state,
> > +};
> > +
> > +static int malidp_de_plane_check(struct drm_plane *plane,
> > +				 struct drm_plane_state *state)
> > +{
> > +	struct malidp_plane *mp = to_malidp_plane(plane);
> > +	struct malidp_plane_state *ms = to_malidp_plane_state(state);
> > +	u8 format_id;
> > +	u32 src_w, src_h;
> > +
> > +	if (!state->crtc || !state->fb)
> > +		return 0;
> > +
> > +	format_id = malidp_hw_get_format_id(&mp->hwdev->map, mp->layer->id,
> > +					    state->fb->pixel_format);
> > +	if (format_id == MALIDP_INVALID_FORMAT_ID)
> > +		return -EINVAL;
> > +
> > +	src_w = state->src_w >> 16;
> > +	src_h = state->src_h >> 16;
> > +
> > +	if ((state->crtc_w > mp->hwdev->max_line_size) ||
> > +	    (state->crtc_h > mp->hwdev->max_line_size) ||
> > +	    (state->crtc_w < mp->hwdev->min_line_size) ||
> > +	    (state->crtc_h < mp->hwdev->min_line_size) ||
> > +	    (state->crtc_w != src_w) || (state->crtc_h != src_h))
> > +		return -EINVAL;
> > +
> > +	/* packed RGB888 / BGR888 can't be rotated or flipped */
> > +	if (state->rotation != BIT(DRM_ROTATE_0) &&
> > +	    (state->fb->pixel_format == DRM_FORMAT_RGB888 ||
> > +	     state->fb->pixel_format == DRM_FORMAT_BGR888))
> > +		return -EINVAL;
> > +
> > +	ms->rotmem_size = 0;
> > +	if (state->rotation & MALIDP_ROTATED_MASK) {
> > +		int val;
> > +
> > +		val = mp->hwdev->rotmem_required(mp->hwdev, state->crtc_h,
> > +						 state->crtc_w,
> > +						 state->fb->pixel_format);
> > +		if (val < 0)
> > +			return val;
> > +
> > +		ms->rotmem_size = val;
> > +	}
> > +
> > +	return 0;
> > +}
> > +
> > +static void malidp_de_plane_update(struct drm_plane *plane,
> > +				   struct drm_plane_state *old_state)
> > +{
> > +	struct drm_gem_cma_object *obj;
> > +	struct malidp_plane *mp;
> > +	const struct malidp_hw_regmap *map;
> > +	u8 format_id;
> > +	u16 ptr;
> > +	u32 format, src_w, src_h, dest_w, dest_h, val = 0;
> > +	int num_planes, i;
> > +
> > +	mp = to_malidp_plane(plane);
> > +
> > +	map = &mp->hwdev->map;
> > +	format = plane->state->fb->pixel_format;
> > +	format_id = malidp_hw_get_format_id(map, mp->layer->id, format);
> > +	num_planes = drm_format_num_planes(format);
> > +
> > +	/* convert src values from Q16 fixed point to integer */
> > +	src_w = plane->state->src_w >> 16;
> > +	src_h = plane->state->src_h >> 16;
> > +	if (plane->state->rotation & MALIDP_ROTATED_MASK) {
> > +		dest_w = plane->state->crtc_h;
> > +		dest_h = plane->state->crtc_w;
> > +	} else {
> > +		dest_w = plane->state->crtc_w;
> > +		dest_h = plane->state->crtc_h;
> > +	}
> > +
> > +	malidp_hw_write(mp->hwdev, format_id, mp->layer->base);
> > +
> > +	for (i = 0; i < num_planes; i++) {
> > +		/* calculate the offset for the layer's plane registers */
> > +		ptr = mp->layer->ptr + (i << 4);
> > +
> > +		obj = drm_fb_cma_get_gem_obj(plane->state->fb, i);
> > +		malidp_hw_write(mp->hwdev, lower_32_bits(obj->paddr), ptr);
> > +		malidp_hw_write(mp->hwdev, upper_32_bits(obj->paddr), ptr + 4);
> > +		malidp_hw_write(mp->hwdev, plane->state->fb->pitches[i],
> > +				mp->layer->base + MALIDP_LAYER_STRIDE);
> > +	}
> > +
> > +	malidp_hw_write(mp->hwdev, LAYER_H_VAL(src_w) | LAYER_V_VAL(src_h),
> > +			mp->layer->base + MALIDP_LAYER_SIZE);
> > +
> > +	malidp_hw_write(mp->hwdev, LAYER_H_VAL(dest_w) | LAYER_V_VAL(dest_h),
> > +			mp->layer->base + MALIDP_LAYER_COMP_SIZE);
> > +
> > +	malidp_hw_write(mp->hwdev, LAYER_H_VAL(plane->state->crtc_x) |
> > +			LAYER_V_VAL(plane->state->crtc_y),
> > +			mp->layer->base + MALIDP_LAYER_OFFSET);
> > +
> > +	/* first clear the rotation bits in the register */
> > +	malidp_hw_clearbits(mp->hwdev, LAYER_ROT_MASK,
> > +			    mp->layer->base + MALIDP_LAYER_CONTROL);
> > +
> > +	/* setup the rotation and axis flip bits */
> > +	if (plane->state->rotation & DRM_ROTATE_MASK)
> > +		val = ilog2(plane->state->rotation & DRM_ROTATE_MASK) << LAYER_ROT_OFFSET;
> > +	if (plane->state->rotation & BIT(DRM_REFLECT_X))
> > +		val |= LAYER_V_FLIP;
> > +	if (plane->state->rotation & BIT(DRM_REFLECT_Y))
> > +		val |= LAYER_H_FLIP;
> > +
> > +	/* set the 'enable layer' bit */
> > +	val |= LAYER_ENABLE;
> > +
> > +	malidp_hw_setbits(mp->hwdev, val,
> > +			  mp->layer->base + MALIDP_LAYER_CONTROL);
> > +}
> > +
> > +static void malidp_de_plane_disable(struct drm_plane *plane,
> > +				    struct drm_plane_state *state)
> > +{
> > +	struct malidp_plane *mp = to_malidp_plane(plane);
> > +
> > +	malidp_hw_clearbits(mp->hwdev, LAYER_ENABLE,
> > +			    mp->layer->base + MALIDP_LAYER_CONTROL);
> > +}
> > +
> > +static const struct drm_plane_helper_funcs malidp_de_plane_helper_funcs = {
> > +	.atomic_check = malidp_de_plane_check,
> > +	.atomic_update = malidp_de_plane_update,
> > +	.atomic_disable = malidp_de_plane_disable,
> > +};
> > +
> > +int malidp_de_planes_init(struct drm_device *drm)
> > +{
> > +	struct malidp_drm *malidp = drm->dev_private;
> > +	const struct malidp_hw_regmap *map = &malidp->dev->map;
> > +	struct malidp_plane *plane = NULL;
> > +	enum drm_plane_type plane_type;
> > +	unsigned long crtcs = 1 << drm->mode_config.num_crtc;
> > +	u32 *formats;
> > +	int ret, i, j, n;
> > +
> > +	formats = kcalloc(map->n_input_formats, sizeof(*formats), GFP_KERNEL);
> > +	if (!formats) {
> > +		ret = -ENOMEM;
> > +		goto cleanup;
> > +	}
> > +
> > +	for (i = 0; i < map->n_layers; i++) {
> > +		u8 id = map->layers[i].id;
> > +
> > +		plane = kzalloc(sizeof(*plane), GFP_KERNEL);
> > +		if (!plane) {
> > +			ret = -ENOMEM;
> > +			goto cleanup;
> > +		}
> > +
> > +		/* build the list of DRM supported formats based on the map */
> > +		for (n = 0, j = 0;  j < map->n_input_formats; j++) {
> > +			if ((map->input_formats[j].layer & id) == id)
> > +				formats[n++] = map->input_formats[j].format;
> > +		}
> > +
> > +		plane_type = (i == 0) ? DRM_PLANE_TYPE_PRIMARY :
> > +					DRM_PLANE_TYPE_OVERLAY;
> > +		ret = drm_universal_plane_init(drm, &plane->base, crtcs,
> > +					       &malidp_de_plane_funcs, formats,
> > +					       n, plane_type, NULL);
> > +		if (ret < 0)
> > +			goto cleanup;
> > +
> > +		if (!drm->mode_config.rotation_property) {
> > +			unsigned long flags = BIT(DRM_ROTATE_0) |
> > +					      BIT(DRM_ROTATE_90) |
> > +					      BIT(DRM_ROTATE_180) |
> > +					      BIT(DRM_ROTATE_270) |
> > +					      BIT(DRM_REFLECT_X) |
> > +					      BIT(DRM_REFLECT_Y);
> > +			drm->mode_config.rotation_property =
> > +				drm_mode_create_rotation_property(drm, flags);
> > +		}
> > +		/* SMART layer can't be rotated */
> > +		if (drm->mode_config.rotation_property && (id != DE_SMART))
> > +			drm_object_attach_property(&plane->base.base,
> > +						   drm->mode_config.rotation_property,
> > +						   BIT(DRM_ROTATE_0));
> > +
> > +		drm_plane_helper_add(&plane->base,
> > +				     &malidp_de_plane_helper_funcs);
> > +		plane->hwdev = malidp->dev;
> > +		plane->layer = &map->layers[i];
> > +	}
> > +
> > +	kfree(formats);
> > +
> > +	return 0;
> > +
> > +cleanup:
> > +	malidp_de_planes_destroy(drm);
> > +	kfree(formats);
> > +
> > +	return ret;
> > +}
> > +
> > +void malidp_de_planes_destroy(struct drm_device *drm)
> > +{
> > +	struct drm_plane *p, *pt;
> > +
> > +	list_for_each_entry_safe(p, pt, &drm->mode_config.plane_list, head) {
> > +		drm_plane_cleanup(p);
> > +		kfree(p);
> > +	}
> > +}
> > diff --git a/drivers/gpu/drm/arm/malidp_regs.h b/drivers/gpu/drm/arm/malidp_regs.h
> > new file mode 100644
> > index 0000000..73fecb3
> > --- /dev/null
> > +++ b/drivers/gpu/drm/arm/malidp_regs.h
> > @@ -0,0 +1,172 @@
> > +/*
> > + * (C) COPYRIGHT 2016 ARM Limited. All rights reserved.
> > + * Author: Liviu Dudau <Liviu.Dudau@arm.com>
> > + *
> > + * This program is free software and is provided to you under the terms of the
> > + * GNU General Public License version 2 as published by the Free Software
> > + * Foundation, and any use by you of this program is subject to the terms
> > + * of such GNU licence.
> > + *
> > + * ARM Mali DP500/DP550/DP650 registers definition.
> > + */
> > +
> > +#ifndef __MALIDP_REGS_H__
> > +#define __MALIDP_REGS_H__
> > +
> > +/*
> > + * abbreviations used:
> > + *    - DC - display core (general settings)
> > + *    - DE - display engine
> > + *    - SE - scaling engine
> > + */
> > +
> > +/* interrupt bit masks */
> > +#define MALIDP_DE_IRQ_UNDERRUN			(1 << 0)
> > +
> > +#define MALIDP500_DE_IRQ_AXI_ERR		(1 << 4)
> > +#define MALIDP500_DE_IRQ_VSYNC			(1 << 5)
> > +#define MALIDP500_DE_IRQ_PROG_LINE		(1 << 6)
> > +#define MALIDP500_DE_IRQ_SATURATION		(1 << 7)
> > +#define MALIDP500_DE_IRQ_CONF_VALID		(1 << 8)
> > +#define MALIDP500_DE_IRQ_CONF_MODE		(1 << 11)
> > +#define MALIDP500_DE_IRQ_CONF_ACTIVE		(1 << 17)
> > +#define MALIDP500_DE_IRQ_PM_ACTIVE		(1 << 18)
> > +#define MALIDP500_DE_IRQ_TESTMODE_ACTIVE	(1 << 19)
> > +#define MALIDP500_DE_IRQ_FORCE_BLNK_ACTIVE	(1 << 24)
> > +#define MALIDP500_DE_IRQ_AXI_BUSY		(1 << 28)
> > +#define MALIDP500_DE_IRQ_GLOBAL			(1 << 31)
> > +#define MALIDP500_SE_IRQ_CONF_MODE		(1 << 0)
> > +#define MALIDP500_SE_IRQ_CONF_VALID		(1 << 4)
> > +#define MALIDP500_SE_IRQ_INIT_BUSY		(1 << 5)
> > +#define MALIDP500_SE_IRQ_AXI_ERROR		(1 << 8)
> > +#define MALIDP500_SE_IRQ_OVERRUN		(1 << 9)
> > +#define MALIDP500_SE_IRQ_PROG_LINE1		(1 << 12)
> > +#define MALIDP500_SE_IRQ_PROG_LINE2		(1 << 13)
> > +#define MALIDP500_SE_IRQ_CONF_ACTIVE		(1 << 17)
> > +#define MALIDP500_SE_IRQ_PM_ACTIVE		(1 << 18)
> > +#define MALIDP500_SE_IRQ_AXI_BUSY		(1 << 28)
> > +#define MALIDP500_SE_IRQ_GLOBAL			(1 << 31)
> > +
> > +#define MALIDP550_DE_IRQ_SATURATION		(1 << 8)
> > +#define MALIDP550_DE_IRQ_VSYNC			(1 << 12)
> > +#define MALIDP550_DE_IRQ_PROG_LINE		(1 << 13)
> > +#define MALIDP550_DE_IRQ_AXI_ERR		(1 << 16)
> > +#define MALIDP550_SE_IRQ_EOW			(1 << 0)
> > +#define MALIDP550_SE_IRQ_AXI_ERR		(1 << 16)
> > +#define MALIDP550_DC_IRQ_CONF_VALID		(1 << 0)
> > +#define MALIDP550_DC_IRQ_CONF_MODE		(1 << 4)
> > +#define MALIDP550_DC_IRQ_CONF_ACTIVE		(1 << 16)
> > +#define MALIDP550_DC_IRQ_DE			(1 << 20)
> > +#define MALIDP550_DC_IRQ_SE			(1 << 24)
> > +
> > +#define MALIDP650_DE_IRQ_DRIFT			(1 << 4)
> > +
> > +/* bit masks that are common between products */
> > +#define   MALIDP_CFG_VALID		(1 << 0)
> > +#define   MALIDP_DISP_FUNC_ILACED	(1 << 8)
> > +
> > +/* register offsets for IRQ management */
> > +#define MALIDP_REG_STATUS		0x00000
> > +#define MALIDP_REG_SETIRQ		0x00004
> > +#define MALIDP_REG_MASKIRQ		0x00008
> > +#define MALIDP_REG_CLEARIRQ		0x0000c
> > +
> > +/* register offsets */
> > +#define MALIDP_DE_CORE_ID		0x00018
> > +#define MALIDP_DE_DISPLAY_FUNC		0x00020
> > +
> > +/* these offsets are relative to MALIDP5x0_TIMINGS_BASE */
> > +#define MALIDP_DE_H_TIMINGS		0x0
> > +#define MALIDP_DE_V_TIMINGS		0x4
> > +#define MALIDP_DE_SYNC_WIDTH		0x8
> > +#define MALIDP_DE_HV_ACTIVE		0xc
> > +
> > +/* macros to set values into registers */
> > +#define MALIDP_DE_H_FRONTPORCH(x)	(((x) & 0xfff) << 0)
> > +#define MALIDP_DE_H_BACKPORCH(x)	(((x) & 0x3ff) << 16)
> > +#define MALIDP500_DE_V_FRONTPORCH(x)	(((x) & 0xff) << 0)
> > +#define MALIDP550_DE_V_FRONTPORCH(x)	(((x) & 0xfff) << 0)
> > +#define MALIDP_DE_V_BACKPORCH(x)	(((x) & 0xff) << 16)
> > +#define MALIDP_DE_H_SYNCWIDTH(x)	(((x) & 0x3ff) << 0)
> > +#define MALIDP_DE_V_SYNCWIDTH(x)	(((x) & 0xff) << 16)
> > +#define MALIDP_DE_H_ACTIVE(x)		(((x) & 0x1fff) << 0)
> > +#define MALIDP_DE_V_ACTIVE(x)		(((x) & 0x1fff) << 16)
> > +
> > +/* register offsets and bits specific to DP500 */
> > +#define MALIDP500_DC_BASE		0x00000
> > +#define MALIDP500_DC_CONTROL		0x0000c
> > +#define   MALIDP500_DC_CONFIG_REQ	(1 << 17)
> > +#define   MALIDP500_HSYNCPOL		(1 << 20)
> > +#define   MALIDP500_VSYNCPOL		(1 << 21)
> > +#define   MALIDP500_DC_CLEAR_MASK	0x300fff
> > +#define MALIDP500_DE_LINE_COUNTER	0x00010
> > +#define MALIDP500_DE_AXI_CONTROL	0x00014
> > +#define MALIDP500_DE_SECURE_CTRL	0x0001c
> > +#define MALIDP500_DE_CHROMA_KEY		0x00024
> > +#define MALIDP500_TIMINGS_BASE		0x00028
> > +
> > +#define MALIDP500_CONFIG_3D		0x00038
> > +#define MALIDP500_BGND_COLOR		0x0003c
> > +#define MALIDP500_OUTPUT_DEPTH		0x00044
> > +#define MALIDP500_YUV_RGB_COEF		0x00048
> > +#define MALIDP500_COLOR_ADJ_COEF	0x00078
> > +#define MALIDP500_COEF_TABLE_ADDR	0x000a8
> > +#define MALIDP500_COEF_TABLE_DATA	0x000ac
> > +#define MALIDP500_DE_LV_BASE		0x00100
> > +#define MALIDP500_DE_LV_PTR_BASE	0x00124
> > +#define MALIDP500_DE_LG1_BASE		0x00200
> > +#define MALIDP500_DE_LG1_PTR_BASE	0x0021c
> > +#define MALIDP500_DE_LG2_BASE		0x00300
> > +#define MALIDP500_DE_LG2_PTR_BASE	0x0031c
> > +#define MALIDP500_SE_BASE		0x00c00
> > +#define MALIDP500_SE_PTR_BASE		0x00e0c
> > +#define MALIDP500_DC_IRQ_BASE		0x00f00
> > +#define MALIDP500_CONFIG_VALID		0x00f00
> > +#define MALIDP500_CONFIG_ID		0x00fd4
> > +
> > +/* register offsets and bits specific to DP550/DP650 */
> > +#define MALIDP550_DE_CONTROL		0x00010
> > +#define MALIDP550_DE_LINE_COUNTER	0x00014
> > +#define MALIDP550_DE_AXI_CONTROL	0x00018
> > +#define MALIDP550_DE_QOS		0x0001c
> > +#define MALIDP550_TIMINGS_BASE		0x00030
> > +#define MALIDP550_HSYNCPOL		(1 << 12)
> > +#define MALIDP550_VSYNCPOL		(1 << 28)
> > +
> > +#define MALIDP550_DE_DISP_SIDEBAND	0x00040
> > +#define MALIDP550_DE_BGND_COLOR		0x00044
> > +#define MALIDP550_DE_OUTPUT_DEPTH	0x0004c
> > +#define MALIDP550_DE_COLOR_COEF		0x00050
> > +#define MALIDP550_DE_COEF_TABLE_ADDR	0x00080
> > +#define MALIDP550_DE_COEF_TABLE_DATA	0x00084
> > +#define MALIDP550_DE_LV1_BASE		0x00100
> > +#define MALIDP550_DE_LV1_PTR_BASE	0x00124
> > +#define MALIDP550_DE_LV2_BASE		0x00200
> > +#define MALIDP550_DE_LV2_PTR_BASE	0x00224
> > +#define MALIDP550_DE_LG_BASE		0x00300
> > +#define MALIDP550_DE_LG_PTR_BASE	0x0031c
> > +#define MALIDP550_DE_LS_BASE		0x00400
> > +#define MALIDP550_DE_LS_PTR_BASE	0x0042c
> > +#define MALIDP550_DE_PERF_BASE		0x00500
> > +#define MALIDP550_SE_BASE		0x08000
> > +#define MALIDP550_DC_BASE		0x0c000
> > +#define MALIDP550_DC_CONTROL		0x0c010
> > +#define   MALIDP550_DC_CONFIG_REQ	(1 << 16)
> > +#define MALIDP550_CONFIG_VALID		0x0c014
> > +#define MALIDP550_CONFIG_ID		0x0ffd4
> > +
> > +/*
> > + * Starting with DP550 the register map blocks has been standardised to the
> > + * following layout:
> > + *
> > + *   Offset            Block registers
> > + *  0x00000            Display Engine
> > + *  0x08000            Scaling Engine
> > + *  0x0c000            Display Core
> > + *  0x10000            Secure control
> > + *
> > + * The old DP500 IP mixes some DC with the DE registers, hence the need
> > + * for a mapping structure.
> > + */
> > +
> > +#endif /* __MALIDP_REGS_H__ */
> > -- 
> > 2.8.2
> > 
> 
> -- 
> Daniel Vetter
> Software Engineer, Intel Corporation
> http://blog.ffwll.ch
> 

-- 
====================
| I would like to |
| fix the world,  |
| but they're not |
| giving me the   |
 \ source code!  /
  ---------------
    ¯\_(ツ)_/¯

From mboxrd@z Thu Jan  1 00:00:00 1970
From: Liviu Dudau <Liviu.Dudau@arm.com>
Subject: Re: [PATCH v5 2/3] drm/arm: Add support for Mali Display Processors
Date: Wed, 15 Jun 2016 17:17:58 +0100
Message-ID: <20160615161758.GF9711@e106497-lin.cambridge.arm.com>
References: <1466002295-24813-1-git-send-email-Liviu.Dudau@arm.com>
 <1466002295-24813-3-git-send-email-Liviu.Dudau@arm.com>
 <20160615152309.GI1338@phenom.ffwll.local>
Mime-Version: 1.0
Content-Type: text/plain; charset="utf-8"
Content-Transfer-Encoding: base64
Return-path: <dri-devel-bounces@lists.freedesktop.org>
Content-Disposition: inline
In-Reply-To: <20160615152309.GI1338@phenom.ffwll.local>
List-Unsubscribe: <https://lists.freedesktop.org/mailman/options/dri-devel>,
 <mailto:dri-devel-request@lists.freedesktop.org?subject=unsubscribe>
List-Archive: <https://lists.freedesktop.org/archives/dri-devel>
List-Post: <mailto:dri-devel@lists.freedesktop.org>
List-Help: <mailto:dri-devel-request@lists.freedesktop.org?subject=help>
List-Subscribe: <https://lists.freedesktop.org/mailman/listinfo/dri-devel>,
 <mailto:dri-devel-request@lists.freedesktop.org?subject=subscribe>
Errors-To: dri-devel-bounces@lists.freedesktop.org
Sender: "dri-devel" <dri-devel-bounces@lists.freedesktop.org>
To: David Airlie <airlied@linux.ie>, Rob Herring <robh+dt@kernel.org>, Brian Starkey <brian.starkey@arm.com>, Emil Velikov <emil.l.velikov@gmail.com>, devicetree <devicetree@vger.kernel.org>, DRI devel <dri-devel@lists.freedesktop.org>, LKML <linux-kernel@vger.kernel.org>, David Brown <David.Brown@arm.com>, LAKML <linux-arm-kernel@lists.infradead.org>
List-Id: devicetree@vger.kernel.org
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From mboxrd@z Thu Jan  1 00:00:00 1970
From: Liviu.Dudau@arm.com (Liviu Dudau)
Date: Wed, 15 Jun 2016 17:17:58 +0100
Subject: [PATCH v5 2/3] drm/arm: Add support for Mali Display Processors
In-Reply-To: <20160615152309.GI1338@phenom.ffwll.local>
References: <1466002295-24813-1-git-send-email-Liviu.Dudau@arm.com>
 <1466002295-24813-3-git-send-email-Liviu.Dudau@arm.com>
 <20160615152309.GI1338@phenom.ffwll.local>
Message-ID: <20160615161758.GF9711@e106497-lin.cambridge.arm.com>
To: linux-arm-kernel@lists.infradead.org
List-Id: linux-arm-kernel.lists.infradead.org

On Wed, Jun 15, 2016 at 05:23:10PM +0200, Daniel Vetter wrote:
> On Wed, Jun 15, 2016 at 03:51:34PM +0100, Liviu Dudau wrote:
> > Add support for the new family of Display Processors from ARM Ltd.
> > This commit adds basic support for Mali DP500, DP550 and DP650
> > parts, with only the display engine being supported at the moment.
> > 
> > Cc: David Brown <David.Brown@arm.com>
> > Cc: Brian Starkey <Brian.Starkey@arm.com>
> > 
> > Signed-off-by: Liviu Dudau <Liviu.Dudau@arm.com>
> 
> Small thing I noticed: drm_dev_register/connector_register_all should be
> the last step in your init code, and unregister the first. Atm it's
> somewhere in the middle. But perfectly fine to do that as a follow-up.

I've tried that, but the connector and encoder that gets registered as part
of the component_bind_all() fails if there is no drm dev registered. You did
comment on the v4 version about that and I did test your idea, sorry for
forgeting to update you on that.

> 
> Quickly scrolled through the driver, looks all nice.
> 
> Acked-by: Daniel Vetter <daniel.vetter@ffwll.ch>

And thanks for the Acked-by.

Best regards,
Liviu

> > ---
> >  drivers/gpu/drm/arm/Kconfig         |  16 +
> >  drivers/gpu/drm/arm/Makefile        |   2 +
> >  drivers/gpu/drm/arm/malidp_crtc.c   | 216 +++++++++++
> >  drivers/gpu/drm/arm/malidp_drv.c    | 512 ++++++++++++++++++++++++++
> >  drivers/gpu/drm/arm/malidp_drv.h    |  54 +++
> >  drivers/gpu/drm/arm/malidp_hw.c     | 691 ++++++++++++++++++++++++++++++++++++
> >  drivers/gpu/drm/arm/malidp_hw.h     | 241 +++++++++++++
> >  drivers/gpu/drm/arm/malidp_planes.c | 298 ++++++++++++++++
> >  drivers/gpu/drm/arm/malidp_regs.h   | 172 +++++++++
> >  9 files changed, 2202 insertions(+)
> >  create mode 100644 drivers/gpu/drm/arm/malidp_crtc.c
> >  create mode 100644 drivers/gpu/drm/arm/malidp_drv.c
> >  create mode 100644 drivers/gpu/drm/arm/malidp_drv.h
> >  create mode 100644 drivers/gpu/drm/arm/malidp_hw.c
> >  create mode 100644 drivers/gpu/drm/arm/malidp_hw.h
> >  create mode 100644 drivers/gpu/drm/arm/malidp_planes.c
> >  create mode 100644 drivers/gpu/drm/arm/malidp_regs.h
> > 
> > diff --git a/drivers/gpu/drm/arm/Kconfig b/drivers/gpu/drm/arm/Kconfig
> > index eaed454..1b29065 100644
> > --- a/drivers/gpu/drm/arm/Kconfig
> > +++ b/drivers/gpu/drm/arm/Kconfig
> > @@ -25,3 +25,19 @@ config DRM_HDLCD_SHOW_UNDERRUN
> >  	  Enable this option to show in red colour the pixels that the
> >  	  HDLCD device did not fetch from framebuffer due to underrun
> >  	  conditions.
> > +
> > +config DRM_MALI_DISPLAY
> > +	tristate "ARM Mali Display Processor"
> > +	depends on DRM && OF && (ARM || ARM64)
> > +	depends on COMMON_CLK
> > +	select DRM_ARM
> > +	select DRM_KMS_HELPER
> > +	select DRM_KMS_CMA_HELPER
> > +	select DRM_GEM_CMA_HELPER
> > +	select VIDEOMODE_HELPERS
> > +	help
> > +	  Choose this option if you want to compile the ARM Mali Display
> > +	  Processor driver. It supports the DP500, DP550 and DP650 variants
> > +	  of the hardware.
> > +
> > +	  If compiled as a module it will be called mali-dp.
> > diff --git a/drivers/gpu/drm/arm/Makefile b/drivers/gpu/drm/arm/Makefile
> > index 89dcb7b..bb8b158 100644
> > --- a/drivers/gpu/drm/arm/Makefile
> > +++ b/drivers/gpu/drm/arm/Makefile
> > @@ -1,2 +1,4 @@
> >  hdlcd-y := hdlcd_drv.o hdlcd_crtc.o
> >  obj-$(CONFIG_DRM_HDLCD)	+= hdlcd.o
> > +mali-dp-y := malidp_drv.o malidp_hw.o malidp_planes.o malidp_crtc.o
> > +obj-$(CONFIG_DRM_MALI_DISPLAY)	+= mali-dp.o
> > diff --git a/drivers/gpu/drm/arm/malidp_crtc.c b/drivers/gpu/drm/arm/malidp_crtc.c
> > new file mode 100644
> > index 0000000..08e6a71
> > --- /dev/null
> > +++ b/drivers/gpu/drm/arm/malidp_crtc.c
> > @@ -0,0 +1,216 @@
> > +/*
> > + * (C) COPYRIGHT 2016 ARM Limited. All rights reserved.
> > + * Author: Liviu Dudau <Liviu.Dudau@arm.com>
> > + *
> > + * This program is free software and is provided to you under the terms of the
> > + * GNU General Public License version 2 as published by the Free Software
> > + * Foundation, and any use by you of this program is subject to the terms
> > + * of such GNU licence.
> > + *
> > + * ARM Mali DP500/DP550/DP650 driver (crtc operations)
> > + */
> > +
> > +#include <drm/drmP.h>
> > +#include <drm/drm_atomic.h>
> > +#include <drm/drm_atomic_helper.h>
> > +#include <drm/drm_crtc.h>
> > +#include <drm/drm_crtc_helper.h>
> > +#include <linux/clk.h>
> > +#include <video/videomode.h>
> > +
> > +#include "malidp_drv.h"
> > +#include "malidp_hw.h"
> > +
> > +static bool malidp_crtc_mode_fixup(struct drm_crtc *crtc,
> > +				   const struct drm_display_mode *mode,
> > +				   struct drm_display_mode *adjusted_mode)
> > +{
> > +	struct malidp_drm *malidp = crtc_to_malidp_device(crtc);
> > +	struct malidp_hw_device *hwdev = malidp->dev;
> > +
> > +	/*
> > +	 * check that the hardware can drive the required clock rate,
> > +	 * but skip the check if the clock is meant to be disabled (req_rate = 0)
> > +	 */
> > +	long rate, req_rate = mode->crtc_clock * 1000;
> > +
> > +	if (req_rate) {
> > +		rate = clk_round_rate(hwdev->mclk, req_rate);
> > +		if (rate < req_rate) {
> > +			DRM_DEBUG_DRIVER("mclk clock unable to reach %d kHz\n",
> > +					 mode->crtc_clock);
> > +			return false;
> > +		}
> > +
> > +		rate = clk_round_rate(hwdev->pxlclk, req_rate);
> > +		if (rate != req_rate) {
> > +			DRM_DEBUG_DRIVER("pxlclk doesn't support %ld Hz\n",
> > +					 req_rate);
> > +			return false;
> > +		}
> > +	}
> > +
> > +	return true;
> > +}
> > +
> > +static void malidp_crtc_enable(struct drm_crtc *crtc)
> > +{
> > +	struct malidp_drm *malidp = crtc_to_malidp_device(crtc);
> > +	struct malidp_hw_device *hwdev = malidp->dev;
> > +	struct videomode vm;
> > +
> > +	drm_display_mode_to_videomode(&crtc->state->adjusted_mode, &vm);
> > +
> > +	clk_prepare_enable(hwdev->pxlclk);
> > +
> > +	/* mclk needs to be set to the same or higher rate than pxlclk */
> > +	clk_set_rate(hwdev->mclk, crtc->state->adjusted_mode.crtc_clock * 1000);
> > +	clk_set_rate(hwdev->pxlclk, crtc->state->adjusted_mode.crtc_clock * 1000);
> > +
> > +	hwdev->modeset(hwdev, &vm);
> > +	hwdev->leave_config_mode(hwdev);
> > +	drm_crtc_vblank_on(crtc);
> > +}
> > +
> > +static void malidp_crtc_disable(struct drm_crtc *crtc)
> > +{
> > +	struct malidp_drm *malidp = crtc_to_malidp_device(crtc);
> > +	struct malidp_hw_device *hwdev = malidp->dev;
> > +
> > +	drm_crtc_vblank_off(crtc);
> > +	hwdev->enter_config_mode(hwdev);
> > +	clk_disable_unprepare(hwdev->pxlclk);
> > +}
> > +
> > +static int malidp_crtc_atomic_check(struct drm_crtc *crtc,
> > +				    struct drm_crtc_state *state)
> > +{
> > +	struct malidp_drm *malidp = crtc_to_malidp_device(crtc);
> > +	struct malidp_hw_device *hwdev = malidp->dev;
> > +	struct drm_plane *plane;
> > +	const struct drm_plane_state *pstate;
> > +	u32 rot_mem_free, rot_mem_usable;
> > +	int rotated_planes = 0;
> > +
> > +	/*
> > +	 * check if there is enough rotation memory available for planes
> > +	 * that need 90? and 270? rotation. Each plane has set its required
> > +	 * memory size in the ->plane_check() callback, here we only make
> > +	 * sure that the sums are less that the total usable memory.
> > +	 *
> > +	 * The rotation memory allocation algorithm (for each plane):
> > +	 *  a. If no more rotated planes exist, all remaining rotate
> > +	 *     memory in the bank is available for use by the plane.
> > +	 *  b. If other rotated planes exist, and plane's layer ID is
> > +	 *     DE_VIDEO1, it can use all the memory from first bank if
> > +	 *     secondary rotation memory bank is available, otherwise it can
> > +	 *     use up to half the bank's memory.
> > +	 *  c. If other rotated planes exist, and plane's layer ID is not
> > +	 *     DE_VIDEO1, it can use half of the available memory
> > +	 *
> > +	 * Note: this algorithm assumes that the order in which the planes are
> > +	 * checked always has DE_VIDEO1 plane first in the list if it is
> > +	 * rotated. Because that is how we create the planes in the first
> > +	 * place, under current DRM version things work, but if ever the order
> > +	 * in which drm_atomic_crtc_state_for_each_plane() iterates over planes
> > +	 * changes, we need to pre-sort the planes before validation.
> > +	 */
> > +
> > +	/* first count the number of rotated planes */
> > +	drm_atomic_crtc_state_for_each_plane_state(plane, pstate, state) {
> > +		if (pstate->rotation & MALIDP_ROTATED_MASK)
> > +			rotated_planes++;
> > +	}
> > +
> > +	rot_mem_free = hwdev->rotation_memory[0];
> > +	/*
> > +	 * if we have more than 1 plane using rotation memory, use the second
> > +	 * block of rotation memory as well
> > +	 */
> > +	if (rotated_planes > 1)
> > +		rot_mem_free += hwdev->rotation_memory[1];
> > +
> > +	/* now validate the rotation memory requirements */
> > +	drm_atomic_crtc_state_for_each_plane_state(plane, pstate, state) {
> > +		struct malidp_plane *mp = to_malidp_plane(plane);
> > +		struct malidp_plane_state *ms = to_malidp_plane_state(pstate);
> > +
> > +		if (pstate->rotation & MALIDP_ROTATED_MASK) {
> > +			/* process current plane */
> > +			rotated_planes--;
> > +
> > +			if (!rotated_planes) {
> > +				/* no more rotated planes, we can use what's left */
> > +				rot_mem_usable = rot_mem_free;
> > +			} else {
> > +				if ((mp->layer->id != DE_VIDEO1) ||
> > +				    (hwdev->rotation_memory[1] == 0))
> > +					rot_mem_usable = rot_mem_free / 2;
> > +				else
> > +					rot_mem_usable = hwdev->rotation_memory[0];
> > +			}
> > +
> > +			rot_mem_free -= rot_mem_usable;
> > +
> > +			if (ms->rotmem_size > rot_mem_usable)
> > +				return -EINVAL;
> > +		}
> > +	}
> > +
> > +	return 0;
> > +}
> > +
> > +static const struct drm_crtc_helper_funcs malidp_crtc_helper_funcs = {
> > +	.mode_fixup = malidp_crtc_mode_fixup,
> > +	.enable = malidp_crtc_enable,
> > +	.disable = malidp_crtc_disable,
> > +	.atomic_check = malidp_crtc_atomic_check,
> > +};
> > +
> > +static const struct drm_crtc_funcs malidp_crtc_funcs = {
> > +	.destroy = drm_crtc_cleanup,
> > +	.set_config = drm_atomic_helper_set_config,
> > +	.page_flip = drm_atomic_helper_page_flip,
> > +	.reset = drm_atomic_helper_crtc_reset,
> > +	.atomic_duplicate_state = drm_atomic_helper_crtc_duplicate_state,
> > +	.atomic_destroy_state = drm_atomic_helper_crtc_destroy_state,
> > +};
> > +
> > +int malidp_crtc_init(struct drm_device *drm)
> > +{
> > +	struct malidp_drm *malidp = drm->dev_private;
> > +	struct drm_plane *primary = NULL, *plane;
> > +	int ret;
> > +
> > +	ret = malidp_de_planes_init(drm);
> > +	if (ret < 0) {
> > +		DRM_ERROR("Failed to initialise planes\n");
> > +		return ret;
> > +	}
> > +
> > +	drm_for_each_plane(plane, drm) {
> > +		if (plane->type == DRM_PLANE_TYPE_PRIMARY) {
> > +			primary = plane;
> > +			break;
> > +		}
> > +	}
> > +
> > +	if (!primary) {
> > +		DRM_ERROR("no primary plane found\n");
> > +		ret = -EINVAL;
> > +		goto crtc_cleanup_planes;
> > +	}
> > +
> > +	ret = drm_crtc_init_with_planes(drm, &malidp->crtc, primary, NULL,
> > +					&malidp_crtc_funcs, NULL);
> > +
> > +	if (!ret) {
> > +		drm_crtc_helper_add(&malidp->crtc, &malidp_crtc_helper_funcs);
> > +		return 0;
> > +	}
> > +
> > +crtc_cleanup_planes:
> > +	malidp_de_planes_destroy(drm);
> > +
> > +	return ret;
> > +}
> > diff --git a/drivers/gpu/drm/arm/malidp_drv.c b/drivers/gpu/drm/arm/malidp_drv.c
> > new file mode 100644
> > index 0000000..e5b44e9
> > --- /dev/null
> > +++ b/drivers/gpu/drm/arm/malidp_drv.c
> > @@ -0,0 +1,512 @@
> > +/*
> > + * (C) COPYRIGHT 2016 ARM Limited. All rights reserved.
> > + * Author: Liviu Dudau <Liviu.Dudau@arm.com>
> > + *
> > + * This program is free software and is provided to you under the terms of the
> > + * GNU General Public License version 2 as published by the Free Software
> > + * Foundation, and any use by you of this program is subject to the terms
> > + * of such GNU licence.
> > + *
> > + * ARM Mali DP500/DP550/DP650 KMS/DRM driver
> > + */
> > +
> > +#include <linux/module.h>
> > +#include <linux/clk.h>
> > +#include <linux/component.h>
> > +#include <linux/of_device.h>
> > +#include <linux/of_graph.h>
> > +#include <linux/of_reserved_mem.h>
> > +
> > +#include <drm/drmP.h>
> > +#include <drm/drm_atomic.h>
> > +#include <drm/drm_atomic_helper.h>
> > +#include <drm/drm_crtc.h>
> > +#include <drm/drm_crtc_helper.h>
> > +#include <drm/drm_fb_helper.h>
> > +#include <drm/drm_fb_cma_helper.h>
> > +#include <drm/drm_gem_cma_helper.h>
> > +#include <drm/drm_of.h>
> > +
> > +#include "malidp_drv.h"
> > +#include "malidp_regs.h"
> > +#include "malidp_hw.h"
> > +
> > +#define MALIDP_CONF_VALID_TIMEOUT	250
> > +
> > +/*
> > + * set the "config valid" bit and wait until the hardware acts on it
> > + */
> > +static int malidp_set_and_wait_config_valid(struct drm_device *drm)
> > +{
> > +	struct malidp_drm *malidp = drm->dev_private;
> > +	struct malidp_hw_device *hwdev = malidp->dev;
> > +	int ret;
> > +
> > +	hwdev->set_config_valid(hwdev);
> > +	/* don't wait for config_valid flag if we are in config mode */
> > +	if (hwdev->in_config_mode(hwdev))
> > +		return 0;
> > +
> > +	ret = wait_event_interruptible_timeout(malidp->wq,
> > +			atomic_read(&malidp->config_valid) == 1,
> > +			msecs_to_jiffies(MALIDP_CONF_VALID_TIMEOUT));
> > +
> > +	return (ret > 0) ? 0 : -ETIMEDOUT;
> > +}
> > +
> > +static void malidp_output_poll_changed(struct drm_device *drm)
> > +{
> > +	struct malidp_drm *malidp = drm->dev_private;
> > +
> > +	drm_fbdev_cma_hotplug_event(malidp->fbdev);
> > +}
> > +
> > +static void malidp_atomic_commit_hw_done(struct drm_atomic_state *state)
> > +{
> > +	struct drm_pending_vblank_event *event;
> > +	struct drm_device *drm = state->dev;
> > +	struct malidp_drm *malidp = drm->dev_private;
> > +	int ret = malidp_set_and_wait_config_valid(drm);
> > +
> > +	if (ret)
> > +		DRM_DEBUG_DRIVER("timed out waiting for updated configuration\n");
> > +
> > +	event = malidp->crtc.state->event;
> > +	if (event) {
> > +		malidp->crtc.state->event = NULL;
> > +
> > +		spin_lock_irq(&drm->event_lock);
> > +		if (drm_crtc_vblank_get(&malidp->crtc) == 0)
> > +			drm_crtc_arm_vblank_event(&malidp->crtc, event);
> > +		else
> > +			drm_crtc_send_vblank_event(&malidp->crtc, event);
> > +		spin_unlock_irq(&drm->event_lock);
> > +	}
> > +	drm_atomic_helper_commit_hw_done(state);
> > +}
> > +
> > +static void malidp_atomic_commit_tail(struct drm_atomic_state *state)
> > +{
> > +	struct drm_device *drm = state->dev;
> > +
> > +	drm_atomic_helper_commit_modeset_disables(drm, state);
> > +	drm_atomic_helper_commit_modeset_enables(drm, state);
> > +	drm_atomic_helper_commit_planes(drm, state, true);
> > +
> > +	malidp_atomic_commit_hw_done(state);
> > +
> > +	drm_atomic_helper_wait_for_vblanks(drm, state);
> > +
> > +	drm_atomic_helper_cleanup_planes(drm, state);
> > +}
> > +
> > +static struct drm_mode_config_helper_funcs malidp_mode_config_helpers = {
> > +	.atomic_commit_tail = malidp_atomic_commit_tail,
> > +};
> > +
> > +static const struct drm_mode_config_funcs malidp_mode_config_funcs = {
> > +	.fb_create = drm_fb_cma_create,
> > +	.output_poll_changed = malidp_output_poll_changed,
> > +	.atomic_check = drm_atomic_helper_check,
> > +	.atomic_commit = drm_atomic_helper_commit,
> > +};
> > +
> > +static int malidp_enable_vblank(struct drm_device *drm, unsigned int crtc)
> > +{
> > +	struct malidp_drm *malidp = drm->dev_private;
> > +	struct malidp_hw_device *hwdev = malidp->dev;
> > +
> > +	malidp_hw_enable_irq(hwdev, MALIDP_DE_BLOCK,
> > +			     hwdev->map.de_irq_map.vsync_irq);
> > +	return 0;
> > +}
> > +
> > +static void malidp_disable_vblank(struct drm_device *drm, unsigned int pipe)
> > +{
> > +	struct malidp_drm *malidp = drm->dev_private;
> > +	struct malidp_hw_device *hwdev = malidp->dev;
> > +
> > +	malidp_hw_disable_irq(hwdev, MALIDP_DE_BLOCK,
> > +			      hwdev->map.de_irq_map.vsync_irq);
> > +}
> > +
> > +static int malidp_init(struct drm_device *drm)
> > +{
> > +	int ret;
> > +	struct malidp_drm *malidp = drm->dev_private;
> > +	struct malidp_hw_device *hwdev = malidp->dev;
> > +
> > +	drm_mode_config_init(drm);
> > +
> > +	drm->mode_config.min_width = hwdev->min_line_size;
> > +	drm->mode_config.min_height = hwdev->min_line_size;
> > +	drm->mode_config.max_width = hwdev->max_line_size;
> > +	drm->mode_config.max_height = hwdev->max_line_size;
> > +	drm->mode_config.funcs = &malidp_mode_config_funcs;
> > +	drm->mode_config.helper_private = &malidp_mode_config_helpers;
> > +
> > +	ret = malidp_crtc_init(drm);
> > +	if (ret) {
> > +		drm_mode_config_cleanup(drm);
> > +		return ret;
> > +	}
> > +
> > +	return 0;
> > +}
> > +
> > +static int malidp_irq_init(struct platform_device *pdev)
> > +{
> > +	int irq_de, irq_se, ret = 0;
> > +	struct drm_device *drm = dev_get_drvdata(&pdev->dev);
> > +
> > +	/* fetch the interrupts from DT */
> > +	irq_de = platform_get_irq_byname(pdev, "DE");
> > +	if (irq_de < 0) {
> > +		DRM_ERROR("no 'DE' IRQ specified!\n");
> > +		return irq_de;
> > +	}
> > +	irq_se = platform_get_irq_byname(pdev, "SE");
> > +	if (irq_se < 0) {
> > +		DRM_ERROR("no 'SE' IRQ specified!\n");
> > +		return irq_se;
> > +	}
> > +
> > +	ret = malidp_de_irq_init(drm, irq_de);
> > +	if (ret)
> > +		return ret;
> > +
> > +	ret = malidp_se_irq_init(drm, irq_se);
> > +	if (ret) {
> > +		malidp_de_irq_fini(drm);
> > +		return ret;
> > +	}
> > +
> > +	return 0;
> > +}
> > +
> > +static void malidp_lastclose(struct drm_device *drm)
> > +{
> > +	struct malidp_drm *malidp = drm->dev_private;
> > +
> > +	drm_fbdev_cma_restore_mode(malidp->fbdev);
> > +}
> > +
> > +static const struct file_operations fops = {
> > +	.owner = THIS_MODULE,
> > +	.open = drm_open,
> > +	.release = drm_release,
> > +	.unlocked_ioctl = drm_ioctl,
> > +#ifdef CONFIG_COMPAT
> > +	.compat_ioctl = drm_compat_ioctl,
> > +#endif
> > +	.poll = drm_poll,
> > +	.read = drm_read,
> > +	.llseek = noop_llseek,
> > +	.mmap = drm_gem_cma_mmap,
> > +};
> > +
> > +static struct drm_driver malidp_driver = {
> > +	.driver_features = DRIVER_GEM | DRIVER_MODESET | DRIVER_ATOMIC |
> > +			   DRIVER_PRIME,
> > +	.lastclose = malidp_lastclose,
> > +	.get_vblank_counter = drm_vblank_no_hw_counter,
> > +	.enable_vblank = malidp_enable_vblank,
> > +	.disable_vblank = malidp_disable_vblank,
> > +	.gem_free_object_unlocked = drm_gem_cma_free_object,
> > +	.gem_vm_ops = &drm_gem_cma_vm_ops,
> > +	.dumb_create = drm_gem_cma_dumb_create,
> > +	.dumb_map_offset = drm_gem_cma_dumb_map_offset,
> > +	.dumb_destroy = drm_gem_dumb_destroy,
> > +	.prime_handle_to_fd = drm_gem_prime_handle_to_fd,
> > +	.prime_fd_to_handle = drm_gem_prime_fd_to_handle,
> > +	.gem_prime_export = drm_gem_prime_export,
> > +	.gem_prime_import = drm_gem_prime_import,
> > +	.gem_prime_get_sg_table = drm_gem_cma_prime_get_sg_table,
> > +	.gem_prime_import_sg_table = drm_gem_cma_prime_import_sg_table,
> > +	.gem_prime_vmap = drm_gem_cma_prime_vmap,
> > +	.gem_prime_vunmap = drm_gem_cma_prime_vunmap,
> > +	.gem_prime_mmap = drm_gem_cma_prime_mmap,
> > +	.fops = &fops,
> > +	.name = "mali-dp",
> > +	.desc = "ARM Mali Display Processor driver",
> > +	.date = "20160106",
> > +	.major = 1,
> > +	.minor = 0,
> > +};
> > +
> > +static const struct of_device_id  malidp_drm_of_match[] = {
> > +	{
> > +		.compatible = "arm,mali-dp500",
> > +		.data = &malidp_device[MALIDP_500]
> > +	},
> > +	{
> > +		.compatible = "arm,mali-dp550",
> > +		.data = &malidp_device[MALIDP_550]
> > +	},
> > +	{
> > +		.compatible = "arm,mali-dp650",
> > +		.data = &malidp_device[MALIDP_650]
> > +	},
> > +	{},
> > +};
> > +MODULE_DEVICE_TABLE(of, malidp_drm_of_match);
> > +
> > +#define MAX_OUTPUT_CHANNELS	3
> > +
> > +static int malidp_bind(struct device *dev)
> > +{
> > +	struct resource *res;
> > +	struct drm_device *drm;
> > +	struct malidp_drm *malidp;
> > +	struct malidp_hw_device *hwdev;
> > +	struct platform_device *pdev = to_platform_device(dev);
> > +	/* number of lines for the R, G and B output */
> > +	u8 output_width[MAX_OUTPUT_CHANNELS];
> > +	int ret = 0, i;
> > +	u32 version, out_depth = 0;
> > +
> > +	malidp = devm_kzalloc(dev, sizeof(*malidp), GFP_KERNEL);
> > +	if (!malidp)
> > +		return -ENOMEM;
> > +
> > +	hwdev = devm_kzalloc(dev, sizeof(*hwdev), GFP_KERNEL);
> > +	if (!hwdev)
> > +		return -ENOMEM;
> > +
> > +	/*
> > +	 * copy the associated data from malidp_drm_of_match to avoid
> > +	 * having to keep a reference to the OF node after binding
> > +	 */
> > +	memcpy(hwdev, of_device_get_match_data(dev), sizeof(*hwdev));
> > +	malidp->dev = hwdev;
> > +
> > +	INIT_LIST_HEAD(&malidp->event_list);
> > +
> > +	res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
> > +	hwdev->regs = devm_ioremap_resource(dev, res);
> > +	if (IS_ERR(hwdev->regs)) {
> > +		DRM_ERROR("Failed to map control registers area\n");
> > +		return PTR_ERR(hwdev->regs);
> > +	}
> > +
> > +	hwdev->pclk = devm_clk_get(dev, "pclk");
> > +	if (IS_ERR(hwdev->pclk))
> > +		return PTR_ERR(hwdev->pclk);
> > +
> > +	hwdev->aclk = devm_clk_get(dev, "aclk");
> > +	if (IS_ERR(hwdev->aclk))
> > +		return PTR_ERR(hwdev->aclk);
> > +
> > +	hwdev->mclk = devm_clk_get(dev, "mclk");
> > +	if (IS_ERR(hwdev->mclk))
> > +		return PTR_ERR(hwdev->mclk);
> > +
> > +	hwdev->pxlclk = devm_clk_get(dev, "pxlclk");
> > +	if (IS_ERR(hwdev->pxlclk))
> > +		return PTR_ERR(hwdev->pxlclk);
> > +
> > +	/* Get the optional framebuffer memory resource */
> > +	ret = of_reserved_mem_device_init(dev);
> > +	if (ret && ret != -ENODEV)
> > +		return ret;
> > +
> > +	drm = drm_dev_alloc(&malidp_driver, dev);
> > +	if (!drm) {
> > +		ret = -ENOMEM;
> > +		goto alloc_fail;
> > +	}
> > +
> > +	/* Enable APB clock in order to get access to the registers */
> > +	clk_prepare_enable(hwdev->pclk);
> > +	/*
> > +	 * Enable AXI clock and main clock so that prefetch can start once
> > +	 * the registers are set
> > +	 */
> > +	clk_prepare_enable(hwdev->aclk);
> > +	clk_prepare_enable(hwdev->mclk);
> > +
> > +	ret = hwdev->query_hw(hwdev);
> > +	if (ret) {
> > +		DRM_ERROR("Invalid HW configuration\n");
> > +		goto query_hw_fail;
> > +	}
> > +
> > +	version = malidp_hw_read(hwdev, hwdev->map.dc_base + MALIDP_DE_CORE_ID);
> > +	DRM_INFO("found ARM Mali-DP%3x version r%dp%d\n", version >> 16,
> > +		 (version >> 12) & 0xf, (version >> 8) & 0xf);
> > +
> > +	/* set the number of lines used for output of RGB data */
> > +	ret = of_property_read_u8_array(dev->of_node,
> > +					"arm,malidp-output-port-lines",
> > +					output_width, MAX_OUTPUT_CHANNELS);
> > +	if (ret)
> > +		goto query_hw_fail;
> > +
> > +	for (i = 0; i < MAX_OUTPUT_CHANNELS; i++)
> > +		out_depth = (out_depth << 8) | (output_width[i] & 0xf);
> > +	malidp_hw_write(hwdev, out_depth, hwdev->map.out_depth_base);
> > +
> > +	drm->dev_private = malidp;
> > +	dev_set_drvdata(dev, drm);
> > +	atomic_set(&malidp->config_valid, 0);
> > +	init_waitqueue_head(&malidp->wq);
> > +
> > +	ret = malidp_init(drm);
> > +	if (ret < 0)
> > +		goto init_fail;
> > +
> > +	ret = drm_dev_register(drm, 0);
> > +	if (ret)
> > +		goto register_fail;
> > +
> > +	/* Set the CRTC's port so that the encoder component can find it */
> > +	malidp->crtc.port = of_graph_get_next_endpoint(dev->of_node, NULL);
> > +
> > +	ret = component_bind_all(dev, drm);
> > +	of_node_put(malidp->crtc.port);
> > +
> > +	if (ret) {
> > +		DRM_ERROR("Failed to bind all components\n");
> > +		goto bind_fail;
> > +	}
> > +
> > +	ret = malidp_irq_init(pdev);
> > +	if (ret < 0)
> > +		goto irq_init_fail;
> > +
> > +	ret = drm_vblank_init(drm, drm->mode_config.num_crtc);
> > +	if (ret < 0) {
> > +		DRM_ERROR("failed to initialise vblank\n");
> > +		goto vblank_fail;
> > +	}
> > +
> > +	drm_mode_config_reset(drm);
> > +
> > +	malidp->fbdev = drm_fbdev_cma_init(drm, 32, drm->mode_config.num_crtc,
> > +					   drm->mode_config.num_connector);
> > +
> > +	if (IS_ERR(malidp->fbdev)) {
> > +		ret = PTR_ERR(malidp->fbdev);
> > +		malidp->fbdev = NULL;
> > +		goto fbdev_fail;
> > +	}
> > +
> > +	drm_kms_helper_poll_init(drm);
> > +	return 0;
> > +
> > +fbdev_fail:
> > +	drm_vblank_cleanup(drm);
> > +vblank_fail:
> > +	malidp_se_irq_fini(drm);
> > +	malidp_de_irq_fini(drm);
> > +irq_init_fail:
> > +	component_unbind_all(dev, drm);
> > +bind_fail:
> > +	drm_dev_unregister(drm);
> > +register_fail:
> > +	malidp_de_planes_destroy(drm);
> > +	drm_mode_config_cleanup(drm);
> > +init_fail:
> > +	drm->dev_private = NULL;
> > +	dev_set_drvdata(dev, NULL);
> > +query_hw_fail:
> > +	clk_disable_unprepare(hwdev->mclk);
> > +	clk_disable_unprepare(hwdev->aclk);
> > +	clk_disable_unprepare(hwdev->pclk);
> > +	drm_dev_unref(drm);
> > +alloc_fail:
> > +	of_reserved_mem_device_release(dev);
> > +
> > +	return ret;
> > +}
> > +
> > +static void malidp_unbind(struct device *dev)
> > +{
> > +	struct drm_device *drm = dev_get_drvdata(dev);
> > +	struct malidp_drm *malidp = drm->dev_private;
> > +	struct malidp_hw_device *hwdev = malidp->dev;
> > +
> > +	if (malidp->fbdev) {
> > +		drm_fbdev_cma_fini(malidp->fbdev);
> > +		malidp->fbdev = NULL;
> > +	}
> > +	drm_kms_helper_poll_fini(drm);
> > +	malidp_se_irq_fini(drm);
> > +	malidp_de_irq_fini(drm);
> > +	drm_vblank_cleanup(drm);
> > +	component_unbind_all(dev, drm);
> > +	drm_dev_unregister(drm);
> > +	malidp_de_planes_destroy(drm);
> > +	drm_mode_config_cleanup(drm);
> > +	drm->dev_private = NULL;
> > +	dev_set_drvdata(dev, NULL);
> > +	clk_disable_unprepare(hwdev->mclk);
> > +	clk_disable_unprepare(hwdev->aclk);
> > +	clk_disable_unprepare(hwdev->pclk);
> > +	drm_dev_unref(drm);
> > +	of_reserved_mem_device_release(dev);
> > +}
> > +
> > +static const struct component_master_ops malidp_master_ops = {
> > +	.bind = malidp_bind,
> > +	.unbind = malidp_unbind,
> > +};
> > +
> > +static int malidp_compare_dev(struct device *dev, void *data)
> > +{
> > +	struct device_node *np = data;
> > +
> > +	return dev->of_node == np;
> > +}
> > +
> > +static int malidp_platform_probe(struct platform_device *pdev)
> > +{
> > +	struct device_node *port, *ep;
> > +	struct component_match *match = NULL;
> > +
> > +	if (!pdev->dev.of_node)
> > +		return -ENODEV;
> > +
> > +	/* there is only one output port inside each device, find it */
> > +	ep = of_graph_get_next_endpoint(pdev->dev.of_node, NULL);
> > +	if (!ep)
> > +		return -ENODEV;
> > +
> > +	if (!of_device_is_available(ep)) {
> > +		of_node_put(ep);
> > +		return -ENODEV;
> > +	}
> > +
> > +	/* add the remote encoder port as component */
> > +	port = of_graph_get_remote_port_parent(ep);
> > +	of_node_put(ep);
> > +	if (!port || !of_device_is_available(port)) {
> > +		of_node_put(port);
> > +		return -EAGAIN;
> > +	}
> > +
> > +	component_match_add(&pdev->dev, &match, malidp_compare_dev, port);
> > +	return component_master_add_with_match(&pdev->dev, &malidp_master_ops,
> > +					       match);
> > +}
> > +
> > +static int malidp_platform_remove(struct platform_device *pdev)
> > +{
> > +	component_master_del(&pdev->dev, &malidp_master_ops);
> > +	return 0;
> > +}
> > +
> > +static struct platform_driver malidp_platform_driver = {
> > +	.probe		= malidp_platform_probe,
> > +	.remove		= malidp_platform_remove,
> > +	.driver	= {
> > +		.name = "mali-dp",
> > +		.of_match_table	= malidp_drm_of_match,
> > +	},
> > +};
> > +
> > +module_platform_driver(malidp_platform_driver);
> > +
> > +MODULE_AUTHOR("Liviu Dudau <Liviu.Dudau@arm.com>");
> > +MODULE_DESCRIPTION("ARM Mali DP DRM driver");
> > +MODULE_LICENSE("GPL v2");
> > diff --git a/drivers/gpu/drm/arm/malidp_drv.h b/drivers/gpu/drm/arm/malidp_drv.h
> > new file mode 100644
> > index 0000000..95558fd
> > --- /dev/null
> > +++ b/drivers/gpu/drm/arm/malidp_drv.h
> > @@ -0,0 +1,54 @@
> > +/*
> > + * (C) COPYRIGHT 2016 ARM Limited. All rights reserved.
> > + * Author: Liviu Dudau <Liviu.Dudau@arm.com>
> > + *
> > + * This program is free software and is provided to you under the terms of the
> > + * GNU General Public License version 2 as published by the Free Software
> > + * Foundation, and any use by you of this program is subject to the terms
> > + * of such GNU licence.
> > + *
> > + * ARM Mali DP500/DP550/DP650 KMS/DRM driver structures
> > + */
> > +
> > +#ifndef __MALIDP_DRV_H__
> > +#define __MALIDP_DRV_H__
> > +
> > +#include <linux/mutex.h>
> > +#include <linux/wait.h>
> > +#include "malidp_hw.h"
> > +
> > +struct malidp_drm {
> > +	struct malidp_hw_device *dev;
> > +	struct drm_fbdev_cma *fbdev;
> > +	struct list_head event_list;
> > +	struct drm_crtc crtc;
> > +	wait_queue_head_t wq;
> > +	atomic_t config_valid;
> > +};
> > +
> > +#define crtc_to_malidp_device(x) container_of(x, struct malidp_drm, crtc)
> > +
> > +struct malidp_plane {
> > +	struct drm_plane base;
> > +	struct malidp_hw_device *hwdev;
> > +	const struct malidp_layer *layer;
> > +};
> > +
> > +struct malidp_plane_state {
> > +	struct drm_plane_state base;
> > +
> > +	/* size of the required rotation memory if plane is rotated */
> > +	u32 rotmem_size;
> > +};
> > +
> > +#define to_malidp_plane(x) container_of(x, struct malidp_plane, base)
> > +#define to_malidp_plane_state(x) container_of(x, struct malidp_plane_state, base)
> > +
> > +int malidp_de_planes_init(struct drm_device *drm);
> > +void malidp_de_planes_destroy(struct drm_device *drm);
> > +int malidp_crtc_init(struct drm_device *drm);
> > +
> > +/* often used combination of rotational bits */
> > +#define MALIDP_ROTATED_MASK	(BIT(DRM_ROTATE_90) | BIT(DRM_ROTATE_270))
> > +
> > +#endif  /* __MALIDP_DRV_H__ */
> > diff --git a/drivers/gpu/drm/arm/malidp_hw.c b/drivers/gpu/drm/arm/malidp_hw.c
> > new file mode 100644
> > index 0000000..a6132f1
> > --- /dev/null
> > +++ b/drivers/gpu/drm/arm/malidp_hw.c
> > @@ -0,0 +1,691 @@
> > +/*
> > + * (C) COPYRIGHT 2016 ARM Limited. All rights reserved.
> > + * Author: Liviu Dudau <Liviu.Dudau@arm.com>
> > + *
> > + * This program is free software and is provided to you under the terms of the
> > + * GNU General Public License version 2 as published by the Free Software
> > + * Foundation, and any use by you of this program is subject to the terms
> > + * of such GNU licence.
> > + *
> > + * ARM Mali DP500/DP550/DP650 hardware manipulation routines. This is where
> > + * the difference between various versions of the hardware is being dealt with
> > + * in an attempt to provide to the rest of the driver code a unified view
> > + */
> > +
> > +#include <linux/types.h>
> > +#include <linux/io.h>
> > +#include <drm/drmP.h>
> > +#include <video/videomode.h>
> > +#include <video/display_timing.h>
> > +
> > +#include "malidp_drv.h"
> > +#include "malidp_hw.h"
> > +
> > +static const struct malidp_input_format malidp500_de_formats[] = {
> > +	/*    fourcc,   layers supporting the format,     internal id  */
> > +	{ DRM_FORMAT_ARGB2101010, DE_VIDEO1 | DE_GRAPHICS1 | DE_GRAPHICS2,  0 },
> > +	{ DRM_FORMAT_ABGR2101010, DE_VIDEO1 | DE_GRAPHICS1 | DE_GRAPHICS2,  1 },
> > +	{ DRM_FORMAT_ARGB8888, DE_VIDEO1 | DE_GRAPHICS1 | DE_GRAPHICS2,  2 },
> > +	{ DRM_FORMAT_ABGR8888, DE_VIDEO1 | DE_GRAPHICS1 | DE_GRAPHICS2,  3 },
> > +	{ DRM_FORMAT_XRGB8888, DE_VIDEO1 | DE_GRAPHICS1 | DE_GRAPHICS2,  4 },
> > +	{ DRM_FORMAT_XBGR8888, DE_VIDEO1 | DE_GRAPHICS1 | DE_GRAPHICS2,  5 },
> > +	{ DRM_FORMAT_RGB888, DE_VIDEO1 | DE_GRAPHICS1 | DE_GRAPHICS2,  6 },
> > +	{ DRM_FORMAT_BGR888, DE_VIDEO1 | DE_GRAPHICS1 | DE_GRAPHICS2,  7 },
> > +	{ DRM_FORMAT_RGBA5551, DE_VIDEO1 | DE_GRAPHICS1 | DE_GRAPHICS2,  8 },
> > +	{ DRM_FORMAT_ABGR1555, DE_VIDEO1 | DE_GRAPHICS1 | DE_GRAPHICS2,  9 },
> > +	{ DRM_FORMAT_RGB565, DE_VIDEO1 | DE_GRAPHICS1 | DE_GRAPHICS2, 10 },
> > +	{ DRM_FORMAT_BGR565, DE_VIDEO1 | DE_GRAPHICS1 | DE_GRAPHICS2, 11 },
> > +	{ DRM_FORMAT_UYVY, DE_VIDEO1, 12 },
> > +	{ DRM_FORMAT_YUYV, DE_VIDEO1, 13 },
> > +	{ DRM_FORMAT_NV12, DE_VIDEO1, 14 },
> > +	{ DRM_FORMAT_YUV420, DE_VIDEO1, 15 },
> > +};
> > +
> > +#define MALIDP_ID(__group, __format) \
> > +	((((__group) & 0x7) << 3) | ((__format) & 0x7))
> > +
> > +#define MALIDP_COMMON_FORMATS \
> > +	/*    fourcc,   layers supporting the format,      internal id   */ \
> > +	{ DRM_FORMAT_ARGB2101010, DE_VIDEO1 | DE_GRAPHICS1 | DE_VIDEO2, MALIDP_ID(0, 0) }, \
> > +	{ DRM_FORMAT_ABGR2101010, DE_VIDEO1 | DE_GRAPHICS1 | DE_VIDEO2, MALIDP_ID(0, 1) }, \
> > +	{ DRM_FORMAT_RGBA1010102, DE_VIDEO1 | DE_GRAPHICS1 | DE_VIDEO2, MALIDP_ID(0, 2) }, \
> > +	{ DRM_FORMAT_BGRA1010102, DE_VIDEO1 | DE_GRAPHICS1 | DE_VIDEO2, MALIDP_ID(0, 3) }, \
> > +	{ DRM_FORMAT_ARGB8888, DE_VIDEO1 | DE_GRAPHICS1 | DE_VIDEO2 | DE_SMART, MALIDP_ID(1, 0) }, \
> > +	{ DRM_FORMAT_ABGR8888, DE_VIDEO1 | DE_GRAPHICS1 | DE_VIDEO2 | DE_SMART, MALIDP_ID(1, 1) }, \
> > +	{ DRM_FORMAT_RGBA8888, DE_VIDEO1 | DE_GRAPHICS1 | DE_VIDEO2 | DE_SMART, MALIDP_ID(1, 2) }, \
> > +	{ DRM_FORMAT_BGRA8888, DE_VIDEO1 | DE_GRAPHICS1 | DE_VIDEO2 | DE_SMART, MALIDP_ID(1, 3) }, \
> > +	{ DRM_FORMAT_XRGB8888, DE_VIDEO1 | DE_GRAPHICS1 | DE_VIDEO2 | DE_SMART, MALIDP_ID(2, 0) }, \
> > +	{ DRM_FORMAT_XBGR8888, DE_VIDEO1 | DE_GRAPHICS1 | DE_VIDEO2 | DE_SMART, MALIDP_ID(2, 1) }, \
> > +	{ DRM_FORMAT_RGBX8888, DE_VIDEO1 | DE_GRAPHICS1 | DE_VIDEO2 | DE_SMART, MALIDP_ID(2, 2) }, \
> > +	{ DRM_FORMAT_BGRX8888, DE_VIDEO1 | DE_GRAPHICS1 | DE_VIDEO2 | DE_SMART, MALIDP_ID(2, 3) }, \
> > +	{ DRM_FORMAT_RGB888, DE_VIDEO1 | DE_GRAPHICS1 | DE_VIDEO2, MALIDP_ID(3, 0) }, \
> > +	{ DRM_FORMAT_BGR888, DE_VIDEO1 | DE_GRAPHICS1 | DE_VIDEO2, MALIDP_ID(3, 1) }, \
> > +	{ DRM_FORMAT_RGBA5551, DE_VIDEO1 | DE_GRAPHICS1 | DE_VIDEO2, MALIDP_ID(4, 0) }, \
> > +	{ DRM_FORMAT_ABGR1555, DE_VIDEO1 | DE_GRAPHICS1 | DE_VIDEO2, MALIDP_ID(4, 1) }, \
> > +	{ DRM_FORMAT_RGB565, DE_VIDEO1 | DE_GRAPHICS1 | DE_VIDEO2, MALIDP_ID(4, 2) }, \
> > +	{ DRM_FORMAT_BGR565, DE_VIDEO1 | DE_GRAPHICS1 | DE_VIDEO2, MALIDP_ID(4, 3) }, \
> > +	{ DRM_FORMAT_YUYV, DE_VIDEO1 | DE_VIDEO2, MALIDP_ID(5, 2) },	\
> > +	{ DRM_FORMAT_UYVY, DE_VIDEO1 | DE_VIDEO2, MALIDP_ID(5, 3) },	\
> > +	{ DRM_FORMAT_NV12, DE_VIDEO1 | DE_VIDEO2, MALIDP_ID(5, 6) },	\
> > +	{ DRM_FORMAT_YUV420, DE_VIDEO1 | DE_VIDEO2, MALIDP_ID(5, 7) }
> > +
> > +static const struct malidp_input_format malidp550_de_formats[] = {
> > +	MALIDP_COMMON_FORMATS,
> > +};
> > +
> > +static const struct malidp_layer malidp500_layers[] = {
> > +	{ DE_VIDEO1, MALIDP500_DE_LV_BASE, MALIDP500_DE_LV_PTR_BASE },
> > +	{ DE_GRAPHICS1, MALIDP500_DE_LG1_BASE, MALIDP500_DE_LG1_PTR_BASE },
> > +	{ DE_GRAPHICS2, MALIDP500_DE_LG2_BASE, MALIDP500_DE_LG2_PTR_BASE },
> > +};
> > +
> > +static const struct malidp_layer malidp550_layers[] = {
> > +	{ DE_VIDEO1, MALIDP550_DE_LV1_BASE, MALIDP550_DE_LV1_PTR_BASE },
> > +	{ DE_GRAPHICS1, MALIDP550_DE_LG_BASE, MALIDP550_DE_LG_PTR_BASE },
> > +	{ DE_VIDEO2, MALIDP550_DE_LV2_BASE, MALIDP550_DE_LV2_PTR_BASE },
> > +	{ DE_SMART, MALIDP550_DE_LS_BASE, MALIDP550_DE_LS_PTR_BASE },
> > +};
> > +
> > +#define MALIDP_DE_DEFAULT_PREFETCH_START	5
> > +
> > +static int malidp500_query_hw(struct malidp_hw_device *hwdev)
> > +{
> > +	u32 conf = malidp_hw_read(hwdev, MALIDP500_CONFIG_ID);
> > +	/* bit 4 of the CONFIG_ID register holds the line size multiplier */
> > +	u8 ln_size_mult = conf & 0x10 ? 2 : 1;
> > +
> > +	hwdev->min_line_size = 2;
> > +	hwdev->max_line_size = SZ_2K * ln_size_mult;
> > +	hwdev->rotation_memory[0] = SZ_1K * 64 * ln_size_mult;
> > +	hwdev->rotation_memory[1] = 0; /* no second rotation memory bank */
> > +
> > +	return 0;
> > +}
> > +
> > +static void malidp500_enter_config_mode(struct malidp_hw_device *hwdev)
> > +{
> > +	u32 status, count = 100;
> > +
> > +	malidp_hw_setbits(hwdev, MALIDP500_DC_CONFIG_REQ, MALIDP500_DC_CONTROL);
> > +	while (count) {
> > +		status = malidp_hw_read(hwdev, hwdev->map.dc_base + MALIDP_REG_STATUS);
> > +		if ((status & MALIDP500_DC_CONFIG_REQ) == MALIDP500_DC_CONFIG_REQ)
> > +			break;
> > +		/*
> > +		 * entering config mode can take as long as the rendering
> > +		 * of a full frame, hence the long sleep here
> > +		 */
> > +		usleep_range(1000, 10000);
> > +		count--;
> > +	}
> > +	WARN(count == 0, "timeout while entering config mode");
> > +}
> > +
> > +static void malidp500_leave_config_mode(struct malidp_hw_device *hwdev)
> > +{
> > +	u32 status, count = 100;
> > +
> > +	malidp_hw_clearbits(hwdev, MALIDP500_DC_CONFIG_REQ, MALIDP500_DC_CONTROL);
> > +	while (count) {
> > +		status = malidp_hw_read(hwdev, hwdev->map.dc_base + MALIDP_REG_STATUS);
> > +		if ((status & MALIDP500_DC_CONFIG_REQ) == 0)
> > +			break;
> > +		usleep_range(100, 1000);
> > +		count--;
> > +	}
> > +	WARN(count == 0, "timeout while leaving config mode");
> > +}
> > +
> > +static bool malidp500_in_config_mode(struct malidp_hw_device *hwdev)
> > +{
> > +	u32 status;
> > +
> > +	status = malidp_hw_read(hwdev, hwdev->map.dc_base + MALIDP_REG_STATUS);
> > +	if ((status & MALIDP500_DC_CONFIG_REQ) == MALIDP500_DC_CONFIG_REQ)
> > +		return true;
> > +
> > +	return false;
> > +}
> > +
> > +static void malidp500_set_config_valid(struct malidp_hw_device *hwdev)
> > +{
> > +	malidp_hw_setbits(hwdev, MALIDP_CFG_VALID, MALIDP500_CONFIG_VALID);
> > +}
> > +
> > +static void malidp500_modeset(struct malidp_hw_device *hwdev, struct videomode *mode)
> > +{
> > +	u32 val = 0;
> > +
> > +	malidp_hw_clearbits(hwdev, MALIDP500_DC_CLEAR_MASK, MALIDP500_DC_CONTROL);
> > +	if (mode->flags & DISPLAY_FLAGS_HSYNC_HIGH)
> > +		val |= MALIDP500_HSYNCPOL;
> > +	if (mode->flags & DISPLAY_FLAGS_VSYNC_HIGH)
> > +		val |= MALIDP500_VSYNCPOL;
> > +	val |= MALIDP_DE_DEFAULT_PREFETCH_START;
> > +	malidp_hw_setbits(hwdev, val, MALIDP500_DC_CONTROL);
> > +
> > +	/*
> > +	 * Mali-DP500 encodes the background color like this:
> > +	 *    - red   @ MALIDP500_BGND_COLOR[12:0]
> > +	 *    - green @ MALIDP500_BGND_COLOR[27:16]
> > +	 *    - blue  @ (MALIDP500_BGND_COLOR + 4)[12:0]
> > +	 */
> > +	val = ((MALIDP_BGND_COLOR_G & 0xfff) << 16) |
> > +	      (MALIDP_BGND_COLOR_R & 0xfff);
> > +	malidp_hw_write(hwdev, val, MALIDP500_BGND_COLOR);
> > +	malidp_hw_write(hwdev, MALIDP_BGND_COLOR_B, MALIDP500_BGND_COLOR + 4);
> > +
> > +	val = MALIDP_DE_H_FRONTPORCH(mode->hfront_porch) |
> > +		MALIDP_DE_H_BACKPORCH(mode->hback_porch);
> > +	malidp_hw_write(hwdev, val, MALIDP500_TIMINGS_BASE + MALIDP_DE_H_TIMINGS);
> > +
> > +	val = MALIDP500_DE_V_FRONTPORCH(mode->vfront_porch) |
> > +		MALIDP_DE_V_BACKPORCH(mode->vback_porch);
> > +	malidp_hw_write(hwdev, val, MALIDP500_TIMINGS_BASE + MALIDP_DE_V_TIMINGS);
> > +
> > +	val = MALIDP_DE_H_SYNCWIDTH(mode->hsync_len) |
> > +		MALIDP_DE_V_SYNCWIDTH(mode->vsync_len);
> > +	malidp_hw_write(hwdev, val, MALIDP500_TIMINGS_BASE + MALIDP_DE_SYNC_WIDTH);
> > +
> > +	val = MALIDP_DE_H_ACTIVE(mode->hactive) | MALIDP_DE_V_ACTIVE(mode->vactive);
> > +	malidp_hw_write(hwdev, val, MALIDP500_TIMINGS_BASE + MALIDP_DE_HV_ACTIVE);
> > +
> > +	if (mode->flags & DISPLAY_FLAGS_INTERLACED)
> > +		malidp_hw_setbits(hwdev, MALIDP_DISP_FUNC_ILACED, MALIDP_DE_DISPLAY_FUNC);
> > +	else
> > +		malidp_hw_clearbits(hwdev, MALIDP_DISP_FUNC_ILACED, MALIDP_DE_DISPLAY_FUNC);
> > +}
> > +
> > +static int malidp500_rotmem_required(struct malidp_hw_device *hwdev, u16 w, u16 h, u32 fmt)
> > +{
> > +	unsigned int depth;
> > +	int bpp;
> > +
> > +	/* RGB888 or BGR888 can't be rotated */
> > +	if ((fmt == DRM_FORMAT_RGB888) || (fmt == DRM_FORMAT_BGR888))
> > +		return -EINVAL;
> > +
> > +	/*
> > +	 * Each layer needs enough rotation memory to fit 8 lines
> > +	 * worth of pixel data. Required size is then:
> > +	 *    size = rotated_width * (bpp / 8) * 8;
> > +	 */
> > +	drm_fb_get_bpp_depth(fmt, &depth, &bpp);
> > +
> > +	return w * bpp;
> > +}
> > +
> > +static int malidp550_query_hw(struct malidp_hw_device *hwdev)
> > +{
> > +	u32 conf = malidp_hw_read(hwdev, MALIDP550_CONFIG_ID);
> > +	u8 ln_size = (conf >> 4) & 0x3, rsize;
> > +
> > +	hwdev->min_line_size = 2;
> > +
> > +	switch (ln_size) {
> > +	case 0:
> > +		hwdev->max_line_size = SZ_2K;
> > +		/* two banks of 64KB for rotation memory */
> > +		rsize = 64;
> > +		break;
> > +	case 1:
> > +		hwdev->max_line_size = SZ_4K;
> > +		/* two banks of 128KB for rotation memory */
> > +		rsize = 128;
> > +		break;
> > +	case 2:
> > +		hwdev->max_line_size = 1280;
> > +		/* two banks of 40KB for rotation memory */
> > +		rsize = 40;
> > +		break;
> > +	case 3:
> > +		/* reserved value */
> > +		hwdev->max_line_size = 0;
> > +		return -EINVAL;
> > +	}
> > +
> > +	hwdev->rotation_memory[0] = hwdev->rotation_memory[1] = rsize * SZ_1K;
> > +	return 0;
> > +}
> > +
> > +static void malidp550_enter_config_mode(struct malidp_hw_device *hwdev)
> > +{
> > +	u32 status, count = 100;
> > +
> > +	malidp_hw_setbits(hwdev, MALIDP550_DC_CONFIG_REQ, MALIDP550_DC_CONTROL);
> > +	while (count) {
> > +		status = malidp_hw_read(hwdev, hwdev->map.dc_base + MALIDP_REG_STATUS);
> > +		if ((status & MALIDP550_DC_CONFIG_REQ) == MALIDP550_DC_CONFIG_REQ)
> > +			break;
> > +		/*
> > +		 * entering config mode can take as long as the rendering
> > +		 * of a full frame, hence the long sleep here
> > +		 */
> > +		usleep_range(1000, 10000);
> > +		count--;
> > +	}
> > +	WARN(count == 0, "timeout while entering config mode");
> > +}
> > +
> > +static void malidp550_leave_config_mode(struct malidp_hw_device *hwdev)
> > +{
> > +	u32 status, count = 100;
> > +
> > +	malidp_hw_clearbits(hwdev, MALIDP550_DC_CONFIG_REQ, MALIDP550_DC_CONTROL);
> > +	while (count) {
> > +		status = malidp_hw_read(hwdev, hwdev->map.dc_base + MALIDP_REG_STATUS);
> > +		if ((status & MALIDP550_DC_CONFIG_REQ) == 0)
> > +			break;
> > +		usleep_range(100, 1000);
> > +		count--;
> > +	}
> > +	WARN(count == 0, "timeout while leaving config mode");
> > +}
> > +
> > +static bool malidp550_in_config_mode(struct malidp_hw_device *hwdev)
> > +{
> > +	u32 status;
> > +
> > +	status = malidp_hw_read(hwdev, hwdev->map.dc_base + MALIDP_REG_STATUS);
> > +	if ((status & MALIDP550_DC_CONFIG_REQ) == MALIDP550_DC_CONFIG_REQ)
> > +		return true;
> > +
> > +	return false;
> > +}
> > +
> > +static void malidp550_set_config_valid(struct malidp_hw_device *hwdev)
> > +{
> > +	malidp_hw_setbits(hwdev, MALIDP_CFG_VALID, MALIDP550_CONFIG_VALID);
> > +}
> > +
> > +static void malidp550_modeset(struct malidp_hw_device *hwdev, struct videomode *mode)
> > +{
> > +	u32 val = MALIDP_DE_DEFAULT_PREFETCH_START;
> > +
> > +	malidp_hw_write(hwdev, val, MALIDP550_DE_CONTROL);
> > +	/*
> > +	 * Mali-DP550 and Mali-DP650 encode the background color like this:
> > +	 *   - red   @ MALIDP550_DE_BGND_COLOR[23:16]
> > +	 *   - green @ MALIDP550_DE_BGND_COLOR[15:8]
> > +	 *   - blue  @ MALIDP550_DE_BGND_COLOR[7:0]
> > +	 *
> > +	 * We need to truncate the least significant 4 bits from the default
> > +	 * MALIDP_BGND_COLOR_x values
> > +	 */
> > +	val = (((MALIDP_BGND_COLOR_R >> 4) & 0xff) << 16) |
> > +	      (((MALIDP_BGND_COLOR_G >> 4) & 0xff) << 8) |
> > +	      ((MALIDP_BGND_COLOR_B >> 4) & 0xff);
> > +	malidp_hw_write(hwdev, val, MALIDP550_DE_BGND_COLOR);
> > +
> > +	val = MALIDP_DE_H_FRONTPORCH(mode->hfront_porch) |
> > +		MALIDP_DE_H_BACKPORCH(mode->hback_porch);
> > +	malidp_hw_write(hwdev, val, MALIDP550_TIMINGS_BASE + MALIDP_DE_H_TIMINGS);
> > +
> > +	val = MALIDP550_DE_V_FRONTPORCH(mode->vfront_porch) |
> > +		MALIDP_DE_V_BACKPORCH(mode->vback_porch);
> > +	malidp_hw_write(hwdev, val, MALIDP550_TIMINGS_BASE + MALIDP_DE_V_TIMINGS);
> > +
> > +	val = MALIDP_DE_H_SYNCWIDTH(mode->hsync_len) |
> > +		MALIDP_DE_V_SYNCWIDTH(mode->vsync_len);
> > +	if (mode->flags & DISPLAY_FLAGS_HSYNC_HIGH)
> > +		val |= MALIDP550_HSYNCPOL;
> > +	if (mode->flags & DISPLAY_FLAGS_VSYNC_HIGH)
> > +		val |= MALIDP550_VSYNCPOL;
> > +	malidp_hw_write(hwdev, val, MALIDP550_TIMINGS_BASE + MALIDP_DE_SYNC_WIDTH);
> > +
> > +	val = MALIDP_DE_H_ACTIVE(mode->hactive) | MALIDP_DE_V_ACTIVE(mode->vactive);
> > +	malidp_hw_write(hwdev, val, MALIDP550_TIMINGS_BASE + MALIDP_DE_HV_ACTIVE);
> > +
> > +	if (mode->flags & DISPLAY_FLAGS_INTERLACED)
> > +		malidp_hw_setbits(hwdev, MALIDP_DISP_FUNC_ILACED, MALIDP_DE_DISPLAY_FUNC);
> > +	else
> > +		malidp_hw_clearbits(hwdev, MALIDP_DISP_FUNC_ILACED, MALIDP_DE_DISPLAY_FUNC);
> > +}
> > +
> > +static int malidp550_rotmem_required(struct malidp_hw_device *hwdev, u16 w, u16 h, u32 fmt)
> > +{
> > +	u32 bytes_per_col;
> > +
> > +	/* raw RGB888 or BGR888 can't be rotated */
> > +	if ((fmt == DRM_FORMAT_RGB888) || (fmt == DRM_FORMAT_BGR888))
> > +		return -EINVAL;
> > +
> > +	switch (fmt) {
> > +	/* 8 lines at 4 bytes per pixel */
> > +	case DRM_FORMAT_ARGB2101010:
> > +	case DRM_FORMAT_ABGR2101010:
> > +	case DRM_FORMAT_RGBA1010102:
> > +	case DRM_FORMAT_BGRA1010102:
> > +	case DRM_FORMAT_ARGB8888:
> > +	case DRM_FORMAT_ABGR8888:
> > +	case DRM_FORMAT_RGBA8888:
> > +	case DRM_FORMAT_BGRA8888:
> > +	case DRM_FORMAT_XRGB8888:
> > +	case DRM_FORMAT_XBGR8888:
> > +	case DRM_FORMAT_RGBX8888:
> > +	case DRM_FORMAT_BGRX8888:
> > +	case DRM_FORMAT_RGB888:
> > +	case DRM_FORMAT_BGR888:
> > +	/* 16 lines at 2 bytes per pixel */
> > +	case DRM_FORMAT_RGBA5551:
> > +	case DRM_FORMAT_ABGR1555:
> > +	case DRM_FORMAT_RGB565:
> > +	case DRM_FORMAT_BGR565:
> > +	case DRM_FORMAT_UYVY:
> > +	case DRM_FORMAT_YUYV:
> > +		bytes_per_col = 32;
> > +		break;
> > +	/* 16 lines at 1.5 bytes per pixel */
> > +	case DRM_FORMAT_NV12:
> > +	case DRM_FORMAT_YUV420:
> > +		bytes_per_col = 24;
> > +		break;
> > +	default:
> > +		return -EINVAL;
> > +	}
> > +
> > +	return w * bytes_per_col;
> > +}
> > +
> > +static int malidp650_query_hw(struct malidp_hw_device *hwdev)
> > +{
> > +	u32 conf = malidp_hw_read(hwdev, MALIDP550_CONFIG_ID);
> > +	u8 ln_size = (conf >> 4) & 0x3, rsize;
> > +
> > +	hwdev->min_line_size = 4;
> > +
> > +	switch (ln_size) {
> > +	case 0:
> > +	case 2:
> > +		/* reserved values */
> > +		hwdev->max_line_size = 0;
> > +		return -EINVAL;
> > +	case 1:
> > +		hwdev->max_line_size = SZ_4K;
> > +		/* two banks of 128KB for rotation memory */
> > +		rsize = 128;
> > +		break;
> > +	case 3:
> > +		hwdev->max_line_size = 2560;
> > +		/* two banks of 80KB for rotation memory */
> > +		rsize = 80;
> > +	}
> > +
> > +	hwdev->rotation_memory[0] = hwdev->rotation_memory[1] = rsize * SZ_1K;
> > +	return 0;
> > +}
> > +
> > +const struct malidp_hw_device malidp_device[MALIDP_MAX_DEVICES] = {
> > +	[MALIDP_500] = {
> > +		.map = {
> > +			.se_base = MALIDP500_SE_BASE,
> > +			.dc_base = MALIDP500_DC_BASE,
> > +			.out_depth_base = MALIDP500_OUTPUT_DEPTH,
> > +			.features = 0,	/* no CLEARIRQ register */
> > +			.n_layers = ARRAY_SIZE(malidp500_layers),
> > +			.layers = malidp500_layers,
> > +			.de_irq_map = {
> > +				.irq_mask = MALIDP_DE_IRQ_UNDERRUN |
> > +					    MALIDP500_DE_IRQ_AXI_ERR |
> > +					    MALIDP500_DE_IRQ_VSYNC |
> > +					    MALIDP500_DE_IRQ_GLOBAL,
> > +				.vsync_irq = MALIDP500_DE_IRQ_VSYNC,
> > +			},
> > +			.se_irq_map = {
> > +				.irq_mask = MALIDP500_SE_IRQ_CONF_MODE,
> > +				.vsync_irq = 0,
> > +			},
> > +			.dc_irq_map = {
> > +				.irq_mask = MALIDP500_DE_IRQ_CONF_VALID,
> > +				.vsync_irq = MALIDP500_DE_IRQ_CONF_VALID,
> > +			},
> > +			.input_formats = malidp500_de_formats,
> > +			.n_input_formats = ARRAY_SIZE(malidp500_de_formats),
> > +		},
> > +		.query_hw = malidp500_query_hw,
> > +		.enter_config_mode = malidp500_enter_config_mode,
> > +		.leave_config_mode = malidp500_leave_config_mode,
> > +		.in_config_mode = malidp500_in_config_mode,
> > +		.set_config_valid = malidp500_set_config_valid,
> > +		.modeset = malidp500_modeset,
> > +		.rotmem_required = malidp500_rotmem_required,
> > +	},
> > +	[MALIDP_550] = {
> > +		.map = {
> > +			.se_base = MALIDP550_SE_BASE,
> > +			.dc_base = MALIDP550_DC_BASE,
> > +			.out_depth_base = MALIDP550_DE_OUTPUT_DEPTH,
> > +			.features = MALIDP_REGMAP_HAS_CLEARIRQ,
> > +			.n_layers = ARRAY_SIZE(malidp550_layers),
> > +			.layers = malidp550_layers,
> > +			.de_irq_map = {
> > +				.irq_mask = MALIDP_DE_IRQ_UNDERRUN |
> > +					    MALIDP550_DE_IRQ_VSYNC,
> > +				.vsync_irq = MALIDP550_DE_IRQ_VSYNC,
> > +			},
> > +			.se_irq_map = {
> > +				.irq_mask = MALIDP550_SE_IRQ_EOW |
> > +					    MALIDP550_SE_IRQ_AXI_ERR,
> > +			},
> > +			.dc_irq_map = {
> > +				.irq_mask = MALIDP550_DC_IRQ_CONF_VALID,
> > +				.vsync_irq = MALIDP550_DC_IRQ_CONF_VALID,
> > +			},
> > +			.input_formats = malidp550_de_formats,
> > +			.n_input_formats = ARRAY_SIZE(malidp550_de_formats),
> > +		},
> > +		.query_hw = malidp550_query_hw,
> > +		.enter_config_mode = malidp550_enter_config_mode,
> > +		.leave_config_mode = malidp550_leave_config_mode,
> > +		.in_config_mode = malidp550_in_config_mode,
> > +		.set_config_valid = malidp550_set_config_valid,
> > +		.modeset = malidp550_modeset,
> > +		.rotmem_required = malidp550_rotmem_required,
> > +	},
> > +	[MALIDP_650] = {
> > +		.map = {
> > +			.se_base = MALIDP550_SE_BASE,
> > +			.dc_base = MALIDP550_DC_BASE,
> > +			.out_depth_base = MALIDP550_DE_OUTPUT_DEPTH,
> > +			.features = MALIDP_REGMAP_HAS_CLEARIRQ,
> > +			.n_layers = ARRAY_SIZE(malidp550_layers),
> > +			.layers = malidp550_layers,
> > +			.de_irq_map = {
> > +				.irq_mask = MALIDP_DE_IRQ_UNDERRUN |
> > +					    MALIDP650_DE_IRQ_DRIFT |
> > +					    MALIDP550_DE_IRQ_VSYNC,
> > +				.vsync_irq = MALIDP550_DE_IRQ_VSYNC,
> > +			},
> > +			.se_irq_map = {
> > +				.irq_mask = MALIDP550_SE_IRQ_EOW |
> > +					    MALIDP550_SE_IRQ_AXI_ERR,
> > +			},
> > +			.dc_irq_map = {
> > +				.irq_mask = MALIDP550_DC_IRQ_CONF_VALID,
> > +				.vsync_irq = MALIDP550_DC_IRQ_CONF_VALID,
> > +			},
> > +			.input_formats = malidp550_de_formats,
> > +			.n_input_formats = ARRAY_SIZE(malidp550_de_formats),
> > +		},
> > +		.query_hw = malidp650_query_hw,
> > +		.enter_config_mode = malidp550_enter_config_mode,
> > +		.leave_config_mode = malidp550_leave_config_mode,
> > +		.in_config_mode = malidp550_in_config_mode,
> > +		.set_config_valid = malidp550_set_config_valid,
> > +		.modeset = malidp550_modeset,
> > +		.rotmem_required = malidp550_rotmem_required,
> > +	},
> > +};
> > +
> > +u8 malidp_hw_get_format_id(const struct malidp_hw_regmap *map,
> > +			   u8 layer_id, u32 format)
> > +{
> > +	unsigned int i;
> > +
> > +	for (i = 0; i < map->n_input_formats; i++) {
> > +		if (((map->input_formats[i].layer & layer_id) == layer_id) &&
> > +		    (map->input_formats[i].format == format))
> > +			return map->input_formats[i].id;
> > +	}
> > +
> > +	return MALIDP_INVALID_FORMAT_ID;
> > +}
> > +
> > +static void malidp_hw_clear_irq(struct malidp_hw_device *hwdev, u8 block, u32 irq)
> > +{
> > +	u32 base = malidp_get_block_base(hwdev, block);
> > +
> > +	if (hwdev->map.features & MALIDP_REGMAP_HAS_CLEARIRQ)
> > +		malidp_hw_write(hwdev, irq, base + MALIDP_REG_CLEARIRQ);
> > +	else
> > +		malidp_hw_write(hwdev, irq, base + MALIDP_REG_STATUS);
> > +}
> > +
> > +static irqreturn_t malidp_de_irq(int irq, void *arg)
> > +{
> > +	struct drm_device *drm = arg;
> > +	struct malidp_drm *malidp = drm->dev_private;
> > +	struct malidp_hw_device *hwdev;
> > +	const struct malidp_irq_map *de;
> > +	u32 status, mask, dc_status;
> > +	irqreturn_t ret = IRQ_NONE;
> > +
> > +	if (!drm->dev_private)
> > +		return IRQ_HANDLED;
> > +
> > +	hwdev = malidp->dev;
> > +	de = &hwdev->map.de_irq_map;
> > +
> > +	/* first handle the config valid IRQ */
> > +	dc_status = malidp_hw_read(hwdev, hwdev->map.dc_base + MALIDP_REG_STATUS);
> > +	if (dc_status & hwdev->map.dc_irq_map.vsync_irq) {
> > +		/* we have a page flip event */
> > +		atomic_set(&malidp->config_valid, 1);
> > +		malidp_hw_clear_irq(hwdev, MALIDP_DC_BLOCK, dc_status);
> > +		ret = IRQ_WAKE_THREAD;
> > +	}
> > +
> > +	status = malidp_hw_read(hwdev, MALIDP_REG_STATUS);
> > +	if (!(status & de->irq_mask))
> > +		return ret;
> > +
> > +	mask = malidp_hw_read(hwdev, MALIDP_REG_MASKIRQ);
> > +	status &= mask;
> > +	if (status & de->vsync_irq)
> > +		drm_crtc_handle_vblank(&malidp->crtc);
> > +
> > +	malidp_hw_clear_irq(hwdev, MALIDP_DE_BLOCK, status);
> > +
> > +	return (ret == IRQ_NONE) ? IRQ_HANDLED : ret;
> > +}
> > +
> > +static irqreturn_t malidp_de_irq_thread_handler(int irq, void *arg)
> > +{
> > +	struct drm_device *drm = arg;
> > +	struct malidp_drm *malidp = drm->dev_private;
> > +
> > +	wake_up(&malidp->wq);
> > +
> > +	return IRQ_HANDLED;
> > +}
> > +
> > +int malidp_de_irq_init(struct drm_device *drm, int irq)
> > +{
> > +	struct malidp_drm *malidp = drm->dev_private;
> > +	struct malidp_hw_device *hwdev = malidp->dev;
> > +	int ret;
> > +
> > +	/* ensure interrupts are disabled */
> > +	malidp_hw_disable_irq(hwdev, MALIDP_DE_BLOCK, 0xffffffff);
> > +	malidp_hw_clear_irq(hwdev, MALIDP_DE_BLOCK, 0xffffffff);
> > +	malidp_hw_disable_irq(hwdev, MALIDP_DC_BLOCK, 0xffffffff);
> > +	malidp_hw_clear_irq(hwdev, MALIDP_DC_BLOCK, 0xffffffff);
> > +
> > +	ret = devm_request_threaded_irq(drm->dev, irq, malidp_de_irq,
> > +					malidp_de_irq_thread_handler,
> > +					IRQF_SHARED, "malidp-de", drm);
> > +	if (ret < 0) {
> > +		DRM_ERROR("failed to install DE IRQ handler\n");
> > +		return ret;
> > +	}
> > +
> > +	/* first enable the DC block IRQs */
> > +	malidp_hw_enable_irq(hwdev, MALIDP_DC_BLOCK,
> > +			     hwdev->map.dc_irq_map.irq_mask);
> > +
> > +	/* now enable the DE block IRQs */
> > +	malidp_hw_enable_irq(hwdev, MALIDP_DE_BLOCK,
> > +			     hwdev->map.de_irq_map.irq_mask);
> > +
> > +	return 0;
> > +}
> > +
> > +void malidp_de_irq_fini(struct drm_device *drm)
> > +{
> > +	struct malidp_drm *malidp = drm->dev_private;
> > +	struct malidp_hw_device *hwdev = malidp->dev;
> > +
> > +	malidp_hw_disable_irq(hwdev, MALIDP_DE_BLOCK,
> > +			      hwdev->map.de_irq_map.irq_mask);
> > +	malidp_hw_disable_irq(hwdev, MALIDP_DC_BLOCK,
> > +			      hwdev->map.dc_irq_map.irq_mask);
> > +}
> > +
> > +static irqreturn_t malidp_se_irq(int irq, void *arg)
> > +{
> > +	struct drm_device *drm = arg;
> > +	struct malidp_drm *malidp = drm->dev_private;
> > +	struct malidp_hw_device *hwdev = malidp->dev;
> > +	u32 status, mask;
> > +
> > +	status = malidp_hw_read(hwdev, hwdev->map.se_base + MALIDP_REG_STATUS);
> > +	if (!(status & hwdev->map.se_irq_map.irq_mask))
> > +		return IRQ_NONE;
> > +
> > +	mask = malidp_hw_read(hwdev, hwdev->map.se_base + MALIDP_REG_MASKIRQ);
> > +	status = malidp_hw_read(hwdev, hwdev->map.se_base + MALIDP_REG_STATUS);
> > +	status &= mask;
> > +	/* ToDo: status decoding and firing up of VSYNC and page flip events */
> > +
> > +	malidp_hw_clear_irq(hwdev, MALIDP_SE_BLOCK, status);
> > +
> > +	return IRQ_HANDLED;
> > +}
> > +
> > +static irqreturn_t malidp_se_irq_thread_handler(int irq, void *arg)
> > +{
> > +	return IRQ_HANDLED;
> > +}
> > +
> > +int malidp_se_irq_init(struct drm_device *drm, int irq)
> > +{
> > +	struct malidp_drm *malidp = drm->dev_private;
> > +	struct malidp_hw_device *hwdev = malidp->dev;
> > +	int ret;
> > +
> > +	/* ensure interrupts are disabled */
> > +	malidp_hw_disable_irq(hwdev, MALIDP_SE_BLOCK, 0xffffffff);
> > +	malidp_hw_clear_irq(hwdev, MALIDP_SE_BLOCK, 0xffffffff);
> > +
> > +	ret = devm_request_threaded_irq(drm->dev, irq, malidp_se_irq,
> > +					malidp_se_irq_thread_handler,
> > +					IRQF_SHARED, "malidp-se", drm);
> > +	if (ret < 0) {
> > +		DRM_ERROR("failed to install SE IRQ handler\n");
> > +		return ret;
> > +	}
> > +
> > +	malidp_hw_enable_irq(hwdev, MALIDP_SE_BLOCK,
> > +			     hwdev->map.se_irq_map.irq_mask);
> > +
> > +	return 0;
> > +}
> > +
> > +void malidp_se_irq_fini(struct drm_device *drm)
> > +{
> > +	struct malidp_drm *malidp = drm->dev_private;
> > +	struct malidp_hw_device *hwdev = malidp->dev;
> > +
> > +	malidp_hw_disable_irq(hwdev, MALIDP_SE_BLOCK,
> > +			      hwdev->map.se_irq_map.irq_mask);
> > +}
> > diff --git a/drivers/gpu/drm/arm/malidp_hw.h b/drivers/gpu/drm/arm/malidp_hw.h
> > new file mode 100644
> > index 0000000..141743e
> > --- /dev/null
> > +++ b/drivers/gpu/drm/arm/malidp_hw.h
> > @@ -0,0 +1,241 @@
> > +/*
> > + *
> > + * (C) COPYRIGHT 2013-2016 ARM Limited. All rights reserved.
> > + *
> > + * This program is free software and is provided to you under the terms of the
> > + * GNU General Public License version 2 as published by the Free Software
> > + * Foundation, and any use by you of this program is subject to the terms
> > + * of such GNU licence.
> > + *
> > + * ARM Mali DP hardware manipulation routines.
> > + */
> > +
> > +#ifndef __MALIDP_HW_H__
> > +#define __MALIDP_HW_H__
> > +
> > +#include <linux/bitops.h>
> > +#include "malidp_regs.h"
> > +
> > +struct videomode;
> > +struct clk;
> > +
> > +/* Mali DP IP blocks */
> > +enum {
> > +	MALIDP_DE_BLOCK = 0,
> > +	MALIDP_SE_BLOCK,
> > +	MALIDP_DC_BLOCK
> > +};
> > +
> > +/* Mali DP layer IDs */
> > +enum {
> > +	DE_VIDEO1 = BIT(0),
> > +	DE_GRAPHICS1 = BIT(1),
> > +	DE_GRAPHICS2 = BIT(2), /* used only in DP500 */
> > +	DE_VIDEO2 = BIT(3),
> > +	DE_SMART = BIT(4),
> > +};
> > +
> > +struct malidp_input_format {
> > +	u32 format;		/* DRM fourcc */
> > +	u8 layer;		/* bitmask of layers supporting it */
> > +	u8 id;			/* used internally */
> > +};
> > +
> > +#define MALIDP_INVALID_FORMAT_ID	0xff
> > +
> > +/*
> > + * hide the differences between register maps
> > + * by using a common structure to hold the
> > + * base register offsets
> > + */
> > +
> > +struct malidp_irq_map {
> > +	u32 irq_mask;		/* mask of IRQs that can be enabled in the block */
> > +	u32 vsync_irq;		/* IRQ bit used for signaling during VSYNC */
> > +};
> > +
> > +struct malidp_layer {
> > +	u16 id;			/* layer ID */
> > +	u16 base;		/* address offset for the register bank */
> > +	u16 ptr;		/* address offset for the pointer register */
> > +};
> > +
> > +/* regmap features */
> > +#define MALIDP_REGMAP_HAS_CLEARIRQ	(1 << 0)
> > +
> > +struct malidp_hw_regmap {
> > +	/* address offset of the DE register bank */
> > +	/* is always 0x0000 */
> > +	/* address offset of the SE registers bank */
> > +	const u16 se_base;
> > +	/* address offset of the DC registers bank */
> > +	const u16 dc_base;
> > +
> > +	/* address offset for the output depth register */
> > +	const u16 out_depth_base;
> > +
> > +	/* bitmap with register map features */
> > +	const u8 features;
> > +
> > +	/* list of supported layers */
> > +	const u8 n_layers;
> > +	const struct malidp_layer *layers;
> > +
> > +	const struct malidp_irq_map de_irq_map;
> > +	const struct malidp_irq_map se_irq_map;
> > +	const struct malidp_irq_map dc_irq_map;
> > +
> > +	/* list of supported input formats for each layer */
> > +	const struct malidp_input_format *input_formats;
> > +	const u8 n_input_formats;
> > +};
> > +
> > +struct malidp_hw_device {
> > +	const struct malidp_hw_regmap map;
> > +	void __iomem *regs;
> > +
> > +	/* APB clock */
> > +	struct clk *pclk;
> > +	/* AXI clock */
> > +	struct clk *aclk;
> > +	/* main clock for display core */
> > +	struct clk *mclk;
> > +	/* pixel clock for display core */
> > +	struct clk *pxlclk;
> > +
> > +	/*
> > +	 * Validate the driver instance against the hardware bits
> > +	 */
> > +	int (*query_hw)(struct malidp_hw_device *hwdev);
> > +
> > +	/*
> > +	 * Set the hardware into config mode, ready to accept mode changes
> > +	 */
> > +	void (*enter_config_mode)(struct malidp_hw_device *hwdev);
> > +
> > +	/*
> > +	 * Tell hardware to exit configuration mode
> > +	 */
> > +	void (*leave_config_mode)(struct malidp_hw_device *hwdev);
> > +
> > +	/*
> > +	 * Query if hardware is in configuration mode
> > +	 */
> > +	bool (*in_config_mode)(struct malidp_hw_device *hwdev);
> > +
> > +	/*
> > +	 * Set configuration valid flag for hardware parameters that can
> > +	 * be changed outside the configuration mode. Hardware will use
> > +	 * the new settings when config valid is set after the end of the
> > +	 * current buffer scanout
> > +	 */
> > +	void (*set_config_valid)(struct malidp_hw_device *hwdev);
> > +
> > +	/*
> > +	 * Set a new mode in hardware. Requires the hardware to be in
> > +	 * configuration mode before this function is called.
> > +	 */
> > +	void (*modeset)(struct malidp_hw_device *hwdev, struct videomode *m);
> > +
> > +	/*
> > +	 * Calculate the required rotation memory given the active area
> > +	 * and the buffer format.
> > +	 */
> > +	int (*rotmem_required)(struct malidp_hw_device *hwdev, u16 w, u16 h, u32 fmt);
> > +
> > +	u8 features;
> > +
> > +	u8 min_line_size;
> > +	u16 max_line_size;
> > +
> > +	/* size of memory used for rotating layers, up to two banks available */
> > +	u32 rotation_memory[2];
> > +};
> > +
> > +/* Supported variants of the hardware */
> > +enum {
> > +	MALIDP_500 = 0,
> > +	MALIDP_550,
> > +	MALIDP_650,
> > +	/* keep the next entry last */
> > +	MALIDP_MAX_DEVICES
> > +};
> > +
> > +extern const struct malidp_hw_device malidp_device[MALIDP_MAX_DEVICES];
> > +
> > +static inline u32 malidp_hw_read(struct malidp_hw_device *hwdev, u32 reg)
> > +{
> > +	return readl(hwdev->regs + reg);
> > +}
> > +
> > +static inline void malidp_hw_write(struct malidp_hw_device *hwdev,
> > +				   u32 value, u32 reg)
> > +{
> > +	writel(value, hwdev->regs + reg);
> > +}
> > +
> > +static inline void malidp_hw_setbits(struct malidp_hw_device *hwdev,
> > +				     u32 mask, u32 reg)
> > +{
> > +	u32 data = malidp_hw_read(hwdev, reg);
> > +
> > +	data |= mask;
> > +	malidp_hw_write(hwdev, data, reg);
> > +}
> > +
> > +static inline void malidp_hw_clearbits(struct malidp_hw_device *hwdev,
> > +				       u32 mask, u32 reg)
> > +{
> > +	u32 data = malidp_hw_read(hwdev, reg);
> > +
> > +	data &= ~mask;
> > +	malidp_hw_write(hwdev, data, reg);
> > +}
> > +
> > +static inline u32 malidp_get_block_base(struct malidp_hw_device *hwdev,
> > +					u8 block)
> > +{
> > +	switch (block) {
> > +	case MALIDP_SE_BLOCK:
> > +		return hwdev->map.se_base;
> > +	case MALIDP_DC_BLOCK:
> > +		return hwdev->map.dc_base;
> > +	}
> > +
> > +	return 0;
> > +}
> > +
> > +static inline void malidp_hw_disable_irq(struct malidp_hw_device *hwdev,
> > +					 u8 block, u32 irq)
> > +{
> > +	u32 base = malidp_get_block_base(hwdev, block);
> > +
> > +	malidp_hw_clearbits(hwdev, irq, base + MALIDP_REG_MASKIRQ);
> > +}
> > +
> > +static inline void malidp_hw_enable_irq(struct malidp_hw_device *hwdev,
> > +					u8 block, u32 irq)
> > +{
> > +	u32 base = malidp_get_block_base(hwdev, block);
> > +
> > +	malidp_hw_setbits(hwdev, irq, base + MALIDP_REG_MASKIRQ);
> > +}
> > +
> > +int malidp_de_irq_init(struct drm_device *drm, int irq);
> > +void malidp_de_irq_fini(struct drm_device *drm);
> > +int malidp_se_irq_init(struct drm_device *drm, int irq);
> > +void malidp_se_irq_fini(struct drm_device *drm);
> > +
> > +u8 malidp_hw_get_format_id(const struct malidp_hw_regmap *map,
> > +			   u8 layer_id, u32 format);
> > +
> > +/*
> > + * background color components are defined as 12bits values,
> > + * they will be shifted right when stored on hardware that
> > + * supports only 8bits per channel
> > + */
> > +#define MALIDP_BGND_COLOR_R		0x000
> > +#define MALIDP_BGND_COLOR_G		0x000
> > +#define MALIDP_BGND_COLOR_B		0x000
> > +
> > +#endif  /* __MALIDP_HW_H__ */
> > diff --git a/drivers/gpu/drm/arm/malidp_planes.c b/drivers/gpu/drm/arm/malidp_planes.c
> > new file mode 100644
> > index 0000000..725098d
> > --- /dev/null
> > +++ b/drivers/gpu/drm/arm/malidp_planes.c
> > @@ -0,0 +1,298 @@
> > +/*
> > + * (C) COPYRIGHT 2016 ARM Limited. All rights reserved.
> > + * Author: Liviu Dudau <Liviu.Dudau@arm.com>
> > + *
> > + * This program is free software and is provided to you under the terms of the
> > + * GNU General Public License version 2 as published by the Free Software
> > + * Foundation, and any use by you of this program is subject to the terms
> > + * of such GNU licence.
> > + *
> > + * ARM Mali DP plane manipulation routines.
> > + */
> > +
> > +#include <drm/drmP.h>
> > +#include <drm/drm_atomic_helper.h>
> > +#include <drm/drm_fb_cma_helper.h>
> > +#include <drm/drm_gem_cma_helper.h>
> > +#include <drm/drm_plane_helper.h>
> > +
> > +#include "malidp_hw.h"
> > +#include "malidp_drv.h"
> > +
> > +/* Layer specific register offsets */
> > +#define MALIDP_LAYER_FORMAT		0x000
> > +#define MALIDP_LAYER_CONTROL		0x004
> > +#define   LAYER_ENABLE			(1 << 0)
> > +#define   LAYER_ROT_OFFSET		8
> > +#define   LAYER_H_FLIP			(1 << 10)
> > +#define   LAYER_V_FLIP			(1 << 11)
> > +#define   LAYER_ROT_MASK		(0xf << 8)
> > +#define MALIDP_LAYER_SIZE		0x00c
> > +#define   LAYER_H_VAL(x)		(((x) & 0x1fff) << 0)
> > +#define   LAYER_V_VAL(x)		(((x) & 0x1fff) << 16)
> > +#define MALIDP_LAYER_COMP_SIZE		0x010
> > +#define MALIDP_LAYER_OFFSET		0x014
> > +#define MALIDP_LAYER_STRIDE		0x018
> > +
> > +static void malidp_de_plane_destroy(struct drm_plane *plane)
> > +{
> > +	struct malidp_plane *mp = to_malidp_plane(plane);
> > +
> > +	if (mp->base.fb)
> > +		drm_framebuffer_unreference(mp->base.fb);
> > +
> > +	drm_plane_helper_disable(plane);
> > +	drm_plane_cleanup(plane);
> > +	devm_kfree(plane->dev->dev, mp);
> > +}
> > +
> > +struct drm_plane_state *malidp_duplicate_plane_state(struct drm_plane *plane)
> > +{
> > +	struct malidp_plane_state *state, *m_state;
> > +
> > +	if (!plane->state)
> > +		return NULL;
> > +
> > +	state = kmalloc(sizeof(*state), GFP_KERNEL);
> > +	if (state) {
> > +		m_state = to_malidp_plane_state(plane->state);
> > +		__drm_atomic_helper_plane_duplicate_state(plane, &state->base);
> > +		state->rotmem_size = m_state->rotmem_size;
> > +	}
> > +
> > +	return &state->base;
> > +}
> > +
> > +void malidp_destroy_plane_state(struct drm_plane *plane,
> > +				struct drm_plane_state *state)
> > +{
> > +	struct malidp_plane_state *m_state = to_malidp_plane_state(state);
> > +
> > +	__drm_atomic_helper_plane_destroy_state(state);
> > +	kfree(m_state);
> > +}
> > +
> > +static const struct drm_plane_funcs malidp_de_plane_funcs = {
> > +	.update_plane = drm_atomic_helper_update_plane,
> > +	.disable_plane = drm_atomic_helper_disable_plane,
> > +	.destroy = malidp_de_plane_destroy,
> > +	.reset = drm_atomic_helper_plane_reset,
> > +	.atomic_duplicate_state = malidp_duplicate_plane_state,
> > +	.atomic_destroy_state = malidp_destroy_plane_state,
> > +};
> > +
> > +static int malidp_de_plane_check(struct drm_plane *plane,
> > +				 struct drm_plane_state *state)
> > +{
> > +	struct malidp_plane *mp = to_malidp_plane(plane);
> > +	struct malidp_plane_state *ms = to_malidp_plane_state(state);
> > +	u8 format_id;
> > +	u32 src_w, src_h;
> > +
> > +	if (!state->crtc || !state->fb)
> > +		return 0;
> > +
> > +	format_id = malidp_hw_get_format_id(&mp->hwdev->map, mp->layer->id,
> > +					    state->fb->pixel_format);
> > +	if (format_id == MALIDP_INVALID_FORMAT_ID)
> > +		return -EINVAL;
> > +
> > +	src_w = state->src_w >> 16;
> > +	src_h = state->src_h >> 16;
> > +
> > +	if ((state->crtc_w > mp->hwdev->max_line_size) ||
> > +	    (state->crtc_h > mp->hwdev->max_line_size) ||
> > +	    (state->crtc_w < mp->hwdev->min_line_size) ||
> > +	    (state->crtc_h < mp->hwdev->min_line_size) ||
> > +	    (state->crtc_w != src_w) || (state->crtc_h != src_h))
> > +		return -EINVAL;
> > +
> > +	/* packed RGB888 / BGR888 can't be rotated or flipped */
> > +	if (state->rotation != BIT(DRM_ROTATE_0) &&
> > +	    (state->fb->pixel_format == DRM_FORMAT_RGB888 ||
> > +	     state->fb->pixel_format == DRM_FORMAT_BGR888))
> > +		return -EINVAL;
> > +
> > +	ms->rotmem_size = 0;
> > +	if (state->rotation & MALIDP_ROTATED_MASK) {
> > +		int val;
> > +
> > +		val = mp->hwdev->rotmem_required(mp->hwdev, state->crtc_h,
> > +						 state->crtc_w,
> > +						 state->fb->pixel_format);
> > +		if (val < 0)
> > +			return val;
> > +
> > +		ms->rotmem_size = val;
> > +	}
> > +
> > +	return 0;
> > +}
> > +
> > +static void malidp_de_plane_update(struct drm_plane *plane,
> > +				   struct drm_plane_state *old_state)
> > +{
> > +	struct drm_gem_cma_object *obj;
> > +	struct malidp_plane *mp;
> > +	const struct malidp_hw_regmap *map;
> > +	u8 format_id;
> > +	u16 ptr;
> > +	u32 format, src_w, src_h, dest_w, dest_h, val = 0;
> > +	int num_planes, i;
> > +
> > +	mp = to_malidp_plane(plane);
> > +
> > +	map = &mp->hwdev->map;
> > +	format = plane->state->fb->pixel_format;
> > +	format_id = malidp_hw_get_format_id(map, mp->layer->id, format);
> > +	num_planes = drm_format_num_planes(format);
> > +
> > +	/* convert src values from Q16 fixed point to integer */
> > +	src_w = plane->state->src_w >> 16;
> > +	src_h = plane->state->src_h >> 16;
> > +	if (plane->state->rotation & MALIDP_ROTATED_MASK) {
> > +		dest_w = plane->state->crtc_h;
> > +		dest_h = plane->state->crtc_w;
> > +	} else {
> > +		dest_w = plane->state->crtc_w;
> > +		dest_h = plane->state->crtc_h;
> > +	}
> > +
> > +	malidp_hw_write(mp->hwdev, format_id, mp->layer->base);
> > +
> > +	for (i = 0; i < num_planes; i++) {
> > +		/* calculate the offset for the layer's plane registers */
> > +		ptr = mp->layer->ptr + (i << 4);
> > +
> > +		obj = drm_fb_cma_get_gem_obj(plane->state->fb, i);
> > +		malidp_hw_write(mp->hwdev, lower_32_bits(obj->paddr), ptr);
> > +		malidp_hw_write(mp->hwdev, upper_32_bits(obj->paddr), ptr + 4);
> > +		malidp_hw_write(mp->hwdev, plane->state->fb->pitches[i],
> > +				mp->layer->base + MALIDP_LAYER_STRIDE);
> > +	}
> > +
> > +	malidp_hw_write(mp->hwdev, LAYER_H_VAL(src_w) | LAYER_V_VAL(src_h),
> > +			mp->layer->base + MALIDP_LAYER_SIZE);
> > +
> > +	malidp_hw_write(mp->hwdev, LAYER_H_VAL(dest_w) | LAYER_V_VAL(dest_h),
> > +			mp->layer->base + MALIDP_LAYER_COMP_SIZE);
> > +
> > +	malidp_hw_write(mp->hwdev, LAYER_H_VAL(plane->state->crtc_x) |
> > +			LAYER_V_VAL(plane->state->crtc_y),
> > +			mp->layer->base + MALIDP_LAYER_OFFSET);
> > +
> > +	/* first clear the rotation bits in the register */
> > +	malidp_hw_clearbits(mp->hwdev, LAYER_ROT_MASK,
> > +			    mp->layer->base + MALIDP_LAYER_CONTROL);
> > +
> > +	/* setup the rotation and axis flip bits */
> > +	if (plane->state->rotation & DRM_ROTATE_MASK)
> > +		val = ilog2(plane->state->rotation & DRM_ROTATE_MASK) << LAYER_ROT_OFFSET;
> > +	if (plane->state->rotation & BIT(DRM_REFLECT_X))
> > +		val |= LAYER_V_FLIP;
> > +	if (plane->state->rotation & BIT(DRM_REFLECT_Y))
> > +		val |= LAYER_H_FLIP;
> > +
> > +	/* set the 'enable layer' bit */
> > +	val |= LAYER_ENABLE;
> > +
> > +	malidp_hw_setbits(mp->hwdev, val,
> > +			  mp->layer->base + MALIDP_LAYER_CONTROL);
> > +}
> > +
> > +static void malidp_de_plane_disable(struct drm_plane *plane,
> > +				    struct drm_plane_state *state)
> > +{
> > +	struct malidp_plane *mp = to_malidp_plane(plane);
> > +
> > +	malidp_hw_clearbits(mp->hwdev, LAYER_ENABLE,
> > +			    mp->layer->base + MALIDP_LAYER_CONTROL);
> > +}
> > +
> > +static const struct drm_plane_helper_funcs malidp_de_plane_helper_funcs = {
> > +	.atomic_check = malidp_de_plane_check,
> > +	.atomic_update = malidp_de_plane_update,
> > +	.atomic_disable = malidp_de_plane_disable,
> > +};
> > +
> > +int malidp_de_planes_init(struct drm_device *drm)
> > +{
> > +	struct malidp_drm *malidp = drm->dev_private;
> > +	const struct malidp_hw_regmap *map = &malidp->dev->map;
> > +	struct malidp_plane *plane = NULL;
> > +	enum drm_plane_type plane_type;
> > +	unsigned long crtcs = 1 << drm->mode_config.num_crtc;
> > +	u32 *formats;
> > +	int ret, i, j, n;
> > +
> > +	formats = kcalloc(map->n_input_formats, sizeof(*formats), GFP_KERNEL);
> > +	if (!formats) {
> > +		ret = -ENOMEM;
> > +		goto cleanup;
> > +	}
> > +
> > +	for (i = 0; i < map->n_layers; i++) {
> > +		u8 id = map->layers[i].id;
> > +
> > +		plane = kzalloc(sizeof(*plane), GFP_KERNEL);
> > +		if (!plane) {
> > +			ret = -ENOMEM;
> > +			goto cleanup;
> > +		}
> > +
> > +		/* build the list of DRM supported formats based on the map */
> > +		for (n = 0, j = 0;  j < map->n_input_formats; j++) {
> > +			if ((map->input_formats[j].layer & id) == id)
> > +				formats[n++] = map->input_formats[j].format;
> > +		}
> > +
> > +		plane_type = (i == 0) ? DRM_PLANE_TYPE_PRIMARY :
> > +					DRM_PLANE_TYPE_OVERLAY;
> > +		ret = drm_universal_plane_init(drm, &plane->base, crtcs,
> > +					       &malidp_de_plane_funcs, formats,
> > +					       n, plane_type, NULL);
> > +		if (ret < 0)
> > +			goto cleanup;
> > +
> > +		if (!drm->mode_config.rotation_property) {
> > +			unsigned long flags = BIT(DRM_ROTATE_0) |
> > +					      BIT(DRM_ROTATE_90) |
> > +					      BIT(DRM_ROTATE_180) |
> > +					      BIT(DRM_ROTATE_270) |
> > +					      BIT(DRM_REFLECT_X) |
> > +					      BIT(DRM_REFLECT_Y);
> > +			drm->mode_config.rotation_property =
> > +				drm_mode_create_rotation_property(drm, flags);
> > +		}
> > +		/* SMART layer can't be rotated */
> > +		if (drm->mode_config.rotation_property && (id != DE_SMART))
> > +			drm_object_attach_property(&plane->base.base,
> > +						   drm->mode_config.rotation_property,
> > +						   BIT(DRM_ROTATE_0));
> > +
> > +		drm_plane_helper_add(&plane->base,
> > +				     &malidp_de_plane_helper_funcs);
> > +		plane->hwdev = malidp->dev;
> > +		plane->layer = &map->layers[i];
> > +	}
> > +
> > +	kfree(formats);
> > +
> > +	return 0;
> > +
> > +cleanup:
> > +	malidp_de_planes_destroy(drm);
> > +	kfree(formats);
> > +
> > +	return ret;
> > +}
> > +
> > +void malidp_de_planes_destroy(struct drm_device *drm)
> > +{
> > +	struct drm_plane *p, *pt;
> > +
> > +	list_for_each_entry_safe(p, pt, &drm->mode_config.plane_list, head) {
> > +		drm_plane_cleanup(p);
> > +		kfree(p);
> > +	}
> > +}
> > diff --git a/drivers/gpu/drm/arm/malidp_regs.h b/drivers/gpu/drm/arm/malidp_regs.h
> > new file mode 100644
> > index 0000000..73fecb3
> > --- /dev/null
> > +++ b/drivers/gpu/drm/arm/malidp_regs.h
> > @@ -0,0 +1,172 @@
> > +/*
> > + * (C) COPYRIGHT 2016 ARM Limited. All rights reserved.
> > + * Author: Liviu Dudau <Liviu.Dudau@arm.com>
> > + *
> > + * This program is free software and is provided to you under the terms of the
> > + * GNU General Public License version 2 as published by the Free Software
> > + * Foundation, and any use by you of this program is subject to the terms
> > + * of such GNU licence.
> > + *
> > + * ARM Mali DP500/DP550/DP650 registers definition.
> > + */
> > +
> > +#ifndef __MALIDP_REGS_H__
> > +#define __MALIDP_REGS_H__
> > +
> > +/*
> > + * abbreviations used:
> > + *    - DC - display core (general settings)
> > + *    - DE - display engine
> > + *    - SE - scaling engine
> > + */
> > +
> > +/* interrupt bit masks */
> > +#define MALIDP_DE_IRQ_UNDERRUN			(1 << 0)
> > +
> > +#define MALIDP500_DE_IRQ_AXI_ERR		(1 << 4)
> > +#define MALIDP500_DE_IRQ_VSYNC			(1 << 5)
> > +#define MALIDP500_DE_IRQ_PROG_LINE		(1 << 6)
> > +#define MALIDP500_DE_IRQ_SATURATION		(1 << 7)
> > +#define MALIDP500_DE_IRQ_CONF_VALID		(1 << 8)
> > +#define MALIDP500_DE_IRQ_CONF_MODE		(1 << 11)
> > +#define MALIDP500_DE_IRQ_CONF_ACTIVE		(1 << 17)
> > +#define MALIDP500_DE_IRQ_PM_ACTIVE		(1 << 18)
> > +#define MALIDP500_DE_IRQ_TESTMODE_ACTIVE	(1 << 19)
> > +#define MALIDP500_DE_IRQ_FORCE_BLNK_ACTIVE	(1 << 24)
> > +#define MALIDP500_DE_IRQ_AXI_BUSY		(1 << 28)
> > +#define MALIDP500_DE_IRQ_GLOBAL			(1 << 31)
> > +#define MALIDP500_SE_IRQ_CONF_MODE		(1 << 0)
> > +#define MALIDP500_SE_IRQ_CONF_VALID		(1 << 4)
> > +#define MALIDP500_SE_IRQ_INIT_BUSY		(1 << 5)
> > +#define MALIDP500_SE_IRQ_AXI_ERROR		(1 << 8)
> > +#define MALIDP500_SE_IRQ_OVERRUN		(1 << 9)
> > +#define MALIDP500_SE_IRQ_PROG_LINE1		(1 << 12)
> > +#define MALIDP500_SE_IRQ_PROG_LINE2		(1 << 13)
> > +#define MALIDP500_SE_IRQ_CONF_ACTIVE		(1 << 17)
> > +#define MALIDP500_SE_IRQ_PM_ACTIVE		(1 << 18)
> > +#define MALIDP500_SE_IRQ_AXI_BUSY		(1 << 28)
> > +#define MALIDP500_SE_IRQ_GLOBAL			(1 << 31)
> > +
> > +#define MALIDP550_DE_IRQ_SATURATION		(1 << 8)
> > +#define MALIDP550_DE_IRQ_VSYNC			(1 << 12)
> > +#define MALIDP550_DE_IRQ_PROG_LINE		(1 << 13)
> > +#define MALIDP550_DE_IRQ_AXI_ERR		(1 << 16)
> > +#define MALIDP550_SE_IRQ_EOW			(1 << 0)
> > +#define MALIDP550_SE_IRQ_AXI_ERR		(1 << 16)
> > +#define MALIDP550_DC_IRQ_CONF_VALID		(1 << 0)
> > +#define MALIDP550_DC_IRQ_CONF_MODE		(1 << 4)
> > +#define MALIDP550_DC_IRQ_CONF_ACTIVE		(1 << 16)
> > +#define MALIDP550_DC_IRQ_DE			(1 << 20)
> > +#define MALIDP550_DC_IRQ_SE			(1 << 24)
> > +
> > +#define MALIDP650_DE_IRQ_DRIFT			(1 << 4)
> > +
> > +/* bit masks that are common between products */
> > +#define   MALIDP_CFG_VALID		(1 << 0)
> > +#define   MALIDP_DISP_FUNC_ILACED	(1 << 8)
> > +
> > +/* register offsets for IRQ management */
> > +#define MALIDP_REG_STATUS		0x00000
> > +#define MALIDP_REG_SETIRQ		0x00004
> > +#define MALIDP_REG_MASKIRQ		0x00008
> > +#define MALIDP_REG_CLEARIRQ		0x0000c
> > +
> > +/* register offsets */
> > +#define MALIDP_DE_CORE_ID		0x00018
> > +#define MALIDP_DE_DISPLAY_FUNC		0x00020
> > +
> > +/* these offsets are relative to MALIDP5x0_TIMINGS_BASE */
> > +#define MALIDP_DE_H_TIMINGS		0x0
> > +#define MALIDP_DE_V_TIMINGS		0x4
> > +#define MALIDP_DE_SYNC_WIDTH		0x8
> > +#define MALIDP_DE_HV_ACTIVE		0xc
> > +
> > +/* macros to set values into registers */
> > +#define MALIDP_DE_H_FRONTPORCH(x)	(((x) & 0xfff) << 0)
> > +#define MALIDP_DE_H_BACKPORCH(x)	(((x) & 0x3ff) << 16)
> > +#define MALIDP500_DE_V_FRONTPORCH(x)	(((x) & 0xff) << 0)
> > +#define MALIDP550_DE_V_FRONTPORCH(x)	(((x) & 0xfff) << 0)
> > +#define MALIDP_DE_V_BACKPORCH(x)	(((x) & 0xff) << 16)
> > +#define MALIDP_DE_H_SYNCWIDTH(x)	(((x) & 0x3ff) << 0)
> > +#define MALIDP_DE_V_SYNCWIDTH(x)	(((x) & 0xff) << 16)
> > +#define MALIDP_DE_H_ACTIVE(x)		(((x) & 0x1fff) << 0)
> > +#define MALIDP_DE_V_ACTIVE(x)		(((x) & 0x1fff) << 16)
> > +
> > +/* register offsets and bits specific to DP500 */
> > +#define MALIDP500_DC_BASE		0x00000
> > +#define MALIDP500_DC_CONTROL		0x0000c
> > +#define   MALIDP500_DC_CONFIG_REQ	(1 << 17)
> > +#define   MALIDP500_HSYNCPOL		(1 << 20)
> > +#define   MALIDP500_VSYNCPOL		(1 << 21)
> > +#define   MALIDP500_DC_CLEAR_MASK	0x300fff
> > +#define MALIDP500_DE_LINE_COUNTER	0x00010
> > +#define MALIDP500_DE_AXI_CONTROL	0x00014
> > +#define MALIDP500_DE_SECURE_CTRL	0x0001c
> > +#define MALIDP500_DE_CHROMA_KEY		0x00024
> > +#define MALIDP500_TIMINGS_BASE		0x00028
> > +
> > +#define MALIDP500_CONFIG_3D		0x00038
> > +#define MALIDP500_BGND_COLOR		0x0003c
> > +#define MALIDP500_OUTPUT_DEPTH		0x00044
> > +#define MALIDP500_YUV_RGB_COEF		0x00048
> > +#define MALIDP500_COLOR_ADJ_COEF	0x00078
> > +#define MALIDP500_COEF_TABLE_ADDR	0x000a8
> > +#define MALIDP500_COEF_TABLE_DATA	0x000ac
> > +#define MALIDP500_DE_LV_BASE		0x00100
> > +#define MALIDP500_DE_LV_PTR_BASE	0x00124
> > +#define MALIDP500_DE_LG1_BASE		0x00200
> > +#define MALIDP500_DE_LG1_PTR_BASE	0x0021c
> > +#define MALIDP500_DE_LG2_BASE		0x00300
> > +#define MALIDP500_DE_LG2_PTR_BASE	0x0031c
> > +#define MALIDP500_SE_BASE		0x00c00
> > +#define MALIDP500_SE_PTR_BASE		0x00e0c
> > +#define MALIDP500_DC_IRQ_BASE		0x00f00
> > +#define MALIDP500_CONFIG_VALID		0x00f00
> > +#define MALIDP500_CONFIG_ID		0x00fd4
> > +
> > +/* register offsets and bits specific to DP550/DP650 */
> > +#define MALIDP550_DE_CONTROL		0x00010
> > +#define MALIDP550_DE_LINE_COUNTER	0x00014
> > +#define MALIDP550_DE_AXI_CONTROL	0x00018
> > +#define MALIDP550_DE_QOS		0x0001c
> > +#define MALIDP550_TIMINGS_BASE		0x00030
> > +#define MALIDP550_HSYNCPOL		(1 << 12)
> > +#define MALIDP550_VSYNCPOL		(1 << 28)
> > +
> > +#define MALIDP550_DE_DISP_SIDEBAND	0x00040
> > +#define MALIDP550_DE_BGND_COLOR		0x00044
> > +#define MALIDP550_DE_OUTPUT_DEPTH	0x0004c
> > +#define MALIDP550_DE_COLOR_COEF		0x00050
> > +#define MALIDP550_DE_COEF_TABLE_ADDR	0x00080
> > +#define MALIDP550_DE_COEF_TABLE_DATA	0x00084
> > +#define MALIDP550_DE_LV1_BASE		0x00100
> > +#define MALIDP550_DE_LV1_PTR_BASE	0x00124
> > +#define MALIDP550_DE_LV2_BASE		0x00200
> > +#define MALIDP550_DE_LV2_PTR_BASE	0x00224
> > +#define MALIDP550_DE_LG_BASE		0x00300
> > +#define MALIDP550_DE_LG_PTR_BASE	0x0031c
> > +#define MALIDP550_DE_LS_BASE		0x00400
> > +#define MALIDP550_DE_LS_PTR_BASE	0x0042c
> > +#define MALIDP550_DE_PERF_BASE		0x00500
> > +#define MALIDP550_SE_BASE		0x08000
> > +#define MALIDP550_DC_BASE		0x0c000
> > +#define MALIDP550_DC_CONTROL		0x0c010
> > +#define   MALIDP550_DC_CONFIG_REQ	(1 << 16)
> > +#define MALIDP550_CONFIG_VALID		0x0c014
> > +#define MALIDP550_CONFIG_ID		0x0ffd4
> > +
> > +/*
> > + * Starting with DP550 the register map blocks has been standardised to the
> > + * following layout:
> > + *
> > + *   Offset            Block registers
> > + *  0x00000            Display Engine
> > + *  0x08000            Scaling Engine
> > + *  0x0c000            Display Core
> > + *  0x10000            Secure control
> > + *
> > + * The old DP500 IP mixes some DC with the DE registers, hence the need
> > + * for a mapping structure.
> > + */
> > +
> > +#endif /* __MALIDP_REGS_H__ */
> > -- 
> > 2.8.2
> > 
> 
> -- 
> Daniel Vetter
> Software Engineer, Intel Corporation
> http://blog.ffwll.ch
> 

-- 
====================
| I would like to |
| fix the world,  |
| but they're not |
| giving me the   |
 \ source code!  /
  ---------------
    ?\_(?)_/?