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 0BFA3397692 for ; Mon, 31 Aug 2026 08:41:09 +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=1788165671; cv=none; b=N5SErCqpYgj4dtlQ7m+Zihn9N6h5J5G6M4JXwb1QQHGnNJTW0mOoySSUEhbO8pK5FqWt3hGk7C080YgyD06yjEbBbbqQ0u2Wl0rTHZy7NVAkzbKmzA/f9j3bFCc+CDROkxOv7x6cebts/M//6IBVVBZErq09/K293U6nyPsbulQ= ARC-Message-Signature:i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1788165671; c=relaxed/simple; bh=l0SI8SLuurkMXpxi82jxXzBQ8NVvmiXbaSp6jmeaBo4=; h=From:Subject:To:Cc:In-Reply-To:References:Content-Type:Date: Message-Id; b=kL4k+WHx7uZS6aQzm8x/waBn71cxUmaDpIqy6o/dXzUdT6PeZYz5iqkelr7yvA20aBA3cN2KMdStzSQsTjt4ROElhMvi9FmZdLv2LZSNCvhtkc62zYWol1hZGrc2BCWIgBvIv+xZAtghYY9HTA25yK+k0wBkQuR67UmBQ7jgAno= ARC-Authentication-Results:i=1; smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b=MzKA/KSs; 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="MzKA/KSs" Received: by smtp.kernel.org (Postfix) with ESMTPSA id 30DA11F000E9; Mon, 31 Aug 2026 08:41:08 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=kernel.org; s=k20260515; t=1788165669; bh=SYxdarkq2tSLaE0LEwk03SmpjTFmGU6/ydnxJALoFJI=; h=From:Subject:Reply-To:To:Cc:In-Reply-To:References:Date; b=MzKA/KSsfm6Hjb4InbYVJ2XTLVor6c7MrG3XLiTzGi1O48c9O4CA0Y9B2BpcNH62w NjTDYXSG5dyV+x+aazxjG3Ur21BW1ypv2Ihbjpaek6wzdnG7xwhC3YvtEg+crpkFc8 cUHCc3PNiPgwNUCr8vPnkhpX/9OhFEr+jP/5E5IQenKTHV8v+eQ4E5vuebJgoHsJk1 w/lvmtooj1vYHd+psMEe+c+Zt/hgRonYENzaEFNJ/nRFQ9cY9Fw4QbtzP/x5oee4Fx uU+vlRSKNw1fW8odT+NYON8+yViQp7uuu316Rd9hMTqkXWPU/I/FB0UdyeylsT6thn 6w+5/LYfJHBFA== From: sashiko-bot@kernel.org Subject: Re: [PATCH v1 3/4] usb: cdns3: Add CIX Sky1 glue driver Reply-To: sashiko-reviews@lists.linux.dev To: "Hongliang Yang" Cc: neil.armstrong@linaro.org, olteanv@gmail.com, conor+dt@kernel.org, devicetree@vger.kernel.org, vkoul@kernel.org, linux-phy@lists.infradead.org, robh@kernel.org In-Reply-To: <20260831082309.3854507-4-hongliang.yang@cixtech.com> References: <20260831082309.3854507-1-hongliang.yang@cixtech.com> <20260831082309.3854507-4-hongliang.yang@cixtech.com> Content-Type: text/plain; charset=utf-8 Content-Transfer-Encoding: quoted-printable Date: Mon, 31 Aug 2026 08:41:07 +0000 Message-Id: <20260831084108.30DA11F000E9@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 11 potential issue= (s) to consider: - [High] IOMEM, clock, and reset leaks on probe error paths. - [High] Missing get_device() causes unsafe device pointer storage in match= function, leading to Use-After-Free. - [High] Global state corruption of shared static cdns_sky1_auxdata array i= n probe. - [High] Flawed platform_data memory management causes leaks or double-free= s when multiple or zero children exist. - [High] Unbalanced Runtime PM state during driver removal. - [High] Incorrect hardware reset logic during driver removal. - [High] Signed integer overflow in clock frequency calculations. - [High] Writing inverted AXI_HALT bitmask to the capability register inadv= ertently sets all other bits to 1. - [Medium] Device node reference leak in sky1_of_get_addr_by_name. - [Medium] Clock error recovery paths destructively nullify devres managed = clock pointers. - [Low] Signed integer overflow when defining CFG_3XPORT_MODE_DIS_SSP. -- commit f5b41d8b4e76c0521bdb8557f0e54b6023714500 Author: Hongliang Yang usb: cdns3: Add CIX Sky1 glue driver Add glue layer for the Cadence USBSSP DRD controller on CIX Sky1 SoCs. The glue driver handles platform-specific initialization including clocks, resets, and PHY configuration. > diff --git a/drivers/usb/cdns3/cdnsp-sky1.c b/drivers/usb/cdns3/cdnsp-sky= 1.c > new file mode 100644 > --- /dev/null > +++ b/drivers/usb/cdns3/cdnsp-sky1.c > @@ -0,0 +1,682 @@ [ ... ] > +static int cdnsp_sky1_clk_enable_resume(struct device *dev) > +{ [ ... ] > +err_usb_clks: > + cix_usb_clks[i] =3D NULL; > + while (--i >=3D 0) { > + clk_disable_unprepare(cix_usb_clks[i]); > + cix_usb_clks[i] =3D NULL; [Severity: Medium] Is it safe to nullify these clock pointers?=20 Because the clocks are devres-managed, devres will still properly free them, but nullifying the pointers destroys the driver's ability to ever reference them again.=20 If a transient error occurs during a resume attempt, any subsequent retry or cleanup will fail because the driver lost its internal pointers. > + } > + return ret; > +}; [ ... ] > +static void cdnsp_sky1_configure_controller(struct cdnsp_sky1 *data) > +{ [ ... ] > + writel(AXI_HALT, data->device_base + D_XEC_AXI_CAP); > + writel(AXI_HALT, data->xhci_base + D_XEC_AXI_CAP); > + writel(data->axi_bmax_value, data->device_base + D_XEC_AXI_CTRL0); > + writel(data->axi_bmax_value, data->xhci_base + D_XEC_AXI_CTRL0); > + writel((~(u32)(AXI_HALT)), data->device_base + D_XEC_AXI_CAP); > + writel((~(u32)(AXI_HALT)), data->xhci_base + D_XEC_AXI_CAP); [Severity: High] Does this inadvertently overwrite other capability bits?=20 AXI_HALT is defined as BIT(31). Blindly writing ~(u32)(AXI_HALT) yields 0x7FFFFFFF, which sets bits 0 through 30 to 1 rather than preserving their existing state with a read-modify-write or clearing them with 0.=20 Overwriting 31 capability bits with 1s can enable unintended modes or cause unpredictable hardware behavior. > + clk =3D data->sof_clk_freq; > + v0 =3D 25 * clk / 100000000; > + v1 =3D clk / 10000; > + v2 =3D clk / 10; > + writel(((v0 > 1) ? v0 - 1 : 1), data->device_base > + + D_XEC_PRE_REG_250NS); > + writel((unsigned int)((v1 / 100 > 1) > 0 ? (v1 / 100) - 1 : 1), > + data->device_base + D_XEC_PRE_REG_1US); > + writel((unsigned int)((v1 / 10 > 1) > 0 ? (v1 / 10) - 1 : 1), > + data->device_base + D_XEC_PRE_REG_10US); > + writel(((v1) > 1 ? v1 - 1 : 1), data->device_base > + + D_XEC_PRE_REG_100US); > + writel((unsigned int)((125 * clk / 1000000) > 1 ? (125 * clk / 1000000)= : 1), > + data->device_base + D_XEC_PRE_REG_125US); [Severity: High] Will this calculation overflow for frequencies above 17.1 MHz? Because clk is typed as a signed 32-bit int, 125 * clk will exceed INT_MAX (2,147,483,647) and overflow for values above approximately 17.1 MHz. This yields a negative value that improperly configures the hardware pre-scaler registers.=20 Could this be mitigated by using an unsigned 64-bit cast, such as 125ULL * = clk? [ ... ] > +static void *sky1_of_get_addr_by_name(struct device_node *parent, char *= name) > +{ > + struct device_node *node; > + int index; > + > + node =3D of_get_next_child(parent, NULL); > + if (node) { > + index =3D of_property_match_string(node, "reg-names", name); > + if (index >=3D 0) > + return of_iomap(node, index); > + } > + return NULL; > +} [Severity: Medium] Can this leak the device node reference? of_get_next_child() acquires and returns a device node with an incremented reference count, but the reference is never released with of_node_put() on either the success or failure paths. [ ... ] > +static struct of_dev_auxdata cdns_sky1_auxdata[] =3D { > + { > + .compatible =3D "cdns,usb3", > + }, > + {}, > +}; > + > +static int cdnsp_sky1_probe(struct platform_device *pdev) > +{ [ ... ] > + data->device_base =3D sky1_get_addr_by_name(dev, "dev"); > + if (!data->device_base) > + return -ENODEV; > + ret =3D cdnsp_sky1_drd_init(data); > + if (ret =3D=3D -ETIMEDOUT) > + return -EPROBE_DEFER; > + if (ret) > + return ret; [Severity: High] Do these error paths leak the IOMEM regions, hardware clocks, and resets? cdnsp_sky1_probe() manually maps IOMEM regions using sky1_get_addr_by_name() and enables hardware clocks in cdnsp_sky1_drd_init(). If subsequent initialization steps fail, the function returns directly or jumps to the err label without unmapping the IOMEM with iounmap(), disabling the clocks, or re-asserting the hardware resets. Since probe can be retried multiple times, these leaked resources will accumulate. > + data->oc_gpio =3D devm_gpiod_get_optional(data->dev, "oc", GPIOD_IN); > + if (IS_ERR(data->oc_gpio)) { > + dev_err(data->dev, "can not get oc_gpio\n"); > + ret =3D PTR_ERR(data->oc_gpio); > + return ret; > + } > + if (data->oc_gpio) { > + ret =3D gpiod_direction_input(data->oc_gpio); > + if (ret < 0) > + dev_err(data->dev, "set oc_gpio input failed:%d\n", ret); > + } > + /* release by platform_device_release */ > + cdns_sky1_pdata =3D kzalloc(sizeof(*cdns_sky1_pdata), GFP_KERNEL); [Severity: High] Can this cause a memory leak or double-free of cdns_sky1_pdata? The instance-specific structure cdns_sky1_pdata is allocated here and passed to child devices via of_platform_populate(). If of_platform_populate() matc= hes zero children, the pointer is never attached to a device and permanently le= aks. If it matches multiple children, all children receive the exact same pointe= r, resulting in a double-free kernel panic when each child's release function attempts to free the same pointer upon unbind. > + if (!cdns_sky1_pdata) > + return -ENOMEM; > + cdns_sky1_pdata->platform_suspend =3D cdns_sky1_platform_suspend; > + cdns_sky1_pdata->quirks =3D CDNS3_DEFAULT_PM_RUNTIME_ALLOW; > + cdns_sky1_auxdata->platform_data =3D cdns_sky1_pdata; > + ret =3D of_platform_populate(node, NULL, cdns_sky1_auxdata, dev); [Severity: High] Does this corrupt the global cdns_sky1_auxdata array? cdns_sky1_auxdata is defined as a statically shared array for the driver, b= ut a dynamically allocated, instance-specific pointer (cdns_sky1_pdata) is assigned to cdns_sky1_auxdata->platform_data. Because the device tree contains multiple instances of this driver, probing them concurrently or sequentially will race to overwrite this shared global state, causing cross-device memory corruption and dangling pointers. [ ... ] > +static void cdnsp_sky1_remove(struct platform_device *pdev) > +{ > + struct device *dev =3D &pdev->dev; > + struct cdnsp_sky1 *data =3D dev_get_drvdata(dev); > + > + pm_runtime_get_sync(dev); > + of_platform_depopulate(dev); > + sky1_put_addr(data->xhci_base); > + sky1_put_addr(data->device_base); > + reset_control_deassert(data->reset); > + reset_control_deassert(data->preset); [Severity: High] Should these resets be asserted instead of deasserted? The driver attempts to tear down the hardware but incorrectly calls reset_control_deassert() again instead of reset_control_assert(). This fails to reset the hardware and leaves it active while its clocks are subsequently disabled, which can hang the system or cause undefined hardware behavior. > + cdnsp_sky1_clk_disable_all(dev); > + platform_set_drvdata(pdev, NULL); > +} [Severity: High] Does this leave the device's runtime PM subsystem in an unbalanced state? cdnsp_sky1_probe() enables runtime PM, but cdnsp_sky1_remove() omits a call to pm_runtime_disable() before exiting. Additionally, cdnsp_sky1_remove() calls pm_runtime_get_sync() at the start of the function but omits a balancing pm_runtime_put() call, permanently leaking the device's usage counter. [ ... ] > +static int cdnsp_sky1_find_gadget_match(struct device *dev, void *data) > +{ [ ... ] > + if (name && dev->bus && !strcmp(dev->bus->name, "gadget") && > + !strncmp(name, gadget_prefix, sizeof(gadget_prefix) - 1)) { > + *gadget_dev =3D dev; > + return 1; > + } > + return 0; > +} > + > +static void cdnsp_sky1_shutdown(struct platform_device *pdev) > +{ [ ... ] > + if (!device_may_wakeup(dev)) { > + /* > + * Find the cdns3 child device, then find its gadget device > + * and release the function driver before disabling clocks. > + * This ensures all register accesses in gadget_unbind_driver > + * complete before clocks are turned off. > + */ > + device_for_each_child(dev, &cdns, cdnsp_sky1_find_cdns); > + if (cdns) > + device_for_each_child(cdns->dev, &gadget_dev, > + cdnsp_sky1_find_gadget_match); > + if (gadget_dev) > + device_release_driver(gadget_dev); [Severity: High] Can this result in a use-after-free condition? In cdnsp_sky1_find_gadget_match(), a pointer to the matched device is stored without acquiring a persistent reference via get_device(). The iterator device_for_each_child() immediately drops its reference when advancing or returning, leaving a bare pointer. If the gadget device is removed concurrently immediately before device_release_driver() is called, the pointer becomes dangling. [ ... ] > diff --git a/drivers/usb/cdns3/cdnsp-sky1.h b/drivers/usb/cdns3/cdnsp-sky= 1.h > new file mode 100644 > --- /dev/null > +++ b/drivers/usb/cdns3/cdnsp-sky1.h > @@ -0,0 +1,127 @@ [ ... ] > +#define D_XEC_CFG_3XPORT_MODE_VALUE 0xa0031e07 > +#define XEC_CFG_3XPORT_MODE_VALUE 0xa0031e07 > +#define CFG_3XPORT_MODE_DIS_SSP (~(1 << 31)) [Severity: Low] Does this trigger undefined behavior? 1 is treated as a signed 32-bit integer, and shifting it left by 31 bits overflows the sign bit. Should this be explicitly unsigned, such as (~(1U << 31)) or ~BIT(31)? --=20 Sashiko AI review =C2=B7 https://sashiko.dev/#/patchset/20260831082309.3854= 507-1-hongliang.yang@cixtech.com?part=3D3 From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from bombadil.infradead.org (bombadil.infradead.org [198.137.202.133]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.lore.kernel.org (Postfix) with ESMTPS id 9A303C61DE2 for ; Mon, 31 Aug 2026 08:41:12 +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=7qaXZ55bZS2PsOPlsBpNX5bA4QDDaH7uP1KyAasYzfk=; b=FyifVKQnDL14A8 fKtSXt5aQSzTgWURK1TVnu07ABxD8pLI3Kf6sE0/AQg5JXHfd8GZZFHGKpvJaYlxifL3yrq00Y7Pl AmATW9DcBKFlzKYpHu0Kzmebyw/8Wzx33bCm58IneKMoMIscBU9rsYoPRl4NP82/Rk4hOzmSCefhK ygzu5CKe7XsDkwMRgXhQP4x7bLtCl89GBxfmEi5oHC/KhJ6Tx8BMEA5BTDqcuJ2NGJBrXlUDLEBvh OKEiTHuX0KPsq5/TCbQh+mBgt4Z+JrSeZP22ZnxJkBK9HIrKG0CKfZB3yQbB+iZ98wK+qh4aYTEVs m8TAm8vFX0cyzbddeWkQ==; Received: from localhost ([::1] helo=bombadil.infradead.org) by bombadil.infradead.org with esmtp (Exim 4.99.1 #2 (Red Hat Linux)) id 1x0xZo-00000008vTQ-1Izx; Mon, 31 Aug 2026 08:41:12 +0000 Received: from sea.source.kernel.org ([2600:3c0a:e001:78e:0:1991:8:25]) by bombadil.infradead.org with esmtps (Exim 4.99.1 #2 (Red Hat Linux)) id 1x0xZm-00000008vSu-1Lq0 for linux-phy@lists.infradead.org; Mon, 31 Aug 2026 08:41:10 +0000 Received: from smtp.kernel.org (quasi.space.kernel.org [100.103.45.18]) by sea.source.kernel.org (Postfix) with ESMTP id C5BCF40DF5; Mon, 31 Aug 2026 08:41:09 +0000 (UTC) Received: by smtp.kernel.org (Postfix) with ESMTPSA id 30DA11F000E9; Mon, 31 Aug 2026 08:41:08 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=kernel.org; s=k20260515; t=1788165669; bh=SYxdarkq2tSLaE0LEwk03SmpjTFmGU6/ydnxJALoFJI=; h=From:Subject:Reply-To:To:Cc:In-Reply-To:References:Date; b=MzKA/KSsfm6Hjb4InbYVJ2XTLVor6c7MrG3XLiTzGi1O48c9O4CA0Y9B2BpcNH62w NjTDYXSG5dyV+x+aazxjG3Ur21BW1ypv2Ihbjpaek6wzdnG7xwhC3YvtEg+crpkFc8 cUHCc3PNiPgwNUCr8vPnkhpX/9OhFEr+jP/5E5IQenKTHV8v+eQ4E5vuebJgoHsJk1 w/lvmtooj1vYHd+psMEe+c+Zt/hgRonYENzaEFNJ/nRFQ9cY9Fw4QbtzP/x5oee4Fx uU+vlRSKNw1fW8odT+NYON8+yViQp7uuu316Rd9hMTqkXWPU/I/FB0UdyeylsT6thn 6w+5/LYfJHBFA== From: sashiko-bot@kernel.org Subject: Re: [PATCH v1 3/4] usb: cdns3: Add CIX Sky1 glue driver To: "Hongliang Yang" Cc: neil.armstrong@linaro.org, olteanv@gmail.com, conor+dt@kernel.org, devicetree@vger.kernel.org, vkoul@kernel.org, linux-phy@lists.infradead.org, robh@kernel.org In-Reply-To: <20260831082309.3854507-4-hongliang.yang@cixtech.com> References: <20260831082309.3854507-1-hongliang.yang@cixtech.com> <20260831082309.3854507-4-hongliang.yang@cixtech.com> Date: Mon, 31 Aug 2026 08:41:07 +0000 Message-Id: <20260831084108.30DA11F000E9@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 MTEgcG90ZW50aWFsIGlzc3VlKHMpIHRvIGNvbnNpZGVyOgotIFtIaWdoXSBJT01FTSwgY2xvY2ss IGFuZCByZXNldCBsZWFrcyBvbiBwcm9iZSBlcnJvciBwYXRocy4KLSBbSGlnaF0gTWlzc2luZyBn ZXRfZGV2aWNlKCkgY2F1c2VzIHVuc2FmZSBkZXZpY2UgcG9pbnRlciBzdG9yYWdlIGluIG1hdGNo IGZ1bmN0aW9uLCBsZWFkaW5nIHRvIFVzZS1BZnRlci1GcmVlLgotIFtIaWdoXSBHbG9iYWwgc3Rh dGUgY29ycnVwdGlvbiBvZiBzaGFyZWQgc3RhdGljIGNkbnNfc2t5MV9hdXhkYXRhIGFycmF5IGlu IHByb2JlLgotIFtIaWdoXSBGbGF3ZWQgcGxhdGZvcm1fZGF0YSBtZW1vcnkgbWFuYWdlbWVudCBj YXVzZXMgbGVha3Mgb3IgZG91YmxlLWZyZWVzIHdoZW4gbXVsdGlwbGUgb3IgemVybyBjaGlsZHJl biBleGlzdC4KLSBbSGlnaF0gVW5iYWxhbmNlZCBSdW50aW1lIFBNIHN0YXRlIGR1cmluZyBkcml2 ZXIgcmVtb3ZhbC4KLSBbSGlnaF0gSW5jb3JyZWN0IGhhcmR3YXJlIHJlc2V0IGxvZ2ljIGR1cmlu ZyBkcml2ZXIgcmVtb3ZhbC4KLSBbSGlnaF0gU2lnbmVkIGludGVnZXIgb3ZlcmZsb3cgaW4gY2xv Y2sgZnJlcXVlbmN5IGNhbGN1bGF0aW9ucy4KLSBbSGlnaF0gV3JpdGluZyBpbnZlcnRlZCBBWElf SEFMVCBiaXRtYXNrIHRvIHRoZSBjYXBhYmlsaXR5IHJlZ2lzdGVyIGluYWR2ZXJ0ZW50bHkgc2V0 cyBhbGwgb3RoZXIgYml0cyB0byAxLgotIFtNZWRpdW1dIERldmljZSBub2RlIHJlZmVyZW5jZSBs ZWFrIGluIHNreTFfb2ZfZ2V0X2FkZHJfYnlfbmFtZS4KLSBbTWVkaXVtXSBDbG9jayBlcnJvciBy ZWNvdmVyeSBwYXRocyBkZXN0cnVjdGl2ZWx5IG51bGxpZnkgZGV2cmVzIG1hbmFnZWQgY2xvY2sg cG9pbnRlcnMuCi0gW0xvd10gU2lnbmVkIGludGVnZXIgb3ZlcmZsb3cgd2hlbiBkZWZpbmluZyBD RkdfM1hQT1JUX01PREVfRElTX1NTUC4KLS0KCmNvbW1pdCBmNWI0MWQ4YjRlNzZjMDUyMWJkYjg1 NTdmMGU1NGI2MDIzNzE0NTAwCkF1dGhvcjogSG9uZ2xpYW5nIFlhbmcgPGhvbmdsaWFuZy55YW5n QGNpeHRlY2guY29tPgoKdXNiOiBjZG5zMzogQWRkIENJWCBTa3kxIGdsdWUgZHJpdmVyCgpBZGQg Z2x1ZSBsYXllciBmb3IgdGhlIENhZGVuY2UgVVNCU1NQIERSRCBjb250cm9sbGVyIG9uIENJWCBT a3kxIFNvQ3MuClRoZSBnbHVlIGRyaXZlciBoYW5kbGVzIHBsYXRmb3JtLXNwZWNpZmljIGluaXRp YWxpemF0aW9uIGluY2x1ZGluZyBjbG9ja3MsCnJlc2V0cywgYW5kIFBIWSBjb25maWd1cmF0aW9u LgoKPiBkaWZmIC0tZ2l0IGEvZHJpdmVycy91c2IvY2RuczMvY2Ruc3Atc2t5MS5jIGIvZHJpdmVy cy91c2IvY2RuczMvY2Ruc3Atc2t5MS5jCj4gbmV3IGZpbGUgbW9kZSAxMDA2NDQKPiAtLS0gL2Rl di9udWxsCj4gKysrIGIvZHJpdmVycy91c2IvY2RuczMvY2Ruc3Atc2t5MS5jCj4gQEAgLTAsMCAr MSw2ODIgQEAKWyAuLi4gXQo+ICtzdGF0aWMgaW50IGNkbnNwX3NreTFfY2xrX2VuYWJsZV9yZXN1 bWUoc3RydWN0IGRldmljZSAqZGV2KQo+ICt7ClsgLi4uIF0KPiArZXJyX3VzYl9jbGtzOgo+ICsJ Y2l4X3VzYl9jbGtzW2ldID0gTlVMTDsKPiArCXdoaWxlICgtLWkgPj0gMCkgewo+ICsJCWNsa19k aXNhYmxlX3VucHJlcGFyZShjaXhfdXNiX2Nsa3NbaV0pOwo+ICsJCWNpeF91c2JfY2xrc1tpXSA9 IE5VTEw7CgpbU2V2ZXJpdHk6IE1lZGl1bV0KSXMgaXQgc2FmZSB0byBudWxsaWZ5IHRoZXNlIGNs b2NrIHBvaW50ZXJzPyAKCkJlY2F1c2UgdGhlIGNsb2NrcyBhcmUgZGV2cmVzLW1hbmFnZWQsIGRl dnJlcyB3aWxsIHN0aWxsIHByb3Blcmx5IGZyZWUgdGhlbSwKYnV0IG51bGxpZnlpbmcgdGhlIHBv aW50ZXJzIGRlc3Ryb3lzIHRoZSBkcml2ZXIncyBhYmlsaXR5IHRvIGV2ZXIgcmVmZXJlbmNlCnRo ZW0gYWdhaW4uIAoKSWYgYSB0cmFuc2llbnQgZXJyb3Igb2NjdXJzIGR1cmluZyBhIHJlc3VtZSBh dHRlbXB0LCBhbnkgc3Vic2VxdWVudCByZXRyeSBvcgpjbGVhbnVwIHdpbGwgZmFpbCBiZWNhdXNl IHRoZSBkcml2ZXIgbG9zdCBpdHMgaW50ZXJuYWwgcG9pbnRlcnMuCgo+ICsJfQo+ICsJcmV0dXJu IHJldDsKPiArfTsKWyAuLi4gXQo+ICtzdGF0aWMgdm9pZCBjZG5zcF9za3kxX2NvbmZpZ3VyZV9j b250cm9sbGVyKHN0cnVjdCBjZG5zcF9za3kxICpkYXRhKQo+ICt7ClsgLi4uIF0KPiArCXdyaXRl bChBWElfSEFMVCwgZGF0YS0+ZGV2aWNlX2Jhc2UgKyBEX1hFQ19BWElfQ0FQKTsKPiArCXdyaXRl bChBWElfSEFMVCwgZGF0YS0+eGhjaV9iYXNlICsgRF9YRUNfQVhJX0NBUCk7Cj4gKwl3cml0ZWwo ZGF0YS0+YXhpX2JtYXhfdmFsdWUsIGRhdGEtPmRldmljZV9iYXNlICsgRF9YRUNfQVhJX0NUUkww KTsKPiArCXdyaXRlbChkYXRhLT5heGlfYm1heF92YWx1ZSwgZGF0YS0+eGhjaV9iYXNlICsgRF9Y RUNfQVhJX0NUUkwwKTsKPiArCXdyaXRlbCgofih1MzIpKEFYSV9IQUxUKSksIGRhdGEtPmRldmlj ZV9iYXNlICsgRF9YRUNfQVhJX0NBUCk7Cj4gKwl3cml0ZWwoKH4odTMyKShBWElfSEFMVCkpLCBk YXRhLT54aGNpX2Jhc2UgKyBEX1hFQ19BWElfQ0FQKTsKCltTZXZlcml0eTogSGlnaF0KRG9lcyB0 aGlzIGluYWR2ZXJ0ZW50bHkgb3ZlcndyaXRlIG90aGVyIGNhcGFiaWxpdHkgYml0cz8gCgpBWElf SEFMVCBpcyBkZWZpbmVkIGFzIEJJVCgzMSkuIEJsaW5kbHkgd3JpdGluZyB+KHUzMikoQVhJX0hB TFQpIHlpZWxkcwoweDdGRkZGRkZGLCB3aGljaCBzZXRzIGJpdHMgMCB0aHJvdWdoIDMwIHRvIDEg cmF0aGVyIHRoYW4gcHJlc2VydmluZyB0aGVpcgpleGlzdGluZyBzdGF0ZSB3aXRoIGEgcmVhZC1t b2RpZnktd3JpdGUgb3IgY2xlYXJpbmcgdGhlbSB3aXRoIDAuIAoKT3ZlcndyaXRpbmcgMzEgY2Fw YWJpbGl0eSBiaXRzIHdpdGggMXMgY2FuIGVuYWJsZSB1bmludGVuZGVkIG1vZGVzIG9yIGNhdXNl CnVucHJlZGljdGFibGUgaGFyZHdhcmUgYmVoYXZpb3IuCgo+ICsJY2xrID0gZGF0YS0+c29mX2Ns a19mcmVxOwo+ICsJdjAgPSAgMjUgKiBjbGsgLyAxMDAwMDAwMDA7Cj4gKwl2MSA9IGNsayAvIDEw MDAwOwo+ICsJdjIgPSBjbGsgLyAxMDsKPiArCXdyaXRlbCgoKHYwID4gMSkgPyB2MCAtIDEgOiAx KSwgZGF0YS0+ZGV2aWNlX2Jhc2UKPiArCQkrIERfWEVDX1BSRV9SRUdfMjUwTlMpOwo+ICsJd3Jp dGVsKCh1bnNpZ25lZCBpbnQpKCh2MSAvIDEwMCA+IDEpID4gMCA/ICh2MSAvIDEwMCkgLSAxIDog MSksCj4gKwkgICAgICAgZGF0YS0+ZGV2aWNlX2Jhc2UgKyBEX1hFQ19QUkVfUkVHXzFVUyk7Cj4g Kwl3cml0ZWwoKHVuc2lnbmVkIGludCkoKHYxIC8gMTAgPiAxKSA+IDAgPyAodjEgLyAxMCkgLSAx IDogMSksCj4gKwkgICAgICAgZGF0YS0+ZGV2aWNlX2Jhc2UgKyBEX1hFQ19QUkVfUkVHXzEwVVMp Owo+ICsJd3JpdGVsKCgodjEpID4gMSA/IHYxIC0gMSA6IDEpLCBkYXRhLT5kZXZpY2VfYmFzZQo+ ICsJCSsgRF9YRUNfUFJFX1JFR18xMDBVUyk7Cj4gKwl3cml0ZWwoKHVuc2lnbmVkIGludCkoKDEy NSAqIGNsayAvIDEwMDAwMDApID4gMSA/ICgxMjUgKiBjbGsgLyAxMDAwMDAwKSA6IDEpLAo+ICsJ ICAgICAgIGRhdGEtPmRldmljZV9iYXNlICsgRF9YRUNfUFJFX1JFR18xMjVVUyk7CgpbU2V2ZXJp dHk6IEhpZ2hdCldpbGwgdGhpcyBjYWxjdWxhdGlvbiBvdmVyZmxvdyBmb3IgZnJlcXVlbmNpZXMg YWJvdmUgMTcuMSBNSHo/CgpCZWNhdXNlIGNsayBpcyB0eXBlZCBhcyBhIHNpZ25lZCAzMi1iaXQg aW50LCAxMjUgKiBjbGsgd2lsbCBleGNlZWQgSU5UX01BWAooMiwxNDcsNDgzLDY0NykgYW5kIG92 ZXJmbG93IGZvciB2YWx1ZXMgYWJvdmUgYXBwcm94aW1hdGVseSAxNy4xIE1Iei4gVGhpcwp5aWVs ZHMgYSBuZWdhdGl2ZSB2YWx1ZSB0aGF0IGltcHJvcGVybHkgY29uZmlndXJlcyB0aGUgaGFyZHdh cmUgcHJlLXNjYWxlcgpyZWdpc3RlcnMuIAoKQ291bGQgdGhpcyBiZSBtaXRpZ2F0ZWQgYnkgdXNp bmcgYW4gdW5zaWduZWQgNjQtYml0IGNhc3QsIHN1Y2ggYXMgMTI1VUxMICogY2xrPwoKWyAuLi4g XQo+ICtzdGF0aWMgdm9pZCAqc2t5MV9vZl9nZXRfYWRkcl9ieV9uYW1lKHN0cnVjdCBkZXZpY2Vf bm9kZSAqcGFyZW50LCBjaGFyICpuYW1lKQo+ICt7Cj4gKwlzdHJ1Y3QgZGV2aWNlX25vZGUgKm5v ZGU7Cj4gKwlpbnQgaW5kZXg7Cj4gKwo+ICsJbm9kZSA9IG9mX2dldF9uZXh0X2NoaWxkKHBhcmVu dCwgTlVMTCk7Cj4gKwlpZiAobm9kZSkgewo+ICsJCWluZGV4ID0gb2ZfcHJvcGVydHlfbWF0Y2hf c3RyaW5nKG5vZGUsICJyZWctbmFtZXMiLCBuYW1lKTsKPiArCQlpZiAoaW5kZXggPj0gMCkKPiAr CQkJcmV0dXJuIG9mX2lvbWFwKG5vZGUsIGluZGV4KTsKPiArCX0KPiArCXJldHVybiBOVUxMOwo+ ICt9CgpbU2V2ZXJpdHk6IE1lZGl1bV0KQ2FuIHRoaXMgbGVhayB0aGUgZGV2aWNlIG5vZGUgcmVm ZXJlbmNlPwoKb2ZfZ2V0X25leHRfY2hpbGQoKSBhY3F1aXJlcyBhbmQgcmV0dXJucyBhIGRldmlj ZSBub2RlIHdpdGggYW4gaW5jcmVtZW50ZWQKcmVmZXJlbmNlIGNvdW50LCBidXQgdGhlIHJlZmVy ZW5jZSBpcyBuZXZlciByZWxlYXNlZCB3aXRoIG9mX25vZGVfcHV0KCkgb24KZWl0aGVyIHRoZSBz dWNjZXNzIG9yIGZhaWx1cmUgcGF0aHMuCgpbIC4uLiBdCj4gK3N0YXRpYyBzdHJ1Y3Qgb2ZfZGV2 X2F1eGRhdGEgY2Ruc19za3kxX2F1eGRhdGFbXSA9IHsKPiArCXsKPiArCQkuY29tcGF0aWJsZSA9 ICJjZG5zLHVzYjMiLAo+ICsJfSwKPiArCXt9LAo+ICt9Owo+ICsKPiArc3RhdGljIGludCBjZG5z cF9za3kxX3Byb2JlKHN0cnVjdCBwbGF0Zm9ybV9kZXZpY2UgKnBkZXYpCj4gK3sKWyAuLi4gXQo+ ICsJZGF0YS0+ZGV2aWNlX2Jhc2UgPSBza3kxX2dldF9hZGRyX2J5X25hbWUoZGV2LCAiZGV2Iik7 Cj4gKwlpZiAoIWRhdGEtPmRldmljZV9iYXNlKQo+ICsJCXJldHVybiAtRU5PREVWOwo+ICsJcmV0 ID0gY2Ruc3Bfc2t5MV9kcmRfaW5pdChkYXRhKTsKPiArCWlmIChyZXQgPT0gLUVUSU1FRE9VVCkK PiArCQlyZXR1cm4gLUVQUk9CRV9ERUZFUjsKPiArCWlmIChyZXQpCj4gKwkJcmV0dXJuIHJldDsK CltTZXZlcml0eTogSGlnaF0KRG8gdGhlc2UgZXJyb3IgcGF0aHMgbGVhayB0aGUgSU9NRU0gcmVn aW9ucywgaGFyZHdhcmUgY2xvY2tzLCBhbmQgcmVzZXRzPwoKY2Ruc3Bfc2t5MV9wcm9iZSgpIG1h bnVhbGx5IG1hcHMgSU9NRU0gcmVnaW9ucyB1c2luZyBza3kxX2dldF9hZGRyX2J5X25hbWUoKQph bmQgZW5hYmxlcyBoYXJkd2FyZSBjbG9ja3MgaW4gY2Ruc3Bfc2t5MV9kcmRfaW5pdCgpLiBJZiBz dWJzZXF1ZW50CmluaXRpYWxpemF0aW9uIHN0ZXBzIGZhaWwsIHRoZSBmdW5jdGlvbiByZXR1cm5z IGRpcmVjdGx5IG9yIGp1bXBzIHRvIHRoZSBlcnIKbGFiZWwgd2l0aG91dCB1bm1hcHBpbmcgdGhl IElPTUVNIHdpdGggaW91bm1hcCgpLCBkaXNhYmxpbmcgdGhlIGNsb2Nrcywgb3IKcmUtYXNzZXJ0 aW5nIHRoZSBoYXJkd2FyZSByZXNldHMuCgpTaW5jZSBwcm9iZSBjYW4gYmUgcmV0cmllZCBtdWx0 aXBsZSB0aW1lcywgdGhlc2UgbGVha2VkIHJlc291cmNlcyB3aWxsCmFjY3VtdWxhdGUuCgo+ICsJ ZGF0YS0+b2NfZ3BpbyA9IGRldm1fZ3Bpb2RfZ2V0X29wdGlvbmFsKGRhdGEtPmRldiwgIm9jIiwg R1BJT0RfSU4pOwo+ICsJaWYgKElTX0VSUihkYXRhLT5vY19ncGlvKSkgewo+ICsJCWRldl9lcnIo ZGF0YS0+ZGV2LCAiY2FuIG5vdCBnZXQgb2NfZ3Bpb1xuIik7Cj4gKwkJcmV0ID0gUFRSX0VSUihk YXRhLT5vY19ncGlvKTsKPiArCQlyZXR1cm4gcmV0Owo+ICsJfQo+ICsJaWYgKGRhdGEtPm9jX2dw aW8pIHsKPiArCQlyZXQgPSBncGlvZF9kaXJlY3Rpb25faW5wdXQoZGF0YS0+b2NfZ3Bpbyk7Cj4g KwkJaWYgKHJldCA8IDApCj4gKwkJCWRldl9lcnIoZGF0YS0+ZGV2LCAic2V0IG9jX2dwaW8gaW5w dXQgZmFpbGVkOiVkXG4iLCByZXQpOwo+ICsJfQo+ICsJLyogcmVsZWFzZSBieSBwbGF0Zm9ybV9k ZXZpY2VfcmVsZWFzZSAqLwo+ICsJY2Ruc19za3kxX3BkYXRhID0ga3phbGxvYyhzaXplb2YoKmNk bnNfc2t5MV9wZGF0YSksIEdGUF9LRVJORUwpOwoKW1NldmVyaXR5OiBIaWdoXQpDYW4gdGhpcyBj YXVzZSBhIG1lbW9yeSBsZWFrIG9yIGRvdWJsZS1mcmVlIG9mIGNkbnNfc2t5MV9wZGF0YT8KClRo ZSBpbnN0YW5jZS1zcGVjaWZpYyBzdHJ1Y3R1cmUgY2Ruc19za3kxX3BkYXRhIGlzIGFsbG9jYXRl ZCBoZXJlIGFuZCBwYXNzZWQKdG8gY2hpbGQgZGV2aWNlcyB2aWEgb2ZfcGxhdGZvcm1fcG9wdWxh dGUoKS4gSWYgb2ZfcGxhdGZvcm1fcG9wdWxhdGUoKSBtYXRjaGVzCnplcm8gY2hpbGRyZW4sIHRo ZSBwb2ludGVyIGlzIG5ldmVyIGF0dGFjaGVkIHRvIGEgZGV2aWNlIGFuZCBwZXJtYW5lbnRseSBs ZWFrcy4KCklmIGl0IG1hdGNoZXMgbXVsdGlwbGUgY2hpbGRyZW4sIGFsbCBjaGlsZHJlbiByZWNl aXZlIHRoZSBleGFjdCBzYW1lIHBvaW50ZXIsCnJlc3VsdGluZyBpbiBhIGRvdWJsZS1mcmVlIGtl cm5lbCBwYW5pYyB3aGVuIGVhY2ggY2hpbGQncyByZWxlYXNlIGZ1bmN0aW9uCmF0dGVtcHRzIHRv IGZyZWUgdGhlIHNhbWUgcG9pbnRlciB1cG9uIHVuYmluZC4KCj4gKwlpZiAoIWNkbnNfc2t5MV9w ZGF0YSkKPiArCQlyZXR1cm4gLUVOT01FTTsKPiArCWNkbnNfc2t5MV9wZGF0YS0+cGxhdGZvcm1f c3VzcGVuZCA9IGNkbnNfc2t5MV9wbGF0Zm9ybV9zdXNwZW5kOwo+ICsJY2Ruc19za3kxX3BkYXRh LT5xdWlya3MgPSBDRE5TM19ERUZBVUxUX1BNX1JVTlRJTUVfQUxMT1c7Cj4gKwljZG5zX3NreTFf YXV4ZGF0YS0+cGxhdGZvcm1fZGF0YSA9IGNkbnNfc2t5MV9wZGF0YTsKPiArCXJldCA9IG9mX3Bs YXRmb3JtX3BvcHVsYXRlKG5vZGUsIE5VTEwsIGNkbnNfc2t5MV9hdXhkYXRhLCBkZXYpOwoKW1Nl dmVyaXR5OiBIaWdoXQpEb2VzIHRoaXMgY29ycnVwdCB0aGUgZ2xvYmFsIGNkbnNfc2t5MV9hdXhk YXRhIGFycmF5PwoKY2Ruc19za3kxX2F1eGRhdGEgaXMgZGVmaW5lZCBhcyBhIHN0YXRpY2FsbHkg c2hhcmVkIGFycmF5IGZvciB0aGUgZHJpdmVyLCBidXQKYSBkeW5hbWljYWxseSBhbGxvY2F0ZWQs IGluc3RhbmNlLXNwZWNpZmljIHBvaW50ZXIgKGNkbnNfc2t5MV9wZGF0YSkgaXMKYXNzaWduZWQg dG8gY2Ruc19za3kxX2F1eGRhdGEtPnBsYXRmb3JtX2RhdGEuCgpCZWNhdXNlIHRoZSBkZXZpY2Ug dHJlZSBjb250YWlucyBtdWx0aXBsZSBpbnN0YW5jZXMgb2YgdGhpcyBkcml2ZXIsIHByb2JpbmcK dGhlbSBjb25jdXJyZW50bHkgb3Igc2VxdWVudGlhbGx5IHdpbGwgcmFjZSB0byBvdmVyd3JpdGUg dGhpcyBzaGFyZWQgZ2xvYmFsCnN0YXRlLCBjYXVzaW5nIGNyb3NzLWRldmljZSBtZW1vcnkgY29y cnVwdGlvbiBhbmQgZGFuZ2xpbmcgcG9pbnRlcnMuCgpbIC4uLiBdCj4gK3N0YXRpYyB2b2lkIGNk bnNwX3NreTFfcmVtb3ZlKHN0cnVjdCBwbGF0Zm9ybV9kZXZpY2UgKnBkZXYpCj4gK3sKPiArCXN0 cnVjdCBkZXZpY2UgKmRldiA9ICZwZGV2LT5kZXY7Cj4gKwlzdHJ1Y3QgY2Ruc3Bfc2t5MSAqZGF0 YSA9IGRldl9nZXRfZHJ2ZGF0YShkZXYpOwo+ICsKPiArCXBtX3J1bnRpbWVfZ2V0X3N5bmMoZGV2 KTsKPiArCW9mX3BsYXRmb3JtX2RlcG9wdWxhdGUoZGV2KTsKPiArCXNreTFfcHV0X2FkZHIoZGF0 YS0+eGhjaV9iYXNlKTsKPiArCXNreTFfcHV0X2FkZHIoZGF0YS0+ZGV2aWNlX2Jhc2UpOwo+ICsJ cmVzZXRfY29udHJvbF9kZWFzc2VydChkYXRhLT5yZXNldCk7Cj4gKwlyZXNldF9jb250cm9sX2Rl YXNzZXJ0KGRhdGEtPnByZXNldCk7CgpbU2V2ZXJpdHk6IEhpZ2hdClNob3VsZCB0aGVzZSByZXNl dHMgYmUgYXNzZXJ0ZWQgaW5zdGVhZCBvZiBkZWFzc2VydGVkPwoKVGhlIGRyaXZlciBhdHRlbXB0 cyB0byB0ZWFyIGRvd24gdGhlIGhhcmR3YXJlIGJ1dCBpbmNvcnJlY3RseSBjYWxscwpyZXNldF9j b250cm9sX2RlYXNzZXJ0KCkgYWdhaW4gaW5zdGVhZCBvZiByZXNldF9jb250cm9sX2Fzc2VydCgp LiBUaGlzIGZhaWxzCnRvIHJlc2V0IHRoZSBoYXJkd2FyZSBhbmQgbGVhdmVzIGl0IGFjdGl2ZSB3 aGlsZSBpdHMgY2xvY2tzIGFyZSBzdWJzZXF1ZW50bHkKZGlzYWJsZWQsIHdoaWNoIGNhbiBoYW5n IHRoZSBzeXN0ZW0gb3IgY2F1c2UgdW5kZWZpbmVkIGhhcmR3YXJlIGJlaGF2aW9yLgoKPiArCWNk bnNwX3NreTFfY2xrX2Rpc2FibGVfYWxsKGRldik7Cj4gKwlwbGF0Zm9ybV9zZXRfZHJ2ZGF0YShw ZGV2LCBOVUxMKTsKPiArfQoKW1NldmVyaXR5OiBIaWdoXQpEb2VzIHRoaXMgbGVhdmUgdGhlIGRl dmljZSdzIHJ1bnRpbWUgUE0gc3Vic3lzdGVtIGluIGFuIHVuYmFsYW5jZWQgc3RhdGU/CgpjZG5z cF9za3kxX3Byb2JlKCkgZW5hYmxlcyBydW50aW1lIFBNLCBidXQgY2Ruc3Bfc2t5MV9yZW1vdmUo KSBvbWl0cyBhIGNhbGwKdG8gcG1fcnVudGltZV9kaXNhYmxlKCkgYmVmb3JlIGV4aXRpbmcuCgpB ZGRpdGlvbmFsbHksIGNkbnNwX3NreTFfcmVtb3ZlKCkgY2FsbHMgcG1fcnVudGltZV9nZXRfc3lu YygpIGF0IHRoZSBzdGFydApvZiB0aGUgZnVuY3Rpb24gYnV0IG9taXRzIGEgYmFsYW5jaW5nIHBt X3J1bnRpbWVfcHV0KCkgY2FsbCwgcGVybWFuZW50bHkKbGVha2luZyB0aGUgZGV2aWNlJ3MgdXNh Z2UgY291bnRlci4KClsgLi4uIF0KPiArc3RhdGljIGludCBjZG5zcF9za3kxX2ZpbmRfZ2FkZ2V0 X21hdGNoKHN0cnVjdCBkZXZpY2UgKmRldiwgdm9pZCAqZGF0YSkKPiArewpbIC4uLiBdCj4gKwlp ZiAobmFtZSAmJiBkZXYtPmJ1cyAmJiAhc3RyY21wKGRldi0+YnVzLT5uYW1lLCAiZ2FkZ2V0Iikg JiYKPiArCSAgICAhc3RybmNtcChuYW1lLCBnYWRnZXRfcHJlZml4LCBzaXplb2YoZ2FkZ2V0X3By ZWZpeCkgLSAxKSkgewo+ICsJCSpnYWRnZXRfZGV2ID0gZGV2Owo+ICsJCXJldHVybiAxOwo+ICsJ fQo+ICsJcmV0dXJuIDA7Cj4gK30KPiArCj4gK3N0YXRpYyB2b2lkIGNkbnNwX3NreTFfc2h1dGRv d24oc3RydWN0IHBsYXRmb3JtX2RldmljZSAqcGRldikKPiArewpbIC4uLiBdCj4gKwlpZiAoIWRl dmljZV9tYXlfd2FrZXVwKGRldikpIHsKPiArCQkvKgo+ICsJCSAqIEZpbmQgdGhlIGNkbnMzIGNo aWxkIGRldmljZSwgdGhlbiBmaW5kIGl0cyBnYWRnZXQgZGV2aWNlCj4gKwkJICogYW5kIHJlbGVh c2UgdGhlIGZ1bmN0aW9uIGRyaXZlciBiZWZvcmUgZGlzYWJsaW5nIGNsb2Nrcy4KPiArCQkgKiBU aGlzIGVuc3VyZXMgYWxsIHJlZ2lzdGVyIGFjY2Vzc2VzIGluIGdhZGdldF91bmJpbmRfZHJpdmVy Cj4gKwkJICogY29tcGxldGUgYmVmb3JlIGNsb2NrcyBhcmUgdHVybmVkIG9mZi4KPiArCQkgKi8K PiArCQlkZXZpY2VfZm9yX2VhY2hfY2hpbGQoZGV2LCAmY2RucywgY2Ruc3Bfc2t5MV9maW5kX2Nk bnMpOwo+ICsJCWlmIChjZG5zKQo+ICsJCQlkZXZpY2VfZm9yX2VhY2hfY2hpbGQoY2Rucy0+ZGV2 LCAmZ2FkZ2V0X2RldiwKPiArCQkJCQkgICAgICBjZG5zcF9za3kxX2ZpbmRfZ2FkZ2V0X21hdGNo KTsKPiArCQlpZiAoZ2FkZ2V0X2RldikKPiArCQkJZGV2aWNlX3JlbGVhc2VfZHJpdmVyKGdhZGdl dF9kZXYpOwoKW1NldmVyaXR5OiBIaWdoXQpDYW4gdGhpcyByZXN1bHQgaW4gYSB1c2UtYWZ0ZXIt ZnJlZSBjb25kaXRpb24/CgpJbiBjZG5zcF9za3kxX2ZpbmRfZ2FkZ2V0X21hdGNoKCksIGEgcG9p bnRlciB0byB0aGUgbWF0Y2hlZCBkZXZpY2UgaXMgc3RvcmVkCndpdGhvdXQgYWNxdWlyaW5nIGEg cGVyc2lzdGVudCByZWZlcmVuY2UgdmlhIGdldF9kZXZpY2UoKS4gVGhlIGl0ZXJhdG9yCmRldmlj ZV9mb3JfZWFjaF9jaGlsZCgpIGltbWVkaWF0ZWx5IGRyb3BzIGl0cyByZWZlcmVuY2Ugd2hlbiBh ZHZhbmNpbmcgb3IKcmV0dXJuaW5nLCBsZWF2aW5nIGEgYmFyZSBwb2ludGVyLgoKSWYgdGhlIGdh ZGdldCBkZXZpY2UgaXMgcmVtb3ZlZCBjb25jdXJyZW50bHkgaW1tZWRpYXRlbHkgYmVmb3JlCmRl dmljZV9yZWxlYXNlX2RyaXZlcigpIGlzIGNhbGxlZCwgdGhlIHBvaW50ZXIgYmVjb21lcyBkYW5n bGluZy4KClsgLi4uIF0KPiBkaWZmIC0tZ2l0IGEvZHJpdmVycy91c2IvY2RuczMvY2Ruc3Atc2t5 MS5oIGIvZHJpdmVycy91c2IvY2RuczMvY2Ruc3Atc2t5MS5oCj4gbmV3IGZpbGUgbW9kZSAxMDA2 NDQKPiAtLS0gL2Rldi9udWxsCj4gKysrIGIvZHJpdmVycy91c2IvY2RuczMvY2Ruc3Atc2t5MS5o Cj4gQEAgLTAsMCArMSwxMjcgQEAKWyAuLi4gXQo+ICsjZGVmaW5lIERfWEVDX0NGR18zWFBPUlRf TU9ERV9WQUxVRSAgICAgMHhhMDAzMWUwNwo+ICsjZGVmaW5lIFhFQ19DRkdfM1hQT1JUX01PREVf VkFMVUUgICAgICAgMHhhMDAzMWUwNwo+ICsjZGVmaW5lIENGR18zWFBPUlRfTU9ERV9ESVNfU1NQ ICAgICAgICAgKH4oMSA8PCAzMSkpCgpbU2V2ZXJpdHk6IExvd10KRG9lcyB0aGlzIHRyaWdnZXIg dW5kZWZpbmVkIGJlaGF2aW9yPwoKMSBpcyB0cmVhdGVkIGFzIGEgc2lnbmVkIDMyLWJpdCBpbnRl Z2VyLCBhbmQgc2hpZnRpbmcgaXQgbGVmdCBieSAzMSBiaXRzCm92ZXJmbG93cyB0aGUgc2lnbiBi aXQuIFNob3VsZCB0aGlzIGJlIGV4cGxpY2l0bHkgdW5zaWduZWQsIHN1Y2ggYXMKKH4oMVUgPDwg MzEpKSBvciB+QklUKDMxKT8KCi0tIApTYXNoaWtvIEFJIHJldmlldyDCtyBodHRwczovL3Nhc2hp a28uZGV2LyMvcGF0Y2hzZXQvMjAyNjA4MzEwODIzMDkuMzg1NDUwNy0xLWhvbmdsaWFuZy55YW5n QGNpeHRlY2guY29tP3BhcnQ9MwoKLS0gCmxpbnV4LXBoeSBtYWlsaW5nIGxpc3QKbGludXgtcGh5 QGxpc3RzLmluZnJhZGVhZC5vcmcKaHR0cHM6Ly9saXN0cy5pbmZyYWRlYWQub3JnL21haWxtYW4v bGlzdGluZm8vbGludXgtcGh5Cg==