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=1795248513; b=Pume/bBc3j6fe+koIn/V15zjGtUlzdTJuPYJaUjNCdyJBP6rdKZQQzSd6No/WB2ZLfRK 0TpbR/1Z7hFnFcM7go5fA2Jtu6TYtQyULkSPxT2h5GbGHA0NyLAs5h87jyuS2XnQuzDrV 2X1FxX7pd1r20CBhV7UwjLvL7mTEXayb04pPNoyaOrY19o5MY2UthG29TAnfZixoUD3l1 tzXX1NXf6wSzcD/zk9ltd0Dtdr+1koh1Nh40MFBJW8q7bNswlyP+MgmGLIFtPvN8jCJDA GtzCP6nTYBswrRIkogReBqBwr4qO+sJgM27pNctv5vWqBtsZA1ZaYuzkjEkQVD49C5Q== ARC-Message-Signature: i=1; d=subspace.kernel.org; s=arc20261015; a=rsa-sha256; c=relaxed/relaxed; t=1795248513; h=Received:DKIM-Signature:Message-ID:From:Subject:Reply-To:To:Cc: In-Reply-To:References:Content-Type:Content-Transfer-Encoding:Date; bh=3raE7u8WA73CEKC1arPbGq0UbR1DaFv/0W8Yfa/NNSg=; b=lGXUKX7GEn82zfAsTondyTFDFNIQ2GQ6pWqSmg6wFG9+IzqXOOLYLkt65uC/zMJ65Lhk nZ5VX/fQMdQ7V14xPKva8anEwWhHTjqtG3inye2moBFfNIBh+IcA9qv7V4RqWPwa01zO2 E0Z5OwDk5u944p1K7cYV2ErvK5ITVkpsxH3bx/BJPJTxdS0TrLaY8jCjCsXybHJbj9dEd 49kjrLVPMbN76D40+Sj4etCqRiwIdN1LK6mBxKFJi2jFHD3xD5x7ItX2PApyRFpxFSxzO aAjZ5qNk8SixNsOq+om7c96VmHaZzei0u9xMe/YDTy51XMuVeKYZORAZT1HWv7dBepA== 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=gudNDYEC; 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 D7B2A606A325; Sat, 21 Nov 2026 08:08:33 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.a=rsa-sha256 header.s=k20260515 header.b=gudNDYEC Received: by smtp.kernel.org (Postfix) with ESMTPSA id 41E811F000C6; Sat, 21 Nov 2026 08:08:33 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=kernel.org; s=k20260515; t=1795248513; bh=3raE7u8WA73CEKC1arPbGq0UbR1DaFv/0W8Yfa/NNSg=; h=From:Subject:Reply-To:To:Cc:In-Reply-To:References:Date; b=gudNDYEClDBoqYsVwrw2cKPLBtfyUB9Kw6TPnG8C4WNAtnurIlAZ60nHmIbKGyjAl HRgm6cVFA/eqj7OAKt/lUn9GKb+mFFO0cucR2kC4HBSzsEeEnsWKbk4St6xI4tsPkm w+y+9zwMalKOLObRvEg0oa7acowA0xGylBpzzivCCgJnpNxUDoQFo+QXa1q1BnMunG HPIAWKUxeR6TdTMl6SIQnc28taFYEybm+/R6M6chObxmwj6lTmtsUfVS7QwotatJjU 5XE3meqtYWm60CJDuVUE45eKHPkvvxoLsfNbrnHMk/0ApM7WLfFpneX3NqXPDWk1w+ 8OOO5vb/FZYLQ== Message-ID: From: sashiko-bot@kernel.org Subject: Re: [PATCH v3 12/17] drm/spacemit: add Innosilicon DP/eDP controller bridge driver Reply-To: sashiko-reviews@lists.linux.dev To: "Cody Kang" Cc: dri-devel@lists.freedesktop.org, devicetree@vger.kernel.org, linux-phy@lists.infradead.org, linux-clk@vger.kernel.org, robh@kernel.org, conor+dt@kernel.org, vkoul@kernel.org, neil.armstrong@linaro.org, olteanv@gmail.com In-Reply-To: <20261121-k3-display-v3-12-ec419e8e96b8@gmail.com> References: <20261121-k3-display-v3-0-ec419e8e96b8@gmail.com> <20261121-k3-display-v3-12-ec419e8e96b8@gmail.com> Content-Type: text/plain; charset=utf-8 Content-Transfer-Encoding: quoted-printable Date: Sat, 21 Nov 2026 08:08:32 +0000 X-Mailing-List: linux-clk@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 13 potential issues to consider: - [High] drm/spacemit: missing pre-emphasis shift in spacemit_dp_link_apply_adjust() - [High] drm/spacemit: reset in spacemit_dp_dev_init() desyncs cached PREPLL clk rate - [Medium] drm/spacemit: broken HPD IRQ notify in spacemit_dp_hotplug_event_handler() - [Medium] drm/spacemit: fallback caps in spacemit_dp_hw_read_sink_caps() block retry - [Medium] drm/spacemit: missing hw disable in spacemit_dp_unregister() and bind() - [Medium] drm/spacemit: missing spacemit_dp_hw_disable() on bind init failure - [Medium] drm/spacemit: pixel clock truncation to MHz in TU and HBLANK calculation - [Medium] drm/spacemit: unacknowledged level-high HPD IRQ in spacemit_dp_irq_handler() - [Medium] drm/spacemit: unlocked dp->link and dp->dpcd reads in mode_valid and check - [Medium] drm/spacemit: AUX registered before init and MPLL reset without hw_mutex - [Medium] drm/spacemit: pixel PLL left powered down on untrained link in atomic_enable - [Medium] drm/spacemit: nested AUX retries and fallback in spacemit_dp_aux_transfer() - [Medium] drm/spacemit: spacemit_dp_remove() runs before devm AUX bus depopulation -- commit a1a5915e82d2de32d9e2fe7095172a35686df3b2 Author: Cody Kang drm/spacemit: add Innosilicon DP/eDP controller bridge driver This commit adds the DRM bridge driver for the Innosilicon DisplayPort and embedded DisplayPort controller downstream of the SpacemiT Saturn DPU. > diff --git a/drivers/gpu/drm/spacemit/spacemit_inno_dp.c b/drivers/gpu/dr= m/spacemit/spacemit_inno_dp.c > new file mode 100644 > index 0000000000000..436e5f15b4039 > --- /dev/null > +++ b/drivers/gpu/drm/spacemit/spacemit_inno_dp.c [ ... ] > + ret =3D regmap_read_poll_timeout(dp->regs, DP_GENERAL_INTERRUPT, val, > + val & DP_AUX_REPLY_EVENT_INT_STA, > + SPACEMIT_DP_AUX_POLL_US, > + SPACEMIT_DP_AUX_TIMEOUT_US); > + if (ret) { > + if (retries < SPACEMIT_DP_AUX_MAX_RETRIES) { > + retries++; > + spacemit_dp_aux_hw_reset(dp); > + dev_dbg(dp->dev, > + "AUX timeout, cmd=3D0x%x addr=3D0x%x size=3D%zu retry %d/%d\n", > + cmd, msg->address, msg->size, retries, SPACEMIT_DP_AUX_MAX_RETRIES); > + goto retry_eio; > + } > + > + dev_err_ratelimited(dp->dev, > + "AUX transfer timeout, req: 0x%x, cmd: 0x%x, addr: 0x%x, size %z= u\n", > + msg->request, cmd, msg->address, msg->size); > + return ret; > + } [Severity: Medium] Does retrying timed-out transfers inside spacemit_dp_aux_transfer() compound with the DRM DP helpers and spacemit_dp_hw_read_sink_caps() to stall for over two minutes under dp->mode_lock? Each timed-out spacemit_dp_aux_transfer() call waits 4 * 200 ms (~813 ms). drm_dp_dpcd_access() retries negative errors 32 times, drm_dp_dpcd_read_data() falls back to a second 32-retry probe via drm_dp_dpcd_readb(), and spacemit_dp_hw_read_sink_caps() loops SPACEMIT_DP_SINK_READY_RETRIES (3) times, multiplying a single unresponsive sink into 768 consecutive 200 ms timeouts (~156 seconds) while holding dp->mode_lock or component bind locks. This is also reachable on eDP during spacemit_dp_bind(), which checks spacemit_dp_hw_detect_hpd() and calls spacemit_dp_hw_read_sink_caps() even though DP_HPD_IN_STATUS is not meaningful on eDP and the panel is powered off until atomic_pre_enable; when that read fails, the non-zero fallback limits set by spacemit_dp_hw_read_sink_caps() prevent spacemit_dp_bridge_atomic_enable() from re-reading DPCD once the panel is powered. [ ... ] > +static void spacemit_dp_hw_read_sink_caps(struct spacemit_dp_dev *dp) > +{ [ ... ] > + if (ret < 0) { > + drm_warn_ratelimited(dp->drm, > + "failed to read DPCD after %d retries: %zd\n", > + SPACEMIT_DP_SINK_READY_RETRIES, ret); > + dp->link.revision =3D DP_DPCD_REV_14; > + dp->link.max_rate =3D SPACEMIT_DP_LINK_RATE_5_40; > + dp->link.max_num_lanes =3D SPACEMIT_DP_LANE_2; > + dp->link.enhanced_framing =3D 1; > + return; > + } [Severity: Medium] Does populating non-zero fallback values in dp->link.max_rate and dp->link.max_num_lanes when spacemit_dp_hw_read_sink_caps() fails prevent spacemit_dp_bridge_atomic_enable() from retrying the DPCD read? spacemit_dp_bridge_atomic_enable() only retries spacemit_dp_hw_read_sink_ca= ps() when !dp->link.max_rate || !dp->link.max_num_lanes. If an earlier DPCD read at bind or detect time fails (for example, on eDP during spacemit_dp_bind() when noisy DP_HPD_IN_STATUS reads high before the panel is powered, or on a slow-waking monitor), max_rate and max_num_lanes are set to 5.4 Gbps and 2 lanes while dp->dpcd remains zeroed or stale. The enable-time retry is then skipped, clamping 4-lane panels or monitors to 2 lanes and running link training without valid dp->dpcd capability bytes (such as TPS3 support). [ ... ] > +static int spacemit_dp_link_apply_adjust(struct spacemit_dp_dev *dp, > + const u8 *link_status, > + enum spacemit_dp_lane_count lanes, > + u8 *training_set) > +{ > + union phy_configure_opts opts =3D { > + .dp =3D { > + .lanes =3D lanes, > + .set_voltages =3D true, > + }, > + }; > + int i, ret; > + > + for (i =3D 0; i < lanes; i++) { > + u8 v =3D drm_dp_get_adjust_request_voltage(link_status, i); > + u8 p =3D drm_dp_get_adjust_request_pre_emphasis(link_status, i); > + u8 v_bits; > + > + if (v >=3D SPACEMIT_DP_SWING_MAX) > + v =3D SPACEMIT_DP_SWING_MAX; > + if (p >=3D SPACEMIT_DP_PREEMP_MAX) > + p =3D SPACEMIT_DP_PREEMP_MAX; > + > + opts.dp.voltage[i] =3D v; > + opts.dp.pre[i] =3D p; > + > + v_bits =3D v; > + if (v =3D=3D SPACEMIT_DP_SWING_MAX) > + v_bits |=3D DP_TRAIN_MAX_SWING_REACHED; > + if (p =3D=3D SPACEMIT_DP_PREEMP_MAX) > + v_bits |=3D DP_TRAIN_MAX_PRE_EMPHASIS_REACHED; > + > + training_set[i] =3D v_bits | (p << DP_TRAIN_PRE_EMPHASIS_SHIFT); > + } [Severity: High] Isn't the return value of drm_dp_get_adjust_request_pre_emphasis() already shifted left by DP_TRAIN_PRE_EMPHASIS_SHIFT (3)? For pre-emphasis levels 1, 2 and 3, drm_dp_get_adjust_request_pre_emphasis() returns 8, 16 and 24. Comparing p >=3D SPACEMIT_DP_PREEMP_MAX (2) without shifting right by DP_TRAIN_PRE_EMPHASIS_SHIFT first causes any request for pre-emphasis level 1 to be clamped to level 2, marked with DP_TRAIN_MAX_PRE_EMPHASIS_REACHED, and shifted a second time when building training_set[i]. [ ... ] > +static void spacemit_dp_hw_set_msa_and_enable_video(struct spacemit_dp_d= ev *dp, > + const struct drm_display_mode *mode, > + enum spacemit_dp_link_rate rate, > + enum spacemit_dp_lane_count lanes) > +{ > + u64 hb_num; > + u32 link_rate; > + u32 fp; /* Pixel clock in MHz */ > + u32 tu, tu_frac, tu_int, rd_thres; > + u32 hsync_len, hstart, vstart; > + > + /* mode->clock unit is kHz, fp unit is MHz */ > + fp =3D mode->clock / 1000; > + > + if (fp =3D=3D 0) > + fp =3D 1; /* Prevent division by zero */ > + > + /* > + * HBlank interval =3D (htotal - hactive) * (LinkSymbolClock / 4) / > + * PixelClock, where LinkSymbolClock =3D LinkRate * 100 (1.62G -> 162MH= z). > + * rate is in kbit/s, so link_rate =3D rate / 10000 gives the 162, 270, > + * 540 form used below. > + */ > + link_rate =3D rate / 10000; > + > + /* Multiply before dividing: hb_num =3D hblank * (link_rate / 4) / fp */ > + hb_num =3D (u64)(mode->htotal - mode->hdisplay) * link_rate; > + do_div(hb_num, 4 * fp); > + > + /* Transfer unit: tu =3D fp * bpp * 640 / (8 * lanes * link_rate) */ > + tu =3D div_u64((u64)fp * SPACEMIT_DP_BPP * 640, 8 * lanes * link_rate); [Severity: Medium] Does truncating mode->clock to integer MHz in fp underestimate the transfer unit size for fractional-MHz pixel clocks? spacemit_dp_set_plls() programs dp->pll_clk to mode->clock * 1000 Hz, so a 1080p60 mode runs at 148.5 MHz (and 720p60 at 74.25 MHz), whereas fp =3D mode->clock / 1000 truncates those clocks to 148 MHz and 74 MHz. For 1080p60 on 2 lanes at 2.7 Gbps, this programs a TU of 52.6 instead of 52.8, packing fewer bytes per TU than the pixel clock delivers into the video FIFO. Using mode->clock in kHz and rate / 10 directly avoids the truncation. [ ... ] > +static enum drm_mode_status > +spacemit_dp_bridge_mode_valid(struct drm_bridge *bridge, > + const struct drm_display_info *info, > + const struct drm_display_mode *mode) > +{ > + struct spacemit_dp_dev *dp =3D container_of(bridge, > + struct spacemit_dp_dev, > + bridge); > + unsigned int max_link_rate, max_lanes; > + u64 max_bw, req_bw; > + > + /* > + * Prefer the link limits the driver maintains: they start as the > + * sink's capabilities clamped to the PHY and are narrowed after a > + * failed training. drm_dp_max_link_rate() is in 10 kbit/s. > + */ > + if (dp->link.max_rate && dp->link.max_num_lanes) { > + max_link_rate =3D dp->link.max_rate / 10; > + max_lanes =3D dp->link.max_num_lanes; > + } else { > + max_link_rate =3D min_t(unsigned int, > + drm_dp_max_link_rate(dp->dpcd), > + SPACEMIT_DP_SOURCE_MAX_RATE / 10); > + max_lanes =3D drm_dp_max_lane_count(dp->dpcd); > + } [Severity: Medium] Can spacemit_dp_bridge_mode_valid() and spacemit_dp_bridge_atomic_check() race with concurrent updates to dp->link and dp->dpcd? spacemit_dp_hw_read_sink_caps() and spacemit_dp_link_narrow() update dp->dpcd, dp->link.max_rate and dp->link.max_num_lanes under dp->mode_lock from the hotplug IRQ thread (spacemit_dp_hotplug_event_handler()) and from non-blocking atomic commits (spacemit_dp_bridge_atomic_enable()), neither of which holds the DRM modeset locks. Reading those fields in spacemit_dp_bridge_mode_valid() and spacemit_dp_bridge_atomic_check() without dp->mode_lock can observe a torn rate/lane pair or partially read dp->dpcd bytes. [ ... ] > + for (trained =3D false, i =3D start; > + i < ARRAY_SIZE(spacemit_dp_link_priority_table); i++) { > + u32 capacity; > + > + cfg =3D &spacemit_dp_link_priority_table[i]; > + > + /* Source and sink limits */ > + if (cfg->rate > dp->link.max_rate || cfg->lanes > dp->link.max_num_lan= es) > + continue; > + > + /* Bandwidth requirement */ > + capacity =3D spacemit_dp_calc_link_capacity(cfg->rate, > + cfg->lanes); > + if (capacity < req_bw) > + continue; > + > + drm_dbg(dp->drm, "trying link config: rate %d lanes %d (capacity %d, r= equired %d)\n", > + cfg->rate, cfg->lanes, capacity, req_bw); > + > + spacemit_dp_link_disable(dp); > + > + /* Apply Hardware Settings */ > + if (spacemit_dp_set_plls(dp, cfg->rate, adjusted_mode->clock)) > + continue; > + > + if (spacemit_dp_phy_set_lanes(dp, cfg->lanes)) > + continue; > + > + if (spacemit_dp_phy_on(dp)) > + continue; [ ... ] > + /* > + * The DPU's pixel clock comes from the PHY PLL, so scanning out into an > + * untrained link never reaches CFG_RDY and wedges the CRTC on > + * flip_done. > + */ > + if (!trained) { [Severity: Medium] Can the !trained path in spacemit_dp_bridge_atomic_enable() return with the PHY pixel PLL powered down and stall the DPU commit? When dp->link.max_rate or dp->link.max_num_lanes was 0 during atomic_check() and the enable-time DPCD read yields limits below req_bw, every entry in spacemit_dp_link_priority_table is skipped before spacemit_dp_set_plls() or spacemit_dp_phy_on() is called, leaving the PHY powered off from spacemit_dp_bind() or spacemit_dp_bridge_atomic_disable(). The same happens if spacemit_dp_set_plls(), spacemit_dp_phy_set_lanes() or spacemit_dp_phy_on() fails after spacemit_dp_link_disable(). Because the DPU gets its pixel clock from dp->pll_clk, returning with PREPLL powered down prevents the DPU from latching CFG_RDY and stalls drm_atomic_helper_wait_for_flip_done() until the 3000 ms SATURN_CFG_RDY_TIMEOUT_MS timeout expires. [ ... ] > +static irqreturn_t spacemit_dp_irq_handler(int irq, void *data) > +{ > + struct spacemit_dp_dev *dp =3D data; > + irqreturn_t ret =3D IRQ_NONE; > + int idx; > + > + if (!drm_dev_enter(dp->drm, &idx)) > + return IRQ_NONE; [Severity: Medium] What happens if a level-high HPD interrupt fires after drm_dev_unplug() during master unbind? In spacemit_drm_master_unbind(), drm_dev_unplug() runs before drm_kms_helper_poll_fini(), drm_atomic_helper_shutdown() and component_unbind_all(). Once drm_dev_unplug() marks the device unplugged, drm_dev_enter() in spacemit_dp_irq_handler() returns false and the handler exits with IRQ_NONE without calling spacemit_dp_hw_clean_hpd() to clear the level-triggered interrupt latch, causing a hardirq storm until spacemit_dp_unbind() calls disable_irq(). [ ... ] > +static irqreturn_t spacemit_dp_hotplug_event_handler(int irq, void *data) > +{ > + struct spacemit_dp_dev *dp =3D data; > + enum drm_connector_status status; > + int idx; > + > + if (!drm_dev_enter(dp->drm, &idx)) > + return IRQ_HANDLED; > + > + /* > + * .detect() owns mode_lock and re-reads the sink caps on a fresh plug > + */ > + status =3D spacemit_dp_bridge_detect(&dp->bridge, dp->connector); > + drm_bridge_hpd_notify(&dp->bridge, status); > + > + drm_dev_exit(idx); > + return IRQ_HANDLED; > +} [Severity: Medium] Does drm_bridge_hpd_notify() ever notify DRM on external DisplayPort hotplug interrupts? In spacemit_dp_probe(), external DP sets dp->bridge.ops to DRM_BRIDGE_OP_DETECT | DRM_BRIDGE_OP_EDID without DRM_BRIDGE_OP_HPD. Because drm_bridge_connector_init() only registers an HPD callback on a bridge with DRM_BRIDGE_OP_HPD set, dp->bridge.hpd_cb is NULL and drm_bridge_hpd_notify() is a no-op. Moreover, calling spacemit_dp_bridge_detect() here updates dp->connector_status without updating dp->connector->status, so an unplug-and-replug while the pixel clock is running between 10-second poll intervals leaves both statuses as connector_status_connected and drops the hotplug event and EDID re-read. [ ... ] > +static int spacemit_dp_dev_init(struct spacemit_dp_dev *dp) > +{ [ ... ] > + /* Reset Controller and PHY */ > + regmap_write_bits(dp->regs, DP_SOFT_RESET, DP_CONTROLLER_RESET, > + FIELD_PREP(DP_CONTROLLER_RESET, 0x1)); > + regmap_write_bits(dp->regs, DP_SOFT_RESET, DP_PHY_RESET, > + FIELD_PREP(DP_PHY_RESET, 0x1)); > + regmap_write_bits(dp->regs, DP_SOFT_RESET, DP_HDCP_RESET, > + FIELD_PREP(DP_HDCP_RESET, 0x1)); > + regmap_write_bits(dp->regs, DP_SOFT_RESET, DP_AUX_RESET, > + FIELD_PREP(DP_AUX_RESET, 0x1)); > + regmap_write_bits(dp->regs, DP_SOFT_RESET, DP_VIDEO_RESET, > + FIELD_PREP(DP_VIDEO_RESET, 0x1)); > + usleep_range(5000, 8000); [ ... ] > + ret =3D spacemit_dp_set_plls(dp, SPACEMIT_DP_LINK_RATE_2_70, 148500); > + if (ret) > + return ret; > + > + ret =3D spacemit_dp_phy_set_lanes(dp, SPACEMIT_DP_LANE_2); > + if (ret) > + return ret; > + > + ret =3D spacemit_dp_phy_on(dp); > + if (ret) > + return ret; [Severity: High] When spacemit_dp_dev_init() runs a second time in spacemit_dp_bind() on eDP (or on component rebind), does pulsing DP_PHY_RESET wipe the PREPLL registers while clk_set_rate(dp->pll_clk, 148500000) short-circuits in the clock framework? On eDP, spacemit_dp_probe() calls spacemit_dp_dev_init(), which programs dp->pll_clk to 148.5 MHz, and the PHY clock provider caches that rate. When spacemit_dp_bind() calls spacemit_dp_dev_init() again, asserting DP_PHY_RESET resets the shared PHY PREPLL registers back to hardware defaults, but clk_set_rate(dp->pll_clk, 148500000) sees that the requested rate matches the cached rate and returns without calling the PHY clock's .set_rate callback. spacemit_dp_phy_on() (and later atomic_enable() for any 148.5 MHz mode) then tries to lock an unprogrammed PREPLL. [ ... ] > +static int spacemit_dp_bind(struct device *dev, struct device *master, > + void *data) > +{ > + struct spacemit_dp_dev *dp =3D dev_get_drvdata(dev); > + struct drm_device *drm =3D data; > + struct device_node *ep; > + int ret; > + > + dp->drm =3D drm; > + dp->aux.drm_dev =3D drm; > + ret =3D drm_dp_aux_register(&dp->aux); > + if (ret) { > + dev_err_probe(dev, ret, "failed to register DP AUX\n"); > + goto err_drm; > + } [ ... ] > + ret =3D spacemit_dp_dev_init(dp); > + if (ret) > + goto err_encoder; [Severity: Medium] Can userspace AUX or DDC transactions race with spacemit_dp_dev_init() and spacemit_dp_set_plls()? spacemit_dp_bind() calls drm_dp_aux_register(&dp->aux) before spacemit_dp_dev_init(dp), exposing /dev/drm_dp_aux* and the I2C adapter before the controller is initialized on external DP and while spacemit_dp_dev_init() powers down MPLL and asserts DP_CONTROLLER_RESET, DP_PHY_RESET and DP_AUX_RESET without holding dp->aux.hw_mutex. Similarly, in spacemit_dp_bridge_atomic_enable(), spacemit_dp_link_disable() releases dp->aux.hw_mutex before spacemit_dp_set_plls() power-cycles the MPLL that supplies the 16 MHz AUX reference clock. [Severity: Medium] If spacemit_dp_dev_init() fails here in spacemit_dp_bind(), should the error path call spacemit_dp_hw_disable(dp) the way spacemit_dp_probe() does? spacemit_dp_dev_init() enables interrupt masks and powers up the MPLL and PREPLL in spacemit_dp_set_plls() before calling spacemit_dp_phy_set_lanes() and spacemit_dp_phy_on(). Jumping to err_encoder on failure leaves the PLLs powered on, and because dp->component_added is true while bind failed, a later spacemit_dp_remove() will not run spacemit_dp_unbind() or spacemit_dp_hw_disable() either. [ ... ] > +/* Leave the DRM device, or power down a controller that never joined on= e. */ > +static void spacemit_dp_unregister(struct spacemit_dp_dev *dp) > +{ > + if (dp->component_added) > + component_del(dp->dev, &spacemit_dp_ops); > + else > + spacemit_dp_hw_disable(dp); > +} [Severity: Medium] Does spacemit_dp_unregister() leave the hardware powered on when dp->component_added is true but the component master was never bound? On eDP, spacemit_dp_probe() powers up the MPLL and analog TX blocks via spacemit_dp_dev_init() and spacemit_dp_edp_link_panel() sets dp->component_added =3D true. If the driver is removed while the aggregate DRM device is unbound (or if spacemit_dp_dev_init() failed during spacemit_dp_bind()), component_del() does not invoke spacemit_dp_unbind(), and the if (dp->component_added) branch skips spacemit_dp_hw_disable(dp). Calling spacemit_dp_hw_disable(dp) unconditionally after component_del() would ensure the PLLs and TX blocks are always powered down. [ ... ] > + ret =3D devm_of_dp_aux_populate_bus(&dp->aux, spacemit_dp_edp_link_pane= l); > + if (ret) { > + spacemit_dp_unregister(dp); > + return dev_err_probe(dev, ret, > + "eDP: failed to populate aux-bus panel\n"); > + } > + > + return 0; > + > +err_disable_pxclk: > + clk_disable_unprepare(dp->pxclk); > + return ret; > +} > + > +static void spacemit_dp_remove(struct platform_device *pdev) > +{ > + spacemit_dp_unregister(platform_get_drvdata(pdev)); > +} [Severity: Medium] On eDP, does spacemit_dp_remove() tear down the component and power down the controller before devres depopulates the AUX bus? devm_of_dp_aux_populate_bus() registers of_dp_aux_depopulate_bus_void() as a devres action, which runs during devres_release_all() after spacemit_dp_remove() returns. During driver unbind, spacemit_dp_remove() powers down the controller while the AUX-bus child panel device is still registered, and a deferred panel probe completing in that window can still invoke spacemit_dp_edp_link_panel() -> component_add() after spacemit_dp_unregister() has already run: CPU0 CPU1 (deferred_probe_work_func) __device_release_driver() spacemit_dp_remove() spacemit_dp_unregister() /* dp->component_added is false */ spacemit_dp_hw_disable() panel_edp_probe() spacemit_dp_edp_link_panel() component_add(dp->dev, ...) devres_release_all() of_dp_aux_depopulate_bus_void() /* dp freed while component remains registered */ Depopulating the AUX bus in spacemit_dp_remove() before spacemit_dp_unregister() (or registering spacemit_dp_unregister() as a devm action prior to devm_of_dp_aux_populate_bus()) avoids this ordering inversion. --=20 Sashiko AI review =C2=B7 https://sashiko.dev/#/patchset/20261121-k3-display= -v3-0-ec419e8e96b8@gmail.com?part=3D12 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 2E27C606A320 for ; Sat, 21 Nov 2026 08:08:36 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=lists.infradead.org header.i=@lists.infradead.org header.a=rsa-sha256 header.s=bombadil.20210309 header.b=U1OtbfcE; dkim=fail reason="signature verification failed" (2048-bit key) header.d=kernel.org header.i=@kernel.org header.a=rsa-sha256 header.s=k20260515 header.b=gudNDYEC 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=dLAntExyKXYdWI0gALJQZvI4ElOoTNWh5gEQsnm0bGU=; b=U1OtbfcEGTuRUyUnZv92Z9DJI8 W2t27//tL+0cyYGs/rPfrPXaMlVfpMsN5PuADWcCWqW9YkpOKJ0hAo1ivD3i1ogM2UVmmKrdwxyaM /uPAQMN0mAPO5ksd6oqZDtIPCy8832orgeCZpCl7qAGBT+eCxBWOPyjx905Q1SH5wGGRZRa44QoJE JsVQ4g3ZyGhdi5qo7ZiiRtB1UEPdW7JRwJ+TObHGd8uu8tB0RGBXJ5txNzSUXjlM5qW3v+IAOVMiX HcJ3mrTmPt1hYmgZyUK76wdYPBWcc0AMHwdvft6RXJrwIZvGcERdH2j21UjJzlrBCUEYFh0jXZuRs ye0noK6A==; Received: from localhost ([::1] helo=bombadil.infradead.org) by bombadil.infradead.org with esmtp (Exim 4.100.1 #2 (Red Hat Linux)) id 1xUg9D-0000000Gv2g-3qBd; Sat, 21 Nov 2026 08:08:35 +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 1xUg9C-0000000Gv2W-2a1c for linux-phy@lists.infradead.org; Sat, 21 Nov 2026 08:08:34 +0000 Received: from smtp.kernel.org (quasi.space.kernel.org [100.103.45.18]) by tor.source.kernel.org (Postfix) with ESMTP id 0756C60DA8; Sat, 21 Nov 2026 08:08:34 +0000 (UTC) Received: by smtp.kernel.org (Postfix) with ESMTPSA id 41E811F000C6; Sat, 21 Nov 2026 08:08:33 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=kernel.org; s=k20260515; t=1795248513; bh=3raE7u8WA73CEKC1arPbGq0UbR1DaFv/0W8Yfa/NNSg=; h=From:Subject:Reply-To:To:Cc:In-Reply-To:References:Date; b=gudNDYEClDBoqYsVwrw2cKPLBtfyUB9Kw6TPnG8C4WNAtnurIlAZ60nHmIbKGyjAl HRgm6cVFA/eqj7OAKt/lUn9GKb+mFFO0cucR2kC4HBSzsEeEnsWKbk4St6xI4tsPkm w+y+9zwMalKOLObRvEg0oa7acowA0xGylBpzzivCCgJnpNxUDoQFo+QXa1q1BnMunG HPIAWKUxeR6TdTMl6SIQnc28taFYEybm+/R6M6chObxmwj6lTmtsUfVS7QwotatJjU 5XE3meqtYWm60CJDuVUE45eKHPkvvxoLsfNbrnHMk/0ApM7WLfFpneX3NqXPDWk1w+ 8OOO5vb/FZYLQ== Message-ID: From: sashiko-bot@kernel.org Subject: Re: [PATCH v3 12/17] drm/spacemit: add Innosilicon DP/eDP controller bridge driver To: "Cody Kang" Cc: dri-devel@lists.freedesktop.org, devicetree@vger.kernel.org, linux-phy@lists.infradead.org, linux-clk@vger.kernel.org, robh@kernel.org, conor+dt@kernel.org, vkoul@kernel.org, neil.armstrong@linaro.org, olteanv@gmail.com In-Reply-To: <20261121-k3-display-v3-12-ec419e8e96b8@gmail.com> References: <20261121-k3-display-v3-0-ec419e8e96b8@gmail.com> <20261121-k3-display-v3-12-ec419e8e96b8@gmail.com> Date: Sat, 21 Nov 2026 08:08:32 +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 MTMgcG90ZW50aWFsCmlzc3VlcyB0byBjb25zaWRlcjoKLSBbSGlnaF0gZHJtL3NwYWNlbWl0OiBt aXNzaW5nIHByZS1lbXBoYXNpcyBzaGlmdCBpbgogIHNwYWNlbWl0X2RwX2xpbmtfYXBwbHlfYWRq dXN0KCkKLSBbSGlnaF0gZHJtL3NwYWNlbWl0OiByZXNldCBpbiBzcGFjZW1pdF9kcF9kZXZfaW5p dCgpIGRlc3luY3MgY2FjaGVkCiAgUFJFUExMIGNsayByYXRlCi0gW01lZGl1bV0gZHJtL3NwYWNl bWl0OiBicm9rZW4gSFBEIElSUSBub3RpZnkgaW4KICBzcGFjZW1pdF9kcF9ob3RwbHVnX2V2ZW50 X2hhbmRsZXIoKQotIFtNZWRpdW1dIGRybS9zcGFjZW1pdDogZmFsbGJhY2sgY2FwcyBpbgogIHNw YWNlbWl0X2RwX2h3X3JlYWRfc2lua19jYXBzKCkgYmxvY2sgcmV0cnkKLSBbTWVkaXVtXSBkcm0v c3BhY2VtaXQ6IG1pc3NpbmcgaHcgZGlzYWJsZSBpbiBzcGFjZW1pdF9kcF91bnJlZ2lzdGVyKCkK ICBhbmQgYmluZCgpCi0gW01lZGl1bV0gZHJtL3NwYWNlbWl0OiBtaXNzaW5nIHNwYWNlbWl0X2Rw X2h3X2Rpc2FibGUoKSBvbiBiaW5kIGluaXQKICBmYWlsdXJlCi0gW01lZGl1bV0gZHJtL3NwYWNl bWl0OiBwaXhlbCBjbG9jayB0cnVuY2F0aW9uIHRvIE1IeiBpbiBUVSBhbmQgSEJMQU5LCiAgY2Fs Y3VsYXRpb24KLSBbTWVkaXVtXSBkcm0vc3BhY2VtaXQ6IHVuYWNrbm93bGVkZ2VkIGxldmVsLWhp Z2ggSFBEIElSUSBpbgogIHNwYWNlbWl0X2RwX2lycV9oYW5kbGVyKCkKLSBbTWVkaXVtXSBkcm0v c3BhY2VtaXQ6IHVubG9ja2VkIGRwLT5saW5rIGFuZCBkcC0+ZHBjZCByZWFkcyBpbgogIG1vZGVf dmFsaWQgYW5kIGNoZWNrCi0gW01lZGl1bV0gZHJtL3NwYWNlbWl0OiBBVVggcmVnaXN0ZXJlZCBi ZWZvcmUgaW5pdCBhbmQgTVBMTCByZXNldAogIHdpdGhvdXQgaHdfbXV0ZXgKLSBbTWVkaXVtXSBk cm0vc3BhY2VtaXQ6IHBpeGVsIFBMTCBsZWZ0IHBvd2VyZWQgZG93biBvbiB1bnRyYWluZWQgbGlu awogIGluIGF0b21pY19lbmFibGUKLSBbTWVkaXVtXSBkcm0vc3BhY2VtaXQ6IG5lc3RlZCBBVVgg cmV0cmllcyBhbmQgZmFsbGJhY2sgaW4KICBzcGFjZW1pdF9kcF9hdXhfdHJhbnNmZXIoKQotIFtN ZWRpdW1dIGRybS9zcGFjZW1pdDogc3BhY2VtaXRfZHBfcmVtb3ZlKCkgcnVucyBiZWZvcmUgZGV2 bSBBVVggYnVzCiAgZGVwb3B1bGF0aW9uCi0tCgpjb21taXQgYTFhNTkxNWU4MmQyZGUzMmQ5ZTJm ZTcwOTUxNzJhMzU2ODZkZjNiMgpBdXRob3I6IENvZHkgS2FuZyA8Y29keWthbmdAdnNpdC5haT4K CmRybS9zcGFjZW1pdDogYWRkIElubm9zaWxpY29uIERQL2VEUCBjb250cm9sbGVyIGJyaWRnZSBk cml2ZXIKClRoaXMgY29tbWl0IGFkZHMgdGhlIERSTSBicmlkZ2UgZHJpdmVyIGZvciB0aGUgSW5u b3NpbGljb24gRGlzcGxheVBvcnQgYW5kCmVtYmVkZGVkIERpc3BsYXlQb3J0IGNvbnRyb2xsZXIg ZG93bnN0cmVhbSBvZiB0aGUgU3BhY2VtaVQgU2F0dXJuIERQVS4KCj4gZGlmZiAtLWdpdCBhL2Ry aXZlcnMvZ3B1L2RybS9zcGFjZW1pdC9zcGFjZW1pdF9pbm5vX2RwLmMgYi9kcml2ZXJzL2dwdS9k cm0vc3BhY2VtaXQvc3BhY2VtaXRfaW5ub19kcC5jCj4gbmV3IGZpbGUgbW9kZSAxMDA2NDQKPiBp bmRleCAwMDAwMDAwMDAwMDAwLi40MzZlNWYxNWI0MDM5Cj4gLS0tIC9kZXYvbnVsbAo+ICsrKyBi L2RyaXZlcnMvZ3B1L2RybS9zcGFjZW1pdC9zcGFjZW1pdF9pbm5vX2RwLmMKWyAuLi4gXQo+ICsJ cmV0ID0gcmVnbWFwX3JlYWRfcG9sbF90aW1lb3V0KGRwLT5yZWdzLCBEUF9HRU5FUkFMX0lOVEVS UlVQVCwgdmFsLAo+ICsJCQkJICAgICAgIHZhbCAmIERQX0FVWF9SRVBMWV9FVkVOVF9JTlRfU1RB LAo+ICsJCQkJICAgICAgIFNQQUNFTUlUX0RQX0FVWF9QT0xMX1VTLAo+ICsJCQkJICAgICAgIFNQ QUNFTUlUX0RQX0FVWF9USU1FT1VUX1VTKTsKPiArCWlmIChyZXQpIHsKPiArCQlpZiAocmV0cmll cyA8IFNQQUNFTUlUX0RQX0FVWF9NQVhfUkVUUklFUykgewo+ICsJCQlyZXRyaWVzKys7Cj4gKwkJ CXNwYWNlbWl0X2RwX2F1eF9od19yZXNldChkcCk7Cj4gKwkJCWRldl9kYmcoZHAtPmRldiwKPiAr CQkJCSJBVVggdGltZW91dCwgY21kPTB4JXggYWRkcj0weCV4IHNpemU9JXp1IHJldHJ5ICVkLyVk XG4iLAo+ICsJCQkJY21kLCBtc2ctPmFkZHJlc3MsIG1zZy0+c2l6ZSwgcmV0cmllcywgU1BBQ0VN SVRfRFBfQVVYX01BWF9SRVRSSUVTKTsKPiArCQkJZ290byByZXRyeV9laW87Cj4gKwkJfQo+ICsK PiArCQlkZXZfZXJyX3JhdGVsaW1pdGVkKGRwLT5kZXYsCj4gKwkJCQkgICAgIkFVWCB0cmFuc2Zl ciB0aW1lb3V0LCByZXE6IDB4JXgsIGNtZDogMHgleCwgYWRkcjogMHgleCwgc2l6ZSAlenVcbiIs Cj4gKwkJCQkgICAgbXNnLT5yZXF1ZXN0LCBjbWQsIG1zZy0+YWRkcmVzcywgbXNnLT5zaXplKTsK PiArCQlyZXR1cm4gcmV0Owo+ICsJfQoKW1NldmVyaXR5OiBNZWRpdW1dCkRvZXMgcmV0cnlpbmcg dGltZWQtb3V0IHRyYW5zZmVycyBpbnNpZGUgc3BhY2VtaXRfZHBfYXV4X3RyYW5zZmVyKCkgY29t cG91bmQKd2l0aCB0aGUgRFJNIERQIGhlbHBlcnMgYW5kIHNwYWNlbWl0X2RwX2h3X3JlYWRfc2lu a19jYXBzKCkgdG8gc3RhbGwgZm9yCm92ZXIgdHdvIG1pbnV0ZXMgdW5kZXIgZHAtPm1vZGVfbG9j az8KCkVhY2ggdGltZWQtb3V0IHNwYWNlbWl0X2RwX2F1eF90cmFuc2ZlcigpIGNhbGwgd2FpdHMg NCAqIDIwMCBtcyAofjgxMyBtcykuCmRybV9kcF9kcGNkX2FjY2VzcygpIHJldHJpZXMgbmVnYXRp dmUgZXJyb3JzIDMyIHRpbWVzLApkcm1fZHBfZHBjZF9yZWFkX2RhdGEoKSBmYWxscyBiYWNrIHRv IGEgc2Vjb25kIDMyLXJldHJ5IHByb2JlIHZpYQpkcm1fZHBfZHBjZF9yZWFkYigpLCBhbmQgc3Bh Y2VtaXRfZHBfaHdfcmVhZF9zaW5rX2NhcHMoKSBsb29wcwpTUEFDRU1JVF9EUF9TSU5LX1JFQURZ X1JFVFJJRVMgKDMpIHRpbWVzLCBtdWx0aXBseWluZyBhIHNpbmdsZSB1bnJlc3BvbnNpdmUKc2lu ayBpbnRvIDc2OCBjb25zZWN1dGl2ZSAyMDAgbXMgdGltZW91dHMgKH4xNTYgc2Vjb25kcykgd2hp bGUgaG9sZGluZwpkcC0+bW9kZV9sb2NrIG9yIGNvbXBvbmVudCBiaW5kIGxvY2tzLgoKVGhpcyBp cyBhbHNvIHJlYWNoYWJsZSBvbiBlRFAgZHVyaW5nIHNwYWNlbWl0X2RwX2JpbmQoKSwgd2hpY2gg Y2hlY2tzCnNwYWNlbWl0X2RwX2h3X2RldGVjdF9ocGQoKSBhbmQgY2FsbHMgc3BhY2VtaXRfZHBf aHdfcmVhZF9zaW5rX2NhcHMoKSBldmVuCnRob3VnaCBEUF9IUERfSU5fU1RBVFVTIGlzIG5vdCBt ZWFuaW5nZnVsIG9uIGVEUCBhbmQgdGhlIHBhbmVsIGlzIHBvd2VyZWQKb2ZmIHVudGlsIGF0b21p Y19wcmVfZW5hYmxlOyB3aGVuIHRoYXQgcmVhZCBmYWlscywgdGhlIG5vbi16ZXJvIGZhbGxiYWNr CmxpbWl0cyBzZXQgYnkgc3BhY2VtaXRfZHBfaHdfcmVhZF9zaW5rX2NhcHMoKSBwcmV2ZW50CnNw YWNlbWl0X2RwX2JyaWRnZV9hdG9taWNfZW5hYmxlKCkgZnJvbSByZS1yZWFkaW5nIERQQ0Qgb25j ZSB0aGUgcGFuZWwgaXMKcG93ZXJlZC4KClsgLi4uIF0KCj4gK3N0YXRpYyB2b2lkIHNwYWNlbWl0 X2RwX2h3X3JlYWRfc2lua19jYXBzKHN0cnVjdCBzcGFjZW1pdF9kcF9kZXYgKmRwKQo+ICt7Clsg Li4uIF0KPiArCWlmIChyZXQgPCAwKSB7Cj4gKwkJZHJtX3dhcm5fcmF0ZWxpbWl0ZWQoZHAtPmRy bSwKPiArCQkJCSAgICAgImZhaWxlZCB0byByZWFkIERQQ0QgYWZ0ZXIgJWQgcmV0cmllczogJXpk XG4iLAo+ICsJCQkJICAgICBTUEFDRU1JVF9EUF9TSU5LX1JFQURZX1JFVFJJRVMsIHJldCk7Cj4g KwkJZHAtPmxpbmsucmV2aXNpb24gPSBEUF9EUENEX1JFVl8xNDsKPiArCQlkcC0+bGluay5tYXhf cmF0ZSA9IFNQQUNFTUlUX0RQX0xJTktfUkFURV81XzQwOwo+ICsJCWRwLT5saW5rLm1heF9udW1f bGFuZXMgPSBTUEFDRU1JVF9EUF9MQU5FXzI7Cj4gKwkJZHAtPmxpbmsuZW5oYW5jZWRfZnJhbWlu ZyA9IDE7Cj4gKwkJcmV0dXJuOwo+ICsJfQoKW1NldmVyaXR5OiBNZWRpdW1dCkRvZXMgcG9wdWxh dGluZyBub24temVybyBmYWxsYmFjayB2YWx1ZXMgaW4gZHAtPmxpbmsubWF4X3JhdGUgYW5kCmRw LT5saW5rLm1heF9udW1fbGFuZXMgd2hlbiBzcGFjZW1pdF9kcF9od19yZWFkX3NpbmtfY2Fwcygp IGZhaWxzIHByZXZlbnQKc3BhY2VtaXRfZHBfYnJpZGdlX2F0b21pY19lbmFibGUoKSBmcm9tIHJl dHJ5aW5nIHRoZSBEUENEIHJlYWQ/CgpzcGFjZW1pdF9kcF9icmlkZ2VfYXRvbWljX2VuYWJsZSgp IG9ubHkgcmV0cmllcyBzcGFjZW1pdF9kcF9od19yZWFkX3NpbmtfY2FwcygpCndoZW4gIWRwLT5s aW5rLm1heF9yYXRlIHx8ICFkcC0+bGluay5tYXhfbnVtX2xhbmVzLiAgSWYgYW4gZWFybGllciBE UENEIHJlYWQKYXQgYmluZCBvciBkZXRlY3QgdGltZSBmYWlscyAoZm9yIGV4YW1wbGUsIG9uIGVE UCBkdXJpbmcgc3BhY2VtaXRfZHBfYmluZCgpCndoZW4gbm9pc3kgRFBfSFBEX0lOX1NUQVRVUyBy ZWFkcyBoaWdoIGJlZm9yZSB0aGUgcGFuZWwgaXMgcG93ZXJlZCwgb3Igb24gYQpzbG93LXdha2lu ZyBtb25pdG9yKSwgbWF4X3JhdGUgYW5kIG1heF9udW1fbGFuZXMgYXJlIHNldCB0byA1LjQgR2Jw cyBhbmQgMgpsYW5lcyB3aGlsZSBkcC0+ZHBjZCByZW1haW5zIHplcm9lZCBvciBzdGFsZS4gIFRo ZSBlbmFibGUtdGltZSByZXRyeSBpcyB0aGVuCnNraXBwZWQsIGNsYW1waW5nIDQtbGFuZSBwYW5l bHMgb3IgbW9uaXRvcnMgdG8gMiBsYW5lcyBhbmQgcnVubmluZyBsaW5rCnRyYWluaW5nIHdpdGhv dXQgdmFsaWQgZHAtPmRwY2QgY2FwYWJpbGl0eSBieXRlcyAoc3VjaCBhcyBUUFMzIHN1cHBvcnQp LgoKWyAuLi4gXQoKPiArc3RhdGljIGludCBzcGFjZW1pdF9kcF9saW5rX2FwcGx5X2FkanVzdChz dHJ1Y3Qgc3BhY2VtaXRfZHBfZGV2ICpkcCwKPiArCQkJCQkgY29uc3QgdTggKmxpbmtfc3RhdHVz LAo+ICsJCQkJICAgIGVudW0gc3BhY2VtaXRfZHBfbGFuZV9jb3VudCBsYW5lcywKPiArCQkJCSAg ICB1OCAqdHJhaW5pbmdfc2V0KQo+ICt7Cj4gKwl1bmlvbiBwaHlfY29uZmlndXJlX29wdHMgb3B0 cyA9IHsKPiArCQkuZHAgPSB7Cj4gKwkJCS5sYW5lcyA9IGxhbmVzLAo+ICsJCQkuc2V0X3ZvbHRh Z2VzID0gdHJ1ZSwKPiArCQl9LAo+ICsJfTsKPiArCWludCBpLCByZXQ7Cj4gKwo+ICsJZm9yIChp ID0gMDsgaSA8IGxhbmVzOyBpKyspIHsKPiArCQl1OCB2ID0gZHJtX2RwX2dldF9hZGp1c3RfcmVx dWVzdF92b2x0YWdlKGxpbmtfc3RhdHVzLCBpKTsKPiArCQl1OCBwID0gZHJtX2RwX2dldF9hZGp1 c3RfcmVxdWVzdF9wcmVfZW1waGFzaXMobGlua19zdGF0dXMsIGkpOwo+ICsJCXU4IHZfYml0czsK PiArCj4gKwkJaWYgKHYgPj0gU1BBQ0VNSVRfRFBfU1dJTkdfTUFYKQo+ICsJCQl2ID0gU1BBQ0VN SVRfRFBfU1dJTkdfTUFYOwo+ICsJCWlmIChwID49IFNQQUNFTUlUX0RQX1BSRUVNUF9NQVgpCj4g KwkJCXAgPSBTUEFDRU1JVF9EUF9QUkVFTVBfTUFYOwo+ICsKPiArCQlvcHRzLmRwLnZvbHRhZ2Vb aV0gPSB2Owo+ICsJCW9wdHMuZHAucHJlW2ldID0gcDsKPiArCj4gKwkJdl9iaXRzID0gdjsKPiAr CQlpZiAodiA9PSBTUEFDRU1JVF9EUF9TV0lOR19NQVgpCj4gKwkJCXZfYml0cyB8PSBEUF9UUkFJ Tl9NQVhfU1dJTkdfUkVBQ0hFRDsKPiArCQlpZiAocCA9PSBTUEFDRU1JVF9EUF9QUkVFTVBfTUFY KQo+ICsJCQl2X2JpdHMgfD0gRFBfVFJBSU5fTUFYX1BSRV9FTVBIQVNJU19SRUFDSEVEOwo+ICsK PiArCQl0cmFpbmluZ19zZXRbaV0gPSB2X2JpdHMgfCAocCA8PCBEUF9UUkFJTl9QUkVfRU1QSEFT SVNfU0hJRlQpOwo+ICsJfQoKW1NldmVyaXR5OiBIaWdoXQpJc24ndCB0aGUgcmV0dXJuIHZhbHVl IG9mIGRybV9kcF9nZXRfYWRqdXN0X3JlcXVlc3RfcHJlX2VtcGhhc2lzKCkgYWxyZWFkeQpzaGlm dGVkIGxlZnQgYnkgRFBfVFJBSU5fUFJFX0VNUEhBU0lTX1NISUZUICgzKT8KCkZvciBwcmUtZW1w aGFzaXMgbGV2ZWxzIDEsIDIgYW5kIDMsIGRybV9kcF9nZXRfYWRqdXN0X3JlcXVlc3RfcHJlX2Vt cGhhc2lzKCkKcmV0dXJucyA4LCAxNiBhbmQgMjQuICBDb21wYXJpbmcgcCA+PSBTUEFDRU1JVF9E UF9QUkVFTVBfTUFYICgyKSB3aXRob3V0CnNoaWZ0aW5nIHJpZ2h0IGJ5IERQX1RSQUlOX1BSRV9F TVBIQVNJU19TSElGVCBmaXJzdCBjYXVzZXMgYW55IHJlcXVlc3QgZm9yCnByZS1lbXBoYXNpcyBs ZXZlbCAxIHRvIGJlIGNsYW1wZWQgdG8gbGV2ZWwgMiwgbWFya2VkIHdpdGgKRFBfVFJBSU5fTUFY X1BSRV9FTVBIQVNJU19SRUFDSEVELCBhbmQgc2hpZnRlZCBhIHNlY29uZCB0aW1lIHdoZW4gYnVp bGRpbmcKdHJhaW5pbmdfc2V0W2ldLgoKWyAuLi4gXQoKPiArc3RhdGljIHZvaWQgc3BhY2VtaXRf ZHBfaHdfc2V0X21zYV9hbmRfZW5hYmxlX3ZpZGVvKHN0cnVjdCBzcGFjZW1pdF9kcF9kZXYgKmRw LAo+ICsJCQkJCQkgICAgY29uc3Qgc3RydWN0IGRybV9kaXNwbGF5X21vZGUgKm1vZGUsCj4gKwkJ CQkJCSAgICBlbnVtIHNwYWNlbWl0X2RwX2xpbmtfcmF0ZSByYXRlLAo+ICsJCQkJCQkgICAgZW51 bSBzcGFjZW1pdF9kcF9sYW5lX2NvdW50IGxhbmVzKQo+ICt7Cj4gKwl1NjQgaGJfbnVtOwo+ICsJ dTMyIGxpbmtfcmF0ZTsKPiArCXUzMiBmcDsgLyogUGl4ZWwgY2xvY2sgaW4gTUh6ICovCj4gKwl1 MzIgdHUsIHR1X2ZyYWMsIHR1X2ludCwgcmRfdGhyZXM7Cj4gKwl1MzIgaHN5bmNfbGVuLCBoc3Rh cnQsIHZzdGFydDsKPiArCj4gKwkvKiBtb2RlLT5jbG9jayB1bml0IGlzIGtIeiwgZnAgdW5pdCBp cyBNSHogKi8KPiArCWZwID0gbW9kZS0+Y2xvY2sgLyAxMDAwOwo+ICsKPiArCWlmIChmcCA9PSAw KQo+ICsJCWZwID0gMTsgLyogUHJldmVudCBkaXZpc2lvbiBieSB6ZXJvICovCj4gKwo+ICsJLyoK PiArCSAqIEhCbGFuayBpbnRlcnZhbCA9IChodG90YWwgLSBoYWN0aXZlKSAqIChMaW5rU3ltYm9s Q2xvY2sgLyA0KSAvCj4gKwkgKiBQaXhlbENsb2NrLCB3aGVyZSBMaW5rU3ltYm9sQ2xvY2sgPSBM aW5rUmF0ZSAqIDEwMCAoMS42MkcgLT4gMTYyTUh6KS4KPiArCSAqIHJhdGUgaXMgaW4ga2JpdC9z LCBzbyBsaW5rX3JhdGUgPSByYXRlIC8gMTAwMDAgZ2l2ZXMgdGhlIDE2MiwgMjcwLAo+ICsJICog NTQwIGZvcm0gdXNlZCBiZWxvdy4KPiArCSAqLwo+ICsJbGlua19yYXRlID0gcmF0ZSAvIDEwMDAw Owo+ICsKPiArCS8qIE11bHRpcGx5IGJlZm9yZSBkaXZpZGluZzogaGJfbnVtID0gaGJsYW5rICog KGxpbmtfcmF0ZSAvIDQpIC8gZnAgKi8KPiArCWhiX251bSA9ICh1NjQpKG1vZGUtPmh0b3RhbCAt IG1vZGUtPmhkaXNwbGF5KSAqIGxpbmtfcmF0ZTsKPiArCWRvX2RpdihoYl9udW0sIDQgKiBmcCk7 Cj4gKwo+ICsJLyogVHJhbnNmZXIgdW5pdDogdHUgPSBmcCAqIGJwcCAqIDY0MCAvICg4ICogbGFu ZXMgKiBsaW5rX3JhdGUpICovCj4gKwl0dSA9IGRpdl91NjQoKHU2NClmcCAqIFNQQUNFTUlUX0RQ X0JQUCAqIDY0MCwgOCAqIGxhbmVzICogbGlua19yYXRlKTsKCltTZXZlcml0eTogTWVkaXVtXQpE b2VzIHRydW5jYXRpbmcgbW9kZS0+Y2xvY2sgdG8gaW50ZWdlciBNSHogaW4gZnAgdW5kZXJlc3Rp bWF0ZSB0aGUgdHJhbnNmZXIKdW5pdCBzaXplIGZvciBmcmFjdGlvbmFsLU1IeiBwaXhlbCBjbG9j a3M/CgpzcGFjZW1pdF9kcF9zZXRfcGxscygpIHByb2dyYW1zIGRwLT5wbGxfY2xrIHRvIG1vZGUt PmNsb2NrICogMTAwMCBIeiwgc28gYQoxMDgwcDYwIG1vZGUgcnVucyBhdCAxNDguNSBNSHogKGFu ZCA3MjBwNjAgYXQgNzQuMjUgTUh6KSwgd2hlcmVhcwpmcCA9IG1vZGUtPmNsb2NrIC8gMTAwMCB0 cnVuY2F0ZXMgdGhvc2UgY2xvY2tzIHRvIDE0OCBNSHogYW5kIDc0IE1Iei4gIEZvcgoxMDgwcDYw IG9uIDIgbGFuZXMgYXQgMi43IEdicHMsIHRoaXMgcHJvZ3JhbXMgYSBUVSBvZiA1Mi42IGluc3Rl YWQgb2YgNTIuOCwKcGFja2luZyBmZXdlciBieXRlcyBwZXIgVFUgdGhhbiB0aGUgcGl4ZWwgY2xv Y2sgZGVsaXZlcnMgaW50byB0aGUgdmlkZW8KRklGTy4gIFVzaW5nIG1vZGUtPmNsb2NrIGluIGtI eiBhbmQgcmF0ZSAvIDEwIGRpcmVjdGx5IGF2b2lkcyB0aGUKdHJ1bmNhdGlvbi4KClsgLi4uIF0K Cj4gK3N0YXRpYyBlbnVtIGRybV9tb2RlX3N0YXR1cwo+ICtzcGFjZW1pdF9kcF9icmlkZ2VfbW9k ZV92YWxpZChzdHJ1Y3QgZHJtX2JyaWRnZSAqYnJpZGdlLAo+ICsJCQkgICAgICBjb25zdCBzdHJ1 Y3QgZHJtX2Rpc3BsYXlfaW5mbyAqaW5mbywKPiArCQkJIGNvbnN0IHN0cnVjdCBkcm1fZGlzcGxh eV9tb2RlICptb2RlKQo+ICt7Cj4gKwlzdHJ1Y3Qgc3BhY2VtaXRfZHBfZGV2ICpkcCA9IGNvbnRh aW5lcl9vZihicmlkZ2UsCj4gKwkJCQkJCSAgc3RydWN0IHNwYWNlbWl0X2RwX2RldiwKPiArCQkJ CQkJICBicmlkZ2UpOwo+ICsJdW5zaWduZWQgaW50IG1heF9saW5rX3JhdGUsIG1heF9sYW5lczsK PiArCXU2NCBtYXhfYncsIHJlcV9idzsKPiArCj4gKwkvKgo+ICsJICogUHJlZmVyIHRoZSBsaW5r IGxpbWl0cyB0aGUgZHJpdmVyIG1haW50YWluczogdGhleSBzdGFydCBhcyB0aGUKPiArCSAqIHNp bmsncyBjYXBhYmlsaXRpZXMgY2xhbXBlZCB0byB0aGUgUEhZIGFuZCBhcmUgbmFycm93ZWQgYWZ0 ZXIgYQo+ICsJICogZmFpbGVkIHRyYWluaW5nLiBkcm1fZHBfbWF4X2xpbmtfcmF0ZSgpIGlzIGlu IDEwIGtiaXQvcy4KPiArCSAqLwo+ICsJaWYgKGRwLT5saW5rLm1heF9yYXRlICYmIGRwLT5saW5r Lm1heF9udW1fbGFuZXMpIHsKPiArCQltYXhfbGlua19yYXRlID0gZHAtPmxpbmsubWF4X3JhdGUg LyAxMDsKPiArCQltYXhfbGFuZXMgPSBkcC0+bGluay5tYXhfbnVtX2xhbmVzOwo+ICsJfSBlbHNl IHsKPiArCQltYXhfbGlua19yYXRlID0gbWluX3QodW5zaWduZWQgaW50LAo+ICsJCQkJICAgICAg ZHJtX2RwX21heF9saW5rX3JhdGUoZHAtPmRwY2QpLAo+ICsJCQkJICAgICAgU1BBQ0VNSVRfRFBf U09VUkNFX01BWF9SQVRFIC8gMTApOwo+ICsJCW1heF9sYW5lcyA9IGRybV9kcF9tYXhfbGFuZV9j b3VudChkcC0+ZHBjZCk7Cj4gKwl9CgpbU2V2ZXJpdHk6IE1lZGl1bV0KQ2FuIHNwYWNlbWl0X2Rw X2JyaWRnZV9tb2RlX3ZhbGlkKCkgYW5kIHNwYWNlbWl0X2RwX2JyaWRnZV9hdG9taWNfY2hlY2so KQpyYWNlIHdpdGggY29uY3VycmVudCB1cGRhdGVzIHRvIGRwLT5saW5rIGFuZCBkcC0+ZHBjZD8K CnNwYWNlbWl0X2RwX2h3X3JlYWRfc2lua19jYXBzKCkgYW5kIHNwYWNlbWl0X2RwX2xpbmtfbmFy cm93KCkgdXBkYXRlCmRwLT5kcGNkLCBkcC0+bGluay5tYXhfcmF0ZSBhbmQgZHAtPmxpbmsubWF4 X251bV9sYW5lcyB1bmRlciBkcC0+bW9kZV9sb2NrCmZyb20gdGhlIGhvdHBsdWcgSVJRIHRocmVh ZCAoc3BhY2VtaXRfZHBfaG90cGx1Z19ldmVudF9oYW5kbGVyKCkpIGFuZCBmcm9tCm5vbi1ibG9j a2luZyBhdG9taWMgY29tbWl0cyAoc3BhY2VtaXRfZHBfYnJpZGdlX2F0b21pY19lbmFibGUoKSks IG5laXRoZXIgb2YKd2hpY2ggaG9sZHMgdGhlIERSTSBtb2Rlc2V0IGxvY2tzLiAgUmVhZGluZyB0 aG9zZSBmaWVsZHMgaW4Kc3BhY2VtaXRfZHBfYnJpZGdlX21vZGVfdmFsaWQoKSBhbmQgc3BhY2Vt aXRfZHBfYnJpZGdlX2F0b21pY19jaGVjaygpCndpdGhvdXQgZHAtPm1vZGVfbG9jayBjYW4gb2Jz ZXJ2ZSBhIHRvcm4gcmF0ZS9sYW5lIHBhaXIgb3IgcGFydGlhbGx5IHJlYWQKZHAtPmRwY2QgYnl0 ZXMuCgpbIC4uLiBdCgo+ICsJZm9yICh0cmFpbmVkID0gZmFsc2UsIGkgPSBzdGFydDsKPiArCSAg ICAgaSA8IEFSUkFZX1NJWkUoc3BhY2VtaXRfZHBfbGlua19wcmlvcml0eV90YWJsZSk7IGkrKykg ewo+ICsJCXUzMiBjYXBhY2l0eTsKPiArCj4gKwkJY2ZnID0gJnNwYWNlbWl0X2RwX2xpbmtfcHJp b3JpdHlfdGFibGVbaV07Cj4gKwo+ICsJCS8qIFNvdXJjZSBhbmQgc2luayBsaW1pdHMgKi8KPiAr CQlpZiAoY2ZnLT5yYXRlID4gZHAtPmxpbmsubWF4X3JhdGUgfHwgY2ZnLT5sYW5lcyA+IGRwLT5s aW5rLm1heF9udW1fbGFuZXMpCj4gKwkJCWNvbnRpbnVlOwo+ICsKPiArCQkvKiBCYW5kd2lkdGgg cmVxdWlyZW1lbnQgKi8KPiArCQljYXBhY2l0eSA9IHNwYWNlbWl0X2RwX2NhbGNfbGlua19jYXBh Y2l0eShjZmctPnJhdGUsCj4gKwkJCQkJCQkgIGNmZy0+bGFuZXMpOwo+ICsJCWlmIChjYXBhY2l0 eSA8IHJlcV9idykKPiArCQkJY29udGludWU7Cj4gKwo+ICsJCWRybV9kYmcoZHAtPmRybSwgInRy eWluZyBsaW5rIGNvbmZpZzogcmF0ZSAlZCBsYW5lcyAlZCAoY2FwYWNpdHkgJWQsIHJlcXVpcmVk ICVkKVxuIiwKPiArCQkJY2ZnLT5yYXRlLCBjZmctPmxhbmVzLCBjYXBhY2l0eSwgcmVxX2J3KTsK PiArCj4gKwkJc3BhY2VtaXRfZHBfbGlua19kaXNhYmxlKGRwKTsKPiArCj4gKwkJLyogQXBwbHkg SGFyZHdhcmUgU2V0dGluZ3MgKi8KPiArCQlpZiAoc3BhY2VtaXRfZHBfc2V0X3BsbHMoZHAsIGNm Zy0+cmF0ZSwgYWRqdXN0ZWRfbW9kZS0+Y2xvY2spKQo+ICsJCQljb250aW51ZTsKPiArCj4gKwkJ aWYgKHNwYWNlbWl0X2RwX3BoeV9zZXRfbGFuZXMoZHAsIGNmZy0+bGFuZXMpKQo+ICsJCQljb250 aW51ZTsKPiArCj4gKwkJaWYgKHNwYWNlbWl0X2RwX3BoeV9vbihkcCkpCj4gKwkJCWNvbnRpbnVl OwpbIC4uLiBdCj4gKwkvKgo+ICsJICogVGhlIERQVSdzIHBpeGVsIGNsb2NrIGNvbWVzIGZyb20g dGhlIFBIWSBQTEwsIHNvIHNjYW5uaW5nIG91dCBpbnRvIGFuCj4gKwkgKiB1bnRyYWluZWQgbGlu ayBuZXZlciByZWFjaGVzIENGR19SRFkgYW5kIHdlZGdlcyB0aGUgQ1JUQyBvbgo+ICsJICogZmxp cF9kb25lLgo+ICsJICovCj4gKwlpZiAoIXRyYWluZWQpIHsKCltTZXZlcml0eTogTWVkaXVtXQpD YW4gdGhlICF0cmFpbmVkIHBhdGggaW4gc3BhY2VtaXRfZHBfYnJpZGdlX2F0b21pY19lbmFibGUo KSByZXR1cm4gd2l0aCB0aGUKUEhZIHBpeGVsIFBMTCBwb3dlcmVkIGRvd24gYW5kIHN0YWxsIHRo ZSBEUFUgY29tbWl0PwoKV2hlbiBkcC0+bGluay5tYXhfcmF0ZSBvciBkcC0+bGluay5tYXhfbnVt X2xhbmVzIHdhcyAwIGR1cmluZyBhdG9taWNfY2hlY2soKQphbmQgdGhlIGVuYWJsZS10aW1lIERQ Q0QgcmVhZCB5aWVsZHMgbGltaXRzIGJlbG93IHJlcV9idywgZXZlcnkgZW50cnkgaW4Kc3BhY2Vt aXRfZHBfbGlua19wcmlvcml0eV90YWJsZSBpcyBza2lwcGVkIGJlZm9yZSBzcGFjZW1pdF9kcF9z ZXRfcGxscygpIG9yCnNwYWNlbWl0X2RwX3BoeV9vbigpIGlzIGNhbGxlZCwgbGVhdmluZyB0aGUg UEhZIHBvd2VyZWQgb2ZmIGZyb20Kc3BhY2VtaXRfZHBfYmluZCgpIG9yIHNwYWNlbWl0X2RwX2Jy aWRnZV9hdG9taWNfZGlzYWJsZSgpLiAgVGhlIHNhbWUgaGFwcGVucwppZiBzcGFjZW1pdF9kcF9z ZXRfcGxscygpLCBzcGFjZW1pdF9kcF9waHlfc2V0X2xhbmVzKCkgb3IKc3BhY2VtaXRfZHBfcGh5 X29uKCkgZmFpbHMgYWZ0ZXIgc3BhY2VtaXRfZHBfbGlua19kaXNhYmxlKCkuICBCZWNhdXNlIHRo ZQpEUFUgZ2V0cyBpdHMgcGl4ZWwgY2xvY2sgZnJvbSBkcC0+cGxsX2NsaywgcmV0dXJuaW5nIHdp dGggUFJFUExMIHBvd2VyZWQKZG93biBwcmV2ZW50cyB0aGUgRFBVIGZyb20gbGF0Y2hpbmcgQ0ZH X1JEWSBhbmQgc3RhbGxzCmRybV9hdG9taWNfaGVscGVyX3dhaXRfZm9yX2ZsaXBfZG9uZSgpIHVu dGlsIHRoZSAzMDAwIG1zClNBVFVSTl9DRkdfUkRZX1RJTUVPVVRfTVMgdGltZW91dCBleHBpcmVz LgoKWyAuLi4gXQoKPiArc3RhdGljIGlycXJldHVybl90IHNwYWNlbWl0X2RwX2lycV9oYW5kbGVy KGludCBpcnEsIHZvaWQgKmRhdGEpCj4gK3sKPiArCXN0cnVjdCBzcGFjZW1pdF9kcF9kZXYgKmRw ID0gZGF0YTsKPiArCWlycXJldHVybl90IHJldCA9IElSUV9OT05FOwo+ICsJaW50IGlkeDsKPiAr Cj4gKwlpZiAoIWRybV9kZXZfZW50ZXIoZHAtPmRybSwgJmlkeCkpCj4gKwkJcmV0dXJuIElSUV9O T05FOwoKW1NldmVyaXR5OiBNZWRpdW1dCldoYXQgaGFwcGVucyBpZiBhIGxldmVsLWhpZ2ggSFBE IGludGVycnVwdCBmaXJlcyBhZnRlciBkcm1fZGV2X3VucGx1ZygpCmR1cmluZyBtYXN0ZXIgdW5i aW5kPwoKSW4gc3BhY2VtaXRfZHJtX21hc3Rlcl91bmJpbmQoKSwgZHJtX2Rldl91bnBsdWcoKSBy dW5zIGJlZm9yZQpkcm1fa21zX2hlbHBlcl9wb2xsX2ZpbmkoKSwgZHJtX2F0b21pY19oZWxwZXJf c2h1dGRvd24oKSBhbmQKY29tcG9uZW50X3VuYmluZF9hbGwoKS4gIE9uY2UgZHJtX2Rldl91bnBs dWcoKSBtYXJrcyB0aGUgZGV2aWNlIHVucGx1Z2dlZCwKZHJtX2Rldl9lbnRlcigpIGluIHNwYWNl bWl0X2RwX2lycV9oYW5kbGVyKCkgcmV0dXJucyBmYWxzZSBhbmQgdGhlIGhhbmRsZXIKZXhpdHMg d2l0aCBJUlFfTk9ORSB3aXRob3V0IGNhbGxpbmcgc3BhY2VtaXRfZHBfaHdfY2xlYW5faHBkKCkg dG8gY2xlYXIgdGhlCmxldmVsLXRyaWdnZXJlZCBpbnRlcnJ1cHQgbGF0Y2gsIGNhdXNpbmcgYSBo YXJkaXJxIHN0b3JtIHVudGlsCnNwYWNlbWl0X2RwX3VuYmluZCgpIGNhbGxzIGRpc2FibGVfaXJx KCkuCgpbIC4uLiBdCgo+ICtzdGF0aWMgaXJxcmV0dXJuX3Qgc3BhY2VtaXRfZHBfaG90cGx1Z19l dmVudF9oYW5kbGVyKGludCBpcnEsIHZvaWQgKmRhdGEpCj4gK3sKPiArCXN0cnVjdCBzcGFjZW1p dF9kcF9kZXYgKmRwID0gZGF0YTsKPiArCWVudW0gZHJtX2Nvbm5lY3Rvcl9zdGF0dXMgc3RhdHVz Owo+ICsJaW50IGlkeDsKPiArCj4gKwlpZiAoIWRybV9kZXZfZW50ZXIoZHAtPmRybSwgJmlkeCkp Cj4gKwkJcmV0dXJuIElSUV9IQU5ETEVEOwo+ICsKPiArCS8qCj4gKwkgKiAuZGV0ZWN0KCkgb3du cyBtb2RlX2xvY2sgYW5kIHJlLXJlYWRzIHRoZSBzaW5rIGNhcHMgb24gYSBmcmVzaCBwbHVnCj4g KwkgKi8KPiArCXN0YXR1cyA9IHNwYWNlbWl0X2RwX2JyaWRnZV9kZXRlY3QoJmRwLT5icmlkZ2Us IGRwLT5jb25uZWN0b3IpOwo+ICsJZHJtX2JyaWRnZV9ocGRfbm90aWZ5KCZkcC0+YnJpZGdlLCBz dGF0dXMpOwo+ICsKPiArCWRybV9kZXZfZXhpdChpZHgpOwo+ICsJcmV0dXJuIElSUV9IQU5ETEVE Owo+ICt9CgpbU2V2ZXJpdHk6IE1lZGl1bV0KRG9lcyBkcm1fYnJpZGdlX2hwZF9ub3RpZnkoKSBl dmVyIG5vdGlmeSBEUk0gb24gZXh0ZXJuYWwgRGlzcGxheVBvcnQKaG90cGx1ZyBpbnRlcnJ1cHRz PwoKSW4gc3BhY2VtaXRfZHBfcHJvYmUoKSwgZXh0ZXJuYWwgRFAgc2V0cyBkcC0+YnJpZGdlLm9w cyB0bwpEUk1fQlJJREdFX09QX0RFVEVDVCB8IERSTV9CUklER0VfT1BfRURJRCB3aXRob3V0IERS TV9CUklER0VfT1BfSFBELgpCZWNhdXNlIGRybV9icmlkZ2VfY29ubmVjdG9yX2luaXQoKSBvbmx5 IHJlZ2lzdGVycyBhbiBIUEQgY2FsbGJhY2sgb24gYQpicmlkZ2Ugd2l0aCBEUk1fQlJJREdFX09Q X0hQRCBzZXQsIGRwLT5icmlkZ2UuaHBkX2NiIGlzIE5VTEwgYW5kCmRybV9icmlkZ2VfaHBkX25v dGlmeSgpIGlzIGEgbm8tb3AuICBNb3Jlb3ZlciwgY2FsbGluZwpzcGFjZW1pdF9kcF9icmlkZ2Vf ZGV0ZWN0KCkgaGVyZSB1cGRhdGVzIGRwLT5jb25uZWN0b3Jfc3RhdHVzIHdpdGhvdXQKdXBkYXRp bmcgZHAtPmNvbm5lY3Rvci0+c3RhdHVzLCBzbyBhbiB1bnBsdWctYW5kLXJlcGx1ZyB3aGlsZSB0 aGUgcGl4ZWwKY2xvY2sgaXMgcnVubmluZyBiZXR3ZWVuIDEwLXNlY29uZCBwb2xsIGludGVydmFs cyBsZWF2ZXMgYm90aCBzdGF0dXNlcyBhcwpjb25uZWN0b3Jfc3RhdHVzX2Nvbm5lY3RlZCBhbmQg ZHJvcHMgdGhlIGhvdHBsdWcgZXZlbnQgYW5kIEVESUQgcmUtcmVhZC4KClsgLi4uIF0KCj4gK3N0 YXRpYyBpbnQgc3BhY2VtaXRfZHBfZGV2X2luaXQoc3RydWN0IHNwYWNlbWl0X2RwX2RldiAqZHAp Cj4gK3sKWyAuLi4gXQo+ICsJLyogUmVzZXQgQ29udHJvbGxlciBhbmQgUEhZICovCj4gKwlyZWdt YXBfd3JpdGVfYml0cyhkcC0+cmVncywgRFBfU09GVF9SRVNFVCwgRFBfQ09OVFJPTExFUl9SRVNF VCwKPiArCQkJICBGSUVMRF9QUkVQKERQX0NPTlRST0xMRVJfUkVTRVQsIDB4MSkpOwo+ICsJcmVn bWFwX3dyaXRlX2JpdHMoZHAtPnJlZ3MsIERQX1NPRlRfUkVTRVQsIERQX1BIWV9SRVNFVCwKPiAr CQkJICBGSUVMRF9QUkVQKERQX1BIWV9SRVNFVCwgMHgxKSk7Cj4gKwlyZWdtYXBfd3JpdGVfYml0 cyhkcC0+cmVncywgRFBfU09GVF9SRVNFVCwgRFBfSERDUF9SRVNFVCwKPiArCQkJICBGSUVMRF9Q UkVQKERQX0hEQ1BfUkVTRVQsIDB4MSkpOwo+ICsJcmVnbWFwX3dyaXRlX2JpdHMoZHAtPnJlZ3Ms IERQX1NPRlRfUkVTRVQsIERQX0FVWF9SRVNFVCwKPiArCQkJICBGSUVMRF9QUkVQKERQX0FVWF9S RVNFVCwgMHgxKSk7Cj4gKwlyZWdtYXBfd3JpdGVfYml0cyhkcC0+cmVncywgRFBfU09GVF9SRVNF VCwgRFBfVklERU9fUkVTRVQsCj4gKwkJCSAgRklFTERfUFJFUChEUF9WSURFT19SRVNFVCwgMHgx KSk7Cj4gKwl1c2xlZXBfcmFuZ2UoNTAwMCwgODAwMCk7ClsgLi4uIF0KPiArCXJldCA9IHNwYWNl bWl0X2RwX3NldF9wbGxzKGRwLCBTUEFDRU1JVF9EUF9MSU5LX1JBVEVfMl83MCwgMTQ4NTAwKTsK PiArCWlmIChyZXQpCj4gKwkJcmV0dXJuIHJldDsKPiArCj4gKwlyZXQgPSBzcGFjZW1pdF9kcF9w aHlfc2V0X2xhbmVzKGRwLCBTUEFDRU1JVF9EUF9MQU5FXzIpOwo+ICsJaWYgKHJldCkKPiArCQly ZXR1cm4gcmV0Owo+ICsKPiArCXJldCA9IHNwYWNlbWl0X2RwX3BoeV9vbihkcCk7Cj4gKwlpZiAo cmV0KQo+ICsJCXJldHVybiByZXQ7CgpbU2V2ZXJpdHk6IEhpZ2hdCldoZW4gc3BhY2VtaXRfZHBf ZGV2X2luaXQoKSBydW5zIGEgc2Vjb25kIHRpbWUgaW4gc3BhY2VtaXRfZHBfYmluZCgpIG9uIGVE UAoob3Igb24gY29tcG9uZW50IHJlYmluZCksIGRvZXMgcHVsc2luZyBEUF9QSFlfUkVTRVQgd2lw ZSB0aGUgUFJFUExMCnJlZ2lzdGVycyB3aGlsZSBjbGtfc2V0X3JhdGUoZHAtPnBsbF9jbGssIDE0 ODUwMDAwMCkgc2hvcnQtY2lyY3VpdHMgaW4gdGhlCmNsb2NrIGZyYW1ld29yaz8KCk9uIGVEUCwg c3BhY2VtaXRfZHBfcHJvYmUoKSBjYWxscyBzcGFjZW1pdF9kcF9kZXZfaW5pdCgpLCB3aGljaCBw cm9ncmFtcwpkcC0+cGxsX2NsayB0byAxNDguNSBNSHosIGFuZCB0aGUgUEhZIGNsb2NrIHByb3Zp ZGVyIGNhY2hlcyB0aGF0IHJhdGUuICBXaGVuCnNwYWNlbWl0X2RwX2JpbmQoKSBjYWxscyBzcGFj ZW1pdF9kcF9kZXZfaW5pdCgpIGFnYWluLCBhc3NlcnRpbmcKRFBfUEhZX1JFU0VUIHJlc2V0cyB0 aGUgc2hhcmVkIFBIWSBQUkVQTEwgcmVnaXN0ZXJzIGJhY2sgdG8gaGFyZHdhcmUKZGVmYXVsdHMs IGJ1dCBjbGtfc2V0X3JhdGUoZHAtPnBsbF9jbGssIDE0ODUwMDAwMCkgc2VlcyB0aGF0IHRoZSBy ZXF1ZXN0ZWQKcmF0ZSBtYXRjaGVzIHRoZSBjYWNoZWQgcmF0ZSBhbmQgcmV0dXJucyB3aXRob3V0 IGNhbGxpbmcgdGhlIFBIWSBjbG9jaydzCi5zZXRfcmF0ZSBjYWxsYmFjay4gIHNwYWNlbWl0X2Rw X3BoeV9vbigpIChhbmQgbGF0ZXIgYXRvbWljX2VuYWJsZSgpIGZvciBhbnkKMTQ4LjUgTUh6IG1v ZGUpIHRoZW4gdHJpZXMgdG8gbG9jayBhbiB1bnByb2dyYW1tZWQgUFJFUExMLgoKWyAuLi4gXQoK PiArc3RhdGljIGludCBzcGFjZW1pdF9kcF9iaW5kKHN0cnVjdCBkZXZpY2UgKmRldiwgc3RydWN0 IGRldmljZSAqbWFzdGVyLAo+ICsJCQkgICAgdm9pZCAqZGF0YSkKPiArewo+ICsJc3RydWN0IHNw YWNlbWl0X2RwX2RldiAqZHAgPSBkZXZfZ2V0X2RydmRhdGEoZGV2KTsKPiArCXN0cnVjdCBkcm1f ZGV2aWNlICpkcm0gPSBkYXRhOwo+ICsJc3RydWN0IGRldmljZV9ub2RlICplcDsKPiArCWludCBy ZXQ7Cj4gKwo+ICsJZHAtPmRybSA9IGRybTsKPiArCWRwLT5hdXguZHJtX2RldiA9IGRybTsKPiAr CXJldCA9IGRybV9kcF9hdXhfcmVnaXN0ZXIoJmRwLT5hdXgpOwo+ICsJaWYgKHJldCkgewo+ICsJ CWRldl9lcnJfcHJvYmUoZGV2LCByZXQsICJmYWlsZWQgdG8gcmVnaXN0ZXIgRFAgQVVYXG4iKTsK PiArCQlnb3RvIGVycl9kcm07Cj4gKwl9ClsgLi4uIF0KPiArCXJldCA9IHNwYWNlbWl0X2RwX2Rl dl9pbml0KGRwKTsKPiArCWlmIChyZXQpCj4gKwkJZ290byBlcnJfZW5jb2RlcjsKCltTZXZlcml0 eTogTWVkaXVtXQpDYW4gdXNlcnNwYWNlIEFVWCBvciBEREMgdHJhbnNhY3Rpb25zIHJhY2Ugd2l0 aCBzcGFjZW1pdF9kcF9kZXZfaW5pdCgpIGFuZApzcGFjZW1pdF9kcF9zZXRfcGxscygpPwoKc3Bh Y2VtaXRfZHBfYmluZCgpIGNhbGxzIGRybV9kcF9hdXhfcmVnaXN0ZXIoJmRwLT5hdXgpIGJlZm9y ZQpzcGFjZW1pdF9kcF9kZXZfaW5pdChkcCksIGV4cG9zaW5nIC9kZXYvZHJtX2RwX2F1eCogYW5k IHRoZSBJMkMgYWRhcHRlcgpiZWZvcmUgdGhlIGNvbnRyb2xsZXIgaXMgaW5pdGlhbGl6ZWQgb24g ZXh0ZXJuYWwgRFAgYW5kIHdoaWxlCnNwYWNlbWl0X2RwX2Rldl9pbml0KCkgcG93ZXJzIGRvd24g TVBMTCBhbmQgYXNzZXJ0cyBEUF9DT05UUk9MTEVSX1JFU0VULApEUF9QSFlfUkVTRVQgYW5kIERQ X0FVWF9SRVNFVCB3aXRob3V0IGhvbGRpbmcgZHAtPmF1eC5od19tdXRleC4gIFNpbWlsYXJseSwK aW4gc3BhY2VtaXRfZHBfYnJpZGdlX2F0b21pY19lbmFibGUoKSwgc3BhY2VtaXRfZHBfbGlua19k aXNhYmxlKCkgcmVsZWFzZXMKZHAtPmF1eC5od19tdXRleCBiZWZvcmUgc3BhY2VtaXRfZHBfc2V0 X3BsbHMoKSBwb3dlci1jeWNsZXMgdGhlIE1QTEwgdGhhdApzdXBwbGllcyB0aGUgMTYgTUh6IEFV WCByZWZlcmVuY2UgY2xvY2suCgpbU2V2ZXJpdHk6IE1lZGl1bV0KSWYgc3BhY2VtaXRfZHBfZGV2 X2luaXQoKSBmYWlscyBoZXJlIGluIHNwYWNlbWl0X2RwX2JpbmQoKSwgc2hvdWxkIHRoZSBlcnJv cgpwYXRoIGNhbGwgc3BhY2VtaXRfZHBfaHdfZGlzYWJsZShkcCkgdGhlIHdheSBzcGFjZW1pdF9k cF9wcm9iZSgpIGRvZXM/CgpzcGFjZW1pdF9kcF9kZXZfaW5pdCgpIGVuYWJsZXMgaW50ZXJydXB0 IG1hc2tzIGFuZCBwb3dlcnMgdXAgdGhlIE1QTEwgYW5kClBSRVBMTCBpbiBzcGFjZW1pdF9kcF9z ZXRfcGxscygpIGJlZm9yZSBjYWxsaW5nIHNwYWNlbWl0X2RwX3BoeV9zZXRfbGFuZXMoKQphbmQg c3BhY2VtaXRfZHBfcGh5X29uKCkuICBKdW1waW5nIHRvIGVycl9lbmNvZGVyIG9uIGZhaWx1cmUg bGVhdmVzIHRoZQpQTExzIHBvd2VyZWQgb24sIGFuZCBiZWNhdXNlIGRwLT5jb21wb25lbnRfYWRk ZWQgaXMgdHJ1ZSB3aGlsZSBiaW5kIGZhaWxlZCwKYSBsYXRlciBzcGFjZW1pdF9kcF9yZW1vdmUo KSB3aWxsIG5vdCBydW4gc3BhY2VtaXRfZHBfdW5iaW5kKCkgb3IKc3BhY2VtaXRfZHBfaHdfZGlz YWJsZSgpIGVpdGhlci4KClsgLi4uIF0KCj4gKy8qIExlYXZlIHRoZSBEUk0gZGV2aWNlLCBvciBw b3dlciBkb3duIGEgY29udHJvbGxlciB0aGF0IG5ldmVyIGpvaW5lZCBvbmUuICovCj4gK3N0YXRp YyB2b2lkIHNwYWNlbWl0X2RwX3VucmVnaXN0ZXIoc3RydWN0IHNwYWNlbWl0X2RwX2RldiAqZHAp Cj4gK3sKPiArCWlmIChkcC0+Y29tcG9uZW50X2FkZGVkKQo+ICsJCWNvbXBvbmVudF9kZWwoZHAt PmRldiwgJnNwYWNlbWl0X2RwX29wcyk7Cj4gKwllbHNlCj4gKwkJc3BhY2VtaXRfZHBfaHdfZGlz YWJsZShkcCk7Cj4gK30KCltTZXZlcml0eTogTWVkaXVtXQpEb2VzIHNwYWNlbWl0X2RwX3VucmVn aXN0ZXIoKSBsZWF2ZSB0aGUgaGFyZHdhcmUgcG93ZXJlZCBvbiB3aGVuCmRwLT5jb21wb25lbnRf YWRkZWQgaXMgdHJ1ZSBidXQgdGhlIGNvbXBvbmVudCBtYXN0ZXIgd2FzIG5ldmVyIGJvdW5kPwoK T24gZURQLCBzcGFjZW1pdF9kcF9wcm9iZSgpIHBvd2VycyB1cCB0aGUgTVBMTCBhbmQgYW5hbG9n IFRYIGJsb2NrcyB2aWEKc3BhY2VtaXRfZHBfZGV2X2luaXQoKSBhbmQgc3BhY2VtaXRfZHBfZWRw X2xpbmtfcGFuZWwoKSBzZXRzCmRwLT5jb21wb25lbnRfYWRkZWQgPSB0cnVlLiAgSWYgdGhlIGRy aXZlciBpcyByZW1vdmVkIHdoaWxlIHRoZSBhZ2dyZWdhdGUKRFJNIGRldmljZSBpcyB1bmJvdW5k IChvciBpZiBzcGFjZW1pdF9kcF9kZXZfaW5pdCgpIGZhaWxlZCBkdXJpbmcKc3BhY2VtaXRfZHBf YmluZCgpKSwgY29tcG9uZW50X2RlbCgpIGRvZXMgbm90IGludm9rZSBzcGFjZW1pdF9kcF91bmJp bmQoKSwKYW5kIHRoZSBpZiAoZHAtPmNvbXBvbmVudF9hZGRlZCkgYnJhbmNoIHNraXBzIHNwYWNl bWl0X2RwX2h3X2Rpc2FibGUoZHApLgpDYWxsaW5nIHNwYWNlbWl0X2RwX2h3X2Rpc2FibGUoZHAp IHVuY29uZGl0aW9uYWxseSBhZnRlciBjb21wb25lbnRfZGVsKCkKd291bGQgZW5zdXJlIHRoZSBQ TExzIGFuZCBUWCBibG9ja3MgYXJlIGFsd2F5cyBwb3dlcmVkIGRvd24uCgpbIC4uLiBdCgo+ICsJ cmV0ID0gZGV2bV9vZl9kcF9hdXhfcG9wdWxhdGVfYnVzKCZkcC0+YXV4LCBzcGFjZW1pdF9kcF9l ZHBfbGlua19wYW5lbCk7Cj4gKwlpZiAocmV0KSB7Cj4gKwkJc3BhY2VtaXRfZHBfdW5yZWdpc3Rl cihkcCk7Cj4gKwkJcmV0dXJuIGRldl9lcnJfcHJvYmUoZGV2LCByZXQsCj4gKwkJCQkgICAgICJl RFA6IGZhaWxlZCB0byBwb3B1bGF0ZSBhdXgtYnVzIHBhbmVsXG4iKTsKPiArCX0KPiArCj4gKwly ZXR1cm4gMDsKPiArCj4gK2Vycl9kaXNhYmxlX3B4Y2xrOgo+ICsJY2xrX2Rpc2FibGVfdW5wcmVw YXJlKGRwLT5weGNsayk7Cj4gKwlyZXR1cm4gcmV0Owo+ICt9Cj4gKwo+ICtzdGF0aWMgdm9pZCBz cGFjZW1pdF9kcF9yZW1vdmUoc3RydWN0IHBsYXRmb3JtX2RldmljZSAqcGRldikKPiArewo+ICsJ c3BhY2VtaXRfZHBfdW5yZWdpc3RlcihwbGF0Zm9ybV9nZXRfZHJ2ZGF0YShwZGV2KSk7Cj4gK30K CltTZXZlcml0eTogTWVkaXVtXQpPbiBlRFAsIGRvZXMgc3BhY2VtaXRfZHBfcmVtb3ZlKCkgdGVh ciBkb3duIHRoZSBjb21wb25lbnQgYW5kIHBvd2VyIGRvd24gdGhlCmNvbnRyb2xsZXIgYmVmb3Jl IGRldnJlcyBkZXBvcHVsYXRlcyB0aGUgQVVYIGJ1cz8KCmRldm1fb2ZfZHBfYXV4X3BvcHVsYXRl X2J1cygpIHJlZ2lzdGVycyBvZl9kcF9hdXhfZGVwb3B1bGF0ZV9idXNfdm9pZCgpIGFzIGEKZGV2 cmVzIGFjdGlvbiwgd2hpY2ggcnVucyBkdXJpbmcgZGV2cmVzX3JlbGVhc2VfYWxsKCkgYWZ0ZXIK c3BhY2VtaXRfZHBfcmVtb3ZlKCkgcmV0dXJucy4gIER1cmluZyBkcml2ZXIgdW5iaW5kLCBzcGFj ZW1pdF9kcF9yZW1vdmUoKQpwb3dlcnMgZG93biB0aGUgY29udHJvbGxlciB3aGlsZSB0aGUgQVVY LWJ1cyBjaGlsZCBwYW5lbCBkZXZpY2UgaXMgc3RpbGwKcmVnaXN0ZXJlZCwgYW5kIGEgZGVmZXJy ZWQgcGFuZWwgcHJvYmUgY29tcGxldGluZyBpbiB0aGF0IHdpbmRvdyBjYW4gc3RpbGwKaW52b2tl IHNwYWNlbWl0X2RwX2VkcF9saW5rX3BhbmVsKCkgLT4gY29tcG9uZW50X2FkZCgpIGFmdGVyCnNw YWNlbWl0X2RwX3VucmVnaXN0ZXIoKSBoYXMgYWxyZWFkeSBydW46CgpDUFUwICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgIENQVTEgKGRlZmVycmVkX3Byb2JlX3dvcmtfZnVuYykKX19k ZXZpY2VfcmVsZWFzZV9kcml2ZXIoKQogIHNwYWNlbWl0X2RwX3JlbW92ZSgpCiAgICBzcGFjZW1p dF9kcF91bnJlZ2lzdGVyKCkKICAgICAgLyogZHAtPmNvbXBvbmVudF9hZGRlZCBpcyBmYWxzZSAq LwogICAgICBzcGFjZW1pdF9kcF9od19kaXNhYmxlKCkKICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICBwYW5lbF9lZHBfcHJvYmUoKQogICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgc3BhY2VtaXRfZHBfZWRwX2xpbmtfcGFuZWwoKQogICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICBjb21wb25lbnRfYWRkKGRwLT5kZXYsIC4uLikK ICBkZXZyZXNfcmVsZWFzZV9hbGwoKQogICAgb2ZfZHBfYXV4X2RlcG9wdWxhdGVfYnVzX3ZvaWQo KQogICAgLyogZHAgZnJlZWQgd2hpbGUgY29tcG9uZW50IHJlbWFpbnMgcmVnaXN0ZXJlZCAqLwoK RGVwb3B1bGF0aW5nIHRoZSBBVVggYnVzIGluIHNwYWNlbWl0X2RwX3JlbW92ZSgpIGJlZm9yZQpz cGFjZW1pdF9kcF91bnJlZ2lzdGVyKCkgKG9yIHJlZ2lzdGVyaW5nIHNwYWNlbWl0X2RwX3VucmVn aXN0ZXIoKSBhcyBhIGRldm0KYWN0aW9uIHByaW9yIHRvIGRldm1fb2ZfZHBfYXV4X3BvcHVsYXRl X2J1cygpKSBhdm9pZHMgdGhpcyBvcmRlcmluZwppbnZlcnNpb24uCgotLSAKU2FzaGlrbyBBSSBy ZXZpZXcgwrcgaHR0cHM6Ly9zYXNoaWtvLmRldi8jL3BhdGNoc2V0LzIwMjYxMTIxLWszLWRpc3Bs YXktdjMtMC1lYzQxOWU4ZTk2YjhAZ21haWwuY29tP3BhcnQ9MTIKCi0tIApsaW51eC1waHkgbWFp bGluZyBsaXN0CmxpbnV4LXBoeUBsaXN0cy5pbmZyYWRlYWQub3JnCmh0dHBzOi8vbGlzdHMuaW5m cmFkZWFkLm9yZy9tYWlsbWFuL2xpc3RpbmZvL2xpbnV4LXBoeQo=