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 92A20399350 for ; Sat, 4 Jul 2026 07:49:52 +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=1783151397; cv=none; b=gCKSODL2pe6bQrw5BcBLqWkAwrdY8XiuLeXaKSNtOPwU8u3KD9ML7drMOyjEydpbB5uUg38VKXcs1Rydyc1F13VkeIx/YU+vL28atKkPGeZT701nPiX2yJ90fVikEnDKOAnak+YoC1R+i4SNlQqZvXtc+6sCrHmLD4roVfHEbyg= ARC-Message-Signature:i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1783151397; c=relaxed/simple; bh=Rn7LRc990GU1vst3MZaGXHWtC+gGdAumo3leUtKbLmg=; h=From:Subject:To:Cc:In-Reply-To:References:Content-Type:Date: Message-Id; b=gzG6shZla0Crm/UF7VzaYuEa2pL2pw0Yrf4GjYgFarlvCkMi36ah26ewwTbPVxevGIFbMmQ7MFbwcxW6vqbC63nJoy6c/objZ8cM098gw3qgysYpoVo+3xHEqnFp3bBVtN4Gf1wAicjKiJVy7Uz6bqwX4C6RYjmOYNY3ed8LfQU= ARC-Authentication-Results:i=1; smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b=CQv0mmAN; 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="CQv0mmAN" Received: by smtp.kernel.org (Postfix) with ESMTPSA id 7FED61F000E9; Sat, 4 Jul 2026 07:49:49 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=kernel.org; s=k20260515; t=1783151389; bh=n0VFtWrzUPum8j12EUWnnxF4s1y6ma75vn5DbOOD1EE=; h=From:Subject:Reply-To:To:Cc:In-Reply-To:References:Date; b=CQv0mmANfCkYGfeg0GVPmELxK7R0xmSL+uG/lm0zh7bRHVdKLZZnRpEa2keRjq8sD GoyjPRtk2qgtlEJgVxhIspUCuEW8PtNMz7Cdjmo2fHyFOCBgXfm7O1FyRRuwTekudd SAqdJGNYK4+9cuF6MjZY6nopJqfEUjTPLUgjxZRlG6cSZTweqK0QVB9piQaKthd43r dPUACF7zzHVoe0Gyua333p0zyw0+BZ/7URug0uBdAFEx5Idz93fTIg3ONv/lBPm0o0 jog2KJrUVG6/BiqjaXECe2stN+51DqvaT2pfYjjEzhlTWyxZRh/aiOFT6Sc9jHGR15 YkOHiAtJ5U1Lg== From: sashiko-bot@kernel.org Subject: Re: [PATCH 2/5] 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, neil.armstrong@linaro.org, olteanv@gmail.com, vkoul@kernel.org, linux-phy@lists.infradead.org In-Reply-To: <20260704073843.1750458-3-ivo.g.dimitrov.75@gmail.com> References: <20260704073843.1750458-1-ivo.g.dimitrov.75@gmail.com> <20260704073843.1750458-3-ivo.g.dimitrov.75@gmail.com> Content-Type: text/plain; charset=utf-8 Content-Transfer-Encoding: quoted-printable Date: Sat, 04 Jul 2026 07:49:49 +0000 Message-Id: <20260704074949.7FED61F000E9@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 6 potential issue(= s) to consider: New issues: - [High] Renaming the expected IRQ name from 'se1' to 'chrg_det' breaks com= patibility with existing Device Tree binaries. - [Medium] Early update of `ddata->mode` causes the state machine to become= permanently stuck if the subsequent hardware configuration fails. - [Medium] The system's SysRq functionality is permanently left disabled gl= obally if a hardware configuration step fails in `cpcap_usb_set_idle_mode()= `. - [Medium] The module parameter `enable_uart` is ignored on boot, leaving t= he PHY in a partially uninitialized state. - [Medium] A Time-of-Check to Time-of-Use (TOCTOU) race condition exists wh= en reading the global `cpcap_enable_uart` module parameter. Pre-existing issues: - [Critical] A race condition during driver removal allows the devm-managed= threaded IRQ handler to schedule `detect_work` after it has been canceled,= leading to a Use-After-Free. -- commit e8047562da705a40f07fe646c6694386f4dad156 Author: Ivaylo Dimitrov phy: cpcap-usb: add DCP detection and make UART idle mode optional =20 Handle DCP separately from USB host connections based on CPCAP charger detection status. =20 Make the existing idle UART mode optional via the "enable_uart" module parameter. When disabled, the PHY remains in its USB/charger detection configuration while idle. This reduces power usage in idle by 25mW. =20 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 c6cc8fce6940f..3be2b3afaaf4d 100644 > --- a/drivers/phy/motorola/phy-cpcap-usb.c > +++ b/drivers/phy/motorola/phy-cpcap-usb.c > @@ -296,36 +309,53 @@ static void cpcap_usb_detect(struct work_struct *wo= rk) > return; > } > =20 > vbus =3D cpcap_usb_vbus_valid(ddata); > =20 > - /* Otherwise assume we're connected to a USB host */ > - if (vbus) { > - dev_dbg(ddata->dev, "connected to USB host\n"); > - error =3D cpcap_usb_set_usb_mode(ddata); > + /* Check if we're connected to a USB host */ > + if (vbus && ddata->mode !=3D CPCAP_USB_HOST) { > + if (!s.chrg_det || !s.sessvld || ddata->mode !=3D CPCAP_IDLE) > + return; > + > + if (s.se1) > + ddata->mode =3D CPCAP_CHARGER; > + else if (!s.dm && !s.dp) > + ddata->mode =3D CPCAP_USB; > + else > + return; [Severity: Medium] Can the state machine become permanently stuck if the subsequent hardware configuration fails? The state variable ddata->mode is eagerly updated here to CPCAP_CHARGER or CPCAP_USB before applying the hardware state via cpcap_usb_set_usb_mode(). If the configuration fails and returns early, the state is never reverted. On the next evaluation, the condition checking ddata->mode !=3D CPCAP_IDLE will evaluate to true and return immediately, preventing recovery until the cable is physically unplugged. > + > + dev_dbg(ddata->dev, "connected to %s\n", > + s.se1 ? "DCP" : "USB host"); > + > + error =3D regmap_update_bits(ddata->reg, CPCAP_REG_USBC3, > + CPCAP_BIT_VBUSSTBY_EN | > + CPCAP_BIT_VBUSEN_SPI, 0); > if (error) > goto out_err; > - cpcap_usb_try_musb_mailbox(ddata, MUSB_VBUS_VALID); > + > + if (ddata->mode =3D=3D CPCAP_CHARGER) > + error =3D cpcap_usb_set_dcp_mode(ddata); > + else > + error =3D cpcap_usb_set_usb_mode(ddata); > + > + if (error) > + goto out_err; > + > + if (ddata->mode =3D=3D CPCAP_USB) > + cpcap_usb_try_musb_mailbox(ddata, MUSB_VBUS_VALID); > =20 > return; > } > =20 > - ddata->vbus_provider =3D false; > - ddata->docked =3D false; > + if (ddata->mode =3D=3D CPCAP_IDLE) > + return; [Severity: Medium] Does this early return prevent the enable_uart module parameter from being applied on boot? During initial probe, ddata->mode is zero-initialized to CPCAP_IDLE. When cpcap_usb_detect() runs for the first time, it exits early here and complet= ely skips cpcap_usb_set_idle_mode(). This leaves the PHY in a partially uninitialized state until a cable is attached and removed. > + > + ddata->mode =3D CPCAP_IDLE; > cpcap_usb_try_musb_mailbox(ddata, MUSB_VBUS_OFF); > =20 > - /* Default to debug UART mode */ > - error =3D cpcap_usb_set_uart_mode(ddata); > + error =3D cpcap_usb_set_idle_mode(ddata); > if (error) > goto out_err; [ ... ] > @@ -374,7 +404,7 @@ static const char * const cpcap_phy_irqs[] =3D { > "id_ground", "id_float", > =20 > /* REG_INT1 */ > - "se0conn", "vbusvld", "sessvld", "sessend", "se1", > + "se0conn", "vbusvld", "sessvld", "sessend", "chrg_det", [Severity: High] Does this break compatibility with existing Device Tree binaries? The driver now strictly requests the "chrg_det" interrupt by name, but older DTBs only provide "se1". Without a fallback to check for the old name, cpcap_usb_init_irq() will return -ENODEV and abort the probe. [ ... ] > @@ -426,30 +457,52 @@ static int cpcap_usb_set_uart_mode(struct cpcap_phy= _ddata *ddata) > if (error) > goto out_err; > =20 > - if (ddata->pins_uart) { > - error =3D pinctrl_select_state(ddata->pins, ddata->pins_uart); > + if (cpcap_enable_uart && ddata->pins_uart) { [Severity: Medium] Can a race condition occur when reading the global cpcap_enable_uart module parameter? Since it is modifiable via sysfs and evaluated multiple times independently within cpcap_usb_set_idle_mode(), a concurrent write could change its value mid-execution. This might result in a mismatched configuration, such as setting UART pinctrl but then improperly applying SUSPEND_SPI later in the function. > + error =3D pinctrl_select_state(ddata->pins, ddata->pins_uart); > + if (error) > + goto out_err; > + } else if (!cpcap_enable_uart && ddata->pins_ulpi) { > + error =3D pinctrl_select_state(ddata->pins, ddata->pins_ulpi); > if (error) > goto out_err; > } [ ... ] > @@ -457,6 +510,8 @@ static int cpcap_usb_set_uart_mode(struct cpcap_phy_d= data *ddata) > if (sysrq & 1) > sysrq_toggle_support(sysrq); > =20 > + dev_dbg(ddata->dev, "set %s mode\n", cpcap_enable_uart ? "UART" : "IDLE= "); > + > return 0; > =20 > out_err: > + dev_err(ddata->dev, "%s failed with %i\n", __func__, error); > + > + return error; > +} [Severity: Medium] Is it possible for the system's SysRq functionality to be permanently left disabled on an error path? In cpcap_usb_set_idle_mode(), sysrq is disabled to prevent line glitches. If any subsequent hardware configuration step fails, the function jumps to = the out_err label here and returns without restoring the original sysrq state v= ia sysrq_toggle_support(). [ ... ] > @@ -697,13 +848,9 @@ static int cpcap_usb_phy_probe(struct platform_devic= e *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"); > - > + cpcap_usb_set_idle_mode(ddata); > cpcap_usb_try_musb_mailbox(ddata, MUSB_VBUS_OFF); > =20 > usb_remove_phy(&ddata->phy); [Severity: Critical] This is a pre-existing issue, but does a race condition exist during driver removal that allows the devm-managed threaded IRQ handler to schedule detect_work after it has been canceled? Because the IRQ is devm-managed, it is still active when cancel_delayed_work_sync() is called at the end of cpcap_usb_phy_remove(). If the IRQ thread in cpcap_phy_irq_thread() evaluates ddata->active !=3D 0 before it is cleared, but is preempted before calling schedule_delayed_work= (), the remove function can finish and cancel the work. Devres will then wait for the preempted IRQ thread to finish. The thread wi= ll resume and schedule the delayed work, and devres will then free ddata. When the timer expires, the workqueue will execute cpcap_usb_detect() using the freed ddata. --=20 Sashiko AI review =C2=B7 https://sashiko.dev/#/patchset/20260704073843.1750= 458-1-ivo.g.dimitrov.75@gmail.com?part=3D2 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 A933FC43458 for ; Sat, 4 Jul 2026 07:49:52 +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=3xMrvLFrHCVMDIKpa0grA2Ex+Wjg5ApPmydSSPXvmbA=; b=SMUsQQbqNO6RlO fwcYm8NYSFdh90hZoDoCTI3hQDFL8TG445rLpa7+bhQM+kKpqcQ14tZnn5vJ6ByR8NL/lSiev3Oqe EvABnHom4mo13iOEEOcdumwOKZhor61XebESc5Q5jHWBSP58iluXY0xnnl90LuEbhPyGuhLUZ1Dtk oJzGQlmT7ziV/d76VkpNIOc8ID7/6VzlcGfKD1AlZTM4RNS4rjzcfRXAjYt9BahUoZKvgOO0sF12b ID81QqXtpi98o2ZkNEFTh0AEP3bfkZuO1h5vRatbJT7ewIceuJE85ZOiS/WshQjoAMmwzzoF4Prmt KhS9OA0oCDc0n3sd9oiw==; Received: from localhost ([::1] helo=bombadil.infradead.org) by bombadil.infradead.org with esmtp (Exim 4.99.1 #2 (Red Hat Linux)) id 1wfv8K-00000008Gzu-1ALD; Sat, 04 Jul 2026 07:49:52 +0000 Received: from tor.source.kernel.org ([2600:3c04:e001:324:0:1991:8:25]) by bombadil.infradead.org with esmtps (Exim 4.99.1 #2 (Red Hat Linux)) id 1wfv8I-00000008Gzo-3BkF for linux-phy@lists.infradead.org; Sat, 04 Jul 2026 07:49:50 +0000 Received: from smtp.kernel.org (quasi.space.kernel.org [100.103.45.18]) by tor.source.kernel.org (Postfix) with ESMTP id 3BBD660052; Sat, 4 Jul 2026 07:49:50 +0000 (UTC) Received: by smtp.kernel.org (Postfix) with ESMTPSA id 7FED61F000E9; Sat, 4 Jul 2026 07:49:49 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=kernel.org; s=k20260515; t=1783151389; bh=n0VFtWrzUPum8j12EUWnnxF4s1y6ma75vn5DbOOD1EE=; h=From:Subject:Reply-To:To:Cc:In-Reply-To:References:Date; b=CQv0mmANfCkYGfeg0GVPmELxK7R0xmSL+uG/lm0zh7bRHVdKLZZnRpEa2keRjq8sD GoyjPRtk2qgtlEJgVxhIspUCuEW8PtNMz7Cdjmo2fHyFOCBgXfm7O1FyRRuwTekudd SAqdJGNYK4+9cuF6MjZY6nopJqfEUjTPLUgjxZRlG6cSZTweqK0QVB9piQaKthd43r dPUACF7zzHVoe0Gyua333p0zyw0+BZ/7URug0uBdAFEx5Idz93fTIg3ONv/lBPm0o0 jog2KJrUVG6/BiqjaXECe2stN+51DqvaT2pfYjjEzhlTWyxZRh/aiOFT6Sc9jHGR15 YkOHiAtJ5U1Lg== From: sashiko-bot@kernel.org Subject: Re: [PATCH 2/5] 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, neil.armstrong@linaro.org, olteanv@gmail.com, vkoul@kernel.org, linux-phy@lists.infradead.org In-Reply-To: <20260704073843.1750458-3-ivo.g.dimitrov.75@gmail.com> References: <20260704073843.1750458-1-ivo.g.dimitrov.75@gmail.com> <20260704073843.1750458-3-ivo.g.dimitrov.75@gmail.com> Date: Sat, 04 Jul 2026 07:49:49 +0000 Message-Id: <20260704074949.7FED61F000E9@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 NiBwb3RlbnRpYWwgaXNzdWUocykgdG8gY29uc2lkZXI6CgpOZXcgaXNzdWVzOgotIFtIaWdoXSBS ZW5hbWluZyB0aGUgZXhwZWN0ZWQgSVJRIG5hbWUgZnJvbSAnc2UxJyB0byAnY2hyZ19kZXQnIGJy ZWFrcyBjb21wYXRpYmlsaXR5IHdpdGggZXhpc3RpbmcgRGV2aWNlIFRyZWUgYmluYXJpZXMuCi0g W01lZGl1bV0gRWFybHkgdXBkYXRlIG9mIGBkZGF0YS0+bW9kZWAgY2F1c2VzIHRoZSBzdGF0ZSBt YWNoaW5lIHRvIGJlY29tZSBwZXJtYW5lbnRseSBzdHVjayBpZiB0aGUgc3Vic2VxdWVudCBoYXJk d2FyZSBjb25maWd1cmF0aW9uIGZhaWxzLgotIFtNZWRpdW1dIFRoZSBzeXN0ZW0ncyBTeXNScSBm dW5jdGlvbmFsaXR5IGlzIHBlcm1hbmVudGx5IGxlZnQgZGlzYWJsZWQgZ2xvYmFsbHkgaWYgYSBo YXJkd2FyZSBjb25maWd1cmF0aW9uIHN0ZXAgZmFpbHMgaW4gYGNwY2FwX3VzYl9zZXRfaWRsZV9t b2RlKClgLgotIFtNZWRpdW1dIFRoZSBtb2R1bGUgcGFyYW1ldGVyIGBlbmFibGVfdWFydGAgaXMg aWdub3JlZCBvbiBib290LCBsZWF2aW5nIHRoZSBQSFkgaW4gYSBwYXJ0aWFsbHkgdW5pbml0aWFs aXplZCBzdGF0ZS4KLSBbTWVkaXVtXSBBIFRpbWUtb2YtQ2hlY2sgdG8gVGltZS1vZi1Vc2UgKFRP Q1RPVSkgcmFjZSBjb25kaXRpb24gZXhpc3RzIHdoZW4gcmVhZGluZyB0aGUgZ2xvYmFsIGBjcGNh cF9lbmFibGVfdWFydGAgbW9kdWxlIHBhcmFtZXRlci4KClByZS1leGlzdGluZyBpc3N1ZXM6Ci0g W0NyaXRpY2FsXSBBIHJhY2UgY29uZGl0aW9uIGR1cmluZyBkcml2ZXIgcmVtb3ZhbCBhbGxvd3Mg dGhlIGRldm0tbWFuYWdlZCB0aHJlYWRlZCBJUlEgaGFuZGxlciB0byBzY2hlZHVsZSBgZGV0ZWN0 X3dvcmtgIGFmdGVyIGl0IGhhcyBiZWVuIGNhbmNlbGVkLCBsZWFkaW5nIHRvIGEgVXNlLUFmdGVy LUZyZWUuCi0tCgpjb21taXQgZTgwNDc1NjJkYTcwNWE0MGYwN2ZlNjQ2YzY2OTQzODZmNGRhZDE1 NgpBdXRob3I6IEl2YXlsbyBEaW1pdHJvdiA8aXZvLmcuZGltaXRyb3YuNzVAZ21haWwuY29tPgoK cGh5OiBjcGNhcC11c2I6IGFkZCBEQ1AgZGV0ZWN0aW9uIGFuZCBtYWtlIFVBUlQgaWRsZSBtb2Rl IG9wdGlvbmFsCiAgICAKSGFuZGxlIERDUCBzZXBhcmF0ZWx5IGZyb20gVVNCIGhvc3QgY29ubmVj dGlvbnMgYmFzZWQgb24gQ1BDQVAgY2hhcmdlcgpkZXRlY3Rpb24gc3RhdHVzLgogICAgCk1ha2Ug dGhlIGV4aXN0aW5nIGlkbGUgVUFSVCBtb2RlIG9wdGlvbmFsIHZpYSB0aGUgImVuYWJsZV91YXJ0 IiBtb2R1bGUKcGFyYW1ldGVyLiBXaGVuIGRpc2FibGVkLCB0aGUgUEhZIHJlbWFpbnMgaW4gaXRz IFVTQi9jaGFyZ2VyIGRldGVjdGlvbgpjb25maWd1cmF0aW9uIHdoaWxlIGlkbGUuIFRoaXMgcmVk dWNlcyBwb3dlciB1c2FnZSBpbiBpZGxlIGJ5IDI1bVcuCiAgICAKQWxzbyBpbml0aWFsaXplIHRo ZSBQSFkgaW50byB0aGUgYmFzZWxpbmUgY29uZmlndXJhdGlvbiByZXF1aXJlZCBmb3IKcmVsaWFi bGUgY2hhcmdlciBkZXRlY3Rpb24gZHVyaW5nIHByb2JlLgoKPiBkaWZmIC0tZ2l0IGEvZHJpdmVy cy9waHkvbW90b3JvbGEvcGh5LWNwY2FwLXVzYi5jIGIvZHJpdmVycy9waHkvbW90b3JvbGEvcGh5 LWNwY2FwLXVzYi5jCj4gaW5kZXggYzZjYzhmY2U2OTQwZi4uM2JlMmIzYWZhYWY0ZCAxMDA2NDQK PiAtLS0gYS9kcml2ZXJzL3BoeS9tb3Rvcm9sYS9waHktY3BjYXAtdXNiLmMKPiArKysgYi9kcml2 ZXJzL3BoeS9tb3Rvcm9sYS9waHktY3BjYXAtdXNiLmMKPiBAQCAtMjk2LDM2ICszMDksNTMgQEAg c3RhdGljIHZvaWQgY3BjYXBfdXNiX2RldGVjdChzdHJ1Y3Qgd29ya19zdHJ1Y3QgKndvcmspCj4g IAkJcmV0dXJuOwo+ICAJfQo+ICAKPiAgCXZidXMgPSBjcGNhcF91c2JfdmJ1c192YWxpZChkZGF0 YSk7Cj4gIAo+IC0JLyogT3RoZXJ3aXNlIGFzc3VtZSB3ZSdyZSBjb25uZWN0ZWQgdG8gYSBVU0Ig aG9zdCAqLwo+IC0JaWYgKHZidXMpIHsKPiAtCQlkZXZfZGJnKGRkYXRhLT5kZXYsICJjb25uZWN0 ZWQgdG8gVVNCIGhvc3RcbiIpOwo+IC0JCWVycm9yID0gY3BjYXBfdXNiX3NldF91c2JfbW9kZShk ZGF0YSk7Cj4gKwkvKiBDaGVjayBpZiB3ZSdyZSBjb25uZWN0ZWQgdG8gYSBVU0IgaG9zdCAqLwo+ ICsJaWYgKHZidXMgJiYgZGRhdGEtPm1vZGUgIT0gQ1BDQVBfVVNCX0hPU1QpIHsKPiArCQlpZiAo IXMuY2hyZ19kZXQgfHwgIXMuc2Vzc3ZsZCB8fCBkZGF0YS0+bW9kZSAhPSBDUENBUF9JRExFKQo+ ICsJCQlyZXR1cm47Cj4gKwo+ICsJCWlmIChzLnNlMSkKPiArCQkJZGRhdGEtPm1vZGUgPSBDUENB UF9DSEFSR0VSOwo+ICsJCWVsc2UgaWYgKCFzLmRtICYmICFzLmRwKQo+ICsJCQlkZGF0YS0+bW9k ZSA9IENQQ0FQX1VTQjsKPiArCQllbHNlCj4gKwkJCXJldHVybjsKCltTZXZlcml0eTogTWVkaXVt XQpDYW4gdGhlIHN0YXRlIG1hY2hpbmUgYmVjb21lIHBlcm1hbmVudGx5IHN0dWNrIGlmIHRoZSBz dWJzZXF1ZW50IGhhcmR3YXJlCmNvbmZpZ3VyYXRpb24gZmFpbHM/CgpUaGUgc3RhdGUgdmFyaWFi bGUgZGRhdGEtPm1vZGUgaXMgZWFnZXJseSB1cGRhdGVkIGhlcmUgdG8gQ1BDQVBfQ0hBUkdFUiBv cgpDUENBUF9VU0IgYmVmb3JlIGFwcGx5aW5nIHRoZSBoYXJkd2FyZSBzdGF0ZSB2aWEgY3BjYXBf dXNiX3NldF91c2JfbW9kZSgpLgpJZiB0aGUgY29uZmlndXJhdGlvbiBmYWlscyBhbmQgcmV0dXJu cyBlYXJseSwgdGhlIHN0YXRlIGlzIG5ldmVyIHJldmVydGVkLgoKT24gdGhlIG5leHQgZXZhbHVh dGlvbiwgdGhlIGNvbmRpdGlvbiBjaGVja2luZyBkZGF0YS0+bW9kZSAhPSBDUENBUF9JRExFCndp bGwgZXZhbHVhdGUgdG8gdHJ1ZSBhbmQgcmV0dXJuIGltbWVkaWF0ZWx5LCBwcmV2ZW50aW5nIHJl Y292ZXJ5IHVudGlsIHRoZQpjYWJsZSBpcyBwaHlzaWNhbGx5IHVucGx1Z2dlZC4KCj4gKwo+ICsJ CWRldl9kYmcoZGRhdGEtPmRldiwgImNvbm5lY3RlZCB0byAlc1xuIiwKPiArCQkJcy5zZTEgPyAi RENQIiA6ICJVU0IgaG9zdCIpOwo+ICsKPiArCQllcnJvciA9IHJlZ21hcF91cGRhdGVfYml0cyhk ZGF0YS0+cmVnLCBDUENBUF9SRUdfVVNCQzMsCj4gKwkJCQkJICAgQ1BDQVBfQklUX1ZCVVNTVEJZ X0VOIHwKPiArCQkJCQkgICBDUENBUF9CSVRfVkJVU0VOX1NQSSwgMCk7Cj4gIAkJaWYgKGVycm9y KQo+ICAJCQlnb3RvIG91dF9lcnI7Cj4gLQkJY3BjYXBfdXNiX3RyeV9tdXNiX21haWxib3goZGRh dGEsIE1VU0JfVkJVU19WQUxJRCk7Cj4gKwo+ICsJCWlmIChkZGF0YS0+bW9kZSA9PSBDUENBUF9D SEFSR0VSKQo+ICsJCQllcnJvciA9IGNwY2FwX3VzYl9zZXRfZGNwX21vZGUoZGRhdGEpOwo+ICsJ CWVsc2UKPiArCQkJZXJyb3IgPSBjcGNhcF91c2Jfc2V0X3VzYl9tb2RlKGRkYXRhKTsKPiArCj4g KwkJaWYgKGVycm9yKQo+ICsJCQlnb3RvIG91dF9lcnI7Cj4gKwo+ICsJCWlmIChkZGF0YS0+bW9k ZSA9PSBDUENBUF9VU0IpCj4gKwkJCWNwY2FwX3VzYl90cnlfbXVzYl9tYWlsYm94KGRkYXRhLCBN VVNCX1ZCVVNfVkFMSUQpOwo+ICAKPiAgCQlyZXR1cm47Cj4gIAl9Cj4gIAo+IC0JZGRhdGEtPnZi dXNfcHJvdmlkZXIgPSBmYWxzZTsKPiAtCWRkYXRhLT5kb2NrZWQgPSBmYWxzZTsKPiArCWlmIChk ZGF0YS0+bW9kZSA9PSBDUENBUF9JRExFKQo+ICsJCXJldHVybjsKCltTZXZlcml0eTogTWVkaXVt XQpEb2VzIHRoaXMgZWFybHkgcmV0dXJuIHByZXZlbnQgdGhlIGVuYWJsZV91YXJ0IG1vZHVsZSBw YXJhbWV0ZXIgZnJvbSBiZWluZwphcHBsaWVkIG9uIGJvb3Q/CgpEdXJpbmcgaW5pdGlhbCBwcm9i ZSwgZGRhdGEtPm1vZGUgaXMgemVyby1pbml0aWFsaXplZCB0byBDUENBUF9JRExFLiBXaGVuCmNw Y2FwX3VzYl9kZXRlY3QoKSBydW5zIGZvciB0aGUgZmlyc3QgdGltZSwgaXQgZXhpdHMgZWFybHkg aGVyZSBhbmQgY29tcGxldGVseQpza2lwcyBjcGNhcF91c2Jfc2V0X2lkbGVfbW9kZSgpLiBUaGlz IGxlYXZlcyB0aGUgUEhZIGluIGEgcGFydGlhbGx5CnVuaW5pdGlhbGl6ZWQgc3RhdGUgdW50aWwg YSBjYWJsZSBpcyBhdHRhY2hlZCBhbmQgcmVtb3ZlZC4KCj4gKwo+ICsJZGRhdGEtPm1vZGUgPSBD UENBUF9JRExFOwo+ICAJY3BjYXBfdXNiX3RyeV9tdXNiX21haWxib3goZGRhdGEsIE1VU0JfVkJV U19PRkYpOwo+ICAKPiAtCS8qIERlZmF1bHQgdG8gZGVidWcgVUFSVCBtb2RlICovCj4gLQllcnJv ciA9IGNwY2FwX3VzYl9zZXRfdWFydF9tb2RlKGRkYXRhKTsKPiArCWVycm9yID0gY3BjYXBfdXNi X3NldF9pZGxlX21vZGUoZGRhdGEpOwo+ICAJaWYgKGVycm9yKQo+ICAJCWdvdG8gb3V0X2VycjsK ClsgLi4uIF0KCj4gQEAgLTM3NCw3ICs0MDQsNyBAQCBzdGF0aWMgY29uc3QgY2hhciAqIGNvbnN0 IGNwY2FwX3BoeV9pcnFzW10gPSB7Cj4gIAkiaWRfZ3JvdW5kIiwgImlkX2Zsb2F0IiwKPiAgCj4g IAkvKiBSRUdfSU5UMSAqLwo+IC0JInNlMGNvbm4iLCAidmJ1c3ZsZCIsICJzZXNzdmxkIiwgInNl c3NlbmQiLCAic2UxIiwKPiArCSJzZTBjb25uIiwgInZidXN2bGQiLCAic2Vzc3ZsZCIsICJzZXNz ZW5kIiwgImNocmdfZGV0IiwKCltTZXZlcml0eTogSGlnaF0KRG9lcyB0aGlzIGJyZWFrIGNvbXBh dGliaWxpdHkgd2l0aCBleGlzdGluZyBEZXZpY2UgVHJlZSBiaW5hcmllcz8KClRoZSBkcml2ZXIg bm93IHN0cmljdGx5IHJlcXVlc3RzIHRoZSAiY2hyZ19kZXQiIGludGVycnVwdCBieSBuYW1lLCBi dXQgb2xkZXIKRFRCcyBvbmx5IHByb3ZpZGUgInNlMSIuIFdpdGhvdXQgYSBmYWxsYmFjayB0byBj aGVjayBmb3IgdGhlIG9sZCBuYW1lLApjcGNhcF91c2JfaW5pdF9pcnEoKSB3aWxsIHJldHVybiAt RU5PREVWIGFuZCBhYm9ydCB0aGUgcHJvYmUuCgpbIC4uLiBdCgo+IEBAIC00MjYsMzAgKzQ1Nyw1 MiBAQCBzdGF0aWMgaW50IGNwY2FwX3VzYl9zZXRfdWFydF9tb2RlKHN0cnVjdCBjcGNhcF9waHlf ZGRhdGEgKmRkYXRhKQo+ICAJaWYgKGVycm9yKQo+ICAJCWdvdG8gb3V0X2VycjsKPiAgCj4gLQlp ZiAoZGRhdGEtPnBpbnNfdWFydCkgewo+IC0JCWVycm9yID0gcGluY3RybF9zZWxlY3Rfc3RhdGUo ZGRhdGEtPnBpbnMsIGRkYXRhLT5waW5zX3VhcnQpOwo+ICsJaWYgKGNwY2FwX2VuYWJsZV91YXJ0 ICYmIGRkYXRhLT5waW5zX3VhcnQpIHsKCltTZXZlcml0eTogTWVkaXVtXQpDYW4gYSByYWNlIGNv bmRpdGlvbiBvY2N1ciB3aGVuIHJlYWRpbmcgdGhlIGdsb2JhbCBjcGNhcF9lbmFibGVfdWFydCBt b2R1bGUKcGFyYW1ldGVyPwoKU2luY2UgaXQgaXMgbW9kaWZpYWJsZSB2aWEgc3lzZnMgYW5kIGV2 YWx1YXRlZCBtdWx0aXBsZSB0aW1lcyBpbmRlcGVuZGVudGx5CndpdGhpbiBjcGNhcF91c2Jfc2V0 X2lkbGVfbW9kZSgpLCBhIGNvbmN1cnJlbnQgd3JpdGUgY291bGQgY2hhbmdlIGl0cyB2YWx1ZQpt aWQtZXhlY3V0aW9uLiBUaGlzIG1pZ2h0IHJlc3VsdCBpbiBhIG1pc21hdGNoZWQgY29uZmlndXJh dGlvbiwgc3VjaCBhcwpzZXR0aW5nIFVBUlQgcGluY3RybCBidXQgdGhlbiBpbXByb3Blcmx5IGFw cGx5aW5nIFNVU1BFTkRfU1BJIGxhdGVyIGluIHRoZQpmdW5jdGlvbi4KCj4gKwkJZXJyb3IgPSBw aW5jdHJsX3NlbGVjdF9zdGF0ZShkZGF0YS0+cGlucywgIGRkYXRhLT5waW5zX3VhcnQpOwo+ICsJ CWlmIChlcnJvcikKPiArCQkJZ290byBvdXRfZXJyOwo+ICsJfSBlbHNlIGlmICghY3BjYXBfZW5h YmxlX3VhcnQgJiYgZGRhdGEtPnBpbnNfdWxwaSkgewo+ICsJCWVycm9yID0gcGluY3RybF9zZWxl Y3Rfc3RhdGUoZGRhdGEtPnBpbnMsIGRkYXRhLT5waW5zX3VscGkpOwo+ICAJCWlmIChlcnJvcikK PiAgCQkJZ290byBvdXRfZXJyOwo+ICAJfQoKWyAuLi4gXQoKPiBAQCAtNDU3LDYgKzUxMCw4IEBA IHN0YXRpYyBpbnQgY3BjYXBfdXNiX3NldF91YXJ0X21vZGUoc3RydWN0IGNwY2FwX3BoeV9kZGF0 YSAqZGRhdGEpCj4gIAlpZiAoc3lzcnEgJiAxKQo+ICAJCXN5c3JxX3RvZ2dsZV9zdXBwb3J0KHN5 c3JxKTsKPiAgCj4gKwlkZXZfZGJnKGRkYXRhLT5kZXYsICJzZXQgJXMgbW9kZVxuIiwgY3BjYXBf ZW5hYmxlX3VhcnQgPyAiVUFSVCIgOiAiSURMRSIpOwo+ICsKPiAgCXJldHVybiAwOwo+ICAKPiAg b3V0X2VycjoKPiArCWRldl9lcnIoZGRhdGEtPmRldiwgIiVzIGZhaWxlZCB3aXRoICVpXG4iLCBf X2Z1bmNfXywgZXJyb3IpOwo+ICsKPiArCXJldHVybiBlcnJvcjsKPiArfQoKW1NldmVyaXR5OiBN ZWRpdW1dCklzIGl0IHBvc3NpYmxlIGZvciB0aGUgc3lzdGVtJ3MgU3lzUnEgZnVuY3Rpb25hbGl0 eSB0byBiZSBwZXJtYW5lbnRseSBsZWZ0CmRpc2FibGVkIG9uIGFuIGVycm9yIHBhdGg/CgpJbiBj cGNhcF91c2Jfc2V0X2lkbGVfbW9kZSgpLCBzeXNycSBpcyBkaXNhYmxlZCB0byBwcmV2ZW50IGxp bmUgZ2xpdGNoZXMuCklmIGFueSBzdWJzZXF1ZW50IGhhcmR3YXJlIGNvbmZpZ3VyYXRpb24gc3Rl cCBmYWlscywgdGhlIGZ1bmN0aW9uIGp1bXBzIHRvIHRoZQpvdXRfZXJyIGxhYmVsIGhlcmUgYW5k IHJldHVybnMgd2l0aG91dCByZXN0b3JpbmcgdGhlIG9yaWdpbmFsIHN5c3JxIHN0YXRlIHZpYQpz eXNycV90b2dnbGVfc3VwcG9ydCgpLgoKWyAuLi4gXQoKPiBAQCAtNjk3LDEzICs4NDgsOSBAQCBz dGF0aWMgaW50IGNwY2FwX3VzYl9waHlfcHJvYmUoc3RydWN0IHBsYXRmb3JtX2RldmljZSAqcGRl dikKPiAgc3RhdGljIHZvaWQgY3BjYXBfdXNiX3BoeV9yZW1vdmUoc3RydWN0IHBsYXRmb3JtX2Rl dmljZSAqcGRldikKPiAgewo+ICAJc3RydWN0IGNwY2FwX3BoeV9kZGF0YSAqZGRhdGEgPSBwbGF0 Zm9ybV9nZXRfZHJ2ZGF0YShwZGV2KTsKPiAtCWludCBlcnJvcjsKPiAgCj4gIAlhdG9taWNfc2V0 KCZkZGF0YS0+YWN0aXZlLCAwKTsKPiAtCWVycm9yID0gY3BjYXBfdXNiX3NldF91YXJ0X21vZGUo ZGRhdGEpOwo+IC0JaWYgKGVycm9yKQo+IC0JCWRldl9lcnIoZGRhdGEtPmRldiwgImNvdWxkIG5v dCBzZXQgVUFSVCBtb2RlXG4iKTsKPiAtCj4gKwljcGNhcF91c2Jfc2V0X2lkbGVfbW9kZShkZGF0 YSk7Cj4gIAljcGNhcF91c2JfdHJ5X211c2JfbWFpbGJveChkZGF0YSwgTVVTQl9WQlVTX09GRik7 Cj4gIAo+ICAJdXNiX3JlbW92ZV9waHkoJmRkYXRhLT5waHkpOwoKW1NldmVyaXR5OiBDcml0aWNh bF0KVGhpcyBpcyBhIHByZS1leGlzdGluZyBpc3N1ZSwgYnV0IGRvZXMgYSByYWNlIGNvbmRpdGlv biBleGlzdCBkdXJpbmcgZHJpdmVyCnJlbW92YWwgdGhhdCBhbGxvd3MgdGhlIGRldm0tbWFuYWdl ZCB0aHJlYWRlZCBJUlEgaGFuZGxlciB0byBzY2hlZHVsZQpkZXRlY3Rfd29yayBhZnRlciBpdCBo YXMgYmVlbiBjYW5jZWxlZD8KCkJlY2F1c2UgdGhlIElSUSBpcyBkZXZtLW1hbmFnZWQsIGl0IGlz IHN0aWxsIGFjdGl2ZSB3aGVuCmNhbmNlbF9kZWxheWVkX3dvcmtfc3luYygpIGlzIGNhbGxlZCBh dCB0aGUgZW5kIG9mIGNwY2FwX3VzYl9waHlfcmVtb3ZlKCkuCgpJZiB0aGUgSVJRIHRocmVhZCBp biBjcGNhcF9waHlfaXJxX3RocmVhZCgpIGV2YWx1YXRlcyBkZGF0YS0+YWN0aXZlICE9IDAKYmVm b3JlIGl0IGlzIGNsZWFyZWQsIGJ1dCBpcyBwcmVlbXB0ZWQgYmVmb3JlIGNhbGxpbmcgc2NoZWR1 bGVfZGVsYXllZF93b3JrKCksCnRoZSByZW1vdmUgZnVuY3Rpb24gY2FuIGZpbmlzaCBhbmQgY2Fu Y2VsIHRoZSB3b3JrLgoKRGV2cmVzIHdpbGwgdGhlbiB3YWl0IGZvciB0aGUgcHJlZW1wdGVkIElS USB0aHJlYWQgdG8gZmluaXNoLiBUaGUgdGhyZWFkIHdpbGwKcmVzdW1lIGFuZCBzY2hlZHVsZSB0 aGUgZGVsYXllZCB3b3JrLCBhbmQgZGV2cmVzIHdpbGwgdGhlbiBmcmVlIGRkYXRhLiBXaGVuCnRo ZSB0aW1lciBleHBpcmVzLCB0aGUgd29ya3F1ZXVlIHdpbGwgZXhlY3V0ZSBjcGNhcF91c2JfZGV0 ZWN0KCkgdXNpbmcgdGhlCmZyZWVkIGRkYXRhLgoKLS0gClNhc2hpa28gQUkgcmV2aWV3IMK3IGh0 dHBzOi8vc2FzaGlrby5kZXYvIy9wYXRjaHNldC8yMDI2MDcwNDA3Mzg0My4xNzUwNDU4LTEtaXZv LmcuZGltaXRyb3YuNzVAZ21haWwuY29tP3BhcnQ9MgoKLS0gCmxpbnV4LXBoeSBtYWlsaW5nIGxp c3QKbGludXgtcGh5QGxpc3RzLmluZnJhZGVhZC5vcmcKaHR0cHM6Ly9saXN0cy5pbmZyYWRlYWQu b3JnL21haWxtYW4vbGlzdGluZm8vbGludXgtcGh5Cg==