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 5DB3C2989B5 for ; Sat, 11 Jul 2026 17:06:43 +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=1783789604; cv=none; b=c9pPIg1RdDeMJUEN8rXNC9m5SKhEsEKxJdqOmuuy9w7MVo8vSKtVXdnl0FSTbHEhugK0KtuEFuOs+r6Z8I2PWlM1t7lg11zj5qpZFWru0MdNzjBPkyimNbFnJbIu6w2E9xjkKNu6kP014sjT+Xnxi0xI76C9NdZ9OSthygMTeeY= ARC-Message-Signature:i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1783789604; c=relaxed/simple; bh=7sTmTnptkACXFPfnlub7+Ga5CpXeQFg5kmy1aPQ5rFA=; h=From:Subject:To:Cc:In-Reply-To:References:Content-Type:Date: Message-Id; b=ZMQ/Ms4ljsb4YgytcIdb9cr4nbK40NoZSXnoIZmvbh03JNHuQcWr/EdO5rPHCXuPjgAyOCTUUnWmJaqvT2jKS9qD2nT6U2cWbYfvHcAt3gPPncEx2vU0g9t8m9HRKfbgTxccN9FkRsxQTpvExFsbdVqTBYAfTe/x1U7NLxIq+qc= ARC-Authentication-Results:i=1; smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b=Px7aHcjp; 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="Px7aHcjp" Received: by smtp.kernel.org (Postfix) with ESMTPSA id BA9A61F000E9; Sat, 11 Jul 2026 17:06:42 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=kernel.org; s=k20260515; t=1783789603; bh=wUWDYIcY8F+g78dToxDQA4HnGeV4QLeONGfJJppqmkc=; h=From:Subject:Reply-To:To:Cc:In-Reply-To:References:Date; b=Px7aHcjp+dolpK2Gkn9set6hhP5c6rlLmQyRQ1s3Rdx74pEAToTJPykizaUaBHEtI XwQZ3JEhRiUOJ3YyVwhSXpbv5QOaQmlV+5F3jGNzuGURTVWBvRw1YeEZtcK9dMlto+ a3KIvxmyTzt2eev+onRmDvji91AMioGJJp47zpJldhxPPSWJRp9KPuXXGW9RLDSd48 y5ocyzjZ33XOmLd4nW7wy+iMzSe59Jmy38uv4tJR62+aV/Up+bDwroHGik+NEPEuma X/mhedbyDeen0a1mMe5rEH00uD3flB/aHqGo3eC1XJEsOItlJaTonhE3on5AV3rMoK PliJ40/E0Qx/A== From: sashiko-bot@kernel.org Subject: Re: [PATCH v4 3/6] phy: cpcap-usb: add DCP detection and make UART idle mode optional Reply-To: sashiko-reviews@lists.linux.dev To: "Ivaylo Dimitrov" Cc: robh@kernel.org, conor+dt@kernel.org, devicetree@vger.kernel.org, vkoul@kernel.org, olteanv@gmail.com, neil.armstrong@linaro.org, linux-phy@lists.infradead.org In-Reply-To: <20260711164754.185565-4-ivo.g.dimitrov.75@gmail.com> References: <20260711164754.185565-1-ivo.g.dimitrov.75@gmail.com> <20260711164754.185565-4-ivo.g.dimitrov.75@gmail.com> Content-Type: text/plain; charset=utf-8 Content-Transfer-Encoding: quoted-printable Date: Sat, 11 Jul 2026 17:06:42 +0000 Message-Id: <20260711170642.BA9A61F000E9@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 3 potential issue(= s) to consider: New issues: - [High] `cpcap_usb_set_idle_mode()` unconditionally sets `CPCAP_BIT_DMPD_S= PI` and `CPCAP_BIT_DPPD_SPI`, overriding hardware pulldowns and breaking su= bsequent charger detection. - [Medium] The `cpcap_usb_set_dcp_mode` function fails to fully configure t= he PHY registers, leaving them in a non-deterministic state. Pre-existing issues: - [High] A TOCTOU race condition exists between the IRQ handler thread and = `cpcap_usb_phy_remove`, leading to a use-after-free of the `ddata` structur= e. -- --- Patch [3]: [PATCH v4 3/6] phy: cpcap-usb: add DCP detection and make UA= RT idle mode optional --- commit ccdf9470fbb5fbd414c5546a329d78f69ecf50b7 Author: Ivaylo Dimitrov phy: cpcap-usb: add DCP detection and make UART idle mode optional Handle DCP separately from USB host connections using CPCAP charger detection status. Make the existing idle UART mode optional via the enable_uart module parameter. Also initialize the PHY into the baseline configuration required for reliable charger detection during probe. > diff --git a/drivers/phy/motorola/phy-cpcap-usb.c b/drivers/phy/motorola/= phy-cpcap-usb.c > index 7cb020dd3423c..d4eb8086b6000 100644 > --- a/drivers/phy/motorola/phy-cpcap-usb.c > +++ b/drivers/phy/motorola/phy-cpcap-usb.c [ ... ] > @@ -411,43 +446,84 @@ static int cpcap_usb_gpio_set_mode(struct cpcap_phy= _ddata *ddata, [ ... ] > +static int cpcap_usb_set_idle_mode(struct cpcap_phy_ddata *ddata) > +{ > + int error; > + unsigned int val; > + bool enable_uart =3D cpcap_enable_uart; > + > + error =3D cpcap_usb_set_safe_mode(ddata); > + if (error) > + return error; > + > error =3D regmap_update_bits(ddata->reg, CPCAP_REG_USBC1, > + CPCAP_BIT_DP150KPU | > + CPCAP_BIT_DP1K5PU | > + CPCAP_BIT_DM1K5PU | > + CPCAP_BIT_DPPD | > + CPCAP_BIT_DMPD | > CPCAP_BIT_VBUSPD, > + CPCAP_BIT_DP150KPU | > CPCAP_BIT_VBUSPD); > if (error) > goto out_err; > =20 > - error =3D regmap_update_bits(ddata->reg, CPCAP_REG_USBC2, > - 0xffff, CPCAP_BIT_UARTMUX0 | > - CPCAP_BIT_EMUMODE0); > + val =3D CPCAP_BIT_USBSUSPEND; > + > + if (enable_uart) > + val |=3D (CPCAP_BIT_UARTMUX0 | CPCAP_BIT_EMUMODE0); > + > + error =3D regmap_update_bits(ddata->reg, CPCAP_REG_USBC2, 0xffff, val); > if (error) > goto out_err; > =20 > - error =3D regmap_update_bits(ddata->reg, CPCAP_REG_USBC3, 0x7fff, > - CPCAP_BIT_IDPU_SPI); > + val =3D CPCAP_BIT_VBUSSTBY_EN | > + CPCAP_BIT_VBUSPD_SPI | > + CPCAP_BIT_DMPD_SPI | > + CPCAP_BIT_DPPD_SPI | > + CPCAP_BIT_PU_SPI | > + CPCAP_BIT_IDPU_SPI | > + CPCAP_BIT_ULPI_SPI_SEL; > + > + if (!enable_uart) > + val |=3D CPCAP_BIT_SUSPEND_SPI; > + > + error =3D regmap_update_bits(ddata->reg, CPCAP_REG_USBC3, 0x7fff, val); [Severity: High] Does setting CPCAP_BIT_DMPD_SPI and CPCAP_BIT_DPPD_SPI here break charger detection? Writing this value to USBC3 unconditionally sets both DMPD_SPI and DPPD_SPI= to 1. This overrides the hardware pulldowns and forces them off. The original code correctly cleared these bits, and as noted in cpcap_usb_init_usb(), disabling these pulldowns can break subsequent charger detection when the cable is disconnected. > if (error) > goto out_err; > =20 [ ... ] > @@ -508,6 +583,31 @@ static int cpcap_usb_set_usb_mode(struct cpcap_phy_d= data *ddata) > return error; > } > =20 > +static int cpcap_usb_set_dcp_mode(struct cpcap_phy_ddata *ddata) > +{ > + int error; > + > + error =3D cpcap_usb_set_safe_mode(ddata); > + if (error) > + return error; > + > + error =3D regmap_update_bits(ddata->reg, CPCAP_REG_USBC3, > + CPCAP_BIT_SUSPEND_SPI, 0); > + if (error) > + goto out_err; [Severity: Medium] Does cpcap_usb_set_dcp_mode() need to configure USBC1 and USBC2 as well? Because this only updates USBC3, it seems to inherit whatever state was left by the previous mode. For example, if transitioning from USB mode, USBXCVREN in USBC2 might remain set. If transitioning from IDLE mode with enable_uart=3D1, UARTMUX0 might remain set, leaving the UART connected to t= he data lines during charging. > + > + error =3D cpcap_usb_gpio_set_mode(ddata, CPCAP_DM_DP); > + if (error) > + goto out_err; > + > + return 0; > + > +out_err: > + dev_err(ddata->dev, "%s failed with %i\n", __func__, error); > + > + return error; > +} > + [ ... ] > @@ -688,17 +849,13 @@ static int cpcap_usb_phy_probe(struct platform_devi= ce *pdev) > static void cpcap_usb_phy_remove(struct platform_device *pdev) > { > struct cpcap_phy_ddata *ddata =3D platform_get_drvdata(pdev); > - int error; > =20 > atomic_set(&ddata->active, 0); > - error =3D cpcap_usb_set_uart_mode(ddata); > - if (error) > - dev_err(ddata->dev, "could not set UART mode\n"); > - > + cancel_delayed_work_sync(&ddata->detect_work); > + cpcap_usb_set_idle_mode(ddata); > cpcap_usb_try_musb_mailbox(ddata, MUSB_VBUS_OFF); > =20 > usb_remove_phy(&ddata->phy); > - cancel_delayed_work_sync(&ddata->detect_work); > regulator_disable(ddata->vusb); > } [Severity: High] This is a pre-existing issue, but is there a TOCTOU race condition between cpcap_phy_irq_thread() and cpcap_usb_phy_remove() that can result in a use-after-free? If the IRQ thread reads ddata->active as 1 in cpcap_phy_irq_thread() and ge= ts preempted: cpcap_phy_irq_thread() { if (!atomic_read(&ddata->active)) return IRQ_NONE; /* preempted here */ And cpcap_usb_phy_remove() completes, setting ddata->active =3D 0, cancelin= g the work, and allowing devres to free ddata: cpcap_usb_phy_remove() { atomic_set(&ddata->active, 0); cancel_delayed_work_sync(&ddata->detect_work); ... } /* devres frees ddata */ Could the IRQ thread then resume and call schedule_delayed_work() on the fr= eed ddata? --=20 Sashiko AI review =C2=B7 https://sashiko.dev/#/patchset/20260711164754.1855= 65-1-ivo.g.dimitrov.75@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 5941CC43458 for ; Sat, 11 Jul 2026 17:06:45 +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=AfZoN6HM3G+xD5q+8EBO39jwS9Trq7kMCBbJN+OC0OM=; b=sa274/ziFBP210 7ZydnUlNTT4DaVowDmzhFwf/gKE5ZsnS7Jhac7UFvO+WRG03L03ANBWgoc0doZL2hapQtgoCCjJLA 34J+SKeOev6M7OqwjRDWI7Ekth2R0Mgo+GAUwGqUhnhOYsoXHCMldoelbGIweyLkQJ8vaXB4CcyAN QG7ftF8mujkR7u1pkab3clsfuzCcKED8+CVlVx7O1CT5x2y9co3oCXv3z449zUYh+XpGBtc8TtnW7 AHipmv/Qpoh91dAFQy2hj+K+cRKDcXnDgrPJQN4sAmo0NromFaV4jCNvhWfwgEDkl/qQmGGbjYOyB dcNJxzt/TV19PFlnzmPg==; Received: from localhost ([::1] helo=bombadil.infradead.org) by bombadil.infradead.org with esmtp (Exim 4.99.1 #2 (Red Hat Linux)) id 1wibA4-00000006iJr-2LTb; Sat, 11 Jul 2026 17:06:44 +0000 Received: from sea.source.kernel.org ([2600:3c0a:e001:78e:0:1991:8:25]) by bombadil.infradead.org with esmtps (Exim 4.99.1 #2 (Red Hat Linux)) id 1wibA3-00000006iJl-364T for linux-phy@lists.infradead.org; Sat, 11 Jul 2026 17:06:43 +0000 Received: from smtp.kernel.org (quasi.space.kernel.org [100.103.45.18]) by sea.source.kernel.org (Postfix) with ESMTP id 52980419FA; Sat, 11 Jul 2026 17:06:43 +0000 (UTC) Received: by smtp.kernel.org (Postfix) with ESMTPSA id BA9A61F000E9; Sat, 11 Jul 2026 17:06:42 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=kernel.org; s=k20260515; t=1783789603; bh=wUWDYIcY8F+g78dToxDQA4HnGeV4QLeONGfJJppqmkc=; h=From:Subject:Reply-To:To:Cc:In-Reply-To:References:Date; b=Px7aHcjp+dolpK2Gkn9set6hhP5c6rlLmQyRQ1s3Rdx74pEAToTJPykizaUaBHEtI XwQZ3JEhRiUOJ3YyVwhSXpbv5QOaQmlV+5F3jGNzuGURTVWBvRw1YeEZtcK9dMlto+ a3KIvxmyTzt2eev+onRmDvji91AMioGJJp47zpJldhxPPSWJRp9KPuXXGW9RLDSd48 y5ocyzjZ33XOmLd4nW7wy+iMzSe59Jmy38uv4tJR62+aV/Up+bDwroHGik+NEPEuma X/mhedbyDeen0a1mMe5rEH00uD3flB/aHqGo3eC1XJEsOItlJaTonhE3on5AV3rMoK PliJ40/E0Qx/A== From: sashiko-bot@kernel.org Subject: Re: [PATCH v4 3/6] phy: cpcap-usb: add DCP detection and make UART idle mode optional To: "Ivaylo Dimitrov" Cc: robh@kernel.org, conor+dt@kernel.org, devicetree@vger.kernel.org, vkoul@kernel.org, olteanv@gmail.com, neil.armstrong@linaro.org, linux-phy@lists.infradead.org In-Reply-To: <20260711164754.185565-4-ivo.g.dimitrov.75@gmail.com> References: <20260711164754.185565-1-ivo.g.dimitrov.75@gmail.com> <20260711164754.185565-4-ivo.g.dimitrov.75@gmail.com> Date: Sat, 11 Jul 2026 17:06:42 +0000 Message-Id: <20260711170642.BA9A61F000E9@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 MyBwb3RlbnRpYWwgaXNzdWUocykgdG8gY29uc2lkZXI6CgpOZXcgaXNzdWVzOgotIFtIaWdoXSBg Y3BjYXBfdXNiX3NldF9pZGxlX21vZGUoKWAgdW5jb25kaXRpb25hbGx5IHNldHMgYENQQ0FQX0JJ VF9ETVBEX1NQSWAgYW5kIGBDUENBUF9CSVRfRFBQRF9TUElgLCBvdmVycmlkaW5nIGhhcmR3YXJl IHB1bGxkb3ducyBhbmQgYnJlYWtpbmcgc3Vic2VxdWVudCBjaGFyZ2VyIGRldGVjdGlvbi4KLSBb TWVkaXVtXSBUaGUgYGNwY2FwX3VzYl9zZXRfZGNwX21vZGVgIGZ1bmN0aW9uIGZhaWxzIHRvIGZ1 bGx5IGNvbmZpZ3VyZSB0aGUgUEhZIHJlZ2lzdGVycywgbGVhdmluZyB0aGVtIGluIGEgbm9uLWRl dGVybWluaXN0aWMgc3RhdGUuCgpQcmUtZXhpc3RpbmcgaXNzdWVzOgotIFtIaWdoXSBBIFRPQ1RP VSByYWNlIGNvbmRpdGlvbiBleGlzdHMgYmV0d2VlbiB0aGUgSVJRIGhhbmRsZXIgdGhyZWFkIGFu ZCBgY3BjYXBfdXNiX3BoeV9yZW1vdmVgLCBsZWFkaW5nIHRvIGEgdXNlLWFmdGVyLWZyZWUgb2Yg dGhlIGBkZGF0YWAgc3RydWN0dXJlLgotLQoKLS0tIFBhdGNoIFszXTogW1BBVENIIHY0IDMvNl0g cGh5OiBjcGNhcC11c2I6IGFkZCBEQ1AgZGV0ZWN0aW9uIGFuZCBtYWtlIFVBUlQgaWRsZSBtb2Rl IG9wdGlvbmFsIC0tLQpjb21taXQgY2NkZjk0NzBmYmI1ZmJkNDE0YzU1NDZhMzI5ZDc4ZjY5ZWNm NTBiNwpBdXRob3I6IEl2YXlsbyBEaW1pdHJvdiA8aXZvLmcuZGltaXRyb3YuNzVAZ21haWwuY29t PgoKcGh5OiBjcGNhcC11c2I6IGFkZCBEQ1AgZGV0ZWN0aW9uIGFuZCBtYWtlIFVBUlQgaWRsZSBt b2RlIG9wdGlvbmFsCgpIYW5kbGUgRENQIHNlcGFyYXRlbHkgZnJvbSBVU0IgaG9zdCBjb25uZWN0 aW9ucyB1c2luZyBDUENBUCBjaGFyZ2VyCmRldGVjdGlvbiBzdGF0dXMuIE1ha2UgdGhlIGV4aXN0 aW5nIGlkbGUgVUFSVCBtb2RlIG9wdGlvbmFsIHZpYSB0aGUKZW5hYmxlX3VhcnQgbW9kdWxlIHBh cmFtZXRlci4gQWxzbyBpbml0aWFsaXplIHRoZSBQSFkgaW50byB0aGUgYmFzZWxpbmUKY29uZmln dXJhdGlvbiByZXF1aXJlZCBmb3IgcmVsaWFibGUgY2hhcmdlciBkZXRlY3Rpb24gZHVyaW5nIHBy b2JlLgoKPiBkaWZmIC0tZ2l0IGEvZHJpdmVycy9waHkvbW90b3JvbGEvcGh5LWNwY2FwLXVzYi5j IGIvZHJpdmVycy9waHkvbW90b3JvbGEvcGh5LWNwY2FwLXVzYi5jCj4gaW5kZXggN2NiMDIwZGQz NDIzYy4uZDRlYjgwODZiNjAwMCAxMDA2NDQKPiAtLS0gYS9kcml2ZXJzL3BoeS9tb3Rvcm9sYS9w aHktY3BjYXAtdXNiLmMKPiArKysgYi9kcml2ZXJzL3BoeS9tb3Rvcm9sYS9waHktY3BjYXAtdXNi LmMKWyAuLi4gXQo+IEBAIC00MTEsNDMgKzQ0Niw4NCBAQCBzdGF0aWMgaW50IGNwY2FwX3VzYl9n cGlvX3NldF9tb2RlKHN0cnVjdCBjcGNhcF9waHlfZGRhdGEgKmRkYXRhLApbIC4uLiBdCj4gK3N0 YXRpYyBpbnQgY3BjYXBfdXNiX3NldF9pZGxlX21vZGUoc3RydWN0IGNwY2FwX3BoeV9kZGF0YSAq ZGRhdGEpCj4gK3sKPiArCWludCBlcnJvcjsKPiArCXVuc2lnbmVkIGludCB2YWw7Cj4gKwlib29s IGVuYWJsZV91YXJ0ID0gY3BjYXBfZW5hYmxlX3VhcnQ7Cj4gKwo+ICsJZXJyb3IgPSBjcGNhcF91 c2Jfc2V0X3NhZmVfbW9kZShkZGF0YSk7Cj4gKwlpZiAoZXJyb3IpCj4gKwkJcmV0dXJuIGVycm9y Owo+ICsKPiAgCWVycm9yID0gcmVnbWFwX3VwZGF0ZV9iaXRzKGRkYXRhLT5yZWcsIENQQ0FQX1JF R19VU0JDMSwKPiArCQkJCSAgIENQQ0FQX0JJVF9EUDE1MEtQVSB8Cj4gKwkJCQkgICBDUENBUF9C SVRfRFAxSzVQVSB8Cj4gKwkJCQkgICBDUENBUF9CSVRfRE0xSzVQVSB8Cj4gKwkJCQkgICBDUENB UF9CSVRfRFBQRCB8Cj4gKwkJCQkgICBDUENBUF9CSVRfRE1QRCB8Cj4gIAkJCQkgICBDUENBUF9C SVRfVkJVU1BELAo+ICsJCQkJICAgQ1BDQVBfQklUX0RQMTUwS1BVIHwKPiAgCQkJCSAgIENQQ0FQ X0JJVF9WQlVTUEQpOwo+ICAJaWYgKGVycm9yKQo+ICAJCWdvdG8gb3V0X2VycjsKPiAgCj4gLQll cnJvciA9IHJlZ21hcF91cGRhdGVfYml0cyhkZGF0YS0+cmVnLCBDUENBUF9SRUdfVVNCQzIsCj4g LQkJCQkgICAweGZmZmYsIENQQ0FQX0JJVF9VQVJUTVVYMCB8Cj4gLQkJCQkgICBDUENBUF9CSVRf RU1VTU9ERTApOwo+ICsJdmFsID0gQ1BDQVBfQklUX1VTQlNVU1BFTkQ7Cj4gKwo+ICsJaWYgKGVu YWJsZV91YXJ0KQo+ICsJCXZhbCB8PSAoQ1BDQVBfQklUX1VBUlRNVVgwIHwgQ1BDQVBfQklUX0VN VU1PREUwKTsKPiArCj4gKwllcnJvciA9IHJlZ21hcF91cGRhdGVfYml0cyhkZGF0YS0+cmVnLCBD UENBUF9SRUdfVVNCQzIsIDB4ZmZmZiwgdmFsKTsKPiAgCWlmIChlcnJvcikKPiAgCQlnb3RvIG91 dF9lcnI7Cj4gIAo+IC0JZXJyb3IgPSByZWdtYXBfdXBkYXRlX2JpdHMoZGRhdGEtPnJlZywgQ1BD QVBfUkVHX1VTQkMzLCAweDdmZmYsCj4gLQkJCQkgICBDUENBUF9CSVRfSURQVV9TUEkpOwo+ICsJ dmFsID0gQ1BDQVBfQklUX1ZCVVNTVEJZX0VOIHwKPiArCSAgICAgIENQQ0FQX0JJVF9WQlVTUERf U1BJIHwKPiArCSAgICAgIENQQ0FQX0JJVF9ETVBEX1NQSSB8Cj4gKwkgICAgICBDUENBUF9CSVRf RFBQRF9TUEkgfAo+ICsJICAgICAgQ1BDQVBfQklUX1BVX1NQSSB8Cj4gKwkgICAgICBDUENBUF9C SVRfSURQVV9TUEkgfAo+ICsJICAgICAgQ1BDQVBfQklUX1VMUElfU1BJX1NFTDsKPiArCj4gKwlp ZiAoIWVuYWJsZV91YXJ0KQo+ICsJCXZhbCB8PSBDUENBUF9CSVRfU1VTUEVORF9TUEk7Cj4gKwo+ ICsJZXJyb3IgPSByZWdtYXBfdXBkYXRlX2JpdHMoZGRhdGEtPnJlZywgQ1BDQVBfUkVHX1VTQkMz LCAweDdmZmYsIHZhbCk7CgpbU2V2ZXJpdHk6IEhpZ2hdCkRvZXMgc2V0dGluZyBDUENBUF9CSVRf RE1QRF9TUEkgYW5kIENQQ0FQX0JJVF9EUFBEX1NQSSBoZXJlIGJyZWFrIGNoYXJnZXIKZGV0ZWN0 aW9uPwoKV3JpdGluZyB0aGlzIHZhbHVlIHRvIFVTQkMzIHVuY29uZGl0aW9uYWxseSBzZXRzIGJv dGggRE1QRF9TUEkgYW5kIERQUERfU1BJIHRvCjEuIFRoaXMgb3ZlcnJpZGVzIHRoZSBoYXJkd2Fy ZSBwdWxsZG93bnMgYW5kIGZvcmNlcyB0aGVtIG9mZi4gVGhlIG9yaWdpbmFsCmNvZGUgY29ycmVj dGx5IGNsZWFyZWQgdGhlc2UgYml0cywgYW5kIGFzIG5vdGVkIGluIGNwY2FwX3VzYl9pbml0X3Vz YigpLApkaXNhYmxpbmcgdGhlc2UgcHVsbGRvd25zIGNhbiBicmVhayBzdWJzZXF1ZW50IGNoYXJn ZXIgZGV0ZWN0aW9uIHdoZW4gdGhlCmNhYmxlIGlzIGRpc2Nvbm5lY3RlZC4KCj4gIAlpZiAoZXJy b3IpCj4gIAkJZ290byBvdXRfZXJyOwo+ICAKWyAuLi4gXQo+IEBAIC01MDgsNiArNTgzLDMxIEBA IHN0YXRpYyBpbnQgY3BjYXBfdXNiX3NldF91c2JfbW9kZShzdHJ1Y3QgY3BjYXBfcGh5X2RkYXRh ICpkZGF0YSkKPiAgCXJldHVybiBlcnJvcjsKPiAgfQo+ICAKPiArc3RhdGljIGludCBjcGNhcF91 c2Jfc2V0X2RjcF9tb2RlKHN0cnVjdCBjcGNhcF9waHlfZGRhdGEgKmRkYXRhKQo+ICt7Cj4gKwlp bnQgZXJyb3I7Cj4gKwo+ICsJZXJyb3IgPSBjcGNhcF91c2Jfc2V0X3NhZmVfbW9kZShkZGF0YSk7 Cj4gKwlpZiAoZXJyb3IpCj4gKwkJcmV0dXJuIGVycm9yOwo+ICsKPiArCWVycm9yID0gcmVnbWFw X3VwZGF0ZV9iaXRzKGRkYXRhLT5yZWcsIENQQ0FQX1JFR19VU0JDMywKPiArCQkJCSAgIENQQ0FQ X0JJVF9TVVNQRU5EX1NQSSwgMCk7Cj4gKwlpZiAoZXJyb3IpCj4gKwkJZ290byBvdXRfZXJyOwoK W1NldmVyaXR5OiBNZWRpdW1dCkRvZXMgY3BjYXBfdXNiX3NldF9kY3BfbW9kZSgpIG5lZWQgdG8g Y29uZmlndXJlIFVTQkMxIGFuZCBVU0JDMiBhcyB3ZWxsPwoKQmVjYXVzZSB0aGlzIG9ubHkgdXBk YXRlcyBVU0JDMywgaXQgc2VlbXMgdG8gaW5oZXJpdCB3aGF0ZXZlciBzdGF0ZSB3YXMgbGVmdApi eSB0aGUgcHJldmlvdXMgbW9kZS4gRm9yIGV4YW1wbGUsIGlmIHRyYW5zaXRpb25pbmcgZnJvbSBV U0IgbW9kZSwgVVNCWENWUkVOCmluIFVTQkMyIG1pZ2h0IHJlbWFpbiBzZXQuIElmIHRyYW5zaXRp b25pbmcgZnJvbSBJRExFIG1vZGUgd2l0aAplbmFibGVfdWFydD0xLCBVQVJUTVVYMCBtaWdodCBy ZW1haW4gc2V0LCBsZWF2aW5nIHRoZSBVQVJUIGNvbm5lY3RlZCB0byB0aGUKZGF0YSBsaW5lcyBk dXJpbmcgY2hhcmdpbmcuCgo+ICsKPiArCWVycm9yID0gY3BjYXBfdXNiX2dwaW9fc2V0X21vZGUo ZGRhdGEsIENQQ0FQX0RNX0RQKTsKPiArCWlmIChlcnJvcikKPiArCQlnb3RvIG91dF9lcnI7Cj4g Kwo+ICsJcmV0dXJuIDA7Cj4gKwo+ICtvdXRfZXJyOgo+ICsJZGV2X2VycihkZGF0YS0+ZGV2LCAi JXMgZmFpbGVkIHdpdGggJWlcbiIsIF9fZnVuY19fLCBlcnJvcik7Cj4gKwo+ICsJcmV0dXJuIGVy cm9yOwo+ICt9Cj4gKwpbIC4uLiBdCj4gQEAgLTY4OCwxNyArODQ5LDEzIEBAIHN0YXRpYyBpbnQg Y3BjYXBfdXNiX3BoeV9wcm9iZShzdHJ1Y3QgcGxhdGZvcm1fZGV2aWNlICpwZGV2KQo+ICBzdGF0 aWMgdm9pZCBjcGNhcF91c2JfcGh5X3JlbW92ZShzdHJ1Y3QgcGxhdGZvcm1fZGV2aWNlICpwZGV2 KQo+ICB7Cj4gIAlzdHJ1Y3QgY3BjYXBfcGh5X2RkYXRhICpkZGF0YSA9IHBsYXRmb3JtX2dldF9k cnZkYXRhKHBkZXYpOwo+IC0JaW50IGVycm9yOwo+ICAKPiAgCWF0b21pY19zZXQoJmRkYXRhLT5h Y3RpdmUsIDApOwo+IC0JZXJyb3IgPSBjcGNhcF91c2Jfc2V0X3VhcnRfbW9kZShkZGF0YSk7Cj4g LQlpZiAoZXJyb3IpCj4gLQkJZGV2X2VycihkZGF0YS0+ZGV2LCAiY291bGQgbm90IHNldCBVQVJU IG1vZGVcbiIpOwo+IC0KPiArCWNhbmNlbF9kZWxheWVkX3dvcmtfc3luYygmZGRhdGEtPmRldGVj dF93b3JrKTsKPiArCWNwY2FwX3VzYl9zZXRfaWRsZV9tb2RlKGRkYXRhKTsKPiAgCWNwY2FwX3Vz Yl90cnlfbXVzYl9tYWlsYm94KGRkYXRhLCBNVVNCX1ZCVVNfT0ZGKTsKPiAgCj4gIAl1c2JfcmVt b3ZlX3BoeSgmZGRhdGEtPnBoeSk7Cj4gLQljYW5jZWxfZGVsYXllZF93b3JrX3N5bmMoJmRkYXRh LT5kZXRlY3Rfd29yayk7Cj4gIAlyZWd1bGF0b3JfZGlzYWJsZShkZGF0YS0+dnVzYik7Cj4gIH0K CltTZXZlcml0eTogSGlnaF0KVGhpcyBpcyBhIHByZS1leGlzdGluZyBpc3N1ZSwgYnV0IGlzIHRo ZXJlIGEgVE9DVE9VIHJhY2UgY29uZGl0aW9uIGJldHdlZW4KY3BjYXBfcGh5X2lycV90aHJlYWQo KSBhbmQgY3BjYXBfdXNiX3BoeV9yZW1vdmUoKSB0aGF0IGNhbiByZXN1bHQgaW4gYQp1c2UtYWZ0 ZXItZnJlZT8KCklmIHRoZSBJUlEgdGhyZWFkIHJlYWRzIGRkYXRhLT5hY3RpdmUgYXMgMSBpbiBj cGNhcF9waHlfaXJxX3RocmVhZCgpIGFuZCBnZXRzCnByZWVtcHRlZDoKCmNwY2FwX3BoeV9pcnFf dGhyZWFkKCkgewogICAgaWYgKCFhdG9taWNfcmVhZCgmZGRhdGEtPmFjdGl2ZSkpCiAgICAgICAg cmV0dXJuIElSUV9OT05FOwogICAgLyogcHJlZW1wdGVkIGhlcmUgKi8KCkFuZCBjcGNhcF91c2Jf cGh5X3JlbW92ZSgpIGNvbXBsZXRlcywgc2V0dGluZyBkZGF0YS0+YWN0aXZlID0gMCwgY2FuY2Vs aW5nIHRoZQp3b3JrLCBhbmQgYWxsb3dpbmcgZGV2cmVzIHRvIGZyZWUgZGRhdGE6CgpjcGNhcF91 c2JfcGh5X3JlbW92ZSgpIHsKICAgIGF0b21pY19zZXQoJmRkYXRhLT5hY3RpdmUsIDApOwogICAg Y2FuY2VsX2RlbGF5ZWRfd29ya19zeW5jKCZkZGF0YS0+ZGV0ZWN0X3dvcmspOwogICAgLi4uCn0K LyogZGV2cmVzIGZyZWVzIGRkYXRhICovCgpDb3VsZCB0aGUgSVJRIHRocmVhZCB0aGVuIHJlc3Vt ZSBhbmQgY2FsbCBzY2hlZHVsZV9kZWxheWVkX3dvcmsoKSBvbiB0aGUgZnJlZWQKZGRhdGE/Cgot LSAKU2FzaGlrbyBBSSByZXZpZXcgwrcgaHR0cHM6Ly9zYXNoaWtvLmRldi8jL3BhdGNoc2V0LzIw MjYwNzExMTY0NzU0LjE4NTU2NS0xLWl2by5nLmRpbWl0cm92Ljc1QGdtYWlsLmNvbT9wYXJ0PTMK Ci0tIApsaW51eC1waHkgbWFpbGluZyBsaXN0CmxpbnV4LXBoeUBsaXN0cy5pbmZyYWRlYWQub3Jn Cmh0dHBzOi8vbGlzdHMuaW5mcmFkZWFkLm9yZy9tYWlsbWFuL2xpc3RpbmZvL2xpbnV4LXBoeQo=