From mboxrd@z Thu Jan 1 00:00:00 1970 Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.remote-ip=100.103.45.18 ARC-Seal: i=1; d=subspace.kernel.org; s=arc20261015; a=rsa-sha256; cv=none; t=1793365672; b=SKCgWp2kHd5t1z7kWm/1FpWdcmpE1mkXzeKNUEbBi3v1HeBuhCbvL48h+WQgRhvKAvIo thPAgecE0kZqgdbTTgMhGYyllQ8ODctStgOrA9LMKFYDJCZt9snN2nbx07DcseO2/Mnzj ewDFQWgZ61b00HHidNEG00O7MR4c2+R8UEzRNI9ZpCD5dR9iTxD7k0FuQOExPd3QK/AwI xNEJBrmJ14z4+cwJDPR+OZS24XUw+5Dkb3kLLdo0jfMNEokz9p8BKmsY/ejpt+ZCxeAXl N/8WKOx4mY42nb7V2wFcCbW16lz/4VNruwmjXRFys5VeJP6wD4C1oSBrmLPkzDBPz6g== ARC-Message-Signature: i=1; d=subspace.kernel.org; s=arc20261015; a=rsa-sha256; c=relaxed/relaxed; t=1793365672; h=Received:DKIM-Signature:Message-ID:From:Subject:Reply-To:To:Cc: In-Reply-To:References:Content-Type:Content-Transfer-Encoding:Date; bh=JT+3LP+5QyAnCVRh6Qv6QLpMg9XRGcsCRkKadZAigA4=; b=RDHzwe1CfDIjGQYs6VSHxWcbPzOziPUSP3wnqb41dVJaRz8BXxIrW8GIDRxBgQvms2Qd HDYgL98kILuLsv/dInCtMzfCxJ9O8jsn6TmXhRnFO0gfTtDS6IWmQp27gLprKumJHjP0a 4JEH4J6E9fPAcbI8iX1iP3Lcvt4G5HAaUw3j5FdjavB8qKhl5qj6VQW5DJZJQuJ28Dh9w 2vaHVtnA25S6TVDrkmOPYNU+LA6D3m51FtuyfBB1fzhGSVzhhI7xEiFXaxULg2ivsGoHb YOiupf1uN5lvv1SmTlpsR05e+7+5sGsK+WOLT8XIMs3ZcSfxedfL5sLO8GMEScuR6xg== ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dkim=pass header.d=kernel.org header.i=@kernel.org header.a=rsa-sha256 header.s=k20260515 header.b=ZtjjYszc; arc=none smtp.remote-ip=100.103.45.18 Received: from smtp.kernel.org (quasi.space.kernel.org [100.103.45.18]) (using TLSv1.3 with cipher TLS_AES_256_GCM_SHA384 (256/256 bits) key-exchange X25519 server-signature ECDSA (prime256v1)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id B638B606A333 for ; Fri, 30 Oct 2026 13:07:51 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key, unprotected) header.d=kernel.org header.i=@kernel.org header.a=rsa-sha256 header.s=k20260515 header.b=ZtjjYszc Received: by smtp.kernel.org (Postfix) with ESMTPSA id EEE6D1F00A1D; Fri, 30 Oct 2026 13:07:50 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=kernel.org; s=k20260515; t=1793365671; bh=JT+3LP+5QyAnCVRh6Qv6QLpMg9XRGcsCRkKadZAigA4=; h=From:Subject:Reply-To:To:Cc:In-Reply-To:References:Date; b=ZtjjYszcVqxuNf1vJaZ5617YkWrVLiATvGy8kOq1LjUFiZHUbDkmLI9/1WSPDWgIq 9DAPfW8qRvTerOOtM4/L19CzLjdsl0/oCnIXg8/fdtfIaIKIYtGxpYhXaYuzbdRSbJ FTqSuVwACG4flQTj26aNzwXBv8I5+ueYbEA8feWRzpYNJxSpptzKAU9RgOSb06b7xV Ro9vNcXQVGfOgH9xvtgPENje5nKGVc0ngff2WxpQd2HVrmWZhuLhFsiv3neYoGmy2c +LKc0aL+3vBZv8kgD4GXqcZynMbI+Qgm8uhYHzgl7mwXA2Sb41j+d0OgXHA4Rc1fcO wEeiGKNSGxPtQ== Message-ID: From: sashiko-bot@kernel.org Subject: Re: [PATCH v3 5/5] media: qcom: camss: Add support for Hawi Reply-To: sashiko-reviews@lists.linux.dev To: "Nihal Kumar Gupta" Cc: devicetree@vger.kernel.org, linux-phy@lists.infradead.org, robh@kernel.org, conor+dt@kernel.org, media-ci@linuxtv.org, vkoul@kernel.org, neil.armstrong@linaro.org, olteanv@gmail.com In-Reply-To: <20261030-hawi-maili-camss-v3-5-9742bca8cef2@oss.qualcomm.com> References: <20261030-hawi-maili-camss-v3-0-9742bca8cef2@oss.qualcomm.com> <20261030-hawi-maili-camss-v3-5-9742bca8cef2@oss.qualcomm.com> Content-Type: text/plain; charset=utf-8 Content-Transfer-Encoding: quoted-printable Date: Fri, 30 Oct 2026 13:07:50 +0000 X-Mailing-List: devicetree@vger.kernel.org List-Id: List-Post: List-Help: List-Subscribe: List-Unsubscribe: List-Owner: Precedence: list Thank you for your contribution! Sashiko AI review found 6 potential issue(= s) to consider: - [High] media: qcom: camss: unconditional AUP strobes in csid_configure_st= ream() - [High] media: camss: NULL hw_ops deref in msm_csiphy_subdev_init_legacy() - [Medium] media: qcom: camss: wrong camnoc_rt_axi clock rates in vfe_res_h= awi - [Medium] media: qcom: camss: data race on csid->addr_update and csid->reg= _update - [Low] media: qcom: camss: duplicate CSID 1080 and VFE 1080 code in 1190 f= iles - [Low] media: qcom: camss: macros in camss-csid-1190.c implicitly capture = csid -- commit 25967aac8ac2c5b636dbbaab24c84dd484d99ab8 Author: Hangxiang Ma media: qcom: camss: Add support for Hawi This commit adds CAMSS support for the Hawi SoC, including CSID 1190 and VFE 1190 hardware operations and Hawi resource definitions. > diff --git a/drivers/media/platform/qcom/camss/camss-csid-1190.c b/driver= s/media/platform/qcom/camss/camss-csid-1190.c > new file mode 100644 > index 0000000000000..4bd2cce094402 > --- /dev/null > +++ b/drivers/media/platform/qcom/camss/camss-csid-1190.c > @@ -0,0 +1,417 @@ [ ... ] > +#define MSM_CSID_MAX_SRC_STREAMS_1190 (csid_is_lite(csid) ? 4 : 5) > + > +/* RDI Configuration */ > +#define CSID_RDI_CFG0(rdi) (csid_is_lite(csid) ?\ > + (0x3080 + 0x200 * (rdi)) :\ > + (0x5480 + 0x200 * (rdi))) > +#define RDI_CFG0_RETIME_BS BIT(5) > +#define RDI_CFG0_TIMESTAMP_EN BIT(6) > +#define RDI_CFG0_TIMESTAMP_STB_SEL BIT(8) > +#define RDI_CFG0_DECODE_FORMAT 12 > +#define RDI_CFG0_DT 16 > +#define RDI_CFG0_VC 22 > +#define RDI_CFG0_EN BIT(31) > + > +/* RDI Control and Configuration */ > +#define CSID_RDI_CTRL(rdi) (csid_is_lite(csid) ?\ > + (0x3088 + 0x200 * (rdi)) :\ > + (0x5488 + 0x200 * (rdi))) > +#define RDI_CTRL_START_CMD BIT(0) > + > +#define CSID_RDI_CFG1(rdi) (csid_is_lite(csid) ?\ > + (0x3094 + 0x200 * (rdi)) :\ > + (0x5494 + 0x200 * (rdi))) [Severity: Low] As reported by Sashiko on v2 [1], this isn't a bug, but MSM_CSID_MAX_SRC_STREAMS_1190, CSID_RDI_CFG0(rdi), CSID_RDI_CTRL(rdi), and CSID_RDI_CFG1(rdi) in drivers/media/platform/qcom/camss/camss-csid-1190.c expand to expressions calling csid_is_lite(csid) without taking csid as a macro parameter. Should these macros take csid explicitly instead of relying on a local variable named csid in the caller's scope? [ ... ] > +static void __csid_aup_rup_trigger(struct csid_device *csid) > +{ > + /* trigger SET in combined register */ > + writel(RUP_SET, csid->base + CSID_RUP_AUP_CMD); > +} > + > +static void __csid_addr_update(struct csid_device *csid, int port_id) > +{ > + csid->addr_update |=3D CSID_RUP_AUP_RDI(port_id); > + writel(csid->addr_update, csid->base + CSID_AUP_CMD); > + > + __csid_aup_rup_trigger(csid); > +} > + > +static void __csid_addr_update_clear(struct csid_device *csid, int port_= id) > +{ > + /* Hardware clears the registers upon consuming the settings */ > + csid->addr_update &=3D ~CSID_RUP_AUP_RDI(port_id); > +} > + > +static void __csid_reg_update(struct csid_device *csid, int port_id) > +{ > + csid->reg_update |=3D CSID_RUP_AUP_RDI(port_id); > + writel(csid->reg_update, csid->base + CSID_RUP_CMD); > + > + __csid_aup_rup_trigger(csid); > +} > + > +static void __csid_reg_update_clear(struct csid_device *csid, int port_i= d) > +{ > + /* Hardware clears the registers upon consuming the settings */ > + csid->reg_update &=3D ~CSID_RUP_AUP_RDI(port_id); > +} [Severity: Medium] As reported by Sashiko on v2 [1], can __csid_addr_update() and __csid_reg_update() race with __csid_addr_update_clear() and __csid_reg_update_clear() on csid->addr_update and csid->reg_update? In drivers/media/platform/qcom/camss/camss-csid-1190.c, __csid_addr_update() and __csid_reg_update() perform non-atomic read-modify-write operations on csid->addr_update and csid->reg_update before writing CSID_AUP_CMD and CSID_RUP_CMD. Meanwhile, in hardirq context, csid_isr() clears those fields when INFO_RUP_DONE is set without holding any lock: drivers/media/platform/qcom/camss/camss-csid-1190.c:csid_isr() { ... if (val & INFO_RUP_DONE) { __csid_addr_update_clear(csid, i); __csid_reg_update_clear(csid, i); } ... } Because vfe_queue_buffer_v2() and vfe_enable_output_v2() only hold vfe->output_lock (which csid_isr() does not acquire before camss_buf_done()) and csid_configure_stream() holds no spinlock, concurrent updates from proc= ess context (for example during VIDIOC_QBUF or when starting multiple RDI strea= ms sharing a CSID) and hardirq context can clobber bits in csid->addr_update a= nd csid->reg_update. [ ... ] > +static void csid_configure_stream(struct csid_device *csid, u8 enable) > +{ > + u8 i, k; > + > + __csid_configure_rx(csid, &csid->phy); > + > + for (i =3D 0; i < MSM_CSID_MAX_SRC_STREAMS_1190; i++) { > + if (csid->phy.en_vc & BIT(i)) { > + __csid_configure_rdi_stream(csid, enable, i, 0); > + __csid_configure_rx_vc(csid, 0); > + > + for (k =3D 0; k < CAMSS_INIT_BUF_COUNT; k++) > + __csid_addr_update(csid, i); > + > + __csid_reg_update(csid, i); > + > + __csid_ctrl_rdi(csid, enable, i); > + } > + } > +} [Severity: High] What happens in csid_configure_stream() if VIDIOC_STREAMON is called with fewer than CAMSS_INIT_BUF_COUNT (2) buffers queued? In msm_video_register() in drivers/media/platform/qcom/camss/camss-video.c, vb2_queue.min_queued_buffers is 0, so vb2_core_streamon() invokes vb2_start_streaming() -> video_start_streaming() even when 0 or 1 buffer is queued before VIDIOC_STREAMON. video_start_streaming() first calls vfe_set_stream() -> vfe_enable_v2() -> vfe_enable_output_v2(), which dequeues only the available pending buffers (0 or 1) and writes their addresses via ops->vfe_wm_update(): drivers/media/platform/qcom/camss/camss-vfe.c:vfe_enable_output_v2() { ... for (i =3D 0; i < CAMSS_INIT_BUF_COUNT; i++) { output->buf[i] =3D vfe_buf_get_pending(output); if (!output->buf[i]) break; output->gen2.active_num++; ops->vfe_wm_update(vfe, output->wm_idx[0], output->buf[i]->addr[0], line); if (!ops->addr_update) ops->reg_update(vfe, line->id); } ... } Next, video_start_streaming() calls csid_set_stream() -> csid_configure_stream(), which unconditionally loops CAMSS_INIT_BUF_COUNT (= 2) times calling __csid_addr_update(csid, i) regardless of how many buffers we= re queued in vfe_enable_output_v2(). Moreover, vfe_wm_stop() in drivers/media/platform/qcom/camss/camss-vfe-1190.c only clears VFE_BUS_WM_CFG(wm) without clearing VFE_BUS_WM_IMAGE_ADDR(wm). When userspace later queues buffers via VIDIOC_QBUF, vfe_queue_buffer_v2() sees output->state =3D=3D VFE_OUTPUT_ON and output->gen2.active_num < 2, and issues additional ops->addr_update() and ops->reg_update() strobes: drivers/media/platform/qcom/camss/camss-vfe.c:vfe_queue_buffer_v2() { ... if (output->state =3D=3D VFE_OUTPUT_ON && output->gen2.active_num < 2) { output->buf[output->gen2.active_num++] =3D buf; ops->vfe_wm_update(vfe, output->wm_idx[0], buf->addr[0], line); if (ops->addr_update) ops->addr_update(vfe, line->id); ops->reg_update(vfe, line->id); } ... } Doesn't issuing two unconditional __csid_addr_update() strobes in csid_configure_stream() latch stale or duplicate DMA addresses in the write master and desynchronize buffer tracking when fewer than two buffers were queued before streamon? [ ... ] > +const struct csid_hw_ops csid_ops_1190 =3D { > + .configure_stream =3D csid_configure_stream, > + .configure_testgen_pattern =3D csid_configure_testgen_pattern, > + .hw_version =3D csid_hw_version, > + .isr =3D csid_isr, > + .reset =3D csid_reset, > + .src_pad_code =3D csid_src_pad_code, > + .subdev_init =3D csid_subdev_init, > + .reg_update =3D csid_subdev_reg_update, > + .addr_update =3D csid_subdev_addr_update, > +}; [Severity: Low] This isn't a bug, but every register offset, bitmask macro, stream count definition, helper function, interrupt handler, reset routine, and hardware operation callback in drivers/media/platform/qcom/camss/camss-csid-1190.c (including the unused lane_cnt local variable in __csid_configure_rdi_stream()) is identical to drivers/media/platform/qcom/camss/camss-csid-1080.c. Similarly, drivers/media/platform/qcom/camss/camss-vfe-1190.c duplicates all functions and callbacks of drivers/media/platform/qcom/camss/camss-vfe-1080= .c verbatim, differing only in the BUS_REG_BASE and write master register offs= et macros. Could csid_res_hawi reuse csid_ops_1080 directly (just as hawi_resources reuses csiphy_res_kaanapali and tpg_res_x1e80100), and could the common VFE 1080/1190 helpers be shared? > diff --git a/drivers/media/platform/qcom/camss/camss.c b/drivers/media/pl= atform/qcom/camss/camss.c > index df4b4cf30711b..0a67d4f746eeb 100644 > --- a/drivers/media/platform/qcom/camss/camss.c > +++ b/drivers/media/platform/qcom/camss/camss.c > @@ -4359,6 +4359,218 @@ static const struct resources_icc icc_res_sa8775p= [] =3D { > }, > }; > =20 > +static const struct camss_subdev_resources vfe_res_hawi[] =3D { > + /* VFE0 - TFE Full */ > + { > + .clock =3D { "vfe0_fast_ahb", "vfe0", "cpas_vfe0", > + "camnoc_rt_axi", "camnoc_nrt_axi", "qdss_debug_xo", > + "cpas_mnoc_hf", "cpas_mnoc_sf" }, > + .clock_rate =3D { { 0 }, > + { 238200000, 397000000, 440000000, 480000000, > + 630000000, 750000000, 833000000 }, > + { 0 }, > + { 171428571, 240000000, 300000000, 400000000, > + 480000000, 600000000 }, [Severity: Medium] Are the camnoc_rt_axi clock rates in vfe_res_hawi (for VFE0 through VFE4) matching the Hawi CAMCC clock driver? In drivers/clk/qcom/camcc-hawi.c, ftbl_cam_cc_camnoc_rt_axi_clk_src for qcom,hawi-camcc defines a maximum rate of 480 MHz: drivers/clk/qcom/camcc-hawi.c: static const struct freq_tbl ftbl_cam_cc_camnoc_rt_axi_clk_src[] =3D { F(19200000, P_BI_TCXO, 1, 0, 0), F(120000000, P_CAM_CC_PLL6_OUT_EVEN, 4, 0, 0), F(160000000, P_CAM_CC_PLL6_OUT_EVEN, 3, 0, 0), F(240000000, P_CAM_CC_PLL6_OUT_EVEN, 2, 0, 0), F(320000000, P_CAM_CC_PLL6_OUT_EVEN, 1.5, 0, 0), F(480000000, P_CAM_CC_PLL6_OUT_EVEN, 1, 0, 0), { } }; (Whereas the 200/240/300/400/480/600 MHz table ftbl_cam_cc_camnoc_rt_axi_clk_src_maili is only used for qcom,maili-camcc, = and 171428571 Hz is in neither table.) When vfe_get() -> vfe_set_clock_rates() runs with min_rate between 480 MHz = and 600 MHz, it selects 600000000 Hz from vfe_res_hawi instead of rejecting the rate, and clk_round_rate() on Hawi clamps it down to 480000000 Hz. When the second pipeline entity calls vfe_get() -> vfe_check_clock_rates(), won't clk_get_rate(clock->clk) < min_rate cause vfe_check_clock_rates() to fail w= ith -EBUSY? [ ... ] > @@ -6078,6 +6290,22 @@ static const struct camss_resources sm8650_resourc= es =3D { > .vfe_num =3D ARRAY_SIZE(vfe_res_sm8650), > }; > =20 > +static const struct camss_resources hawi_resources =3D { > + .version =3D CAMSS_HAWI, > + .pd_name =3D "top", > + .pm_clks =3D { "cpas_fast_ahb", "cpas_ahb", "gcc_axi_hf" }, > + .csiphy_res =3D csiphy_res_kaanapali, [Severity: High] As reported by Sashiko on v2 [2], can reusing csiphy_res_kaanapali in hawi_resources lead to a NULL pointer dereference in msm_csiphy_subdev_init_legacy() during probe? The entries in csiphy_res_kaanapali do not set .csiphy.hw_ops, leaving hw_o= ps as NULL. During camss_probe() -> camss_init_subdevices(), camss_detect_legacy_phy() defaults camss->legacy_phy to true: drivers/media/platform/qcom/camss/camss.c:camss_detect_legacy_phy() { camss->legacy_phy =3D true; /* Find first remote-endpoint and determine if its a PHY */ for_each_endpoint_of_node(camss->dev->of_node, ep) { ... } If the qcom,hawi-camss node has no endpoints in its ports node (for example, when enabling CAMSS to use its internal Test Pattern Generators without external sensors or PHYs), camss->legacy_phy remains true. camss_init_subdevices() then calls msm_csiphy_subdev_init_legacy(), which unconditionally dereferences csiphy->res->hw_ops: drivers/media/platform/qcom/camss/camss-csiphy.c:msm_csiphy_subdev_init_leg= acy() { ... ret =3D csiphy->res->hw_ops->init(csiphy); ... } [1] https://lore.kernel.org/r/20261013-hawi-maili-camss-v2-7-fc93222da89c@o= ss.qualcomm.com [2] https://lore.kernel.org/r/20261013-hawi-maili-camss-v2-6-fc93222da89c@o= ss.qualcomm.com --=20 Sashiko AI review =C2=B7 https://sashiko.dev/#/patchset/20261030-hawi-maili= -camss-v3-0-9742bca8cef2@oss.qualcomm.com?part=3D5 From mboxrd@z Thu Jan 1 00:00:00 1970 Received: from bombadil.infradead.org (bombadil.infradead.org [198.137.202.133]) (using TLSv1.3 with cipher TLS_AES_256_GCM_SHA384 (256/256 bits) key-exchange X25519 server-signature ECDSA (prime256v1) server-digest SHA256) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 2A64560A262B for ; Fri, 30 Oct 2026 13:07:54 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key, unprotected) header.d=lists.infradead.org header.i=@lists.infradead.org header.a=rsa-sha256 header.s=bombadil.20210309 header.b=WZ1OqI6M; dkim=fail reason="signature verification failed" (2048-bit key, unprotected) header.d=kernel.org header.i=@kernel.org header.a=rsa-sha256 header.s=k20260515 header.b=ZtjjYszc 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:Date:References: In-Reply-To:Cc:To:Subject:From:Message-ID:Content-ID:Content-Description: Resent-Date:Resent-From:Resent-Sender:Resent-To:Resent-Cc:Resent-Message-ID: List-Unsubscribe-Post:List-Owner; bh=mxQ16sCbxeOwlh9ecC+NrVTIwk1Y1bWflRaQ7WBGpPg=; b=WZ1OqI6MNZjXit83tysDsJvnSc nYGUun5D5DVw3omPWvOs/OWzTvjfGQT2LFFqy0J88YE3LX7NGROWqxX0Ukdyz+U1m+6lQFw5TCbBS cf/wYJqKx523dy2TJVwt2Jxdb7iC/lSaaRSwdeUPEba4m+3c8Gf6U7IDTXCZOQWBwjYYZCgndvhTk mc66AFRKUoJCQbe+ajES1FgPSAStyb+vT89mNS54HjgDfVaf81b8ehY33VvM9Qhutt+EuRSrWayQt tqGTxirgWzcnERHmfhVLQqraDRwuDypzeK0boUv9z+UlXqvCDzz28W5E/l9yhYDhI0qFk+RMc8Yco sigigptg==; Received: from localhost ([::1] helo=bombadil.infradead.org) by bombadil.infradead.org with esmtp (Exim 4.100.1 #2 (Red Hat Linux)) id 1xMmKn-0000000BjRR-2xIh; Fri, 30 Oct 2026 13:07:53 +0000 Received: from tor.source.kernel.org ([172.105.4.254]) by bombadil.infradead.org with esmtps (Exim 4.100.1 #2 (Red Hat Linux)) id 1xMmKm-0000000BjRC-19wT for linux-phy@lists.infradead.org; Fri, 30 Oct 2026 13:07:52 +0000 Received: from smtp.kernel.org (quasi.space.kernel.org [100.103.45.18]) by tor.source.kernel.org (Postfix) with ESMTP id A7468605D0; Fri, 30 Oct 2026 13:07:51 +0000 (UTC) Received: by smtp.kernel.org (Postfix) with ESMTPSA id EEE6D1F00A1D; Fri, 30 Oct 2026 13:07:50 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=kernel.org; s=k20260515; t=1793365671; bh=JT+3LP+5QyAnCVRh6Qv6QLpMg9XRGcsCRkKadZAigA4=; h=From:Subject:Reply-To:To:Cc:In-Reply-To:References:Date; b=ZtjjYszcVqxuNf1vJaZ5617YkWrVLiATvGy8kOq1LjUFiZHUbDkmLI9/1WSPDWgIq 9DAPfW8qRvTerOOtM4/L19CzLjdsl0/oCnIXg8/fdtfIaIKIYtGxpYhXaYuzbdRSbJ FTqSuVwACG4flQTj26aNzwXBv8I5+ueYbEA8feWRzpYNJxSpptzKAU9RgOSb06b7xV Ro9vNcXQVGfOgH9xvtgPENje5nKGVc0ngff2WxpQd2HVrmWZhuLhFsiv3neYoGmy2c +LKc0aL+3vBZv8kgD4GXqcZynMbI+Qgm8uhYHzgl7mwXA2Sb41j+d0OgXHA4Rc1fcO wEeiGKNSGxPtQ== Message-ID: From: sashiko-bot@kernel.org Subject: Re: [PATCH v3 5/5] media: qcom: camss: Add support for Hawi To: "Nihal Kumar Gupta" Cc: devicetree@vger.kernel.org, linux-phy@lists.infradead.org, robh@kernel.org, conor+dt@kernel.org, media-ci@linuxtv.org, vkoul@kernel.org, neil.armstrong@linaro.org, olteanv@gmail.com In-Reply-To: <20261030-hawi-maili-camss-v3-5-9742bca8cef2@oss.qualcomm.com> References: <20261030-hawi-maili-camss-v3-0-9742bca8cef2@oss.qualcomm.com> <20261030-hawi-maili-camss-v3-5-9742bca8cef2@oss.qualcomm.com> Date: Fri, 30 Oct 2026 13:07:50 +0000 X-BeenThere: linux-phy@lists.infradead.org X-Mailman-Version: 2.1.34 Precedence: list List-Id: Linux Phy Mailing list List-Archive: List-Post: List-Help: List-Subscribe: , Reply-To: sashiko-reviews@lists.linux.dev X-Archived-By: MIME-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Sender: "linux-phy" X-Spam-Status: No, score=-8.9 required=3.0 tests=BAYES_00,DKIMWL_WL_HIGH, DKIM_SIGNED,DKIM_VALID,DKIM_VALID_EF,HEADER_FROM_DIFFERENT_DOMAINS, INCLUDES_PATCH,MAILING_LIST_MULTI,SPF_HELO_NONE,SPF_PASS autolearn=ham autolearn_force=no version=4.0.1 X-Spam-Checker-Version: SpamAssassin 4.0.1 (2024-03-26) on aws-us-west-2-korg-listserv-alma10-1 VGhhbmsgeW91IGZvciB5b3VyIGNvbnRyaWJ1dGlvbiEgU2FzaGlrbyBBSSByZXZpZXcgZm91bmQg NiBwb3RlbnRpYWwgaXNzdWUocykgdG8gY29uc2lkZXI6Ci0gW0hpZ2hdIG1lZGlhOiBxY29tOiBj YW1zczogdW5jb25kaXRpb25hbCBBVVAgc3Ryb2JlcyBpbiBjc2lkX2NvbmZpZ3VyZV9zdHJlYW0o KQotIFtIaWdoXSBtZWRpYTogY2Ftc3M6IE5VTEwgaHdfb3BzIGRlcmVmIGluIG1zbV9jc2lwaHlf c3ViZGV2X2luaXRfbGVnYWN5KCkKLSBbTWVkaXVtXSBtZWRpYTogcWNvbTogY2Ftc3M6IHdyb25n IGNhbW5vY19ydF9heGkgY2xvY2sgcmF0ZXMgaW4gdmZlX3Jlc19oYXdpCi0gW01lZGl1bV0gbWVk aWE6IHFjb206IGNhbXNzOiBkYXRhIHJhY2Ugb24gY3NpZC0+YWRkcl91cGRhdGUgYW5kIGNzaWQt PnJlZ191cGRhdGUKLSBbTG93XSBtZWRpYTogcWNvbTogY2Ftc3M6IGR1cGxpY2F0ZSBDU0lEIDEw ODAgYW5kIFZGRSAxMDgwIGNvZGUgaW4gMTE5MCBmaWxlcwotIFtMb3ddIG1lZGlhOiBxY29tOiBj YW1zczogbWFjcm9zIGluIGNhbXNzLWNzaWQtMTE5MC5jIGltcGxpY2l0bHkgY2FwdHVyZSBjc2lk Ci0tCgpjb21taXQgMjU5NjdhYWM4YWMyYzViNjM2ZGJiYWFiMjRjODRkZDQ4NGQ5OWFiOApBdXRo b3I6IEhhbmd4aWFuZyBNYSA8aGFuZ3hpYW5nLm1hQG9zcy5xdWFsY29tbS5jb20+CgptZWRpYTog cWNvbTogY2Ftc3M6IEFkZCBzdXBwb3J0IGZvciBIYXdpCgpUaGlzIGNvbW1pdCBhZGRzIENBTVNT IHN1cHBvcnQgZm9yIHRoZSBIYXdpIFNvQywgaW5jbHVkaW5nIENTSUQgMTE5MCBhbmQKVkZFIDEx OTAgaGFyZHdhcmUgb3BlcmF0aW9ucyBhbmQgSGF3aSByZXNvdXJjZSBkZWZpbml0aW9ucy4KCj4g ZGlmZiAtLWdpdCBhL2RyaXZlcnMvbWVkaWEvcGxhdGZvcm0vcWNvbS9jYW1zcy9jYW1zcy1jc2lk LTExOTAuYyBiL2RyaXZlcnMvbWVkaWEvcGxhdGZvcm0vcWNvbS9jYW1zcy9jYW1zcy1jc2lkLTEx OTAuYwo+IG5ldyBmaWxlIG1vZGUgMTAwNjQ0Cj4gaW5kZXggMDAwMDAwMDAwMDAwMC4uNGJkMmNj ZTA5NDQwMgo+IC0tLSAvZGV2L251bGwKPiArKysgYi9kcml2ZXJzL21lZGlhL3BsYXRmb3JtL3Fj b20vY2Ftc3MvY2Ftc3MtY3NpZC0xMTkwLmMKPiBAQCAtMCwwICsxLDQxNyBAQAoKWyAuLi4gXQoK PiArI2RlZmluZSBNU01fQ1NJRF9NQVhfU1JDX1NUUkVBTVNfMTE5MAkJKGNzaWRfaXNfbGl0ZShj c2lkKSA/IDQgOiA1KQo+ICsKPiArLyogUkRJIENvbmZpZ3VyYXRpb24gKi8KPiArI2RlZmluZSBD U0lEX1JESV9DRkcwKHJkaSkJKGNzaWRfaXNfbGl0ZShjc2lkKSA/XAo+ICsJCQkJCSgweDMwODAg KyAweDIwMCAqIChyZGkpKSA6XAo+ICsJCQkJCSgweDU0ODAgKyAweDIwMCAqIChyZGkpKSkKPiAr I2RlZmluZQkJUkRJX0NGRzBfUkVUSU1FX0JTCQkJQklUKDUpCj4gKyNkZWZpbmUJCVJESV9DRkcw X1RJTUVTVEFNUF9FTgkJCUJJVCg2KQo+ICsjZGVmaW5lCQlSRElfQ0ZHMF9USU1FU1RBTVBfU1RC X1NFTAkJQklUKDgpCj4gKyNkZWZpbmUJCVJESV9DRkcwX0RFQ09ERV9GT1JNQVQJCQkxMgo+ICsj ZGVmaW5lCQlSRElfQ0ZHMF9EVAkJCQkxNgo+ICsjZGVmaW5lCQlSRElfQ0ZHMF9WQwkJCQkyMgo+ ICsjZGVmaW5lCQlSRElfQ0ZHMF9FTgkJCQlCSVQoMzEpCj4gKwo+ICsvKiBSREkgQ29udHJvbCBh bmQgQ29uZmlndXJhdGlvbiAqLwo+ICsjZGVmaW5lIENTSURfUkRJX0NUUkwocmRpKQkoY3NpZF9p c19saXRlKGNzaWQpID9cCj4gKwkJCQkJKDB4MzA4OCArIDB4MjAwICogKHJkaSkpIDpcCj4gKwkJ CQkJKDB4NTQ4OCArIDB4MjAwICogKHJkaSkpKQo+ICsjZGVmaW5lCQlSRElfQ1RSTF9TVEFSVF9D TUQJCQlCSVQoMCkKPiArCj4gKyNkZWZpbmUgQ1NJRF9SRElfQ0ZHMShyZGkpCShjc2lkX2lzX2xp dGUoY3NpZCkgP1wKPiArCQkJCQkoMHgzMDk0ICsgMHgyMDAgKiAocmRpKSkgOlwKPiArCQkJCQko MHg1NDk0ICsgMHgyMDAgKiAocmRpKSkpCgpbU2V2ZXJpdHk6IExvd10KQXMgcmVwb3J0ZWQgYnkg U2FzaGlrbyBvbiB2MiBbMV0sIHRoaXMgaXNuJ3QgYSBidWcsIGJ1dApNU01fQ1NJRF9NQVhfU1JD X1NUUkVBTVNfMTE5MCwgQ1NJRF9SRElfQ0ZHMChyZGkpLCBDU0lEX1JESV9DVFJMKHJkaSksIGFu ZApDU0lEX1JESV9DRkcxKHJkaSkgaW4gZHJpdmVycy9tZWRpYS9wbGF0Zm9ybS9xY29tL2NhbXNz L2NhbXNzLWNzaWQtMTE5MC5jCmV4cGFuZCB0byBleHByZXNzaW9ucyBjYWxsaW5nIGNzaWRfaXNf bGl0ZShjc2lkKSB3aXRob3V0IHRha2luZyBjc2lkIGFzIGEKbWFjcm8gcGFyYW1ldGVyLiBTaG91 bGQgdGhlc2UgbWFjcm9zIHRha2UgY3NpZCBleHBsaWNpdGx5IGluc3RlYWQgb2YgcmVseWluZwpv biBhIGxvY2FsIHZhcmlhYmxlIG5hbWVkIGNzaWQgaW4gdGhlIGNhbGxlcidzIHNjb3BlPwoKWyAu Li4gXQoKPiArc3RhdGljIHZvaWQgX19jc2lkX2F1cF9ydXBfdHJpZ2dlcihzdHJ1Y3QgY3NpZF9k ZXZpY2UgKmNzaWQpCj4gK3sKPiArCS8qIHRyaWdnZXIgU0VUIGluIGNvbWJpbmVkIHJlZ2lzdGVy ICovCj4gKwl3cml0ZWwoUlVQX1NFVCwgY3NpZC0+YmFzZSArIENTSURfUlVQX0FVUF9DTUQpOwo+ ICt9Cj4gKwo+ICtzdGF0aWMgdm9pZCBfX2NzaWRfYWRkcl91cGRhdGUoc3RydWN0IGNzaWRfZGV2 aWNlICpjc2lkLCBpbnQgcG9ydF9pZCkKPiArewo+ICsJY3NpZC0+YWRkcl91cGRhdGUgfD0gQ1NJ RF9SVVBfQVVQX1JESShwb3J0X2lkKTsKPiArCXdyaXRlbChjc2lkLT5hZGRyX3VwZGF0ZSwgY3Np ZC0+YmFzZSArIENTSURfQVVQX0NNRCk7Cj4gKwo+ICsJX19jc2lkX2F1cF9ydXBfdHJpZ2dlcihj c2lkKTsKPiArfQo+ICsKPiArc3RhdGljIHZvaWQgX19jc2lkX2FkZHJfdXBkYXRlX2NsZWFyKHN0 cnVjdCBjc2lkX2RldmljZSAqY3NpZCwgaW50IHBvcnRfaWQpCj4gK3sKPiArCS8qIEhhcmR3YXJl IGNsZWFycyB0aGUgcmVnaXN0ZXJzIHVwb24gY29uc3VtaW5nIHRoZSBzZXR0aW5ncyAqLwo+ICsJ Y3NpZC0+YWRkcl91cGRhdGUgJj0gfkNTSURfUlVQX0FVUF9SREkocG9ydF9pZCk7Cj4gK30KPiAr Cj4gK3N0YXRpYyB2b2lkIF9fY3NpZF9yZWdfdXBkYXRlKHN0cnVjdCBjc2lkX2RldmljZSAqY3Np ZCwgaW50IHBvcnRfaWQpCj4gK3sKPiArCWNzaWQtPnJlZ191cGRhdGUgfD0gQ1NJRF9SVVBfQVVQ X1JESShwb3J0X2lkKTsKPiArCXdyaXRlbChjc2lkLT5yZWdfdXBkYXRlLCBjc2lkLT5iYXNlICsg Q1NJRF9SVVBfQ01EKTsKPiArCj4gKwlfX2NzaWRfYXVwX3J1cF90cmlnZ2VyKGNzaWQpOwo+ICt9 Cj4gKwo+ICtzdGF0aWMgdm9pZCBfX2NzaWRfcmVnX3VwZGF0ZV9jbGVhcihzdHJ1Y3QgY3NpZF9k ZXZpY2UgKmNzaWQsIGludCBwb3J0X2lkKQo+ICt7Cj4gKwkvKiBIYXJkd2FyZSBjbGVhcnMgdGhl IHJlZ2lzdGVycyB1cG9uIGNvbnN1bWluZyB0aGUgc2V0dGluZ3MgKi8KPiArCWNzaWQtPnJlZ191 cGRhdGUgJj0gfkNTSURfUlVQX0FVUF9SREkocG9ydF9pZCk7Cj4gK30KCltTZXZlcml0eTogTWVk aXVtXQpBcyByZXBvcnRlZCBieSBTYXNoaWtvIG9uIHYyIFsxXSwgY2FuIF9fY3NpZF9hZGRyX3Vw ZGF0ZSgpIGFuZApfX2NzaWRfcmVnX3VwZGF0ZSgpIHJhY2Ugd2l0aCBfX2NzaWRfYWRkcl91cGRh dGVfY2xlYXIoKSBhbmQKX19jc2lkX3JlZ191cGRhdGVfY2xlYXIoKSBvbiBjc2lkLT5hZGRyX3Vw ZGF0ZSBhbmQgY3NpZC0+cmVnX3VwZGF0ZT8KCkluIGRyaXZlcnMvbWVkaWEvcGxhdGZvcm0vcWNv bS9jYW1zcy9jYW1zcy1jc2lkLTExOTAuYywgX19jc2lkX2FkZHJfdXBkYXRlKCkKYW5kIF9fY3Np ZF9yZWdfdXBkYXRlKCkgcGVyZm9ybSBub24tYXRvbWljIHJlYWQtbW9kaWZ5LXdyaXRlIG9wZXJh dGlvbnMgb24KY3NpZC0+YWRkcl91cGRhdGUgYW5kIGNzaWQtPnJlZ191cGRhdGUgYmVmb3JlIHdy aXRpbmcgQ1NJRF9BVVBfQ01EIGFuZApDU0lEX1JVUF9DTUQuCgpNZWFud2hpbGUsIGluIGhhcmRp cnEgY29udGV4dCwgY3NpZF9pc3IoKSBjbGVhcnMgdGhvc2UgZmllbGRzIHdoZW4KSU5GT19SVVBf RE9ORSBpcyBzZXQgd2l0aG91dCBob2xkaW5nIGFueSBsb2NrOgoKZHJpdmVycy9tZWRpYS9wbGF0 Zm9ybS9xY29tL2NhbXNzL2NhbXNzLWNzaWQtMTE5MC5jOmNzaWRfaXNyKCkgewogICAgLi4uCgkJ CWlmICh2YWwgJiBJTkZPX1JVUF9ET05FKSB7CgkJCQlfX2NzaWRfYWRkcl91cGRhdGVfY2xlYXIo Y3NpZCwgaSk7CgkJCQlfX2NzaWRfcmVnX3VwZGF0ZV9jbGVhcihjc2lkLCBpKTsKCQkJfQogICAg Li4uCn0KCkJlY2F1c2UgdmZlX3F1ZXVlX2J1ZmZlcl92MigpIGFuZCB2ZmVfZW5hYmxlX291dHB1 dF92MigpIG9ubHkgaG9sZAp2ZmUtPm91dHB1dF9sb2NrICh3aGljaCBjc2lkX2lzcigpIGRvZXMg bm90IGFjcXVpcmUgYmVmb3JlIGNhbXNzX2J1Zl9kb25lKCkpCmFuZCBjc2lkX2NvbmZpZ3VyZV9z dHJlYW0oKSBob2xkcyBubyBzcGlubG9jaywgY29uY3VycmVudCB1cGRhdGVzIGZyb20gcHJvY2Vz cwpjb250ZXh0IChmb3IgZXhhbXBsZSBkdXJpbmcgVklESU9DX1FCVUYgb3Igd2hlbiBzdGFydGlu ZyBtdWx0aXBsZSBSREkgc3RyZWFtcwpzaGFyaW5nIGEgQ1NJRCkgYW5kIGhhcmRpcnEgY29udGV4 dCBjYW4gY2xvYmJlciBiaXRzIGluIGNzaWQtPmFkZHJfdXBkYXRlIGFuZApjc2lkLT5yZWdfdXBk YXRlLgoKWyAuLi4gXQoKPiArc3RhdGljIHZvaWQgY3NpZF9jb25maWd1cmVfc3RyZWFtKHN0cnVj dCBjc2lkX2RldmljZSAqY3NpZCwgdTggZW5hYmxlKQo+ICt7Cj4gKwl1OCBpLCBrOwo+ICsKPiAr CV9fY3NpZF9jb25maWd1cmVfcngoY3NpZCwgJmNzaWQtPnBoeSk7Cj4gKwo+ICsJZm9yIChpID0g MDsgaSA8IE1TTV9DU0lEX01BWF9TUkNfU1RSRUFNU18xMTkwOyBpKyspIHsKPiArCQlpZiAoY3Np ZC0+cGh5LmVuX3ZjICYgQklUKGkpKSB7Cj4gKwkJCV9fY3NpZF9jb25maWd1cmVfcmRpX3N0cmVh bShjc2lkLCBlbmFibGUsIGksIDApOwo+ICsJCQlfX2NzaWRfY29uZmlndXJlX3J4X3ZjKGNzaWQs IDApOwo+ICsKPiArCQkJZm9yIChrID0gMDsgayA8IENBTVNTX0lOSVRfQlVGX0NPVU5UOyBrKysp Cj4gKwkJCQlfX2NzaWRfYWRkcl91cGRhdGUoY3NpZCwgaSk7Cj4gKwo+ICsJCQlfX2NzaWRfcmVn X3VwZGF0ZShjc2lkLCBpKTsKPiArCj4gKwkJCV9fY3NpZF9jdHJsX3JkaShjc2lkLCBlbmFibGUs IGkpOwo+ICsJCX0KPiArCX0KPiArfQoKW1NldmVyaXR5OiBIaWdoXQpXaGF0IGhhcHBlbnMgaW4g Y3NpZF9jb25maWd1cmVfc3RyZWFtKCkgaWYgVklESU9DX1NUUkVBTU9OIGlzIGNhbGxlZCB3aXRo CmZld2VyIHRoYW4gQ0FNU1NfSU5JVF9CVUZfQ09VTlQgKDIpIGJ1ZmZlcnMgcXVldWVkPwoKSW4g bXNtX3ZpZGVvX3JlZ2lzdGVyKCkgaW4gZHJpdmVycy9tZWRpYS9wbGF0Zm9ybS9xY29tL2NhbXNz L2NhbXNzLXZpZGVvLmMsCnZiMl9xdWV1ZS5taW5fcXVldWVkX2J1ZmZlcnMgaXMgMCwgc28gdmIy X2NvcmVfc3RyZWFtb24oKSBpbnZva2VzCnZiMl9zdGFydF9zdHJlYW1pbmcoKSAtPiB2aWRlb19z dGFydF9zdHJlYW1pbmcoKSBldmVuIHdoZW4gMCBvciAxIGJ1ZmZlciBpcwpxdWV1ZWQgYmVmb3Jl IFZJRElPQ19TVFJFQU1PTi4KCnZpZGVvX3N0YXJ0X3N0cmVhbWluZygpIGZpcnN0IGNhbGxzIHZm ZV9zZXRfc3RyZWFtKCkgLT4gdmZlX2VuYWJsZV92MigpIC0+CnZmZV9lbmFibGVfb3V0cHV0X3Yy KCksIHdoaWNoIGRlcXVldWVzIG9ubHkgdGhlIGF2YWlsYWJsZSBwZW5kaW5nIGJ1ZmZlcnMgKDAK b3IgMSkgYW5kIHdyaXRlcyB0aGVpciBhZGRyZXNzZXMgdmlhIG9wcy0+dmZlX3dtX3VwZGF0ZSgp OgoKZHJpdmVycy9tZWRpYS9wbGF0Zm9ybS9xY29tL2NhbXNzL2NhbXNzLXZmZS5jOnZmZV9lbmFi bGVfb3V0cHV0X3YyKCkgewogICAgLi4uCglmb3IgKGkgPSAwOyBpIDwgQ0FNU1NfSU5JVF9CVUZf Q09VTlQ7IGkrKykgewoJCW91dHB1dC0+YnVmW2ldID0gdmZlX2J1Zl9nZXRfcGVuZGluZyhvdXRw dXQpOwoJCWlmICghb3V0cHV0LT5idWZbaV0pCgkJCWJyZWFrOwoJCW91dHB1dC0+Z2VuMi5hY3Rp dmVfbnVtKys7CgkJb3BzLT52ZmVfd21fdXBkYXRlKHZmZSwgb3V0cHV0LT53bV9pZHhbMF0sCgkJ CQkgICBvdXRwdXQtPmJ1ZltpXS0+YWRkclswXSwgbGluZSk7CgkJaWYgKCFvcHMtPmFkZHJfdXBk YXRlKQoJCQlvcHMtPnJlZ191cGRhdGUodmZlLCBsaW5lLT5pZCk7Cgl9CiAgICAuLi4KfQoKTmV4 dCwgdmlkZW9fc3RhcnRfc3RyZWFtaW5nKCkgY2FsbHMgY3NpZF9zZXRfc3RyZWFtKCkgLT4KY3Np ZF9jb25maWd1cmVfc3RyZWFtKCksIHdoaWNoIHVuY29uZGl0aW9uYWxseSBsb29wcyBDQU1TU19J TklUX0JVRl9DT1VOVCAoMikKdGltZXMgY2FsbGluZyBfX2NzaWRfYWRkcl91cGRhdGUoY3NpZCwg aSkgcmVnYXJkbGVzcyBvZiBob3cgbWFueSBidWZmZXJzIHdlcmUKcXVldWVkIGluIHZmZV9lbmFi bGVfb3V0cHV0X3YyKCkuIE1vcmVvdmVyLCB2ZmVfd21fc3RvcCgpIGluCmRyaXZlcnMvbWVkaWEv cGxhdGZvcm0vcWNvbS9jYW1zcy9jYW1zcy12ZmUtMTE5MC5jIG9ubHkgY2xlYXJzClZGRV9CVVNf V01fQ0ZHKHdtKSB3aXRob3V0IGNsZWFyaW5nIFZGRV9CVVNfV01fSU1BR0VfQUREUih3bSkuCgpX aGVuIHVzZXJzcGFjZSBsYXRlciBxdWV1ZXMgYnVmZmVycyB2aWEgVklESU9DX1FCVUYsIHZmZV9x dWV1ZV9idWZmZXJfdjIoKQpzZWVzIG91dHB1dC0+c3RhdGUgPT0gVkZFX09VVFBVVF9PTiBhbmQg b3V0cHV0LT5nZW4yLmFjdGl2ZV9udW0gPCAyLCBhbmQKaXNzdWVzIGFkZGl0aW9uYWwgb3BzLT5h ZGRyX3VwZGF0ZSgpIGFuZCBvcHMtPnJlZ191cGRhdGUoKSBzdHJvYmVzOgoKZHJpdmVycy9tZWRp YS9wbGF0Zm9ybS9xY29tL2NhbXNzL2NhbXNzLXZmZS5jOnZmZV9xdWV1ZV9idWZmZXJfdjIoKSB7 CiAgICAuLi4KCWlmIChvdXRwdXQtPnN0YXRlID09IFZGRV9PVVRQVVRfT04gJiYKCSAgICBvdXRw dXQtPmdlbjIuYWN0aXZlX251bSA8IDIpIHsKCQlvdXRwdXQtPmJ1ZltvdXRwdXQtPmdlbjIuYWN0 aXZlX251bSsrXSA9IGJ1ZjsKCQlvcHMtPnZmZV93bV91cGRhdGUodmZlLCBvdXRwdXQtPndtX2lk eFswXSwKCQkJCSAgIGJ1Zi0+YWRkclswXSwgbGluZSk7CgkJaWYgKG9wcy0+YWRkcl91cGRhdGUp CgkJCW9wcy0+YWRkcl91cGRhdGUodmZlLCBsaW5lLT5pZCk7CgkJb3BzLT5yZWdfdXBkYXRlKHZm ZSwgbGluZS0+aWQpOwoJfQogICAgLi4uCn0KCkRvZXNuJ3QgaXNzdWluZyB0d28gdW5jb25kaXRp b25hbCBfX2NzaWRfYWRkcl91cGRhdGUoKSBzdHJvYmVzIGluCmNzaWRfY29uZmlndXJlX3N0cmVh bSgpIGxhdGNoIHN0YWxlIG9yIGR1cGxpY2F0ZSBETUEgYWRkcmVzc2VzIGluIHRoZSB3cml0ZQpt YXN0ZXIgYW5kIGRlc3luY2hyb25pemUgYnVmZmVyIHRyYWNraW5nIHdoZW4gZmV3ZXIgdGhhbiB0 d28gYnVmZmVycyB3ZXJlCnF1ZXVlZCBiZWZvcmUgc3RyZWFtb24/CgpbIC4uLiBdCgo+ICtjb25z dCBzdHJ1Y3QgY3NpZF9od19vcHMgY3NpZF9vcHNfMTE5MCA9IHsKPiArCS5jb25maWd1cmVfc3Ry ZWFtID0gY3NpZF9jb25maWd1cmVfc3RyZWFtLAo+ICsJLmNvbmZpZ3VyZV90ZXN0Z2VuX3BhdHRl cm4gPSBjc2lkX2NvbmZpZ3VyZV90ZXN0Z2VuX3BhdHRlcm4sCj4gKwkuaHdfdmVyc2lvbiA9IGNz aWRfaHdfdmVyc2lvbiwKPiArCS5pc3IgPSBjc2lkX2lzciwKPiArCS5yZXNldCA9IGNzaWRfcmVz ZXQsCj4gKwkuc3JjX3BhZF9jb2RlID0gY3NpZF9zcmNfcGFkX2NvZGUsCj4gKwkuc3ViZGV2X2lu aXQgPSBjc2lkX3N1YmRldl9pbml0LAo+ICsJLnJlZ191cGRhdGUgPSBjc2lkX3N1YmRldl9yZWdf dXBkYXRlLAo+ICsJLmFkZHJfdXBkYXRlID0gY3NpZF9zdWJkZXZfYWRkcl91cGRhdGUsCj4gK307 CgpbU2V2ZXJpdHk6IExvd10KVGhpcyBpc24ndCBhIGJ1ZywgYnV0IGV2ZXJ5IHJlZ2lzdGVyIG9m ZnNldCwgYml0bWFzayBtYWNybywgc3RyZWFtIGNvdW50CmRlZmluaXRpb24sIGhlbHBlciBmdW5j dGlvbiwgaW50ZXJydXB0IGhhbmRsZXIsIHJlc2V0IHJvdXRpbmUsIGFuZCBoYXJkd2FyZQpvcGVy YXRpb24gY2FsbGJhY2sgaW4gZHJpdmVycy9tZWRpYS9wbGF0Zm9ybS9xY29tL2NhbXNzL2NhbXNz LWNzaWQtMTE5MC5jCihpbmNsdWRpbmcgdGhlIHVudXNlZCBsYW5lX2NudCBsb2NhbCB2YXJpYWJs ZSBpbgpfX2NzaWRfY29uZmlndXJlX3JkaV9zdHJlYW0oKSkgaXMgaWRlbnRpY2FsIHRvCmRyaXZl cnMvbWVkaWEvcGxhdGZvcm0vcWNvbS9jYW1zcy9jYW1zcy1jc2lkLTEwODAuYy4KClNpbWlsYXJs eSwgZHJpdmVycy9tZWRpYS9wbGF0Zm9ybS9xY29tL2NhbXNzL2NhbXNzLXZmZS0xMTkwLmMgZHVw bGljYXRlcyBhbGwKZnVuY3Rpb25zIGFuZCBjYWxsYmFja3Mgb2YgZHJpdmVycy9tZWRpYS9wbGF0 Zm9ybS9xY29tL2NhbXNzL2NhbXNzLXZmZS0xMDgwLmMKdmVyYmF0aW0sIGRpZmZlcmluZyBvbmx5 IGluIHRoZSBCVVNfUkVHX0JBU0UgYW5kIHdyaXRlIG1hc3RlciByZWdpc3RlciBvZmZzZXQKbWFj cm9zLgoKQ291bGQgY3NpZF9yZXNfaGF3aSByZXVzZSBjc2lkX29wc18xMDgwIGRpcmVjdGx5IChq dXN0IGFzIGhhd2lfcmVzb3VyY2VzCnJldXNlcyBjc2lwaHlfcmVzX2thYW5hcGFsaSBhbmQgdHBn X3Jlc194MWU4MDEwMCksIGFuZCBjb3VsZCB0aGUgY29tbW9uIFZGRQoxMDgwLzExOTAgaGVscGVy cyBiZSBzaGFyZWQ/Cgo+IGRpZmYgLS1naXQgYS9kcml2ZXJzL21lZGlhL3BsYXRmb3JtL3Fjb20v Y2Ftc3MvY2Ftc3MuYyBiL2RyaXZlcnMvbWVkaWEvcGxhdGZvcm0vcWNvbS9jYW1zcy9jYW1zcy5j Cj4gaW5kZXggZGY0YjRjZjMwNzExYi4uMGE2N2Q0Zjc0NmVlYiAxMDA2NDQKPiAtLS0gYS9kcml2 ZXJzL21lZGlhL3BsYXRmb3JtL3Fjb20vY2Ftc3MvY2Ftc3MuYwo+ICsrKyBiL2RyaXZlcnMvbWVk aWEvcGxhdGZvcm0vcWNvbS9jYW1zcy9jYW1zcy5jCj4gQEAgLTQzNTksNiArNDM1OSwyMTggQEAg c3RhdGljIGNvbnN0IHN0cnVjdCByZXNvdXJjZXNfaWNjIGljY19yZXNfc2E4Nzc1cFtdID0gewo+ ICAJfSwKPiAgfTsKPiAgCj4gK3N0YXRpYyBjb25zdCBzdHJ1Y3QgY2Ftc3Nfc3ViZGV2X3Jlc291 cmNlcyB2ZmVfcmVzX2hhd2lbXSA9IHsKPiArCS8qIFZGRTAgLSBURkUgRnVsbCAqLwo+ICsJewo+ ICsJCS5jbG9jayA9IHsgInZmZTBfZmFzdF9haGIiLCAidmZlMCIsICJjcGFzX3ZmZTAiLAo+ICsJ CQkgICAiY2Ftbm9jX3J0X2F4aSIsICJjYW1ub2NfbnJ0X2F4aSIsICJxZHNzX2RlYnVnX3hvIiwK PiArCQkJICAgImNwYXNfbW5vY19oZiIsICJjcGFzX21ub2Nfc2YiIH0sCj4gKwkJLmNsb2NrX3Jh dGUgPSB7IHsgMCB9LAo+ICsJCQkJeyAyMzgyMDAwMDAsIDM5NzAwMDAwMCwgNDQwMDAwMDAwLCA0 ODAwMDAwMDAsCj4gKwkJCQkgIDYzMDAwMDAwMCwgNzUwMDAwMDAwLCA4MzMwMDAwMDAgfSwKPiAr CQkJCXsgMCB9LAo+ICsJCQkJeyAxNzE0Mjg1NzEsIDI0MDAwMDAwMCwgMzAwMDAwMDAwLCA0MDAw MDAwMDAsCj4gKwkJCQkgIDQ4MDAwMDAwMCwgNjAwMDAwMDAwIH0sCgpbU2V2ZXJpdHk6IE1lZGl1 bV0KQXJlIHRoZSBjYW1ub2NfcnRfYXhpIGNsb2NrIHJhdGVzIGluIHZmZV9yZXNfaGF3aSAoZm9y IFZGRTAgdGhyb3VnaCBWRkU0KQptYXRjaGluZyB0aGUgSGF3aSBDQU1DQyBjbG9jayBkcml2ZXI/ CgpJbiBkcml2ZXJzL2Nsay9xY29tL2NhbWNjLWhhd2kuYywgZnRibF9jYW1fY2NfY2Ftbm9jX3J0 X2F4aV9jbGtfc3JjIGZvcgpxY29tLGhhd2ktY2FtY2MgZGVmaW5lcyBhIG1heGltdW0gcmF0ZSBv ZiA0ODAgTUh6OgoKZHJpdmVycy9jbGsvcWNvbS9jYW1jYy1oYXdpLmM6CnN0YXRpYyBjb25zdCBz dHJ1Y3QgZnJlcV90YmwgZnRibF9jYW1fY2NfY2Ftbm9jX3J0X2F4aV9jbGtfc3JjW10gPSB7CglG KDE5MjAwMDAwLCBQX0JJX1RDWE8sIDEsIDAsIDApLAoJRigxMjAwMDAwMDAsIFBfQ0FNX0NDX1BM TDZfT1VUX0VWRU4sIDQsIDAsIDApLAoJRigxNjAwMDAwMDAsIFBfQ0FNX0NDX1BMTDZfT1VUX0VW RU4sIDMsIDAsIDApLAoJRigyNDAwMDAwMDAsIFBfQ0FNX0NDX1BMTDZfT1VUX0VWRU4sIDIsIDAs IDApLAoJRigzMjAwMDAwMDAsIFBfQ0FNX0NDX1BMTDZfT1VUX0VWRU4sIDEuNSwgMCwgMCksCglG KDQ4MDAwMDAwMCwgUF9DQU1fQ0NfUExMNl9PVVRfRVZFTiwgMSwgMCwgMCksCgl7IH0KfTsKCihX aGVyZWFzIHRoZSAyMDAvMjQwLzMwMC80MDAvNDgwLzYwMCBNSHogdGFibGUKZnRibF9jYW1fY2Nf Y2Ftbm9jX3J0X2F4aV9jbGtfc3JjX21haWxpIGlzIG9ubHkgdXNlZCBmb3IgcWNvbSxtYWlsaS1j YW1jYywgYW5kCjE3MTQyODU3MSBIeiBpcyBpbiBuZWl0aGVyIHRhYmxlLikKCldoZW4gdmZlX2dl dCgpIC0+IHZmZV9zZXRfY2xvY2tfcmF0ZXMoKSBydW5zIHdpdGggbWluX3JhdGUgYmV0d2VlbiA0 ODAgTUh6IGFuZAo2MDAgTUh6LCBpdCBzZWxlY3RzIDYwMDAwMDAwMCBIeiBmcm9tIHZmZV9yZXNf aGF3aSBpbnN0ZWFkIG9mIHJlamVjdGluZyB0aGUKcmF0ZSwgYW5kIGNsa19yb3VuZF9yYXRlKCkg b24gSGF3aSBjbGFtcHMgaXQgZG93biB0byA0ODAwMDAwMDAgSHouIFdoZW4gdGhlCnNlY29uZCBw aXBlbGluZSBlbnRpdHkgY2FsbHMgdmZlX2dldCgpIC0+IHZmZV9jaGVja19jbG9ja19yYXRlcygp LCB3b24ndApjbGtfZ2V0X3JhdGUoY2xvY2stPmNsaykgPCBtaW5fcmF0ZSBjYXVzZSB2ZmVfY2hl Y2tfY2xvY2tfcmF0ZXMoKSB0byBmYWlsIHdpdGgKLUVCVVNZPwoKWyAuLi4gXQoKPiBAQCAtNjA3 OCw2ICs2MjkwLDIyIEBAIHN0YXRpYyBjb25zdCBzdHJ1Y3QgY2Ftc3NfcmVzb3VyY2VzIHNtODY1 MF9yZXNvdXJjZXMgPSB7Cj4gIAkudmZlX251bSA9IEFSUkFZX1NJWkUodmZlX3Jlc19zbTg2NTAp LAo+ICB9Owo+ICAKPiArc3RhdGljIGNvbnN0IHN0cnVjdCBjYW1zc19yZXNvdXJjZXMgaGF3aV9y ZXNvdXJjZXMgPSB7Cj4gKwkudmVyc2lvbiA9IENBTVNTX0hBV0ksCj4gKwkucGRfbmFtZSA9ICJ0 b3AiLAo+ICsJLnBtX2Nsa3MgPSB7ICJjcGFzX2Zhc3RfYWhiIiwgImNwYXNfYWhiIiwgImdjY19h eGlfaGYiIH0sCj4gKwkuY3NpcGh5X3JlcyA9IGNzaXBoeV9yZXNfa2FhbmFwYWxpLAoKW1NldmVy aXR5OiBIaWdoXQpBcyByZXBvcnRlZCBieSBTYXNoaWtvIG9uIHYyIFsyXSwgY2FuIHJldXNpbmcg Y3NpcGh5X3Jlc19rYWFuYXBhbGkgaW4KaGF3aV9yZXNvdXJjZXMgbGVhZCB0byBhIE5VTEwgcG9p bnRlciBkZXJlZmVyZW5jZSBpbgptc21fY3NpcGh5X3N1YmRldl9pbml0X2xlZ2FjeSgpIGR1cmlu ZyBwcm9iZT8KClRoZSBlbnRyaWVzIGluIGNzaXBoeV9yZXNfa2FhbmFwYWxpIGRvIG5vdCBzZXQg LmNzaXBoeS5od19vcHMsIGxlYXZpbmcgaHdfb3BzCmFzIE5VTEwuIER1cmluZyBjYW1zc19wcm9i ZSgpIC0+IGNhbXNzX2luaXRfc3ViZGV2aWNlcygpLApjYW1zc19kZXRlY3RfbGVnYWN5X3BoeSgp IGRlZmF1bHRzIGNhbXNzLT5sZWdhY3lfcGh5IHRvIHRydWU6Cgpkcml2ZXJzL21lZGlhL3BsYXRm b3JtL3Fjb20vY2Ftc3MvY2Ftc3MuYzpjYW1zc19kZXRlY3RfbGVnYWN5X3BoeSgpIHsKCWNhbXNz LT5sZWdhY3lfcGh5ID0gdHJ1ZTsKCgkvKiBGaW5kIGZpcnN0IHJlbW90ZS1lbmRwb2ludCBhbmQg ZGV0ZXJtaW5lIGlmIGl0cyBhIFBIWSAqLwoJZm9yX2VhY2hfZW5kcG9pbnRfb2Zfbm9kZShjYW1z cy0+ZGV2LT5vZl9ub2RlLCBlcCkgewogICAgICAgIC4uLgp9CgpJZiB0aGUgcWNvbSxoYXdpLWNh bXNzIG5vZGUgaGFzIG5vIGVuZHBvaW50cyBpbiBpdHMgcG9ydHMgbm9kZSAoZm9yIGV4YW1wbGUs CndoZW4gZW5hYmxpbmcgQ0FNU1MgdG8gdXNlIGl0cyBpbnRlcm5hbCBUZXN0IFBhdHRlcm4gR2Vu ZXJhdG9ycyB3aXRob3V0CmV4dGVybmFsIHNlbnNvcnMgb3IgUEhZcyksIGNhbXNzLT5sZWdhY3lf cGh5IHJlbWFpbnMgdHJ1ZS4KY2Ftc3NfaW5pdF9zdWJkZXZpY2VzKCkgdGhlbiBjYWxscyBtc21f Y3NpcGh5X3N1YmRldl9pbml0X2xlZ2FjeSgpLCB3aGljaAp1bmNvbmRpdGlvbmFsbHkgZGVyZWZl cmVuY2VzIGNzaXBoeS0+cmVzLT5od19vcHM6Cgpkcml2ZXJzL21lZGlhL3BsYXRmb3JtL3Fjb20v Y2Ftc3MvY2Ftc3MtY3NpcGh5LmM6bXNtX2NzaXBoeV9zdWJkZXZfaW5pdF9sZWdhY3koKSB7CiAg ICAuLi4KCXJldCA9IGNzaXBoeS0+cmVzLT5od19vcHMtPmluaXQoY3NpcGh5KTsKICAgIC4uLgp9 CgpbMV0gaHR0cHM6Ly9sb3JlLmtlcm5lbC5vcmcvci8yMDI2MTAxMy1oYXdpLW1haWxpLWNhbXNz LXYyLTctZmM5MzIyMmRhODljQG9zcy5xdWFsY29tbS5jb20KWzJdIGh0dHBzOi8vbG9yZS5rZXJu ZWwub3JnL3IvMjAyNjEwMTMtaGF3aS1tYWlsaS1jYW1zcy12Mi02LWZjOTMyMjJkYTg5Y0Bvc3Mu cXVhbGNvbW0uY29tCgotLSAKU2FzaGlrbyBBSSByZXZpZXcgwrcgaHR0cHM6Ly9zYXNoaWtvLmRl di8jL3BhdGNoc2V0LzIwMjYxMDMwLWhhd2ktbWFpbGktY2Ftc3MtdjMtMC05NzQyYmNhOGNlZjJA b3NzLnF1YWxjb21tLmNvbT9wYXJ0PTUKCi0tIApsaW51eC1waHkgbWFpbGluZyBsaXN0CmxpbnV4 LXBoeUBsaXN0cy5pbmZyYWRlYWQub3JnCmh0dHBzOi8vbGlzdHMuaW5mcmFkZWFkLm9yZy9tYWls bWFuL2xpc3RpbmZvL2xpbnV4LXBoeQo=