From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.1 (2015-04-28) on archive.lwn.net X-Spam-Level: X-Spam-Status: No, score=-5.8 required=5.0 tests=DKIM_SIGNED,DKIM_VALID, DKIM_VALID_AU,FREEMAIL_FORGED_FROMDOMAIN,FREEMAIL_FROM, HEADER_FROM_DIFFERENT_DOMAINS,MAILING_LIST_MULTI,RCVD_IN_DNSWL_HI autolearn=unavailable autolearn_force=no version=3.4.1 Received: from vger.kernel.org (vger.kernel.org [209.132.180.67]) by archive.lwn.net (Postfix) with ESMTP id 0DC707DE78 for ; Sun, 2 Sep 2018 12:01:53 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1727248AbeIBQRD (ORCPT ); Sun, 2 Sep 2018 12:17:03 -0400 Received: from mail-lf1-f67.google.com ([209.85.167.67]:36937 "EHLO mail-lf1-f67.google.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1726014AbeIBQRD (ORCPT ); Sun, 2 Sep 2018 12:17:03 -0400 Received: by mail-lf1-f67.google.com with SMTP id j8-v6so13140613lfb.4; Sun, 02 Sep 2018 05:01:26 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20161025; h=from:to:cc:subject:date:message-id:in-reply-to:references :mime-version:content-transfer-encoding; bh=HUP8hVZZHfnZdGxwxdQ4hnKRy6Ys9kDZ7ORt5poUXFA=; b=JRG5MHaq6/MajsNMmqdMnfnkkbkT6EctCJxvfcR/Q7fZkqhEWRHTmvcJiR6rEDaytR 8qtFpeWa1blfJfb/lZ59ddjkT8aLO5hlT9kwsaJWMynvUEr596A3bLtWKHOwg3m9JcIZ hvS+bWCMxA2zUs0TawpeZGJuefIcdCO0OtGAH7/I/HjT7hIaafILNYG2XmZc/C00EV9c zWBYHEfvPTJ9P7uDTZoBws8Sb4+c8h0p2hSqYbtHTNtNDFhqrnAK1OC4fISqQuhREmNe pCNSCbyZgNjlupac6oAqBXKvy2Ox82N0vd9tzZO3k5UITXqHeUjFpkyesmYGCxQro4pZ xIAA== 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=HUP8hVZZHfnZdGxwxdQ4hnKRy6Ys9kDZ7ORt5poUXFA=; b=m4d+TCe1a2tZch9pSeoVh+MKKNcQYUiSL0E7tMCrZzTjq9KwxzGlIuF+2HfvCfsEhj x/5GtkIeTOi8Nh9SRamUkV/5EpHbaZ1v/CqpqDtvBz7lh5LLuPW8dwOurJbIg4er+3LC wMl20xLbhbLxXTfcLa7IFpHxsdeA6oVGSp7n3exQjen9gkJmZ/Kx5i97EdWq6eszd/hp x2GrT0dsp6iP7FcRo5o7/xwkUKVtEbeOpaOFvZN+82NAV39qrE06Ey1GkT8dvEhhX9HZ GYQ1vqsNB5yyP/wS8CVd60oaAGjBwk4sSiWcJR8decQUu7wKdqMVNekkvLq6YEGx/qQj vFYw== X-Gm-Message-State: APzg51BxmIju788c1O0gtzTbp6fnY41yj+U6RKAhoBVrsKDsonkkrX28 +waPvr9H5Io3J1amXV1li4g= X-Google-Smtp-Source: ANB0VdaZnbhD4fCuuUjejCPzAtXkuvI+WK6xsqsUl5OxdyuEYOuxRk5m5tPLHIsvpB4hIQQpbw2HLQ== X-Received: by 2002:a19:11d1:: with SMTP id 78-v6mr14736952lfr.25.1535889685861; Sun, 02 Sep 2018 05:01:25 -0700 (PDT) Received: from localhost.localdomain (apn-37-248-210-194.dynamic.gprs.plus.pl. [37.248.210.194]) by smtp.gmail.com with ESMTPSA id n3-v6sm2760321lji.96.2018.09.02.05.01.15 (version=TLS1_2 cipher=ECDHE-RSA-AES128-GCM-SHA256 bits=128/128); Sun, 02 Sep 2018 05:01:25 -0700 (PDT) From: Janusz Krzysztofik To: Linus Walleij Cc: Jonathan Corbet , Miguel Ojeda Sandonis , Peter Korsgaard , Peter Rosin , Ulf Hansson , Andrew Lunn , Florian Fainelli , "David S. Miller" , Dominik Brodowski , Greg Kroah-Hartman , Kishon Vijay Abraham I , Lars-Peter Clausen , Michael Hennerich , Jonathan Cameron , Hartmut Knaack , Peter Meerwald-Stadler , Jiri Slaby , Willy Tarreau , Geert Uytterhoeven , linux-doc@vger.kernel.org, linux-i2c@vger.kernel.org, linux-mmc@vger.kernel.org, netdev@vger.kernel.org, linux-iio@vger.kernel.org, devel@driverdev.osuosl.org, linux-serial@vger.kernel.org, linux-gpio@vger.kernel.org, linux-kernel@vger.kernel.org, Janusz Krzysztofik , Sebastien Bourdelin , Lukas Wunner , Rojhalat Ibrahim , Russell King , Tony Lindgren , Yegor Yefremov , =?UTF-8?q?Uwe=20Kleine-K=C3=B6nig?= Subject: [PATCH v7 3/4] gpiolib: Pass array info to get/set array functions Date: Sun, 2 Sep 2018 14:01:43 +0200 Message-Id: <20180902120144.6855-4-jmkrzyszt@gmail.com> X-Mailer: git-send-email 2.16.4 In-Reply-To: <20180902120144.6855-1-jmkrzyszt@gmail.com> References: <20180831225616.29221-1-jmkrzyszt@gmail.com> <20180902120144.6855-1-jmkrzyszt@gmail.com> MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Sender: linux-doc-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: linux-doc@vger.kernel.org In order to make use of array info obtained from gpiod_get_array() and speed up processing of arrays matching single GPIO chip layout, that information must be passed to get/set array functions. Extend the functions' API with that additional parameter and update all users. Pass NULL if a user bulids an array itself from single GPIOs. Cc: Jonathan Corbet Cc: Miguel Ojeda Sandonis Cc: Geert Uytterhoeven Cc: Sebastien Bourdelin Cc: Lukas Wunner Cc: Peter Korsgaard Cc: Peter Rosin Cc: Andrew Lunn Cc: Florian Fainelli Cc: "David S. Miller" Cc: Rojhalat Ibrahim Cc: Dominik Brodowski Cc: Russell King Cc: Kishon Vijay Abraham I Cc: Tony Lindgren Cc: Lars-Peter Clausen Cc: Michael Hennerich Cc: Jonathan Cameron Cc: Hartmut Knaack Cc: Peter Meerwald-Stadler Cc: Greg Kroah-Hartman Cc: Jiri Slaby Cc: Yegor Yefremov Cc: Uwe Kleine-König Signed-off-by: Janusz Krzysztofik Acked-by: Ulf Hansson --- Documentation/driver-api/gpio/consumer.rst | 14 +++++++++++-- drivers/auxdisplay/hd44780.c | 8 ++++---- drivers/bus/ts-nbus.c | 5 +++-- drivers/gpio/gpio-max3191x.c | 6 ++++-- drivers/gpio/gpiolib.c | 32 +++++++++++++++++++++-------- drivers/gpio/gpiolib.h | 2 ++ drivers/i2c/muxes/i2c-mux-gpio.c | 3 ++- drivers/mmc/core/pwrseq_simple.c | 2 +- drivers/mux/gpio.c | 3 ++- drivers/net/phy/mdio-mux-gpio.c | 2 +- drivers/pcmcia/soc_common.c | 2 +- drivers/phy/motorola/phy-mapphone-mdm6600.c | 4 +++- drivers/staging/iio/adc/ad7606.c | 3 ++- drivers/tty/serial/serial_mctrl_gpio.c | 2 +- include/linux/gpio/consumer.h | 8 ++++++++ 15 files changed, 70 insertions(+), 26 deletions(-) diff --git a/Documentation/driver-api/gpio/consumer.rst b/Documentation/driver-api/gpio/consumer.rst index 7e0298b9a7b9..0afd95a12b10 100644 --- a/Documentation/driver-api/gpio/consumer.rst +++ b/Documentation/driver-api/gpio/consumer.rst @@ -325,28 +325,36 @@ The following functions get or set the values of an array of GPIOs:: int gpiod_get_array_value(unsigned int array_size, struct gpio_desc **desc_array, + struct gpio_array *array_info, unsigned long *value_bitmap); int gpiod_get_raw_array_value(unsigned int array_size, struct gpio_desc **desc_array, + struct gpio_array *array_info, unsigned long *value_bitmap); int gpiod_get_array_value_cansleep(unsigned int array_size, struct gpio_desc **desc_array, + struct gpio_array *array_info, unsigned long *value_bitmap); int gpiod_get_raw_array_value_cansleep(unsigned int array_size, struct gpio_desc **desc_array, + struct gpio_array *array_info, unsigned long *value_bitmap); void gpiod_set_array_value(unsigned int array_size, struct gpio_desc **desc_array, + struct gpio_array *array_info, unsigned long *value_bitmap) void gpiod_set_raw_array_value(unsigned int array_size, struct gpio_desc **desc_array, + struct gpio_array *array_info, unsigned long *value_bitmap) void gpiod_set_array_value_cansleep(unsigned int array_size, struct gpio_desc **desc_array, + struct gpio_array *array_info, unsigned long *value_bitmap) void gpiod_set_raw_array_value_cansleep(unsigned int array_size, struct gpio_desc **desc_array, + struct gpio_array *array_info, unsigned long *value_bitmap) The array can be an arbitrary set of GPIOs. The functions will try to access @@ -358,6 +366,7 @@ accessed sequentially. The functions take three arguments: * array_size - the number of array elements * desc_array - an array of GPIO descriptors + * array_info - optional information obtained from gpiod_array_get() * value_bitmap - a bitmap to store the GPIOs' values (get) or a bitmap of values to assign to the GPIOs (set) @@ -368,12 +377,13 @@ the struct gpio_descs returned by gpiod_get_array():: struct gpio_descs *my_gpio_descs = gpiod_get_array(...); gpiod_set_array_value(my_gpio_descs->ndescs, my_gpio_descs->desc, - my_gpio_value_bitmap); + my_gpio_descs->info, my_gpio_value_bitmap); It is also possible to access a completely arbitrary array of descriptors. The descriptors may be obtained using any combination of gpiod_get() and gpiod_get_array(). Afterwards the array of descriptors has to be setup -manually before it can be passed to one of the above functions. +manually before it can be passed to one of the above functions. In that case, +array_info should be set to NULL. Note that for optimal performance GPIOs belonging to the same chip should be contiguous within the array of descriptors. diff --git a/drivers/auxdisplay/hd44780.c b/drivers/auxdisplay/hd44780.c index 333e30e378b5..033024df3962 100644 --- a/drivers/auxdisplay/hd44780.c +++ b/drivers/auxdisplay/hd44780.c @@ -70,7 +70,7 @@ static void hd44780_write_gpio8(struct hd44780 *hd, u8 val, unsigned int rs) n = hd->pins[PIN_CTRL_RW] ? 10 : 9; /* Present the data to the port */ - gpiod_set_array_value_cansleep(n, &hd->pins[PIN_DATA0], values); + gpiod_set_array_value_cansleep(n, &hd->pins[PIN_DATA0], NULL, values); hd44780_strobe_gpio(hd); } @@ -87,7 +87,7 @@ static void hd44780_write_gpio4(struct hd44780 *hd, u8 val, unsigned int rs) n = hd->pins[PIN_CTRL_RW] ? 6 : 5; /* Present the data to the port */ - gpiod_set_array_value_cansleep(n, &hd->pins[PIN_DATA4], values); + gpiod_set_array_value_cansleep(n, &hd->pins[PIN_DATA4], NULL, values); hd44780_strobe_gpio(hd); @@ -96,7 +96,7 @@ static void hd44780_write_gpio4(struct hd44780 *hd, u8 val, unsigned int rs) *values |= val & 0x0f; /* Present the data to the port */ - gpiod_set_array_value_cansleep(n, &hd->pins[PIN_DATA4], values); + gpiod_set_array_value_cansleep(n, &hd->pins[PIN_DATA4], NULL, values); hd44780_strobe_gpio(hd); } @@ -152,7 +152,7 @@ static void hd44780_write_cmd_raw_gpio4(struct charlcd *lcd, int cmd) n = hd->pins[PIN_CTRL_RW] ? 6 : 5; /* Present the data to the port */ - gpiod_set_array_value_cansleep(n, &hd->pins[PIN_DATA4], values); + gpiod_set_array_value_cansleep(n, &hd->pins[PIN_DATA4], NULL, values); hd44780_strobe_gpio(hd); } diff --git a/drivers/bus/ts-nbus.c b/drivers/bus/ts-nbus.c index 6499957a8044..60796f2db6fc 100644 --- a/drivers/bus/ts-nbus.c +++ b/drivers/bus/ts-nbus.c @@ -114,7 +114,8 @@ static void ts_nbus_reset_bus(struct ts_nbus *ts_nbus) *values = 0; - gpiod_set_array_value_cansleep(8, ts_nbus->data->desc, values); + gpiod_set_array_value_cansleep(8, ts_nbus->data->desc, + ts_nbus->data->info, values); gpiod_set_value_cansleep(ts_nbus->csn, 0); gpiod_set_value_cansleep(ts_nbus->strobe, 0); gpiod_set_value_cansleep(ts_nbus->ale, 0); @@ -159,7 +160,7 @@ static void ts_nbus_write_byte(struct ts_nbus *ts_nbus, u8 byte) *values = byte; - gpiod_set_array_value_cansleep(8, gpios->desc, values); + gpiod_set_array_value_cansleep(8, gpios->desc, gpios->info, values); } /* diff --git a/drivers/gpio/gpio-max3191x.c b/drivers/gpio/gpio-max3191x.c index bd4a245fc5a0..9a8876abeb57 100644 --- a/drivers/gpio/gpio-max3191x.c +++ b/drivers/gpio/gpio-max3191x.c @@ -313,6 +313,7 @@ static int max3191x_set_config(struct gpio_chip *gpio, unsigned int offset, static void gpiod_set_array_single_value_cansleep(unsigned int ndescs, struct gpio_desc **desc, + struct gpio_array *info, int value) { unsigned long *values; @@ -326,7 +327,7 @@ static void gpiod_set_array_single_value_cansleep(unsigned int ndescs, else bitmap_zero(values, ndescs); - gpiod_set_array_value_cansleep(ndescs, desc, values); + gpiod_set_array_value_cansleep(ndescs, desc, info, values); kfree(values); } @@ -399,7 +400,8 @@ static int max3191x_probe(struct spi_device *spi) if (max3191x->modesel_pins) gpiod_set_array_single_value_cansleep( max3191x->modesel_pins->ndescs, - max3191x->modesel_pins->desc, max3191x->mode); + max3191x->modesel_pins->desc, + max3191x->modesel_pins->info, max3191x->mode); max3191x->ignore_uv = device_property_read_bool(dev, "maxim,ignore-undervoltage"); diff --git a/drivers/gpio/gpiolib.c b/drivers/gpio/gpiolib.c index 141f2f290538..cef6ee31fe05 100644 --- a/drivers/gpio/gpiolib.c +++ b/drivers/gpio/gpiolib.c @@ -436,6 +436,7 @@ static long linehandle_ioctl(struct file *filep, unsigned int cmd, true, lh->numdescs, lh->descs, + NULL, vals); if (ret) return ret; @@ -468,6 +469,7 @@ static long linehandle_ioctl(struct file *filep, unsigned int cmd, true, lh->numdescs, lh->descs, + NULL, vals); } return -EINVAL; @@ -2784,6 +2786,7 @@ static int gpio_chip_get_multiple(struct gpio_chip *chip, int gpiod_get_array_value_complex(bool raw, bool can_sleep, unsigned int array_size, struct gpio_desc **desc_array, + struct gpio_array *array_info, unsigned long *value_bitmap) { int i = 0; @@ -2908,12 +2911,14 @@ EXPORT_SYMBOL_GPL(gpiod_get_value); */ int gpiod_get_raw_array_value(unsigned int array_size, struct gpio_desc **desc_array, + struct gpio_array *array_info, unsigned long *value_bitmap) { if (!desc_array) return -EINVAL; return gpiod_get_array_value_complex(true, false, array_size, - desc_array, value_bitmap); + desc_array, array_info, + value_bitmap); } EXPORT_SYMBOL_GPL(gpiod_get_raw_array_value); @@ -2931,12 +2936,14 @@ EXPORT_SYMBOL_GPL(gpiod_get_raw_array_value); */ int gpiod_get_array_value(unsigned int array_size, struct gpio_desc **desc_array, + struct gpio_array *array_info, unsigned long *value_bitmap) { if (!desc_array) return -EINVAL; return gpiod_get_array_value_complex(false, false, array_size, - desc_array, value_bitmap); + desc_array, array_info, + value_bitmap); } EXPORT_SYMBOL_GPL(gpiod_get_array_value); @@ -3029,6 +3036,7 @@ static void gpio_chip_set_multiple(struct gpio_chip *chip, int gpiod_set_array_value_complex(bool raw, bool can_sleep, unsigned int array_size, struct gpio_desc **desc_array, + struct gpio_array *array_info, unsigned long *value_bitmap) { int i = 0; @@ -3166,12 +3174,13 @@ EXPORT_SYMBOL_GPL(gpiod_set_value); */ int gpiod_set_raw_array_value(unsigned int array_size, struct gpio_desc **desc_array, + struct gpio_array *array_info, unsigned long *value_bitmap) { if (!desc_array) return -EINVAL; return gpiod_set_array_value_complex(true, false, array_size, - desc_array, value_bitmap); + desc_array, array_info, value_bitmap); } EXPORT_SYMBOL_GPL(gpiod_set_raw_array_value); @@ -3189,12 +3198,13 @@ EXPORT_SYMBOL_GPL(gpiod_set_raw_array_value); */ void gpiod_set_array_value(unsigned int array_size, struct gpio_desc **desc_array, + struct gpio_array *array_info, unsigned long *value_bitmap) { if (!desc_array) return; gpiod_set_array_value_complex(false, false, array_size, desc_array, - value_bitmap); + array_info, value_bitmap); } EXPORT_SYMBOL_GPL(gpiod_set_array_value); @@ -3426,13 +3436,15 @@ EXPORT_SYMBOL_GPL(gpiod_get_value_cansleep); */ int gpiod_get_raw_array_value_cansleep(unsigned int array_size, struct gpio_desc **desc_array, + struct gpio_array *array_info, unsigned long *value_bitmap) { might_sleep_if(extra_checks); if (!desc_array) return -EINVAL; return gpiod_get_array_value_complex(true, true, array_size, - desc_array, value_bitmap); + desc_array, array_info, + value_bitmap); } EXPORT_SYMBOL_GPL(gpiod_get_raw_array_value_cansleep); @@ -3449,13 +3461,15 @@ EXPORT_SYMBOL_GPL(gpiod_get_raw_array_value_cansleep); */ int gpiod_get_array_value_cansleep(unsigned int array_size, struct gpio_desc **desc_array, + struct gpio_array *array_info, unsigned long *value_bitmap) { might_sleep_if(extra_checks); if (!desc_array) return -EINVAL; return gpiod_get_array_value_complex(false, true, array_size, - desc_array, value_bitmap); + desc_array, array_info, + value_bitmap); } EXPORT_SYMBOL_GPL(gpiod_get_array_value_cansleep); @@ -3508,13 +3522,14 @@ EXPORT_SYMBOL_GPL(gpiod_set_value_cansleep); */ int gpiod_set_raw_array_value_cansleep(unsigned int array_size, struct gpio_desc **desc_array, + struct gpio_array *array_info, unsigned long *value_bitmap) { might_sleep_if(extra_checks); if (!desc_array) return -EINVAL; return gpiod_set_array_value_complex(true, true, array_size, desc_array, - value_bitmap); + array_info, value_bitmap); } EXPORT_SYMBOL_GPL(gpiod_set_raw_array_value_cansleep); @@ -3548,13 +3563,14 @@ void gpiod_add_lookup_tables(struct gpiod_lookup_table **tables, size_t n) */ void gpiod_set_array_value_cansleep(unsigned int array_size, struct gpio_desc **desc_array, + struct gpio_array *array_info, unsigned long *value_bitmap) { might_sleep_if(extra_checks); if (!desc_array) return; gpiod_set_array_value_complex(false, true, array_size, desc_array, - value_bitmap); + array_info, value_bitmap); } EXPORT_SYMBOL_GPL(gpiod_set_array_value_cansleep); diff --git a/drivers/gpio/gpiolib.h b/drivers/gpio/gpiolib.h index b60905d558b1..b65ca896b24d 100644 --- a/drivers/gpio/gpiolib.h +++ b/drivers/gpio/gpiolib.h @@ -196,10 +196,12 @@ struct gpio_desc *gpiochip_get_desc(struct gpio_chip *chip, u16 hwnum); int gpiod_get_array_value_complex(bool raw, bool can_sleep, unsigned int array_size, struct gpio_desc **desc_array, + struct gpio_array *array_info, unsigned long *value_bitmap); int gpiod_set_array_value_complex(bool raw, bool can_sleep, unsigned int array_size, struct gpio_desc **desc_array, + struct gpio_array *array_info, unsigned long *value_bitmap); /* This is just passed between gpiolib and devres */ diff --git a/drivers/i2c/muxes/i2c-mux-gpio.c b/drivers/i2c/muxes/i2c-mux-gpio.c index 0717cfb56732..c6e1c7776a56 100644 --- a/drivers/i2c/muxes/i2c-mux-gpio.c +++ b/drivers/i2c/muxes/i2c-mux-gpio.c @@ -30,7 +30,8 @@ static void i2c_mux_gpio_set(const struct gpiomux *mux, unsigned val) *values = val; - gpiod_set_array_value_cansleep(mux->data.n_gpios, mux->gpios, values); + gpiod_set_array_value_cansleep(mux->data.n_gpios, mux->gpios, NULL, + values); } static int i2c_mux_gpio_select(struct i2c_mux_core *muxc, u32 chan) diff --git a/drivers/mmc/core/pwrseq_simple.c b/drivers/mmc/core/pwrseq_simple.c index 5ad764c88b50..a17252f51418 100644 --- a/drivers/mmc/core/pwrseq_simple.c +++ b/drivers/mmc/core/pwrseq_simple.c @@ -46,7 +46,7 @@ static void mmc_pwrseq_simple_set_gpios_value(struct mmc_pwrseq_simple *pwrseq, *values = value; gpiod_set_array_value_cansleep(nvalues, reset_gpios->desc, - values); + reset_gpios->info, values); } } diff --git a/drivers/mux/gpio.c b/drivers/mux/gpio.c index 1b6b4cc22a2c..4f58a3198c4e 100644 --- a/drivers/mux/gpio.c +++ b/drivers/mux/gpio.c @@ -27,7 +27,8 @@ static int mux_gpio_set(struct mux_control *mux, int state) *values = state; gpiod_set_array_value_cansleep(mux_gpio->gpios->ndescs, - mux_gpio->gpios->desc, values); + mux_gpio->gpios->desc, + mux_gpio->gpios->info, values); return 0; } diff --git a/drivers/net/phy/mdio-mux-gpio.c b/drivers/net/phy/mdio-mux-gpio.c index eb8c56b83c70..7d8bea21f099 100644 --- a/drivers/net/phy/mdio-mux-gpio.c +++ b/drivers/net/phy/mdio-mux-gpio.c @@ -34,7 +34,7 @@ static int mdio_mux_gpio_switch_fn(int current_child, int desired_child, *values = desired_child; gpiod_set_array_value_cansleep(s->gpios->ndescs, s->gpios->desc, - values); + s->gpios->info, values); return 0; } diff --git a/drivers/pcmcia/soc_common.c b/drivers/pcmcia/soc_common.c index 388dbdc46129..8447eeeaf3fe 100644 --- a/drivers/pcmcia/soc_common.c +++ b/drivers/pcmcia/soc_common.c @@ -365,7 +365,7 @@ static int soc_common_pcmcia_config_skt( } if (n) - gpiod_set_array_value_cansleep(n, descs, values); + gpiod_set_array_value_cansleep(n, descs, NULL, values); /* * This really needs a better solution. The IRQ diff --git a/drivers/phy/motorola/phy-mapphone-mdm6600.c b/drivers/phy/motorola/phy-mapphone-mdm6600.c index 4de7f4577433..08e71c7ae199 100644 --- a/drivers/phy/motorola/phy-mapphone-mdm6600.c +++ b/drivers/phy/motorola/phy-mapphone-mdm6600.c @@ -162,7 +162,8 @@ static void phy_mdm6600_cmd(struct phy_mdm6600 *ddata, int val) *values = val; gpiod_set_array_value_cansleep(PHY_MDM6600_NR_CMD_LINES, - ddata->cmd_gpios->desc, values); + ddata->cmd_gpios->desc, + ddata->cmd_gpios->info, values); } /** @@ -181,6 +182,7 @@ static void phy_mdm6600_status(struct work_struct *work) error = gpiod_get_array_value_cansleep(PHY_MDM6600_NR_STATUS_LINES, ddata->status_gpios->desc, + ddata->status_gpios->info, values); if (error) return; diff --git a/drivers/staging/iio/adc/ad7606.c b/drivers/staging/iio/adc/ad7606.c index 053c9b7f1084..d32dba23e782 100644 --- a/drivers/staging/iio/adc/ad7606.c +++ b/drivers/staging/iio/adc/ad7606.c @@ -230,7 +230,8 @@ static int ad7606_write_raw(struct iio_dev *indio_dev, *values = ret; mutex_lock(&st->lock); - gpiod_set_array_value(3, st->gpio_os->desc, values); + gpiod_set_array_value(3, st->gpio_os->desc, st->gpio_os->info, + values); st->oversampling = val; mutex_unlock(&st->lock); diff --git a/drivers/tty/serial/serial_mctrl_gpio.c b/drivers/tty/serial/serial_mctrl_gpio.c index 30444fd6cf32..d7934ca55e2f 100644 --- a/drivers/tty/serial/serial_mctrl_gpio.c +++ b/drivers/tty/serial/serial_mctrl_gpio.c @@ -53,7 +53,7 @@ void mctrl_gpio_set(struct mctrl_gpios *gpios, unsigned int mctrl) !!(mctrl & mctrl_gpios_desc[i].mctrl)); count++; } - gpiod_set_array_value(count, desc_array, values); + gpiod_set_array_value(count, desc_array, NULL, values); } EXPORT_SYMBOL_GPL(mctrl_gpio_set); diff --git a/include/linux/gpio/consumer.h b/include/linux/gpio/consumer.h index 8dede3e886af..bf037ebe2ed8 100644 --- a/include/linux/gpio/consumer.h +++ b/include/linux/gpio/consumer.h @@ -114,36 +114,44 @@ int gpiod_direction_output_raw(struct gpio_desc *desc, int value); int gpiod_get_value(const struct gpio_desc *desc); int gpiod_get_array_value(unsigned int array_size, struct gpio_desc **desc_array, + struct gpio_array *array_info, unsigned long *value_bitmap); void gpiod_set_value(struct gpio_desc *desc, int value); void gpiod_set_array_value(unsigned int array_size, struct gpio_desc **desc_array, + struct gpio_array *array_info, unsigned long *value_bitmap); int gpiod_get_raw_value(const struct gpio_desc *desc); int gpiod_get_raw_array_value(unsigned int array_size, struct gpio_desc **desc_array, + struct gpio_array *array_info, unsigned long *value_bitmap); void gpiod_set_raw_value(struct gpio_desc *desc, int value); int gpiod_set_raw_array_value(unsigned int array_size, struct gpio_desc **desc_array, + struct gpio_array *array_info, unsigned long *value_bitmap); /* Value get/set from sleeping context */ int gpiod_get_value_cansleep(const struct gpio_desc *desc); int gpiod_get_array_value_cansleep(unsigned int array_size, struct gpio_desc **desc_array, + struct gpio_array *array_info, unsigned long *value_bitmap); void gpiod_set_value_cansleep(struct gpio_desc *desc, int value); void gpiod_set_array_value_cansleep(unsigned int array_size, struct gpio_desc **desc_array, + struct gpio_array *array_info, unsigned long *value_bitmap); int gpiod_get_raw_value_cansleep(const struct gpio_desc *desc); int gpiod_get_raw_array_value_cansleep(unsigned int array_size, struct gpio_desc **desc_array, + struct gpio_array *array_info, unsigned long *value_bitmap); void gpiod_set_raw_value_cansleep(struct gpio_desc *desc, int value); int gpiod_set_raw_array_value_cansleep(unsigned int array_size, struct gpio_desc **desc_array, + struct gpio_array *array_info, unsigned long *value_bitmap); int gpiod_set_debounce(struct gpio_desc *desc, unsigned debounce); -- 2.16.4 From mboxrd@z Thu Jan 1 00:00:00 1970 From: Janusz Krzysztofik Subject: [PATCH v7 3/4] gpiolib: Pass array info to get/set array functions Date: Sun, 2 Sep 2018 14:01:43 +0200 Message-ID: <20180902120144.6855-4-jmkrzyszt@gmail.com> References: <20180831225616.29221-1-jmkrzyszt@gmail.com> <20180902120144.6855-1-jmkrzyszt@gmail.com> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Return-path: In-Reply-To: <20180902120144.6855-1-jmkrzyszt@gmail.com> List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: driverdev-devel-bounces@linuxdriverproject.org Sender: "devel" To: Linus Walleij Cc: Andrew Lunn , Ulf Hansson , linux-doc@vger.kernel.org, linux-iio@vger.kernel.org, Dominik Brodowski , Peter Rosin , netdev@vger.kernel.org, linux-i2c@vger.kernel.org, Peter Meerwald-Stadler , devel@driverdev.osuosl.org, Florian Fainelli , Jonathan Corbet , Janusz Krzysztofik , Kishon Vijay Abraham I , Tony Lindgren , Lukas Wunner , Geert Uytterhoeven , linux-serial@vger.kernel.org, Jiri Slaby , Michael Hennerich , =?UTF-8?q?Uwe=20Kleine-K=C3=B6nig?= , linux-gpio@vger.kernel.org, Russell King , Lars-Peter Clausen , Yeg List-Id: linux-gpio@vger.kernel.org SW4gb3JkZXIgdG8gbWFrZSB1c2Ugb2YgYXJyYXkgaW5mbyBvYnRhaW5lZCBmcm9tIGdwaW9kX2dl dF9hcnJheSgpIGFuZApzcGVlZCB1cCBwcm9jZXNzaW5nIG9mIGFycmF5cyBtYXRjaGluZyBzaW5n bGUgR1BJTyBjaGlwIGxheW91dCwgdGhhdAppbmZvcm1hdGlvbiBtdXN0IGJlIHBhc3NlZCB0byBn ZXQvc2V0IGFycmF5IGZ1bmN0aW9ucy4gIEV4dGVuZCB0aGUKZnVuY3Rpb25zJyBBUEkgd2l0aCB0 aGF0IGFkZGl0aW9uYWwgcGFyYW1ldGVyIGFuZCB1cGRhdGUgYWxsIHVzZXJzLgpQYXNzIE5VTEwg aWYgYSB1c2VyIGJ1bGlkcyBhbiBhcnJheSBpdHNlbGYgZnJvbSBzaW5nbGUgR1BJT3MuCgpDYzog Sm9uYXRoYW4gQ29yYmV0IDxjb3JiZXRAbHduLm5ldD4KQ2M6IE1pZ3VlbCBPamVkYSBTYW5kb25p cyA8bWlndWVsLm9qZWRhLnNhbmRvbmlzQGdtYWlsLmNvbT4KQ2M6IEdlZXJ0IFV5dHRlcmhvZXZl biA8Z2VlcnRAbGludXgtbTY4ay5vcmc+CkNjOiBTZWJhc3RpZW4gQm91cmRlbGluIDxzZWJhc3Rp ZW4uYm91cmRlbGluQHNhdm9pcmZhaXJlbGludXguY29tPgpDYzogTHVrYXMgV3VubmVyIDxsdWth c0B3dW5uZXIuZGU+CkNjOiBQZXRlciBLb3JzZ2FhcmQgPHBldGVyLmtvcnNnYWFyZEBiYXJjby5j b20+CkNjOiBQZXRlciBSb3NpbiA8cGVkYUBheGVudGlhLnNlPgpDYzogQW5kcmV3IEx1bm4gPGFu ZHJld0BsdW5uLmNoPgpDYzogRmxvcmlhbiBGYWluZWxsaSA8Zi5mYWluZWxsaUBnbWFpbC5jb20+ CkNjOiAiRGF2aWQgUy4gTWlsbGVyIiA8ZGF2ZW1AZGF2ZW1sb2Z0Lm5ldD4KQ2M6IFJvamhhbGF0 IElicmFoaW0gPGltckBydHNjaGVuay5kZT4KQ2M6IERvbWluaWsgQnJvZG93c2tpIDxsaW51eEBk b21pbmlrYnJvZG93c2tpLm5ldD4KQ2M6IFJ1c3NlbGwgS2luZyA8cm1rK2tlcm5lbEBhcm1saW51 eC5vcmcudWs+CkNjOiBLaXNob24gVmlqYXkgQWJyYWhhbSBJIDxraXNob25AdGkuY29tPgpDYzog VG9ueSBMaW5kZ3JlbiA8dG9ueUBhdG9taWRlLmNvbT4KQ2M6IExhcnMtUGV0ZXIgQ2xhdXNlbiA8 bGFyc0BtZXRhZm9vLmRlPgpDYzogTWljaGFlbCBIZW5uZXJpY2ggPE1pY2hhZWwuSGVubmVyaWNo QGFuYWxvZy5jb20+CkNjOiBKb25hdGhhbiBDYW1lcm9uIDxqaWMyM0BrZXJuZWwub3JnPgpDYzog SGFydG11dCBLbmFhY2sgPGtuYWFjay5oQGdteC5kZT4KQ2M6IFBldGVyIE1lZXJ3YWxkLVN0YWRs ZXIgPHBtZWVyd0BwbWVlcncubmV0PgpDYzogR3JlZyBLcm9haC1IYXJ0bWFuIDxncmVna2hAbGlu dXhmb3VuZGF0aW9uLm9yZz4KQ2M6IEppcmkgU2xhYnkgPGpzbGFieUBzdXNlLmNvbT4KQ2M6IFll Z29yIFllZnJlbW92IDx5ZWdvcnNsaXN0c0Bnb29nbGVtYWlsLmNvbT4KQ2M6IFV3ZSBLbGVpbmUt S8O2bmlnIDx1LmtsZWluZS1rb2VuaWdAcGVuZ3V0cm9uaXguZGU+ClNpZ25lZC1vZmYtYnk6IEph bnVzeiBLcnp5c3p0b2ZpayA8am1rcnp5c3p0QGdtYWlsLmNvbT4KQWNrZWQtYnk6IFVsZiBIYW5z c29uIDx1bGYuaGFuc3NvbkBsaW5hcm8ub3JnPgotLS0KIERvY3VtZW50YXRpb24vZHJpdmVyLWFw aS9ncGlvL2NvbnN1bWVyLnJzdCAgfCAxNCArKysrKysrKysrKy0tCiBkcml2ZXJzL2F1eGRpc3Bs YXkvaGQ0NDc4MC5jICAgICAgICAgICAgICAgIHwgIDggKysrKy0tLS0KIGRyaXZlcnMvYnVzL3Rz LW5idXMuYyAgICAgICAgICAgICAgICAgICAgICAgfCAgNSArKystLQogZHJpdmVycy9ncGlvL2dw aW8tbWF4MzE5MXguYyAgICAgICAgICAgICAgICB8ICA2ICsrKystLQogZHJpdmVycy9ncGlvL2dw aW9saWIuYyAgICAgICAgICAgICAgICAgICAgICB8IDMyICsrKysrKysrKysrKysrKysrKysrKy0t LS0tLS0tCiBkcml2ZXJzL2dwaW8vZ3Bpb2xpYi5oICAgICAgICAgICAgICAgICAgICAgIHwgIDIg KysKIGRyaXZlcnMvaTJjL211eGVzL2kyYy1tdXgtZ3Bpby5jICAgICAgICAgICAgfCAgMyArKy0K IGRyaXZlcnMvbW1jL2NvcmUvcHdyc2VxX3NpbXBsZS5jICAgICAgICAgICAgfCAgMiArLQogZHJp dmVycy9tdXgvZ3Bpby5jICAgICAgICAgICAgICAgICAgICAgICAgICB8ICAzICsrLQogZHJpdmVy cy9uZXQvcGh5L21kaW8tbXV4LWdwaW8uYyAgICAgICAgICAgICB8ICAyICstCiBkcml2ZXJzL3Bj bWNpYS9zb2NfY29tbW9uLmMgICAgICAgICAgICAgICAgIHwgIDIgKy0KIGRyaXZlcnMvcGh5L21v dG9yb2xhL3BoeS1tYXBwaG9uZS1tZG02NjAwLmMgfCAgNCArKystCiBkcml2ZXJzL3N0YWdpbmcv aWlvL2FkYy9hZDc2MDYuYyAgICAgICAgICAgIHwgIDMgKystCiBkcml2ZXJzL3R0eS9zZXJpYWwv c2VyaWFsX21jdHJsX2dwaW8uYyAgICAgIHwgIDIgKy0KIGluY2x1ZGUvbGludXgvZ3Bpby9jb25z dW1lci5oICAgICAgICAgICAgICAgfCAgOCArKysrKysrKwogMTUgZmlsZXMgY2hhbmdlZCwgNzAg aW5zZXJ0aW9ucygrKSwgMjYgZGVsZXRpb25zKC0pCgpkaWZmIC0tZ2l0IGEvRG9jdW1lbnRhdGlv bi9kcml2ZXItYXBpL2dwaW8vY29uc3VtZXIucnN0IGIvRG9jdW1lbnRhdGlvbi9kcml2ZXItYXBp L2dwaW8vY29uc3VtZXIucnN0CmluZGV4IDdlMDI5OGI5YTdiOS4uMGFmZDk1YTEyYjEwIDEwMDY0 NAotLS0gYS9Eb2N1bWVudGF0aW9uL2RyaXZlci1hcGkvZ3Bpby9jb25zdW1lci5yc3QKKysrIGIv RG9jdW1lbnRhdGlvbi9kcml2ZXItYXBpL2dwaW8vY29uc3VtZXIucnN0CkBAIC0zMjUsMjggKzMy NSwzNiBAQCBUaGUgZm9sbG93aW5nIGZ1bmN0aW9ucyBnZXQgb3Igc2V0IHRoZSB2YWx1ZXMgb2Yg YW4gYXJyYXkgb2YgR1BJT3M6OgogCiAJaW50IGdwaW9kX2dldF9hcnJheV92YWx1ZSh1bnNpZ25l ZCBpbnQgYXJyYXlfc2l6ZSwKIAkJCQkgIHN0cnVjdCBncGlvX2Rlc2MgKipkZXNjX2FycmF5LAor CQkJCSAgc3RydWN0IGdwaW9fYXJyYXkgKmFycmF5X2luZm8sCiAJCQkJICB1bnNpZ25lZCBsb25n ICp2YWx1ZV9iaXRtYXApOwogCWludCBncGlvZF9nZXRfcmF3X2FycmF5X3ZhbHVlKHVuc2lnbmVk IGludCBhcnJheV9zaXplLAogCQkJCSAgICAgIHN0cnVjdCBncGlvX2Rlc2MgKipkZXNjX2FycmF5 LAorCQkJCSAgICAgIHN0cnVjdCBncGlvX2FycmF5ICphcnJheV9pbmZvLAogCQkJCSAgICAgIHVu c2lnbmVkIGxvbmcgKnZhbHVlX2JpdG1hcCk7CiAJaW50IGdwaW9kX2dldF9hcnJheV92YWx1ZV9j YW5zbGVlcCh1bnNpZ25lZCBpbnQgYXJyYXlfc2l6ZSwKIAkJCQkJICAgc3RydWN0IGdwaW9fZGVz YyAqKmRlc2NfYXJyYXksCisJCQkJCSAgIHN0cnVjdCBncGlvX2FycmF5ICphcnJheV9pbmZvLAog CQkJCQkgICB1bnNpZ25lZCBsb25nICp2YWx1ZV9iaXRtYXApOwogCWludCBncGlvZF9nZXRfcmF3 X2FycmF5X3ZhbHVlX2NhbnNsZWVwKHVuc2lnbmVkIGludCBhcnJheV9zaXplLAogCQkJCQkgICBz dHJ1Y3QgZ3Bpb19kZXNjICoqZGVzY19hcnJheSwKKwkJCQkJICAgc3RydWN0IGdwaW9fYXJyYXkg KmFycmF5X2luZm8sCiAJCQkJCSAgIHVuc2lnbmVkIGxvbmcgKnZhbHVlX2JpdG1hcCk7CiAKIAl2 b2lkIGdwaW9kX3NldF9hcnJheV92YWx1ZSh1bnNpZ25lZCBpbnQgYXJyYXlfc2l6ZSwKIAkJCQkg ICBzdHJ1Y3QgZ3Bpb19kZXNjICoqZGVzY19hcnJheSwKKwkJCQkgICBzdHJ1Y3QgZ3Bpb19hcnJh eSAqYXJyYXlfaW5mbywKIAkJCQkgICB1bnNpZ25lZCBsb25nICp2YWx1ZV9iaXRtYXApCiAJdm9p ZCBncGlvZF9zZXRfcmF3X2FycmF5X3ZhbHVlKHVuc2lnbmVkIGludCBhcnJheV9zaXplLAogCQkJ CSAgICAgICBzdHJ1Y3QgZ3Bpb19kZXNjICoqZGVzY19hcnJheSwKKwkJCQkgICAgICAgc3RydWN0 IGdwaW9fYXJyYXkgKmFycmF5X2luZm8sCiAJCQkJICAgICAgIHVuc2lnbmVkIGxvbmcgKnZhbHVl X2JpdG1hcCkKIAl2b2lkIGdwaW9kX3NldF9hcnJheV92YWx1ZV9jYW5zbGVlcCh1bnNpZ25lZCBp bnQgYXJyYXlfc2l6ZSwKIAkJCQkJICAgIHN0cnVjdCBncGlvX2Rlc2MgKipkZXNjX2FycmF5LAor CQkJCQkgICAgc3RydWN0IGdwaW9fYXJyYXkgKmFycmF5X2luZm8sCiAJCQkJCSAgICB1bnNpZ25l ZCBsb25nICp2YWx1ZV9iaXRtYXApCiAJdm9pZCBncGlvZF9zZXRfcmF3X2FycmF5X3ZhbHVlX2Nh bnNsZWVwKHVuc2lnbmVkIGludCBhcnJheV9zaXplLAogCQkJCQkJc3RydWN0IGdwaW9fZGVzYyAq KmRlc2NfYXJyYXksCisJCQkJCQlzdHJ1Y3QgZ3Bpb19hcnJheSAqYXJyYXlfaW5mbywKIAkJCQkJ CXVuc2lnbmVkIGxvbmcgKnZhbHVlX2JpdG1hcCkKIAogVGhlIGFycmF5IGNhbiBiZSBhbiBhcmJp dHJhcnkgc2V0IG9mIEdQSU9zLiBUaGUgZnVuY3Rpb25zIHdpbGwgdHJ5IHRvIGFjY2VzcwpAQCAt MzU4LDYgKzM2Niw3IEBAIGFjY2Vzc2VkIHNlcXVlbnRpYWxseS4KIFRoZSBmdW5jdGlvbnMgdGFr ZSB0aHJlZSBhcmd1bWVudHM6CiAJKiBhcnJheV9zaXplCS0gdGhlIG51bWJlciBvZiBhcnJheSBl bGVtZW50cwogCSogZGVzY19hcnJheQktIGFuIGFycmF5IG9mIEdQSU8gZGVzY3JpcHRvcnMKKwkq IGFycmF5X2luZm8JLSBvcHRpb25hbCBpbmZvcm1hdGlvbiBvYnRhaW5lZCBmcm9tIGdwaW9kX2Fy cmF5X2dldCgpCiAJKiB2YWx1ZV9iaXRtYXAJLSBhIGJpdG1hcCB0byBzdG9yZSB0aGUgR1BJT3Mn IHZhbHVlcyAoZ2V0KSBvcgogCQkJICBhIGJpdG1hcCBvZiB2YWx1ZXMgdG8gYXNzaWduIHRvIHRo ZSBHUElPcyAoc2V0KQogCkBAIC0zNjgsMTIgKzM3NywxMyBAQCB0aGUgc3RydWN0IGdwaW9fZGVz Y3MgcmV0dXJuZWQgYnkgZ3Bpb2RfZ2V0X2FycmF5KCk6OgogCiAJc3RydWN0IGdwaW9fZGVzY3Mg Km15X2dwaW9fZGVzY3MgPSBncGlvZF9nZXRfYXJyYXkoLi4uKTsKIAlncGlvZF9zZXRfYXJyYXlf dmFsdWUobXlfZ3Bpb19kZXNjcy0+bmRlc2NzLCBteV9ncGlvX2Rlc2NzLT5kZXNjLAotCQkJICAg ICAgbXlfZ3Bpb192YWx1ZV9iaXRtYXApOworCQkJICAgICAgbXlfZ3Bpb19kZXNjcy0+aW5mbywg bXlfZ3Bpb192YWx1ZV9iaXRtYXApOwogCiBJdCBpcyBhbHNvIHBvc3NpYmxlIHRvIGFjY2VzcyBh IGNvbXBsZXRlbHkgYXJiaXRyYXJ5IGFycmF5IG9mIGRlc2NyaXB0b3JzLiBUaGUKIGRlc2NyaXB0 b3JzIG1heSBiZSBvYnRhaW5lZCB1c2luZyBhbnkgY29tYmluYXRpb24gb2YgZ3Bpb2RfZ2V0KCkg YW5kCiBncGlvZF9nZXRfYXJyYXkoKS4gQWZ0ZXJ3YXJkcyB0aGUgYXJyYXkgb2YgZGVzY3JpcHRv cnMgaGFzIHRvIGJlIHNldHVwCi1tYW51YWxseSBiZWZvcmUgaXQgY2FuIGJlIHBhc3NlZCB0byBv bmUgb2YgdGhlIGFib3ZlIGZ1bmN0aW9ucy4KK21hbnVhbGx5IGJlZm9yZSBpdCBjYW4gYmUgcGFz c2VkIHRvIG9uZSBvZiB0aGUgYWJvdmUgZnVuY3Rpb25zLiAgSW4gdGhhdCBjYXNlLAorYXJyYXlf aW5mbyBzaG91bGQgYmUgc2V0IHRvIE5VTEwuCiAKIE5vdGUgdGhhdCBmb3Igb3B0aW1hbCBwZXJm b3JtYW5jZSBHUElPcyBiZWxvbmdpbmcgdG8gdGhlIHNhbWUgY2hpcCBzaG91bGQgYmUKIGNvbnRp Z3VvdXMgd2l0aGluIHRoZSBhcnJheSBvZiBkZXNjcmlwdG9ycy4KZGlmZiAtLWdpdCBhL2RyaXZl cnMvYXV4ZGlzcGxheS9oZDQ0NzgwLmMgYi9kcml2ZXJzL2F1eGRpc3BsYXkvaGQ0NDc4MC5jCmlu ZGV4IDMzM2UzMGUzNzhiNS4uMDMzMDI0ZGYzOTYyIDEwMDY0NAotLS0gYS9kcml2ZXJzL2F1eGRp c3BsYXkvaGQ0NDc4MC5jCisrKyBiL2RyaXZlcnMvYXV4ZGlzcGxheS9oZDQ0NzgwLmMKQEAgLTcw LDcgKzcwLDcgQEAgc3RhdGljIHZvaWQgaGQ0NDc4MF93cml0ZV9ncGlvOChzdHJ1Y3QgaGQ0NDc4 MCAqaGQsIHU4IHZhbCwgdW5zaWduZWQgaW50IHJzKQogCW4gPSBoZC0+cGluc1tQSU5fQ1RSTF9S V10gPyAxMCA6IDk7CiAKIAkvKiBQcmVzZW50IHRoZSBkYXRhIHRvIHRoZSBwb3J0ICovCi0JZ3Bp b2Rfc2V0X2FycmF5X3ZhbHVlX2NhbnNsZWVwKG4sICZoZC0+cGluc1tQSU5fREFUQTBdLCB2YWx1 ZXMpOworCWdwaW9kX3NldF9hcnJheV92YWx1ZV9jYW5zbGVlcChuLCAmaGQtPnBpbnNbUElOX0RB VEEwXSwgTlVMTCwgdmFsdWVzKTsKIAogCWhkNDQ3ODBfc3Ryb2JlX2dwaW8oaGQpOwogfQpAQCAt ODcsNyArODcsNyBAQCBzdGF0aWMgdm9pZCBoZDQ0NzgwX3dyaXRlX2dwaW80KHN0cnVjdCBoZDQ0 NzgwICpoZCwgdTggdmFsLCB1bnNpZ25lZCBpbnQgcnMpCiAJbiA9IGhkLT5waW5zW1BJTl9DVFJM X1JXXSA/IDYgOiA1OwogCiAJLyogUHJlc2VudCB0aGUgZGF0YSB0byB0aGUgcG9ydCAqLwotCWdw aW9kX3NldF9hcnJheV92YWx1ZV9jYW5zbGVlcChuLCAmaGQtPnBpbnNbUElOX0RBVEE0XSwgdmFs dWVzKTsKKwlncGlvZF9zZXRfYXJyYXlfdmFsdWVfY2Fuc2xlZXAobiwgJmhkLT5waW5zW1BJTl9E QVRBNF0sIE5VTEwsIHZhbHVlcyk7CiAKIAloZDQ0NzgwX3N0cm9iZV9ncGlvKGhkKTsKIApAQCAt OTYsNyArOTYsNyBAQCBzdGF0aWMgdm9pZCBoZDQ0NzgwX3dyaXRlX2dwaW80KHN0cnVjdCBoZDQ0 NzgwICpoZCwgdTggdmFsLCB1bnNpZ25lZCBpbnQgcnMpCiAJKnZhbHVlcyB8PSB2YWwgJiAweDBm OwogCiAJLyogUHJlc2VudCB0aGUgZGF0YSB0byB0aGUgcG9ydCAqLwotCWdwaW9kX3NldF9hcnJh eV92YWx1ZV9jYW5zbGVlcChuLCAmaGQtPnBpbnNbUElOX0RBVEE0XSwgdmFsdWVzKTsKKwlncGlv ZF9zZXRfYXJyYXlfdmFsdWVfY2Fuc2xlZXAobiwgJmhkLT5waW5zW1BJTl9EQVRBNF0sIE5VTEws IHZhbHVlcyk7CiAKIAloZDQ0NzgwX3N0cm9iZV9ncGlvKGhkKTsKIH0KQEAgLTE1Miw3ICsxNTIs NyBAQCBzdGF0aWMgdm9pZCBoZDQ0NzgwX3dyaXRlX2NtZF9yYXdfZ3BpbzQoc3RydWN0IGNoYXJs Y2QgKmxjZCwgaW50IGNtZCkKIAluID0gaGQtPnBpbnNbUElOX0NUUkxfUlddID8gNiA6IDU7CiAK IAkvKiBQcmVzZW50IHRoZSBkYXRhIHRvIHRoZSBwb3J0ICovCi0JZ3Bpb2Rfc2V0X2FycmF5X3Zh bHVlX2NhbnNsZWVwKG4sICZoZC0+cGluc1tQSU5fREFUQTRdLCB2YWx1ZXMpOworCWdwaW9kX3Nl dF9hcnJheV92YWx1ZV9jYW5zbGVlcChuLCAmaGQtPnBpbnNbUElOX0RBVEE0XSwgTlVMTCwgdmFs dWVzKTsKIAogCWhkNDQ3ODBfc3Ryb2JlX2dwaW8oaGQpOwogfQpkaWZmIC0tZ2l0IGEvZHJpdmVy cy9idXMvdHMtbmJ1cy5jIGIvZHJpdmVycy9idXMvdHMtbmJ1cy5jCmluZGV4IDY0OTk5NTdhODA0 NC4uNjA3OTZmMmRiNmZjIDEwMDY0NAotLS0gYS9kcml2ZXJzL2J1cy90cy1uYnVzLmMKKysrIGIv ZHJpdmVycy9idXMvdHMtbmJ1cy5jCkBAIC0xMTQsNyArMTE0LDggQEAgc3RhdGljIHZvaWQgdHNf bmJ1c19yZXNldF9idXMoc3RydWN0IHRzX25idXMgKnRzX25idXMpCiAKIAkqdmFsdWVzID0gMDsK IAotCWdwaW9kX3NldF9hcnJheV92YWx1ZV9jYW5zbGVlcCg4LCB0c19uYnVzLT5kYXRhLT5kZXNj LCB2YWx1ZXMpOworCWdwaW9kX3NldF9hcnJheV92YWx1ZV9jYW5zbGVlcCg4LCB0c19uYnVzLT5k YXRhLT5kZXNjLAorCQkJCSAgICAgICB0c19uYnVzLT5kYXRhLT5pbmZvLCB2YWx1ZXMpOwogCWdw aW9kX3NldF92YWx1ZV9jYW5zbGVlcCh0c19uYnVzLT5jc24sIDApOwogCWdwaW9kX3NldF92YWx1 ZV9jYW5zbGVlcCh0c19uYnVzLT5zdHJvYmUsIDApOwogCWdwaW9kX3NldF92YWx1ZV9jYW5zbGVl cCh0c19uYnVzLT5hbGUsIDApOwpAQCAtMTU5LDcgKzE2MCw3IEBAIHN0YXRpYyB2b2lkIHRzX25i dXNfd3JpdGVfYnl0ZShzdHJ1Y3QgdHNfbmJ1cyAqdHNfbmJ1cywgdTggYnl0ZSkKIAogCSp2YWx1 ZXMgPSBieXRlOwogCi0JZ3Bpb2Rfc2V0X2FycmF5X3ZhbHVlX2NhbnNsZWVwKDgsIGdwaW9zLT5k ZXNjLCB2YWx1ZXMpOworCWdwaW9kX3NldF9hcnJheV92YWx1ZV9jYW5zbGVlcCg4LCBncGlvcy0+ ZGVzYywgZ3Bpb3MtPmluZm8sIHZhbHVlcyk7CiB9CiAKIC8qCmRpZmYgLS1naXQgYS9kcml2ZXJz L2dwaW8vZ3Bpby1tYXgzMTkxeC5jIGIvZHJpdmVycy9ncGlvL2dwaW8tbWF4MzE5MXguYwppbmRl eCBiZDRhMjQ1ZmM1YTAuLjlhODg3NmFiZWI1NyAxMDA2NDQKLS0tIGEvZHJpdmVycy9ncGlvL2dw aW8tbWF4MzE5MXguYworKysgYi9kcml2ZXJzL2dwaW8vZ3Bpby1tYXgzMTkxeC5jCkBAIC0zMTMs NiArMzEzLDcgQEAgc3RhdGljIGludCBtYXgzMTkxeF9zZXRfY29uZmlnKHN0cnVjdCBncGlvX2No aXAgKmdwaW8sIHVuc2lnbmVkIGludCBvZmZzZXQsCiAKIHN0YXRpYyB2b2lkIGdwaW9kX3NldF9h cnJheV9zaW5nbGVfdmFsdWVfY2Fuc2xlZXAodW5zaWduZWQgaW50IG5kZXNjcywKIAkJCQkJCSAg c3RydWN0IGdwaW9fZGVzYyAqKmRlc2MsCisJCQkJCQkgIHN0cnVjdCBncGlvX2FycmF5ICppbmZv LAogCQkJCQkJICBpbnQgdmFsdWUpCiB7CiAJdW5zaWduZWQgbG9uZyAqdmFsdWVzOwpAQCAtMzI2 LDcgKzMyNyw3IEBAIHN0YXRpYyB2b2lkIGdwaW9kX3NldF9hcnJheV9zaW5nbGVfdmFsdWVfY2Fu c2xlZXAodW5zaWduZWQgaW50IG5kZXNjcywKIAllbHNlCiAJCWJpdG1hcF96ZXJvKHZhbHVlcywg bmRlc2NzKTsKIAotCWdwaW9kX3NldF9hcnJheV92YWx1ZV9jYW5zbGVlcChuZGVzY3MsIGRlc2Ms IHZhbHVlcyk7CisJZ3Bpb2Rfc2V0X2FycmF5X3ZhbHVlX2NhbnNsZWVwKG5kZXNjcywgZGVzYywg aW5mbywgdmFsdWVzKTsKIAlrZnJlZSh2YWx1ZXMpOwogfQogCkBAIC0zOTksNyArNDAwLDggQEAg c3RhdGljIGludCBtYXgzMTkxeF9wcm9iZShzdHJ1Y3Qgc3BpX2RldmljZSAqc3BpKQogCWlmICht YXgzMTkxeC0+bW9kZXNlbF9waW5zKQogCQlncGlvZF9zZXRfYXJyYXlfc2luZ2xlX3ZhbHVlX2Nh bnNsZWVwKAogCQkJCSBtYXgzMTkxeC0+bW9kZXNlbF9waW5zLT5uZGVzY3MsCi0JCQkJIG1heDMx OTF4LT5tb2Rlc2VsX3BpbnMtPmRlc2MsIG1heDMxOTF4LT5tb2RlKTsKKwkJCQkgbWF4MzE5MXgt Pm1vZGVzZWxfcGlucy0+ZGVzYywKKwkJCQkgbWF4MzE5MXgtPm1vZGVzZWxfcGlucy0+aW5mbywg bWF4MzE5MXgtPm1vZGUpOwogCiAJbWF4MzE5MXgtPmlnbm9yZV91diA9IGRldmljZV9wcm9wZXJ0 eV9yZWFkX2Jvb2woZGV2LAogCQkJCQkJICAibWF4aW0saWdub3JlLXVuZGVydm9sdGFnZSIpOwpk aWZmIC0tZ2l0IGEvZHJpdmVycy9ncGlvL2dwaW9saWIuYyBiL2RyaXZlcnMvZ3Bpby9ncGlvbGli LmMKaW5kZXggMTQxZjJmMjkwNTM4Li5jZWY2ZWUzMWZlMDUgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMv Z3Bpby9ncGlvbGliLmMKKysrIGIvZHJpdmVycy9ncGlvL2dwaW9saWIuYwpAQCAtNDM2LDYgKzQz Niw3IEBAIHN0YXRpYyBsb25nIGxpbmVoYW5kbGVfaW9jdGwoc3RydWN0IGZpbGUgKmZpbGVwLCB1 bnNpZ25lZCBpbnQgY21kLAogCQkJCQkJCXRydWUsCiAJCQkJCQkJbGgtPm51bWRlc2NzLAogCQkJ CQkJCWxoLT5kZXNjcywKKwkJCQkJCQlOVUxMLAogCQkJCQkJCXZhbHMpOwogCQlpZiAocmV0KQog CQkJcmV0dXJuIHJldDsKQEAgLTQ2OCw2ICs0NjksNyBAQCBzdGF0aWMgbG9uZyBsaW5laGFuZGxl X2lvY3RsKHN0cnVjdCBmaWxlICpmaWxlcCwgdW5zaWduZWQgaW50IGNtZCwKIAkJCQkJICAgICAg dHJ1ZSwKIAkJCQkJICAgICAgbGgtPm51bWRlc2NzLAogCQkJCQkgICAgICBsaC0+ZGVzY3MsCisJ CQkJCSAgICAgIE5VTEwsCiAJCQkJCSAgICAgIHZhbHMpOwogCX0KIAlyZXR1cm4gLUVJTlZBTDsK QEAgLTI3ODQsNiArMjc4Niw3IEBAIHN0YXRpYyBpbnQgZ3Bpb19jaGlwX2dldF9tdWx0aXBsZShz dHJ1Y3QgZ3Bpb19jaGlwICpjaGlwLAogaW50IGdwaW9kX2dldF9hcnJheV92YWx1ZV9jb21wbGV4 KGJvb2wgcmF3LCBib29sIGNhbl9zbGVlcCwKIAkJCQkgIHVuc2lnbmVkIGludCBhcnJheV9zaXpl LAogCQkJCSAgc3RydWN0IGdwaW9fZGVzYyAqKmRlc2NfYXJyYXksCisJCQkJICBzdHJ1Y3QgZ3Bp b19hcnJheSAqYXJyYXlfaW5mbywKIAkJCQkgIHVuc2lnbmVkIGxvbmcgKnZhbHVlX2JpdG1hcCkK IHsKIAlpbnQgaSA9IDA7CkBAIC0yOTA4LDEyICsyOTExLDE0IEBAIEVYUE9SVF9TWU1CT0xfR1BM KGdwaW9kX2dldF92YWx1ZSk7CiAgKi8KIGludCBncGlvZF9nZXRfcmF3X2FycmF5X3ZhbHVlKHVu c2lnbmVkIGludCBhcnJheV9zaXplLAogCQkJICAgICAgc3RydWN0IGdwaW9fZGVzYyAqKmRlc2Nf YXJyYXksCisJCQkgICAgICBzdHJ1Y3QgZ3Bpb19hcnJheSAqYXJyYXlfaW5mbywKIAkJCSAgICAg IHVuc2lnbmVkIGxvbmcgKnZhbHVlX2JpdG1hcCkKIHsKIAlpZiAoIWRlc2NfYXJyYXkpCiAJCXJl dHVybiAtRUlOVkFMOwogCXJldHVybiBncGlvZF9nZXRfYXJyYXlfdmFsdWVfY29tcGxleCh0cnVl LCBmYWxzZSwgYXJyYXlfc2l6ZSwKLQkJCQkJICAgICBkZXNjX2FycmF5LCB2YWx1ZV9iaXRtYXAp OworCQkJCQkgICAgIGRlc2NfYXJyYXksIGFycmF5X2luZm8sCisJCQkJCSAgICAgdmFsdWVfYml0 bWFwKTsKIH0KIEVYUE9SVF9TWU1CT0xfR1BMKGdwaW9kX2dldF9yYXdfYXJyYXlfdmFsdWUpOwog CkBAIC0yOTMxLDEyICsyOTM2LDE0IEBAIEVYUE9SVF9TWU1CT0xfR1BMKGdwaW9kX2dldF9yYXdf YXJyYXlfdmFsdWUpOwogICovCiBpbnQgZ3Bpb2RfZ2V0X2FycmF5X3ZhbHVlKHVuc2lnbmVkIGlu dCBhcnJheV9zaXplLAogCQkJICBzdHJ1Y3QgZ3Bpb19kZXNjICoqZGVzY19hcnJheSwKKwkJCSAg c3RydWN0IGdwaW9fYXJyYXkgKmFycmF5X2luZm8sCiAJCQkgIHVuc2lnbmVkIGxvbmcgKnZhbHVl X2JpdG1hcCkKIHsKIAlpZiAoIWRlc2NfYXJyYXkpCiAJCXJldHVybiAtRUlOVkFMOwogCXJldHVy biBncGlvZF9nZXRfYXJyYXlfdmFsdWVfY29tcGxleChmYWxzZSwgZmFsc2UsIGFycmF5X3NpemUs Ci0JCQkJCSAgICAgZGVzY19hcnJheSwgdmFsdWVfYml0bWFwKTsKKwkJCQkJICAgICBkZXNjX2Fy cmF5LCBhcnJheV9pbmZvLAorCQkJCQkgICAgIHZhbHVlX2JpdG1hcCk7CiB9CiBFWFBPUlRfU1lN Qk9MX0dQTChncGlvZF9nZXRfYXJyYXlfdmFsdWUpOwogCkBAIC0zMDI5LDYgKzMwMzYsNyBAQCBz dGF0aWMgdm9pZCBncGlvX2NoaXBfc2V0X211bHRpcGxlKHN0cnVjdCBncGlvX2NoaXAgKmNoaXAs CiBpbnQgZ3Bpb2Rfc2V0X2FycmF5X3ZhbHVlX2NvbXBsZXgoYm9vbCByYXcsIGJvb2wgY2FuX3Ns ZWVwLAogCQkJCSAgIHVuc2lnbmVkIGludCBhcnJheV9zaXplLAogCQkJCSAgIHN0cnVjdCBncGlv X2Rlc2MgKipkZXNjX2FycmF5LAorCQkJCSAgIHN0cnVjdCBncGlvX2FycmF5ICphcnJheV9pbmZv LAogCQkJCSAgIHVuc2lnbmVkIGxvbmcgKnZhbHVlX2JpdG1hcCkKIHsKIAlpbnQgaSA9IDA7CkBA IC0zMTY2LDEyICszMTc0LDEzIEBAIEVYUE9SVF9TWU1CT0xfR1BMKGdwaW9kX3NldF92YWx1ZSk7 CiAgKi8KIGludCBncGlvZF9zZXRfcmF3X2FycmF5X3ZhbHVlKHVuc2lnbmVkIGludCBhcnJheV9z aXplLAogCQkJIHN0cnVjdCBncGlvX2Rlc2MgKipkZXNjX2FycmF5LAorCQkJIHN0cnVjdCBncGlv X2FycmF5ICphcnJheV9pbmZvLAogCQkJIHVuc2lnbmVkIGxvbmcgKnZhbHVlX2JpdG1hcCkKIHsK IAlpZiAoIWRlc2NfYXJyYXkpCiAJCXJldHVybiAtRUlOVkFMOwogCXJldHVybiBncGlvZF9zZXRf YXJyYXlfdmFsdWVfY29tcGxleCh0cnVlLCBmYWxzZSwgYXJyYXlfc2l6ZSwKLQkJCQkJZGVzY19h cnJheSwgdmFsdWVfYml0bWFwKTsKKwkJCQkJZGVzY19hcnJheSwgYXJyYXlfaW5mbywgdmFsdWVf Yml0bWFwKTsKIH0KIEVYUE9SVF9TWU1CT0xfR1BMKGdwaW9kX3NldF9yYXdfYXJyYXlfdmFsdWUp OwogCkBAIC0zMTg5LDEyICszMTk4LDEzIEBAIEVYUE9SVF9TWU1CT0xfR1BMKGdwaW9kX3NldF9y YXdfYXJyYXlfdmFsdWUpOwogICovCiB2b2lkIGdwaW9kX3NldF9hcnJheV92YWx1ZSh1bnNpZ25l ZCBpbnQgYXJyYXlfc2l6ZSwKIAkJCSAgIHN0cnVjdCBncGlvX2Rlc2MgKipkZXNjX2FycmF5LAor CQkJICAgc3RydWN0IGdwaW9fYXJyYXkgKmFycmF5X2luZm8sCiAJCQkgICB1bnNpZ25lZCBsb25n ICp2YWx1ZV9iaXRtYXApCiB7CiAJaWYgKCFkZXNjX2FycmF5KQogCQlyZXR1cm47CiAJZ3Bpb2Rf c2V0X2FycmF5X3ZhbHVlX2NvbXBsZXgoZmFsc2UsIGZhbHNlLCBhcnJheV9zaXplLCBkZXNjX2Fy cmF5LAotCQkJCSAgICAgIHZhbHVlX2JpdG1hcCk7CisJCQkJICAgICAgYXJyYXlfaW5mbywgdmFs dWVfYml0bWFwKTsKIH0KIEVYUE9SVF9TWU1CT0xfR1BMKGdwaW9kX3NldF9hcnJheV92YWx1ZSk7 CiAKQEAgLTM0MjYsMTMgKzM0MzYsMTUgQEAgRVhQT1JUX1NZTUJPTF9HUEwoZ3Bpb2RfZ2V0X3Zh bHVlX2NhbnNsZWVwKTsKICAqLwogaW50IGdwaW9kX2dldF9yYXdfYXJyYXlfdmFsdWVfY2Fuc2xl ZXAodW5zaWduZWQgaW50IGFycmF5X3NpemUsCiAJCQkJICAgICAgIHN0cnVjdCBncGlvX2Rlc2Mg KipkZXNjX2FycmF5LAorCQkJCSAgICAgICBzdHJ1Y3QgZ3Bpb19hcnJheSAqYXJyYXlfaW5mbywK IAkJCQkgICAgICAgdW5zaWduZWQgbG9uZyAqdmFsdWVfYml0bWFwKQogewogCW1pZ2h0X3NsZWVw X2lmKGV4dHJhX2NoZWNrcyk7CiAJaWYgKCFkZXNjX2FycmF5KQogCQlyZXR1cm4gLUVJTlZBTDsK IAlyZXR1cm4gZ3Bpb2RfZ2V0X2FycmF5X3ZhbHVlX2NvbXBsZXgodHJ1ZSwgdHJ1ZSwgYXJyYXlf c2l6ZSwKLQkJCQkJICAgICBkZXNjX2FycmF5LCB2YWx1ZV9iaXRtYXApOworCQkJCQkgICAgIGRl c2NfYXJyYXksIGFycmF5X2luZm8sCisJCQkJCSAgICAgdmFsdWVfYml0bWFwKTsKIH0KIEVYUE9S VF9TWU1CT0xfR1BMKGdwaW9kX2dldF9yYXdfYXJyYXlfdmFsdWVfY2Fuc2xlZXApOwogCkBAIC0z NDQ5LDEzICszNDYxLDE1IEBAIEVYUE9SVF9TWU1CT0xfR1BMKGdwaW9kX2dldF9yYXdfYXJyYXlf dmFsdWVfY2Fuc2xlZXApOwogICovCiBpbnQgZ3Bpb2RfZ2V0X2FycmF5X3ZhbHVlX2NhbnNsZWVw KHVuc2lnbmVkIGludCBhcnJheV9zaXplLAogCQkJCSAgIHN0cnVjdCBncGlvX2Rlc2MgKipkZXNj X2FycmF5LAorCQkJCSAgIHN0cnVjdCBncGlvX2FycmF5ICphcnJheV9pbmZvLAogCQkJCSAgIHVu c2lnbmVkIGxvbmcgKnZhbHVlX2JpdG1hcCkKIHsKIAltaWdodF9zbGVlcF9pZihleHRyYV9jaGVj a3MpOwogCWlmICghZGVzY19hcnJheSkKIAkJcmV0dXJuIC1FSU5WQUw7CiAJcmV0dXJuIGdwaW9k X2dldF9hcnJheV92YWx1ZV9jb21wbGV4KGZhbHNlLCB0cnVlLCBhcnJheV9zaXplLAotCQkJCQkg ICAgIGRlc2NfYXJyYXksIHZhbHVlX2JpdG1hcCk7CisJCQkJCSAgICAgZGVzY19hcnJheSwgYXJy YXlfaW5mbywKKwkJCQkJICAgICB2YWx1ZV9iaXRtYXApOwogfQogRVhQT1JUX1NZTUJPTF9HUEwo Z3Bpb2RfZ2V0X2FycmF5X3ZhbHVlX2NhbnNsZWVwKTsKIApAQCAtMzUwOCwxMyArMzUyMiwxNCBA QCBFWFBPUlRfU1lNQk9MX0dQTChncGlvZF9zZXRfdmFsdWVfY2Fuc2xlZXApOwogICovCiBpbnQg Z3Bpb2Rfc2V0X3Jhd19hcnJheV92YWx1ZV9jYW5zbGVlcCh1bnNpZ25lZCBpbnQgYXJyYXlfc2l6 ZSwKIAkJCQkJc3RydWN0IGdwaW9fZGVzYyAqKmRlc2NfYXJyYXksCisJCQkJCXN0cnVjdCBncGlv X2FycmF5ICphcnJheV9pbmZvLAogCQkJCQl1bnNpZ25lZCBsb25nICp2YWx1ZV9iaXRtYXApCiB7 CiAJbWlnaHRfc2xlZXBfaWYoZXh0cmFfY2hlY2tzKTsKIAlpZiAoIWRlc2NfYXJyYXkpCiAJCXJl dHVybiAtRUlOVkFMOwogCXJldHVybiBncGlvZF9zZXRfYXJyYXlfdmFsdWVfY29tcGxleCh0cnVl LCB0cnVlLCBhcnJheV9zaXplLCBkZXNjX2FycmF5LAotCQkJCSAgICAgIHZhbHVlX2JpdG1hcCk7 CisJCQkJICAgICAgYXJyYXlfaW5mbywgdmFsdWVfYml0bWFwKTsKIH0KIEVYUE9SVF9TWU1CT0xf R1BMKGdwaW9kX3NldF9yYXdfYXJyYXlfdmFsdWVfY2Fuc2xlZXApOwogCkBAIC0zNTQ4LDEzICsz NTYzLDE0IEBAIHZvaWQgZ3Bpb2RfYWRkX2xvb2t1cF90YWJsZXMoc3RydWN0IGdwaW9kX2xvb2t1 cF90YWJsZSAqKnRhYmxlcywgc2l6ZV90IG4pCiAgKi8KIHZvaWQgZ3Bpb2Rfc2V0X2FycmF5X3Zh bHVlX2NhbnNsZWVwKHVuc2lnbmVkIGludCBhcnJheV9zaXplLAogCQkJCSAgICBzdHJ1Y3QgZ3Bp b19kZXNjICoqZGVzY19hcnJheSwKKwkJCQkgICAgc3RydWN0IGdwaW9fYXJyYXkgKmFycmF5X2lu Zm8sCiAJCQkJICAgIHVuc2lnbmVkIGxvbmcgKnZhbHVlX2JpdG1hcCkKIHsKIAltaWdodF9zbGVl cF9pZihleHRyYV9jaGVja3MpOwogCWlmICghZGVzY19hcnJheSkKIAkJcmV0dXJuOwogCWdwaW9k X3NldF9hcnJheV92YWx1ZV9jb21wbGV4KGZhbHNlLCB0cnVlLCBhcnJheV9zaXplLCBkZXNjX2Fy cmF5LAotCQkJCSAgICAgIHZhbHVlX2JpdG1hcCk7CisJCQkJICAgICAgYXJyYXlfaW5mbywgdmFs dWVfYml0bWFwKTsKIH0KIEVYUE9SVF9TWU1CT0xfR1BMKGdwaW9kX3NldF9hcnJheV92YWx1ZV9j YW5zbGVlcCk7CiAKZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3Bpby9ncGlvbGliLmggYi9kcml2ZXJz L2dwaW8vZ3Bpb2xpYi5oCmluZGV4IGI2MDkwNWQ1NThiMS4uYjY1Y2E4OTZiMjRkIDEwMDY0NAot LS0gYS9kcml2ZXJzL2dwaW8vZ3Bpb2xpYi5oCisrKyBiL2RyaXZlcnMvZ3Bpby9ncGlvbGliLmgK QEAgLTE5NiwxMCArMTk2LDEyIEBAIHN0cnVjdCBncGlvX2Rlc2MgKmdwaW9jaGlwX2dldF9kZXNj KHN0cnVjdCBncGlvX2NoaXAgKmNoaXAsIHUxNiBod251bSk7CiBpbnQgZ3Bpb2RfZ2V0X2FycmF5 X3ZhbHVlX2NvbXBsZXgoYm9vbCByYXcsIGJvb2wgY2FuX3NsZWVwLAogCQkJCSAgdW5zaWduZWQg aW50IGFycmF5X3NpemUsCiAJCQkJICBzdHJ1Y3QgZ3Bpb19kZXNjICoqZGVzY19hcnJheSwKKwkJ CQkgIHN0cnVjdCBncGlvX2FycmF5ICphcnJheV9pbmZvLAogCQkJCSAgdW5zaWduZWQgbG9uZyAq dmFsdWVfYml0bWFwKTsKIGludCBncGlvZF9zZXRfYXJyYXlfdmFsdWVfY29tcGxleChib29sIHJh dywgYm9vbCBjYW5fc2xlZXAsCiAJCQkJICAgdW5zaWduZWQgaW50IGFycmF5X3NpemUsCiAJCQkJ ICAgc3RydWN0IGdwaW9fZGVzYyAqKmRlc2NfYXJyYXksCisJCQkJICAgc3RydWN0IGdwaW9fYXJy YXkgKmFycmF5X2luZm8sCiAJCQkJICAgdW5zaWduZWQgbG9uZyAqdmFsdWVfYml0bWFwKTsKIAog LyogVGhpcyBpcyBqdXN0IHBhc3NlZCBiZXR3ZWVuIGdwaW9saWIgYW5kIGRldnJlcyAqLwpkaWZm IC0tZ2l0IGEvZHJpdmVycy9pMmMvbXV4ZXMvaTJjLW11eC1ncGlvLmMgYi9kcml2ZXJzL2kyYy9t dXhlcy9pMmMtbXV4LWdwaW8uYwppbmRleCAwNzE3Y2ZiNTY3MzIuLmM2ZTFjNzc3NmE1NiAxMDA2 NDQKLS0tIGEvZHJpdmVycy9pMmMvbXV4ZXMvaTJjLW11eC1ncGlvLmMKKysrIGIvZHJpdmVycy9p MmMvbXV4ZXMvaTJjLW11eC1ncGlvLmMKQEAgLTMwLDcgKzMwLDggQEAgc3RhdGljIHZvaWQgaTJj X211eF9ncGlvX3NldChjb25zdCBzdHJ1Y3QgZ3Bpb211eCAqbXV4LCB1bnNpZ25lZCB2YWwpCiAK IAkqdmFsdWVzID0gdmFsOwogCi0JZ3Bpb2Rfc2V0X2FycmF5X3ZhbHVlX2NhbnNsZWVwKG11eC0+ ZGF0YS5uX2dwaW9zLCBtdXgtPmdwaW9zLCB2YWx1ZXMpOworCWdwaW9kX3NldF9hcnJheV92YWx1 ZV9jYW5zbGVlcChtdXgtPmRhdGEubl9ncGlvcywgbXV4LT5ncGlvcywgTlVMTCwKKwkJCQkgICAg ICAgdmFsdWVzKTsKIH0KIAogc3RhdGljIGludCBpMmNfbXV4X2dwaW9fc2VsZWN0KHN0cnVjdCBp MmNfbXV4X2NvcmUgKm11eGMsIHUzMiBjaGFuKQpkaWZmIC0tZ2l0IGEvZHJpdmVycy9tbWMvY29y ZS9wd3JzZXFfc2ltcGxlLmMgYi9kcml2ZXJzL21tYy9jb3JlL3B3cnNlcV9zaW1wbGUuYwppbmRl eCA1YWQ3NjRjODhiNTAuLmExNzI1MmY1MTQxOCAxMDA2NDQKLS0tIGEvZHJpdmVycy9tbWMvY29y ZS9wd3JzZXFfc2ltcGxlLmMKKysrIGIvZHJpdmVycy9tbWMvY29yZS9wd3JzZXFfc2ltcGxlLmMK QEAgLTQ2LDcgKzQ2LDcgQEAgc3RhdGljIHZvaWQgbW1jX3B3cnNlcV9zaW1wbGVfc2V0X2dwaW9z X3ZhbHVlKHN0cnVjdCBtbWNfcHdyc2VxX3NpbXBsZSAqcHdyc2VxLAogCQkqdmFsdWVzID0gdmFs dWU7CiAKIAkJZ3Bpb2Rfc2V0X2FycmF5X3ZhbHVlX2NhbnNsZWVwKG52YWx1ZXMsIHJlc2V0X2dw aW9zLT5kZXNjLAotCQkJCQkgICAgICAgdmFsdWVzKTsKKwkJCQkJICAgICAgIHJlc2V0X2dwaW9z LT5pbmZvLCB2YWx1ZXMpOwogCX0KIH0KIApkaWZmIC0tZ2l0IGEvZHJpdmVycy9tdXgvZ3Bpby5j IGIvZHJpdmVycy9tdXgvZ3Bpby5jCmluZGV4IDFiNmI0Y2MyMmEyYy4uNGY1OGEzMTk4YzRlIDEw MDY0NAotLS0gYS9kcml2ZXJzL211eC9ncGlvLmMKKysrIGIvZHJpdmVycy9tdXgvZ3Bpby5jCkBA IC0yNyw3ICsyNyw4IEBAIHN0YXRpYyBpbnQgbXV4X2dwaW9fc2V0KHN0cnVjdCBtdXhfY29udHJv bCAqbXV4LCBpbnQgc3RhdGUpCiAJKnZhbHVlcyA9IHN0YXRlOwogCiAJZ3Bpb2Rfc2V0X2FycmF5 X3ZhbHVlX2NhbnNsZWVwKG11eF9ncGlvLT5ncGlvcy0+bmRlc2NzLAotCQkJCSAgICAgICBtdXhf Z3Bpby0+Z3Bpb3MtPmRlc2MsIHZhbHVlcyk7CisJCQkJICAgICAgIG11eF9ncGlvLT5ncGlvcy0+ ZGVzYywKKwkJCQkgICAgICAgbXV4X2dwaW8tPmdwaW9zLT5pbmZvLCB2YWx1ZXMpOwogCiAJcmV0 dXJuIDA7CiB9CmRpZmYgLS1naXQgYS9kcml2ZXJzL25ldC9waHkvbWRpby1tdXgtZ3Bpby5jIGIv ZHJpdmVycy9uZXQvcGh5L21kaW8tbXV4LWdwaW8uYwppbmRleCBlYjhjNTZiODNjNzAuLjdkOGJl YTIxZjA5OSAxMDA2NDQKLS0tIGEvZHJpdmVycy9uZXQvcGh5L21kaW8tbXV4LWdwaW8uYworKysg Yi9kcml2ZXJzL25ldC9waHkvbWRpby1tdXgtZ3Bpby5jCkBAIC0zNCw3ICszNCw3IEBAIHN0YXRp YyBpbnQgbWRpb19tdXhfZ3Bpb19zd2l0Y2hfZm4oaW50IGN1cnJlbnRfY2hpbGQsIGludCBkZXNp cmVkX2NoaWxkLAogCSp2YWx1ZXMgPSBkZXNpcmVkX2NoaWxkOwogCiAJZ3Bpb2Rfc2V0X2FycmF5 X3ZhbHVlX2NhbnNsZWVwKHMtPmdwaW9zLT5uZGVzY3MsIHMtPmdwaW9zLT5kZXNjLAotCQkJCSAg ICAgICB2YWx1ZXMpOworCQkJCSAgICAgICBzLT5ncGlvcy0+aW5mbywgdmFsdWVzKTsKIAogCXJl dHVybiAwOwogfQpkaWZmIC0tZ2l0IGEvZHJpdmVycy9wY21jaWEvc29jX2NvbW1vbi5jIGIvZHJp dmVycy9wY21jaWEvc29jX2NvbW1vbi5jCmluZGV4IDM4OGRiZGM0NjEyOS4uODQ0N2VlZWFmM2Zl IDEwMDY0NAotLS0gYS9kcml2ZXJzL3BjbWNpYS9zb2NfY29tbW9uLmMKKysrIGIvZHJpdmVycy9w Y21jaWEvc29jX2NvbW1vbi5jCkBAIC0zNjUsNyArMzY1LDcgQEAgc3RhdGljIGludCBzb2NfY29t bW9uX3BjbWNpYV9jb25maWdfc2t0KAogCQl9CiAKIAkJaWYgKG4pCi0JCQlncGlvZF9zZXRfYXJy YXlfdmFsdWVfY2Fuc2xlZXAobiwgZGVzY3MsIHZhbHVlcyk7CisJCQlncGlvZF9zZXRfYXJyYXlf dmFsdWVfY2Fuc2xlZXAobiwgZGVzY3MsIE5VTEwsIHZhbHVlcyk7CiAKIAkJLyoKIAkJICogVGhp cyByZWFsbHkgbmVlZHMgYSBiZXR0ZXIgc29sdXRpb24uICBUaGUgSVJRCmRpZmYgLS1naXQgYS9k cml2ZXJzL3BoeS9tb3Rvcm9sYS9waHktbWFwcGhvbmUtbWRtNjYwMC5jIGIvZHJpdmVycy9waHkv bW90b3JvbGEvcGh5LW1hcHBob25lLW1kbTY2MDAuYwppbmRleCA0ZGU3ZjQ1Nzc0MzMuLjA4ZTcx YzdhZTE5OSAxMDA2NDQKLS0tIGEvZHJpdmVycy9waHkvbW90b3JvbGEvcGh5LW1hcHBob25lLW1k bTY2MDAuYworKysgYi9kcml2ZXJzL3BoeS9tb3Rvcm9sYS9waHktbWFwcGhvbmUtbWRtNjYwMC5j CkBAIC0xNjIsNyArMTYyLDggQEAgc3RhdGljIHZvaWQgcGh5X21kbTY2MDBfY21kKHN0cnVjdCBw aHlfbWRtNjYwMCAqZGRhdGEsIGludCB2YWwpCiAJKnZhbHVlcyA9IHZhbDsKIAogCWdwaW9kX3Nl dF9hcnJheV92YWx1ZV9jYW5zbGVlcChQSFlfTURNNjYwMF9OUl9DTURfTElORVMsCi0JCQkJICAg ICAgIGRkYXRhLT5jbWRfZ3Bpb3MtPmRlc2MsIHZhbHVlcyk7CisJCQkJICAgICAgIGRkYXRhLT5j bWRfZ3Bpb3MtPmRlc2MsCisJCQkJICAgICAgIGRkYXRhLT5jbWRfZ3Bpb3MtPmluZm8sIHZhbHVl cyk7CiB9CiAKIC8qKgpAQCAtMTgxLDYgKzE4Miw3IEBAIHN0YXRpYyB2b2lkIHBoeV9tZG02NjAw X3N0YXR1cyhzdHJ1Y3Qgd29ya19zdHJ1Y3QgKndvcmspCiAKIAllcnJvciA9IGdwaW9kX2dldF9h cnJheV92YWx1ZV9jYW5zbGVlcChQSFlfTURNNjYwMF9OUl9TVEFUVVNfTElORVMsCiAJCQkJCSAg ICAgICBkZGF0YS0+c3RhdHVzX2dwaW9zLT5kZXNjLAorCQkJCQkgICAgICAgZGRhdGEtPnN0YXR1 c19ncGlvcy0+aW5mbywKIAkJCQkJICAgICAgIHZhbHVlcyk7CiAJaWYgKGVycm9yKQogCQlyZXR1 cm47CmRpZmYgLS1naXQgYS9kcml2ZXJzL3N0YWdpbmcvaWlvL2FkYy9hZDc2MDYuYyBiL2RyaXZl cnMvc3RhZ2luZy9paW8vYWRjL2FkNzYwNi5jCmluZGV4IDA1M2M5YjdmMTA4NC4uZDMyZGJhMjNl NzgyIDEwMDY0NAotLS0gYS9kcml2ZXJzL3N0YWdpbmcvaWlvL2FkYy9hZDc2MDYuYworKysgYi9k cml2ZXJzL3N0YWdpbmcvaWlvL2FkYy9hZDc2MDYuYwpAQCAtMjMwLDcgKzIzMCw4IEBAIHN0YXRp YyBpbnQgYWQ3NjA2X3dyaXRlX3JhdyhzdHJ1Y3QgaWlvX2RldiAqaW5kaW9fZGV2LAogCQkqdmFs dWVzID0gcmV0OwogCiAJCW11dGV4X2xvY2soJnN0LT5sb2NrKTsKLQkJZ3Bpb2Rfc2V0X2FycmF5 X3ZhbHVlKDMsIHN0LT5ncGlvX29zLT5kZXNjLCB2YWx1ZXMpOworCQlncGlvZF9zZXRfYXJyYXlf dmFsdWUoMywgc3QtPmdwaW9fb3MtPmRlc2MsIHN0LT5ncGlvX29zLT5pbmZvLAorCQkJCSAgICAg IHZhbHVlcyk7CiAJCXN0LT5vdmVyc2FtcGxpbmcgPSB2YWw7CiAJCW11dGV4X3VubG9jaygmc3Qt PmxvY2spOwogCmRpZmYgLS1naXQgYS9kcml2ZXJzL3R0eS9zZXJpYWwvc2VyaWFsX21jdHJsX2dw aW8uYyBiL2RyaXZlcnMvdHR5L3NlcmlhbC9zZXJpYWxfbWN0cmxfZ3Bpby5jCmluZGV4IDMwNDQ0 ZmQ2Y2YzMi4uZDc5MzRjYTU1ZTJmIDEwMDY0NAotLS0gYS9kcml2ZXJzL3R0eS9zZXJpYWwvc2Vy aWFsX21jdHJsX2dwaW8uYworKysgYi9kcml2ZXJzL3R0eS9zZXJpYWwvc2VyaWFsX21jdHJsX2dw aW8uYwpAQCAtNTMsNyArNTMsNyBAQCB2b2lkIG1jdHJsX2dwaW9fc2V0KHN0cnVjdCBtY3RybF9n cGlvcyAqZ3Bpb3MsIHVuc2lnbmVkIGludCBtY3RybCkKIAkJCQkgICAgICEhKG1jdHJsICYgbWN0 cmxfZ3Bpb3NfZGVzY1tpXS5tY3RybCkpOwogCQkJY291bnQrKzsKIAkJfQotCWdwaW9kX3NldF9h cnJheV92YWx1ZShjb3VudCwgZGVzY19hcnJheSwgdmFsdWVzKTsKKwlncGlvZF9zZXRfYXJyYXlf dmFsdWUoY291bnQsIGRlc2NfYXJyYXksIE5VTEwsIHZhbHVlcyk7CiB9CiBFWFBPUlRfU1lNQk9M X0dQTChtY3RybF9ncGlvX3NldCk7CiAKZGlmZiAtLWdpdCBhL2luY2x1ZGUvbGludXgvZ3Bpby9j b25zdW1lci5oIGIvaW5jbHVkZS9saW51eC9ncGlvL2NvbnN1bWVyLmgKaW5kZXggOGRlZGUzZTg4 NmFmLi5iZjAzN2ViZTJlZDggMTAwNjQ0Ci0tLSBhL2luY2x1ZGUvbGludXgvZ3Bpby9jb25zdW1l ci5oCisrKyBiL2luY2x1ZGUvbGludXgvZ3Bpby9jb25zdW1lci5oCkBAIC0xMTQsMzYgKzExNCw0 NCBAQCBpbnQgZ3Bpb2RfZGlyZWN0aW9uX291dHB1dF9yYXcoc3RydWN0IGdwaW9fZGVzYyAqZGVz YywgaW50IHZhbHVlKTsKIGludCBncGlvZF9nZXRfdmFsdWUoY29uc3Qgc3RydWN0IGdwaW9fZGVz YyAqZGVzYyk7CiBpbnQgZ3Bpb2RfZ2V0X2FycmF5X3ZhbHVlKHVuc2lnbmVkIGludCBhcnJheV9z aXplLAogCQkJICBzdHJ1Y3QgZ3Bpb19kZXNjICoqZGVzY19hcnJheSwKKwkJCSAgc3RydWN0IGdw aW9fYXJyYXkgKmFycmF5X2luZm8sCiAJCQkgIHVuc2lnbmVkIGxvbmcgKnZhbHVlX2JpdG1hcCk7 CiB2b2lkIGdwaW9kX3NldF92YWx1ZShzdHJ1Y3QgZ3Bpb19kZXNjICpkZXNjLCBpbnQgdmFsdWUp Owogdm9pZCBncGlvZF9zZXRfYXJyYXlfdmFsdWUodW5zaWduZWQgaW50IGFycmF5X3NpemUsCiAJ CQkgICBzdHJ1Y3QgZ3Bpb19kZXNjICoqZGVzY19hcnJheSwKKwkJCSAgIHN0cnVjdCBncGlvX2Fy cmF5ICphcnJheV9pbmZvLAogCQkJICAgdW5zaWduZWQgbG9uZyAqdmFsdWVfYml0bWFwKTsKIGlu dCBncGlvZF9nZXRfcmF3X3ZhbHVlKGNvbnN0IHN0cnVjdCBncGlvX2Rlc2MgKmRlc2MpOwogaW50 IGdwaW9kX2dldF9yYXdfYXJyYXlfdmFsdWUodW5zaWduZWQgaW50IGFycmF5X3NpemUsCiAJCQkg ICAgICBzdHJ1Y3QgZ3Bpb19kZXNjICoqZGVzY19hcnJheSwKKwkJCSAgICAgIHN0cnVjdCBncGlv X2FycmF5ICphcnJheV9pbmZvLAogCQkJICAgICAgdW5zaWduZWQgbG9uZyAqdmFsdWVfYml0bWFw KTsKIHZvaWQgZ3Bpb2Rfc2V0X3Jhd192YWx1ZShzdHJ1Y3QgZ3Bpb19kZXNjICpkZXNjLCBpbnQg dmFsdWUpOwogaW50IGdwaW9kX3NldF9yYXdfYXJyYXlfdmFsdWUodW5zaWduZWQgaW50IGFycmF5 X3NpemUsCiAJCQkgICAgICAgc3RydWN0IGdwaW9fZGVzYyAqKmRlc2NfYXJyYXksCisJCQkgICAg ICAgc3RydWN0IGdwaW9fYXJyYXkgKmFycmF5X2luZm8sCiAJCQkgICAgICAgdW5zaWduZWQgbG9u ZyAqdmFsdWVfYml0bWFwKTsKIAogLyogVmFsdWUgZ2V0L3NldCBmcm9tIHNsZWVwaW5nIGNvbnRl eHQgKi8KIGludCBncGlvZF9nZXRfdmFsdWVfY2Fuc2xlZXAoY29uc3Qgc3RydWN0IGdwaW9fZGVz YyAqZGVzYyk7CiBpbnQgZ3Bpb2RfZ2V0X2FycmF5X3ZhbHVlX2NhbnNsZWVwKHVuc2lnbmVkIGlu dCBhcnJheV9zaXplLAogCQkJCSAgIHN0cnVjdCBncGlvX2Rlc2MgKipkZXNjX2FycmF5LAorCQkJ CSAgIHN0cnVjdCBncGlvX2FycmF5ICphcnJheV9pbmZvLAogCQkJCSAgIHVuc2lnbmVkIGxvbmcg KnZhbHVlX2JpdG1hcCk7CiB2b2lkIGdwaW9kX3NldF92YWx1ZV9jYW5zbGVlcChzdHJ1Y3QgZ3Bp b19kZXNjICpkZXNjLCBpbnQgdmFsdWUpOwogdm9pZCBncGlvZF9zZXRfYXJyYXlfdmFsdWVfY2Fu c2xlZXAodW5zaWduZWQgaW50IGFycmF5X3NpemUsCiAJCQkJICAgIHN0cnVjdCBncGlvX2Rlc2Mg KipkZXNjX2FycmF5LAorCQkJCSAgICBzdHJ1Y3QgZ3Bpb19hcnJheSAqYXJyYXlfaW5mbywKIAkJ CQkgICAgdW5zaWduZWQgbG9uZyAqdmFsdWVfYml0bWFwKTsKIGludCBncGlvZF9nZXRfcmF3X3Zh bHVlX2NhbnNsZWVwKGNvbnN0IHN0cnVjdCBncGlvX2Rlc2MgKmRlc2MpOwogaW50IGdwaW9kX2dl dF9yYXdfYXJyYXlfdmFsdWVfY2Fuc2xlZXAodW5zaWduZWQgaW50IGFycmF5X3NpemUsCiAJCQkJ ICAgICAgIHN0cnVjdCBncGlvX2Rlc2MgKipkZXNjX2FycmF5LAorCQkJCSAgICAgICBzdHJ1Y3Qg Z3Bpb19hcnJheSAqYXJyYXlfaW5mbywKIAkJCQkgICAgICAgdW5zaWduZWQgbG9uZyAqdmFsdWVf Yml0bWFwKTsKIHZvaWQgZ3Bpb2Rfc2V0X3Jhd192YWx1ZV9jYW5zbGVlcChzdHJ1Y3QgZ3Bpb19k ZXNjICpkZXNjLCBpbnQgdmFsdWUpOwogaW50IGdwaW9kX3NldF9yYXdfYXJyYXlfdmFsdWVfY2Fu c2xlZXAodW5zaWduZWQgaW50IGFycmF5X3NpemUsCiAJCQkJCXN0cnVjdCBncGlvX2Rlc2MgKipk ZXNjX2FycmF5LAorCQkJCQlzdHJ1Y3QgZ3Bpb19hcnJheSAqYXJyYXlfaW5mbywKIAkJCQkJdW5z aWduZWQgbG9uZyAqdmFsdWVfYml0bWFwKTsKIAogaW50IGdwaW9kX3NldF9kZWJvdW5jZShzdHJ1 Y3QgZ3Bpb19kZXNjICpkZXNjLCB1bnNpZ25lZCBkZWJvdW5jZSk7Ci0tIAoyLjE2LjQKCl9fX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fCmRldmVsIG1haWxpbmcg bGlzdApkZXZlbEBsaW51eGRyaXZlcnByb2plY3Qub3JnCmh0dHA6Ly9kcml2ZXJkZXYubGludXhk cml2ZXJwcm9qZWN0Lm9yZy9tYWlsbWFuL2xpc3RpbmZvL2RyaXZlcmRldi1kZXZlbAo=