From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1751754AbeDEJAg (ORCPT ); Thu, 5 Apr 2018 05:00:36 -0400 Received: from mail-cys01nam02on0078.outbound.protection.outlook.com ([104.47.37.78]:51392 "EHLO NAM02-CY1-obe.outbound.protection.outlook.com" rhost-flags-OK-OK-OK-FAIL) by vger.kernel.org with ESMTP id S1751412AbeDEJAc (ORCPT ); Thu, 5 Apr 2018 05:00:32 -0400 Subject: Re: [RFC 1/3] drm: Add DAMAGE_CLIPS property to plane To: Deepak Rawat , dri-devel@lists.freedesktop.org, syeh@vmware.com, linux-graphics-maintainer@vmware.com, ville.syrjala@linux.intel.com, lukasz.spintzyk@displaylink.com, noralf@tronnes.org, robdclark@gmail.com, gustavo@padovan.org, maarten.lankhorst@linux.intel.com, seanpaul@chromium.org, airlied@linux.ie, linux-kernel@vger.kernel.org References: <1522885748-67122-1-git-send-email-drawat@vmware.com> <1522885748-67122-2-git-send-email-drawat@vmware.com> <20180405073525.GP3881@phenom.ffwll.local> From: Thomas Hellstrom Message-ID: Date: Thu, 5 Apr 2018 11:00:15 +0200 User-Agent: Mozilla/5.0 (X11; Linux x86_64; rv:52.0) Gecko/20100101 Thunderbird/52.6.0 MIME-Version: 1.0 In-Reply-To: <20180405073525.GP3881@phenom.ffwll.local> Content-Type: text/plain; charset=utf-8; format=flowed Content-Transfer-Encoding: 7bit Content-Language: en-US X-Originating-IP: [155.4.205.56] X-ClientProxiedBy: DB3PR0202CA0006.eurprd02.prod.outlook.com (2603:10a6:8:1::19) To BLUPR05MB756.namprd05.prod.outlook.com (2a01:111:e400:89e::23) X-MS-PublicTrafficType: Email X-MS-Office365-Filtering-Correlation-Id: f0eaf50e-f373-49c5-9db8-08d59ad3ad87 X-Microsoft-Antispam: UriScan:;BCL:0;PCL:0;RULEID:(7020095)(4652020)(5600026)(4604075)(4534165)(4627221)(201703031133081)(201702281549075)(2017052603328)(7153060)(7193020);SRVR:BLUPR05MB756; X-Microsoft-Exchange-Diagnostics: 1;BLUPR05MB756;3:RKlLzOPcoN5rOcHjZMCNisv6ZKiYxg23U9WdZ+QWdQw3A9WXOpFRTU7BglcHRw3R20FF7otS5/RRFCDiGB0krVV5Uq2t9QKEBRhTBw9K0poPQ1HZT/wDAUK43FtOTZmtP1cuJBMZaOoK72AewtLgD7ZIKORADJJKMPxrs/uICUwZEAp9xn+Dgza5ePpRvIPRaNjOKkW5zrQ6sdtLD1Ukdt3P5YnQHvtqfleyrI4OWtL6kSvn+Zyp5ZEeLou+vxLo;25:B+kpCQFnAxvJ0Yvz+IxLwCSneCeMqWrATjacH3MrBqstBVkAivk5o8FhrY/0UJOYpJQ4ASyMS2kThsKpKmK67zR+ll8DOXf/vCCwMrLUCGJ1xkz+cbPWGUwQcddzxQX3wJLeT9Jz1FMdmPUKPo76M1NGN6zFeyHnbHLBZsa4N6e16XWiWxU46fm+1qc8RinLt5CoDm1o18j1HRVTVOsttwJGejY2hIOXs3gQbVB401lrWkHPJeurvJpMa5lDrXgllge0vRcHBxnTft97n2zbyWbwCvDL2fHrSsQeFXbNUuV1D6x6WXbVCxuGKsPZwQf3C9hP3A+2Ebi4FFQmkd1qVw==;31:dOsU6JbcK1kV4qSNtP74l6zlnK420vRjHismq61IBEbOG7/8ismGPDzNRKCxDdnRGfe/ivbEdg0rUnr2/U7egLqe0T/0S2RkCH1ETX/qzkSAG6T2HPofMJ6yQt2Djj/Vyz2+HxzSypGy9/LJxCK2Jz77a6SMYRvT64bMBjIfQVLSC4hUwNqgmsyu/ZwAGZTP6/z24Cwh25J9rX35cPOL4XCymLJzCfH8AXdPK/6OrN0= X-MS-TrafficTypeDiagnostic: BLUPR05MB756: Authentication-Results: spf=none (sender IP is ) smtp.mailfrom=thellstrom@vmware.com; X-Microsoft-Exchange-Diagnostics: 1;BLUPR05MB756;20:DzteknV1+COUwMNWcz8oxEV4EaAdO5CQFG/okV8wntnyImqg1xDKII6+v0ZSnzMmIDzqq0zqBoNcwVj/kOW7eZizCzv8ZC6o/cjsdoDKGLXZR2s2UVhjj2fIXEAAMSdlKhcGGQw0ZLqxsY3owaLWUaVXpj1tQyuOBFD70KfZjiM6pUN25GYtCnxk9c9jVuQJ6Y1nhoo6oNsvmv+hFH4T729btWT+S4zOzz6l6Z1iSJzWtYbiAHiBnRJmoCD96zjQZUACidR/BT8CL1ajsyDjnOq6BgsWUWZZpJHjbJpNrtOYd+Yil6aZ04g+QKwrphzvjbMsVpCDoh2hmypRBooxbVyGcv96wDnWck4vGBaJIayyZvFwKXE8cWRz/kZ2CO47kYYIERPF/ghCs4EFpo6jjPCKi6g5ELZVHqo/mDPm/sPXQEBR6zyE3sELhgCj5eGWje51lH6kbYDDma5RQB1segvQpDxhAk50wGLY6CD2TkUpVJ1oLkwxydSfJhDitjDI;4:GQazns7I6/BAaWVwEkVcyZ6Tito+SnHykrR+5l0LBFWwtvU7mZnjx/aDCzBxF8OeW883Ds/iNjByFaZIiJG3TKrOiJb8YkALXW5dSHSki2Q0mZ9uvGw7cJgUpmYvlBSUvsgeyXYPf5po5ZQgoLXmql6aXAYc6DxJ4KRe+U9/8utemK7XK65DnCxyYD2NsizgHoptYn0evwvbAGrHtyxwhutEYJncBv7l2lHjoBXiIvsdd31xUsIjc2eVo3UFDhq0wpeIt5+8zuM87nI5BqCTfoR+bi3vTVUyX6U2KDyMtesobCseVmH3HG8pkxREG+1hVB2ycJXPxxjWyd5C7derbGc+KpXsUvKN1Um1uLrfvSc= X-Microsoft-Antispam-PRVS: X-Exchange-Antispam-Report-Test: UriScan:(61668805478150)(10436049006162); X-Exchange-Antispam-Report-CFA-Test: BCL:0;PCL:0;RULEID:(8211001083)(6040522)(2401047)(5005006)(8121501046)(10201501046)(3002001)(93006095)(93001095)(3231221)(944501327)(52105095)(6041310)(20161123562045)(201703131423095)(201702281528075)(20161123555045)(201703061421075)(201703061406153)(20161123560045)(20161123564045)(20161123558120)(6072148)(201708071742011);SRVR:BLUPR05MB756;BCL:0;PCL:0;RULEID:;SRVR:BLUPR05MB756; X-Forefront-PRVS: 06339BAE63 X-Forefront-Antispam-Report: SFV:NSPM;SFS:(10009020)(6069001)(39860400002)(366004)(39380400002)(396003)(346002)(376002)(199004)(189003)(11346002)(52116002)(58126008)(2486003)(97736004)(52146003)(16526019)(23676004)(956004)(7416002)(6506007)(53546011)(229853002)(386003)(2906002)(65956001)(230700001)(7736002)(76176011)(47776003)(66066001)(65806001)(2616005)(305945005)(59450400001)(31696002)(316002)(486006)(478600001)(6512007)(6246003)(39060400002)(67846002)(6306002)(6486002)(3846002)(105586002)(446003)(5890100001)(8936002)(53936002)(50466002)(36756003)(5660300001)(68736007)(25786009)(64126003)(8676002)(476003)(6666003)(26005)(575784001)(81166006)(31686004)(6116002)(86362001)(966005)(106356001)(186003)(81156014)(65826007)(921003)(1121003);DIR:OUT;SFP:1101;SCL:1;SRVR:BLUPR05MB756;H:localhost.localdomain;FPR:;SPF:None;LANG:en;PTR:InfoNoRecords;A:1;MX:1; X-Microsoft-Exchange-Diagnostics: =?utf-8?B?MTtCTFVQUjA1TUI3NTY7MjM6a2VyVDZ0WDVhYmcyTzZzYmZGLzIyd2M5d0RY?= =?utf-8?B?YVVxWUpWVlZOa3lMdVlMK05OVlRHV04zeE0rbDNHYjhkdk5aQ0I3ZlJiWmdl?= =?utf-8?B?VkJUMGVDYnRYeFoyRWQ0NjlqUzFtcUtYZUhKM1NNOFNLb1RIYkJSTUoxS1JB?= =?utf-8?B?VWhPVXFzbCt1NVUzYUVtTjgyZlNPTERHUDVtNk5qcTBFVVIyZEtxSGpCdTdl?= =?utf-8?B?WEFCckNKNDJuNiszbXE4SU1ZRGJXLzBVc1QrMmNiY0J6WUpFTEVqZTNQWlU3?= =?utf-8?B?N2VYNS83YnhucmNuVEFrb1Q4S2FlSGM2NVRQOW1GY1o4UmpEbVdxZzdlbm5M?= =?utf-8?B?RXZPdzc3MUl5bU4xSWxwVzZNTklGT00xWVdqMGMvbTNPN2V6R1hwcXE3YXFo?= =?utf-8?B?cnJXMkRGTnRBbFpqVEY3Nng5eHF1d0p5Ly9GKzhmYzFZQ3EyN2dHdkJPU29H?= =?utf-8?B?bFFMSVJSTExvWTl6VjZtMklCWVU0bk1ZcDZ3RldaS3QwOEc1YjRSL28rbmls?= =?utf-8?B?M0tvU0NIWlR3UCtFQ3IrU3NOYVRQSXkrR1BQQnIwK3VEUytyU1krc04zd24v?= =?utf-8?B?ckFCRzduYjFNSVByWU5na21CTERwa0xzeWIvRlVtUmN0YnFyM0V4ZWJ3TFhl?= =?utf-8?B?RzBFVDJoa28xdnlQK2FqU1l0TXd4MGcvMnNSOGNDMXlCakVSTkFlck52bFNF?= =?utf-8?B?YWQzekIyZU9xZWJDc2J5K3ZJWmxLMFdJaVJCcWxzV2NDWjRpOENobEl5OXNP?= =?utf-8?B?TDl5aUxOZkNxd0dSM0tOMm83cHgyQUFoNUZ3MkdmV0lpLzlhSUcrM0MyQm4w?= =?utf-8?B?NWNQMjhlb1Ztcm96OVRtK3UrSDE1Q243RVE0SXNxWWp1ZDdaVkFrWE9KbXVq?= =?utf-8?B?ZDJyWGRNbW0yM1kvY0VSZlFybDdLNDh1ZlJqcFNXa3BqUklaN1l1REo5KzJz?= =?utf-8?B?blNJbnJtRFdVN3JrMVhaZWpHRldBY3gydWVmd3Y4YVY2YWtwQTdTNGlQdnNN?= =?utf-8?B?T3FuV0JqSzhMQ2tzTWdtNXdYSTk4cWpJNHpiUE9BWmpid1RsK09NclBlaHA4?= =?utf-8?B?UVBLR1Z1S0xSbnNucm9va2NDYmVKRy9kdThJb2s4NlNDKzByQ0pZZHdkV2Vq?= =?utf-8?B?TERMcjZYV1gzNWxMSkpXaXhpOFZLRkJ0aUNCVUFzcHNHeUtFMnV0amRwS1p0?= =?utf-8?B?Z2NRNk1BK2l2TjBuclR0TjFyOFZCUUMxanA5eVdKRzlFU1YxN3Fjbmw1Tlpw?= =?utf-8?B?NEVySzBpQy9JazN4bGVmZWlSV0o5UWNZZnhWUE9jKzdVV0FyRFNUZUI4bXFy?= =?utf-8?B?UGQ3SDVVUDVLeS9GaHk0UUp0V0NVRUtHbmw4ekFzTFMvL3dydytqVnJOM0dM?= =?utf-8?B?TFgrSGhjNGE5WVZwcUZ5bS8xUHR5enRlOG1tbWdvYjI4a2VNY1NMdXFGN202?= =?utf-8?B?dEdRNnlMYzNka3ZLVERVeFh6aHEzb2xGaEhNR2JzKzI3K0NjUFhvNWVJR3RU?= =?utf-8?B?MXdFU3VpbTByd294VkNkWXVJSGZNZGFjRTl2bnI3SW1MSjJZT2pzdHFaV1JL?= =?utf-8?B?eXcyREtaWUtQb3lxckpLTW9uOEErOGxUL3B5bDVlaGxua3RQMXROa0ZMOUI1?= =?utf-8?B?V01oeExSMTRqVzY3L2FkT2JHVzI5OFdCNlMxWnl6bVBnT3JOdS9tNEZiVFI3?= =?utf-8?B?ZzBuWlpwak1JZFIyQWlkVStoWU0vcmVoNGt0Qi9SbHliK2pvOG81aTNIdFlS?= =?utf-8?B?ZG5FSzNXa2F3cWhLaE8zMjAwMHBUOU8wYVFOdHpKVERPWWZxTU1ZYkZNS0VD?= =?utf-8?B?WXY1SmZIU2VJcE9DaWZFRU5YcnA5MlZkS0xXRE56VUY5SzlOY2xVQ2tWaXRG?= =?utf-8?B?ZXMvU2JrMi91RFlVdXBqRThxTXhIdlJ0Q240cVdmREdSVnBrUVhUUUNnanNM?= =?utf-8?B?YzQ2dm0wRGo0NkJtZHZjMFdvWU9RWEo5QWxVRUpWOHlsWEFEcm1rcmQ4NkJq?= =?utf-8?B?S1lScjdGeTJ5QjNYSTFzdFJWZy9JSWlNa2FRRVN3ZTBVNkcyL0t1blZsUlNy?= =?utf-8?B?K29OdzFaWHB3QVpoclVwbEJ1QU1nR0tTeERlMis4b1VBcy94dVFBRk1DazNG?= =?utf-8?Q?aL/n5W0yojrHLNwTWA/FOQLpGciaNQo+a+xXIE0TTaT?= X-Microsoft-Antispam-Message-Info: YqWXGXOGUKmU9Ivk4gAJqzNSBMeLbUk+Qph4YCCiYecXhlH7XutHc6wZs8UPyFgVX0YYX4VWtjiGuS5xADECG/1RbHtDuxSnRqn3qC60Ke5mHqhNbk16xQNhGVxWkeK9HkvIKGRSXCIE+1WurGIyzdzw18qzH2rBTIel0uIt8h6Xxfci2tSA8VGG9Qv2XwM5 X-Microsoft-Exchange-Diagnostics: 1;BLUPR05MB756;6:E5EkgtBeiFQoIQSnA0dB3cncIrzGTvlkX2/a4r7EKpU/TdBaRpTnuZcyNJT8Eizzu378byo/UnjD2Y+aa5vOqknIgxta2QIqBQ9s7A96692+Wq0xm20GyC9lCRpvXOG7u+B2VHE7bBOtaUDSR3ysdjSzIJbrRVvivpyTFMk91c4y7AhJKfZRXjezEklhihNch35Vi28kytc6VyO4HK4kMg28vG9QIZaLSEwD1NBIXiXO0mSt6yzf5CYsziwGjjQSUf4kXhNqWjt343t17Dw3viIU0RNgskrFpUIcRw/hPr6vqrvXVuGKpQ9Rrcp7lHLXGovJiVJVZ5m4khilcEGq0OxGZ378crutvGSqBklzD5pI1LbEwkdiA5uiu+SsBpd4K0SevZH0lYcUKrUJWZh31ifqjcUe5DLXB1ijIB2/yPf4e+7jatR5FJjuZOJVk5L33XoSapX1m1xfSWOg9AzC6A==;5:kfgKJ20m42UG1OVv1BeEclqFihj+i967pumLLoeVb6nCnv6wSzusMxx88FtKReQFtKAQ0ndzdG5TCFGlPRDX7NpxGjchUCFmwwTVDfNAEcxHDFUNr1O/O0AytLnRL99xsqwN08fBOUxAhxxy4nOrYhfXme5VxdHlkiUuBFwBmzk=;24:AAxmJgLJ7uRVlf+kLC/pU4HGbKNv5NfClIF2pQWlqgkz3zBP5mltKESHyA9E9Z4bNukFWxdxJWuXxdfcCQzpJOL9EoflxMmglkPNqvdVxjU= SpamDiagnosticOutput: 1:99 SpamDiagnosticMetadata: NSPM X-Microsoft-Exchange-Diagnostics: 1;BLUPR05MB756;7:u1uXmfqB+xasDBkhDEu8zRzhDQnU1LYoc4qc+yAC/JVi/EmLf1xOWjD/DJSZwuD0Ffi9uM+yBAJ7hXUgI6HOQJC9ZRU17BJShxY8NuJypbAJUo0sEBAK/n9iZeOpmcytzZd/wlDs6VDDti+MA3gtGecrGVi024QGviu8QrtAeT+MgVaQmU77PH8+fgVXlmHoHEViYwUxJFx23JTMEkDmLtkzsjzOGj+kS0Zsd0pVaM+zLMvt28e50GGDYgvUdrDW;20:KrJ9F4e/EUqBbp/5ZJ8AZ99IcmNst01jEQB7DH/CZA5v/8QFlngm4SySm+3Imjz5GjvBCg6Jp6vZUoysPL/kALHtWMqxPwp3A7QDnApxkcMtFTQ0a0FKTy+S6DM5wDJiYVvWzmlgqlC01w/b+tdJsDLaHrICm8ZT5F5S/VuXxRc= X-OriginatorOrg: vmware.com X-MS-Exchange-CrossTenant-OriginalArrivalTime: 05 Apr 2018 09:00:26.0578 (UTC) X-MS-Exchange-CrossTenant-Network-Message-Id: f0eaf50e-f373-49c5-9db8-08d59ad3ad87 X-MS-Exchange-CrossTenant-FromEntityHeader: Hosted X-MS-Exchange-CrossTenant-Id: b39138ca-3cee-4b4a-a4d6-cd83d9dd62f0 X-MS-Exchange-Transport-CrossTenantHeadersStamped: BLUPR05MB756 Sender: linux-kernel-owner@vger.kernel.org List-ID: X-Mailing-List: linux-kernel@vger.kernel.org On 04/05/2018 09:35 AM, Daniel Vetter wrote: > On Wed, Apr 04, 2018 at 04:49:06PM -0700, Deepak Rawat wrote: >> From: Lukasz Spintzyk >> >> Optional plane property to mark damaged regions on the plane in >> framebuffer coordinates of the framebuffer attached to the plane. >> >> The layout of blob data is simply an array of drm_mode_rect with maximum >> array size limited by DRM_MODE_FB_DIRTY_MAX_CLIPS. Unlike plane src >> coordinates, damage clips are not in 16.16 fixed point. >> >> Damage clips are a hint to kernel as which area of framebuffer has >> changed since last page-flip. This should be helpful for some drivers >> especially for virtual devices where each framebuffer change needs to >> be transmitted over network, usb, etc. >> >> Driver which are interested in enabling DAMAGE_CLIPS property for a >> plane should enable this property using drm_plane_enable_damage_clips. >> >> Signed-off-by: Lukasz Spintzyk >> Signed-off-by: Deepak Rawat > The property uapi section is missing, see: > > https://urldefense.proofpoint.com/v2/url?u=https-3A__dri.freedesktop.org_docs_drm_gpu_drm-2Dkms.html-23plane-2Dcomposition-2Dproperties&d=DwIBAg&c=uilaK90D4TOVoH58JNXRgQ&r=wnSlgOCqfpNS4d02vP68_E9q2BNMCwfD2OZ_6dCFVQQ&m=J31YNV1uz3IVRaorM-eo48msi9__sQurqRZrig2UE1s&s=vzsuquF1agbOw54HSC_18Kk2k9j83m8RusmDCtPAFWQ&e= > > Plane composition feels like the best place to put this. Please use that > section to tie all the various bits together, including the helpers you're > adding in the following patches for drivers to use. > > Bunch of nitpicks below, but overall I'm agreeing now with just going with > fb coordinate damage rects. > > Like you say, the thing needed here now is userspace + driver actually > implementing this. I'd also say the compat helper to map the legacy > fb->dirty to this new atomic way of doing things should be included here > (gives us a lot more testing for these new paths). > > Icing on the cake would be an igt to make sure kernel rejects invalid clip > rects correctly. > >> --- >> drivers/gpu/drm/drm_atomic.c | 42 +++++++++++++++++++++++++++++++++++++ >> drivers/gpu/drm/drm_atomic_helper.c | 4 ++++ >> drivers/gpu/drm/drm_mode_config.c | 5 +++++ >> drivers/gpu/drm/drm_plane.c | 12 +++++++++++ >> include/drm/drm_mode_config.h | 15 +++++++++++++ >> include/drm/drm_plane.h | 16 ++++++++++++++ >> include/uapi/drm/drm_mode.h | 15 +++++++++++++ >> 7 files changed, 109 insertions(+) >> >> diff --git a/drivers/gpu/drm/drm_atomic.c b/drivers/gpu/drm/drm_atomic.c >> index 7d25c42..9226d24 100644 >> --- a/drivers/gpu/drm/drm_atomic.c >> +++ b/drivers/gpu/drm/drm_atomic.c >> @@ -669,6 +669,40 @@ static void drm_atomic_crtc_print_state(struct drm_printer *p, >> } >> >> /** >> + * drm_atomic_set_damage_for_plane - sets the damage clips property to plane >> + * @state: plane state >> + * @blob: damage clips in framebuffer coordinates >> + * >> + * Returns: >> + * >> + * Zero on success, error code on failure. >> + */ >> +static int drm_atomic_set_damage_for_plane(struct drm_plane_state *state, >> + struct drm_property_blob *blob) >> +{ >> + if (blob == state->damage_clips) >> + return 0; >> + >> + drm_property_blob_put(state->damage_clips); >> + state->damage_clips = NULL; >> + >> + if (blob) { >> + uint32_t count = blob->length/sizeof(struct drm_rect); >> + >> + if (count > DRM_MODE_FB_DIRTY_MAX_CLIPS) >> + return -EINVAL; >> + >> + state->damage_clips = drm_property_blob_get(blob); >> + state->num_clips = count; >> + } else { >> + state->damage_clips = NULL; >> + state->num_clips = 0; >> + } >> + >> + return 0; >> +} >> + >> +/** >> * drm_atomic_get_plane_state - get plane state >> * @state: global atomic state object >> * @plane: plane to get state object for >> @@ -793,6 +827,12 @@ static int drm_atomic_plane_set_property(struct drm_plane *plane, >> state->color_encoding = val; >> } else if (property == plane->color_range_property) { >> state->color_range = val; >> + } else if (property == config->prop_damage_clips) { >> + struct drm_property_blob *blob = >> + drm_property_lookup_blob(dev, val); >> + int ret = drm_atomic_set_damage_for_plane(state, blob); > There's already a helper with size-checking built-in, see > drm_atomic_replace_property_blob_from_id(). Wrt computing num_clips I'd > just provide a little inline helper that does the > blob->length/sizeof(drm_rect) conversion (it's just a shift, so fast). > >> + drm_property_blob_put(blob); >> + return ret; >> } else if (plane->funcs->atomic_set_property) { >> return plane->funcs->atomic_set_property(plane, state, >> property, val); >> @@ -856,6 +896,8 @@ drm_atomic_plane_get_property(struct drm_plane *plane, >> *val = state->color_encoding; >> } else if (property == plane->color_range_property) { >> *val = state->color_range; >> + } else if (property == config->prop_damage_clips) { >> + *val = (state->damage_clips) ? state->damage_clips->base.id : 0; >> } else if (plane->funcs->atomic_get_property) { >> return plane->funcs->atomic_get_property(plane, state, property, val); >> } else { >> diff --git a/drivers/gpu/drm/drm_atomic_helper.c b/drivers/gpu/drm/drm_atomic_helper.c >> index c356545..55b44e3 100644 >> --- a/drivers/gpu/drm/drm_atomic_helper.c >> +++ b/drivers/gpu/drm/drm_atomic_helper.c >> @@ -3506,6 +3506,8 @@ void __drm_atomic_helper_plane_duplicate_state(struct drm_plane *plane, >> >> state->fence = NULL; >> state->commit = NULL; >> + state->damage_clips = NULL; >> + state->num_clips = 0; >> } >> EXPORT_SYMBOL(__drm_atomic_helper_plane_duplicate_state); >> >> @@ -3550,6 +3552,8 @@ void __drm_atomic_helper_plane_destroy_state(struct drm_plane_state *state) >> >> if (state->commit) >> drm_crtc_commit_put(state->commit); >> + >> + drm_property_blob_put(state->damage_clips); >> } >> EXPORT_SYMBOL(__drm_atomic_helper_plane_destroy_state); >> >> diff --git a/drivers/gpu/drm/drm_mode_config.c b/drivers/gpu/drm/drm_mode_config.c >> index e5c6533..e93b127 100644 >> --- a/drivers/gpu/drm/drm_mode_config.c >> +++ b/drivers/gpu/drm/drm_mode_config.c >> @@ -293,6 +293,11 @@ static int drm_mode_create_standard_properties(struct drm_device *dev) >> return -ENOMEM; >> dev->mode_config.prop_crtc_id = prop; >> >> + prop = drm_property_create(dev, DRM_MODE_PROP_BLOB, "DAMAGE_CLIPS", 0); > Bit a bikeshed, but since the coordinates are in fb pixels, not plane > pixels, I'd call this "FB_DAMAGE_CLIPS". > >> + if (!prop) >> + return -ENOMEM; >> + dev->mode_config.prop_damage_clips = prop; >> + >> prop = drm_property_create_bool(dev, DRM_MODE_PROP_ATOMIC, >> "ACTIVE"); >> if (!prop) >> diff --git a/drivers/gpu/drm/drm_plane.c b/drivers/gpu/drm/drm_plane.c >> index 6d2a6e4..071221b 100644 >> --- a/drivers/gpu/drm/drm_plane.c >> +++ b/drivers/gpu/drm/drm_plane.c >> @@ -1101,3 +1101,15 @@ int drm_mode_page_flip_ioctl(struct drm_device *dev, >> >> return ret; >> } >> + >> +/** >> + * drm_plane_enable_damage_clips - enable damage clips property >> + * @plane: plane on which this property to enable. >> + */ >> +void drm_plane_enable_damage_clips(struct drm_plane *plane) >> +{ >> + struct drm_device *dev = plane->dev; >> + struct drm_mode_config *config = &dev->mode_config; >> + >> + drm_object_attach_property(&plane->base, config->prop_damage_clips, 0); >> +} >> diff --git a/include/drm/drm_mode_config.h b/include/drm/drm_mode_config.h >> index 7569f22..d8767da 100644 >> --- a/include/drm/drm_mode_config.h >> +++ b/include/drm/drm_mode_config.h >> @@ -628,6 +628,21 @@ struct drm_mode_config { >> */ >> struct drm_property *prop_crtc_id; >> /** >> + * @prop_damage_clips: Optional plane property to mark damaged regions >> + * on the plane in framebuffer coordinates of the framebuffer attached >> + * to the plane. > Why should we make this optional? Looks like just another thing drivers > might screw up, since we have multiple callbacks and things to set up for > proper dirty tracking. > > One option I'm seeing is that if this is set, and it's an atomic driver, > then we just directly call into the default atomic fb->dirty > implementation. That way there's only 1 thing drivers need to do to set up > dirty rect tracking, and they'll get all of it. > >> + * >> + * The layout of blob data is simply an array of drm_mode_rect with >> + * maximum array size limited by DRM_MODE_FB_DIRTY_MAX_CLIPS. Unlike >> + * plane src coordinates, damage clips are not in 16.16 fixed point. > I honestly have no idea where this limit is from. Worth keeping? I can > easily imagine that userspace could trip over this - it's fairly high, but > not unlimited. > >> + * >> + * Damage clips are a hint to kernel as which area of framebuffer has >> + * changed since last page-flip. This should be helpful >> + * for some drivers especially for virtual devices where each >> + * framebuffer change needs to be transmitted over network, usb, etc. > I'd also clarify that userspace still must render the entire screen, i.e. > make it more clear that it's really just a hint and not mandatory to only > scan out the damaged parts. > >> + */ >> + struct drm_property *prop_damage_clips; >> + /** >> * @prop_active: Default atomic CRTC property to control the active >> * state, which is the simplified implementation for DPMS in atomic >> * drivers. >> diff --git a/include/drm/drm_plane.h b/include/drm/drm_plane.h >> index f7bf4a4..9f24548 100644 >> --- a/include/drm/drm_plane.h >> +++ b/include/drm/drm_plane.h >> @@ -146,6 +146,21 @@ struct drm_plane_state { >> */ >> struct drm_crtc_commit *commit; >> >> + /* >> + * @damage_clips >> + * >> + * blob property with damage as array of drm_rect in framebuffer > &drm_rect gives you a nice hyperlink in the generated docs. > >> + * coodinates. >> + */ >> + struct drm_property_blob *damage_clips; >> + >> + /* >> + * @num_clips >> + * >> + * Number of drm_rect in @damage_clips. >> + */ >> + uint32_t num_clips; >> + >> struct drm_atomic_state *state; >> }; >> >> @@ -611,6 +626,7 @@ int drm_plane_init(struct drm_device *dev, >> const uint32_t *formats, unsigned int format_count, >> bool is_primary); >> void drm_plane_cleanup(struct drm_plane *plane); >> +void drm_plane_enable_damage_clips(struct drm_plane *plane); >> >> /** >> * drm_plane_index - find the index of a registered plane >> diff --git a/include/uapi/drm/drm_mode.h b/include/uapi/drm/drm_mode.h >> index 50bcf42..0ad0d5b 100644 >> --- a/include/uapi/drm/drm_mode.h >> +++ b/include/uapi/drm/drm_mode.h >> @@ -873,6 +873,21 @@ struct drm_mode_revoke_lease { >> __u32 lessee_id; >> }; >> >> +/** >> + * struct drm_mode_rect - two dimensional rectangle drm_rect exported to >> + * user-space. >> + * @x1: horizontal starting coordinate (inclusive) >> + * @y1: vertical starting coordinate (inclusive) >> + * @x2: horizontal ending coordinate (exclusive) >> + * @y2: vertical ending coordinate (exclusive) >> + */ >> +struct drm_mode_rect { >> + __s32 x1; >> + __s32 y1; >> + __s32 x2; >> + __s32 y2; > Why signed? Negative damage rects on an fb don't make sense to me. Also, > please specify what this is exactly (to avoid confusion with the 16.16 > fixed point src rects), and maybe mention in the commit message why we're > not using drm_clip_rect (going to proper uapi types and 32bit makes sense > to me). IMO, while we don't expect negative damage coordinates, to avoid yet another drm uapi rect in the future when we actually need negative numbers signed is a good choice... /Thomas From mboxrd@z Thu Jan 1 00:00:00 1970 From: Thomas Hellstrom Subject: Re: [RFC 1/3] drm: Add DAMAGE_CLIPS property to plane Date: Thu, 5 Apr 2018 11:00:15 +0200 Message-ID: References: <1522885748-67122-1-git-send-email-drawat@vmware.com> <1522885748-67122-2-git-send-email-drawat@vmware.com> <20180405073525.GP3881@phenom.ffwll.local> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8"; Format="flowed" Content-Transfer-Encoding: base64 Return-path: Received: from NAM01-BY2-obe.outbound.protection.outlook.com (mail-by2nam01on0053.outbound.protection.outlook.com [104.47.34.53]) by gabe.freedesktop.org (Postfix) with ESMTPS id 1B3BB6E6FA for ; Thu, 5 Apr 2018 09:00:32 +0000 (UTC) In-Reply-To: <20180405073525.GP3881@phenom.ffwll.local> 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: Deepak Rawat , dri-devel@lists.freedesktop.org, syeh@vmware.com, linux-graphics-maintainer@vmware.com, ville.syrjala@linux.intel.com, lukasz.spintzyk@displaylink.com, noralf@tronnes.org, robdclark@gmail.com, gustavo@padovan.org, maarten.lankhorst@linux.intel.com, seanpaul@chromium.org, airlied@linux.ie, linux-kernel@vger.kernel.org List-Id: dri-devel@lists.freedesktop.org T24gMDQvMDUvMjAxOCAwOTozNSBBTSwgRGFuaWVsIFZldHRlciB3cm90ZToKPiBPbiBXZWQsIEFw ciAwNCwgMjAxOCBhdCAwNDo0OTowNlBNIC0wNzAwLCBEZWVwYWsgUmF3YXQgd3JvdGU6Cj4+IEZy b206IEx1a2FzeiBTcGludHp5ayA8bHVrYXN6LnNwaW50enlrQGRpc3BsYXlsaW5rLmNvbT4KPj4K Pj4gT3B0aW9uYWwgcGxhbmUgcHJvcGVydHkgdG8gbWFyayBkYW1hZ2VkIHJlZ2lvbnMgb24gdGhl IHBsYW5lIGluCj4+IGZyYW1lYnVmZmVyIGNvb3JkaW5hdGVzIG9mIHRoZSBmcmFtZWJ1ZmZlciBh dHRhY2hlZCB0byB0aGUgcGxhbmUuCj4+Cj4+IFRoZSBsYXlvdXQgb2YgYmxvYiBkYXRhIGlzIHNp bXBseSBhbiBhcnJheSBvZiBkcm1fbW9kZV9yZWN0IHdpdGggbWF4aW11bQo+PiBhcnJheSBzaXpl IGxpbWl0ZWQgYnkgRFJNX01PREVfRkJfRElSVFlfTUFYX0NMSVBTLiBVbmxpa2UgcGxhbmUgc3Jj Cj4+IGNvb3JkaW5hdGVzLCBkYW1hZ2UgY2xpcHMgYXJlIG5vdCBpbiAxNi4xNiBmaXhlZCBwb2lu dC4KPj4KPj4gRGFtYWdlIGNsaXBzIGFyZSBhIGhpbnQgdG8ga2VybmVsIGFzIHdoaWNoIGFyZWEg b2YgZnJhbWVidWZmZXIgaGFzCj4+IGNoYW5nZWQgc2luY2UgbGFzdCBwYWdlLWZsaXAuIFRoaXMg c2hvdWxkIGJlIGhlbHBmdWwgZm9yIHNvbWUgZHJpdmVycwo+PiBlc3BlY2lhbGx5IGZvciB2aXJ0 dWFsIGRldmljZXMgd2hlcmUgZWFjaCBmcmFtZWJ1ZmZlciBjaGFuZ2UgbmVlZHMgdG8KPj4gYmUg dHJhbnNtaXR0ZWQgb3ZlciBuZXR3b3JrLCB1c2IsIGV0Yy4KPj4KPj4gRHJpdmVyIHdoaWNoIGFy ZSBpbnRlcmVzdGVkIGluIGVuYWJsaW5nIERBTUFHRV9DTElQUyBwcm9wZXJ0eSBmb3IgYQo+PiBw bGFuZSBzaG91bGQgZW5hYmxlIHRoaXMgcHJvcGVydHkgdXNpbmcgZHJtX3BsYW5lX2VuYWJsZV9k YW1hZ2VfY2xpcHMuCj4+Cj4+IFNpZ25lZC1vZmYtYnk6IEx1a2FzeiBTcGludHp5ayA8bHVrYXN6 LnNwaW50enlrQGRpc3BsYXlsaW5rLmNvbT4KPj4gU2lnbmVkLW9mZi1ieTogRGVlcGFrIFJhd2F0 IDxkcmF3YXRAdm13YXJlLmNvbT4KPiBUaGUgcHJvcGVydHkgdWFwaSBzZWN0aW9uIGlzIG1pc3Np bmcsIHNlZToKPgo+IGh0dHBzOi8vdXJsZGVmZW5zZS5wcm9vZnBvaW50LmNvbS92Mi91cmw/dT1o dHRwcy0zQV9fZHJpLmZyZWVkZXNrdG9wLm9yZ19kb2NzX2RybV9ncHVfZHJtLTJEa21zLmh0bWwt MjNwbGFuZS0yRGNvbXBvc2l0aW9uLTJEcHJvcGVydGllcyZkPUR3SUJBZyZjPXVpbGFLOTBENFRP Vm9INThKTlhSZ1Emcj13blNsZ09DcWZwTlM0ZDAydlA2OF9FOXEyQk5NQ3dmRDJPWl82ZENGVlFR Jm09SjMxWU5WMXV6M0lWUmFvck0tZW80OG1zaTlfX3NRdXJxUlpyaWcyVUUxcyZzPXZ6c3VxdUYx YWdiT3c1NEhTQ18xOEtrMms5ajgzbThSdXNtREN0UEFGV1EmZT0KPgo+IFBsYW5lIGNvbXBvc2l0 aW9uIGZlZWxzIGxpa2UgdGhlIGJlc3QgcGxhY2UgdG8gcHV0IHRoaXMuIFBsZWFzZSB1c2UgdGhh dAo+IHNlY3Rpb24gdG8gdGllIGFsbCB0aGUgdmFyaW91cyBiaXRzIHRvZ2V0aGVyLCBpbmNsdWRp bmcgdGhlIGhlbHBlcnMgeW91J3JlCj4gYWRkaW5nIGluIHRoZSBmb2xsb3dpbmcgcGF0Y2hlcyBm b3IgZHJpdmVycyB0byB1c2UuCj4KPiBCdW5jaCBvZiBuaXRwaWNrcyBiZWxvdywgYnV0IG92ZXJh bGwgSSdtIGFncmVlaW5nIG5vdyB3aXRoIGp1c3QgZ29pbmcgd2l0aAo+IGZiIGNvb3JkaW5hdGUg ZGFtYWdlIHJlY3RzLgo+Cj4gTGlrZSB5b3Ugc2F5LCB0aGUgdGhpbmcgbmVlZGVkIGhlcmUgbm93 IGlzIHVzZXJzcGFjZSArIGRyaXZlciBhY3R1YWxseQo+IGltcGxlbWVudGluZyB0aGlzLiBJJ2Qg YWxzbyBzYXkgdGhlIGNvbXBhdCBoZWxwZXIgdG8gbWFwIHRoZSBsZWdhY3kKPiBmYi0+ZGlydHkg dG8gdGhpcyBuZXcgYXRvbWljIHdheSBvZiBkb2luZyB0aGluZ3Mgc2hvdWxkIGJlIGluY2x1ZGVk IGhlcmUKPiAoZ2l2ZXMgdXMgYSBsb3QgbW9yZSB0ZXN0aW5nIGZvciB0aGVzZSBuZXcgcGF0aHMp Lgo+Cj4gSWNpbmcgb24gdGhlIGNha2Ugd291bGQgYmUgYW4gaWd0IHRvIG1ha2Ugc3VyZSBrZXJu ZWwgcmVqZWN0cyBpbnZhbGlkIGNsaXAKPiByZWN0cyBjb3JyZWN0bHkuCj4KPj4gLS0tCj4+ICAg ZHJpdmVycy9ncHUvZHJtL2RybV9hdG9taWMuYyAgICAgICAgfCA0MiArKysrKysrKysrKysrKysr KysrKysrKysrKysrKysrKysrKysrCj4+ICAgZHJpdmVycy9ncHUvZHJtL2RybV9hdG9taWNfaGVs cGVyLmMgfCAgNCArKysrCj4+ICAgZHJpdmVycy9ncHUvZHJtL2RybV9tb2RlX2NvbmZpZy5jICAg fCAgNSArKysrKwo+PiAgIGRyaXZlcnMvZ3B1L2RybS9kcm1fcGxhbmUuYyAgICAgICAgIHwgMTIg KysrKysrKysrKysKPj4gICBpbmNsdWRlL2RybS9kcm1fbW9kZV9jb25maWcuaCAgICAgICB8IDE1 ICsrKysrKysrKysrKysKPj4gICBpbmNsdWRlL2RybS9kcm1fcGxhbmUuaCAgICAgICAgICAgICB8 IDE2ICsrKysrKysrKysrKysrCj4+ICAgaW5jbHVkZS91YXBpL2RybS9kcm1fbW9kZS5oICAgICAg ICAgfCAxNSArKysrKysrKysrKysrCj4+ICAgNyBmaWxlcyBjaGFuZ2VkLCAxMDkgaW5zZXJ0aW9u cygrKQo+Pgo+PiBkaWZmIC0tZ2l0IGEvZHJpdmVycy9ncHUvZHJtL2RybV9hdG9taWMuYyBiL2Ry aXZlcnMvZ3B1L2RybS9kcm1fYXRvbWljLmMKPj4gaW5kZXggN2QyNWM0Mi4uOTIyNmQyNCAxMDA2 NDQKPj4gLS0tIGEvZHJpdmVycy9ncHUvZHJtL2RybV9hdG9taWMuYwo+PiArKysgYi9kcml2ZXJz L2dwdS9kcm0vZHJtX2F0b21pYy5jCj4+IEBAIC02NjksNiArNjY5LDQwIEBAIHN0YXRpYyB2b2lk IGRybV9hdG9taWNfY3J0Y19wcmludF9zdGF0ZShzdHJ1Y3QgZHJtX3ByaW50ZXIgKnAsCj4+ICAg fQo+PiAgIAo+PiAgIC8qKgo+PiArICogZHJtX2F0b21pY19zZXRfZGFtYWdlX2Zvcl9wbGFuZSAt IHNldHMgdGhlIGRhbWFnZSBjbGlwcyBwcm9wZXJ0eSB0byBwbGFuZQo+PiArICogQHN0YXRlOiBw bGFuZSBzdGF0ZQo+PiArICogQGJsb2I6IGRhbWFnZSBjbGlwcyBpbiBmcmFtZWJ1ZmZlciBjb29y ZGluYXRlcwo+PiArICoKPj4gKyAqIFJldHVybnM6Cj4+ICsgKgo+PiArICogWmVybyBvbiBzdWNj ZXNzLCBlcnJvciBjb2RlIG9uIGZhaWx1cmUuCj4+ICsgKi8KPj4gK3N0YXRpYyBpbnQgZHJtX2F0 b21pY19zZXRfZGFtYWdlX2Zvcl9wbGFuZShzdHJ1Y3QgZHJtX3BsYW5lX3N0YXRlICpzdGF0ZSwK Pj4gKwkJCQkJICAgc3RydWN0IGRybV9wcm9wZXJ0eV9ibG9iICpibG9iKQo+PiArewo+PiArCWlm IChibG9iID09IHN0YXRlLT5kYW1hZ2VfY2xpcHMpCj4+ICsJCXJldHVybiAwOwo+PiArCj4+ICsJ ZHJtX3Byb3BlcnR5X2Jsb2JfcHV0KHN0YXRlLT5kYW1hZ2VfY2xpcHMpOwo+PiArCXN0YXRlLT5k YW1hZ2VfY2xpcHMgPSBOVUxMOwo+PiArCj4+ICsJaWYgKGJsb2IpIHsKPj4gKwkJdWludDMyX3Qg Y291bnQgPSBibG9iLT5sZW5ndGgvc2l6ZW9mKHN0cnVjdCBkcm1fcmVjdCk7Cj4+ICsKPj4gKwkJ aWYgKGNvdW50ID4gRFJNX01PREVfRkJfRElSVFlfTUFYX0NMSVBTKQo+PiArCQkJcmV0dXJuIC1F SU5WQUw7Cj4+ICsKPj4gKwkJc3RhdGUtPmRhbWFnZV9jbGlwcyA9IGRybV9wcm9wZXJ0eV9ibG9i X2dldChibG9iKTsKPj4gKwkJc3RhdGUtPm51bV9jbGlwcyA9IGNvdW50Owo+PiArCX0gZWxzZSB7 Cj4+ICsJCXN0YXRlLT5kYW1hZ2VfY2xpcHMgPSBOVUxMOwo+PiArCQlzdGF0ZS0+bnVtX2NsaXBz ID0gMDsKPj4gKwl9Cj4+ICsKPj4gKwlyZXR1cm4gMDsKPj4gK30KPj4gKwo+PiArLyoqCj4+ICAg ICogZHJtX2F0b21pY19nZXRfcGxhbmVfc3RhdGUgLSBnZXQgcGxhbmUgc3RhdGUKPj4gICAgKiBA c3RhdGU6IGdsb2JhbCBhdG9taWMgc3RhdGUgb2JqZWN0Cj4+ICAgICogQHBsYW5lOiBwbGFuZSB0 byBnZXQgc3RhdGUgb2JqZWN0IGZvcgo+PiBAQCAtNzkzLDYgKzgyNywxMiBAQCBzdGF0aWMgaW50 IGRybV9hdG9taWNfcGxhbmVfc2V0X3Byb3BlcnR5KHN0cnVjdCBkcm1fcGxhbmUgKnBsYW5lLAo+ PiAgIAkJc3RhdGUtPmNvbG9yX2VuY29kaW5nID0gdmFsOwo+PiAgIAl9IGVsc2UgaWYgKHByb3Bl cnR5ID09IHBsYW5lLT5jb2xvcl9yYW5nZV9wcm9wZXJ0eSkgewo+PiAgIAkJc3RhdGUtPmNvbG9y X3JhbmdlID0gdmFsOwo+PiArCX0gZWxzZSBpZiAocHJvcGVydHkgPT0gY29uZmlnLT5wcm9wX2Rh bWFnZV9jbGlwcykgewo+PiArCQlzdHJ1Y3QgZHJtX3Byb3BlcnR5X2Jsb2IgKmJsb2IgPQo+PiAr CQkJZHJtX3Byb3BlcnR5X2xvb2t1cF9ibG9iKGRldiwgdmFsKTsKPj4gKwkJaW50IHJldCA9IGRy bV9hdG9taWNfc2V0X2RhbWFnZV9mb3JfcGxhbmUoc3RhdGUsIGJsb2IpOwo+IFRoZXJlJ3MgYWxy ZWFkeSBhIGhlbHBlciB3aXRoIHNpemUtY2hlY2tpbmcgYnVpbHQtaW4sIHNlZQo+IGRybV9hdG9t aWNfcmVwbGFjZV9wcm9wZXJ0eV9ibG9iX2Zyb21faWQoKS4gV3J0IGNvbXB1dGluZyBudW1fY2xp cHMgSSdkCj4ganVzdCBwcm92aWRlIGEgbGl0dGxlIGlubGluZSBoZWxwZXIgdGhhdCBkb2VzIHRo ZQo+IGJsb2ItPmxlbmd0aC9zaXplb2YoZHJtX3JlY3QpIGNvbnZlcnNpb24gKGl0J3MganVzdCBh IHNoaWZ0LCBzbyBmYXN0KS4KPgo+PiArCQlkcm1fcHJvcGVydHlfYmxvYl9wdXQoYmxvYik7Cj4+ ICsJCXJldHVybiByZXQ7Cj4+ICAgCX0gZWxzZSBpZiAocGxhbmUtPmZ1bmNzLT5hdG9taWNfc2V0 X3Byb3BlcnR5KSB7Cj4+ICAgCQlyZXR1cm4gcGxhbmUtPmZ1bmNzLT5hdG9taWNfc2V0X3Byb3Bl cnR5KHBsYW5lLCBzdGF0ZSwKPj4gICAJCQkJcHJvcGVydHksIHZhbCk7Cj4+IEBAIC04NTYsNiAr ODk2LDggQEAgZHJtX2F0b21pY19wbGFuZV9nZXRfcHJvcGVydHkoc3RydWN0IGRybV9wbGFuZSAq cGxhbmUsCj4+ICAgCQkqdmFsID0gc3RhdGUtPmNvbG9yX2VuY29kaW5nOwo+PiAgIAl9IGVsc2Ug aWYgKHByb3BlcnR5ID09IHBsYW5lLT5jb2xvcl9yYW5nZV9wcm9wZXJ0eSkgewo+PiAgIAkJKnZh bCA9IHN0YXRlLT5jb2xvcl9yYW5nZTsKPj4gKwl9IGVsc2UgaWYgKHByb3BlcnR5ID09IGNvbmZp Zy0+cHJvcF9kYW1hZ2VfY2xpcHMpIHsKPj4gKwkJKnZhbCA9IChzdGF0ZS0+ZGFtYWdlX2NsaXBz KSA/IHN0YXRlLT5kYW1hZ2VfY2xpcHMtPmJhc2UuaWQgOiAwOwo+PiAgIAl9IGVsc2UgaWYgKHBs YW5lLT5mdW5jcy0+YXRvbWljX2dldF9wcm9wZXJ0eSkgewo+PiAgIAkJcmV0dXJuIHBsYW5lLT5m dW5jcy0+YXRvbWljX2dldF9wcm9wZXJ0eShwbGFuZSwgc3RhdGUsIHByb3BlcnR5LCB2YWwpOwo+ PiAgIAl9IGVsc2Ugewo+PiBkaWZmIC0tZ2l0IGEvZHJpdmVycy9ncHUvZHJtL2RybV9hdG9taWNf aGVscGVyLmMgYi9kcml2ZXJzL2dwdS9kcm0vZHJtX2F0b21pY19oZWxwZXIuYwo+PiBpbmRleCBj MzU2NTQ1Li41NWI0NGUzIDEwMDY0NAo+PiAtLS0gYS9kcml2ZXJzL2dwdS9kcm0vZHJtX2F0b21p Y19oZWxwZXIuYwo+PiArKysgYi9kcml2ZXJzL2dwdS9kcm0vZHJtX2F0b21pY19oZWxwZXIuYwo+ PiBAQCAtMzUwNiw2ICszNTA2LDggQEAgdm9pZCBfX2RybV9hdG9taWNfaGVscGVyX3BsYW5lX2R1 cGxpY2F0ZV9zdGF0ZShzdHJ1Y3QgZHJtX3BsYW5lICpwbGFuZSwKPj4gICAKPj4gICAJc3RhdGUt PmZlbmNlID0gTlVMTDsKPj4gICAJc3RhdGUtPmNvbW1pdCA9IE5VTEw7Cj4+ICsJc3RhdGUtPmRh bWFnZV9jbGlwcyA9IE5VTEw7Cj4+ICsJc3RhdGUtPm51bV9jbGlwcyA9IDA7Cj4+ICAgfQo+PiAg IEVYUE9SVF9TWU1CT0woX19kcm1fYXRvbWljX2hlbHBlcl9wbGFuZV9kdXBsaWNhdGVfc3RhdGUp Owo+PiAgIAo+PiBAQCAtMzU1MCw2ICszNTUyLDggQEAgdm9pZCBfX2RybV9hdG9taWNfaGVscGVy X3BsYW5lX2Rlc3Ryb3lfc3RhdGUoc3RydWN0IGRybV9wbGFuZV9zdGF0ZSAqc3RhdGUpCj4+ICAg Cj4+ICAgCWlmIChzdGF0ZS0+Y29tbWl0KQo+PiAgIAkJZHJtX2NydGNfY29tbWl0X3B1dChzdGF0 ZS0+Y29tbWl0KTsKPj4gKwo+PiArCWRybV9wcm9wZXJ0eV9ibG9iX3B1dChzdGF0ZS0+ZGFtYWdl X2NsaXBzKTsKPj4gICB9Cj4+ICAgRVhQT1JUX1NZTUJPTChfX2RybV9hdG9taWNfaGVscGVyX3Bs YW5lX2Rlc3Ryb3lfc3RhdGUpOwo+PiAgIAo+PiBkaWZmIC0tZ2l0IGEvZHJpdmVycy9ncHUvZHJt L2RybV9tb2RlX2NvbmZpZy5jIGIvZHJpdmVycy9ncHUvZHJtL2RybV9tb2RlX2NvbmZpZy5jCj4+ IGluZGV4IGU1YzY1MzMuLmU5M2IxMjcgMTAwNjQ0Cj4+IC0tLSBhL2RyaXZlcnMvZ3B1L2RybS9k cm1fbW9kZV9jb25maWcuYwo+PiArKysgYi9kcml2ZXJzL2dwdS9kcm0vZHJtX21vZGVfY29uZmln LmMKPj4gQEAgLTI5Myw2ICsyOTMsMTEgQEAgc3RhdGljIGludCBkcm1fbW9kZV9jcmVhdGVfc3Rh bmRhcmRfcHJvcGVydGllcyhzdHJ1Y3QgZHJtX2RldmljZSAqZGV2KQo+PiAgIAkJcmV0dXJuIC1F Tk9NRU07Cj4+ICAgCWRldi0+bW9kZV9jb25maWcucHJvcF9jcnRjX2lkID0gcHJvcDsKPj4gICAK Pj4gKwlwcm9wID0gZHJtX3Byb3BlcnR5X2NyZWF0ZShkZXYsIERSTV9NT0RFX1BST1BfQkxPQiwg IkRBTUFHRV9DTElQUyIsIDApOwo+IEJpdCBhIGJpa2VzaGVkLCBidXQgc2luY2UgdGhlIGNvb3Jk aW5hdGVzIGFyZSBpbiBmYiBwaXhlbHMsIG5vdCBwbGFuZQo+IHBpeGVscywgSSdkIGNhbGwgdGhp cyAiRkJfREFNQUdFX0NMSVBTIi4KPgo+PiArCWlmICghcHJvcCkKPj4gKwkJcmV0dXJuIC1FTk9N RU07Cj4+ICsJZGV2LT5tb2RlX2NvbmZpZy5wcm9wX2RhbWFnZV9jbGlwcyA9IHByb3A7Cj4+ICsK Pj4gICAJcHJvcCA9IGRybV9wcm9wZXJ0eV9jcmVhdGVfYm9vbChkZXYsIERSTV9NT0RFX1BST1Bf QVRPTUlDLAo+PiAgIAkJCSJBQ1RJVkUiKTsKPj4gICAJaWYgKCFwcm9wKQo+PiBkaWZmIC0tZ2l0 IGEvZHJpdmVycy9ncHUvZHJtL2RybV9wbGFuZS5jIGIvZHJpdmVycy9ncHUvZHJtL2RybV9wbGFu ZS5jCj4+IGluZGV4IDZkMmE2ZTQuLjA3MTIyMWIgMTAwNjQ0Cj4+IC0tLSBhL2RyaXZlcnMvZ3B1 L2RybS9kcm1fcGxhbmUuYwo+PiArKysgYi9kcml2ZXJzL2dwdS9kcm0vZHJtX3BsYW5lLmMKPj4g QEAgLTExMDEsMyArMTEwMSwxNSBAQCBpbnQgZHJtX21vZGVfcGFnZV9mbGlwX2lvY3RsKHN0cnVj dCBkcm1fZGV2aWNlICpkZXYsCj4+ICAgCj4+ICAgCXJldHVybiByZXQ7Cj4+ICAgfQo+PiArCj4+ ICsvKioKPj4gKyAqIGRybV9wbGFuZV9lbmFibGVfZGFtYWdlX2NsaXBzIC0gZW5hYmxlIGRhbWFn ZSBjbGlwcyBwcm9wZXJ0eQo+PiArICogQHBsYW5lOiBwbGFuZSBvbiB3aGljaCB0aGlzIHByb3Bl cnR5IHRvIGVuYWJsZS4KPj4gKyAqLwo+PiArdm9pZCBkcm1fcGxhbmVfZW5hYmxlX2RhbWFnZV9j bGlwcyhzdHJ1Y3QgZHJtX3BsYW5lICpwbGFuZSkKPj4gK3sKPj4gKwlzdHJ1Y3QgZHJtX2Rldmlj ZSAqZGV2ID0gcGxhbmUtPmRldjsKPj4gKwlzdHJ1Y3QgZHJtX21vZGVfY29uZmlnICpjb25maWcg PSAmZGV2LT5tb2RlX2NvbmZpZzsKPj4gKwo+PiArCWRybV9vYmplY3RfYXR0YWNoX3Byb3BlcnR5 KCZwbGFuZS0+YmFzZSwgY29uZmlnLT5wcm9wX2RhbWFnZV9jbGlwcywgMCk7Cj4+ICt9Cj4+IGRp ZmYgLS1naXQgYS9pbmNsdWRlL2RybS9kcm1fbW9kZV9jb25maWcuaCBiL2luY2x1ZGUvZHJtL2Ry bV9tb2RlX2NvbmZpZy5oCj4+IGluZGV4IDc1NjlmMjIuLmQ4NzY3ZGEgMTAwNjQ0Cj4+IC0tLSBh L2luY2x1ZGUvZHJtL2RybV9tb2RlX2NvbmZpZy5oCj4+ICsrKyBiL2luY2x1ZGUvZHJtL2RybV9t b2RlX2NvbmZpZy5oCj4+IEBAIC02MjgsNiArNjI4LDIxIEBAIHN0cnVjdCBkcm1fbW9kZV9jb25m aWcgewo+PiAgIAkgKi8KPj4gICAJc3RydWN0IGRybV9wcm9wZXJ0eSAqcHJvcF9jcnRjX2lkOwo+ PiAgIAkvKioKPj4gKwkgKiBAcHJvcF9kYW1hZ2VfY2xpcHM6IE9wdGlvbmFsIHBsYW5lIHByb3Bl cnR5IHRvIG1hcmsgZGFtYWdlZCByZWdpb25zCj4+ICsJICogb24gdGhlIHBsYW5lIGluIGZyYW1l YnVmZmVyIGNvb3JkaW5hdGVzIG9mIHRoZSBmcmFtZWJ1ZmZlciBhdHRhY2hlZAo+PiArCSAqIHRv IHRoZSBwbGFuZS4KPiBXaHkgc2hvdWxkIHdlIG1ha2UgdGhpcyBvcHRpb25hbD8gTG9va3MgbGlr ZSBqdXN0IGFub3RoZXIgdGhpbmcgZHJpdmVycwo+IG1pZ2h0IHNjcmV3IHVwLCBzaW5jZSB3ZSBo YXZlIG11bHRpcGxlIGNhbGxiYWNrcyBhbmQgdGhpbmdzIHRvIHNldCB1cCBmb3IKPiBwcm9wZXIg ZGlydHkgdHJhY2tpbmcuCj4KPiBPbmUgb3B0aW9uIEknbSBzZWVpbmcgaXMgdGhhdCBpZiB0aGlz IGlzIHNldCwgYW5kIGl0J3MgYW4gYXRvbWljIGRyaXZlciwKPiB0aGVuIHdlIGp1c3QgZGlyZWN0 bHkgY2FsbCBpbnRvIHRoZSBkZWZhdWx0IGF0b21pYyBmYi0+ZGlydHkKPiBpbXBsZW1lbnRhdGlv bi4gVGhhdCB3YXkgdGhlcmUncyBvbmx5IDEgdGhpbmcgZHJpdmVycyBuZWVkIHRvIGRvIHRvIHNl dCB1cAo+IGRpcnR5IHJlY3QgdHJhY2tpbmcsIGFuZCB0aGV5J2xsIGdldCBhbGwgb2YgaXQuCj4K Pj4gKwkgKgo+PiArCSAqIFRoZSBsYXlvdXQgb2YgYmxvYiBkYXRhIGlzIHNpbXBseSBhbiBhcnJh eSBvZiBkcm1fbW9kZV9yZWN0IHdpdGgKPj4gKwkgKiBtYXhpbXVtIGFycmF5IHNpemUgbGltaXRl ZCBieSBEUk1fTU9ERV9GQl9ESVJUWV9NQVhfQ0xJUFMuIFVubGlrZQo+PiArCSAqIHBsYW5lIHNy YyBjb29yZGluYXRlcywgZGFtYWdlIGNsaXBzIGFyZSBub3QgaW4gMTYuMTYgZml4ZWQgcG9pbnQu Cj4gSSBob25lc3RseSBoYXZlIG5vIGlkZWEgd2hlcmUgdGhpcyBsaW1pdCBpcyBmcm9tLiBXb3J0 aCBrZWVwaW5nPyBJIGNhbgo+IGVhc2lseSBpbWFnaW5lIHRoYXQgdXNlcnNwYWNlIGNvdWxkIHRy aXAgb3ZlciB0aGlzIC0gaXQncyBmYWlybHkgaGlnaCwgYnV0Cj4gbm90IHVubGltaXRlZC4KPgo+ PiArCSAqCj4+ICsJICogRGFtYWdlIGNsaXBzIGFyZSBhIGhpbnQgdG8ga2VybmVsIGFzIHdoaWNo IGFyZWEgb2YgZnJhbWVidWZmZXIgaGFzCj4+ICsJICogY2hhbmdlZCBzaW5jZSBsYXN0IHBhZ2Ut ZmxpcC4gVGhpcyBzaG91bGQgYmUgaGVscGZ1bAo+PiArCSAqIGZvciBzb21lIGRyaXZlcnMgZXNw ZWNpYWxseSBmb3IgdmlydHVhbCBkZXZpY2VzIHdoZXJlIGVhY2gKPj4gKwkgKiBmcmFtZWJ1ZmZl ciBjaGFuZ2UgbmVlZHMgdG8gYmUgdHJhbnNtaXR0ZWQgb3ZlciBuZXR3b3JrLCB1c2IsIGV0Yy4K PiBJJ2QgYWxzbyBjbGFyaWZ5IHRoYXQgdXNlcnNwYWNlIHN0aWxsIG11c3QgcmVuZGVyIHRoZSBl bnRpcmUgc2NyZWVuLCBpLmUuCj4gbWFrZSBpdCBtb3JlIGNsZWFyIHRoYXQgaXQncyByZWFsbHkg anVzdCBhIGhpbnQgYW5kIG5vdCBtYW5kYXRvcnkgdG8gb25seQo+IHNjYW4gb3V0IHRoZSBkYW1h Z2VkIHBhcnRzLgo+Cj4+ICsJICovCj4+ICsJc3RydWN0IGRybV9wcm9wZXJ0eSAqcHJvcF9kYW1h Z2VfY2xpcHM7Cj4+ICsJLyoqCj4+ICAgCSAqIEBwcm9wX2FjdGl2ZTogRGVmYXVsdCBhdG9taWMg Q1JUQyBwcm9wZXJ0eSB0byBjb250cm9sIHRoZSBhY3RpdmUKPj4gICAJICogc3RhdGUsIHdoaWNo IGlzIHRoZSBzaW1wbGlmaWVkIGltcGxlbWVudGF0aW9uIGZvciBEUE1TIGluIGF0b21pYwo+PiAg IAkgKiBkcml2ZXJzLgo+PiBkaWZmIC0tZ2l0IGEvaW5jbHVkZS9kcm0vZHJtX3BsYW5lLmggYi9p bmNsdWRlL2RybS9kcm1fcGxhbmUuaAo+PiBpbmRleCBmN2JmNGE0Li45ZjI0NTQ4IDEwMDY0NAo+ PiAtLS0gYS9pbmNsdWRlL2RybS9kcm1fcGxhbmUuaAo+PiArKysgYi9pbmNsdWRlL2RybS9kcm1f cGxhbmUuaAo+PiBAQCAtMTQ2LDYgKzE0NiwyMSBAQCBzdHJ1Y3QgZHJtX3BsYW5lX3N0YXRlIHsK Pj4gICAJICovCj4+ICAgCXN0cnVjdCBkcm1fY3J0Y19jb21taXQgKmNvbW1pdDsKPj4gICAKPj4g KwkvKgo+PiArCSAqIEBkYW1hZ2VfY2xpcHMKPj4gKwkgKgo+PiArCSAqIGJsb2IgcHJvcGVydHkg d2l0aCBkYW1hZ2UgYXMgYXJyYXkgb2YgZHJtX3JlY3QgaW4gZnJhbWVidWZmZXIKPiAmZHJtX3Jl Y3QgZ2l2ZXMgeW91IGEgbmljZSBoeXBlcmxpbmsgaW4gdGhlIGdlbmVyYXRlZCBkb2NzLgo+Cj4+ ICsJICogY29vZGluYXRlcy4KPj4gKwkgKi8KPj4gKwlzdHJ1Y3QgZHJtX3Byb3BlcnR5X2Jsb2Ig KmRhbWFnZV9jbGlwczsKPj4gKwo+PiArCS8qCj4+ICsJICogQG51bV9jbGlwcwo+PiArCSAqCj4+ ICsJICogTnVtYmVyIG9mIGRybV9yZWN0IGluIEBkYW1hZ2VfY2xpcHMuCj4+ICsJICovCj4+ICsJ dWludDMyX3QgbnVtX2NsaXBzOwo+PiArCj4+ICAgCXN0cnVjdCBkcm1fYXRvbWljX3N0YXRlICpz dGF0ZTsKPj4gICB9Owo+PiAgIAo+PiBAQCAtNjExLDYgKzYyNiw3IEBAIGludCBkcm1fcGxhbmVf aW5pdChzdHJ1Y3QgZHJtX2RldmljZSAqZGV2LAo+PiAgIAkJICAgY29uc3QgdWludDMyX3QgKmZv cm1hdHMsIHVuc2lnbmVkIGludCBmb3JtYXRfY291bnQsCj4+ICAgCQkgICBib29sIGlzX3ByaW1h cnkpOwo+PiAgIHZvaWQgZHJtX3BsYW5lX2NsZWFudXAoc3RydWN0IGRybV9wbGFuZSAqcGxhbmUp Owo+PiArdm9pZCBkcm1fcGxhbmVfZW5hYmxlX2RhbWFnZV9jbGlwcyhzdHJ1Y3QgZHJtX3BsYW5l ICpwbGFuZSk7Cj4+ICAgCj4+ICAgLyoqCj4+ICAgICogZHJtX3BsYW5lX2luZGV4IC0gZmluZCB0 aGUgaW5kZXggb2YgYSByZWdpc3RlcmVkIHBsYW5lCj4+IGRpZmYgLS1naXQgYS9pbmNsdWRlL3Vh cGkvZHJtL2RybV9tb2RlLmggYi9pbmNsdWRlL3VhcGkvZHJtL2RybV9tb2RlLmgKPj4gaW5kZXgg NTBiY2Y0Mi4uMGFkMGQ1YiAxMDA2NDQKPj4gLS0tIGEvaW5jbHVkZS91YXBpL2RybS9kcm1fbW9k ZS5oCj4+ICsrKyBiL2luY2x1ZGUvdWFwaS9kcm0vZHJtX21vZGUuaAo+PiBAQCAtODczLDYgKzg3 MywyMSBAQCBzdHJ1Y3QgZHJtX21vZGVfcmV2b2tlX2xlYXNlIHsKPj4gICAJX191MzIgbGVzc2Vl X2lkOwo+PiAgIH07Cj4+ICAgCj4+ICsvKioKPj4gKyAqIHN0cnVjdCBkcm1fbW9kZV9yZWN0IC0g dHdvIGRpbWVuc2lvbmFsIHJlY3RhbmdsZSBkcm1fcmVjdCBleHBvcnRlZCB0bwo+PiArICogdXNl ci1zcGFjZS4KPj4gKyAqIEB4MTogaG9yaXpvbnRhbCBzdGFydGluZyBjb29yZGluYXRlIChpbmNs dXNpdmUpCj4+ICsgKiBAeTE6IHZlcnRpY2FsIHN0YXJ0aW5nIGNvb3JkaW5hdGUgKGluY2x1c2l2 ZSkKPj4gKyAqIEB4MjogaG9yaXpvbnRhbCBlbmRpbmcgY29vcmRpbmF0ZSAoZXhjbHVzaXZlKQo+ PiArICogQHkyOiB2ZXJ0aWNhbCBlbmRpbmcgY29vcmRpbmF0ZSAoZXhjbHVzaXZlKQo+PiArICov Cj4+ICtzdHJ1Y3QgZHJtX21vZGVfcmVjdCB7Cj4+ICsJX19zMzIgeDE7Cj4+ICsJX19zMzIgeTE7 Cj4+ICsJX19zMzIgeDI7Cj4+ICsJX19zMzIgeTI7Cj4gV2h5IHNpZ25lZD8gTmVnYXRpdmUgZGFt YWdlIHJlY3RzIG9uIGFuIGZiIGRvbid0IG1ha2Ugc2Vuc2UgdG8gbWUuIEFsc28sCj4gcGxlYXNl IHNwZWNpZnkgd2hhdCB0aGlzIGlzIGV4YWN0bHkgKHRvIGF2b2lkIGNvbmZ1c2lvbiB3aXRoIHRo ZSAxNi4xNgo+IGZpeGVkIHBvaW50IHNyYyByZWN0cyksIGFuZCBtYXliZSBtZW50aW9uIGluIHRo ZSBjb21taXQgbWVzc2FnZSB3aHkgd2UncmUKPiBub3QgdXNpbmcgZHJtX2NsaXBfcmVjdCAoZ29p bmcgdG8gcHJvcGVyIHVhcGkgdHlwZXMgYW5kIDMyYml0IG1ha2VzIHNlbnNlCj4gdG8gbWUpLgoK SU1PLCB3aGlsZSB3ZSBkb24ndCBleHBlY3QgbmVnYXRpdmUgZGFtYWdlIGNvb3JkaW5hdGVzLAp0 byBhdm9pZCB5ZXQgYW5vdGhlciBkcm0gdWFwaSByZWN0IGluIHRoZSBmdXR1cmUgd2hlbiB3ZSBh Y3R1YWxseSBuZWVkIApuZWdhdGl2ZSBudW1iZXJzIHNpZ25lZCBpcyBhIGdvb2QgY2hvaWNlLi4u CgovVGhvbWFzCgoKX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f X18KZHJpLWRldmVsIG1haWxpbmcgbGlzdApkcmktZGV2ZWxAbGlzdHMuZnJlZWRlc2t0b3Aub3Jn Cmh0dHBzOi8vbGlzdHMuZnJlZWRlc2t0b3Aub3JnL21haWxtYW4vbGlzdGluZm8vZHJpLWRldmVs Cg==