From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1752849AbeDEAGc (ORCPT ); Wed, 4 Apr 2018 20:06:32 -0400 Received: from ex13-edg-ou-001.vmware.com ([208.91.0.189]:14300 "EHLO EX13-EDG-OU-001.vmware.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1752353AbeDEAGD (ORCPT ); Wed, 4 Apr 2018 20:06:03 -0400 From: Deepak Rawat To: , , CC: , , , , , , , , , , , Deepak Rawat Subject: [RFC 1/3] drm: Add DAMAGE_CLIPS property to plane Date: Wed, 4 Apr 2018 16:49:06 -0700 Message-ID: <1522885748-67122-2-git-send-email-drawat@vmware.com> X-Mailer: git-send-email 2.7.4 In-Reply-To: <1522885748-67122-1-git-send-email-drawat@vmware.com> References: <1522885748-67122-1-git-send-email-drawat@vmware.com> MIME-Version: 1.0 Content-Type: text/plain Sender: linux-kernel-owner@vger.kernel.org List-ID: X-Mailing-List: linux-kernel@vger.kernel.org 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 --- 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); + 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); + 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. + * + * 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. + */ + 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 + * 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; +}; + #if defined(__cplusplus) } #endif -- 2.7.4 From mboxrd@z Thu Jan 1 00:00:00 1970 From: Deepak Rawat Subject: [RFC 1/3] drm: Add DAMAGE_CLIPS property to plane Date: Wed, 4 Apr 2018 16:49:06 -0700 Message-ID: <1522885748-67122-2-git-send-email-drawat@vmware.com> References: <1522885748-67122-1-git-send-email-drawat@vmware.com> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Return-path: Received: from EX13-EDG-OU-001.vmware.com (ex13-edg-ou-001.vmware.com [208.91.0.189]) by gabe.freedesktop.org (Postfix) with ESMTPS id 3E13A6E654 for ; Wed, 4 Apr 2018 23:51:01 +0000 (UTC) In-Reply-To: <1522885748-67122-1-git-send-email-drawat@vmware.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, thellstrom@vmware.com, syeh@vmware.com Cc: airlied@linux.ie, linux-kernel@vger.kernel.org, linux-graphics-maintainer@vmware.com, Deepak Rawat , lukasz.spintzyk@displaylink.com List-Id: dri-devel@lists.freedesktop.org RnJvbTogTHVrYXN6IFNwaW50enlrIDxsdWthc3ouc3BpbnR6eWtAZGlzcGxheWxpbmsuY29tPgoK T3B0aW9uYWwgcGxhbmUgcHJvcGVydHkgdG8gbWFyayBkYW1hZ2VkIHJlZ2lvbnMgb24gdGhlIHBs YW5lIGluCmZyYW1lYnVmZmVyIGNvb3JkaW5hdGVzIG9mIHRoZSBmcmFtZWJ1ZmZlciBhdHRhY2hl ZCB0byB0aGUgcGxhbmUuCgpUaGUgbGF5b3V0IG9mIGJsb2IgZGF0YSBpcyBzaW1wbHkgYW4gYXJy YXkgb2YgZHJtX21vZGVfcmVjdCB3aXRoIG1heGltdW0KYXJyYXkgc2l6ZSBsaW1pdGVkIGJ5IERS TV9NT0RFX0ZCX0RJUlRZX01BWF9DTElQUy4gVW5saWtlIHBsYW5lIHNyYwpjb29yZGluYXRlcywg ZGFtYWdlIGNsaXBzIGFyZSBub3QgaW4gMTYuMTYgZml4ZWQgcG9pbnQuCgpEYW1hZ2UgY2xpcHMg YXJlIGEgaGludCB0byBrZXJuZWwgYXMgd2hpY2ggYXJlYSBvZiBmcmFtZWJ1ZmZlciBoYXMKY2hh bmdlZCBzaW5jZSBsYXN0IHBhZ2UtZmxpcC4gVGhpcyBzaG91bGQgYmUgaGVscGZ1bCBmb3Igc29t ZSBkcml2ZXJzCmVzcGVjaWFsbHkgZm9yIHZpcnR1YWwgZGV2aWNlcyB3aGVyZSBlYWNoIGZyYW1l YnVmZmVyIGNoYW5nZSBuZWVkcyB0bwpiZSB0cmFuc21pdHRlZCBvdmVyIG5ldHdvcmssIHVzYiwg ZXRjLgoKRHJpdmVyIHdoaWNoIGFyZSBpbnRlcmVzdGVkIGluIGVuYWJsaW5nIERBTUFHRV9DTElQ UyBwcm9wZXJ0eSBmb3IgYQpwbGFuZSBzaG91bGQgZW5hYmxlIHRoaXMgcHJvcGVydHkgdXNpbmcg ZHJtX3BsYW5lX2VuYWJsZV9kYW1hZ2VfY2xpcHMuCgpTaWduZWQtb2ZmLWJ5OiBMdWthc3ogU3Bp bnR6eWsgPGx1a2Fzei5zcGludHp5a0BkaXNwbGF5bGluay5jb20+ClNpZ25lZC1vZmYtYnk6IERl ZXBhayBSYXdhdCA8ZHJhd2F0QHZtd2FyZS5jb20+Ci0tLQogZHJpdmVycy9ncHUvZHJtL2RybV9h dG9taWMuYyAgICAgICAgfCA0MiArKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysr CiBkcml2ZXJzL2dwdS9kcm0vZHJtX2F0b21pY19oZWxwZXIuYyB8ICA0ICsrKysKIGRyaXZlcnMv Z3B1L2RybS9kcm1fbW9kZV9jb25maWcuYyAgIHwgIDUgKysrKysKIGRyaXZlcnMvZ3B1L2RybS9k cm1fcGxhbmUuYyAgICAgICAgIHwgMTIgKysrKysrKysrKysKIGluY2x1ZGUvZHJtL2RybV9tb2Rl X2NvbmZpZy5oICAgICAgIHwgMTUgKysrKysrKysrKysrKwogaW5jbHVkZS9kcm0vZHJtX3BsYW5l LmggICAgICAgICAgICAgfCAxNiArKysrKysrKysrKysrKwogaW5jbHVkZS91YXBpL2RybS9kcm1f bW9kZS5oICAgICAgICAgfCAxNSArKysrKysrKysrKysrCiA3IGZpbGVzIGNoYW5nZWQsIDEwOSBp bnNlcnRpb25zKCspCgpkaWZmIC0tZ2l0IGEvZHJpdmVycy9ncHUvZHJtL2RybV9hdG9taWMuYyBi L2RyaXZlcnMvZ3B1L2RybS9kcm1fYXRvbWljLmMKaW5kZXggN2QyNWM0Mi4uOTIyNmQyNCAxMDA2 NDQKLS0tIGEvZHJpdmVycy9ncHUvZHJtL2RybV9hdG9taWMuYworKysgYi9kcml2ZXJzL2dwdS9k cm0vZHJtX2F0b21pYy5jCkBAIC02NjksNiArNjY5LDQwIEBAIHN0YXRpYyB2b2lkIGRybV9hdG9t aWNfY3J0Y19wcmludF9zdGF0ZShzdHJ1Y3QgZHJtX3ByaW50ZXIgKnAsCiB9CiAKIC8qKgorICog ZHJtX2F0b21pY19zZXRfZGFtYWdlX2Zvcl9wbGFuZSAtIHNldHMgdGhlIGRhbWFnZSBjbGlwcyBw cm9wZXJ0eSB0byBwbGFuZQorICogQHN0YXRlOiBwbGFuZSBzdGF0ZQorICogQGJsb2I6IGRhbWFn ZSBjbGlwcyBpbiBmcmFtZWJ1ZmZlciBjb29yZGluYXRlcworICoKKyAqIFJldHVybnM6CisgKgor ICogWmVybyBvbiBzdWNjZXNzLCBlcnJvciBjb2RlIG9uIGZhaWx1cmUuCisgKi8KK3N0YXRpYyBp bnQgZHJtX2F0b21pY19zZXRfZGFtYWdlX2Zvcl9wbGFuZShzdHJ1Y3QgZHJtX3BsYW5lX3N0YXRl ICpzdGF0ZSwKKwkJCQkJICAgc3RydWN0IGRybV9wcm9wZXJ0eV9ibG9iICpibG9iKQoreworCWlm IChibG9iID09IHN0YXRlLT5kYW1hZ2VfY2xpcHMpCisJCXJldHVybiAwOworCisJZHJtX3Byb3Bl cnR5X2Jsb2JfcHV0KHN0YXRlLT5kYW1hZ2VfY2xpcHMpOworCXN0YXRlLT5kYW1hZ2VfY2xpcHMg PSBOVUxMOworCisJaWYgKGJsb2IpIHsKKwkJdWludDMyX3QgY291bnQgPSBibG9iLT5sZW5ndGgv c2l6ZW9mKHN0cnVjdCBkcm1fcmVjdCk7CisKKwkJaWYgKGNvdW50ID4gRFJNX01PREVfRkJfRElS VFlfTUFYX0NMSVBTKQorCQkJcmV0dXJuIC1FSU5WQUw7CisKKwkJc3RhdGUtPmRhbWFnZV9jbGlw cyA9IGRybV9wcm9wZXJ0eV9ibG9iX2dldChibG9iKTsKKwkJc3RhdGUtPm51bV9jbGlwcyA9IGNv dW50OworCX0gZWxzZSB7CisJCXN0YXRlLT5kYW1hZ2VfY2xpcHMgPSBOVUxMOworCQlzdGF0ZS0+ bnVtX2NsaXBzID0gMDsKKwl9CisKKwlyZXR1cm4gMDsKK30KKworLyoqCiAgKiBkcm1fYXRvbWlj X2dldF9wbGFuZV9zdGF0ZSAtIGdldCBwbGFuZSBzdGF0ZQogICogQHN0YXRlOiBnbG9iYWwgYXRv bWljIHN0YXRlIG9iamVjdAogICogQHBsYW5lOiBwbGFuZSB0byBnZXQgc3RhdGUgb2JqZWN0IGZv cgpAQCAtNzkzLDYgKzgyNywxMiBAQCBzdGF0aWMgaW50IGRybV9hdG9taWNfcGxhbmVfc2V0X3By b3BlcnR5KHN0cnVjdCBkcm1fcGxhbmUgKnBsYW5lLAogCQlzdGF0ZS0+Y29sb3JfZW5jb2Rpbmcg PSB2YWw7CiAJfSBlbHNlIGlmIChwcm9wZXJ0eSA9PSBwbGFuZS0+Y29sb3JfcmFuZ2VfcHJvcGVy dHkpIHsKIAkJc3RhdGUtPmNvbG9yX3JhbmdlID0gdmFsOworCX0gZWxzZSBpZiAocHJvcGVydHkg PT0gY29uZmlnLT5wcm9wX2RhbWFnZV9jbGlwcykgeworCQlzdHJ1Y3QgZHJtX3Byb3BlcnR5X2Js b2IgKmJsb2IgPQorCQkJZHJtX3Byb3BlcnR5X2xvb2t1cF9ibG9iKGRldiwgdmFsKTsKKwkJaW50 IHJldCA9IGRybV9hdG9taWNfc2V0X2RhbWFnZV9mb3JfcGxhbmUoc3RhdGUsIGJsb2IpOworCQlk cm1fcHJvcGVydHlfYmxvYl9wdXQoYmxvYik7CisJCXJldHVybiByZXQ7CiAJfSBlbHNlIGlmIChw bGFuZS0+ZnVuY3MtPmF0b21pY19zZXRfcHJvcGVydHkpIHsKIAkJcmV0dXJuIHBsYW5lLT5mdW5j cy0+YXRvbWljX3NldF9wcm9wZXJ0eShwbGFuZSwgc3RhdGUsCiAJCQkJcHJvcGVydHksIHZhbCk7 CkBAIC04NTYsNiArODk2LDggQEAgZHJtX2F0b21pY19wbGFuZV9nZXRfcHJvcGVydHkoc3RydWN0 IGRybV9wbGFuZSAqcGxhbmUsCiAJCSp2YWwgPSBzdGF0ZS0+Y29sb3JfZW5jb2Rpbmc7CiAJfSBl bHNlIGlmIChwcm9wZXJ0eSA9PSBwbGFuZS0+Y29sb3JfcmFuZ2VfcHJvcGVydHkpIHsKIAkJKnZh bCA9IHN0YXRlLT5jb2xvcl9yYW5nZTsKKwl9IGVsc2UgaWYgKHByb3BlcnR5ID09IGNvbmZpZy0+ cHJvcF9kYW1hZ2VfY2xpcHMpIHsKKwkJKnZhbCA9IChzdGF0ZS0+ZGFtYWdlX2NsaXBzKSA/IHN0 YXRlLT5kYW1hZ2VfY2xpcHMtPmJhc2UuaWQgOiAwOwogCX0gZWxzZSBpZiAocGxhbmUtPmZ1bmNz LT5hdG9taWNfZ2V0X3Byb3BlcnR5KSB7CiAJCXJldHVybiBwbGFuZS0+ZnVuY3MtPmF0b21pY19n ZXRfcHJvcGVydHkocGxhbmUsIHN0YXRlLCBwcm9wZXJ0eSwgdmFsKTsKIAl9IGVsc2UgewpkaWZm IC0tZ2l0IGEvZHJpdmVycy9ncHUvZHJtL2RybV9hdG9taWNfaGVscGVyLmMgYi9kcml2ZXJzL2dw dS9kcm0vZHJtX2F0b21pY19oZWxwZXIuYwppbmRleCBjMzU2NTQ1Li41NWI0NGUzIDEwMDY0NAot LS0gYS9kcml2ZXJzL2dwdS9kcm0vZHJtX2F0b21pY19oZWxwZXIuYworKysgYi9kcml2ZXJzL2dw dS9kcm0vZHJtX2F0b21pY19oZWxwZXIuYwpAQCAtMzUwNiw2ICszNTA2LDggQEAgdm9pZCBfX2Ry bV9hdG9taWNfaGVscGVyX3BsYW5lX2R1cGxpY2F0ZV9zdGF0ZShzdHJ1Y3QgZHJtX3BsYW5lICpw bGFuZSwKIAogCXN0YXRlLT5mZW5jZSA9IE5VTEw7CiAJc3RhdGUtPmNvbW1pdCA9IE5VTEw7CisJ c3RhdGUtPmRhbWFnZV9jbGlwcyA9IE5VTEw7CisJc3RhdGUtPm51bV9jbGlwcyA9IDA7CiB9CiBF WFBPUlRfU1lNQk9MKF9fZHJtX2F0b21pY19oZWxwZXJfcGxhbmVfZHVwbGljYXRlX3N0YXRlKTsK IApAQCAtMzU1MCw2ICszNTUyLDggQEAgdm9pZCBfX2RybV9hdG9taWNfaGVscGVyX3BsYW5lX2Rl c3Ryb3lfc3RhdGUoc3RydWN0IGRybV9wbGFuZV9zdGF0ZSAqc3RhdGUpCiAKIAlpZiAoc3RhdGUt PmNvbW1pdCkKIAkJZHJtX2NydGNfY29tbWl0X3B1dChzdGF0ZS0+Y29tbWl0KTsKKworCWRybV9w cm9wZXJ0eV9ibG9iX3B1dChzdGF0ZS0+ZGFtYWdlX2NsaXBzKTsKIH0KIEVYUE9SVF9TWU1CT0wo X19kcm1fYXRvbWljX2hlbHBlcl9wbGFuZV9kZXN0cm95X3N0YXRlKTsKIApkaWZmIC0tZ2l0IGEv ZHJpdmVycy9ncHUvZHJtL2RybV9tb2RlX2NvbmZpZy5jIGIvZHJpdmVycy9ncHUvZHJtL2RybV9t b2RlX2NvbmZpZy5jCmluZGV4IGU1YzY1MzMuLmU5M2IxMjcgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMv Z3B1L2RybS9kcm1fbW9kZV9jb25maWcuYworKysgYi9kcml2ZXJzL2dwdS9kcm0vZHJtX21vZGVf Y29uZmlnLmMKQEAgLTI5Myw2ICsyOTMsMTEgQEAgc3RhdGljIGludCBkcm1fbW9kZV9jcmVhdGVf c3RhbmRhcmRfcHJvcGVydGllcyhzdHJ1Y3QgZHJtX2RldmljZSAqZGV2KQogCQlyZXR1cm4gLUVO T01FTTsKIAlkZXYtPm1vZGVfY29uZmlnLnByb3BfY3J0Y19pZCA9IHByb3A7CiAKKwlwcm9wID0g ZHJtX3Byb3BlcnR5X2NyZWF0ZShkZXYsIERSTV9NT0RFX1BST1BfQkxPQiwgIkRBTUFHRV9DTElQ UyIsIDApOworCWlmICghcHJvcCkKKwkJcmV0dXJuIC1FTk9NRU07CisJZGV2LT5tb2RlX2NvbmZp Zy5wcm9wX2RhbWFnZV9jbGlwcyA9IHByb3A7CisKIAlwcm9wID0gZHJtX3Byb3BlcnR5X2NyZWF0 ZV9ib29sKGRldiwgRFJNX01PREVfUFJPUF9BVE9NSUMsCiAJCQkiQUNUSVZFIik7CiAJaWYgKCFw cm9wKQpkaWZmIC0tZ2l0IGEvZHJpdmVycy9ncHUvZHJtL2RybV9wbGFuZS5jIGIvZHJpdmVycy9n cHUvZHJtL2RybV9wbGFuZS5jCmluZGV4IDZkMmE2ZTQuLjA3MTIyMWIgMTAwNjQ0Ci0tLSBhL2Ry aXZlcnMvZ3B1L2RybS9kcm1fcGxhbmUuYworKysgYi9kcml2ZXJzL2dwdS9kcm0vZHJtX3BsYW5l LmMKQEAgLTExMDEsMyArMTEwMSwxNSBAQCBpbnQgZHJtX21vZGVfcGFnZV9mbGlwX2lvY3RsKHN0 cnVjdCBkcm1fZGV2aWNlICpkZXYsCiAKIAlyZXR1cm4gcmV0OwogfQorCisvKioKKyAqIGRybV9w bGFuZV9lbmFibGVfZGFtYWdlX2NsaXBzIC0gZW5hYmxlIGRhbWFnZSBjbGlwcyBwcm9wZXJ0eQor ICogQHBsYW5lOiBwbGFuZSBvbiB3aGljaCB0aGlzIHByb3BlcnR5IHRvIGVuYWJsZS4KKyAqLwor dm9pZCBkcm1fcGxhbmVfZW5hYmxlX2RhbWFnZV9jbGlwcyhzdHJ1Y3QgZHJtX3BsYW5lICpwbGFu ZSkKK3sKKwlzdHJ1Y3QgZHJtX2RldmljZSAqZGV2ID0gcGxhbmUtPmRldjsKKwlzdHJ1Y3QgZHJt X21vZGVfY29uZmlnICpjb25maWcgPSAmZGV2LT5tb2RlX2NvbmZpZzsKKworCWRybV9vYmplY3Rf YXR0YWNoX3Byb3BlcnR5KCZwbGFuZS0+YmFzZSwgY29uZmlnLT5wcm9wX2RhbWFnZV9jbGlwcywg MCk7Cit9CmRpZmYgLS1naXQgYS9pbmNsdWRlL2RybS9kcm1fbW9kZV9jb25maWcuaCBiL2luY2x1 ZGUvZHJtL2RybV9tb2RlX2NvbmZpZy5oCmluZGV4IDc1NjlmMjIuLmQ4NzY3ZGEgMTAwNjQ0Ci0t LSBhL2luY2x1ZGUvZHJtL2RybV9tb2RlX2NvbmZpZy5oCisrKyBiL2luY2x1ZGUvZHJtL2RybV9t b2RlX2NvbmZpZy5oCkBAIC02MjgsNiArNjI4LDIxIEBAIHN0cnVjdCBkcm1fbW9kZV9jb25maWcg ewogCSAqLwogCXN0cnVjdCBkcm1fcHJvcGVydHkgKnByb3BfY3J0Y19pZDsKIAkvKioKKwkgKiBA cHJvcF9kYW1hZ2VfY2xpcHM6IE9wdGlvbmFsIHBsYW5lIHByb3BlcnR5IHRvIG1hcmsgZGFtYWdl ZCByZWdpb25zCisJICogb24gdGhlIHBsYW5lIGluIGZyYW1lYnVmZmVyIGNvb3JkaW5hdGVzIG9m IHRoZSBmcmFtZWJ1ZmZlciBhdHRhY2hlZAorCSAqIHRvIHRoZSBwbGFuZS4KKwkgKgorCSAqIFRo ZSBsYXlvdXQgb2YgYmxvYiBkYXRhIGlzIHNpbXBseSBhbiBhcnJheSBvZiBkcm1fbW9kZV9yZWN0 IHdpdGgKKwkgKiBtYXhpbXVtIGFycmF5IHNpemUgbGltaXRlZCBieSBEUk1fTU9ERV9GQl9ESVJU WV9NQVhfQ0xJUFMuIFVubGlrZQorCSAqIHBsYW5lIHNyYyBjb29yZGluYXRlcywgZGFtYWdlIGNs aXBzIGFyZSBub3QgaW4gMTYuMTYgZml4ZWQgcG9pbnQuCisJICoKKwkgKiBEYW1hZ2UgY2xpcHMg YXJlIGEgaGludCB0byBrZXJuZWwgYXMgd2hpY2ggYXJlYSBvZiBmcmFtZWJ1ZmZlciBoYXMKKwkg KiBjaGFuZ2VkIHNpbmNlIGxhc3QgcGFnZS1mbGlwLiBUaGlzIHNob3VsZCBiZSBoZWxwZnVsCisJ ICogZm9yIHNvbWUgZHJpdmVycyBlc3BlY2lhbGx5IGZvciB2aXJ0dWFsIGRldmljZXMgd2hlcmUg ZWFjaAorCSAqIGZyYW1lYnVmZmVyIGNoYW5nZSBuZWVkcyB0byBiZSB0cmFuc21pdHRlZCBvdmVy IG5ldHdvcmssIHVzYiwgZXRjLgorCSAqLworCXN0cnVjdCBkcm1fcHJvcGVydHkgKnByb3BfZGFt YWdlX2NsaXBzOworCS8qKgogCSAqIEBwcm9wX2FjdGl2ZTogRGVmYXVsdCBhdG9taWMgQ1JUQyBw cm9wZXJ0eSB0byBjb250cm9sIHRoZSBhY3RpdmUKIAkgKiBzdGF0ZSwgd2hpY2ggaXMgdGhlIHNp bXBsaWZpZWQgaW1wbGVtZW50YXRpb24gZm9yIERQTVMgaW4gYXRvbWljCiAJICogZHJpdmVycy4K ZGlmZiAtLWdpdCBhL2luY2x1ZGUvZHJtL2RybV9wbGFuZS5oIGIvaW5jbHVkZS9kcm0vZHJtX3Bs YW5lLmgKaW5kZXggZjdiZjRhNC4uOWYyNDU0OCAxMDA2NDQKLS0tIGEvaW5jbHVkZS9kcm0vZHJt X3BsYW5lLmgKKysrIGIvaW5jbHVkZS9kcm0vZHJtX3BsYW5lLmgKQEAgLTE0Niw2ICsxNDYsMjEg QEAgc3RydWN0IGRybV9wbGFuZV9zdGF0ZSB7CiAJICovCiAJc3RydWN0IGRybV9jcnRjX2NvbW1p dCAqY29tbWl0OwogCisJLyoKKwkgKiBAZGFtYWdlX2NsaXBzCisJICoKKwkgKiBibG9iIHByb3Bl cnR5IHdpdGggZGFtYWdlIGFzIGFycmF5IG9mIGRybV9yZWN0IGluIGZyYW1lYnVmZmVyCisJICog Y29vZGluYXRlcy4KKwkgKi8KKwlzdHJ1Y3QgZHJtX3Byb3BlcnR5X2Jsb2IgKmRhbWFnZV9jbGlw czsKKworCS8qCisJICogQG51bV9jbGlwcworCSAqCisJICogTnVtYmVyIG9mIGRybV9yZWN0IGlu IEBkYW1hZ2VfY2xpcHMuCisJICovCisJdWludDMyX3QgbnVtX2NsaXBzOworCiAJc3RydWN0IGRy bV9hdG9taWNfc3RhdGUgKnN0YXRlOwogfTsKIApAQCAtNjExLDYgKzYyNiw3IEBAIGludCBkcm1f cGxhbmVfaW5pdChzdHJ1Y3QgZHJtX2RldmljZSAqZGV2LAogCQkgICBjb25zdCB1aW50MzJfdCAq Zm9ybWF0cywgdW5zaWduZWQgaW50IGZvcm1hdF9jb3VudCwKIAkJICAgYm9vbCBpc19wcmltYXJ5 KTsKIHZvaWQgZHJtX3BsYW5lX2NsZWFudXAoc3RydWN0IGRybV9wbGFuZSAqcGxhbmUpOwordm9p ZCBkcm1fcGxhbmVfZW5hYmxlX2RhbWFnZV9jbGlwcyhzdHJ1Y3QgZHJtX3BsYW5lICpwbGFuZSk7 CiAKIC8qKgogICogZHJtX3BsYW5lX2luZGV4IC0gZmluZCB0aGUgaW5kZXggb2YgYSByZWdpc3Rl cmVkIHBsYW5lCmRpZmYgLS1naXQgYS9pbmNsdWRlL3VhcGkvZHJtL2RybV9tb2RlLmggYi9pbmNs dWRlL3VhcGkvZHJtL2RybV9tb2RlLmgKaW5kZXggNTBiY2Y0Mi4uMGFkMGQ1YiAxMDA2NDQKLS0t IGEvaW5jbHVkZS91YXBpL2RybS9kcm1fbW9kZS5oCisrKyBiL2luY2x1ZGUvdWFwaS9kcm0vZHJt X21vZGUuaApAQCAtODczLDYgKzg3MywyMSBAQCBzdHJ1Y3QgZHJtX21vZGVfcmV2b2tlX2xlYXNl IHsKIAlfX3UzMiBsZXNzZWVfaWQ7CiB9OwogCisvKioKKyAqIHN0cnVjdCBkcm1fbW9kZV9yZWN0 IC0gdHdvIGRpbWVuc2lvbmFsIHJlY3RhbmdsZSBkcm1fcmVjdCBleHBvcnRlZCB0bworICogdXNl ci1zcGFjZS4KKyAqIEB4MTogaG9yaXpvbnRhbCBzdGFydGluZyBjb29yZGluYXRlIChpbmNsdXNp dmUpCisgKiBAeTE6IHZlcnRpY2FsIHN0YXJ0aW5nIGNvb3JkaW5hdGUgKGluY2x1c2l2ZSkKKyAq IEB4MjogaG9yaXpvbnRhbCBlbmRpbmcgY29vcmRpbmF0ZSAoZXhjbHVzaXZlKQorICogQHkyOiB2 ZXJ0aWNhbCBlbmRpbmcgY29vcmRpbmF0ZSAoZXhjbHVzaXZlKQorICovCitzdHJ1Y3QgZHJtX21v ZGVfcmVjdCB7CisJX19zMzIgeDE7CisJX19zMzIgeTE7CisJX19zMzIgeDI7CisJX19zMzIgeTI7 Cit9OworCiAjaWYgZGVmaW5lZChfX2NwbHVzcGx1cykKIH0KICNlbmRpZgotLSAKMi43LjQKCl9f X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fCmRyaS1kZXZlbCBt YWlsaW5nIGxpc3QKZHJpLWRldmVsQGxpc3RzLmZyZWVkZXNrdG9wLm9yZwpodHRwczovL2xpc3Rz LmZyZWVkZXNrdG9wLm9yZy9tYWlsbWFuL2xpc3RpbmZvL2RyaS1kZXZlbAo=