From mboxrd@z Thu Jan 1 00:00:00 1970 Received: from relay9-d.mail.gandi.net (relay9-d.mail.gandi.net [217.70.183.199]) (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 C3B4C15F30A; Mon, 27 May 2024 16:15:01 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=217.70.183.199 ARC-Seal:i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1716826505; cv=none; b=cgpw1J/EYqFzZk0J3mzLu0g+aV/pgtuiIMPE/eTvWJtm1gIXJdDAgKzlvzntofusJqyXty3kUoEX5ddjPmQZzuXVVr5iR7bYS7W8XkqPVubjSVJjtAloeSs71enpDPsmpvvHT2642HPyRfBTkgPFF8IFXKGXMae2fqs/C/PDTjo= ARC-Message-Signature:i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1716826505; c=relaxed/simple; bh=0M1Hns7CDOYJ2aLM9KSawz/vJcM90IBbHl4CqMegdlE=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version:Content-Type; b=Dsa9AiA6NrSyZLTYAyhddrLRg8uJigHZ6cBBrX8P+nC9ZAZNbFKRPsJNtGyiImDxuxojGaReH4V2N8yl+U/0ABOENGgbXV7oc6pcKsp+EY51eFjL/tPqzkykR6I3dV8AZWoZlNsng4O0VV7zna5ufnvRbJpRWtZHC7qLs87t/kQ= ARC-Authentication-Results:i=1; smtp.subspace.kernel.org; dmarc=pass (p=reject dis=none) header.from=bootlin.com; spf=pass smtp.mailfrom=bootlin.com; dkim=pass (2048-bit key) header.d=bootlin.com header.i=@bootlin.com header.b=UbbkYHxY; arc=none smtp.client-ip=217.70.183.199 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=reject dis=none) header.from=bootlin.com Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=bootlin.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=bootlin.com header.i=@bootlin.com header.b="UbbkYHxY" Received: by mail.gandi.net (Postfix) with ESMTPA id 6E42AFF811; Mon, 27 May 2024 16:14:58 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=bootlin.com; s=gm1; t=1716826500; h=from:from:reply-to:subject:subject:date:date:message-id:message-id: to:to:cc:cc:mime-version:mime-version:content-type:content-type: content-transfer-encoding:content-transfer-encoding: in-reply-to:in-reply-to:references:references; bh=W9+p1hma003opriOOEox9fT6iYMjtITIcW1ZIQ2QLNo=; b=UbbkYHxYIA3ApPt5oZI7rO4HRwWoAo+RNwHf495UokGST04QM/XPmwZtNfGcvXqNkTLLfv zPUvOe+3SPZsP9KT2IJxAesVe4FI9LV4C2BZTsojIVpNNUeFoesg2zWL8OJEA8+nRMAOHN K+llDN/wjyKrld3B3chDtl9+p+esUWB+dB8aE9FtPOBBFiQg0um64VbuBdlxOWQtqvk3OM W0JAOMp5UrAlcivoZaqFJ2Ggh8DZV8bwlkDnUzSnTShUs503r9tGo7Of+ahmFZI3fGyWJG U5aa5lsr0s8+nuyELHEYKPojqVP9Am8/bPDFC0Q/FPlAZ32lf/kjwEoYKm4y8A== From: Herve Codina To: Simon Horman , Sai Krishna Gajula , Herve Codina , Thomas Gleixner , Rob Herring , Krzysztof Kozlowski , Conor Dooley , "David S. Miller" , Eric Dumazet , Jakub Kicinski , Paolo Abeni , Lee Jones , Arnd Bergmann , Horatiu Vultur , UNGLinuxDriver@microchip.com, Andrew Lunn , Heiner Kallweit , Russell King , Saravana Kannan , Bjorn Helgaas , Philipp Zabel , Lars Povlsen , Steen Hegelund , Daniel Machon , Alexandre Belloni Cc: linux-kernel@vger.kernel.org, devicetree@vger.kernel.org, netdev@vger.kernel.org, linux-pci@vger.kernel.org, linux-arm-kernel@lists.infradead.org, Allan Nielsen , Steen Hegelund , Luca Ceresoli , Thomas Petazzoni , =?UTF-8?q?Cl=C3=A9ment=20L=C3=A9ger?= Subject: [PATCH v2 01/19] mfd: syscon: Add reference counting and device managed support Date: Mon, 27 May 2024 18:14:28 +0200 Message-ID: <20240527161450.326615-2-herve.codina@bootlin.com> X-Mailer: git-send-email 2.45.0 In-Reply-To: <20240527161450.326615-1-herve.codina@bootlin.com> References: <20240527161450.326615-1-herve.codina@bootlin.com> Precedence: bulk X-Mailing-List: linux-pci@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit X-GND-Sasl: herve.codina@bootlin.com From: Clément Léger Syscon releasing is not supported. Without release function, unbinding a driver that uses syscon whether explicitly or due to a module removal left the used syscon in a in-use state. For instance a syscon_node_to_regmap() call from a consumer retrieve a syscon regmap instance. Internally, syscon_node_to_regmap() can create syscon instance and add it to the existing syscon list. No API is available to release this syscon instance, remove it from the list and free it when it is not used anymore. Introduce reference counting in syscon in order to keep track of syscon usage using syscon_{get,put}() and add a device managed version of syscon_regmap_lookup_by_phandle(), to automatically release the syscon instance on the consumer removal. Signed-off-by: Clément Léger Signed-off-by: Herve Codina --- drivers/mfd/syscon.c | 145 ++++++++++++++++++++++++++++++++++--- include/linux/mfd/syscon.h | 18 +++++ 2 files changed, 154 insertions(+), 9 deletions(-) diff --git a/drivers/mfd/syscon.c b/drivers/mfd/syscon.c index 7d0e91164cba..86898831b842 100644 --- a/drivers/mfd/syscon.c +++ b/drivers/mfd/syscon.c @@ -34,6 +34,7 @@ struct syscon { struct regmap *regmap; struct reset_control *reset; struct list_head list; + struct kref refcount; }; static const struct regmap_config syscon_regmap_config = { @@ -147,6 +148,8 @@ static struct syscon *of_syscon_register(struct device_node *np, bool check_res) syscon->regmap = regmap; syscon->np = np; + of_node_get(syscon->np); + kref_init(&syscon->refcount); spin_lock(&syscon_list_slock); list_add_tail(&syscon->list, &syscon_list); @@ -168,7 +171,30 @@ static struct syscon *of_syscon_register(struct device_node *np, bool check_res) return ERR_PTR(ret); } -static struct regmap *device_node_get_regmap(struct device_node *np, +static void syscon_free(struct kref *kref) +{ + struct syscon *syscon = container_of(kref, struct syscon, refcount); + + spin_lock(&syscon_list_slock); + list_del(&syscon->list); + spin_unlock(&syscon_list_slock); + + regmap_exit(syscon->regmap); + of_node_put(syscon->np); + kfree(syscon); +} + +static void syscon_get(struct syscon *syscon) +{ + kref_get(&syscon->refcount); +} + +static void syscon_put(struct syscon *syscon) +{ + kref_put(&syscon->refcount, syscon_free); +} + +static struct syscon *device_node_get_syscon(struct device_node *np, bool check_res) { struct syscon *entry, *syscon = NULL; @@ -183,9 +209,23 @@ static struct regmap *device_node_get_regmap(struct device_node *np, spin_unlock(&syscon_list_slock); - if (!syscon) + if (!syscon) { syscon = of_syscon_register(np, check_res); + if (IS_ERR(syscon)) + return ERR_CAST(syscon); + } else { + syscon_get(syscon); + } + + return syscon; +} +static struct regmap *device_node_get_regmap(struct device_node *np, + bool check_res) +{ + struct syscon *syscon; + + syscon = device_node_get_syscon(np, check_res); if (IS_ERR(syscon)) return ERR_CAST(syscon); @@ -198,12 +238,23 @@ struct regmap *device_node_to_regmap(struct device_node *np) } EXPORT_SYMBOL_GPL(device_node_to_regmap); -struct regmap *syscon_node_to_regmap(struct device_node *np) +static struct syscon *syscon_node_to_syscon(struct device_node *np) { if (!of_device_is_compatible(np, "syscon")) return ERR_PTR(-EINVAL); - return device_node_get_regmap(np, true); + return device_node_get_syscon(np, true); +} + +struct regmap *syscon_node_to_regmap(struct device_node *np) +{ + struct syscon *syscon; + + syscon = syscon_node_to_syscon(np); + if (IS_ERR(syscon)) + return ERR_CAST(syscon); + + return syscon->regmap; } EXPORT_SYMBOL_GPL(syscon_node_to_regmap); @@ -223,11 +274,11 @@ struct regmap *syscon_regmap_lookup_by_compatible(const char *s) } EXPORT_SYMBOL_GPL(syscon_regmap_lookup_by_compatible); -struct regmap *syscon_regmap_lookup_by_phandle(struct device_node *np, - const char *property) +static struct syscon *syscon_lookup_by_phandle(struct device_node *np, + const char *property) { struct device_node *syscon_np; - struct regmap *regmap; + struct syscon *syscon; if (property) syscon_np = of_parse_phandle(np, property, 0); @@ -237,12 +288,24 @@ struct regmap *syscon_regmap_lookup_by_phandle(struct device_node *np, if (!syscon_np) return ERR_PTR(-ENODEV); - regmap = syscon_node_to_regmap(syscon_np); + syscon = syscon_node_to_syscon(syscon_np); if (property) of_node_put(syscon_np); - return regmap; + return syscon; +} + +struct regmap *syscon_regmap_lookup_by_phandle(struct device_node *np, + const char *property) +{ + struct syscon *syscon; + + syscon = syscon_lookup_by_phandle(np, property); + if (IS_ERR(syscon)) + return ERR_CAST(syscon); + + return syscon->regmap; } EXPORT_SYMBOL_GPL(syscon_regmap_lookup_by_phandle); @@ -293,6 +356,70 @@ struct regmap *syscon_regmap_lookup_by_phandle_optional(struct device_node *np, } EXPORT_SYMBOL_GPL(syscon_regmap_lookup_by_phandle_optional); +static struct syscon *syscon_from_regmap(struct regmap *regmap) +{ + struct syscon *entry, *syscon = NULL; + + spin_lock(&syscon_list_slock); + + list_for_each_entry(entry, &syscon_list, list) + if (entry->regmap == regmap) { + syscon = entry; + break; + } + + spin_unlock(&syscon_list_slock); + + return syscon; +} + +void syscon_put_regmap(struct regmap *regmap) +{ + struct syscon *syscon; + + syscon = syscon_from_regmap(regmap); + if (!syscon) + return; + + syscon_put(syscon); +} +EXPORT_SYMBOL_GPL(syscon_put_regmap); + +static void devm_syscon_release(struct device *dev, void *res) +{ + syscon_put(*(struct syscon **)res); +} + +static struct regmap *__devm_syscon_get(struct device *dev, + struct syscon *syscon) +{ + struct syscon **ptr; + + if (IS_ERR(syscon)) + return ERR_CAST(syscon); + + ptr = devres_alloc(devm_syscon_release, sizeof(struct syscon *), GFP_KERNEL); + if (!ptr) { + syscon_put(syscon); + return ERR_PTR(-ENOMEM); + } + + *ptr = syscon; + devres_add(dev, ptr); + + return syscon->regmap; +} + +struct regmap *devm_syscon_regmap_lookup_by_phandle(struct device *dev, + struct device_node *np, + const char *property) +{ + struct syscon *syscon = syscon_lookup_by_phandle(np, property); + + return __devm_syscon_get(dev, syscon); +} +EXPORT_SYMBOL_GPL(devm_syscon_regmap_lookup_by_phandle); + static int syscon_probe(struct platform_device *pdev) { struct device *dev = &pdev->dev; diff --git a/include/linux/mfd/syscon.h b/include/linux/mfd/syscon.h index c315903f6dab..f742d865a37a 100644 --- a/include/linux/mfd/syscon.h +++ b/include/linux/mfd/syscon.h @@ -15,6 +15,7 @@ #include struct device_node; +struct device; #ifdef CONFIG_MFD_SYSCON struct regmap *device_node_to_regmap(struct device_node *np); @@ -28,6 +29,11 @@ struct regmap *syscon_regmap_lookup_by_phandle_args(struct device_node *np, unsigned int *out_args); struct regmap *syscon_regmap_lookup_by_phandle_optional(struct device_node *np, const char *property); +void syscon_put_regmap(struct regmap *regmap); + +struct regmap *devm_syscon_regmap_lookup_by_phandle(struct device *dev, + struct device_node *np, + const char *property); #else static inline struct regmap *device_node_to_regmap(struct device_node *np) { @@ -67,6 +73,18 @@ static inline struct regmap *syscon_regmap_lookup_by_phandle_optional( return NULL; } +static inline void syscon_put_regmap(struct regmap *regmap) +{ +} + +static inline +struct regmap *devm_syscon_regmap_lookup_by_phandle(struct device *dev, + struct device_node *np, + const char *property) +{ + return NULL; +} + #endif #endif /* __LINUX_MFD_SYSCON_H__ */ -- 2.45.0 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 CD355C25B74 for ; Mon, 27 May 2024 16:15:17 +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:List-Subscribe:List-Help:List-Post: List-Archive:List-Unsubscribe:List-Id:MIME-Version:References:In-Reply-To: Message-ID:Date:Subject:Cc:To:From:Reply-To:Content-ID:Content-Description: Resent-Date:Resent-From:Resent-Sender:Resent-To:Resent-Cc:Resent-Message-ID: List-Owner; bh=8Hql+etGSPdSQ3Ymb/cs4va0nSAyLw/VCzUtHqpF6WQ=; b=CHfQL/fgj2+J17 MRLVWgRVwyTdEpG0Z3m4h19f55e8wl58fHaAfMZsNGjWm+/MbXhVpNGLXHD+JRq7rSyoIs288D1DP XJhO8GvPiDz6WRoCVCr2+hqbkfytr9QG6Lh6PiV281AH0A5l9VNYcBa1ORZBsFE1ZUdX9WfnKghrz H8yDsIDX+Px+bcYQsQyWOfdTw382ZkhjkhQjkzkFdBdq/rIEchFm7zLSA+6zHbalbOaysOcbendrZ 1bcOMhcqpC24ldobyhhhTSL92hiZoufbAAAK8uzLBMM96GujUBrfySieJdvy2rCu0dBzGfswAgFiF hp1A7txwBJbJHbk6a9Dw==; Received: from localhost ([::1] helo=bombadil.infradead.org) by bombadil.infradead.org with esmtp (Exim 4.97.1 #2 (Red Hat Linux)) id 1sBd06-0000000FmTy-3P8M; Mon, 27 May 2024 16:15:06 +0000 Received: from relay9-d.mail.gandi.net ([2001:4b98:dc4:8::229]) by bombadil.infradead.org with esmtps (Exim 4.97.1 #2 (Red Hat Linux)) id 1sBd03-0000000FmQs-0Zm2 for linux-arm-kernel@lists.infradead.org; Mon, 27 May 2024 16:15:04 +0000 Received: by mail.gandi.net (Postfix) with ESMTPA id 6E42AFF811; Mon, 27 May 2024 16:14:58 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=bootlin.com; s=gm1; t=1716826500; h=from:from:reply-to:subject:subject:date:date:message-id:message-id: to:to:cc:cc:mime-version:mime-version:content-type:content-type: content-transfer-encoding:content-transfer-encoding: in-reply-to:in-reply-to:references:references; bh=W9+p1hma003opriOOEox9fT6iYMjtITIcW1ZIQ2QLNo=; b=UbbkYHxYIA3ApPt5oZI7rO4HRwWoAo+RNwHf495UokGST04QM/XPmwZtNfGcvXqNkTLLfv zPUvOe+3SPZsP9KT2IJxAesVe4FI9LV4C2BZTsojIVpNNUeFoesg2zWL8OJEA8+nRMAOHN K+llDN/wjyKrld3B3chDtl9+p+esUWB+dB8aE9FtPOBBFiQg0um64VbuBdlxOWQtqvk3OM W0JAOMp5UrAlcivoZaqFJ2Ggh8DZV8bwlkDnUzSnTShUs503r9tGo7Of+ahmFZI3fGyWJG U5aa5lsr0s8+nuyELHEYKPojqVP9Am8/bPDFC0Q/FPlAZ32lf/kjwEoYKm4y8A== From: Herve Codina To: Simon Horman , Sai Krishna Gajula , Herve Codina , Thomas Gleixner , Rob Herring , Krzysztof Kozlowski , Conor Dooley , "David S. Miller" , Eric Dumazet , Jakub Kicinski , Paolo Abeni , Lee Jones , Arnd Bergmann , Horatiu Vultur , UNGLinuxDriver@microchip.com, Andrew Lunn , Heiner Kallweit , Russell King , Saravana Kannan , Bjorn Helgaas , Philipp Zabel , Lars Povlsen , Steen Hegelund , Daniel Machon , Alexandre Belloni Cc: linux-kernel@vger.kernel.org, devicetree@vger.kernel.org, netdev@vger.kernel.org, linux-pci@vger.kernel.org, linux-arm-kernel@lists.infradead.org, Allan Nielsen , Steen Hegelund , Luca Ceresoli , Thomas Petazzoni , =?UTF-8?q?Cl=C3=A9ment=20L=C3=A9ger?= Subject: [PATCH v2 01/19] mfd: syscon: Add reference counting and device managed support Date: Mon, 27 May 2024 18:14:28 +0200 Message-ID: <20240527161450.326615-2-herve.codina@bootlin.com> X-Mailer: git-send-email 2.45.0 In-Reply-To: <20240527161450.326615-1-herve.codina@bootlin.com> References: <20240527161450.326615-1-herve.codina@bootlin.com> MIME-Version: 1.0 X-GND-Sasl: herve.codina@bootlin.com X-CRM114-Version: 20100106-BlameMichelson ( TRE 0.8.0 (BSD) ) MR-646709E3 X-CRM114-CacheID: sfid-20240527_091503_552459_FB7A63F0 X-CRM114-Status: GOOD ( 23.77 ) X-BeenThere: linux-arm-kernel@lists.infradead.org X-Mailman-Version: 2.1.34 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Sender: "linux-arm-kernel" Errors-To: linux-arm-kernel-bounces+linux-arm-kernel=archiver.kernel.org@lists.infradead.org RnJvbTogQ2zDqW1lbnQgTMOpZ2VyIDxjbGVtZW50LmxlZ2VyQGJvb3RsaW4uY29tPgoKU3lzY29u IHJlbGVhc2luZyBpcyBub3Qgc3VwcG9ydGVkLgpXaXRob3V0IHJlbGVhc2UgZnVuY3Rpb24sIHVu YmluZGluZyBhIGRyaXZlciB0aGF0IHVzZXMgc3lzY29uIHdoZXRoZXIKZXhwbGljaXRseSBvciBk dWUgdG8gYSBtb2R1bGUgcmVtb3ZhbCBsZWZ0IHRoZSB1c2VkIHN5c2NvbiBpbiBhIGluLXVzZQpz dGF0ZS4KCkZvciBpbnN0YW5jZSBhIHN5c2Nvbl9ub2RlX3RvX3JlZ21hcCgpIGNhbGwgZnJvbSBh IGNvbnN1bWVyIHJldHJpZXZlIGEKc3lzY29uIHJlZ21hcCBpbnN0YW5jZS4gSW50ZXJuYWxseSwg c3lzY29uX25vZGVfdG9fcmVnbWFwKCkgY2FuIGNyZWF0ZQpzeXNjb24gaW5zdGFuY2UgYW5kIGFk ZCBpdCB0byB0aGUgZXhpc3Rpbmcgc3lzY29uIGxpc3QuIE5vIEFQSSBpcwphdmFpbGFibGUgdG8g cmVsZWFzZSB0aGlzIHN5c2NvbiBpbnN0YW5jZSwgcmVtb3ZlIGl0IGZyb20gdGhlIGxpc3QgYW5k CmZyZWUgaXQgd2hlbiBpdCBpcyBub3QgdXNlZCBhbnltb3JlLgoKSW50cm9kdWNlIHJlZmVyZW5j ZSBjb3VudGluZyBpbiBzeXNjb24gaW4gb3JkZXIgdG8ga2VlcCB0cmFjayBvZiBzeXNjb24KdXNh Z2UgdXNpbmcgc3lzY29uX3tnZXQscHV0fSgpIGFuZCBhZGQgYSBkZXZpY2UgbWFuYWdlZCB2ZXJz aW9uIG9mCnN5c2Nvbl9yZWdtYXBfbG9va3VwX2J5X3BoYW5kbGUoKSwgdG8gYXV0b21hdGljYWxs eSByZWxlYXNlIHRoZSBzeXNjb24KaW5zdGFuY2Ugb24gdGhlIGNvbnN1bWVyIHJlbW92YWwuCgpT aWduZWQtb2ZmLWJ5OiBDbMOpbWVudCBMw6lnZXIgPGNsZW1lbnQubGVnZXJAYm9vdGxpbi5jb20+ ClNpZ25lZC1vZmYtYnk6IEhlcnZlIENvZGluYSA8aGVydmUuY29kaW5hQGJvb3RsaW4uY29tPgot LS0KIGRyaXZlcnMvbWZkL3N5c2Nvbi5jICAgICAgIHwgMTQ1ICsrKysrKysrKysrKysrKysrKysr KysrKysrKysrKysrKystLS0KIGluY2x1ZGUvbGludXgvbWZkL3N5c2Nvbi5oIHwgIDE4ICsrKysr CiAyIGZpbGVzIGNoYW5nZWQsIDE1NCBpbnNlcnRpb25zKCspLCA5IGRlbGV0aW9ucygtKQoKZGlm ZiAtLWdpdCBhL2RyaXZlcnMvbWZkL3N5c2Nvbi5jIGIvZHJpdmVycy9tZmQvc3lzY29uLmMKaW5k ZXggN2QwZTkxMTY0Y2JhLi44Njg5ODgzMWI4NDIgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbWZkL3N5 c2Nvbi5jCisrKyBiL2RyaXZlcnMvbWZkL3N5c2Nvbi5jCkBAIC0zNCw2ICszNCw3IEBAIHN0cnVj dCBzeXNjb24gewogCXN0cnVjdCByZWdtYXAgKnJlZ21hcDsKIAlzdHJ1Y3QgcmVzZXRfY29udHJv bCAqcmVzZXQ7CiAJc3RydWN0IGxpc3RfaGVhZCBsaXN0OworCXN0cnVjdCBrcmVmIHJlZmNvdW50 OwogfTsKIAogc3RhdGljIGNvbnN0IHN0cnVjdCByZWdtYXBfY29uZmlnIHN5c2Nvbl9yZWdtYXBf Y29uZmlnID0gewpAQCAtMTQ3LDYgKzE0OCw4IEBAIHN0YXRpYyBzdHJ1Y3Qgc3lzY29uICpvZl9z eXNjb25fcmVnaXN0ZXIoc3RydWN0IGRldmljZV9ub2RlICpucCwgYm9vbCBjaGVja19yZXMpCiAK IAlzeXNjb24tPnJlZ21hcCA9IHJlZ21hcDsKIAlzeXNjb24tPm5wID0gbnA7CisJb2Zfbm9kZV9n ZXQoc3lzY29uLT5ucCk7CisJa3JlZl9pbml0KCZzeXNjb24tPnJlZmNvdW50KTsKIAogCXNwaW5f bG9jaygmc3lzY29uX2xpc3Rfc2xvY2spOwogCWxpc3RfYWRkX3RhaWwoJnN5c2Nvbi0+bGlzdCwg JnN5c2Nvbl9saXN0KTsKQEAgLTE2OCw3ICsxNzEsMzAgQEAgc3RhdGljIHN0cnVjdCBzeXNjb24g Km9mX3N5c2Nvbl9yZWdpc3RlcihzdHJ1Y3QgZGV2aWNlX25vZGUgKm5wLCBib29sIGNoZWNrX3Jl cykKIAlyZXR1cm4gRVJSX1BUUihyZXQpOwogfQogCi1zdGF0aWMgc3RydWN0IHJlZ21hcCAqZGV2 aWNlX25vZGVfZ2V0X3JlZ21hcChzdHJ1Y3QgZGV2aWNlX25vZGUgKm5wLAorc3RhdGljIHZvaWQg c3lzY29uX2ZyZWUoc3RydWN0IGtyZWYgKmtyZWYpCit7CisJc3RydWN0IHN5c2NvbiAqc3lzY29u ID0gY29udGFpbmVyX29mKGtyZWYsIHN0cnVjdCBzeXNjb24sIHJlZmNvdW50KTsKKworCXNwaW5f bG9jaygmc3lzY29uX2xpc3Rfc2xvY2spOworCWxpc3RfZGVsKCZzeXNjb24tPmxpc3QpOworCXNw aW5fdW5sb2NrKCZzeXNjb25fbGlzdF9zbG9jayk7CisKKwlyZWdtYXBfZXhpdChzeXNjb24tPnJl Z21hcCk7CisJb2Zfbm9kZV9wdXQoc3lzY29uLT5ucCk7CisJa2ZyZWUoc3lzY29uKTsKK30KKwor c3RhdGljIHZvaWQgc3lzY29uX2dldChzdHJ1Y3Qgc3lzY29uICpzeXNjb24pCit7CisJa3JlZl9n ZXQoJnN5c2Nvbi0+cmVmY291bnQpOworfQorCitzdGF0aWMgdm9pZCBzeXNjb25fcHV0KHN0cnVj dCBzeXNjb24gKnN5c2NvbikKK3sKKwlrcmVmX3B1dCgmc3lzY29uLT5yZWZjb3VudCwgc3lzY29u X2ZyZWUpOworfQorCitzdGF0aWMgc3RydWN0IHN5c2NvbiAqZGV2aWNlX25vZGVfZ2V0X3N5c2Nv bihzdHJ1Y3QgZGV2aWNlX25vZGUgKm5wLAogCQkJCQkgICAgIGJvb2wgY2hlY2tfcmVzKQogewog CXN0cnVjdCBzeXNjb24gKmVudHJ5LCAqc3lzY29uID0gTlVMTDsKQEAgLTE4Myw5ICsyMDksMjMg QEAgc3RhdGljIHN0cnVjdCByZWdtYXAgKmRldmljZV9ub2RlX2dldF9yZWdtYXAoc3RydWN0IGRl dmljZV9ub2RlICpucCwKIAogCXNwaW5fdW5sb2NrKCZzeXNjb25fbGlzdF9zbG9jayk7CiAKLQlp ZiAoIXN5c2NvbikKKwlpZiAoIXN5c2NvbikgewogCQlzeXNjb24gPSBvZl9zeXNjb25fcmVnaXN0 ZXIobnAsIGNoZWNrX3Jlcyk7CisJCWlmIChJU19FUlIoc3lzY29uKSkKKwkJCXJldHVybiBFUlJf Q0FTVChzeXNjb24pOworCX0gZWxzZSB7CisJCXN5c2Nvbl9nZXQoc3lzY29uKTsKKwl9CisKKwly ZXR1cm4gc3lzY29uOworfQogCitzdGF0aWMgc3RydWN0IHJlZ21hcCAqZGV2aWNlX25vZGVfZ2V0 X3JlZ21hcChzdHJ1Y3QgZGV2aWNlX25vZGUgKm5wLAorCQkJCQkgICAgIGJvb2wgY2hlY2tfcmVz KQoreworCXN0cnVjdCBzeXNjb24gKnN5c2NvbjsKKworCXN5c2NvbiA9IGRldmljZV9ub2RlX2dl dF9zeXNjb24obnAsIGNoZWNrX3Jlcyk7CiAJaWYgKElTX0VSUihzeXNjb24pKQogCQlyZXR1cm4g RVJSX0NBU1Qoc3lzY29uKTsKIApAQCAtMTk4LDEyICsyMzgsMjMgQEAgc3RydWN0IHJlZ21hcCAq ZGV2aWNlX25vZGVfdG9fcmVnbWFwKHN0cnVjdCBkZXZpY2Vfbm9kZSAqbnApCiB9CiBFWFBPUlRf U1lNQk9MX0dQTChkZXZpY2Vfbm9kZV90b19yZWdtYXApOwogCi1zdHJ1Y3QgcmVnbWFwICpzeXNj b25fbm9kZV90b19yZWdtYXAoc3RydWN0IGRldmljZV9ub2RlICpucCkKK3N0YXRpYyBzdHJ1Y3Qg c3lzY29uICpzeXNjb25fbm9kZV90b19zeXNjb24oc3RydWN0IGRldmljZV9ub2RlICpucCkKIHsK IAlpZiAoIW9mX2RldmljZV9pc19jb21wYXRpYmxlKG5wLCAic3lzY29uIikpCiAJCXJldHVybiBF UlJfUFRSKC1FSU5WQUwpOwogCi0JcmV0dXJuIGRldmljZV9ub2RlX2dldF9yZWdtYXAobnAsIHRy dWUpOworCXJldHVybiBkZXZpY2Vfbm9kZV9nZXRfc3lzY29uKG5wLCB0cnVlKTsKK30KKworc3Ry dWN0IHJlZ21hcCAqc3lzY29uX25vZGVfdG9fcmVnbWFwKHN0cnVjdCBkZXZpY2Vfbm9kZSAqbnAp Cit7CisJc3RydWN0IHN5c2NvbiAqc3lzY29uOworCisJc3lzY29uID0gc3lzY29uX25vZGVfdG9f c3lzY29uKG5wKTsKKwlpZiAoSVNfRVJSKHN5c2NvbikpCisJCXJldHVybiBFUlJfQ0FTVChzeXNj b24pOworCisJcmV0dXJuIHN5c2Nvbi0+cmVnbWFwOwogfQogRVhQT1JUX1NZTUJPTF9HUEwoc3lz Y29uX25vZGVfdG9fcmVnbWFwKTsKIApAQCAtMjIzLDExICsyNzQsMTEgQEAgc3RydWN0IHJlZ21h cCAqc3lzY29uX3JlZ21hcF9sb29rdXBfYnlfY29tcGF0aWJsZShjb25zdCBjaGFyICpzKQogfQog RVhQT1JUX1NZTUJPTF9HUEwoc3lzY29uX3JlZ21hcF9sb29rdXBfYnlfY29tcGF0aWJsZSk7CiAK LXN0cnVjdCByZWdtYXAgKnN5c2Nvbl9yZWdtYXBfbG9va3VwX2J5X3BoYW5kbGUoc3RydWN0IGRl dmljZV9ub2RlICpucCwKLQkJCQkJY29uc3QgY2hhciAqcHJvcGVydHkpCitzdGF0aWMgc3RydWN0 IHN5c2NvbiAqc3lzY29uX2xvb2t1cF9ieV9waGFuZGxlKHN0cnVjdCBkZXZpY2Vfbm9kZSAqbnAs CisJCQkJCSAgICAgICBjb25zdCBjaGFyICpwcm9wZXJ0eSkKIHsKIAlzdHJ1Y3QgZGV2aWNlX25v ZGUgKnN5c2Nvbl9ucDsKLQlzdHJ1Y3QgcmVnbWFwICpyZWdtYXA7CisJc3RydWN0IHN5c2NvbiAq c3lzY29uOwogCiAJaWYgKHByb3BlcnR5KQogCQlzeXNjb25fbnAgPSBvZl9wYXJzZV9waGFuZGxl KG5wLCBwcm9wZXJ0eSwgMCk7CkBAIC0yMzcsMTIgKzI4OCwyNCBAQCBzdHJ1Y3QgcmVnbWFwICpz eXNjb25fcmVnbWFwX2xvb2t1cF9ieV9waGFuZGxlKHN0cnVjdCBkZXZpY2Vfbm9kZSAqbnAsCiAJ aWYgKCFzeXNjb25fbnApCiAJCXJldHVybiBFUlJfUFRSKC1FTk9ERVYpOwogCi0JcmVnbWFwID0g c3lzY29uX25vZGVfdG9fcmVnbWFwKHN5c2Nvbl9ucCk7CisJc3lzY29uID0gc3lzY29uX25vZGVf dG9fc3lzY29uKHN5c2Nvbl9ucCk7CiAKIAlpZiAocHJvcGVydHkpCiAJCW9mX25vZGVfcHV0KHN5 c2Nvbl9ucCk7CiAKLQlyZXR1cm4gcmVnbWFwOworCXJldHVybiBzeXNjb247Cit9CisKK3N0cnVj dCByZWdtYXAgKnN5c2Nvbl9yZWdtYXBfbG9va3VwX2J5X3BoYW5kbGUoc3RydWN0IGRldmljZV9u b2RlICpucCwKKwkJCQkJICAgICAgIGNvbnN0IGNoYXIgKnByb3BlcnR5KQoreworCXN0cnVjdCBz eXNjb24gKnN5c2NvbjsKKworCXN5c2NvbiA9IHN5c2Nvbl9sb29rdXBfYnlfcGhhbmRsZShucCwg cHJvcGVydHkpOworCWlmIChJU19FUlIoc3lzY29uKSkKKwkJcmV0dXJuIEVSUl9DQVNUKHN5c2Nv bik7CisKKwlyZXR1cm4gc3lzY29uLT5yZWdtYXA7CiB9CiBFWFBPUlRfU1lNQk9MX0dQTChzeXNj b25fcmVnbWFwX2xvb2t1cF9ieV9waGFuZGxlKTsKIApAQCAtMjkzLDYgKzM1Niw3MCBAQCBzdHJ1 Y3QgcmVnbWFwICpzeXNjb25fcmVnbWFwX2xvb2t1cF9ieV9waGFuZGxlX29wdGlvbmFsKHN0cnVj dCBkZXZpY2Vfbm9kZSAqbnAsCiB9CiBFWFBPUlRfU1lNQk9MX0dQTChzeXNjb25fcmVnbWFwX2xv b2t1cF9ieV9waGFuZGxlX29wdGlvbmFsKTsKIAorc3RhdGljIHN0cnVjdCBzeXNjb24gKnN5c2Nv bl9mcm9tX3JlZ21hcChzdHJ1Y3QgcmVnbWFwICpyZWdtYXApCit7CisJc3RydWN0IHN5c2NvbiAq ZW50cnksICpzeXNjb24gPSBOVUxMOworCisJc3Bpbl9sb2NrKCZzeXNjb25fbGlzdF9zbG9jayk7 CisKKwlsaXN0X2Zvcl9lYWNoX2VudHJ5KGVudHJ5LCAmc3lzY29uX2xpc3QsIGxpc3QpCisJCWlm IChlbnRyeS0+cmVnbWFwID09IHJlZ21hcCkgeworCQkJc3lzY29uID0gZW50cnk7CisJCQlicmVh azsKKwkJfQorCisJc3Bpbl91bmxvY2soJnN5c2Nvbl9saXN0X3Nsb2NrKTsKKworCXJldHVybiBz eXNjb247Cit9CisKK3ZvaWQgc3lzY29uX3B1dF9yZWdtYXAoc3RydWN0IHJlZ21hcCAqcmVnbWFw KQoreworCXN0cnVjdCBzeXNjb24gKnN5c2NvbjsKKworCXN5c2NvbiA9IHN5c2Nvbl9mcm9tX3Jl Z21hcChyZWdtYXApOworCWlmICghc3lzY29uKQorCQlyZXR1cm47CisKKwlzeXNjb25fcHV0KHN5 c2Nvbik7Cit9CitFWFBPUlRfU1lNQk9MX0dQTChzeXNjb25fcHV0X3JlZ21hcCk7CisKK3N0YXRp YyB2b2lkIGRldm1fc3lzY29uX3JlbGVhc2Uoc3RydWN0IGRldmljZSAqZGV2LCB2b2lkICpyZXMp Cit7CisJc3lzY29uX3B1dCgqKHN0cnVjdCBzeXNjb24gKiopcmVzKTsKK30KKworc3RhdGljIHN0 cnVjdCByZWdtYXAgKl9fZGV2bV9zeXNjb25fZ2V0KHN0cnVjdCBkZXZpY2UgKmRldiwKKwkJCQkJ c3RydWN0IHN5c2NvbiAqc3lzY29uKQoreworCXN0cnVjdCBzeXNjb24gKipwdHI7CisKKwlpZiAo SVNfRVJSKHN5c2NvbikpCisJCXJldHVybiBFUlJfQ0FTVChzeXNjb24pOworCisJcHRyID0gZGV2 cmVzX2FsbG9jKGRldm1fc3lzY29uX3JlbGVhc2UsIHNpemVvZihzdHJ1Y3Qgc3lzY29uICopLCBH RlBfS0VSTkVMKTsKKwlpZiAoIXB0cikgeworCQlzeXNjb25fcHV0KHN5c2Nvbik7CisJCXJldHVy biBFUlJfUFRSKC1FTk9NRU0pOworCX0KKworCSpwdHIgPSBzeXNjb247CisJZGV2cmVzX2FkZChk ZXYsIHB0cik7CisKKwlyZXR1cm4gc3lzY29uLT5yZWdtYXA7Cit9CisKK3N0cnVjdCByZWdtYXAg KmRldm1fc3lzY29uX3JlZ21hcF9sb29rdXBfYnlfcGhhbmRsZShzdHJ1Y3QgZGV2aWNlICpkZXYs CisJCQkJCQkgICAgc3RydWN0IGRldmljZV9ub2RlICpucCwKKwkJCQkJCSAgICBjb25zdCBjaGFy ICpwcm9wZXJ0eSkKK3sKKwlzdHJ1Y3Qgc3lzY29uICpzeXNjb24gPSBzeXNjb25fbG9va3VwX2J5 X3BoYW5kbGUobnAsIHByb3BlcnR5KTsKKworCXJldHVybiBfX2Rldm1fc3lzY29uX2dldChkZXYs IHN5c2Nvbik7Cit9CitFWFBPUlRfU1lNQk9MX0dQTChkZXZtX3N5c2Nvbl9yZWdtYXBfbG9va3Vw X2J5X3BoYW5kbGUpOworCiBzdGF0aWMgaW50IHN5c2Nvbl9wcm9iZShzdHJ1Y3QgcGxhdGZvcm1f ZGV2aWNlICpwZGV2KQogewogCXN0cnVjdCBkZXZpY2UgKmRldiA9ICZwZGV2LT5kZXY7CmRpZmYg LS1naXQgYS9pbmNsdWRlL2xpbnV4L21mZC9zeXNjb24uaCBiL2luY2x1ZGUvbGludXgvbWZkL3N5 c2Nvbi5oCmluZGV4IGMzMTU5MDNmNmRhYi4uZjc0MmQ4NjVhMzdhIDEwMDY0NAotLS0gYS9pbmNs dWRlL2xpbnV4L21mZC9zeXNjb24uaAorKysgYi9pbmNsdWRlL2xpbnV4L21mZC9zeXNjb24uaApA QCAtMTUsNiArMTUsNyBAQAogI2luY2x1ZGUgPGxpbnV4L2Vycm5vLmg+CiAKIHN0cnVjdCBkZXZp Y2Vfbm9kZTsKK3N0cnVjdCBkZXZpY2U7CiAKICNpZmRlZiBDT05GSUdfTUZEX1NZU0NPTgogc3Ry dWN0IHJlZ21hcCAqZGV2aWNlX25vZGVfdG9fcmVnbWFwKHN0cnVjdCBkZXZpY2Vfbm9kZSAqbnAp OwpAQCAtMjgsNiArMjksMTEgQEAgc3RydWN0IHJlZ21hcCAqc3lzY29uX3JlZ21hcF9sb29rdXBf YnlfcGhhbmRsZV9hcmdzKHN0cnVjdCBkZXZpY2Vfbm9kZSAqbnAsCiAJCQkJCQkgICAgdW5zaWdu ZWQgaW50ICpvdXRfYXJncyk7CiBzdHJ1Y3QgcmVnbWFwICpzeXNjb25fcmVnbWFwX2xvb2t1cF9i eV9waGFuZGxlX29wdGlvbmFsKHN0cnVjdCBkZXZpY2Vfbm9kZSAqbnAsCiAJCQkJCQkJY29uc3Qg Y2hhciAqcHJvcGVydHkpOwordm9pZCBzeXNjb25fcHV0X3JlZ21hcChzdHJ1Y3QgcmVnbWFwICpy ZWdtYXApOworCitzdHJ1Y3QgcmVnbWFwICpkZXZtX3N5c2Nvbl9yZWdtYXBfbG9va3VwX2J5X3Bo YW5kbGUoc3RydWN0IGRldmljZSAqZGV2LAorCQkJCQkJICAgIHN0cnVjdCBkZXZpY2Vfbm9kZSAq bnAsCisJCQkJCQkgICAgY29uc3QgY2hhciAqcHJvcGVydHkpOwogI2Vsc2UKIHN0YXRpYyBpbmxp bmUgc3RydWN0IHJlZ21hcCAqZGV2aWNlX25vZGVfdG9fcmVnbWFwKHN0cnVjdCBkZXZpY2Vfbm9k ZSAqbnApCiB7CkBAIC02Nyw2ICs3MywxOCBAQCBzdGF0aWMgaW5saW5lIHN0cnVjdCByZWdtYXAg KnN5c2Nvbl9yZWdtYXBfbG9va3VwX2J5X3BoYW5kbGVfb3B0aW9uYWwoCiAJcmV0dXJuIE5VTEw7 CiB9CiAKK3N0YXRpYyBpbmxpbmUgdm9pZCBzeXNjb25fcHV0X3JlZ21hcChzdHJ1Y3QgcmVnbWFw ICpyZWdtYXApCit7Cit9CisKK3N0YXRpYyBpbmxpbmUKK3N0cnVjdCByZWdtYXAgKmRldm1fc3lz Y29uX3JlZ21hcF9sb29rdXBfYnlfcGhhbmRsZShzdHJ1Y3QgZGV2aWNlICpkZXYsCisJCQkJCQkg ICAgc3RydWN0IGRldmljZV9ub2RlICpucCwKKwkJCQkJCSAgICBjb25zdCBjaGFyICpwcm9wZXJ0 eSkKK3sKKwlyZXR1cm4gTlVMTDsKK30KKwogI2VuZGlmCiAKICNlbmRpZiAvKiBfX0xJTlVYX01G RF9TWVNDT05fSF9fICovCi0tIAoyLjQ1LjAKCgpfX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fXwpsaW51eC1hcm0ta2VybmVsIG1haWxpbmcgbGlzdApsaW51eC1h cm0ta2VybmVsQGxpc3RzLmluZnJhZGVhZC5vcmcKaHR0cDovL2xpc3RzLmluZnJhZGVhZC5vcmcv bWFpbG1hbi9saXN0aW5mby9saW51eC1hcm0ta2VybmVsCg==