[PATCH v9 5/6] drm/imx: Introduce i.MX8qm/qxp DPU DRM
Laurentiu Palcu
laurentiu.palcu at oss.nxp.com
Wed Apr 21 11:12:54 UTC 2021
Hi,
On Mon, Mar 29, 2021 at 01:57:25PM +0800, Liu Ying wrote:
> This patch introduces i.MX8qm/qxp Display Processing Unit(DPU) DRM support.
>
> DPU is comprised of two main components that include a blit engine for
> 2D graphics accelerations(with composition support) and a display controller
> for display output processing, as well as a command sequencer. Outside of
> DPU, optional prefetch engines, a.k.a, Prefetch Resolve Gasket(PRG) and
> Display Prefetch Resolve(DPR), can fetch data from memory prior to some DPU
> fetchunits of blit engine and display controller. The prefetch engines
> support reading linear formats and resolving Vivante GPU tile formats.
>
> This patch adds kernel modesetting support for the display controller part.
> The driver supports two CRTCs per display controller, planes backed by
> four fetchunits(decode0/1, fetchlayer, fetchwarp), fetchunit allocation
> logic for the two CRTCs, prefetch engines(with tile resolving supported),
> plane upscaling/deinterlacing/yuv2rgb CSC/alpha blending and CRTC gamma
> correction. The registers of the controller is accessed without command
> sequencer involved, instead just by using CPU.
>
> Reference manual can be found at:
> https://www.nxp.com/webapp/Download?colCode=IMX8DQXPRM
>
> Signed-off-by: Liu Ying <victor.liu at nxp.com>
Reviewed-by: Laurentiu Palcu <laurentiu.palcu at oss.nxp.com>
Thanks,
laurentiu
> ---
> v8->v9:
> * Use drm_atomic_get_new_plane_state() in dpu_plane_atomic_update(). (Laurentiu)
> * Drop getting DPU DT alias ID, as it is unused.
> * Get the DPR interrupt(dpr_wrap) by name.
>
> v7->v8:
> * Update dpu_plane_atomic_check() and dpu_plane_atomic_update(), due to DRM
> plane helper functions API change(atomic_check and atomic_update) from DRM
> atomic core. Also, rename plane->state variables and relevant DPU plane
> state variables in those two functions to reflect they are new states, like
> the patch 'drm: Rename plane->state variables in atomic update and disable'
> recently landed in drm-misc-next.
> * Replace drm_gem_fb_prepare_fb() with drm_gem_plane_helper_prepare_fb(),
> due to DRM core API change.
> * Use 256byte DPR burst length for GPU standard tile and 128byte DPR burst
> length for 32bpp GPU super tile to align with the latest version of internal
> HW documention.
>
> v6->v7:
> * Fix return value of dpu_get_irqs() if platform_get_irq() fails. (Laurentiu)
> * Use the function array dpu_irq_handler[] to store individual DPU irq handlers.
> (Laurentiu)
> * Call get/put() hooks directly to get/put DPU fetchunits for DPU plane groups.
> (Laurentiu)
> * Shorten the names of individual DPU irq handlers by using DPU unit abbrev
> names to make writing dpu_irq_handler[] easier.
>
> v5->v6:
> * Do not use macros where possible. (Laurentiu)
> * Break dpu_plane_atomic_check() into some smaller functions. (Laurentiu)
> * Address some minor comments from Laurentiu.
> * Add dpu_crtc_err() helper marco to tell dmesg which CRTC generates error.
> * Drop calling dev_set_drvdata() from dpu_drm_bind/unbind() as it is done
> in dpu_drm_probe().
> * Some trivial tweaks.
>
> v4->v5:
> * Rebase up onto the latest drm-misc-next branch and remove the hook to
> drm_atomic_helper_legacy_gamma_set(), because it was dropped by the newly
> landed commit 'drm: automatic legacy gamma support'.
> * Remove a redundant blank line from dpu_plane_atomic_update().
>
> v3->v4:
> * No change.
>
> v2->v3:
> * Fix build warnings Reported-by: kernel test robot <lkp at intel.com>.
> * Drop build dependency on IMX_SCU, as dummy SCU functions have been added in
> header files by the patch 'firmware: imx: add dummy functions' which has
> landed in linux-next/master branch.
>
> v1->v2:
> * Add compatible for i.MX8qm DPU, as this is tested with i.MX8qm LVDS displays.
> (Laurentiu)
> * Fix PRG burst size and stride. (Laurentiu)
> * Put 'ports' OF node to fix the bail-out logic in dpu_drm_probe(). (Laurentiu)
>
> drivers/gpu/drm/imx/Kconfig | 1 +
> drivers/gpu/drm/imx/Makefile | 1 +
> drivers/gpu/drm/imx/dpu/Kconfig | 10 +
> drivers/gpu/drm/imx/dpu/Makefile | 10 +
> drivers/gpu/drm/imx/dpu/dpu-constframe.c | 171 +++++
> drivers/gpu/drm/imx/dpu/dpu-core.c | 1047 +++++++++++++++++++++++++++++
> drivers/gpu/drm/imx/dpu/dpu-crtc.c | 967 ++++++++++++++++++++++++++
> drivers/gpu/drm/imx/dpu/dpu-crtc.h | 66 ++
> drivers/gpu/drm/imx/dpu/dpu-disengcfg.c | 117 ++++
> drivers/gpu/drm/imx/dpu/dpu-dprc.c | 723 ++++++++++++++++++++
> drivers/gpu/drm/imx/dpu/dpu-dprc.h | 40 ++
> drivers/gpu/drm/imx/dpu/dpu-drv.c | 292 ++++++++
> drivers/gpu/drm/imx/dpu/dpu-drv.h | 28 +
> drivers/gpu/drm/imx/dpu/dpu-extdst.c | 299 ++++++++
> drivers/gpu/drm/imx/dpu/dpu-fetchdecode.c | 294 ++++++++
> drivers/gpu/drm/imx/dpu/dpu-fetcheco.c | 224 ++++++
> drivers/gpu/drm/imx/dpu/dpu-fetchlayer.c | 154 +++++
> drivers/gpu/drm/imx/dpu/dpu-fetchunit.c | 609 +++++++++++++++++
> drivers/gpu/drm/imx/dpu/dpu-fetchunit.h | 191 ++++++
> drivers/gpu/drm/imx/dpu/dpu-fetchwarp.c | 250 +++++++
> drivers/gpu/drm/imx/dpu/dpu-framegen.c | 395 +++++++++++
> drivers/gpu/drm/imx/dpu/dpu-gammacor.c | 223 ++++++
> drivers/gpu/drm/imx/dpu/dpu-hscaler.c | 275 ++++++++
> drivers/gpu/drm/imx/dpu/dpu-kms.c | 540 +++++++++++++++
> drivers/gpu/drm/imx/dpu/dpu-kms.h | 23 +
> drivers/gpu/drm/imx/dpu/dpu-layerblend.c | 348 ++++++++++
> drivers/gpu/drm/imx/dpu/dpu-plane.c | 803 ++++++++++++++++++++++
> drivers/gpu/drm/imx/dpu/dpu-plane.h | 56 ++
> drivers/gpu/drm/imx/dpu/dpu-prg.c | 433 ++++++++++++
> drivers/gpu/drm/imx/dpu/dpu-prg.h | 45 ++
> drivers/gpu/drm/imx/dpu/dpu-prv.h | 231 +++++++
> drivers/gpu/drm/imx/dpu/dpu-tcon.c | 250 +++++++
> drivers/gpu/drm/imx/dpu/dpu-vscaler.c | 308 +++++++++
> drivers/gpu/drm/imx/dpu/dpu.h | 385 +++++++++++
> 34 files changed, 9809 insertions(+)
> create mode 100644 drivers/gpu/drm/imx/dpu/Kconfig
> create mode 100644 drivers/gpu/drm/imx/dpu/Makefile
> create mode 100644 drivers/gpu/drm/imx/dpu/dpu-constframe.c
> create mode 100644 drivers/gpu/drm/imx/dpu/dpu-core.c
> create mode 100644 drivers/gpu/drm/imx/dpu/dpu-crtc.c
> create mode 100644 drivers/gpu/drm/imx/dpu/dpu-crtc.h
> create mode 100644 drivers/gpu/drm/imx/dpu/dpu-disengcfg.c
> create mode 100644 drivers/gpu/drm/imx/dpu/dpu-dprc.c
> create mode 100644 drivers/gpu/drm/imx/dpu/dpu-dprc.h
> create mode 100644 drivers/gpu/drm/imx/dpu/dpu-drv.c
> create mode 100644 drivers/gpu/drm/imx/dpu/dpu-drv.h
> create mode 100644 drivers/gpu/drm/imx/dpu/dpu-extdst.c
> create mode 100644 drivers/gpu/drm/imx/dpu/dpu-fetchdecode.c
> create mode 100644 drivers/gpu/drm/imx/dpu/dpu-fetcheco.c
> create mode 100644 drivers/gpu/drm/imx/dpu/dpu-fetchlayer.c
> create mode 100644 drivers/gpu/drm/imx/dpu/dpu-fetchunit.c
> create mode 100644 drivers/gpu/drm/imx/dpu/dpu-fetchunit.h
> create mode 100644 drivers/gpu/drm/imx/dpu/dpu-fetchwarp.c
> create mode 100644 drivers/gpu/drm/imx/dpu/dpu-framegen.c
> create mode 100644 drivers/gpu/drm/imx/dpu/dpu-gammacor.c
> create mode 100644 drivers/gpu/drm/imx/dpu/dpu-hscaler.c
> create mode 100644 drivers/gpu/drm/imx/dpu/dpu-kms.c
> create mode 100644 drivers/gpu/drm/imx/dpu/dpu-kms.h
> create mode 100644 drivers/gpu/drm/imx/dpu/dpu-layerblend.c
> create mode 100644 drivers/gpu/drm/imx/dpu/dpu-plane.c
> create mode 100644 drivers/gpu/drm/imx/dpu/dpu-plane.h
> create mode 100644 drivers/gpu/drm/imx/dpu/dpu-prg.c
> create mode 100644 drivers/gpu/drm/imx/dpu/dpu-prg.h
> create mode 100644 drivers/gpu/drm/imx/dpu/dpu-prv.h
> create mode 100644 drivers/gpu/drm/imx/dpu/dpu-tcon.c
> create mode 100644 drivers/gpu/drm/imx/dpu/dpu-vscaler.c
> create mode 100644 drivers/gpu/drm/imx/dpu/dpu.h
>
> diff --git a/drivers/gpu/drm/imx/Kconfig b/drivers/gpu/drm/imx/Kconfig
> index b5fa0e4..6e3c044 100644
> --- a/drivers/gpu/drm/imx/Kconfig
> +++ b/drivers/gpu/drm/imx/Kconfig
> @@ -42,3 +42,4 @@ config DRM_IMX_HDMI
> Choose this if you want to use HDMI on i.MX6.
>
> source "drivers/gpu/drm/imx/dcss/Kconfig"
> +source "drivers/gpu/drm/imx/dpu/Kconfig"
> diff --git a/drivers/gpu/drm/imx/Makefile b/drivers/gpu/drm/imx/Makefile
> index b644def..55da147 100644
> --- a/drivers/gpu/drm/imx/Makefile
> +++ b/drivers/gpu/drm/imx/Makefile
> @@ -10,3 +10,4 @@ obj-$(CONFIG_DRM_IMX_LDB) += imx-ldb.o
>
> obj-$(CONFIG_DRM_IMX_HDMI) += dw_hdmi-imx.o
> obj-$(CONFIG_DRM_IMX_DCSS) += dcss/
> +obj-$(CONFIG_DRM_IMX_DPU) += dpu/
> diff --git a/drivers/gpu/drm/imx/dpu/Kconfig b/drivers/gpu/drm/imx/dpu/Kconfig
> new file mode 100644
> index 00000000..e825173
> --- /dev/null
> +++ b/drivers/gpu/drm/imx/dpu/Kconfig
> @@ -0,0 +1,10 @@
> +config DRM_IMX_DPU
> + tristate "DRM support for Freescale i.MX DPU Graphics"
> + select DRM_KMS_HELPER
> + select VIDEOMODE_HELPERS
> + select DRM_GEM_CMA_HELPER
> + select DRM_KMS_CMA_HELPER
> + depends on DRM && OF && ARCH_MXC
> + depends on COMMON_CLK
> + help
> + enable Freescale i.MX DPU graphics support
> diff --git a/drivers/gpu/drm/imx/dpu/Makefile b/drivers/gpu/drm/imx/dpu/Makefile
> new file mode 100644
> index 00000000..2f9238a
> --- /dev/null
> +++ b/drivers/gpu/drm/imx/dpu/Makefile
> @@ -0,0 +1,10 @@
> +# SPDX-License-Identifier: GPL-2.0
> +
> +imx-dpu-drm-objs := dpu-constframe.o dpu-core.o dpu-crtc.o \
> + dpu-disengcfg.o dpu-dprc.o dpu-drv.o dpu-extdst.o \
> + dpu-fetchdecode.o dpu-fetcheco.o dpu-fetchlayer.o \
> + dpu-fetchwarp.o dpu-fetchunit.o dpu-framegen.o \
> + dpu-gammacor.o dpu-hscaler.o dpu-kms.o dpu-layerblend.o \
> + dpu-plane.o dpu-prg.o dpu-tcon.o dpu-vscaler.o
> +
> +obj-$(CONFIG_DRM_IMX_DPU) += imx-dpu-drm.o
> diff --git a/drivers/gpu/drm/imx/dpu/dpu-constframe.c b/drivers/gpu/drm/imx/dpu/dpu-constframe.c
> new file mode 100644
> index 00000000..5adb02d
> --- /dev/null
> +++ b/drivers/gpu/drm/imx/dpu/dpu-constframe.c
> @@ -0,0 +1,171 @@
> +// SPDX-License-Identifier: GPL-2.0+
> +
> +/*
> + * Copyright (C) 2016 Freescale Semiconductor, Inc.
> + * Copyright 2017-2020 NXP
> + */
> +
> +#include <linux/io.h>
> +#include <linux/kernel.h>
> +#include <linux/mutex.h>
> +#include <linux/sizes.h>
> +
> +#include "dpu-prv.h"
> +
> +#define STATICCONTROL 0x8
> +
> +#define FRAMEDIMENSIONS 0xc
> +#define WIDTH(w) (((w) - 1) & 0x3fff)
> +#define HEIGHT(h) ((((h) - 1) & 0x3fff) << 16)
> +
> +#define CONSTANTCOLOR 0x10
> +#define RED(r) (((r) & 0xff) << 24)
> +#define GREEN(g) (((g) & 0xff) << 16)
> +#define BLUE(b) (((b) & 0xff) << 8)
> +#define ALPHA(a) ((a) & 0xff)
> +
> +struct dpu_constframe {
> + void __iomem *pec_base;
> + void __iomem *base;
> + struct mutex mutex;
> + unsigned int id;
> + unsigned int index;
> + enum dpu_link_id link_id;
> + bool inuse;
> + struct dpu_soc *dpu;
> +};
> +
> +static const enum dpu_link_id
> +dpu_cf_link_id[] = {LINK_ID_CONSTFRAME0, LINK_ID_CONSTFRAME1,
> + LINK_ID_CONSTFRAME4, LINK_ID_CONSTFRAME5};
> +
> +static inline void dpu_cf_write(struct dpu_constframe *cf,
> + unsigned int offset, u32 value)
> +{
> + writel(value, cf->base + offset);
> +}
> +
> +static void dpu_cf_enable_shden(struct dpu_constframe *cf)
> +{
> + dpu_cf_write(cf, STATICCONTROL, SHDEN);
> +}
> +
> +enum dpu_link_id dpu_cf_get_link_id(struct dpu_constframe *cf)
> +{
> + return cf->link_id;
> +}
> +
> +void dpu_cf_framedimensions(struct dpu_constframe *cf, unsigned int w,
> + unsigned int h)
> +{
> + dpu_cf_write(cf, FRAMEDIMENSIONS, WIDTH(w) | HEIGHT(h));
> +}
> +
> +void dpu_cf_constantcolor_black(struct dpu_constframe *cf)
> +{
> + dpu_cf_write(cf, CONSTANTCOLOR, 0);
> +}
> +
> +void dpu_cf_constantcolor_blue(struct dpu_constframe *cf)
> +{
> + dpu_cf_write(cf, CONSTANTCOLOR, BLUE(0xff));
> +}
> +
> +static struct dpu_constframe *dpu_cf_get(struct dpu_soc *dpu, unsigned int id)
> +{
> + struct dpu_constframe *cf;
> + int i;
> +
> + for (i = 0; i < ARRAY_SIZE(dpu->cf_priv); i++) {
> + cf = dpu->cf_priv[i];
> + if (cf->id == id)
> + break;
> + }
> +
> + if (i == ARRAY_SIZE(dpu->cf_priv))
> + return ERR_PTR(-EINVAL);
> +
> + mutex_lock(&cf->mutex);
> +
> + if (cf->inuse) {
> + mutex_unlock(&cf->mutex);
> + return ERR_PTR(-EBUSY);
> + }
> +
> + cf->inuse = true;
> +
> + mutex_unlock(&cf->mutex);
> +
> + return cf;
> +}
> +
> +static void dpu_cf_put(struct dpu_constframe *cf)
> +{
> + if (IS_ERR_OR_NULL(cf))
> + return;
> +
> + mutex_lock(&cf->mutex);
> +
> + cf->inuse = false;
> +
> + mutex_unlock(&cf->mutex);
> +}
> +
> +/* ConstFrame for safety stream */
> +struct dpu_constframe *dpu_cf_safe_get(struct dpu_soc *dpu,
> + unsigned int stream_id)
> +{
> + return dpu_cf_get(dpu, stream_id + DPU_SAFETY_STREAM_OFFSET);
> +}
> +
> +void dpu_cf_safe_put(struct dpu_constframe *cf)
> +{
> + return dpu_cf_put(cf);
> +}
> +
> +/* ConstFrame for content stream */
> +struct dpu_constframe *dpu_cf_cont_get(struct dpu_soc *dpu,
> + unsigned int stream_id)
> +{
> + return dpu_cf_get(dpu, stream_id);
> +}
> +
> +void dpu_cf_cont_put(struct dpu_constframe *cf)
> +{
> + return dpu_cf_put(cf);
> +}
> +
> +void dpu_cf_hw_init(struct dpu_soc *dpu, unsigned int index)
> +{
> + dpu_cf_enable_shden(dpu->cf_priv[index]);
> +}
> +
> +int dpu_cf_init(struct dpu_soc *dpu, unsigned int index,
> + unsigned int id, enum dpu_unit_type type,
> + unsigned long pec_base, unsigned long base)
> +{
> + struct dpu_constframe *cf;
> +
> + cf = devm_kzalloc(dpu->dev, sizeof(*cf), GFP_KERNEL);
> + if (!cf)
> + return -ENOMEM;
> +
> + dpu->cf_priv[index] = cf;
> +
> + cf->pec_base = devm_ioremap(dpu->dev, pec_base, SZ_16);
> + if (!cf->pec_base)
> + return -ENOMEM;
> +
> + cf->base = devm_ioremap(dpu->dev, base, SZ_32);
> + if (!cf->base)
> + return -ENOMEM;
> +
> + cf->dpu = dpu;
> + cf->id = id;
> + cf->index = index;
> + cf->link_id = dpu_cf_link_id[index];
> +
> + mutex_init(&cf->mutex);
> +
> + return 0;
> +}
> diff --git a/drivers/gpu/drm/imx/dpu/dpu-core.c b/drivers/gpu/drm/imx/dpu/dpu-core.c
> new file mode 100644
> index 00000000..cdebb77
> --- /dev/null
> +++ b/drivers/gpu/drm/imx/dpu/dpu-core.c
> @@ -0,0 +1,1047 @@
> +// SPDX-License-Identifier: GPL-2.0+
> +
> +/*
> + * Copyright (C) 2016 Freescale Semiconductor, Inc.
> + * Copyright 2017-2020 NXP
> + */
> +
> +#include <linux/dma-mapping.h>
> +#include <linux/io.h>
> +#include <linux/irq.h>
> +#include <linux/irqchip/chained_irq.h>
> +#include <linux/module.h>
> +#include <linux/of_device.h>
> +#include <linux/of_graph.h>
> +#include <linux/platform_device.h>
> +#include <linux/pm_domain.h>
> +#include <linux/pm_runtime.h>
> +#include <linux/sizes.h>
> +
> +#include "dpu.h"
> +#include "dpu-prv.h"
> +
> +static inline u32 dpu_comctrl_read(struct dpu_soc *dpu, unsigned int offset)
> +{
> + return readl(dpu->comctrl_reg + offset);
> +}
> +
> +static inline void dpu_comctrl_write(struct dpu_soc *dpu,
> + unsigned int offset, u32 value)
> +{
> + writel(value, dpu->comctrl_reg + offset);
> +}
> +
> +/* Constant Frame */
> +static const unsigned int cf_ids[] = {0, 1, 4, 5};
> +static const enum dpu_unit_type cf_types[] = {DPU_DISP, DPU_DISP,
> + DPU_DISP, DPU_DISP};
> +static const unsigned long cf_ofss[] = {0x4400, 0x5400, 0x4c00, 0x5c00};
> +static const unsigned long cf_pec_ofss[] = {0x960, 0x9e0, 0x9a0, 0xa20};
> +
> +static const struct dpu_units dpu_cfs = {
> + .ids = cf_ids,
> + .types = cf_types,
> + .ofss = cf_ofss,
> + .pec_ofss = cf_pec_ofss,
> + .cnt = ARRAY_SIZE(cf_ids),
> + .name = "ConstFrame",
> + .init = dpu_cf_init,
> + .hw_init = dpu_cf_hw_init,
> +};
> +
> +/* Display Engine Configuration */
> +static const unsigned int dec_ids[] = {0, 1};
> +static const enum dpu_unit_type dec_types[] = {DPU_DISP, DPU_DISP};
> +static const unsigned long dec_ofss[] = {0xb400, 0xb420};
> +
> +static const struct dpu_units dpu_decs = {
> + .ids = dec_ids,
> + .types = dec_types,
> + .ofss = dec_ofss,
> + .pec_ofss = NULL,
> + .cnt = ARRAY_SIZE(dec_ids),
> + .name = "DisEngCfg",
> + .init = dpu_dec_init,
> + .hw_init = dpu_dec_hw_init,
> +};
> +
> +/* External Destination */
> +static const unsigned int ed_ids[] = {0, 1, 4, 5};
> +static const enum dpu_unit_type ed_types[] = {DPU_DISP, DPU_DISP,
> + DPU_DISP, DPU_DISP};
> +static const unsigned long ed_ofss[] = {0x4800, 0x5800, 0x5000, 0x6000};
> +static const unsigned long ed_pec_ofss[] = {0x980, 0xa00, 0x9c0, 0xa40};
> +
> +static const struct dpu_units dpu_eds = {
> + .ids = ed_ids,
> + .types = ed_types,
> + .ofss = ed_ofss,
> + .pec_ofss = ed_pec_ofss,
> + .cnt = ARRAY_SIZE(ed_ids),
> + .name = "ExtDst",
> + .init = dpu_ed_init,
> + .hw_init = dpu_ed_hw_init,
> +};
> +
> +/* Fetch Decode */
> +static const unsigned int fd_ids[] = {0, 1, 9};
> +static const enum dpu_unit_type fd_types[] = {DPU_DISP, DPU_DISP, DPU_BLIT};
> +static const unsigned long fd_ofss[] = {0x6c00, 0x7800, 0x1000};
> +static const unsigned long fd_pec_ofss[] = {0xa80, 0xaa0, 0x820};
> +
> +static const struct dpu_units dpu_fds = {
> + .ids = fd_ids,
> + .types = fd_types,
> + .ofss = fd_ofss,
> + .pec_ofss = fd_pec_ofss,
> + .cnt = ARRAY_SIZE(fd_ids),
> + .name = "FetchDecode",
> + .init = dpu_fd_init,
> + .hw_init = dpu_fd_hw_init,
> +};
> +
> +/* Fetch ECO */
> +static const unsigned int fe_ids[] = {0, 1, 2, 9};
> +static const enum dpu_unit_type fe_types[] = {DPU_DISP, DPU_DISP,
> + DPU_DISP, DPU_BLIT};
> +static const unsigned long fe_ofss[] = {0x7400, 0x8000, 0x6800, 0x1c00};
> +static const unsigned long fe_pec_ofss[] = {0xa90, 0xab0, 0xa70, 0x850};
> +
> +static const struct dpu_units dpu_fes = {
> + .ids = fe_ids,
> + .types = fe_types,
> + .ofss = fe_ofss,
> + .pec_ofss = fe_pec_ofss,
> + .cnt = ARRAY_SIZE(fe_ids),
> + .name = "FetchEco",
> + .init = dpu_fe_init,
> + .hw_init = dpu_fe_hw_init,
> +};
> +
> +/* Frame Generator */
> +static const unsigned int fg_ids[] = {0, 1};
> +static const enum dpu_unit_type fg_types[] = {DPU_DISP, DPU_DISP};
> +static const unsigned long fg_ofss[] = {0xb800, 0xd400};
> +
> +static const struct dpu_units dpu_fgs = {
> + .ids = fg_ids,
> + .types = fg_types,
> + .ofss = fg_ofss,
> + .pec_ofss = NULL,
> + .cnt = ARRAY_SIZE(fg_ids),
> + .name = "FrameGen",
> + .init = dpu_fg_init,
> + .hw_init = dpu_fg_hw_init,
> +};
> +
> +/* Fetch Layer */
> +static const unsigned int fl_ids[] = {0};
> +static const enum dpu_unit_type fl_types[] = {DPU_DISP};
> +static const unsigned long fl_ofss[] = {0x8400};
> +static const unsigned long fl_pec_ofss[] = {0xac0};
> +
> +static const struct dpu_units dpu_fls = {
> + .ids = fl_ids,
> + .types = fl_types,
> + .ofss = fl_ofss,
> + .pec_ofss = fl_pec_ofss,
> + .cnt = ARRAY_SIZE(fl_ids),
> + .name = "FetchLayer",
> + .init = dpu_fl_init,
> + .hw_init = dpu_fl_hw_init,
> +};
> +
> +/* Fetch Warp */
> +static const unsigned int fw_ids[] = {2, 9};
> +static const enum dpu_unit_type fw_types[] = {DPU_DISP, DPU_BLIT};
> +static const unsigned long fw_ofss[] = {0x6400, 0x1800};
> +static const unsigned long fw_pec_ofss[] = {0xa60, 0x840};
> +
> +static const struct dpu_units dpu_fws = {
> + .ids = fw_ids,
> + .types = fw_types,
> + .ofss = fw_ofss,
> + .pec_ofss = fw_pec_ofss,
> + .cnt = ARRAY_SIZE(fw_ids),
> + .name = "FetchWarp",
> + .init = dpu_fw_init,
> + .hw_init = dpu_fw_hw_init,
> +};
> +
> +/* Gamma Correction */
> +static const unsigned int gc_ids[] = {0, 1};
> +static const enum dpu_unit_type gc_types[] = {DPU_DISP, DPU_DISP};
> +static const unsigned long gc_ofss[] = {0xc000, 0xdc00};
> +
> +static const struct dpu_units dpu_gcs = {
> + .ids = gc_ids,
> + .types = gc_types,
> + .ofss = gc_ofss,
> + .pec_ofss = NULL,
> + .cnt = ARRAY_SIZE(gc_ids),
> + .name = "GammaCor",
> + .init = dpu_gc_init,
> + .hw_init = dpu_gc_hw_init,
> +};
> +
> +/* Horizontal Scaler */
> +static const unsigned int hs_ids[] = {4, 5, 9};
> +static const enum dpu_unit_type hs_types[] = {DPU_DISP, DPU_DISP, DPU_BLIT};
> +static const unsigned long hs_ofss[] = {0x9000, 0x9c00, 0x3000};
> +static const unsigned long hs_pec_ofss[] = {0xb00, 0xb60, 0x8c0};
> +
> +static const struct dpu_units dpu_hss = {
> + .ids = hs_ids,
> + .types = hs_types,
> + .ofss = hs_ofss,
> + .pec_ofss = hs_pec_ofss,
> + .cnt = ARRAY_SIZE(hs_ids),
> + .name = "HScaler",
> + .init = dpu_hs_init,
> + .hw_init = dpu_hs_hw_init,
> +};
> +
> +/* Layer Blend */
> +static const unsigned int lb_ids[] = {0, 1, 2, 3};
> +static const enum dpu_unit_type lb_types[] = {DPU_DISP, DPU_DISP,
> + DPU_DISP, DPU_DISP};
> +static const unsigned long lb_ofss[] = {0xa400, 0xa800, 0xac00, 0xb000};
> +static const unsigned long lb_pec_ofss[] = {0xba0, 0xbc0, 0xbe0, 0xc00};
> +
> +static const struct dpu_units dpu_lbs = {
> + .ids = lb_ids,
> + .types = lb_types,
> + .ofss = lb_ofss,
> + .pec_ofss = lb_pec_ofss,
> + .cnt = ARRAY_SIZE(lb_ids),
> + .name = "LayerBlend",
> + .init = dpu_lb_init,
> + .hw_init = dpu_lb_hw_init,
> +};
> +
> +/* Timing Controller */
> +static const unsigned int tcon_ids[] = {0, 1};
> +static const enum dpu_unit_type tcon_types[] = {DPU_DISP, DPU_DISP};
> +static const unsigned long tcon_ofss[] = {0xc800, 0xe400};
> +
> +static const struct dpu_units dpu_tcons = {
> + .ids = tcon_ids,
> + .types = tcon_types,
> + .ofss = tcon_ofss,
> + .pec_ofss = NULL,
> + .cnt = ARRAY_SIZE(tcon_ids),
> + .name = "TCON",
> + .init = dpu_tcon_init,
> + .hw_init = dpu_tcon_hw_init,
> +};
> +
> +/* Vertical Scaler */
> +static const unsigned int vs_ids[] = {4, 5, 9};
> +static const enum dpu_unit_type vs_types[] = {DPU_DISP, DPU_DISP, DPU_BLIT};
> +static const unsigned long vs_ofss[] = {0x9400, 0xa000, 0x3400};
> +static const unsigned long vs_pec_ofss[] = {0xb20, 0xb80, 0x8e0};
> +
> +static const struct dpu_units dpu_vss = {
> + .ids = vs_ids,
> + .types = vs_types,
> + .ofss = vs_ofss,
> + .pec_ofss = vs_pec_ofss,
> + .cnt = ARRAY_SIZE(vs_ids),
> + .name = "VScaler",
> + .init = dpu_vs_init,
> + .hw_init = dpu_vs_hw_init,
> +};
> +
> +static const struct dpu_units *dpu_all_units[] = {
> + &dpu_cfs,
> + &dpu_decs,
> + &dpu_eds,
> + &dpu_fds,
> + &dpu_fes,
> + &dpu_fgs,
> + &dpu_fls,
> + &dpu_fws,
> + &dpu_gcs,
> + &dpu_hss,
> + &dpu_lbs,
> + &dpu_tcons,
> + &dpu_vss,
> +};
> +
> +static inline void dpu_detach_pm_domain(struct device **pd_dev,
> + struct device_link **pd_link)
> +{
> + if (!IS_ERR_OR_NULL(*pd_link))
> + device_link_del(*pd_link);
> + if (!IS_ERR_OR_NULL(*pd_dev))
> + dev_pm_domain_detach(*pd_dev, true);
> +
> + *pd_dev = NULL;
> + *pd_link = NULL;
> +}
> +
> +static void dpu_detach_pm_domains(struct dpu_soc *dpu)
> +{
> + dpu_detach_pm_domain(&dpu->pd_pll1_dev, &dpu->pd_pll1_link);
> + dpu_detach_pm_domain(&dpu->pd_pll0_dev, &dpu->pd_pll0_link);
> + dpu_detach_pm_domain(&dpu->pd_dc_dev, &dpu->pd_dc_link);
> +}
> +
> +static inline int dpu_attach_pm_domain(struct dpu_soc *dpu,
> + struct device **pd_dev,
> + struct device_link **pd_link,
> + const char *name)
> +{
> + u32 flags = DL_FLAG_STATELESS | DL_FLAG_PM_RUNTIME | DL_FLAG_RPM_ACTIVE;
> + int ret;
> +
> + *pd_dev = dev_pm_domain_attach_by_name(dpu->dev, name);
> + if (IS_ERR(*pd_dev)) {
> + ret = PTR_ERR(*pd_dev);
> + dev_err(dpu->dev,
> + "failed to attach %s pd dev: %d\n", name, ret);
> + return ret;
> + }
> +
> + *pd_link = device_link_add(dpu->dev, *pd_dev, flags);
> + if (IS_ERR(*pd_link)) {
> + ret = PTR_ERR(*pd_link);
> + dev_err(dpu->dev, "failed to add device link to %s pd dev: %d\n",
> + name, ret);
> + return ret;
> + }
> +
> + return 0;
> +}
> +
> +static int dpu_attach_pm_domains(struct dpu_soc *dpu)
> +{
> + int ret;
> +
> + ret = dpu_attach_pm_domain(dpu, &dpu->pd_dc_dev, &dpu->pd_dc_link, "dc");
> + if (ret)
> + goto err_out;
> +
> + ret = dpu_attach_pm_domain(dpu, &dpu->pd_pll0_dev, &dpu->pd_pll0_link,
> + "pll0");
> + if (ret)
> + goto err_out;
> +
> + ret = dpu_attach_pm_domain(dpu, &dpu->pd_pll1_dev, &dpu->pd_pll1_link,
> + "pll1");
> + if (ret)
> + goto err_out;
> +
> + return 0;
> +err_out:
> + dpu_detach_pm_domains(dpu);
> +
> + return ret;
> +}
> +
> +static void dpu_units_addr_dbg(struct dpu_soc *dpu, unsigned long dpu_base)
> +{
> + const struct dpu_units *us;
> + int i, j;
> +
> + dev_dbg(dpu->dev, "Common Control: 0x%08lx\n", dpu_base);
> +
> + for (i = 0; i < ARRAY_SIZE(dpu_all_units); i++) {
> + us = dpu_all_units[i];
> +
> + for (j = 0; j < us->cnt; j++) {
> + if (us->pec_ofss) {
> + dev_dbg(dpu->dev,
> + "%s%d: pixengcfg @ 0x%08lx, unit @ 0x%08lx\n",
> + us->name, us->ids[j],
> + dpu_base + us->pec_ofss[j],
> + dpu_base + us->ofss[j]);
> + } else {
> + dev_dbg(dpu->dev,
> + "%s%d: unit @ 0x%08lx\n", us->name,
> + us->ids[j], dpu_base + us->ofss[j]);
> + }
> + }
> + }
> +}
> +
> +static int dpu_get_irqs(struct platform_device *pdev, struct dpu_soc *dpu)
> +{
> + unsigned int i, j;
> +
> + /* do not get the reserved irq */
> + for (i = 0, j = 0; i < DPU_IRQ_COUNT - 1; i++, j++) {
> + if (i == DPU_IRQ_RESERVED)
> + j++;
> +
> + dpu->irq[j] = platform_get_irq(pdev, i);
> + if (dpu->irq[j] < 0) {
> + dev_err_probe(dpu->dev, dpu->irq[j],
> + "failed to get irq\n");
> + return dpu->irq[j];
> + }
> + }
> +
> + return 0;
> +}
> +
> +static void dpu_irq_handle(struct irq_desc *desc, enum dpu_irq irq)
> +{
> + struct dpu_soc *dpu = irq_desc_get_handler_data(desc);
> + struct irq_chip *chip = irq_desc_get_chip(desc);
> + unsigned int virq;
> + u32 status;
> +
> + chained_irq_enter(chip, desc);
> +
> + status = dpu_comctrl_read(dpu, USERINTERRUPTSTATUS(irq / 32));
> + status &= dpu_comctrl_read(dpu, USERINTERRUPTENABLE(irq / 32));
> +
> + if (status & BIT(irq % 32)) {
> + virq = irq_linear_revmap(dpu->domain, irq);
> + if (virq)
> + generic_handle_irq(virq);
> + }
> +
> + chained_irq_exit(chip, desc);
> +}
> +
> +static void dpu_dec_framecomplete0_irq_handler(struct irq_desc *desc)
> +{
> + dpu_irq_handle(desc, DPU_IRQ_DISENGCFG_FRAMECOMPLETE0);
> +}
> +
> +static void dpu_dec_framecomplete1_irq_handler(struct irq_desc *desc)
> +{
> + dpu_irq_handle(desc, DPU_IRQ_DISENGCFG_FRAMECOMPLETE1);
> +}
> +
> +static void dpu_dec_seqcomplete0_irq_handler(struct irq_desc *desc)
> +{
> + dpu_irq_handle(desc, DPU_IRQ_DISENGCFG_SEQCOMPLETE0);
> +}
> +
> +static void dpu_dec_seqcomplete1_irq_handler(struct irq_desc *desc)
> +{
> + dpu_irq_handle(desc, DPU_IRQ_DISENGCFG_SEQCOMPLETE1);
> +}
> +
> +static void dpu_dec_shdload0_irq_handler(struct irq_desc *desc)
> +{
> + dpu_irq_handle(desc, DPU_IRQ_DISENGCFG_SHDLOAD0);
> +}
> +
> +static void dpu_dec_shdload1_irq_handler(struct irq_desc *desc)
> +{
> + dpu_irq_handle(desc, DPU_IRQ_DISENGCFG_SHDLOAD1);
> +}
> +
> +static void dpu_ed0_shdload_irq_handler(struct irq_desc *desc)
> +{
> + dpu_irq_handle(desc, DPU_IRQ_EXTDST0_SHDLOAD);
> +}
> +
> +static void dpu_ed1_shdload_irq_handler(struct irq_desc *desc)
> +{
> + dpu_irq_handle(desc, DPU_IRQ_EXTDST1_SHDLOAD);
> +}
> +
> +static void dpu_ed4_shdload_irq_handler(struct irq_desc *desc)
> +{
> + dpu_irq_handle(desc, DPU_IRQ_EXTDST4_SHDLOAD);
> +}
> +
> +static void dpu_ed5_shdload_irq_handler(struct irq_desc *desc)
> +{
> + dpu_irq_handle(desc, DPU_IRQ_EXTDST5_SHDLOAD);
> +}
> +
> +static void (* const dpu_irq_handler[DPU_IRQ_COUNT])(struct irq_desc *desc) = {
> + [DPU_IRQ_EXTDST0_SHDLOAD] = dpu_ed0_shdload_irq_handler,
> + [DPU_IRQ_EXTDST4_SHDLOAD] = dpu_ed4_shdload_irq_handler,
> + [DPU_IRQ_EXTDST1_SHDLOAD] = dpu_ed1_shdload_irq_handler,
> + [DPU_IRQ_EXTDST5_SHDLOAD] = dpu_ed5_shdload_irq_handler,
> + [DPU_IRQ_DISENGCFG_SHDLOAD0] = dpu_dec_shdload0_irq_handler,
> + [DPU_IRQ_DISENGCFG_FRAMECOMPLETE0] = dpu_dec_framecomplete0_irq_handler,
> + [DPU_IRQ_DISENGCFG_SEQCOMPLETE0] = dpu_dec_seqcomplete0_irq_handler,
> + [DPU_IRQ_DISENGCFG_SHDLOAD1] = dpu_dec_shdload1_irq_handler,
> + [DPU_IRQ_DISENGCFG_FRAMECOMPLETE1] = dpu_dec_framecomplete1_irq_handler,
> + [DPU_IRQ_DISENGCFG_SEQCOMPLETE1] = dpu_dec_seqcomplete1_irq_handler,
> + [DPU_IRQ_RESERVED] = NULL, /* do not use */
> +};
> +
> +int dpu_map_irq(struct dpu_soc *dpu, int irq)
> +{
> + int virq = irq_linear_revmap(dpu->domain, irq);
> +
> + if (!virq)
> + virq = irq_create_mapping(dpu->domain, irq);
> +
> + return virq;
> +}
> +
> +static const unsigned long unused_irq[2] = {0x00000000, 0xfffe0008};
> +
> +static void dpu_irq_hw_init(struct dpu_soc *dpu)
> +{
> + int i;
> +
> + for (i = 0; i < DPU_IRQ_COUNT; i += 32) {
> + /* mask and clear all interrupts */
> + dpu_comctrl_write(dpu, USERINTERRUPTENABLE(i / 32), 0);
> + dpu_comctrl_write(dpu, USERINTERRUPTCLEAR(i / 32),
> + ~unused_irq[i / 32]);
> + dpu_comctrl_write(dpu, INTERRUPTENABLE(i / 32), 0);
> + dpu_comctrl_write(dpu, INTERRUPTCLEAR(i / 32),
> + ~unused_irq[i / 32]);
> +
> + /* set all interrupts to user mode */
> + dpu_comctrl_write(dpu, USERINTERRUPTMASK(i / 32),
> + ~unused_irq[i / 32]);
> + }
> +}
> +
> +static int dpu_irq_init(struct dpu_soc *dpu)
> +{
> + struct device *dev = dpu->dev;
> + struct irq_chip_generic *gc;
> + struct irq_chip_type *ct;
> + int ret, i;
> +
> + dpu->domain = irq_domain_add_linear(dev->of_node, DPU_IRQ_COUNT,
> + &irq_generic_chip_ops, dpu);
> + if (!dpu->domain) {
> + dev_err(dev, "failed to add irq domain\n");
> + return -ENODEV;
> + }
> +
> + ret = irq_alloc_domain_generic_chips(dpu->domain, 32, 1, "DPU",
> + handle_level_irq, 0, 0, 0);
> + if (ret) {
> + dev_err(dev, "failed to alloc generic irq chips: %d\n", ret);
> + irq_domain_remove(dpu->domain);
> + return ret;
> + }
> +
> + for (i = 0; i < DPU_IRQ_COUNT; i += 32) {
> + gc = irq_get_domain_generic_chip(dpu->domain, i);
> + gc->reg_base = dpu->comctrl_reg;
> + gc->unused = unused_irq[i / 32];
> + ct = gc->chip_types;
> + ct->chip.irq_ack = irq_gc_ack_set_bit;
> + ct->chip.irq_mask = irq_gc_mask_clr_bit;
> + ct->chip.irq_unmask = irq_gc_mask_set_bit;
> + ct->regs.ack = USERINTERRUPTCLEAR(i / 32);
> + ct->regs.mask = USERINTERRUPTENABLE(i / 32);
> + }
> +
> + for (i = 0; i < DPU_IRQ_COUNT; i++) {
> + if (!dpu_irq_handler[i])
> + continue;
> +
> + irq_set_chained_handler_and_data(dpu->irq[i],
> + dpu_irq_handler[i],
> + dpu);
> + }
> +
> + return ret;
> +}
> +
> +static void dpu_irq_exit(struct dpu_soc *dpu)
> +{
> + unsigned int i, irq;
> +
> + for (i = 0; i < DPU_IRQ_COUNT; i++) {
> + if (!dpu_irq_handler[i])
> + continue;
> +
> + irq_set_chained_handler_and_data(dpu->irq[i], NULL, NULL);
> + }
> +
> + for (i = 0; i < DPU_IRQ_COUNT; i++) {
> + irq = irq_linear_revmap(dpu->domain, i);
> + if (irq)
> + irq_dispose_mapping(irq);
> + }
> +
> + irq_domain_remove(dpu->domain);
> +}
> +
> +static void dpu_submodules_hw_init(struct dpu_soc *dpu)
> +{
> + const struct dpu_units *us;
> + int i, j;
> +
> + for (i = 0; i < ARRAY_SIZE(dpu_all_units); i++) {
> + us = dpu_all_units[i];
> +
> + for (j = 0; j < us->cnt; j++)
> + us->hw_init(dpu, j);
> + }
> +}
> +
> +static int dpu_submodules_init(struct dpu_soc *dpu, unsigned long dpu_base)
> +{
> + const struct dpu_units *us;
> + unsigned long pec_ofs;
> + int i, j, ret;
> +
> + for (i = 0; i < ARRAY_SIZE(dpu_all_units); i++) {
> + us = dpu_all_units[i];
> +
> + for (j = 0; j < us->cnt; j++) {
> + pec_ofs = us->pec_ofss ? dpu_base + us->pec_ofss[j] : 0;
> +
> + ret = us->init(dpu, j, us->ids[j], us->types[j],
> + pec_ofs, dpu_base + us->ofss[j]);
> + if (ret) {
> + dev_err(dpu->dev,
> + "failed to initialize %s%d: %d\n",
> + us->name, us->ids[j], ret);
> + return ret;
> + }
> + }
> + }
> +
> + return 0;
> +}
> +
> +static int platform_remove_devices_fn(struct device *dev, void *unused)
> +{
> + struct platform_device *pdev = to_platform_device(dev);
> +
> + platform_device_unregister(pdev);
> +
> + return 0;
> +}
> +
> +static void platform_device_unregister_children(struct platform_device *pdev)
> +{
> + device_for_each_child(&pdev->dev, NULL, platform_remove_devices_fn);
> +}
> +
> +struct dpu_platform_reg {
> + struct dpu_client_platformdata pdata;
> + const char *name;
> +};
> +
> +static struct dpu_platform_reg client_reg[] = {
> + {
> + .pdata = {
> + .stream_id = 0,
> + .dec_frame_complete_irq = DPU_IRQ_DISENGCFG_FRAMECOMPLETE0,
> + .dec_seq_complete_irq = DPU_IRQ_DISENGCFG_SEQCOMPLETE0,
> + .dec_shdld_irq = DPU_IRQ_DISENGCFG_SHDLOAD0,
> + .ed_cont_shdld_irq = DPU_IRQ_EXTDST0_SHDLOAD,
> + .ed_safe_shdld_irq = DPU_IRQ_EXTDST4_SHDLOAD,
> + },
> + .name = "imx-dpu-crtc",
> + }, {
> + .pdata = {
> + .stream_id = 1,
> + .dec_frame_complete_irq = DPU_IRQ_DISENGCFG_FRAMECOMPLETE1,
> + .dec_seq_complete_irq = DPU_IRQ_DISENGCFG_SEQCOMPLETE1,
> + .dec_shdld_irq = DPU_IRQ_DISENGCFG_SHDLOAD1,
> + .ed_cont_shdld_irq = DPU_IRQ_EXTDST1_SHDLOAD,
> + .ed_safe_shdld_irq = DPU_IRQ_EXTDST5_SHDLOAD,
> + },
> + .name = "imx-dpu-crtc",
> + }
> +};
> +
> +static DEFINE_MUTEX(dpu_client_id_mutex);
> +static int dpu_client_id;
> +
> +static int dpu_get_layerblends_for_plane_grp(struct dpu_soc *dpu,
> + struct dpu_plane_res *res)
> +{
> + int i, ret;
> +
> + res->lb_cnt = dpu_lbs.cnt;
> +
> + res->lb = devm_kcalloc(dpu->dev, res->lb_cnt, sizeof(*res->lb),
> + GFP_KERNEL);
> + if (!res->lb)
> + return -ENOMEM;
> +
> + for (i = 0; i < res->lb_cnt; i++) {
> + res->lb[i] = dpu_lb_get(dpu, lb_ids[i]);
> + if (IS_ERR(res->lb[i])) {
> + ret = PTR_ERR(res->lb[i]);
> + dev_err(dpu->dev, "failed to get %s%d: %d\n",
> + dpu_lbs.name, lb_ids[i], ret);
> + return ret;
> + }
> + }
> +
> + return 0;
> +}
> +
> +static int
> +dpu_get_fetchunits_for_plane_grp(struct dpu_soc *dpu,
> + const struct dpu_units *us,
> + struct dpu_fetchunit ***fu,
> + unsigned int *cnt,
> + struct dpu_fetchunit *
> + (*get)(struct dpu_soc *dpu,
> + unsigned int id))
> +{
> + unsigned int fu_cnt = 0;
> + int i, j, ret;
> +
> + for (i = 0; i < us->cnt; i++) {
> + if (us->types[i] == DPU_DISP)
> + fu_cnt++;
> + }
> +
> + *cnt = fu_cnt;
> +
> + *fu = devm_kcalloc(dpu->dev, fu_cnt, sizeof(**fu), GFP_KERNEL);
> + if (!(*fu))
> + return -ENOMEM;
> +
> + for (i = 0, j = 0; i < us->cnt; i++) {
> + if (us->types[i] != DPU_DISP)
> + continue;
> +
> + (*fu)[j] = get(dpu, us->ids[i]);
> + if (IS_ERR((*fu)[j])) {
> + ret = PTR_ERR((*fu)[j]);
> + dev_err(dpu->dev, "failed to get %s%d: %d\n",
> + us->name, us->ids[i], ret);
> + return ret;
> + }
> + j++;
> + }
> +
> + return 0;
> +}
> +
> +static void dpu_add_fetchunits_to_plane_grp_list(struct list_head *list,
> + struct dpu_fetchunit ***fu,
> + unsigned int *cnt)
> +{
> + int i;
> +
> + for (i = *cnt - 1; i >= 0; i--)
> + dpu_fu_add_to_list((*fu)[i], list);
> +}
> +
> +static int dpu_get_plane_grp_res(struct dpu_soc *dpu,
> + struct dpu_plane_grp *grp)
> +{
> + struct dpu_plane_res *res = &grp->res;
> + struct {
> + const struct dpu_units *us;
> + struct dpu_fetchunit ***fu;
> + unsigned int *cnt;
> + struct dpu_fetchunit *(*get)(struct dpu_soc *dpu,
> + unsigned int id);
> + } fus[] = {
> + {&dpu_fds, &res->fd, &res->fd_cnt, dpu_fd_get},
> + {&dpu_fls, &res->fl, &res->fl_cnt, dpu_fl_get},
> + {&dpu_fws, &res->fw, &res->fw_cnt, dpu_fw_get},
> + };
> + int i, ret;
> +
> + INIT_LIST_HEAD(&grp->fu_list);
> +
> + ret = dpu_get_layerblends_for_plane_grp(dpu, res);
> + if (ret)
> + return ret;
> +
> + for (i = 0; i < ARRAY_SIZE(fus); i++) {
> + ret = dpu_get_fetchunits_for_plane_grp(dpu,
> + fus[i].us, fus[i].fu, fus[i].cnt, fus[i].get);
> + if (ret)
> + return ret;
> + }
> +
> + for (i = 0; i < ARRAY_SIZE(fus); i++)
> + dpu_add_fetchunits_to_plane_grp_list(&grp->fu_list,
> + fus[i].fu, fus[i].cnt);
> +
> + grp->hw_plane_cnt = res->fd_cnt + res->fl_cnt + res->fw_cnt;
> +
> + return ret;
> +}
> +
> +static void
> +dpu_put_fetchunits_for_plane_grp(struct dpu_fetchunit ***fu,
> + unsigned int *cnt,
> + void (*put)(struct dpu_fetchunit *fu))
> +{
> + int i;
> +
> + for (i = 0; i < *cnt; i++)
> + put((*fu)[i]);
> +
> + *cnt = 0;
> +}
> +
> +static void dpu_put_plane_grp_res(struct dpu_plane_grp *grp)
> +{
> + struct dpu_plane_res *res = &grp->res;
> + struct list_head *l, *tmp;
> + struct {
> + struct dpu_fetchunit ***fu;
> + unsigned int *cnt;
> + void (*put)(struct dpu_fetchunit *fu);
> + } fus[] = {
> + {&res->fd, &res->fd_cnt, dpu_fd_put},
> + {&res->fl, &res->fl_cnt, dpu_fl_put},
> + {&res->fw, &res->fw_cnt, dpu_fw_put},
> + };
> + int i;
> +
> + grp->hw_plane_cnt = 0;
> +
> + list_for_each_safe(l, tmp, &grp->fu_list)
> + list_del(l);
> +
> + for (i = 0; i < ARRAY_SIZE(fus); i++)
> + dpu_put_fetchunits_for_plane_grp(fus[i].fu,
> + fus[i].cnt, fus[i].put);
> +
> + for (i = 0; i < res->lb_cnt; i++)
> + dpu_lb_put(res->lb[i]);
> + res->lb_cnt = 0;
> +}
> +
> +static int dpu_add_client_devices(struct dpu_soc *dpu)
> +{
> + struct device *dev = dpu->dev;
> + struct dpu_platform_reg *reg;
> + struct dpu_crtc_grp *crtc_grp;
> + struct dpu_plane_grp *plane_grp;
> + size_t client_cnt, reg_size;
> + int i, id, ret;
> +
> + client_cnt = ARRAY_SIZE(client_reg);
> +
> + reg = devm_kcalloc(dev, client_cnt, sizeof(*reg), GFP_KERNEL);
> + if (!reg)
> + return -ENOMEM;
> +
> + crtc_grp = devm_kzalloc(dev, sizeof(*crtc_grp), GFP_KERNEL);
> + if (!crtc_grp)
> + return -ENOMEM;
> +
> + plane_grp = devm_kzalloc(dev, sizeof(*plane_grp), GFP_KERNEL);
> + if (!plane_grp)
> + return -ENOMEM;
> +
> + crtc_grp->plane_grp = plane_grp;
> +
> + mutex_lock(&dpu_client_id_mutex);
> + id = dpu_client_id;
> + dpu_client_id += client_cnt;
> + mutex_unlock(&dpu_client_id_mutex);
> +
> + reg_size = client_cnt * sizeof(struct dpu_platform_reg);
> + memcpy(reg, &client_reg[0], reg_size);
> +
> + ret = dpu_get_plane_grp_res(dpu, plane_grp);
> + if (ret)
> + goto err_get_plane_res;
> +
> + for (i = 0; i < client_cnt; i++) {
> + struct platform_device *pdev;
> + struct device_node *np;
> +
> + /* Associate subdevice with the corresponding port node. */
> + np = of_graph_get_port_by_id(dev->of_node, i);
> + if (!np) {
> + dev_info(dev,
> + "no port@%d node in %s, not using DISP%d\n",
> + i, dev->of_node->full_name, i);
> + continue;
> + }
> +
> + reg[i].pdata.crtc_grp = crtc_grp;
> +
> + pdev = platform_device_alloc(reg[i].name, id++);
> + if (!pdev) {
> + ret = -ENOMEM;
> + goto err_register;
> + }
> +
> + pdev->dev.parent = dev;
> + pdev->dev.of_node = np;
> + pdev->dev.coherent_dma_mask = DMA_BIT_MASK(32);
> + pdev->dev.dma_mask = &pdev->dev.coherent_dma_mask;
> +
> + reg[i].pdata.of_node = np;
> + ret = platform_device_add_data(pdev, ®[i].pdata,
> + sizeof(reg[i].pdata));
> + if (!ret)
> + ret = platform_device_add(pdev);
> + if (ret) {
> + platform_device_put(pdev);
> + goto err_register;
> + }
> + }
> +
> + return ret;
> +
> +err_register:
> + platform_device_unregister_children(to_platform_device(dev));
> +err_get_plane_res:
> + dpu_put_plane_grp_res(plane_grp);
> +
> + return ret;
> +}
> +
> +static int dpu_core_probe(struct platform_device *pdev)
> +{
> + struct device *dev = &pdev->dev;
> + struct dpu_soc *dpu;
> + struct resource *res;
> + unsigned long dpu_base;
> + int ret;
> +
> + res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
> + if (!res)
> + return -ENODEV;
> +
> + dpu_base = res->start;
> +
> + dpu = devm_kzalloc(dev, sizeof(*dpu), GFP_KERNEL);
> + if (!dpu)
> + return -ENOMEM;
> +
> + dpu->dev = dev;
> +
> + dpu_units_addr_dbg(dpu, dpu_base);
> +
> + ret = dpu_get_irqs(pdev, dpu);
> + if (ret)
> + return ret;
> +
> + dpu->comctrl_reg = devm_ioremap(dev, dpu_base, SZ_512);
> + if (!dpu->comctrl_reg)
> + return -ENOMEM;
> +
> + ret = dpu_attach_pm_domains(dpu);
> + if (ret)
> + return ret;
> +
> + dpu->clk_cfg = devm_clk_get(dev, "cfg");
> + if (IS_ERR(dpu->clk_cfg)) {
> + ret = PTR_ERR(dpu->clk_cfg);
> + dev_err_probe(dev, ret, "failed to get cfg clock\n");
> + goto failed_clk_cfg_get;
> + }
> +
> + dpu->clk_axi = devm_clk_get(dev, "axi");
> + if (IS_ERR(dpu->clk_axi)) {
> + ret = PTR_ERR(dpu->clk_axi);
> + dev_err_probe(dev, ret, "failed to get axi clock\n");
> + goto failed_clk_axi_get;
> + }
> +
> + ret = dpu_irq_init(dpu);
> + if (ret)
> + goto failed_irq_init;
> +
> + ret = dpu_submodules_init(dpu, dpu_base);
> + if (ret)
> + goto failed_submodules_init;
> +
> + platform_set_drvdata(pdev, dpu);
> +
> + pm_runtime_enable(dev);
> +
> + ret = dpu_add_client_devices(dpu);
> + if (ret) {
> + dev_err(dev, "failed to add client devices: %d\n", ret);
> + goto failed_add_clients;
> + }
> +
> + return ret;
> +
> +failed_add_clients:
> + pm_runtime_disable(dev);
> +failed_submodules_init:
> + dpu_irq_exit(dpu);
> +failed_irq_init:
> +failed_clk_axi_get:
> +failed_clk_cfg_get:
> + dpu_detach_pm_domains(dpu);
> + return ret;
> +}
> +
> +static int dpu_core_remove(struct platform_device *pdev)
> +{
> + struct dpu_soc *dpu = platform_get_drvdata(pdev);
> +
> + platform_device_unregister_children(pdev);
> + pm_runtime_disable(dpu->dev);
> + dpu_irq_exit(dpu);
> + dpu_detach_pm_domains(dpu);
> +
> + return 0;
> +}
> +
> +static int __maybe_unused dpu_runtime_suspend(struct device *dev)
> +{
> + struct platform_device *pdev = to_platform_device(dev);
> + struct dpu_soc *dpu = platform_get_drvdata(pdev);
> +
> + clk_disable_unprepare(dpu->clk_axi);
> + clk_disable_unprepare(dpu->clk_cfg);
> +
> + dev_dbg(dev, "suspended\n");
> +
> + return 0;
> +}
> +
> +static int __maybe_unused dpu_runtime_resume(struct device *dev)
> +{
> + struct platform_device *pdev = to_platform_device(dev);
> + struct dpu_soc *dpu = platform_get_drvdata(pdev);
> + int ret;
> +
> + ret = clk_prepare_enable(dpu->clk_cfg);
> + if (ret) {
> + dev_err(dev, "failed to enable cfg clock: %d\n", ret);
> + return ret;
> + }
> + ret = clk_prepare_enable(dpu->clk_axi);
> + if (ret) {
> + clk_disable_unprepare(dpu->clk_cfg);
> + dev_err(dev, "failed to enable axi clock: %d\n", ret);
> + return ret;
> + }
> +
> + dpu_irq_hw_init(dpu);
> +
> + dpu_submodules_hw_init(dpu);
> +
> + dev_dbg(dev, "resumed\n");
> +
> + return ret;
> +}
> +
> +static const struct dev_pm_ops dpu_pm_ops = {
> + SET_LATE_SYSTEM_SLEEP_PM_OPS(pm_runtime_force_suspend,
> + pm_runtime_force_resume)
> + SET_RUNTIME_PM_OPS(dpu_runtime_suspend, dpu_runtime_resume, NULL)
> +};
> +
> +const struct of_device_id dpu_dt_ids[] = {
> + { .compatible = "fsl,imx8qm-dpu" },
> + { .compatible = "fsl,imx8qxp-dpu" },
> + { /* sentinel */ }
> +};
> +MODULE_DEVICE_TABLE(of, dpu_dt_ids);
> +
> +struct platform_driver dpu_core_driver = {
> + .driver = {
> + .pm = &dpu_pm_ops,
> + .name = "dpu-core",
> + .of_match_table = dpu_dt_ids,
> + },
> + .probe = dpu_core_probe,
> + .remove = dpu_core_remove,
> +};
> diff --git a/drivers/gpu/drm/imx/dpu/dpu-crtc.c b/drivers/gpu/drm/imx/dpu/dpu-crtc.c
> new file mode 100644
> index 00000000..5ed55ec
> --- /dev/null
> +++ b/drivers/gpu/drm/imx/dpu/dpu-crtc.c
> @@ -0,0 +1,967 @@
> +// SPDX-License-Identifier: GPL-2.0+
> +
> +/*
> + * Copyright 2017-2020 NXP
> + */
> +
> +#include <linux/component.h>
> +#include <linux/irq.h>
> +#include <linux/irqflags.h>
> +#include <linux/pm_runtime.h>
> +#include <linux/preempt.h>
> +#include <linux/spinlock.h>
> +
> +#include <drm/drm_atomic.h>
> +#include <drm/drm_atomic_helper.h>
> +#include <drm/drm_atomic_state_helper.h>
> +#include <drm/drm_color_mgmt.h>
> +
> +#include "dpu.h"
> +#include "dpu-crtc.h"
> +#include "dpu-dprc.h"
> +#include "dpu-drv.h"
> +#include "dpu-plane.h"
> +
> +#define DPU_CRTC_WAIT_FOR_COMPLETION_TIMEOUT(_name) \
> +do { \
> + unsigned long ret; \
> + ret = wait_for_completion_timeout(&dpu_crtc->_name, HZ); \
> + if (ret == 0) \
> + dpu_crtc_err(crtc, "%s: wait for " #_name " timeout\n", \
> + __func__); \
> +} while (0)
> +
> +#define DPU_CRTC_WAIT_FOR_FRAMEGEN_FRAME_CNT_MOVING(fg) \
> +do { \
> + if (dpu_fg_wait_for_frame_counter_moving(fg)) \
> + dpu_crtc_err(crtc, \
> + "%s: FrameGen frame counter isn't moving\n", \
> + __func__); \
> +} while (0)
> +
> +#define DPU_CRTC_CHECK_FRAMEGEN_FIFO(fg) \
> +do { \
> + if (dpu_fg_secondary_requests_to_read_empty_fifo(fg)) { \
> + dpu_fg_secondary_clear_channel_status(fg); \
> + dpu_crtc_err(crtc, "%s: FrameGen FIFO empty\n", \
> + __func__); \
> + } \
> +} while (0)
> +
> +#define DPU_CRTC_WAIT_FOR_FRAMEGEN_SECONDARY_SYNCUP(fg) \
> +do { \
> + if (dpu_fg_wait_for_secondary_syncup(fg)) \
> + dpu_crtc_err(crtc, \
> + "%s: FrameGen secondary channel isn't syncup\n",\
> + __func__); \
> +} while (0)
> +
> +static u32 dpu_crtc_get_vblank_counter(struct drm_crtc *crtc)
> +{
> + struct dpu_crtc *dpu_crtc = to_dpu_crtc(crtc);
> +
> + if (pm_runtime_active(dpu_crtc->dev->parent))
> + return dpu_fg_get_frame_index(dpu_crtc->fg);
> + else
> + return (u32)drm_crtc_vblank_count(crtc);
> +}
> +
> +static int dpu_crtc_enable_vblank(struct drm_crtc *crtc)
> +{
> + struct dpu_crtc *dpu_crtc = to_dpu_crtc(crtc);
> +
> + enable_irq(dpu_crtc->dec_frame_complete_irq);
> +
> + return 0;
> +}
> +
> +static void dpu_crtc_disable_vblank(struct drm_crtc *crtc)
> +{
> + struct dpu_crtc *dpu_crtc = to_dpu_crtc(crtc);
> +
> + disable_irq_nosync(dpu_crtc->dec_frame_complete_irq);
> +}
> +
> +static irqreturn_t
> +dpu_crtc_dec_frame_complete_irq_handler(int irq, void *dev_id)
> +{
> + struct dpu_crtc *dpu_crtc = dev_id;
> + struct drm_crtc *crtc = &dpu_crtc->base;
> + unsigned long flags;
> +
> + drm_crtc_handle_vblank(crtc);
> +
> + spin_lock_irqsave(&crtc->dev->event_lock, flags);
> + if (dpu_crtc->event) {
> + drm_crtc_send_vblank_event(crtc, dpu_crtc->event);
> + dpu_crtc->event = NULL;
> + drm_crtc_vblank_put(crtc);
> + }
> + spin_unlock_irqrestore(&crtc->dev->event_lock, flags);
> +
> + return IRQ_HANDLED;
> +}
> +
> +static irqreturn_t dpu_crtc_common_irq_handler(int irq, void *dev_id)
> +{
> + struct dpu_crtc *dpu_crtc = dev_id;
> + struct drm_crtc *crtc = &dpu_crtc->base;
> +
> + if (irq == dpu_crtc->dec_seq_complete_irq) {
> + complete(&dpu_crtc->dec_seq_complete_done);
> + } else if (irq == dpu_crtc->dec_shdld_irq) {
> + complete(&dpu_crtc->dec_shdld_done);
> + } else if (irq == dpu_crtc->ed_cont_shdld_irq) {
> + complete(&dpu_crtc->ed_cont_shdld_done);
> + } else if (irq == dpu_crtc->ed_safe_shdld_irq) {
> + complete(&dpu_crtc->ed_safe_shdld_done);
> + } else {
> + dpu_crtc_err(crtc, "invalid CRTC irq(%u)\n", irq);
> + return IRQ_NONE;
> + }
> +
> + return IRQ_HANDLED;
> +}
> +
> +static const struct drm_crtc_funcs dpu_crtc_funcs = {
> + .reset = drm_atomic_helper_crtc_reset,
> + .destroy = drm_crtc_cleanup,
> + .set_config = drm_atomic_helper_set_config,
> + .page_flip = drm_atomic_helper_page_flip,
> + .atomic_duplicate_state = drm_atomic_helper_crtc_duplicate_state,
> + .atomic_destroy_state = drm_atomic_helper_crtc_destroy_state,
> + .get_vblank_counter = dpu_crtc_get_vblank_counter,
> + .enable_vblank = dpu_crtc_enable_vblank,
> + .disable_vblank = dpu_crtc_disable_vblank,
> + .get_vblank_timestamp = drm_crtc_vblank_helper_get_vblank_timestamp,
> +};
> +
> +static void dpu_crtc_queue_state_event(struct drm_crtc *crtc)
> +{
> + struct dpu_crtc *dpu_crtc = to_dpu_crtc(crtc);
> +
> + spin_lock_irq(&crtc->dev->event_lock);
> + if (crtc->state->event) {
> + WARN_ON(drm_crtc_vblank_get(crtc));
> + WARN_ON(dpu_crtc->event);
> + dpu_crtc->event = crtc->state->event;
> + crtc->state->event = NULL;
> + }
> + spin_unlock_irq(&crtc->dev->event_lock);
> +}
> +
> +static enum drm_mode_status
> +dpu_crtc_mode_valid(struct drm_crtc *crtc, const struct drm_display_mode *mode)
> +{
> + if (mode->crtc_clock > DPU_FRAMEGEN_MAX_CLOCK)
> + return MODE_CLOCK_HIGH;
> +
> + return MODE_OK;
> +}
> +
> +static int dpu_crtc_pm_runtime_get_sync(struct dpu_crtc *dpu_crtc)
> +{
> + int ret;
> +
> + ret = pm_runtime_get_sync(dpu_crtc->dev->parent);
> + if (ret < 0) {
> + pm_runtime_put_noidle(dpu_crtc->dev->parent);
> + dpu_crtc_err(&dpu_crtc->base,
> + "failed to get parent device RPM sync: %d\n", ret);
> + }
> +
> + return ret;
> +}
> +
> +static int dpu_crtc_pm_runtime_put(struct dpu_crtc *dpu_crtc)
> +{
> + int ret;
> +
> + ret = pm_runtime_put(dpu_crtc->dev->parent);
> + if (ret < 0)
> + dpu_crtc_err(&dpu_crtc->base,
> + "failed to put parent device RPM: %d\n", ret);
> +
> + return ret;
> +}
> +
> +static void dpu_crtc_mode_set_nofb(struct drm_crtc *crtc)
> +{
> + struct dpu_crtc *dpu_crtc = to_dpu_crtc(crtc);
> + struct drm_display_mode *adj = &crtc->state->adjusted_mode;
> + enum dpu_link_id cf_link;
> +
> + dpu_crtc_dbg(crtc, "mode " DRM_MODE_FMT "\n", DRM_MODE_ARG(adj));
> +
> + /* request power-on when we start to set mode for CRTC */
> + dpu_crtc_pm_runtime_get_sync(dpu_crtc);
> +
> + dpu_fg_displaymode(dpu_crtc->fg, FG_DM_SEC_ON_TOP);
> + dpu_fg_panic_displaymode(dpu_crtc->fg, FG_DM_CONSTCOL);
> + dpu_fg_cfg_videomode(dpu_crtc->fg, adj);
> +
> + dpu_tcon_cfg_videomode(dpu_crtc->tcon, adj);
> + dpu_tcon_set_fmt(dpu_crtc->tcon);
> +
> + dpu_cf_framedimensions(dpu_crtc->cf_cont,
> + adj->crtc_hdisplay, adj->crtc_vdisplay);
> + dpu_cf_framedimensions(dpu_crtc->cf_safe,
> + adj->crtc_hdisplay, adj->crtc_vdisplay);
> + /* constframe in content stream shows black frame - CRTC background */
> + dpu_cf_constantcolor_black(dpu_crtc->cf_cont);
> + /* constframe in safety stream shows blue frame */
> + dpu_cf_constantcolor_blue(dpu_crtc->cf_safe);
> +
> + cf_link = dpu_cf_get_link_id(dpu_crtc->cf_safe);
> + dpu_ed_pec_src_sel(dpu_crtc->ed_safe, cf_link);
> +
> + cf_link = dpu_cf_get_link_id(dpu_crtc->cf_cont);
> + dpu_ed_pec_src_sel(dpu_crtc->ed_cont, cf_link);
> +}
> +
> +static int dpu_crtc_atomic_check_gamma(struct drm_crtc *crtc,
> + struct drm_crtc_state *state)
> +{
> + size_t lut_size;
> +
> + if (!state->color_mgmt_changed || !state->gamma_lut)
> + return 0;
> +
> + if (crtc->state->gamma_lut &&
> + (crtc->state->gamma_lut->base.id == state->gamma_lut->base.id))
> + return 0;
> +
> + if (state->gamma_lut->length % sizeof(struct drm_color_lut)) {
> + dpu_crtc_dbg(crtc, "wrong gamma_lut length\n");
> + return -EINVAL;
> + }
> +
> + lut_size = state->gamma_lut->length / sizeof(struct drm_color_lut);
> + if (lut_size != 256) {
> + dpu_crtc_dbg(crtc, "gamma_lut size is not 256\n");
> + return -EINVAL;
> + }
> +
> + return 0;
> +}
> +
> +static int dpu_crtc_atomic_check(struct drm_crtc *crtc,
> + struct drm_atomic_state *state)
> +{
> + struct drm_crtc_state *crtc_state;
> + int ret;
> +
> + crtc_state = drm_atomic_get_new_crtc_state(state, crtc);
> +
> + ret = dpu_crtc_atomic_check_gamma(crtc, crtc_state);
> + if (ret)
> + return ret;
> +
> + /* force a mode set if the CRTC is changed to active */
> + if (crtc_state->active_changed && crtc_state->active) {
> + /*
> + * If mode_changed is set by us, call
> + * drm_atomic_helper_check_modeset() as it's Kerneldoc requires.
> + */
> + if (!crtc_state->mode_changed) {
> + crtc_state->mode_changed = true;
> +
> + ret = drm_atomic_helper_check_modeset(crtc->dev, state);
> + if (ret)
> + return ret;
> + }
> + }
> +
> + return ret;
> +}
> +
> +static void dpu_crtc_atomic_begin(struct drm_crtc *crtc,
> + struct drm_atomic_state *state)
> +{
> + struct drm_crtc_state *old_crtc_state;
> + struct drm_atomic_state *old_state;
> + struct dpu_crtc *dpu_crtc = to_dpu_crtc(crtc);
> + struct drm_plane *plane;
> + struct drm_plane_state *old_plane_state;
> + struct dpu_plane_state *old_dpstate;
> + struct dpu_fetchunit *fu;
> + const struct dpu_fetchunit_ops *fu_ops;
> + enum dpu_link_id cf_link;
> + int i;
> +
> + old_crtc_state = drm_atomic_get_old_crtc_state(state, crtc);
> + old_state = old_crtc_state->state;
> +
> + /* do nothing if planes keep being disabled */
> + if (old_crtc_state->plane_mask == 0 && crtc->state->plane_mask == 0)
> + return;
> +
> + /* request power-on when any plane starts to be active */
> + if (old_crtc_state->plane_mask == 0 && crtc->state->plane_mask != 0)
> + dpu_crtc_pm_runtime_get_sync(dpu_crtc);
> +
> + /*
> + * Disable relevant planes' resources in SHADOW only.
> + * Whether any of them would be disabled or kept running depends
> + * on new plane states in the new global atomic state.
> + */
> + for_each_old_plane_in_state(old_state, plane, old_plane_state, i) {
> + old_dpstate = to_dpu_plane_state(old_plane_state);
> +
> + if (!old_plane_state->fb)
> + continue;
> +
> + if (old_plane_state->crtc != crtc)
> + continue;
> +
> + fu = old_dpstate->source;
> +
> + fu_ops = dpu_fu_get_ops(fu);
> +
> + fu_ops->disable_src_buf(fu);
> +
> + if (old_dpstate->is_top) {
> + cf_link = dpu_cf_get_link_id(dpu_crtc->cf_cont);
> + dpu_ed_pec_src_sel(dpu_crtc->ed_cont, cf_link);
> + }
> + }
> +}
> +
> +static void dpu_crtc_set_gammacor(struct dpu_crtc *dpu_crtc)
> +{
> + struct drm_crtc *crtc = &dpu_crtc->base;
> + struct drm_color_lut *lut;
> +
> + lut = (struct drm_color_lut *)crtc->state->gamma_lut->data;
> +
> + dpu_gc_enable_rgb_write(dpu_crtc->gc);
> + dpu_gc_mode(dpu_crtc->gc, GC_GAMMACOR);
> +
> + dpu_gc_start_rgb(dpu_crtc->gc, lut);
> + dpu_gc_delta_rgb(dpu_crtc->gc, lut);
> +}
> +
> +static void dpu_crtc_set_gammacor_sync(struct dpu_crtc *dpu_crtc)
> +{
> + struct drm_crtc *crtc = &dpu_crtc->base;
> +
> + enable_irq(dpu_crtc->dec_shdld_irq);
> +
> + dpu_crtc_set_gammacor(dpu_crtc);
> + dpu_fg_shdtokgen(dpu_crtc->fg);
> + DPU_CRTC_WAIT_FOR_COMPLETION_TIMEOUT(dec_shdld_done);
> +
> + disable_irq(dpu_crtc->dec_shdld_irq);
> +}
> +
> +static void dpu_crtc_disable_gammacor(struct dpu_crtc *dpu_crtc)
> +{
> + dpu_gc_mode(dpu_crtc->gc, GC_NEUTRAL);
> + dpu_gc_disable_rgb_write(dpu_crtc->gc);
> +}
> +
> +static void dpu_crtc_disable_gammacor_sync(struct dpu_crtc *dpu_crtc)
> +{
> + struct drm_crtc *crtc = &dpu_crtc->base;
> +
> + enable_irq(dpu_crtc->dec_shdld_irq);
> +
> + dpu_crtc_disable_gammacor(dpu_crtc);
> + dpu_fg_shdtokgen(dpu_crtc->fg);
> + DPU_CRTC_WAIT_FOR_COMPLETION_TIMEOUT(dec_shdld_done);
> +
> + disable_irq(dpu_crtc->dec_shdld_irq);
> +}
> +
> +static void dpu_crtc_atomic_flush(struct drm_crtc *crtc,
> + struct drm_atomic_state *state)
> +{
> + struct drm_crtc_state *old_crtc_state;
> + struct drm_atomic_state *old_state;
> + struct dpu_crtc *dpu_crtc = to_dpu_crtc(crtc);
> + struct drm_plane *plane;
> + struct drm_plane_state *old_plane_state;
> + struct dpu_plane_state *old_dpstate;
> + struct dpu_fetchunit *fu;
> + struct dpu_dprc *dprc;
> + const struct dpu_fetchunit_ops *fu_ops;
> + bool need_modeset = drm_atomic_crtc_needs_modeset(crtc->state);
> + unsigned long flags;
> + int i;
> +
> + old_crtc_state = drm_atomic_get_old_crtc_state(state, crtc);
> + old_state = old_crtc_state->state;
> +
> + if (old_crtc_state->plane_mask == 0 && crtc->state->plane_mask == 0) {
> + /* Queue a pending vbl event if necessary. */
> + if (!need_modeset && crtc->state->active)
> + dpu_crtc_queue_state_event(crtc);
> + return;
> + }
> +
> + if (!need_modeset && crtc->state->active)
> + enable_irq(dpu_crtc->ed_cont_shdld_irq);
> +
> + /*
> + * Don't relinquish CPU until DPRC repeat_en is disabled
> + * and flush is done(if necessary).
> + */
> + local_irq_save(flags);
> + preempt_disable();
> +
> + /*
> + * Scan over old plane fetchunits to determine if we
> + * need to wait for FrameGen frame counter moving in
> + * the next loop prior to DPRC repeat_en disablement
> + * or not.
> + */
> + for_each_old_plane_in_state(old_state, plane, old_plane_state, i) {
> + old_dpstate = to_dpu_plane_state(old_plane_state);
> +
> + if (!old_plane_state->fb)
> + continue;
> +
> + if (old_plane_state->crtc != crtc)
> + continue;
> +
> + fu = old_dpstate->source;
> +
> + fu_ops = dpu_fu_get_ops(fu);
> +
> + /*
> + * Sync with FrameGen frame counter moving so that
> + * we may disable DPRC repeat_en correctly.
> + */
> + if (!fu_ops->is_enabled(fu) && !need_modeset &&
> + old_crtc_state->active) {
> + DPU_CRTC_WAIT_FOR_FRAMEGEN_FRAME_CNT_MOVING(dpu_crtc->fg);
> + break;
> + }
> + }
> +
> + /*
> + * Set no stream id for disabled fetchunits of relevant planes.
> + * Also, disable DPRC repeat_en if necessary.
> + */
> + for_each_old_plane_in_state(old_state, plane, old_plane_state, i) {
> + old_dpstate = to_dpu_plane_state(old_plane_state);
> +
> + if (!old_plane_state->fb)
> + continue;
> +
> + if (old_plane_state->crtc != crtc)
> + continue;
> +
> + fu = old_dpstate->source;
> +
> + fu_ops = dpu_fu_get_ops(fu);
> +
> + if (!fu_ops->is_enabled(fu)) {
> + fu_ops->set_no_stream_id(fu);
> +
> + dprc = fu_ops->get_dprc(fu);
> + dpu_dprc_disable_repeat_en(dprc);
> + }
> + }
> +
> + if (!need_modeset && crtc->state->active) {
> + /*
> + * Flush plane(s) update out to display & queue a pending
> + * vbl event if necessary.
> + */
> + dpu_ed_pec_sync_trigger(dpu_crtc->ed_cont);
> +
> + local_irq_restore(flags);
> + preempt_enable();
> +
> + if (old_crtc_state->gamma_lut && !crtc->state->gamma_lut)
> + dpu_crtc_disable_gammacor_sync(dpu_crtc);
> + else if (old_crtc_state->gamma_lut && crtc->state->gamma_lut &&
> + old_crtc_state->gamma_lut->base.id !=
> + crtc->state->gamma_lut->base.id)
> + dpu_crtc_set_gammacor_sync(dpu_crtc);
> +
> + DPU_CRTC_WAIT_FOR_COMPLETION_TIMEOUT(ed_cont_shdld_done);
> +
> + disable_irq(dpu_crtc->ed_cont_shdld_irq);
> +
> + DPU_CRTC_CHECK_FRAMEGEN_FIFO(dpu_crtc->fg);
> +
> + dpu_crtc_queue_state_event(crtc);
> + } else {
> + /*
> + * Simply flush and hope that any update takes effect
> + * if CRTC is disabled. This helps for the case where
> + * migrating plane(s) from a disabled CRTC to the other
> + * CRTC.
> + */
> + if (!crtc->state->active)
> + dpu_ed_pec_sync_trigger(dpu_crtc->ed_cont);
> +
> + local_irq_restore(flags);
> + preempt_enable();
> + }
> +
> + /* request power-off when all planes are off */
> + if (old_crtc_state->plane_mask != 0 && crtc->state->plane_mask == 0)
> + dpu_crtc_pm_runtime_put(dpu_crtc);
> +}
> +
> +static void dpu_crtc_atomic_enable(struct drm_crtc *crtc,
> + struct drm_atomic_state *state)
> +{
> + struct dpu_crtc *dpu_crtc = to_dpu_crtc(crtc);
> + unsigned long flags;
> +
> + drm_crtc_vblank_on(crtc);
> +
> + enable_irq(dpu_crtc->dec_shdld_irq);
> + enable_irq(dpu_crtc->ed_cont_shdld_irq);
> + enable_irq(dpu_crtc->ed_safe_shdld_irq);
> +
> + dpu_fg_enable_clock(dpu_crtc->fg);
> + dpu_ed_pec_sync_trigger(dpu_crtc->ed_cont);
> + dpu_ed_pec_sync_trigger(dpu_crtc->ed_safe);
> + if (crtc->state->gamma_lut)
> + dpu_crtc_set_gammacor(dpu_crtc);
> + else
> + dpu_crtc_disable_gammacor(dpu_crtc);
> + dpu_fg_shdtokgen(dpu_crtc->fg);
> +
> + /* don't relinquish CPU until TCON is set to operation mode */
> + local_irq_save(flags);
> + preempt_disable();
> + dpu_fg_enable(dpu_crtc->fg);
> +
> + /*
> + * TKT320590:
> + * Turn TCON into operation mode as soon as the first dumb
> + * frame is generated by DPU(we don't relinquish CPU to ensure
> + * this). This makes DPR/PRG be able to evade the frame.
> + */
> + DPU_CRTC_WAIT_FOR_FRAMEGEN_FRAME_CNT_MOVING(dpu_crtc->fg);
> + dpu_tcon_set_operation_mode(dpu_crtc->tcon);
> + local_irq_restore(flags);
> + preempt_enable();
> +
> + DPU_CRTC_WAIT_FOR_COMPLETION_TIMEOUT(ed_safe_shdld_done);
> + DPU_CRTC_WAIT_FOR_COMPLETION_TIMEOUT(ed_cont_shdld_done);
> + DPU_CRTC_WAIT_FOR_COMPLETION_TIMEOUT(dec_shdld_done);
> +
> + disable_irq(dpu_crtc->ed_safe_shdld_irq);
> + disable_irq(dpu_crtc->ed_cont_shdld_irq);
> + disable_irq(dpu_crtc->dec_shdld_irq);
> +
> + DPU_CRTC_WAIT_FOR_FRAMEGEN_SECONDARY_SYNCUP(dpu_crtc->fg);
> +
> + DPU_CRTC_CHECK_FRAMEGEN_FIFO(dpu_crtc->fg);
> +
> + dpu_crtc_queue_state_event(crtc);
> +}
> +
> +static void dpu_crtc_atomic_disable(struct drm_crtc *crtc,
> + struct drm_atomic_state *state)
> +{
> + struct dpu_crtc *dpu_crtc = to_dpu_crtc(crtc);
> + struct drm_plane *plane;
> + struct drm_plane_state *old_plane_state;
> + struct dpu_plane_state *old_dpstate;
> + struct dpu_fetchunit *fu;
> + struct dpu_dprc *dprc;
> + const struct dpu_fetchunit_ops *fu_ops;
> + unsigned long flags;
> + int i;
> +
> + enable_irq(dpu_crtc->dec_seq_complete_irq);
> +
> + /* don't relinquish CPU until DPRC repeat_en is disabled */
> + local_irq_save(flags);
> + preempt_disable();
> + /*
> + * Sync to FrameGen frame counter moving so that
> + * FrameGen can be disabled in the next frame.
> + */
> + DPU_CRTC_WAIT_FOR_FRAMEGEN_FRAME_CNT_MOVING(dpu_crtc->fg);
> + dpu_fg_disable(dpu_crtc->fg);
> + /*
> + * There is one frame leftover after FrameGen disablement.
> + * Sync to FrameGen frame counter moving so that
> + * DPRC repeat_en can be disabled in the next frame.
> + */
> + DPU_CRTC_WAIT_FOR_FRAMEGEN_FRAME_CNT_MOVING(dpu_crtc->fg);
> +
> + for_each_old_plane_in_state(state, plane, old_plane_state, i) {
> + old_dpstate = to_dpu_plane_state(old_plane_state);
> +
> + if (!old_plane_state->fb)
> + continue;
> +
> + if (old_plane_state->crtc != crtc)
> + continue;
> +
> + fu = old_dpstate->source;
> +
> + fu_ops = dpu_fu_get_ops(fu);
> +
> + dprc = fu_ops->get_dprc(fu);
> + dpu_dprc_disable_repeat_en(dprc);
> + }
> +
> + local_irq_restore(flags);
> + preempt_enable();
> +
> + DPU_CRTC_WAIT_FOR_COMPLETION_TIMEOUT(dec_seq_complete_done);
> +
> + disable_irq(dpu_crtc->dec_seq_complete_irq);
> +
> + dpu_fg_disable_clock(dpu_crtc->fg);
> +
> + drm_crtc_vblank_off(crtc);
> +
> + spin_lock_irq(&crtc->dev->event_lock);
> + if (crtc->state->event && !crtc->state->active) {
> + drm_crtc_send_vblank_event(crtc, crtc->state->event);
> + crtc->state->event = NULL;
> + }
> + spin_unlock_irq(&crtc->dev->event_lock);
> +
> + /* request power-off when CRTC is disabled */
> + dpu_crtc_pm_runtime_put(dpu_crtc);
> +}
> +
> +static bool dpu_crtc_get_scanout_position(struct drm_crtc *crtc,
> + bool in_vblank_irq,
> + int *vpos, int *hpos,
> + ktime_t *stime, ktime_t *etime,
> + const struct drm_display_mode *mode)
> +{
> + struct dpu_crtc *dpu_crtc = to_dpu_crtc(crtc);
> + int vdisplay = mode->crtc_vdisplay;
> + int vtotal = mode->crtc_vtotal;
> + int line;
> + bool reliable;
> +
> + if (stime)
> + *stime = ktime_get();
> +
> + if (pm_runtime_active(dpu_crtc->dev->parent)) {
> + /* line index starts with 0 for the first active output line */
> + line = dpu_fg_get_line_index(dpu_crtc->fg);
> +
> + if (line < vdisplay)
> + /* active scanout area - positive */
> + *vpos = line + 1;
> + else
> + /* inside vblank - negative */
> + *vpos = line - (vtotal - 1);
> +
> + reliable = true;
> + } else {
> + *vpos = 0;
> + reliable = false;
> + }
> +
> + *hpos = 0;
> +
> + if (etime)
> + *etime = ktime_get();
> +
> + return reliable;
> +}
> +
> +static const struct drm_crtc_helper_funcs dpu_helper_funcs = {
> + .mode_valid = dpu_crtc_mode_valid,
> + .mode_set_nofb = dpu_crtc_mode_set_nofb,
> + .atomic_check = dpu_crtc_atomic_check,
> + .atomic_begin = dpu_crtc_atomic_begin,
> + .atomic_flush = dpu_crtc_atomic_flush,
> + .atomic_enable = dpu_crtc_atomic_enable,
> + .atomic_disable = dpu_crtc_atomic_disable,
> + .get_scanout_position = dpu_crtc_get_scanout_position,
> +};
> +
> +static void dpu_crtc_put_resources(struct dpu_crtc *dpu_crtc)
> +{
> + dpu_cf_cont_put(dpu_crtc->cf_cont);
> + dpu_cf_safe_put(dpu_crtc->cf_safe);
> + dpu_dec_put(dpu_crtc->dec);
> + dpu_ed_cont_put(dpu_crtc->ed_cont);
> + dpu_ed_safe_put(dpu_crtc->ed_safe);
> + dpu_fg_put(dpu_crtc->fg);
> + dpu_gc_put(dpu_crtc->gc);
> + dpu_tcon_put(dpu_crtc->tcon);
> +}
> +
> +static int dpu_crtc_get_resources(struct dpu_crtc *dpu_crtc)
> +{
> + struct dpu_soc *dpu = dev_get_drvdata(dpu_crtc->dev->parent);
> + struct {
> + void **dpu_unit;
> + void *(*get)(struct dpu_soc *dpu, unsigned int id);
> + } resources[] = {
> + {(void *) &dpu_crtc->cf_cont, (void *) dpu_cf_cont_get},
> + {(void *) &dpu_crtc->cf_safe, (void *) dpu_cf_safe_get},
> + {(void *) &dpu_crtc->dec, (void *) dpu_dec_get},
> + {(void *) &dpu_crtc->ed_cont, (void *) dpu_ed_cont_get},
> + {(void *) &dpu_crtc->ed_safe, (void *) dpu_ed_safe_get},
> + {(void *) &dpu_crtc->fg, (void *) dpu_fg_get},
> + {(void *) &dpu_crtc->gc, (void *) dpu_gc_get},
> + {(void *) &dpu_crtc->tcon, (void *) dpu_tcon_get},
> + };
> + int i, ret;
> +
> + for (i = 0; i < ARRAY_SIZE(resources); i++) {
> + *resources[i].dpu_unit =
> + resources[i].get(dpu, dpu_crtc->stream_id);
> + if (IS_ERR(*resources[i].dpu_unit)) {
> + ret = PTR_ERR(*resources[i].dpu_unit);
> + dpu_crtc_put_resources(dpu_crtc);
> + return ret;
> + }
> + }
> +
> + return 0;
> +}
> +
> +static int dpu_crtc_request_irq(struct dpu_crtc *dpu_crtc,
> + unsigned int *crtc_irq,
> + unsigned int dpu_irq,
> + irqreturn_t (*irq_handler)(int irq,
> + void *dev_id))
> +{
> + struct drm_crtc *crtc = &dpu_crtc->base;
> + struct dpu_soc *dpu = dev_get_drvdata(dpu_crtc->dev->parent);
> + int ret;
> +
> + *crtc_irq = dpu_map_irq(dpu, dpu_irq);
> + irq_set_status_flags(*crtc_irq, IRQ_DISABLE_UNLAZY);
> + ret = devm_request_irq(dpu_crtc->dev, *crtc_irq, irq_handler,
> + 0, dev_name(dpu_crtc->dev), dpu_crtc);
> + if (ret < 0) {
> + dpu_crtc_err(crtc, "failed to request irq(%u): %d\n",
> + *crtc_irq, ret);
> + return ret;
> + }
> + disable_irq(*crtc_irq);
> +
> + return 0;
> +}
> +
> +static int dpu_crtc_request_irqs(struct dpu_crtc *dpu_crtc,
> + struct dpu_client_platformdata *pdata)
> +{
> + struct {
> + unsigned int *crtc_irq;
> + unsigned int dpu_irq;
> + irqreturn_t (*irq_handler)(int irq, void *dev_id);
> + } irqs[] = {
> + {
> + &dpu_crtc->dec_frame_complete_irq,
> + pdata->dec_frame_complete_irq,
> + dpu_crtc_dec_frame_complete_irq_handler,
> + }, {
> + &dpu_crtc->dec_seq_complete_irq,
> + pdata->dec_seq_complete_irq,
> + dpu_crtc_common_irq_handler,
> + }, {
> + &dpu_crtc->dec_shdld_irq,
> + pdata->dec_shdld_irq,
> + dpu_crtc_common_irq_handler,
> + }, {
> + &dpu_crtc->ed_cont_shdld_irq,
> + pdata->ed_cont_shdld_irq,
> + dpu_crtc_common_irq_handler,
> + }, {
> + &dpu_crtc->ed_safe_shdld_irq,
> + pdata->ed_safe_shdld_irq,
> + dpu_crtc_common_irq_handler,
> + },
> + };
> + int i, ret;
> +
> + for (i = 0; i < ARRAY_SIZE(irqs); i++) {
> + ret = dpu_crtc_request_irq(dpu_crtc,
> + irqs[i].crtc_irq, irqs[i].dpu_irq, irqs[i].irq_handler);
> + if (ret)
> + return ret;
> + }
> +
> + return 0;
> +}
> +
> +static int dpu_crtc_init(struct dpu_crtc *dpu_crtc,
> + struct dpu_client_platformdata *pdata,
> + struct dpu_drm_device *dpu_drm)
> +{
> + struct drm_device *drm = &dpu_drm->base;
> + struct drm_crtc *crtc = &dpu_crtc->base;
> + struct dpu_plane *dpu_plane;
> + struct dpu_crtc_grp *crtc_grp = pdata->crtc_grp;
> + struct dpu_plane_grp *plane_grp = crtc_grp->plane_grp;
> + unsigned int stream_id = pdata->stream_id;
> + unsigned int crtc_cnt;
> + int i, ret;
> +
> + init_completion(&dpu_crtc->dec_seq_complete_done);
> + init_completion(&dpu_crtc->dec_shdld_done);
> + init_completion(&dpu_crtc->ed_cont_shdld_done);
> + init_completion(&dpu_crtc->ed_safe_shdld_done);
> +
> + dpu_crtc->grp = crtc_grp;
> + dpu_crtc->stream_id = stream_id;
> + dpu_crtc->hw_plane_cnt = plane_grp->hw_plane_cnt;
> +
> + ret = dpu_crtc_get_resources(dpu_crtc);
> + if (ret) {
> + drm_err(drm, "failed to get HW resources for CRTC: %d\n", ret);
> + return ret;
> + }
> +
> + plane_grp->cf[stream_id] = dpu_crtc->cf_cont;
> + plane_grp->ed[stream_id] = dpu_crtc->ed_cont;
> +
> + /* each CRTC has a primary plane */
> + dpu_plane = dpu_plane_initialize(drm, 0, plane_grp,
> + DRM_PLANE_TYPE_PRIMARY);
> + if (IS_ERR(dpu_plane)) {
> + ret = PTR_ERR(dpu_plane);
> + drm_err(drm, "failed to init primary plane: %d\n", ret);
> + goto err_put_resources;
> + }
> +
> + drm_crtc_helper_add(crtc, &dpu_helper_funcs);
> +
> + ret = drm_crtc_init_with_planes(drm, crtc, &dpu_plane->base,
> + NULL, &dpu_crtc_funcs, NULL);
> + if (ret) {
> + drm_err(drm, "failed to add CRTC: %d\n", ret);
> + goto err_put_resources;
> + }
> +
> + /* X server assumes 256 element gamma table so let's use that. */
> + ret = drm_mode_crtc_set_gamma_size(crtc, 256);
> + if (ret) {
> + dpu_crtc_err(crtc, "failed to set gamma size: %d\n", ret);
> + goto err_put_resources;
> + }
> +
> + drm_crtc_enable_color_mgmt(crtc, 0, false, 256);
> +
> + dpu_crtc->encoder->possible_crtcs = drm_crtc_mask(crtc);
> + crtc_grp->crtc_mask |= drm_crtc_mask(crtc);
> + crtc_cnt = hweight32(crtc_grp->crtc_mask);
> +
> + /* initialize shared overlay planes for CRTCs in a CRTC group */
> + if (crtc_cnt == DPU_CRTC_CNT_IN_GRP) {
> + /*
> + * All HW planes in a plane group are shared by CRTCs in a
> + * CRTC group. They will be assigned to either primary plane
> + * or overlay plane dynamically in runtime. Considering a
> + * CRTC consumes all HW planes and primary plane takes one
> + * HW plane, so overlay plane count for a CRTC group should
> + * be plane_grp->hw_plane_cnt - 1.
> + */
> + for (i = 1; i < plane_grp->hw_plane_cnt; i++) {
> + dpu_plane =
> + dpu_plane_initialize(drm, crtc_grp->crtc_mask,
> + plane_grp,
> + DRM_PLANE_TYPE_OVERLAY);
> + if (IS_ERR(dpu_plane)) {
> + ret = PTR_ERR(dpu_plane);
> + dpu_crtc_err(crtc,
> + "failed to init overlay plane(%d): %d\n",
> + i, ret);
> + goto err_put_resources;
> + }
> + }
> + }
> +
> + ret = dpu_crtc_pm_runtime_get_sync(dpu_crtc);
> + if (ret < 0)
> + goto err_put_resources;
> +
> + ret = dpu_crtc_request_irqs(dpu_crtc, pdata);
> + if (ret)
> + goto err_put_pm_runtime;
> +
> + ret = dpu_crtc_pm_runtime_put(dpu_crtc);
> + if (ret < 0)
> + dpu_crtc_put_resources(dpu_crtc);
> +
> + return ret;
> +
> +err_put_pm_runtime:
> + pm_runtime_put(dpu_crtc->dev->parent);
> +err_put_resources:
> + dpu_crtc_put_resources(dpu_crtc);
> +
> + return ret;
> +}
> +
> +static int dpu_crtc_bind(struct device *dev, struct device *master, void *data)
> +{
> + struct dpu_client_platformdata *pdata = dev->platform_data;
> + struct dpu_drm_device *dpu_drm = data;
> + struct dpu_crtc *dpu_crtc;
> + bool found = false;
> + int ret;
> +
> + list_for_each_entry(dpu_crtc, &dpu_drm->crtc_list, node) {
> + if (dpu_crtc->np == dev->of_node) {
> + found = true;
> + break;
> + }
> + }
> +
> + if (!found) {
> + drm_err(&dpu_drm->base, "failed to find CRTC OF node\n");
> + return -ENODEV;
> + }
> +
> + dpu_crtc->dev = dev;
> +
> + ret = dpu_crtc_init(dpu_crtc, pdata, dpu_drm);
> + if (ret)
> + return ret;
> +
> + dev_set_drvdata(dev, dpu_crtc);
> +
> + return ret;
> +}
> +
> +static void dpu_crtc_unbind(struct device *dev, struct device *master,
> + void *data)
> +{
> + struct dpu_crtc *dpu_crtc = dev_get_drvdata(dev);
> +
> + dpu_crtc_put_resources(dpu_crtc);
> +}
> +
> +static const struct component_ops dpu_crtc_ops = {
> + .bind = dpu_crtc_bind,
> + .unbind = dpu_crtc_unbind,
> +};
> +
> +static int dpu_crtc_probe(struct platform_device *pdev)
> +{
> + struct device *dev = &pdev->dev;
> +
> + if (!dev->platform_data)
> + return -EINVAL;
> +
> + return component_add(dev, &dpu_crtc_ops);
> +}
> +
> +static int dpu_crtc_remove(struct platform_device *pdev)
> +{
> + component_del(&pdev->dev, &dpu_crtc_ops);
> + return 0;
> +}
> +
> +struct platform_driver dpu_crtc_driver = {
> + .driver = {
> + .name = "imx-dpu-crtc",
> + },
> + .probe = dpu_crtc_probe,
> + .remove = dpu_crtc_remove,
> +};
> diff --git a/drivers/gpu/drm/imx/dpu/dpu-crtc.h b/drivers/gpu/drm/imx/dpu/dpu-crtc.h
> new file mode 100644
> index 00000000..a5697f3
> --- /dev/null
> +++ b/drivers/gpu/drm/imx/dpu/dpu-crtc.h
> @@ -0,0 +1,66 @@
> +/* SPDX-License-Identifier: GPL-2.0+ */
> +
> +/*
> + * Copyright 2017-2020 NXP
> + */
> +
> +#ifndef __DPU_CRTC_H__
> +#define __DPU_CRTC_H__
> +
> +#include <linux/completion.h>
> +#include <linux/device.h>
> +#include <linux/kernel.h>
> +#include <linux/of.h>
> +
> +#include <drm/drm_crtc.h>
> +#include <drm/drm_encoder.h>
> +#include <drm/drm_print.h>
> +#include <drm/drm_vblank.h>
> +
> +#include "dpu.h"
> +
> +#define dpu_crtc_dbg(crtc, fmt, ...) \
> + drm_dbg_kms((crtc)->dev, "[CRTC:%d:%s] " fmt, \
> + (crtc)->base.id, (crtc)->name, ##__VA_ARGS__)
> +
> +#define dpu_crtc_err(crtc, fmt, ...) \
> + drm_err((crtc)->dev, "[CRTC:%d:%s] " fmt, \
> + (crtc)->base.id, (crtc)->name, ##__VA_ARGS__)
> +
> +#define DPU_CRTC_CNT_IN_GRP 2
> +
> +struct dpu_crtc {
> + struct device *dev;
> + struct device_node *np;
> + struct list_head node;
> + struct drm_crtc base;
> + struct dpu_crtc_grp *grp;
> + struct drm_encoder *encoder;
> + struct dpu_constframe *cf_cont;
> + struct dpu_constframe *cf_safe;
> + struct dpu_disengcfg *dec;
> + struct dpu_extdst *ed_cont;
> + struct dpu_extdst *ed_safe;
> + struct dpu_framegen *fg;
> + struct dpu_gammacor *gc;
> + struct dpu_tcon *tcon;
> + unsigned int stream_id;
> + unsigned int hw_plane_cnt;
> + unsigned int dec_frame_complete_irq;
> + unsigned int dec_seq_complete_irq;
> + unsigned int dec_shdld_irq;
> + unsigned int ed_cont_shdld_irq;
> + unsigned int ed_safe_shdld_irq;
> + struct completion dec_seq_complete_done;
> + struct completion dec_shdld_done;
> + struct completion ed_safe_shdld_done;
> + struct completion ed_cont_shdld_done;
> + struct drm_pending_vblank_event *event;
> +};
> +
> +static inline struct dpu_crtc *to_dpu_crtc(struct drm_crtc *crtc)
> +{
> + return container_of(crtc, struct dpu_crtc, base);
> +}
> +
> +#endif /* __DPU_CRTC_H__ */
> diff --git a/drivers/gpu/drm/imx/dpu/dpu-disengcfg.c b/drivers/gpu/drm/imx/dpu/dpu-disengcfg.c
> new file mode 100644
> index 00000000..a2687f2
> --- /dev/null
> +++ b/drivers/gpu/drm/imx/dpu/dpu-disengcfg.c
> @@ -0,0 +1,117 @@
> +// SPDX-License-Identifier: GPL-2.0+
> +
> +/*
> + * Copyright (C) 2016 Freescale Semiconductor, Inc.
> + * Copyright 2017-2020 NXP
> + */
> +
> +#include <linux/io.h>
> +#include <linux/kernel.h>
> +#include <linux/mutex.h>
> +#include <linux/sizes.h>
> +
> +#include "dpu-prv.h"
> +
> +#define POLARITYCTRL 0xc
> +#define POLHS_HIGH BIT(0)
> +#define POLVS_HIGH BIT(1)
> +#define POLEN_HIGH BIT(2)
> +#define PIXINV_INV BIT(3)
> +
> +#define SRCSELECT0 0x10
> +#define PATH_SELECT0 BIT(4)
> +#define MATRIX_FIRST BIT(4)
> +#define GAMMA_FIRST 0
> +#define SIG_SELECT0 0x3
> +#define SIG_FRAMEGEN 0x0
> +#define SIG_GAMMACOR 0x1
> +#define SIG_MATRIX 0x2
> +#define SIG_DITHER 0x3
> +
> +struct dpu_disengcfg {
> + void __iomem *base;
> + struct mutex mutex;
> + unsigned int id;
> + unsigned int index;
> + bool inuse;
> + struct dpu_soc *dpu;
> +};
> +
> +static inline void dpu_dec_write(struct dpu_disengcfg *dec,
> + unsigned int offset, u32 value)
> +{
> + writel(value, dec->base + offset);
> +}
> +
> +struct dpu_disengcfg *dpu_dec_get(struct dpu_soc *dpu, unsigned int id)
> +{
> + struct dpu_disengcfg *dec;
> + int i;
> +
> + for (i = 0; i < ARRAY_SIZE(dpu->dec_priv); i++) {
> + dec = dpu->dec_priv[i];
> + if (dec->id == id)
> + break;
> + }
> +
> + if (i == ARRAY_SIZE(dpu->dec_priv))
> + return ERR_PTR(-EINVAL);
> +
> + mutex_lock(&dec->mutex);
> +
> + if (dec->inuse) {
> + mutex_unlock(&dec->mutex);
> + return ERR_PTR(-EBUSY);
> + }
> +
> + dec->inuse = true;
> +
> + mutex_unlock(&dec->mutex);
> +
> + return dec;
> +}
> +
> +void dpu_dec_put(struct dpu_disengcfg *dec)
> +{
> + if (IS_ERR_OR_NULL(dec))
> + return;
> +
> + mutex_lock(&dec->mutex);
> +
> + dec->inuse = false;
> +
> + mutex_unlock(&dec->mutex);
> +}
> +
> +void dpu_dec_hw_init(struct dpu_soc *dpu, unsigned int index)
> +{
> + struct dpu_disengcfg *dec = dpu->dec_priv[index];
> +
> + dpu_dec_write(dec, POLARITYCTRL, POLEN_HIGH);
> + dpu_dec_write(dec, SRCSELECT0, GAMMA_FIRST | SIG_FRAMEGEN);
> +}
> +
> +int dpu_dec_init(struct dpu_soc *dpu, unsigned int index,
> + unsigned int id, enum dpu_unit_type type,
> + unsigned long unused, unsigned long base)
> +{
> + struct dpu_disengcfg *dec;
> +
> + dec = devm_kzalloc(dpu->dev, sizeof(*dec), GFP_KERNEL);
> + if (!dec)
> + return -ENOMEM;
> +
> + dpu->dec_priv[index] = dec;
> +
> + dec->base = devm_ioremap(dpu->dev, base, SZ_32);
> + if (!dec->base)
> + return -ENOMEM;
> +
> + dec->dpu = dpu;
> + dec->id = id;
> + dec->index = index;
> +
> + mutex_init(&dec->mutex);
> +
> + return 0;
> +}
> diff --git a/drivers/gpu/drm/imx/dpu/dpu-dprc.c b/drivers/gpu/drm/imx/dpu/dpu-dprc.c
> new file mode 100644
> index 00000000..7679273
> --- /dev/null
> +++ b/drivers/gpu/drm/imx/dpu/dpu-dprc.c
> @@ -0,0 +1,723 @@
> +// SPDX-License-Identifier: GPL-2.0+
> +
> +/*
> + * Copyright 2017-2020 NXP
> + */
> +
> +#include <linux/clk.h>
> +#include <linux/delay.h>
> +#include <linux/firmware/imx/svc/misc.h>
> +#include <linux/interrupt.h>
> +#include <linux/io.h>
> +#include <linux/kernel.h>
> +#include <linux/module.h>
> +#include <linux/of_device.h>
> +#include <linux/platform_device.h>
> +#include <linux/pm_runtime.h>
> +
> +#include <dt-bindings/firmware/imx/rsrc.h>
> +
> +#include "dpu.h"
> +#include "dpu-dprc.h"
> +#include "dpu-prg.h"
> +
> +#define SET 0x4
> +#define CLR 0x8
> +#define TOG 0xc
> +
> +#define SYSTEM_CTRL0 0x00
> +#define BCMD2AXI_MASTR_ID_CTRL BIT(16)
> +#define SW_SHADOW_LOAD_SEL BIT(4)
> +#define SHADOW_LOAD_EN BIT(3)
> +#define REPEAT_EN BIT(2)
> +#define SOFT_RESET BIT(1)
> +#define RUN_EN BIT(0) /* self-clearing */
> +
> +#define IRQ_MASK 0x20
> +#define IRQ_MASK_STATUS 0x30
> +#define IRQ_NONMASK_STATUS 0x40
> +#define DPR2RTR_FIFO_LOAD_BUF_RDY_UV_ERROR BIT(7)
> +#define DPR2RTR_FIFO_LOAD_BUF_RDY_YRGB_ERROR BIT(6)
> +#define DPR2RTR_UV_FIFO_OVFL BIT(5)
> +#define DPR2RTR_YRGB_FIFO_OVFL BIT(4)
> +#define IRQ_AXI_READ_ERROR BIT(3)
> +#define IRQ_DPR_SHADOW_LOADED_MASK BIT(2)
> +#define IRQ_DPR_RUN BIT(1)
> +#define IRQ_DPR_CRTL_DONE BIT(0)
> +#define IRQ_CTRL_MASK 0x7
> +
> +#define MODE_CTRL0 0x50
> +#define A_COMP_SEL(byte) (((byte) & 0x3) << 16)
> +#define R_COMP_SEL(byte) (((byte) & 0x3) << 14)
> +#define G_COMP_SEL(byte) (((byte) & 0x3) << 12)
> +#define B_COMP_SEL(byte) (((byte) & 0x3) << 10)
> +#define PIX_UV_SWAP BIT(9)
> +#define PIX_LUMA_UV_SWAP BIT(8)
> +#define PIX_SIZE_8BIT (0 << 6)
> +#define PIX_SIZE_16BIT (1 << 6)
> +#define PIX_SIZE_32BIT (2 << 6)
> +#define COMP_2PLANE_EN BIT(5)
> +#define YUV_EN BIT(4)
> +#define LINEAR_TILE (0 << 2)
> +#define GPU_STANDARD_TILE (1 << 2)
> +#define GPU_SUPER_TILE (2 << 2)
> +#define VPU_TILE (3 << 2)
> +#define LINE4 BIT(1)
> +#define LINE8 0
> +#define BUF3 BIT(0)
> +#define BUF2 0
> +
> +#define FRAME_CTRL0 0x70
> +#define PITCH(n) (((n) & 0xffff) << 16)
> +#define ROT_FIRST BIT(4)
> +#define FLIP_FIRST 0
> +#define ROT_ENC_MASK 0xc
> +#define ROT_ENC_0 0x0
> +#define ROT_ENC_90 0x4
> +#define ROT_ENC_270 0xc
> +#define DEGREE(n) ((((n) / 90) & 0x3) << 2)
> +#define VFLIP_EN BIT(1)
> +#define HFLIP_EN BIT(0)
> +
> +#define FRAME_1P_CTRL0 0x90
> +#define FRAME_2P_CTRL0 0xe0
> +#define BYTE_64 0x0
> +#define BYTE_128 0x1
> +#define BYTE_256 0x2
> +#define BYTE_512 0x3
> +#define BYTE_1K 0x4
> +#define BYTE_2K 0x5
> +#define BYTE_4K 0x6
> +
> +#define FRAME_1P_PIX_X_CTRL 0xa0
> +#define NUM_X_PIX_WIDE(n) ((n) & 0xffff)
> +
> +#define FRAME_1P_PIX_Y_CTRL 0xb0
> +#define NUM_Y_PIX_HIGH(n) ((n) & 0xffff)
> +
> +#define FRAME_1P_BASE_ADDR_CTRL0 0xc0
> +
> +#define FRAME_PIX_X_ULC_CTRL 0xf0
> +#define CROP_ULC_X(n) ((n) & 0xffff)
> +
> +#define FRAME_PIX_Y_ULC_CTRL 0x100
> +#define CROP_ULC_Y(n) ((n) & 0xffff)
> +
> +#define FRAME_2P_BASE_ADDR_CTRL0 0x110
> +
> +#define STATUS_CTRL0 0x130
> +#define STATUS_CTRL1 0x140
> +
> +#define RTRAM_CTRL0 0x200
> +#define ABORT BIT(7)
> +#define STALL 0
> +#define THRES_LOW(n) (((n) & 0x7) << 4)
> +#define THRES_HIGH(n) (((n) & 0x7) << 1)
> +#define ROWS_0_6 BIT(0)
> +#define ROWS_0_4 0
> +
> +#define DPU_DRPC_MAX_STRIDE 0x10000
> +#define DPU_DPRC_MAX_RTRAM_WIDTH 2880
> +
> +struct dpu_dprc {
> + struct device *dev;
> + void __iomem *base;
> + struct list_head list;
> + struct clk *clk_apb;
> + struct clk *clk_b;
> + struct clk *clk_rtram;
> + struct imx_sc_ipc *ipc_handle;
> + spinlock_t spin_lock;
> + u32 sc_resource;
> + bool is_blit;
> +
> + /* The second one, if non-NULL, is auxiliary for UV buffer. */
> + struct dpu_prg *prgs[2];
> + bool has_aux_prg;
> + bool use_aux_prg;
> +};
> +
> +static DEFINE_MUTEX(dpu_dprc_list_mutex);
> +static LIST_HEAD(dpu_dprc_list);
> +
> +static inline u32 dpu_dprc_read(struct dpu_dprc *dprc, unsigned int offset)
> +{
> + return readl(dprc->base + offset);
> +}
> +
> +static inline void
> +dpu_dprc_write(struct dpu_dprc *dprc, unsigned int offset, u32 value)
> +{
> + writel(value, dprc->base + offset);
> +}
> +
> +static inline void
> +dpu_dprc_set_stream_id(struct dpu_dprc *dprc, unsigned int stream_id)
> +{
> + int ret;
> +
> + ret = imx_sc_misc_set_control(dprc->ipc_handle,
> + dprc->sc_resource, IMX_SC_C_KACHUNK_SEL, stream_id);
> + if (ret)
> + dev_warn(dprc->dev, "failed to set KACHUNK_SEL: %d\n", ret);
> +}
> +
> +static inline void
> +dpu_dprc_set_prg_sel(struct dpu_dprc *dprc, u32 resource, bool enable)
> +{
> + int ret;
> +
> + ret = imx_sc_misc_set_control(dprc->ipc_handle,
> + resource, IMX_SC_C_SEL0, enable);
> + if (ret)
> + dev_warn(dprc->dev, "failed to set SEL0: %d\n", ret);
> +}
> +
> +static void dpu_dprc_reset(struct dpu_dprc *dprc)
> +{
> + dpu_dprc_write(dprc, SYSTEM_CTRL0 + SET, SOFT_RESET);
> + usleep_range(10, 20);
> + dpu_dprc_write(dprc, SYSTEM_CTRL0 + CLR, SOFT_RESET);
> +}
> +
> +static void dpu_dprc_enable(struct dpu_dprc *dprc)
> +{
> + dpu_prg_enable(dprc->prgs[0]);
> + if (dprc->use_aux_prg)
> + dpu_prg_enable(dprc->prgs[1]);
> +}
> +
> +static void dpu_dprc_reg_update(struct dpu_dprc *dprc)
> +{
> + dpu_prg_reg_update(dprc->prgs[0]);
> + if (dprc->use_aux_prg)
> + dpu_prg_reg_update(dprc->prgs[1]);
> +}
> +
> +static void dpu_dprc_enable_ctrl_done_irq(struct dpu_dprc *dprc)
> +{
> + unsigned long flags;
> +
> + spin_lock_irqsave(&dprc->spin_lock, flags);
> + dpu_dprc_write(dprc, IRQ_MASK + CLR, IRQ_DPR_CRTL_DONE);
> + spin_unlock_irqrestore(&dprc->spin_lock, flags);
> +}
> +
> +void dpu_dprc_configure(struct dpu_dprc *dprc, unsigned int stream_id,
> + unsigned int width, unsigned int height,
> + unsigned int x_offset, unsigned int y_offset,
> + unsigned int stride,
> + const struct drm_format_info *format, u64 modifier,
> + dma_addr_t baddr, dma_addr_t uv_baddr,
> + bool start, bool interlace_frame)
> +{
> + struct device *dev = dprc->dev;
> + unsigned int dprc_width = width + x_offset;
> + unsigned int dprc_height;
> + unsigned int p1_w, p1_h;
> + unsigned int prg_stride = width * format->cpp[0];
> + unsigned int bpp = 8 * format->cpp[0];
> + unsigned int preq;
> + unsigned int mt_w = 0, mt_h = 0; /* micro-tile width/height */
> + u32 val;
> +
> + dprc->use_aux_prg = false;
> +
> + if (start && !dprc->is_blit)
> + dpu_dprc_set_stream_id(dprc, stream_id);
> +
> + if (interlace_frame) {
> + height /= 2;
> + y_offset /= 2;
> + }
> +
> + dprc_height = height + y_offset;
> +
> + if (format->num_planes > 1) {
> + p1_w = round_up(dprc_width, modifier ? 8 : 64);
> + p1_h = round_up(dprc_height, 8);
> +
> + preq = modifier ? BYTE_64 : BYTE_1K;
> +
> + dpu_dprc_write(dprc, FRAME_2P_CTRL0, preq);
> + if (dprc->sc_resource == IMX_SC_R_DC_0_BLIT1 ||
> + dprc->sc_resource == IMX_SC_R_DC_1_BLIT1) {
> + dpu_dprc_set_prg_sel(dprc,
> + dprc->sc_resource == IMX_SC_R_DC_0_BLIT1 ?
> + IMX_SC_R_DC_0_BLIT0 : IMX_SC_R_DC_1_BLIT0,
> + true);
> + dpu_prg_set_auxiliary(dprc->prgs[1]);
> + dprc->has_aux_prg = true;
> + }
> + dpu_dprc_write(dprc, FRAME_2P_BASE_ADDR_CTRL0, uv_baddr);
> + } else {
> + switch (dprc->sc_resource) {
> + case IMX_SC_R_DC_0_BLIT0:
> + case IMX_SC_R_DC_1_BLIT0:
> + dpu_dprc_set_prg_sel(dprc, dprc->sc_resource, false);
> + dpu_prg_set_primary(dprc->prgs[0]);
> + break;
> + case IMX_SC_R_DC_0_BLIT1:
> + case IMX_SC_R_DC_1_BLIT1:
> + dprc->has_aux_prg = false;
> + break;
> + default:
> + break;
> + }
> +
> + switch (modifier) {
> + case DRM_FORMAT_MOD_VIVANTE_TILED:
> + p1_w = round_up(dprc_width,
> + format->cpp[0] == 2 ? 8 : 4);
> + break;
> + case DRM_FORMAT_MOD_VIVANTE_SUPER_TILED:
> + if (dprc->is_blit)
> + p1_w = round_up(dprc_width,
> + format->cpp[0] == 2 ? 8 : 4);
> + else
> + p1_w = round_up(dprc_width, 64);
> + break;
> + default:
> + p1_w = round_up(dprc_width,
> + format->cpp[0] == 2 ? 32 : 16);
> + break;
> + }
> + p1_h = round_up(dprc_height, 4);
> + }
> +
> + dpu_dprc_write(dprc, FRAME_CTRL0, PITCH(stride));
> +
> + switch (modifier) {
> + case DRM_FORMAT_MOD_VIVANTE_TILED:
> + preq = BYTE_256;
> + mt_w = bpp == 16 ? 8 : 4;
> + mt_h = 4;
> + break;
> + case DRM_FORMAT_MOD_VIVANTE_SUPER_TILED:
> + if (bpp == 16) {
> + preq = BYTE_64;
> + mt_w = 8;
> + } else {
> + preq = BYTE_128;
> + mt_w = 4;
> + }
> + mt_h = 4;
> + break;
> + default:
> + preq = BYTE_1K;
> + break;
> + }
> + dpu_dprc_write(dprc, FRAME_1P_CTRL0, preq);
> + dpu_dprc_write(dprc, FRAME_1P_PIX_X_CTRL, NUM_X_PIX_WIDE(p1_w));
> + dpu_dprc_write(dprc, FRAME_1P_PIX_Y_CTRL, NUM_Y_PIX_HIGH(p1_h));
> + dpu_dprc_write(dprc, FRAME_1P_BASE_ADDR_CTRL0, baddr);
> + if (modifier) {
> + dpu_dprc_write(dprc, FRAME_PIX_X_ULC_CTRL,
> + CROP_ULC_X(round_down(x_offset, mt_w)));
> + dpu_dprc_write(dprc, FRAME_PIX_Y_ULC_CTRL,
> + CROP_ULC_Y(round_down(y_offset, mt_h)));
> + } else {
> + dpu_dprc_write(dprc, FRAME_PIX_X_ULC_CTRL, CROP_ULC_X(0));
> + dpu_dprc_write(dprc, FRAME_PIX_Y_ULC_CTRL, CROP_ULC_Y(0));
> + }
> +
> + dpu_dprc_write(dprc, RTRAM_CTRL0, THRES_LOW(3) | THRES_HIGH(7));
> +
> + switch (modifier) {
> + case DRM_FORMAT_MOD_NONE:
> + val = 0;
> + break;
> + case DRM_FORMAT_MOD_VIVANTE_TILED:
> + val = GPU_STANDARD_TILE;
> + break;
> + case DRM_FORMAT_MOD_VIVANTE_SUPER_TILED:
> + val = GPU_SUPER_TILE;
> + break;
> + default:
> + dev_err(dev, "unsupported modifier 0x%016llx\n", modifier);
> + return;
> + }
> + val |= format->num_planes > 1 ? LINE8 : LINE4;
> + val |= BUF2;
> + switch (format->format) {
> + case DRM_FORMAT_ARGB8888:
> + case DRM_FORMAT_XRGB8888:
> + case DRM_FORMAT_ABGR8888:
> + case DRM_FORMAT_XBGR8888:
> + case DRM_FORMAT_RGBA8888:
> + case DRM_FORMAT_RGBX8888:
> + case DRM_FORMAT_BGRA8888:
> + case DRM_FORMAT_BGRX8888:
> + /*
> + * It turns out pixel components are mapped directly
> + * without position change via DPR processing with
> + * the following color component configurations.
> + * Leave the pixel format to be handled by the
> + * display controllers.
> + */
> + val |= A_COMP_SEL(3) | R_COMP_SEL(2) |
> + G_COMP_SEL(1) | B_COMP_SEL(0);
> + val |= PIX_SIZE_32BIT;
> + break;
> + case DRM_FORMAT_YUYV:
> + case DRM_FORMAT_UYVY:
> + val |= YUV_EN;
> + fallthrough;
> + case DRM_FORMAT_RGB565:
> + val |= PIX_SIZE_16BIT;
> + break;
> + case DRM_FORMAT_NV12:
> + case DRM_FORMAT_NV21:
> + dprc->use_aux_prg = true;
> +
> + val |= COMP_2PLANE_EN;
> + val |= YUV_EN;
> + val |= PIX_SIZE_8BIT;
> + break;
> + default:
> + dev_err(dev, "unsupported format 0x%08x\n", format->format);
> + return;
> + }
> + dpu_dprc_write(dprc, MODE_CTRL0, val);
> +
> + if (dprc->is_blit) {
> + val = SW_SHADOW_LOAD_SEL | RUN_EN | SHADOW_LOAD_EN;
> + dpu_dprc_write(dprc, SYSTEM_CTRL0, val);
> + } else if (start) {
> + /* software shadow load for the first frame */
> + val = SW_SHADOW_LOAD_SEL | SHADOW_LOAD_EN;
> + dpu_dprc_write(dprc, SYSTEM_CTRL0, val);
> +
> + /* and then, run... */
> + val |= RUN_EN | REPEAT_EN;
> + dpu_dprc_write(dprc, SYSTEM_CTRL0, val);
> + }
> +
> + dpu_prg_configure(dprc->prgs[0], width, height, x_offset, y_offset,
> + prg_stride, bpp, baddr, format, modifier, start);
> + if (dprc->use_aux_prg)
> + dpu_prg_configure(dprc->prgs[1], width, height,
> + x_offset, y_offset,
> + prg_stride, 8, uv_baddr, format, modifier,
> + start);
> +
> + dpu_dprc_enable(dprc);
> +
> + dpu_dprc_reg_update(dprc);
> +
> + if (!dprc->is_blit && start)
> + dpu_dprc_enable_ctrl_done_irq(dprc);
> +
> + dev_dbg(dev, "w-%u, h-%u, s-%u, fmt-0x%08x, mod-0x%016llx\n",
> + width, height, stride, format->format, modifier);
> +}
> +
> +void dpu_dprc_disable_repeat_en(struct dpu_dprc *dprc)
> +{
> + dpu_dprc_write(dprc, SYSTEM_CTRL0 + CLR, REPEAT_EN);
> +
> + dev_dbg(dprc->dev, "disable repeat_en\n");
> +}
> +
> +static void dpu_dprc_ctrl_done_handle(struct dpu_dprc *dprc)
> +{
> + if (dprc->is_blit)
> + return;
> +
> + dpu_dprc_write(dprc, SYSTEM_CTRL0, REPEAT_EN);
> +
> + dpu_prg_shadow_enable(dprc->prgs[0]);
> + if (dprc->use_aux_prg)
> + dpu_prg_shadow_enable(dprc->prgs[1]);
> +
> + dev_dbg(dprc->dev, "ctrl done handle\n");
> +}
> +
> +static irqreturn_t dpu_dprc_wrap_irq_handler(int irq, void *data)
> +{
> + struct dpu_dprc *dprc = data;
> + struct device *dev = dprc->dev;
> + u32 mask, status;
> +
> + spin_lock(&dprc->spin_lock);
> +
> + /* cache valid irq status */
> + mask = dpu_dprc_read(dprc, IRQ_MASK);
> + mask = ~mask;
> + status = dpu_dprc_read(dprc, IRQ_MASK_STATUS);
> + status &= mask;
> +
> + /* mask the irqs being handled */
> + dpu_dprc_write(dprc, IRQ_MASK + SET, status);
> +
> + /* clear status register */
> + dpu_dprc_write(dprc, IRQ_MASK_STATUS, status);
> +
> + if (status & DPR2RTR_FIFO_LOAD_BUF_RDY_UV_ERROR)
> + dev_err(dev, "DPR to RTRAM FIFO load UV buffer ready error\n");
> +
> + if (status & DPR2RTR_FIFO_LOAD_BUF_RDY_YRGB_ERROR)
> + dev_err(dev, "DPR to RTRAM FIFO load YRGB buffer ready error\n");
> +
> + if (status & DPR2RTR_UV_FIFO_OVFL)
> + dev_err(dev, "DPR to RTRAM FIFO UV FIFO overflow\n");
> +
> + if (status & DPR2RTR_YRGB_FIFO_OVFL)
> + dev_err(dev, "DPR to RTRAM FIFO YRGB FIFO overflow\n");
> +
> + if (status & IRQ_AXI_READ_ERROR)
> + dev_err(dev, "AXI read error\n");
> +
> + if (status & IRQ_DPR_CRTL_DONE)
> + dpu_dprc_ctrl_done_handle(dprc);
> +
> + spin_unlock(&dprc->spin_lock);
> +
> + return IRQ_HANDLED;
> +}
> +
> +bool dpu_dprc_rtram_width_supported(struct dpu_dprc *dprc, unsigned int width)
> +{
> + return width <= DPU_DPRC_MAX_RTRAM_WIDTH;
> +}
> +
> +bool dpu_dprc_stride_supported(struct dpu_dprc *dprc,
> + unsigned int stride, unsigned int uv_stride,
> + unsigned int width, unsigned int x_offset,
> + const struct drm_format_info *format,
> + u64 modifier,
> + dma_addr_t baddr, dma_addr_t uv_baddr)
> +{
> + unsigned int prg_stride = width * format->cpp[0];
> + unsigned int bpp = 8 * format->cpp[0];
> +
> + if (stride > DPU_DRPC_MAX_STRIDE)
> + return false;
> +
> + if (format->num_planes > 1 && stride != uv_stride)
> + return false;
> +
> + if (!dpu_prg_stride_supported(dprc->prgs[0], x_offset, bpp,
> + modifier, prg_stride, baddr))
> + return false;
> +
> + if (format->num_planes > 1 &&
> + !dpu_prg_stride_supported(dprc->prgs[1], x_offset, bpp,
> + modifier, prg_stride, uv_baddr))
> + return false;
> +
> + return true;
> +}
> +
> +struct dpu_dprc *
> +dpu_dprc_lookup_by_of_node(struct device *dev, struct device_node *dprc_node)
> +{
> + struct dpu_dprc *dprc;
> +
> + mutex_lock(&dpu_dprc_list_mutex);
> + list_for_each_entry(dprc, &dpu_dprc_list, list) {
> + if (dprc_node == dprc->dev->of_node) {
> + mutex_unlock(&dpu_dprc_list_mutex);
> + device_link_add(dev, dprc->dev,
> + DL_FLAG_PM_RUNTIME |
> + DL_FLAG_AUTOREMOVE_CONSUMER);
> + return dprc;
> + }
> + }
> + mutex_unlock(&dpu_dprc_list_mutex);
> +
> + return NULL;
> +}
> +
> +static const struct of_device_id dpu_dprc_dt_ids[] = {
> + { .compatible = "fsl,imx8qm-dpr-channel", },
> + { .compatible = "fsl,imx8qxp-dpr-channel", },
> + { /* sentinel */ },
> +};
> +
> +static int dpu_dprc_probe(struct platform_device *pdev)
> +{
> + struct device *dev = &pdev->dev;
> + struct device_node *np = dev->of_node;
> + struct resource *res;
> + struct dpu_dprc *dprc;
> + int ret, wrap_irq, i;
> +
> + dprc = devm_kzalloc(dev, sizeof(*dprc), GFP_KERNEL);
> + if (!dprc)
> + return -ENOMEM;
> +
> + ret = imx_scu_get_handle(&dprc->ipc_handle);
> + if (ret) {
> + dev_err_probe(dev, ret, "failed to get SCU ipc handle\n");
> + return ret;
> + }
> +
> + res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
> + dprc->base = devm_ioremap_resource(dev, res);
> + if (IS_ERR(dprc->base))
> + return PTR_ERR(dprc->base);
> +
> + wrap_irq = platform_get_irq_byname(pdev, "dpr_wrap");
> + if (wrap_irq < 0)
> + return -ENODEV;
> +
> + dprc->clk_apb = devm_clk_get(dev, "apb");
> + if (IS_ERR(dprc->clk_apb)) {
> + ret = PTR_ERR(dprc->clk_apb);
> + dev_err_probe(dev, ret, "failed to get apb clock\n");
> + return ret;
> + }
> +
> + dprc->clk_b = devm_clk_get(dev, "b");
> + if (IS_ERR(dprc->clk_b)) {
> + ret = PTR_ERR(dprc->clk_b);
> + dev_err_probe(dev, ret, "failed to get b clock\n");
> + return ret;
> + }
> +
> + dprc->clk_rtram = devm_clk_get(dev, "rtram");
> + if (IS_ERR(dprc->clk_rtram)) {
> + ret = PTR_ERR(dprc->clk_rtram);
> + dev_err_probe(dev, ret, "failed to get rtram clock\n");
> + return ret;
> + }
> +
> + ret = of_property_read_u32(np, "fsl,sc-resource", &dprc->sc_resource);
> + if (ret) {
> + dev_err(dev, "cannot get SC resource %d\n", ret);
> + return ret;
> + }
> +
> + switch (dprc->sc_resource) {
> + case IMX_SC_R_DC_0_BLIT1:
> + case IMX_SC_R_DC_1_BLIT1:
> + dprc->has_aux_prg = true;
> + fallthrough;
> + case IMX_SC_R_DC_0_BLIT0:
> + case IMX_SC_R_DC_1_BLIT0:
> + dprc->is_blit = true;
> + fallthrough;
> + case IMX_SC_R_DC_0_FRAC0:
> + case IMX_SC_R_DC_1_FRAC0:
> + break;
> + case IMX_SC_R_DC_0_VIDEO0:
> + case IMX_SC_R_DC_0_VIDEO1:
> + case IMX_SC_R_DC_1_VIDEO0:
> + case IMX_SC_R_DC_1_VIDEO1:
> + case IMX_SC_R_DC_0_WARP:
> + case IMX_SC_R_DC_1_WARP:
> + dprc->has_aux_prg = true;
> + break;
> + default:
> + dev_err(dev, "wrong SC resource %u\n", dprc->sc_resource);
> + return -EINVAL;
> + }
> +
> + for (i = 0; i < 2; i++) {
> + if (i == 1 && !dprc->has_aux_prg)
> + break;
> +
> + dprc->prgs[i] = dpu_prg_lookup_by_phandle(dev, "fsl,prgs", i);
> + if (!dprc->prgs[i])
> + return -EPROBE_DEFER;
> +
> + if (i == 1)
> + dpu_prg_set_auxiliary(dprc->prgs[i]);
> + }
> +
> + dprc->dev = dev;
> + spin_lock_init(&dprc->spin_lock);
> +
> + ret = devm_request_irq(dev, wrap_irq, dpu_dprc_wrap_irq_handler,
> + IRQF_SHARED, dev_name(dev), dprc);
> + if (ret < 0) {
> + dev_err(dev, "failed to request dpr_wrap irq(%u): %d\n",
> + wrap_irq, ret);
> + return ret;
> + }
> +
> + platform_set_drvdata(pdev, dprc);
> +
> + pm_runtime_enable(dev);
> +
> + mutex_lock(&dpu_dprc_list_mutex);
> + list_add(&dprc->list, &dpu_dprc_list);
> + mutex_unlock(&dpu_dprc_list_mutex);
> +
> + return 0;
> +}
> +
> +static int dpu_dprc_remove(struct platform_device *pdev)
> +{
> + struct dpu_dprc *dprc = platform_get_drvdata(pdev);
> +
> + mutex_lock(&dpu_dprc_list_mutex);
> + list_del(&dprc->list);
> + mutex_unlock(&dpu_dprc_list_mutex);
> +
> + pm_runtime_disable(&pdev->dev);
> +
> + return 0;
> +}
> +
> +static int __maybe_unused dpu_dprc_runtime_suspend(struct device *dev)
> +{
> + struct platform_device *pdev = to_platform_device(dev);
> + struct dpu_dprc *dprc = platform_get_drvdata(pdev);
> +
> + clk_disable_unprepare(dprc->clk_rtram);
> + clk_disable_unprepare(dprc->clk_b);
> + clk_disable_unprepare(dprc->clk_apb);
> +
> + return 0;
> +}
> +
> +static int __maybe_unused dpu_dprc_runtime_resume(struct device *dev)
> +{
> + struct platform_device *pdev = to_platform_device(dev);
> + struct dpu_dprc *dprc = platform_get_drvdata(pdev);
> + int ret;
> +
> + ret = clk_prepare_enable(dprc->clk_apb);
> + if (ret) {
> + dev_err(dev, "failed to enable apb clock: %d\n", ret);
> + return ret;
> + }
> +
> + ret = clk_prepare_enable(dprc->clk_b);
> + if (ret) {
> + dev_err(dev, "failed to enable b clock: %d\n", ret);
> + return ret;
> + }
> +
> + ret = clk_prepare_enable(dprc->clk_rtram);
> + if (ret) {
> + dev_err(dev, "failed to enable rtram clock: %d\n", ret);
> + return ret;
> + }
> +
> + dpu_dprc_reset(dprc);
> +
> + /* disable all control irqs and enable all error irqs */
> + spin_lock(&dprc->spin_lock);
> + dpu_dprc_write(dprc, IRQ_MASK, IRQ_CTRL_MASK);
> + spin_unlock(&dprc->spin_lock);
> +
> + return ret;
> +}
> +
> +static const struct dev_pm_ops dpu_dprc_pm_ops = {
> + SET_RUNTIME_PM_OPS(dpu_dprc_runtime_suspend,
> + dpu_dprc_runtime_resume, NULL)
> +};
> +
> +struct platform_driver dpu_dprc_driver = {
> + .probe = dpu_dprc_probe,
> + .remove = dpu_dprc_remove,
> + .driver = {
> + .pm = &dpu_dprc_pm_ops,
> + .name = "dpu-dpr-channel",
> + .of_match_table = dpu_dprc_dt_ids,
> + },
> +};
> diff --git a/drivers/gpu/drm/imx/dpu/dpu-dprc.h b/drivers/gpu/drm/imx/dpu/dpu-dprc.h
> new file mode 100644
> index 00000000..96a5978
> --- /dev/null
> +++ b/drivers/gpu/drm/imx/dpu/dpu-dprc.h
> @@ -0,0 +1,40 @@
> +/* SPDX-License-Identifier: GPL-2.0+ */
> +
> +/*
> + * Copyright 2017-2020 NXP
> + */
> +
> +#ifndef _DPU_DPRC_H_
> +#define _DPU_DPRC_H_
> +
> +#include <linux/device.h>
> +#include <linux/of.h>
> +#include <linux/types.h>
> +
> +#include <drm/drm_fourcc.h>
> +
> +struct dpu_dprc;
> +
> +void dpu_dprc_configure(struct dpu_dprc *dprc, unsigned int stream_id,
> + unsigned int width, unsigned int height,
> + unsigned int x_offset, unsigned int y_offset,
> + unsigned int stride,
> + const struct drm_format_info *format, u64 modifier,
> + dma_addr_t baddr, dma_addr_t uv_baddr,
> + bool start, bool interlace_frame);
> +
> +void dpu_dprc_disable_repeat_en(struct dpu_dprc *dprc);
> +
> +bool dpu_dprc_rtram_width_supported(struct dpu_dprc *dprc, unsigned int width);
> +
> +bool dpu_dprc_stride_supported(struct dpu_dprc *dprc,
> + unsigned int stride, unsigned int uv_stride,
> + unsigned int width, unsigned int x_offset,
> + const struct drm_format_info *format,
> + u64 modifier,
> + dma_addr_t baddr, dma_addr_t uv_baddr);
> +
> +struct dpu_dprc *
> +dpu_dprc_lookup_by_of_node(struct device *dev, struct device_node *dprc_node);
> +
> +#endif
> diff --git a/drivers/gpu/drm/imx/dpu/dpu-drv.c b/drivers/gpu/drm/imx/dpu/dpu-drv.c
> new file mode 100644
> index 00000000..a35ac19
> --- /dev/null
> +++ b/drivers/gpu/drm/imx/dpu/dpu-drv.c
> @@ -0,0 +1,292 @@
> +// SPDX-License-Identifier: GPL-2.0+
> +
> +/*
> + * Copyright 2019,2020 NXP
> + */
> +
> +#include <linux/component.h>
> +#include <linux/dma-mapping.h>
> +#include <linux/kernel.h>
> +#include <linux/module.h>
> +#include <linux/of.h>
> +#include <linux/platform_device.h>
> +
> +#include <drm/drm_atomic_helper.h>
> +#include <drm/drm_drv.h>
> +#include <drm/drm_fb_helper.h>
> +#include <drm/drm_gem_cma_helper.h>
> +#include <drm/drm_modeset_helper.h>
> +#include <drm/drm_of.h>
> +#include <drm/drm_print.h>
> +#include <drm/drm_probe_helper.h>
> +
> +#include "dpu-drv.h"
> +#include "dpu-kms.h"
> +
> +#define DRIVER_NAME "imx-dpu-drm"
> +
> +static int legacyfb_depth = 32;
> +module_param(legacyfb_depth, uint, 0444);
> +
> +struct dpu_drm_drv_data {
> + struct list_head crtc_np_list;
> +};
> +
> +DEFINE_DRM_GEM_CMA_FOPS(dpu_drm_driver_fops);
> +
> +static struct drm_driver dpu_drm_driver = {
> + .driver_features = DRIVER_MODESET | DRIVER_GEM |
> + DRIVER_ATOMIC,
> + DRM_GEM_CMA_DRIVER_OPS,
> + .fops = &dpu_drm_driver_fops,
> + .name = "imx-dpu",
> + .desc = "i.MX DPU DRM graphics",
> + .date = "20200805",
> + .major = 1,
> + .minor = 0,
> + .patchlevel = 0,
> +};
> +
> +static int dpu_drm_bind(struct device *dev)
> +{
> + struct dpu_drm_device *dpu_drm;
> + struct drm_device *drm;
> + struct dpu_drm_drv_data *drv_data = dev_get_drvdata(dev);
> + int ret;
> +
> + dpu_drm = devm_drm_dev_alloc(dev, &dpu_drm_driver,
> + struct dpu_drm_device, base);
> + if (IS_ERR(dpu_drm)) {
> + ret = PTR_ERR(dpu_drm);
> + DRM_DEV_ERROR(dev, "failed to alloc drm device: %d\n", ret);
> + return ret;
> + }
> +
> + drm = &dpu_drm->base;
> +
> + drm->irq_enabled = true;
> +
> + ret = dpu_kms_prepare(dpu_drm, &drv_data->crtc_np_list);
> + if (ret) {
> + if (ret != -EPROBE_DEFER)
> + DRM_DEV_ERROR(dev, "failed to prepare kms: %d\n", ret);
> + return ret;
> + }
> +
> + ret = component_bind_all(dev, dpu_drm);
> + if (ret) {
> + if (ret != -EPROBE_DEFER)
> + DRM_DEV_ERROR(dev,
> + "failed to bind all components: %d\n",
> + ret);
> + return ret;
> + }
> +
> + drm_mode_config_reset(drm);
> +
> + drm_kms_helper_poll_init(drm);
> +
> + ret = drm_dev_register(drm, 0);
> + if (ret) {
> + DRM_DEV_ERROR(dev, "failed to register drm device: %d\n", ret);
> + goto out_register;
> + }
> +
> + if (legacyfb_depth != 16 && legacyfb_depth != 32) {
> + DRM_DEV_INFO(dev,
> + "Invalid legacyfb_depth. Defaulting to 32bpp\n");
> + legacyfb_depth = 32;
> + }
> +
> + drm_fbdev_generic_setup(drm, legacyfb_depth);
> +
> + return ret;
> +
> +out_register:
> + drm_kms_helper_poll_fini(drm);
> + component_unbind_all(dev, NULL);
> +
> + return ret;
> +}
> +
> +static void dpu_drm_unbind(struct device *dev)
> +{
> + struct drm_device *drm = dev_get_drvdata(dev);
> +
> + drm_dev_unregister(drm);
> +
> + drm_kms_helper_poll_fini(drm);
> +
> + drm_atomic_helper_shutdown(drm);
> +
> + component_unbind_all(drm->dev, NULL);
> +}
> +
> +static const struct component_master_ops dpu_drm_ops = {
> + .bind = dpu_drm_bind,
> + .unbind = dpu_drm_unbind,
> +};
> +
> +static int compare_of(struct device *dev, void *data)
> +{
> + struct device_node *np = data;
> +
> + return dev->of_node == np;
> +}
> +
> +static int dpu_drm_probe(struct platform_device *pdev)
> +{
> + struct device *dev = &pdev->dev;
> + struct component_match *match = NULL;
> + struct device_node *np, *ports, *port;
> + struct dpu_drm_drv_data *drv_data;
> + struct dpu_crtc_of_node *crtc_of_node;
> +
> + drv_data = devm_kzalloc(dev, sizeof(*drv_data), GFP_KERNEL);
> + if (!drv_data) {
> + DRM_DEV_ERROR(dev, "failed to alloc driver data\n");
> + return -ENOMEM;
> + }
> +
> + INIT_LIST_HEAD(&drv_data->crtc_np_list);
> +
> + for_each_matching_node(np, dpu_dt_ids) {
> + if (!of_device_is_available(np))
> + continue;
> +
> + ports = of_get_child_by_name(np, "ports");
> + if (!ports)
> + ports = np;
> +
> + for_each_child_of_node(ports, port) {
> + drm_of_component_match_add(dev, &match, compare_of,
> + port);
> +
> + crtc_of_node = devm_kzalloc(dev, sizeof(*crtc_of_node),
> + GFP_KERNEL);
> + if (!crtc_of_node) {
> + DRM_DEV_ERROR(dev,
> + "failed to alloc crtc_of_node\n");
> + of_node_put(ports);
> + return -ENOMEM;
> + }
> +
> + crtc_of_node->np = port;
> +
> + list_add(&crtc_of_node->list, &drv_data->crtc_np_list);
> + }
> +
> + of_node_put(ports);
> + }
> +
> + if (!match) {
> + DRM_DEV_ERROR(dev, "no available DPU display output port\n");
> + return -ENODEV;
> + }
> +
> + dev_set_drvdata(dev, drv_data);
> +
> + return component_master_add_with_match(dev, &dpu_drm_ops, match);
> +}
> +
> +static int dpu_drm_remove(struct platform_device *pdev)
> +{
> + component_master_del(&pdev->dev, &dpu_drm_ops);
> +
> + return 0;
> +}
> +
> +static int __maybe_unused dpu_drm_suspend(struct device *dev)
> +{
> + struct drm_device *drm_dev = dev_get_drvdata(dev);
> +
> + return drm_mode_config_helper_suspend(drm_dev);
> +}
> +
> +static int __maybe_unused dpu_drm_resume(struct device *dev)
> +{
> + struct drm_device *drm_dev = dev_get_drvdata(dev);
> +
> + return drm_mode_config_helper_resume(drm_dev);
> +}
> +
> +static SIMPLE_DEV_PM_OPS(dpu_drm_pm_ops, dpu_drm_suspend, dpu_drm_resume);
> +
> +static struct platform_driver dpu_drm_platform_driver = {
> + .probe = dpu_drm_probe,
> + .remove = dpu_drm_remove,
> + .driver = {
> + .name = DRIVER_NAME,
> + .pm = &dpu_drm_pm_ops,
> + },
> +};
> +
> +static struct platform_device *dpu_drm_platform_dev;
> +
> +static struct platform_driver * const drivers[] = {
> + &dpu_prg_driver,
> + &dpu_dprc_driver,
> + &dpu_core_driver,
> + &dpu_crtc_driver,
> + &dpu_drm_platform_driver,
> +};
> +
> +static int __init dpu_init(void)
> +{
> + struct platform_device *pdev;
> + struct device_node *np;
> + int ret;
> +
> + ret = platform_register_drivers(drivers, ARRAY_SIZE(drivers));
> + if (ret)
> + return ret;
> +
> + /*
> + * If the DT contains at least one available DPU device, instantiate
> + * the DRM platform device.
> + */
> + for_each_matching_node(np, dpu_dt_ids) {
> + if (!of_device_is_available(np))
> + continue;
> +
> + pdev = platform_device_alloc(DRIVER_NAME, -1);
> + if (!pdev) {
> + ret = -ENOMEM;
> + goto unregister_drivers;
> + }
> +
> + ret = dma_set_coherent_mask(&pdev->dev, DMA_BIT_MASK(32));
> + if (ret)
> + goto unregister_drivers;
> +
> + ret = platform_device_add(pdev);
> + if (ret) {
> + platform_device_put(pdev);
> + goto unregister_drivers;
> + }
> +
> + dpu_drm_platform_dev = pdev;
> + of_node_put(np);
> + break;
> + }
> +
> + return ret;
> +
> +unregister_drivers:
> + of_node_put(np);
> + platform_unregister_drivers(drivers, ARRAY_SIZE(drivers));
> + return ret;
> +}
> +module_init(dpu_init);
> +
> +static void __exit dpu_exit(void)
> +{
> + platform_device_unregister(dpu_drm_platform_dev);
> + platform_unregister_drivers(drivers, ARRAY_SIZE(drivers));
> +}
> +module_exit(dpu_exit);
> +
> +MODULE_DESCRIPTION("i.MX DPU DRM Driver");
> +MODULE_AUTHOR("Liu Ying <victor.liu at nxp.com>");
> +MODULE_ALIAS("platform:" DRIVER_NAME);
> +MODULE_LICENSE("GPL v2");
> diff --git a/drivers/gpu/drm/imx/dpu/dpu-drv.h b/drivers/gpu/drm/imx/dpu/dpu-drv.h
> new file mode 100644
> index 00000000..df56bfc
> --- /dev/null
> +++ b/drivers/gpu/drm/imx/dpu/dpu-drv.h
> @@ -0,0 +1,28 @@
> +/* SPDX-License-Identifier: GPL-2.0+ */
> +
> +/*
> + * Copyright 2020 NXP
> + */
> +
> +#ifndef __DPU_DRV_H__
> +#define __DPU_DRV_H__
> +
> +#include <linux/mod_devicetable.h>
> +#include <linux/platform_device.h>
> +#include <linux/types.h>
> +
> +#include <drm/drm_device.h>
> +
> +struct dpu_drm_device {
> + struct drm_device base;
> + struct list_head crtc_list;
> +};
> +
> +extern const struct of_device_id dpu_dt_ids[];
> +
> +extern struct platform_driver dpu_prg_driver;
> +extern struct platform_driver dpu_dprc_driver;
> +extern struct platform_driver dpu_core_driver;
> +extern struct platform_driver dpu_crtc_driver;
> +
> +#endif /* __DPU_DRV_H__ */
> diff --git a/drivers/gpu/drm/imx/dpu/dpu-extdst.c b/drivers/gpu/drm/imx/dpu/dpu-extdst.c
> new file mode 100644
> index 00000000..b292087
> --- /dev/null
> +++ b/drivers/gpu/drm/imx/dpu/dpu-extdst.c
> @@ -0,0 +1,299 @@
> +// SPDX-License-Identifier: GPL-2.0+
> +
> +/*
> + * Copyright (C) 2016 Freescale Semiconductor, Inc.
> + * Copyright 2017-2020 NXP
> + */
> +
> +#include <linux/io.h>
> +#include <linux/kernel.h>
> +#include <linux/mutex.h>
> +#include <linux/sizes.h>
> +
> +#include "dpu.h"
> +#include "dpu-prv.h"
> +
> +#define PIXENGCFG_STATIC 0x8
> +#define POWERDOWN BIT(4)
> +#define SYNC_MODE BIT(8)
> +#define AUTO BIT(8)
> +#define SINGLE 0
> +#define DIV_MASK 0xff0000
> +#define DIV(n) (((n) & 0xff) << 16)
> +#define DIV_RESET 0x80
> +
> +#define PIXENGCFG_DYNAMIC 0xc
> +
> +#define PIXENGCFG_REQUEST 0x10
> +
> +#define PIXENGCFG_TRIGGER 0x14
> +#define SYNC_TRIGGER BIT(0)
> +
> +#define STATICCONTROL 0x8
> +#define KICK_MODE BIT(8)
> +#define EXTERNAL BIT(8)
> +#define SOFTWARE 0
> +#define PERFCOUNTMODE BIT(12)
> +
> +#define CONTROL 0xc
> +#define GAMMAAPPLYENABLE BIT(0)
> +
> +#define SOFTWAREKICK 0x10
> +#define KICK BIT(0)
> +
> +#define STATUS 0x14
> +#define CNT_ERR_STS BIT(0)
> +
> +#define CONTROLWORD 0x18
> +#define CURPIXELCNT 0x1c
> +#define LASTPIXELCNT 0x20
> +#define PERFCOUNTER 0x24
> +
> +struct dpu_extdst {
> + void __iomem *pec_base;
> + void __iomem *base;
> + struct mutex mutex;
> + unsigned int id;
> + unsigned int index;
> + bool inuse;
> + struct dpu_soc *dpu;
> +};
> +
> +static const enum dpu_link_id src_sels[] = {
> + LINK_ID_NONE,
> + LINK_ID_BLITBLEND9,
> + LINK_ID_CONSTFRAME0,
> + LINK_ID_CONSTFRAME1,
> + LINK_ID_CONSTFRAME4,
> + LINK_ID_CONSTFRAME5,
> + LINK_ID_MATRIX4,
> + LINK_ID_HSCALER4,
> + LINK_ID_VSCALER4,
> + LINK_ID_MATRIX5,
> + LINK_ID_HSCALER5,
> + LINK_ID_VSCALER5,
> + LINK_ID_LAYERBLEND3,
> + LINK_ID_LAYERBLEND2,
> + LINK_ID_LAYERBLEND1,
> + LINK_ID_LAYERBLEND0,
> +};
> +
> +static inline u32 dpu_pec_ed_read(struct dpu_extdst *ed, unsigned int offset)
> +{
> + return readl(ed->pec_base + offset);
> +}
> +
> +static inline void dpu_pec_ed_write(struct dpu_extdst *ed,
> + unsigned int offset, u32 value)
> +{
> + writel(value, ed->pec_base + offset);
> +}
> +
> +static inline void dpu_pec_ed_write_mask(struct dpu_extdst *ed,
> + unsigned int offset,
> + u32 mask, u32 value)
> +{
> + u32 tmp;
> +
> + tmp = dpu_pec_ed_read(ed, offset);
> + tmp &= ~mask;
> + dpu_pec_ed_write(ed, offset, tmp | value);
> +}
> +
> +static inline u32 dpu_ed_read(struct dpu_extdst *ed, unsigned int offset)
> +{
> + return readl(ed->base + offset);
> +}
> +
> +static inline void dpu_ed_write(struct dpu_extdst *ed,
> + unsigned int offset, u32 value)
> +{
> + writel(value, ed->base + offset);
> +}
> +
> +static inline void dpu_ed_write_mask(struct dpu_extdst *ed, unsigned int offset,
> + u32 mask, u32 value)
> +{
> + u32 tmp;
> +
> + tmp = dpu_ed_read(ed, offset);
> + tmp &= ~mask;
> + dpu_ed_write(ed, offset, tmp | value);
> +}
> +
> +static inline bool dpu_ed_is_safety_stream(struct dpu_extdst *ed)
> +{
> + if ((ed->id == DPU_SAFETY_STREAM_OFFSET) ||
> + (ed->id == DPU_SAFETY_STREAM_OFFSET + 1))
> + return true;
> +
> + return false;
> +}
> +
> +static void dpu_ed_pec_enable_shden(struct dpu_extdst *ed)
> +{
> + dpu_pec_ed_write_mask(ed, PIXENGCFG_STATIC, SHDEN, SHDEN);
> +}
> +
> +void dpu_ed_pec_poweron(struct dpu_extdst *ed)
> +{
> + dpu_pec_ed_write_mask(ed, PIXENGCFG_STATIC, POWERDOWN, 0);
> +}
> +
> +static void dpu_ed_pec_sync_mode_single(struct dpu_extdst *ed)
> +{
> + dpu_pec_ed_write_mask(ed, PIXENGCFG_STATIC, SYNC_MODE, SINGLE);
> +}
> +
> +static void dpu_ed_pec_div_reset(struct dpu_extdst *ed)
> +{
> + dpu_pec_ed_write_mask(ed, PIXENGCFG_STATIC, DIV_MASK, DIV(DIV_RESET));
> +}
> +
> +void dpu_ed_pec_src_sel(struct dpu_extdst *ed, enum dpu_link_id src)
> +{
> + struct dpu_soc *dpu = ed->dpu;
> + int i;
> +
> + for (i = 0; i < ARRAY_SIZE(src_sels); i++) {
> + if (src_sels[i] == src) {
> + dpu_pec_ed_write(ed, PIXENGCFG_DYNAMIC, src);
> + return;
> + }
> + }
> +
> + dev_err(dpu->dev, "invalid source(0x%02x) for ExtDst%u\n", src, ed->id);
> +}
> +
> +void dpu_ed_pec_sync_trigger(struct dpu_extdst *ed)
> +{
> + dpu_pec_ed_write(ed, PIXENGCFG_TRIGGER, SYNC_TRIGGER);
> +}
> +
> +static void dpu_ed_enable_shden(struct dpu_extdst *ed)
> +{
> + dpu_ed_write_mask(ed, STATICCONTROL, SHDEN, SHDEN);
> +}
> +
> +static void dpu_ed_kick_mode_external(struct dpu_extdst *ed)
> +{
> + dpu_ed_write_mask(ed, STATICCONTROL, KICK_MODE, EXTERNAL);
> +}
> +
> +static void dpu_ed_disable_perfcountmode(struct dpu_extdst *ed)
> +{
> + dpu_ed_write_mask(ed, STATICCONTROL, PERFCOUNTMODE, 0);
> +}
> +
> +static void dpu_ed_disable_gamma_apply(struct dpu_extdst *ed)
> +{
> + dpu_ed_write_mask(ed, CONTROL, GAMMAAPPLYENABLE, 0);
> +}
> +
> +static struct dpu_extdst *dpu_ed_get(struct dpu_soc *dpu, unsigned int id)
> +{
> + struct dpu_extdst *ed;
> + int i;
> +
> + for (i = 0; i < ARRAY_SIZE(dpu->ed_priv); i++) {
> + ed = dpu->ed_priv[i];
> + if (ed->id == id)
> + break;
> + }
> +
> + if (i == ARRAY_SIZE(dpu->ed_priv))
> + return ERR_PTR(-EINVAL);
> +
> + mutex_lock(&ed->mutex);
> +
> + if (ed->inuse) {
> + mutex_unlock(&ed->mutex);
> + return ERR_PTR(-EBUSY);
> + }
> +
> + ed->inuse = true;
> +
> + mutex_unlock(&ed->mutex);
> +
> + return ed;
> +}
> +
> +static void dpu_ed_put(struct dpu_extdst *ed)
> +{
> + if (IS_ERR_OR_NULL(ed))
> + return;
> +
> + mutex_lock(&ed->mutex);
> +
> + ed->inuse = false;
> +
> + mutex_unlock(&ed->mutex);
> +}
> +
> +/* ExtDst for safety stream */
> +struct dpu_extdst *dpu_ed_safe_get(struct dpu_soc *dpu,
> + unsigned int stream_id)
> +{
> + return dpu_ed_get(dpu, stream_id + DPU_SAFETY_STREAM_OFFSET);
> +}
> +
> +void dpu_ed_safe_put(struct dpu_extdst *ed)
> +{
> + return dpu_ed_put(ed);
> +}
> +
> +/* ExtDst for content stream */
> +struct dpu_extdst *dpu_ed_cont_get(struct dpu_soc *dpu,
> + unsigned int stream_id)
> +{
> + return dpu_ed_get(dpu, stream_id);
> +}
> +
> +void dpu_ed_cont_put(struct dpu_extdst *ed)
> +{
> + return dpu_ed_put(ed);
> +}
> +
> +void dpu_ed_hw_init(struct dpu_soc *dpu, unsigned int index)
> +{
> + struct dpu_extdst *ed = dpu->ed_priv[index];
> +
> + dpu_ed_pec_src_sel(ed, LINK_ID_NONE);
> + dpu_ed_pec_enable_shden(ed);
> + dpu_ed_pec_poweron(ed);
> + dpu_ed_pec_sync_mode_single(ed);
> + dpu_ed_pec_div_reset(ed);
> + dpu_ed_enable_shden(ed);
> + dpu_ed_disable_perfcountmode(ed);
> + dpu_ed_kick_mode_external(ed);
> + dpu_ed_disable_gamma_apply(ed);
> +}
> +
> +int dpu_ed_init(struct dpu_soc *dpu, unsigned int index,
> + unsigned int id, enum dpu_unit_type type,
> + unsigned long pec_base, unsigned long base)
> +{
> + struct dpu_extdst *ed;
> +
> + ed = devm_kzalloc(dpu->dev, sizeof(*ed), GFP_KERNEL);
> + if (!ed)
> + return -ENOMEM;
> +
> + dpu->ed_priv[index] = ed;
> +
> + ed->pec_base = devm_ioremap(dpu->dev, pec_base, SZ_32);
> + if (!ed->pec_base)
> + return -ENOMEM;
> +
> + ed->base = devm_ioremap(dpu->dev, base, SZ_128);
> + if (!ed->base)
> + return -ENOMEM;
> +
> + ed->dpu = dpu;
> + ed->id = id;
> + ed->index = index;
> +
> + mutex_init(&ed->mutex);
> +
> + return 0;
> +}
> diff --git a/drivers/gpu/drm/imx/dpu/dpu-fetchdecode.c b/drivers/gpu/drm/imx/dpu/dpu-fetchdecode.c
> new file mode 100644
> index 00000000..7ee118f
> --- /dev/null
> +++ b/drivers/gpu/drm/imx/dpu/dpu-fetchdecode.c
> @@ -0,0 +1,294 @@
> +// SPDX-License-Identifier: GPL-2.0+
> +
> +/*
> + * Copyright (C) 2016 Freescale Semiconductor, Inc.
> + * Copyright 2017-2020 NXP
> + */
> +
> +#include <linux/kernel.h>
> +#include <linux/mutex.h>
> +#include <linux/sizes.h>
> +
> +#include "dpu.h"
> +#include "dpu-fetchunit.h"
> +#include "dpu-prv.h"
> +
> +#define RINGBUFSTARTADDR0 0x10
> +#define RINGBUFWRAPADDR0 0x14
> +#define FRAMEPROPERTIES0 0x18
> +#define FRAMEDIMENSIONS 0x44
> +#define FRAMERESAMPLING 0x48
> +#define DECODECONTROL 0x4c
> +#define SOURCEBUFFERLENGTH 0x50
> +#define CONTROL 0x54
> +#define CONTROLTRIGGER 0x58
> +#define START 0x5c
> +#define FETCHTYPE 0x60
> +#define DECODERSTATUS 0x64
> +#define READADDRESS0 0x68
> +#define BURSTBUFFERPROPERTIES 0x6c
> +#define STATUS 0x70
> +#define HIDDENSTATUS 0x74
> +
> +#define DPU_FETCHDECODE_DISP_SCALER_OFFSET 4
> +#define DPU_FETCHDECODE_REG_OFFSET 0xc
> +
> +#define DPU_FETCHDECODE_CAP_MASK (DPU_FETCHUNIT_CAP_USE_FETCHECO | \
> + DPU_FETCHUNIT_CAP_USE_SCALER | \
> + DPU_FETCHUNIT_CAP_PACKED_YUV422)
> +
> +static const enum dpu_link_id dpu_fd_link_id[] = {
> + LINK_ID_FETCHDECODE0, LINK_ID_FETCHDECODE1, LINK_ID_FETCHDECODE9
> +};
> +
> +static const enum dpu_link_id fd_srcs[3][4] = {
> + {
> + LINK_ID_NONE,
> + LINK_ID_FETCHECO0,
> + LINK_ID_FETCHDECODE1,
> + LINK_ID_FETCHWARP2,
> + }, {
> + LINK_ID_NONE,
> + LINK_ID_FETCHECO1,
> + LINK_ID_FETCHDECODE0,
> + LINK_ID_FETCHWARP2,
> + }, {
> + LINK_ID_NONE,
> + LINK_ID_FETCHECO9,
> + LINK_ID_FETCHWARP9,
> + },
> +};
> +
> +static void dpu_fd_pec_dynamic_src_sel(struct dpu_fetchunit *fu,
> + enum dpu_link_id src)
> +{
> + struct dpu_soc *dpu = fu->dpu;
> + int i;
> +
> + for (i = 0; i < ARRAY_SIZE(fd_srcs[fu->index]); i++) {
> + if (fd_srcs[fu->index][i] == src) {
> + dpu_pec_fu_write(fu, PIXENGCFG_DYNAMIC, src);
> + return;
> + }
> + }
> +
> + dev_err(dpu->dev, "%s - invalid source 0x%02x\n", fu->name, src);
> +}
> +
> +static void
> +dpu_fd_set_src_buf_dimensions(struct dpu_fetchunit *fu,
> + unsigned int w, unsigned int h,
> + const struct drm_format_info *unused,
> + bool deinterlace)
> +{
> + if (deinterlace)
> + h /= 2;
> +
> + dpu_fu_write(fu, SOURCEBUFFERDIMENSION(fu),
> + LINEWIDTH(w) | LINECOUNT(h));
> +}
> +
> +static void dpu_fd_set_fmt(struct dpu_fetchunit *fu,
> + const struct drm_format_info *format,
> + enum drm_color_encoding color_encoding,
> + enum drm_color_range color_range,
> + bool deinterlace)
> +{
> + u32 val, bits = 0, shifts = 0;
> + bool is_planar_yuv = false, is_rastermode_yuv422 = false;
> + bool is_yuv422upsamplingmode_interpolate = false;
> + bool is_inputselect_compact = false;
> + unsigned int bpp;
> +
> + switch (format->format) {
> + case DRM_FORMAT_YUYV:
> + case DRM_FORMAT_UYVY:
> + is_rastermode_yuv422 = true;
> + is_yuv422upsamplingmode_interpolate = true;
> + bpp = 16;
> + break;
> + case DRM_FORMAT_NV12:
> + case DRM_FORMAT_NV21:
> + if (deinterlace)
> + is_yuv422upsamplingmode_interpolate = true;
> + is_planar_yuv = true;
> + is_rastermode_yuv422 = true;
> + is_inputselect_compact = true;
> + bpp = format->cpp[0] * 8;
> + break;
> + default:
> + bpp = format->cpp[0] * 8;
> + break;
> + }
> +
> + dpu_fu_set_src_bpp(fu, bpp);
> +
> + val = dpu_fu_read(fu, CONTROL);
> + val &= ~YUV422UPSAMPLINGMODE_MASK;
> + val &= ~INPUTSELECT_MASK;
> + val &= ~RASTERMODE_MASK;
> + if (is_yuv422upsamplingmode_interpolate)
> + val |= YUV422UPSAMPLINGMODE(YUV422UPSAMPLINGMODE_INTERPOLATE);
> + else
> + val |= YUV422UPSAMPLINGMODE(YUV422UPSAMPLINGMODE_REPLICATE);
> + if (is_inputselect_compact)
> + val |= INPUTSELECT(INPUTSELECT_COMPPACK);
> + else
> + val |= INPUTSELECT(INPUTSELECT_INACTIVE);
> + if (is_rastermode_yuv422)
> + val |= RASTERMODE(RASTERMODE_YUV422);
> + else
> + val |= RASTERMODE(RASTERMODE_NORMAL);
> + dpu_fu_write(fu, CONTROL, val);
> +
> + val = dpu_fu_read(fu, LAYERPROPERTY(fu));
> + val &= ~YUVCONVERSIONMODE_MASK;
> + if (format->is_yuv) {
> + if (color_encoding == DRM_COLOR_YCBCR_BT709)
> + val |= YUVCONVERSIONMODE(YUVCONVERSIONMODE_ITU709);
> + else if (color_encoding == DRM_COLOR_YCBCR_BT601 &&
> + color_range == DRM_COLOR_YCBCR_FULL_RANGE)
> + val |= YUVCONVERSIONMODE(YUVCONVERSIONMODE_ITU601_FR);
> + else
> + val |= YUVCONVERSIONMODE(YUVCONVERSIONMODE_ITU601);
> + } else {
> + val |= YUVCONVERSIONMODE(YUVCONVERSIONMODE_OFF);
> + }
> + dpu_fu_write(fu, LAYERPROPERTY(fu), val);
> +
> + dpu_fu_get_pixel_format_bits(fu, format->format, &bits);
> + dpu_fu_get_pixel_format_shifts(fu, format->format, &shifts);
> +
> + if (is_planar_yuv) {
> + bits &= ~(U_BITS_MASK | V_BITS_MASK);
> + shifts &= ~(U_SHIFT_MASK | V_SHIFT_MASK);
> + }
> +
> + dpu_fu_write(fu, COLORCOMPONENTBITS(fu), bits);
> + dpu_fu_write(fu, COLORCOMPONENTSHIFT(fu), shifts);
> +}
> +
> +static void dpu_fd_set_framedimensions(struct dpu_fetchunit *fu,
> + unsigned int w, unsigned int h,
> + bool deinterlace)
> +{
> + if (deinterlace)
> + h /= 2;
> +
> + dpu_fu_write(fu, FRAMEDIMENSIONS, FRAMEWIDTH(w) | FRAMEHEIGHT(h));
> +}
> +
> +static void dpu_fd_set_ops(struct dpu_fetchunit *fu)
> +{
> + memcpy(&fu->ops, &dpu_fu_common_ops, sizeof(dpu_fu_common_ops));
> + fu->ops.set_pec_dynamic_src_sel = dpu_fd_pec_dynamic_src_sel;
> + fu->ops.set_src_buf_dimensions = dpu_fd_set_src_buf_dimensions;
> + fu->ops.set_fmt = dpu_fd_set_fmt;
> + fu->ops.set_framedimensions = dpu_fd_set_framedimensions;
> +}
> +
> +struct dpu_fetchunit *dpu_fd_get(struct dpu_soc *dpu, unsigned int id)
> +{
> + struct dpu_fetchunit *fu;
> + int i;
> +
> + for (i = 0; i < ARRAY_SIZE(dpu->fd_priv); i++) {
> + fu = dpu->fd_priv[i];
> + if (fu->id == id)
> + break;
> + }
> +
> + if (i == ARRAY_SIZE(dpu->fd_priv))
> + return ERR_PTR(-EINVAL);
> +
> + fu->fe = dpu_fe_get(dpu, id);
> + if (IS_ERR(fu->fe))
> + return ERR_CAST(fu->fe);
> +
> + fu->hs = dpu_hs_get(dpu, fu->type == DPU_DISP ?
> + id + DPU_FETCHDECODE_DISP_SCALER_OFFSET : id);
> + if (IS_ERR(fu->hs))
> + return ERR_CAST(fu->hs);
> +
> + fu->vs = dpu_vs_get(dpu, fu->type == DPU_DISP ?
> + id + DPU_FETCHDECODE_DISP_SCALER_OFFSET : id);
> + if (IS_ERR(fu->vs))
> + return ERR_CAST(fu->vs);
> +
> + mutex_lock(&fu->mutex);
> +
> + if (fu->inuse) {
> + mutex_unlock(&fu->mutex);
> + return ERR_PTR(-EBUSY);
> + }
> +
> + fu->inuse = true;
> +
> + mutex_unlock(&fu->mutex);
> +
> + return fu;
> +}
> +
> +void dpu_fd_put(struct dpu_fetchunit *fu)
> +{
> + if (IS_ERR_OR_NULL(fu))
> + return;
> +
> + mutex_lock(&fu->mutex);
> +
> + fu->inuse = false;
> +
> + mutex_unlock(&fu->mutex);
> +}
> +
> +void dpu_fd_hw_init(struct dpu_soc *dpu, unsigned int index)
> +{
> + struct dpu_fetchunit *fu = dpu->fd_priv[index];
> +
> + fu->ops.set_pec_dynamic_src_sel(fu, LINK_ID_NONE);
> + dpu_fu_common_hw_init(fu);
> +}
> +
> +int dpu_fd_init(struct dpu_soc *dpu, unsigned int index,
> + unsigned int id, enum dpu_unit_type type,
> + unsigned long pec_base, unsigned long base)
> +{
> + struct dpu_fetchunit *fu;
> + int ret;
> +
> + fu = devm_kzalloc(dpu->dev, sizeof(*fu), GFP_KERNEL);
> + if (!fu)
> + return -ENOMEM;
> +
> + dpu->fd_priv[index] = fu;
> +
> + fu->pec_base = devm_ioremap(dpu->dev, pec_base, SZ_16);
> + if (!fu->pec_base)
> + return -ENOMEM;
> +
> + fu->base = devm_ioremap(dpu->dev, base, SZ_2K);
> + if (!fu->base)
> + return -ENOMEM;
> +
> + fu->dpu = dpu;
> + fu->id = id;
> + fu->index = index;
> + fu->type = type;
> + fu->link_id = dpu_fd_link_id[index];
> + fu->cap_mask = DPU_FETCHDECODE_CAP_MASK;
> + fu->reg_offset = DPU_FETCHDECODE_REG_OFFSET;
> + snprintf(fu->name, sizeof(fu->name), "FetchDecode%u", id);
> +
> + ret = dpu_fu_attach_dprc(fu);
> + if (ret) {
> + dev_err_probe(dpu->dev, ret, "%s - failed to attach DPRC\n",
> + fu->name);
> + return ret;
> + }
> +
> + dpu_fd_set_ops(fu);
> +
> + mutex_init(&fu->mutex);
> +
> + return 0;
> +}
> diff --git a/drivers/gpu/drm/imx/dpu/dpu-fetcheco.c b/drivers/gpu/drm/imx/dpu/dpu-fetcheco.c
> new file mode 100644
> index 00000000..8345a98
> --- /dev/null
> +++ b/drivers/gpu/drm/imx/dpu/dpu-fetcheco.c
> @@ -0,0 +1,224 @@
> +// SPDX-License-Identifier: GPL-2.0+
> +
> +/*
> + * Copyright 2017-2020 NXP
> + */
> +
> +#include <linux/kernel.h>
> +#include <linux/mutex.h>
> +#include <linux/sizes.h>
> +
> +#include "dpu.h"
> +#include "dpu-fetchunit.h"
> +#include "dpu-prv.h"
> +
> +#define FRAMEDIMENSIONS 0x38
> +#define FRAMERESAMPLING 0x3c
> +#define CONTROL 0x40
> +#define CONTROLTRIGGER 0x44
> +#define START 0x48
> +#define FETCHTYPE 0x4c
> +#define BURSTBUFFERPROPERTIES 0x50
> +#define HIDDENSTATUS 0x54
> +
> +static const enum dpu_link_id dpu_fe_link_id[] = {
> + LINK_ID_FETCHECO0, LINK_ID_FETCHECO1,
> + LINK_ID_FETCHECO2, LINK_ID_FETCHECO9
> +};
> +
> +static void
> +dpu_fe_set_src_buf_dimensions(struct dpu_fetchunit *fu,
> + unsigned int w, unsigned int h,
> + const struct drm_format_info *format,
> + bool deinterlace)
> +{
> + struct dpu_soc *dpu = fu->dpu;
> + unsigned int width, height;
> +
> + if (deinterlace) {
> + width = w;
> + height = h / 2;
> + } else {
> + width = w / format->hsub;
> + height = h / format->vsub;
> + }
> +
> + switch (format->format) {
> + case DRM_FORMAT_NV12:
> + case DRM_FORMAT_NV21:
> + case DRM_FORMAT_NV16:
> + case DRM_FORMAT_NV61:
> + case DRM_FORMAT_NV24:
> + case DRM_FORMAT_NV42:
> + break;
> + default:
> + dev_warn(dpu->dev,
> + "%s - unsupported pixel format 0x%08x\n",
> + fu->name, format->format);
> + return;
> + }
> +
> + dpu_fu_write(fu, SOURCEBUFFERDIMENSION(fu),
> + LINEWIDTH(width) | LINECOUNT(height));
> +}
> +
> +static void dpu_fe_set_fmt(struct dpu_fetchunit *fu,
> + const struct drm_format_info *format,
> + enum drm_color_encoding unused1,
> + enum drm_color_range unused2,
> + bool deinterlace)
> +{
> + struct dpu_soc *dpu = fu->dpu;
> + u32 bits = 0, shifts = 0;
> + unsigned int x, y;
> +
> + switch (format->format) {
> + case DRM_FORMAT_NV12:
> + case DRM_FORMAT_NV21:
> + break;
> + default:
> + dev_warn(dpu->dev,
> + "%s - unsupported pixel format 0x%08x\n",
> + fu->name, format->format);
> + return;
> + }
> +
> + switch (format->hsub) {
> + case 1:
> + x = 0x4;
> + break;
> + case 2:
> + x = 0x2;
> + break;
> + default:
> + dev_warn(dpu->dev,
> + "%s - unsupported horizontal subsampling %u\n",
> + fu->name, format->hsub);
> + return;
> + }
> +
> + switch (format->vsub) {
> + case 1:
> + y = 0x4;
> + break;
> + case 2:
> + y = 0x2;
> + break;
> + default:
> + dev_warn(dpu->dev,
> + "%s - unsupported vertical subsampling %u\n",
> + fu->name, format->vsub);
> + return;
> + }
> +
> + dpu_fu_set_src_bpp(fu, 16);
> +
> + dpu_fu_write_mask(fu, FRAMERESAMPLING, DELTAX_MASK | DELTAY_MASK,
> + DELTAX(x) | DELTAY(y));
> +
> + dpu_fu_write_mask(fu, CONTROL, RASTERMODE_MASK,
> + RASTERMODE(RASTERMODE_NORMAL));
> +
> + dpu_fu_get_pixel_format_bits(fu, format->format, &bits);
> + dpu_fu_get_pixel_format_shifts(fu, format->format, &shifts);
> +
> + dpu_fu_write(fu, COLORCOMPONENTBITS(fu), bits & ~Y_BITS_MASK);
> + dpu_fu_write(fu, COLORCOMPONENTSHIFT(fu), shifts & ~Y_SHIFT_MASK);
> +}
> +
> +static void dpu_fe_set_framedimensions(struct dpu_fetchunit *fu,
> + unsigned int w, unsigned int h,
> + bool deinterlace)
> +{
> + if (deinterlace)
> + h /= 2;
> +
> + dpu_fu_write(fu, FRAMEDIMENSIONS, FRAMEWIDTH(w) | FRAMEHEIGHT(h));
> +}
> +
> +static void dpu_fe_set_ops(struct dpu_fetchunit *fu)
> +{
> + memcpy(&fu->ops, &dpu_fu_common_ops, sizeof(dpu_fu_common_ops));
> + fu->ops.set_src_buf_dimensions = dpu_fe_set_src_buf_dimensions;
> + fu->ops.set_fmt = dpu_fe_set_fmt;
> + fu->ops.set_framedimensions = dpu_fe_set_framedimensions;
> +}
> +
> +struct dpu_fetchunit *dpu_fe_get(struct dpu_soc *dpu, unsigned int id)
> +{
> + struct dpu_fetchunit *fu;
> + int i;
> +
> + for (i = 0; i < ARRAY_SIZE(dpu->fe_priv); i++) {
> + fu = dpu->fe_priv[i];
> + if (fu->id == id)
> + break;
> + }
> +
> + if (i == ARRAY_SIZE(dpu->fe_priv))
> + return ERR_PTR(-EINVAL);
> +
> + mutex_lock(&fu->mutex);
> +
> + if (fu->inuse) {
> + mutex_unlock(&fu->mutex);
> + return ERR_PTR(-EBUSY);
> + }
> +
> + fu->inuse = true;
> +
> + mutex_unlock(&fu->mutex);
> +
> + return fu;
> +}
> +
> +void dpu_fe_put(struct dpu_fetchunit *fu)
> +{
> + if (IS_ERR_OR_NULL(fu))
> + return;
> +
> + mutex_lock(&fu->mutex);
> +
> + fu->inuse = false;
> +
> + mutex_unlock(&fu->mutex);
> +}
> +
> +void dpu_fe_hw_init(struct dpu_soc *dpu, unsigned int index)
> +{
> + dpu_fu_common_hw_init(dpu->fe_priv[index]);
> +}
> +
> +int dpu_fe_init(struct dpu_soc *dpu, unsigned int index,
> + unsigned int id, enum dpu_unit_type type,
> + unsigned long pec_base, unsigned long base)
> +{
> + struct dpu_fetchunit *fu;
> +
> + fu = devm_kzalloc(dpu->dev, sizeof(*fu), GFP_KERNEL);
> + if (!fu)
> + return -ENOMEM;
> +
> + dpu->fe_priv[index] = fu;
> +
> + fu->pec_base = devm_ioremap(dpu->dev, pec_base, SZ_16);
> + if (!fu->pec_base)
> + return -ENOMEM;
> +
> + fu->base = devm_ioremap(dpu->dev, base, SZ_128);
> + if (!fu->base)
> + return -ENOMEM;
> +
> + fu->dpu = dpu;
> + fu->id = id;
> + fu->index = index;
> + fu->type = type;
> + fu->link_id = dpu_fe_link_id[index];
> + snprintf(fu->name, sizeof(fu->name), "FetchECO%u", id);
> +
> + dpu_fe_set_ops(fu);
> +
> + mutex_init(&fu->mutex);
> +
> + return 0;
> +}
> diff --git a/drivers/gpu/drm/imx/dpu/dpu-fetchlayer.c b/drivers/gpu/drm/imx/dpu/dpu-fetchlayer.c
> new file mode 100644
> index 00000000..ca18685
> --- /dev/null
> +++ b/drivers/gpu/drm/imx/dpu/dpu-fetchlayer.c
> @@ -0,0 +1,154 @@
> +// SPDX-License-Identifier: GPL-2.0+
> +
> +/*
> + * Copyright (C) 2016 Freescale Semiconductor, Inc.
> + * Copyright 2017-2020 NXP
> + */
> +
> +#include <linux/kernel.h>
> +#include <linux/mutex.h>
> +#include <linux/sizes.h>
> +
> +#include "dpu.h"
> +#include "dpu-fetchunit.h"
> +#include "dpu-prv.h"
> +
> +#define FRAMEDIMENSIONS 0x150
> +#define FRAMERESAMPLING 0x154
> +#define CONTROL 0x158
> +#define TRIGGERENABLE 0x15c
> +#define CONTROLTRIGGER 0x160
> +#define START 0x164
> +#define FETCHTYPE 0x168
> +#define BURSTBUFFERPROPERTIES 0x16c
> +#define STATUS 0x170
> +#define HIDDENSTATUS 0x174
> +
> +static const enum dpu_link_id dpu_fl_link_id[] = {LINK_ID_FETCHLAYER0};
> +
> +static void dpu_fl_set_fmt(struct dpu_fetchunit *fu,
> + const struct drm_format_info *format,
> + enum drm_color_encoding color_encoding,
> + enum drm_color_range color_range,
> + bool unused)
> +{
> + u32 bits = 0, shifts = 0;
> +
> + dpu_fu_set_src_bpp(fu, format->cpp[0] * 8);
> +
> + dpu_fu_write_mask(fu, LAYERPROPERTY(fu), YUVCONVERSIONMODE_MASK,
> + YUVCONVERSIONMODE(YUVCONVERSIONMODE_OFF));
> +
> + dpu_fu_get_pixel_format_bits(fu, format->format, &bits);
> + dpu_fu_get_pixel_format_shifts(fu, format->format, &shifts);
> +
> + dpu_fu_write(fu, COLORCOMPONENTBITS(fu), bits);
> + dpu_fu_write(fu, COLORCOMPONENTSHIFT(fu), shifts);
> +}
> +
> +static void
> +dpu_fl_set_framedimensions(struct dpu_fetchunit *fu, unsigned int w,
> + unsigned int h, bool unused)
> +{
> + dpu_fu_write(fu, FRAMEDIMENSIONS, FRAMEWIDTH(w) | FRAMEHEIGHT(h));
> +}
> +
> +static void dpu_fl_set_ops(struct dpu_fetchunit *fu)
> +{
> + memcpy(&fu->ops, &dpu_fu_common_ops, sizeof(dpu_fu_common_ops));
> + fu->ops.set_src_buf_dimensions =
> + dpu_fu_set_src_buf_dimensions_no_deinterlace;
> + fu->ops.set_fmt = dpu_fl_set_fmt;
> + fu->ops.set_framedimensions = dpu_fl_set_framedimensions;
> +}
> +
> +struct dpu_fetchunit *dpu_fl_get(struct dpu_soc *dpu, unsigned int id)
> +{
> + struct dpu_fetchunit *fu;
> + int i;
> +
> + for (i = 0; i < ARRAY_SIZE(dpu->fl_priv); i++) {
> + fu = dpu->fl_priv[i];
> + if (fu->id == id)
> + break;
> + }
> +
> + if (i == ARRAY_SIZE(dpu->fl_priv))
> + return ERR_PTR(-EINVAL);
> +
> + mutex_lock(&fu->mutex);
> +
> + if (fu->inuse) {
> + mutex_unlock(&fu->mutex);
> + return ERR_PTR(-EBUSY);
> + }
> +
> + fu->inuse = true;
> +
> + mutex_unlock(&fu->mutex);
> +
> + return fu;
> +}
> +
> +void dpu_fl_put(struct dpu_fetchunit *fu)
> +{
> + if (IS_ERR_OR_NULL(fu))
> + return;
> +
> + mutex_lock(&fu->mutex);
> +
> + fu->inuse = false;
> +
> + mutex_unlock(&fu->mutex);
> +}
> +
> +void dpu_fl_hw_init(struct dpu_soc *dpu, unsigned int index)
> +{
> + struct dpu_fetchunit *fu = dpu->fl_priv[index];
> +
> + dpu_fu_common_hw_init(fu);
> + dpu_fu_shdldreq_sticky(fu, 0xff);
> +}
> +
> +int dpu_fl_init(struct dpu_soc *dpu, unsigned int index,
> + unsigned int id, enum dpu_unit_type type,
> + unsigned long pec_base, unsigned long base)
> +{
> + struct dpu_fetchunit *fu;
> + int ret;
> +
> + fu = devm_kzalloc(dpu->dev, sizeof(*fu), GFP_KERNEL);
> + if (!fu)
> + return -ENOMEM;
> +
> + dpu->fl_priv[index] = fu;
> +
> + fu->pec_base = devm_ioremap(dpu->dev, pec_base, SZ_16);
> + if (!fu->pec_base)
> + return -ENOMEM;
> +
> + fu->base = devm_ioremap(dpu->dev, base, SZ_2K);
> + if (!fu->base)
> + return -ENOMEM;
> +
> + fu->dpu = dpu;
> + fu->id = id;
> + fu->index = index;
> + fu->type = type;
> + fu->sub_id = 0;
> + fu->link_id = dpu_fl_link_id[index];
> + snprintf(fu->name, sizeof(fu->name), "FetchLayer%u", id);
> +
> + ret = dpu_fu_attach_dprc(fu);
> + if (ret) {
> + dev_err_probe(dpu->dev, ret, "%s - failed to attach DPRC\n",
> + fu->name);
> + return ret;
> + }
> +
> + dpu_fl_set_ops(fu);
> +
> + mutex_init(&fu->mutex);
> +
> + return 0;
> +}
> diff --git a/drivers/gpu/drm/imx/dpu/dpu-fetchunit.c b/drivers/gpu/drm/imx/dpu/dpu-fetchunit.c
> new file mode 100644
> index 00000000..4e7faee
> --- /dev/null
> +++ b/drivers/gpu/drm/imx/dpu/dpu-fetchunit.c
> @@ -0,0 +1,609 @@
> +// SPDX-License-Identifier: GPL-2.0+
> +
> +/*
> + * Copyright 2018-2020 NXP
> + */
> +
> +#include <linux/bitops.h>
> +#include <linux/list.h>
> +#include <linux/kernel.h>
> +#include <linux/of.h>
> +
> +#include <drm/drm_blend.h>
> +
> +#include <dt-bindings/firmware/imx/rsrc.h>
> +
> +#include "dpu-fetchunit.h"
> +
> +#define STATICCONTROL 0x8
> +#define SHDLDREQSTICKY(lm) (((lm) & 0xff) << 24)
> +#define SHDLDREQSTICKY_MASK (0xff << 24)
> +#define BASEADDRESSAUTOUPDATE(lm) (((lm) & 0xff) << 16)
> +#define BASEADDRESSAUTOUPDATE_MASK (0xff << 16)
> +
> +#define BURSTBUFFERMANAGEMENT 0xc
> +#define SETBURSTLENGTH(n) (((n) & 0x1f) << 8)
> +#define SETBURSTLENGTH_MASK 0x1f00
> +#define SETNUMBUFFERS(n) ((n) & 0xff)
> +#define SETNUMBUFFERS_MASK 0xff
> +#define LINEMODE_MASK 0x80000000
> +#define LINEMODE_SHIFT 31
> +
> +#define BASEADDRESS(fu) (0x10 + SUBID_OFFSET + REG_OFFSET)
> +
> +#define SOURCEBUFFERATTRIBUTES(fu) (0x14 + SUBID_OFFSET + REG_OFFSET)
> +#define BITSPERPIXEL_MASK 0x3f0000
> +#define BITSPERPIXEL(bpp) (((bpp) & 0x3f) << 16)
> +#define STRIDE_MASK 0xffff
> +#define STRIDE(n) (((n) - 1) & 0xffff)
> +
> +#define LAYEROFFSET(fu) (0x24 + SUBID_OFFSET + REG_OFFSET)
> +#define LAYERXOFFSET(x) ((x) & 0x7fff)
> +#define LAYERYOFFSET(y) (((y) & 0x7fff) << 16)
> +
> +#define CLIPWINDOWOFFSET(fu) (0x28 + SUBID_OFFSET + REG_OFFSET)
> +#define CLIPWINDOWXOFFSET(x) ((x) & 0x7fff)
> +#define CLIPWINDOWYOFFSET(y) (((y) & 0x7fff) << 16)
> +
> +#define CLIPWINDOWDIMENSIONS(fu) (0x2c + SUBID_OFFSET + REG_OFFSET)
> +#define CLIPWINDOWWIDTH(w) (((w) - 1) & 0x3fff)
> +#define CLIPWINDOWHEIGHT(h) ((((h) - 1) & 0x3fff) << 16)
> +
> +#define CONSTANTCOLOR(fu) (0x30 + SUBID_OFFSET + REG_OFFSET)
> +#define CONSTANTALPHA_MASK 0xff
> +#define CONSTANTALPHA(n) ((n) & CONSTANTALPHA_MASK)
> +
> +#define DPU_FETCHUNIT_NO_STREAM_ID (~0)
> +
> +enum dpu_linemode {
> + /*
> + * Mandatory setting for operation in the Display Controller.
> + * Works also for Blit Engine with marginal performance impact.
> + */
> + LINEMODE_DISPLAY = 0,
> + /* Recommended setting for operation in the Blit Engine. */
> + LINEMODE_BLIT = (1 << LINEMODE_SHIFT),
> +};
> +
> +struct dpu_fetchunit_pixel_format {
> + u32 pixel_format;
> + u32 bits;
> + u32 shifts;
> +};
> +
> +struct dpu_fetchunit_sc_rsc_map {
> + u32 sc_rsc;
> + enum dpu_link_id link_id;
> +};
> +
> +static const struct dpu_fetchunit_pixel_format pixel_formats[] = {
> + {
> + DRM_FORMAT_ARGB8888,
> + R_BITS(8) | G_BITS(8) | B_BITS(8) | A_BITS(8),
> + R_SHIFT(16) | G_SHIFT(8) | B_SHIFT(0) | A_SHIFT(24),
> + }, {
> + DRM_FORMAT_XRGB8888,
> + R_BITS(8) | G_BITS(8) | B_BITS(8) | A_BITS(0),
> + R_SHIFT(16) | G_SHIFT(8) | B_SHIFT(0) | A_SHIFT(0),
> + }, {
> + DRM_FORMAT_ABGR8888,
> + R_BITS(8) | G_BITS(8) | B_BITS(8) | A_BITS(8),
> + R_SHIFT(0) | G_SHIFT(8) | B_SHIFT(16) | A_SHIFT(24),
> + }, {
> + DRM_FORMAT_XBGR8888,
> + R_BITS(8) | G_BITS(8) | B_BITS(8) | A_BITS(0),
> + R_SHIFT(0) | G_SHIFT(8) | B_SHIFT(16) | A_SHIFT(0),
> + }, {
> + DRM_FORMAT_RGBA8888,
> + R_BITS(8) | G_BITS(8) | B_BITS(8) | A_BITS(8),
> + R_SHIFT(24) | G_SHIFT(16) | B_SHIFT(8) | A_SHIFT(0),
> + }, {
> + DRM_FORMAT_RGBX8888,
> + R_BITS(8) | G_BITS(8) | B_BITS(8) | A_BITS(0),
> + R_SHIFT(24) | G_SHIFT(16) | B_SHIFT(8) | A_SHIFT(0),
> + }, {
> + DRM_FORMAT_BGRA8888,
> + R_BITS(8) | G_BITS(8) | B_BITS(8) | A_BITS(8),
> + R_SHIFT(8) | G_SHIFT(16) | B_SHIFT(24) | A_SHIFT(0),
> + }, {
> + DRM_FORMAT_BGRX8888,
> + R_BITS(8) | G_BITS(8) | B_BITS(8) | A_BITS(0),
> + R_SHIFT(8) | G_SHIFT(16) | B_SHIFT(24) | A_SHIFT(0),
> + }, {
> + DRM_FORMAT_RGB888,
> + R_BITS(8) | G_BITS(8) | B_BITS(8) | A_BITS(0),
> + R_SHIFT(16) | G_SHIFT(8) | B_SHIFT(0) | A_SHIFT(0),
> + }, {
> + DRM_FORMAT_BGR888,
> + R_BITS(8) | G_BITS(8) | B_BITS(8) | A_BITS(0),
> + R_SHIFT(0) | G_SHIFT(8) | B_SHIFT(16) | A_SHIFT(0),
> + }, {
> + DRM_FORMAT_RGB565,
> + R_BITS(5) | G_BITS(6) | B_BITS(5) | A_BITS(0),
> + R_SHIFT(11) | G_SHIFT(5) | B_SHIFT(0) | A_SHIFT(0),
> + }, {
> + DRM_FORMAT_YUYV,
> + Y_BITS(8) | U_BITS(8) | V_BITS(8) | A_BITS(0),
> + Y_SHIFT(0) | U_SHIFT(8) | V_SHIFT(8) | A_SHIFT(0),
> + }, {
> + DRM_FORMAT_UYVY,
> + Y_BITS(8) | U_BITS(8) | V_BITS(8) | A_BITS(0),
> + Y_SHIFT(8) | U_SHIFT(0) | V_SHIFT(0) | A_SHIFT(0),
> + }, {
> + DRM_FORMAT_NV12,
> + Y_BITS(8) | U_BITS(8) | V_BITS(8) | A_BITS(0),
> + Y_SHIFT(0) | U_SHIFT(0) | V_SHIFT(8) | A_SHIFT(0),
> + }, {
> + DRM_FORMAT_NV21,
> + Y_BITS(8) | U_BITS(8) | V_BITS(8) | A_BITS(0),
> + Y_SHIFT(0) | U_SHIFT(8) | V_SHIFT(0) | A_SHIFT(0),
> + },
> +};
> +
> +static const struct dpu_fetchunit_sc_rsc_map sc_rsc_maps[] = {
> + { IMX_SC_R_DC_0_BLIT0, LINK_ID_FETCHDECODE9 },
> + { IMX_SC_R_DC_0_BLIT1, LINK_ID_FETCHWARP9 },
> + { IMX_SC_R_DC_0_WARP, LINK_ID_FETCHWARP2 },
> + { IMX_SC_R_DC_0_VIDEO0, LINK_ID_FETCHDECODE0 },
> + { IMX_SC_R_DC_0_VIDEO1, LINK_ID_FETCHDECODE1 },
> + { IMX_SC_R_DC_0_FRAC0, LINK_ID_FETCHLAYER0 },
> + { IMX_SC_R_DC_1_BLIT0, LINK_ID_FETCHDECODE9 },
> + { IMX_SC_R_DC_1_BLIT1, LINK_ID_FETCHWARP9 },
> + { IMX_SC_R_DC_1_WARP, LINK_ID_FETCHWARP2 },
> + { IMX_SC_R_DC_1_VIDEO0, LINK_ID_FETCHDECODE0 },
> + { IMX_SC_R_DC_1_VIDEO1, LINK_ID_FETCHDECODE1 },
> + { IMX_SC_R_DC_1_FRAC0, LINK_ID_FETCHLAYER0 },
> +};
> +
> +void dpu_fu_get_pixel_format_bits(struct dpu_fetchunit *fu,
> + u32 format, u32 *bits)
> +{
> + struct dpu_soc *dpu = fu->dpu;
> + int i;
> +
> + for (i = 0; i < ARRAY_SIZE(pixel_formats); i++) {
> + if (pixel_formats[i].pixel_format == format) {
> + *bits = pixel_formats[i].bits;
> + return;
> + }
> + }
> +
> + dev_warn(dpu->dev, "%s - unsupported pixel format 0x%08x\n",
> + fu->name, format);
> +}
> +
> +void dpu_fu_get_pixel_format_shifts(struct dpu_fetchunit *fu,
> + u32 format, u32 *shifts)
> +{
> + struct dpu_soc *dpu = fu->dpu;
> + int i;
> +
> + for (i = 0; i < ARRAY_SIZE(pixel_formats); i++) {
> + if (pixel_formats[i].pixel_format == format) {
> + *shifts = pixel_formats[i].shifts;
> + return;
> + }
> + }
> +
> + dev_warn(dpu->dev, "%s - unsupported pixel format 0x%08x\n",
> + fu->name, format);
> +}
> +
> +static bool dpu_fu_is_enabled(struct dpu_fetchunit *fu)
> +{
> + u32 val = dpu_fu_read(fu, LAYERPROPERTY(fu));
> +
> + return !!(val & SOURCEBUFFERENABLE);
> +}
> +
> +static void dpu_fu_enable_shden(struct dpu_fetchunit *fu)
> +{
> + dpu_fu_write_mask(fu, STATICCONTROL, SHDEN, SHDEN);
> +}
> +
> +static void dpu_fu_baddr_autoupdate(struct dpu_fetchunit *fu, u8 layer_mask)
> +{
> + dpu_fu_write_mask(fu, STATICCONTROL, BASEADDRESSAUTOUPDATE_MASK,
> + BASEADDRESSAUTOUPDATE(layer_mask));
> +}
> +
> +void dpu_fu_shdldreq_sticky(struct dpu_fetchunit *fu, u8 layer_mask)
> +{
> + dpu_fu_write_mask(fu, STATICCONTROL, SHDLDREQSTICKY_MASK,
> + SHDLDREQSTICKY(layer_mask));
> +}
> +
> +static void dpu_fu_set_linemode(struct dpu_fetchunit *fu, enum dpu_linemode mode)
> +{
> + dpu_fu_write_mask(fu, BURSTBUFFERMANAGEMENT, LINEMODE_MASK, mode);
> +}
> +
> +static void dpu_fu_set_numbuffers(struct dpu_fetchunit *fu, unsigned int num)
> +{
> + dpu_fu_write_mask(fu, BURSTBUFFERMANAGEMENT, SETNUMBUFFERS_MASK,
> + SETNUMBUFFERS(num));
> +}
> +
> +/* address TKT343664: base address has to align to burst size */
> +static unsigned int dpu_fu_burst_size_fixup(dma_addr_t baddr)
> +{
> + unsigned int burst_size;
> +
> + burst_size = 1 << __ffs(baddr);
> + burst_size = round_up(burst_size, 8);
> + burst_size = min(burst_size, 128U);
> +
> + return burst_size;
> +}
> +
> +/* address TKT339017: mismatch between burst size and stride */
> +static unsigned int dpu_fu_stride_fixup(unsigned int stride,
> + unsigned int burst_size,
> + dma_addr_t baddr, bool nonzero_mod)
> +{
> + if (nonzero_mod)
> + stride = round_up(stride + round_up(baddr % 8, 8), burst_size);
> + else
> + stride = round_up(stride, burst_size);
> +
> + return stride;
> +}
> +
> +static void dpu_fu_set_burstlength(struct dpu_fetchunit *fu,
> + unsigned int x_offset, unsigned int mt_w,
> + int bpp, dma_addr_t baddr)
> +{
> + struct dpu_soc *dpu = fu->dpu;
> + unsigned int burst_size, burst_length;
> + bool nonzero_mod = !!mt_w;
> +
> + /* consider PRG x offset to calculate buffer address */
> + if (nonzero_mod)
> + baddr += (x_offset % mt_w) * (bpp / 8);
> +
> + burst_size = dpu_fu_burst_size_fixup(baddr);
> + burst_length = burst_size / 8;
> +
> + dpu_fu_write_mask(fu, BURSTBUFFERMANAGEMENT, SETBURSTLENGTH_MASK,
> + SETBURSTLENGTH(burst_length));
> +
> + dev_dbg(dpu->dev, "%s burst length is %u\n", fu->name, burst_length);
> +}
> +
> +static void
> +dpu_fu_set_baseaddress(struct dpu_fetchunit *fu, unsigned int width,
> + unsigned int x_offset, unsigned int y_offset,
> + unsigned int mt_w, unsigned int mt_h,
> + int bpp, dma_addr_t baddr)
> +{
> + unsigned int burst_size, stride;
> + bool nonzero_mod = !!mt_w;
> +
> + if (nonzero_mod) {
> + /* consider PRG x offset to calculate buffer address */
> + baddr += (x_offset % mt_w) * (bpp / 8);
> +
> + burst_size = dpu_fu_burst_size_fixup(baddr);
> +
> + stride = width * (bpp / 8);
> + stride = dpu_fu_stride_fixup(stride, burst_size, baddr,
> + nonzero_mod);
> +
> + /* consider PRG y offset to calculate buffer address */
> + baddr += (y_offset % mt_h) * stride;
> + }
> +
> + dpu_fu_write(fu, BASEADDRESS(fu), baddr);
> +}
> +
> +void dpu_fu_set_src_bpp(struct dpu_fetchunit *fu, unsigned int bpp)
> +{
> + dpu_fu_write_mask(fu, SOURCEBUFFERATTRIBUTES(fu), BITSPERPIXEL_MASK,
> + BITSPERPIXEL(bpp));
> +}
> +
> +static void
> +dpu_fu_set_src_stride(struct dpu_fetchunit *fu,
> + unsigned int width, unsigned int x_offset,
> + unsigned int mt_w, int bpp, unsigned int stride,
> + dma_addr_t baddr)
> +{
> + unsigned int burst_size;
> + bool nonzero_mod = !!mt_w;
> +
> + /* consider PRG x offset to calculate buffer address */
> + if (nonzero_mod)
> + baddr += (x_offset % mt_w) * (bpp / 8);
> +
> + burst_size = dpu_fu_burst_size_fixup(baddr);
> +
> + stride = width * (bpp / 8);
> + stride = dpu_fu_stride_fixup(stride, burst_size, baddr, nonzero_mod);
> +
> + dpu_fu_write_mask(fu, SOURCEBUFFERATTRIBUTES(fu), STRIDE_MASK,
> + STRIDE(stride));
> +}
> +
> +void
> +dpu_fu_set_src_buf_dimensions_no_deinterlace(struct dpu_fetchunit *fu,
> + unsigned int w, unsigned int h,
> + const struct drm_format_info *unused1,
> + bool unused2)
> +{
> + dpu_fu_write(fu, SOURCEBUFFERDIMENSION(fu),
> + LINEWIDTH(w) | LINECOUNT(h));
> +}
> +
> +static void dpu_fu_layeroffset(struct dpu_fetchunit *fu, unsigned int x,
> + unsigned int y)
> +{
> + dpu_fu_write(fu, LAYEROFFSET(fu), LAYERXOFFSET(x) | LAYERYOFFSET(y));
> +}
> +
> +static void dpu_fu_clipoffset(struct dpu_fetchunit *fu, unsigned int x,
> + unsigned int y)
> +{
> + dpu_fu_write(fu, CLIPWINDOWOFFSET(fu),
> + CLIPWINDOWXOFFSET(x) | CLIPWINDOWYOFFSET(y));
> +}
> +
> +static void dpu_fu_clipdimensions(struct dpu_fetchunit *fu, unsigned int w,
> + unsigned int h)
> +{
> + dpu_fu_write(fu, CLIPWINDOWDIMENSIONS(fu),
> + CLIPWINDOWWIDTH(w) | CLIPWINDOWHEIGHT(h));
> +}
> +
> +static void dpu_fu_set_pixel_blend_mode(struct dpu_fetchunit *fu,
> + unsigned int pixel_blend_mode,
> + u16 alpha, bool fb_format_has_alpha)
> +{
> + u32 mode = 0;
> +
> + if (pixel_blend_mode == DRM_MODE_BLEND_PREMULTI ||
> + pixel_blend_mode == DRM_MODE_BLEND_COVERAGE) {
> + mode = ALPHACONSTENABLE;
> +
> + if (fb_format_has_alpha)
> + mode |= ALPHASRCENABLE;
> + }
> +
> + dpu_fu_write_mask(fu, LAYERPROPERTY(fu),
> + PREMULCONSTRGB | ALPHA_ENABLE_MASK | RGB_ENABLE_MASK,
> + mode);
> +
> + dpu_fu_write_mask(fu, CONSTANTCOLOR(fu), CONSTANTALPHA_MASK,
> + CONSTANTALPHA(alpha >> 8));
> +}
> +
> +static void dpu_fu_enable_src_buf(struct dpu_fetchunit *fu)
> +{
> + struct dpu_soc *dpu = fu->dpu;
> +
> + dpu_fu_write_mask(fu, LAYERPROPERTY(fu), SOURCEBUFFERENABLE,
> + SOURCEBUFFERENABLE);
> +
> + dev_dbg(dpu->dev, "%s enables source buffer in shadow\n", fu->name);
> +}
> +
> +static void dpu_fu_disable_src_buf(struct dpu_fetchunit *fu)
> +{
> + struct dpu_soc *dpu = fu->dpu;
> +
> + if (fu->ops.set_pec_dynamic_src_sel)
> + fu->ops.set_pec_dynamic_src_sel(fu, LINK_ID_NONE);
> +
> + dpu_fu_write_mask(fu, LAYERPROPERTY(fu), SOURCEBUFFERENABLE, 0);
> +
> + if (fu->fe)
> + fu->fe->ops.disable_src_buf(fu->fe);
> +
> + if (fu->hs) {
> + dpu_hs_pec_clken(fu->hs, CLKEN_DISABLE);
> + dpu_hs_mode(fu->hs, SCALER_NEUTRAL);
> + }
> +
> + if (fu->vs) {
> + dpu_vs_pec_clken(fu->vs, CLKEN_DISABLE);
> + dpu_vs_mode(fu->vs, SCALER_NEUTRAL);
> + }
> +
> + if (fu->lb) {
> + dpu_lb_pec_clken(fu->lb, CLKEN_DISABLE);
> + dpu_lb_mode(fu->lb, LB_NEUTRAL);
> + }
> +
> + dev_dbg(dpu->dev, "%s disables source buffer in shadow\n", fu->name);
> +}
> +
> +static struct dpu_dprc *dpu_fu_get_dprc(struct dpu_fetchunit *fu)
> +{
> + return fu->dprc;
> +}
> +
> +static struct dpu_fetchunit *dpu_fu_get_fetcheco(struct dpu_fetchunit *fu)
> +{
> + return fu->fe;
> +}
> +
> +static struct dpu_hscaler *dpu_fu_get_hscaler(struct dpu_fetchunit *fu)
> +{
> + return fu->hs;
> +}
> +
> +static struct dpu_vscaler *dpu_fu_get_vscaler(struct dpu_fetchunit *fu)
> +{
> + return fu->vs;
> +}
> +
> +static void
> +dpu_fu_set_layerblend(struct dpu_fetchunit *fu, struct dpu_layerblend *lb)
> +{
> + fu->lb = lb;
> +}
> +
> +static bool dpu_fu_is_available(struct dpu_fetchunit *fu)
> +{
> + return fu->is_available;
> +}
> +
> +static void dpu_fu_set_available(struct dpu_fetchunit *fu)
> +{
> + fu->is_available = true;
> +}
> +
> +static void dpu_fu_set_inavailable(struct dpu_fetchunit *fu)
> +{
> + fu->is_available = false;
> +}
> +
> +static void
> +dpu_fu_set_stream_id(struct dpu_fetchunit *fu, unsigned int stream_id)
> +{
> + struct dpu_soc *dpu = fu->dpu;
> +
> + fu->stream_id = stream_id;
> +
> + dev_dbg(dpu->dev, "%s sets stream id %u\n", fu->name, stream_id);
> +}
> +
> +static unsigned int dpu_fu_get_stream_id(struct dpu_fetchunit *fu)
> +{
> + struct dpu_soc *dpu = fu->dpu;
> +
> + dev_dbg(dpu->dev, "%s gets stream id %u\n", fu->name, fu->stream_id);
> +
> + return fu->stream_id;
> +}
> +
> +static void dpu_fu_set_no_stream_id(struct dpu_fetchunit *fu)
> +{
> + struct dpu_soc *dpu = fu->dpu;
> +
> + fu->stream_id = DPU_FETCHUNIT_NO_STREAM_ID;
> +
> + dev_dbg(dpu->dev, "%s sets no stream id\n", fu->name);
> +}
> +
> +static bool dpu_fu_has_stream_id(struct dpu_fetchunit *fu)
> +{
> + struct dpu_soc *dpu = fu->dpu;
> + bool result = fu->stream_id != DPU_FETCHUNIT_NO_STREAM_ID;
> +
> + if (result)
> + dev_dbg(dpu->dev, "%s has stream id\n", fu->name);
> + else
> + dev_dbg(dpu->dev, "%s has no stream id\n", fu->name);
> +
> + return result;
> +}
> +
> +static enum dpu_link_id dpu_fu_get_link_id(struct dpu_fetchunit *fu)
> +{
> + return fu->link_id;
> +}
> +
> +static u32 dpu_fu_get_cap_mask(struct dpu_fetchunit *fu)
> +{
> + return fu->cap_mask;
> +}
> +
> +static const char *dpu_fu_get_name(struct dpu_fetchunit *fu)
> +{
> + return fu->name;
> +}
> +
> +const struct dpu_fetchunit_ops dpu_fu_common_ops = {
> + .is_enabled = dpu_fu_is_enabled,
> + .set_numbuffers = dpu_fu_set_numbuffers,
> + .set_burstlength = dpu_fu_set_burstlength,
> + .set_baseaddress = dpu_fu_set_baseaddress,
> + .set_src_stride = dpu_fu_set_src_stride,
> + .set_pixel_blend_mode = dpu_fu_set_pixel_blend_mode,
> + .enable_src_buf = dpu_fu_enable_src_buf,
> + .disable_src_buf = dpu_fu_disable_src_buf,
> + .get_dprc = dpu_fu_get_dprc,
> + .get_fetcheco = dpu_fu_get_fetcheco,
> + .get_hscaler = dpu_fu_get_hscaler,
> + .get_vscaler = dpu_fu_get_vscaler,
> + .set_layerblend = dpu_fu_set_layerblend,
> + .is_available = dpu_fu_is_available,
> + .set_available = dpu_fu_set_available,
> + .set_inavailable = dpu_fu_set_inavailable,
> + .set_stream_id = dpu_fu_set_stream_id,
> + .get_stream_id = dpu_fu_get_stream_id,
> + .set_no_stream_id = dpu_fu_set_no_stream_id,
> + .has_stream_id = dpu_fu_has_stream_id,
> + .get_link_id = dpu_fu_get_link_id,
> + .get_cap_mask = dpu_fu_get_cap_mask,
> + .get_name = dpu_fu_get_name,
> +};
> +
> +const struct dpu_fetchunit_ops *dpu_fu_get_ops(struct dpu_fetchunit *fu)
> +{
> + return &fu->ops;
> +}
> +
> +struct dpu_fetchunit *dpu_fu_get_from_list(struct list_head *l)
> +{
> + return container_of(l, struct dpu_fetchunit, node);
> +}
> +
> +void dpu_fu_add_to_list(struct dpu_fetchunit *fu, struct list_head *l)
> +{
> + list_add(&fu->node, l);
> +}
> +
> +void dpu_fu_common_hw_init(struct dpu_fetchunit *fu)
> +{
> + dpu_fu_baddr_autoupdate(fu, 0x0);
> + dpu_fu_enable_shden(fu);
> + dpu_fu_set_linemode(fu, LINEMODE_DISPLAY);
> + dpu_fu_layeroffset(fu, 0x0, 0x0);
> + dpu_fu_clipoffset(fu, 0x0, 0x0);
> + dpu_fu_clipdimensions(fu, 0x0, 0x0);
> + dpu_fu_set_numbuffers(fu, 16);
> + dpu_fu_disable_src_buf(fu);
> + dpu_fu_set_no_stream_id(fu);
> +}
> +
> +int dpu_fu_attach_dprc(struct dpu_fetchunit *fu)
> +{
> + struct dpu_soc *dpu = fu->dpu;
> + struct device_node *parent = dpu->dev->of_node;
> + struct device_node *dprc_node;
> + u32 rsc;
> + int i, j;
> + int ret;
> +
> + for (i = 0; ; i++) {
> + dprc_node = of_parse_phandle(parent, "fsl,dpr-channels", i);
> + if (!dprc_node)
> + break;
> +
> + ret = of_property_read_u32(dprc_node, "fsl,sc-resource", &rsc);
> + if (ret) {
> + of_node_put(dprc_node);
> + return ret;
> + }
> +
> + for (j = 0; j < ARRAY_SIZE(sc_rsc_maps); j++) {
> + if (sc_rsc_maps[j].sc_rsc == rsc &&
> + sc_rsc_maps[j].link_id == fu->link_id) {
> + fu->dprc = dpu_dprc_lookup_by_of_node(dpu->dev,
> + dprc_node);
> + if (!fu->dprc) {
> + of_node_put(dprc_node);
> + return -EPROBE_DEFER;
> + }
> +
> + of_node_put(dprc_node);
> + return 0;
> + }
> + }
> +
> + of_node_put(dprc_node);
> + }
> +
> + return -EINVAL;
> +}
> diff --git a/drivers/gpu/drm/imx/dpu/dpu-fetchunit.h b/drivers/gpu/drm/imx/dpu/dpu-fetchunit.h
> new file mode 100644
> index 00000000..bffa4e5
> --- /dev/null
> +++ b/drivers/gpu/drm/imx/dpu/dpu-fetchunit.h
> @@ -0,0 +1,191 @@
> +/* SPDX-License-Identifier: GPL-2.0+ */
> +
> +/*
> + * Copyright 2019,2020 NXP
> + */
> +
> +#ifndef __DPU_FETCHUNIT_H__
> +#define __DPU_FETCHUNIT_H__
> +
> +#include <linux/io.h>
> +#include <linux/mutex.h>
> +
> +#include "dpu.h"
> +#include "dpu-dprc.h"
> +#include "dpu-prv.h"
> +
> +#define REG_OFFSET ((fu)->reg_offset)
> +#define SUBID_OFFSET (((fu)->sub_id) * 0x28)
> +
> +#define PIXENGCFG_DYNAMIC 0x8
> +
> +#define SOURCEBUFFERDIMENSION(fu) (0x18 + SUBID_OFFSET + REG_OFFSET)
> +#define LINEWIDTH(w) (((w) - 1) & 0x3fff)
> +#define LINECOUNT(h) ((((h) - 1) & 0x3fff) << 16)
> +
> +#define COLORCOMPONENTBITS(fu) (0x1c + SUBID_OFFSET + REG_OFFSET)
> +#define ITUFORMAT BIT(31)
> +#define R_BITS(n) (((n) & 0xf) << 24)
> +#define G_BITS(n) (((n) & 0xf) << 16)
> +#define B_BITS(n) (((n) & 0xf) << 8)
> +#define A_BITS(n) ((n) & 0xf)
> +#define Y_BITS(n) R_BITS(n)
> +#define Y_BITS_MASK 0xf000000
> +#define U_BITS(n) G_BITS(n)
> +#define U_BITS_MASK 0xf0000
> +#define V_BITS(n) B_BITS(n)
> +#define V_BITS_MASK 0xf00
> +
> +#define COLORCOMPONENTSHIFT(fu) (0x20 + SUBID_OFFSET + REG_OFFSET)
> +#define R_SHIFT(n) (((n) & 0x1f) << 24)
> +#define G_SHIFT(n) (((n) & 0x1f) << 16)
> +#define B_SHIFT(n) (((n) & 0x1f) << 8)
> +#define A_SHIFT(n) ((n) & 0x1f)
> +#define Y_SHIFT(n) R_SHIFT(n)
> +#define Y_SHIFT_MASK 0x1f000000
> +#define U_SHIFT(n) G_SHIFT(n)
> +#define U_SHIFT_MASK 0x1f0000
> +#define V_SHIFT(n) B_SHIFT(n)
> +#define V_SHIFT_MASK 0x1f00
> +
> +#define LAYERPROPERTY(fu) (0x34 + SUBID_OFFSET + REG_OFFSET)
> +#define PALETTEENABLE BIT(0)
> +enum dpu_tilemode {
> + TILE_FILL_ZERO,
> + TILE_FILL_CONSTANT,
> + TILE_PAD,
> + TILE_PAD_ZERO,
> +};
> +#define ALPHASRCENABLE BIT(8)
> +#define ALPHACONSTENABLE BIT(9)
> +#define ALPHAMASKENABLE BIT(10)
> +#define ALPHATRANSENABLE BIT(11)
> +#define ALPHA_ENABLE_MASK (ALPHASRCENABLE | ALPHACONSTENABLE | \
> + ALPHAMASKENABLE | ALPHATRANSENABLE)
> +#define RGBALPHASRCENABLE BIT(12)
> +#define RGBALPHACONSTENABLE BIT(13)
> +#define RGBALPHAMASKENABLE BIT(14)
> +#define RGBALPHATRANSENABLE BIT(15)
> +#define RGB_ENABLE_MASK (RGBALPHASRCENABLE | \
> + RGBALPHACONSTENABLE | \
> + RGBALPHAMASKENABLE | \
> + RGBALPHATRANSENABLE)
> +#define PREMULCONSTRGB BIT(16)
> +enum dpu_yuvconversionmode {
> + YUVCONVERSIONMODE_OFF,
> + YUVCONVERSIONMODE_ITU601,
> + YUVCONVERSIONMODE_ITU601_FR,
> + YUVCONVERSIONMODE_ITU709,
> +};
> +#define YUVCONVERSIONMODE_MASK 0x60000
> +#define YUVCONVERSIONMODE(m) (((m) & 0x3) << 17)
> +#define GAMMAREMOVEENABLE BIT(20)
> +#define CLIPWINDOWENABLE BIT(30)
> +#define SOURCEBUFFERENABLE BIT(31)
> +
> +#define EMPTYFRAME BIT(31)
> +#define FRAMEWIDTH(w) (((w) - 1) & 0x3fff)
> +#define FRAMEHEIGHT(h) ((((h) - 1) & 0x3fff) << 16)
> +#define DELTAX_MASK 0x3f000
> +#define DELTAY_MASK 0xfc0000
> +#define DELTAX(x) (((x) & 0x3f) << 12)
> +#define DELTAY(y) (((y) & 0x3f) << 18)
> +#define YUV422UPSAMPLINGMODE_MASK BIT(5)
> +#define YUV422UPSAMPLINGMODE(m) (((m) & 0x1) << 5)
> +enum dpu_yuv422upsamplingmode {
> + YUV422UPSAMPLINGMODE_REPLICATE,
> + YUV422UPSAMPLINGMODE_INTERPOLATE,
> +};
> +#define INPUTSELECT_MASK 0x18
> +#define INPUTSELECT(s) (((s) & 0x3) << 3)
> +enum dpu_inputselect {
> + INPUTSELECT_INACTIVE,
> + INPUTSELECT_COMPPACK,
> + INPUTSELECT_ALPHAMASK,
> + INPUTSELECT_COORDINATE,
> +};
> +#define RASTERMODE_MASK 0x7
> +#define RASTERMODE(m) ((m) & 0x7)
> +enum dpu_rastermode {
> + RASTERMODE_NORMAL,
> + RASTERMODE_DECODE,
> + RASTERMODE_ARBITRARY,
> + RASTERMODE_PERSPECTIVE,
> + RASTERMODE_YUV422,
> + RASTERMODE_AFFINE,
> +};
> +
> +struct dpu_fetchunit {
> + void __iomem *pec_base;
> + void __iomem *base;
> + char name[13];
> + struct mutex mutex;
> + struct list_head node;
> + unsigned int reg_offset;
> + unsigned int id;
> + unsigned int index;
> + unsigned int sub_id; /* for fractional fetch units */
> + unsigned int stream_id;
> + enum dpu_unit_type type;
> + enum dpu_link_id link_id;
> + u32 cap_mask;
> + bool inuse;
> + bool is_available;
> + struct dpu_soc *dpu;
> + struct dpu_fetchunit_ops ops;
> + struct dpu_dprc *dprc;
> + struct dpu_fetchunit *fe;
> + struct dpu_hscaler *hs;
> + struct dpu_vscaler *vs;
> + struct dpu_layerblend *lb;
> +};
> +
> +extern const struct dpu_fetchunit_ops dpu_fu_common_ops;
> +
> +static inline void
> +dpu_pec_fu_write(struct dpu_fetchunit *fu, unsigned int offset, u32 value)
> +{
> + writel(value, fu->pec_base + offset);
> +}
> +
> +static inline u32 dpu_pec_fu_read(struct dpu_fetchunit *fu, unsigned int offset)
> +{
> + return readl(fu->pec_base + offset);
> +}
> +
> +static inline u32 dpu_fu_read(struct dpu_fetchunit *fu, unsigned int offset)
> +{
> + return readl(fu->base + offset);
> +}
> +
> +static inline void
> +dpu_fu_write(struct dpu_fetchunit *fu, unsigned int offset, u32 value)
> +{
> + writel(value, fu->base + offset);
> +}
> +
> +static inline void dpu_fu_write_mask(struct dpu_fetchunit *fu,
> + unsigned int offset, u32 mask, u32 value)
> +{
> + u32 tmp;
> +
> + tmp = dpu_fu_read(fu, offset);
> + tmp &= ~mask;
> + dpu_fu_write(fu, offset, tmp | value);
> +}
> +
> +void dpu_fu_get_pixel_format_bits(struct dpu_fetchunit *fu,
> + u32 format, u32 *bits);
> +void dpu_fu_get_pixel_format_shifts(struct dpu_fetchunit *fu,
> + u32 format, u32 *shifts);
> +void dpu_fu_shdldreq_sticky(struct dpu_fetchunit *fu, u8 layer_mask);
> +void dpu_fu_set_src_bpp(struct dpu_fetchunit *fu, unsigned int bpp);
> +void
> +dpu_fu_set_src_buf_dimensions_no_deinterlace(struct dpu_fetchunit *fu,
> + unsigned int w, unsigned int h,
> + const struct drm_format_info *unused1,
> + bool unused2);
> +void dpu_fu_common_hw_init(struct dpu_fetchunit *fu);
> +int dpu_fu_attach_dprc(struct dpu_fetchunit *fu);
> +
> +#endif /* __DPU_FETCHUNIT_H__ */
> diff --git a/drivers/gpu/drm/imx/dpu/dpu-fetchwarp.c b/drivers/gpu/drm/imx/dpu/dpu-fetchwarp.c
> new file mode 100644
> index 00000000..0ca8d6d
> --- /dev/null
> +++ b/drivers/gpu/drm/imx/dpu/dpu-fetchwarp.c
> @@ -0,0 +1,250 @@
> +// SPDX-License-Identifier: GPL-2.0+
> +
> +/*
> + * Copyright 2018-2020 NXP
> + */
> +
> +#include <linux/kernel.h>
> +#include <linux/mutex.h>
> +#include <linux/sizes.h>
> +
> +#include "dpu.h"
> +#include "dpu-fetchunit.h"
> +#include "dpu-prv.h"
> +
> +#define FRAMEDIMENSIONS 0x150
> +#define FRAMERESAMPLING 0x154
> +#define WARPCONTROL 0x158
> +#define ARBSTARTX 0x15c
> +#define ARBSTARTY 0x160
> +#define ARBDELTA 0x164
> +#define FIRPOSITIONS 0x168
> +#define FIRCOEFFICIENTS 0x16c
> +#define CONTROL 0x170
> +#define TRIGGERENABLE 0x174
> +#define CONTROLTRIGGER 0x178
> +#define START 0x17c
> +#define FETCHTYPE 0x180
> +#define BURSTBUFFERPROPERTIES 0x184
> +#define STATUS 0x188
> +#define HIDDENSTATUS 0x18c
> +
> +static const enum dpu_link_id dpu_fw_link_id[] = {
> + LINK_ID_FETCHWARP2, LINK_ID_FETCHWARP9
> +};
> +
> +static const enum dpu_link_id fw_srcs[2][2] = {
> + {
> + LINK_ID_NONE,
> + LINK_ID_FETCHECO2,
> + }, {
> + LINK_ID_NONE,
> + LINK_ID_FETCHECO9,
> + },
> +};
> +
> +static void dpu_fw_pec_dynamic_src_sel(struct dpu_fetchunit *fu,
> + enum dpu_link_id src)
> +{
> + struct dpu_soc *dpu = fu->dpu;
> + int i;
> +
> + for (i = 0; i < ARRAY_SIZE(fw_srcs[fu->index]); i++) {
> + if (fw_srcs[fu->index][i] == src) {
> + dpu_pec_fu_write(fu, PIXENGCFG_DYNAMIC, src);
> + return;
> + }
> + }
> +
> + dev_err(dpu->dev, "%s - invalid source 0x%02x\n", fu->name, src);
> +}
> +
> +static void dpu_fw_set_fmt(struct dpu_fetchunit *fu,
> + const struct drm_format_info *format,
> + enum drm_color_encoding color_encoding,
> + enum drm_color_range color_range,
> + bool unused)
> +{
> + u32 val, bits = 0, shifts = 0;
> + bool is_planar_yuv = false, is_rastermode_yuv422 = false;
> + bool is_inputselect_compact = false;
> + unsigned int bpp;
> +
> + switch (format->format) {
> + case DRM_FORMAT_NV12:
> + case DRM_FORMAT_NV21:
> + is_planar_yuv = true;
> + is_rastermode_yuv422 = true;
> + is_inputselect_compact = true;
> + bpp = format->cpp[0] * 8;
> + break;
> + default:
> + bpp = format->cpp[0] * 8;
> + break;
> + }
> +
> + dpu_fu_set_src_bpp(fu, bpp);
> +
> + val = dpu_fu_read(fu, CONTROL);
> + val &= ~INPUTSELECT_MASK;
> + val &= ~RASTERMODE_MASK;
> + if (is_inputselect_compact)
> + val |= INPUTSELECT(INPUTSELECT_COMPPACK);
> + else
> + val |= INPUTSELECT(INPUTSELECT_INACTIVE);
> + if (is_rastermode_yuv422)
> + val |= RASTERMODE(RASTERMODE_YUV422);
> + else
> + val |= RASTERMODE(RASTERMODE_NORMAL);
> + dpu_fu_write(fu, CONTROL, val);
> +
> + val = dpu_fu_read(fu, LAYERPROPERTY(fu));
> + val &= ~YUVCONVERSIONMODE_MASK;
> + if (format->is_yuv) {
> + if (color_encoding == DRM_COLOR_YCBCR_BT709)
> + val |= YUVCONVERSIONMODE(YUVCONVERSIONMODE_ITU709);
> + else if (color_encoding == DRM_COLOR_YCBCR_BT601 &&
> + color_range == DRM_COLOR_YCBCR_FULL_RANGE)
> + val |= YUVCONVERSIONMODE(YUVCONVERSIONMODE_ITU601_FR);
> + else
> + val |= YUVCONVERSIONMODE(YUVCONVERSIONMODE_ITU601);
> + } else {
> + val |= YUVCONVERSIONMODE(YUVCONVERSIONMODE_OFF);
> + }
> + dpu_fu_write(fu, LAYERPROPERTY(fu), val);
> +
> + dpu_fu_get_pixel_format_bits(fu, format->format, &bits);
> + dpu_fu_get_pixel_format_shifts(fu, format->format, &shifts);
> +
> + if (is_planar_yuv) {
> + bits &= ~(U_BITS_MASK | V_BITS_MASK);
> + shifts &= ~(U_SHIFT_MASK | V_SHIFT_MASK);
> + }
> +
> + dpu_fu_write(fu, COLORCOMPONENTBITS(fu), bits);
> + dpu_fu_write(fu, COLORCOMPONENTSHIFT(fu), shifts);
> +}
> +
> +static void
> +dpu_fw_set_framedimensions(struct dpu_fetchunit *fu,
> + unsigned int w, unsigned int h, bool unused)
> +{
> + dpu_fu_write(fu, FRAMEDIMENSIONS, FRAMEWIDTH(w) | FRAMEHEIGHT(h));
> +}
> +
> +static void dpu_fw_set_ops(struct dpu_fetchunit *fu)
> +{
> + memcpy(&fu->ops, &dpu_fu_common_ops, sizeof(dpu_fu_common_ops));
> + fu->ops.set_pec_dynamic_src_sel = dpu_fw_pec_dynamic_src_sel;
> + fu->ops.set_src_buf_dimensions =
> + dpu_fu_set_src_buf_dimensions_no_deinterlace;
> + fu->ops.set_fmt = dpu_fw_set_fmt;
> + fu->ops.set_framedimensions = dpu_fw_set_framedimensions;
> +}
> +
> +struct dpu_fetchunit *dpu_fw_get(struct dpu_soc *dpu, unsigned int id)
> +{
> + struct dpu_fetchunit *fu;
> + int i;
> +
> + for (i = 0; i < ARRAY_SIZE(dpu->fw_priv); i++) {
> + fu = dpu->fw_priv[i];
> + if (fu->id == id)
> + break;
> + }
> +
> + if (i == ARRAY_SIZE(dpu->fw_priv))
> + return ERR_PTR(-EINVAL);
> +
> + fu->fe = dpu_fe_get(dpu, id);
> + if (IS_ERR(fu->fe))
> + return ERR_CAST(fu->fe);
> +
> + if (fu->type == DPU_BLIT) {
> + fu->hs = dpu_hs_get(dpu, id);
> + if (IS_ERR(fu->hs))
> + return ERR_CAST(fu->hs);
> +
> + fu->vs = dpu_vs_get(dpu, id);
> + if (IS_ERR(fu->vs))
> + return ERR_CAST(fu->vs);
> + }
> +
> + mutex_lock(&fu->mutex);
> +
> + if (fu->inuse) {
> + mutex_unlock(&fu->mutex);
> + return ERR_PTR(-EBUSY);
> + }
> +
> + fu->inuse = true;
> +
> + mutex_unlock(&fu->mutex);
> +
> + return fu;
> +}
> +
> +void dpu_fw_put(struct dpu_fetchunit *fu)
> +{
> + if (IS_ERR_OR_NULL(fu))
> + return;
> +
> + mutex_lock(&fu->mutex);
> +
> + fu->inuse = false;
> +
> + mutex_unlock(&fu->mutex);
> +}
> +
> +void dpu_fw_hw_init(struct dpu_soc *dpu, unsigned int index)
> +{
> + struct dpu_fetchunit *fu = dpu->fw_priv[index];
> +
> + fu->ops.set_pec_dynamic_src_sel(fu, LINK_ID_NONE);
> + dpu_fu_common_hw_init(fu);
> + dpu_fu_shdldreq_sticky(fu, 0xff);
> +}
> +
> +int dpu_fw_init(struct dpu_soc *dpu, unsigned int index,
> + unsigned int id, enum dpu_unit_type type,
> + unsigned long pec_base, unsigned long base)
> +{
> + struct dpu_fetchunit *fu;
> + int ret;
> +
> + fu = devm_kzalloc(dpu->dev, sizeof(*fu), GFP_KERNEL);
> + if (!fu)
> + return -ENOMEM;
> +
> + dpu->fw_priv[index] = fu;
> +
> + fu->pec_base = devm_ioremap(dpu->dev, pec_base, SZ_16);
> + if (!fu->pec_base)
> + return -ENOMEM;
> +
> + fu->base = devm_ioremap(dpu->dev, base, SZ_512);
> + if (!fu->base)
> + return -ENOMEM;
> +
> + fu->dpu = dpu;
> + fu->id = id;
> + fu->index = index;
> + fu->type = type;
> + fu->sub_id = 0;
> + fu->link_id = dpu_fw_link_id[index];
> + fu->cap_mask = DPU_FETCHUNIT_CAP_USE_FETCHECO;
> + snprintf(fu->name, sizeof(fu->name), "FetchWarp%u", id);
> +
> + ret = dpu_fu_attach_dprc(fu);
> + if (ret) {
> + dev_err_probe(dpu->dev, ret, "%s - failed to attach DPRC\n",
> + fu->name);
> + return ret;
> + }
> +
> + dpu_fw_set_ops(fu);
> +
> + mutex_init(&fu->mutex);
> +
> + return 0;
> +}
> diff --git a/drivers/gpu/drm/imx/dpu/dpu-framegen.c b/drivers/gpu/drm/imx/dpu/dpu-framegen.c
> new file mode 100644
> index 00000000..7d9fccb
> --- /dev/null
> +++ b/drivers/gpu/drm/imx/dpu/dpu-framegen.c
> @@ -0,0 +1,395 @@
> +// SPDX-License-Identifier: GPL-2.0+
> +
> +/*
> + * Copyright (C) 2016 Freescale Semiconductor, Inc.
> + * Copyright 2017-2020 NXP
> + */
> +
> +#include <linux/clk.h>
> +#include <linux/device.h>
> +#include <linux/io.h>
> +#include <linux/iopoll.h>
> +#include <linux/jiffies.h>
> +#include <linux/kernel.h>
> +#include <linux/mutex.h>
> +#include <linux/sizes.h>
> +
> +#include "dpu.h"
> +#include "dpu-prv.h"
> +
> +#define FGSTCTRL 0x8
> +#define FGSYNCMODE_MASK 0x6
> +#define FGSYNCMODE(n) ((n) << 6)
> +
> +#define HTCFG1 0xc
> +#define HTOTAL(n) ((((n) - 1) & 0x3fff) << 16)
> +#define HACT(n) ((n) & 0x3fff)
> +
> +#define HTCFG2 0x10
> +#define HSEN BIT(31)
> +#define HSBP(n) ((((n) - 1) & 0x3fff) << 16)
> +#define HSYNC(n) (((n) - 1) & 0x3fff)
> +
> +#define VTCFG1 0x14
> +#define VTOTAL(n) ((((n) - 1) & 0x3fff) << 16)
> +#define VACT(n) ((n) & 0x3fff)
> +
> +#define VTCFG2 0x18
> +#define VSEN BIT(31)
> +#define VSBP(n) ((((n) - 1) & 0x3fff) << 16)
> +#define VSYNC(n) (((n) - 1) & 0x3fff)
> +
> +#define INTCONFIG(n) (0x1c + 4 * (n))
> +#define EN BIT(31)
> +#define ROW(n) (((n) & 0x3fff) << 16)
> +#define COL(n) ((n) & 0x3fff)
> +
> +#define PKICKCONFIG 0x2c
> +#define SKICKCONFIG 0x30
> +#define SECSTATCONFIG 0x34
> +#define FGSRCR1 0x38
> +#define FGSRCR2 0x3c
> +#define FGSRCR3 0x40
> +#define FGSRCR4 0x44
> +#define FGSRCR5 0x48
> +#define FGSRCR6 0x4c
> +#define FGKSDR 0x50
> +
> +#define PACFG 0x54
> +#define SACFG 0x58
> +#define STARTX(n) (((n) + 1) & 0x3fff)
> +#define STARTY(n) (((((n) + 1) & 0x3fff)) << 16)
> +
> +#define FGINCTRL 0x5c
> +#define FGINCTRLPANIC 0x60
> +#define FGDM_MASK 0x7
> +#define ENPRIMALPHA BIT(3)
> +#define ENSECALPHA BIT(4)
> +
> +#define FGCCR 0x64
> +#define CCALPHA(a) (((a) & 0x1) << 30)
> +#define CCRED(r) (((r) & 0x3ff) << 20)
> +#define CCGREEN(g) (((g) & 0x3ff) << 10)
> +#define CCBLUE(b) ((b) & 0x3ff)
> +
> +#define FGENABLE 0x68
> +#define FGEN BIT(0)
> +
> +#define FGSLR 0x6c
> +#define SHDTOKGEN BIT(0)
> +
> +#define FGENSTS 0x70
> +#define ENSTS BIT(0)
> +
> +#define FGTIMESTAMP 0x74
> +#define FRAMEINDEX_SHIFT 14
> +#define FRAMEINDEX_MASK (DPU_FRAMEGEN_MAX_FRAME_INDEX << \
> + FRAMEINDEX_SHIFT)
> +#define LINEINDEX_MASK 0x3fff
> +
> +#define FGCHSTAT 0x78
> +#define SECSYNCSTAT BIT(24)
> +#define SFIFOEMPTY BIT(16)
> +
> +#define FGCHSTATCLR 0x7c
> +#define CLRSECSTAT BIT(16)
> +
> +#define FGSKEWMON 0x80
> +#define FGSFIFOMIN 0x84
> +#define FGSFIFOMAX 0x88
> +#define FGSFIFOFILLCLR 0x8c
> +#define FGSREPD 0x90
> +#define FGSRFTD 0x94
> +
> +#define KHZ 1000
> +#define MIN_PLL_RATE 648000000 /* assume 648MHz */
> +
> +struct dpu_framegen {
> + void __iomem *base;
> + struct clk *clk_pll;
> + struct clk *clk_disp;
> + struct mutex mutex;
> + unsigned int id;
> + unsigned int index;
> + bool inuse;
> + struct dpu_soc *dpu;
> +};
> +
> +static inline u32 dpu_fg_read(struct dpu_framegen *fg, unsigned int offset)
> +{
> + return readl(fg->base + offset);
> +}
> +
> +static inline void dpu_fg_write(struct dpu_framegen *fg,
> + unsigned int offset, u32 value)
> +{
> + writel(value, fg->base + offset);
> +}
> +
> +static inline void dpu_fg_write_mask(struct dpu_framegen *fg,
> + unsigned int offset, u32 mask, u32 value)
> +{
> + u32 tmp;
> +
> + tmp = dpu_fg_read(fg, offset);
> + tmp &= ~mask;
> + dpu_fg_write(fg, offset, tmp | value);
> +}
> +
> +static void dpu_fg_enable_shden(struct dpu_framegen *fg)
> +{
> + dpu_fg_write_mask(fg, FGSTCTRL, SHDEN, SHDEN);
> +}
> +
> +void dpu_fg_syncmode(struct dpu_framegen *fg, enum dpu_fg_syncmode mode)
> +{
> + dpu_fg_write_mask(fg, FGSTCTRL, FGSYNCMODE_MASK, FGSYNCMODE(mode));
> +}
> +
> +void dpu_fg_cfg_videomode(struct dpu_framegen *fg, struct drm_display_mode *m)
> +{
> + u32 hact, htotal, hsync, hsbp;
> + u32 vact, vtotal, vsync, vsbp;
> + u32 kick_row, kick_col;
> + unsigned long pclk_rate, pll_rate = 0;
> + int div = 0;
> +
> + hact = m->crtc_hdisplay;
> + htotal = m->crtc_htotal;
> + hsync = m->crtc_hsync_end - m->crtc_hsync_start;
> + hsbp = m->crtc_htotal - m->crtc_hsync_start;
> +
> + vact = m->crtc_vdisplay;
> + vtotal = m->crtc_vtotal;
> + vsync = m->crtc_vsync_end - m->crtc_vsync_start;
> + vsbp = m->crtc_vtotal - m->crtc_vsync_start;
> +
> + /* video mode */
> + dpu_fg_write(fg, HTCFG1, HACT(hact) | HTOTAL(htotal));
> + dpu_fg_write(fg, HTCFG2, HSYNC(hsync) | HSBP(hsbp) | HSEN);
> + dpu_fg_write(fg, VTCFG1, VACT(vact) | VTOTAL(vtotal));
> + dpu_fg_write(fg, VTCFG2, VSYNC(vsync) | VSBP(vsbp) | VSEN);
> +
> + kick_col = hact + 1;
> + kick_row = vact;
> +
> + /* pkickconfig */
> + dpu_fg_write(fg, PKICKCONFIG, COL(kick_col) | ROW(kick_row) | EN);
> +
> + /* skikconfig */
> + dpu_fg_write(fg, SKICKCONFIG, COL(kick_col) | ROW(kick_row) | EN);
> +
> + /* primary and secondary area position configuration */
> + dpu_fg_write(fg, PACFG, STARTX(0) | STARTY(0));
> + dpu_fg_write(fg, SACFG, STARTX(0) | STARTY(0));
> +
> + /* alpha */
> + dpu_fg_write_mask(fg, FGINCTRL, ENPRIMALPHA | ENSECALPHA, 0);
> + dpu_fg_write_mask(fg, FGINCTRLPANIC, ENPRIMALPHA | ENSECALPHA, 0);
> +
> + /* constant color is green(used in panic mode) */
> + dpu_fg_write(fg, FGCCR, CCGREEN(0x3ff));
> +
> + clk_set_parent(fg->clk_disp, fg->clk_pll);
> +
> + pclk_rate = m->clock * KHZ;
> +
> + /* find a minimal even divider for PLL */
> + do {
> + div += 2;
> + pll_rate = pclk_rate * div;
> + } while (pll_rate < MIN_PLL_RATE);
> +
> + clk_set_rate(fg->clk_pll, pll_rate);
> + clk_set_rate(fg->clk_disp, pclk_rate);
> +}
> +
> +void dpu_fg_displaymode(struct dpu_framegen *fg, enum dpu_fg_dm mode)
> +{
> + dpu_fg_write_mask(fg, FGINCTRL, FGDM_MASK, mode);
> +}
> +
> +void dpu_fg_panic_displaymode(struct dpu_framegen *fg, enum dpu_fg_dm mode)
> +{
> + dpu_fg_write_mask(fg, FGINCTRLPANIC, FGDM_MASK, mode);
> +}
> +
> +void dpu_fg_enable(struct dpu_framegen *fg)
> +{
> + dpu_fg_write(fg, FGENABLE, FGEN);
> +}
> +
> +void dpu_fg_disable(struct dpu_framegen *fg)
> +{
> + dpu_fg_write(fg, FGENABLE, 0);
> +}
> +
> +void dpu_fg_shdtokgen(struct dpu_framegen *fg)
> +{
> + dpu_fg_write(fg, FGSLR, SHDTOKGEN);
> +}
> +
> +u32 dpu_fg_get_frame_index(struct dpu_framegen *fg)
> +{
> + u32 val = dpu_fg_read(fg, FGTIMESTAMP);
> +
> + return (val & FRAMEINDEX_MASK) >> FRAMEINDEX_SHIFT;
> +}
> +
> +int dpu_fg_get_line_index(struct dpu_framegen *fg)
> +{
> + u32 val = dpu_fg_read(fg, FGTIMESTAMP);
> +
> + return val & LINEINDEX_MASK;
> +}
> +
> +int dpu_fg_wait_for_frame_counter_moving(struct dpu_framegen *fg)
> +{
> + u32 frame_index, last_frame_index;
> + unsigned long timeout = jiffies + msecs_to_jiffies(100);
> +
> + frame_index = dpu_fg_get_frame_index(fg);
> + do {
> + last_frame_index = frame_index;
> + frame_index = dpu_fg_get_frame_index(fg);
> + } while (last_frame_index == frame_index &&
> + time_before(jiffies, timeout));
> +
> + if (last_frame_index == frame_index) {
> + dev_dbg(fg->dpu->dev,
> + "failed to wait for FrameGen%d frame counter moving\n",
> + fg->id);
> + return -ETIMEDOUT;
> + }
> +
> + dev_dbg(fg->dpu->dev,
> + "FrameGen%d frame counter moves - last %u, curr %d\n",
> + fg->id, last_frame_index, frame_index);
> + return 0;
> +}
> +
> +bool dpu_fg_secondary_requests_to_read_empty_fifo(struct dpu_framegen *fg)
> +{
> + u32 val;
> +
> + val = dpu_fg_read(fg, FGCHSTAT);
> +
> + return !!(val & SFIFOEMPTY);
> +}
> +
> +void dpu_fg_secondary_clear_channel_status(struct dpu_framegen *fg)
> +{
> + dpu_fg_write(fg, FGCHSTATCLR, CLRSECSTAT);
> +}
> +
> +int dpu_fg_wait_for_secondary_syncup(struct dpu_framegen *fg)
> +{
> + u32 val;
> + int ret;
> +
> + ret = readl_poll_timeout(fg->base + FGCHSTAT, val,
> + val & SECSYNCSTAT, 5, 100000);
> + if (ret) {
> + dev_dbg(fg->dpu->dev,
> + "failed to wait for FrameGen%u secondary syncup\n",
> + fg->id);
> + return -ETIMEDOUT;
> + }
> +
> + dev_dbg(fg->dpu->dev, "FrameGen%u secondary syncup\n", fg->id);
> +
> + return 0;
> +}
> +
> +void dpu_fg_enable_clock(struct dpu_framegen *fg)
> +{
> + clk_prepare_enable(fg->clk_pll);
> + clk_prepare_enable(fg->clk_disp);
> +}
> +
> +void dpu_fg_disable_clock(struct dpu_framegen *fg)
> +{
> + clk_disable_unprepare(fg->clk_disp);
> + clk_disable_unprepare(fg->clk_pll);
> +}
> +
> +struct dpu_framegen *dpu_fg_get(struct dpu_soc *dpu, unsigned int id)
> +{
> + struct dpu_framegen *fg;
> + int i;
> +
> + for (i = 0; i < ARRAY_SIZE(dpu->fg_priv); i++) {
> + fg = dpu->fg_priv[i];
> + if (fg->id == id)
> + break;
> + }
> +
> + if (i == ARRAY_SIZE(dpu->fg_priv))
> + return ERR_PTR(-EINVAL);
> +
> + mutex_lock(&fg->mutex);
> +
> + if (fg->inuse) {
> + mutex_unlock(&fg->mutex);
> + return ERR_PTR(-EBUSY);
> + }
> +
> + fg->inuse = true;
> +
> + mutex_unlock(&fg->mutex);
> +
> + return fg;
> +}
> +
> +void dpu_fg_put(struct dpu_framegen *fg)
> +{
> + if (IS_ERR_OR_NULL(fg))
> + return;
> +
> + mutex_lock(&fg->mutex);
> +
> + fg->inuse = false;
> +
> + mutex_unlock(&fg->mutex);
> +}
> +
> +void dpu_fg_hw_init(struct dpu_soc *dpu, unsigned int index)
> +{
> + struct dpu_framegen *fg = dpu->fg_priv[index];
> +
> + dpu_fg_enable_shden(fg);
> + dpu_fg_syncmode(fg, FG_SYNCMODE_OFF);
> +}
> +
> +int dpu_fg_init(struct dpu_soc *dpu, unsigned int index,
> + unsigned int id, enum dpu_unit_type type,
> + unsigned long unused, unsigned long base)
> +{
> + struct dpu_framegen *fg;
> +
> + fg = devm_kzalloc(dpu->dev, sizeof(*fg), GFP_KERNEL);
> + if (!fg)
> + return -ENOMEM;
> +
> + dpu->fg_priv[index] = fg;
> +
> + fg->base = devm_ioremap(dpu->dev, base, SZ_256);
> + if (!fg->base)
> + return -ENOMEM;
> +
> + fg->clk_pll = devm_clk_get(dpu->dev, id ? "pll1" : "pll0");
> + if (IS_ERR(fg->clk_pll))
> + return PTR_ERR(fg->clk_pll);
> +
> + fg->clk_disp = devm_clk_get(dpu->dev, id ? "disp1" : "disp0");
> + if (IS_ERR(fg->clk_disp))
> + return PTR_ERR(fg->clk_disp);
> +
> + fg->dpu = dpu;
> + fg->id = id;
> + fg->index = index;
> +
> + mutex_init(&fg->mutex);
> +
> + return 0;
> +}
> diff --git a/drivers/gpu/drm/imx/dpu/dpu-gammacor.c b/drivers/gpu/drm/imx/dpu/dpu-gammacor.c
> new file mode 100644
> index 00000000..8f9214f
> --- /dev/null
> +++ b/drivers/gpu/drm/imx/dpu/dpu-gammacor.c
> @@ -0,0 +1,223 @@
> +// SPDX-License-Identifier: GPL-2.0+
> +
> +/*
> + * Copyright 2020 NXP
> + */
> +
> +#include <linux/io.h>
> +#include <linux/kernel.h>
> +#include <linux/mutex.h>
> +#include <linux/sizes.h>
> +
> +#include "dpu.h"
> +#include "dpu-prv.h"
> +
> +#define STATICCONTROL 0x8
> +#define BLUEWRITEENABLE BIT(1)
> +#define GREENWRITEENABLE BIT(2)
> +#define REDWRITEENABLE BIT(3)
> +#define COLORWRITEENABLE (REDWRITEENABLE | \
> + GREENWRITEENABLE | \
> + BLUEWRITEENABLE)
> +
> +#define LUTSTART 0xc
> +#define STARTBLUE(n) ((n) & 0x3ff)
> +#define STARTGREEN(n) (((n) & 0x3ff) << 10)
> +#define STARTRED(n) (((n) & 0x3ff) << 20)
> +
> +#define LUTDELTAS 0x10
> +#define DELTABLUE(n) ((n) & 0x3ff)
> +#define DELTAGREEN(n) (((n) & 0x3ff) << 10)
> +#define DELTARED(n) (((n) & 0x3ff) << 20)
> +
> +#define CONTROL 0x14
> +#define CTRL_MODE_MASK BIT(0)
> +#define ALHPAMASK BIT(4)
> +#define ALHPAINVERT BIT(5)
> +
> +/* 16-bit to 10-bit */
> +#define GAMMACOR_COL_CONVERT(n) (((n) * 0x3ff) / 0xffff)
> +
> +struct dpu_gammacor {
> + void __iomem *base;
> + struct mutex mutex;
> + unsigned int id;
> + unsigned int index;
> + bool inuse;
> + struct dpu_soc *dpu;
> +};
> +
> +static inline u32 dpu_gc_read(struct dpu_gammacor *gc, unsigned int offset)
> +{
> + return readl(gc->base + offset);
> +}
> +
> +static inline void dpu_gc_write(struct dpu_gammacor *gc,
> + unsigned int offset, u32 value)
> +{
> + writel(value, gc->base + offset);
> +}
> +
> +static inline void dpu_gc_write_mask(struct dpu_gammacor *gc,
> + unsigned int offset, u32 mask, u32 value)
> +{
> + u32 tmp;
> +
> + tmp = dpu_gc_read(gc, offset);
> + tmp &= ~mask;
> + dpu_gc_write(gc, offset, tmp | value);
> +}
> +
> +static void dpu_gc_enable_shden(struct dpu_gammacor *gc)
> +{
> + dpu_gc_write_mask(gc, STATICCONTROL, SHDEN, SHDEN);
> +}
> +
> +void dpu_gc_enable_rgb_write(struct dpu_gammacor *gc)
> +{
> + dpu_gc_write_mask(gc, STATICCONTROL, COLORWRITEENABLE, COLORWRITEENABLE);
> +}
> +
> +void dpu_gc_disable_rgb_write(struct dpu_gammacor *gc)
> +{
> + dpu_gc_write_mask(gc, STATICCONTROL, COLORWRITEENABLE, 0);
> +}
> +
> +static inline void
> +dpu_gc_sample_point_color_convert(u32 *red, u32 *green, u32 *blue)
> +{
> + *red = GAMMACOR_COL_CONVERT(*red);
> + *green = GAMMACOR_COL_CONVERT(*green);
> + *blue = GAMMACOR_COL_CONVERT(*blue);
> +}
> +
> +void dpu_gc_start_rgb(struct dpu_gammacor *gc, const struct drm_color_lut *lut)
> +{
> + struct dpu_soc *dpu = gc->dpu;
> + u32 r = lut[0].red, g = lut[0].green, b = lut[0].blue;
> +
> + dpu_gc_sample_point_color_convert(&r, &g, &b);
> +
> + dpu_gc_write(gc, LUTSTART, STARTRED(r) | STARTGREEN(g) | STARTBLUE(b));
> +
> + dev_dbg(dpu->dev, "GammaCor%u LUT start:\t r-0x%03x g-0x%03x b-0x%03x\n",
> + gc->id, r, g, b);
> +}
> +
> +void dpu_gc_delta_rgb(struct dpu_gammacor *gc, const struct drm_color_lut *lut)
> +{
> + struct dpu_soc *dpu = gc->dpu;
> + int i, curr, next;
> + u32 dr, dg, db;
> +
> + /* The first delta value is zero. */
> + dpu_gc_write(gc, LUTDELTAS, DELTARED(0) | DELTAGREEN(0) | DELTABLUE(0));
> +
> + /*
> + * Assuming gamma_size = 256, we get additional 32 delta
> + * values for every 8 sample points, so 33 delta values for
> + * 33 sample points in total as the GammaCor unit requires.
> + * A curve with 10-bit resolution will be generated in the
> + * GammaCor unit internally by a linear interpolation in-between
> + * the sample points. Note that the last value in the lookup
> + * table is lut[255].
> + */
> + for (i = 0; i < 32; i++) {
> + curr = i * 8;
> + next = curr + 8;
> +
> + if (next == 256)
> + next--;
> +
> + dr = lut[next].red - lut[curr].red;
> + dg = lut[next].green - lut[curr].green;
> + db = lut[next].blue - lut[curr].blue;
> +
> + dpu_gc_sample_point_color_convert(&dr, &dg, &db);
> +
> + dpu_gc_write(gc, LUTDELTAS,
> + DELTARED(dr) | DELTAGREEN(dg) | DELTABLUE(db));
> +
> + dev_dbg(dpu->dev,
> + "GammaCor%u delta[%d]:\t r-0x%03x g-0x%03x b-0x%03x\n",
> + gc->id, i + 1, dr, dg, db);
> + }
> +}
> +
> +void dpu_gc_mode(struct dpu_gammacor *gc, enum dpu_gc_mode mode)
> +{
> + dpu_gc_write_mask(gc, CONTROL, CTRL_MODE_MASK, mode);
> +}
> +
> +struct dpu_gammacor *dpu_gc_get(struct dpu_soc *dpu, unsigned int id)
> +{
> + struct dpu_gammacor *gc;
> + int i;
> +
> + for (i = 0; i < ARRAY_SIZE(dpu->gc_priv); i++) {
> + gc = dpu->gc_priv[i];
> + if (gc->id == id)
> + break;
> + }
> +
> + if (i == ARRAY_SIZE(dpu->gc_priv))
> + return ERR_PTR(-EINVAL);
> +
> + mutex_lock(&gc->mutex);
> +
> + if (gc->inuse) {
> + mutex_unlock(&gc->mutex);
> + return ERR_PTR(-EBUSY);
> + }
> +
> + gc->inuse = true;
> +
> + mutex_unlock(&gc->mutex);
> +
> + return gc;
> +}
> +
> +void dpu_gc_put(struct dpu_gammacor *gc)
> +{
> + if (IS_ERR_OR_NULL(gc))
> + return;
> +
> + mutex_lock(&gc->mutex);
> +
> + gc->inuse = false;
> +
> + mutex_unlock(&gc->mutex);
> +}
> +
> +void dpu_gc_hw_init(struct dpu_soc *dpu, unsigned int index)
> +{
> + struct dpu_gammacor *gc = dpu->gc_priv[index];
> +
> + dpu_gc_write(gc, CONTROL, 0);
> + dpu_gc_enable_shden(gc);
> +}
> +
> +int dpu_gc_init(struct dpu_soc *dpu, unsigned int index,
> + unsigned int id, enum dpu_unit_type type,
> + unsigned long unused, unsigned long base)
> +{
> + struct dpu_gammacor *gc;
> +
> + gc = devm_kzalloc(dpu->dev, sizeof(*gc), GFP_KERNEL);
> + if (!gc)
> + return -ENOMEM;
> +
> + dpu->gc_priv[index] = gc;
> +
> + gc->base = devm_ioremap(dpu->dev, base, SZ_32);
> + if (!gc->base)
> + return -ENOMEM;
> +
> + gc->dpu = dpu;
> + gc->id = id;
> + gc->index = index;
> +
> + mutex_init(&gc->mutex);
> +
> + return 0;
> +}
> diff --git a/drivers/gpu/drm/imx/dpu/dpu-hscaler.c b/drivers/gpu/drm/imx/dpu/dpu-hscaler.c
> new file mode 100644
> index 00000000..8b3b1dd
> --- /dev/null
> +++ b/drivers/gpu/drm/imx/dpu/dpu-hscaler.c
> @@ -0,0 +1,275 @@
> +// SPDX-License-Identifier: GPL-2.0+
> +
> +/*
> + * Copyright 2017-2020 NXP
> + */
> +
> +#include <linux/io.h>
> +#include <linux/kernel.h>
> +#include <linux/mutex.h>
> +#include <linux/sizes.h>
> +
> +#include "dpu.h"
> +#include "dpu-prv.h"
> +
> +#define PIXENGCFG_DYNAMIC 0x8
> +#define PIXENGCFG_DYNAMIC_SRC_SEL_MASK 0x3f
> +
> +#define STATICCONTROL 0x8
> +#define SETUP1 0xc
> +#define SETUP2 0x10
> +
> +#define CONTROL 0x14
> +#define CTRL_MODE_MASK BIT(0)
> +
> +struct dpu_hscaler {
> + void __iomem *pec_base;
> + void __iomem *base;
> + struct mutex mutex;
> + unsigned int id;
> + unsigned int index;
> + enum dpu_link_id link_id;
> + bool inuse;
> + struct dpu_soc *dpu;
> +};
> +
> +static const enum dpu_link_id dpu_hs_link_id[] = {
> + LINK_ID_HSCALER4, LINK_ID_HSCALER5, LINK_ID_HSCALER9
> +};
> +
> +static const enum dpu_link_id src_sels[3][4] = {
> + {
> + LINK_ID_NONE,
> + LINK_ID_FETCHDECODE0,
> + LINK_ID_MATRIX4,
> + LINK_ID_VSCALER4,
> + }, {
> + LINK_ID_NONE,
> + LINK_ID_FETCHDECODE1,
> + LINK_ID_MATRIX5,
> + LINK_ID_VSCALER5,
> + }, {
> + LINK_ID_NONE,
> + LINK_ID_MATRIX9,
> + LINK_ID_VSCALER9,
> + LINK_ID_FILTER9,
> + },
> +};
> +
> +static inline u32 dpu_pec_hs_read(struct dpu_hscaler *hs,
> + unsigned int offset)
> +{
> + return readl(hs->pec_base + offset);
> +}
> +
> +static inline void dpu_pec_hs_write(struct dpu_hscaler *hs,
> + unsigned int offset, u32 value)
> +{
> + writel(value, hs->pec_base + offset);
> +}
> +
> +static inline void dpu_pec_hs_write_mask(struct dpu_hscaler *hs,
> + unsigned int offset,
> + u32 mask, u32 value)
> +{
> + u32 tmp;
> +
> + tmp = dpu_pec_hs_read(hs, offset);
> + tmp &= ~mask;
> + dpu_pec_hs_write(hs, offset, tmp | value);
> +}
> +
> +static inline u32 dpu_hs_read(struct dpu_hscaler *hs, unsigned int offset)
> +{
> + return readl(hs->base + offset);
> +}
> +
> +static inline void dpu_hs_write(struct dpu_hscaler *hs,
> + unsigned int offset, u32 value)
> +{
> + writel(value, hs->base + offset);
> +}
> +
> +static inline void dpu_hs_write_mask(struct dpu_hscaler *hs,
> + unsigned int offset, u32 mask, u32 value)
> +{
> + u32 tmp;
> +
> + tmp = dpu_hs_read(hs, offset);
> + tmp &= ~mask;
> + dpu_hs_write(hs, offset, tmp | value);
> +}
> +
> +enum dpu_link_id dpu_hs_get_link_id(struct dpu_hscaler *hs)
> +{
> + return hs->link_id;
> +}
> +
> +void dpu_hs_pec_dynamic_src_sel(struct dpu_hscaler *hs, enum dpu_link_id src)
> +{
> + struct dpu_soc *dpu = hs->dpu;
> + int i;
> +
> + for (i = 0; i < ARRAY_SIZE(src_sels[hs->index]); i++) {
> + if (src_sels[hs->index][i] == src) {
> + dpu_pec_hs_write_mask(hs, PIXENGCFG_DYNAMIC,
> + PIXENGCFG_DYNAMIC_SRC_SEL_MASK,
> + src);
> + return;
> + }
> + }
> +
> + dev_err(dpu->dev, "HScaler%u - invalid source 0x%02x\n", hs->id, src);
> +}
> +
> +void dpu_hs_pec_clken(struct dpu_hscaler *hs, enum dpu_pec_clken clken)
> +{
> + dpu_pec_hs_write_mask(hs, PIXENGCFG_DYNAMIC, CLKEN_MASK, CLKEN(clken));
> +}
> +
> +static void dpu_hs_enable_shden(struct dpu_hscaler *hs)
> +{
> + dpu_hs_write_mask(hs, STATICCONTROL, SHDEN, SHDEN);
> +}
> +
> +void dpu_hs_setup1(struct dpu_hscaler *hs,
> + unsigned int src_w, unsigned int dst_w)
> +{
> + struct dpu_soc *dpu = hs->dpu;
> + u32 scale_factor;
> + u64 tmp64;
> +
> + if (src_w == dst_w) {
> + scale_factor = 0x80000;
> + } else {
> + if (src_w > dst_w) {
> + tmp64 = (u64)((u64)dst_w * 0x80000);
> + do_div(tmp64, src_w);
> +
> + } else {
> + tmp64 = (u64)((u64)src_w * 0x80000);
> + do_div(tmp64, dst_w);
> + }
> + scale_factor = (u32)tmp64;
> + }
> +
> + if (scale_factor > 0x80000) {
> + dev_err(dpu->dev, "HScaler%u - invalid scale factor 0x%08x\n",
> + hs->id, scale_factor);
> + return;
> + }
> +
> + dpu_hs_write(hs, SETUP1, SCALE_FACTOR(scale_factor));
> +
> + dev_dbg(dpu->dev, "HScaler%u - scale factor 0x%08x\n",
> + hs->id, scale_factor);
> +}
> +
> +void dpu_hs_setup2(struct dpu_hscaler *hs, u32 phase_offset)
> +{
> + dpu_hs_write(hs, SETUP2, PHASE_OFFSET(phase_offset));
> +}
> +
> +void dpu_hs_output_size(struct dpu_hscaler *hs, u32 line_num)
> +{
> + dpu_hs_write_mask(hs, CONTROL, OUTPUT_SIZE_MASK, OUTPUT_SIZE(line_num));
> +}
> +
> +void dpu_hs_filter_mode(struct dpu_hscaler *hs, enum dpu_scaler_filter_mode m)
> +{
> + dpu_hs_write_mask(hs, CONTROL, FILTER_MODE_MASK, FILTER_MODE(m));
> +}
> +
> +void dpu_hs_scale_mode(struct dpu_hscaler *hs, enum dpu_scaler_scale_mode m)
> +{
> + dpu_hs_write_mask(hs, CONTROL, SCALE_MODE_MASK, SCALE_MODE(m));
> +}
> +
> +void dpu_hs_mode(struct dpu_hscaler *hs, enum dpu_scaler_mode m)
> +{
> + dpu_hs_write_mask(hs, CONTROL, CTRL_MODE_MASK, m);
> +}
> +
> +unsigned int dpu_hs_get_id(struct dpu_hscaler *hs)
> +{
> + return hs->id;
> +}
> +
> +struct dpu_hscaler *dpu_hs_get(struct dpu_soc *dpu, unsigned int id)
> +{
> + struct dpu_hscaler *hs;
> + int i;
> +
> + for (i = 0; i < ARRAY_SIZE(dpu->hs_priv); i++) {
> + hs = dpu->hs_priv[i];
> + if (hs->id == id)
> + break;
> + }
> +
> + if (i == ARRAY_SIZE(dpu->hs_priv))
> + return ERR_PTR(-EINVAL);
> +
> + mutex_lock(&hs->mutex);
> +
> + if (hs->inuse) {
> + mutex_unlock(&hs->mutex);
> + return ERR_PTR(-EBUSY);
> + }
> +
> + hs->inuse = true;
> +
> + mutex_unlock(&hs->mutex);
> +
> + return hs;
> +}
> +
> +void dpu_hs_put(struct dpu_hscaler *hs)
> +{
> + if (IS_ERR_OR_NULL(hs))
> + return;
> +
> + mutex_lock(&hs->mutex);
> +
> + hs->inuse = false;
> +
> + mutex_unlock(&hs->mutex);
> +}
> +
> +void dpu_hs_hw_init(struct dpu_soc *dpu, unsigned int index)
> +{
> + struct dpu_hscaler *hs = dpu->hs_priv[index];
> +
> + dpu_hs_enable_shden(hs);
> + dpu_hs_setup2(hs, 0);
> + dpu_hs_pec_dynamic_src_sel(hs, LINK_ID_NONE);
> +}
> +
> +int dpu_hs_init(struct dpu_soc *dpu, unsigned int index,
> + unsigned int id, enum dpu_unit_type type,
> + unsigned long pec_base, unsigned long base)
> +{
> + struct dpu_hscaler *hs;
> +
> + hs = devm_kzalloc(dpu->dev, sizeof(*hs), GFP_KERNEL);
> + if (!hs)
> + return -ENOMEM;
> +
> + dpu->hs_priv[index] = hs;
> +
> + hs->pec_base = devm_ioremap(dpu->dev, pec_base, SZ_16);
> + if (!hs->pec_base)
> + return -ENOMEM;
> +
> + hs->base = devm_ioremap(dpu->dev, base, SZ_32);
> + if (!hs->base)
> + return -ENOMEM;
> +
> + hs->dpu = dpu;
> + hs->id = id;
> + hs->index = index;
> + hs->link_id = dpu_hs_link_id[index];
> +
> + mutex_init(&hs->mutex);
> +
> + return 0;
> +}
> diff --git a/drivers/gpu/drm/imx/dpu/dpu-kms.c b/drivers/gpu/drm/imx/dpu/dpu-kms.c
> new file mode 100644
> index 00000000..cc008e4
> --- /dev/null
> +++ b/drivers/gpu/drm/imx/dpu/dpu-kms.c
> @@ -0,0 +1,540 @@
> +// SPDX-License-Identifier: GPL-2.0+
> +
> +/*
> + * Copyright 2017-2020 NXP
> + */
> +
> +#include <linux/list.h>
> +#include <linux/of.h>
> +#include <linux/of_graph.h>
> +#include <linux/slab.h>
> +#include <linux/sort.h>
> +
> +#include <drm/drm_atomic.h>
> +#include <drm/drm_atomic_helper.h>
> +#include <drm/drm_bridge.h>
> +#include <drm/drm_bridge_connector.h>
> +#include <drm/drm_gem_framebuffer_helper.h>
> +#include <drm/drm_managed.h>
> +#include <drm/drm_simple_kms_helper.h>
> +
> +#include "dpu.h"
> +#include "dpu-crtc.h"
> +#include "dpu-drv.h"
> +#include "dpu-kms.h"
> +#include "dpu-plane.h"
> +
> +static int zpos_cmp(const void *a, const void *b)
> +{
> + const struct drm_plane_state *sa = *(struct drm_plane_state **)a;
> + const struct drm_plane_state *sb = *(struct drm_plane_state **)b;
> +
> + return sa->normalized_zpos - sb->normalized_zpos;
> +}
> +
> +static int dpu_atomic_sort_planes_per_crtc(struct drm_crtc_state *crtc_state,
> + struct drm_plane_state **plane_states)
> +{
> + struct drm_atomic_state *state = crtc_state->state;
> + struct drm_plane *plane;
> + int n = 0;
> +
> + drm_atomic_crtc_state_for_each_plane(plane, crtc_state) {
> + struct drm_plane_state *plane_state =
> + drm_atomic_get_plane_state(state, plane);
> + if (IS_ERR(plane_state))
> + return PTR_ERR(plane_state);
> + plane_states[n++] = plane_state;
> + }
> +
> + sort(plane_states, n, sizeof(*plane_states), zpos_cmp, NULL);
> +
> + return n;
> +}
> +
> +static void
> +dpu_atomic_set_top_plane_per_crtc(struct drm_plane_state **plane_states, int n)
> +{
> + struct dpu_plane_state *dpstate;
> + int i;
> +
> + for (i = 0; i < n; i++) {
> + dpstate = to_dpu_plane_state(plane_states[i]);
> + dpstate->is_top = (i == (n - 1)) ? true : false;
> + }
> +}
> +
> +static int
> +dpu_atomic_assign_plane_source_per_crtc(struct dpu_crtc *dpu_crtc,
> + struct drm_plane_state **plane_states,
> + int n, bool use_current_source)
> +{
> + struct drm_plane_state *plane_state;
> + struct dpu_plane_state *dpstate;
> + struct dpu_plane *dplane;
> + struct dpu_plane_grp *grp;
> + struct dpu_plane_res *res;
> + struct drm_framebuffer *fb;
> + struct dpu_fetchunit *fu;
> + struct list_head *node;
> + const struct dpu_fetchunit_ops *fu_ops;
> + union dpu_plane_stage stage;
> + struct dpu_layerblend *blend;
> + unsigned int sid = dpu_crtc->stream_id;
> + int i, j;
> + u32 src_w, src_h, dst_w, dst_h;
> + u32 cap_mask;
> + bool fb_is_packed_yuv422, fb_is_interlaced;
> + bool need_fetcheco, need_hscaler, need_vscaler;
> + bool found_fu;
> +
> + /* for active planes only */
> + for (i = 0; i < n; i++) {
> + plane_state = plane_states[i];
> + dpstate = to_dpu_plane_state(plane_state);
> +
> + /*
> + * If modeset is not allowed, use the current source for
> + * the prone-to-put planes so that unnecessary updates and
> + * spurious EBUSY can be avoided.
> + */
> + if (use_current_source) {
> + fu_ops = dpu_fu_get_ops(dpstate->source);
> + fu_ops->set_inavailable(dpstate->source);
> + continue;
> + }
> +
> + dplane = to_dpu_plane(plane_state->plane);
> + fb = plane_state->fb;
> + grp = dplane->grp;
> + res = &grp->res;
> +
> + src_w = plane_state->src_w >> 16;
> + src_h = plane_state->src_h >> 16;
> + dst_w = plane_state->crtc_w;
> + dst_h = plane_state->crtc_h;
> +
> + fb_is_packed_yuv422 =
> + drm_format_info_is_yuv_packed(fb->format) &&
> + drm_format_info_is_yuv_sampling_422(fb->format);
> + fb_is_interlaced = !!(fb->flags & DRM_MODE_FB_INTERLACED);
> + need_fetcheco = fb->format->num_planes > 1;
> + need_hscaler = src_w != dst_w;
> + need_vscaler = (src_h != dst_h) || fb_is_interlaced;
> +
> + cap_mask = 0;
> + if (need_fetcheco)
> + cap_mask |= DPU_FETCHUNIT_CAP_USE_FETCHECO;
> + if (need_hscaler || need_vscaler)
> + cap_mask |= DPU_FETCHUNIT_CAP_USE_SCALER;
> + if (fb_is_packed_yuv422)
> + cap_mask |= DPU_FETCHUNIT_CAP_PACKED_YUV422;
> +
> + /* assign source */
> + found_fu = false;
> + list_for_each(node, &grp->fu_list) {
> + fu = dpu_fu_get_from_list(node);
> +
> + fu_ops = dpu_fu_get_ops(fu);
> +
> + /* available? */
> + if (!fu_ops->is_available(fu))
> + continue;
> +
> + /* enough capability? */
> + if ((cap_mask & fu_ops->get_cap_mask(fu)) != cap_mask)
> + continue;
> +
> + /* avoid fetchunit hot migration */
> + if (fu_ops->has_stream_id(fu) &&
> + fu_ops->get_stream_id(fu) != sid)
> + continue;
> +
> + fu_ops->set_inavailable(fu);
> + found_fu = true;
> + break;
> + }
> +
> + if (!found_fu)
> + return -EINVAL;
> +
> + dpstate->source = fu;
> +
> + /* assign stage and blend */
> + if (sid) {
> + j = grp->hw_plane_cnt - (n - i);
> + blend = res->lb[j];
> + if (i == 0)
> + stage.cf = grp->cf[sid];
> + else
> + stage.lb = res->lb[j - 1];
> + } else {
> + blend = res->lb[i];
> + if (i == 0)
> + stage.cf = grp->cf[sid];
> + else
> + stage.lb = res->lb[i - 1];
> + }
> +
> + dpstate->stage = stage;
> + dpstate->blend = blend;
> + }
> +
> + return 0;
> +}
> +
> +static int dpu_atomic_assign_plane_source(struct drm_atomic_state *state,
> + u32 crtc_mask_prone_to_put,
> + bool prone_to_put)
> +{
> + struct drm_crtc *crtc;
> + struct drm_crtc_state *crtc_state;
> + struct dpu_crtc *dpu_crtc;
> + struct drm_plane_state **plane_states;
> + bool use_current_source;
> + int i, n;
> + int ret = 0;
> +
> + use_current_source = !state->allow_modeset && prone_to_put;
> +
> + for_each_new_crtc_in_state(state, crtc, crtc_state, i) {
> + /* Skip if no active plane. */
> + if (crtc_state->plane_mask == 0)
> + continue;
> +
> + if (prone_to_put !=
> + !!(drm_crtc_mask(crtc) & crtc_mask_prone_to_put))
> + continue;
> +
> + dpu_crtc = to_dpu_crtc(crtc);
> +
> + plane_states = kmalloc_array(dpu_crtc->hw_plane_cnt,
> + sizeof(*plane_states), GFP_KERNEL);
> + if (!plane_states) {
> + ret = -ENOMEM;
> + dpu_crtc_dbg(crtc,
> + "failed to alloc plane state ptrs: %d\n",
> + ret);
> + return ret;
> + }
> +
> + n = dpu_atomic_sort_planes_per_crtc(crtc_state, plane_states);
> + if (n < 0) {
> + dpu_crtc_dbg(crtc, "failed to sort planes: %d\n", n);
> + kfree(plane_states);
> + return n;
> + }
> +
> + dpu_atomic_set_top_plane_per_crtc(plane_states, n);
> +
> + ret = dpu_atomic_assign_plane_source_per_crtc(dpu_crtc,
> + plane_states, n, use_current_source);
> + if (ret) {
> + dpu_crtc_dbg(crtc,
> + "failed to assign resource to plane: %d\n",
> + ret);
> + kfree(plane_states);
> + return ret;
> + }
> +
> + kfree(plane_states);
> + }
> +
> + return ret;
> +}
> +
> +static void dpu_atomic_put_plane_state(struct drm_atomic_state *state,
> + struct drm_plane *plane)
> +{
> + int index = drm_plane_index(plane);
> +
> + plane->funcs->atomic_destroy_state(plane, state->planes[index].state);
> + state->planes[index].ptr = NULL;
> + state->planes[index].state = NULL;
> + state->planes[index].old_state = NULL;
> + state->planes[index].new_state = NULL;
> +
> + drm_modeset_unlock(&plane->mutex);
> +
> + dpu_plane_dbg(plane, "put state\n");
> +}
> +
> +static void dpu_atomic_put_crtc_state(struct drm_atomic_state *state,
> + struct drm_crtc *crtc)
> +{
> + int index = drm_crtc_index(crtc);
> +
> + crtc->funcs->atomic_destroy_state(crtc, state->crtcs[index].state);
> + state->crtcs[index].ptr = NULL;
> + state->crtcs[index].state = NULL;
> + state->crtcs[index].old_state = NULL;
> + state->crtcs[index].new_state = NULL;
> +
> + drm_modeset_unlock(&crtc->mutex);
> +
> + dpu_crtc_dbg(crtc, "put state\n");
> +}
> +
> +static void
> +dpu_atomic_put_possible_states_per_crtc(struct drm_crtc_state *crtc_state)
> +{
> + struct drm_atomic_state *state = crtc_state->state;
> + struct drm_crtc *crtc = crtc_state->crtc;
> + struct drm_plane *plane;
> + struct drm_plane_state *old_plane_state, *new_plane_state;
> + struct dpu_plane_state *old_dpstate, *new_dpstate;
> +
> + drm_atomic_crtc_state_for_each_plane(plane, crtc_state) {
> + old_plane_state = drm_atomic_get_old_plane_state(state, plane);
> + new_plane_state = drm_atomic_get_new_plane_state(state, plane);
> +
> + old_dpstate = to_dpu_plane_state(old_plane_state);
> + new_dpstate = to_dpu_plane_state(new_plane_state);
> +
> + /* Should be enough to check the below HW plane resources. */
> + if (old_dpstate->stage.ptr != new_dpstate->stage.ptr ||
> + old_dpstate->source != new_dpstate->source ||
> + old_dpstate->blend != new_dpstate->blend)
> + return;
> + }
> +
> + drm_atomic_crtc_state_for_each_plane(plane, crtc_state)
> + dpu_atomic_put_plane_state(state, plane);
> +
> + dpu_atomic_put_crtc_state(state, crtc);
> +}
> +
> +static int dpu_drm_atomic_check(struct drm_device *dev,
> + struct drm_atomic_state *state)
> +{
> + struct drm_crtc *crtc;
> + struct drm_crtc_state *crtc_state;
> + struct dpu_crtc *dpu_crtc;
> + struct dpu_plane_grp *plane_grp;
> + struct dpu_fetchunit *fu;
> + struct list_head *node;
> + const struct dpu_fetchunit_ops *fu_ops;
> + u32 crtc_mask_in_state = 0;
> + u32 crtc_mask_in_grps = 0;
> + u32 crtc_mask_prone_to_put;
> + int ret, i;
> +
> + ret = drm_atomic_helper_check_modeset(dev, state);
> + if (ret)
> + return ret;
> +
> + /* Set crtc_mask_in_state and crtc_mask_in_grps. */
> + for_each_new_crtc_in_state(state, crtc, crtc_state, i) {
> + dpu_crtc = to_dpu_crtc(crtc);
> +
> + crtc_mask_in_state |= drm_crtc_mask(crtc);
> + crtc_mask_in_grps |= dpu_crtc->grp->crtc_mask;
> + }
> +
> + /*
> + * Those CRTCs in groups but not in the state for check
> + * are prone to put, because HW resources of their active
> + * planes are likely unchanged.
> + */
> + crtc_mask_prone_to_put = crtc_mask_in_grps ^ crtc_mask_in_state;
> +
> + /*
> + * For those CRTCs prone to put, get their CRTC states as well,
> + * so that all relevant active plane states can be got when
> + * assigning HW resources to them later on.
> + */
> + drm_for_each_crtc(crtc, dev) {
> + if ((drm_crtc_mask(crtc) & crtc_mask_prone_to_put) == 0)
> + continue;
> +
> + crtc_state = drm_atomic_get_crtc_state(state, crtc);
> + if (IS_ERR(crtc_state))
> + return PTR_ERR(crtc_state);
> + }
> +
> + /*
> + * Set all the fetchunits in the plane groups in question
> + * to be available, so that they can be assigned to planes.
> + */
> + for_each_new_crtc_in_state(state, crtc, crtc_state, i) {
> + dpu_crtc = to_dpu_crtc(crtc);
> +
> + /* Skip the CRTC with stream ID1 in a CRTC group. */
> + if (dpu_crtc->stream_id == 1)
> + continue;
> +
> + plane_grp = dpu_crtc->grp->plane_grp;
> +
> + list_for_each(node, &plane_grp->fu_list) {
> + fu = dpu_fu_get_from_list(node);
> + fu_ops = dpu_fu_get_ops(fu);
> + fu_ops->set_available(fu);
> + }
> + }
> +
> + ret = drm_atomic_normalize_zpos(dev, state);
> + if (ret) {
> + drm_dbg_kms(dev, "failed to normalize zpos: %d\n", ret);
> + return ret;
> + }
> +
> + /*
> + * Assign HW resources to planes in question.
> + * It is likely to fail due to some reasons, e.g., no enough
> + * fetchunits, users ask for more features than the HW resources
> + * can provide, HW resource hot-migration bewteen CRTCs is needed.
> + *
> + * Do the assignment for the prone-to-put CRTCs first, as we want
> + * the planes of them to use the current sources if modeset is not
> + * allowed.
> + */
> + ret = dpu_atomic_assign_plane_source(state,
> + crtc_mask_prone_to_put, true);
> + if (ret) {
> + drm_dbg_kms(dev,
> + "failed to assign source to prone-to-put plane: %d\n",
> + ret);
> + return ret;
> + }
> + ret = dpu_atomic_assign_plane_source(state,
> + crtc_mask_prone_to_put, false);
> + if (ret) {
> + drm_dbg_kms(dev, "failed to assign source to plane: %d\n", ret);
> + return ret;
> + }
> +
> + /*
> + * To gain some performance, put those CRTC and plane states
> + * which can be put.
> + */
> + drm_for_each_crtc(crtc, dev) {
> + if (crtc_mask_prone_to_put & drm_crtc_mask(crtc)) {
> + crtc_state = drm_atomic_get_new_crtc_state(state, crtc);
> + if (WARN_ON(!crtc_state))
> + return -EINVAL;
> +
> + dpu_atomic_put_possible_states_per_crtc(crtc_state);
> + }
> + }
> +
> + return drm_atomic_helper_check_planes(dev, state);
> +}
> +
> +static const struct drm_mode_config_funcs dpu_drm_mode_config_funcs = {
> + .fb_create = drm_gem_fb_create,
> + .atomic_check = dpu_drm_atomic_check,
> + .atomic_commit = drm_atomic_helper_commit,
> +};
> +
> +static int dpu_kms_init_encoder_per_crtc(struct drm_device *drm,
> + struct dpu_crtc *dpu_crtc)
> +{
> + struct drm_encoder *encoder = dpu_crtc->encoder;
> + struct drm_bridge *bridge;
> + struct drm_connector *connector;
> + struct device_node *ep, *remote;
> + int ret = 0;
> +
> + ep = of_get_next_child(dpu_crtc->np, NULL);
> + if (!ep) {
> + drm_err(drm, "failed to find CRTC port's endpoint\n");
> + return -ENODEV;
> + }
> +
> + remote = of_graph_get_remote_port_parent(ep);
> + if (!remote || !of_device_is_available(remote))
> + goto out;
> + else if (!of_device_is_available(remote->parent))
> + goto out;
> +
> + bridge = of_drm_find_bridge(remote);
> + if (!bridge) {
> + ret = -EPROBE_DEFER;
> + drm_dbg_kms(drm, "CRTC(%pOF) failed to find bridge: %d\n",
> + dpu_crtc->np, ret);
> + goto out;
> + }
> +
> + ret = drm_simple_encoder_init(drm, encoder, DRM_MODE_ENCODER_NONE);
> + if (ret) {
> + drm_err(drm, "failed to initialize encoder: %d\n", ret);
> + goto out;
> + }
> +
> + ret = drm_bridge_attach(encoder, bridge, NULL,
> + DRM_BRIDGE_ATTACH_NO_CONNECTOR);
> + if (ret) {
> + drm_err(drm, "failed to attach bridge to encoder: %d\n", ret);
> + goto out;
> + }
> +
> + connector = drm_bridge_connector_init(drm, encoder);
> + if (IS_ERR(connector)) {
> + ret = PTR_ERR(connector);
> + drm_err(drm,
> + "failed to initialize bridge connector: %d\n", ret);
> + goto out;
> + }
> +
> + ret = drm_connector_attach_encoder(connector, encoder);
> + if (ret)
> + drm_err(drm,
> + "failed to attach encoder to connector: %d\n", ret);
> +
> +out:
> + of_node_put(remote);
> + of_node_put(ep);
> + return ret;
> +}
> +
> +int dpu_kms_prepare(struct dpu_drm_device *dpu_drm,
> + struct list_head *crtc_np_list)
> +{
> + struct drm_device *drm = &dpu_drm->base;
> + struct dpu_crtc_of_node *crtc_of_node;
> + struct dpu_crtc *crtc;
> + int ret, n_crtc = 0;
> +
> + INIT_LIST_HEAD(&dpu_drm->crtc_list);
> +
> + list_for_each_entry(crtc_of_node, crtc_np_list, list) {
> + crtc = drmm_kzalloc(drm, sizeof(*crtc), GFP_KERNEL);
> + if (!crtc)
> + return -ENOMEM;
> +
> + crtc->np = crtc_of_node->np;
> +
> + crtc->encoder = drmm_kzalloc(drm, sizeof(*crtc->encoder),
> + GFP_KERNEL);
> + if (!crtc->encoder)
> + return -ENOMEM;
> +
> + list_add(&crtc->node, &dpu_drm->crtc_list);
> +
> + n_crtc++;
> + }
> +
> + ret = drmm_mode_config_init(drm);
> + if (ret)
> + return ret;
> +
> + drm->mode_config.min_width = 60;
> + drm->mode_config.min_height = 60;
> + drm->mode_config.max_width = 8192;
> + drm->mode_config.max_height = 8192;
> + drm->mode_config.funcs = &dpu_drm_mode_config_funcs;
> + drm->mode_config.normalize_zpos = true;
> + drm->max_vblank_count = DPU_FRAMEGEN_MAX_FRAME_INDEX;
> +
> + list_for_each_entry(crtc, &dpu_drm->crtc_list, node) {
> + ret = dpu_kms_init_encoder_per_crtc(drm, crtc);
> + if (ret)
> + return ret;
> + }
> +
> + ret = drm_vblank_init(drm, n_crtc);
> + if (ret)
> + drm_err(drm, "failed to initialize vblank support: %d\n", ret);
> +
> + return ret;
> +}
> diff --git a/drivers/gpu/drm/imx/dpu/dpu-kms.h b/drivers/gpu/drm/imx/dpu/dpu-kms.h
> new file mode 100644
> index 00000000..699a0d1
> --- /dev/null
> +++ b/drivers/gpu/drm/imx/dpu/dpu-kms.h
> @@ -0,0 +1,23 @@
> +/* SPDX-License-Identifier: GPL-2.0+ */
> +
> +/*
> + * Copyright 2019,2020 NXP
> + */
> +
> +#ifndef __DPU_KMS_H__
> +#define __DPU_KMS_H__
> +
> +#include <linux/of.h>
> +#include <linux/types.h>
> +
> +#include "dpu-drv.h"
> +
> +struct dpu_crtc_of_node {
> + struct device_node *np;
> + struct list_head list;
> +};
> +
> +int dpu_kms_prepare(struct dpu_drm_device *dpu_drm,
> + struct list_head *crtc_np_list);
> +
> +#endif
> diff --git a/drivers/gpu/drm/imx/dpu/dpu-layerblend.c b/drivers/gpu/drm/imx/dpu/dpu-layerblend.c
> new file mode 100644
> index 00000000..cc150f4
> --- /dev/null
> +++ b/drivers/gpu/drm/imx/dpu/dpu-layerblend.c
> @@ -0,0 +1,348 @@
> +// SPDX-License-Identifier: GPL-2.0+
> +
> +/*
> + * Copyright (C) 2016 Freescale Semiconductor, Inc.
> + * Copyright 2017-2020 NXP
> + */
> +
> +#include <linux/io.h>
> +#include <linux/kernel.h>
> +#include <linux/mutex.h>
> +#include <linux/sizes.h>
> +
> +#include <drm/drm_blend.h>
> +
> +#include "dpu.h"
> +#include "dpu-prv.h"
> +
> +#define PIXENGCFG_DYNAMIC 0x8
> +#define PIXENGCFG_DYNAMIC_PRIM_SEL_MASK 0x3f
> +#define PIXENGCFG_DYNAMIC_SEC_SEL_SHIFT 8
> +#define PIXENGCFG_DYNAMIC_SEC_SEL_MASK 0x3f00
> +
> +#define PIXENGCFG_STATUS 0xc
> +
> +#define STATICCONTROL 0x8
> +#define SHDTOKSEL_MASK 0x18
> +#define SHDTOKSEL(n) ((n) << 3)
> +#define SHDLDSEL_MASK 0x6
> +#define SHDLDSEL(n) ((n) << 1)
> +
> +#define CONTROL 0xc
> +#define CTRL_MODE_MASK BIT(0)
> +
> +#define BLENDCONTROL 0x10
> +#define ALPHA(a) (((a) & 0xff) << 16)
> +#define PRIM_C_BLD_FUNC__ONE_MINUS_CONST_ALPHA 0x7
> +#define PRIM_C_BLD_FUNC__ONE_MINUS_SEC_ALPHA 0x5
> +#define PRIM_C_BLD_FUNC__ZERO 0x0
> +#define SEC_C_BLD_FUNC__CONST_ALPHA (0x6 << 4)
> +#define SEC_C_BLD_FUNC__SEC_ALPHA (0x4 << 4)
> +#define PRIM_A_BLD_FUNC__ZERO (0x0 << 8)
> +#define SEC_A_BLD_FUNC__ZERO (0x0 << 12)
> +
> +#define POSITION 0x14
> +#define XPOS(x) ((x) & 0x7fff)
> +#define YPOS(y) (((y) & 0x7fff) << 16)
> +
> +#define PRIMCONTROLWORD 0x18
> +#define SECCONTROLWORD 0x1c
> +
> +enum dpu_lb_shadow_sel {
> + PRIMARY, /* background plane */
> + SECONDARY, /* foreground plane */
> + BOTH,
> +};
> +
> +struct dpu_layerblend {
> + void __iomem *pec_base;
> + void __iomem *base;
> + struct mutex mutex;
> + unsigned int id;
> + unsigned int index;
> + enum dpu_link_id link_id;
> + bool inuse;
> + struct dpu_soc *dpu;
> +};
> +
> +static const enum dpu_link_id dpu_lb_link_id[] = {
> + LINK_ID_LAYERBLEND0, LINK_ID_LAYERBLEND1,
> + LINK_ID_LAYERBLEND2, LINK_ID_LAYERBLEND3
> +};
> +
> +static const enum dpu_link_id prim_sels[] = {
> + /* common options */
> + LINK_ID_NONE,
> + LINK_ID_BLITBLEND9,
> + LINK_ID_CONSTFRAME0,
> + LINK_ID_CONSTFRAME1,
> + LINK_ID_CONSTFRAME4,
> + LINK_ID_CONSTFRAME5,
> + LINK_ID_MATRIX4,
> + LINK_ID_HSCALER4,
> + LINK_ID_VSCALER4,
> + LINK_ID_MATRIX5,
> + LINK_ID_HSCALER5,
> + LINK_ID_VSCALER5,
> + /*
> + * special options:
> + * layerblend(n) has n special options,
> + * from layerblend0 to layerblend(n - 1), e.g.,
> + * layerblend3 has 3 special options -
> + * layerblend0/1/2.
> + */
> + LINK_ID_LAYERBLEND0,
> + LINK_ID_LAYERBLEND1,
> + LINK_ID_LAYERBLEND2,
> + LINK_ID_LAYERBLEND3,
> +};
> +
> +static const enum dpu_link_id sec_sels[] = {
> + LINK_ID_NONE,
> + LINK_ID_FETCHWARP2,
> + LINK_ID_FETCHDECODE0,
> + LINK_ID_FETCHDECODE1,
> + LINK_ID_MATRIX4,
> + LINK_ID_HSCALER4,
> + LINK_ID_VSCALER4,
> + LINK_ID_MATRIX5,
> + LINK_ID_HSCALER5,
> + LINK_ID_VSCALER5,
> + LINK_ID_FETCHLAYER0,
> +};
> +
> +static inline u32 dpu_pec_lb_read(struct dpu_layerblend *lb,
> + unsigned int offset)
> +{
> + return readl(lb->pec_base + offset);
> +}
> +
> +static inline void dpu_pec_lb_write(struct dpu_layerblend *lb,
> + unsigned int offset, u32 value)
> +{
> + writel(value, lb->pec_base + offset);
> +}
> +
> +static inline void dpu_pec_lb_write_mask(struct dpu_layerblend *lb,
> + unsigned int offset,
> + u32 mask, u32 value)
> +{
> + u32 tmp;
> +
> + tmp = dpu_pec_lb_read(lb, offset);
> + tmp &= ~mask;
> + dpu_pec_lb_write(lb, offset, tmp | value);
> +}
> +
> +static inline u32 dpu_lb_read(struct dpu_layerblend *lb, unsigned int offset)
> +{
> + return readl(lb->base + offset);
> +}
> +
> +static inline void dpu_lb_write(struct dpu_layerblend *lb,
> + unsigned int offset, u32 value)
> +{
> + writel(value, lb->base + offset);
> +}
> +
> +static inline void dpu_lb_write_mask(struct dpu_layerblend *lb,
> + unsigned int offset, u32 mask, u32 value)
> +{
> + u32 tmp;
> +
> + tmp = dpu_lb_read(lb, offset);
> + tmp &= ~mask;
> + dpu_lb_write(lb, offset, tmp | value);
> +}
> +
> +enum dpu_link_id dpu_lb_get_link_id(struct dpu_layerblend *lb)
> +{
> + return lb->link_id;
> +}
> +
> +void dpu_lb_pec_dynamic_prim_sel(struct dpu_layerblend *lb,
> + enum dpu_link_id prim)
> +{
> + struct dpu_soc *dpu = lb->dpu;
> + int fixed_sels_num = ARRAY_SIZE(prim_sels) - 4;
> + int i;
> +
> + for (i = 0; i < fixed_sels_num + lb->id; i++) {
> + if (prim_sels[i] == prim) {
> + dpu_pec_lb_write_mask(lb, PIXENGCFG_DYNAMIC,
> + PIXENGCFG_DYNAMIC_PRIM_SEL_MASK,
> + prim);
> + return;
> + }
> + }
> +
> + dev_err(dpu->dev, "LayerBlend%u - invalid primary source 0x%02x\n",
> + lb->id, prim);
> +}
> +
> +void dpu_lb_pec_dynamic_sec_sel(struct dpu_layerblend *lb, enum dpu_link_id sec)
> +{
> + struct dpu_soc *dpu = lb->dpu;
> + int i;
> +
> + for (i = 0; i < ARRAY_SIZE(sec_sels); i++) {
> + if (sec_sels[i] == sec) {
> + dpu_pec_lb_write_mask(lb, PIXENGCFG_DYNAMIC,
> + PIXENGCFG_DYNAMIC_SEC_SEL_MASK,
> + sec << PIXENGCFG_DYNAMIC_SEC_SEL_SHIFT);
> + return;
> + }
> + }
> +
> + dev_err(dpu->dev, "LayerBlend%u - invalid secondary source 0x%02x\n",
> + lb->id, sec);
> +}
> +
> +void dpu_lb_pec_clken(struct dpu_layerblend *lb, enum dpu_pec_clken clken)
> +{
> + dpu_pec_lb_write_mask(lb, PIXENGCFG_DYNAMIC, CLKEN_MASK, CLKEN(clken));
> +}
> +
> +static void dpu_lb_enable_shden(struct dpu_layerblend *lb)
> +{
> + dpu_lb_write_mask(lb, STATICCONTROL, SHDEN, SHDEN);
> +}
> +
> +static void dpu_lb_shdtoksel(struct dpu_layerblend *lb,
> + enum dpu_lb_shadow_sel sel)
> +{
> + dpu_lb_write_mask(lb, STATICCONTROL, SHDTOKSEL_MASK, SHDTOKSEL(sel));
> +}
> +
> +static void dpu_lb_shdldsel(struct dpu_layerblend *lb,
> + enum dpu_lb_shadow_sel sel)
> +{
> + dpu_lb_write_mask(lb, STATICCONTROL, SHDLDSEL_MASK, SHDLDSEL(sel));
> +}
> +
> +void dpu_lb_mode(struct dpu_layerblend *lb, enum dpu_lb_mode mode)
> +{
> + dpu_lb_write_mask(lb, CONTROL, CTRL_MODE_MASK, mode);
> +}
> +
> +void dpu_lb_blendcontrol(struct dpu_layerblend *lb, unsigned int zpos,
> + unsigned int pixel_blend_mode, u16 alpha)
> +{
> + u32 val = PRIM_A_BLD_FUNC__ZERO | SEC_A_BLD_FUNC__ZERO;
> +
> + if (zpos == 0) {
> + val |= PRIM_C_BLD_FUNC__ZERO | SEC_C_BLD_FUNC__CONST_ALPHA;
> + alpha = DRM_BLEND_ALPHA_OPAQUE;
> + } else {
> + switch (pixel_blend_mode) {
> + case DRM_MODE_BLEND_PIXEL_NONE:
> + val |= PRIM_C_BLD_FUNC__ONE_MINUS_CONST_ALPHA |
> + SEC_C_BLD_FUNC__CONST_ALPHA;
> + break;
> + case DRM_MODE_BLEND_PREMULTI:
> + val |= PRIM_C_BLD_FUNC__ONE_MINUS_SEC_ALPHA |
> + SEC_C_BLD_FUNC__CONST_ALPHA;
> + break;
> + case DRM_MODE_BLEND_COVERAGE:
> + val |= PRIM_C_BLD_FUNC__ONE_MINUS_SEC_ALPHA |
> + SEC_C_BLD_FUNC__SEC_ALPHA;
> + break;
> + }
> + }
> +
> + val |= ALPHA(alpha >> 8);
> +
> + dpu_lb_write(lb, BLENDCONTROL, val);
> +}
> +
> +void dpu_lb_position(struct dpu_layerblend *lb, int x, int y)
> +{
> + dpu_lb_write(lb, POSITION, XPOS(x) | YPOS(y));
> +}
> +
> +unsigned int dpu_lb_get_id(struct dpu_layerblend *lb)
> +{
> + return lb->id;
> +}
> +
> +struct dpu_layerblend *dpu_lb_get(struct dpu_soc *dpu, unsigned int id)
> +{
> + struct dpu_layerblend *lb;
> + int i;
> +
> + for (i = 0; i < ARRAY_SIZE(dpu->lb_priv); i++) {
> + lb = dpu->lb_priv[i];
> + if (lb->id == id)
> + break;
> + }
> +
> + if (i == ARRAY_SIZE(dpu->lb_priv))
> + return ERR_PTR(-EINVAL);
> +
> + mutex_lock(&lb->mutex);
> +
> + if (lb->inuse) {
> + mutex_unlock(&lb->mutex);
> + return ERR_PTR(-EBUSY);
> + }
> +
> + lb->inuse = true;
> +
> + mutex_unlock(&lb->mutex);
> +
> + return lb;
> +}
> +
> +void dpu_lb_put(struct dpu_layerblend *lb)
> +{
> + if (IS_ERR_OR_NULL(lb))
> + return;
> +
> + mutex_lock(&lb->mutex);
> +
> + lb->inuse = false;
> +
> + mutex_unlock(&lb->mutex);
> +}
> +
> +void dpu_lb_hw_init(struct dpu_soc *dpu, unsigned int index)
> +{
> + struct dpu_layerblend *lb = dpu->lb_priv[index];
> +
> + dpu_lb_pec_dynamic_prim_sel(lb, LINK_ID_NONE);
> + dpu_lb_pec_dynamic_sec_sel(lb, LINK_ID_NONE);
> + dpu_lb_pec_clken(lb, CLKEN_DISABLE);
> + dpu_lb_shdldsel(lb, BOTH);
> + dpu_lb_shdtoksel(lb, BOTH);
> + dpu_lb_enable_shden(lb);
> +}
> +
> +int dpu_lb_init(struct dpu_soc *dpu, unsigned int index,
> + unsigned int id, enum dpu_unit_type type,
> + unsigned long pec_base, unsigned long base)
> +{
> + struct dpu_layerblend *lb;
> +
> + lb = devm_kzalloc(dpu->dev, sizeof(*lb), GFP_KERNEL);
> + if (!lb)
> + return -ENOMEM;
> +
> + dpu->lb_priv[index] = lb;
> +
> + lb->pec_base = devm_ioremap(dpu->dev, pec_base, SZ_16);
> + if (!lb->pec_base)
> + return -ENOMEM;
> +
> + lb->base = devm_ioremap(dpu->dev, base, SZ_32);
> + if (!lb->base)
> + return -ENOMEM;
> +
> + lb->dpu = dpu;
> + lb->id = id;
> + lb->index = index;
> + lb->link_id = dpu_lb_link_id[index];
> +
> + mutex_init(&lb->mutex);
> +
> + return 0;
> +}
> diff --git a/drivers/gpu/drm/imx/dpu/dpu-plane.c b/drivers/gpu/drm/imx/dpu/dpu-plane.c
> new file mode 100644
> index 00000000..5430206
> --- /dev/null
> +++ b/drivers/gpu/drm/imx/dpu/dpu-plane.c
> @@ -0,0 +1,803 @@
> +// SPDX-License-Identifier: GPL-2.0+
> +
> +/*
> + * Copyright 2017-2020 NXP
> + */
> +
> +#include <drm/drm_atomic.h>
> +#include <drm/drm_atomic_helper.h>
> +#include <drm/drm_atomic_state_helper.h>
> +#include <drm/drm_color_mgmt.h>
> +#include <drm/drm_fb_cma_helper.h>
> +#include <drm/drm_gem_atomic_helper.h>
> +#include <drm/drm_gem_cma_helper.h>
> +#include <drm/drm_plane_helper.h>
> +
> +#include "dpu.h"
> +#include "dpu-crtc.h"
> +#include "dpu-dprc.h"
> +#include "dpu-plane.h"
> +
> +#define FRAC_16_16(mult, div) (((mult) << 16) / (div))
> +
> +#define DPU_PLANE_MAX_PITCH 0x10000
> +#define DPU_PLANE_MAX_PIX_CNT 8192
> +#define DPU_PLANE_MAX_PIX_CNT_WITH_SCALER 2048
> +
> +static const uint32_t dpu_plane_formats[] = {
> + DRM_FORMAT_ARGB8888,
> + DRM_FORMAT_XRGB8888,
> + DRM_FORMAT_ABGR8888,
> + DRM_FORMAT_XBGR8888,
> + DRM_FORMAT_RGBA8888,
> + DRM_FORMAT_RGBX8888,
> + DRM_FORMAT_BGRA8888,
> + DRM_FORMAT_BGRX8888,
> + DRM_FORMAT_RGB565,
> +
> + DRM_FORMAT_YUYV,
> + DRM_FORMAT_UYVY,
> + DRM_FORMAT_NV12,
> + DRM_FORMAT_NV21,
> +};
> +
> +static const uint64_t dpu_plane_format_modifiers[] = {
> + DRM_FORMAT_MOD_VIVANTE_TILED,
> + DRM_FORMAT_MOD_VIVANTE_SUPER_TILED,
> + DRM_FORMAT_MOD_LINEAR,
> + DRM_FORMAT_MOD_INVALID,
> +};
> +
> +static unsigned int dpu_plane_get_default_zpos(enum drm_plane_type type)
> +{
> + if (type == DRM_PLANE_TYPE_PRIMARY)
> + return 0;
> + else if (type == DRM_PLANE_TYPE_OVERLAY)
> + return 1;
> +
> + return 0;
> +}
> +
> +static void dpu_plane_destroy(struct drm_plane *plane)
> +{
> + struct dpu_plane *dpu_plane = to_dpu_plane(plane);
> +
> + drm_plane_cleanup(plane);
> + kfree(dpu_plane);
> +}
> +
> +static void dpu_plane_reset(struct drm_plane *plane)
> +{
> + struct dpu_plane_state *state;
> +
> + if (plane->state) {
> + __drm_atomic_helper_plane_destroy_state(plane->state);
> + kfree(to_dpu_plane_state(plane->state));
> + plane->state = NULL;
> + }
> +
> + state = kzalloc(sizeof(*state), GFP_KERNEL);
> + if (!state)
> + return;
> +
> + __drm_atomic_helper_plane_reset(plane, &state->base);
> +
> + plane->state->zpos = dpu_plane_get_default_zpos(plane->type);
> + plane->state->color_encoding = DRM_COLOR_YCBCR_BT709;
> + plane->state->color_range = DRM_COLOR_YCBCR_LIMITED_RANGE;
> +}
> +
> +static struct drm_plane_state *
> +dpu_drm_atomic_plane_duplicate_state(struct drm_plane *plane)
> +{
> + struct dpu_plane_state *state, *copy;
> +
> + if (WARN_ON(!plane->state))
> + return NULL;
> +
> + copy = kmalloc(sizeof(*state), GFP_KERNEL);
> + if (!copy)
> + return NULL;
> +
> + __drm_atomic_helper_plane_duplicate_state(plane, ©->base);
> + state = to_dpu_plane_state(plane->state);
> + copy->stage = state->stage;
> + copy->source = state->source;
> + copy->blend = state->blend;
> + copy->is_top = state->is_top;
> +
> + return ©->base;
> +}
> +
> +static void dpu_drm_atomic_plane_destroy_state(struct drm_plane *plane,
> + struct drm_plane_state *state)
> +{
> + __drm_atomic_helper_plane_destroy_state(state);
> + kfree(to_dpu_plane_state(state));
> +}
> +
> +static bool dpu_drm_plane_format_mod_supported(struct drm_plane *plane,
> + uint32_t format,
> + uint64_t modifier)
> +{
> + switch (format) {
> + case DRM_FORMAT_YUYV:
> + case DRM_FORMAT_UYVY:
> + case DRM_FORMAT_NV12:
> + case DRM_FORMAT_NV21:
> + return modifier == DRM_FORMAT_MOD_LINEAR;
> + case DRM_FORMAT_ARGB8888:
> + case DRM_FORMAT_XRGB8888:
> + case DRM_FORMAT_ABGR8888:
> + case DRM_FORMAT_XBGR8888:
> + case DRM_FORMAT_RGBA8888:
> + case DRM_FORMAT_RGBX8888:
> + case DRM_FORMAT_BGRA8888:
> + case DRM_FORMAT_BGRX8888:
> + case DRM_FORMAT_RGB565:
> + return modifier == DRM_FORMAT_MOD_LINEAR ||
> + modifier == DRM_FORMAT_MOD_VIVANTE_TILED ||
> + modifier == DRM_FORMAT_MOD_VIVANTE_SUPER_TILED;
> + default:
> + return false;
> + }
> +}
> +
> +static const struct drm_plane_funcs dpu_plane_funcs = {
> + .update_plane = drm_atomic_helper_update_plane,
> + .disable_plane = drm_atomic_helper_disable_plane,
> + .destroy = dpu_plane_destroy,
> + .reset = dpu_plane_reset,
> + .atomic_duplicate_state = dpu_drm_atomic_plane_duplicate_state,
> + .atomic_destroy_state = dpu_drm_atomic_plane_destroy_state,
> + .format_mod_supported = dpu_drm_plane_format_mod_supported,
> +};
> +
> +static inline dma_addr_t
> +drm_plane_state_to_baseaddr(struct drm_plane_state *state)
> +{
> + struct drm_framebuffer *fb = state->fb;
> + struct drm_gem_cma_object *cma_obj;
> + unsigned int x = state->src.x1 >> 16;
> + unsigned int y = state->src.y1 >> 16;
> +
> + cma_obj = drm_fb_cma_get_gem_obj(fb, 0);
> +
> + if (fb->flags & DRM_MODE_FB_INTERLACED)
> + y /= 2;
> +
> + return cma_obj->paddr + fb->offsets[0] + fb->pitches[0] * y +
> + fb->format->cpp[0] * x;
> +}
> +
> +static inline dma_addr_t
> +drm_plane_state_to_uvbaseaddr(struct drm_plane_state *state)
> +{
> + struct drm_framebuffer *fb = state->fb;
> + struct drm_gem_cma_object *cma_obj;
> + int x = state->src.x1 >> 16;
> + int y = state->src.y1 >> 16;
> +
> + cma_obj = drm_fb_cma_get_gem_obj(fb, 1);
> +
> + x /= fb->format->hsub;
> + y /= fb->format->vsub;
> +
> + if (fb->flags & DRM_MODE_FB_INTERLACED)
> + y /= 2;
> +
> + return cma_obj->paddr + fb->offsets[1] + fb->pitches[1] * y +
> + fb->format->cpp[1] * x;
> +}
> +
> +static int dpu_plane_check_no_off_screen(struct drm_plane_state *state,
> + struct drm_crtc_state *crtc_state)
> +{
> + if (state->dst.x1 < 0 || state->dst.y1 < 0 ||
> + (state->dst.x2 > crtc_state->adjusted_mode.hdisplay) ||
> + (state->dst.y2 > crtc_state->adjusted_mode.vdisplay)) {
> + dpu_plane_dbg(state->plane, "no off screen\n");
> + return -EINVAL;
> + }
> +
> + return 0;
> +}
> +
> +static int dpu_plane_check_max_source_resolution(struct drm_plane_state *state)
> +{
> + u32 src_w = drm_rect_width(&state->src) >> 16;
> + u32 src_h = drm_rect_height(&state->src) >> 16;
> + u32 dst_w = drm_rect_width(&state->dst);
> + u32 dst_h = drm_rect_height(&state->dst);
> +
> + if (src_w == dst_w || src_h == dst_h) {
> + /* without scaling */
> + if (src_w > DPU_PLANE_MAX_PIX_CNT ||
> + src_h > DPU_PLANE_MAX_PIX_CNT) {
> + dpu_plane_dbg(state->plane,
> + "invalid source resolution\n");
> + return -EINVAL;
> + }
> + } else {
> + /* with scaling */
> + if (src_w > DPU_PLANE_MAX_PIX_CNT_WITH_SCALER ||
> + src_h > DPU_PLANE_MAX_PIX_CNT_WITH_SCALER) {
> + dpu_plane_dbg(state->plane,
> + "invalid source resolution with scale\n");
> + return -EINVAL;
> + }
> + }
> +
> + return 0;
> +}
> +
> +static int dpu_plane_check_source_alignment(struct drm_plane_state *state)
> +{
> + struct drm_framebuffer *fb = state->fb;
> + bool fb_is_interlaced = !!(fb->flags & DRM_MODE_FB_INTERLACED);
> + u32 src_w = drm_rect_width(&state->src) >> 16;
> + u32 src_h = drm_rect_height(&state->src) >> 16;
> + u32 src_x = state->src.x1 >> 16;
> + u32 src_y = state->src.y1 >> 16;
> +
> + if (fb->format->hsub == 2) {
> + if (src_w % 2) {
> + dpu_plane_dbg(state->plane, "bad uv width\n");
> + return -EINVAL;
> + }
> + if (src_x % 2) {
> + dpu_plane_dbg(state->plane, "bad uv xoffset\n");
> + return -EINVAL;
> + }
> + }
> + if (fb->format->vsub == 2) {
> + if (src_h % (fb_is_interlaced ? 4 : 2)) {
> + dpu_plane_dbg(state->plane, "bad uv height\n");
> + return -EINVAL;
> + }
> + if (src_y % (fb_is_interlaced ? 4 : 2)) {
> + dpu_plane_dbg(state->plane, "bad uv yoffset\n");
> + return -EINVAL;
> + }
> + }
> +
> + return 0;
> +}
> +
> +static int dpu_plane_check_fb_modifier(struct drm_plane_state *state)
> +{
> + struct drm_plane *plane = state->plane;
> + struct drm_framebuffer *fb = state->fb;
> +
> + if ((fb->flags & DRM_MODE_FB_MODIFIERS) &&
> + !plane->funcs->format_mod_supported(plane, fb->format->format,
> + fb->modifier)) {
> + dpu_plane_dbg(plane, "invalid modifier 0x%016llx",
> + fb->modifier);
> + return -EINVAL;
> + }
> +
> + return 0;
> +}
> +
> +/* for tile formats, framebuffer has to be tile aligned */
> +static int dpu_plane_check_tiled_fb_alignment(struct drm_plane_state *state)
> +{
> + struct drm_plane *plane = state->plane;
> + struct drm_framebuffer *fb = state->fb;
> +
> + switch (fb->modifier) {
> + case DRM_FORMAT_MOD_VIVANTE_TILED:
> + if (fb->width % 4) {
> + dpu_plane_dbg(plane, "bad fb width for VIVANTE tile\n");
> + return -EINVAL;
> + }
> + if (fb->height % 4) {
> + dpu_plane_dbg(plane, "bad fb height for VIVANTE tile\n");
> + return -EINVAL;
> + }
> + break;
> + case DRM_FORMAT_MOD_VIVANTE_SUPER_TILED:
> + if (fb->width % 64) {
> + dpu_plane_dbg(plane,
> + "bad fb width for VIVANTE super tile\n");
> + return -EINVAL;
> + }
> + if (fb->height % 64) {
> + dpu_plane_dbg(plane,
> + "bad fb height for VIVANTE super tile\n");
> + return -EINVAL;
> + }
> + break;
> + }
> +
> + return 0;
> +}
> +
> +static int dpu_plane_check_no_bt709_full_range(struct drm_plane_state *state)
> +{
> + if (state->fb->format->is_yuv &&
> + state->color_encoding == DRM_COLOR_YCBCR_BT709 &&
> + state->color_range == DRM_COLOR_YCBCR_FULL_RANGE) {
> + dpu_plane_dbg(state->plane, "no BT709 full range support\n");
> + return -EINVAL;
> + }
> +
> + return 0;
> +}
> +
> +static int dpu_plane_check_fb_plane_1(struct drm_plane_state *state)
> +{
> + struct drm_plane *plane = state->plane;
> + struct drm_framebuffer *fb = state->fb;
> + dma_addr_t baseaddr = drm_plane_state_to_baseaddr(state);
> + int bpp;
> +
> + /* base address alignment */
> + switch (fb->format->format) {
> + case DRM_FORMAT_YUYV:
> + case DRM_FORMAT_UYVY:
> + bpp = 16;
> + break;
> + case DRM_FORMAT_NV12:
> + case DRM_FORMAT_NV21:
> + bpp = 8;
> + break;
> + default:
> + bpp = fb->format->cpp[0] * 8;
> + break;
> + }
> + if (((bpp == 32) && (baseaddr & 0x3)) ||
> + ((bpp == 16) && (baseaddr & 0x1))) {
> + dpu_plane_dbg(plane, "%dbpp fb bad baddr alignment\n", bpp);
> + return -EINVAL;
> + }
> + switch (bpp) {
> + case 32:
> + if (baseaddr & 0x3) {
> + dpu_plane_dbg(plane, "32bpp fb bad baddr alignment\n");
> + return -EINVAL;
> + }
> + break;
> + case 16:
> + if (fb->modifier) {
> + if (baseaddr & 0x1) {
> + dpu_plane_dbg(plane,
> + "16bpp tile fb bad baddr alignment\n");
> + return -EINVAL;
> + }
> + } else {
> + if (baseaddr & 0x7) {
> + dpu_plane_dbg(plane,
> + "16bpp fb bad baddr alignment\n");
> + return -EINVAL;
> + }
> + }
> + break;
> + }
> +
> + /* pitches[0] range */
> + if (fb->pitches[0] > DPU_PLANE_MAX_PITCH) {
> + dpu_plane_dbg(plane, "fb pitches[0] is out of range\n");
> + return -EINVAL;
> + }
> +
> + /* pitches[0] alignment */
> + if (((bpp == 32) && (fb->pitches[0] & 0x3)) ||
> + ((bpp == 16) && (fb->pitches[0] & 0x1))) {
> + dpu_plane_dbg(plane, "%dbpp fb bad pitches[0] alignment\n", bpp);
> + return -EINVAL;
> + }
> +
> + return 0;
> +}
> +
> +/* UV planar check, assuming 16bpp */
> +static int dpu_plane_check_fb_plane_2(struct drm_plane_state *state)
> +{
> + struct drm_plane *plane = state->plane;
> + struct drm_framebuffer *fb = state->fb;
> + dma_addr_t uv_baseaddr = drm_plane_state_to_uvbaseaddr(state);
> +
> + /* base address alignment */
> + if (uv_baseaddr & 0x7) {
> + dpu_plane_dbg(plane, "bad uv baddr alignment\n");
> + return -EINVAL;
> + }
> +
> + /* pitches[1] range */
> + if (fb->pitches[1] > DPU_PLANE_MAX_PITCH) {
> + dpu_plane_dbg(plane, "fb pitches[1] is out of range\n");
> + return -EINVAL;
> + }
> +
> + /* pitches[1] alignment */
> + if (fb->pitches[1] & 0x1) {
> + dpu_plane_dbg(plane, "fb bad pitches[1] alignment\n");
> + return -EINVAL;
> + }
> +
> + return 0;
> +}
> +
> +static int dpu_plane_check_dprc(struct drm_plane_state *state)
> +{
> + struct dpu_plane_state *dpstate = to_dpu_plane_state(state);
> + struct drm_framebuffer *fb = state->fb;
> + const struct dpu_fetchunit_ops *fu_ops;
> + struct dpu_dprc *dprc;
> + dma_addr_t baseaddr, uv_baseaddr = 0;
> + u32 src_w = drm_rect_width(&state->src) >> 16;
> + u32 src_x = state->src.x1 >> 16;
> +
> + fu_ops = dpu_fu_get_ops(dpstate->source);
> + dprc = fu_ops->get_dprc(dpstate->source);
> +
> + if (!dpu_dprc_rtram_width_supported(dprc, src_w)) {
> + dpu_plane_dbg(state->plane, "bad RTRAM width for DPRC\n");
> + return -EINVAL;
> + }
> +
> + baseaddr = drm_plane_state_to_baseaddr(state);
> + if (fb->format->num_planes > 1)
> + uv_baseaddr = drm_plane_state_to_uvbaseaddr(state);
> +
> + if (!dpu_dprc_stride_supported(dprc, fb->pitches[0], fb->pitches[1],
> + src_w, src_x, fb->format, fb->modifier,
> + baseaddr, uv_baseaddr)) {
> + dpu_plane_dbg(state->plane, "bad fb pitches for DPRC\n");
> + return -EINVAL;
> + }
> +
> + return 0;
> +}
> +
> +static int dpu_plane_atomic_check(struct drm_plane *plane,
> + struct drm_atomic_state *state)
> +{
> + struct drm_plane_state *new_plane_state =
> + drm_atomic_get_new_plane_state(state, plane);
> + struct dpu_plane_state *new_dpstate =
> + to_dpu_plane_state(new_plane_state);
> + struct drm_framebuffer *fb = new_plane_state->fb;
> + struct drm_crtc_state *crtc_state;
> + int min_scale, ret;
> +
> + /* ok to disable */
> + if (!fb) {
> + new_dpstate->source = NULL;
> + new_dpstate->stage.ptr = NULL;
> + new_dpstate->blend = NULL;
> + return 0;
> + }
> +
> + if (!new_plane_state->crtc) {
> + dpu_plane_dbg(plane, "no CRTC in plane state\n");
> + return -EINVAL;
> + }
> +
> + crtc_state =
> + drm_atomic_get_existing_crtc_state(state, new_plane_state->crtc);
> + if (WARN_ON(!crtc_state))
> + return -EINVAL;
> +
> + min_scale = FRAC_16_16(1, DPU_PLANE_MAX_PIX_CNT_WITH_SCALER);
> + ret = drm_atomic_helper_check_plane_state(new_plane_state, crtc_state,
> + min_scale,
> + DRM_PLANE_HELPER_NO_SCALING,
> + true, false);
> + if (ret) {
> + dpu_plane_dbg(plane, "failed to check plane state: %d\n", ret);
> + return ret;
> + }
> +
> + ret = dpu_plane_check_no_off_screen(new_plane_state, crtc_state);
> + if (ret)
> + return ret;
> +
> + ret = dpu_plane_check_max_source_resolution(new_plane_state);
> + if (ret)
> + return ret;
> +
> + ret = dpu_plane_check_source_alignment(new_plane_state);
> + if (ret)
> + return ret;
> +
> + ret = dpu_plane_check_fb_modifier(new_plane_state);
> + if (ret)
> + return ret;
> +
> + ret = dpu_plane_check_tiled_fb_alignment(new_plane_state);
> + if (ret)
> + return ret;
> +
> + ret = dpu_plane_check_no_bt709_full_range(new_plane_state);
> + if (ret)
> + return ret;
> +
> + ret = dpu_plane_check_fb_plane_1(new_plane_state);
> + if (ret)
> + return ret;
> +
> + if (fb->format->num_planes > 1) {
> + ret = dpu_plane_check_fb_plane_2(new_plane_state);
> + if (ret)
> + return ret;
> + }
> +
> + return dpu_plane_check_dprc(new_plane_state);
> +}
> +
> +static void dpu_plane_atomic_update(struct drm_plane *plane,
> + struct drm_atomic_state *state)
> +{
> + struct dpu_plane *dplane = to_dpu_plane(plane);
> + struct drm_plane_state *new_state =
> + drm_atomic_get_new_plane_state(state, plane);
> + struct dpu_plane_state *new_dpstate = to_dpu_plane_state(new_state);
> + struct dpu_plane_grp *grp = dplane->grp;
> + struct dpu_crtc *dpu_crtc;
> + struct drm_framebuffer *fb = new_state->fb;
> + struct dpu_fetchunit *fu = new_dpstate->source;
> + struct dpu_layerblend *lb = new_dpstate->blend;
> + struct dpu_dprc *dprc;
> + const struct dpu_fetchunit_ops *fu_ops;
> + dma_addr_t baseaddr, uv_baseaddr;
> + enum dpu_link_id fu_link;
> + enum dpu_link_id lb_src_link, stage_link;
> + enum dpu_link_id vs_link;
> + unsigned int src_w, src_h, src_x, src_y, dst_w, dst_h;
> + unsigned int mt_w = 0, mt_h = 0; /* micro-tile width/height */
> + int bpp;
> + bool prefetch_start = false;
> + bool need_fetcheco = false, need_hscaler = false, need_vscaler = false;
> + bool need_modeset;
> + bool fb_is_interlaced;
> +
> + /*
> + * Do nothing since the plane is disabled by
> + * crtc_func->atomic_begin/flush.
> + */
> + if (!fb)
> + return;
> +
> + /* Do nothing if CRTC is inactive. */
> + if (!new_state->crtc->state->active)
> + return;
> +
> + need_modeset = drm_atomic_crtc_needs_modeset(new_state->crtc->state);
> +
> + fb_is_interlaced = !!(fb->flags & DRM_MODE_FB_INTERLACED);
> +
> + src_w = drm_rect_width(&new_state->src) >> 16;
> + src_h = drm_rect_height(&new_state->src) >> 16;
> + src_x = new_state->src.x1 >> 16;
> + src_y = new_state->src.y1 >> 16;
> + dst_w = drm_rect_width(&new_state->dst);
> + dst_h = drm_rect_height(&new_state->dst);
> +
> + switch (fb->format->format) {
> + case DRM_FORMAT_YUYV:
> + case DRM_FORMAT_UYVY:
> + bpp = 16;
> + break;
> + case DRM_FORMAT_NV12:
> + case DRM_FORMAT_NV21:
> + bpp = 8;
> + break;
> + default:
> + bpp = fb->format->cpp[0] * 8;
> + break;
> + }
> +
> + switch (fb->modifier) {
> + case DRM_FORMAT_MOD_VIVANTE_TILED:
> + case DRM_FORMAT_MOD_VIVANTE_SUPER_TILED:
> + mt_w = (bpp == 16) ? 8 : 4;
> + mt_h = 4;
> + break;
> + }
> +
> + if (fb->format->num_planes > 1)
> + need_fetcheco = true;
> +
> + if (src_w != dst_w)
> + need_hscaler = true;
> +
> + if ((src_h != dst_h) || fb_is_interlaced)
> + need_vscaler = true;
> +
> + baseaddr = drm_plane_state_to_baseaddr(new_state);
> + if (need_fetcheco)
> + uv_baseaddr = drm_plane_state_to_uvbaseaddr(new_state);
> +
> + dpu_crtc = to_dpu_crtc(new_state->crtc);
> +
> + fu_ops = dpu_fu_get_ops(fu);
> +
> + if (!fu_ops->has_stream_id(fu) || need_modeset)
> + prefetch_start = true;
> +
> + fu_ops->set_layerblend(fu, lb);
> +
> + fu_ops->set_burstlength(fu, src_x, mt_w, bpp, baseaddr);
> + fu_ops->set_src_stride(fu, src_w, src_w, mt_w, bpp, fb->pitches[0],
> + baseaddr);
> + fu_ops->set_src_buf_dimensions(fu, src_w, src_h, fb->format,
> + fb_is_interlaced);
> + fu_ops->set_fmt(fu, fb->format, new_state->color_encoding,
> + new_state->color_range, fb_is_interlaced);
> + fu_ops->set_pixel_blend_mode(fu, new_state->pixel_blend_mode,
> + new_state->alpha, fb->format->has_alpha);
> + fu_ops->enable_src_buf(fu);
> + fu_ops->set_framedimensions(fu, src_w, src_h, fb_is_interlaced);
> + fu_ops->set_baseaddress(fu, src_w, src_x, src_y, mt_w, mt_h, bpp,
> + baseaddr);
> + fu_ops->set_stream_id(fu, dpu_crtc->stream_id);
> +
> + fu_link = fu_ops->get_link_id(fu);
> + lb_src_link = fu_link;
> +
> + dpu_plane_dbg(plane, "uses %s\n", fu_ops->get_name(fu));
> +
> + if (need_fetcheco) {
> + struct dpu_fetchunit *fe = fu_ops->get_fetcheco(fu);
> + const struct dpu_fetchunit_ops *fe_ops;
> +
> + fe_ops = dpu_fu_get_ops(fe);
> +
> + fu_ops->set_pec_dynamic_src_sel(fu, fe_ops->get_link_id(fe));
> +
> + fe_ops->set_burstlength(fe, src_x, mt_w, bpp, uv_baseaddr);
> + fe_ops->set_src_stride(fe, src_w, src_x, mt_w, bpp,
> + fb->pitches[1], uv_baseaddr);
> + fe_ops->set_fmt(fe, fb->format, new_state->color_encoding,
> + new_state->color_range, fb_is_interlaced);
> + fe_ops->set_src_buf_dimensions(fe, src_w, src_h,
> + fb->format, fb_is_interlaced);
> + fe_ops->set_framedimensions(fe, src_w, src_h, fb_is_interlaced);
> + fe_ops->set_baseaddress(fe, src_w, src_x, src_y / 2,
> + mt_w, mt_h, bpp, uv_baseaddr);
> + fe_ops->enable_src_buf(fe);
> +
> + dpu_plane_dbg(plane, "uses %s\n", fe_ops->get_name(fe));
> + } else {
> + if (fu_ops->set_pec_dynamic_src_sel)
> + fu_ops->set_pec_dynamic_src_sel(fu, LINK_ID_NONE);
> + }
> +
> + /* VScaler comes first */
> + if (need_vscaler) {
> + struct dpu_vscaler *vs = fu_ops->get_vscaler(fu);
> +
> + dpu_vs_pec_dynamic_src_sel(vs, fu_link);
> + dpu_vs_pec_clken(vs, CLKEN_AUTOMATIC);
> + dpu_vs_setup1(vs, src_h, new_state->crtc_h, fb_is_interlaced);
> + dpu_vs_setup2(vs, fb_is_interlaced);
> + dpu_vs_setup3(vs, fb_is_interlaced);
> + dpu_vs_output_size(vs, dst_h);
> + dpu_vs_field_mode(vs, fb_is_interlaced ?
> + SCALER_ALWAYS0 : SCALER_INPUT);
> + dpu_vs_filter_mode(vs, SCALER_LINEAR);
> + dpu_vs_scale_mode(vs, SCALER_UPSCALE);
> + dpu_vs_mode(vs, SCALER_ACTIVE);
> +
> + vs_link = dpu_vs_get_link_id(vs);
> + lb_src_link = vs_link;
> +
> + dpu_plane_dbg(plane, "uses VScaler%u\n", dpu_vs_get_id(vs));
> + }
> +
> + /* and then, HScaler */
> + if (need_hscaler) {
> + struct dpu_hscaler *hs = fu_ops->get_hscaler(fu);
> +
> + dpu_hs_pec_dynamic_src_sel(hs, need_vscaler ? vs_link : fu_link);
> + dpu_hs_pec_clken(hs, CLKEN_AUTOMATIC);
> + dpu_hs_setup1(hs, src_w, dst_w);
> + dpu_hs_output_size(hs, dst_w);
> + dpu_hs_filter_mode(hs, SCALER_LINEAR);
> + dpu_hs_scale_mode(hs, SCALER_UPSCALE);
> + dpu_hs_mode(hs, SCALER_ACTIVE);
> +
> + lb_src_link = dpu_hs_get_link_id(hs);
> +
> + dpu_plane_dbg(plane, "uses HScaler%u\n", dpu_hs_get_id(hs));
> + }
> +
> + dprc = fu_ops->get_dprc(fu);
> +
> + dpu_dprc_configure(dprc, dpu_crtc->stream_id,
> + src_w, src_h, src_x, src_y,
> + fb->pitches[0], fb->format, fb->modifier,
> + baseaddr, uv_baseaddr,
> + prefetch_start, fb_is_interlaced);
> +
> + if (new_state->normalized_zpos == 0)
> + stage_link = dpu_cf_get_link_id(new_dpstate->stage.cf);
> + else
> + stage_link = dpu_lb_get_link_id(new_dpstate->stage.lb);
> +
> + dpu_lb_pec_dynamic_prim_sel(lb, stage_link);
> + dpu_lb_pec_dynamic_sec_sel(lb, lb_src_link);
> + dpu_lb_mode(lb, LB_BLEND);
> + dpu_lb_blendcontrol(lb, new_state->normalized_zpos,
> + new_state->pixel_blend_mode, new_state->alpha);
> + dpu_lb_pec_clken(lb, CLKEN_AUTOMATIC);
> + dpu_lb_position(lb, new_state->dst.x1, new_state->dst.y1);
> +
> + dpu_plane_dbg(plane, "uses LayerBlend%u\n", dpu_lb_get_id(lb));
> +
> + if (new_dpstate->is_top)
> + dpu_ed_pec_src_sel(grp->ed[dpu_crtc->stream_id],
> + dpu_lb_get_link_id(lb));
> +}
> +
> +static const struct drm_plane_helper_funcs dpu_plane_helper_funcs = {
> + .prepare_fb = drm_gem_plane_helper_prepare_fb,
> + .atomic_check = dpu_plane_atomic_check,
> + .atomic_update = dpu_plane_atomic_update,
> +};
> +
> +struct dpu_plane *dpu_plane_initialize(struct drm_device *drm,
> + unsigned int possible_crtcs,
> + struct dpu_plane_grp *grp,
> + enum drm_plane_type type)
> +{
> + struct dpu_plane *dpu_plane;
> + struct drm_plane *plane;
> + unsigned int zpos = dpu_plane_get_default_zpos(type);
> + int ret;
> +
> + dpu_plane = kzalloc(sizeof(*dpu_plane), GFP_KERNEL);
> + if (!dpu_plane)
> + return ERR_PTR(-ENOMEM);
> +
> + dpu_plane->grp = grp;
> +
> + plane = &dpu_plane->base;
> +
> + ret = drm_universal_plane_init(drm, plane, possible_crtcs,
> + &dpu_plane_funcs,
> + dpu_plane_formats,
> + ARRAY_SIZE(dpu_plane_formats),
> + dpu_plane_format_modifiers, type, NULL);
> + if (ret) {
> + /*
> + * The plane is not added to the global plane list, so
> + * free it manually.
> + */
> + kfree(dpu_plane);
> + return ERR_PTR(ret);
> + }
> +
> + drm_plane_helper_add(plane, &dpu_plane_helper_funcs);
> +
> + ret = drm_plane_create_zpos_property(plane,
> + zpos, 0, grp->hw_plane_cnt - 1);
> + if (ret)
> + return ERR_PTR(ret);
> +
> + ret = drm_plane_create_alpha_property(plane);
> + if (ret)
> + return ERR_PTR(ret);
> +
> + ret = drm_plane_create_blend_mode_property(plane,
> + BIT(DRM_MODE_BLEND_PIXEL_NONE) |
> + BIT(DRM_MODE_BLEND_PREMULTI) |
> + BIT(DRM_MODE_BLEND_COVERAGE));
> + if (ret)
> + return ERR_PTR(ret);
> +
> + ret = drm_plane_create_color_properties(plane,
> + BIT(DRM_COLOR_YCBCR_BT601) |
> + BIT(DRM_COLOR_YCBCR_BT709),
> + BIT(DRM_COLOR_YCBCR_LIMITED_RANGE) |
> + BIT(DRM_COLOR_YCBCR_FULL_RANGE),
> + DRM_COLOR_YCBCR_BT709,
> + DRM_COLOR_YCBCR_LIMITED_RANGE);
> + if (ret)
> + return ERR_PTR(ret);
> +
> + return dpu_plane;
> +}
> diff --git a/drivers/gpu/drm/imx/dpu/dpu-plane.h b/drivers/gpu/drm/imx/dpu/dpu-plane.h
> new file mode 100644
> index 00000000..7bdd867
> --- /dev/null
> +++ b/drivers/gpu/drm/imx/dpu/dpu-plane.h
> @@ -0,0 +1,56 @@
> +/* SPDX-License-Identifier: GPL-2.0+ */
> +
> +/*
> + * Copyright 2017-2020 NXP
> + */
> +
> +#ifndef __DPU_PLANE_H__
> +#define __DPU_PLANE_H__
> +
> +#include <linux/kernel.h>
> +
> +#include <drm/drm_device.h>
> +#include <drm/drm_plane.h>
> +#include <drm/drm_print.h>
> +
> +#include "dpu.h"
> +
> +#define dpu_plane_dbg(plane, fmt, ...) \
> + drm_dbg_kms((plane)->dev, "[PLANE:%d:%s] " fmt, \
> + (plane)->base.id, (plane)->name, ##__VA_ARGS__)
> +
> +struct dpu_plane {
> + struct drm_plane base;
> + struct dpu_plane_grp *grp;
> +};
> +
> +union dpu_plane_stage {
> + struct dpu_constframe *cf;
> + struct dpu_layerblend *lb;
> + void *ptr;
> +};
> +
> +struct dpu_plane_state {
> + struct drm_plane_state base;
> + union dpu_plane_stage stage;
> + struct dpu_fetchunit *source;
> + struct dpu_layerblend *blend;
> + bool is_top;
> +};
> +
> +static inline struct dpu_plane *to_dpu_plane(struct drm_plane *plane)
> +{
> + return container_of(plane, struct dpu_plane, base);
> +}
> +
> +static inline struct dpu_plane_state *
> +to_dpu_plane_state(struct drm_plane_state *plane_state)
> +{
> + return container_of(plane_state, struct dpu_plane_state, base);
> +}
> +
> +struct dpu_plane *dpu_plane_initialize(struct drm_device *drm,
> + unsigned int possible_crtcs,
> + struct dpu_plane_grp *grp,
> + enum drm_plane_type type);
> +#endif /* __DPU_PLANE_H__ */
> diff --git a/drivers/gpu/drm/imx/dpu/dpu-prg.c b/drivers/gpu/drm/imx/dpu/dpu-prg.c
> new file mode 100644
> index 00000000..33a1a3e
> --- /dev/null
> +++ b/drivers/gpu/drm/imx/dpu/dpu-prg.c
> @@ -0,0 +1,433 @@
> +// SPDX-License-Identifier: GPL-2.0+
> +
> +/*
> + * Copyright 2017-2020 NXP
> + */
> +
> +#include <linux/bitops.h>
> +#include <linux/clk.h>
> +#include <linux/delay.h>
> +#include <linux/io.h>
> +#include <linux/kernel.h>
> +#include <linux/module.h>
> +#include <linux/of.h>
> +#include <linux/of_device.h>
> +#include <linux/platform_device.h>
> +#include <linux/pm_runtime.h>
> +
> +#include "dpu-prg.h"
> +
> +#define SET 0x4
> +#define CLR 0x8
> +#define TOG 0xc
> +
> +#define PRG_CTRL 0x00
> +#define BYPASS BIT(0)
> +#define SC_DATA_TYPE_8BIT 0
> +#define SC_DATA_TYPE_10BIT BIT(2)
> +#define UV_EN BIT(3)
> +#define HANDSHAKE_MODE_4LINES 0
> +#define HANDSHAKE_MODE_8LINES BIT(4)
> +#define SHADOW_LOAD_MODE BIT(5)
> +#define DES_DATA_TYPE_32BPP (0 << 16)
> +#define DES_DATA_TYPE_24BPP (1 << 16)
> +#define DES_DATA_TYPE_16BPP (2 << 16)
> +#define DES_DATA_TYPE_8BPP (3 << 16)
> +#define SOFTRST BIT(30)
> +#define SHADOW_EN BIT(31)
> +
> +#define PRG_STATUS 0x10
> +#define BUFFER_VALID_B BIT(1)
> +#define BUFFER_VALID_A BIT(0)
> +
> +#define PRG_REG_UPDATE 0x20
> +#define REG_UPDATE BIT(0)
> +
> +#define PRG_STRIDE 0x30
> +#define STRIDE(n) (((n) - 1) & 0xffff)
> +
> +#define PRG_HEIGHT 0x40
> +#define HEIGHT(n) (((n) - 1) & 0xffff)
> +
> +#define PRG_BADDR 0x50
> +
> +#define PRG_OFFSET 0x60
> +#define Y(n) (((n) & 0x7) << 16)
> +#define X(n) ((n) & 0xffff)
> +
> +#define PRG_WIDTH 0x70
> +#define WIDTH(n) (((n) - 1) & 0xffff)
> +
> +#define DPU_PRG_MAX_STRIDE 0x10000
> +
> +struct dpu_prg {
> + struct device *dev;
> + void __iomem *base;
> + struct list_head list;
> + struct clk *clk_apb;
> + struct clk *clk_rtram;
> + bool is_auxiliary;
> +};
> +
> +static DEFINE_MUTEX(dpu_prg_list_mutex);
> +static LIST_HEAD(dpu_prg_list);
> +
> +static inline u32 dpu_prg_read(struct dpu_prg *prg, unsigned int offset)
> +{
> + return readl(prg->base + offset);
> +}
> +
> +static inline void
> +dpu_prg_write(struct dpu_prg *prg, unsigned int offset, u32 value)
> +{
> + writel(value, prg->base + offset);
> +}
> +
> +static void dpu_prg_reset(struct dpu_prg *prg)
> +{
> + usleep_range(10, 20);
> + dpu_prg_write(prg, PRG_CTRL + SET, SOFTRST);
> + usleep_range(10, 20);
> + dpu_prg_write(prg, PRG_CTRL + CLR, SOFTRST);
> +}
> +
> +void dpu_prg_enable(struct dpu_prg *prg)
> +{
> + dpu_prg_write(prg, PRG_CTRL + CLR, BYPASS);
> +}
> +
> +void dpu_prg_disable(struct dpu_prg *prg)
> +{
> + dpu_prg_write(prg, PRG_CTRL, BYPASS);
> +}
> +
> +static int dpu_prg_mod_to_mt_w(struct dpu_prg *prg, u64 modifier,
> + unsigned int bits_per_pixel, unsigned int *mt_w)
> +{
> + switch (modifier) {
> + case DRM_FORMAT_MOD_NONE:
> + *mt_w = 0;
> + break;
> + case DRM_FORMAT_MOD_VIVANTE_TILED:
> + case DRM_FORMAT_MOD_VIVANTE_SUPER_TILED:
> + *mt_w = (bits_per_pixel == 16) ? 8 : 4;
> + break;
> + default:
> + dev_err(prg->dev, "unsupported modifier 0x%016llx\n", modifier);
> + return -EINVAL;
> + }
> +
> + return 0;
> +}
> +
> +static int dpu_prg_mod_to_mt_h(struct dpu_prg *prg, u64 modifier,
> + unsigned int *mt_h)
> +{
> + switch (modifier) {
> + case DRM_FORMAT_MOD_NONE:
> + *mt_h = 0;
> + break;
> + case DRM_FORMAT_MOD_VIVANTE_TILED:
> + case DRM_FORMAT_MOD_VIVANTE_SUPER_TILED:
> + *mt_h = 4;
> + break;
> + default:
> + dev_err(prg->dev, "unsupported modifier 0x%016llx\n", modifier);
> + return -EINVAL;
> + }
> +
> + return 0;
> +}
> +
> +/* address TKT343664: base address has to align to burst size */
> +static unsigned int dpu_prg_burst_size_fixup(dma_addr_t baddr)
> +{
> + unsigned int burst_size;
> +
> + burst_size = 1 << __ffs(baddr);
> + burst_size = round_up(burst_size, 8);
> + burst_size = min(burst_size, 128U);
> +
> + return burst_size;
> +}
> +
> +/* address TKT339017: mismatch between burst size and stride */
> +static unsigned int dpu_prg_stride_fixup(unsigned int stride,
> + unsigned int burst_size,
> + dma_addr_t baddr, u64 modifier)
> +{
> + if (modifier)
> + stride = round_up(stride + round_up(baddr % 8, 8), burst_size);
> + else
> + stride = round_up(stride, burst_size);
> +
> + return stride;
> +}
> +
> +void dpu_prg_configure(struct dpu_prg *prg,
> + unsigned int width, unsigned int height,
> + unsigned int x_offset, unsigned int y_offset,
> + unsigned int stride, unsigned int bits_per_pixel,
> + dma_addr_t baddr,
> + const struct drm_format_info *format, u64 modifier,
> + bool start)
> +{
> + unsigned int mt_w, mt_h; /* micro-tile width/height */
> + unsigned int burst_size;
> + dma_addr_t _baddr;
> + u32 val;
> + int ret;
> +
> + ret = dpu_prg_mod_to_mt_w(prg, modifier, bits_per_pixel, &mt_w);
> + ret |= dpu_prg_mod_to_mt_h(prg, modifier, &mt_h);
> + if (ret)
> + return;
> +
> + if (modifier) {
> + x_offset %= mt_w;
> + y_offset %= mt_h;
> +
> + /* consider x offset to calculate stride */
> + _baddr = baddr + (x_offset * (bits_per_pixel / 8));
> + } else {
> + x_offset = 0;
> + y_offset = 0;
> + _baddr = baddr;
> + }
> +
> + burst_size = dpu_prg_burst_size_fixup(_baddr);
> +
> + stride = dpu_prg_stride_fixup(stride, burst_size, _baddr, modifier);
> +
> + /*
> + * address TKT342628(part 1):
> + * when prg stride is less or equals to burst size,
> + * the auxiliary prg height needs to be a half
> + */
> + if (prg->is_auxiliary && stride <= burst_size) {
> + height /= 2;
> + if (modifier)
> + y_offset /= 2;
> + }
> +
> + dpu_prg_write(prg, PRG_STRIDE, STRIDE(stride));
> + dpu_prg_write(prg, PRG_WIDTH, WIDTH(width));
> + dpu_prg_write(prg, PRG_HEIGHT, HEIGHT(height));
> + dpu_prg_write(prg, PRG_OFFSET, X(x_offset) | Y(y_offset));
> + dpu_prg_write(prg, PRG_BADDR, baddr);
> +
> + val = SHADOW_LOAD_MODE | SC_DATA_TYPE_8BIT | BYPASS;
> + if (format->format == DRM_FORMAT_NV21 ||
> + format->format == DRM_FORMAT_NV12) {
> + val |= HANDSHAKE_MODE_8LINES;
> + /*
> + * address TKT342628(part 2):
> + * when prg stride is less or equals to burst size,
> + * we disable UV_EN bit for the auxiliary prg
> + */
> + if (prg->is_auxiliary && stride > burst_size)
> + val |= UV_EN;
> + } else {
> + val |= HANDSHAKE_MODE_4LINES;
> + }
> + switch (bits_per_pixel) {
> + case 32:
> + val |= DES_DATA_TYPE_32BPP;
> + break;
> + case 24:
> + val |= DES_DATA_TYPE_24BPP;
> + break;
> + case 16:
> + val |= DES_DATA_TYPE_16BPP;
> + break;
> + case 8:
> + val |= DES_DATA_TYPE_8BPP;
> + break;
> + }
> + /* no shadow for the first frame */
> + if (!start)
> + val |= SHADOW_EN;
> + dpu_prg_write(prg, PRG_CTRL, val);
> +}
> +
> +void dpu_prg_reg_update(struct dpu_prg *prg)
> +{
> + dpu_prg_write(prg, PRG_REG_UPDATE, REG_UPDATE);
> +}
> +
> +void dpu_prg_shadow_enable(struct dpu_prg *prg)
> +{
> + dpu_prg_write(prg, PRG_CTRL + SET, SHADOW_EN);
> +}
> +
> +bool dpu_prg_stride_supported(struct dpu_prg *prg,
> + unsigned int x_offset,
> + unsigned int bits_per_pixel, u64 modifier,
> + unsigned int stride, dma_addr_t baddr)
> +{
> + unsigned int mt_w; /* micro-tile width */
> + unsigned int burst_size;
> + int ret;
> +
> + ret = dpu_prg_mod_to_mt_w(prg, modifier, bits_per_pixel, &mt_w);
> + if (ret)
> + return false;
> +
> + if (modifier) {
> + x_offset %= mt_w;
> +
> + /* consider x offset to calculate stride */
> + baddr += (x_offset * (bits_per_pixel / 8));
> + }
> +
> + burst_size = dpu_prg_burst_size_fixup(baddr);
> +
> + stride = dpu_prg_stride_fixup(stride, burst_size, baddr, modifier);
> +
> + if (stride > DPU_PRG_MAX_STRIDE)
> + return false;
> +
> + return true;
> +}
> +
> +void dpu_prg_set_auxiliary(struct dpu_prg *prg)
> +{
> + prg->is_auxiliary = true;
> +}
> +
> +void dpu_prg_set_primary(struct dpu_prg *prg)
> +{
> + prg->is_auxiliary = false;
> +}
> +
> +struct dpu_prg *
> +dpu_prg_lookup_by_phandle(struct device *dev, const char *name, int index)
> +{
> + struct device_node *prg_node = of_parse_phandle(dev->of_node,
> + name, index);
> + struct dpu_prg *prg;
> +
> + mutex_lock(&dpu_prg_list_mutex);
> + list_for_each_entry(prg, &dpu_prg_list, list) {
> + if (prg_node == prg->dev->of_node) {
> + mutex_unlock(&dpu_prg_list_mutex);
> + device_link_add(dev, prg->dev,
> + DL_FLAG_PM_RUNTIME |
> + DL_FLAG_AUTOREMOVE_CONSUMER);
> + return prg;
> + }
> + }
> + mutex_unlock(&dpu_prg_list_mutex);
> +
> + return NULL;
> +}
> +
> +static const struct of_device_id dpu_prg_dt_ids[] = {
> + { .compatible = "fsl,imx8qm-prg", },
> + { .compatible = "fsl,imx8qxp-prg", },
> + { /* sentinel */ },
> +};
> +
> +static int dpu_prg_probe(struct platform_device *pdev)
> +{
> + struct device *dev = &pdev->dev;
> + struct resource *res;
> + struct dpu_prg *prg;
> + int ret;
> +
> + prg = devm_kzalloc(dev, sizeof(*prg), GFP_KERNEL);
> + if (!prg)
> + return -ENOMEM;
> +
> + res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
> + prg->base = devm_ioremap_resource(&pdev->dev, res);
> + if (IS_ERR(prg->base))
> + return PTR_ERR(prg->base);
> +
> + prg->clk_apb = devm_clk_get(dev, "apb");
> + if (IS_ERR(prg->clk_apb)) {
> + ret = PTR_ERR(prg->clk_apb);
> + dev_err_probe(dev, ret, "failed to get apb clock\n");
> + return ret;
> + }
> +
> + prg->clk_rtram = devm_clk_get(dev, "rtram");
> + if (IS_ERR(prg->clk_rtram)) {
> + ret = PTR_ERR(prg->clk_rtram);
> + dev_err_probe(dev, ret, "failed to get rtram clock\n");
> + return ret;
> + }
> +
> + prg->dev = dev;
> + platform_set_drvdata(pdev, prg);
> +
> + pm_runtime_enable(dev);
> +
> + mutex_lock(&dpu_prg_list_mutex);
> + list_add(&prg->list, &dpu_prg_list);
> + mutex_unlock(&dpu_prg_list_mutex);
> +
> + return 0;
> +}
> +
> +static int dpu_prg_remove(struct platform_device *pdev)
> +{
> + struct dpu_prg *prg = platform_get_drvdata(pdev);
> +
> + mutex_lock(&dpu_prg_list_mutex);
> + list_del(&prg->list);
> + mutex_unlock(&dpu_prg_list_mutex);
> +
> + pm_runtime_disable(&pdev->dev);
> +
> + return 0;
> +}
> +
> +static int __maybe_unused dpu_prg_runtime_suspend(struct device *dev)
> +{
> + struct platform_device *pdev = to_platform_device(dev);
> + struct dpu_prg *prg = platform_get_drvdata(pdev);
> +
> + clk_disable_unprepare(prg->clk_rtram);
> + clk_disable_unprepare(prg->clk_apb);
> +
> + return 0;
> +}
> +
> +static int __maybe_unused dpu_prg_runtime_resume(struct device *dev)
> +{
> + struct platform_device *pdev = to_platform_device(dev);
> + struct dpu_prg *prg = platform_get_drvdata(pdev);
> + int ret;
> +
> + ret = clk_prepare_enable(prg->clk_apb);
> + if (ret) {
> + dev_err(dev, "failed to enable apb clock: %d\n", ret);
> + return ret;
> + }
> +
> + ret = clk_prepare_enable(prg->clk_rtram);
> + if (ret) {
> + dev_err(dev, "failed to enable rtramclock: %d\n", ret);
> + return ret;
> + }
> +
> + dpu_prg_reset(prg);
> +
> + return ret;
> +}
> +
> +static const struct dev_pm_ops dpu_prg_pm_ops = {
> + SET_RUNTIME_PM_OPS(dpu_prg_runtime_suspend,
> + dpu_prg_runtime_resume, NULL)
> +};
> +
> +struct platform_driver dpu_prg_driver = {
> + .probe = dpu_prg_probe,
> + .remove = dpu_prg_remove,
> + .driver = {
> + .pm = &dpu_prg_pm_ops,
> + .name = "dpu-prg",
> + .of_match_table = dpu_prg_dt_ids,
> + },
> +};
> diff --git a/drivers/gpu/drm/imx/dpu/dpu-prg.h b/drivers/gpu/drm/imx/dpu/dpu-prg.h
> new file mode 100644
> index 00000000..550e350
> --- /dev/null
> +++ b/drivers/gpu/drm/imx/dpu/dpu-prg.h
> @@ -0,0 +1,45 @@
> +/* SPDX-License-Identifier: GPL-2.0+ */
> +
> +/*
> + * Copyright 2017-2020 NXP
> + */
> +
> +#ifndef _DPU_PRG_H_
> +#define _DPU_PRG_H_
> +
> +#include <linux/device.h>
> +#include <linux/types.h>
> +
> +#include <drm/drm_fourcc.h>
> +
> +struct dpu_prg;
> +
> +void dpu_prg_enable(struct dpu_prg *prg);
> +
> +void dpu_prg_disable(struct dpu_prg *prg);
> +
> +void dpu_prg_configure(struct dpu_prg *prg,
> + unsigned int width, unsigned int height,
> + unsigned int x_offset, unsigned int y_offset,
> + unsigned int stride, unsigned int bits_per_pixel,
> + dma_addr_t baddr,
> + const struct drm_format_info *format, u64 modifier,
> + bool start);
> +
> +void dpu_prg_reg_update(struct dpu_prg *prg);
> +
> +void dpu_prg_shadow_enable(struct dpu_prg *prg);
> +
> +bool dpu_prg_stride_supported(struct dpu_prg *prg,
> + unsigned int x_offset,
> + unsigned int bits_per_pixel, u64 modifier,
> + unsigned int stride, dma_addr_t baddr);
> +
> +void dpu_prg_set_auxiliary(struct dpu_prg *prg);
> +
> +void dpu_prg_set_primary(struct dpu_prg *prg);
> +
> +struct dpu_prg *
> +dpu_prg_lookup_by_phandle(struct device *dev, const char *name, int index);
> +
> +#endif
> diff --git a/drivers/gpu/drm/imx/dpu/dpu-prv.h b/drivers/gpu/drm/imx/dpu/dpu-prv.h
> new file mode 100644
> index 00000000..6fc2f6b
> --- /dev/null
> +++ b/drivers/gpu/drm/imx/dpu/dpu-prv.h
> @@ -0,0 +1,231 @@
> +/* SPDX-License-Identifier: GPL-2.0+ */
> +
> +/*
> + * Copyright (C) 2016 Freescale Semiconductor, Inc.
> + * Copyright 2017-2020 NXP
> + */
> +
> +#ifndef __DPU_PRV_H__
> +#define __DPU_PRV_H__
> +
> +#include <linux/clk.h>
> +#include <linux/device.h>
> +#include <linux/irqdomain.h>
> +
> +#include "dpu.h"
> +
> +/* DPU common control registers */
> +#define DPU_COMCTRL_REG(offset) (offset)
> +
> +#define IPIDENTIFIER DPU_COMCTRL_REG(0x0)
> +#define LOCKUNLOCK DPU_COMCTRL_REG(0x40)
> +#define LOCKSTATUS DPU_COMCTRL_REG(0x44)
> +#define USERINTERRUPTMASK(n) DPU_COMCTRL_REG(0x48 + 4 * (n))
> +#define INTERRUPTENABLE(n) DPU_COMCTRL_REG(0x50 + 4 * (n))
> +#define INTERRUPTPRESET(n) DPU_COMCTRL_REG(0x58 + 4 * (n))
> +#define INTERRUPTCLEAR(n) DPU_COMCTRL_REG(0x60 + 4 * (n))
> +#define INTERRUPTSTATUS(n) DPU_COMCTRL_REG(0x68 + 4 * (n))
> +#define USERINTERRUPTENABLE(n) DPU_COMCTRL_REG(0x80 + 4 * (n))
> +#define USERINTERRUPTPRESET(n) DPU_COMCTRL_REG(0x88 + 4 * (n))
> +#define USERINTERRUPTCLEAR(n) DPU_COMCTRL_REG(0x90 + 4 * (n))
> +#define USERINTERRUPTSTATUS(n) DPU_COMCTRL_REG(0x98 + 4 * (n))
> +#define GENERALPURPOSE DPU_COMCTRL_REG(0x100)
> +
> +#define DPU_SAFETY_STREAM_OFFSET 4
> +
> +/* shadow enable bit for several DPU units */
> +#define SHDEN BIT(0)
> +
> +/* Pixel Engine Configuration register fields */
> +#define CLKEN_MASK_SHIFT 24
> +#define CLKEN_MASK (0x3 << CLKEN_MASK_SHIFT)
> +#define CLKEN(n) ((n) << CLKEN_MASK_SHIFT)
> +
> +/* H/Vscaler register fields */
> +#define SCALE_FACTOR_MASK 0xfffff
> +#define SCALE_FACTOR(n) ((n) & 0xfffff)
> +#define PHASE_OFFSET_MASK 0x1fffff
> +#define PHASE_OFFSET(n) ((n) & 0x1fffff)
> +#define OUTPUT_SIZE_MASK 0x3fff0000
> +#define OUTPUT_SIZE(n) ((((n) - 1) << 16) & OUTPUT_SIZE_MASK)
> +#define FILTER_MODE_MASK 0x100
> +#define FILTER_MODE(n) ((n) << 8)
> +#define SCALE_MODE_MASK 0x10
> +#define SCALE_MODE(n) ((n) << 4)
> +
> +enum dpu_irq {
> + DPU_IRQ_STORE9_SHDLOAD = 0,
> + DPU_IRQ_STORE9_FRAMECOMPLETE = 1,
> + DPU_IRQ_STORE9_SEQCOMPLETE = 2,
> + DPU_IRQ_EXTDST0_SHDLOAD = 3,
> + DPU_IRQ_EXTDST0_FRAMECOMPLETE = 4,
> + DPU_IRQ_EXTDST0_SEQCOMPLETE = 5,
> + DPU_IRQ_EXTDST4_SHDLOAD = 6,
> + DPU_IRQ_EXTDST4_FRAMECOMPLETE = 7,
> + DPU_IRQ_EXTDST4_SEQCOMPLETE = 8,
> + DPU_IRQ_EXTDST1_SHDLOAD = 9,
> + DPU_IRQ_EXTDST1_FRAMECOMPLETE = 10,
> + DPU_IRQ_EXTDST1_SEQCOMPLETE = 11,
> + DPU_IRQ_EXTDST5_SHDLOAD = 12,
> + DPU_IRQ_EXTDST5_FRAMECOMPLETE = 13,
> + DPU_IRQ_EXTDST5_SEQCOMPLETE = 14,
> + DPU_IRQ_DISENGCFG_SHDLOAD0 = 15,
> + DPU_IRQ_DISENGCFG_FRAMECOMPLETE0 = 16,
> + DPU_IRQ_DISENGCFG_SEQCOMPLETE0 = 17,
> + DPU_IRQ_FRAMEGEN0_INT0 = 18,
> + DPU_IRQ_FRAMEGEN0_INT1 = 19,
> + DPU_IRQ_FRAMEGEN0_INT2 = 20,
> + DPU_IRQ_FRAMEGEN0_INT3 = 21,
> + DPU_IRQ_SIG0_SHDLOAD = 22,
> + DPU_IRQ_SIG0_VALID = 23,
> + DPU_IRQ_SIG0_ERROR = 24,
> + DPU_IRQ_DISENGCFG_SHDLOAD1 = 25,
> + DPU_IRQ_DISENGCFG_FRAMECOMPLETE1 = 26,
> + DPU_IRQ_DISENGCFG_SEQCOMPLETE1 = 27,
> + DPU_IRQ_FRAMEGEN1_INT0 = 28,
> + DPU_IRQ_FRAMEGEN1_INT1 = 29,
> + DPU_IRQ_FRAMEGEN1_INT2 = 30,
> + DPU_IRQ_FRAMEGEN1_INT3 = 31,
> + DPU_IRQ_SIG1_SHDLOAD = 32,
> + DPU_IRQ_SIG1_VALID = 33,
> + DPU_IRQ_SIG1_ERROR = 34,
> + DPU_IRQ_RESERVED = 35,
> + DPU_IRQ_CMDSEQ_ERROR = 36,
> + DPU_IRQ_COMCTRL_SW0 = 37,
> + DPU_IRQ_COMCTRL_SW1 = 38,
> + DPU_IRQ_COMCTRL_SW2 = 39,
> + DPU_IRQ_COMCTRL_SW3 = 40,
> + DPU_IRQ_FRAMEGEN0_PRIMSYNC_ON = 41,
> + DPU_IRQ_FRAMEGEN0_PRIMSYNC_OFF = 42,
> + DPU_IRQ_FRAMEGEN0_SECSYNC_ON = 43,
> + DPU_IRQ_FRAMEGEN0_SECSYNC_OFF = 44,
> + DPU_IRQ_FRAMEGEN1_PRIMSYNC_ON = 45,
> + DPU_IRQ_FRAMEGEN1_PRIMSYNC_OFF = 46,
> + DPU_IRQ_FRAMEGEN1_SECSYNC_ON = 47,
> + DPU_IRQ_FRAMEGEN1_SECSYNC_OFF = 48,
> + DPU_IRQ_COUNT = 49,
> +};
> +
> +enum dpu_unit_type {
> + DPU_DISP,
> + DPU_BLIT,
> +};
> +
> +struct dpu_soc {
> + struct device *dev;
> +
> + struct device *pd_dc_dev;
> + struct device *pd_pll0_dev;
> + struct device *pd_pll1_dev;
> + struct device_link *pd_dc_link;
> + struct device_link *pd_pll0_link;
> + struct device_link *pd_pll1_link;
> +
> + void __iomem *comctrl_reg;
> +
> + struct clk *clk_cfg;
> + struct clk *clk_axi;
> +
> + int irq[DPU_IRQ_COUNT];
> +
> + struct irq_domain *domain;
> +
> + struct dpu_constframe *cf_priv[4];
> + struct dpu_disengcfg *dec_priv[2];
> + struct dpu_extdst *ed_priv[4];
> + struct dpu_fetchunit *fd_priv[3];
> + struct dpu_fetchunit *fe_priv[4];
> + struct dpu_framegen *fg_priv[2];
> + struct dpu_fetchunit *fl_priv[1];
> + struct dpu_fetchunit *fw_priv[2];
> + struct dpu_gammacor *gc_priv[2];
> + struct dpu_hscaler *hs_priv[3];
> + struct dpu_layerblend *lb_priv[4];
> + struct dpu_tcon *tcon_priv[2];
> + struct dpu_vscaler *vs_priv[3];
> +};
> +
> +struct dpu_units {
> + const unsigned int *ids;
> + const enum dpu_unit_type *types;
> + const unsigned long *ofss;
> + const unsigned long *pec_ofss; /* Pixel Engine Configuration */
> + const unsigned int cnt;
> + const char *name;
> +
> + /* software initialization */
> + int (*init)(struct dpu_soc *dpu, unsigned int index,
> + unsigned int id, enum dpu_unit_type type,
> + unsigned long pec_base, unsigned long base);
> +
> + /* hardware initialization */
> + void (*hw_init)(struct dpu_soc *dpu, unsigned int index);
> +};
> +
> +void dpu_cf_hw_init(struct dpu_soc *dpu, unsigned int index);
> +void dpu_dec_hw_init(struct dpu_soc *dpu, unsigned int index);
> +void dpu_ed_hw_init(struct dpu_soc *dpu, unsigned int index);
> +void dpu_fd_hw_init(struct dpu_soc *dpu, unsigned int index);
> +void dpu_fe_hw_init(struct dpu_soc *dpu, unsigned int index);
> +void dpu_fg_hw_init(struct dpu_soc *dpu, unsigned int index);
> +void dpu_fl_hw_init(struct dpu_soc *dpu, unsigned int index);
> +void dpu_fw_hw_init(struct dpu_soc *dpu, unsigned int index);
> +void dpu_gc_hw_init(struct dpu_soc *dpu, unsigned int index);
> +void dpu_hs_hw_init(struct dpu_soc *dpu, unsigned int index);
> +void dpu_lb_hw_init(struct dpu_soc *dpu, unsigned int index);
> +void dpu_tcon_hw_init(struct dpu_soc *dpu, unsigned int index);
> +void dpu_vs_hw_init(struct dpu_soc *dpu, unsigned int index);
> +
> +int dpu_cf_init(struct dpu_soc *dpu, unsigned int index,
> + unsigned int id, enum dpu_unit_type type,
> + unsigned long pec_base, unsigned long base);
> +
> +int dpu_dec_init(struct dpu_soc *dpu, unsigned int index,
> + unsigned int id, enum dpu_unit_type type,
> + unsigned long unused, unsigned long base);
> +
> +int dpu_ed_init(struct dpu_soc *dpu, unsigned int index,
> + unsigned int id, enum dpu_unit_type type,
> + unsigned long pec_base, unsigned long base);
> +
> +int dpu_fd_init(struct dpu_soc *dpu, unsigned int index,
> + unsigned int id, enum dpu_unit_type type,
> + unsigned long pec_base, unsigned long base);
> +
> +int dpu_fe_init(struct dpu_soc *dpu, unsigned int index,
> + unsigned int id, enum dpu_unit_type type,
> + unsigned long pec_base, unsigned long base);
> +
> +int dpu_fg_init(struct dpu_soc *dpu, unsigned int index,
> + unsigned int id, enum dpu_unit_type type,
> + unsigned long unused, unsigned long base);
> +
> +int dpu_fl_init(struct dpu_soc *dpu, unsigned int index,
> + unsigned int id, enum dpu_unit_type type,
> + unsigned long pec_base, unsigned long base);
> +
> +int dpu_fw_init(struct dpu_soc *dpu, unsigned int index,
> + unsigned int id, enum dpu_unit_type type,
> + unsigned long pec_base, unsigned long base);
> +
> +int dpu_gc_init(struct dpu_soc *dpu, unsigned int index,
> + unsigned int id, enum dpu_unit_type type,
> + unsigned long unused, unsigned long base);
> +
> +int dpu_hs_init(struct dpu_soc *dpu, unsigned int index,
> + unsigned int id, enum dpu_unit_type type,
> + unsigned long pec_base, unsigned long base);
> +
> +int dpu_lb_init(struct dpu_soc *dpu, unsigned int index,
> + unsigned int id, enum dpu_unit_type type,
> + unsigned long pec_base, unsigned long base);
> +
> +int dpu_tcon_init(struct dpu_soc *dpu, unsigned int index,
> + unsigned int id, enum dpu_unit_type type,
> + unsigned long unused, unsigned long base);
> +
> +int dpu_vs_init(struct dpu_soc *dpu, unsigned int index,
> + unsigned int id, enum dpu_unit_type type,
> + unsigned long pec_base, unsigned long base);
> +
> +#endif /* __DPU_PRV_H__ */
> diff --git a/drivers/gpu/drm/imx/dpu/dpu-tcon.c b/drivers/gpu/drm/imx/dpu/dpu-tcon.c
> new file mode 100644
> index 00000000..143f51f
> --- /dev/null
> +++ b/drivers/gpu/drm/imx/dpu/dpu-tcon.c
> @@ -0,0 +1,250 @@
> +// SPDX-License-Identifier: GPL-2.0+
> +
> +/*
> + * Copyright (C) 2016 Freescale Semiconductor, Inc.
> + * Copyright 2017-2020 NXP
> + */
> +
> +#include <linux/io.h>
> +#include <linux/kernel.h>
> +#include <linux/mutex.h>
> +#include <linux/sizes.h>
> +
> +#include "dpu.h"
> +#include "dpu-prv.h"
> +
> +#define SSQCNTS 0x0
> +#define SSQCYCLE 0x408
> +#define SWRESET 0x40c
> +
> +#define TCON_CTRL 0x410
> +#define CTRL_RST_VAL 0x01401408
> +#define BYPASS BIT(3)
> +
> +#define RSDSINVCTRL 0x414
> +
> +/* red: MAPBIT 29-20, green: MAPBIT 19-10, blue: MAPBIT 9-0 */
> +#define MAPBIT3_0 0x418
> +#define MAPBIT7_4 0x41c
> +#define MAPBIT11_8 0x420
> +#define MAPBIT15_12 0x424
> +#define MAPBIT19_16 0x428
> +#define MAPBIT23_20 0x42c
> +#define MAPBIT27_24 0x430
> +#define MAPBIT31_28 0x434
> +#define MAPBIT34_32 0x438
> +#define MAPBIT3_0_DUAL 0x43c
> +#define MAPBIT7_4_DUAL 0x440
> +#define MAPBIT11_8_DUAL 0x444
> +#define MAPBIT15_12_DUAL 0x448
> +#define MAPBIT19_16_DUAL 0x44c
> +#define MAPBIT23_20_DUAL 0x450
> +#define MAPBIT27_24_DUAL 0x454
> +#define MAPBIT31_28_DUAL 0x458
> +#define MAPBIT34_32_DUAL 0x45c
> +
> +#define SPGPOSON(n) (0x460 + (n) * 16)
> +#define SPGMASKON(n) (0x464 + (n) * 16)
> +#define SPGPOSOFF(n) (0x468 + (n) * 16)
> +#define SPGMASKOFF(n) (0x46c + (n) * 16)
> +#define X(n) (((n) & 0x7fff) << 16)
> +#define Y(n) ((n) & 0x7fff)
> +
> +#define SMXSIGS(n) (0x520 + (n) * 8)
> +#define SMXFCTTABLE(n) (0x524 + (n) * 8)
> +#define RESET_OVER_UNFERFLOW 0x580
> +#define DUAL_DEBUG 0x584
> +
> +struct dpu_tcon {
> + void __iomem *base;
> + struct mutex mutex;
> + unsigned int id;
> + unsigned int index;
> + bool inuse;
> + struct dpu_soc *dpu;
> +};
> +
> +static inline u32 dpu_tcon_read(struct dpu_tcon *tcon, unsigned int offset)
> +{
> + return readl(tcon->base + offset);
> +}
> +
> +static inline void dpu_tcon_write(struct dpu_tcon *tcon,
> + unsigned int offset, u32 value)
> +{
> + writel(value, tcon->base + offset);
> +}
> +
> +static inline void dpu_tcon_write_mask(struct dpu_tcon *tcon,
> + unsigned int offset, u32 mask, u32 value)
> +{
> + u32 tmp;
> +
> + tmp = dpu_tcon_read(tcon, offset);
> + tmp &= ~mask;
> + dpu_tcon_write(tcon, offset, tmp | value);
> +}
> +
> +void dpu_tcon_set_fmt(struct dpu_tcon *tcon)
> +{
> + /*
> + * The pixels reach TCON are always in 30-bit BGR format.
> + * The first bridge always receives pixels in 30-bit RGB format.
> + * So, map the format to MEDIA_BUS_FMT_RGB101010_1X30.
> + */
> + dpu_tcon_write(tcon, MAPBIT3_0, 0x17161514);
> + dpu_tcon_write(tcon, MAPBIT7_4, 0x1b1a1918);
> + dpu_tcon_write(tcon, MAPBIT11_8, 0x0b0a1d1c);
> + dpu_tcon_write(tcon, MAPBIT15_12, 0x0f0e0d0c);
> + dpu_tcon_write(tcon, MAPBIT19_16, 0x13121110);
> + dpu_tcon_write(tcon, MAPBIT23_20, 0x03020100);
> + dpu_tcon_write(tcon, MAPBIT27_24, 0x07060504);
> + dpu_tcon_write(tcon, MAPBIT31_28, 0x00000908);
> +}
> +
> +void dpu_tcon_set_operation_mode(struct dpu_tcon *tcon)
> +{
> + dpu_tcon_write_mask(tcon, TCON_CTRL, BYPASS, 0);
> +}
> +
> +void dpu_tcon_cfg_videomode(struct dpu_tcon *tcon, struct drm_display_mode *m)
> +{
> + int hdisplay, hsync_start, hsync_end;
> + int vdisplay, vsync_start, vsync_end;
> + int y;
> +
> + hdisplay = m->hdisplay;
> + vdisplay = m->vdisplay;
> + hsync_start = m->hsync_start;
> + vsync_start = m->vsync_start;
> + hsync_end = m->hsync_end;
> + vsync_end = m->vsync_end;
> +
> + /*
> + * TKT320590:
> + * Turn TCON into operation mode later after the first dumb frame is
> + * generated by DPU. This makes DPR/PRG be able to evade the frame.
> + */
> + dpu_tcon_write_mask(tcon, TCON_CTRL, BYPASS, BYPASS);
> +
> + /* dsp_control[0]: hsync */
> + dpu_tcon_write(tcon, SPGPOSON(0), X(hsync_start));
> + dpu_tcon_write(tcon, SPGMASKON(0), 0xffff);
> +
> + dpu_tcon_write(tcon, SPGPOSOFF(0), X(hsync_end));
> + dpu_tcon_write(tcon, SPGMASKOFF(0), 0xffff);
> +
> + dpu_tcon_write(tcon, SMXSIGS(0), 0x2);
> + dpu_tcon_write(tcon, SMXFCTTABLE(0), 0x1);
> +
> + /* dsp_control[1]: vsync */
> + dpu_tcon_write(tcon, SPGPOSON(1), X(hsync_start) | Y(vsync_start - 1));
> + dpu_tcon_write(tcon, SPGMASKON(1), 0x0);
> +
> + dpu_tcon_write(tcon, SPGPOSOFF(1), X(hsync_start) | Y(vsync_end - 1));
> + dpu_tcon_write(tcon, SPGMASKOFF(1), 0x0);
> +
> + dpu_tcon_write(tcon, SMXSIGS(1), 0x3);
> + dpu_tcon_write(tcon, SMXFCTTABLE(1), 0x1);
> +
> + /* dsp_control[2]: data enable */
> + /* horizontal */
> + dpu_tcon_write(tcon, SPGPOSON(2), 0x0);
> + dpu_tcon_write(tcon, SPGMASKON(2), 0xffff);
> +
> + dpu_tcon_write(tcon, SPGPOSOFF(2), X(hdisplay));
> + dpu_tcon_write(tcon, SPGMASKOFF(2), 0xffff);
> +
> + /* vertical */
> + dpu_tcon_write(tcon, SPGPOSON(3), 0x0);
> + dpu_tcon_write(tcon, SPGMASKON(3), 0x7fff0000);
> +
> + dpu_tcon_write(tcon, SPGPOSOFF(3), Y(vdisplay));
> + dpu_tcon_write(tcon, SPGMASKOFF(3), 0x7fff0000);
> +
> + dpu_tcon_write(tcon, SMXSIGS(2), 0x2c);
> + dpu_tcon_write(tcon, SMXFCTTABLE(2), 0x8);
> +
> + /* dsp_control[3]: kachuck */
> + y = vdisplay + 1;
> +
> + dpu_tcon_write(tcon, SPGPOSON(4), X(0x0) | Y(y));
> + dpu_tcon_write(tcon, SPGMASKON(4), 0x0);
> +
> + dpu_tcon_write(tcon, SPGPOSOFF(4), X(0x20) | Y(y));
> + dpu_tcon_write(tcon, SPGMASKOFF(4), 0x0);
> +
> + dpu_tcon_write(tcon, SMXSIGS(3), 0x6);
> + dpu_tcon_write(tcon, SMXFCTTABLE(3), 0x2);
> +}
> +
> +struct dpu_tcon *dpu_tcon_get(struct dpu_soc *dpu, unsigned int id)
> +{
> + struct dpu_tcon *tcon;
> + int i;
> +
> + for (i = 0; i < ARRAY_SIZE(dpu->tcon_priv); i++) {
> + tcon = dpu->tcon_priv[i];
> + if (tcon->id == id)
> + break;
> + }
> +
> + if (i == ARRAY_SIZE(dpu->tcon_priv))
> + return ERR_PTR(-EINVAL);
> +
> + mutex_lock(&tcon->mutex);
> +
> + if (tcon->inuse) {
> + mutex_unlock(&tcon->mutex);
> + return ERR_PTR(-EBUSY);
> + }
> +
> + tcon->inuse = true;
> +
> + mutex_unlock(&tcon->mutex);
> +
> + return tcon;
> +}
> +
> +void dpu_tcon_put(struct dpu_tcon *tcon)
> +{
> + if (IS_ERR_OR_NULL(tcon))
> + return;
> +
> + mutex_lock(&tcon->mutex);
> +
> + tcon->inuse = false;
> +
> + mutex_unlock(&tcon->mutex);
> +}
> +
> +void dpu_tcon_hw_init(struct dpu_soc *dpu, unsigned int index)
> +{
> + /* reset TCON_CTRL to POR default so that TCON works in bypass mode */
> + dpu_tcon_write(dpu->tcon_priv[index], TCON_CTRL, CTRL_RST_VAL);
> +}
> +
> +int dpu_tcon_init(struct dpu_soc *dpu, unsigned int index,
> + unsigned int id, enum dpu_unit_type type,
> + unsigned long unused, unsigned long base)
> +{
> + struct dpu_tcon *tcon;
> +
> + tcon = devm_kzalloc(dpu->dev, sizeof(*tcon), GFP_KERNEL);
> + if (!tcon)
> + return -ENOMEM;
> +
> + dpu->tcon_priv[index] = tcon;
> +
> + tcon->base = devm_ioremap(dpu->dev, base, SZ_2K);
> + if (!tcon->base)
> + return -ENOMEM;
> +
> + tcon->dpu = dpu;
> + tcon->id = id;
> + tcon->index = index;
> +
> + mutex_init(&tcon->mutex);
> +
> + return 0;
> +}
> diff --git a/drivers/gpu/drm/imx/dpu/dpu-vscaler.c b/drivers/gpu/drm/imx/dpu/dpu-vscaler.c
> new file mode 100644
> index 00000000..bdef0cd
> --- /dev/null
> +++ b/drivers/gpu/drm/imx/dpu/dpu-vscaler.c
> @@ -0,0 +1,308 @@
> +// SPDX-License-Identifier: GPL-2.0+
> +
> +/*
> + * Copyright 2017-2020 NXP
> + */
> +
> +#include <linux/io.h>
> +#include <linux/kernel.h>
> +#include <linux/mutex.h>
> +#include <linux/sizes.h>
> +
> +#include "dpu.h"
> +#include "dpu-prv.h"
> +
> +#define PIXENGCFG_DYNAMIC 0x8
> +#define PIXENGCFG_DYNAMIC_SRC_SEL_MASK 0x3f
> +
> +#define STATICCONTROL 0x8
> +
> +#define SETUP(n) (0xc + ((n) - 1) * 0x4)
> +
> +#define CONTROL 0x20
> +#define FIELD_MODE_MASK 0x3000
> +#define FIELD_MODE(n) ((n) << 12)
> +#define CTRL_MODE_MASK BIT(0)
> +
> +struct dpu_vscaler {
> + void __iomem *pec_base;
> + void __iomem *base;
> + struct mutex mutex;
> + unsigned int id;
> + unsigned int index;
> + enum dpu_link_id link_id;
> + bool inuse;
> + struct dpu_soc *dpu;
> +};
> +
> +static const enum dpu_link_id dpu_vs_link_id[] = {
> + LINK_ID_VSCALER4, LINK_ID_VSCALER5, LINK_ID_VSCALER9
> +};
> +
> +static const enum dpu_link_id src_sels[3][4] = {
> + {
> + LINK_ID_NONE,
> + LINK_ID_FETCHDECODE0,
> + LINK_ID_MATRIX4,
> + LINK_ID_HSCALER4,
> + }, {
> + LINK_ID_NONE,
> + LINK_ID_FETCHDECODE1,
> + LINK_ID_MATRIX5,
> + LINK_ID_HSCALER5,
> + }, {
> + LINK_ID_NONE,
> + LINK_ID_MATRIX9,
> + LINK_ID_HSCALER9,
> + },
> +};
> +
> +static inline u32 dpu_pec_vs_read(struct dpu_vscaler *vs,
> + unsigned int offset)
> +{
> + return readl(vs->pec_base + offset);
> +}
> +
> +static inline void dpu_pec_vs_write(struct dpu_vscaler *vs,
> + unsigned int offset, u32 value)
> +{
> + writel(value, vs->pec_base + offset);
> +}
> +
> +static inline void dpu_pec_vs_write_mask(struct dpu_vscaler *vs,
> + unsigned int offset,
> + u32 mask, u32 value)
> +{
> + u32 tmp;
> +
> + tmp = dpu_pec_vs_read(vs, offset);
> + tmp &= ~mask;
> + dpu_pec_vs_write(vs, offset, tmp | value);
> +}
> +
> +static inline u32 dpu_vs_read(struct dpu_vscaler *vs, unsigned int offset)
> +{
> + return readl(vs->base + offset);
> +}
> +
> +static inline void dpu_vs_write(struct dpu_vscaler *vs,
> + unsigned int offset, u32 value)
> +{
> + writel(value, vs->base + offset);
> +}
> +
> +static inline void dpu_vs_write_mask(struct dpu_vscaler *vs,
> + unsigned int offset, u32 mask, u32 value)
> +{
> + u32 tmp;
> +
> + tmp = dpu_vs_read(vs, offset);
> + tmp &= ~mask;
> + dpu_vs_write(vs, offset, tmp | value);
> +}
> +
> +enum dpu_link_id dpu_vs_get_link_id(struct dpu_vscaler *vs)
> +{
> + return vs->link_id;
> +}
> +
> +void dpu_vs_pec_dynamic_src_sel(struct dpu_vscaler *vs, enum dpu_link_id src)
> +{
> + struct dpu_soc *dpu = vs->dpu;
> + int i;
> +
> + for (i = 0; i < ARRAY_SIZE(src_sels[vs->index]); i++) {
> + if (src_sels[vs->index][i] == src) {
> + dpu_pec_vs_write_mask(vs, PIXENGCFG_DYNAMIC,
> + PIXENGCFG_DYNAMIC_SRC_SEL_MASK,
> + src);
> + return;
> + }
> + }
> +
> + dev_err(dpu->dev, "VScaler%u - invalid source 0x%02x\n", vs->id, src);
> +}
> +
> +void dpu_vs_pec_clken(struct dpu_vscaler *vs, enum dpu_pec_clken clken)
> +{
> + dpu_pec_vs_write_mask(vs, PIXENGCFG_DYNAMIC, CLKEN_MASK, CLKEN(clken));
> +}
> +
> +static void dpu_vs_enable_shden(struct dpu_vscaler *vs)
> +{
> + dpu_vs_write_mask(vs, STATICCONTROL, SHDEN, SHDEN);
> +}
> +
> +void dpu_vs_setup1(struct dpu_vscaler *vs,
> + unsigned int src_w, unsigned int dst_w, bool deinterlace)
> +{
> + struct dpu_soc *dpu = vs->dpu;
> + u32 scale_factor;
> + u64 tmp64;
> +
> + if (deinterlace)
> + dst_w *= 2;
> +
> + if (src_w == dst_w) {
> + scale_factor = 0x80000;
> + } else {
> + if (src_w > dst_w) {
> + tmp64 = (u64)((u64)dst_w * 0x80000);
> + do_div(tmp64, src_w);
> +
> + } else {
> + tmp64 = (u64)((u64)src_w * 0x80000);
> + do_div(tmp64, dst_w);
> + }
> + scale_factor = (u32)tmp64;
> + }
> +
> + if (scale_factor > 0x80000) {
> + dev_err(dpu->dev, "VScaler%u - invalid scale factor 0x%08x\n",
> + vs->id, scale_factor);
> + return;
> + }
> +
> + dpu_vs_write(vs, SETUP(1), SCALE_FACTOR(scale_factor));
> +
> + dev_dbg(dpu->dev, "VScaler%u - scale factor 0x%08x\n",
> + vs->id, scale_factor);
> +}
> +
> +void dpu_vs_setup2(struct dpu_vscaler *vs, bool deinterlace)
> +{
> + /* 0x20000: +0.25 phase offset for deinterlace */
> + u32 phase_offset = deinterlace ? 0x20000 : 0;
> +
> + dpu_vs_write(vs, SETUP(2), PHASE_OFFSET(phase_offset));
> +}
> +
> +void dpu_vs_setup3(struct dpu_vscaler *vs, bool deinterlace)
> +{
> + /* 0x1e0000: -0.25 phase offset for deinterlace */
> + u32 phase_offset = deinterlace ? 0x1e0000 : 0;
> +
> + dpu_vs_write(vs, SETUP(3), PHASE_OFFSET(phase_offset));
> +}
> +
> +void dpu_vs_setup4(struct dpu_vscaler *vs, u32 phase_offset)
> +{
> + dpu_vs_write(vs, SETUP(4), PHASE_OFFSET(phase_offset));
> +}
> +
> +void dpu_vs_setup5(struct dpu_vscaler *vs, u32 phase_offset)
> +{
> + dpu_vs_write(vs, SETUP(5), PHASE_OFFSET(phase_offset));
> +}
> +
> +void dpu_vs_output_size(struct dpu_vscaler *vs, u32 line_num)
> +{
> + dpu_vs_write_mask(vs, CONTROL, OUTPUT_SIZE_MASK, OUTPUT_SIZE(line_num));
> +}
> +
> +void dpu_vs_field_mode(struct dpu_vscaler *vs, enum dpu_scaler_field_mode m)
> +{
> + dpu_vs_write_mask(vs, CONTROL, FIELD_MODE_MASK, FIELD_MODE(m));
> +}
> +
> +void dpu_vs_filter_mode(struct dpu_vscaler *vs, enum dpu_scaler_filter_mode m)
> +{
> + dpu_vs_write_mask(vs, CONTROL, FILTER_MODE_MASK, FILTER_MODE(m));
> +}
> +
> +void dpu_vs_scale_mode(struct dpu_vscaler *vs, enum dpu_scaler_scale_mode m)
> +{
> + dpu_vs_write_mask(vs, CONTROL, SCALE_MODE_MASK, SCALE_MODE(m));
> +}
> +
> +void dpu_vs_mode(struct dpu_vscaler *vs, enum dpu_scaler_mode m)
> +{
> + dpu_vs_write_mask(vs, CONTROL, CTRL_MODE_MASK, m);
> +}
> +
> +unsigned int dpu_vs_get_id(struct dpu_vscaler *vs)
> +{
> + return vs->id;
> +}
> +
> +struct dpu_vscaler *dpu_vs_get(struct dpu_soc *dpu, unsigned int id)
> +{
> + struct dpu_vscaler *vs;
> + int i;
> +
> + for (i = 0; i < ARRAY_SIZE(dpu->vs_priv); i++) {
> + vs = dpu->vs_priv[i];
> + if (vs->id == id)
> + break;
> + }
> +
> + if (i == ARRAY_SIZE(dpu->vs_priv))
> + return ERR_PTR(-EINVAL);
> +
> + mutex_lock(&vs->mutex);
> +
> + if (vs->inuse) {
> + mutex_unlock(&vs->mutex);
> + return ERR_PTR(-EBUSY);
> + }
> +
> + vs->inuse = true;
> +
> + mutex_unlock(&vs->mutex);
> +
> + return vs;
> +}
> +
> +void dpu_vs_put(struct dpu_vscaler *vs)
> +{
> + if (IS_ERR_OR_NULL(vs))
> + return;
> +
> + mutex_lock(&vs->mutex);
> +
> + vs->inuse = false;
> +
> + mutex_unlock(&vs->mutex);
> +}
> +
> +void dpu_vs_hw_init(struct dpu_soc *dpu, unsigned int index)
> +{
> + struct dpu_vscaler *vs = dpu->vs_priv[index];
> +
> + dpu_vs_enable_shden(vs);
> + dpu_vs_setup2(vs, false);
> + dpu_vs_setup3(vs, false);
> + dpu_vs_setup4(vs, 0);
> + dpu_vs_setup5(vs, 0);
> + dpu_vs_pec_dynamic_src_sel(vs, LINK_ID_NONE);
> +}
> +
> +int dpu_vs_init(struct dpu_soc *dpu, unsigned int index,
> + unsigned int id, enum dpu_unit_type type,
> + unsigned long pec_base, unsigned long base)
> +{
> + struct dpu_vscaler *vs;
> +
> + vs = devm_kzalloc(dpu->dev, sizeof(*vs), GFP_KERNEL);
> + if (!vs)
> + return -ENOMEM;
> +
> + dpu->vs_priv[index] = vs;
> +
> + vs->pec_base = devm_ioremap(dpu->dev, pec_base, SZ_16);
> + if (!vs->pec_base)
> + return -ENOMEM;
> +
> + vs->base = devm_ioremap(dpu->dev, base, SZ_32);
> + if (!vs->base)
> + return -ENOMEM;
> +
> + vs->dpu = dpu;
> + vs->id = id;
> + vs->index = index;
> + vs->link_id = dpu_vs_link_id[index];
> +
> + mutex_init(&vs->mutex);
> +
> + return 0;
> +}
> diff --git a/drivers/gpu/drm/imx/dpu/dpu.h b/drivers/gpu/drm/imx/dpu/dpu.h
> new file mode 100644
> index 00000000..ef012e2
> --- /dev/null
> +++ b/drivers/gpu/drm/imx/dpu/dpu.h
> @@ -0,0 +1,385 @@
> +/* SPDX-License-Identifier: GPL-2.0+ */
> +
> +/*
> + * Copyright (C) 2016 Freescale Semiconductor, Inc.
> + * Copyright 2017-2020 NXP
> + */
> +
> +#ifndef __DPU_H__
> +#define __DPU_H__
> +
> +#include <linux/of.h>
> +#include <linux/types.h>
> +
> +#include <drm/drm_color_mgmt.h>
> +#include <drm/drm_fourcc.h>
> +#include <drm/drm_modes.h>
> +
> +#define DPU_FRAMEGEN_MAX_FRAME_INDEX 0x3ffff
> +#define DPU_FRAMEGEN_MAX_CLOCK 300000 /* in KHz */
> +
> +#define DPU_FETCHUNIT_CAP_USE_FETCHECO BIT(0)
> +#define DPU_FETCHUNIT_CAP_USE_SCALER BIT(1)
> +#define DPU_FETCHUNIT_CAP_PACKED_YUV422 BIT(2)
> +
> +struct dpu_dprc;
> +struct dpu_fetchunit;
> +struct dpu_soc;
> +
> +enum dpu_link_id {
> + LINK_ID_NONE = 0x00,
> + LINK_ID_FETCHDECODE9 = 0x01,
> + LINK_ID_FETCHWARP9 = 0x02,
> + LINK_ID_FETCHECO9 = 0x03,
> + LINK_ID_ROP9 = 0x04,
> + LINK_ID_CLUT9 = 0x05,
> + LINK_ID_MATRIX9 = 0x06,
> + LINK_ID_HSCALER9 = 0x07,
> + LINK_ID_VSCALER9 = 0x08,
> + LINK_ID_FILTER9 = 0x09,
> + LINK_ID_BLITBLEND9 = 0x0a,
> + LINK_ID_CONSTFRAME0 = 0x0c,
> + LINK_ID_CONSTFRAME4 = 0x0e,
> + LINK_ID_CONSTFRAME1 = 0x10,
> + LINK_ID_CONSTFRAME5 = 0x12,
> + LINK_ID_FETCHWARP2 = 0x14,
> + LINK_ID_FETCHECO2 = 0x15,
> + LINK_ID_FETCHDECODE0 = 0x16,
> + LINK_ID_FETCHECO0 = 0x17,
> + LINK_ID_FETCHDECODE1 = 0x18,
> + LINK_ID_FETCHECO1 = 0x19,
> + LINK_ID_FETCHLAYER0 = 0x1a,
> + LINK_ID_MATRIX4 = 0x1b,
> + LINK_ID_HSCALER4 = 0x1c,
> + LINK_ID_VSCALER4 = 0x1d,
> + LINK_ID_MATRIX5 = 0x1e,
> + LINK_ID_HSCALER5 = 0x1f,
> + LINK_ID_VSCALER5 = 0x20,
> + LINK_ID_LAYERBLEND0 = 0x21,
> + LINK_ID_LAYERBLEND1 = 0x22,
> + LINK_ID_LAYERBLEND2 = 0x23,
> + LINK_ID_LAYERBLEND3 = 0x24,
> +};
> +
> +enum dpu_fg_syncmode {
> + FG_SYNCMODE_OFF, /* No side-by-side synchronization. */
> + FG_SYNCMODE_MASTER, /* Framegen is master. */
> + FG_SYNCMODE_SLAVE_CYC, /* Runs in cyclic synchronization mode. */
> + FG_SYNCMODE_SLAVE_ONCE, /* Runs in one time synchronization mode. */
> +};
> +
> +enum dpu_fg_dm {
> + FG_DM_BLACK,
> + FG_DM_CONSTCOL, /* Constant Color Background is shown. */
> + FG_DM_PRIM,
> + FG_DM_SEC,
> + FG_DM_PRIM_ON_TOP,
> + FG_DM_SEC_ON_TOP,
> + FG_DM_TEST, /* White color background with test pattern is shown. */
> +};
> +
> +enum dpu_gc_mode {
> + GC_NEUTRAL, /* Input data is bypassed to the output. */
> + GC_GAMMACOR,
> +};
> +
> +enum dpu_lb_mode {
> + LB_NEUTRAL, /* Output is same as primary input. */
> + LB_BLEND,
> +};
> +
> +enum dpu_scaler_field_mode {
> + /* Constant 0 indicates frame or top field. */
> + SCALER_ALWAYS0,
> + /* Constant 1 indicates bottom field. */
> + SCALER_ALWAYS1,
> + /* Output field polarity is taken from input field polarity. */
> + SCALER_INPUT,
> + /* Output field polarity toggles, starting with 0 after reset. */
> + SCALER_TOGGLE,
> +};
> +
> +enum dpu_scaler_filter_mode {
> + SCALER_NEAREST, /* pointer-sampling */
> + SCALER_LINEAR, /* box filter */
> +};
> +
> +enum dpu_scaler_scale_mode {
> + SCALER_DOWNSCALE,
> + SCALER_UPSCALE,
> +};
> +
> +enum dpu_scaler_mode {
> + /* Pixel by-pass the scaler, all other settings are ignored. */
> + SCALER_NEUTRAL,
> + /* Scaler is active. */
> + SCALER_ACTIVE,
> +};
> +
> +enum dpu_pec_clken {
> + CLKEN_DISABLE = 0x0,
> + CLKEN_AUTOMATIC = 0x1,
> + CLKEN_FULL = 0x3,
> +};
> +
> +int dpu_map_irq(struct dpu_soc *dpu, int irq);
> +
> +/* Constant Frame Unit */
> +struct dpu_constframe;
> +enum dpu_link_id dpu_cf_get_link_id(struct dpu_constframe *cf);
> +void dpu_cf_framedimensions(struct dpu_constframe *cf, unsigned int w,
> + unsigned int h);
> +void dpu_cf_constantcolor_black(struct dpu_constframe *cf);
> +void dpu_cf_constantcolor_blue(struct dpu_constframe *cf);
> +struct dpu_constframe *dpu_cf_safe_get(struct dpu_soc *dpu,
> + unsigned int stream_id);
> +void dpu_cf_safe_put(struct dpu_constframe *cf);
> +struct dpu_constframe *dpu_cf_cont_get(struct dpu_soc *dpu,
> + unsigned int stream_id);
> +void dpu_cf_cont_put(struct dpu_constframe *cf);
> +
> +/* Display Engine Configuration Unit */
> +struct dpu_disengcfg;
> +struct dpu_disengcfg *dpu_dec_get(struct dpu_soc *dpu, unsigned int id);
> +void dpu_dec_put(struct dpu_disengcfg *dec);
> +
> +/* External Destination Unit */
> +struct dpu_extdst;
> +void dpu_ed_pec_poweron(struct dpu_extdst *ed);
> +void dpu_ed_pec_src_sel(struct dpu_extdst *ed, enum dpu_link_id src);
> +void dpu_ed_pec_sync_trigger(struct dpu_extdst *ed);
> +struct dpu_extdst *dpu_ed_safe_get(struct dpu_soc *dpu,
> + unsigned int stream_id);
> +void dpu_ed_safe_put(struct dpu_extdst *ed);
> +struct dpu_extdst *dpu_ed_cont_get(struct dpu_soc *dpu,
> + unsigned int stream_id);
> +void dpu_ed_cont_put(struct dpu_extdst *ed);
> +
> +/* Fetch Decode Unit */
> +struct dpu_fetchunit *dpu_fd_get(struct dpu_soc *dpu, unsigned int id);
> +void dpu_fd_put(struct dpu_fetchunit *fu);
> +
> +/* Fetch ECO Unit */
> +struct dpu_fetchunit *dpu_fe_get(struct dpu_soc *dpu, unsigned int id);
> +void dpu_fe_put(struct dpu_fetchunit *fu);
> +
> +/* Fetch Layer Unit */
> +struct dpu_fetchunit *dpu_fl_get(struct dpu_soc *dpu, unsigned int id);
> +void dpu_fl_put(struct dpu_fetchunit *fu);
> +
> +/* Fetch Warp Unit */
> +struct dpu_fetchunit *dpu_fw_get(struct dpu_soc *dpu, unsigned int id);
> +void dpu_fw_put(struct dpu_fetchunit *fu);
> +
> +/* Frame Generator Unit */
> +struct dpu_framegen;
> +void dpu_fg_syncmode(struct dpu_framegen *fg, enum dpu_fg_syncmode mode);
> +void dpu_fg_cfg_videomode(struct dpu_framegen *fg, struct drm_display_mode *m);
> +void dpu_fg_displaymode(struct dpu_framegen *fg, enum dpu_fg_dm mode);
> +void dpu_fg_panic_displaymode(struct dpu_framegen *fg, enum dpu_fg_dm mode);
> +void dpu_fg_enable(struct dpu_framegen *fg);
> +void dpu_fg_disable(struct dpu_framegen *fg);
> +void dpu_fg_shdtokgen(struct dpu_framegen *fg);
> +u32 dpu_fg_get_frame_index(struct dpu_framegen *fg);
> +int dpu_fg_get_line_index(struct dpu_framegen *fg);
> +int dpu_fg_wait_for_frame_counter_moving(struct dpu_framegen *fg);
> +bool dpu_fg_secondary_requests_to_read_empty_fifo(struct dpu_framegen *fg);
> +void dpu_fg_secondary_clear_channel_status(struct dpu_framegen *fg);
> +int dpu_fg_wait_for_secondary_syncup(struct dpu_framegen *fg);
> +void dpu_fg_enable_clock(struct dpu_framegen *fg);
> +void dpu_fg_disable_clock(struct dpu_framegen *fg);
> +struct dpu_framegen *dpu_fg_get(struct dpu_soc *dpu, unsigned int id);
> +void dpu_fg_put(struct dpu_framegen *fg);
> +
> +/* Gamma Correction Unit */
> +struct dpu_gammacor;
> +void dpu_gc_enable_rgb_write(struct dpu_gammacor *gc);
> +void dpu_gc_disable_rgb_write(struct dpu_gammacor *gc);
> +void dpu_gc_start_rgb(struct dpu_gammacor *gc, const struct drm_color_lut *lut);
> +void dpu_gc_delta_rgb(struct dpu_gammacor *gc, const struct drm_color_lut *lut);
> +void dpu_gc_mode(struct dpu_gammacor *gc, enum dpu_gc_mode mode);
> +struct dpu_gammacor *dpu_gc_get(struct dpu_soc *dpu, unsigned int id);
> +void dpu_gc_put(struct dpu_gammacor *gc);
> +
> +/* Horizontal Scaler Unit */
> +struct dpu_hscaler;
> +enum dpu_link_id dpu_hs_get_link_id(struct dpu_hscaler *hs);
> +void dpu_hs_pec_dynamic_src_sel(struct dpu_hscaler *hs, enum dpu_link_id src);
> +void dpu_hs_pec_clken(struct dpu_hscaler *hs, enum dpu_pec_clken clken);
> +void dpu_hs_setup1(struct dpu_hscaler *hs,
> + unsigned int src_w, unsigned int dst_w);
> +void dpu_hs_setup2(struct dpu_hscaler *hs, u32 phase_offset);
> +void dpu_hs_output_size(struct dpu_hscaler *hs, u32 line_num);
> +void dpu_hs_filter_mode(struct dpu_hscaler *hs, enum dpu_scaler_filter_mode m);
> +void dpu_hs_scale_mode(struct dpu_hscaler *hs, enum dpu_scaler_scale_mode m);
> +void dpu_hs_mode(struct dpu_hscaler *hs, enum dpu_scaler_mode m);
> +unsigned int dpu_hs_get_id(struct dpu_hscaler *hs);
> +struct dpu_hscaler *dpu_hs_get(struct dpu_soc *dpu, unsigned int id);
> +void dpu_hs_put(struct dpu_hscaler *hs);
> +
> +/* Layer Blend Unit */
> +struct dpu_layerblend;
> +enum dpu_link_id dpu_lb_get_link_id(struct dpu_layerblend *lb);
> +void dpu_lb_pec_dynamic_prim_sel(struct dpu_layerblend *lb,
> + enum dpu_link_id prim);
> +void dpu_lb_pec_dynamic_sec_sel(struct dpu_layerblend *lb,
> + enum dpu_link_id sec);
> +void dpu_lb_pec_clken(struct dpu_layerblend *lb, enum dpu_pec_clken clken);
> +void dpu_lb_mode(struct dpu_layerblend *lb, enum dpu_lb_mode mode);
> +void dpu_lb_blendcontrol(struct dpu_layerblend *lb, unsigned int zpos,
> + unsigned int pixel_blend_mode, u16 alpha);
> +void dpu_lb_position(struct dpu_layerblend *lb, int x, int y);
> +unsigned int dpu_lb_get_id(struct dpu_layerblend *lb);
> +struct dpu_layerblend *dpu_lb_get(struct dpu_soc *dpu, unsigned int id);
> +void dpu_lb_put(struct dpu_layerblend *lb);
> +
> +/* Timing Controller Unit */
> +struct dpu_tcon;
> +void dpu_tcon_set_fmt(struct dpu_tcon *tcon);
> +void dpu_tcon_set_operation_mode(struct dpu_tcon *tcon);
> +void dpu_tcon_cfg_videomode(struct dpu_tcon *tcon, struct drm_display_mode *m);
> +struct dpu_tcon *dpu_tcon_get(struct dpu_soc *dpu, unsigned int id);
> +void dpu_tcon_put(struct dpu_tcon *tcon);
> +
> +/* Vertical Scaler Unit */
> +struct dpu_vscaler;
> +enum dpu_link_id dpu_vs_get_link_id(struct dpu_vscaler *vs);
> +void dpu_vs_pec_dynamic_src_sel(struct dpu_vscaler *vs, enum dpu_link_id src);
> +void dpu_vs_pec_clken(struct dpu_vscaler *vs, enum dpu_pec_clken clken);
> +void dpu_vs_setup1(struct dpu_vscaler *vs,
> + unsigned int src_w, unsigned int dst_w, bool deinterlace);
> +void dpu_vs_setup2(struct dpu_vscaler *vs, bool deinterlace);
> +void dpu_vs_setup3(struct dpu_vscaler *vs, bool deinterlace);
> +void dpu_vs_setup4(struct dpu_vscaler *vs, u32 phase_offset);
> +void dpu_vs_setup5(struct dpu_vscaler *vs, u32 phase_offset);
> +void dpu_vs_output_size(struct dpu_vscaler *vs, u32 line_num);
> +void dpu_vs_field_mode(struct dpu_vscaler *vs, enum dpu_scaler_field_mode m);
> +void dpu_vs_filter_mode(struct dpu_vscaler *vs, enum dpu_scaler_filter_mode m);
> +void dpu_vs_scale_mode(struct dpu_vscaler *vs, enum dpu_scaler_scale_mode m);
> +void dpu_vs_mode(struct dpu_vscaler *vs, enum dpu_scaler_mode m);
> +unsigned int dpu_vs_get_id(struct dpu_vscaler *vs);
> +struct dpu_vscaler *dpu_vs_get(struct dpu_soc *dpu, unsigned int id);
> +void dpu_vs_put(struct dpu_vscaler *vs);
> +
> +/* Fetch Units */
> +struct dpu_fetchunit_ops {
> + void (*set_pec_dynamic_src_sel)(struct dpu_fetchunit *fu,
> + enum dpu_link_id src);
> +
> + bool (*is_enabled)(struct dpu_fetchunit *fu);
> +
> + void (*set_stream_id)(struct dpu_fetchunit *fu, unsigned int stream_id);
> +
> + unsigned int (*get_stream_id)(struct dpu_fetchunit *fu);
> +
> + void (*set_no_stream_id)(struct dpu_fetchunit *fu);
> +
> + bool (*has_stream_id)(struct dpu_fetchunit *fu);
> +
> + void (*set_numbuffers)(struct dpu_fetchunit *fu, unsigned int num);
> +
> + void (*set_burstlength)(struct dpu_fetchunit *fu,
> + unsigned int x_offset, unsigned int mt_w,
> + int bpp, dma_addr_t baddr);
> +
> + void (*set_baseaddress)(struct dpu_fetchunit *fu, unsigned int width,
> + unsigned int x_offset, unsigned int y_offset,
> + unsigned int mt_w, unsigned int mt_h,
> + int bpp, dma_addr_t baddr);
> +
> + void (*set_src_stride)(struct dpu_fetchunit *fu,
> + unsigned int width, unsigned int x_offset,
> + unsigned int mt_w, int bpp, unsigned int stride,
> + dma_addr_t baddr);
> +
> + void (*set_src_buf_dimensions)(struct dpu_fetchunit *fu,
> + unsigned int w, unsigned int h,
> + const struct drm_format_info *format,
> + bool deinterlace);
> +
> + void (*set_fmt)(struct dpu_fetchunit *fu,
> + const struct drm_format_info *format,
> + enum drm_color_encoding color_encoding,
> + enum drm_color_range color_range,
> + bool deinterlace);
> +
> + void (*set_pixel_blend_mode)(struct dpu_fetchunit *fu,
> + unsigned int pixel_blend_mode, u16 alpha,
> + bool fb_format_has_alpha);
> +
> + void (*enable_src_buf)(struct dpu_fetchunit *fu);
> + void (*disable_src_buf)(struct dpu_fetchunit *fu);
> +
> + void (*set_framedimensions)(struct dpu_fetchunit *fu,
> + unsigned int w, unsigned int h,
> + bool deinterlace);
> +
> + struct dpu_dprc *(*get_dprc)(struct dpu_fetchunit *fu);
> + struct dpu_fetchunit *(*get_fetcheco)(struct dpu_fetchunit *fu);
> + struct dpu_hscaler *(*get_hscaler)(struct dpu_fetchunit *fu);
> + struct dpu_vscaler *(*get_vscaler)(struct dpu_fetchunit *fu);
> +
> + void (*set_layerblend)(struct dpu_fetchunit *fu,
> + struct dpu_layerblend *lb);
> +
> + bool (*is_available)(struct dpu_fetchunit *fu);
> + void (*set_available)(struct dpu_fetchunit *fu);
> + void (*set_inavailable)(struct dpu_fetchunit *fu);
> +
> + enum dpu_link_id (*get_link_id)(struct dpu_fetchunit *fu);
> +
> + u32 (*get_cap_mask)(struct dpu_fetchunit *fu);
> +
> + const char *(*get_name)(struct dpu_fetchunit *fu);
> +};
> +
> +const struct dpu_fetchunit_ops *dpu_fu_get_ops(struct dpu_fetchunit *fu);
> +struct dpu_fetchunit *dpu_fu_get_from_list(struct list_head *l);
> +void dpu_fu_add_to_list(struct dpu_fetchunit *fu, struct list_head *l);
> +
> +/* HW resources for a plane group */
> +struct dpu_plane_res {
> + struct dpu_fetchunit **fd;
> + struct dpu_fetchunit **fe;
> + struct dpu_fetchunit **fl;
> + struct dpu_fetchunit **fw;
> + struct dpu_layerblend **lb;
> + unsigned int fd_cnt;
> + unsigned int fe_cnt;
> + unsigned int fl_cnt;
> + unsigned int fw_cnt;
> + unsigned int lb_cnt;
> +};
> +
> +/*
> + * fetchunit/scaler/layerblend resources of a plane group are
> + * shared by the two CRTCs in a CRTC group
> + */
> +struct dpu_plane_grp {
> + struct dpu_plane_res res;
> + struct list_head node;
> + struct list_head fu_list;
> + unsigned int hw_plane_cnt;
> + struct dpu_constframe *cf[2];
> + struct dpu_extdst *ed[2];
> +};
> +
> +/* the two CRTCs of one DPU are in a CRTC group */
> +struct dpu_crtc_grp {
> + u32 crtc_mask;
> + struct dpu_plane_grp *plane_grp;
> +};
> +
> +struct dpu_client_platformdata {
> + const unsigned int stream_id;
> + const unsigned int dec_frame_complete_irq;
> + const unsigned int dec_seq_complete_irq;
> + const unsigned int dec_shdld_irq;
> + const unsigned int ed_cont_shdld_irq;
> + const unsigned int ed_safe_shdld_irq;
> + struct dpu_crtc_grp *crtc_grp;
> +
> + struct device_node *of_node;
> +};
> +
> +#endif /* __DPU_H__ */
> --
> 2.7.4
>
More information about the dri-devel
mailing list