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=-6.8 required=3.0 tests=HEADER_FROM_DIFFERENT_DOMAINS, INCLUDES_PATCH,MAILING_LIST_MULTI,SIGNED_OFF_BY,SPF_HELO_NONE,SPF_PASS 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 459D2C43603 for ; Thu, 19 Dec 2019 21:56:44 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [209.132.180.67]) by mail.kernel.org (Postfix) with ESMTP id 10E90222C2 for ; Thu, 19 Dec 2019 21:56:44 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1726880AbfLSV4n convert rfc822-to-8bit (ORCPT ); Thu, 19 Dec 2019 16:56:43 -0500 Received: from mailoutvs37.siol.net ([185.57.226.228]:59338 "EHLO mail.siol.net" rhost-flags-OK-OK-OK-FAIL) by vger.kernel.org with ESMTP id S1726866AbfLSV4n (ORCPT ); Thu, 19 Dec 2019 16:56:43 -0500 Received: from localhost (localhost [127.0.0.1]) by mail.siol.net (Postfix) with ESMTP id B547B522B4B; Thu, 19 Dec 2019 22:56:36 +0100 (CET) X-Virus-Scanned: amavisd-new at psrvmta09.zcs-production.pri Received: from mail.siol.net ([127.0.0.1]) by localhost (psrvmta09.zcs-production.pri [127.0.0.1]) (amavisd-new, port 10032) with ESMTP id FBVzyIgr4hHV; Thu, 19 Dec 2019 22:56:35 +0100 (CET) Received: from mail.siol.net (localhost [127.0.0.1]) by mail.siol.net (Postfix) with ESMTPS id 72419522D6A; Thu, 19 Dec 2019 22:56:35 +0100 (CET) Received: from jernej-laptop.localnet (cpe-86-58-102-7.static.triera.net [86.58.102.7]) (Authenticated sender: jernej.skrabec@siol.net) by mail.siol.net (Postfix) with ESMTPA id 098C8522B4B; Thu, 19 Dec 2019 22:56:35 +0100 (CET) From: Jernej =?utf-8?B?xaBrcmFiZWM=?= To: Neil Armstrong Cc: dri-devel@lists.freedesktop.org, Boris Brezillon , Mark Rutland , 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 , Seung-Woo Kim Subject: Re: [PATCH v5 4/4] drm/bridge: Add the necessary bits to support bus format negotiation Date: Thu, 19 Dec 2019 22:56:34 +0100 Message-ID: <4172148.KvaJEjK4kp@jernej-laptop> In-Reply-To: <20191219101151.28039-5-narmstrong@baylibre.com> References: <20191219101151.28039-1-narmstrong@baylibre.com> <20191219101151.28039-5-narmstrong@baylibre.com> MIME-Version: 1.0 Content-Transfer-Encoding: 8BIT Content-Type: text/plain; charset="UTF-8" Sender: devicetree-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: devicetree@vger.kernel.org Hi! Dne četrtek, 19. december 2019 ob 11:11:51 CET je Neil Armstrong napisal(a): > From: Boris Brezillon > > drm_bridge_state is extended to describe the input and output bus > configurations. These bus configurations are exposed through the > drm_bus_cfg struct which encodes the configuration of a physical > bus between two components in an output pipeline, usually between > two bridges, an encoder and a bridge, or a bridge and a connector. > > The bus configuration is stored in drm_bridge_state separately for > the input and output buses, as seen from the point of view of each > bridge. The bus configuration of a bridge output is usually identical > to the configuration of the next bridge's input, but may differ if > the signals are modified between the two bridges, for instance by an > inverter on the board. The input and output configurations of a > bridge may differ if the bridge modifies the signals internally, > for instance by performing format conversion, or*modifying signals > polarities. > > Bus format negotiation is automated by the core, drivers just have > to implement the ->atomic_get_{output,input}_bus_fmts() hooks if they > want to take part to this negotiation. Negotiation happens in reverse > order, starting from the last element of the chain (the one directly > connected to the display) up to the first element of the chain (the one > connected to the encoder). > During this negotiation all supported formats are tested until we find > one that works, meaning that the formats array should be in decreasing > preference order (assuming the driver has a preference order). > > Note that the bus format negotiation works even if some elements in the > chain don't implement the ->atomic_get_{output,input}_bus_fmts() hooks. > In that case, the core advertises only MEDIA_BUS_FMT_FIXED and lets > the previous bridge element decide what to do (most of the time, bridge > drivers will pick a default bus format or extract this piece of > information from somewhere else, like a FW property). > > Signed-off-by: Boris Brezillon > Signed-off-by: Neil Armstrong > --- Thanks a lot for this work! Just one small nit bellow. Otherwise: Reviewed by: Jernej Skrabec > Changes in v5: > * None > > Changes in v4: > * Enhance the doc > * Fix typos > * Rename some parameters/fields > * Reword the commit message > > Changes in v3: > * Fix the commit message (Reported by Laurent) > * Document the fact that bus formats should not be directly modified by > drivers (Suggested by Laurent) > * Document the fact that format order matters (Suggested by Laurent) > * Propagate bus flags by default > * Document the fact that drivers can tweak bus flags if needed > * Let ->atomic_get_{output,input}_bus_fmts() allocate the bus format > array (Suggested by Laurent) > * Add a drm_atomic_helper_bridge_propagate_bus_fmt() > * Mandate that bridge drivers return accurate input_fmts even if they > are known to be the first element in the bridge chain > > Changes in v2: > * Rework things to support more complex use cases > --- > drivers/gpu/drm/drm_bridge.c | 267 ++++++++++++++++++++++++++++++++++- > include/drm/drm_bridge.h | 124 ++++++++++++++++ > 2 files changed, 390 insertions(+), 1 deletion(-) > > diff --git a/drivers/gpu/drm/drm_bridge.c b/drivers/gpu/drm/drm_bridge.c > index 442804598f60..9cc4b0181f85 100644 > --- a/drivers/gpu/drm/drm_bridge.c > +++ b/drivers/gpu/drm/drm_bridge.c > @@ -635,13 +635,261 @@ static int drm_atomic_bridge_check(struct drm_bridge > *bridge, return 0; > } > > +/** > + * drm_atomic_helper_bridge_propagate_bus_fmt() - Propagate output format > to + * the input end of a bridge > + * @bridge: bridge control structure > + * @bridge_state: new bridge state > + * @crtc_state: new CRTC state > + * @conn_state: new connector state > + * @output_fmt: tested output bus format > + * @num_input_fmts: will contain the size of the returned array > + * > + * This helper is a pluggable implementation of the > + * &drm_bridge_funcs.atomic_get_input_bus_fmts operation for bridges that > don't + * modify the bus configuration between their input and their > output. It + * returns an array of input formats with a single element set > to @output_fmt. + * > + * RETURNS: > + * a valid format array of size @num_input_fmts, or NULL if the allocation > + * failed > + */ > +u32 * > +drm_atomic_helper_bridge_propagate_bus_fmt(struct drm_bridge *bridge, > + struct drm_bridge_state *bridge_state, > + struct drm_crtc_state *crtc_state, > + struct drm_connector_state *conn_state, > + u32 output_fmt, > + unsigned int *num_input_fmts) > +{ > + u32 *input_fmts; > + > + input_fmts = kzalloc(sizeof(*input_fmts), GFP_KERNEL); > + if (!input_fmts) { > + *num_input_fmts = 0; > + return NULL; > + } > + > + *num_input_fmts = 1; > + input_fmts[0] = output_fmt; > + return input_fmts; > +} > +EXPORT_SYMBOL(drm_atomic_helper_bridge_propagate_bus_fmt); > + > +static int select_bus_fmt_recursive(struct drm_bridge *first_bridge, > + struct drm_bridge *cur_bridge, > + struct drm_crtc_state *crtc_state, > + struct drm_connector_state *conn_state, > + u32 out_bus_fmt) > +{ > + struct drm_bridge_state *cur_state; > + unsigned int num_in_bus_fmts, i; > + struct drm_bridge *prev_bridge; > + u32 *in_bus_fmts; > + int ret; > + > + prev_bridge = drm_bridge_get_prev_bridge(cur_bridge); > + cur_state = drm_atomic_get_new_bridge_state(crtc_state->state, > + cur_bridge); > + if (WARN_ON(!cur_state)) > + return -EINVAL; > + > + /* > + * If bus format negotiation is not supported by this bridge, let's > + * pass MEDIA_BUS_FMT_FIXED to the previous bridge in the chain and > + * hope that it can handle this situation gracefully (by providing > + * appropriate default values). > + */ > + if (!cur_bridge->funcs->atomic_get_input_bus_fmts) { > + if (cur_bridge != first_bridge) { > + ret = select_bus_fmt_recursive(first_bridge, > + prev_bridge, crtc_state, > + conn_state, > + MEDIA_BUS_FMT_FIXED); > + if (ret) > + return ret; > + } > + > + cur_state->input_bus_cfg.format = MEDIA_BUS_FMT_FIXED; > + cur_state->output_bus_cfg.format = out_bus_fmt; > + return 0; > + } > + > + in_bus_fmts = cur_bridge->funcs- >atomic_get_input_bus_fmts(cur_bridge, > + cur_state, > + crtc_state, > + conn_state, > + out_bus_fmt, > + &num_in_bus_fmts); > + if (!num_in_bus_fmts) > + return -ENOTSUPP; > + else if (!in_bus_fmts) > + return -ENOMEM; > + > + if (first_bridge == cur_bridge) { > + cur_state->input_bus_cfg.format = in_bus_fmts[0]; > + cur_state->output_bus_cfg.format = out_bus_fmt; > + kfree(in_bus_fmts); > + return 0; > + } > + > + for (i = 0; i < num_in_bus_fmts; i++) { > + ret = select_bus_fmt_recursive(first_bridge, prev_bridge, > + crtc_state, conn_state, > + in_bus_fmts[i]); > + if (ret != -ENOTSUPP) > + break; > + } > + > + if (!ret) { > + cur_state->input_bus_cfg.format = in_bus_fmts[i]; > + cur_state->output_bus_cfg.format = out_bus_fmt; > + } > + > + kfree(in_bus_fmts); > + return ret; > +} > + > +/* > + * This function is called by &drm_atomic_bridge_chain_check() just before > + * calling &drm_bridge_funcs.atomic_check() on all elements of the chain. > + * It performs bus format negotiation between bridge elements. The > negotiation + * happens in reverse order, starting from the last element in > the chain up to + * @bridge. > + * > + * Negotiation starts by retrieving supported output bus formats on the > last + * bridge element and testing them one by one. The test is recursive, > meaning + * that for each tested output format, the whole chain will be > walked backward, + * and each element will have to choose an input bus > format that can be + * transcoded to the requested output format. When a > bridge element does not + * support transcoding into a specific output > format -ENOTSUPP is returned and + * the next bridge element will have to > try a different format. If none of the + * combinations worked, -ENOTSUPP > is returned and the atomic modeset will fail. + * > + * This implementation is relying on > + * &drm_bridge_funcs.atomic_get_output_bus_fmts() and > + * &drm_bridge_funcs.atomic_get_input_bus_fmts() to gather supported > + * input/output formats. > + * > + * When &drm_bridge_funcs.atomic_get_output_bus_fmts() is not implemented > by + * the last element of the chain, > &drm_atomic_bridge_chain_select_bus_fmts() + * tries a single format: > &drm_connector.display_info.bus_formats[0] if + * available, > MEDIA_BUS_FMT_FIXED otherwise. > + * > + * When &drm_bridge_funcs.atomic_get_input_bus_fmts() is not implemented, > + * &drm_atomic_bridge_chain_select_bus_fmts() skips the negotiation on the > + * bridge element that lacks this hook and asks the previous element in the > + * chain to try MEDIA_BUS_FMT_FIXED. It's up to bridge drivers to decide > what + * to do in that case (fail if they want to enforce bus format > negotiation, or + * provide a reasonable default if they need to support > pipelines where not + * all elements support bus format negotiation). > + */ > +static int > +drm_atomic_bridge_chain_select_bus_fmts(struct drm_bridge *bridge, > + struct drm_crtc_state *crtc_state, > + struct drm_connector_state *conn_state) > +{ > + struct drm_connector *conn = conn_state->connector; > + struct drm_encoder *encoder = bridge->encoder; > + struct drm_bridge_state *last_bridge_state; > + unsigned int i, num_out_bus_fmts; > + struct drm_bridge *last_bridge; > + u32 *out_bus_fmts; > + int ret = 0; > + > + last_bridge = list_last_entry(&encoder->bridge_chain, > + struct drm_bridge, chain_node); > + last_bridge_state = drm_atomic_get_new_bridge_state(crtc_state- >state, > + last_bridge); > + if (WARN_ON(!last_bridge_state)) > + return -EINVAL; > + > + if (last_bridge->funcs->atomic_get_output_bus_fmts) { > + const struct drm_bridge_funcs *funcs = last_bridge- >funcs; > + > + out_bus_fmts = funcs- >atomic_get_output_bus_fmts(last_bridge, > + last_bridge_state, > + crtc_state, > + conn_state, > + &num_out_bus_fmts); > + if (!num_out_bus_fmts) > + return -ENOTSUPP; > + else if (!out_bus_fmts) > + return -ENOMEM; > + } else { > + num_out_bus_fmts = 1; > + out_bus_fmts = kmalloc(sizeof(*out_bus_fmts), GFP_KERNEL); > + if (!out_bus_fmts) > + return -ENOMEM; > + > + if (conn->display_info.num_bus_formats && > + conn->display_info.bus_formats) > + out_bus_fmts[0] = conn- >display_info.bus_formats[0]; > + else > + out_bus_fmts[0] = MEDIA_BUS_FMT_FIXED; > + } > + > + for (i = 0; i < num_out_bus_fmts; i++) { > + ret = select_bus_fmt_recursive(bridge, last_bridge, crtc_state, > + conn_state, out_bus_fmts[i]); > + if (ret != -ENOTSUPP) > + break; > + } > + > + kfree(out_bus_fmts); > + > + return ret; > +} > + > +static void > +drm_atomic_bridge_propagate_bus_flags(struct drm_bridge *bridge, > + struct drm_connector *conn, > + struct drm_atomic_state *state) > +{ > + struct drm_bridge_state *bridge_state, *next_bridge_state; > + struct drm_bridge *next_bridge; > + u32 output_flags; > + > + bridge_state = drm_atomic_get_new_bridge_state(state, bridge); > + next_bridge = drm_bridge_get_next_bridge(bridge); > + > + /* > + * Let's try to apply the most common case here, that is, propagate > + * display_info flags for the last bridge, and propagate the input > + * flags of the next bridge element to the output end of the current > + * bridge when the bridge is not the last one. > + * There are exceptions to this rule, like when signal inversion is > + * happening at the board level, but that's something drivers can deal > + * with from their &drm_bridge_funcs.atomic_check() implementation by > + * simply overriding the flags value we've set here. > + */ > + if (!next_bridge) { > + output_flags = conn->display_info.bus_flags; > + } else { > + next_bridge_state = drm_atomic_get_new_bridge_state(state, > + next_bridge); > + output_flags = next_bridge_state->input_bus_cfg.flags; > + } > + > + bridge_state->output_bus_cfg.flags = output_flags; > + > + /* > + * Propage the output flags to the input end of the bridge. Again, it's > + * not necessarily what all bridges want, but that's what most of them > + * do, and by doing that by default we avoid forcing drivers to > + * duplicate the "dummy propagation" logic. > + */ > + bridge_state->input_bus_cfg.flags = output_flags; > +} > + > /** > * drm_atomic_bridge_chain_check() - Do an atomic check on the bridge chain > * @bridge: bridge control structure > * @crtc_state: new CRTC state > * @conn_state: new connector state > * > - * Calls &drm_bridge_funcs.atomic_check() (falls back on > + * First trigger a bus format negotiation before calling > + * &drm_bridge_funcs.atomic_check() (falls back on > * &drm_bridge_funcs.mode_fixup()) op for all the bridges in the encoder > chain, * starting from the last bridge to the first. These are called > before calling * &drm_encoder_helper_funcs.atomic_check() > @@ -653,12 +901,29 @@ int drm_atomic_bridge_chain_check(struct drm_bridge > *bridge, struct drm_crtc_state *crtc_state, > struct drm_connector_state *conn_state) > { > + struct drm_connector *conn = conn_state->connector; > struct drm_encoder *encoder = bridge->encoder; > struct drm_bridge *iter; > + int ret; > + > + ret = drm_atomic_bridge_chain_select_bus_fmts(bridge, crtc_state, > + conn_state); > + if (ret) > + return ret; > > list_for_each_entry_reverse(iter, &encoder->bridge_chain, chain_node) { > int ret; > > + /* > + * Bus flags are propagated by default. If a bridge needs to > + * tweak the input bus flags for any reason, it should happen > + * in its &drm_bridge_funcs.atomic_check() implementation such > + * that preceding bridges in the chain can propagate the new > + * bus flags. > + */ > + drm_atomic_bridge_propagate_bus_flags(iter, conn, > + crtc_state->state); > + > ret = drm_atomic_bridge_check(iter, crtc_state, conn_state); > if (ret) > return ret; > diff --git a/include/drm/drm_bridge.h b/include/drm/drm_bridge.h > index 269f0d1da339..192227f03d4b 100644 > --- a/include/drm/drm_bridge.h > +++ b/include/drm/drm_bridge.h > @@ -35,6 +35,38 @@ struct drm_bridge; > struct drm_bridge_timings; > struct drm_panel; > > +/** > + * struct drm_bus_cfg - bus configuration > + * > + * This structure stores the configuration of a physical bus between two > + * components in an output pipeline, usually between two bridges, an > encoder + * and a bridge, or a bridge and a connector. > + * > + * The bus configuration is stored in &drm_bridge_state separately for the > + * input and output buses, as seen from the point of view of each bridge. > The + * bus configuration of a bridge output is usually identical to the + > * configuration of the next bridge's input, but may differ if the signals > are + * modified between the two bridges, for instance by an inverter on > the board. + * The input and output configurations of a bridge may differ > if the bridge + * modifies the signals internally, for instance by > performing format + * conversion, or modifying signals polarities. > + */ > +struct drm_bus_cfg { > + /** > + * @fmt: format used on this bus (one of the MEDIA_BUS_FMT_* format) > + * > + * This field should not be directly modified by drivers > + * (&drm_atomic_bridge_chain_select_bus_fmts() takes care of the bus > + * format negotiation). > + */ > + u32 format; > + > + /** > + * @flags: DRM_BUS_* flags used on this bus > + */ > + u32 flags; > +}; > + > /** > * struct drm_bridge_state - Atomic bridge state object > * @base: inherit from &drm_private_state > @@ -44,6 +76,16 @@ struct drm_bridge_state { > struct drm_private_state base; > > struct drm_bridge *bridge; > + > + /** > + * @input_bus_cfg: input bus configuration > + */ > + struct drm_bus_cfg input_bus_cfg; > + > + /** > + * @output_bus_cfg: input bus configuration > + */ > + struct drm_bus_cfg output_bus_cfg; > }; > > static inline struct drm_bridge_state * > @@ -387,6 +429,72 @@ struct drm_bridge_funcs { > void (*atomic_destroy_state)(struct drm_bridge *bridge, > struct drm_bridge_state *state); > > + /** > + * @atomic_get_output_bus_fmts: > + * > + * Return the supported bus formats on the output end of a bridge. > + * The returned array must be allocated with kmalloc() and will be > + * freed by the caller. If the allocation fails, NULL should be > + * returned. num_output_fmts must be set to the returned array size. > + * Formats listed in the returned array should be listed in decreasing > + * preference order (the core will try all formats until it finds one > + * that works). > + * > + * This method is only called on the last element of the bridge chain > + * as part of the bus format negotiation process that happens in > + * &drm_atomic_bridge_chain_select_bus_fmts(). > + * This method is optional. When not implemented, the core will > + * fall back to &drm_connector.display_info.bus_formats[0] if > + * &drm_connector.display_info.num_bus_formats > 0, > + * or to MEDIA_BUS_FMT_FIXED otherwise. > + */ > + u32 *(*atomic_get_output_bus_fmts)(struct drm_bridge *bridge, > + struct drm_bridge_state *bridge_state, > + struct drm_crtc_state *crtc_state, > + struct drm_connector_state *conn_state, > + unsigned int *num_output_fmts); > + > + /** > + * @atomic_get_input_bus_fmts: > + * > + * Return the supported bus formats on the input end of a bridge for > + * a specific output bus format. > + * > + * The returned array must be allocated with kmalloc() and will be > + * freed by the caller. If the allocation fails, NULL should be > + * returned. num_output_fmts must be set to the returned array size. > + * Formats listed in the returned array should be listed in decreasing > + * preference order (the core will try all formats until it finds one > + * that works). When the format is not supported NULL should be > + * returned and *num_output_fmts should be set to 0. > + * > + * This method is called on all elements of the bridge chain as part of > + * the bus format negotiation process that happens in > + * &drm_atomic_bridge_chain_select_bus_fmts(). > + * This method is optional. When not implemented, the core will bypass > + * bus format negotiation on this element of the bridge without > + * failing, and the previous element in the chain will be passed > + * MEDIA_BUS_FMT_FIXED as its output bus format. > + * > + * Bridge drivers that need to support being linked to bridges that are > + * not supporting bus format negotiation should handle the > + * output_fmt == MEDIA_BUS_FMT_FIXED case appropriately, by selecting a > + * sensible default value or extracting this information from somewhere > + * else (FW property, &drm_display_mode, &drm_display_info, ...) > + * > + * Note: Even if input format selection on the first bridge has no > + * impact on the negotiation process (bus format negotiation stops once > + * we reach the first element of the chain), drivers are expected to > + * return accurate input formats as the input format may be used to > + * configure the CRTC output appropriately. > + */ > + u32 *(*atomic_get_input_bus_fmts)(struct drm_bridge *bridge, > + struct drm_bridge_state *bridge_state, > + struct drm_crtc_state *crtc_state, > + struct drm_connector_state *conn_state, > + u32 output_fmt, > + unsigned int *num_input_fmts); > + > /** > * @atomic_check: > * > @@ -401,6 +509,14 @@ struct drm_bridge_funcs { > * called when &drm_bridge_funcs.atomic_check() is implemented, so only > * one of them should be provided. > * > + * If drivers need to tweak &drm_bridge_state.input_bus_cfg.flags or > + * &drm_bridge_state.output_bus_cfg.flags it should should happen in "should" is duplicated ^ Best regards, Jernej > + * this function. By default the &drm_bridge_state.output_bus_cfg.flags > + * field is set to the next bridge > + * &drm_bridge_state.input_bus_cfg.flags value or > + * &drm_connector.display_info.bus_flags if the bridge is the last > + * element in the chain. > + * > * RETURNS: > * zero if the check passed, a negative error code otherwise. > */ > @@ -588,6 +704,14 @@ 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); > > +u32 * > +drm_atomic_helper_bridge_propagate_bus_fmt(struct drm_bridge *bridge, > + struct drm_bridge_state *bridge_state, > + struct drm_crtc_state *crtc_state, > + struct drm_connector_state *conn_state, > + u32 output_fmt, > + unsigned int *num_input_fmts); > + > void __drm_atomic_helper_bridge_reset(struct drm_bridge *bridge, > struct drm_bridge_state *state); > void drm_atomic_helper_bridge_destroy_state(struct drm_bridge *bridge, 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=-6.8 required=3.0 tests=HEADER_FROM_DIFFERENT_DOMAINS, INCLUDES_PATCH,MAILING_LIST_MULTI,SIGNED_OFF_BY,SPF_HELO_NONE,SPF_PASS 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 49F2FC2D0D4 for ; Mon, 23 Dec 2019 08:11:42 +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 2A67520715 for ; Mon, 23 Dec 2019 08:11:42 +0000 (UTC) DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org 2A67520715 Authentication-Results: mail.kernel.org; dmarc=fail (p=none dis=none) header.from=siol.net 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 5A4E06E1F4; Mon, 23 Dec 2019 08:10:51 +0000 (UTC) Received: from mail.siol.net (mailoutvs8.siol.net [185.57.226.199]) by gabe.freedesktop.org (Postfix) with ESMTPS id D3FC36EBA0 for ; Thu, 19 Dec 2019 22:04:57 +0000 (UTC) Received: from localhost (localhost [127.0.0.1]) by mail.siol.net (Postfix) with ESMTP id B547B522B4B; Thu, 19 Dec 2019 22:56:36 +0100 (CET) X-Virus-Scanned: amavisd-new at psrvmta09.zcs-production.pri Received: from mail.siol.net ([127.0.0.1]) by localhost (psrvmta09.zcs-production.pri [127.0.0.1]) (amavisd-new, port 10032) with ESMTP id FBVzyIgr4hHV; Thu, 19 Dec 2019 22:56:35 +0100 (CET) Received: from mail.siol.net (localhost [127.0.0.1]) by mail.siol.net (Postfix) with ESMTPS id 72419522D6A; Thu, 19 Dec 2019 22:56:35 +0100 (CET) Received: from jernej-laptop.localnet (cpe-86-58-102-7.static.triera.net [86.58.102.7]) (Authenticated sender: jernej.skrabec@siol.net) by mail.siol.net (Postfix) with ESMTPA id 098C8522B4B; Thu, 19 Dec 2019 22:56:35 +0100 (CET) From: Jernej =?utf-8?B?xaBrcmFiZWM=?= To: Neil Armstrong Subject: Re: [PATCH v5 4/4] drm/bridge: Add the necessary bits to support bus format negotiation Date: Thu, 19 Dec 2019 22:56:34 +0100 Message-ID: <4172148.KvaJEjK4kp@jernej-laptop> In-Reply-To: <20191219101151.28039-5-narmstrong@baylibre.com> References: <20191219101151.28039-1-narmstrong@baylibre.com> <20191219101151.28039-5-narmstrong@baylibre.com> MIME-Version: 1.0 X-Mailman-Approved-At: Mon, 23 Dec 2019 08:10:46 +0000 X-BeenThere: dri-devel@lists.freedesktop.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: Direct Rendering Infrastructure - Development List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Cc: Mark Rutland , Nikita Yushchenko , devicetree@vger.kernel.org, Andrey Smirnov , Jonas Karlman , Seung-Woo Kim , dri-devel@lists.freedesktop.org, Rob Herring , Kyungmin Park , Boris Brezillon , Thierry Reding , Laurent Pinchart , kernel@collabora.com, Sam Ravnborg , Chris Healy Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Errors-To: dri-devel-bounces@lists.freedesktop.org Sender: "dri-devel" SGkhCgpEbmUgxI1ldHJ0ZWssIDE5LiBkZWNlbWJlciAyMDE5IG9iIDExOjExOjUxIENFVCBqZSBO ZWlsIEFybXN0cm9uZyBuYXBpc2FsKGEpOgo+IEZyb206IEJvcmlzIEJyZXppbGxvbiA8Ym9yaXMu YnJlemlsbG9uQGNvbGxhYm9yYS5jb20+Cj4gCj4gZHJtX2JyaWRnZV9zdGF0ZSBpcyBleHRlbmRl ZCB0byBkZXNjcmliZSB0aGUgaW5wdXQgYW5kIG91dHB1dCBidXMKPiBjb25maWd1cmF0aW9ucy4g VGhlc2UgYnVzIGNvbmZpZ3VyYXRpb25zIGFyZSBleHBvc2VkIHRocm91Z2ggdGhlCj4gZHJtX2J1 c19jZmcgc3RydWN0IHdoaWNoIGVuY29kZXMgdGhlIGNvbmZpZ3VyYXRpb24gb2YgYSBwaHlzaWNh bAo+IGJ1cyBiZXR3ZWVuIHR3byBjb21wb25lbnRzIGluIGFuIG91dHB1dCBwaXBlbGluZSwgdXN1 YWxseSBiZXR3ZWVuCj4gdHdvIGJyaWRnZXMsIGFuIGVuY29kZXIgYW5kIGEgYnJpZGdlLCBvciBh IGJyaWRnZSBhbmQgYSBjb25uZWN0b3IuCj4gCj4gVGhlIGJ1cyBjb25maWd1cmF0aW9uIGlzIHN0 b3JlZCBpbiBkcm1fYnJpZGdlX3N0YXRlIHNlcGFyYXRlbHkgZm9yCj4gdGhlIGlucHV0IGFuZCBv dXRwdXQgYnVzZXMsIGFzIHNlZW4gZnJvbSB0aGUgcG9pbnQgb2YgdmlldyBvZiBlYWNoCj4gYnJp ZGdlLiBUaGUgYnVzIGNvbmZpZ3VyYXRpb24gb2YgYSBicmlkZ2Ugb3V0cHV0IGlzIHVzdWFsbHkg aWRlbnRpY2FsCj4gdG8gdGhlIGNvbmZpZ3VyYXRpb24gb2YgdGhlIG5leHQgYnJpZGdlJ3MgaW5w dXQsIGJ1dCBtYXkgZGlmZmVyIGlmCj4gdGhlIHNpZ25hbHMgYXJlIG1vZGlmaWVkIGJldHdlZW4g dGhlIHR3byBicmlkZ2VzLCBmb3IgaW5zdGFuY2UgYnkgYW4KPiBpbnZlcnRlciBvbiB0aGUgYm9h cmQuIFRoZSBpbnB1dCBhbmQgb3V0cHV0IGNvbmZpZ3VyYXRpb25zIG9mIGEKPiBicmlkZ2UgbWF5 IGRpZmZlciBpZiB0aGUgYnJpZGdlIG1vZGlmaWVzIHRoZSBzaWduYWxzIGludGVybmFsbHksCj4g Zm9yIGluc3RhbmNlIGJ5IHBlcmZvcm1pbmcgZm9ybWF0IGNvbnZlcnNpb24sIG9yKm1vZGlmeWlu ZyBzaWduYWxzCj4gcG9sYXJpdGllcy4KPiAKPiBCdXMgZm9ybWF0IG5lZ290aWF0aW9uIGlzIGF1 dG9tYXRlZCBieSB0aGUgY29yZSwgZHJpdmVycyBqdXN0IGhhdmUKPiB0byBpbXBsZW1lbnQgdGhl IC0+YXRvbWljX2dldF97b3V0cHV0LGlucHV0fV9idXNfZm10cygpIGhvb2tzIGlmIHRoZXkKPiB3 YW50IHRvIHRha2UgcGFydCB0byB0aGlzIG5lZ290aWF0aW9uLiBOZWdvdGlhdGlvbiBoYXBwZW5z IGluIHJldmVyc2UKPiBvcmRlciwgc3RhcnRpbmcgZnJvbSB0aGUgbGFzdCBlbGVtZW50IG9mIHRo ZSBjaGFpbiAodGhlIG9uZSBkaXJlY3RseQo+IGNvbm5lY3RlZCB0byB0aGUgZGlzcGxheSkgdXAg dG8gdGhlIGZpcnN0IGVsZW1lbnQgb2YgdGhlIGNoYWluICh0aGUgb25lCj4gY29ubmVjdGVkIHRv IHRoZSBlbmNvZGVyKS4KPiBEdXJpbmcgdGhpcyBuZWdvdGlhdGlvbiBhbGwgc3VwcG9ydGVkIGZv cm1hdHMgYXJlIHRlc3RlZCB1bnRpbCB3ZSBmaW5kCj4gb25lIHRoYXQgd29ya3MsIG1lYW5pbmcg dGhhdCB0aGUgZm9ybWF0cyBhcnJheSBzaG91bGQgYmUgaW4gZGVjcmVhc2luZwo+IHByZWZlcmVu Y2Ugb3JkZXIgKGFzc3VtaW5nIHRoZSBkcml2ZXIgaGFzIGEgcHJlZmVyZW5jZSBvcmRlcikuCj4g Cj4gTm90ZSB0aGF0IHRoZSBidXMgZm9ybWF0IG5lZ290aWF0aW9uIHdvcmtzIGV2ZW4gaWYgc29t ZSBlbGVtZW50cyBpbiB0aGUKPiBjaGFpbiBkb24ndCBpbXBsZW1lbnQgdGhlIC0+YXRvbWljX2dl dF97b3V0cHV0LGlucHV0fV9idXNfZm10cygpIGhvb2tzLgo+IEluIHRoYXQgY2FzZSwgdGhlIGNv cmUgYWR2ZXJ0aXNlcyBvbmx5IE1FRElBX0JVU19GTVRfRklYRUQgYW5kIGxldHMKPiB0aGUgcHJl dmlvdXMgYnJpZGdlIGVsZW1lbnQgZGVjaWRlIHdoYXQgdG8gZG8gKG1vc3Qgb2YgdGhlIHRpbWUs IGJyaWRnZQo+IGRyaXZlcnMgd2lsbCBwaWNrIGEgZGVmYXVsdCBidXMgZm9ybWF0IG9yIGV4dHJh Y3QgdGhpcyBwaWVjZSBvZgo+IGluZm9ybWF0aW9uIGZyb20gc29tZXdoZXJlIGVsc2UsIGxpa2Ug YSBGVyBwcm9wZXJ0eSkuCj4gCj4gU2lnbmVkLW9mZi1ieTogQm9yaXMgQnJlemlsbG9uIDxib3Jp cy5icmV6aWxsb25AY29sbGFib3JhLmNvbT4KPiBTaWduZWQtb2ZmLWJ5OiBOZWlsIEFybXN0cm9u ZyA8bmFybXN0cm9uZ0BiYXlsaWJyZS5jb20+Cj4gLS0tCgpUaGFua3MgYSBsb3QgZm9yIHRoaXMg d29yayEgSnVzdCBvbmUgc21hbGwgbml0IGJlbGxvdy4gT3RoZXJ3aXNlOgoKUmV2aWV3ZWQgYnk6 IEplcm5laiBTa3JhYmVjIDxqZXJuZWouc2tyYWJlY0BzaW9sLm5ldD4KCj4gQ2hhbmdlcyBpbiB2 NToKPiAqIE5vbmUKPiAKPiBDaGFuZ2VzIGluIHY0Ogo+ICogRW5oYW5jZSB0aGUgZG9jCj4gKiBG aXggdHlwb3MKPiAqIFJlbmFtZSBzb21lIHBhcmFtZXRlcnMvZmllbGRzCj4gKiBSZXdvcmQgdGhl IGNvbW1pdCBtZXNzYWdlCj4gCj4gQ2hhbmdlcyBpbiB2MzoKPiAqIEZpeCB0aGUgY29tbWl0IG1l c3NhZ2UgKFJlcG9ydGVkIGJ5IExhdXJlbnQpCj4gKiBEb2N1bWVudCB0aGUgZmFjdCB0aGF0IGJ1 cyBmb3JtYXRzIHNob3VsZCBub3QgYmUgZGlyZWN0bHkgbW9kaWZpZWQgYnkKPiAgIGRyaXZlcnMg KFN1Z2dlc3RlZCBieSBMYXVyZW50KQo+ICogRG9jdW1lbnQgdGhlIGZhY3QgdGhhdCBmb3JtYXQg b3JkZXIgbWF0dGVycyAoU3VnZ2VzdGVkIGJ5IExhdXJlbnQpCj4gKiBQcm9wYWdhdGUgYnVzIGZs YWdzIGJ5IGRlZmF1bHQKPiAqIERvY3VtZW50IHRoZSBmYWN0IHRoYXQgZHJpdmVycyBjYW4gdHdl YWsgYnVzIGZsYWdzIGlmIG5lZWRlZAo+ICogTGV0IC0+YXRvbWljX2dldF97b3V0cHV0LGlucHV0 fV9idXNfZm10cygpIGFsbG9jYXRlIHRoZSBidXMgZm9ybWF0Cj4gICBhcnJheSAoU3VnZ2VzdGVk IGJ5IExhdXJlbnQpCj4gKiBBZGQgYSBkcm1fYXRvbWljX2hlbHBlcl9icmlkZ2VfcHJvcGFnYXRl X2J1c19mbXQoKQo+ICogTWFuZGF0ZSB0aGF0IGJyaWRnZSBkcml2ZXJzIHJldHVybiBhY2N1cmF0 ZSBpbnB1dF9mbXRzIGV2ZW4gaWYgdGhleQo+ICAgYXJlIGtub3duIHRvIGJlIHRoZSBmaXJzdCBl bGVtZW50IGluIHRoZSBicmlkZ2UgY2hhaW4KPiAKPiBDaGFuZ2VzIGluIHYyOgo+ICogUmV3b3Jr IHRoaW5ncyB0byBzdXBwb3J0IG1vcmUgY29tcGxleCB1c2UgY2FzZXMKPiAtLS0KPiAgZHJpdmVy cy9ncHUvZHJtL2RybV9icmlkZ2UuYyB8IDI2NyArKysrKysrKysrKysrKysrKysrKysrKysrKysr KysrKysrLQo+ICBpbmNsdWRlL2RybS9kcm1fYnJpZGdlLmggICAgIHwgMTI0ICsrKysrKysrKysr KysrKysKPiAgMiBmaWxlcyBjaGFuZ2VkLCAzOTAgaW5zZXJ0aW9ucygrKSwgMSBkZWxldGlvbigt KQo+IAo+IGRpZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9kcm0vZHJtX2JyaWRnZS5jIGIvZHJpdmVy cy9ncHUvZHJtL2RybV9icmlkZ2UuYwo+IGluZGV4IDQ0MjgwNDU5OGY2MC4uOWNjNGIwMTgxZjg1 IDEwMDY0NAo+IC0tLSBhL2RyaXZlcnMvZ3B1L2RybS9kcm1fYnJpZGdlLmMKPiArKysgYi9kcml2 ZXJzL2dwdS9kcm0vZHJtX2JyaWRnZS5jCj4gQEAgLTYzNSwxMyArNjM1LDI2MSBAQCBzdGF0aWMg aW50IGRybV9hdG9taWNfYnJpZGdlX2NoZWNrKHN0cnVjdCBkcm1fYnJpZGdlCj4gKmJyaWRnZSwg cmV0dXJuIDA7Cj4gIH0KPiAKPiArLyoqCj4gKyAqIGRybV9hdG9taWNfaGVscGVyX2JyaWRnZV9w cm9wYWdhdGVfYnVzX2ZtdCgpIC0gUHJvcGFnYXRlIG91dHB1dCBmb3JtYXQKPiB0byArICoJCQkJ CQkgIHRoZSAKaW5wdXQgZW5kIG9mIGEgYnJpZGdlCj4gKyAqIEBicmlkZ2U6IGJyaWRnZSBjb250 cm9sIHN0cnVjdHVyZQo+ICsgKiBAYnJpZGdlX3N0YXRlOiBuZXcgYnJpZGdlIHN0YXRlCj4gKyAq IEBjcnRjX3N0YXRlOiBuZXcgQ1JUQyBzdGF0ZQo+ICsgKiBAY29ubl9zdGF0ZTogbmV3IGNvbm5l Y3RvciBzdGF0ZQo+ICsgKiBAb3V0cHV0X2ZtdDogdGVzdGVkIG91dHB1dCBidXMgZm9ybWF0Cj4g KyAqIEBudW1faW5wdXRfZm10czogd2lsbCBjb250YWluIHRoZSBzaXplIG9mIHRoZSByZXR1cm5l ZCBhcnJheQo+ICsgKgo+ICsgKiBUaGlzIGhlbHBlciBpcyBhIHBsdWdnYWJsZSBpbXBsZW1lbnRh dGlvbiBvZiB0aGUKPiArICogJmRybV9icmlkZ2VfZnVuY3MuYXRvbWljX2dldF9pbnB1dF9idXNf Zm10cyBvcGVyYXRpb24gZm9yIGJyaWRnZXMgdGhhdAo+IGRvbid0ICsgKiBtb2RpZnkgdGhlIGJ1 cyBjb25maWd1cmF0aW9uIGJldHdlZW4gdGhlaXIgaW5wdXQgYW5kIHRoZWlyCj4gb3V0cHV0LiBJ dCArICogcmV0dXJucyBhbiBhcnJheSBvZiBpbnB1dCBmb3JtYXRzIHdpdGggYSBzaW5nbGUgZWxl bWVudCBzZXQKPiB0byBAb3V0cHV0X2ZtdC4gKyAqCj4gKyAqIFJFVFVSTlM6Cj4gKyAqIGEgdmFs aWQgZm9ybWF0IGFycmF5IG9mIHNpemUgQG51bV9pbnB1dF9mbXRzLCBvciBOVUxMIGlmIHRoZSBh bGxvY2F0aW9uCj4gKyAqIGZhaWxlZAo+ICsgKi8KPiArdTMyICoKPiArZHJtX2F0b21pY19oZWxw ZXJfYnJpZGdlX3Byb3BhZ2F0ZV9idXNfZm10KHN0cnVjdCBkcm1fYnJpZGdlICpicmlkZ2UsCj4g KwkJCQkJc3RydWN0IGRybV9icmlkZ2Vfc3RhdGUgCipicmlkZ2Vfc3RhdGUsCj4gKwkJCQkJc3Ry dWN0IGRybV9jcnRjX3N0YXRlIAoqY3J0Y19zdGF0ZSwKPiArCQkJCQlzdHJ1Y3QgCmRybV9jb25u ZWN0b3Jfc3RhdGUgKmNvbm5fc3RhdGUsCj4gKwkJCQkJdTMyIG91dHB1dF9mbXQsCj4gKwkJCQkJ dW5zaWduZWQgaW50IAoqbnVtX2lucHV0X2ZtdHMpCj4gK3sKPiArCXUzMiAqaW5wdXRfZm10czsK PiArCj4gKwlpbnB1dF9mbXRzID0ga3phbGxvYyhzaXplb2YoKmlucHV0X2ZtdHMpLCBHRlBfS0VS TkVMKTsKPiArCWlmICghaW5wdXRfZm10cykgewo+ICsJCSpudW1faW5wdXRfZm10cyA9IDA7Cj4g KwkJcmV0dXJuIE5VTEw7Cj4gKwl9Cj4gKwo+ICsJKm51bV9pbnB1dF9mbXRzID0gMTsKPiArCWlu cHV0X2ZtdHNbMF0gPSBvdXRwdXRfZm10Owo+ICsJcmV0dXJuIGlucHV0X2ZtdHM7Cj4gK30KPiAr RVhQT1JUX1NZTUJPTChkcm1fYXRvbWljX2hlbHBlcl9icmlkZ2VfcHJvcGFnYXRlX2J1c19mbXQp Owo+ICsKPiArc3RhdGljIGludCBzZWxlY3RfYnVzX2ZtdF9yZWN1cnNpdmUoc3RydWN0IGRybV9i cmlkZ2UgKmZpcnN0X2JyaWRnZSwKPiArCQkJCSAgICBzdHJ1Y3QgZHJtX2JyaWRnZSAqY3VyX2Jy aWRnZSwKPiArCQkJCSAgICBzdHJ1Y3QgZHJtX2NydGNfc3RhdGUgCipjcnRjX3N0YXRlLAo+ICsJ CQkJICAgIHN0cnVjdCBkcm1fY29ubmVjdG9yX3N0YXRlIAoqY29ubl9zdGF0ZSwKPiArCQkJCSAg ICB1MzIgb3V0X2J1c19mbXQpCj4gK3sKPiArCXN0cnVjdCBkcm1fYnJpZGdlX3N0YXRlICpjdXJf c3RhdGU7Cj4gKwl1bnNpZ25lZCBpbnQgbnVtX2luX2J1c19mbXRzLCBpOwo+ICsJc3RydWN0IGRy bV9icmlkZ2UgKnByZXZfYnJpZGdlOwo+ICsJdTMyICppbl9idXNfZm10czsKPiArCWludCByZXQ7 Cj4gKwo+ICsJcHJldl9icmlkZ2UgPSBkcm1fYnJpZGdlX2dldF9wcmV2X2JyaWRnZShjdXJfYnJp ZGdlKTsKPiArCWN1cl9zdGF0ZSA9IGRybV9hdG9taWNfZ2V0X25ld19icmlkZ2Vfc3RhdGUoY3J0 Y19zdGF0ZS0+c3RhdGUsCj4gKwkJCQkJCSAgICAKY3VyX2JyaWRnZSk7Cj4gKwlpZiAoV0FSTl9P TighY3VyX3N0YXRlKSkKPiArCQlyZXR1cm4gLUVJTlZBTDsKPiArCj4gKwkvKgo+ICsJICogSWYg YnVzIGZvcm1hdCBuZWdvdGlhdGlvbiBpcyBub3Qgc3VwcG9ydGVkIGJ5IHRoaXMgYnJpZGdlLCBs ZXQncwo+ICsJICogcGFzcyBNRURJQV9CVVNfRk1UX0ZJWEVEIHRvIHRoZSBwcmV2aW91cyBicmlk Z2UgaW4gdGhlIGNoYWluIGFuZAo+ICsJICogaG9wZSB0aGF0IGl0IGNhbiBoYW5kbGUgdGhpcyBz aXR1YXRpb24gZ3JhY2VmdWxseSAoYnkgcHJvdmlkaW5nCj4gKwkgKiBhcHByb3ByaWF0ZSBkZWZh dWx0IHZhbHVlcykuCj4gKwkgKi8KPiArCWlmICghY3VyX2JyaWRnZS0+ZnVuY3MtPmF0b21pY19n ZXRfaW5wdXRfYnVzX2ZtdHMpIHsKPiArCQlpZiAoY3VyX2JyaWRnZSAhPSBmaXJzdF9icmlkZ2Up IHsKPiArCQkJcmV0ID0gc2VsZWN0X2J1c19mbXRfcmVjdXJzaXZlKGZpcnN0X2JyaWRnZSwKPiAr CQkJCQkJICAgICAgIApwcmV2X2JyaWRnZSwgY3J0Y19zdGF0ZSwKPiArCQkJCQkJICAgICAgIApj b25uX3N0YXRlLAo+ICsJCQkJCQkgICAgICAgCk1FRElBX0JVU19GTVRfRklYRUQpOwo+ICsJCQlp ZiAocmV0KQo+ICsJCQkJcmV0dXJuIHJldDsKPiArCQl9Cj4gKwo+ICsJCWN1cl9zdGF0ZS0+aW5w dXRfYnVzX2NmZy5mb3JtYXQgPSBNRURJQV9CVVNfRk1UX0ZJWEVEOwo+ICsJCWN1cl9zdGF0ZS0+ b3V0cHV0X2J1c19jZmcuZm9ybWF0ID0gb3V0X2J1c19mbXQ7Cj4gKwkJcmV0dXJuIDA7Cj4gKwl9 Cj4gKwo+ICsJaW5fYnVzX2ZtdHMgPSBjdXJfYnJpZGdlLT5mdW5jcy0KPmF0b21pY19nZXRfaW5w dXRfYnVzX2ZtdHMoY3VyX2JyaWRnZSwKPiArCQkJCQkJCQpjdXJfc3RhdGUsCj4gKwkJCQkJCQkK Y3J0Y19zdGF0ZSwKPiArCQkJCQkJCQpjb25uX3N0YXRlLAo+ICsJCQkJCQkJCm91dF9idXNfZm10 LAo+ICsJCQkJCQkJCiZudW1faW5fYnVzX2ZtdHMpOwo+ICsJaWYgKCFudW1faW5fYnVzX2ZtdHMp Cj4gKwkJcmV0dXJuIC1FTk9UU1VQUDsKPiArCWVsc2UgaWYgKCFpbl9idXNfZm10cykKPiArCQly ZXR1cm4gLUVOT01FTTsKPiArCj4gKwlpZiAoZmlyc3RfYnJpZGdlID09IGN1cl9icmlkZ2UpIHsK PiArCQljdXJfc3RhdGUtPmlucHV0X2J1c19jZmcuZm9ybWF0ID0gaW5fYnVzX2ZtdHNbMF07Cj4g KwkJY3VyX3N0YXRlLT5vdXRwdXRfYnVzX2NmZy5mb3JtYXQgPSBvdXRfYnVzX2ZtdDsKPiArCQlr ZnJlZShpbl9idXNfZm10cyk7Cj4gKwkJcmV0dXJuIDA7Cj4gKwl9Cj4gKwo+ICsJZm9yIChpID0g MDsgaSA8IG51bV9pbl9idXNfZm10czsgaSsrKSB7Cj4gKwkJcmV0ID0gc2VsZWN0X2J1c19mbXRf cmVjdXJzaXZlKGZpcnN0X2JyaWRnZSwgcHJldl9icmlkZ2UsCj4gKwkJCQkJICAgICAgIGNydGNf c3RhdGUsIApjb25uX3N0YXRlLAo+ICsJCQkJCSAgICAgICBpbl9idXNfZm10c1tpXSk7Cj4gKwkJ aWYgKHJldCAhPSAtRU5PVFNVUFApCj4gKwkJCWJyZWFrOwo+ICsJfQo+ICsKPiArCWlmICghcmV0 KSB7Cj4gKwkJY3VyX3N0YXRlLT5pbnB1dF9idXNfY2ZnLmZvcm1hdCA9IGluX2J1c19mbXRzW2ld Owo+ICsJCWN1cl9zdGF0ZS0+b3V0cHV0X2J1c19jZmcuZm9ybWF0ID0gb3V0X2J1c19mbXQ7Cj4g Kwl9Cj4gKwo+ICsJa2ZyZWUoaW5fYnVzX2ZtdHMpOwo+ICsJcmV0dXJuIHJldDsKPiArfQo+ICsK PiArLyoKPiArICogVGhpcyBmdW5jdGlvbiBpcyBjYWxsZWQgYnkgJmRybV9hdG9taWNfYnJpZGdl X2NoYWluX2NoZWNrKCkganVzdCBiZWZvcmUKPiArICogY2FsbGluZyAmZHJtX2JyaWRnZV9mdW5j cy5hdG9taWNfY2hlY2soKSBvbiBhbGwgZWxlbWVudHMgb2YgdGhlIGNoYWluLgo+ICsgKiBJdCBw ZXJmb3JtcyBidXMgZm9ybWF0IG5lZ290aWF0aW9uIGJldHdlZW4gYnJpZGdlIGVsZW1lbnRzLiBU aGUKPiBuZWdvdGlhdGlvbiArICogaGFwcGVucyBpbiByZXZlcnNlIG9yZGVyLCBzdGFydGluZyBm cm9tIHRoZSBsYXN0IGVsZW1lbnQgaW4KPiB0aGUgY2hhaW4gdXAgdG8gKyAqIEBicmlkZ2UuCj4g KyAqCj4gKyAqIE5lZ290aWF0aW9uIHN0YXJ0cyBieSByZXRyaWV2aW5nIHN1cHBvcnRlZCBvdXRw dXQgYnVzIGZvcm1hdHMgb24gdGhlCj4gbGFzdCArICogYnJpZGdlIGVsZW1lbnQgYW5kIHRlc3Rp bmcgdGhlbSBvbmUgYnkgb25lLiBUaGUgdGVzdCBpcyByZWN1cnNpdmUsCj4gbWVhbmluZyArICog dGhhdCBmb3IgZWFjaCB0ZXN0ZWQgb3V0cHV0IGZvcm1hdCwgdGhlIHdob2xlIGNoYWluIHdpbGwg YmUKPiB3YWxrZWQgYmFja3dhcmQsICsgKiBhbmQgZWFjaCBlbGVtZW50IHdpbGwgaGF2ZSB0byBj aG9vc2UgYW4gaW5wdXQgYnVzCj4gZm9ybWF0IHRoYXQgY2FuIGJlICsgKiB0cmFuc2NvZGVkIHRv IHRoZSByZXF1ZXN0ZWQgb3V0cHV0IGZvcm1hdC4gV2hlbiBhCj4gYnJpZGdlIGVsZW1lbnQgZG9l cyBub3QgKyAqIHN1cHBvcnQgdHJhbnNjb2RpbmcgaW50byBhIHNwZWNpZmljIG91dHB1dAo+IGZv cm1hdCAtRU5PVFNVUFAgaXMgcmV0dXJuZWQgYW5kICsgKiB0aGUgbmV4dCBicmlkZ2UgZWxlbWVu dCB3aWxsIGhhdmUgdG8KPiB0cnkgYSBkaWZmZXJlbnQgZm9ybWF0LiBJZiBub25lIG9mIHRoZSAr ICogY29tYmluYXRpb25zIHdvcmtlZCwgLUVOT1RTVVBQCj4gaXMgcmV0dXJuZWQgYW5kIHRoZSBh dG9taWMgbW9kZXNldCB3aWxsIGZhaWwuICsgKgo+ICsgKiBUaGlzIGltcGxlbWVudGF0aW9uIGlz IHJlbHlpbmcgb24KPiArICogJmRybV9icmlkZ2VfZnVuY3MuYXRvbWljX2dldF9vdXRwdXRfYnVz X2ZtdHMoKSBhbmQKPiArICogJmRybV9icmlkZ2VfZnVuY3MuYXRvbWljX2dldF9pbnB1dF9idXNf Zm10cygpIHRvIGdhdGhlciBzdXBwb3J0ZWQKPiArICogaW5wdXQvb3V0cHV0IGZvcm1hdHMuCj4g KyAqCj4gKyAqIFdoZW4gJmRybV9icmlkZ2VfZnVuY3MuYXRvbWljX2dldF9vdXRwdXRfYnVzX2Zt dHMoKSBpcyBub3QgaW1wbGVtZW50ZWQKPiBieSArICogdGhlIGxhc3QgZWxlbWVudCBvZiB0aGUg Y2hhaW4sCj4gJmRybV9hdG9taWNfYnJpZGdlX2NoYWluX3NlbGVjdF9idXNfZm10cygpICsgKiB0 cmllcyBhIHNpbmdsZSBmb3JtYXQ6Cj4gJmRybV9jb25uZWN0b3IuZGlzcGxheV9pbmZvLmJ1c19m b3JtYXRzWzBdIGlmICsgKiBhdmFpbGFibGUsCj4gTUVESUFfQlVTX0ZNVF9GSVhFRCBvdGhlcndp c2UuCj4gKyAqCj4gKyAqIFdoZW4gJmRybV9icmlkZ2VfZnVuY3MuYXRvbWljX2dldF9pbnB1dF9i dXNfZm10cygpIGlzIG5vdCBpbXBsZW1lbnRlZCwKPiArICogJmRybV9hdG9taWNfYnJpZGdlX2No YWluX3NlbGVjdF9idXNfZm10cygpIHNraXBzIHRoZSBuZWdvdGlhdGlvbiBvbiB0aGUKPiArICog YnJpZGdlIGVsZW1lbnQgdGhhdCBsYWNrcyB0aGlzIGhvb2sgYW5kIGFza3MgdGhlIHByZXZpb3Vz IGVsZW1lbnQgaW4gdGhlCj4gKyAqIGNoYWluIHRvIHRyeSBNRURJQV9CVVNfRk1UX0ZJWEVELiBJ dCdzIHVwIHRvIGJyaWRnZSBkcml2ZXJzIHRvIGRlY2lkZQo+IHdoYXQgKyAqIHRvIGRvIGluIHRo YXQgY2FzZSAoZmFpbCBpZiB0aGV5IHdhbnQgdG8gZW5mb3JjZSBidXMgZm9ybWF0Cj4gbmVnb3Rp YXRpb24sIG9yICsgKiBwcm92aWRlIGEgcmVhc29uYWJsZSBkZWZhdWx0IGlmIHRoZXkgbmVlZCB0 byBzdXBwb3J0Cj4gcGlwZWxpbmVzIHdoZXJlIG5vdCArICogYWxsIGVsZW1lbnRzIHN1cHBvcnQg YnVzIGZvcm1hdCBuZWdvdGlhdGlvbikuCj4gKyAqLwo+ICtzdGF0aWMgaW50Cj4gK2RybV9hdG9t aWNfYnJpZGdlX2NoYWluX3NlbGVjdF9idXNfZm10cyhzdHJ1Y3QgZHJtX2JyaWRnZSAqYnJpZGdl LAo+ICsJCQkJCXN0cnVjdCBkcm1fY3J0Y19zdGF0ZSAKKmNydGNfc3RhdGUsCj4gKwkJCQkJc3Ry dWN0IApkcm1fY29ubmVjdG9yX3N0YXRlICpjb25uX3N0YXRlKQo+ICt7Cj4gKwlzdHJ1Y3QgZHJt X2Nvbm5lY3RvciAqY29ubiA9IGNvbm5fc3RhdGUtPmNvbm5lY3RvcjsKPiArCXN0cnVjdCBkcm1f ZW5jb2RlciAqZW5jb2RlciA9IGJyaWRnZS0+ZW5jb2RlcjsKPiArCXN0cnVjdCBkcm1fYnJpZGdl X3N0YXRlICpsYXN0X2JyaWRnZV9zdGF0ZTsKPiArCXVuc2lnbmVkIGludCBpLCBudW1fb3V0X2J1 c19mbXRzOwo+ICsJc3RydWN0IGRybV9icmlkZ2UgKmxhc3RfYnJpZGdlOwo+ICsJdTMyICpvdXRf YnVzX2ZtdHM7Cj4gKwlpbnQgcmV0ID0gMDsKPiArCj4gKwlsYXN0X2JyaWRnZSA9IGxpc3RfbGFz dF9lbnRyeSgmZW5jb2Rlci0+YnJpZGdlX2NoYWluLAo+ICsJCQkJICAgICAgc3RydWN0IGRybV9i cmlkZ2UsIApjaGFpbl9ub2RlKTsKPiArCWxhc3RfYnJpZGdlX3N0YXRlID0gZHJtX2F0b21pY19n ZXRfbmV3X2JyaWRnZV9zdGF0ZShjcnRjX3N0YXRlLQo+c3RhdGUsCj4gKwkJCQkJCQkgICAgCmxh c3RfYnJpZGdlKTsKPiArCWlmIChXQVJOX09OKCFsYXN0X2JyaWRnZV9zdGF0ZSkpCj4gKwkJcmV0 dXJuIC1FSU5WQUw7Cj4gKwo+ICsJaWYgKGxhc3RfYnJpZGdlLT5mdW5jcy0+YXRvbWljX2dldF9v dXRwdXRfYnVzX2ZtdHMpIHsKPiArCQljb25zdCBzdHJ1Y3QgZHJtX2JyaWRnZV9mdW5jcyAqZnVu Y3MgPSBsYXN0X2JyaWRnZS0KPmZ1bmNzOwo+ICsKPiArCQlvdXRfYnVzX2ZtdHMgPSBmdW5jcy0K PmF0b21pY19nZXRfb3V0cHV0X2J1c19mbXRzKGxhc3RfYnJpZGdlLAo+ICsJCQkJCQkJCmxhc3Rf YnJpZGdlX3N0YXRlLAo+ICsJCQkJCQkJCmNydGNfc3RhdGUsCj4gKwkJCQkJCQkKY29ubl9zdGF0 ZSwKPiArCQkJCQkJCQombnVtX291dF9idXNfZm10cyk7Cj4gKwkJaWYgKCFudW1fb3V0X2J1c19m bXRzKQo+ICsJCQlyZXR1cm4gLUVOT1RTVVBQOwo+ICsJCWVsc2UgaWYgKCFvdXRfYnVzX2ZtdHMp Cj4gKwkJCXJldHVybiAtRU5PTUVNOwo+ICsJfSBlbHNlIHsKPiArCQludW1fb3V0X2J1c19mbXRz ID0gMTsKPiArCQlvdXRfYnVzX2ZtdHMgPSBrbWFsbG9jKHNpemVvZigqb3V0X2J1c19mbXRzKSwg CkdGUF9LRVJORUwpOwo+ICsJCWlmICghb3V0X2J1c19mbXRzKQo+ICsJCQlyZXR1cm4gLUVOT01F TTsKPiArCj4gKwkJaWYgKGNvbm4tPmRpc3BsYXlfaW5mby5udW1fYnVzX2Zvcm1hdHMgJiYKPiAr CQkgICAgY29ubi0+ZGlzcGxheV9pbmZvLmJ1c19mb3JtYXRzKQo+ICsJCQlvdXRfYnVzX2ZtdHNb MF0gPSBjb25uLQo+ZGlzcGxheV9pbmZvLmJ1c19mb3JtYXRzWzBdOwo+ICsJCWVsc2UKPiArCQkJ b3V0X2J1c19mbXRzWzBdID0gTUVESUFfQlVTX0ZNVF9GSVhFRDsKPiArCX0KPiArCj4gKwlmb3Ig KGkgPSAwOyBpIDwgbnVtX291dF9idXNfZm10czsgaSsrKSB7Cj4gKwkJcmV0ID0gc2VsZWN0X2J1 c19mbXRfcmVjdXJzaXZlKGJyaWRnZSwgbGFzdF9icmlkZ2UsIApjcnRjX3N0YXRlLAo+ICsJCQkJ CSAgICAgICBjb25uX3N0YXRlLCAKb3V0X2J1c19mbXRzW2ldKTsKPiArCQlpZiAocmV0ICE9IC1F Tk9UU1VQUCkKPiArCQkJYnJlYWs7Cj4gKwl9Cj4gKwo+ICsJa2ZyZWUob3V0X2J1c19mbXRzKTsK PiArCj4gKwlyZXR1cm4gcmV0Owo+ICt9Cj4gKwo+ICtzdGF0aWMgdm9pZAo+ICtkcm1fYXRvbWlj X2JyaWRnZV9wcm9wYWdhdGVfYnVzX2ZsYWdzKHN0cnVjdCBkcm1fYnJpZGdlICpicmlkZ2UsCj4g KwkJCQkgICAgICBzdHJ1Y3QgZHJtX2Nvbm5lY3RvciAqY29ubiwKPiArCQkJCSAgICAgIHN0cnVj dCBkcm1fYXRvbWljX3N0YXRlIAoqc3RhdGUpCj4gK3sKPiArCXN0cnVjdCBkcm1fYnJpZGdlX3N0 YXRlICpicmlkZ2Vfc3RhdGUsICpuZXh0X2JyaWRnZV9zdGF0ZTsKPiArCXN0cnVjdCBkcm1fYnJp ZGdlICpuZXh0X2JyaWRnZTsKPiArCXUzMiBvdXRwdXRfZmxhZ3M7Cj4gKwo+ICsJYnJpZGdlX3N0 YXRlID0gZHJtX2F0b21pY19nZXRfbmV3X2JyaWRnZV9zdGF0ZShzdGF0ZSwgYnJpZGdlKTsKPiAr CW5leHRfYnJpZGdlID0gZHJtX2JyaWRnZV9nZXRfbmV4dF9icmlkZ2UoYnJpZGdlKTsKPiArCj4g KwkvKgo+ICsJICogTGV0J3MgdHJ5IHRvIGFwcGx5IHRoZSBtb3N0IGNvbW1vbiBjYXNlIGhlcmUs IHRoYXQgaXMsIHByb3BhZ2F0ZQo+ICsJICogZGlzcGxheV9pbmZvIGZsYWdzIGZvciB0aGUgbGFz dCBicmlkZ2UsIGFuZCBwcm9wYWdhdGUgdGhlIGlucHV0Cj4gKwkgKiBmbGFncyBvZiB0aGUgbmV4 dCBicmlkZ2UgZWxlbWVudCB0byB0aGUgb3V0cHV0IGVuZCBvZiB0aGUgY3VycmVudAo+ICsJICog YnJpZGdlIHdoZW4gdGhlIGJyaWRnZSBpcyBub3QgdGhlIGxhc3Qgb25lLgo+ICsJICogVGhlcmUg YXJlIGV4Y2VwdGlvbnMgdG8gdGhpcyBydWxlLCBsaWtlIHdoZW4gc2lnbmFsIGludmVyc2lvbiBp cwo+ICsJICogaGFwcGVuaW5nIGF0IHRoZSBib2FyZCBsZXZlbCwgYnV0IHRoYXQncyBzb21ldGhp bmcgZHJpdmVycyBjYW4gCmRlYWwKPiArCSAqIHdpdGggZnJvbSB0aGVpciAmZHJtX2JyaWRnZV9m dW5jcy5hdG9taWNfY2hlY2soKSBpbXBsZW1lbnRhdGlvbiAKYnkKPiArCSAqIHNpbXBseSBvdmVy cmlkaW5nIHRoZSBmbGFncyB2YWx1ZSB3ZSd2ZSBzZXQgaGVyZS4KPiArCSAqLwo+ICsJaWYgKCFu ZXh0X2JyaWRnZSkgewo+ICsJCW91dHB1dF9mbGFncyA9IGNvbm4tPmRpc3BsYXlfaW5mby5idXNf ZmxhZ3M7Cj4gKwl9IGVsc2Ugewo+ICsJCW5leHRfYnJpZGdlX3N0YXRlID0gCmRybV9hdG9taWNf Z2V0X25ld19icmlkZ2Vfc3RhdGUoc3RhdGUsCj4gKwkJCQkJCQkJCm5leHRfYnJpZGdlKTsKPiAr CQlvdXRwdXRfZmxhZ3MgPSBuZXh0X2JyaWRnZV9zdGF0ZS0+aW5wdXRfYnVzX2NmZy5mbGFnczsK PiArCX0KPiArCj4gKwlicmlkZ2Vfc3RhdGUtPm91dHB1dF9idXNfY2ZnLmZsYWdzID0gb3V0cHV0 X2ZsYWdzOwo+ICsKPiArCS8qCj4gKwkgKiBQcm9wYWdlIHRoZSBvdXRwdXQgZmxhZ3MgdG8gdGhl IGlucHV0IGVuZCBvZiB0aGUgYnJpZGdlLiBBZ2FpbiwgCml0J3MKPiArCSAqIG5vdCBuZWNlc3Nh cmlseSB3aGF0IGFsbCBicmlkZ2VzIHdhbnQsIGJ1dCB0aGF0J3Mgd2hhdCBtb3N0IG9mIAp0aGVt Cj4gKwkgKiBkbywgYW5kIGJ5IGRvaW5nIHRoYXQgYnkgZGVmYXVsdCB3ZSBhdm9pZCBmb3JjaW5n IGRyaXZlcnMgdG8KPiArCSAqIGR1cGxpY2F0ZSB0aGUgImR1bW15IHByb3BhZ2F0aW9uIiBsb2dp Yy4KPiArCSAqLwo+ICsJYnJpZGdlX3N0YXRlLT5pbnB1dF9idXNfY2ZnLmZsYWdzID0gb3V0cHV0 X2ZsYWdzOwo+ICt9Cj4gKwo+ICAvKioKPiAgICogZHJtX2F0b21pY19icmlkZ2VfY2hhaW5fY2hl Y2soKSAtIERvIGFuIGF0b21pYyBjaGVjayBvbiB0aGUgYnJpZGdlIGNoYWluCj4gKiBAYnJpZGdl OiBicmlkZ2UgY29udHJvbCBzdHJ1Y3R1cmUKPiAgICogQGNydGNfc3RhdGU6IG5ldyBDUlRDIHN0 YXRlCj4gICAqIEBjb25uX3N0YXRlOiBuZXcgY29ubmVjdG9yIHN0YXRlCj4gICAqCj4gLSAqIENh bGxzICZkcm1fYnJpZGdlX2Z1bmNzLmF0b21pY19jaGVjaygpIChmYWxscyBiYWNrIG9uCj4gKyAq IEZpcnN0IHRyaWdnZXIgYSBidXMgZm9ybWF0IG5lZ290aWF0aW9uIGJlZm9yZSBjYWxsaW5nCj4g KyAqICZkcm1fYnJpZGdlX2Z1bmNzLmF0b21pY19jaGVjaygpIChmYWxscyBiYWNrIG9uCj4gICAq ICZkcm1fYnJpZGdlX2Z1bmNzLm1vZGVfZml4dXAoKSkgb3AgZm9yIGFsbCB0aGUgYnJpZGdlcyBp biB0aGUgZW5jb2Rlcgo+IGNoYWluLCAqIHN0YXJ0aW5nIGZyb20gdGhlIGxhc3QgYnJpZGdlIHRv IHRoZSBmaXJzdC4gVGhlc2UgYXJlIGNhbGxlZAo+IGJlZm9yZSBjYWxsaW5nICogJmRybV9lbmNv ZGVyX2hlbHBlcl9mdW5jcy5hdG9taWNfY2hlY2soKQo+IEBAIC02NTMsMTIgKzkwMSwyOSBAQCBp bnQgZHJtX2F0b21pY19icmlkZ2VfY2hhaW5fY2hlY2soc3RydWN0IGRybV9icmlkZ2UKPiAqYnJp ZGdlLCBzdHJ1Y3QgZHJtX2NydGNfc3RhdGUgKmNydGNfc3RhdGUsCj4gIAkJCQkgIHN0cnVjdCBk cm1fY29ubmVjdG9yX3N0YXRlIAoqY29ubl9zdGF0ZSkKPiAgewo+ICsJc3RydWN0IGRybV9jb25u ZWN0b3IgKmNvbm4gPSBjb25uX3N0YXRlLT5jb25uZWN0b3I7Cj4gIAlzdHJ1Y3QgZHJtX2VuY29k ZXIgKmVuY29kZXIgPSBicmlkZ2UtPmVuY29kZXI7Cj4gIAlzdHJ1Y3QgZHJtX2JyaWRnZSAqaXRl cjsKPiArCWludCByZXQ7Cj4gKwo+ICsJcmV0ID0gZHJtX2F0b21pY19icmlkZ2VfY2hhaW5fc2Vs ZWN0X2J1c19mbXRzKGJyaWRnZSwgY3J0Y19zdGF0ZSwKPiArCQkJCQkJICAgICAgCmNvbm5fc3Rh dGUpOwo+ICsJaWYgKHJldCkKPiArCQlyZXR1cm4gcmV0Owo+IAo+ICAJbGlzdF9mb3JfZWFjaF9l bnRyeV9yZXZlcnNlKGl0ZXIsICZlbmNvZGVyLT5icmlkZ2VfY2hhaW4sIApjaGFpbl9ub2RlKSB7 Cj4gIAkJaW50IHJldDsKPiAKPiArCQkvKgo+ICsJCSAqIEJ1cyBmbGFncyBhcmUgcHJvcGFnYXRl ZCBieSBkZWZhdWx0LiBJZiBhIGJyaWRnZSBuZWVkcyAKdG8KPiArCQkgKiB0d2VhayB0aGUgaW5w dXQgYnVzIGZsYWdzIGZvciBhbnkgcmVhc29uLCBpdCBzaG91bGQgCmhhcHBlbgo+ICsJCSAqIGlu IGl0cyAmZHJtX2JyaWRnZV9mdW5jcy5hdG9taWNfY2hlY2soKSAKaW1wbGVtZW50YXRpb24gc3Vj aAo+ICsJCSAqIHRoYXQgcHJlY2VkaW5nIGJyaWRnZXMgaW4gdGhlIGNoYWluIGNhbiBwcm9wYWdh dGUgdGhlIApuZXcKPiArCQkgKiBidXMgZmxhZ3MuCj4gKwkJICovCj4gKwkJZHJtX2F0b21pY19i cmlkZ2VfcHJvcGFnYXRlX2J1c19mbGFncyhpdGVyLCBjb25uLAo+ICsJCQkJCQkgICAgICAKY3J0 Y19zdGF0ZS0+c3RhdGUpOwo+ICsKPiAgCQlyZXQgPSBkcm1fYXRvbWljX2JyaWRnZV9jaGVjayhp dGVyLCBjcnRjX3N0YXRlLCAKY29ubl9zdGF0ZSk7Cj4gIAkJaWYgKHJldCkKPiAgCQkJcmV0dXJu IHJldDsKPiBkaWZmIC0tZ2l0IGEvaW5jbHVkZS9kcm0vZHJtX2JyaWRnZS5oIGIvaW5jbHVkZS9k cm0vZHJtX2JyaWRnZS5oCj4gaW5kZXggMjY5ZjBkMWRhMzM5Li4xOTIyMjdmMDNkNGIgMTAwNjQ0 Cj4gLS0tIGEvaW5jbHVkZS9kcm0vZHJtX2JyaWRnZS5oCj4gKysrIGIvaW5jbHVkZS9kcm0vZHJt X2JyaWRnZS5oCj4gQEAgLTM1LDYgKzM1LDM4IEBAIHN0cnVjdCBkcm1fYnJpZGdlOwo+ICBzdHJ1 Y3QgZHJtX2JyaWRnZV90aW1pbmdzOwo+ICBzdHJ1Y3QgZHJtX3BhbmVsOwo+IAo+ICsvKioKPiAr ICogc3RydWN0IGRybV9idXNfY2ZnIC0gYnVzIGNvbmZpZ3VyYXRpb24KPiArICoKPiArICogVGhp cyBzdHJ1Y3R1cmUgc3RvcmVzIHRoZSBjb25maWd1cmF0aW9uIG9mIGEgcGh5c2ljYWwgYnVzIGJl dHdlZW4gdHdvCj4gKyAqIGNvbXBvbmVudHMgaW4gYW4gb3V0cHV0IHBpcGVsaW5lLCB1c3VhbGx5 IGJldHdlZW4gdHdvIGJyaWRnZXMsIGFuCj4gZW5jb2RlciArICogYW5kIGEgYnJpZGdlLCBvciBh IGJyaWRnZSBhbmQgYSBjb25uZWN0b3IuCj4gKyAqCj4gKyAqIFRoZSBidXMgY29uZmlndXJhdGlv biBpcyBzdG9yZWQgaW4gJmRybV9icmlkZ2Vfc3RhdGUgc2VwYXJhdGVseSBmb3IgdGhlCj4gKyAq IGlucHV0IGFuZCBvdXRwdXQgYnVzZXMsIGFzIHNlZW4gZnJvbSB0aGUgcG9pbnQgb2YgdmlldyBv ZiBlYWNoIGJyaWRnZS4KPiBUaGUgKyAqIGJ1cyBjb25maWd1cmF0aW9uIG9mIGEgYnJpZGdlIG91 dHB1dCBpcyB1c3VhbGx5IGlkZW50aWNhbCB0byB0aGUgKwo+ICogY29uZmlndXJhdGlvbiBvZiB0 aGUgbmV4dCBicmlkZ2UncyBpbnB1dCwgYnV0IG1heSBkaWZmZXIgaWYgdGhlIHNpZ25hbHMKPiBh cmUgKyAqIG1vZGlmaWVkIGJldHdlZW4gdGhlIHR3byBicmlkZ2VzLCBmb3IgaW5zdGFuY2UgYnkg YW4gaW52ZXJ0ZXIgb24KPiB0aGUgYm9hcmQuICsgKiBUaGUgaW5wdXQgYW5kIG91dHB1dCBjb25m aWd1cmF0aW9ucyBvZiBhIGJyaWRnZSBtYXkgZGlmZmVyCj4gaWYgdGhlIGJyaWRnZSArICogbW9k aWZpZXMgdGhlIHNpZ25hbHMgaW50ZXJuYWxseSwgZm9yIGluc3RhbmNlIGJ5Cj4gcGVyZm9ybWlu ZyBmb3JtYXQgKyAqIGNvbnZlcnNpb24sIG9yIG1vZGlmeWluZyBzaWduYWxzIHBvbGFyaXRpZXMu Cj4gKyAqLwo+ICtzdHJ1Y3QgZHJtX2J1c19jZmcgewo+ICsJLyoqCj4gKwkgKiBAZm10OiBmb3Jt YXQgdXNlZCBvbiB0aGlzIGJ1cyAob25lIG9mIHRoZSBNRURJQV9CVVNfRk1UXyogCmZvcm1hdCkK PiArCSAqCj4gKwkgKiBUaGlzIGZpZWxkIHNob3VsZCBub3QgYmUgZGlyZWN0bHkgbW9kaWZpZWQg YnkgZHJpdmVycwo+ICsJICogKCZkcm1fYXRvbWljX2JyaWRnZV9jaGFpbl9zZWxlY3RfYnVzX2Zt dHMoKSB0YWtlcyBjYXJlIG9mIHRoZSAKYnVzCj4gKwkgKiBmb3JtYXQgbmVnb3RpYXRpb24pLgo+ ICsJICovCj4gKwl1MzIgZm9ybWF0Owo+ICsKPiArCS8qKgo+ICsJICogQGZsYWdzOiBEUk1fQlVT XyogZmxhZ3MgdXNlZCBvbiB0aGlzIGJ1cwo+ICsJICovCj4gKwl1MzIgZmxhZ3M7Cj4gK307Cj4g Kwo+ICAvKioKPiAgICogc3RydWN0IGRybV9icmlkZ2Vfc3RhdGUgLSBBdG9taWMgYnJpZGdlIHN0 YXRlIG9iamVjdAo+ICAgKiBAYmFzZTogaW5oZXJpdCBmcm9tICZkcm1fcHJpdmF0ZV9zdGF0ZQo+ IEBAIC00NCw2ICs3NiwxNiBAQCBzdHJ1Y3QgZHJtX2JyaWRnZV9zdGF0ZSB7Cj4gIAlzdHJ1Y3Qg ZHJtX3ByaXZhdGVfc3RhdGUgYmFzZTsKPiAKPiAgCXN0cnVjdCBkcm1fYnJpZGdlICpicmlkZ2U7 Cj4gKwo+ICsJLyoqCj4gKwkgKiBAaW5wdXRfYnVzX2NmZzogaW5wdXQgYnVzIGNvbmZpZ3VyYXRp b24KPiArCSAqLwo+ICsJc3RydWN0IGRybV9idXNfY2ZnIGlucHV0X2J1c19jZmc7Cj4gKwo+ICsJ LyoqCj4gKwkgKiBAb3V0cHV0X2J1c19jZmc6IGlucHV0IGJ1cyBjb25maWd1cmF0aW9uCj4gKwkg Ki8KPiArCXN0cnVjdCBkcm1fYnVzX2NmZyBvdXRwdXRfYnVzX2NmZzsKPiAgfTsKPiAKPiAgc3Rh dGljIGlubGluZSBzdHJ1Y3QgZHJtX2JyaWRnZV9zdGF0ZSAqCj4gQEAgLTM4Nyw2ICs0MjksNzIg QEAgc3RydWN0IGRybV9icmlkZ2VfZnVuY3Mgewo+ICAJdm9pZCAoKmF0b21pY19kZXN0cm95X3N0 YXRlKShzdHJ1Y3QgZHJtX2JyaWRnZSAqYnJpZGdlLAo+ICAJCQkJICAgICBzdHJ1Y3QgZHJtX2Jy aWRnZV9zdGF0ZSAKKnN0YXRlKTsKPiAKPiArCS8qKgo+ICsJICogQGF0b21pY19nZXRfb3V0cHV0 X2J1c19mbXRzOgo+ICsJICoKPiArCSAqIFJldHVybiB0aGUgc3VwcG9ydGVkIGJ1cyBmb3JtYXRz IG9uIHRoZSBvdXRwdXQgZW5kIG9mIGEgYnJpZGdlLgo+ICsJICogVGhlIHJldHVybmVkIGFycmF5 IG11c3QgYmUgYWxsb2NhdGVkIHdpdGgga21hbGxvYygpIGFuZCB3aWxsIGJlCj4gKwkgKiBmcmVl ZCBieSB0aGUgY2FsbGVyLiBJZiB0aGUgYWxsb2NhdGlvbiBmYWlscywgTlVMTCBzaG91bGQgYmUK PiArCSAqIHJldHVybmVkLiBudW1fb3V0cHV0X2ZtdHMgbXVzdCBiZSBzZXQgdG8gdGhlIHJldHVy bmVkIGFycmF5IApzaXplLgo+ICsJICogRm9ybWF0cyBsaXN0ZWQgaW4gdGhlIHJldHVybmVkIGFy cmF5IHNob3VsZCBiZSBsaXN0ZWQgaW4gCmRlY3JlYXNpbmcKPiArCSAqIHByZWZlcmVuY2Ugb3Jk ZXIgKHRoZSBjb3JlIHdpbGwgdHJ5IGFsbCBmb3JtYXRzIHVudGlsIGl0IGZpbmRzIApvbmUKPiAr CSAqIHRoYXQgd29ya3MpLgo+ICsJICoKPiArCSAqIFRoaXMgbWV0aG9kIGlzIG9ubHkgY2FsbGVk IG9uIHRoZSBsYXN0IGVsZW1lbnQgb2YgdGhlIGJyaWRnZSAKY2hhaW4KPiArCSAqIGFzIHBhcnQg b2YgdGhlIGJ1cyBmb3JtYXQgbmVnb3RpYXRpb24gcHJvY2VzcyB0aGF0IGhhcHBlbnMgaW4KPiAr CSAqICZkcm1fYXRvbWljX2JyaWRnZV9jaGFpbl9zZWxlY3RfYnVzX2ZtdHMoKS4KPiArCSAqIFRo aXMgbWV0aG9kIGlzIG9wdGlvbmFsLiBXaGVuIG5vdCBpbXBsZW1lbnRlZCwgdGhlIGNvcmUgd2ls bAo+ICsJICogZmFsbCBiYWNrIHRvICZkcm1fY29ubmVjdG9yLmRpc3BsYXlfaW5mby5idXNfZm9y bWF0c1swXSBpZgo+ICsJICogJmRybV9jb25uZWN0b3IuZGlzcGxheV9pbmZvLm51bV9idXNfZm9y bWF0cyA+IDAsCj4gKwkgKiBvciB0byBNRURJQV9CVVNfRk1UX0ZJWEVEIG90aGVyd2lzZS4KPiAr CSAqLwo+ICsJdTMyICooKmF0b21pY19nZXRfb3V0cHV0X2J1c19mbXRzKShzdHJ1Y3QgZHJtX2Jy aWRnZSAqYnJpZGdlLAo+ICsJCQkJCSAgIHN0cnVjdCAKZHJtX2JyaWRnZV9zdGF0ZSAqYnJpZGdl X3N0YXRlLAo+ICsJCQkJCSAgIHN0cnVjdCAKZHJtX2NydGNfc3RhdGUgKmNydGNfc3RhdGUsCj4g KwkJCQkJICAgc3RydWN0IApkcm1fY29ubmVjdG9yX3N0YXRlICpjb25uX3N0YXRlLAo+ICsJCQkJ CSAgIHVuc2lnbmVkIGludCAKKm51bV9vdXRwdXRfZm10cyk7Cj4gKwo+ICsJLyoqCj4gKwkgKiBA YXRvbWljX2dldF9pbnB1dF9idXNfZm10czoKPiArCSAqCj4gKwkgKiBSZXR1cm4gdGhlIHN1cHBv cnRlZCBidXMgZm9ybWF0cyBvbiB0aGUgaW5wdXQgZW5kIG9mIGEgYnJpZGdlIApmb3IKPiArCSAq IGEgc3BlY2lmaWMgb3V0cHV0IGJ1cyBmb3JtYXQuCj4gKwkgKgo+ICsJICogVGhlIHJldHVybmVk IGFycmF5IG11c3QgYmUgYWxsb2NhdGVkIHdpdGgga21hbGxvYygpIGFuZCB3aWxsIGJlCj4gKwkg KiBmcmVlZCBieSB0aGUgY2FsbGVyLiBJZiB0aGUgYWxsb2NhdGlvbiBmYWlscywgTlVMTCBzaG91 bGQgYmUKPiArCSAqIHJldHVybmVkLiBudW1fb3V0cHV0X2ZtdHMgbXVzdCBiZSBzZXQgdG8gdGhl IHJldHVybmVkIGFycmF5IApzaXplLgo+ICsJICogRm9ybWF0cyBsaXN0ZWQgaW4gdGhlIHJldHVy bmVkIGFycmF5IHNob3VsZCBiZSBsaXN0ZWQgaW4gCmRlY3JlYXNpbmcKPiArCSAqIHByZWZlcmVu Y2Ugb3JkZXIgKHRoZSBjb3JlIHdpbGwgdHJ5IGFsbCBmb3JtYXRzIHVudGlsIGl0IGZpbmRzIApv bmUKPiArCSAqIHRoYXQgd29ya3MpLiBXaGVuIHRoZSBmb3JtYXQgaXMgbm90IHN1cHBvcnRlZCBO VUxMIHNob3VsZCBiZQo+ICsJICogcmV0dXJuZWQgYW5kICpudW1fb3V0cHV0X2ZtdHMgc2hvdWxk IGJlIHNldCB0byAwLgo+ICsJICoKPiArCSAqIFRoaXMgbWV0aG9kIGlzIGNhbGxlZCBvbiBhbGwg ZWxlbWVudHMgb2YgdGhlIGJyaWRnZSBjaGFpbiBhcyAKcGFydCBvZgo+ICsJICogdGhlIGJ1cyBm b3JtYXQgbmVnb3RpYXRpb24gcHJvY2VzcyB0aGF0IGhhcHBlbnMgaW4KPiArCSAqICZkcm1fYXRv bWljX2JyaWRnZV9jaGFpbl9zZWxlY3RfYnVzX2ZtdHMoKS4KPiArCSAqIFRoaXMgbWV0aG9kIGlz IG9wdGlvbmFsLiBXaGVuIG5vdCBpbXBsZW1lbnRlZCwgdGhlIGNvcmUgd2lsbCAKYnlwYXNzCj4g KwkgKiBidXMgZm9ybWF0IG5lZ290aWF0aW9uIG9uIHRoaXMgZWxlbWVudCBvZiB0aGUgYnJpZGdl IHdpdGhvdXQKPiArCSAqIGZhaWxpbmcsIGFuZCB0aGUgcHJldmlvdXMgZWxlbWVudCBpbiB0aGUg Y2hhaW4gd2lsbCBiZSBwYXNzZWQKPiArCSAqIE1FRElBX0JVU19GTVRfRklYRUQgYXMgaXRzIG91 dHB1dCBidXMgZm9ybWF0Lgo+ICsJICoKPiArCSAqIEJyaWRnZSBkcml2ZXJzIHRoYXQgbmVlZCB0 byBzdXBwb3J0IGJlaW5nIGxpbmtlZCB0byBicmlkZ2VzIHRoYXQgCmFyZQo+ICsJICogbm90IHN1 cHBvcnRpbmcgYnVzIGZvcm1hdCBuZWdvdGlhdGlvbiBzaG91bGQgaGFuZGxlIHRoZQo+ICsJICog b3V0cHV0X2ZtdCA9PSBNRURJQV9CVVNfRk1UX0ZJWEVEIGNhc2UgYXBwcm9wcmlhdGVseSwgYnkg CnNlbGVjdGluZyBhCj4gKwkgKiBzZW5zaWJsZSBkZWZhdWx0IHZhbHVlIG9yIGV4dHJhY3Rpbmcg dGhpcyBpbmZvcm1hdGlvbiBmcm9tIApzb21ld2hlcmUKPiArCSAqIGVsc2UgKEZXIHByb3BlcnR5 LCAmZHJtX2Rpc3BsYXlfbW9kZSwgJmRybV9kaXNwbGF5X2luZm8sIC4uLikKPiArCSAqCj4gKwkg KiBOb3RlOiBFdmVuIGlmIGlucHV0IGZvcm1hdCBzZWxlY3Rpb24gb24gdGhlIGZpcnN0IGJyaWRn ZSBoYXMgbm8KPiArCSAqIGltcGFjdCBvbiB0aGUgbmVnb3RpYXRpb24gcHJvY2VzcyAoYnVzIGZv cm1hdCBuZWdvdGlhdGlvbiBzdG9wcyAKb25jZQo+ICsJICogd2UgcmVhY2ggdGhlIGZpcnN0IGVs ZW1lbnQgb2YgdGhlIGNoYWluKSwgZHJpdmVycyBhcmUgZXhwZWN0ZWQgdG8KPiArCSAqIHJldHVy biBhY2N1cmF0ZSBpbnB1dCBmb3JtYXRzIGFzIHRoZSBpbnB1dCBmb3JtYXQgbWF5IGJlIHVzZWQg dG8KPiArCSAqIGNvbmZpZ3VyZSB0aGUgQ1JUQyBvdXRwdXQgYXBwcm9wcmlhdGVseS4KPiArCSAq Lwo+ICsJdTMyICooKmF0b21pY19nZXRfaW5wdXRfYnVzX2ZtdHMpKHN0cnVjdCBkcm1fYnJpZGdl ICpicmlkZ2UsCj4gKwkJCQkJICBzdHJ1Y3QgCmRybV9icmlkZ2Vfc3RhdGUgKmJyaWRnZV9zdGF0 ZSwKPiArCQkJCQkgIHN0cnVjdCBkcm1fY3J0Y19zdGF0ZSAKKmNydGNfc3RhdGUsCj4gKwkJCQkJ ICBzdHJ1Y3QgCmRybV9jb25uZWN0b3Jfc3RhdGUgKmNvbm5fc3RhdGUsCj4gKwkJCQkJICB1MzIg b3V0cHV0X2ZtdCwKPiArCQkJCQkgIHVuc2lnbmVkIGludCAKKm51bV9pbnB1dF9mbXRzKTsKPiAr Cj4gIAkvKioKPiAgCSAqIEBhdG9taWNfY2hlY2s6Cj4gIAkgKgo+IEBAIC00MDEsNiArNTA5LDE0 IEBAIHN0cnVjdCBkcm1fYnJpZGdlX2Z1bmNzIHsKPiAgCSAqIGNhbGxlZCB3aGVuICZkcm1fYnJp ZGdlX2Z1bmNzLmF0b21pY19jaGVjaygpIGlzIGltcGxlbWVudGVkLCBzbyAKb25seQo+ICAJICog b25lIG9mIHRoZW0gc2hvdWxkIGJlIHByb3ZpZGVkLgo+ICAJICoKPiArCSAqIElmIGRyaXZlcnMg bmVlZCB0byB0d2VhayAmZHJtX2JyaWRnZV9zdGF0ZS5pbnB1dF9idXNfY2ZnLmZsYWdzIG9yCj4g KwkgKiAmZHJtX2JyaWRnZV9zdGF0ZS5vdXRwdXRfYnVzX2NmZy5mbGFncyBpdCBzaG91bGQgc2hv dWxkIGhhcHBlbiBpbgoKInNob3VsZCIgaXMgZHVwbGljYXRlZCBeCgpCZXN0IHJlZ2FyZHMsCkpl cm5lagoKPiArCSAqIHRoaXMgZnVuY3Rpb24uIEJ5IGRlZmF1bHQgdGhlIAomZHJtX2JyaWRnZV9z dGF0ZS5vdXRwdXRfYnVzX2NmZy5mbGFncwo+ICsJICogZmllbGQgaXMgc2V0IHRvIHRoZSBuZXh0 IGJyaWRnZQo+ICsJICogJmRybV9icmlkZ2Vfc3RhdGUuaW5wdXRfYnVzX2NmZy5mbGFncyB2YWx1 ZSBvcgo+ICsJICogJmRybV9jb25uZWN0b3IuZGlzcGxheV9pbmZvLmJ1c19mbGFncyBpZiB0aGUg YnJpZGdlIGlzIHRoZSBsYXN0Cj4gKwkgKiBlbGVtZW50IGluIHRoZSBjaGFpbi4KPiArCSAqCj4g IAkgKiBSRVRVUk5TOgo+ICAJICogemVybyBpZiB0aGUgY2hlY2sgcGFzc2VkLCBhIG5lZ2F0aXZl IGVycm9yIGNvZGUgb3RoZXJ3aXNlLgo+ICAJICovCj4gQEAgLTU4OCw2ICs3MDQsMTQgQEAgdm9p ZCBkcm1fYXRvbWljX2JyaWRnZV9jaGFpbl9wcmVfZW5hYmxlKHN0cnVjdAo+IGRybV9icmlkZ2Ug KmJyaWRnZSwgdm9pZCBkcm1fYXRvbWljX2JyaWRnZV9jaGFpbl9lbmFibGUoc3RydWN0IGRybV9i cmlkZ2UKPiAqYnJpZGdlLAo+ICAJCQkJICAgIHN0cnVjdCBkcm1fYXRvbWljX3N0YXRlIAoqc3Rh dGUpOwo+IAo+ICt1MzIgKgo+ICtkcm1fYXRvbWljX2hlbHBlcl9icmlkZ2VfcHJvcGFnYXRlX2J1 c19mbXQoc3RydWN0IGRybV9icmlkZ2UgKmJyaWRnZSwKPiArCQkJCQlzdHJ1Y3QgZHJtX2JyaWRn ZV9zdGF0ZSAKKmJyaWRnZV9zdGF0ZSwKPiArCQkJCQlzdHJ1Y3QgZHJtX2NydGNfc3RhdGUgCipj cnRjX3N0YXRlLAo+ICsJCQkJCXN0cnVjdCAKZHJtX2Nvbm5lY3Rvcl9zdGF0ZSAqY29ubl9zdGF0 ZSwKPiArCQkJCQl1MzIgb3V0cHV0X2ZtdCwKPiArCQkJCQl1bnNpZ25lZCBpbnQgCipudW1faW5w dXRfZm10cyk7Cj4gKwo+ICB2b2lkIF9fZHJtX2F0b21pY19oZWxwZXJfYnJpZGdlX3Jlc2V0KHN0 cnVjdCBkcm1fYnJpZGdlICpicmlkZ2UsCj4gIAkJCQkgICAgICBzdHJ1Y3QgZHJtX2JyaWRnZV9z dGF0ZSAKKnN0YXRlKTsKPiAgdm9pZCBkcm1fYXRvbWljX2hlbHBlcl9icmlkZ2VfZGVzdHJveV9z dGF0ZShzdHJ1Y3QgZHJtX2JyaWRnZSAqYnJpZGdlLAoKCgoKX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fX18KZHJpLWRldmVsIG1haWxpbmcgbGlzdApkcmktZGV2 ZWxAbGlzdHMuZnJlZWRlc2t0b3Aub3JnCmh0dHBzOi8vbGlzdHMuZnJlZWRlc2t0b3Aub3JnL21h aWxtYW4vbGlzdGluZm8vZHJpLWRldmVsCg==