From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from mga01.intel.com ([192.55.52.88]:37328 "EHLO mga01.intel.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S933338AbcECQdf (ORCPT ); Tue, 3 May 2016 12:33:35 -0400 Message-ID: <5728D2DA.2020201@intel.com> Date: Tue, 03 May 2016 22:03:30 +0530 From: "Sharma, Shashank" MIME-Version: 1.0 To: ville.syrjala@linux.intel.com, dri-devel@lists.freedesktop.org CC: intel-gfx@lists.freedesktop.org, stable@vger.kernel.org, Tore Anderson , Paulo Zanoni , Daniel Vetter Subject: Re: [PATCH v2 1/4] drm: Add helper for DP++ adaptors References: <1462216105-20881-1-git-send-email-ville.syrjala@linux.intel.com> <1462216105-20881-2-git-send-email-ville.syrjala@linux.intel.com> In-Reply-To: <1462216105-20881-2-git-send-email-ville.syrjala@linux.intel.com> Content-Type: text/plain; charset=utf-8; format=flowed Content-Transfer-Encoding: 8bit Sender: stable-owner@vger.kernel.org List-ID: On 5/3/2016 12:38 AM, ville.syrjala@linux.intel.com wrote: > From: Ville Syrjälä > > Add a helper which aids in the identification of DP dual mode > (aka. DP++) adaptors. There are several types of adaptors > specified: type 1 DVI, type 1 HDMI, type 2 DVI, type 2 HDMI > > Type 1 adaptors have a max TMDS clock limit of 165MHz, type 2 adaptors > may go as high as 300MHz and they provide a register informing the > source device what the actual limit is. Supposedly also type 1 adaptors > may optionally implement this register. This TMDS clock limit is the > main reason why we need to identify these adaptors. > > Type 1 adaptors provide access to their internal registers and the sink > DDC bus through I2C. Type 2 adaptors provide this access both via I2C > and I2C-over-AUX. A type 2 source device may choose to implement either > of these methods. If a source device implements the I2C-over-AUX > method, then the driver will obviously need specific support for such > adaptors since the port is driven like an HDMI port, but DDC > communication happes over the AUX channel. > > This helper should be enough to identify the adaptor type (some > type 1 DVI adaptors may be a slight exception) and the maximum TMDS > clock limit. Another feature that may be available is control over > the TMDS output buffers on the adaptor, possibly allowing for some > power saving when the TMDS link is down. > > Other user controllable features that may be available in the adaptors > are downstream i2c bus speed control when using i2c-over-aux, and > some control over the CEC pin. I chose not to provide any helper > functions for those since I have no use for them in i915 at this time. > The rest of the registers in the adaptor are mostly just information, > eg. IEEE OUI, hardware and firmware revision, etc. > > v2: Pass adaptor type to helper functions to ease driver implementation > Fix a bunch of typoes (Paulo) > Add DRM_DP_DUAL_MODE_UNKNOWN for the case where we don't (yet) know > the type (Paulo) > Reject 0x00 and 0xff DP_DUAL_MODE_MAX_TMDS_CLOCK values (Paulo) > Adjust drm_dp_dual_mode_detect() type2 vs. type1 detection to > ease future LSPCON enabling > Remove the unused DP_DUAL_MODE_LAST_RESERVED define > > Cc: stable@vger.kernel.org > Cc: Tore Anderson > Cc: Paulo Zanoni > Cc: Shashank Sharma > Cc: Daniel Vetter > Signed-off-by: Ville Syrjälä > --- > drivers/gpu/drm/Makefile | 2 +- > drivers/gpu/drm/drm_dp_dual_mode_helper.c | 356 ++++++++++++++++++++++++++++++ > include/drm/drm_dp_dual_mode_helper.h | 83 +++++++ > 3 files changed, 440 insertions(+), 1 deletion(-) > create mode 100644 drivers/gpu/drm/drm_dp_dual_mode_helper.c > create mode 100644 include/drm/drm_dp_dual_mode_helper.h > > diff --git a/drivers/gpu/drm/Makefile b/drivers/gpu/drm/Makefile > index 1a26b4eb1ce0..29f2ee9b9534 100644 > --- a/drivers/gpu/drm/Makefile > +++ b/drivers/gpu/drm/Makefile > @@ -23,7 +23,7 @@ drm-$(CONFIG_AGP) += drm_agpsupport.o > > drm_kms_helper-y := drm_crtc_helper.o drm_dp_helper.o drm_probe_helper.o \ > drm_plane_helper.o drm_dp_mst_topology.o drm_atomic_helper.o \ > - drm_kms_helper_common.o > + drm_kms_helper_common.o drm_dp_dual_mode_helper.o > > drm_kms_helper-$(CONFIG_DRM_LOAD_EDID_FIRMWARE) += drm_edid_load.o > drm_kms_helper-$(CONFIG_DRM_FBDEV_EMULATION) += drm_fb_helper.o > diff --git a/drivers/gpu/drm/drm_dp_dual_mode_helper.c b/drivers/gpu/drm/drm_dp_dual_mode_helper.c > new file mode 100644 > index 000000000000..949c0fbeb542 > --- /dev/null > +++ b/drivers/gpu/drm/drm_dp_dual_mode_helper.c > @@ -0,0 +1,356 @@ > +/* > + * Copyright © 2016 Intel Corporation > + * > + * Permission is hereby granted, free of charge, to any person obtaining a > + * copy of this software and associated documentation files (the "Software"), > + * to deal in the Software without restriction, including without limitation > + * the rights to use, copy, modify, merge, publish, distribute, sublicense, > + * and/or sell copies of the Software, and to permit persons to whom the > + * Software is furnished to do so, subject to the following conditions: > + * > + * The above copyright notice and this permission notice shall be included in > + * all copies or substantial portions of the Software. > + * > + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR > + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, > + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL > + * THE COPYRIGHT HOLDER(S) OR AUTHOR(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR > + * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, > + * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR > + * OTHER DEALINGS IN THE SOFTWARE. > + */ > + > +#include > +#include > +#include > +#include > +#include > +#include > +#include > + > +/** > + * DOC: DP dual mode (aka. DP++) adaptor helpers > + * > + * Helper functions to deal with DP dual mode adaptors. > + * > + * Type 1: > + * Adaptor registers (if any) and the sink DDC bus may be accessed via I2C. > + * > + * Type 2: > + * Adaptor registers and sink DDC bus can be accessed either via I2C or > + * I2C-over-AUX. Source devices may choose to implement either of these > + * access methods. > + */ > + > +#define DP_DUAL_MODE_SLAVE_ADDRESS 0x40 > + > +/** > + * drm_dp_dual_mode_read - Read from the DP dual mode adaptor register(s) > + * adapter: I2C adapter for the DDC bus > + * offset: register offset > + * buffer: buffer for return data > + * size: sizo of the buffer > + * > + * Reads @size bytes from the DP dual mode adaptor registers > + * starting at @offset. > + * > + * Returns: > + * 0 on success, negative error code on failure > + */ > +ssize_t drm_dp_dual_mode_read(struct i2c_adapter *adapter, > + u8 offset, void *buffer, size_t size) > +{ > + struct i2c_msg msgs[] = { > + { > + .addr = DP_DUAL_MODE_SLAVE_ADDRESS, > + .flags = 0, > + .len = 1, > + .buf = &offset, > + }, > + { > + .addr = DP_DUAL_MODE_SLAVE_ADDRESS, > + .flags = I2C_M_RD, > + .len = size, > + .buf = buffer, > + }, > + }; > + int ret; > + > + ret = i2c_transfer(adapter, msgs, ARRAY_SIZE(msgs)); > + if (ret < 0) > + return ret; > + if (ret != ARRAY_SIZE(msgs)) > + return -EPROTO; > + > + return 0; > +} > + > +/** > + * drm_dp_dual_mode_write - Write to the DP dual mode adaptor register(s) > + * adapter: I2C adapter for the DDC bus > + * offset: register offset > + * buffer: buffer for write data > + * size: sizo of the buffer > + * > + * Writes @size bytes to the DP dual mode adaptor registers > + * starting at @offset. > + * > + * Returns: > + * 0 on success, negative error code on failure > + */ > +ssize_t drm_dp_dual_mode_write(struct i2c_adapter *adapter, > + u8 offset, const void *buffer, size_t size) > +{ > + struct i2c_msg msg = { > + .addr = DP_DUAL_MODE_SLAVE_ADDRESS, > + .flags = 0, > + .len = 1 + size, > + .buf = NULL, > + }; > + void *data; > + int ret; > + > + data = kmalloc(msg.len, GFP_TEMPORARY); > + if (!data) > + return -ENOMEM; > + > + msg.buf = data; > + > + memcpy(data, &offset, 1); > + memcpy(data + 1, buffer, size); > + > + ret = i2c_transfer(adapter, &msg, 1); > + > + kfree(data); > + > + if (ret < 0) > + return ret; > + if (ret != 1) > + return -EPROTO; > + > + return 0; > +} > +EXPORT_SYMBOL(drm_dp_dual_mode_write); > + > +static bool is_hdmi_adaptor(const char hdmi_id[DP_DUAL_MODE_HDMI_ID_LEN]) > +{ > + static const char dp_dual_mode_hdmi_id[DP_DUAL_MODE_HDMI_ID_LEN] = > + "DP-HDMI ADAPTOR\x04"; > + > + return memcmp(hdmi_id, dp_dual_mode_hdmi_id, > + sizeof(dp_dual_mode_hdmi_id)) == 0; > +} > + > +static bool is_type2_adaptor(uint8_t adaptor_id) > +{ > + return adaptor_id == (DP_DUAL_MODE_TYPE_TYPE2 | > + DP_DUAL_MODE_REV_TYPE2); > +} > + > +/** > + * drm_dp_dual_mode_detect - Identify the DP dual mode adaptor > + * adapter: I2C adapter for the DDC bus > + * > + * Attempt to identify the type of the DP dual mode adaptor used. > + * > + * Note that when the answer is @DRM_DP_DUAL_MODE_NONE it's not > + * certain whether we're dealing with a native HDMI port or > + * a type 1 DVI dual mode adaptor. The driver will have to use > + * some other hardware/driver specific mechanism to make that > + * distinction. > + * > + * Returns: > + * The type of the DP dual mode adaptor used > + */ > +enum drm_dp_dual_mode_type drm_dp_dual_mode_detect(struct i2c_adapter *adapter) > +{ > + char hdmi_id[DP_DUAL_MODE_HDMI_ID_LEN] = {}; > + uint8_t adaptor_id = 0x00; > + ssize_t ret; > + > + /* > + * Let's see if the adaptor is there the by reading the > + * HDMI ID registers. > + * > + * Note that type 1 DVI adaptors are not required to implemnt > + * any registers, and that presents a problem for detection. > + * If the i2c transfer is nacked, we may or may not be dealing > + * with a type 1 DVI adaptor. Some other mechanism of detecting > + * the presence of the adaptor is required. One way would be > + * to check the state of the CONFIG1 pin, Another method would > + * simply require the driver to know whether the port is a DP++ > + * port or a native HDMI port. Both of these methods are entirely > + * hardware/driver specific so we can't deal with them here. > + */ > + ret = drm_dp_dual_mode_read(adapter, DP_DUAL_MODE_HDMI_ID, > + hdmi_id, sizeof(hdmi_id)); > + if (ret) > + return DRM_DP_DUAL_MODE_UNKNOWN; > + > + /* > + * Sigh. Some (maybe all?) type 1 adaptors are broken and ack > + * the offset but ignore it, and instead they just always return > + * data from the start of the HDMI ID buffer. So for a broken > + * type 1 HDMI adaptor a single byte read will always give us > + * 0x44, and for a type 1 DVI adaptor it should give 0x00 > + * (assuming it implements any registers). Fortunately neither > + * of those values will match the type 2 signature of the > + * DP_DUAL_MODE_ADAPTOR_ID register so we can proceed with > + * the type 2 adaptor detection safely even in the presence > + * of broken type 1 adaptors. > + */ > + ret = drm_dp_dual_mode_read(adapter, DP_DUAL_MODE_ADAPTOR_ID, > + &adaptor_id, sizeof(adaptor_id)); can we read all 16 bytes in a single read, and then split the characters into dongle_signature and adaptor_id ? > + if (ret == 0) { > + if (is_type2_adaptor(adaptor_id) && is_hdmi_adaptor(hdmi_id)) > + return DRM_DP_DUAL_MODE_TYPE2_HDMI; > + else if (is_type2_adaptor(adaptor_id)) > + return DRM_DP_DUAL_MODE_TYPE2_DVI; can we save one if, or its too late for me to work :) ? is_type2_adaptor() { is_hdmi_adaptor() return type2_hdmi; else return type2_dvi } > + } > + > + if (is_hdmi_adaptor(hdmi_id)) > + return DRM_DP_DUAL_MODE_TYPE1_HDMI; > + else > + return DRM_DP_DUAL_MODE_TYPE1_DVI; > +} > +EXPORT_SYMBOL(drm_dp_dual_mode_detect); > + > +/** > + * drm_dp_dual_mode_max_tmds_clock - Max TMDS clock for DP dual mode adaptor > + * type: DP dual mode adaptor type > + * adapter: I2C adapter for the DDC bus > + * > + * Determine the max TMDS clock the adaptor supports based on the > + * type of the dual mode adaptor and the DP_DUAL_MODE_MAX_TMDS_CLOCK > + * register (on type2 adaptors). As some type 1 adaptors have > + * problems with registers (see comments in drm_dp_dual_mode_detect()) > + * we don't read the register on those, instead we simply assume > + * a 165 MHz limit based on the specification. > + * > + * Returns: > + * Maximum supported TMDS clock rate for the DP dual mode adaptor in kHz. > + */ > +int drm_dp_dual_mode_max_tmds_clock(enum drm_dp_dual_mode_type type, > + struct i2c_adapter *adapter) > +{ > + uint8_t max_tmds_clock; > + ssize_t ret; > + > + /* native HDMI so no limit */ > + if (type == DRM_DP_DUAL_MODE_NONE) > + return 0; > + > + /* > + * Type 1 adaptors are limited to 165MHz > + * Type 2 adaptors can tells us their limit > + */ > + if (type < DRM_DP_DUAL_MODE_TYPE2_DVI) > + return 165000; > + > + ret = drm_dp_dual_mode_read(adapter, DP_DUAL_MODE_MAX_TMDS_CLOCK, > + &max_tmds_clock, sizeof(max_tmds_clock)); > + if (ret || max_tmds_clock == 0x00 || max_tmds_clock == 0xff) > + return 165000; > + > + return max_tmds_clock * 5000 / 2; > +} > +EXPORT_SYMBOL(drm_dp_dual_mode_max_tmds_clock); > + > +/** > + * drm_dp_dual_mode_get_tmds_output - Get the state of the TMDS output buffers in the DP dual mode adaptor > + * type: DP dual mode adaptor type > + * adapter: I2C adapter for the DDC bus > + * enabled: current state of the TMDS output buffers > + * > + * Get the state of the TMDS output buffers in the adaptor. For > + * type2 adaptors this is queried from the DP_DUAL_MODE_TMDS_OEN > + * register. As some type 1 adaptors have problems with registers > + * (see comments in drm_dp_dual_mode_detect()) we don't read the > + * register on those, instead we simply assume that the buffers > + * are always enabled. > + * > + * Returns: > + * 0 on success, negative error code on failure > + */ > +int drm_dp_dual_mode_get_tmds_output(enum drm_dp_dual_mode_type type, > + struct i2c_adapter *adapter, > + bool *enabled) > +{ > + uint8_t tmds_oen; > + ssize_t ret; > + > + if (type < DRM_DP_DUAL_MODE_TYPE2_DVI) { > + *enabled = true; > + return 0; > + } > + > + ret = drm_dp_dual_mode_read(adapter, DP_DUAL_MODE_TMDS_OEN, > + &tmds_oen, sizeof(tmds_oen)); > + if (ret) debug message here might help in failure cases. > + return ret; > + > + *enabled = !(tmds_oen & DP_DUAL_MODE_TMDS_DISABLE); > + > + return 0; > +} > +EXPORT_SYMBOL(drm_dp_dual_mode_get_tmds_output); > + > +/** > + * drm_dp_dual_mode_set_tmds_output - Enable/disable TMDS output buffers in the DP dual mode adaptor > + * type: DP dual mode adaptor type > + * adapter: I2C adapter for the DDC bus > + * enable: enable (as opposed to disable) the TMDS output buffers > + * > + * Set the state of the TMDS output buffers in the adaptor. For > + * type2 this is set via the DP_DUAL_MODE_TMDS_OEN register. As > + * some type 1 adaptors have problems with registers (see comments > + * in drm_dp_dual_mode_detect()) we avoid touching the register, > + * making this function a no-op on type 1 adaptors. > + * > + * Returns: > + * 0 on success, negative error code on failure > + */ > +int drm_dp_dual_mode_set_tmds_output(enum drm_dp_dual_mode_type type, > + struct i2c_adapter *adapter, bool enable) > +{ > + uint8_t tmds_oen = enable ? 0 : DP_DUAL_MODE_TMDS_DISABLE; > + ssize_t ret; > + > + if (type < DRM_DP_DUAL_MODE_TYPE2_DVI) > + return 0; > + > + ret = drm_dp_dual_mode_write(adapter, DP_DUAL_MODE_TMDS_OEN, > + &tmds_oen, sizeof(tmds_oen)); > + if (ret) debug message here might help in failure cases. > + return ret; > + > + return 0; > +} > +EXPORT_SYMBOL(drm_dp_dual_mode_set_tmds_output); > + > +/** > + * drm_dp_get_dual_mode_type_name - Get the name of the DP dual mode adaptor type as a string > + * type: DP dual mode adaptor type > + * > + * Returns: > + * String representation of the DP dual mode adaptor type > + */ > +const char *drm_dp_get_dual_mode_type_name(enum drm_dp_dual_mode_type type) > +{ > + switch (type) { > + case DRM_DP_DUAL_MODE_NONE: > + return "none"; > + case DRM_DP_DUAL_MODE_TYPE1_DVI: > + return "type 1 DVI"; > + case DRM_DP_DUAL_MODE_TYPE1_HDMI: > + return "type 1 HDMI"; > + case DRM_DP_DUAL_MODE_TYPE2_DVI: > + return "type 2 DVI"; > + case DRM_DP_DUAL_MODE_TYPE2_HDMI: > + return "type 2 HDMI"; > + default: > + WARN_ON(type != DRM_DP_DUAL_MODE_UNKNOWN); do we need a warning here, or a DRM_ERROR should work ? I am afraid we will show a back-trace for all non-compliant adapters. > + return "unknown"; > + } > +} > +EXPORT_SYMBOL(drm_dp_get_dual_mode_type_name); > diff --git a/include/drm/drm_dp_dual_mode_helper.h b/include/drm/drm_dp_dual_mode_helper.h > new file mode 100644 > index 000000000000..b4603b9fc03d > --- /dev/null > +++ b/include/drm/drm_dp_dual_mode_helper.h > @@ -0,0 +1,83 @@ > +/* > + * Copyright © 2016 Intel Corporation > + * > + * Permission is hereby granted, free of charge, to any person obtaining a > + * copy of this software and associated documentation files (the "Software"), > + * to deal in the Software without restriction, including without limitation > + * the rights to use, copy, modify, merge, publish, distribute, sublicense, > + * and/or sell copies of the Software, and to permit persons to whom the > + * Software is furnished to do so, subject to the following conditions: > + * > + * The above copyright notice and this permission notice shall be included in > + * all copies or substantial portions of the Software. > + * > + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR > + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, > + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL > + * THE COPYRIGHT HOLDER(S) OR AUTHOR(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR > + * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, > + * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR > + * OTHER DEALINGS IN THE SOFTWARE. > + */ > + > +#ifndef DRM_DP_DUAL_MODE_HELPER_H > +#define DRM_DP_DUAL_MODE_HELPER_H > + > +#include > + > +/* > + * Optional for type 1 DVI adaptors > + * Mandatory for type 1 HDMI and type 2 adators > + */ > +#define DP_DUAL_MODE_HDMI_ID 0x00 /* 00-0f */ > +#define DP_DUAL_MODE_HDMI_ID_LEN 16 > +/* > + * Optional for type 1 adaptors > + * Mandatory for type 2 adators > + */ > +#define DP_DUAL_MODE_ADAPTOR_ID 0x10 > +#define DP_DUAL_MODE_REV_MASK 0x07 > +#define DP_DUAL_MODE_REV_TYPE2 0x00 > +#define DP_DUAL_MODE_TYPE_MASK 0xf0 > +#define DP_DUAL_MODE_TYPE_TYPE2 0xa0 > +#define DP_DUAL_MODE_IEEE_OUI 0x11 /* 11-13*/ > +#define DP_DUAL_IEEE_OUI_LEN 3 > +#define DP_DUAL_DEVICE_ID 0x14 /* 14-19 */ > +#define DP_DUAL_DEVICE_ID_LEN 6 > +#define DP_DUAL_MODE_HARDWARE_REV 0x1a > +#define DP_DUAL_MODE_FIRMWARE_MAJOR_REV 0x1b > +#define DP_DUAL_MODE_FIRMWARE_MINOR_REV 0x1c > +#define DP_DUAL_MODE_MAX_TMDS_CLOCK 0x1d > +#define DP_DUAL_MODE_I2C_SPEED_CAP 0x1e > +#define DP_DUAL_MODE_TMDS_OEN 0x20 > +#define DP_DUAL_MODE_TMDS_DISABLE 0x01 > +#define DP_DUAL_MODE_HDMI_PIN_CTRL 0x21 > +#define DP_DUAL_MODE_CEC_ENABLE 0x01 > +#define DP_DUAL_MODE_I2C_SPEED_CTRL 0x22 > + > +struct i2c_adapter; > + > +ssize_t drm_dp_dual_mode_read(struct i2c_adapter *adapter, > + u8 offset, void *buffer, size_t size); > +ssize_t drm_dp_dual_mode_write(struct i2c_adapter *adapter, > + u8 offset, const void *buffer, size_t size); > + > +enum drm_dp_dual_mode_type { > + DRM_DP_DUAL_MODE_NONE, what does dual mode none indicate (considering we have an unknown case below) ? Regards Shashank > + DRM_DP_DUAL_MODE_UNKNOWN, > + DRM_DP_DUAL_MODE_TYPE1_DVI, > + DRM_DP_DUAL_MODE_TYPE1_HDMI, > + DRM_DP_DUAL_MODE_TYPE2_DVI, > + DRM_DP_DUAL_MODE_TYPE2_HDMI, > +}; > + > +enum drm_dp_dual_mode_type drm_dp_dual_mode_detect(struct i2c_adapter *adapter); > +int drm_dp_dual_mode_max_tmds_clock(enum drm_dp_dual_mode_type type, > + struct i2c_adapter *adapter); > +int drm_dp_dual_mode_get_tmds_output(enum drm_dp_dual_mode_type type, > + struct i2c_adapter *adapter, bool *enabled); > +int drm_dp_dual_mode_set_tmds_output(enum drm_dp_dual_mode_type type, > + struct i2c_adapter *adapter, bool enable); > +const char *drm_dp_get_dual_mode_type_name(enum drm_dp_dual_mode_type type); > + > +#endif > From mboxrd@z Thu Jan 1 00:00:00 1970 From: "Sharma, Shashank" Subject: Re: [PATCH v2 1/4] drm: Add helper for DP++ adaptors Date: Tue, 03 May 2016 22:03:30 +0530 Message-ID: <5728D2DA.2020201@intel.com> References: <1462216105-20881-1-git-send-email-ville.syrjala@linux.intel.com> <1462216105-20881-2-git-send-email-ville.syrjala@linux.intel.com> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8"; Format="flowed" Content-Transfer-Encoding: base64 Return-path: In-Reply-To: <1462216105-20881-2-git-send-email-ville.syrjala@linux.intel.com> List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: dri-devel-bounces@lists.freedesktop.org Sender: "dri-devel" To: ville.syrjala@linux.intel.com, dri-devel@lists.freedesktop.org Cc: Daniel Vetter , intel-gfx@lists.freedesktop.org, Tore Anderson , Paulo Zanoni , stable@vger.kernel.org List-Id: dri-devel@lists.freedesktop.org CgpPbiA1LzMvMjAxNiAxMjozOCBBTSwgdmlsbGUuc3lyamFsYUBsaW51eC5pbnRlbC5jb20gd3Jv dGU6Cj4gRnJvbTogVmlsbGUgU3lyasOkbMOkIDx2aWxsZS5zeXJqYWxhQGxpbnV4LmludGVsLmNv bT4KPgo+IEFkZCBhIGhlbHBlciB3aGljaCBhaWRzIGluIHRoZSBpZGVudGlmaWNhdGlvbiBvZiBE UCBkdWFsIG1vZGUKPiAoYWthLiBEUCsrKSBhZGFwdG9ycy4gVGhlcmUgYXJlIHNldmVyYWwgdHlw ZXMgb2YgYWRhcHRvcnMKPiBzcGVjaWZpZWQ6IHR5cGUgMSBEVkksIHR5cGUgMSBIRE1JLCB0eXBl IDIgRFZJLCB0eXBlIDIgSERNSQo+Cj4gVHlwZSAxIGFkYXB0b3JzIGhhdmUgYSBtYXggVE1EUyBj bG9jayBsaW1pdCBvZiAxNjVNSHosIHR5cGUgMiBhZGFwdG9ycwo+IG1heSBnbyBhcyBoaWdoIGFz IDMwME1IeiBhbmQgdGhleSBwcm92aWRlIGEgcmVnaXN0ZXIgaW5mb3JtaW5nIHRoZQo+IHNvdXJj ZSBkZXZpY2Ugd2hhdCB0aGUgYWN0dWFsIGxpbWl0IGlzLiBTdXBwb3NlZGx5IGFsc28gdHlwZSAx IGFkYXB0b3JzCj4gbWF5IG9wdGlvbmFsbHkgaW1wbGVtZW50IHRoaXMgcmVnaXN0ZXIuIFRoaXMg VE1EUyBjbG9jayBsaW1pdCBpcyB0aGUKPiBtYWluIHJlYXNvbiB3aHkgd2UgbmVlZCB0byBpZGVu dGlmeSB0aGVzZSBhZGFwdG9ycy4KPgo+IFR5cGUgMSBhZGFwdG9ycyBwcm92aWRlIGFjY2VzcyB0 byB0aGVpciBpbnRlcm5hbCByZWdpc3RlcnMgYW5kIHRoZSBzaW5rCj4gRERDIGJ1cyB0aHJvdWdo IEkyQy4gVHlwZSAyIGFkYXB0b3JzIHByb3ZpZGUgdGhpcyBhY2Nlc3MgYm90aCB2aWEgSTJDCj4g YW5kIEkyQy1vdmVyLUFVWC4gQSB0eXBlIDIgc291cmNlIGRldmljZSBtYXkgY2hvb3NlIHRvIGlt cGxlbWVudCBlaXRoZXIKPiBvZiB0aGVzZSBtZXRob2RzLiBJZiBhIHNvdXJjZSBkZXZpY2UgaW1w bGVtZW50cyB0aGUgSTJDLW92ZXItQVVYCj4gbWV0aG9kLCB0aGVuIHRoZSBkcml2ZXIgd2lsbCBv YnZpb3VzbHkgbmVlZCBzcGVjaWZpYyBzdXBwb3J0IGZvciBzdWNoCj4gYWRhcHRvcnMgc2luY2Ug dGhlIHBvcnQgaXMgZHJpdmVuIGxpa2UgYW4gSERNSSBwb3J0LCBidXQgRERDCj4gY29tbXVuaWNh dGlvbiBoYXBwZXMgb3ZlciB0aGUgQVVYIGNoYW5uZWwuCj4KPiBUaGlzIGhlbHBlciBzaG91bGQg YmUgZW5vdWdoIHRvIGlkZW50aWZ5IHRoZSBhZGFwdG9yIHR5cGUgKHNvbWUKPiB0eXBlIDEgRFZJ IGFkYXB0b3JzIG1heSBiZSBhIHNsaWdodCBleGNlcHRpb24pIGFuZCB0aGUgbWF4aW11bSBUTURT Cj4gY2xvY2sgbGltaXQuIEFub3RoZXIgZmVhdHVyZSB0aGF0IG1heSBiZSBhdmFpbGFibGUgaXMg Y29udHJvbCBvdmVyCj4gdGhlIFRNRFMgb3V0cHV0IGJ1ZmZlcnMgb24gdGhlIGFkYXB0b3IsIHBv c3NpYmx5IGFsbG93aW5nIGZvciBzb21lCj4gcG93ZXIgc2F2aW5nIHdoZW4gdGhlIFRNRFMgbGlu ayBpcyBkb3duLgo+Cj4gT3RoZXIgdXNlciBjb250cm9sbGFibGUgZmVhdHVyZXMgdGhhdCBtYXkg YmUgYXZhaWxhYmxlIGluIHRoZSBhZGFwdG9ycwo+IGFyZSBkb3duc3RyZWFtIGkyYyBidXMgc3Bl ZWQgY29udHJvbCB3aGVuIHVzaW5nIGkyYy1vdmVyLWF1eCwgYW5kCj4gc29tZSBjb250cm9sIG92 ZXIgdGhlIENFQyBwaW4uIEkgY2hvc2Ugbm90IHRvIHByb3ZpZGUgYW55IGhlbHBlcgo+IGZ1bmN0 aW9ucyBmb3IgdGhvc2Ugc2luY2UgSSBoYXZlIG5vIHVzZSBmb3IgdGhlbSBpbiBpOTE1IGF0IHRo aXMgdGltZS4KPiBUaGUgcmVzdCBvZiB0aGUgcmVnaXN0ZXJzIGluIHRoZSBhZGFwdG9yIGFyZSBt b3N0bHkganVzdCBpbmZvcm1hdGlvbiwKPiBlZy4gSUVFRSBPVUksIGhhcmR3YXJlIGFuZCBmaXJt d2FyZSByZXZpc2lvbiwgZXRjLgo+Cj4gdjI6IFBhc3MgYWRhcHRvciB0eXBlIHRvIGhlbHBlciBm dW5jdGlvbnMgdG8gZWFzZSBkcml2ZXIgaW1wbGVtZW50YXRpb24KPiAgICAgIEZpeCBhIGJ1bmNo IG9mIHR5cG9lcyAoUGF1bG8pCj4gICAgICBBZGQgRFJNX0RQX0RVQUxfTU9ERV9VTktOT1dOIGZv ciB0aGUgY2FzZSB3aGVyZSB3ZSBkb24ndCAoeWV0KSBrbm93Cj4gICAgICB0aGUgdHlwZSAoUGF1 bG8pCj4gICAgICBSZWplY3QgMHgwMCBhbmQgMHhmZiBEUF9EVUFMX01PREVfTUFYX1RNRFNfQ0xP Q0sgdmFsdWVzIChQYXVsbykKPiAgICAgIEFkanVzdCBkcm1fZHBfZHVhbF9tb2RlX2RldGVjdCgp IHR5cGUyIHZzLiB0eXBlMSBkZXRlY3Rpb24gdG8KPiAgICAgIGVhc2UgZnV0dXJlIExTUENPTiBl bmFibGluZwo+ICAgICAgUmVtb3ZlIHRoZSB1bnVzZWQgRFBfRFVBTF9NT0RFX0xBU1RfUkVTRVJW RUQgZGVmaW5lCj4KPiBDYzogc3RhYmxlQHZnZXIua2VybmVsLm9yZwo+IENjOiBUb3JlIEFuZGVy c29uIDx0b3JlQGZ1ZC5ubz4KPiBDYzogUGF1bG8gWmFub25pIDxwYXVsby5yLnphbm9uaUBpbnRl bC5jb20+Cj4gQ2M6IFNoYXNoYW5rIFNoYXJtYSA8c2hhc2hhbmsuc2hhcm1hQGludGVsLmNvbT4K PiBDYzogRGFuaWVsIFZldHRlciA8ZGFuaWVsLnZldHRlckBmZndsbC5jaD4KPiBTaWduZWQtb2Zm LWJ5OiBWaWxsZSBTeXJqw6Rsw6QgPHZpbGxlLnN5cmphbGFAbGludXguaW50ZWwuY29tPgo+IC0t LQo+ICAgZHJpdmVycy9ncHUvZHJtL01ha2VmaWxlICAgICAgICAgICAgICAgICAgfCAgIDIgKy0K PiAgIGRyaXZlcnMvZ3B1L2RybS9kcm1fZHBfZHVhbF9tb2RlX2hlbHBlci5jIHwgMzU2ICsrKysr KysrKysrKysrKysrKysrKysrKysrKysrKwo+ICAgaW5jbHVkZS9kcm0vZHJtX2RwX2R1YWxfbW9k ZV9oZWxwZXIuaCAgICAgfCAgODMgKysrKysrKwo+ICAgMyBmaWxlcyBjaGFuZ2VkLCA0NDAgaW5z ZXJ0aW9ucygrKSwgMSBkZWxldGlvbigtKQo+ICAgY3JlYXRlIG1vZGUgMTAwNjQ0IGRyaXZlcnMv Z3B1L2RybS9kcm1fZHBfZHVhbF9tb2RlX2hlbHBlci5jCj4gICBjcmVhdGUgbW9kZSAxMDA2NDQg aW5jbHVkZS9kcm0vZHJtX2RwX2R1YWxfbW9kZV9oZWxwZXIuaAo+Cj4gZGlmZiAtLWdpdCBhL2Ry aXZlcnMvZ3B1L2RybS9NYWtlZmlsZSBiL2RyaXZlcnMvZ3B1L2RybS9NYWtlZmlsZQo+IGluZGV4 IDFhMjZiNGViMWNlMC4uMjlmMmVlOWI5NTM0IDEwMDY0NAo+IC0tLSBhL2RyaXZlcnMvZ3B1L2Ry bS9NYWtlZmlsZQo+ICsrKyBiL2RyaXZlcnMvZ3B1L2RybS9NYWtlZmlsZQo+IEBAIC0yMyw3ICsy Myw3IEBAIGRybS0kKENPTkZJR19BR1ApICs9IGRybV9hZ3BzdXBwb3J0Lm8KPgo+ICAgZHJtX2tt c19oZWxwZXIteSA6PSBkcm1fY3J0Y19oZWxwZXIubyBkcm1fZHBfaGVscGVyLm8gZHJtX3Byb2Jl X2hlbHBlci5vIFwKPiAgIAkJZHJtX3BsYW5lX2hlbHBlci5vIGRybV9kcF9tc3RfdG9wb2xvZ3ku byBkcm1fYXRvbWljX2hlbHBlci5vIFwKPiAtCQlkcm1fa21zX2hlbHBlcl9jb21tb24ubwo+ICsJ CWRybV9rbXNfaGVscGVyX2NvbW1vbi5vIGRybV9kcF9kdWFsX21vZGVfaGVscGVyLm8KPgo+ICAg ZHJtX2ttc19oZWxwZXItJChDT05GSUdfRFJNX0xPQURfRURJRF9GSVJNV0FSRSkgKz0gZHJtX2Vk aWRfbG9hZC5vCj4gICBkcm1fa21zX2hlbHBlci0kKENPTkZJR19EUk1fRkJERVZfRU1VTEFUSU9O KSArPSBkcm1fZmJfaGVscGVyLm8KPiBkaWZmIC0tZ2l0IGEvZHJpdmVycy9ncHUvZHJtL2RybV9k cF9kdWFsX21vZGVfaGVscGVyLmMgYi9kcml2ZXJzL2dwdS9kcm0vZHJtX2RwX2R1YWxfbW9kZV9o ZWxwZXIuYwo+IG5ldyBmaWxlIG1vZGUgMTAwNjQ0Cj4gaW5kZXggMDAwMDAwMDAwMDAwLi45NDlj MGZiZWI1NDIKPiAtLS0gL2Rldi9udWxsCj4gKysrIGIvZHJpdmVycy9ncHUvZHJtL2RybV9kcF9k dWFsX21vZGVfaGVscGVyLmMKPiBAQCAtMCwwICsxLDM1NiBAQAo+ICsvKgo+ICsgKiBDb3B5cmln aHQgwqkgMjAxNiBJbnRlbCBDb3Jwb3JhdGlvbgo+ICsgKgo+ICsgKiBQZXJtaXNzaW9uIGlzIGhl cmVieSBncmFudGVkLCBmcmVlIG9mIGNoYXJnZSwgdG8gYW55IHBlcnNvbiBvYnRhaW5pbmcgYQo+ ICsgKiBjb3B5IG9mIHRoaXMgc29mdHdhcmUgYW5kIGFzc29jaWF0ZWQgZG9jdW1lbnRhdGlvbiBm aWxlcyAodGhlICJTb2Z0d2FyZSIpLAo+ICsgKiB0byBkZWFsIGluIHRoZSBTb2Z0d2FyZSB3aXRo b3V0IHJlc3RyaWN0aW9uLCBpbmNsdWRpbmcgd2l0aG91dCBsaW1pdGF0aW9uCj4gKyAqIHRoZSBy aWdodHMgdG8gdXNlLCBjb3B5LCBtb2RpZnksIG1lcmdlLCBwdWJsaXNoLCBkaXN0cmlidXRlLCBz dWJsaWNlbnNlLAo+ICsgKiBhbmQvb3Igc2VsbCBjb3BpZXMgb2YgdGhlIFNvZnR3YXJlLCBhbmQg dG8gcGVybWl0IHBlcnNvbnMgdG8gd2hvbSB0aGUKPiArICogU29mdHdhcmUgaXMgZnVybmlzaGVk IHRvIGRvIHNvLCBzdWJqZWN0IHRvIHRoZSBmb2xsb3dpbmcgY29uZGl0aW9uczoKPiArICoKPiAr ICogVGhlIGFib3ZlIGNvcHlyaWdodCBub3RpY2UgYW5kIHRoaXMgcGVybWlzc2lvbiBub3RpY2Ug c2hhbGwgYmUgaW5jbHVkZWQgaW4KPiArICogYWxsIGNvcGllcyBvciBzdWJzdGFudGlhbCBwb3J0 aW9ucyBvZiB0aGUgU29mdHdhcmUuCj4gKyAqCj4gKyAqIFRIRSBTT0ZUV0FSRSBJUyBQUk9WSURF RCAiQVMgSVMiLCBXSVRIT1VUIFdBUlJBTlRZIE9GIEFOWSBLSU5ELCBFWFBSRVNTIE9SCj4gKyAq IElNUExJRUQsIElOQ0xVRElORyBCVVQgTk9UIExJTUlURUQgVE8gVEhFIFdBUlJBTlRJRVMgT0Yg TUVSQ0hBTlRBQklMSVRZLAo+ICsgKiBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRSBB TkQgTk9OSU5GUklOR0VNRU5ULiAgSU4gTk8gRVZFTlQgU0hBTEwKPiArICogVEhFIENPUFlSSUdI VCBIT0xERVIoUykgT1IgQVVUSE9SKFMpIEJFIExJQUJMRSBGT1IgQU5ZIENMQUlNLCBEQU1BR0VT IE9SCj4gKyAqIE9USEVSIExJQUJJTElUWSwgV0hFVEhFUiBJTiBBTiBBQ1RJT04gT0YgQ09OVFJB Q1QsIFRPUlQgT1IgT1RIRVJXSVNFLAo+ICsgKiBBUklTSU5HIEZST00sIE9VVCBPRiBPUiBJTiBD T05ORUNUSU9OIFdJVEggVEhFIFNPRlRXQVJFIE9SIFRIRSBVU0UgT1IKPiArICogT1RIRVIgREVB TElOR1MgSU4gVEhFIFNPRlRXQVJFLgo+ICsgKi8KPiArCj4gKyNpbmNsdWRlIDxsaW51eC9lcnJu by5oPgo+ICsjaW5jbHVkZSA8bGludXgvZXhwb3J0Lmg+Cj4gKyNpbmNsdWRlIDxsaW51eC9pMmMu aD4KPiArI2luY2x1ZGUgPGxpbnV4L3NsYWIuaD4KPiArI2luY2x1ZGUgPGxpbnV4L3N0cmluZy5o Pgo+ICsjaW5jbHVkZSA8ZHJtL2RybV9kcF9kdWFsX21vZGVfaGVscGVyLmg+Cj4gKyNpbmNsdWRl IDxkcm0vZHJtUC5oPgo+ICsKPiArLyoqCj4gKyAqIERPQzogRFAgZHVhbCBtb2RlIChha2EuIERQ KyspIGFkYXB0b3IgaGVscGVycwo+ICsgKgo+ICsgKiBIZWxwZXIgZnVuY3Rpb25zIHRvIGRlYWwg d2l0aCBEUCBkdWFsIG1vZGUgYWRhcHRvcnMuCj4gKyAqCj4gKyAqIFR5cGUgMToKPiArICogQWRh cHRvciByZWdpc3RlcnMgKGlmIGFueSkgYW5kIHRoZSBzaW5rIEREQyBidXMgbWF5IGJlIGFjY2Vz c2VkIHZpYSBJMkMuCj4gKyAqCj4gKyAqIFR5cGUgMjoKPiArICogQWRhcHRvciByZWdpc3RlcnMg YW5kIHNpbmsgRERDIGJ1cyBjYW4gYmUgYWNjZXNzZWQgZWl0aGVyIHZpYSBJMkMgb3IKPiArICog STJDLW92ZXItQVVYLiBTb3VyY2UgZGV2aWNlcyBtYXkgY2hvb3NlIHRvIGltcGxlbWVudCBlaXRo ZXIgb2YgdGhlc2UKPiArICogYWNjZXNzIG1ldGhvZHMuCj4gKyAqLwo+ICsKPiArI2RlZmluZSBE UF9EVUFMX01PREVfU0xBVkVfQUREUkVTUyAweDQwCj4gKwo+ICsvKioKPiArICogZHJtX2RwX2R1 YWxfbW9kZV9yZWFkIC0gUmVhZCBmcm9tIHRoZSBEUCBkdWFsIG1vZGUgYWRhcHRvciByZWdpc3Rl cihzKQo+ICsgKiBhZGFwdGVyOiBJMkMgYWRhcHRlciBmb3IgdGhlIEREQyBidXMKPiArICogb2Zm c2V0OiByZWdpc3RlciBvZmZzZXQKPiArICogYnVmZmVyOiBidWZmZXIgZm9yIHJldHVybiBkYXRh Cj4gKyAqIHNpemU6IHNpem8gb2YgdGhlIGJ1ZmZlcgo+ICsgKgo+ICsgKiBSZWFkcyBAc2l6ZSBi eXRlcyBmcm9tIHRoZSBEUCBkdWFsIG1vZGUgYWRhcHRvciByZWdpc3RlcnMKPiArICogc3RhcnRp bmcgYXQgQG9mZnNldC4KPiArICoKPiArICogUmV0dXJuczoKPiArICogMCBvbiBzdWNjZXNzLCBu ZWdhdGl2ZSBlcnJvciBjb2RlIG9uIGZhaWx1cmUKPiArICovCj4gK3NzaXplX3QgZHJtX2RwX2R1 YWxfbW9kZV9yZWFkKHN0cnVjdCBpMmNfYWRhcHRlciAqYWRhcHRlciwKPiArCQkJICAgICAgdTgg b2Zmc2V0LCB2b2lkICpidWZmZXIsIHNpemVfdCBzaXplKQo+ICt7Cj4gKwlzdHJ1Y3QgaTJjX21z ZyBtc2dzW10gPSB7Cj4gKwkJewo+ICsJCQkuYWRkciA9IERQX0RVQUxfTU9ERV9TTEFWRV9BRERS RVNTLAo+ICsJCQkuZmxhZ3MgPSAwLAo+ICsJCQkubGVuID0gMSwKPiArCQkJLmJ1ZiA9ICZvZmZz ZXQsCj4gKwkJfSwKPiArCQl7Cj4gKwkJCS5hZGRyID0gRFBfRFVBTF9NT0RFX1NMQVZFX0FERFJF U1MsCj4gKwkJCS5mbGFncyA9IEkyQ19NX1JELAo+ICsJCQkubGVuID0gc2l6ZSwKPiArCQkJLmJ1 ZiA9IGJ1ZmZlciwKPiArCQl9LAo+ICsJfTsKPiArCWludCByZXQ7Cj4gKwo+ICsJcmV0ID0gaTJj X3RyYW5zZmVyKGFkYXB0ZXIsIG1zZ3MsIEFSUkFZX1NJWkUobXNncykpOwo+ICsJaWYgKHJldCA8 IDApCj4gKwkJcmV0dXJuIHJldDsKPiArCWlmIChyZXQgIT0gQVJSQVlfU0laRShtc2dzKSkKPiAr CQlyZXR1cm4gLUVQUk9UTzsKPiArCj4gKwlyZXR1cm4gMDsKPiArfQo+ICsKPiArLyoqCj4gKyAq IGRybV9kcF9kdWFsX21vZGVfd3JpdGUgLSBXcml0ZSB0byB0aGUgRFAgZHVhbCBtb2RlIGFkYXB0 b3IgcmVnaXN0ZXIocykKPiArICogYWRhcHRlcjogSTJDIGFkYXB0ZXIgZm9yIHRoZSBEREMgYnVz Cj4gKyAqIG9mZnNldDogcmVnaXN0ZXIgb2Zmc2V0Cj4gKyAqIGJ1ZmZlcjogYnVmZmVyIGZvciB3 cml0ZSBkYXRhCj4gKyAqIHNpemU6IHNpem8gb2YgdGhlIGJ1ZmZlcgo+ICsgKgo+ICsgKiBXcml0 ZXMgQHNpemUgYnl0ZXMgdG8gdGhlIERQIGR1YWwgbW9kZSBhZGFwdG9yIHJlZ2lzdGVycwo+ICsg KiBzdGFydGluZyBhdCBAb2Zmc2V0Lgo+ICsgKgo+ICsgKiBSZXR1cm5zOgo+ICsgKiAwIG9uIHN1 Y2Nlc3MsIG5lZ2F0aXZlIGVycm9yIGNvZGUgb24gZmFpbHVyZQo+ICsgKi8KPiArc3NpemVfdCBk cm1fZHBfZHVhbF9tb2RlX3dyaXRlKHN0cnVjdCBpMmNfYWRhcHRlciAqYWRhcHRlciwKPiArCQkJ ICAgICAgIHU4IG9mZnNldCwgY29uc3Qgdm9pZCAqYnVmZmVyLCBzaXplX3Qgc2l6ZSkKPiArewo+ ICsJc3RydWN0IGkyY19tc2cgbXNnID0gewo+ICsJCS5hZGRyID0gRFBfRFVBTF9NT0RFX1NMQVZF X0FERFJFU1MsCj4gKwkJLmZsYWdzID0gMCwKPiArCQkubGVuID0gMSArIHNpemUsCj4gKwkJLmJ1 ZiA9IE5VTEwsCj4gKwl9Owo+ICsJdm9pZCAqZGF0YTsKPiArCWludCByZXQ7Cj4gKwo+ICsJZGF0 YSA9IGttYWxsb2MobXNnLmxlbiwgR0ZQX1RFTVBPUkFSWSk7Cj4gKwlpZiAoIWRhdGEpCj4gKwkJ cmV0dXJuIC1FTk9NRU07Cj4gKwo+ICsJbXNnLmJ1ZiA9IGRhdGE7Cj4gKwo+ICsJbWVtY3B5KGRh dGEsICZvZmZzZXQsIDEpOwo+ICsJbWVtY3B5KGRhdGEgKyAxLCBidWZmZXIsIHNpemUpOwo+ICsK PiArCXJldCA9IGkyY190cmFuc2ZlcihhZGFwdGVyLCAmbXNnLCAxKTsKPiArCj4gKwlrZnJlZShk YXRhKTsKPiArCj4gKwlpZiAocmV0IDwgMCkKPiArCQlyZXR1cm4gcmV0Owo+ICsJaWYgKHJldCAh PSAxKQo+ICsJCXJldHVybiAtRVBST1RPOwo+ICsKPiArCXJldHVybiAwOwo+ICt9Cj4gK0VYUE9S VF9TWU1CT0woZHJtX2RwX2R1YWxfbW9kZV93cml0ZSk7Cj4gKwo+ICtzdGF0aWMgYm9vbCBpc19o ZG1pX2FkYXB0b3IoY29uc3QgY2hhciBoZG1pX2lkW0RQX0RVQUxfTU9ERV9IRE1JX0lEX0xFTl0p Cj4gK3sKPiArCXN0YXRpYyBjb25zdCBjaGFyIGRwX2R1YWxfbW9kZV9oZG1pX2lkW0RQX0RVQUxf TU9ERV9IRE1JX0lEX0xFTl0gPQo+ICsJCSJEUC1IRE1JIEFEQVBUT1JceDA0IjsKPiArCj4gKwly ZXR1cm4gbWVtY21wKGhkbWlfaWQsIGRwX2R1YWxfbW9kZV9oZG1pX2lkLAo+ICsJCSAgICAgIHNp emVvZihkcF9kdWFsX21vZGVfaGRtaV9pZCkpID09IDA7Cj4gK30KPiArCj4gK3N0YXRpYyBib29s IGlzX3R5cGUyX2FkYXB0b3IodWludDhfdCBhZGFwdG9yX2lkKQo+ICt7Cj4gKwlyZXR1cm4gYWRh cHRvcl9pZCA9PSAoRFBfRFVBTF9NT0RFX1RZUEVfVFlQRTIgfAo+ICsJCQkgICAgICBEUF9EVUFM X01PREVfUkVWX1RZUEUyKTsKPiArfQo+ICsKPiArLyoqCj4gKyAqIGRybV9kcF9kdWFsX21vZGVf ZGV0ZWN0IC0gSWRlbnRpZnkgdGhlIERQIGR1YWwgbW9kZSBhZGFwdG9yCj4gKyAqIGFkYXB0ZXI6 IEkyQyBhZGFwdGVyIGZvciB0aGUgRERDIGJ1cwo+ICsgKgo+ICsgKiBBdHRlbXB0IHRvIGlkZW50 aWZ5IHRoZSB0eXBlIG9mIHRoZSBEUCBkdWFsIG1vZGUgYWRhcHRvciB1c2VkLgo+ICsgKgo+ICsg KiBOb3RlIHRoYXQgd2hlbiB0aGUgYW5zd2VyIGlzIEBEUk1fRFBfRFVBTF9NT0RFX05PTkUgaXQn cyBub3QKPiArICogY2VydGFpbiB3aGV0aGVyIHdlJ3JlIGRlYWxpbmcgd2l0aCBhIG5hdGl2ZSBI RE1JIHBvcnQgb3IKPiArICogYSB0eXBlIDEgRFZJIGR1YWwgbW9kZSBhZGFwdG9yLiBUaGUgZHJp dmVyIHdpbGwgaGF2ZSB0byB1c2UKPiArICogc29tZSBvdGhlciBoYXJkd2FyZS9kcml2ZXIgc3Bl Y2lmaWMgbWVjaGFuaXNtIHRvIG1ha2UgdGhhdAo+ICsgKiBkaXN0aW5jdGlvbi4KPiArICoKPiAr ICogUmV0dXJuczoKPiArICogVGhlIHR5cGUgb2YgdGhlIERQIGR1YWwgbW9kZSBhZGFwdG9yIHVz ZWQKPiArICovCj4gK2VudW0gZHJtX2RwX2R1YWxfbW9kZV90eXBlIGRybV9kcF9kdWFsX21vZGVf ZGV0ZWN0KHN0cnVjdCBpMmNfYWRhcHRlciAqYWRhcHRlcikKPiArewo+ICsJY2hhciBoZG1pX2lk W0RQX0RVQUxfTU9ERV9IRE1JX0lEX0xFTl0gPSB7fTsKPiArCXVpbnQ4X3QgYWRhcHRvcl9pZCA9 IDB4MDA7Cj4gKwlzc2l6ZV90IHJldDsKPiArCj4gKwkvKgo+ICsJICogTGV0J3Mgc2VlIGlmIHRo ZSBhZGFwdG9yIGlzIHRoZXJlIHRoZSBieSByZWFkaW5nIHRoZQo+ICsJICogSERNSSBJRCByZWdp c3RlcnMuCj4gKwkgKgo+ICsJICogTm90ZSB0aGF0IHR5cGUgMSBEVkkgYWRhcHRvcnMgYXJlIG5v dCByZXF1aXJlZCB0byBpbXBsZW1udAo+ICsJICogYW55IHJlZ2lzdGVycywgYW5kIHRoYXQgcHJl c2VudHMgYSBwcm9ibGVtIGZvciBkZXRlY3Rpb24uCj4gKwkgKiBJZiB0aGUgaTJjIHRyYW5zZmVy IGlzIG5hY2tlZCwgd2UgbWF5IG9yIG1heSBub3QgYmUgZGVhbGluZwo+ICsJICogd2l0aCBhIHR5 cGUgMSBEVkkgYWRhcHRvci4gU29tZSBvdGhlciBtZWNoYW5pc20gb2YgZGV0ZWN0aW5nCj4gKwkg KiB0aGUgcHJlc2VuY2Ugb2YgdGhlIGFkYXB0b3IgaXMgcmVxdWlyZWQuIE9uZSB3YXkgd291bGQg YmUKPiArCSAqIHRvIGNoZWNrIHRoZSBzdGF0ZSBvZiB0aGUgQ09ORklHMSBwaW4sIEFub3RoZXIg bWV0aG9kIHdvdWxkCj4gKwkgKiBzaW1wbHkgcmVxdWlyZSB0aGUgZHJpdmVyIHRvIGtub3cgd2hl dGhlciB0aGUgcG9ydCBpcyBhIERQKysKPiArCSAqIHBvcnQgb3IgYSBuYXRpdmUgSERNSSBwb3J0 LiBCb3RoIG9mIHRoZXNlIG1ldGhvZHMgYXJlIGVudGlyZWx5Cj4gKwkgKiBoYXJkd2FyZS9kcml2 ZXIgc3BlY2lmaWMgc28gd2UgY2FuJ3QgZGVhbCB3aXRoIHRoZW0gaGVyZS4KPiArCSAqLwo+ICsJ cmV0ID0gZHJtX2RwX2R1YWxfbW9kZV9yZWFkKGFkYXB0ZXIsIERQX0RVQUxfTU9ERV9IRE1JX0lE LAo+ICsJCQkJICAgIGhkbWlfaWQsIHNpemVvZihoZG1pX2lkKSk7Cj4gKwlpZiAocmV0KQo+ICsJ CXJldHVybiBEUk1fRFBfRFVBTF9NT0RFX1VOS05PV047Cj4gKwo+ICsJLyoKPiArCSAqIFNpZ2gu IFNvbWUgKG1heWJlIGFsbD8pIHR5cGUgMSBhZGFwdG9ycyBhcmUgYnJva2VuIGFuZCBhY2sKPiAr CSAqIHRoZSBvZmZzZXQgYnV0IGlnbm9yZSBpdCwgYW5kIGluc3RlYWQgdGhleSBqdXN0IGFsd2F5 cyByZXR1cm4KPiArCSAqIGRhdGEgZnJvbSB0aGUgc3RhcnQgb2YgdGhlIEhETUkgSUQgYnVmZmVy LiBTbyBmb3IgYSBicm9rZW4KPiArCSAqIHR5cGUgMSBIRE1JIGFkYXB0b3IgYSBzaW5nbGUgYnl0 ZSByZWFkIHdpbGwgYWx3YXlzIGdpdmUgdXMKPiArCSAqIDB4NDQsIGFuZCBmb3IgYSB0eXBlIDEg RFZJIGFkYXB0b3IgaXQgc2hvdWxkIGdpdmUgMHgwMAo+ICsJICogKGFzc3VtaW5nIGl0IGltcGxl bWVudHMgYW55IHJlZ2lzdGVycykuIEZvcnR1bmF0ZWx5IG5laXRoZXIKPiArCSAqIG9mIHRob3Nl IHZhbHVlcyB3aWxsIG1hdGNoIHRoZSB0eXBlIDIgc2lnbmF0dXJlIG9mIHRoZQo+ICsJICogRFBf RFVBTF9NT0RFX0FEQVBUT1JfSUQgcmVnaXN0ZXIgc28gd2UgY2FuIHByb2NlZWQgd2l0aAo+ICsJ ICogdGhlIHR5cGUgMiBhZGFwdG9yIGRldGVjdGlvbiBzYWZlbHkgZXZlbiBpbiB0aGUgcHJlc2Vu Y2UKPiArCSAqIG9mIGJyb2tlbiB0eXBlIDEgYWRhcHRvcnMuCj4gKwkgKi8KPiArCXJldCA9IGRy bV9kcF9kdWFsX21vZGVfcmVhZChhZGFwdGVyLCBEUF9EVUFMX01PREVfQURBUFRPUl9JRCwKPiAr CQkJCSAgICAmYWRhcHRvcl9pZCwgc2l6ZW9mKGFkYXB0b3JfaWQpKTsKY2FuIHdlIHJlYWQgYWxs IDE2IGJ5dGVzIGluIGEgc2luZ2xlIHJlYWQsIGFuZCB0aGVuIHNwbGl0IHRoZSBjaGFyYWN0ZXJz IAppbnRvIGRvbmdsZV9zaWduYXR1cmUgYW5kIGFkYXB0b3JfaWQgPwo+ICsJaWYgKHJldCA9PSAw KSB7Cj4gKwkJaWYgKGlzX3R5cGUyX2FkYXB0b3IoYWRhcHRvcl9pZCkgJiYgaXNfaGRtaV9hZGFw dG9yKGhkbWlfaWQpKQo+ICsJCQlyZXR1cm4gRFJNX0RQX0RVQUxfTU9ERV9UWVBFMl9IRE1JOwo+ ICsJCWVsc2UgaWYgKGlzX3R5cGUyX2FkYXB0b3IoYWRhcHRvcl9pZCkpCj4gKwkJCXJldHVybiBE Uk1fRFBfRFVBTF9NT0RFX1RZUEUyX0RWSTsKCWNhbiB3ZSBzYXZlIG9uZSBpZiwgb3IgaXRzIHRv byBsYXRlIGZvciBtZSB0byB3b3JrIDopID8KCQlpc190eXBlMl9hZGFwdG9yKCkgewoJCQlpc19o ZG1pX2FkYXB0b3IoKQoJCQkJcmV0dXJuIHR5cGUyX2hkbWk7CgkJCWVsc2UKCQkJCXJldHVybiB0 eXBlMl9kdmkKCQl9Cj4gKwl9Cj4gKwo+ICsJaWYgKGlzX2hkbWlfYWRhcHRvcihoZG1pX2lkKSkK PiArCQlyZXR1cm4gRFJNX0RQX0RVQUxfTU9ERV9UWVBFMV9IRE1JOwo+ICsJZWxzZQo+ICsJCXJl dHVybiBEUk1fRFBfRFVBTF9NT0RFX1RZUEUxX0RWSTsKPiArfQo+ICtFWFBPUlRfU1lNQk9MKGRy bV9kcF9kdWFsX21vZGVfZGV0ZWN0KTsKPiArCj4gKy8qKgo+ICsgKiBkcm1fZHBfZHVhbF9tb2Rl X21heF90bWRzX2Nsb2NrIC0gTWF4IFRNRFMgY2xvY2sgZm9yIERQIGR1YWwgbW9kZSBhZGFwdG9y Cj4gKyAqIHR5cGU6IERQIGR1YWwgbW9kZSBhZGFwdG9yIHR5cGUKPiArICogYWRhcHRlcjogSTJD IGFkYXB0ZXIgZm9yIHRoZSBEREMgYnVzCj4gKyAqCj4gKyAqIERldGVybWluZSB0aGUgbWF4IFRN RFMgY2xvY2sgdGhlIGFkYXB0b3Igc3VwcG9ydHMgYmFzZWQgb24gdGhlCj4gKyAqIHR5cGUgb2Yg dGhlIGR1YWwgbW9kZSBhZGFwdG9yIGFuZCB0aGUgRFBfRFVBTF9NT0RFX01BWF9UTURTX0NMT0NL Cj4gKyAqIHJlZ2lzdGVyIChvbiB0eXBlMiBhZGFwdG9ycykuIEFzIHNvbWUgdHlwZSAxIGFkYXB0 b3JzIGhhdmUKPiArICogcHJvYmxlbXMgd2l0aCByZWdpc3RlcnMgKHNlZSBjb21tZW50cyBpbiBk cm1fZHBfZHVhbF9tb2RlX2RldGVjdCgpKQo+ICsgKiB3ZSBkb24ndCByZWFkIHRoZSByZWdpc3Rl ciBvbiB0aG9zZSwgaW5zdGVhZCB3ZSBzaW1wbHkgYXNzdW1lCj4gKyAqIGEgMTY1IE1IeiBsaW1p dCBiYXNlZCBvbiB0aGUgc3BlY2lmaWNhdGlvbi4KPiArICoKPiArICogUmV0dXJuczoKPiArICog TWF4aW11bSBzdXBwb3J0ZWQgVE1EUyBjbG9jayByYXRlIGZvciB0aGUgRFAgZHVhbCBtb2RlIGFk YXB0b3IgaW4ga0h6Lgo+ICsgKi8KPiAraW50IGRybV9kcF9kdWFsX21vZGVfbWF4X3RtZHNfY2xv Y2soZW51bSBkcm1fZHBfZHVhbF9tb2RlX3R5cGUgdHlwZSwKPiArCQkJCSAgICBzdHJ1Y3QgaTJj X2FkYXB0ZXIgKmFkYXB0ZXIpCj4gK3sKPiArCXVpbnQ4X3QgbWF4X3RtZHNfY2xvY2s7Cj4gKwlz c2l6ZV90IHJldDsKPiArCj4gKwkvKiBuYXRpdmUgSERNSSBzbyBubyBsaW1pdCAqLwo+ICsJaWYg KHR5cGUgPT0gRFJNX0RQX0RVQUxfTU9ERV9OT05FKQo+ICsJCXJldHVybiAwOwo+ICsKPiArCS8q Cj4gKwkgKiBUeXBlIDEgYWRhcHRvcnMgYXJlIGxpbWl0ZWQgdG8gMTY1TUh6Cj4gKwkgKiBUeXBl IDIgYWRhcHRvcnMgY2FuIHRlbGxzIHVzIHRoZWlyIGxpbWl0Cj4gKwkgKi8KPiArCWlmICh0eXBl IDwgRFJNX0RQX0RVQUxfTU9ERV9UWVBFMl9EVkkpCj4gKwkJcmV0dXJuIDE2NTAwMDsKPiArCj4g KwlyZXQgPSBkcm1fZHBfZHVhbF9tb2RlX3JlYWQoYWRhcHRlciwgRFBfRFVBTF9NT0RFX01BWF9U TURTX0NMT0NLLAo+ICsJCQkJICAgICZtYXhfdG1kc19jbG9jaywgc2l6ZW9mKG1heF90bWRzX2Ns b2NrKSk7Cj4gKwlpZiAocmV0IHx8IG1heF90bWRzX2Nsb2NrID09IDB4MDAgfHwgbWF4X3RtZHNf Y2xvY2sgPT0gMHhmZikKPiArCQlyZXR1cm4gMTY1MDAwOwo+ICsKPiArCXJldHVybiBtYXhfdG1k c19jbG9jayAqIDUwMDAgLyAyOwo+ICt9Cj4gK0VYUE9SVF9TWU1CT0woZHJtX2RwX2R1YWxfbW9k ZV9tYXhfdG1kc19jbG9jayk7Cj4gKwo+ICsvKioKPiArICogZHJtX2RwX2R1YWxfbW9kZV9nZXRf dG1kc19vdXRwdXQgLSBHZXQgdGhlIHN0YXRlIG9mIHRoZSBUTURTIG91dHB1dCBidWZmZXJzIGlu IHRoZSBEUCBkdWFsIG1vZGUgYWRhcHRvcgo+ICsgKiB0eXBlOiBEUCBkdWFsIG1vZGUgYWRhcHRv ciB0eXBlCj4gKyAqIGFkYXB0ZXI6IEkyQyBhZGFwdGVyIGZvciB0aGUgRERDIGJ1cwo+ICsgKiBl bmFibGVkOiBjdXJyZW50IHN0YXRlIG9mIHRoZSBUTURTIG91dHB1dCBidWZmZXJzCj4gKyAqCj4g KyAqIEdldCB0aGUgc3RhdGUgb2YgdGhlIFRNRFMgb3V0cHV0IGJ1ZmZlcnMgaW4gdGhlIGFkYXB0 b3IuIEZvcgo+ICsgKiB0eXBlMiBhZGFwdG9ycyB0aGlzIGlzIHF1ZXJpZWQgZnJvbSB0aGUgRFBf RFVBTF9NT0RFX1RNRFNfT0VOCj4gKyAqIHJlZ2lzdGVyLiBBcyBzb21lIHR5cGUgMSBhZGFwdG9y cyBoYXZlIHByb2JsZW1zIHdpdGggcmVnaXN0ZXJzCj4gKyAqIChzZWUgY29tbWVudHMgaW4gZHJt X2RwX2R1YWxfbW9kZV9kZXRlY3QoKSkgd2UgZG9uJ3QgcmVhZCB0aGUKPiArICogcmVnaXN0ZXIg b24gdGhvc2UsIGluc3RlYWQgd2Ugc2ltcGx5IGFzc3VtZSB0aGF0IHRoZSBidWZmZXJzCj4gKyAq IGFyZSBhbHdheXMgZW5hYmxlZC4KPiArICoKPiArICogUmV0dXJuczoKPiArICogMCBvbiBzdWNj ZXNzLCBuZWdhdGl2ZSBlcnJvciBjb2RlIG9uIGZhaWx1cmUKPiArICovCj4gK2ludCBkcm1fZHBf ZHVhbF9tb2RlX2dldF90bWRzX291dHB1dChlbnVtIGRybV9kcF9kdWFsX21vZGVfdHlwZSB0eXBl LAo+ICsJCQkJICAgICBzdHJ1Y3QgaTJjX2FkYXB0ZXIgKmFkYXB0ZXIsCj4gKwkJCQkgICAgIGJv b2wgKmVuYWJsZWQpCj4gK3sKPiArCXVpbnQ4X3QgdG1kc19vZW47Cj4gKwlzc2l6ZV90IHJldDsK PiArCj4gKwlpZiAodHlwZSA8IERSTV9EUF9EVUFMX01PREVfVFlQRTJfRFZJKSB7Cj4gKwkJKmVu YWJsZWQgPSB0cnVlOwo+ICsJCXJldHVybiAwOwo+ICsJfQo+ICsKPiArCXJldCA9IGRybV9kcF9k dWFsX21vZGVfcmVhZChhZGFwdGVyLCBEUF9EVUFMX01PREVfVE1EU19PRU4sCj4gKwkJCQkgICAg JnRtZHNfb2VuLCBzaXplb2YodG1kc19vZW4pKTsKPiArCWlmIChyZXQpCmRlYnVnIG1lc3NhZ2Ug aGVyZSBtaWdodCBoZWxwIGluIGZhaWx1cmUgY2FzZXMuCj4gKwkJcmV0dXJuIHJldDsKPiArCj4g KwkqZW5hYmxlZCA9ICEodG1kc19vZW4gJiBEUF9EVUFMX01PREVfVE1EU19ESVNBQkxFKTsKPiAr Cj4gKwlyZXR1cm4gMDsKPiArfQo+ICtFWFBPUlRfU1lNQk9MKGRybV9kcF9kdWFsX21vZGVfZ2V0 X3RtZHNfb3V0cHV0KTsKPiArCj4gKy8qKgo+ICsgKiBkcm1fZHBfZHVhbF9tb2RlX3NldF90bWRz X291dHB1dCAtIEVuYWJsZS9kaXNhYmxlIFRNRFMgb3V0cHV0IGJ1ZmZlcnMgaW4gdGhlIERQIGR1 YWwgbW9kZSBhZGFwdG9yCj4gKyAqIHR5cGU6IERQIGR1YWwgbW9kZSBhZGFwdG9yIHR5cGUKPiAr ICogYWRhcHRlcjogSTJDIGFkYXB0ZXIgZm9yIHRoZSBEREMgYnVzCj4gKyAqIGVuYWJsZTogZW5h YmxlIChhcyBvcHBvc2VkIHRvIGRpc2FibGUpIHRoZSBUTURTIG91dHB1dCBidWZmZXJzCj4gKyAq Cj4gKyAqIFNldCB0aGUgc3RhdGUgb2YgdGhlIFRNRFMgb3V0cHV0IGJ1ZmZlcnMgaW4gdGhlIGFk YXB0b3IuIEZvcgo+ICsgKiB0eXBlMiB0aGlzIGlzIHNldCB2aWEgdGhlIERQX0RVQUxfTU9ERV9U TURTX09FTiByZWdpc3Rlci4gQXMKPiArICogc29tZSB0eXBlIDEgYWRhcHRvcnMgaGF2ZSBwcm9i bGVtcyB3aXRoIHJlZ2lzdGVycyAoc2VlIGNvbW1lbnRzCj4gKyAqIGluIGRybV9kcF9kdWFsX21v ZGVfZGV0ZWN0KCkpIHdlIGF2b2lkIHRvdWNoaW5nIHRoZSByZWdpc3RlciwKPiArICogbWFraW5n IHRoaXMgZnVuY3Rpb24gYSBuby1vcCBvbiB0eXBlIDEgYWRhcHRvcnMuCj4gKyAqCj4gKyAqIFJl dHVybnM6Cj4gKyAqIDAgb24gc3VjY2VzcywgbmVnYXRpdmUgZXJyb3IgY29kZSBvbiBmYWlsdXJl Cj4gKyAqLwo+ICtpbnQgZHJtX2RwX2R1YWxfbW9kZV9zZXRfdG1kc19vdXRwdXQoZW51bSBkcm1f ZHBfZHVhbF9tb2RlX3R5cGUgdHlwZSwKPiArCQkJCSAgICAgc3RydWN0IGkyY19hZGFwdGVyICph ZGFwdGVyLCBib29sIGVuYWJsZSkKPiArewo+ICsJdWludDhfdCB0bWRzX29lbiA9IGVuYWJsZSA/ IDAgOiBEUF9EVUFMX01PREVfVE1EU19ESVNBQkxFOwo+ICsJc3NpemVfdCByZXQ7Cj4gKwo+ICsJ aWYgKHR5cGUgPCBEUk1fRFBfRFVBTF9NT0RFX1RZUEUyX0RWSSkKPiArCQlyZXR1cm4gMDsKPiAr Cj4gKwlyZXQgPSBkcm1fZHBfZHVhbF9tb2RlX3dyaXRlKGFkYXB0ZXIsIERQX0RVQUxfTU9ERV9U TURTX09FTiwKPiArCQkJCSAgICAgJnRtZHNfb2VuLCBzaXplb2YodG1kc19vZW4pKTsKPiArCWlm IChyZXQpCmRlYnVnIG1lc3NhZ2UgaGVyZSBtaWdodCBoZWxwIGluIGZhaWx1cmUgY2FzZXMuCj4g KwkJcmV0dXJuIHJldDsKPiArCj4gKwlyZXR1cm4gMDsKPiArfQo+ICtFWFBPUlRfU1lNQk9MKGRy bV9kcF9kdWFsX21vZGVfc2V0X3RtZHNfb3V0cHV0KTsKPiArCj4gKy8qKgo+ICsgKiBkcm1fZHBf Z2V0X2R1YWxfbW9kZV90eXBlX25hbWUgLSBHZXQgdGhlIG5hbWUgb2YgdGhlIERQIGR1YWwgbW9k ZSBhZGFwdG9yIHR5cGUgYXMgYSBzdHJpbmcKPiArICogdHlwZTogRFAgZHVhbCBtb2RlIGFkYXB0 b3IgdHlwZQo+ICsgKgo+ICsgKiBSZXR1cm5zOgo+ICsgKiBTdHJpbmcgcmVwcmVzZW50YXRpb24g b2YgdGhlIERQIGR1YWwgbW9kZSBhZGFwdG9yIHR5cGUKPiArICovCj4gK2NvbnN0IGNoYXIgKmRy bV9kcF9nZXRfZHVhbF9tb2RlX3R5cGVfbmFtZShlbnVtIGRybV9kcF9kdWFsX21vZGVfdHlwZSB0 eXBlKQo+ICt7Cj4gKwlzd2l0Y2ggKHR5cGUpIHsKPiArCWNhc2UgRFJNX0RQX0RVQUxfTU9ERV9O T05FOgo+ICsJCXJldHVybiAibm9uZSI7Cj4gKwljYXNlIERSTV9EUF9EVUFMX01PREVfVFlQRTFf RFZJOgo+ICsJCXJldHVybiAidHlwZSAxIERWSSI7Cj4gKwljYXNlIERSTV9EUF9EVUFMX01PREVf VFlQRTFfSERNSToKPiArCQlyZXR1cm4gInR5cGUgMSBIRE1JIjsKPiArCWNhc2UgRFJNX0RQX0RV QUxfTU9ERV9UWVBFMl9EVkk6Cj4gKwkJcmV0dXJuICJ0eXBlIDIgRFZJIjsKPiArCWNhc2UgRFJN X0RQX0RVQUxfTU9ERV9UWVBFMl9IRE1JOgo+ICsJCXJldHVybiAidHlwZSAyIEhETUkiOwo+ICsJ ZGVmYXVsdDoKPiArCQlXQVJOX09OKHR5cGUgIT0gRFJNX0RQX0RVQUxfTU9ERV9VTktOT1dOKTsK ZG8gd2UgbmVlZCBhIHdhcm5pbmcgaGVyZSwgb3IgYSBEUk1fRVJST1Igc2hvdWxkIHdvcmsgPwpJ IGFtIGFmcmFpZCB3ZSB3aWxsIHNob3cgYSBiYWNrLXRyYWNlIGZvciBhbGwgbm9uLWNvbXBsaWFu dCBhZGFwdGVycy4KPiArCQlyZXR1cm4gInVua25vd24iOwo+ICsJfQo+ICt9Cj4gK0VYUE9SVF9T WU1CT0woZHJtX2RwX2dldF9kdWFsX21vZGVfdHlwZV9uYW1lKTsKPiBkaWZmIC0tZ2l0IGEvaW5j bHVkZS9kcm0vZHJtX2RwX2R1YWxfbW9kZV9oZWxwZXIuaCBiL2luY2x1ZGUvZHJtL2RybV9kcF9k dWFsX21vZGVfaGVscGVyLmgKPiBuZXcgZmlsZSBtb2RlIDEwMDY0NAo+IGluZGV4IDAwMDAwMDAw MDAwMC4uYjQ2MDNiOWZjMDNkCj4gLS0tIC9kZXYvbnVsbAo+ICsrKyBiL2luY2x1ZGUvZHJtL2Ry bV9kcF9kdWFsX21vZGVfaGVscGVyLmgKPiBAQCAtMCwwICsxLDgzIEBACj4gKy8qCj4gKyAqIENv cHlyaWdodCDCqSAyMDE2IEludGVsIENvcnBvcmF0aW9uCj4gKyAqCj4gKyAqIFBlcm1pc3Npb24g aXMgaGVyZWJ5IGdyYW50ZWQsIGZyZWUgb2YgY2hhcmdlLCB0byBhbnkgcGVyc29uIG9idGFpbmlu ZyBhCj4gKyAqIGNvcHkgb2YgdGhpcyBzb2Z0d2FyZSBhbmQgYXNzb2NpYXRlZCBkb2N1bWVudGF0 aW9uIGZpbGVzICh0aGUgIlNvZnR3YXJlIiksCj4gKyAqIHRvIGRlYWwgaW4gdGhlIFNvZnR3YXJl IHdpdGhvdXQgcmVzdHJpY3Rpb24sIGluY2x1ZGluZyB3aXRob3V0IGxpbWl0YXRpb24KPiArICog dGhlIHJpZ2h0cyB0byB1c2UsIGNvcHksIG1vZGlmeSwgbWVyZ2UsIHB1Ymxpc2gsIGRpc3RyaWJ1 dGUsIHN1YmxpY2Vuc2UsCj4gKyAqIGFuZC9vciBzZWxsIGNvcGllcyBvZiB0aGUgU29mdHdhcmUs IGFuZCB0byBwZXJtaXQgcGVyc29ucyB0byB3aG9tIHRoZQo+ICsgKiBTb2Z0d2FyZSBpcyBmdXJu aXNoZWQgdG8gZG8gc28sIHN1YmplY3QgdG8gdGhlIGZvbGxvd2luZyBjb25kaXRpb25zOgo+ICsg Kgo+ICsgKiBUaGUgYWJvdmUgY29weXJpZ2h0IG5vdGljZSBhbmQgdGhpcyBwZXJtaXNzaW9uIG5v dGljZSBzaGFsbCBiZSBpbmNsdWRlZCBpbgo+ICsgKiBhbGwgY29waWVzIG9yIHN1YnN0YW50aWFs IHBvcnRpb25zIG9mIHRoZSBTb2Z0d2FyZS4KPiArICoKPiArICogVEhFIFNPRlRXQVJFIElTIFBS T1ZJREVEICJBUyBJUyIsIFdJVEhPVVQgV0FSUkFOVFkgT0YgQU5ZIEtJTkQsIEVYUFJFU1MgT1IK PiArICogSU1QTElFRCwgSU5DTFVESU5HIEJVVCBOT1QgTElNSVRFRCBUTyBUSEUgV0FSUkFOVElF UyBPRiBNRVJDSEFOVEFCSUxJVFksCj4gKyAqIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUiBQVVJQ T1NFIEFORCBOT05JTkZSSU5HRU1FTlQuICBJTiBOTyBFVkVOVCBTSEFMTAo+ICsgKiBUSEUgQ09Q WVJJR0hUIEhPTERFUihTKSBPUiBBVVRIT1IoUykgQkUgTElBQkxFIEZPUiBBTlkgQ0xBSU0sIERB TUFHRVMgT1IKPiArICogT1RIRVIgTElBQklMSVRZLCBXSEVUSEVSIElOIEFOIEFDVElPTiBPRiBD T05UUkFDVCwgVE9SVCBPUiBPVEhFUldJU0UsCj4gKyAqIEFSSVNJTkcgRlJPTSwgT1VUIE9GIE9S IElOIENPTk5FQ1RJT04gV0lUSCBUSEUgU09GVFdBUkUgT1IgVEhFIFVTRSBPUgo+ICsgKiBPVEhF UiBERUFMSU5HUyBJTiBUSEUgU09GVFdBUkUuCj4gKyAqLwo+ICsKPiArI2lmbmRlZiBEUk1fRFBf RFVBTF9NT0RFX0hFTFBFUl9ICj4gKyNkZWZpbmUgRFJNX0RQX0RVQUxfTU9ERV9IRUxQRVJfSAo+ ICsKPiArI2luY2x1ZGUgPGxpbnV4L3R5cGVzLmg+Cj4gKwo+ICsvKgo+ICsgKiBPcHRpb25hbCBm b3IgdHlwZSAxIERWSSBhZGFwdG9ycwo+ICsgKiBNYW5kYXRvcnkgZm9yIHR5cGUgMSBIRE1JIGFu ZCB0eXBlIDIgYWRhdG9ycwo+ICsgKi8KPiArI2RlZmluZSBEUF9EVUFMX01PREVfSERNSV9JRCAw eDAwIC8qIDAwLTBmICovCj4gKyNkZWZpbmUgIERQX0RVQUxfTU9ERV9IRE1JX0lEX0xFTiAxNgo+ ICsvKgo+ICsgKiBPcHRpb25hbCBmb3IgdHlwZSAxIGFkYXB0b3JzCj4gKyAqIE1hbmRhdG9yeSBm b3IgdHlwZSAyIGFkYXRvcnMKPiArICovCj4gKyNkZWZpbmUgRFBfRFVBTF9NT0RFX0FEQVBUT1Jf SUQgMHgxMAo+ICsjZGVmaW5lICBEUF9EVUFMX01PREVfUkVWX01BU0sgMHgwNwo+ICsjZGVmaW5l ICBEUF9EVUFMX01PREVfUkVWX1RZUEUyIDB4MDAKPiArI2RlZmluZSAgRFBfRFVBTF9NT0RFX1RZ UEVfTUFTSyAweGYwCj4gKyNkZWZpbmUgIERQX0RVQUxfTU9ERV9UWVBFX1RZUEUyIDB4YTAKPiAr I2RlZmluZSBEUF9EVUFMX01PREVfSUVFRV9PVUkgMHgxMSAvKiAxMS0xMyovCj4gKyNkZWZpbmUg IERQX0RVQUxfSUVFRV9PVUlfTEVOIDMKPiArI2RlZmluZSBEUF9EVUFMX0RFVklDRV9JRCAweDE0 IC8qIDE0LTE5ICovCj4gKyNkZWZpbmUgIERQX0RVQUxfREVWSUNFX0lEX0xFTiA2Cj4gKyNkZWZp bmUgRFBfRFVBTF9NT0RFX0hBUkRXQVJFX1JFViAweDFhCj4gKyNkZWZpbmUgRFBfRFVBTF9NT0RF X0ZJUk1XQVJFX01BSk9SX1JFViAweDFiCj4gKyNkZWZpbmUgRFBfRFVBTF9NT0RFX0ZJUk1XQVJF X01JTk9SX1JFViAweDFjCj4gKyNkZWZpbmUgRFBfRFVBTF9NT0RFX01BWF9UTURTX0NMT0NLIDB4 MWQKPiArI2RlZmluZSBEUF9EVUFMX01PREVfSTJDX1NQRUVEX0NBUCAweDFlCj4gKyNkZWZpbmUg RFBfRFVBTF9NT0RFX1RNRFNfT0VOIDB4MjAKPiArI2RlZmluZSAgRFBfRFVBTF9NT0RFX1RNRFNf RElTQUJMRSAweDAxCj4gKyNkZWZpbmUgRFBfRFVBTF9NT0RFX0hETUlfUElOX0NUUkwgMHgyMQo+ ICsjZGVmaW5lICBEUF9EVUFMX01PREVfQ0VDX0VOQUJMRSAweDAxCj4gKyNkZWZpbmUgRFBfRFVB TF9NT0RFX0kyQ19TUEVFRF9DVFJMIDB4MjIKPiArCj4gK3N0cnVjdCBpMmNfYWRhcHRlcjsKPiAr Cj4gK3NzaXplX3QgZHJtX2RwX2R1YWxfbW9kZV9yZWFkKHN0cnVjdCBpMmNfYWRhcHRlciAqYWRh cHRlciwKPiArCQkJICAgICAgdTggb2Zmc2V0LCB2b2lkICpidWZmZXIsIHNpemVfdCBzaXplKTsK PiArc3NpemVfdCBkcm1fZHBfZHVhbF9tb2RlX3dyaXRlKHN0cnVjdCBpMmNfYWRhcHRlciAqYWRh cHRlciwKPiArCQkJICAgICAgIHU4IG9mZnNldCwgY29uc3Qgdm9pZCAqYnVmZmVyLCBzaXplX3Qg c2l6ZSk7Cj4gKwo+ICtlbnVtIGRybV9kcF9kdWFsX21vZGVfdHlwZSB7Cj4gKwlEUk1fRFBfRFVB TF9NT0RFX05PTkUsCndoYXQgZG9lcyBkdWFsIG1vZGUgbm9uZSBpbmRpY2F0ZSAoY29uc2lkZXJp bmcgd2UgaGF2ZSBhbiB1bmtub3duIGNhc2UgCmJlbG93KSA/ClJlZ2FyZHMKU2hhc2hhbmsKPiAr CURSTV9EUF9EVUFMX01PREVfVU5LTk9XTiwKPiArCURSTV9EUF9EVUFMX01PREVfVFlQRTFfRFZJ LAo+ICsJRFJNX0RQX0RVQUxfTU9ERV9UWVBFMV9IRE1JLAo+ICsJRFJNX0RQX0RVQUxfTU9ERV9U WVBFMl9EVkksCj4gKwlEUk1fRFBfRFVBTF9NT0RFX1RZUEUyX0hETUksCj4gK307Cj4gKwo+ICtl bnVtIGRybV9kcF9kdWFsX21vZGVfdHlwZSBkcm1fZHBfZHVhbF9tb2RlX2RldGVjdChzdHJ1Y3Qg aTJjX2FkYXB0ZXIgKmFkYXB0ZXIpOwo+ICtpbnQgZHJtX2RwX2R1YWxfbW9kZV9tYXhfdG1kc19j bG9jayhlbnVtIGRybV9kcF9kdWFsX21vZGVfdHlwZSB0eXBlLAo+ICsJCQkJICAgIHN0cnVjdCBp MmNfYWRhcHRlciAqYWRhcHRlcik7Cj4gK2ludCBkcm1fZHBfZHVhbF9tb2RlX2dldF90bWRzX291 dHB1dChlbnVtIGRybV9kcF9kdWFsX21vZGVfdHlwZSB0eXBlLAo+ICsJCQkJICAgICBzdHJ1Y3Qg aTJjX2FkYXB0ZXIgKmFkYXB0ZXIsIGJvb2wgKmVuYWJsZWQpOwo+ICtpbnQgZHJtX2RwX2R1YWxf bW9kZV9zZXRfdG1kc19vdXRwdXQoZW51bSBkcm1fZHBfZHVhbF9tb2RlX3R5cGUgdHlwZSwKPiAr CQkJCSAgICAgc3RydWN0IGkyY19hZGFwdGVyICphZGFwdGVyLCBib29sIGVuYWJsZSk7Cj4gK2Nv bnN0IGNoYXIgKmRybV9kcF9nZXRfZHVhbF9tb2RlX3R5cGVfbmFtZShlbnVtIGRybV9kcF9kdWFs X21vZGVfdHlwZSB0eXBlKTsKPiArCj4gKyNlbmRpZgo+Cl9fX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fCmRyaS1kZXZlbCBtYWlsaW5nIGxpc3QKZHJpLWRldmVs QGxpc3RzLmZyZWVkZXNrdG9wLm9yZwpodHRwczovL2xpc3RzLmZyZWVkZXNrdG9wLm9yZy9tYWls bWFuL2xpc3RpbmZvL2RyaS1kZXZlbAo=