From mboxrd@z Thu Jan 1 00:00:00 1970 Received: from smtp.kernel.org (aws-us-west-2-korg-mail-alma10-1.taild15c8.ts.net [100.103.45.18]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id C96D647426A for ; Thu, 27 Aug 2026 13:26:53 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=100.103.45.18 ARC-Seal:i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1787837221; cv=none; b=pjD7Qzo7ohRYLKqDaHrdfEM4hvjqkMERfqpP/fGTlCLNMwgIkYO4VXPaBoc1i9EuMOBDfuBpbDjBB/2y2LbEu97HHy+DE4i8to0SpDz7J5kf+1N45jWzB6ZFklKzzp7ogSj+E28T+4wN93G4wt+Edx+F8NuIxKQi6rz2hflg8Kg= ARC-Message-Signature:i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1787837221; c=relaxed/simple; bh=3q+VUn9NaYhAmskuQyNSDF6I2dtW4rB/VBzFtDR+Pg4=; h=From:Subject:To:Cc:In-Reply-To:References:Content-Type:Date: Message-Id; b=qLyOMM8Nyk/j7u4CVC3jFQ0/1REuqnBZa2gV/vTtVuiMt0stOaa3zkERGk4PnYMrmJmBbwWADglSMw7Z+SFzJCXayLlLpJYOZLV0tOYe/f2ot2R09rzkJpmWXjJqfL4Kewl7QxhnoVtijZS7IiK3VGqK9pLJm4uyo3gCWV1Y208= ARC-Authentication-Results:i=1; smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b=nqp2Ey3H; arc=none smtp.client-ip=100.103.45.18 Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b="nqp2Ey3H" Received: by smtp.kernel.org (Postfix) with ESMTPSA id E137A1F000E9; Thu, 27 Aug 2026 13:26:50 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=kernel.org; s=k20260515; t=1787837211; bh=LtCVUJazwoQ7zB+f+5caGH5GuyOSXRHlJB94JFJRrRQ=; h=From:Subject:Reply-To:To:Cc:In-Reply-To:References:Date; b=nqp2Ey3H2N+AvEeoNj9EMhb2kkHtZGqfqohACnnpFuqxV+XKGXbi20J8uicY3A1Ns b+agFO8fnObcFSxBHfsLCdDYp+xIkwubLztB+Irh8nuAaPUlk6xnRz2LaI+XKfkO8R CZp8GnnsFl/AD6am9X6U6mDl/OuRSPgWTcWsAblYkzC5+iXG88JO+6V2Odv9kPqIZr bcXilQSJudPDhb3PPtOpME+mMfkWg6sorKGvGUAN259kGCdiXW1PW8N45ElGjPOJTe kTd6kQ6E9OqBkbw22OnjJgsk7IpYK/HIebyV5/OLBgW5ob0D6iqcLCvT70dwq4f4FB Yy0zBO/k4/RDw== From: sashiko-bot@kernel.org Subject: Re: [PATCH v3 3/3] phy: airoha: Add support for Airoha AN7583 USB PHY Reply-To: sashiko-reviews@lists.linux.dev To: "Christian Marangi" Cc: vkoul@kernel.org, olteanv@gmail.com, conor+dt@kernel.org, linux-phy@lists.infradead.org, robh@kernel.org, neil.armstrong@linaro.org, devicetree@vger.kernel.org In-Reply-To: <20260827131551.26725-4-ansuelsmth@gmail.com> References: <20260827131551.26725-1-ansuelsmth@gmail.com> <20260827131551.26725-4-ansuelsmth@gmail.com> Content-Type: text/plain; charset=utf-8 Content-Transfer-Encoding: quoted-printable Date: Thu, 27 Aug 2026 13:26:50 +0000 Message-Id: <20260827132650.E137A1F000E9@smtp.kernel.org> Precedence: bulk X-Mailing-List: devicetree@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: Thank you for your contribution! Sashiko AI review found 9 potential issue(= s) to consider: - [High] Off-by-one error in array bounds check allows out-of-bounds array = write. - [High] Incorrect device node is used to fetch the per-port serdes PHY. - [High] Missing per-port register offset in `an7583_usb_phy_u2_set_mode` c= auses cross-instance state corruption. - [Medium] Uninitialized variable `ret` is used as an error return code in = `an7583_usb_phy_parse_ports`. - [Medium] `fm_out` may be evaluated uninitialized if the regmap polling ma= cro fails. - [Medium] The PHY initialization error codes for USB3 and PCIe are silentl= y ignored. - [Medium] Nested acquisition of same-class PHY mutex triggers lockdep warn= ing. - [Medium] Excessive busy-waiting using mdelay() in PHY initialization loop= s. - [Low] Missing `fallthrough;` annotation in switch statements triggers imp= licit fallthrough warnings. -- commit e08eb2476fb864bd66e0895961c95bf0fbc89352 Author: Christian Marangi phy: airoha: Add support for Airoha AN7583 USB PHY Adds support for USB PHY on Airoha AN7583 SoC, supporting two U2 ports and one U3 port via a single USB PHY instance, plus a second instance for PCIe Gen2. > diff --git a/drivers/phy/airoha/phy-an7583-usb.c b/drivers/phy/airoha/phy= -an7583-usb.c > new file mode 100644 > index 0000000000000..33915c9f4a0de > --- /dev/null > +++ b/drivers/phy/airoha/phy-an7583-usb.c > @@ -280,18 +280,18 @@ static int an7583_usb_phy_u2_slew_rate_calibration(= struct phy *phy) > /* Timeout can happen and we will apply workaround at the end */ > regmap_read_poll_timeout(priv->regs[AIROHA_USB_PHY_PHY], > AIROHA_USB_PHY_FMMONR0 + offset, > fm_out, fm_out, AIROHA_USB_PHY_FREQDET_SLEEP, > AIROHA_USB_PHY_FREQDET_TIMEOUT); > =20 > /* Disable Frequency meter */ > regmap_clear_bits(priv->regs[AIROHA_USB_PHY_PHY], > AIROHA_USB_PHY_FMCR0 + offset, > AIROHA_USB_PHY_FREQDET_EN); > =20 > /* Disable Free run clock */ > regmap_clear_bits(priv->regs[AIROHA_USB_PHY_PHY], > AIROHA_USB_PHY_FMMONR1 + offset, > AIROHA_USB_PHY_FRCK_EN); > =20 > /* Disable HS TX SR calibration */ > regmap_clear_bits(priv->regs[AIROHA_USB_PHY_PHY], > AIROHA_USB_PHY_USBPHYACR5 + offset, > AIROHA_USB_PHY_USB20_HSTX_SRCAL_EN); > =20 > usleep_range(1000, 1500); > =20 > /* Frequency was not detected, use default SR calibration value */ > if (!fm_out) { [Severity: Medium] If the regmap read returns an error here in an7583_usb_phy_u2_slew_rate_calibration(), regmap_read_poll_timeout() will terminate early without initializing fm_out. Will this cause the subsequent check if (!fm_out) to evaluate garbage data? [ ... ] > @@ -340,11 +340,11 @@ static bool an7583_usb_phy_u3_kband_is_calibrated(s= truct an7583_usb_phy_priv *pr > /* Read KBand */ > regmap_clear_bits(priv->regs[AIROHA_USB_PHY_ANA], > AIROHA_USB_ANA_TDC_FT_CK_EN, > AIROHA_USB_ANA_PLL_DEBUG_SEL); > =20 > mdelay(5); [Severity: Medium] Can this delay in an7583_usb_phy_u3_kband_is_calibrated() cause excessive CPU stalling? It uses mdelay(5) twice per loop, and is called up to 50 times in an7583_usb_phy_u3_init(). Because mdelay spins the CPU instead of sleeping, this could freeze the CPU for up to 500ms during hardware initialization failures. Should this be using usleep_range() or msleep() instead? [ ... ] > @@ -1020,16 +1020,16 @@ static int an7583_usb_phy_init(struct phy *phy) > struct an7583_usb_phy_instance *instance =3D phy_get_drvdata(phy); > =20 > switch (instance->type) { > case PHY_TYPE_USB2: > an7583_usb_phy_u2_init(phy); > break; > case PHY_TYPE_USB3: > if (phy_get_mode(phy) =3D=3D PHY_MODE_ETHERNET) > return 0; > =20 > an7583_usb_phy_u3_init(phy); > break; > case PHY_TYPE_PCIE: > if (phy_get_mode(phy) =3D=3D PHY_MODE_ETHERNET) > return 0; > =20 > an7583_usb_phy_pcie_init(phy); [Severity: Medium] Both an7583_usb_phy_u3_init() and an7583_usb_phy_pcie_init() return an error code (-EINVAL) when calibration fails, but those values are ignored here. Does this falsely notify the PHY framework of a successful initialization? > break; > default: > return -EINVAL; > } [ ... ] > @@ -1176,8 +1176,8 @@ static int an7583_usb_phy_u2_set_mode(struct phy *p= hy, enum phy_mode mode) > case PHY_MODE_USB_HOST: > val |=3D AIROHA_USB_PHY_FORCE_IDDIG; > break; > case PHY_MODE_USB_OTG: > break; > default: > return 0; > } > =20 > regmap_update_bits(priv->regs[AIROHA_USB_PHY_PHY], AIROHA_USB_PHY_U2PHY= DTM1, [Severity: High] Does this code in an7583_usb_phy_u2_set_mode() write to the base register space of port 0 instead of the correct port? Unlike other functions (e.g., power_on or init), this directly accesses AIROHA_USB_PHY_U2PHYDTM1 without adding instance->offset. If mode configuration is applied to a secondary port, it seems like this will corru= pt port 0's state. > AIROHA_USB_PHY_FORCE_IDDIG | > AIROHA_USB_PHY_IDDIG, val); [ ... ] > @@ -1193,12 +1193,12 @@ static int an7583_usb_phy_u3_set_mode(struct phy = *phy, enum phy_mode mode, > int submode) > { > struct an7583_usb_phy_instance *instance =3D phy_get_drvdata(phy); > int ret; > =20 > switch (mode) { > case PHY_MODE_ETHERNET: > if (submode !=3D PHY_INTERFACE_MODE_SGMII && > submode !=3D PHY_INTERFACE_MODE_1000BASEX && > submode !=3D PHY_INTERFACE_MODE_2500BASEX) > return -EOPNOTSUPP; > case PHY_MODE_USB_DEVICE_SS: [Severity: Low] Is this an intentional fallthrough? If so, this switch block needs a fallthrough annotation to prevent compiler warnings. > break; > default: > return -EOPNOTSUPP; > } > =20 > ret =3D phy_set_mode_ext(instance->serdes_phy, mode, submode); [Severity: Medium] Will this nested call to phy_set_mode_ext() in an7583_usb_phy_u3_set_mode() trigger a lockdep warning? The core PHY framework invokes the driver's set_mode callback with the primary phy->mutex held. Calling phy_set_mode_ext() on the secondary PHY attempts to acquire the secondary PHY's mutex, which belongs to the same lock class. [ ... ] > @@ -1215,12 +1215,12 @@ static int an7583_usb_phy_pcie_set_mode(struct ph= y *phy, enum phy_mode mode, > int submode) > { > struct an7583_usb_phy_instance *instance =3D phy_get_drvdata(phy); > int ret; > =20 > switch (mode) { > case PHY_MODE_ETHERNET: > if (submode !=3D PHY_INTERFACE_MODE_SGMII && > submode !=3D PHY_INTERFACE_MODE_1000BASEX && > submode !=3D PHY_INTERFACE_MODE_2500BASEX) > return -EOPNOTSUPP; > case PHY_MODE_PCIE: [Severity: Low] Is this an intentional fallthrough? If so, this switch block needs a fallthrough annotation to prevent compiler warnings. > break; > default: > return -EOPNOTSUPP; > } > =20 > ret =3D phy_set_mode_ext(instance->serdes_phy, mode, submode); [Severity: Medium] Will this nested call to phy_set_mode_ext() in an7583_usb_phy_pcie_set_mode= () trigger a lockdep warning? The core PHY framework invokes the driver's set_mode callback with the primary phy->mutex held. Calling phy_set_mode_ext() on the secondary PHY attempts to acquire the secondary PHY's mutex, which belongs to the same lock class. [ ... ] > @@ -1297,29 +1297,29 @@ static int an7583_usb_phy_parse_ports(struct devi= ce *dev, > struct an7583_usb_phy_priv *priv, > int index, struct device_node *subnode) > { > const struct an7583_usb_phy_match_data *data; > struct an7583_usb_phy_instance *instance; > struct phy *phy; > int ret; > =20 > data =3D of_device_get_match_data(dev); > =20 > if (index > data->max_instance) [Severity: High] Should this bounds check use >=3D instead of > in an7583_usb_phy_parse_port= s()? The max_instance is the size of the array (3 for USB), so allowing index to equal max_instance will cause an out-of-bounds write when priv->phys[index] is assigned later. > return -EINVAL; > =20 > if (!of_device_is_available(subnode)) > return 0; > =20 > instance =3D devm_kzalloc(dev, sizeof(*instance), GFP_KERNEL); > if (!instance) > return -ENOMEM; > =20 > instance->serdes_phy =3D devm_phy_optional_get(dev, NULL); [Severity: High] Does devm_phy_optional_get() fetch the per-port serdes PHY from the parent device node rather than the specific port subnode? Because it uses dev and not subnode, it appears all subnodes will resolve to the exact same PHY instance, which would misclassify every port as PHY_TYPE_USB3 and break USB2 port initialization. Should this use devm_of_phy_optional_get(dev, subnode, NULL)? > if (IS_ERR(instance->serdes_phy)) > return dev_err_probe(dev, PTR_ERR(instance->serdes_phy), "error on ser= des phy for USB 3.0\n"); > =20 > if (!instance->serdes_phy && > !of_property_present(subnode, "airoha,usb2-monitor-clk-sel")) > return dev_err_probe(dev, ret, "monitor clock selection or serdes PHY = is mandatory for USB PHY\n"); [Severity: Medium] If the subnode lacks both the serdes_phy and the airoha,usb2-monitor-clk-sel properties, the error path returns the uninitialized ret variable. Can this return a garbage error code (or 0) leading to silent initialization failures? > =20 > if (instance->serdes_phy) { > instance->type =3D PHY_TYPE_USB3; > } else { > ret =3D of_property_read_u32(subnode, "airoha,usb2-monitor-clk-sel", > &instance->monclk_sel); > if (ret) > return dev_err_probe(dev, ret, "failed to parse Monitor clock selecti= on\n"); > =20 > ret =3D of_property_read_u32(subnode, "reg", > &instance->offset); > if (ret) > return dev_err_probe(dev, ret, "missing reg for U2 PHY\n"); > =20 > instance->type =3D PHY_TYPE_USB2; > } > =20 > phy =3D devm_phy_create(dev, subnode, &airoha_phy); > if (IS_ERR(phy)) > return dev_err_probe(dev, PTR_ERR(phy), "failed to create phy\n"); > =20 > priv->phys[index] =3D phy; [ ... ] > @@ -1341,12 +1341,12 @@ static int airoha_pcie_phy_parse_ports(struct dev= ice *dev, > struct an7583_usb_phy_priv *priv, > int index, struct device_node *subnode) > { > const struct an7583_usb_phy_match_data *data; > struct an7583_usb_phy_instance *instance; > struct phy *phy; > =20 > data =3D of_device_get_match_data(dev); > =20 > if (index > data->max_instance) [Severity: High] Should this bounds check use >=3D instead of > in airoha_pcie_phy_parse_por= ts()? The max_instance is the size of the array (1 for PCIe), so allowing index to equal max_instance will cause an out-of-bounds write when priv->phys[index] is assigned later. > return -EINVAL; > =20 > if (!of_device_is_available(subnode)) > return 0; --=20 Sashiko AI review =C2=B7 https://sashiko.dev/#/patchset/20260827131551.2672= 5-1-ansuelsmth@gmail.com?part=3D3 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 Received: from bombadil.infradead.org (bombadil.infradead.org [198.137.202.133]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.lore.kernel.org (Postfix) with ESMTPS id 48C2CC61DC2 for ; Thu, 27 Aug 2026 13:26:54 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; q=dns/txt; c=relaxed/relaxed; d=lists.infradead.org; s=bombadil.20210309; h=Sender: Content-Transfer-Encoding:Content-Type:MIME-Version:Reply-To:List-Subscribe: List-Help:List-Post:List-Archive:List-Unsubscribe:List-Id:Message-Id:Date: References:In-Reply-To:Cc:To:Subject:From:Content-ID:Content-Description: Resent-Date:Resent-From:Resent-Sender:Resent-To:Resent-Cc:Resent-Message-ID: List-Owner; bh=3NJEhM4Dui6qLQSxPtgmjPtJ4j7mT37Z4jHEsmCZNNY=; b=vd0bjj3RPfRZmk spxpZKhfFflTtNk9hiW6FTjvGKZuSTpgGb9doFNTvHO9eSRH5+6t6kxLpbeNFhI/yIxjf7xyrAURp J3JlRGlp3A/Mye8YJvEP58Vq2os3caGhyU6fb76wgw1EaBeJN4Oyje4wTtuNUshjFiAdhAlgBIDi4 OgL2P8rABWpzt53wGpwCXKrHOD9g0lE4tt7acWnleSbSaphpH11OwAphcqo7/Rd2WeCPfN0W+xDRt idrQoTPLeBfd9Pep6RxB96eNuN2mBuLX7EfiCmTdLxfKbcwGFAeF5BMeDYbkHjQkM3j5Oi0buBZ5r D52JnTSiGh5jVur33jCA==; Received: from localhost ([::1] helo=bombadil.infradead.org) by bombadil.infradead.org with esmtp (Exim 4.99.1 #2 (Red Hat Linux)) id 1wza85-000000043Ir-3DXg; Thu, 27 Aug 2026 13:26:53 +0000 Received: from sea.source.kernel.org ([172.234.252.31]) by bombadil.infradead.org with esmtps (Exim 4.99.1 #2 (Red Hat Linux)) id 1wza83-000000043Id-3ddN for linux-phy@lists.infradead.org; Thu, 27 Aug 2026 13:26:51 +0000 Received: from smtp.kernel.org (quasi.space.kernel.org [100.103.45.18]) by sea.source.kernel.org (Postfix) with ESMTP id 5069240A95; Thu, 27 Aug 2026 13:26:51 +0000 (UTC) Received: by smtp.kernel.org (Postfix) with ESMTPSA id E137A1F000E9; Thu, 27 Aug 2026 13:26:50 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=kernel.org; s=k20260515; t=1787837211; bh=LtCVUJazwoQ7zB+f+5caGH5GuyOSXRHlJB94JFJRrRQ=; h=From:Subject:Reply-To:To:Cc:In-Reply-To:References:Date; b=nqp2Ey3H2N+AvEeoNj9EMhb2kkHtZGqfqohACnnpFuqxV+XKGXbi20J8uicY3A1Ns b+agFO8fnObcFSxBHfsLCdDYp+xIkwubLztB+Irh8nuAaPUlk6xnRz2LaI+XKfkO8R CZp8GnnsFl/AD6am9X6U6mDl/OuRSPgWTcWsAblYkzC5+iXG88JO+6V2Odv9kPqIZr bcXilQSJudPDhb3PPtOpME+mMfkWg6sorKGvGUAN259kGCdiXW1PW8N45ElGjPOJTe kTd6kQ6E9OqBkbw22OnjJgsk7IpYK/HIebyV5/OLBgW5ob0D6iqcLCvT70dwq4f4FB Yy0zBO/k4/RDw== From: sashiko-bot@kernel.org Subject: Re: [PATCH v3 3/3] phy: airoha: Add support for Airoha AN7583 USB PHY To: "Christian Marangi" Cc: vkoul@kernel.org, olteanv@gmail.com, conor+dt@kernel.org, linux-phy@lists.infradead.org, robh@kernel.org, neil.armstrong@linaro.org, devicetree@vger.kernel.org In-Reply-To: <20260827131551.26725-4-ansuelsmth@gmail.com> References: <20260827131551.26725-1-ansuelsmth@gmail.com> <20260827131551.26725-4-ansuelsmth@gmail.com> Date: Thu, 27 Aug 2026 13:26:50 +0000 Message-Id: <20260827132650.E137A1F000E9@smtp.kernel.org> X-BeenThere: linux-phy@lists.infradead.org X-Mailman-Version: 2.1.34 Precedence: list List-Id: Linux Phy Mailing list List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Reply-To: sashiko-reviews@lists.linux.dev MIME-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Sender: "linux-phy" Errors-To: linux-phy-bounces+linux-phy=archiver.kernel.org@lists.infradead.org VGhhbmsgeW91IGZvciB5b3VyIGNvbnRyaWJ1dGlvbiEgU2FzaGlrbyBBSSByZXZpZXcgZm91bmQg OSBwb3RlbnRpYWwgaXNzdWUocykgdG8gY29uc2lkZXI6Ci0gW0hpZ2hdIE9mZi1ieS1vbmUgZXJy b3IgaW4gYXJyYXkgYm91bmRzIGNoZWNrIGFsbG93cyBvdXQtb2YtYm91bmRzIGFycmF5IHdyaXRl LgotIFtIaWdoXSBJbmNvcnJlY3QgZGV2aWNlIG5vZGUgaXMgdXNlZCB0byBmZXRjaCB0aGUgcGVy LXBvcnQgc2VyZGVzIFBIWS4KLSBbSGlnaF0gTWlzc2luZyBwZXItcG9ydCByZWdpc3RlciBvZmZz ZXQgaW4gYGFuNzU4M191c2JfcGh5X3UyX3NldF9tb2RlYCBjYXVzZXMgY3Jvc3MtaW5zdGFuY2Ug c3RhdGUgY29ycnVwdGlvbi4KLSBbTWVkaXVtXSBVbmluaXRpYWxpemVkIHZhcmlhYmxlIGByZXRg IGlzIHVzZWQgYXMgYW4gZXJyb3IgcmV0dXJuIGNvZGUgaW4gYGFuNzU4M191c2JfcGh5X3BhcnNl X3BvcnRzYC4KLSBbTWVkaXVtXSBgZm1fb3V0YCBtYXkgYmUgZXZhbHVhdGVkIHVuaW5pdGlhbGl6 ZWQgaWYgdGhlIHJlZ21hcCBwb2xsaW5nIG1hY3JvIGZhaWxzLgotIFtNZWRpdW1dIFRoZSBQSFkg aW5pdGlhbGl6YXRpb24gZXJyb3IgY29kZXMgZm9yIFVTQjMgYW5kIFBDSWUgYXJlIHNpbGVudGx5 IGlnbm9yZWQuCi0gW01lZGl1bV0gTmVzdGVkIGFjcXVpc2l0aW9uIG9mIHNhbWUtY2xhc3MgUEhZ IG11dGV4IHRyaWdnZXJzIGxvY2tkZXAgd2FybmluZy4KLSBbTWVkaXVtXSBFeGNlc3NpdmUgYnVz eS13YWl0aW5nIHVzaW5nIG1kZWxheSgpIGluIFBIWSBpbml0aWFsaXphdGlvbiBsb29wcy4KLSBb TG93XSBNaXNzaW5nIGBmYWxsdGhyb3VnaDtgIGFubm90YXRpb24gaW4gc3dpdGNoIHN0YXRlbWVu dHMgdHJpZ2dlcnMgaW1wbGljaXQgZmFsbHRocm91Z2ggd2FybmluZ3MuCi0tCgpjb21taXQgZTA4 ZWIyNDc2ZmI4NjRiZDY2ZTA4OTU5NjFjOTViZjBmYmM4OTM1MgpBdXRob3I6IENocmlzdGlhbiBN YXJhbmdpIDxhbnN1ZWxzbXRoQGdtYWlsLmNvbT4KCnBoeTogYWlyb2hhOiBBZGQgc3VwcG9ydCBm b3IgQWlyb2hhIEFONzU4MyBVU0IgUEhZCgpBZGRzIHN1cHBvcnQgZm9yIFVTQiBQSFkgb24gQWly b2hhIEFONzU4MyBTb0MsIHN1cHBvcnRpbmcgdHdvIFUyIHBvcnRzIGFuZApvbmUgVTMgcG9ydCB2 aWEgYSBzaW5nbGUgVVNCIFBIWSBpbnN0YW5jZSwgcGx1cyBhIHNlY29uZCBpbnN0YW5jZSBmb3IK UENJZSBHZW4yLgoKPiBkaWZmIC0tZ2l0IGEvZHJpdmVycy9waHkvYWlyb2hhL3BoeS1hbjc1ODMt dXNiLmMgYi9kcml2ZXJzL3BoeS9haXJvaGEvcGh5LWFuNzU4My11c2IuYwo+IG5ldyBmaWxlIG1v ZGUgMTAwNjQ0Cj4gaW5kZXggMDAwMDAwMDAwMDAwMC4uMzM5MTVjOWY0YTBkZQo+IC0tLSAvZGV2 L251bGwKPiArKysgYi9kcml2ZXJzL3BoeS9haXJvaGEvcGh5LWFuNzU4My11c2IuYwo+IEBAIC0y ODAsMTggKzI4MCwxOCBAQCBzdGF0aWMgaW50IGFuNzU4M191c2JfcGh5X3UyX3NsZXdfcmF0ZV9j YWxpYnJhdGlvbihzdHJ1Y3QgcGh5ICpwaHkpCj4gIAkvKiBUaW1lb3V0IGNhbiBoYXBwZW4gYW5k IHdlIHdpbGwgYXBwbHkgd29ya2Fyb3VuZCBhdCB0aGUgZW5kICovCj4gIAlyZWdtYXBfcmVhZF9w b2xsX3RpbWVvdXQocHJpdi0+cmVnc1tBSVJPSEFfVVNCX1BIWV9QSFldLAo+ICAJCQkJIEFJUk9I QV9VU0JfUEhZX0ZNTU9OUjAgKyBvZmZzZXQsCj4gIAkJCQkgZm1fb3V0LCBmbV9vdXQsIEFJUk9I QV9VU0JfUEhZX0ZSRVFERVRfU0xFRVAsCj4gIAkJCQkgQUlST0hBX1VTQl9QSFlfRlJFUURFVF9U SU1FT1VUKTsKPiAgCj4gIAkvKiBEaXNhYmxlIEZyZXF1ZW5jeSBtZXRlciAqLwo+ICAJcmVnbWFw X2NsZWFyX2JpdHMocHJpdi0+cmVnc1tBSVJPSEFfVVNCX1BIWV9QSFldLAo+ICAJCQkgIEFJUk9I QV9VU0JfUEhZX0ZNQ1IwICsgb2Zmc2V0LAo+ICAJCQkgIEFJUk9IQV9VU0JfUEhZX0ZSRVFERVRf RU4pOwo+ICAKPiAgCS8qIERpc2FibGUgRnJlZSBydW4gY2xvY2sgKi8KPiAgCXJlZ21hcF9jbGVh cl9iaXRzKHByaXYtPnJlZ3NbQUlST0hBX1VTQl9QSFlfUEhZXSwKPiAgCQkJICBBSVJPSEFfVVNC X1BIWV9GTU1PTlIxICsgb2Zmc2V0LAo+ICAJCQkgIEFJUk9IQV9VU0JfUEhZX0ZSQ0tfRU4pOwo+ ICAKPiAgCS8qIERpc2FibGUgSFMgVFggU1IgY2FsaWJyYXRpb24gKi8KPiAgCXJlZ21hcF9jbGVh cl9iaXRzKHByaXYtPnJlZ3NbQUlST0hBX1VTQl9QSFlfUEhZXSwKPiAgCQkJICBBSVJPSEFfVVNC X1BIWV9VU0JQSFlBQ1I1ICsgb2Zmc2V0LAo+ICAJCQkgIEFJUk9IQV9VU0JfUEhZX1VTQjIwX0hT VFhfU1JDQUxfRU4pOwo+ICAKPiAgCXVzbGVlcF9yYW5nZSgxMDAwLCAxNTAwKTsKPiAgCj4gIAkv KiBGcmVxdWVuY3kgd2FzIG5vdCBkZXRlY3RlZCwgdXNlIGRlZmF1bHQgU1IgY2FsaWJyYXRpb24g dmFsdWUgKi8KPiAgCWlmICghZm1fb3V0KSB7CgpbU2V2ZXJpdHk6IE1lZGl1bV0KSWYgdGhlIHJl Z21hcCByZWFkIHJldHVybnMgYW4gZXJyb3IgaGVyZSBpbgphbjc1ODNfdXNiX3BoeV91Ml9zbGV3 X3JhdGVfY2FsaWJyYXRpb24oKSwgcmVnbWFwX3JlYWRfcG9sbF90aW1lb3V0KCkKd2lsbCB0ZXJt aW5hdGUgZWFybHkgd2l0aG91dCBpbml0aWFsaXppbmcgZm1fb3V0LgoKV2lsbCB0aGlzIGNhdXNl IHRoZSBzdWJzZXF1ZW50IGNoZWNrIGlmICghZm1fb3V0KSB0byBldmFsdWF0ZSBnYXJiYWdlIGRh dGE/CgpbIC4uLiBdCgo+IEBAIC0zNDAsMTEgKzM0MCwxMSBAQCBzdGF0aWMgYm9vbCBhbjc1ODNf dXNiX3BoeV91M19rYmFuZF9pc19jYWxpYnJhdGVkKHN0cnVjdCBhbjc1ODNfdXNiX3BoeV9wcml2 ICpwcgo+ICAJLyogUmVhZCBLQmFuZCAqLwo+ICAJcmVnbWFwX2NsZWFyX2JpdHMocHJpdi0+cmVn c1tBSVJPSEFfVVNCX1BIWV9BTkFdLAo+ICAJCQkgIEFJUk9IQV9VU0JfQU5BX1REQ19GVF9DS19F TiwKPiAgCQkJICBBSVJPSEFfVVNCX0FOQV9QTExfREVCVUdfU0VMKTsKPiAgCj4gIAltZGVsYXko NSk7CgpbU2V2ZXJpdHk6IE1lZGl1bV0KQ2FuIHRoaXMgZGVsYXkgaW4gYW43NTgzX3VzYl9waHlf dTNfa2JhbmRfaXNfY2FsaWJyYXRlZCgpIGNhdXNlIGV4Y2Vzc2l2ZQpDUFUgc3RhbGxpbmc/CgpJ dCB1c2VzIG1kZWxheSg1KSB0d2ljZSBwZXIgbG9vcCwgYW5kIGlzIGNhbGxlZCB1cCB0byA1MCB0 aW1lcyBpbgphbjc1ODNfdXNiX3BoeV91M19pbml0KCkuIEJlY2F1c2UgbWRlbGF5IHNwaW5zIHRo ZSBDUFUgaW5zdGVhZCBvZiBzbGVlcGluZywKdGhpcyBjb3VsZCBmcmVlemUgdGhlIENQVSBmb3Ig dXAgdG8gNTAwbXMgZHVyaW5nIGhhcmR3YXJlIGluaXRpYWxpemF0aW9uCmZhaWx1cmVzLgoKU2hv dWxkIHRoaXMgYmUgdXNpbmcgdXNsZWVwX3JhbmdlKCkgb3IgbXNsZWVwKCkgaW5zdGVhZD8KClsg Li4uIF0KCj4gQEAgLTEwMjAsMTYgKzEwMjAsMTYgQEAgc3RhdGljIGludCBhbjc1ODNfdXNiX3Bo eV9pbml0KHN0cnVjdCBwaHkgKnBoeSkKPiAgCXN0cnVjdCBhbjc1ODNfdXNiX3BoeV9pbnN0YW5j ZSAqaW5zdGFuY2UgPSBwaHlfZ2V0X2RydmRhdGEocGh5KTsKPiAgCj4gIAlzd2l0Y2ggKGluc3Rh bmNlLT50eXBlKSB7Cj4gIAljYXNlIFBIWV9UWVBFX1VTQjI6Cj4gIAkJYW43NTgzX3VzYl9waHlf dTJfaW5pdChwaHkpOwo+ICAJCWJyZWFrOwo+ICAJY2FzZSBQSFlfVFlQRV9VU0IzOgo+ICAJCWlm IChwaHlfZ2V0X21vZGUocGh5KSA9PSBQSFlfTU9ERV9FVEhFUk5FVCkKPiAgCQkJcmV0dXJuIDA7 Cj4gIAo+ICAJCWFuNzU4M191c2JfcGh5X3UzX2luaXQocGh5KTsKPiAgCQlicmVhazsKPiAgCWNh c2UgUEhZX1RZUEVfUENJRToKPiAgCQlpZiAocGh5X2dldF9tb2RlKHBoeSkgPT0gUEhZX01PREVf RVRIRVJORVQpCj4gIAkJCXJldHVybiAwOwo+ICAKPiAgCQlhbjc1ODNfdXNiX3BoeV9wY2llX2lu aXQocGh5KTsKCltTZXZlcml0eTogTWVkaXVtXQpCb3RoIGFuNzU4M191c2JfcGh5X3UzX2luaXQo KSBhbmQgYW43NTgzX3VzYl9waHlfcGNpZV9pbml0KCkgcmV0dXJuIGFuCmVycm9yIGNvZGUgKC1F SU5WQUwpIHdoZW4gY2FsaWJyYXRpb24gZmFpbHMsIGJ1dCB0aG9zZSB2YWx1ZXMgYXJlIGlnbm9y ZWQKaGVyZS4KCkRvZXMgdGhpcyBmYWxzZWx5IG5vdGlmeSB0aGUgUEhZIGZyYW1ld29yayBvZiBh IHN1Y2Nlc3NmdWwgaW5pdGlhbGl6YXRpb24/Cgo+ICAJCWJyZWFrOwo+ICAJZGVmYXVsdDoKPiAg CQlyZXR1cm4gLUVJTlZBTDsKPiAgCX0KClsgLi4uIF0KCj4gQEAgLTExNzYsOCArMTE3Niw4IEBA IHN0YXRpYyBpbnQgYW43NTgzX3VzYl9waHlfdTJfc2V0X21vZGUoc3RydWN0IHBoeSAqcGh5LCBl bnVtIHBoeV9tb2RlIG1vZGUpCj4gIAljYXNlIFBIWV9NT0RFX1VTQl9IT1NUOgo+ICAJCXZhbCB8 PSBBSVJPSEFfVVNCX1BIWV9GT1JDRV9JRERJRzsKPiAgCQlicmVhazsKPiAgCWNhc2UgUEhZX01P REVfVVNCX09URzoKPiAgCQlicmVhazsKPiAgCWRlZmF1bHQ6Cj4gIAkJcmV0dXJuIDA7Cj4gIAl9 Cj4gIAo+ICAJcmVnbWFwX3VwZGF0ZV9iaXRzKHByaXYtPnJlZ3NbQUlST0hBX1VTQl9QSFlfUEhZ XSwgQUlST0hBX1VTQl9QSFlfVTJQSFlEVE0xLAoKW1NldmVyaXR5OiBIaWdoXQpEb2VzIHRoaXMg Y29kZSBpbiBhbjc1ODNfdXNiX3BoeV91Ml9zZXRfbW9kZSgpIHdyaXRlIHRvIHRoZSBiYXNlIHJl Z2lzdGVyCnNwYWNlIG9mIHBvcnQgMCBpbnN0ZWFkIG9mIHRoZSBjb3JyZWN0IHBvcnQ/CgpVbmxp a2Ugb3RoZXIgZnVuY3Rpb25zIChlLmcuLCBwb3dlcl9vbiBvciBpbml0KSwgdGhpcyBkaXJlY3Rs eSBhY2Nlc3NlcwpBSVJPSEFfVVNCX1BIWV9VMlBIWURUTTEgd2l0aG91dCBhZGRpbmcgaW5zdGFu Y2UtPm9mZnNldC4gSWYgbW9kZQpjb25maWd1cmF0aW9uIGlzIGFwcGxpZWQgdG8gYSBzZWNvbmRh cnkgcG9ydCwgaXQgc2VlbXMgbGlrZSB0aGlzIHdpbGwgY29ycnVwdApwb3J0IDAncyBzdGF0ZS4K Cj4gIAkJCSAgIEFJUk9IQV9VU0JfUEhZX0ZPUkNFX0lERElHIHwKPiAgCQkJICAgQUlST0hBX1VT Ql9QSFlfSURESUcsIHZhbCk7CgpbIC4uLiBdCgo+IEBAIC0xMTkzLDEyICsxMTkzLDEyIEBAIHN0 YXRpYyBpbnQgYW43NTgzX3VzYl9waHlfdTNfc2V0X21vZGUoc3RydWN0IHBoeSAqcGh5LCBlbnVt IHBoeV9tb2RlIG1vZGUsCj4gIAkJCQkgICAgICBpbnQgc3VibW9kZSkKPiAgewo+ICAJc3RydWN0 IGFuNzU4M191c2JfcGh5X2luc3RhbmNlICppbnN0YW5jZSA9IHBoeV9nZXRfZHJ2ZGF0YShwaHkp Owo+ICAJaW50IHJldDsKPiAgCj4gIAlzd2l0Y2ggKG1vZGUpIHsKPiAgCWNhc2UgUEhZX01PREVf RVRIRVJORVQ6Cj4gIAkJaWYgKHN1Ym1vZGUgIT0gUEhZX0lOVEVSRkFDRV9NT0RFX1NHTUlJICYm Cj4gIAkJICAgIHN1Ym1vZGUgIT0gUEhZX0lOVEVSRkFDRV9NT0RFXzEwMDBCQVNFWCAmJgo+ICAJ CSAgICBzdWJtb2RlICE9IFBIWV9JTlRFUkZBQ0VfTU9ERV8yNTAwQkFTRVgpCj4gIAkJCXJldHVy biAtRU9QTk9UU1VQUDsKPiAgCWNhc2UgUEhZX01PREVfVVNCX0RFVklDRV9TUzoKCltTZXZlcml0 eTogTG93XQpJcyB0aGlzIGFuIGludGVudGlvbmFsIGZhbGx0aHJvdWdoPwoKSWYgc28sIHRoaXMg c3dpdGNoIGJsb2NrIG5lZWRzIGEgZmFsbHRocm91Z2ggYW5ub3RhdGlvbiB0byBwcmV2ZW50IGNv bXBpbGVyCndhcm5pbmdzLgoKPiAgCQlicmVhazsKPiAgCWRlZmF1bHQ6Cj4gIAkJcmV0dXJuIC1F T1BOT1RTVVBQOwo+ICAJfQo+ICAKPiAgCXJldCA9IHBoeV9zZXRfbW9kZV9leHQoaW5zdGFuY2Ut PnNlcmRlc19waHksIG1vZGUsIHN1Ym1vZGUpOwoKW1NldmVyaXR5OiBNZWRpdW1dCldpbGwgdGhp cyBuZXN0ZWQgY2FsbCB0byBwaHlfc2V0X21vZGVfZXh0KCkgaW4gYW43NTgzX3VzYl9waHlfdTNf c2V0X21vZGUoKQp0cmlnZ2VyIGEgbG9ja2RlcCB3YXJuaW5nPwoKVGhlIGNvcmUgUEhZIGZyYW1l d29yayBpbnZva2VzIHRoZSBkcml2ZXIncyBzZXRfbW9kZSBjYWxsYmFjayB3aXRoIHRoZQpwcmlt YXJ5IHBoeS0+bXV0ZXggaGVsZC4gQ2FsbGluZyBwaHlfc2V0X21vZGVfZXh0KCkgb24gdGhlIHNl Y29uZGFyeSBQSFkKYXR0ZW1wdHMgdG8gYWNxdWlyZSB0aGUgc2Vjb25kYXJ5IFBIWSdzIG11dGV4 LCB3aGljaCBiZWxvbmdzIHRvIHRoZSBzYW1lCmxvY2sgY2xhc3MuCgpbIC4uLiBdCgo+IEBAIC0x MjE1LDEyICsxMjE1LDEyIEBAIHN0YXRpYyBpbnQgYW43NTgzX3VzYl9waHlfcGNpZV9zZXRfbW9k ZShzdHJ1Y3QgcGh5ICpwaHksIGVudW0gcGh5X21vZGUgbW9kZSwKPiAgCQkJCQlpbnQgc3VibW9k ZSkKPiAgewo+ICAJc3RydWN0IGFuNzU4M191c2JfcGh5X2luc3RhbmNlICppbnN0YW5jZSA9IHBo eV9nZXRfZHJ2ZGF0YShwaHkpOwo+ICAJaW50IHJldDsKPiAgCj4gIAlzd2l0Y2ggKG1vZGUpIHsK PiAgCWNhc2UgUEhZX01PREVfRVRIRVJORVQ6Cj4gIAkJaWYgKHN1Ym1vZGUgIT0gUEhZX0lOVEVS RkFDRV9NT0RFX1NHTUlJICYmCj4gIAkJICAgIHN1Ym1vZGUgIT0gUEhZX0lOVEVSRkFDRV9NT0RF XzEwMDBCQVNFWCAmJgo+ICAJCSAgICBzdWJtb2RlICE9IFBIWV9JTlRFUkZBQ0VfTU9ERV8yNTAw QkFTRVgpCj4gIAkJCXJldHVybiAtRU9QTk9UU1VQUDsKPiAgCWNhc2UgUEhZX01PREVfUENJRToK CltTZXZlcml0eTogTG93XQpJcyB0aGlzIGFuIGludGVudGlvbmFsIGZhbGx0aHJvdWdoPwoKSWYg c28sIHRoaXMgc3dpdGNoIGJsb2NrIG5lZWRzIGEgZmFsbHRocm91Z2ggYW5ub3RhdGlvbiB0byBw cmV2ZW50IGNvbXBpbGVyCndhcm5pbmdzLgoKPiAgCQlicmVhazsKPiAgCWRlZmF1bHQ6Cj4gIAkJ cmV0dXJuIC1FT1BOT1RTVVBQOwo+ICAJfQo+ICAKPiAgCXJldCA9IHBoeV9zZXRfbW9kZV9leHQo aW5zdGFuY2UtPnNlcmRlc19waHksIG1vZGUsIHN1Ym1vZGUpOwoKW1NldmVyaXR5OiBNZWRpdW1d CldpbGwgdGhpcyBuZXN0ZWQgY2FsbCB0byBwaHlfc2V0X21vZGVfZXh0KCkgaW4gYW43NTgzX3Vz Yl9waHlfcGNpZV9zZXRfbW9kZSgpCnRyaWdnZXIgYSBsb2NrZGVwIHdhcm5pbmc/CgpUaGUgY29y ZSBQSFkgZnJhbWV3b3JrIGludm9rZXMgdGhlIGRyaXZlcidzIHNldF9tb2RlIGNhbGxiYWNrIHdp dGggdGhlCnByaW1hcnkgcGh5LT5tdXRleCBoZWxkLiBDYWxsaW5nIHBoeV9zZXRfbW9kZV9leHQo KSBvbiB0aGUgc2Vjb25kYXJ5IFBIWQphdHRlbXB0cyB0byBhY3F1aXJlIHRoZSBzZWNvbmRhcnkg UEhZJ3MgbXV0ZXgsIHdoaWNoIGJlbG9uZ3MgdG8gdGhlIHNhbWUKbG9jayBjbGFzcy4KClsgLi4u IF0KCj4gQEAgLTEyOTcsMjkgKzEyOTcsMjkgQEAgc3RhdGljIGludCBhbjc1ODNfdXNiX3BoeV9w YXJzZV9wb3J0cyhzdHJ1Y3QgZGV2aWNlICpkZXYsCj4gIAkJCQkgICAgICBzdHJ1Y3QgYW43NTgz X3VzYl9waHlfcHJpdiAqcHJpdiwKPiAgCQkJCSAgICAgIGludCBpbmRleCwgc3RydWN0IGRldmlj ZV9ub2RlICpzdWJub2RlKQo+ICB7Cj4gIAljb25zdCBzdHJ1Y3QgYW43NTgzX3VzYl9waHlfbWF0 Y2hfZGF0YSAqZGF0YTsKPiAgCXN0cnVjdCBhbjc1ODNfdXNiX3BoeV9pbnN0YW5jZSAgKmluc3Rh bmNlOwo+ICAJc3RydWN0IHBoeSAqcGh5Owo+ICAJaW50IHJldDsKPiAgCj4gIAlkYXRhID0gb2Zf ZGV2aWNlX2dldF9tYXRjaF9kYXRhKGRldik7Cj4gIAo+ICAJaWYgKGluZGV4ID4gZGF0YS0+bWF4 X2luc3RhbmNlKQoKW1NldmVyaXR5OiBIaWdoXQpTaG91bGQgdGhpcyBib3VuZHMgY2hlY2sgdXNl ID49IGluc3RlYWQgb2YgPiBpbiBhbjc1ODNfdXNiX3BoeV9wYXJzZV9wb3J0cygpPwoKVGhlIG1h eF9pbnN0YW5jZSBpcyB0aGUgc2l6ZSBvZiB0aGUgYXJyYXkgKDMgZm9yIFVTQiksIHNvIGFsbG93 aW5nIGluZGV4IHRvCmVxdWFsIG1heF9pbnN0YW5jZSB3aWxsIGNhdXNlIGFuIG91dC1vZi1ib3Vu ZHMgd3JpdGUgd2hlbiBwcml2LT5waHlzW2luZGV4XQppcyBhc3NpZ25lZCBsYXRlci4KCj4gIAkJ cmV0dXJuIC1FSU5WQUw7Cj4gIAo+ICAJaWYgKCFvZl9kZXZpY2VfaXNfYXZhaWxhYmxlKHN1Ym5v ZGUpKQo+ICAJCXJldHVybiAwOwo+ICAKPiAgCWluc3RhbmNlID0gZGV2bV9remFsbG9jKGRldiwg c2l6ZW9mKCppbnN0YW5jZSksIEdGUF9LRVJORUwpOwo+ICAJaWYgKCFpbnN0YW5jZSkKPiAgCQly ZXR1cm4gLUVOT01FTTsKPiAgCj4gIAlpbnN0YW5jZS0+c2VyZGVzX3BoeSA9IGRldm1fcGh5X29w dGlvbmFsX2dldChkZXYsIE5VTEwpOwoKW1NldmVyaXR5OiBIaWdoXQpEb2VzIGRldm1fcGh5X29w dGlvbmFsX2dldCgpIGZldGNoIHRoZSBwZXItcG9ydCBzZXJkZXMgUEhZIGZyb20gdGhlIHBhcmVu dApkZXZpY2Ugbm9kZSByYXRoZXIgdGhhbiB0aGUgc3BlY2lmaWMgcG9ydCBzdWJub2RlPwoKQmVj YXVzZSBpdCB1c2VzIGRldiBhbmQgbm90IHN1Ym5vZGUsIGl0IGFwcGVhcnMgYWxsIHN1Ym5vZGVz IHdpbGwgcmVzb2x2ZSB0bwp0aGUgZXhhY3Qgc2FtZSBQSFkgaW5zdGFuY2UsIHdoaWNoIHdvdWxk IG1pc2NsYXNzaWZ5IGV2ZXJ5IHBvcnQgYXMKUEhZX1RZUEVfVVNCMyBhbmQgYnJlYWsgVVNCMiBw b3J0IGluaXRpYWxpemF0aW9uLgoKU2hvdWxkIHRoaXMgdXNlIGRldm1fb2ZfcGh5X29wdGlvbmFs X2dldChkZXYsIHN1Ym5vZGUsIE5VTEwpPwoKPiAgCWlmIChJU19FUlIoaW5zdGFuY2UtPnNlcmRl c19waHkpKQo+ICAJCXJldHVybiBkZXZfZXJyX3Byb2JlKGRldiwgUFRSX0VSUihpbnN0YW5jZS0+ c2VyZGVzX3BoeSksICJlcnJvciBvbiBzZXJkZXMgcGh5IGZvciBVU0IgMy4wXG4iKTsKPiAgCj4g IAlpZiAoIWluc3RhbmNlLT5zZXJkZXNfcGh5ICYmCj4gIAkgICAgIW9mX3Byb3BlcnR5X3ByZXNl bnQoc3Vibm9kZSwgImFpcm9oYSx1c2IyLW1vbml0b3ItY2xrLXNlbCIpKQo+ICAJCXJldHVybiBk ZXZfZXJyX3Byb2JlKGRldiwgcmV0LCAibW9uaXRvciBjbG9jayBzZWxlY3Rpb24gb3Igc2VyZGVz IFBIWSBpcyBtYW5kYXRvcnkgZm9yIFVTQiBQSFlcbiIpOwoKW1NldmVyaXR5OiBNZWRpdW1dCklm IHRoZSBzdWJub2RlIGxhY2tzIGJvdGggdGhlIHNlcmRlc19waHkgYW5kIHRoZSBhaXJvaGEsdXNi Mi1tb25pdG9yLWNsay1zZWwKcHJvcGVydGllcywgdGhlIGVycm9yIHBhdGggcmV0dXJucyB0aGUg dW5pbml0aWFsaXplZCByZXQgdmFyaWFibGUuCgpDYW4gdGhpcyByZXR1cm4gYSBnYXJiYWdlIGVy cm9yIGNvZGUgKG9yIDApIGxlYWRpbmcgdG8gc2lsZW50IGluaXRpYWxpemF0aW9uCmZhaWx1cmVz PwoKPiAgCj4gIAlpZiAoaW5zdGFuY2UtPnNlcmRlc19waHkpIHsKPiAgCQlpbnN0YW5jZS0+dHlw ZSA9IFBIWV9UWVBFX1VTQjM7Cj4gIAl9IGVsc2Ugewo+ICAJCXJldCA9IG9mX3Byb3BlcnR5X3Jl YWRfdTMyKHN1Ym5vZGUsICJhaXJvaGEsdXNiMi1tb25pdG9yLWNsay1zZWwiLAo+ICAJCQkJCSAg ICZpbnN0YW5jZS0+bW9uY2xrX3NlbCk7Cj4gIAkJaWYgKHJldCkKPiAgCQkJcmV0dXJuIGRldl9l cnJfcHJvYmUoZGV2LCByZXQsICJmYWlsZWQgdG8gcGFyc2UgTW9uaXRvciBjbG9jayBzZWxlY3Rp b25cbiIpOwo+ICAKPiAgCQlyZXQgPSBvZl9wcm9wZXJ0eV9yZWFkX3UzMihzdWJub2RlLCAicmVn IiwKPiAgCQkJCQkgICAmaW5zdGFuY2UtPm9mZnNldCk7Cj4gIAkJaWYgKHJldCkKPiAgCQkJcmV0 dXJuIGRldl9lcnJfcHJvYmUoZGV2LCByZXQsICJtaXNzaW5nIHJlZyBmb3IgVTIgUEhZXG4iKTsK PiAgCj4gIAkJaW5zdGFuY2UtPnR5cGUgPSBQSFlfVFlQRV9VU0IyOwo+ICAJfQo+ICAKPiAgCXBo eSA9IGRldm1fcGh5X2NyZWF0ZShkZXYsIHN1Ym5vZGUsICZhaXJvaGFfcGh5KTsKPiAgCWlmIChJ U19FUlIocGh5KSkKPiAgCQlyZXR1cm4gZGV2X2Vycl9wcm9iZShkZXYsIFBUUl9FUlIocGh5KSwg ImZhaWxlZCB0byBjcmVhdGUgcGh5XG4iKTsKPiAgCj4gIAlwcml2LT5waHlzW2luZGV4XSA9IHBo eTsKClsgLi4uIF0KCj4gQEAgLTEzNDEsMTIgKzEzNDEsMTIgQEAgc3RhdGljIGludCBhaXJvaGFf cGNpZV9waHlfcGFyc2VfcG9ydHMoc3RydWN0IGRldmljZSAqZGV2LAo+ICAJCQkJICAgICAgIHN0 cnVjdCBhbjc1ODNfdXNiX3BoeV9wcml2ICpwcml2LAo+ICAJCQkJICAgICAgIGludCBpbmRleCwg c3RydWN0IGRldmljZV9ub2RlICpzdWJub2RlKQo+ICB7Cj4gIAljb25zdCBzdHJ1Y3QgYW43NTgz X3VzYl9waHlfbWF0Y2hfZGF0YSAqZGF0YTsKPiAgCXN0cnVjdCBhbjc1ODNfdXNiX3BoeV9pbnN0 YW5jZSAgKmluc3RhbmNlOwo+ICAJc3RydWN0IHBoeSAqcGh5Owo+ICAKPiAgCWRhdGEgPSBvZl9k ZXZpY2VfZ2V0X21hdGNoX2RhdGEoZGV2KTsKPiAgCj4gIAlpZiAoaW5kZXggPiBkYXRhLT5tYXhf aW5zdGFuY2UpCgpbU2V2ZXJpdHk6IEhpZ2hdClNob3VsZCB0aGlzIGJvdW5kcyBjaGVjayB1c2Ug Pj0gaW5zdGVhZCBvZiA+IGluIGFpcm9oYV9wY2llX3BoeV9wYXJzZV9wb3J0cygpPwoKVGhlIG1h eF9pbnN0YW5jZSBpcyB0aGUgc2l6ZSBvZiB0aGUgYXJyYXkgKDEgZm9yIFBDSWUpLCBzbyBhbGxv d2luZyBpbmRleCB0bwplcXVhbCBtYXhfaW5zdGFuY2Ugd2lsbCBjYXVzZSBhbiBvdXQtb2YtYm91 bmRzIHdyaXRlIHdoZW4gcHJpdi0+cGh5c1tpbmRleF0KaXMgYXNzaWduZWQgbGF0ZXIuCgo+ICAJ CXJldHVybiAtRUlOVkFMOwo+ICAKPiAgCWlmICghb2ZfZGV2aWNlX2lzX2F2YWlsYWJsZShzdWJu b2RlKSkKPiAgCQlyZXR1cm4gMDsKCi0tIApTYXNoaWtvIEFJIHJldmlldyDCtyBodHRwczovL3Nh c2hpa28uZGV2LyMvcGF0Y2hzZXQvMjAyNjA4MjcxMzE1NTEuMjY3MjUtMS1hbnN1ZWxzbXRoQGdt YWlsLmNvbT9wYXJ0PTMKCi0tIApsaW51eC1waHkgbWFpbGluZyBsaXN0CmxpbnV4LXBoeUBsaXN0 cy5pbmZyYWRlYWQub3JnCmh0dHBzOi8vbGlzdHMuaW5mcmFkZWFkLm9yZy9tYWlsbWFuL2xpc3Rp bmZvL2xpbnV4LXBoeQo=