From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org X-Spam-Level: X-Spam-Status: No, score=-9.7 required=3.0 tests=HEADER_FROM_DIFFERENT_DOMAINS, INCLUDES_PATCH,MAILING_LIST_MULTI,SIGNED_OFF_BY,SPF_HELO_NONE,SPF_PASS, URIBL_BLOCKED,USER_AGENT_GIT autolearn=ham autolearn_force=no version=3.4.0 Received: from mail.kernel.org (mail.kernel.org [198.145.29.99]) by smtp.lore.kernel.org (Postfix) with ESMTP id 6CC40CA9EB9 for ; Wed, 23 Oct 2019 15:45:28 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [209.132.180.67]) by mail.kernel.org (Postfix) with ESMTP id 3B54A2084C for ; Wed, 23 Oct 2019 15:45:28 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S2406910AbfJWPp1 (ORCPT ); Wed, 23 Oct 2019 11:45:27 -0400 Received: from bhuna.collabora.co.uk ([46.235.227.227]:37738 "EHLO bhuna.collabora.co.uk" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S2404032AbfJWPp1 (ORCPT ); Wed, 23 Oct 2019 11:45:27 -0400 Received: from localhost.localdomain (unknown [IPv6:2a01:e0a:2c:6930:5cf4:84a1:2763:fe0d]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) (Authenticated sender: bbrezillon) by bhuna.collabora.co.uk (Postfix) with ESMTPSA id 2F96528F905; Wed, 23 Oct 2019 16:45:25 +0100 (BST) From: Boris Brezillon To: dri-devel@lists.freedesktop.org Cc: Lucas Stach , Chris Healy , Andrey Smirnov , Nikita Yushchenko , kernel@collabora.com, Daniel Vetter , Inki Dae , Joonyoung Shim , Seung-Woo Kim , Kyungmin Park , Thierry Reding , Sam Ravnborg , Philipp Zabel , Rob Clark , Andrzej Hajda , Neil Armstrong , Laurent Pinchart , Jonas Karlman , Jernej Skrabec , Rob Herring , Mark Rutland , devicetree@vger.kernel.org, Boris Brezillon Subject: [PATCH v3 09/21] drm/bridge: Add a drm_bridge_state object Date: Wed, 23 Oct 2019 17:45:00 +0200 Message-Id: <20191023154512.9762-10-boris.brezillon@collabora.com> X-Mailer: git-send-email 2.21.0 In-Reply-To: <20191023154512.9762-1-boris.brezillon@collabora.com> References: <20191023154512.9762-1-boris.brezillon@collabora.com> MIME-Version: 1.0 Content-Transfer-Encoding: 8bit Sender: devicetree-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: devicetree@vger.kernel.org One of the last remaining objects to not have its atomic state. This is being motivated by our attempt to support runtime bus-format negotiation between elements of the bridge chain. This patch just paves the road for such a feature by adding a new drm_bridge_state object inheriting from drm_private_obj so we can re-use some of the existing state initialization/tracking logic. Signed-off-by: Boris Brezillon --- Changes in v3: * None Changes in v2: * Use drm_for_each_bridge_in_chain() * Rename helpers to be more consistent with the rest of the DRM API * Improve/fix the doc --- drivers/gpu/drm/drm_atomic.c | 39 +++++++ drivers/gpu/drm/drm_atomic_helper.c | 20 ++++ drivers/gpu/drm/drm_bridge.c | 168 +++++++++++++++++++++++++++- include/drm/drm_atomic.h | 3 + include/drm/drm_bridge.h | 118 +++++++++++++++++++ 5 files changed, 343 insertions(+), 5 deletions(-) diff --git a/drivers/gpu/drm/drm_atomic.c b/drivers/gpu/drm/drm_atomic.c index 419381abbdd1..6c249ce39380 100644 --- a/drivers/gpu/drm/drm_atomic.c +++ b/drivers/gpu/drm/drm_atomic.c @@ -30,6 +30,7 @@ #include #include +#include #include #include #include @@ -1010,6 +1011,44 @@ static void drm_atomic_connector_print_state(struct drm_printer *p, connector->funcs->atomic_print_state(p, state); } +/** + * drm_atomic_add_encoder_bridges - add bridges attached to an encoder + * @state: atomic state + * @encoder: DRM encoder + * + * This function adds all bridges attached to @encoder. This is needed to add + * bridge states to @state and make them available when + * &bridge_funcs.atomic_{check,pre_enable,enable,disable_post_disable}() are + * called + * + * Returns: + * 0 on success or can fail with -EDEADLK or -ENOMEM. When the error is EDEADLK + * then the w/w mutex code has detected a deadlock and the entire atomic + * sequence must be restarted. All other errors are fatal. + */ +int +drm_atomic_add_encoder_bridges(struct drm_atomic_state *state, + struct drm_encoder *encoder) +{ + struct drm_bridge_state *bridge_state; + struct drm_bridge *bridge; + + if (!encoder) + return 0; + + DRM_DEBUG_ATOMIC("Adding all bridges for [encoder:%d:%s] to %p\n", + encoder->base.id, encoder->name, state); + + drm_for_each_bridge_in_chain(encoder, bridge) { + bridge_state = drm_atomic_get_bridge_state(state, bridge); + if (IS_ERR(bridge_state)) + return PTR_ERR(bridge_state); + } + + return 0; +} +EXPORT_SYMBOL(drm_atomic_add_encoder_bridges); + /** * drm_atomic_add_affected_connectors - add connectors for crtc * @state: atomic state diff --git a/drivers/gpu/drm/drm_atomic_helper.c b/drivers/gpu/drm/drm_atomic_helper.c index f02ddffd4960..de985ba7ce2d 100644 --- a/drivers/gpu/drm/drm_atomic_helper.c +++ b/drivers/gpu/drm/drm_atomic_helper.c @@ -730,6 +730,26 @@ drm_atomic_helper_check_modeset(struct drm_device *dev, return ret; } + /* + * Iterate over all connectors again, and add all affected bridges to + * the state. + */ + for_each_oldnew_connector_in_state(state, connector, + old_connector_state, + new_connector_state, i) { + struct drm_encoder *encoder; + + encoder = old_connector_state->best_encoder; + ret = drm_atomic_add_encoder_bridges(state, encoder); + if (ret) + return ret; + + encoder = new_connector_state->best_encoder; + ret = drm_atomic_add_encoder_bridges(state, encoder); + if (ret) + return ret; + } + ret = mode_valid(state); if (ret) return ret; diff --git a/drivers/gpu/drm/drm_bridge.c b/drivers/gpu/drm/drm_bridge.c index c5cf8a9c4237..c53966767782 100644 --- a/drivers/gpu/drm/drm_bridge.c +++ b/drivers/gpu/drm/drm_bridge.c @@ -25,6 +25,7 @@ #include #include +#include #include #include @@ -89,6 +90,38 @@ void drm_bridge_remove(struct drm_bridge *bridge) } EXPORT_SYMBOL(drm_bridge_remove); +static struct drm_private_state * +drm_bridge_atomic_duplicate_priv_state(struct drm_private_obj *obj) +{ + struct drm_bridge *bridge = drm_priv_to_bridge(obj); + struct drm_bridge_state *state; + + if (bridge->funcs->atomic_duplicate_state) + state = bridge->funcs->atomic_duplicate_state(bridge); + else + state = drm_atomic_helper_bridge_duplicate_state(bridge); + + return &state->base; +} + +static void +drm_bridge_atomic_destroy_priv_state(struct drm_private_obj *obj, + struct drm_private_state *s) +{ + struct drm_bridge_state *state = drm_priv_to_bridge_state(s); + struct drm_bridge *bridge = drm_priv_to_bridge(obj); + + if (bridge->funcs->atomic_destroy_state) + bridge->funcs->atomic_destroy_state(bridge, state); + else + drm_atomic_helper_bridge_destroy_state(bridge, state); +} + +static const struct drm_private_state_funcs drm_bridge_priv_state_funcs = { + .atomic_duplicate_state = drm_bridge_atomic_duplicate_priv_state, + .atomic_destroy_state = drm_bridge_atomic_destroy_priv_state, +}; + /** * drm_bridge_attach - attach the bridge to an encoder's chain * @@ -114,6 +147,7 @@ EXPORT_SYMBOL(drm_bridge_remove); int drm_bridge_attach(struct drm_encoder *encoder, struct drm_bridge *bridge, struct drm_bridge *previous) { + struct drm_bridge_state *state; LIST_HEAD(tmp_list); int ret; @@ -132,19 +166,39 @@ int drm_bridge_attach(struct drm_encoder *encoder, struct drm_bridge *bridge, if (bridge->funcs->attach) { ret = bridge->funcs->attach(bridge); - if (ret < 0) { - bridge->dev = NULL; - bridge->encoder = NULL; - return ret; - } + if (ret < 0) + goto err_reset_bridge; } + if (bridge->funcs->atomic_reset) + state = bridge->funcs->atomic_reset(bridge); + else + state = drm_atomic_helper_bridge_reset(bridge); + + if (IS_ERR(state)) { + ret = PTR_ERR(state); + goto err_detach_bridge; + } + + drm_atomic_private_obj_init(bridge->dev, &bridge->base, + &state->base, + &drm_bridge_priv_state_funcs); + if (previous) list_splice(&tmp_list, &previous->chain_node); else list_splice(&tmp_list, &encoder->bridge_chain); return 0; + +err_detach_bridge: + if (bridge->funcs->detach) + bridge->funcs->detach(bridge); + +err_reset_bridge: + bridge->dev = NULL; + bridge->encoder = NULL; + return ret; } EXPORT_SYMBOL(drm_bridge_attach); @@ -156,6 +210,8 @@ void drm_bridge_detach(struct drm_bridge *bridge) if (WARN_ON(!bridge->dev)) return; + drm_atomic_private_obj_fini(&bridge->base); + if (bridge->funcs->detach) bridge->funcs->detach(bridge); @@ -522,6 +578,108 @@ void drm_atomic_bridge_chain_enable(struct drm_bridge *bridge, } EXPORT_SYMBOL(drm_atomic_bridge_chain_enable); +/** + * drm_atomic_helper_bridge_destroy_state() - Default destroy state helper + * @bridge: the bridge this state refers to + * @state: state object to destroy + * + * Just a simple kfree() for now. + */ +void drm_atomic_helper_bridge_destroy_state(struct drm_bridge *bridge, + struct drm_bridge_state *state) +{ + kfree(state); +} +EXPORT_SYMBOL(drm_atomic_helper_bridge_destroy_state); + +/** + * __drm_atomic_helper_bridge_reset() - Initialize a bridge state to its + * default + * @bridge: the bridge this state is refers to + * @state: bridge state to initialize + * + * For now it's just a memset(0) plus a state->bridge assignment. Might + * be extended in the future. + */ +void __drm_atomic_helper_bridge_reset(struct drm_bridge *bridge, + struct drm_bridge_state *state) +{ + memset(state, 0, sizeof(*state)); + state->bridge = bridge; +} +EXPORT_SYMBOL(__drm_atomic_helper_bridge_reset); + +/** + * drm_atomic_helper_bridge_reset() - default &drm_plane_funcs.reset hook for + * bridges + * @bridge: the bridge to reset state on + * + * Resets the atomic state for @bridge by freeing the state pointer (which + * might be NULL, e.g. at driver load time) and allocating a new empty state + * object. + * + * RETURNS: + * A valid drm_bridge_state object in case of success, an ERR_PTR() + * giving the reaon of the failure otherwise. + */ +struct drm_bridge_state * +drm_atomic_helper_bridge_reset(struct drm_bridge *bridge) +{ + struct drm_bridge_state *bridge_state; + + bridge_state = kzalloc(sizeof(*bridge_state), GFP_KERNEL); + if (!bridge_state) + return ERR_PTR(-ENOMEM); + + __drm_atomic_helper_bridge_reset(bridge, bridge_state); + return bridge_state; +} +EXPORT_SYMBOL(drm_atomic_helper_bridge_reset); + +/** + * __drm_atomic_helper_bridge_duplicate_state() - Copy the content of the + * current bridge state into a + * new one + * @bridge: bridge element the old and new states are referring to + * @new: new bridge state to copy to + * + * Should be used by custom &drm_bridge_funcs.atomic_duplicate() implementation + * to copy the previous state into the new object. + */ +void __drm_atomic_helper_bridge_duplicate_state(struct drm_bridge *bridge, + struct drm_bridge_state *new) +{ + __drm_atomic_helper_private_obj_duplicate_state(&bridge->base, + &new->base); + new->bridge = bridge; +} +EXPORT_SYMBOL(__drm_atomic_helper_bridge_duplicate_state); + +/** + * drm_atomic_helper_duplicate_bridge_state() - Default duplicate state helper + * @bridge: bridge containing the state to duplicate + * + * Default implementation of &drm_bridge_funcs.atomic_duplicate(). + * + * RETURNS: + * a valid state object or NULL if the allocation fails. + */ +struct drm_bridge_state * +drm_atomic_helper_bridge_duplicate_state(struct drm_bridge *bridge) +{ + struct drm_bridge_state *new; + + if (WARN_ON(!bridge->base.state)) + return NULL; + + new = kzalloc(sizeof(*new), GFP_KERNEL); + if (new) + __drm_atomic_helper_bridge_duplicate_state(bridge, new); + + return new; +} +EXPORT_SYMBOL(drm_atomic_helper_bridge_duplicate_state); + #ifdef CONFIG_OF /** * of_drm_find_bridge - find the bridge corresponding to the device node in diff --git a/include/drm/drm_atomic.h b/include/drm/drm_atomic.h index 927e1205d7aa..1c0a08217712 100644 --- a/include/drm/drm_atomic.h +++ b/include/drm/drm_atomic.h @@ -660,6 +660,9 @@ __drm_atomic_get_current_plane_state(struct drm_atomic_state *state, return plane->state; } +int __must_check +drm_atomic_add_encoder_bridges(struct drm_atomic_state *state, + struct drm_encoder *encoder); int __must_check drm_atomic_add_affected_connectors(struct drm_atomic_state *state, struct drm_crtc *crtc); diff --git a/include/drm/drm_bridge.h b/include/drm/drm_bridge.h index 238e84ab63a3..a608c47d1de5 100644 --- a/include/drm/drm_bridge.h +++ b/include/drm/drm_bridge.h @@ -25,6 +25,7 @@ #include #include +#include #include #include #include @@ -33,6 +34,23 @@ struct drm_bridge; struct drm_bridge_timings; struct drm_panel; +/** + * struct drm_bridge_state - Atomic bridge state object + * @base: inherit from &drm_private_state + * @bridge: the bridge this state refers to + */ +struct drm_bridge_state { + struct drm_private_state base; + + struct drm_bridge *bridge; +}; + +static inline struct drm_bridge_state * +drm_priv_to_bridge_state(struct drm_private_state *priv) +{ + return container_of(priv, struct drm_bridge_state, base); +} + /** * struct drm_bridge_funcs - drm_bridge control functions */ @@ -338,6 +356,48 @@ struct drm_bridge_funcs { */ void (*atomic_post_disable)(struct drm_bridge *bridge, struct drm_atomic_state *state); + + /** + * @atomic_duplicate_state: + * + * Duplicate the current bridge state object (which is guaranteed to be + * non-NULL). + * + * The atomic_duplicate_state() is optional, the core falls back on + * &drm_atomic_helper_bridge_duplicate_state() when not implemented. + * + * RETURNS: + * A valid drm_bridge_state object or NULL if the allocation fails. + */ + struct drm_bridge_state *(*atomic_duplicate_state)(struct drm_bridge *bridge); + + /** + * @atomic_destroy_state: + * + * Destroy a bridge state object previously allocated by + * &drm_bridge_funcs.atomic_duplicate_state(). + * + * The atomic_destroy_state hook is optional, the coref falls back on + * &drm_atomic_helper_bridge_destroy_state() when not implemented. + */ + void (*atomic_destroy_state)(struct drm_bridge *bridge, + struct drm_bridge_state *state); + + /** + * @atomic_reset: + * + * Reset the bridge to a predefined state (or retrieve its current + * state) and return a &drm_bridge_state object matching this state. + * This function is called at attach time. + * + * The atomic_reset hook is optional, the core falls back on + * &drm_atomic_helper_bridge_reset() when not implemented. + * + * RETURNS: + * A valid drm_bridge_state object in case of success, an ERR_PTR() + * giving the reaon of the failure otherwise. + */ + struct drm_bridge_state *(*atomic_reset)(struct drm_bridge *bridge); }; /** @@ -380,6 +440,8 @@ struct drm_bridge_timings { * struct drm_bridge - central DRM bridge control structure */ struct drm_bridge { + /** @base: inherit from &drm_private_object */ + struct drm_private_obj base; /** @dev: DRM device this bridge belongs to */ struct drm_device *dev; /** @encoder: encoder to which this bridge is connected */ @@ -404,6 +466,12 @@ struct drm_bridge { void *driver_private; }; +static inline struct drm_bridge * +drm_priv_to_bridge(struct drm_private_obj *priv) +{ + return container_of(priv, struct drm_bridge, base); +} + void drm_bridge_add(struct drm_bridge *bridge); void drm_bridge_remove(struct drm_bridge *bridge); struct drm_bridge *of_drm_find_bridge(struct device_node *np); @@ -475,6 +543,56 @@ void drm_atomic_bridge_chain_pre_enable(struct drm_bridge *bridge, void drm_atomic_bridge_chain_enable(struct drm_bridge *bridge, struct drm_atomic_state *state); +void __drm_atomic_helper_bridge_reset(struct drm_bridge *bridge, + struct drm_bridge_state *state); +struct drm_bridge_state * +drm_atomic_helper_bridge_reset(struct drm_bridge *bridge); +void drm_atomic_helper_bridge_destroy_state(struct drm_bridge *bridge, + struct drm_bridge_state *state); +void __drm_atomic_helper_bridge_duplicate_state(struct drm_bridge *bridge, + struct drm_bridge_state *new); +struct drm_bridge_state * +drm_atomic_helper_bridge_duplicate_state(struct drm_bridge *bridge); + +static inline struct drm_bridge_state * +drm_atomic_get_bridge_state(struct drm_atomic_state *state, + struct drm_bridge *bridge) +{ + struct drm_private_state *obj_state; + + obj_state = drm_atomic_get_private_obj_state(state, &bridge->base); + if (!obj_state) + return NULL; + + return drm_priv_to_bridge_state(obj_state); +} + +static inline struct drm_bridge_state * +drm_atomic_get_old_bridge_state(struct drm_atomic_state *state, + struct drm_bridge *bridge) +{ + struct drm_private_state *obj_state; + + obj_state = drm_atomic_get_old_private_obj_state(state, &bridge->base); + if (!obj_state) + return NULL; + + return drm_priv_to_bridge_state(obj_state); +} + +static inline struct drm_bridge_state * +drm_atomic_get_new_bridge_state(struct drm_atomic_state *state, + struct drm_bridge *bridge) +{ + struct drm_private_state *obj_state; + + obj_state = drm_atomic_get_new_private_obj_state(state, &bridge->base); + if (!obj_state) + return NULL; + + return drm_priv_to_bridge_state(obj_state); +} + #ifdef CONFIG_DRM_PANEL_BRIDGE struct drm_bridge *drm_panel_bridge_add(struct drm_panel *panel); struct drm_bridge *drm_panel_bridge_add_typed(struct drm_panel *panel, -- 2.21.0 From mboxrd@z Thu Jan 1 00:00:00 1970 From: Boris Brezillon Subject: [PATCH v3 09/21] drm/bridge: Add a drm_bridge_state object Date: Wed, 23 Oct 2019 17:45:00 +0200 Message-ID: <20191023154512.9762-10-boris.brezillon@collabora.com> References: <20191023154512.9762-1-boris.brezillon@collabora.com> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Return-path: Received: from bhuna.collabora.co.uk (bhuna.collabora.co.uk [46.235.227.227]) by gabe.freedesktop.org (Postfix) with ESMTPS id 97DD88959D for ; Wed, 23 Oct 2019 15:45:27 +0000 (UTC) In-Reply-To: <20191023154512.9762-1-boris.brezillon@collabora.com> List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: dri-devel-bounces@lists.freedesktop.org Sender: "dri-devel" To: dri-devel@lists.freedesktop.org Cc: Mark Rutland , Neil Armstrong , Thierry Reding , Laurent Pinchart , kernel@collabora.com, Sam Ravnborg , Nikita Yushchenko , Andrey Smirnov , Kyungmin Park , Chris Healy , devicetree@vger.kernel.org, Jonas Karlman , Rob Herring , Jernej Skrabec , Seung-Woo Kim , Boris Brezillon List-Id: dri-devel@lists.freedesktop.org T25lIG9mIHRoZSBsYXN0IHJlbWFpbmluZyBvYmplY3RzIHRvIG5vdCBoYXZlIGl0cyBhdG9taWMg c3RhdGUuCgpUaGlzIGlzIGJlaW5nIG1vdGl2YXRlZCBieSBvdXIgYXR0ZW1wdCB0byBzdXBwb3J0 IHJ1bnRpbWUgYnVzLWZvcm1hdApuZWdvdGlhdGlvbiBiZXR3ZWVuIGVsZW1lbnRzIG9mIHRoZSBi cmlkZ2UgY2hhaW4uClRoaXMgcGF0Y2gganVzdCBwYXZlcyB0aGUgcm9hZCBmb3Igc3VjaCBhIGZl YXR1cmUgYnkgYWRkaW5nIGEgbmV3CmRybV9icmlkZ2Vfc3RhdGUgb2JqZWN0IGluaGVyaXRpbmcg ZnJvbSBkcm1fcHJpdmF0ZV9vYmogc28gd2UgY2FuCnJlLXVzZSBzb21lIG9mIHRoZSBleGlzdGlu ZyBzdGF0ZSBpbml0aWFsaXphdGlvbi90cmFja2luZyBsb2dpYy4KClNpZ25lZC1vZmYtYnk6IEJv cmlzIEJyZXppbGxvbiA8Ym9yaXMuYnJlemlsbG9uQGNvbGxhYm9yYS5jb20+Ci0tLQpDaGFuZ2Vz IGluIHYzOgoqIE5vbmUKCkNoYW5nZXMgaW4gdjI6CiogVXNlIGRybV9mb3JfZWFjaF9icmlkZ2Vf aW5fY2hhaW4oKQoqIFJlbmFtZSBoZWxwZXJzIHRvIGJlIG1vcmUgY29uc2lzdGVudCB3aXRoIHRo ZSByZXN0IG9mIHRoZSBEUk0gQVBJCiogSW1wcm92ZS9maXggdGhlIGRvYwotLS0KIGRyaXZlcnMv Z3B1L2RybS9kcm1fYXRvbWljLmMgICAgICAgIHwgIDM5ICsrKysrKysKIGRyaXZlcnMvZ3B1L2Ry bS9kcm1fYXRvbWljX2hlbHBlci5jIHwgIDIwICsrKysKIGRyaXZlcnMvZ3B1L2RybS9kcm1fYnJp ZGdlLmMgICAgICAgIHwgMTY4ICsrKysrKysrKysrKysrKysrKysrKysrKysrKy0KIGluY2x1ZGUv ZHJtL2RybV9hdG9taWMuaCAgICAgICAgICAgIHwgICAzICsKIGluY2x1ZGUvZHJtL2RybV9icmlk Z2UuaCAgICAgICAgICAgIHwgMTE4ICsrKysrKysrKysrKysrKysrKysKIDUgZmlsZXMgY2hhbmdl ZCwgMzQzIGluc2VydGlvbnMoKyksIDUgZGVsZXRpb25zKC0pCgpkaWZmIC0tZ2l0IGEvZHJpdmVy cy9ncHUvZHJtL2RybV9hdG9taWMuYyBiL2RyaXZlcnMvZ3B1L2RybS9kcm1fYXRvbWljLmMKaW5k ZXggNDE5MzgxYWJiZGQxLi42YzI0OWNlMzkzODAgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvZ3B1L2Ry bS9kcm1fYXRvbWljLmMKKysrIGIvZHJpdmVycy9ncHUvZHJtL2RybV9hdG9taWMuYwpAQCAtMzAs NiArMzAsNyBAQAogCiAjaW5jbHVkZSA8ZHJtL2RybV9hdG9taWMuaD4KICNpbmNsdWRlIDxkcm0v ZHJtX2F0b21pY191YXBpLmg+CisjaW5jbHVkZSA8ZHJtL2RybV9icmlkZ2UuaD4KICNpbmNsdWRl IDxkcm0vZHJtX2RlYnVnZnMuaD4KICNpbmNsdWRlIDxkcm0vZHJtX2RldmljZS5oPgogI2luY2x1 ZGUgPGRybS9kcm1fZHJ2Lmg+CkBAIC0xMDEwLDYgKzEwMTEsNDQgQEAgc3RhdGljIHZvaWQgZHJt X2F0b21pY19jb25uZWN0b3JfcHJpbnRfc3RhdGUoc3RydWN0IGRybV9wcmludGVyICpwLAogCQlj b25uZWN0b3ItPmZ1bmNzLT5hdG9taWNfcHJpbnRfc3RhdGUocCwgc3RhdGUpOwogfQogCisvKioK KyAqIGRybV9hdG9taWNfYWRkX2VuY29kZXJfYnJpZGdlcyAtIGFkZCBicmlkZ2VzIGF0dGFjaGVk IHRvIGFuIGVuY29kZXIKKyAqIEBzdGF0ZTogYXRvbWljIHN0YXRlCisgKiBAZW5jb2RlcjogRFJN IGVuY29kZXIKKyAqCisgKiBUaGlzIGZ1bmN0aW9uIGFkZHMgYWxsIGJyaWRnZXMgYXR0YWNoZWQg dG8gQGVuY29kZXIuIFRoaXMgaXMgbmVlZGVkIHRvIGFkZAorICogYnJpZGdlIHN0YXRlcyB0byBA c3RhdGUgYW5kIG1ha2UgdGhlbSBhdmFpbGFibGUgd2hlbgorICogJmJyaWRnZV9mdW5jcy5hdG9t aWNfe2NoZWNrLHByZV9lbmFibGUsZW5hYmxlLGRpc2FibGVfcG9zdF9kaXNhYmxlfSgpIGFyZQor ICogY2FsbGVkCisgKgorICogUmV0dXJuczoKKyAqIDAgb24gc3VjY2VzcyBvciBjYW4gZmFpbCB3 aXRoIC1FREVBRExLIG9yIC1FTk9NRU0uIFdoZW4gdGhlIGVycm9yIGlzIEVERUFETEsKKyAqIHRo ZW4gdGhlIHcvdyBtdXRleCBjb2RlIGhhcyBkZXRlY3RlZCBhIGRlYWRsb2NrIGFuZCB0aGUgZW50 aXJlIGF0b21pYworICogc2VxdWVuY2UgbXVzdCBiZSByZXN0YXJ0ZWQuIEFsbCBvdGhlciBlcnJv cnMgYXJlIGZhdGFsLgorICovCitpbnQKK2RybV9hdG9taWNfYWRkX2VuY29kZXJfYnJpZGdlcyhz dHJ1Y3QgZHJtX2F0b21pY19zdGF0ZSAqc3RhdGUsCisJCQkgICAgICAgc3RydWN0IGRybV9lbmNv ZGVyICplbmNvZGVyKQoreworCXN0cnVjdCBkcm1fYnJpZGdlX3N0YXRlICpicmlkZ2Vfc3RhdGU7 CisJc3RydWN0IGRybV9icmlkZ2UgKmJyaWRnZTsKKworCWlmICghZW5jb2RlcikKKwkJcmV0dXJu IDA7CisKKwlEUk1fREVCVUdfQVRPTUlDKCJBZGRpbmcgYWxsIGJyaWRnZXMgZm9yIFtlbmNvZGVy OiVkOiVzXSB0byAlcFxuIiwKKwkJCSBlbmNvZGVyLT5iYXNlLmlkLCBlbmNvZGVyLT5uYW1lLCBz dGF0ZSk7CisKKwlkcm1fZm9yX2VhY2hfYnJpZGdlX2luX2NoYWluKGVuY29kZXIsIGJyaWRnZSkg eworCQlicmlkZ2Vfc3RhdGUgPSBkcm1fYXRvbWljX2dldF9icmlkZ2Vfc3RhdGUoc3RhdGUsIGJy aWRnZSk7CisJCWlmIChJU19FUlIoYnJpZGdlX3N0YXRlKSkKKwkJCXJldHVybiBQVFJfRVJSKGJy aWRnZV9zdGF0ZSk7CisJfQorCisJcmV0dXJuIDA7Cit9CitFWFBPUlRfU1lNQk9MKGRybV9hdG9t aWNfYWRkX2VuY29kZXJfYnJpZGdlcyk7CisKIC8qKgogICogZHJtX2F0b21pY19hZGRfYWZmZWN0 ZWRfY29ubmVjdG9ycyAtIGFkZCBjb25uZWN0b3JzIGZvciBjcnRjCiAgKiBAc3RhdGU6IGF0b21p YyBzdGF0ZQpkaWZmIC0tZ2l0IGEvZHJpdmVycy9ncHUvZHJtL2RybV9hdG9taWNfaGVscGVyLmMg Yi9kcml2ZXJzL2dwdS9kcm0vZHJtX2F0b21pY19oZWxwZXIuYwppbmRleCBmMDJkZGZmZDQ5NjAu LmRlOTg1YmE3Y2UyZCAxMDA2NDQKLS0tIGEvZHJpdmVycy9ncHUvZHJtL2RybV9hdG9taWNfaGVs cGVyLmMKKysrIGIvZHJpdmVycy9ncHUvZHJtL2RybV9hdG9taWNfaGVscGVyLmMKQEAgLTczMCw2 ICs3MzAsMjYgQEAgZHJtX2F0b21pY19oZWxwZXJfY2hlY2tfbW9kZXNldChzdHJ1Y3QgZHJtX2Rl dmljZSAqZGV2LAogCQkJcmV0dXJuIHJldDsKIAl9CiAKKwkvKgorCSAqIEl0ZXJhdGUgb3ZlciBh bGwgY29ubmVjdG9ycyBhZ2FpbiwgYW5kIGFkZCBhbGwgYWZmZWN0ZWQgYnJpZGdlcyB0bworCSAq IHRoZSBzdGF0ZS4KKwkgKi8KKwlmb3JfZWFjaF9vbGRuZXdfY29ubmVjdG9yX2luX3N0YXRlKHN0 YXRlLCBjb25uZWN0b3IsCisJCQkJCSAgIG9sZF9jb25uZWN0b3Jfc3RhdGUsCisJCQkJCSAgIG5l d19jb25uZWN0b3Jfc3RhdGUsIGkpIHsKKwkJc3RydWN0IGRybV9lbmNvZGVyICplbmNvZGVyOwor CisJCWVuY29kZXIgPSBvbGRfY29ubmVjdG9yX3N0YXRlLT5iZXN0X2VuY29kZXI7CisJCXJldCA9 IGRybV9hdG9taWNfYWRkX2VuY29kZXJfYnJpZGdlcyhzdGF0ZSwgZW5jb2Rlcik7CisJCWlmIChy ZXQpCisJCQlyZXR1cm4gcmV0OworCisJCWVuY29kZXIgPSBuZXdfY29ubmVjdG9yX3N0YXRlLT5i ZXN0X2VuY29kZXI7CisJCXJldCA9IGRybV9hdG9taWNfYWRkX2VuY29kZXJfYnJpZGdlcyhzdGF0 ZSwgZW5jb2Rlcik7CisJCWlmIChyZXQpCisJCQlyZXR1cm4gcmV0OworCX0KKwogCXJldCA9IG1v ZGVfdmFsaWQoc3RhdGUpOwogCWlmIChyZXQpCiAJCXJldHVybiByZXQ7CmRpZmYgLS1naXQgYS9k cml2ZXJzL2dwdS9kcm0vZHJtX2JyaWRnZS5jIGIvZHJpdmVycy9ncHUvZHJtL2RybV9icmlkZ2Uu YwppbmRleCBjNWNmOGE5YzQyMzcuLmM1Mzk2Njc2Nzc4MiAxMDA2NDQKLS0tIGEvZHJpdmVycy9n cHUvZHJtL2RybV9icmlkZ2UuYworKysgYi9kcml2ZXJzL2dwdS9kcm0vZHJtX2JyaWRnZS5jCkBA IC0yNSw2ICsyNSw3IEBACiAjaW5jbHVkZSA8bGludXgvbW9kdWxlLmg+CiAjaW5jbHVkZSA8bGlu dXgvbXV0ZXguaD4KIAorI2luY2x1ZGUgPGRybS9kcm1fYXRvbWljX3N0YXRlX2hlbHBlci5oPgog I2luY2x1ZGUgPGRybS9kcm1fYnJpZGdlLmg+CiAjaW5jbHVkZSA8ZHJtL2RybV9lbmNvZGVyLmg+ CiAKQEAgLTg5LDYgKzkwLDM4IEBAIHZvaWQgZHJtX2JyaWRnZV9yZW1vdmUoc3RydWN0IGRybV9i cmlkZ2UgKmJyaWRnZSkKIH0KIEVYUE9SVF9TWU1CT0woZHJtX2JyaWRnZV9yZW1vdmUpOwogCitz dGF0aWMgc3RydWN0IGRybV9wcml2YXRlX3N0YXRlICoKK2RybV9icmlkZ2VfYXRvbWljX2R1cGxp Y2F0ZV9wcml2X3N0YXRlKHN0cnVjdCBkcm1fcHJpdmF0ZV9vYmogKm9iaikKK3sKKwlzdHJ1Y3Qg ZHJtX2JyaWRnZSAqYnJpZGdlID0gZHJtX3ByaXZfdG9fYnJpZGdlKG9iaik7CisJc3RydWN0IGRy bV9icmlkZ2Vfc3RhdGUgKnN0YXRlOworCisJaWYgKGJyaWRnZS0+ZnVuY3MtPmF0b21pY19kdXBs aWNhdGVfc3RhdGUpCisJCXN0YXRlID0gYnJpZGdlLT5mdW5jcy0+YXRvbWljX2R1cGxpY2F0ZV9z dGF0ZShicmlkZ2UpOworCWVsc2UKKwkJc3RhdGUgPSBkcm1fYXRvbWljX2hlbHBlcl9icmlkZ2Vf ZHVwbGljYXRlX3N0YXRlKGJyaWRnZSk7CisKKwlyZXR1cm4gJnN0YXRlLT5iYXNlOworfQorCitz dGF0aWMgdm9pZAorZHJtX2JyaWRnZV9hdG9taWNfZGVzdHJveV9wcml2X3N0YXRlKHN0cnVjdCBk cm1fcHJpdmF0ZV9vYmogKm9iaiwKKwkJCQkgICAgIHN0cnVjdCBkcm1fcHJpdmF0ZV9zdGF0ZSAq cykKK3sKKwlzdHJ1Y3QgZHJtX2JyaWRnZV9zdGF0ZSAqc3RhdGUgPSBkcm1fcHJpdl90b19icmlk Z2Vfc3RhdGUocyk7CisJc3RydWN0IGRybV9icmlkZ2UgKmJyaWRnZSA9IGRybV9wcml2X3RvX2Jy aWRnZShvYmopOworCisJaWYgKGJyaWRnZS0+ZnVuY3MtPmF0b21pY19kZXN0cm95X3N0YXRlKQor CQlicmlkZ2UtPmZ1bmNzLT5hdG9taWNfZGVzdHJveV9zdGF0ZShicmlkZ2UsIHN0YXRlKTsKKwll bHNlCisJCWRybV9hdG9taWNfaGVscGVyX2JyaWRnZV9kZXN0cm95X3N0YXRlKGJyaWRnZSwgc3Rh dGUpOworfQorCitzdGF0aWMgY29uc3Qgc3RydWN0IGRybV9wcml2YXRlX3N0YXRlX2Z1bmNzIGRy bV9icmlkZ2VfcHJpdl9zdGF0ZV9mdW5jcyA9IHsKKwkuYXRvbWljX2R1cGxpY2F0ZV9zdGF0ZSA9 IGRybV9icmlkZ2VfYXRvbWljX2R1cGxpY2F0ZV9wcml2X3N0YXRlLAorCS5hdG9taWNfZGVzdHJv eV9zdGF0ZSA9IGRybV9icmlkZ2VfYXRvbWljX2Rlc3Ryb3lfcHJpdl9zdGF0ZSwKK307CisKIC8q KgogICogZHJtX2JyaWRnZV9hdHRhY2ggLSBhdHRhY2ggdGhlIGJyaWRnZSB0byBhbiBlbmNvZGVy J3MgY2hhaW4KICAqCkBAIC0xMTQsNiArMTQ3LDcgQEAgRVhQT1JUX1NZTUJPTChkcm1fYnJpZGdl X3JlbW92ZSk7CiBpbnQgZHJtX2JyaWRnZV9hdHRhY2goc3RydWN0IGRybV9lbmNvZGVyICplbmNv ZGVyLCBzdHJ1Y3QgZHJtX2JyaWRnZSAqYnJpZGdlLAogCQkgICAgICBzdHJ1Y3QgZHJtX2JyaWRn ZSAqcHJldmlvdXMpCiB7CisJc3RydWN0IGRybV9icmlkZ2Vfc3RhdGUgKnN0YXRlOwogCUxJU1Rf SEVBRCh0bXBfbGlzdCk7CiAJaW50IHJldDsKIApAQCAtMTMyLDE5ICsxNjYsMzkgQEAgaW50IGRy bV9icmlkZ2VfYXR0YWNoKHN0cnVjdCBkcm1fZW5jb2RlciAqZW5jb2Rlciwgc3RydWN0IGRybV9i cmlkZ2UgKmJyaWRnZSwKIAogCWlmIChicmlkZ2UtPmZ1bmNzLT5hdHRhY2gpIHsKIAkJcmV0ID0g YnJpZGdlLT5mdW5jcy0+YXR0YWNoKGJyaWRnZSk7Ci0JCWlmIChyZXQgPCAwKSB7Ci0JCQlicmlk Z2UtPmRldiA9IE5VTEw7Ci0JCQlicmlkZ2UtPmVuY29kZXIgPSBOVUxMOwotCQkJcmV0dXJuIHJl dDsKLQkJfQorCQlpZiAocmV0IDwgMCkKKwkJCWdvdG8gZXJyX3Jlc2V0X2JyaWRnZTsKIAl9CiAK KwlpZiAoYnJpZGdlLT5mdW5jcy0+YXRvbWljX3Jlc2V0KQorCQlzdGF0ZSA9IGJyaWRnZS0+ZnVu Y3MtPmF0b21pY19yZXNldChicmlkZ2UpOworCWVsc2UKKwkJc3RhdGUgPSBkcm1fYXRvbWljX2hl bHBlcl9icmlkZ2VfcmVzZXQoYnJpZGdlKTsKKworCWlmIChJU19FUlIoc3RhdGUpKSB7CisJCXJl dCA9IFBUUl9FUlIoc3RhdGUpOworCQlnb3RvIGVycl9kZXRhY2hfYnJpZGdlOworCX0KKworCWRy bV9hdG9taWNfcHJpdmF0ZV9vYmpfaW5pdChicmlkZ2UtPmRldiwgJmJyaWRnZS0+YmFzZSwKKwkJ CQkgICAgJnN0YXRlLT5iYXNlLAorCQkJCSAgICAmZHJtX2JyaWRnZV9wcml2X3N0YXRlX2Z1bmNz KTsKKwogCWlmIChwcmV2aW91cykKIAkJbGlzdF9zcGxpY2UoJnRtcF9saXN0LCAmcHJldmlvdXMt PmNoYWluX25vZGUpOwogCWVsc2UKIAkJbGlzdF9zcGxpY2UoJnRtcF9saXN0LCAmZW5jb2Rlci0+ YnJpZGdlX2NoYWluKTsKIAogCXJldHVybiAwOworCitlcnJfZGV0YWNoX2JyaWRnZToKKwlpZiAo YnJpZGdlLT5mdW5jcy0+ZGV0YWNoKQorCQlicmlkZ2UtPmZ1bmNzLT5kZXRhY2goYnJpZGdlKTsK KworZXJyX3Jlc2V0X2JyaWRnZToKKwlicmlkZ2UtPmRldiA9IE5VTEw7CisJYnJpZGdlLT5lbmNv ZGVyID0gTlVMTDsKKwlyZXR1cm4gcmV0OwogfQogRVhQT1JUX1NZTUJPTChkcm1fYnJpZGdlX2F0 dGFjaCk7CiAKQEAgLTE1Niw2ICsyMTAsOCBAQCB2b2lkIGRybV9icmlkZ2VfZGV0YWNoKHN0cnVj dCBkcm1fYnJpZGdlICpicmlkZ2UpCiAJaWYgKFdBUk5fT04oIWJyaWRnZS0+ZGV2KSkKIAkJcmV0 dXJuOwogCisJZHJtX2F0b21pY19wcml2YXRlX29ial9maW5pKCZicmlkZ2UtPmJhc2UpOworCiAJ aWYgKGJyaWRnZS0+ZnVuY3MtPmRldGFjaCkKIAkJYnJpZGdlLT5mdW5jcy0+ZGV0YWNoKGJyaWRn ZSk7CiAKQEAgLTUyMiw2ICs1NzgsMTA4IEBAIHZvaWQgZHJtX2F0b21pY19icmlkZ2VfY2hhaW5f ZW5hYmxlKHN0cnVjdCBkcm1fYnJpZGdlICpicmlkZ2UsCiB9CiBFWFBPUlRfU1lNQk9MKGRybV9h dG9taWNfYnJpZGdlX2NoYWluX2VuYWJsZSk7CiAKKy8qKgorICogZHJtX2F0b21pY19oZWxwZXJf YnJpZGdlX2Rlc3Ryb3lfc3RhdGUoKSAtIERlZmF1bHQgZGVzdHJveSBzdGF0ZSBoZWxwZXIKKyAq IEBicmlkZ2U6IHRoZSBicmlkZ2UgdGhpcyBzdGF0ZSByZWZlcnMgdG8KKyAqIEBzdGF0ZTogc3Rh dGUgb2JqZWN0IHRvIGRlc3Ryb3kKKyAqCisgKiBKdXN0IGEgc2ltcGxlIGtmcmVlKCkgZm9yIG5v dy4KKyAqLwordm9pZCBkcm1fYXRvbWljX2hlbHBlcl9icmlkZ2VfZGVzdHJveV9zdGF0ZShzdHJ1 Y3QgZHJtX2JyaWRnZSAqYnJpZGdlLAorCQkJCQkgICAgc3RydWN0IGRybV9icmlkZ2Vfc3RhdGUg KnN0YXRlKQoreworCWtmcmVlKHN0YXRlKTsKK30KK0VYUE9SVF9TWU1CT0woZHJtX2F0b21pY19o ZWxwZXJfYnJpZGdlX2Rlc3Ryb3lfc3RhdGUpOworCisvKioKKyAqIF9fZHJtX2F0b21pY19oZWxw ZXJfYnJpZGdlX3Jlc2V0KCkgLSBJbml0aWFsaXplIGEgYnJpZGdlIHN0YXRlIHRvIGl0cworICoJ CQkJCWRlZmF1bHQKKyAqIEBicmlkZ2U6IHRoZSBicmlkZ2UgdGhpcyBzdGF0ZSBpcyByZWZlcnMg dG8KKyAqIEBzdGF0ZTogYnJpZGdlIHN0YXRlIHRvIGluaXRpYWxpemUKKyAqCisgKiBGb3Igbm93 IGl0J3MganVzdCBhIG1lbXNldCgwKSBwbHVzIGEgc3RhdGUtPmJyaWRnZSBhc3NpZ25tZW50LiBN aWdodAorICogYmUgZXh0ZW5kZWQgaW4gdGhlIGZ1dHVyZS4KKyAqLwordm9pZCBfX2RybV9hdG9t aWNfaGVscGVyX2JyaWRnZV9yZXNldChzdHJ1Y3QgZHJtX2JyaWRnZSAqYnJpZGdlLAorCQkJCSAg ICAgIHN0cnVjdCBkcm1fYnJpZGdlX3N0YXRlICpzdGF0ZSkKK3sKKwltZW1zZXQoc3RhdGUsIDAs IHNpemVvZigqc3RhdGUpKTsKKwlzdGF0ZS0+YnJpZGdlID0gYnJpZGdlOworfQorRVhQT1JUX1NZ TUJPTChfX2RybV9hdG9taWNfaGVscGVyX2JyaWRnZV9yZXNldCk7CisKKy8qKgorICogZHJtX2F0 b21pY19oZWxwZXJfYnJpZGdlX3Jlc2V0KCkgLSBkZWZhdWx0ICZkcm1fcGxhbmVfZnVuY3MucmVz ZXQgaG9vayBmb3IKKyAqCQkJCSAgICAgIGJyaWRnZXMKKyAqIEBicmlkZ2U6IHRoZSBicmlkZ2Ug dG8gcmVzZXQgc3RhdGUgb24KKyAqCisgKiBSZXNldHMgdGhlIGF0b21pYyBzdGF0ZSBmb3IgQGJy aWRnZSBieSBmcmVlaW5nIHRoZSBzdGF0ZSBwb2ludGVyICh3aGljaAorICogbWlnaHQgYmUgTlVM TCwgZS5nLiBhdCBkcml2ZXIgbG9hZCB0aW1lKSBhbmQgYWxsb2NhdGluZyBhIG5ldyBlbXB0eSBz dGF0ZQorICogb2JqZWN0LgorICoKKyAqIFJFVFVSTlM6CisgKiBBIHZhbGlkIGRybV9icmlkZ2Vf c3RhdGUgb2JqZWN0IGluIGNhc2Ugb2Ygc3VjY2VzcywgYW4gRVJSX1BUUigpCisgKiBnaXZpbmcg dGhlIHJlYW9uIG9mIHRoZSBmYWlsdXJlIG90aGVyd2lzZS4KKyAqLworc3RydWN0IGRybV9icmlk Z2Vfc3RhdGUgKgorZHJtX2F0b21pY19oZWxwZXJfYnJpZGdlX3Jlc2V0KHN0cnVjdCBkcm1fYnJp ZGdlICpicmlkZ2UpCit7CisJc3RydWN0IGRybV9icmlkZ2Vfc3RhdGUgKmJyaWRnZV9zdGF0ZTsK KworCWJyaWRnZV9zdGF0ZSA9IGt6YWxsb2Moc2l6ZW9mKCpicmlkZ2Vfc3RhdGUpLCBHRlBfS0VS TkVMKTsKKwlpZiAoIWJyaWRnZV9zdGF0ZSkKKwkJcmV0dXJuIEVSUl9QVFIoLUVOT01FTSk7CisK KwlfX2RybV9hdG9taWNfaGVscGVyX2JyaWRnZV9yZXNldChicmlkZ2UsIGJyaWRnZV9zdGF0ZSk7 CisJcmV0dXJuIGJyaWRnZV9zdGF0ZTsKK30KK0VYUE9SVF9TWU1CT0woZHJtX2F0b21pY19oZWxw ZXJfYnJpZGdlX3Jlc2V0KTsKKworLyoqCisgKiBfX2RybV9hdG9taWNfaGVscGVyX2JyaWRnZV9k dXBsaWNhdGVfc3RhdGUoKSAtIENvcHkgdGhlIGNvbnRlbnQgb2YgdGhlCisgKgkJCQkJCSAgY3Vy cmVudCBicmlkZ2Ugc3RhdGUgaW50byBhCisgKgkJCQkJCSAgbmV3IG9uZQorICogQGJyaWRnZTog YnJpZGdlIGVsZW1lbnQgdGhlIG9sZCBhbmQgbmV3IHN0YXRlcyBhcmUgcmVmZXJyaW5nIHRvCisg KiBAbmV3OiBuZXcgYnJpZGdlIHN0YXRlIHRvIGNvcHkgdG8KKyAqCisgKiBTaG91bGQgYmUgdXNl ZCBieSBjdXN0b20gJmRybV9icmlkZ2VfZnVuY3MuYXRvbWljX2R1cGxpY2F0ZSgpIGltcGxlbWVu dGF0aW9uCisgKiB0byBjb3B5IHRoZSBwcmV2aW91cyBzdGF0ZSBpbnRvIHRoZSBuZXcgb2JqZWN0 LgorICovCit2b2lkIF9fZHJtX2F0b21pY19oZWxwZXJfYnJpZGdlX2R1cGxpY2F0ZV9zdGF0ZShz dHJ1Y3QgZHJtX2JyaWRnZSAqYnJpZGdlLAorCQkJCQkJc3RydWN0IGRybV9icmlkZ2Vfc3RhdGUg Km5ldykKK3sKKwlfX2RybV9hdG9taWNfaGVscGVyX3ByaXZhdGVfb2JqX2R1cGxpY2F0ZV9zdGF0 ZSgmYnJpZGdlLT5iYXNlLAorCQkJCQkJCSZuZXctPmJhc2UpOworCW5ldy0+YnJpZGdlID0gYnJp ZGdlOworfQorRVhQT1JUX1NZTUJPTChfX2RybV9hdG9taWNfaGVscGVyX2JyaWRnZV9kdXBsaWNh dGVfc3RhdGUpOworCisvKioKKyAqIGRybV9hdG9taWNfaGVscGVyX2R1cGxpY2F0ZV9icmlkZ2Vf c3RhdGUoKSAtIERlZmF1bHQgZHVwbGljYXRlIHN0YXRlIGhlbHBlcgorICogQGJyaWRnZTogYnJp ZGdlIGNvbnRhaW5pbmcgdGhlIHN0YXRlIHRvIGR1cGxpY2F0ZQorICoKKyAqIERlZmF1bHQgaW1w bGVtZW50YXRpb24gb2YgJmRybV9icmlkZ2VfZnVuY3MuYXRvbWljX2R1cGxpY2F0ZSgpLgorICoK KyAqIFJFVFVSTlM6CisgKiBhIHZhbGlkIHN0YXRlIG9iamVjdCBvciBOVUxMIGlmIHRoZSBhbGxv Y2F0aW9uIGZhaWxzLgorICovCitzdHJ1Y3QgZHJtX2JyaWRnZV9zdGF0ZSAqCitkcm1fYXRvbWlj X2hlbHBlcl9icmlkZ2VfZHVwbGljYXRlX3N0YXRlKHN0cnVjdCBkcm1fYnJpZGdlICpicmlkZ2Up Cit7CisJc3RydWN0IGRybV9icmlkZ2Vfc3RhdGUgKm5ldzsKKworCWlmIChXQVJOX09OKCFicmlk Z2UtPmJhc2Uuc3RhdGUpKQorCQlyZXR1cm4gTlVMTDsKKworCW5ldyA9IGt6YWxsb2Moc2l6ZW9m KCpuZXcpLCBHRlBfS0VSTkVMKTsKKwlpZiAobmV3KQorCQlfX2RybV9hdG9taWNfaGVscGVyX2Jy aWRnZV9kdXBsaWNhdGVfc3RhdGUoYnJpZGdlLCBuZXcpOworCisJcmV0dXJuIG5ldzsKK30KK0VY UE9SVF9TWU1CT0woZHJtX2F0b21pY19oZWxwZXJfYnJpZGdlX2R1cGxpY2F0ZV9zdGF0ZSk7CisK ICNpZmRlZiBDT05GSUdfT0YKIC8qKgogICogb2ZfZHJtX2ZpbmRfYnJpZGdlIC0gZmluZCB0aGUg YnJpZGdlIGNvcnJlc3BvbmRpbmcgdG8gdGhlIGRldmljZSBub2RlIGluCmRpZmYgLS1naXQgYS9p bmNsdWRlL2RybS9kcm1fYXRvbWljLmggYi9pbmNsdWRlL2RybS9kcm1fYXRvbWljLmgKaW5kZXgg OTI3ZTEyMDVkN2FhLi4xYzBhMDgyMTc3MTIgMTAwNjQ0Ci0tLSBhL2luY2x1ZGUvZHJtL2RybV9h dG9taWMuaAorKysgYi9pbmNsdWRlL2RybS9kcm1fYXRvbWljLmgKQEAgLTY2MCw2ICs2NjAsOSBA QCBfX2RybV9hdG9taWNfZ2V0X2N1cnJlbnRfcGxhbmVfc3RhdGUoc3RydWN0IGRybV9hdG9taWNf c3RhdGUgKnN0YXRlLAogCXJldHVybiBwbGFuZS0+c3RhdGU7CiB9CiAKK2ludCBfX211c3RfY2hl Y2sKK2RybV9hdG9taWNfYWRkX2VuY29kZXJfYnJpZGdlcyhzdHJ1Y3QgZHJtX2F0b21pY19zdGF0 ZSAqc3RhdGUsCisJCQkgICAgICAgc3RydWN0IGRybV9lbmNvZGVyICplbmNvZGVyKTsKIGludCBf X211c3RfY2hlY2sKIGRybV9hdG9taWNfYWRkX2FmZmVjdGVkX2Nvbm5lY3RvcnMoc3RydWN0IGRy bV9hdG9taWNfc3RhdGUgKnN0YXRlLAogCQkJCSAgIHN0cnVjdCBkcm1fY3J0YyAqY3J0Yyk7CmRp ZmYgLS1naXQgYS9pbmNsdWRlL2RybS9kcm1fYnJpZGdlLmggYi9pbmNsdWRlL2RybS9kcm1fYnJp ZGdlLmgKaW5kZXggMjM4ZTg0YWI2M2EzLi5hNjA4YzQ3ZDFkZTUgMTAwNjQ0Ci0tLSBhL2luY2x1 ZGUvZHJtL2RybV9icmlkZ2UuaAorKysgYi9pbmNsdWRlL2RybS9kcm1fYnJpZGdlLmgKQEAgLTI1 LDYgKzI1LDcgQEAKIAogI2luY2x1ZGUgPGxpbnV4L2xpc3QuaD4KICNpbmNsdWRlIDxsaW51eC9j dHlwZS5oPgorI2luY2x1ZGUgPGRybS9kcm1fYXRvbWljLmg+CiAjaW5jbHVkZSA8ZHJtL2RybV9l bmNvZGVyLmg+CiAjaW5jbHVkZSA8ZHJtL2RybV9tb2RlX29iamVjdC5oPgogI2luY2x1ZGUgPGRy bS9kcm1fbW9kZXMuaD4KQEAgLTMzLDYgKzM0LDIzIEBAIHN0cnVjdCBkcm1fYnJpZGdlOwogc3Ry dWN0IGRybV9icmlkZ2VfdGltaW5nczsKIHN0cnVjdCBkcm1fcGFuZWw7CiAKKy8qKgorICogc3Ry dWN0IGRybV9icmlkZ2Vfc3RhdGUgLSBBdG9taWMgYnJpZGdlIHN0YXRlIG9iamVjdAorICogQGJh c2U6IGluaGVyaXQgZnJvbSAmZHJtX3ByaXZhdGVfc3RhdGUKKyAqIEBicmlkZ2U6IHRoZSBicmlk Z2UgdGhpcyBzdGF0ZSByZWZlcnMgdG8KKyAqLworc3RydWN0IGRybV9icmlkZ2Vfc3RhdGUgewor CXN0cnVjdCBkcm1fcHJpdmF0ZV9zdGF0ZSBiYXNlOworCisJc3RydWN0IGRybV9icmlkZ2UgKmJy aWRnZTsKK307CisKK3N0YXRpYyBpbmxpbmUgc3RydWN0IGRybV9icmlkZ2Vfc3RhdGUgKgorZHJt X3ByaXZfdG9fYnJpZGdlX3N0YXRlKHN0cnVjdCBkcm1fcHJpdmF0ZV9zdGF0ZSAqcHJpdikKK3sK KwlyZXR1cm4gY29udGFpbmVyX29mKHByaXYsIHN0cnVjdCBkcm1fYnJpZGdlX3N0YXRlLCBiYXNl KTsKK30KKwogLyoqCiAgKiBzdHJ1Y3QgZHJtX2JyaWRnZV9mdW5jcyAtIGRybV9icmlkZ2UgY29u dHJvbCBmdW5jdGlvbnMKICAqLwpAQCAtMzM4LDYgKzM1Niw0OCBAQCBzdHJ1Y3QgZHJtX2JyaWRn ZV9mdW5jcyB7CiAJICovCiAJdm9pZCAoKmF0b21pY19wb3N0X2Rpc2FibGUpKHN0cnVjdCBkcm1f YnJpZGdlICpicmlkZ2UsCiAJCQkJICAgIHN0cnVjdCBkcm1fYXRvbWljX3N0YXRlICpzdGF0ZSk7 CisKKwkvKioKKwkgKiBAYXRvbWljX2R1cGxpY2F0ZV9zdGF0ZToKKwkgKgorCSAqIER1cGxpY2F0 ZSB0aGUgY3VycmVudCBicmlkZ2Ugc3RhdGUgb2JqZWN0ICh3aGljaCBpcyBndWFyYW50ZWVkIHRv IGJlCisJICogbm9uLU5VTEwpLgorCSAqCisJICogVGhlIGF0b21pY19kdXBsaWNhdGVfc3RhdGUo KSBpcyBvcHRpb25hbCwgdGhlIGNvcmUgZmFsbHMgYmFjayBvbgorCSAqICZkcm1fYXRvbWljX2hl bHBlcl9icmlkZ2VfZHVwbGljYXRlX3N0YXRlKCkgd2hlbiBub3QgaW1wbGVtZW50ZWQuCisJICoK KwkgKiBSRVRVUk5TOgorCSAqIEEgdmFsaWQgZHJtX2JyaWRnZV9zdGF0ZSBvYmplY3Qgb3IgTlVM TCBpZiB0aGUgYWxsb2NhdGlvbiBmYWlscy4KKwkgKi8KKwlzdHJ1Y3QgZHJtX2JyaWRnZV9zdGF0 ZSAqKCphdG9taWNfZHVwbGljYXRlX3N0YXRlKShzdHJ1Y3QgZHJtX2JyaWRnZSAqYnJpZGdlKTsK KworCS8qKgorCSAqIEBhdG9taWNfZGVzdHJveV9zdGF0ZToKKwkgKgorCSAqIERlc3Ryb3kgYSBi cmlkZ2Ugc3RhdGUgb2JqZWN0IHByZXZpb3VzbHkgYWxsb2NhdGVkIGJ5CisJICogJmRybV9icmlk Z2VfZnVuY3MuYXRvbWljX2R1cGxpY2F0ZV9zdGF0ZSgpLgorCSAqCisJICogVGhlIGF0b21pY19k ZXN0cm95X3N0YXRlIGhvb2sgaXMgb3B0aW9uYWwsIHRoZSBjb3JlZiBmYWxscyBiYWNrIG9uCisJ ICogJmRybV9hdG9taWNfaGVscGVyX2JyaWRnZV9kZXN0cm95X3N0YXRlKCkgd2hlbiBub3QgaW1w bGVtZW50ZWQuCisJICovCisJdm9pZCAoKmF0b21pY19kZXN0cm95X3N0YXRlKShzdHJ1Y3QgZHJt X2JyaWRnZSAqYnJpZGdlLAorCQkJCSAgICAgc3RydWN0IGRybV9icmlkZ2Vfc3RhdGUgKnN0YXRl KTsKKworCS8qKgorCSAqIEBhdG9taWNfcmVzZXQ6CisJICoKKwkgKiBSZXNldCB0aGUgYnJpZGdl IHRvIGEgcHJlZGVmaW5lZCBzdGF0ZSAob3IgcmV0cmlldmUgaXRzIGN1cnJlbnQKKwkgKiBzdGF0 ZSkgYW5kIHJldHVybiBhICZkcm1fYnJpZGdlX3N0YXRlIG9iamVjdCBtYXRjaGluZyB0aGlzIHN0 YXRlLgorCSAqIFRoaXMgZnVuY3Rpb24gaXMgY2FsbGVkIGF0IGF0dGFjaCB0aW1lLgorCSAqCisJ ICogVGhlIGF0b21pY19yZXNldCBob29rIGlzIG9wdGlvbmFsLCB0aGUgY29yZSBmYWxscyBiYWNr IG9uCisJICogJmRybV9hdG9taWNfaGVscGVyX2JyaWRnZV9yZXNldCgpIHdoZW4gbm90IGltcGxl bWVudGVkLgorCSAqCisJICogUkVUVVJOUzoKKwkgKiBBIHZhbGlkIGRybV9icmlkZ2Vfc3RhdGUg b2JqZWN0IGluIGNhc2Ugb2Ygc3VjY2VzcywgYW4gRVJSX1BUUigpCisJICogZ2l2aW5nIHRoZSBy ZWFvbiBvZiB0aGUgZmFpbHVyZSBvdGhlcndpc2UuCisJICovCisJc3RydWN0IGRybV9icmlkZ2Vf c3RhdGUgKigqYXRvbWljX3Jlc2V0KShzdHJ1Y3QgZHJtX2JyaWRnZSAqYnJpZGdlKTsKIH07CiAK IC8qKgpAQCAtMzgwLDYgKzQ0MCw4IEBAIHN0cnVjdCBkcm1fYnJpZGdlX3RpbWluZ3MgewogICog c3RydWN0IGRybV9icmlkZ2UgLSBjZW50cmFsIERSTSBicmlkZ2UgY29udHJvbCBzdHJ1Y3R1cmUK ICAqLwogc3RydWN0IGRybV9icmlkZ2UgeworCS8qKiBAYmFzZTogaW5oZXJpdCBmcm9tICZkcm1f cHJpdmF0ZV9vYmplY3QgKi8KKwlzdHJ1Y3QgZHJtX3ByaXZhdGVfb2JqIGJhc2U7CiAJLyoqIEBk ZXY6IERSTSBkZXZpY2UgdGhpcyBicmlkZ2UgYmVsb25ncyB0byAqLwogCXN0cnVjdCBkcm1fZGV2 aWNlICpkZXY7CiAJLyoqIEBlbmNvZGVyOiBlbmNvZGVyIHRvIHdoaWNoIHRoaXMgYnJpZGdlIGlz IGNvbm5lY3RlZCAqLwpAQCAtNDA0LDYgKzQ2NiwxMiBAQCBzdHJ1Y3QgZHJtX2JyaWRnZSB7CiAJ dm9pZCAqZHJpdmVyX3ByaXZhdGU7CiB9OwogCitzdGF0aWMgaW5saW5lIHN0cnVjdCBkcm1fYnJp ZGdlICoKK2RybV9wcml2X3RvX2JyaWRnZShzdHJ1Y3QgZHJtX3ByaXZhdGVfb2JqICpwcml2KQor eworCXJldHVybiBjb250YWluZXJfb2YocHJpdiwgc3RydWN0IGRybV9icmlkZ2UsIGJhc2UpOwor fQorCiB2b2lkIGRybV9icmlkZ2VfYWRkKHN0cnVjdCBkcm1fYnJpZGdlICpicmlkZ2UpOwogdm9p ZCBkcm1fYnJpZGdlX3JlbW92ZShzdHJ1Y3QgZHJtX2JyaWRnZSAqYnJpZGdlKTsKIHN0cnVjdCBk cm1fYnJpZGdlICpvZl9kcm1fZmluZF9icmlkZ2Uoc3RydWN0IGRldmljZV9ub2RlICpucCk7CkBA IC00NzUsNiArNTQzLDU2IEBAIHZvaWQgZHJtX2F0b21pY19icmlkZ2VfY2hhaW5fcHJlX2VuYWJs ZShzdHJ1Y3QgZHJtX2JyaWRnZSAqYnJpZGdlLAogdm9pZCBkcm1fYXRvbWljX2JyaWRnZV9jaGFp bl9lbmFibGUoc3RydWN0IGRybV9icmlkZ2UgKmJyaWRnZSwKIAkJCQkgICAgc3RydWN0IGRybV9h dG9taWNfc3RhdGUgKnN0YXRlKTsKIAordm9pZCBfX2RybV9hdG9taWNfaGVscGVyX2JyaWRnZV9y ZXNldChzdHJ1Y3QgZHJtX2JyaWRnZSAqYnJpZGdlLAorCQkJCSAgICAgIHN0cnVjdCBkcm1fYnJp ZGdlX3N0YXRlICpzdGF0ZSk7CitzdHJ1Y3QgZHJtX2JyaWRnZV9zdGF0ZSAqCitkcm1fYXRvbWlj X2hlbHBlcl9icmlkZ2VfcmVzZXQoc3RydWN0IGRybV9icmlkZ2UgKmJyaWRnZSk7Cit2b2lkIGRy bV9hdG9taWNfaGVscGVyX2JyaWRnZV9kZXN0cm95X3N0YXRlKHN0cnVjdCBkcm1fYnJpZGdlICpi cmlkZ2UsCisJCQkJCSAgICBzdHJ1Y3QgZHJtX2JyaWRnZV9zdGF0ZSAqc3RhdGUpOwordm9pZCBf X2RybV9hdG9taWNfaGVscGVyX2JyaWRnZV9kdXBsaWNhdGVfc3RhdGUoc3RydWN0IGRybV9icmlk Z2UgKmJyaWRnZSwKKwkJCQkJCXN0cnVjdCBkcm1fYnJpZGdlX3N0YXRlICpuZXcpOworc3RydWN0 IGRybV9icmlkZ2Vfc3RhdGUgKgorZHJtX2F0b21pY19oZWxwZXJfYnJpZGdlX2R1cGxpY2F0ZV9z dGF0ZShzdHJ1Y3QgZHJtX2JyaWRnZSAqYnJpZGdlKTsKKworc3RhdGljIGlubGluZSBzdHJ1Y3Qg ZHJtX2JyaWRnZV9zdGF0ZSAqCitkcm1fYXRvbWljX2dldF9icmlkZ2Vfc3RhdGUoc3RydWN0IGRy bV9hdG9taWNfc3RhdGUgKnN0YXRlLAorCQkJICAgIHN0cnVjdCBkcm1fYnJpZGdlICpicmlkZ2Up Cit7CisJc3RydWN0IGRybV9wcml2YXRlX3N0YXRlICpvYmpfc3RhdGU7CisKKwlvYmpfc3RhdGUg PSBkcm1fYXRvbWljX2dldF9wcml2YXRlX29ial9zdGF0ZShzdGF0ZSwgJmJyaWRnZS0+YmFzZSk7 CisJaWYgKCFvYmpfc3RhdGUpCisJCXJldHVybiBOVUxMOworCisJcmV0dXJuIGRybV9wcml2X3Rv X2JyaWRnZV9zdGF0ZShvYmpfc3RhdGUpOworfQorCitzdGF0aWMgaW5saW5lIHN0cnVjdCBkcm1f YnJpZGdlX3N0YXRlICoKK2RybV9hdG9taWNfZ2V0X29sZF9icmlkZ2Vfc3RhdGUoc3RydWN0IGRy bV9hdG9taWNfc3RhdGUgKnN0YXRlLAorCQkJCXN0cnVjdCBkcm1fYnJpZGdlICpicmlkZ2UpCit7 CisJc3RydWN0IGRybV9wcml2YXRlX3N0YXRlICpvYmpfc3RhdGU7CisKKwlvYmpfc3RhdGUgPSBk cm1fYXRvbWljX2dldF9vbGRfcHJpdmF0ZV9vYmpfc3RhdGUoc3RhdGUsICZicmlkZ2UtPmJhc2Up OworCWlmICghb2JqX3N0YXRlKQorCQlyZXR1cm4gTlVMTDsKKworCXJldHVybiBkcm1fcHJpdl90 b19icmlkZ2Vfc3RhdGUob2JqX3N0YXRlKTsKK30KKworc3RhdGljIGlubGluZSBzdHJ1Y3QgZHJt X2JyaWRnZV9zdGF0ZSAqCitkcm1fYXRvbWljX2dldF9uZXdfYnJpZGdlX3N0YXRlKHN0cnVjdCBk cm1fYXRvbWljX3N0YXRlICpzdGF0ZSwKKwkJCQlzdHJ1Y3QgZHJtX2JyaWRnZSAqYnJpZGdlKQor eworCXN0cnVjdCBkcm1fcHJpdmF0ZV9zdGF0ZSAqb2JqX3N0YXRlOworCisJb2JqX3N0YXRlID0g ZHJtX2F0b21pY19nZXRfbmV3X3ByaXZhdGVfb2JqX3N0YXRlKHN0YXRlLCAmYnJpZGdlLT5iYXNl KTsKKwlpZiAoIW9ial9zdGF0ZSkKKwkJcmV0dXJuIE5VTEw7CisKKwlyZXR1cm4gZHJtX3ByaXZf dG9fYnJpZGdlX3N0YXRlKG9ial9zdGF0ZSk7Cit9CisKICNpZmRlZiBDT05GSUdfRFJNX1BBTkVM X0JSSURHRQogc3RydWN0IGRybV9icmlkZ2UgKmRybV9wYW5lbF9icmlkZ2VfYWRkKHN0cnVjdCBk cm1fcGFuZWwgKnBhbmVsKTsKIHN0cnVjdCBkcm1fYnJpZGdlICpkcm1fcGFuZWxfYnJpZGdlX2Fk ZF90eXBlZChzdHJ1Y3QgZHJtX3BhbmVsICpwYW5lbCwKLS0gCjIuMjEuMAoKX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX18KZHJpLWRldmVsIG1haWxpbmcgbGlz dApkcmktZGV2ZWxAbGlzdHMuZnJlZWRlc2t0b3Aub3JnCmh0dHBzOi8vbGlzdHMuZnJlZWRlc2t0 b3Aub3JnL21haWxtYW4vbGlzdGluZm8vZHJpLWRldmVs