From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org X-Spam-Level: X-Spam-Status: No, score=-9.8 required=3.0 tests=DKIMWL_WL_HIGH,DKIM_SIGNED, DKIM_VALID,HEADER_FROM_DIFFERENT_DOMAINS,INCLUDES_PATCH,MAILING_LIST_MULTI, SIGNED_OFF_BY,SPF_HELO_NONE,SPF_PASS,URIBL_BLOCKED,USER_AGENT_GIT autolearn=unavailable autolearn_force=no version=3.4.0 Received: from mail.kernel.org (mail.kernel.org [198.145.29.99]) by smtp.lore.kernel.org (Postfix) with ESMTP id 49E80C4360C for ; Thu, 10 Oct 2019 09:27:11 +0000 (UTC) Received: from bombadil.infradead.org (bombadil.infradead.org [198.137.202.133]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by mail.kernel.org (Postfix) with ESMTPS id 1A01B2067B for ; Thu, 10 Oct 2019 09:27:11 +0000 (UTC) Authentication-Results: mail.kernel.org; dkim=pass (2048-bit key) header.d=lists.infradead.org header.i=@lists.infradead.org header.b="EVN7rAnF"; dkim=fail reason="signature verification failed" (2048-bit key) header.d=baylibre-com.20150623.gappssmtp.com header.i=@baylibre-com.20150623.gappssmtp.com header.b="LirWXDC/" DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org 1A01B2067B Authentication-Results: mail.kernel.org; dmarc=none (p=none dis=none) header.from=baylibre.com Authentication-Results: mail.kernel.org; spf=none smtp.mailfrom=linux-arm-kernel-bounces+infradead-linux-arm-kernel=archiver.kernel.org@lists.infradead.org DKIM-Signature: v=1; a=rsa-sha256; q=dns/txt; c=relaxed/relaxed; d=lists.infradead.org; s=bombadil.20170209; h=Sender: Content-Transfer-Encoding:Content-Type:Cc:List-Subscribe:List-Help:List-Post: List-Archive:List-Unsubscribe:List-Id:MIME-Version:References:In-Reply-To: Message-Id:Date:Subject:To:From:Reply-To:Content-ID:Content-Description: Resent-Date:Resent-From:Resent-Sender:Resent-To:Resent-Cc:Resent-Message-ID: List-Owner; bh=j/OiUp5KLI5OdAfccDHF7s8u6qb7IE3ocOxlUqgW8tA=; b=EVN7rAnFy5ew9O SC+YU6vC/r8JlRm46pS4laWjiznen3vQSZHMCCKEURCtJTrwHWtKb8aXCcxKNEljQxZTYnCkIMa1P 98zwXrLpMJQq+CHoTEkMksr0o+9SwweQ9pECfTwXR4nQZ7yZ/j11JDjvJCtte4F1tCoxpiEdLgY+6 3QSL6/z3RFx/36ZorKdSNWs5uWzANzeMbORnx/DLFAJ3Nv1a+07LAW4yzP3pcrCvXfFcv9y2+Hhwv vkVCIwJFedhhXEBZ/QOGUKgsvj1YGL+kx8S5/ofaAQ1POwFNHzDmWWFCwPBdbeTHXEbFOgJo17QL6 DnfJgCPgE14AgWCUf1GA==; Received: from localhost ([127.0.0.1] helo=bombadil.infradead.org) by bombadil.infradead.org with esmtp (Exim 4.92.2 #3 (Red Hat Linux)) id 1iIUit-0007SZ-HC; Thu, 10 Oct 2019 09:27:03 +0000 Received: from mail-wm1-x341.google.com ([2a00:1450:4864:20::341]) by bombadil.infradead.org with esmtps (Exim 4.92.2 #3 (Red Hat Linux)) id 1iIUhT-0005yr-M7 for linux-arm-kernel@lists.infradead.org; Thu, 10 Oct 2019 09:25:42 +0000 Received: by mail-wm1-x341.google.com with SMTP id m18so5976077wmc.1 for ; Thu, 10 Oct 2019 02:25:33 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=baylibre-com.20150623.gappssmtp.com; s=20150623; h=from:to:cc:subject:date:message-id:in-reply-to:references :mime-version:content-transfer-encoding; bh=jNOW6VFMFnuOEHBHUTNnkLO8G+eFUm1jKDuBa5pJiKw=; b=LirWXDC/uJCGfPj6YwT8MzFZ/H8e3/V/KIYk6xg9HSOap4IKAfXvSPWxCbXaqk84nJ qnZ+HIRKaUknvCY9Wy7uMsfe+3HD6Rr5rhnpifac91CnRM2o4j6AI0rQuQ8be/WaRTHu hgsgTBGLXPnRkw9+Jx2bwqwN/CPI/6IyjvA8NHAtMW+m85dX5as7MwHgTZNNyn4Cm4y3 Lb4te3Ce/SGrkF5TA+s1mrxx85RJ4DyxdGGrjuHIqJ3P6QtVXoMhqdb0KL+dsqtDX9ev L8Od8xDxC0HFUGQw5E6kRabxnZ1bevJqX90cD67QSLoCrJG/wUt00KhxIhVEPd7q47H6 r0Vw== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references:mime-version:content-transfer-encoding; bh=jNOW6VFMFnuOEHBHUTNnkLO8G+eFUm1jKDuBa5pJiKw=; b=Fmk9aHHjRG+lEMeLDLHIspsMygbp8iyl05m8dMHtzDOZX/2QgRd7vyN9/Li8lZugqu LFNcqOuya4PfTGQBabBWNATx3dJWNtsQV3bWt9GCFZU+fqDEcHKlhmmimYnjcTZZmzAw yiXzccxl60xvPgcCtkxHpEOjiKPscyqlee6ZCngJW2GNby7b1f4twMSqcYaHnStdlPJJ /GSEkXzau/m00jzg6F1q0KP9KzojUXP7cUh38s3uc833V4rFNJ2iQm9MUBAwdGEEpbCC 2Ds39fidHYmlrTpaTKXKlQEN0rOaSqpfc41ti34PnqQ9EvbhrN2a+SLcBsfabANslvut CSBA== X-Gm-Message-State: APjAAAX+2H57Sot78FSlV89H22N9Iau4NFZ2vGdQuWo0XHGrvuK0BcZn 3YtgQusQnHU6JONQw0KhPC9WzA== X-Google-Smtp-Source: APXvYqwrx9k09Qz9beA56ra3SmYtiEFiO6W6iJpVpbX/4MiFYrKQUlpbm22UU2M2mqGVU9vMVtpwwA== X-Received: by 2002:a05:600c:c1:: with SMTP id u1mr6233756wmm.87.1570699531768; Thu, 10 Oct 2019 02:25:31 -0700 (PDT) Received: from bender.baylibre.local (lmontsouris-657-1-212-31.w90-63.abo.wanadoo.fr. [90.63.244.31]) by smtp.gmail.com with ESMTPSA id s10sm8373770wmf.48.2019.10.10.02.25.31 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Thu, 10 Oct 2019 02:25:31 -0700 (PDT) From: Neil Armstrong To: dri-devel@lists.freedesktop.org Subject: [PATCH 3/7] drm/meson: Add AFBCD module driver Date: Thu, 10 Oct 2019 11:25:22 +0200 Message-Id: <20191010092526.10419-4-narmstrong@baylibre.com> X-Mailer: git-send-email 2.22.0 In-Reply-To: <20191010092526.10419-1-narmstrong@baylibre.com> References: <20191010092526.10419-1-narmstrong@baylibre.com> MIME-Version: 1.0 X-CRM114-Version: 20100106-BlameMichelson ( TRE 0.8.0 (BSD) ) MR-646709E3 X-CRM114-CacheID: sfid-20191010_022535_723834_10A6628C X-CRM114-Status: GOOD ( 24.44 ) X-BeenThere: linux-arm-kernel@lists.infradead.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Cc: khilman@baylibre.com, linux-amlogic@lists.infradead.org, ayan.halder@arm.com, linux-arm-kernel@lists.infradead.org, Neil Armstrong Content-Type: text/plain; charset="us-ascii" Content-Transfer-Encoding: 7bit Sender: "linux-arm-kernel" Errors-To: linux-arm-kernel-bounces+infradead-linux-arm-kernel=archiver.kernel.org@lists.infradead.org This adds the driver for the ARM Framebuffer Compression decoders found in the Amlogic GXM and G12A SoCs. The Amlogic GXM and G12A AFBC decoder are totally different, the GXM only handling only the AFBC v1.0 modes and the G12A decoder handling the AFBC v1.2 modes. The G12A AFBC decoder is an external IP integrated in the video pipeline, and the GXM AFBC decoder seems to the an Amlogic custom decoder more tighly integrated in the video pipeline. The GXM AFBC decoder can handle only one AFBC plane for 2 available OSD planes available in HW, and the G12A AFBC decoder can handle up to 4 AFBC planes for up to 3 OSD planes available in HW. The Amlogic GXM supports 16x16 SPARSE and 16x16 SPLIT AFBC buffers up to 4k. On the other side, for G12A SPLIT is mandatory in 16x16 block mode, but for 4k modes 32x8+SPLIT AFBC buffers is manadatory for performances reasons. Signed-off-by: Neil Armstrong --- drivers/gpu/drm/meson/Makefile | 1 + drivers/gpu/drm/meson/meson_drv.c | 38 ++- drivers/gpu/drm/meson/meson_drv.h | 12 + drivers/gpu/drm/meson/meson_osd_afbcd.c | 370 ++++++++++++++++++++++++ drivers/gpu/drm/meson/meson_osd_afbcd.h | 28 ++ 5 files changed, 443 insertions(+), 6 deletions(-) create mode 100644 drivers/gpu/drm/meson/meson_osd_afbcd.c create mode 100644 drivers/gpu/drm/meson/meson_osd_afbcd.h diff --git a/drivers/gpu/drm/meson/Makefile b/drivers/gpu/drm/meson/Makefile index c389e2399133..b1fa055aaed3 100644 --- a/drivers/gpu/drm/meson/Makefile +++ b/drivers/gpu/drm/meson/Makefile @@ -1,6 +1,7 @@ # SPDX-License-Identifier: GPL-2.0-only meson-drm-y := meson_drv.o meson_plane.o meson_crtc.o meson_venc_cvbs.o meson-drm-y += meson_viu.o meson_vpp.o meson_venc.o meson_vclk.o meson_overlay.o +meson-drm-y += meson_osd_afbcd.o obj-$(CONFIG_DRM_MESON) += meson-drm.o obj-$(CONFIG_DRM_MESON_DW_HDMI) += meson_dw_hdmi.o diff --git a/drivers/gpu/drm/meson/meson_drv.c b/drivers/gpu/drm/meson/meson_drv.c index a24f8dec5adc..0f31e70bb94f 100644 --- a/drivers/gpu/drm/meson/meson_drv.c +++ b/drivers/gpu/drm/meson/meson_drv.c @@ -28,6 +28,7 @@ #include "meson_drv.h" #include "meson_overlay.h" #include "meson_plane.h" +#include "meson_osd_afbcd.h" #include "meson_registers.h" #include "meson_venc_cvbs.h" #include "meson_viu.h" @@ -184,6 +185,7 @@ static void meson_remove_framebuffers(void) static int meson_drv_bind_master(struct device *dev, bool has_components) { struct platform_device *pdev = to_platform_device(dev); + const struct meson_drm_match_data *match; struct meson_drm *priv; struct drm_device *drm; struct resource *res; @@ -196,6 +198,10 @@ static int meson_drv_bind_master(struct device *dev, bool has_components) return -ENODEV; } + match = of_device_get_match_data(dev); + if (!match) + return -ENODEV; + drm = drm_dev_alloc(&meson_driver, dev); if (IS_ERR(drm)) return PTR_ERR(drm); @@ -208,8 +214,8 @@ static int meson_drv_bind_master(struct device *dev, bool has_components) drm->dev_private = priv; priv->drm = drm; priv->dev = dev; - - priv->compat = (enum vpu_compatible)of_device_get_match_data(priv->dev); + priv->compat = match->compat; + priv->afbcd.ops = match->afbcd_ops; res = platform_get_resource_byname(pdev, IORESOURCE_MEM, "vpu"); regs = devm_ioremap_resource(dev, res); @@ -289,6 +295,8 @@ static int meson_drv_bind_master(struct device *dev, bool has_components) meson_venc_init(priv); meson_vpp_init(priv); meson_viu_init(priv); + if (priv->afbcd.ops) + priv->afbcd.ops->init(priv); /* Encoder Initialization */ @@ -454,15 +462,33 @@ static int meson_drv_probe(struct platform_device *pdev) return 0; }; +static struct meson_drm_match_data meson_drm_gxbb_data = { + .compat = VPU_COMPATIBLE_GXBB, +}; + +static struct meson_drm_match_data meson_drm_gxl_data = { + .compat = VPU_COMPATIBLE_GXL, +}; + +static struct meson_drm_match_data meson_drm_gxm_data = { + .compat = VPU_COMPATIBLE_GXM, + .afbcd_ops = &meson_afbcd_gxm_ops, +}; + +static struct meson_drm_match_data meson_drm_g12a_data = { + .compat = VPU_COMPATIBLE_G12A, + .afbcd_ops = &meson_afbcd_g12a_ops, +}; + static const struct of_device_id dt_match[] = { { .compatible = "amlogic,meson-gxbb-vpu", - .data = (void *)VPU_COMPATIBLE_GXBB }, + .data = (void *)&meson_drm_gxbb_data }, { .compatible = "amlogic,meson-gxl-vpu", - .data = (void *)VPU_COMPATIBLE_GXL }, + .data = (void *)&meson_drm_gxl_data }, { .compatible = "amlogic,meson-gxm-vpu", - .data = (void *)VPU_COMPATIBLE_GXM }, + .data = (void *)&meson_drm_gxm_data }, { .compatible = "amlogic,meson-g12a-vpu", - .data = (void *)VPU_COMPATIBLE_G12A }, + .data = (void *)&meson_drm_g12a_data }, {} }; MODULE_DEVICE_TABLE(of, dt_match); diff --git a/drivers/gpu/drm/meson/meson_drv.h b/drivers/gpu/drm/meson/meson_drv.h index 3287282450a9..60f13c6f34e5 100644 --- a/drivers/gpu/drm/meson/meson_drv.h +++ b/drivers/gpu/drm/meson/meson_drv.h @@ -16,6 +16,7 @@ struct drm_crtc; struct drm_device; struct drm_plane; struct meson_drm; +struct meson_afbcd_ops; enum vpu_compatible { VPU_COMPATIBLE_GXBB = 0, @@ -24,6 +25,11 @@ enum vpu_compatible { VPU_COMPATIBLE_G12A = 3, }; +struct meson_drm_match_data { + enum vpu_compatible compat; + struct meson_afbcd_ops *afbcd_ops; +}; + struct meson_drm { struct device *dev; enum vpu_compatible compat; @@ -123,6 +129,12 @@ struct meson_drm { bool venc_repeat; bool hdmi_use_enci; } venc; + + struct { + struct meson_afbcd_ops *ops; + u64 modifier; + u32 format; + } afbcd; }; static inline int meson_vpu_is_compatible(struct meson_drm *priv, diff --git a/drivers/gpu/drm/meson/meson_osd_afbcd.c b/drivers/gpu/drm/meson/meson_osd_afbcd.c new file mode 100644 index 000000000000..36caf5716e8c --- /dev/null +++ b/drivers/gpu/drm/meson/meson_osd_afbcd.c @@ -0,0 +1,370 @@ +// SPDX-License-Identifier: GPL-2.0+ +/* + * Copyright (C) 2019 BayLibre, SAS + * Author: Neil Armstrong + */ + +#include + +#include +#include + +#include "meson_drv.h" +#include "meson_registers.h" +#include "meson_viu.h" +#include "meson_osd_afbcd.h" + +/* + * DOC: Driver for the ARM FrameBuffer Compression Decoders + * + * The Amlogic GXM and G12A SoC families embeds an AFBC Decoder, + * to decode compressed buffers generated by the ARM Mali GPU. + * + * For the GXM Family, Amlogic designed their own Decoder, named in + * the vendor source as "MESON_AFBC", and a single decoder is available + * for the 2 OSD planes. + * This decoder is compatible with the AFBC 1.0 specifications and the + * Mali T820 GPU capabilities. + * It supports : + * - basic AFBC buffer for RGB32 only, thus YTR feature is mandatory + * - SPARSE layout and SPLIT layout + * - only 16x16 superblock + * + * The decoder reads the data from the SDRAM, decodes and sends the + * decoded pixel stream to the OSD1 Plane pixel composer. + * + * For the G12A Family, Amlogic integrated an ARM AFBC Decoder, named + * in the vendor source as "MALI_AFBC", and the decoder can decode up + * to 4 surfaces, one for each of the 4 available OSDs. + * This decoder is compatible with the AFBC 1.2 specifications for the + * Mali G31 and G52 GPUs. + * Is supports : + * - basic AFBC buffer for multiple RGB and YUV pixel formats + * - SPARSE layout and SPLIT layout + * - 16x16 and 32x8 "wideblk" superblocks + * - Tiled header + * + * The ARM AFBC Decoder independent from the VPU Pixel Pipeline, so + * the ARM AFBC Decoder reads the data from the SDRAM then decodes + * into a private internal physical address where the OSD1 Plane pixel + * composer unpacks the decoded data. + */ + +/* Amlogic AFBC Decoder for GXM Family */ + +#define OSD1_AFBCD_RGB32 0x15 + +static int meson_gxm_afbcd_pixel_fmt(u64 modifier, uint32_t format) +{ + switch (format) { + case DRM_FORMAT_XRGB8888: + case DRM_FORMAT_ARGB8888: + case DRM_FORMAT_XBGR8888: + case DRM_FORMAT_ABGR8888: + return OSD1_AFBCD_RGB32; + /* TOFIX support mode formats */ + default: + DRM_DEBUG("unsupported afbc format[%08x]\n", format); + return -EINVAL; + } +} + +static bool meson_gxm_afbcd_supported_fmt(u64 modifier, uint32_t format) +{ + if (modifier & AFBC_FORMAT_MOD_BLOCK_SIZE_32x8) + return false; + + if (!(modifier & AFBC_FORMAT_MOD_YTR)) + return false; + + return meson_gxm_afbcd_pixel_fmt(modifier, format) >= 0; +} + +static int meson_gxm_afbcd_init(struct meson_drm *priv) +{ + return 0; +} + +static int meson_gxm_afbcd_reset(struct meson_drm *priv) +{ + writel_relaxed(VIU_SW_RESET_OSD1_AFBCD, + priv->io_base + _REG(VIU_SW_RESET)); + writel_relaxed(0, priv->io_base + _REG(VIU_SW_RESET)); + + return 0; +} + +static int meson_gxm_afbcd_enable(struct meson_drm *priv) +{ + writel_relaxed(FIELD_PREP(OSD1_AFBCD_ID_FIFO_THRD, 0x40) | + OSD1_AFBCD_DEC_ENABLE, + priv->io_base + _REG(OSD1_AFBCD_ENABLE)); + + return 0; +} + +static int meson_gxm_afbcd_disable(struct meson_drm *priv) +{ + writel_bits_relaxed(OSD1_AFBCD_DEC_ENABLE, 0, + priv->io_base + _REG(OSD1_AFBCD_ENABLE)); + + return 0; +} + +static int meson_gxm_afbcd_setup(struct meson_drm *priv) +{ + u32 conv_lbuf_len; + u32 mode = FIELD_PREP(OSD1_AFBCD_MIF_URGENT, 3) | + FIELD_PREP(OSD1_AFBCD_HOLD_LINE_NUM, 4) | + FIELD_PREP(OSD1_AFBCD_RGBA_EXCHAN_CTRL, 0x34) | + meson_gxm_afbcd_pixel_fmt(priv->afbcd.modifier, + priv->afbcd.format); + + if (priv->afbcd.modifier & AFBC_FORMAT_MOD_SPARSE) + mode |= OSD1_AFBCD_HREG_HALF_BLOCK; + + if (priv->afbcd.modifier & AFBC_FORMAT_MOD_SPLIT) + mode |= OSD1_AFBCD_HREG_BLOCK_SPLIT; + + writel_relaxed(mode, priv->io_base + _REG(OSD1_AFBCD_MODE)); + + writel_relaxed(FIELD_PREP(OSD1_AFBCD_HREG_VSIZE_IN, + priv->viu.osd1_width) | + FIELD_PREP(OSD1_AFBCD_HREG_HSIZE_IN, + priv->viu.osd1_height), + priv->io_base + _REG(OSD1_AFBCD_SIZE_IN)); + + writel_relaxed(priv->viu.osd1_addr >> 4, + priv->io_base + _REG(OSD1_AFBCD_HDR_PTR)); + writel_relaxed(priv->viu.osd1_addr >> 4, + priv->io_base + _REG(OSD1_AFBCD_FRAME_PTR)); + /* TOFIX: bits 31:24 are not documented, nor the meaning of 0xe4 */ + writel_relaxed((0xe4 << 24) | (priv->viu.osd1_addr & 0xffffff), + priv->io_base + _REG(OSD1_AFBCD_CHROMA_PTR)); + + if (priv->viu.osd1_width <= 128) + conv_lbuf_len = 32; + else if (priv->viu.osd1_width <= 256) + conv_lbuf_len = 64; + else if (priv->viu.osd1_width <= 512) + conv_lbuf_len = 128; + else if (priv->viu.osd1_width <= 1024) + conv_lbuf_len = 256; + else if (priv->viu.osd1_width <= 2048) + conv_lbuf_len = 512; + else + conv_lbuf_len = 1024; + + writel_relaxed(conv_lbuf_len, + priv->io_base + _REG(OSD1_AFBCD_CONV_CTRL)); + + writel_relaxed(FIELD_PREP(OSD1_AFBCD_DEC_PIXEL_BGN_H, 0) | + FIELD_PREP(OSD1_AFBCD_DEC_PIXEL_END_H, + priv->viu.osd1_width - 1), + priv->io_base + _REG(OSD1_AFBCD_PIXEL_HSCOPE)); + + writel_relaxed(FIELD_PREP(OSD1_AFBCD_DEC_PIXEL_BGN_V, 0) | + FIELD_PREP(OSD1_AFBCD_DEC_PIXEL_END_V, + priv->viu.osd1_height - 1), + priv->io_base + _REG(OSD1_AFBCD_PIXEL_VSCOPE)); + + return 0; +} + +struct meson_afbcd_ops meson_afbcd_gxm_ops = { + .init = meson_gxm_afbcd_init, + .reset = meson_gxm_afbcd_reset, + .enable = meson_gxm_afbcd_enable, + .disable = meson_gxm_afbcd_disable, + .setup = meson_gxm_afbcd_setup, + .supported_fmt = meson_gxm_afbcd_supported_fmt, +}; + +/* ARM AFBC Decoder for G12A Family */ + +/* Amlogic G12A Mali AFBC Decoder supported formats */ +enum { + MAFBC_FMT_RGB565 = 0, + MAFBC_FMT_RGBA5551, + MAFBC_FMT_RGBA1010102, + MAFBC_FMT_YUV420_10B, + MAFBC_FMT_RGB888, + MAFBC_FMT_RGBA8888, + MAFBC_FMT_RGBA4444, + MAFBC_FMT_R8, + MAFBC_FMT_RG88, + MAFBC_FMT_YUV420_8B, + MAFBC_FMT_YUV422_8B = 11, + MAFBC_FMT_YUV422_10B = 14, +}; + +static int meson_g12a_afbcd_pixel_fmt(u64 modifier, uint32_t format) +{ + switch (format) { + case DRM_FORMAT_XRGB8888: + case DRM_FORMAT_ARGB8888: + case DRM_FORMAT_XBGR8888: + case DRM_FORMAT_ABGR8888: + return MAFBC_FMT_RGBA8888; + case DRM_FORMAT_RGB888: + return MAFBC_FMT_RGB888; + case DRM_FORMAT_RGB565: + return MAFBC_FMT_RGB565; + /* TOFIX support mode formats */ + default: + DRM_DEBUG("unsupported afbc format[%08x]\n", format); + return -EINVAL; + } +} + +static int meson_g12a_afbcd_bpp(uint32_t format) +{ + switch (format) { + case DRM_FORMAT_XRGB8888: + case DRM_FORMAT_ARGB8888: + case DRM_FORMAT_XBGR8888: + case DRM_FORMAT_ABGR8888: + return 32; + case DRM_FORMAT_RGB888: + return 24; + case DRM_FORMAT_RGB565: + return 16; + /* TOFIX support mode formats */ + default: + DRM_ERROR("unsupported afbc format[%08x]\n", format); + return 0; + } +} + +static int meson_g12a_afbcd_fmt_to_blk_mode(u64 modifier, uint32_t format) +{ + switch (format) { + case DRM_FORMAT_XRGB8888: + case DRM_FORMAT_ARGB8888: + case DRM_FORMAT_XBGR8888: + case DRM_FORMAT_ABGR8888: + return OSD_MALI_COLOR_MODE_RGBA8888; + case DRM_FORMAT_RGB888: + return OSD_MALI_COLOR_MODE_RGB888; + case DRM_FORMAT_RGB565: + return OSD_MALI_COLOR_MODE_RGB565; + /* TOFIX support mode formats */ + default: + DRM_DEBUG("unsupported afbc format[%08x]\n", format); + return -EINVAL; + } +} + +static bool meson_g12a_afbcd_supported_fmt(u64 modifier, uint32_t format) +{ + if (!(modifier & AFBC_FORMAT_MOD_YTR)) + return false; + + return meson_g12a_afbcd_pixel_fmt(modifier, format) >= 0; +} + +static int meson_g12a_afbcd_init(struct meson_drm *priv) +{ + /* Handle AFBC Decoder reset manually */ + writel_bits_relaxed(MALI_AFBCD_MANUAL_RESET, MALI_AFBCD_MANUAL_RESET, + priv->io_base + _REG(MALI_AFBCD_TOP_CTRL)); + + return 0; +} + +static int meson_g12a_afbcd_reset(struct meson_drm *priv) +{ + writel_relaxed(VIU_SW_RESET_G12A_AFBC_ARB | + VIU_SW_RESET_G12A_OSD1_AFBCD, + priv->io_base + _REG(VIU_SW_RESET)); + writel_relaxed(0, priv->io_base + _REG(VIU_SW_RESET)); + + return 0; +} + +static int meson_g12a_afbcd_enable(struct meson_drm *priv) +{ + writel_relaxed(VPU_MAFBC_IRQ_SURFACES_COMPLETED | + VPU_MAFBC_IRQ_CONFIGURATION_SWAPPED | + VPU_MAFBC_IRQ_DECODE_ERROR | + VPU_MAFBC_IRQ_DETILING_ERROR, + priv->io_base + _REG(VPU_MAFBC_IRQ_MASK)); + + writel_bits_relaxed(VPU_MAFBC_S0_ENABLE, VPU_MAFBC_S0_ENABLE, + priv->io_base + _REG(VPU_MAFBC_SURFACE_CFG)); + + writel_relaxed(VPU_MAFBC_DIRECT_SWAP, + priv->io_base + _REG(VPU_MAFBC_COMMAND)); + + return 0; +} + +static int meson_g12a_afbcd_disable(struct meson_drm *priv) +{ + writel_bits_relaxed(VPU_MAFBC_S0_ENABLE, 0, + priv->io_base + _REG(VPU_MAFBC_SURFACE_CFG)); + + return 0; +} + +static int meson_g12a_afbcd_setup(struct meson_drm *priv) +{ + u32 format = meson_g12a_afbcd_pixel_fmt(priv->afbcd.modifier, + priv->afbcd.format); + + if (priv->afbcd.modifier & AFBC_FORMAT_MOD_YTR) + format |= VPU_MAFBC_YUV_TRANSFORM; + + if (priv->afbcd.modifier & AFBC_FORMAT_MOD_SPLIT) + format |= VPU_MAFBC_BLOCK_SPLIT; + + if (priv->afbcd.modifier & AFBC_FORMAT_MOD_TILED) + format |= VPU_MAFBC_TILED_HEADER_EN; + + if ((priv->afbcd.modifier & AFBC_FORMAT_MOD_BLOCK_SIZE_MASK) == + AFBC_FORMAT_MOD_BLOCK_SIZE_32x8) + format |= FIELD_PREP(VPU_MAFBC_SUPER_BLOCK_ASPECT, 1); + + writel_relaxed(format, + priv->io_base + _REG(VPU_MAFBC_FORMAT_SPECIFIER_S0)); + + writel_relaxed(priv->viu.osd1_addr, + priv->io_base + _REG(VPU_MAFBC_HEADER_BUF_ADDR_LOW_S0)); + writel_relaxed(0, + priv->io_base + _REG(VPU_MAFBC_HEADER_BUF_ADDR_HIGH_S0)); + + writel_relaxed(priv->viu.osd1_width, + priv->io_base + _REG(VPU_MAFBC_BUFFER_WIDTH_S0)); + writel_relaxed(ALIGN(priv->viu.osd1_height, 32), + priv->io_base + _REG(VPU_MAFBC_BUFFER_HEIGHT_S0)); + + writel_relaxed(0, + priv->io_base + _REG(VPU_MAFBC_BOUNDING_BOX_X_START_S0)); + writel_relaxed(priv->viu.osd1_width - 1, + priv->io_base + _REG(VPU_MAFBC_BOUNDING_BOX_X_END_S0)); + writel_relaxed(0, + priv->io_base + _REG(VPU_MAFBC_BOUNDING_BOX_Y_START_S0)); + writel_relaxed(priv->viu.osd1_height - 1, + priv->io_base + _REG(VPU_MAFBC_BOUNDING_BOX_Y_END_S0)); + + writel_relaxed(MESON_G12A_AFBCD_OUT_ADDR, + priv->io_base + _REG(VPU_MAFBC_OUTPUT_BUF_ADDR_LOW_S0)); + writel_relaxed(0, + priv->io_base + _REG(VPU_MAFBC_OUTPUT_BUF_ADDR_HIGH_S0)); + + writel_relaxed(priv->viu.osd1_width * + (meson_g12a_afbcd_bpp(priv->afbcd.format) / 8), + priv->io_base + _REG(VPU_MAFBC_OUTPUT_BUF_STRIDE_S0)); + + return 0; +} + +struct meson_afbcd_ops meson_afbcd_g12a_ops = { + .init = meson_g12a_afbcd_init, + .reset = meson_g12a_afbcd_reset, + .enable = meson_g12a_afbcd_enable, + .disable = meson_g12a_afbcd_disable, + .setup = meson_g12a_afbcd_setup, + .fmt_to_blk_mode = meson_g12a_afbcd_fmt_to_blk_mode, + .supported_fmt = meson_g12a_afbcd_supported_fmt, +}; diff --git a/drivers/gpu/drm/meson/meson_osd_afbcd.h b/drivers/gpu/drm/meson/meson_osd_afbcd.h new file mode 100644 index 000000000000..5e5523304f42 --- /dev/null +++ b/drivers/gpu/drm/meson/meson_osd_afbcd.h @@ -0,0 +1,28 @@ +/* SPDX-License-Identifier: GPL-2.0+ */ +/* + * Copyright (C) 2019 BayLibre, SAS + * Author: Neil Armstrong + */ + +#ifndef __MESON_OSD_AFBCD_H +#define __MESON_OSD_AFBCD_H + +#include "meson_drv.h" + +/* This is an internal address used to transfer pixel from AFBC to the VIU */ +#define MESON_G12A_AFBCD_OUT_ADDR 0x1000000 + +struct meson_afbcd_ops { + int (*init)(struct meson_drm *priv); + int (*reset)(struct meson_drm *priv); + int (*enable)(struct meson_drm *priv); + int (*disable)(struct meson_drm *priv); + int (*setup)(struct meson_drm *priv); + int (*fmt_to_blk_mode)(u64 modifier, uint32_t format); + bool (*supported_fmt)(u64 modifier, uint32_t format); +}; + +extern struct meson_afbcd_ops meson_afbcd_gxm_ops; +extern struct meson_afbcd_ops meson_afbcd_g12a_ops; + +#endif /* __MESON_OSD_AFBCD_H */ -- 2.22.0 _______________________________________________ linux-arm-kernel mailing list linux-arm-kernel@lists.infradead.org http://lists.infradead.org/mailman/listinfo/linux-arm-kernel From mboxrd@z Thu Jan 1 00:00:00 1970 From: Neil Armstrong Subject: [PATCH 3/7] drm/meson: Add AFBCD module driver Date: Thu, 10 Oct 2019 11:25:22 +0200 Message-ID: <20191010092526.10419-4-narmstrong@baylibre.com> References: <20191010092526.10419-1-narmstrong@baylibre.com> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Return-path: Received: from mail-wm1-x344.google.com (mail-wm1-x344.google.com [IPv6:2a00:1450:4864:20::344]) by gabe.freedesktop.org (Postfix) with ESMTPS id B825D6EAD3 for ; Thu, 10 Oct 2019 09:25:33 +0000 (UTC) Received: by mail-wm1-x344.google.com with SMTP id b24so5958047wmj.5 for ; Thu, 10 Oct 2019 02:25:33 -0700 (PDT) In-Reply-To: <20191010092526.10419-1-narmstrong@baylibre.com> List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: dri-devel-bounces@lists.freedesktop.org Sender: "dri-devel" To: dri-devel@lists.freedesktop.org Cc: khilman@baylibre.com, linux-amlogic@lists.infradead.org, ayan.halder@arm.com, linux-arm-kernel@lists.infradead.org, Neil Armstrong List-Id: dri-devel@lists.freedesktop.org VGhpcyBhZGRzIHRoZSBkcml2ZXIgZm9yIHRoZSBBUk0gRnJhbWVidWZmZXIgQ29tcHJlc3Npb24g ZGVjb2RlcnMgZm91bmQKaW4gdGhlIEFtbG9naWMgR1hNIGFuZCBHMTJBIFNvQ3MuCgpUaGUgQW1s b2dpYyBHWE0gYW5kIEcxMkEgQUZCQyBkZWNvZGVyIGFyZSB0b3RhbGx5IGRpZmZlcmVudCwgdGhl IEdYTSBvbmx5CmhhbmRsaW5nIG9ubHkgdGhlIEFGQkMgdjEuMCBtb2RlcyBhbmQgdGhlIEcxMkEg ZGVjb2RlciBoYW5kbGluZyB0aGUKQUZCQyB2MS4yIG1vZGVzLgoKVGhlIEcxMkEgQUZCQyBkZWNv ZGVyIGlzIGFuIGV4dGVybmFsIElQIGludGVncmF0ZWQgaW4gdGhlIHZpZGVvIHBpcGVsaW5lLAph bmQgdGhlIEdYTSBBRkJDIGRlY29kZXIgc2VlbXMgdG8gdGhlIGFuIEFtbG9naWMgY3VzdG9tIGRl Y29kZXIgbW9yZQp0aWdobHkgaW50ZWdyYXRlZCBpbiB0aGUgdmlkZW8gcGlwZWxpbmUuCgpUaGUg R1hNIEFGQkMgZGVjb2RlciBjYW4gaGFuZGxlIG9ubHkgb25lIEFGQkMgcGxhbmUgZm9yIDIgYXZh aWxhYmxlCk9TRCBwbGFuZXMgYXZhaWxhYmxlIGluIEhXLCBhbmQgdGhlIEcxMkEgQUZCQyBkZWNv ZGVyIGNhbiBoYW5kbGUgdXAKdG8gNCBBRkJDIHBsYW5lcyBmb3IgdXAgdG8gMyBPU0QgcGxhbmVz IGF2YWlsYWJsZSBpbiBIVy4KClRoZSBBbWxvZ2ljIEdYTSBzdXBwb3J0cyAxNngxNiBTUEFSU0Ug YW5kIDE2eDE2IFNQTElUIEFGQkMgYnVmZmVycyB1cAp0byA0ay4KCk9uIHRoZSBvdGhlciBzaWRl LCBmb3IgRzEyQSBTUExJVCBpcyBtYW5kYXRvcnkgaW4gMTZ4MTYgYmxvY2sgbW9kZSwgYnV0CmZv ciA0ayBtb2RlcyAzMng4K1NQTElUIEFGQkMgYnVmZmVycyBpcyBtYW5hZGF0b3J5IGZvciBwZXJm b3JtYW5jZXMgcmVhc29ucy4KClNpZ25lZC1vZmYtYnk6IE5laWwgQXJtc3Ryb25nIDxuYXJtc3Ry b25nQGJheWxpYnJlLmNvbT4KLS0tCiBkcml2ZXJzL2dwdS9kcm0vbWVzb24vTWFrZWZpbGUgICAg ICAgICAgfCAgIDEgKwogZHJpdmVycy9ncHUvZHJtL21lc29uL21lc29uX2Rydi5jICAgICAgIHwg IDM4ICsrLQogZHJpdmVycy9ncHUvZHJtL21lc29uL21lc29uX2Rydi5oICAgICAgIHwgIDEyICsK IGRyaXZlcnMvZ3B1L2RybS9tZXNvbi9tZXNvbl9vc2RfYWZiY2QuYyB8IDM3MCArKysrKysrKysr KysrKysrKysrKysrKysKIGRyaXZlcnMvZ3B1L2RybS9tZXNvbi9tZXNvbl9vc2RfYWZiY2QuaCB8 ICAyOCArKwogNSBmaWxlcyBjaGFuZ2VkLCA0NDMgaW5zZXJ0aW9ucygrKSwgNiBkZWxldGlvbnMo LSkKIGNyZWF0ZSBtb2RlIDEwMDY0NCBkcml2ZXJzL2dwdS9kcm0vbWVzb24vbWVzb25fb3NkX2Fm YmNkLmMKIGNyZWF0ZSBtb2RlIDEwMDY0NCBkcml2ZXJzL2dwdS9kcm0vbWVzb24vbWVzb25fb3Nk X2FmYmNkLmgKCmRpZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9kcm0vbWVzb24vTWFrZWZpbGUgYi9k cml2ZXJzL2dwdS9kcm0vbWVzb24vTWFrZWZpbGUKaW5kZXggYzM4OWUyMzk5MTMzLi5iMWZhMDU1 YWFlZDMgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvZ3B1L2RybS9tZXNvbi9NYWtlZmlsZQorKysgYi9k cml2ZXJzL2dwdS9kcm0vbWVzb24vTWFrZWZpbGUKQEAgLTEsNiArMSw3IEBACiAjIFNQRFgtTGlj ZW5zZS1JZGVudGlmaWVyOiBHUEwtMi4wLW9ubHkKIG1lc29uLWRybS15IDo9IG1lc29uX2Rydi5v IG1lc29uX3BsYW5lLm8gbWVzb25fY3J0Yy5vIG1lc29uX3ZlbmNfY3Zicy5vCiBtZXNvbi1kcm0t eSArPSBtZXNvbl92aXUubyBtZXNvbl92cHAubyBtZXNvbl92ZW5jLm8gbWVzb25fdmNsay5vIG1l c29uX292ZXJsYXkubworbWVzb24tZHJtLXkgKz0gbWVzb25fb3NkX2FmYmNkLm8KIAogb2JqLSQo Q09ORklHX0RSTV9NRVNPTikgKz0gbWVzb24tZHJtLm8KIG9iai0kKENPTkZJR19EUk1fTUVTT05f RFdfSERNSSkgKz0gbWVzb25fZHdfaGRtaS5vCmRpZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9kcm0v bWVzb24vbWVzb25fZHJ2LmMgYi9kcml2ZXJzL2dwdS9kcm0vbWVzb24vbWVzb25fZHJ2LmMKaW5k ZXggYTI0ZjhkZWM1YWRjLi4wZjMxZTcwYmI5NGYgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvZ3B1L2Ry bS9tZXNvbi9tZXNvbl9kcnYuYworKysgYi9kcml2ZXJzL2dwdS9kcm0vbWVzb24vbWVzb25fZHJ2 LmMKQEAgLTI4LDYgKzI4LDcgQEAKICNpbmNsdWRlICJtZXNvbl9kcnYuaCIKICNpbmNsdWRlICJt ZXNvbl9vdmVybGF5LmgiCiAjaW5jbHVkZSAibWVzb25fcGxhbmUuaCIKKyNpbmNsdWRlICJtZXNv bl9vc2RfYWZiY2QuaCIKICNpbmNsdWRlICJtZXNvbl9yZWdpc3RlcnMuaCIKICNpbmNsdWRlICJt ZXNvbl92ZW5jX2N2YnMuaCIKICNpbmNsdWRlICJtZXNvbl92aXUuaCIKQEAgLTE4NCw2ICsxODUs NyBAQCBzdGF0aWMgdm9pZCBtZXNvbl9yZW1vdmVfZnJhbWVidWZmZXJzKHZvaWQpCiBzdGF0aWMg aW50IG1lc29uX2Rydl9iaW5kX21hc3RlcihzdHJ1Y3QgZGV2aWNlICpkZXYsIGJvb2wgaGFzX2Nv bXBvbmVudHMpCiB7CiAJc3RydWN0IHBsYXRmb3JtX2RldmljZSAqcGRldiA9IHRvX3BsYXRmb3Jt X2RldmljZShkZXYpOworCWNvbnN0IHN0cnVjdCBtZXNvbl9kcm1fbWF0Y2hfZGF0YSAqbWF0Y2g7 CiAJc3RydWN0IG1lc29uX2RybSAqcHJpdjsKIAlzdHJ1Y3QgZHJtX2RldmljZSAqZHJtOwogCXN0 cnVjdCByZXNvdXJjZSAqcmVzOwpAQCAtMTk2LDYgKzE5OCwxMCBAQCBzdGF0aWMgaW50IG1lc29u X2Rydl9iaW5kX21hc3RlcihzdHJ1Y3QgZGV2aWNlICpkZXYsIGJvb2wgaGFzX2NvbXBvbmVudHMp CiAJCXJldHVybiAtRU5PREVWOwogCX0KIAorCW1hdGNoID0gb2ZfZGV2aWNlX2dldF9tYXRjaF9k YXRhKGRldik7CisJaWYgKCFtYXRjaCkKKwkJcmV0dXJuIC1FTk9ERVY7CisKIAlkcm0gPSBkcm1f ZGV2X2FsbG9jKCZtZXNvbl9kcml2ZXIsIGRldik7CiAJaWYgKElTX0VSUihkcm0pKQogCQlyZXR1 cm4gUFRSX0VSUihkcm0pOwpAQCAtMjA4LDggKzIxNCw4IEBAIHN0YXRpYyBpbnQgbWVzb25fZHJ2 X2JpbmRfbWFzdGVyKHN0cnVjdCBkZXZpY2UgKmRldiwgYm9vbCBoYXNfY29tcG9uZW50cykKIAlk cm0tPmRldl9wcml2YXRlID0gcHJpdjsKIAlwcml2LT5kcm0gPSBkcm07CiAJcHJpdi0+ZGV2ID0g ZGV2OwotCi0JcHJpdi0+Y29tcGF0ID0gKGVudW0gdnB1X2NvbXBhdGlibGUpb2ZfZGV2aWNlX2dl dF9tYXRjaF9kYXRhKHByaXYtPmRldik7CisJcHJpdi0+Y29tcGF0ID0gbWF0Y2gtPmNvbXBhdDsK Kwlwcml2LT5hZmJjZC5vcHMgPSBtYXRjaC0+YWZiY2Rfb3BzOwogCiAJcmVzID0gcGxhdGZvcm1f Z2V0X3Jlc291cmNlX2J5bmFtZShwZGV2LCBJT1JFU09VUkNFX01FTSwgInZwdSIpOwogCXJlZ3Mg PSBkZXZtX2lvcmVtYXBfcmVzb3VyY2UoZGV2LCByZXMpOwpAQCAtMjg5LDYgKzI5NSw4IEBAIHN0 YXRpYyBpbnQgbWVzb25fZHJ2X2JpbmRfbWFzdGVyKHN0cnVjdCBkZXZpY2UgKmRldiwgYm9vbCBo YXNfY29tcG9uZW50cykKIAltZXNvbl92ZW5jX2luaXQocHJpdik7CiAJbWVzb25fdnBwX2luaXQo cHJpdik7CiAJbWVzb25fdml1X2luaXQocHJpdik7CisJaWYgKHByaXYtPmFmYmNkLm9wcykKKwkJ cHJpdi0+YWZiY2Qub3BzLT5pbml0KHByaXYpOwogCiAJLyogRW5jb2RlciBJbml0aWFsaXphdGlv biAqLwogCkBAIC00NTQsMTUgKzQ2MiwzMyBAQCBzdGF0aWMgaW50IG1lc29uX2Rydl9wcm9iZShz dHJ1Y3QgcGxhdGZvcm1fZGV2aWNlICpwZGV2KQogCXJldHVybiAwOwogfTsKIAorc3RhdGljIHN0 cnVjdCBtZXNvbl9kcm1fbWF0Y2hfZGF0YSBtZXNvbl9kcm1fZ3hiYl9kYXRhID0geworCS5jb21w YXQgPSBWUFVfQ09NUEFUSUJMRV9HWEJCLAorfTsKKworc3RhdGljIHN0cnVjdCBtZXNvbl9kcm1f bWF0Y2hfZGF0YSBtZXNvbl9kcm1fZ3hsX2RhdGEgPSB7CisJLmNvbXBhdCA9IFZQVV9DT01QQVRJ QkxFX0dYTCwKK307CisKK3N0YXRpYyBzdHJ1Y3QgbWVzb25fZHJtX21hdGNoX2RhdGEgbWVzb25f ZHJtX2d4bV9kYXRhID0geworCS5jb21wYXQgPSBWUFVfQ09NUEFUSUJMRV9HWE0sCisJLmFmYmNk X29wcyA9ICZtZXNvbl9hZmJjZF9neG1fb3BzLAorfTsKKworc3RhdGljIHN0cnVjdCBtZXNvbl9k cm1fbWF0Y2hfZGF0YSBtZXNvbl9kcm1fZzEyYV9kYXRhID0geworCS5jb21wYXQgPSBWUFVfQ09N UEFUSUJMRV9HMTJBLAorCS5hZmJjZF9vcHMgPSAmbWVzb25fYWZiY2RfZzEyYV9vcHMsCit9Owor CiBzdGF0aWMgY29uc3Qgc3RydWN0IG9mX2RldmljZV9pZCBkdF9tYXRjaFtdID0gewogCXsgLmNv bXBhdGlibGUgPSAiYW1sb2dpYyxtZXNvbi1neGJiLXZwdSIsCi0JICAuZGF0YSAgICAgICA9ICh2 b2lkICopVlBVX0NPTVBBVElCTEVfR1hCQiB9LAorCSAgLmRhdGEgICAgICAgPSAodm9pZCAqKSZt ZXNvbl9kcm1fZ3hiYl9kYXRhIH0sCiAJeyAuY29tcGF0aWJsZSA9ICJhbWxvZ2ljLG1lc29uLWd4 bC12cHUiLAotCSAgLmRhdGEgICAgICAgPSAodm9pZCAqKVZQVV9DT01QQVRJQkxFX0dYTCB9LAor CSAgLmRhdGEgICAgICAgPSAodm9pZCAqKSZtZXNvbl9kcm1fZ3hsX2RhdGEgfSwKIAl7IC5jb21w YXRpYmxlID0gImFtbG9naWMsbWVzb24tZ3htLXZwdSIsCi0JICAuZGF0YSAgICAgICA9ICh2b2lk ICopVlBVX0NPTVBBVElCTEVfR1hNIH0sCisJICAuZGF0YSAgICAgICA9ICh2b2lkICopJm1lc29u X2RybV9neG1fZGF0YSB9LAogCXsgLmNvbXBhdGlibGUgPSAiYW1sb2dpYyxtZXNvbi1nMTJhLXZw dSIsCi0JICAuZGF0YSAgICAgICA9ICh2b2lkICopVlBVX0NPTVBBVElCTEVfRzEyQSB9LAorCSAg LmRhdGEgICAgICAgPSAodm9pZCAqKSZtZXNvbl9kcm1fZzEyYV9kYXRhIH0sCiAJe30KIH07CiBN T0RVTEVfREVWSUNFX1RBQkxFKG9mLCBkdF9tYXRjaCk7CmRpZmYgLS1naXQgYS9kcml2ZXJzL2dw dS9kcm0vbWVzb24vbWVzb25fZHJ2LmggYi9kcml2ZXJzL2dwdS9kcm0vbWVzb24vbWVzb25fZHJ2 LmgKaW5kZXggMzI4NzI4MjQ1MGE5Li42MGYxM2M2ZjM0ZTUgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMv Z3B1L2RybS9tZXNvbi9tZXNvbl9kcnYuaAorKysgYi9kcml2ZXJzL2dwdS9kcm0vbWVzb24vbWVz b25fZHJ2LmgKQEAgLTE2LDYgKzE2LDcgQEAgc3RydWN0IGRybV9jcnRjOwogc3RydWN0IGRybV9k ZXZpY2U7CiBzdHJ1Y3QgZHJtX3BsYW5lOwogc3RydWN0IG1lc29uX2RybTsKK3N0cnVjdCBtZXNv bl9hZmJjZF9vcHM7CiAKIGVudW0gdnB1X2NvbXBhdGlibGUgewogCVZQVV9DT01QQVRJQkxFX0dY QkIgPSAwLApAQCAtMjQsNiArMjUsMTEgQEAgZW51bSB2cHVfY29tcGF0aWJsZSB7CiAJVlBVX0NP TVBBVElCTEVfRzEyQSA9IDMsCiB9OwogCitzdHJ1Y3QgbWVzb25fZHJtX21hdGNoX2RhdGEgewor CWVudW0gdnB1X2NvbXBhdGlibGUgY29tcGF0OworCXN0cnVjdCBtZXNvbl9hZmJjZF9vcHMgKmFm YmNkX29wczsKK307CisKIHN0cnVjdCBtZXNvbl9kcm0gewogCXN0cnVjdCBkZXZpY2UgKmRldjsK IAllbnVtIHZwdV9jb21wYXRpYmxlIGNvbXBhdDsKQEAgLTEyMyw2ICsxMjksMTIgQEAgc3RydWN0 IG1lc29uX2RybSB7CiAJCWJvb2wgdmVuY19yZXBlYXQ7CiAJCWJvb2wgaGRtaV91c2VfZW5jaTsK IAl9IHZlbmM7CisKKwlzdHJ1Y3QgeworCQlzdHJ1Y3QgbWVzb25fYWZiY2Rfb3BzICpvcHM7CisJ CXU2NCBtb2RpZmllcjsKKwkJdTMyIGZvcm1hdDsKKwl9IGFmYmNkOwogfTsKIAogc3RhdGljIGlu bGluZSBpbnQgbWVzb25fdnB1X2lzX2NvbXBhdGlibGUoc3RydWN0IG1lc29uX2RybSAqcHJpdiwK ZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1L2RybS9tZXNvbi9tZXNvbl9vc2RfYWZiY2QuYyBiL2Ry aXZlcnMvZ3B1L2RybS9tZXNvbi9tZXNvbl9vc2RfYWZiY2QuYwpuZXcgZmlsZSBtb2RlIDEwMDY0 NAppbmRleCAwMDAwMDAwMDAwMDAuLjM2Y2FmNTcxNmU4YwotLS0gL2Rldi9udWxsCisrKyBiL2Ry aXZlcnMvZ3B1L2RybS9tZXNvbi9tZXNvbl9vc2RfYWZiY2QuYwpAQCAtMCwwICsxLDM3MCBAQAor Ly8gU1BEWC1MaWNlbnNlLUlkZW50aWZpZXI6IEdQTC0yLjArCisvKgorICogQ29weXJpZ2h0IChD KSAyMDE5IEJheUxpYnJlLCBTQVMKKyAqIEF1dGhvcjogTmVpbCBBcm1zdHJvbmcgPG5hcm1zdHJv bmdAYmF5bGlicmUuY29tPgorICovCisKKyNpbmNsdWRlIDxsaW51eC9iaXRmaWVsZC5oPgorCisj aW5jbHVkZSA8ZHJtL2RybV9wcmludC5oPgorI2luY2x1ZGUgPGRybS9kcm1fZm91cmNjLmg+CisK KyNpbmNsdWRlICJtZXNvbl9kcnYuaCIKKyNpbmNsdWRlICJtZXNvbl9yZWdpc3RlcnMuaCIKKyNp bmNsdWRlICJtZXNvbl92aXUuaCIKKyNpbmNsdWRlICJtZXNvbl9vc2RfYWZiY2QuaCIKKworLyoK KyAqIERPQzogRHJpdmVyIGZvciB0aGUgQVJNIEZyYW1lQnVmZmVyIENvbXByZXNzaW9uIERlY29k ZXJzCisgKgorICogVGhlIEFtbG9naWMgR1hNIGFuZCBHMTJBIFNvQyBmYW1pbGllcyBlbWJlZHMg YW4gQUZCQyBEZWNvZGVyLAorICogdG8gZGVjb2RlIGNvbXByZXNzZWQgYnVmZmVycyBnZW5lcmF0 ZWQgYnkgdGhlIEFSTSBNYWxpIEdQVS4KKyAqCisgKiBGb3IgdGhlIEdYTSBGYW1pbHksIEFtbG9n aWMgZGVzaWduZWQgdGhlaXIgb3duIERlY29kZXIsIG5hbWVkIGluCisgKiB0aGUgdmVuZG9yIHNv dXJjZSBhcyAiTUVTT05fQUZCQyIsIGFuZCBhIHNpbmdsZSBkZWNvZGVyIGlzIGF2YWlsYWJsZQor ICogZm9yIHRoZSAyIE9TRCBwbGFuZXMuCisgKiBUaGlzIGRlY29kZXIgaXMgY29tcGF0aWJsZSB3 aXRoIHRoZSBBRkJDIDEuMCBzcGVjaWZpY2F0aW9ucyBhbmQgdGhlCisgKiBNYWxpIFQ4MjAgR1BV IGNhcGFiaWxpdGllcy4KKyAqIEl0IHN1cHBvcnRzIDoKKyAqIC0gYmFzaWMgQUZCQyBidWZmZXIg Zm9yIFJHQjMyIG9ubHksIHRodXMgWVRSIGZlYXR1cmUgaXMgbWFuZGF0b3J5CisgKiAtIFNQQVJT RSBsYXlvdXQgYW5kIFNQTElUIGxheW91dAorICogLSBvbmx5IDE2eDE2IHN1cGVyYmxvY2sKKyAq CisgKiBUaGUgZGVjb2RlciByZWFkcyB0aGUgZGF0YSBmcm9tIHRoZSBTRFJBTSwgZGVjb2RlcyBh bmQgc2VuZHMgdGhlCisgKiBkZWNvZGVkIHBpeGVsIHN0cmVhbSB0byB0aGUgT1NEMSBQbGFuZSBw aXhlbCBjb21wb3Nlci4KKyAqCisgKiBGb3IgdGhlIEcxMkEgRmFtaWx5LCBBbWxvZ2ljIGludGVn cmF0ZWQgYW4gQVJNIEFGQkMgRGVjb2RlciwgbmFtZWQKKyAqIGluIHRoZSB2ZW5kb3Igc291cmNl IGFzICJNQUxJX0FGQkMiLCBhbmQgdGhlIGRlY29kZXIgY2FuIGRlY29kZSB1cAorICogdG8gNCBz dXJmYWNlcywgb25lIGZvciBlYWNoIG9mIHRoZSA0IGF2YWlsYWJsZSBPU0RzLgorICogVGhpcyBk ZWNvZGVyIGlzIGNvbXBhdGlibGUgd2l0aCB0aGUgQUZCQyAxLjIgc3BlY2lmaWNhdGlvbnMgZm9y IHRoZQorICogTWFsaSBHMzEgYW5kIEc1MiBHUFVzLgorICogSXMgc3VwcG9ydHMgOgorICogLSBi YXNpYyBBRkJDIGJ1ZmZlciBmb3IgbXVsdGlwbGUgUkdCIGFuZCBZVVYgcGl4ZWwgZm9ybWF0cwor ICogLSBTUEFSU0UgbGF5b3V0IGFuZCBTUExJVCBsYXlvdXQKKyAqIC0gMTZ4MTYgYW5kIDMyeDgg IndpZGVibGsiIHN1cGVyYmxvY2tzCisgKiAtIFRpbGVkIGhlYWRlcgorICoKKyAqIFRoZSBBUk0g QUZCQyBEZWNvZGVyIGluZGVwZW5kZW50IGZyb20gdGhlIFZQVSBQaXhlbCBQaXBlbGluZSwgc28K KyAqIHRoZSBBUk0gQUZCQyBEZWNvZGVyIHJlYWRzIHRoZSBkYXRhIGZyb20gdGhlIFNEUkFNIHRo ZW4gZGVjb2RlcworICogaW50byBhIHByaXZhdGUgaW50ZXJuYWwgcGh5c2ljYWwgYWRkcmVzcyB3 aGVyZSB0aGUgT1NEMSBQbGFuZSBwaXhlbAorICogY29tcG9zZXIgdW5wYWNrcyB0aGUgZGVjb2Rl ZCBkYXRhLgorICovCisKKy8qIEFtbG9naWMgQUZCQyBEZWNvZGVyIGZvciBHWE0gRmFtaWx5ICov CisKKyNkZWZpbmUgT1NEMV9BRkJDRF9SR0IzMgkweDE1CisKK3N0YXRpYyBpbnQgbWVzb25fZ3ht X2FmYmNkX3BpeGVsX2ZtdCh1NjQgbW9kaWZpZXIsIHVpbnQzMl90IGZvcm1hdCkKK3sKKwlzd2l0 Y2ggKGZvcm1hdCkgeworCWNhc2UgRFJNX0ZPUk1BVF9YUkdCODg4ODoKKwljYXNlIERSTV9GT1JN QVRfQVJHQjg4ODg6CisJY2FzZSBEUk1fRk9STUFUX1hCR1I4ODg4OgorCWNhc2UgRFJNX0ZPUk1B VF9BQkdSODg4ODoKKwkJcmV0dXJuIE9TRDFfQUZCQ0RfUkdCMzI7CisJLyogVE9GSVggc3VwcG9y dCBtb2RlIGZvcm1hdHMgKi8KKwlkZWZhdWx0OgorCQlEUk1fREVCVUcoInVuc3VwcG9ydGVkIGFm YmMgZm9ybWF0WyUwOHhdXG4iLCBmb3JtYXQpOworCQlyZXR1cm4gLUVJTlZBTDsKKwl9Cit9CisK K3N0YXRpYyBib29sIG1lc29uX2d4bV9hZmJjZF9zdXBwb3J0ZWRfZm10KHU2NCBtb2RpZmllciwg dWludDMyX3QgZm9ybWF0KQoreworCWlmIChtb2RpZmllciAmIEFGQkNfRk9STUFUX01PRF9CTE9D S19TSVpFXzMyeDgpCisJCXJldHVybiBmYWxzZTsKKworCWlmICghKG1vZGlmaWVyICYgQUZCQ19G T1JNQVRfTU9EX1lUUikpCisJCXJldHVybiBmYWxzZTsKKworCXJldHVybiBtZXNvbl9neG1fYWZi Y2RfcGl4ZWxfZm10KG1vZGlmaWVyLCBmb3JtYXQpID49IDA7Cit9CisKK3N0YXRpYyBpbnQgbWVz b25fZ3htX2FmYmNkX2luaXQoc3RydWN0IG1lc29uX2RybSAqcHJpdikKK3sKKwlyZXR1cm4gMDsK K30KKworc3RhdGljIGludCBtZXNvbl9neG1fYWZiY2RfcmVzZXQoc3RydWN0IG1lc29uX2RybSAq cHJpdikKK3sKKwl3cml0ZWxfcmVsYXhlZChWSVVfU1dfUkVTRVRfT1NEMV9BRkJDRCwKKwkJICAg ICAgIHByaXYtPmlvX2Jhc2UgKyBfUkVHKFZJVV9TV19SRVNFVCkpOworCXdyaXRlbF9yZWxheGVk KDAsIHByaXYtPmlvX2Jhc2UgKyBfUkVHKFZJVV9TV19SRVNFVCkpOworCisJcmV0dXJuIDA7Cit9 CisKK3N0YXRpYyBpbnQgbWVzb25fZ3htX2FmYmNkX2VuYWJsZShzdHJ1Y3QgbWVzb25fZHJtICpw cml2KQoreworCXdyaXRlbF9yZWxheGVkKEZJRUxEX1BSRVAoT1NEMV9BRkJDRF9JRF9GSUZPX1RI UkQsIDB4NDApIHwKKwkJICAgICAgIE9TRDFfQUZCQ0RfREVDX0VOQUJMRSwKKwkJICAgICAgIHBy aXYtPmlvX2Jhc2UgKyBfUkVHKE9TRDFfQUZCQ0RfRU5BQkxFKSk7CisKKwlyZXR1cm4gMDsKK30K Kworc3RhdGljIGludCBtZXNvbl9neG1fYWZiY2RfZGlzYWJsZShzdHJ1Y3QgbWVzb25fZHJtICpw cml2KQoreworCXdyaXRlbF9iaXRzX3JlbGF4ZWQoT1NEMV9BRkJDRF9ERUNfRU5BQkxFLCAwLAor CQkJICAgIHByaXYtPmlvX2Jhc2UgKyBfUkVHKE9TRDFfQUZCQ0RfRU5BQkxFKSk7CisKKwlyZXR1 cm4gMDsKK30KKworc3RhdGljIGludCBtZXNvbl9neG1fYWZiY2Rfc2V0dXAoc3RydWN0IG1lc29u X2RybSAqcHJpdikKK3sKKwl1MzIgY29udl9sYnVmX2xlbjsKKwl1MzIgbW9kZSA9IEZJRUxEX1BS RVAoT1NEMV9BRkJDRF9NSUZfVVJHRU5ULCAzKSB8CisJCSAgIEZJRUxEX1BSRVAoT1NEMV9BRkJD RF9IT0xEX0xJTkVfTlVNLCA0KSB8CisJCSAgIEZJRUxEX1BSRVAoT1NEMV9BRkJDRF9SR0JBX0VY Q0hBTl9DVFJMLCAweDM0KSB8CisJCSAgIG1lc29uX2d4bV9hZmJjZF9waXhlbF9mbXQocHJpdi0+ YWZiY2QubW9kaWZpZXIsCisJCQkJCSAgICAgcHJpdi0+YWZiY2QuZm9ybWF0KTsKKworCWlmIChw cml2LT5hZmJjZC5tb2RpZmllciAmIEFGQkNfRk9STUFUX01PRF9TUEFSU0UpCisJCW1vZGUgfD0g T1NEMV9BRkJDRF9IUkVHX0hBTEZfQkxPQ0s7CisKKwlpZiAocHJpdi0+YWZiY2QubW9kaWZpZXIg JiBBRkJDX0ZPUk1BVF9NT0RfU1BMSVQpCisJCW1vZGUgfD0gT1NEMV9BRkJDRF9IUkVHX0JMT0NL X1NQTElUOworCisJd3JpdGVsX3JlbGF4ZWQobW9kZSwgcHJpdi0+aW9fYmFzZSArIF9SRUcoT1NE MV9BRkJDRF9NT0RFKSk7CisKKwl3cml0ZWxfcmVsYXhlZChGSUVMRF9QUkVQKE9TRDFfQUZCQ0Rf SFJFR19WU0laRV9JTiwKKwkJCQkgIHByaXYtPnZpdS5vc2QxX3dpZHRoKSB8CisJCSAgICAgICBG SUVMRF9QUkVQKE9TRDFfQUZCQ0RfSFJFR19IU0laRV9JTiwKKwkJCQkgIHByaXYtPnZpdS5vc2Qx X2hlaWdodCksCisJCSAgICAgICBwcml2LT5pb19iYXNlICsgX1JFRyhPU0QxX0FGQkNEX1NJWkVf SU4pKTsKKworCXdyaXRlbF9yZWxheGVkKHByaXYtPnZpdS5vc2QxX2FkZHIgPj4gNCwKKwkJICAg ICAgIHByaXYtPmlvX2Jhc2UgKyBfUkVHKE9TRDFfQUZCQ0RfSERSX1BUUikpOworCXdyaXRlbF9y ZWxheGVkKHByaXYtPnZpdS5vc2QxX2FkZHIgPj4gNCwKKwkJICAgICAgIHByaXYtPmlvX2Jhc2Ug KyBfUkVHKE9TRDFfQUZCQ0RfRlJBTUVfUFRSKSk7CisJLyogVE9GSVg6IGJpdHMgMzE6MjQgYXJl IG5vdCBkb2N1bWVudGVkLCBub3IgdGhlIG1lYW5pbmcgb2YgMHhlNCAqLworCXdyaXRlbF9yZWxh eGVkKCgweGU0IDw8IDI0KSB8IChwcml2LT52aXUub3NkMV9hZGRyICYgMHhmZmZmZmYpLAorCQkg ICAgICAgcHJpdi0+aW9fYmFzZSArIF9SRUcoT1NEMV9BRkJDRF9DSFJPTUFfUFRSKSk7CisKKwlp ZiAocHJpdi0+dml1Lm9zZDFfd2lkdGggPD0gMTI4KQorCQljb252X2xidWZfbGVuID0gMzI7CisJ ZWxzZSBpZiAocHJpdi0+dml1Lm9zZDFfd2lkdGggPD0gMjU2KQorCQljb252X2xidWZfbGVuID0g NjQ7CisJZWxzZSBpZiAocHJpdi0+dml1Lm9zZDFfd2lkdGggPD0gNTEyKQorCQljb252X2xidWZf bGVuID0gMTI4OworCWVsc2UgaWYgKHByaXYtPnZpdS5vc2QxX3dpZHRoIDw9IDEwMjQpCisJCWNv bnZfbGJ1Zl9sZW4gPSAyNTY7CisJZWxzZSBpZiAocHJpdi0+dml1Lm9zZDFfd2lkdGggPD0gMjA0 OCkKKwkJY29udl9sYnVmX2xlbiA9IDUxMjsKKwllbHNlCisJCWNvbnZfbGJ1Zl9sZW4gPSAxMDI0 OworCisJd3JpdGVsX3JlbGF4ZWQoY29udl9sYnVmX2xlbiwKKwkJICAgICAgIHByaXYtPmlvX2Jh c2UgKyBfUkVHKE9TRDFfQUZCQ0RfQ09OVl9DVFJMKSk7CisKKwl3cml0ZWxfcmVsYXhlZChGSUVM RF9QUkVQKE9TRDFfQUZCQ0RfREVDX1BJWEVMX0JHTl9ILCAwKSB8CisJCSAgICAgICBGSUVMRF9Q UkVQKE9TRDFfQUZCQ0RfREVDX1BJWEVMX0VORF9ILAorCQkJCSAgcHJpdi0+dml1Lm9zZDFfd2lk dGggLSAxKSwKKwkJICAgICAgIHByaXYtPmlvX2Jhc2UgKyBfUkVHKE9TRDFfQUZCQ0RfUElYRUxf SFNDT1BFKSk7CisKKwl3cml0ZWxfcmVsYXhlZChGSUVMRF9QUkVQKE9TRDFfQUZCQ0RfREVDX1BJ WEVMX0JHTl9WLCAwKSB8CisJCSAgICAgICBGSUVMRF9QUkVQKE9TRDFfQUZCQ0RfREVDX1BJWEVM X0VORF9WLAorCQkJCSAgcHJpdi0+dml1Lm9zZDFfaGVpZ2h0IC0gMSksCisJCSAgICAgICBwcml2 LT5pb19iYXNlICsgX1JFRyhPU0QxX0FGQkNEX1BJWEVMX1ZTQ09QRSkpOworCisJcmV0dXJuIDA7 Cit9CisKK3N0cnVjdCBtZXNvbl9hZmJjZF9vcHMgbWVzb25fYWZiY2RfZ3htX29wcyA9IHsKKwku aW5pdCA9IG1lc29uX2d4bV9hZmJjZF9pbml0LAorCS5yZXNldCA9IG1lc29uX2d4bV9hZmJjZF9y ZXNldCwKKwkuZW5hYmxlID0gbWVzb25fZ3htX2FmYmNkX2VuYWJsZSwKKwkuZGlzYWJsZSA9IG1l c29uX2d4bV9hZmJjZF9kaXNhYmxlLAorCS5zZXR1cCA9IG1lc29uX2d4bV9hZmJjZF9zZXR1cCwK Kwkuc3VwcG9ydGVkX2ZtdCA9IG1lc29uX2d4bV9hZmJjZF9zdXBwb3J0ZWRfZm10LAorfTsKKwor LyogQVJNIEFGQkMgRGVjb2RlciBmb3IgRzEyQSBGYW1pbHkgKi8KKworLyogQW1sb2dpYyBHMTJB IE1hbGkgQUZCQyBEZWNvZGVyIHN1cHBvcnRlZCBmb3JtYXRzICovCitlbnVtIHsKKwlNQUZCQ19G TVRfUkdCNTY1ID0gMCwKKwlNQUZCQ19GTVRfUkdCQTU1NTEsCisJTUFGQkNfRk1UX1JHQkExMDEw MTAyLAorCU1BRkJDX0ZNVF9ZVVY0MjBfMTBCLAorCU1BRkJDX0ZNVF9SR0I4ODgsCisJTUFGQkNf Rk1UX1JHQkE4ODg4LAorCU1BRkJDX0ZNVF9SR0JBNDQ0NCwKKwlNQUZCQ19GTVRfUjgsCisJTUFG QkNfRk1UX1JHODgsCisJTUFGQkNfRk1UX1lVVjQyMF84QiwKKwlNQUZCQ19GTVRfWVVWNDIyXzhC ID0gMTEsCisJTUFGQkNfRk1UX1lVVjQyMl8xMEIgPSAxNCwKK307CisKK3N0YXRpYyBpbnQgbWVz b25fZzEyYV9hZmJjZF9waXhlbF9mbXQodTY0IG1vZGlmaWVyLCB1aW50MzJfdCBmb3JtYXQpCit7 CisJc3dpdGNoIChmb3JtYXQpIHsKKwljYXNlIERSTV9GT1JNQVRfWFJHQjg4ODg6CisJY2FzZSBE Uk1fRk9STUFUX0FSR0I4ODg4OgorCWNhc2UgRFJNX0ZPUk1BVF9YQkdSODg4ODoKKwljYXNlIERS TV9GT1JNQVRfQUJHUjg4ODg6CisJCXJldHVybiBNQUZCQ19GTVRfUkdCQTg4ODg7CisJY2FzZSBE Uk1fRk9STUFUX1JHQjg4ODoKKwkJcmV0dXJuIE1BRkJDX0ZNVF9SR0I4ODg7CisJY2FzZSBEUk1f Rk9STUFUX1JHQjU2NToKKwkJcmV0dXJuIE1BRkJDX0ZNVF9SR0I1NjU7CisJLyogVE9GSVggc3Vw cG9ydCBtb2RlIGZvcm1hdHMgKi8KKwlkZWZhdWx0OgorCQlEUk1fREVCVUcoInVuc3VwcG9ydGVk IGFmYmMgZm9ybWF0WyUwOHhdXG4iLCBmb3JtYXQpOworCQlyZXR1cm4gLUVJTlZBTDsKKwl9Cit9 CisKK3N0YXRpYyBpbnQgbWVzb25fZzEyYV9hZmJjZF9icHAodWludDMyX3QgZm9ybWF0KQorewor CXN3aXRjaCAoZm9ybWF0KSB7CisJY2FzZSBEUk1fRk9STUFUX1hSR0I4ODg4OgorCWNhc2UgRFJN X0ZPUk1BVF9BUkdCODg4ODoKKwljYXNlIERSTV9GT1JNQVRfWEJHUjg4ODg6CisJY2FzZSBEUk1f Rk9STUFUX0FCR1I4ODg4OgorCQlyZXR1cm4gMzI7CisJY2FzZSBEUk1fRk9STUFUX1JHQjg4ODoK KwkJcmV0dXJuIDI0OworCWNhc2UgRFJNX0ZPUk1BVF9SR0I1NjU6CisJCXJldHVybiAxNjsKKwkv KiBUT0ZJWCBzdXBwb3J0IG1vZGUgZm9ybWF0cyAqLworCWRlZmF1bHQ6CisJCURSTV9FUlJPUigi dW5zdXBwb3J0ZWQgYWZiYyBmb3JtYXRbJTA4eF1cbiIsIGZvcm1hdCk7CisJCXJldHVybiAwOwor CX0KK30KKworc3RhdGljIGludCBtZXNvbl9nMTJhX2FmYmNkX2ZtdF90b19ibGtfbW9kZSh1NjQg bW9kaWZpZXIsIHVpbnQzMl90IGZvcm1hdCkKK3sKKwlzd2l0Y2ggKGZvcm1hdCkgeworCWNhc2Ug RFJNX0ZPUk1BVF9YUkdCODg4ODoKKwljYXNlIERSTV9GT1JNQVRfQVJHQjg4ODg6CisJY2FzZSBE Uk1fRk9STUFUX1hCR1I4ODg4OgorCWNhc2UgRFJNX0ZPUk1BVF9BQkdSODg4ODoKKwkJcmV0dXJu IE9TRF9NQUxJX0NPTE9SX01PREVfUkdCQTg4ODg7CisJY2FzZSBEUk1fRk9STUFUX1JHQjg4ODoK KwkJcmV0dXJuIE9TRF9NQUxJX0NPTE9SX01PREVfUkdCODg4OworCWNhc2UgRFJNX0ZPUk1BVF9S R0I1NjU6CisJCXJldHVybiBPU0RfTUFMSV9DT0xPUl9NT0RFX1JHQjU2NTsKKwkvKiBUT0ZJWCBz dXBwb3J0IG1vZGUgZm9ybWF0cyAqLworCWRlZmF1bHQ6CisJCURSTV9ERUJVRygidW5zdXBwb3J0 ZWQgYWZiYyBmb3JtYXRbJTA4eF1cbiIsIGZvcm1hdCk7CisJCXJldHVybiAtRUlOVkFMOworCX0K K30KKworc3RhdGljIGJvb2wgbWVzb25fZzEyYV9hZmJjZF9zdXBwb3J0ZWRfZm10KHU2NCBtb2Rp ZmllciwgdWludDMyX3QgZm9ybWF0KQoreworCWlmICghKG1vZGlmaWVyICYgQUZCQ19GT1JNQVRf TU9EX1lUUikpCisJCXJldHVybiBmYWxzZTsKKworCXJldHVybiBtZXNvbl9nMTJhX2FmYmNkX3Bp eGVsX2ZtdChtb2RpZmllciwgZm9ybWF0KSA+PSAwOworfQorCitzdGF0aWMgaW50IG1lc29uX2cx MmFfYWZiY2RfaW5pdChzdHJ1Y3QgbWVzb25fZHJtICpwcml2KQoreworCS8qIEhhbmRsZSBBRkJD IERlY29kZXIgcmVzZXQgbWFudWFsbHkgKi8KKwl3cml0ZWxfYml0c19yZWxheGVkKE1BTElfQUZC Q0RfTUFOVUFMX1JFU0VULCBNQUxJX0FGQkNEX01BTlVBTF9SRVNFVCwKKwkJCSAgICBwcml2LT5p b19iYXNlICsgX1JFRyhNQUxJX0FGQkNEX1RPUF9DVFJMKSk7CisKKwlyZXR1cm4gMDsKK30KKwor c3RhdGljIGludCBtZXNvbl9nMTJhX2FmYmNkX3Jlc2V0KHN0cnVjdCBtZXNvbl9kcm0gKnByaXYp Cit7CisJd3JpdGVsX3JlbGF4ZWQoVklVX1NXX1JFU0VUX0cxMkFfQUZCQ19BUkIgfAorCQkgICAg ICAgVklVX1NXX1JFU0VUX0cxMkFfT1NEMV9BRkJDRCwKKwkJICAgICAgIHByaXYtPmlvX2Jhc2Ug KyBfUkVHKFZJVV9TV19SRVNFVCkpOworCXdyaXRlbF9yZWxheGVkKDAsIHByaXYtPmlvX2Jhc2Ug KyBfUkVHKFZJVV9TV19SRVNFVCkpOworCisJcmV0dXJuIDA7Cit9CisKK3N0YXRpYyBpbnQgbWVz b25fZzEyYV9hZmJjZF9lbmFibGUoc3RydWN0IG1lc29uX2RybSAqcHJpdikKK3sKKwl3cml0ZWxf cmVsYXhlZChWUFVfTUFGQkNfSVJRX1NVUkZBQ0VTX0NPTVBMRVRFRCB8CisJCSAgICAgICBWUFVf TUFGQkNfSVJRX0NPTkZJR1VSQVRJT05fU1dBUFBFRCB8CisJCSAgICAgICBWUFVfTUFGQkNfSVJR X0RFQ09ERV9FUlJPUiB8CisJCSAgICAgICBWUFVfTUFGQkNfSVJRX0RFVElMSU5HX0VSUk9SLAor CQkgICAgICAgcHJpdi0+aW9fYmFzZSArIF9SRUcoVlBVX01BRkJDX0lSUV9NQVNLKSk7CisKKwl3 cml0ZWxfYml0c19yZWxheGVkKFZQVV9NQUZCQ19TMF9FTkFCTEUsIFZQVV9NQUZCQ19TMF9FTkFC TEUsCisJCQkgICAgcHJpdi0+aW9fYmFzZSArIF9SRUcoVlBVX01BRkJDX1NVUkZBQ0VfQ0ZHKSk7 CisKKwl3cml0ZWxfcmVsYXhlZChWUFVfTUFGQkNfRElSRUNUX1NXQVAsCisJCSAgICAgICBwcml2 LT5pb19iYXNlICsgX1JFRyhWUFVfTUFGQkNfQ09NTUFORCkpOworCisJcmV0dXJuIDA7Cit9CisK K3N0YXRpYyBpbnQgbWVzb25fZzEyYV9hZmJjZF9kaXNhYmxlKHN0cnVjdCBtZXNvbl9kcm0gKnBy aXYpCit7CisJd3JpdGVsX2JpdHNfcmVsYXhlZChWUFVfTUFGQkNfUzBfRU5BQkxFLCAwLAorCQkJ ICAgIHByaXYtPmlvX2Jhc2UgKyBfUkVHKFZQVV9NQUZCQ19TVVJGQUNFX0NGRykpOworCisJcmV0 dXJuIDA7Cit9CisKK3N0YXRpYyBpbnQgbWVzb25fZzEyYV9hZmJjZF9zZXR1cChzdHJ1Y3QgbWVz b25fZHJtICpwcml2KQoreworCXUzMiBmb3JtYXQgPSBtZXNvbl9nMTJhX2FmYmNkX3BpeGVsX2Zt dChwcml2LT5hZmJjZC5tb2RpZmllciwKKwkJCQkJCXByaXYtPmFmYmNkLmZvcm1hdCk7CisKKwlp ZiAocHJpdi0+YWZiY2QubW9kaWZpZXIgJiBBRkJDX0ZPUk1BVF9NT0RfWVRSKQorCQlmb3JtYXQg fD0gVlBVX01BRkJDX1lVVl9UUkFOU0ZPUk07CisKKwlpZiAocHJpdi0+YWZiY2QubW9kaWZpZXIg JiBBRkJDX0ZPUk1BVF9NT0RfU1BMSVQpCisJCWZvcm1hdCB8PSBWUFVfTUFGQkNfQkxPQ0tfU1BM SVQ7CisKKwlpZiAocHJpdi0+YWZiY2QubW9kaWZpZXIgJiBBRkJDX0ZPUk1BVF9NT0RfVElMRUQp CisJCWZvcm1hdCB8PSBWUFVfTUFGQkNfVElMRURfSEVBREVSX0VOOworCisJaWYgKChwcml2LT5h ZmJjZC5tb2RpZmllciAmIEFGQkNfRk9STUFUX01PRF9CTE9DS19TSVpFX01BU0spID09CisJCUFG QkNfRk9STUFUX01PRF9CTE9DS19TSVpFXzMyeDgpCisJCWZvcm1hdCB8PSBGSUVMRF9QUkVQKFZQ VV9NQUZCQ19TVVBFUl9CTE9DS19BU1BFQ1QsIDEpOworCisJd3JpdGVsX3JlbGF4ZWQoZm9ybWF0 LAorCQkgICAgICAgcHJpdi0+aW9fYmFzZSArIF9SRUcoVlBVX01BRkJDX0ZPUk1BVF9TUEVDSUZJ RVJfUzApKTsKKworCXdyaXRlbF9yZWxheGVkKHByaXYtPnZpdS5vc2QxX2FkZHIsCisJCSAgICAg ICBwcml2LT5pb19iYXNlICsgX1JFRyhWUFVfTUFGQkNfSEVBREVSX0JVRl9BRERSX0xPV19TMCkp OworCXdyaXRlbF9yZWxheGVkKDAsCisJCSAgICAgICBwcml2LT5pb19iYXNlICsgX1JFRyhWUFVf TUFGQkNfSEVBREVSX0JVRl9BRERSX0hJR0hfUzApKTsKKworCXdyaXRlbF9yZWxheGVkKHByaXYt PnZpdS5vc2QxX3dpZHRoLAorCQkgICAgICAgcHJpdi0+aW9fYmFzZSArIF9SRUcoVlBVX01BRkJD X0JVRkZFUl9XSURUSF9TMCkpOworCXdyaXRlbF9yZWxheGVkKEFMSUdOKHByaXYtPnZpdS5vc2Qx X2hlaWdodCwgMzIpLAorCQkgICAgICAgcHJpdi0+aW9fYmFzZSArIF9SRUcoVlBVX01BRkJDX0JV RkZFUl9IRUlHSFRfUzApKTsKKworCXdyaXRlbF9yZWxheGVkKDAsCisJCSAgICAgICBwcml2LT5p b19iYXNlICsgX1JFRyhWUFVfTUFGQkNfQk9VTkRJTkdfQk9YX1hfU1RBUlRfUzApKTsKKwl3cml0 ZWxfcmVsYXhlZChwcml2LT52aXUub3NkMV93aWR0aCAtIDEsCisJCSAgICAgICBwcml2LT5pb19i YXNlICsgX1JFRyhWUFVfTUFGQkNfQk9VTkRJTkdfQk9YX1hfRU5EX1MwKSk7CisJd3JpdGVsX3Jl bGF4ZWQoMCwKKwkJICAgICAgIHByaXYtPmlvX2Jhc2UgKyBfUkVHKFZQVV9NQUZCQ19CT1VORElO R19CT1hfWV9TVEFSVF9TMCkpOworCXdyaXRlbF9yZWxheGVkKHByaXYtPnZpdS5vc2QxX2hlaWdo dCAtIDEsCisJCSAgICAgICBwcml2LT5pb19iYXNlICsgX1JFRyhWUFVfTUFGQkNfQk9VTkRJTkdf Qk9YX1lfRU5EX1MwKSk7CisKKwl3cml0ZWxfcmVsYXhlZChNRVNPTl9HMTJBX0FGQkNEX09VVF9B RERSLAorCQkgICAgICAgcHJpdi0+aW9fYmFzZSArIF9SRUcoVlBVX01BRkJDX09VVFBVVF9CVUZf QUREUl9MT1dfUzApKTsKKwl3cml0ZWxfcmVsYXhlZCgwLAorCQkgICAgICAgcHJpdi0+aW9fYmFz ZSArIF9SRUcoVlBVX01BRkJDX09VVFBVVF9CVUZfQUREUl9ISUdIX1MwKSk7CisKKwl3cml0ZWxf cmVsYXhlZChwcml2LT52aXUub3NkMV93aWR0aCAqCisJCSAgICAgICAobWVzb25fZzEyYV9hZmJj ZF9icHAocHJpdi0+YWZiY2QuZm9ybWF0KSAvIDgpLAorCQkgICAgICAgcHJpdi0+aW9fYmFzZSAr IF9SRUcoVlBVX01BRkJDX09VVFBVVF9CVUZfU1RSSURFX1MwKSk7CisKKwlyZXR1cm4gMDsKK30K Kworc3RydWN0IG1lc29uX2FmYmNkX29wcyBtZXNvbl9hZmJjZF9nMTJhX29wcyA9IHsKKwkuaW5p dCA9IG1lc29uX2cxMmFfYWZiY2RfaW5pdCwKKwkucmVzZXQgPSBtZXNvbl9nMTJhX2FmYmNkX3Jl c2V0LAorCS5lbmFibGUgPSBtZXNvbl9nMTJhX2FmYmNkX2VuYWJsZSwKKwkuZGlzYWJsZSA9IG1l c29uX2cxMmFfYWZiY2RfZGlzYWJsZSwKKwkuc2V0dXAgPSBtZXNvbl9nMTJhX2FmYmNkX3NldHVw LAorCS5mbXRfdG9fYmxrX21vZGUgPSBtZXNvbl9nMTJhX2FmYmNkX2ZtdF90b19ibGtfbW9kZSwK Kwkuc3VwcG9ydGVkX2ZtdCA9IG1lc29uX2cxMmFfYWZiY2Rfc3VwcG9ydGVkX2ZtdCwKK307CmRp ZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9kcm0vbWVzb24vbWVzb25fb3NkX2FmYmNkLmggYi9kcml2 ZXJzL2dwdS9kcm0vbWVzb24vbWVzb25fb3NkX2FmYmNkLmgKbmV3IGZpbGUgbW9kZSAxMDA2NDQK aW5kZXggMDAwMDAwMDAwMDAwLi41ZTU1MjMzMDRmNDIKLS0tIC9kZXYvbnVsbAorKysgYi9kcml2 ZXJzL2dwdS9kcm0vbWVzb24vbWVzb25fb3NkX2FmYmNkLmgKQEAgLTAsMCArMSwyOCBAQAorLyog U1BEWC1MaWNlbnNlLUlkZW50aWZpZXI6IEdQTC0yLjArICovCisvKgorICogQ29weXJpZ2h0IChD KSAyMDE5IEJheUxpYnJlLCBTQVMKKyAqIEF1dGhvcjogTmVpbCBBcm1zdHJvbmcgPG5hcm1zdHJv bmdAYmF5bGlicmUuY29tPgorICovCisKKyNpZm5kZWYgX19NRVNPTl9PU0RfQUZCQ0RfSAorI2Rl ZmluZSBfX01FU09OX09TRF9BRkJDRF9ICisKKyNpbmNsdWRlICJtZXNvbl9kcnYuaCIKKworLyog VGhpcyBpcyBhbiBpbnRlcm5hbCBhZGRyZXNzIHVzZWQgdG8gdHJhbnNmZXIgcGl4ZWwgZnJvbSBB RkJDIHRvIHRoZSBWSVUgKi8KKyNkZWZpbmUgTUVTT05fRzEyQV9BRkJDRF9PVVRfQUREUgkweDEw MDAwMDAKKworc3RydWN0IG1lc29uX2FmYmNkX29wcyB7CisJaW50ICgqaW5pdCkoc3RydWN0IG1l c29uX2RybSAqcHJpdik7CisJaW50ICgqcmVzZXQpKHN0cnVjdCBtZXNvbl9kcm0gKnByaXYpOwor CWludCAoKmVuYWJsZSkoc3RydWN0IG1lc29uX2RybSAqcHJpdik7CisJaW50ICgqZGlzYWJsZSko c3RydWN0IG1lc29uX2RybSAqcHJpdik7CisJaW50ICgqc2V0dXApKHN0cnVjdCBtZXNvbl9kcm0g KnByaXYpOworCWludCAoKmZtdF90b19ibGtfbW9kZSkodTY0IG1vZGlmaWVyLCB1aW50MzJfdCBm b3JtYXQpOworCWJvb2wgKCpzdXBwb3J0ZWRfZm10KSh1NjQgbW9kaWZpZXIsIHVpbnQzMl90IGZv cm1hdCk7Cit9OworCitleHRlcm4gc3RydWN0IG1lc29uX2FmYmNkX29wcyBtZXNvbl9hZmJjZF9n eG1fb3BzOworZXh0ZXJuIHN0cnVjdCBtZXNvbl9hZmJjZF9vcHMgbWVzb25fYWZiY2RfZzEyYV9v cHM7CisKKyNlbmRpZiAvKiBfX01FU09OX09TRF9BRkJDRF9IICovCi0tIAoyLjIyLjAKCl9fX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fCmRyaS1kZXZlbCBtYWls aW5nIGxpc3QKZHJpLWRldmVsQGxpc3RzLmZyZWVkZXNrdG9wLm9yZwpodHRwczovL2xpc3RzLmZy ZWVkZXNrdG9wLm9yZy9tYWlsbWFuL2xpc3RpbmZvL2RyaS1kZXZlbA== From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org X-Spam-Level: X-Spam-Status: No, score=-9.8 required=3.0 tests=DKIMWL_WL_HIGH,DKIM_SIGNED, DKIM_VALID,HEADER_FROM_DIFFERENT_DOMAINS,INCLUDES_PATCH,MAILING_LIST_MULTI, SIGNED_OFF_BY,SPF_HELO_NONE,SPF_PASS,URIBL_BLOCKED,USER_AGENT_GIT autolearn=ham autolearn_force=no version=3.4.0 Received: from mail.kernel.org (mail.kernel.org [198.145.29.99]) by smtp.lore.kernel.org (Postfix) with ESMTP id 6AD4BC4360C for ; Thu, 10 Oct 2019 09:26:31 +0000 (UTC) Received: from bombadil.infradead.org (bombadil.infradead.org [198.137.202.133]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by mail.kernel.org (Postfix) with ESMTPS id 355332064A for ; Thu, 10 Oct 2019 09:26:31 +0000 (UTC) Authentication-Results: mail.kernel.org; dkim=pass (2048-bit key) header.d=lists.infradead.org header.i=@lists.infradead.org header.b="jZ///UYr"; dkim=fail reason="signature verification failed" (2048-bit key) header.d=baylibre-com.20150623.gappssmtp.com header.i=@baylibre-com.20150623.gappssmtp.com header.b="LirWXDC/" DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org 355332064A Authentication-Results: mail.kernel.org; dmarc=none (p=none dis=none) header.from=baylibre.com Authentication-Results: mail.kernel.org; spf=none smtp.mailfrom=linux-amlogic-bounces+linux-amlogic=archiver.kernel.org@lists.infradead.org DKIM-Signature: v=1; a=rsa-sha256; q=dns/txt; c=relaxed/relaxed; d=lists.infradead.org; s=bombadil.20170209; h=Sender: Content-Transfer-Encoding:Content-Type:Cc:List-Subscribe:List-Help:List-Post: List-Archive:List-Unsubscribe:List-Id:MIME-Version:References:In-Reply-To: Message-Id:Date:Subject:To:From:Reply-To:Content-ID:Content-Description: Resent-Date:Resent-From:Resent-Sender:Resent-To:Resent-Cc:Resent-Message-ID: List-Owner; bh=CucNkfxf0ujb4mFA0A5SICe4Zan/K3b8i5w0ARsS0cg=; b=jZ///UYrQITc/W Tq8QbIr2fHMSd3RCAFiqysFVqB8aU8ibqasyQ3ziliv3ftZWXAW4ScIS32clKtGTQRLc0KYDKPUAg jokBQEaESHS9z5fW1XldUNt8EhtSh3/jicIyL/5gGjXgXN3apGMkohNkbMlQJ7qwGn+Yvz/1MD6/1 hEtKtZbNp4nKbQFUWVqdhvighrIGlTMDjLZEMwlkocW9OvZDVZhBD+3/3gRh5Sbe16BXN3pYUcH7E 2bspIl7+QdQc5MyXrqirV2KnIFwUXPL8VUe7nHYPYNhwqASoA654QyCwuRRsEtA+2Ji57MJDiLw4D QgNl5/QG4aRQdyt25gog==; Received: from localhost ([127.0.0.1] helo=bombadil.infradead.org) by bombadil.infradead.org with esmtp (Exim 4.92.2 #3 (Red Hat Linux)) id 1iIUiH-0006mt-9t; Thu, 10 Oct 2019 09:26:25 +0000 Received: from mail-wm1-x343.google.com ([2a00:1450:4864:20::343]) by bombadil.infradead.org with esmtps (Exim 4.92.2 #3 (Red Hat Linux)) id 1iIUhR-0005yq-BZ for linux-amlogic@lists.infradead.org; Thu, 10 Oct 2019 09:25:37 +0000 Received: by mail-wm1-x343.google.com with SMTP id 3so5971036wmi.3 for ; Thu, 10 Oct 2019 02:25:33 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=baylibre-com.20150623.gappssmtp.com; s=20150623; h=from:to:cc:subject:date:message-id:in-reply-to:references :mime-version:content-transfer-encoding; bh=jNOW6VFMFnuOEHBHUTNnkLO8G+eFUm1jKDuBa5pJiKw=; b=LirWXDC/uJCGfPj6YwT8MzFZ/H8e3/V/KIYk6xg9HSOap4IKAfXvSPWxCbXaqk84nJ qnZ+HIRKaUknvCY9Wy7uMsfe+3HD6Rr5rhnpifac91CnRM2o4j6AI0rQuQ8be/WaRTHu hgsgTBGLXPnRkw9+Jx2bwqwN/CPI/6IyjvA8NHAtMW+m85dX5as7MwHgTZNNyn4Cm4y3 Lb4te3Ce/SGrkF5TA+s1mrxx85RJ4DyxdGGrjuHIqJ3P6QtVXoMhqdb0KL+dsqtDX9ev L8Od8xDxC0HFUGQw5E6kRabxnZ1bevJqX90cD67QSLoCrJG/wUt00KhxIhVEPd7q47H6 r0Vw== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references:mime-version:content-transfer-encoding; bh=jNOW6VFMFnuOEHBHUTNnkLO8G+eFUm1jKDuBa5pJiKw=; b=k1DJR+uAJbaWdjnSgeIRUpI9wk4qi5GlxbdtFJbjPLM+1vVwXt/BdH4Zy27zVSnNER 3pAOuAl/eBfugs1GOTmS0MSBsMDiuaq4c+2SxcN+nT5g8J7B1Wk0Ii0GwDz4nPu21xDr 8fKOA3ksvv28rAA4G9oTjOYmazC+1uXCwKpOSU+y5BcAP4I2WtYTVCnHIJsrpIYbj0cs PT3SC59ZKdsWIAnApnQRKTtYvN1xUiy2YASnytTT/5mng15TdkXw3G3ENsIWxc5h9t7T aNAL5wPHKkcrl3IA+Y360cTJa/4GyXkLAY4M0Ob93lLua5Kg6XMFHJmwsudZuPpKq5ss yOTA== X-Gm-Message-State: APjAAAVwe3zIB7xaJRYsl6WqFwJ7inWM39051vtEMppOytqQ+GXwuUw0 4bz9bMuW+CACjkp9dTTGpbNir+IRnUJ7hA== X-Google-Smtp-Source: APXvYqwrx9k09Qz9beA56ra3SmYtiEFiO6W6iJpVpbX/4MiFYrKQUlpbm22UU2M2mqGVU9vMVtpwwA== X-Received: by 2002:a05:600c:c1:: with SMTP id u1mr6233756wmm.87.1570699531768; Thu, 10 Oct 2019 02:25:31 -0700 (PDT) Received: from bender.baylibre.local (lmontsouris-657-1-212-31.w90-63.abo.wanadoo.fr. [90.63.244.31]) by smtp.gmail.com with ESMTPSA id s10sm8373770wmf.48.2019.10.10.02.25.31 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Thu, 10 Oct 2019 02:25:31 -0700 (PDT) From: Neil Armstrong To: dri-devel@lists.freedesktop.org Subject: [PATCH 3/7] drm/meson: Add AFBCD module driver Date: Thu, 10 Oct 2019 11:25:22 +0200 Message-Id: <20191010092526.10419-4-narmstrong@baylibre.com> X-Mailer: git-send-email 2.22.0 In-Reply-To: <20191010092526.10419-1-narmstrong@baylibre.com> References: <20191010092526.10419-1-narmstrong@baylibre.com> MIME-Version: 1.0 X-CRM114-Version: 20100106-BlameMichelson ( TRE 0.8.0 (BSD) ) MR-646709E3 X-CRM114-CacheID: sfid-20191010_022533_531170_CACD229A X-CRM114-Status: GOOD ( 22.79 ) X-BeenThere: linux-amlogic@lists.infradead.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Cc: khilman@baylibre.com, linux-amlogic@lists.infradead.org, ayan.halder@arm.com, linux-arm-kernel@lists.infradead.org, Neil Armstrong Content-Type: text/plain; charset="us-ascii" Content-Transfer-Encoding: 7bit Sender: "linux-amlogic" Errors-To: linux-amlogic-bounces+linux-amlogic=archiver.kernel.org@lists.infradead.org This adds the driver for the ARM Framebuffer Compression decoders found in the Amlogic GXM and G12A SoCs. The Amlogic GXM and G12A AFBC decoder are totally different, the GXM only handling only the AFBC v1.0 modes and the G12A decoder handling the AFBC v1.2 modes. The G12A AFBC decoder is an external IP integrated in the video pipeline, and the GXM AFBC decoder seems to the an Amlogic custom decoder more tighly integrated in the video pipeline. The GXM AFBC decoder can handle only one AFBC plane for 2 available OSD planes available in HW, and the G12A AFBC decoder can handle up to 4 AFBC planes for up to 3 OSD planes available in HW. The Amlogic GXM supports 16x16 SPARSE and 16x16 SPLIT AFBC buffers up to 4k. On the other side, for G12A SPLIT is mandatory in 16x16 block mode, but for 4k modes 32x8+SPLIT AFBC buffers is manadatory for performances reasons. Signed-off-by: Neil Armstrong --- drivers/gpu/drm/meson/Makefile | 1 + drivers/gpu/drm/meson/meson_drv.c | 38 ++- drivers/gpu/drm/meson/meson_drv.h | 12 + drivers/gpu/drm/meson/meson_osd_afbcd.c | 370 ++++++++++++++++++++++++ drivers/gpu/drm/meson/meson_osd_afbcd.h | 28 ++ 5 files changed, 443 insertions(+), 6 deletions(-) create mode 100644 drivers/gpu/drm/meson/meson_osd_afbcd.c create mode 100644 drivers/gpu/drm/meson/meson_osd_afbcd.h diff --git a/drivers/gpu/drm/meson/Makefile b/drivers/gpu/drm/meson/Makefile index c389e2399133..b1fa055aaed3 100644 --- a/drivers/gpu/drm/meson/Makefile +++ b/drivers/gpu/drm/meson/Makefile @@ -1,6 +1,7 @@ # SPDX-License-Identifier: GPL-2.0-only meson-drm-y := meson_drv.o meson_plane.o meson_crtc.o meson_venc_cvbs.o meson-drm-y += meson_viu.o meson_vpp.o meson_venc.o meson_vclk.o meson_overlay.o +meson-drm-y += meson_osd_afbcd.o obj-$(CONFIG_DRM_MESON) += meson-drm.o obj-$(CONFIG_DRM_MESON_DW_HDMI) += meson_dw_hdmi.o diff --git a/drivers/gpu/drm/meson/meson_drv.c b/drivers/gpu/drm/meson/meson_drv.c index a24f8dec5adc..0f31e70bb94f 100644 --- a/drivers/gpu/drm/meson/meson_drv.c +++ b/drivers/gpu/drm/meson/meson_drv.c @@ -28,6 +28,7 @@ #include "meson_drv.h" #include "meson_overlay.h" #include "meson_plane.h" +#include "meson_osd_afbcd.h" #include "meson_registers.h" #include "meson_venc_cvbs.h" #include "meson_viu.h" @@ -184,6 +185,7 @@ static void meson_remove_framebuffers(void) static int meson_drv_bind_master(struct device *dev, bool has_components) { struct platform_device *pdev = to_platform_device(dev); + const struct meson_drm_match_data *match; struct meson_drm *priv; struct drm_device *drm; struct resource *res; @@ -196,6 +198,10 @@ static int meson_drv_bind_master(struct device *dev, bool has_components) return -ENODEV; } + match = of_device_get_match_data(dev); + if (!match) + return -ENODEV; + drm = drm_dev_alloc(&meson_driver, dev); if (IS_ERR(drm)) return PTR_ERR(drm); @@ -208,8 +214,8 @@ static int meson_drv_bind_master(struct device *dev, bool has_components) drm->dev_private = priv; priv->drm = drm; priv->dev = dev; - - priv->compat = (enum vpu_compatible)of_device_get_match_data(priv->dev); + priv->compat = match->compat; + priv->afbcd.ops = match->afbcd_ops; res = platform_get_resource_byname(pdev, IORESOURCE_MEM, "vpu"); regs = devm_ioremap_resource(dev, res); @@ -289,6 +295,8 @@ static int meson_drv_bind_master(struct device *dev, bool has_components) meson_venc_init(priv); meson_vpp_init(priv); meson_viu_init(priv); + if (priv->afbcd.ops) + priv->afbcd.ops->init(priv); /* Encoder Initialization */ @@ -454,15 +462,33 @@ static int meson_drv_probe(struct platform_device *pdev) return 0; }; +static struct meson_drm_match_data meson_drm_gxbb_data = { + .compat = VPU_COMPATIBLE_GXBB, +}; + +static struct meson_drm_match_data meson_drm_gxl_data = { + .compat = VPU_COMPATIBLE_GXL, +}; + +static struct meson_drm_match_data meson_drm_gxm_data = { + .compat = VPU_COMPATIBLE_GXM, + .afbcd_ops = &meson_afbcd_gxm_ops, +}; + +static struct meson_drm_match_data meson_drm_g12a_data = { + .compat = VPU_COMPATIBLE_G12A, + .afbcd_ops = &meson_afbcd_g12a_ops, +}; + static const struct of_device_id dt_match[] = { { .compatible = "amlogic,meson-gxbb-vpu", - .data = (void *)VPU_COMPATIBLE_GXBB }, + .data = (void *)&meson_drm_gxbb_data }, { .compatible = "amlogic,meson-gxl-vpu", - .data = (void *)VPU_COMPATIBLE_GXL }, + .data = (void *)&meson_drm_gxl_data }, { .compatible = "amlogic,meson-gxm-vpu", - .data = (void *)VPU_COMPATIBLE_GXM }, + .data = (void *)&meson_drm_gxm_data }, { .compatible = "amlogic,meson-g12a-vpu", - .data = (void *)VPU_COMPATIBLE_G12A }, + .data = (void *)&meson_drm_g12a_data }, {} }; MODULE_DEVICE_TABLE(of, dt_match); diff --git a/drivers/gpu/drm/meson/meson_drv.h b/drivers/gpu/drm/meson/meson_drv.h index 3287282450a9..60f13c6f34e5 100644 --- a/drivers/gpu/drm/meson/meson_drv.h +++ b/drivers/gpu/drm/meson/meson_drv.h @@ -16,6 +16,7 @@ struct drm_crtc; struct drm_device; struct drm_plane; struct meson_drm; +struct meson_afbcd_ops; enum vpu_compatible { VPU_COMPATIBLE_GXBB = 0, @@ -24,6 +25,11 @@ enum vpu_compatible { VPU_COMPATIBLE_G12A = 3, }; +struct meson_drm_match_data { + enum vpu_compatible compat; + struct meson_afbcd_ops *afbcd_ops; +}; + struct meson_drm { struct device *dev; enum vpu_compatible compat; @@ -123,6 +129,12 @@ struct meson_drm { bool venc_repeat; bool hdmi_use_enci; } venc; + + struct { + struct meson_afbcd_ops *ops; + u64 modifier; + u32 format; + } afbcd; }; static inline int meson_vpu_is_compatible(struct meson_drm *priv, diff --git a/drivers/gpu/drm/meson/meson_osd_afbcd.c b/drivers/gpu/drm/meson/meson_osd_afbcd.c new file mode 100644 index 000000000000..36caf5716e8c --- /dev/null +++ b/drivers/gpu/drm/meson/meson_osd_afbcd.c @@ -0,0 +1,370 @@ +// SPDX-License-Identifier: GPL-2.0+ +/* + * Copyright (C) 2019 BayLibre, SAS + * Author: Neil Armstrong + */ + +#include + +#include +#include + +#include "meson_drv.h" +#include "meson_registers.h" +#include "meson_viu.h" +#include "meson_osd_afbcd.h" + +/* + * DOC: Driver for the ARM FrameBuffer Compression Decoders + * + * The Amlogic GXM and G12A SoC families embeds an AFBC Decoder, + * to decode compressed buffers generated by the ARM Mali GPU. + * + * For the GXM Family, Amlogic designed their own Decoder, named in + * the vendor source as "MESON_AFBC", and a single decoder is available + * for the 2 OSD planes. + * This decoder is compatible with the AFBC 1.0 specifications and the + * Mali T820 GPU capabilities. + * It supports : + * - basic AFBC buffer for RGB32 only, thus YTR feature is mandatory + * - SPARSE layout and SPLIT layout + * - only 16x16 superblock + * + * The decoder reads the data from the SDRAM, decodes and sends the + * decoded pixel stream to the OSD1 Plane pixel composer. + * + * For the G12A Family, Amlogic integrated an ARM AFBC Decoder, named + * in the vendor source as "MALI_AFBC", and the decoder can decode up + * to 4 surfaces, one for each of the 4 available OSDs. + * This decoder is compatible with the AFBC 1.2 specifications for the + * Mali G31 and G52 GPUs. + * Is supports : + * - basic AFBC buffer for multiple RGB and YUV pixel formats + * - SPARSE layout and SPLIT layout + * - 16x16 and 32x8 "wideblk" superblocks + * - Tiled header + * + * The ARM AFBC Decoder independent from the VPU Pixel Pipeline, so + * the ARM AFBC Decoder reads the data from the SDRAM then decodes + * into a private internal physical address where the OSD1 Plane pixel + * composer unpacks the decoded data. + */ + +/* Amlogic AFBC Decoder for GXM Family */ + +#define OSD1_AFBCD_RGB32 0x15 + +static int meson_gxm_afbcd_pixel_fmt(u64 modifier, uint32_t format) +{ + switch (format) { + case DRM_FORMAT_XRGB8888: + case DRM_FORMAT_ARGB8888: + case DRM_FORMAT_XBGR8888: + case DRM_FORMAT_ABGR8888: + return OSD1_AFBCD_RGB32; + /* TOFIX support mode formats */ + default: + DRM_DEBUG("unsupported afbc format[%08x]\n", format); + return -EINVAL; + } +} + +static bool meson_gxm_afbcd_supported_fmt(u64 modifier, uint32_t format) +{ + if (modifier & AFBC_FORMAT_MOD_BLOCK_SIZE_32x8) + return false; + + if (!(modifier & AFBC_FORMAT_MOD_YTR)) + return false; + + return meson_gxm_afbcd_pixel_fmt(modifier, format) >= 0; +} + +static int meson_gxm_afbcd_init(struct meson_drm *priv) +{ + return 0; +} + +static int meson_gxm_afbcd_reset(struct meson_drm *priv) +{ + writel_relaxed(VIU_SW_RESET_OSD1_AFBCD, + priv->io_base + _REG(VIU_SW_RESET)); + writel_relaxed(0, priv->io_base + _REG(VIU_SW_RESET)); + + return 0; +} + +static int meson_gxm_afbcd_enable(struct meson_drm *priv) +{ + writel_relaxed(FIELD_PREP(OSD1_AFBCD_ID_FIFO_THRD, 0x40) | + OSD1_AFBCD_DEC_ENABLE, + priv->io_base + _REG(OSD1_AFBCD_ENABLE)); + + return 0; +} + +static int meson_gxm_afbcd_disable(struct meson_drm *priv) +{ + writel_bits_relaxed(OSD1_AFBCD_DEC_ENABLE, 0, + priv->io_base + _REG(OSD1_AFBCD_ENABLE)); + + return 0; +} + +static int meson_gxm_afbcd_setup(struct meson_drm *priv) +{ + u32 conv_lbuf_len; + u32 mode = FIELD_PREP(OSD1_AFBCD_MIF_URGENT, 3) | + FIELD_PREP(OSD1_AFBCD_HOLD_LINE_NUM, 4) | + FIELD_PREP(OSD1_AFBCD_RGBA_EXCHAN_CTRL, 0x34) | + meson_gxm_afbcd_pixel_fmt(priv->afbcd.modifier, + priv->afbcd.format); + + if (priv->afbcd.modifier & AFBC_FORMAT_MOD_SPARSE) + mode |= OSD1_AFBCD_HREG_HALF_BLOCK; + + if (priv->afbcd.modifier & AFBC_FORMAT_MOD_SPLIT) + mode |= OSD1_AFBCD_HREG_BLOCK_SPLIT; + + writel_relaxed(mode, priv->io_base + _REG(OSD1_AFBCD_MODE)); + + writel_relaxed(FIELD_PREP(OSD1_AFBCD_HREG_VSIZE_IN, + priv->viu.osd1_width) | + FIELD_PREP(OSD1_AFBCD_HREG_HSIZE_IN, + priv->viu.osd1_height), + priv->io_base + _REG(OSD1_AFBCD_SIZE_IN)); + + writel_relaxed(priv->viu.osd1_addr >> 4, + priv->io_base + _REG(OSD1_AFBCD_HDR_PTR)); + writel_relaxed(priv->viu.osd1_addr >> 4, + priv->io_base + _REG(OSD1_AFBCD_FRAME_PTR)); + /* TOFIX: bits 31:24 are not documented, nor the meaning of 0xe4 */ + writel_relaxed((0xe4 << 24) | (priv->viu.osd1_addr & 0xffffff), + priv->io_base + _REG(OSD1_AFBCD_CHROMA_PTR)); + + if (priv->viu.osd1_width <= 128) + conv_lbuf_len = 32; + else if (priv->viu.osd1_width <= 256) + conv_lbuf_len = 64; + else if (priv->viu.osd1_width <= 512) + conv_lbuf_len = 128; + else if (priv->viu.osd1_width <= 1024) + conv_lbuf_len = 256; + else if (priv->viu.osd1_width <= 2048) + conv_lbuf_len = 512; + else + conv_lbuf_len = 1024; + + writel_relaxed(conv_lbuf_len, + priv->io_base + _REG(OSD1_AFBCD_CONV_CTRL)); + + writel_relaxed(FIELD_PREP(OSD1_AFBCD_DEC_PIXEL_BGN_H, 0) | + FIELD_PREP(OSD1_AFBCD_DEC_PIXEL_END_H, + priv->viu.osd1_width - 1), + priv->io_base + _REG(OSD1_AFBCD_PIXEL_HSCOPE)); + + writel_relaxed(FIELD_PREP(OSD1_AFBCD_DEC_PIXEL_BGN_V, 0) | + FIELD_PREP(OSD1_AFBCD_DEC_PIXEL_END_V, + priv->viu.osd1_height - 1), + priv->io_base + _REG(OSD1_AFBCD_PIXEL_VSCOPE)); + + return 0; +} + +struct meson_afbcd_ops meson_afbcd_gxm_ops = { + .init = meson_gxm_afbcd_init, + .reset = meson_gxm_afbcd_reset, + .enable = meson_gxm_afbcd_enable, + .disable = meson_gxm_afbcd_disable, + .setup = meson_gxm_afbcd_setup, + .supported_fmt = meson_gxm_afbcd_supported_fmt, +}; + +/* ARM AFBC Decoder for G12A Family */ + +/* Amlogic G12A Mali AFBC Decoder supported formats */ +enum { + MAFBC_FMT_RGB565 = 0, + MAFBC_FMT_RGBA5551, + MAFBC_FMT_RGBA1010102, + MAFBC_FMT_YUV420_10B, + MAFBC_FMT_RGB888, + MAFBC_FMT_RGBA8888, + MAFBC_FMT_RGBA4444, + MAFBC_FMT_R8, + MAFBC_FMT_RG88, + MAFBC_FMT_YUV420_8B, + MAFBC_FMT_YUV422_8B = 11, + MAFBC_FMT_YUV422_10B = 14, +}; + +static int meson_g12a_afbcd_pixel_fmt(u64 modifier, uint32_t format) +{ + switch (format) { + case DRM_FORMAT_XRGB8888: + case DRM_FORMAT_ARGB8888: + case DRM_FORMAT_XBGR8888: + case DRM_FORMAT_ABGR8888: + return MAFBC_FMT_RGBA8888; + case DRM_FORMAT_RGB888: + return MAFBC_FMT_RGB888; + case DRM_FORMAT_RGB565: + return MAFBC_FMT_RGB565; + /* TOFIX support mode formats */ + default: + DRM_DEBUG("unsupported afbc format[%08x]\n", format); + return -EINVAL; + } +} + +static int meson_g12a_afbcd_bpp(uint32_t format) +{ + switch (format) { + case DRM_FORMAT_XRGB8888: + case DRM_FORMAT_ARGB8888: + case DRM_FORMAT_XBGR8888: + case DRM_FORMAT_ABGR8888: + return 32; + case DRM_FORMAT_RGB888: + return 24; + case DRM_FORMAT_RGB565: + return 16; + /* TOFIX support mode formats */ + default: + DRM_ERROR("unsupported afbc format[%08x]\n", format); + return 0; + } +} + +static int meson_g12a_afbcd_fmt_to_blk_mode(u64 modifier, uint32_t format) +{ + switch (format) { + case DRM_FORMAT_XRGB8888: + case DRM_FORMAT_ARGB8888: + case DRM_FORMAT_XBGR8888: + case DRM_FORMAT_ABGR8888: + return OSD_MALI_COLOR_MODE_RGBA8888; + case DRM_FORMAT_RGB888: + return OSD_MALI_COLOR_MODE_RGB888; + case DRM_FORMAT_RGB565: + return OSD_MALI_COLOR_MODE_RGB565; + /* TOFIX support mode formats */ + default: + DRM_DEBUG("unsupported afbc format[%08x]\n", format); + return -EINVAL; + } +} + +static bool meson_g12a_afbcd_supported_fmt(u64 modifier, uint32_t format) +{ + if (!(modifier & AFBC_FORMAT_MOD_YTR)) + return false; + + return meson_g12a_afbcd_pixel_fmt(modifier, format) >= 0; +} + +static int meson_g12a_afbcd_init(struct meson_drm *priv) +{ + /* Handle AFBC Decoder reset manually */ + writel_bits_relaxed(MALI_AFBCD_MANUAL_RESET, MALI_AFBCD_MANUAL_RESET, + priv->io_base + _REG(MALI_AFBCD_TOP_CTRL)); + + return 0; +} + +static int meson_g12a_afbcd_reset(struct meson_drm *priv) +{ + writel_relaxed(VIU_SW_RESET_G12A_AFBC_ARB | + VIU_SW_RESET_G12A_OSD1_AFBCD, + priv->io_base + _REG(VIU_SW_RESET)); + writel_relaxed(0, priv->io_base + _REG(VIU_SW_RESET)); + + return 0; +} + +static int meson_g12a_afbcd_enable(struct meson_drm *priv) +{ + writel_relaxed(VPU_MAFBC_IRQ_SURFACES_COMPLETED | + VPU_MAFBC_IRQ_CONFIGURATION_SWAPPED | + VPU_MAFBC_IRQ_DECODE_ERROR | + VPU_MAFBC_IRQ_DETILING_ERROR, + priv->io_base + _REG(VPU_MAFBC_IRQ_MASK)); + + writel_bits_relaxed(VPU_MAFBC_S0_ENABLE, VPU_MAFBC_S0_ENABLE, + priv->io_base + _REG(VPU_MAFBC_SURFACE_CFG)); + + writel_relaxed(VPU_MAFBC_DIRECT_SWAP, + priv->io_base + _REG(VPU_MAFBC_COMMAND)); + + return 0; +} + +static int meson_g12a_afbcd_disable(struct meson_drm *priv) +{ + writel_bits_relaxed(VPU_MAFBC_S0_ENABLE, 0, + priv->io_base + _REG(VPU_MAFBC_SURFACE_CFG)); + + return 0; +} + +static int meson_g12a_afbcd_setup(struct meson_drm *priv) +{ + u32 format = meson_g12a_afbcd_pixel_fmt(priv->afbcd.modifier, + priv->afbcd.format); + + if (priv->afbcd.modifier & AFBC_FORMAT_MOD_YTR) + format |= VPU_MAFBC_YUV_TRANSFORM; + + if (priv->afbcd.modifier & AFBC_FORMAT_MOD_SPLIT) + format |= VPU_MAFBC_BLOCK_SPLIT; + + if (priv->afbcd.modifier & AFBC_FORMAT_MOD_TILED) + format |= VPU_MAFBC_TILED_HEADER_EN; + + if ((priv->afbcd.modifier & AFBC_FORMAT_MOD_BLOCK_SIZE_MASK) == + AFBC_FORMAT_MOD_BLOCK_SIZE_32x8) + format |= FIELD_PREP(VPU_MAFBC_SUPER_BLOCK_ASPECT, 1); + + writel_relaxed(format, + priv->io_base + _REG(VPU_MAFBC_FORMAT_SPECIFIER_S0)); + + writel_relaxed(priv->viu.osd1_addr, + priv->io_base + _REG(VPU_MAFBC_HEADER_BUF_ADDR_LOW_S0)); + writel_relaxed(0, + priv->io_base + _REG(VPU_MAFBC_HEADER_BUF_ADDR_HIGH_S0)); + + writel_relaxed(priv->viu.osd1_width, + priv->io_base + _REG(VPU_MAFBC_BUFFER_WIDTH_S0)); + writel_relaxed(ALIGN(priv->viu.osd1_height, 32), + priv->io_base + _REG(VPU_MAFBC_BUFFER_HEIGHT_S0)); + + writel_relaxed(0, + priv->io_base + _REG(VPU_MAFBC_BOUNDING_BOX_X_START_S0)); + writel_relaxed(priv->viu.osd1_width - 1, + priv->io_base + _REG(VPU_MAFBC_BOUNDING_BOX_X_END_S0)); + writel_relaxed(0, + priv->io_base + _REG(VPU_MAFBC_BOUNDING_BOX_Y_START_S0)); + writel_relaxed(priv->viu.osd1_height - 1, + priv->io_base + _REG(VPU_MAFBC_BOUNDING_BOX_Y_END_S0)); + + writel_relaxed(MESON_G12A_AFBCD_OUT_ADDR, + priv->io_base + _REG(VPU_MAFBC_OUTPUT_BUF_ADDR_LOW_S0)); + writel_relaxed(0, + priv->io_base + _REG(VPU_MAFBC_OUTPUT_BUF_ADDR_HIGH_S0)); + + writel_relaxed(priv->viu.osd1_width * + (meson_g12a_afbcd_bpp(priv->afbcd.format) / 8), + priv->io_base + _REG(VPU_MAFBC_OUTPUT_BUF_STRIDE_S0)); + + return 0; +} + +struct meson_afbcd_ops meson_afbcd_g12a_ops = { + .init = meson_g12a_afbcd_init, + .reset = meson_g12a_afbcd_reset, + .enable = meson_g12a_afbcd_enable, + .disable = meson_g12a_afbcd_disable, + .setup = meson_g12a_afbcd_setup, + .fmt_to_blk_mode = meson_g12a_afbcd_fmt_to_blk_mode, + .supported_fmt = meson_g12a_afbcd_supported_fmt, +}; diff --git a/drivers/gpu/drm/meson/meson_osd_afbcd.h b/drivers/gpu/drm/meson/meson_osd_afbcd.h new file mode 100644 index 000000000000..5e5523304f42 --- /dev/null +++ b/drivers/gpu/drm/meson/meson_osd_afbcd.h @@ -0,0 +1,28 @@ +/* SPDX-License-Identifier: GPL-2.0+ */ +/* + * Copyright (C) 2019 BayLibre, SAS + * Author: Neil Armstrong + */ + +#ifndef __MESON_OSD_AFBCD_H +#define __MESON_OSD_AFBCD_H + +#include "meson_drv.h" + +/* This is an internal address used to transfer pixel from AFBC to the VIU */ +#define MESON_G12A_AFBCD_OUT_ADDR 0x1000000 + +struct meson_afbcd_ops { + int (*init)(struct meson_drm *priv); + int (*reset)(struct meson_drm *priv); + int (*enable)(struct meson_drm *priv); + int (*disable)(struct meson_drm *priv); + int (*setup)(struct meson_drm *priv); + int (*fmt_to_blk_mode)(u64 modifier, uint32_t format); + bool (*supported_fmt)(u64 modifier, uint32_t format); +}; + +extern struct meson_afbcd_ops meson_afbcd_gxm_ops; +extern struct meson_afbcd_ops meson_afbcd_g12a_ops; + +#endif /* __MESON_OSD_AFBCD_H */ -- 2.22.0 _______________________________________________ linux-amlogic mailing list linux-amlogic@lists.infradead.org http://lists.infradead.org/mailman/listinfo/linux-amlogic