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=-8.3 required=3.0 tests=DKIM_SIGNED,DKIM_VALID, DKIM_VALID_AU,HEADER_FROM_DIFFERENT_DOMAINS,INCLUDES_PATCH,MAILING_LIST_MULTI, SIGNED_OFF_BY,SPF_HELO_NONE,SPF_PASS,USER_AGENT_SANE_1 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 DADF0C432C0 for ; Tue, 3 Dec 2019 18:17:17 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [209.132.180.67]) by mail.kernel.org (Postfix) with ESMTP id 8D73320661 for ; Tue, 3 Dec 2019 18:17:17 +0000 (UTC) Authentication-Results: mail.kernel.org; dkim=pass (1024-bit key) header.d=ideasonboard.com header.i=@ideasonboard.com header.b="JI/UVR1x" Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1726628AbfLCSRR (ORCPT ); Tue, 3 Dec 2019 13:17:17 -0500 Received: from perceval.ideasonboard.com ([213.167.242.64]:39392 "EHLO perceval.ideasonboard.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1726564AbfLCSRR (ORCPT ); Tue, 3 Dec 2019 13:17:17 -0500 Received: from pendragon.ideasonboard.com (81-175-216-236.bb.dnainternet.fi [81.175.216.236]) by perceval.ideasonboard.com (Postfix) with ESMTPSA id AE4AD309; Tue, 3 Dec 2019 19:17:12 +0100 (CET) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=ideasonboard.com; s=mail; t=1575397032; bh=NX5JWI3hET+/MB7TF0ps9TJ/voJtAAEfFbkaQ/yWSxY=; h=Date:From:To:Cc:Subject:References:In-Reply-To:From; b=JI/UVR1xE+l6nEhz0D26iSjp/dhCC1gmnHewe0xtB1V4ubxy/rAgg1s0E+lO1+NWV KKZ5i5A+OSIrwdD1/Xk5QJOn4DduXYJqYDns69t2yXonJjvUQ/+WA+xcyzG8hMyL5V OblqhXQiwx+WFTRY5h39nc0N5lJdX/wTdS9MtsJ4= Date: Tue, 3 Dec 2019 20:17:05 +0200 From: Laurent Pinchart To: Boris Brezillon Cc: dri-devel@lists.freedesktop.org, 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 , Jonas Karlman , Jernej Skrabec , Rob Herring , Mark Rutland , devicetree@vger.kernel.org, Eric Anholt Subject: Re: [PATCH v4 08/11] drm/bridge: Add a drm_bridge_state object Message-ID: <20191203181705.GT4730@pendragon.ideasonboard.com> References: <20191203141515.3597631-1-boris.brezillon@collabora.com> <20191203141515.3597631-9-boris.brezillon@collabora.com> MIME-Version: 1.0 Content-Type: text/plain; charset=utf-8 Content-Disposition: inline In-Reply-To: <20191203141515.3597631-9-boris.brezillon@collabora.com> User-Agent: Mutt/1.10.1 (2018-07-13) Sender: devicetree-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: devicetree@vger.kernel.org Hi Boris, Thank you for the patch. On Tue, Dec 03, 2019 at 03:15:12PM +0100, Boris Brezillon wrote: > 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 > Reviewed-by: Neil Armstrong > --- > Changes in v4: > * Fix the doc > * Kill default helpers (inlined) I liked the default helpers, inlining their content makes the code more difficult to follow in my opinion. I will however not push back if you prefer not to have them. > * Fix drm_atomic_get_bridge_state() to check for an ERR_PTR() > * Add Neil's R-b > > 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 | 118 ++++++++++++++++++++++++++-- > include/drm/drm_atomic.h | 3 + > include/drm/drm_bridge.h | 116 +++++++++++++++++++++++++++ > 5 files changed, 290 insertions(+), 6 deletions(-) > > diff --git a/drivers/gpu/drm/drm_atomic.c b/drivers/gpu/drm/drm_atomic.c > index 14aeaf736321..02f8034f5240 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 > @@ -1015,6 +1016,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 29c3115bf9e2..e2f7f336a2d2 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 b6517b4fa3d1..bf5a2243a115 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,48 @@ 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); > + > + return state ? &state->base : NULL; > + } > + > + if (WARN_ON(!bridge->base.state)) > + return NULL; > + > + state = kzalloc(sizeof(*state), GFP_KERNEL); > + if (!state) > + return NULL; > + > + __drm_atomic_helper_bridge_duplicate_state(bridge, state); > + > + 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 > + kfree(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 +157,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; > int ret; > > if (!encoder || !bridge) > @@ -135,15 +179,40 @@ int drm_bridge_attach(struct drm_encoder *encoder, struct drm_bridge *bridge, > > if (bridge->funcs->attach) { > ret = bridge->funcs->attach(bridge); > - if (ret < 0) { > - list_del(&bridge->chain_node); > - 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 = kzalloc(sizeof(*state), GFP_KERNEL); > + if (state) > + __drm_atomic_helper_bridge_reset(bridge, state); > + else > + state = ERR_PTR(-ENOMEM); > + } > + > + 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); > + > return 0; > + > +err_detach_bridge: > + if (bridge->funcs->detach) > + bridge->funcs->detach(bridge); > + > +err_reset_bridge: > + bridge->dev = NULL; > + bridge->encoder = NULL; > + list_del(&bridge->chain_node); > + return ret; > } > EXPORT_SYMBOL(drm_bridge_attach); > > @@ -155,6 +224,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); > > @@ -516,6 +587,41 @@ void drm_atomic_bridge_chain_enable(struct drm_bridge *bridge, > } > EXPORT_SYMBOL(drm_atomic_bridge_chain_enable); > > +/** > + * __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 > + * > + * Initialize the bridge state to default values. This is meant to be* called s/be\*/be/ Reviewed-by: Laurent Pinchart > + * by the bridge &drm_plane_funcs.reset hook for bridges that subclass the > + * bridge state. > + */ > +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_duplicate_state() - Copy atomic bridge state > + * @bridge: bridge object > + * @state: atomic bridge state > + * > + * Copies atomic state from a bridge's current state and resets inferred values. > + * This is useful for drivers that subclass the bridge state. > + */ > +void __drm_atomic_helper_bridge_duplicate_state(struct drm_bridge *bridge, > + struct drm_bridge_state *state) > +{ > + __drm_atomic_helper_private_obj_duplicate_state(&bridge->base, > + &state->base); > + state->bridge = bridge; > +} > +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 b6c73fd9f55a..e08582773d6c 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 d7d714023050..db5fc18d49bd 100644 > --- a/include/drm/drm_bridge.h > +++ b/include/drm/drm_bridge.h > @@ -25,6 +25,8 @@ > > #include > #include > + > +#include > #include > #include > #include > @@ -33,6 +35,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 +357,49 @@ struct drm_bridge_funcs { > */ > void (*atomic_post_disable)(struct drm_bridge *bridge, > struct drm_atomic_state *old_state); > + > + /** > + * @atomic_duplicate_state: > + * > + * Duplicate the current bridge state object (which is guaranteed to be > + * non-NULL). > + * > + * The atomic_duplicate_state() is optional. When not implemented the > + * core allocates a drm_bridge_state object and calls > + * &__drm_atomic_helper_bridge_duplicate_state() to initialize it. > + * > + * 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. When not implemented the > + * core calls kfree() on the state. > + */ > + 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. When not implemented the core > + * allocates a new state and calls &__drm_atomic_helper_bridge_reset(). > + * > + * RETURNS: > + * A valid drm_bridge_state object in case of success, an ERR_PTR() > + * giving the reason of the failure otherwise. > + */ > + struct drm_bridge_state *(*atomic_reset)(struct drm_bridge *bridge); > }; > > /** > @@ -380,6 +442,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 +468,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); > @@ -491,6 +561,52 @@ 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_duplicate_state(struct drm_bridge *bridge, > + struct drm_bridge_state *new); > + > +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 (IS_ERR(obj_state)) > + return ERR_CAST(obj_state); > + > + 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.23.0 > -- Regards, Laurent Pinchart 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=-8.2 required=3.0 tests=HEADER_FROM_DIFFERENT_DOMAINS, INCLUDES_PATCH,MAILING_LIST_MULTI,SIGNED_OFF_BY,SPF_HELO_NONE,SPF_PASS, USER_AGENT_SANE_1 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 F1854C43215 for ; Tue, 3 Dec 2019 18:17:17 +0000 (UTC) Received: from gabe.freedesktop.org (gabe.freedesktop.org [131.252.210.177]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by mail.kernel.org (Postfix) with ESMTPS id CF67220833 for ; Tue, 3 Dec 2019 18:17:17 +0000 (UTC) DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org CF67220833 Authentication-Results: mail.kernel.org; dmarc=none (p=none dis=none) header.from=ideasonboard.com Authentication-Results: mail.kernel.org; spf=none smtp.mailfrom=dri-devel-bounces@lists.freedesktop.org Received: from gabe.freedesktop.org (localhost [127.0.0.1]) by gabe.freedesktop.org (Postfix) with ESMTP id E36356EA55; Tue, 3 Dec 2019 18:17:16 +0000 (UTC) Received: from perceval.ideasonboard.com (perceval.ideasonboard.com [213.167.242.64]) by gabe.freedesktop.org (Postfix) with ESMTPS id A561D6EA55 for ; Tue, 3 Dec 2019 18:17:15 +0000 (UTC) Received: from pendragon.ideasonboard.com (81-175-216-236.bb.dnainternet.fi [81.175.216.236]) by perceval.ideasonboard.com (Postfix) with ESMTPSA id AE4AD309; Tue, 3 Dec 2019 19:17:12 +0100 (CET) Date: Tue, 3 Dec 2019 20:17:05 +0200 From: Laurent Pinchart To: Boris Brezillon Subject: Re: [PATCH v4 08/11] drm/bridge: Add a drm_bridge_state object Message-ID: <20191203181705.GT4730@pendragon.ideasonboard.com> References: <20191203141515.3597631-1-boris.brezillon@collabora.com> <20191203141515.3597631-9-boris.brezillon@collabora.com> MIME-Version: 1.0 Content-Disposition: inline In-Reply-To: <20191203141515.3597631-9-boris.brezillon@collabora.com> User-Agent: Mutt/1.10.1 (2018-07-13) X-Mailman-Original-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=ideasonboard.com; s=mail; t=1575397032; bh=NX5JWI3hET+/MB7TF0ps9TJ/voJtAAEfFbkaQ/yWSxY=; h=Date:From:To:Cc:Subject:References:In-Reply-To:From; b=JI/UVR1xE+l6nEhz0D26iSjp/dhCC1gmnHewe0xtB1V4ubxy/rAgg1s0E+lO1+NWV KKZ5i5A+OSIrwdD1/Xk5QJOn4DduXYJqYDns69t2yXonJjvUQ/+WA+xcyzG8hMyL5V OblqhXQiwx+WFTRY5h39nc0N5lJdX/wTdS9MtsJ4= X-BeenThere: dri-devel@lists.freedesktop.org X-Mailman-Version: 2.1.23 Precedence: list List-Id: Direct Rendering Infrastructure - Development List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Cc: Mark Rutland , Neil Armstrong , dri-devel@lists.freedesktop.org, Thierry Reding , 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 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Errors-To: dri-devel-bounces@lists.freedesktop.org Sender: "dri-devel" SGkgQm9yaXMsCgpUaGFuayB5b3UgZm9yIHRoZSBwYXRjaC4KCk9uIFR1ZSwgRGVjIDAzLCAyMDE5 IGF0IDAzOjE1OjEyUE0gKzAxMDAsIEJvcmlzIEJyZXppbGxvbiB3cm90ZToKPiBPbmUgb2YgdGhl IGxhc3QgcmVtYWluaW5nIG9iamVjdHMgdG8gbm90IGhhdmUgaXRzIGF0b21pYyBzdGF0ZS4KPiAK PiBUaGlzIGlzIGJlaW5nIG1vdGl2YXRlZCBieSBvdXIgYXR0ZW1wdCB0byBzdXBwb3J0IHJ1bnRp bWUgYnVzLWZvcm1hdAo+IG5lZ290aWF0aW9uIGJldHdlZW4gZWxlbWVudHMgb2YgdGhlIGJyaWRn ZSBjaGFpbi4KPiBUaGlzIHBhdGNoIGp1c3QgcGF2ZXMgdGhlIHJvYWQgZm9yIHN1Y2ggYSBmZWF0 dXJlIGJ5IGFkZGluZyBhIG5ldwo+IGRybV9icmlkZ2Vfc3RhdGUgb2JqZWN0IGluaGVyaXRpbmcg ZnJvbSBkcm1fcHJpdmF0ZV9vYmogc28gd2UgY2FuCj4gcmUtdXNlIHNvbWUgb2YgdGhlIGV4aXN0 aW5nIHN0YXRlIGluaXRpYWxpemF0aW9uL3RyYWNraW5nIGxvZ2ljLgo+IAo+IFNpZ25lZC1vZmYt Ynk6IEJvcmlzIEJyZXppbGxvbiA8Ym9yaXMuYnJlemlsbG9uQGNvbGxhYm9yYS5jb20+Cj4gUmV2 aWV3ZWQtYnk6IE5laWwgQXJtc3Ryb25nIDxuYXJtc3Ryb25nQGJheWxpYnJlLmNvbT4KPiAtLS0K PiBDaGFuZ2VzIGluIHY0Ogo+ICogRml4IHRoZSBkb2MKPiAqIEtpbGwgZGVmYXVsdCBoZWxwZXJz IChpbmxpbmVkKQoKSSBsaWtlZCB0aGUgZGVmYXVsdCBoZWxwZXJzLCBpbmxpbmluZyB0aGVpciBj b250ZW50IG1ha2VzIHRoZSBjb2RlIG1vcmUKZGlmZmljdWx0IHRvIGZvbGxvdyBpbiBteSBvcGlu aW9uLiBJIHdpbGwgaG93ZXZlciBub3QgcHVzaCBiYWNrIGlmIHlvdQpwcmVmZXIgbm90IHRvIGhh dmUgdGhlbS4KCj4gKiBGaXggZHJtX2F0b21pY19nZXRfYnJpZGdlX3N0YXRlKCkgdG8gY2hlY2sg Zm9yIGFuIEVSUl9QVFIoKQo+ICogQWRkIE5laWwncyBSLWIKPiAKPiBDaGFuZ2VzIGluIHYzOgo+ ICogTm9uZQo+IAo+IENoYW5nZXMgaW4gdjI6Cj4gKiBVc2UgZHJtX2Zvcl9lYWNoX2JyaWRnZV9p bl9jaGFpbigpCj4gKiBSZW5hbWUgaGVscGVycyB0byBiZSBtb3JlIGNvbnNpc3RlbnQgd2l0aCB0 aGUgcmVzdCBvZiB0aGUgRFJNIEFQSQo+ICogSW1wcm92ZS9maXggdGhlIGRvYwo+IC0tLQo+ICBk cml2ZXJzL2dwdS9kcm0vZHJtX2F0b21pYy5jICAgICAgICB8ICAzOSArKysrKysrKysKPiAgZHJp dmVycy9ncHUvZHJtL2RybV9hdG9taWNfaGVscGVyLmMgfCAgMjAgKysrKysKPiAgZHJpdmVycy9n cHUvZHJtL2RybV9icmlkZ2UuYyAgICAgICAgfCAxMTggKysrKysrKysrKysrKysrKysrKysrKysr KystLQo+ICBpbmNsdWRlL2RybS9kcm1fYXRvbWljLmggICAgICAgICAgICB8ICAgMyArCj4gIGlu Y2x1ZGUvZHJtL2RybV9icmlkZ2UuaCAgICAgICAgICAgIHwgMTE2ICsrKysrKysrKysrKysrKysr KysrKysrKysrKwo+ICA1IGZpbGVzIGNoYW5nZWQsIDI5MCBpbnNlcnRpb25zKCspLCA2IGRlbGV0 aW9ucygtKQo+IAo+IGRpZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9kcm0vZHJtX2F0b21pYy5jIGIv ZHJpdmVycy9ncHUvZHJtL2RybV9hdG9taWMuYwo+IGluZGV4IDE0YWVhZjczNjMyMS4uMDJmODAz NGY1MjQwIDEwMDY0NAo+IC0tLSBhL2RyaXZlcnMvZ3B1L2RybS9kcm1fYXRvbWljLmMKPiArKysg Yi9kcml2ZXJzL2dwdS9kcm0vZHJtX2F0b21pYy5jCj4gQEAgLTMwLDYgKzMwLDcgQEAKPiAgCj4g ICNpbmNsdWRlIDxkcm0vZHJtX2F0b21pYy5oPgo+ICAjaW5jbHVkZSA8ZHJtL2RybV9hdG9taWNf dWFwaS5oPgo+ICsjaW5jbHVkZSA8ZHJtL2RybV9icmlkZ2UuaD4KPiAgI2luY2x1ZGUgPGRybS9k cm1fZGVidWdmcy5oPgo+ICAjaW5jbHVkZSA8ZHJtL2RybV9kZXZpY2UuaD4KPiAgI2luY2x1ZGUg PGRybS9kcm1fZHJ2Lmg+Cj4gQEAgLTEwMTUsNiArMTAxNiw0NCBAQCBzdGF0aWMgdm9pZCBkcm1f YXRvbWljX2Nvbm5lY3Rvcl9wcmludF9zdGF0ZShzdHJ1Y3QgZHJtX3ByaW50ZXIgKnAsCj4gIAkJ Y29ubmVjdG9yLT5mdW5jcy0+YXRvbWljX3ByaW50X3N0YXRlKHAsIHN0YXRlKTsKPiAgfQo+ICAK PiArLyoqCj4gKyAqIGRybV9hdG9taWNfYWRkX2VuY29kZXJfYnJpZGdlcyAtIGFkZCBicmlkZ2Vz IGF0dGFjaGVkIHRvIGFuIGVuY29kZXIKPiArICogQHN0YXRlOiBhdG9taWMgc3RhdGUKPiArICog QGVuY29kZXI6IERSTSBlbmNvZGVyCj4gKyAqCj4gKyAqIFRoaXMgZnVuY3Rpb24gYWRkcyBhbGwg YnJpZGdlcyBhdHRhY2hlZCB0byBAZW5jb2Rlci4gVGhpcyBpcyBuZWVkZWQgdG8gYWRkCj4gKyAq IGJyaWRnZSBzdGF0ZXMgdG8gQHN0YXRlIGFuZCBtYWtlIHRoZW0gYXZhaWxhYmxlIHdoZW4KPiAr ICogJmJyaWRnZV9mdW5jcy5hdG9taWNfe2NoZWNrLHByZV9lbmFibGUsZW5hYmxlLGRpc2FibGVf cG9zdF9kaXNhYmxlfSgpIGFyZQo+ICsgKiBjYWxsZWQKPiArICoKPiArICogUmV0dXJuczoKPiAr ICogMCBvbiBzdWNjZXNzIG9yIGNhbiBmYWlsIHdpdGggLUVERUFETEsgb3IgLUVOT01FTS4gV2hl biB0aGUgZXJyb3IgaXMgRURFQURMSwo+ICsgKiB0aGVuIHRoZSB3L3cgbXV0ZXggY29kZSBoYXMg ZGV0ZWN0ZWQgYSBkZWFkbG9jayBhbmQgdGhlIGVudGlyZSBhdG9taWMKPiArICogc2VxdWVuY2Ug bXVzdCBiZSByZXN0YXJ0ZWQuIEFsbCBvdGhlciBlcnJvcnMgYXJlIGZhdGFsLgo+ICsgKi8KPiAr aW50Cj4gK2RybV9hdG9taWNfYWRkX2VuY29kZXJfYnJpZGdlcyhzdHJ1Y3QgZHJtX2F0b21pY19z dGF0ZSAqc3RhdGUsCj4gKwkJCSAgICAgICBzdHJ1Y3QgZHJtX2VuY29kZXIgKmVuY29kZXIpCj4g K3sKPiArCXN0cnVjdCBkcm1fYnJpZGdlX3N0YXRlICpicmlkZ2Vfc3RhdGU7Cj4gKwlzdHJ1Y3Qg ZHJtX2JyaWRnZSAqYnJpZGdlOwo+ICsKPiArCWlmICghZW5jb2RlcikKPiArCQlyZXR1cm4gMDsK PiArCj4gKwlEUk1fREVCVUdfQVRPTUlDKCJBZGRpbmcgYWxsIGJyaWRnZXMgZm9yIFtlbmNvZGVy OiVkOiVzXSB0byAlcFxuIiwKPiArCQkJIGVuY29kZXItPmJhc2UuaWQsIGVuY29kZXItPm5hbWUs IHN0YXRlKTsKPiArCj4gKwlkcm1fZm9yX2VhY2hfYnJpZGdlX2luX2NoYWluKGVuY29kZXIsIGJy aWRnZSkgewo+ICsJCWJyaWRnZV9zdGF0ZSA9IGRybV9hdG9taWNfZ2V0X2JyaWRnZV9zdGF0ZShz dGF0ZSwgYnJpZGdlKTsKPiArCQlpZiAoSVNfRVJSKGJyaWRnZV9zdGF0ZSkpCj4gKwkJCXJldHVy biBQVFJfRVJSKGJyaWRnZV9zdGF0ZSk7Cj4gKwl9Cj4gKwo+ICsJcmV0dXJuIDA7Cj4gK30KPiAr RVhQT1JUX1NZTUJPTChkcm1fYXRvbWljX2FkZF9lbmNvZGVyX2JyaWRnZXMpOwo+ICsKPiAgLyoq Cj4gICAqIGRybV9hdG9taWNfYWRkX2FmZmVjdGVkX2Nvbm5lY3RvcnMgLSBhZGQgY29ubmVjdG9y cyBmb3IgY3J0Ywo+ICAgKiBAc3RhdGU6IGF0b21pYyBzdGF0ZQo+IGRpZmYgLS1naXQgYS9kcml2 ZXJzL2dwdS9kcm0vZHJtX2F0b21pY19oZWxwZXIuYyBiL2RyaXZlcnMvZ3B1L2RybS9kcm1fYXRv bWljX2hlbHBlci5jCj4gaW5kZXggMjljMzExNWJmOWUyLi5lMmY3ZjMzNmEyZDIgMTAwNjQ0Cj4g LS0tIGEvZHJpdmVycy9ncHUvZHJtL2RybV9hdG9taWNfaGVscGVyLmMKPiArKysgYi9kcml2ZXJz L2dwdS9kcm0vZHJtX2F0b21pY19oZWxwZXIuYwo+IEBAIC03MzAsNiArNzMwLDI2IEBAIGRybV9h dG9taWNfaGVscGVyX2NoZWNrX21vZGVzZXQoc3RydWN0IGRybV9kZXZpY2UgKmRldiwKPiAgCQkJ cmV0dXJuIHJldDsKPiAgCX0KPiAgCj4gKwkvKgo+ICsJICogSXRlcmF0ZSBvdmVyIGFsbCBjb25u ZWN0b3JzIGFnYWluLCBhbmQgYWRkIGFsbCBhZmZlY3RlZCBicmlkZ2VzIHRvCj4gKwkgKiB0aGUg c3RhdGUuCj4gKwkgKi8KPiArCWZvcl9lYWNoX29sZG5ld19jb25uZWN0b3JfaW5fc3RhdGUoc3Rh dGUsIGNvbm5lY3RvciwKPiArCQkJCQkgICBvbGRfY29ubmVjdG9yX3N0YXRlLAo+ICsJCQkJCSAg IG5ld19jb25uZWN0b3Jfc3RhdGUsIGkpIHsKPiArCQlzdHJ1Y3QgZHJtX2VuY29kZXIgKmVuY29k ZXI7Cj4gKwo+ICsJCWVuY29kZXIgPSBvbGRfY29ubmVjdG9yX3N0YXRlLT5iZXN0X2VuY29kZXI7 Cj4gKwkJcmV0ID0gZHJtX2F0b21pY19hZGRfZW5jb2Rlcl9icmlkZ2VzKHN0YXRlLCBlbmNvZGVy KTsKPiArCQlpZiAocmV0KQo+ICsJCQlyZXR1cm4gcmV0Owo+ICsKPiArCQllbmNvZGVyID0gbmV3 X2Nvbm5lY3Rvcl9zdGF0ZS0+YmVzdF9lbmNvZGVyOwo+ICsJCXJldCA9IGRybV9hdG9taWNfYWRk X2VuY29kZXJfYnJpZGdlcyhzdGF0ZSwgZW5jb2Rlcik7Cj4gKwkJaWYgKHJldCkKPiArCQkJcmV0 dXJuIHJldDsKPiArCX0KPiArCj4gIAlyZXQgPSBtb2RlX3ZhbGlkKHN0YXRlKTsKPiAgCWlmIChy ZXQpCj4gIAkJcmV0dXJuIHJldDsKPiBkaWZmIC0tZ2l0IGEvZHJpdmVycy9ncHUvZHJtL2RybV9i cmlkZ2UuYyBiL2RyaXZlcnMvZ3B1L2RybS9kcm1fYnJpZGdlLmMKPiBpbmRleCBiNjUxN2I0ZmEz ZDEuLmJmNWEyMjQzYTExNSAxMDA2NDQKPiAtLS0gYS9kcml2ZXJzL2dwdS9kcm0vZHJtX2JyaWRn ZS5jCj4gKysrIGIvZHJpdmVycy9ncHUvZHJtL2RybV9icmlkZ2UuYwo+IEBAIC0yNSw2ICsyNSw3 IEBACj4gICNpbmNsdWRlIDxsaW51eC9tb2R1bGUuaD4KPiAgI2luY2x1ZGUgPGxpbnV4L211dGV4 Lmg+Cj4gIAo+ICsjaW5jbHVkZSA8ZHJtL2RybV9hdG9taWNfc3RhdGVfaGVscGVyLmg+Cj4gICNp bmNsdWRlIDxkcm0vZHJtX2JyaWRnZS5oPgo+ICAjaW5jbHVkZSA8ZHJtL2RybV9lbmNvZGVyLmg+ Cj4gIAo+IEBAIC04OSw2ICs5MCw0OCBAQCB2b2lkIGRybV9icmlkZ2VfcmVtb3ZlKHN0cnVjdCBk cm1fYnJpZGdlICpicmlkZ2UpCj4gIH0KPiAgRVhQT1JUX1NZTUJPTChkcm1fYnJpZGdlX3JlbW92 ZSk7Cj4gIAo+ICtzdGF0aWMgc3RydWN0IGRybV9wcml2YXRlX3N0YXRlICoKPiArZHJtX2JyaWRn ZV9hdG9taWNfZHVwbGljYXRlX3ByaXZfc3RhdGUoc3RydWN0IGRybV9wcml2YXRlX29iaiAqb2Jq KQo+ICt7Cj4gKwlzdHJ1Y3QgZHJtX2JyaWRnZSAqYnJpZGdlID0gZHJtX3ByaXZfdG9fYnJpZGdl KG9iaik7Cj4gKwlzdHJ1Y3QgZHJtX2JyaWRnZV9zdGF0ZSAqc3RhdGU7Cj4gKwo+ICsJaWYgKGJy aWRnZS0+ZnVuY3MtPmF0b21pY19kdXBsaWNhdGVfc3RhdGUpIHsKPiArCQlzdGF0ZSA9IGJyaWRn ZS0+ZnVuY3MtPmF0b21pY19kdXBsaWNhdGVfc3RhdGUoYnJpZGdlKTsKPiArCj4gKwkJcmV0dXJu IHN0YXRlID8gJnN0YXRlLT5iYXNlIDogTlVMTDsKPiArCX0KPiArCj4gKwlpZiAoV0FSTl9PTigh YnJpZGdlLT5iYXNlLnN0YXRlKSkKPiArCQlyZXR1cm4gTlVMTDsKPiArCj4gKwlzdGF0ZSA9IGt6 YWxsb2Moc2l6ZW9mKCpzdGF0ZSksIEdGUF9LRVJORUwpOwo+ICsJaWYgKCFzdGF0ZSkKPiArCQly ZXR1cm4gTlVMTDsKPiArCj4gKwlfX2RybV9hdG9taWNfaGVscGVyX2JyaWRnZV9kdXBsaWNhdGVf c3RhdGUoYnJpZGdlLCBzdGF0ZSk7Cj4gKwo+ICsJcmV0dXJuICZzdGF0ZS0+YmFzZTsKPiArfQo+ ICsKPiArc3RhdGljIHZvaWQKPiArZHJtX2JyaWRnZV9hdG9taWNfZGVzdHJveV9wcml2X3N0YXRl KHN0cnVjdCBkcm1fcHJpdmF0ZV9vYmogKm9iaiwKPiArCQkJCSAgICAgc3RydWN0IGRybV9wcml2 YXRlX3N0YXRlICpzKQo+ICt7Cj4gKwlzdHJ1Y3QgZHJtX2JyaWRnZV9zdGF0ZSAqc3RhdGUgPSBk cm1fcHJpdl90b19icmlkZ2Vfc3RhdGUocyk7Cj4gKwlzdHJ1Y3QgZHJtX2JyaWRnZSAqYnJpZGdl ID0gZHJtX3ByaXZfdG9fYnJpZGdlKG9iaik7Cj4gKwo+ICsJaWYgKGJyaWRnZS0+ZnVuY3MtPmF0 b21pY19kZXN0cm95X3N0YXRlKQo+ICsJCWJyaWRnZS0+ZnVuY3MtPmF0b21pY19kZXN0cm95X3N0 YXRlKGJyaWRnZSwgc3RhdGUpOwo+ICsJZWxzZQo+ICsJCWtmcmVlKHN0YXRlKTsKPiArfQo+ICsK PiArc3RhdGljIGNvbnN0IHN0cnVjdCBkcm1fcHJpdmF0ZV9zdGF0ZV9mdW5jcyBkcm1fYnJpZGdl X3ByaXZfc3RhdGVfZnVuY3MgPSB7Cj4gKwkuYXRvbWljX2R1cGxpY2F0ZV9zdGF0ZSA9IGRybV9i cmlkZ2VfYXRvbWljX2R1cGxpY2F0ZV9wcml2X3N0YXRlLAo+ICsJLmF0b21pY19kZXN0cm95X3N0 YXRlID0gZHJtX2JyaWRnZV9hdG9taWNfZGVzdHJveV9wcml2X3N0YXRlLAo+ICt9Owo+ICsKPiAg LyoqCj4gICAqIGRybV9icmlkZ2VfYXR0YWNoIC0gYXR0YWNoIHRoZSBicmlkZ2UgdG8gYW4gZW5j b2RlcidzIGNoYWluCj4gICAqCj4gQEAgLTExNCw2ICsxNTcsNyBAQCBFWFBPUlRfU1lNQk9MKGRy bV9icmlkZ2VfcmVtb3ZlKTsKPiAgaW50IGRybV9icmlkZ2VfYXR0YWNoKHN0cnVjdCBkcm1fZW5j b2RlciAqZW5jb2Rlciwgc3RydWN0IGRybV9icmlkZ2UgKmJyaWRnZSwKPiAgCQkgICAgICBzdHJ1 Y3QgZHJtX2JyaWRnZSAqcHJldmlvdXMpCj4gIHsKPiArCXN0cnVjdCBkcm1fYnJpZGdlX3N0YXRl ICpzdGF0ZTsKPiAgCWludCByZXQ7Cj4gIAo+ICAJaWYgKCFlbmNvZGVyIHx8ICFicmlkZ2UpCj4g QEAgLTEzNSwxNSArMTc5LDQwIEBAIGludCBkcm1fYnJpZGdlX2F0dGFjaChzdHJ1Y3QgZHJtX2Vu Y29kZXIgKmVuY29kZXIsIHN0cnVjdCBkcm1fYnJpZGdlICpicmlkZ2UsCj4gIAo+ICAJaWYgKGJy aWRnZS0+ZnVuY3MtPmF0dGFjaCkgewo+ICAJCXJldCA9IGJyaWRnZS0+ZnVuY3MtPmF0dGFjaChi cmlkZ2UpOwo+IC0JCWlmIChyZXQgPCAwKSB7Cj4gLQkJCWxpc3RfZGVsKCZicmlkZ2UtPmNoYWlu X25vZGUpOwo+IC0JCQlicmlkZ2UtPmRldiA9IE5VTEw7Cj4gLQkJCWJyaWRnZS0+ZW5jb2RlciA9 IE5VTEw7Cj4gLQkJCXJldHVybiByZXQ7Cj4gLQkJfQo+ICsJCWlmIChyZXQgPCAwKQo+ICsJCQln b3RvIGVycl9yZXNldF9icmlkZ2U7Cj4gIAl9Cj4gIAo+ICsJaWYgKGJyaWRnZS0+ZnVuY3MtPmF0 b21pY19yZXNldCkgewo+ICsJCXN0YXRlID0gYnJpZGdlLT5mdW5jcy0+YXRvbWljX3Jlc2V0KGJy aWRnZSk7Cj4gKwl9IGVsc2Ugewo+ICsJCXN0YXRlID0ga3phbGxvYyhzaXplb2YoKnN0YXRlKSwg R0ZQX0tFUk5FTCk7Cj4gKwkJaWYgKHN0YXRlKQo+ICsJCQlfX2RybV9hdG9taWNfaGVscGVyX2Jy aWRnZV9yZXNldChicmlkZ2UsIHN0YXRlKTsKPiArCQllbHNlCj4gKwkJCXN0YXRlID0gRVJSX1BU UigtRU5PTUVNKTsKPiArCX0KPiArCj4gKwlpZiAoSVNfRVJSKHN0YXRlKSkgewo+ICsJCXJldCA9 IFBUUl9FUlIoc3RhdGUpOwo+ICsJCWdvdG8gZXJyX2RldGFjaF9icmlkZ2U7Cj4gKwl9Cj4gKwo+ ICsJZHJtX2F0b21pY19wcml2YXRlX29ial9pbml0KGJyaWRnZS0+ZGV2LCAmYnJpZGdlLT5iYXNl LAo+ICsJCQkJICAgICZzdGF0ZS0+YmFzZSwKPiArCQkJCSAgICAmZHJtX2JyaWRnZV9wcml2X3N0 YXRlX2Z1bmNzKTsKPiArCj4gIAlyZXR1cm4gMDsKPiArCj4gK2Vycl9kZXRhY2hfYnJpZGdlOgo+ ICsJaWYgKGJyaWRnZS0+ZnVuY3MtPmRldGFjaCkKPiArCQlicmlkZ2UtPmZ1bmNzLT5kZXRhY2go YnJpZGdlKTsKPiArCj4gK2Vycl9yZXNldF9icmlkZ2U6Cj4gKwlicmlkZ2UtPmRldiA9IE5VTEw7 Cj4gKwlicmlkZ2UtPmVuY29kZXIgPSBOVUxMOwo+ICsJbGlzdF9kZWwoJmJyaWRnZS0+Y2hhaW5f bm9kZSk7Cj4gKwlyZXR1cm4gcmV0Owo+ICB9Cj4gIEVYUE9SVF9TWU1CT0woZHJtX2JyaWRnZV9h dHRhY2gpOwo+ICAKPiBAQCAtMTU1LDYgKzIyNCw4IEBAIHZvaWQgZHJtX2JyaWRnZV9kZXRhY2go c3RydWN0IGRybV9icmlkZ2UgKmJyaWRnZSkKPiAgCWlmIChXQVJOX09OKCFicmlkZ2UtPmRldikp Cj4gIAkJcmV0dXJuOwo+ICAKPiArCWRybV9hdG9taWNfcHJpdmF0ZV9vYmpfZmluaSgmYnJpZGdl LT5iYXNlKTsKPiArCj4gIAlpZiAoYnJpZGdlLT5mdW5jcy0+ZGV0YWNoKQo+ICAJCWJyaWRnZS0+ ZnVuY3MtPmRldGFjaChicmlkZ2UpOwo+ICAKPiBAQCAtNTE2LDYgKzU4Nyw0MSBAQCB2b2lkIGRy bV9hdG9taWNfYnJpZGdlX2NoYWluX2VuYWJsZShzdHJ1Y3QgZHJtX2JyaWRnZSAqYnJpZGdlLAo+ ICB9Cj4gIEVYUE9SVF9TWU1CT0woZHJtX2F0b21pY19icmlkZ2VfY2hhaW5fZW5hYmxlKTsKPiAg Cj4gKy8qKgo+ICsgKiBfX2RybV9hdG9taWNfaGVscGVyX2JyaWRnZV9yZXNldCgpIC0gSW5pdGlh bGl6ZSBhIGJyaWRnZSBzdGF0ZSB0byBpdHMKPiArICoJCQkJCWRlZmF1bHQKPiArICogQGJyaWRn ZTogdGhlIGJyaWRnZSB0aGlzIHN0YXRlIGlzIHJlZmVycyB0bwo+ICsgKiBAc3RhdGU6IGJyaWRn ZSBzdGF0ZSB0byBpbml0aWFsaXplCj4gKyAqCj4gKyAqIEluaXRpYWxpemUgdGhlIGJyaWRnZSBz dGF0ZSB0byBkZWZhdWx0IHZhbHVlcy4gVGhpcyBpcyBtZWFudCB0byBiZSogY2FsbGVkCgpzL2Jl XCovYmUvCgpSZXZpZXdlZC1ieTogTGF1cmVudCBQaW5jaGFydCA8bGF1cmVudC5waW5jaGFydEBp ZGVhc29uYm9hcmQuY29tPgoKPiArICogYnkgdGhlIGJyaWRnZSAmZHJtX3BsYW5lX2Z1bmNzLnJl c2V0IGhvb2sgZm9yIGJyaWRnZXMgdGhhdCBzdWJjbGFzcyB0aGUKPiArICogYnJpZGdlIHN0YXRl Lgo+ICsgKi8KPiArdm9pZCBfX2RybV9hdG9taWNfaGVscGVyX2JyaWRnZV9yZXNldChzdHJ1Y3Qg ZHJtX2JyaWRnZSAqYnJpZGdlLAo+ICsJCQkJICAgICAgc3RydWN0IGRybV9icmlkZ2Vfc3RhdGUg KnN0YXRlKQo+ICt7Cj4gKwltZW1zZXQoc3RhdGUsIDAsIHNpemVvZigqc3RhdGUpKTsKPiArCXN0 YXRlLT5icmlkZ2UgPSBicmlkZ2U7Cj4gK30KPiArRVhQT1JUX1NZTUJPTChfX2RybV9hdG9taWNf aGVscGVyX2JyaWRnZV9yZXNldCk7Cj4gKwo+ICsvKioKPiArICogX19kcm1fYXRvbWljX2hlbHBl cl9icmlkZ2VfZHVwbGljYXRlX3N0YXRlKCkgLSBDb3B5IGF0b21pYyBicmlkZ2Ugc3RhdGUKPiAr ICogQGJyaWRnZTogYnJpZGdlIG9iamVjdAo+ICsgKiBAc3RhdGU6IGF0b21pYyBicmlkZ2Ugc3Rh dGUKPiArICoKPiArICogQ29waWVzIGF0b21pYyBzdGF0ZSBmcm9tIGEgYnJpZGdlJ3MgY3VycmVu dCBzdGF0ZSBhbmQgcmVzZXRzIGluZmVycmVkIHZhbHVlcy4KPiArICogVGhpcyBpcyB1c2VmdWwg Zm9yIGRyaXZlcnMgdGhhdCBzdWJjbGFzcyB0aGUgYnJpZGdlIHN0YXRlLgo+ICsgKi8KPiArdm9p ZCBfX2RybV9hdG9taWNfaGVscGVyX2JyaWRnZV9kdXBsaWNhdGVfc3RhdGUoc3RydWN0IGRybV9i cmlkZ2UgKmJyaWRnZSwKPiArCQkJCQkJc3RydWN0IGRybV9icmlkZ2Vfc3RhdGUgKnN0YXRlKQo+ ICt7Cj4gKwlfX2RybV9hdG9taWNfaGVscGVyX3ByaXZhdGVfb2JqX2R1cGxpY2F0ZV9zdGF0ZSgm YnJpZGdlLT5iYXNlLAo+ICsJCQkJCQkJJnN0YXRlLT5iYXNlKTsKPiArCXN0YXRlLT5icmlkZ2Ug PSBicmlkZ2U7Cj4gK30KPiArRVhQT1JUX1NZTUJPTChfX2RybV9hdG9taWNfaGVscGVyX2JyaWRn ZV9kdXBsaWNhdGVfc3RhdGUpOwo+ICsKPiAgI2lmZGVmIENPTkZJR19PRgo+ICAvKioKPiAgICog b2ZfZHJtX2ZpbmRfYnJpZGdlIC0gZmluZCB0aGUgYnJpZGdlIGNvcnJlc3BvbmRpbmcgdG8gdGhl IGRldmljZSBub2RlIGluCj4gZGlmZiAtLWdpdCBhL2luY2x1ZGUvZHJtL2RybV9hdG9taWMuaCBi L2luY2x1ZGUvZHJtL2RybV9hdG9taWMuaAo+IGluZGV4IGI2YzczZmQ5ZjU1YS4uZTA4NTgyNzcz ZDZjIDEwMDY0NAo+IC0tLSBhL2luY2x1ZGUvZHJtL2RybV9hdG9taWMuaAo+ICsrKyBiL2luY2x1 ZGUvZHJtL2RybV9hdG9taWMuaAo+IEBAIC02NjAsNiArNjYwLDkgQEAgX19kcm1fYXRvbWljX2dl dF9jdXJyZW50X3BsYW5lX3N0YXRlKHN0cnVjdCBkcm1fYXRvbWljX3N0YXRlICpzdGF0ZSwKPiAg CXJldHVybiBwbGFuZS0+c3RhdGU7Cj4gIH0KPiAgCj4gK2ludCBfX211c3RfY2hlY2sKPiArZHJt X2F0b21pY19hZGRfZW5jb2Rlcl9icmlkZ2VzKHN0cnVjdCBkcm1fYXRvbWljX3N0YXRlICpzdGF0 ZSwKPiArCQkJICAgICAgIHN0cnVjdCBkcm1fZW5jb2RlciAqZW5jb2Rlcik7Cj4gIGludCBfX211 c3RfY2hlY2sKPiAgZHJtX2F0b21pY19hZGRfYWZmZWN0ZWRfY29ubmVjdG9ycyhzdHJ1Y3QgZHJt X2F0b21pY19zdGF0ZSAqc3RhdGUsCj4gIAkJCQkgICBzdHJ1Y3QgZHJtX2NydGMgKmNydGMpOwo+ IGRpZmYgLS1naXQgYS9pbmNsdWRlL2RybS9kcm1fYnJpZGdlLmggYi9pbmNsdWRlL2RybS9kcm1f YnJpZGdlLmgKPiBpbmRleCBkN2Q3MTQwMjMwNTAuLmRiNWZjMThkNDliZCAxMDA2NDQKPiAtLS0g YS9pbmNsdWRlL2RybS9kcm1fYnJpZGdlLmgKPiArKysgYi9pbmNsdWRlL2RybS9kcm1fYnJpZGdl LmgKPiBAQCAtMjUsNiArMjUsOCBAQAo+ICAKPiAgI2luY2x1ZGUgPGxpbnV4L2xpc3QuaD4KPiAg I2luY2x1ZGUgPGxpbnV4L2N0eXBlLmg+Cj4gKwo+ICsjaW5jbHVkZSA8ZHJtL2RybV9hdG9taWMu aD4KPiAgI2luY2x1ZGUgPGRybS9kcm1fZW5jb2Rlci5oPgo+ICAjaW5jbHVkZSA8ZHJtL2RybV9t b2RlX29iamVjdC5oPgo+ICAjaW5jbHVkZSA8ZHJtL2RybV9tb2Rlcy5oPgo+IEBAIC0zMyw2ICsz NSwyMyBAQCBzdHJ1Y3QgZHJtX2JyaWRnZTsKPiAgc3RydWN0IGRybV9icmlkZ2VfdGltaW5nczsK PiAgc3RydWN0IGRybV9wYW5lbDsKPiAgCj4gKy8qKgo+ICsgKiBzdHJ1Y3QgZHJtX2JyaWRnZV9z dGF0ZSAtIEF0b21pYyBicmlkZ2Ugc3RhdGUgb2JqZWN0Cj4gKyAqIEBiYXNlOiBpbmhlcml0IGZy b20gJmRybV9wcml2YXRlX3N0YXRlCj4gKyAqIEBicmlkZ2U6IHRoZSBicmlkZ2UgdGhpcyBzdGF0 ZSByZWZlcnMgdG8KPiArICovCj4gK3N0cnVjdCBkcm1fYnJpZGdlX3N0YXRlIHsKPiArCXN0cnVj dCBkcm1fcHJpdmF0ZV9zdGF0ZSBiYXNlOwo+ICsKPiArCXN0cnVjdCBkcm1fYnJpZGdlICpicmlk Z2U7Cj4gK307Cj4gKwo+ICtzdGF0aWMgaW5saW5lIHN0cnVjdCBkcm1fYnJpZGdlX3N0YXRlICoK PiArZHJtX3ByaXZfdG9fYnJpZGdlX3N0YXRlKHN0cnVjdCBkcm1fcHJpdmF0ZV9zdGF0ZSAqcHJp dikKPiArewo+ICsJcmV0dXJuIGNvbnRhaW5lcl9vZihwcml2LCBzdHJ1Y3QgZHJtX2JyaWRnZV9z dGF0ZSwgYmFzZSk7Cj4gK30KPiArCj4gIC8qKgo+ICAgKiBzdHJ1Y3QgZHJtX2JyaWRnZV9mdW5j cyAtIGRybV9icmlkZ2UgY29udHJvbCBmdW5jdGlvbnMKPiAgICovCj4gQEAgLTMzOCw2ICszNTcs NDkgQEAgc3RydWN0IGRybV9icmlkZ2VfZnVuY3Mgewo+ICAJICovCj4gIAl2b2lkICgqYXRvbWlj X3Bvc3RfZGlzYWJsZSkoc3RydWN0IGRybV9icmlkZ2UgKmJyaWRnZSwKPiAgCQkJCSAgICBzdHJ1 Y3QgZHJtX2F0b21pY19zdGF0ZSAqb2xkX3N0YXRlKTsKPiArCj4gKwkvKioKPiArCSAqIEBhdG9t aWNfZHVwbGljYXRlX3N0YXRlOgo+ICsJICoKPiArCSAqIER1cGxpY2F0ZSB0aGUgY3VycmVudCBi cmlkZ2Ugc3RhdGUgb2JqZWN0ICh3aGljaCBpcyBndWFyYW50ZWVkIHRvIGJlCj4gKwkgKiBub24t TlVMTCkuCj4gKwkgKgo+ICsJICogVGhlIGF0b21pY19kdXBsaWNhdGVfc3RhdGUoKSBpcyBvcHRp b25hbC4gV2hlbiBub3QgaW1wbGVtZW50ZWQgdGhlCj4gKwkgKiBjb3JlIGFsbG9jYXRlcyBhIGRy bV9icmlkZ2Vfc3RhdGUgb2JqZWN0IGFuZCBjYWxscwo+ICsJICogJl9fZHJtX2F0b21pY19oZWxw ZXJfYnJpZGdlX2R1cGxpY2F0ZV9zdGF0ZSgpIHRvIGluaXRpYWxpemUgaXQuCj4gKwkgKgo+ICsJ ICogUkVUVVJOUzoKPiArCSAqIEEgdmFsaWQgZHJtX2JyaWRnZV9zdGF0ZSBvYmplY3Qgb3IgTlVM TCBpZiB0aGUgYWxsb2NhdGlvbiBmYWlscy4KPiArCSAqLwo+ICsJc3RydWN0IGRybV9icmlkZ2Vf c3RhdGUgKigqYXRvbWljX2R1cGxpY2F0ZV9zdGF0ZSkoc3RydWN0IGRybV9icmlkZ2UgKmJyaWRn ZSk7Cj4gKwo+ICsJLyoqCj4gKwkgKiBAYXRvbWljX2Rlc3Ryb3lfc3RhdGU6Cj4gKwkgKgo+ICsJ ICogRGVzdHJveSBhIGJyaWRnZSBzdGF0ZSBvYmplY3QgcHJldmlvdXNseSBhbGxvY2F0ZWQgYnkK PiArCSAqICZkcm1fYnJpZGdlX2Z1bmNzLmF0b21pY19kdXBsaWNhdGVfc3RhdGUoKS4KPiArCSAq Cj4gKwkgKiBUaGUgYXRvbWljX2Rlc3Ryb3lfc3RhdGUgaG9vayBpcyBvcHRpb25hbC4gV2hlbiBu b3QgaW1wbGVtZW50ZWQgdGhlCj4gKwkgKiBjb3JlIGNhbGxzIGtmcmVlKCkgb24gdGhlIHN0YXRl Lgo+ICsJICovCj4gKwl2b2lkICgqYXRvbWljX2Rlc3Ryb3lfc3RhdGUpKHN0cnVjdCBkcm1fYnJp ZGdlICpicmlkZ2UsCj4gKwkJCQkgICAgIHN0cnVjdCBkcm1fYnJpZGdlX3N0YXRlICpzdGF0ZSk7 Cj4gKwo+ICsJLyoqCj4gKwkgKiBAYXRvbWljX3Jlc2V0Ogo+ICsJICoKPiArCSAqIFJlc2V0IHRo ZSBicmlkZ2UgdG8gYSBwcmVkZWZpbmVkIHN0YXRlIChvciByZXRyaWV2ZSBpdHMgY3VycmVudAo+ ICsJICogc3RhdGUpIGFuZCByZXR1cm4gYSAmZHJtX2JyaWRnZV9zdGF0ZSBvYmplY3QgbWF0Y2hp bmcgdGhpcyBzdGF0ZS4KPiArCSAqIFRoaXMgZnVuY3Rpb24gaXMgY2FsbGVkIGF0IGF0dGFjaCB0 aW1lLgo+ICsJICoKPiArCSAqIFRoZSBhdG9taWNfcmVzZXQgaG9vayBpcyBvcHRpb25hbC4gV2hl biBub3QgaW1wbGVtZW50ZWQgdGhlIGNvcmUKPiArCSAqIGFsbG9jYXRlcyBhIG5ldyBzdGF0ZSBh bmQgY2FsbHMgJl9fZHJtX2F0b21pY19oZWxwZXJfYnJpZGdlX3Jlc2V0KCkuCj4gKwkgKgo+ICsJ ICogUkVUVVJOUzoKPiArCSAqIEEgdmFsaWQgZHJtX2JyaWRnZV9zdGF0ZSBvYmplY3QgaW4gY2Fz ZSBvZiBzdWNjZXNzLCBhbiBFUlJfUFRSKCkKPiArCSAqIGdpdmluZyB0aGUgcmVhc29uIG9mIHRo ZSBmYWlsdXJlIG90aGVyd2lzZS4KPiArCSAqLwo+ICsJc3RydWN0IGRybV9icmlkZ2Vfc3RhdGUg KigqYXRvbWljX3Jlc2V0KShzdHJ1Y3QgZHJtX2JyaWRnZSAqYnJpZGdlKTsKPiAgfTsKPiAgCj4g IC8qKgo+IEBAIC0zODAsNiArNDQyLDggQEAgc3RydWN0IGRybV9icmlkZ2VfdGltaW5ncyB7Cj4g ICAqIHN0cnVjdCBkcm1fYnJpZGdlIC0gY2VudHJhbCBEUk0gYnJpZGdlIGNvbnRyb2wgc3RydWN0 dXJlCj4gICAqLwo+ICBzdHJ1Y3QgZHJtX2JyaWRnZSB7Cj4gKwkvKiogQGJhc2U6IGluaGVyaXQg ZnJvbSAmZHJtX3ByaXZhdGVfb2JqZWN0ICovCj4gKwlzdHJ1Y3QgZHJtX3ByaXZhdGVfb2JqIGJh c2U7Cj4gIAkvKiogQGRldjogRFJNIGRldmljZSB0aGlzIGJyaWRnZSBiZWxvbmdzIHRvICovCj4g IAlzdHJ1Y3QgZHJtX2RldmljZSAqZGV2Owo+ICAJLyoqIEBlbmNvZGVyOiBlbmNvZGVyIHRvIHdo aWNoIHRoaXMgYnJpZGdlIGlzIGNvbm5lY3RlZCAqLwo+IEBAIC00MDQsNiArNDY4LDEyIEBAIHN0 cnVjdCBkcm1fYnJpZGdlIHsKPiAgCXZvaWQgKmRyaXZlcl9wcml2YXRlOwo+ICB9Owo+ICAKPiAr c3RhdGljIGlubGluZSBzdHJ1Y3QgZHJtX2JyaWRnZSAqCj4gK2RybV9wcml2X3RvX2JyaWRnZShz dHJ1Y3QgZHJtX3ByaXZhdGVfb2JqICpwcml2KQo+ICt7Cj4gKwlyZXR1cm4gY29udGFpbmVyX29m KHByaXYsIHN0cnVjdCBkcm1fYnJpZGdlLCBiYXNlKTsKPiArfQo+ICsKPiAgdm9pZCBkcm1fYnJp ZGdlX2FkZChzdHJ1Y3QgZHJtX2JyaWRnZSAqYnJpZGdlKTsKPiAgdm9pZCBkcm1fYnJpZGdlX3Jl bW92ZShzdHJ1Y3QgZHJtX2JyaWRnZSAqYnJpZGdlKTsKPiAgc3RydWN0IGRybV9icmlkZ2UgKm9m X2RybV9maW5kX2JyaWRnZShzdHJ1Y3QgZGV2aWNlX25vZGUgKm5wKTsKPiBAQCAtNDkxLDYgKzU2 MSw1MiBAQCB2b2lkIGRybV9hdG9taWNfYnJpZGdlX2NoYWluX3ByZV9lbmFibGUoc3RydWN0IGRy bV9icmlkZ2UgKmJyaWRnZSwKPiAgdm9pZCBkcm1fYXRvbWljX2JyaWRnZV9jaGFpbl9lbmFibGUo c3RydWN0IGRybV9icmlkZ2UgKmJyaWRnZSwKPiAgCQkJCSAgICBzdHJ1Y3QgZHJtX2F0b21pY19z dGF0ZSAqc3RhdGUpOwo+ICAKPiArdm9pZCBfX2RybV9hdG9taWNfaGVscGVyX2JyaWRnZV9yZXNl dChzdHJ1Y3QgZHJtX2JyaWRnZSAqYnJpZGdlLAo+ICsJCQkJICAgICAgc3RydWN0IGRybV9icmlk Z2Vfc3RhdGUgKnN0YXRlKTsKPiArc3RydWN0IGRybV9icmlkZ2Vfc3RhdGUgKgo+ICtkcm1fYXRv bWljX2hlbHBlcl9icmlkZ2VfcmVzZXQoc3RydWN0IGRybV9icmlkZ2UgKmJyaWRnZSk7Cj4gK3Zv aWQgX19kcm1fYXRvbWljX2hlbHBlcl9icmlkZ2VfZHVwbGljYXRlX3N0YXRlKHN0cnVjdCBkcm1f YnJpZGdlICpicmlkZ2UsCj4gKwkJCQkJCXN0cnVjdCBkcm1fYnJpZGdlX3N0YXRlICpuZXcpOwo+ ICsKPiArc3RhdGljIGlubGluZSBzdHJ1Y3QgZHJtX2JyaWRnZV9zdGF0ZSAqCj4gK2RybV9hdG9t aWNfZ2V0X2JyaWRnZV9zdGF0ZShzdHJ1Y3QgZHJtX2F0b21pY19zdGF0ZSAqc3RhdGUsCj4gKwkJ CSAgICBzdHJ1Y3QgZHJtX2JyaWRnZSAqYnJpZGdlKQo+ICt7Cj4gKwlzdHJ1Y3QgZHJtX3ByaXZh dGVfc3RhdGUgKm9ial9zdGF0ZTsKPiArCj4gKwlvYmpfc3RhdGUgPSBkcm1fYXRvbWljX2dldF9w cml2YXRlX29ial9zdGF0ZShzdGF0ZSwgJmJyaWRnZS0+YmFzZSk7Cj4gKwlpZiAoSVNfRVJSKG9i al9zdGF0ZSkpCj4gKwkJcmV0dXJuIEVSUl9DQVNUKG9ial9zdGF0ZSk7Cj4gKwo+ICsJcmV0dXJu IGRybV9wcml2X3RvX2JyaWRnZV9zdGF0ZShvYmpfc3RhdGUpOwo+ICt9Cj4gKwo+ICtzdGF0aWMg aW5saW5lIHN0cnVjdCBkcm1fYnJpZGdlX3N0YXRlICoKPiArZHJtX2F0b21pY19nZXRfb2xkX2Jy aWRnZV9zdGF0ZShzdHJ1Y3QgZHJtX2F0b21pY19zdGF0ZSAqc3RhdGUsCj4gKwkJCQlzdHJ1Y3Qg ZHJtX2JyaWRnZSAqYnJpZGdlKQo+ICt7Cj4gKwlzdHJ1Y3QgZHJtX3ByaXZhdGVfc3RhdGUgKm9i al9zdGF0ZTsKPiArCj4gKwlvYmpfc3RhdGUgPSBkcm1fYXRvbWljX2dldF9vbGRfcHJpdmF0ZV9v Ympfc3RhdGUoc3RhdGUsICZicmlkZ2UtPmJhc2UpOwo+ICsJaWYgKCFvYmpfc3RhdGUpCj4gKwkJ cmV0dXJuIE5VTEw7Cj4gKwo+ICsJcmV0dXJuIGRybV9wcml2X3RvX2JyaWRnZV9zdGF0ZShvYmpf c3RhdGUpOwo+ICt9Cj4gKwo+ICtzdGF0aWMgaW5saW5lIHN0cnVjdCBkcm1fYnJpZGdlX3N0YXRl ICoKPiArZHJtX2F0b21pY19nZXRfbmV3X2JyaWRnZV9zdGF0ZShzdHJ1Y3QgZHJtX2F0b21pY19z dGF0ZSAqc3RhdGUsCj4gKwkJCQlzdHJ1Y3QgZHJtX2JyaWRnZSAqYnJpZGdlKQo+ICt7Cj4gKwlz dHJ1Y3QgZHJtX3ByaXZhdGVfc3RhdGUgKm9ial9zdGF0ZTsKPiArCj4gKwlvYmpfc3RhdGUgPSBk cm1fYXRvbWljX2dldF9uZXdfcHJpdmF0ZV9vYmpfc3RhdGUoc3RhdGUsICZicmlkZ2UtPmJhc2Up Owo+ICsJaWYgKCFvYmpfc3RhdGUpCj4gKwkJcmV0dXJuIE5VTEw7Cj4gKwo+ICsJcmV0dXJuIGRy bV9wcml2X3RvX2JyaWRnZV9zdGF0ZShvYmpfc3RhdGUpOwo+ICt9Cj4gKwo+ICAjaWZkZWYgQ09O RklHX0RSTV9QQU5FTF9CUklER0UKPiAgc3RydWN0IGRybV9icmlkZ2UgKmRybV9wYW5lbF9icmlk Z2VfYWRkKHN0cnVjdCBkcm1fcGFuZWwgKnBhbmVsKTsKPiAgc3RydWN0IGRybV9icmlkZ2UgKmRy bV9wYW5lbF9icmlkZ2VfYWRkX3R5cGVkKHN0cnVjdCBkcm1fcGFuZWwgKnBhbmVsLAo+IC0tIAo+ IDIuMjMuMAo+IAoKLS0gClJlZ2FyZHMsCgpMYXVyZW50IFBpbmNoYXJ0Cl9fX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fCmRyaS1kZXZlbCBtYWlsaW5nIGxpc3QK ZHJpLWRldmVsQGxpc3RzLmZyZWVkZXNrdG9wLm9yZwpodHRwczovL2xpc3RzLmZyZWVkZXNrdG9w Lm9yZy9tYWlsbWFuL2xpc3RpbmZvL2RyaS1kZXZlbA==