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=-7.0 required=3.0 tests=DKIMWL_WL_MED,DKIM_SIGNED, DKIM_VALID,HEADER_FROM_DIFFERENT_DOMAINS,INCLUDES_PATCH,MAILING_LIST_MULTI, SIGNED_OFF_BY,SPF_PASS,URIBL_BLOCKED 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 50F5EC04EBF for ; Mon, 3 Dec 2018 11:32:11 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [209.132.180.67]) by mail.kernel.org (Postfix) with ESMTP id E863220834 for ; Mon, 3 Dec 2018 11:32:10 +0000 (UTC) Authentication-Results: mail.kernel.org; dkim=pass (1024-bit key) header.d=armh.onmicrosoft.com header.i=@armh.onmicrosoft.com header.b="Hy5EBx9W" DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org E863220834 Authentication-Results: mail.kernel.org; dmarc=none (p=none dis=none) header.from=arm.com Authentication-Results: mail.kernel.org; spf=none smtp.mailfrom=linux-kernel-owner@vger.kernel.org Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1726438AbeLCLcs (ORCPT ); Mon, 3 Dec 2018 06:32:48 -0500 Received: from mail-eopbgr20042.outbound.protection.outlook.com ([40.107.2.42]:52592 "EHLO EUR02-VE1-obe.outbound.protection.outlook.com" rhost-flags-OK-OK-OK-FAIL) by vger.kernel.org with ESMTP id S1726386AbeLCLcr (ORCPT ); Mon, 3 Dec 2018 06:32:47 -0500 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=armh.onmicrosoft.com; s=selector1-arm-com; h=From:Date:Subject:Message-ID:Content-Type:MIME-Version:X-MS-Exchange-SenderADCheck; bh=t5r1W7iov3F9c3G5jDOOBXKH3YiWag1PuAl4bxyyQp4=; b=Hy5EBx9WABbmsJS+JV+jT2ScleMYl2mBkshLRl1B/sXG21UyQ2KcEoCkC0yABQEQWzom4k9WzIZqWxXQd5jaUO3AWe2elBgegpyQU2IHlLVy139iF1CX9SlR1axmFom89meFceWFpEuOcORiigqtsoYxP+aQdCNjFVdv4tFL58M= Received: from AM0PR08MB3891.eurprd08.prod.outlook.com (20.178.82.147) by AM0PR08MB3491.eurprd08.prod.outlook.com (20.177.108.222) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id 15.20.1382.18; Mon, 3 Dec 2018 11:31:58 +0000 Received: from AM0PR08MB3891.eurprd08.prod.outlook.com ([fe80::896a:710:2a8c:e2fa]) by AM0PR08MB3891.eurprd08.prod.outlook.com ([fe80::896a:710:2a8c:e2fa%6]) with mapi id 15.20.1382.020; Mon, 3 Dec 2018 11:31:58 +0000 From: Ayan Halder To: Ayan Halder , Liviu Dudau , Brian Starkey , "malidp@foss.arm.com" , "airlied@linux.ie" , "dri-devel@lists.freedesktop.org" , "linux-kernel@vger.kernel.org" , "maxime.ripard@bootlin.com" , "sean@poorly.run" , "maarten.lankhorst@linux.intel.com" , "corbet@lwn.net" , "mchehab+samsung@kernel.org" , "gregkh@linuxfoundation.org" , "davem@davemloft.net" , "akpm@linux-foundation.org" , "nicolas.ferre@microchip.com" , "arnd@arndb.de" , "linux-doc@vger.kernel.org" CC: nd Subject: [RFC v3 AFBC 04/12] drm/arm/malidp: Set the AFBC register bits if the framebuffer has AFBC modifier Thread-Topic: [RFC v3 AFBC 04/12] drm/arm/malidp: Set the AFBC register bits if the framebuffer has AFBC modifier Thread-Index: AQHUivvNe+KfFyADaUyOk+ZKPgY96g== Date: Mon, 3 Dec 2018 11:31:58 +0000 Message-ID: <1543836703-8491-5-git-send-email-ayan.halder@arm.com> References: <1543836703-8491-1-git-send-email-ayan.halder@arm.com> In-Reply-To: <1543836703-8491-1-git-send-email-ayan.halder@arm.com> Accept-Language: en-US Content-Language: en-US X-MS-Has-Attach: X-MS-TNEF-Correlator: x-clientproxiedby: LO2P265CA0279.GBRP265.PROD.OUTLOOK.COM (2603:10a6:600:a1::27) To AM0PR08MB3891.eurprd08.prod.outlook.com (2603:10a6:208:109::19) authentication-results: spf=none (sender IP is ) smtp.mailfrom=Ayan.Halder@arm.com; x-ms-exchange-messagesentrepresentingtype: 1 x-originating-ip: [217.140.106.55] x-ms-publictraffictype: Email x-microsoft-exchange-diagnostics: 1;AM0PR08MB3491;6:/4iIGJ889C8iKDGTqoZbKVVe1+guMx8fT/Pe72XpGPBSbRuzVUlCthJnDiwtKyqRoNARP2mWn7rkUw1yEx6/gArHapqUcUoqv7t8bEgJ8Q1LrKFFuJk46MnK0ZOMFvZsf/okn/Z7PWAgWgJUylWQRvx6TsEBBkcKLU6eCAObTHgwtTtufpi3xo6/wYMJwK+9fEeMTrGf6LF8pGUKA9M1rn3XiWXNy6Ovh/ruZcB2dcoy+pzhP9nc0eanXRzqZVenrrfXkXjyztsZWEjTprzN4ktjzzYEfCGQzH6LPsh/sdAsCMvTtVbJbggooZeGOmgPXSzBk3XMVl87N5zaxjR29bjYU3yutufGwqXDVngn6vZY7oMTiYoU1joMsCR3UbsBXO3BQwr6FjP+KDI/PuYQ9Dd4okLl6neyZdGC4u4j/FhyBlBmVRhiHuONlVGS8O2dVjuJCE04GO6wy1GQL8jEkg==;5:LzGEhk77a0HpQpH7wbG25XhRnwXVTho2MMraHr9F59K584yDXBwWbgwsW+TOyhFpvuxPdmrQxYeJjgwGaMIr96uikIfI7OPNv3eJApNJz9EFbqeSZ6Ap8fuN8UvBeBZhuUhxlVXzNrIc10WKRbiQlCKHYBSLUo5ovwFG9LC2LzM=;7:RMwgNyNetXdgj9ZrU6gc1ERcDW77dTsISJMNh9ecmXTi5KSXXLIDO2ACHPkjIX4EVWZxIHPXxffXVzC53F5vUtCR08owlnt3yCDeAXb4QflsOCbw2UR4j1mESdJHjpL6r5LnVGd+trdzO7mTG/S7xA== x-ms-office365-filtering-correlation-id: 485703a2-e8d3-42bb-53e3-08d65912ef90 x-ms-office365-filtering-ht: Tenant x-microsoft-antispam: BCL:0;PCL:0;RULEID:(2390098)(7020095)(4652040)(8989299)(5600074)(711020)(4618075)(4534185)(4627221)(201703031133081)(201702281549075)(8990200)(2017052603328)(7153060)(7193020);SRVR:AM0PR08MB3491; x-ms-traffictypediagnostic: AM0PR08MB3491: nodisclaimer: True x-microsoft-antispam-prvs: x-ms-exchange-senderadcheck: 1 x-exchange-antispam-report-cfa-test: BCL:0;PCL:0;RULEID:(8211001083)(6040522)(2401047)(8121501046)(5005006)(3002001)(10201501046)(3231455)(999002)(944501493)(52105112)(93006095)(93001095)(6055026)(148016)(149066)(150057)(6041310)(201703131423095)(201702281528075)(20161123555045)(201703061421075)(201703061406153)(20161123560045)(20161123564045)(20161123562045)(20161123558120)(201708071742011)(7699051)(76991095);SRVR:AM0PR08MB3491;BCL:0;PCL:0;RULEID:;SRVR:AM0PR08MB3491; x-forefront-prvs: 08756AC3C8 x-forefront-antispam-report: SFV:NSPM;SFS:(10009020)(396003)(39860400002)(376002)(136003)(346002)(366004)(199004)(189003)(99286004)(4326008)(71190400001)(97736004)(36756003)(4744004)(71200400001)(106356001)(6486002)(68736007)(72206003)(256004)(14454004)(66066001)(478600001)(7416002)(5660300001)(45080400002)(81166006)(8936002)(7736002)(25786009)(2201001)(81156014)(305945005)(3846002)(6116002)(26005)(102836004)(316002)(186003)(6436002)(11346002)(486006)(2906002)(2501003)(8676002)(14444005)(575784001)(2616005)(44832011)(476003)(6512007)(105586002)(53936002)(52116002)(446003)(386003)(6506007)(86362001)(110136005)(76176011)(921003)(1121003);DIR:OUT;SFP:1101;SCL:1;SRVR:AM0PR08MB3491;H:AM0PR08MB3891.eurprd08.prod.outlook.com;FPR:;SPF:None;LANG:en;PTR:InfoNoRecords;A:1;MX:1; received-spf: None (protection.outlook.com: arm.com does not designate permitted sender hosts) x-microsoft-antispam-message-info: 8uUoIMBsJEOLHbjF/QcCi7xdahh+Kb3wAeoNpKsbzK9bzDn7S3qBK0IN79DSSXDgKwVt4sFZNftXHyw3gY3cmrijfPf50sAoMTO+QucC+FsgLGXPg4HXISwwRIxeYquRg1JAM6nWepffLDvm6KqFhJWoUIZtX1306//nuYEWw9Kuwaey7yo5gyv5ZKleqAuPcgTp5g53DPTv/vwo4CZUmWqBpY9klAbcgrn2K8RlkcVsAe8PiHMkbaFwvCmGdglOfasNVHDzE7HxIJ53L/11oqiPcy+81C9dneqe2QIQcuo8Snnf6lUqRqljwyJhSrJDs6Pb0kOOiOvFSdN5whmjEWZOoSHIXAvhv9PfHnqebhY= spamdiagnosticoutput: 1:99 spamdiagnosticmetadata: NSPM Content-Type: text/plain; charset="iso-8859-1" Content-Transfer-Encoding: quoted-printable MIME-Version: 1.0 X-OriginatorOrg: arm.com X-MS-Exchange-CrossTenant-Network-Message-Id: 485703a2-e8d3-42bb-53e3-08d65912ef90 X-MS-Exchange-CrossTenant-originalarrivaltime: 03 Dec 2018 11:31:58.4511 (UTC) X-MS-Exchange-CrossTenant-fromentityheader: Hosted X-MS-Exchange-CrossTenant-id: f34e5979-57d9-4aaa-ad4d-b122a662184d X-MS-Exchange-Transport-CrossTenantHeadersStamped: AM0PR08MB3491 Sender: linux-kernel-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org Added the AFBC decoder registers for DP500 , DP550 and DP650. These registers control the processing of AFBC buffers. It controls various features like AFBC decoder enable, lossless transformation and block split as well as setting of the left, right, top and bottom cropping of AFBC buff= ers (in number of pixels). All the layers (except DE_SMART) support framebuffers with AFBC modifiers. One needs to set the pixel values of the top, left, bottom and right croppi= ng for the AFBC framebuffer. Cropping an AFBC framebuffer is controlled by the AFBC crop registers. In that case, the layer input size registers should be configured with framebuffer's dimensions and not with drm_plane_state source width/height values (which is used for non AFBC framebuffer to denote cropping). Changes from v1: - Removed the "if (fb->modifier)" check from malidp_de_plane_update() and added it in malidp_de_set_plane_afbc(). This will consolidate all the AFBC specific register configurations in a single function ie malidp_de_set_plane_afbc(). Changes from v2: - For AFBC framebuffer, layer input size register should be set to framebu= ffer's width and height Signed-off-by: Ayan Kumar Halder --- drivers/gpu/drm/arm/malidp_hw.c | 25 +++++---- drivers/gpu/drm/arm/malidp_hw.h | 2 + drivers/gpu/drm/arm/malidp_planes.c | 109 +++++++++++++++++++++++++++++++-= ---- drivers/gpu/drm/arm/malidp_regs.h | 20 +++++++ 4 files changed, 130 insertions(+), 26 deletions(-) diff --git a/drivers/gpu/drm/arm/malidp_hw.c b/drivers/gpu/drm/arm/malidp_h= w.c index b9bed11..87b7b12 100644 --- a/drivers/gpu/drm/arm/malidp_hw.c +++ b/drivers/gpu/drm/arm/malidp_hw.c @@ -94,11 +94,12 @@ static const struct malidp_layer malidp500_layers[] =3D= { * yuv2rgb matrix offset, mmu control register offset, rotation_features */ { DE_VIDEO1, MALIDP500_DE_LV_BASE, MALIDP500_DE_LV_PTR_BASE, - MALIDP_DE_LV_STRIDE0, MALIDP500_LV_YUV2RGB, 0, ROTATE_ANY }, + MALIDP_DE_LV_STRIDE0, MALIDP500_LV_YUV2RGB, 0, ROTATE_ANY, + MALIDP500_DE_LV_AD_CTRL }, { DE_GRAPHICS1, MALIDP500_DE_LG1_BASE, MALIDP500_DE_LG1_PTR_BASE, - MALIDP_DE_LG_STRIDE, 0, 0, ROTATE_ANY }, + MALIDP_DE_LG_STRIDE, 0, 0, ROTATE_ANY, MALIDP500_DE_LG1_AD_CTRL }, { DE_GRAPHICS2, MALIDP500_DE_LG2_BASE, MALIDP500_DE_LG2_PTR_BASE, - MALIDP_DE_LG_STRIDE, 0, 0, ROTATE_ANY }, + MALIDP_DE_LG_STRIDE, 0, 0, ROTATE_ANY, MALIDP500_DE_LG2_AD_CTRL }, }; =20 static const struct malidp_layer malidp550_layers[] =3D { @@ -106,13 +107,15 @@ static const struct malidp_layer malidp550_layers[] = =3D { * yuv2rgb matrix offset, mmu control register offset, rotation_features */ { DE_VIDEO1, MALIDP550_DE_LV1_BASE, MALIDP550_DE_LV1_PTR_BASE, - MALIDP_DE_LV_STRIDE0, MALIDP550_LV_YUV2RGB, 0, ROTATE_ANY }, + MALIDP_DE_LV_STRIDE0, MALIDP550_LV_YUV2RGB, 0, ROTATE_ANY, + MALIDP550_DE_LV1_AD_CTRL }, { DE_GRAPHICS1, MALIDP550_DE_LG_BASE, MALIDP550_DE_LG_PTR_BASE, - MALIDP_DE_LG_STRIDE, 0, 0, ROTATE_ANY }, + MALIDP_DE_LG_STRIDE, 0, 0, ROTATE_ANY, MALIDP550_DE_LG_AD_CTRL }, { DE_VIDEO2, MALIDP550_DE_LV2_BASE, MALIDP550_DE_LV2_PTR_BASE, - MALIDP_DE_LV_STRIDE0, MALIDP550_LV_YUV2RGB, 0, ROTATE_ANY }, + MALIDP_DE_LV_STRIDE0, MALIDP550_LV_YUV2RGB, 0, ROTATE_ANY, + MALIDP550_DE_LV2_AD_CTRL }, { DE_SMART, MALIDP550_DE_LS_BASE, MALIDP550_DE_LS_PTR_BASE, - MALIDP550_DE_LS_R1_STRIDE, 0, 0, ROTATE_NONE }, + MALIDP550_DE_LS_R1_STRIDE, 0, 0, ROTATE_NONE, 0 }, }; =20 static const struct malidp_layer malidp650_layers[] =3D { @@ -122,16 +125,16 @@ static const struct malidp_layer malidp650_layers[] = =3D { */ { DE_VIDEO1, MALIDP550_DE_LV1_BASE, MALIDP550_DE_LV1_PTR_BASE, MALIDP_DE_LV_STRIDE0, MALIDP550_LV_YUV2RGB, - MALIDP650_DE_LV_MMU_CTRL, ROTATE_ANY }, + MALIDP650_DE_LV_MMU_CTRL, ROTATE_ANY, MALIDP550_DE_LV1_AD_CTRL }, { DE_GRAPHICS1, MALIDP550_DE_LG_BASE, MALIDP550_DE_LG_PTR_BASE, MALIDP_DE_LG_STRIDE, 0, MALIDP650_DE_LG_MMU_CTRL, - ROTATE_COMPRESSED }, + ROTATE_COMPRESSED, MALIDP550_DE_LG_AD_CTRL }, { DE_VIDEO2, MALIDP550_DE_LV2_BASE, MALIDP550_DE_LV2_PTR_BASE, MALIDP_DE_LV_STRIDE0, MALIDP550_LV_YUV2RGB, - MALIDP650_DE_LV_MMU_CTRL, ROTATE_ANY }, + MALIDP650_DE_LV_MMU_CTRL, ROTATE_ANY, MALIDP550_DE_LV2_AD_CTRL }, { DE_SMART, MALIDP550_DE_LS_BASE, MALIDP550_DE_LS_PTR_BASE, MALIDP550_DE_LS_R1_STRIDE, 0, MALIDP650_DE_LS_MMU_CTRL, - ROTATE_NONE }, + ROTATE_NONE, 0 }, }; =20 #define SE_N_SCALING_COEFFS 96 diff --git a/drivers/gpu/drm/arm/malidp_hw.h b/drivers/gpu/drm/arm/malidp_h= w.h index 40155e2..651558f 100644 --- a/drivers/gpu/drm/arm/malidp_hw.h +++ b/drivers/gpu/drm/arm/malidp_hw.h @@ -70,6 +70,8 @@ struct malidp_layer { s16 yuv2rgb_offset; /* offset to the YUV->RGB matrix entries */ u16 mmu_ctrl_offset; /* offset to the MMU control register */ enum rotation_features rot; /* type of rotation supported */ + /* address offset for the AFBC decoder registers */ + u16 afbc_decoder_offset; }; =20 enum malidp_scaling_coeff_set { diff --git a/drivers/gpu/drm/arm/malidp_planes.c b/drivers/gpu/drm/arm/mali= dp_planes.c index c9a6d3e..cd60f73 100644 --- a/drivers/gpu/drm/arm/malidp_planes.c +++ b/drivers/gpu/drm/arm/malidp_planes.c @@ -592,6 +592,80 @@ static void malidp_de_set_mmu_control(struct malidp_pl= ane *mp, mp->layer->base + mp->layer->mmu_ctrl_offset); } =20 +static void malidp_set_plane_base_addr(struct drm_framebuffer *fb, + struct malidp_plane *mp, + int plane_index) +{ + dma_addr_t paddr; + u16 ptr; + struct drm_plane *plane =3D &mp->base; + bool afbc =3D fb->modifier ? true : false; + + ptr =3D mp->layer->ptr + (plane_index << 4); + + /* + * For AFBC buffers, cropping is handled by AFBC decoder rather than + * pointer manipulation. + */ + if (!afbc) { + paddr =3D drm_fb_cma_get_gem_addr(fb, plane->state, + plane_index); + } else { + struct drm_gem_cma_object *obj; + + obj =3D drm_fb_cma_get_gem_obj(fb, plane_index); + + if (WARN_ON(!obj)) + return; + paddr =3D obj->paddr; + } + + malidp_hw_write(mp->hwdev, lower_32_bits(paddr), ptr); + malidp_hw_write(mp->hwdev, upper_32_bits(paddr), ptr + 4); +} + +static void malidp_de_set_plane_afbc(struct drm_plane *plane) +{ + struct malidp_plane *mp; + u32 src_w, src_h, val =3D 0, src_x, src_y; + struct drm_framebuffer *fb =3D plane->state->fb; + + mp =3D to_malidp_plane(plane); + + /* no afbc_decoder_offset means AFBC is not supported on this plane */ + if (!mp->layer->afbc_decoder_offset) + return; + + if (!fb->modifier) { + malidp_hw_write(mp->hwdev, 0, mp->layer->afbc_decoder_offset); + return; + } + + /* convert src values from Q16 fixed point to integer */ + src_w =3D plane->state->src_w >> 16; + src_h =3D plane->state->src_h >> 16; + src_x =3D plane->state->src_x >> 16; + src_y =3D plane->state->src_y >> 16; + + val =3D ((fb->width - (src_x + src_w)) << MALIDP_AD_CROP_RIGHT_OFFSET) | + src_x; + malidp_hw_write(mp->hwdev, val, + mp->layer->afbc_decoder_offset + MALIDP_AD_CROP_H); + + val =3D ((fb->height - (src_y + src_h)) << MALIDP_AD_CROP_BOTTOM_OFFSET) = | + src_y; + malidp_hw_write(mp->hwdev, val, + mp->layer->afbc_decoder_offset + MALIDP_AD_CROP_V); + + val =3D MALIDP_AD_EN; + if (fb->modifier & AFBC_FORMAT_MOD_SPLIT) + val |=3D MALIDP_AD_BS; + if (fb->modifier & AFBC_FORMAT_MOD_YTR) + val |=3D MALIDP_AD_YTR; + + malidp_hw_write(mp->hwdev, val, mp->layer->afbc_decoder_offset); +} + static void malidp_de_plane_update(struct drm_plane *plane, struct drm_plane_state *old_state) { @@ -600,30 +674,33 @@ static void malidp_de_plane_update(struct drm_plane *= plane, struct drm_plane_state *state =3D plane->state; u16 pixel_alpha =3D state->pixel_blend_mode; u8 plane_alpha =3D state->alpha >> 8; + bool format_has_alpha =3D state->fb->format->has_alpha; u32 src_w, src_h, dest_w, dest_h, val; int i; + struct drm_framebuffer *fb =3D plane->state->fb; =20 mp =3D to_malidp_plane(plane); =20 - /* convert src values from Q16 fixed point to integer */ - src_w =3D state->src_w >> 16; - src_h =3D state->src_h >> 16; - dest_w =3D state->crtc_w; - dest_h =3D state->crtc_h; + /* For AFBC framebuffer, use the framebuffer width and height for configu= ring + * layer input size register. + */ + if (fb->modifier) { + src_w =3D fb->width; + src_h =3D fb->height; + } else { + /* convert src values from Q16 fixed point to integer */ + src_w =3D ms->base.src_w >> 16; + src_h =3D ms->base.src_h >> 16; + } + dest_w =3D ms->base.crtc_w; + dest_h =3D ms->base.crtc_h; =20 val =3D malidp_hw_read(mp->hwdev, mp->layer->base); val =3D (val & ~LAYER_FORMAT_MASK) | ms->format; malidp_hw_write(mp->hwdev, val, mp->layer->base); =20 - for (i =3D 0; i < ms->n_planes; i++) { - /* calculate the offset for the layer's plane registers */ - u16 ptr =3D mp->layer->ptr + (i << 4); - dma_addr_t fb_addr =3D drm_fb_cma_get_gem_addr(state->fb, - state, i); - - malidp_hw_write(mp->hwdev, lower_32_bits(fb_addr), ptr); - malidp_hw_write(mp->hwdev, upper_32_bits(fb_addr), ptr + 4); - } + for (i =3D 0; i < ms->n_planes; i++) + malidp_set_plane_base_addr(fb, mp, i); =20 malidp_de_set_mmu_control(mp, ms); =20 @@ -657,6 +734,8 @@ static void malidp_de_plane_update(struct drm_plane *pl= ane, mp->layer->base + MALIDP550_LS_R1_IN_SIZE); } =20 + malidp_de_set_plane_afbc(plane); + /* first clear the rotation bits */ val =3D malidp_hw_read(mp->hwdev, mp->layer->base + MALIDP_LAYER_CONTROL)= ; val &=3D ~LAYER_ROT_MASK; @@ -674,7 +753,7 @@ static void malidp_de_plane_update(struct drm_plane *pl= ane, =20 if (state->alpha !=3D DRM_BLEND_ALPHA_OPAQUE) { val |=3D LAYER_COMP_PLANE; - } else if (state->fb->format->has_alpha) { + } else if (format_has_alpha) { /* We only care about blend mode if the format has alpha */ switch (pixel_alpha) { case DRM_MODE_BLEND_PREMULTI: diff --git a/drivers/gpu/drm/arm/malidp_regs.h b/drivers/gpu/drm/arm/malidp= _regs.h index 7ce3e14..a0dd6e1 100644 --- a/drivers/gpu/drm/arm/malidp_regs.h +++ b/drivers/gpu/drm/arm/malidp_regs.h @@ -198,10 +198,13 @@ #define MALIDP500_LV_YUV2RGB ((s16)(-0xB8)) #define MALIDP500_DE_LV_BASE 0x00100 #define MALIDP500_DE_LV_PTR_BASE 0x00124 +#define MALIDP500_DE_LV_AD_CTRL 0x00400 #define MALIDP500_DE_LG1_BASE 0x00200 #define MALIDP500_DE_LG1_PTR_BASE 0x0021c +#define MALIDP500_DE_LG1_AD_CTRL 0x0040c #define MALIDP500_DE_LG2_BASE 0x00300 #define MALIDP500_DE_LG2_PTR_BASE 0x0031c +#define MALIDP500_DE_LG2_AD_CTRL 0x00418 #define MALIDP500_SE_BASE 0x00c00 #define MALIDP500_SE_CONTROL 0x00c0c #define MALIDP500_SE_MEMWRITE_OUT_SIZE 0x00c2c @@ -228,10 +231,13 @@ #define MALIDP550_LV_YUV2RGB 0x00084 #define MALIDP550_DE_LV1_BASE 0x00100 #define MALIDP550_DE_LV1_PTR_BASE 0x00124 +#define MALIDP550_DE_LV1_AD_CTRL 0x001B8 #define MALIDP550_DE_LV2_BASE 0x00200 #define MALIDP550_DE_LV2_PTR_BASE 0x00224 +#define MALIDP550_DE_LV2_AD_CTRL 0x002B8 #define MALIDP550_DE_LG_BASE 0x00300 #define MALIDP550_DE_LG_PTR_BASE 0x0031c +#define MALIDP550_DE_LG_AD_CTRL 0x00330 #define MALIDP550_DE_LS_BASE 0x00400 #define MALIDP550_DE_LS_PTR_BASE 0x0042c #define MALIDP550_DE_PERF_BASE 0x00500 @@ -258,6 +264,20 @@ #define MALIDP_MMU_CTRL_PX_PS(x) (1 << (8 + (x))) #define MALIDP_MMU_CTRL_PP_NUM_REQ(x) (((x) & 0x7f) << 12) =20 +/* AFBC register offsets relative to MALIDPXXX_DE_LX_AD_CTRL */ +/* The following register offsets are common for DP500, DP550 and DP650 */ +#define MALIDP_AD_CROP_H 0x4 +#define MALIDP_AD_CROP_V 0x8 +#define MALIDP_AD_END_PTR_LOW 0xc +#define MALIDP_AD_END_PTR_HIGH 0x10 + +/* AFBC decoder Registers */ +#define MALIDP_AD_EN BIT(0) +#define MALIDP_AD_YTR BIT(4) +#define MALIDP_AD_BS BIT(8) +#define MALIDP_AD_CROP_RIGHT_OFFSET 16 +#define MALIDP_AD_CROP_BOTTOM_OFFSET 16 + /* * Starting with DP550 the register map blocks has been standardised to th= e * following layout: --=20 2.7.4 From mboxrd@z Thu Jan 1 00:00:00 1970 From: Ayan Halder Subject: [RFC v3 AFBC 04/12] drm/arm/malidp: Set the AFBC register bits if the framebuffer has AFBC modifier Date: Mon, 3 Dec 2018 11:31:58 +0000 Message-ID: <1543836703-8491-5-git-send-email-ayan.halder@arm.com> References: <1543836703-8491-1-git-send-email-ayan.halder@arm.com> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Return-path: Received: from EUR02-VE1-obe.outbound.protection.outlook.com (mail-eopbgr20083.outbound.protection.outlook.com [40.107.2.83]) by gabe.freedesktop.org (Postfix) with ESMTPS id 9341889CE3 for ; Mon, 3 Dec 2018 11:32:00 +0000 (UTC) In-Reply-To: <1543836703-8491-1-git-send-email-ayan.halder@arm.com> Content-Language: en-US List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: dri-devel-bounces@lists.freedesktop.org Sender: "dri-devel" To: Ayan Halder , Liviu Dudau , Brian Starkey , "malidp@foss.arm.com" , "airlied@linux.ie" , "dri-devel@lists.freedesktop.org" , "linux-kernel@vger.kernel.org" , "maxime.ripard@bootlin.com" , "sean@poorly.run" , "maarten.lankhorst@linux.intel.com" , "corbet@lwn.net" , "mchehab+samsung@kernel.org" , "gregkh@linuxfoundation.org" , "davem@davemloft.net" , "akpm@linux-foundation.org" , "nicolas.ferre@microchip.com" , "arnd@arndb.de" , "linux-doc@vger.kernel.org" Cc: nd List-Id: dri-devel@lists.freedesktop.org QWRkZWQgdGhlIEFGQkMgZGVjb2RlciByZWdpc3RlcnMgZm9yIERQNTAwICwgRFA1NTAgYW5kIERQ NjUwLgpUaGVzZSByZWdpc3RlcnMgY29udHJvbCB0aGUgcHJvY2Vzc2luZyBvZiBBRkJDIGJ1ZmZl cnMuIEl0IGNvbnRyb2xzIHZhcmlvdXMKZmVhdHVyZXMgbGlrZSBBRkJDIGRlY29kZXIgZW5hYmxl LCBsb3NzbGVzcyB0cmFuc2Zvcm1hdGlvbiBhbmQgYmxvY2sgc3BsaXQKYXMgd2VsbCBhcyBzZXR0 aW5nIG9mIHRoZSBsZWZ0LCByaWdodCwgdG9wIGFuZCBib3R0b20gY3JvcHBpbmcgb2YgQUZCQyBi dWZmZXJzCihpbiBudW1iZXIgb2YgcGl4ZWxzKS4KQWxsIHRoZSBsYXllcnMgKGV4Y2VwdCBERV9T TUFSVCkgc3VwcG9ydCBmcmFtZWJ1ZmZlcnMgd2l0aCBBRkJDIG1vZGlmaWVycy4KT25lIG5lZWRz IHRvIHNldCB0aGUgcGl4ZWwgdmFsdWVzIG9mIHRoZSB0b3AsIGxlZnQsIGJvdHRvbSBhbmQgcmln aHQgY3JvcHBpbmcKZm9yIHRoZSBBRkJDIGZyYW1lYnVmZmVyLgpDcm9wcGluZyBhbiBBRkJDIGZy YW1lYnVmZmVyIGlzIGNvbnRyb2xsZWQgYnkgdGhlIEFGQkMgY3JvcCByZWdpc3RlcnMuCkluIHRo YXQgY2FzZSwgdGhlIGxheWVyIGlucHV0IHNpemUgcmVnaXN0ZXJzIHNob3VsZCBiZSBjb25maWd1 cmVkIHdpdGgKZnJhbWVidWZmZXIncyBkaW1lbnNpb25zIGFuZCBub3Qgd2l0aCBkcm1fcGxhbmVf c3RhdGUgc291cmNlIHdpZHRoL2hlaWdodAp2YWx1ZXMgKHdoaWNoIGlzIHVzZWQgZm9yIG5vbiBB RkJDIGZyYW1lYnVmZmVyIHRvIGRlbm90ZSBjcm9wcGluZykuCgpDaGFuZ2VzIGZyb20gdjE6CiAt IFJlbW92ZWQgdGhlICJpZiAoZmItPm1vZGlmaWVyKSIgY2hlY2sgZnJvbSBtYWxpZHBfZGVfcGxh bmVfdXBkYXRlKCkKYW5kIGFkZGVkIGl0IGluIG1hbGlkcF9kZV9zZXRfcGxhbmVfYWZiYygpLiBU aGlzIHdpbGwgY29uc29saWRhdGUgYWxsIHRoZQpBRkJDIHNwZWNpZmljIHJlZ2lzdGVyIGNvbmZp Z3VyYXRpb25zIGluIGEgc2luZ2xlIGZ1bmN0aW9uIGllCm1hbGlkcF9kZV9zZXRfcGxhbmVfYWZi YygpLgoKQ2hhbmdlcyBmcm9tIHYyOgogLSBGb3IgQUZCQyBmcmFtZWJ1ZmZlciwgbGF5ZXIgaW5w dXQgc2l6ZSByZWdpc3RlciBzaG91bGQgYmUgc2V0IHRvIGZyYW1lYnVmZmVyJ3MKd2lkdGggYW5k IGhlaWdodAoKU2lnbmVkLW9mZi1ieTogQXlhbiBLdW1hciBIYWxkZXIgPGF5YW4uaGFsZGVyQGFy bS5jb20+Ci0tLQogZHJpdmVycy9ncHUvZHJtL2FybS9tYWxpZHBfaHcuYyAgICAgfCAgMjUgKysr KystLS0tCiBkcml2ZXJzL2dwdS9kcm0vYXJtL21hbGlkcF9ody5oICAgICB8ICAgMiArCiBkcml2 ZXJzL2dwdS9kcm0vYXJtL21hbGlkcF9wbGFuZXMuYyB8IDEwOSArKysrKysrKysrKysrKysrKysr KysrKysrKysrKysrLS0tLS0KIGRyaXZlcnMvZ3B1L2RybS9hcm0vbWFsaWRwX3JlZ3MuaCAgIHwg IDIwICsrKysrKysKIDQgZmlsZXMgY2hhbmdlZCwgMTMwIGluc2VydGlvbnMoKyksIDI2IGRlbGV0 aW9ucygtKQoKZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1L2RybS9hcm0vbWFsaWRwX2h3LmMgYi9k cml2ZXJzL2dwdS9kcm0vYXJtL21hbGlkcF9ody5jCmluZGV4IGI5YmVkMTEuLjg3YjdiMTIgMTAw NjQ0Ci0tLSBhL2RyaXZlcnMvZ3B1L2RybS9hcm0vbWFsaWRwX2h3LmMKKysrIGIvZHJpdmVycy9n cHUvZHJtL2FybS9tYWxpZHBfaHcuYwpAQCAtOTQsMTEgKzk0LDEyIEBAIHN0YXRpYyBjb25zdCBz dHJ1Y3QgbWFsaWRwX2xheWVyIG1hbGlkcDUwMF9sYXllcnNbXSA9IHsKIAkgKgl5dXYycmdiIG1h dHJpeCBvZmZzZXQsIG1tdSBjb250cm9sIHJlZ2lzdGVyIG9mZnNldCwgcm90YXRpb25fZmVhdHVy ZXMKIAkgKi8KIAl7IERFX1ZJREVPMSwgTUFMSURQNTAwX0RFX0xWX0JBU0UsIE1BTElEUDUwMF9E RV9MVl9QVFJfQkFTRSwKLQkJTUFMSURQX0RFX0xWX1NUUklERTAsIE1BTElEUDUwMF9MVl9ZVVYy UkdCLCAwLCBST1RBVEVfQU5ZIH0sCisJCU1BTElEUF9ERV9MVl9TVFJJREUwLCBNQUxJRFA1MDBf TFZfWVVWMlJHQiwgMCwgUk9UQVRFX0FOWSwKKwkJTUFMSURQNTAwX0RFX0xWX0FEX0NUUkwgfSwK IAl7IERFX0dSQVBISUNTMSwgTUFMSURQNTAwX0RFX0xHMV9CQVNFLCBNQUxJRFA1MDBfREVfTEcx X1BUUl9CQVNFLAotCQlNQUxJRFBfREVfTEdfU1RSSURFLCAwLCAwLCBST1RBVEVfQU5ZIH0sCisJ CU1BTElEUF9ERV9MR19TVFJJREUsIDAsIDAsIFJPVEFURV9BTlksIE1BTElEUDUwMF9ERV9MRzFf QURfQ1RSTCB9LAogCXsgREVfR1JBUEhJQ1MyLCBNQUxJRFA1MDBfREVfTEcyX0JBU0UsIE1BTElE UDUwMF9ERV9MRzJfUFRSX0JBU0UsCi0JCU1BTElEUF9ERV9MR19TVFJJREUsIDAsIDAsIFJPVEFU RV9BTlkgfSwKKwkJTUFMSURQX0RFX0xHX1NUUklERSwgMCwgMCwgUk9UQVRFX0FOWSwgTUFMSURQ NTAwX0RFX0xHMl9BRF9DVFJMIH0sCiB9OwogCiBzdGF0aWMgY29uc3Qgc3RydWN0IG1hbGlkcF9s YXllciBtYWxpZHA1NTBfbGF5ZXJzW10gPSB7CkBAIC0xMDYsMTMgKzEwNywxNSBAQCBzdGF0aWMg Y29uc3Qgc3RydWN0IG1hbGlkcF9sYXllciBtYWxpZHA1NTBfbGF5ZXJzW10gPSB7CiAJICoJeXV2 MnJnYiBtYXRyaXggb2Zmc2V0LCBtbXUgY29udHJvbCByZWdpc3RlciBvZmZzZXQsIHJvdGF0aW9u X2ZlYXR1cmVzCiAJICovCiAJeyBERV9WSURFTzEsIE1BTElEUDU1MF9ERV9MVjFfQkFTRSwgTUFM SURQNTUwX0RFX0xWMV9QVFJfQkFTRSwKLQkJTUFMSURQX0RFX0xWX1NUUklERTAsIE1BTElEUDU1 MF9MVl9ZVVYyUkdCLCAwLCBST1RBVEVfQU5ZIH0sCisJCU1BTElEUF9ERV9MVl9TVFJJREUwLCBN QUxJRFA1NTBfTFZfWVVWMlJHQiwgMCwgUk9UQVRFX0FOWSwKKwkJTUFMSURQNTUwX0RFX0xWMV9B RF9DVFJMIH0sCiAJeyBERV9HUkFQSElDUzEsIE1BTElEUDU1MF9ERV9MR19CQVNFLCBNQUxJRFA1 NTBfREVfTEdfUFRSX0JBU0UsCi0JCU1BTElEUF9ERV9MR19TVFJJREUsIDAsIDAsIFJPVEFURV9B TlkgfSwKKwkJTUFMSURQX0RFX0xHX1NUUklERSwgMCwgMCwgUk9UQVRFX0FOWSwgTUFMSURQNTUw X0RFX0xHX0FEX0NUUkwgfSwKIAl7IERFX1ZJREVPMiwgTUFMSURQNTUwX0RFX0xWMl9CQVNFLCBN QUxJRFA1NTBfREVfTFYyX1BUUl9CQVNFLAotCQlNQUxJRFBfREVfTFZfU1RSSURFMCwgTUFMSURQ NTUwX0xWX1lVVjJSR0IsIDAsIFJPVEFURV9BTlkgfSwKKwkJTUFMSURQX0RFX0xWX1NUUklERTAs IE1BTElEUDU1MF9MVl9ZVVYyUkdCLCAwLCBST1RBVEVfQU5ZLAorCQlNQUxJRFA1NTBfREVfTFYy X0FEX0NUUkwgfSwKIAl7IERFX1NNQVJULCBNQUxJRFA1NTBfREVfTFNfQkFTRSwgTUFMSURQNTUw X0RFX0xTX1BUUl9CQVNFLAotCQlNQUxJRFA1NTBfREVfTFNfUjFfU1RSSURFLCAwLCAwLCBST1RB VEVfTk9ORSB9LAorCQlNQUxJRFA1NTBfREVfTFNfUjFfU1RSSURFLCAwLCAwLCBST1RBVEVfTk9O RSwgMCB9LAogfTsKIAogc3RhdGljIGNvbnN0IHN0cnVjdCBtYWxpZHBfbGF5ZXIgbWFsaWRwNjUw X2xheWVyc1tdID0gewpAQCAtMTIyLDE2ICsxMjUsMTYgQEAgc3RhdGljIGNvbnN0IHN0cnVjdCBt YWxpZHBfbGF5ZXIgbWFsaWRwNjUwX2xheWVyc1tdID0gewogCSAqLwogCXsgREVfVklERU8xLCBN QUxJRFA1NTBfREVfTFYxX0JBU0UsIE1BTElEUDU1MF9ERV9MVjFfUFRSX0JBU0UsCiAJCU1BTElE UF9ERV9MVl9TVFJJREUwLCBNQUxJRFA1NTBfTFZfWVVWMlJHQiwKLQkJTUFMSURQNjUwX0RFX0xW X01NVV9DVFJMLCBST1RBVEVfQU5ZIH0sCisJCU1BTElEUDY1MF9ERV9MVl9NTVVfQ1RSTCwgUk9U QVRFX0FOWSwgTUFMSURQNTUwX0RFX0xWMV9BRF9DVFJMIH0sCiAJeyBERV9HUkFQSElDUzEsIE1B TElEUDU1MF9ERV9MR19CQVNFLCBNQUxJRFA1NTBfREVfTEdfUFRSX0JBU0UsCiAJCU1BTElEUF9E RV9MR19TVFJJREUsIDAsIE1BTElEUDY1MF9ERV9MR19NTVVfQ1RSTCwKLQkJUk9UQVRFX0NPTVBS RVNTRUQgfSwKKwkJUk9UQVRFX0NPTVBSRVNTRUQsIE1BTElEUDU1MF9ERV9MR19BRF9DVFJMIH0s CiAJeyBERV9WSURFTzIsIE1BTElEUDU1MF9ERV9MVjJfQkFTRSwgTUFMSURQNTUwX0RFX0xWMl9Q VFJfQkFTRSwKIAkJTUFMSURQX0RFX0xWX1NUUklERTAsIE1BTElEUDU1MF9MVl9ZVVYyUkdCLAot CQlNQUxJRFA2NTBfREVfTFZfTU1VX0NUUkwsIFJPVEFURV9BTlkgfSwKKwkJTUFMSURQNjUwX0RF X0xWX01NVV9DVFJMLCBST1RBVEVfQU5ZLCBNQUxJRFA1NTBfREVfTFYyX0FEX0NUUkwgfSwKIAl7 IERFX1NNQVJULCBNQUxJRFA1NTBfREVfTFNfQkFTRSwgTUFMSURQNTUwX0RFX0xTX1BUUl9CQVNF LAogCQlNQUxJRFA1NTBfREVfTFNfUjFfU1RSSURFLCAwLCBNQUxJRFA2NTBfREVfTFNfTU1VX0NU UkwsCi0JCVJPVEFURV9OT05FIH0sCisJCVJPVEFURV9OT05FLCAwIH0sCiB9OwogCiAjZGVmaW5l IFNFX05fU0NBTElOR19DT0VGRlMJOTYKZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1L2RybS9hcm0v bWFsaWRwX2h3LmggYi9kcml2ZXJzL2dwdS9kcm0vYXJtL21hbGlkcF9ody5oCmluZGV4IDQwMTU1 ZTIuLjY1MTU1OGYgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvZ3B1L2RybS9hcm0vbWFsaWRwX2h3LmgK KysrIGIvZHJpdmVycy9ncHUvZHJtL2FybS9tYWxpZHBfaHcuaApAQCAtNzAsNiArNzAsOCBAQCBz dHJ1Y3QgbWFsaWRwX2xheWVyIHsKIAlzMTYgeXV2MnJnYl9vZmZzZXQ7CS8qIG9mZnNldCB0byB0 aGUgWVVWLT5SR0IgbWF0cml4IGVudHJpZXMgKi8KIAl1MTYgbW11X2N0cmxfb2Zmc2V0OyAgICAv KiBvZmZzZXQgdG8gdGhlIE1NVSBjb250cm9sIHJlZ2lzdGVyICovCiAJZW51bSByb3RhdGlvbl9m ZWF0dXJlcyByb3Q7CS8qIHR5cGUgb2Ygcm90YXRpb24gc3VwcG9ydGVkICovCisJLyogYWRkcmVz cyBvZmZzZXQgZm9yIHRoZSBBRkJDIGRlY29kZXIgcmVnaXN0ZXJzICovCisJdTE2IGFmYmNfZGVj b2Rlcl9vZmZzZXQ7CiB9OwogCiBlbnVtIG1hbGlkcF9zY2FsaW5nX2NvZWZmX3NldCB7CmRpZmYg LS1naXQgYS9kcml2ZXJzL2dwdS9kcm0vYXJtL21hbGlkcF9wbGFuZXMuYyBiL2RyaXZlcnMvZ3B1 L2RybS9hcm0vbWFsaWRwX3BsYW5lcy5jCmluZGV4IGM5YTZkM2UuLmNkNjBmNzMgMTAwNjQ0Ci0t LSBhL2RyaXZlcnMvZ3B1L2RybS9hcm0vbWFsaWRwX3BsYW5lcy5jCisrKyBiL2RyaXZlcnMvZ3B1 L2RybS9hcm0vbWFsaWRwX3BsYW5lcy5jCkBAIC01OTIsNiArNTkyLDgwIEBAIHN0YXRpYyB2b2lk IG1hbGlkcF9kZV9zZXRfbW11X2NvbnRyb2woc3RydWN0IG1hbGlkcF9wbGFuZSAqbXAsCiAJCQlt cC0+bGF5ZXItPmJhc2UgKyBtcC0+bGF5ZXItPm1tdV9jdHJsX29mZnNldCk7CiB9CiAKK3N0YXRp YyB2b2lkIG1hbGlkcF9zZXRfcGxhbmVfYmFzZV9hZGRyKHN0cnVjdCBkcm1fZnJhbWVidWZmZXIg KmZiLAorCQkJCSAgICAgICBzdHJ1Y3QgbWFsaWRwX3BsYW5lICptcCwKKwkJCQkgICAgICAgaW50 IHBsYW5lX2luZGV4KQoreworCWRtYV9hZGRyX3QgcGFkZHI7CisJdTE2IHB0cjsKKwlzdHJ1Y3Qg ZHJtX3BsYW5lICpwbGFuZSA9ICZtcC0+YmFzZTsKKwlib29sIGFmYmMgPSBmYi0+bW9kaWZpZXIg PyB0cnVlIDogZmFsc2U7CisKKwlwdHIgPSBtcC0+bGF5ZXItPnB0ciArIChwbGFuZV9pbmRleCA8 PCA0KTsKKworCS8qCisJICogRm9yIEFGQkMgYnVmZmVycywgY3JvcHBpbmcgaXMgaGFuZGxlZCBi eSBBRkJDIGRlY29kZXIgcmF0aGVyIHRoYW4KKwkgKiBwb2ludGVyIG1hbmlwdWxhdGlvbi4KKwkg Ki8KKwlpZiAoIWFmYmMpIHsKKwkJcGFkZHIgPSBkcm1fZmJfY21hX2dldF9nZW1fYWRkcihmYiwg cGxhbmUtPnN0YXRlLAorCQkJCQkJcGxhbmVfaW5kZXgpOworCX0gZWxzZSB7CisJCXN0cnVjdCBk cm1fZ2VtX2NtYV9vYmplY3QgKm9iajsKKworCQlvYmogPSBkcm1fZmJfY21hX2dldF9nZW1fb2Jq KGZiLCBwbGFuZV9pbmRleCk7CisKKwkJaWYgKFdBUk5fT04oIW9iaikpCisJCQlyZXR1cm47CisJ CXBhZGRyID0gb2JqLT5wYWRkcjsKKwl9CisKKwltYWxpZHBfaHdfd3JpdGUobXAtPmh3ZGV2LCBs b3dlcl8zMl9iaXRzKHBhZGRyKSwgcHRyKTsKKwltYWxpZHBfaHdfd3JpdGUobXAtPmh3ZGV2LCB1 cHBlcl8zMl9iaXRzKHBhZGRyKSwgcHRyICsgNCk7Cit9CisKK3N0YXRpYyB2b2lkIG1hbGlkcF9k ZV9zZXRfcGxhbmVfYWZiYyhzdHJ1Y3QgZHJtX3BsYW5lICpwbGFuZSkKK3sKKwlzdHJ1Y3QgbWFs aWRwX3BsYW5lICptcDsKKwl1MzIgc3JjX3csIHNyY19oLCB2YWwgPSAwLCBzcmNfeCwgc3JjX3k7 CisJc3RydWN0IGRybV9mcmFtZWJ1ZmZlciAqZmIgPSBwbGFuZS0+c3RhdGUtPmZiOworCisJbXAg PSB0b19tYWxpZHBfcGxhbmUocGxhbmUpOworCisJLyogbm8gYWZiY19kZWNvZGVyX29mZnNldCBt ZWFucyBBRkJDIGlzIG5vdCBzdXBwb3J0ZWQgb24gdGhpcyBwbGFuZSAqLworCWlmICghbXAtPmxh eWVyLT5hZmJjX2RlY29kZXJfb2Zmc2V0KQorCQlyZXR1cm47CisKKwlpZiAoIWZiLT5tb2RpZmll cikgeworCQltYWxpZHBfaHdfd3JpdGUobXAtPmh3ZGV2LCAwLCBtcC0+bGF5ZXItPmFmYmNfZGVj b2Rlcl9vZmZzZXQpOworCQlyZXR1cm47CisJfQorCisJLyogY29udmVydCBzcmMgdmFsdWVzIGZy b20gUTE2IGZpeGVkIHBvaW50IHRvIGludGVnZXIgKi8KKwlzcmNfdyA9IHBsYW5lLT5zdGF0ZS0+ c3JjX3cgPj4gMTY7CisJc3JjX2ggPSBwbGFuZS0+c3RhdGUtPnNyY19oID4+IDE2OworCXNyY194 ID0gcGxhbmUtPnN0YXRlLT5zcmNfeCA+PiAxNjsKKwlzcmNfeSA9IHBsYW5lLT5zdGF0ZS0+c3Jj X3kgPj4gMTY7CisKKwl2YWwgPSAoKGZiLT53aWR0aCAtIChzcmNfeCArIHNyY193KSkgPDwgTUFM SURQX0FEX0NST1BfUklHSFRfT0ZGU0VUKSB8CisJCSAgIHNyY194OworCW1hbGlkcF9od193cml0 ZShtcC0+aHdkZXYsIHZhbCwKKwkJCW1wLT5sYXllci0+YWZiY19kZWNvZGVyX29mZnNldCArIE1B TElEUF9BRF9DUk9QX0gpOworCisJdmFsID0gKChmYi0+aGVpZ2h0IC0gKHNyY195ICsgc3JjX2gp KSA8PCBNQUxJRFBfQURfQ1JPUF9CT1RUT01fT0ZGU0VUKSB8CisJCSAgIHNyY195OworCW1hbGlk cF9od193cml0ZShtcC0+aHdkZXYsIHZhbCwKKwkJCW1wLT5sYXllci0+YWZiY19kZWNvZGVyX29m ZnNldCArIE1BTElEUF9BRF9DUk9QX1YpOworCisJdmFsID0gTUFMSURQX0FEX0VOOworCWlmIChm Yi0+bW9kaWZpZXIgJiBBRkJDX0ZPUk1BVF9NT0RfU1BMSVQpCisJCXZhbCB8PSBNQUxJRFBfQURf QlM7CisJaWYgKGZiLT5tb2RpZmllciAmIEFGQkNfRk9STUFUX01PRF9ZVFIpCisJCXZhbCB8PSBN QUxJRFBfQURfWVRSOworCisJbWFsaWRwX2h3X3dyaXRlKG1wLT5od2RldiwgdmFsLCBtcC0+bGF5 ZXItPmFmYmNfZGVjb2Rlcl9vZmZzZXQpOworfQorCiBzdGF0aWMgdm9pZCBtYWxpZHBfZGVfcGxh bmVfdXBkYXRlKHN0cnVjdCBkcm1fcGxhbmUgKnBsYW5lLAogCQkJCSAgIHN0cnVjdCBkcm1fcGxh bmVfc3RhdGUgKm9sZF9zdGF0ZSkKIHsKQEAgLTYwMCwzMCArNjc0LDMzIEBAIHN0YXRpYyB2b2lk IG1hbGlkcF9kZV9wbGFuZV91cGRhdGUoc3RydWN0IGRybV9wbGFuZSAqcGxhbmUsCiAJc3RydWN0 IGRybV9wbGFuZV9zdGF0ZSAqc3RhdGUgPSBwbGFuZS0+c3RhdGU7CiAJdTE2IHBpeGVsX2FscGhh ID0gc3RhdGUtPnBpeGVsX2JsZW5kX21vZGU7CiAJdTggcGxhbmVfYWxwaGEgPSBzdGF0ZS0+YWxw aGEgPj4gODsKKwlib29sIGZvcm1hdF9oYXNfYWxwaGEgPSBzdGF0ZS0+ZmItPmZvcm1hdC0+aGFz X2FscGhhOwogCXUzMiBzcmNfdywgc3JjX2gsIGRlc3RfdywgZGVzdF9oLCB2YWw7CiAJaW50IGk7 CisJc3RydWN0IGRybV9mcmFtZWJ1ZmZlciAqZmIgPSBwbGFuZS0+c3RhdGUtPmZiOwogCiAJbXAg PSB0b19tYWxpZHBfcGxhbmUocGxhbmUpOwogCi0JLyogY29udmVydCBzcmMgdmFsdWVzIGZyb20g UTE2IGZpeGVkIHBvaW50IHRvIGludGVnZXIgKi8KLQlzcmNfdyA9IHN0YXRlLT5zcmNfdyA+PiAx NjsKLQlzcmNfaCA9IHN0YXRlLT5zcmNfaCA+PiAxNjsKLQlkZXN0X3cgPSBzdGF0ZS0+Y3J0Y193 OwotCWRlc3RfaCA9IHN0YXRlLT5jcnRjX2g7CisJLyogRm9yIEFGQkMgZnJhbWVidWZmZXIsIHVz ZSB0aGUgZnJhbWVidWZmZXIgd2lkdGggYW5kIGhlaWdodCBmb3IgY29uZmlndXJpbmcKKwkgKiBs YXllciBpbnB1dCBzaXplIHJlZ2lzdGVyLgorCSAqLworCWlmIChmYi0+bW9kaWZpZXIpIHsKKwkJ c3JjX3cgPSBmYi0+d2lkdGg7CisJCXNyY19oID0gZmItPmhlaWdodDsKKwl9IGVsc2UgeworCQkv KiBjb252ZXJ0IHNyYyB2YWx1ZXMgZnJvbSBRMTYgZml4ZWQgcG9pbnQgdG8gaW50ZWdlciAqLwor CQlzcmNfdyA9IG1zLT5iYXNlLnNyY193ID4+IDE2OworCQlzcmNfaCA9IG1zLT5iYXNlLnNyY19o ID4+IDE2OworCX0KKwlkZXN0X3cgPSBtcy0+YmFzZS5jcnRjX3c7CisJZGVzdF9oID0gbXMtPmJh c2UuY3J0Y19oOwogCiAJdmFsID0gbWFsaWRwX2h3X3JlYWQobXAtPmh3ZGV2LCBtcC0+bGF5ZXIt PmJhc2UpOwogCXZhbCA9ICh2YWwgJiB+TEFZRVJfRk9STUFUX01BU0spIHwgbXMtPmZvcm1hdDsK IAltYWxpZHBfaHdfd3JpdGUobXAtPmh3ZGV2LCB2YWwsIG1wLT5sYXllci0+YmFzZSk7CiAKLQlm b3IgKGkgPSAwOyBpIDwgbXMtPm5fcGxhbmVzOyBpKyspIHsKLQkJLyogY2FsY3VsYXRlIHRoZSBv ZmZzZXQgZm9yIHRoZSBsYXllcidzIHBsYW5lIHJlZ2lzdGVycyAqLwotCQl1MTYgcHRyID0gbXAt PmxheWVyLT5wdHIgKyAoaSA8PCA0KTsKLQkJZG1hX2FkZHJfdCBmYl9hZGRyID0gZHJtX2ZiX2Nt YV9nZXRfZ2VtX2FkZHIoc3RhdGUtPmZiLAotCQkJCQkJCSAgICAgc3RhdGUsIGkpOwotCi0JCW1h bGlkcF9od193cml0ZShtcC0+aHdkZXYsIGxvd2VyXzMyX2JpdHMoZmJfYWRkciksIHB0cik7Ci0J CW1hbGlkcF9od193cml0ZShtcC0+aHdkZXYsIHVwcGVyXzMyX2JpdHMoZmJfYWRkciksIHB0ciAr IDQpOwotCX0KKwlmb3IgKGkgPSAwOyBpIDwgbXMtPm5fcGxhbmVzOyBpKyspCisJCW1hbGlkcF9z ZXRfcGxhbmVfYmFzZV9hZGRyKGZiLCBtcCwgaSk7CiAKIAltYWxpZHBfZGVfc2V0X21tdV9jb250 cm9sKG1wLCBtcyk7CiAKQEAgLTY1Nyw2ICs3MzQsOCBAQCBzdGF0aWMgdm9pZCBtYWxpZHBfZGVf cGxhbmVfdXBkYXRlKHN0cnVjdCBkcm1fcGxhbmUgKnBsYW5lLAogCQkJCW1wLT5sYXllci0+YmFz ZSArIE1BTElEUDU1MF9MU19SMV9JTl9TSVpFKTsKIAl9CiAKKwltYWxpZHBfZGVfc2V0X3BsYW5l X2FmYmMocGxhbmUpOworCiAJLyogZmlyc3QgY2xlYXIgdGhlIHJvdGF0aW9uIGJpdHMgKi8KIAl2 YWwgPSBtYWxpZHBfaHdfcmVhZChtcC0+aHdkZXYsIG1wLT5sYXllci0+YmFzZSArIE1BTElEUF9M QVlFUl9DT05UUk9MKTsKIAl2YWwgJj0gfkxBWUVSX1JPVF9NQVNLOwpAQCAtNjc0LDcgKzc1Myw3 IEBAIHN0YXRpYyB2b2lkIG1hbGlkcF9kZV9wbGFuZV91cGRhdGUoc3RydWN0IGRybV9wbGFuZSAq cGxhbmUsCiAKIAlpZiAoc3RhdGUtPmFscGhhICE9IERSTV9CTEVORF9BTFBIQV9PUEFRVUUpIHsK IAkJdmFsIHw9IExBWUVSX0NPTVBfUExBTkU7Ci0JfSBlbHNlIGlmIChzdGF0ZS0+ZmItPmZvcm1h dC0+aGFzX2FscGhhKSB7CisJfSBlbHNlIGlmIChmb3JtYXRfaGFzX2FscGhhKSB7CiAJCS8qIFdl IG9ubHkgY2FyZSBhYm91dCBibGVuZCBtb2RlIGlmIHRoZSBmb3JtYXQgaGFzIGFscGhhICovCiAJ CXN3aXRjaCAocGl4ZWxfYWxwaGEpIHsKIAkJY2FzZSBEUk1fTU9ERV9CTEVORF9QUkVNVUxUSToK ZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1L2RybS9hcm0vbWFsaWRwX3JlZ3MuaCBiL2RyaXZlcnMv Z3B1L2RybS9hcm0vbWFsaWRwX3JlZ3MuaAppbmRleCA3Y2UzZTE0Li5hMGRkNmUxIDEwMDY0NAot LS0gYS9kcml2ZXJzL2dwdS9kcm0vYXJtL21hbGlkcF9yZWdzLmgKKysrIGIvZHJpdmVycy9ncHUv ZHJtL2FybS9tYWxpZHBfcmVncy5oCkBAIC0xOTgsMTAgKzE5OCwxMyBAQAogI2RlZmluZSBNQUxJ RFA1MDBfTFZfWVVWMlJHQgkJKChzMTYpKC0weEI4KSkKICNkZWZpbmUgTUFMSURQNTAwX0RFX0xW X0JBU0UJCTB4MDAxMDAKICNkZWZpbmUgTUFMSURQNTAwX0RFX0xWX1BUUl9CQVNFCTB4MDAxMjQK KyNkZWZpbmUgTUFMSURQNTAwX0RFX0xWX0FEX0NUUkwJCTB4MDA0MDAKICNkZWZpbmUgTUFMSURQ NTAwX0RFX0xHMV9CQVNFCQkweDAwMjAwCiAjZGVmaW5lIE1BTElEUDUwMF9ERV9MRzFfUFRSX0JB U0UJMHgwMDIxYworI2RlZmluZSBNQUxJRFA1MDBfREVfTEcxX0FEX0NUUkwJMHgwMDQwYwogI2Rl ZmluZSBNQUxJRFA1MDBfREVfTEcyX0JBU0UJCTB4MDAzMDAKICNkZWZpbmUgTUFMSURQNTAwX0RF X0xHMl9QVFJfQkFTRQkweDAwMzFjCisjZGVmaW5lIE1BTElEUDUwMF9ERV9MRzJfQURfQ1RSTAkw eDAwNDE4CiAjZGVmaW5lIE1BTElEUDUwMF9TRV9CQVNFCQkweDAwYzAwCiAjZGVmaW5lIE1BTElE UDUwMF9TRV9DT05UUk9MCQkweDAwYzBjCiAjZGVmaW5lIE1BTElEUDUwMF9TRV9NRU1XUklURV9P VVRfU0laRQkweDAwYzJjCkBAIC0yMjgsMTAgKzIzMSwxMyBAQAogI2RlZmluZSBNQUxJRFA1NTBf TFZfWVVWMlJHQgkJMHgwMDA4NAogI2RlZmluZSBNQUxJRFA1NTBfREVfTFYxX0JBU0UJCTB4MDAx MDAKICNkZWZpbmUgTUFMSURQNTUwX0RFX0xWMV9QVFJfQkFTRQkweDAwMTI0CisjZGVmaW5lIE1B TElEUDU1MF9ERV9MVjFfQURfQ1RSTAkweDAwMUI4CiAjZGVmaW5lIE1BTElEUDU1MF9ERV9MVjJf QkFTRQkJMHgwMDIwMAogI2RlZmluZSBNQUxJRFA1NTBfREVfTFYyX1BUUl9CQVNFCTB4MDAyMjQK KyNkZWZpbmUgTUFMSURQNTUwX0RFX0xWMl9BRF9DVFJMCTB4MDAyQjgKICNkZWZpbmUgTUFMSURQ NTUwX0RFX0xHX0JBU0UJCTB4MDAzMDAKICNkZWZpbmUgTUFMSURQNTUwX0RFX0xHX1BUUl9CQVNF CTB4MDAzMWMKKyNkZWZpbmUgTUFMSURQNTUwX0RFX0xHX0FEX0NUUkwJCTB4MDAzMzAKICNkZWZp bmUgTUFMSURQNTUwX0RFX0xTX0JBU0UJCTB4MDA0MDAKICNkZWZpbmUgTUFMSURQNTUwX0RFX0xT X1BUUl9CQVNFCTB4MDA0MmMKICNkZWZpbmUgTUFMSURQNTUwX0RFX1BFUkZfQkFTRQkJMHgwMDUw MApAQCAtMjU4LDYgKzI2NCwyMCBAQAogI2RlZmluZSBNQUxJRFBfTU1VX0NUUkxfUFhfUFMoeCkJ KDEgPDwgKDggKyAoeCkpKQogI2RlZmluZSBNQUxJRFBfTU1VX0NUUkxfUFBfTlVNX1JFUSh4KQko KCh4KSAmIDB4N2YpIDw8IDEyKQogCisvKiBBRkJDIHJlZ2lzdGVyIG9mZnNldHMgcmVsYXRpdmUg dG8gTUFMSURQWFhYX0RFX0xYX0FEX0NUUkwgKi8KKy8qIFRoZSBmb2xsb3dpbmcgcmVnaXN0ZXIg b2Zmc2V0cyBhcmUgY29tbW9uIGZvciBEUDUwMCwgRFA1NTAgYW5kIERQNjUwICovCisjZGVmaW5l IE1BTElEUF9BRF9DUk9QX0ggICAgICAgICAgICAgICAgMHg0CisjZGVmaW5lIE1BTElEUF9BRF9D Uk9QX1YgICAgICAgICAgICAgICAgMHg4CisjZGVmaW5lIE1BTElEUF9BRF9FTkRfUFRSX0xPVyAg ICAgICAgICAgMHhjCisjZGVmaW5lIE1BTElEUF9BRF9FTkRfUFRSX0hJR0ggICAgICAgICAgMHgx MAorCisvKiBBRkJDIGRlY29kZXIgUmVnaXN0ZXJzICovCisjZGVmaW5lIE1BTElEUF9BRF9FTiAg ICAgICAgICAgICAgICAgICAgQklUKDApCisjZGVmaW5lIE1BTElEUF9BRF9ZVFIgICAgICAgICAg ICAgICAgICAgQklUKDQpCisjZGVmaW5lIE1BTElEUF9BRF9CUyAgICAgICAgICAgICAgICAgICAg QklUKDgpCisjZGVmaW5lIE1BTElEUF9BRF9DUk9QX1JJR0hUX09GRlNFVCAgICAgMTYKKyNkZWZp bmUgTUFMSURQX0FEX0NST1BfQk9UVE9NX09GRlNFVCAgICAxNgorCiAvKgogICogU3RhcnRpbmcg d2l0aCBEUDU1MCB0aGUgcmVnaXN0ZXIgbWFwIGJsb2NrcyBoYXMgYmVlbiBzdGFuZGFyZGlzZWQg dG8gdGhlCiAgKiBmb2xsb3dpbmcgbGF5b3V0OgotLSAKMi43LjQKCl9fX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fCmRyaS1kZXZlbCBtYWlsaW5nIGxpc3QKZHJp LWRldmVsQGxpc3RzLmZyZWVkZXNrdG9wLm9yZwpodHRwczovL2xpc3RzLmZyZWVkZXNrdG9wLm9y Zy9tYWlsbWFuL2xpc3RpbmZvL2RyaS1kZXZlbAo=