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 X-Spam-Level: X-Spam-Status: No, score=-9.1 required=3.0 tests=DKIM_SIGNED,DKIM_VALID, DKIM_VALID_AU,HEADER_FROM_DIFFERENT_DOMAINS,INCLUDES_PATCH,MAILING_LIST_MULTI, SIGNED_OFF_BY,SPF_PASS,URIBL_BLOCKED,USER_AGENT_GIT autolearn=ham autolearn_force=no version=3.4.0 Received: from mail.kernel.org (mail.kernel.org [198.145.29.99]) by smtp.lore.kernel.org (Postfix) with ESMTP id 28BA6C169C4 for ; Wed, 6 Feb 2019 16:47:15 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [209.132.180.67]) by mail.kernel.org (Postfix) with ESMTP id D5B4520818 for ; Wed, 6 Feb 2019 16:47:14 +0000 (UTC) Authentication-Results: mail.kernel.org; dkim=pass (1024-bit key) header.d=ffwll.ch header.i=@ffwll.ch header.b="Eo6KG0ja" Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1731456AbfBFQrN (ORCPT ); Wed, 6 Feb 2019 11:47:13 -0500 Received: from mail-ed1-f65.google.com ([209.85.208.65]:40125 "EHLO mail-ed1-f65.google.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1728167AbfBFQrM (ORCPT ); Wed, 6 Feb 2019 11:47:12 -0500 Received: by mail-ed1-f65.google.com with SMTP id g22so6453592edr.7 for ; Wed, 06 Feb 2019 08:47:10 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=ffwll.ch; s=google; h=from:to:cc:subject:date:message-id:in-reply-to:references :mime-version:content-transfer-encoding; bh=PSAl5Vk5/4xvwry0x6LplDmDORdq7fnY5y2c51DrLvc=; b=Eo6KG0ja+E5vVRJhVwXCR0ILHPmmFmnvsJaNXiNSDTcwlVZWFKth8SFhvJpfw+gq58 UGZ3jK+p2k8B5G350IVk7aiXTXCgW+W27WD77tA1nja/Vva60X2LVPaU5p2wjTlOWkaO WdF5G2JtQ5rYSaoE2vxRD8vbHlb2p37ZoiCZI= X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references:mime-version:content-transfer-encoding; bh=PSAl5Vk5/4xvwry0x6LplDmDORdq7fnY5y2c51DrLvc=; b=S7hjUd9wid9/O09SmrvQbAqX65GW6nttSnjD6WwmpNfEJ1k/rMInlxLyjCvIw9DgXh iEpk4UMKV8882XNzfx9W5rHCG8T+ZK94jVkyYokDisthbJvAKtrLnSvpZCrEzE+xgbmw zwlvYxRG59jDSSS4ROLCdrNbGaQGbXlkyRNVUdsOSjtzMcOdMlN74vA6m2413p6vaPt1 RpEve7xJgL1bLeJkceRbQzcJl6WitKgLzXhAL/3N+qbCpY3yfBhkzSP07CH7jcDkArN7 vSJkhzwZuy/jTbh4bYCHxMFybUJiy9qGDlnzj891e1/9I/luNWlD5DpEGVsEyd1UZRGO 3J+w== X-Gm-Message-State: AHQUAuatfBs0wZXPriC4l5JUZEh2s5UYOIL6VTWHrlbfalYrfdHWdWmb 6cAvrd0bERSMJqk3U0gkPc6EbA== X-Google-Smtp-Source: AHgI3IZGrLuglDXWkIYWZ16tRYG0ijmHjLvEEsKzEVyeIbSovGaKgIBwcXWYy5YNbYFPGA1hOhPCZQ== X-Received: by 2002:a50:9dc1:: with SMTP id l1mr8956055edk.272.1549471629308; Wed, 06 Feb 2019 08:47:09 -0800 (PST) Received: from phenom.ffwll.local ([2a02:168:569e:0:3106:d637:d723:e855]) by smtp.gmail.com with ESMTPSA id a38sm6089154edd.44.2019.02.06.08.47.07 (version=TLS1_2 cipher=ECDHE-RSA-AES128-GCM-SHA256 bits=128/128); Wed, 06 Feb 2019 08:47:07 -0800 (PST) From: Daniel Vetter To: DRI Development Cc: LKML , Daniel Vetter , "C, Ramalingam" , Greg Kroah-Hartman , Russell King , "Rafael J . Wysocki" , Jaroslav Kysela , Takashi Iwai , Rodrigo Vivi , Jani Nikula , Daniel Vetter Subject: [PATCH] component: Add documentation Date: Wed, 6 Feb 2019 17:47:02 +0100 Message-Id: <20190206164702.29753-1-daniel.vetter@ffwll.ch> X-Mailer: git-send-email 2.20.1 In-Reply-To: <20190206164551.29400-1-daniel.vetter@ffwll.ch> References: <20190206164551.29400-1-daniel.vetter@ffwll.ch> MIME-Version: 1.0 Content-Transfer-Encoding: 8bit Sender: linux-kernel-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org While typing these I think doing an s/component_master/aggregate/ would be useful: - it's shorter :-) - I think component/aggregate is much more meaningful naming than component/puppetmaster or something like that. At least to my English ear "aggregate" emphasizes much more the "assemble a pile of things into something bigger" aspect, and there's not really much of a control hierarchy between aggregate and constituing components. But that's way more than a quick doc typing exercise ... Thanks to Ram for commenting on an initial draft of these docs. v2: Review from Rafael: - git add Documenation/driver-api/component.rst - lots of polish to the wording + spelling fixes. v3: Review from Russell: - s/framework/helper - clarify the documentation for component_match_add functions. Cc: "C, Ramalingam" Cc: Greg Kroah-Hartman Cc: Russell King Cc: Rafael J. Wysocki Cc: Jaroslav Kysela Cc: Takashi Iwai Cc: Rodrigo Vivi Cc: Jani Nikula Signed-off-by: Daniel Vetter --- Documentation/driver-api/component.rst | 17 ++++ Documentation/driver-api/device_link.rst | 3 + Documentation/driver-api/index.rst | 1 + drivers/base/component.c | 107 ++++++++++++++++++++++- include/linux/component.h | 71 +++++++++++++++ 5 files changed, 196 insertions(+), 3 deletions(-) create mode 100644 Documentation/driver-api/component.rst diff --git a/Documentation/driver-api/component.rst b/Documentation/driver-api/component.rst new file mode 100644 index 000000000000..2da4a8f20607 --- /dev/null +++ b/Documentation/driver-api/component.rst @@ -0,0 +1,17 @@ +====================================== +Component Helper for Aggregate Drivers +====================================== + +.. kernel-doc:: drivers/base/component.c + :doc: overview + + +API +=== + +.. kernel-doc:: include/linux/component.h + :internal: + +.. kernel-doc:: drivers/base/component.c + :export: + diff --git a/Documentation/driver-api/device_link.rst b/Documentation/driver-api/device_link.rst index d6763272e747..2d5919b2b337 100644 --- a/Documentation/driver-api/device_link.rst +++ b/Documentation/driver-api/device_link.rst @@ -1,6 +1,9 @@ .. |struct dev_pm_domain| replace:: :c:type:`struct dev_pm_domain ` .. |struct generic_pm_domain| replace:: :c:type:`struct generic_pm_domain ` + +.. _device_link: + ============ Device links ============ diff --git a/Documentation/driver-api/index.rst b/Documentation/driver-api/index.rst index ab38ced66a44..c0b600ed9961 100644 --- a/Documentation/driver-api/index.rst +++ b/Documentation/driver-api/index.rst @@ -22,6 +22,7 @@ available subsections can be seen below. device_connection dma-buf device_link + component message-based sound frame-buffer diff --git a/drivers/base/component.c b/drivers/base/component.c index ddcea8739c12..f34d4b784709 100644 --- a/drivers/base/component.c +++ b/drivers/base/component.c @@ -16,6 +16,32 @@ #include #include +/** + * DOC: overview + * + * The component helper allows drivers to collect a pile of sub-devices, + * including their bound drivers, into an aggregate driver. Various subsystems + * already provide functions to get hold of such components, e.g. + * of_clk_get_by_name(). The component helper can be used when such a + * subsystem-specific way to find a device is not available: The component + * helper fills the niche of aggregate drivers for specific hardware, where + * further standardization into a subsystem would not be practical. The common + * example is when a logical device (e.g. a DRM display driver) is spread around + * the SoC on various component (scanout engines, blending blocks, transcoders + * for various outputs and so on). + * + * The component helper also doesn't solve runtime dependencies, e.g. for system + * suspend and resume operations. See also :ref:`device links`. + * + * Components are registered using component_add() and unregistered with + * component_del(), usually from the driver's probe and disconnect functions. + * + * Aggregate drivers first assemble a component match list of what they need + * using component_match_add(). This is then registered as an aggregate driver + * using component_master_add_with_match(), and unregistered using + * component_master_del(). + */ + struct component; struct component_match_array { @@ -301,10 +327,25 @@ static int component_match_realloc(struct device *dev, return 0; } -/* - * Add a component to be matched, with a release function. +/** + * component_match_add_release - add a component match with release callback + * @master: device with the aggregate driver + * @matchptr: pointer to the list of component matches + * @release: release function for @compare_data + * @compare: compare function to match against all components + * @compare_data: opaque pointer passed to the @compare function + * + * This adds a new component match to the list stored in @matchptr, which the + * @master aggregate driver needs to function. The list of component matches + * pointed to by @matchptr must be initialized to NULL before adding the first + * match. + * + * The allocated match list in @matchptr is automatically released using devm + * actions, where upon @release will be called to free any references held by + * @compare_data, e.g. when @compare_data is a &device_node that must be + * released with of_node_put(). * - * The match array is first created or extended if necessary. + * See also component_match_add(). */ void component_match_add_release(struct device *master, struct component_match **matchptr, @@ -367,6 +408,18 @@ static void free_master(struct master *master) kfree(master); } +/** + * component_master_add_with_match - register an aggregate driver + * @dev: device with the aggregate driver + * @ops: callbacks for the aggregate driver + * @match: component match list for the aggregate driver + * + * Registers a new aggregate driver consisting of the components added to @match + * by calling one of the component_match_add() functions. Once all components in + * @match are available, it will be assembled by calling + * &component_master_ops.bind from @ops. Must be unregistered by calling + * component_master_del(). + */ int component_master_add_with_match(struct device *dev, const struct component_master_ops *ops, struct component_match *match) @@ -403,6 +456,15 @@ int component_master_add_with_match(struct device *dev, } EXPORT_SYMBOL_GPL(component_master_add_with_match); +/** + * component_master_del - unregister an aggregate driver + * @dev: device with the aggregate driver + * @ops: callbacks for the aggregate driver + * + * Unregisters an aggregate driver registered with + * component_master_add_with_match(). If necessary the aggregate driver is first + * disassembled by calling &component_master_ops.unbind from @ops. + */ void component_master_del(struct device *dev, const struct component_master_ops *ops) { @@ -430,6 +492,15 @@ static void component_unbind(struct component *component, devres_release_group(component->dev, component); } +/** + * component_unbind_all - unbind all component to an aggregate driver + * @master_dev: device with the aggregate driver + * @data: opaque pointer, passed to all components + * + * Unbinds all components to the aggregate @dev by passing @data to their + * &component_ops.unbind functions. Should be called from + * &component_master_ops.unbind. + */ void component_unbind_all(struct device *master_dev, void *data) { struct master *master; @@ -503,6 +574,15 @@ static int component_bind(struct component *component, struct master *master, return ret; } +/** + * component_bind_all - bind all component to an aggregate driver + * @master_dev: device with the aggregate driver + * @data: opaque pointer, passed to all components + * + * Binds all components to the aggregate @dev by passing @data to their + * &component_ops.bind functions. Should be called from + * &component_master_ops.bind. + */ int component_bind_all(struct device *master_dev, void *data) { struct master *master; @@ -537,6 +617,18 @@ int component_bind_all(struct device *master_dev, void *data) } EXPORT_SYMBOL_GPL(component_bind_all); +/** + * component_add - register a component + * @dev: component device + * @ops: component callbacks + * + * Register a new component for @dev. Functions in @ops will be called when the + * aggregate driver is ready to bind the overall driver by calling + * component_bind_all(). See also &struct component_ops. + * + * The component needs to be unregistered at driver unload/disconnect by calling + * component_del(). + */ int component_add(struct device *dev, const struct component_ops *ops) { struct component *component; @@ -568,6 +660,15 @@ int component_add(struct device *dev, const struct component_ops *ops) } EXPORT_SYMBOL_GPL(component_add); +/** + * component_del - unregister a component + * @dev: component device + * @ops: component callbacks + * + * Unregister a component added with component_add(). If the component is bound + * into an aggregate driver, this will force the entire aggregate driver, including + * all its components, to be unbound. + */ void component_del(struct device *dev, const struct component_ops *ops) { struct component *c, *component = NULL; diff --git a/include/linux/component.h b/include/linux/component.h index e71fbbbc74e2..4911598b4c42 100644 --- a/include/linux/component.h +++ b/include/linux/component.h @@ -4,11 +4,31 @@ #include + struct device; +/** + * struct component_ops - callbacks for component drivers + * + * Components are registered with component_add() and unregistered with + * component_del(). + */ struct component_ops { + /** + * @bind: + * + * Called through component_bind_all() when the aggregate driver is + * ready to bind the overall driver. + */ int (*bind)(struct device *comp, struct device *master, void *master_data); + /** + * @unbind: + * + * Called through component_unbind_all() when the aggregate driver is + * ready to bind the overall driver, or when component_bind_all() fails + * part-ways through and needs to unbind some already bound components. + */ void (*unbind)(struct device *comp, struct device *master, void *master_data); }; @@ -21,8 +41,42 @@ void component_unbind_all(struct device *master, void *master_data); struct master; +/** + * struct component_master_ops - callback for the aggregate driver + * + * Aggregate drivers are registered with component_master_add_with_match() and + * unregistered with component_master_del(). + */ struct component_master_ops { + /** + * @bind: + * + * Called when all components or the aggregate driver, as specified in + * the match list passed to component_master_add_with_match(), are + * ready. Usually there are 3 steps to bind an aggregate driver: + * + * 1. Allocate a structure for the aggregate driver. + * + * 2. Bind all components to the aggregate driver by calling + * component_bind_all() with the aggregate driver structure as opaque + * pointer data. + * + * 3. Register the aggregate driver with the subsystem to publish its + * interfaces. + * + * Note that the lifetime of the aggregate driver does not align with + * any of the underlying &struct device instances. Therefore devm cannot + * be used and all resources acquired or allocated in this callback must + * be explicitly released in the @unbind callback. + */ int (*bind)(struct device *master); + /** + * @unbind: + * + * Called when either the aggregate driver, using + * component_master_del(), or one of its components, using + * component_del(), is unregistered. + */ void (*unbind)(struct device *master); }; @@ -38,6 +92,23 @@ void component_match_add_release(struct device *master, void (*release)(struct device *, void *), int (*compare)(struct device *, void *), void *compare_data); +/** + * component_match_add - add a compent match + * @master: device with the aggregate driver + * @matchptr: pointer to the list of component matches + * @compare: compare function to match against all components + * @compare_data: opaque pointer passed to the @compare function + * + * This adds a new component match to the list stored in @matchptr, which the + * @master aggregate driver needs to function. The list of component matches + * pointed to by @matchptr must be initialized to NULL before adding the first + * match. + * + * The allocated match list in @matchptr is automatically released using devm + * actions. + * + * See also component_match_add_release(). + */ static inline void component_match_add(struct device *master, struct component_match **matchptr, int (*compare)(struct device *, void *), void *compare_data) -- 2.20.1 From mboxrd@z Thu Jan 1 00:00:00 1970 From: Daniel Vetter Subject: [PATCH] component: Add documentation Date: Wed, 6 Feb 2019 17:47:02 +0100 Message-ID: <20190206164702.29753-1-daniel.vetter@ffwll.ch> References: <20190206164551.29400-1-daniel.vetter@ffwll.ch> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Return-path: Received: from mail-ed1-x543.google.com (mail-ed1-x543.google.com [IPv6:2a00:1450:4864:20::543]) by gabe.freedesktop.org (Postfix) with ESMTPS id 2D0016EAB6 for ; Wed, 6 Feb 2019 16:47:11 +0000 (UTC) Received: by mail-ed1-x543.google.com with SMTP id h50so6455458ede.5 for ; Wed, 06 Feb 2019 08:47:11 -0800 (PST) In-Reply-To: <20190206164551.29400-1-daniel.vetter@ffwll.ch> List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: dri-devel-bounces@lists.freedesktop.org Sender: "dri-devel" To: DRI Development Cc: "Rafael J . Wysocki" , Daniel Vetter , Daniel Vetter , Takashi Iwai , LKML , Jaroslav Kysela , Rodrigo Vivi , Greg Kroah-Hartman , Russell King List-Id: dri-devel@lists.freedesktop.org V2hpbGUgdHlwaW5nIHRoZXNlIEkgdGhpbmsgZG9pbmcgYW4gcy9jb21wb25lbnRfbWFzdGVyL2Fn Z3JlZ2F0ZS8Kd291bGQgYmUgdXNlZnVsOgotIGl0J3Mgc2hvcnRlciA6LSkKLSBJIHRoaW5rIGNv bXBvbmVudC9hZ2dyZWdhdGUgaXMgbXVjaCBtb3JlIG1lYW5pbmdmdWwgbmFtaW5nIHRoYW4KICBj b21wb25lbnQvcHVwcGV0bWFzdGVyIG9yIHNvbWV0aGluZyBsaWtlIHRoYXQuIEF0IGxlYXN0IHRv IG15CiAgRW5nbGlzaCBlYXIgImFnZ3JlZ2F0ZSIgZW1waGFzaXplcyBtdWNoIG1vcmUgdGhlICJh c3NlbWJsZSBhIHBpbGUgb2YKICB0aGluZ3MgaW50byBzb21ldGhpbmcgYmlnZ2VyIiBhc3BlY3Qs IGFuZCB0aGVyZSdzIG5vdCByZWFsbHkgbXVjaAogIG9mIGEgY29udHJvbCBoaWVyYXJjaHkgYmV0 d2VlbiBhZ2dyZWdhdGUgYW5kIGNvbnN0aXR1aW5nIGNvbXBvbmVudHMuCgpCdXQgdGhhdCdzIHdh eSBtb3JlIHRoYW4gYSBxdWljayBkb2MgdHlwaW5nIGV4ZXJjaXNlIC4uLgoKVGhhbmtzIHRvIFJh bSBmb3IgY29tbWVudGluZyBvbiBhbiBpbml0aWFsIGRyYWZ0IG9mIHRoZXNlIGRvY3MuCgp2Mjog UmV2aWV3IGZyb20gUmFmYWVsOgotIGdpdCBhZGQgRG9jdW1lbmF0aW9uL2RyaXZlci1hcGkvY29t cG9uZW50LnJzdAotIGxvdHMgb2YgcG9saXNoIHRvIHRoZSB3b3JkaW5nICsgc3BlbGxpbmcgZml4 ZXMuCgp2MzogUmV2aWV3IGZyb20gUnVzc2VsbDoKLSBzL2ZyYW1ld29yay9oZWxwZXIKLSBjbGFy aWZ5IHRoZSBkb2N1bWVudGF0aW9uIGZvciBjb21wb25lbnRfbWF0Y2hfYWRkIGZ1bmN0aW9ucy4K CkNjOiAiQywgUmFtYWxpbmdhbSIgPHJhbWFsaW5nYW0uY0BpbnRlbC5jb20+CkNjOiBHcmVnIEty b2FoLUhhcnRtYW4gPGdyZWdraEBsaW51eGZvdW5kYXRpb24ub3JnPgpDYzogUnVzc2VsbCBLaW5n IDxybWsra2VybmVsQGFybS5saW51eC5vcmcudWs+CkNjOiBSYWZhZWwgSi4gV3lzb2NraSA8cmFm YWVsQGtlcm5lbC5vcmc+CkNjOiBKYXJvc2xhdiBLeXNlbGEgPHBlcmV4QHBlcmV4LmN6PgpDYzog VGFrYXNoaSBJd2FpIDx0aXdhaUBzdXNlLmNvbT4KQ2M6IFJvZHJpZ28gVml2aSA8cm9kcmlnby52 aXZpQGludGVsLmNvbT4KQ2M6IEphbmkgTmlrdWxhIDxqYW5pLm5pa3VsYUBsaW51eC5pbnRlbC5j b20+ClNpZ25lZC1vZmYtYnk6IERhbmllbCBWZXR0ZXIgPGRhbmllbC52ZXR0ZXJAaW50ZWwuY29t PgotLS0KIERvY3VtZW50YXRpb24vZHJpdmVyLWFwaS9jb21wb25lbnQucnN0ICAgfCAgMTcgKysr KwogRG9jdW1lbnRhdGlvbi9kcml2ZXItYXBpL2RldmljZV9saW5rLnJzdCB8ICAgMyArCiBEb2N1 bWVudGF0aW9uL2RyaXZlci1hcGkvaW5kZXgucnN0ICAgICAgIHwgICAxICsKIGRyaXZlcnMvYmFz ZS9jb21wb25lbnQuYyAgICAgICAgICAgICAgICAgfCAxMDcgKysrKysrKysrKysrKysrKysrKysr Ky0KIGluY2x1ZGUvbGludXgvY29tcG9uZW50LmggICAgICAgICAgICAgICAgfCAgNzEgKysrKysr KysrKysrKysrCiA1IGZpbGVzIGNoYW5nZWQsIDE5NiBpbnNlcnRpb25zKCspLCAzIGRlbGV0aW9u cygtKQogY3JlYXRlIG1vZGUgMTAwNjQ0IERvY3VtZW50YXRpb24vZHJpdmVyLWFwaS9jb21wb25l bnQucnN0CgpkaWZmIC0tZ2l0IGEvRG9jdW1lbnRhdGlvbi9kcml2ZXItYXBpL2NvbXBvbmVudC5y c3QgYi9Eb2N1bWVudGF0aW9uL2RyaXZlci1hcGkvY29tcG9uZW50LnJzdApuZXcgZmlsZSBtb2Rl IDEwMDY0NAppbmRleCAwMDAwMDAwMDAwMDAuLjJkYTRhOGYyMDYwNwotLS0gL2Rldi9udWxsCisr KyBiL0RvY3VtZW50YXRpb24vZHJpdmVyLWFwaS9jb21wb25lbnQucnN0CkBAIC0wLDAgKzEsMTcg QEAKKz09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09CitDb21wb25lbnQgSGVs cGVyIGZvciBBZ2dyZWdhdGUgRHJpdmVycworPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT0KKworLi4ga2VybmVsLWRvYzo6IGRyaXZlcnMvYmFzZS9jb21wb25lbnQuYworICAg OmRvYzogb3ZlcnZpZXcKKworCitBUEkKKz09PQorCisuLiBrZXJuZWwtZG9jOjogaW5jbHVkZS9s aW51eC9jb21wb25lbnQuaAorICAgOmludGVybmFsOgorCisuLiBrZXJuZWwtZG9jOjogZHJpdmVy cy9iYXNlL2NvbXBvbmVudC5jCisgICA6ZXhwb3J0OgorCmRpZmYgLS1naXQgYS9Eb2N1bWVudGF0 aW9uL2RyaXZlci1hcGkvZGV2aWNlX2xpbmsucnN0IGIvRG9jdW1lbnRhdGlvbi9kcml2ZXItYXBp L2RldmljZV9saW5rLnJzdAppbmRleCBkNjc2MzI3MmU3NDcuLjJkNTkxOWIyYjMzNyAxMDA2NDQK LS0tIGEvRG9jdW1lbnRhdGlvbi9kcml2ZXItYXBpL2RldmljZV9saW5rLnJzdAorKysgYi9Eb2N1 bWVudGF0aW9uL2RyaXZlci1hcGkvZGV2aWNlX2xpbmsucnN0CkBAIC0xLDYgKzEsOSBAQAogLi4g fHN0cnVjdCBkZXZfcG1fZG9tYWlufCByZXBsYWNlOjogOmM6dHlwZTpgc3RydWN0IGRldl9wbV9k b21haW4gPGRldl9wbV9kb21haW4+YAogLi4gfHN0cnVjdCBnZW5lcmljX3BtX2RvbWFpbnwgcmVw bGFjZTo6IDpjOnR5cGU6YHN0cnVjdCBnZW5lcmljX3BtX2RvbWFpbiA8Z2VuZXJpY19wbV9kb21h aW4+YAogCisKKy4uIF9kZXZpY2VfbGluazoKKwogPT09PT09PT09PT09CiBEZXZpY2UgbGlua3MK ID09PT09PT09PT09PQpkaWZmIC0tZ2l0IGEvRG9jdW1lbnRhdGlvbi9kcml2ZXItYXBpL2luZGV4 LnJzdCBiL0RvY3VtZW50YXRpb24vZHJpdmVyLWFwaS9pbmRleC5yc3QKaW5kZXggYWIzOGNlZDY2 YTQ0Li5jMGI2MDBlZDk5NjEgMTAwNjQ0Ci0tLSBhL0RvY3VtZW50YXRpb24vZHJpdmVyLWFwaS9p bmRleC5yc3QKKysrIGIvRG9jdW1lbnRhdGlvbi9kcml2ZXItYXBpL2luZGV4LnJzdApAQCAtMjIs NiArMjIsNyBAQCBhdmFpbGFibGUgc3Vic2VjdGlvbnMgY2FuIGJlIHNlZW4gYmVsb3cuCiAgICBk ZXZpY2VfY29ubmVjdGlvbgogICAgZG1hLWJ1ZgogICAgZGV2aWNlX2xpbmsKKyAgIGNvbXBvbmVu dAogICAgbWVzc2FnZS1iYXNlZAogICAgc291bmQKICAgIGZyYW1lLWJ1ZmZlcgpkaWZmIC0tZ2l0 IGEvZHJpdmVycy9iYXNlL2NvbXBvbmVudC5jIGIvZHJpdmVycy9iYXNlL2NvbXBvbmVudC5jCmlu ZGV4IGRkY2VhODczOWMxMi4uZjM0ZDRiNzg0NzA5IDEwMDY0NAotLS0gYS9kcml2ZXJzL2Jhc2Uv Y29tcG9uZW50LmMKKysrIGIvZHJpdmVycy9iYXNlL2NvbXBvbmVudC5jCkBAIC0xNiw2ICsxNiwz MiBAQAogI2luY2x1ZGUgPGxpbnV4L3NsYWIuaD4KICNpbmNsdWRlIDxsaW51eC9kZWJ1Z2ZzLmg+ CiAKKy8qKgorICogRE9DOiBvdmVydmlldworICoKKyAqIFRoZSBjb21wb25lbnQgaGVscGVyIGFs bG93cyBkcml2ZXJzIHRvIGNvbGxlY3QgYSBwaWxlIG9mIHN1Yi1kZXZpY2VzLAorICogaW5jbHVk aW5nIHRoZWlyIGJvdW5kIGRyaXZlcnMsIGludG8gYW4gYWdncmVnYXRlIGRyaXZlci4gVmFyaW91 cyBzdWJzeXN0ZW1zCisgKiBhbHJlYWR5IHByb3ZpZGUgZnVuY3Rpb25zIHRvIGdldCBob2xkIG9m IHN1Y2ggY29tcG9uZW50cywgZS5nLgorICogb2ZfY2xrX2dldF9ieV9uYW1lKCkuIFRoZSBjb21w b25lbnQgaGVscGVyIGNhbiBiZSB1c2VkIHdoZW4gc3VjaCBhCisgKiBzdWJzeXN0ZW0tc3BlY2lm aWMgd2F5IHRvIGZpbmQgYSBkZXZpY2UgaXMgbm90IGF2YWlsYWJsZTogVGhlIGNvbXBvbmVudAor ICogaGVscGVyIGZpbGxzIHRoZSBuaWNoZSBvZiBhZ2dyZWdhdGUgZHJpdmVycyBmb3Igc3BlY2lm aWMgaGFyZHdhcmUsIHdoZXJlCisgKiBmdXJ0aGVyIHN0YW5kYXJkaXphdGlvbiBpbnRvIGEgc3Vi c3lzdGVtIHdvdWxkIG5vdCBiZSBwcmFjdGljYWwuIFRoZSBjb21tb24KKyAqIGV4YW1wbGUgaXMg d2hlbiBhIGxvZ2ljYWwgZGV2aWNlIChlLmcuIGEgRFJNIGRpc3BsYXkgZHJpdmVyKSBpcyBzcHJl YWQgYXJvdW5kCisgKiB0aGUgU29DIG9uIHZhcmlvdXMgY29tcG9uZW50IChzY2Fub3V0IGVuZ2lu ZXMsIGJsZW5kaW5nIGJsb2NrcywgdHJhbnNjb2RlcnMKKyAqIGZvciB2YXJpb3VzIG91dHB1dHMg YW5kIHNvIG9uKS4KKyAqCisgKiBUaGUgY29tcG9uZW50IGhlbHBlciBhbHNvIGRvZXNuJ3Qgc29s dmUgcnVudGltZSBkZXBlbmRlbmNpZXMsIGUuZy4gZm9yIHN5c3RlbQorICogc3VzcGVuZCBhbmQg cmVzdW1lIG9wZXJhdGlvbnMuIFNlZSBhbHNvIDpyZWY6YGRldmljZSBsaW5rczxkZXZpY2VfbGlu az5gLgorICoKKyAqIENvbXBvbmVudHMgYXJlIHJlZ2lzdGVyZWQgdXNpbmcgY29tcG9uZW50X2Fk ZCgpIGFuZCB1bnJlZ2lzdGVyZWQgd2l0aAorICogY29tcG9uZW50X2RlbCgpLCB1c3VhbGx5IGZy b20gdGhlIGRyaXZlcidzIHByb2JlIGFuZCBkaXNjb25uZWN0IGZ1bmN0aW9ucy4KKyAqCisgKiBB Z2dyZWdhdGUgZHJpdmVycyBmaXJzdCBhc3NlbWJsZSBhIGNvbXBvbmVudCBtYXRjaCBsaXN0IG9m IHdoYXQgdGhleSBuZWVkCisgKiB1c2luZyBjb21wb25lbnRfbWF0Y2hfYWRkKCkuIFRoaXMgaXMg dGhlbiByZWdpc3RlcmVkIGFzIGFuIGFnZ3JlZ2F0ZSBkcml2ZXIKKyAqIHVzaW5nIGNvbXBvbmVu dF9tYXN0ZXJfYWRkX3dpdGhfbWF0Y2goKSwgYW5kIHVucmVnaXN0ZXJlZCB1c2luZworICogY29t cG9uZW50X21hc3Rlcl9kZWwoKS4KKyAqLworCiBzdHJ1Y3QgY29tcG9uZW50OwogCiBzdHJ1Y3Qg Y29tcG9uZW50X21hdGNoX2FycmF5IHsKQEAgLTMwMSwxMCArMzI3LDI1IEBAIHN0YXRpYyBpbnQg Y29tcG9uZW50X21hdGNoX3JlYWxsb2Moc3RydWN0IGRldmljZSAqZGV2LAogCXJldHVybiAwOwog fQogCi0vKgotICogQWRkIGEgY29tcG9uZW50IHRvIGJlIG1hdGNoZWQsIHdpdGggYSByZWxlYXNl IGZ1bmN0aW9uLgorLyoqCisgKiBjb21wb25lbnRfbWF0Y2hfYWRkX3JlbGVhc2UgLSBhZGQgYSBj b21wb25lbnQgbWF0Y2ggd2l0aCByZWxlYXNlIGNhbGxiYWNrCisgKiBAbWFzdGVyOiBkZXZpY2Ug d2l0aCB0aGUgYWdncmVnYXRlIGRyaXZlcgorICogQG1hdGNocHRyOiBwb2ludGVyIHRvIHRoZSBs aXN0IG9mIGNvbXBvbmVudCBtYXRjaGVzCisgKiBAcmVsZWFzZTogcmVsZWFzZSBmdW5jdGlvbiBm b3IgQGNvbXBhcmVfZGF0YQorICogQGNvbXBhcmU6IGNvbXBhcmUgZnVuY3Rpb24gdG8gbWF0Y2gg YWdhaW5zdCBhbGwgY29tcG9uZW50cworICogQGNvbXBhcmVfZGF0YTogb3BhcXVlIHBvaW50ZXIg cGFzc2VkIHRvIHRoZSBAY29tcGFyZSBmdW5jdGlvbgorICoKKyAqIFRoaXMgYWRkcyBhIG5ldyBj b21wb25lbnQgbWF0Y2ggdG8gdGhlIGxpc3Qgc3RvcmVkIGluIEBtYXRjaHB0ciwgd2hpY2ggdGhl CisgKiBAbWFzdGVyIGFnZ3JlZ2F0ZSBkcml2ZXIgbmVlZHMgdG8gZnVuY3Rpb24uIFRoZSBsaXN0 IG9mIGNvbXBvbmVudCBtYXRjaGVzCisgKiBwb2ludGVkIHRvIGJ5IEBtYXRjaHB0ciBtdXN0IGJl IGluaXRpYWxpemVkIHRvIE5VTEwgYmVmb3JlIGFkZGluZyB0aGUgZmlyc3QKKyAqIG1hdGNoLgor ICoKKyAqIFRoZSBhbGxvY2F0ZWQgbWF0Y2ggbGlzdCBpbiBAbWF0Y2hwdHIgaXMgYXV0b21hdGlj YWxseSByZWxlYXNlZCB1c2luZyBkZXZtCisgKiBhY3Rpb25zLCB3aGVyZSB1cG9uIEByZWxlYXNl IHdpbGwgYmUgY2FsbGVkIHRvIGZyZWUgYW55IHJlZmVyZW5jZXMgaGVsZCBieQorICogQGNvbXBh cmVfZGF0YSwgZS5nLiB3aGVuIEBjb21wYXJlX2RhdGEgaXMgYSAmZGV2aWNlX25vZGUgdGhhdCBt dXN0IGJlCisgKiByZWxlYXNlZCB3aXRoIG9mX25vZGVfcHV0KCkuCiAgKgotICogVGhlIG1hdGNo IGFycmF5IGlzIGZpcnN0IGNyZWF0ZWQgb3IgZXh0ZW5kZWQgaWYgbmVjZXNzYXJ5LgorICogU2Vl IGFsc28gY29tcG9uZW50X21hdGNoX2FkZCgpLgogICovCiB2b2lkIGNvbXBvbmVudF9tYXRjaF9h ZGRfcmVsZWFzZShzdHJ1Y3QgZGV2aWNlICptYXN0ZXIsCiAJc3RydWN0IGNvbXBvbmVudF9tYXRj aCAqKm1hdGNocHRyLApAQCAtMzY3LDYgKzQwOCwxOCBAQCBzdGF0aWMgdm9pZCBmcmVlX21hc3Rl cihzdHJ1Y3QgbWFzdGVyICptYXN0ZXIpCiAJa2ZyZWUobWFzdGVyKTsKIH0KIAorLyoqCisgKiBj b21wb25lbnRfbWFzdGVyX2FkZF93aXRoX21hdGNoIC0gcmVnaXN0ZXIgYW4gYWdncmVnYXRlIGRy aXZlcgorICogQGRldjogZGV2aWNlIHdpdGggdGhlIGFnZ3JlZ2F0ZSBkcml2ZXIKKyAqIEBvcHM6 IGNhbGxiYWNrcyBmb3IgdGhlIGFnZ3JlZ2F0ZSBkcml2ZXIKKyAqIEBtYXRjaDogY29tcG9uZW50 IG1hdGNoIGxpc3QgZm9yIHRoZSBhZ2dyZWdhdGUgZHJpdmVyCisgKgorICogUmVnaXN0ZXJzIGEg bmV3IGFnZ3JlZ2F0ZSBkcml2ZXIgY29uc2lzdGluZyBvZiB0aGUgY29tcG9uZW50cyBhZGRlZCB0 byBAbWF0Y2gKKyAqIGJ5IGNhbGxpbmcgb25lIG9mIHRoZSBjb21wb25lbnRfbWF0Y2hfYWRkKCkg ZnVuY3Rpb25zLiBPbmNlIGFsbCBjb21wb25lbnRzIGluCisgKiBAbWF0Y2ggYXJlIGF2YWlsYWJs ZSwgaXQgd2lsbCBiZSBhc3NlbWJsZWQgYnkgY2FsbGluZworICogJmNvbXBvbmVudF9tYXN0ZXJf b3BzLmJpbmQgZnJvbSBAb3BzLiBNdXN0IGJlIHVucmVnaXN0ZXJlZCBieSBjYWxsaW5nCisgKiBj b21wb25lbnRfbWFzdGVyX2RlbCgpLgorICovCiBpbnQgY29tcG9uZW50X21hc3Rlcl9hZGRfd2l0 aF9tYXRjaChzdHJ1Y3QgZGV2aWNlICpkZXYsCiAJY29uc3Qgc3RydWN0IGNvbXBvbmVudF9tYXN0 ZXJfb3BzICpvcHMsCiAJc3RydWN0IGNvbXBvbmVudF9tYXRjaCAqbWF0Y2gpCkBAIC00MDMsNiAr NDU2LDE1IEBAIGludCBjb21wb25lbnRfbWFzdGVyX2FkZF93aXRoX21hdGNoKHN0cnVjdCBkZXZp Y2UgKmRldiwKIH0KIEVYUE9SVF9TWU1CT0xfR1BMKGNvbXBvbmVudF9tYXN0ZXJfYWRkX3dpdGhf bWF0Y2gpOwogCisvKioKKyAqIGNvbXBvbmVudF9tYXN0ZXJfZGVsIC0gdW5yZWdpc3RlciBhbiBh Z2dyZWdhdGUgZHJpdmVyCisgKiBAZGV2OiBkZXZpY2Ugd2l0aCB0aGUgYWdncmVnYXRlIGRyaXZl cgorICogQG9wczogY2FsbGJhY2tzIGZvciB0aGUgYWdncmVnYXRlIGRyaXZlcgorICoKKyAqIFVu cmVnaXN0ZXJzIGFuIGFnZ3JlZ2F0ZSBkcml2ZXIgcmVnaXN0ZXJlZCB3aXRoCisgKiBjb21wb25l bnRfbWFzdGVyX2FkZF93aXRoX21hdGNoKCkuIElmIG5lY2Vzc2FyeSB0aGUgYWdncmVnYXRlIGRy aXZlciBpcyBmaXJzdAorICogZGlzYXNzZW1ibGVkIGJ5IGNhbGxpbmcgJmNvbXBvbmVudF9tYXN0 ZXJfb3BzLnVuYmluZCBmcm9tIEBvcHMuCisgKi8KIHZvaWQgY29tcG9uZW50X21hc3Rlcl9kZWwo c3RydWN0IGRldmljZSAqZGV2LAogCWNvbnN0IHN0cnVjdCBjb21wb25lbnRfbWFzdGVyX29wcyAq b3BzKQogewpAQCAtNDMwLDYgKzQ5MiwxNSBAQCBzdGF0aWMgdm9pZCBjb21wb25lbnRfdW5iaW5k KHN0cnVjdCBjb21wb25lbnQgKmNvbXBvbmVudCwKIAlkZXZyZXNfcmVsZWFzZV9ncm91cChjb21w b25lbnQtPmRldiwgY29tcG9uZW50KTsKIH0KIAorLyoqCisgKiBjb21wb25lbnRfdW5iaW5kX2Fs bCAtIHVuYmluZCBhbGwgY29tcG9uZW50IHRvIGFuIGFnZ3JlZ2F0ZSBkcml2ZXIKKyAqIEBtYXN0 ZXJfZGV2OiBkZXZpY2Ugd2l0aCB0aGUgYWdncmVnYXRlIGRyaXZlcgorICogQGRhdGE6IG9wYXF1 ZSBwb2ludGVyLCBwYXNzZWQgdG8gYWxsIGNvbXBvbmVudHMKKyAqCisgKiBVbmJpbmRzIGFsbCBj b21wb25lbnRzIHRvIHRoZSBhZ2dyZWdhdGUgQGRldiBieSBwYXNzaW5nIEBkYXRhIHRvIHRoZWly CisgKiAmY29tcG9uZW50X29wcy51bmJpbmQgZnVuY3Rpb25zLiBTaG91bGQgYmUgY2FsbGVkIGZy b20KKyAqICZjb21wb25lbnRfbWFzdGVyX29wcy51bmJpbmQuCisgKi8KIHZvaWQgY29tcG9uZW50 X3VuYmluZF9hbGwoc3RydWN0IGRldmljZSAqbWFzdGVyX2Rldiwgdm9pZCAqZGF0YSkKIHsKIAlz dHJ1Y3QgbWFzdGVyICptYXN0ZXI7CkBAIC01MDMsNiArNTc0LDE1IEBAIHN0YXRpYyBpbnQgY29t cG9uZW50X2JpbmQoc3RydWN0IGNvbXBvbmVudCAqY29tcG9uZW50LCBzdHJ1Y3QgbWFzdGVyICpt YXN0ZXIsCiAJcmV0dXJuIHJldDsKIH0KIAorLyoqCisgKiBjb21wb25lbnRfYmluZF9hbGwgLSBi aW5kIGFsbCBjb21wb25lbnQgdG8gYW4gYWdncmVnYXRlIGRyaXZlcgorICogQG1hc3Rlcl9kZXY6 IGRldmljZSB3aXRoIHRoZSBhZ2dyZWdhdGUgZHJpdmVyCisgKiBAZGF0YTogb3BhcXVlIHBvaW50 ZXIsIHBhc3NlZCB0byBhbGwgY29tcG9uZW50cworICoKKyAqIEJpbmRzIGFsbCBjb21wb25lbnRz IHRvIHRoZSBhZ2dyZWdhdGUgQGRldiBieSBwYXNzaW5nIEBkYXRhIHRvIHRoZWlyCisgKiAmY29t cG9uZW50X29wcy5iaW5kIGZ1bmN0aW9ucy4gU2hvdWxkIGJlIGNhbGxlZCBmcm9tCisgKiAmY29t cG9uZW50X21hc3Rlcl9vcHMuYmluZC4KKyAqLwogaW50IGNvbXBvbmVudF9iaW5kX2FsbChzdHJ1 Y3QgZGV2aWNlICptYXN0ZXJfZGV2LCB2b2lkICpkYXRhKQogewogCXN0cnVjdCBtYXN0ZXIgKm1h c3RlcjsKQEAgLTUzNyw2ICs2MTcsMTggQEAgaW50IGNvbXBvbmVudF9iaW5kX2FsbChzdHJ1Y3Qg ZGV2aWNlICptYXN0ZXJfZGV2LCB2b2lkICpkYXRhKQogfQogRVhQT1JUX1NZTUJPTF9HUEwoY29t cG9uZW50X2JpbmRfYWxsKTsKIAorLyoqCisgKiBjb21wb25lbnRfYWRkIC0gcmVnaXN0ZXIgYSBj b21wb25lbnQKKyAqIEBkZXY6IGNvbXBvbmVudCBkZXZpY2UKKyAqIEBvcHM6IGNvbXBvbmVudCBj YWxsYmFja3MKKyAqCisgKiBSZWdpc3RlciBhIG5ldyBjb21wb25lbnQgZm9yIEBkZXYuIEZ1bmN0 aW9ucyBpbiBAb3BzIHdpbGwgYmUgY2FsbGVkIHdoZW4gdGhlCisgKiBhZ2dyZWdhdGUgZHJpdmVy IGlzIHJlYWR5IHRvIGJpbmQgdGhlIG92ZXJhbGwgZHJpdmVyIGJ5IGNhbGxpbmcKKyAqIGNvbXBv bmVudF9iaW5kX2FsbCgpLiBTZWUgYWxzbyAmc3RydWN0IGNvbXBvbmVudF9vcHMuCisgKgorICog VGhlIGNvbXBvbmVudCBuZWVkcyB0byBiZSB1bnJlZ2lzdGVyZWQgYXQgZHJpdmVyIHVubG9hZC9k aXNjb25uZWN0IGJ5IGNhbGxpbmcKKyAqIGNvbXBvbmVudF9kZWwoKS4KKyAqLwogaW50IGNvbXBv bmVudF9hZGQoc3RydWN0IGRldmljZSAqZGV2LCBjb25zdCBzdHJ1Y3QgY29tcG9uZW50X29wcyAq b3BzKQogewogCXN0cnVjdCBjb21wb25lbnQgKmNvbXBvbmVudDsKQEAgLTU2OCw2ICs2NjAsMTUg QEAgaW50IGNvbXBvbmVudF9hZGQoc3RydWN0IGRldmljZSAqZGV2LCBjb25zdCBzdHJ1Y3QgY29t cG9uZW50X29wcyAqb3BzKQogfQogRVhQT1JUX1NZTUJPTF9HUEwoY29tcG9uZW50X2FkZCk7CiAK Ky8qKgorICogY29tcG9uZW50X2RlbCAtIHVucmVnaXN0ZXIgYSBjb21wb25lbnQKKyAqIEBkZXY6 IGNvbXBvbmVudCBkZXZpY2UKKyAqIEBvcHM6IGNvbXBvbmVudCBjYWxsYmFja3MKKyAqCisgKiBV bnJlZ2lzdGVyIGEgY29tcG9uZW50IGFkZGVkIHdpdGggY29tcG9uZW50X2FkZCgpLiBJZiB0aGUg Y29tcG9uZW50IGlzIGJvdW5kCisgKiBpbnRvIGFuIGFnZ3JlZ2F0ZSBkcml2ZXIsIHRoaXMgd2ls bCBmb3JjZSB0aGUgZW50aXJlIGFnZ3JlZ2F0ZSBkcml2ZXIsIGluY2x1ZGluZworICogYWxsIGl0 cyBjb21wb25lbnRzLCB0byBiZSB1bmJvdW5kLgorICovCiB2b2lkIGNvbXBvbmVudF9kZWwoc3Ry dWN0IGRldmljZSAqZGV2LCBjb25zdCBzdHJ1Y3QgY29tcG9uZW50X29wcyAqb3BzKQogewogCXN0 cnVjdCBjb21wb25lbnQgKmMsICpjb21wb25lbnQgPSBOVUxMOwpkaWZmIC0tZ2l0IGEvaW5jbHVk ZS9saW51eC9jb21wb25lbnQuaCBiL2luY2x1ZGUvbGludXgvY29tcG9uZW50LmgKaW5kZXggZTcx ZmJiYmM3NGUyLi40OTExNTk4YjRjNDIgMTAwNjQ0Ci0tLSBhL2luY2x1ZGUvbGludXgvY29tcG9u ZW50LmgKKysrIGIvaW5jbHVkZS9saW51eC9jb21wb25lbnQuaApAQCAtNCwxMSArNCwzMSBAQAog CiAjaW5jbHVkZSA8bGludXgvc3RkZGVmLmg+CiAKKwogc3RydWN0IGRldmljZTsKIAorLyoqCisg KiBzdHJ1Y3QgY29tcG9uZW50X29wcyAtIGNhbGxiYWNrcyBmb3IgY29tcG9uZW50IGRyaXZlcnMK KyAqCisgKiBDb21wb25lbnRzIGFyZSByZWdpc3RlcmVkIHdpdGggY29tcG9uZW50X2FkZCgpIGFu ZCB1bnJlZ2lzdGVyZWQgd2l0aAorICogY29tcG9uZW50X2RlbCgpLgorICovCiBzdHJ1Y3QgY29t cG9uZW50X29wcyB7CisJLyoqCisJICogQGJpbmQ6CisJICoKKwkgKiBDYWxsZWQgdGhyb3VnaCBj b21wb25lbnRfYmluZF9hbGwoKSB3aGVuIHRoZSBhZ2dyZWdhdGUgZHJpdmVyIGlzCisJICogcmVh ZHkgdG8gYmluZCB0aGUgb3ZlcmFsbCBkcml2ZXIuCisJICovCiAJaW50ICgqYmluZCkoc3RydWN0 IGRldmljZSAqY29tcCwgc3RydWN0IGRldmljZSAqbWFzdGVyLAogCQkgICAgdm9pZCAqbWFzdGVy X2RhdGEpOworCS8qKgorCSAqIEB1bmJpbmQ6CisJICoKKwkgKiBDYWxsZWQgdGhyb3VnaCBjb21w b25lbnRfdW5iaW5kX2FsbCgpIHdoZW4gdGhlIGFnZ3JlZ2F0ZSBkcml2ZXIgaXMKKwkgKiByZWFk eSB0byBiaW5kIHRoZSBvdmVyYWxsIGRyaXZlciwgb3Igd2hlbiBjb21wb25lbnRfYmluZF9hbGwo KSBmYWlscworCSAqIHBhcnQtd2F5cyB0aHJvdWdoIGFuZCBuZWVkcyB0byB1bmJpbmQgc29tZSBh bHJlYWR5IGJvdW5kIGNvbXBvbmVudHMuCisJICovCiAJdm9pZCAoKnVuYmluZCkoc3RydWN0IGRl dmljZSAqY29tcCwgc3RydWN0IGRldmljZSAqbWFzdGVyLAogCQkgICAgICAgdm9pZCAqbWFzdGVy X2RhdGEpOwogfTsKQEAgLTIxLDggKzQxLDQyIEBAIHZvaWQgY29tcG9uZW50X3VuYmluZF9hbGwo c3RydWN0IGRldmljZSAqbWFzdGVyLCB2b2lkICptYXN0ZXJfZGF0YSk7CiAKIHN0cnVjdCBtYXN0 ZXI7CiAKKy8qKgorICogc3RydWN0IGNvbXBvbmVudF9tYXN0ZXJfb3BzIC0gY2FsbGJhY2sgZm9y IHRoZSBhZ2dyZWdhdGUgZHJpdmVyCisgKgorICogQWdncmVnYXRlIGRyaXZlcnMgYXJlIHJlZ2lz dGVyZWQgd2l0aCBjb21wb25lbnRfbWFzdGVyX2FkZF93aXRoX21hdGNoKCkgYW5kCisgKiB1bnJl Z2lzdGVyZWQgd2l0aCBjb21wb25lbnRfbWFzdGVyX2RlbCgpLgorICovCiBzdHJ1Y3QgY29tcG9u ZW50X21hc3Rlcl9vcHMgeworCS8qKgorCSAqIEBiaW5kOgorCSAqCisJICogQ2FsbGVkIHdoZW4g YWxsIGNvbXBvbmVudHMgb3IgdGhlIGFnZ3JlZ2F0ZSBkcml2ZXIsIGFzIHNwZWNpZmllZCBpbgor CSAqIHRoZSBtYXRjaCBsaXN0IHBhc3NlZCB0byBjb21wb25lbnRfbWFzdGVyX2FkZF93aXRoX21h dGNoKCksIGFyZQorCSAqIHJlYWR5LiBVc3VhbGx5IHRoZXJlIGFyZSAzIHN0ZXBzIHRvIGJpbmQg YW4gYWdncmVnYXRlIGRyaXZlcjoKKwkgKgorCSAqIDEuIEFsbG9jYXRlIGEgc3RydWN0dXJlIGZv ciB0aGUgYWdncmVnYXRlIGRyaXZlci4KKwkgKgorCSAqIDIuIEJpbmQgYWxsIGNvbXBvbmVudHMg dG8gdGhlIGFnZ3JlZ2F0ZSBkcml2ZXIgYnkgY2FsbGluZworCSAqICAgIGNvbXBvbmVudF9iaW5k X2FsbCgpIHdpdGggdGhlIGFnZ3JlZ2F0ZSBkcml2ZXIgc3RydWN0dXJlIGFzIG9wYXF1ZQorCSAq ICAgIHBvaW50ZXIgZGF0YS4KKwkgKgorCSAqIDMuIFJlZ2lzdGVyIHRoZSBhZ2dyZWdhdGUgZHJp dmVyIHdpdGggdGhlIHN1YnN5c3RlbSB0byBwdWJsaXNoIGl0cworCSAqICAgIGludGVyZmFjZXMu CisJICoKKwkgKiBOb3RlIHRoYXQgdGhlIGxpZmV0aW1lIG9mIHRoZSBhZ2dyZWdhdGUgZHJpdmVy IGRvZXMgbm90IGFsaWduIHdpdGgKKwkgKiBhbnkgb2YgdGhlIHVuZGVybHlpbmcgJnN0cnVjdCBk ZXZpY2UgaW5zdGFuY2VzLiBUaGVyZWZvcmUgZGV2bSBjYW5ub3QKKwkgKiBiZSB1c2VkIGFuZCBh bGwgcmVzb3VyY2VzIGFjcXVpcmVkIG9yIGFsbG9jYXRlZCBpbiB0aGlzIGNhbGxiYWNrIG11c3QK KwkgKiBiZSBleHBsaWNpdGx5IHJlbGVhc2VkIGluIHRoZSBAdW5iaW5kIGNhbGxiYWNrLgorCSAq LwogCWludCAoKmJpbmQpKHN0cnVjdCBkZXZpY2UgKm1hc3Rlcik7CisJLyoqCisJICogQHVuYmlu ZDoKKwkgKgorCSAqIENhbGxlZCB3aGVuIGVpdGhlciB0aGUgYWdncmVnYXRlIGRyaXZlciwgdXNp bmcKKwkgKiBjb21wb25lbnRfbWFzdGVyX2RlbCgpLCBvciBvbmUgb2YgaXRzIGNvbXBvbmVudHMs IHVzaW5nCisJICogY29tcG9uZW50X2RlbCgpLCBpcyB1bnJlZ2lzdGVyZWQuCisJICovCiAJdm9p ZCAoKnVuYmluZCkoc3RydWN0IGRldmljZSAqbWFzdGVyKTsKIH07CiAKQEAgLTM4LDYgKzkyLDIz IEBAIHZvaWQgY29tcG9uZW50X21hdGNoX2FkZF9yZWxlYXNlKHN0cnVjdCBkZXZpY2UgKm1hc3Rl ciwKIAl2b2lkICgqcmVsZWFzZSkoc3RydWN0IGRldmljZSAqLCB2b2lkICopLAogCWludCAoKmNv bXBhcmUpKHN0cnVjdCBkZXZpY2UgKiwgdm9pZCAqKSwgdm9pZCAqY29tcGFyZV9kYXRhKTsKIAor LyoqCisgKiBjb21wb25lbnRfbWF0Y2hfYWRkIC0gYWRkIGEgY29tcGVudCBtYXRjaAorICogQG1h c3RlcjogZGV2aWNlIHdpdGggdGhlIGFnZ3JlZ2F0ZSBkcml2ZXIKKyAqIEBtYXRjaHB0cjogcG9p bnRlciB0byB0aGUgbGlzdCBvZiBjb21wb25lbnQgbWF0Y2hlcworICogQGNvbXBhcmU6IGNvbXBh cmUgZnVuY3Rpb24gdG8gbWF0Y2ggYWdhaW5zdCBhbGwgY29tcG9uZW50cworICogQGNvbXBhcmVf ZGF0YTogb3BhcXVlIHBvaW50ZXIgcGFzc2VkIHRvIHRoZSBAY29tcGFyZSBmdW5jdGlvbgorICoK KyAqIFRoaXMgYWRkcyBhIG5ldyBjb21wb25lbnQgbWF0Y2ggdG8gdGhlIGxpc3Qgc3RvcmVkIGlu IEBtYXRjaHB0ciwgd2hpY2ggdGhlCisgKiBAbWFzdGVyIGFnZ3JlZ2F0ZSBkcml2ZXIgbmVlZHMg dG8gZnVuY3Rpb24uIFRoZSBsaXN0IG9mIGNvbXBvbmVudCBtYXRjaGVzCisgKiBwb2ludGVkIHRv IGJ5IEBtYXRjaHB0ciBtdXN0IGJlIGluaXRpYWxpemVkIHRvIE5VTEwgYmVmb3JlIGFkZGluZyB0 aGUgZmlyc3QKKyAqIG1hdGNoLgorICoKKyAqIFRoZSBhbGxvY2F0ZWQgbWF0Y2ggbGlzdCBpbiBA bWF0Y2hwdHIgaXMgYXV0b21hdGljYWxseSByZWxlYXNlZCB1c2luZyBkZXZtCisgKiBhY3Rpb25z LgorICoKKyAqIFNlZSBhbHNvIGNvbXBvbmVudF9tYXRjaF9hZGRfcmVsZWFzZSgpLgorICovCiBz dGF0aWMgaW5saW5lIHZvaWQgY29tcG9uZW50X21hdGNoX2FkZChzdHJ1Y3QgZGV2aWNlICptYXN0 ZXIsCiAJc3RydWN0IGNvbXBvbmVudF9tYXRjaCAqKm1hdGNocHRyLAogCWludCAoKmNvbXBhcmUp KHN0cnVjdCBkZXZpY2UgKiwgdm9pZCAqKSwgdm9pZCAqY29tcGFyZV9kYXRhKQotLSAKMi4yMC4x CgpfX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fXwpkcmktZGV2 ZWwgbWFpbGluZyBsaXN0CmRyaS1kZXZlbEBsaXN0cy5mcmVlZGVza3RvcC5vcmcKaHR0cHM6Ly9s aXN0cy5mcmVlZGVza3RvcC5vcmcvbWFpbG1hbi9saXN0aW5mby9kcmktZGV2ZWwK