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 mail.kernel.org (mail.kernel.org [198.145.29.99]) by smtp.lore.kernel.org (Postfix) with ESMTP id A5D06C43217 for ; Tue, 9 Nov 2021 10:02:30 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by mail.kernel.org (Postfix) with ESMTP id 8DB5E61215 for ; Tue, 9 Nov 2021 10:02:30 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S245184AbhKIKFP (ORCPT ); Tue, 9 Nov 2021 05:05:15 -0500 Received: from mail.kernel.org ([198.145.29.99]:33014 "EHLO mail.kernel.org" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S245179AbhKIKFO (ORCPT ); Tue, 9 Nov 2021 05:05:14 -0500 Received: by mail.kernel.org (Postfix) with ESMTPSA id EF7A461130; Tue, 9 Nov 2021 10:02:26 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1636452148; bh=pwmejsZnkl62Kuuzf1JnZ72Ygl7f6FNKemOPbCL9Ahs=; h=From:To:Cc:Subject:Date:In-Reply-To:References:From; b=DOMVkIn9MFZq7++K4ZjBt7bq2AUqKtmwdJj4Q20SEmWa0ig9VlZpwR1vx1fQcmmZg xLA872cnuEJQzF/ibG7D7zU3JrNHNTVclUkENwjZGTt7TGEf0TPFBk/miywYld4XoJ /0OChCZ6lWPMYDZ4c/KEFd8iKbtST5k9o6ibpLMpX64X18f4tpg4Ge+qxmdDqyxYvD olFMlLWYBHBtUxJMHVZGCPMAoaDDm7sNFYlk18s0/5yKApWrdLP5qFAEtLQ9DODi1L 1XgTZX+0SV5+p1haraxb4g3HDqqY3E2e54+BwrELhcJrfZ436Ad0pHUCd0srOUEhix Wu9Tvzt+oZywA== From: Arnd Bergmann To: linux-gpio@vger.kernel.org Cc: Arnd Bergmann , Linus Walleij , Bartosz Golaszewski , Andy Shevchenko , Geert Uytterhoeven , linux-arm-kernel@lists.infradead.org, linux-kernel@vger.kernel.org Subject: [PATCH v2 6/8] gpiolib: remove legacy gpio_export Date: Tue, 9 Nov 2021 11:02:05 +0100 Message-Id: <20211109100207.2474024-7-arnd@kernel.org> X-Mailer: git-send-email 2.29.2 In-Reply-To: <20211109100207.2474024-1-arnd@kernel.org> References: <20211109100207.2474024-1-arnd@kernel.org> MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Precedence: bulk List-ID: X-Mailing-List: linux-gpio@vger.kernel.org From: Arnd Bergmann There are only a handful of users of gpio_export() and related functions. As these are just wrappers around the modern gpiod_export() helper, remove the wrappers and open-code the gpio_to_desc in all callers to shrink the legacy API. Signed-off-by: Arnd Bergmann --- Documentation/admin-guide/gpio/sysfs.rst | 2 +- Documentation/driver-api/gpio/legacy.rst | 30 ----------------- Documentation/translations/zh_CN/gpio.txt | 26 -------------- Documentation/translations/zh_TW/gpio.txt | 27 --------------- arch/arm/mach-davinci/board-dm646x-evm.c | 28 +++++++++------- arch/arm/mach-omap2/pdata-quirks.c | 9 ++--- arch/sh/boards/mach-ap325rxa/setup.c | 7 ++-- drivers/gpio/gpiolib-sysfs.c | 4 +-- drivers/media/i2c/noon010pc30.c | 5 +-- drivers/media/i2c/ov9650.c | 4 +-- drivers/media/i2c/s5k4ecgx.c | 3 +- drivers/media/pci/sta2x11/sta2x11_vip.c | 10 ++++-- drivers/mfd/dm355evm_msp.c | 3 +- drivers/net/ieee802154/ca8210.c | 3 +- include/linux/gpio.h | 41 ----------------------- 15 files changed, 45 insertions(+), 157 deletions(-) diff --git a/Documentation/admin-guide/gpio/sysfs.rst b/Documentation/admin-guide/gpio/sysfs.rst index ec09ffd983e7..35171d15f78d 100644 --- a/Documentation/admin-guide/gpio/sysfs.rst +++ b/Documentation/admin-guide/gpio/sysfs.rst @@ -145,7 +145,7 @@ requested using gpio_request():: /* export the GPIO to userspace */ int gpiod_export(struct gpio_desc *desc, bool direction_may_change); - /* reverse gpio_export() */ + /* reverse gpiod_export() */ void gpiod_unexport(struct gpio_desc *desc); /* create a sysfs link to an exported GPIO node */ diff --git a/Documentation/driver-api/gpio/legacy.rst b/Documentation/driver-api/gpio/legacy.rst index eae185f771d7..34fcb14814db 100644 --- a/Documentation/driver-api/gpio/legacy.rst +++ b/Documentation/driver-api/gpio/legacy.rst @@ -717,36 +717,6 @@ gpiochip nodes (possibly in conjunction with schematics) to determine the correct GPIO number to use for a given signal. -Exporting from Kernel code --------------------------- -Kernel code can explicitly manage exports of GPIOs which have already been -requested using gpio_request():: - - /* export the GPIO to userspace */ - int gpio_export(unsigned gpio, bool direction_may_change); - - /* reverse gpio_export() */ - void gpio_unexport(); - - /* create a sysfs link to an exported GPIO node */ - int gpio_export_link(struct device *dev, const char *name, - unsigned gpio) - -After a kernel driver requests a GPIO, it may only be made available in -the sysfs interface by gpio_export(). The driver can control whether the -signal direction may change. This helps drivers prevent userspace code -from accidentally clobbering important system state. - -This explicit exporting can help with debugging (by making some kinds -of experiments easier), or can provide an always-there interface that's -suitable for documenting as part of a board support package. - -After the GPIO has been exported, gpio_export_link() allows creating -symlinks from elsewhere in sysfs to the GPIO sysfs node. Drivers can -use this to provide the interface under their own device in sysfs with -a descriptive name. - - API Reference ============= diff --git a/Documentation/translations/zh_CN/gpio.txt b/Documentation/translations/zh_CN/gpio.txt index a23ee14fc927..e49fa88a2804 100644 --- a/Documentation/translations/zh_CN/gpio.txt +++ b/Documentation/translations/zh_CN/gpio.txt @@ -622,29 +622,3 @@ GPIO 控制器的路径类似 /sys/class/gpio/gpiochip42/ (对于从#42 GPIO 固定的,例如在扩展卡上的 GPIO会根据所使用的主板或所在堆叠架构中其他的板子而 有所不同。在这种情况下,你可能需要使用 gpiochip 节点(尽可能地结合电路图)来 确定给定信号所用的 GPIO 编号。 - - -从内核代码中导出 -------------- -内核代码可以明确地管理那些已通过 gpio_request()申请的 GPIO 的导出: - - /* 导出 GPIO 到用户空间 */ - int gpio_export(unsigned gpio, bool direction_may_change); - - /* gpio_export()的逆操作 */ - void gpio_unexport(); - - /* 创建一个 sysfs 连接到已导出的 GPIO 节点 */ - int gpio_export_link(struct device *dev, const char *name, - unsigned gpio) - -在一个内核驱动申请一个 GPIO 之后，它可以通过 gpio_export()使其在 sysfs -接口中可见。该驱动可以控制信号方向是否可修改。这有助于防止用户空间代码无意间 -破坏重要的系统状态。 - -这个明确的导出有助于(通过使某些实验更容易来)调试，也可以提供一个始终存在的接口， -与文档配合作为板级支持包的一部分。 - -在 GPIO 被导出之后，gpio_export_link()允许在 sysfs 文件系统的任何地方 -创建一个到这个 GPIO sysfs 节点的符号链接。这样驱动就可以通过一个描述性的 -名字，在 sysfs 中他们所拥有的设备下提供一个(到这个 GPIO sysfs 节点的)接口。 diff --git a/Documentation/translations/zh_TW/gpio.txt b/Documentation/translations/zh_TW/gpio.txt index e3c076dd75a5..c9bf3ddd08b3 100644 --- a/Documentation/translations/zh_TW/gpio.txt +++ b/Documentation/translations/zh_TW/gpio.txt @@ -622,30 +622,3 @@ GPIO 控制器的路徑類似 /sys/class/gpio/gpiochip42/ (對於從#42 GPIO 固定的,例如在擴展卡上的 GPIO會根據所使用的主板或所在堆疊架構中其他的板子而 有所不同。在這種情況下,你可能需要使用 gpiochip 節點(儘可能地結合電路圖)來 確定給定信號所用的 GPIO 編號。 - - -從內核代碼中導出 -------------- -內核代碼可以明確地管理那些已通過 gpio_request()申請的 GPIO 的導出: - - /* 導出 GPIO 到用戶空間 */ - int gpio_export(unsigned gpio, bool direction_may_change); - - /* gpio_export()的逆操作 */ - void gpio_unexport(); - - /* 創建一個 sysfs 連接到已導出的 GPIO 節點 */ - int gpio_export_link(struct device *dev, const char *name, - unsigned gpio) - -在一個內核驅動申請一個 GPIO 之後，它可以通過 gpio_export()使其在 sysfs -接口中可見。該驅動可以控制信號方向是否可修改。這有助於防止用戶空間代碼無意間 -破壞重要的系統狀態。 - -這個明確的導出有助於(通過使某些實驗更容易來)調試，也可以提供一個始終存在的接口， -與文檔配合作爲板級支持包的一部分。 - -在 GPIO 被導出之後，gpio_export_link()允許在 sysfs 文件系統的任何地方 -創建一個到這個 GPIO sysfs 節點的符號連結。這樣驅動就可以通過一個描述性的 -名字，在 sysfs 中他們所擁有的設備下提供一個(到這個 GPIO sysfs 節點的)接口。 - diff --git a/arch/arm/mach-davinci/board-dm646x-evm.c b/arch/arm/mach-davinci/board-dm646x-evm.c index ee91d81ebbfd..4a258e33021d 100644 --- a/arch/arm/mach-davinci/board-dm646x-evm.c +++ b/arch/arm/mach-davinci/board-dm646x-evm.c @@ -19,7 +19,7 @@ #include #include #include -#include +#include #include #include #include @@ -249,7 +249,7 @@ static int evm_led_teardown(struct i2c_client *client, int gpio, return 0; } -static int evm_sw_gpio[4] = { -EINVAL, -EINVAL, -EINVAL, -EINVAL }; +static struct gpio_desc *evm_sw_gpio[4]; static int evm_sw_setup(struct i2c_client *client, int gpio, unsigned ngpio, void *c) @@ -259,17 +259,19 @@ static int evm_sw_setup(struct i2c_client *client, int gpio, char label[10]; for (i = 0; i < 4; ++i) { + struct gpio_desc *desc = gpio_to_desc(gpio + i); + snprintf(label, 10, "user_sw%d", i); - status = gpio_request(gpio, label); + status = gpio_request(gpio + i, label); if (status) goto out_free; - evm_sw_gpio[i] = gpio++; + evm_sw_gpio[i] = desc; - status = gpio_direction_input(evm_sw_gpio[i]); + status = gpiod_direction_input(desc); if (status) goto out_free; - status = gpio_export(evm_sw_gpio[i], 0); + status = gpiod_export(desc, 0); if (status) goto out_free; } @@ -277,9 +279,9 @@ static int evm_sw_setup(struct i2c_client *client, int gpio, out_free: for (i = 0; i < 4; ++i) { - if (evm_sw_gpio[i] != -EINVAL) { - gpio_free(evm_sw_gpio[i]); - evm_sw_gpio[i] = -EINVAL; + if (evm_sw_gpio[i]) { + gpio_free(pin + i); + evm_sw_gpio[i] = NULL; } } return status; @@ -291,10 +293,10 @@ static int evm_sw_teardown(struct i2c_client *client, int gpio, int i; for (i = 0; i < 4; ++i) { - if (evm_sw_gpio[i] != -EINVAL) { - gpio_unexport(evm_sw_gpio[i]); - gpio_free(evm_sw_gpio[i]); - evm_sw_gpio[i] = -EINVAL; + if (evm_sw_gpio[i]) { + gpiod_unexport(evm_sw_gpio[i]); + gpio_free(gpio + i); + evm_sw_gpio[i] = NULL; } } return 0; diff --git a/arch/arm/mach-omap2/pdata-quirks.c b/arch/arm/mach-omap2/pdata-quirks.c index e7fd29a502a0..1fdf7fcf091e 100644 --- a/arch/arm/mach-omap2/pdata-quirks.c +++ b/arch/arm/mach-omap2/pdata-quirks.c @@ -6,6 +6,7 @@ */ #include #include +#include #include #include #include @@ -120,7 +121,7 @@ static int omap3_sbc_t3730_twl_callback(struct device *dev, if (res) return res; - gpio_export(gpio, 0); + gpiod_export(gpio_to_desc(gpio), 0); return 0; } @@ -135,7 +136,7 @@ static void __init omap3_sbc_t3x_usb_hub_init(int gpio, char *hub_name) return; } - gpio_export(gpio, 0); + gpiod_export(gpio_to_desc(gpio), 0); udelay(10); gpio_set_value(gpio, 1); @@ -212,8 +213,8 @@ static void __init omap3_sbc_t3517_wifi_init(void) return; } - gpio_export(cm_t3517_wlan_gpios[0].gpio, 0); - gpio_export(cm_t3517_wlan_gpios[1].gpio, 0); + gpiod_export(gpio_to_desc(cm_t3517_wlan_gpios[0].gpio), 0); + gpiod_export(gpio_to_desc(cm_t3517_wlan_gpios[1].gpio), 0); msleep(100); gpio_set_value(cm_t3517_wlan_gpios[1].gpio, 0); diff --git a/arch/sh/boards/mach-ap325rxa/setup.c b/arch/sh/boards/mach-ap325rxa/setup.c index c77b5f00a66a..151792162152 100644 --- a/arch/sh/boards/mach-ap325rxa/setup.c +++ b/arch/sh/boards/mach-ap325rxa/setup.c @@ -18,6 +18,7 @@ #include #include #include +#include #include #include #include @@ -411,16 +412,16 @@ static int __init ap325rxa_devices_setup(void) /* LD3 and LD4 LEDs */ gpio_request(GPIO_PTX5, NULL); /* RUN */ gpio_direction_output(GPIO_PTX5, 1); - gpio_export(GPIO_PTX5, 0); + gpiod_export(gpio_to_desc(GPIO_PTX5), 0); gpio_request(GPIO_PTX4, NULL); /* INDICATOR */ gpio_direction_output(GPIO_PTX4, 0); - gpio_export(GPIO_PTX4, 0); + gpiod_export(gpio_to_desc(GPIO_PTX4), 0); /* SW1 input */ gpio_request(GPIO_PTF7, NULL); /* MODE */ gpio_direction_input(GPIO_PTF7); - gpio_export(GPIO_PTF7, 0); + gpiod_export(gpio_to_desc(GPIO_PTF7), 0); /* LCDC */ gpio_request(GPIO_FN_LCDD15, NULL); diff --git a/drivers/gpio/gpiolib-sysfs.c b/drivers/gpio/gpiolib-sysfs.c index 4098bc7f88b7..a83fba3649c4 100644 --- a/drivers/gpio/gpiolib-sysfs.c +++ b/drivers/gpio/gpiolib-sysfs.c @@ -511,7 +511,7 @@ static ssize_t unexport_store(struct class *class, goto done; desc = gpio_to_desc(gpio); - /* reject bogus commands (gpio_unexport ignores them) */ + /* reject bogus commands (gpiod_unexport ignores them) */ if (!desc) { pr_warn("%s: invalid GPIO %ld\n", __func__, gpio); return -EINVAL; @@ -814,7 +814,7 @@ static int __init gpiolib_sysfs_init(void) * early (e.g. before the class_register above was called). * * We run before arch_initcall() so chip->dev nodes can have - * registered, and so arch_initcall() can always gpio_export(). + * registered, and so arch_initcall() can always gpiod_export(). */ spin_lock_irqsave(&gpio_lock, flags); list_for_each_entry(gdev, &gpio_devices, list) { diff --git a/drivers/media/i2c/noon010pc30.c b/drivers/media/i2c/noon010pc30.c index f3ac379ef34a..6faa44eb5354 100644 --- a/drivers/media/i2c/noon010pc30.c +++ b/drivers/media/i2c/noon010pc30.c @@ -10,6 +10,7 @@ */ #include +#include #include #include #include @@ -755,7 +756,7 @@ static int noon010_probe(struct i2c_client *client, goto np_err; } info->gpio_nreset = pdata->gpio_nreset; - gpio_export(info->gpio_nreset, 0); + gpiod_export(gpio_to_desc(info->gpio_nreset), 0); } if (gpio_is_valid(pdata->gpio_nstby)) { @@ -767,7 +768,7 @@ static int noon010_probe(struct i2c_client *client, goto np_err; } info->gpio_nstby = pdata->gpio_nstby; - gpio_export(info->gpio_nstby, 0); + gpiod_export(gpio_to_desc(info->gpio_nstby), 0); } for (i = 0; i < NOON010_NUM_SUPPLIES; i++) diff --git a/drivers/media/i2c/ov9650.c b/drivers/media/i2c/ov9650.c index c313e11a9754..021acd20ede2 100644 --- a/drivers/media/i2c/ov9650.c +++ b/drivers/media/i2c/ov9650.c @@ -1426,9 +1426,9 @@ static int ov965x_configure_gpios_pdata(struct ov965x *ov965x, return ret; v4l2_dbg(1, debug, &ov965x->sd, "set gpio %d to 1\n", gpio); - gpio_set_value_cansleep(gpio, 1); - gpio_export(gpio, 0); ov965x->gpios[i] = gpio_to_desc(gpio); + gpiod_set_value_cansleep(ov965x->gpios[i], 1); + gpiod_export(ov965x->gpios[i], 0); } return 0; diff --git a/drivers/media/i2c/s5k4ecgx.c b/drivers/media/i2c/s5k4ecgx.c index af9a305242cd..419d03fcc978 100644 --- a/drivers/media/i2c/s5k4ecgx.c +++ b/drivers/media/i2c/s5k4ecgx.c @@ -15,6 +15,7 @@ #include #include #include +#include #include #include #include @@ -852,7 +853,7 @@ static int s5k4ecgx_config_gpio(int nr, int val, const char *name) return 0; ret = gpio_request_one(nr, flags, name); if (!ret) - gpio_export(nr, 0); + gpiod_export(gpio_to_desc(nr), 0); return ret; } diff --git a/drivers/media/pci/sta2x11/sta2x11_vip.c b/drivers/media/pci/sta2x11/sta2x11_vip.c index 524912f20d9f..f7cef598f21d 100644 --- a/drivers/media/pci/sta2x11/sta2x11_vip.c +++ b/drivers/media/pci/sta2x11/sta2x11_vip.c @@ -18,6 +18,7 @@ #include #include #include +#include #include #include #include @@ -893,6 +894,7 @@ static int sta2x11_vip_init_controls(struct sta2x11_vip *vip) static int vip_gpio_reserve(struct device *dev, int pin, int dir, const char *name) { + struct gpio_desc *desc = gpio_to_desc(pin); int ret = -ENODEV; if (!gpio_is_valid(pin)) @@ -904,7 +906,7 @@ static int vip_gpio_reserve(struct device *dev, int pin, int dir, return ret; } - ret = gpio_direction_output(pin, dir); + ret = gpiod_direction_output(desc, dir); if (ret) { dev_err(dev, "Failed to set direction for pin %d (%s)\n", pin, name); @@ -912,7 +914,7 @@ static int vip_gpio_reserve(struct device *dev, int pin, int dir, return ret; } - ret = gpio_export(pin, false); + ret = gpiod_export(desc, false); if (ret) { dev_err(dev, "Failed to export pin %d (%s)\n", pin, name); gpio_free(pin); @@ -932,8 +934,10 @@ static int vip_gpio_reserve(struct device *dev, int pin, int dir, static void vip_gpio_release(struct device *dev, int pin, const char *name) { if (gpio_is_valid(pin)) { + struct gpio_desc *desc = gpio_to_desc(pin); + dev_dbg(dev, "releasing pin %d (%s)\n", pin, name); - gpio_unexport(pin); + gpiod_unexport(desc); gpio_free(pin); } } diff --git a/drivers/mfd/dm355evm_msp.c b/drivers/mfd/dm355evm_msp.c index 54fb6cbd2aa0..2388fb4d0121 100644 --- a/drivers/mfd/dm355evm_msp.c +++ b/drivers/mfd/dm355evm_msp.c @@ -11,6 +11,7 @@ #include #include #include +#include #include #include #include @@ -329,7 +330,7 @@ static int add_children(struct i2c_client *client) gpio_request_one(gpio, GPIOF_IN, config_inputs[i].label); /* make it easy for userspace to see these */ - gpio_export(gpio, false); + gpiod_export(gpio_to_desc(gpio), false); } /* MMC/SD inputs -- right after the last config input */ diff --git a/drivers/net/ieee802154/ca8210.c b/drivers/net/ieee802154/ca8210.c index ece6ff6049f6..6252907b2c92 100644 --- a/drivers/net/ieee802154/ca8210.c +++ b/drivers/net/ieee802154/ca8210.c @@ -51,6 +51,7 @@ #include #include #include +#include #include #include #include @@ -2895,7 +2896,7 @@ static int ca8210_interrupt_init(struct spi_device *spi) ); if (ret) { dev_crit(&spi->dev, "request_irq %d failed\n", pdata->irq_id); - gpio_unexport(pdata->gpio_irq); + gpiod_unexport(gpio_to_desc(pdata->gpio_irq)); gpio_free(pdata->gpio_irq); } diff --git a/include/linux/gpio.h b/include/linux/gpio.h index 64cc8f09eba8..7ceb93678689 100644 --- a/include/linux/gpio.h +++ b/include/linux/gpio.h @@ -144,26 +144,6 @@ extern int gpio_request_one(unsigned gpio, unsigned long flags, const char *labe extern int gpio_request_array(const struct gpio *array, size_t num); extern void gpio_free_array(const struct gpio *array, size_t num); -/* - * A sysfs interface can be exported by individual drivers if they want, - * but more typically is configured entirely from userspace. - */ -static inline int gpio_export(unsigned gpio, bool direction_may_change) -{ - return gpiod_export(gpio_to_desc(gpio), direction_may_change); -} - -static inline int gpio_export_link(struct device *dev, const char *name, - unsigned gpio) -{ - return gpiod_export_link(dev, name, gpio_to_desc(gpio)); -} - -static inline void gpio_unexport(unsigned gpio) -{ - gpiod_unexport(gpio_to_desc(gpio)); -} - /* CONFIG_GPIOLIB: bindings for managed devices that want to request gpios */ struct device; @@ -253,27 +233,6 @@ static inline void gpio_set_value_cansleep(unsigned gpio, int value) WARN_ON(1); } -static inline int gpio_export(unsigned gpio, bool direction_may_change) -{ - /* GPIO can never have been requested or set as {in,out}put */ - WARN_ON(1); - return -EINVAL; -} - -static inline int gpio_export_link(struct device *dev, const char *name, - unsigned gpio) -{ - /* GPIO can never have been exported */ - WARN_ON(1); - return -EINVAL; -} - -static inline void gpio_unexport(unsigned gpio) -{ - /* GPIO can never have been exported */ - WARN_ON(1); -} - static inline int gpio_to_irq(unsigned gpio) { /* GPIO can never have been requested or set as input */ -- 2.29.2 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 mail.kernel.org (mail.kernel.org [198.145.29.99]) by smtp.lore.kernel.org (Postfix) with ESMTP id 6DD5EC4332F for ; Tue, 9 Nov 2021 10:10:45 +0000 (UTC) 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 mail.kernel.org (Postfix) with ESMTPS id 293DA61207 for ; Tue, 9 Nov 2021 10:10:45 +0000 (UTC) DMARC-Filter: OpenDMARC Filter v1.4.1 mail.kernel.org 293DA61207 Authentication-Results: mail.kernel.org; dmarc=fail (p=none dis=none) header.from=kernel.org Authentication-Results: mail.kernel.org; spf=none smtp.mailfrom=lists.infradead.org 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=DD2cHTXi5KkPlYBKC6j72DjI7YvPnrxWtMReyHJBPh8=; b=Ysgypp32kyYZFd fLLr2YQGBU0iv8sKJkZdu9rn2Ca9/q57JxzutaKivkyeTpx8+fkhtSyfd2wxsOKx44Xe5zrm6oKhD g1fhLMPEnS3oLJellcKeFua6zVEanEzMHvpqDRv2JW1L1wKAz58AST83+kDYRgpVpKDPgcVlGudEg mqQiaLMCFhTKtIkmTiKxRgFmKcTS42j0tNUW/i46Sdxf+vfrdIA0uyCH1yFcwOtXlQdB9njk1D0L8 uiAyPqLGwkKnDoaQFiAvISwOx7CP6ez67U7AWO5E4T79ECcQ/nKQZkMCpezJoB3D9hpt4rwRu57ru d0bgDPhUYqXXudo4HdYw==; Received: from localhost ([::1] helo=bombadil.infradead.org) by bombadil.infradead.org with esmtp (Exim 4.94.2 #2 (Red Hat Linux)) id 1mkO3m-001QJz-CS; Tue, 09 Nov 2021 10:09:00 +0000 Received: from mail.kernel.org ([198.145.29.99]) by bombadil.infradead.org with esmtps (Exim 4.94.2 #2 (Red Hat Linux)) id 1mkNxU-001OSk-Pf for linux-arm-kernel@lists.infradead.org; Tue, 09 Nov 2021 10:02:31 +0000 Received: by mail.kernel.org (Postfix) with ESMTPSA id EF7A461130; Tue, 9 Nov 2021 10:02:26 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1636452148; bh=pwmejsZnkl62Kuuzf1JnZ72Ygl7f6FNKemOPbCL9Ahs=; h=From:To:Cc:Subject:Date:In-Reply-To:References:From; b=DOMVkIn9MFZq7++K4ZjBt7bq2AUqKtmwdJj4Q20SEmWa0ig9VlZpwR1vx1fQcmmZg xLA872cnuEJQzF/ibG7D7zU3JrNHNTVclUkENwjZGTt7TGEf0TPFBk/miywYld4XoJ /0OChCZ6lWPMYDZ4c/KEFd8iKbtST5k9o6ibpLMpX64X18f4tpg4Ge+qxmdDqyxYvD olFMlLWYBHBtUxJMHVZGCPMAoaDDm7sNFYlk18s0/5yKApWrdLP5qFAEtLQ9DODi1L 1XgTZX+0SV5+p1haraxb4g3HDqqY3E2e54+BwrELhcJrfZ436Ad0pHUCd0srOUEhix Wu9Tvzt+oZywA== From: Arnd Bergmann To: linux-gpio@vger.kernel.org Cc: Arnd Bergmann , Linus Walleij , Bartosz Golaszewski , Andy Shevchenko , Geert Uytterhoeven , linux-arm-kernel@lists.infradead.org, linux-kernel@vger.kernel.org Subject: [PATCH v2 6/8] gpiolib: remove legacy gpio_export Date: Tue, 9 Nov 2021 11:02:05 +0100 Message-Id: <20211109100207.2474024-7-arnd@kernel.org> X-Mailer: git-send-email 2.29.2 In-Reply-To: <20211109100207.2474024-1-arnd@kernel.org> References: <20211109100207.2474024-1-arnd@kernel.org> MIME-Version: 1.0 X-CRM114-Version: 20100106-BlameMichelson ( TRE 0.8.0 (BSD) ) MR-646709E3 X-CRM114-CacheID: sfid-20211109_020228_978384_AA3547DE X-CRM114-Status: GOOD ( 23.68 ) 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 RnJvbTogQXJuZCBCZXJnbWFubiA8YXJuZEBhcm5kYi5kZT4KClRoZXJlIGFyZSBvbmx5IGEgaGFu ZGZ1bCBvZiB1c2VycyBvZiBncGlvX2V4cG9ydCgpIGFuZApyZWxhdGVkIGZ1bmN0aW9ucy4KCkFz IHRoZXNlIGFyZSBqdXN0IHdyYXBwZXJzIGFyb3VuZCB0aGUgbW9kZXJuIGdwaW9kX2V4cG9ydCgp CmhlbHBlciwgcmVtb3ZlIHRoZSB3cmFwcGVycyBhbmQgb3Blbi1jb2RlIHRoZSBncGlvX3RvX2Rl c2MKaW4gYWxsIGNhbGxlcnMgdG8gc2hyaW5rIHRoZSBsZWdhY3kgQVBJLgoKU2lnbmVkLW9mZi1i eTogQXJuZCBCZXJnbWFubiA8YXJuZEBhcm5kYi5kZT4KLS0tCiBEb2N1bWVudGF0aW9uL2FkbWlu LWd1aWRlL2dwaW8vc3lzZnMucnN0ICB8ICAyICstCiBEb2N1bWVudGF0aW9uL2RyaXZlci1hcGkv Z3Bpby9sZWdhY3kucnN0ICB8IDMwIC0tLS0tLS0tLS0tLS0tLS0tCiBEb2N1bWVudGF0aW9uL3Ry YW5zbGF0aW9ucy96aF9DTi9ncGlvLnR4dCB8IDI2IC0tLS0tLS0tLS0tLS0tCiBEb2N1bWVudGF0 aW9uL3RyYW5zbGF0aW9ucy96aF9UVy9ncGlvLnR4dCB8IDI3IC0tLS0tLS0tLS0tLS0tLQogYXJj aC9hcm0vbWFjaC1kYXZpbmNpL2JvYXJkLWRtNjQ2eC1ldm0uYyAgfCAyOCArKysrKysrKystLS0t LS0tCiBhcmNoL2FybS9tYWNoLW9tYXAyL3BkYXRhLXF1aXJrcy5jICAgICAgICB8ICA5ICsrLS0t CiBhcmNoL3NoL2JvYXJkcy9tYWNoLWFwMzI1cnhhL3NldHVwLmMgICAgICB8ICA3ICsrLS0KIGRy aXZlcnMvZ3Bpby9ncGlvbGliLXN5c2ZzLmMgICAgICAgICAgICAgIHwgIDQgKy0tCiBkcml2ZXJz L21lZGlhL2kyYy9ub29uMDEwcGMzMC5jICAgICAgICAgICB8ICA1ICstLQogZHJpdmVycy9tZWRp YS9pMmMvb3Y5NjUwLmMgICAgICAgICAgICAgICAgfCAgNCArLS0KIGRyaXZlcnMvbWVkaWEvaTJj L3M1azRlY2d4LmMgICAgICAgICAgICAgIHwgIDMgKy0KIGRyaXZlcnMvbWVkaWEvcGNpL3N0YTJ4 MTEvc3RhMngxMV92aXAuYyAgIHwgMTAgKysrKy0tCiBkcml2ZXJzL21mZC9kbTM1NWV2bV9tc3Au YyAgICAgICAgICAgICAgICB8ICAzICstCiBkcml2ZXJzL25ldC9pZWVlODAyMTU0L2NhODIxMC5j ICAgICAgICAgICB8ICAzICstCiBpbmNsdWRlL2xpbnV4L2dwaW8uaCAgICAgICAgICAgICAgICAg ICAgICB8IDQxIC0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tCiAxNSBmaWxlcyBjaGFuZ2VkLCA0NSBp bnNlcnRpb25zKCspLCAxNTcgZGVsZXRpb25zKC0pCgpkaWZmIC0tZ2l0IGEvRG9jdW1lbnRhdGlv bi9hZG1pbi1ndWlkZS9ncGlvL3N5c2ZzLnJzdCBiL0RvY3VtZW50YXRpb24vYWRtaW4tZ3VpZGUv Z3Bpby9zeXNmcy5yc3QKaW5kZXggZWMwOWZmZDk4M2U3Li4zNTE3MWQxNWY3OGQgMTAwNjQ0Ci0t LSBhL0RvY3VtZW50YXRpb24vYWRtaW4tZ3VpZGUvZ3Bpby9zeXNmcy5yc3QKKysrIGIvRG9jdW1l bnRhdGlvbi9hZG1pbi1ndWlkZS9ncGlvL3N5c2ZzLnJzdApAQCAtMTQ1LDcgKzE0NSw3IEBAIHJl cXVlc3RlZCB1c2luZyBncGlvX3JlcXVlc3QoKTo6CiAJLyogZXhwb3J0IHRoZSBHUElPIHRvIHVz ZXJzcGFjZSAqLwogCWludCBncGlvZF9leHBvcnQoc3RydWN0IGdwaW9fZGVzYyAqZGVzYywgYm9v bCBkaXJlY3Rpb25fbWF5X2NoYW5nZSk7CiAKLQkvKiByZXZlcnNlIGdwaW9fZXhwb3J0KCkgKi8K KwkvKiByZXZlcnNlIGdwaW9kX2V4cG9ydCgpICovCiAJdm9pZCBncGlvZF91bmV4cG9ydChzdHJ1 Y3QgZ3Bpb19kZXNjICpkZXNjKTsKIAogCS8qIGNyZWF0ZSBhIHN5c2ZzIGxpbmsgdG8gYW4gZXhw b3J0ZWQgR1BJTyBub2RlICovCmRpZmYgLS1naXQgYS9Eb2N1bWVudGF0aW9uL2RyaXZlci1hcGkv Z3Bpby9sZWdhY3kucnN0IGIvRG9jdW1lbnRhdGlvbi9kcml2ZXItYXBpL2dwaW8vbGVnYWN5LnJz dAppbmRleCBlYWUxODVmNzcxZDcuLjM0ZmNiMTQ4MTRkYiAxMDA2NDQKLS0tIGEvRG9jdW1lbnRh dGlvbi9kcml2ZXItYXBpL2dwaW8vbGVnYWN5LnJzdAorKysgYi9Eb2N1bWVudGF0aW9uL2RyaXZl ci1hcGkvZ3Bpby9sZWdhY3kucnN0CkBAIC03MTcsMzYgKzcxNyw2IEBAIGdwaW9jaGlwIG5vZGVz IChwb3NzaWJseSBpbiBjb25qdW5jdGlvbiB3aXRoIHNjaGVtYXRpY3MpIHRvIGRldGVybWluZQog dGhlIGNvcnJlY3QgR1BJTyBudW1iZXIgdG8gdXNlIGZvciBhIGdpdmVuIHNpZ25hbC4KIAogCi1F eHBvcnRpbmcgZnJvbSBLZXJuZWwgY29kZQotLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0KLUtl cm5lbCBjb2RlIGNhbiBleHBsaWNpdGx5IG1hbmFnZSBleHBvcnRzIG9mIEdQSU9zIHdoaWNoIGhh dmUgYWxyZWFkeSBiZWVuCi1yZXF1ZXN0ZWQgdXNpbmcgZ3Bpb19yZXF1ZXN0KCk6OgotCi0JLyog ZXhwb3J0IHRoZSBHUElPIHRvIHVzZXJzcGFjZSAqLwotCWludCBncGlvX2V4cG9ydCh1bnNpZ25l ZCBncGlvLCBib29sIGRpcmVjdGlvbl9tYXlfY2hhbmdlKTsKLQotCS8qIHJldmVyc2UgZ3Bpb19l eHBvcnQoKSAqLwotCXZvaWQgZ3Bpb191bmV4cG9ydCgpOwotCi0JLyogY3JlYXRlIGEgc3lzZnMg bGluayB0byBhbiBleHBvcnRlZCBHUElPIG5vZGUgKi8KLQlpbnQgZ3Bpb19leHBvcnRfbGluayhz dHJ1Y3QgZGV2aWNlICpkZXYsIGNvbnN0IGNoYXIgKm5hbWUsCi0JCXVuc2lnbmVkIGdwaW8pCi0K LUFmdGVyIGEga2VybmVsIGRyaXZlciByZXF1ZXN0cyBhIEdQSU8sIGl0IG1heSBvbmx5IGJlIG1h ZGUgYXZhaWxhYmxlIGluCi10aGUgc3lzZnMgaW50ZXJmYWNlIGJ5IGdwaW9fZXhwb3J0KCkuICBU aGUgZHJpdmVyIGNhbiBjb250cm9sIHdoZXRoZXIgdGhlCi1zaWduYWwgZGlyZWN0aW9uIG1heSBj aGFuZ2UuICBUaGlzIGhlbHBzIGRyaXZlcnMgcHJldmVudCB1c2Vyc3BhY2UgY29kZQotZnJvbSBh Y2NpZGVudGFsbHkgY2xvYmJlcmluZyBpbXBvcnRhbnQgc3lzdGVtIHN0YXRlLgotCi1UaGlzIGV4 cGxpY2l0IGV4cG9ydGluZyBjYW4gaGVscCB3aXRoIGRlYnVnZ2luZyAoYnkgbWFraW5nIHNvbWUg a2luZHMKLW9mIGV4cGVyaW1lbnRzIGVhc2llciksIG9yIGNhbiBwcm92aWRlIGFuIGFsd2F5cy10 aGVyZSBpbnRlcmZhY2UgdGhhdCdzCi1zdWl0YWJsZSBmb3IgZG9jdW1lbnRpbmcgYXMgcGFydCBv ZiBhIGJvYXJkIHN1cHBvcnQgcGFja2FnZS4KLQotQWZ0ZXIgdGhlIEdQSU8gaGFzIGJlZW4gZXhw b3J0ZWQsIGdwaW9fZXhwb3J0X2xpbmsoKSBhbGxvd3MgY3JlYXRpbmcKLXN5bWxpbmtzIGZyb20g ZWxzZXdoZXJlIGluIHN5c2ZzIHRvIHRoZSBHUElPIHN5c2ZzIG5vZGUuICBEcml2ZXJzIGNhbgot dXNlIHRoaXMgdG8gcHJvdmlkZSB0aGUgaW50ZXJmYWNlIHVuZGVyIHRoZWlyIG93biBkZXZpY2Ug aW4gc3lzZnMgd2l0aAotYSBkZXNjcmlwdGl2ZSBuYW1lLgotCi0KIEFQSSBSZWZlcmVuY2UKID09 PT09PT09PT09PT0KIApkaWZmIC0tZ2l0IGEvRG9jdW1lbnRhdGlvbi90cmFuc2xhdGlvbnMvemhf Q04vZ3Bpby50eHQgYi9Eb2N1bWVudGF0aW9uL3RyYW5zbGF0aW9ucy96aF9DTi9ncGlvLnR4dApp bmRleCBhMjNlZTE0ZmM5MjcuLmU0OWZhODhhMjgwNCAxMDA2NDQKLS0tIGEvRG9jdW1lbnRhdGlv bi90cmFuc2xhdGlvbnMvemhfQ04vZ3Bpby50eHQKKysrIGIvRG9jdW1lbnRhdGlvbi90cmFuc2xh dGlvbnMvemhfQ04vZ3Bpby50eHQKQEAgLTYyMiwyOSArNjIyLDMgQEAgR1BJTyDmjqfliLblmajn moTot6/lvoTnsbvkvLwgL3N5cy9jbGFzcy9ncGlvL2dwaW9jaGlwNDIvICjlr7nkuo7ku44jNDIg R1BJTwog5Zu65a6a55qELOS+i+WmguWcqOaJqeWxleWNoeS4iueahCBHUElP5Lya5qC55o2u5omA 5L2/55So55qE5Li75p2/5oiW5omA5Zyo5aCG5Y+g5p625p6E5Lit5YW25LuW55qE5p2/5a2Q6ICM CiDmnInmiYDkuI3lkIzjgILlnKjov5nnp43mg4XlhrXkuIss5L2g5Y+v6IO96ZyA6KaB5L2/55So IGdwaW9jaGlwIOiKgueCuSjlsL3lj6/og73lnLDnu5PlkIjnlLXot6/lm74p5p2lCiDnoa7lrprn u5nlrprkv6Hlj7fmiYDnlKjnmoQgR1BJTyDnvJblj7fjgIIKLQotCi3ku47lhoXmoLjku6PnoIHk uK3lr7zlh7oKLS0tLS0tLS0tLS0tLS0KLeWGheaguOS7o+eggeWPr+S7peaYjuehruWcsOeuoeeQ humCo+S6m+W3sumAmui/hyBncGlvX3JlcXVlc3QoKeeUs+ivt+eahCBHUElPIOeahOWvvOWHujoK LQotCS8qIOWvvOWHuiBHUElPIOWIsOeUqOaIt+epuumXtCAqLwotCWludCBncGlvX2V4cG9ydCh1 bnNpZ25lZCBncGlvLCBib29sIGRpcmVjdGlvbl9tYXlfY2hhbmdlKTsKLQotCS8qIGdwaW9fZXhw b3J0KCnnmoTpgIbmk43kvZwgKi8KLQl2b2lkIGdwaW9fdW5leHBvcnQoKTsKLQotCS8qIOWIm+W7 uuS4gOS4qiBzeXNmcyDov57mjqXliLDlt7Llr7zlh7rnmoQgR1BJTyDoioLngrkgKi8KLQlpbnQg Z3Bpb19leHBvcnRfbGluayhzdHJ1Y3QgZGV2aWNlICpkZXYsIGNvbnN0IGNoYXIgKm5hbWUsCi0J CXVuc2lnbmVkIGdwaW8pCi0KLeWcqOS4gOS4quWGheaguOmpseWKqOeUs+ivt+S4gOS4qiBHUElP IOS5i+WQju+8jOWug+WPr+S7pemAmui/hyBncGlvX2V4cG9ydCgp5L2/5YW25ZyoIHN5c2ZzCi3m jqXlj6PkuK3lj6/op4HjgILor6XpqbHliqjlj6/ku6XmjqfliLbkv6Hlj7fmlrnlkJHmmK/lkKbl j6/kv67mlLnjgILov5nmnInliqnkuo7pmLLmraLnlKjmiLfnqbrpl7Tku6PnoIHml6DmhI/pl7QK LeegtOWdj+mHjeimgeeahOezu+e7n+eKtuaAgeOAggotCi3ov5nkuKrmmI7noa7nmoTlr7zlh7rm nInliqnkuo4o6YCa6L+H5L2/5p+Q5Lqb5a6e6aqM5pu05a655piT5p2lKeiwg+ivle+8jOS5n+WP r+S7peaPkOS+m+S4gOS4quWni+e7iOWtmOWcqOeahOaOpeWPo++8jAot5LiO5paH5qGj6YWN5ZCI 5L2c5Li65p2/57qn5pSv5oyB5YyF55qE5LiA6YOo5YiG44CCCi0KLeWcqCBHUElPIOiiq+WvvOWH uuS5i+WQju+8jGdwaW9fZXhwb3J0X2xpbmsoKeWFgeiuuOWcqCBzeXNmcyDmlofku7bns7vnu5/n moTku7vkvZXlnLDmlrkKLeWIm+W7uuS4gOS4quWIsOi/meS4qiBHUElPIHN5c2ZzIOiKgueCueea hOespuWPt+mTvuaOpeOAgui/meagt+mpseWKqOWwseWPr+S7pemAmui/h+S4gOS4quaPj+i/sOaA p+eahAot5ZCN5a2X77yM5ZyoIHN5c2ZzIOS4reS7luS7rOaJgOaLpeacieeahOiuvuWkh+S4i+aP kOS+m+S4gOS4qijliLDov5nkuKogR1BJTyBzeXNmcyDoioLngrnnmoQp5o6l5Y+j44CCCmRpZmYg LS1naXQgYS9Eb2N1bWVudGF0aW9uL3RyYW5zbGF0aW9ucy96aF9UVy9ncGlvLnR4dCBiL0RvY3Vt ZW50YXRpb24vdHJhbnNsYXRpb25zL3poX1RXL2dwaW8udHh0CmluZGV4IGUzYzA3NmRkNzVhNS4u YzliZjNkZGQwOGIzIDEwMDY0NAotLS0gYS9Eb2N1bWVudGF0aW9uL3RyYW5zbGF0aW9ucy96aF9U Vy9ncGlvLnR4dAorKysgYi9Eb2N1bWVudGF0aW9uL3RyYW5zbGF0aW9ucy96aF9UVy9ncGlvLnR4 dApAQCAtNjIyLDMwICs2MjIsMyBAQCBHUElPIOaOp+WItuWZqOeahOi3r+W+kemhnuS8vCAvc3lz L2NsYXNzL2dwaW8vZ3Bpb2NoaXA0Mi8gKOWwjeaWvOW+niM0MiBHUElPCiDlm7rlrprnmoQs5L6L 5aaC5Zyo5pO05bGV5Y2h5LiK55qEIEdQSU/mnIPmoLnmk5rmiYDkvb/nlKjnmoTkuLvmnb/miJbm iYDlnKjloIbnlormnrbmp4vkuK3lhbbku5bnmoTmnb/lrZDogIwKIOacieaJgOS4jeWQjOOAguWc qOmAmeeoruaDheazgeS4iyzkvaDlj6/og73pnIDopoHkvb/nlKggZ3Bpb2NoaXAg56+A6bueKOWE mOWPr+iDveWcsOe1kOWQiOmbu+i3r+WclinkvoYKIOeiuuWumue1puWumuS/oeiZn+aJgOeUqOea hCBHUElPIOe3qOiZn+OAggotCi0KLeW+nuWFp+aguOS7o+eivOS4reWwjuWHugotLS0tLS0tLS0t LS0tLQot5YWn5qC45Luj56K85Y+v5Lul5piO56K65Zyw566h55CG6YKj5Lqb5bey6YCa6YGOIGdw aW9fcmVxdWVzdCgp55Sz6KuL55qEIEdQSU8g55qE5bCO5Ye6OgotCi0JLyog5bCO5Ye6IEdQSU8g 5Yiw55So5oi256m66ZaTICovCi0JaW50IGdwaW9fZXhwb3J0KHVuc2lnbmVkIGdwaW8sIGJvb2wg ZGlyZWN0aW9uX21heV9jaGFuZ2UpOwotCi0JLyogZ3Bpb19leHBvcnQoKeeahOmAhuaTjeS9nCAq LwotCXZvaWQgZ3Bpb191bmV4cG9ydCgpOwotCi0JLyog5Ym15bu65LiA5YCLIHN5c2ZzIOmAo+aO peWIsOW3suWwjuWHuueahCBHUElPIOevgOm7niAqLwotCWludCBncGlvX2V4cG9ydF9saW5rKHN0 cnVjdCBkZXZpY2UgKmRldiwgY29uc3QgY2hhciAqbmFtZSwKLQkJdW5zaWduZWQgZ3BpbykKLQot 5Zyo5LiA5YCL5YWn5qC46amF5YuV55Sz6KuL5LiA5YCLIEdQSU8g5LmL5b6M77yM5a6D5Y+v5Lul 6YCa6YGOIGdwaW9fZXhwb3J0KCnkvb/lhbblnKggc3lzZnMKLeaOpeWPo+S4reWPr+imi+OAguip sumpheWLleWPr+S7peaOp+WItuS/oeiZn+aWueWQkeaYr+WQpuWPr+S/ruaUueOAgumAmeacieWK qeaWvOmYsuatoueUqOaItuepuumWk+S7o+eivOeEoeaEj+mWkwot56C05aOe6YeN6KaB55qE57O7 57Wx54uA5oWL44CCCi0KLemAmeWAi+aYjueiuueahOWwjuWHuuacieWKqeaWvCjpgJrpgY7kvb/m n5Dkupvlr6bpqZfmm7TlrrnmmJPkvoYp6Kq/6Kmm77yM5Lmf5Y+v5Lul5o+Q5L6b5LiA5YCL5aeL 57WC5a2Y5Zyo55qE5o6l5Y+j77yMCi3oiIfmlofmqpTphY3lkIjkvZzniLLmnb/ntJrmlK/mjIHl jIXnmoTkuIDpg6jliIbjgIIKLQot5ZyoIEdQSU8g6KKr5bCO5Ye65LmL5b6M77yMZ3Bpb19leHBv cnRfbGluaygp5YWB6Kix5ZyoIHN5c2ZzIOaWh+S7tuezu+e1seeahOS7u+S9leWcsOaWuQot5Ym1 5bu65LiA5YCL5Yiw6YCZ5YCLIEdQSU8gc3lzZnMg56+A6bue55qE56ym6Jmf6YCj57WQ44CC6YCZ 5qij6amF5YuV5bCx5Y+v5Lul6YCa6YGO5LiA5YCL5o+P6L+w5oCn55qECi3lkI3lrZfvvIzlnKgg c3lzZnMg5Lit5LuW5YCR5omA5pOB5pyJ55qE6Kit5YKZ5LiL5o+Q5L6b5LiA5YCLKOWIsOmAmeWA iyBHUElPIHN5c2ZzIOevgOm7nueahCnmjqXlj6PjgIIKLQpkaWZmIC0tZ2l0IGEvYXJjaC9hcm0v bWFjaC1kYXZpbmNpL2JvYXJkLWRtNjQ2eC1ldm0uYyBiL2FyY2gvYXJtL21hY2gtZGF2aW5jaS9i b2FyZC1kbTY0NngtZXZtLmMKaW5kZXggZWU5MWQ4MWViYmZkLi40YTI1OGUzMzAyMWQgMTAwNjQ0 Ci0tLSBhL2FyY2gvYXJtL21hY2gtZGF2aW5jaS9ib2FyZC1kbTY0NngtZXZtLmMKKysrIGIvYXJj aC9hcm0vbWFjaC1kYXZpbmNpL2JvYXJkLWRtNjQ2eC1ldm0uYwpAQCAtMTksNyArMTksNyBAQAog I2luY2x1ZGUgPGxpbnV4L2tlcm5lbC5oPgogI2luY2x1ZGUgPGxpbnV4L2luaXQuaD4KICNpbmNs dWRlIDxsaW51eC9sZWRzLmg+Ci0jaW5jbHVkZSA8bGludXgvZ3Bpby5oPgorI2luY2x1ZGUgPGxp bnV4L2dwaW8vY29uc3VtZXIuaD4KICNpbmNsdWRlIDxsaW51eC9wbGF0Zm9ybV9kZXZpY2UuaD4K ICNpbmNsdWRlIDxsaW51eC9pMmMuaD4KICNpbmNsdWRlIDxsaW51eC9wcm9wZXJ0eS5oPgpAQCAt MjQ5LDcgKzI0OSw3IEBAIHN0YXRpYyBpbnQgZXZtX2xlZF90ZWFyZG93bihzdHJ1Y3QgaTJjX2Ns aWVudCAqY2xpZW50LCBpbnQgZ3BpbywKIAlyZXR1cm4gMDsKIH0KIAotc3RhdGljIGludCBldm1f c3dfZ3Bpb1s0XSA9IHsgLUVJTlZBTCwgLUVJTlZBTCwgLUVJTlZBTCwgLUVJTlZBTCB9Oworc3Rh dGljIHN0cnVjdCBncGlvX2Rlc2MgKmV2bV9zd19ncGlvWzRdOwogCiBzdGF0aWMgaW50IGV2bV9z d19zZXR1cChzdHJ1Y3QgaTJjX2NsaWVudCAqY2xpZW50LCBpbnQgZ3BpbywKIAkJCXVuc2lnbmVk IG5ncGlvLCB2b2lkICpjKQpAQCAtMjU5LDE3ICsyNTksMTkgQEAgc3RhdGljIGludCBldm1fc3df c2V0dXAoc3RydWN0IGkyY19jbGllbnQgKmNsaWVudCwgaW50IGdwaW8sCiAJY2hhciBsYWJlbFsx MF07CiAKIAlmb3IgKGkgPSAwOyBpIDwgNDsgKytpKSB7CisJCXN0cnVjdCBncGlvX2Rlc2MgKmRl c2MgPSBncGlvX3RvX2Rlc2MoZ3BpbyArIGkpOworCiAJCXNucHJpbnRmKGxhYmVsLCAxMCwgInVz ZXJfc3clZCIsIGkpOwotCQlzdGF0dXMgPSBncGlvX3JlcXVlc3QoZ3BpbywgbGFiZWwpOworCQlz dGF0dXMgPSBncGlvX3JlcXVlc3QoZ3BpbyArIGksIGxhYmVsKTsKIAkJaWYgKHN0YXR1cykKIAkJ CWdvdG8gb3V0X2ZyZWU7Ci0JCWV2bV9zd19ncGlvW2ldID0gZ3BpbysrOworCQlldm1fc3dfZ3Bp b1tpXSA9IGRlc2M7CiAKLQkJc3RhdHVzID0gZ3Bpb19kaXJlY3Rpb25faW5wdXQoZXZtX3N3X2dw aW9baV0pOworCQlzdGF0dXMgPSBncGlvZF9kaXJlY3Rpb25faW5wdXQoZGVzYyk7CiAJCWlmIChz dGF0dXMpCiAJCQlnb3RvIG91dF9mcmVlOwogCi0JCXN0YXR1cyA9IGdwaW9fZXhwb3J0KGV2bV9z d19ncGlvW2ldLCAwKTsKKwkJc3RhdHVzID0gZ3Bpb2RfZXhwb3J0KGRlc2MsIDApOwogCQlpZiAo c3RhdHVzKQogCQkJZ290byBvdXRfZnJlZTsKIAl9CkBAIC0yNzcsOSArMjc5LDkgQEAgc3RhdGlj IGludCBldm1fc3dfc2V0dXAoc3RydWN0IGkyY19jbGllbnQgKmNsaWVudCwgaW50IGdwaW8sCiAK IG91dF9mcmVlOgogCWZvciAoaSA9IDA7IGkgPCA0OyArK2kpIHsKLQkJaWYgKGV2bV9zd19ncGlv W2ldICE9IC1FSU5WQUwpIHsKLQkJCWdwaW9fZnJlZShldm1fc3dfZ3Bpb1tpXSk7Ci0JCQlldm1f c3dfZ3Bpb1tpXSA9IC1FSU5WQUw7CisJCWlmIChldm1fc3dfZ3Bpb1tpXSkgeworCQkJZ3Bpb19m cmVlKHBpbiArIGkpOworCQkJZXZtX3N3X2dwaW9baV0gPSBOVUxMOwogCQl9CiAJfQogCXJldHVy biBzdGF0dXM7CkBAIC0yOTEsMTAgKzI5MywxMCBAQCBzdGF0aWMgaW50IGV2bV9zd190ZWFyZG93 bihzdHJ1Y3QgaTJjX2NsaWVudCAqY2xpZW50LCBpbnQgZ3BpbywKIAlpbnQgaTsKIAogCWZvciAo aSA9IDA7IGkgPCA0OyArK2kpIHsKLQkJaWYgKGV2bV9zd19ncGlvW2ldICE9IC1FSU5WQUwpIHsK LQkJCWdwaW9fdW5leHBvcnQoZXZtX3N3X2dwaW9baV0pOwotCQkJZ3Bpb19mcmVlKGV2bV9zd19n cGlvW2ldKTsKLQkJCWV2bV9zd19ncGlvW2ldID0gLUVJTlZBTDsKKwkJaWYgKGV2bV9zd19ncGlv W2ldKSB7CisJCQlncGlvZF91bmV4cG9ydChldm1fc3dfZ3Bpb1tpXSk7CisJCQlncGlvX2ZyZWUo Z3BpbyArIGkpOworCQkJZXZtX3N3X2dwaW9baV0gPSBOVUxMOwogCQl9CiAJfQogCXJldHVybiAw OwpkaWZmIC0tZ2l0IGEvYXJjaC9hcm0vbWFjaC1vbWFwMi9wZGF0YS1xdWlya3MuYyBiL2FyY2gv YXJtL21hY2gtb21hcDIvcGRhdGEtcXVpcmtzLmMKaW5kZXggZTdmZDI5YTUwMmEwLi4xZmRmN2Zj ZjA5MWUgMTAwNjQ0Ci0tLSBhL2FyY2gvYXJtL21hY2gtb21hcDIvcGRhdGEtcXVpcmtzLmMKKysr IGIvYXJjaC9hcm0vbWFjaC1vbWFwMi9wZGF0YS1xdWlya3MuYwpAQCAtNiw2ICs2LDcgQEAKICAq LwogI2luY2x1ZGUgPGxpbnV4L2Nsay5oPgogI2luY2x1ZGUgPGxpbnV4L2RhdmluY2lfZW1hYy5o PgorI2luY2x1ZGUgPGxpbnV4L2dwaW8vY29uc3VtZXIuaD4KICNpbmNsdWRlIDxsaW51eC9ncGlv Lmg+CiAjaW5jbHVkZSA8bGludXgvaW5pdC5oPgogI2luY2x1ZGUgPGxpbnV4L2tlcm5lbC5oPgpA QCAtMTIwLDcgKzEyMSw3IEBAIHN0YXRpYyBpbnQgb21hcDNfc2JjX3QzNzMwX3R3bF9jYWxsYmFj ayhzdHJ1Y3QgZGV2aWNlICpkZXYsCiAJaWYgKHJlcykKIAkJcmV0dXJuIHJlczsKIAotCWdwaW9f ZXhwb3J0KGdwaW8sIDApOworCWdwaW9kX2V4cG9ydChncGlvX3RvX2Rlc2MoZ3BpbyksIDApOwog CiAJcmV0dXJuIDA7CiB9CkBAIC0xMzUsNyArMTM2LDcgQEAgc3RhdGljIHZvaWQgX19pbml0IG9t YXAzX3NiY190M3hfdXNiX2h1Yl9pbml0KGludCBncGlvLCBjaGFyICpodWJfbmFtZSkKIAkJcmV0 dXJuOwogCX0KIAotCWdwaW9fZXhwb3J0KGdwaW8sIDApOworCWdwaW9kX2V4cG9ydChncGlvX3Rv X2Rlc2MoZ3BpbyksIDApOwogCiAJdWRlbGF5KDEwKTsKIAlncGlvX3NldF92YWx1ZShncGlvLCAx KTsKQEAgLTIxMiw4ICsyMTMsOCBAQCBzdGF0aWMgdm9pZCBfX2luaXQgb21hcDNfc2JjX3QzNTE3 X3dpZmlfaW5pdCh2b2lkKQogCQlyZXR1cm47CiAJfQogCi0JZ3Bpb19leHBvcnQoY21fdDM1MTdf d2xhbl9ncGlvc1swXS5ncGlvLCAwKTsKLQlncGlvX2V4cG9ydChjbV90MzUxN193bGFuX2dwaW9z WzFdLmdwaW8sIDApOworCWdwaW9kX2V4cG9ydChncGlvX3RvX2Rlc2MoY21fdDM1MTdfd2xhbl9n cGlvc1swXS5ncGlvKSwgMCk7CisJZ3Bpb2RfZXhwb3J0KGdwaW9fdG9fZGVzYyhjbV90MzUxN193 bGFuX2dwaW9zWzFdLmdwaW8pLCAwKTsKIAogCW1zbGVlcCgxMDApOwogCWdwaW9fc2V0X3ZhbHVl KGNtX3QzNTE3X3dsYW5fZ3Bpb3NbMV0uZ3BpbywgMCk7CmRpZmYgLS1naXQgYS9hcmNoL3NoL2Jv YXJkcy9tYWNoLWFwMzI1cnhhL3NldHVwLmMgYi9hcmNoL3NoL2JvYXJkcy9tYWNoLWFwMzI1cnhh L3NldHVwLmMKaW5kZXggYzc3YjVmMDBhNjZhLi4xNTE3OTIxNjIxNTIgMTAwNjQ0Ci0tLSBhL2Fy Y2gvc2gvYm9hcmRzL21hY2gtYXAzMjVyeGEvc2V0dXAuYworKysgYi9hcmNoL3NoL2JvYXJkcy9t YWNoLWFwMzI1cnhhL3NldHVwLmMKQEAgLTE4LDYgKzE4LDcgQEAKICNpbmNsdWRlIDxsaW51eC9k ZWxheS5oPgogI2luY2x1ZGUgPGxpbnV4L2RldmljZS5oPgogI2luY2x1ZGUgPGxpbnV4L2dwaW8u aD4KKyNpbmNsdWRlIDxsaW51eC9ncGlvL2NvbnN1bWVyLmg+CiAjaW5jbHVkZSA8bGludXgvZ3Bp by9tYWNoaW5lLmg+CiAjaW5jbHVkZSA8bGludXgvaTJjLmg+CiAjaW5jbHVkZSA8bGludXgvaW5p dC5oPgpAQCAtNDExLDE2ICs0MTIsMTYgQEAgc3RhdGljIGludCBfX2luaXQgYXAzMjVyeGFfZGV2 aWNlc19zZXR1cCh2b2lkKQogCS8qIExEMyBhbmQgTEQ0IExFRHMgKi8KIAlncGlvX3JlcXVlc3Qo R1BJT19QVFg1LCBOVUxMKTsgLyogUlVOICovCiAJZ3Bpb19kaXJlY3Rpb25fb3V0cHV0KEdQSU9f UFRYNSwgMSk7Ci0JZ3Bpb19leHBvcnQoR1BJT19QVFg1LCAwKTsKKwlncGlvZF9leHBvcnQoZ3Bp b190b19kZXNjKEdQSU9fUFRYNSksIDApOwogCiAJZ3Bpb19yZXF1ZXN0KEdQSU9fUFRYNCwgTlVM TCk7IC8qIElORElDQVRPUiAqLwogCWdwaW9fZGlyZWN0aW9uX291dHB1dChHUElPX1BUWDQsIDAp OwotCWdwaW9fZXhwb3J0KEdQSU9fUFRYNCwgMCk7CisJZ3Bpb2RfZXhwb3J0KGdwaW9fdG9fZGVz YyhHUElPX1BUWDQpLCAwKTsKIAogCS8qIFNXMSBpbnB1dCAqLwogCWdwaW9fcmVxdWVzdChHUElP X1BURjcsIE5VTEwpOyAvKiBNT0RFICovCiAJZ3Bpb19kaXJlY3Rpb25faW5wdXQoR1BJT19QVEY3 KTsKLQlncGlvX2V4cG9ydChHUElPX1BURjcsIDApOworCWdwaW9kX2V4cG9ydChncGlvX3RvX2Rl c2MoR1BJT19QVEY3KSwgMCk7CiAKIAkvKiBMQ0RDICovCiAJZ3Bpb19yZXF1ZXN0KEdQSU9fRk5f TENERDE1LCBOVUxMKTsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3Bpby9ncGlvbGliLXN5c2ZzLmMg Yi9kcml2ZXJzL2dwaW8vZ3Bpb2xpYi1zeXNmcy5jCmluZGV4IDQwOThiYzdmODhiNy4uYTgzZmJh MzY0OWM0IDEwMDY0NAotLS0gYS9kcml2ZXJzL2dwaW8vZ3Bpb2xpYi1zeXNmcy5jCisrKyBiL2Ry aXZlcnMvZ3Bpby9ncGlvbGliLXN5c2ZzLmMKQEAgLTUxMSw3ICs1MTEsNyBAQCBzdGF0aWMgc3Np emVfdCB1bmV4cG9ydF9zdG9yZShzdHJ1Y3QgY2xhc3MgKmNsYXNzLAogCQlnb3RvIGRvbmU7CiAK IAlkZXNjID0gZ3Bpb190b19kZXNjKGdwaW8pOwotCS8qIHJlamVjdCBib2d1cyBjb21tYW5kcyAo Z3Bpb191bmV4cG9ydCBpZ25vcmVzIHRoZW0pICovCisJLyogcmVqZWN0IGJvZ3VzIGNvbW1hbmRz IChncGlvZF91bmV4cG9ydCBpZ25vcmVzIHRoZW0pICovCiAJaWYgKCFkZXNjKSB7CiAJCXByX3dh cm4oIiVzOiBpbnZhbGlkIEdQSU8gJWxkXG4iLCBfX2Z1bmNfXywgZ3Bpbyk7CiAJCXJldHVybiAt RUlOVkFMOwpAQCAtODE0LDcgKzgxNCw3IEBAIHN0YXRpYyBpbnQgX19pbml0IGdwaW9saWJfc3lz ZnNfaW5pdCh2b2lkKQogCSAqIGVhcmx5IChlLmcuIGJlZm9yZSB0aGUgY2xhc3NfcmVnaXN0ZXIg YWJvdmUgd2FzIGNhbGxlZCkuCiAJICoKIAkgKiBXZSBydW4gYmVmb3JlIGFyY2hfaW5pdGNhbGwo KSBzbyBjaGlwLT5kZXYgbm9kZXMgY2FuIGhhdmUKLQkgKiByZWdpc3RlcmVkLCBhbmQgc28gYXJj aF9pbml0Y2FsbCgpIGNhbiBhbHdheXMgZ3Bpb19leHBvcnQoKS4KKwkgKiByZWdpc3RlcmVkLCBh bmQgc28gYXJjaF9pbml0Y2FsbCgpIGNhbiBhbHdheXMgZ3Bpb2RfZXhwb3J0KCkuCiAJICovCiAJ c3Bpbl9sb2NrX2lycXNhdmUoJmdwaW9fbG9jaywgZmxhZ3MpOwogCWxpc3RfZm9yX2VhY2hfZW50 cnkoZ2RldiwgJmdwaW9fZGV2aWNlcywgbGlzdCkgewpkaWZmIC0tZ2l0IGEvZHJpdmVycy9tZWRp YS9pMmMvbm9vbjAxMHBjMzAuYyBiL2RyaXZlcnMvbWVkaWEvaTJjL25vb24wMTBwYzMwLmMKaW5k ZXggZjNhYzM3OWVmMzRhLi42ZmFhNDRlYjUzNTQgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbWVkaWEv aTJjL25vb24wMTBwYzMwLmMKKysrIGIvZHJpdmVycy9tZWRpYS9pMmMvbm9vbjAxMHBjMzAuYwpA QCAtMTAsNiArMTAsNyBAQAogICovCiAKICNpbmNsdWRlIDxsaW51eC9kZWxheS5oPgorI2luY2x1 ZGUgPGxpbnV4L2dwaW8vY29uc3VtZXIuaD4KICNpbmNsdWRlIDxsaW51eC9ncGlvLmg+CiAjaW5j bHVkZSA8bGludXgvaTJjLmg+CiAjaW5jbHVkZSA8bGludXgvc2xhYi5oPgpAQCAtNzU1LDcgKzc1 Niw3IEBAIHN0YXRpYyBpbnQgbm9vbjAxMF9wcm9iZShzdHJ1Y3QgaTJjX2NsaWVudCAqY2xpZW50 LAogCQkJZ290byBucF9lcnI7CiAJCX0KIAkJaW5mby0+Z3Bpb19ucmVzZXQgPSBwZGF0YS0+Z3Bp b19ucmVzZXQ7Ci0JCWdwaW9fZXhwb3J0KGluZm8tPmdwaW9fbnJlc2V0LCAwKTsKKwkJZ3Bpb2Rf ZXhwb3J0KGdwaW9fdG9fZGVzYyhpbmZvLT5ncGlvX25yZXNldCksIDApOwogCX0KIAogCWlmIChn cGlvX2lzX3ZhbGlkKHBkYXRhLT5ncGlvX25zdGJ5KSkgewpAQCAtNzY3LDcgKzc2OCw3IEBAIHN0 YXRpYyBpbnQgbm9vbjAxMF9wcm9iZShzdHJ1Y3QgaTJjX2NsaWVudCAqY2xpZW50LAogCQkJZ290 byBucF9lcnI7CiAJCX0KIAkJaW5mby0+Z3Bpb19uc3RieSA9IHBkYXRhLT5ncGlvX25zdGJ5Owot CQlncGlvX2V4cG9ydChpbmZvLT5ncGlvX25zdGJ5LCAwKTsKKwkJZ3Bpb2RfZXhwb3J0KGdwaW9f dG9fZGVzYyhpbmZvLT5ncGlvX25zdGJ5KSwgMCk7CiAJfQogCiAJZm9yIChpID0gMDsgaSA8IE5P T04wMTBfTlVNX1NVUFBMSUVTOyBpKyspCmRpZmYgLS1naXQgYS9kcml2ZXJzL21lZGlhL2kyYy9v djk2NTAuYyBiL2RyaXZlcnMvbWVkaWEvaTJjL292OTY1MC5jCmluZGV4IGMzMTNlMTFhOTc1NC4u MDIxYWNkMjBlZGUyIDEwMDY0NAotLS0gYS9kcml2ZXJzL21lZGlhL2kyYy9vdjk2NTAuYworKysg Yi9kcml2ZXJzL21lZGlhL2kyYy9vdjk2NTAuYwpAQCAtMTQyNiw5ICsxNDI2LDkgQEAgc3RhdGlj IGludCBvdjk2NXhfY29uZmlndXJlX2dwaW9zX3BkYXRhKHN0cnVjdCBvdjk2NXggKm92OTY1eCwK IAkJCXJldHVybiByZXQ7CiAJCXY0bDJfZGJnKDEsIGRlYnVnLCAmb3Y5NjV4LT5zZCwgInNldCBn cGlvICVkIHRvIDFcbiIsIGdwaW8pOwogCi0JCWdwaW9fc2V0X3ZhbHVlX2NhbnNsZWVwKGdwaW8s IDEpOwotCQlncGlvX2V4cG9ydChncGlvLCAwKTsKIAkJb3Y5NjV4LT5ncGlvc1tpXSA9IGdwaW9f dG9fZGVzYyhncGlvKTsKKwkJZ3Bpb2Rfc2V0X3ZhbHVlX2NhbnNsZWVwKG92OTY1eC0+Z3Bpb3Nb aV0sIDEpOworCQlncGlvZF9leHBvcnQob3Y5NjV4LT5ncGlvc1tpXSwgMCk7CiAJfQogCiAJcmV0 dXJuIDA7CmRpZmYgLS1naXQgYS9kcml2ZXJzL21lZGlhL2kyYy9zNWs0ZWNneC5jIGIvZHJpdmVy cy9tZWRpYS9pMmMvczVrNGVjZ3guYwppbmRleCBhZjlhMzA1MjQyY2QuLjQxOWQwM2ZjYzk3OCAx MDA2NDQKLS0tIGEvZHJpdmVycy9tZWRpYS9pMmMvczVrNGVjZ3guYworKysgYi9kcml2ZXJzL21l ZGlhL2kyYy9zNWs0ZWNneC5jCkBAIC0xNSw2ICsxNSw3IEBACiAjaW5jbHVkZSA8bGludXgvY3R5 cGUuaD4KICNpbmNsdWRlIDxsaW51eC9kZWxheS5oPgogI2luY2x1ZGUgPGxpbnV4L2Zpcm13YXJl Lmg+CisjaW5jbHVkZSA8bGludXgvZ3Bpby9jb25zdW1lci5oPgogI2luY2x1ZGUgPGxpbnV4L2dw aW8uaD4KICNpbmNsdWRlIDxsaW51eC9pMmMuaD4KICNpbmNsdWRlIDxsaW51eC9tb2R1bGUuaD4K QEAgLTg1Miw3ICs4NTMsNyBAQCBzdGF0aWMgaW50IHM1azRlY2d4X2NvbmZpZ19ncGlvKGludCBu ciwgaW50IHZhbCwgY29uc3QgY2hhciAqbmFtZSkKIAkJcmV0dXJuIDA7CiAJcmV0ID0gZ3Bpb19y ZXF1ZXN0X29uZShuciwgZmxhZ3MsIG5hbWUpOwogCWlmICghcmV0KQotCQlncGlvX2V4cG9ydChu ciwgMCk7CisJCWdwaW9kX2V4cG9ydChncGlvX3RvX2Rlc2MobnIpLCAwKTsKIAogCXJldHVybiBy ZXQ7CiB9CmRpZmYgLS1naXQgYS9kcml2ZXJzL21lZGlhL3BjaS9zdGEyeDExL3N0YTJ4MTFfdmlw LmMgYi9kcml2ZXJzL21lZGlhL3BjaS9zdGEyeDExL3N0YTJ4MTFfdmlwLmMKaW5kZXggNTI0OTEy ZjIwZDlmLi5mN2NlZjU5OGYyMWQgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbWVkaWEvcGNpL3N0YTJ4 MTEvc3RhMngxMV92aXAuYworKysgYi9kcml2ZXJzL21lZGlhL3BjaS9zdGEyeDExL3N0YTJ4MTFf dmlwLmMKQEAgLTE4LDYgKzE4LDcgQEAKICNpbmNsdWRlIDxsaW51eC9wY2kuaD4KICNpbmNsdWRl IDxsaW51eC9pbnRlcnJ1cHQuaD4KICNpbmNsdWRlIDxsaW51eC9pby5oPgorI2luY2x1ZGUgPGxp bnV4L2dwaW8vY29uc3VtZXIuaD4KICNpbmNsdWRlIDxsaW51eC9ncGlvLmg+CiAjaW5jbHVkZSA8 bGludXgvaTJjLmg+CiAjaW5jbHVkZSA8bGludXgvZGVsYXkuaD4KQEAgLTg5Myw2ICs4OTQsNyBA QCBzdGF0aWMgaW50IHN0YTJ4MTFfdmlwX2luaXRfY29udHJvbHMoc3RydWN0IHN0YTJ4MTFfdmlw ICp2aXApCiBzdGF0aWMgaW50IHZpcF9ncGlvX3Jlc2VydmUoc3RydWN0IGRldmljZSAqZGV2LCBp bnQgcGluLCBpbnQgZGlyLAogCQkJICAgIGNvbnN0IGNoYXIgKm5hbWUpCiB7CisJc3RydWN0IGdw aW9fZGVzYyAqZGVzYyA9IGdwaW9fdG9fZGVzYyhwaW4pOwogCWludCByZXQgPSAtRU5PREVWOwog CiAJaWYgKCFncGlvX2lzX3ZhbGlkKHBpbikpCkBAIC05MDQsNyArOTA2LDcgQEAgc3RhdGljIGlu dCB2aXBfZ3Bpb19yZXNlcnZlKHN0cnVjdCBkZXZpY2UgKmRldiwgaW50IHBpbiwgaW50IGRpciwK IAkJcmV0dXJuIHJldDsKIAl9CiAKLQlyZXQgPSBncGlvX2RpcmVjdGlvbl9vdXRwdXQocGluLCBk aXIpOworCXJldCA9IGdwaW9kX2RpcmVjdGlvbl9vdXRwdXQoZGVzYywgZGlyKTsKIAlpZiAocmV0 KSB7CiAJCWRldl9lcnIoZGV2LCAiRmFpbGVkIHRvIHNldCBkaXJlY3Rpb24gZm9yIHBpbiAlZCAo JXMpXG4iLAogCQkJcGluLCBuYW1lKTsKQEAgLTkxMiw3ICs5MTQsNyBAQCBzdGF0aWMgaW50IHZp cF9ncGlvX3Jlc2VydmUoc3RydWN0IGRldmljZSAqZGV2LCBpbnQgcGluLCBpbnQgZGlyLAogCQly ZXR1cm4gcmV0OwogCX0KIAotCXJldCA9IGdwaW9fZXhwb3J0KHBpbiwgZmFsc2UpOworCXJldCA9 IGdwaW9kX2V4cG9ydChkZXNjLCBmYWxzZSk7CiAJaWYgKHJldCkgewogCQlkZXZfZXJyKGRldiwg IkZhaWxlZCB0byBleHBvcnQgcGluICVkICglcylcbiIsIHBpbiwgbmFtZSk7CiAJCWdwaW9fZnJl ZShwaW4pOwpAQCAtOTMyLDggKzkzNCwxMCBAQCBzdGF0aWMgaW50IHZpcF9ncGlvX3Jlc2VydmUo c3RydWN0IGRldmljZSAqZGV2LCBpbnQgcGluLCBpbnQgZGlyLAogc3RhdGljIHZvaWQgdmlwX2dw aW9fcmVsZWFzZShzdHJ1Y3QgZGV2aWNlICpkZXYsIGludCBwaW4sIGNvbnN0IGNoYXIgKm5hbWUp CiB7CiAJaWYgKGdwaW9faXNfdmFsaWQocGluKSkgeworCQlzdHJ1Y3QgZ3Bpb19kZXNjICpkZXNj ID0gZ3Bpb190b19kZXNjKHBpbik7CisKIAkJZGV2X2RiZyhkZXYsICJyZWxlYXNpbmcgcGluICVk ICglcylcbiIsCXBpbiwgbmFtZSk7Ci0JCWdwaW9fdW5leHBvcnQocGluKTsKKwkJZ3Bpb2RfdW5l eHBvcnQoZGVzYyk7CiAJCWdwaW9fZnJlZShwaW4pOwogCX0KIH0KZGlmZiAtLWdpdCBhL2RyaXZl cnMvbWZkL2RtMzU1ZXZtX21zcC5jIGIvZHJpdmVycy9tZmQvZG0zNTVldm1fbXNwLmMKaW5kZXgg NTRmYjZjYmQyYWEwLi4yMzg4ZmI0ZDAxMjEgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbWZkL2RtMzU1 ZXZtX21zcC5jCisrKyBiL2RyaXZlcnMvbWZkL2RtMzU1ZXZtX21zcC5jCkBAIC0xMSw2ICsxMSw3 IEBACiAjaW5jbHVkZSA8bGludXgvY2xrLmg+CiAjaW5jbHVkZSA8bGludXgvbW9kdWxlLmg+CiAj aW5jbHVkZSA8bGludXgvZXJyLmg+CisjaW5jbHVkZSA8bGludXgvZ3Bpby9jb25zdW1lci5oPgog I2luY2x1ZGUgPGxpbnV4L2dwaW8uaD4KICNpbmNsdWRlIDxsaW51eC9ncGlvL21hY2hpbmUuaD4K ICNpbmNsdWRlIDxsaW51eC9sZWRzLmg+CkBAIC0zMjksNyArMzMwLDcgQEAgc3RhdGljIGludCBh ZGRfY2hpbGRyZW4oc3RydWN0IGkyY19jbGllbnQgKmNsaWVudCkKIAkJZ3Bpb19yZXF1ZXN0X29u ZShncGlvLCBHUElPRl9JTiwgY29uZmlnX2lucHV0c1tpXS5sYWJlbCk7CiAKIAkJLyogbWFrZSBp dCBlYXN5IGZvciB1c2Vyc3BhY2UgdG8gc2VlIHRoZXNlICovCi0JCWdwaW9fZXhwb3J0KGdwaW8s IGZhbHNlKTsKKwkJZ3Bpb2RfZXhwb3J0KGdwaW9fdG9fZGVzYyhncGlvKSwgZmFsc2UpOwogCX0K IAogCS8qIE1NQy9TRCBpbnB1dHMgLS0gcmlnaHQgYWZ0ZXIgdGhlIGxhc3QgY29uZmlnIGlucHV0 ICovCmRpZmYgLS1naXQgYS9kcml2ZXJzL25ldC9pZWVlODAyMTU0L2NhODIxMC5jIGIvZHJpdmVy cy9uZXQvaWVlZTgwMjE1NC9jYTgyMTAuYwppbmRleCBlY2U2ZmY2MDQ5ZjYuLjYyNTI5MDdiMmM5 MiAxMDA2NDQKLS0tIGEvZHJpdmVycy9uZXQvaWVlZTgwMjE1NC9jYTgyMTAuYworKysgYi9kcml2 ZXJzL25ldC9pZWVlODAyMTU0L2NhODIxMC5jCkBAIC01MSw2ICs1MSw3IEBACiAjaW5jbHVkZSA8 bGludXgvY2xrLXByb3ZpZGVyLmg+CiAjaW5jbHVkZSA8bGludXgvZGVidWdmcy5oPgogI2luY2x1 ZGUgPGxpbnV4L2RlbGF5Lmg+CisjaW5jbHVkZSA8bGludXgvZ3Bpby9jb25zdW1lci5oPgogI2lu Y2x1ZGUgPGxpbnV4L2dwaW8uaD4KICNpbmNsdWRlIDxsaW51eC9pZWVlODAyMTU0Lmg+CiAjaW5j bHVkZSA8bGludXgvaW8uaD4KQEAgLTI4OTUsNyArMjg5Niw3IEBAIHN0YXRpYyBpbnQgY2E4MjEw X2ludGVycnVwdF9pbml0KHN0cnVjdCBzcGlfZGV2aWNlICpzcGkpCiAJKTsKIAlpZiAocmV0KSB7 CiAJCWRldl9jcml0KCZzcGktPmRldiwgInJlcXVlc3RfaXJxICVkIGZhaWxlZFxuIiwgcGRhdGEt PmlycV9pZCk7Ci0JCWdwaW9fdW5leHBvcnQocGRhdGEtPmdwaW9faXJxKTsKKwkJZ3Bpb2RfdW5l eHBvcnQoZ3Bpb190b19kZXNjKHBkYXRhLT5ncGlvX2lycSkpOwogCQlncGlvX2ZyZWUocGRhdGEt PmdwaW9faXJxKTsKIAl9CiAKZGlmZiAtLWdpdCBhL2luY2x1ZGUvbGludXgvZ3Bpby5oIGIvaW5j bHVkZS9saW51eC9ncGlvLmgKaW5kZXggNjRjYzhmMDllYmE4Li43Y2ViOTM2Nzg2ODkgMTAwNjQ0 Ci0tLSBhL2luY2x1ZGUvbGludXgvZ3Bpby5oCisrKyBiL2luY2x1ZGUvbGludXgvZ3Bpby5oCkBA IC0xNDQsMjYgKzE0NCw2IEBAIGV4dGVybiBpbnQgZ3Bpb19yZXF1ZXN0X29uZSh1bnNpZ25lZCBn cGlvLCB1bnNpZ25lZCBsb25nIGZsYWdzLCBjb25zdCBjaGFyICpsYWJlCiBleHRlcm4gaW50IGdw aW9fcmVxdWVzdF9hcnJheShjb25zdCBzdHJ1Y3QgZ3BpbyAqYXJyYXksIHNpemVfdCBudW0pOwog ZXh0ZXJuIHZvaWQgZ3Bpb19mcmVlX2FycmF5KGNvbnN0IHN0cnVjdCBncGlvICphcnJheSwgc2l6 ZV90IG51bSk7CiAKLS8qCi0gKiBBIHN5c2ZzIGludGVyZmFjZSBjYW4gYmUgZXhwb3J0ZWQgYnkg aW5kaXZpZHVhbCBkcml2ZXJzIGlmIHRoZXkgd2FudCwKLSAqIGJ1dCBtb3JlIHR5cGljYWxseSBp cyBjb25maWd1cmVkIGVudGlyZWx5IGZyb20gdXNlcnNwYWNlLgotICovCi1zdGF0aWMgaW5saW5l IGludCBncGlvX2V4cG9ydCh1bnNpZ25lZCBncGlvLCBib29sIGRpcmVjdGlvbl9tYXlfY2hhbmdl KQotewotCXJldHVybiBncGlvZF9leHBvcnQoZ3Bpb190b19kZXNjKGdwaW8pLCBkaXJlY3Rpb25f bWF5X2NoYW5nZSk7Ci19Ci0KLXN0YXRpYyBpbmxpbmUgaW50IGdwaW9fZXhwb3J0X2xpbmsoc3Ry dWN0IGRldmljZSAqZGV2LCBjb25zdCBjaGFyICpuYW1lLAotCQkJCSAgIHVuc2lnbmVkIGdwaW8p Ci17Ci0JcmV0dXJuIGdwaW9kX2V4cG9ydF9saW5rKGRldiwgbmFtZSwgZ3Bpb190b19kZXNjKGdw aW8pKTsKLX0KLQotc3RhdGljIGlubGluZSB2b2lkIGdwaW9fdW5leHBvcnQodW5zaWduZWQgZ3Bp bykKLXsKLQlncGlvZF91bmV4cG9ydChncGlvX3RvX2Rlc2MoZ3BpbykpOwotfQotCiAvKiBDT05G SUdfR1BJT0xJQjogYmluZGluZ3MgZm9yIG1hbmFnZWQgZGV2aWNlcyB0aGF0IHdhbnQgdG8gcmVx dWVzdCBncGlvcyAqLwogCiBzdHJ1Y3QgZGV2aWNlOwpAQCAtMjUzLDI3ICsyMzMsNiBAQCBzdGF0 aWMgaW5saW5lIHZvaWQgZ3Bpb19zZXRfdmFsdWVfY2Fuc2xlZXAodW5zaWduZWQgZ3BpbywgaW50 IHZhbHVlKQogCVdBUk5fT04oMSk7CiB9CiAKLXN0YXRpYyBpbmxpbmUgaW50IGdwaW9fZXhwb3J0 KHVuc2lnbmVkIGdwaW8sIGJvb2wgZGlyZWN0aW9uX21heV9jaGFuZ2UpCi17Ci0JLyogR1BJTyBj YW4gbmV2ZXIgaGF2ZSBiZWVuIHJlcXVlc3RlZCBvciBzZXQgYXMge2luLG91dH1wdXQgKi8KLQlX QVJOX09OKDEpOwotCXJldHVybiAtRUlOVkFMOwotfQotCi1zdGF0aWMgaW5saW5lIGludCBncGlv X2V4cG9ydF9saW5rKHN0cnVjdCBkZXZpY2UgKmRldiwgY29uc3QgY2hhciAqbmFtZSwKLQkJCQl1 bnNpZ25lZCBncGlvKQotewotCS8qIEdQSU8gY2FuIG5ldmVyIGhhdmUgYmVlbiBleHBvcnRlZCAq LwotCVdBUk5fT04oMSk7Ci0JcmV0dXJuIC1FSU5WQUw7Ci19Ci0KLXN0YXRpYyBpbmxpbmUgdm9p ZCBncGlvX3VuZXhwb3J0KHVuc2lnbmVkIGdwaW8pCi17Ci0JLyogR1BJTyBjYW4gbmV2ZXIgaGF2 ZSBiZWVuIGV4cG9ydGVkICovCi0JV0FSTl9PTigxKTsKLX0KLQogc3RhdGljIGlubGluZSBpbnQg Z3Bpb190b19pcnEodW5zaWduZWQgZ3BpbykKIHsKIAkvKiBHUElPIGNhbiBuZXZlciBoYXZlIGJl ZW4gcmVxdWVzdGVkIG9yIHNldCBhcyBpbnB1dCAqLwotLSAKMi4yOS4yCgoKX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX18KbGludXgtYXJtLWtlcm5lbCBtYWls aW5nIGxpc3QKbGludXgtYXJtLWtlcm5lbEBsaXN0cy5pbmZyYWRlYWQub3JnCmh0dHA6Ly9saXN0 cy5pbmZyYWRlYWQub3JnL21haWxtYW4vbGlzdGluZm8vbGludXgtYXJtLWtlcm5lbAo=